diff --git a/.github/workflows/docs-on-pr.yml b/.github/workflows/docs-on-pr.yml index 42bc8c982..c32372d59 100644 --- a/.github/workflows/docs-on-pr.yml +++ b/.github/workflows/docs-on-pr.yml @@ -16,6 +16,7 @@ jobs: - name: Install Poetry uses: snok/install-poetry@v1 with: + version: 1.4.0 # TODO: remove after poetry fix virtualenvs-create: true virtualenvs-in-project: true - name: Load cached venv diff --git a/.github/workflows/docs-unstable.yml b/.github/workflows/docs-unstable.yml index 5dbbe59e5..11fb090da 100644 --- a/.github/workflows/docs-unstable.yml +++ b/.github/workflows/docs-unstable.yml @@ -17,6 +17,7 @@ jobs: - name: Install Poetry uses: snok/install-poetry@v1 with: + version: 1.4.0 # TODO: remove after poetry fix virtualenvs-create: true virtualenvs-in-project: true - name: Load cached venv diff --git a/.github/workflows/notebooks.yml b/.github/workflows/notebooks.yml index 15cb3ba4e..83ba01fce 100644 --- a/.github/workflows/notebooks.yml +++ b/.github/workflows/notebooks.yml @@ -26,6 +26,7 @@ jobs: - name: Install Poetry uses: snok/install-poetry@v1 with: + version: 1.4.0 # TODO: remove after poetry fix virtualenvs-create: true virtualenvs-in-project: true - name: Install dependencies diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 1b4f40d09..d735cf455 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -21,7 +21,7 @@ jobs: - name: Install Dependencies run: | - pip install poetry + pip install poetry==1.4.0 # TODO: remove after poetry fix poetry --version poetry config virtualenvs.in-project true poetry install -E style --no-root @@ -48,6 +48,7 @@ jobs: - name: Install Poetry uses: snok/install-poetry@v1 with: + version: 1.4.0 # TODO: remove after poetry fix virtualenvs-create: true virtualenvs-in-project: true @@ -86,6 +87,7 @@ jobs: - name: Install Poetry uses: snok/install-poetry@v1 with: + version: 1.4.0 # TODO: remove after poetry fix virtualenvs-create: true virtualenvs-in-project: true @@ -123,6 +125,7 @@ jobs: - name: Install Poetry uses: snok/install-poetry@v1 with: + version: 1.4.0 # TODO: remove after poetry fix virtualenvs-create: true virtualenvs-in-project: true @@ -160,6 +163,7 @@ jobs: - name: Install Poetry uses: snok/install-poetry@v1 with: + version: 1.4.0 # TODO: remove after poetry fix virtualenvs-create: true virtualenvs-in-project: true @@ -199,6 +203,7 @@ jobs: - name: Install Poetry uses: snok/install-poetry@v1 with: + version: 1.4.0 # TODO: remove after poetry fix virtualenvs-create: true virtualenvs-in-project: true diff --git a/CHANGELOG.md b/CHANGELOG.md index e5a23c23e..4e67592fc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,18 +7,32 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## Unreleased ### Added -- +- Add `refit` parameter into `backtest` ([#1159](https://github.com/tinkoff-ai/etna/pull/1159)) +- Add `stride` parameter into `backtest` ([#1165](https://github.com/tinkoff-ai/etna/pull/1165)) +- Add optional parameter `ts` into `forecast` method of pipelines ([#1071](https://github.com/tinkoff-ai/etna/pull/1071)) +- Add tests on `transform` method of transforms on subset of segments, on new segments, on future with gap ([#1094](https://github.com/tinkoff-ai/etna/pull/1094)) +- Add tests on `inverse_transform` method of transforms on subset of segments, on new segments, on future with gap ([#1127](https://github.com/tinkoff-ai/etna/pull/1127)) - - - - ### Changed -- +- Add more scenarios into tests for models ([#1082](https://github.com/tinkoff-ai/etna/pull/1082)) +- Decouple `SeasonalMovingAverageModel` from `PerSegmentModelMixin` ([#1132](https://github.com/tinkoff-ai/etna/pull/1132)) +- Decouple `DeadlineMovingAverageModel` from `PerSegmentModelMixin` ([#1140](https://github.com/tinkoff-ai/etna/pull/1140)) - - - ### Fixed -- +- Fix inference tests on new segments for `DeepARModel` and `TFTModel` ([#1109](https://github.com/tinkoff-ai/etna/pull/1109)) +- Fix alignment during forecasting in new NNs, add validation of context size during forecasting in new NNs, add validation of batch in `MLPNet` ([#1108](https://github.com/tinkoff-ai/etna/pull/1108)) +- Fix `MeanSegmentEncoderTransform` to work with subset of segments and raise error on new segments ([#1104](https://github.com/tinkoff-ai/etna/pull/1104)) +- Fix outliers transforms on future with gap ([#1147](https://github.com/tinkoff-ai/etna/pull/1147)) +- Fix `SegmentEncoderTransform` to work with subset of segments and raise error on new segments ([#1103](https://github.com/tinkoff-ai/etna/pull/1103)) +- Fix `SklearnTransform` in per-segment mode to work on subset of segments and raise error on new segments ([#1107](https://github.com/tinkoff-ai/etna/pull/1107)) +- Fix `OutliersTransform` and its children to raise error on new segments ([#1139](https://github.com/tinkoff-ai/etna/pull/1139)) +- Fix `DifferencingTransform` to raise error on new segments during `transform` and `inverse_transform` in inplace mode ([#1141](https://github.com/tinkoff-ai/etna/pull/1141)) +- Teach `DifferencingTransform` to `inverse_transform` with NaNs ([#1155](https://github.com/tinkoff-ai/etna/pull/1155)) - - - diff --git a/docs/source/tutorials.rst b/docs/source/tutorials.rst index a1d1baf57..9744c9b08 100644 --- a/docs/source/tutorials.rst +++ b/docs/source/tutorials.rst @@ -17,3 +17,4 @@ Tutorials tutorials/NN_examples tutorials/classification tutorials/hierarchical_pipeline + tutorials/inference diff --git a/etna/ensembles/direct_ensemble.py b/etna/ensembles/direct_ensemble.py index 4b20c7e50..f5203ffb6 100644 --- a/etna/ensembles/direct_ensemble.py +++ b/etna/ensembles/direct_ensemble.py @@ -122,17 +122,14 @@ def _merge(self, forecasts: List[TSDataset]) -> TSDataset: forecast_dataset = TSDataset(df=forecast_df, freq=forecasts[0].freq) return forecast_dataset - def _forecast(self) -> TSDataset: + def _forecast(self, ts: TSDataset) -> TSDataset: """Make predictions. In each point in the future, forecast of the ensemble is forecast of base pipeline with the shortest horizon, which covers this point. """ - if self.ts is None: - raise ValueError("Something went wrong, ts is None!") - forecasts = Parallel(n_jobs=self.n_jobs, backend="multiprocessing", verbose=11)( - delayed(self._forecast_pipeline)(pipeline=pipeline) for pipeline in self.pipelines + delayed(self._forecast_pipeline)(pipeline=pipeline, ts=ts) for pipeline in self.pipelines ) forecast = self._merge(forecasts=forecasts) return forecast diff --git a/etna/ensembles/mixins.py b/etna/ensembles/mixins.py index 256ddd602..81e8f02c9 100644 --- a/etna/ensembles/mixins.py +++ b/etna/ensembles/mixins.py @@ -41,10 +41,10 @@ def _fit_pipeline(pipeline: BasePipeline, ts: TSDataset) -> BasePipeline: return pipeline @staticmethod - def _forecast_pipeline(pipeline: BasePipeline) -> TSDataset: + def _forecast_pipeline(pipeline: BasePipeline, ts: TSDataset) -> TSDataset: """Make forecast with given pipeline.""" tslogger.log(msg=f"Start forecasting with {pipeline}.") - forecast = pipeline.forecast() + forecast = pipeline.forecast(ts=ts) tslogger.log(msg=f"Forecast is done with {pipeline}.") return forecast diff --git a/etna/ensembles/stacking_ensemble.py b/etna/ensembles/stacking_ensemble.py index db5fd31e5..8d9e98033 100644 --- a/etna/ensembles/stacking_ensemble.py +++ b/etna/ensembles/stacking_ensemble.py @@ -8,7 +8,6 @@ from typing import Set from typing import Tuple from typing import Union -from typing import cast import numpy as np import pandas as pd @@ -160,7 +159,7 @@ def fit(self, ts: TSDataset) -> "StackingEnsemble": # Fit the final model self.filtered_features_for_final_model = self._filter_features_to_use(forecasts) - x, y = self._make_features(forecasts=forecasts, train=True) + x, y = self._make_features(ts=self.ts, forecasts=forecasts, train=True) self.final_model.fit(x, y) # Fit the base models @@ -170,12 +169,9 @@ def fit(self, ts: TSDataset) -> "StackingEnsemble": return self def _make_features( - self, forecasts: List[TSDataset], train: bool = False + self, ts: TSDataset, forecasts: List[TSDataset], train: bool = False ) -> Tuple[pd.DataFrame, Optional[pd.Series]]: """Prepare features for the ``final_model``.""" - if self.ts is None: - raise ValueError("StackingEnsemble is not fitted! Fit the StackingEnsemble before calling forecast method.") - # Stack targets from the forecasts targets = [ forecast[:, :, "target"].rename({"target": f"regressor_target_{i}"}, axis=1) @@ -201,29 +197,25 @@ def _make_features( features_df = pd.concat([features, targets], axis=1) # Flatten the features to fit the sklearn interface - x = pd.concat([features_df.loc[:, segment] for segment in self.ts.segments], axis=0) + x = pd.concat([features_df.loc[:, segment] for segment in ts.segments], axis=0) if train: y = pd.concat( - [ - self.ts[forecasts[0].index.min() : forecasts[0].index.max(), segment, "target"] - for segment in self.ts.segments - ], + [ts[forecasts[0].index.min() : forecasts[0].index.max(), segment, "target"] for segment in ts.segments], axis=0, ) return x, y else: return x, None - def _process_forecasts(self, forecasts: List[TSDataset]) -> TSDataset: - x, _ = self._make_features(forecasts=forecasts, train=False) - self.ts = cast(TSDataset, self.ts) + def _process_forecasts(self, ts: TSDataset, forecasts: List[TSDataset]) -> TSDataset: + x, _ = self._make_features(ts=ts, forecasts=forecasts, train=False) y = self.final_model.predict(x) num_segments = len(forecasts[0].segments) y = y.reshape(num_segments, -1).T num_timestamps = y.shape[0] # Format the forecast into TSDataset - segment_col = [segment for segment in self.ts.segments for _ in range(num_timestamps)] + segment_col = [segment for segment in ts.segments for _ in range(num_timestamps)] x.loc[:, "segment"] = segment_col x.loc[:, "timestamp"] = x.index.values df_exog = TSDataset.to_dataset(x) @@ -231,21 +223,19 @@ def _process_forecasts(self, forecasts: List[TSDataset]) -> TSDataset: df = forecasts[0][:, :, "target"].copy() df.loc[pd.IndexSlice[:], pd.IndexSlice[:, "target"]] = np.NAN - result = TSDataset(df=df, freq=self.ts.freq, df_exog=df_exog) + result = TSDataset(df=df, freq=ts.freq, df_exog=df_exog) result.loc[pd.IndexSlice[:], pd.IndexSlice[:, "target"]] = y return result - def _forecast(self) -> TSDataset: + def _forecast(self, ts: TSDataset) -> TSDataset: """Make predictions. Compute the combination of pipelines' forecasts using ``final_model`` """ - if self.ts is None: - raise ValueError("Something went wrong, ts is None!") forecasts = Parallel(n_jobs=self.n_jobs, **self.joblib_params)( - delayed(self._forecast_pipeline)(pipeline=pipeline) for pipeline in self.pipelines + delayed(self._forecast_pipeline)(pipeline=pipeline, ts=ts) for pipeline in self.pipelines ) - forecast = self._process_forecasts(forecasts=forecasts) + forecast = self._process_forecasts(ts=ts, forecasts=forecasts) return forecast def _predict( @@ -265,5 +255,5 @@ def _predict( ) for pipeline in self.pipelines ) - prediction = self._process_forecasts(forecasts=predictions) + prediction = self._process_forecasts(ts=ts, forecasts=predictions) return prediction diff --git a/etna/ensembles/voting_ensemble.py b/etna/ensembles/voting_ensemble.py index effc1edfa..eb42c4219 100644 --- a/etna/ensembles/voting_ensemble.py +++ b/etna/ensembles/voting_ensemble.py @@ -5,7 +5,6 @@ from typing import Optional from typing import Sequence from typing import Union -from typing import cast import pandas as pd from joblib import Parallel @@ -199,16 +198,13 @@ def _vote(self, forecasts: List[TSDataset]) -> TSDataset: forecast_dataset = TSDataset(df=forecast_df, freq=forecasts[0].freq) return forecast_dataset - def _forecast(self) -> TSDataset: + def _forecast(self, ts: TSDataset) -> TSDataset: """Make predictions. Compute weighted average of pipelines' forecasts """ - if self.ts is None: - raise ValueError("Something went wrong, ts is None!") - forecasts = Parallel(n_jobs=self.n_jobs, backend="multiprocessing", verbose=11)( - delayed(self._forecast_pipeline)(pipeline=pipeline) for pipeline in self.pipelines + delayed(self._forecast_pipeline)(pipeline=pipeline, ts=ts) for pipeline in self.pipelines ) forecast = self._vote(forecasts=forecasts) return forecast @@ -224,7 +220,6 @@ def _predict( if prediction_interval: raise NotImplementedError(f"Ensemble {self.__class__.__name__} doesn't support prediction intervals!") - self.ts = cast(TSDataset, self.ts) predictions = Parallel(n_jobs=self.n_jobs, backend="multiprocessing", verbose=11)( delayed(self._predict_pipeline)( ts=ts, pipeline=pipeline, start_timestamp=start_timestamp, end_timestamp=end_timestamp diff --git a/etna/models/base.py b/etna/models/base.py index abfa20b4d..cf307de53 100644 --- a/etna/models/base.py +++ b/etna/models/base.py @@ -622,6 +622,12 @@ def forecast(self, ts: "TSDataset", prediction_size: int) -> "TSDataset": : Dataset with predictions """ + expected_length = prediction_size + self.encoder_length + if len(ts.index) < expected_length: + raise ValueError( + "Given context isn't big enough, try to decrease context_size, prediction_size or increase length of given dataset!" + ) + test_dataset = ts.to_torch_dataset( make_samples=functools.partial( self.net.make_samples, encoder_length=self.encoder_length, decoder_length=prediction_size @@ -629,9 +635,11 @@ def forecast(self, ts: "TSDataset", prediction_size: int) -> "TSDataset": dropna=False, ) predictions = self.raw_predict(test_dataset) - future_ts = ts.tsdataset_idx_slice(start_idx=self.encoder_length, end_idx=self.encoder_length + prediction_size) + end_idx = len(ts.index) + future_ts = ts.tsdataset_idx_slice(start_idx=end_idx - prediction_size, end_idx=end_idx) for (segment, feature_nm), value in predictions.items(): - future_ts.df.loc[:, pd.IndexSlice[segment, feature_nm]] = value[:prediction_size, :] + # we don't want to change dtype after assignment, but there can happen cast to float32 + future_ts.df.loc[:, pd.IndexSlice[segment, feature_nm]] = value[:prediction_size, :].astype(np.float64) future_ts.inverse_transform() diff --git a/etna/models/deadline_ma.py b/etna/models/deadline_ma.py index 8549d4c68..003c2c480 100644 --- a/etna/models/deadline_ma.py +++ b/etna/models/deadline_ma.py @@ -1,14 +1,12 @@ import warnings from enum import Enum -from typing import Dict -from typing import List +from typing import Optional import numpy as np import pandas as pd +from etna.datasets import TSDataset from etna.models.base import NonPredictionIntervalContextRequiredAbstractModel -from etna.models.mixins import NonPredictionIntervalContextRequiredModelMixin -from etna.models.mixins import PerSegmentModelMixin class SeasonalityMode(Enum): @@ -24,76 +22,99 @@ def _missing_(cls, value): ) -class _DeadlineMovingAverageModel: +class DeadlineMovingAverageModel( + NonPredictionIntervalContextRequiredAbstractModel, +): """Moving average model that uses exact previous dates to predict.""" def __init__(self, window: int = 3, seasonality: str = "month"): - """ - Initialize deadline moving average model. + """Initialize deadline moving average model. Length of the context is equal to the number of ``window`` months or years, depending on the ``seasonality``. Parameters ---------- - window: int + window: Number of values taken for forecast for each point. - seasonality: str + seasonality: Only allowed monthly or annual seasonality. """ - self.name = "target" self.window = window self.seasonality = SeasonalityMode(seasonality) - self.freqs_available = {"H", "D"} - self._freq = None + self._freqs_available = {"H", "D"} + self._freq: Optional[str] = None + + def _validate_fitted(self): + """Check if model is fitted.""" + if self._freq is None: + raise ValueError("Model is not fitted! Fit the model before trying the find out context size!") + + @property + def context_size(self) -> int: + """Upper bound to context size of the model.""" + self._validate_fitted() + + cur_value = None + if self.seasonality is SeasonalityMode.year: + cur_value = 366 + elif self.seasonality is SeasonalityMode.month: + cur_value = 31 - def fit(self, df: pd.DataFrame, regressors: List[str]) -> "_DeadlineMovingAverageModel": + if self._freq == "H": + cur_value *= 24 + + cur_value *= self.window + + return cur_value + + def get_model(self) -> "DeadlineMovingAverageModel": + """Get internal model. + + Returns + ------- + : + Itself """ - Fit DeadlineMovingAverageModel model. + return self + + def fit(self, ts: TSDataset) -> "DeadlineMovingAverageModel": + """Fit model. Parameters ---------- - df: pd.DataFrame - Data to fit on - regressors: - List of the columns with regressors(ignored in this model) - - Raises - ------ - ValueError - If freq of dataframe is not supported - ValueError - If series is too short for chosen shift value + ts: + Dataset with features Returns ------- : - Fitted model + Model after fit """ - freq = pd.infer_freq(df["timestamp"]) - if freq not in self.freqs_available: - raise ValueError(f"{freq} is not supported! Use daily or hourly frequency!") + # we make a normalization to treat "1d" like "D" + freq = pd.tseries.frequencies.to_offset(ts.freq).freqstr + if freq not in self._freqs_available: + raise ValueError(f"Freq {freq} is not supported! Use daily or hourly frequency!") + + self._freq = freq - if set(df.columns) != {"timestamp", "target"}: + columns = set(ts.columns.get_level_values("feature")) + if columns != {"target"}: warnings.warn( message=f"{type(self).__name__} does not work with any exogenous series or features. " f"It uses only target series for predict/\n " ) - - self._freq = freq - return self @staticmethod def _get_context_beginning( df: pd.DataFrame, prediction_size: int, seasonality: SeasonalityMode, window: int ) -> pd.Timestamp: - """ - Get timestamp where context begins. + """Get timestamp where context begins. Parameters ---------- df: - Time series in a long format. + Time series in a wide format. prediction_size: Number of last timestamps to leave after making prediction. Previous timestamps will be used as a context for models that require it. @@ -113,29 +134,31 @@ def _get_context_beginning( if context isn't big enough """ df_history = df.iloc[:-prediction_size] - history_timestamps = df_history["timestamp"] - future_timestamps = df["timestamp"].iloc[-prediction_size:] + history_timestamps = df_history.index + future_timestamps = df.iloc[-prediction_size:].index # if we have len(history_timestamps) == 0, then len(df) <= prediction_size if len(history_timestamps) == 0: raise ValueError( - "Given context isn't big enough, try to decrease context_size, prediction_size of increase length of given dataframe!" + "Given context isn't big enough, try to decrease context_size, prediction_size or increase length of given dataframe!" ) if seasonality is SeasonalityMode.month: - first_index = future_timestamps.iloc[0] - pd.DateOffset(months=window) + first_index = future_timestamps[0] - pd.DateOffset(months=window) elif seasonality is SeasonalityMode.year: - first_index = future_timestamps.iloc[0] - pd.DateOffset(years=window) + first_index = future_timestamps[0] - pd.DateOffset(years=window) - if first_index < history_timestamps.iloc[0]: + if first_index < history_timestamps[0]: raise ValueError( - "Given context isn't big enough, try to decrease context_size, prediction_size of increase length of given dataframe!" + "Given context isn't big enough, try to decrease context_size, prediction_size or increase length of given dataframe!" ) return first_index - def _make_predictions(self, result_template: pd.Series, context: pd.Series, prediction_size: int) -> np.ndarray: + def _make_predictions( + self, result_template: pd.DataFrame, context: pd.DataFrame, prediction_size: int + ) -> np.ndarray: """Make predictions using ``result_template`` as a base and ``context`` as a context.""" index = result_template.index start_idx = len(result_template) - prediction_size @@ -154,149 +177,117 @@ def _make_predictions(self, result_template: pd.Series, context: pd.Series, pred result_values = result_template.values[-prediction_size:] return result_values - def forecast(self, df: pd.DataFrame, prediction_size: int) -> np.ndarray: - """Compute autoregressive forecasts. - - Parameters - ---------- - df: - Features dataframe. - prediction_size: - Number of last timestamps to leave after making prediction. - Previous timestamps will be used as a context for models that require it. - - Returns - ------- - : - Array with predictions. - - Raises - ------ - ValueError: - if context isn't big enough - ValueError: - if forecast context contains NaNs - """ + def _forecast(self, df: pd.DataFrame, prediction_size: int) -> pd.DataFrame: + """Make autoregressive forecasts on a wide dataframe.""" context_beginning = self._get_context_beginning( df=df, prediction_size=prediction_size, seasonality=self.seasonality, window=self.window ) - df = df.set_index("timestamp") - df_history = df.iloc[:-prediction_size] - history = df_history["target"] - history = history[history.index >= context_beginning] + history = df.loc[:, pd.IndexSlice[:, "target"]] + history = history.iloc[:-prediction_size] + history = history.loc[history.index >= context_beginning] if np.any(history.isnull()): raise ValueError("There are NaNs in a forecast context, forecast method requires context to be filled!") + num_segments = history.shape[1] index = pd.date_range(start=context_beginning, end=df.index[-1], freq=self._freq) - result_template = np.append(history.values, np.zeros(prediction_size)) - result_template = pd.Series(result_template, index=index) + result_template = np.append(history.values, np.zeros((prediction_size, num_segments)), axis=0) + result_template = pd.DataFrame(result_template, index=index, columns=history.columns) result_values = self._make_predictions( result_template=result_template, context=result_template, prediction_size=prediction_size ) - return result_values - def predict(self, df: pd.DataFrame, prediction_size: int) -> np.ndarray: - """Compute predictions using true target data as context. + df = df.iloc[-prediction_size:] + y_pred = result_values[-prediction_size:] + df.loc[:, pd.IndexSlice[:, "target"]] = y_pred + return df + + def forecast(self, ts: TSDataset, prediction_size: int) -> TSDataset: + """Make autoregressive forecasts. Parameters ---------- - df: - Features dataframe. + ts: + Dataset with features prediction_size: Number of last timestamps to leave after making prediction. - Previous timestamps will be used as a context for models that require it. + Previous timestamps will be used as a context. Returns ------- : - Array with predictions. + Dataset with predictions Raises ------ + ValueError: + if model isn't fitted ValueError: if context isn't big enough ValueError: - if there are NaNs in a target column on timestamps that are required to make predictions + if forecast context contains NaNs """ + self._validate_fitted() + df = ts.to_pandas() + new_df = self._forecast(df=df, prediction_size=prediction_size) + ts.df = new_df + ts.inverse_transform() + return ts + + def _predict(self, df: pd.DataFrame, prediction_size: int) -> pd.DataFrame: + """Make predictions on a wide dataframe using true values as autoregression context.""" context_beginning = self._get_context_beginning( df=df, prediction_size=prediction_size, seasonality=self.seasonality, window=self.window ) - df = df.set_index("timestamp") - context = df["target"] - context = context[context.index >= context_beginning] - if np.any(np.isnan(context)): + context = df.loc[:, pd.IndexSlice[:, "target"]] + context = context.loc[context.index >= context_beginning] + if np.any(context.isnull()): raise ValueError("There are NaNs in a target column, predict method requires target to be filled!") + num_segments = context.shape[1] index = pd.date_range(start=df.index[-prediction_size], end=df.index[-1], freq=self._freq) - result_template = pd.Series(np.zeros(prediction_size), index=index) + result_template = pd.DataFrame(np.zeros((prediction_size, num_segments)), index=index, columns=context.columns) result_values = self._make_predictions( result_template=result_template, context=context, prediction_size=prediction_size ) - return result_values - - @property - def context_size(self) -> int: - """Upper bound to context size of the model.""" - cur_value = None - if self.seasonality is SeasonalityMode.year: - cur_value = 366 - elif self.seasonality is SeasonalityMode.month: - cur_value = 31 - - if self._freq is None: - raise ValueError("Model is not fitted! Fit the model before trying the find out context size!") - if self._freq == "H": - cur_value *= 24 - - cur_value *= self.window - - return cur_value - -class DeadlineMovingAverageModel( - PerSegmentModelMixin, - NonPredictionIntervalContextRequiredModelMixin, - NonPredictionIntervalContextRequiredAbstractModel, -): - """Moving average model that uses exact previous dates to predict.""" + df = df.iloc[-prediction_size:] + y_pred = result_values[-prediction_size:] + df.loc[:, pd.IndexSlice[:, "target"]] = y_pred + return df - def __init__(self, window: int = 3, seasonality: str = "month"): - """ - Initialize deadline moving average model. - - Length of the context is equal to the number of ``window`` months or years, depending on the ``seasonality``. + def predict(self, ts: TSDataset, prediction_size: int) -> TSDataset: + """Make predictions using true values as autoregression context (teacher forcing). Parameters ---------- - window: int - Number of values taken for forecast for each point. - seasonality: str - Only allowed monthly or annual seasonality. - """ - self.window = window - self.seasonality = seasonality - super(DeadlineMovingAverageModel, self).__init__( - base_model=_DeadlineMovingAverageModel(window=window, seasonality=seasonality) - ) - - @property - def context_size(self) -> int: - """Upper bound to context size of the model.""" - models = self.get_model() - model = next(iter(models.values())) - return model.context_size - - def get_model(self) -> Dict[str, "DeadlineMovingAverageModel"]: - """Get internal model. + ts: + Dataset with features + prediction_size: + Number of last timestamps to leave after making prediction. + Previous timestamps will be used as a context. Returns ------- : - Internal model + Dataset with predictions + + Raises + ------ + ValueError: + if model isn't fitted + ValueError: + if context isn't big enough + ValueError: + if forecast context contains NaNs """ - return self._get_model() + self._validate_fitted() + df = ts.to_pandas() + new_df = self._predict(df=df, prediction_size=prediction_size) + ts.df = new_df + ts.inverse_transform() + return ts __all__ = ["DeadlineMovingAverageModel"] diff --git a/etna/models/mixins.py b/etna/models/mixins.py index 76b3659cb..f1cdf005f 100644 --- a/etna/models/mixins.py +++ b/etna/models/mixins.py @@ -324,11 +324,14 @@ def _make_predictions(self, ts: TSDataset, prediction_method: Callable, **kwargs """ result_list = list() df = ts.to_pandas() - for segment, model in self._get_model().items(): + models = self._get_model() + for segment in ts.segments: + if segment not in models: + raise NotImplementedError("Per-segment models can't make predictions on new segments!") + segment_model = models[segment] segment_predict = self._make_predictions_segment( - model=model, segment=segment, df=df, prediction_method=prediction_method, **kwargs + model=segment_model, segment=segment, df=df, prediction_method=prediction_method, **kwargs ) - result_list.append(segment_predict) result_df = pd.concat(result_list, ignore_index=True) diff --git a/etna/models/nn/mlp.py b/etna/models/nn/mlp.py index 3887b58a8..034b1b252 100644 --- a/etna/models/nn/mlp.py +++ b/etna/models/nn/mlp.py @@ -66,6 +66,11 @@ def __init__( layers.append(nn.Linear(in_features=hidden_size[-1], out_features=1)) self.mlp = nn.Sequential(*layers) + @staticmethod + def _validate_batch(batch: MLPBatch): + if batch["decoder_real"].isnan().sum().item(): + raise ValueError("There are NaNs in features, this model can't work with them!") + def forward(self, batch: MLPBatch): # type: ignore """Forward pass. @@ -78,6 +83,7 @@ def forward(self, batch: MLPBatch): # type: ignore : forecast """ + self._validate_batch(batch) decoder_real = batch["decoder_real"].float() return self.mlp(decoder_real) @@ -93,6 +99,7 @@ def step(self, batch: MLPBatch, *args, **kwargs): # type: ignore : loss, true_target, prediction_target """ + self._validate_batch(batch) decoder_real = batch["decoder_real"].float() decoder_target = batch["decoder_target"].float() diff --git a/etna/models/seasonal_ma.py b/etna/models/seasonal_ma.py index 99fc8d588..85c070821 100644 --- a/etna/models/seasonal_ma.py +++ b/etna/models/seasonal_ma.py @@ -1,18 +1,16 @@ import warnings -from typing import Dict -from typing import List import numpy as np import pandas as pd +from etna.datasets import TSDataset from etna.models.base import NonPredictionIntervalContextRequiredAbstractModel -from etna.models.mixins import NonPredictionIntervalContextRequiredModelMixin -from etna.models.mixins import PerSegmentModelMixin -class _SeasonalMovingAverageModel: - """ - Seasonal moving average. +class SeasonalMovingAverageModel( + NonPredictionIntervalContextRequiredAbstractModel, +): + """Seasonal moving average. .. math:: y_{t} = \\frac{\\sum_{i=1}^{n} y_{t-is} }{n}, @@ -28,165 +26,158 @@ def __init__(self, window: int = 5, seasonality: int = 7): Parameters ---------- - window: int + window: Number of values taken for forecast for each point. - seasonality: int + seasonality: Lag between values taken for forecast. """ - self.name = "target" self.window = window self.seasonality = seasonality - self.shift = self.window * self.seasonality - def fit(self, df: pd.DataFrame, regressors: List[str]) -> "_SeasonalMovingAverageModel": - """ - Fit SeasonalMovingAverage model. + @property + def context_size(self) -> int: + """Context size of the model.""" + return self.window * self.seasonality - Parameters - ---------- - df: - Data to fit on - regressors: - List of the columns with regressors(ignored in this model) + def get_model(self) -> "SeasonalMovingAverageModel": + """Get internal model. Returns ------- : - Fitted model + Itself """ - if set(df.columns) != {"timestamp", "target"}: - warnings.warn( - message=f"{type(self).__name__} does not work with any exogenous series or features. " - f"It uses only target series for predict/\n " - ) - return self - def forecast(self, df: pd.DataFrame, prediction_size: int) -> np.ndarray: - """Compute autoregressive forecasts. + def fit(self, ts: TSDataset) -> "SeasonalMovingAverageModel": + """Fit model. + + For this model, fit does nothing. Parameters ---------- - df: - Features dataframe. - prediction_size: - Number of last timestamps to leave after making prediction. - Previous timestamps will be used as a context for models that require it. + ts: + Dataset with features Returns ------- : - Array with predictions. - - Raises - ------ - ValueError: - if context isn't big enough - ValueError: - if forecast context contains NaNs + Model after fit """ - expected_length = prediction_size + self.shift + columns = set(ts.columns.get_level_values("feature")) + if columns != {"target"}: + warnings.warn( + message=f"{type(self).__name__} does not work with any exogenous series or features. " + f"It uses only target series for predict/\n " + ) + return self + + def _validate_context(self, df: pd.DataFrame, prediction_size: int): + """Validate that we have enough context to make prediction with given parameters.""" + expected_length = prediction_size + self.context_size + if len(df) < expected_length: raise ValueError( - "Given context isn't big enough, try to decrease context_size, prediction_size of increase length of given dataframe!" + "Given context isn't big enough, try to decrease context_size, prediction_size or increase length of given dataframe!" ) - history = df["target"][-expected_length:-prediction_size] - if np.any(history.isnull()): + def _forecast(self, df: pd.DataFrame, prediction_size: int) -> pd.DataFrame: + """Make autoregressive forecasts on a wide dataframe.""" + self._validate_context(df=df, prediction_size=prediction_size) + + expected_length = prediction_size + self.context_size + history = df.loc[:, pd.IndexSlice[:, "target"]].values + history = history[-expected_length:-prediction_size] + if np.any(np.isnan(history)): raise ValueError("There are NaNs in a forecast context, forecast method requires context to be filled!") - res = np.append(history, np.zeros(prediction_size)) - for i in range(self.shift, len(res)): - res[i] = res[i - self.shift : i : self.seasonality].mean() + num_segments = history.shape[1] + res = np.append(history, np.zeros((prediction_size, num_segments)), axis=0) + for i in range(self.context_size, len(res)): + res[i] = res[i - self.context_size : i : self.seasonality].mean(axis=0) + + df = df.iloc[-prediction_size:] y_pred = res[-prediction_size:] - return y_pred + df.loc[:, pd.IndexSlice[:, "target"]] = y_pred + return df - def predict(self, df: pd.DataFrame, prediction_size: int) -> np.ndarray: - """Compute predictions using true target data as context. + def forecast(self, ts: TSDataset, prediction_size: int) -> TSDataset: + """Make autoregressive forecasts. Parameters ---------- - df: - Features dataframe. + ts: + Dataset with features prediction_size: Number of last timestamps to leave after making prediction. - Previous timestamps will be used as a context for models that require it. + Previous timestamps will be used as a context. Returns ------- : - Array with predictions. + Dataset with predictions Raises ------ ValueError: if context isn't big enough ValueError: - if there are NaNs in a target column on timestamps that are required to make predictions + if forecast context contains NaNs """ - expected_length = prediction_size + self.shift - if len(df) < expected_length: - raise ValueError( - "Given context isn't big enough, try to decrease context_size, prediction_size of increase length of given dataframe!" - ) - - context = df["target"][-expected_length:].values + df = ts.to_pandas() + new_df = self._forecast(df=df, prediction_size=prediction_size) + ts.df = new_df + ts.inverse_transform() + return ts + + def _predict(self, df: pd.DataFrame, prediction_size: int) -> pd.DataFrame: + """Make predictions on a wide dataframe using true values as autoregression context.""" + self._validate_context(df=df, prediction_size=prediction_size) + + expected_length = prediction_size + self.context_size + context = df.loc[:, pd.IndexSlice[:, "target"]].values + context = context[-expected_length:] if np.any(np.isnan(context)): raise ValueError("There are NaNs in a target column, predict method requires target to be filled!") - res = np.zeros(prediction_size) - for res_idx, context_idx in enumerate(range(self.shift, len(context))): - res[res_idx] = context[context_idx - self.shift : context_idx : self.seasonality].mean() - return res - - -class SeasonalMovingAverageModel( - PerSegmentModelMixin, - NonPredictionIntervalContextRequiredModelMixin, - NonPredictionIntervalContextRequiredAbstractModel, -): - """ - Seasonal moving average. - - .. math:: - y_{t} = \\frac{\\sum_{i=1}^{n} y_{t-is} }{n}, - - where :math:`s` is seasonality, :math:`n` is window size (how many history values are taken for forecast). - """ + num_segments = context.shape[1] + res = np.zeros((prediction_size, num_segments)) + for res_idx, context_idx in enumerate(range(self.context_size, len(context))): + res[res_idx] = context[context_idx - self.context_size : context_idx : self.seasonality].mean(axis=0) - def __init__(self, window: int = 5, seasonality: int = 7): - """ - Initialize seasonal moving average model. + df = df.iloc[-prediction_size:] + y_pred = res[-prediction_size:] + df.loc[:, pd.IndexSlice[:, "target"]] = y_pred + return df - Length of the context is ``window * seasonality``. + def predict(self, ts: TSDataset, prediction_size: int) -> TSDataset: + """Make predictions using true values as autoregression context (teacher forcing). Parameters ---------- - window: int - Number of values taken for forecast for each point. - seasonality: int - Lag between values taken for forecast. - """ - self.window = window - self.seasonality = seasonality - super(SeasonalMovingAverageModel, self).__init__( - base_model=_SeasonalMovingAverageModel(window=window, seasonality=seasonality) - ) - - @property - def context_size(self) -> int: - """Context size of the model.""" - return self.window * self.seasonality - - def get_model(self) -> Dict[str, "SeasonalMovingAverageModel"]: - """Get internal model. + ts: + Dataset with features + prediction_size: + Number of last timestamps to leave after making prediction. + Previous timestamps will be used as a context. Returns ------- : - Internal model + Dataset with predictions + + Raises + ------ + ValueError: + if context isn't big enough + ValueError: + if forecast context contains NaNs """ - return self._get_model() + df = ts.to_pandas() + new_df = self._predict(df=df, prediction_size=prediction_size) + ts.df = new_df + ts.inverse_transform() + return ts __all__ = ["SeasonalMovingAverageModel"] diff --git a/etna/pipeline/autoregressive_pipeline.py b/etna/pipeline/autoregressive_pipeline.py index a2f13772a..4a1a3ff49 100644 --- a/etna/pipeline/autoregressive_pipeline.py +++ b/etna/pipeline/autoregressive_pipeline.py @@ -96,34 +96,28 @@ def fit(self, ts: TSDataset) -> "AutoRegressivePipeline": self.ts.inverse_transform() return self - def _create_predictions_template(self) -> pd.DataFrame: + def _create_predictions_template(self, ts: TSDataset) -> pd.DataFrame: """Create dataframe to fill with forecasts.""" - if self.ts is None: - raise ValueError( - "AutoRegressivePipeline is not fitted! Fit the AutoRegressivePipeline before calling forecast method." - ) - prediction_df = self.ts[:, :, "target"] + prediction_df = ts[:, :, "target"] future_dates = pd.date_range( - start=prediction_df.index.max(), periods=self.horizon + 1, freq=self.ts.freq, closed="right" + start=prediction_df.index.max(), periods=self.horizon + 1, freq=ts.freq, closed="right" ) prediction_df = prediction_df.reindex(prediction_df.index.append(future_dates)) prediction_df.index.name = "timestamp" return prediction_df - def _forecast(self) -> TSDataset: + def _forecast(self, ts: TSDataset) -> TSDataset: """Make predictions.""" - if self.ts is None: - raise ValueError("Something went wrong, ts is None!") - prediction_df = self._create_predictions_template() + prediction_df = self._create_predictions_template(ts) for idx_start in range(0, self.horizon, self.step): current_step = min(self.step, self.horizon - idx_start) - current_idx_border = self.ts.index.shape[0] + idx_start + current_idx_border = ts.index.shape[0] + idx_start current_ts = TSDataset( df=prediction_df.iloc[:current_idx_border], - freq=self.ts.freq, - df_exog=self.ts.df_exog, - known_future=self.ts.known_future, + freq=ts.freq, + df_exog=ts.df_exog, + known_future=ts.known_future, ) # manually set transforms in current_ts, otherwise make_future won't know about them current_ts.transforms = self.transforms @@ -152,9 +146,7 @@ def _forecast(self) -> TSDataset: prediction_df = prediction_df.combine_first(current_ts_future.to_pandas()[prediction_df.columns]) # construct dataset and add all features - prediction_ts = TSDataset( - df=prediction_df, freq=self.ts.freq, df_exog=self.ts.df_exog, known_future=self.ts.known_future - ) + prediction_ts = TSDataset(df=prediction_df, freq=ts.freq, df_exog=ts.df_exog, known_future=ts.known_future) prediction_ts.transform(self.transforms) prediction_ts.inverse_transform() # cut only last timestamps from result dataset diff --git a/etna/pipeline/base.py b/etna/pipeline/base.py index 1bc5b7c5f..4e6897384 100644 --- a/etna/pipeline/base.py +++ b/etna/pipeline/base.py @@ -1,3 +1,4 @@ +import math from abc import abstractmethod from copy import deepcopy from enum import Enum @@ -15,6 +16,8 @@ from joblib import Parallel from joblib import delayed from scipy.stats import norm +from typing_extensions import TypedDict +from typing_extensions import assert_never from etna.core import AbstractSaveable from etna.core import BaseMixin @@ -33,6 +36,12 @@ class CrossValidationMode(Enum): expand = "expand" constant = "constant" + @classmethod + def _missing_(cls, value): + raise NotImplementedError( + f"{value} is not a valid {cls.__name__}. Only {', '.join([repr(m.value) for m in cls])} modes allowed" + ) + class FoldMask(BaseMixin): """Container to hold the description of the fold mask. @@ -130,12 +139,20 @@ def fit(self, ts: TSDataset) -> "AbstractPipeline": @abstractmethod def forecast( - self, prediction_interval: bool = False, quantiles: Sequence[float] = (0.025, 0.975), n_folds: int = 3 + self, + ts: Optional[TSDataset] = None, + prediction_interval: bool = False, + quantiles: Sequence[float] = (0.025, 0.975), + n_folds: int = 3, ) -> TSDataset: - """Make predictions. + """Make a forecast of the next points of a dataset. + + The result of forecasting starts from the last point of ``ts``, not including it. Parameters ---------- + ts: + Dataset to forecast. If not given, dataset given during :py:meth:``fit`` is used. prediction_interval: If True returns prediction interval for forecast quantiles: @@ -201,14 +218,18 @@ def backtest( ts: TSDataset, metrics: List[Metric], n_folds: Union[int, List[FoldMask]] = 5, - mode: str = "expand", + mode: Optional[str] = None, aggregate_metrics: bool = False, n_jobs: int = 1, + refit: Union[bool, int] = True, + stride: Optional[int] = None, joblib_params: Optional[Dict[str, Any]] = None, forecast_params: Optional[Dict[str, Any]] = None, ) -> Tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]: """Run backtest with the pipeline. + If ``refit != True`` and some component of the pipeline doesn't support forecasting with gap, this component will raise an exception. + Parameters ---------- ts: @@ -218,11 +239,23 @@ def backtest( n_folds: Number of folds or the list of fold masks mode: - One of 'expand', 'constant' -- train generation policy + Train generation policy: 'expand' or 'constant'. Works only if ``n_folds`` is integer. + By default, is set to 'expand'. aggregate_metrics: If True aggregate metrics above folds, return raw metrics otherwise n_jobs: Number of jobs to run in parallel + refit: + Determines how often pipeline should be retrained during iteration over folds. + + * If ``True``: pipeline is retrained on each fold. + + * If ``False``: pipeline is trained only on the first fold. + + * If ``value: int``: pipeline is trained every ``value`` folds starting from the first. + + stride: + Number of points between folds. Works only if ``n_folds`` is integer. By default, is set to ``horizon``. joblib_params: Additional parameters for :py:class:`joblib.Parallel` forecast_params: @@ -235,6 +268,15 @@ def backtest( """ +class FoldParallelGroup(TypedDict): + """Group for parallel fold processing.""" + + train_fold_number: int + train_mask: FoldMask + forecast_fold_numbers: List[int] + forecast_masks: List[FoldMask] + + class BasePipeline(AbstractPipeline, BaseMixin): """Base class for pipeline.""" @@ -258,34 +300,29 @@ def _validate_quantiles(quantiles: Sequence[float]) -> Sequence[float]: return quantiles @abstractmethod - def _forecast(self) -> TSDataset: + def _forecast(self, ts: TSDataset) -> TSDataset: """Make predictions.""" pass def _forecast_prediction_interval( - self, predictions: TSDataset, quantiles: Sequence[float], n_folds: int + self, ts: TSDataset, predictions: TSDataset, quantiles: Sequence[float], n_folds: int ) -> TSDataset: """Add prediction intervals to the forecasts.""" - if self.ts is None: - raise ValueError("Pipeline is not fitted! Fit the Pipeline before calling forecast method.") with tslogger.disable(): - _, forecasts, _ = self.backtest(ts=self.ts, metrics=[MAE()], n_folds=n_folds) + _, forecasts, _ = self.backtest(ts=ts, metrics=[MAE()], n_folds=n_folds) - self._add_forecast_borders(backtest_forecasts=forecasts, quantiles=quantiles, predictions=predictions) + self._add_forecast_borders(ts=ts, backtest_forecasts=forecasts, quantiles=quantiles, predictions=predictions) return predictions def _add_forecast_borders( - self, backtest_forecasts: pd.DataFrame, quantiles: Sequence[float], predictions: TSDataset + self, ts: TSDataset, backtest_forecasts: pd.DataFrame, quantiles: Sequence[float], predictions: TSDataset ) -> None: """Estimate prediction intervals and add to the forecasts.""" - if self.ts is None: - raise ValueError("Pipeline is not fitted!") - - backtest_forecasts = TSDataset(df=backtest_forecasts, freq=self.ts.freq) + backtest_forecasts = TSDataset(df=backtest_forecasts, freq=ts.freq) residuals = ( backtest_forecasts.loc[:, pd.IndexSlice[:, "target"]] - - self.ts[backtest_forecasts.index.min() : backtest_forecasts.index.max(), :, "target"] + - ts[backtest_forecasts.index.min() : backtest_forecasts.index.max(), :, "target"] ) sigma = np.std(residuals.values, axis=0) @@ -299,12 +336,20 @@ def _add_forecast_borders( predictions.df = pd.concat([predictions.df] + borders, axis=1).sort_index(axis=1, level=(0, 1)) def forecast( - self, prediction_interval: bool = False, quantiles: Sequence[float] = (0.025, 0.975), n_folds: int = 3 + self, + ts: Optional[TSDataset] = None, + prediction_interval: bool = False, + quantiles: Sequence[float] = (0.025, 0.975), + n_folds: int = 3, ) -> TSDataset: - """Make predictions. + """Make a forecast of the next points of a dataset. + + The result of forecasting starts from the last point of ``ts``, not including it. Parameters ---------- + ts: + Dataset to forecast. If not given, dataset given during :py:meth:``fit`` is used. prediction_interval: If True returns prediction interval for forecast quantiles: @@ -317,18 +362,20 @@ def forecast( : Dataset with predictions """ - if self.ts is None: - raise ValueError( - f"{self.__class__.__name__} is not fitted! Fit the {self.__class__.__name__} " - f"before calling forecast method." - ) + if ts is None: + if self.ts is None: + raise ValueError( + "There is no ts to forecast! Pass ts into forecast method or make sure that pipeline is loaded with ts." + ) + ts = self.ts + self._validate_quantiles(quantiles=quantiles) self._validate_backtest_n_folds(n_folds=n_folds) - predictions = self._forecast() + predictions = self._forecast(ts=ts) if prediction_interval: predictions = self._forecast_prediction_interval( - predictions=predictions, quantiles=quantiles, n_folds=n_folds + ts=ts, predictions=predictions, quantiles=quantiles, n_folds=n_folds ) return predictions @@ -428,43 +475,65 @@ def _init_backtest(self): @staticmethod def _validate_backtest_n_folds(n_folds: int): - """Check that given n_folds value is valid.""" + """Check that given n_folds value is >= 1.""" if n_folds < 1: raise ValueError(f"Folds number should be a positive number, {n_folds} given") @staticmethod - def _validate_backtest_dataset(ts: TSDataset, n_folds: int, horizon: int): + def _validate_backtest_mode(n_folds: Union[int, List[FoldMask]], mode: Optional[str]) -> CrossValidationMode: + if mode is None: + return CrossValidationMode.expand + + if not isinstance(n_folds, int): + raise ValueError("Mode shouldn't be set if n_folds are fold masks!") + + return CrossValidationMode(mode.lower()) + + @staticmethod + def _validate_backtest_stride(n_folds: Union[int, List[FoldMask]], horizon: int, stride: Optional[int]) -> int: + if stride is None: + return horizon + + if not isinstance(n_folds, int): + raise ValueError("Stride shouldn't be set if n_folds are fold masks!") + + if stride < 1: + raise ValueError(f"Stride should be a positive number, {stride} given!") + + return stride + + @staticmethod + def _validate_backtest_dataset(ts: TSDataset, n_folds: int, horizon: int, stride: int): """Check all segments have enough timestamps to validate forecaster with given number of splits.""" - min_required_length = horizon * n_folds + min_required_length = horizon + (n_folds - 1) * stride segments = set(ts.df.columns.get_level_values("segment")) for segment in segments: segment_target = ts[:, segment, "target"] if len(segment_target) < min_required_length: raise ValueError( f"All the series from feature dataframe should contain at least " - f"{horizon} * {n_folds} = {min_required_length} timestamps; " + f"{horizon} + {n_folds-1} * {stride} = {min_required_length} timestamps; " f"series {segment} does not." ) @staticmethod - def _generate_masks_from_n_folds(ts: TSDataset, n_folds: int, horizon: int, mode: str) -> List[FoldMask]: + def _generate_masks_from_n_folds( + ts: TSDataset, n_folds: int, horizon: int, mode: CrossValidationMode, stride: int + ) -> List[FoldMask]: """Generate fold masks from n_folds.""" - mode_enum = CrossValidationMode(mode.lower()) - if mode_enum == CrossValidationMode.expand: + if mode is CrossValidationMode.expand: constant_history_length = 0 - elif mode_enum == CrossValidationMode.constant: + elif mode is CrossValidationMode.constant: constant_history_length = 1 else: - raise NotImplementedError( - f"Only '{CrossValidationMode.expand}' and '{CrossValidationMode.constant}' modes allowed" - ) + assert_never(mode) masks = [] dataset_timestamps = list(ts.index) min_timestamp_idx, max_timestamp_idx = 0, len(dataset_timestamps) for offset in range(n_folds, 0, -1): - min_train_idx = min_timestamp_idx + (n_folds - offset) * horizon * constant_history_length - max_train_idx = max_timestamp_idx - horizon * offset - 1 + min_train_idx = min_timestamp_idx + (n_folds - offset) * stride * constant_history_length + max_train_idx = max_timestamp_idx - stride * (offset - 1) - horizon - 1 min_test_idx = max_train_idx + 1 max_test_idx = max_train_idx + horizon @@ -521,21 +590,40 @@ def _compute_metrics( metrics_values[metric.name] = metric(y_true=y_true, y_pred=y_pred) # type: ignore return metrics_values - def _run_fold( + def _fit_backtest_pipeline( + self, + ts: TSDataset, + fold_number: int, + ) -> "BasePipeline": + """Fit pipeline for a given data in backtest.""" + tslogger.start_experiment(job_type="training", group=str(fold_number)) + pipeline = deepcopy(self) + pipeline.fit(ts=ts) + tslogger.finish_experiment() + return pipeline + + def _forecast_backtest_pipeline( + self, pipeline: "BasePipeline", ts: TSDataset, fold_number: int, forecast_params: Dict[str, Any] + ) -> TSDataset: + """Make a forecast with a given pipeline in backtest.""" + tslogger.start_experiment(job_type="forecasting", group=str(fold_number)) + forecast = pipeline.forecast(ts=ts, **forecast_params) + tslogger.finish_experiment() + return forecast + + def _process_fold_forecast( self, + forecast: TSDataset, train: TSDataset, test: TSDataset, + pipeline: "BasePipeline", fold_number: int, mask: FoldMask, metrics: List[Metric], - forecast_params: Dict[str, Any], ) -> Dict[str, Any]: - """Run fit-forecast pipeline of model for one fold.""" + """Process forecast made for a fold.""" tslogger.start_experiment(job_type="crossval", group=str(fold_number)) - pipeline = deepcopy(self) - pipeline.fit(ts=train) - forecast = pipeline.forecast(**forecast_params) fold: Dict[str, Any] = {} for stage_name, stage_df in zip(("train", "test"), (train, test)): fold[f"{stage_name}_timerange"] = {} @@ -583,7 +671,7 @@ def _get_fold_info(self) -> pd.DataFrame: tmp_df[f"{stage_name}_{border}_time"] = [fold_info[f"{stage_name}_timerange"][border]] tmp_df[self._fold_column] = fold_number timerange_dfs.append(tmp_df) - timerange_df = pd.concat(timerange_dfs) + timerange_df = pd.concat(timerange_dfs, ignore_index=True) return timerange_df def _get_backtest_forecasts(self) -> pd.DataFrame: @@ -606,12 +694,16 @@ def _get_backtest_forecasts(self) -> pd.DataFrame: forecasts.sort_index(axis=1, inplace=True) return forecasts - def _prepare_fold_masks(self, ts: TSDataset, masks: Union[int, List[FoldMask]], mode: str) -> List[FoldMask]: + def _prepare_fold_masks( + self, ts: TSDataset, masks: Union[int, List[FoldMask]], mode: CrossValidationMode, stride: int + ) -> List[FoldMask]: """Prepare and validate fold masks.""" if isinstance(masks, int): self._validate_backtest_n_folds(n_folds=masks) - self._validate_backtest_dataset(ts=ts, n_folds=masks, horizon=self.horizon) - masks = self._generate_masks_from_n_folds(ts=ts, n_folds=masks, horizon=self.horizon, mode=mode) + self._validate_backtest_dataset(ts=ts, n_folds=masks, horizon=self.horizon, stride=stride) + masks = self._generate_masks_from_n_folds( + ts=ts, n_folds=masks, horizon=self.horizon, mode=mode, stride=stride + ) for i, mask in enumerate(masks): mask.first_train_timestamp = mask.first_train_timestamp if mask.first_train_timestamp else ts.index[0] masks[i] = mask @@ -619,19 +711,126 @@ def _prepare_fold_masks(self, ts: TSDataset, masks: Union[int, List[FoldMask]], mask.validate_on_dataset(ts=ts, horizon=self.horizon) return masks + @staticmethod + def _make_backtest_fold_groups(masks: List[FoldMask], refit: Union[bool, int]) -> List[FoldParallelGroup]: + """Make groups of folds for backtest.""" + if not refit: + refit = len(masks) + + grouped_folds = [] + num_groups = math.ceil(len(masks) / refit) + for group_id in range(num_groups): + train_fold_number = group_id * refit + forecast_fold_numbers = [train_fold_number + i for i in range(refit) if train_fold_number + i < len(masks)] + cur_group: FoldParallelGroup = { + "train_fold_number": train_fold_number, + "train_mask": masks[train_fold_number], + "forecast_fold_numbers": forecast_fold_numbers, + "forecast_masks": [masks[i] for i in forecast_fold_numbers], + } + grouped_folds.append(cur_group) + + return grouped_folds + + def _run_all_folds( + self, + masks: List[FoldMask], + ts: TSDataset, + metrics: List[Metric], + n_jobs: int, + refit: Union[bool, int], + joblib_params: Dict[str, Any], + forecast_params: Dict[str, Any], + ) -> Dict[int, Any]: + """Run pipeline on all folds.""" + fold_groups = self._make_backtest_fold_groups(masks=masks, refit=refit) + + with Parallel(n_jobs=n_jobs, **joblib_params) as parallel: + # fitting + fit_masks = [group["train_mask"] for group in fold_groups] + fit_datasets = ( + train for train, _ in self._generate_folds_datasets(ts=ts, masks=fit_masks, horizon=self.horizon) + ) + pipelines = parallel( + delayed(self._fit_backtest_pipeline)(ts=fit_ts, fold_number=fold_groups[group_idx]["train_fold_number"]) + for group_idx, fit_ts in enumerate(fit_datasets) + ) + + # forecasting + forecast_masks = [group["forecast_masks"] for group in fold_groups] + forecast_datasets = ( + ( + train + for train, _ in self._generate_folds_datasets( + ts=ts, masks=group_forecast_masks, horizon=self.horizon + ) + ) + for group_forecast_masks in forecast_masks + ) + forecasts_flat = parallel( + delayed(self._forecast_backtest_pipeline)( + ts=forecast_ts, + pipeline=pipelines[group_idx], + fold_number=fold_groups[group_idx]["forecast_fold_numbers"][idx], + forecast_params=forecast_params, + ) + for group_idx, group_forecast_datasets in enumerate(forecast_datasets) + for idx, forecast_ts in enumerate(group_forecast_datasets) + ) + + # processing forecasts + fold_process_train_datasets = ( + train for train, _ in self._generate_folds_datasets(ts=ts, masks=fit_masks, horizon=self.horizon) + ) + fold_process_test_datasets = ( + ( + test + for _, test in self._generate_folds_datasets( + ts=ts, masks=group_forecast_masks, horizon=self.horizon + ) + ) + for group_forecast_masks in forecast_masks + ) + fold_results_flat = parallel( + delayed(self._process_fold_forecast)( + forecast=forecasts_flat[group_idx * refit + idx], + train=train, + test=test, + pipeline=pipelines[group_idx], + fold_number=fold_groups[group_idx]["forecast_fold_numbers"][idx], + mask=fold_groups[group_idx]["forecast_masks"][idx], + metrics=metrics, + ) + for group_idx, (train, group_fold_process_test_datasets) in enumerate( + zip(fold_process_train_datasets, fold_process_test_datasets) + ) + for idx, test in enumerate(group_fold_process_test_datasets) + ) + + results = { + fold_number: fold_results_flat[group_idx * refit + idx] + for group_idx in range(len(fold_groups)) + for idx, fold_number in enumerate(fold_groups[group_idx]["forecast_fold_numbers"]) + } + return results + def backtest( self, ts: TSDataset, metrics: List[Metric], n_folds: Union[int, List[FoldMask]] = 5, - mode: str = "expand", + mode: Optional[str] = None, aggregate_metrics: bool = False, n_jobs: int = 1, + refit: Union[bool, int] = True, + stride: Optional[int] = None, joblib_params: Optional[Dict[str, Any]] = None, forecast_params: Optional[Dict[str, Any]] = None, ) -> Tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]: """Run backtest with the pipeline. + If ``refit != True`` and some component of the pipeline doesn't support forecasting with gap, this component will raise an exception. + Parameters ---------- ts: @@ -641,11 +840,23 @@ def backtest( n_folds: Number of folds or the list of fold masks mode: - One of 'expand', 'constant' -- train generation policy, ignored if n_folds is a list of masks + Train generation policy: 'expand' or 'constant'. Works only if ``n_folds`` is integer. + By default, is set to 'expand'. aggregate_metrics: If True aggregate metrics above folds, return raw metrics otherwise n_jobs: Number of jobs to run in parallel + refit: + Determines how often pipeline should be retrained during iteration over folds. + + * If ``True``: pipeline is retrained on each fold. + + * If ``False``: pipeline is trained only on the first fold. + + * If ``value: int``: pipeline is trained every ``value`` folds starting from the first. + + stride: + Number of points between folds. Works only if ``n_folds`` is integer. By default, is set to ``horizon``. joblib_params: Additional parameters for :py:class:`joblib.Parallel` forecast_params: @@ -655,7 +866,17 @@ def backtest( ------- metrics_df, forecast_df, fold_info_df: Tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame] Metrics dataframe, forecast dataframe and dataframe with information about folds + + Raises + ------ + ValueError: + If ``mode`` is set when ``n_folds`` are ``List[FoldMask]``. + ValueError: + If ``stride`` is set when ``n_folds`` are ``List[FoldMask]``. """ + mode_enum = self._validate_backtest_mode(n_folds=n_folds, mode=mode) + stride = self._validate_backtest_stride(n_folds=n_folds, horizon=self.horizon, stride=stride) + if joblib_params is None: joblib_params = dict(verbose=11, backend="multiprocessing", mmap_mode="c") @@ -664,22 +885,16 @@ def backtest( self._init_backtest() self._validate_backtest_metrics(metrics=metrics) - masks = self._prepare_fold_masks(ts=ts, masks=n_folds, mode=mode) - - folds = Parallel(n_jobs=n_jobs, **joblib_params)( - delayed(self._run_fold)( - train=train, - test=test, - fold_number=fold_number, - mask=masks[fold_number], - metrics=metrics, - forecast_params=forecast_params, - ) - for fold_number, (train, test) in enumerate( - self._generate_folds_datasets(ts=ts, masks=masks, horizon=self.horizon) - ) + masks = self._prepare_fold_masks(ts=ts, masks=n_folds, mode=mode_enum, stride=stride) + self._folds = self._run_all_folds( + masks=masks, + ts=ts, + metrics=metrics, + n_jobs=n_jobs, + refit=refit, + joblib_params=joblib_params, + forecast_params=forecast_params, ) - self._folds = {i: fold for i, fold in enumerate(folds)} metrics_df = self._get_backtest_metrics(aggregate_metrics=aggregate_metrics) forecast_df = self._get_backtest_forecasts() diff --git a/etna/pipeline/hierarchical_pipeline.py b/etna/pipeline/hierarchical_pipeline.py index c7ca590ed..85066e42c 100644 --- a/etna/pipeline/hierarchical_pipeline.py +++ b/etna/pipeline/hierarchical_pipeline.py @@ -1,3 +1,4 @@ +import pathlib from copy import deepcopy from typing import Dict from typing import List @@ -67,12 +68,20 @@ def fit(self, ts: TSDataset) -> "HierarchicalPipeline": return self def raw_forecast( - self, prediction_interval: bool = False, quantiles: Sequence[float] = (0.25, 0.75), n_folds: int = 3 + self, + ts: TSDataset, + prediction_interval: bool = False, + quantiles: Sequence[float] = (0.25, 0.75), + n_folds: int = 3, ) -> TSDataset: - """Make a prediction for target at the source level of hierarchy. + """Make a forecast of the next points of a dataset on a source level. + + The result of forecasting starts from the last point of ``ts``, not including it. Parameters ---------- + ts: + Dataset to forecast prediction_interval: If True returns prediction interval for forecast quantiles: @@ -85,25 +94,41 @@ def raw_forecast( : Dataset with predictions at the source level """ - forecast = super().forecast(prediction_interval=prediction_interval, quantiles=quantiles, n_folds=n_folds) - target_columns = tuple(get_target_with_quantiles(columns=forecast.columns)) + # handle `prediction_interval=True` separately + source_ts = self.reconciliator.aggregate(ts=ts) + forecast = super().forecast(ts=source_ts, prediction_interval=False, n_folds=n_folds) + if prediction_interval: + forecast = self._forecast_prediction_interval( + ts=ts, predictions=forecast, quantiles=quantiles, n_folds=n_folds + ) + target_columns = tuple(get_target_with_quantiles(columns=forecast.columns)) hierarchical_forecast = TSDataset( df=forecast[..., target_columns], freq=forecast.freq, df_exog=forecast.df_exog, known_future=forecast.known_future, - hierarchical_structure=self.ts.hierarchical_structure, # type: ignore + hierarchical_structure=ts.hierarchical_structure, # type: ignore ) return hierarchical_forecast def forecast( - self, prediction_interval: bool = False, quantiles: Sequence[float] = (0.025, 0.975), n_folds: int = 3 + self, + ts: Optional[TSDataset] = None, + prediction_interval: bool = False, + quantiles: Sequence[float] = (0.025, 0.975), + n_folds: int = 3, ) -> TSDataset: - """Make a prediction for target at the source level of hierarchy and make reconciliation to target level. + """Make a forecast of the next points of a dataset on a target level. + + The result of forecasting starts from the last point of ``ts``, not including it. + + Method makes a prediction for target at the source level of hierarchy and then makes reconciliation to target level. Parameters ---------- + ts: + Dataset to forecast. If not given, dataset given during :py:meth:``fit`` is used. prediction_interval: If True returns prediction interval for forecast quantiles: @@ -116,7 +141,16 @@ def forecast( : Dataset with predictions at the target level of hierarchy. """ - forecast = self.raw_forecast(prediction_interval=prediction_interval, quantiles=quantiles, n_folds=n_folds) + if ts is None: + if self._fit_ts is None: + raise ValueError( + "There is no ts to forecast! Pass ts into forecast method or make sure that pipeline is loaded with ts." + ) + ts = self._fit_ts + + forecast = self.raw_forecast( + ts=ts, prediction_interval=prediction_interval, quantiles=quantiles, n_folds=n_folds + ) forecast_reconciled = self.reconciliator.reconcile(forecast) return forecast_reconciled @@ -136,21 +170,68 @@ def _compute_metrics( return metrics_values def _forecast_prediction_interval( - self, predictions: TSDataset, quantiles: Sequence[float], n_folds: int + self, ts: TSDataset, predictions: TSDataset, quantiles: Sequence[float], n_folds: int ) -> TSDataset: """Add prediction intervals to the forecasts.""" + # TODO: fix this: what if during backtest KeyboardInterrupt is raised self.forecast, self.raw_forecast = self.raw_forecast, self.forecast # type: ignore - if self.ts is None or self._fit_ts is None: + if self.ts is None: raise ValueError("Pipeline is not fitted! Fit the Pipeline before calling forecast method.") # TODO: rework intervals estimation for `BottomUpReconciliator` with tslogger.disable(): - _, forecasts, _ = self.backtest(ts=self._fit_ts, metrics=[MAE()], n_folds=n_folds) + _, forecasts, _ = self.backtest(ts=ts, metrics=[MAE()], n_folds=n_folds) - self._add_forecast_borders(backtest_forecasts=forecasts, quantiles=quantiles, predictions=predictions) + source_ts = self.reconciliator.aggregate(ts=ts) + self._add_forecast_borders( + ts=source_ts, backtest_forecasts=forecasts, quantiles=quantiles, predictions=predictions + ) self.forecast, self.raw_forecast = self.raw_forecast, self.forecast # type: ignore return predictions + + def save(self, path: pathlib.Path): + """Save the object. + + Parameters + ---------- + path: + Path to save object to. + """ + fit_ts = self._fit_ts + + try: + # extract attributes we can't easily save + delattr(self, "_fit_ts") + + # save the remaining part + super().save(path=path) + finally: + self._fit_ts = fit_ts + + @classmethod + def load(cls, path: pathlib.Path, ts: Optional[TSDataset] = None) -> "HierarchicalPipeline": + """Load an object. + + Parameters + ---------- + path: + Path to load object from. + ts: + TSDataset to set into loaded pipeline. + + Returns + ------- + : + Loaded object. + """ + obj = super().load(path=path) + obj._fit_ts = deepcopy(ts) + if ts is not None: + obj.ts = obj.reconciliator.aggregate(ts=ts) + else: + obj.ts = None + return obj diff --git a/etna/pipeline/pipeline.py b/etna/pipeline/pipeline.py index 456925bd5..09080360c 100644 --- a/etna/pipeline/pipeline.py +++ b/etna/pipeline/pipeline.py @@ -1,3 +1,4 @@ +from typing import Optional from typing import Sequence from typing import cast @@ -56,28 +57,36 @@ def fit(self, ts: TSDataset) -> "Pipeline": self.ts.inverse_transform() return self - def _forecast(self) -> TSDataset: + def _forecast(self, ts: TSDataset) -> TSDataset: """Make predictions.""" - if self.ts is None: - raise ValueError("Something went wrong, ts is None!") + # because make_future uses `ts.transforms` + ts.transforms = self.transforms if isinstance(self.model, get_args(ContextRequiredModelType)): self.model = cast(ContextRequiredModelType, self.model) - future = self.ts.make_future(future_steps=self.horizon, tail_steps=self.model.context_size) + future = ts.make_future(future_steps=self.horizon, tail_steps=self.model.context_size) predictions = self.model.forecast(ts=future, prediction_size=self.horizon) else: self.model = cast(ContextIgnorantModelType, self.model) - future = self.ts.make_future(future_steps=self.horizon) + future = ts.make_future(future_steps=self.horizon) predictions = self.model.forecast(ts=future) return predictions def forecast( - self, prediction_interval: bool = False, quantiles: Sequence[float] = (0.025, 0.975), n_folds: int = 3 + self, + ts: Optional[TSDataset] = None, + prediction_interval: bool = False, + quantiles: Sequence[float] = (0.025, 0.975), + n_folds: int = 3, ) -> TSDataset: - """Make predictions. + """Make a forecast of the next points of a dataset. + + The result of forecasting starts from the last point of ``ts``, not including it. Parameters ---------- + ts: + Dataset to forecast. If not given, dataset given during :py:meth:``fit`` is used. prediction_interval: If True returns prediction interval for forecast quantiles: @@ -90,24 +99,29 @@ def forecast( : Dataset with predictions """ - if self.ts is None: - raise ValueError( - f"{self.__class__.__name__} is not fitted! Fit the {self.__class__.__name__} " - f"before calling forecast method." - ) + if ts is None: + if self.ts is None: + raise ValueError( + "There is no ts to forecast! Pass ts into forecast method or make sure that pipeline is loaded with ts." + ) + ts = self.ts + else: + # because make_future uses `ts.transforms` + ts.transforms = self.transforms + self._validate_quantiles(quantiles=quantiles) self._validate_backtest_n_folds(n_folds=n_folds) if prediction_interval and isinstance(self.model, PredictionIntervalContextIgnorantAbstractModel): - future = self.ts.make_future(future_steps=self.horizon) + future = ts.make_future(future_steps=self.horizon) predictions = self.model.forecast(ts=future, prediction_interval=prediction_interval, quantiles=quantiles) elif prediction_interval and isinstance(self.model, PredictionIntervalContextRequiredAbstractModel): - future = self.ts.make_future(future_steps=self.horizon, tail_steps=self.model.context_size) + future = ts.make_future(future_steps=self.horizon, tail_steps=self.model.context_size) predictions = self.model.forecast( ts=future, prediction_size=self.horizon, prediction_interval=prediction_interval, quantiles=quantiles ) else: predictions = super().forecast( - prediction_interval=prediction_interval, quantiles=quantiles, n_folds=n_folds + ts=ts, prediction_interval=prediction_interval, quantiles=quantiles, n_folds=n_folds ) return predictions diff --git a/etna/transforms/base.py b/etna/transforms/base.py index d71070fe6..1fa72895c 100644 --- a/etna/transforms/base.py +++ b/etna/transforms/base.py @@ -94,14 +94,19 @@ def fit(self, df: pd.DataFrame) -> "PerSegmentWrapper": def transform(self, df: pd.DataFrame) -> pd.DataFrame: """Apply transform to each segment separately.""" results = [] - for key, value in self.segment_transforms.items(): - seg_df = value.transform(df[key]) + segments = set(df.columns.get_level_values("segment")) + for segment in segments: + if segment not in self.segment_transforms: + raise NotImplementedError("Per-segment transforms can't work on new segments!") + + segment_transform = self.segment_transforms[segment] + seg_df = segment_transform.transform(df[segment]) _idx = seg_df.columns.to_frame() - _idx.insert(0, "segment", key) + _idx.insert(0, "segment", segment) seg_df.columns = pd.MultiIndex.from_frame(_idx) - results.append(seg_df) + df = pd.concat(results, axis=1) df = df.sort_index(axis=1) df.columns.names = ["segment", "feature"] @@ -110,11 +115,16 @@ def transform(self, df: pd.DataFrame) -> pd.DataFrame: def inverse_transform(self, df: pd.DataFrame) -> pd.DataFrame: """Apply inverse_transform to each segment.""" results = [] - for key, value in self.segment_transforms.items(): - seg_df = value.inverse_transform(df[key]) + segments = set(df.columns.get_level_values("segment")) + for segment in segments: + if segment not in self.segment_transforms: + raise NotImplementedError("Per-segment transforms can't work on new segments!") + + segment_transform = self.segment_transforms[segment] + seg_df = segment_transform.inverse_transform(df[segment]) _idx = seg_df.columns.to_frame() - _idx.insert(0, "segment", key) + _idx.insert(0, "segment", segment) seg_df.columns = pd.MultiIndex.from_frame(_idx) results.append(seg_df) diff --git a/etna/transforms/encoders/mean_segment_encoder.py b/etna/transforms/encoders/mean_segment_encoder.py index 8f518441c..60fab1462 100644 --- a/etna/transforms/encoders/mean_segment_encoder.py +++ b/etna/transforms/encoders/mean_segment_encoder.py @@ -1,4 +1,7 @@ -import numpy as np +import reprlib +from typing import Dict +from typing import Optional + import pandas as pd from etna.transforms import Transform @@ -13,7 +16,7 @@ class MeanSegmentEncoderTransform(Transform, FutureMixin): def __init__(self): self.mean_encoder = MeanTransform(in_column="target", window=-1, out_column="segment_mean") - self.global_means: np.ndarray[float] = None + self.global_means: Optional[Dict[str, float]] = None def fit(self, df: pd.DataFrame) -> "MeanSegmentEncoderTransform": """ @@ -30,7 +33,9 @@ def fit(self, df: pd.DataFrame) -> "MeanSegmentEncoderTransform": Fitted transform """ self.mean_encoder.fit(df) - self.global_means = df.loc[:, self.idx[:, "target"]].mean().values + mean_values = df.loc[:, self.idx[:, "target"]].mean().to_dict() + mean_values = {key[0]: value for key, value in mean_values.items()} + self.global_means = mean_values return self def transform(self, df: pd.DataFrame) -> pd.DataFrame: @@ -46,9 +51,26 @@ def transform(self, df: pd.DataFrame) -> pd.DataFrame: ------- : result dataframe + + Raises + ------ + ValueError: + If transform isn't fitted. + NotImplementedError: + If there are segments that weren't present during training. """ + if self.global_means is None: + raise ValueError("The transform isn't fitted!") + + segments = df.columns.get_level_values("segment").unique().tolist() + new_segments = set(segments) - self.global_means.keys() + if len(new_segments) > 0: + raise NotImplementedError( + f"This transform can't process segments that weren't present on train data: {reprlib.repr(new_segments)}" + ) + df = self.mean_encoder.transform(df) - segment = df.columns.get_level_values("segment").unique()[0] + segment = segments[0] nan_timestamps = df[df.loc[:, self.idx[segment, "target"]].isna()].index - df.loc[nan_timestamps, self.idx[:, "segment_mean"]] = self.global_means + df.loc[nan_timestamps, self.idx[:, "segment_mean"]] = [self.global_means[x] for x in segments] return df diff --git a/etna/transforms/encoders/segment_encoder.py b/etna/transforms/encoders/segment_encoder.py index e899b8eac..f54a7a13d 100644 --- a/etna/transforms/encoders/segment_encoder.py +++ b/etna/transforms/encoders/segment_encoder.py @@ -1,3 +1,6 @@ +import reprlib + +import numpy as np import pandas as pd from sklearn import preprocessing @@ -44,12 +47,31 @@ def transform(self, df: pd.DataFrame) -> pd.DataFrame: ------- : result dataframe + + Raises + ------ + ValueError: + If transform isn't fitted. + NotImplementedError: + If there are segments that weren't present during training. """ - encoded_matrix = self._le.transform(self._le.classes_) - encoded_matrix = encoded_matrix.reshape(len(self._le.classes_), -1).repeat(len(df), axis=1).T + segments = df.columns.get_level_values("segment").unique().tolist() + + try: + new_segments = set(segments) - set(self._le.classes_) + except AttributeError: + raise ValueError("The transform isn't fitted!") + + if len(new_segments) > 0: + raise NotImplementedError( + f"This transform can't process segments that weren't present on train data: {reprlib.repr(new_segments)}" + ) + + encoded_matrix = self._le.transform(segments) + encoded_matrix = np.tile(encoded_matrix, (len(df), 1)) encoded_df = pd.DataFrame( encoded_matrix, - columns=pd.MultiIndex.from_product([self._le.classes_, ["segment_code"]], names=("segment", "feature")), + columns=pd.MultiIndex.from_product([segments, ["segment_code"]], names=("segment", "feature")), index=df.index, ) encoded_df = encoded_df.astype("category") diff --git a/etna/transforms/math/differencing.py b/etna/transforms/math/differencing.py index 74f0a9e10..692066429 100644 --- a/etna/transforms/math/differencing.py +++ b/etna/transforms/math/differencing.py @@ -3,18 +3,21 @@ from typing import Optional from typing import Set from typing import Union +from typing import cast import numpy as np import pandas as pd from etna.transforms.base import Transform +from etna.transforms.utils import check_new_segments from etna.transforms.utils import match_target_quantiles class _SingleDifferencingTransform(Transform): """Calculate a time series differences of order 1. - This transform can work with NaNs at the beginning of the segment, but fails when meets NaN inside the segment. + During ``fit`` this transform can work with NaNs at the beginning of the segment, but fails when meets NaN inside the segment. + During ``transform`` and ``inverse_transform`` there is no special treatment of NaNs. Notes ----- @@ -84,12 +87,16 @@ def fit(self, df: pd.DataFrame) -> "_SingleDifferencingTransform": Returns ------- result: _SingleDifferencingTransform + + Raises + ------ + ValueError: + if NaNs are present inside the segment """ segments = sorted(set(df.columns.get_level_values("segment"))) fit_df = df.loc[:, pd.IndexSlice[segments, self.in_column]].copy() - self._train_timestamp = fit_df.index - self._train_init_dict = {} + train_init_dict = {} for current_segment in segments: cur_series = fit_df.loc[:, pd.IndexSlice[current_segment, self.in_column]] cur_series = cur_series.loc[cur_series.first_valid_index() :] @@ -97,7 +104,10 @@ def fit(self, df: pd.DataFrame) -> "_SingleDifferencingTransform": if cur_series.isna().sum() > 0: raise ValueError(f"There should be no NaNs inside the segments") - self._train_init_dict[current_segment] = cur_series[: self.period] + train_init_dict[current_segment] = cur_series[: self.period] + + self._train_init_dict = train_init_dict + self._train_timestamp = fit_df.index self._test_init_df = fit_df.iloc[-self.period :, :] # make multiindex levels consistent self._test_init_df.columns = self._test_init_df.columns.remove_unused_levels() @@ -113,21 +123,15 @@ def transform(self, df: pd.DataFrame) -> pd.DataFrame: Returns ------- - result: pd.Dataframe + result: transformed dataframe """ - if self._train_init_dict is None or self._test_init_df is None or self._train_timestamp is None: - raise AttributeError("Transform is not fitted") - segments = sorted(set(df.columns.get_level_values("segment"))) transformed = df.loc[:, pd.IndexSlice[segments, self.in_column]].copy() for current_segment in segments: to_transform = transformed.loc[:, pd.IndexSlice[current_segment, self.in_column]] - start_idx = to_transform.first_valid_index() # make a differentiation - transformed.loc[start_idx:, pd.IndexSlice[current_segment, self.in_column]] = to_transform.loc[ - start_idx: - ].diff(periods=self.period) + transformed.loc[:, pd.IndexSlice[current_segment, self.in_column]] = to_transform.diff(periods=self.period) if self.inplace: result_df = df.copy() @@ -184,12 +188,9 @@ def _reconstruct_test(self, df: pd.DataFrame, columns_to_inverse: Set[str]) -> p to_transform = df.loc[:, pd.IndexSlice[segments, column]].copy() init_df = self._test_init_df.copy() # type: ignore init_df.columns.set_levels([column], level="feature", inplace=True) + init_df = init_df[segments] to_transform = pd.concat([init_df, to_transform]) - # validate values inside the series to transform - if to_transform.isna().sum().sum() > 0: - raise ValueError(f"There should be no NaNs inside the segments") - # run reconstruction and save the result to_transform = self._make_inv_diff(to_transform) result_df.loc[:, pd.IndexSlice[segments, column]] = to_transform @@ -206,11 +207,18 @@ def inverse_transform(self, df: pd.DataFrame) -> pd.DataFrame: Returns ------- - result: pd.DataFrame + result: transformed DataFrame. + + Raises + ------ + ValueError: + if inverse transform is applied not to full train nor to test that goes after train + ValueError: + if inverse transform is applied to test that goes after train with gap """ - if self._train_init_dict is None or self._test_init_df is None or self._train_timestamp is None: - raise AttributeError("Transform is not fitted") + # we assume this to be fitted + self._train_timestamp = cast(pd.DatetimeIndex, self._train_timestamp) if not self.inplace: return df @@ -239,7 +247,8 @@ def inverse_transform(self, df: pd.DataFrame) -> pd.DataFrame: class DifferencingTransform(Transform): """Calculate a time series differences. - This transform can work with NaNs at the beginning of the segment, but fails when meets NaN inside the segment. + During ``fit`` this transform can work with NaNs at the beginning of the segment, but fails when meets NaN inside the segment. + During ``transform`` and ``inverse_transform`` there is no special treatment of NaNs. Notes ----- @@ -311,6 +320,7 @@ def __init__( self._differencing_transforms.append( _SingleDifferencingTransform(in_column=result_out_column, period=self.period, inplace=True) ) + self._fit_segments: Optional[List[str]] = None def _get_column_name(self) -> str: if self.inplace: @@ -331,13 +341,23 @@ def fit(self, df: pd.DataFrame) -> "DifferencingTransform": Returns ------- result: DifferencingTransform + + Raises + ------ + ValueError: + if NaNs are present inside the segment """ # this is made because transforms of high order may need some columns created by transforms of lower order result_df = df.copy() for transform in self._differencing_transforms: result_df = transform.fit_transform(result_df) + self._fit_segments = df.columns.get_level_values("segment").unique().tolist() return self + def _check_is_fitted(self): + if self._fit_segments is None: + raise ValueError("Transform is not fitted!") + def transform(self, df: pd.DataFrame) -> pd.DataFrame: """Make a differencing transformation. @@ -348,9 +368,21 @@ def transform(self, df: pd.DataFrame) -> pd.DataFrame: Returns ------- - result: pd.Dataframe + result: transformed dataframe + + Raises + ------ + ValueError: + if transform isn't fitted + NotImplementedError: + if there are segments that weren't present during training """ + self._check_is_fitted() + segments = df.columns.get_level_values("segment").unique().tolist() + if self.inplace: + check_new_segments(transform_segments=segments, fit_segments=self._fit_segments) + result_df = df.copy() for transform in self._differencing_transforms: result_df = transform.transform(result_df) @@ -366,12 +398,27 @@ def inverse_transform(self, df: pd.DataFrame) -> pd.DataFrame: Returns ------- - result: pd.DataFrame + result: transformed DataFrame. + + Raises + ------ + ValueError: + if transform isn't fitted + NotImplementedError: + if there are segments that weren't present during training + ValueError: + if inverse transform is applied not to full train nor to test that goes after train + ValueError: + if inverse transform is applied to test that goes after train with gap """ + self._check_is_fitted() if not self.inplace: return df + segments = df.columns.get_level_values("segment").unique().tolist() + check_new_segments(transform_segments=segments, fit_segments=self._fit_segments) + result_df = df.copy() for transform in self._differencing_transforms[::-1]: result_df = transform.inverse_transform(result_df) diff --git a/etna/transforms/math/sklearn.py b/etna/transforms/math/sklearn.py index bd32db9d6..c4c56aee4 100644 --- a/etna/transforms/math/sklearn.py +++ b/etna/transforms/math/sklearn.py @@ -4,6 +4,7 @@ from typing import List from typing import Optional from typing import Union +from typing import cast import numpy as np import pandas as pd @@ -12,6 +13,7 @@ from etna.core import StringEnumWithRepr from etna.datasets import set_columns_wide from etna.transforms.base import Transform +from etna.transforms.utils import check_new_segments from etna.transforms.utils import match_target_quantiles @@ -72,6 +74,7 @@ def __init__( self.out_column = out_column self.out_columns: Optional[List[str]] = None + self._fit_segments: Optional[List[str]] = None def _get_column_name(self, in_column: str) -> str: if self.out_column is None: @@ -104,10 +107,11 @@ def fit(self, df: pd.DataFrame) -> "SklearnTransform": else: self.out_columns = [self._get_column_name(column) for column in self.in_column] + self._fit_segments = df.columns.get_level_values("segment").unique().tolist() if self.mode == TransformMode.per_segment: x = df.loc[:, pd.IndexSlice[:, self.in_column]].values elif self.mode == TransformMode.macro: - x = self._reshape(df) + x = self._preprocess_macro(df) else: raise ValueError(f"'{self.mode}' is not a valid TransformMode.") @@ -127,23 +131,26 @@ def transform(self, df: pd.DataFrame) -> pd.DataFrame: ------- : transformed DataFrame. + + Raises + ------ + ValueError: + If transform isn't fitted. + NotImplementedError: + If there are segments that weren't present during training. """ - df = df.sort_index(axis=1) - segments = sorted(set(df.columns.get_level_values("segment"))) + if self._fit_segments is None: + raise ValueError("The transform isn't fitted!") + else: + self.in_column = cast(List[str], self.in_column) - if self.mode == TransformMode.per_segment: - x = df.loc[:, pd.IndexSlice[:, self.in_column]].values - transformed = self.transformer.transform(X=x) + df = df.sort_index(axis=1) + transformed = self._make_transform(df) - elif self.mode == TransformMode.macro: - x = self._reshape(df) - transformed = self.transformer.transform(X=x) - transformed = self._inverse_reshape(df, transformed) - else: - raise ValueError(f"'{self.mode}' is not a valid TransformMode.") if self.inplace: df.loc[:, pd.IndexSlice[:, self.in_column]] = transformed else: + segments = sorted(set(df.columns.get_level_values("segment"))) transformed_features = pd.DataFrame( transformed, columns=df.loc[:, pd.IndexSlice[:, self.in_column]].columns, index=df.index ).sort_index(axis=1) @@ -166,10 +173,20 @@ def inverse_transform(self, df: pd.DataFrame) -> pd.DataFrame: ------- : transformed DataFrame. + + Raises + ------ + ValueError: + If transform isn't fitted. + NotImplementedError: + If there are segments that weren't present during training. """ + if self._fit_segments is None: + raise ValueError("The transform isn't fitted!") + else: + self.in_column = cast(List[str], self.in_column) + df = df.sort_index(axis=1) - if self.in_column is None: - raise ValueError("Transform is not fitted yet.") if "target" in self.in_column: quantiles = match_target_quantiles(set(df.columns.get_level_values("feature"))) @@ -178,60 +195,85 @@ def inverse_transform(self, df: pd.DataFrame) -> pd.DataFrame: if self.inplace: quantiles_arrays: Dict[str, pd.DataFrame] = dict() + transformed = self._make_inverse_transform(df) - if self.mode == TransformMode.per_segment: - x = df.loc[:, pd.IndexSlice[:, self.in_column]].values - transformed = self.transformer.inverse_transform(X=x) - - # quantiles inverse transformation - for quantile_column_nm in quantiles: - df_slice_copy = df.loc[:, pd.IndexSlice[:, self.in_column]].copy() - df_slice_copy = set_columns_wide( - df_slice_copy, df, features_left=["target"], features_right=[quantile_column_nm] - ) - transformed_quantile = self.transformer.inverse_transform(X=df_slice_copy) - df_slice_copy.loc[:, pd.IndexSlice[:, self.in_column]] = transformed_quantile - quantiles_arrays[quantile_column_nm] = df_slice_copy.loc[:, pd.IndexSlice[:, "target"]].rename( - columns={"target": quantile_column_nm} - ) - - elif self.mode == TransformMode.macro: - x = self._reshape(df) - transformed = self.transformer.inverse_transform(X=x) - transformed = self._inverse_reshape(df, transformed) - - # quantiles inverse transformation - for quantile_column_nm in quantiles: - df_slice_copy = df.loc[:, pd.IndexSlice[:, self.in_column]].copy() - df_slice_copy = set_columns_wide( - df_slice_copy, df, features_left=["target"], features_right=[quantile_column_nm] - ) - df_slice_copy_reshaped_array = self._reshape(df_slice_copy) - transformed_quantile = self.transformer.inverse_transform(X=df_slice_copy_reshaped_array) - inverse_reshaped_quantile = self._inverse_reshape(df_slice_copy, transformed_quantile) - df_slice_copy.loc[:, pd.IndexSlice[:, self.in_column]] = inverse_reshaped_quantile - quantiles_arrays[quantile_column_nm] = df_slice_copy.loc[:, pd.IndexSlice[:, "target"]].rename( - columns={"target": quantile_column_nm} - ) - - else: - raise ValueError(f"'{self.mode}' is not a valid TransformMode.") - df.loc[:, pd.IndexSlice[:, self.in_column]] = transformed + # quantiles inverse transformation + for quantile_column_nm in quantiles: + df_slice_copy = df.loc[:, pd.IndexSlice[:, self.in_column]].copy() + df_slice_copy = set_columns_wide( + df_slice_copy, df, features_left=["target"], features_right=[quantile_column_nm] + ) + transformed_quantile = self._make_inverse_transform(df_slice_copy) + df_slice_copy.loc[:, pd.IndexSlice[:, self.in_column]] = transformed_quantile + quantiles_arrays[quantile_column_nm] = df_slice_copy.loc[:, pd.IndexSlice[:, "target"]].rename( + columns={"target": quantile_column_nm} + ) + df.loc[:, pd.IndexSlice[:, self.in_column]] = transformed for quantile_column_nm in quantiles: df.loc[:, pd.IndexSlice[:, quantile_column_nm]] = quantiles_arrays[quantile_column_nm].values + return df - def _reshape(self, df: pd.DataFrame) -> np.ndarray: + def _preprocess_macro(self, df: pd.DataFrame) -> np.ndarray: segments = sorted(set(df.columns.get_level_values("segment"))) x = df.loc[:, pd.IndexSlice[:, self.in_column]] x = pd.concat([x[segment] for segment in segments]).values return x - def _inverse_reshape(self, df: pd.DataFrame, transformed: np.ndarray) -> np.ndarray: + def _postprocess_macro(self, df: pd.DataFrame, transformed: np.ndarray) -> np.ndarray: time_period_len = len(df) n_segments = len(set(df.columns.get_level_values("segment"))) transformed = np.concatenate( [transformed[i * time_period_len : (i + 1) * time_period_len, :] for i in range(n_segments)], axis=1 ) return transformed + + def _preprocess_per_segment(self, df: pd.DataFrame) -> np.ndarray: + self._fit_segments = cast(List[str], self._fit_segments) + transform_segments = df.columns.get_level_values("segment").unique().tolist() + check_new_segments(transform_segments=transform_segments, fit_segments=self._fit_segments) + + df = df.loc[:, pd.IndexSlice[:, self.in_column]] + to_add_segments = set(self._fit_segments) - set(transform_segments) + df_to_add = pd.DataFrame(index=df.index, columns=pd.MultiIndex.from_product([to_add_segments, self.in_column])) + df = pd.concat([df, df_to_add], axis=1) + df = df.sort_index(axis=1) + return df.values + + def _postprocess_per_segment(self, df: pd.DataFrame, transformed: np.ndarray) -> np.ndarray: + self._fit_segments = cast(List[str], self._fit_segments) + self.in_column = cast(List[str], self.in_column) + num_features = len(self.in_column) + transform_segments = set(df.columns.get_level_values("segment")) + select_segments = [segment in transform_segments for segment in self._fit_segments] + # make a mask for columns to select + select_columns = np.repeat(select_segments, num_features) + result = transformed[:, select_columns] + return result + + def _make_transform(self, df: pd.DataFrame) -> np.ndarray: + if self.mode == TransformMode.per_segment: + x = self._preprocess_per_segment(df) + transformed = self.transformer.transform(X=x) + transformed = self._postprocess_per_segment(df, transformed) + elif self.mode == TransformMode.macro: + x = self._preprocess_macro(df) + transformed = self.transformer.transform(X=x) + transformed = self._postprocess_macro(df, transformed) + else: + raise ValueError(f"'{self.mode}' is not a valid TransformMode.") + return transformed + + def _make_inverse_transform(self, df: pd.DataFrame) -> np.ndarray: + if self.mode == TransformMode.per_segment: + x = self._preprocess_per_segment(df) + transformed = self.transformer.inverse_transform(X=x) + transformed = self._postprocess_per_segment(df, transformed) + elif self.mode == TransformMode.macro: + x = self._preprocess_macro(df) + transformed = self.transformer.inverse_transform(X=x) + transformed = self._postprocess_macro(df, transformed) + else: + raise ValueError(f"'{self.mode}' is not a valid TransformMode.") + return transformed diff --git a/etna/transforms/missing_values/resample.py b/etna/transforms/missing_values/resample.py index 46827a31a..3322be686 100644 --- a/etna/transforms/missing_values/resample.py +++ b/etna/transforms/missing_values/resample.py @@ -135,13 +135,13 @@ def __init__( self.in_column = in_column self.distribution_column = distribution_column self.inplace = inplace - self.out_column = self._get_out_column(out_column) + self.out_column = out_column super().__init__( transform=_OneSegmentResampleWithDistributionTransform( in_column=in_column, distribution_column=distribution_column, inplace=inplace, - out_column=self.out_column, + out_column=self._get_out_column(self.out_column), ) ) diff --git a/etna/transforms/outliers/base.py b/etna/transforms/outliers/base.py index d68075f33..51d928cc0 100644 --- a/etna/transforms/outliers/base.py +++ b/etna/transforms/outliers/base.py @@ -9,6 +9,7 @@ from etna.datasets import TSDataset from etna.transforms.base import Transform +from etna.transforms.utils import check_new_segments class OutliersTransform(Transform, ABC): @@ -26,6 +27,7 @@ def __init__(self, in_column: str): self.in_column = in_column self.outliers_timestamps: Optional[Dict[str, List[pd.Timestamp]]] = None self.original_values: Optional[Dict[str, List[pd.Timestamp]]] = None + self._fit_segments: Optional[List[str]] = None def _save_original_values(self, ts: TSDataset): """ @@ -61,6 +63,7 @@ def fit(self, df: pd.DataFrame) -> "OutliersTransform": ts = TSDataset(df, freq=pd.infer_freq(df.index)) self.outliers_timestamps = self.detect_outliers(ts) self._save_original_values(ts) + self._fit_segments = ts.segments return self @@ -75,14 +78,25 @@ def transform(self, df: pd.DataFrame) -> pd.DataFrame: Returns ------- - result: pd.DataFrame + result: dataframe with in_column series with filled with NaNs + + Raises + ------ + ValueError: + If transform isn't fitted. + NotImplementedError: + If there are segments that weren't present during training. """ if self.outliers_timestamps is None: raise ValueError("Transform is not fitted! Fit the Transform before calling transform method.") result_df = df.copy() - for segment in df.columns.get_level_values("segment").unique(): - result_df.loc[self.outliers_timestamps[segment], pd.IndexSlice[segment, self.in_column]] = np.NaN + segments = df.columns.get_level_values("segment").unique().tolist() + check_new_segments(transform_segments=segments, fit_segments=self._fit_segments) + for segment in segments: + # to locate only present indices + segment_outliers_timestamps = result_df.index.intersection(self.outliers_timestamps[segment]) + result_df.loc[segment_outliers_timestamps, pd.IndexSlice[segment, self.in_column]] = np.NaN return result_df def inverse_transform(self, df: pd.DataFrame) -> pd.DataFrame: @@ -96,13 +110,22 @@ def inverse_transform(self, df: pd.DataFrame) -> pd.DataFrame: Returns ------- - result: pd.DataFrame + result: data with reconstructed values + + Raises + ------ + ValueError: + If transform isn't fitted. + NotImplementedError: + If there are segments that weren't present during training. """ if self.original_values is None or self.outliers_timestamps is None: raise ValueError("Transform is not fitted! Fit the Transform before calling inverse_transform method.") result = df.copy() - for segment in self.original_values.keys(): + segments = df.columns.get_level_values("segment").unique().tolist() + check_new_segments(transform_segments=segments, fit_segments=self._fit_segments) + for segment in segments: segment_ts = result[segment, self.in_column] segment_ts[segment_ts.index.isin(self.outliers_timestamps[segment])] = self.original_values[segment] return result diff --git a/etna/transforms/timestamp/special_days.py b/etna/transforms/timestamp/special_days.py index 265257b96..8db6c8469 100644 --- a/etna/transforms/timestamp/special_days.py +++ b/etna/transforms/timestamp/special_days.py @@ -1,4 +1,6 @@ import datetime +from typing import Any +from typing import Dict from typing import Optional from typing import Tuple @@ -55,6 +57,7 @@ def __init__(self, find_special_weekday: bool = True, find_special_month_day: bo self.anomaly_week_days: Optional[Tuple[int]] = None self.anomaly_month_days: Optional[Tuple[int]] = None + self.res_type: Dict[str, Any] if self.find_special_weekday and find_special_month_day: self.res_type = {"df_sample": (0, 0), "columns": ["anomaly_weekdays", "anomaly_monthdays"]} elif self.find_special_weekday: diff --git a/etna/transforms/utils.py b/etna/transforms/utils.py index 3e6615257..8b491c752 100644 --- a/etna/transforms/utils.py +++ b/etna/transforms/utils.py @@ -1 +1,17 @@ +import reprlib +from typing import List +from typing import Optional + from etna.datasets.utils import match_target_quantiles # noqa: F401 + + +def check_new_segments(transform_segments: List[str], fit_segments: Optional[List[str]]): + """Check if there are any new segments that weren't present during training.""" + if fit_segments is None: + raise ValueError("Transform is not fitted!") + + new_segments = set(transform_segments) - set(fit_segments) + if len(new_segments) > 0: + raise NotImplementedError( + f"This transform can't process segments that weren't present on train data: {reprlib.repr(new_segments)}" + ) diff --git a/examples/inference.ipynb b/examples/inference.ipynb index 9bd3934bf..9d6777deb 100644 --- a/examples/inference.ipynb +++ b/examples/inference.ipynb @@ -230,7 +230,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -644,7 +644,7 @@ "id": "59012669", "metadata": {}, "source": [ - "Here we explicitly set `ts=new_ts` in `load` function in order to pass it inside our `pipeline_loaded`. Otherwise, `pipeline_loaded` doesn't have any `ts` to work with.\n", + "Here we explicitly set `ts=new_ts` in `load` function in order to pass it inside our `pipeline_loaded`. Otherwise, `pipeline_loaded` doesn't have `ts` to forecast and we should explicitly call `forecast(ts=new_ts)` for making a forecast.\n", "\n", "We can also load saved model and transoform using `load`, but we shouldn't set `ts` parameter, because models and transforms don't need it." ] @@ -722,7 +722,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAB9sAAAPzCAYAAAAXr2wFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeXhU5fn/8ffMJDPZ94QkbGHfN9lEUBERwaVVsYu1Vq2tXbBW/dVWu6r9Vltra9Xa1qpVu1hb17qhgGyCCIiA7BBIWBMSsu+Z5fz+OJkJgSRkmS3k87ouLsjMmXOemTlM5jn3c9+3xTAMAxEREREREREREREREREREekwa6gHICIiIiIiIiIiIiIiIiIi0tMo2C4iIiIiIiIiIiIiIiIiItJJCraLiIiIiIiIiIiIiIiIiIh0koLtIiIiIiIiIiIiIiIiIiIinaRgu4iIiIiIiIiIiIiIiIiISCcp2C4iIiIiIiIiIiIiIiIiItJJCraLiIiIiIiIiIiIiIiIiIh0koLtIiIiIiIiIiIiIiIiIiIinaRgu4iIiIiIiIiIiIiIiIiISCcp2C4iIiIiIiIiIiIiIn6Rn5+PxWLhkUceCfVQREREAk7BdhEREQkbDz74IG+88UaohyEiIiIiIiLS62mOLiIicmYKtouIiEjY0EReREREREREJDxoji4iInJmCraLiIiIiIiIiIiIiIiIiIh0koLtIiIiYaCqqoo77riDnJwcHA4HGRkZXHLJJXz66ae+bdavX8/8+fNJTEwkJiaGCy+8kLVr1562r5UrVzJlyhSioqIYMmQITz31FPfddx8Wi6XFdhaLhdtuu42XX36Z0aNHEx0dzYwZM9i2bRsATz31FEOHDiUqKorZs2eTn59/2rE6MibvsXNzc7nppptISkoiMTGRm2++mdra2hbjqamp4YUXXsBisWCxWLjppps6/Bp6PB4ee+wxxo0bR1RUFOnp6cyfP59PPvmkw/sQERERERER0Ry9+3N0r0cffZSBAwcSHR3NhRdeyPbt2zu9DxERkXAWEeoBiIiICHz729/mlVde4bbbbmP06NGUlJSwZs0adu3axTnnnMPy5ctZsGABkydP5he/+AVWq5XnnnuOOXPm8OGHHzJt2jQANm/ezPz588nKyuL+++/H7XbzwAMPkJ6e3upxP/zwQ958800WLVoEwEMPPcQVV1zBD3/4Q/70pz/x3e9+l7KyMh5++GG+/vWvs3z5ct9jOzomry9+8YsMGjSIhx56iE8//ZRnnnmGjIwMfvOb3wDwj3/8g2984xtMmzaNW2+9FYAhQ4Z0+DW85ZZbeP7551mwYAHf+MY3cLlcfPjhh3z88cdMmTKl42+GiIiIiIiI9Gqao3d/jg7w97//naqqKhYtWkR9fT2PPfYYc+bMYdu2bfTp06dT+xIREQlbhoiIiIRcYmKisWjRolbv83g8xrBhw4xLL73U8Hg8vttra2uNQYMGGZdcconvtiuvvNKIiYkxjh496rtt3759RkREhHHqr33AcDgcRl5enu+2p556ygCMzMxMo7Ky0nf7vffeawC+bTszpl/84hcGYHz9619vcfyrr77aSE1NbXFbbGysceONN7bxKrVt+fLlBmDcfvvtp9138vhEREREREREzkRzdFNX5+h5eXkGYERHRxtHjhzx3b5+/XoDMO68885O71NERCRcqYy8iIhIGEhKSmL9+vUcO3bstPu2bNnCvn37+MpXvkJJSQknTpzgxIkT1NTUcPHFF7N69Wo8Hg9ut5tly5Zx1VVXkZ2d7Xv80KFDWbBgQavHvfjii8nJyfH9PH36dAAWLlxIfHz8abcfOHCgU2M62be//e0WP59//vmUlJRQWVnZiVeqda+++ioWi4Vf/OIXp913amk+ERERERERkfZoju4fV111FX379vX9PG3aNKZPn867777rt2OIiIiEmsrIi4iIhIGHH36YG2+8kf79+zN58mQuu+wyvva1rzF48GD27dsHwI033tjm4ysqKqivr6euro6hQ4eedn9rtwEMGDCgxc+JiYkA9O/fv9Xby8rKADo8puTk5DaP5b2vrKyMhISENvfTEfv37yc7O5uUlJRu7UdEREREREREc/TuzdG9hg0bdtptw4cP57///a9f9i8iIhIOFGwXEREJA1/84hc5//zzef3111myZAm//e1v+c1vfsNrr73mW33+29/+lokTJ7b6+Li4OOrr6zt9XJvN1qnbDcMA6PCYOrNPERERERERkXCgObqIiIh0lILtIiIiYSIrK4vvfve7fPe736WoqIhzzjmHX/3qVzz66KMAJCQkMHfu3DYfn5GRQVRUFLm5uafd19pt3TFkyJAOjamzulryfciQIbz//vuUlpYqu11ERERERES6TXP07rdl82bcn2zv3r0tSuWLiIj0dOrZLiIiEmJut5uKiooWt2VkZJCdnU1DQwOTJ09myJAhPPLII1RXV5/2+OLiYsBclT537lzeeOONFn3lcnNzWbx4sV/H3NExdVZsbCzl5eWdftzChQsxDIP777//tPu0Kl9EREREREQ6SnP0Zl2do3u98cYbHD161Pfzhg0bWL9+fZs960VERHoiZbaLiIiEWFVVFf369ePaa69lwoQJxMXFsWzZMjZu3Mjvfvc7rFYrzzzzDAsWLGDMmDHcfPPN9O3bl6NHj7JixQoSEhJ46623ALjvvvtYsmQJM2fO5Dvf+Q5ut5s//vGPjB07li1btvhtzJ0ZU2dMnjyZZcuW8fvf/57s7GwGDRrE9OnTz/i4iy66iBtuuIHHH3+cffv2MX/+fDweDx9++CEXXXQRt912W1eepoiIiIiIiPQymqM36+oc3Wvo0KHMmjWL73znOzQ0NPCHP/yB1NRUfvjDH3Z6LCIiIuFKwXYREZEQi4mJ4bvf/S5Llizx9X8bOnQof/rTn/jOd74DwOzZs1m3bh2//OUv+eMf/0h1dTWZmZlMnz6db33rW759TZ48mcWLF/ODH/yAn/3sZ/Tv358HHniAXbt2sXv3br+Ou6Nj6ozf//733Hrrrfz0pz+lrq6OG2+8scMT+eeee47x48fz7LPPcvfdd5OYmMiUKVM477zzujQWERERERER6X00R2/WnTk6wNe+9jWsVit/+MMfKCoqYtq0afzxj38kKyurS+MREREJRxZDtVVFRETOeldddRU7duxotV+aiIiIiIiIiASP5ugiIiJnD/VsFxEROcvU1dW1+Hnfvn28++67zJ49OzQDEhEREREREemlNEcXERE5uymzXURE5CyTlZXFTTfdxODBgzl48CB//vOfaWhoYPPmzQwbNizUw+sUt9tNcXFxu9vExcURFxcXpBGJiIiIiIiIdJzm6CIiImc39WwXERE5y8yfP59///vfFBYW4nA4mDFjBg8++GCPm8QDHD58mEGDBrW7zS9+8Qvuu+++4AxIREREREREpBM0RxcRETm7KbNdREREwlZ9fT1r1qxpd5vBgwczePDgII1IREREREREpHfSHF1EROR0CraLiIiIiIiIiIiIiIiIiIh0kjXUAxAREREREREREREREREREelpztqe7R6Ph2PHjhEfH4/FYgn1cERERERERETaZBgGVVVVZGdnY7WefeviNUcXERERERGRnqSj8/SzNth+7Ngx+vfvH+phiIiIiIiIiHTY4cOH6devX6iH4Xeao4uIiIiIiEhPdKZ5+lkbbI+PjwfMFyAhISEkY3A6nSxZsoR58+YRGRkZkjFIeNK5IcGic03aonNDwonOR2mLzg0JlnA41yorK+nfv79vLnu2CYc5OoTHey3hSeeGBIPOM2mPzg8JJzofpS06NyQYwuU86+g8/awNtnvL0iUkJIQ02B4TE0NCQoI+dKQFnRsSLDrXpC06NySc6HyUtujckGAJp3PtbC2xHg5zdAiv91rCi84NCQadZ9IenR8STnQ+Slt0bkgwhNt5dqZ5+tnXCE5ERERERERERERERERERCTAFGwXERERERERERERERERERHpJAXbRUREREREREREREREREREOums7dneEYZh4HK5cLvdAdm/0+kkIiKC+vr6gB3jbGWz2YiIiDhr+xWKiIiIiIhIS4Geo4Pm6d2hebqIiIiIiMjpem2wvbGxkYKCAmprawN2DMMwyMzM5PDhw5qMdkFMTAxZWVnY7fZQD0VEREREREQCKBhzdNA8vbs0TxcREREREWmpVwbbPR4PeXl52Gw2srOzsdvtAZlkezweqquriYuLw2pVxf6OMgyDxsZGiouLycvLY9iwYXr9REREREREzlLBmqN7j6V5eudpni4iIiIiItK6Xhlsb2xsxOPx0L9/f2JiYgJ2HI/HQ2NjI1FRUZqEdlJ0dDSRkZEcPHjQ9xqKiIiIiIjI2SdYc3TQPL07NE8XERERERE5Xa+eWWpiHd70/oiIiIiIiPQemgOGP71HIiIiIiIiLWmWJCIiIiIiIiIiIiIiIiIi0kkKtouIiIiIiIiIiIiIiIiIiHSSgu29WE5ODn/4wx9CPQwRERERERGRXk9zdBERERERkZ4nItQDkM6ZPXs2EydO9MsEfOPGjcTGxnZ/UCIiIiIiIiK9kOboIiIiIiIivZuC7WcZwzBwu91ERJz5rU1PTw/CiERERERERER6J83RRUREREREzm4qI485+a1tdAXkT12ju937DcPo8DhvuukmVq1axWOPPYbFYsFisfD8889jsVhYvHgxkydPxuFwsGbNGvbv38/nP/95+vTpQ1xcHFOnTmXZsmUt9ndqiTqLxcIzzzzD1VdfTUxMDMOGDePNN9/018ssIiIiIiJyRtv+vY0jHx8J9TAkxHrCPF1zdBERERGRwNvywhaOfXIs1MMQaZMy24E6p5vRP38/JMfe+cClxNg79jY89thj7N27l7Fjx/LAAw8AsGPHDgDuueceHnnkEQYPHkxycjKHDx/msssu41e/+hUOh4O///3vXHnllezZs4cBAwa0eYz777+fhx9+mN/+9rc88cQTXH/99Rw8eJCUlJTuP1kREREREZF2HPvkGK995TUSByZyR/4doR6OhFBPmKdrji4iIiIiEljHPzvO/276HzHpMdx15C5sdluohyRyGmW29yCJiYnY7XZiYmLIzMwkMzMTm838YHnggQe45JJLGDJkCCkpKUyYMIFvfetbjB07lmHDhvHLX/6SIUOGnHEV/E033cR1113H0KFDefDBB6murmbDhg3BeHoiIiIiItLL5S3PA6DiYAXOWmeIRyPSPs3RRUREREQCq7qwGoDa4lr2Ld4X4tGItE6Z7UB0pI2dD1zq9/16PB6qKquIT4jHam19XUN0pH9W4UyZMqXFz9XV1dx333288847FBQU4HK5qKur49ChQ+3uZ/z48b5/x8bGkpCQQFFRkV/GKCIiIiIi0p6Dqw/6/l1+sJz0Ueph3Vv19Hm65ugiIiIiIt138iLsrS9sZeTnR4ZwNCKtU7Adsw9aR0u5d4bH48FltxFjj2hzEu8vsbGxLX7+wQ9+wNKlS3nkkUcYOnQo0dHRXHvttTQ2Nra7n8jIyBY/WywWPB6P38crIiIiIiJyMo/bw6E1zYHH8nwF23uznj5P1xxdRERERKT7Gmuavy/vfXsvtSW1xKTGhHBEIqdTsL2HsdvtuN3uM263du1abrrpJq6++mrAXEWfn58f4NGJiIiIiIh0TdH2IhoqGnw/l+eXh24wIh2kObqIiIiISOA4a5oz2z1OD9v/vZ1pt00L4YhETqee7T1MTk4O69evJz8/nxMnTrS5on3YsGG89tprbNmyha1bt/KVr3xFq99FRERERCRsHfqwZTltBdulJ9AcXUREREQkcLyZ7dYIM5y59YWtoRyOSKsUbO9hfvCDH2Cz2Rg9ejTp6elt9nf7/e9/T3JyMueddx5XXnkll156Keecc06QRysiIiIiItIx3n7tsX3M8tvleeUhHI1Ix2iOLiIiIiKh4nF58LjO7gWc3sz2YZcPwxph5dgnxyjeWRziUYm0pDLyPczw4cNZt25di9tuuumm07bLyclh+fLlLW5btGhRi59PLVlnGMZp+ykvL+/SOEVERERERDrKMAxfsH3c9eP4+PcfK7NdegTN0UVEREQkFOrL63ly1JOkjUrjax98DYvFEuohBYQ3sz0pJ4lhlw1jz5t72PLCFi75zSUhHplIM2W2i4iIiIiISEiV5pZSc7wGm93GmC+MAVRGXkREREREpC0HPzxIdWE1+SvyKd5x9mZ6ezPbI2MjmXDTBAA++8dn4ZHR31gLHz0Bag/V6ynYLiIiIiIiIiHlzWrvO70vaSPTAKgtrvVlMYiIiIiIiEizgk0Fvn/vfHVnCEcSWN45oT3WzvDLhxOdGk11QTUHlh0I8ciAfUtgyU+hJDfUI5EQU7BdREREREREQurQh2af6wHnDyAqKYqopChA2e0iIiIiIiKtOTnYvuvVXd3eX+n+Uva+vbfVVkahdHJmu81uY+x1YwHY+sLWUA7LVLzb/LuhKrTjkJBTsF1ERERERERCypvZPvCCgYDZjw8UbBcREREREWnNsU3HfP8u2lZEyd6SLu/L8Bj8a8G/+PeV/+a/1/yX+vJ6fwzRL3zB9phIACbeOBGA3W/spr4ixOMsalrk0Khge2+nYLuIiIiIiIiETOWRSsrzyrFYLfSf0R9QsF1ERERERKQtVceqqC6oxmK1MGDWAKB7peQPrTlE6b5SwAxi/3XKXyncUuiXsXbXyWXkAbImZ5E+Oh1XvYsd/90RyqEps118FGwXERERERGRkDn4oZnVnjkpE0eCA4DEnERAwXYREREREZFTebPa00alMf6G8UD3SslveWELAIMuHkTiwETK9pfx7Ixn2fy3zd0ea3c5a5vLyANYLBYm3DgBCHEpebezuVd7Q3XoxiFhQcF2ERERERERCRlvCfkB5w/w3ZY8KBmA8rzyUAxJREREREQkbHn7tWdPzmbkVSOxWC0UbCro0mJlZ62TnS+bWfEX/vxCvvXptxh22TBc9S7evOVN/nfL/3DWOf05/M6Nr6mMvDezHWD8V8djsVo4vPYwpbmloRlYyX7wuMx/NyrY3tsp2C4iIiIiIiIhc+jDQ0Bzv3ZQGXkREREREZG2eIPtWZOziM2I9c2ldr3W+ez2Xa/vorGqkaRBSQyYNYDolGiue+s6Lvq/i7BYLWz52xb+dt7fKN0fmqC2t4y8N7MdID47nsGXDAZg699DlN1e3PRa2+zQUBmaMUjYULBdREREREREQqK2pJbiHcUAvl6DoGC7iIiIiIhIW7xl5LMmZwEwauEooGul5L2l2Cd8bQIWqwUAi9XCBT+5gK8u+Sox6TEUbinkr5P/yu43dvtj+J3SWmY7wMSbJgLm+A2PEexhQdFuiEmD+CyVkRcF20VERERERCQ0Dq0xs9rTRqURmx7ru90bbK8rqaOhqiEUQxMREREREQk7VceqqC6oxmK1kDkxE4CRV48E4PBHh6k82vEs64rDFRxYdgAwg+2nGnzxYL61+Vv0P68/DRUN/Ofq/7D8nuUY7uAFt1vLbAcY8fkROBIdVByqIH9VftDG41O8GzJGgSMeGqqCf3wJKwq29zCzZ8/mjjvu8Nv+brrpJq666iq/7U9ERERERKSjvP3aTy4hD+BIcBCdEg0ou13Cm+boIiIiIhJM3qz2tFFpvmzvhL4J9D+vPwC7X+949vln//wMDBhw/gCSBye3uk1C3wRuXHkj5955LgAf//5jDv/pcHeeQocZhoGztvXM9sjoSMZ8cQzQnJ1/JpVHK/nHvH/wp7F/8gXxu6x4N6SPBHuceraLgu0iIiIiIiISGt5+7QPOH3DafSolLyIiIiIi0pK3X3v25OwWt3e2lLxhGL4gtbcke1tskTYu/f2lfO7ZzwFQsaGiM0PuMledC5qS6E/NbAeYcKOZjb/zlZ00VrcfPM9bnsdfz/krB5YeoHhHMYWbC7sxsEYoyYX0EcpsF0DBdsD8UGmsaQzIH2eNs937DaPj5TZuuukmVq1axWOPPYbFYsFisZCfn8/27dtZsGABcXFx9OnThxtuuIETJ074HvfKK68wbtw4oqOjSU1NZe7cudTU1HDffffxwgsv8L///c+3v5UrVwbgFRYREREREWmpsbqRgk/NC0WnZraDgu29XU+Yp2uOLiIiIiLB5g22e/u1e426xgy2H1x9kJqimjPu5+iGo5TsKSEiOoLR147u0LEHXzIYAHetu1Oxra46Ofs8Mub0YHv/8/qTMjQFZ42TXa+1vsjA8Bh8+OCH/OOSf7R4Xbo1zyzdDx5XUxn5OAXbhYhQDyAcOGudPBT3UEiOfW/1vaeVv2jLY489xt69exk7diwPPPAAAJGRkUybNo1vfOMbPProo9TV1fGjH/2IL37xiyxfvpyCggKuu+46Hn74Ya6++mqqqqr48MMPMQyDH/zgB+zatYvKykqee+45AFJSUgL2XEVERERERLwOrzuM4TZIHJhIYv/E0+5PzDFvU7C9d+oJ83TN0UVEREQk2Lxl5E8NtiflJJE1OYuCTQXsfmM3k2+d3O5+vFnto64ZhSPB0aFjRyVGmf9wg6vehd3esdhWVzlrzBLyEVERWG2n5w5bLBbGf208K3++kq0vbD2t73xdWR2v3/A6+97ZB8DEmyfiqnOx/aXtlB8s7/rAipoC++lNPdvLD3V9X3JW8Htm+0MPPcTUqVOJj48nIyODq666ij179rTYpr6+nkWLFpGamkpcXBwLFy7k+PHjLbY5dOgQl19+OTExMWRkZHD33Xfjcrn8PdweJTExEbvdTkxMDJmZmWRmZvLnP/+ZSZMm8eCDDzJy5EgmTZrE3/72N1asWMHevXspKCjA5XJxzTXXkJOTw7hx4/jud79LXFwccXFxREdH43A4fPsL9IejiIiIiIgItN2v3St5kNkzsDyvPFhDEukUzdFFREREJJiqjlVRXVCNxWohc2Lmafd3tJS8q8EMOENzKfaOsMfZwWL+u6GiocOP6ypvZntrJeS9Jtxgjj9vRR4Vh5rL2x/bdIy/nvNX9r2zD5vDxpXPXMnn//Z5UkemAt1c1F28B2LTITYV7CojLwHIbF+1ahWLFi1i6tSpuFwufvzjHzNv3jx27txJbGwsAHfeeSfvvPMOL7/8MomJidx2221cc801rF27FgC3283ll19OZmYmH330EQUFBXzta18jMjKSBx980N9DJjImknur7/X7fj0eD1WVVcQnxGO1tr6uobXSF52xdetWVqxYQVxc3Gn37d+/n3nz5nHxxRczbtw4Lr30UubNm8e1115LcnJyt44rIiIiIiLSHYdWt92vHVRGvrfrqfN0zdFFREREJFC8We1po9JarcQ0euFolv94OXnL86grqyM6ObrV/ex9ay/1ZfXE941n0JxBHT6+xWrBEe+gobKBhsrAB9u9me3tfT9PykkiZ3YO+Svz2fqPrZz/4/P59OlPWfy9xbgb3SQPTuYLr3yBrElZvu0BKvK70Xe+eBekjzT/7YiHhuqu70vOCn4Ptr/33nstfn7++efJyMhg06ZNXHDBBVRUVPDss8/y4osvMmfOHACee+45Ro0axccff8y5557LkiVL2LlzJ8uWLaNPnz5MnDiRX/7yl/zoRz/ivvvu8/vKbovF0uFS7p3h8XiIdEdij7W3OYnvrurqaq688kp+85vfnHZfVlYWNpuNpUuX8tFHH7FkyRKeeOIJfvKTn7B+/XoGDer4h6iIiIiIiIi/uBpcHFl/BGg7s13B9t6tp87TNUcXERERkUDx9mvPnpzd6v2pw1PJGJdB0bYi9ry5h4k3Tmx1uy3PbwFg/A3jWy3P3h57gp2GygYaqxrPvHE3OWvNYPuZ5gUTbpxgBtuf30rp3lK2/t0skT/icyO46oWriEqK8m3rl3lm0W4YdIH5b0ccNCrY3tsFvGd7RYW5OsTbZ2zTpk04nU7mzp3r22bkyJEMGDCAdevWce6557Ju3TrGjRtHnz59fNtceumlfOc732HHjh1MmjTptOM0NDTQ0NC8kqayshIAp9OJ0+lssa3T6cQwDDweDx6Px39P9hSGYfj+9tdxIiMjcblcvv1NmjSJ1157jQEDBhARcfrb6d1uxowZzJgxg5/+9KcMGjSI1157jTvvvPO0/YUTj8eDYRg4nU5sNluoh+NX3nPy1HNTxN90rklbdG5IONH5KG3RuXH2OrzuMO4GNzEZMSQMSmj1PY7ta1ZGqy+rp+pEVXN/wAAIh3NN53nPZLfbcbvdvp/POeccXn31VXJyclqdo4O5kGDmzJnMnDmTn//85wwcOJDXX3+du+6667T9iYiIiIh4eYPtp/ZrP9mohaMo2lbErld3tRpsrz5eTe57uQBtBuPb40hwUEUV9RX1nX5sZ3WkjDzA6GtH8+5t71KaW0ppbikWq4WLH7qY8+4+D4vF0mLbpIFJAFQcqsDwGFisllb22A5XI5Tuh+m3mj/b48wy8oYBlk7uS84aAQ22ezwe7rjjDmbOnMnYsWMBKCwsxG63k5SU1GLbPn36UFhY6Nvm5EC7937vfa156KGHuP/++0+7fcmSJcTExLS4LSIigszMTKqrq2lsDPzqm6oq//Vr6Nu3L+vWrWP79u3ExsZyww038PTTT/PFL36R22+/neTkZA4cOMBrr73G448/zubNm1m1ahVz5swhLS2NTZs2UVxczIABA6isrCQzM5P33nuPTZs2kZKSQkJCApGR3Stt7y+NjY3U1dWxevVqXC5XqIcTEEuXLg31EKSX0LkmbdG5IeFE56O0RefG2ef4K8cBiBwSyeLFi9vczpZgw13p5p1/vkP0oNZLIPpTKM+12trakB1bui4nJ4f169eTn59PXFwcixYt4umnn+a6667jhz/8ISkpKeTm5vLSSy/xzDPP8Mknn/DBBx8wb948MjIyWL9+PcXFxYwaNcq3v/fff589e/aQmppKYmJi2MzRRURERCS0vGXk2wu2j144mlX3rWL/+/tpqGzAkeBocf+2f23DcBv0ndaXtJFpnR6Dd3+NlUHIbK/pWGa7Pc7O6GtHs/WFrcT2ieXa/1xLzoU5rW6b0C8Bi82Cu9FNdWE18dnxnRtUSS54XJBufn/HEQ8Y0FhjZrlLrxTQYPuiRYvYvn07a9asCeRhALj33nu56667fD9XVlbSv39/5s2bR0JCQott6+vrOXz4MHFxcURFBS47wjAMqqqqiI+PP231TFfdc8893HzzzZx77rnU1dWxf/9+1qxZwz333MPChQtpaGhg4MCBXHrppSQlJZGVlcWGDRt46qmnqKysZODAgTzyyCMsXLgQgNtuu42PP/6YOXPmUF1dzQcffMDs2bP9Mtbuqq+vJzo6mgsuuCCg71MoOJ1Oli5dyiWXXKILJxJQOtekLTo3JJzofJS26Nw4e73055cAmPaFaUy9bGqb2x0fdpyCTQWM6z+O4ZcND9h4wuFc81Znk57lBz/4ATfeeCOjR4+mrq6OvLw81q5dy49+9CPmzZvnm6PPnz8fq9VKQkICq1ev5g9/+INvjv673/2OBQsWAPDNb36TlStXMmXKFKqrq1mxYkXYzNFFREREJHSqjlVRXVCNxWohc2Jmm9ulj0kndUQqJXtK2PvOXsZdN67F/VtfMEusT7hpQpfG4Ug0g+3B6Nne0cx2gEsevoTMiZmM+dIY4rPaDqBbI6wk9Eug4mAF5fnlnQ+2F+82/844OdiOmd2uYHuvFbBg+2233cbbb7/N6tWr6devn+/2zMxMGhsbKS8vb5Hdfvz4cTIzM33bbNiwocX+jh8/7ruvNQ6HA4fDcdrtkZGRp10scbvdWCwWrFZrwHqpQ3MJd++x/GHkyJGsW7futNtff/31VrcfM2YM77//fpv769OnT9hmClmtViwWS6vv4dnibH5uEl50rklbdG5IONH5KG3RuXF28bg9HPnI7Nc+aPagdt/b5EHJFGwqoOpIVVDOgVCeazrHe6bhw4e3Okd/7bXXWt1+1KhRvPfee23uLz09nSVLlvhtfCIiIiJydvBmtaeNSms309tisTBq4SjWPLiGXa/uahFsL9xSyPHPjmOz2xj7pbFdGocjPnjB9o5mtgPEZsRy7h3ndmi/STlJZrD9YDn9z+vfuUEV74bYdIgxW2f7gu3q296r+T3SbBgGt912G6+//jrLly9n0KBBLe6fPHkykZGRfPDBB77b9uzZw6FDh5gxYwZg9hfftm0bRUVFvm2WLl1KQkICo0eP9veQRUREREREJEiObz1OY1UjjgQHfcb3aXfbxJxEAMrzy4MwMhERERERkfDk7deePTn7jNuOXmjG0XIX5/qywwG2vLAFgBGfG0F0StfadPky2yvCK7O9M7x927s0zyzaBekjm3+2N2WzN/ivnbT0PH4Pti9atIh//vOfvPjii8THx1NYWEhhYSF1dXUAJCYmcsstt3DXXXexYsUKNm3axM0338yMGTM491xz1cm8efMYPXo0N9xwA1u3buX999/npz/9KYsWLWo1e11ERERERER6hoOrDwLQf2Z/rLb2p6TJg5IBKM8rD/SwREREREREwpY32N5ev3avzEmZJOUk4ax1kvteLgBup5tt/9oGwIQbu1ZCHpp7tjdUBS+z3d/B9m4t6i7e3VxCHppLxyvY3qv5Pdj+5z//mYqKCmbPnk1WVpbvz3/+8x/fNo8++ihXXHEFCxcu5IILLiAzM7NFiTWbzcbbb7+NzWZjxowZfPWrX+VrX/saDzzwgL+HKyIiIiIiIkF06MNDAAy8YOAZt03KSQKU2S4iIiIiIr2bt4x8R4LtFouFUdeaAeFdr+4CzCz32uJaYjNiGXLpkC6PwxdsD2Jme0fKyHeGd55ZcbCicw90NUDJ/paZ7Y4E82+Vke/V/N6z3TCMM24TFRXFk08+yZNPPtnmNgMHDuTdd9/159BEREREREQkhAzD4OCHZmb7gPMHnHF7BdtFRERERKS3qzpWRXVBNRarhcyJmR16zOiFo1n3yDr2vr0XV4OLrS9sBWDc9eOwRdq6PBZ7ghn4DmbP9rApI1+yHwx3y8x2lZEXApDZLiIiIiIiItKakj0l1BbXEhEVQfaUM/caTBxolvdrqGigvrw+0MMTEREREREJO96s9rRRaR3O8u47rS/xfeNprGpkx392sOetPUD3SsgDRCVGAcENtgcys70jCcQ+xWaVgBaZ7REOsEYq2N7LKdguIiIiIiIiQeHt1953el8iHGcutGaPtRObEQsou11ERERERPyseA90JtgaIt5+7dmTz7xg2ctitTDqGjMD+73vv4fH6aHPhD5kTuhYZnxb7PFm4LuxsrFb++kIbxl5f2e2J/RLwGK14Kp3UXO8puMPLNoNsRkQk9J8m8Vi9m1XGfleTcF2ERERERERCYrO9Gv38mYdlOWVBWJIIiIiIiLSG1Uegyenw/qnQj2SM/IG2zvSr/1ko68dDeCrEtbdrHYAR6LZs72+IvCVx5y1gclst9ltxPeNB6D8YHnHH1i8CzJGnn67PV6Z7b2cgu0iIiIiIiISFN7M9q4E25XZLiIiImerRpeHxdsLaXSHeiQivcixzYABqx+G+spQj6Zdxz4xy8h3Ntjef2Z/X6Uwa4SV8deP7/ZYHAlmsL2xKvCZ7b6e7TH+zWyHLvZtL9oN6aNOv90RDw3KbO/NFGwXERERERGRgCs/WE7FoQosNgv9zu3X4ccl5ph92xVsFxERkbPVn1bmcvt/PuO9I7pcLxI0BVvBkQiNNfDRE6EeTZuqjlVRXViNxWohc2LnSsBbbVZGXmNmYg9dMNQXeO8Ob7C9oSLwPdsDVUYeurCo29UApQdaz2x3xCmzvZfTb+8exjAMbr31VlJSUrBYLGzZsiXUQxIRERERETkjbwn57MnZ2OM6XgbQexGkIr8iEMMS6RbN0UVExB/e33EcgN3llhCPRKQXKfgM+k2B6d+CdU9C1fFQj6hVxzaZWe1po9K6VE79ovsvYvod05n/2Hy/jMcXbK9qwPAEtt+9N7Pd32XkoXlRd8XBDs4zS3LBcEN6a8H2eGhUsL03iwj1AKRz3nvvPZ5//nlWrlzJ4MGDSUtLC/WQuiQnJ4c77riDO+64I9RDEREREREJCLfTzb539jHwwoFEJ0eHejgB46p3seu1XTRUtZ/ZsPPlnQAMOH9Ap/afPCgZUM92CU+ao4uISHcVVtSzq8AsYX2sFqrqnaRE+j+LU0ROUbAVJnwJZn4fNj1vlpO//HehHtVpvP3asydnd+nxsRmxzH/UP4F2aO7ZjgGN1Y2+4HsgBDSzvbNl5It2mX+3Fmy3x0F9B/cjZyUF23uY/fv3k5WVxXnnndelxxuGgdvtJiJCb72IiIiISKAYHoM3vvYG21/aztAFQ7n+3etDPaSA2fDkBpb+YGmHt+9Mv3ZoWd7PMAwsFmV8SfjQHF1EJDx8sOs4y3YV8YsrRxMVaQv1cDpl5Z4i378NLGw+XMHFo2NCOCKRXqDmBFQdg6wJEJ0Ms+6C5b+Ec78LqUNCPboWvMH2zvZrD5SIqAiwAW5oqGwIaLA9kJntnS4jX7wb4vpATMrp9znioOKI38YWLPUV9Sz/yXJGXj2SwRcPDvVwejSVke9BbrrpJr73ve9x6NAhLBYLOTk5NDQ0cPvtt5ORkUFUVBSzZs1i48aNvsesXLkSi8XC4sWLmTx5Mg6HgzVr1uDxeHjooYcYNGgQ0dHRTJgwgVdeeaXF8Xbs2MEVV1xBQkIC8fHxnH/++ezfvx+AjRs3cskll5CWlkZiYiIXXnghn376qe+xhmFw3333MWDAABwOB9nZ2dx+++0AzJ49m4MHD3LnnXdisVh0sUxEREREzjrL7lnG9pe2A5C7OJf8VfmhHVAAHdtoljXsM6EPI68a2e6f6XdMZ9hlwzq1/8SBZnm/xqpG6svq/T5+ka7SHF1EJHz89v09/HvDIZbtCs8y0O1Z0RRsj7Can7+fHFQ1H5GAK9hq/p053vx7+rcgNgNW/Cp0Y2rDsU/M+Va4BNstFgu2GHNRU0NlYPu2B6tnu2F0oBx+0a7Ws9oBHAnQWO2/wQXJ6l+uZuOTG1n+k+WhHkqPp6XTXo21cGKvf/dpGNhqqqEmDtqarKYNB3vHVio+9thjDBkyhL/+9a9s3LgRm83GD3/4Q1599VVeeOEFBg4cyMMPP8yll15Kbm4uKSnNK2zuueceHnnkEQYPHkxycjIPPfQQ//znP/nLX/7CsGHDWL16NV/96ldJT0/nwgsv5OjRo1xwwQXMnj2b5cuXk5CQwNq1a3G5XABUVVVx44038sQTT2AYBr/73e+47LLL2LdvH/Hx8bz66qs8+uijvPTSS4wZM4bCwkK2bjV/gb322mtMmDCBW2+9lW9+85vde41FRERERMLMhj9u4KPffgRA1jlZFHxawAf3fsDX1379rAxiFe8oBmDOr+Yw/PLhft9/ZHQksX1iqTleQ3l+OdEpZ29JfjlFmM/TNUcXEQkPhmFwqLQWgD2FVVwxPsQD6oRGl4c1+04A8MUpfXlxwxE+OVge2kGJ9AYFW8EeD8mDzJ8jo+Gie+HN78F534PsSaEdX5OqY1VUF1ZjsVrInJgZ6uH42GJsuKvc1FcEbjG02+nG4/QAgclsT+ifABZw1bmoPVFLbHps+w8o3gNDL279PnscNPSsnu2VRyvZ+KS5KLjD2f3SJgXbvU7shb9e6NddWoH4M2106yrIntih/SUmJhIfH4/NZiMzM5Oamhr+/Oc/8/zzz7NgwQIAnn76aZYuXcqzzz7L3Xff7XvsAw88wCWXXAJAQ0MDDz74IMuWLWPGjBkADB48mDVr1vDUU09x4YUX8uSTT5KYmMhLL71EZFOPoOHDmy+czZkzp8XY/vrXv5KUlMSqVau44oorOHToEJmZmcydO5fIyEgGDBjAtGnTAEhJScFmsxEfH09mZvj8ghARERER6a5dr+9i8e2LATP4PPHmiTw+5HGOrDvC3rf3MuLKESEeoX95XB5O7DEvEKePTg/YcZIHJVNzvIayvDKyzgmPjA4JgjCfp2uOLiISHkpqGqltdANmsL0n+SS/lJpGN+nxDm6YPoAXNxzhsyMVNLjcOCJ6Vjl8kR6l8DPIGg/Wk4o/T/gKfPQELLsfvvZGyIZ2smObzKz2tFFpAQk4d5U12nzdApnZ7i0hD4HJbI9wRBCfFU/VsSrK88vbD7a7GqD0AKR/t/X7HfHQ0LMy21f/32pc9ebC3ZrjNbjqXWaLgLY01oD9DAsSejEF273ShpsTaj/yGAY1NdXExsZhbW/FfBft378fp9PJzJkzfbdFRkYybdo0du3a1WLbKVOm+P6dm5tLbW2tb2Lv1djYyKRJ5oqtLVu2cP755/sm8ac6fvw4P/3pT1m5ciVFRUW43W5qa2s5dOgQAF/4whf4wx/+wODBg5k/fz6XXXYZV155pfrQiYiIiMhZ6/C6w7z2ldfAgMnfmsyse2dhsViYfvt01v5mLct/vJxhlw3Dajt7unmV7i/F4/QQGRNJ0sCkgB0nKSeJIx8f0Yr73qaHzdM1RxcRCY3DTVntAHuP96xgu7eE/Ozh6QxJjyU2wqDG5WH70QomD2ylL7CI+EfBZzBsXsvbbBFw8c/hP1+F/StgyEWhGdtJvP3asydnh3gkLdlim8rIVwQu2O4tIW+xWbDZA7P4KCknyRds7zu1b9sbntgHhhvSR7V+vyMOGqvAMNqunhVGyg6UsfmZzeYPFsCAyiOVpAxt4/fOnsXwytfh+59BXOAW2fdkmlV52WM6nGHeYR4P7spKSEhouUIqBGJjm1ecVFebK2zeeecd+vZt+QHicDgAiI5uvzTjjTfeSElJCY899hgDBw7E4XAwY8YMGhvND8D+/fuzZ88eli1bxtKlS/nud7/Lb3/7W1atWtXmxQERERERkZ6qZG8J/77y37jqXQy/YjiX/fEyX8n4mT+ayaanNlG0vYjt/97O+K/2oNqmZ+AtIZ82Kg2LNXAXFRJzzL7tCrb3MmfxPF1zdBER/zlcVuf798HSWmobXcTYe8Zl7xV7zO9SF43MwGKxMDjeYFuZhQ15ZQq2iwRKfSWU7jcz20818groNxWW3QeDLgx5XCfc+rV72aID37Pdm9luj7UHrB1bUk4Shz86TMXBivY3LN5t/p3RRs92ezwYHnDW9ojs71X3r8Lj8jBk3hAqDlVwYvcJyg+Wtx1s3/qS+dz2LYFJ1wd3sD3E2ZNS0QsNGTIEu93O2rVrfbc5nU42btzI6NGj23zc6NGjcTgcHDp0iKFDh7b4079/fwDGjx/Phx9+iNPpbHUfa9eu5fbbb+eyyy5jzJgxOBwOTpw40WKb6OhorrzySh5//HFWrlzJunXr2LZtGwB2ux23293dl0BEREREJORqimr414J/UVdSR/aUbBa+tBBrRPNUKzo5mvN+eB4AK36+Anfj2fM9uHineYE4kCXkwbwIAlCRf4aLICIhpDm6iEhonJzZbhiQW9QzSvkeLq0lt6gam9XCrGFpAAxJMACzvLyIBMjx7ebfWRNOv89igbn3Q8EW2PlGMEfVKm9me7eC7VWF8Lf58Pp3YPM/oSzf/LDsBm9meyB7tjtrze+9gSgh75U4sIOLuot2QVwmRCe3fr+jqVFVDyglX7yrmM/++RkAF/3fRb7XoOJQG3NtZx3sW2r+e9/7wRhij9QzlvhJq2JjY/nOd77D3XffTUpKCgMGDODhhx+mtraWW265pc3HxcfH84Mf/IA777wTj8fDrFmzqKioYO3atSQkJHDjjTdy22238cQTT/DlL3+Ze++9l8TERD7++GOmTZvGiBEjGDZsGP/4xz+YMmUKlZWV3H333S1W2j///PO43W6mT59OTEwM//znP4mOjmbgwIEA5OTksHr1ar785S/jcDhIS0sL+OslIiIiIuJvjTWNvHjFi5QdKCN5cDLXvX1dq730pt8+nQ2Pb6A8r5xNT29i2qJpIRit//mC7WMCG2xPHmRe1CjLKwvocUS6Q3N0EZHQODnYDrC7sIrx/ZJCM5hOWNlUQn7ywGQSoiJxOp0M9gbbD5bh8RhYA1g5SKTXKtgKNkfbrYNyZsKwS2H5L2HUlWALTRWgqmNVVBdWY7FayJyY2fUdrXoYju+ExmrY+m/AgMT+MHAm5Mwyn2/yoE6VPw9Gz3ZvGXl7rB22vAj2OPP98GOWu3dR9xmD7cW7IX1E2/c74sy/G6ogvo9fxhYoK3++EsNjMPLqkfSd2pfEAWcItud+AM4aGP8l2P0uuBoh4vRrHr2dMtt7uF//+tcsXLiQG264gXPOOYfc3Fzef/99kpPbWGHT5Je//CU/+9nPeOihhxg1ahTz58/nnXfeYdCgQQCkpqayfPlyqqurufDCC5k8eTJPP/20r7zcs88+S1lZGeeccw433HADt99+OxkZGb79JyUl8fTTTzNz5kzGjx/PsmXLeOutt0hNTQXggQceID8/nyFDhpCerh4PIiIiItLzeFweXv3yqxzbeIzo1GiuX3w9cX3iWt3WHmvngp9dAMDqX672XTjo6bxl5IOV2V6eX47RzSwMkUDSHF1EJPgOl5nB9uQY8zNxb2HP6NvuKyE/ovnzul8MREdaqahzsq+HZOiL9DgFn0GfMe0H0ef+Akrz4NMXgjeuUxzbZJaQTxuV1uqC7g4p2W8+hwv+H3x7DfwoD778bxj9eSjeBW/dDo9PgkfHwKvfhD3vdWi3wejZ7i0jHxkTCcvuh//eAC9+CcoP+e0YnQq2Z7TRrx2aM9sbw/v3T8GnBex8ZSdY4KJfXgRw5mD7rjchYzTMWGQ+v0PrgjXcHkWZ7T3MHXfcwR133OH7OSoqiscff5zHH3+81e1nz57d6sUoi8XC97//fb7//e+3eazx48fz/vutl4WYNGkSGzdubHHbtdde6/v3VVddxVVXXdXmvs8991y2bt3a5v0iIiIiIuHMMAzeWfQOe9/eS0RUBNe9eR2pw1Pbfcw53ziHdb9bR9mBMtY/tp7zf3x+kEYbGB6XhxN7zDLVgQ62ey8AOGuc1JXUEZMWE9DjiXSU5ugiIqF3qCmz/aKRGbz26VH2HA/vYAdAvdPNR/vN71EXjWz+HmWzwqT+SXx0oJQN+aWMyIwP1RBFzl6Fn0G/Ke1v02eMmcm78jcw/svNmctB5C0hnz05u+s7WfEgxKbDtFvNn6OTYeRl5h+AunI49DEcXAMHVsK/vwzXvwzDLml3t8Ho2e5doB4ZGwmNNTB8gVmV4MnpcNFPYPq3wda9EKevXdnBCgzDaL03vLMeSg9Aehv92sHMugczsz2MLf/pcgDGfWUcGWPMhV6+YHtrfetdDbBnMZz7XcgcD/FZsPd9GHxh0MbcUyizXUREREREpJPWPLSGT//6KVjgmhevof95/c/4GJvdxuwHZgOw9uG11JXWBXiUgVWWV4a7wU1EdITvIkWgRERFEJdlXsA4Y9aBiIiI9Bout4dj5WbP4LmjzNK9e3pAZvvHB0qod3rISoxiRJ+WAfXJA5MA9W0XCQhnvdl/O3P8mbe96MdQXw4f/zngw2rNsU/MzPYu92sv+Ay2vwKz74HI6Na3iU6CEfNh3v/BravNIPur3zD7urfDFhO8zHZ7bKRZAn/4pbBoPZzzNVjyU3hmDhzb3K1jeAPNjdWNbc/PS/aB4elYZnsY92w/tPYQuYtzsdgszL5vtu/2dnu2H1gFDZUw+nNm+f5h89S3vQ0KtouIiIiIiHRCTVENK362AoAFjy9g1NXtTLpPMe66cWSMy6ChooE1v1kTqCEGhbdfe9rINKy2wE8t1bddJHzVNLh4ckUuxyvrQz0UEellCirqcXsM7DYrs4alAVBU1UBZmLfsWdlUQn72iIzTMimnDDS/82zMU7BdxO+KdoLhhqyJZ942eSBM/QasfQxqSgI+tFN5M9u7HGxf/ktIHQoTv9qx7a1WuOavZgD+PzeAs+3F4daY4PVsj4oDMMAeC1EJsOA38M0PzAD403Ng8T1dziiPiIogLvMMi7qL95h/t9uz3VtGPvDB9rIDZaz+v9VUHev4czYMg+U/MbPaJ319EilDU3z3nVxG/rQKXLv+BylDzDLyYC54KMk12xNICwq2i4iIiIiIdMLRDUcxPAZpo9KYdtu0Tj3WYrVw8YMXA7Dh8Q2dmiCHm2D1a/fqcD89aeGhhx5i6tSpxMfHk5GRwVVXXcWePXtO227dunXMmTOH2NhYEhISuOCCC6ira77AVlpayvXXX09CQgJJSUnccsstVFeHb+aGBNc/Pj7Ib9/fw8/e2B7qoYhIL+Pt194vOZqEqEj6JZvZm+FcSt4wDJbvLgLgohGnf4+a0C8Rm9XCsYp6jpb37EpIImGn8DOw2KDP6I5tf/4PzL8/fCRwY2pF1bEqqgursVgtZE7M7PwO8tfCviVmufXOlFqPToYv/gNO7IV3/h+00v4ImjPb6ysCt9DSm9keHe8xb7DHNt/ZdzJ8cyXMvd/sSf/kdNj9zuk7MQyor4QTuZC/Bra/Cuv+BPtX+DY5uZR8q4p2QVym+dq0JSLKPK8aKjvxDLtmza/XsOJnK3hq0lPkrcjr0GMOLDvAwVUHsdltXPCzC1rcl9A3ASzgbnBTW1zbfIfbab6moz9vZrUDDLoQbA6zlLy0oGC7iIiIiIhIJ3jL+fWd2rdLjx92+TD6n9cfV72LVb9c5c+hBZU3sz19THCC7Yk55op7Bds7Z9WqVSxatIiPP/6YpUuX4nQ6mTdvHjU1Nb5t1q1bx/z585k3bx4bNmxg48aN3HbbbVitzZcMrr/+enbs2MHSpUt5++23Wb16NbfeemsonpKEoZ3HzAuLq/YWU9PgCvFoRKQ3OdzUr71fSgyAryT73jAOtuedqOFQaS2RNgszh6addn+sI4Kx2QmAsttF/K5gK6QNb7us+qliU2HaN+HTfwR2XKc4tsmcc6aNSsMea+/cgw0DPrgfsibA6Ks6f/Cs8XDFH2DLv2DT861u4isjH4zM9li3ecPJwXYwFxHMvB2++7GZef3SV+DvV5lZ+c9eCo9NgAez4df94Y+T4fnL4ZWvw7JfwD8XwpFNQHMZ9bYz23dDRjv92sEMRjvig1JGvq7EXIRVU1TDP+b+gw8f/BDD0/qiCGiZ1T7lu1NI7J/Y4n6b3UZ8lvm7s/xgefMd+WugrswsIe/liIOcWSol34peHWw/rSSChBW9PyIiIiISjny986Z0rZyfxWLh4l+b2e2bn9lMaW7PvIjqC7YHObO9Ir+NjANp1XvvvcdNN93EmDFjmDBhAs8//zyHDh1i06ZNvm3uvPNObr/9du655x7GjBnDiBEj+OIXv4jD4QBg165dvPfeezzzzDNMnz6dWbNm8cQTT/DSSy9x7Ngxv41Vc8Dw19Z7lFtkXlhscHlYsacomEMSkV7ucFOP3f5NGe0jMs2AQTj3bV/RVEJ++qBUYh2tZ5xOyTFL/G5U33YR/yr4zAxCd0ZyDjRWgccTkCG1xltCPntyducfvPd9OLweLv6FWRq+KyZeB1NugcU/9AWlT+YrIx+Enu1RMd5ge1zrGyYPhOtfhmufg8Yas6R8co6ZkT3nZ7DwWbjpHbhtE9xzGH58DLInwmvfgIbqM1dQK9oF6R1oHeeI73I5+85w1pmvS+rwVAyPGUh/6fMvUVfWeiWUPW/u4djGY0TGRnL+vee3uk2rfdt3vQlJA05vuTD8UrNyQhCea0/SifoRZ4/IyEgAamtriY7u4AomCbraWnNlqvf9EhEREREJNcMwfMH27ClduPDRZOD5Axm6YCi5i3NZ8fMVLHxxob+GGBQet4cTu04AwQu2q2e7f1RUmBdQUlLMi/hFRUWsX7+e66+/nvPOO4/9+/czcuRIfvWrXzFr1izAzHxPSkpiypQpvv3MnTsXq9XK+vXrufrqq087TkNDAw0NzRffKivNzGen04nT6Txte8MwqK6u9gX4A8UbLDYMA08QL5ieLaqrq32vofd9dHsM9hc3Z/G8+9kxLh0VnM8Ff/I+n9bOTxF/0XnmfwdLzM+fvkkOnE4nQ9LMDPfdBZVh+zov33UcgAuGpbYY48nnxzn9E3gW2JBXErbPQ85uZ+XnlcdFxPHteEZ9Hk8nnpfFaicCcNZXQWRM4MZ3kqMbjwKQMTGjc++Bx03EsvswBs7CPeB86M77d/ED2I5twfLfG3B9/QOINStxOJ3OFpntgTpH6qvMEvV2R9O5aLG3/3xGXGn+ORMP8Lk/EfHMRRiL7yG+/w2A2Qv9tOfiqieiLA936jCMMzzPCHscnvrKTp1bXeHN+D//5+fTWNPI+7e/z9639/LUOU9xzUvXkHVOc1KANxgPMPW2qdiT7a2+X/H9zIVqZXlNr4HHTcSut/CM/QIe1ylVqwbNIdLjxLV3GcbIKwL0LMPnM6ijx++VwXabzUZSUhJFReZq65iYGCzengN+5PF4aGxspL6+vkX5PWmfYRjU1tZSVFREUlISNpst1EMSEREREQGg6mgVNcdrsNgsZE7oQu+8k1z84MXkLs5l+7+3M/OHM7vWiy9EyvPLcdW7sDlsJA9up3edH52ccWAYRkDmcGc7j8fDHXfcwcyZMxk7diwABw4cAOC+++7jkUceYeLEifz973/n4osvZvv27QwbNozCwkIyMjJa7CsiIoKUlBQKCwtbPdZDDz3E/ffff9rtS5YsISbm9IuU8fHxNDQ0UF9fj91uD/j7W1JSEtD9n20Mw6CxsZETJ05QVlbGvn37fPedqIcGV/PlpWU7C3njraPYe+hUfunSpaEegvQCOs/8Z9sBG2ChOG8371bu4ngNQAQ7j5bxzjvvEm5fFxrc8HHTmCnYwbvv7jhtm6VLl1LlBIhgX1ENL//vXWKViyQhcjZ9XsXXHWGOq551+XWUlLzb4cdllu9iOrBs8Vs0RsQHboAnObL9CAAHKg9Q/G5xhx/Xr3Qtk4t38eHwn1O2eHG3xxGVfAOzi35G5TPX8NHQH4LFjHN5g+3OWifvvPkOlgj/f9ge2nMIgOITeZANK9ZuoM7RsR7lHTEw80tM3PIcdUYUEM/hHYd5992W50VC7SEuMjx8tK+MsoL2z5nza51U7d/Flnc7fm51xYkCc9H71p1bSZyWyJCHhpD/m3wq8it4ftbz9P1mX1LnpWKxWChbVUbxjmKsMVYqx1We9vy8Spzm3GjLqi2cGHaC1OrdzKopZm1ZKmWtPGZOVDalK/7GlgOBj3uG+jPImxR8Jr0y2A6QmWleyPIG3APBMAzq6uqIjo7WhaAuSEpK8r1PIiIiIiLhwJvVnjEmg8iY7l31zJyYydgvj2X7S9tZ/pPlfOWdr/hjiEHhLSGfNjINqy04C4sT+ieABVx1LmqLa4nNiD3zg6SFRYsWsX37dtasWeO7zZvd/a1vfYubb74ZgEmTJvHBBx/wt7/9jYceeqhLx7r33nu56667fD9XVlbSv39/5s2bR0JCwmnbG4ZBUVGRLwM+UAzDoL6+nqioKM3TuyA9PZ0xY8a0eO2W7ymGzZsZ0SeOqnoXxyrqiR0yhUtGZ7Szp/DjdDpZunQpl1xyiSrsScDoPPO/X25bCTTyuTkzGds3gUaXh99v/4A6N5wzaw5ZiVEhHmFLH+wqwr1hC/2To7npmlktPk9PPT/+lr+GAydqSRkxhYtH9qzPVOn5zsbPK8u2/8JumP75b0DU6d9H23zcgWjIe4y5F86ExH4BHGGz/LvyqaeeWRfPou/0vh17kLuRiD//FM/wy5jxhdv9NhZL/kDSXlzIFTFb8Fz0U5xOJ0sWL/HdP2fWHKJT/F9B+vV/vU4ppQwZmgm1cNGlV0BMqv8OYCzA80ohF+S/zKa4L+IsdbBgwYIWn8uW7a/AHpjxuZsgKrHtfQG2iudIsseRfdll/htjK47+9Ci11HLu+ecy6OJBANR/tZ63vv4W+97ex5E/HyGpMol5f5jHcz94DoDzf3Q+M784s819fnLwE5a8sYQUWwqXXXYZ1iVrMOIymXHt93wLLE5mdWwgbtt/yV4wv9X7/SFcPoM6Oj/ttcF2i8VCVlYWGRmdLMPRCU6nk9WrV3PBBRecNb+QgiUyMlIZ7SIiIiISdrrbr/1Usx+YzY6Xd7Dv3X0c3XiUvlM7eCElxIp3BLdfO0CEI4L47HiqjlZRnl+uYHsn3Xbbbbz99tusXr2afv2aLxJmZZnn8ujRo1tsP2rUKA4dMrNJMjMzT1uo7nK5KC0tbXOBtMPhaLUkfGRkZJvz4379+uF2uwNaKlDz9K5ra56eV2L2hxyemUB6nIO/rc1j6e5iLpvQMz7PTtXeOSriLzrP/KOu0c2JarOc7uCMhKbXFQalxbKvqJr9JXUMSAtOFmpHrd5v9mCfMzIDu93e6jbe82PaoFQOnKhl85FK5o/rmZ+p0vOdVZ9XRTsgOYfI+E4GbKPMz5FIoxGC9Fq4as3S3dEJ0R1//T99DiqPYLn+v1j9Oc5hc2DufdiW/hxb/6kw9FIsERYioiNw1blw17qJ7OP/18VdZ/Zqj4pyQy1ExiT5//X//B8x/jSDz31uCS++eDXuGjfRySctHCjdB/FZRMannXlfUQnQUOXf174VrrrTz43I9Eiue/M6PvrtR3xw7wds/9d2Drx/gNoTtcSkx3DeXee1ex6lDDJbjFUdqSLSZoPdb8PozxNpb6PF18gF8PEfiSzeAX3P8e8TPEWoP4M6euxeG2z3stlsAQvq2mw2XC4XUVFRZ88vJBERERGRXswbbPdXUDx1WCqjrhnFzpd3svftvT0n2N6U2Z4+Jrh9mZMHJVN1tIqyvDL6TusZr1WoGYbB9773PV5//XVWrlzJoEGDWtyfk5NDdnY2e/bsaXH73r17WbBgAQAzZsygvLycTZs2MXnyZACWL1+Ox+Nh+vTpfh1vIOfo3v1rnu5fuUVmv+RhGXGcNySVv63NY9mu4zS43DgitIheRALncJlZ2jU+KoLEkyoODc+MZ19RNXsLq7hoRPhkhBuGwcrd5uK12R3IVJ+Sk8JLGw+zMa800EMT6R0KP4OsCZ1/nL2pBZKzY+Wk/cHbl7vD1dQaqmH1b2HCdZAxyv8DOu92OLIR3vgO3GxmtTsSHLjqXDRUNvj/eJz0GkQ2gsUGEW0EfrsjNg3LVX9mWM1Cpk7dQsXBipbB9qLdkD6yY/uyx0PlMf+P8RTeYHtEdMvwrsViYeYPZ9J3el9e+dIr1Jh9VTj/x+djj2t9cZdX4gAza7/iUAUc3QRVx2D059p+QP/p4EiEve8HPNjeU6iRuIiIiIiISAcYhuELtmdPyfbbfofMGwJA3jL/9Z8LNF+wPYiZ7dCyb7t0zKJFi/jnP//Jiy++SHx8PIWFhRQWFlJXZ2YjWywW7r77bh5//HFeeeUVcnNz+dnPfsbu3bu55ZZbADPLff78+Xzzm99kw4YNrF27lttuu40vf/nLZGf77/+C9Ez7moLtQzPiOGdAMhnxDqrqXXyUWxLikYnI2e5wqRn46p8c0+L2kX3MLNQ9hVVBH1N79h6v5lhFPY4IKzMGnzmzdlqOmWm47WgF9U53oIcncnYzDCj4DDLHd/6xkd5ge51/x9QGwzBw1jqbDt3BYPv6P0N9Ocy+JzCDsljg83+CuD5EvHoTNncDjngz+B2oYLuzpuk1iHCCPdYcQyAMm8uO/Jlccslqand/2vK+4l0dX7zgiDcXPQSY79yIbv3cyLkwh29t/hYjrx7JsMuHMeXbU864T2+wvba4Fvdnr0NsOgyY0fYDbJEw9GLY937nn8BZSsF2ERERERGRDijPL6eupA5rpJWMcf7Lkho8dzAAR9YfCdiFCn8yPAYndp0Agh9sT8wxLwIo2N5xf/7zn6moqGD27NlkZWX5/vznP//xbXPHHXdw7733cueddzJhwgQ++OADli5dypAhQ3zb/Otf/2LkyJFcfPHFXHbZZcyaNYu//vWvoXhKEkYMw2D/SZntVquFS8eYrQUWby8I5dBEpBfwBdtP6RU8PLMp2H48vILtK/aYWe3nDUklKvLMlT/6p0STEe/A6TbYcrg8wKMTOcuV5UNDRdcy2yObPmOClNnucXow3IZ56I4E22tLYe3jMOUWSBoQuIFFJcCX/gllBxlS/B6OxKZge0VgM9sjbA1msD2AdtddT3l5In32/RRcTc/HWWeeN+kjOrYTRxw0BiHYXnfmhRjxWfF86bUv8ZW3v0JE1JkLnEclRWGPtwMG7PwfjLwcrGf4PTX8Uji2GaqOd2b4Zy0F20VERERERDrAm9XeZ3wfIhz+68iVlJNE8pBkDLfBwdUH/bbfQCk/WI6z1onNbiNlSEpQj+3NbK/IrwjqcXsywzBa/XPTTTe12O6ee+7h8OHD1NTU8NFHHzFr1qwW96ekpPDiiy9SVVVFRUUFf/vb34iLiwviM5FwVFhZT3WDC5vVwsBU8yLogrFmsH3pzuO43J5QDk9EznKHy8ws0wEpp2S2NwXb9xVVh9Xn0IqmEvIXdaCEPJjVZ6Y29dH9JF+l5EW6pfAz8+8uBduDm9nuzVw2D92BYPua34PhgfP/XwBH1SRjJEbacKIaS7EnmKXJA57Zbg18sD1hYAavvnoZ0a58WP5/5o0n9pmva3oHM9vtcdBQGbAxgrnw3d1gVjo5tYx8d1gsFhIHJJKZWYSt5giM/vyZHzT0EsAC+5b4bRw9mYLtIiIiIiIiHRCIEvJe3uz2A8sO+H3f/uYtIZ86IhVrRHCnlMmDkgFltouEi33HzeydnNQY7E2fB9MGpZAcE0lZrZP16jMsIgF0yJfZ3jLY3j85hqhIK40uDwdLg9djuT2V9U4+OVgGwOzhHa+QNHWg+d1nQ35ZQMYl0msUbIW4TIjrQoUyb2Z7Y3A+T7zBdovNgjXyDPOtiqOw4WmYcRvEBanqmCOeSE8djgQzs72+oj4gh/Fmttss9QEPtiflJHH8eAafFVwFHz0BeauheLd5Z4cz25vKyBtGwMbpzWqHtsvId1XigERGj96HyxoPOeef+QGxqdBvqkrJN1GwXUREREREpAMKPjFLIgci2D7o4kEA5H0Q/n3bi3eEpl87tOzZbgTwIoaIdEyur4R8vO+2CJvVV0r+3W0qJS8igdNWz3ar1cLwpr7te8Okb/uafSdwewyGpMcyIDXmzA9o4s1s//RgGW6PvvuIdFnBZ5DVhX7tABFRgCVoZeRP7tduOVOf8lW/MQPRMxYFYWRNHPFEuJuD7YHObLdZGiAysMH2xIFmu7ING6dCzix4/dtw6GOIz4bopI7txBEPhjugFRBcdS7fv/2Z2Q6QODCBUaP2UeyeavZk74jh82D/iubS+72Ygu0iIiIiIiJnYHgMjm0KXGb7oIsGgQWKthdRXRj4Pm/d4c1sTx8T/GB7Qr8ELFYLrnoXNcdrgn58EWlpX1OwfWhGy5YC85tKyb+/47iCQyISEIZhcKSpjPypme0AI5qC7bvDJNjuKyE/onNZtSMzE4h3RFDd4GJXQWDLE4uc1Qo/61oJeQCLxSwlH+Qy8mcsIV9xBLa8CDPvMPupB4sjngh3fUB7thsew/c62Iy6oGS2A5TlV8LVfzEz1D95FjJGdnwnjqbFpwHs2+7NbLfZbVht/g3vZvUrJy2tjPyiTvw/GT7ffL4HP/LrWHoiBdtFRERERETOoHR/KQ0VDdgctoAEmWPSYsialAXAgQ/Cu5S8L9gegsx2m91GfF/zIoZKyYuEXm6RGcQa1qdlsP28IWnER0VworqBTQdV+lhE/K+s1kl1g5nh1y85+rT7RzT1bd97PPTBdo/HYOVe8/tTR/u1e9msFs5pKiW/UX3bRbqmqhCqj0NmFzPbwSwlH4LM9nate9IMQk+5OQijambYm8rIxwcus/3kculWTxCC7QOTAKgvr6eeNLji9+Yd6Z0Ittubvg83BO73TofPjS7oG/8p9fV2cvf26/iD+oyFhL6wV6XkFWwXERERERE5A2+/9syJmdgibQE5hq+U/LLwLSVveIyQBttBfdtFwoVhGG1mttsjrFwyqg8Ai7erlLyI+J+3hHxGvIOoVr6becvI7wmDYPvOgkqKqxqItduYkpPc6cdPayol/4n6tot0TcFn5t9dzWyH8Mtsry2FTc/DtFubM6qDxRFnlpEPYGa7t4Q8gMVd2xzIDhB7nJ3oVHPhVsXBChh3LVz+e5jciYUMjsAH271l5P1dQh4gpWE1e/cOpuxgJxaVWCwwbJ76tqNgu4iIiIiIyBl5g+2BKCHvNXjuYMDMbA/XfuQVhytw1jixRlpJGZoSkjH4Svzl6YKzSCiV1DRSXuvEYoEh6adfAF0wzqzW8d72QjwqJS8ifna4rKlfeysl5AFGNmW255+ood7pDtq4WuMtIT9zaBqOiM4v2pzSlNm+Ib80bL8jioS1gq0QlQRJA7q+jxBktttj7W1vtOGvYBgw/VtBGVML9sD3bG+saQTMoLLFWQv21j/r/ck7z/Qt6p56C6QP7/gOHE2l/ANZRt67ECPaz5ntJ3Kx1+Sya9cwKg9XYnTmu/vwS6H0AJzI9e+YehgF20VERERERM6g4BMzMzN7auCC7QNmDcBmt1F5uJLSfeFZJtSb1Z46PDVgGf5nkpiTCCizXSTUcpuy2vsnx7SaVXr+sDRi7TYKKurZeqQ8yKMTkbPdoabM9gFtBNvT4x0kxUTiMZo/r0JlxZ6mfu2dLCHvNaF/EnableKqBt/zFpFOKNwKmePMLNyuCqcy8g3VsP4vMPlGiE0LyphacMQT4an3BdvrK+r9fogWCw4aqwNeRh5OCrYfLO/aDoJRRr4uQGXkd/0PIzKG/QcG4W50U328E783B10ANgfsfc+/Y+phFGwXERERERFph8ftoeDTpmB7ADPbI2Mi6T+zPwAHloVn3/ZQl5CH5osgFfkVIRuDiNBmCXmvqEibL7D03vbCoI1LRHqHw6VmOef+rfRrB7BYLIzwlpIvDF0p+fLaRjYfLgdg9oiufX+KirQxrp+52HBDXnguyBQJlnW/X8djgx+jZF9Jxx9U8Fn3SsiDGewNlzLyn/7dDOjOWBSU8ZzKcMRjM1xExZmLFwLSs72pjHxkbCQ01gQ32N7VRd3ecv4NgVvgFbAy8jv/h2XYJUT3MavXVRzqxFzbHmsG3Ht5KXkF20VERERERNpRsqeExupGImMiSRsZ2MwBb9/2sA2272gKto8JXbBdPdtFwkNuUx/kYW0E2wEWjDVLyS/eXqjSxyLiV0eaysj3ayOzHWBEUyn5vSHs236krA7DMHvLZyW2vjCgI6bmqG+7CMDOV3ZSnlfOpqc2dewBdWVQfrD7wfYgZrZ7S6i3Gmx3NcK6P8K4L3SvLH53NGVwR8WaAfFA9Gz3vgZmZntNwHu2AyQONBc1dXlRd2Q0WKzQGMDM9kCUkS/LN1stjPociQOaXoPOBNvBLCV/8COo770L4hVsFxERERHpxTxuD+ufWM+JPSdCPZSw5e3XnnVOFlZbYKdQ3r7t+Svy8bg9AT1WV4RTZnt5fnnnesmJiF/lFref2Q5mFqcjwsqh0lp2FlQGa2gi0gucqYw8wHBvZnsIg+11Tf3iYx3dy0KcmmMuNtyYr8x26d28Gc+7Xt3VsYV8hdvMvzPHd+/AkdHhkdm+7WWoPAozvx+UsbSqKYPbEWUGxAOa2R5jMxc5RIagZ3tnWSxgj+95ZeR3vWWWgR9+KUkDkwCoONjJoPmweeBxwf4V/htXD6Ngu4iIiIhIL5a7OJf3bn+Pf83/F+5Gd6iHE5Z8wfYpWQE/VvbkbByJDurL632l68OFYRhhEWxP6JeAxWYxe8kVhrYHq0hvtu/4mYPtsY4IX9nkxdtUSl5E/MPtMThW3lRGvp1g+8jM0JeRr2v6fh0daevWfqYMNDPbD5yo4US1/wNbIj2FN+O5PL+8Y/Olgs8gIhrShnXvwJEx0Bjcnu0RMacs0vF4YO0fYMTlkDEqKGNpjdEUbI9ymOOsr6j3ewUj7/scndB0Q0/o2Q7mQoSeVEbeMGDHGzD0YnDEkzDAfME7ndmePBDSR8G+Jf4ZVw+kYLuIiIiISC/mnUiW55ez6ekOluLrZbzB9kD2a/eyRljJmZ0DhF8p+cojlTRWNWKNsJI6LDVk47BGWEnoZ14EUCl5kdCoqHNSVGUGe9oLtsPJpeTDawGRiPRchZX1ON0GkTYLmQlRbW43rCmzvaCinoqmbMBgq/UG2+3dC7YnxkT6etB/oux26cW8Gc9gZrefUcFWyBwL1u79HwxmGfk2M9v3vAMn9sKsO4MyjjY1lXS32+sB8Dg9uBv8u3Df+z7HxHlaHDOQvFnddSV1NFR1cVGTIy6wme3tVT3oLMOADx6Ao5/ApK8CdL2MPMDweWaw3RN+FfqCQcF2EREREZFerLa4+YLB6l+u9q0gF5PH5aFws5mNGYxgOzSXks/7IC8ox+sob1Z7yrAUbN28YNxd6tsuElq5RWbGTmZCFPFR7V/smzMqg0ibhf3FNewLYSlnETl7HG4qId83KRqb1dLmdonRkWQlmsH4UPVtr3OaWYgxfvjuNHWQt5S8+rZL73XyfLVDpeQLP+t+v3aAyNjQlpE3DFjzKAycBf2nBmUcbWrKbI+0Nb8X9RX1fj2E932OimsK4gchs92R4CAq2fyd0eky6r6dxAe2Z3vTwjG/ZLavfAjW/B7m/QpGXg7Q9TLyAMPnQ00xHNvc/bH1QAq2i4iIiIj0YrUnmoPtNcdrWP/Y+hCOJvwU7yzGVe/CHm8PWja3N9h+aM0h32Q6HIRDCXkvb4m/sjxdbBYJhdwi8yLisD5nzjJKiIpk1tA0ABZvVyl5Eek+b7/29krIe40IcSn5ukYzwy+qm2XkAabmmKXk1bddeivDMFpktpfsLaF4R3HbD2isNTPBu9uvHULfsz1vNRzdBOeHOKsdfMF2i7MKe7wd8H/fdu/7HB3rzWwPfLAd/FBK3h4X0DLyvnMjupuZ7St/A6t+A3Pvh/Nu893crcz2ftMgKgn2vte9sfVQCraLiIiIiPRi3sz2fuf2A2Dtw2upKw3ORYSewFdCfnI2lnYyp/wpdUQq8X3jcTe4Obz2cFCO2RHeC1npY8Ig2D44CYCyXAXbRULBm9l+phLyXt5S8u9uUyl5Eem+I03B9n7JHQi2N5VeD1Vme22jHzPbm4LtO45VUtPg6vb+RHoad4Mbw2Nmsg+8YCAAO1/d2fYDju8AwwNZ/gq2B6eMvKvW/P/dIti+5lHIHAdDLg7KGNoVEY0HK5aGKqKaqof4O9juy2yPCV5mOzRndne5glqAy8h7e7Z3q4z86kdg5YNw8c9h1h0t7vIG2+tK62is7mTVQ1sE5MyCIxu6PrYeTMF2EREREZFezJvZPnXRVPqM70NDRQNrfrMmxKMKH95ge9aUrKAd02KxMPhiM7s9nPq2h1Nme9pIM0v2xJ4TIR6JSO+0r5PB9ktG98FmtbC7sIr8EzWBHJqI9AKHy8yFof1Tos+4rTezfXeIMtvrnU092/2Q2Z6dFE3/lGjcHoN/fHyw2/sT6WlOLiE//mtmAH3XK+30bS/cCtYIyBjd/YNHxoSuZ/uxzXBghdmr3RKcBeDtslhw2aKhsQpHggOAhorAZLY7opsWFgUp2J6YYwabux5sT4DGAGa2d7eM/Jo/wPJfwkU/gfP/32l3OxIcOBLN97TicBey22NSoL6ya2Pr4RRsFxERERFpQ+WRSt9E92xVU2wGPWL7xDLnwTkAbHh8A5VHe+cE6VTeYHvfqX2DetxBcwcB4dO33TCM8Aq2j2gKtu8+ceY+jSLid97M9mEZ8R3aPjnWzozBZisOlZIXke7ylpEf0IEy8sNPymwPxXeG2samYLsfMtsBvnfRMAAeXbqXPC1ekl7GG4C1OWyMunoU1ggrRduLKNlb0voDCrZC+iiIcHT/4N7M9iB8jpwWbF/zKCQPglGfD/ixO8pli4aG6uZge4Ay2x1RwQ22e8vIV+R3sWe7PcCZ7d6qB10pI//RH2HZL+DCH8GFP2xzs271bQ/wYoNwpmC7iIiIiEgrSnNLeWzQY/znmv+EeigB5c1sj0mLYdhlw+g/sz+ueherf7k6xCMLPXejm+NbjwOQPSU7qMf2ZrYf23QsLMr6Vx2roqGiAYvNQurw4PSub0/KsBSwQH1Zva8VgogER22jiyNNWaXDOpjZDjB/bCYA721XKXkR6Z7D3p7tHSgjPzQjDqsFymudFFX5NxjUEXVNme3+KCMP8IUp/Zg1NI0Gl4cfvfoZHo8WHUrv4S1rbY+1E50SzaA55gLlNkvJF3zmnxLy5kHNv131/tlfO7zBdnusHU7kws43Yeb3zTLdYcJljYKGKl8WdH2Ff18Xb1DZ7miqZhDZQ3q2O+ID27O97pSFGB318Z9hSVM2++x72920W33bA7zYIJwp2C4iIiIi0oqCzQV4XB72v7+f4l3FoR5OQBiG4Qu2x6bHYrFYmPvruQB8+synlOxrI0OglyjaXoS70U1UchRJg5KCeuz47HjSRqWBAXkrQp/d7s1qTxmaQoQj9Bd5IqMjfRdCTuxWKXmRYNpfZGZSpsbaSY61d/hx88b0wWKBrUcqOFKmRTIi0jX1TrcvaN6/A5ntUZE2ctLMIM2eEJSSr2v0Xxl5MNsNPXTNOKIjbWzIK+XFDYf8st9g2ZhfyrV//oith8tDPRTpgbzZzpGxZqBx1MJRAOx6tZVS8m4nFO2ErAn+OXhkU9sKZ+AXQrfIbP/oMYjLgAnXBfy4neG0RWNpDHxmu93uAmskRHT8O2d3+KVne2Pge7Z3qoz8hqfhvXvMBRtzfnbGVgQJAxKALgbbHfEKtouIiIiISLOTs2W3PL8ldAMJoIbKBjxOD2BmtgMMmDWAYZcNw3AbrPz5yhCOLvSObjwKmFntlhD0xhs818xuD4dS8uFUQt7L17ddwXaRoMotNi+gdbRfu1dGfBTj+5qZMlsUZBGRLvIu1olzRJDcwcy+ESeVkg+25jLy/lus2D8lhh/OHwHArxfv5lh56KsgddRrnx7lk4Nl3PvaNmXlS6d5y8jbmxb7jbxqJBarhYJNBacHR4t3g7sRMv2U2e4Ltgd+waA30BxlLYUt/4ZzvwuRUQE/bme4rNEtMtsD1bM9MqIxaCXkoTmzvba41vc+dIo32BygdgOntRg4k43Pwrs/gBm3wdz7zxhoh25mtjvizTLyHk/nH9vDKdguIiIiItIKby9zgM/+8Rke19k3WfAuKLDH2YmIar4A6O3dvv2l7RRu6b29db392oNdQt7LG2w/sOxASI5/suIdTcH2MQq2i/R2+46bpTE7G2wHGJxuPuZgiTLbRaRrDje11+mXHN3hxZDevu27Q5HZ7vRvZrvX12bkcM6AJKobXPz49W0h6UffFbWNZlbmzoJKFm/vvfMM6ZpTM9tjM2IZcP4AoJVS8gWfARbIHOufg0c2VdIIYmZ7YsG/zONO+XrAj9lZLlsUNFYFPLPdDLZ3/jtnV0UlRfkWEHStjHo8eFzgCkzbEl8Z+Y70bN/2CrxzF0z/Nsz7vw4F2qG7Pdub3qte2LddwXYRERERkVacnNleXVDN/iX7QziawDi5X/vJMidkMvY686LEBz/+IOjjChcFn5h9hUMVbB944UAsNgul+0q73jPOT8I5s71kT+9udyASbLlF5sWzzvRr9xrQVPL5kILt0kt5PAYN7lCPomc73JTZ3pES8l4jM0OX2e4tI++vnu1eNquFh68dj91mZeWeYv635Zhf9x8oNSf9B/j90j24ld0unXBqZjvA6GtHA62Uki/YCqlDzExbf/BmtjfWtL+dHzhrnURF1RFz8L8w7RsQlRDwY3aW02Zmtkclmhn3/u7Z7ststzYENbMdullK3htsDlApde9CjA6VkV//Fxg6F+b/usOBduhuZnvTuapgu4iIiIiIQHOw3btSe8tzW0I4msDwZu/HpJ9+sfKiBy7CGmEld3EuB1cfDPbQQs5Z56RoexEQumB7VGIUfaf2BUJbSt4wjLAMtqeOSAWU2S4SbL5ge5/OX7wemGr+vjlYGvgL1SLh6PEV+/nRBhub1Uqhyw6XNgXbkzsebB9+UrA92KXLvZntUX7ObAcYmhHP7RcPBeD+t3ZwojowmZT+5M1sB9hfXMPrm4+GcDTS05ya2Q4w8uqRABxZd4TKo5XmjW4X7P8Asif57+CRTQHfIGW2jxu3B4un0cxKDkMuazSWhubM9sbKLpRcb4f3vbZZG8De8c97f/CWku9asL3p+3GA+rZ7e7afsYx8fQUc/RRGXdmpQDs0B9srj1TicXeywqM9sIsNwpmC7SIiIiIirfAGoqd8ZwoAe97cQ+1ZlonXVmY7QMrQFCZ9w7w48cG9H/SY0pT+cvyz43hcHmLSY0joH7pMgkFzBwGhDbZXF1ZTX1aPxWohbURayMZxKm9me1leGa561xm2FhF/aHC5yS8xfz92pYy8N9iuzHbprZbsPI6BheW7i0M9lB7rUFOwfUBKdIcfk5Maiz3CSr3T43t8sNQGKLPd61sXDmFUVgJltU7ue3NHQI7hTzVNr8e0nBQA/rBsL41nYbsuCYzWMtsT+ibQb0Y/AHa/vtu8ccs/oSQXZizy38GD1LPd4/bgbnATG1uDEZMOcRkBPV5XuWxRLXq2ByqzPcJSH9Qy8gCJOWawuUvBdl+wOTCZ3R0uI5+/Fgw3DJ7d6WPEZcVhjbDicXmoLuzk8/AuNgjQ8w9nCraLiIiIiLSipsgMJgyeO5jMSZm4G91s//f2EI/Kv7zZ+7HprZdlu/BnFxIRHcHhjw6z7519wRxayJ3cr72j/UAD4eS+7aFa8ODNak8ekkxEVAfK1QVJbEYsUUlRYEDJPpWSFwmG/BO1eAyIj4ogI97R6ccPSDF/3xRU1tPgUi1t6V3qnW4ONC103FXQ+zK+/MXbs70zZeRtVouv9cWeIJeSr/f2bA9QsD3SZuW3147HZrXw9mcFLNkR3n3QaxvMBZLfnj2Y9HgHR8rq+M8nh0M8KukpWstsBxi1cBTQVEq+sQZWPAjjvuDnzPbg9Gz3ZS5HurAEOaO7M1y26KD0bLdSH/wy8k2Z7V3rWd60UD/UZeQPrISkgZCc0+ljWG1WEvqZz6PTr4GvjH5lp4/b0ynYLiIiIiLSCm8gOiY9hok3TQTOvlLy3sz26LTWM4Pis+OZfvt0wOzdbvSinoqh7tfu1e/cfkRER1BTVOMrax9s4VhCHsBisfiy21VKXiQ49hWZFw6HZcR1aSFSWpydGLsNw2gOmIn0FvuOV/v6U+8uVLC9KwzDaC4j34lgO8CIptYXe4L82nvLpkcHoIy819i+idx6gblA86dvbKeiKfMxHHkz/VNiHXxvjlkC/4kP9vl624u0x5fZHmdvcfvohWbf9oOrD9K47FGoK4M5P/XbcUv2lrDzrfymQQT2+4s3mGq3O4NePr0znNZoLI01RCWY70VDhX+D7d732mbU9cye7QHqWd7hMvJ5q7qU1e7V5b7t6tkuIiIiIiJehsfwlYyPTY9l3FfGYY20UvBpAcc/Ox7i0fnPmTLbAWb+aCaORAdF24rY9u9twRpayPky26eGNtge4Yhg4AUDgdCVkvcF28eEV7AdULBdJMi8/dq7UkIezEUyA5oCZIfUt116mZ0FzResj1c19Ij+2uGmos5JVVNmdGd6tgOMaOrbHuzM9roAl5H3+v7FwxicFktRVQMPvbsroMfqDu/ig1i7jS9PHUDfpGiKqhr4x8f5oR2Y9AhtZbYn5SSRNTmLmOhqbBv/CNNu7VJGb2u2PL+Fv0z4Cy9f95Z5gzOw3198wfYoN5YgB5k7w2UzF+xHxZifcf7MbHc3uvE0tZeweuqaqwoESbd6tgewZ7lhGB0rI19ZAMW7QxNsV892ERERERHxqiurw3CbmUcxaTHEpMUw4nMjANj83OZQDs2vvH3pW+vZ7hWdHM3MH80EYOXPV/aK3tiNNY2+AHP25NAG26FlKflQKN4RnpntAKkjUwEo2aMy8iLBsK8p2D4sI77L+/D2bT+ovu3Sy+w81rKk6q6C3lditbu8FTHS4hydLss+vCnYvjfIme11AS4j7xUVaeM3144H4KWNh1mbG54LEb0922McEdgjrHx/7jAA/rxyP1X14ZuRL+GhtZ7tXqMWjuLCCz/G5QTO/3/dP1adkze/+Sb/u/l/TXNgCx5LVNAy2x1R7qAHmTujOdhuLoDwZ89276IKAIurNug9273B9prjNb7gdofZYwFLQILN7gY3NBUbbDezPW+V+fegC7p8rMSBXQy2R9jB5lCwXUREREREmjO+HYkObE0XxibePBGAbf/chvssKXPoLSMfk97+JH767dOJ7RNL2YEyHu3/KO/d8R6FW8K7H2R3FG4pxPAYxGfHE5/d9YCSv3iD7fkr83E7g3vuGYYR1sH2tBHKbBcJptzj3ctsBxiYamZpKdguvY23T3uExWj6WcH2zjpc5i0h33oLpPZ4y8gfOFFDgys436ecbg9O7wLeyDP01/WDqTkpfG2GWRHpntc+82WRhwun20NjU7ZqbNMc65pJfRmcHktZrZO/rckP4eikJ2isbj2zHWDsJVGcc842Plw1lbqGzn9GnKzsQBl/m/k3Nj+zGSzN82U3DnAG9vtLc7DdBZHdex6B5LSaY3M4zPekobIBw/BP2znva2CNsGJx1ga9jHxUcpSvVUGng80WCzjiAxJsPjnw327P9gOrIHMcxKZ1+Vi+zPYu9a0PzPMPdwq2i4iIiIicwpvxHZvRPKkbeulQ4jLjqD1Ry75394VqaH7l60vfTmY7mJkDVz1/FXFZ5vNf/9h6npr0FE9Neor1j6/3Be3PFr4S8iHu1+7VZ3wfYtJicNY4Obr+aFCPXVtcS11pHViaS7aHk5PLyPvr4o5IKKzNPcG9r30W1ll9LreHvBPm78fuBNuby8ifXb87RNpjGIYvuD4uxfx9dWqmu5yZ93OjsyXkAbISo4iPisDtMThQHJw2FnUnLZKMsgfnMvwP54+kb1I0h0vr+N2SvUE5ZkfVnrRgOcZuBooibFbunDscgGc+PEDZSRmtIqdqL7M9ef/j1DYk8PG6iex5c0+Xj7HnzT08dc5TFG4uJCYthhuW3MDwy81z1G3Yg9iz3RX0IHNneDPbHfam/7NG82KI7vK+z5GxkWbv7yC/DhaLpXul5B3xAelZ7j03LDYLtsg2qqUYBhxYCYMu7NaxulxGHsy+9Qq2i4iIiIhITVFTsP2kXubWCCvjbzBLM255bksohuV33iB5ez3bvYbOH8qdh+7kK+9+hdFfGI3NbqNwSyHvff89fpf9O/678L/sfXuvr7daT3Zsoxlsz5qSFeKRmCxWC4PmDALgwAfBLSVftKMIgOTBye33hQuR5CHJWCOsOGucVB3tfRN6OXv8evFu/r3hMP9afyjUQ2nTodJaGt0eoiNt9E3qeqZVcxl59WyX3uNIWR1VDS4ibRYmpXoz2/V7q7MONwXbvYt2OsNisfiy2/cEqZS8t1+7zWrBbgvOZfg4RwT/d9VYAF5cf8g3hnDgzbSPtFmwRzS/HpePy2JUVgJVDS7+snp/qIYnPUBbPds5vAF2vcmRmJtwuyPY9equTu/b4/Kw7J5lvPT5l2ioaKDfjH58a/O3GDx3MPYEM7gfjGC77znanWFeRj4KABu1WGwWwH99272vgT3WDo01QS8jD82l5LuU2W2Pgwb/B9tddU2foe2VkC/JhapjMPiibh2re8H2wCw2CHeBr18jIiIiItLD+DK+TymvPvGmiXz024/Y+85eqo9XE9fHv5M+V4OLNb9ew+C5gxkwc4Bf993asbyT4TNltntZI6wMWzCMYQuGUVtSy/Z/b2fL81so2FTArtd2seu1XcT2iSXnwhzfhLu9fU35zhT6z+jf7efib+GW2Q4waO4gdvx3B3nL8pj9i9lBO663d304lpAHsEXaSB6STMmeEk7sPkFCv4RQD0mk01xuD3uOm4GfxdsL+faFQ0I8otblNvVrH5IRi9Xa/md8ewammAu8DpfV4fEY3dqXSE+xoymLfVhGHAPiygDILa6m3ukmqq3sNDnN4TIzyNWVMvJg9m3/5GCZ7zM30LyB7uhIGxZL8D7rZo9Ip19yNEfK6li1t4j5Y8NjAWlNQ1O/dnvLkITVauEH84Zzywuf8MJH+dwycxAZCVGhGKKEuVYz2w0DlvwM+owjddZ34P6n2P/+fhoqG3AkODq03+rCal697lXyV+YDMP3707nk4Ut8LeW8+3G5m4K/AeTNXo6MDPNge1MZeUtjNVGJUdSV1tFQ0QB9u79v3/scZwV3A9iD/zok5pjB5q5ltsdBg/+r13jLyLe7CP7ASrBGwsAZ3TqWN9heX17fqf9LANhVRt4vVq9ezZVXXkl2djYWi4U33nijxf3V1dXcdttt9OvXj+joaEaPHs1f/vKXFtvU19ezaNEiUlNTiYuLY+HChRw/ftzfQxURERERaZW3jPypwfb00en0ndYXw23w2T8/8/txNz65kVX3rWLJ/1vi932fqq7EvFhpsVmISur8xayY1Bim3TaNWz+5lW9v/Tbn3nkuMekx1ByvYcd/d7D939vb/fPZPz7jrW+8FXalvxsqGyjZUwJA9uQwCrZfZGa2H1l/JKjVA3zB9jHhGWyHlqXkRXqiAydqfD1stx4u52h5YDOmumpfU7B9WEZ8t/aTnRRFhNVCo8tDYWW9P4YmEva8JeRHZcWTZIek6EjcHsO3iEU65kg3ysgDjMw0P7/2Bimz3Vs2Pdoe3AUVFouFBWMzAXh3W2FQj90eb2Z7bCuvx5yRGUwakES908OTK3KDPTTpIVrNbN/9Dhz+GOY9QPrYPqQOT8Xd6GbvOx1ro3Dww4M8dc5T5K/Mxx5n59r/XMv8P8z3BdqhOdjudEYGrYx8ZIQzJEHmjvJmttNQ5Xt9/J3ZHutdRx2CcvpJA5OA8Cwj325m+4GV0H9at18ze5yd6KaFbZ3ObnfEBySzP9z5PdheU1PDhAkTePLJJ1u9/6677uK9997jn//8J7t27eKOO+7gtttu48033/Rtc+edd/LWW2/x8ssvs2rVKo4dO8Y111zj76GKiIiIiLTKm9neWnn1iTdPBGDr81v9Gij2uDysf3w9AOV55X7bb1t8CwpSY7B0M6uwz/g+XPr7S7nr6F18+c0vc+mjl7b7Z97v5xERFUHxzmJfFnm4KPi0ADBXcsdmhE+PvOTBydgcNjxOD+UHy4N23OId4Z3ZDicF2/co2C4906l9m9/bHj6BkZN5g4Ld6dcOZn/evsnmxbuDJerbLr3DzqZg+8jMeCwWGJlp/j9S3/aO83gMjvgy27sWgBreVEZ+d7DKyDu9mdzBr16wYJyZzb58dxENrvAoJe/NbG9t8YHFYuHueSMAeHHDIY6U6feDnO60zHa3E5b9AobMgSFzsFgsjLp2FEC7peQ9Lg97397Lf675Dy9c9ALVBdWkj0nnmxu/yZgvjjlt+6hEM7DsdEaAM7DnpjegGmFrDOvMdsNiw4iMMYPtif4Ntnvf5+j4pkXmISwjX3agrPMPtgemZ7m3jHxEdBsFyz1uyPsQBs/2y/G6XEo+QJn94c7vZeQXLFjAggUL2rz/o48+4sYbb2T27NkA3HrrrTz11FNs2LCBz33uc1RUVPDss8/y4osvMmfOHACee+45Ro0axccff8y5557r7yGLiIiIiLTQVhl5gLFfHsv7d75P0fYiCjYV+K3U+O43dvv6gdUU1eBqcBHhCFzXJ2+/9taeY1fZIm2MuHJEh7Yt+KSAbS9uY8tzW+g71Q+15vwkHEvIg9m3PXVYKkXbiyjZW0LKkJSgHDfcy8gDpI5IBaBkd0mIRyLSNd6M1zhHBNUNLt7bXsAtswaFeFSn81ewHcx+ywdLajlUWsOMIand3p9IuPMG1UdlxlNSBqOyEvg4r8wXhJczO15VT6Pbg81qISuxayXGvUH64ir/BITO5OQy8sE2sV8SmQlRFFbWs2bfCS4e1SfoYziVL7O9jTnOeUPTOG9IKh/tL+HxD/bx8LUTgjk86QFOy2z/9O9Qsh+ufc63zeiFo1nz4BpyF+firHW2yAIu2VvC5uc2s/WFrVQXNGfejv/qeC7/y+Uty9OfxJu53dgYEbTM9ghrY0gyujulKajsSDDnivUV/qlY5H2fo+O8wfbgvw59JpifmQWfFlBXVkd0cifalzgSoMb/C8F9me1tlZE/tgUaKvwXbB+YSOGWwq5ltpfs98sYepKg92w/77zzePPNN/n6179OdnY2K1euZO/evTz66KMAbNq0CafTydy5c32PGTlyJAMGDGDdunVtBtsbGhpoaGj+olRZaX5ZdTqdOJ3OAD6jtnmPG6rjS/jSuSHBonNN2qJzo+Mq6py8va2Q1zYfpaS6kadvOIdhfrjILM3C8XysbgooRKVEnTYuW6yN4Z8fzs7/7GTTs5tIn+CfIOS6369r8XPZwTKSBiX5Zd+tqWy6uBudGh2S137sDWPZ9uI2tv97O3N+M4eIqNOnJqE4N45sOAJAn0l9wuqcBEgakkTR9iKKdxeTMzcn4MerPVFrLjyxQNLQpLB7PbyShiYBULy7uMtjDIfPoXB9fSXwvMG2r8/M4fHluXxysIyiyvqw6lfrOanctT++Bw1MjeHDfcpsl96hos7paw8xMjOetbvMoDugYHsnHC41X8PspCgibF0r1hrXFORtdHtocLlxRAQ2CO4NLge7jDyYfdDnj83k+Y/yWby9MEyC7WfO9P/BpSO45k8f8eqnR/nWhUMYkq65tzRr7uVtNzOHVz4EE74MWeN922ROyiQpJ4ny/HJy38tlyKVD2PnyTjb/bTOHPjzk2y4mLYbxXxvPpJsnkTE2o93j+oLt9bagBNstFg82qxMiOxHgDQVHPDRU4kjoBwQgs90bbA9Bhn/qsFTSx6RTvKOYvW/tZcLXOrH4xxEXmDLy3p7tbZWRP7DC7JeefY5fjufNbO90Zb0AldEPd0EPtj/xxBPceuut9OvXj4iICKxWK08//TQXXHABAIWFhdjtdpKSklo8rk+fPhQWtl1K7aGHHuL+++8/7fYlS5YQExPachtLly4N6fElfOnckGDRuSZt0bnROo8BeyosrC+ysK3UgstoLrH97b+t5Y5xbmzdq7otrQin87Fwv/m9c3vedg69e+i0++tHmiu2t/5jK645Lqz27nVnqtlbw5F1R7BEWLDF2nBVuFjyyhLixgTu4lLxajNjucJVwbvvvhuw47TFcBtEpkVSf6Ke/9z/H5LPT25z22CeGwe3HDT/rj1I+bvlQTtuR5TbygHYvGwzxYOLA3682lwzCBaZHMnSleHz//NUrirzQnbVkSreevUtbNFdv6Adys+h2loFHXsjwzB8Ga9zRvVh9b4TbDlczvs7CrlhRk5oB3eSYxV11Dnd2G1WBnSxfPPJBqaYGUoHS3vWee/2GGzML2VMdgLxUe30yxQ5ibd6Rd+kaBKbstG8vcN3FVRiGAYWiyYXZ3Kom/3aoTnYDlBd78IRF9gguLeMfCgy2wFfsH3pzuM43R4iu7hIwV+ae7a3HZI4Z0AyF4/M4IPdRTy6dC9//Ip/gkbS8xmG4ct4tsfa4aM/Qn0lXPSTFttZLBZGLRzFut+tY8kPllB7Yy2N1ebjLFYLQ+cPZdItkxh+xfAWfdnb4+tJXmcDZ40fn9XpnLVOIiPN/yvhXEYewLDHYWmo8pXZb6jwb892R0xTC4wQlJEHGLVwFMU7itn16q7OBdvtgSmjfsYy8nmrIGcW2PwT9vUG2ysPdfK52OMDUkY/3IUk2P7xxx/z5ptvMnDgQFavXs2iRYvIzs5ukc3eWffeey933XWX7+fKykr69+/PvHnzSEhI8MfQO83pdLJ06VIuueQSIiM1CZNmOjckWHSuSVt0brQu70QNr28+xutbjlF40orcEX3iuHJ8Fn/9MI9DNS6OxY/iWxeEX3nXniocz8d9394HwOzLZpM5KfO0+z2Xenjy2SepOlLFYOdgRl81ulvHe+PFNwCzRH3lkUoOrjzImH5jGHPZ6f3i/GX1xtUc5SiDxw5mwWVtt4EKpLhP4lj70Fps22xc9tBlp90finMj7448AC647AL6Tg+f8vYAW4u28s5r7xDvjOeyy05/vfwt991c9rKX1IGpQTledxz4fweoLaplyqApZJ2T1enHh8PnkLc6m/QuxVUNlNQ0YrXAiD7xLBibyZbD5SzeHl7B9n1NWe2D0mK7nFF6sgGp5sXjQz0ss/25tXn83zu7iIq0ctm4LL40pT/TBqUoUCrt8gbbR2U1X58ckh5LpM1CVb2LI2V1Xe5B3pscbgq2d2fBj81qIcZuo7bRTXWDi9Q4h7+G16q6DmRyB9LUnBTS4uycqG5k3f4SLhge2rZA3p7tMWdolXXXvOF8sLuItz8r4O5LaxiYGualtCUo3I1uDLcBQKRRCh89Aed+G5L6n7bt6GtHs+536yjPKwcgeUgyk74+iQk3TiChb+djRd5ge32tDZyBzdg1g+1NFa/CvYy8Ix4aqrEnmOX3/Z3ZHhXTtOggRK/D6IWjWf3AanLfz6WhqgFHfAd/ZzS9Lv7Wbhn5xlo49DFc8ku/Ha/rPdsD8/zDXVCD7XV1dfz4xz/m9ddf5/LLLwdg/PjxbNmyhUceeYS5c+eSmZlJY2Mj5eXlLbLbjx8/Tmbm6Rc6vRwOBw7H6Sd7ZGRkyC/ahsMYJDzp3JBg0bkmbdG5YWYovfrpEf678TCfHCzz3Z4UE8nnJ2TzhSn9GZOdgMVioU9iNHe/8hmPr9jP/HHZfulZKs3C5Xw0DIO6E2ZpuMTsxNbHFAkTb5zIh7/6kO3/2M6Er3S9n2DlkUp2vboLgPP+33m+cvI1hTUBfT3qy8zs/Pg+8SF73c+55RzWPrSWA0sPUHe8joR+rV/4COa5UVtkXsht870PofSR5gXSsn1lQRlbfYl5jsRlxoXda3Gq9JHpHCw6SHluOQOmD+jyfkL5ORTur7EExo6mINzg9Dii7TYWjM3iocW7WZ9XSmlNIylt9A4NttzjTf3a+/jnu09OU+Akv6SmR2X1ekuB1zs9vPbpUV779Cg5qTF8YUp/Fp7Tj8wu9pGWs5u3esXo7ObvOfYIK0Mz4tlVUMnOgkoF2zvgcFlTZns3X6s4RwS1jW6q6l3+GFa7vJntUSHKbLdZLcwbk8mL6w+xeHthyIPtzZnt7b8eY7ITmTU0jTW5J3h3WyHfmT0kGMOTMOfNTgdwbPo9RNhh1l2tbtt3el9m3jOT2uJaxt8wnoEXDOzWdw1fZnuNBZyBXSjYItjeI8rIN2e2+7tnuyMqtMH2jHEZpAxLoXRfKfve3cfYL43t2AMdgcnsbreM/OGPwd0Igy/02/ESB3Y12B5nVoDwuMEamt9/oRDU2jHe/ulWa8vD2mw2PB6z/8LkyZOJjIzkgw8+8N2/Z88eDh06xIwZM4I5XBEREekFXv7kMD985TM+OViG1QIXjUjnya+cw/ofX8z9nx/L2L6JvknZtZP7MXtEOo0uD3e/shW3xwjx6CUQ6svr8bjM76Yx6W1fzJt400QA9i/ZT+XRrmekbvjjBgy3Qc7sHDInZvoCzpVHApvlWltsXiSISQvdxd2UISkMvGAgGLD171tDNg6vxppG32rx2IzwyyJIHZ4KmD3TXEG4QFxdaAbX4jLDf2FR6gjztSnZUxLikYh0zqkZrwNSYxiTnYDbY7B0Z9ut9ILN2699qJ9653ozU6vqXZQ3fe72BN4s1c9PzObLU/sTa7eRX1LLb9/fw3m//oCbn9vA4m0FNDZ9jxAB2FXYFGzParmo0PvzLvVt7xBvZnu/5O4Fn+KizNyzmobAf5fqSI/yQFsw1kxeW7qzMOTz1xrf63Hm/L/5TeN+b3tBQMckPYc32zkjqxzL5n/ABXdDdFKr21osFuY+NJfPPfM5ci7M6faiPkdiU7C93obRGNie7a5aF3a7N9gefnPSFpqCyr7FCP7KbG/6bhjqYLu3JQHArld2dfyBjnjwOMHln9fDq90y8gdWQVwfSB/pt+P5ysgfrfRdI+sQh9kqp7f1bfd7sL26upotW7awZcsWAPLy8tiyZQuHDh0iISGBCy+8kLvvvpuVK1eSl5fH888/z9///neuvvpqABITE7nlllu46667WLFiBZs2beLmm29mxowZnHvuuf4eroiIiPRym5qy2S8fl8W6ey/muZuncfn4LBwRp18QsVgsPHj1OOIdEWw+VM7f1uQFe7gSBN4gtD3eTkQ7JQ5ThqYwYNYADI/R5UBxY00jm/66CYDpd0wHaA62Hw5wsP1EU7C9nQUFwTDhJrMqwJbntmAYIb4AWGT234uIjiAyNvyyjGMzYrHH28GAsgNlZ35AN1U3ZbLG9gnzizxA2sg0AE7sPhHikYh0ji/j9aQgnDcwsnh7+ATb9xWZ2TnD/JTZHm23kdFUirMn9W33Bs7G9U3k1wvHs/Gnc/ntteOZmpOMx4AVe4r5zr8+5dyHPuCJD/aF/PeahJ7T7WFv0+K1U4Pto7LMi9HezwFp3+FSM8DVnTLyAPFN3++rgxBsr3d2PLgcKOcOTiUxOpIT1Y1szC8N2TgAapte81jHmRcfzBvTB4sFth6p4EhZz/k9IYHTWNOIxeLhyiuWQPJAmPqNoB3bWz7c6YwIbma7PbyrnhhNvbl9ixH81LPdu7DCbndCRFRIs6NHLzRbBu57d59vEcAZeXvM+7mUuq+MfGuZ7QdWwqALwY/VouL6xGGNtGK4DaqOdSxTf+crO8n7qGlO3sv6tvs92P7JJ58wadIkJk2aBMBdd93FpEmT+PnPfw7ASy+9xNSpU7n++usZPXo0v/71r/nVr37Ft7/9bd8+Hn30Ua644goWLlzIBRdcQGZmJq+99pq/hyoiIiLCzqZMks9NzKZPwplLf2YnRfOTy82VrY8s2cOB4t61UrM3qCk2A66x6WcOME68eSIAW5/f2qUL6ltf2Ep9WT3JQ5IZfsVwgF6V2Q4w5gtjiIyNpDS3lMMfHQ7pWLzB9tj02LAsaWyxWHzZ7SV7A5/BXXPcfD16Qma7gu3SUzVntsf7bps/NguAtbknqKgLfda3YRjNme1+bKEzsKlv+8GSGr/tM9C8JaGjm7JUY+wRfGFKf17+9nks/38X8p3ZQ8iId1Ba08jvlu5l1d7iUA5XwsD+4moa3R7iHRGnZWR7y8p7M9+lbQ0uN8erzPLE3S4jHxW8YLt3gU6oysgDRNqszBvdB4DF20KbJd6ZzPaM+Cim5qQA8F4YLT6T0HHWOJk2bQt9s47A55+EiA72z/YDa4SVyJhInM5IM9gewMV0ZrC96fMpMryD7WZme6X/M9t9wfbGkPetz5qcReLARJy1TnLfz+3YgxzeYLt/f797y8ifltleWwoFW2HwbL8ez2K1kNi/46XkC7cW8vIXXmbFrz4xb1CwvXtmz56NYRin/Xn++ecByMzM5LnnnuPo0aPU1dWxe/du7rrrrhYXs6KionjyyScpLS2lpqaG1157rd1+7SIiIiJd0ejysPe4+eXv1EyT9nxpan/OH5ZGg8vDj179DI/KyZ9VfAHXDpQRH/2F0UTGRFKyt4RDaw516jiGx+DjP3wMwPTvT8dqM7+aJ/QPUrC9KbO9I4sKAskeZ2fMF8YAZnZ7KHXmvQ+VYAbbfWXk/ZTJGkjeYHvJ3hI8bpVvlp6hrtFN3gnzc+fkXs5DM+IYlhGH023wwa7joRqeT3FVA5X1LqwWGJTmv8/HASnmvg6V9JyMxbp2SkIPTo/jR/NH8tE9c7hmUl8AFm9TgKi38y6oGZkVj9XaciGfd/5xuLSOyvrQL6wJZ0fL6jAMiI60kRpr79a+YpsCvcHo2R4OZeQBFoxrKsm+ozCkc1dvz/aOvh4LfKXk9Vkq4CnO5eKL1/DZ3hkw8LygH9+R4KCxMQILht/Lg5+ssabxpDLyYR5st8e16Nnur8x2b8/2yAhnyIPtFouFUdc0lZJ/tYOl5ANURt2X2R59SmZ7/oeA4dd+7V6d6du+4mcrAKivbfo97efM/nAX1J7tIiIiIuEkt6gap9sgIer0TJP2WCwWHrpmHLF2Gxvzy3hhXX7gBilB58v47kB5dUe8gzFfMgPFb3ztDV9wsiP2vbuP0n2lOBIdTLp5ku92b2Z79fFq3E0X6PzNMIywKSMPzaXkd/xnh29iHQre9z6cg+0pw8wMn5J9wcts7wll5BMHJmJz2HA3uKk4eOYLASLhYM/xKjwGpMXZyYhvWV1nwTgzuz0cSsnva8pqz0mNbbXNTlf5Mtt7UBl5X2Z7O1mqETYrCyf3A2DJzkJcWgDUq7XWKsIrKcZOdlOAYndB78r+6qxDTZ8TA1Jiul19KJiZ7fUd+MwIhplD04h3RHC8soHNh8tDNo6ahs4tPvD2bd90qIzjlfUBG5f0AB4PqTt/TlVVLJv2XxGSITgSHGZmOwS0lHxPKiMfsJ7tTZntEbaGsOhbP/pas5T83rf24urI7w57U7Ddz5nd3p7tp5WRP7ASUodCYj+/Hg+a+7aXHyxvd7sjHx9h71t7AWhs9Abbe1flHgXbRUREpNfaccwMyIzOTuj0RZt+yTHce5m5uvU37+3uUSVQpX3eMvIdDULP/fVckgcnU55fzotXvEhjdceCxd6s9nO+eQ72uOYMnZi0GGx2GxhQFaALrw0VDXhcHt/xQm3gBQNJHpxMY3Vjx1eLB0BPymwv3Rv4npvenu09oYy81Wb1vTYqJS89hTcIN6qVIJw3m2/V3uKgBITa4y0hP8SPJeShOdjekzLbvVmq0WcogTx9UArJMZGU1TrZkBfaHsk9xeq9xVz9p7XsP8taNO1q+i7X2v9zaK5qsfNY71so1uBys+hfn/L9lzZTeobFlofLzH7t/VM6vkC6Lb6e7UHJbDePER3izHZHhI05ozIAeG976ErJe6uDxDo61sM+KzGaif2TMAx4f0foF59JCG18muiqzbz55jwsUaGZq5nB9qZz11kXsOM4a509JrPdcMSDx4kjzryeVl/hn0Uxvsx2W+jLyAP0O7cf8dnxNFQ2cGDZgTM/wJvZ7ufMbm+w/bQy8gdW+b2EvJc32H6mzPblP1nu+3dDQ9P1LT9n9oc7BdtFRESk1/L2ax+dldilx39l2gBmDE6l3unhh6+onPzZwpfd3MHy6rEZsVz/3vVEp0ZTsKmAl7/4si+Q3Zbjnx0n74M8LDYL0783vcV9FouluW/74cCsBPYuKLDH24no4MWuQLJYLL7s9i3PbwnZOLzB9piM8L2o4SsjH+DMdleDi/oy82JJTygjD5A2oqlv+x4F26Vn2FXQdsbryMx4clJjaHR5WLG7KNhDa2FfkRksHObnYPuAFG9me89ZsOjNUj1TVmaEzcq80eaCiXdDGNjqSZ5Zk8fmQ+W8uL5zbXnCmWEYzfON7NaD7d4gvHe73uQ/Gw/zzrYC/rflGJc//iGfHiprc9sjTZnt/ZK7/x0tmJntdU5zThDqzHaABWPNiinvbivECGC/6fbUdLKMPMBlTSXw1ZajFys9AMvuozj+ag4e7N9ioXowORJPzmwPbLA9MtKFYbWDNfSfHe2ym98No6LN4Li/M9ttlvqwCLZbrBZGXj0S6GApeW/P9kb/Jk+0Wka+/BCU7g9csL2pjHzloba/p+QtzyNveR7WSCvJQ5Kbg+3q2S4iIiLSO/jKOrZx8etMrFYLv1k4nuhIG+vzSvnX+oP+HJ6ESGfKyHulDkvlK29/hYioCHIX5/L2d95u9yKWN6t99MLRvpXCJ/MF2wPUt91XQj4Mstq9Jt44ESyQvyKfsry2L7YGUo/IbB9mBturC6ppqApcr0Dva2GNtBKVHHWGrcND6khltkvP0l4QzmKxML8pMBLqXrXezPZhfl54MzDV/Kw9XtngC2KHO1+WagcCZ/ObAkTv7ziuBZlnYBgG246UA7C5nYBrT1NU1UBpTSNWCwzvE9/qNt7FNrt6WRn5ukY3TyzPBSA+KoKCinq+9NQ6nl+b1+p3aG8Z+f4pfgi2O8wgRTB6ttd1IbgcKBcOTyc60sbR8jq2Hw3N4o7aTma2Q/MigfV5JZRUB+67r4Qpjwf+9z2ITeeg42YA7LEhCra3yGwPfBl5IyJ85uptasrgjooyg8DOGucZEw86wpvZbqPeF9APtVELzcqWe/63B/eZvrdGxgIWvwebnXVNwfb/z955x0lu1+f/UZnR1O39dq/b189XfPadey9nsA02hJYEmxBCDAk4IYQkOBBCnAAJSX5xQkKxaQ4E29jYPpfDvdz57Ou9323vbfpoRvr9IX01s7szu1OkGX13v+/Xy6+E2ykajaSR9Hye50mPkT/zGsDxwMIrTH0vwkzOdlVVDVf7xs9sRMOqBqgqD4WTWGc7g8FgMBgMxlwg3WmyqkCxHQDm13rw5VuWAQAefO4YOijqHWVkhri+c3W2E1o3t+KuX9wFjuew9wd78cY338j4uGBfEAd/fhAAsPmLmzM+pqLNYrE9T/d+KaicX4lF1y0CAOz/8f6yLIMhtttovUzGVeUyBkGGT1oXTUz62n2NvqK7UUtF3XLN2T50zPo+ewajWBRFndbZDqTcfK8c7y+rGE3E9qX1mcXCQqn2OIw453ZKzp8iRoz8zMLZ5Uvq4HeJGAjEsHsWCchW0DUawYju1jrUPY64CTfq7QAZ7F1S74Mry4AGcbYf7wsgkZwdnzsXfrzjHAYCMbRWu/H6l67F1jVNkJMqvvb0EXz+f/ciNMl13jGS6mwvFuJsn/weVhCRcz9mWI3bKeDa5fUAgOfKlLhB1nk+wwdtNR6saqmAogLbj/RZtWgMu/LeD4HzbwJ3/AdiYW3fdXgdMzzJGkrZ2e50ygAFYruqi+1OR2oQxoyBcMPZrkZs01u/4MoF8NR7EBmO4PxrMxhteF4bEihFjPzZ14DmdYC72tT3IqR3tmcahjv57El07uyE6BZx1V9fBVeVNqifUN3M2c5gMBgMBoMxF+gciSAQTcAp8FhaZCzq721ZiEsW1iAcT+IvnzhQtlg+hjkYQnQB7ubldyzHLf9+CwDgla++kjES/b3/eg/JeBKtm1vRurk14+vMRWc7AKy7Zx0ALUpeLYMLkAZnO5Byt1sZJR/s1W4MeBvtvS7SIWI7c7YzaKB9OIxwPAmnyGNRXeb9bM28SsyrciMcT+K1EwMlXkKN0XAcg0HNXbTE5GMjx3GYr/e2n6ekt90QznJwtjtFHjeuaATA4o9n4lBXyi0VTyjGIArtzBQhD2jisdcpIJ5QcGaQnkqFYhiPyvjea6cBAF+44UJUe5146GMb8MD7VkLkOTxzoAe3/8ebONmXuknfMWxBZ3sJxHbi5LZDjDwAIzHluUPliZI3nO3O/Gqsbl2tR8mXOemFUWKGzwLb/xbY9AfAoqtSPd6zWGxXVdWIkbeLyDwtutguKCGI+iBTbKx4sZ1817xqjxh5AOBFHsvv1KLkjzx2ZOYnSD7zne3hSc52VQXOvAosvtrU90mnsk0T2+OB+JTvVlVSrvZLPn8JfE0+SFUSACK2z47zuVxhYjuDwWAwGIw5yWHdaXJhkw8OobhTIp7n8K2718Ll4PHWqSH8764OMxaRUSaM3u48YuTTueS+S3DZX1wGAHj600/j9Iunjb8logm8+5/vAgAu/cKlGZ8PoGSd7YV+RqtY8YEVkCokjJ0fw7nXzpX8/YsZtCglRm/7CQvF9j5NbKelrx1IdbaH+kOIjFjXo8hgmAER4ZY3+SFmOQ/RouRJV215XIjD+s1Ov0uEJ09xJBcWGGK7/UVGOalATmriVK6uTPL9PX+ohw1jTsPBronRpPs6RsuzICZD9vMVWdIrAO06Yjnpbe+eGzelf/jGWYyGZSyp9+ID6+cB0I53916xCL/8zGY0VbhweiCEOx56C0/t68JYRMaYHp3bZkZnuy62B0rhbNfFZSuOn4Vw3fIGOEUeZwdDON5XWsehqqqpznYpv+EDMiTw1qlBjOliE8NilCS4zl2Q5MzR0da/vwL85vOAtxa44esAgLg+/GePGHlrrjWSsSSgAg6HTIfYTiLeYwFIFZrIWmxvu6qohoObT4ZtEyMPpKLkj/36GJSZ0mgkPxA319luxMiTzvb+I0BowLK+dkAT9sl9o8lR8od/dRh9B/ogVUi4/C8uBwC4q7WhODkhmf757Q4T2xkMBoPBYMxJjnRrJ4nZolvzZWGdF39+kxYn/w/bjqJrlAk9NKKqasEx8unc8OANWP3R1VASCv7vrv9D7z7NhXHwfw8iPBBGRVsFVt61MuvzLXe2D9jT2e7wOLDqI6sAAPse3lfS91ZVlRpne82FNQCsjZE3nO1N9l4X6Th9TmPfGTrOouQZ9oY4d1c0TX8eQtx8Lx3tRyxR+ij5sCEUWePKnF+jHWNoiJGPpEX5Z4sEn8xVF9bD4xTQPRbF/s4yCRYUcFDvj26u1KJHZ0tv+9Hu6asiCKne9tkvto+E4vjhm2cBAPffuAwCP7GqZuOCGjzzJ1fg8qW1CMeT+NNf7MMXf7kPAFDrdebV9Z0N8hrBqPWibSpG3h634H2SiKsu0KPkS5y4EZUVkJmjfJ3tSxt8uLDRh4Si4rdHWZR8SVCSEH+8FQ3jB8rz/rt/BJx7A7j9PzSHMFLR4vZwtltzv8dwLjtkcBIF12G6sx2xIKRKc8R2IigDAJcM28bZDgCLrl0EV5ULof4QOt6awWTjtM7ZbsTIn3kNEF1AW+Z6QrPI1NuuJBS8+sCrAIAtf7YFHn2AlsTIx2WJxcgzGAwGg8FgzAWOzNCTWgj3XL4IGxdUIxhL4C8fZ3HyNBIbj0GRtQnlYlzfHM/hjofvwMJrFiIejOPnW3+O0fOj2PndnQC0iC1ezH4qbnlnO4mRt5mzHQDWfXIdAC2ardgL9XyIjkahJIr/7kuBESNvobM9vbOdJmqXaeuGRckz7A5xsE4XLw0AG+ZXo8EvIRBL4O1TpR8iCVvsylxAUYw8cajyHCBN8xuejssh4NrlDQDK15Fsd1RVxcHOUQDAxy+dD2B2ONvD8QTO6okN0znbgdRx4MgcENu/99ppBGMJrGqpMIaJJlPnk/CTey/F569bCgB4+Vg/AKDVhL52QEvqAEocI28TZzuQGuJ6vsSR7MTVDhQWq58egT+b2H1+BG+etOF5q+iEKkgQlWjp33vkHPDiA8DF906IxyZie9mc7ZXpznZrzluImOqUEnSI7aIb4AQgNm4426NjxW0z5HvW/4etxHbBKWDZ7ZrJ5sjjM0TJS37TxWbi+Ddi5M+8CrRdCjhcpr7PZNJ72wn7f7ofQyeG4K51Y/MXUmI/EdtjMafpnfV2h4ntDAaDwWAw5iTkJveqeZWmvaagx8k7RR5vnBzEr97rNO21GaWBOL4dXkcqmqtAREnE7/z6d1C/qh7BniB+cOkP0H+wHw6vAxs/vXHa5xJ3bqAngKRsvpPRrs52AGjd3IraZbVIRBI4+tjRkr0vcbVLlRJEE1xTVlKKGHkittPU2Q6w3nYGPRzNIV4a0CKmjSj5Moi1YV0csapveIEunlHhbE8bPOA4boZHp0gXttgg5lS6RiMYCcsQeQ4f3tQGADg3FDYqDGjlWG8AqgrU+yXU+6VpH7siLUZ+Nm8jfeNR/HjHOQDAn9+0DDyffT8SeA5/dtMyPHzPJlTposKiWnPOW32Gs91asT2pqIjrg5x26WwHgBtWNELkORzvC+D0QOmEkHAs1V8/3XefDXIsff3kQEkGJUqBoqj45MO78MmHd2EoWLoh45yRfBCTJU7sUxTgqc8Bnhrgxr+b8Cc7dLYDHBJJBxC3VmyXXEnA4bbkPUyF4wxR2aWn0xQ7MG98zx4HuHgYcNjrnsWKu/Uo+SeOQVWm+c22OkY+KQPn37I0Qp5QuWCisz0RS+C1r78GALjiL68wBi2AlNgejTqYs53BYDAYDAZjtjMSiqNbn7Zd3uQ39bWX1PvwZzdeCAD4xrNH0DPG4uRpwowI+XRcVS58fNvH4W/xG+LlunvWGRcg2fDWe8E7eEBNxXmbCXG2m/U5zYTjOKy7Zx0A4MBPShdbSEuEPADULNVi5KMjUYQtcoOS7c7XRJeznYntDBoYDaedhzTPfB5CxPYXj/RBnqkf0mQiVsfI6+JZ50gYyeluWNoA4lDNNUKecO2yBkgij/NDYRztmVs3HXPhkN7XfmGjHw1+Fxbr5yb7KXe35zpQAwDLGv3gOWAoFMdAwIaCm0n8x8unEJUVbFxQjWuW1ef0nGuXNeDpz12Bz16zBJ+//gJTlsOnO9tD8aSlx5306gmrjqGFUOlx4LKl2vlSKd3tYVkTyL159rUTljf5sbDWg3hCMdIOaGc0IiMQTSChqDjZb0MHqNNXemf77of1+Pj/l4oo1ym7s10XFBNJh2XOdiI0O10JwGH/61IAgFQxsbN9rMgYef17lvw8oMi26mwHgCU3LoHT58R45zi6dnVlf6DVMfJduzUxvxRiu+5sH2/Xzm32fH8Pxs6Pwdfsw6b7Nk14rKtaF9tDIhCfW+e9TGxnMBgMBoMx5yARjQtqPfC7zJ+K/oMrF+OitioEogn81RMHZ7VDZbZBHN9mCq6V8yvxsW0fg9PvhOAUsPlPZ+7T4ngOFfP0KPkO8yNFyVCBHZ3tAHDR714EjufQ+XYnol2lucFjiO02HECYjMPjSHWTW+RuD/bpYjtlMfJMbGfQADkPaatxoyKH85BLFtagxuvEaFjGO2eGrV68CaQikK0Ripor3XAIHOSkiu5Rew8oEuEsX9HMK4m4+kK9I5lFyU/hoC62r9HTpta3VQOgv7f9SI597YC2fy2q084/Ds/SKPmO4TB+8W47AM3Vnk86RFuNB1++ZTmW1JtzTuJLSzBKjzY3GzKsxOVRPVEqtpYhMSUUK66WhOM4I0r++VlyLE13s5/Rr89shdMPMVlCsT0RA7b/LbDh94Al1075sz2c7dB62y3ubHc6ZcBpz2v1KejOdrM628n37K3U76PZKEYeAESXiAvfpxlspo2Sl/ymxqgn5STUpLZOHB6HFiHvqgSaLzLtPbKRHiMvh2W88c03AABXffWqKYmQxFgSCQrM2c5gMBgMBoMx2zncrd3UWzVDT2qhCDyH79y9Fk6BxyvHB/DEnmmmXRm2ggiuZnd2N13UhM8e+Cz+cPcfGq7kmSBiqhW97XbubAcAf4sfS25eAgAYfrk0whJNznbA+ih52mPkR06PWFLBwGAQVFXFt184hn/77cm8n5uPCAcAosDj5lWNAEov1ob1/chrUd+wwHNoq6YjSp4IZ4XEQd+6hghbs6tr2AwOdmn7w5pW7UbuuvlVAIC9s8bZnluK1sqWygnPm23820snISdVXLG0DluW1JZ1WSSRh0PQxP6QhXHk6ceMfIYLSsGNKxvBc8ChrnF0lOjYS2pJinH5b9WPpa8cGzDWL80MpIntpYz0zxVV8sFRyhj5yKjmhL3w1ox/touzPR4XLe9sdzgStotPz4rkm+BsN6uz3VNhT7EdAFbcpUXJH338aHZzjeQz1dlN+toBPUb+zGvAoqsA3vrkFCK2j7WPYdd/7EKwN4iqhVXY8KkNUx5LxPbQuMA62xkMBoPBYDAIiqLOSld2vje5C+GCRj/+9AYt6vDrTx9G/3iJ49cYBWF2jHw6VQur0LC6IefHV7RZI7YnYgnEA9q0uF2d7QCMKPmRV0eglCA22eixb7DvOkmn5gJtaGP4pPnDCIloAtFR7ZhFW4y8f54fDq8DSkLByBm6XZEMe/PLdzvw0Cun8d3fnjDOK3KFRInnEi9NIG6+Fw73lTRuPWKCODITJEr+vEW1GGZh9NcXsC6uW94Ih8DhVH8Qp/rnlstnOlRVxcHOUQDpzvYqAMC+jlEoNq8WyEZSUXGsV/uecx3uJaJ8vscTGjjVH8QTezoBAH9+87IyL43mkC5FbzuJTbdThDyh1ifh0kXa0EOpouSJs90rFT68tWZeJeZVuRGRk3jtxIBZi1Y2hoJx4/8/Y0OxveQx8kTAzuLoNiLWfeUV2+W4YLmz3SHKFIntfiA2noqRN8nZ7vHbV2xfeutSiG4Ro2dH0bsvyzFUd/ybBdk2wAECFwE6dwGLrjbt9aejakEVACDQHcBb//QWAODqr10NIcPvm+FsD4lQmbOdwWAwGAwGQ7vRs/yB5/FvL+Xv2LI7JL51le4gsYrPXLUYa+ZVYjyawF/9+tCsHFyYbRiCqw0c31Y524mrnRO4Gbvjy8my25fBVe2CPCTj/KvnLX8/5mxPQdaF4BRsvY1kguM41C1jUfIMa+kdi+Kbzx41/vfjuoiUK+Q8JJ+hvy2La1HhEjEYjGH3+dINklgdIw8AC2p0sX3YhhG6aZAY+UKc7ZVuB67QO5KfO8jc7YSu0QhGwjJEnsOyJk1sXt7kh8vBIxBN4MygvbeJbJwfCiEcT0ISeSysze28ghwPZqOz/bu/PQFF1dzU6/RhinJDetsDJXC2uwo4ZpSCVOJGaRJTzHC2a1Hy2nLPhij5CTHydjzeST6IpXS2E7E9S1c5cTyXK0beValdF8WiDigxa76vlNgepytGPh5Mxcib1Nnu8unpFTYU251eJy64VTPXHHksS5S809wYeTmibxtuB7iu3YCS0JztJcBT74EgCYAKRIYjqFteh7WfWJvxsZJfAjggHneCS0SApHW/s3aDie0MBoPBYDAy8tqJAcQTCn7wxlnjwng2EJWTOK27l1daFCNPEAUe3/7QWjgEDr892off7O+29P0YxWNLsd3kznbjM9Z5bBdpmY4oiVh47UIAwMAR650rtIrtVjjbSV+7t8Fr620kG6y3nWElqqrib548iEAsgRo9xvSpfV2Qc0zgiCcUw9mcz3mIU+Rxw0otSn7bwdIJDEQsstbZrh13223ubC92XdyqpxNsY1HyBof0vvYLG/2GICkKPNbOqwJAb287Sa9Y3uSHKOR265WI7WcHQ7MiHptwuHsMzx7oAccBf3bTheVeHANSjWGls70Ux89iuHlVEzgO2NM+ip4x6wXVUNycWpJbdbH9paP9iCXo3leGQilne8dw2H6fp9TO9jgR292Z/0yc7WWKkXf6tfeVZRFqxJokAiK2i0I869CB7SCd7SY7211e+4rtQA5R8pIPSMaARHzq3wrA2DbcIhDSr3MrWkx57ZngOM6IkgeAa/7uGvBZzm84XjN1xGL6fmpilL7dYWI7g8FgMBiMjJDezGAsUbJouVJwvDeApKKi1utEg1+y/P2WN1Xg89dpE69/+5vDGAgUd+HBsBYrY+TzxWpnux0+40z4WzWXW7Db+lhF2sR2EiM/dGLI9NSMYK+2vmmLkCfULtdd/8es6bNnzG2eOdCD3x7th0Pg8NNPXYJarxODwThezzHO9lR/EHJSRYVLxLyqzDeTs7HViJIv3XlZytluTWc7ACwsMEb+rVODWPd3L+K5Eg0fGM72AoWzG1c2QuA5HO0Zx/khGzoYy8BBXWxf2zoxbYr0tu+jtLf9SI/2ufIZqKn3S6jzOaGowPG+2XNj+p9fPAEAeP/aFixvsnbQOR/8urM9aKWzvYg0jFLQWOHCxvnVAIAXD/dZ/n5hfV17pOLWx4b51WjwSwjEEnjrFN2DlYNpMfKKar+hM1Xyl8fZnsHRrapq2Z3tgkOA6BYhyyKUiHXOdo5TIPCJrEMHtkOqAGKBlPPfJGe720PEdntek174vgshOAUMHR/KbA6QtHsZiJtzL4N0tjs8Dj2enivpQAYR25vWN2HlXSunfewEsX0ORckzsZ3BYDAYDEZGOoZTF3q/ei+/eFQ7Y0S3tlSUzLH52WuWYGVzBUbDMr76JIuTtzO2dLabLLaTgQI797UT/Hp/abCHie2TqV5UDU7gIIdlBLrNvYAN9enropGOdTEZ5mxnWMVwKI6v/eYwAOBz116AVS2VuH2d5ijJNUqenIesaM7/PGTTQm3IpmcsWjL3W6gEne0LdLG9fTic1znS9984g9GwjFeO91u1aBMwBg8KFM6qvU5sXqx9h8/NokHWYjjYpe0Pq+dNFNtJb/ve9tESL5E5EGf7ijyqIjiOMx4/W3rbd58fwcvH+iHwHL54o31c7QBK09leghqOYrlkkXZMOluCCPOQSU5/nk9FydNey5EeIw/ASOCzDeXqbM8gICbjSSgJLUWoXM52QOttl2VrY+QdDr2bm6YYeQuc7ZJbPz7btLteqpCw+MbFADR3+xTIkIBJYnN6jDxiAW3IgS+dvLvirhVw17pxy7/eAo6f/hpmothu/b0cu8DEdgaDwWAwGBlpTxPbd5wZmiC+08zh7vydJsXi0OPkRZ7D84d78WwJ418Z+WEnwbWiTdtGAz0B48aCGRBnux0GCmbC16xdoAZ6rJ+GNr57Chz/gNanXrWwCoD5UfIkRp5WZ3u62M6Gmxhm8ndPH8ZQKI5ljX589polAIC7N7YCAH57pB+j4ZljIo+mie354k1zA4ZjpRHbSxGD3FrtAcdpDtP0SN3pGIvIhqPRSmdqOlG5+HVxi55OwMR2zaV4sHMUALBmXmZn+/G+AJV1VkQsX5nnfj7betu/88JxAMDdG1qxqM5e51c+l+aMtbSz3ebOdgCo8mjrYUwXcayEONuLjZEHYIjt24/25VzjYkcGdbHdq/+unB6wmSjlLHFne1wXsDOIzMTtDJTP2Q5oAmsiIaYi701GDstwOvXPSkuMvNOnie16Z3t0rLgBDfJdO132FtsBYOXdmsM7Y2+7pJ8DmCW2p8fIx8ZTzvkSsemzm/ClgS9hwVULZnysq8qFeJw52xkMBoPBYDCQSCroHtUuqi5o0MSWXB1bdqfQm1/FsqqlEn987VIAwANPHZ4yxc4oP6qq2ipG3tvgBS/yUJOqIX6aQXpnu93xtWjHH6tj5JWEgsiwdsyzw6BFrpDe9qET5salkxh5Wp3ttRfUAhwQHY0a2zuDUSwvH+vDk/u6wXPAt+5eC6eo3U5Z1VKJ5U1+xJMKnj4w8zCdcR5SwNCfKPCQ9PctlcBcrJs7F1wOAU0VWvRorlHyLx3tg5zUhmmCJRo8IOvCVYTYfvOqRnAcsL9jFF2jJRQwbEjXaAQjYRkiz2FZ08Qbxs2VbjRVuJBUVBzsHCvTEhbGcCiO3nFNaFier9iuHxeOzAKx/a1Tg9hxZghOgcef3HBBuRdnCsTZHrJSbDeGlayr4SiWClcJxXbZvPVxycIa1HidGA3L2HnGvPPg3rFoSQVvMmC2YYEW53/GZs52VfJDVGKAWqKBBsPZPvU6lbideQcPoYwDLFKFhHjckVpWk9Gc7URkpiVG3g/Eg5D82vGkWGc7EZUlKaENHJTQvZ0vy25fBl7k0X+wH0MnJx2LJH1w3aoYeVfpq1lyTeVyV7sRi+m1nayzncFgMBgMxlymZyyKhKLCKfCGc+ux3Z1QFLodgklFxbFe7URvVUvlDI82n89duxTLm/wYDsXxt3oMLcM+xINxJPUb9nZwffMCD3+LdvN5vMO8m640OdtLFSMfHgoDKgAOcNdSclMDaWL75Av7IiEx8r5GOp3toks0XP8sSp5hBoGojL964hAA4A+uXIyL9IhrAnG3P757+sFEVVVxtLe4oT8iEBHh12pKJRbNryFR8rkJDenO8GDUepEISK1zj6PwddHgd2HTAi22+fk57m4/pPe1X9johyuDcLJO389o620nrvQFtR5jf82VFWnOdtqvux5+6ywA4GOXzse8KvudW5Wis52GGPlKtyaOjZfS2V5kZzugDZ/dtLIRgHlJIf2BKG79t9fxvn9/M6ekGjMY0jvbL9Xj/M8M2s/ZzkFNOc6tRo4AggTwU7cRw+1cxgh5AHBVuiDLDnAJawbmJsbIUzL4rDusXXrHerGd7WSwwumM234duGvcWHjtQgDAyWdPTvyjlTHy0dI72/NBqpJYZzuDwWAwGAwGkOprb61x49bVzfBLIjpHIth51lxBp9ScGwohHE/C5eDLEmXoFHl8++6LIPAcnjnQg+1H+kq+DIzsEAes6BbLfhFPsKK3nUZne2w8hnjQupteJELeU+cBL9BziVRzgXZjbviEyTHyvXTHyAOstz2dBx98EJs2bYLf70dDQwPuvPNOHD9+PONjVVXFrbfeCo7j8OSTT074W3t7O2677TZ4PB40NDTgS1/6EhIJ+uKdC+HB546hdzyKhbUefPGGqb3Dd6ybB4HnsK9jFKf6s98o7xmLYlR38i5tKGz/8ugiRcmc7bL1ne1Aqrc9F2d7KJbA6ycGjP9d6hh5t7O43wkSf/z8obldK3RQF9vXtmYegF2vR8nT1ttuVEU05T9Qs7jOC6fIIxxPTqj0ohHi7r96WX2ZlyQzZBAiYGFnOw0x8kRsL4WzPWTy8Nata7RajhcP9yJpwnDK3z51GCNhGRE5iXM5pqwUQ1ROGr9fmxbqYvtAyF4VSE5znbkzEg9l7SknAmw5I+QB0tkugkta02Uvh9Jj5O1/vQ7AiEuXJO07SsaTSBRxbmYMVjhkKnrrG1Y3AEhdQxsQMdzkGHnN2T6eiqm3IVqMvL6vMrGdwWAwGAzGXIbc3Jlf44HbKeB9F7UA0NztNEOiW5c3VUDgc4s/Mps1rZX4/S0LAQBP7+8uyzIwMmOnCHkC6W03VWzXne12+pzZkPwSeJd2yWJlb7vR105RhDxgXYw8cbbTGiMPMLE9nddeew333Xcfdu7cie3bt0OWZdx0000Ihaa6lP71X/81YzxgMpnEbbfdhng8jrfffhs//vGP8cgjj+CBBx4oxUcoKztOD+HRd9oBAA9+cG1Gh2K9X8LVF2qC0nS1O0SEW1Lvy+jkzQXSdWtl9HE6pXJmLqjVjjftOQgcrxzvRyyhQNTP5UIli5HX1rm7SKGIiO3vnR9Bf8Cam/U0cECPh189L7PYTquzvdiqiGWN2s152qPkw/p+aUY/txUQsd3KYZ1IvDTDSsVQQZztJUgIIcdQM5ztALBlcS0qXCIGg3G8d664wdPnDvZMcMj3j1t/bCYR8k6Bx9rWKgDa0MNwqDSu+pwgYmGpxHY5nFVgtouzXRPbHeAUi8T29Bh5CoRmAMZ24nSk1kkx7nbyXYtiPDXwYWNcVVoVUnR00jZh8rAKiZEvV2d7PriqXFBVHglFAmI2S+ywEHue8TAYDAaDwSgrRGxvq9ZO7u/e2Ir/3dWO5w724u/uSOQdiWgXDus3v1YVcPPLTDYtrMaP3jpLvWNltmE4vm0Ur26Fs50MFdDgbAcAR40Dse4YAt0BrYvbAmgX24dPD0NJKqa58oN9urOd0hh5gInt6Tz//PMT/vcjjzyChoYG7N69G1dddZXx7/v27cM///M/47333kNzc/OE57z44os4cuQIfvvb36KxsRHr1q3DN77xDXz5y1/G1772NTidU298xmIxxGKpG23j49pxTJZlyHJpYr8zQd47l2WIxJP48uP7AQAf2dSKi+dXZH3enRc14eVj/XhiTyf+9NrFGYf6DnaOAgCWN/kKXgdEtBkPx0qyHknsr8Tnts4KZV6l1ut4big04/s8qw8rXrusHtuP9iMQNWebmmnbMGtd1HtFXNRaif2dY9h2oBsfv6St4NeiFVVVjRj5FY3ejOtzeaMHAs+hdzyK9sEAmitdpV7Mgjjcrcfj13syfq6ZtrPlTT4c7BrDoc5R3Kj/ltEIGQhy8mpZj/nZcInaMXo8Erds+UIxXRwUcj9m5PMbZQYe3Xg4FrH+tzkYNff3hANw/fJ6/HpfD5450I0NbYVd44+GZXz1Ka0qRuQ5JBQV3aNhy9dH74h2/VHjdUDkFLRUutA9FsWJ3jFcrHe4l5sE74IIIBkaBUqwTfKxIHiHG4kM7xUZ02LbHV5HWY8pok+ELIvg1RjkeBzIscM6V+KhuBEjL8NRkvVeCBOOVYIbDgBKdAxOnxPxYBzBoSCc1YUNRsSC2vWDyEehODxI2nQdEESfXvE0PPW4ITq9UMKjUEz4DFF9QFOQBCjRcahVC015XStwVmjfvZyUwEUK//yl/k2caTlmgs475QwGg8FgMCwl3dkOABvmV2FxvRdnBkJ49kA3fmfT/LxfMxJPguNQsJPLDIhDpBCniZm06eu1o8Rie0SP0M/kWsyXkVAcoznGDVa6HaixSSz7dNhRcLUkRp6iznZgothuFcZ3T4HbP53KtkoIkoBkLImx82OoXlz8jblENGE4EViM/OxkbEwTgmpqaox/C4fD+NjHPoaHHnoITU1NU56zY8cOrFmzBo2Njca/3XzzzfjsZz+Lw4cPY/369VOe8+CDD+LrX//6lH9/8cUX4fGU//izffv2GR/z1Dke7cM8qpwq1uMctm07l/WxsgK4BQF94zH82y+ex/KqqTGwrx7nAfDAaCe2besoaLnDY9pr7Hh3D5LnrY+aHQ8JADi8u/NNtFtYu9wRBAARJ3tGsG3btqyPiyeBl45qy7RA6QEgIBiV8eyz20y7351t2+jq09736KH9kHr2FfUeC3gO+yHg568dRvXgwaJei0aGY8BIWATPqTi77y10Hsj8uCaXgK4wh4d/8wrW1dooWjkLCQU42a9tJz3H3sO2s9kfm207U4Y4AAJeO3AKy+InLFnOUjAW1o8dO97EeftVtuOkvp47egamPeYU9R5nteP1+dMnsS2a33eZy2+UGYQTACAiKiv4zTPbIFqYgds3pG0TB/ftRuysOftzXVT7Hh995zyqxs9gaeagjGn5+Skeg0EejW4VC30K3hngsWOP9cfmwyPasovJKLZt24YK8OgGj6de3on+Rnsc7zyxPtwIYPeO1zB4aGDGxxfL2vZjqA4n8FqGfXL07VEAQCAWsGyfzYWe/h40yg7wnIJnn/0NFN7cWPvejl4s1GPkX3jlTSQFew+abd++He74IG4CsOuNl6BKPBAEXt72MjxLCzvf7+/sBwAExnqR5BLYUcbvOxeGz2vJGp2nOqdsmzcrDpw9tBcnhor/DL0HtPSN7sFuhId70JNsxhGbrpthPW0kEnWg89gBHAkUt5yl+k3MRjic271bJrYzGAwGg8GYQseINjVMRGGO4/ChjW34p+eP4VfvdeYttvcHorj9/70Fl4PHtj+90rSetnw5YjjbC7gKN5H5ei/pUCiOUCwBbwmSAl443IvP/HQ3FtV5cffGVnxwwzw0V+Z35ysqJ/Hbo3341XudeOPkAHKtxvvMVYvxla0rCljq0mLLGHkitneYI7aripoS2ylytgMoidjuaaBjnRA4nkPN0hoMHB7A0MkhU8R24moXnAIk3WlKI7XLNNf/6LlRJKIJiC526QsAiqLgC1/4Ai6//HKsXr3a+PcvfvGLuOyyy3DHHXdkfF5vb+8EoR2A8b97e3szPQVf+cpXcP/99xv/e3x8HG1tbbjppptQUVG+oTdZlrF9+3bceOONcDiy3yA90DmGV3e+AwD41oc34Noceof3qEfw6K5OdDlacf/WNVP+/i/H3wQQxgeuvQSXLyksqeO58f04NtaHpStWYeul+Q8/5suf79oOQMUtN1xnqbN4LCLjnw++goDM4errb8p6brT9SD/iu/ZhXpUL933oMvzg71+GAg7X3Xhz0VH3M20b/3N+BxAI4PJLLzZqAwpl9XAYv/numzgTFLD56uuoGEo0kxcO9wF79mN5UwXueN+WrI/bkTiCX7zbCb5+MbbesqyES1gYh7vHobyzE5VuER+/88aMA64zbWf150bw+A/fxbDiwdatV035Ow2oqoov7tRujG+96Xo0+O13PuE/NYiHT+yB0+PH1q2XWfIez/1iPzDQh/Vrcz9e5/obZRaKouKv3tsOVQUuu+Z61Pms+66+dfR1IBLFtVdehotazbkev0VR0f7L/XjhSD9+ctaFX376UizJ41rujZOD2LVjDzgO+PdPXIodZ4bxzkunUNHUhq1bV5myjNkI7+kCjh3G4pY6bN26Ee+px3BsZzu8zfY53sljPcCRL+HiNcvAr9xq+fsJTz0NjEWwdevU9zoweADncA6NbY0Z/14qdhzegd7DbwAAbrn+asBdZerrP/IPj8Chu2hvft+dAGfPFugJx6pECDh8Py65aAX21PdgaGgIF6+9GAuvWVjQa//ggR8ghBDqatzwNNWW9fvOhROJE2j/93ZUOCumLKt4/uu4cEETlt5Q/Gd45c1X0IteLFm2BF5RxeIV67DwCnuum5PqSbT/azuSSTcWz6vHwgK/w1L/JmaDJLTNBLvjwGAwGAwGYwodk5ztAPDBDfPw7ReO4b3zIzgzEMTi+twcj6qq4qtPHkKv3nv2yNvn8MfXLDV/oWegfzyKwWAMPAejC7FcVLgcqPI4MBqW0TESxvIm60WHt05p7s6zgyF8+4Xj+OcXj+OKC+rxoY2tuHFlY9bEAVVVcbBrDI/t7sRT+7oxluZm90uilt83A5KVFgkTmQsx8tGxKNSkNiVBi9gu1miXLFaK7eS7t1OqQa7UXlCrie0nhrD05uKPrel97WakYJQLb4MXrioXoqNRDJ0cQuOaxpmfNAe47777cOjQIbz55pvGv/3mN7/Byy+/jL1795r6XpIkQZKm3rR3OBxlvVmSy3LEEwr++qkjUFTgjnUtuGl1S06v+aGL5+PRXZ148Wgfosk18LtSrx+MJdA+oh1r1rRWF7wOfPprRhKq5esxkVQg678ZFR7J0verczhQ6XZgLCKjJyBjhS/zQOD2Y5qz7pbVzajyusBxgKoCUQWoMGn5sm0bEVkBAPjcxa+LJY2VWNlcgSM943j15FBBqVE0c1Qf7FrbWjXtuty4oAa/eLcTB7sCtjhuzMRJ/XxiRXNFxnqNdLJtZ6vbtMG5nrEoQrKKKg99gxhROWkM5VZ6XXA47Hf7ucqrDQ8F40nLtq1oQj9muJx5v0cpfyv9kojxaAIhGWi28D3D8SQA839P/u2jG/DR7+/E3vZRfPpne/DrP748p6GBYCyBr/7mKADg97csxKVL6nFuWDMdDATjlq//0Yi2Pur9bjgcDlyg36M4Pxyxz/HOqx2PhGQEYimWKRkFnF7wGd5LiWn7k+Sz9nxkJjw1Hsiy9v4OyIDJy5KIJOBwy1B4CQ6n/QaVJuNwOOCQtO1ETEbgrtLO35Lhwo+tibDeTc7FwEu+jNuDnfDWafcQYmOxqZ/ZVQEhEYZgwmdIxrRjhtPrBBcbh+CuMuV1rcBXp90vjkYdEOTiP3+5rx9zfW/7ne0wGAwGg8EoK4GojOFQHADQVpO60dlY4cJVF9bj1eMDeHxPJ7508/KcXu+ZAz2ae0Xne6+exscvWYBKT2lPlA7rEfKL631FO5/MYH6NB6PhMbQPlUZs79OHHW5d3YShYBy7zg3j9RMDeP3EACpcIm5f14IPbWzD2tZKcByHwWAMT+7twq/e68TxvpTI2Vzpwl0bWnH3xlYsrKNPmJwOW4rtevdgoDtgSic3+YxOvxNiCRIVzIA424PdQcvew44VArlSc6EWBT50YsiU1wv26n3tFEfIA1oiS93yOnTu7MTgsUEmtgP43Oc+h2eeeQavv/46WltbjX9/+eWXcfr0aVRVVU14/F133YUrr7wSr776KpqamrBr164Jf+/r037bM8XO085/vXoax3oDqPE68bfvz93Ztq4tVbvz3MFefHhTqov7eO84VBVorJBQW4Rz0Kcfu8P6DTcrCcup9yjFudOCWg8OdI7h/FAYK5qnnhvFElrCDqCdz3AcB59TRCCWQCiWBCyepYzoQpHHpHWxdU0TjvSMY9vB3jknth/o1OosVs+b3t26fn6V9viuUchJBY4iz4Osxqisai7ctVvhcqCtxo2O4QiO9IzjsiX09baTvnYAcJexQmw6/PqxNH1ZzSZsHDPsfc5d6XFgPJqYMFRtBSGTj6EEl0PA93/vYnzwP99G+3AYf/Dj9/C/n9484+/Wt58/hq7RCFqr3fjSzZqTvKFCG8LoH4+ZuoyZGNJ7qet82kDNYl2cOqOnrdkCQYICAVzMuuuwCcTDgDPztXhcv0flLHMSjFQhQZb1fVqOmP76cliGszIBVbBh/0Y2BBFweIBYAFKFdjJGaskKgXzXgqoNX9gdV5V23IiORqf+0ekDTNp/ZP0Y7XQDSEQBV3nrMafDVa2vk4gDiFlnmrAb9j5LZTAYDAaDUXI69GnuGq9zgiMLAD60Ubtp/PjuLiRzyBAfCsbwt785DAD4k+uWYnmTH+PRBL73+mmTl3pmUhHy9jghJRH97SXqbe/TbxjcuX4e/u+PtuDVP78Gn79uKVoqXRiPJvCzne2446G3cPO/vo5PPfIuNv/DS/j7Z4/ieF8ATpHH7Re14KefugRvfvk6/PnNy2ad0A7YM0be1+QDJ3BQEoohCBeDHT/jTJQyRp5Gsb32Qi2KevjksCmvR2LkfY10i+0A620nqKqKz33uc/j1r3+Nl19+GYsWLZrw97/8y7/EgQMHsG/fPuM/APjud7+Lhx9+GACwZcsWHDx4EP39/cbztm/fjoqKCqxcubJkn6UUJJIKXjqmCbpfu31VXvHeHMfhrg3aIMNjezon/I2ch6zMICLnAxEpghYKRAQi6As8B2cJRM75xrlR5t+7t08NIRBNoMEvYcN8zUXl0ysiglHr10dEHz4wSzy8dU0zAODNU4MYCFgv7NgFVVVxqEsT29fMILYvrvPB79L6pI/32v9m7VFdbF/RXNzkBzlOkOMGbRCR2e0QIPD2TMkxjh2xBFTVmn7sKDlmOO19+71Cv+Yfj1ontieSCuK6099rwfBBnU/Cw/dsQqXbgX0do/jCL/dOe7/i3XPD+PGO8wCABz+4xqguafTrYnsgg2hmMoO62F5LxHb9+qx9OAw5qVj+/jnBcUgILiBeIrFdDmuibQbiQU2AdXjL6+TVxHZ9GWTz7+XIYRkOhwyI9jEA5ITk18R2vYYsVsTAihzSjkW8EqZfbJcqTBObExHtXNfl0o/VUnkTO6eDrJNIUIQao/NcphDs/WvPYDAYDAaj5BDxt61m6sn9DSsbUOl2oHc8ijdPzSxePPCbwxgOxbG8yY/PXXcB/vwmbWL84bfOon/c+gvYdMy6yW0WbdXa+u0okdhO1nejPq2/sM6LP7tpGd748nX42acuxR3rWiCJPE70BfHSsX4kFBXr2qrw93euxrt/fQP+/aPrceUF9ba9YWYGdnS28wIPv37D1ozedtr62gHAUc3E9umovUAT281ytqfHyNNO7XJ93RwzZ93Qyn333Yef/exnePTRR+H3+9Hb24ve3l5EItpwXVNTE1avXj3hPwCYP3++IczfdNNNWLlyJX73d38X+/fvxwsvvIC/+Zu/wX333ZcxKp5mRIHHY390Gf7tI+vw/rXNeT//gxvmgeOAXWeH0T6U+o0/0qMdwzI5tvOBCALheAnEdv09PA6hJLUSC2q136bzQ5nPjZ471AMAuGV1E3j9fISsj5IMHxAB0SRX5pJ6Hy5qq0JSUfHUvi5TXpMGukYjGAnLEHkOy5qmv1HM8xzWtVUBAPZ2jFq/cEWgqmrqeqPI4V5ynDjaY/8Bg0yE9GOHV7Knqx1IpYTISRWxhDXCZmrowObOdrcutlvobE9PSvFYtF0sqffhf353I5wCjxcO9+HBbUczPi4qJ/Hlxw4AAD58cSuuvKDe+FtDhXZOMxSKWy54D+nu3Vqv9p5NFS64HQISilqygfxcSAju0jlTpxHbiQBrD7HdWme7wyFDzbIebIvkB2LjkPR9KDpW2P0+VVUNZzuXDGvOcJtDhOVENIHE5OFPyWfasIoc1vYByRXXX9se9zYzQdZJLOqAGqXzXKYQmNjOYDAYDAZjAkT8baueGlsliQLuWKf1lv7qvY5pX+e5gz149kAPBJ7Ddz50EZwij+tXNGDjgmpEZQX//vJJ8xd+GoxYR5s42+eX0NmuKCr6dcdUY8VEUUTgOVxxQR3+7SPrseuvb8CDH1yDP7vxQmz/4lV48r7L8YnNC4wbMLMdw/VtM8HVzN52Ow4UzES6s90q5xHVYrvubB87P4aECWLTbImRB5iznfBf//VfGBsbwzXXXIPm5mbjv1/+8pc5v4YgCHjmmWcgCAK2bNmCT3ziE/i93/s9/N3f/Z2FS14+nCKPO9bNK0hgbq5043I99vnxNHe7WechXl3oDZUiRt5kcXkmFtSkXH2TSSQVbD+iJQ7csjpVXeArkdieVFTDlWlmJPTdG+YBAB7fM3fEduJqX9bkhyuHlID1uti+r33UwqUqnq7RCMajCYg8h6UNxf2GkuHg/Z2jONQ1Nu1/x3rHc0ocKyUkmt1r48qidHe1VcePSImPoYVCrvWsjJEnSSmixUkply6uxbc/tBYA8IM3z+InO85Necy/v3QSZwZDqPdL+OutE9N5ajxOiDwHVU05z61iUHdqE2c7z3NYpKfHne4vkZM8BxJ8CZ3t8exOZjvFyMfj+v2RuPmR/3JYhtMpg3NSFCMPmOZsV2QFalL7TeMSkay1AnZC8kuAfskwZcjA6QNMcnYTZ7vkjJI3NuV1rcDhcYAXecRiTiAyd5zt9j3rYTAYDAaDURbIDc75GZztgBYl/5Md5/HikT6MheWM3evDoTi++tQhAMBnr15i9DFyHIe/uHkZfud/duIXuzrw6SsXY0Gt9eJWMJbAuSHtQsguzvZSiu3D4TgSigqOA+qn6YmtdDvw0UvmVmdoOobgarOIdVPFdhqd7brYLodlxMZjcFW6TH19OSIjHtBu3tjtu88Fb6MXTr8T8UAcI2dGUL+ifuYnTcNscrbXLdPF9uODUFW1JM5cO1LIkEqm5yxYsADbtm0zY5FmPXdvbMWbpwbxxN5O/On1F0CF1tkOmOdsL4WTm8Smm92vm4350zjb3zk7jJGwjBqvE5csrDH+3VeC3mUgtS4Aczuo339RC77xzFEc7RnHke5x2wyFWsnBHCPkCev03va9HSNWLZIpHNNd6EsbfJDE4rYRcpw41R/E+/7fmzM+/mOXzsc/fGBNUe9pJmQYyM5d5TzPwesUEIonEYwmUDfNNVKhlPoYWihGjLyFYjtJO/A4rU9KuWPdPHSORPDtF47ja785jHlVbly/ohGANuzz36+fAQD8/Z2rp9zL4HkO9X4JPWNR9I3H0FxpneCZ6mxPbXtLGnw40jOOM4P26W2XBTe4ksbIZ17n9nK2kxh5c53tSTkJRVa0GHmpytTXthynT+9s18X2AjvbyVAFoAJyiIoYeY7nIFVIiI3FEB2NTqxjk/zmdbbrznanQ19HrtzOo8oBx3FwVbs0sb1Uxw8bwJztDAaDwWAwJtAxMr3YvnpeBZY3+RFPKPjNge6Mj/n604cxGIzjwkYfPn/90gl/u3RxLa5ZVo+EouJftp8wd+GzcKxnHKqqRbPVWnAjpRDI+u0ciUCx2I3Sp0fI1/kkiCXoXKWReChuTArbzfVd0Wae2E7c+3b7jNPBSzxc1ZrAHugyP4KMuP15B29M4tMEx3GmRsnPps726iXV4EUecki2ZNthMLJx86om+CQRHcMRvHtuGGcHQ4jKCtwOAQuLHDL0lTRGnrgySyOYkRj5rtHIlPjebQe1CPmbVjZOOJch6yNgtdgeT4ntLod551JVHieuX9EAYGISwmzmQKcmtq/OVWxvqwYAnBkIYSxsnRhYLEMhTVhoqSpenGutduOD6+ehsUKa9r96v3be8sSeTgQs7NvOF3J88tpcZE7vbbeCSFp3vZ0hgnMpnO2lSjv442uW4HcuboOiAp97dC8Odo5BTir4i8cOIKmouG1NM25e1ZTxuQ167ZqVtXeKomJYFxXTxfbFurP9zIB9xKkE77JVjHzZne2VqRh5JWbuUAS5H+FwyOAkyq7F9G5yQ2wv0NlufM9uBZyqUBEjD6TFpk8eMjAzRj5CxHZ9yMPGznZAWyfxuBOcbJ/jmdWwu60MBoPBYDAmMJOzneM43L2xFQDwWIYo+RcP9+Kpfd3gOeDbd1+U0dlButuf2tdtdBtaCYluXWUjt1BzlQsCzyGWUDBgcURd/3jmCHlGCiK4CpIAp6+8F/CTMdPZHhnULsxocrYDgK9Zu8i2orc9vT6AVucziZIfPjlc9GvNphh5wSGgeokm0sz1KHlGaXE7BWxdo93Ef3xPJ47q5yHLmvwQ+OKOMx7D2W59jHykxIJZo98Fp8gjqajoHk25xZKKihcOaxHyt65pnvAcQyyb3JFpMumimdm/FeS8+sm9XZZ3BJcbVVWNGPlcne01XqcxiLGvc9SqRSuaoIliIsdx+JffWYd3/uqGaf/b9VfXY0m9F1FZwXMHe4t+X7MwnO02jpEH0oZ1LDh+KIpqONvtHiNfoR9HrRTb053tpYDjOPz9B1bjygvqEJGTuPfH7+Kbzx7FkZ5xVHkc+Nrtq7I+t1EfYukLWHeNPhaRkdAH7mvSxOPF9URst4+zPSHYLEa+zNfqkl9CIqHtM4mAufeyjM/oTICT6LpeJw5ukkJXrLPdW6X/AwXOdiAltkdHJw3p6EMIZmAMYwgkRt4+9zcz4arSnO2cEgcS8ZmfMAtgYjuDwWAwGAwDRVHROazd3GzLIrYDwJ3r50HkOezvHMOJvtSJ42g4jr9+UouP/8OrluAivWNxMqvnVeJ9a7Wbpd958bhJS5+dw1326msHAIfAo0U/Ibc6Sp442xv95sZvzyYMwbXefoKrIbZ3mOdspy0u3d+iTW1bIrZT3NdOqLlAi1Q2w9k+m2LkAeB9//0+fPq9T6Pt8rZyLwpjjnHXBk1A3XawF7vPa/HXZpyH+CRNqCits7004gjPc8awZ3qU/O7zIxgMxlDhErFlce2E55Q6Rt4KoeiqC+tR53NiKBTHa8cHTH99O9E1GsFIWIZD4LC8OXdHFg297WQbJPtoKeA4DneRIWgbJSPQ42zXHN1WONujidRAlN1j5Eln+3jEuuOosU2UcADDIfB46OMbsLzJj4FADI+8fQ4A8MD7VhqpEJlo0AfUByx0tpMkjAqXCKeYkmeW1GvDrnaKkU/w7tKI7UoSSMZsHyMvOAUIkhOJhIBEwNxrUyMm3JUER4nIbEA6201ytnsq9PTHLEkHdiOr2O70AYkokCx+mIlsHw4+AvAOQLS3mYaI7QDmTJQ8E9sZDAaDwWAY9AWiiCcViDyH5ml6ket8Eq5drkVePrY7dWPn7545goFADEvqvfjCDRdM+15/dtMyCDyHl4/1491zxbsxp4M42+3S104wetszdJOaSa9+o4BE4jGmQpztdoxXt6Sz3YafczosdbbPArGdONuLFdvliGzcGJkNMfIAsPDqhWjZ2AKHu7w35hhzj00La9BW40YwlsAv3m0HYM55COlAtlpcBlJieymFogVEbE8bRHzukBYhf8PKxgmiBJAS263usCdCkcuCOGiHwOOOdfMAzP4oeeJqv7DRn1ev+TpdbLdzbzvZJ70l7in/wPp54Dhg19lhy68pciUUt39nOwD4LRzWmVA9kce2Xg4q3NbHyJO0g1JH6le4HPjRJzehQRfXr1lWjw+snzftc8iAel+BYmEuDAanRsgDwCI9Rn44FMdo2B5O0ITgAleKGHlZP35lEVcN13eZY+QBrbc9HncgGbRIbHfK1IjMBpIfiI0btWzRscKGVcj37CGnzJTFyE91tuuDhSbsQyRGXuQi2uvazCQyGXe1OyW2x6xPNLUDTGxnMBgMBoNhQG7QzKt2z9jt/SHdRfHEHi3y8uVjfXhiTxc4DvjW3RfNeDNyUZ0XH75Ycxp+6/ljUFVresvlpILjuvt+VUtucZWloq1aF9std7azGPmZsLPj2+hs7xqHqhS3nxhDBZTFyPubmbN9OsyKkSeudkESqOyvZzDsBM9z+OB67VwpKmvR4CtMENtTTu5SxMiXXjCbX0sGEbXjkaKoeP6QFo996+rmKY/3lkhsj1g8eECSEF462m8bgcUKSF97rhHyhPXztUqQfR2jll0zFAvZBkvp3AWA5ko3rlhaB8A+wxphY13YW2Q2YuQtOH6QYSWXgwdfZH2I1RCxfTxqYWd7GZzthJYqN375mS340s3L8N0Pr5sxxYw42/sCFjrbdbG9dlIkulcS0aQPyJ+2SZR8gi9RjHxcvyeSxdFtF2c7oIntsixCCZu7XlJiewJw0nW9braz3e3Xz3MpcfhnF9v1YQET9iGyfQhqGHDZy0iUCalKShPbmbOdwWAwGAzGHGOmvvZ0rl3egFqvE4PBGJ450I2vPHEQAPAHVyzCxgXVOb3fn15/ASSRx7vnRvCqRbGZpweCiCcU+CURrdWZI8nKBYnq77BYbO8nMfLM2Z4VOwuuviYfOJ6DIivGUEChEGe7HYcKpsPXYr2znTa3fzokRj7QHUA8WLhIE+zT+9obfbarU2AwaIQIqIBmPlnelHtsdjaI2BuRk0gWOYA1E6WOkQeAhbXa7xOJkd/fOYqesSi8TgFXXlA35fEl62y3MEYe0CoGVjRXIJ5U8PT+bkveww4c1J3tq/MU21c0V8Ap8hgNyzhnE/f2ZFIx8qUXE8mx5om9nVAsPi7kAi3OdiuPH1G5PE7uQqgsgbO9HEkp6Syq8+K+a5eiOgdXNEmD67fQ2U5i5Cc72wFgiX49enrAHuJUQihRjLysX+dmiZG3m7Ndlh1QIuYORBgx4Q5ane0BuIjYXmRnu9urDarSIrYbjv4pMfLmOdtJZ7ughlKOeRvjqnIhHidiewnSMWwAE9sZDAaDwWAYdIxofe2t1TOf2DsEHnfqEWx/8dgB9I3HsKjOiz+7aVnO79dU6cInL1sIAPjWC8ctuTl0pFuLK1rRXGE7V4ERI2+1sz1AxHbmVM2GnWPkBYcAX5MmNhfT256IJgwhljZnu5Ux8uF+fQDBhoMWueKudhvf6fCpwt3twV5dbG+iI66PwbA782s9uGSRNgyzsNZriqMv/TWs7m0Py9rre0ooFhnOdv3ciLjar1vRmDE1yV+yGHniUrVuXdy1QTuvfmxPl2XvYTY/2XEOf/PkQUNYnA5VVY0Y+Xyd7U6Rx+oWzcW1z6ZR8kE9baIczt2bVzXBJ4noGI5YXs+VC9R0thvHD/NF5jAlAwdAacX2UtcsFAKJke+30Nk+mMXZDgCL6/Tedrs42wW3JpRZnSoia/ei4Mh8TUauY23hbK/Une1RJrYbSH5AkSHpX19sPFZQEg1xtrs8s8XZTsT24gZWlKSCpH4cFZQQINkrtTMTrLOdwWAwGAzGnKYjD2c7AHzoYs1FISdVPT5+bd43IT97zRL4XSKO9ozj6QPmO3mI2L6yxX4xS2Q9d4yUJka+wc+c7dmws9gOmNPbTlztvMhTFxHub7EwRn7AvqkG+UDc7cX0tpMYeW8j3euCwbATn9i8AACwZUmtKa8niTwEfXjQ6ij5cKx8ne3tw2GoqornjAj5poyPL1mMvMXOdgC4Y908CDyH/R2jONVPhwPo288fx892tuOLv9w349Bs12gEI2EZDoHD8ub8HVnr2vQo+fbRQhbVcohgW47odLdTwNY12j5ihyh5MnjgKcPgQT4YYrsFznZyzHA57H/rvcKliZfBWMKyZASS/OCxebUAkIqRHwrFIScVS95jMKhdn9d6p16TLdYTyM7YxdnOu8CpSkoMtwojRj7z9TgRYe3kbFdj1ojtohCnRmQ20EVlya19BlVRje8sH4iznVaxfYqj34iRL+68jrjaAYBPBqlxtrPOdgaDwWAwGHOWfGLkAWB5UwXWtmoTlZ+8bCE2LazJ+z2rPE585qrFAIB/2X7C9AvawxSI7X3jsZwcQYWQSCrGxTyLkc+OnTvbAXPEdvIZPXUe6iLC053tZne12rlCIB9Ib3sxYjuJkWdiO4NhHrdf1IJnPn8F/ua2Faa8Hsdxhlu0VG5udwmdiK3VHvCc9t6vnRhA+3AYLgePa5bVZ3y8r8Sd7VZG6tf7JVxzofY5H9ttf3e7oqgI6g7m5w714h+fPzbt44mr/cJGPyQx//W4fn4VAGBvx2jezy0FZPilHDHyQCpKftvBXmN7LRdhI1Lf3sIqiZG3orM9QqGzXVWBgEWVHDQ522s8Tog8B1VNieJmMxQkMfIZnO31urN90B7OdlnQY92tdqZOEyOfjCehJLT7RLZwtutiO2RzTRNyWAbHKRD4ZNY4fduii78OPgpO0O41FNLbTgR6yZ0AOB4Q6biHNbOzvTixXU5LHuHkIBWd7e5qd1qMvD2Gh6yGie0MBoPBYDAM8hXbAeC7v7MOX799Ff7y1uUFv+89ly9Cnc+J80Nh/PLdjoJfZzKqquJIjyZOrrKh2F7lcRjxp50WudsHg3GoKiDwHGptMAVuV2zvbG8zz9lu1884HSTWXJEVRIbMdVXMNrF9+CSLkWcw7MbqeZWmCi5EzLM6Rj5CYuRL6Gx3ijyaK7UbzN977TQA4OoL67OuP7IuQiVytrsd1gpFd2/UBNNf7+1E0gbd29MRTSQnpAr/z+tn8NMd57I+/kBnYRHyhHVtVQC01CqrhlSLgWyD5YiRB4BNC2swv8aDYCyBFw73lmUZCKE4OXbYW1i10tluDCtR0NnuFHljOa2KkqfJ2c7zHOr9muO8z6Le9iEjRj6Ds71OuyY5PxRCwiJnfS6oqop4MI5YTBe3re5cniZGnridATs520VLxHanU98HaYyRB8DFA5D0dIjoWP5VDMTdL0ky4PQBlJgEsortTv26ukix2ehrlwRwsQA1znaAQzzhZJ3tDAaDwWAw5haReBIDAe1iMh+xfUm9D79/2cKCHCoEryTi89ddAAD495dOmubG6BqNYCyixVVe0GC/k1GO49BmcW9737h2st/gl2zXWZ+OmizvDeW54Gw3Bgoo62sHAMEpGEMCZkbJq6o6a8R2M2PkfY1MbGcw7IynxD3lVrq5M7FA723feUYbHtq6pjnrY4kz1QqxLJ3UurD2Ntp1KxpQ6XagbzyGt04NWvpexZJeY3D/jRcCAP72N4fx8rG+jI8/qDvbVxcotrdWu1Hnk5BQVBzuHivoNawkaLi5yyMw8zyHD26YB6D8UfKGi9nmwqrfZd2x1BjQsXlvPaHCra2L8ag1YjtNznYAaNAT4frHreltH9LF47oMYvu8KjckkYecVNE5YnF0+zTs/p/d+E7Nd9D5f6PaP1gtlsV1Z3uGGHniduZFHoIN9ikitnMJc7cPOSxrfe0ANfHpBpJubomlxPZCnO1ksMIp0dVbn1Vs5wXtcxTrbNeHEBwehxbJLtnPTDQZsk7icYl1tjMYDAaDwZhbkN7wCpeISk/po7k+esl8tFa70R+I4SfTuGLygfS1L23wwyna87SnrUZzb7UPWSy22zRCXkkqeOSKR3DgIwcMV205sLvgaojtHcU72+06UDATVvS2xwNxJHWxgNb1QjAjRp51tjMYdECcs2GrO9uNGOTyiO0A4BR4XLe8IetjDWdqPGF6zUg6kRI5dSVRwO0XtQAov2A6E+F4Kvng89ctxYcvboWiAp97dK8RGU9QVdX4N1JBlS8cxxnu9r027G0PlVlsB1JR8m+eGkTPWPlEOsPFbHNh1cpkjEi89MkgxUCi5C1ztlO2PhqJsz1gjbPd6GzPECPP8xwW6e7202XsbXdVavcPIgF9P7Y8Rl6/H5JBYCUCrB0i5IFUjDynWCi2UyQ0A5gQl062nWJi5J1OmaqBg6xiO6CtmyL3HxIj73ATsd1+ZqLJGD32UeZsZzAYDAaDMccgYu/82vKc1DtFHn909RIAwPYjmR0x+WLnCHnCfMPZbs0NMXKDgNwwsBu8wCM2FoMqq+jbb873ni9yRDYu6uwasW5mZ7u7jrL+Nx0rxHYyZOHwOrQpcYqpWao52yPDEYQLHN5hMfIMBh2QzvaQ1THyZXIizq9J3Vy94oI6+F3Zj89ELFPV1HCAFaRi5K0Xiu7So+RfONyLgEUuUzNIH8bgOA7f/MAaXLG0DuF4Evc+8i66RlPntl2jEYyEtbSpZU2F3yC2a2+7oqgIGW7u8gnMbTUeXLKoBqoKPLGnq2zLQYuLmRw/LOlsL+ExwwwqXNaK7WQ4zO4DGIQG3Zk7YIGzPSonEdDTWOq8ma/Rl5De9oHy9bYbQtl4CWPkBUlzAk/+ExFgMwwnlAOpUnO282aL7SEZTqd+PKJNbDfi0tOc7WOFi+0OMU6X2F45jdju9JnmbBfdgvZaFHS2u6r1dRIRoUYLv49FE0xsZzAYDAaDASDlbG+rLt9J/ebFmlh0uHvclH6yw7qzfWWzfU9E51scI0+i7xpt6mwHgMaLGgGgbGI7iVfnHbxxYWg30sX2Qp17zNk+FbsnGuSD0+uEf562jgrtbQ/26WI7i5FnMGyN13BjWu1s1274litGHgBuWd007WNdDh6CXpNjZax+KSP1L2qtxJJ6L6Kygm0Heyx/v0IJT3L7OwQe//mJDVjW6Ed/IIZ7H37XiKQmrvYLG/1FVU+t153t+2zmbA+ndciX09kOAHfr7vbH93RamvYwHbT0c1tZQ1GuGo5CIc72caud7TbfJgiNfu3a2YrO9mHdpS3ynBHfP5nF+vXamcHyOdulSu26ODymL2ORndMzEg9ljJDX/qRHi9ugrx1IOdsFmLt9TIyRp0xsd7gBTgBi48a2U0yMvCa203NNSoZT5LCMpDzp/FzyFy22k852tx+AkqAjRp4kHMQkKCH71f9YARPbGQwGg8FgAEiJvfn0tZvNojofvE4BETmJ0yZMcZMY+ZU2draTzvbOEWtj5BttKiID5Rfb0/vaOc6evfb+Fj/AAcl40hDN84XmznbAIrF9YPaI7UBalPzJ/KPk5bCMeEC7ucFi5BkMe2M42y3ubI+UKUZ+Ya12DBJ5DjetbJz2sRzHGevDSrE9KpduXXAcZ7jbH99dPnfyTIRiU9dJhcuBH92zCfV+Ccf7Avjjn+2BnFRwoFO7ybqmwL52wtq2KnCc5pTvs6hLuRDIvshz2gBIObl1TRNcDh5nBkLYV4YEAFVVqXO2W9rZTomz3eoY+XIlpRQKcbb3Bcw/zgwFtfPtWp8z67UnEdvNuCdSKClnOweV44G41c72MODIfA1iuJ1tFiMvcBaK7bQ52zlOF5WDhoEhOpb//kO+a5GPUeVsTzdtTHH0mxgj7/ElyRsW9XqlQHSJEF0iYjEHE9sZDAaDwWDMLTp0sb2tjGK7wHNYrd+EO9A5WtRrjYbjRnylncX2dGe7Fe4TMo1v1852AGhcp4vt+8rrbLdrhDwACE7BcBsX2ttORHo7f87pYM72mam5QEsHKaS3nbjaRZdo24QHBoOh4bVQIEonXEKBOZ0VzX7cd+0S/P2dq1HlmdnFRmLmrXCnEoh46CqRcPaB9fPAccCuc8M4P1Q+sWU6wlmGMeZVufHwJzfB4xTw5qlB/PWvD+Kg7mxfXaTY7pNEox5qx+n8f+usguyLXkks++Cm3+XALau0RIjH93SW/P3jSQUJRbumsbuLmYjt4XgSScXc67ByDSsVSgXrbJ8AuXbut8DZPhjSXrPOl/18e3GdDWLkdVdqMqyYEoM9I3JEc0dnwJ7OdhECHzf1deWwrHWVA/SJ7YAmAMcCpjjbRT5KlbufF3k4/dr2OSVK3sQYebdP3z4o6GwHtKGdWEyCGmWd7QwGg8FgMOYQdnC2A8DaVu0mHLkpVyjEybGw1mN00NmRedVucJx2k2coZO7FGpDubLev2N6wtgEAMHxqGPGg+etgJtKd7Xam2N525myfymwT24mzffhE/jHyoT59XTTaN+GBwWBopAQii8V2Iwa5tE5EjuPwpZuX4yOXzM/p8V7Jeqd/qYWz5ko3rlhaBwB4vIzd29NBtr9MHeWr51Xi/310PXgO+L/3OvHmqUEAqfP8Yrh8ibZe3tJf0w6Qba/cEfIEkozw9P4exBLW1k1MJpxWb+GxuaubxMgD5g8vGQM6lIjLRGwn1Q9mQ7aLTMcLO0Ji5PstdbZPI7br16WDwZhlAxAzQZztUADV4StrjLxdne2iaO53Q3WMPGDEpZvR2S5wMapi5IHUPjNFbNcd/8VgxMj79N8qCjrbAa23PR53AExsZzAYDAaDMVdQVdU2Yvua1ioAMOImC2Wv3uW4YX51kUtkLZIooFkXwq3obe8PaBc4do6R9zX6IFaLgAr0HSi9u50WwbVYsZ2WoYJsMLF9ZoqJkWd97QwGPZCO7KCFne2JpIJ4QtHez+6CmS7eBKwU28sQCX23Lpg+sacTismuWzMIzTCAcP2KRnz99lUAAFUFHAKHZU3FO7Eu04cQ3j49VLZO8smkO9vtwGVL6tBU4cJYRMZLR/tL+t5kXbgcPETB3redJVGAU19Gs8V2csyw+/GTkIqRN/84qqqq4Wz3UjJ8QGLkh0JxyEnF1NceDOrO9mlc2n6XAw1+bRnODJSnt110i+BFbf9QBG/RMdgzMk2MPBnIt5+zXQGS5gnuE5ztYmaXv63RxXajq7sIZ7ugRqmKkQemE9t9RdcwkBh5t5tOZzvk8hzHSo29z3oYDAaDwWCUhIFgDFFZAc8BLVXlPalfq8dLHukZL+rCdk/7CABg/QJ7i+0A0KoPOHSYLLbHEkkM6xcrZDrfrngWa+ugd19vyd+bhhh5AKhoK1xsVxUVkSGtVoF2Z3uwNwjFpJte4X7tu581YvsFuth+In8BItiri+1NTGxnMOwOcXJb6WwnEfIA4La5OOIrYYx8KdfFTSub4JNEdI5EsOtc/oklVhMxYqGzC8y/u2UhPn3lIgBaX7skFr/+Ni2shkPg0DUasWRQtRBCNnPtCjyHD26YBwB4fHdpo+Rp6WsnEHe72ckYqTQMOtZDhb4erHBRxxIKyLyQxyb7yEzUeJwQeQ6qmhLHzWJIf71a3/TCMXG3lytKnuM4SFWa4K/wbiBW2MB3zsjhGWPk7eJsd1Xqbl0AStQ8EVFztiegcC6Ap1C2k3xAbNwUZzuvRmaR2O43L0beQ8R2SpztVS7EYk7wCXtWIpkNhXstg8FgMBgMs+kY1kS45ko3nGJ5Tw8W1Hrgd4mIJxSc6CvshFRRVCNGfn1blXkLZxFGb/uQuTcMB3RXu1PkUeWxx4VpNtyLtAvrcojtxPFte7G9CGd7ZCQClfRnUiq2exu94HgOalI1BiSKhTjb7f7d50r14mpwPAc5JBviea6kx8gzGAx7QwS9UsSm8xwglfnccCZ8JEbewuGDcghnbqeA29Y0Ayi9YJoLRGCeKVr/K7euwH99fAO++zvrTHlfj1PE+jZtmPZtm/S2p2Lk7TOYQqLkXz0xYFwTlAKjm9tG62I6jGQMk4d1IpTFyBNn+7gFYnv6b1Up00GKgec51OvO8j6Te9tziZEHgMX1em/7YPkcocShnICnBDHyYWpi5J1+J2RZO3bER4pLZEyHxMirgr2NElmZHCNfhLOdT2ZPOrArZH+Z2tluXoy8JOnrlCJnezzuBK8wsZ3BYDAYDMYcgTiq22rKH1XFcVyqt73AKPnTA0EEogm4HQKWmxBXaTWG2G6yO4fcGGiskGzfwWyI7XvL52y3e7y6IbZ35C+2hwe1zyhVSBAouek3GV7gDde1WVHyRrT+LHG2C04BVYuqAGju9nwg4jwT2xkM+5MS262LkQ+nict2P4ewSixLpxwx8kBKMN12sMfSJINCmK6zPR2e53DrmmYsqDXv92XLEi3JxS697UaMvI1czEvqfVjXVoWkouKpfV0le1+jm9tG62I6yPHD9M52SmPkrRDbjWQQhwCBt/fvSToNetVb/7i5ve2DuphYO0Mk+uK68jrbAUCq1ETThOIqb4x8yF4x8qIkQuG0dSOPmiu2O50yVJHSQXDJD8SDxnYTHct/3yEObi5JsbN98ueWfKY5251SDHB4AMEegycz4arWne1IAInSDf6VCzrOfBgMBoPBYFiKXfraCWvmVeGtU0M40DWGjxTwfNLXvra10vZdgUBqvXeMmCu2kxsDdo+QBwD3Yk1s7zvYByWhGP1wpYCaGPkinO20fMaZ8Lf4EegOYLxrHM0bmot+vdnW2Q5oUfIjp0cwdGIIC69emPPziLOdxcgzGPaHdN5a6eQmQqrdI+SB0jr9Z3Jxm82mhdWYX+NB+3AYm//hJThmOK9d2uDDTz91aUmSqsJlWicAcPnSOvzbSyexQ+9tL/dASMrZbq/brHdtbMW+jlE8trsTf3Dl4pK8p+Fsp+DYAaRi5M2uoYiWoXqiGCqI2B61wNlO2TZBaCTOdpOTIUiMfJ1/emf7EuJst4HYLiclIDZq7ZtNEyNvN2c7AMOFHx8dNe0lSYy8SmNfO6BFmxfhbFcVVXdwq+ASYerEdlK7kDFGPhEBkglAKOw8gXS2S84YNa52QBtACMT0IZlYABCnP+7Rjv3vPjMYDAaDwbAcu4ntxNl+oHO0oOeTvvYNFPS1A0Cb0dkeMfV1e4nYXmF/sd3Z6ITT70QylsTg8dK6lAx3My3O9s7xvPu4ibOd1gh5AultN8PZriqpOPrZJLbXXFgDoABne5/e2d7IxHYGw+6UUlz2UiCO+C1yphIURTWc7a4Su1Q5jsPvbVkAABiPJjAUik/73ztnh3Gs1+JeXZ1yiu3r2qrgdggYCsVxvMDaKTMh+6JdOtsJ71/bDKfA41hvAIe7zXNfTkeuiQd2IeVsN1dkDsv0DCwBKWf7WETO+zpjJozKCUqqBQgNumA4YLaznYjt3pli5LXrk7NDISQVc7+TXCGx2PGEq0Qx8pmvyYjY7pyh576UcJK2rPKYeb+5JEYeDkqv2fUYebLd5NvZTtzbDod+PKZMbM/a2e7Ur6+LSIcgMfJOMUZNXzuQ6mwHULS7nwboOPNhMBgMBoNhKe1GjLw9TurXzNPE9uO9AUTlZN43NomznYa+diA15NA9FkE8oZjmRiIx8uRGgZ3heA4NaxvQ+VYnevf2omFVQ8nemxbXt3+eJjQnoglEhiPw1Oa+vLQMFMyEr8W8GPnIMP099pmoX1kPAOjb15fX80iMPHO2Mxj2h8QzlyJG3k1BFLRVzlRCLKEY/385hOVPXbEIN61sQjQx/ff9mZ/uxtnBkKVx+ukQgbmUPfYEp8hj06IavH5iAG+fGsLypvLeeA6S6HSbCcxVHiduWNmAbQd78fjuLqxqqbT8PQ1hlRKR2erOdlo6yonYLie14SIz9+vU8Ja99o+ZIOlwZna2q6qa1tk+vXDcWu2BU+ARTyjoGolgfh7XfmZBnO3xmBOIWyyUyeGsIrPdYuQBgHdr10yJgHnrRQ5pYjsnVZn2miWlyM5243uW6BbbY6OTPjdxoscCgLuqoNc2BhHECHXO9nh87ojtzNnOYDAYDAbD6Gy3i7O9tdqNao8DclLF8d78TsgCURkn+rXnrJ9Ph7O9zueE2yFAVYGuUfPc7f0UOdsBoPGiRgBA777S9bYnYgnjItDu7mZREo1lzLe3nTnbp0Ii5N01bgiU3AjNhdbNWr9v5zudUJLKDI9OQWLkWWc7g2F/vLo70Epnezldy/nitdjZnt6VXmpnO6C52+fXenBho3/a/0j/rxWdy5kgbn9vmdyql+u97W+fLn9veypG3n77y10btPOCp/Z1Qc7jvKBQDGc7JcKqMaxj8vGjXNUTheJxpvrUxyPmrgtaY+TJwHpfwDxn+3gkgYQ+7Fszg3As8BwW6tdupwctdpVnwRAPow7rhTLKYuQFjya2J4PmONtVRUUimoDTKQMSpddjTp/W2e7XjqvxYDyv61HyPXsq9CQHSsX2jDHygCnOdocQBVz0ONvd1e6Us72Iz08LTGxnMBgMBmOOE0skjbhxu4jtHMdhTWsVAOBAV36Rh/s7xqCqQFuNG/Uz9KDZBY7jjHVPUgbMgNwYaKTA2Q6UR2wnrnZe5I2LIztTaG87Le79mSBie7C7+As1IrbTvk4m07CqAQ6vA/FAHINHcxMg4qE44rrLhsXIMxj2hzgxQ/GE6XG/hIhMjzjis1hsJ6KyJPKGGGVH/C5rHLrZIAKz21EeUfWyJXUAgHfODCNRAhF5OoI2jZEHgKsurEedz4mhUBxvn86vYqYQaIsMN2ooTNxvVFVFWKars53juAlR8mZCW7UAoUEfWO830dk+GNJeyy+JOQ1vLa4rb287cShHI46yxsjb0dkueLXr0mTInPVCOrkdjgR4idLrU11Ullyp42k8EM/56eR79lbOMrGdxMgXMbBibB8cfc72uRQjz8R2BoPBYDDmOF0jEaiq1sk503R1KVmrR8kfzLO3fa/e176+jQ5XO6GtRpviNlVs128MkAg8u9O0rgkA0Lu31zLxYDIkXt1T5wHH2fcGOqFgsZ0526dAxHa7JxrkCy/ymHfJPABA587OnJ5DXO2iW4TTb5/fAQaDkRmPLlgoKhCVrREZwxRFIPss7rCnxaFaoQtl49HSONvJNlIuZ/vKlgpUuh0IxBI4mOdwrtnYWWx3CDzW6dVa3SYmaGWDOmd72vCSWcQSCsilDA3HUEKFPrBjtthOW7UAgVxD95vobCcR8nU5mgJIb/uZgfI4QqUqbTkjIQFQZCBh3uDBBJQkkIxljZG3o7Nd9GkCqhIxSWxP6yvn3JQOP+td4iIiEPRzg+hY7vsP+Z7dfv3c1knXeiBd9Vmd7cWI7fr2IXJh1tluY5jYzmAwGAzGHCe9r91OYuPaVk1sP9CZ382zPbrYvmF+ldmLZClturO9w1SxXTvJb6AkRr5uRR14kUdkOJK3mFwotDm+/a3ahdpcd7abIrYPzE6xHUhFyXfs6Mjp8cE+va+90Wer3wEGg5EZT5p4Y6ZAlA4tAjOQ1rlsWYw8HYMHxNk+XiJne6pqoDyiqsBz2Ly4BgBK4tiejlSMvD0FZqsHUtKxa399NnwWJEKQ4ydg/+NGOsTZbnYVBW0DGAQSIz8UiptWwTAU1MTq2hxNDovry+tsJ+JhJKhvx1aJZXH982WJkbejs91R4UYiIUAJm/PdEDFVkhLgKHN0G6SJyoX0tpPv2ePXp5WyDF/YFcPZPnnAQNKHBkyIkRdU+sR2WXZoA2hMbGcwGAwGgzHb6UgT2+3EWj1G/mR/cMINi+lQVRV7O0YB0NPXTjBi5IfMEdvD8YRx04iWGHnRJaJuhRYJ2ru3NFHyhuBaT8cFbWWbNoQy153tof4QknJux4VszFZnOwC0btHE9q6dXTk9nvW1Mxh0wfOcIYJbJZ4RJ6KbAnHE6Fy2SGSOUBIHXeHShLJAyZzt5a8auHypdt5Y7t52OzvbAWsE5WzYYbvIBytqKMgxwynwEAV6br1XWBQjT1u1AKHG44TIc1BVYDBojqObvE6tL1exXXe2l6mzXarU7iOExiwW22U9dSNbjLyeCGAnZ7tUIUGWRSgxc8V2hzNBnchskCa2k0GN2Fju+w5xtru8+nU+ZUMH2WPkzXO2C0qIuhh5gEMs5oQSKY2hppzQ84vPYDBsw2g4jn/YdhTHe2f/RBKDMRcgzna79LUTGisk1PslJBUVR3pyOyk7OxjCaFiGJPJY0UzPtCeQWv8dI+aI7aRbzuMUbOuyyUTz+mYApettp83xbcTId+R3oULbUEE2PLUe8A7tEibYW9xNp1kttl+qie0DRwamXuxngKxLXxNdUX0MxlzGazhVixs8ykaYws52q2Pk7S62+13ElVqqznbdwVzGgYzLltQCAN47N4JokUN4xUASJux6zu2TtG3DTEE5GyHKnO1+C4Z1wpQcMyZjldhOq7Od5znU63HvfSb1tg/qonGtL7dh+CV6Z3vfeKwk++9kUmK7nnxlmdhOnO3Tx8jbydmuie2OlCu/SIiY6nTKs0BsHy/K2e7yELGdrmtTIrbHA3EoibQ0DEEERDcQK/z+Bels55MhwEXPvU6yTmIxJ5Ljo+VdmBJgutj++uuv4/3vfz9aWlrAcRyefPLJKY85evQobr/9dlRWVsLr9WLTpk1ob283/h6NRnHfffehtrYWPp8Pd911F/r6+sxeVAaDUSC/3tuF/3n9DB565VS5F4XBYJiAXcV2juPy7m3f2649bs28SjhFumYK053tZvSVkwj5xgoXVbHQjesaAZRObKdNcJ3rne0cz8HfbE6UfLhfWye0fPf54G3wonqxlu7RtWtmdzuJkWfOdgaDHrzE2c5i5NM6l5NQlOLPoSZDXKoeh72Fogo3cS9b72xXFDW1XsroVl1S70ODX0IsoRhVUuWACMx2FdutEJSzQZuz3WuFs52S6onJGDHyJh9DQpQOHwCpOrb+cXN624dCmvBYl6NoXOlxoE53wZejt524k0PD+v2EImKwpyWuGw6yiMxEhLWTs91V6YIsi0A8YsrrpXe2w0npNXt6jHxl/mI7GaqQ3AmAdwCifYYrcoF8ZiDD55b8RQ2raDHyKrgkXc52XuTh9DkRjzuRDIyWe3Esx/S70KFQCBdddBEeeuihjH8/ffo0rrjiCixfvhyvvvoqDhw4gK9+9atwuVJdol/84hfx9NNP41e/+hVee+01dHd344Mf/KDZi8pgMAqkc0Q7kTArRonBYJSX9mFtn7ab2A4Aa0hve1duve17O7SbbOsp62sHgNZqbf0HYglT3AR9Ae0Y3eCnI0Ke0LSuCUDpY+Spc7Z3juc8lCFHZOPClZbPOR1m9bbTNmiRLyRKvnNn54yPJTHyvka63AMMxlzGa7GbmyZnZrqD1orhA7IuXDZfF4azvQRieyTNRV5OUZXjuFSU/Kny9banYuTtuY1YEZWeDSKs0uJiJuvG1M52mZ5hpXQqrXK2x+h0tgNAI3G2B8y5/zmkO9vr8rhGX1xXvt52Ih4GyOG1CGfutBgx8lOvVZNyEoqsuYRt6WxPmCu2iyLFznbiRE/rbJ/SXz4NRm+9K0FdhDwACA7BGAiZki4n+YB4cTHyTmccHFSqOtsBzd0eizmRDOd2X5dmTP+Vu/XWW3Hrrbdm/ftf//VfY+vWrfjWt75l/NuSJUuM/39sbAw//OEP8eijj+K6664DADz88MNYsWIFdu7cic2bN5u9yAwGI0969R/K0XBpuuAYDIZ1qKqKTpt2tgPA2lbibM/tpGzP+VEAwAbK+toB7WZ2g19CfyCG9uEwqjzFXUj2pznbaYKI7aPnRhEdjRqxU1ZBYuRpiVcnYrsclhEdjcJd7Z7xOcTVzjt446KXZswW22fDAEImWje34uDPD6Jzx8xiO4uRZzDow+oY+QhFgpkk8nAIHOSkimAsYYjOZpFytttbOKsoYS83GWrgOMAllne9bFlSi1/v7cJbpwfx51hW8veXkwrielysXZ3thqBcArGdCKu09HMbrn8T1w1x99MwrJROhcuqGPnyp2AUSoN+7TRglrOdxMh78xDb673YdW64LM72VIy87teMWdS5PE2MPBkaBwBnjl33pYB0tnOceWI7zych8El6xXZB1JY9FoCrsgVAYTHykiRTKbYDmrAsh+QMve2+omPkPS5t/dAqtqvh2d/ZXtKzQEVR8Oyzz+Iv/uIvcPPNN2Pv3r1YtGgRvvKVr+DOO+8EAOzevRuyLOOGG24wnrd8+XLMnz8fO3bsyCq2x2IxxGKpnXd8XPvyZFmGLJdHECTvW673Z9gX2reN7lHtpv1IOE7tZ5gLjEVkfPyH76IBPG5k3xNjEmTfHRyPGDddmnyi7fbp5brj9NRAECPByLQ3sMLxBI71ar//q1t8tvssudBa7UZ/IIaz/QGsKDLOuUc/Vtf7HLZfF+m/iw6fA5ULKjF2fgyduzux4KoFlr43EVylasn26wkAIADuOjcigxEMnxlGw9qGGZ8y3qPtF546DxKJ0nf9FUOmcyZPk3bzYaxjrKjvjLrvPk+aNmmDK53vdCIei4Pjs9dJELHdVeualesiF+xwfj5X1z2jMIwYecuc7fSIRRzHwSeJGAnLlqyPCCWx2CV1tsdTAwj8NL8vpYD0th/oHEMgKps+bDET6ducXXvKfUaMvPXbRpiiQR1gYp+9qqqm1G9FZcpj5CPmHkdp2ybSafRrg9/mdbZrr1Obh2i8WB8KPz1Yemc7iZGPx/Xjahli5IkAy4s8BBv9DksVEuJxB3iHOYMYcljWIuQBemPkAS3iPB6Es0LbxmNj+cfIO510OtsBbZ8JdAUyONsrCo6RV1UViUgCkk9flxR1tgOAq1oT2xFlYrup9Pf3IxgM4h//8R/x93//9/inf/onPP/88/jgBz+IV155BVdffTV6e3vhdDpRVVU14bmNjY3o7c0eJ/rggw/i61//+pR/f/HFF+HxlPcAtX379rK+P8O+0LptnO0TAHAYCkSwbdu2ci8OIwvvDXA43ifgBDj88pntqKHfzMiwgMdeeBWAiEqHipe2v1DuxclIlVPAaJzDj379IpZOc055coyDogqocqrY8+bLpVtAE+HDPAAe23fuBTqK6xzde0J7raHOM9i27bQpy2c15HdRbVSB88Arj76ChuDMYnIxDJwfAAAcOH0AZ7adsfS9TMMPYBB4+cmXUdE584XW+F7toibhTFD7u51+ztQ33gcAOPbuMYS3hQt6PUVWjAvgt/e/DfEsfTf/ZkJNqOCcHKIjUfz6B7+GqzV7SkT/2X4AwIEzFO0HFlHO8/NwuLDtmTE3MZztFnW2hynqbAe09TESli1xddMSI1/pLqGzPUZqBsr/+9la7cGCWg/OD4Wx6+wwrl/RWNL3J45op8jDIZje1mkKfouTMNIhxyS7RupPhgwiJBUVsYQClwkCOU01HOmkxHazO9vpGFjKBHG29wXMEVSJ2F6Xj9hexhh5XuTBu3goUQWqwwfOshh5/Rw4g8hMBFg79bUDmtg+JjvgEM0ZxJBDMpxOfd9z0Ck0A9C7yceNQY1CnO0OZ5xesV1PZpwSny/5Ch5WSejndZJEnO30dLYDxNkuWTesYyNK7mwHgDvuuANf/OIXAQDr1q3D22+/je9973u4+uqrC37tr3zlK7j//vuN/z0+Po62tjbcdNNNqKgoz7SHLMvYvn07brzxRjgc9vpBYJQXmreNRFLB/e+8BEBFXOFw/U23QBLteUE519nxmyMAOqGCw5B/KT5xw4XlXiSGjSDHoXkXrgUOHsEFLdXYuvWSci9WRp4Z3YftR/vha1uJrZcvzPq4/379LHDkJLZc0IStWy8q3QKayMmXTuG9V8/A2zAfW7euKuq1ft7zLjA0gqsvWYeta5tNWkJrmPy7+MbuN/DGrjdQK9di69atlr73sfAxAMB177sOdSvqLH0vswj+TxCnzp7CspZlWL91/YyPPzR6CGdwBo2LGy1fn2aT6ZzpwOABPPOzZ1ApVBb8eQLdARzAAXACh/d/+P3Tur5pZviSYXS82YGlrqVYu3Vt1scdDhwGANxw5w2oWVpTqsWzFXY4PyfpbAxGLhCHoFXOdto6h63spKYlRp44ugNR8xy62QjbTFC9bEkdzg+14+3TQyUX24mAbdcIeSA1nFOKzvZwjBw77Ls+0vE4BHAcoKravmOG2B6h1NleoQ/smJ2OQbYJuyY/TEeDXsnWb4KzPZ5QMK6LZvnEyC9p0MT2s4NBKIpa8jQRwStAiSpQBA+EAp25MyLP7Gy3U187kIqRd7nNdLbrx2jane1pne0FOdvFeKr/nTIMsX2Ks90PBLIbiacjESFiu74uKYyRjw84wCVGy70ollPSX7m6ujqIooiVK1dO+PcVK1bgzTffBAA0NTUhHo9jdHR0gru9r68PTU1NWV9bkiRI0tQfKofDUXYx0w7LwLAnNG4bQ+EokkrKbRmWVfjcdH2GucJ7enc1ADx5oA/337yy7BF/VnGwcwxtNe6iO67nIt1j2oXL/FqvbY9HF7VVYfvRfhzuCU67jPs6NZFi48Ia236WmVhYr02odo3Giv4MA3ofXEu1fb/byZDfxZaNWr9X//5+S5c9GU8aF0GVLZXUrKfK+ZUAgFBPKKdljo1qF2W+eh81n3Ey6edMVfOrAOT++TMRH9H2D2+9F05p9v52tG1pQ8ebHeje1Y2Nn9qY8THxYNy4sVHVWkXtNmIW5Tw/n+vrnpEfKWe7NU5Vw5npoEMc8UnWDR9EKHGpkr7lpKIiHE9aKmylkg/ssX1ctqQW/7urHW+dGiz5exMB2y6DB5kg7u2AxTHy8YSCeFIzWtEirPI8B59TRCCWQDCWQL2/+EjACGXJIATibDe7s51mZzuJke83wdk+rIvGIs8Z6zoX2qrdcAgcorKC7rEIWqtLK8QKHgHykIwk54FgZYy8IAH81G3Ets72SgmJhAiBj0NJKuCLTDaZECPvcJuwhGWCiO2Vutiex6AK+a5FIQY4Ki1ZPKvJKrY7fQXHyMthbb24Pfr2QaOzvVMCnyx9OkepKakd1el0YtOmTTh+/PiEfz9x4gQWLND6ODdu3AiHw4GXXnrJ+Pvx48fR3t6OLVu2lHJxGQxGBnrGIhP+96jJJ+EMcxgKxnCqXzsJdvIqOkci2HVuuMxLZQ2Hu8fw/v94E7//8LtQ1eJit+ciHSPaPj2/xr6Ts2taqwAAB7vGsj5GVVXs6xgBAKyfX12KxbIE8j20DxcXJayqKvrGtZP7xors0dF2pXm95sQfODKAhIUOnPCgtp45noO7hp4L2so27cJzvDM3F2x4QPucnnr77uf54G/RLi4D3YU7K0hfu7eBzni6XGnd3AoA6NrZlfUxwT7tfEF0i3DmEWnJYDDKCxH2LHO2UyYWpcTEuSu2uxw8RH242ure9rDNxDPS236sN4ChoDmRvrlC9kE791H705ztVl4zh9NqLeyybeSC4fw36fhBe4y82WK70dlOyQBGOiRGfigUh6wPkhQKiZCv8TrzMsKIAm/cJyhHlLzg1bbjJDwFi4UzIoezurnt7Wx3wOGQEdeNDsUgh2dJjLxzorN9Spz6NMSNgRR6Y+SlKv1zT3G2Fx4jL+vHZI8/CYCjzvXvqnYhHndAUGd/ZZrpYnswGMS+ffuwb98+AMDZs2exb98+tLe3AwC+9KUv4Ze//CW+//3v49SpU/iP//gPPP300/jjP/5jAEBlZSU+9alP4f7778crr7yC3bt345577sGWLVuwefNmsxeXwWDkSe+kH8nRMBPb7ci75zTR8YIGLzbWaRfTv3qvs5yLZBkHOzUBdn/HKHacGSrz0tAHDWL72nmasHh2MJT1wr9zJILBYBwOgcOqFroildIh30PXaASJIi7mg7GEcVOD3CCgiYq2CriqXVASCgaODFj2PiH9ZoWnzkNVjHhFq7aNj3fkJrYbn3OWiO0V87TPHxmOGP1l+ULE9tmyTrJBxPb+Q/2IBTKLD6E+bV34mnyWRg4zGAxz8VrcwWw3MXUmvBY628OUREJzHIcKdypK3kpCMXsNY9T6JCxv0obxSn1NSLY5O8fIk2EURU1FnFsBSdqwc399JoxhnZg597dSMfL23SYyQdIxwvFk0cJyOmQfscvxIh9qPE6IPAdVTYnlhUKeX+vL//p8cT3pbS995zHv0fblhOKyVmzPIjDb1dkuSiLkpBMORyIv93Y2Zm2MfAHOdoGPUiu2Z4+Rryh4/yEx8m6frK1fnp7fVyDV2S5yUa2zZRZj+jfz3nvvYf369Vi/XuuPvP/++7F+/Xo88MADAIAPfOAD+N73vodvfetbWLNmDX7wgx/g8ccfxxVXXGG8xne/+128733vw1133YWrrroKYY61bwABAABJREFUTU1NeOKJJ8xeVAaDUQDdk8T2kXDx03sM83lXd7FfvKAalzZoF0nbDvaUpKOt1HSOpNIWfvTm2TIuCZ3QILZXe51o013Hh7O42/e0awMmq1oqTenZKxcNfglOkUdSUdGTxwTwZPr0Cxq/S7RNvGc+cByHpnVafVDv3sJ6rXKBVse3Ibbn6GyPDGr7uaeOrs+ZDalSgqh3SgZ6CrtgnSvOdn+LH5XzK6EqKrrf7c74GOJs9zXSNSHPYMx1vE5rne0hypyZfgs7qaMUufz9umg4bnECndHZbqPzzMuW1AEA3jpVWrE9FSNvn3UxGbdDAJkrNcu9nYmw4fK3/76Sjs9kZ3sqDYMuQYQcPwDzjiGJpIJYQrsnReN1Kc9zaNCrBfqKFFSHdPdzXQFJUovrtWuWV08M4Kl9XdP+98qxfiiKeYIWcbbLSalgZ+6MxKdxtgft6WwHAJV3wemU8+olz8bEGHmKr9slPxALwlWpic75rBvD2Y4ode5tgvG5Ryd9bqcPiBXobE+Pkaesrx0gYrsDPJcEEsVXctgZ03/lrrnmmhkjie69917ce++9Wf/ucrnw0EMP4aGHHjJ78RgMRpH0ToqRH2POdluy66wmtm9aWA2+4xwW1XpwdiiMbQd78OGL28q8dObSOZKKoXnpWD/ODoawqG52iydmkVRgCLp2FtsBYO28KnQMR3CgawyXLa2b8ve97aMAgPV6lzOt8DyH1mo3zgyE0D4cRluB30u/HiHfRGGEPKFpfRPOvXIOvfusE9uJ49tbT9cxg4jtYx1jUFV1RjcyrZ8zGxzHwd/ix8jpEQS6A6helH91hLFOZrnYDgCtW1ox1j6Gzp2dWHTdoil/D/ZqF/3extm/LhiM2USqs9184SypqIhTJo4QsSxghbPdEM7svy6IM9VqZ7vR2W6jnvLLl9biR2+dxY7Tpe1tp8HZznEcfJKI8WgCgVgCDRa9T8gYTLHvusgEEZnNGtaJULoeRIGHTxIRjCUwFpELcmBPJpyWpEDDwFIm6itc6B6LGtfYhTIU0p3tBYjGS3Vn+6vHB/Dq8ZmT3775gdX4+KUL8n6fTBCxPS5LBYuFMyKHs/aUEwHWbs52AFBFNxyOBEZNcranYuTtfX9uWiQ/EBsvytnOqxFq3f3Zne1+QA4BShLg8zsWkhh5TWynq68dSDnbAWjHkCz7+myArhE7BoNRdiY7LUcjzNluN4KxBA53a+7fixdUg+OAD65vAQA8Nguj5Imz3SeJUFXgkbeYuz1XRuLazVRJ5FHvt3fU+JpWLUqe1AZMhjjbae5rJ5jR295LcV87wXC2Wyi20+5sl0NyThevpJt+tjjbgeJ72+eKsx1IRcl37sh8DpAeI89gMOjB0th0CnuXWYy8huFst7izPWRDt/8li2og8BzODYXRNRqZ+QkmETL6qO2zLjLh1wcxSuJst/m6mIzP5GQMmo4ZkyG97eMmu/wFnoMk0ilDNBJne5ZKplwhzvZChhhuWd2EO9e14IqlddP+Ryr1fvjGWdPc7URsj8WdZY2Rt6OzHaIbDkdu1+QzQZztKji6xUgSI19ZeGc7r8yCGPnJn1vSr7ULSIcgMfKSKw646HO2u6vdiMX0/TeWWzojrdA1YsdgMMoO6WxvrJDQNx5jne02ZPf5ESgq0FbjRnOlC3sB3Lm+Bd996RR2nRvGucEQFs4i53eH7mz/42uX4FvPH8evdnfi/puWGReJjOwMRTU3bFuNx/Y9vaS3/UDX6JS/ReUkjnRrJ2wbKHe2A+aI7STijsa+dkK62K4qqiWd6rR2mTs8Drhr3IgMRzDeMW5ElWWD1qGC6TDE9q7CbviE+7V1MifE9i262L6zM2MSAomRZ852BoMuSHy3FZ3tRBzhOFAjjhjOVAuERJpi5Imz3SyhLBupuHD73Fb0uxxY21qJve2jePvUID5UokQ3GmLkgZQAblX1BECvs91ssT1CWQ1HOhVuB7pGIxgzKUY+va/d7vccskGuqQeKdLYPGjHy+V+j+10O/OtH1s/4uGAsgS3/8BLODIbw2skBXLus+BwLwaOL7VEHELdIbI+HssfI29jZzkkeCIKC2Fio6NeSwzIqHAkonAsCpfsKgJTY7tfE1WQsiUQsATGH30gSl84nw/TGyGdztjt1R3osCLgq83pNsl5cUhyQrMqmsQ5XlQvxOBHbLTqG2AQ6rpoYDIZtIM725U3aJNUIE9ttx66zWkfdJQtrjX9rqnDhigvqAQCP7Z497vZYImmIir9zcRuWN/kRjifxi13tZV4yOhjSh2/tHiEPAKt0sb1jOIKR0MREjYNdY0goKur9EuZVUTwBrEO+j46ixHb6ne11y+sgSALigThGzo5Y8h40u5tz7W1Xkgoiw7Orsx1gzvZ8aFrXBMEpIDwYxsjpqftSqJc52xkMGjGEMwti5ElEuNcpUiOOeA2xzPzhg7CsrWMXBS7VknW2y/YUVS9bol0Dv326dL3tNMTIA9ZWLRBIKgZ1znaTh3Uickpgpo0KfV2YJban/57QSqNfu6YutrN9MKjHyBfQ2Z4rPkk0Bo0efuucKa9JnO3RsMPCGPlIVje34Wy3cL0VjO6+lseKd+uSGHmVp9cwAUAT2xUZUtpldq7Ofzkkg+MUcEqMfmd7phh5oCCxmcTIO50xijvb9f23AGc/TTCxncFg5ExSUQ0BZ0Wz3hfLYuRtx7u6KHXJpA7bD23UnG2P7+lE0qQ4qXLTrZ+8eJwCarxO3Hu51kX747fPIZFUyrloVDCoO9tpENsr3Q4s0hMZDnRNjJLfq0fIb5hfRc0N4eloM0Fs7w/oYrvN6wGmQ3AIaFitTe327rUmSp44vmnsMidi+0wx+9GRKFT9mM/E9hRzSWwXJRHNG5oBaO72yRBnu6+Rie0MBk1YGyNPnysz5Uw1X2SOxEl/vf3XR4W7RJ3tMXuKiZcvqQMAvH16EKpammteItDa3dnuK0GMPEnasNsQxkz4zY6R14+hNAzoTMaIkTfb2U7ZAEY6ZIC9L2BOZ3udxaLxJy9bCI4DXj8xgFP9xQtbxNkeCQpliZG3s7Odd2nLnBjPXHeYD0aMvED5NbsuKvNyyPjOchHbVVVFPBSnvrc+u9heeIw8cbY7HTGKO9v1pIPgaHkXxmKY2M5gMHJmKBhDQlEh8Bwu1G/Ishh5exGVk9jXMQoAuGRR7YS/3biyERUuET1jUbx9erAMS2c+nXqEfGu1GxzH4fZ1LajzOdE9FsVzh6zreZ4tDOvnu20UiO0AsGYe6W0fnfDve9u1/z0b+toBc2PkaXa2A9b3ttMcr77oem246JUHXsHZV85mfRzpa5cqJQgU3vDLhlliO43ffSGQKPmOHR1T/kY621mMPINBF4bYHrcgRp5CV6bhTLVg+CCiu3Vp6F8ueWe7zQS0DQuq4RR59I3HcHqg+FjfXKAlRt5sQTkThrOdomMHkJaMYXJPOU3HUAIR25mzPUW9HiPfX6Sz3ehs91o7ED+/1oPrlzcCAB55O/t1Yq4QZ3s4KADJGJC04Pdlmhh5O3e2827d2R4wx9nucMhQRcrTGokYHA8YdXexsZn3nWQ8CTWpwuHQty/KY+Rj4zHD9AAgzdme/7ZCOtudjgiVne1ShYSYHiMvj1iTWmkXmNjOYDByhkTIN/gl1OgnOSxG3l4c6BxDPKmgzidhYe3EE1WXQ8Ad6+YBAH713uyIku/Qo5HbqrXP6nII+PilCwAAP3yz+IuK2Q5NznYAWNuq97Z3pqaGVVXFHsPZPjvEdjL8MBKWC75RSlJIGmgX29dbK7aTznYane2bv7AZqz68Coqs4Jd3/hL9h/ozPo7mzzgdxYjt8VDcmA6fC852AGjdrIntXTu7pvwt2Ks721mMPINBFUTMiicUyCYnOhnOdgrEZYLPcPqbO3ygqioiMj3CGelst9rZHrGpgOZyCLh4gXZNUKoBc1Ll4LPZ4MFkzO4lzwQtgweTIcM6ZkXsk2MGTcdQQoXZzvY4fcNbkyEx8v1FONtVVU2J7SWIQ7/38oUAgMd3d2GsyPu2htg+pstIVrjb5UhWJzMR223pbPdo10/JYPEJAnJIi5HPFqdPDWlx6ZI+qJKLs90YqiDOdkpj5KVKfZhGnfS5yfBAAVUMJEbeIUSpjJHneA6i1wdF4ZAYY2I7g8FgAEiJ7U2VLlR7tJPDsTCLkbcTpK/90kU1GeO079aj5F843GvapHI6qqpix+khdI9GTH/tTKQ72wmf2LwAToHHvo5R7D5v3Y/4mycHcbzXogitEkFTZzuQ5mxPi5HvGYuibzwGgeeMv9OOTxKNgaZCouRVVTWm7hsr6I2RB9Kc7RbHyNPobuZ4Dnf++E7Mv3I+YuMx/PzWn2O8a+qUNHG2z6YIeaA4sZ1876JLtGf3nwUQZ3vv/l5j0AAA4sHU4AGLkWcw6CJdzAqbLDCHKXRlGn3UJovMsYQCYkyiIVa/VJ3tRECz4zq5fKkeJX+qNL3tQX3/80n2E4LSMQRlCwcxDBczbWK7Rc52O+4fM2HEyJuUjkF+n2jbJtJp0K+ph0LxgofbArEE4vpz63zWX6NvWVKLZY1+ROQk/u+9qclW+UDE9uCofo/RErE9nFVsJzHydnS2C17tmlQJmyC26852WkVmAyIGxwKG8JyL2E6+Z7dXP6eldD2IkghR/72dECVvOP4Lj5F38BEqxXYAcFW5EYs5kQiMlntRLIWJ7QwGI2d6xjQBtbnShSqPdgI+avFFPCM/dp0jfe01Gf++trUSFzb6EEsoeOZAt+nv/9+vn8FHv78T9z26x/TXzkTniLZNtlanTsrr/RLuWNcCAPjRW9a427cd7MEnfvgObv7X1/H+//cmfrLjHEYpGzwZj8gIJ7SLpbYaOiZnV82rBMdpAjuZKieu9hXNfipvZmSjmN720bBsXMjXU9zZDgCNaxsBThNUSey3WSgJBRE9HYNW17foEvGRJz+CuuV1GO8cx6NbH0V0bKLjguaBgunwNWvCcDwQRyyQX6Rjel97psG02UhFawX8LX6oSRXd76V+/0lfu8PjmDODBwzGbMEh8HCK2i2dYNxc8SwVgUyPOOKzqMM+KqcGGWhwqaY62629TjcENBtuI1uWaHVqO84MIalY39seMtzc9t4+Us5267YNo5+bsusyv8k1FDQeQwlmx8jbeTAnV2o8Tog8B1UFBoOFRckTV7tPEuEqwW8Jx3G4R3e3/3jHuaKOhbxHP9cY1q+bChALZySHGHk7OtvFCk34VMLF36vQxPYEtSKzQQZn++R7FJkg37O7Qh9ooTRGHkjrbU//3IIDEF0FDaskIgnwfBICF6eysx1I9bYrrLOdwWAwNHqJs73CjSq3dkM2HE8iljC/J5CRP4mkgt3nhgEAmxZmFts5jsOHNrYBMD9K/ql9XfjH544BAA53jZfkxkYmZzsA3HuF1mX8/KFedJnssldVFf/9+hnjfx/sGsMDTx3GJd98Cff9fA9eOd5fks9eLB36oEKt10nNTQCfJGJpvXbCfUh3t5O+9tkSIU8opre9Tx9EqPE6IYn03tQAAMkvoWapdjzr3W+uu504vsEB7lo6Bk4y4a5x4+PPfRy+Jh/6DvTh/+76PyTT+ntnq7Nd8ktw+rVzkWBPfjd80sX2uQLHcYa7vXNn6vefRcgzGHRDouTNFpjDFLoyiZAYkZNImBirT9aFU+AhCva/hZbqbLc2Rj4s66KqDQXmtfMq4ZNEjEVkHO0pvkd3Jsj+57O5c9cQlEvhbKfk+pJAUglME9upjpEn6RjmrIvUNkHfuiDwPIcGfYi9r8DediLSlyJCnnDn+nmo9jjQORLB9iN9Bb8OcbZHI7rYXUAM9oxMEyNvZ2e76NeETzVanNiuqqrhbOckyq9R08R2o7M9D2e7x0/EdnrvXxhi++ikIQOnryCxXQ7LkCTd4EWx2B6PO6GErT8vKyf2v1JgMBi2gcTIt1S54HeJ4PWhxmL7fxjmcKRnHKF4EhUuEcuasv/43rG+BQLPYV/HKE71mxP/9PbpQfz5r/Yb/zueVAwh3EqIYNw2KQZ9RXMFLltSi6Si4sdvnzP1Pfe0j2B/xyicIo/tX7wKD7xvJVY0VyCeVPDswR7c8/C7uOwfX8I/PncMpwcsuAgxidS6o0tkXDOpt50429fPryrXIlnCfP176RjOf1iE3ABooNzVTrAqSp50mXtqPeApuHk+HVULq/CxZz8Gh9eBsy+dxW/+4DdQVW3ox/ics8zZDhQeJT8XxXYg1dveuSMltof69HXROLfWBYMxW/Ba5OYOU9ixmx5RHIqbNwxOhCKXg45zhVRne2mc7XbcRkSBx6V60ttbp6zvbaelp9xrONutM0sYznYbDmFMh5l99vGEgoQ+fE/TwBLBbGd76vfE3vvHTNRX6L3t44X1tg8Rsb2EgrHLIeCjl8wHADxcROojL/HgBA7xuL7sZsfIK0kgGcsutuupAHZ0tjsqNWe7GitObE/Gk1AVFU6nDM5F+XWZ6AI4AYiNw1mhbTOxsdw7210+IrbTux6yiu2Sv2BnuyG2uyiNka/WnO2I0l3HOhN0XC0wGBay6+ww/vQXe41IYkZ2etM623meM07CWZS8Pdh1VnO1X7ywBgKfPRa3we/CtcvqAQC/2l28u/1Y7zg+85PdkJMqblvTjGWNmvhhtdAclZMY0KODJzvbAeBTurv9f3e1m3oD8odvahcpd65rwQWNftx7xSI896dX4tk/uQKfvGwhqj0O9I3H8L3XTuP6f34Nd//X2yXrsM+HDn0Yoi3DurMza0lve+cYYokkDusd1czZnqJPvwHQqN8QoJ2m9brYvs9kZ/ssi1dv3tCMDz/2YXAChwM/PYBXvvoKACAyqB1/ZpuzHWBie76kO9vJMAaJkWd97QwGnRD3aIh1tsMppsXqm3juT2LkaRGKiNhulis1GyQa2q4O5sv03vadZ6ztbVdVlRpneyli5Gl1tpvp+o9QVj0xGXIMMS1G3uhsp29dpNNInO151lcRBnXBuLYEfe3p/O6WBRB4Du+cHcbh7rGCXoPjOCMCGgAQN1ksi+tC9Qwx8nZ0thtie7w4sd3o5HbI4N2UX5dxnCEqE2d7JAcTSaqzXRfbHfReq2cX232FdbZHZEiSfuyh2NkeiznNH9axGUxsZ8x5/vPVU3hqXzd+vaer3Itie3rGU53tAFDl0U50Rpmz3RYQsT1bX3s6d+tR8k/s6SoqZrFnLIJ7Hn4XgVgCmxZW458/fBGW6jfszwyY2688GRIP75NEY/AjnWuXNWBxnReBaAK/eq/DlPfsGA7j+UOa4Eei6gmrWirxtdtXYedfXY//+vgGXL+8AQLP4b3zI3jchKEGsyF9923VdAlwa1qrAAAHusZwuHsc8aSCGq/TEKdnC8V0tvcbYjtztk8HcXzT2teeiaW3LMX7/+f9AIA3vvkGdv/P7ln5OQnFiu2zZdAiV5o3NIMXeQR7gxg7r91sIzHy3qbZt30wGHMBIl6ETO5sN2LkHZQJZpL5Mdm0ReoT0TAiJyGbGKefTlJREZW117brQMaF+jVpTw49scUQlRWQBjG7O9t9JveSZyJEYSoGYG4NBelrF3nOGACiCXJvZdykdIzZ4mxv0K+tBwp2tmtCYl2JxfbmSjduXa1dTz/y1rmCX0eqlBCPWxQjL+tC7Awx8nZ0tktVPiSTfOozFIghtjsT4Gl3tgOAVAHEgqhboQ2+de2aWXMxnO2ehOaOF+g9ZmSPkfcXtP9MjJGvLHbxygIR2znZvgmwZkDfrz6DYTJEEDzRN7t39mJRFDXN2a45YclJ+Eg4XrblYmioqop3Z+hrT+e65Q2o8ToxEIjh9ZMDBb3neFTGPQ+/i56xKJbUe/H937sYLoeAJXqnttXOdiIWt1a7wXFTnfw8z+GeyxcCAB5++5wpPeo/fvscFBW4Ymkdljdlju6RRAG3rmnGDz+5CX9x8zIAWsS/3SDx5LTFyK9sroDAcxgIxIzBh/VtVRm3AZohwwOdI5G8t10SIz9rnO262D54fNC40DaD2eZsJ6y/dz2u/trVAIBnP/uscWHLnO0pyHc/15ztDrfD2J9IbzuJkWfOdgaDTqyKkY8Q1zJlTkSviVHQBNq6l4nYDgABi7q50527dhXQqnVjwLCJ546ZSN/WPDbfRqwYRplM2HAx23O7yMaEGooik0KIuEzLMWMyhtgekaGYcA8lNAs62wGg0a9dWxfa2T4U0p5XV8LOdsI9l2tGkaf2dxtx9vniqnRBVXkovMt8Z6qsG3WyiO2Gs70M624mpAp9CCFhjtjudCayrgeq0J3ti67Ttr3OnZ0z3sshf3e56V8HUqU2VGNmjLzLRb+zPR53gktaa8wrN0xsZ8xp4olUr7RZ3dWzlaFQHHJSBceleoCrPXq8FHO2l51T/UGMhGW4HDzWzJt5ys0p8rhjXQsA4LECXNfxhILP/mw3jvUGUO+X8Mg9lxhJB0t09+Tpfmt/QInjt3UaZ/ZdG1tR6Xbg/FAYLx3tK+r9grEEfvmu5pD/1CRXezZW69+FLcV2w9lOl9judgq4oEEThcj3sWHB7IqQB7QJdJHnEE8qRix8rpDHN8wSsd3f7Nf6pFWg/1C/aa87m7vMr37gaqy7dx1URUV0RNseZuPnZDHy+ZMeJQ+kOdtZZzuDQSVGjLyJHeUAfW5ugpm9y4QIZU5dUeCNZbWqtz2sr1+Os2+XfbUeNzwSjhvVKVZABl28TgH8NFVudoA527OTXkMRKDJm3xjQoWwdECp0sV1RgaAJqSnkeOGhbABjMmSQva/ACtLBMnS2EzbMr8JFrZWIJxQ8+k57Qa9BxMMk5y0oBnta4nqaX4aObiWhIKmfk9gxRt5V6YIsi+CVKNQihlMMsd0hUy80AzBE5erF1ahcUAlFVtD+xvTbnrEOpATgpHsQnDjbp3TVS76Cahi0GPnZ0dkuKPmnd9KEPc+KGYwS0T4cNiK/TvYHLb0Iox3iam/wS3AI2qHDiJGPMGd7udmlu9o3zK/OOarsQ3qU/G+P9GMkj4l/VVXx5ccP4K1TQ/A4BTz8yU1G5DWAsjjbs+FxivjoJfMBAD9662xR7/d/73YgEEtgcb0XV19Yn9NzVjRrJ0Hnh8KmxbCZQTyhGDH8NMavr23VhhhIj9z6tqoyLo01CDyHefq2nW9vO+mRI71yswErouQNwXUWxqtzHIf3fe99WHLzEuPfmLM9xZwW2zfrYvuOSc72JrpvaDAYcxUPiZE3WTwLk55yypyZPguc/jQKZ1b3tqf3cts1XapGv1chJ1XTh1HSIcI1DU5usn9YlXgApLYNu/fXZ8Jv0rAOiZGnbeCA4HIIxj2lcRN620Npxwuaqddj5PsLdLaXq7Md0K4Nibv9pzvPI57IvyrBENthhbOdxMhPvbeX7oa2ZYx8hQRZdsDplBEPFn5vnAjNokPO2l1PFZIfiI2D4zjD3X725envyRoJBpKccfCCJrJ3tlcA0bG8X0+LkY9B5QQtYp9CSIy8yBWXAmF3mNjOmNOcG0w5b8PxpCE+MabSM6atGxIhD6THyNtHRJyrkL72XCLkCStbKrCqpQLxpIKn9s3cn0P4zovH8eu9XRB4Dv/58Q2Ge5uwqE47KRoKxfMS8fOFpFJMJ7YDwO9ftgAiz2HnmWEc7s7/pAbQegkfefscAODeyxfl7Fqo8TrRXKmdCB3rsU96xsvH+iEnVVQ4VCoFWdLbDgA8B6ydhWI7kBqEyFdsT3W203kSnglDbN9nntg+26PEBYeAD/3qQ1h8w2LMv3I+qhZWlXuRTIeJ7flDnO09e3uQiCYQ1GuUWIw8g0EnVojLQLpYRJc4Yjh3rehsp2jwgETJW+VsJ+5lOw8guJ0CJF0wtPKalOx7NIjLfkm7fxNLKAWJbbkQpNjFbNbxgwzouCg6ZkyG3OsbM0FsNzrbKaslmQyJke8v0NlO4ttryxSFvnVNMxr8EvoDMTx3qCfv57v0+1oJpbQx8kSA5QQOgg1/cwRJQCLhgMORQKzAQQxAE1N5PgmBVwDHLLhGlXzGdrLoel1sf2l6sZ0MVjids1hs9zUAwfzTGhORBCQpDkX0a7FCFEJi5EV+dmtvTGxnzGnODk6MuT7Zz3rbs9GjO9ub08Qb0oM2ysT2sqKqqiG2X7ood7EdAO7eqN10f2xPblHyP3/nPB565TQA4MEPrME1yxqmPMYriWjRT8TPDFq3T6Wc7dNPfTZXurF1TTMA4IdvFuZu/+3RPrQPh1HpduCuDa15PXdVi+ZuL1TotwJSHbCpXrV93GEm1qYNeFzY6Kfi5lYhkMSIzjzEdkVR0R+YXZ3tANC03jqxfTbGqxMkv4Tf3f67uOf1e8ALs++03z8vJbbnmk6kquqcFturFlbB2+CFIivo2dPDYuQZDMpJdbabHSNvfzE1E4Zz19QYeQqd7aRz2aoYeUo6mGvSouStggwe0OBs96aJnWYP6ACAnEyJ+HbfNjJhVg1FmHJnOwBU6IMHpojtsdnhbG/Qne2DwTjkZP7DKkO6kFhXBmc7oFUlfGLzAgDAj946l/fzpSptueMJV0lj5A0B1uu0ZZIKx3FIqE44HDKiY4UNYgDaUIHTqe9vGRz+1JHWTb7oWk1s79nbg8hwdqGVDFY4xDj17v6sYru/SRPblfzO2+WwDJcrBlWkd0Bec7ZLcAgxYBYnS8++u24MRh6cmSS2n+pjYns2iNjeVJkSb6pIZzuLkS8rnSMR9IxFIfIc1s/Pr7v6jnXz4BA4HOoax7/+9gR+8MaZrP/9y4vH8dUnDwEAvnDDBfjwprasr7ukgUTJW9fbTpztbTUzn4jeq3esP72/23D95gMR6T926fy8b7St1KPkj3Tbo7d9IBDDK8e1ScpLG6xxNFjN8mY/HIJ2oTUb+9oJhTjbh0JxJBUVHAfUlWlq3gqIs73vQB+UAm5uZIJ0ts/GGPm5gr9ZE9sTkcTUPrQsREejUPQbwbN50CIbHMcZ7vbT208joUcMM2c7g0EnRNCyztlOl1jktSJGnsJ1QZzt4xbFhYcpST4g5oBhC53tQSIkUuDaFQUeLod2G9iK3vZwWly/3beNTJgltkcprJ6YDHG2m1FFQQZSaDqGZqLG44SoGxVI/3quyEnFMCmVS2wHtPtZToHH/o5R7Gkfyeu5UgUR2yUgZvK9c1m/35FBZDYEWBtGyBOSqgRRLN7Z7nDoYjvlrm4AWly6PpThb/GjbkUdoALnXj2X9SlksEIT2+m+Ns3ubG8C1CQQHsrr9Uhnuyr5zVrEkuOudiMWc4Dn1dQ+Pwuh7+yHwTAREiM/v8aD9uEwTvTZJ+bZbvTqMfItVVPF9pEQc7aXE+JqX9NamfcFXY3XiRtWNOK5Q73419+ezOk5H764FX96/QXTPmZJvQ9vnBy0rLc9Ek8anVczOdsBYF1bFTYuqMbu8yP48uMH8P3fuxhiji7PQ11j2HV2GCLP4fe3LMx7WVfqzvYjPfYQ25/c24WkomJdWyUa3fmd4NkFSRSwsrkC+zvHsDHPAROaKERs79OHSep8Us7bOA3ULK2Bw+uAHJIxdGII9Svqi3q9sfYxjJ4dBcC6qmlGdIlw17gRGY4g0B0wLmqng7japQoJIgUuNCto3dyK408dx/EnjwPQbl45Z9FwDoMxlzDE5bjJne0UurmBlMhsppAYpjASOtXZbpGz3egpt/c6qfaS2jsWI0/wSQ5E5ZhFYrv2mg6BMzq/acJvUox8qnqCjm0iEymx3YwYefoGljLB8xwa/BK6x6LoG4+huTJ39zEZ+OE5oMpdPtG4zifh/Re14PE9nXjkrXPYkMe9FHKdFY85LYiRJ2L71Ht76c52u6JAgsMRN0Fs1489GdYDdaQ52wEtSn7w6CDOvHQGKz64IuNTjMEKIU79wEF2Z3uj9n8DPVqkfI5oMfIxwFlh1iKWHOJsBwA1FgBH+XecDfrOfhgMEyEx8jev0g52LEY+Oylne+qEsorEyFt0Ec/IjXfPaWL7JXn0tafzl7cux0c2teHOdS0z/velm5fhmx9YM2N80xLdKXq63xpne9eodjLud4nGheBMPPC+lXA5eLxyfABffepQzpHDxNV+29rmCckOubKqRYs8P9EXsKwbL1dUVcWvdncAAO5aP6+sy1Isf3fHanzxhgtx+7qWci+KZaTE9tw7jYjY3jSLIuQBgBd4NK7Vfqt79xYXJa+qKp7+9NNIRBNou7xNm7JmUEu+ve2kPmAuRsgTWjdrznZSy8Bc7QwGvZBYXrOd7bQ4lydD1oeZQiLNzvaARc72kDGMYe/tgzjbrTQHhGL0xMgD1gykEEidBW3HDYLZMfK0DSulU2FSZ7uqqqnaCUr2kemo16+x801LJE74Gq9U9hq/ey5fCADYdrAHvXnEnkuVmkgWjTiAuMliezwMiC6An7rPxHWTjZ2d7SrvgtMpFy22z9YYeQBYdJ2WNnru5XNZn0LEdoGPUi+2G/tLJmc7AAT6cn4tVVUhhzVnO+eqnPkJNkXrbNf248RYfskaNEH/Lx2DUSDheAK9+gnSjSub8P03zuJUfxCqqtqyB6bckHXVnB4jT07ALZwUZ8wMcbZfkmdfO2FBrRf/eNdaMxcJi+u1G/dnLHK2d+TY157ORW1V+PePrMcf/Ww3/ndXB+ZVufG566Z36PeNR/H0/m4AwKf0KPp8aa12w+8SEYgmcKo/aDjdy8HBrjGc6AtCEnnctqYRb7xctkUpmovaqnBRW1W5F8NSSGf7YDCGcDyR042rvnHS116+eDqraFrXhM4dnejd14s1H1tT8Ovs/dFenH7xNESXiDt+dAf7zaccf4sf/Yf6cxbb53JfO6FlUws4noOqaENnLN2BwaCXlLPdms52mgRmAPCZ5ExNJ0Lh4IHVne0R0lNu8+3DENstvF8RpExsNwRlCwYxwpRsF9kg32GxQyokRt5DURrGZCpNOobEEgqS+vkmbb8nmWj0a9fYfYH8RNWhIOlrL787e/W8SlyysAa7zg3jZzvP489vXpbT80iMfDQsWhMjn0VgJgKsnZ3tquCGwyFjlMXIp5D8Woy8kgR4AQuvWQhwwOCxQYx3jaNi3tT7oiTFQOSigIPudUCc7bGx2ESdydcAgAOCuRtIFFmBqqiQpBg4D73OdofXgbisHUdig0NwtJZ5gSyCOdsZc5Zzg5qzqcrjwLq2Kog8h2AsYTi4GSlUVU052yumxsgzZ3v5GAjEcGYwBI4DLl5QmNhuBUt0sf38cNgSN3enHqvdWp3fxOdNq5rwtdtXAQC+8+IJPL67c9rH/2THOSQUFZsWVmNta1VBy8pxXKq3vcxR8r96T/u8t6xugt9l38lghkal24EK/aZxrlHyxNneMMuc7QDQtF6bAu5+t7vg1xjvHMeL978IALj2769F7YW1piwbo3zk62xnYrt2s4okRQCAt3HurgsGg3Y8kjWd7akYZLrEEb9JztR0IhTGyJfK2W73AYRqbwnE9ihtMfL6tmGls52SdTEZn0mufzJ0QLOzvdIkZ3s4bRDM7seLXGjQBed8ne1DIU2ErbWB2A6k3O2P7mo3hkNmgoiHkZBgTYx8FnHV6PG2s7NddMHhMLGzfbbEyANGb7u72o3mDc0AgHOvnMv4FMPZrtLvbCf7i6qoRjoDAEBwAN66vJztsn4clqQ4OA+9znaO48C5tHvj8shwmZfGOpjYzpizkAj5RXVeOEUeC+u0AzmLkp/KcCiOeEIBxwGNE8R27UQxHE8iljDXTcHIDRIhv6zRj0qPfU4+GyskeJ0CkoqK9mHzo+Q7dWd7Wx7OdsLvbVmIz1y9GADw5ccP4I2TAxkfF4kn8fN32gEU7monEDf74e6xol6nGKJyEk/t6wIAfGhjW9mWg5EfFzRqFyk7Tg/l9Pj+gHbh3+iffWL7/MvnAwDOvXoOux7alffzVVXFM595BrHxGFo3t2LzFzabvYiMMuBr0Ya7xrtyG2YiYrunYRbcxCiC1i2pUXLmbJ/9PPjgg9i0aRP8fj8aGhpw55134vjx48bfh4eH8fnPfx7Lli2D2+3G/Pnz8Sd/8icYG5t43tLe3o7bbrsNHo8HDQ0N+NKXvoREwhoxj5EbRDgLm+hsTyoqYvqwLG1ORK8FYjuNfcOl6my3+zqp1q+PLY2RN9zcdAiJVqQ/EGh3tvtNcv1H4trxk2ax3axjCBkEczl4CGWOTzcDco3dn6eomnK22yN97saVjZhX5YbbIeD8UG5D/SQWOzwuGAKqacTDgDPztZnhbLfJoEJGHJqz3bwY+VlwnerUxfZJve0AcPalsxmfQgYr+FkgtosuEYL+G5AxSj7Qk/NryeE0sd1Nr9gOAJxbuzeeGGViO4Mx6zg3pIvttdoB/EK9r/Jkn8kTerMA4mqv80lwiqnDhl8SQc6Xx8LM3V4OSIT8pQVGyFsFx3FY0qDtU6cHrBPb83W2E75883LcflELEoqKz/5sD450TxVpntjbidGwjNZqN25c2VTU8hrO9gzvUyq2H+nDeDSBlkoXLlvC3Ly08P612vTvYzOkMBBmc4x8/cp6XPuNawEAz33+ORx78lhez9//k/04ue0kBEnA7T+6HbzAToNnA8TZHuzO7aYPc7ZrkN52gDnb5wKvvfYa7rvvPuzcuRPbt2+HLMu46aabEApp+0N3dze6u7vxne98B4cOHcIjjzyC559/Hp/61KeM10gmk7jtttsQj8fx9ttv48c//jEeeeQRPPDAA+X6WAykxE4rnNwAPdHYBEti5GXdpcqc7QbGAIJk73VSUwpne4z0Udt7XRBS6Q/m37+hJfEgG2Z1tpNjxmyIkTfL2U7LMMpMEPNRXyA/Z/uA3tle67XHNboo8Pj5H1yK1750DZY1+XN6jkuvFA2N85oTXTHRcCWHswrMRIC1c4w8nF7N2T5mVoz8LBDbpali++LrNdPTmZfOQFXVKU8hgxW8EqZebOc4znC3TxHb/Y1AMHdneyKiDy254oYznFZ4rzYskBgfLe+CWAi7y8iYs5wZSDnbAWBpg/ZDcLKPOdsn0zs2ta8dAHieM07CWZR8eSBi+yabie1AKkr+tAW97Z0jhcXIE3iew7c/tBabF9cgGEvgnkd2oXs0YvxdUVT86E1t2vKTly0segp7VYt2QnGkZzzjSWUpIGLtXRtbwc+CqfK5wh3r5sEp8DjcPZ7TsAaJkW+chTHyAHDlX1+JDZ/eAKjA4x99HB07OnJ6XqA7gBe+8AIA4JqvX4P6FfUWLiWjlBQcI19P9wV8sUxwtjcyZ/ts5/nnn8cnP/lJrFq1ChdddBEeeeQRtLe3Y/fu3QCA1atX4/HHH8f73/9+LFmyBNdddx2++c1v4umnnzac6y+++CKOHDmCn/3sZ1i3bh1uvfVWfOMb38BDDz2EeNw6IYsxPUQcMjNGnrhTOQ6QRLpuGflIrH7c/M52mlyqVne2hygR0Ehn+3DIumMU2ffIgIPdSaU/mJ9MGKKsv34yPt3NXbTYTuExYzIVbu07LFZsJ8diuw/m5Eq9ESNfmLPdLjHyALCwzgsxj+Fz4myPBPTv0swo+WnEdiLA2jlGnpO8JjnbE1DBAeIsuJdjiO2p+8Ftl7eBd/AY7xjHyOmRKU+RwzJ4PglOTVAvtgOYRmxvAgK5d7Zrznats91Yr5TiqPAhmeShBMuX+mo1dJ4BMRgmcHZQO+CT+PgLdBfuyX7mbJ9Mz5gmQjZlEG+qPE6MhGWMWHgBy8jMWETG0V5NfLtkoR3Fdm3fOt1vvrO9w3C2Fz7xKYkC/vt3L8aHvvc2TvQF8cmHd+FXf3QZKt0OvH5yAKcHQvBJIn5nU/GR60sbfHAIHALRBDpHImirKe2kau9Y1IjLv3tj6wyPZtiJaq8TN6xswLaDvfjV7g78bcuqaR9PnO0Ns9DZDmgTwrf9520IdAVwcttJ/O/7/xefevtT03avq6qKZ/7oGURHo2jZ1ILL/uyyEi4xw2ryFdvDA9qw1lx3ttcsrYG7xo3IcIQ52+cgJB6+pib7+ePY2BgqKiogitotgx07dmDNmjVobGw0HnPzzTfjs5/9LA4fPoz169dPeY1YLIZYLHXjcXxcO2+VZRmyXL5BXfLe5VwGs5B4bYgzHE8iFoubMlA5Hta+M49DoK4mwKVrAIFoYdtYpm2DRKY7eJWabcYjatvBeMSafS0Y1a79JcHe+5HfqQlJI6G4ZcsZ0AcaXAKX83uU8xjkcWjrZDwcM/39AxFtu3A7cl8XdkLXlws+fhDI0IGzwP3DDr9RXn07GSvyGJL+e0LjNjGZWn0j6RuP5vV5BnQnfLWbvvVAlpf3aNtELKYNDMjhUUA05xpCiAUB0Y1khnUT1c0Egp3XneSGI55AZDRS8DLGgjFUOmQocEGh5Nxr2mOV4IYDQCI8AlX/O+fkMG/zPHS80YGTL57EhgUbJjwlHorD6dR+RxKCy3gerZABldBgaMI64j0N4AOvIJHj54sEIhDFBARBQcLhpXq9OCslxGJOJIKjVJwzZVqOmWBiO2POck7vpSHO9gv1XtyT/UGoqgqOY85PQk8WZzsAVHmYs71c7Dk/AlUFFtZ60GBDF+tii5ztoVjCcCe01hTmbCdUuh14+J5L8MH/fAsn+oL4zE/fw4/vvQQ/1F3tH764DX5X8RO0TpHHBQ1+HOkZx+Hu8ZKL7Y/v6YSiApcsqsGCWiaq0MbdG1ux7WAvntrXja/cumJCnUc6clLBUIjEyNvvmGAWvMjj7l/ejR9f+2N0v9eNn9/6c3xqx6eyiqcHHz2IE0+fAO/gcceP7gBPmUuPMT2G2N4TgKqo4GYQmliMvAbHcdj8xc04/H+HseDKBeVeHEYJURQFX/jCF3D55Zdj9erVGR8zODiIb3zjG/jDP/xD4996e3snCO0AjP/d25vZnfHggw/i61//+pR/f/HFF+HxlD8ic/v27eVehKLRDJTabZ0nn33OEJuLoSukvSavJrBt27biX7CEDMcAQEQgHC9q2dO3jcExAQCH/e/tQuBE0YtYEnrDACBiKBC25Ds828ED4HHmxFFsGzti+uubBdkehoJRPPvsNlhxi6dnQNs+jhzYC3Tkl2BWjmNQVxcHQMDRU+ewbdsZU197X6f22kO93di2LbcKLDtxfExb/p6BkaL2m/Zubf84ceQQtg0cLPh1yvkb1an/DgyMBotaFweGtXUaCwWo+z3JREAGABFDoTiefmYbcjWGn+nSjhNnjx7Etr4DFi6hdbz86svgJd4Q29/Yvg0B9zxTXntzdzuSggvvZthGOo9qx5Lz3edtuw3VDI1gsSeJ7rMdBS9j17ku1LlkxBUBL9r0c2Yj07FKTIRwG4A9O15Dz7FUiqg8T9MOdj66E73zJl4/RANR+F3aoMGufYcxcIbuRIxAXDMDvPPaOzjJnzT+fdHAIFYHerHt2WeRy4lJ8HAQkqTdA3/v4An0tdO1faQzMD6AeNyJoa5z2Jfndl7u67ZwOJzT45jYzpiTjIVlQ6wjYvvCOg8EXnOe9o3H0JRBWJ6rkBj5psqpwmYV6XJine0l5x09Qv4SG0bIAxNj5M0cYOnS494r3Q5UmCCEz6ty4+FPXoIP//cO7DwzjHsfeRdvnRoCzwH3XL6w6NcnrGqpwJGecRzpHsMtq4vrgM8HVVWNCPkPMVc7lVx1QT0a/BL6AzG8fKw/6/YzGIxBVQGR51DjsU9EnRU4fU589JmP4odbfoiRMyN49H2P4vdf+f0pXW7B3iCe/5PnAQBXP3A1GlY3lGNxGRbia9J+axRZQXgoPGM8PBPbU1z1N1fhqr+5qtyLwSgx9913Hw4dOoQ333wz49/Hx8dx2223YeXKlfja175W1Ht95Stfwf333z/htdva2nDTTTehoqJ8nYOyLGP79u248cYb4XDYN5Y0F1RVxZff3Q5FBa645no0+ItPttnbPgoc2IUqnwdbt15Z/EKWkLGIjK/veQWyyuGGm27JOqCYjUzbxjcPvQZEY7ju6iuwspmOrsze8Sge3P86YgqPW2+9yXQjwS/73gNGhnHJhnXYelGzqa9tJqFYAl/f8zISKodrbrjJknjzfzn+JhAK45orNuPiBdU5Paecx6Dhd9rxTPsxVDc0Y+vWi0x97UMvnAA6zmH50kXYeusyU1+7FMzrHMN/HnkHnNONrVsLPz/6SdcuYGwUmy/egJtXNc78hEnY4TeqcySCbx94A1FVwNatNxf8OvL+HuD4QbQ01mLr1otNXMLyoCgqvrbnt0goKi6+8rqMhqRM/NOR1wFEcfM1l+Gi1kprF9Jk0rfHU7WnEI9r2+RVm9dDnWfOdyr85D+BqvnYunXrlL8988QzGMQgVl60Elu2bjHl/cymZ/As0AHUuF0ZP0Mu/Pzffg4nL4N3+gt+jVIz7bFKSQIHP4sNqy6Aui71eToqO/DTX/wUseMx3HrLrcagvJJUsC++D84KTau55PJrobZdWrLPYgVP/PQJHNt/DMsXLcfFacc/7pgK/vGfYOu1mwFP9oRGwmnhNLZL7wIALr782v/P3nvHx3EW+P/v2a6yqrYky3K34xInthOnOAXSSQwJJbQQQsvBwSVwHBzH3XF3vy8c3+O4Ozg6d3whBAihBAglGBITh/TEqbZT3CVLLrLVy+5q6/z+eOaZle2VtGVWuzP7vF+vvBRLuzujR7OzM8/n+Xw+6Avtm9S47ZFtRMM+mht8nJXlcV4On4mQTmibCSW2KyqSzgEx0doS9Js3XH6Pm0XN1RzsC7HvxJgS2ychne3tDZlj5AGGwipGfrZ5pkuK7TN/OJeCRc3VuDQYm0jQNx6lJWjNe6rQvvZMrGmv49vvPof3f18I7QDXrGmz1IG+pr0OnhO97bPJ891DdPaHqPa52XxW+U6GKabG43bx5nPm878PH+QXz/VMKbabEfJBvyUxsuVObWstN//hZu646A6OPnOUX77zl7zj3neYznVd1/n9X/2eyGCEtg1tXPzpi0u8x4pi4Pa6qWmpIXQixNjRsWnF9lRCCPKgxHZFZXL77bdz33338cgjj9DRcfoCvLGxMa699lqCwSD33nvvSRMabW1tbN++/aTHHz9+3PxZJvx+P37/6eKv1+stC5G7XPajUGp8HsaiCaJJLPl9YilxDVHj99hufBpcaRdULKVRk+f+Tz42InHRvxys8ttmPJqD4m+YTOkkcFHttXbqLxxPARCs8pX1mNR7PPg8LmKJFONxnYZa6/dV9tfXVwdyHotSnIPqq41Y21jS8m1PJISzv7bMj4upaKgR8xXj0URB+x8x3h+FjkMpP6OajXVFsUSKJC4C3vwcptGkcUz4nfF5C+Je++jIBIORJAvnzPw76bpOv2H2aq2vtu04eL1eAvUBokfFOcSTjIBVv0s8DP5aXBleLxERTudAXe7n2NnCVycWWqUiobz3MRlJ4m1IoHvsd4xkPld5wVuNJxE+6ThZdNEivNVeIv0RBncP0rZO3ENEJ8Rcls8njHye6nrrjq8SUW3MJ8fH4iePT4NIhPBODED9zEYsPW70tQOe6kZbj0t1czXRIR9aYtwW10ynbj8bVI6moiKRfe3S1S45o8WIkj9ubey13ek1OnIyd7arGPlSMBFPsvPwMFCefe0AAa/bFKsP9lnX294zKPvarRPbAS5dMZcv3ni2+e9bL11i6euf2S5WML9ydHbF9nueFa72zWfNK4qbQzE7yFSCh/b0ccLofDuV48a5uhxrJYrFnJVzuOl3N+EJeNh731623L4FXReTOi///GV237sbl8fFG7//Rtx5ThIpyp9se9vDA2HQAQ2qmq39DFEoyhld17n99tu599572bZtG0uWnH6NMzo6yjXXXIPP5+O3v/0tgcDJnyWbNm1i165dnDhxwvze1q1bqaurY82aNUX/HRRTI6/vwoboVyjhmJjYrvLZ73PT43YRMLqGx6PWdJ5GjHGt9tnnOrrK68btkr3t1ne/ymOk3O8tNC2d9jQUKs58heznri3zsZDI/bTq/TGZkDwubHjuAAgG0mMj7yfyYSJuv3PGqdT6PMi126MFzPWFo2Isyv1ckQtzjXvtE6OZ78lPZTyaIJYQCzCaa+2dPhdoCBCNGoJTdPr7rpyIh8Gb2egSN87d3pryFRg9QXEvqkfy1xLi4Thebxw8DrpH9QdPO07cPjeLXiMqzDq3dZrfl39nnxGXPtXxYCcChmFxYviUc0XQSDwZO5bV6yQiCQIBY1wC9khYmgpxDvHhSmQXyW5HlNiuqEg6DeFv6SnupxWtIop03wkLLxpsjq7rHDViu+dljJEXF4vDKkZ+Vnmhe5h4UqetLsCCAnvLi8myIvS2S2f7gkbrL75uPLeDb7xrA194y1mcZ/EihlXzxAX40ZEJhkKzkwQRjiW4b6e4gFMR8vZmeUuQ9QsaSKZ0fvPC0YyPkTf8rXWFR8jaiQUXLeAtP34LaPDc/z7HY//+GKG+EH+4/Q8AXPqZS80V0wpnkq3YLiPkq5urcWVbsqhQOIDbbruNu+66i7vvvptgMEhvby+9vb1EIuIaXwrtoVCI733ve4yOjpqPSSbFRPk111zDmjVruOWWW9ixYwf3338///RP/8Rtt92W0b2umD2q/ULYsko8C5visj0Fs1q/mJC3YjziyRSJlBDdqmy0aE/TNOoM4XBswvr7dDsdI9IcMFiEJL5kSjeTD2r85T8WALVSUJ4owiIMQ1ittqmwKhcipPR0okU+2On9MRUul0bQqOwbKUBslwsw7DwWp9Jq1LUcH4tm9fiBcXHuqfa5bb0AAyBQHyAWMxYMRC00qcUjU4qrMWP8Tq2LKye8RjVSaiJ/AdEU2x0gMpv4gxA7/f58yZVi0W/ng2mxPWbMkVYHjW/4aou+e8VmSrG9Vortx7N6nXg4bjrb8dtcbG80xPaUdYa8ckPNMikqkk4jQnRx88li+/IWQ2xXznaT4XCcqLEKs7X+9Ik0efM6ElEx8rPJdqOv/bwlTZZ38FnJMmNBy4ET1n2QHh4qjrNd8oaz27np/IWWv25dwMtCw+k/W1Hyf3ypl/FogoVN1Zy/pDwTEBTZ87aNYsHEPc/1ZHRbyBj51gpytktWv2U11371WgC2/eM2fnjlDwn3h2k9u5VL/9FefbOK3KltF9dv2YrtKkJeUWl8+9vfZmRkhMsuu4x58+aZ//3sZz8D4Pnnn+fpp59m165dLF++/KTH9PT0AOB2u7nvvvtwu91s2rSJd7/73bznPe/hc5/7XCl/NQVpgUi6jQtFCkVVFkePzxa1hugZskBsn5wWYDenvxTKRosqtpf/MdJUI80B1s9XhCa95+zi3A1auBjlVOzubK/2uZFTK4UsRpBCfb7R6+VCfVXh5xB5rrDL+yMbWoyF7dk62wdC4h7d7q52EOJhKuUmhQ9iFs6bx0Lgm0JsN0TYcna2exuEAKrHQuip/FIx4uG4iFCfYhxsSQZnO8CSK4TYfujhQySN86V0tgdqjesun/3v16cU2z1+qGqC8d6sXiceieOXjn9/cPoHlzmBBrFgx4Nzne3O+bRTKHJgyhj5ViNG/sQ4uq6XtYg5W8i+9jm1Pvye028WpNherFg2RWa2d4le8XIXUJcWxdkuxXb7XYSe2V5H92CYV46OcvHyOUXf3i+eExHybz23Q53PHMD169r53O9eYe/xcXYeHmHdgoaTfn7cdLZXntgOcMFHL2Dk0AhPfulJTuw6gebWRHy8TSf8FNmTjbN9pGeEl37yEqDEdseQTEDPU7DoYlCfcdMyUxzuZZddllVk7qJFi9iyZYtVu6WwiBqfjD62Nkberk5E6dwds0BMlBHybpeG122v80xdlRiH0SI4mOVCBjscI41GjPxgEZLF5Dh4XBp+jz28TDUWJ2FMxk6LMDKhaRq1fg9jEwnGowla8nydiAOc7ZAW2wtyttvoXJEtrUEZI5+ds73fcGbPqbV/CpDfMGAlqMIXtdBAEg+DN/P9mRkvXs7O9gZRGen1JIiFYviDuf+thbM9geZ30H3qFGJ72/o2Ao0BJoYmOPrsURZsWpB2ttcKs58THP5Tiu0Awbacne2JlA+Pu3wXnWRDoCFAf9SHW8tusZIdscfVoEJhIbqu09UvVtCcGiO/ZE4NLk1cTPZlGQnkdHpHhbDZVp9ZvGkwbl5VZ/vsItMX1nXUl3hPpqcYMfI9Rox8RxnH50/FmnlixevLR0eKvq2ewTBPHBhA00Q8vsL+1AW8XLtWxKHLhRSTkVF2LXnc3DmFq//jatbetBaA1/7La5l3zrwS75FiNpBi+/jRkz9r4pE4u36yix9d8yO+sugrvPC9FwCYu3burO/jjETH4cSrpd4L+5BKwW9vhztfD52PlHpvFIqSUmOhkxvSQpFdYrFPxeyktkBklg7Vaq/bdgtXpYO5kL7lTCRTupl8Zwe3aqPhhhwqQu2dfM/V+D22OT5qLeolz4Td+uszESyw0z6RTBFLiveHnaonMiEX7BQitpvOdpsuwMiEXNh+fCxLZ7shtjfX2P8eXYqHiWTAuhj5ZAKSMfBmnt+TIqyvjJMBPLVins/rjRPNchHGqcgYeWeJ7XUZxXbNpbHkciNK3uhtN53t1UkhtLvsL1nKxSkZxfba1pw72xO6/ebAT0U6230eJbYrFI6hbzzKeDSBS4MFTSevlAp43SwyouX3nVBR8gBHjQ+FtrrMJ/UGudq1CLFsisykUrq5Mr8lWN4OVhkjf2Q4wkQBvWeSsYk4w8ZEiR2d7WvaxUX4bMTI//J5IcZevGwO8xvsf1GmELzVWDjxmxePnPaeOlHhznYQN25v+fFb+Ouuv+a1//LaUu+OYpaY7GzXdZ3DTx/mvg/fx5fmfYlfvetXHNx6EHRYfNli3vSDN/G6L72uxHt8CtEx+OEb4X8uhbHs4uQqGl2HLX8LO34Kbh/0bC/1HikUJUUKnlaJ7eG43WPkrRsP6fK3W4Q8pIWyMYud7ZPrCuzgVpXO9qEiONtlmoSdxGW5CEPXT65JsAKzn9umC3Wg8E77yV3vdjxvTMaMkY/kfw4xne02PiZOZa4ZI5+ts108bk4Zi8XZIsXDWNJvXYx83IiTniI+XYqw5Rwjrxn77vUm8hLbU4kUyVgSny+OVmX/rnITX21GsR1O722Xiyr81UlHRMhDenFKdCTDMRFsg/Esne0R4WxPavabAz+VqsYqolEfXk8078qFcsc+V4QKhUV09om+zvmNVRlj0Ve01NLZH2Lf8bFZiXkud3qNGPl5Uzrbi7dSXJGZ0Yk4CeNDqamMo5RA7F9DtZfhcJzO/hCrDWd3vhwZFkkLjdVeW01qSM5sF0kEB/pCTMSTRetxS6V00/kse74VzuCiZXNorw9wdGSCra8c5/p17ebPKj1GXqJpGg2LGkq9G4pZpG6++Gzp393Pt878Fv2v9ps/q19Uz7r3rmP9e9fTuLSxVLs4NfEJ+MlN0LcH3F54/ofw2r8r9V6VL7oOW/8Znv0e3PB1ePleOPxMqfdKoSgpMrI5ZFGMvN0jkGsLdKZORi5stKNoVqzOdinQujRsEZ1uiu3F6Gw3ne32OT4CXhdul0YypTMeTViaThCO2t/FLMcj3xoKef7UbPL+mI66QOEx8mGbf55kwoyRz9rZ7qzOdoBYzD+liJozUmyfIkbedLaX89ynEXnu88UzC6szEDfeY15vHJeTxPYpYuQhLbb3PNFDPBInbmgK/kDCcWL7lDHyh57I6nVEjHyMpGb/cQk0BIhGffj9MWJjUfxTaE12xt6f/ApFHnQNCLF9cXPmk9SKVvHBtlc524F0Z/tMMfKReNIS57JiZmTnU13Ag6/Mb+A0TbM0Sv7woH372gFa6/w01fhIpnT29Fp0c5KBpzsHOTwUIej3cM2atqJtRzH7uF2aWQtwz6Qo+WgiaS56aq2zf0SdQpEL0tkeG4/R/2o/nioPZ7/7bN7z4Hv464N/zeWfvbw8hfZkHO55Lxx+Fm7+OZz9dnj2+yJOUZGZh/8Dnvg6XPvvcM57oOM8IbZbHIWrUNiJWkPom+w4LgQ7u7khLZZZIbZLociOcdBSKLPe2Z4WVO0QnS4XpxdDbB+fFCNvF2QvOVh/bJjOdpueO6DwGgo7V0+ciiWd7eYxYZ/3yEy0GPfa/eMx4kZlwHT0hxwUI18vxXavdTHypth+ehpjKpkiaSziKWdnO24vyZQrb2e7FJq93gSuKvsLqibTiO3NZzQTbA+SjCaF4B6SYntcOOIdwGSx/bTallrD2Z7FPWwikhBiu8v+x4Yn4CGeCqBpMNE/WOrdKQrlrdIoFEXgYL8Q25fOmUJsbxETtvuPK7Ed0p3t7Q2Zxfag34PLuIewug9OkRkZIT+n1h4X6/K9duBEqODXMvvaG+0Zi65pmtnbXswo+Xue6wHgDevabTtRqpgaGSX/2L4+M31Extj5PC5zYkShqBRqWms454PnsPiyxbzhO2/gk8c+yZt/9GaWXLEEzVWmE52pJPzqQ3BgG7zzLlh0EWy8FcaOwp4tpd678uSJb8Cf/w2u+Ce48CPiex3nQ2QQBg+Wdt8UihIiRQwrxGWwvxOx0BjoyUiXqh2vp4PGOFh9j263WGiZxDcYKl5nu90S16xMf5AkUzoTcSE82mnxwakEA4WNjblAxwHicp0ZI5//eyfiwM72pmofHuP+QkbET4cTne0TER/ELDKPxGSM/Olz9PFJ5+2ydrYDyZQv7852Kbb7fHE0h7i6gWnFdk3TToqSNxMMfHEzKcDuyPdLKpEy/8YmwVZITMDE8IyvI8T2KCm3M44N3SsWU0T7+kq8J8VBie2KikPGyC+ZSmw3ne1jp688qkBMZ/sUne0ul2YKOypKfnaw28X6shYLne1DYvHHgib7XnydKXvbjxZHbB+PJvjDLtH5qyLkncmi5hrOX9xESodfPi/c7ekIeb/tXRQKRa5omsb137me9z70Xs794Lmm66Js0XX43V/DK7+Bt94By68S3593Niy4AJ75bmn3r1h0Pw0/fht84zzY/v9EhH62PPt9eOAzcMnfwKV/m/7+/HPE18PPWruvCoWNkMKZVf3Ldo+RD1ooJJouVRuOhRTKiuVst4tTVTrbh4sZI2+TsZAELVyQIpmcrGHH94uk0IUIEbN6wv7T7XVWOtttsjgnG1wujZagML4cz0JYHTCSKefaxCwzHbKzfSLsKUKM/OlzfFKA1Vwa7jI/hhIpf4HOdh2v1zlCM5AW26fQVpZcYYjt2zrNhRU+b8wxMfLeai8uI432tCj5WiOBdGzm3nYZI697g1bvYknQ/OL3iA8qZ7tC4QjMGPkpxPZlc2vRNBgOx8247kpF13WODU/f2Q7pHrRi3MAqTkfGUJV7X7vE0hh5mzvbAdYYYvvLR0eK8vq/33mUSDzJsrk1bFjQUJRtKErPW42FFL947jC6rps3+m0V3teuUJQ9ug73/yO88CN407dg9fUn//y8v4DOh6Fvb2n2z2p0HQ4+DHe+Ae64Boa7oWU1/OHv4Gvr4alvpx0tU7HjZ3Df38D5H4Ir/z9RhCqpboLmFaq3XVHRSBHDame7XZ2ZKkZeYDrbLe9st1dUuJyrkOlwVjIuO8pt5uROv0esOzbke8Xt0mzdVV7rL2yRirlYyWuvYyIT0lRTyDkkHHWesx1grnHPfWJ05oWj/aZZxv5iu3TqhsfdsxIjLwVYb4237A0FKfz5O9tDcdzuJC6X7hihGQB/HaTikMg8JtLZfvSZo4wdFYs3PN64Y8ZA07Spe9uDhtg+3jvj68QjcQKBqOkItztalZgTjw8PlXhPioN9r4AUijxIpXS6BsQH+dI5mU9SAa+bhYZrdt+J4nUq24HRSMJcmTtVZztAvRHNNqxi5GeFAZtdrC+bKy6UDvaFSKUKS4uQznY7i+3S2b67d4xkgeORiftfFisjbzy3o+xvSBT58/qz5lHtc9PZH+L57iHT2d6ixHaForz58xfgqW/B5v+Cde88/edr3gjVc+DZ783+vlmJrsPe++F7V8MPb4DoKLz9R/CRJ+HtP4TbnoGll8P9n4Gvng2PfzXzpN2rv4NffwTW3wzXfvFkoV0ie9sVigpFOjFDVontkzqH7YiVEdkRGy88mI3OdjvQaCxQjyZS5t/TKqRYXVvmjstTSb9HrBsPs17AZ++ucllDke/5VL4/AjZZjDId6c72/M8hIZstzsmWVulsH5teWE0kU2YCqF2SKadDpodFxtzoMYvE9mli5M1ocRsYjVJaAWJ7OC5c7ZBx0YFtMRzMU6Ug1C+op2lFE3pKZ/8f9gPgdccc09kO6TSI6Mgpx4UU28eyENuls91fZ/XulQRXdT0AiVEltisUtufoSIRYIoXXrTF/GrFuhRF7vf9EZfe2HzP62hurvQSmmWxpkBfhKkZ+VpAxVHNscMEJIvLd69aIxJP0ZrHydzp6BqWz3b7RSkvm1BLwugjHkmbShpW8anTBn7+4yfLXVpQPNX4Pm8+aB8A9zx7m+JgRIx9UYrtCUbY8/jV4+Itw1f+B8z+Y+TEeP5zzHnjxbohZ/xlRdFIpEY//v5fC3W8HzQU3/wI+9DCsuQFcxu3nnOXw5m/DR5+DldfBg/8KXzkLHvlPmDCSX/b9Ce55v3jeDV9LP/dUOjbC8ZdmdsgrFA5Fip4hi4TEcNTe4oiViw/MSGiv/abO6orc2W6XHvsanxufW/z9Bi1O4gvZ1Nlea8bIW+9st8sijKkotIYiYvPFSpMp9BySTOlMxFOA/d4jM9FSJwS0mZzt8pyjaemUDTuT7mz3woRFtYjTxcgbc5/eGq812yoiKVcArzfBxEjuc57xcByfzzjneJ3h6gbAb4jm0amPFRklP3RQCK8e1wT47DvfeypTOtu9VeCvz0psF53tMTN+3e64aoXYnhwtTtprqbHfHYNCUQCd/WLScmFTNW7X1KttV7SKE9je45XtbJd97fPqp19ZJy8ah1SM/KwwELKXs93rdrGoWVwwFhIlPxKJM2o4M+Y32He1p9ulsbKtOL3tI+G4+b49o80ZF2KKqXnruSJK/r6dx+gyPt9a6+xxXlAoKo5n74Ct/wyXflL0jk/HxvdDbBx23TM7+2YFEyPw4k/gWxfCz98DVU3w3vvgA/fDiqszO9IBmpbADV+Hj70Aa98CD/+HEN3/8Gn42c2w/Ep483fANc2kdcd5kErAsR3F+d0UijJHxshb5mw33dz2FIukkGiFoztis37yyRSrs12KiTU2cXNrmkaDkcQ3ZHGUvBRk5TFnFwoVlDNhOtttclxMRaHnj0jMXotRpsOMkc9TbJeVE2DfxVtTIRe4n5jBxSyNMk3VvmnnoO2Ct8aL5taIRn1o8ZBYZFsoWcTI28HZjqfKGme7g4TmmZztkI6Sl3hcUcfEyMM0YjtAsBXGs+hsj0Tx+6NoVfVW715J8NQ1AJAKD5d0P4qFEtsVFYUU25dMESEvkc72fccr29nea4rt0zslyylG/n8fPsDb//dJsxfJifQbF+x2iqFaOscQ2wtIizhiRMg31/hsvzJaRsm/csxasX2PsUBofkOVGR2pcC4XLGliYVM149EED756AoBWFSOvUJQfO38O930Czv9LuOKfZ358w0I441p45rsijr0cSaXg6IvwyH/BHdfBF5fArz8MjYvh1q3w3t/CkkunFtlPpWEBvP5L8Nc7YN274Lk7YcEF8LYfgGeG652WNcINo6LkFRWKdHKHLRLO0mKqPa+3TWd7rPDxsPPCg2J1tks3t50WIDTVFMccIAXmWpu9V+T+jlkotsv3it3G4lQK7bOP2PiccSpSbB+LJvKqv5PHhNul4fc4S36Q99zPdw+x8/Aw+hTX62YqpU2MMjOhaRqB+gCxmHFtHrcghSsWBk8g48JaM0beBnOfuqcKrzdBbDT3zxnnxsgbsefTVA4svmzxSf92M+GoGPnpxfa2rJztxMJoGmjVzhDbfQ1BEgk3etiZBld7XwUpFDmSFtunXym2okWsvqr4GPlhIW5O19cO0FAlLnyGSxwjf7BvnP+4fw/JlM53H+3k769bVdL9KRaDxgVnc419LtiXtdTCK8c50Jf/xfjhIRkhb/+LzzXzxEXnyxY723f3itdbqVztFYGmabz13A6+vHUvCWMCpEU52xWK8uLAQ3Dvh2H9u+Daf89efD7vVrjrRujZDgsvKO4+ZkuoHw5sg/1/El9DfWIyZMlrYfN/Chd64+LCtlHXDtf9O1z+j0JAd2dxu+r2QPs5SmxXVCxS9LTKpSrdiFU2jUE2+6itcLabMfL2Gwu58DYcS5JIpvC4rRG7wjbsYJbO9sEiOdvtFp2ejpG3Tmwft3n9hKRQ13/YSTHyVenF+6OROI05uovNtAOvGy3b61+bsKLVMGidGOeGbzzOqrYgb9+4gDdvmH/SOEkTkJ2MMjPhr/cTjRrHRnQs7V7Ol3goY4S8+JGYY7ZDjDy+arzeBNH+/JztPp8U253j6s7G2V4zt4bWda0c3yEc3kJsd84YTCu217bByOEZX8OdEvPoWo0zxPZAQ4Bonw89Zu18eLngrKVlCsUMZOtsX95Si6bBQCjGgIMd0jNxLEtne6Nx4TNc4hj5L2/da664/cn27pNiq5zEgA0v2JfNFe+5QmLkewxnu5372iVr2osTI7+7V1zEKrG9crjx3I6TtDvlbFcoyoj+fXDPe2HpZXD9NJ3jmVh6BTQuEe72UvPiT+A7l8F/LodffRBOvALrbxYx8X/XCTfdLRYHFCq0TyZQl53QLunYCIeftW77CoWNMJ3tseSU7rpsSU3q2LWraGYKiVZ0tttQWJZMjja3Mko+bMNofelst9ocIMVEu6VA1BYhRl7Ovdht4cGpFLoQYcJBznav22We+/JJyDDPFTavFsjEhoWN/OxDF/LG9e34PC52947xufte4YJ/e5Dbfvw8D+/tI5nSJ4ntzlkQH2gIEI0av0/UAoNaPDKl2G46220QI6/5qguMkTfOORUWIw/p3nbQcaUilSO2B1thfGZnu8sQ2901DVbuWskINIh0DM2K80cZosR2RUXRZYrt05+4q3xu0z27r4Ld7b2j2XW2y3ipUjrbXzoywn07jwEwp9bHSCTOL58/UrL9KRaJZIohY5ybbXDBKVk2t/DOdic521e31eHSxErnE2MZLrryZI8htq9SYnvFML+hiouWNZv/VmK7QlEmhAfh7neIFetv+35uwjEIYf68W+GVX8N4X1F2MWse/nfx9U3fgk/ugQ8/Bld/VsTEzxTxPlt0nAdjR2HEedd+CsVMSCEjkdKJJgrrT5VObrCXmDoZKXzGkzrRRHKGR0+PFIsCNnSpet0u05FvrdguRVX7jElDtfisstrZLiP17RadHiyCs92sF7DZWJxKoQsR7Fw9kQk51zeSR2WkHAu7L8CYiguWNvPVd27gmX+8in9945msnV9HLJni97uO8d47tnPpF7dx7wviutROc3czcVKMfMyCGOhYeEqB2U7Odi1QY01n+xQLD2yJJwAuD0SnNxnJ3naPJ4FGylHu/hmd7WMzd7a7dUNsr2u0dN9KRaAxQDTqQ0tYUENRhiixXVExxBIp0xk7k9gO6Sj5Shbbs3W2y5vXUna2/+f9ewB44/p2brt8OQDff6yTVB7dUuXMoJEe4NLS424HlhrO9uOj0bxvXA9LZ3uT/S8+q3xu8zxkVZS8ruvsVc72iuRt5y4AxKSn3Sb7FApHkozDz98DkSF4108hkGfk2/qbQXPBCz+0dv9yIZUUAvb6m0UUfrCtdPsyHR0bxdfD20u7HwpFCZgsZEhxI1/k8zUNAl57ThdNHo9CxUS5+MCOznaAuirre9ulqGonMbFJzldYnMRnxsjbzLlbU1Rnu73G4lQKFtttXD2RCVlHkY/YHpLJIDZ7f+RKfbWXWzYt5r6PXsrvP3YJ77toMfVVXo6OTJhzPXNslEo5E8LZPilGvlCmiZGXznY7iO2uqhq83gQTI7mbaU6Okbf/fKeJponKsRmOk0WvWYTm1ia5+50jtvvrRQpEdCTDIoxgmzj+pxmfVCKFzy2OKXewoRi7OOuIc4jPdOw7DXvePSkUedAzFCaZ0qnyumnNotNWdvDsP27BxYMN0XU9h8720sbIP3VwgIf39uFxaXzi6jN428YFBP0eDvaH+PPeEyXZp2IxMC7GuKnGh9tln96r+iovc4PifXcwT3e7KbY7wNkOsKZdiC9WRckfGY4wFk3gdWssnaEqQ+EsrjurjbdsmM/Hrzqj1LuiUCh0Hbb8LXQ/Be+4C5qW5v9a1U2w9q3w7PeF6F0KxnohFYf6BaXZfrYE26B+oYqSV1QkbpdmCjuhAsWzSCwtFNm1Y9ft0kzBTwrD+TJ5POxI0BDKrBTbTbeqjRZ4yg7lQatj5A0x0W6LXYsRIx+yYb1AJqTrfyKeIp7MPSlkImbvBTqnIp3to5Hcj5Vw1BnHRC6c2V7P/7nhTJ7+xyv5+k0buHTFHOY3VHHVmtZS75pliM52i2PkpxBXpbPdDjHy7upgwc52XXeBxzmVAwD462YU2/1BP+d88BxaVxvHgYPE9ulj5I1F7GNTR8nHI3H8fnFMeeqbp3ycnZBiu1sPl3pXioIS2xUVw+QI+WwmDqSzfe/xynS2j0UT5g3TTGJ7Y3VxOtCyQdd1/uOPuwF45/kLWNRcQ63fwzvPF5PC33usc9b3qZhIsb25xn4XYEvn5B8lr+s6hwfFB/ECh4jtZ8re9mPWiO0yQn7Z3Fp8HvXxXkn4PW6+/I71fPA1BYh6CoXCGp7+H3juTnjDl2HxxYW/3nm3wkgP7Hug8NfKh5Ee8bVhYWm2nwsLzoPDz5R6LxSKkiCdtYWKZ+G4fTvKJyOF4LFoYfen0tluJxf3ZOoM4TAfoWwqwjbssW+sFoLhkOUx8vbsbDdj5K10ttvU5X8qk/+W+SxeCtt8gc6pyHSMQpztdk87yIeA183169r50a0X8PjfX8GqtrpS75JliL5lw2kes2C+PBYCb+Y5Pjs52901QbzeBNHRKLqeW8Kq7GxPan7hBncS/mBWizLe8O038N4tN4p/+JxjHpoxRh6mFdsTkQR+fwxdB09dnml5ZYbsbPdokVLvSlFQs/GKiqEzy752yYoWcXKv1Bj5XiP6pr7KO+NK1Hrj5jUSTzIRn13n1YOvnuD57mECXhcfu2KF+f33XrQYlwaP7x/gVYvEzHJgICRWtDXbMIZqmfGeOnAi96iY0UiCMeNmd36DM2KV1swzxHaLnO27VYS8QqEoB1Ip6HxUOLtznGiwPfu2wv3/CJtuh3PeY81rzj8H5p8Lz3zXmtfLlWEptpe5sx1Eb/vRFyFRmqQlhaKUSIFICqH54pS+4VqLOqkjNnfrSmf7mJUx8jYcE+lsH7IwiS+aSBJPiuscu4nttX5xXFja2W7D4yITXrfLrNAYy2N80gt07D0OkrpCOtujMkbeGWOhEPjr/SSTHlK626IY+fCU0el2crZ7gkERBa+n9ztb4iERI5/Spje62RJ/MPvjJGbMFfucMecLMznbjcSL8al72+OROIFAlGjMh+a297W5pKqximjUh9c9QSqRe4JMuaPEdkXFkKvYvtwQBvvHo5avgLYD2fa1AwT9HmSieT4X4fmSTOlmV/v7LlpCS116Xzsaq7lu7TwA7nCQu31yjLzdWGb0tufjbO8ZEq72ObV+20/+SdYYzvaugZAlrgIltisUipIycgQe/k/42nr4wRvgjtfBna+Hgw9Xhuh+4lW45/2w4hq4+nPWvvZ5fwH7/wQDB6x93WwYPgRVjWKipNzpOA+SUTi+q9R7olDMOlLgGi8wNt2M/fXaWxyRMdmhAhcfRGzevyyFslELRVXTwWyjezKZxGflvM7kigI7jQWkF6OMFaOz3ebOdigsZt/u1ROnYsbI57FgRy7AsNv7QzE9UjyMp6osEttnjpG3g7PdVV2Dx5NE01I5R8nLGPmUy6lie5YGI5mUUCkx8v6gcPGPHZvy+fFwHL8/Rixmv3TbqRBVFD78/lhetQvljhLbFRWDFNsXZym21/g9zG8QUTaV6G7vHRFxHtmI7S6XRkMJouR/u+MIe46PURfw8JHXLjvt5x+4ZAkAv3nxKH1jzjiBS2f7nFr7fdAum5t/jLzT+tpB/A1b6/zoOuy2IH1hT694jVVKbFcoFLNFMg6v/g5+/Hb4ylp47Muw+BJ4/x/hpp+J1ek/vAG+v9nZonuoH+5+h3B/3/hdcFk8qXjmm4Xg/ewd1r5uNoz0lH9fu6TtLHD7VG+7oiKpNQSucKEx8oZgZvfFrVIsy8eZOhm7O/1lXLiVznY5JnZyqzZJsd3CuQoZMR7wuvC47TW1Kt8fsUSKaMKaZEK5+KDGAY7ugsT2uLM62+sCBTjbzcoJ+x8TijQBY444nvAXP0beMBvZwdmuGe58jyeRt9iuu50z32mSi7M9bnR4OzRGPmO9QG1rFjHyUWIJ5yzEcHvdJPQAfn8s8yIEm2OvK0KFogBydbYDrGiVUfIWrNazGUeNE15bfXYf9g3GitdhC6PZpiOWSPHlrXsB+MvXLjOj7CdzzsIG1i1oIJZM8eOnD83KfhWbdGd7+V9snop0tnf1h0mmchNcDhvOdieJ7TApSr5AsT2WSHGwT5zjVjqoD0yhUJQp/fvggX+GL6+Gn70bQn3w+i/DJ/fAm74FizbBymvhQ3+Gd/0cEhFDdL8ODv7ZWaJ7IirGIBaCm35aHAe4two2vBteuEu4P2aT4W579LUDePwwb53qbVdUJGlnuzVObrsLRTLWO1Sg0z9ic7FdCmUV39leY33tnXyv1dpo0YGk9qRecqvEdgc52wuooXDKgiWJ6WzPp7M96ozPE8XJ+OuF8ScW8xU9Rl52tvvsUKNpuLG93gQTI7kJiPGwiJF3pthem0eMvIOc7cbilGQsSSLTZ0qwbfoYecPZHneQ2A6Qctfg88WIDDmvt12J7YqKIBJLmrHoS3MQ289oFROm+46Xr7N9T+8Yl//Xn/nfh62NFu3NIUYe0r3tw7MUI//TZ7rpGYwwN+jn/RcvzvgYTdO41XC33/XUoVnvky8G/VJst6GzfX5DFX6Pi1gyZYrn2ZJ2tjunuwfgzPZ6oPDe9gN94yRSOsGAh/Ys37MKhUKRMyNHhEv9GxvhhR/B2hvhw4/Dhx6Cje+HwCmLfTQNzngdfPAhQ3SfgB++Ee64Fg48ZH/RXdfhvk/AkefgnT+GxkXF29bGD8DECLz0y+JtIxPDPfYR20FEySuxXVGB1Jqd7QXGyDukdzloOlPzvzdNJFPEkqJLstqmkdDFcLanu7ntMya1fg8eo/fOqt72tLhsv/eK26WZMedW9bY7pbMdJiVjqBh5U2wvxNlux/eIYmqkUzca9UHUgrlyh8TIS3e+1xvP09memHLRga3x1+Ugto8DGnicM6fpq/WhGdcf0ZEMx0WwbVpnezwSx++PitoGB6F7avH740zkqA3YASW2KyqCrgGxOqq+yktjDo5g2dtezs72rz64l87+EF/4w25+ur3bstc9Niqd7dl9yDWaMfLFd7aHYwm+9uB+AD52xfJpb+iuW9vGvPoA/eMxfrvjaNH3rdjIGPlmO6zsPAWXSzOTJXKNkpfi/IImZ11gyN72lwsU2/cYfe2r2oJomlbwfikUCkVGnvwGnHgFbvwefGI3XPdFaFs78/NOEt3vgWQMfvQm0es+3FP03S4KqSQ89H/hxbvghq/DwguLu72mpbD8Knjmu8XdzmR03V4x8gAdG2GoC8b7Sr0nCsWsIoXPQp3tYRsKqZkoxJkqiUxaqG1Xl2pdAX3LmUgkU8QSYgGCneLCNU0z54EGLeptHze76+0zDpMx3yMW9bY7q7NdvG9CKkY+fQ7JS2x31lgoBNKpOxHxQsyCufLpYuRD9omRl0K5z5ev2B53qNgezL5uIBYSEfIOmtPUXJqZBpExMr12erFdxMjHSDhMbJdpgLHBoRLviPUosV1REeQTIQ+wQortZeps7xkM88eX0iflz/z6JR7ac8KS15ad7e05x8gX39n+/ce76B+PsrCpmnecN73byut28d6LFgNwx2OdmTtSbISMkZ9jQ7EdYJnxnjpwIpTT85zqbJcx8nuOjxE3nDP5sNsQ21eqvnaFQlEsElHY8VNYfzOc9Vbw5rHiXNPgjGvgg9vg5l/AYCc8/O/W72ux6dsjFgo88l9wxT/BunfOznbP+ws4+oJw0s8GoT6RRmA3ZzvAEdXbrqgs0rHpBcbI2zAiPBM1prM9f6e/FM00Dfwee06d1ZnOdosEVRsvQGg0kviGQtbMV8iIbDvGyMPk9AeLnO1R5zjbgwXFyItxCDjM2T5awFjYdUGKIjNmB3XYY2GMvJOc7fl3tuN3Tny6SS6d7bGwoyLkJZN7208j2DpjjHwgECWBs+bCtYCYu44PDZZ4T6zHnncMCkWOSLE9lwh5gBVGjPyJsSgjsyAi58oPnugipcPFy5u58ZwOkimd2378PLsOjxT82seGc3O2z1aM/HA4xv8YkfmfuPoMfFlMfNx03kKqvG52947xxIGBou5fsZEr8Ztr7BcjD+ne9lyc7bqu0zPozM72hU3V1Po9J3Wu58OeXuGMV33tCoWiaOzZApFBOOc9hb+WpsGKq2HTbbDz5zBuzULBopOMw6Nfgv+5BCJD8P4/wGs+NXvbX3E11C+EF++ene3J1IEGGznb6xdAbauKkldUHFbHyNtNSD2VWgti5GUcdLXXbdvkKLOz3SJne9gQVN0uzXYLEGQSn/Ux8vZ8r6Sd7RYdGzF7O/0nk2+MfCqlEzWSH+y+YElSSIy8fI9U2/Q9osiMdOlGQh70QmPkkwmReOabobPdRs72fGPkfb442hTjYGuksz2VxfVpbLzyxPbaNoiOioUGGRAx8jGSmrPGRasWlaqJEeVsVyhsiRTbF+cottf60/3H5RYlPx5N8LNnxCToX1yylC+85SwuXTGHcCzJ++98xhQn82FsIm7eWJRbjPz/PHyQsYkEq9qC3LCuPavn1Fd7edvGDgC+91hnMXevqEzEk+bK8ya7Otvn5h4jPxyOmx1w8xucJba7XBqr54lFPS8fzX+RzO5JMfIKhUJRFJ7/EXScD3NXWvea574XXJ7ZjUbPl95d8N0rYdvn4cKPwIcfg0WbZncfXG6xzWM7Z2d7w4fEVzvFyGua6m1XVCRSzFAx8oJa0+lfuLPdzgsPglY72yclH9htAYLVYvuYjTvbYZKgbMGxkUrp6XOHA4RVMxkjx7FxQvXEqdRVibEYicRzTolUznZnImPkYzEfeqSwOkTixrz1FDHy9nK2S7E9f2e7Fqgtxp6VFiMuPKso+VhoyoUXdmZ6Z3ub+DqeOUpexsgnNWeNi6tGGMWSo8Ol3ZEioMR2RUXQlWeMPMByw92+70R5Rcn//JkexqIJls6t4bVnzMXncfGtm89h9bw6+sejvPf72xnKs4/suNHXHgx4so5Fa6gufoz88dEJ7nxCiOWfet1KXK7sb/Dff/ESNA227T6Rc194uTAgV3W6XWbsm92QzvZcXNwyQr4l6HdMHNtkZJT8K3n2to+E4xwbEe/ZM1qV2K5QKIrAcA8c2Abn3GLt61Y1woZ3C7E9HrH2ta0iEYOH/g2+c5lwtv/Fn+Dqz005KVR05q6Cvt2iT73YjPSALyj+TnaiYyMceT47B4VC4RDSzvZCY+SdEQWdrzN1Mk5w+RfSt5wJO4tnsrPduhh5cWzZNUa+1sIY+ckisx2PjVMJ5un6nzwOAY99zxuTkc725KQFFdkSckgtieJk3D43nioP0agXJgo0pZli++lz9alkioSx4MUeznYZIx8nOpK92K7ruiG2J3BVOVhszyZKXna2O4ysxPYpetvj4Th+f5SU21nj4qlrACAZKjyZudxQYruiIsi3sx3Ks7c9mdK584kuQIjIUnQOBrx8/33n0V4f4GBfiA/+8Fkm4rlPNErhLtu+dkhfhBdTbP/ag/uYiKc4d1EjV6xqyem5S+bUcKXxnDsf7yrC3hWfgXFxwdZc67Odk0Cy1HC2D4RiWS8GOTzkzAh5yZntIj7nlWP5ie17jouL1vb6gPk+VCgUCkt58W6xWv/MN1v/2hd8GMKDIk6+3DjyHHzntSI6/tK/hQ89DPPPLe0+tawWUXOjR4u/reEeESFvt2uOjvOEe6Jvd6n3RKGYNaQ4XkhHOaQ7uatsvsBVRmQX0mE/EbP/WEx2tufqSs2EGQttQ/GsyXBGWh0jb1uxvYBe8lORoqqmQcBr/2nmfBciRCadM3IxhpQzVV43Xrf4XXKNkpe1E3ZNf1BMTaAhQDTqz86tPB1SbM/gZo5Pmlt2srPdXFDgi+OqdpagCoiF2wATWcx3xkPOjJGvny5GvlV8nVJsn8DnS5DyOGtcPPVNAOhhJbYrFLZjJBI3HcG5xsgDnNFqiO1lFCP/p1eP0z0Ypr7Ky43nzD/pZ231Ae78wPkEAx6ePTTE3/zsRVKp3G6spdiebYQ8QIPFsWyncmggZMbmf/raVXmJzR+4ZAkAv3jucNHj7ovBwLjR127TCHkQE4GymuFgf3YX5j2m2O6s2BzJmnbhbH/56Ghek2DpvnblalcoFEUglYIX74K1b06vTLeS5mWwcjM8+c3ZcWtnQyIGD/wzfPcqcHvhQ3+Gy/8BPGXw+Tt3lfja92rxtzXcDQ0Li78dq2nfAJpbRckrKopaI7o5XKBLNeIQJ2JtnjHQk0k72+0rFMnO9kRKP8l1my9yMYYdo8JljPxgnul/pzJu8xj5oIXOdlNU9XlsawqYTL4R+05IwzgVTdPM80iuYrtytjuXQH2AWMyHlggVdv8me6q9GcR2mUKigSdgg/Os24uOK+fOdjMq3+tQsb1xkaiN23f/zI+NOVNs9zf4AZgYySC2B+rBE4Dx4xmfq0eEGK17nTXf62kQyXl6oekYZYjlYvsjjzzC9ddfT3t7O5qm8etf/3rKx374wx9G0zS+8pWvnPT9wcFBbr75Zurq6mhoaODWW29lfLx8XMUKeyEj5FuC/rxWHS9vMWLky8jZLnvH33XBwowRf2e0BvnOLRvxuV384aVePv/73CZkjxmrreblILY3Vud3AZ4tv9txlERK59IVczh/SVNer7FpaTOr59URiSf5yfYei/ew+PRLZ3uNv8R7UhjLjLSIAyeyi5KXMfJOdbavaK3F53YxEolzIId4fYnsa1/ZVmf1rikUCgV0PixE1w3vKd42Nt0G/Xtg/4PF20Yu7PwpPPkNuOKf4S+2QdtZpd6jNA2LxITUiVlwbY/02KuvXeKrgdYzoUeJ7YrKIe1sL0w4kx3ndheLrIjITrv87etRqfa5cRsOWyu6uaWoaseaAas72+3ubK+xsLNdiqo1NlyEkQnT9Z+rs90hySCnUp9HHYWup2Pn7Xi+UEyPcLZ70Uil3en5EJ9abI8ZZiNfjU2SPTWNlBbI2dkuHPy6cLb7nSc0E2yDjR+AR/9bpNlNRyyUsVLA7kwbI69pYozGjmV8rmbE7+s+Z4ntgcZa4nF3dvUCNsPyu4ZQKMS6dev45je/Oe3j7r33Xp566ina29tP+9nNN9/Myy+/zNatW7nvvvt45JFH+NCHPmT1rioqBBkhn4+rHWC5IQz2jk4wOlG8iPRseenICNs7B/G4NN67afGUj9u0rJn/evs6AO54vJPvPnow6230jgpxMydne5W4eS1WjHxnv7gIuyBPoR3EqtwPXLwYgB880UU8mbJi12YNmdBgZ2c7pHvbD/Rlt4BFiu0LmpzpbPd73FywVBzXD+0+kfPz9xhi++p5zrr4UigUZcILP4I5Z8CC84u3jUUXwbz1QuAuB/r2QONiuPQT4C6zCUKXS/w9ThTZ2a7rhrPdhmI7iCh55WxXVBA1Zme7NTHydhdHaiwQ2yccIBRpmmZGyVvR225np2qjxTHy4zaPyLaiakESmuRsdwLS9Z/r2ISN94fdFyudSrAqd2NNNJEiaSRs2jEJQzE9/nq/iJEHiBZgTJsmRj5mzH/6bDT/qburcne2h+O43UnR2uVAoRmA13wKUgl47MvTP86hznYptkeHpzguattgLLOznagRv+93lrkq0CjSMVzx3A1n5Y7lYvt1113H5z//ed785qk7HY8cOcJHP/pRfvzjH+P1nty78eqrr/LHP/6R7373u1xwwQVccsklfP3rX+enP/0pR4/OQjehwnFIsX1pnmJ7fZWXtjpxYiwHd7t0tb/+7HkziuE3rGvnH64TcaOf//2r/H5n5pVSpyJj5HNxttcbzvZIPJlXT/xMdA+Kv+PC5sI+eG9Y386cWj+9oxNs2ZXdeJQLMvKuucY+F5uZWGb0tmcrtvcMOruzHeCKVS0AbMtRbNd13exsVzHyCoXCcsKD8Op9sOGW4vZ2axpsuh0OPgTHXynedrJlqEuI7eVKy+rix8hHhkQPox1j5EGI7f17IDJc6j1RKGaF2jzFoVORMfI1NheLgpOcqfl2lTtFODPFdgsczLKT2o6iqulsD1ljDghF7e3mtjJG3lyEYdOxOJV8++wnzMVKzhgHSX0eYntk0sKvaoc5/RVCPIzFDD2nkN72LGLkbdHXbqB7qvJytvt8xnvL69A5z9oWuOij8PR3YOTw1I9zuNie0dkOEGyF8cyd7Zp8fwUcJrY3BIhGfWhJ54nts36FnEqluOWWW/jUpz7FmWeeedrPn3zySRoaGti4caP5vauuugqXy8XTTz89pYgfjUaJRtMns9FRsfIjHo8Tj5fGjSy3W6rtKwQHjK71hU2BvP8Wy+bW0Ds6wZ5jw5zdXniHSr7HxvHRCX63Qyw6ee+FC7J6/vs3LeDwYIgfPd3D3/z8RRqr3Jy3uHHa5xwbFk7iubXerPexyq3jdmkkUzr9o2Fa67IX6rNB1gF01PsKek+5gHed38HXth3gq3/ay/r5Qdob7HFB02ckDjRUebIeg3I8Dy1qEsfGgRPjM+6XruscNjrb24LZH49249Llwtn+TNcgg2NhgoHsbiiODkcYm0jgcWksqPfnND7leGwoKhd1PJYnrhd/iktPkjjzrVDsv80Zr8cTnIf+xDdIvuGr5rdLcWx4BrtIdWwkVabHo6v5DFyv/pZELFa8RRADnXiBRE07epmOw7S0rRf7370dfenlWT2lHM5D6hyoyBcp7hQqnDmlc1guPkimdKKJFIE8xJ5IXKSg2T0SWvQtRyxJ6bOzs72pxuIY+Zi9Y+TzjUrPhJ3rBTJhdrbn7GwX45DP+aacMWPkc1h8IN8ffo8Lj9u+VRyKzPjr/QxEDROQdN7mw3Qx8qF0jLxt8BjO9pHcxHav1/h8zuDwdwwX3Q7PfBce+gK8aYo07FgIfM7rrZ9RbK9tg769GX+kJYSmpVXVF2XfSkWgIcBE1IdbL6CGokyZ9SuhL37xi3g8Hj72sY9l/Hlvby8tLS0nfc/j8dDU1ERvb+ZVHgBf+MIX+OxnP3va9x944AGqq0t7stq6dWtJt1/p7DjoBjQGunazZTQ/F5An5AJcPPD0S9Qc32nZvuV6bNzX7SKRcrE0qNOz43F6dmT3vHM0eLHRxa4h+Is7t/PXa5O0TfO26O4XY7bvxe2MZT7fZyTgchNKafzugW20W/i2iyahb1ycrvY8l/3vPRWtcajxuDnYH+a6rz7Cu5enOLMxP8fDbLK7SxyHRw7sZstYbsdyOZ2HRHKOh0MDIX573xY809x7jcchEhd/+51PPswrDr5Pawm4OTEBX7/nT6xvzu54fGlIA9zM9af40wN/zGu75XRsKBROPx5dqRgaOkmXv9S7MjO6zmV7vk0ouI5nHp6dOO7lwUtZtfNnPJi8kKj35BvKWTs2dJ3N/fvZ6zmT/Vu2zM42c6RlZJxNsRAP/eZHRHxzirKNecPPcj6w9dm9xHZMfQ9Wtug617lrOPDQT9i7O5LTU0t5HgqHnTfhoJgdpDgUTaRIJFN5ixsRB0SngxCDNU00YoxNJPIT220sLE9GOtut7Wy335g0GM72cEwk8RUqiI6bznZ7vldq/UJAtbSz3YbHRSZq/ScnY2TbF50+fzpjHCR1xjkkF2e7XHhg1/eHYnqkKxWwJkbeIc52fNX4fLnHyHu9xnnYqTHyAP4gvPbT8MdPw6bboHXN6Y+pWGf71J3troQwHmrVznO2j0R9eFwTJGNJ3A763JzVT73nnnuOr371qzz//PNZX6xkyz/8wz/wiU98wvz36OgoCxYs4JprrqGurjQHZDweZ+vWrVx99dWnxeUrZgdd1/nM8w8BCW685lJWtOS3Qmrs2cM8/JtXSNbMZfPmcwver3yOjUgsyf/50iNAnE+8fj2vO7M1p21edU2SW77/LC/2jPDDQ7X8/EMX0BI8fbI/FE0QeXIbAG97wzXmzXk2fGXvY3QOhDl744Wcvzj/bvVT2d07BtufpKHKy1tvuMaS17zw0jB//bOdvHR0lO/sdvOXly7h41cuK+tVt9859CQMj3H5RRu57Iy5WT2nHM9Duq7zHy9tIxRLsub817B8mvflzsMj8OzTtAb93PAGa/725coObQ93PHGI4ZoFbN68NqvndD98EHbv59zl89i8+eyctleOx4aicnH08ZiYQDuwDderv0bbez96y2qS78tvccyscuxFvC92U3P9v7N5xSydfyMX4fr6fVzd2E3qNZ8GSnBshAfxvjjBygtfxxmrNxd/e/kwchZ840tcsXYe+vKri7IJ1/Zu9J4qrrrhHcWtECgi7rFNrGSU5Zuz+zuWw3lIprMpFLkyOb45FEtSX5XfPU3YIWKRpmnU+jyMRROMRxPMzXDfOxMRIxLaGc52azrbzePDhgJaXcBjJvENh+O01Rf2d5Ux8rZ1tlsYIx+Oyhh5e47FqUjXv66LYz5bwTji8Bj5XM4h8v3htLFQCAL1om8ZKDxG3hMA1+nXLHZ0tmuBajyeIaKj0awX6lREjLzk3PfBU9+EBz8H7/rpyT9LpSAecqS7P1Cfhdg+MQzxCfCenBLsTo6TTLrw1DjL8R+oDxCN+fH7Y0wMT1DT4pxFFrN6JfToo49y4sQJFi5Md/8lk0k++clP8pWvfIWuri7a2to4ceLkztpEIsHg4CBtbW1Tvrbf78fvP/0Gyuv1lnzSthz2wWl0D4QJxxOsapt+IUXfWJTxaAJNg2WtdXg9+V3orZon3FUH+kKW/i1zOTbuef4YQ+E4HY1VXHf2fNyu3CY+vV4vd7zvfG789hN09of40F0v8LO/3HTazeGAsB1T6/fQFMztg76xxkfnQJixqG7pOB0xIngWzamx7HWXtdbzy7+6iH/7/av84MlD/O+jnbxweISv37TB8gh8qxg0Vna21lfnPA7ldh5a1lLLzsMjdA1OsHr+1LUGx8bEBfaCptx/Z7tx1Zo27njiEI/u68ft9uDK4j2+r0+sBF7dXp/3+JTbsaGobBxzPCaicGAbvHwv7N4CsTFoXQurNqPtugfXSBfMWVHqvZyenT+BYDuela8D9yzdMnjnwvqbcT/3fdyv+eRJEw6zdmyMix45z5xlUK7HYvMS8NXiGdwH3iItCBg9AvUdeH32meA6jQXnw1PfwuXx5LRgoJTnIUec/xQlwe9x43VrxJM64VjCFEdyIZXS0wKzAwSSGr8Q2/PtsXdKpL6sp7LE2W5jB7OmaTRWe+kfjzEYitFWX9g9fyhqb+duMM9e8kyEpIvZhsdFJqq8blwapHSxGCHbv7HjY+TzcbbbPCVFkZmTne1j+b9QPJTR1S5+ZD9nuytQi9d7Aj2lCxE9i4UCJ8fIO0dwzIjHB1f8M/zyVjj0BCy6KP0zmXLg5Bj5kali5A0z5fhxaFx00o9cepho1Ie32sb35BnQXBqJVIBq/6jjxPZZtXDecsst7Ny5kxdffNH8r729nU996lPcf//9AGzatInh4WGee+4583nbtm0jlUpxwQUXzObuKsqURDLFW779BNd99VG+9MAekqmp45Y7jZ7v+Q1V+PMU2gFWtAQBODoyYcnK31zRdZ07Hu8E4H0XLc5ZaJc01fi48/3n0Vzj4+Wjo9z24+eJJ1MnPabXOPnnc/Mpo9lGItb0oEm6BsSH7uJma1e4+T1uPvvGtXzjXRuo9XvY3jnI5q8+yqP7+izdjhXous7AuBjX5lobxA/PwLK54gLqb37+In/zsxd5Yn8/qQzv5cNDIvq1o9HhKzyBjYubCPo99I/H2HlkJKvn7OkVNzar2oLF3DWFQpENiRjsvR/u/TD853L4yTvh2E646KNw2zPwkcfhhq+Dvw52/aLUezs98YjYx/Xvmj2hXXLhRyA8ADt/PrvblQx1ia+Ni0uz/WzQNJi7Ek7sLt42RnqgYeHMjytnOjYKl8DAgVLviUIxK8jo93zF5YlEctJr2V8sqi0wPl1GQtve2V4lxsGazna5AMGeAlqjMV8xXGBvu67r6eh0vz2Pjxorne1m5YI9j4tT0TQt3duew/nDsTHyhtieS4y86Wy36ftDMT3+ej+JhIeU7ipQbI9MKTDb09leg88njv1so+RPEtunWHjgKM58C8xbB1v/PxEfIjHFdueIrhIpticiCRKZPnODhrl4/PhpP/IQIhr146lyxufrZJJaNX5/fGrHv02xXGwfHx83hXSAzs5OXnzxRbq7u2lubmbt2rUn/ef1emlra2PlypUArF69mmuvvZYPfvCDbN++nccff5zbb7+dd77znbS3t1u9uwobsvf4OP3jUXQdvr5tPzd/9ylOjGZ+Y3YZYvuSOYWdrOurvTRUiwvMw0Oz36X48N4+9p8Yp9bv4R3nLSjotRY11/C9951HwOvi4b19fObeXeiTPuCOGWL7vHzEduMifDhc+I38ZA4ZYvuipuJceLzh7HZ+99FLWD2vjoFQjPfcsZ0vb9077UKO2WYsmiBmLIxottHF5lS876LFLG+pZSKe4t4XjvCu7z7Npf/xEF/eupeewfR7TL7fOhqdf9Hp87i49AzRvbtt94kZHg2xRIoDfSKya9U8Z/X3KBS2Y/+f4EtnwN1vhyPPwYV/BX/1FNz2FFz2aZh7hnictwpWvQF23XPyzWW58cpvIToCG949+9tuXgYrN8NT3yrNGA11QaABqhpmf9u5MHc19L1avNcf7oaGwq45S858o/rp8DOl3Q+FYpaQ4pB03OaKdCICBApYqF4u1PgLW3zglEjotLO98Hv0iI2d7ZAW2wcLFNvDsaR5iWL3GPlQLJFx0XsupF3+9jwuMiHfN7ksRnBK9cSpmM72HM4hytnubIR4qBGP+wuPkZ8iOt2OznbNW40vII79XMR2M0begRHqp+FywVWfhcPbYc+W9PflceRAsd1f5wfDMxkdyXBcBOeJrxl62z1EDGe7fd4H2ZJyVeP3R4kYJjunYLnY/uyzz7JhwwY2bNgAwCc+8Qk2bNjAv/zLv2T9Gj/+8Y9ZtWoVV155JZs3b+aSSy7hO9/5jtW7qrApz3cPAcLpWuNz89TBQTZ/7TGe2N9/2mMPWiS2y+0BHB6c/ZPA9x4Trva3b1xgXvQXwvoFDXzjpnNwafDzZw/z1Qf3mT87Nix+v7zEduPmdchysV38HRc1F+9Dd8mcGu79q4u46fyF6Dp87cF9vOeOp+kby+4CqdgMGq72Gp/bEbFk6xY0sPVvXsO9f3UR77pgIcGAhyPDEb724D4u/Y+HeOd3nuSXzx3mwAnxt68EZzvA5StbANi2+/QVjadysH+cREonGPDQXmAMokKhKIADD8FP3gXzN8JHnoDbtsPl/wAtqzM//qwbYfAAHHtxVnczJ174ESy+FJqWlGb7m/4K+nbDgQdnf9tDXeXtape0rIK+PaLfrhgMd9vf2V7VAHNWKrFdUTFIUThvcXmSkzubOqNyJ1igczdscxe3pK5Ah/9kpKhq127uRkO0KXS+Qr7HXJp9hdXg5F7yeH4LdCRmvYBNj4tM1OaxWCfikHPGqdTn42w3jgm713AoMiM7qKNxX9Fi5KWz3U5iO94q/FJszySqZkA4243zTCU42wGWXQ5LL4M/fRaSxu8eE3O/eJ0ntmsuTQjuTNHbXtUIbh+MZXC2uyJMTPjw5lEPVe7onlp8PuVsn5HLLrsMXddP++/OO+/M+Piuri4+/vGPn/S9pqYm7r77bsbGxhgZGeGOO+6gttZ5nQ2K/HihexiAt2yYz28/egmr2oL0j0d59/ee5msP7jvJjWyVsx1ggeGs7ZllZ/ve42M8uq8flwbvv3ixZa971ZpW/vVNawH4yp/28fNnegA4Nipj5HMXN6X73+oYedPZbnGM/KkEvG6+8Jaz+Mo71lPtc/P4/gE2f+1Rfvz0IUti9wphICQu1JwQIS/RNI0NCxv5tzefxTOfuYqvvnM9l66Yg6bBUwcH+eQ9O3jy4AAgOtsrgcsMsf2lI6NTJnZIZIT8ytYgWg5dtAqFwkIOPizi4pe+Ft75Y2g9c+Zu6CWXQfWc8o2SHzwIXY/COe8p3T4suljEyz35zdnftl3E9rmrRdze8CHrX3tiVMSv19tcbAfoOE+J7YqKwXRyxwpzttvdyS0xY6ALdLbbVUyV1AVy71ueCjMu3KZj0mQkxA2FCpuvkAs4anwe296H+T0uPMaimkJ720MOdDHnU0MRdkj1xKnIc0guYntYph045PNEcTIyFjs64YNogc72KZzM0tlupxh5vFV484iR9/niIpLfbaPftVCu+j/Qvwd23C3+LcV2BzrbYVJveyZhWdNEb/t472k/8rojjo2Rx1eL3x9VYrtCUWpeMJztGxY2smxuLff+1cW8fWMHKR2+vHUv7/v+dvrHxYdaZzGc7bMcb3GH4Wq/Zk2b5YLjzRcs4rbLlwHwD/fu4uG9fWZne37Odutj5KOJJEdHxJgX09k+mTdtmM9vb7+EM1pr6RuL8pl7X+K8z/+Jv/7pCzy6r6/gmLV86Df72p158RXwunnj+vn86NYLeOzTV/DJq88wF1f43C5WtFTGgqu5QT/rFjQA8NCe6aPkXz1miO2qr12hKA1djwuhfdFF8PYfgSfLxVBuD5z5ZnjpV8VzJRfCC3eBvx5WX1+6fdA02HQ7HNgGJ4oYlZ4Ju4jtLavE174i9LaPiAWYto+RB9Hbfvzl9ASOQuFg8nFiTsZpTsSCY+QdsvhAdrZb4Ww3F2TYNC48ncRXmNiejk237+S3pmmmoDwetcbpb/f3ymRq80jGmHBI9cSpmDHykdwXHtg1BUMxPf56cd8bjXjQo6P5v1B86hj52LgNne2+GrN/PVuxPRaK4fXGSRKYedG+k2jfAGtvhIe+IBZdVLLYDqK3fex0sd3nmXBsjDz+ID5fgokhZ92nK7FdYSuGQjEzGn69IUhV+dz8x1vX8V9vW0fA6+LRff28/muP8tTBAboGrBTbhfA3m53tA+NRfvXCEQBuvbQ4Ua5/e81K3rxhPsmUzkfueo6dh0eA/MT2+iJ0tvcMRtB1sSJ2ziwKzctbavnNbZfwT69fzRmttUQTKX7z4lFu+d52LvniNr70wB4z3n42GJBie41znO1TMb+hio9euYI//+1l/PIjF/HLj1xES13lxKRfYUbJTy+27+kVNzWrlNiuUMw+3U/Bj98mXLPvvBu8OZ6jznorjB2F7ieKs3/5kkzAi3fD2W+bcuJj1ljzJgi2497+P7O3zWQcRg7bQ2yvmw/+uuIsRhiWYrsDnO0Lzgc9CUdfLPWeKBRFRwo8+camO0VclsiY7Hxdu9LZbvcKL1lDZ0VSm917mJuqLXa223TRgcRMfyhwIUbYAYsPTsUU23PqKXfWgiWJXLATiSeJJbJbKGxWCzhsLBQCUzic8KFHComRD08ZnW462+1kOPJW4XHnJraLGPk4Kc35c72nccU/QegEbP9f54vthsYyMTKF2F7beprYrqd0fN4o0ajfkTHyVNUBkBgeLu1+WIwS2xW24sXDwwAsnVND4ylRMm89t4Pf3HYJy+bWcHw0yk3/7ymiiRRet8b8hsInjEvhbL/76W5iiRRnd9SzcVFjUbahaRpfvPFsLl7eTDiWNFMB5uURI99o0UrxyXQPig/chc01sx7RVuVz8xeXLuX+j7+G395+MbdcuIi6gIejIxN8fdt+Xvuff+bt//skP3+2J2/HRLYMGH+X2VxwUGo0TePcRY2c1VFf6l2ZVa5YJcT2x/b1E01MHQNqxsi31c3KfikUCoOe7XDXjTD/HLjpp/mJ0h3ni4jucouSP/AgjB2DDbeUek/A44PzP4j20i/wx0dmZ5sjh0FPQeOi2dleIWgazF1VPGe7ywu1bda/9mwzdxX4alWUvKIikOKQFDlyJR0j7wzBTAqhlb74QEZAW9LZHrO3g1km8Q1a1Nlea3NxOR/3dibsflxkIp+xcWqMvFywA9lHyaePCXu/RxSZ8dX60FwasZiPVKiA+7RpYuRlZ7u9YuSrcxbbE+GEiJHXKsdgZNK0FDZ+AB77b3EfDs4V27Nxto+f3NmemEjg90cd62x31Rhi++hQiffEWpTYrrAVLxxKR8hnYmVbkN/efglvWt+ObiR9L2yqxuMu/FCXEe49g7PjbE+mdH74lOjhvPWSJUUVmn0eF99+97knOWTbCoiRz6XLaSa6+sV4Ly5yX/t0aJrG2R0N/Oub1rL9M1fx9Zs28Joz5qJpsL1zkL/7xU4u/uI2M4K/GAyEnB0jr0hzZnsdc4N+QrEk2zsHMz5mJBLnqHG8rWxVznaFYtY4/JwQ2tvOFkK7L8/PJpcL1r4FXvk1JKxboFYwz/8Q2s6C9vWl3hPBue8Dl5vF/Q/OzvaGusRXOzjbQUTJF8XZfgjqO8RxandcbrEwRontigqg2hSX8+1sd5ZgVusX96b5ColOcalKh781ne32joaWne3DBZoD0s52e46DpND0B4mZeGDz8ZiM2dmuYuRxu7T0eSRLp3867cBZY6EQaJqGv95PNOpDjxQaIz+9s91WMfLeKjyuGKDn6GxPoLtKnCpXKl7zd5BKwuNfAZfHsb31M4rttafHyMcjcfz+mGM72z1Boe2lxmfJWDFLOGAGRVFJvNAzDMCGhQ1TPqbG7+G/37GeL7zlLIIBD9etnWfJtqU7fnQiYamYPBVHhiL0jUXxeVyW/Q7TURfw8v33n8fyllo2LW2mLpD7ibyhSt68Wjc+Mqp9tvraZyLgdXP9unZ++IHzeeLvr+BTr1vJnFofw+H4jB3bhSDF9qYKiJGvdFwujctXzgWmjpLfe1y42ufVB6h34ApHhaIsOfoC/OjN0LIabv45+GsLe72z3gqRITj4kDX7VyjjJ2DvH2HDe0q9J2mqm0idfRNL+h+EVHETZAAhtmsuqLdJV/nc1dC/V0xQWMlwjzP62iUd56kYeUVFIIWucIU7uSVSLMu7sz3uDJdqnRE9GoolSSSzi4DORDyZMiOk7RoNLdMRBy2Lkbf35Lfc/1wE5Uw4urM9h4UITnW2QzohQznbFZJAfYBYzAfR8fxfZLrOdps62wG83sTUceGnYMbIeypUbK+dCxd9VLi6fTWO7a33N4i5/Gmd7eH+k4wY8VCMQCBKLOHHZYGJtNzw1DcAkAorsV2hKAmplM6L3cPA9GI7iFV2N52/kB3/cg1/+7qVlmy/xu8xV0IfmYUo+UMyPr2pGp9ndt6q8+qreODjr+HuD16Ql5O+wVhxGIknzVW9hXLISBJYVEJn+1TMq6/itsuXc9P5otN0KheyFVRijHwlc8WqVgAemkJs321EyKu+doVilji2A374JpizAm7+BfgteO+1rhUR1+USJb/jp6C5RV97GaGvvh5/YgwG9hd/Y0NdwtHttskippZVkJhIO/KtYrhb1Bw4hYs+CrcrZ7vC+cge7VCBMfJVDhFHaguIkU+ldCbiQli2u4AYnLSIvpC4cHl8gH0FNFl7V6g5QIrLQZuL7VJQLrQSz3S22/S4yEQwj8U65gIdm58zMlFflZvYnk47cN5YKASBhgDRqA/iBYjt08TI29PZLsX2eM6d7bgrVGwH2HQb1MwV1V8OJasYeRAd9gaJUBi3O0VCLz89xApqF7cD0Hams/7uSmxX2Ib9feOMRRNU+9xZxya7XNauiEr3thc/Sr5roDTx6S6XlndkfdDvwW2MuVXu/0MD5Su2S85f0gQUW2w3YuSVs70iuGTFHLxuja6BMAf7Tr952dMrorpUX7tCMQv07oIfvlF0it3yKwhY9L7TNFj7Vtj9ezHRUGpeuAtWXw9Vmat6SoXeehYAWu/O4m9sqMs+EfIgnO1gfW/7SA80OEhsr2rMv/JBobARNaZwlt+iZykUVTvElSlj5PPpKp9IpMfQ7sKZ1+0ynbaF9LbLWH2PS5s1M4DVNBli+3g0QTSRvzkg5BBnuxUx8rqup13MDhJW8+lsj8ScL7ZnW0eRTjuw93tEMTX+ej+xmBetELF9mhh5ezrbhWbg9SaIjWaXoBIPx/H54uhTjENF4A/C5v+EM99c6j0pGlJsjw5PsQijVhiuGEv3tidHhcaQxJnHxvyLzwBg/duXlnhPrMWeV8iKiuSFbtHXfnZHvSUd7PmwoNHobZ8FZ3t3mcWnZ4OmaeZFuBVR8olkip5BueigfMfhnIWNuF0aR4YjHBkuzrExEBIfyKqzvTKo9Xu4YEkzkDlKfvcx5WxXKGaFWAjueqsQHm/5FQTqrX39tW+BeAj2/sHa182ViRHo3wMrryvtfmQiUE/I14LWu6P427Kb2B5sE8eklb3t8QiE+pwVI69QVAjSyZ2vS9UpHeWSmgLGIzLJxR3w2H88pKhayIL4sANqBoIBD9KPUch8xbjZR21vITEfQflUJuIpdF38v5Oc7WZnew4LEdILlpwzDpI6oy84W7HdCecLxfQIZ7sfdyqMeRLIFcd1tufrbE+gVfrC4DPfDK/7v6Xei6KRtbN9PN3bnhwbBiChOfTY8Bnz2bECFuyUIUpsV9iG5w8NA0LYLBWlcLaXs6M7Ew1Gf/RQuLAeNIBjIxMkUjo+j4u2ukDBr1csavwe1rYLp+MzRXC3J1O62SunxPbK4fJVLcDpYruu6+wxOttXKrFdoSguT/8PhAfg7T8qjuO7eRnMPxd2/dL6186FwU7xtWlJafdjCoarF6H17ir+huwmtmuacLdb6Wwf7hFfneRsVygqBOkgzFc4c5o4EjSc7fmMR8SIkA94XZan5ZWCYB7C4amEHSAwu1yaGSVfyHyFXMBRa3Mnt5n+UIDYLl3tmuasrvJcFyLoum6K7QGf86baTWd7lucQ1dnufAL1AaJRLxpJSGQnLJ9EMgHJ2JTpU/Z2tucRI1/pYrvDCdQbYvvIFGJ79RxR6Td2zPxWKiS6zFNuZ8Wsm7g98IH74YxrS70nluK8KwCFY3mhRzjbN5SF2D4Lne02dLYDNFjobO8aSPfWl/skh4ySf7oIYvtwOEbKWCgqo+8UzucKQ2zf3jnI2ET6/XR0ZIKxiQQel8ayuQ696FIoyoHIEDz+Vdj4fmhcVLztrH0r7N8qtlcqhgyxvbE8xfaRqsVox3dBKlW8jUSGYWIYGor4ty4GLausdbaPdIuv9crZrlDYDSkOTe7WzoWIw8R26UzNS2w3x8IZQlGdKZTlf48eckjygTQHyMXs+TAec0aMfK0FMfJmXLjXXfZzNrmQq9g+2eHvlPPGZHLtbI+oznbH42/wE4sZ85PRsdxfIG6Y2DI42/WUTiIi3nv2dLYnchLbfb44WsBec/+K3JjR2e5yiSj5STHyqfCw+Opy8LzvwguhZk6p98JSlNiusAWjE3H2nRCxEhsWNpRsPzqMGPlii+2plE63EZ++qMleq9saDDF4JFK4s91099tgDM5bLHvbByx/7QFjIqCh2luyCgXF7LNkTg1L59SQSOk8tq/f/L7sa186t8a2fYkKhS14/GuQjMOlf1vc7Zz5ZrGdV39X3O1Mx2CniCOvbirdPkzDSPUitOhYelFAMRg+JL6W6YKDKWlZA/17hTvECoa7QXNBXbs1r6dQKGYNKZLnGyMfMvuGnSEUSZFnPJpAzzHiVjpUneLUDQby76+XmOKZzY+PJsMlWYg5wDGd7RbEyIeMxINqm4/FqeS6EEGeM8A5543J1BnnkJEs3zfyuLD7+UIxNcLZbojtMWvF9vik48xWznZf/jHyroBKrXQyM4rtAMHWk2Lk9bBwtus+B4vtDkTN0itswY6eYXRdOJzn1PpLth8Lmgxn+2A45xv2XDgxFmUinsLt0phvuOntglwpboWz3U699VJsP9AXon88jwilaRgYNyLk7XSRqbAEGSX/4KQo+d29MkK+riT7pFBUBGPHRYT8BR8WNz3FpG4eLLkUdv2iuNuZjqHOshaZR6oMt3nvzuJtZKhLfLVTjDzA3FUigtGqhQjDPVA3H9w2cpEoFAogLfxJB3KuRMzYX2cIRTJGXtdzd/ubYrtDxqIukFvfciZCDjk+ZIx8Ic72dIy8vYVEec4oxNkeli5/mx8XpyL/ttlG7Mtx8HlcuB3k8JfUV2efjpFMpSP17X6+UEyNv96fFtujeXQux8R8b6b49JgxB4oGniobnWfNGPnE1HHhk9B1nVgohtcbx1WlBFUnk5XYXtt2krOdCWG00r3q2LATSmxX2IJ0X3tDSfdjfoO4CBiLJhiNWOQgyoCMT+9orMJrMydzQ5XsQLMiRl6sdFw8p/yd7Y01Ps5oFR+Az3ZZGyU/EBLifXMJF5ooSoOMkv/znhOkjC6BPYbYvkr1tSsUxePRL4HLCxd/bHa2t/at0PUojPXO/NhiMNhZtn3tAFFvPXpwHhzbUbyNDHWBL1i27v4paVktvloVJT/SoyLkFQqbYort0fxi5J3W2R7wupCaV65uf6eNhRXOdtnZbvcxkWL7cAGd7eMO6K+HtHu7sM52Z1UuSORinVgiRSwxc43RhMPF5Vxi5Ce7/O3+HlFMTaAhUGCMvJEY6z3dXDW5r13TbLR4xXDp+/wJJoYmGD0yOu3DU/EUelLH54vjqi5/k5kif6TYHg/FScanuE4Ptp3U2c7EGPG4G3fAXibMSsdeKp7CMibiSfrHozP+V0iclJWUQ187iJXtc2rFxUTPULho2+k2ROaFNohPPxXpbLciRv7QpM52OyB727d3Wtu7K53t8thTVA7nLW6i1u+hfzzGriMiQkiJ7QpFkRnuhmfvEEJ71Sxdd6y5ATQ3vHzv7GzvVIa6yt7RrbeeBceK7GxvXAx2mtABqJkLVU3Qt9ua1xvuhoaF1ryWQqGYVWRseiiWe2w6TBaYnSGOaJqWsztVIoWzgEPioOsMZ2Ahne3SuWv3uPDGGulsLzxGvtbmfdS15gKdQhZhyEh9e4/FqUz+fbIZH3n+dGKEPEyKkc9CbJfHhEsDv6q9cywnx8jn4Ww3Y+RPFxLjxvnZVn3tAG4faC7mLBXCeee26ZPHRFy+jtcbx12j5vecjL8ubZ6LjkyRhhtsg/FJzvbYKNGoH2+1zd4HFY69r5IVOaPrOj9/tofP/e4VcwXqdHhcGv/vvRu5fGXLLOxdZnRd54XuYaC0fe2S+Y3V9I/HODwUYe38+qJsQzrbF9sgPv1UrIqRn9xbb5dxOH9JM3c91c32Lmt72weMWPrmGuVsrzR8HheXrpjDH17qZdvuE6yeV8f+E+JGZqUS2xWK4vDnL0JVg4iQny2qGmHF1SJK/sKPzN52ARIxGDlc1jHyAHrb2fD8nSIPuBiC+FAXNC6y/nWLjaYJd7tVzvbhHljyGmteS6FQzCqyG1fXhbMwV9E84jA3NwgxcXQiUfHO9jrT2V5IjLzsYLb3mDQa8xVDBTjbHdPZHrCgs91hi3QkHreLKq+bSDzJeDRhLtKYCnn+dEr1xKnUVWUfI58+V3js5UpW5ESgYZLYno+zfboY+UnOdluhaeCtpnV1LdwLnQ92su6WdVM+PB6O4/EkxK1tQEWFOxmXx4Uv6CM2FmNieILqTAm+ta0Q6oNkAtwetPg40ajPXlUKCuVsryTCsQSfvGcHn/7lrqyEdoBESueRvX1F3rPpOdgfYiQSx+9xsXpe6TuKFxgd6oeL6Gw/ZDjbFzXbw9E9mYZqGSNfmLPdjr315xu97a8cHS1oIuNU+o0LzWblbK9IZG/7Q3tOcLB/nERKJ+j3ML/BHu8LhSIbXM/ewTld3y71bkDfXthxN1z6t+Cf5RvetTfCkWdFpPtsMtwN6GUdIw+G2B7uh9GjxdmADdz9UzJ3lTXO9kRMRNepGHmFwpZU+9zmWqR8ouTDcSG4OUkskjHZuXZSS2e7U1yq6c72wru57S6qStG0kPkKKU7X2Hwsaq3sbHeYsx0mxexnMT5hh50zTqXeEHtGsjDVyMUo1Q48JhRp/PV+4nEvuo7lMfK2dbYDeKtpXibm8ju3dU6bNBQPx/F6xftFy7DoQOEsAvVGb/vIFL3twTbQU0JwB1yJcSYmlLPdbtj7ylCRNfuOj/FXP36efSfGcWnwyWtW8pHXLsPlmnqV4Y+fPsRn7n3JFH5LhXS1n91RXxb95R2N4gPw8FCkaNs4NChW+C2yiaN7Mg1V1jjbZYT8/Ab79Na31QdY2FRN92CY5w4NcZlFiRCms111tlckl62cC8DOwyM8tq8fgDPagmqVuMJZREdpHd0h7Hil5KH/C8F22Pj+2d/2yutEz9tLv4DXfGr2tjtkiPt2cLYD9O6E+vnWvngqKRzddhXbW1bD8z+EZBzcBdyMjx4GdBUjr1DYFE3TqPF5GI8KJ/fcYG73Dk51tkPuMfKmcOaQsTA726OFxMg74/hokuaAUH5ieyKZImp0eNfa3NkuxeRYMkU0kcTvyf1vKxf22H0RRiZq/R76xrKr13Ti+XMy0tk+Fk2QSunTziU7rZJEkRnRQa0RjfkJWBwjb1tnO4C3ioZ2P26fm9GeUQb3D9K8ojnjQ+PhOD6f8bnsVWK70wk0BBg9PMrE8DRiO8B4L9TNw5UcJxL14WlS51I7YQ8FS1EQv3r+MDd843H2nRinJejn7g9eyG2XL5/24gjS0d1S9CwVz3eL/utzStzXLukosrNd13UO9cv4dPt92KY72wsV2+3p7j/PcLc/0zVo2WvKzvZmO15oKgqmJRjg7A5RWfG9x4QopiLkFU5Db1qCLxmGyFDpduLoi/DKr+GyvwdPCRY3+Wpg1eth1y9nd7uDnaJfrq59drebK3XzRTf5sR3Wv/boUUjF7Su2z10l9n/wYGGvM9wjviqxXaGwLVLoyScW2hRIvM6Z1KvJs5N6IibEVKe4VM3O9kKc7Yaoavfo9MYaGSOf33zF5NQIu4/FZGd+vu526Wy3+8KDTJjO/ywWqaRj5J03DpCuotD1mRcvhcwUDGecPxWZkS7dWNSLPlFAjHwGkdnuznY3UTo2dQAiSn4qhLPdOL/47Ge2U+SGWKDC1GJ7rSG2j4nedncqJDrbq2z4PqhglNjuYCbiSf7+lzv5xM93EIknuXh5M7//2KVcuDTziqpTkSJnz2CEZKp0TrNy6muHyWJ7cZztg6EYY1HR2bKgyV5CM0CjRTHydu2tv2CJENu3d1ontg+GlNhe6VxupCQcM+KGVimxXeEw9MalAGhDsxyhPpltn4fmFbDuptLtw9q3Qt+rcPzl2dvmUCc0LAJXmU+IaRrMO7s4YvtQl/hqV7G9ZbX4Wmhv+3C3+FrfUdjrKBSKkiHFoXCWtXESXdeJOMzNDfl3Uktnu1PEoqAlne1GzYDNFyA0FuhsHzfGwed24fPYe0rV7dKoKWCBDkx2ttv7uMiEmYyRU4y8vY+JqQh43fiN4310BmNNZFJnu8K5+OvF4vRo1EdybDj3F4hHwFMFrtPfM3Z3thMPs+QKkRrXuS1LsT2Dw1/hLGYU22vmAppwtgNuPUw06lMx8jbDmVcBCg72jfOmbz7OT5/pQdPg41et4IcfuCCnKLl59VV43RqxZIpjI8WLTJ+O8WiCPb2jAGwoE2e7FMB7BsPTdq/ky6FB4ehuqwsQsOGNbL3xITART5ldd/kgx8F2znZDbN/RM1LQ7z+ZfhUjX/FcufrkSoKVrUpsVzgMKXIOFejMzZdDT8D+rXDFZ8BdwomhZVdAoAF23TN72xzsLPu+dpN56+DYTutfd6gL0OzbVV4zB6rnFC62j/SIFfWlSHZQKBSWIDtyc3Zyx1Nmk4uTRDMp9uQqJDrNpSpdqaMFdHObAprNe5il2D4WTRAz4uBzQb637D4OkpocBOVMpMfDGe+VydTmsFhnogKi0+cY81E7Dg9P+zjV2V4ZePwePAGPENvHR3J/gXhoSoHZ7s52YmGWXJkW2/UpDIwnx8jby2imyJ0ZxXa3RwjuY0Js9xAmGvXjqXLu54oTUWK7A/ndjqNc//XH2N07RnONjx994AI+ftUZuGeIjT8Vt0szheXuEvW27zw8TEoXvd2tdYGS7MOpzG8QFwOhWLLgXvJMyNh+u4nMkqDfYx5rhUTJp8fBXhcci5urmRv0E0um2NEzXPDrxRIpc1JkTq0NV3UqLGFte715cwuwqq2uhHujUBQBf5AJTz1aoTHY+aDr8ODnoO1sWP3G2d/+ZDw+OPNN8NIvZ6+/fqjTPo7ueetEr3io39rXHeoSMfre8rjWzIuW1SIVoRCGu6HBpgsOFAoFkBaXpQs5W8KTHm935/JkTLEsRyHRdPk7ZCykw39sIp63YSAdDW3vSd+6Ki9yamw4kru7fdxh4nIugnImnBwZHvRnf/6QaSJ2NMxky43nzAfgK3/aN236aVg52yuGQEOAWMxHKjya+5Nj4Smj06Wz3Z5iu3C2zz9/Pt4aL5GBCMd3Hc/4UOFsN84vPntqAIrs8TeIOd0pxXYQve1SbNciwtmuYuRthRLbHYSu6/zf37/CR3/yAqFYkvOXNLHlry/lkhVz8n7NRYbY3lUisV1GyK8vkwh5EBfPMiGgGFHyZld5k71EZommaTQYHwT5LkaY3Ftvt0UHmqZxvoVR8jJC3uPSTEeCovJwuTQuXzkXgHn1ATNBQqFwEiF/a2li5Pc/CN1PwpX/kjHGbtZZ+1Yheh5+pvjb0nUhNDfaxNnetk58tTpKfqjLPgsOpqJlNZzYXdhrDPeovnaFwubk21GeFopcuHJcpF/OBPMcj0jMWdHYdcb9eTypMxHP3c0N6WPE7mPidmnUG+MxFMp9vkIeS07pKM/3PSJxsrAqFyJkMzYRh1VPZOIvXrOU+iov+0+M85sXj0z5OCcvwFCcjL/eTzTqRY/kIbbHIxn72iHtbPfZ0XDkq4Z4BLfXzaLXLAKm7m0/OUbeXnPfityZ0dkOQmwfF4szvO4IExN+FSNvM8pgRlFhFd98aD//71FxAv+ry5Zx919cULAbXLqKpct4tnmhewiAc8okQl6S7m23fhGCKbbPse8HrRQC8+1tHwrHGTNuaBbasLf+/MWG2N5VuNguI+SbanyOmvhS5M4b14uV5Bcty38BlUJRzoT8rSLSfDZJpeDBz8LCTbD8qtnd9lQsulhEgu+9v/jbGuuFxIR9YuSbloKvFnotjpJ3gtg+dxUMHoBEftdeAIx02zdKX6FQAJPF9tzqrJwqmJkR2bmK7Q5zttf43KabO9/e9rCDYrIbjR7gfOYrpMtZOdsFTo4Mr83h/BExBGannDMyURfw8pevXQoId/tUNQzhqKyccMZ7RDE1gYYA0agfomO5P3maGPnYuJ0724XYDqSj5KcQ22Oh2KQYefvNfStyI1AvNLroSHTqB9W2ijkaXcfrniAa9akYeZuhxHaH8IvnDvNfD+wF4LM3nMnfXbsKj7vwP+9iw1V8qATOdl3XTWf7hjJytgMsaBTjUgxne5exsGGxzeLTJ1Oos12Owbx6e/bWS2f784eGSCTzcw5IBgxne5MdLzIVlnLJijn86ROv4XNvPLPUu6JQFIWSONtf/a0Qbq/8F9DKZEGTywULzocjzxZ/W3K87eJsd7lE3L9ytp9Oy2pIJWBgf37PTyZg5IhytjuUL3zhC5x33nkEg0FaWlp405vexJ49e056zMTEBLfddhvNzc3U1tZy4403cvz4ybGX3d3dvP71r6e6upqWlhY+9alPkUjk3wGtsJ7aPDvbZYx8lcOciAXHyDtkPDRNI2j2tucptjuoq7zJ6G0fCuUfI+8UZ3ttgZ3tTl2oA5jmpVeOzuzalePglHPGVLzvosXMqfXTPRjm58/2ZHyMcrZXDoH6ALGYFy2eh0HP4THyAEuuEPfYhx45RDJ++iJI6WxP6W5RJ6dwNNk52+cJsT02jqbpRKPK2W43lNjuAB7d18ff/1I4fP7ytUt570WLLXtt6WzvKoGzvXswzEAohs/t4sz28uonls72niI427uNhQ12dHRLGoyb15E8OtAgnaRg1zFY2RqkLuAhFEvyyrE84pQmMWA42yf3dSsql+UtQbVCXOFYxv0taJFBiAzNzgaTCdj2eeFoX3TR7GwzWzo2wpHnhfO+mMgkgcZFxd2Olcw7G45Z6GyPjkO43/5i+9xV4mu+ve1jx0BPKrHdoTz88MPcdtttPPXUU2zdupV4PM4111xDKJS+x/ubv/kbfve733HPPffw8MMPc/ToUd7ylreYP08mk7z+9a8nFovxxBNP8IMf/IA777yTf/mXfynFr6SYAuk6Hs+xs91psekSKSTm2mHvNGc7pHvbR/MUVUMOcrbL+YqhPMwBTouRr/WLSXzV2X46V6xqAeCZrkEzcXAqKiFGHsT7/7bLlwHw9W37mMggICpne+UgO9u1xHjuT46HZ46Rt6PpyFttiu1t69qoaqoiNh7j6DNHT3uo7GxP6mq+txLITmxvhdAJmBgBUJ3tNkSJ7TbnlaOjfOSu50mkdG5Y186nX7fK0teXfdndg2F0Xbf0tWdCutrPnF+H31NeF6wdRXK2j07ETSez3brKJ9Ngxsjnt2peJinY1d3vcmmct9ia3nbZ2d5sx64ihUKhyIGQv038z+DB2dngrp/DwD644p9mZ3u5MH8jREehf29xtzPUCcH2KSP8ypJ560Rc+kRhi9lMhg+Jrw02WnCQieomETuXb2/7cLf4qmLkHckf//hH3ve+93HmmWeybt067rzzTrq7u3nuuecAGBkZ4Xvf+x5f/vKXueKKKzj33HP5/ve/zxNPPMFTTz0FwAMPPMArr7zCXXfdxfr167nuuuv413/9V775zW8SixVQX6CwFCluhPOMka9ygJA6GSmI5uxsd+DigzrpbI/kd4/upDFpqsm/9k4uOnCCwx/SizByfY9InCysLmiq5qz59aR0eODl49M+Vr4/nLRAZyredcFC2usDHB+NctdTh077eagCIvUVAtHZ7seVysOIFg9PeQ8qxXb7OtuFVqC5NBZfvhiAzm2nJ/jFw3F8vjhJlNheCWQltte2ibQ6wxShYuTth/pr2ZgjwxHef+d2xqMJLlzaxH++7WzLO507GqtxaeLmu288SkuwsA74XCjXvnYoXme7dLXPqfWZMW92pKFKCMP5xsg7obf+vCVNPLj7BNs7B/mLS5fm/Tr9RldRc426+FIoFM4m5BfuEQY7Yf65xd/gwT9Dx3nQvqH428qV+ecAGhx+BlqsXUh5EoOd9ulrl8xbJ7727oLFFxf+ekNd4qvdne0g3O35OttHjCjQBiW2VwIjI8It0dQkFoc+99xzxONxrrrqKvMxq1atYuHChTz55JNceOGFPPnkk5x11lm0traaj3nd617HRz7yEV5++WU2bDj9XBqNRolG027A0VGxSCYejxOP53efYAVy26Xch2Jh6GaMRWI5/X5jEfF3qvJojhoXczwmEln9XvIxcvGB16U7ZjxkxcBwKJrz7xRLpIgZ9Wg+B4xJnXFg9I9N5Py7jBoCfZXXlfc4lNM5qMoj5hBHcjxnSKSw6oTjIhOvW9PCriMjbNl1lLedM2/Kx8kqDp+78L9rOR0fmXABt1++lH/89St886H93Lhh3klJD+NGVUXAU76/gyJ7pjsefUEf0agXtx7J+W/tjoagei7JDM+LGkkSLn/+59lS4XIHcMXDJIz9XnjZQl795asc+NMBNn1600mPjY5HqfbGSWl+2/2eUP7nqnLDUyvOkxPDU197aFVz8ADJ46/iBiYm/GheZ12b50q5HGfZbl+J7TZlJBLn/d/fzvHRKGe01vK/t2wsivvb53HR3lDF4aEIhwbCsyq2P1+mfe0gVriCcLbruo5mUc/rIQdEyEPa2V5ojPyiJns62yHd2/5M1yCplJ73QhgZI6+c7QqFwukk3NXo1XPQBg7MzgaHu8u3q9wfhJY1Qmw/55bibWeoMx0/bhfmnAFuP/TutE5s91RBbUvhr1VqWlbD/gfze+5wD1Q3T9mdqHAOqVSKj3/841x88cWsXbsWgN7eXnw+Hw0NDSc9trW1ld7eXvMxk4V2+XP5s0x84Qtf4LOf/exp33/ggQeori79/c7WrVtLvQuW09mrAW4O9hxhy5bMfbqZePq4eN7Y8ABbtmwp2v7NNodDAB4GRsZz+r1GQhFA49mnnuDormLt3ewSGXEBLp549gW0ntxSC8MJkNOHDz+4FY/NMzJPHBHH+0v7Otmi53bd+cpBMY7HurvYsqWwNKZyOAcdNsZiz4Hcfx9dh9CEG9B46rGHedWBUxb+CICHJw70c89vtjCV0fboCTEOr+x8EffhFyzZdjkcH1MR0GFuwE1fOM5nfrCV13WkzymHe8V7ZM/Lu9hy3MLqJ0VJyXQ89h7vpTXmw63F+f19v0V3ZS8zvXagl6GJGnZm+GzuO9IHwM5Xd3Joy+npCeXM0hOdrJ4YM685JlzCxdzzeA/33XsfLn/6A7R7TzctvjjhmMbjNr72KudzVTkRPSbm98f7p74mDcQGeB3Q9dyfWIZwtj/29GP4DykDXqmPs3A4O8OtEtttSDSR5C9/9Cx7j4/TWufn++8/n/oi9jcsbq7h8FCErv6QGY1dbCKxJK8aXdcbytDZ3m5Ef4RjSQZDMZot6tPuMkRmu8anSxpljHyoQGe7jaP017bXU+V1MxSOs79vnDNag3m9jqwVmKPEdoVCUQHoTUvRZitGfrin/LraJ9OxEQ4/W9xtDHXBGdcVdxtW4/ZC65lwbIc1rzfUJVztFi2cLClzV8H270B8Arw5LpAdPqT62iuE2267jZdeeonHHnus6Nv6h3/4Bz7xiU+Y/x4dHWXBggVcc8011NXVFX37UxGPx9m6dStXX301Xq9908QyEX/xKPd0vkRt4xw2b96Y9fP6njwEB/eweH47mzefXcQ9nF0ODYb5z52PkdA8bN78uhkfL4+NpPAVcc2Vl9l+Ibzkz5Fd7Bo6xqLlq9h8aW6LDY+NTMAzj+B1a9zwhs1F2sPZI/TcEX7b/TLVjS1s3nxOTs/98y93wfFjrDtzZc7jKCmnc9DQ9h5+1/0qDXPb2Lx5fU7PjcaTpJ4Si/yuv+4ax/TYn8ovjj3BnuPjuBasY/M58zM+5lsHn4DxcS7ZdD4XL2suaHvldHxMy4JjfOKeXTza5+dzt1xqzkt/t/spGB3l4gs2cvnKuSXeSUWhTHc8PnvoWbqfexSA6664RNRaZYnn0GcJLl9Nx5Wnf6Yc/sfDhAmz6bWbzBh2u6C9MIDnyF1svu460DR0Xecb//YNxo6McWbdmSy5Mv258eu7f413IoGvuoHNm+332Wqbc1WZEOoL8epHXiUVSXHt667F5c6wcjEZg5f/hiV1CeiDaNTP1dddTe282tnf4TKhXI4zmdA2E868EnIwqZTO396zk6cODlLr9/D9953P/Ibi9mwuaq7msf2it3222HVkhERKp7XOT3v97Lnps8XvcdNa5+f4aJTDQxHLxHbp6F5oY5EZoL7aiJHPw9k+5pDeep/HxYaFDTxxYIDtnYP5i+2Gs71JxcgrFIpKoHHJ7HS2J+MwdrS8xcWO8+CFH0F0TDjdrWZiFMID9ouRBxEl3/O0Na8lxXYn0LIG9BQM7IO2s3J77kiP6muvAG6//Xbuu+8+HnnkETo6Oszvt7W1EYvFGB4ePsndfvz4cdra2szHbN++/aTXO378uPmzTPj9fvz+069hvV5vWUzKlct+WEldtRjvSDyV0+8mK95rAh5HjUlDjZhLCMWSuN2erNLGdB0mEmJAgtV+x4xHvXFshGK5HRsAsZS4J632OeP4mGMkNo5EEjn/PuG4iNOvs+DYKIdzUINxXITzOC5Goynz/+uqA7gtrrUsF647ax57ju9j66t9vPOCxRkfEzGOi2CVz7K/aTkcH9Pxpg0L+M6jXezuHeOOJ7r5u2tFWpas4bDiPaIoHzIdjzVNNUSjYv7Xm5qAXP7e8Qhufy3uDM9JiDgVquqr7HcMBcR9u5cEeMWc9tIrl7LjhzvofribM649w3xociKJzxcHT9B+v+ckyv1cVS4E56TndFKRFP7GDPP8Xi9UN6MN7AcgFvPa831QBEp9nGW7bZuHP1UeX7x/N7/bcRSPS+Pb7z6HNe3FdwRIwbNrYPbEdtnXvmFBo2UR7VbT0ZiOkrcK6ei2u7O9wVjRmk9nuxyD5hp799ZDOkp+e+dg3q9hdrYrZ7tCoagA9NkS20ePCFGynMXFjo1iH49aE0V5GkOd4mu5RulPx7yzoW8PxC24BnOS2D53pfh6Ynfuzx3uLu/FJ4qC0HWd22+/nXvvvZdt27axZMnJ7/tzzz0Xr9fLgw+mawj27NlDd3c3mzaJfslNmzaxa9cuTpw4YT5m69at1NXVsWbNmtn5RRQzUmM4S0PRRE7PixjiSLXPWX6MyU5b2S09E/GUENzBWeMhe8rHJnI7NiDdR13js766sBQ01Yh766Fw7uaAkLEypdbvjLGQ75GxHM8ZkBZVq7xuxwrtAJvPEl3tj+7rZ2wi8xxXeiycc86YCZdL4xNXC+Hw+493cWJMxGXLsahx0PlTkZlAQ4BYzJirjI7l9uR42BSjTyVmGLB8NTacB/UahshJ96mLr1gMQNe2rpMeGg/H8Xrj6J7imigV5YHb58ZrdJGMHxuf+oG1bTDcTTTqQ9ddeIuYZq2wHiW224gfPtnF/z4sJqC/eOPZXLpiduJ4FhnCb7fhup4NnjfE9nMWNczaNnOlo1F8GB4esm4RghPi0wEaDWf7SCR/sd3uYwBw/uK02K7rufXiSQZljLxytisUigpAb1oC4X6YGCnuhoaNHttyFhfnrAR/nehtLwaDhthuV2e7noTjrxT2OqkUDB1yjthe1QDBduh7NbfnpVIwcri83w+Kgrjtttu46667uPvuuwkGg/T29tLb20skIiYC6+vrufXWW/nEJz7BQw89xHPPPcf73/9+Nm3axIUXXgjANddcw5o1a7jlllvYsWMH999/P//0T//EbbfdltG9rigNabE9mdPzTKHIIWKqxO9x4TFEwGzHJJ4261Lldc541BmTtaNTiIXT4bTjo8GYr5D32rkwHpULD5whJNYaizDG8zgu5AKWGocsPJiKFS21LJ1bQyyZYtvuExkfMxF31nskW65e08q6BQ1E4km+9dABIL3Yq9rhx4UC/PV+09lObBrxMBPxMPgyG83iRiWpFCZthc+Yy46ntYKlVy4F4OizR5kYnjC/L8X2qRYdKJxHxwUiWezgg9MYTIJtaOhEoz40t4bLq+RbO6H+Wjbh4b19/J/fvgzA315zBjee2zHDM6xDuqxny9mu6zrPdw8D5dnXLllgONt7LBLbJ+JJekfFh+4iuzvbZWd7HivFZW+93ccAxPHrcWn0jk7klYAQjiWIGDdtytmuUCgqgkZxI1p0d/twt/haP3vXUznjcsH8c4rX2z7UCf56qCrfa60paTkTNDcce7Gw1xk/Dsmoc8R2gJZVuTvbQydEP1w5Jz0oCuLb3/42IyMjXHbZZcybN8/872c/+5n5mP/+7//mDW94AzfeeCOvec1raGtr41e/+pX5c7fbzX333Yfb7WbTpk28+93v5j3veQ+f+9znSvErKaZAum2zdXFLpHO52kHiMoCmaWkxMZqdmCiTsX0el6PcukErnO0O6eSWzvaxiQTxZGqGR5+MFBKd0k8uf4/xPJztcgGLkxIgMqFpGtetFXUpf3yp97Sf67qePodWmNiuaRqfukYkK939dDdHhiPK2V5BBBoCabE9moPYnkyIew/v6Y5uPaUTN1JSfXacB5XC+SRne11HHc1nNKOndLoe7jK/Hw/H8fniaFMsOlA4j+WblwOwf8v+qR8UFJ83ExN+vFXesk18VmRGie02QNd1/uOPu0np8I6NC7jt8uWzuv2FTeKDYiQSZzgP8TRXjo5M0DcWxePSOGt+fdG3ly9pZ7s1MfLdg0K0DwY8NFbbcPXeJOqN/Z+Ip8wVvtnS7SBne5XPzdkd4hjOJ0p+wIiQD3hdFXfTplAoKhNdRpoXW2wf6YGalow3+GVFx3nC2Z5nOsq0DHZC02Kw482bNwBzV0HvzsJeZ6hLfG1cVPAulQ1zV+fubJeLT5Sz3bHoup7xv/e9733mYwKBAN/85jcZHBwkFArxq1/96rQu9kWLFrFlyxbC4TB9fX3813/9Fx6PmkwvJ6TolWuMvBRHqh0iIE7GjMnOUmSWznan3X/VGRVto3mkz6VFVWeMSX2V17z8ybX6Tr63nLLwIGg62/NfhOGU42I6rlsrouQf2nPC/L0lsWSKlHGpXmnOdoCLlzdz4dImYskUX7p/DwljMJSz3fkE6ieL7aPZP1G6vjM4uuOTzsn2jpE/2Zgno+Q7t3Wa3xPO9gT4ldheKazYvAKAzoc6TzrWT6K2FYBo1IenyhnXGpWEEtttwPbOQV4+Oorf4+LT162a9RUtVT43rXUiGvDQLLjbnz8kIuTXtNcRKOOV9VZ3tnf1C0f34uYa269aCvo9pgsg1yh56Wy3e2+95LwCetv7x6MANNf4bX9MKBQKRVZUNUBVEwwU29neAw02cPHO3wihvrQYaiVDnfZ2dM9bB8d2FPYaUmxvcJDY3rJKLKTIpc/eFNtt8J5QKBTTIgXAeFInlsjesWuK7Q4UimpzjNY3hsJREfIAQUNsL8TZ7hQHs9ulUW/E6udqKBl3mNhuVk/EkiRTuS3ulO8pp4zFdJzZXkdHYxUT8RQP7+k76WeRWPrc4rTzRjZomsanXifc7b964Yj5faclpShOZ3JnezKUh9iewdEt+9rRsKfQ6D09Rh7SUfKdD6bF9lgohtcbxxVwxvy3YmbmrJpDw+IGktEknQ91Zn6Q4WyPRn14bW7GrESU2G4DvveYePO95ZwOM+5qtlnUJKPki9/b/oIRIX9OGUfIw8md7fn2cU9GOtsXOsDRrWkaDVX5RcnLBR1OGAeACwyx/Zmu/J3tc+wYnaRQKBT50rxsFmLkD9nDxduxUXwtRm/7UBc02rCvXTLvbNHZnszdoWcy1CVWjvuccc0BCGc7OvTvzf45Iz0QqBf/KRQKW1MzSSzPxd0eiTvXoZqOyc4tRt5pDtU6Q7QopLPdScdHUx697bquEzLGwmkx8lBA/YSDjoup0DSNzWcJd/sfTomSl9V/XreG112Z0+znLmri8pVzzX/7PC48FToWlYSv1geaRizmJTEylP0TY4a2kCFlzuxrr7ZpfPZUzvbLFgPQ93If48fHjYcYMfKB2tncQ0UJ0TTNjJLft2Vf5geZYruIkVfYC/XJV+YcGgix9dXjANx6yeKS7YeM9J4VZ3u3+IDesLCh6NsqhPaGKjRNRKX3jxcer592dDtjwldGyecSyza5t94pzvZzFzWhaXCwP8SJsYmcnjsQEs72Ui2yUSgUipLQtHR2YuTt0E9dM0cI4lb3tidiMHIYmuwstq8Tfet9e/J/jaEue7v7MzFXOIty6m0f7oZ6Gyw+USgUM+Jxu/B7xDRPLsKZFFOd6MqsMcX27Jzt8aSY3HfaWBTmbHdeB3NDtTQHZD9fEU2kTPd3jUMisv0eF163OOZzrZ9w2sKDmbjW6G3ftvvESXWJ8v1Rzsmcs8Enje52OHnhl8K5aC7NjJJPjA1n/0SZwOWd2tluywh5yNjZDlA9p5q29eIcIqPkRYx8HFe1M+a/Fdkho+T3b9mf2bxZm3a22zLdocJRYnuZ8/3Hu9B1eO0Zc1neEizZfiyeI078xRbbo4kkrxwV0TMbFpS3s93ncdFWFwCEu71Q5NjKFAG701CVu9jupN56SX2Vl1VtdQA805nDSk8wF3E01/ot3y+FQqEoW4ottqeSMHLEHs52SPe2W8lID+gpezvb284SXwuJknei2B6og7qO3Hrb7VKroFAosqImx9h0SMcgOyUmfDK1Zid1bs52p7l16+Q4RBN5xIULEdZJbn+5oD2XJL7xSWK0UxYeaJqWTn/IcSFGOOqseoGZWN/RQFtdgPFogsf29Zvfjzgw+SEf1s6v5/WG+79SjgkF+Ov9RKM+UuMj2T/JjJHP0Nkune01Np0TnkJsB1hypbj37nywk1QyRTKawOdL4Kound6jmH2WXL4Et9/NcNcw/bv7T39AUHa2+1WMvA1RYnsZMzoR555newC49ZLSToYubJLO9uLGyL90ZJRYMsWcWh8Lmk6Pkyk30lHyhfe2m2K7Q5ztjUYsWy4daLK3flFztT3jgqbg/MVi4UiuUfIy0q5ZxcgrFIpKomkphE7ARA69b7kw1gupuL3E9t6dkIha95qDRj+YnZ3t/iA0LRNjky9OFNtB9LafyEVs77bP+0GhUMyIdNzm5Wx3oFgUnNRJnQ1xQ2x3mktVOtshD1FVOtsd4uYGaMgjRj4UTcemu1zOma+QC1LGcnW2m/31zjkupsPl0kx3++QoeRkj77Q0jHz45DVn0FTjY9Oy5lLvimKWkL3tqXAO9+7TxMjb3tnu8QPaaTHyAEuuMMT2bZ0kIgk8HnEOddcosb2S8FZ7WXK5OBYyRskbzvaJCZ+KkbchSmwvY362vYdQLMmKllouXTGnpPsiI727iuxsf8GIkF+/oNEWYmtHoxDGCxXbY4mU6Y6XKQJ2x4yRj+TubF/kkAh5yflLxI3G0525ie0D40JYmVOjnO0KhaKCaFomvg51Fuf1R8RCRlvEyAN0nAvJGPTusu41hzrB5YW6+da9ZimYty5/Z3s8AuO9DhXbV2cvtuu6fWoVFApFVkjHbS6R0E7s5JZIp3+28ekyEMBpY+HzuAh4xRRgrr3t6W5u57hVpbM9F3PAuCkuO2ccAGr9Yu4m10UYIQcnYkzFdYbY/qdXjxNPipU56cVKlTMOU7F0bi1P/cOV/Nfb1pV6VxSzhIyR1yM5iO3TxMjb3tmuacLdnsHZvvDShbg8LoY7hznx8gl8PvG7uqtVZ3ulIXvb92/Zf/oPvQFC3pX09TUrZ7sNUWJ7mZJIprjziS4APnDJkpILzwsNt3X/eDTnHqdceLFnGCj/vnbJAsPZ3lNgjPyR4QgpHQJeFy1BZwirDVXy5jX7G3mn9dZLzlsinO27e0cZyWHxwYBytisUikpEuq2LFSU/bIjtdonNbj0L3H5ro+QHO6FxEbhsLiTMWycWIaRSuT93uFt8daLYPnc1DB9Ku0amIzwonBfK2a5QOIb8YuTTjl2nYUZkR7O7D4ubMfLOE86kuz1XsT3kwMUYjaazPfuxkGK00zrKg/50xUAuyEUYldTPvXFxE3NqfYxE4jx5YABQMfKn4vMoqaGSCDQIsZ3YWPZPmiZG3vbOdhCO/Qz3Yf6gn/nni8Xue+/bi9crPn80v7MMZ4qZWXGd6G0/9OghoqOnJxi+FPw6r756hupstyHqE7BMeeCV4xwZjtBU4+PNG0rvOqqv8pod2sXsbd91RHS8rF/QULRtWIlVznYZz7+oqabkCyusQh4vI5HsV4o7rbde0hIMsGRODboOzx3K3t2uOtsVCkVFUt0EgQYYOFCc1x8+BFWNIobcDnh80L7eWrF9qNMZIvO8syE2nt/CjKEu8bVhkaW7VBa0rBJfDz8782OHD4mvdll8olAoZiQttmcnnOm6Tjju3Bj52hwXH8QcGiMP6d72bF3+EikmOqWnHNLzFbk422U1g9PEdhkjn7Oz3XhPVTtsPKbD7dK45syTo+QjcTFuKkZeUYn46/3EYl602Hj2T5JCtOf0GHkpPNrW2Q5iEUEGZzuke9v3/m4vXq9xzs3g8Fc4m6blTTStaCIVT3HwwdPnMuKGcVHFyNsPJbaXKd97TESn3nzBwrK5yZPR3t2DxeltHw7HTLF1bXt9UbZhNenO9sIWIDitrx2gwbh5HcphpbgTx0Fy/uImALZ3DmX9HBkj32znFZ0KhUKRD83L0r3iVmPHyOyO8ywW27ug0cZ97ZI2I6Ly2Iu5P3eoC9w+CM6zco/Kg9azoO1s+OWt0Ldn+seatQrK2a5QOAXpMs22sz2aSKHr4v+d6OauzVFgjibF4ncnulRNZ3sOaWswqavcQd3cjcY99mBOMfLO666HSVULytmeFTJK/oGXe0mmdCLGCh0nLlZSKGbCX+8nGvXjSuYwLx4PC6HddbosdXzncQCaVjRZtYuzzxQx8pDubT++47gZI5/J4a9wPis2C3d7pt72uHGd5ql23nW501FiexnyYs8wzx0awuvWuOXC8nHbyGjvYvW2S1f74uZqs++73JHO9iNDEXQ5Q5EHMj7dSSJzvRHLNpylsz2eTHFkWFyMOK2zHeC8JeJC8enOgawen0rpDKoYeYVCUak0LS1ujLzdIrM7NorY8/EThb+WrguhuckBYntNs1g4kU9v+1CXcLVnmOSxPR4f3PJrqJkLP7ge+jN0wUmGu4WbotrGE1oKheIkco2Rn+yAd6IzszZHp7+MkXfiWATzdLaHHelsz732Th5DjnO2+5WzPRcuXNpMQ7WXgVCM7Z2D5qIDJ54zFIqZCDQEiMW8uFI5iu1TCMxHnjoCQMcFHVbsXmnwVkF0JOOPOjZ1mNHgMkYer3O0AEX2SLF9/5b9p2lKiYj4XFHOdvvhwNkl+yNd7deva6elLlDivUmz0BBAZeS51ew8LD6IzupoKMrrF4N5DQFcmnAD9I2d3rGRLd2mo9s5InM6li27m9cjQxGSKd1RvfWT2bSsGYAdPcP0j898rIxOxEmkxIdtk3K2KxSKSqOoYnu3/cT2+RvF12xiwWdi/LiY4HCCsx2Eg7t3Z+7PG+pyRpT+VNQ0w3t+KyoZfnD91O+n4R4RIe+QGiOFQjHJ2Z6luCyF1IDXhdvlvHNBbY591HKNghNdqnVV+XW2m2Kig8akyYgolgvcs0G+p2ocJi7LRRjZpmFIKtXZ7nW7uHp1KwB/fOkYE3HV2a6oXAL1orPdrecgtsfCGQXmeDhuOts7LrSx2L7gAtj9e4ieHq3v8XtYeImYizCd7Upsr0gWvWYR3movY0fHzONeImPkVWe7/VBie5lxdDjCll3HALj1kvKaBJXO9mJ1tu8yxPaz59sjQh7ERfa8ehEl31NAb7t0ti92kNjeUJXbSvGuSb31LgdO8sxvqOLsjnpSOtz/cu+Mjx8wbvqDAQ9+j7ppUygUFUbTUhjvzXiDWhC6bs8Y+foOqG2zJkpexvM7wdkOMG+dcLbnmjDkdLEdoHYuvPe3wjnygxtg6NDpjxmxYdKDQqGYFtPZnqVwFjGFImdO6Jl91MrZnndnuxOd7Q2Gs30kEieRTGX1nHGHiu1yQUqux0Uo5uxzx3Rcd5aIkv/jy73mOJRLBahCMZsEGoTY7nHlMCcezyy2H3v+GKlEitq2WuoW1Fm4l7PMptsgOgbP/yDjj2WUvNnZrmLkKxJPwMOSK8WxcGqUvIyR99ok+VmRRontZcYPnzxEMqVz4dImziyz3vJFprO9uDHyZ3WU1+89E/ML7G1PpnR6BmV8unM+YGVne7Yx8vK4WuigMTiV69aKXtg/7MpCbB8X4zan1nkuf4VCoZiRpmXi65DFve2hPkhM2E9c1DQRJW+F2C7H1ClC87x1EBmCkcPZP0dG6TtlDKYj2Abv/R24PMLhfuo4DXfbb/GJQqGYlpocY9OlkOpEcRnSAnG2YrtRv+xIl2qd6mw3aZgUzTqS5Xg4PkY+1852h45HNly8fA5Bv4fjo1Ge2N8POPOcoVDMhOxs97jikMgy8XWKGPnDT4v7lI4LO9DsnLrVsBDOehs88Q1InD4nLgVWFSOvmBwlPxkVI29flNheRoRjCX6yvRuAD1xcfm4jKQQfHYkQTWTX/5Yt/eNRjgxH0DRYayNnO0CHKbbn52zvHZ0glkzhdWvMqy+f2oBCkWL7RDxlxmpNhxTbFztYbH/9WUJsf/LgwIxxdQNG1HyzipBXKBSVSNNS8dXqKPnhHvG1wYbiYsd5cOR5SBV4DTbYCcF5okvOCcw7W3zNpbc91G9E6S8uyi6VHXXtQnBHhzvfAKNH0z+TMfIKhcIxmDHysew+L2QUtFOFIhmRnW0ftRTbnRSZLsm3sz3iwJhsj9tFvTGJPRTOziAwHnWewx8mpT/kWC9gOtsdtAgjW/weN1esbgFgh5HS6aT3h0KRLYGGAAMDjeIffXuye9IUMfKyr33+BfOt2r3ScfHHYewo7PzZaT+ad848/PV+fL44yZQb3EpQrVSWX7ccgJ4neohM0pVkjLxyttsPJbaXEb987jAjkTiLmqu50uj/KSeaa3zU+j3oOqYT2yqkq33Z3FrbrYpd0CguEPJ1th/qF/HpHY3VeNzOeUvW+j1m5182UfKHZIy8g6L0T2VhczVr59eRTOkzRsn3G2K86mtXKBQVSXUT+Oth4IC1rzsiFjXa0snbcR7EQ3Di1cJeZ6jTWSJzcB7UzM1NbB/qEl8bFxVll8qShgXw3vsgGRcO97HjEBmG6Ij9kh4UCsW05Opsj8ScJ6RORs4vROJJkqmZK0diSXEP60Snfz6d7bFEinhSjJvT4sIbq6XYnpuzvcZh4nIwD2e7ruvp8XDYcZEtMrlQomLkFZVIoD7A8eNz0HUNendm96QpYuQnO9ttT8sqWPUGePwrpy2Wd7ldLL5sMV5vnKSu0kwrmYZFDcw9cy56SufAA+m5L+lsV53t9sM5yp7NSaV07ni8C4D3X7TYFCnLCU3TWNgke9tDlr62HfvaJYU62w8NCpHeSRHyII4XGc2WTZS82dnusHE4FXlDtmXXsWkfZzrbVYy8QqGoRDQNmpcWwdneDb4gVDVa+7qzQft60Nxw5NnCXmeoCxrLL0EpbzQN2s7OfnIH0mJ7QwWJ7SAWF7zvdxALwQ9vgKMviO/XK7FdoXASecfIO1Rsn9yvnY2YGDVj5J03wZmPs10mH4DzFmQ0GgvbZ0qdkzg1Rr4mj872WDJFwli8UonOdoDXnjH3pEU5TjxnKBQzEWgIEI/7GBxqhGM5iO2nxMiPHR1jtGcUzaXRvrG9CHtaAi75GxjYD6/+7rQfrb5xNV5vHN3tnIRbRX5kipI3ne0qRt52KLG9THhozwk6+0MEAx7etrF83VaL54gPwy6Le9t3HrZnXzsIRzrkL7ZLkXmxAx3d9cZK8ZluXif31jtxHCYjo+SfODDA0DTjku5sV852hUJRoTQtFZHnViIjs+3YAeergdY1hfe2D3ZCk4PEdhC97bk626ubIVBXtF0qW5qWCod7ZAh+dov4nnK2KxSOIi22Zxcjn3a2O1Mo8nlc+Dxi6isbsV02oFX5nDddZna25+Bsl4sxfG4XXgcl8QE0Vot77enuyyczbjrbnfVeMWPkc3C2hyedX6or1NFd5XNz+aq5k/7trPeHQpEN/nphEDp2dC56tmJ7hhh56WpvWduCzynzoB0bYfGl8Nh/g35yss7Z7z6b8z+8Fl+TDU0ACkuRYvu+P+xDNxaxxSMqRt6uqCuBMuF7j4nJ5JvOX1jWF+4y4rvbamf7kWEAzral2C6c7UeGIqSyiKU7lUP9YuGCTA1wEnIhwt//chcvGVUBmXBqb30mFs+pYc08ESX/wCtTR8kPhFRnu0KhqHCaiuBsH+mxZ4S8pOM8OFyAsz06BuF+ZznbQYjtY8dg/ER2jx/qclaUfq7MWS463D1+cPtFDL9CoXAM6c72bJ3t4nFOdbZD2omcjdvf7Gz3lu+8TL4EDbE9H2e7E93LptiebYx8zJnO9mCOaRiQHgu/x+WoOsRcuXZSlLwTzxkKxUwEjDnc3t65ImkslZr5SfHQ6WL7U0Jsd0Rf+2Qu/QQcexEOPnTStzVNozoIms95WoAiNxZcvABf0Ee4L8zR544CKkbezlTuFVEZ8crRUZ44MIDbpfHeixaXenemZVGT9c7246MTHB+N4tJgzTz7ie3z6gO4XRqxZIoTY9Gcny9j5GVqgJP4x82rmN9QRfdgmLd86wl+9NQhdP30BQmylsBpvfVTsfmsNgC27JpGbDec7SpGXqFQVCxNS2HsqFj5bhXD3fZ28XacB327Rdd2PsikAMc5288WX7N1U1S62A4wdyV84I/wxm+Cy/nXXgpFJZGrsz1sWLmd7E6V4uhIZGZR1RTbHbj4oM6YtB3NYhwk8jhyYi93urM92xh5YywcJrZPdrZnmq/JhEw8cNpY5MoVq1rM5AwnnjMUipnwBDy4/W6OHWtBi4dgKItkunjktBj5I08fARzS1z6ZpZfDvPXw6JdP/1ksDF5np7sqZsbtdbPsmmUA7NuyD1Ax8nZGzayUAd9/XHwQXbu2jfkNVSXem+mRznYrO9tlhPwZrUFbXpx63C7TjX14KDdBQNd1cywXOTA+fVVbHVs+dilXrW4llkzxz79+iY/+5IXT4skODTizt34qNhtR8o/v72d4ihv7gZAU25WzXaFQVChN4oYjqxv2bND1dIy8Xek4T3w9+nx+z5dj6TRne+MS8NcL10A2KLFdMGcFnP22Uu+FQqGwGCmKZt3ZHpUx8va7F8+W5S21ADx5YGDax+m6jqEhOnI8JjvbcxVV7ThXMxOysz33GHlnjYVcjBJP6kQTWbhSSZ9fnPg+yYVav4fbL1/OugUNnLtIxUErKpNAQ4De3hbxj2yqvU6JkU8lUhx9Rjh6Heds1zTR3d716OkJdfEQeMtbB1LMDqf2tqsYefuixPYS0zcW5Tcvig+UWy8p/4lP6b4+PBQhkczuInwmdh0eBuCs+fZztUtklHyuve394zHCsSSaln4Np1Ff7eX/vedcPrN5NW6Xxn07j3HD1x/j1WOj5mNkb/0iB0bpZ2Lp3FpWtQVJpHQeeOV4xscMjIuUhDnK2a5QKCqVpqXiq1VR8hPDEBuzt7O9aRkE6uHwc/k9f7AT/HVQ3WTtfpUaTYP29bDjJ0JIn45EFEaPKLFdoVA4FikERuJJklnUnEkxtdrBDtVrzxTJYn94aepkMRBiYwoNcKa4XGc4mGPJVNaiqoyRr3HgeDRJsT1rZ7szY+QnpxZk29tuOtsdmHiQKx+7cgW/ue1ixx0XCkW2BOoDhMPVJPwtIkp+Jk6JkT/x8gni4Tj+Oj9zVzuw3mr19dC8XHS3TyYWBp/zjHeK3Fl+7XIAjjxzhNCJkIqRtzFKbC8xTx0cIJFKsX5BA+csLP9VkK3BAD6Pi0RK5+jwhCWvudPo8rZjX7tEdpPn6mzvNiLk2+ur8Hucd/Mq0TSND75mKT//ywuZVx/gYH+IN33zcX72TDe6rtNtOtsr5yJDutv/sOvYaT9LJFNmb1yT6mxXKBSVSs0c8AWtE9uHu8XXehuL7S4XzN8Ih5/J7/lDndC4SIjTTuO6/4BUAr5zGRz889SPGzkM6EpsVygUjmVyrHM4i972SNxwqDo4Rv7qNa24XRqvHhudNqUvEk9H71c5cDxqfB7zEmB0Ituecpl84LwJ33SM/MxjkUrpjo1Od7k0Uygen8hObA851OWvUChyJ9Ag0l4nAmdkV+sVj5wkMsu+9vbz2tFcDrxPdbnh4o/D7vvgxO709+OR07rrFZVJsD1I24Y20GH//fvTMfLK2W47lNheYq5f184jf3c5n3/T2lLvSla4XJrpPj40WHiUvK7r7DJi5M/qaCj49UrFAkNs7xnMzdku+9orJT793EVN/P5jl3LZyrlEEyk+/ctdfPLnO9h7fAxwZm/9VEix/bH9/ad1Bw4aK+s1DRqrldiuUCgqFE2D5qUwcMCa1xvuEV/tHCMPIkr+8DMiFj9XhrqcFyEvaVkFH3xIdOL96C3w5Lcyj5GM0m9YNKu7p1AoFLOF3+PCbUxWS3FwOpwcEy5prPGxaWkzML27XYrtXreG1+286TKXSyPol73t2YmqkZhz48LlvXY2MfKhSQtXnOhgNsX2XJ3tDhwLhUKRG4FGIbaPJhYLZ/t096nJBCRjJ4nMju1rn8zZ74BgOzz+lfT3VIy8YhIySn7Pb/aQMtKHVGe7/XDe3YMN6WisZq2NItSl+7hrIDcXdyaOjkwwEIrhcWmsagsW/HqlwoyRH85tTA4NCHG+khzdTTU+7njveXzqdStxafCrF45woE8s3FjYVDnjsLylljNaa4kndf50SpT8wLi42W+q9pkTZQqFQlGRNC21ztk+0gOeANTYPJqu4zyIDOY3LoOd0ORQsR1EPP7Nv4BNfwX3/wPc+2HhGJjMUBe4PFDnsD5AhUKhMNA0zYz8zkY4CzvYuTyZa9caUfIZksUkEWMsAg50tUvSve1ZOtujzq0ZkJ3tg1nEyMtxcLs0/B7nTaVKh/pYts52By/CUCgUubHwEpEct//FGgj1wdg0lS1xw7g3SWSWznbH9bVPxuODi26HXfekE/dUjLxiEmZv+x/2m99TMfL2w3lXiIqiI13Yh/oLd7bLvvaVbUFb39Dm29kuY+QXV4izXeJyadx2+XLu/uCFtARFJ7lLgwVNlbWiT7rbt5wy4TNorKxvrlWudoVCUeE0LRUCsRUMd0P9AvtHqM8/R3w9/Gxuz0vGRYS6U53tErcHrvk8vOW78Mqv4Y5rjeh4g6EucRy41Y2rQqFwLtJtGspCbI+YYrt978ez4ZozW9E02HF4hCPDme/bzYUHNp6bmIk6wyU1mqWo6uTOdulsH4nESaamTwySC1dqfG40u19LZqDWWISRrbPdjJF3+CIdhUIxM6tvXA3Aiw8IN+60ve1yIbQhMk+MTNC/ux+Ajgsc7GwHOOe94A/CE98Q/1Yx8opJzL9gPlVNVWaEPIAnoD5j7YYS2xU5I4VhGYFeCDsP27+vHaDDiNY/OhyZ8SZtMt0VFiN/Khcubeb3H7uUt2yYz8evOsPRvfWZeL0htj+6r/+kzrz+8SgAzTX+kuyXQqFQlA1NS2H08Onu5HwY7rZ/hDwI93bzcjiSo9g+3A160tnO9smc/Tb4wP0QHoD/fS0cekJ8f6hL9bUrFArHkxbbs4mRF6KZk2PkAVqCAc5b1ATAH6eIkp+IV4KzXRwb2TrbnVwz0GB0oeo6p1W7nYoUoWUygNMI5rBARzxOJh4477hQKBS5MXf1XOasnsNQfy0JV3D63vaYdLYb8+jPHAUdGpY0UNPicJe3vxYu+DA8/0MI9QuXv68y9QDF6bjcLpa9bpn5b0+Vx5GL+5yOEtsVOSMjzw8NWOBsP2L0tc9vKPi1SklbXQCPSyOe1Dk+OpH189Kd7Q6/oJiGuUE/X37Hej525YpS78qss6I1yPKWWmLJFA++mo6SlzHyytmuUCgqnibjZmOoq/DXGumBhoWFv045IHvbc0F2lTvd2T6Z9vXwoT9Dy2r4wfXwzHdhsEuJ7QqFwvFIF3I2wlm4QpztANedJaLk//hS5ij5cNy5wrKkzhCLs+1sN7u5Hehg9rpd5uKDoRmi5E0nt0PFZdnZPpZ1Z7tytisUijRr3roG0BgYbYfeHVM/MG4Y9wyxXUbIO7qvfTLnfwg0Fzz1bREjr5ztiknIKHkAb7UzF/c5HSW2K3LGjJEfCJPKwcV9KrquO8bZ7nZptDfkFiUfisOIcYNbqc52RTpK/vc70+6KgZB0tiuxXaFQVDhNS8VXK3rbZYy8E+jYCL27cnP8D3aKrvL6CpnIkNTMgVvuhY23wu8/Ccd3KbFdoVA4HtPZHssiRj5eOWK77G1/9tAQJzIskp+IiQhcJ49FXY7OdikyO9XB3GTccw+FphfbzRh5B3bXA9Qax8V41p3t8rzhzPFQKBS5IaPkO18Joh/NJkZezIMfefoI4PC+9slUN8G574Pt/w8SKkZecTLLXrcMDDO7t0qJ7XbEcrH9kUce4frrr6e9vR1N0/j1r39t/iwej/PpT3+as846i5qaGtrb23nPe97D0aNHT3qNwcFBbr75Zurq6mhoaODWW29lfHzc6l1V5Mn8hio8Lo1oIsWJsWjer9MzGGEkEsfncXFGa9DCPSwN6d727OL1+42hmxv0qxuUCmaz4a54ZF+fOeGRdrarGHmFQlHh1LaAr7ZwsT06BpEhZznbUwk4No1r4FSGusTv73LmZPm0uL2w+T/gjd8ETxXMP7fUe6RQKBRFRd5fZhcjb7i5vc6/J51XX8X6BQ3oOtz/8ulR8mEzRt65vpR0Z3tuMfJOdTA3GL3tgzOI7XLRQa1TxXbj9xqPZnlcONzpr1AocqP17FYalzVy9PActJFDEBnO/MBJMfK6rleesx1g021ph7+vcpNuFadTM7eG+eeLhSeeKmdebzgdy+8gQqEQ69at45vf/OZpPwuHwzz//PP88z//M88//zy/+tWv2LNnDzfccMNJj7v55pt5+eWX2bp1K/fddx+PPPIIH/rQh6zeVUWeeNwu5hvCclcBUfI7Dg8DsHpeHT6P/W9m02J7di6zgQmxVGmxcrVXNCtbgyydW0MskWLb7hMA9KsYeYVCoRBomugYHzhQ2OsM94ivThHbW84UonEuUfKDnZUVIZ+JDe+GfzwCSy4t9Z4oFApFUak1BLBwNs72CoqRB7jOcLf/IUNvu+xsr66Izvbc4sKdGq3fZMS09swwj2PGyDt00UFQOdsVCkUBaJrG6htX09vbIr7RuyvzAyfFyA93DhPuD+P2uWlb3zY7O1oO1M+Hde8U/++tKu2+KMoOGSWvYuTtieUK53XXXcfnP/953vzmN5/2s/r6erZu3crb3/52Vq5cyYUXXsg3vvENnnvuObq7uwF49dVX+eMf/8h3v/tdLrjgAi655BK+/vWv89Of/vQ0B7yidFjR2y772s+eb+8IecmCRiGa9wxm52zvM1LrKrmvXSEuSF9vRsmL7sB0jLxytisUCgVNSwt3to8YYrtTYuTdHmjfAIefzf45Q11i4UKlU4nOfoVCUXHUmC7V6YUzXdfNqHmnxoSfynVrxb3X052DDIyfnNQnXdwBB4vt6c72LGPkHe5s37CwEYAvPbCHl4w5qkyMGykRTo2Rr8m3s71CzhsKhWJm1rx1Df39TcTjHpI9L2R+0KQYeelqb9vQhseh59Ypufjj4K9zjhlAYRlrb1qLt8bLgosdMndVYZT8TDYyMoKmaTQ0NADw5JNP0tDQwMaNG83HXHXVVbhcLp5++umMIj5ANBolGk3fKI2OjgIiuj4ez+4mwmrkdku1/WKysDEAQGffeN6/346eIQDWzKt1xBjNqxMu5J7B0Iy/Tzwep99wtnc0BBzx+yvy5+pVc/n6tv38eW8fQ+MRc9KnIeAq+Nhw8nlIURjq2FCUE9Mdj66GxbiO/IpEAceqa6ALl8tDItAMDjnmXe3n4Hrl3uzGRdfxDHWROvsdpGz2+6tzlWK2KIdjTR3nCquQwpkUj6cimkih6+L/K8WhurC5mjPb63j56ChbXznOO89PT3RXgss/X2e7UxdjfOSyZWzvHOSx/f184M5nuPe2i5nfcLrTMB0j78xxMGPks3W2R529CEOhUORO+8Z26hY0cvz4HIIvPEH9az52+oNkjLynisNPC7G9YvraJzNnOXy6Sy0EV5xG84pmPj34aVwOrjRyMiW9KpqYmODTn/40N910E3V1dQD09vbS0tJy0uM8Hg9NTU309p4e8yX5whe+wGc/+9nTvv/AAw9QXV3amO6tW7eWdPvFYLxXA9w89fIBtsT35fz8lA4vdrsBjeEDO9jSm0PnaJnSPQrgYd/RQbZs2TLj4/snxAfqUPcetmzZXdydU5Q1ug5zA276JlJ85WdbOT7iAjR2Pfskx1+2ZhtOPA8prEEdG4pyItPxuHBgnPUjh/njfb8m5cqvXmPNkT/T7mniT3+8v9BdLBva/n/27js+qir///h7Jpn0TkmBkNCkl1CliKg0sax1F3UVdVfWvlh33d/aWNfesZe1l/2uFRsCIqKICNI7AUILCSW9T2bu749hRiIMpN6ZzLyejwcPyMydO5/kvrm5Z8495xSHanjJHi1/7z7lxQ865rbh9iJNspdr2daDyjt4/GsUf8S5CmbxZdYqKuo3QxZwPO4OsOONbD+8Mz4ygEdz/9bpfVO0LrdEX63Nq9PZXmUPgpHtjVyzPVCn1reFWPXcHwfpwucXa1N+qa58ban+d80IzwwAbmWeNcoDs3PZM418A0e2B+pNGAAazmKxqOd5PZW3pb1i2x9jGvnQSMlq1Z6f9kgKsvXaD0dHO7wICeCbPgOdz64S7Xa7fv/738swDD3//PNN3t8dd9yhm2++2fN1SUmJ0tPTNWHCBE9Hvtnsdrvmzp2r8ePHy2YLrHUWwjfu0yc7VsoeHq/Jk0c0+PXb9per+qdFirBZdfl5kxQa0vrv1tlbXKWn1y1Usd2qCRPHH/N7stvtunPZfEnS2aeOVP+OgTGVPhpvU9gWPb9wu3Isyap2HJAknTd5vOfDkMYK5PMQmoZswJ8cK4+WnQmyvPWqJp3YW2p7QqP2H/LRh1LkCZo8eXJzlOsfjElyfrBZw7a/rNpTPpdS+nnd1LJribRWGjTuAql9LxOLbDrOVTCLP2TNPTsb0FTuqZ237y+XYRiyWCxH3c7dYRYealWI9ejbBKJJfVP16JzN+nHrARVX2hV/qM1VYQ/8ke3uTuSC8pp6bV8R4NOnS66fyX+uGKpzn12kTfmluvbt5XrtiqGyHfaZTnmAd7a7R7aX17OznZHtAI6m9/m9tXp6ew0atEaO8jKFRMfU3cBeIYVFqba6VnkrXYMqOw4P0s52AAHHJ1dF7o72HTt2aP78+XU6w1NSUrRv374629fW1qqgoEApKSle9xkeHq7w8CPXN7bZbD7/YM4famhu3ZJdx2znwUqFhoZ6bbx7syHfNW1Mn7R4RUYExrrUHZNCZQuxyO4wdLDSoY6J3r+v8upaldhdP7NuyfEBlw803BkDOuj5hdu1cIuro90WYlFSbGSD/295E4jnITQPsgF/ctQ8tnN1sNtKdkqpfRq345I9UruesgZa1i94RXrtdNn+90fpqvlSrJdr5RLXmvW2dt2kVvoz4FwFs/gya2QczWVsj/Z6aPZGLd52UF+uydMZ/VOPul0wTJt+NN3ax6h7+xht2Vembzbk67xBrg/63SPbA3mU/wnJro6PbQfKVVRRo4SoY88aVO4ewRzgGemQEKn/XD5Uv39xsX7IPqD/9/EaPXR+f0973P1ziAnwzvb6rtlezprtAI4ifWS6vq/JkNVqaOeX89TpwnPqblBTIdmilbciT44ah6LaRSmhc4IvSgWAZmf6cGJ3R/uWLVs0b948tWnTps7zI0aMUFFRkX755RfPY/Pnz5fT6dTw4cPNLhdedEyMksXiuhCv7x3Rh1u9u1iS1K9D4IzotlotnrW9dhdWHnPbXYeeT4i0KT6KD9Ug9UmLU0abKM+aiW2iw5utox0AWrXYFMkWJRVsa/w+inZKCenNV5O/CIuWLnpfMpzSe1NcH14cTeF2KSZZCvPt0koAAHN0ax+ja8d2kyTdPWutCr202T1ThAfh6NTT+7luQPhyza/LFbp/HpEB3LHcPi5C3drHyDCkn7YdPOa2hmEcdkNG4Gekb4d4PXNxlqwW6f+W7daz32Z7nisL8BH+MRENW7PdPeNBMOQCQP1ZrBYlnXSSnE6LCn9YcOQG9grJ9ut67R2Hd+SzTwABo9k728vKyrRy5UqtXLlSkrR9+3atXLlSO3fulN1u1wUXXKBly5bpnXfekcPhUF5envLy8lRT42r89erVS5MmTdJVV12ln3/+WYsWLdL111+vKVOmKC0trbnLRSNF2EKUGhchSdpR0PC1BdfsKZKkgJs+vWOi60Ps43W27zjo+pl1Sops8ZrQOlgsFp3e99cRJ21iGrcuMQAEHItFSuoiHdzauNfbq6TyfVJ8AHa2S1JcmnTxf6X9m6SPp0lO55HbFGyXEjubXxsAwGeuPaWrTkiO0YGyGv3r8/VH3SYYOpe9Ob2vazaYhVv2e9aprrK7focG8sh2SRrV1TXoZVH2sTvbaxxO1Tpdd4MHy9rcp/ZM1r1nu2ZSenTOZn260rWmsHt69ZgA/TnEhrsGgdRnzfaaWqdqHK7/K0wjD+C3ep4/UAcOJMm5e5Wctb9pmx6aRt69XnuHEzv4oEIAaBnN3tm+bNkyZWVlKSsrS5J08803KysrS3fddZf27NmjWbNmaffu3Ro4cKBSU1M9f3788UfPPt555x317NlTp512miZPnqzRo0frpZdeau5S0UQZbaIlSTsOljfodQ6nobV7XOsRBl5nu3tk+7FvQHDfoNApiRFm+NUZ/Q7vbA+M5RUAoFkkdW78yPZi113zSujUfPX4m9QB0vmvShs+l+bPOPL5whzXzxAAEDTCQ0P00Pn9ZbVIH63Yo2837jtim0p7cEwRfjQ9U2KV2SZKNbVOz8/Gc/OBzfRJIE01omtbSdKPWw8cczv36GVJigrwGxAOd+mITE0b00WSdNv/VmvJtoOBv2b7oZHtFTUOOQ7dYOGNe7YDKThv1AFwbBljMrS/IFXtEnO1Y+GOuk8emkb+8JHtABAomv0qcezYsTIM7xdmx3rOLSkpSe+++25zloUWkNEmSou3HVTOgYaNbN+6v0yVdoeiw0LUuW1MC1XnG+mHOs8/XL5b63NLvG63Mc/1XEYbOtvxq74d4pSeFKldBZVqG83IdgDwSOoirfukca8tOtTAD8Rp5A/Xc7I04V/SnH9KbbpJWX/89bnC7VK3cb6rDQDgE1mdEnXlqM565Yft+n8fr9HXN41RbMSvy5j92rkcfB1mFotFk/qm6oXvtmr22jydNSBNlfbgGOk/oksbWS3S1v3lyiuuUkp8xFG3qzj08wgLtSo0JLBvQPitv0/qqV0FFfpqbZ6mvfWL57PMQO1sP3zt9bLqWsVHel/u0L1ee1iIVWGhwZULAMdnDbXKSOmv5Oj/05wP1qrzqYfd9G2vUK0RpqLtRZJFShvKLMYAAgdXRWg098j2nQ2cRt69XnvfDvEKsQbWuiw9kmMlSbsKKjVnfb7XPzsLXNPM90yJ9WW58DMWi0XnZrnu6uzaPrBuRAGAJknqIhXvkmqPvubsMRXvkixWKS4Ipqgbcb00aKr02XQp5wfXY9WlUvl+RrYDQJC6ZUIPdUqKUm5xlR6avbHOc7+u2R7YncveTO7nmkp+/sZ9qqxxeEbsBvrNB/FRNvXt4JplcPE276PbK9yjuYMwH1arRU/8YaCyOiWouNKukir3NPKB2dkeHhqisEM3VBxvKvmKQ53twbK0AICGSxwxRjZbrfZ9u0jG4bNl2CtUeWhsWrte7RTh5WYvAGiNAvMqEabIPDQqO6eB08iv3l0kKfCmkJekU3u21wt/HKyD5dXH3M7hcChn41qN79XepMrQWtx4ajdldUrQiZ3b+LoUAPAfSV0lw+kapd62e8NeW7RLik2TQryP0AkYFot0xmOuaeP/+0fpz9+41sWTWLMdAIJUZFiIHjy/ny5+eYne/mmnzuqfpuFdXG0Nd+dyVIB2IB5Pvw7x6pAQqT1Flfpu8/6gGdkuSSO6ttHq3cValH3Qc8P3b5V7bsYIznxE2EL08mVDdN5zP3oGmQTqyHbJNZV8QXmNZ8p8b8oPLS/Aeu0AvEmZNEHaIMXbcrTrx13qNPrQkm41FSotcC3BynrtAAINV0ZotE6HOtt3HGzcyPZ+HROauySfs1otmtQ35bjb2e12fbl/TcCN7EfThYZYdUoPbsIAgDqSXOtmqmBbIzrbdwb+FPKHC7FJv39DemW89M6F0qi/uh5nZDsABK2RXdvqomHpeu/nXfr7R2v01V9PUoQtxDMddDCtx30411TyKXr1h+2avXbvr53tQfDzGNW1rV78bpt+zD4gwzBksRz52YRnBHMQ3HzgTduYcL12xVBd+MJiWSS1jQnc5d5iwl2d7aVVx+lsr3GvXx+8uQBwbCHxbVRub6uUlH1a/+H6Xzvb7eUqzXd1R7FeO4BAwzTyaDT3NPIF5TUqqbLX6zV2h1Pr97rmi+nfIfBGtgMAgBYQmyqFRrg62xuqeJcUH0Sd7ZIUmShd8n9SZaH01e1SWKwUxYwpABDM7pjcS8lx4dp+oFxPzNss6bCR7UHcmXr6oZvlv9mwT2WHOhmDobN9SGaibCEW5RZXeR1AUVEd3DMfuHVtF6Nvbx2rb245WeGhgZsN9xT5x51Gvjq4ZzwAUD/Otn2VkrJPGz7cIMNwTSVv1FSqcI9rabiOJ9LZDiCw0NmORosJD/Xc1buznqPbN+eXqqbWqdiIUGUcGhkPAABwTFara3T7wa0Nf23RLimhU/PX5O+SukhT3pGcDikx0zXFPAAgaMVF2PTvc/pJkl5euE2rdxd51myPDOJOs0GdEtU+Nlyl1bWeadODYRr5qLBQZXVKlCQt2nr0dds9I5iD4OdxPPGRNiVEBe6odsk1jbwkz00n3jCyHUB9RPU7Uamp+1Wyq1i5S3MlSc7KUlWVWWWLtqldn3Y+rhAAmhed7WgS9+j2+q7bvubQFPL9O8YfdZoyAACAo0rq0vCR7Q67VJobXNPIHy5jpDTlXWns33xdCQDAD4zrnayzBqTJaUi3f7BaJZWuGeqCeWT70ZaCC4aR7ZJrKnlJ+nHrwaM+z8wHwSXWM7L92DNXbt3v+vwv0ha8N+kAOL6Q9CxFRlYpPr5U6z9cL0kyqsplt9vUYWgHWUPolgIQWDiroUkyGrhu++o9h9Zr75DQUiUBAIBAlNS54Z3tJXskwxl808gf7oQJUq+zfF0FAMBP3HNWbyVG2bQxr1SzVrlGmgV7Z+oRne1B8vMY2c21xMzirQfldBpHPF9ew3ThwST6UGf7sdZs/3bjPj0zf4sk6eQejEoFcAyp/SWpzlTyFmeVq7N9eAcfFwcAzY/OdjRJRpJrZPuORoxsBwAAqLekLlLRTtdo9foq2un6OyGjZWoCAKCVaRMTrnvO7iNJqq51SgqezmVvhmUmKSnaNUW4RYbCQoJjFr4BHRMUFRaigvIabcovPeL5imqmCw8mnmnkvazZvnZPsa57d7mchnTB4I764/AgXKYJQP3FpsqIbKsO6QdUuLVQ+Sv2KMRSq5oaG+u1AwhIdLajSTLb1n9ke3WtQxvzSiRJ/TrQ2Q4AABogqatkOH7tQK+Pol2uv+NpzAMA4Hb2gDSd2rO95+tgH9keGmLVhN7JkqSwEAXNkndhoVYNzUySJC3KPnLd9go7I9uDiWca+aOMbM8tqtSf3liqihqHRnVro/vP7Rc0/08ANJLFIktaf3XpWyZJWvvWz5LEyHYAAYvOdjSJe832+nS2b8orld1hKDHKpo6JkS1dGgAACCRJXVx/N2Qq+eJdUnR7yRbRMjUBANAKWSwW/fvcvoo51LmWEBnm44p87/R+qZKk6CDrVx51aCr5o63b7h7ZHuw3YwQL9/mgvKZuZ3tplV1Xvr5U+SXVOiE5Rs9dMlhhoXycDKAeUvqrXZs8SdLaN1yd7bb4OMWmxvqyKgBoEVwdoUkyklwj2/NKqvTd5v1yHGWdL7fVh6aQ79cxgTtgAQBAw8R1kELCpYPZ9X9N0U4pgSkuAQD4rdT4SL06dYiuPrmrRndv6+tyfG5M97b6+6QTdEFnp69LMdXIrq5jv2TbQdkddb931mwPLu5p5A9fs93ucOrad5ZrY16p2sWG6z+XD1V8pM1XJQJobVL7K6x2n6LjqmRVlSQp4YQ0HxcFAC2DznY0SUKUTSlxrtFiU//zs0Y/NF+Pfr1J2w8cuYb76t1FkqT+TCEPAAAaymqV0odJaz+SDO8399VRtFNKSG/ZugAAaKWGd2mjv5/eU7YQPhqyWCz606hM9Ums5zVGgOidGqeEKJvKaxyeARJulYc621mzPTi4R7a712w3DEN3frJW3285oEhbiP4zdag6Jkb5skQArU3KAEnSoMmhCgtznVuSerPEG4DARIsKTWKxWPTOVcN12YgMxUfatLe4Ss98m61THl2gC1/4Uf+3dJfnQt3dcOvfkc52AADQCCNvkHb/LO1cXL/ti3cxsh0AAMALq9WiEV1cU8kv3lp33Xb3dOKRNjrbg0FsRN01259bsFXvL90lq0WaeVGW+vFZHoCGSuoihcWox/Bq2Wx2SVK7ARk+LgoAWgad7Wiyru1iNON3fbXkH6fp2YsHaWyPdrJapKU5hbr9w9Uaet883fx/K7VlX5kkqX/HBN8WDAAAWqdu46V2vaRFTx1/W6dDKt4txTOyHQAAwJuRXV2d7Yuy667bXlHtHtnONPLBICbcNT18WXWtPl25R498vUmSdM/ZfTSud7IvSwPQWlmtUnJfJbfLV9Sh+3Xa0tkOIEDR2Y5mE2EL0Rn9U/X6FcP0499P0+2TeqhL22hV2h36aPkeOZyG2sWGKzku3NelAgCA1shqlUb9Vdo8W8pff+xtS/MkZy0j2wEAAI5hZDfXuu2/7CxUld3hebzC7hrhHBXGyPZg4F4uYGdBhW7732pJ0p9Hd9ZlIzJ9WBWAVi+1v0IL1umMJ8dKkmyxzJIBIDDR2Y4WkRIfoWvHdtM3t5ysD68ZqYuGpSs5LlyXDO8ki8Xi6/IAAEBr1e8CKa6j9OPTx96ueJfrbzrbAQAAvOrSNlrJceGqqXXqlx2FnsfdI9ujwhjZHgzc08hX1DhU43BqUp8U/WNyLx9XBaDVS+kvHcxWXGK162tbpG/rAYAWwhUzWpTFYtHgjEQNzkj0dSkAACAQhNikEddKc++STvl/UoKXaeKLdrr+Zhp5AAAArywWi0Z1bauPVuzRouwDGnVopLt7zXZGtgcH9zTykjQwPUFP/GGgrFYGywBootT+kgxp11LX16F0tgMITIxsBwAAQOsyaKoUFiP99Lz3bYp2SpGJUniMeXUBAAC0Qu6p5H/c+uu67azZHlzaxoSpR3KseiTH6pWpQxTJTRYAmkO7XpLVJu36SbJFuZaGA4AAxBUzAAAAWpfwGGnYVdLi56Qxt0pRSUduU7yLKeQBAADqYWTXNpKk1buLVFJlV2x4qCrs7mnk6XQNBqEhVn3115NkSAphRDuA5hIaJrXvKeWtkaLa+LoaAGgx3EoEAACA1mfYXyTDIS199ejPF+1kCnkAAIB6SEuIVOe20XIa0s/bClRd65TDaUiisz2YWK0WOtoBNL+UAa6/bdG+rQMAWhCd7QAAAGh9YtpJAy+Rlrwg2SuPfL6Ike0AAAD1NeLQ6PZFWw+oosbheTwqjEkxAQBNkNrf9XdYlG/rAIAWRGc7AAAAWqeRN0iVBdLKd+o+bhhMIw8AANAAo7q61m1fvPWgKmpqJUnhoVZGOgMAmiblUGe7LdK3dQBAC6KzHQAAAK1TUmep9znSjzMlR+2vj5fvl2qrmEYeAACgnk7skiRJ2phXqp0FFZKk6HBGtQMAmiilryQL08gDCGh0tgMAAKD1GvVXqTBH2vDpr48V7XL9nUBnOwAAQH20iQlXr9Q4SdI3G/ZJYr12AEAzCI+VkrowjTyAgEZnOwAAAFqvtIFSl7HSoqdc08dLUvFO199MIw8AkqSFCxfqrLPOUlpamiwWiz755JM6z5eVlen6669Xx44dFRkZqd69e+uFF16os01VVZWuu+46tWnTRjExMTr//POVn59v4ncBoKWNOrRu+7wNrv/bdLYDAJrFoEulrqf5ugoAaDF0tgMAAKB1GzVd2rtK2rbA9XXRTiksVopI8GFRAOA/ysvLNWDAAD377LNHff7mm2/W7Nmz9fbbb2vDhg2aPn26rr/+es2aNcuzzU033aTPPvtM//vf//Tdd98pNzdX5513nlnfAgATjOzm6mzfcdA1jXxUGNPIAwCaweibpBOv9nUVANBiuGoGAABA69ZlrJTSX1r0pNT1FNc08gnpksXi68oAwC+cfvrpOv30070+/+OPP2rq1KkaO3asJGnatGl68cUX9fPPP+vss89WcXGxXn31Vb377rs69dRTJUmvvfaaevXqpZ9++kknnniiGd8GgBY2rHMbhVgtcjhdswVFhzOyHQAAADgeOtsBAADQulks0ujp0gdXSrkrXSPbmUIeAOpt5MiRmjVrlq688kqlpaVpwYIF2rx5s5544glJ0i+//CK73a5x48Z5XtOzZ0916tRJixcvPmpne3V1taqrqz1fl5SUSJLsdrvsdnsLf0feud/blzXAP5ENKdwq9e8QpxW7iiVJEaHWoP55tARyhmMhH/An5BHekA2YwV9yVt/3p7MdAAAArV+v30mJma6124t3SRmjfF0RALQaM2fO1LRp09SxY0eFhobKarXq5Zdf1pgxYyRJeXl5CgsLU0JCQp3XJScnKy8v76j7fOCBB3Tvvfce8ficOXMUFRXV7N9DQ82dO9fXJcBPBXs22jmtcq86WXQgX19++aVvCwpQwZ4zHBv5gD8hj/CGbMAMvs5ZRUVFvbajsx0AAACtX0ioNPIG6cvbJKtNGnCRrysCgFZj5syZ+umnnzRr1ixlZGRo4cKFuu6665SWllZnNHtD3HHHHbr55ps9X5eUlCg9PV0TJkxQXFxcc5XeYHa7XXPnztX48eNls9l8Vgf8D9lwabO9QHP+s0yS1C2zkyZP7u3jigILOcOxkA/4E/IIb8gGzOAvOXPP0HY8dLYDAAAgMAy8RPr2AanigGvNdgDAcVVWVuof//iHPv74Y51xxhmSpP79+2vlypV69NFHNW7cOKWkpKimpkZFRUV1Rrfn5+crJSXlqPsNDw9XeHj4EY/bbDa/+FDOX+qA/wn2bAzp3FbhoVZV1zoVGxHcP4uWFOw5w7GRD/gT8ghvyAbM4Ouc1fe9rS1cBwAAAGAOW6Q0/GrXv+NZsx0A6sO9hrrVWvfjgZCQEDmdTknS4MGDZbPZ9M0333ie37Rpk3bu3KkRI0aYWi+AlhVhC9HQzCRJUlRYiI+rAQAAAPwfI9sBAAAQOE68WrKGSKkDfF0JAPiNsrIyZWdne77evn27Vq5cqaSkJHXq1Eknn3yybrvtNkVGRiojI0Pfffed3nzzTT3++OOSpPj4eP3pT3/SzTffrKSkJMXFxemGG27QiBEjdOKJJ/rq2wLQQi4fmam9xZU6pWd7X5cCAAAA+D062wEAABA4wmOlk24+/nYAEESWLVumU045xfO1ey31qVOn6vXXX9f777+vO+64Q5dccokKCgqUkZGhf//737r66qs9r3niiSdktVp1/vnnq7q6WhMnTtRzzz1n+vcCoOWN652scb2TfV0GAAAA0CrQ2Q4AAAAAQAAbO3asDMPw+nxKSopee+21Y+4jIiJCzz77rJ599tnmLg8AAAAAgFaLNdsBAAAAAAAAAAAAAGggOtsBAAAAAAAAAAAAAGggOtsBAAAAAAAAAAAAAGggOtsBAAAAAAAAAAAAAGggOtsBAAAAAAAAAAAAAGggOtsBAAAAAAAAAAAAAGggOtsBAAAAAAAAAAAAAGggOtsBAAAAAAAAAAAAAGggOtsBAAAAAAAAAAAAAGggOtsBAAAAAAAAAAAAAGggOtsBAAAAAAAAAAAAAGggOtsBAAAAAAAAAAAAAGggOtsBAAAAAAAAAAAAAGggOtsBAAAAAAAAAAAAAGigUF8X0FIMw5AklZSU+KwGu92uiooKlZSUyGaz+awO+B+yAbOQNXhDNuBPyCO8IRswiz9kzd12dbdlA40/tNEl/zjW8E9kA2YgZzgW8gF/Qh7hDdmAGfwlZ/VtpwdsZ3tpaakkKT093ceVAAAAAABQP6WlpYqPj/d1Gc2ONjoAAAAAoDU6XjvdYgTobfNOp1O5ubmKjY2VxWLxSQ0lJSVKT0/Xrl27FBcX55Ma4J/IBsxC1uAN2YA/IY/whmzALP6QNcMwVFpaqrS0NFmtgbfimz+00SX/ONbwT2QDZiBnOBbyAX9CHuEN2YAZ/CVn9W2nB+zIdqvVqo4dO/q6DElSXFwcJx0cFdmAWcgavCEb8CfkEd6QDZjF11kLxBHtbv7URpd8f6zhv8gGzEDOcCzkA/6EPMIbsgEz+EPO6tNOD7zb5QEAAAAAAAAAAAAAaGF0tgMAAAAAAAAAAAAA0EB0treg8PBw3X333QoPD/d1KfAzZANmIWvwhmzAn5BHeEM2YBayFjw41vCGbMAM5AzHQj7gT8gjvCEbMENry5nFMAzD10UAAAAAAAAAAAAAANCaMLIdAAAAAAAAAAAAAIAGorMdAAAAAAAAAAAAAIAGorMdAAAAAAAAAAAAAIAGorMdAAAAAAAAAAAAAIAGorMdAAAAAAAAAAAAAIAGorMdAAAAAAAAAAAAAIAGorO9FXM6nb4uAX5o586dWr16ta/LQBDgHISj4RwEf8T5Ckezbds2zZ4929dlIAhwDgoeHGscDdfHMBPnIRwN5yH4G85VOBra6DBTc5+H6Gxvhfbv36+ysjJZrVZ+MaGOlStXKjMzUxs3bvR1KQhgnIPgDecg+Jvc3FwVFRXJarXK4XD4uhz4kZUrV6p79+7Kzc31dSkIYFwzBQ+ONbzh+hhm4TwEbzgPwZ/QRoc3tNFhlpa6ZqKzvZXZsGGDRowYoeuvv17FxcVcRMNj1apVOumkk3TzzTfr97///RHPkxM0B85B8IZzEPzNxo0bNWDAAJ199tk6cOCAQkJCaMxDkut8NXr0aN1000268sorj3ie8xWaA9dMwYNjDW+4PoZZOA/BG85D8Ce00eENbXSYpSWvmSyGYRjNsie0uN27d+uCCy5QUVGR2rVrp379+umBBx5QfHy8nE6nrFbunQhWa9eu1ciRI/WXv/xFjzzyiJxOp+bNm6c9e/YoMTFR55xzjiSREzQJ5yB4wzkI/iY3N1dTpkxRdXW1wsPDFR0drbfeektt27aVw+FQSEiIr0uEj2zcuFHDhw/X1KlT9fTTT8vhcOiDDz7Qnj17FBoaquuuu458oMm4ZgoeHGt4w/UxzMJ5CN5wHoI/oY0Ob2ijwywtfc3Eb9JWZMGCBYqMjNTrr7+uM888UytWrNAdd9zhuQODO8GC17PPPquysjJdcsklqqqq0oQJE3TnnXfq1ltv1c0336xhw4appqZGVqtV3F+DxuIcBG84B8Hf/PzzzwoPD9ejjz6q6667TmVlZbr00ku5ex569913VVpaqpNPPlkFBQWaOHGinnrqKT333HN69NFH1aNHD23evFmSOF+h0bhmCh4ca3jD9THMwnkI3nAegj+hjQ5vaKPDLC19zcTI9lbE6XTqiy++0FlnnSVJevDBB/Xpp58qKytL999/vxISEurcgcFdYcHl7LPP1pIlS9SxY0d16NBBDz74oBITE7Vt2zZdddVV6tChg+bOnevrMkpcp9YAAQAASURBVNGKcQ7CsXAOgr/5+uuvNXHiREnS+++/r2effVYxMTF688031a5dO85RQeyaa67R3LlzFRoaqm7dumnmzJlKSEhQRUWFLr74YhUVFWn58uXkA43GNVPw4FjjWLg+hhk4D+FYOA/Bn9BGhze00WGGFr9mMtBq1dbWGg8++KBx4oknGtdcc41RVFRkGIZhPPnkkz6uDGay2+2ef5999tlGly5djOzs7DrbvP7660anTp2MzZs3m10eAhjnIBgG5yC0Dk6n03j//feN0aNHG5MmTTL2799vGIZhPPzww0ZOTo6Pq4NZDj9fXX311caQIUOMDRs21NlmwYIFRlJSkvHjjz+aXR4CGNdMwYNjDcPg+hi+xXkIhsF5CP6PNjoMgzY6fKu5r5lCW+IOATSPXbt26ZdffpHdbldWVpa6devmea62tlahoaG65ZZbJEmffPKJ7rjjDtXW1uqVV17R5MmT1b17d1+VjhZWWVmpyMhIGYah0NBQTx4+/fRTzZ49Wx06dJD067pL0dHRioiIUFxcnI8rR2vCOQjecA6Cv8nJydF3332noqIinXTSSRowYIDn7lP3nagXXnihJOmZZ57RZZddprS0NP3nP//R2Wef7cvS0cLKysoUExMjSQoNDfXk4fnnn9e3336rzMxMSa7p6CwWi2pqatS2bVslJyf7sGq0NlwzBQ+ONbzh+hhm4TwEbzgPwZ/QRoc3tNFhFtOvmZrnHgA0t1WrVhkpKSlG7969jU6dOhkRERHGE088YezZs8ezjfvOn9raWuOBBx4wIiMjjYSEBGPFihU+qhpmWLdunZGRkWF8+umnhmG47gQ0DFcOvJk+fboxadIko7S01JQa0fpxDoI3nIPgb1avXm20bdvWGDRokNGjRw8jNDTUuPXWW43ly5d7tnGfr5xOp/HOO+8Y0dHRRmJiIuerALd27VojMTHReOWVV+o8fqzz1W233WaMHTvWKCwsbOHqECi4ZgoeHGt4w/UxzMJ5CN5wHoI/oY0Ob2ijwyy+uGais90PFRQUGFlZWcbf/vY3o6ioyNi7d6/xyCOPGFFRUcZf//pXY+vWrZ5tHQ6HYRiGce211xpxcXHG2rVrfVU2TLBjxw6jT58+Rrt27Yy2bdsas2bNMgzj14vo39q0aZNx2223GYmJicbq1avNLBWtGOcgeMM5CP6mpKTEOOmkk4xbbrnFqKqqMgzDNR3iCSecYEyZMsVYvHixZ9vDz1fR0dGcrwLcrl27jAEDBhidOnUywsLCjFdfffWY2//yyy/GbbfdZsTHxxurVq0yqUq0dlwzBQ+ONbzh+hhm4TwEbzgPwZ/QRoc3tNFhFl9dM9HZ7of27dtn9OzZ0/jiiy/qPP7mm28abdu2NW6//XajsrLS8/gHH3xghIWF1bk7DIGnpqbGmDFjhnH++ecbs2fPNq6++mojPj6+zkX04RfSK1asMK677jqja9eu3BWIBuEchKPhHAR/VFpaavTu3fuIRtrnn39uDBw40Jg6daqxY8cOz+Nz5swxMjIyjF9++cXsUmGi2tpa49lnnzXOO+88Y/Hixca9995rWCwWr435rVu3GjfddJPRs2dPY+XKlSZXi9aMa6bgwbHG0XB9DDNxHsLRcB6Cv6GNjqOhjQ4z+eqaic52P+N0Oo2tW7caycnJxkcffWQYhuG5C8wwDOM///mPYbFYjC+//LLO63bv3m1qnfCNhQsXGm+99ZZhGK47V397EX248vJyY/HixWQDDcI5CMfCOQj+xOl0Gvn5+Ua/fv2MJ554wjCMuuerjz/+2EhMTDReeOGFOq/Lz883s0z4yPLly40PPvjAMAzDqK6uNu655x6vjXmHw2FkZ2cbubm5ZpeJVoxrpuDBscaxcH0MM3AewrFwHoK/oI2OY6GNDjP48pqJznY/ddVVVxkdOnTwnFBqamo8dyJefvnlxsknn2xUVlYaNTU1viwTPrZt27YjLqIrKyuN77//vs5JBGgozkGoD85B8Ad33nmnERUVZWzevNkwDFejze0f//iH0bVrV6OsrMyzFhOCU3l5+RF3z1dVVRmfffYZHzaiSbhmCh4ca9QH18doSZyHUB+ch+BrtNFRH7TR0ZJ8cc0UKvgVwzBksVg0ffp0bd68WX/4wx/0/vvvKy0tTbW1tQoNDVVGRoa2bdumiIgIX5cLH3HnpHPnzrrtttskSZdeeqlef/11LVy4UG+99ZY2btyo8PBwH1eK1oZzEOqDcxD8gTuHt912m5YtW6ZTTjlFixYtUkZGhpxOp6xWq7p27aqEhATZbDaFhnLZG8yioqJ0yy23SJL+/Oc/y+l0au3atXrrrbe0du1aH1eH1ohrpuDBsUZ9cH2MlsR5CPXBeQi+RhsdDUEbHS3Bl9dM1mbdG5rMYrFIknr37q1bbrlFtbW1OvPMM7Vt2zbPL6CDBw8qJiZGlZWVMgzDl+XCZE6nU5IrJ3a7XZLUpUsX3X777brooot03nnn6bXXXtMXX3yhNm3a+LJUtFKcg3AsnIPgTywWiwzDUGxsrB544AGdcMIJGjZsmBYvXqzy8nJJ0po1axQZGamamhofVwuzuc9Xkjy/q6Kjo3Xrrbfq7rvv1rRp0/TGG29o9uzZSk1N9VWZaMW4ZgoeHGscC9fHMAPnIRwL5yH4C9roOBba6DCDL6+ZuH3IzzgcDoWEhKikpERnnXWWEhMT9e9//1t9+/bV6NGjJUk//fSTvv/+e0VGRvq4WpjJnY39+/erXbt2stlsnucyMzNVWFio+Ph4LVq0SL179/ZhpWjNOAfBG85B8DfuTB48eFDJycl66aWXdPfdd2vs2LHq1auXYmNjtWbNGi1YsEAxMTG+LhcmcmcjPz9fkpScnOx5Ljw8XDt27FB8fLx+/PFH9erVy1dlopXjmil4cKzhDdfHMAvnIXjDeQj+hDY6vKGNDrP48pqJke1+pKamRiEhIdqxY4cSExP18ssva/To0fr000/11FNPKSsrSyNHjtTSpUs1YMAAX5cLEx2ejQ4dOujZZ5/1POd0OvXSSy9p9uzZ+uabb7h4Rr0YhnHEnVucgyAdPxucg+APnE5nnUz+97//Vbdu3fTOO+/ov//9r6644gpdcMEFWrZsmQYOHOjrcmGiw7PRuXNnvfPOO57nDMPQhx9+qFmzZmnevHk04tFotbW1XDMFCa6P4Q3Xx2gJtNPhDe10+Dva6PCGNjrM4ut2usVgbiHTbdq0SW+++aZ2796trKwsnXLKKZ6Du3PnTg0fPlznnnuuZs6cqZCQEB9XCzPVNxvPPPOMrNZf75X56aef1K5dO3Xt2tVXpaMV2bBhg55++mnt3r1bgwYN0qmnnqqTTz5ZEuegYFffbHAOgln27t2rwsLCo344lJeXp/79++v888/XM888w/kqyNQ3G88++2yd89XGjRsVHR2t9PR0M8tFK7V161a9/fbb2rZtm4YNG6ZLL71UcXFxkqTc3FwNHjyYa6YAQRsd3tBGh1lop8Mb2unwJ7TR4Q1tdJjFX9vpdLabbN26dRo9erTGjRunpKQkffnll0pOTtZVV12lv/zlL/rPf/6j7Oxs/fvf//asL2AYhuffCFyNyQbQUBs3btSJJ56o0047TW3bttW8efPUvn17TZo0SXfffbdee+01bdmyhXNQEGpMNoCWtGHDBg0ZMkRDhw7VCy+8oJ49e0r69Zz08ccfa/Pmzbr99tvJZJAhGzDDmjVrNGnSJA0cOFBWq1WzZ8/WDTfcoMcff1yGYei5555TXl6eZsyYwTVTK0cbHd7QRodZaKfDG9rp8Ce0w+AN2YBZ/LmdTme7icrKynT++ecrKytLDz74oCTXHYgDBw5UeHi47rjjDt14440+rhK+QDZgBofDoVtuuUUHDx7UW2+9JUnas2ePZs6cqc8//1y///3vddddd/m4SvgC2YC/2b9/vy644AIlJSXp559/1gknnKDnnnuuzpRifMAYnMgGzLB7925NmDBBZ5xxhh555BFJ0pw5c3Tuuedq0aJFGjhwoJxOZ50RGWidaIfBG7IBs9AWgzdkA/6Edhi8IRswi7+30/l0wEQWi0WFhYXKysqSJFVWVqpTp0469dRT1adPH7333nv6+uuvfVwlfIFswAwhISHauXOnSkpKPI916NBBN998sy644AJ9/PHHeuGFF3xYIXyFbMDfbN++XZ07d9Y999yjZcuWadOmTbr22mu1YcMGzzaHN9S4dzR4kA20NMMw9NlnnykjI0O33nqrJNfab/3791daWpqqqqokiY72AEE7DN6QDZiFthi8IRvwJ7TD4A3ZgBlaQzudTwhMYhiGSktLtWvXLu3du1eSFBkZqV27dmnjxo269NJLVV5ero8//tjHlcJsZANmcF/IDB48WBUVFdq5c6fnufbt2+uqq65Sz5499cknn6i6utpXZcIHyAb8Uc+ePXXDDTeoX79+Sk1N1dKlS7Vx48YjGmwOh0OSuEM6iJANtDSLxaLhw4crKytLycnJkqTQ0FClpKQoNDTUc72O1o92GLwhGzALbTF4Qzbgb2iHwRuyATO0ina6AVM99thjhsViMa666irjrrvuMmJiYoxp06YZhmEY77//vtGlSxejoKDAcDgcPq4UZiMbMMPPP/9sxMTEGH//+9+NqqoqwzAMw+l0GoZhGMuXLzcsFouxePFiX5YIHyEb8FfV1dWGYRjGnj17jJSUFGPs2LHG+vXrjerqauOhhx4y3n77bR9XCF8hG2huTqfT87vv8Mfcevfubbz33nuerz/55BNjzZo1ptWHlkE7DN6QDZiFthi8IRvwR7TD4A3ZQEtoLe30UF939geynJwcLV68WPn5+Ro7dqy6d++um2++WdHR0Xr55ZfVpk0b/fOf/9Tf/vY3SVJ+fr4SEhKUmJjo48rR0sgGzFBcXCyr1arY2FjPXdFDhw7VSy+9pD/+8Y+KjIzU9OnTFRcXJ0lKTExUnz59FBkZ6cuyYQKyAX/z20wefqdzWFiYamtrlZaWpuXLl2vQoEG6/vrr1aZNG82aNUsrV670XeFocWQDZjja70U3i8Wi2tpaWa1WRUZGKiEhQZL0j3/8Q4888oiys7N9UDEai3YYvCEbMAttMXhDNuBPaIfBG7IBs7S6drrp3ftBYvXq1Ubbtm2Nk046yUhISDD69OljXHDBBUZ+fr5hGIZRUlLiuSPR7frrrzcuvPBCo7Ky8og7NRA4yAbMsG7dOmPo0KHGk08+aRQXFxuGYRgOh8OTn5dfftkzSuPLL780du7cafz973830tPTjdzcXF+WjhZGNuBvjpbJo6mtrTUMwzBycnIMi8ViJCUlGcuXLzerTPgA2YAZ6pMz9530AwYMML7++mtjxowZRnR0tLF06VKTq0VT0A6DN2QDZqEtBm/IBvwJ7TB4QzZgltbYTqezvQWUlZUZo0ePNq6//nqjsrLSsNvtxksvvWSMHj3a6Nevn7F3717DMAzPVGMbNmwwpk+fbsTFxRmrV6/2ZeloYWQDZtixY4fRv39/IykpyejTp4/x4osven4pHf5B0JdffmkMHTrUSElJMXr06GFkZmZy4RPgyAb8zbEyeTQVFRXGDTfcYMTExBjr1q0zsVKYjWzADA3N2YgRI4wePXoY4eHhdLS3MrTD4A3ZgFloi8EbsgF/QjsM3pANmKW1ttOt5o+lD3yVlZU6cOCATjnlFEVERCg0NFRXXHGFZsyYobi4OJ1//vkqLCyU1WpVUVGR5syZo5UrV+q7775Tv379fF0+WhDZQEtzOp2aO3euOnbsqMWLF+vEE0/UI488ovfff18lJSWyWCxyOp1yOp06/fTT9dlnn2nevHl644039NNPPykrK8vX3wJaCNmAvzleJiUdMU3Unj17tGTJEn3zzTfq3bu3L8qGCcgGzNCQnDmdTpWWlmrv3r3Kzs7WsmXLNGTIEF+WjwaiHQZvyAbMQFsM3pAN+BPaYfCGbMAsrbmdbjF++78ATWa32zVmzBiNGjVKjz76qOdxwzD01Vdf6d5779UZZ5yhO++8UxaLRQcPHpTVamWtryBANmCGLVu2aOPGjTrrrLMkSX/+85/13Xff6bbbbtMf/vAHxcfHy+l0ymKx1FlXB4GPbMDf1CeTh6uurlZtba2io6N9US5MRDZghvrmzDi0FuH8+fPVrl07OthaIdph8IZswCy0xeAN2YA/oR0Gb8gGzNJq2+m+GE4f6BwOh3Hrrbcaw4YNMxYuXHjE89OmTTNGjRrFul5BiGzAV/70pz8Z3bp1qzPtyptvvnnMKVgQHMgG/I23TBYVFfm4Mvga2YAZjpaz119/3SgoKPBxZWgK2mHwhmzAl2iLwRuyAX9COwzekA2YpTW00xnZ3kKKiop00kknKSYmRs8884wGDhyokJAQSdL//d//6d5779UPP/zA3dBBiGzATA6Hw5Mv911gt9xyi5YtW6ZPPvlEv/zyizIyMnxcJXyBbMDfkEl4QzZgBnIW+GiHwRuyAbPxOwfekA34E/IIb8gGzNKaskZnewuoqalRWFiYDhw4oBEjRqhdu3a66aabdM455yg0NFQ33nijVq1apdmzZysqKsrX5cJEZANmcDqdslqtnq/tdrtsNpsk6aqrrtKrr76q6Ohofffddxo0aJCvyoQPkA34GzIJb8gGzEDOggftMHhDNmAWfufAG7IBf0Ie4Q3ZgFlaa9asx98Ex/LbexUcDofCwsKUm5urkpISLV26VDExMbr//vuVkZGhiRMn6u2339bTTz9NQy3AkQ2Y4Wg5s1qt2r9/v3788UdJks1mk8PhkCRFR0crMTFRS5Ys8atfRmh+ZAP+hkzCG7IBM5Cz4EE7DN6QDZiF3znwhmzAn5BHeEM2YJZAyhqd7Y1UW1sr6dcwOJ1O1dbWKiQkRDt27NDQoUP1xRdfKCEhQR9//LGefvpp3XDDDfrDH/6gpUuXauDAgT6sHi2JbMAMx8vZwIEDtXr1as/2ISEheu+99/T0009rzpw56t27t0/qRssjG/A3ZBLekA2YgZwFD9ph8IZswCz8zoE3ZAP+hDzCG7IBswRi1phGvhE2bNigmTNnav/+/UpLS9OUKVM0YsQISdKePXvUo0cP/fGPf9Tzzz8vwzDqTHmAwEY2YIaG5MxisXheV11drX379ik9Pd1XpaOFkQ34GzIJb8gGzEDOggftMHhDNmAWfufAG7IBf0Ie4Q3ZgFkCNWu0Ihpo3bp1GjVqlAzDULt27ZSfn68xY8bolVdeUUVFhfLy8nTdddfpueeek8VioaEWRMgGzNDQnB0uPDzcb38ZoenIBvwNmYQ3ZANmIGfBg3YYvCEbMAu/c+AN2YA/IY/whmzALAGdNQP1VlVVZZx//vnGDTfc4HksNzfX6NmzpxEWFmY8+uijhmEYhtPp9FWJ8BGyATOQM3hDNuBvyCS8IRswAzkLHhxreEM2YBayBm/IBvwJeYQ3ZANmCfSscdtuA9jtdm3ZskV9+vSR5FpXIDU1VaNGjdK4ceN022236YsvvjjijgsEPrIBM5AzeEM24G/IJLwhGzADOQseHGt4QzZgFrIGb8gG/Al5hDdkA2YJ9KzR2d4A4eHhysjI0NKlS1VSUqLQ0FDt2LFDn376qaZPn66pU6fqgQceUEVFha9LhcnIBsxAzuAN2YC/IZPwhmzADOQseHCs4Q3ZgFnIGrwhG/An5BHekA2YJdCzRmd7PTidTkmSzWbTaaedpnXr1unMM8/UP/7xD/Xp00cXXHCBxo8fr4kTJ2rPnj2y2+0+rhhmIRswAzmDN2QD/oZMwhuyATOQs+DBsYY3ZANmIWvwhmzAn5BHeEM2YJZgyVqorwvwZ0VFRUpISJDValVtba1CQ0P117/+VYmJiZo/f742b96sf//73/rrX/8qyXVnRlxcnI+rhhnIBsxAzuAN2YC/IZPwhmzADOQseHCs4Q3ZgFnIGrwhG/An5BHekA2YJeiy5utF4/3V+vXrjc6dOxt33nmn57Hq6uo629TU1NT5+uqrrzYmTJhgVFRUmFIjfINswAzkDN6QDfgbMglvyAbMQM6CB8ca3pANmIWswRuyAX9CHuEN2YBZgjFrjGw/il27duniiy9WaGioPv74Y4WGhuquu+5SWFiY5w4MSZ6/f/zxR7377rt699139f333ysyMtKX5aMFkQ2YgZzBG7IBf0Mm4Q3ZgBnIWfDgWMMbsgGzkDV4QzbgT8gjvCEbMEuwZo3O9t8wDEPvvfee0tLSNH36dC1atEjvvfeeJOmuu+5SaGioHA6HQkJCZLFY5HQ6deDAAS1fvlwLFy5U//79ffwdoKWQDZiBnMEbsgF/QybhDdmAGchZ8OBYwxuyAbOQNXhDNuBPyCO8IRswSzBnjc7237BYLLrsssuUnJys8ePHa8CAAZKk9957T4Zh6O6771ZISIicTqesVqusVqvOPvtsnXLKKYqNjfVx9WhJZANmIGfwhmzA35BJeEM2YAZyFjw41vCGbMAsZA3ekA34E/IIb8gGzBLMWbMYhmH4ugh/t3fvXr344ov673//qylTpujuu++WJH3yySc666yzFBIS4uMK4StkA2YgZ/CGbMDfkEl4QzZgBnIWPDjW8IZswCxkDd6QDfgT8ghvyAbMEixZY2S7XAd7165dKiws1Lhx4zwH1+l0ymKxKDU1VdOmTZMkvf/++zIMQ8XFxXrqqae0e/dupaWl+bJ8tCCyATOQM3hDNuBvyCS8IRswAzkLHhxreEM2YBayBm/IBvwJeYQ3ZANmIWuHGEFu1apVRkZGhnHCCScY8fHxRs+ePY13333XOHjwoGEYhuFwOAyn02kYhmHk5uYad911l2GxWIzExERj2bJlviwdLYxswAzkDN6QDfgbMglvyAbMQM6CB8ca3pANmIWswRuyAX9CHuEN2YBZyNqvrL7u7Pel/fv36w9/+IMuueQSffXVV1q/fr0GDBigf/3rX3r66ae1f/9+Wa2//ohSU1O1fft2xcbG6ocfftDgwYN9WD1aEtmAGcgZvCEb8DdkEt6QDZiBnAUPjjW8IRswC1mDN2QD/oQ8whuyAbOQtd/wdW+/L61bt87IzMw84g6Kv/3tb0a/fv2Mhx9+2CgvL/c8/sorrxgJCQnG8uXLzS4VJiMbMAM5gzdkA/6GTMIbsgEzkLPgwbGGN2QDZiFr8IZswJ+QR3hDNmAWslZXUI9st9vtqq2tVUVFhSSpsrJSkvTggw/qlFNO0fPPP6/s7GzP9meeeaaWL1+urKwsn9QL85ANmIGcwRuyAX9DJuEN2YAZyFnw4FjDG7IBs5A1eEM24E/II7whGzALWavLYhiG4esifGnYsGGKiYnR/PnzJUnV1dUKDw+XJA0dOlTdunXTe++9J4fDoZCQEF+WCpORDZiBnMEbsgF/QybhDdmAGchZ8OBYwxuyAbOQNXhDNuBPyCO8IRswC1n7VVCNbC8vL1dpaalKSko8j7344otat26dLr74YklSeHi4amtrJUljxoxReXm5JAV8EIId2YAZyBm8IRvwN2QS3pANmIGcBQ+ONbwhGzALWYM3ZAP+hDzCG7IBs5C1Ywuazvb169frvPPO08knn6xevXrpnXfekST16tVLTz31lObOnasLL7xQdrtdVqvrx7Jv3z5FR0ertrZWQT4BQEAjGzADOYM3ZAP+hkzCG7IBM5Cz4MGxhjdkA2Yha/CGbMCfkEd4QzZgFrJ2fKG+LsAM69ev15gxY3TZZZdpyJAh+uWXX3TFFVeod+/eysrK0tlnn63o6Ghde+216t+/v3r27KmwsDB98cUX+umnnxQaGhQ/pqBENmAGcgZvyAb8DZmEN2QDZiBnwYNjDW/IBsxC1uAN2YA/IY/whmzALGStfgJ+zfaCggJddNFF6tmzp5566inP46eccor69eunp59+2vNYaWmp7rvvPhUUFCgiIkLXXHONevfu7YuyYQKyATOQM3hDNuBvyCS8IRswAzkLHhxreEM2YBayBm/IBvwJeYQ3ZANmIWv1F/C3FNjtdhUVFemCCy6QJDmdTlmtVnXu3FkFBQWSJMMwZBiGYmNj9dBDD9XZDoGLbMAM5AzekA34GzIJb8gGzEDOggfHGt6QDZiFrMEbsgF/Qh7hDdmAWcha/QX8d5ucnKy3335bJ510kiTJ4XBIkjp06OA52BaLRVarVSUlJZ7XWSwW84uFqcgGzEDO4A3ZgL8hk/CGbMAM5Cx4cKzhDdmAWcgavCEb8CfkEd6QDZiFrNVfwHe2S1L37t0lue6msNlsklx3W+zbt8+zzQMPPKBXXnlFtbW1koIzDMGIbMAM5AzekA34GzIJb8gGzEDOggfHGt6QDZiFrMEbsgF/Qh7hDdmAWcha/QT8NPKHs1qtMgzDc6Ddd17cdddduu+++7RixQqFhgbVjwSHkA2YgZzBG7IBf0Mm4Q3ZgBnIWfDgWMMbsgGzkDV4QzbgT8gjvCEbMAtZO7agGNl+OMMwJEmhoaFKT0/Xo48+qocffljLli3TgAEDfFwdfIlswAzkDN6QDfgbMglvyAbMQM6CB8ca3pANmIWswRuyAX9CHuEN2YBZyJp3QXebgftuC5vNppdffllxcXH64YcfNGjQIB9XBl8jGzADOYM3ZAP+hkzCG7IBM5Cz4MGxhjdkA2Yha/CGbMCfkEd4QzZgFrLmXdCNbHebOHGiJOnHH3/UkCFDfFwN/AnZgBnIGbwhG/A3ZBLekA2YgZwFD441vCEbMAtZgzdkA/6EPMIbsgGzkLUjWQz3uP8gVF5erujoaF+XAT9ENmAGcgZvyAb8DZmEN2QDZiBnwYNjDW/IBsxC1uAN2YA/IY/whmzALGStrqDubAcAAAAAAAAAAAAAoDGCdhp5AAAAAAAAAAAAAAAai852AAAAAAAAAAAAAAAaiM52AAAAAAAAAAAAAAAaiM52AAAAAAAAAAAAAAAaiM52AAAAAAAAAAAAAAAaiM52AAAAAAAAAAAAAAAaiM52AAAAAAAAAAAAAAAaiM52AAAAAAAAAAAAAAAaiM52AAAAAAAAAAAAAAAaiM52AAAAAAAAAAAAAAAaiM52AAAQkHJycmSxWPT666/7uhQAAAAAAAAAQACisx0AAPiF+++/X5988omvywAAAAAAAKKdDgBAfdDZDgAA/AKNeAAAAAAA/AftdAAAjo/OdgAAAAAAAAAAAAAAGojOdgAAfKy0tFTTp09XZmamwsPD1b59e40fP17Lly/3bLNkyRJNmjRJ8fHxioqK0sknn6xFixYdsa8FCxZoyJAhioiIUNeuXfXiiy/qnnvukcViqbOdxWLR9ddfr//973/q3bu3IiMjNWLECK1Zs0aS9OKLL6pbt26KiIjQ2LFjlZOTc8R71acm93tnZ2fr8ssvV0JCguLj43XFFVeooqKiTj3l5eV64403ZLFYZLFYdPnll9f7Z1hUVKTLL79c8fHxSkhI0NSpU1VUVFTv1wMAAAAA4EY7vent9EcffVQjR45UmzZtFBkZqcGDB+uDDz6o9+sBAGgtQn1dAAAAwe7qq6/WBx98oOuvv169e/fWwYMH9cMPP2jDhg0aNGiQ5s+fr9NPP12DBw/W3XffLavVqtdee02nnnqqvv/+ew0bNkyStGLFCk2aNEmpqam699575XA4NGPGDLVr1+6o7/v9999r1qxZuu666yRJDzzwgM4880zdfvvteu6553TttdeqsLBQDz/8sK688krNnz/f89r61uT2+9//Xp07d9YDDzyg5cuX65VXXlH79u310EMPSZLeeust/fnPf9awYcM0bdo0SVLXrl3r9fMzDEO/+93v9MMPP+jqq69Wr1699PHHH2vq1KkNOxAAAAAAAIh2utS0drokPfXUUzr77LN1ySWXqKamRu+//74uvPBCff755zrjjDPqfzAAAPB3BgAA8Kn4+HjjuuuuO+pzTqfT6N69uzFx4kTD6XR6Hq+oqDA6d+5sjB8/3vPYWWedZURFRRl79uzxPLZlyxYjNDTU+O2vfElGeHi4sX37ds9jL774oiHJSElJMUpKSjyP33HHHYYkz7YNqenuu+82JBlXXnllnfc/99xzjTZt2tR5LDo62pg6daqXn5J3n3zyiSHJePjhhz2P1dbWGieddJIhyXjttdcavE8AAAAAQPCine7S2Ha6+70PV1NTY/Tt29c49dRTG7U/AAD8FdPIAwDgYwkJCVqyZIlyc3OPeG7lypXasmWLLr74Yh08eFAHDhzQgQMHVF5ertNOO00LFy6U0+mUw+HQvHnzdM455ygtLc3z+m7duun0008/6vuedtppyszM9Hw9fPhwSdL555+v2NjYIx7ftm1bg2o63NVXX13n65NOOkkHDx5USUlJA35SR/fll18qNDRU11xzjeexkJAQ3XDDDU3eNwAAAAAg+NBOb7rIyEjPvwsLC1VcXKyTTjqpzlT8AAAEAqaRBwDAxx5++GFNnTpV6enpGjx4sCZPnqzLLrtMXbp00ZYtWyTpmFOiFxcXq6qqSpWVlerWrdsRzx/tMUnq1KlTna/j4+MlSenp6Ud9vLCwUJLqXVNiYqLX93I/V1hYqLi4OK/7qY8dO3YoNTVVMTExdR7v0aNHk/YLAAAAAAhOtNOb1k6XpM8//1z33XefVq5cqerqas/jv12rHgCA1o7OdgAAfOz3v/+9TjrpJH388ceaM2eOHnnkET300EP66KOPPHeeP/LIIxo4cOBRXx8TE6OqqqoGv29ISEiDHjcMQ5LqXVND9gkAAAAAgL+gnd4033//vc4++2yNGTNGzz33nFJTU2Wz2fTaa6/p3XffbfL+AQDwJ3S2AwDgB1JTU3Xttdfq2muv1b59+zRo0CD9+9//1hNPPCFJiouL07hx47y+vn379oqIiFB2dvYRzx3tsabo2rVrvWpqqMbe3Z6RkaFvvvlGZWVldT482LRpU3OVBgAAAAAIMrTTG99O//DDDxUREaGvv/5a4eHhnsdfe+215ioNAAC/wZrtAAD4kMPhUHFxcZ3H2rdvr7S0NFVXV2vw4MHq2rWrHn30UZWVlR3x+v3790ty3ZE+btw4ffLJJ3XWlMvOztZXX33VrDXXt6aGio6OVlFRUYNfN3nyZNXW1ur555/3POZwODRz5sxG1QEAAAAACF6003/V2HZ6SEiILBaLHA6H57GcnBx98sknjaoDAAB/xsh2AAB8qLS0VB07dtQFF1ygAQMGKCYmRvPmzdPSpUv12GOPyWq16pVXXtHpp5+uPn366IorrlCHDh20Z88effvtt4qLi9Nnn30mSbrnnns0Z84cjRo1Stdcc40cDoeeeeYZ9e3bVytXrmy2mhtSU0MMHjxY8+bN0+OPP660tDR17txZw4cPP+7rzjrrLI0aNUp///vflZOTo969e+ujjz464sMRAAAAAACOh3b6rxrbTj/jjDP0+OOPa9KkSbr44ou1b98+Pfvss+rWrZtWr17dmG8RAAC/RWc7AAA+FBUVpWuvvVZz5szxrP3WrVs3Pffcc7rmmmskSWPHjtXixYv1r3/9S88884zKysqUkpKi4cOH6y9/+YtnX4MHD9ZXX32lW2+9VXfeeafS09M1Y8YMbdiwQRs3bmzWuutbU0M8/vjjmjZtmv75z3+qsrJSU6dOrVcj3mq1atasWZo+fbrefvttWSwWnX322XrssceUlZXVqFoAAAAAAMGJdvqvGttOP/XUU/Xqq6/qwQcf1PTp09W5c2c99NBDysnJobMdABBwLIZhGL4uAgAAtJxzzjlH69at05YtW3xdCgAAAAAAQY92OgAAgYM12wEACCCVlZV1vt6yZYu+/PJLjR071jcFAQAAAAAQxGinAwAQ2BjZDgBAAElNTdXll1+uLl26aMeOHXr++edVXV2tFStWqHv37r4ur0EcDof2799/zG1iYmIUExNjUkUAAAAAADQM7XQAAAIba7YDABBAJk2apPfee095eXkKDw/XiBEjdP/997e6Brwk7dq1S507dz7mNnfffbfuuececwoCAAAAAKCBaKcDABDYGNkOAAD8UlVVlX744YdjbtOlSxd16dLFpIoAAAAAAAhetNMBADgSne0AAAAAAAAAAAAAADSQ1dcFAAAAAAAAAAAAAADQ2gTsmu1Op1O5ubmKjY2VxWLxdTkAAAAAAHhlGIZKS0uVlpYmqzXw7ounjQ4AAAAAaE3q204P2M723Nxcpaen+7oMAAAAAADqbdeuXerYsaOvy2h2tNEBAAAAAK3R8drpAdvZHhsbK8n1A4iLi/NJDXa7XXPmzNGECRNks9l8UgP8E9mAWcgavCEb8CfkEd6QDZjFH7JWUlKi9PR0T1s20PhDG13yj2MN/0Q2YAZyhmMhH/An5BHekA2YwV9yVt92esB2trunpYuLi/NpZ3tUVJTi4uI46aAOsgGzkDV4QzbgT8gjvCEbMIs/ZS1Qp1j3hza65F/HGv6FbMAM5AzHQj7gT8gjvCEbMIO/5ex47fTAWwgOAAAAAAAAAAAAAIAWRmc7AAAAAAAAAAAAAAANFLDTyNeXw+GQ3W5vkX3b7XaFhoaqqqpKDoejRd4jUNlsNoWEhPi6DAAAAACAiVqyjS7RTm8K2ukAAAAAcKSg7Ww3DEN5eXkqKipq0fdISUnRrl27AnbdvZaUkJCglJQUfnYAAAAAEODMaKO734d2euPRTgcAAACAuoK2s93diG/fvr2ioqJapKHodDpVVlammJgYWa3M2F9fhmGooqJC+/btkySlpqb6uCIAAAAAQEsyo40u0U5vLNrpAAAAAHB0QdnZ7nA4PI34Nm3atNj7OJ1O1dTUKCIigkZ8A0VGRkqS9u3bp/bt2zNVHQAAAAAEKLPa6BLt9KagnQ4AAAAARwrKlqV7/beoqCgfV4JjcR+fllyvDwAAAADgW7TRWw/a6QAAAABQV1B2truxxph/4/gAAAAAQPCgDej/OEYAAAAAUFdQd7YDAAAAAAAAAAAAANAYdLYDAAAAAAAAAAAAANBAdLYHsczMTD355JO+LgMAAAAAgKBHGx0AAAAAWp9QXxeAhhk7dqwGDhzYLA3wpUuXKjo6uulFAQAAAAAQhGijAwAAAEBwo7M9wBiGIYfDodDQ4x/adu3amVARAAAAAADBiTY6AAAAAAQ2ppGXq/FbUVPbIn8qaxzHfN4wjHrXefnll+u7777TU089JYvFIovFotdff10Wi0VfffWVBg8erPDwcP3www/aunWrfve73yk5OVkxMTEaOnSo5s2bV2d/v52izmKx6JVXXtG5556rqKgode/eXbNmzWquHzMAkzmchh6Zs1krD1p8XQoAAADQIK2hnU4bHQAAAEBrVV1SrS+v/1Lb5m3zdSmtHiPbJVXaHep919c+ee/1MyYqKqx+h+Gpp57S5s2b1bdvX82YMUOStG7dOknS3//+dz366KPq0qWLEhMTtWvXLk2ePFn//ve/FR4erjfffFNnnXWWNm3apE6dOnl9j3vvvVcPP/ywHnnkEc2cOVOXXHKJduzYoaSkpKZ/swBMtXDLfr30fY6iQ626owE39gAAAAC+1hra6bTRAQAAALRWix5epKXPLtWen/eoy7guvi6nVWNkeysSHx+vsLAwRUVFKSUlRSkpKQoJCZEkzZgxQ+PHj1fXrl2VlJSkAQMG6C9/+Yv69u2r7t2761//+pe6du163LvgL7/8cl100UXq1q2b7r//fpWVlennn38249sD0MyWbi+QJJXXWrSnqMrH1QAAAACBhTY6AAAAgNaouqRaS59dKkk6uPlgg2bhxpEY2S4p0hai9TMmNvt+nU6nSktKFRsXK6v16Pc1RNpCmuW9hgwZUufrsrIy3XPPPfriiy+0d+9e1dbWqrKyUjt37jzmfvr37+/5d3R0tOLi4rRv375mqRGAuZbmFHj+vTa3RJ3bx/mwGgAAAKD+Wns7nTY6AAAAAH+17MVlqjo0QK+6uFqVBZWKahPl46paLzrb5VoHrb5TuTeE0+lUbViIosJCvTbim0t0dHSdr2+99VbNnTtXjz76qLp166bIyEhdcMEFqqmpOeZ+bDZbna8tFoucTmez1wugZVXZHVq1q9jz9brcEp010Hf1AAAAAA3R2tvptNEBAAAA+KPaqlr99PhPdR4r3FpIZ3sT0NneyoSFhcnhcBx3u0WLFunyyy/XueeeK8l1F31OTk4LVwfAX6zeXawax68fwq3NLfFhNQAAAEBgoo0OAAAAoDVZ9dYqleWVKa5jnGI7xGrPkj0qyC5Qh2EdfF1aq8Wa7a1MZmamlixZopycHB04cMDrHe3du3fXRx99pJUrV2rVqlW6+OKLufsdCCLuKeQ7JkZKco1sZ90VAACA4LRnzx798Y9/VJs2bRQZGal+/fpp2bJlnucNw9Bdd92l1NRURUZGaty4cdqyZUudfRQUFOiSSy5RXFycEhIS9Kc//UllZWVmfyt+hzY6AAAAgNbC6XDqx4d/lCSNuGWE2vVqJ0kq2FpwrJfhOOhsb2VuvfVWhYSEqHfv3mrXrp3X9d0ef/xxJSYmauTIkTrrrLM0ceJEDRo0yORqAfiKu7P9oqEdZbUYKqywa09RpY+rAgAAgNkKCws1atQo2Ww2ffXVV1q/fr0ee+wxJSYmerZ5+OGH9fTTT+uFF17QkiVLFB0drYkTJ6qqqsqzzSWXXKJ169Zp7ty5+vzzz7Vw4UJNmzbNF9+SX6GNDgAAAKC12PDhBhVkFygyKVKD/jxIid1c7cLCrYU+rqx1Yxr5VuaEE07Q4sWL6zx2+eWXH7FdZmam5s+fX+ex6667rs7Xv52y7mijXouKihpVJwDfcTgN/ZLj+uU4qmsbvfuDtKdCWrunWB0TWXcFAAAgmDz00ENKT0/Xa6+95nmsc+fOnn8bhqEnn3xS//znP/W73/1OkvTmm28qOTlZn3zyiaZMmaINGzZo9uzZWrp0qYYMGSJJmjlzpiZPnqxHH31UaWlp5n5TfoQ2OgAAAIDWwDAM/fDgD5KkYTcOU1hMmJK6JkmSCrIZ2d4UdLYDQIDZmFei0upaxYSHqmdKrNJjDO2psGjNnmJN6pvq6/IAAABgolmzZmnixIm68MIL9d1336lDhw669tprddVVV0mStm/frry8PI0bN87zmvj4eA0fPlyLFy/WlClTtHjxYiUkJHg62iVp3LhxslqtWrJkiWcd8sNVV1erurra83VJSYkkyW63y26319nWbrfLMAw5nc4Wn1rd3YHtfj80jNPplGEYstvtCgkJ8XU5zcqdy9/mE2hO5AzHQj7gT8gjvCEbrde2uduUtyJPtiibsv6SJbvdrtiMWEmuaeT96Zj6S87q+/50tgNAgFl2aFT7oIxEhVgt6hjt+kBxzZ4SX5YFAAAAH9i2bZuef/553XzzzfrHP/6hpUuX6sYbb1RYWJimTp2qvLw8SVJycnKd1yUnJ3uey8vLU/v27es8HxoaqqSkJM82v/XAAw/o3nvvPeLxOXPmKCqq7mxLoaGhSklJUVlZmWpqahr9vTZEaWmpKe8TaGpqalRZWamFCxeqtrbW1+W0iLlz5/q6BAQBcoZjIR/wJ+QR3pCN1if7zmxJUsJpCVqwZIEkqbbMdU1fnleuzz76TCER/nVDra9zVlFRUa/t6GwHgADz86H12odmuNZbST/U2b52T7EMw5DFYvFZbQAAADCX0+nUkCFDdP/990uSsrKytHbtWr3wwguaOnVqi73vHXfcoZtvvtnzdUlJidLT0zVhwgTFxcXV2baqqkq7du1STEyMIiIiWqwmyTWivbS0VLGxsVwXN0JVVZUiIyM1ZsyYFj9WZrPb7Zo7d67Gjx8vm83m63IQoMgZjoV8wJ+QR3hDNlqnPT/v0co1K2UNteoPT/5Bcem/tsmyb8hWVWGVhncbrvb92x9jL+bxl5y5Z2g7HjrbASCAGIahpdsPdbZ3dq23khYlhVgtKiiv0d7iKqUlRPqyRAAAAJgoNTVVvXv3rvNYr1699OGHH0qSUlJSJEn5+flKTf11yaH8/HwNHDjQs82+ffvq7KO2tlYFBQWe1/9WeHi4wsPDj3jcZrMd8WGJw+GQxWKR1WqV1Wpt2DfYQO6p493vh4axWq2yWCxHPY6BIpC/N/gPcoZjIR/wJ+QR3pCN1mXJo0skSf3/2F9turSp81xS1yTlLstVyc4SdRjcwRfleeXrnNX3vWlZAkAA2VlQoX2l1bKFWDQwPUGSFBYidW8XLUlas6fYh9UBAADAbKNGjdKmTZvqPLZ582ZlZGRIkjp37qyUlBR98803nudLSkq0ZMkSjRgxQpI0YsQIFRUV6ZdffvFsM3/+fDmdTg0fPtyE7wIAAAAA0Bj7N+zXxk82ShZp5O0jj3g+qZtr0F7h1kKzSwsYdLYDQABZemi99v4dExRh+3V9lT4dXNPCrKWzHQAAIKjcdNNN+umnn3T//fcrOztb7777rl566SVdd911klwjvKdPn6777rtPs2bN0po1a3TZZZcpLS1N55xzjiTXSPhJkybpqquu0s8//6xFixbp+uuv15QpU5SWlubD7w4AAAAAcCw/PvyjJKnnOT3Vrle7I55P7OpajrYgu8DUugIJne0AEEA8U8hnJtV5vG+aq7Odke0AAADBZejQofr444/13nvvqW/fvvrXv/6lJ598Updccolnm9tvv1033HCDpk2bpqFDh6qsrEyzZ8+usyb3O++8o549e+q0007T5MmTNXr0aL300ku++JYAAAAAAPVQvKtYq99eLUka9bdRR93G3dnOyPbGY812AAggS3Pcne2JdR7vk/bryHbDMGSxWEyvDQAAAL5x5pln6swzz/T6vMVi0YwZMzRjxgyv2yQlJendd99tifIAAAAAAC1g8WOL5ax1KvOUTHUc3vGo27inkS/Yysj2xmJkOwAEiP2l1dp2oFwWizQko+7I9l4psQqxWnSgrEZ5JVU+qhAAAAAAAAAAALS0igMVWv7ycknS6L+P9rpdUldXX0LxjmI5ahym1BZo6GwHgADxyw7XnWc9kmMVH2Wr81yELUTd28dIktbsZip5AAAAAAAAAAAC1c/P/Cx7hV0pWSnqMr6L1+1iUmMUGhkqw2moaEeReQUGEDrbW5mxY8dq+vTpzba/yy+/XOecc06z7Q+A7/y83bWmym/Xa3fr2yFekmsqeQAAAABNRxsdAAAAgL+pKavRzzN/liSNvmP0MZeVtVgsntHtrNveOHS2A0CAcK/XPuQ367W79TvU2b6GznYAAAAAAAAAAALS8leWq7KgUkndktTrvF7H3T6xq6tPoSCbddsbg852SYZhqKa8pkX+2Mvtx3zeMIx613n55Zfru+++01NPPSWLxSKLxaKcnBytXbtWp59+umJiYpScnKxLL71UBw4c8Lzugw8+UL9+/RQZGak2bdpo3LhxKi8v1z333KM33nhDn376qWd/CxYsaIGfMICWVlZdq3W5rk70YZ2PPbJ9zZ6SBp17AAAAALO1hnY6bXQAAAAA/sYwDP30xE+SpJG3j5Q15PhdwUndXH0KBVvpbG+MUF8X4A/sFXY9EPOAT977jrI7FBYdVq9tn3rqKW3evFl9+/bVjBkzJEk2m03Dhg3Tn//8Zz3xxBOqrKzU3/72N/3+97/X/PnztXfvXl100UV6+OGHde6556q0tFTff/+9DMPQrbfeqg0bNqikpESvvfaaJCkp6eiddAD824qdhXIaUsfESKXGRx51m96pcbJapANl1covqVZKfITJVQIAAAD10xra6bTRAQAAAP+QtzJPC+5eoHEPj1PbHm19XY5PleeXq3hnsSxWi/pf0r9er3GPbGca+cahs70ViY+PV1hYmKKiopSSkiJJuu+++5SVlaX777/fs91//vMfpaena/PmzSorK1Ntba3OO+88ZWRkSJL69evn2TYyMlLV1dWe/QFonZZud91xNszLeu2SFBkWom7tY7Q5v0xr9xTT2Q4AAAA0AW10AAAAwD/MvW2uts3bpqh2UTr7lbN9XY5P7V+/X5KU2CVRtihbvV7jXrOdaeQbp8Gd7QsXLtQjjzyiX375RXv37tXHH3+sc845x/O8YRi6++679fLLL6uoqEijRo3S888/r+7du3u2KSgo0A033KDPPvtMVqtV559/vp566inFxMR4tlm9erWuu+46LV26VO3atdMNN9yg22+/vWnfrRe2KJvuKLuj2ffrdDpVWlKq2LhYWa1Hn6ahvkH3ZtWqVfr222/r/Ozctm7dqgkTJui0005Tv379NHHiRE2YMEEXXHCBEhOPvqYzgNbpZ8967cce+dK3Q7w255dpzZ5ijeudbEZpAAAAQIO11nY6bXQAAADAXMW7irXtm22SpJwFOb4txg+4O9vb9W5X79e4p5Ev3FYow2nIYrW0SG2BqsGd7eXl5RowYICuvPJKnXfeeUc8//DDD+vpp5/WG2+8oc6dO+vOO+/UxIkTtX79ekVEuEZRXnLJJdq7d6/mzp0ru92uK664QtOmTdO7774rSSopKdGECRM0btw4vfDCC1qzZo2uvPJKJSQkaNq0aU38lo9ksVjqPZV7QzidTtkcNoVFh3ltxDdVWVmZzjrrLD300ENHPJeamqqQkBDNnTtXP/74o+bMmaOZM2fq//2//6clS5aoc+fOLVITAHPV1Dq1YmeRJGlY52N/SNevQ7w+Wr5Ha/cUm1AZAAAA0DittZ1OGx0AAAAw1+q3V0uG69+FWwtVvKtY8enxvi3Kh9yd7W171386/fhO8bKGWuWodqhkT0lQ//wao8Ety9NPP1333Xefzj333COeMwxDTz75pP75z3/qd7/7nfr3768333xTubm5+uSTTyRJGzZs0OzZs/XKK69o+PDhGj16tGbOnKn3339fubm5kqR33nlHNTU1+s9//qM+ffpoypQpuvHGG/X444837bsNAGFhYXI4HJ6vBw0apHXr1ikzM1PdunWr8yc6OlqS60OKUaNG6d5779WKFSsUFhamjz/++Kj7A9D6rM0tVnWtU0nRYera7sgRNIfr18H1S3INne0AAABAk9FGBwAAAHzHMAytemOVJMkS4hqNHeyj2xszst0aalV8hqvvgHXbG65Z12zfvn278vLyNG7cOM9j8fHxGj58uBYvXqwpU6Zo8eLFSkhI0JAhQzzbjBs3TlarVUuWLNG5556rxYsXa8yYMQoL+/Uu9okTJ+qhhx5SYWHhUadXq66uVnV1tefrkpISSZLdbpfdbq+zrd1ul2EYcjqdcjqdzfb9/5ZhGJ6/m+t9MjIytGTJEm3btk0xMTG65ppr9PLLL2vKlCm67bbblJSUpOzsbP33v//Vyy+/rGXLlmn+/PkaP3682rdvryVLlmj//v3q0aOHnE6nMjIy9PXXX2vDhg1q06aN4uPjZbM1bWr75uJ0OmUYhux2u0JCQnxdTrNyZ/K32QQa46etrl+egzslqLa2ts5zv81a93aRslqkfaXV2lNQpvax4eYWC7/BeQj+hDzCG7IBs/hD1sh565SZmaklS5YoJydHMTExuu666/Tyyy/roosu0u233+5po7///vt65ZVXtGzZMn3zzTeaMGFCnTZ6r169PPv7+uuvtWnTJr9rowMAAAD+Jndprg5uOqjQyFANvHyglj2/TDnf5mjApQN8XZrPNKazXXJNJV+4tVAFWwuUOTazBSoLXM3a2Z6XlydJSk6uuw5wcnKy57m8vDy1b9++bhGhoUpKSqqzzW+nT3PvMy8v76id7Q888IDuvffeIx6fM2eOoqKijni/lJQUlZWVqaampiHfYqOUlpY2277+8pe/6Nprr1Xfvn1VWVmpVatW6auvvtI999yjiRMnqqamRunp6TrttNNUVlYmq9Wqb7/9Vk8++aRKS0uVnp6uf/3rXxo1apRKSkr0hz/8Qd98842GDRumsrIyffbZZxo9enSz1dsUNTU1qqys1MKFC4/oQAwUc+fO9XUJCABfbrRKsiqqYq++/DL3qNscnrX2ESHKq7To9Vnz1TfRMKlK+CvOQ/An5BHekA2YxZdZq6io8Nl7o/FuvfVWTZ06Vb1791ZlZaW2b9+uRYsW6W9/+5smTJig6upqZWRkaNKkSbJarYqLi9PChQv15JNPqqSkRBkZGXrsscd0+umnS5KuuuoqLViwQEOGDFFZWZm+/fZbjR071rffJAAAAOCnVr6xUpLU67xe6nF2D1dnexCPbC/fX66K/a62Zdue9Z9GXpISu7r6XguyC5q9rkDXrJ3tvnTHHXfo5ptv9nxdUlKi9PR0TZgwQXFxcXW2raqq0q5duxQTE+NZR74lGIah0tJSxcbGymKxNMs+Bw0apJ9++umIxz/99NOjbj906FDNmTPH6/7i4uI0b968ZqmtuVVVVSkyMlJjxoxp0ePkC3a7XXPnztX48eMZpYAmcToN3bXyW0m1unTSSA3oWHctlaNl7duKNfpk1V5Fpp6gyad29UHV8Aech+BPyCO8IRswiz9kzT07G1qXE044QYsXLz7i8Y8++uio2/fq1UuzZ8/2ur927dodsw0PAAAAwKW2ulZr31srSRowdYA6nthRlhCLirYXqWhHkRIyEnxboA8c2HBAkpSQmaCw6LDjbF1XUrckSUwj3xjN2tmekpIiScrPz1dqaqrn8fz8fA0cONCzzb59++q8rra2VgUFBZ7Xp6SkKD8/v8427q/d2/xWeHi4wsOPnA7ZZrMd8WGJw+GQxWKR1WqV1drgZevrzT11vPu90DBWq1UWi+WoxzBQBPL3BnNszi9VcWWtIm0hGtApSbaQo59rDs9a//REfbJqr9bnlZI/cB6CXyGP8IZswCy+zBoZBwAAAID62/z5ZlUVVim2Q6w6n9pZ1hCrOgztoN0/7VbOghwNnDrQ1yWarrFTyEtSUlc62xurWXuAO3furJSUFH3zzTeex0pKSrRkyRKNGDFCkjRixAgVFRXpl19+8Wwzf/58OZ1ODR8+3LPNwoUL66xZN3fuXPXo0eOoU8gDQLD6ebtrSpdBGQleO9p/q9+h0e9r9hS3WF0AAAAAAAAAALSUVW+skiT1/2N/WQ99Np4xNkOStGPBDp/V5Uvuzva2vRs2hbxUdxp5w2D52YZocGd7WVmZVq5cqZUrV0qStm/frpUrV2rnzp2yWCyaPn267rvvPs2aNUtr1qzRZZddprS0NJ1zzjmSXFOmTZo0SVdddZV+/vlnLVq0SNdff72mTJmitLQ0SdLFF1+ssLAw/elPf9K6dev03//+V0899VSdaeIBANLSHFdn+5CMpHq/pndqnCwWKb+kWvtKq1qqNAAAAAAAAAAAml35vnJlf5UtyTWFvFvnUzpLkrZ/u90ndflaU0a2J3ZxdbZXl1Sr8mBls9YV6Brc2b5s2TJlZWUpKytLknTzzTcrKytLd911lyTp9ttv1w033KBp06Zp6NChKisr0+zZs+usuf3OO++oZ8+eOu200zR58mSNHj1aL730kuf5+Ph4zZkzR9u3b9fgwYN1yy236K677tK0adOa+v0CQEBZemhk+7DO9e9sjw4PVdd2MZKktYxuBwAAAAAA8KnsfaW64o1ftKvM15UAQOuw5t01ctY6lTY0Te16/dqxnD4yXdZQq4p3FKsop8h3BfpIUzrbbZE2xXaIlSQVbC1o1roCXYPXbB87duwxpw+wWCyaMWOGZsyY4XWbpKQkvfvuu8d8n/79++v7779vaHkAEDT2FFUqt7hKoVaLsjolNOi1fdPilL2vTGt2l+jUnsktUyAAAAAAAACO69UftuuH7IMqSLDqL74uBgBaAfcU8oePapeksJgwpQ1N0+7Fu7X92+3KuiLLF+X5RFVRlcr2uu7aOvwGhIZI6pqk0j2lKsguUMfhHRv02r3L98phdzT4dYGgWddsBwCYxz2qvU+HeEWFNezeqb4dXOu2r81lZDsAAAAAAIAvrdhZJEnaXGxRRU2tb4sBAD+XvzpfeSvzZLVZ1XdK3yOezzwlU1Lwrdu+f4NrVHtcxziFx4U3ah+J3VxTyRduLWzQ66pLq/X6ya/rzVPfVHVpdaPeuzWjsx0AWqmfD63XPjQjscGv7efubGcaeQAAAAAAAJ8prbJrU36pJKnWsGhRNlP3AsCxrHxjpSSpx1k9FNUm6ojnM8dmSpJyFuQcc6buQOOeQr5tr7aN3kdSV9dytQ3tbN/x3Q7VlNXIXmFXye6SRr9/a0VnOwC0Uu6R7UMbsF67W58O8bJYpL3FVTpQFnx3mgEAAAAAAPiD1buLdXhf0LyN+3xXDAD4OWetU2veWSPpyCnk3dJHpstqs6p4Z7GKtheZWJ1vNWW9drfErq6BfQUNvPFr69ytnn+X55c3+v1bKzrbAaAVKiyv0ZZ9rvVXhmY2vLM9JjxUndtGS5LWMLodAAAAAADAJ5bvcI0eTIuPkCR9u2m/HM7gGYkJAA2xdc5WleeXK6pdlLqd3u2o24RFh6nDsA6SXKPbg8WB9QckNa2zPambq6+hYGvDOtu3zdnm+Xf5Pjrb4ecMw9C0adOUlJQki8WilStX+rokAD6w7FBDrFv7GCVFhzVqH56p5HfT2Q4AAAA0Bm10AEBTrdhVJEm6bEQnRYYYKqywa/nOhk3fCwDBYtUbqyRJ/S7upxBbiNftPFPJf5tjQlX+oTlGtrunkS/PL1dNWU29XlOyu0QHNh7wfF2WX9bo92+t6GxvZWbPnq3XX39dn3/+ufbu3au+ffv6uqRGyczM1JNPPunrMoBWa6l7vfbMhq/X7ububGdkOwAAANA4tNEBAE1hGIZWHOpYH5KRqN6JrhHt89bn+7IsAPBLlYWV2vjpRknep5B3yzwlU1LwrNteXVqt4p2uz/mbsmZ7REKEIpMiJdV/dPvhU8hLTCOPVmDr1q1KTU3VyJEjlZKSotDQ0Aa93jAM1dbWtlB1AMzya2d7w6eQd+vrHtlOZzsAAADQKLTRAQBNkXOwQoUVdoWFWtUrJVb9DnW2z91AZzsAc23/drvm3DpHS2YuUfbsbBVkF8hhd/i6rDrW/d86Oaodat+vvVIGphxz2/QRrnXbS3aXqHBr4M8W4h5ZHp0crag2UU3al3sq+fr+3NxTyNuibJIY2Q4/d/nll+uGG27Qzp07ZbFYlJmZqerqat14441q3769IiIiNHr0aC1dutTzmgULFshiseirr77S4MGDFR4erh9++EFOp1MPPPCAOnfurMjISA0YMEAffPBBnfdbt26dzjzzTMXFxSk2NlYnnXSStm513aGydOlSjR8/Xm3btlV8fLxOPvlkLV++3PNawzB0zz33qFOnTgoPD1daWppuvPFGSdLYsWO1Y8cO3XTTTbJYLLJYLCb89IDAkltUKUk6ITm20fvokxbn2ldxlQ6WVTdLXQAAAECwoI0OAGgq96j2fh3iXR3uCYZsIRZt21+urfuDr7MCgG/UVtfqfxf+T4sfW6zZN87WO6e/o5ndZ+r+qPs1s/tMvXP6O/ryhi+15Oklyv4qW45K33TCu6eQHzB1wHGvWW1RNnU8saOk4Fi3vTmmkHdL7OqaTbc+I9sNp6Ft81yd7b3O6yUpOEe2N+yW60BWUyEd2Ny8+zQMhZSXSeUxkrf/+G1PkMLqd5fJU089pa5du+qll17S0qVLFRISottvv10ffvih3njjDWVkZOjhhx/WxIkTlZ2draSkX0e8/v3vf9ejjz6qLl26KDExUQ888IDefvttvfDCC+revbsWLlyoP/7xj2rXrp1OPvlk7dmzR2PGjNHYsWM1f/58xcXFadGiRZ477ktLSzV16lTNnDlThmHoscce0+TJk7VlyxbFxsbqww8/1BNPPKH3339fffr0UV5enlatcp0IP/roIw0YMEDTpk3TVVdd1bSfMRCkKqpdFzQx4Y0/jcdG2NSlbbS2HSjXmj3FGtujfXOVBwAAADSdn7fTaaMDAJpqxc4iSVJWeoIkKSJUGt45ST9kH9S89fnqenKM74oDEDQ2frJRlQcrFdUuSp1Gd1JBdoEKsgtUW1nr+ffhontFS+ebW+PBzQe1e/FuWawW9bu4X71ekzk2Uzu/36mcBTka9OdBLVyhbzVnZ7t7ZPtvj/vR5K3MU8WBCoXFhOmEs0/Q6rdX09ke1A5sll46uVl3aZV03DGn076T0gbWa3/x8fGKjY1VSEiIUlJSVF5erueff16vv/66Tj/9dEnSyy+/rLlz5+rVV1/Vbbfd5nntjBkzNH78eElSdXW17r//fs2bN08jRoyQJHXp0kU//PCDXnzxRZ188sl69tlnFR8fr/fff182m2vqhxNOOMGzv1NPPbVObS+99JISEhL03Xff6cwzz9TOnTuVkpKicePGyWazqVOnTho2bJgkKSkpSSEhIYqNjVVKyrGn+gBwJMMwVF7j+lAtKjykSfvq2yFe2w6Uay2d7QAAAPA3ft5Op40OAGiq5YdGtg/KSPQ8dlrPdvoh+6Dmrs/XX07u6qvSAASRFa+skCQNuXqITplxiiTXiOXSvaWuzvYtrg73/NX5yv4qW5U7Kk2vcdWbrhtFu07sqtjU+s32mjk2Uwv/tVA537rWbQ/kGZwOrHdNI9+cI9vrM428e732zFMyFdfRNZNu+T4624NX2xNcDepm5DQMlZeXKTo6RtZj3THfSFu3bpXdbteoUaM8j9lsNg0bNkwbNmyos+2QIUM8/87OzlZFRYWnYe9WU1OjrKwsSdLKlSt10kkneRrxv5Wfn69//vOfWrBggfbt2yeHw6GKigrt3LlTknThhRfqySefVJcuXTRp0iRNnjxZZ511VoPXrwNwpOpap5yuJbwUHda0/1P9OsRr1qpcrWHddgAAAPibVtZOp40OAGiIippabcwrlSRldUrwPH5az/a69/ON+mVnoQ6WVatNTLiPKgQQDAq3F7qmAbdIWVdmeR63WC2K6xCnuA5xyjw5U5JUllemx1Ifk7PSKcP9AbUJDKeh1W+tluSaQr6+Oo7oqJCwEJXmum4aaNO9TUuV6HPNOrK9a/3XbN821zWFfJfxXRST7JqNpSy/LOBvbvgtWlVuYVH1HmFeb06nHCUlUlycZLU2774bKDo62vPvsjLXej9ffPGFOnToUGe78HDXxVtkZOQx9zd16lQdPHhQTz31lDIyMhQeHq4RI0aopqZGkpSenq5NmzZp3rx5mjt3rq699lo98sgj+u6777x+OACgfsqraz3/jrQ1bWR7nw6uu83W7ilp0n4AAACAZhfA7XTa6ACANbuL5XAaSomLUGp8pOx2uyQpNT5CfdLitC63RPM37tOFQ9J9XCmAQLbiP65R7V3GdVFCZsIxt41IiHD9w5CqS6oV1i6shatzyVmQo+KdxQqPD1fP3/Ws9+tska5123cs3KGcb3MCtrPdXmFX4XZXx3hzTiNfvLNYjhqHQsKO3gdhr7Br5/eum3u7ju+q6PauNk5tZa1qymoUHhs8N4v5tgcYTdK1a1eFhYVp0aJFnsfsdruWLl2q3r17e31d7969FR4erp07d6pbt251/qSnuy7e+vfvr++//95zkfdbixYt0o033qjJkyerT58+Cg8P14EDB+psExkZqbPOOktPP/20FixYoMWLF2vNmjWSpLCwMDkcjqb+CICgVFHj+r8TaQuR1dq0u8P6doiXJO0pqlRheU2TawMABD7DMFRVXKXCbYXas3SPsmdna/U7q7Xk6SX69u5v9eUNX2r5q8t9XSYAmI42OgCgIZYfWq99UEbCEc+N65UsSZq7Pt/EigAEG2etUytfWylJ9VrTPDQiVCGHljWtLq5uydLqWPWGawr5Pn/oo9CIho0hzjwlU5Krwz5QHdh0QDKkyDaRimoX1eT9RSdHyxZtk+E0VJRT5HW7Hd/vkKPGobj0OLXp0UZhMWGyRblu5A22ddsZ2d6KRUdH65prrtFtt92mpKQkderUSQ8//LAqKir0pz/9yevrYmNjdeutt+qmm26S0+nU6NGjVVxcrEWLFikuLk5Tp07V9ddfr5kzZ2rKlCm64447FB8fr59++knDhg1Tjx491L17d7311lsaMmSISkpKdNttt9W50/7111+Xw+HQ8OHDFRUVpbfffluRkZHKyMiQJGVmZmrhwoWaMmWKwsPD1bZt2xb/eQGBwr1ee3QT12uXpLgImzLbRCnnYIXW7CnWmBOafucbACAwrX1/rebcMkfl+8rlrHUed/sOwzoouV+yCZUBgH+gjQ4AaIgVh9Zrz0pPPOK58b2T9dQ3W/T9lgOqsjsU0cSZDQHgaLK/zlbpnlJFtolUj9/1qNdrIhIiVJ5frqqiqhauzqWmrEbrP1wvSRo4dWCDX585NlPf3ftdQK/bfmDDr+u1N8f3Z7FYlNglUfvW7HNNv3/C0WcEOHwKeff7RidHq2h7kcryyzwj5IMBI9tbuQcffFDnn3++Lr30Ug0aNEjZ2dn6+uuvlZh45EXa4f71r3/pzjvv1AMPPKBevXpp0qRJ+uKLL9S5c2dJUps2bTR//nyVlZXp5JNP1uDBg/Xyyy97ppd79dVXVVhYqEGDBunSSy/VjTfeqPbt23v2n5CQoJdfflmjRo1S//79NW/ePH322Wdq08b1n3LGjBnKyclR165d1a4dnXtAQ5RXu0acRDVxvXY39+j2VbuKmmV/AIDAtPS5pSrNLfV0tIdGhiquY5ySBySr86md1fvC3hp89WClDk6VJC17YZkvywUAn6CNDgCoD8MwtOLQ5zCHr9fu1ictTmnxEaq0O7Qo+8ARzwNAc1jximsK+QFTByg0vH6fNYfHuaYGryo2p7M9b1We7OV2xXaIVccRHRv8+o4ndlRIeIjK8sp0cPPBFqjQ95pzvXY3d0d5wdYCr9tsnbNVkmsKeTf3uu3l+xjZDj82ffp0TZ8+3fN1RESEnn76aT399NNH3X7s2LEyDOOIxy0Wi/7617/qr3/9q9f36t+/v77++uujPpeVlaWlS5fWeeyCCy7w/Pucc87ROeec43XfJ554olatWuX1eQDeVRwa2R7lZa2UhhrRtY0+X71Xc9bn64bTujfLPgEAgcUwDOWvdk1hedk3l6njiI6yRR59jd9t32zTW+Pe0uq3Vmv8Q+MVFmPOGm4A4Au00QEAjbG7sFL7S6tlC7F4BkEczmKxaFzvZL25eIfmbcjXab2YMQpA8yrdW6pNn22SJA360/GnkHdzr9tu1jTy7hH0samxjRq1HRoRqvQR6cpZkKOcBTlq2yPwZnBqic72xK6um4ULtxYe9fnSvaXat2afZJG6jOvieTw62bVue7BNI8/IdgBoZdwj26Prebfh8Uzqk6IQq0Vr9hQr50Bw/RIEANRPye4SVRdXyxpqVfqodK8d7ZLU+dTOanNCG9WU1mj1O6tNrBIAAABoHdyj2nunxnmdIt69bvu8DfvkdB55oxYANMWqN1bJcBhKH5neoE7a8ATXyPbqInM626tLXO/jHlHfGBljXUsn5Xyb0xwl+Z0WGdne9dDI9uyjj2zfNs81hXxqVqqi2v66Try7s70sv6zZamkN6GwHgFamuUe2t4kJ18iurukjv1izt1n2CQAILO5R7W16tDnu1HIWi0WDrx4sSVr2/LKjjuAEAAAAgtnyHYfWa+/kfZmRE7u0UUx4qPaXVmvV7iKTKgMQDAzD0PJXlkuSsv6c1aDXmj2NvHsEfVM62zuf4lqaKWdBTsB9RlFbXevpEG+JaeS9jWw/fL32w0W3Z2Q7AKAVKK85NLK9mdZsl6Qz+rnW1/18NZ3tAIAj7VuzT5KU3L9+01cOnDpQoRGhyl+Vr90/7W7J0gAAAIBW51jrtbuFhVp1cg9Xx8m8DfkmVAUgWOz4bocKtxYqLDZMfS7s06DXuqeRd0/v3tI8I9vjG9/Z3mFYB4VGhKo8v1wHNh5ortL8QsGWAhkOQ+Hx4YpJjWm2/Xqmkd9WKKfDWec5wzA8ne1dJ3St85xnzXY62wEA/qyi+tDI9vDmGdkuSZP6pijUatGGvSXauj+4pngBAByfe2R7+37t67V9ZFKk+k7pK8k1uh0AAACAS5XdofW5xZKkQccY2S5J4w9NJT93PZ3tAJqPe1R734v6KiwmrEGvjYg/tGZ7iUlrth8aQd+Uke2hEaHqOKKjJNfo9kBy+BTyjVnT3pv49HhZbVY5ahwq3VNa57l9a/epLK9MoZGhSh+VXuc5ppEPQk6n8/gbwWc4PsDRtcTI9oSoMI3u3laS9AWj2wEAv9HQke2SNOSaIZKkdf+3ThUHK1qkLgCBhTag/+MYAUDTrcstlt1hqG1MmDomRh5z21N6tFeI1aLN+WXacTC4RgkCaBmVhZVa/8F6SdLgqwY3+PXuEeamr9nehJHtkpR5SqakwFu33d3Z3rZX22bdrzXUqoTMBElSwda667a7R7VnjMk4YqlBz8j2fcH1O6v5empakbCwMFmtVuXm5qpdu3YKCwtr1js+3JxOp2pqalRVVSWrNajva2gQwzBUU1Oj/fv3y2q1KiysYXdWAYGuJUa2S66p5Bds2q/PV+fqxtO6N+u+AQCtV211rWeatYZ0tqcNTVPqoFTtXb5XK19bqZG3jmypEgG0cma10SXa6Y1FOx0Ams+KnUWSXOu1H+/3XXyUTcMyk7R420HN27BPfxrd2YQKAQSyNe+skaPaoeQByUodnNrg14cnHFqz3aRp5GtKalzv24SR7ZKUOTZT0q/rtrdUe8Nsh49sb25JXZNUsKVAhVsLPeveS/I6hbz068j2YJtGPig7261Wqzp37qy9e/cqNze3xd7HMAxVVlYqMjIyYP7jmikqKkqdOnXiAxDgN1piZLskTeiTon98vEab88u0Ob9UJyTHNuv+AQCt04GNB+SsdSo8PlxxHePq/TqLxaIh1wzRZ1d9pmUvLNOIm0fIYuWaGMCRzGqjS7TTm4p2OgA03a+d7Qn12n5872Qt3nZQc9fn0dkOoEkMw9Dyl11TyA/686BGXQ/7ahp59/s2VodhHRQaGaqK/RU6sOFAi3RO+0JLdrYndnMtdVKQ/evI9tqqWuV8lyNJ6jK+yxGviW7v6myvLqlWbVWtQiOCoxs6OL7LowgLC1OnTp1UW1srh8PRIu9ht9u1cOFCjRkzRjabrUXeI1CFhIQoNDSUDz+Ao6ioOTSyPax5R7bHR9o0pns7fbNxnz5fvVc3j6ezHQBQdwr5hl6b9b2or+bcMkeFWwu1bd62o971DACSOW10iXZ6U9BOB4DmsXxnoSQpK/3Y67W7je+drBmfr9fSnEIVVdQoIYrZRQA0Tu6yXOWvzldIeIj6XdKvUftwT+du1sh2zzTyTRzZHhoeqvSR6dr+zXZt/3Z7QHS2O+wOHdx8UFLLjWyXpMKthZ7Hdv24S7WVtYpJiVH7vu2PeE1EQoRCwkLkqHGoLL9MCRkJzV6XPwraznbJNdrGZrO1WAM7JCREtbW1ioiIoBEPoNmUVx8a2R7e/KfwMwek6puN+/TF6lzdNK47H6QBAJS/Ol+S1L7fkY2o4wmLDlP/y/pr6TNLtez5ZXS2Azimlm6jS7TTAQC+tbe4UnuLq2S1SAPS4+v1mvSkKPVMidXGvFJ9u2mfzs3q2MJVAghUy19xjWrvfUFvRSZGNmofEQmHRrYXm7Rme3HzdLZLrqnkt3+zXTsW7NCw64Y1eX++Vri1UE67U7Zom+Lr+TulIRK7HhrZftia7VvnbJXkGtV+tL4Di8Wi6PbRKtldovL88qDpbGfeLwBoZVpqZLskjeuVrLBQq7buL9fGvNJm3z8AoPU5fGR7Ywy5eogkadOsTSrZXdJsdQEAAACtzcpDU8j3TIlTVAOWBxzXy3UtPm/9vpYoC0AQqCmr0dp310qSBl01qNH78YxsLzZ5ZHt8M3S2n5Ip6dC67U6jyfvzNc8U8r3atciyfUndXCPbC7ILZBiun5d7vfajTSHv5l63vSy/rNlr8ld0tgNAK9NSa7ZLUmyETWNPcE058/nqll0vEwDQOrhHtif3a1xne/s+7ZUxJkOG09AvL//SnKUBANCquT+0BBA8PFPI13O9drdxvV3X4t9t3q/q2pZbbgVA4Fr3v3WqKatRUrckZYzJaPR+PGu2F1Wbci3j7tRvjpHtHYZ2kC3KpooDFdry1ZYm78/X9m9oufXaJSmxc6JkkWpKa1RxoELl+8u1d8VeSVKXcd4722OSYyRJ5fvKW6Quf0RnOwC0MhXVh0a2hzf/yHZJOnNAmiTpi9V7+fAHAIJcxcEKlea6Zjo52lpc9TXkGtfo9uUvL5fDzoeDAABsP1CuUQ/O163/W+XrUgCYaMWhke2DOtVvvXa3/h3i1T42XGXVtfppW8HxXwAAv7HilRWSpKw/ZzVp6dDwBFent7PWKXuFvVlqOxb3yHZ3J39ThISFaPDVgyVJX177pWrKapq8T186sP6AJKlt77Ytsv/QiFDFdYiT5Jqyfvs32yXDtcxgbGqs19e5R7aX59PZDgDwUxUtOLJdkk7r2V4RNqtyDlZoXS7T/QJAMHNPIZ/QOaFJd5H3Oq+XottHq2xvmTbN2tRc5aEVKd5VrI8v+1hvT3zb82EJAAQru8Op6f9dqdziKn20fLcKylv3B70A6qem1qk1e4olNXxku9Vq0WmeqeTzm7s0AAFu//r92vXjLllCLBo4dWCT9hUWE+bpWWzpddtrq2vlqHZ9Ft4cI9sl6ZQZpyghM0HFO4s1/5/zm2WfvuKZRr6FRrZLdaeS3zr31/XajyW6PdPIAwD8XPmhNdujW2hke3R4qE7t6Rq9+PnqvS3yHgCA1qGpU8i7hYSFKOtPWZKkZc8va3JdaD1qq2q18N8L9WzPZ7X6rdXaOmerNn6y0ddlAYBPzZyfrVW7iiRJTkOav5E1mIFgsGFviaprnUqIsqlz2+gGv37Coank523IZyZCAA2y/JXlkqQeZ/VQTEpMk/ZlsVgUEuX6XLqqqGXXbT/8Ru2w2LBm2WdYdJjOeOEMSdKSp5do95LdzbJfszkdTh3Y6BrZ3pKd7YldXTOxFGwt8KzX3nVC12O+hpHtAAC/V3Hobr6oFhrZLkln9ndNJf/56lwacAAQxPLXuDrb2/dv/BTyboOnDZYs0vZvtuvg5oNN3h/83+bPN+u5vs/p239+K3uFXeHxrpEIOd/m+LYwAPChX3YU6pn5rjVCB6QnSGKUKhAsVrjXa09PaNQUziO6tlFUWIj2Fldp+aHp6AHgeGqra7XqTdeyNVl/zmqWfYZEm9vZHhYTJmtI83VndpvYTf0v7S8Z0md//kyOmta33F1RTpFqq2oVGhGqhMyEFnsf98j2LV9sUcmuEoWEhSjjpIxjvsazZnsQdba3XE8NAKDZ1dQ6VeNwSmq5aeQl6ZQe7RUVFqLdhZVavbvY8yEQACC47FvtGmnX1JHtkpSQmaDuk7tryxdbtOyFZZr4+MQm7xP+qSC7QLOnz9aWL1ydSTGpMZrw6ARFtonUO5Pe0fb522UYRpPWCQSA1qisulY3/XelnIZ0blYH/Wl0Z5058wct3LJfVXaHImwtM3sZ/INhGHpx4Xa9szJEvYeXq3tKgq9LgslWHJrRIquB67W7RdhCdHrfVH24fLde/zFHgzMatx8ArZu9wq6cBTna8tUWbZu7TRUHKo65vbPWqeriasV2iFW3Sd2apQZPZ3txC3e2H5qmvrmmkD/cxMcnKvurbO1bu0+LHl6kMf8c0+zv0ZLcU8i37dm2WW9E+C33yPbcpbmSpE6jO8kWZTvmazwj2/cFT2c7I9sBoBWpPOwuu8iwlvsgJjIsxLMW2Oerc1vsfQAA/stwGtq39lBne/+md7ZL0pBrhkiSVr6+UvZKe7PsE/6jprxG3/y/b/Rcn+e05YststqsGnn7SF2/6Xr1u7ifOo3uJKvNquKdxSraXuTrcgHAdPfOWqedBRXqkBCpe3/XR33S4pQaH6GKGocWb2XWl0BmGIYem7NZj87dor2VFn29jqUDgtFy98j2Bq7XfrgrR2dKkr5cs1d7iyuboSoA/s74/+ydd3gcZ7m+79miXXVZXXK3Zcu9xj127MR2itOBVEghECDAoYZDzo8Oh0DgHHJogRBCeiGQ6jhxSbHj3nuTLEuW1XtbabVlfn/MfiPJVllJO7Oz8tzX5Qui3Z35NJqdme973+d5ZJnqU9XsfHwnL1z9Ar9O/jUvrXmJPX/cQ82pGlprWnv9JwrWC/5jQciKsnrbyAuXtFASkxrDNf93DQBbfr5FtWSPFPTIawdIHp/c5b/Hre49rx06lO2XUma7qWw3MTExiSBEXnuU1UKUTdt+qTXTs3jnUCnvHi7jkWsnY7GY6jMTExOTS4m6gjo8Lg9Wh1W1DRssOdfkkDg6kYaiBo798xiz7p0Vku2ahBdZljn+2nE2fGcDjecbASXD7ZrfX0Nqbqr6vqjYKIbPH07xtmLOfnSWYeNMNZaJicmlw3tHynht33kkCX53+ywSnIoiaOXkDJ7fWcSG4xWsmDT42BYT4yHLMr9Zf4o/f3xG/Vle5aWz+GyiUNXkpri2FUliUO6BU7MTWTgumZ0FtTy7vYjvXzspdIM0MTExDL52H/nr88l/T/lXX1jf5fXEUYnkXJtDzrU5pExIgT6WbUNtNa6XjbxQzmuhbAeYduc0Dr9wmPz38nnnwXe47+P7kCJkDbz6uNIckDoltY93Dg6hbBeMX9V7Xjt0KNtba1rxeXxYLwH3JrPYbmJiYhJBuALK9hiH9jeo5blpxDlslDa0caC43rQnMzExMbnEUPPap6ZjCVGDl8VqYe6X5vLhf33I3if2msX2IcKRl47wxmffAJS4gKt/dzW5N+V2axM/9sqxFG8rpvDDQuY8MEfvoZqYmJiEhYrGNh554wgAX7liPPPHdjSxrZyiFNs/OFGB3z/NbHIeYsiyzGPrT/FEoNB+ZW4aH56qMovtlyAir31CepzabDNQHrh8HDsLanl59zn+46ocYjSMGTQxMQkPr3/2dY6/dlz9b2uUldHLRisF9mtySJ2cGtZYLlFsF6p5rRDKdmeiU5PtS5LEmifW8Oepf+bcJ+fY97d9XPalyzTZV6jRS9nuTHQSkxqDq9pFTGoMmbMy+/xMdHI0kkVC9su4qlzEZ8drOkYjYNrIm5iYmEQQroCyXcu8doHTbmXVFNNK3sTExORSpeKwUmwPlYW8YPbnZ2OxWyjZVULZgbKQbtskPBx79RgAs+6bxUPHH2LSzZN6XPgZs2IMAGc/UnLbTUxMTIY6fr/Md187RL3Lw7ThCXxz5cQury8cl0ycw0Zlk5sjJQ1hGqWJFsiyzK/eP6kW2n98wxT+69pcAM5UteDzm/fBSwk1r33k4IUMV05KZ3RKDA2tHv697/ygt2diYmI8Kg4p8/Fpd0zjznfu5Hs13+NzGz/Hom8vIm1KWlgL7aCfsl21kddI2Q6QNDqJq355FQCbvreJxpJGzfYVKmS/TNUJfYrt0KFuH7dyXFDKf4vVQkxaDHDpWMmbxXYTExOTCKLFHVC2a5jX3pk107MAJQvMby4EmJiYmFxSVB5RskTTp4fW0jYuI47Jt04GYO8Te0O6bRP9kf0y5z45B8BlX7kMe3TvSq2Ri0ZidVhpLmum5rSZT2xiYjL0eWZ7IZ/kVeO0W3j89tkXxYE5bFaumKgskm48XhGOIZpogCzL/Oq9k/x1cwEAP71xKvcvGcuIYdHYJRm3109xrSvMozTRE6FsnzM6adDbslok7l88BoB/bCs012tMTIYgosi85PtLmHj9RKLiosI8oq5YYpTnGc2L7Q3aZbZ3Zt5X5zF8wXDcjW7WfXWd4RvDG4ob8LR4sNgtF2Wqa8HoK0YDMPX2qUF/RuS2t1S0aDImo2EW201MTEwiCKFsj3HoYxG2dGIq8U4bFY1u9hbV6bJPExMTExNjoJWyHZSiLCj24+4mbW3ntOLQc4c48fqJcA8j7FQcqaCtvg17rJ3M2X3bydmcNkYuHgnA2Q/Paj08ExMTk7ByqryJX71/EoD/t2YKOelx3b5v5RSlsW3TCbPYPhSQZZlfrjvBX7cohfaf3TSVewOFUatFIj1aeZ9pJX/p4PX5OVSsOFfMHhWaiL7PXDaSeKeNguoWPj5dGZJtmpiYGAcxT3bEa1tkHih628hrqWwHRYl9w99uwGKzcOqtU4af6wsL+dTc1JDF/vXGip+t4Gunv8akmycF/RmR295SaRbbTUxMTEwMRksgsz1WJ2W7w2Zl9RRl4fxd00q+C7Ut7bR7/eEehomJiYkmtLe0U5tfC4Re2Q4wetloUiam4GnxcPTloyHfvtbUnqnlzXvf5F93/CtimwVCRdHmIgBGLRmF1R7c84mwki/8qFCjUZmYmJiEH7fXxzdeOUC718+Vk9L57IJRPb53RW46VovEyfImU+0c4ciyzH+/e4K/faI0lP385mncs2hMl/dkxihqudMVTXoPzyRMnKpootXjI95hIyet+6ab/hLrsHHnfOW68vetZgOjiclQwu/z42nxABAVbyxFu0AvG/m2BmX7WhfbATKmZ7Dk+0sAeO9r79Fa16r5PgeKWmyfnKrL/mwOGykTUvr1GaFsN23kTUxMTEwMh8sdULbrkNkuuH5mwEr+aLmZKRfgaEkDC365iUdePxLuoZiYmJhoQtXxKpAhNj1WnSCFEkmSmPPgHAD2Pbkv5NvXGlEk9nv8lO2/tHPnRbFd2MoFw9gVYwEo/LgQ2Xy20Jyf/OQnSJLU5d+kSR2KhOXLl1/0+pe//OUu2zh37hxr1qwhJiaG9PR0Hn74Ybxer96/iolJRPHb9ac4Wd5ESmwUv/7UjF6zVZNiopg3RlG7mlbykYssy/x87QmeChQ+f3HzND638OL7Y1ag2J5nFtsvGQ6cqwdg1qgkLEFk3QbLPYtGY5FgW34NJ8uNnzFsYmISHO3N7er/16PIPBD0Kra3NyrHQmsbecGy/7eMlNwUmsub2fi9jbrscyBUn6gG9MlrHyiqst20kTcxMTExMRqqst2hj7IdYMn4VBKj7VQ1udl11sxWBXjnUCken8y7R0pp8/jCPRwTExMNuVQLgcJCXgtVu2DWvbOwRlkp21cWcQXrwo8L1f9fsrskfAMJM7IsU7Sl/8X24fOHY4+x46pyUXnMtD3Vg6lTp1JWVqb+27p1a5fXv/jFL3Z5/bHHHlNf8/l8rFmzhvb2drZv386zzz7LM888w49+9CO9fw0Tk4hhW361qmz+9admkBaEBezKyUpsi2klH5nIsszP1h7n6W3K3/2Xt0zns90U2gEyAzbypy8RpZcJ7A/ktc8emRTS7Y4YFsO10xSBxNOmut3EZMjQ3qQUmC12CzadokT7i1psbxg6ynZQYs9u+NsNABx46gBnPzLmtVUo2w1dbE83i+0mJiYmJgYlHMr2KJuFa6YKK/nIKoZoxebTygNNm8fP3sLIy7L3+2XufGo3/3PYalrhm5j0QlNpE7/N+C1rv7I23EPRncojSgFUi7x2QUxqDJNvnQzAvr9FjrpdluUuxfbS3ZduzErV8Spc1S5s0TaGzxse9OesUVZGXa7YnppW8vpgs9nIzMxU/6WmdrUbjImJ6fJ6QkKC+tqGDRs4fvw4L7zwArNmzeLaa6/l5z//OX/6059ob2+/cFcmJpc8sizzo7eUiJS7Foxi5ZTg7qWrAu/bdbaWBpdHs/GZaMOOghr+sa0QgEdvnc5dvcQGCGX7mapm0z3uEuFgQNkeqrz2znz+csUx6M2DpVQ3X9rxRiYmQwW9csoHg17KdnEsnIlOTffTmdFLRzP3y3MB+OCRD3Tbb7DIshwZxfaAsv1SsZE3ZluMiYmJiUm36J3ZLrh+Zhav7i3m/aPl/PTGqdisl26vVnlDGyfLO+z+tuRVcfkEffJxQkVhTQt7i+oBiQ9OVnLj7JHhHpKJiSEp21+Gq9rFwX8cZPVvVxMVa8ysNC0QynYti+0Acx6cw9FXjnLkxSOs/s1qouKMf4zrztTRVNJxH7iUle3CQn7kopFY+/lsMmbFGM5sOEPhR4Us+I8FWgzPpBN5eXlkZ2fjdDpZtGgRjz76KKNGdRSCXnzxRV544QUyMzO54YYb+OEPf0hMTAwAO3bsYPr06WRkdFwPrr76ar7yla9w7NgxZs+e3e0+3W43bnfHon9jo2Jv6/F48HjCV0gU+w7nGEyMSajOjfzKZs5UtWC3Snx3ZU7Q28tOiGJCeix5lS1sOl7GjYE4L5PIoLBKeTZYNiGFT8/O6vHv7vF4SHaA02ahzeunoLKBMSmxeg414jhW2sg3Xj3M5Kx47lk4istGJ/Uay2A06l0eCqoVVd/UrNherwkDuQ7NyI5j5ohEDp1v4LltZ/n6leMHN2ATkwDmM1P4aKlTrhlR8VGGPP4ejwdrTEexXcsxCmW7Ncaq67FY+J2F7PvLPkr3luJqdGGPtuu2775oKm3C3eBGskrEj4k35DkC4ExRGiSaK5oHNEajXIOC3b9ZbDcxMTGJIFztAWW7zhZCi8alMCzGTk1LOweK65k3JlnX/RuJLQFVu80i4fXLbDldxX9dNznMo+ofx8s6stxe2XveLLabmPSAyEnzuX2c/eAsuTfmhnlE+iDLsi428gBjlo8hOSeZ2vxajr56lDkPzNF0f6FA2Mhlzs6k/GA5DecaaC5vJi4z9Nn2Rmcgee2CsVd25Lb7fX4sl3Ajn9YsWLCAZ555htzcXMrKyvjpT3/K0qVLOXr0KPHx8dx1112MHj2a7OxsDh8+zH/+539y6tQpXn/9dQDKy8u7FNoB9b/Ly8t73O+jjz7KT3/604t+vmHDBrWQH042bjRuBqNJeBnsubGxRAKs5MT7+OTDDf367Bi7hTwsvPDRIWwlBwY1DhN92VOm/N2ba6tYt25dr++1SJDq8HHeK/HKe1uYkWyq23vj+TwLRbUWimpdvH+sguExMksz/cxNldFZhzAgzrcA2Eiwy+z4eFNQn+nvdWhWtMQhrDy9NZ/RrlPYzMcqkxBiPjPpT9NBpYHLjbvPe0q4EMp2b6uXtW+txWLX5sJTX14PwL5j+zjpOanJPrpDlmVsiTa8DV7efOJNYicZpzGu6ZByfkRlRrHhg/49a+qJq8AFQG1x7aDO43Bfg1wuV1DvM4vtJiYmJhFEizs8ynab1cKi8SmsO1LOroKaS7rYLizk714wiud2FnGyvInKxjbSE/SzMxosx0o7iu3bz9RSVNPCaFNNYWJyEe6mDkXm6XdPXzLF9ubyZlprWpEskuaWZJIkMeeLc9j0n5vY/+T+iCi2F32sFJgn3jARX7uPqmNVlOwpIfeGS+P8EMiyTOHmQmBgxfasOVlExUfRVt9GxaEKsuaYCk6tuPbaa9X/P2PGDBYsWMDo0aP55z//yQMPPMCDDz6ovj59+nSysrK46qqrOHPmDOPHD1wd98gjj/Dtb39b/e/GxkZGjhzJ6tWru9jU643H42Hjxo2sWrUKu904ChWT8BOqc+OZJ3cBDdy5bCrXzetfU2t2cT0bn9zN6WY7K1evIMqsmEUMRZsLoDCf8WNGct11U3t8nzjP5ozP5PzhChJG5HLd8nE6jjSyaPf6+cGBjwEvV+amsb2ghhKXn1cKrLxfZuczc4dz94KRDE+KDvdQe2RPYR0c3kNKQizXXXd5r+8d6HVolc/P+v/9hPJGN57smdw4J/h4HxOTnjCfmcLHSfdJznCG1OxUrrvuunAP5yI8Hg8b3u8o8q5YvILYNG3WFU95Tyn7uHoFqZP1dRZtWdJC/rp8xkSNYd5183Tdd2/sKdjDGc4w+rLRhjw/BE2lTZz+9ml8jT6uveZaJEv/XGmMcg0SDm19YRbbTUxMTCKIcCnbARaMDRTbz9byNd33bgy8Pj+f5CnF9ptnD+dAcT2HzzewJa+aT88dEebRBc/xQLHdKsn4ZIlX9hTzn9dMCvOoTEyMh1C2A+S9m4csyxFlWTlQhKo9eUKyLlZps+6bxYc/+JCS3SWUHyonc2am5vscKJ3z2scsH0NjcaNSbN996RXba07X0FLRgtVhZcSC/t8DLTYLo5eNJu/dPM5+dNYstutIUlISEydOJD8/v9vXFyxQbP3z8/MZP348mZmZ7N69u8t7KiqU60RmZs/fV4fDgcNxcc6k3W43xIKtUcZhYjwGc25UNbk5eL4BgNVTs/u9nbljUkmLd1DV5GZfcSPLJho3h9OkK21eRZ0e5wzu/JmYkQBUcKbaZV6LemH72Sqa2rykxjn4273zaGrz8OqeYp7fWcT5ulb+trWQv28rZOXkDO5bMoZF41IM97we0EwQ67QF/bfu73XIbof7lozlV++d5Jkd57h9/mjDHQeTyMV8ZtIfn0u5cDgTnYY99pJVIiouivbmdnwtPuzZoR+nLMuqjXxsSqzux2L4/OHkr8unYn+Fof4OtadrAUifmm6ocV1IYnYiALJPxtPoGXBDRrivQcHu22yRNTExuSQ5XtrI+brgLECMRLgy2wEWjFPU7PuK6vD4/Lrv3wgcLK6nsc1LUoydGSOSWBrIahfW8pGCsJG/IktZEHpt7/lL9m9qYtIbnYvtTSVNVByqCONo9KPySCWgfV67IDY9lkk3Kw0/+/+2X5d9DpTa/FqaSpuwOqyMXDSS4fMV1VDp7tIwj0x/hIX8iAUjsDkH1gSoWsl/VBiqYZkEQXNzM2fOnCErq/sGh4MHDwKory9atIgjR45QWVmpvmfjxo0kJCQwZcoUzcdrYhJJfHiyAlmGGSMSyUzsv/OVxSKxcrIS4bLpxKXx3DFUcAXm6jFBztUnZCjxM6crmjQb01Dg/aNKXMnqqRlYLRJJMVF86YrxbH54BU9+bi6X56Til2HD8Qru+tsurn58Cy/uKlKFCkagRYgmorQVTdw5bxTRdisny5vYUVCj6b5MTEy0RbjsOeIvblw1Eo4kZXzuBncf7xwY3lYvsk9Zu3QO4LlqsAyfp8z3S/aU6L7v3nBVKTWNhOHhcwsLBqvdSnSy4jzTUtES5tFoj1lsNzExueQoqmnhpj9t5drHP+FEWXA2IEbB5dZnktYdE9PjSYqx42r3cbSkQff9GwFhIb90QhpWi8SyCYrSZGt+NX5/ZOTsVTa1UdXkRpJg1XA/qXFRVDe7+cBczDMxuYj2pvYu/3363dNhGom+6JXX3pm5D84F4PDzh/G4PLrtt78IVfuIhUqBWRTbS3aXIEfIfSBUDCavXTBmxRhlW1uK8HvNpi+t+O53v8vmzZspLCxk+/bt3HLLLVitVu68807OnDnDz3/+c/bt20dhYSFvv/0299xzD8uWLWPGjBkArF69milTpvC5z32OQ4cOsX79en7wgx/w1a9+tVvluonJpczG40pTyqrJA29YWxn47KbjFcjypXVviWRc/SyoTkhX1F0FVS14zcbnbvH5ZTYeV4rt10zt6qRitUisnprJC19YwKZvL+NzC0cTE2XldEUz/++Noyz85Qf8Yu1xztWEX2ThCkjb4zR2KEyMsauOe09vPavpvkxMTLTF3agUr6MSosI8kt4RBfC2+jZNti9U7ZJFwh6rv7I5e142ADWnatSxGAGxVuVIMP5cLDZDed5prmgO80i0xyy2m5iYXHK8c6gUj0+mye3l3qd3U1wb/slXsKjKdof+ynaLRWJ+IKt919la3fdvBESx/YqAneOc0cOIjbJS29LeJQfdyJwoU5QTY1NiibHBp2YrhaKXdheHc1gmJoZEKNvjs+MBxUr+UkBvZTsoCudh44bhbnRz7J/HdNtvfxF57WOWjwGUhgSrw0pbfRu1+ZfOvXGwee2CzJmZOIc5aW9qp3TfpecOoBfnz5/nzjvvJDc3l9tuu42UlBR27txJWloaUVFRbNq0idWrVzNp0iS+853v8KlPfYp33nlH/bzVamXt2rVYrVYWLVrEZz/7We655x5+9rOfhfG3MjExHq3tPrbmK/OFlVMGfg9dkpNKtN1KaUNbxMwxTPqvbB+eGE203Uq7z09RBK1J6Mm+ojqqm9tJcNpYOC6lx/flpMfz85unsfO/ruJH109hTEoMjW1entp6lit++xEPPLOHLaerwtYg36Fs134d5/4lYwD44GQlZ6uHvorQxGSoohZTja5sT1TGp1WxXTQdOBIcYYnGiE2LJXG0YoVetq9M9/33hNqMEW/sZgyAuICTT0vl0L8nmcV2ExOTS461h5WbY0yUlcomN/c+vZvalvY+PmUM+tstH2oWBCa4uy5BS7LqZjeHA/mLywL28XarhUXjA1byeZFhJS/y2idnKcXDz1ymFNs/yauKqMYTExM9EBPcKZ9RbJLP7zyPq3pof098Hh9Vx5XrmZ7FdskiMeeLcwDY9+Q+3fbbHy7MawfFFk1kjZfsNpa1nJbUFdTRVNKExW5h5KKRA96OZJHUY2layWvHK6+8QmlpKW63m/Pnz/PKK68wfvx4AEaOHMnmzZupqamhra2NvLw8HnvsMRISuloSjh49mnXr1uFyuaiqquK3v/0tNlt4nkdNTIzK1vxq2jx+RgyLZlJm/IC347Rb1bgq00o+cuhvsd1ikchJVxag80wr+W4RFvIrJ2cQZet7CTvBaefzl4/lw+8s5x/3zeOKiWnIslJ4vufp3az83Wae3V5Is1tfi3mXGgeo/X1zXFocV01KR5bhH9tMdbuJSaQSKcVUZ1JA2a6R6rtzsT1cGNFK3gjHJViEst20kTcxMTEZYuRXNnOyvAmbReL1hxaTneikoLqF+5/ZY6hMr55ocYdP2Q6wYKyibN9bWIfvErPL3ZpXDcCUrATSEzpygq6YGFm57SKvfXJgAXB0cgyX56Qiy/DqHlPdbmLSGaFsT52USuasTJAh772hrW6vzavF1+4jKi6KpNFJuu571n2zsNgsnN9xnoojxisudM5rH7FwhPrz4Qs6rOQvFYSF/PB5w7HHDM7OT1jJn/3QXBA2MYlkyhpa+dpL+3n4tUP86aN83j1cxrHSBt2LWuFk03Hl3rVycsag1VdCGb/xuPHuhybdM5DG+I7c9qFvrdpfZFlm/TGl2H71tMw+3t0Vi0VixaR0nv38fD78zhXct3gMcQ4bBVUt/PjtYyz85Qf8bUuBFsPuFnEdjNFpHefzl48F4LW952kwcDyTiYlJz0SKTbjmyvZAFrzYTzgQVvKle4zjxOZuirxiu2kjb2JiYjLEeDegar98QiqTMhN47oH5JMXYOVRcz1df3I/H4FlpYgKvR0d0d0zOSiDeaaPJ7VUV0pcKqoV8blqXny8LWMrvK6qLiMXE46WKOn9KVofa5s75owD4595iMy/QxKQTotgeFRfFhDUTgKFvJd85r12y6GvTFpcZR+6NuQDs/9t+XfcdDEJ5LfLaBZ1z2y8VirYMPq9dMHaFsiBcvK0YX0D5ZWJiEnm8uPMcaw+X8dq+8/xm/Sm++tJ+1vx+K9N+vJ7LfrGJz/xlO9997RB//DCPj05VDrkscp9f5oOTyj101SAs5AVXTUpHkuBYaSOl9a1Bfaa41sWh4vpB79tkYPRX2Q4wMUOZk502le0Xcay0kZL6VqLtVpZNSOv7Az0wLi2On9w4lZ3/dRU/u2kq49NiaXZ7+d2m0yEcbe+43Pqu4ywen8KkzHhaPT5e2XNOl32amJiEFrWYatrIK/vpT1HZE9qxGLLY3hgZ5wdAbLqpbDcxMTEZkqw9rNwYr5+h3Chz0uP5+73zcNotfHSqiu//+4hhF378fnlAE/hQYu2S237pWMn7/bKqXBd57YLRKbGMSo7B65fZccbYx8TV7qUgkNs2uVOxfdWUDFJio6hscvPhycpwDc/ExHCICW5UfBQTr58IwJn1Z/B5hm5BsHOxPRzMeVCxkj/8/GE8rcZS4lxoIS8QxfbyA+WXTLFYKNtDUWxPm5pGTFoMHpfnkmpYMDEZahwLNHSunJzOrbOHM2dUEsmxivVpdbObPYV1/GvfeX674TT3/2MPX3h2L9XN7nAOOaQcLK6nurmdeKeN+QE3sMGQEudg7qhhAHzQh5W83y/z961nuep/NnPzn7dR1hBccd4ktHTM1YMvqE7MEDbyQ1/t1V+Ehfzy3DSiQ7D+Eeewcc+iMfzry4sB5e+ll9iiRZwbOinbJUlS1e3P7SgKW1a9iYnJwOlXkdlVC57w3PudiQEbeY2K7cKePuhie8l++NUoqDgWsjFkz80GCRrONRgid1yW5YhxPoBOme1msd3ExMRk6HCqvIm8ymairJYuaoO5o4fxp7vmYLVI/Hv/eR5bfyqMo+yZ1k7FnVhH+DIyxeLRzoLasI1Bb46WNlDT0k6cw8bc0cMuen1ZwEr+E4Pntp8qb0KWIS3eQWpcxwNZlM3Cpy9TLJFf3m12vpuYCDor27PnZROTGkNbfRvF24du5ELlEaXhRs+89s6MXzWexNGJtNW3cfxfx8Myhu7oLq9dMGzcMKKTo/G1+9RmhaFMw7kG6gvrkawSIxcPPK9dIEmSqm43reRNTCKXYwHXq68sz+F/b5/F6w8tYf8PV3Hox6t552uX8/s7Z/OdVRO5ZfZwoqwWPjhZyTWPb+GjU0Oj0VPYva/ITcduDc1Sm7CS39CLlXxFYxv3/mM3P197nHafH1mGUo0WvE16R6iX+9MYPyFdaYAuqG42HcYu4P2Ahfw1/bSQ74u4Tu5EzW36ONMJh8I4HddxbpyZTZzDRkl9K/vP1em2XxMTk9AgiqlBZbY/ewOs+67GI+oekdku7N5DjWg6EEX9Pjn0CvjcsPfpkI3BkeAgNVdZ9zVCbrvH5UEONFFFQrFdzWw3QKOC1pjFdhMTk0uGdwOq9mUTU0mM7povetXkDB69dToAT3x8hn9sM95ib0tggmaRwGEL3+V7wbgUAPYU1l4yHdKbTylF9CU5Kd0unglbO6PntotF0ClZCRe9dsc8xUr+49NVlARpVWliMtRRJ7hxUVisFnKuzQGGtpW8KBZnTA9PsV2ySMz5oqJu3/+kcazka/NqaS5rviivHZRi8aVkJV+4uRBQOvxDZVsnctuFVb+JiUlkUdXkprLJjSR1dU8CSIy2M31EIjfOzObrV03gd7fP4q2vLSE3I57q5nbu/8cefvL2Mdoi3DVm04nQWcgLxLZ2FtTQ1Hax28v6Y+Vc8/gWPsmrxmm3EB8oIkZCtNVQxBU4h2P7oV4enhRNTJQVj0+msMal1dAijvzKJvIrm7Fblez1UGK3Woi2K3+jJp2K7S3u/rseDBan3crVU5VGhbcOGsf62MTEJDiCVrbXFULFUTj6BrTrX8x0JOmT2R6VEETTgd8Hx9+EqHg4/Bq0h+6+aiQreXFuSBYJW3T4xHjBIpTtZma7iYmJyRBBlmXWBvLahYX8hdx22UgevlrJiv3Z2uO8cyj8N9DOuAITtNgoG5Kkb45uZ6ZlJxAbZaWh1cPJ8ksjW07Na5/Y/UR/0fgUbBaJwhoX5wy8SHK8LFBsz7642D42NZZF41KQZXh1z9BV7ZqY9AehbBcFxaGe297W0EbDOcUGOFw28gCz75+NZJU4t/UcVceN0cQkVO0jF43sktcuyJ6vPFtcCsX2UFrIC8ZeGcht31FsuPgAExOTvhEW8mNTY4MqJk3OSuCtry3h/iVjAHhmeyE3/nErxwONoZHG2eoW8iubsVkkrsgdeLb0hYxPi2Ncaiwen6zOR0BRyT7y+mG+9Pw+6lwepmYnsPbrS5kcaKjVS61r0hUxX4/uR0HVYpGYkC6s5C+NuXUwrD+mNK8syUklwWnv4939RzSmNHbTxKIFQtkeq3Mc4E2zlOfTd4+U6WaZb2JiEhqCzmzP2wiSFTwtcGKtDiPrimgG0DqzPShle9E2aK6AGx4HdwMcfytk4zBisd2R4AhrfSBYVGV7RYtho3tDhVlsNzExuSQ4UdZEQXULUTYLV03uuYDw0PLx3LtoNLIM3/7nQbbnV+s4yt4Ryna9cr56wma1MPcSym1vcHlU2zVhF38h8U47cwKZilsMbCV/vBdlO8CdCxR1+z/3FJs2hhojyzJ7C2sjXsU11OlsIw+Qc3UOklWi6ngVdWeHnh2jsJBPGJlA9LDosI0jPjue3BuU5reDTx8M2zg6I4rto5d3X2C+lJTtWhTbkyckE58dj8/t4/yO8yHbromJiT6Ihs6p2YlBf8Zpt/LjG6byzP3zSI1zcLqimZv/tI2nPimIOPesTQGb94XjUkJeGBTqdrGPw+fruf73W3l5dzGSBF+6YhxvPLSEnPQ44h1C2W42LemNx+enPTB/6m9BdUKG4gZx+hJQfAWLyGu/ZmpoLeQFotiul7K9WSjbdY4DXDw+hdS4KGpb2tmaZ5y1LRMTk74JWtmevwlGL4ZRi+HwKzqMrCt62cgHZZd+9N+QNBqmfQrGLoP9z4ZsHMPnBeb7e0rCXjCOpLx2gNh0pdjua/dpdp4YBbPYbmJi0m8aXB4eXXeC0xHUeb02YCG/IjeN+F4WQCRJ4kc3TGXN9Cw8PpkHn9/HiTJjKCxc7R3K9nCzIJDbvusSyG3fdqYavww56XGMGBbT4/tEId6oVvI+v8zJ8p6V7QBXT81gWIyd8sY2Pj5lzN9jqPDy7mI+/ZcdPPHxmXAPxaQHfO0+fIHrrshJcyY5GXW50pQyFNXtFUfCayHfGWElf/SFo/jbw9v801teu0BMvqtPVtPWMHSzcptKm6jNr0WySOp3IRRIkqRayZ/9yHhRPiYmJr0jooqm9vCM2RvLc9NZ/82lrJycTrvPzy/ePcE9T++mojFyrqUbNbCQF4jc9g9PVvLHD/O49c/bKahuITPByYtfWMAj104mKhAxFqdzAdGkAzFXB4juZ7F9YsBe9XRl5KyvaMn5OhdHShqwSB3nf6gRa0LdxTNoQbiU7TarRXV2fOvg0G8INTEZKvh9fjwtyvWp18x2Txuc3QI5K2Hm7VDwMTSW6TPIAKLYrrWNvCOxj8KyzwPH34Zpt4IkwZx74dwOqDodknFkzsrEYrPgqnKpboDhQjQg9HpuGAh7tF0d61C3kjeL7SYmJv3mtX3F/HVLAX/+KD/cQwkKWZZ594jysLGmBwv5zlgtEv97+0wWjUuh2e3l1++f1HqIQdHiNoayHWDhOKXYvruwNuwdfVoj8tqvmNi7JeTSQG779jM1hrRoO1vdQpvHT0yUlTEpsd2+x2Gz8um5ShbxK3vO6Tm8S44PTyqLskdKwvuQbtIzQtUOHcp2GNpW8iKvPX1G+CzkBeOvHk/CyARaa1tp2BHe70mXvPYFI7p9T2x6LEljkkCG0r3ht5bTCpHXnjkrMzgrv34grOTN3HYTk8jj+CCK7QApcQ7+ds9l/Pct03DaLWzNr+bqx7fw0cnKUA5TE2pb2tlbqDQg9+agNlDmjBpGcmwUjW1efrvhNF6/zHXTM3n/m0tZPL6r61acw8xsDxetgWK7zSIRZe3fUqtQtps28grCQn7emGRS47RR7emtbBeZ7bE6K9uhw0p+w/EKtegfbmqa3Ty/o5Dalva+32xicgnSeS2iV/Xyue3gccGEVTDlZrDY4chr2g+wE3rZyPep4i7YDK21MPVW5b8n3wDRySFTt9ucNjVqL9xW8v1S+xsEkdveUtES5pFoi1lsNzEx6TdC0V7nigx7uqMljRTVuHDaLVw1KbgFEIfNyi9vnQ4oed0l9a1aDjEoRLd8jD38yvbpw5Nw2i3UtrSTVzl0u9JkWe6U1957sX3a8ESGxdhpdns5WFyvw+j6h7D3nJQZj9XSc6bPHfMVpeKHJyspawj/eT8U8ftl9hYpFuSlBri2mHSPyEizOqxY7R1NThPXTAQU9W37EFsgEjbyRlC2W6wW5nxBUbdXbwiv7aVQWveU1y64FKzkhYX8qGWhU7ULhLK9ZFdJUN+tptIm9jyxh9Za8zpqYhJOmt1ezlYrC2c9RRUFgyRJ3L1gNGu/vpSp2QnUuzw89OJ+qpuNbTf50clK/LLyu/fmgjVQrBZJncPGRln5zadn8Ke75pAUc7GaSSjbzcx2/RGRb9FR1n7np04MFNvPVrcYsmlbb9YLC/lp2ljIA2rcg/7Kdv3XcmaNTGJUcgyudh+bThijgenJTwr44VvHuOlPW80mExOTbhA24Ra7BVtvTTp5myA+G9KnQHQS5F4Dh1/VZ5ABHElKwdfd5EbWIAZIuMb1WVg+9jqkTIBMZS0fmwNm3gmHXgZvaJ4lRW57yZ7wzvfFWlUkFdvV3PZKs9jeb5qamvjmN7/J6NGjiY6OZvHixezZs0d9XZZlfvSjH5GVlUV0dDQrV64kL6+rOqi2tpa7776bhIQEkpKSeOCBB2huHroFHROTSOJMlXJhbImQjvm1R5SOsysnpferk3hsaiyLx6cgy/DqnmKthhc0RlK2R9kszB2tZJTvKhi6ue2nK5opb2zDabcwP2Cd3xNWi8TlAXW7Ea3k1bz2PhRH49PiWDA2Gb8M/9xj5uZqQUF1M/WBZiUjNPKYdM+Fee2C1MmpJI1Nwuf2cfaDoWN3LcuyqmzPmBH+YjvA7M/PRrJItBxroeZU+O41RR8HMsp7yGsXDF+gFNtLdw9dZbsoto+5YkzItz1s7DASRyfi9/o5t7VndxVZljn47EH+PPXPrHtoHTt+tyPkYzExMQmek4GGzswEJykhUKHmpMfxxkNLmDEikVaPjye3FAx6m1qyMZClrpXdNcB3VufyrZUTWfeNpXzmspE9FnNFZrtpI68/rYOIfMtOdBLnsOHxyRRWD+1F6L6oanKzp0hxirhao7x26HCB0OO74vfLHcKJMKzlSJKkqtvfNoiVfFVAlVlc28qtT2w38+RNTC4gaOVy3gaYsFKxTQeluFxxFMqPajzCDlS3M7lj3KFEbLNXVzWvG06s7bCQF8y5B1w1cPLdkIxFRMcZRtkeHznFdqFsN23kB8AXvvAFNm7cyPPPP8+RI0dYvXo1K1eupKREuak/9thj/P73v+cvf/kLu3btIjY2lquvvpq2tg67ibvvvptjx46xceNG1q5dy5YtW3jwwQe1GK6JiUk/kGWZ/ICSORLs6WRZ5t3DioX89UFYyF/InQGV7z/3FOMNc5e5kTLbARaMTQFg59mhm9v+8Sml83vRuBSc9r4nxksnGDe3XSjbp2Ql9vlecd6/uuccPg06Uy919hTWqf+/qc1Lo06KCpP+0VOxXZIk1Ur+9Luhyf8yAg1FDbQ3tWOxW0jJTQn3cABIGJHAqCuU61HxtvA0vQWT1y4Y6sr25opmqk8qi6GjloZe2Q59W8k3ljTy8g0v89Z9b6lWhY3FjZqMxcTEJDgGk9feE1E2C99aqTjJPLejkKomY6rb2zw+tuQpz/2rJmtXbM9MdPKNlRMY3UMUlMC0kQ8famP8ADK5JUkiJz2Q2z7EF6H7YuPxCmQZZo5IJDspWrP9qDbyOnxXXB6f+v/DtZYjiu0fn6qizgDOXOK4xzlsNLV5ufcfu3l5txljZ2IiUJXLvRVT6wqhJg9yVnX8LGclxKTA4Ve0HWAnbE4b1kAjkRZW8mpme2+NB/kfgLuhw0JekD4JRi6A/c+FZCxC2V62r0wTFX+wqJntCZGR2Q6dlO2mjXz/aG1t5d///jePPfYYy5YtIycnh5/85Cfk5OTwxBNPIMsyjz/+OD/4wQ+46aabmDFjBs899xylpaW8+eabAJw4cYL333+fp556igULFnD55Zfzhz/8gVdeeYXS0qGrFDExiQRqWtppaFUKQ5EwiT90voHzda3ERFlZkdv/DL3VUzMYFmOnvLFNtRMPF8KabiATeC1YEFB67yoYurntwVrIC5YFlO2HSxoMMYntTLDKdlAs+xKj7ZQ2tBmycSDS2VPYtUGlTKNsK5PBIazbupvgCiv5/HX5Q+b6V3FEUealTU7rYpsfbuKzFWvVtrrwfE9qTtfQXN6MzWnrMa9dkDk7E8kq0VTaRGPJ0CsAF21RVO3p09OJSQm9VTJ0WMlfWGyXZZmDzyhq9rx387BGWRl9heI00FpjOoSYmISTY6UNQHDPmP1heW4as0Ym0ebx89fNZ0K67VCxo6AGV7uPzAQn04aH9vcfCHHCGjsC5ulDDVFQHahyeYJabL+0LbXfP6ZYyF+toYU8QLyONvKuwPdRksBpD0+aa056PFOyEvD6Zd4L2PSHE9Gc8uMbpnDzrGx8fplHXj/CL9edMJv9TUzoVEyN76WYmrcRLDYYt7zjZ1Y7TPsUHH4N/L4ePxpqnEmK6lxYvocSVcWd2Eux/ei/IX2qUly/kDn3QsFHSnPCIEmfmo4t2oa70U3N6fA576lrVRFoIz/Ule0hb6nzer34fD6czq7WDtHR0WzdupWzZ89SXl7OypUr1dcSExNZsGABO3bs4I477mDHjh0kJSVx2WWXqe9ZuXIlFouFXbt2ccstt1y0X7fbjdvd0e3c2KgscHk8Hjye8CjGxH7DtX8T4xLJ58apsnr1/7e4vYb/Hd4+oNhgr8hNwyb58Xj6p063ALfOzubv24p4cWcRy3J6txLXkqZW5WbqtFuCPu5anmtTM2OJslmobnZzuqyBcWm9Ky0ijRa3Vy2KLhk/LKhjmBJjZWJ6HKcrm9l8qoI107VdJAiWqiY31c1uLBKMS3Z2uTd293tZgVtmZfHMjnO8uLOQy8cP03nE+nKqvInv/OsIX18xnqunam+fvTdwXkkSyDIU1zQxLqUXS6xLACPeF131LgDssfaLxjV8yXDsMXYazzdSsq+EjJnGsF0fDGUHFBeYtGlphvo7iG5tV60rLOM684FS4Bm+cDiyVe51DFKURNrUNCoPV3Ju+zlyb87Va5i6oGbXLx2p2d9ixOVKQ0Pp3lKaqptwJjppKmli3UPrOPOe8rfIuiyL65+6nppTNRRtLqKluiUk4zHCdchI3z0Tk2DRQtkOitr3mysncN8/9vDCriIevGIc6fHGel7qsJBP73dOtxbEq5nt5rVEb4SNfIx9YMusIrc9r/LSLbY3tHrYnq846FyjoYU8dHxXGnWwkW/p5FAYzuvETbOyOV7WyJsHS7hrgTYORcEihDvJsVH87vZZjE2N43ebTvPklgIKq1t4/I5ZxBjE0dHEpDOyLOvyPQ6qmJq/CUYuBOcFz18z7oDdT0LBx5BzlXaD7IQzyUlLRUvIle2yX+47n7zdBafeg6Xf7v71qTfD+9+H/c/DVT8c1HgsNgtZc7Io3lZMyZ4SUielDmp7AyUSbeRj0y8NZXvI71zx8fEsWrSIn//850yePJmMjAxefvllduzYQU5ODuXlSgddRkbXRcmMjAz1tfLyctLTuypQbTYbycnJ6nsu5NFHH+WnP/3pRT/fsGEDMTHaKC+CZePGjWHdv4lxicRzY3uFhFKKg8bWdtatWxfeAfWCX4bX91sBicz2EtatG1j+dEYrgI2PTlXy0hvrSArTvez4WQtgoay4kHXr+pddqNW5NirGSn6jxNNrt7A4Y2h1IB+tlfD4rKQ4ZI7t3MzxIJ+ns60WTmPh5Y8OIhWHN3pAcKJO+d6mOWU+2rS+y2s9nRtZLgAbH56s5OU315EYOe5E/ebFfAunqiw8+vZBfEXadv82tMO5WhsSMuPjIb9RYsO2vbTkD63vz0Ax0n2xdqvSFNHY1tjtvS56WjSe3R7effxdMj9jjMaawVC4sRCAGluNoe7tZbVKE0DekTza1umvbi98pRAAd5Y7qOPiy1CuIZ+8+glnooypxBwoJ989CUBNnLbniCPbgbvUzRuPv4G30UvJ30vwu/xINonMuzJJvymdPYV7aM5TuuKrz1WHdDzhvA65XK6w7dvEZCC0e/3kBRQqU7P7jirqL1dMVNTtB4vr+evmAn54/ZSQ72Og+P0yH5xQiu2rphjjOSDetJEPG6qN/ECV7RmmjfyHJyvw+mUmZsQxLi1O0311NKboUGwPnBuxYchr78wNM7P51fsn2X22ltL6Vk1t+vuiuZONvCRJfGPlBMakxvDwa4fZcLyC2/66g7/fO4+MBGM1WGmBLMt88bl91LvaeemLC4myhcf9wKR3ZFnm3Yfe5dSbp/jini+SMEJbN5s+beQ9bXB2C1zxnxe/NnwOpEyAw6/qV2wP5KmHutje3twOctd9XETeBvC0KHnt3REVC9M/DQdfhOWPgHVw5dDsedkUbyumdE8pMz83c1DbGihqsT2ClO0is90stg+A559/ns9//vMMHz4cq9XKnDlzuPPOO9m3b58WuwPgkUce4dvf7uhgaWxsZOTIkaxevZqEhPDYeXk8HjZu3MiqVauw2+1hGYOJMYnkc+PAupNQoGQp+WSJq1Zfg8OgD4P7z9VTv3M3sQ4r37r9KhyDsMXdVL+H3YV11CTlcteK8SEcZfBsffMYlJcwY/JErrtiXFCf0fpcy3Pk88ePC3DFDee662aEfPvhZPc7J4Birpk5ijVrJgf9ufj8aj5+dj+F7miuvXaZIVQu5zYXwMl85uVkqX+nYM6NjfW72VtUT0X8RO68KkfPIetGu9fPDw98DHgpcUnMWLSCEcO0W3h472g57DtMbmYC80Ynkb+rmJQROVy3aoJm+4wEjHhf3Fe8j3OcI2tMFtddd91Frx8oPcB7u9/Desba7euRxl+//1cAln1mGeOvDs99rjt2nNpBxasVpMWl6X6cZVnm91/+PQArv7AyqJzyg+UHWbdxHdG10UPivBC4ql0cPHcQgJv+4ya1M10TroODTx2k/IlyWmsVi/jsedms+dsa0qZ0xLpUjqwk/wf5WNyWkBxrI1yHhDubiUmkkF/ZTLvPT7zTpsnzkyRJfGvVRO59ejcv7CziS8vGkW6Q4suRkgYqGt3ERllZOC587medidOxgGjSlVZhIz/AyDehbC+sbqHd678kC27vB+zNtVa1g8428p2U7eEkOyma+WOS2XW2lncOlfKlK8L3vN/RgNBxTG6aNZzhSdE8+Pw+jpY0ctMft/H3+y7TpJHLSJQ3trEp0Lh1pKSBuaOHtqtgpLLz8Z3s+4tS1yreXszU26Zqur8+i6nntoPHBRNWXfyaJMHM2+GT/wV3Mzi0bV6CDht5ka8eKsRxsNgtai78RRz9N2TPhuRe1snn3At7n4b8jZB77aDGNHzecABK94Qv6jqSbeRbKs1ie78ZP348mzdvpqWlhcbGRrKysrj99tsZN24cmZnKQ1NFRQVZWVnqZyoqKpg1axYAmZmZVFZWdtmm1+ultrZW/fyFOBwOHI6LTzC73R72RVsjjMHEmETiuXH2glzMdr9EnEF/h/eOKdeR1VMyiYsZ3KLM3QtHs7uwjn/tK+EbK3OxWvQvoLYGLPDjo6P6fd5oda4tzknjjx8XsKewHpstvLZooUSWZbYELOxWTMro17FbnJOOw2ahotFNYZ1bXTgJJycDDzPTRiRd9Lv0dm58btEY9hYd5InNBcwelczKKZFvlX0hWwsqu9gHfni6hgcuH6vZ/g6cVwop88cmq2qC8qb2iLsXaIWR7os+l7Iw5kxwdjumSTdM4r2H3qNkVwmeBg8xqeF1UhoM3jYvtXmKkj97drZh/gYAsSnKpKy9Uf/vSfWpalrKW7A5bYxePBpbENawoxYpBfmyvWXYrDakMDwvaEHpTmUxIXVyKknDkzTd1/irxnPwqYO01rZidVhZ8bMVLPr2IiwXFB4SMpWG6ra6tpAe63Beh4z03TMxCQY1rz0rQbN5wLIJqcwZlcT+c/U8sfkMP75B2wXuYBHFkSty03DYwqtYFcQFCldmZrv+tLhFsX1gy6xZiU7iHTaa3F7OVreQmxn+OaSeuNq9bD5dBWif1w6QEGhMadLFRn5wrgeh5KZZw9l1tpa3Doa32C4aguIcXb8vl41J5s2HlnD/M7s5U9XCZ/6ygz/cOZurJg+9dQjB4fMN6v8/cK7OLLYbkKItRWx8uMP5SjQDa4kopvaY2Z63CeKzIb0Hx5/pt8GHv4AT78CsOzUaZQdqZnuIle0iA96R4Oj+OdPdpCjbV/y/3jeUPQuyZsK+ZwddbM+elw1A+cFyfB4f1kEI+waKaELo8fwwIELZPtQz2zVtlYyNjSUrK4u6ujrWr1/PTTfdxNixY8nMzOSDDz5Q39fY2MiuXbtYtGgRAIsWLaK+vr6LEv7DDz/E7/ezYMECLYdsYmLSB2equl4Ujdo17/fLrDuiWM+umZ7Vx7v75uqpmSTF2CltaGNLXtWgtzcQjNIR3ZnZo4Zht0qUN7ZxrnboWJ8W1rgorm3FbpVYND6lX5912q3MH6uoW7acDs+5ciEnAlmaU7L65/Ry48xsPj13BH4ZvvrSfvYV1WoxvLCy7rBynUiKUQocG451H1cTKvYV1QEwd/QwtdheUq/9ZM2k/7Q39z7BTRiRQOasTJAh//18PYcWcqpOVCH7ZKKTo4nPNtbirnOYNhP3YCj8qBCAEYtGYHMGd+9Nm5KGPcZOe1M71SerNRydvhRtKQJg9BWjNd9XzjU5DBs3jFGXj+JLB77Eku8tuajQDhCdolxDZb+sLsSYmJjoS0deu3bKQ6FuB3hx1zkqGo3xfRd57asM1IyqKtvdXmTZjCjSk1ZRUB2gsl2SJHJUK/lLL7d9y+kq2jx+RiZH93vOOhA6lO362cgbIYP82mmZ2K0Sx8sayQvTeeb3y2qOfVw3z9ejUmJ4/aElLMlJwdXu40vP76OweugqIY+WdC6214dvICbd0lTaxGu3vYbsk5GsSrG3tU779Zs+le35G2HCSkXF3h3DRsPoJXD4FY1G2BVHojLOUM/ZxXHo0UL+1HvgbYOpt/S9sTn3Qt56aBycIj05JxlnkhNvm5fKo5V9f0ADItFGXijbPS0e2lvawzwa7dCk2L5+/Xref/99zp49y8aNG1mxYgWTJk3i/vvvR5IkvvnNb/KLX/yCt99+myNHjnDPPfeQnZ3NzTffDMDkyZO55ppr+OIXv8ju3bvZtm0bX/va17jjjjvIzs7WYsgmJiZB0NruU4tCwtbMqHlwewprqWxyE++0sXRi6qC357RbuXX2CABe3nVu0NsbCIPNgdOC6CgrM0ckAbCrYOgUYj8+pTwwzRuT3MXaLFiumKjY3G7JC3+hpcXt5WyNMjmdkt2/hQtJknj01umsyE3D7fXz+Wf2kl85dBZ/PD4/GwILpT9Yo3QE7ymspaY5tNZXgha3V12UnjcmmeGB7t9Ss9huSNRie1zP3cIT1ij2/6fXntZlTFohVO2pk1MN51CidsnXhaHY/nEhAGOWjwn6Mxabhay5SpNfye4SDUYVHoo2K8X2MVeM0XxfziQnX8//Ovd/cj9pk9N6fJ/NYcMeqyyWt9aY11ETk3BwvEwU27Utjl2ek8rc0cNo9/p54uMzmu4rGIprXZwsb8JqkViRmx7u4ajEO5Rroix3NGqb6IMoHg6moDoxXWl4zKsc2qqv7uhsIa/Hs2i8qmzXwUbeLUQT4V/HGRYbpa5VvH0oPBbILk/HtelCZbsgMdrOM/fPZ+G4ZLx+mRd2Fuk1PN3prGzff64ujCMxuRBfu4/XPvMaLRUtpE9PZ84X5wD6zEtFZnu3jf91RVB9GnK6sZDvzMw7oGDzoIvLwaDO2UPcAC1s6XssKh99HUYugKSRfW9s+qfB5lSy2weBJElkX6bUJ8NlJS/Oj0gqtkfFRWGLVq75Qzm3XZNie0NDA1/96leZNGkS99xzD5dffjnr169XbfG+973v8fWvf50HH3yQefPm0dzczPvvv4/T2dGl8uKLLzJp0iSuuuoqrrvuOi6//HKefPJJLYZrYmISJAXVzciyogDNDnSVCUsso/FuQNV+9dTMkNn63TlfuXl/cLIyLIoKIyrbARYEMgp3nq0J80hCh7CwExPR/rIs8LldBTW0ecK70HWyvAlZhowEB6lx/X8Qs1st/OnuOcwamURDq4d7/r6bsoahUdTYfqaGhlYPqXFR3DJ7OFOzE/DLyndcCw4W1+PzywxPiiY78A+gvKENn99UHxkNdQIT3/P3RhTbz6w/g9/r12VcWiAmxdHJoc/bHSxaWdL1hSzLAyq2AwxfoOS4DZVie1t9G+UHlUVwPZTtQNAL7TEpSnyDq2bouOuYmEQKfr+suidNHa5tsV2SJL61UlG3v7T7HOVhdrMQFvLzxgwjKcY4Fp5Ou0WNOzNqU/xQxdU+uMx2gAkBZXu4FMfhot3r54MTyvzrGh0s5KGj2N7S7tN8HibWzAbSxK8FN85SnlPfOlgaFgcM4Y5ptUg4unEuEtitFh5cpmQwv7bvPK1DsIFIluUuyvayhrYhs9YyFNjw3Q0Uby/Gkejg9tdvJ2GE8qyji418Yy+Z3PkbwWKDcct738iUm8DmgCOvhX6AF6DVnF1VcCd2cxxa6yB/E0y9NbiNORMVBfz+58E/uLUbYSVfsic88331uPSyVmU0JEkiNl1Rtw9lK3lNiu233XYbZ86cwe12U1ZWxh//+EcSEztsxSRJ4mc/+xnl5eW0tbWxadMmJk6c2GUbycnJvPTSSzQ1NdHQ0MDTTz9NXFycFsM1MTEJkjNVSudRTlpch0WdAW3kfX6ZdUeUReE1MwZvIS+YkBHPvDHD8PllXttbHLLtBkvLIK3ptGLBWMVmfago29s8PnYWKI0DyweoVJmQHkdmghO318/us+E9LkJxNBg7vpgoG0/fN49xabGUNrRx79O7aXBprwLQmvc6NeVYLRJXT1UWd7Sykt9b2GEhD5Ae78RqkfD6Zao1UtObDBxPs3KO96ZsHz5/ODGpMbTVt1G8Xf/7QqgQmXBGnKypNvJ1bbouCNacqqGlQslrF8XzYBk+f2gV289tPQcyJE9IJj7LWDEDokHEVLabmOhPcZ2LJreXKJuF8Wnar9UsyUlh3hihbg9vfIuwkF9psBxhSZI6ctsNOE8fyrhCMFefmKHcYy81G/ntZ6ppcntJi3cwe6Q+edWd7cu1XtMymmhi5eR0YqKsnKt1caC4Xvf9i0agOIetz+bKKyamM2JYNA2tHt45HB4FqZaUNrRR09KOzSIxPk0pQh00reQNweEXDrP7D7sBuOX5W0jOSSZ6mDLv0FPZ3u38PG8jjFwIzj7W+JyJSj75oVcUyxsNEcVwd31o17V6tUs/+S74vTD15uA3OOdeqC+Csx8Palyi2B42ZXsE2shDR257S6WpbDcxMTHhTMDObHxanDpRMGLH/K6zNVQ3u0mMtnN5zuAt5Dtz5/xRALy8uxi/zkpU1X7MIB3Rgjmjh2G1SJTUt3K+LvKVZbvP1tLm8ZOZ4GRixsAWDiVJYukE5dz7JC+8ue3HRV77IO09k2OjeO7z80mPd3C6opkvPLcn7Kr9weDx+VkfKKqvma405ayeqiyYbsmrVmMbQsneQOb9vDHKIpLVIpGZoBQSL/Xc9tPvnKZmU42hcpd7tW4LYLFayLk2B4hsK/lgftdwIbrk/V4/Hh2bfISqfeTikdj6ed8VxfaKQxV4h0Cxo3BzIaCfqr0/iNx2PRQmJiYmXRHROLkZ8dit2i8tdVa3v7y7OGzqvwaXh12BZloj5bULOortkd8YG0m4QmEjHyi2F9a4cHsjd57VX8Sc7OqpGVgs+sQZOWxWNRqxUePvitHiAGOibKwOXLvePqh/oailU7G9L6wWibsXKM+fQ9FK/kjAQn5iRjwLxykiFtNKPvxUHK7gnQffAWDpD5aSe0Mu0NEEHtbMdk8bnN2i5LUHw8w7ofI4lB8J8Qi7opWNvNhet5ntR/8NYy6H+H44ooycD6m5sO/ZQY1r+Dxlvl95tFLXNQoAv8+Pp0XZZ6QV20Vuu2kjb2JiYgLkVwWK7emx6oOxFgWpwbL2sKJWvWZqZsgXfq6bnkWC00ZJfSuf5Oubx21UZXucw8a04Yp7yVBQt3e2kB9MXpywkt9yOry57R3K9sQ+3tk3I4bF8Ozn5xPvtLGnsI7/ePkAXl9kWmfvKqilzuUhOTaK+WOVKITcjHhGp8TQ7vWz5XRomyS8Pj/7i5SJ82VjktWfDw9YyV/que3vPfQexX8spqGwoe8360Qwme3QYSWf926e5mPSCqFsN2Kx3R5rh8BtT8/cdlFsH728/wXmxFGJxKbH4vf6Vfv1SEbPvPb+YtrIm5iED9HQqXVee2cWjU9h/thk2n1+/vxReLLbPz5dic8vMzEjjtEpsWEZQ28Ie2wjNsUPZVyqVfjA5+oZCQ7inTZ8fpmz1UN3IbozPr/MhmOKU8Q1U0PnShgMCU59XCDEmplRlO0AN81WCkVrD5fqPp8X16Zgvyu3XTaCKKuFw+cbOBQGJb6WHCmpB2D68ERmj1Ia8g+Yyvaw0lbfxqu3voq31cv4q8ez/CfL1ddURy09bOR7mp+f2w4eV9957YLxV0JMKhx+NcQj7IrWNvJRCRcch5ZqJY9+WpAW8gJJgrn3Kqr4loGv1cYPjycuMw7ZJ+s+3xfrVGDM9ZveEMV200bexMTEhA5le056Jxt5g03ivT4/7x9VbnTXzwz9ZM1pt3LrnBEAvLL7XMi33xOyLHfYjxlM2Q6wMFCs3BXhue07ztSwNmBPdkXuwPLaBZfnpCJJcKqiKWy5kl6fn5NloVG2CyZnJfC3ey4jymZhw/EKfvjWsbBkvQ2WdztZyNsCTTmSJKld/utDbCV/sryJlnYf8U6bqloByApMSi71Ynu4crl7I9hie87VOUhWiarjVdQX1uswstBj5MwvSZKwxSn3PT1UBDC4vHZQxjxUrOTdTW7K9ivXS0Mr200beRMT3TlWqjTI6VlslySJb65Umtxe3VMclucnka+7eHxoHdRChWiKN2Lc21BGzNWj7QMvtkuS1MlKfuguRHfmeGkjNS3txDtsLBiX3PcHQki80w5o7wLRIlwPDKJsB2WtIjk2iurmdraf0XcNp7kfynaAlDgH1wfiIZ8fYur2IyXKWs30EYnMGZUU+FkD7d7IFDREOrJf5o173qDuTB2JoxO59cVbsXQScOlqI9/T/DxvE8RnQ8bU4DZktcP0Tyu57b4gnwsay/qthNes2N7Qg8L/+FvK/06+qf8bnXGHUnQ/9PKAxyVJUthy28W5YY2yBufA194ChVvh2Juw5++w+TFY9z341+fhuZvgicvhfybBf2d3HFeNUG3kTWW7iYnJpU7n7urxaXFqwddoxfYdBTXUtrSTHBvFooANU6i5Y/5IQMnqq2zSpzDk9vrxBWzrjaZsB9SJ8a4w55MPlP3n6vjsU7u48287qWh0k5Hg4PIJg1tAGxYbxYyA4n/7mfCo2wtrWnB7/cREWRmdHBOy7S4cl8L/3T4LSYKXd5/j/z6ILEWv1+dXc9mvm97Vckrktn9wshJPCLv89xYq3405o5TYBUG2qmzX/lriavfy8u5zhrtuQ6dcbiMV24PMMXcmORm1RIkYOfbPY5qPSwvU39WgNmTWWOW+p9f5UX2yuiOvfX7/8toF2fMDk+8IL7bXn61H9slEp0STOHLwDimhRhTbTWW7iYn+HAtRVFF/WTw+lQVC3R6G7HbxHJUca0w1kVC2NxnweW8oE6rINxFjlneJ5LaLZv15Y5N1iaPojF4uEML1INjish7YrRY1Su0tna3kVaV/P47HZxcpDZ/vHCqlrqW9j3dHBrIsc+R8PaAo28emxpIYbcft9XMiIJgw0ZdPfvkJp985jdVh5fbXb1cdtASqjbwOynY1s/3C+Xn+Rsi5SikWB8uM26G5Ago+7v19njbY8lv4wxz4+2porQ96F8LmXRTHQ4UoLF9kI3/sDRi3HGIHsO4fmwKTb1Cs5AchHApXbnu/1m5a6+GpVfDMGnjtXlj3MOx+UokiaK4EZ5JirT/nHkgaCYde0XTssemmjbyJiYkJoKgu3V4/UVYLI4bFGNZG/l1hIT+tQ60aaiZlJjBnVBJev8y/9p3XZB8XIjrlYXA5cFpx2ZhkLBIU1bjCpuIeCMdKG3jgmT3c+uftbM2vxm6VuGfRaN752uUkBDrdB4NQJpSF6ZiIRdDJWQkhz7+7dnoWP7tpGgCPb8rjxV2R02W++2wtNS3tDIuxq9logtmjhpEaF0VTm5edBaHr8t8TsJAXee0CUWzXI7P92e1FPPL6ER57/6Tm++ovkaxsB5h570wAtj22zVC588Fi5Mx26FRs18lGfjB57YKhpGyHHnLyDIBYBDOV7SYm+lLV5KayyY0kKXMjvfnWKiW7/dU9xbo8Q3WmOVBUNVLhrDNxgTmMqWzXF5dHOd7Rg2yMn5AulO2XRrF9d6BZX8R66Um8bjbyAWW7wdZxbpqlFIrWHyunzePr492hQzQ3iOMfDLNHJjE1OwG316/bGpzWnK9rpc7lwW6VmJQVjyRJzA6o2w+Yue26k78+n49+9BEAa55YQ9aci51ShY18e3M7Po2/M6p9euf5eV0RVJ+GCUFayAuyZys55Yd7KKTKMpxcB39eAB8/CrPuAl97vwqvnddzQul82a2yvbFMUWr310K+M3PugZo8OLdjwJsQue16F9u7PTe6w+uGVz8LjSVw//vwvbPww2p4OB++uhPuWwu3PQvX/y+s+C+YdTec+QjatWtiN23kTUxMTALkByzkx6bGYrVIHfZ0Biu2i5zla6dl9vHOwXHnfEXF+MruYvx+7S20RVOD027pooo1CglOu6pqiQQr+fzKJr764n7W/H4rH5ysxGqRuO2yEXz03eX87KZppCeEpqiQEK0sdjVqbE3XEyJLc0qWNougn1s4mv+4MgeAH755NGImheuOKk05q6dkXqSgsFokVgWs5EV+4GCRZVlVtnfOawcYrqON/Jkq5Tr+4clKw1n/q5MzHTO5+6I/BeiZ98wkdXIqrTWtbHtsm9ZDCznBqvjDhTVOWbjWy0ZeZJQPJK9dICbftXm1uqgftKLHvECDoGd2oomJSQfHA6q7samxYYm4WjguhUXjUvD4ZP70kb7q9ubAc71hi+0GnacPdVRl+yALqhNUZfvQXYgW+P0yuwNzpAXhKLY79LGRF8r2WIM5FM4ZNYzhSdE0u718cKJSt/02DyDDXpIkPrdQeS5/YVeRLmtwWiMiSXIz43HYlHNjjshtH2LZ9EanobiB1+96HWSY8+AcZt8/u9v3iTUL0FYkIPtlPC3KdalLkTl/I1hsiqK7P0gSzLwdTqwF9wWNXNV58OKn4ZU7IXkcfGU7rPkfmHwj7HkqaOW3ODZ+rx+PK3TXVNVOP7HTcTj+lnIcJl0/8A2PWQbDxsBHv1QKzO7+33OzL1MalmpO1+gqGlGPSW/Kdr8f3vgSFO+GO1+B0YsgJhksvZSCJ60BbysUfBTiEXeg2shXmsp2ExOTSxxRpMlJVy6MHTby+nXA9kVFYxulDW1YpI6HVK24fkY28U4b52pdumRcqXntBuuG7syCsYpCeGeBca3kz9W4+PY/D7L6d1t490gZkgQ3zsxm47eW8dinZzJiWOis1gFVHd/YGp7FruMhzmvvjm+tmsi10zLxy0rzidHx+WXeP6oU0a+bcXG3MihFeIANx8tDMpE/X9dKRaMbu1Vi5oikLq8JZbse7gfCdeJ8XStFBrNcNpqNvCzL/VK2W2wWrnr0KgB2/m4njSWRZf1neGV7nL7K9oYiZfErY3rGgLcRnRxNco6ycKx3jlsoUS0MDdqIYWa2m5iEh4689vDFS4js9tf2FnO+Tr/nGjVvuB+qTD3RyxpbC9xeH/uKag3XFBoMYr4+2Mg34YxWWNOiq9o4HORVNlPv8hBttzJtuP7XEvFdadRL2W6wBh2LReLGgLr9rYP6PasK143+NmrdOEtZgyuqcfFJfnhi+kLJ4UCxfXqnc18o2/dHiIhhqLD3ib201raSNTeLa39/bY/vs1gtaoFTy0ZfsQ4BF8zB8jbByAXgHMD1cvptSiH1xDvKf7c1woYfwJ8XKgX3O16Cz74OabnK6/O+oCi/z24OavP2WDuSVRGGhdJKvtvC8tF/Q85KiE4a+IYtFrjyh1BxFJ6/GX41Cp5cDu8/ohTzm/oW3sSkxpA0VhlD6T791O19zs9lGTb8PyWj/VNPKYX2YEgZrzggnHw3NAPtBqFsN23kTUxMLnlEsX18mnJhjHMok0gj2cgfOFcPKBNUrRUW0VFWbpmtqNZe3nNO030BtAS6oWMcxuqG7ozoRjeqsn3dkTKu/J+PeX1/CX4ZVk/J4L1vLOX3d85mXFqcJvtMiBYTeP2V7bIsa65sh65d5u8dLaPdG7qccy3YU1hLdbObxGg7i8d3n++0OCeF2CgrFY1udRI8GPYWKQ0oU7MTL7KWFMX22pZ2Wtu1XVAra+iYEBptgUJ0Khul2O5t9UJgnTeYYjtA7o25jFwyEm+rl80/DW5SahQMr2zXObNdRAF06aAfAMMXRL6VvNGV7cJG3sxsNzHRl2M6PGP2xYJxKSwer6jbX9ql/XxMYHgbeYc+1tha8KM3j/GpJ3bw3I7IiacCRaHd6glNsT093kGC04ZfhoKqobsYDbA7sG4wd/Qw3fPaAeKdQtmucbHdoMp26LCS//hUFQ0hVKP2RssAbORBseH/9NwRADwfYdeI7jiqFtuT1J/NHJmEJEFxbStVTaHNvjbpmbx38wBY+K2FfUaICVctLZvARYHZYrdgFWvAXreSs52zcmAbTRoJY5bCwZeUf3+YC3v+Dsu/D1/draiaO+fAj14M6VNg99+C2rwkSWrsWCjn7GJerkaa1Z+D87th2qcGv/Hpn4aHC+ChXYqaXxSa/3kP/M9E+P1sePMh2P+8kmffDcLNTs/5fp/K9u1/gJ1/hut+A1Nu7N/GJ62B0++DX5u1SaFsb6tvw2ugelIoMYvtJiYmQXEmYPExPqBsjwtYbhmpY/5AsdL9OVtjVbvgjnmKlfyGY+VUN2v7IBwqWzotmT82GUlSFgUqm4xRMBPIsszvNp7G65dZNC6Ft766hCfvuUzzjMlEYSPfqn+xvbLJTU1LO1aLRG5mvKb7WjAuhfR4B41tXjXKwai8d0RYyGf0uKjjsFlZPikdUDLsBsuewu7z2kFxPxCLoqUN2iozyzup57fmGevvFD1M+0lrf3B3WtyIig2uyChJEqseU/LTDvz9ANUnjdXQ0BuGV7bH6msjL7rxB5tTLnLbS3frm+MWSkxlu4mJSXecCBTbp2ronhQMy3PTAH0cggTNbuW5Phz2+cEQqTby5+tc/Gu/ksX89LazEWUT3dpJgT7YXG5JklR1e17l0M5t3xXGvHbonNmu7VzdqJntAJMyE5iUGU+7z8/7x8p02adoWBrINfSzgSb/D09W6OpoEmpkWebw+YuV7QlOOxMCa64HTSt5XWgobqDicAWSRSLnmpw+3y8c+bScl3aef0miAF60HTwt/c9r78zMO6DwE3jzKzB2GXxtLyx7GOzdzHklCeY9AKfWQUNwheTOue2h4qLC8rE3wOaE3GtCswOLBdInwWX3w61/hW8ehm+fgE//A3JWQfkReOc/YNOPu/149jylYUnP3PZei+2HX4ONP4Sl34H5X+z/xietAVcNFO8a5Ci7xznMicWmrMMOVSt5s9huYmISFPmqsl3YyCsL380G6pgXynZhvaQ1U7ITmDkyCY9P5t/7zmu6L1XZbsBuaEFSTBS5gYWBPWeNZXt1vKyRvMpmomwW/nrPXGaOTNJlvx028voX24WqfXxaLE67tueN1SKxJmDJ/vYh4xaV/H6Z944qxfPrpndvIS+4emrASj4Exfae8toF2Trktje1eWjppJzffqYGr884LgSOJGWiEErLscEgrNvssXYki9THuzsYuXgkk26ehOyX+eCRD7QaXsgxurLdFqcsxunVjBFUDloQiGJ7ye6SiLTEhchRtrc3t+PT2B3ExMREocXt5WyNskAW7mJ7OJ61xfy3v6pMvRD29s1hcNYaDE99chZfoMAeaTbRYq4uSeC0D36ZdUJgTn26YugW22VZZrdhiu3armmJzHajumFcMVFpWjpRps/5NpiGpfFpcSzJScEvw8u79XM0CTXn61ppaPUQZbUwMbOry+LskUqDvmklrw956xRV+4iFI9R5RW8IkYCWNvLdzkXzNkJ8FmRMG/iGp94C874I962DT/8dEof3/v4Zt4M9Fvb9I6jNq26FIWyAFOtD6rE4/hZMWA0ODQVFCdkw7Va47jH48iew5Btw6GVov7jBJxzF9h7n5wUfK40UM+9SLPIHQvYciMvUzEpekiRi04e2lbxZbDcxMemT2pZ2aluUi/k41UZeeTAWE8tw4/X5OXy+HoA5OhXbAe6aPxJQHvS1XEgXEzSjKigEC8cpttxGs5J/66Dy4HPVpHR1UU4PEoSyPQxNKWpeu072njfOVB4yNx6vUM9Xo7HvXB2VTW7inTaW5KT2+t7luWnYrRJnqlrIr2we8D4bXB5OVyifnzu6e9cNYSWvZbFdqNrjHTYSo+00tXk5dH7wFvmhQu2CNoiyfTDF5yt/eSWSReLkmycp3l4c6qGFHL/PjydgG2nUgqqa2a6Djbzf51ebLQZrI585KxOLzUJLZQsN54zzfesP4lgY9dxwJDog0A9jWsmbmOjDibJGZBkyE5ykxIW3SUsvG+jOtBjcRj4+ApXtNc1uXglEs4mm6EiyiRZRUDF2a4cKcRBMDNisijnEUKSwxkVlk5soq4VZOjXCX4geyna/X8Ylzg+DRgKmBCKzGnRqWhLX0PgBXkNFhN2re4pxeyOz0VKo2nMz43HYup4XQjx0wCy264KwkJ+wZkJQ79fDRr7bYmr+RsVCfjD3mKhYWPNbGLMkuPc74hU1/L5nwdve59tDrWz3ezvWKdR5ef05yJoRku0HzZx7oK1BKfRfQNacLJCg8XwjzeX63LO7bcYoOwyvfBbGXQE3/n7g54nFArnXKsV2jWocam67qWw3MTG5VCkIqNqHJ0Wr1leiY94ome0ny5to8/iJd9oYl6pN/nZ3XD8jmziHjcIaF0dCkO3cEx3WY8acoAlEbvu+IuNMDHx+mbcDxfabZvXRuRli1Mz2MCrbp+ikOJo1MomRydG0enx8cKJSl332l3cPK9Z4q6ZkEGXr/REowWln8XilIL/h+MDV7fvOKYqNcamxpPawIC2K7SUaFhKFvWp2UjRLcpSmmK15xlEM6WHH1h/UAmOQee2dSZucxuwHZgOw8XsbDa9oFpN5MK6yXc1s16EZQ0xeYfDKdpvTRsbMDCByc9uNbiNvsVp0UZiYmJh0cEznZ8zeUJ+1dVJxu70+2gPOQEZtgo7TSa0bSp7ZXkibx8/MEYn8z2dmApFlEy3m6tEhsglXbeSHsLJd5LXPGpmkuQtbT+jRrNM5YsCokYBJ0cp8p97VdzEtFIhGoIFeQ1dOziAzwUl1czvvHx28C104EGuH00ckXvTanECD/uHzDYZyohuKeFo9FGwqAIIvtutiI39hMbWuCKpPD85CfqDMewBaKuHkO32+NdTF9m7n5e5miNJvzR+A5HGK7f7+Zy96yRHvIG2y4g5Sskef+f7F50chvPhpSM2BzzwL1kEKzCatgbqzUHVycNvpAZHb3jxEGwrNYruJiUmfCFWnULVDx0TBKJP4A4E8o1kjk7D0w/J3sMQ6bGrneamGhTJV2W7QCZpgxDDFdqmmWZ+JWjDsOltDeWMbCU4bKyal6bpvkdne0OrRveDWoWy/eAKnBZIkccMMRd1uRCt5v19WJ+Nr+rCQF6yeqhTJ1h+rGPB+RV77Zd3ktQuG66Fsb1SuTxmJTi7PUb4HW/ONk9susrGNZiM/kGI7wPKfLMcWbaN4WzGn3zkdyqGFHFFMtdgtWA2quNEzs11MXq0OK7YQFFKElfy5TyLT6tLoNvJg5rabmOjNcYPktYP+NvKdI9SMqmwX4zLKPL0vmt1ent1eCMBXlo8nJz3ybKJbPaJ4GJrnqAmB9YWiWhdtnshU7vZFuPPaQR8beSFOCVXEgBYIN756va6j7sF9X2xWC3ctGAUE74AhyzIv7Czi7qd2qo6Y4eRIiTKGznntgpy0OOIdNlztPk4N4YYbI1D4cSHeVi8JIxLImJER1GfUYruWNvIXNjvnbwSLDcYt12yfPZI+GcYshd1P9flWsaYT6mK7LdqG1W4Fvw+8rfoX2wHm3AvndkDVqYte0ttKvsv8vKUGXvgU2GPgrtfAEYJjM3aZcoxPrh38trpBVbabNvImJiaXKmcuyGuHjkm82+s3RLelsFiaParngpZWJMcqD0A1LdoViVRlu0ELIYLOxWWj8NYB5YHnuulZF1l0aY1YAPT65S5d7VrT7PZSGMjSnJylYZbRBdw4S3nI3HyqylDnAMCB4jrKG9uId9i4fELvFvKCVVMykCQ4VFyv2rD3l31qsb3nhSSR2V7WoL2NfFaCk6WB3//AuXpNbRP7g5i0GsVGXkxwB1pgjM+OZ+G3FgKw6fub8HvDf5/sic6W+aGwPtUC1UZeD2V7oOFDLBYMlvGrxwOw78l9VB03ToNLsAwmUkEvRL6iaSNvYqIPx8oURZ4hiu3R+trId3Ybs+rY4N0fRAExUmzkX951jsY2L+PSYlk9JROIPJtoVdkeIoV2WpyDpBg7styxFjPUCHdeO3RWtms3H2oJWMjHRtkM+5ydFKPvGo5oQIh3DFx9ece8kdgsEnuL6tQGsJ6obnbzwLN7+cGbR9mWX8MXn9tLVVP4GrxlWeZIwEa+u2K7xSIxS7WSr9dxZJcewkI+57qcoL+fetjIX6RcztsEIxeAUx8hzUXMewDObYeKY72+zZGkjDdUAoqLjkN7oDgbFdvDJzRk8g0QnQz7n7voJb2L7eK4OOMlePl2aK2Hz/4b4kIkLrM5lMiCk+tCs70LEMV2U9luYmJyyXKmSrmh5aR3FNs7Wz6JyWU4ORhQts8OQ95XSqxSjKnVUM0dKcp2YeXY6vHRboDiUpvHx7qjinW43hby0HUhrrFVvwWvU+XhydKclJnAxIw42n1+1hvM0m3dEWU8K6dkBN10kR7vVK8pGwdgJe/2+jgY6Jy/rIe8doCsRKFs195GPjPRycjkGMakxOD1y+wsqNVsn/1BFNu9bV68BlBiDVbZDrDke0uITomm+kQ1B589GKKRhZ7BNhbogZ6Z7eqkfpB57YLcm3KZcN0EfG4fb977pqEbL7ojEs4PU9luYqIfHp+f04FMSr3ck3pDVaa6vfj82rtINbmVYpRRLeSho4DY7Pbq4qwlyzKeATbfu70+ntqqWPh+edl41aFu5eQMMhIcEWMTLTK5Q3VeSJLExHRhJT/0FqNL6ls5X9eK1SKpltnhoPP1QytaBqni1gO12O6KDGU7QHqCk6unKc05L+zqWd3+0clKrnl8Cx+erCTKZiEr0UlFo5uvvbQ/bKKhc7UuGtu8RFktamTEhYg1CLPYrh2yLKvF9onXTwz6cyK+SrfMdq8bzm5Rip/hYtL1EJcJe3pXt4faRr4tsIalNsG3B+6H4VC22xww6y44+JLyN+mEcLIr2VOiy3OXWK9IthyB83vg9hcgZXxodzJpDZTuh8bQNxAIG3lT2W5iYnLJ0p2yPcpmUTOPxaJDuKh3tVMQaAiYFY5ie6AYU9OiXbFddETHGLzYLhZ3QL/sxN74+FQlTW1eshKdap68nkiSREJgEq+n0jucWZo3zlS6Ot85bBwreb9f5r0jStPFtYFJebBcPVV5/0Cs5I+WNNDu9ZMSG8XY1J67b4erme2tmj2cVzR2FNsBVd2/Nc8YSltHvAMCzeR6FFT7IhRqXmeik2U/WAbAxz/6GI9OC1j9JRKUy8JG3uPy4GvXtsFPTOoHm9cukCSJG/52A85hTkr3lrL1V1tDsl29iITzw1S2m5joR15FM+0+P/FOGyMD6q5wIopl0NXiXStEk3m8gYvtwoHO55dp82hfTLr/mT0s/fVHFFb3f9H0jf0lVDS6yUxwctPsbPXnNquFu+Yr6vYXdgZnEx1ORGN8TFToCqrCSv70ELSR3hNQtU/LTghrHENnFwi/Rs06rk7KdqOiZrbrEH0ny7LagDDYv71wwHjzQMlFa09tHh8/fuso9z+zh+rmdnIz4nn7a0t4/oEFxEZZ2XW2lsfWX2wHrQcir31yVry6pnohwrFTOHiahJ7qE9XUF9ZjdVgZe+XYoD+ni418Y6dm56Lt4GkJT167wGqHuffBoVehrWcnCa1s5C9StofCKn0gzLkHWmsvslfPmJGBxW6htaaV+sJ6zYehxgxEBY5z1ozQ72TCKpCscCr06vbYdNNG3sTE5BKmzeOjuFZZvByf3rVYJB6Ow61sF6r2samxDIvVX3mVHKt9sd0VAR3RAFaLpC4+6ZWd2BtvHCgBFHtzS5isHoW1vp7NB8JKbUqW/sX26wO57dvyq8Nqz9aZQ+frKW1oIzbKyrKJ/bNWWh0otu8sqOl3t3/nvPbebMkyEpxIErR7/ZpdRzor2wE1t/2T/GpN9tdfJIukay53Xwhluz1u4PaGAJd95TKSxiTRVNrErt/vCsXQQk4kKJetMVa1GUPr8yPUNvKgxApc+4drAdj8s82UHzS+Sk8QCeeHM1n7RS8TExOF42Udz5hGsER22KxqDrIez9rNgSbzOKdxC2cxUVbEn0brpnhZltmWX015YxtffmEfrf1oiPP5Zf66RVG1f2Hp2Iucp+6Yr9hE7yms40RZ7zbR4cbV3hEvECqE4vX0EFS27zpbA8CCcSlhHYeIfJNlaGnXpllHbNfIcYBC2e7zy5rHT7R6fIi+hsFeRxeMTWZCehyudh9v7C9Rf368tJEb/rCVZwN57vcvGcNbX1vCpMwEctLj+O1nZgLw5JYC3j1cNqgxDARhIT+tGwt5gRARFVS3UKfhOuOlzOl3TwMwdsVYovqxjixs5LWck6rF1ASHoi52JELGNM32FxRz7wVvGxx6pce3CGV7yGzkGy4otrsDzWfhsJEHSMuFUYtg37Ndfmxz2Micqawb6mElrzZj2NtBsih57aEmehiMWaKJlbya2V5pFttNTEwuQQprWvDLkOC0kXaBHbUo/IY7D05YK4XDQh4gNXBcarXMbI8QZTt0ZCeGO7O7weXho5OKavfmMFjIC8Tx0LP5QF0IDYOyfUxqLDNHJOKXYd0R/Sev3SHGcdXkDJz9zFIcmxrLxIw4vH6ZD0/1T92+VxTbR/fuqhBls5AeUI2W1mszaSsP5MFnBQqIi8anYLVIFFS1UKLRPvuLKLYbIbddneAOUs1rc9hY8YsVAGz91VZDKm8jQbksWaSOTnmNz4+LOuhDxPS7pjPplkn4PX7evPdNzRX6oSISzg+hbDdt5E1MtOdYqchrD7+FvEA4a+lRbBfZ8EZWqUqSpDbFa632d3v9eHxK5exkeROPvH44aGXs+mPlnK1uITHazp3zR130ekaCU3WYMrq6vUPZHrrzQijb8yqHnrJ9l8hrHxO+vHYAh82C3ap0pjRp9F1xuY2/juO0W3EEFNb1GjtxiWuSRYLofs7LL0SSJD63SFG3P7+zCJ9f5qlPCrj5T9vIq2wmLd7Bs5+fz49vmNplDeDa6Vl86YpxADz8r0Pk6/wdOxwots8Y0fN9dFhsFOMCzngils4ktAgL+QlrJvTrc3rayDviHUqBOToJwt3gmJANk69XrOR7uM+H2kb+ong3NbM9TMp2gDn3wtnNUFvQ5ceZs5Xnlarj2jtHiuNit7mVY6HVuTHpeiXCoBc3g4EgbOTNzHYTE5NLkjOBTqPx6XEXqRfiHB15cOHkgMhrH5UUlv2rynY9MtsN3BEtUIvLYc5dfu9oGe0+P7kZ8UwOg8JbkKDjAiCA1+fnZLkyYZwahmI7wA0BK/m3D4XfSl6WZTWv/brp/bOQF6yeonxuQz+s5P1+mX1FykLSZWP6ziLMThK57aEvFrV5fNQFFk6yEpT9JEbbmRmY4BvFSl4tthvBRj4Eme2C6XdOJ3NWJu4GN5/88pNBby/URIJyGTos+7Q+P1Qb+RBltgskSeL6v1xPTGoMFYcr2PyzzSHdvlZEwvlhZrabmOhHOKOKekJENjW26mcjb2RlO3TY3Gs9T+9coLRaJN48WMpzO/oujMuyzBMfnwHg3sVjesw6/2zAJvqNAyU0GSCirCe0VLafq3WFfb0llFQ1uSmoakGSYF6Yi+2SJKnNOloV29XM9hCeG1qg5rZrLBBQ89qjbCFxR7ll9nBioqzkVzZz/R+28ot3T9Du87Nycgbvf2MpV/Tgavfw6lwWjUvB1e7jwef36XZ98ftljpb2rWwHmBVY3zxQZFrJh5rWulbObT0H9L/YrqeNvCPBoRSYw1lc7sy8L0D1KSjsPhZNzJ9DndneYSMfxsx2wZSbFKeB/c91+XFcZiCHXAe1tmjGsFvbtD0WudeC3wP5G0O6WaFsd1W78Hu1jzvSG7PYbmJi0ivd5bUL4gKF35YwTv78fpmDgRwjkWukN3rYyLdEQEe0IDFa/4zy7njzoGIl1jn/LxwkiOOhU15zQXUL7V4/cQ4bI4dpYCcUBDfMzEaSYF9RHefrwqvkPXy+gZL6VmKirCzPTR/QNoSq5uNTVbR5glOjFlQ3U+fy4LRbglJ/Zau57aEvJIq8dqfdop6PAJdPCFjJ5xnDSt4aZxwbeU+z8n0NRbFdskis/PVKAPb8cY8uOV79IRKUy9AxedfcRv7CDvoQEpsey5on1gCK00HJnpI+PhFeZFmOiPPDzGw3MdEHv1/mRKDYHq6Gzu4Qjb56FEuEjbyRM9uhoxlAa2W7OObxDhuPXDsJgJ+vPa42nPbE1vxqjpQ04LRbuG/xmB7ft3BcMjkBm+jX9xv3nqlFsT01zsGo5BhkGXYHbNeHAnsKlXMjNyOexJjBxTWFApHbrtX1o8NG3tjXDBF9p7WyPdQNS/FOO7fMVlwMT5Q14rRb+O9bpvG3e+aSEtfzs6vNauEPd80mK9FJQVUL3/tX8K4cg6Go1kVTm5com0VtqOmJOSK3PSAuMgkdZzacQfbJpE5OZdjY/q0jCxt5b5sXr0b3WDH/ioqPAndz+DLKL2TMUkjNhT1/6/ZlVdneoLGyPZzHIyoGZtwGB14EX8f1UuSQu6q0nY/62n3qeWeT2rQ9FkmjIHN6yK3kY1JjkCwSyErBfahhFttNTIYo7V4/lU1tnK5oYldBDe8fLefjU5X9foDMr+y52B6rU8d8bxRUt9DY5sVpt5Cb2fvDqlYIG/m6lnb8fm0e0EX+ndE7oqGTkjuMxfayhlbVnu7GmeEttifqrPQXee2Ts+LDllOfkeBkwVhFqbA2DDlonVl3VNn/iknp/baQF0wbnkB2opNWj4+tQRamhYX8rJFJRNn6ftwaHii2l2mgbBd57VmJ0V0UBEsnpAKwLb9as2tXfxDFdiMo20Ot5h23ahxjrxqLr93HRz/6KCTbDBVq5peBlcvQSdmutY38hdlwIWbKp6cw7Y5pyD6ZN+99U7NFmlDgbfUiB64NRj4/TGW7iYk+nK9rpcmtFAly0g2y8EtnG3ntr6eieN2TEtsoCBv5Jp2U7fFOGw9cPpY1M7Lw+mUeenE/lU0936+Fqv2OeaPUxvXukCSJzy3ssInWoxg2ELSwkQdYPF7JNN+eP3SK7bsDc3QxVww36ndFKxv5wDpOnMFFE0nRyvdQa8FEU6BhKZTX0AcuH8uwGDszRyax9utLuXvB6KBU86lxDv589xzsVon3jpbz5JaCPj8zWI6UKKr2yVkJ2K29rxEI586D5+oNMVcfSgzUQh6UBmQpsM6mVRN4V2V7c/gyyi9EkhR1+4m10HjxOp9mNvJdlO0S2KJDsv0BM/deaKmE0++rP4pJU5q/tVa2i3UqAKvcqr3Kf9L1kLcRvKETF1qsFmJSleM1FK3kzWK7iUmEU+9q5/v/Pszn/r6L6//wCZf/+kOm/Xg9E3/wHvP/+wNW/24Ltz+5ky+/sI/7/rGH94+W92v7Qtne3YKKXllwvXEw0OU5Y3hSnw+rWjEsVlng8fplzazCI6UjGjqKy+FUtr99sBRZVnLgRoRJ3S3Qu/lAzWsPo3U+dLKSPxg+K3nFQl6ZBKyZnjXg7UiSxOqAun39seCuoXuCzGsXiCz10obQT9jKA8X2zARnl5/PGplEnMNGncuj2sKGEyNltofSRh6Uc0io2w+/cJjzu86HZLuhQM2n16i4HCpCPXnvCVFsFxnxWnDtH68lLjOO6hPVfPjDDzXbz2DpPJmP6qUYEm5MZbuJiT6IvPbcjPiwzbu6o8NGXg9le2TYyMcF5h/aK9tFsd2OJEk89qkZ5KTHUdHo5msvHcDju9ge9GBxPdvP1GCzSHxx2bg+93HLnA6b6J0FvSvmw4UWynaAxTmBxtgzQ6fYLhriF4xLCfNIFISyXbN1HLdYxzG2aEK4DNS3aufWCJ2U7SFc1xqXFsee/7eSt766pN+NYLNHDePHN0wF4Nfvn2R7vraOb0cC+esz+rCQB+VeGxNlpcntJb9q6BWkwoXf5yf/vXwAJq6Z2O/PSxZJnZdqZSWvzs/jDVZsB5h5O9icsO+Zi14S82dvqxdfe3COkL1x0bzcHTgWljA/g2ZOh+FzYd+z6o+Esr2lSttiu3A9sEXbkDxN2qv8c68DdwMUdR8dMFDU46WD7b7eGGeGZGJiMiB+u+EUr+wp5pO8ao6WNHK+rlVVmkuSkr00NjWWEcOUzq/X9gW/wO/3yxQEbhTj0y6+uYsH5HDayB8IWMjPClNeO4DDZlWtBLWykndFkrI9Wt+M8u54M1DgDbeFPOh/PAoCE7EJfdiSac1107KwWSSOlzWqDhl6U9nkpri2FatFYnlu93ltwbJ6SgYAm05U4O1m4fBC9vYjrx20tZEvD9jIZ15QPLRbLSwMLHR9kh/+3HZbrHIdNYKNvBbW2dlzs5l5z0yQ4d2vvGuYfKouNnUGRl3U0MtGXsPmg5iUGK5/8noAdvzPDs5tO6fZvgaDem7ERakKDiMi7Bxba1sNq3o0MRkKqHntYW7ovJAOG3kdlO0BVWYoC0VaEK+qdTVWqQa2L5oPYh02/vq5ucQ5bOw+W8uv3zt50Wf+ElC13zRruOrs1BsJTjs3B2yiX9jZdx58OHCJyLcQnxdC2X6irJGaZncf7zY+DS4PJ8uV60i489oFWme2d6zjGPuakaSbjbxynEN9DbUNogHs7gWj+NScEfhl+PrLByjVwGlOIJTt04MottusFmaMUN4n1j1NBk/pnlJc1S4ciQ5GLhk5oG2IuYdWIoGLM9vDu7bXBWeiUnDf90wXG3XoOn8OhZX8xcp2A+XXz7kX8jdBfTEAsWn6FI+7HBN3Mzg0fibPnA6Jo0JuJS9y21sqzGK7iYmJgSiudfHKbuXC/l/XTeLp+y7j9YcW89F3l3PwR6s489/XcfBHq/nou8t59vPzAdhyuoraIAvCZY1ttHp82K0SI5MvVgerNvLt4Sy21wMwe2RS2MYAkBJQPwZ7bPtLR0e0sSdp0Mk2PUzK9tMVTZwoa8RulQalZg4VQm2jl9K/sVU5V3qzZNSDYbFRqk35O4fCo24X52CC0zZoW8f5Y5NJjLZT5/Lw6b/s4N3DZT0W3Sub2iiqcSFJMGd0cMV2sdioxeReVbZ3o9QVf6Ng7fG1xEg28qFWtgtW/WYVzmFOyg+Us+fPe0K67YESCZncoJ+NvFgY0CKzvTO5N+Qy675ZIMNb971Fu0bPD4NBjVMI8fcg1Agbeb/Hr353TUxMQo9Qtk8dbqxiu9bK1M40a1QoCjVxOsW9CZv6+E5K//Fpcfz2MzMBeGrrWdYe7pgH5Fc2s/644hL15Sv6VrULPrtAsZJff6ycisbwPydeiMsTKLYPMLKqJ1LjHEwKROXtKIh8dfuewlpkGcalxZJmkOfOjsx2bb4rzRGibE+K0cedUFwzYg10PCRJ4r9vmcaUrARqWtp56MX9uL2DV+VeiN8vc7REaTaZPqLvYjsoynvoWPc0GTyn3z0NQM7VOVg7X7P70bAr5qVaNYF3aYZvbzGWsh3gsgeguRzpdNcCrMVmURv4Q7Gmc1G8W3uTcY7FtE8pYznwAtCh1G6tbdVUVHFxxIDGzQeSBJOug1Pr+vUd6Yu4DGXcpo28iYmJoXh8Ux5ev8zSCak8uGw8V07KYM6oYYxNjSUpJqpLXvP4tDimD0/E65d593BwhS+hRh2dEtutVWC4beRd7V61M1o8hIYLUdjUouPc6/PjDtysI0LZrlo5hue8ePNACQDLc9NJigl/gUBVtut0PJoMtAh44yzFWeCdQ6VhURs2drK2HCw2q4XvXzuJKKuFg8X1fPWl/Vzxm4956pOCixZ39wUs5CdlJqgxAn0hlO1VTe6QT+7LAtb0Wd0U2y8PFNv3FtbRGgKrr8EwlG3kBbHpsaz8lWIn/+EPPqSptCmk2x8Ioc6n1wq9le1a2sgLrn78ahJGJFCbX8um72/SfH/9JVJcD+wxdqyBRVszt93ERDtEVNHUbGMV2/WMbGrWwAJZC9QCom6Z7V2fd6+ZlsmXrxgPwPf+dZjTFcrzzl83n0GWYdWUjH65cE3JTuCy0cPw+mVVbGAkXBoWEBePV57Vtw8BK/ndhcbKa4eO64dwrQg1roAwxfDK9sC6Sb1Laxt5sVYx+Pl5KHHarfzls3NJjLZzsLien71zPOT7KKxpodntxWGzMCFIu/s5gXXO/aayPWSIvPaJ142Gwq3w4S/gqZXwy+Gw84mgthE9rMNVK9TIflldi1DUyzpYhfeXzGkwahGWfU9f9FIoo9/UwnJiJ2W7UY6FI04puB94Hvw+pflbAmRto826RAy4m/U5HrnXQWMJlB0M2SZNZbuJiYnhyK9s4o0DiiX8d1fnBvWZmwKFrzeDzFA+Eyi256R1f/EOt4384fMN+GWlgNSdYlNPUuKUm78WNvKiUx4YtDpXDxJ16oruDr9f5q3A+X3zrOG677879LaRF3aO8QbIklw1JROHzUJBdUtYMsFDrT66c/4otn5/Bf9x1QSSY6MoqW/lF++eYPGjH/Kzd45TXKs8VHfktQffBDQsxo7TrjyWlYfAcqsz5YFJyoWZ7QDjUmPJTnTS7vOz62x4F/FUZbsBiu1aFqDnfGEOIxaOoL2pnfXfWh/y7feXSFO2u+u1tVG9qINeQ5yJTm78+40A7PnjHs5+eFbzffaHLpN5AyNJkpnbbmKiMdXNbioa3YrAJdNgxXY9beQvsE03KmJ82me29zzv+O7qiSwen4Kr3ceXn99HXkUTbx5UmqK/snx8v/f1uUWKuv2l3UXdZsGHE2EVHq3BXF1YyWudJa0HIq99voGK7Vor20VGeazBG3QSdbeRN56IZFRKDI/fMQtJghd3neO1vaFt7BEW8lOyE4K2vZ8VcPDMq2wOa0yjUfH053z1+2k+tJ2xzrXcffe/mV58PTyzBvb8HRJHwJQb4f3vB1Vw19JGvrNLl5LZbkBlO8C8L2Ap2kZ8a0mXH4uGdTGnHgyq45wRbeQB5t6rFKHzN2GxWjrmo1UaFtu7KNub9Dkeoxcr8QEhtJI3i+0mJiaG4383nsYvKznCM4O0UL9xZjYWCfYV1XEuiMXIM4Hs5/Hp3d/YVRt5d3jUkKqFfBjz2gUpqrJdg2J74PjarRJRNuNftlV1SRgmA3uL6iipbyXOYeOqyem677879D4ezd3YOYaLzn+Ht8NgJS8WGEO5IJoe7+Tbqyay/ftX8qtbp5OTHkez28vT285yxW8+4isv7OOjU5VA8HntoBSLOnLbQ9shXR5QtnfXlCRJEksnKHn2WljJ+/xy0M0DqrJ9CNvIA0gWiTVPrEGySBz75zHy1+eHfB/9IWKU7Yn6KNv1spEXjF89nrlfmgvAW59/S/17GIFIUbZDh5W8qWw3MdEG0TQ5NiXWcEWjBNNG/iJ0s5EXyvZujofNauEPd84mK9FJQXULt/55Ox6fzIKxyapasz9cMy2T1LgoKhrdfHCiYtBjDyUd6uXQFxAXjEvGapEorHGFfI6gJy1uL0cDxcb5Y1PCPJoOtC62a3luhBK12K61jXybcIEw5jV0RW4637hqAgA/ePOoes6GgiPng89rF6TFOxiZHI0sw+Hi0I1lKLDh4Q08lvoYp9ee7v2NZz6E1+6D3+YQ98a1rFixHUeiE2nF/4MvbYGHz8BnnoGbn4Al31AK7rv+2usmtbSRF8VUi82iOHe1Nxsrs10w+Ubk6GSG1+3o8mMtlO2q45y72ViNB9lzIGM67HsWgJg0pdiuZW77xZntOhTbrXaYeI1iJR8ihO2+aSNvYmJiCI6WNLDuSDmSBN8JUtUOkJ7gVG3I3jpY0se7OxXbe1K2O8OrbD8QsFKaPTK8FvLQYSOvRWZ7S2CCFgmqduiYqIVD2S7UEtdMy8QZ4sy8gZIYHchs17hLHECW5R7tHMPFjTMVR421h0rx+/W1khdqmwQNGg+cdit3zB/Fxm8t45n757F0Qip+Gd47Ws7ZauXhet6Y/qk2shOVYlFZCIvNXp+fqkDxricHEGElv1UDxcwbB0pY9puPeHxTH5NgOpTtWhdT+8Lv9eMNxD5opejNnJXJgm8sAGDdV9fhCcP1UhBpynYtnQ9kWe46gdWJVb9ZRdKYJBqKGtjzpz267bcvIkXZDh0KEy3sHE1MTOB4oNg+xWAW8qBvY2tLhNnIa61sb27rvck3Jc7BE5+dS5TVolraP7QiZ0D7ctis3D5vJADP7ywa0Da0okPZHvr5Z7zTzoxAvvO2CFa37yuqw+eXGTEsmuGBBmMjIObMTRpdP8Q1I8bg1wyR2a51HIeqbDeAMKAn/uPKCazITcPt9fOVF/eFzFr/cEn/i+1gWsn3RPHWYrytXl7/7OvU5td2/6Zjb8ALn4aaM3DZ5/kg7zv8+tcPUZD5G1jyH5A1EyyB0pgkwcqfwuKvw3vfg11P9rhvLecd6vwrwYHk94G3zVgFZoEtCjlpNA5vVwdLTWzkVWW7Dhnl/UGSFHX76fehqVwtILdUaVds79IMr2cjRu51UHEU6gr7fm9LNbzzDdj+xx7fIjLbtWxMCBdmsd1kyNLm8fHcjkI+yasKS1awlvzPhlMA3DQzm9zM/l1YO6zkS/o8LvmBi16PxfaA9ZPWHfPdIcsyB4rrAYMo27W0kRfWYwbvhhZ0ZJTrWzxq9/pZd6QMMI6FPHSytnR7NS82t3p8+AL7MMoi4PLcdOIdNkob2tin8wRRD/WRJEksz03n+QcWsP6by7j9spFE2SzMH5OsKtWDJTswMSkNoWqlqtmNXwabRSI1tvuC2ZKcVCQJTpY3UdkYukJmu9fP45tO0+71B9X8YpTM9vZO13EtlO2C5T9dTvzweOrO1LH1V1s1209fRIyyXUMFgcDb5sXvUaxp9chsFzjiHSz/6XIAdj6+E68OVsjBEEnKdtNG3sREW46VKkWCqdn9KxLoQUKgsbWxVftrZ1Ok2Mg7OuYfWtLkFjbyPTf5zhqZxI9vnALAzBGJLAs0eQ6EO+ePwiLBtvwa8iuNo4YSxXatcrmXiNz2CC627zaghTx0NIo0XuLK9qRokdmucbG93fjuIBaLxOO3z2ZUcgzFta1845WDg17H8ftljoli+4j+3UdnB5xMD5jF9i6IQqy7wc2rt77aZQ4PwIl34N9fUHK1H/wY75Lvs+stGz6fjYlrJna/UUmCVT+HRV+D9x6G3X/r9m1aNoGL30stpoIxi+0Ajnjsvq5zL+EO1zbIaESv24svsBbekdluMGU7wIzbwBoFB14gNi1QbNdB2e5MsCmNGHpl2OdcpfyevVnJ+/2w/zn442Ww7xk4/laPbzVt5E1MIgxXu5cvPLuXH711jM/9fTfXPP4J/9xTTJsnPHbnoWRvYS0fnarCapH45soeHhB64ZppSobymareM5QbXB6qm5WL+Pj07i/eYjIZDmV7aUMbVU1ubBaJaf3sDNWCDhv50Nu/qsp2A09IOtOhLvHq2uiy+XQV9S4P6fEOFo03jjWdOB6yDM3t+qhLLBLEGGRC77RbWT01E4C3D+prJd+kgY18b+RmxvPrT8/gyE9W89IXF/T786I4X9oQumJiWWCSk5HgxGKRun1PcmwUUwNKtVCq21/dW8z5ulbS4h3cu2hMn+8XxXZ3oxt/GLM4hYW8at2mEY54B9c8fg0A2361jZrTNZrtqyfCpeQeCKHsku8JNVtO0rbRojum3TmNhJEJtFS0cPDZg7ruuycipREDTBt5ExOtEcr2qQZUtmutTBXIshw5NvK6ZbYHF19194LRvP21Jfzj/vlIUvfPo8EwYlgMV07KAODFXcZQt8uyrBZUtZp/Lc4J5LafqYlYIYkoti8wXLFdXD+0+a6IyEWjuxQKZXt9a+jFI51RbeQNfjwSY+z85bNzcdgsbD5dxf99kDeo7RVUt9DS7sNpt5DTg5ipJ2YHlO0Hiusj9vuvBardut1C5ZFK1j64tuP4nHoPXrsfJt+o2MNbrBRtLsLT4iEuK47M2Zk9b1iSYPUvYOFXYd13uy24Rw/TMLNduM4lBPLaARwGtJEHcCRg83Wde4Vqzi7+vtBpXt7eYrxj4UyEqbfA/ueISVN+dz0y22MSAutlein9HfEw9oqereQrT8Iza+DtryuW8zPvgtYeHCfoqmyXdXZA1Rqz2G4y5Gh2e7nv6T1sza8m2m4lJsrKqYomvvfvw1z+6w95fNNptYgcaciyzG/WK6r22y4bwZjU/nd0xTvtrJyiTFDfPNCzlfyZaqWDLjPB2eNigjqJD0OxXXR1Ts5KMIRduJY28pHSDS0QNvI+v0xLu34NLsJC/oaZ2Vh7KCqGA6fdSpRNud1qrfYXHflxDtugFrJCzY0BR411R8rw6lhEDZelvsNmxWbt/yNWR2Z76CZtIi+9Jwt5Qahz29s8Pv74obIo8bUVOUHZatriOu41atEzDKhq3rgozb9Hkz81mZxrc/C1+3j3oXd1X0DxtnmRfco+jW4VLibu7gbtmjHUxoN4B5LO9xGr3cqi7ywCYPtvtoe14UQQKRED0FFsN5XtJiahp8Xt5WyNsuBrbBt5bRt92zx+xHqg4YvtOmW2N/bjWXvGiCR1zjwYPrdoNAD/2nfeEGIKt7fjvNCqOX7OqGE4bBYqm9xq1F8k0ebxcTDgSmikvHbo+K5o1azjigAlNyjFZVCuc1p+ryLBRl4wJTuBX94yHYD/+yCPD09WDHhbR0rqAcUdpr/rBJOzEnDYLNS7PGpcnUlHU/CaP69BskoceemIEseVtxH+eQ/kXgu3PglW5Vw7/a4Sazfhugl9z/ElCa7+b1j4kFJw3/P3Li/rYiMf36nYbjQ1t8CRcJGyPWTF9sB6UFRcFBbxnWlvMeaxmHsv1BcxIv0MoK2NvDg/ouMCz3d6KdsBJq2Bou3g6lRE97TCBz+Hv1wOzRVwz9twy18gNafr+y5AWO77vf6wx0iGGrPYbjKkaHB5uPupXewurCXeYeOFL8xnxyNX8ci1k8hKdFLd3M7jm/JY/KsP+c9/HeZ0RVO4h9wvtuZXs+tsLVFWC1+/csKAtyMstt8+VKpaTl+IsGUbn97zjUyvSXx3HDhXDxjDQh4gJdBpp4WNfEuEdEMLnHYLdqvy8KpXbntTm4dNx5XJzy2zjWMhLxCLgFofD/FdNEpeu2Dx+BSSY6OoaWln+xn91LvNAWtLoy9uCER+YSht5MuCLbbndOS2h2Kh+vkdRVQ0uhmeFM0d80cG9RnJJmGPVc7dcD5wC2W7HspmSZK47o/XYXPaOPvBWY6+fFTzfXZGFFNBfyV3fxF2faBdM4awu1Ot6nRmzhfmEJ0cTd2ZOk78+0RYxtCZSFK2Cxt5U9luYhJ6KhrbkGXleSo1znjNN8JG3ueXVTtvLRCW6ZKBHKR6Il6npnjVVl/HZ+2lOalkJDhoavOyryj8tsqdz7lojUQATruVy8Yo6tZt+fo7IQ2WQ8X1tPv8pMU7GBO4XxuFBKcotof+u+LvdE2K0dAtKxTEO2yqYEHLNYtIcQcRfGruCD63UGnw+eYrBymqGVgR7ch5xR2mv3ntAFE2i/o5sQ56qdPZnW3i9RNZ9ZtVAOT9/q/IL98FOSvhU38Hq119f97aPPX9QSFJcPUvYcFX4N1vw96n1Ze0jDfr4jrXHqhZGCmnvBOyMx67v+sxEPPowc7X1ePQeV7ubjJmsX3kAkjNZYTjQwBcldo1f7c3Kus30bGBZw+9MttBaWCRfXB6vfLfZz6EPy+C7b+Hpd+Br2yHcVcor0UnQ1u9Yi3fDdYoq/o9GmpW8max3WTIUNPs5s6/7eRQcT1JMXZe+uJC5o5OJjHazpeuGM+W763g93fOZuaIRNq9fl7dW8zq323hnqd380leVbiH3yeyLPPbgKr9swtH9zsLuDNXTEwjKcZOZZObnQXdT9ZEx3RvFkexgQdkV7tP8yzqCxHKdsMU2wNZyLUt7SE/Fqqy3eATNIEkSaq6Xa/c9vXHKnB7/YxPizWkvWWiTlmSYsGrLytHvbFbLVw3PWAlf0g/K/mO5gNjHY+eyO5UbA+VMqsikMGemdB7sX3umGE47Ypi5nTF4BQzTW0e/vxxPgDfWDkBhy34a5ceVuF9oXeBcdi4YSz9wVIA1n97va6/u/hd7bF23ZXc/cVqt6rNGFodo3Bb6kfFRjH/6/MB2PqrrWG3ioxEZbtZbDcxCT2i8deoxZFouxVb4B6mlRU0dFiyx0UZy0GqO9SmeI1t5JuDtJEPJRaLxOJAhvkOHZt4e0IodZ12i6buauJ33haBue2dLeSN9t0RTerN7tA7Y7R2Uogb3Ta98xqOlrnt4n4Sa9D7SXf88PopzB6VRGObly+/sJ/WATR1CWX7QIrt0LHueaA4/A1GRsDT4oHA19WR4GDhNxey/H4Lt33mDc4WjqJ52R/B1jGXrzlVQ11BHdYoK+NWjgt+R5IE1zwK878Ea78Fe/8B6GMjr2S2G1/ZrpWNvNoE33le3t5izMYDSYK59zKsfRtOZ5u2ynaR2R4TBmV7fCYMvwwOvwL//gI8fwskjlCK7CseAXunNceYZJD9SsG9B4S6XcuM+3BgFttNhgSVjW3c8eROjpc1khoXxSsPLmT6iK4PMXarhRtnZvPmV5fwry8v4pqpmVgk2HK6is/9fTfPbi8Mz+CDZOPxCg6dbyAmyspDK8YPaltRNgvXTc8CeraSPxO42PWU1w5dF1xaNM6i7ozb6+NoIDdw9shhuu23N4Qlns8v0xhiC7JIU7aDfkpugTiPb5413HATeIAE0XygcZZkOBa8guXGmYrjwPpj5bo15wSbI2kUsgLqc1e7L2TfHaFsz+pD2e6wWVVbx8E2oD29tZA6l4dxabHc2k+nCXVypsHENVj0VLYLFn93MSm5KbRUtPDhDz7Ubb+RVEyFjvNDK+cD0YHv7OP7oiXzvzYfW7SN8gPlFGwqCNs44ILFHoOjpZ2jicmljmheNGrjryRJ6rOels/aatNBBDxXijG2+7S1hBbP2gk6u2otHKfkfvckHNATUVDVeq6+JOBCtbOgpkd3QqOyy6B57dAxT9TCGUOskUmS0oxhdDqK7drltkeash2U9dM/3z2H1LgoTpQ18l9vHOlXY4bPL3MssH554Tp1sMwJ5LbvL6of0OeHGqJhXLJK2KJtSEXbWDbuz5TVjOOl567jX3e9g6/TvU9YyI++YnT/5/iSBNf+GuY/CGu/Cfue7TLvCHWTTpfmb3dABGHEAjMEbOS1zWxX5+VeN/g9xj0WIxdikb0kJjZpWjwW577TGXje1ft4TFoDBR9D/gdw8xNw7zuQ2o3zcnTgft/ac4OQyG1vHqTYx2gY/25vYtIHJfWt3PbXHeRVNpOZ4OTVLy1iUmbPylZJkrhsTDJ/+dxcNj+8gjvmKfa2/73uBCfLG/Uadr/w+2X+Z4PycHD/kjEhse8TVvLvHS3vdgJeEFC2j+9F2e6wWVQVgZ5W8ifKmmj3+hkWY2e0QWzIomwWdaJW3RzayYlQthvdrrAzCToq2ysb29h+Runwv2mW8SzkoVOWpMbHI1wZ5cEwa2QSoIyxSafrRZOaYW+849EdTruVlEDjTmmIlLvlDcrkpy8beeiwkv9kELnt9a52nvpEKRB+a+XEfmfSaWnJFiyi2K5nAdrmsLHmz2sA2PPnPZTs6b4RLtREkk04aKsigPDbyAPEpMYw54tzANj2621hGwdckBlocISNvJnZbmISeloioDiix9xD2MhHgiKzs4pWq3m6x+dXC816N7YuGqc8sx46X6/OlcOF+H5oPVeflp1AvMNGY5uXY6UNmu4rlHh8ftXu32h57aD83awarWmpKu4IcMOAjmK7VoIJWZYjstgOkJUYzR/unIPVIvHGgRJe2FkU9GcLqppxtfuItlt7XV/tjdmBYvvJ8sawX/OMgFqQjncgndsJL96GNGo+MV9/E2tMDEVbitj0n5vU9+e9q1jIT1gzwDhWSYJrH4MZd8D6/1LXLPxev6KyDyFd5udC2a6nerkfyI4EbP428HfUFERxPGQ28kLZbvBjQXQSAE5nG64q7eaj4rhEOQLnnUNHG3mAuffBVT+Gr+2FWXcp343uiOm72B6bEVC2mzbyJibG4VyNi9v+soPCGhcjhkXzzy8t6tfDy8jkGB69dTpXTkqn3evnGy8f1LTze6C8c7iUUxVNxDttPLh0cKp2wWWjhzE8KZpmt5cPTlR2ea3d66eoVrk59HY8JUlSFxtadCy2H1Qt5IcZatIiimS1Ic5tb2mPQGW7xhO1zhw+34BfhkmZ8YwySPPFheh1PJoMPHmNslnURSgtu+U7E4mT+ewQ57aXNwanbAdYOlFZuNx1tga3d2D3wr9sLqDJ7WVyVgJrAg4q/UFMzsJpI6+qeXXOMB975VhmfHYGyPDul9/F7+s+3yqURJyyXeNmjHDbyAsWfXsRklXi7AdnKd2rX/TGhUSUst20kTcx0YwWNdLKuM9TorFVFxt5Ax8HgdUiaW4l33m7eqv9RyZHk53oxOOTw57b3qrO1bUtttusFhaMU4rVkZTbfrSkgVaPj6QYOxN6cU0MF5LU8V1pCrlDYWSJJpJiAsp2jdYs3F6/6spgVKeU3lg0PoXvXzMJgJ+tPR70tedIidIcMzU7YcBRE5mJTrISnfhlZf3rUkfM2UaPr4QXPw3D58AdL5M6dQQ3P3szADt/t5Ojrx6lraGNc5+cA2DimiDz2rtDkpQ86vZm7A4ZS8CtItTz0q6Z7c2ABHZjrnOqhV53k/qjkCnbGy7IbBf7MKqlvjMJgOjoNlprW7s4K4QS9fyICjQz6K1sj0mGpd+G2D6a54Sy3VXb41tEsd1UtpuYGIT8ymY+89ftlNS3Mi41ln9+adGACm2SJPHYp2eQGhfFqYomfvXeSQ1GO3A8Pj+/26io2r+0bByJMaFRaFosEjfOygbgzYNdFXRFNS34/DJxDhsZfSw4q5N4t35NCgeK64EOpaxRSIkTue2D6+C7EJfBrRu7Q81s1zgnUNmHMhlMM3CxSM1s1/h4GDWzXZCkQw5cZ4xsq98T2YHJSWnD4Cdtfr9MRWCSktFHZjtAbkY8afEO2jz+AS1cVja18cz2swB8Z9VELANYTBDF1EvNRl6w6rercCY5Kdtfxt4n9mq+v4hVtmuV2X7hpD5MJI1OYvpd04HwqtsjUdneVt+G36t9o4qJyaWEKGAbudiui418e2Q9V3bM0zUqtnfKKrf308losEiSxMLxykJvuHPb9WyMX5Kj/M7C1S0SEHnt88YkD2huoAcd14/QfleELX0kNOhAx1y9QaO5eudrkdEz7HviC0vHct30TDw+mYde3EdVU99rf6I4PlALeYFqJX/OzG1vb2pn1Kjz3HL185A5He58BaKUucDkWyaz5PtLAHj7gbfZ9X+78Hv9pExMITlnkFEWDsVFV3I3aRZh1aUZvr1ZKaYaSGTWhcDxwN3hEhxqG/mLlO1ROiu5g8WpfL+jY5Rxa9UALs4Pm9UN1iiwGXQdR1W291xsFzbyprLdxMQAnChr5Pa/7qCi0c3EjDhe+dJCVQ04EFLjHPzmMzMBeGZ7IR+dquzjE/rx733nKaxxkRIbxf1LxoZ027cEsnQ/PlXZRWl6RrWQj+1TOa51x3x3HDhXD8DsUUm67TMYRG57qG3kI1LZHpiw6qFsF3aRemcF9ge9beSNmiWZFKN8R7Tqlr8QozcfdIe4l5WEQNle62qn3edHkiA9vu9iuyRJXD4IK/k/f3SGNo+f2aOSuGpyer8/D52K7WFUtoezAB2XEcfyny4H4NBzhzTfX2cLvkhAnbxr1IxxUTZcGFnyPWWR6Pi/j1NzOjyFhIhStid3zAPCGUNhVH7yk58gSVKXf5MmTVJfb2tr46tf/SopKSnExcXxqU99ioqKii7bOHfuHGvWrCEmJob09HQefvhhvF7TyvRSQKgz4w1cMNLjWVvMdyOlSCTmA1qp/RvV5+zwzMEWBlTe4c5t1zPyTeS27ymsHbALld7sNnBeuyBeI2cM0aATEyGiiY65ujYudB3XUKthGy/6QhFrzSQnPY6KRjfX/t8n/O/G01Q09jw3ORpQtk8fPrhiu1j/fG3vefIrm3p/c5AY0dm1T2SZ6DMvcM89/6KmaQTc/dpF1uJX/vxKxl41Fk+Lh49//DEwCAv5zjgDxeW2Bs3izboq21uMq+SGbovtomnd3eRG9g88z16Nd7uo2G7Q42G1QVQ8CSnKd0qL3HZZltXzw25t099Cvj/YHGCPDUrZbhbbTUzCjM8v84Vn91LT0s604Qm88uCioIoIfbEiN537Fo8B4OHXDlPdHFp18kBwe338/gMlW+ahFTkhVxNMzIhnclYCHp/MuiPl6s/PVCkXumAs+YXaWq/M9upmN+dqXUgSzDSasl0jG3lXewQr23UoqopJcUK0cRe+1BxJDdU20DGBNWrjgWpNp4ONvM8vq40qkaImABiu2sgPftJWHpigpMY5iLIF98gniu1b+1lsP1/n4sVdSnbdw6tzBxzxISZnRshsD4eyHWD4fKURTosJ2oWonfNhtk0PFq1t5C+a1IeR9GnpTLx+Isiw/bfbwzKGSFK2W2wW9e8WaoXJUGHq1KmUlZWp/7Zu3aq+9q1vfYt33nmH1157jc2bN1NaWsqtt96qvu7z+VizZg3t7e1s376dZ599lmeeeYYf/ehH4fhVTHSmxW18ZXuCDi5SalxThDRxaq1sbwqzg9SiQLH98PkGXSPtLsSlY2P8hPQ4UuMUF6r9RfWa72+w+PwyuwtFsd14ee2CeLUxJbRzdZc7skQTiRq70DVH2DW0J+IcNv7y2bkMT4qmutnN7z/IY8mvPuTrLx9gX1EtstxRYPT5ZY6VKoXIGYNUtq+ZkUVKbBRnq1tY8/utPL+jsMu++sP5Ohdfe2k/dzy5E/8gCqK642mFNx8is+S37Nkzi4/yvtFtwdFis/Cplz9FwsgE9WchKbarxeUmzealXZqd3U3GzSgHZKdy7KXOynbRtC53NA4MBLXpQDjOtRvcRh4gehjxwwLF9qrQr+V427yqg5vN0qa/hXx/iR7Wq7I9Nj2WqPgorBEStRIsZrHdJOI4UdZISX0rcQ4bL35hoaomDgXfv3YSuRnxVDe7+c9/HR7wg0uoeGnXOUob2shKdHL3glGa7OPmbqzk8ysDyvYgMrX0zmw/GFC156TFGa6gmBIozNSEuFGjJcImadCpuKyHsr3NVLYLmtzK9o1aXBbFdj0cD4SSACJrQh/KzHZRbM8MwkJesHSCUmw/WtrA8dLGPt7dwe8/yMPjk1k8PoXFgYL9QDCEjXyY1bwxaYoFnqvKpfm+Is1GXuvzwyg28oIl/6mo2w89e4imstAoWIJF9st4WpRrdaScH2Zue+/YbDYyMzPVf6mpyrW6oaGBv//97/zv//4vV155JXPnzuUf//gH27dvZ+fOnQBs2LCB48eP88ILLzBr1iyuvfZafv7zn/OnP/2J9nbtG+hMwouICzNysV0oUzW1kReFIgMfh86IAmKzW5tj0lFsD88cbGRyDMOTovH6ZfaGMbfdpVNmOyiq2sWqfb7xreRPljfS1OYlzmFjcpZxFXgJGrlAiPlobIQUErTObI+Exq1gyUmP4+OHl/PHu2Yzb8wwvH6Zdw6V8qkndnDDH7fy2t5i2jw+zlQ10+rxERNlZWzq4ApjWYnRvPfNpSybmIbb6+eHbx3jgWf39kso1uz28pv1J7nyfzaz9nAZh87Xc/B8/aDGpRv15+Dpq+HYG5yJ/z7r1y8nKr7nKNnYtFhu+/dtWB1W4rLiGL109ODHoGaUN2pmI9/FeS5SlO1tHetGNqcNW+CaOhi3QnVefqGy3chq7uhEYhOU65wWwgmxTgVglVuNfSwAYob1qmzPvTGXRxof4bZ/36bjoLQn8u9wJpccIpNr/thktfMyVDjtVv7vzlnc+MdtfHCykhd2FvG5RWNCuo9g8fll/vTRGQC+fuUEnHZtHtBvnJXNr94/ye6ztZTUtzI8KbqTjXzfD4Mdk3h9iu0HipWJtNEs5AGSY5WHgBqtlO0RMkmDzpntetjIC2W7cYvtHUp/rTPbjZ0lmRgdsKbTIbNdHIsomwWHLXK+O1mBTuCyEBTbywJ2dpn9sMROT3Ayd/Qw9hXVcdOftvKNqybwpSvG95rFWVDVzL/3Kw1b3706d1Bjjk7SNpM7GMKtbI9JVRYNPC4PHpcHe4x217ZwNxb0F80z2y/Mhgszoy4fxcjFIyneXszOx3ey6terdNt3e6dInEhQtoOS215/th5XjfaNKpFIXl4e2dnZOJ1OFi1axKOPPsqoUaPYt28fHo+HlStXqu+dNGkSo0aNYseOHSxcuJAdO3Ywffp0MjIy1PdcffXVfOUrX+HYsWPMnj2723263W7c7o5F4MZGZTHO4/Hg8egTKdMdYt/hHEMk0dSmXA+ibZJhj1lslPKcUt/SPqgx9nZuNAacmaLtxj0OnYmxK8ekocWtyXjrW5R7cWyUJWzHY/7YYbxxoJXteVUsHpsUljE0tfb/vBjMNWjh2CTePlTK1vxqvr5iXL8/ryc78qsAmDMqEdnvw+M3pmV1TGCtrT7E35VGl3L/i7b37zsSrntUXOA6WqfVNSNwPGKjrBFxDQ2GqyencfXkNI6VNvL8rnO8c7icoyWNPPyvw/xy3QmmZivFyClZ8fh9Xgb7FRjmtPK3u2fx/K5zPLYhjw9PVnL177bw61uncsXEtB4/5/PLvH6glN9tyqMq8Iy/cOwwHrk2lylZcb3+PYzwzCQVbsH6xhfBHov33nWcf7YJ+Bh7rL3XcaXPSudLR76ENcqKX/Lj9/gHNxBrDHbA21KnNme3VLeE9Ni0BdZwrDFW/DWNYI/BZ9Dvi8cSjR3wueqRO43RkejA2+alubqZ2OEDaxYQjnP2OOVvLLkasAEeKQoMejysjkRi4pTrXFN5U8i/M801Sq0mKj4Kua0R2R5r2HMDwOocBi3Vgx6jEa5B/dm/MVfjTUx6YXugg1d09IaaSZkJfP+aSfxs7XF+8e4JFo5LYUKG/t1C9a52tUPx03NHaLafrMRoFoxNZmdBLW8fLOXLV4zjTEDZnpPe901RZNbpVmxX89qH6bK//pAap42NvKpsj6AO4A4lt/bnRYey3bjHp8PaUp/M9nApTPqiw0Ze+4fPzkbiAAEAAElEQVQkYalv5HzR7hA28uWNbXh9fmy9FLn7orxBKdhn9TN/+onPzuG/Xj/KphMV/HbDad4/Vs5vPzOTSZkJ3b7/d5vy8PllrpqUzpxBXpsdScqkNazK9sACRLgKjI4EBxa7Bb/Hj6vGRWLM4CwHeyOSbMJBh8z2BuNktguWfH8Jr9z4Cvv+so+l/7VUt7GJc0OySNgMHNPSGVPZ3jMLFizgmWeeITc3l7KyMn7605+ydOlSjh49Snl5OVFRUSQlJXX5TEZGBuXlSsxUeXl5l0K7eF281hOPPvooP/3pTy/6+YYNG4iJ6VmNpBcbN24M9xAigvxCC2Ch6Mwp1rlOhns43XK+TAKsnD57jnXrCge9ve7OjZMFynEoOZvPunV5g96H1tRXKePde/gYw2qOhnz7u8qVY95SV826detCvv1giGlUxvD+gQKmeMPzNzlapBzn8pJi1q0r6tdnB3INamsDsHGwuI7X31mH08A9xWtPKccmwV0ZtnMkGGorlHEeOHqSdY3HQ7bdA+eV87O2sox160r6fP+F6H2PyqtTxltcXqPJ32tftbL9tqZ6Q58PA2WZA+bMgh2VElvLLdS5PGzNV8Rise21If2d04BvTYHn8qyUtbTzhecPsDTTz42j/Fyo0clrkHij0EKJS4l5S3XI3DzGz7RhVRQeqKLwQHD7DMszkywzvvJ9ppa+QlX8VPaO+gqe/cWUHiwFoLSmNPjjenDww7H4PdwAHN69lfKGMQAc23uM2nU9q3f7S2OV0pi6+9BuYihAkv3sMur3RZa5ASsnD+2msLRjrchrU9biNq/fTFzJwBwdygrLADiWf4ySdSWMqdrFdMnKug0fDH7cGjGvvg2ZBgAO7zhM1biqkG7fdUZpKJejZMrP5WP1e9hp1HMDuKy+DXtNPjtCNMZwz9tcruAa+iNj5cTEJIDX52dPoaJsXjju/7P35XFylHX6T3X1PdM9PUeSSUgISTiSkEDCHU7lCDLgiQcI4rW6Knso6rqux67HrqvrT12VVXdV1AVFVHQRwxGQQ0hCQiAhECAHuZPJTCYz0/dZ9fvjrbeqeqa7p6vqre56a+r5fPxEZrqrq9956636vs/3eR77Mp/ed+FJeHzHMJ7cMYy/u3sL/nDrhS1XRlLSrDPkbzpr1yzesuIEbHjtOP7w/CG8deUJyBQrEH0CTuxpgmxvoY18RZLxwkFy43Kmsp3ayHvKdqrkboVduEq2O1jZ3iob+bTD7S0TNAcuZ7/lLLXM5MlCHiD56gFRQKki42iqoJLvZjCoEIdGlO0AMDMWxv/ccjb+b8th/PN9L+HFQ0m88XtP4e8uPwUfeV21yv3lI0n8cSspdj+52pqqHbA/k7sZqGrvNinbBUFAtC+K9JE0ssNZdM2zj2znTdlu9/yYlA3nAJx67amYsXQGhrcP49kfPIuL//Hilnyu6vAQC0IQhJZ8plVEe5UIBk/ZPgnXXHON+v/POOMMnH/++Zg/fz7uueceRCLm7zNT4bOf/Sxuu+029b+TySTmzZuH1atXIx6v3cDVCpRKJaxduxZXXXUVAgHnPj86Bb87thkYGcG5K8/AwFkntPt0aiL//CHcu/cldHbPwMDA2aaP02hu3P/LLcDwEM4+cxkGzptn8Yztx3NrXsEzw/sx96STMXAVg6zaCdj3xGvAnl045aR5GBg4nfnxm8EZoznc9a2/4GDWh0uvuKItNdCz978MHD6ApacuwsCVzY2z1TXojr1/wYHRHLpPPRevP62+mrXd+Mn+DQCSuO6Ss3HF4pntPp26eHntTjx1dA9mzTsJAwOLmR4XB/bgtEXGjtuue9Ts/WP471c2Qg5GMTBwCfPjj286AOx8GfPnzMLAQG1HHDfgnSB714++Moz/fWY/Xh1M4+/edJblzPZaeE+pgv9YuxM/X78ffxn04Uglhm+94wwsmR3DvuNZfP3BHVj78hAA4n546+sW4ubzT0TIwB5z256ZihmIf/o4fId/j8qFf4/uy/4JV/nInuhDDz2EIQzhtDNOw6UDl7bunADIL34MZy5egNGVp+GpPz2FOT1zcM3ANVO/sUlsL5GGnyuuuQJ9G+4Cor0YGBhgdnyWKJVKKG2LYMnCE7D0Eu0ch04YwuFDh7Fi8QqcOnCqqWP/+As/RgYZrHrdKiy4cgF863dBOBZz7FgAgHj/Q0iPPQMAmN01m/m57ntyH3ZgB+J9cfT3dALhhKPHw/fAY/AdetbyOTqlbqMObVOBrx1oD9Me2w6NI10ooysSwNLZ9m3Q+HwCvvmOM/CG7/wFLx9J4psPvYrPXbvUts+rhVaSZtcsn40v/t9LePVoCve/QEiT+T3Rpkj+VtrI7xpKI10ooyMo4pSZzssmUcl21sr2Io+Z7a1RcgOaet6p1umA1ghgd/NBShlvp45FK5XtSYdb6teDzydgdlcE+49ncViJ9jCLwSQhJI1ktlMIgoC3rDwBFy7qxT/9nqjc/9/aHXho+yD+4+1nYolyD/5/D+8AAFx3xmwsnWP9vkxVu9PZRh6ARrYfs5c0pGQ7L8p2u23kqV2dU2zkAaIsv+gzF+EP7/0DNnxnAy74+AVqDp6d4G1uADplO+PsRDcikUjg1FNPxa5du3DVVVehWCxibGysSt1+9OhR9Pf3AwD6+/uxcePGqmMcPXpU/V09hEIhhEKT51AgEHAEye2U83A6skViu5qIhhw7Xt0d5PkhVagwOcdacyNbIjVZl4PHQQ8a35QtSbacb0ax4+2KBts2HgtmBjC3O4KDozlsPZTC605rPaGbL8sAgFjE+DiYXYMuPqUPv9p4ABv3jmH1sjmG398q0H2MREfY0ddMV1Sxgy6yWT8o1LkRNneNtPoe1Rsnz1HjuZItn2vlWuENgQBw3Yq5uG6FfS6l5HMC+NKbl+PyJf341G+2YtdwBm//0TNYffosPPzSURQrEkSfgHefdyI+fuUp6O00/1zf0vl4/DXg7puB0b3AO34O8fS3QC89KqXJflIkEWn9XArHIZYy6Ogj4rTieJHZOciSrO5FdPR0wFfMAD0L4HPw9VIUowiXMhB150hr9nKmbHpsaC0a7YmSY5RzQLDT2WtHRw+CflKH5o/lmZ9rJUvuqeGuMJkbiXmOnhvo7APyY8zGod11W7Ofba9c1oMHxlin5LVfsLAHPp+9KpuZsTC+cf0ZAID/+cse/GUnW/uPqUBJylaoMrsiAbx+MemI/sHjJCd+0czmrF6osr0VZPvz+4mrwRlzExBt/vubQZ/y4DqaLUKSZGbHzSpj2xHylO21oNnIO/chg45HplhBuWIxJ6oB0g4nmLXM9hYo2/POVvk3whzFKvuwxdz2I+PGM9snYmacqNz/84YVSEQDePFQEm/6/lP47qM7sWnvcTzy8lH4BOATV5nrWJ4IqlzOj+Yhy+zWUSOg9tntVHt3zCDFu91kuxO+qxFMRxt5AFh24zLE58WROZrB1l9sbcln8jY3ACDS49nIN4t0Oo3du3dj9uzZOPvssxEIBPDoo5ot46uvvor9+/dj1apVAIBVq1Zh27ZtGBoaUl+zdu1axONxLF3a2oZkD61HWq1FnPtMRRtbUzY2+vL2bEn3Eeh5s0bKIeOxSnE8XP/aSFs+P0sb4wOtq9VXLeoDADy9uz3fuVnQOLwOh4sGaO2cYnytUPfHKCf7OAl1HS3bsmeRVuZDu9cMN+KyU2fgwb+/BFcumYViRcL9LxxBsSLh0lNn4IG/vwRfecsyS0R7S1EuAj+5GijngQ89Cpz+lkkvUd3I2tEgHYoDhXGtCZxhXVrUuaSG4iGgmAGC5mzYW4WSGAEK1YpfFgKKSU3wxQwQcvZYININP0gsb2Y4w/zwVfO+mAaCzhMhViHSA2TZRSzwAo9s98AVNigF1CobLeT1uHLpLNx8wYkAgE/es5V5FncjtJo0e+tKYglIVdmLZhgj21thI6/ltSds/ywz6I6SDemKJDMjmSVJVlUUXCnbFeI7W6ygZCO5DGjW7E62kddfx6yLeIqKJKvqAadmtndTZXsLmjA0dxBnjkUjzFHU7IcskO2yLGNQKVBmd1mzCBYEAW9ecQIe/sSluGrpLJQqMr61dgdu/O8NAIDrz5rb9D1jKlCyXSpLKGXsnye14BRlO2BPkaYHb+plvY0862YMqSKpf3snKdsBQAyIWPVJQnqu+491kGy+rwL8zQ3Ay2xvhE996lN44oknsHfvXqxbtw5vfetbIYoibrzxRnR1deGDH/wgbrvtNjz22GPYvHkz3v/+92PVqlW44IILAACrV6/G0qVL8Z73vAdbt27FQw89hM9//vO49dZbayrXPbgLmaLzyXb6rJ206Tkb0D1bOrSpdSLoM7BdY+KUJl8aL7jhtfZs6NLIt2gLr48LF5Hv/PKRJEbShZZ9rlFkOBENxGxqTFHXTk72cbp0+yl2rBt0fJ18L+EZvZ0h/M8tZ+Nrb1uOyxfPxB3vPxe/+MB5OHWWwwm5icgdBzJDwNX/BsxcUvMlap3SjpotHAcKKa3Jl6GjFm129vl9EEOiQqhOHe/aTpTEKIQJZHsoQf4uZsl2WZZVYlltgi+kHD8WCCcgSmkAMrLD7EUTVRGAhbTzmw+iPUApA5Sd+5xiBzyy3QM3KJYlbNpLCqgLT+5r2ed+bmApTp7ZiaFUAf9077aWfW6rs5dfd9rMqkJ50YzmbmIxlWyv2HJeejx/gCjbV57YbftnmUHQ71PHkJWVfL5cAeUTnF6k6qGfS3bmlMuyrJLXTla2B0QfokHy97PLWl/vLuHUbvGE0pAy3gIb+ZTqeODMsWiEOQo5bkXZniqUVaWNGRv5WpgZC+O/36Op3MuSjIAo4O+uYJcDGogG4FMiTNplJa8Srm0kGSN9ZA7YrmxvpyrABKiCQK7IVZ3/LECLV8BZme0UZ/3VWYj0RHB813G8fO/Ltn8ej8p2L7O9Pg4ePIgbb7wRp512Gt75zneit7cXGzZswIwZxNnq29/+Nq677jpcf/31uPTSS9Hf3497771Xfb8oirj//vshiiJWrVqFm2++Gbfccgu+/OUvt+sreWghMhyoEWkdYGfd0er63Cq0uDd7xiTlEHexCxTi+cVD47Y6G9SDFvnWulq9rzOExf2EQGuXon8qyLKsks1Ov2boHE4xvlbo2tnKuWEFftGn7u/Z4USXUddQPsaDRwiCgBvPOxE/fd+5eH0bYjWYoECUwQjXj6ijNWxb6pRQDMgnq5rAWUFfmwuCoJDtziZUy2KEEOE6qG50JvdzStkS5ArZCK9Stjt8LBBJQJArCAaLyAzZrWxPcTAeCnczzdTtHtnugRtsOTCGfElCX2cQpzRpcc4CkaCI/7xhBQDgwZcGW2J/DGjq11Z1iocDIgaWzVb/+2SDNvIpm5XtqXwJO4fIQ9eKeQlbP8sKqJU8qw5zWqAJAhD281OU+EWfWlTbqTDJlSooK5b9NCfeqbDbWp9uLoX8PgT9zry9J3TKdrstwlWrTx7JdkXZfsQC2UxV7V2RACIMN3j0KvcPXbIA33rnCszriTI9vh2Fa7OQZVnrGG6jsl21kbehI1oP3ghVf8QPUZnPrJsxaPEqhkT4HbgpHOwI4ry/PQ8AUbfbDU/Z7i7cfffdOHz4MAqFAg4ePIi7774bixYtUn8fDodx++234/jx48hkMrj33nsnZbHPnz8fa9asQTabxfDwML75zW/C73feteKBPdIcqFOpw1WhLKFQtqcJnFsbeZvq9FbvV9TDCYkITuyJoiLJeHbvaMs/P1dsj1X6hdRKfpczyfZcqQJJFQ04+5qxy0Y+y0mzgR5xG/cs0hyOh4c2gKqkGxCJ7beRT9pjI69XLsuyQjA7W81dqkW2Uxv5cXNjQ/++gk9AoENp6OOBbA8nAACRSAH5sTwqRbbPo9q850TZHukh/+Y8st2DB0divZJHdf7CXtLh1UKcPqdLfSAcbYEiE9CK4lgLLZDfvHKO+v8XNm0jTzZd7LaRf+HgOGQZmNcTwQwHb/z2dBDCglXkgGpLFxDhc2BOfSO0Irc9mSPj4/cJiLQwJ88MNMWNuze8GoHOiYok27bxR5HiTH2kB81st2Ijr1nI25M9PTMWxueuXYo3njln6hcbhB2Fa7OoFCuQysSi2wk28nYr23kjVAVBsC23fVIunAOx8gMrAQCHnz1su5U8b40YgKds9+DBDhTLEorKfdHJz1T6c7MjsknSxTXx0shJFap2Z7Y7Ib7qgoVkQ3dDG1TeVL3Nsrm1GVx0spJVv/tYSz+3WehFA05XdtM5zD6zXVG2O3jtnIiEjbFvno28h6ZQVJTtofr297ROaY+NfFe1jfxoDrLERkhS1URQLgBSueE4OAFlX2SSjTyt1wtj5kRokxT+ABeW+ogkyD8d5PxZ7+XQeR+OAZArzs9sjypku6ds9+DBmVinFBE0n6rVoCSRndZ0eqTaoMq8YEEvbr7gRNz6+kVVeU2NQJsB7Cbbtx8mN+8z5iZs/Ryr6FXIdlY28jwWaBRqdqKdZHtey2tvdROOUVDlvd028k7Y8KqHcEBEOEAePcZsblxKO2gD0ChOSFi3kadke79NZLudsGo7ZgV6K/G2ku0z7CfbpYqEknId8kSo2uV8UBifkAvnQHTOVhohZfuvjyplBSewIzvRg4fpDn2N52SCRPQJKrlsR+1BCVXA2U0HetivbC9VfU47sUrZI2qHpXq7lO3nLeiB6BOwdyRrqUHXLqh57UG/4+t0TdnO1n0tq2a2O7vZQA9KttsR+5bhuBneQwtBVdKNyHZKxrajYXyCjTxk7XysQm0iiIWIkhtwPMFcEqNAvjbZbrZepXV5VbRbkQMlt6JsT8wi95HMMFsr+WKS1OfRmNJ07/TxoDbynrLdgwfnIV+q4Pn9YwCAVQvbQ7bTB3A7Vbp60OK1lSpVn0/AV9+yHJ++enHT76HKdrs65ilGFfv+GZ3OVZwBQK9CzowwypLlsUCjaI2ynZ9cbruzJNUNL4cXr4kIuUbsJtvb0bDECrMVsj2ZL5vOnjxCyXZGee2tRDtt5GkOuD/sV7Pj2wFV2W6jjbw+85wXZTtgn/MBD/n1YkBUNx3sdj2o2uzhBNRGvpwro9Si53UPHtwOStSG/D4ERGdvH1H7YzsirOg4+H0CQg6Na5oIWhPYofQHNBcpJ7hqXbBQy223q7G5HiiB2GpleywcwBlzuwAAT+9ynrqdh/gJClovlioyCmV2zkHUDSPa4kYMK9BqdfbxmXRO8Fife2ghaGZ7HctwqSKhlFEiFNtoI+8P+eFXBDWsGn2rsuiLStOBw63TSWZ7NdlO61WrNvJVf98CD8p2Qi4nZihkO+PcdjoukQ7luc7hcwPhBCD4gFzrI37aCT6qBA/THs/tG0WxImFWPIQFfe1ZXFtBHOqR5qTrk55fpli2NYNZr2B2MjQbeUaZ7RwWaBTahldrlO1Oh/2Z7c7Z8GoEzZqOfQGvhxbF4ezxqIXOkF+dL0dMFiiDSVLw8ahsV8nUdijb085Q87bCRp4ql31+H0QONkIpaDMG6/mh2sh3OZtcbnXEQLuvBSMIxUNqk4yX2+7BAxtkOMrY1atTWSOjI4mcrtKloA50BV0UACtIukgoJ9Qes7siOKk3CkkGNu1prYIqV1KU7W14lrpIyW1f50CyXVW2c7B2dAb9oJc1y72LDEcNBxRddtrIczQnPLQRhSTgCwD+2jWZvmG8LXVKOK4qufVW8iygRrzF9cp2ZxOqJTFK3Agk7TnDqrK9ZrxbMeN82/QwaYCL9ZKxYC2cUG3kowrZ7nRlu89HCHfPRt6DB+dhnZLXfuGivrYVt10tIA714IU4o12pkqwVmnaAjofTFcy9HeRhgJWNfJbDAo2ilZntTr9OAPubD3hZM+i8sF3ZzknDUj3QrHWztpB2Z7bbiVBC6YRuQ2a7mlPdRgt5AOiYQRoLsyNZZhlwE6HP5OaFOAC04n062sgDrSfbeVK2C4Kgbnp5ue0ePLABT4SZ5iLFXslNn7NbbRVuBfr6kXXkG2m0J/8/7pDIJqpub2Vue7EsoVQhAxENtH5uXKjktj+9e8RW4YMZZIr8XDM+n4DOIFsnCEmSkaURAxysnxQJG2t1z0beQ1OgduF16lOq7hWDIvztmEuhOFGdSxJzx7UqZbuq8He2mrskRiBAJn83BZZt5JM16nIeMtt9IhDqQmeCrHV2KdvDYWV9DsWZHt8WRHs8G3kPHpwImr3VLgt5QCPKWqZs5yRvOBIQ4VOegey0ktfswp09Hqxt5LlWttu44UWhKtsdPi8ArVHErvHQ3DCcPRbdUcWazua1tB1RHCxhNbedKuJncWgjT4vWdtrIt5tsp3bYckW2TeHPI5kK6JTt09BGHmgd2a5vxuAJ9NrxlO0ePLBBusAPWRRX7FztaGx1koq7WfhFHyIBJfKNMdlOCUkn2eprZHvrNnVpXjvQeht5ADjrxG6E/D4MpwrYPZye+g0thLZ28CEa0Jwx2FwreiEKDw0HFGpmuw21ekaZEx7Z7qEhCqnm8trbVbPRcyumtPg7VjbyKd13o+S1w9XLZZHUpiik1J9RkrwwXjDVCKZmttO/sSQRZbvDxwIAEOlCR4zss7DObFfnPiXbHe56AACI9ABZz0begwdHIVMoY+uBMQDAqkXtI9tbbSPPiypTEAS1eGBdxOuhKtsjzh4Pqmw/zkrZXvSU7Y3ASxMG0AplOx/kslrA25ADp0ea48x2AJijkO1HTBKtg0mqbI8wO6dWgRathTE2cRxG4BQC2h/yqySnXaQqt2SqTTEDno18NZxyLRhFtJeMD6tNLw8epjvU5ykOahFaD9hqI+/w2nwiOhkTiBT65gOnuONQsv2lw+Mt27PJlsg4BEQBwTY0HYQDIs45iWTEPr2rdYr+ZsDbNRNjvH5QZb8gAOEAP1vvdu3hFMoVFCvEWpmH5i0PbUQh3dAuvMpqvR0IK2rifJK5jbxKpsZ4spFX9pt0ue1U2S6VJZRMuGSo40Dr8nIOgOz4sQAAhBOIRMn5s1a207kfCCj7ZFw0H3R7ynYPHpyGTXuPoyzJmNsdwbyeaNvOoxUqXT3oQz4PRBE9R9qpageSKpHobFKVZraPsMpsL3CsbLdRXULBSxMGYL87RpoXG/loa2zktcx2Z68Z9TDHgrI9X6qo48tjZrtdNuHNwCnKdkCzkmfdEU3RdlWASai2dJ6y3dbP4bYZw7OR9+CBKXgizGI2ukipNvIcjIMesZA9TfEpB9bm/V1hLOjraGluuxNq9QuV3PbHXh1q2znUAk8RFIC2frBya8xSZX/QOQ0pzaArorjQMW6M1+8V8nA/8dBGFNNNKdvbVqOEuuiJMLeRr85spzbyziZUyz6FbM9rZHugIwBBJOuemQb5SXU5J5b6AIBIAuEQ+c7MM9vp3A8o63OAg/GI9niZ7R48OA1OsJAHgC5KHLbKRr7AR0Y5oBVQqYL92dxOVzBTG/nRbAkSg5xdVdneBls6q6Bd0XZeM3zZyNs7Hrxktici9tvIlyuSmpHn9PGohzkJ85ntNK89GhS5uIdMBOui1QhUst0BBKPdpCqvymXVrs+mzHZelO25Y/Y2o/A6PzwbeQ8e2CLNEWFmp4uU2nTA2XOVpmxnOyZJh9YdVN2+vkW57Tk18q19tfoblvUDAJ7cMazWAE5AhqMICoC9jTxdO9s5N8yAutCxrtVpE0MkIEL08dN84KENKCQbKnbb3iBNGwEK7G3kaf0VjAWJst0XAPzt35dohJJqI6+R7YIgVFnJG8UkxzlOGg8AAJFuBP1k/4alsl2WZbUZPiDmyVj4OKB1I15muwcPjsOG3QrZ3kYLeUBTY7bCkkyWZZ1ln/NJRFpA2alspxsETlcw0zzqiiQzmStqtzwnRaoedpPL5NhU2e7860RT+tvjjpHkZM1ItEDZrl+LeNngmQg1s33ceOFG89r742GulBQUaia3TVnljaCqeR2gbI/OsJds51a5bFMzBt0ICDvcDYKSyZ6yvTbU8fGU7R48MAFPynbNRp79s7bmmOT8cdBDVevalNnuPLK9BwCwoUVkO7UKbyehumhGJ847qQeSDPx284G2ncdE0LHhYe0ANJcGVs06tPGbl+9PoUW+MSbbOWrc8tBmFKZQtqd0VuvtQCts5OMhJbve+eRymdrI58erfq660ZnY0ykmJ0QFFDlStocTCAiEZGepbC9lSoCi5/MLeT4aDwAg2u0p2z14cBKS+RK2HSILdrvJ9jjjh+9GyJcklBVVNA/d8zTDL2NTZnu5IiGjqlSdTSQG/T5VScrCSp5rZXsLGlSSnDRhAPY3H6QLnGS2RyjZbl9mO3XZCPl9bclPZAFqIz84nkfFoEvGUSWvnUcLecAhNvIOIBhVZTtj+zEKXpXLdjVjtF0l0STUeWEzmawqKxzQeGIEama7p2z3wCEK5Yp6D3cK0kV+CBLNRp79s3aKU6KIEn2sGxDUyDuHNflSN8TtR5LMycJa0JTt7Z0XN5w3DwDw62cPMHHXYwGVXOUkDo+1sl1txAjxtY+jd6GTZXZziY6H0/cqPEyAJAHHdiJQtifWrCYKqYZEYttrtlCcnohWlzJqAq9qJChmuCBUy74wZMFXpWwHrJHtqrJdJduV+degCcMxiCTgl1MA2MYB0nkviAJ8UpaLRgwAirJ9FGB4P3E6+NyB9jBtsPG145BkYEFfB2Z3Rdp6Ll025y3rQYkiQeCDZFWLeJvIdn0nPg8P572d5IFgJG2dTMw4pIA3A61BxZ55AWibaTzYyNu9htCNAac36HTZZE2nh6a2cf68qIeZsRB8AlCqyDiWNta4oyrbOSXb22oj7yCC0W4beV6Vy3Y1Y0yyq3MoWpHZLpUllJV1lLdmDM9G3gPP+Jf7XsKqrz2KLQfG2n0qKnjKXW6JjTwH46AHJcNZK9upC5/T4opmxsNYOKMDsgw8s8d+dbsTlO0AcM2y2YiF/ThwPNcyC/2poK0dzt/PArS6kRXZTjPbedvHocr2iiQzXTfomsHLfPCgQCoh8KNV6B9/vnWfWUxrhHYNqLnV8TbVsMEOQCGX6b4FKxv5qkaCYoYPJbcgEBI8X02205o6byLehI6D6jhHyXYexiOcgK9MyPbCeAFlRuuoOjdiIQjFNBeNGABIZrtcmdSM4WZ4ZLsHR4MWChe0Oa8daDHZnteKeR4sgDUbeZvssXNavlNAdP6y1dtBHvpGMtbJ9ixnRaoe+muGZVe0HkmOSFW6AVgoS8iX2Ecu0GLYaZteE6F2y9uoNlGtPh0+Fo3gF33oj5vLbR9UrOfp+3kDJVNL2RIqRfviSWpBVbY7gWy32Ua+KhOOI9hmIz+xqHcoWkG200YMgMP50cN208uDh1ahIsm4/4UjkGSSvewU0GieTg5qEVtt5B1qmz4VVBt55sp2544H3Tva8Jr9tqVZB2S2A0AkKOItK04AAPxq4/62ngsFT406gF7ZzqZGzXDqUBgOiAgpznAs63XenA48KPCHIPsjCFRarGxvoNptuzubjlymdQerurQ6s72xwt9RCMXJ300HK8p2Gu+mKtvpsXkg2yMJoDAOn59wOaxqdtX1IB6aMmrBUYiQeJ/pZCXPnLWqVCr4whe+gAULFiASiWDRokX4yle+UkW0yLKML37xi5g9ezYikQiuvPJK7Ny5s+o4x48fx0033YR4PI5EIoEPfvCDSKfTrE/Xg8OxTslrv7DNFvKArlPeRuKQQusUdz6BCGgd/raR7RxZhQNAD0OyXeuW5+O760H/XhVJVjciWENVtnMwN2IhP2jvjB2bgLyoubs7aBNG0ba1NJ3nU300EdRK/ojBAoUq22c7nDSsB72yuNW57W0v3nXwbORrg9r1lfNlVX3NApOKeoeCzov8aB5SWbLlM+jc8AV88HO2jlIbeS+z3QNv2H44qT7LbT/sHPWH1gTu7OdLwF4beV7zhumzMPvMdhpf5bx5Qa3kW6Hwpo3xUQfMi3edS6zkH37pKI4z2IewCt6uGdY28k6aG0Zhh9Ao44Jm+GmLcByBSgufqwuNVbttt5EHgFBXlY28LZntvCjbAUL8MrSRV8eha4KNPA/NB+EEBFlC9xwlbneITaNK9dzgTNkOADmPbDeNr3/96/jBD36A73//+3j55Zfx9a9/Hd/4xjfwve99T33NN77xDXz3u9/FD3/4QzzzzDPo6OjA1VdfjXxeuwBvuukmvPTSS1i7di3uv/9+PPnkk/jwhz/M+nQ9OBijmSJePkIWaycp2yWZfbE6EWnObOrsyoKjUMl2BxbztUBt5I8zsJGnJDWPynbiREDYZTscIWRZ5mpu+HyCeq3YMR68EMxU2V6q2NiEkecjv34qULL9sEFlu5bZ3t74FbPwiT61sGp1brujlO2ejXxNhGIhCD5yb2HVjCHLMjc28pHuCKA0btml3q7KC+QMno28B16xQUcMvjzoHLKdJytozUbeBmU7Z/U5RSdjApHCyfFV5y8kG7uvDCYxlrWXdM4qbmXRQPuvj2UndGHZCXEUKxJ+//yhdp8OV64YgI5sL7BStiv7OJwp2wHNSp7lngVvzRcedAgnWqdsl2Wi6G6g2nUE2R6OE2U7Qxt5WZLVvYhQjC/1shyK17WRpw3tRjDpb1xMA/4I4ONgPY10AwC65yjKdkbCCTU+IRZU5gYnZLuqbB9t73m0EMzJ9nXr1uHNb34zrr32Wpx00kl4+9vfjtWrV2Pjxo0AyGbWd77zHXz+85/Hm9/8Zpxxxhn4xS9+gcOHD+MPf/gDAODll1/Ggw8+iB//+Mc4//zzcfHFF+N73/se7r77bhw+fJj1KXtwKGjG1ikzOzHDAZt94YCIoGKnZGcGNaB1ijuxeK2FVtnI80KcaTbyxh8qJoKOKY/KdkEQdLnt7MnlQllCqUKU0XRzzenosilLMl+qoFghCkenXyfhgE9dS+3Kbed1Q3QiKNlu1EZezWzn1EYesNYJbQUq2e4AArpjBulkt9tGnjdCVfAJzJsxKoUKpBJZQ52ubPf5ferGjhcxMBlU2Z47noMs2etE5cEDS+hVuPtGssysjK2Cumzx8ExFo5TShTIqjK9/9dnS4c/ZE6Ep29nOp5SDVaozY2EsUnPb7VVS0VxupxCIN5x7IgDg15v22+7GOBUynNmGx0JsYyh4s9HXw47YN49s5xdyuKt1yvZSFpClhiSzI+qUUAwopFQb+WKqaNlxrKgTaxEb+empbJclWW381jLbeSKXEwCArpnkHsxK2a7u3cRDfEUMKM0H00nZzvwud+GFF+K///u/sWPHDpx66qnYunUrnnrqKXzrW98CAOzZsweDg4O48sor1fd0dXXh/PPPx/r163HDDTdg/fr1SCQSOOecc9TXXHnllfD5fHjmmWfw1re+ddLnFgoFFAoasZVMkou8VCqhVGpPoUo/t12fXw/ZYhmfufclXHxyL951ztx2n05dPLWTZNVdsKDbMWMYD/txLF3ESDKHmR3mL5+p5saYQtJ2BkXHfPdGiChZJKm8PdfbWIbcnGMhPxfj0RUh3XbHUnnL50uLtJDP3FrS7nUoHvZjJFPESCqHUi9ble2I8gDmE4CgIHExN2JKcTmatj439BhLk7EQBCAoyE0du51zIxEJYChVwLFk1tJaWg/jWTIeHUEfF/OiHvpjZNPn0Gi26e9RqkgYVuZDXwcf9xBg8nwMJ8IY3zeO9HC6pd8hr7gCiOH2j12gi/z9M8MZW86FKrnFaPu/ayPUWqvC3WHkR/NID6eRODlh+TPSx5SoKgHwhZ2/bkR6I8gdzyE5mETilATz42dHyYZasDPo+LGYCH+c3FNkSUbqWEptTGgG7X5mavdne2gfyhUJmxRS0O8TUJZkvDqYwjkn9bT5zPgiSPSW5ul8GV1Rds24vDhITURM14DAEk62kQeAVYt6sXs4g/W7R3D16f22fQ516Yo4RL38phVz8NU/bceOo2k8f2AMZ53Y3bZzUTPLOblmmNvIq8p2Pr6/HnTtHMuxc4ZQbeQ5mQ8edAh3IZCyP5YDgJbN7XRleyhObOQTmrghP5ZXnenMgBLMPr8P/rBfsQrnhWyPA+mjVT8yS7YX00VApoelme0cjUU4AQCI95Hmi8ywDTbyhRQ/zQfBKOAPT6vMduZ3uX/8x39EMpnE4sWLIYoiKpUK/vVf/xU33XQTAGBwcBAAMGvWrKr3zZo1S/3d4OAgZs6cWX2ifj96enrU10zE1772NXzpS1+a9POHH34Y0aj5xY4F1q5d29bPn4iNQwIe3C3isZcHETryAhxSF0zCIy+IAAQERvdizZo97T4dAIBYIef08ONPYU+X9U7henNj4xEBgIjk8SGsWbPG8ufYjd3D5Hz3HjyCNWvYW5Y9o4xHipPxOHCMnO/O/dbHYzxD5tymDU9hvwWuul3rkFQg5//YU8/g2Ha23fWDWQDwIyzKeOCBB5ge2y6Usj4APjy5fhPSO9mNx1AOAPwI+WQ8+KCxsWjH3PCV6Vr6NPYyWEsnYst+Ms7HBg9hzZoDzI/fKhw6TtaSl/cfbXrtGy0AsuyHKMjY8MSjUNy2uQGdjxmJFCUbHtuAVyuvtuzzx4bGAACbt23Gq1LrPrcWyimyKVVMFXH//90PX4CtIdXIEbJpsmX7FuwO7GZ6bDugX6sKAik2n1r7FOKjccvHLhxWNjciPjxgcA1tBwqi8v0ffgqJVIL58cfWjwEAMuUMF89dE+EL+yDlJTx474MIzTa+EdfO2i2b9bLmpyO2H0kiVSgjFvZj5YndeHLHMF4+knQE2Z7hyC0o6PchHPAhX5KQzJfYku2qJbbzx0EPVdluk428E5XtAIkhvHPD/qp4BjuQpYSyQzbV4uEArl0+B7977iB+vfFAe8l2zq4Z2jjCylVEdSjkxEZfj4Tixucp2z0AIGR7ZX9rPqugNEA7PbM9HAeSR+Dz+xCMBVFMFZE7nrNGtutswgVB4CqXWw7FgZEdVT+jZLtRG3kqCPAFfBDp+lnMcDMWVNke6y4D8DHPbFdt5IN8RAwAIFbynrLdPO655x7cdddd+OUvf4nTTz8dW7Zswcc//nHMmTMH733ve1l/nIrPfvazuO2229T/TiaTmDdvHlavXo143PomnBmUSiWsXbsWV111FQIB53T8PvbbbQCOoCAJCC04C9css6/T1yyOpQsYXP8EBAH4yPVXoDvqDBvLnx18BkcPjGPpmWfjqqUzp35DHUw1N157bDewdzdOXTAPAwOnWznllsC//Sju2rUVkXg3BgbOZ378XX/eBex9DactPBEDA0uZH581unaP4Bc7NwPhGAYGLjJ9HFmW8clnHgEg45qrLjdlCd3udeg3w5uxb9cITjn9DAysPIHpsZ/fPwZs3YjeWBQDA5cwPbZduH9sC3Ylh7Bg8TIMnDeP2XFfPJQEtmxAoiOMgYHLmnpPO+fG/x7eiMF9Yzht+Upb7kHP/ukV4NB+LDttEQauPIX58VuFBUdS+J9X1yMjBzEw8Pqm3vP8/jHguY2Y3RXBdddeau8JMsTE+fjbO36LHdt2YPGCxTh74OyWncdOaScKKOCyqy7DrBWzpn6DjZAlGS+97yXIFRmXnXMZYiewLahe+7vXkEcel1x5CeacO4fpsVmi1lo19t0x7N29F8tOXoZlA8ssf8aRzUfwMl5GR08HBgYGLB/Pbvzmx7/Bzld2Ysn8JVg5sJL58V849gL2Yi9mnTiLi/GYiNdmvIbkgSTOP+N8Q3O73c9MgObO5mF6Yf1uQgiev6AHp/XH8OSOYWw/4oy5kHGYTfZUiIcDyJcKGM+VwO5JW7Nh54U4pKDnm2KubCfHizuYbAeAVwZTOJ4poqfDnv0kTdnunHG44bx5+N1zB/HHFw7jC29c2pY5K8uyp2znWNluT2Y7X/cSDxrkYByBUouaQakVeSNlu6IAb2sUWigOFEhjfqQnQsh2i/FmVTbhAF8EcziuuRLQH3WZU7ZTUjncFSZNBwBfYxHqAiCgo6sMIMgusz2lazLhyVYfAKI9nrLdCj796U/jH//xH3HDDTcAAJYvX459+/bha1/7Gt773veiv59sqh89ehSzZ89W33f06FGsWLECANDf34+hoaGq45bLZRw/flx9/0SEQiGEQpMX2kAg0Hai2wnnQCHLMjbsGVX/e82LQ3jTSpZlKBts2k8s5Jf0xzGzyzlWIV0K6Z8uSUz+pvXmRq4sK58XcszcaYSuKLmJZotsxmUiMkUyHokOPsZjZpx0M45mS5bOt1CuoKzkDXZ1hC0dq13rUEK5ZjJFmfnnZ9TrxDlr7FTQxoPttULXjHjE+Fi0Y250d5D7dcqmNSNbJJZNvKyh9TC/jxSZo9kSyrKvKYvK4QzZIOrvinD53el8pLnLpaS1ddQoSmmyqRTtjjpi/KK9UWSGMiiOFxE4ie350ILeKd91KujXqmiPMj9SbOZHWbluwl3W7rWtQscM8mxcGC3Ycr6VHNkQDcf5GI+JiPZGkTyQJNeNifNvZ+3G43h7sA6qvr1gYS/6lc3J7UdSjd7SEkiSrGWVc0KQxMJ+DKUKzAgzgNj850vk2ZKXcaDoZEwgUlD1b2fImWtWX2cIp8zsxM6hNDbuGcEbls2e+k0m4DRlOwCcM78bC2d04LXhDP649TBuPO/Elp9DtlgBjYzn5ZqJK8r2QllCsSwh6LfmKEXXzqiD5kazoHsWY1l2NvJpGj3ByXzwQPDcT55D+pfbseKcFjUAFhVlewMi0RHKdl1GeaQ7gvF948iPGiOVJ2JSE0GBI0I1FAfybDLbqRK+6u9bTPFjI+/zAeE4ooECgCBzZXso7gdKWX6aDwCS254bnfp1LgFbP0oQ6zufr/qwoihCkkhxsmDBAvT39+PRRx9Vf59MJvHMM89g1apVAIBVq1ZhbGwMmzdvVl/z5z//GZIk4fzz2atmpxNeO5bBYDKv2sr++dUhJBnZJLEE7e5ftai3zWdSjS7FTinJsMOzFlKcZcJ12pQFR5FUM+H4GI++TlKcHM8UIUnmLbKzSvcvAEQD/BVpACF/AbZd0RT0Oow7NCuwFuh4sF53k5ytGXZY0+nBq/poIuIRv7p5d2S8uU7pQSVznG7W8wqas2y0OLMCWZJRzJBNpWDMGY460RmEVM4eY6smkGVZ655vpyrAJMLdZH5bVRBQOGLTxgCoRWF2xB6ViSMUIxYQ6SXrR26Ezfzw4MFOlCsSNu0lG1AXLOzF0tnEle/VwSQqFuoIFsiWtFqEl2cqO561M7qajDdVJq2TWNrIy7LWhOHk+pyq2ze8Zp+aymmZ7QAgCAJuOJcIau7e1J44LWqh7hOAMOMYJLvQqZvLLKzkaSMGL2unHl027OHw5pLigSDYGUQ+F0TI36JnamojH6rvUOyIui2skctqXXrc2hhVfS9JAkoZfgjmoNJ8IGvPrSrZPm5O2R7q0pPtGX4aDwAg0o1wmHxvVsr2YlIRSnTSQHuObOSj08tGnvlTzxvf+Eb867/+K/70pz9h7969+P3vf49vfetbeOtb3wqAPPh9/OMfx1e/+lXcd9992LZtG2655RbMmTMHb3nLWwAAS5YswRve8AZ86EMfwsaNG/H000/jb/7mb3DDDTdgzhzn2lzygHW7jgEAzlvQg5NndqJYlvDwS0fbfFaTQbv7Vy2crmQ7X0RRp5KjYhfZTseDF1K1W7Gpk2RgzMJcodZrIb8PfpGPInUiumwil8kxnb/JMxF0DidzbK8VbcOLr2vEjiYMwPk5ks1CEATM7Sak2rZD4029Z1Ah5WdzTrbT4owVmdoMStkSoNQuwU6HkO2UVGVUpFFUChVIZdII65TGAiOgmxqsmjFoB32Yk+uGzovcMXuuD9qIwePcAKA6Y9jVjODBA0u8eDiJdKGMrkgAS2fHMb+3A5GAiHxJwp5jbNQwZsEjYaY9a7N7xkwpTZwhv8+y2rXVoPsJuVIF5YrE5JiFsoRShTwwOflZ+9wFPQCArQfHbPuMjEOtwt921lwERAFbD4zh5TZEUqj53EG/ZgPscIg+QW1yZuEEQcnlKCd7enp02ZrZ7pzGFA9TI9obRS4XRihQBCR79nurQK3I66h2K8UKKsq11dY6JRRXyeVIj9Lky8hGPhgLEqId4Ea9LIdjZH6UtDGgZLlZG/mqZooCP/n1AIBwAqEgGQtmynalGT7SqTSA8kS2R6aXjTzzSuF73/se3v72t+NjH/sYlixZgk996lP467/+a3zlK19RX/MP//AP+Nu//Vt8+MMfxrnnnot0Oo0HH3wQ4bC2wXXXXXdh8eLFuOKKKzAwMICLL74Y//3f/836dKcd1imK8YsW9eFNZ5LGhT9uPdzOU5qEI+M57DmWgU8AzlvY0+7TqQIt3u0iiCh46BTXg3anZgplyDJ7BQYlJnkZj4DoUwuU45mC6eOoOV8cFmgUdl4zfCrbyd+SdcOO2qDDyTWiFfDsrOn04G0NbYSrTye54b9uUplyROkcnhXngzSsB5VMtWjHZgTFtDIfBSAQdca6opLtjJXttFgDnNNYYARqpzyj+UE77qs66B0Mu+YFBZ0fvJLtnrLdA0+gTebnLeiBzydA9Ak4rZ9soLU7t10jR/ghzKiynaVtOm9W+nro60i9Qt8KaBO1IDiPZNbjBOVZYThlvh6fCrmiM63C+zpDuGqpsRqCJXhVMbOMXXBixECzsCez3T31+XRCpCeCfF6pj/IteCYppgBfAPDXrsn0NWzbM9ulMlDOM9u3qCKZi3yR7aoTQUGbI7ReL+fKqBSbf/6gdXlVEzxPme0AEEkgKJI6PTPM1kY+ElXuTzyNh6dst4ZYLIbvfOc72LdvH3K5HHbv3o2vfvWrCAa1zRpBEPDlL38Zg4ODyOfzeOSRR3DqqadWHaenpwe//OUvkUqlMD4+jp/+9Kfo7ORoIjkQkiRjvVLMX3hyH96okO1P7TqGkbR9BYhRUAv55Sd0OY5Es8NOqRZ4U2XSjYeyJKNQZtMxrwct6OnmCQ/oVZS7x9LmycQMxzlfFJobBPsuWB7nhV1Kf2oNGedkzaAFvG028qqtPj9zox7eee48CAJpltvbhMJtUClOZndF7D41W9EOG3mVYOwMOoZUsMtGnnbOB6IB+Dh0TlHnByOy3RF2hAZgN9nOc8QAAE1hYtHO0YOHVoDWvhfoHN2WziGblu1QpOqR4ZBkpvUzWxt5ZRw4ec7WI+j3IaSo8alC3yr0kXc+nzOel2qhr5Pcw46lC7YIAgBnq5ffdS7Jav/984eQL7FptGgWvKqYqUscCxt56noQdXBDSj0kIjSznf06ylsDxnRHpFcj2+X8mP0fWEgRu/A6tTit2QLRAHztdJoJK+RyPqnWpZZt5PXNzirZzomNfEgbD+1HWh1pxEq+Zl1eTPMzFgAQTsAPEolQTBVRZtDApY5LWFmXObPVR9bLbPfgQmw/ksRYtoSOoIgz5nZhQV8Hlp/QhYokY82Lg+0+PRXqhoPD8toBnSqVYad8LaRVsp0Pokjf0W6HlXxKJRL5GA8A6OnQctvNIutQWzoj0K4Z9qQqj/PCDmtLAEhxZiOvFvA2NS7xGDFQD3O7o7js1BkAmstddEtmO2vlcjOgynYnKb0pqcqqI5qCN3J5Iphnto/XyIZzMFpFtnvKdg8e7EWpIuHZvUTpoY9PW6Lktm8/7BxlOy+wI7JJTy7zCPo8zKpOV/cqHD4elGzPlySV+GSNXIkSqs4jlS8+uQ8nJCIYz5Xw0Eut3e/jsVEH0DfrMFC2c9pwAOga43PsXOh4dgiZzoj2RpHPk7qrMjpi/wcW0iT/uw4cU6PolNy0yZepsp3a6XNCqMo1lO0+0af+nYwIKGhdHozr/sa8ke2RBHylJHxKBBOLvRy1GT6srMs8KdsjPcS1omyPs6nT4JHt0wjrdpO89vMX9iKgqJhUK/ktzrGSp1b3Fy7qa/OZTEarlO28PYj6fIJaYGZsINtVBTNHxFmvQtaMWCDbVWU7hwUahaZst9FGPsLPvIiryna21wlvm4CqNZ1dynZFucPLeEyFGxRlym83H0CxgXuIJMk4mqTKds7JdsZkajOgZLuT1Lx2ZXNzbxPO2PmAt+aDVtnIO+laMAIvs90DL9h2aByZYgWJaACL+7XN5aWznaFsp6QqV2R7hNpA25E1zM846EGfh9OM6o8UJ8KAaFBEWNnotsvJ0clOdKJPwDvOmQsAuHtja63kM0U+rxlWynZJkrlWtncptXq+JDFxRShVJNUB0y31+XRBoCOAUoXUXcVjw/Z/YCHVMIvaMTVbWCOXWe1bVDmL8WYjH55MtgM6AYURsl35G0+ykecpozycgJAbRccM0iCQHbZek9JxCQapsp2j8YgqEdG56aFu98j2aYSnd1ESW+uav+7M2RAEYOPe4zg81n71x4HjWRway8HvE3DO/O52n84kxFtEtic5y18GdEU8Y7JdlmVNwcyRXXhPB3n4s1LYu0LZbpOSG9AIa66U7coGIOs1hG4I8KLkpk0YozZktpcqEvIlUszzMh5T4YolMzEjFsKxdBGPvHy07utGMkWUKjIEAZjBKUlG0Q4bebVT3kHKdlqgsVa2824Tztr5gHbQhzlpUqFkeyFZMJSB1yxUlwdemzE8ZbsHTkDz2s9X8topFvfHIAjAUKqAY22Me6OEmdMVzHpQsswOG3mexkEPNYeaUZ3OS90hCEKVlTxrVHQRek4lVN9xDomjWv9ac3FUrMBrZnuMUWZ7TkdQ80gux0J+iMo9icU+jl6Qw9ucmO4QBAGIkr350kgLyPZiuqGa2zFkOyU6WdrIJ/U28sSCnBuyvYaNPKDV7LTWbgaq4xz9G1fKQDnPnbId+TE1EjAzZP3+q84PvzKWvMwNgCjbgWmT2+6R7dMExbKETYpFnV4xPrsrgnNPIpP+Ty8cacu56UEt5M+cl3DkQ5idxCGFLMsqYe30AlYP1h3zFNliBRWJZKzxNB69DGzk6QaXEzvlm4WdbhCasp0fsl2v9GeZHcibG4ZmTcd2HIDqNYiX8ZgKAdGHdyrKlF9t3F/3dVTVPqMzpDrY8Ap9F7Qs2ZOzORFOJBjtUjDzrmxn7XxAc+R4sZEPJ8IQlE1QO9TbvDdjeMp2D7xgw2ukPtfntQOEjDipl2wqtlPdnlYJM35qEeqEZouNPEe1qB72KdudPx6UbB9OsW/wzRa18XRqvX5CIqLGUd3zbOvU7bzayMcZke10H0cQoLor8ARBENR9Cxaxb3SvIuT3cV+jTkcIHXHIMlAZa4WNfLKxst0p7ls22Mir9Vc8pCPbOSGYKfE7UdneZV7ZrtblvDUeACSjPJ9Ex0wyN6wKJ6SKhJLiChrwFwCfH/BzVKdTZXvWI9s9uAhbD44hW6ygpyNYZVEHAG9UrOTv29p+K/nN+4ilxAULe9p8JrXRChv5bLECyj3FQvyQiLQ5IlNkS7ZTVYLfJyAScGYRWwuqjXzaQmY7px3helAiPFOsoFypb39tBjzGC9CGnbIkV3W8WwUvdo4UiSi5PoplTYXOCrSYjwRE+F1UzFMr+b/sPIb9dQikI+PusJAHNLIdslZw2Q2VgHaQsp12Q7Mm23knU6mCoJgqQmoQrdAsHKOSaBKCT1DV23ZYyfPejKEq2y0qTDx4sBP6vPaJZDsALJlNavZ2ku0ZDu3Tae2RKng28hSdyp4CKwc6zYXP+XWHncr2nOIs4xMIiehU3HDuPADAbzYfZF6P10Pawfb6jUBr6bTF9UPdxwn6iTKYQ6hkO4PYN96EAR6qEentQD4fQiXZAqKskG5IqjqmZtMpuVk1gavfrcpGnhOy3SeSv1sdZbspsp3+jXmz1AeAcAKAjMQsJbPdorK9qGsYFIUcGQue7i0Rz0begwuxTrGQX7Wwt8qiDgAGlvVD9AnYdmgce1poLVULNN/6hES0redRDzS7qFBmk11UC5Q0E30CV12wVPFAFRCsoO+c56lQ6emgme3WbeR5K1L10BPhrHPKqWKFJ2V7NCjqLNlYKm74sHOk6AiKCIhkHMZybJUmvKuP6mFeTxSXnEKcae7eVFvdPjhOCrxZcf7Jdn/YD7/yN2yVlbyqbHcS2a5TtrN0geCdTNUr0Kkq3Qp4s5EHNPW2HVbp3Ddj9GjNGHbY7HvwwAIvHBxHtlhBdzSA02ZNVnHR3Pbth9tPtvNEkNihbOfdRp7WB6yU7Ty58M1QnnPsINv1mdxO3qe4fPEs9HUGMZwq4M+vDLXkM3lcOwDtGmelbOd5H0cj263X6jw2bnnQEOmJIJ8PQc62gCjjJbNd9AOBKFBIqXWHZRv5lO67FdLk+D6O1pBQvH5mu4F6nb5Wrct5U/kDxEYeQHwGaXCzmtlO570YFCFWsnzltQPKeAiejbwHd+Hp3ccAABeePLlrvrczhItPJhv4921pr7qddpA6tXDrDPrV5iGWOXB66MfAyUXbRKgd88wJVf6swgGti96KjTy1puO5KPGLPnQoRSbr+IUkZwQzQCzZ6CYgS4eMNEd2jgC1piObXyy65fXgaQPQKN59HlG33/PsQZRqKFMGk+5RtgPsrcKngpNt5KWSxFThr+bTO+i7GoEYENWmCBa57Y7ZuDEAuyIGAP6bMcKJMKA8Qnvqdg9OhZbXPrkZHgCWKGT7y0dSLT0vPXhUdMdtyGznXZXZqRKIbMaERxt5O8j2LCeEatDvw/VnkTiqX29qjZV8htN9DFaZ7bxm1uuhj32zCirI4XUNne6I9kaRz4eB3Lj9H1ZMNyQSHVXDKuQydVwr58ooW3CQqc5sz/BFLgNAOD5J2U4b5K0p2xWyPcSbsh2I95A9O6vK9qpGjGJj9wdHwicC4S7PRt6De5AtlvH8ftKBdpEur12PN6lW8oeY5+cagVrIOrRw8/kE23PbqfqXtwfRTkXZnmFkT0dBC504BzZ1eqjKdgs28m7oiAbsiV/IlyooKtbBvDViqLntDDcBUxyuG2oBz5hsV1X+HI1Fs7hy6Sz0dYZwLF3Aoy9PVqZQG/n+rkirT80W0MKVBZnaDNTi3UHK9kAkgEAHuVZYkqqOybuzAJbNGLxltgP2ke3lQhmSEu/B6/zwiT51/fBy2z04FZRsX7VocjM8ACydQ8j2XcNp2xzVpkKaw+dL1UY+X2a2r0Gfs3klzlQCkVGdnlKjvJxfg/UyqMnrgScXuncqVvKPvTqEQQaOQFMhzSnZHGPUrKM1Gzh/btRDgu7hsLCR5/Be4kFDuDuMfD4EodgCsp0XZTugksuheEht8rWyb1Gd2Z7ij1BtpGw3QraPT/gbF/hVtncmyPrJStlOXA9SfDUeUES6PWW7B/fg2b2jKFVkzOkKY35vbXv21afPQtDvw+7hTHu752mXtIMfwjTikC2pTMHrgygtpFhlwVHwqF4GtMJ+NFtERTK30aPP+uIZcRvIZXosQSCOEzxBHQ9GzQeSJCNd5CuzHdAV8Ixt5J3etGUFAdGHt59NlCm/2jjZSn7QRZntgLnizAqost1pBKNKqlos0vRwlCrAJNRmDIvzQ6pI6njwZCMf6bMns12fCeekxhOjUHPbbbDZ9+DBKoplCc/uJc3wtfLaAaA/HkYiGkBFkrFrKN3K01NBCSOe6lJaM1YkWSVDrSLD+bNlJ2Mbea6U7TE7le2ajbzTsWhGJ1bMS0CSgXWK66Wd0Gzk+SKbWSnb6T4OD3OjHhJRxYWOQa2u2cjzNR88EER6I8jlQvCVWsAV8JLZTk4CKCQh+AS1LrXiqFXVDF/M8Ee2h+uT7YWx5u/B6t+4a2JmO0fW6YqyPdpJ1k/Lyna960GBw0YMAIj2eMp2D+6BZiHfV9eWPBYO4PLTZgIA7tvaPit5HrJ24xGaA2eXjTyfSm61iGdNtuf46ZzXo1sh2yXZfM4V3eCKcNAt3whxG5TtKV1jTi3rTSeDtb1lplgGFe7wsOlFQZXto8yV7fxtDBvBDYoy5cmdwzhwvJpkozbybshsB9pgI+9AZTtgj4LZURsVJqE2Y1h0Pijq1G48jYddyna60eOP+OHz81sq0kx7T9nuwYl44eAYcqUKejqCOHVW7Q0zQRCwpL+9ue08qlMjARF+pTZg9ayd5j2znXFTPE+2+pqNvA3K9gJfLnQn9pD7IuvaqxZ4zejuVMl2Rsp2TuZGLbB0J0ypDUt87el5IIj0RlAohCDKNjf+yTJRdHNjIx9TyWWr+xayJFcr2wtp/tTLoVh9G/kmHVWksoSSco+aZCPPk7I9FAcEHyIRUldnhq2R7dWuBxzODQCI9AC50XafRUvA7w6Kh6axfjexqLuwjkUdxZtWECv5P2493DYr+VTB+epMOyyx9aAP9k5uOKgFqi5mbSOf5KhzXo+A6FPnitncdtotz3sHsBa9wG5uqE0YnFnIA1rDDgtLNkDb8AqIAkIcESN2ZbZrahv+5kYzOKmvAxed3AtZBu55VstdlGXZdcr2ltvIOzCzHQA6ZpDCkiWpqhZsDlPxGwGrZgxqVScGRfg5etawi2x3w9wAdMp2L7PdgwNBLeQvWNhTtxke0Kzktx9pD9nOozpVEASdixRbJTdvxCEF66b4JEfP2irZnrJR2c7JvKCNzuMmhQBGwGtmO923sK5sVxoxOPv+erCMfOPxXuJBQ6Qngnw+jACsEYZTopQFZIk7G3nA+r5FUbdnTDLb03yRywATG3n69yWH05Htgg8IcBSV6PMB4S6EQ+R7s1K2q40YPKn8KTxluwe3YDxbwrZDJFflopNr57VTXL54JjpDfhway+G5/a3vNimUtQxmJ3dJ25G3rAdPtmx62G0jzyOpqmbEmSTbM2q3PF9zYSLsaFChmzy8OR4A+jWEtZVjoOGGrdOgFvDMbeSVhiUH30es4sbzTgQA/HrTAZQr5L6ZzJfVTb9+l5DtoYTSCd0iG3mq6HWqst1qR7Qe6nd1WGOBEbBqxphkVccJ7Fa28zw3ALIxCHg28h6cifUq2d64GX7JbEK2v9xmsp03wizGSJ1Kodrpc1afU3SG2BCIFCmOYt5mKGR7qlBGvsQmVoAiqxwvGuCDQKQRXmM2iUb0yCiuGLzVY6xs5DNUNOEp2wHo7iWc72tNV1Ab+aBos1sUzebmhWzXkctq3WGyyZd+L5/fR5q/ixn+yHZd84H6I5Nkuz/ih0jvrdRSn6O9TgBAOIGgn1wzpUxJVeybQXXEQLrhNeJYRHq8zHYP7sD610Ygy8CiGR1T2sqGAyJWL50FAPjj1iOtOL0q0AdywNkP5ZTcY6VKnQiebNn0oJsPrJXtKY5J1V6FsBkxaVunKts5L0rU6AWWme2qsp2/sdGU/mzGg1fbdDWznfFamua0YckIVi/tR29HEEOpAv78yhAALa89EQ0gzMmm31RQs89aZSOfdqiN/Az2pKob1MtU2W61GYPa2jli08YAPGV7Y1Blu2cj78Fu5IoVQyReoVzB5n2ksX3VFGT70tmasr0dznNpTsl21pFNaU6ftSk6GTfF8yQOiEf8CIhkg95sA3w9aOplPp67u6L2uIrVQpozi30K6taQK1VQUhqazYDXRiU9WCrbNRt5fsdjOiPSHUE+H0IwmAfsfBYpKJnwjTLb9aRjuxGKq+ds1XFNb48vCIKibOeMUA111c9sH2/OXYbW5WG9eKTAocofACIJiFIKonIftCKcUDPb40E+IwYAomz3bOQ9uAHraV77osaqdoo3nkms5O9/4YiqlmsVaId0NChCdHAGs/028nw+iLIu4ikoIclDMT8RPYqy/XjGnG0dVVHwUsDXgz3KdoVs57AJI87YHYMndYkeiQ67beT5Gg8jCPp9ePvZcwEAv9q4H4CW197vkrx2QCtaC2PsrT9rgZLtjijedVBJ1WGGme0uUC/T4p2VjXyYM0cIT9neGDSz3VO2e7ATB45ncdl/PIbX/cfjODTW3Fx74eA48iUJfZ1BnDyz8WbZyTM7ERAFpPLlpo/PErw2gauNvoxs5HkdBwr6TJxmrWwPOb8OEwQBvR32WMmrNvKcEMqtVbbzec3o60cr14sbRBNq5BsDFzpe54MHgkgvsZH3ixVIBRubWIsK2d6ASHSUsl2n5FabwE06rk36Xm5RtneZU7ZX/X2L6YYNGI5FOAEhP6YJJyzs5VSNSzHF53hEuomNfJtiq1sJj2x3OZ5W8tovOrlx1zzFxaf0oTsawLF0ARtea629Ay8ECWuibCLSnCq5NRt5tvZsqrKdRxt5xbbObBd9tsB/kQawV3KTY/E7L+KMmw943QDUNnzYqkzUznkONgCt4F3nzgMAPL5jGIfGchgcJ5vwbslrB9iRqc1C7Sh3mrLdBlLVDeplq5saFI7atDEAT9neGGpmu0e2e7AJ+VIFH7lzM4ZSBQwm8/jYnZtRKE9dB61X6vPzF/ZOGf8T9Ptw8kyibNp+uPVW8rwSJDHVNt36s3ahXEGpQjYGeWuGp2DZFF+qSMiXiCjD6fs2FH1K89ixNGuynS9r7FZltkuSrJHNnK0dAdGHcIBsk1uxks9w5npQC3ZktvM2HzwQkMx2UhcUjh6174Oosn062shPVOzzqF4OxYFKAShr91pV2Z4sQGpC0Emb4CeT7Zw1HgBAJAHkRtExk5y7FWV7VX1e4NRGPtoDSCXy93Q5PLLdxRhK5rFrKA1BmDoPjiIg+nDN8tkAgPu2HrLz9CaBF8KINVE2EbyMw0TQ82VtI5/kVLUL6DLbTdrIq8p2Trrl68FOZTuP8yIeZqu20We28wSWBbweaU7dQYxi4YxOXLCwB7IM3LPpAI4olltuyWsH2GVyNwvVRt5hil47bOTdoF5W5wcrG3neMtsV5XYpU0KZkVoRcMfcAHTKdpObXh48NIIsy/j8H17ES4eT6OkIIhENYOvBcfzLfdunfO+GJvPaKZbMJhtqLx9JmT9hE9CTzLwRJFqElfW1Ua9u5YVUnQj6TJwulCFJ1hRF+vHg5Vm7T2mAZ0+2E0I5wkmtrtZeNivb6R4GwN+eFqDV1KmC+XFyg7KdNsan8mVULK4bvMbeeSAQgyIKEqm7CsND9n0QzWyvY58uy3KV3XrbEY4DpSxQKVvet1Btwun34pFgDpPoI7VpAtX1Nf3bNYLaTKGvy4sZPsnlSDeQG0PHDIVsH7JuIx+OCYSw5lLZ3kP+zbo/t90j212MdUrX/Olz4khEm78RvUmxkn/gxcGmuvNZQSNInE0Y2W0jT0lE3h5E7baR503pD+ht5I2T7RVJVlUDvG1wTYTmBsFubvA8LzwbeYKEYk3Hei2lGyO8jYcZ3HjeiQCAe549gEOK+rs/HmnnKTEFq0zuZqGSjE5VtjOykZclGaUMuU54Vi/TTnnLynZObeRDXSEISg4ty1xyR21iWQBVmHiZ7R7swK82HsBvNx+ETwC+d+NK/OcNKyEIJNrlnk0H6r6vOq+9p6nP0nLbx62fuAFkdG5lHZyQiRQsXbX02dNOjrprBP2+gp4INQNKmkUCIgIiH9uJGtnOOLOdM0JVtQW3ObOdrh2iT0DIz8cc0YPWkJaU7S4QTXTpHAStrqV0PHjb4/SgoSSSerRoK9neWNlezpchlckeqTOU7cp5FpLMMturbeQ5I5jpeOS151V/yA+/sqY2s6dT20aeQ0t9AAgngPyYqmxnYSMf6VSezXlzPQBI8wEA5Dyy3QPHeHoXyWu/qMm8dopzT+rBrHgIqXwZT+44Zsep1YRKkDj8AYw+dLJSpU4ELeh5I4o6FIss1mS7ZiPP13gAmo28mS76rG4jhOciDdBfM+wKe57jBdQNQEZke5qTCI6JoOqKUcZWhup4OPxewgJXn96P7mgAR8bzePDFQQCejbxZVEoVVJTNQceS7YyU7UXdZrMjNipMwuqmBoWqJIg76+8+FQRBsMVKfpKNIafwbOQ92IUtB8bwL/e9BAD49NWLcdHJfbjs1Bm47cpTAQCf/78Xse1gbWJ8y/4xFMoS+jpDWDSjuY0ySra3WtlO3crCAR/8nJCqFLEwu0ZfXl3n9Aj5fQgozVlWCESAT3cxSrYPM89sVxoPOKnVae2VzJcsK5UbgV4zHUFxyqgMJ0JVtjOwkedZNOEXfWo9bdUNgTZg8OKG4WEyygFCGJaO28gRFFOAzw/4a9cgqjJaAIIdDqjbQlTJnbRuI5/U1V+VErFj541g1o2HHmqDfBNkO3Wcq2qCL6T4GwtAsZEfV10KrSjb6dwPR5X7Eo/K9qinbPfAOWRZVpXtqxY1Z1FHIfoEXHcGUbfft/Uw83OrB14II2oBbZeyPcWpBTLNxiuWJRTLU2exNAta0POoYO61oGynnfK8doTroVo52mAjH+fsOgF07hiMVAVJTm3ZupQNn3xJQr7EzkVF3RTlcG4YRTgg4vqz5gLQsurdaiMvy/ZtCgJQld6A80hGaj2WH8ujwuBaocW8z++DyHGWJKuYgZpFPSewg2x3i7Kd2shnR7K2rx8epg9G0gV89M7NKFYkXH36LHzksoXq7259/cm4cslMFMsSPnLnZozWeP7f8BrZYLpgYU/TJNQShWzffzzLJIO8WfBMMms28gyU7Zw+Z+shCIJKIFptjOfxObtPaaIcMVGTN4KWS87HsxStQWUZtq4lWc5VzHFV2W5+jCi5zDPZDmjChjGLzfF0j5MXFwgPk1FWyL3y2Ih9H1JIEXV0necjtUG6MwjBCU4z1DY9n7RuI5/SNX/TTGveCGbdeFT9mJLt480r26ua4IsZPsnlcAIojKNjBvn+LJTt4YjyDMelrb5CtudG23seLQDfDI6Huth/PItDYzkERAHnLWjOok4PaiX/yPajVQpbO5HipKC3Q6Wrh6bK5Itc1heZrHLbi2VJtVLnkWy3YiOf0VkW8tgRroc+eoHVhrdqI8+jsl3ZAEwxyE0E9G4YfI1FLORX7ThZNi/xmmFvFjcoVvIUbiLbqXK5UqwwzaSuBVrg+gI+iA5TKIW7w4ByG2Ch0tVncvN8f9HHDFi5txSTE2z7OIKdZLvTmk6MgirbpZJU5ebgwYNZlCsS/vZXz+PIeB4L+zrwzXecWbWG+nwC/t87V2B+bxSHxnL4+19vmaQeXf8aUYQZaYbv7giqrjWvDLZO3c6zMtMOG3meyOVaoHssVpXtPD5nqzbyzJXtSmZ7gI+5ERB96jyw00o+zfHaAbC5VugeKm8RHBNB3RCsK9v52Ov1UB9yZwjlsggpbaMqtZBuaJ1e02K8nQhpGeVWHdeqlO00u543q/BQF/l3grKd5q83ZSNfK96tmOaTbI8kAACxXlILsMhsD4WVmpbH8Qh2AGLQU7Z74BdU1b5yXjeiJroHz5jbhfm9UeRKFTzyso2ZLDqkOVF0U3IvVSjbYr/Fq428X/SpCmxWVvL6bmKnz4ta6FW66I9ni4bnCm8ZcI1AN7zKkowcIwUzVXPz2IRBz1mWgTSDZiZeM9sFQUBC7ZZns+FTLEsoKM4a06WYP3lmZ1VTnZvI9mBnUM2ktqpengqUjHMiwegTfVr+NANS1S1kKu2SlyVZsxU0AdplTzcCeIKdNvK8K9sD0YDq3GDW0tGDBz2++fAOrNs9gmhQxI/ec3ZNsrErEsAPbz4b4YAPT+4Yxnce2aH+Ll+q4Ln9YwCACxYac55bolrJJ6d4JTvw0ghfC2q97tnIq6Dnb7VOT3HoLtZnIdqtEbSGFH4IVdoEb5U8bQSq6o5yes3EWCjblb0cM3uxTgIl26048pUrkroHxOOengcCfyyAfD4EOTNm34dQZXvdXzuVbK+2kTfTBF6V2V5USFneCNWplO1WMtt5azwAiLIdQKybPCtkhi2Q7XTuB5W1mMfxEASibvcy2z3wCprXbtRCnkIQBFxyCsl639GiDvoUJzm7XTolLWv7rYokc909TwuTDCM3BL09tugEmyCD6I6SjWpZNm69pSrbOSre6yEaFOFnrGDWlO38XSfhgIig0pjCUnHDG9kOaFbyVq3pKPQbiLxvihrBuxV1e0dQdPw91AgEQWhZbrtqne2wvHYKaiVvpUijcA2ZGtGRqRbmR80Oek5gq428Q6+FZiEIgmol7+W2e7CKB188gh8+sRsA8I23n4FTZtXfDF4yO45/f9sZAIDv/XkXHtl+FADJei+WJcyIhbCwz5g1KM1t3364dWQ7z8p2+kzMxEae43HQg+4tpJkp2/kZjz7leYc12U4JxChH6uUE49qrFjQVMz/jogeLzPYsh40YtZCIkGvHynyhjQcA/+MxnSF2isjnQ0B+zL4PKaYbkohV6m8noIaNvFSSUDLRnFIV46XayHNGqIoBwB8hTRM60P0cWnM3An1NNdme5s9SHwAi3QCAjjiZDyyU7UG/0rDA29ygiPZ4NvIe+IQkyVivKNsvOrnP9HF6OsjiNmrjg7gevFghB0SfWlCxzm3Xk9Q8FbAUdBPCahFPwWPnvB4B0acWtEat5N2kbBcEQVWYJHOsGjHo3HD2elEPemt9q+Bx04siwVhdQdeeaFDkskHHLK5Z3o8bzp2HT119Gte24LVgpBPaCqiy3akEI0tS1S3KdoBNbrvjLAkNwE5luyvmB3WEGGE3Ph6mH3YNpfGp37wAAPirixfgujPmTPmet6w8Ae+78CQAwCfu2YK9xzJqfb5qYa/he3U7lO082/5qNvIMlO2cCAKmQkxVtlt75qb1OU/zgirbR7MllCoSs+OqCm6O6nVVqWyjsl1tUOFoXPTQmnXMrR+SJCNb4m9u1EIXAxt5ei8JiAJCfo9s5xX+mB+5XBhC0cbnkKmU7U6r2fxhwBcACkkEOgLwKYIaM3Vp1XfjNbMdIA0IVmzk6ThQxzlZVuIFOBwLxUY+EiXfyWxme6VYQUV53gj4lYYFXsn2SI9nI+/BOciXKnjwxcGmHop3DKUwkikiEhCxYl7C9Gd2R9na+06FFCc28gDbAl4PWswHRR+XD6K0oGJlI0/H1+kNGI1Ac9uPGcwLpY0XPHXKNwJLcrlQriBfIhslPGa2A1oDCctNwM4Qf2ORUNwfrFjT6ZHk1FLfKkJ+Ef9+/Rl4/0UL2n0qzMGCTG0GKtnuULV3dAY7UtUtynagOrfdLNxgI587xk65XaWs4Bw0t91Ttnswi0yhjI/cuRnpQhnnLejBZ65Z3PR7/2lgCc6e341Unhzj8R3DAIxbyAPA0jmEbH9lMIUyQ7KwEdLKxh6Pim7qfMXChS7DseucHp2qNbZFZTsnAgk9uqNB0B5cow3wjZDjsF7XlMp22sjz26gD6JXt5sYoV6qAukjzOgYUCQZ7OG6J4pjuEGNE2e4r20y2NyARq6zWnQBBIM0BhSQEQaiykjeKqmZnXm3kATIe+fGqH3XMJET5oY2Hpnz7pIaKcgGQK0CwfhOGY6HYyEfC5DuVsiUUTTyD0LkBAKKQJ+4BIqfrabTbs5H34Bx86Y/b8ZE7N+Pybz6OezYdgNQg//npXaRr/twFPapVsRlQC+zWKdv56ZJmSRzqwVPDQS3Q86Zd3lahKts5tAqn6FXIdsPKdo43uGpBI5fZKbkBPtaLWlCV/gw2AZOuULaztZHndV54mAxKptptI68S0E5XtpvsiNbDTcp2FjEDjlNJGICnbG8MaiPvKds9mIEsy/iH376AXUNpzIqHcPu7z0JAbL62Dvp9+K+bzkJfZwivDKaw9cAYAHMxb/N7oogGRRTKEvaOWI8TaQY8W0FTsqxQlpAvWatLU26xkWeW2c5f3SH6BF0DPBsreVnmU71Mlcp27vHxHEEB6DPbzV0rVDQhCEA4wPeWO4vMdrdEcUx3+GN+5PMh+GUbn0GatJF3VENwOK5mlFvZt6iqRwuKsp3HXO7QZGX7me85E4JPwM4/7cThZw83fDttglfj3XhW+YdigCDCj7QafWdmL4fOjUA0AF+Z0/x6iki3p2z34AyMpAv43XMHyf/PFPEPv3sBb/3BOmxRCvaJWL+b5LVfZDKvnSLhKdvrooshUaYHbTjgqXjVo5ORPR2FplLlp3N+InqVOIaRjLHC3m3K9jjDBhVK2MdCfm6twjV3DBbNB/w0Kk2EtuHD1ka+k+M1w0M1Wm0j71SCkSWp6iZlOxMbeY4z26lymyWZ7CnbPXgg+MlTe/CnbUcQEAX8101nYYaJ+8OseBi3v3ul+rw6Kx7CSUoTiBH4fAIW9xNVz0stym3PcGwFHQv5QZ36rSq5eVfpUrDPbOfrWZtayRt1m6uHfElS1cs81etqo7ONe3w8u2IAmkjAbGOKKpoI+rmP9+piEPnmljV0uoMo28MI+Gwk2wspQtbW+7UTG6R15DKtS80o2ydltgs+YlPPG3TNBxS9p/Zi+U3LAQCP/8vjDd8+6W9c5LjxQBCAcBeE/Jiq7jeT217diNHY/cHxiPR4ynYPzsAvn9mPYlnCGXO78Plrl6Az5MfWA2N4y+1P4zO/faGqO7dckfDMa2TiXrjIfF47oCnbx1qc2c5DPjdVWrNWtifzfD+IqpntjJTt1GKbhzlRDz2KSnLEYGHvpsx2gK2Sm27y8GohD7BzxyiWJRTKiqU+Z5teAHsrw5TS6MPzmuGhGqpNuN028imHZ7YztJF3nAWfBVi1kS/ny6go91uebeRZKdtlWXZ844kRqGS7iU0vD9MbpYqEe58jdpdfuG4pzp7fY/pY5y/sxecGlgAA3nB6v2nyRcttT5k+FyNIcWyf7vMJaj1t1Uo+XeBPyV0LMWbKdj7FASrZnmKjbKeN8QAQCXBEtrcgsz1b5NcVA7BuI+8m0URXxPqecJrzPU4PBFTZHvTb+ExdSDckElX3LSfVsKE4IUAB1UbeUmZ7TMlsD8YAHpt1aijbAeDSL1wKQSTq9kZ28rQJXq3LqcqfV4I5kgByo+iYoZDtw8bJ9kmNGCEOLfUpoj1AdrTdZ2E7PLLd4SiWJfxiwz4AwAcvXoC/umQh/vypy/C2s04AAPz62QN4/Tcfxx1P70G5IuGFQ+NIFcroigTUbDez0GzkW6Ns5yl3mKVKVw/eH0RpQZVhlNmu2cg7f07UQ59JG3k6hlFOi9SJYBm94IZcbtqwk7SoLtFvmHVwOFe0DR9GNvKcr6EeJkPtELfZRt7xme0MbeQdacFnElZt5OlYAM5ttGgE1mR7KVuCrERVuWF+qNmJnrLdg0EERB9++9FV+OpbluE9F8y3fLwPXLwAT3769fjctUtNH4PW9i8faa2ynddnKtVFipGSm/cGaLX5wGKdTp+1Y5zNi75OtjbyOaVRLxIQ4ePIaS3BgDydCrzbhlu1kVdFE5x+fz1Ut1MGme1uGI/pDJrZHgrmUWa03zsJhVRDIrGYdGC9zspGXt9IUMzwaZsOkPEoTG4K7T2lF2fcfAaA+ur2ckHXBK8q2znOrweIbXpOU7ZbsZFXIwZ4JtsjPUBhHKjYtIY4BB7Z7nD8adthDKcKmBUP4ZplswEAM2NhfOudK/C7j67C6XPiSOXL+NIft+Pa7z6Fnz61BwBwwcIey/bKiQ7yYJUrVSxnnTUDnrrnVRt51mS72jnPJ7nMKguOgucsagqaD2fURt51ynbVNt363FAdDzhuwmBlI083vKJBEX4DOaJOAeu4khTnG8MeJoOSqYUxNpuj9aCS7Q4lXFmSqq7KbLfofEBz4YKxIHwcrqF0XpRzZZQYrKN0bgBAsMOZ14IReJntHqwgGvTj5gvmM7MBPrE3iqDf/DpDle3bW0y280qQ0PrR6rN2hqM9ikboVNW6091Gnq2ynbdm5y4G5OlU4H/tsHat0L0wNyjbWWS289645YFAjIrIF8IIhwvIjdhgJS/LQDHVVGa785TtE8h2g45asiRPUC9znMsd6ppkI09B1e27HtiFg88cnPR7qmoHdHsyPGe2A0A4AeTHVJdCyzbyxcbuD45HVHEKy7lb3c7frtI0gizLuOPpvQCAW1adNKk4P3t+D+77m4vxr29dhkQ0gFePpnD/C0cAABedbM1CHiDdyn6FsLc7t71QrqCoWCHz8BBGiTLWynZebdkoOpiT7dQSmq9iXo8epbA3aiPvKdvrww3zgpWtPu8q/0SUsY08pxuAHurDSoe4Eag55g4l26n1mJfZXg2rme2O3LQxgGBnEKKymct0bnQGIXCk1KsHL7Pdg5uwuD8GQQCGUwUMM7LCbgTe1YisnrXVZnhOx4Eipma2WxsPXvcr+mLmavJ6oI3xEc4IVZrZboU8nQqZAt+iAb2ApKK4/RhBlvPMej1UJ4RcCbJsfCwAbQ3lYZ/XQ30IPgEVP3kOyQ8Os/+AUhaQpcaZ7U60kQ9bt5Ev6lxQtVxuTsnlUKymjTwA9CzqwZm3nAkAeOJfnpj0e737ntoEzzvZHklUKdvN2Mir8z6mzA1eGzEAomwHPLLdQ/uwed8oXjg4jpDfhxvPO7Hma0SfgJvOn4/HPvk63HzBifAJQFD04bJTZ1j+fEEQ1E7GUZtz29O6rlEeHsJYEod68G6BTM+blY08VTDzTJyZtZF3nbJdtU1nQLbnaLwAv2PDyh2D9+I1wXgtVddQzjYAPdSHSqaazORuFqU0mYNOJaCpgjkznDG92UXhSmW7yflBO+jDXWFm59RKCIJgi+uBU68Do/CU7R7chGjQjwW9ZLOuFVbylDDjNXc5btEKmoI+W/JOnLHLbOfTea5XqcmHGSnbs5wSymqjs43Kdq1Rh8+1Qz+3zVwvqusBZ40YtUD3gyuSjEzRnNtp2kXNB9MeAUKEF4YG2R+7iWzuqlxzpyAUU5XcZpvA6fcSRAH+sF+xkeeUUNXZ6tfCJZ+7hKjbH9yFA+sPVP2uZhM87zbyE5Tt2SGLNvKuUbYfb+952AyPbHcwfvo0sYR/68oTVCvqeujuCOKrb1mOR267DL+/9ULM72XT9ZNQc9ttJtsL2gOpVfv7VkAlyiwW7xORKvBZvFIwJ9vz/JOqPZ3URt6gsr3oHvsxwFO2TwQrW33eldyajTyjzHaXqI88aKA28maVy83C6cp2WqBVChWUMtbWUTcp261mtlMb+VCXgzZtDIIl2V7VOe8CqMp2g3aOHjw4FdRKvjVkO99Z5cwim1xjI0+V7eZrD0mSkS7yOR5U2X6MmbKdjAN3ynZd7SWZUG03A7qPwWszeDggIqioKlMmhAJZ1aGQz++vRzggIqQ4rJqt190SxeEBQDQBACiOHGN/bJrz3SCP2pGOZKE4yaCGeRt5tRE+HiLRRTwTqqE4UMrUzeTuWdSDM99bW91O6/KqJvhCGhCDgJ/TfYtIAsiNW1O2U8V/POiOzHYAyHpku4c24OBoFg++SLrF3n/Rgqbft3BGJ06f08XsPLoZ5+nWQ4ozNWLcJmU7b+MwEbRb1aqCgIIeh2dSlTbKjGaLhmzI3GQ/BrDb8CLHcEFmOyOlf7rAp5UjBbWmyxS1KBEr4NXa0kN9tMpGnma2O5VkDEQDpNMd5oo0PdykbJ/uNvIAW7Ldrcr2/FgeUsX6PcaDh3Zj6ZzW5banOCdIWNjIy7LsmkZOSnymLDTFZ4plUHMd3urzGYwz23l1oaMN8JIMtXGCNXjPbAe0WtLMvlZGnRt8NWLUA50zZveENSc+d4zHdIbQ0Q0AKI/aYCNfpGR7fZJZT0o7BtRGXpZVG3mj+xaTmp2LGX5t08NKDEAdK3kAuPTzl8Ln92H3w7txYJ2mbq+tbOe48QAgyvbcqBoJaCazvWrvhvfxiCTIv56y3UM78L/r90GSgYtP7sNp/e3rWumKtEbZnuLMPp2VBfREpDlXqarKdkaFGx1fnomzHsUdQpaNXUduU7bTDS8WjRiasp3fecGq+YBXK0eKWNgPQTEzGctZv8/w3rDkYTJaZSOvkowOVbaztAt3lbLdYjMG7zbygKdsbwQ6PyDb747BG/793/8dgiDg4x//uPqz173udRAEoep/H/nIR6ret3//flx77bWIRqOYOXMmPv3pT6Nctoew8TAZS2aTfYFWKtt5qc8nwgpZRpErVUB7pXkmDgGdsr1QNh1HQ8cyIAqq2pUX9Clk+/EMG0U3r5nt4YCIcID87ezKbec95gywtn5k1X0cfr+/HtQNwazQKO2C5gsPBGKcqFIrSRuIMgPKdkfVsKE4yZovZizbyKskM8+53KGpyfbuBd04831E3f74Pz+u/pzW5VWOczxb6gNApBsoptDRR75TdtiijXwhze/cAAAxQOaIp2z30GpkCmX8auN+AMD7LzqprefSKmW72jHOCclsF9meoipVTh9EaRFPM/6sIqXayPMxL2rBL/rUAsVIbrvaLc/pXJgIljbybnA8YDUevDUqTYTPJ2hjweA+44bNHQ/VoDbhxVQREgP3g3qgyvaaZHshDVjMSWcBNevLIqnqSmW72cz2ZI2injNE+sgYMFG2p92lbBcDorpx5eW2a9i0aRN+9KMf4Ywzzpj0uw996EM4cuSI+r9vfOMb6u8qlQquvfZaFItFrFu3Dj//+c/xs5/9DF/84hdbefrTGktnEwe73cMZ5Ets6q1akCSZ+1qERWMrfa4UBP4boGMhMh6yrNWZRqGPrxIE50f/6dGrPN9VJJmJkCTLcS43dRazY4+vIsnIl8jzOq9rB6DtS5qxkad7YW6pR63OlzTn+xUeNPgThGyXUqPsD65mttcm22VZ1pqCnaRs15HLVm3k1fqLZ4JZVbanGr7s0s8Rdftrj7yG/U8R/qu+sp1TlT+gKrk7usg6mBnKGG54VMclFuRf2Q6QBgRP2e6h1bj3uYNI5ss4qTeK1582s63n0k0tsA3mTRsFb1bI1AJ6PFcy3RleC7w/iFIbNRbqZUmSuc+wp+hVrqMRAxlxVE3C+8YORVynpihbtHKlm2b0OuQRtIEkU6xYGg/eM9sBIEGt6Rg0YqRdsmZ40EDJdsBedXtdkrFcBL5/LnDvh9pOuKsKZhMd0RSyLLvCOp2Czo9KoYKSiTVEzWzneCyoVToLMtlNjRgUam77iJfbDgDpdBo33XQT/ud//gfd3d2Tfh+NRtHf36/+Lx6Pq797+OGHsX37dtx5551YsWIFrrnmGnzlK1/B7bffjmLR3lrRA8GseAjd0QAqkoydR9O2fY7epYzXulSLbDJfl+prc97I5YkIB3wQfeQ7pE1ayfMc1xTQNcCPMNjb0pTt/I2FmtvOwFVsIvRrRwfHtuEx3d6FUaj7OBx/fz26LM4XOid4vZd40BDu6UShEIScG2N/8KLyTFNHtVvKlAClFHdU3UbJ5XxStZHPj+UhG3BQmVSb80y2h5RY43xjB6bESQmseP8KAMDj//I4eUuturzIuZI7nAAARGNk/Szny2QuGwCtz8OdFQAy35ntABDtcb2y3bvbOQySJOOOdXsBkKx2n6+9RR19EB+1W9nOGclMlZhlpeufVdcu7+SyaiNvIQuOIs1xJtxE9HaEsHs4g5FM8xlxvObA1YPenSCVL6uNPGag2cjzOy/017iV8aCbXrysnbWQiAaBkSwTdYUbmg88VMPn9yEYC6KYKiI/llcJZ9ZQrdUnKtt3PwqkDgPbfgPMWAxc+ilbPr8ZsLALrxQqqkOAG9TLwVgQgihArsjIj+YRMOiEU9OujjPQeZE7Zp1MdlPEAEW0N4qxPWOesl3BrbfeimuvvRZXXnklvvrVr076/V133YU777wT/f39eOMb34gvfOELiEbJHFu/fj2WL1+OWbNmqa+/+uqr8dGPfhQvvfQSVq5cOel4hUIBhYL2/JtMks23UqmEUsne+rIR6Ge38xzMYkl/DOteO45tB0exeJY998SxDNnwFH0CfHIFpZJ9zjJ2IeIn+yjJXNHQ31k/N+g4dARFLufKRHSGRIznyhhN59ETMU4E8j4ePdEgxrIlDI5lsKDHWnxMSiEew37B1Fi0cw2iTfAjqTzzzx9LkzkSEAX4ZInLtQPQHAtGMwXDY5RW6vOwaG5uAM66R8XDylikjY8FoI1HSHTG9/FgHPTvFkwEkTseAnLjzP+WvuwofD4/yrII1Dh2eoSQ8YIoQBZl58wlMYoAgHLmOPx98wEAsiQjfTzddExZdozUKIGOAEqlEvzFFCR/GJJTvmMDTFqrxLA6HvIU57/qH1Zhy8+2YM+je7D7sd1qLFwgFlCPJ+ZTQCCKCgdjUROBTgQA+MpJ+CN+lHNljB0aQ/fCyQ3P9UCbEIIhUk+VxfCUY+tkiOFuIDNi6G/qlHtis5/P7+68S/HEzmG8NpxBLOTH9WfPbffpoDtKLYPsVSskOSPbIwERfp+AsiQjmS+xI9s5zxum550rVVCRZLV73gzoWARFH8IBvruCexQitVkbeVmWtcx2l3REB0QfokER2WIFyXzJGtmeU2zkOY4X0I/HeM78eLhBya2qKxjcZ3hr3PLQHMKJMIqpoulc7qkgy7KqbJ+k6N32G2Dm6cCSNwJ//goh3JdcZ8t5TAUWNvKUTAVM5tMX0sCeJ4HTriG+um2GIAgIJ8LIjeSQH8sjNsdYp7cllX+lDDz8OWKFdtln2jYeLDPbJ9kYugCqst2gpaMbcffdd+O5557Dpk2bav7+3e9+N+bPn485c+bghRdewGc+8xm8+uqruPfeewEAg4ODVUQ7APW/BwcHax7za1/7Gr70pS9N+vnDDz+skvjtxNq1a9t9CoYRzPkA+PDghm3oOLrVls84mgMAP4KChAceeMCWz7Abr44JAEQcGhrFmjVrDL9/7dq12DlOjoFS3tQxnAZREgEIePjPT2C+CWHUc8fIeBQz41yOh69Ivv8jT23E6CvW3IpeeY1ch4f37cGaNbtNH6cda1A+Sc796U3PQzjA1rVpMAsAfgQgcTlHKMaPkTF6duuL6D62zdB79x4i7931yktYc/xFS+fhhHvU8SPk+zz30qtYk37Z8PuPjZPrbuuzGzBi/O0eHISdB3diYT6EUnqI+fV98tHNOEUI1X3myB8khKMv4nPUc0mkeAyrAWx86lEMx4chBAXIRRkP3PsAQrOaqy+PbjoKABgaH8KaP/0Jbyqk8eKOvdh7nJ81lK5VPqmINwLYuvEvOLhr6mar7su7MfLQCP7w939A6AQyXvsH96vz64JDe1ARAtjE6f1EnR9/eRhCpwjkgEfuewQdpzZvjX/s0DEAwI6dz2ExgA3PvYSRnfZFSdmNs0ZziJQO42mTz+btRDbb3H6LtxvtMPz0qT0AgHedO88RZIGa2c44m3wieMtsFwSSMzySKWI8V8LsrgiT41KiiGaq8Qa9VVi6UFYdAMzADVbhFDQj7liTNvL5kqSq+t2ibAeIIwQll63ADcp2QBuPpIksOApNyc3vPEkwyq8vlCsoKpb8vDYseaiNSHcEyQNJ5EftsZEv58uQK2TRrSKgC2nglTXAZf8AXPRxYGg7cO+HgQ8+DPQvs+VcGoGSqpnhjOljUDI1EA3AJ5pIk3rwM8DzdwLX/wRY/nbT58ESlGw304xBle3NKg9UlAvAbz8AvPoAIFdILt3qr7aFcGdJtqtZiG6yke/xbOQB4MCBA/j7v/97rF27FuFw7fn+4Q9/WP3/y5cvx+zZs3HFFVdg9+7dWLRokanP/exnP4vbbrtN/e9kMol58+Zh9erVVRb1rUapVMLatWtx1VVXIRDg63my8PxhPH7vi8iFezEwcK4tn7H14Diw5Rl0d0YwMHCpLZ9hN+YdGsd/vfwM5EAYAwOXNf0+/dwI7hoFtm9Bf18CAwPn23i2rcF/vbYOx4+mccY55+OiRb2G3z++6QCw82WcNGcWBgYmO1k4HQ+ltmLXi0cx9+SlGLhwvqVjPX7vi8DRw1i+9DQMXLrA8PvbuQY9VXwJLxw/hLkLT8PA6xYyPfbWg+PA1meQ4HjtAIDn1ryCjcP7ccL8kzGw+hRD7/3fwxuBsTFccM5KXLOs39TnO+kete+J1/DYkV3onT0PAwOnG37/P21+FEAFV1/+OszvbX+TnQfjoPPxvNedh/w9IUSDZQwMDDD9DN/jW+DL9NQ97uFnD+MVvILO3k7mn20J+STw0m0474zFkJcOYFffLqQPp7FqxSr0r2zu+n983eM4giNYtHQRrlp9EYQtMk4/63wsXeag71kHk9YqWYa87aNYsXghzjhn6vMfXzaOHyz5AdLb0vCnyR7esnOW4byB8wAA4i/+C0ic6Ky/uREUUmR+LD8FL56YxJHhI1hx8gqcMtD8fWXP3+9BHnmce94S4Bng/EuvAGafaeNJ2wvfQ3+Bb//Thv6mTrknUoe2qeDtRjsIO4+m8Jedx+ATgPdeeFK7TweAYu8LYNRmZXuaQ0W3SrYzstgvVyTkSqQ7iVfiLOQXERAFlCoyMhbJdkoi8k6oAlpm+/EmbeT1WWcRzlX9esTDARwZz6vKdDMoVSTVYp/3RgwW45F2gW16QnVQsbaWpnSZnJ0ualLxoOVy25XZXtQ1QgU6dNfSqw8A5Ryw7HrA5wPe+kPgp1cDv7oR+NCfgc4ZtpxPPXTMIB3QVuzCLdmE799AiPb4XODBfwROvoKoutuMSHcEoxg11YyhZsMZsZEvZoC7bwL2rwdu/BUwth9Y8ylAloGr/7XlhLunbG8Mqmyf7jbymzdvxtDQEM466yz1Z5VKBU8++SS+//3vo1AoQBSrnznPP5+Qi7t27cKiRYvQ39+PjRs3Vr3m6FGixunvr72hGAqFEApNvr4CgUDbCQQnnYcRLJ9H1t1XBlPw++3JEi8ogpnOsJ+78aHo6STXfrpQMfUdAoEAcmXSiBcL8zdPaoHWC7mSbOr7ZEtkPOLRIJfjMTNO5sRormz5/AtKJI/VsWjHGtTTSdbklMlroxHcsHYAQFeEPAdlSsbHKFskc6OrI2x5DJxwj+ruJHVYMm/8upEkGRll74bFeHhoL2IzYkjnwwhG0uz/luUsEIrVPW4lS+ZRKBZy1jwSuwEI8JczQCCASHcE6cNplFKlps+TZniHu8IISKQW80e6ACd9zylQtVaF4xBLaYhNnH/foj6c9Vdn4dkfPIuxPWMAgGh3VDtWKQOEYvBxNBZV8HcDPj/8xRQ6ZpK9nMJowdAcpk580Si5BgId3VzNjUno7ANyo6afzdt5/Tf72SYkLR7sAs1qX720H/N6nNHx182IBJkKqrLdAWr+ZhFTiORk3no+OaCNAQBmtvTtAKvcdqps57XxQA+jNvJZpUqNBkX4LFjxOw1dDBTMVYQqx9cJoDULWFG20/fyfJ3QeWG1qUtvIe+m68YDEO4mmzx22chTsn2S2nvbb4B55wPdivop2AHc8CtCwN/zHqBsbyPiRLBUthtWLldKwP2fAE44myj7ywVg7T+bPg+WsDI/DNvI58aA/30rcHATcNNvgVOvBs77EDDwTWDD7cBDn4NqTdMi6Ml22eJnm54fDkZUUVFNd2X7FVdcgW3btmHLli3q/8455xzcdNNN2LJlyySiHQC2bNkCAJg9ezYAYNWqVdi2bRuGhobU16xduxbxeBxLly5tyffwACzoI5t1qXzZUsNmI9C6lOealD4bpwtllCvmcqNpPct7zUFBxyRlsk5P0bqD0/Hoo25zqeYa4Bsho9TrPDbGJxQi2Q73SjesHYDWmJIysdeXVYQTNPedd1AXOjN7wnoRCc/7FR4IIr0R5PMhBHzWa45JKKSAUP18E0vRX3bC5yPnXUgBIE3ggLH4KrX+ioeAIsmmR7CT7Xm2EqE4UGhOAQwAF3/2Yoi69bLqb1zMACGOx0IQgHACyI+pZHtmqPm9HFmW1bkfCCh7TzzPDQCI9ADZ4y3fM2klPLLdIRjLFnHvcwcBAO+/6KT2nowO3bosXUmy70KghRtvynbAuvUxBX2QD/l9CPr5vTRpYWW2iKdQrcI5zuWm6FW6x5u1kVfz2l2mzmVCLivXW2fID78ZC2QHgbo2WFlD0i7YBEwwiitxw1h4qA1atNplI6+qefUW8tnjwO5HgeXvqH5xYh7wrruAQ5uBP93W0iKBhYLZtLJ9ww+A4VeA674NdJ0AXPFF4LmfA/vWmz4XVlDnhwnnA0M28ulh4OfXAcOvArfcByy4RPudVcJdloGda8k4GwSdF5VipcqlwQwsOR84FGpm+zQn22OxGJYtW1b1v46ODvT29mLZsmXYvXs3vvKVr2Dz5s3Yu3cv7rvvPtxyyy249NJLccYZZwAAVq9ejaVLl+I973kPtm7dioceegif//znceutt9ZUr3uwB+GAqD47HU3Zc190A8msd31KmyWXXTAOenQqY5I2KRbg3VGL1uQjTTbAN0JOUevySCqrtZcNgho3rB2ArjHFxLVCldxu2cuh88XMngVtShF9AkIc73F6ICBkexihUEGtn5mhkGpIIlYR0k5DKEbs5KHFVxnZt1AbCWIuIdvDcbX5oBl0zevCyr/SommqHOcKab7HAgAiCSA3hugM48IJfdxhwK/MqQZNKVwg0g1UCkDJva5z3t3OIfjVxgPIlyScPieO8xb0tPt0VFB7X0k296DZLHjMHWZNtvOWW18PrJTtPM6Jeug1qmyn3dAhd3RDU8QZXDNuUHJT0DUkyUDpz/O6oRbwFjd83DQ3PFQjlCAFl9028lUE4/Y/EAJ06Vsmv+HE84E3/ifw/P8Cz/zQlnOqBVqgWSHbTSmXxw8Cj/87cN6HtXywcz4AnHAOcP/HW67wnwh1fphoxmhaJTF+CLjjGiB1FHj/GmDu2ZNfU0W4/1PzhPvRl4A73wbc9XZizz/4oqHvEIgG4Fea2axayVtStmdGgEe/DAzvsHQOrKEq2w0oTKYjgsEgHnnkEaxevRqLFy/GJz/5SVx//fX44x//qL5GFEXcf//9EEURq1atws0334xbbrkFX/7yl9t45tMTs2KkQWhw3F6yvYNjsijo96mqY7P7GJRc5pFQrQVap5tuPuC8Pu9TG+CtK9uzJTIWEQ7Vywm1Jmf//OaGtQPQK9uN16fZgrv2clQnBBO1uup0EBRtiTzx0FoEogEUyxFEInn2z9VNKtsd2RCsU3KbcVyjzc5E2a4QscEOtufYSoTiavNBs7jks5eo6nZauwEg48E72T5B2Z4dbr5ep/MeAuBHHhB8QCBiw0m2EFElhjB7vL3nYSP4fgJyCUoVCb9YvxcA8IGLFjjqISTo96EjKCJTrGA0W0RX1B5Ch0dFYlwpMq0QZXrwXrxSsLaRd0Vmu1LYN0u2Zwru6oamoH9LFuSyG+ZFXI2iMDcesizrmnT4nSualSEjG3mOx8JDbah2bDbZyKtqXr2yfdtvgYWvq5/LvuLdwNB2Qqr2nQKcfKUt56YHVTDnjucgVaRqy/smUVXMN4sHPkM2P17/Oe1nPpE0HPzoUmDdfwKXftrwubCC2fkhS7I2Ho0y24+/Bvz8zQBk4AMPAr2L6r/2vA8Ru7g/fZL899X/Vj/DPT0EPPavwHO/ALpPAt75C2DNp4ljwMB/GPou0b4okgeSyB7LontBt6H36mFa2X5sF/DLd5CxWvc94JJPAhd/AvC3X33iZbbXx+OPP67+/3nz5uGJJ56Y8j3z58/HmjVrbDwrD81gVlcYrx5N4WjSHrI9XeBXtatHLOxHrlTBeK6EeSben3HBc7Yeemt9M0hy3uTL0kaexr7xSCp32als51jxr4dZZbskyciW3LWXY0XZ7hZBkQcNFTGGcLiA4ZEsEicl2B24mCbuaXXgWBt5gCi58xPIdgPNCFWNBIWj5Ic8W6cbtJEHgPjcOK7/1fUY3DqI/pX95IeSRDLbeW48AFRle8cM4zby6tzoDEIopYFgrP7eAi+IKALj3HHiGulCeMp2B+DBFwdxZDyPvs4QrjtzdrtPZxKout1qnm4j8EgYsVe2u0OVqdrIW3RCoLZ9brCRp5nto9kiKk3EMbgt54uCxTWjNmFE+L5OAH3DjrlrJVeqqPOJ53WDlZUhj01bHpoDLVpts5FPT1Dzjh8E9j092UJ+Iq78EiHZf/MB4NhOW85ND2pLB9m8StewKmDHQ8Ar9wNv+DeykaBH/zLgwr8BnvgPYGS3qfNRu/ctwOz8KKQKgHJLrmsjf3Q78NNrAH9waqKd4ty/Aq79FrDhv4AHPztZ4V7KA3/5FvDds4CXfg+s/lfgY88AS98MrLgJeOHXQNEYMcwiYgAwqWzf+zTwkysBXwC4dSNw4d8CT/4H8MNLnBEz0OPZyHtwH2Yp16h9ZDuNbeK7FrHa2Oo6G3mLdXqKcxepPl20m9W84axqFc7fNWJnZrtmI8/fuOhhlmzPlSrqY59blO20OSNXqiCvNBI0i4zLVP4eACkQQyBQRm54nO2BCylC0tb9tZOV7TGVXDZjI187s51jgjlsXNkOAEvetgSv/9LrNQFqSdkn4LnxACDK9pw5ZXvV3Cik+R8LAIgqZLuLle0e2e4A3PH0HgDAzReciJDfeQ8hdmY6UdCH2M4QP8Rql8XifSK0MeCzeKVgrWyPcT4eANCtXEOy3FzTiqpsd8F310Pb8DI/N+j15iZlu9nmA7pmiD5BtcnkEbShy6qNvJtcDzxUI5xQyFS7beSpsv3F3wH+MLD42sZv9InA9T8BYv3AL98F5EZtOT8KMSCqxLJZUlXNp29mo6KYBdZ8Clj4euD0t9V+zWX/CMRmAfd/wnhO+fN3AV8/iSi7LcBsZjttPPAFfBBrbQIe2gz8bADomAG8/wGga27zBz/3g4Rwf+YHGuEuy8Qx4fvnEkX7ypuBv9sCrPoYIfMB4KxbgPw4sP3/DH0X1SrdIqFseCNr693AL94M9C8HPvgwMOM04IovAn/9JNl4uuMNZG7kxiydlxXQsfGU7R7chH6lQeho0rpCtxZoLcK7W5DVxlbPRr4aamMrp/NihtKkUqxIlupRAMgozfFcku26CC+rTQcTQecI7/sYVIltdK+PzgtBANf1uR6xkB+ij5BfRh0KUy5bQz0AQjgBACgOD7E98BTZ3I5WtuuU3GpdaiSznTqtuSWz3YSyvSZUS32OxwIgyva8LrPdhLJdbcTgfSyAamW7S+Hd8dqM5/eP4rn9YwiKPtx0/vx2n05NdLdC2c6hhXqcQd6yHq4j24vGul4nQiVVXaBs94s+dEcDGM2WMJIuql319eAp2+uDbpa5YV5YVtvo1gwnxY8YBc0NTBXKKFUkBExYYwOest3NMFO0GoFKQFOyfdtvgVOvnqzkroVwHLjxV8CPrwB+eQNwylUkS0sQyL8QJv/3/AuB2WeYOtdoXxT50TzpiF5i/P1VxfxU+Ms3SUb5e/5Q364sGAWu/TZw1/VEkX3mDVMfV6oAj34JePo/gWgf8NS3gRU3Az5z177ajGFU2T5OxiLcFZ68hg69TKzjZy4GbvoNEDFhzX7uB8m43f8JQqCP7AQObgJOGwDe83ug7+TJ7+lZQOILNv8MWHFj0x/FQtkuSzJKGXI/mnJ+yDLw+L8DT/w7aRq49ttawwAAzDqdkO+bfkL+1q+sAQa+ASx5U8ut76iNfDlXRilXQsAFzw8ePMyMK5nttinb3UGQWMldBjTijKc9ikagJHnaYu0R53Q8wgERnSE/0oUyRtIFtTY1ClmWkSvyaxVOyfZiRUKuVGH6HTIuqcfiusgFWZabrrX18QI81+d6CIKAeNiP0WwJY7mSev9pBm6ZDx50iCYAAKWRYbbHLaQaqnaLSZ3C12kIx0mUFqzZyIfiIWAkA4ghQOS4XjGpbJ+EggtU/gDZR9Ap2zPDmabvK+rciIWmvEa4QSgG+Py2C1XaCe+O5wCct6AHJ/ZE1U5bp4E+jI/apGwvlCsoViQAfHVJs7eRd0eeETMbeQ4bMBqhpyNIyPZMAUCs4WszHBfvjaCpSyyQ7aqynf+xsZphTzcOeS9e9Y0TyVwJvVM0o9RDystsdy1Um3C7le2xIDD8KjD4AnDZPzR/gN5FwDv/F/i/W4ENPwBkCYBM/pVR/d+VEhCIAn/3PNDRa/hco31RHN953H5l+/CrwNPfJdnbU1mnn3IlsOx6kl9/ymrNGqwWCmng3g8Brz5A8sznnU8aFXY8MLWTQB2omxoGM9sbKiR2riV/r/f8wVpRe84HyL/3fwKYtRy45T5g4WWN33P2+4DfvA8YeoWQ/U0g0qfkklsg2+l1AEwxP8oF4L6/Jc0VV/wzyWavtVngE4HzPwwsHiBZ9PfcApx2Lcmjr5XJKFWAzDEgfVT53xCw4BIgcaLp7wSQv6/P74NUlpAbySEwl+/nbA8eAKBfITuGbCLb3UKQWHXVSrukGZ4iZlHZrtnI87uO9nYGkS6UcSxdxMIZ5o5RrEgoK1FeUQ7tsSMBEUHRh2JFwli2xJhsp2Qzf+OiB53jskz2ZppdA3h2PGiERJTsZRl1O6Xj4ZY11APgi5E6rzw+wu6gsgwUU4SEqwNDDeOtRihOiFDo4quarEtlSa7eizjiAqtw3XhYghtU/gCxkc9rme2VQgXFVLGpxhF13rtJ2S4IRN2e9ch2DzZh5YnduOevV6FYltp9KnVBle1jNinb07rit4MjclG1kTdpSzcRvGegUdB8LlY28m6xhO7tCGH3cAbHM1NfR1mXZlt1MXCD0DLb+Z8XNHfe9AZgwR0NKaKPdMsn82WMZs2T7Vq+KN/j4WEyqHLZKJnaLFTr7M4gUbWHuoCTrzJ2kAWXAB9/YerXZY4B311JFMED/2H4XGmRZpVsb7hRIcvAnz4JJOYRIrUZXP014PZzgYe/ALzl9tqvGTsA/OpGYHQP8O5fE/cAAJh3AbDu+6bJdrM28vlx8vpQV42xSB0hhDCLzY5zPgAsuoLY0PuauK+fdi1R/D/3c+ANX2vqI1go2+l1IIgC/PXuK9njwN03EYv9t98BLKsTL6BH11zghl8CL99HSPfbzwdW3kQ2DNJDQGqQkOuZYaUxRYcTzgY++Ihp1wOAKLIiPRFkhjLIHc8hPrcJxwoPHhyOWcoGne3Kdo5q81qw2uibconCn6LTZA41QNTcbmiG7+sMYd9IFsfS5iMYcjoHvyiHVuGCIKArGsBwqoCxbAlzEhFmx3aLK0Y44IPfJ6AsyUjlS03Xl1llbvD+/SeC7uMY3RN2i3unBw1inDSLV5IMLaBLOVIDBBuQ7S61kS9miqQ5H7pcbt6V3GFlPCTJUg3nGrI9kgCKaQRCQKAjgFKmhMxwpjmyXT/vC+mGDSlcIdrjaht5L7PdIQj6nfun6FaV7faQ7WqOT1BUs4B4ACWBmSnbXfIg2sEos121qXMBqQqQLnoAGElPfR25Vtlu0TadvNc9udxW1xA3ZZSrue058/cZN2wAeqgNPZnKOlsS0CvbA8CLvwWWvBEING+RaAgdfcClnyL22sM7DL+dKpgzw81nfenRVCb3C/cAe/8CDHyz+XGIzQKu/BKw5U5gz18m//7AJuB/Lid26h98WCPaAeDCvwH2ryMErgmwsJGfhORhINZv6nxqont+c0Q7QOzYV7wb2PJLoNTcd2JBtusbMWra2o3sBn58JXDsVeB99zdHtFMIArD0zcCtG4Ez3gm8uoZY9fv8hFA/+/3Atf8PuOFXwF/9GfjES8At/0fmxNZfmv5OFB0zOxDti6Jkk0uXBw+tBlW2D6cKqEjs74sZlxBmmo28ubrULQp/CiuZ7fmSpubmWdnep9TkVsh2WqsH/T74TcZftRs0xmvMQu1VC265ZgRBMNWcQr+/+5TtdL4YVLa75F7iQUOgpw8AIGcYqlKpCrqRst3JZLvONt2ojTytv9Rm52KGf3I5FAMga2S5WdDMdt6V/uEE+Tc/rgonms1tp/M+GAu6R9kOEGv9rHvJdu+O52FKJNTMdns2qHi1T2dtI59yiUpVLUqsKttdovSn6OlQyPZmlO3TILPdSPaZHlSZ4oZ5YVXpn3aRbXoiGsD+4zBsTadH2iPbXQtatMoVYrPG2j6Oku090X0kb+3abzE9/iSc99eEbF/7BaLwNgDble25UeDhzwGnvxU4+QpjBz/rvcDWu4H7Pw58dB3gVz5j22+BP3wMmLMCeNddQOcE39bTBoDuBUTd/o47jH0mtPlRTBdRKVUgNqkya7hpkzpCzqldOOu9wLrvEjX4Ge+c8uUsle01GzH2bwB+dQPQMQP4q0dJtrwZRBLAdU1eX11zSTzBI/9CGmDCXeY+E8BHXviIa7JTPXgAgN7OEESfgIok41i6gFkGMnSbQdolhJnmImXtWdstz5axsHmyPaU4SAkCn2puij7FQetYyoqynX9ClZKn44z3+NyibAfI9TKWLakOlM1AtdF3wffXI2Fy38ItzRceNIR6u1FJ+oDcOLuDUlK2UWZ7s1Fo7UAoDlQKQLmg2sgXkgVIFQm+KRqy9JncgiC4g1ANKTVbIUkaEcxCVbZzrvSPJMi/uTFEZ0QxtncM2eHmanZ170ZVtnM+NyginrLdwzRHd4c9D+IUvObsUqIsV6owiQHgdRwmopORsj3pOmU7KeyPZ6Yu7GmRFnVZUUL/lqWKjHzJ3DXjJscD+h0KZQn5UmWKV0+GmxpSNGs68/eZlFrM8z83PFTDH/ZDVDY0jaqXmwEtYvrFvwAdM4EFlzL/jCoEwsBVXwJ2PAjsfszQW1VStckCbSKmVLY/+hWipr66OfvyKvh8wBu/A4zuA/7yLWId99i/Ab/7ICHvb7lvMtEOEMX3qluB7f8HjO03/LFU2Q4Ys5JvaCOfPALEZxs+F2boOxk46RJg88+bejlrZfsk/OmTQM8i4kpglmg3g6u+QlQNj/+7pcN4RLsHt0H0CZih1BZHbbCSp7UI73UpdX8y09gqSbKqYHYLcaZX+ht1CtLbQfs4ciOcCEq2DzfhNlcPWi45v/OiK6JERTISjlC4yUY9FqKufAaU7S4VTSTUaFFj80Wtzzm/l3jQEO3rQD4fglBkSLYrFuzcKtvpeRdShuvSqkxuQCHbOSeXKcGuqP1No6CQ7QHexyNB/s2NomOmOWU7IduT/DdiUETdrWz3yHYPU0JTtttlI89nzq7+gdGKLTaFa2zkg9bJ9ryugcENRCIA9HY0byPvVmW7PirCrCMEvdbcYJ0eC/lB9//N2Fu6RXUEAN1R6xs+no28eyEIgmbJZkNuezFdhCBI6Cs9SZS0zdp9W8HStwDzzgce/jwgNd9sY5VUreqOnoiDm4Fnfwpc/jnzRPPMJcBFfw889S3gV+8Cnvg6cMUXgbf+sLEl/Yp3k42KDT80/JE+0ad+HyNke91NG0kiyvbYHMPnwhRnvw/Y9xRwbOeUL7VV2S7LxEJ+2duI5Vsr0XUCiV145kfA0Cut/WwPHhwONbd9nD3Zrj1j8l2LxCxklGd0udxueNYGtO9RkYw3PrslvqpPaSgbsWAjTwnlCMe1umoLzlhQ4yYls5n1I0tt5F3w/fXoMhk74NnIuw+R3gjy+RB85RS7g1JStQGR6GiyXSWXxyEGRLWWasZKvsomHCBNxryrl0PKeBQsku3FDCHareS+OwG0fs6PaTbyTUYCTrKR531uUHjKdg/THd0muxibRZpT+3TRJ6jnzMJKnlqz8V7Adlqwp6OghKogAJ0cd4zrYcRG3q3KdkEQEA9bs3OkyhRqC8kzfD4BsZD5NUQjl/leMwC9laH5pq60soZ6nfPuhJrLbYBMbRbFVBHz5x9EoDICLH878+PXhCAAV/8bcPRFYMtdTb8tOsMaqaq3qpuENZ8E+pcB537I1LFVXPopYgG+9yngnf8LXPJJYCplcbADOPeDwHO/ILnuBmEmt51mtk9StmdHAKnUXmU7QKzTIz3A5p9N+VI92W5UrUhRV9meHgLKOSAx39RxLWPV35DM+wf+gRD/Hjx4AADVOv6oBTvsWpBl2TUECXWRMlN30Fo2IAoI+d2xbRYNilqjb8GgQtUljlp9HdYz293QGG9XZnvaRZnlmhOEARt5qux3wffXw6wLneqSwnnjlgcNkR5Ctvtli3nceqiZ7bUtx6WKhJIy91jHyTHBBHI50k2s5JupSyc1whdcYCPPStnuBpU/UG0jP5PU7M0q2yfZyAfruz9whWiPp2z3ML3RrZAgdinbeSXbAWvWdBPhlvxl2sVshWxXSUTOber06O2kyvapC3s3FPD1oM9tN4OkS1QVFJY2AV2k5NY2fBhktnO+MeyhNowUrUZRTBexfPkrKIVOAE44m/nx62LuOcDydwB//qq2yTAFbLORL6SBw88TYlO0eA0FIsB77ye57Uvf1Pz7zvswybtr0jpdDzPOB5RsD3dNUNynDpN/261s94eI4n/rr4By42eHaC+ZF3JFVr+XUdSdG2P7yL/dJ5k6rmX4Q8Ab/h3Y8wTJsPfgwQMAHdnOWNleKEsoS6SxhXuyPWydbO8I+V0TRSEIglarG1T7p1ziwkeV7ccs2Mi7SdnOMiqyXJFQUNwJeZ8nAFSRgCFle5E2G/D//fVQ54vBWt2LeXMfor1R5PNh+IUMJAZxqgCmzGynhCPg0Mx2Si4r9byRunRSI3wxwz/BzEzZ7hIldyAK+AJVyvZm93K0+SGSfRI3jAdABAX5cUMOjzzBI9s9TAlqI58tVlAos78QeC7crBKHevDcdKBHh5rZbn6u0OYFNyh2KeZ1k43w145lsHnfaMPXZlxQwNeDSi6buGbKFUm9TtyQ2Q5Ya9ihihTe1wwA6LLooCLLsquU/h4mw04b+XImg6VLdyI759qpFdisccU/k0Lj6f9s6uVW7MJlSUYpU0cVkDpC/u2aa/i4NdF1gvFs71g/aT545odAxdhaYKYZo64dYVIZi3Yr2wHgrPcSpf0r9zd8mT/sR6CDrH3ZEYsRAxPnxigl29ukbAeAU68GTrkaeOhzQNG8Vb4HD25Cv9IoxDqzXR8FxnMmNWCOLKNwkx22HjGTjfFuafKlme1slO38joXV2qsW9Ps/vDfqAHobeQPK9gLNrHfXPo7Z2AHNJcVd4zGdEemJIJcLIRwusKvLC0nA5wf8tSPHaM0mhkT4nbi2hKqV3JEeUpc2ZSM/KbM9xb+yPdgBCD42NvK8Nx4AZH8pkgByY2pmu1GyPRJVntl4nxsU0R4AsilHQx7gke0epkQ87Fdzlu2wktfIdv4IEpZke5LjpgM96PlnimVIkjm7TzUTziWEKgDM64ni+rPmQpaBz/zuhYaNKzTri+cCvh6sXDP6TSHeN3ooqB1+0sQmIM+NShNBle1mHVT0Kize3UE81IadNvJzel5GOFxAadFbmB97SiTmAatuBdZ9Dxg/OOXLaTd0KVtS7fSaRTHdQBWQPET+jbdZzb3qVnIuL/3B0NtoM4aR+ZFX1KCTbORTh8kGQcdMQ+dgC2acCpx4oWEreTOgmz2BzgnPXqN7Sfd5qM22dW/4GpA+Cjz9nfaehwcPDsFMpTFmkDnZrjT9BkR1D4BX6Jt8jUZspFX7Y3c9V6qRbwZrj2TeHc3wfZ2akISS5kbhCmW7DTbyaWU8g6IPQRdEL9C5buRacUsEx0R0RZTmDJOZ7W5bR6czfH4fSnIUkUihKTK5KVDr9DpN7yoh7UQLecCSjXzNzHbeCVVBIHWjVRt5N9mmhxNAfkyNBGzWRp7O/TAl29tdj7NCpIf861Iref6fgDzYDkEQLBMhjcBzzq4VokyPQrmComLBE+Ow6UAP+iAty0C2ZE7dnnRJJtxEfOG6JejrDGLXUBq3P7a77uvUrC8XdgBbUXInc1oGXEB0x+3LSvOBm5TcZq3pKOhYCAIQDbjvuvGgI1NtsJE/7aQXMDg4A+KcpcyP3RQu/gQpnB798pQvDcaC8AXI+meUVKXFmiAK8E+8v1I1d6zNau5ZpwOLLgfWf89QPjdtxjBjIz9J2Z4aBDpnWbfTZ4Wz3wfseRIYqf/cAFgn2+sq28f2ts9CXo/eRSTm4KnvkAYADx6mOaiyfSjJNrM9xXFtPhG07pBkrb5qFmmXkkT0+6QMKttTLlG2d4b8CClE8LGUub2trJrLze9YmFUqN4LbVMwxUzby/M+NWjAbO5B2kTjAg4aK0IlwOI/cCCuyPVU3rx1o4EbmFPiDRJWvkMtGHPkmZbYXM+6wCg91sbGRd4OyHVCU7aOqsj0z3CTZrsz9cFhZe91CtkcVsj3nke0epjG6aG57hr2yPa1mMPP3ANZlwRJbD73lFu8bG+GAD1QEkTGZ205JVbfkclMkokH8y5tOBwD84PFdeHWwdkavW7O+AE1hMp4zPjdoE4ab5oUlG3llPNxQvFrd8NGPhY9zFZaH2qAd4qxt5OVcEqcs2olt2xYj2NmmDLhQDLj888ALvwYObW74UkEQtKwvg6SqnkydlD+bOgxEukneerux6m+AI1uBvU81/RYzzRhq8Toxsz15uP1NB3osfRPphn/uFw1fxkrZPsn1YHRfey3k9bjkk0C0l9jJe/AwzUEz2+1Strvh+TIc8CEgkvudEStoQKfI5Lw2n4hOE2pdwD1NvoIgaFbyGXONKrRW51vZzt5GPu0yVTed60aENZmiJg5wE6j4Kpkvo9Kke6Usy6rbgRvuJx40SP44wuGC6eiqSZgim9vxZDtA6nkls92MjXwwFiT51aWsOwjmcNy6st1VZHs3sZFX9nEyQ5mmHJdU54Og0hzIu+sBRaSb/Osp2z1MZ3SrmU52KNv5fQBjZSNPi/9okH+7PkEQ1L+l0Sw4Cjoe1DnATbh2+WxcuWQWShUZn/ndC5OKlWJZQqlCfua2jmhA7wZhRtnuPscD1d7SxHjQ68sN46Fa05m8x6hjweF9xENzoMrlwhhbBV/5hfsQCFTw4ounTSYZW4mV7wFmnk5IxCkKL0qqNtsRTVGXTAWIsj3WZgt5ikWXk7FY//2m36La9TGxkT/iLLI9EAHOvAHYchdQrr9G2qZsH90HJBxCtoc6gdVfIRn2u//c7rPx4KGtoGT7eK6EvEk3sVpwkzpVEASNMDPY6MvzHkUjmM5sL7inDqNW8sdS5p4p3ZDLrTY6M7SRz7qoUQfQGm2MNOpk1bnhjjGg6NLFOzYrEsgWK2pJ47bxmO6Qg4Rsz5msOSah0DinnNYoba3Vp0IoDhRI/rSRJvBiUqdsLyq1vRsI1VCcTWa7G1T+wCQbeakkqUR6PciSrMYAqmS7W8Yj4inbDeGkk06CIAiT/nfrrbcCAPL5PG699Vb09vais7MT119/PY4ePVp1jP379+Paa69FNBrFzJkz8elPfxrlsjWbbg/W0E2V7TZktqtZ5RwWblZUqXq4KXsZ0L6H0Y55CjcqmCkEQcBX37IMsZAfWw6M4Wfr9lb9Xp8dx3O3fD1YaVCha0U84p55ETe5AQho64YbrhN6jzHSLa9HmuP7iIfmYMSOzQiEF3+LfftOQCrdNdlavZXwicDVXwX2rwdevq/hS82SqpNs6vRIHm5/XjuFIJDs9h0PAsM7mnqLFWX7pPFIHgHiDiLbAeCs9wKZYWDHA3Vfwopsr9rIqpSA5EFn2MhTLLsemH8R8MBnGjYfePDgdsTDfoSVWJGjDNXtqjrVJU2/1D3PaGOrazPbTZLtbrGRB6Ap29Pm7iE5xSqcZxc66lyZL0nMmnXcp2w3biPvVmW7X/Spa8dYk/s4tHFLENw3HtMekQR8PhmFkWNsjldINbTH5kLZrlNyG8ps1+fRF9Pkh24g21ko2wtpd4wFoNjIjyEQCaj7FoNbBhu+pZgpAsrWaMCvEPNuGQ9/kHwXT9neHDZt2oQjR46o/1u7di0A4B3veAcA4BOf+AT++Mc/4je/+Q2eeOIJHD58GG9729vU91cqFVx77bUoFotYt24dfv7zn+NnP/sZvvjFL7I+VQ8GkFCU7bZktnNMNHdZzBmmcJNCFdAKLLM28imOowWaQX9XGP84sBgA8M2HXsWB49rGOM0TDIo+BP3uMx+xlNmuNmG4Z150UaW/wfGoSLKaCecGgtlMt7weSZdYW3qoDyNFa9PIHIN48Em8+OJiBGPBydbqrcaiy4FTVgNrvwiU63c6045os5ntk5TLALGRdxLBvPztJDd9w+1NvdxoZnu5UEZFIVIm2cinHGYjDwCzlgLzzgc2/6zuS1jZyFfNj/GDgCw5x0YeILu213wdGNkFbPxRu8/Gg4e2QRAE9Cvq9qMMc9szLlN00yZd0zbyLhkHik4TBKL+9W7Yr9DIdpPKdhcQqrGQX3VUtLqXRUGvGZ7HRQ+655AqND8+bl03AK1eb9aJTnUHCfrbX2N5YApfJ7GALo2OsDmgK2zk4+Zs5PXfTVW2u8A6XTceplHMuIdcVpTtALD07UsBAJt/1Dg+kM4NQRQgykp975bMdoCo2z1le3OYMWMG+vv71f/df//9WLRoES677DKMj4/jJz/5Cb71rW/h8ssvx9lnn4077rgD69atw4YNGwAADz/8MLZv344777wTK1aswDXXXIOvfOUruP3221EseuqFdqE7auzBygg0opk/kqTLggW0HqqyncMxqAVaxJu1kdfswt0xHrVw47kn4rwFPciVKvin329T81pytHjn2JauESwp23M0XsA988KsjbzeNcINxbxf9Km2ls12y+vhVqtPDxoomWrEJnxKbP8D+Wf7Ke3La5+Iq74CjB0AnqlPIqqk6rBBsj3JiY08APhDwHkfBrbeDWSmVk0YbcYojGsb7FXjUcoBuVHnqPz1OPt9xDp9dG/NX9N5kTtmzv2hprKdfpaTlO0A0L8cOOeDwONfB1KNVQEePLgZduS2u1WdatZG3i3jQBEzYY2tf30sxH8d1qfc58yS7Zqynd96XRAEHXnKiGx3WT433Ysypmzn3/WgHrTogebmi1vXUA+AL0YsoCvjjIiyqZTtjaLQnIJQTLVNN+LIV1V/UXLaDVbhYc1W3zRcldmeAHJjAIBzP3YuAGD7b7cjfTRd9y16V0KhmAHEECDy/wymItrtWmW7rXe9YrGIO++8E7fddhsEQcDmzZtRKpVw5ZVXqq9ZvHgxTjzxRKxfvx4XXHAB1q9fj+XLl2PWrFnqa66++mp89KMfxUsvvYSVK1fW/KxCoYBCQXtYTibJIlcqlVAqsbc+bwb0c9v1+SwRV4i/45kC8+9DC7eIyN9YRQOkQ3MsWzR07hPnxniGbJB0BH3cjUEtRANkvoxnzc0X2tTRERRcMR718NU3LcF1t6/HX3Yewz2b9uFtK0/AeIasY9GAyOS7O20d6ghoHfRGz2lMGZvOIJuxcQLoGjJucA0ZzZAH95DfB0GuoGTC/s9pc6Mr4keqUMZwMou5XcYKqfEsmRtuWUOnI6aaj/5O8siaG80x+xuLB59DsWMxstkoeuYGnDF3uhfBd9Z74XvyGyif/g6go2/SS0LdpKs/PZQ2dM65MbJuBDomfNdKCf70UVQ6ZkJ2whhQrLgF/r/8P8ibfgzgjIbf1R9T5sdYc/MjPUIK22BnEBWpgoqkrKGjBxAAUI46bCwA4NRr4Q/FIW36GaTXf27Sr4MJsm6mh43NCwq6kSVGtHusMPIaRMGHcrQfcNp4XPIP8L/4O8gPfxGVNzXngDAVnHBfdMQ65IEbULL96Dh7st0NzkmAzlXLsI28e5Tceli1kXfDvGCnbOd7LBKRAI5niswENW4jV/U28rIsN6XOzqpjwG8jRj1Qsr1ZFzq33Us8aPAneoExQEqxItvTQJB3G/ku4NgQAIM28km9jTx5vyvU3KGYdRv5oots5MMJoJQBykX0r+jH3FVzcXD9QTz34+dw6ecurfmWqnlfSLmjCUMPFyvbbb3r/eEPf8DY2Bje9773AQAGBwcRDAaRSCSqXjdr1iwMDg6qr9ET7fT39Hf18LWvfQ1f+tKXJv384YcfRjQatfAtrINa6fOMg0cFACJe3XMQa9bsZ3ZcWQaSORGAgI3rnsROB987a2FPCgD8GBxJYs2aNYbfT+fGhkEyvpnRY6aO4zSkRn0AfHjmua0IHt5i+P37j5A5sXP7Nqw5+gLr03MUVs8RcP9+EV/6vxdR3LcVR3NkLkjFHNO54JR1aJ9yzQyNGr9mXthD5tXQoX1Ys2aPHafXcuxOAoAfR0bGDY3HoQx5X1CoWJ4nTpkbKJHr/pEn1+NIt7Hc9ucOkutmdOgI1qw5ZMvpeWgN6s3HwlFSbGRGMszWxvP2bEc5RTbOchLbNdcKgqWzsLr4v3jlN1/GazPfMOn3w0PDAIDXXnzN0DkfffYoAGBofKjqfeHiCK6GjE2vHMLQEWeMAcXyrgtxwjM/gu/0bzdcq/IHyGZGaijV1JhkdxFXADkkV72+N/0KLgbwxPM7kH45Y+3kbcDy2HmYs/EOPJxdDlmoLuNSu4gaYnjfsKm5nBoh73/m+Wfwwih59lpy+M+Y6+/G2occcp+YgPl9b8aKbXfgsfIKpMMnMDtuO++L2ay5GAAP0xP9XdRGnh3Z7jYbZLMRVhmXZrZTAjFt1EbeRc0H7DLb+SZUuwwqlaeC29YOqmyvSDJypcqUzRWSJCNbcrGyPUKaOpt1QqBrqFuaLzxoCPTMAMYAOTvK5oBuyGwPxVVle8csosZOHU7htUdfw8IrFtZ9mxrjVWUj7wJSVTceplAuApWiewjmCIleQH4M6JyJcz92Lg6uP4jNP9qMiz9zMXw1ImSrGzHG3DEv9Ij2AJnhdp+FLbD1rveTn/wE11xzDebMsd+K8bOf/Sxuu+029b+TySTmzZuH1atXIx6P2/75tVAqlbB27VpcddVVCAT4tnrwvXQUv35tK0KxHgwMnMfsuIVSBZUNjwIA3nTNVdzZhu8ezuA7Lz6Nsi+AgYGrm37fxLmx/4nXgD27cPJJczEwsMzGM24Nnsi/iBeOH8ZJJy/GwKULDL//9t3rgFQal114Hi5a1GvDGToHV1Uk7P7hM3h5MIUNhbl448p+YPsWzOztwsDABZaP77R1aM+xDL714tMowtg1AwCP/24bMHgEK5edhoGLjc8rJ2LH0RS++9J6lH1BDAy8vun3bdo7CrywCb3xDgwMXGzqs502N3499CwO7j6OU08/EwMrjD03bHtoB3BgL5aesgADbzjNpjP0YCemmo/5sTxe/uuXIRdlrL5iNfwMNm7En30Xo3I/AGDGCTMwMDBg+Zis4Dt6O5b2R7D4DZPPaXt6Ow799yHE/XFD5/z4hsdxBEewcMlCXK1bf4VDzwIvAedc/iZg1ulMzp8Zji+G/wfnY97xp3Hqjf9Wd61KD6bxyt++gkqmgjdc/Qb4xMZJWXsf34sd2IH4jOoxFF7KATuBS6+9wZmZaEdPRODHr8PAyX7Ip1X/7YfmDWH3F3ZDLIim5vK2wjYAwBUDVyBxUgIAIP7+XiC82FHXRhVKr4f8zTvxunmAdK71c3TCfZG6s3nw0AxmxsjGM1sbeYUgcQlZFDOZUe42lS5Fp2IDnzKsbFfivDjbr6mF3k5rNvJusQpP0Hg3VjbyKrnKdxMCRUdQhE8AJJmsH1P9vfPlCpRkQNeMgR5qc0aT8yVdoNETfF8nHiYjOGMG8BogWLUJpyg2Vu2qdtoxJ5PtMdUGvmteF5a/ezm2/XIb7nnbPXj/U+/HrOWzar6tKuYtr1iKu8E6PRwnynZZBppwBZmEoovGAiA28gCxku+ciaVvX4qHPvEQkgeS2PGnHVj85sWT3lLViDFFQwqXiPQAwzvafRa2wLa73r59+/DII4/g3nvvVX/W39+PYrGIsbGxKnX70aNH0d/fr75m48aNVcc6evSo+rt6CIVCCIUmL7yBQKDtJIITzsEq+mLEBmUsV2L6XcYLkvr/uzoiEH0mFuE2oidG1ATJfBmi6IfP4PnTuZEtk6fyrkiI+7kCAHGl6zVXlkx9H7q50dMZdsV4NEIgAHzj7Wfizbc/hT+9OAhRIQg6Q2zXDaesQ73KWpIulOET/Yau+ZSyXnR3uGde9CjjkcqX4ff7m7KnA4B8hawZ8Yj1v6tT5kZ3B7mHp4rG141sicyNuEvW0OmMevPR3+sHBAAyUElXEOmMWP+w7AhK8skAgHDcYetK93yIyYMQa5xTfDZpIs2P5A2dczlL7q2Rrkj1+7LEsi7QcyK5KTkJs06DdNoAFu19EAH/N+p+367ZXQh2BlFMFzH66ij6z6xfMwBAJUM2hCOJCWORGQKCnQh09jD7CkwxdyXQfwb8r94PLHtz1a/ovMiN5OAX/RAM3F8rpQoqdJO8p0Mbk/EDwIwl8DltXlAEAsAJZ0E8+AzECz/G8LDtuy86ah3y4HhQZftQ0hxpWAsZl9kgxyPmbOTV/GkXKLn16DShbC9VJOSVZ203KNtnUGV7avpmtgNAIqoolXOejXwtCIKAzpAfyXwZqXxJje2oB/r9BQGIBPieG7VAmzOanS9plzVfeNAQ6YujWAxAKDJoEJVldyjbKbms4E0/fROSB5PY9+Q+3HXNXfirDX+F+NxqIagsySimtVxuJNMABCDQXndmJgh1AXIFKGXNEeZuUvkDxEYeIMp2AP6wHys/uBJPf/1pPPtfz9Ym26ts5F1kqU8R6XatjXxj2YcF3HHHHZg5cyauvfZa9Wdnn302AoEAHn30UfVnr776Kvbv349Vq1YBAFatWoVt27ZhaGhIfc3atWsRj8exdOlSu07XwxTo7jDWxdgsaJHXGTJGujkFXcoDpywb7w7Xg3aKu6WYpw/UtLvZKJJ5alM3PTYcl8/twocuIdZC9209DID/Tvl6oBtegDbvm0XSRYoKCvpdyoo9XbNI5d1l0wfoCngT95m0i3IkPdSG4BMQTpBNrvwYIwVf5hgKZVK0BBWVk2OQOBEYqx3bE+0jBXj2mDG7aaoKCMYmfNfkYcAf1uzNHAZp+bsQKxwBUvXjpHx+H+ZfOh8AsOfRqWNG8kq+cahrwqZNahCIzTZ/sq3AnBXA8CuTfhztJfNClmTD10hRZ6VbpRoZ3Qt0zzdzlq3D/AuB/euhysk8eJhGoOQPS2W726yg48qzYTJnUNmeJ8/lblNlmsls17sCuGFeUBv5ZL6MQtn4fgVtxOCdROyyUHvVgtvWDkDbj2rGGSOrcwVptoGeJ3QZdELIuKz5woOGaG8U+XwIYiVl/WClHCBL/Ge2h+JEoS+RdcAf8uNdf3gX+pb0IXUohbuuuUutPymKmSKglC+hGCVUOwCfbVRd6xBWGgsKJueI28h2vbJdwdl/fTYgALsf3o2RnSOT3lLlelBMu8dSnyLaA2Q9sr1pSJKEO+64A+9973vh92s31q6uLnzwgx/EbbfdhsceewybN2/G+9//fqxatQoXXEDsklevXo2lS5fiPe95D7Zu3YqHHnoIn//853HrrbfWVK57aA261a7XEmSGm1m8E0Yhv4hwgFxGRnPg9KBEkVuKeWpPZ6SIp6hIsvq++DQizj5+5amY36t1MPJevNdDQPSpKgCjm14ptQnDPfMiGhTVRiMj4+HGsaD3mXETaylt3HDTeHiYDEq250Zz1g9WLgDFFHIFhWyfSEC3G5Rsr/HMpZLtI1nIUvPPZHUt+JKHCcHs0I1Bue8UAIBwfGfD1510+UkAgD1/nppsr7tpkzoMxB1OtvedBhzbCUhS1Y/FoKh+H7ONGGJQhEiVeoU0kB0Buk+yfMq24sQLgfRR4Phr7T4TDx5ajv64ltnOqkZ3mzqVkmVGle1uGwcKNbPdQJ1O9yoiARH+KWJaeEBXJAC/Un+NmMhtzyrK9gjnzfEJ1pntRXdFUADGYihoEwbvjgf1YHS+uG2P04OGSG8E+XwIQX8OJavrByVjGyjb6zaMOwmUXKb25wAi3RHc9MBN6OzvxNCLQ7jnbfegUtQavOj3EkQB/oifEMxusU0PKeORN+l+4DYb+QnKdgDoXtCNU689FQDw7A+fnfQWde+G2si7pfGAItIDlHOk4cZlsOVJ+ZFHHsH+/fvxgQ98YNLvvv3tb+O6667D9ddfj0svvRT9/f1VVvOiKOL++++HKIpYtWoVbr75Ztxyyy348pe/bMepemgStIuxIsmq6pgFUgX+Fd1UmWqGIKKgxa5biKJOhSg2Yk9HoX/PdFG2A0AkKOJrb1uu/rdble2A+WuGNrTo1fG8QxAErUvcwHikXOj+oBbwWeObXuoa6hXzrkakm1jH50cZKPgyxwAA2Twhrh2pbC9lanb7UrJdrhhTMFflfumROgLE55g/V7uROAkSRAgjuxq+bOEVxCFm3xP7UJnCKaQwrozFRGV78ggQc/BYAMCM00hhOn5g0q/Muh7QuVG1iTW2j/ybcLiyfd55AARg37p2n4kHDy3HDKV5qlCWLNWietBnKp7rcz00G3ljdalqI++yZ0tV2W5gPJIua2r1+QQ1t90o2V6uSCiWSbNblHOrcLXRmbGy3U2igbgRZTttNnDZmkHRpURFNluru7VhyQOpJfP5MEKhAnIjFokySqo2UO3yoWxXmgUmkMuJ+Qm8e827EewMYs+f9+C+D96nNkeq3ysWIm4YRRdZhdPxKFgk292i5g5EADEI5EarfnzOx84BAGy5YwtKE+7FVfPercp2wJXqdlvI9tWrV0OWZZx66qmTfhcOh3H77bfj+PHjyGQyuPfeeydlsc+fPx9r1qxBNpvF8PAwvvnNb1Yp5D20HuGAqOYOmSFC6iHNubId0BoRrCjbky6zQKYP1HSTwghoMR8O+BD08985bwQXLurDjeedCABVKne3IR5R7BxN28i74zqhUO0tDYxHmjYqcbx2ToRqZWhK2e6uNdRDbTC1kc8qZHvGwWQ7oBGeOugVzJnhTNOHrLIi04Mq250KMYBsaAYwsrvhy2adMQuR3giK6SIObzrc8LUNle2xxnnvbceM08i/x3ZM+pXViIFJFvKA823kIwlg1jJiJe/BwzRDOCCiW2lWPMoot91tVtD0OTtl4PmyIsFVGeV60GflYkVq2kLdjY5avR1Kbnva2HWT1TXzRTknlTWlMpv9PTfahneqyvap1w/6/d2ubG+2scsj290LQRBQkqKIRPLIHbdItlMytgHJzAfZ3kX+rUEuz145G+/47TsgiAJeuPMF/PnzfyYvndgIX0y7SMlNle3j5t5foMp2lxDMgqBklI9V/fjkq09GYkEC+dE8Xvz1i1W/q9q7KaQbRi1wiYhCtrswt316MVkeLIEW8qMMc9vdoOhWyXaDxKEebmg60KPDRBYchRtzuY3gq29Zhrs/fAHed+FJ7T4V22BGyS3p4wVcpGwHdIobE8p2NzUeJBR1hZl7jBuV/h4mI9zN0EZeUban0+SYk6zV2w2qJmaY297QRt7JynYAqdDsKZXtgk/AgtcvADC1lTzNzAt3hbUfyjLJbHf4WCA+FwhEa+e2s1S2j+4D/GGgc5b5c20V5l/oKds9TFuwzm1PF9xlBa3ZyDdfl+Z1HLTbiCL937VZdbsW1+Se5+w+5Vlo2CDZnlPUy6JPQJBzS33Wme1uJFeN2MhnXWijr4dRsj3jgr1eD/VRQifC4QKyI8ZqjkmgpGoDG3mVlHZava5HuLFt+slXn4w3/s8bAQBP/dtTePZHz062xy9mGo4DV6A28qaV7S7LbAeIlbzORh4g+xfnfJSo25/9r2or+SobeVcq27vJv56y3cN0hkaEsFO2u6FLOm6COJwIaqfvlgKWWjlnzJDtOf7nhBWIPgEXLOxFmHNbukagjRSGyOVCWY0udtvciJvIkky7UMmtFvAWbOTd0rDkoTYo2c7SRj49Top2xynbI92kuKxHts8wTqrWJFRl2fk28gDS4X4Ixxsr2wFgwRUK2f5oY7K9po18dgSoFJ2t8gcAnw/oOwUYfnXSr5gq28f2kaYPQTB/rq3C/FXA6B4SA+DBwzTDLF1uOwu4TtluwlGrQETtCPl9CHBOqE6E6BM0K/kma3U37NlMRJ/y3GdU2a5XLws83B8bgO7vsSLb3bZ2AHqyfeoxSrvQRl+PRESbL9QGuxHU8XBp88F0R8XXiXA4b91GforM9nKhjIrSBOhsZTu1TU/VfcnK96/EZf9yGQBgzcfWYNuvtpG30u9VcJGyvY6tftMopgFBBPwO/psbRSQxSdkOkHkhhkQcfvYwDm06pP68ytGhkHZPIwaFqmwfbfw6DuGuysGDrejuMJ+nWw9uIEjMqHQnIu2yArbDRBYchapsd5l62YMGM9cMJebDAR9CfncVsOp4GNjoSLpQyZ0waSMvy7IrXFKmPUb3oDc9WamrB3Mb+UAHckmyUTrJWr3dEARiJT+Vsn3YorI9NwqU844nmNOh2cD4fqDceFN8weWEbD+w7gBKDdaSmnaEScV63uGNBwCAvtNq2shH+iIAWCnb9zrfQp7ixAvJv/s9dbuH6YdZyjp2dNz6vbEiyciVaO6wO563aU1ZLEvIl5qzTaclrFufK+neSzNqXcAdboQTMaNTsZFPGdvbouplN1iFJxjsY+mRKbgvs9yIM0aWNmK46PvrQRvjy5KMTHHqtdSNTgceNMiBOBtle7Gxsr2oW6MdV6/r0aSS+7IvXoYVH1gBWZLx/I+fJ2+NudBG3icS23Mrme2hTj6avptFDWU7QPZ1lr1rGYBqdbu6X9EZBIopd6n8ASDcRRoqPBt5D9MZqrI9w85GXs3ZDfFLGKl5yznjxDJQTRTx3HSghxUbec8O2v2Im4hecHO8gKa4af56cWVmu86aTpKm7panyJUqqCivd9Mm4HSD77mfY+W+Hzd8TaSbEInMbOQ7elFMK/ZtTlO2A0RVXIds75hBCnHLynZOCOZ0eDYEWQKOv9bwdT2n9CA+N45KsYIDTx+o+zqqbK+ykU8pqmiHNx4AAGacSpTtE5RFbDPb9wHdJ1k6zZYhNgvoWQjs83LbPUw/9FNle8o62Z4pas+ibiFIOoN+da+2WXKZ2si7ZQwmotOANTZ5neLCx/GezUT0dZrMbHeRVTglT9OFMkoVydKximUJReUYnS4YG4o5CVJ7bDs0de5wRp0b/Ddi1EI4ICLoJxRCMwIsz0be3ZDDXYhECgwy21OKgjlc59dkjQ5EA/A52Wkm2EG+xxQZ5YIg4LofXodFVy/S3qrayKfdRaiG4w2V/g1RzLhrLIC6ynYAOOdjxEr+xbtfVBtY6NwPdwKQJfcp2wWBjIlnI+9hOoNmtrNVtlP7dH4fwKwq2wtlCaWKu4gi+j0yxUpTFlN6UAWzm7KoPVTDTPQCbWZxo+OBKVt9l7lhAJo1nSw3v/kHaA4aPgGIuDh+wfXoOhGR0ggg1VdKMLWRzx4Don0aAe1Isv1EYuVdA0YVzOVCGVKJbIJWEaqUYHY62R5SCPBjOxu+ThAEVd3+2qP1iXma2T5J2S74+Mgo7zuNdMZnhqt+HO0lZLtRS8dJjRiyrNnI84L5FwL7PbLdw/TDTJrZPm6MNKwF+kwVEAWE/O7YKvLpbNObbfQtVAg776amVj08G3mgT7nfjWSMku1kLCIuIFRj4YDaiGJV3a6PD3SLKwYAXLVkFgQB2LxvFEfGGz9b0bkRdVGzwUT0dpDrZl8TamY3Oh140CBEEwgGS8iPmCRTKQopQiLWUTDXdCNzIgSBfI8myGUxIOIdv3kH+lf0AwA6ZipqdrcRzKG4eRt5N1nqU4QTdS3TTzjvBMw+azbK+TK23LEFgDb3w1Hl/uymuUER6fFs5D1Mb3TTTCdGNlOAOwo3q5ntdAwEwR0d0oD2QF2RZORLxrqk6Xi4kVT1QGDGDUJTtrvjGtHDjNLfDWvnRAT9PlUJMJZrvqkrpXMG4T07cTpD7poLn1wB0kfrvoapjXxmBOjoU5XtVQS0U0Bt5Gs0rRm1ka+y4OucqGwXHE8wF/0xyOEuYKQx2Q5oue17/7y37mvUjZuuCY0HHTMBkYN1dcZi8u+E3HarynaVbM8MA6UsP8p2gFjJH33JlQW7Bw+NQJXtQyyU7TrbXzc9UxltbKXKdreS7bR+oMKHqeDG+KreDms28m7YtxF9gnptWM1tp64YIb8PfierTw2ivyuMc+eTXNk12wYbvlYjl93TbDARl54yAwDwh+cPTfFKzRGj08XjMZ3h6+gGAJRHLapSi42zqLkh2wFCLjdpmx6KhXDzQzfj9V99PS76h4vID4sZYp3uFoQs2si7jVyOdNe0kQeIYICq25/9wbOQJVmb+2Hl/uymuUER7fGU7R6mN1QbeYsP4nqk8xpJwivMEGV6qBbyQT98Pndsavz/9u47PI7yehvwM9tXZbXqsuXeuy03bLBNt8EGAjhUU5JfAqEkoSchIbQQIJDkoyYhIYEQWkJzKA7YQCgBG9wtF1zBTb1LK2nrfH/Mzqxk7ax2V9KWmee+Li7h3ZE9mj2amXfOe86b0aW6NNZW8vJx1FISkbqLpxuElpcXiGfCTmjtRG0dD/k6E8sDnzYNx4aeiM5hAAChOXzbdCDURr5fKttdtUBGQSjJmKqV7d52oL2+x1uxtpGXK5dNdhMMXasVWyqArCLAmOK/P4IAMW80ULev103lyvaKDRWqEzNU28g70qCFPADkjQQMJqD2q24vx5tsl+NDmXTSGOyokC5rtgPA8PkARODQF8neE6KEKlYq2/t+bVTW2NVAIrEr+V471jby6fyMIhKlsj3GNduzNDQ+72sbeS1UtgOhVvLNMUx0DkfLVczLpkn3hu9sq4i4nUsHa5QvnzUEALCqvBIdEdZtF8XQuu7pvGQoqTPm5AMAfC11ffuL5Mp2FT0mBKcyW2yV3JlFmVj0i0VwjnBKL7hbtVXNbXP02lZflZbWr5dFaCMPAFMvmQprjhWNBxqxf/X+0DJv1uD1WWuTD4BgZTuT7aRjA9FGvlUDA7e+tpFXZnym8TE4Vtd2fa5Yk+1KG3nelGtVXGu2y3GhwY4HsVb6i6LYZaa4ds4bQOh8GksHFS1W+etSjvTwBs3q62xnlUgDjOZDzTEvUdJDe123yvaUHMAHJyCEayUvJ1Vdta6o/iplsHZsVUBrRcq3kFfkj4mqst0xxIH8cfkQAyIOftLz2IkBMZRc7tZGvhLITpNjYTQDeaOBuj3dXu63ynY55tKpjXzuSCCrBDj0ebL3hCihinNCSUNfH9ddlhNmWru/lO8Rox17KMl2jd5byp9va9Rt5LU3GV5uI9/Q7onp90ZuFa6V6mWnvX8q25WJOho5Ll2dOaUEggBsOtSEo03qreS11PVAzZwRuRiWlwGXx4/3dqhX+rt9AfgD0lhNizFBgCm3AAAgtjX17S9yR65g1mple1habCMfd2W7S3trlNucgK8D8IWf5GfOMGPGd2cAAL547At4g9dliyWYg9Pa8QBY2U6Uq1S29+Oa7RqoSOxrsl0L1f3hyDfVsVa2K23kNTSYp+7i+Z1hG/kQty8Ar18avGrpoRcQqq6IZVKX3AJTa+dQ3bFkwW3MgtCknmwvmFAAwSigo6EDbZVtffv3XPUI2PLgDz4YS9nKdkBqJX+MWJOqyoOKY9vlp1GCWcwbI63ZHsVEC7mVfLh12z1tHiD4V/RoI58ule0AUDhOtY18R2MHAr7okwfKZAylsv1raaa5zdE/+5oIgiCt236Q67aTvuRnWmE0CAiIQF1b38bpWk2YhdrIs7IdCE0iiLayXYvj87wMCwRBuqVoiGHcoVS2m7VxLHLi6CoWjkujXTEAoMhhw5wRUiv5/5RXqm7nUtZs19b5sytBEHD+zFIAwGubjqhu17WLiBZjggBLgbSkQKRK3ai4WzTURj66NdvD8rmBgFdbyfYYK/278bi0WdkORPydmX2N1Ep+339C3fzMJi1Xtueysp30TU6CNLr6cc12DSRJYh28H6vVrc2qTLl9Vrxt5LVYwUySeH5n5G21GBfK8Ygy2S4PXgVBe4PXULI99sp2rVYf6UmHpSBiG3mTzYT8cVLLuupt6mu798rnAdzN8BmcykspmWy35wKW7PDJ9sIYk+3BSu4eFfxplGAW88dI65yFaat/LLmV/NcffN3jvc5gq2WDyQBT1/NGSwWQXdIv+5oQBeN7VLbb86SlFiBKCfdo9YiPxoPp1UJeNvx4oGIT4Imtsp8onRkNAoqCE2WqW/rWSl6rbZAd9mAld9SV7dLSbun8jCKS7BjH6aHKdu2Mw0xGA/KCieZY1m1v19iEFGccXcXCkc8dWv2dOSvYSv7tberJ9nYNt9LvavlMqRvZ//bVobI5/L1maPKFUTNLZVJ31sJi6X/ccbYJl3naIq5F3WOpq1TW1+QyoK0Es9UR/+QDrbXUB6TKdkB13XYAKBhfgFGnjVL+bLQaYfQHY4NrtqcNJtsparnKrNeBqGxP3xvSnAw5ceiNq61tKFGkncErEBrEx9pGPjRzXlvHg0Li+Z0JVbZrLy6USv8oE8zKuokWk+YGrzn22KsrWjXQIYUk7dZCoFm9SgIAiqdJA/vq8j4k24PJWq+QAyA4iDGn4ENTQZCq2yNUtntaPfBFcZ3tUbksazkKZKdRsh2Qqtt7MeLkEYAA1O6oRVt19y4ISoVEjhWCEDyHejulWdVpUuUPACgcL02W6LIWnsFkgC1XWr85llbyPeKj6WB6tZCXDZsPBHzA0Q3J3hOihCqS123vY7K9TaOTwGOd2OpmZXs3rRrtxCev217vin7dds2u2d7HZ3xtGp2oIzsj2Ep+y+EmHG4If3+lh8p2ABial4G5I/MgisAbm4+G3Ubr8UCArTgfgYAAg7+lb8u7uVulyeVqbwfHbRZHCk6MP5bVEf/kA09wvKqlhKqtj23ktVbJrVS2N0bcbPZ1s5X/tzqsoQkLZo1NPgCkTnqdTUCgb8tgpRom2ylq8o24y+OHJ4bWlGpEUQwljdL4JkxOlHn8AbjjOC5t8kzxND4G4fS1sl1rD3koRG5BGMvvTGjNdu3FhVJt4/YhEOh9oKLFdRNlSmV7Ryxt5NP/OkKS9l4q2wGgaGoRAKBmW038/5CrFgDgDkgD+5SsapepJNttOTYIRilRHE1SNWxlu7dDGuw5SvtnXwda7kgAQlTrtmfkZ6BkhlSl/vWH3avb3c3SsbDl2EIvtgYrldKkyh+AlGwHgNq+r9ves7L9GyB3RF/3MPGKJgG2HLaSJ90pCbZXremnZLvWOifJY4+Y28hr8F4bALKs0v12tGu2a6FAIpz84P1fXVv0yXaXxtblZmV7dIqybThuZLCV/Pbw1e3Kmu0aPQZdfTtY3f7axiNhE63K+Fxj5wwKySjIgtttgc3SqYyt4uJu004beVtfKrmDyXYtJZitOX2o9G/T1rEApK6FQK9LL4w/ezwcQ6Sl3KzZ1tCxMGgwhZuRB4iBvnfISDEa/KRooDhsZshFlP1R3a6VdYczLUYYgwcmnnXbWzU6eI032a5UtmuwXThJsqwm5VwS7e+Mlivb5Z9JFKOruGnTcNt0Z4xV/oB2q7D0qN2SL1W2R5jZqlS296WNfHsdAMDt6zKISVW5w8Mm2wWDEFNSNWxle7olmM12wDk0qsp2oEsr+WOT7eEe2sjHIp0q2/PHAhCAuvDrtsdd2e73As1H07ONvMEgVbcf+jzZe0KUUMX9VNmu3TbysVW2y8l2rR0HWXYMle2BgIg2jza7SMmV7bG0ke/QWPVyv63ZriSatXFcwlk2TbpHfKe8Kuz7Wp2sFM6ZU0tgMxuwv9aFrUd6Jkm0PvmCpOXdOt122GxudDREv3RVD+7WiNXcqt3ZUpE1ux/ayGsowWzNBvxuaT36WHlc2qryB6JqIw9Inepm/WAWAKkTH9wanHggkycgaKyVPJPtFDWDQVCquBv7eDMOhJKqQHrfkAqCoMyWjyfZrtWqzHjayIuiqFQwM3GmXYIghB56RZts1/Ca7TazEUNypXV2txxu6nX7Fg23TVeWK4nhXNqq0e4getRuKYTg9wAu9ar14qlSsr12Vy38Xn98/5BLaiPf6ZUGLWlR2R6makRJqtbGWdneUiF9TbcEc/2+qDYdeWr4ddvlNdutOV0e2sjHIl0mHgCAJUOafFAbPtneUR/nmu3NRwDRn55t5AEp2X74S2nSAJFOyMn26pY+VJdBuwkSeVzZGmXbdHdwzXat3lvKE3Zb3VFM8vX4lFsQrY3PlWR7HJXtGWn8/Kqr/q5s1+oEFQA4Y3IJDAKwVaWVfLtyDLQ74UCWbTNjyWSpg9RrG3suAaaniQd65vFJyfb2+ugn+Pb8S1q1U9luDbZNj6etvidYEa+ldcptUmFDzBMQRDFYza2hYwEAZhtgsvVa2Q4Ac384F1MumYITfnqCdCy0NvFAZpc6xvTWWj/dMNlOMZETIY39UNneNcmc7usO58SYOOyqVaMtlpTK9igfagBAh9cPX7CNthYrmClEWac85sp2bf2eyBaMKQAAfLavrtdt5eSy1h6EAkCO3EY+hmtMq4Yr/fWm3SL9HoSr5JblDM+BJduCgDeA+t31cf5DdYDJDne79DCsWwI61TiHAd52ZZ35rjILpQFoLJXt3ZPtaVbZDgAFY6OubB++cDgMJgOavm5C49ehAZxqG3lzpvSQJJ0UjAfqjmkjnx9bZbsoit2rRpoOSm+kYxt5ABh+vPQ7U7kt2XtClDChZHtf28hrsw2ysmZ7lOMOrbeRH+KUJvnuqWrrtZuUfJ9tMRpgM2sriVgQvCeqjSHZ3qEk27VxLPprzXatTtTpqjDbinmj8gEAq8q7t5IPBES0e7U1EaM3y4Ot5N/cWgG3r/sEaLaR1wdvIFOqbI9hgm83ohhcs109kZhWyXZbDhDwSUu1xUqTle3BcXWs67Z7O6TW4lo6FjKbs9fKdmkzG5a/uBxTLprS6+9IWssIJttZ2U565owjEaJGaYWsgRtyR4yJw65aNVqlGmojH33loXwsjAZBMwNYCk956BVlO0et/p7ITggm2/+3r/fkoZbbpsdTXaHV7iB61BFFsl0QhFAr+fI4W8m76oDMAnjaggnoVK9sB0IJ0C4yCqWkavPh3te4kiuXu7dOr5AGwRGqCVJO/hig8euoqpYtWRaUHietR9+1lXzYhzYtldKkAyHNJn8Wju9R2W4vkJIo0Sbb/W4/Aj5p6QZLtgVoPAhAAHKG9uuuJsygGYDJzlbypCsl/ZRsDyXMtDUOYxv57sYWZ2NCSTY8/gDe2lYRcVstL18lV7bXt0X/bMulsTbyyvO9Pla2y898tJ5oXjpVmqD6zjHJ9k6fXylm1UNlOyA9vyhx2NDc4cV/v+relUwPky8I8BuyYLN1xl/ZLidVI0x2DjthPFXJY+p41m2X12zXUgWzUtke43rcWpx4ILM7o6ps78bTll7Pa2KhVLYz2U46Fqps74c28m7ttAuPtUq3qzaNtkCWP9dY2sh3bSEvpNsDb4pJLL8zgYCoVHM77Nr6PZEdP1qaJb+rsqXXVoahiQfaOxbOONYN1PpEDD3xGe0Qbc6wieWuiqYWAejDuu2uWiAjP9Q6Ox2S7Y09j8nQ46Vk6Fevf9XrXxN2vbuWSiA7jaraAamyPeALezzCCddKPmwb+dY0PBYAUDBO+n3pUkER65rt8u8BEPxdaPwGcJQCphT+vYjEZAGGzAYOrk32nhAlTEnwfFbV3Mdku0ebraBjbyMf/D6NHYeuvj1Lqkp9bVPPFtBdKcs1aXDcURhHG/kOjbWRz7H305rtGp2oc6wzpkit5LcdacahLglGV/CkIQiAXWMdINQYDQLOLZMmtb668Wi39+RJOnqZeKBXfmN23yrbPb0nmNOqsj3eSm5AOhYGE2BM0/FXOMrxiHHygRZb6suirGzvxq3hZLvZBpx2D1AyNdl70q+YbKeYOPuxjbyWWv/Guv50V1qtUs0MzvZuiyXZHowJtpDXPjlpLq/FHonL40NwdQHNxkZ+lhUTB0k3o5/vj1zdHjpnaO9YdO2eEghEt9ZVm4YnH+hSzlCg6XDETeTK9ppy9bXdI2qvBzILlcr2bgnoVGNzSgPVMNX+Uy6eAsEg4Mi6I2jYH3k2sPygonsb+aPp1UIekNZsB4D66FrJjzwlmGz/8GuIwZKjsA9tWisBRxqtXS8rnCBVhHRZxz7WZLs8EcOcYYbBaJCS9+naQl42/Hipsj0QSPaeECVEUbCyvaXTpyQD49Gqoc5zXcXSRl4URc23kQeAc2YMhtEgYPOhJuyvbVPdTsuTfPODky1jW7M9WNmukSSiPPZq6fTCH+XYKxytTtQ5VkGWFfODk+S7Vre7uqxRrqeikW/PkpLtH+2uQX2X3yO500GWVXvPKyhEtDhgt3eioyHOZLuchNXKmu3xrlEOSNXclqz067IWiS1H+hrr5AO5sl1LVf4ye27s65N72rRZ5S9bcCNQPDnZe9GvmGynmOQqazr1vbJdU23kbXKVbvSJZZmWJh10FWojH0uyXbsz56k7eeJORVPvN+byJAyLSXtrBXa1YIw0cP9sb+R121s12g0DCHU8CIhAmye6cwfbyGuLmDM0Yht5ACieGmwjH3dle/c28uasFH4QJAhSdXuYY5JVkqVUbpe/WB7xrwlb2d5aKVUwpxPHYGlt9SjXbR8ybwhMdhNc1S7U7qwFEFqzvVtle0tFela2F46TvnZpJR9vZbsyEaPxIJA7vP/2MRmGzZceZNTt7n1bIg3ItpqUttZ9aSWv1da/8sR4l8cPnz/yJByPLwC/KD3s1nLisCjbhkVjpeV7Xo9Q3a6MzzWYNOvaRj7aSb5aW7NdHnuJYmiMGQ95PKbl3xnZsqnS5Mx3ykNLMGhteYFojSnKxvQhOfAFRPx7S5fjoZNOB3on2nJgs7njbyMvJ9sjrdkuL4WWypPjZX2tbNdaQlWeRBHr5AO5pb7WjgcQXxt5d6s2Jx5oGJPtFJPczP6rbNdSRXdf2shrtYJA/nniaSOv1eplCjlupLQ2y5qd1Uq1oRq9xEVo3fa6iMdEqxN0AMBmNsJmlm5Nop3UJT8Y0uLx0CPR2XuyXW4j33K4BR2Nccykb68DMvLDJ6BTkUqyHQCmXTYNAFD+QnnE80aPhCqQnm3kBQHIHx11ZbvJasKwBVIrfrmVvJxst+VIlaDSE+aq9DsWgDQ7PrMIqNujvBRvZbvye9D4TfpXtg+dK7ViPMh120kfBEFAcbC6vaofku1aS5h1fd7Q20Twti6dATI10ipczfJgK/k3Nh1VTTZredwhV7b7AmLUz3HkduFaiQ2z0aA8t+lLK3mtTtQJZ8nkYhgNArYfbcHBeqkCsz143tDauTMay8MsSaGnyRd6ZsjMDbaR72OyXaWyXRTF9KpsV9Zsj7OyXWsJVaMZMNnjr2zXYrI9njbyWpyIoXFMtlNM5DZT/bFmu5Js18AsaaUldhyzgUProKX/cehKHpDHUtkuD+a1ui43hZw6sRgWkwEH6lzYXR15DR8l2a7xuJg7Mg9mo4CjTR04GGHAovU1ynNjWLddFEVNTdwiADnDgObDUgJUhS3HhpxhUluymu1xtJI/prI9pddsByIm2yecNwEmuwn1u+tRuaky7DZAmIRqwA+0VaVfG3lAWre9bl/v2wUp67Z/GEy2H/vQpr0B8LvT81gAQOH4/qlsz7JIlQTtdYAzzSvbLZnAoOlMtpOuFAfPaX2pbNdqgsRsNCjrKPe2hJVyDCxGGA0aaucaxmkTi+GwmVDR3Im1B8IvY6Xl+2yryQhH8OeKppV8ICCiwyslVe0aqmCWC0ea4igckSmTEDR27ggnP8uK449pJS9PNtBbZTsAnD1tMMxGATsqWvBVlZRUY+c5fTBk58JoDMDT2BzfX6Cs2R4+2e7r8EH0S88E0iPZ3oc28u5Wja5R7oj9eMhxocXjEVdlu4bXbNcoJtspJqEkSN8r21s0VI0Yb2W7lhNFfWsjr80kIoVkWU04cVwhAGDVNvUEERBqI6/1yvYMiwkzh+UCkKrb1Wh98Bp64NP7dabd44dciKOFiVsUbCPv6wRctRG3k9dtj7mVvN8rzSbOKFAS0GmTbA8zAcGabcX4c8YDALY9v031r+hR2e6qBQI+IDsN1ynPHxt1ZTsAjDp1FADgm4++QcAXQGezlIhS2si3BttepuOxAICCcWEr293Nbvi9va/drPweZFtCkzrSvY08ILWSP7Q24sQdIi2RK9vjTbaLogiXR15nV3v3mNFOjpeXutND0tBmNuKs6dK177WN4VvJy4UBWh2HFQQnIda19T7u6PBqs+tBqKAm/md8bTprG75sqjRB853gcwylsl1DcRGt3EwLTpkgdR2TzyN66nSgZyan1JnR39oQ31/QSxt5efwKATBnpsE1yGiSljuLt7Jdi8llqyOOynYNt5FnZbsuMNlOMenXynYNtU+PN9ne4Q0lirRwHLqKp418q06SqiRZOrUEALBqe1XE7UKV7dqPiwXBVvKf71dPtoceemnrnCGTrzPRVLbLD3aMBkFpP0/pTcwZKv1PlK3ka8pjrGxvD1ZuZRaGKtuzUz3ZPhzwdUgV+WFMXTEVALDj5R0IqKxF26OyvSWYYHakYYK5YKw0WSDKWeElZSWwOW1wN7tRubmyZ2V7S3DCVzpXttfvA/zS+dDmtEEIVmN21Pe+zEK3tRAbv5FeTPc28gAw/Hig5Wiv5xIirShRku29V+iG4/YF4A8OTDM1mDCTJyN8ulf9HhsIrb2sl6Th8plSC+j/bK8KO0k+1FFLm+OOgkw52d77742cUBUEaGrcIY+9ol3CK5x2j34mqQDAksklMBqkau6v61xdluDQx3njWPJ55I3NFfD5A5rtkkLdmfOkZ1dob4zvL3C3AoIRMNvDv90SGqMIQpp0mrFmhyYRxMLjAiwarF62OYDOGDsfeFyAySZNXtAau1MqLPFGuRRiwA9427W3xIDGaecOkRKiPyvbtVTRLSeHW2JMtsuDV4OgvZZToWR771VVMvn4aSEmqHenTiyGxWjAvpo27InQSl7ryeWujleS7fXKA89jtWl47UQAcNqjv86EluEwpc8AjCJzSutr95Ygi7uyXU5Yp1sbeUD1mIxZMgb2PDvaqtqUVuldiQGx58SCVjnBnIbJ9vwx0tf66FrJG4wGjDhpBABp3fYea7a3VgAQgKzift7RBCkcD/g9SqLcYDTAnic9tGqPYg3F7pXtB6WHG+l6LLoaNl/6emhtcveDKEGK+rhmuzwuBbRZnXnl/BEAgD9+tC/iPWabW7vV/eHMHObEyIJMdHj9+E95z25jmk+2B++Loku2B1uFm42aGnfEMvYKx+3zwxts9ZyhwXNHOLmZFqWV/KryylAbeZ2cN4510vgi5GVaUNfmxqd760KdDjR63iCJpUCa/I6OONvIu1ulJKLK+TSt1muXxdM2HQhWL2u1sj3GyQdabakPSJXtQPSt5Hvp/kCpicl2iknXikOxj20Z2zQ0cJMr22NNtncdzGtpwAaEZrF6/AG4fdEl3JV24TqoYCZpksrCsVJyeVWYhzuyFo2vUd7V9CE5yLKa0NTuxc6K8DfpWl+zPZbK9lYNdUihIFuONCiLtrJ9ew1ElYkpYbUHk+0Z+d0relOZkmw/GPZto8WISRdOAgCUv1De432PK/TwNFTNXQEYzEBGQf/uayLIyfa66FvJjzhlBAAp2d6jjXxLJZBVBBjT9JxaIC0jgLrQuu32/GCyPYp127stMdB4UIo3LdyTZuQBhROBg58le0+IEkKubK+JM9nu6rJWuUGDa5WfW1aKCSXZaOn04cn/qk/W0lMbeQAQBAHLZ5YCAF7b1LOVfOheO02vkb0oyIq9st2usYRyjjz2inPN9q7FFZkaKyCJ5KxpUkekt7dVKktw6Onn78piMuAceUmKTUc0v+wdSaxF0uRcY6A1qqWrevC0hdY5D/d2a5p0oevK6gDccUw+8LRps3rZFk8beZd2k8t2adnQqFvJyy31uWZ7WmGynWIiV7b7AiJaY2gPHo6WBm7xtpEPVfen/zE4VteBRrTV7XqqYCbJ0uB6ZxGT7Uobee3HhclowLxR0iz5cOu2BwIi2jzaHrzG8sCHA3mNktcojyB/XD6MFiM8rR40HWyK/u9Ox8p2uxOw5kQ8JtNWTAMA7Hp9F7zH/O7IDyoEowCTfH1tqQCySwBDGg4FrFnS+upxrNt+8NOD8AfvSZSJB60VQHaatpAHpM/R6gBqQ8l2ed32aJLt3ZYYaPxGGy3kZcPnAwdZ2U76UBw8p8Vb2a71tr9Gg4CfnjkBAPD3zw/iSGP486NL4/fZ4Zw3cwgEAVh3oKHHcenaRUqLlGR7a+9V3aFW6dpKqDrt0U90DkeeqGMzG2AypuF9ZZwWTyqBySBgV2ULth+Vkmt6qewP59uzpFbyq3dWK896tXo9IYmtRJr8brO50dEQZVvsrtytEZOquqpsd2u1sj079uOh6WS7U/oadWW7htev1zD93AlRv7CZjcr6VE2uvq3b3qqh1kJyJbbL44dPZb3UcLTcls1kNMBulgai0a7bHmojr73JBxTeaZOKYTYK2FPdhn014dsLtSiTMPQRFwvGSMn2z8Ik210eH+SmIlo8bwChVoaNUbWRD3bD0Els6IZzGNB8OOImRrMRhZMKAcTYSt5VBxitgCUrvWbL9zIBYejxQ5EzPAeeVg/2vLWn23th17trrUzPFvKygjExVbYXTCxAVkmWkmgHuibbq9L7WAgCUDAOqAt97rEk27tVtjcdBJzDB2Y/k2HY8dKkjLbaZO8J0YAr7rJmezwd6Fw6mMB40rhCzB+VD48/gN+v2RN2m9BETm0lVCMpddoxPzjZ941NR7u9p+XnFUCcle1mbcWGsmZ7nJXtep38nJtpwQnBJeDe3yWNRbQ2ESMWkwc7ML44Gx5fQFkOT28xoTcGawa8PlMfku1tESt20zLZzjXbu7PmxFHZrtGJB0CojXzMle1MtqcTJtspZnJ1ezSJkEja3NLNvBZuwLpWYrd0Rl/xr/WBiTyTtTXKY6IkznRQwUySHLsZC8bIreSrwm7T0qGv5QUWBFvrf/lNAzqPaccl/46YjQKsJm1ewofnS0miL79uQKCX9uBaX79et6KobAe6tJIvr4n+726vAzIL0N7QgdZKaSCcPSgNBra9HBPBIGDqiqkAeraS75ZMlbWkeTV3/tio12wHpDa5I08ZqfzZnGmGQa6+aqlM72MBSOu297WyPSvYRj5XQ8n24Vy3nfSjKPgw2uMLxFWh6vJovxJREAT8LFjd/sbmo2GXbGrrDLaD1vBxCGf5TKkq9fXNR7tN1mh1a3syfEGwu1Gdq/dnW3K3Pq3FRl/XbHdpvCtGJMuCreT1tmZ9OIIg4PzgkhQyvbbV1xOP1wabrRMd9fEk21siJhHTZsm3rqxxtE0HtJtgjqfSX6st9YE4Ktu5Zns60uaTehpQzv5KtisViel/Q2oyGpSEeSzrtmt9prhcESA/vOmN3iqYSXJmL63kW3S2vMDowiwUO6zw+ALYeLCx23tdl54QtLCmbhinTChCts2EI40d+Hx/fcRtWzU+YUm3coZKieVeKvOKp0nrxMVc2Z5ZgANrDgCilLDPKkmDwYtzmOqa7TK5lfze/+xFe30oydqtTbispSK9q7kLxgL1+4FA9OsDjjw1lGy35dhCb7RWAI40T7bLle3B35mYku3B5RQyMtsBr0tbbeRzhki/Owc/T/aeEA04q8mIvExpnF7dGnsr+TYlkajt5Mj0oU4smzYIogj85t2veryvxzbyAHDGlBJkWIz4us6FTYdC449WDT2zCSdfaSPfe2V7h1c6FhkaSyD2dc12ZQkKHSaal0wqgdkYGpPr7bxxrPPKSmEIHg672airZQX0yuPPhM3m7jb2jP6bNVjZbsuJPbkcCAQr2zWYbI9n8oFWW+oDgMkKmOxcs13jeOWjmOVm9G1NJwAQRTG0ZrtGBm7yADSW9ltKZbtGk8vyZ9sWZWW7UsGs0eNB4S2eVAyTQcBXVa04UNvW430l2a6TynZBEJSWdMeu2671dRMBabmSc2dIs+L/uSFyK3E9HA9dcg4DvO1Ae0PEzeKubM8owL53paroMWeMiXs3E0qubI8wAaFwUiFKZpQg4A1g5ys7ldfDVranexv5/LGA393rcgNdda1st+YEH9r43EB7vTYq2z1tQIvU/jdneA4A4Jv/ftNrO2l5MkaWNTi5SUtt5AGplfwhJttJH4qCk6qqmuNItstjc6v277dvWzweJoOAj/fU4vNj7rW13nlOTabVhDOmlAAAXt0oXUtEUdR8F6nCLm3ke7teypXtWku2y50rm+Nes106Lnr7nQGkiQpylz5Ae7ERqyKHDQvHSst86bHTgR75xAypjXxcle1tEVunK0u+OdJgyTdZPG3kfR0ARG0mVG0O6bmOP/oOwJptqS+zO4GOxl43A8A129MUk+0UM/lmPN42UwDg9gXg09g6PnIiMK5ku0aOwbGG5UmVVeVHm3vd1usPoCPYMptt5PXFmWHB8cFB6n+292wlr8dJGPKg/dh125VJSho9Z8gumjMUAPDejqqI1xqtPwDULecw6WsvldxyZXv9nnp4o732uuohZuSHku1nplGy3dcJuCKvPR2ulXyPyvbOFikxm84J5oLg51YXfSt55wgnckflAui6Xnuwo0o6HwtASrYDSiv5KRdNgTnDjOqt1fj6w68jfqs8GSPDFIwtLbWRB4DhxwNV5bFXmRCloZJg146alt6rdI/l0tFa5SMKMrHiOOle48F3v+q2bJF8b6n1Cv9wvh1sJf/2tgp0ev3o9Iae2Wi2jXxwIqLbF1Cezajp8MjJdm2NO5x9rGwPLUGhv98ZAFg6NXQPyQQzsHyWdB7Jz0yjBCnFzW/Ihs3WGV9lu7s1usp2rbeRVxKqGqzmtjqkr7EcE61W+cvsudG3kfe0AQaTVBFPaYPJdoqZfDPe2IfKdjlhJAjaaTeVE0y2y1W40dBSK/1wFoyRZrV+ujdycgDovq671hOJ1NPSYCVFuFby8u9Ujo4mYciV7eVHm7tVGWh96QnZlNIcTBrkgMcXwMrNR1W3U9rq85yhLUqyPfK67VklWbDn2yEGRNTtqou4rcJVi/b2DLiqXTBnmjHshGF93NkEkROgvRyTKZdMAQTg0P8OoelgE4Awle0tFdLXdK5szxkKGK1A/d6Yvk1uJa+0kW8JXnPS+VgAUjW60Sq1kgdgz7Njxv/NAACs/W3k9crlyRh2VEuDf1vOgO5qwg0/HhADwJEvk70nKeXBBx+EIAi48cYbldc6Oztx/fXXIz8/H1lZWVi+fDmqq7sv03Ho0CEsW7YMGRkZKCoqwm233QafL4ZqFRpQxdnSua2qJZ428vpad/lHp45FpsWIbUea8U6X8YfLo98q3Xmj8lHqtKO104c1O6uVDlIGQbtrL2dYTEo1cl1b5GKS9mBs2DV2LJx2uXOlp9vEk2jJE3UydPg7AwCLu7SS13tlOwCcNXUQfrF0Iu751uRk7wolQMCcDbvdjY6GOCrbe1mbOz3byMuV3DHkSzwarl62xZNsb9V2st3mjL6NvDwhRaNLiGoVk+0Us/6obFcqui0mGAzaOGmwsr2nhWOlhOGmQ029TkKQB/OZFq7tpEeLJ5fAaBCwo6IFB+tdyutdl5zQakVFOMUOG8YUZUEUgbUHQknE0DlD+8dCrm7/54Yjqm0d9RgbumDPlQabvbQIFwQh9nXb2+tQe1CKp1GnjoIxXR6K5Ui/D71V+ztKHRhx0ggAQPmLUnW7UtmuVHMHk+3pXM1tMAL5o4G62JLtky6YBAAoniHFjSaOBSAdj4KxSmU7AMy7cR4Eg4B97+5DzXb1pRaUyRj+Su21kAeA/DFAZiHXbe9i/fr1eOqppzBt2rRur990001466238Morr+Djjz9GRUUFzj//fOV9v9+PZcuWwePx4PPPP8ff//53PPvss7jzzjsT/SOQiuLgRKLqOJLtLo2PS49VkGXF1YtGAwB+u3o3PL4AAO2PzyMxGAScVyYt5fTapiNo6dJRS9Dwg96CYCv5+rbIHSHa5QrudLl3jJL8HCsgAm2e2CdPubo829OjnAwzvrdgFMYWZaFsWG6ydyfpDAYBVy0ahXmj8pO9K5QAoiWnD23kWyJWtvcYw6YDpZI7hlbyHi1Xtgc/31g6jHlcESdhpD27M7bKdi231NcoZrQoZv1T2S59r5Za/+b0JdmuoePQ1dC8DIwqyIQ/IOLzffURt5VbhTNppk95mRbMDw7IVpWHWsm3e/zwB2fY66mNPBBqJd913Xb53KnVbhhdnTujFBaTAbsqW7D9aPib81YdPxDVNEEIrVHeC3nd9qiS7X4f0NGIo9ulh6mjzxjdp91MKLtTqjiO4ph0bSUvimKYynaNtE7PHxNzZfvo00fj5qM347QHTpNeaKkEzBnaqOYuGKdUtgNA3ug8TDhvAgBg7e/Vq9uV9RDdR7XXQh6QzifD5gEHI1f460VbWxtWrFiBv/zlL8jNDSUFmpub8de//hW///3vccopp2DWrFl45pln8Pnnn2PdunUAgNWrV2Pnzp14/vnnMWPGDJx55pn41a9+hSeffBIeT/yTsKn/FAcfSMeVbPfoq7IdAL6/cCQKsqw4WN+Ol76Urq8upcJfWwnVaJ0/U0q2f7KnFgdqpQSA1sfnBVnS/VFdr8l2ubJdW78jNrMRdrMU7/Gs294WXLNdT+eOY/3szAlYc/OJyjNBIt3IcMaXbBfF4JrtvVe2K2PYdCAnl2Ntmw5os7LdGhxjx3I8eomLtGdzAu1RdmV0R+7+QKlJv3dDFDe5sr2xL5XtGlx3WGkj3xH9bGA9VGUuGleIA3UufLq3FmcEW4WHI1e+c712/Vo6dRD+t68Oq8orce1JUhJMjguzUYDNrK/5YSeMKcCzn3+Dz7pMVGnV0RrlORlmnDG5BG9urcA/NxzC1CFTe2zTpsGJWxSUMzSqxLJc2V5Trl65q+hoAAAc2SYlIcYsSZP12mVRTkCYtHwSVl2/CrU7alG9rbrnenetFUBGPmC2DeTeDryCscCWl2L+tuzBXWaHt1ZKkw60ULFXOB74+uNuLx1/6/HY9doulL9QjlPvPxVZJd0H66IowhNsm2tsPwqMmZuw3U2o8UuBbz6THuxp4bPug+uvvx7Lli3Daaedhvvuu095fePGjfB6vTjttNOU1yZMmIBhw4Zh7dq1mDdvHtauXYupU6eiuLhY2WbJkiW49tprsWPHDpSVlfX499xuN9zuUAKrpUV62Ob1euH1xj9xu6/kfzuZ+zAQCjKlMWVVc2fMP1tLcMK4zSRo7riosRiAH548Cne/tQuPfrAHZ08tVu61bUbtxUc0hjqtKBuag82Hm/GPtd8AALKsRk0fCznZ/o+1B3HcCKfqM6q2Tul6aTP1PTZS7RyUYzehw+tHXUsHSrJjezbV2hFcjsasn3PHQEu1+CB9ixiP9hzYbJ1w1blii1dvO8yiHz6THaLK93U2S2N2U4YpbX4XBFMGTAC8bQ1AVml039PeLH2PwQakyc8p6/VcZbTDDMDnalD9nLsJ+GH2dcBnVI+LdGcYNAOGbf+Er/EokFUUcVtjZwtgzoRfo8ciWqlyTYz23+fTaYpZbqa8plMfKts1WNEtV92yjXx3i8ZJCcNP9tZCFEXVFnRyxa6WJx5QZIsnF+OOleUoP9qMww3tGJqXoUxecdjMmm5fGM5xo/JgNAj4us6FI43tGJKboZs122UXzRmKN7dW4N9bKnDHskmwmbtXGXHNdg1zDouq7XPx1BjayLukGcRtrTbkj8tH7qg0a/XoHB5Vst3mtGHcWeOUJKtSudx1zfbsNF+jHADyx0oTB/oy47ulIv3Xa5cVjAPa6wFXPZApdYoZMm8Ihh4/FIc/P4wvn/gSp9x3Srdv8bZ7IQZECEIAQttRbbaRB4AZl0r/6dzLL7+MTZs2Yf369T3eq6qqgsVigdPp7PZ6cXExqqqqlG26Jtrl9+X3wnnggQdwzz339Hh99erVyMjIiOfH6Fdr1qxJ9i70q8NtAGDCodpmrFq1Kqbv/fqwAYABX+/ZiVVNOwZi91KSIwAU2YyocXlx+9/fR7NLACBg64YvUKmfw9DNWLOAzTDi0+CEX297a8zxlE7GA/ivYMRn++ux7Pcf4OoJfuSG6Vp84JD0O3Jgz1dY1bKrX/7tVDkHGXxGAAJWf/wZDjljW7d9zwHpuBw+sBer3Ht63Z6ilyrxQQSEj8ei+haU2jyoPVQV03XC6m3GGQA2lO9B9aHw31dfKV2DNu3YhL2G2LqZJUtmZyVOA/DFx2tQnx15STzZ4MYvMAfA6o8/g8+Y/HvjeKidqwwBD84GsPXL/+HIvt6vLSZ/O5YB2LxjDyoqtHnfYfZl4gwAX736axwoWhJx2zmH9sHk78BaDd+DxSLZ18T29vaotuPTaYpZjr3/Ktu1lFjNCVZkt8SRbNdyS+jjRubDbBRwuKED39S3Y2RB+HVoQklV7R4Liqwgy4p5o/Lx+f56rCqvxA9OHN2l44F2zhXRctjMmD4kB5sONeHzffW4cE4o2a6HNdsBYP6ofAzJteNIYwf+s70S55UN6fa+HrqD6JZzGLD15V4rUQsnFwIC4Kpxoa26DVnFEZKurlrpi8uOseenUQt5mXMYsO/9qDadumIqdr22C9tf2o7SudKseqWyvaUScKR5C3lAqmwHgPp9wOAZ8f0drVVAzpDet0sHhVLLeNTtBjKPV16ef+t8HD7/MNb/YT0W3L4AlsxQK0Z5IkaOsxWC6AdyRyRyjymBDh8+jBtuuAFr1qyBzZa4rha33347br75ZuXPLS0tGDp0KBYvXgyHw5Gw/TiW1+vFmjVrcPrpp8Ns1s49RF2bG78t/xitPgGLl5wBkzH6rlD/qPgSaGrC/NllODNCNzItMo+sxo9e3opPqk1wB6S12xefvAiD8/TZunNBhxcrH/pYWcd+2KBCLF06M8l7NbBOPNKMa17YjIo2D57ck4GnLivD1NLuS8y8WrsRaKjH3LLpWFrWt4l6qXYOerFqPSq+bsT4qWVYOjW23/+3X9wC1NVg1vQpWDp36MDsoM6kWnyQvkWKx2bUA5tfQKbgx9KlS6P/Sxv2A9uB2cefCHH4grCb7Bf3ww03Tlx8IkrK0uS+pK0a2PVTzCubBHHcGVF9i7ClEfgGWLzsPMCQXkvYRHOuErdfhxkTRmHa7Cjio6US2AaUHbcQM8ac1vv26cr9Dia3bMeEpY9G3Mz40jOApSS23y0NSpVrotyhrTfMalHMcjP6obJdrmLWUDWinAyUk4PR0ENL6EyrCbOH52HtgXp8urdWPdmu46QqhZw5dZCUbN9eJSXbO/SzRnk4C8YUYNOhJvxvXx0unDMUbW65A4Q+jofBIOCCWUPx/97fg3+uP9wj2d6mg3OobjmHAp5WoKMRyMhT3cySaUHemDw07G1ATXlNxGS76KqDAKC9PQNjzkizFvJAqI18FK2wxy4dC5vThpYjLUqbcKWyvbUCGNyz3XPayQ9+hn1KtlcAQ+f02y4lVf5oQDAAtbuB4aFk+/hzxiN3dC4a9zdiy7NbMPf6UKt4d6vU3rtwUHCtQCbbNWvjxo2oqanBzJmhhJnf78cnn3yCJ554Au+99x48Hg+ampq6VbdXV1ejpER6wFlSUoIvv/yy299bXV2tvBeO1WqF1dqzRNRsNqdEAiFV9qO/FOeYYDII8AVENLkDGJQTpjxXRbtHSqw6MqyaOibROGt6Kf762UFsOdykvObMsunuOMjyzWacPqkY72yrBADkZFg0fyxmjyzAyutPwPee3YDd1a249K/r8chFZd2WwesMTj7Itvff8UiVc1BuhnSuaPUEYt6fdq+0ZnuODs8dAy1V4oMICB+PtiKpw5HoaoLJZIq+G6VfbhGfC6jEuLwUWmZeZvr8HmRJ3cVMvnbVn6sHfwdgssNsTd8l3iKeq6wOGL1tMEZzPETpMzdl5ER//NLRjEuAf10OQ9MBaSk4NR4X4BgMg5aPRQySfU2M9t/W1wK41C/kNdvb3D5ltnOstNg+XV6zPbY28tLAREvHIZyF4woAAJ/sqVXdpkVn7bEpvDMml0AQgK2Hm3CksV33kzCOHyP97ny2rw6BgKi7NvIA8O3ZQyAIwLoDDThY71JeDwREtHm0dy2hIOcw6Ws067bLreTLI7eSb/v6G/h8Rvhgx4gTR/R1DxPPOQzwdSoV+pGYrCZM/PZEAEBnk/QwI1TZrpE28nYnkFkI1MXZVlAUpdnzWjgWAGCyArkjgbruLVwNRgPm3TQPALDu9+sQ8Ifu3eXK9oJiFwBBO1X+1MOpp56K8vJybNmyRflv9uzZWLFihfL/ZrMZH3zwgfI9u3fvxqFDhzB//nwAwPz581FeXo6amhplmzVr1sDhcGDSpEkJ/5moJ4NBQFHwXF8dfEgdLZeO76kEQcDtZ04I/Rki7Ob0qi7rb9+eGboe6CUmhuRm4NVr5+PEcYXo9AZw7Qsb8dTH+yGKUutbV/DZTYYGj4czWFDTHEf3Svm4ZGrwuBBRZJZCac1pi7Ed3lgK8tyt0ldrdti3xYDYc8J4OjDZAIMZcEdXAQsA8PRhSbR0YM2O/njIcWEJX6SnGeOWADan1MkxEncrYNFwbGgUk+0UM4fdrBRUNXXE10pei2u2x5psD4ihhxpab4G8aGwhAGDt/nrVCRqhCmZtHwuKrDDbirkjpCrWd7dXdVuzXY/KhjlhNxtR7/Jgd3VraI1yDZ07e1PqtGNh8Bzyrw2hda9cHh+Cz750dTx0Q147urn3tc6KpkmD/JptNRG3a9qxH+3tdow4aSTMGWl4TpEnIDQejGrzaSumdfuzJdsC+DxSsl4LbeQBad32+jiT7R2NgN8NZKdJW8JoFI6XKtuPMeM7M2DPs6PxQCN2/zv0vlzZnpffAjhKpYQ9aVJ2djamTJnS7b/MzEzk5+djypQpyMnJwfe+9z3cfPPN+O9//4uNGzfiu9/9LubPn49586TJGosXL8akSZNw+eWXY+vWrXjvvfdwxx134Prrrw9bvU7JUZwjVUZVNXfG9H2u4D2mXhNmx43Kx6kTpPsJmxHRV+dp1MKxBSgMTtzQ+rOKrrJtZvz1ytm4Yv5wiCLwwH++wu2vl8PrD6AjWMGdYdHeRIycPnSvVM4dGjwuRBSZOU8qDrHZ3Oio74j+Gz1t0leVZLvH5QGCz3qsjjS6xxQEwOYAOpuj/x6PS9vJZZsD6Iwy2e4JFtdoPcFssgKTzwPKXwECEYpYtT4RQ6OYbKeYGQ2CkliOt5V8mwarM5U28lEm2z1+6CZRNGmQAwVZFrg8fmw61Bh2G669TLJl06Qk0DvllcqSEw67tn9H1FhNRswdKU0++GxfnW5/Ty6aLa3/9+rGI/AFqzLliQdmowCribczmpORD5jssVW2b4tc2d5+8BBcLnt6tpAHulT7R5dsH75oOBxDQmsiW7OtQFuV9AetVHMXjIm/sr2lQvrq0MixAICCcWGT7ZZMC2ZfOxsAsPZ3a5XX5cp2p7MFyB2emH2klPX//t//w1lnnYXly5dj0aJFKCkpweuvv668bzQa8fbbb8NoNGL+/Pm47LLLcMUVV+Dee+9N4l7TsYqzpWR7dUtsyXYtdp6L1U/PnIBMixGlGn7mHS2T0YDvHD8CAHqsXa51JqMB935rCu46exIMAvDy+sP4zjNfoilY9a3FZLvTLlWONsXQpVGm94k6RHom2J0AAJutEx0NMSTblQrm8IlEuYW8wWSAKd2el1uzQz9fNNxt2k4uWx3RV7bLkzC0fDxk0y+WCksOfqa+DSvb0xKfTlNc5Fbyja44K9s7tTeYz1HWbPcprcYi6ZQmRsNk0H6iyGAQsGBM5FbyLTpPqlKI3Ep+86EmfFUl3aTqLbnc1YIureS1eO6MxmmTipCbYUZ1ixuf7JXOIW1djoXeq480SRBCa5T3onialGyv3VmLgEr3FI/Lg0BTdfqu1w4Athyp3VgUxwQABIOAKZdMUf5sdViltumAdhLM+WOB+v2h2YuxaA0ei2yNVPkDUmV7yxHpoc0x5v5wLowWIw5/fhiH10odI+TKdkd2Y6ibBOnGRx99hEceeUT5s81mw5NPPomGhga4XC68/vrrPdZiHz58OFatWoX29nbU1tbit7/9LUwmfd2TpLqSnNiT7T5/AJ1e6fqpt3vMrsYVZ+P9mxbgBxP8yd6VlHDdSaPx2c9OwdKpGuoAE4PvnjASf7liNjIsRny2rx6NwUKTDIv2fkecfahsb2OynUi/rNLEbpvNjfb69ui/z90KCEbAbA/7tjwh2JJtSb9nPbEkl4FgZbuGE6q2nNgr2/VQzT30OCB3BLBNpZW8KAYr28N3f6DUpe0MHw0Y+Wa8Md7Kdg22QpaT7f6AqPx8kXQEx/DZNn0kihaNk9pAy4myYykVzDpOqpKkyGHDnOFSNffqHVKlqkND54pYnRBMtn/xdYPSOUNL585oWE1GnFcmrR35z/VSkqhFp1X+uuIcBjT13kY+d1QuzBlm+Dp9aNjXEHabgx8fhN3mghcO5I/P7+89TZwoJyDIpl0WaiVvybYALUelP2iljXzBWMDrCiXOY9FSAUDQXht5oMe67QCQVZKFqZdNBRCqbpcfZDns9dJgn4jSXlGw3WpVDMl2ec1lgAmzgiwrNFi4HBdBEFDqtOviWYWaUycW49Vrjseg4CQWQKuV7fKSiLEV04iiCJdHOn/oeaIOkW4ZjHB7bfG1kbdmASrXF7myPa1ayMtiSS4DgKdV223kY65sF6QOh1onCMC0i4CdbwLeML87PjcQ8Gl7IoZGMdlOcZEr22O9GZeFKhK1kySxmgywGKVfKTkJFIlc2a6ldesjWTBWShhuP9qC+jZ3j/fltbn1lkSk8M4MVlB4gi3D5WUa9GhCSTbyMy1o9/iV45GtoXNntC6aI7WS/2BXDWpb3Wx3qgdRJpYFg4CiKdI6q9Xl4VvJ73t3HzIzO2ApKU3vh8YxJtuLpxVjzvVzMO3yaVJL+dZKafBqcw7cPiZS/ljpazyt5FsrgcxCwKih82nBOOlrmGQ7AMy/eT4AYNfru9CwvwHuVjfMZi9s5la2kSfSiBKHlBSsaek53lLT5pHuqSxGAywa77hGFKtJgx1Yef0JOGFMPk4Yk4/CrDRM/vQi3jXb3b4A/AGpu1CmVXuTEIiodz4xE3Z7Z+yV7VaH+tvpnGyPtY28x6XtSm6bI/rj4W6TJh4YdHIvOu0iaSLC7lU935Nb6ms5NjRKJ9FL/a2vle2tGqxsFwRBSQg2R3FcOv3Sw34tTTiIpCjbhomDpJup/+2r6/F+qI28Po4HRXbGlO6VhnrueGAwCDg+WN0u08skna7Gl2Rj+lAnfAERKzcfDU3a0uGx0A3n0KgTy0VTg8l2lXXb9727DxkZHcgeM7Lfdi8pnMNjSrYDwNInluK8586TJhm0VEgt5NN5wkFXucMBgwmojyPZ3lKhnQp/mTUbcJSGXbcdAIomF2HMmWMAEVj3yDp4Wj1wOpulN9lGnkgTioPJ9tgq2+U20EyWEYVT7LDhhe/PwwvfnweDQSP3UF3Eu2Z7146OmRpsr09EvfMhK/bK9l7WKZeXurJmp2OyPcY28npYsz2WNvJaPhbHyh8NDJkDbP1nz/fkCQp6Oh4awWQ7xUVZs7093jXbpZt4rSVJcoLrjTdHMUiRi9+1NOGgN4vGSQnDj8Os2y6vRa3nduEUMijHjlnDc5U/O+z6josFY0JtrzMsRhg1+JAnGhfNlqrb/7nhcJelJ/QdG5rmHAa4m4GOpl43lddtrymv6fFew/4GNO6rQ0ZGB5yT03S9dplzGNB8OL41yoFQsl0rjGap/Xndvti/t7USyNbQsZAVjFOtbAeA4289HgCw5W9b0HywGbm5wWQ728gTaYKcbI9lzXauuUykb3IxTXO7F2IM95jyRJ0Mi1GTkxCIqHd+YxZstk50NMSSbG+NWLGb1pXtthiSy4D2E8zW7BjayGu8pX440y4C9r0PtB2TJ1Eq27lme7phsp3ikiu3mXL1cc12jQ3o5apsuUo7ErmNvNaOQSQnjpXWbf90b123QZwoilyznXo4s0t1u97j4vjRocp2PU3QOdZZ0wfBZjZgX00bPtkr3YyyjbyGyZW2zb2v2x6psn3/e/tht3dCEABzfpqvz+0cBvg6gbaekwqi0loJZGusmjt/bHyV7a2V2qtsB6R122u/Un17xMkjUDKjBN52L8pfLIfT2YwAzEBWcQJ3kogGSnHwwXRrpw/tnt6XNgNCCTPeUxHpk5xs9/gD6PD6o/4+TtQhooDZEcea7a0Rk4hpnWyPtbLd06btBLPcRj4Q6H1brbfUD2fKckAwANtf6/66m8n2dMVkO8XF2YfKdlEUNdv+N0duIx9FZXuHnGzX2DGIZNaIXNjNRtS2uvFVVWjNFpfHj+BSX2wjT4ozp4aSIHqPi6F5GRienwFA3w9CHTYzlgbj4t3tVQC0dx2hLnKkTgbRtE0vniolCpu+blLazsmk9dqDa8hlFhz7renFOUz6GmMreYUWW6cXjIlvzfYWDVe2N3wN+MLfowuCgPm3SGu3+z1+5Oa2wG0o1s/aeEQal20zI9MitYOvjnLddibbifTNbjbCYpTuA2JZt73dIz3Uks85RKRDthzYbO7Y12yPUM3taZXGMZZsS1/3LvFiqeQGtJ9stzoAiNIEi95ovco/nIw8YOxiYNvL3V+XK9v1djw0gE9VKC5yG/lYbsRlbl8AvmBmNVtj1apysr0lmjby8prtOkoUWU1GzBuVBwD4pEsrefl4mY0CrCaelkhS6rTjmhNHY9nUQRhTyBuME4LrtmvtvBkruZW8PEEny6rv46FpWUWAyQY09V7ZnlGQgezB0qzfmu2hqm+f24evP/waGRnBmfaZhQOyqwnjlCcgHIz9e0UxWM1d2r/7lGz5Y6XJB97oWybD5wba67Q38QAACicAoh9o2K+6yeSLJiO7VPp9cTqb4bFoLCaIdE5Zt705uvOivJwXq1OJ9EkQBOTI3StjeMbHynYiEjKc8a3ZbnWov53Ole1yJXe0S3J4XNquXrYFP+doWutrff16NdMvAio2A7VdloKT12zXW6W/BjCrRXGR20zFU9kut1gXBCDDrK0ZsHKr6+iS7dJXvSWKFo2TEh1yC2ig63rtZggC1/qikJ+dOQFPrpjJNeAAnD5JqtyVK9z1au7IPIwsCM381VN3EN0RBKm6Pcoq7nCt5A/97xC8Li/yS4OD3Yz8ft/NhLLlADZnfJXt7fWA36O9NvIFYwGIQMOB6L+nVeqMobljAUht5AGgdrfqJkazEcfdcBwAIDe3GX47k+1EWiIn22tao0u2s7KdiJzBwpGmjuif8bmYbCfSPWN2vpRs55rtEqsDEAOhyuRI/D5piThNV7bnSF87GnvfVutV/mrGnSE95+la3c7K9rTFZDvFJZRsj72yXWkhbzFpLoEWSxv54GHQXaJoYXDd9vVfN6Ij2HZMnoCht2NBFIuTxxfh9euOx6/Pm5rsXUkqQRBwwewhyp953tA459Coq7iLp0kTUmrKQ5Xt+97dBwAYNjMDMJilQUy6cw6LL9neUiF9dWisdXr+WOlrLOu2t1ZKX7WYbM8sAOx5QN2eiJvNunoWLNlmac12x/AE7RwRJYK8bnu0le0uuRW0VVsT4YkoevIzvuYYnvFxog4RGXPyYLd3xtZG3tMWsZo7vdvIByu53dG0TddBQrVgrFQs8OVTvW+r12S7yQpMPg/Y9q/Q2vbuNsCcARh4b55umGynuITayHsgRtsaJUhuNaXF9ulKG3k5kx5Bpw7XbAeA0YWZKHXa4fEHsO7regChTgB6X5ebqDczh+XyYQaAb88cAmNwshaPBRTejgAAU/hJREFUh8Y5hwHNvbeRB8JXtu9/V2qlXTLeLFW1a6F7Su7w+NrIazXBnFkgTaKIZd12ZeKBxo6FrHB8xMp2ALDl2LD86ZNgtXqRO3tGYvaLiBKiOEeqbI92zXa2giaiHHvwGV8UhSOyNrc8UYfnDiK9MuUWwGTyw9vSBjEQZX7A3RIxwZzWle2xtE33uKSvWk62253AqXcCm58HDq2LvK3WW+pHMu1i6bnXoc+lP3t02lJfA5hsp7jIyXZfQFQG59GSK9u1mGR22KWf6WhT7+1zQm3ktXccIhEEAQvHSmtPy+u2d20jT0TUmyKHDctnlsIgANOGaKBSmdTFUMXdtbJdFEW0HGlBzfYaCAYBeYP8UlJWC5zD46xsPwoIBiCruP/3KZkEQapur98X/fe0VgImuzTLXosKxvWabAeAccdLD7CMBSMHeo+IKIGKs+VkO9vIE1F0nHGs2R46d7DyjkivLAXShHebtQOdTVHcd4hicM129aRqWifblcr2aJLtcmW7xqu5Z30HGFwGvHOL1DpfjVunle0AMGye9Jxna7CVvLuF67WnKSbbKS52ixFWkxQ+sdyMA6Gqby0O5ueMyINBAL78ugHrDtRH3LbTL1XXZeswwSyv2/7p3joAbCNPRLG7/7yp2HrXYowp0unMV73IGSat7xVFG7aCCQUQjAI6mzrRcqQF+96Tkq+lc0th9jdpKNk+DGg6HGoxFq2WSinRbtTgtbZgbOyV7Y5B2uh0EE7heKmtfsAf/n1RlKotKjZJf84dkbBdI6KBV5ITW7K9jcl2It3r05rtFp47iPTKmJ0HALDZ3NG1kvd2AKI/crK9NZhsz07DZHtMle3BZLvWk6oGI7Ds90D1DmD9X9S303M1tyAA0y4Cdv5b+h1x6/hYpDneEVHccjMsqGrpRGO7B0PzMqL+vlAbee0lmUcVZuGSucPwwheHcN87O/Hm9QtU16XXa2U7AJwwugAGAdhX04aKpg5WthNRzExGA7KNnDOoec5h0temw0DxpIibmqwmFEwoQO2OWlRvq1ZayI8+YzTQ/oZ2KrqdwwC/G3DVANkl0X9fa4X2WsjL8scAu1dJSeRoEuitlUC2xtau76pwPODrBL74E+BzA23VQGtV96/e4MOw7EFSG34i0gxlzfZok+2dbCNPpHfxrNnOJSiISB5H2GxudDT03uU1lGDWamV78OeKprLdrZPKdgAonQnM/j/gw18Dk84Nv5ybx6WPY6Fm+sXAJw8Bu/8j/Z7otaV+muNTaoqbfDPeGGNle5tcxazRG/KbTh+HbKsJ24+24PXNR1W3k5d112M1d06GGdOHOgFIreTlNdv1eCyIiCgCJdkeZSv5qVJCvWpzFfavkZLtY84YA7jqtFXZDsTeSr6lEnBoNMFcMBbobJY+52i0VGp3vXYAKJ4KGMzAez8HPnsUOPCR1CHCOQyYeDZwyh3A8r8C33kH+MGnyd5bIupnxQ6psr2mxQ1R7H39VJeHle1EepcTXCqysT36yvZ2j7xmO9vIE+lWcFkum60THfVRJNvljnVaXbPdkg1AiLKNvLxmu06Sqqf+EjBZgdV39HzP5wYCXn1Xc+ePBkpnA9v+ycr2NMbRFMVNXre9KYabcSA0+1WridWCLCuuP2UMHvzPV3j4va+wdGoJMsK01eoIVrZr9Tj0ZtHYQmw+1IRP99Ypa9077KxsJyKiLrKKAaMl6sRy0bQi4GVg8183w93shj3fjsGzBwOf1AEZGkm25wyVvjYdAobOjf77WiqAkQsHZp+SLX+s9LV+L5BV2Pv2rZXAkNkDu0/JlF0M/GS/9Ltjtid7b4gowYqCa7Z7/AE0tnuRl2mJuH2bW06Y6XNcSkRd2sizsp2IYtGlsr2tuq337eVke4TW6Z5WKc9gyY58/5KSDAapIjmWNvJ6qea25wKn3wv8+zpg5hXAqBND78kTD7TeUr830y8G3v2Z9Hyjl86OlJpY2U5xy82M/WYcgNIyXMsz579z/AgMybWjusWNP39yoMf7/oAIT0Bqc6rl4xCJvG77//bVKTHk0OnEAyIiUmEwADlDgObYKtubvmkCAIxePBoGAUB7PZCZP0A7mWA2hzRQbToY2/dpuY183igAQnTrtouilGzXapW/zJbDRDuRTllMBuQHE+zRrNuurLvM6lQi3VLayHdE/3xPPnfo9ZkWEQEw2xEQjbDb3ajdUdv79kobeUfYtwO+ALzBZ8RpWdkOSMl2eVJBJJ42QDDoa8w2/RJg2Hxg1a2Ar0vxptLxQCcTD9RMPl/6WruLle1pisl2ipszjjZTANCqrNmu3Rtym9mI28+cCAB46uMDqGru/pBDngEMaPs4RDJ9SA6ybSY0d3ix7kA9ACCba7YTEdGxnMOibyM/rfu67GPOGCO1zxYD2qlsB2I6JgCkmeKdzdpNMJtt0jGpjyLZ3tEorWeu1YkHREQAioKt5KNZt50JMyJy2uXOlbEn2zPDdHIkIp0QBPiNDthsblRtqep9+17ayLtb3cr/W7PTNdnuiL6NvCULEISB36dUYTAAy34H1O8H1j4Rel1vLfXVZOYDYxdL/88129MSk+0Ut9yM+Crb23RQ2Q4AS6eWYNbwXHR4/Xj4vd3d3pOT7RaTAVaTPisITEYDFoyREh+NcmU728gTEdGxYkgsO4Y6YM0JDcpHLx4NtAfX8c6Mor14uog12d5SKX3VarIdAAZNA7b9C6jcFnm7Vh0cCyLSvZJgNVhNFMl2toImIrmyvakj+mIanjuICAAEew5stk5Ub62GKIqRN3bLle3hE4lyC3mj1QijJU2fl+cOB/a813sreXebPiu5iycDx10DfPIw0HRYek1JtuvweBxr2kXSV1a2p6UBSbYfPXoUl112GfLz82G32zF16lRs2LBBeV8URdx5550YNGgQ7HY7TjvtNOzd270SpaGhAStWrIDD4YDT6cT3vvc9tLVFsfYHJUxunJXt8g25Q+NVzIIg4I5lUnX7a5uOoPxIs/JeaMJBmt449BO5lbxMr+vXExFRBDnRJ5YFQVBayZeUlSCrJAtwycl2LVW2D48t2d5aIX3N1nCCeenvpGr1Z84E9r6vvp088SC7JDH7RUSUBMVyZXuzO+J2oigq1anZTJgR6ZacbO/0BtDp9Uf1PS63tJ3WC2mIKDKDIx82uxvtde1oreilfbq7JWLrdHeLdN+Sti3kAWDJ/dIziLdvlJYwU+Np029C9aSfScuevfsz6c8etpFXjDsDyCqRCiwo7fR7sr2xsREnnHACzGYz/vOf/2Dnzp343e9+h9zcXGWbhx56CI899hj+9Kc/4YsvvkBmZiaWLFmCzs7QrOsVK1Zgx44dWLNmDd5++2188sknuPrqq/t7d6kPcoJVyI0xr9kuba+H9ullw3LxrRnSg+373tmpzPBrVR5oaHvCQW8Wju2e+ND6BAwiIoqDc5i05ro827kXQ+YPAQCMP2e89IJc2Z6hkTXbgWCy/TAQCES3vVLZruHW6dnFwHdXASMWAC9eCGx8Nvx28sSDLCbbiUi75GT7kcb2iNt1eP0IBJ8DszqVSL+yrCYYDVIr42jXbVfayOu8iIRI7wwZTuQEa6mqt1ZH3tjTJlW1q7RO10SyPX80cPYjwPbXgE3PqW/n0WllOwDYHMCSXwNfvQ3sWR161sPW6dISeTdsAWZcmuw9oTj0e7L9N7/5DYYOHYpnnnkGc+fOxciRI7F48WKMHj0agDRz+pFHHsEdd9yBb33rW5g2bRqee+45VFRUYOXKlQCAXbt24d1338XTTz+N4447DgsWLMDjjz+Ol19+GRUVFf29yxQnubK9KdY123XSRl72kzMmwGoy4IuvG7B6p3TT0aasW6/vQcmQ3AyMKgzdWDjs+ogJIiKKgTyjV24x1otFv1yE8184Hwt/vlB6wVULCEbA5hyY/UsG5zDA7wbaenmYIWutAKw52h/MWzKBi14AZn8XeOsG4P17ek5IaKmUlhQwWZKzj0RECTC1NAcAsHLLUeysUG9jKo9LBQHISNd2rUTUZ4IgwGmPfqlIURTh8ujr2R4RqbA7kZ0ndbrodd12d2vEdbnlNdvTdr122dRvAzOvBP7zE6B6Z/htPC59J5cnnw+MOgn4z22hboRaf14RLbNddUIKpbZ+vyN68803sWTJElxwwQX4+OOPUVpaiuuuuw5XXXUVAODrr79GVVUVTjvtNOV7cnJycNxxx2Ht2rW4+OKLsXbtWjidTsyePVvZ5rTTToPBYMAXX3yB8847r8e/63a74XaHWqS1tEgDSq/XC683tsrr/iL/u8n69wdatlWaq9Hg8sT0M7YFK9ttJu0em66KMk34vxOG448ff43739mFBaNy0eySYjXTbNTFMYjkhNH5OFArzWCzG/URE4mk9fMQxY+xQakkYjxmDYIZgK/+AMTc0b3+XQabARMumIAAAgh4AzC01sCQkQ+f3w/4o2uLmfKyBoeOib339viGpiMwOAbBl4a/73Gdq05/AAbHEBg/uBuBxm/gP+txwCQ9sDE0H4EhqyQtjwUNrFS4LvKaTP3l1IlFOH1SMdbsrMaN/9yMN3+4ADZzz2S63AY602KCwId6RLqWk2FGvcsTVUFNpzegdMXIYLKdSN9sOcjIlO5he61sd7dFTDBrorJdduZvgCPrgVe+A1z9356JZI9L38llQQCW/hb4w3zgf78HDGZlzE6Urvr9jujAgQP44x//iJtvvhk///nPsX79evz4xz+GxWLBlVdeiaoqaYZTcXFxt+8rLi5W3quqqkJRUVH3HTWZkJeXp2xzrAceeAD33HNPj9dXr16NjIyM/vjR4rZmzZqk/vsDpboDAEyoa2nHqlWrov6+hjYjAAGbv/gcleUDtXepZYQfyDYbcbChHb949j1IRQNGdLQ0xHTstMjeJAAwQoCITz5cAwOf8QwIrZ6HqO8YG5RKwsajGMDZMGLHZ+/imz2xJ6KmHt6IfL8VH2noemvyd2AZgC0fvYmjeXW9bj/nwGaYAiasTeNjEPu5ahQGj/ghZu58Cs0Hd+DLkTfAa8rCcfu3AjDiizQ+FjSwknldbG+P3PKbKFqCIODB86di86Em7Kluw4P/+Qp3nzO5x3ZsA01EMqWyPYo28nJXDADICDORh4h0xJYDq6UDAFC1NYrKdqv6OuWdTdISw5ZsDXQhM9uBC54F/nwSsOonwLlPdn/f3QpkFYX7Tv0oGAuc8GPg099pqxMh6Va/J9sDgQBmz56N+++/HwBQVlaG7du3409/+hOuvPLK/v7nFLfffjtuvvlm5c8tLS0YOnQoFi9eDIfDMWD/biRerxdr1qzB6aefDrNZe2tRN7g8uH/LR+j0Czh9yRkwG3tflUAURdz8xfsARCxdfApKgmvJ6YFv0BH84t878WG1FRfOHAwcOISRQwdh6dLpyd61pDrF68dHf/oCg502nLVsZrJ3R3O0fh6i+DE2KJX0Fo/CN0MxZagDk05ZGvPfbXzjdSBrBJYujf17U5m493aUjczH9BN6/7mMzzwCFExLy2PQt3PVUoiHz0T+K5fjzIr/B9/FL8NUEUBg8My0PBY0sFLhuih3ZyPqD/lZVjx8wTR895n1ePbzb3DyhCKcOK6w2zZtSrKdlalEeucMLhXZHEUbeWWijsUIAysmiPTN5oQJUsfS+j318Lg8sGSqJMs9rREr22vKawAAuaNz+303k6JwPLDsd8DKa4GRC4HpF4fe87gAi/rEA91YeCuw7RVADPS+LVGK6/cR1aBBgzBp0qRur02cOBGvvfYaAKCkpAQAUF1djUGDBinbVFdXY8aMGco2NTU13f4On8+HhoYG5fuPZbVaYbX2bDVhNpuTnkRIhX0YCAUOEwQBEEXA5QUKbb3/jB0eP/zBXlO5WXaYzfoZ1F983Aj844vD+KqqFc+vPwIAcNgtmoyNWJjNZrx30yIAYOvCAaTV8xD1HWODUolqPDqHwthyBMZ4YrWjAcgshEFrce4cFv0xaa0CxpyW1scg7nPVqAXA998Hnl8O87NnAN4OGCedE18skS4k87rI6zH1t5PHF+GK+cPx3NqDuPWVrXjvxkXI6/IAvK1TSphlM9lOpHuhyvbe28hzog4RKWw5ENzNyB5kQ2tlJ2q212DIcUPCb+tui5hgPrJOel4+dP7QgdjT5JhxKfD1J8DbNwOls6RqbgDwRD4WumHJAL79N6BGZW17ojTSeylyjE444QTs3r2722t79uzB8OHDAQAjR45ESUkJPvjgA+X9lpYWfPHFF5g/fz4AYP78+WhqasLGjRuVbT788EMEAgEcd9xx/b3LFCejQYAjmGCPZk0nAGh1SzNkBUF/raaMBgF3LJMmonR6pdlafKghEQSBiXYiIlLnHA40HY7ve111QGbv65qnHecwoOlQ79v5fUBbFeAY1Pu2WpU/Wkq4546QHmpk6/hYEJHu3H7mRIwpykJtqxu3v74Noigq77k8TJgRkSQnQ36+F31lexbPHUQ0bB4A4ITTDgAAqrZEaCXvVq9s93Z4UbVZ+t4h81WS9elq6W8Bx2Bp/Xav1HIfHlfElvq6MnQOMGvgOmITJUq/J9tvuukmrFu3Dvfffz/27duHF198EX/+859x/fXXA5CSajfeeCPuu+8+vPnmmygvL8cVV1yBwYMH49xzzwUgVcKfccYZuOqqq/Dll1/is88+ww9/+ENcfPHFGDx4cH/vMvVBrnwzHsWaTkBo5nyW1aTLVlMLxhbg1Amh9Vj4UIOIiCgK0SaWw3HVARk6Tra7aqSWbNk6v4fOLACufAtYcj8w8exk7w0RUcLYLUY8ctEMmI0C3ttRjVc2HFHeY3UqEcmcdqnrRTTP9zhRh4gURROBqRdg+sjVMJm8qN5arb6tp0012V65qRIBXwBZJVnIGZYzQDubJNYsaf32ur3Aez+XXnO3AZbMpO4WEfWvfk+2z5kzB2+88QZeeuklTJkyBb/61a/wyCOPYMWKFco2P/nJT/CjH/0IV199NebMmYO2tja8++67sNlC63e/8MILmDBhAk499VQsXboUCxYswJ///Of+3l3qI3lNp0ZXlJXtbFOHny+bCFNwokG2Tb/HgYiIKGrOoVLSWJ4FHq1AAGiv12hl+3Cg+TDg7+WBaEul9FXPle0ysx2Yfz1gdyZ7T4iIEmpKaQ5uPn08AODut3bgYL20tiqrU4lI5gwW00SzZnub2w8AyLTqq2MlEak4+XZYhWbMmbO198p2ldbpcgv5IfOGaLP7ackU4MwHgQ1/A7a/zjbyRBo0ICOqs846C2eddZbq+4Ig4N5778W9996ruk1eXh5efPHFgdg96ke5MbSZAkIz57N0nGQeXZiFG04Zjac+3ovjRuYle3eIiIhSn3OY9LX5SGiNs2h0NgGiX5vJ9qIJgN8D/G48MGEZMOlbwMgTAeMxaz63HJW+OkoTv49ERJQyrl40Ch/trsEXXzfgxn9uwSs/mM+EGREpnBnRr9nOiTpE1E3eKHSOvggLFryOPzw9E2JAhBCuo22ENvJH10njVs21kO9q1nel9dvf/JH0nILJdiJN6ffKdtKXXLmyPdo12zt5Qw4A15w4CvfN8mN0IdvFEBER9UpOtjcdjO372uulr1psIz9yEXD1R0DZ5cDXnwLPLwceHgOsvA7Y/S7gc0vbtVYCRguQkZ/U3SUiouQyGgT8/qIZyLaZsPlQE5747z4lYcZW0ESUY499zXaeO4hIZl32C5jNPsyZvg4N+xt6biCKwWR7+ATz4bWHAUiV7ZolCMDZj4aKAdhGnkhTmGynPlHayMdY2Z5tM/eypfZpsSMOERHRgMgeDAjG2Ndtd9VKX7VY2Q4Ag8uA0+8BfrwZ+MGnwNyrgMNfAi9dJCXeX7sK2Pc+kF3CGw8iIkKp0477zp0CAHj8w3344mtpUpqel3kjIon8fC+6ZLvUFSPDwnMHEUkMeUOw89AJmDdvI+o2ftVzA1+nVM1tdfR4q+VIC1qPtkIwChg0S+PLn9lygG8/A9jzgNwRyd4bIupHTLZTn4TayEdb2S7dtOu5jTwRERHFyGiS2qA3HY7t+1x10lctVrZ3JQjAoGnAKXcAP1wPXLdOWpu8egewdzUH8UREpPjWjFJ8a8Zg+AMith9tAcDqVCICnMHK9uaOKJLtHrlrJZegIKKQyoyLAAiw7/xTzzfdrdLXMK3T5fXaS6aXwJJpGcA9TBGlM4GfHJDWcScizeCIivpEXtMp2jbybcE28pw5T0RERDFxDou9sr29DhAMgD13YPYpFQkCUDRR+u+knwF1+9iejoiIurn3W1Ow/usGVDR3AmCynYiA/CwLBEHqSLn5UCPKhqnfP7exjTwRhZE3dSw+f2UWFp24Cmg+CuSUht6Uk+1h1myXW8iXzivt8Z5msfMckeawsp36JN428npfs52IiIhiFE+y3VUvrVVu0PEtb8EYwKHxVnxERBSTHLsZv79ohvKcl5PhiSjbZsb5ZdJayXe/uQOBgKi6rYvP9ogojJIZJVi3bhbcbgvw8W+6v6kk23tWth9ddxSAxtdrJyLN0/GTR+oPucqaTlG2keea7URERBQP51CgOcY28u112m8hT0REFId5o/JxzzmTMX9UPo4fw2slEQE/PXM8sqwmbD3SjFc3HVHdzsXKdiIKo3haMTweCz79ZA7Ezc8D9ftDb3rapK/HrNnu9/hRsbECAJPtRJTemGynPgm1kY+usr012Eaea7YTERFRTJzDgNZKwOeO/ntctUAmEwhEREThXDF/BF66eh5y7JwMT0RAUbYNN5w6FgDw0LtfoaUz/LM+tpEnonCsDiucI51Yv346/OYC4L/3h95UWbO9aksV/G4/7Pl25I3JS+DeEhH1LybbqU9yM0OV7aKo3mJK1ha8UWebOiIiIoqJc5j0tVm9yqYHV53URp6IiIiIiHp15fEjMKowE3VtHjz2/t6w27jcfgBAltWYyF0jojRQMqMEfr8JB40XA9tfBarKpTfccmV79zXbj6yTxvdD5g2BwHXMiSiNMdlOfZIbrGz3+kW4PP5et1fWbGdlOxEREcUiZ6j0NZZ129vrgczCgdkfIiIiIiKNsZgMuPvsyQCAZz//BvtqWntso7SRt/DZHhF1Vzy9GACwfdc0IG8U8OF90hueVkAwAGZ7t+2PrA0l24mI0hmT7dQndrMRVpMURpVNHb1uL7eRz2aynYiIiGLhKJUG57Ek2111bCNPRERERBSDReMKcfqkYvgCIu5+c2ePTpYuD9vIE1F4JTNKAACVW+qAk38B7HkXOPSF1Ebekg0cU72uVLbPZ7KdiNIbk+3UJ4IgYO5IaT2Vd8ore91eWbOdN+REREQUC5NFaiUvt6HrjSgC7WwjT0REREQUq18umwSLyYD/7avD6p3V3d6T28gz2U5ExyqZLiXba3fWwj/uW0DxFOCDe6Vk+zEt5Nuq2tD0TRMgAKVzSpOwt0RE/YfJduqz82dKF8M3Nh/tdd12uY08K9uJiIgoZhPOAnauBPy+3rftbAICPla2ExERERHFaFh+Bq5eOAoA8Ku3d6LTKyXYRVHsUtnONduJqLuc4Tmw5lgR8AZQ+1U9cMovgYP/A756B7BmddtWrmovmlwEq8OajN0lIuo3TLZTny2ZXIIMixEH69ux6VCj6naiKIbWbLeaE7V7REREpBVTvw24aoGvP+59W1e99DWDyXYiIiIiolhdd/JoDMqx4UhjB/78yQEAQLvHD7nOhl0riehYgiAo1e3VW6uBcUuAIXOBmp09KtvZQp6ItITJduqzDIsJZ0yRLqKvbTqqul2nNwB/QLojZ2U7ERERxWzQDCB/LFD+Su/bttdJX1nZTkREREQUswyLCT9fOhEA8IeP9uFoUwdcwSIagwDYzaxsJ6KeimcUAwCqtlRJa7Sfeqf0hiV8ZfuQeUy2E1H6Y7Kd+sXymdJF8e2tFUprqWO1dnoBSNfYDAtvyImIiChGggBMuxDY9RbgaY+8rUtOthcO/H4REREREWnQWdMG4biReej0BnD/ql1Kx8pMiwmCICR574goFXWrbAeAkQulJeEKxinbBHwBVKyvAMBkOxFpA5Pt1C/mjcpHicOGlk4f/vtVTdhtWpUW8rwhJyIiojhNWQ542oA970berr0OgADYcxOyW0REREREWiMIAu4+ZzIMAvDOtkp8sEt65pfJFvJEpKJkhpRsr9pSBVFed+Ki54GlDynbVJdXw9vuhTXHioIJ7EZHROmPyXbqF0aDgHPLSgGot5Jv65SS7dm8ISciIqJ45Y8GSmf33kreVQtk5AEGdtMhIiIiIorXxEEOXDZvOADg92v2AAAyrbzHJqLwCicVQjAK6GjoQOvRVunFYwrvlBbyxw2BYGBRHhGlPybbqd+cP1NKtn+0uwYNLk+P9+VWU9k2c0L3i4iIiDRm6gXA3jVAe4P6Nq56IIMz5ImIiIiI+urm08fBmWFGR3DpSFa2E5Eak82kVKtXbakKu82RtVKyvXReacL2i4hoIDHZTv1mXHE2ppQ64AuIeGtrRY/35TXbs2y8ISciIqI+mHI+IPqBnf9W36a9Dshksp2IiIiIqK+cGRbcuni88udMC5/tEZE6pZX8VpVke7Cyfej8oQnbJyKigcRkO/Wr88uGAABe39yzlXxrZ2jNdiIiIqK4ZRUBo04Cyl9V38bFZDsRERERUX+5ZO4wTBrkAMDKdiKKrHh6MQCgekt1j/fa69vRsFfqUlc6l5XtRKQNTLZTvzpnxmAYDQK2Hm7Cvpq2bu/JbeRZ2U5ERER9NvVC4OD/gOYj4d9vr2MbeSIiIiKifmI0CPjN8mkYX5yNc2YMTvbuEFEKi1TZLle154/Phz3PntD9IiIaKEy2U78qyLLixHGFAIA3Nnd/+N0WrGx3MNlOREREfTVhGWCyqVe3s7KdiIiIiKhfTR2Sg/duWoRzpjPZTkTqSqZLyfaGfQ3wtHm6vccW8kSkRUy2U787f6bU/mXl5goEAqLyequbbeSJiIion9gcwPgzwyfbRVFKtrOynYiIiIiIiCihMosykTUoCxCB6vLureSPrpOWny2dxxbyRKQdTLZTvzttYjGyrSYcberAF183KK+H1mw3J2vXiIiISEumXgBUlwM1u7q/7m4BAl4gMz85+0VERERERESkY3J1e/XWULI94A/gyBdSZfuQeUOSsl9ERAOByXbqdzazEcumDQLQvZU812wnIiKifjXmdMDmBMpf6f66q076mlmY8F0iIiIiIiIi0rviGcUAgKotoXXb63bVwdPqgTnTjKIpRcnaNSKifsdkOw2I88qkNjCryqvQ4fEDANo6vQCAbLaRJyIiov5gsgCTviUl28XQ0jVor5e+so08ERERERERUcKFq2yX12svnVsKg5GpKSLSDp7RaEDMGZGHIbl2tLl9WLNLuqDKbeSzWdlORERE/WXahUDTIeDwl6HXXLXS10wm24mIiIiIiIgSrWRGMNm+rRoBfwAAcHjtYQBsIU9E2sNkOw0Ig0HA+cHq9tc3STPW2EaeiIiI+t2w4wFHKVD+r9Brcht5e15y9omIiIiIiIhIx/LG5sFkN8Hb7kXj/kYAwNF1RwEAQ+Yz2U5E2sJkOw2Y82ZKF81P9tSiprVTqWzPYht5IiIi6i8GAzBlObDjDcAvLVmD9jrAngsYec9BRPTHP/4R06ZNg8PhgMPhwPz58/Gf//xHef+kk06CIAjd/rvmmmu6/R2HDh3CsmXLkJGRgaKiItx2223w+XyJ/lGIiIiIKE0YjAZlXfaqLVXobOpE7U6pC92Q45hsJyJtYbKdBszIgkyUDXMiIAJvbqlQKtvZRp6IiIj61bQLpXXa9/9X+rOrHsgsTO4+ERGliCFDhuDBBx/Exo0bsWHDBpxyyin41re+hR07dijbXHXVVaisrFT+e+ihh5T3/H4/li1bBo/Hg88//xx///vf8eyzz+LOO+9Mxo9DRERERGlCbiVftbUKR7+UqtpzR+UisygzmbtFRNTvmGynASW3kn9t09EuyXZzMneJiIiItKZ4ClA4IdRKvr0OyOB67UREAHD22Wdj6dKlGDt2LMaNG4df//rXyMrKwrp165RtMjIyUFJSovzncDiU91avXo2dO3fi+eefx4wZM3DmmWfiV7/6FZ588kl4PJ5k/EhERERElAaKpxcDAKq3VOPIOmmpWbaQJyItYokxDaizpg3GvW/vxK7KFuU1tpEnIiKifiUIwNQLgE9/B3hcgKsWyMxP9l4REaUcv9+PV155BS6XC/Pnz1def+GFF/D888+jpKQEZ599Nn75y18iIyMDALB27VpMnToVxcXFyvZLlizBtddeix07dqCsrCzsv+V2u+F2u5U/t7RIY0Kv1wuv1zsQP15U5H87mftAqYmxQYnAOKNIGB+USvojHgumSJPgq7ZWIRAIAAAGzRnEGE9zPFdRIqRKnEX77zPrSQMqN9OCUyYU4b0d1QCkZ+EZFmOS94qIiIg0Z+q3gQ9/BXy1CnDVAc7hyd4jIqKUUV5ejvnz56OzsxNZWVl44403MGnSJADApZdeiuHDh2Pw4MHYtm0bfvrTn2L37t14/fXXAQBVVVXdEu0AlD9XVVWp/psPPPAA7rnnnh6vr169WknkJ9OaNWuSvQuUohgblAiMM4qE8UGppC/x6O/wAwBaj7bCVecCAHzj+wY1q2r6Zd8ouXiuokRIdpy1t7dHtR2T7TTgzisboiTbs6wmCIKQ5D0iIiIizckdAQw9Tmol314PZLKNPBGRbPz48diyZQuam5vx6quv4sorr8THH3+MSZMm4eqrr1a2mzp1KgYNGoRTTz0V+/fvx+jRo+P+N2+//XbcfPPNyp9bWlowdOhQLF68uFub+kTzer1Ys2YNTj/9dJjNXOKMQhgblAiMM4qE8UGppL/i8cjoI2jc34iAOwCTzYTzrj0PRjOL8dIZz1WUCKkSZ3KHtt4w2U4D7uQJhXBmmNHU7oWD67UTERHRQJl6AfCfn0qtdDILk703REQpw2KxYMyYMQCAWbNmYf369Xj00Ufx1FNP9dj2uOOOAwDs27cPo0ePRklJCb788stu21RXS5OpS0pKVP9Nq9UKq9Xa43Wz2ZwSD+VSZT8o9TA2KBEYZxQJ44NSSV/jsWR6CRr3NwIABs8eDFuGrb92jZKM5ypKhGTHWbT/tmGA94MIVpMRZ00bBIDrtRMREdEAmnye9DXgAzK4ZjsRkZpAINBtPfWutmzZAgAYNEgaw82fPx/l5eWoqQm1+1yzZg0cDofSip6IiIiIKJziGaHliErnlSZxT4iIBg4zn5QQl88bgTc2HcXsEbnJ3hUiIiLSqswCYPQpwL41bCNPRBR0++2348wzz8SwYcPQ2tqKF198ER999BHee+897N+/Hy+++CKWLl2K/Px8bNu2DTfddBMWLVqEadOmAQAWL16MSZMm4fLLL8dDDz2Eqqoq3HHHHbj++uvDVq4TEREREclKpoc6IQ2dPzSJe0JENHCYbKeEGF+SjQ13nA6bmc0UiIiIaABNu1BKtmcV974tEZEO1NTU4IorrkBlZSVycnIwbdo0vPfeezj99NNx+PBhvP/++3jkkUfgcrkwdOhQLF++HHfccYfy/UajEW+//TauvfZazJ8/H5mZmbjyyitx7733JvGnIiIiIqJ0UDIjlGwvPY6V7USkTUy2U8LYLcZk7wIRERFp3ZTlgDUbKJyQ7D0hIkoJf/3rX1XfGzp0KD7++ONe/47hw4dj1apV/blbRERERKQDOcNycPJ9J8NgMsBR6kj27hARDQgm24mIiIhIOwxGYPyZyd4LIiIiIiIiIgKw6BeLkr0LREQDij29iYiIiIiIiIiIiIiIiIiIYsRkOxERERERERERERERERERUYyYbCciIiIiIiIiIiIiIiIiIooRk+1EREREREREREREREREREQxYrKdiIiIiIiIiIiIiIiIiIgoRky2ExERERERERERERERERERxYjJdiIiIiIiIiIiIiIiIiIiohgx2U5ERERERERERERERERERBQjJtuJiIiIiIiIiIiIiIiIiIhixGQ7ERERERERERERERERERFRjJhsJyIiIiIiIiIiIiIiIiIiihGT7URERERERERERERERERERDFisp2IiIiIiIiIiIiIiIiIiChGTLYTERERERERERERERERERHFiMl2IiIiIiIiIiIiIiIiIiKiGJmSvQMDRRRFAEBLS0vS9sHr9aK9vR0tLS0wm81J2w9KPYwNShTGGqlhbFAqYTySGsYGJUoqxJo8dpXHslqTCmN0IDU+a0pNjA1KBMYZRcL4oFTCeCQ1jA1KhFSJs2jH6ZpNtre2tgIAhg4dmuQ9ISIiIiIiIopOa2srcnJykr0b/Y5jdCIiIiIiIkpHvY3TBVGj0+YDgQAqKiqQnZ0NQRCSsg8tLS0YOnQoDh8+DIfDkZR9oNTE2KBEYayRGsYGpRLGI6lhbFCipEKsiaKI1tZWDB48GAaD9lZ8S4UxOpAanzWlJsYGJQLjjCJhfFAqYTySGsYGJUKqxFm043TNVrYbDAYMGTIk2bsBAHA4HDzpUFiMDUoUxhqpYWxQKmE8khrGBiVKsmNNixXtslQaowPJ/6wpdTE2KBEYZxQJ44NSCeOR1DA2KBFSIc6iGadrb7o8ERERERERERERERERERHRAGOynYiIiIiIiIiIiIiIiIiIKEZMtg8gq9WKu+66C1arNdm7QimGsUGJwlgjNYwNSiWMR1LD2KBEYazpBz9rUsPYoERgnFEkjA9KJYxHUsPYoERItzgTRFEUk70TRERERERERERERERERERE6YSV7URERERERERERERERERERDFisp2IiIiIiIiIiIiIiIiIiChGTLYTERERERERERERERERERHFiMl2IiIiIiIiIiIiIiIiIiKiGDHZTkREREREREREREREREREFCMm29NYIBBI9i5QCjp06BC2bduW7N0gHeA5iMLhOYiIiKg73jPpBz9rCof3x5RIPA9RODwPERERddff90xMtqeh2tpatLW1wWAw8CaautmyZQtGjBiBr776Ktm7QhrGcxCp4TmIUhXPVRTOgQMH8O677yZ7N0jDeM+kH/ysSQ3vjylReB4iNTwPUSrieYrC4RidEmGg7pmYbE8zu3btwvz58/HDH/4Qzc3NvIkmxdatW7Fw4ULcfPPNuPDCC3u8zzih/sBzEKnhOYhSUUVFBZqammAwGOD3+5O9O5RCtmzZgrFjx6KioiLZu0IaxXsm/eBnTWp4f0yJwvMQqeF5iFINx+ikhmN0SoSBvGdisj2NHDlyBN/97ndhMpmwf/9+3H777byJJgDA9u3bsXDhQlxzzTX47W9/i0AggNWrV+OZZ57BypUrAYBxQn3GcxCp4TmIUtFXX32F6dOn45xzzkFdXR2MRiMH8wRAeui4YMEC3HTTTfi///u/Hu/zXEV9xXsm/eBnTWp4f0yJwvMQqeF5iFINx+ikhmN0SoSBvmdisj2NfPTRR7Db7Xj22Wdx1llnYfPmzd0Cghcn/XryySfR1taGFStWoLOzE4sXL8Yvf/lL3Hrrrbj55psxd+5ceDweGAwGiKKY7N2lNMVzEKnhOYhSTUVFBa6++mqMGjUKAHD55ZdzME8ApAc8ixYtwv/93//ht7/9Lfx+P/75z3/i97//PR577DH4/X4YDBwiUd/wnkk/+FmTGt4fU6LwPERqeB6iVMIxOqnhGJ0SZaDvmQSRV9O0EQgE8M477+Dss88GADz44IP497//jbKyMtx///1wOp0IBALKycfv98NoNCZzlymBzjnnHHzxxRcYMmQISktL8eCDDyI3NxcHDhzAVVddhdLSUqxZsybZu0lpjOcgioTnIEolK1euxJNPPok777wTFRUVeOKJJ5CVlYV//OMfKCgo4PlJx+68807cd999eOWVV3DyySfjwgsvRHt7O2pqauDxeGCxWLBq1SqMGzcOoihCEIRk7zKlId4z6Qc/a4qE98eUCDwPUSQ8D1Gq4Bid1HCMToky0PdMTLanMb/fj9/+9rdYuXIlysrK8MADDyAnJwePPvoobrjhhmTvHiWIz+eDyWQCAHzrW9/C9u3bsXr1aowePVrZ5u9//zvuvPNOvP/++xg7dmyydpU0hucgAngOotT13nvvYcmSJQCAl19+GU8++SSysrLw3HPPobCwkIN5Hbv22muxZs0amEwmjBkzBo8//jicTifa29tx6aWXoqmpCZs2bWJ8UL/hPZN+8LMmgPfHlFw8DxHA8xClJo7RSQ3H6JQM/X3PxGR7Cjt8+DA2btwIr9eLsrIyjBkzRnlPvmny+Xz43e9+pwSEz+fD008/jd27d/NGScM6Ojpgt9uV2Vxdb6LfffddnHTSSbDZbMpMnFdffRW/+MUv8Mknn6C4uDjJe0/pgucgUsNzEKUbURTxr3/9q8fs+YcffhgXXnghhg8fnuxdpAToeq669tprsWHDBvzjH//AhAkTlG0+/vhjnH/++Xj77bcxf/78ZO0qpRneM+kHP2tSw/tjShSeh0gNz0OUTjhGJ4BjdBpYib5nMvX3D0D9Y9u2bViyZAny8vLQ1taGmpoaPPDAA7jwwgsxePBgJRBMJhNuvfVWiKKIe++9F1arFZs2beLNs4bt3LkTS5cuxWOPPYZzzjkHoijCZDIps//OOOMMZVu55cVnn32GUaNGITMzM1m7TWmG5yBSw3MQpaJvvvkGH3/8MZqamrBw4UJMnz5dmfEsx+YFF1wAAHjiiSdwxRVXYPDgwfjb3/6Gc845J5m7TgOsra0NWVlZANDtXPXHP/4R//3vfzFixAgAUB5KejweFBQU8IEjRY33TPrBz5rU8P6YEoXnIVLD8xClGo7RSQ3H6JQISblnEinlNDQ0iGVlZeJPf/pTsampSaysrBQffvhhMSMjQ7zhhhvE/fv3K9v6/X5RFEXxuuuuEx0Oh7h9+/Zk7TYlwMGDB8XJkyeLhYWFYkFBgfjmm2+KoiiKgUAg7Pa7d+8Wb7vtNjE3N1fctm1bIneV0hjPQaSG5yBKRdu2bRMLCgrEmTNniuPHjxdNJpN46623ips2bVK28Xq9oihKsfrCCy+ImZmZYm5urrh58+Yk7TUlwvbt28Xc3Fzx6aef7va6z+dT/Z7bbrtNPOmkk8TGxsYB3jvSAt4z6Qc/a1LD+2NKFJ6HSA3PQ5RqOEYnNRyjUyIk656JyfYUVFNTI06YMEF85513ur3+3HPPiQUFBeJPfvITsaOjQ3n91VdfFS0WS7cLFmmPx+MR7733XnH58uXiu+++K15zzTViTk5Ot5vorjfSmzdvFq+//npx9OjRvFGhmPAcROHwHESpqKWlRVy4cKF4yy23iJ2dnaIoiuKzzz4rjhs3Trz44ovFtWvXKtt2vYHOzMzkQ0eNO3z4sDh9+nRx2LBhosViEf/6179G3H7jxo3ibbfdJubk5Ihbt25N0F5SuuM9k37ws6ZweH9MicTzEIXD8xClGo7RSQ3H6JQoybpnYrI9xQQCAXH//v1icXGx+Prrr4uiKCoXJlEUxb/97W+iIAjiqlWrun3fkSNHErqflByffPKJ+I9//EMURWnm6rE30V25XC5x7dq1jA2KCc9BFAnPQZRqWltbxUmTJvUYpL399tvijBkzxCuvvFI8ePCg8vrq1avF4cOHixs3bkz0rlIC+Xw+8cknnxTPP/98ce3ateI999wjCoKgOpjfv3+/eNNNN4kTJkwQt2zZkuC9pXTFeyb94GdNkfD+mBKB5yGKhOchSiUco1M4HKNToiTznonJ9hR11VVXiaWlpWJFRYUoitJMRXkm4ne+8x3xxBNPFDs6OkSPx5PM3aQkO3DgQI+b6I6ODvHTTz/tdhIhihXPQRQNnoMomQKBgFhdXS1OnTpV/H//7/+Jotj9BvqNN94Qc3NzxT/96U/dvq+6ujqRu0lJsmnTJvHVV18VRVEU3W63ePfdd6sO5v1+v7hv3z7lmkcUC94z6Qc/a4oG749pIPE8RNHgeYiShWN0ioRjdEqkZNwzGfp/6XnqC1EUAQA33ngjxowZg4suuggVFRUwm83w+/0AgOHDh0MURdhsNpjN5mTuLiWJHCcjR47EbbfdhksuuQSXX345Vq5ciZ///Oc477zz0NbWluS9pHTEcxBFg+cgSgWCIKCoqAjnnnsufvGLX2Dv3r2wWq3weDwAgHPPPRfXXnstHn74YbhcLvh8PgBAUVFRMnebEqSsrAzLly8HAFgsFtx22224++678f3vfx9/+9vfAAButxtvv/02KisrMXr0aAwaNCiZu0xphvdM+sHPmqLB+2MaSDwPUTR4HqJk4xidIuEYnRIhmfdMTLanGEEQAACTJk3CLbfcAp/Ph7POOgsHDhyAyWQCANTX1yMrKwsdHR1K8JA+BAIBAFKceL1eAMCoUaPwk5/8BJdccgnOP/98PPPMM3jnnXeQn5+fzF2lNMVzEEXCcxClEvn8c9ttt+HEE0/EySefjIMHD8JisSixOnr0aDidTpjNZuUcRvqUkZGBW265RRnMP/300/jpT3+KK6+8EgYDh0QUO94z6Qc/a4qE98eUCDwPUSQ8D1Gq4BidYsExOg2EZN4z8YyWYvx+P4xGI1paWnD22WcjNzcXv/71rzFlyhQsWLAAALBu3Tp8+umnsNvtSd5bSiQ5Nmpra1FYWNht1s2IESPQ2NiInJwcfPbZZ5g0aVIS95TSGc9BpIbnIEo1giBAFEVkZ2fjgQcewE033YS5c+di5cqVmDJlCrKzs1FeXg673Q6PxwOLxZLsXaYECgQCygBdFEUIgoDMzEzceuutEEURV199NXJycrB69WrOlqe48J5JP/hZkxreH1Oi8DxEangeolTCMTpFwjE6JUIy75k4RSSFeDweGI1GHDx4ELm5ufjLX/6CBQsW4N///jceffRRlJWV4fjjj8f69esxffr0ZO8uJVDX2CgtLcWTTz6pvBcIBPDnP/8Z7777Lj744APePFNURFHsMXOL5yACeo8NnoMoVfj9fgiCgPr6ehQXF+PPf/4zTjvtNJx00klYuHAhFi5ciGeeeQaPP/44srKykr27lEB+vx8GgwHV1dWorq5WZjYDgNVqxcGDB5GTk4PPP/8cc+bMSeKeUrry+Xy8Z9IJ3h+TGt4f00DgOJ3UcJxO6YBjdFLDMTolQrLH6YLI3kIJt3v3bjz33HM4cuQIysrKcPLJJysf7qFDh3DcccfhvPPOw+OPPw6j0ZjkvaVEijY2nnjiiW7tVNatW4fCwkKMHj06WbtOaWTXrl147LHHcOTIEcycOROnnHIKTjzxRAA8B+ldtLHBcxAlmzwj+uDBgxg/fjx+85vf4IYbbgAArFy5EgcPHgQALFu2DGPGjEnmrlKCdY2NiRMn4r777sPNN98MQHpI+corr+C6667De++9h1mzZiV5bynV7d+/H88//zwOHDiAuXPn4vLLL4fD4QAAVFRUYNasWbxn0giO0UkNx+iUKBynkxqO0ykdcIxOajhGp/6WquN0JtsTbMeOHViwYAFOO+005OXlYdWqVSguLsZVV12FH/zgB/jb3/6Gffv24de//rUyw0duq0HaFk9sEMXqq6++wrx583DqqaeioKAA77//PoqKinDGGWfgrrvuwjPPPIO9e/fyHKRD8cQG0UCrrKxEY2Nj2EqMqqoqTJs2DcuXL8cTTzzBh446E21sPPnkk90eOn711VfIzMzE0KFDE7m7lIbKy8txxhlnYMaMGTAYDHj33Xfxox/9CL///e8hiiL+8Ic/oKqqCvfeey/vmdIcx+ikhmN0ShSO00kNx+mUajhGJzUco1MipPI4ncn2BGpra8Py5ctRVlaGBx98EIA0A3HGjBmwWq24/fbb8eMf/zjJe0nJwNigRPD7/bjllltQX1+Pf/zjHwCAo0eP4vHHH8fbb7+NCy+8EHfeeWeS95KSgbFBqWjXrl2YPXs25syZgz/96U+YMGECgNBN8htvvIE9e/bgJz/5CR8s6QxjgwbakSNHsHjxYixbtgwPP/wwAGD16tU477zz8Nlnn2HGjBnd1hyk9MVxGKlhbFCicCxGahgblGo4DiM1jA1KhFQfp5uS8q/qlCAIaGxsRFlZGQCgo6MDw4YNwymnnIKmpia89NJLGD9+PJYsWZLkPaVEY2xQIhiNRhw6dAh+v195rbS0FDfffDNsNhveeOMNFBUV4ZprrkniXlIyMDYo1dTW1uKaa67B4sWL8eWXX+Laa6/FH/7wB0ycOFEZmJ177rkcpOkQY4MGmiiKeOuttzB8+HDceuutAKS136ZNm4bBgwejs7MTAJho1wiOw0gNY4MShWMxUsPYoFTCcRipYWxQIqTDOJ1PCBJEFEW0trbi8OHDqKysBADY7XYcPnwYX331FS6//HK4XC688cYbSd5TSjTGBiWC3MRk1qxZaG9vx6FDh5T3ioqKcNVVV2HChAlYuXIl3G53snaTkoCxQano66+/xsiRI3H33Xdjw4YN2L17N6677jrs2rVL2abrQI2NmvSDsUEDTRAEHHfccSgrK0NxcTEAwGQyoaSkBCaTSblfp/THcRipYWxQonAsRmoYG5RqOA4jNYwNSoS0GKeLlFC/+93vREEQxKuuukq88847xaysLPHqq68WRVEUX375ZXHUqFFiQ0OD6Pf7k7ynlGiMDUqEL7/8UszKyhJ/9rOfiZ2dnaIoimIgEBBFURQ3bdokCoIgrl27Npm7SEnC2KBU0tzcLG7YsEG55h05ckQsKSkRTzrpJHHnzp3Kdj6fL1m7SEnC2KCBFAgElGtf19dkkyZNEl966SXlzytXrhTLy8sTtn80MDgOIzWMDUoUjsVIDWODUgXHYaSGsUEDLV3G6WwjP4C++eYbrF27FtXV1TjppJMwduxY3HzzzcjMzMRf/vIX5Ofn44477sBPf/pTAEB1dTWcTidyc3OTvOc00BgblAjNzc0wGAzIzs5WZg3OmTMHf/7zn3HZZZfBbrfjxhtvhMPhAADk5uZi8uTJsNvtydxtSgDGBqU6h8OBWbNmAQA8Hg9KS0uxceNGzJo1C9dddx3+8Ic/YPTo0XjkkUdQWlqKFStWJHmPKVEYGzQQwl0XZYIgwOfzwWAwwG63w+l0AgB+/vOf4+GHH8a+ffuSsMcUL47DSA1jgxKFYzFSw9igVMZxGKlhbNBASbdxOpPtA6S8vBynnHIKJk6ciPLycjz99NOYOHEinnzySfzgBz/ApZdeCovFAqvVqnzP3r17MXr0aHR2dsJqtXIdC41ibFAi7Ny5E9/5znewYsUKfPe734XD4UAgEAAAXHLJJXC5XLj66qtx5MgRnHfeeZgyZQqeeuopNDc3o6ioKMl7TwOJsUGp6Ngb6K7XOYvFAp/Ph8GDB2PTpk2YOXMmfvjDHyI/Px9vvvkmtmzZkrwdpwHH2KCBFu66eCyj0QgAymD+V7/6FR577DGsXbsWw4cPT/QuU5w4DiM1jA1KFI7FSA1jg1INx2GkhrFBiZCW4/SE19LrQFtbm7hgwQLxhz/8odjR0SF6vV7xz3/+s7hgwQJx6tSpYmVlpSiKotJaY9euXeKNN94oOhwOcdu2bcncdRpgjA1KhIMHD4rTpk0T8/LyxMmTJ4tPPfWU2NzcLIpi9xYrq1atEufMmSOWlJSI48ePF0eMGCFu2rQpWbtNCcDYoFS0Y8cOcc6cOeIjjzyixGM4csuxb775RhQEQczLy2NcahxjgwZapOtiOPPnzxfHjx8vWq1Wcf369QncU+orjsNIDWODEoVjMVLD2KBUw3EYqWFsUCKk6zjdkPj0vvZ1dHSgrq4OJ598Mmw2G0wmE7773e/i3nvvhcPhwPLly9HY2AiDwYCmpiasXr0aW7Zswccff4ypU6cme/dpADE2aKAFAgGsWbMGQ4YMwdq1azFv3jw8/PDDePnll9HS0gJBEBAIBBAIBHDmmWfirbfewvvvv4+///3vWLduHcrKypL9I9AAYWxQKjp06BAuueQS7N+/H3/5y1+UeAzHaDSio6MDv/vd75CZmYlPP/2UcalhjA0aaL1dFwEoreoCgQBaW1tRWVmJffv2YcOGDZg9e3Yyd59ixHEYqWFsUCJwLEZqGBuUajgOIzWMDUqEtB6nJy3Nr2Eej0ecN2+eeMstt3R7PRAIiO+88444d+5c8Z577lFmJ9bV1YkNDQ3J2FVKMMYGJcKePXvEN998U/nz9773PXHMmDHiU089JTY1NYmiKFVmdJ0hTfrA2KBU4vf7xaefflpcunSpuHv37m7xGK6SQxRFce/eveLcuXPFL774Ihm7TAnC2KBEiea6KIqhePvggw9YyZqmOA4jNYwNShSOxUgNY4NSBcdhpIaxQYmUruN0JtsHgN/vF2+99VZx7ty54ieffNLj/auvvlo84YQTeJOkQ4wNSpZwN0HPPfdcxBYspA+MDUqmaG+gZZ2dnWJbW1sid5GShLFByRLuuvjss88yuZbmOA4jNYwNSiaOxUgNY4OSheMwUsPYoGRKh3G6IIrBmnvqV01NTVi4cCGysrLwxBNPYMaMGTAajQCAf/3rX7jnnnvwv//9D7m5uUneU0o0xgYlkt/vV+Lr+9//Pj7++GPccsst2LBhA1auXImNGzdi+PDhSd5LSgbGBqUqOR5vu+02XHzxxXA4HPjHP/6Bc845Bzk5OcnePUoixgYNJF4XtY/jMFLD2KBE4zWH1DA2KBVxHEZqGBs00NLpushk+wDweDywWCyoq6vD/PnzUVhYiJtuugnnnnsuTCYTfvzjH2Pr1q149913kZGRkezdpQRibFAiBAIBGAwG5c9erxdmsxkAcNVVV+Gvf/0rMjMz8fHHH2PmzJnJ2k1KAsYGpbJ0uoGmxGJs0EDhdVE/OA4jNYwNShRec0gNY4NSFcdhpIaxQQMpXa+Lht43oUiOnavg9/thsVhQUVGBlpYWrF+/HllZWbj//vsxfPhwLFmyBM8//zwee+wxDtQ0jrFBiRAuzgwGA2pra/H5558DAMxmM/x+PwAgMzMTubm5+OKLL1LqYkT9j7FB6SAQCCj/bzQa4fV6AQBPP/00TjrpJFx33XX45z//idWrV3OgpjOMDepvvC7qB8dhpIaxQYnCaw6pYWxQquM4jNQwNmggaOm6yGR7nHw+H4BQMAQCAfh8PhiNRhw8eBBz5szBO++8A6fTiTfeeAOPPfYYfvSjH+Giiy7C+vXrMWPGjCTuPQ0kxgYlQm9xNmPGDGzbtk3Z3mg04qWXXsJjjz2G1atXY9KkSUnZbxp4jA1KVVq6gab+xdiggcTron5wHEZqGBuUKLzmkBrGBqUijsNIDWODBpoWr4tsIx+HXbt24fHHH0dtbS0GDx6Miy++GPPnzwcAHD16FOPHj8dll12GP/7xjxBFsVvLA9I2xgYlQixxJgiC8n1utxs1NTUYOnRosnadBhhjg1KRz+eDyWRS2kAFAgEEAgGYTCYcPHgQxx9/PH75y1/immuuUb7npZdewooVK7B+/XrMmjUriXtPA4mxQQON10X94DiM1DA2KFF4zSE1jA1KNRyHkRrGBiWCVq+LHEXEaMeOHTjhhBMgiiIKCwtRXV2NRYsW4emnn0Z7ezuqqqpw/fXX4w9/+AMEQeBATUcYG5QIscZZV1arNWUvRtR3jA1KRbt27cKPf/xjXHDBBbjpppuwdu1aGAwGmEwmHD16FJMnT8bZZ5+NH/zgB92+7/zzz8fBgwc5UNMwxgYNNF4X9YPjMFLD2KBE4TWH1DA2KNVwHEZqGBuUCFq+LrKyPQZutxsrVqzA4MGD8dhjjwEAKisrccopp+DAgQO4//77ccstt0AUxR6BQNrG2KBEYJyRGsYGpaIdO3Zg4cKFuOiiiyAIAhoaGvDaa6/hj3/8Iy699FLs2rUL//rXv/DAAw/w4bbOMDZooPG6qB/8rEkNY4MShbFGahgblGo4DiM1jA1KBK1fF03J3oF04vV6sXfvXpx++ukApLYagwYNwgknnIBRo0bhtttuw4QJE7Bs2bIk7yklGmODEoFxRmoYG5Rq3G437rrrLlx22WXdbqC3bt2K66+/Hs3Nzbjlllswc+bMtLyBpvgxNigReF3UD37WpIaxQYnCWCM1jA1KJRyHkRrGBiWK1q+LnIYSA6vViuHDh2P9+vVoaWlR1qr497//jRtvvBFXXnklHnjgAbS3tyd7VynBGBuUCIwzUsPYoFQj30BPnjwZQPcb6NNOOw233XYb3nnnHQ7UdIixQYnA66J+8LMmNYwNShTGGqlhbFAq4TiM1DA2KFG0fl1ksj0KgUAAAGA2m3Hqqadix44dOOuss/Dzn/8ckydPxre//W2cfvrpWLJkCY4ePQqv15vkPaZEYWxQIjDOSA1jg1KV1m+gKX6MDRpIvC7qBz9rUsPYoERhrJEaxgalIo7DSA1jgwaaXq6LbCMfQVNTE5xOJwwGA3w+H0wmE2644Qbk5ubiww8/xJ49e/DrX/8aN9xwAwDpxORwOJK815QIjA1KBMYZqWFsUKoKBAIwGAzKDfTLL7+Ms846CwsWLMBjjz2Gyy+/HKeffjrq6+vx0Ucfpe0NNMWOsUEDiddF/eBnTWoYG5QojDVSw9igVMRxGKlhbNBA09t1URBFUUz2TqSiXbt2YdmyZbjssstw7733AgA8Hg8sFouyjdfrhdlsVv587bXX4sCBA1i5ciXsdnvC95kSg7FBicA4IzWMDUpF8g00AOUGGgCee+45fPjhh2hra8PChQuVG+g33ngDd999Nz755BPk5OQka7cpARgbNNB4XdQPftakhrFBicJYIzWMDUo1HIeRGsYGJYIer4usbA/j8OHDuPTSS2EymfDGG2/AZDLhzjvvhMVi6XYCkr9+/vnnePHFF/Hiiy/i008/TctAoOgwNigRGGekhrFBqejYG2iTyaTcQF9xxRW44ooretxAr169GiUlJd1uskl7GBs00Hhd1A9+1qSGsUGJwlgjNYwNSjUch5EaxgYlgl6vi0y2H0MURbz00ksYPHgwbrzxRnz22Wd46aWXAAB33nknTCYT/H4/jEYjBEFAIBBAXV0dNm3ahE8++QTTpk1L8k9AA4WxQYnAOCM1jA1KRXq9gabeMTZooPG6qB/8rEkNY4MShbFGahgblGo4DiM1jA1KBD1fF5lsP4YgCLjiiitQXFyM008/HdOnTwcAvPTSSxBFEXfddReMRqOypoXBYMA555yDk08+GdnZ2UneexpIjA1KBMYZqWFsUKrR8w00RcbYoETgdVE/+FmTGsYGJQpjjdQwNiiVcBxGahgblCi6vi6K1KuKigrxrrvuEidMmCDefffdyutvvPGG6PP5krhnlGyMDUoExhmpYWxQslVWVorPPvusKIqiWF1dHTYe/X5/t+9paWlJ6D5ScjA2KBl4XdQPftakhrFBicJYIzWMDUomjsNIDWODkkUv10VWtgOorKzE4cOH0djYiNNOOw1GoxEAEAgEIAgCBg0ahKuvvhoA8PLLL0MURTQ3N+PRRx/FkSNHMHjw4GTuPg0gxgYlAuOM1DA2KNWVlJTgyiuvBAAUFRXhBz/4AQApHgHgrrvugsFgwMqVK3H22WfDaDSm/0xVigpjgwYCr4v6wc+a1DA2KFEYa6SGsUGpjOMwUsPYoIHC66JE98n2bdu24ZxzzoHVakV1dTUGDRqEO++8E0uWLEFeXh4CgQAAYPDgwfjBD34AURRx7733wul0Yv369ZoJBOqJsUGJwDgjNYwNSkW8gSY1jA0aaLwu6gc/a1LD2KBEYayRGsYGpRqOw0gNY4MSgdfFLhJXRJ96ampqxAkTJog///nPxf3794tHjx4VL7roInHixIniXXfdJdbU1IiiKIqBQED5nssvv1x0OBzijh07krXblACMDUoExhmpYWxQKtq6das4fPhwcdy4cWJOTo44YcIE8cUXXxTr6+tFUZTajckxWVFRId55552iIAhibm6uuGHDhmTuOg0wxgYNNF4X9YOfNalhbFCiMNZIDWODUg3HYaSGsUGJwOtid7pOtu/YsUMcMWJEjxPIT3/6U3Hq1KniQw89JLpcLuX1p59+WnQ6neKmTZsSvauUYIwNSgTGGalhbFCq4Q00qWFsUCLwuqgf/KxJDWODEoWxRmoYG5RKOA4jNYwNShReF7szJLuyPpm8Xi98Ph/a29sBAB0dHQCABx98ECeffDL++Mc/Yt++fcr2Z511FjZt2oSysrKk7C8lDmODEoFxRmoYG5Rqamtr0dnZifPPPx+jRo3C4MGD8fLLL+Occ87B66+/jmeffRbt7e0QBAEA8Ne//hVvvfUWPvroI0yaNCnJe08DibFBicDron7wsyY1jA1KFMYaqWFsUCrhOIzUMDYoUXhd7E4QRVFM9k4k09y5c5GVlYUPP/wQAOB2u2G1WgEAc+bMwZgxY/DSSy/B7/cr61qQPjA2KBEYZ6SGsUGpZOvWrTjrrLPw4osvYuHChejo6IDdbgcA3HDDDXjrrbewcuVKTJs2DQBQXV2N9vZ2jBw5Mpm7TQnA2KBE4XVRP/hZkxrGBiUKY43UMDYoVXAcRmoYG5RIvC6G6Kqy3eVyobW1FS0tLcprTz31FHbs2IFLL70UAGC1WuHz+QAAixYtgsvlAgDNB4LeMTYoERhnpIaxQalu+vTpGDRoEO666y4AgN1uh9vtBgA8+uijyM/PxwMPPAAA8Pv9KC4u5kBNJxgbNBB4XdQPftakhrFBicJYIzWMDUplHIeRGsYGDRReFyPTTbJ9586dOP/883HiiSdi4sSJeOGFFwAAEydOxKOPPoo1a9bgggsugNfrhcEgHZaamhpkZmbC5/NB5w0ANI2xQYnAOCM1jA1KRbyBJjWMDRpovC7qBz9rUsPYoERhrJEaxgalGo7DSA1jgxKB18XemZK9A4mwc+dOLFq0CFdccQVmz56NjRs34rvf/S4mTZqEsrIynHPOOcjMzMR1112HadOmYcKECbBYLHjnnXewbt06mEy6OEy6xNigRGCckRrGBqWinTt34qabbkJtbS2qq6vx0EMPYcWKFcoN9I9+9CNccMEFePHFF5WBWdcbaKPRqKz9RdrC2KCBxuuifvCzJjWMDUoUxhqpYWxQquE4jNQwNigReF2MjubXbG9oaMAll1yCCRMm4NFHH1VeP/nkkzF16lQ89thjymutra2477770NDQAJvNhmuvvRaTJk1Kxm5TAjA2KBEYZ6SGsUGpKNwN9OOPP44vvvgCZWVlaG9vxwcffIDrrrsOWVlZPW6gp0yZkuwfgQYIY4MGGq+L+sHPmtQwNihRGGukhrFBqYbjMFLD2KBE4HUxepqfUuD1etHU1IRvf/vbAIBAIACDwYCRI0eioaEBACCKIkRRRHZ2Nn7zm9902460i7FBicA4IzWMDUo1DQ0NuOmmm7BixQr8/ve/BwBceuml2LRpE5555hmUlZUhIyMDZ599Nk466aRuN9Bffvmlrm6g9YaxQYnA66J+8LMmNYwNShTGGqlhbFAq4TiM1DA2KFF4XYye5pPtxcXFeP755zF27FgAgN/vh8FgQGlpKQ4ePAgAEAQBgiCgpaUFDodDeY20jbFBicA4IzWMDUo1vIEmNYwNSgReF/WDnzWpYWxQojDWSA1jg1IJx2GkhrFBicLrYvR08ZslB0IgEIDZbAYgnWxqamqUbR544AE8/fTT8Pl8APQZDHrE2KBEYJyRGsYGpRL5BnrhwoUApBtoACgtLVUGY4IgwGAwoKWlRfk+xqT2MTYoUXhd1A9+1qSGsUGJwlgjNYwNShUch5EaxgYlEq+L0dF8ZXtXBoMBoigqH7R84rnzzjtx3333YfPmzTCZdHVIKIixQYnAOCM1jA1KFdHeQFutVvz4xz+GyWTS5Q20HjE2KJF4XdQPftakhrFBicJYIzWMDUoFHIeRGsYGJRqvi5Hp7ieXg8FkMmHo0KH47W9/i4ceeggbNmzA9OnTk717lESMDUoExhmpYWxQKuENNKlhbFCi8LqoH/ysSQ1jgxKFsUZqGBuUKjgOIzWMDUokXhfV6e63TD7ZmM1m/OUvf4HD4cD//vc/zJw5M8l7RsnG2KBEYJyRGsYGpRreQJMaxgYlAq+L+sHPmtQwNihRGGukhrFBqYTjMFLD2KBE4XVRnS7WbA9nyZIlAIDPP/8cs2fPTvLeUCphbFAiMM5IDWODUsWxN9D33Xcfb6AJAGODEovXRf3gZ01qGBuUKIw1UsPYoFTAcRipYWxQovG62JMgiqKY7J1IFpfLhczMzGTvBqUgxgYlAuOM1DA2KJVs2LABc+fOxfbt2zFp0qRk7w6lEMYGJQqvi/rBz5rUMDYoURhrpIaxQamC4zBSw9igROJ1sTtdJ9uJiIiIqHe8gSY1jA0iIiIiIqLE4jiM1DA2iJKDyXYiIiIiIiIiIiIiIiIiIqIY6XbNdiIiIiIiIiIiIiIiIiIiongx2U5ERERERERERERERERERBQjJtuJiIiIiIiIiIiIiIiIiIhixGQ7ERERERERERERERERERFRjJhsJyIiIiIiIiIiIiIiIiIiihGT7URERERERERERERERERERDFisp2IiIiIiIiIiIiIiIiIiChGTLYTERERERERERERERERERHFiMl2IiIiIiIiIiIiIiIiIiKiGP1/QBdFJr3g6acAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -744,9 +744,9 @@ { "data": { "text/plain": [ - "{'segment_d': 18.20146757117957,\n", + "{'segment_c': 25.23759225436336,\n", " 'segment_b': 4.828671629496564,\n", - " 'segment_c': 25.23759225436336,\n", + " 'segment_d': 18.20146757117957,\n", " 'segment_a': 8.73107925541017}" ] }, @@ -778,7 +778,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -805,9 +805,9 @@ { "data": { "text/plain": [ - "{'segment_d': 11.162075802124274,\n", + "{'segment_c': 18.357231604941372,\n", " 'segment_b': 4.703408652853966,\n", - " 'segment_c': 18.357231604941372,\n", + " 'segment_d': 11.162075802124274,\n", " 'segment_a': 5.587809488492237}" ] }, diff --git a/poetry.lock b/poetry.lock index 5d48c599a..736ea5126 100644 --- a/poetry.lock +++ b/poetry.lock @@ -718,7 +718,7 @@ python-versions = ">=3.7" [[package]] name = "fsspec" -version = "2022.11.0" +version = "2023.1.0" description = "File-system specification" category = "main" optional = true @@ -1409,29 +1409,30 @@ python-versions = ">=3.7" [[package]] name = "mypy" -version = "0.910" +version = "0.950" description = "Optional static typing for Python" category = "main" optional = true -python-versions = ">=3.5" +python-versions = ">=3.6" [package.dependencies] -mypy-extensions = ">=0.4.3,<0.5.0" -toml = "*" -typed-ast = {version = ">=1.4.0,<1.5.0", markers = "python_version < \"3.8\""} -typing-extensions = ">=3.7.4" +mypy-extensions = ">=0.4.3" +tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""} +typed-ast = {version = ">=1.4.0,<2", markers = "python_version < \"3.8\""} +typing-extensions = ">=3.10" [package.extras] dmypy = ["psutil (>=4.0)"] -python2 = ["typed-ast (>=1.4.0,<1.5.0)"] +python2 = ["typed-ast (>=1.4.0,<2)"] +reports = ["lxml"] [[package]] name = "mypy-extensions" -version = "0.4.3" -description = "Experimental type system extensions for programs checked with the mypy typechecker." +version = "1.0.0" +description = "Type system extensions for programs checked with the mypy type checker." category = "main" optional = true -python-versions = "*" +python-versions = ">=3.5" [[package]] name = "myst-parser" @@ -3303,7 +3304,7 @@ wandb = ["wandb"] [metadata] lock-version = "1.1" python-versions = ">=3.7.1, <3.11.0" -content-hash = "78cfffbb71287b0db8af81005d304cbb6e63ed0b725970863bc5800410b70829" +content-hash = "463b30bacf7ec13ce5181b21a964f0abac9112aed2f5769192c78bcd90c9eec3" [metadata.files] absl-py = [ @@ -3838,8 +3839,8 @@ frozenlist = [ {file = "frozenlist-1.3.3.tar.gz", hash = "sha256:58bcc55721e8a90b88332d6cd441261ebb22342e238296bb330968952fbb3a6a"}, ] fsspec = [ - {file = "fsspec-2022.11.0-py3-none-any.whl", hash = "sha256:d6e462003e3dcdcb8c7aa84c73a228f8227e72453cd22570e2363e8844edfe7b"}, - {file = "fsspec-2022.11.0.tar.gz", hash = "sha256:259d5fd5c8e756ff2ea72f42e7613c32667dc2049a4ac3d84364a7ca034acb8b"}, + {file = "fsspec-2023.1.0-py3-none-any.whl", hash = "sha256:b833e2e541e9e8cde0ab549414187871243177feb3d344f9d27b25a93f5d8139"}, + {file = "fsspec-2023.1.0.tar.gz", hash = "sha256:fbae7f20ff801eb5f7d0bedf81f25c787c0dfac5e982d98fa3884a9cde2b5411"}, ] gitdb = [ {file = "gitdb-4.0.9-py3-none-any.whl", hash = "sha256:8033ad4e853066ba6ca92050b9df2f89301b8fc8bf7e9324d412a63f8bf1a8fd"}, @@ -4199,33 +4200,33 @@ mistune = [ ] multidict = [] mypy = [ - {file = "mypy-0.910-cp35-cp35m-macosx_10_9_x86_64.whl", hash = "sha256:a155d80ea6cee511a3694b108c4494a39f42de11ee4e61e72bc424c490e46457"}, - {file = "mypy-0.910-cp35-cp35m-manylinux1_x86_64.whl", hash = "sha256:b94e4b785e304a04ea0828759172a15add27088520dc7e49ceade7834275bedb"}, - {file = "mypy-0.910-cp35-cp35m-manylinux2010_x86_64.whl", hash = "sha256:088cd9c7904b4ad80bec811053272986611b84221835e079be5bcad029e79dd9"}, - {file = "mypy-0.910-cp35-cp35m-win_amd64.whl", hash = "sha256:adaeee09bfde366d2c13fe6093a7df5df83c9a2ba98638c7d76b010694db760e"}, - {file = "mypy-0.910-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:ecd2c3fe726758037234c93df7e98deb257fd15c24c9180dacf1ef829da5f921"}, - {file = "mypy-0.910-cp36-cp36m-manylinux1_x86_64.whl", hash = "sha256:d9dd839eb0dc1bbe866a288ba3c1afc33a202015d2ad83b31e875b5905a079b6"}, - {file = "mypy-0.910-cp36-cp36m-manylinux2010_x86_64.whl", hash = "sha256:3e382b29f8e0ccf19a2df2b29a167591245df90c0b5a2542249873b5c1d78212"}, - {file = "mypy-0.910-cp36-cp36m-win_amd64.whl", hash = "sha256:53fd2eb27a8ee2892614370896956af2ff61254c275aaee4c230ae771cadd885"}, - {file = "mypy-0.910-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:b6fb13123aeef4a3abbcfd7e71773ff3ff1526a7d3dc538f3929a49b42be03f0"}, - {file = "mypy-0.910-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:e4dab234478e3bd3ce83bac4193b2ecd9cf94e720ddd95ce69840273bf44f6de"}, - {file = "mypy-0.910-cp37-cp37m-manylinux2010_x86_64.whl", hash = "sha256:7df1ead20c81371ccd6091fa3e2878559b5c4d4caadaf1a484cf88d93ca06703"}, - {file = "mypy-0.910-cp37-cp37m-win_amd64.whl", hash = "sha256:0aadfb2d3935988ec3815952e44058a3100499f5be5b28c34ac9d79f002a4a9a"}, - {file = "mypy-0.910-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:ec4e0cd079db280b6bdabdc807047ff3e199f334050db5cbb91ba3e959a67504"}, - {file = "mypy-0.910-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:119bed3832d961f3a880787bf621634ba042cb8dc850a7429f643508eeac97b9"}, - {file = "mypy-0.910-cp38-cp38-manylinux2010_x86_64.whl", hash = "sha256:866c41f28cee548475f146aa4d39a51cf3b6a84246969f3759cb3e9c742fc072"}, - {file = "mypy-0.910-cp38-cp38-win_amd64.whl", hash = "sha256:ceb6e0a6e27fb364fb3853389607cf7eb3a126ad335790fa1e14ed02fba50811"}, - {file = "mypy-0.910-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:1a85e280d4d217150ce8cb1a6dddffd14e753a4e0c3cf90baabb32cefa41b59e"}, - {file = "mypy-0.910-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:42c266ced41b65ed40a282c575705325fa7991af370036d3f134518336636f5b"}, - {file = "mypy-0.910-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:3c4b8ca36877fc75339253721f69603a9c7fdb5d4d5a95a1a1b899d8b86a4de2"}, - {file = "mypy-0.910-cp39-cp39-manylinux2010_x86_64.whl", hash = "sha256:c0df2d30ed496a08de5daed2a9ea807d07c21ae0ab23acf541ab88c24b26ab97"}, - {file = "mypy-0.910-cp39-cp39-win_amd64.whl", hash = "sha256:c6c2602dffb74867498f86e6129fd52a2770c48b7cd3ece77ada4fa38f94eba8"}, - {file = "mypy-0.910-py3-none-any.whl", hash = "sha256:ef565033fa5a958e62796867b1df10c40263ea9ded87164d67572834e57a174d"}, - {file = "mypy-0.910.tar.gz", hash = "sha256:704098302473cb31a218f1775a873b376b30b4c18229421e9e9dc8916fd16150"}, + {file = "mypy-0.950-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:cf9c261958a769a3bd38c3e133801ebcd284ffb734ea12d01457cb09eacf7d7b"}, + {file = "mypy-0.950-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b5b5bd0ffb11b4aba2bb6d31b8643902c48f990cc92fda4e21afac658044f0c0"}, + {file = "mypy-0.950-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5e7647df0f8fc947388e6251d728189cfadb3b1e558407f93254e35abc026e22"}, + {file = "mypy-0.950-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:eaff8156016487c1af5ffa5304c3e3fd183edcb412f3e9c72db349faf3f6e0eb"}, + {file = "mypy-0.950-cp310-cp310-win_amd64.whl", hash = "sha256:563514c7dc504698fb66bb1cf897657a173a496406f1866afae73ab5b3cdb334"}, + {file = "mypy-0.950-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:dd4d670eee9610bf61c25c940e9ade2d0ed05eb44227275cce88701fee014b1f"}, + {file = "mypy-0.950-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ca75ecf2783395ca3016a5e455cb322ba26b6d33b4b413fcdedfc632e67941dc"}, + {file = "mypy-0.950-cp36-cp36m-win_amd64.whl", hash = "sha256:6003de687c13196e8a1243a5e4bcce617d79b88f83ee6625437e335d89dfebe2"}, + {file = "mypy-0.950-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:4c653e4846f287051599ed8f4b3c044b80e540e88feec76b11044ddc5612ffed"}, + {file = "mypy-0.950-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:e19736af56947addedce4674c0971e5dceef1b5ec7d667fe86bcd2b07f8f9075"}, + {file = "mypy-0.950-cp37-cp37m-win_amd64.whl", hash = "sha256:ef7beb2a3582eb7a9f37beaf38a28acfd801988cde688760aea9e6cc4832b10b"}, + {file = "mypy-0.950-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:0112752a6ff07230f9ec2f71b0d3d4e088a910fdce454fdb6553e83ed0eced7d"}, + {file = "mypy-0.950-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:ee0a36edd332ed2c5208565ae6e3a7afc0eabb53f5327e281f2ef03a6bc7687a"}, + {file = "mypy-0.950-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:77423570c04aca807508a492037abbd72b12a1fb25a385847d191cd50b2c9605"}, + {file = "mypy-0.950-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:5ce6a09042b6da16d773d2110e44f169683d8cc8687e79ec6d1181a72cb028d2"}, + {file = "mypy-0.950-cp38-cp38-win_amd64.whl", hash = "sha256:5b231afd6a6e951381b9ef09a1223b1feabe13625388db48a8690f8daa9b71ff"}, + {file = "mypy-0.950-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:0384d9f3af49837baa92f559d3fa673e6d2652a16550a9ee07fc08c736f5e6f8"}, + {file = "mypy-0.950-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:1fdeb0a0f64f2a874a4c1f5271f06e40e1e9779bf55f9567f149466fc7a55038"}, + {file = "mypy-0.950-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:61504b9a5ae166ba5ecfed9e93357fd51aa693d3d434b582a925338a2ff57fd2"}, + {file = "mypy-0.950-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:a952b8bc0ae278fc6316e6384f67bb9a396eb30aced6ad034d3a76120ebcc519"}, + {file = "mypy-0.950-cp39-cp39-win_amd64.whl", hash = "sha256:eaea21d150fb26d7b4856766e7addcf929119dd19fc832b22e71d942835201ef"}, + {file = "mypy-0.950-py3-none-any.whl", hash = "sha256:a4d9898f46446bfb6405383b57b96737dcfd0a7f25b748e78ef3e8c576bba3cb"}, + {file = "mypy-0.950.tar.gz", hash = "sha256:1b333cfbca1762ff15808a0ef4f71b5d3eed8528b23ea1c3fb50543c867d68de"}, ] mypy-extensions = [ - {file = "mypy_extensions-0.4.3-py2.py3-none-any.whl", hash = "sha256:090fedd75945a69ae91ce1303b5824f428daf5a028d2f6ab8a299250a846f15d"}, - {file = "mypy_extensions-0.4.3.tar.gz", hash = "sha256:2d82818f5bb3e369420cb3c4060a7970edba416647068eb4c5343488a6c604a8"}, + {file = "mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d"}, + {file = "mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"}, ] myst-parser = [ {file = "myst-parser-0.15.2.tar.gz", hash = "sha256:f7f3b2d62db7655cde658eb5d62b2ec2a4631308137bd8d10f296a40d57bbbeb"}, diff --git a/pyproject.toml b/pyproject.toml index dcab867e4..008fd47c8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -100,7 +100,7 @@ pep8-naming = {version = "^0.12.1", optional = true} flake8-bugbear = {version = "^22.4.25", optional = true} flake8-comprehensions = {version = "^3.9.0", optional = true} flake8-docstrings = {version = "^1.6.0", optional = true} -mypy = {version = "^0.910", optional = true} +mypy = {version = "^0.950", optional = true} types-PyYAML = {version = "^6.0.0", optional = true} codespell = {version = "^2.0.0", optional = true} @@ -269,6 +269,11 @@ markers = [ "long_2" ] +[tool.coverage.report] +exclude_lines = [ + '^ +assert_never\(.*?\)$', +] + [tool.mypy] ignore_missing_imports = true strict_optional = true diff --git a/tests/test_ensembles/test_direct_ensemble.py b/tests/test_ensembles/test_direct_ensemble.py index 031b8efdd..7edd6e320 100644 --- a/tests/test_ensembles/test_direct_ensemble.py +++ b/tests/test_ensembles/test_direct_ensemble.py @@ -9,6 +9,8 @@ from etna.models import NaiveModel from etna.pipeline import Pipeline from tests.test_pipeline.utils import assert_pipeline_equals_loaded_original +from tests.test_pipeline.utils import assert_pipeline_forecasts_given_ts +from tests.test_pipeline.utils import assert_pipeline_forecasts_given_ts_with_prediction_intervals @pytest.fixture @@ -67,5 +69,18 @@ def test_predict(direct_ensemble_pipeline, simple_ts_train): pd.testing.assert_frame_equal(prediction.to_pandas(), expected_prediction.to_pandas()) -def test_save_load(direct_ensemble_pipeline, example_tsds): - assert_pipeline_equals_loaded_original(pipeline=direct_ensemble_pipeline, ts=example_tsds) +@pytest.mark.parametrize("load_ts", [True, False]) +def test_save_load(load_ts, direct_ensemble_pipeline, example_tsds): + assert_pipeline_equals_loaded_original(pipeline=direct_ensemble_pipeline, ts=example_tsds, load_ts=load_ts) + + +def test_forecast_given_ts(direct_ensemble_pipeline, example_tsds): + assert_pipeline_forecasts_given_ts( + pipeline=direct_ensemble_pipeline, ts=example_tsds, horizon=direct_ensemble_pipeline.horizon + ) + + +def test_forecast_given_ts_with_prediction_interval(direct_ensemble_pipeline, example_tsds): + assert_pipeline_forecasts_given_ts_with_prediction_intervals( + pipeline=direct_ensemble_pipeline, ts=example_tsds, horizon=direct_ensemble_pipeline.horizon + ) diff --git a/tests/test_ensembles/test_stacking_ensemble.py b/tests/test_ensembles/test_stacking_ensemble.py index c10ae042c..e706ee6ee 100644 --- a/tests/test_ensembles/test_stacking_ensemble.py +++ b/tests/test_ensembles/test_stacking_ensemble.py @@ -15,6 +15,8 @@ from etna.metrics import MAE from etna.pipeline import Pipeline from tests.test_pipeline.utils import assert_pipeline_equals_loaded_original +from tests.test_pipeline.utils import assert_pipeline_forecasts_given_ts +from tests.test_pipeline.utils import assert_pipeline_forecasts_given_ts_with_prediction_intervals HORIZON = 7 @@ -138,7 +140,7 @@ def test_make_features( ensemble = StackingEnsemble( pipelines=[naive_featured_pipeline_1, naive_featured_pipeline_2], features_to_use=features_to_use ).fit(example_tsds) - x, y = ensemble._make_features(forecasts_ts, train=True) + x, y = ensemble._make_features(ts=example_tsds, forecasts=forecasts_ts, train=True) features = set(x.columns.get_level_values("feature")) assert isinstance(x, pd.DataFrame) assert isinstance(y, pd.Series) @@ -252,7 +254,7 @@ def test_forecast_calls_process_forecasts(example_tsds: TSDataset, naive_ensembl naive_ensemble.fit(ts=example_tsds) naive_ensemble._process_forecasts = MagicMock() - result = naive_ensemble._forecast() + result = naive_ensemble._forecast(ts=example_tsds) naive_ensemble._process_forecasts.assert_called_once() assert result == naive_ensemble._process_forecasts.return_value @@ -314,11 +316,24 @@ def test_backtest(stacking_ensemble_pipeline: StackingEnsemble, example_tsds: TS assert isinstance(df, pd.DataFrame) -def test_forecast_raise_error_if_not_fitted(naive_ensemble: StackingEnsemble): - """Test that StackingEnsemble raise error when calling forecast without being fit.""" - with pytest.raises(ValueError, match="StackingEnsemble is not fitted!"): +def test_forecast_raise_error_if_no_ts(naive_ensemble: StackingEnsemble): + """Test that StackingEnsemble raises error when calling forecast without ts.""" + with pytest.raises(ValueError, match="There is no ts to forecast!"): _ = naive_ensemble.forecast() -def test_save_load(stacking_ensemble_pipeline, example_tsds): - assert_pipeline_equals_loaded_original(pipeline=stacking_ensemble_pipeline, ts=example_tsds) +@pytest.mark.parametrize("load_ts", [True, False]) +def test_save_load(stacking_ensemble_pipeline, example_tsds, load_ts): + assert_pipeline_equals_loaded_original(pipeline=stacking_ensemble_pipeline, ts=example_tsds, load_ts=load_ts) + + +def test_forecast_given_ts(stacking_ensemble_pipeline, example_tsds): + assert_pipeline_forecasts_given_ts( + pipeline=stacking_ensemble_pipeline, ts=example_tsds, horizon=stacking_ensemble_pipeline.horizon + ) + + +def test_forecast_given_ts_with_prediction_interval(stacking_ensemble_pipeline, example_tsds): + assert_pipeline_forecasts_given_ts_with_prediction_intervals( + pipeline=stacking_ensemble_pipeline, ts=example_tsds, horizon=stacking_ensemble_pipeline.horizon + ) diff --git a/tests/test_ensembles/test_voting_ensemble.py b/tests/test_ensembles/test_voting_ensemble.py index 72d8d3d8a..d72f1dcc2 100644 --- a/tests/test_ensembles/test_voting_ensemble.py +++ b/tests/test_ensembles/test_voting_ensemble.py @@ -16,6 +16,8 @@ from etna.metrics import MAE from etna.pipeline import Pipeline from tests.test_pipeline.utils import assert_pipeline_equals_loaded_original +from tests.test_pipeline.utils import assert_pipeline_forecasts_given_ts +from tests.test_pipeline.utils import assert_pipeline_forecasts_given_ts_with_prediction_intervals HORIZON = 7 @@ -119,7 +121,7 @@ def test_vote_default_weights(simple_df: TSDataset, naive_pipeline_1: Pipeline, ensemble = VotingEnsemble(pipelines=[naive_pipeline_1, naive_pipeline_2]) ensemble.fit(ts=simple_df) forecasts = Parallel(n_jobs=ensemble.n_jobs, backend="multiprocessing", verbose=11)( - delayed(ensemble._forecast_pipeline)(pipeline=pipeline) for pipeline in ensemble.pipelines + delayed(ensemble._forecast_pipeline)(pipeline=pipeline, ts=simple_df) for pipeline in ensemble.pipelines ) forecast = ensemble._vote(forecasts=forecasts) np.testing.assert_array_equal(forecast[:, "A", "target"].values, [47.5, 48, 47.5, 48, 47.5, 48, 47.5]) @@ -131,7 +133,7 @@ def test_vote_custom_weights(simple_df: TSDataset, naive_pipeline_1: Pipeline, n ensemble = VotingEnsemble(pipelines=[naive_pipeline_1, naive_pipeline_2], weights=[1, 3]) ensemble.fit(ts=simple_df) forecasts = Parallel(n_jobs=ensemble.n_jobs, backend="multiprocessing", verbose=11)( - delayed(ensemble._forecast_pipeline)(pipeline=pipeline) for pipeline in ensemble.pipelines + delayed(ensemble._forecast_pipeline)(pipeline=pipeline, ts=simple_df) for pipeline in ensemble.pipelines ) forecast = ensemble._vote(forecasts=forecasts) np.testing.assert_array_equal(forecast[:, "A", "target"].values, [47.25, 48, 47.25, 48, 47.25, 48, 47.25]) @@ -143,7 +145,7 @@ def test_forecast_calls_vote(example_tsds: TSDataset, naive_pipeline_1: Pipeline ensemble.fit(ts=example_tsds) ensemble._vote = MagicMock() - result = ensemble._forecast() + result = ensemble._forecast(ts=example_tsds) ensemble._vote.assert_called_once() assert result == ensemble._vote.return_value @@ -197,5 +199,18 @@ def test_backtest(voting_ensemble_pipeline: VotingEnsemble, example_tsds: TSData assert isinstance(df, pd.DataFrame) -def test_save_load(voting_ensemble_pipeline, example_tsds): - assert_pipeline_equals_loaded_original(pipeline=voting_ensemble_pipeline, ts=example_tsds) +@pytest.mark.parametrize("load_ts", [True, False]) +def test_save_load(load_ts, voting_ensemble_pipeline, example_tsds): + assert_pipeline_equals_loaded_original(pipeline=voting_ensemble_pipeline, ts=example_tsds, load_ts=load_ts) + + +def test_forecast_given_ts(voting_ensemble_pipeline, example_tsds): + assert_pipeline_forecasts_given_ts( + pipeline=voting_ensemble_pipeline, ts=example_tsds, horizon=voting_ensemble_pipeline.horizon + ) + + +def test_forecast_given_ts_with_prediction_interval(voting_ensemble_pipeline, example_tsds): + assert_pipeline_forecasts_given_ts_with_prediction_intervals( + pipeline=voting_ensemble_pipeline, ts=example_tsds, horizon=voting_ensemble_pipeline.horizon + ) diff --git a/tests/test_loggers/test_file_logger.py b/tests/test_loggers/test_file_logger.py index b1603611e..ac4d7ea83 100644 --- a/tests/test_loggers/test_file_logger.py +++ b/tests/test_loggers/test_file_logger.py @@ -249,11 +249,12 @@ def test_local_file_logger_with_stacking_ensemble(example_df): assert len(list(cur_dir.iterdir())) == 1, "we've run one experiment" current_experiment_dir = list(cur_dir.iterdir())[0] - assert len(list(current_experiment_dir.iterdir())) == 2, "crossval and crossval_results folders" + assert len(list(current_experiment_dir.iterdir())) == 4, "training, forecasting, crossval, crossval_results" - assert ( - len(list((current_experiment_dir / "crossval").iterdir())) == n_folds - ), "crossval should have `n_folds` runs" + for folder in ["training", "forecasting", "crossval"]: + assert ( + len(list((current_experiment_dir / folder).iterdir())) == n_folds + ), f"{folder} should have `n_folds` runs" tslogger.remove(idx) @@ -281,11 +282,14 @@ def test_local_file_logger_with_empirical_prediction_interval(example_df): assert len(list(cur_dir.iterdir())) == 1, "we've run one experiment" current_experiment_dir = list(cur_dir.iterdir())[0] - assert len(list(current_experiment_dir.iterdir())) == 2, "crossval and crossval_results folders" - assert ( - len(list((current_experiment_dir / "crossval").iterdir())) == n_folds - ), "crossval should have `n_folds` runs" + len(list(current_experiment_dir.iterdir())) == 4 + ), "training, forecasting, crossval, crossval_results folders" + + for folder in ["training", "forecasting", "crossval"]: + assert ( + len(list((current_experiment_dir / folder).iterdir())) == n_folds + ), f"{folder} should have `n_folds` runs" tslogger.remove(idx) diff --git a/tests/test_models/nn/test_mlp.py b/tests/test_models/nn/test_mlp.py index 639305244..aed7f9448 100644 --- a/tests/test_models/nn/test_mlp.py +++ b/tests/test_models/nn/test_mlp.py @@ -24,7 +24,6 @@ ], ) def test_mlp_model_run_weekly_overfit_with_scaler(ts_dataset_weekly_function_with_horizon, horizon): - ts_train, ts_test = ts_dataset_weekly_function_with_horizon(horizon) lag = LagTransform(in_column="target", lags=list(range(horizon, horizon + 4))) fourier = FourierTransform(period=7, order=3) @@ -80,6 +79,17 @@ def test_mlp_make_samples(simple_df_relevance): np.testing.assert_equal(df[["target"]].iloc[decoder_length : 2 * decoder_length], second_sample["decoder_target"]) +def test_mlp_forward_fail_nans(): + batch = { + "decoder_real": torch.Tensor([[torch.nan, 2, 3], [1, 2, 3], [1, 2, 3]]), + "decoder_target": torch.Tensor([[1], [2], [3]]), + "segment": "A", + } + model = MLPNet(input_size=3, hidden_size=[1], lr=1e-2, loss=nn.MSELoss(), optimizer_params=None) + with pytest.raises(ValueError, match="There are NaNs in features"): + _ = model.forward(batch) + + def test_mlp_step(): batch = { @@ -96,6 +106,17 @@ def test_mlp_step(): assert output.shape == torch.Size([3, 1]) +def test_mlp_step_fail_nans(): + batch = { + "decoder_real": torch.Tensor([[torch.nan, 2, 3], [1, 2, 3], [1, 2, 3]]), + "decoder_target": torch.Tensor([[1], [2], [3]]), + "segment": "A", + } + model = MLPNet(input_size=3, hidden_size=[1], lr=1e-2, loss=nn.MSELoss(), optimizer_params=None) + with pytest.raises(ValueError, match="There are NaNs in features"): + _ = model.step(batch) + + def test_mlp_layers(): model = MLPNet(input_size=3, hidden_size=[10], lr=1e-2, loss=None, optimizer_params=None) model_ = nn.Sequential( diff --git a/tests/test_models/test_base.py b/tests/test_models/test_base.py index 9ae93dffc..824285962 100644 --- a/tests/test_models/test_base.py +++ b/tests/test_models/test_base.py @@ -14,6 +14,7 @@ @pytest.fixture() def deep_base_model_mock(): model = MagicMock() + model.encoder_length = 10 model.train_batch_size = 32 model.train_dataloader_params = {} model.val_dataloader_params = {} @@ -23,6 +24,13 @@ def deep_base_model_mock(): return model +@pytest.fixture() +def ts_mock(): + torch_dataset = MagicMock() + torch_dataset.index.__len__.return_value = 100 + return torch_dataset + + @pytest.fixture() def sized_torch_dataset_mock(): torch_dataset = MagicMock() @@ -138,15 +146,19 @@ def test_deep_base_model_raw_predict_call(dataloader, deep_base_model_mock): np.testing.assert_allclose(predictions_dict[("segment2", "target")], batch["target"][1].numpy()) -def test_deep_base_model_forecast_inverse_transform_call_check(deep_base_model_mock): - ts = MagicMock() +def test_deep_base_model_forecast_inverse_transform_call_check(deep_base_model_mock, ts_mock): horizon = 7 - DeepBaseModel.forecast(self=deep_base_model_mock, ts=ts, prediction_size=horizon) - ts.tsdataset_idx_slice.return_value.inverse_transform.assert_called_once() + DeepBaseModel.forecast(self=deep_base_model_mock, ts=ts_mock, prediction_size=horizon) + ts_mock.tsdataset_idx_slice.return_value.inverse_transform.assert_called_once() + + +def test_deep_base_model_forecast_fail_not_enough_context(deep_base_model_mock, ts_mock): + horizon = len(ts_mock.index) + with pytest.raises(ValueError, match="Given context isn't big enough"): + _ = DeepBaseModel.forecast(self=deep_base_model_mock, ts=ts_mock, prediction_size=horizon) -def test_deep_base_model_forecast_loop(simple_df, deep_base_model_mock): - ts = MagicMock() +def test_deep_base_model_forecast_loop(simple_df, deep_base_model_mock, ts_mock): ts_after_tsdataset_idx_slice = MagicMock() horizon = 7 @@ -154,13 +166,13 @@ def test_deep_base_model_forecast_loop(simple_df, deep_base_model_mock): deep_base_model_mock.raw_predict.return_value = raw_predict ts_after_tsdataset_idx_slice.df = simple_df.df.iloc[-horizon:] - ts.tsdataset_idx_slice.return_value = ts_after_tsdataset_idx_slice + ts_mock.tsdataset_idx_slice.return_value = ts_after_tsdataset_idx_slice - future = DeepBaseModel.forecast(self=deep_base_model_mock, ts=ts, prediction_size=horizon) + future = DeepBaseModel.forecast(self=deep_base_model_mock, ts=ts_mock, prediction_size=horizon) np.testing.assert_allclose( future.df.loc[:, pd.IndexSlice["A", "target"]], raw_predict[("A", "target")][:horizon, 0] ) np.testing.assert_allclose( future.df.loc[:, pd.IndexSlice["B", "target"]], raw_predict[("B", "target")][:horizon, 0] ) - ts.tsdataset_idx_slice.return_value.inverse_transform.assert_called_once() + ts_mock.tsdataset_idx_slice.return_value.inverse_transform.assert_called_once() diff --git a/tests/test_models/test_inference/common.py b/tests/test_models/test_inference/common.py index 3314ea9d2..e70775cc7 100644 --- a/tests/test_models/test_inference/common.py +++ b/tests/test_models/test_inference/common.py @@ -1,25 +1,10 @@ -import functools - import numpy as np -import pytest from typing_extensions import get_args from etna.datasets import TSDataset from etna.models import ContextRequiredModelType -def to_be_fixed(raises, match=None): - def to_be_fixed_concrete(func): - @functools.wraps(func) - def wrapped_test(*args, **kwargs): - with pytest.raises(raises, match=match): - return func(*args, **kwargs) - - return wrapped_test - - return to_be_fixed_concrete - - def make_prediction(model, ts, prediction_size, method_name) -> TSDataset: method = getattr(model, method_name) if isinstance(model, get_args(ContextRequiredModelType)): @@ -45,6 +30,8 @@ def _test_prediction_in_sample_full(ts, model, transforms, method_name): # checking forecast_df = forecast_ts.to_pandas(flatten=True) assert not np.any(forecast_df["target"].isna()) + original_target = TSDataset.to_flatten(df)["target"] + assert not forecast_df["target"].equals(original_target) def _test_prediction_in_sample_suffix(ts, model, transforms, method_name, num_skip_points): @@ -57,10 +44,12 @@ def _test_prediction_in_sample_suffix(ts, model, transforms, method_name, num_sk # forecasting forecast_ts = TSDataset(df, freq="D") forecast_ts.transform(ts.transforms) - forecast_ts.df = forecast_ts.df.iloc[(num_skip_points - model.context_size) :] prediction_size = len(forecast_ts.index) - num_skip_points + forecast_ts.df = forecast_ts.df.iloc[(num_skip_points - model.context_size) :] forecast_ts = make_prediction(model=model, ts=forecast_ts, prediction_size=prediction_size, method_name=method_name) # checking forecast_df = forecast_ts.to_pandas(flatten=True) assert not np.any(forecast_df["target"].isna()) + original_target = TSDataset.to_flatten(df.iloc[(num_skip_points - model.context_size) :])["target"] + assert not forecast_df["target"].equals(original_target) diff --git a/tests/test_models/test_inference/test_forecast.py b/tests/test_models/test_inference/test_forecast.py index cb654ef6d..496a869c6 100644 --- a/tests/test_models/test_inference/test_forecast.py +++ b/tests/test_models/test_inference/test_forecast.py @@ -5,6 +5,7 @@ import pytest from pandas.util.testing import assert_frame_equal from pytorch_forecasting.data import GroupNormalizer +from pytorch_forecasting.data import NaNLabelEncoder from typing_extensions import get_args from etna.datasets import TSDataset @@ -28,6 +29,7 @@ from etna.models import SimpleExpSmoothingModel from etna.models import TBATSModel from etna.models.nn import DeepARModel +from etna.models.nn import MLPModel from etna.models.nn import RNNModel from etna.models.nn import TFTModel from etna.transforms import LagTransform @@ -35,7 +37,8 @@ from tests.test_models.test_inference.common import _test_prediction_in_sample_full from tests.test_models.test_inference.common import _test_prediction_in_sample_suffix from tests.test_models.test_inference.common import make_prediction -from tests.test_models.test_inference.common import to_be_fixed +from tests.utils import select_segments_subset +from tests.utils import to_be_fixed def make_forecast(model, ts, prediction_size) -> TSDataset: @@ -43,7 +46,7 @@ def make_forecast(model, ts, prediction_size) -> TSDataset: class TestForecastInSampleFullNoTarget: - """Test forecast on full train dataset with filling target with NaNs. + """Test forecast on full train dataset where target is filled with NaNs. Expected that NaNs are filled after prediction. """ @@ -83,27 +86,30 @@ def _test_forecast_in_sample_full_no_target(ts, model, transforms): def test_forecast_in_sample_full_no_target(self, model, transforms, example_tsds): self._test_forecast_in_sample_full_no_target(example_tsds, model, transforms) - @to_be_fixed(raises=AssertionError) @pytest.mark.parametrize( "model, transforms", [ - (RNNModel(input_size=1, encoder_length=7, decoder_length=7, trainer_params=dict(max_epochs=1)), []), + (LinearPerSegmentModel(), [LagTransform(in_column="target", lags=[2, 3])]), + (LinearMultiSegmentModel(), [LagTransform(in_column="target", lags=[2, 3])]), + (ElasticPerSegmentModel(), [LagTransform(in_column="target", lags=[2, 3])]), + (ElasticMultiSegmentModel(), [LagTransform(in_column="target", lags=[2, 3])]), ], ) - def test_forecast_in_sample_full_no_target_failed(self, model, transforms, example_tsds): - self._test_forecast_in_sample_full_no_target(example_tsds, model, transforms) + def test_forecast_in_sample_full_no_target_failed_nans_sklearn(self, model, transforms, example_tsds): + with pytest.raises(ValueError, match="Input contains NaN, infinity or a value too large"): + self._test_forecast_in_sample_full_no_target(example_tsds, model, transforms) @pytest.mark.parametrize( "model, transforms", [ - (LinearPerSegmentModel(), [LagTransform(in_column="target", lags=[2, 3])]), - (LinearMultiSegmentModel(), [LagTransform(in_column="target", lags=[2, 3])]), - (ElasticPerSegmentModel(), [LagTransform(in_column="target", lags=[2, 3])]), - (ElasticMultiSegmentModel(), [LagTransform(in_column="target", lags=[2, 3])]), + ( + MLPModel(input_size=2, hidden_size=[10], decoder_length=7, trainer_params=dict(max_epochs=1)), + [LagTransform(in_column="target", lags=[5, 6])], + ), ], ) - def test_forecast_in_sample_full_no_target_failed_nans_lags(self, model, transforms, example_tsds): - with pytest.raises(ValueError, match="Input contains NaN, infinity or a value too large"): + def test_forecast_in_sample_full_no_target_failed_nans_nn(self, model, transforms, example_tsds): + with pytest.raises(ValueError, match="There are NaNs in features"): self._test_forecast_in_sample_full_no_target(example_tsds, model, transforms) @pytest.mark.parametrize( @@ -113,6 +119,7 @@ def test_forecast_in_sample_full_no_target_failed_nans_lags(self, model, transfo (NaiveModel(lag=3), []), (SeasonalMovingAverageModel(), []), (DeadlineMovingAverageModel(window=1), []), + (RNNModel(input_size=1, encoder_length=7, decoder_length=7, trainer_params=dict(max_epochs=1)), []), ], ) def test_forecast_in_sample_full_no_target_failed_not_enough_context(self, model, transforms, example_tsds): @@ -160,7 +167,7 @@ def test_forecast_in_sample_full_no_target_failed_not_implemented_in_sample(self class TestForecastInSampleFull: """Test forecast on full train dataset. - Expected that target values are filled after prediction. + Expected that there are no NaNs after prediction and targets are changed compared to original. """ @pytest.mark.parametrize( @@ -174,7 +181,6 @@ class TestForecastInSampleFull: (HoltModel(), []), (HoltWintersModel(), []), (SimpleExpSmoothingModel(), []), - (RNNModel(input_size=1, encoder_length=7, decoder_length=7, trainer_params=dict(max_epochs=1)), []), ], ) def test_forecast_in_sample_full(self, model, transforms, example_tsds): @@ -189,10 +195,23 @@ def test_forecast_in_sample_full(self, model, transforms, example_tsds): (ElasticMultiSegmentModel(), [LagTransform(in_column="target", lags=[2, 3])]), ], ) - def test_forecast_in_sample_full_failed_nans_lags(self, model, transforms, example_tsds): + def test_forecast_in_sample_full_failed_nans_sklearn(self, model, transforms, example_tsds): with pytest.raises(ValueError, match="Input contains NaN, infinity or a value too large"): _test_prediction_in_sample_full(example_tsds, model, transforms, method_name="forecast") + @pytest.mark.parametrize( + "model, transforms", + [ + ( + MLPModel(input_size=2, hidden_size=[10], decoder_length=7, trainer_params=dict(max_epochs=1)), + [LagTransform(in_column="target", lags=[2, 3])], + ), + ], + ) + def test_forecast_in_sample_full_failed_nans_nn(self, model, transforms, example_tsds): + with pytest.raises(ValueError, match="There are NaNs in features"): + _test_prediction_in_sample_full(example_tsds, model, transforms, method_name="forecast") + @pytest.mark.parametrize( "model, transforms", [ @@ -200,12 +219,22 @@ def test_forecast_in_sample_full_failed_nans_lags(self, model, transforms, examp (NaiveModel(lag=3), []), (SeasonalMovingAverageModel(), []), (DeadlineMovingAverageModel(window=1), []), + (RNNModel(input_size=1, encoder_length=7, decoder_length=7, trainer_params=dict(max_epochs=1)), []), ], ) def test_forecast_in_sample_full_failed_not_enough_context(self, model, transforms, example_tsds): with pytest.raises(ValueError, match="Given context isn't big enough"): _test_prediction_in_sample_full(example_tsds, model, transforms, method_name="forecast") + @to_be_fixed(raises=AssertionError) + # Looks like a problem of current implementation of NNs + @pytest.mark.parametrize( + "model, transforms", + [], + ) + def test_forecast_in_sample_full_failed_nans_lags_nns(self, model, transforms, example_tsds): + _test_prediction_in_sample_full(example_tsds, model, transforms, method_name="forecast") + @to_be_fixed(raises=NotImplementedError, match="It is not possible to make in-sample predictions") @pytest.mark.parametrize( "model, transforms", @@ -245,7 +274,7 @@ def test_forecast_in_sample_full_not_implemented(self, model, transforms, exampl class TestForecastInSampleSuffixNoTarget: - """Test forecast on suffix of train dataset with filling target with NaNs. + """Test forecast on suffix of train dataset where target is filled with NaNs. Expected that NaNs are filled after prediction. """ @@ -290,6 +319,10 @@ def _test_forecast_in_sample_suffix_no_target(ts, model, transforms, num_skip_po (SeasonalMovingAverageModel(), []), (DeadlineMovingAverageModel(window=1), []), (RNNModel(input_size=1, encoder_length=7, decoder_length=7, trainer_params=dict(max_epochs=1)), []), + ( + MLPModel(input_size=2, hidden_size=[10], decoder_length=7, trainer_params=dict(max_epochs=1)), + [LagTransform(in_column="target", lags=[2, 3])], + ), ], ) def test_forecast_in_sample_suffix_no_target(self, model, transforms, example_tsds): @@ -338,7 +371,7 @@ def test_forecast_in_sample_suffix_no_target_failed_not_implemented_in_sample( class TestForecastInSampleSuffix: """Test forecast on suffix of train dataset. - Expected that target values are filled after prediction. + Expected that there are no NaNs after prediction and targets are changed compared to original. """ @pytest.mark.parametrize( @@ -361,6 +394,10 @@ class TestForecastInSampleSuffix: (SeasonalMovingAverageModel(), []), (DeadlineMovingAverageModel(window=1), []), (RNNModel(input_size=1, encoder_length=7, decoder_length=7, trainer_params=dict(max_epochs=1)), []), + ( + MLPModel(input_size=2, hidden_size=[10], decoder_length=7, trainer_params=dict(max_epochs=1)), + [LagTransform(in_column="target", lags=[2, 3])], + ), ], ) def test_forecast_in_sample_suffix(self, model, transforms, example_tsds): @@ -486,6 +523,10 @@ def _test_forecast_out_sample_prefix(ts, model, transforms, full_prediction_size ], ), (RNNModel(input_size=1, encoder_length=7, decoder_length=7, trainer_params=dict(max_epochs=1)), []), + ( + MLPModel(input_size=2, hidden_size=[10], decoder_length=7, trainer_params=dict(max_epochs=1)), + [LagTransform(in_column="target", lags=[5, 6])], + ), ], ) def test_forecast_out_sample_prefix(self, model, transforms, example_tsds): @@ -516,7 +557,7 @@ def _test_forecast_out_sample_suffix(ts, model, transforms, full_prediction_size # firstly we should forecast prefix to use it as a context forecast_prefix_ts = deepcopy(forecast_gap_ts) forecast_prefix_ts.df = forecast_prefix_ts.df.iloc[:-suffix_prediction_size] - model.forecast(forecast_prefix_ts, prediction_size=prediction_size_diff) + forecast_prefix_ts = model.forecast(forecast_prefix_ts, prediction_size=prediction_size_diff) forecast_gap_ts.df = forecast_gap_ts.df.combine_first(forecast_prefix_ts.df) # forecast suffix with known context for it @@ -551,20 +592,28 @@ def _test_forecast_out_sample_suffix(ts, model, transforms, full_prediction_size (SeasonalMovingAverageModel(), []), (NaiveModel(lag=3), []), (DeadlineMovingAverageModel(window=1), []), + ( + MLPModel(input_size=2, hidden_size=[10], decoder_length=7, trainer_params=dict(max_epochs=1)), + [LagTransform(in_column="target", lags=[5, 6])], + ), ], ) def test_forecast_out_sample_suffix(self, model, transforms, example_tsds): self._test_forecast_out_sample_suffix(example_tsds, model, transforms) - @to_be_fixed(raises=AssertionError) @pytest.mark.parametrize( "model, transforms", [ (RNNModel(input_size=1, encoder_length=7, decoder_length=7, trainer_params=dict(max_epochs=1)), []), ], ) - def test_forecast_out_sample_suffix_failed(self, model, transforms, example_tsds): - self._test_forecast_out_sample_suffix(example_tsds, model, transforms) + def test_forecast_out_sample_suffix_failed_rnn(self, model, transforms, example_tsds): + """This test is expected to fail due to autoregression in RNN. + + More about it in issue: https://github.com/tinkoff-ai/etna/issues/1087 + """ + with pytest.raises(AssertionError): + self._test_forecast_out_sample_suffix(example_tsds, model, transforms) @to_be_fixed(raises=NotImplementedError, match="You can only forecast from the next point after the last one") @pytest.mark.parametrize( @@ -605,7 +654,7 @@ def test_forecast_out_sample_suffix_failed_not_implemented(self, model, transfor class TestForecastMixedInOutSample: """Test forecast on mixture of in-sample and out-sample. - Expected that target values are filled after prediction. + Expected that there are no NaNs after prediction and targets are changed compared to original. """ @staticmethod @@ -628,6 +677,8 @@ def _test_forecast_mixed_in_out_sample(ts, model, transforms, num_skip_points=50 # checking forecast_full_df = forecast_full_ts.to_pandas(flatten=True) assert not np.any(forecast_full_df["target"].isna()) + original_target = TSDataset.to_flatten(df_full.iloc[(num_skip_points - model.context_size) :])["target"] + assert not forecast_full_df["target"].equals(original_target) @pytest.mark.parametrize( "model, transforms", @@ -649,6 +700,10 @@ def _test_forecast_mixed_in_out_sample(ts, model, transforms, num_skip_points=50 (NaiveModel(lag=3), []), (DeadlineMovingAverageModel(window=1), []), (RNNModel(input_size=1, encoder_length=7, decoder_length=7, trainer_params=dict(max_epochs=1)), []), + ( + MLPModel(input_size=2, hidden_size=[10], decoder_length=7, trainer_params=dict(max_epochs=1)), + [LagTransform(in_column="target", lags=[5, 6])], + ), ], ) def test_forecast_mixed_in_out_sample(self, model, transforms, example_tsds): @@ -690,3 +745,205 @@ def test_forecast_mixed_in_out_sample(self, model, transforms, example_tsds): ) def test_forecast_mixed_in_out_sample_failed_not_implemented_in_sample(self, model, transforms, example_tsds): self._test_forecast_mixed_in_out_sample(example_tsds, model, transforms) + + +class TestForecastSubsetSegments: + """Test forecast on subset of segments. + + Expected that predictions on subset of segments match subset of predictions on full dataset. + """ + + def _test_forecast_subset_segments(self, ts, model, transforms, segments, prediction_size=5): + # select subset of tsdataset + segments = list(set(segments)) + subset_ts = select_segments_subset(ts=deepcopy(ts), segments=segments) + + # fitting + ts.fit_transform(transforms) + subset_ts.transform(ts.transforms) + model.fit(ts) + + # forecasting full + import torch # TODO: remove after fix at issue-802 + + torch.manual_seed(11) + + forecast_full_ts = ts.make_future(future_steps=prediction_size, tail_steps=model.context_size) + forecast_full_ts = make_forecast(model=model, ts=forecast_full_ts, prediction_size=prediction_size) + + # forecasting subset of segments + torch.manual_seed(11) # TODO: remove after fix at issue-802 + + forecast_subset_ts = subset_ts.make_future(future_steps=prediction_size, tail_steps=model.context_size) + forecast_subset_ts = make_forecast(model=model, ts=forecast_subset_ts, prediction_size=prediction_size) + + # checking + forecast_full_df = forecast_full_ts.to_pandas() + forecast_subset_df = forecast_subset_ts.to_pandas() + assert_frame_equal(forecast_subset_df, forecast_full_df.loc[:, pd.IndexSlice[segments, :]]) + + @pytest.mark.parametrize( + "model, transforms", + [ + (CatBoostModelPerSegment(), [LagTransform(in_column="target", lags=[5, 6])]), + (CatBoostModelMultiSegment(), [LagTransform(in_column="target", lags=[5, 6])]), + (LinearPerSegmentModel(), [LagTransform(in_column="target", lags=[5, 6])]), + (LinearMultiSegmentModel(), [LagTransform(in_column="target", lags=[5, 6])]), + (ElasticPerSegmentModel(), [LagTransform(in_column="target", lags=[5, 6])]), + (ElasticMultiSegmentModel(), [LagTransform(in_column="target", lags=[5, 6])]), + (AutoARIMAModel(), []), + (ProphetModel(), []), + (SARIMAXModel(), []), + (HoltModel(), []), + (HoltWintersModel(), []), + (SimpleExpSmoothingModel(), []), + (MovingAverageModel(window=3), []), + (SeasonalMovingAverageModel(), []), + (NaiveModel(lag=3), []), + (DeadlineMovingAverageModel(window=1), []), + (BATSModel(use_trend=True), []), + (TBATSModel(use_trend=True), []), + ( + TFTModel(max_epochs=1, learning_rate=[0.01]), + [ + PytorchForecastingTransform( + max_encoder_length=21, + min_encoder_length=21, + max_prediction_length=5, + time_varying_known_reals=["time_idx"], + time_varying_unknown_reals=["target"], + static_categoricals=["segment"], + target_normalizer=None, + ) + ], + ), + (RNNModel(input_size=1, encoder_length=7, decoder_length=7, trainer_params=dict(max_epochs=1)), []), + ( + MLPModel(input_size=2, hidden_size=[10], decoder_length=7, trainer_params=dict(max_epochs=1)), + [LagTransform(in_column="target", lags=[5, 6])], + ), + ], + ) + def test_forecast_subset_segments(self, model, transforms, example_tsds): + self._test_forecast_subset_segments(example_tsds, model, transforms, segments=["segment_2"]) + + @to_be_fixed(raises=AssertionError) + # issue with explanation: https://github.com/tinkoff-ai/etna/issues/1089 + @pytest.mark.parametrize( + "model, transforms", + [ + ( + DeepARModel(max_epochs=1, learning_rate=[0.01]), + [ + PytorchForecastingTransform( + max_encoder_length=5, + max_prediction_length=5, + time_varying_known_reals=["time_idx"], + time_varying_unknown_reals=["target"], + target_normalizer=GroupNormalizer(groups=["segment"]), + ) + ], + ), + ], + ) + def test_forecast_subset_segments_failed_assertion_error(self, model, transforms, example_tsds): + self._test_forecast_subset_segments(example_tsds, model, transforms, segments=["segment_2"]) + + +class TestForecastNewSegments: + """Test forecast on new segments. + + Expected that target values are filled after prediction. + """ + + def _test_forecast_new_segments(self, ts, model, transforms, train_segments, prediction_size=5): + # create tsdataset with new segments + train_segments = list(set(train_segments)) + forecast_segments = list(set(ts.segments) - set(train_segments)) + train_ts = select_segments_subset(ts=deepcopy(ts), segments=train_segments) + test_ts = select_segments_subset(ts=deepcopy(ts), segments=forecast_segments) + + # fitting + train_ts.fit_transform(transforms) + test_ts.transform(train_ts.transforms) + model.fit(train_ts) + + # forecasting + import torch # TODO: remove after fix at issue-802 + + torch.manual_seed(11) + + forecast_ts = test_ts.make_future(future_steps=prediction_size, tail_steps=model.context_size) + forecast_ts = make_forecast(model=model, ts=forecast_ts, prediction_size=prediction_size) + + # checking + forecast_df = forecast_ts.to_pandas(flatten=True) + assert not np.any(forecast_df["target"].isna()) + + @pytest.mark.parametrize( + "model, transforms", + [ + (CatBoostModelMultiSegment(), [LagTransform(in_column="target", lags=[5, 6])]), + (LinearMultiSegmentModel(), [LagTransform(in_column="target", lags=[5, 6])]), + (ElasticMultiSegmentModel(), [LagTransform(in_column="target", lags=[5, 6])]), + (MovingAverageModel(window=3), []), + (SeasonalMovingAverageModel(), []), + (NaiveModel(lag=3), []), + (DeadlineMovingAverageModel(window=1), []), + (RNNModel(input_size=1, encoder_length=7, decoder_length=7, trainer_params=dict(max_epochs=1)), []), + ( + MLPModel(input_size=2, hidden_size=[10], decoder_length=7, trainer_params=dict(max_epochs=1)), + [LagTransform(in_column="target", lags=[5, 6])], + ), + ( + DeepARModel(max_epochs=1, learning_rate=[0.01]), + [ + PytorchForecastingTransform( + max_encoder_length=5, + max_prediction_length=5, + time_varying_known_reals=["time_idx"], + time_varying_unknown_reals=["target"], + categorical_encoders={"segment": NaNLabelEncoder(add_nan=True, warn=False)}, + target_normalizer=GroupNormalizer(groups=["segment"]), + ) + ], + ), + ( + TFTModel(max_epochs=1, learning_rate=[0.01]), + [ + PytorchForecastingTransform( + max_encoder_length=21, + min_encoder_length=21, + max_prediction_length=5, + time_varying_known_reals=["time_idx"], + time_varying_unknown_reals=["target"], + categorical_encoders={"segment": NaNLabelEncoder(add_nan=True, warn=False)}, + static_categoricals=["segment"], + target_normalizer=None, + ) + ], + ), + ], + ) + def test_forecast_new_segments(self, model, transforms, example_tsds): + self._test_forecast_new_segments(example_tsds, model, transforms, train_segments=["segment_1"]) + + @pytest.mark.parametrize( + "model, transforms", + [ + (CatBoostModelPerSegment(), [LagTransform(in_column="target", lags=[5, 6])]), + (LinearPerSegmentModel(), [LagTransform(in_column="target", lags=[5, 6])]), + (ElasticPerSegmentModel(), [LagTransform(in_column="target", lags=[5, 6])]), + (AutoARIMAModel(), []), + (ProphetModel(), []), + (SARIMAXModel(), []), + (HoltModel(), []), + (HoltWintersModel(), []), + (SimpleExpSmoothingModel(), []), + (BATSModel(use_trend=True), []), + (TBATSModel(use_trend=True), []), + ], + ) + def test_forecast_new_segments_failed_per_segment(self, model, transforms, example_tsds): + with pytest.raises(NotImplementedError, match="Per-segment models can't make predictions on new segments"): + self._test_forecast_new_segments(example_tsds, model, transforms, train_segments=["segment_1"]) diff --git a/tests/test_models/test_inference/test_predict.py b/tests/test_models/test_inference/test_predict.py index 1d89d36ef..5fb0eaf7b 100644 --- a/tests/test_models/test_inference/test_predict.py +++ b/tests/test_models/test_inference/test_predict.py @@ -1,8 +1,11 @@ +from copy import deepcopy + import numpy as np import pandas as pd import pytest from pandas.util.testing import assert_frame_equal from pytorch_forecasting.data import GroupNormalizer +from pytorch_forecasting.data import NaNLabelEncoder from etna.datasets import TSDataset from etna.models import AutoARIMAModel @@ -24,6 +27,7 @@ from etna.models import SimpleExpSmoothingModel from etna.models import TBATSModel from etna.models.nn import DeepARModel +from etna.models.nn import MLPModel from etna.models.nn import RNNModel from etna.models.nn import TFTModel from etna.transforms import LagTransform @@ -31,7 +35,8 @@ from tests.test_models.test_inference.common import _test_prediction_in_sample_full from tests.test_models.test_inference.common import _test_prediction_in_sample_suffix from tests.test_models.test_inference.common import make_prediction -from tests.test_models.test_inference.common import to_be_fixed +from tests.utils import select_segments_subset +from tests.utils import to_be_fixed def make_predict(model, ts, prediction_size) -> TSDataset: @@ -41,7 +46,7 @@ def make_predict(model, ts, prediction_size) -> TSDataset: class TestPredictInSampleFull: """Test predict on full train dataset. - Expected that target values are filled after prediction. + Expected that there are no NaNs after prediction and targets are changed compared to original. """ @pytest.mark.parametrize( @@ -69,7 +74,7 @@ def test_predict_in_sample_full(self, model, transforms, example_tsds): (ElasticMultiSegmentModel(), [LagTransform(in_column="target", lags=[2, 3])]), ], ) - def test_predict_in_sample_full_failed_not_enough_context(self, model, transforms, example_tsds): + def test_predict_in_sample_full_failed_nans_sklearn(self, model, transforms, example_tsds): with pytest.raises(ValueError, match="Input contains NaN, infinity or a value too large"): _test_prediction_in_sample_full(example_tsds, model, transforms, method_name="predict") @@ -119,6 +124,10 @@ def test_predict_in_sample_full_failed_not_enough_context(self, model, transform ], ), (RNNModel(input_size=1, encoder_length=7, decoder_length=7, trainer_params=dict(max_epochs=1)), []), + ( + MLPModel(input_size=2, hidden_size=[10], decoder_length=7, trainer_params=dict(max_epochs=1)), + [LagTransform(in_column="target", lags=[2, 3])], + ), ], ) def test_predict_in_sample_full_failed_not_implemented_predict(self, model, transforms, example_tsds): @@ -136,7 +145,7 @@ def test_predict_in_sample_full_failed_not_implemented_in_sample(self, model, tr class TestPredictInSampleSuffix: """Test predict on suffix of train dataset. - Expected that target values are filled after prediction. + Expected that there are no NaNs after prediction and targets are changed compared to original. """ @pytest.mark.parametrize( @@ -196,6 +205,10 @@ def test_predict_in_sample_suffix(self, model, transforms, example_tsds): ], ), (RNNModel(input_size=1, encoder_length=7, decoder_length=7, trainer_params=dict(max_epochs=1)), []), + ( + MLPModel(input_size=2, hidden_size=[10], decoder_length=7, trainer_params=dict(max_epochs=1)), + [LagTransform(in_column="target", lags=[2, 3])], + ), ], ) def test_predict_in_sample_full_failed_not_implemented_predict(self, model, transforms, example_tsds): @@ -213,13 +226,14 @@ def test_predict_in_sample_suffix_failed_not_implemented_in_sample(self, model, class TestPredictOutSample: """Test predict on future dataset. - Expected that target values are filled after prediction. + Expected that there are no NaNs after prediction and targets are changed compared to original. """ @staticmethod def _test_predict_out_sample(ts, model, transforms, prediction_size=5): - train_ts, future_ts = ts.train_test_split(test_size=prediction_size) + train_ts, _ = ts.train_test_split(test_size=prediction_size) forecast_ts = TSDataset(df=ts.df, freq=ts.freq) + df = forecast_ts.to_pandas() # fitting train_ts.fit_transform(transforms) @@ -234,6 +248,8 @@ def _test_predict_out_sample(ts, model, transforms, prediction_size=5): # checking forecast_df = forecast_ts.to_pandas(flatten=True) assert not np.any(forecast_df["target"].isna()) + original_target = TSDataset.to_flatten(df.iloc[-to_remain:])["target"] + assert not forecast_df["target"].equals(original_target) @pytest.mark.parametrize( "model, transforms", @@ -292,12 +308,217 @@ def test_predict_out_sample(self, model, transforms, example_tsds): ], ), (RNNModel(input_size=1, encoder_length=7, decoder_length=7, trainer_params=dict(max_epochs=1)), []), + ( + MLPModel(input_size=2, hidden_size=[10], decoder_length=7, trainer_params=dict(max_epochs=1)), + [LagTransform(in_column="target", lags=[5, 6])], + ), ], ) def test_predict_out_sample_failed_not_implemented_predict(self, model, transforms, example_tsds): self._test_predict_out_sample(example_tsds, model, transforms) +class TestPredictOutSamplePrefix: + """Test predict on prefix of future dataset. + + Expected that predictions on prefix match prefix of predictions on full future dataset. + """ + + @staticmethod + def _test_predict_out_sample_prefix(ts, model, transforms, full_prediction_size=5, prefix_prediction_size=3): + prediction_size_diff = full_prediction_size - prefix_prediction_size + train_ts, _ = ts.train_test_split(test_size=full_prediction_size) + forecast_full_ts = TSDataset(df=ts.df, freq=ts.freq) + forecast_prefix_ts = TSDataset(df=ts.df, freq=ts.freq) + + # fitting + train_ts.fit_transform(transforms) + model.fit(train_ts) + + # forecasting full + forecast_full_ts.transform(train_ts.transforms) + to_remain = model.context_size + full_prediction_size + forecast_full_ts.df = forecast_full_ts.df.iloc[-to_remain:] + forecast_full_ts = make_predict(model=model, ts=forecast_full_ts, prediction_size=full_prediction_size) + + # forecasting only prefix + forecast_prefix_ts.transform(train_ts.transforms) + forecast_prefix_ts.df = forecast_prefix_ts.df.iloc[-to_remain:-prediction_size_diff] + forecast_prefix_ts = make_predict(model=model, ts=forecast_prefix_ts, prediction_size=prefix_prediction_size) + + # checking + forecast_full_df = forecast_full_ts.to_pandas() + forecast_prefix_df = forecast_prefix_ts.to_pandas() + assert_frame_equal(forecast_prefix_df, forecast_full_df.iloc[:prefix_prediction_size]) + + @pytest.mark.parametrize( + "model, transforms", + [ + (CatBoostModelPerSegment(), [LagTransform(in_column="target", lags=[5, 6])]), + (CatBoostModelMultiSegment(), [LagTransform(in_column="target", lags=[5, 6])]), + (LinearPerSegmentModel(), [LagTransform(in_column="target", lags=[5, 6])]), + (LinearMultiSegmentModel(), [LagTransform(in_column="target", lags=[5, 6])]), + (ElasticPerSegmentModel(), [LagTransform(in_column="target", lags=[5, 6])]), + (ElasticMultiSegmentModel(), [LagTransform(in_column="target", lags=[5, 6])]), + (AutoARIMAModel(), []), + (ProphetModel(), []), + (SARIMAXModel(), []), + (HoltModel(), []), + (HoltWintersModel(), []), + (SimpleExpSmoothingModel(), []), + (MovingAverageModel(window=3), []), + (SeasonalMovingAverageModel(), []), + (NaiveModel(lag=3), []), + (DeadlineMovingAverageModel(window=1), []), + ], + ) + def test_predict_out_sample_prefix(self, model, transforms, example_tsds): + self._test_predict_out_sample_prefix(example_tsds, model, transforms) + + @to_be_fixed(raises=NotImplementedError, match="Method predict isn't currently implemented") + @pytest.mark.parametrize( + "model, transforms", + [ + (BATSModel(use_trend=True), []), + (TBATSModel(use_trend=True), []), + ( + DeepARModel(max_epochs=5, learning_rate=[0.01]), + [ + PytorchForecastingTransform( + max_encoder_length=5, + max_prediction_length=5, + time_varying_known_reals=["time_idx"], + time_varying_unknown_reals=["target"], + target_normalizer=GroupNormalizer(groups=["segment"]), + ) + ], + ), + ( + TFTModel(max_epochs=1, learning_rate=[0.01]), + [ + PytorchForecastingTransform( + max_encoder_length=21, + min_encoder_length=21, + max_prediction_length=5, + time_varying_known_reals=["time_idx"], + time_varying_unknown_reals=["target"], + static_categoricals=["segment"], + target_normalizer=None, + ) + ], + ), + (RNNModel(input_size=1, encoder_length=7, decoder_length=7, trainer_params=dict(max_epochs=1)), []), + ( + MLPModel(input_size=2, hidden_size=[10], decoder_length=7, trainer_params=dict(max_epochs=1)), + [LagTransform(in_column="target", lags=[5, 6])], + ), + ], + ) + def test_predict_out_sample_prefix_failed_not_implemented_predict(self, model, transforms, example_tsds): + self._test_predict_out_sample_prefix(example_tsds, model, transforms) + + +class TestPredictOutSampleSuffix: + """Test predict on suffix of future dataset. + + Expected that predictions on suffix match suffix of predictions on full future dataset. + """ + + @staticmethod + def _test_predict_out_sample_suffix(ts, model, transforms, full_prediction_size=5, suffix_prediction_size=3): + prediction_size_diff = full_prediction_size - suffix_prediction_size + train_ts, _ = ts.train_test_split(test_size=full_prediction_size) + forecast_full_ts = TSDataset(df=ts.df, freq=ts.freq) + forecast_suffix_ts = TSDataset(df=ts.df, freq=ts.freq) + + # fitting + train_ts.fit_transform(transforms) + model.fit(train_ts) + + # forecasting full + forecast_full_ts.transform(train_ts.transforms) + to_remain = model.context_size + full_prediction_size + forecast_full_ts.df = forecast_full_ts.df.iloc[-to_remain:] + forecast_full_ts = make_predict(model=model, ts=forecast_full_ts, prediction_size=full_prediction_size) + + # forecasting only suffix + forecast_suffix_ts.transform(train_ts.transforms) + to_remain = model.context_size + suffix_prediction_size + forecast_suffix_ts.df = forecast_suffix_ts.df.iloc[-to_remain:] + forecast_suffix_ts = make_predict(model=model, ts=forecast_suffix_ts, prediction_size=suffix_prediction_size) + + # checking + forecast_full_df = forecast_full_ts.to_pandas() + forecast_suffix_df = forecast_suffix_ts.to_pandas() + assert_frame_equal(forecast_suffix_df, forecast_full_df.iloc[prediction_size_diff:]) + + @pytest.mark.parametrize( + "model, transforms", + [ + (CatBoostModelPerSegment(), [LagTransform(in_column="target", lags=[5, 6])]), + (CatBoostModelMultiSegment(), [LagTransform(in_column="target", lags=[5, 6])]), + (LinearPerSegmentModel(), [LagTransform(in_column="target", lags=[5, 6])]), + (LinearMultiSegmentModel(), [LagTransform(in_column="target", lags=[5, 6])]), + (ElasticPerSegmentModel(), [LagTransform(in_column="target", lags=[5, 6])]), + (ElasticMultiSegmentModel(), [LagTransform(in_column="target", lags=[5, 6])]), + (AutoARIMAModel(), []), + (ProphetModel(), []), + (SARIMAXModel(), []), + (HoltModel(), []), + (HoltWintersModel(), []), + (SimpleExpSmoothingModel(), []), + (MovingAverageModel(window=3), []), + (SeasonalMovingAverageModel(), []), + (NaiveModel(lag=3), []), + (DeadlineMovingAverageModel(window=1), []), + ], + ) + def test_predict_out_sample_suffix(self, model, transforms, example_tsds): + self._test_predict_out_sample_suffix(example_tsds, model, transforms) + + @to_be_fixed(raises=NotImplementedError, match="Method predict isn't currently implemented") + @pytest.mark.parametrize( + "model, transforms", + [ + (BATSModel(use_trend=True), []), + (TBATSModel(use_trend=True), []), + ( + DeepARModel(max_epochs=5, learning_rate=[0.01]), + [ + PytorchForecastingTransform( + max_encoder_length=5, + max_prediction_length=5, + time_varying_known_reals=["time_idx"], + time_varying_unknown_reals=["target"], + target_normalizer=GroupNormalizer(groups=["segment"]), + ) + ], + ), + ( + TFTModel(max_epochs=1, learning_rate=[0.01]), + [ + PytorchForecastingTransform( + max_encoder_length=21, + min_encoder_length=21, + max_prediction_length=5, + time_varying_known_reals=["time_idx"], + time_varying_unknown_reals=["target"], + static_categoricals=["segment"], + target_normalizer=None, + ) + ], + ), + (RNNModel(input_size=1, encoder_length=7, decoder_length=7, trainer_params=dict(max_epochs=1)), []), + ( + MLPModel(input_size=2, hidden_size=[10], decoder_length=7, trainer_params=dict(max_epochs=1)), + [LagTransform(in_column="target", lags=[5, 6])], + ), + ], + ) + def test_predict_out_sample_suffix_failed_not_implemented_predict(self, model, transforms, example_tsds): + self._test_predict_out_sample_suffix(example_tsds, model, transforms) + + class TestPredictMixedInOutSample: """Test predict on mixture of in-sample and out-sample. @@ -403,7 +624,227 @@ def test_predict_mixed_in_out_sample(self, model, transforms, example_tsds): ], ), (RNNModel(input_size=1, encoder_length=7, decoder_length=7, trainer_params=dict(max_epochs=1)), []), + ( + MLPModel(input_size=2, hidden_size=[10], decoder_length=7, trainer_params=dict(max_epochs=1)), + [LagTransform(in_column="target", lags=[5, 6])], + ), ], ) def test_predict_mixed_in_out_sample_failed_not_implemented_predict(self, model, transforms, example_tsds): self._test_predict_mixed_in_out_sample(example_tsds, model, transforms) + + +class TestPredictSubsetSegments: + """Test predict on subset of segments on suffix of train dataset. + + Expected that predictions on subset of segments match subset of predictions on full dataset. + """ + + def _test_predict_subset_segments(self, ts, model, transforms, segments, num_skip_points=50): + prediction_size = len(ts.index) - num_skip_points + + # select subset of tsdataset + segments = list(set(segments)) + subset_ts = select_segments_subset(ts=deepcopy(ts), segments=segments) + + # fitting + ts.fit_transform(transforms) + subset_ts.transform(ts.transforms) + model.fit(ts) + + # forecasting full + import torch # TODO: remove after fix at issue-802 + + torch.manual_seed(11) + + ts.df = ts.df.iloc[(num_skip_points - model.context_size) :] + forecast_full_ts = make_predict(model=model, ts=ts, prediction_size=prediction_size) + + # forecasting subset of segments + torch.manual_seed(11) # TODO: remove after fix at issue-802 + + subset_ts.df = subset_ts.df.iloc[(num_skip_points - model.context_size) :] + forecast_subset_ts = make_predict(model=model, ts=subset_ts, prediction_size=prediction_size) + + # checking + forecast_full_df = forecast_full_ts.to_pandas() + forecast_subset_df = forecast_subset_ts.to_pandas() + assert_frame_equal(forecast_subset_df, forecast_full_df.loc[:, pd.IndexSlice[segments, :]]) + + @pytest.mark.parametrize( + "model, transforms", + [ + (CatBoostModelPerSegment(), [LagTransform(in_column="target", lags=[5, 6])]), + (CatBoostModelMultiSegment(), [LagTransform(in_column="target", lags=[5, 6])]), + (LinearPerSegmentModel(), [LagTransform(in_column="target", lags=[5, 6])]), + (LinearMultiSegmentModel(), [LagTransform(in_column="target", lags=[5, 6])]), + (ElasticPerSegmentModel(), [LagTransform(in_column="target", lags=[5, 6])]), + (ElasticMultiSegmentModel(), [LagTransform(in_column="target", lags=[5, 6])]), + (AutoARIMAModel(), []), + (ProphetModel(), []), + (SARIMAXModel(), []), + (HoltModel(), []), + (HoltWintersModel(), []), + (SimpleExpSmoothingModel(), []), + (MovingAverageModel(window=3), []), + (SeasonalMovingAverageModel(), []), + (NaiveModel(lag=3), []), + (DeadlineMovingAverageModel(window=1), []), + ], + ) + def test_predict_subset_segments(self, model, transforms, example_tsds): + self._test_predict_subset_segments(example_tsds, model, transforms, segments=["segment_2"]) + + @to_be_fixed(raises=NotImplementedError, match="Method predict isn't currently implemented") + @pytest.mark.parametrize( + "model, transforms", + [ + (BATSModel(use_trend=True), []), + (TBATSModel(use_trend=True), []), + ( + DeepARModel(max_epochs=5, learning_rate=[0.01]), + [ + PytorchForecastingTransform( + max_encoder_length=5, + max_prediction_length=5, + time_varying_known_reals=["time_idx"], + time_varying_unknown_reals=["target"], + target_normalizer=GroupNormalizer(groups=["segment"]), + ) + ], + ), + ( + TFTModel(max_epochs=1, learning_rate=[0.01]), + [ + PytorchForecastingTransform( + max_encoder_length=21, + min_encoder_length=21, + max_prediction_length=5, + time_varying_known_reals=["time_idx"], + time_varying_unknown_reals=["target"], + static_categoricals=["segment"], + target_normalizer=None, + ) + ], + ), + (RNNModel(input_size=1, encoder_length=7, decoder_length=7, trainer_params=dict(max_epochs=1)), []), + ( + MLPModel(input_size=2, hidden_size=[10], decoder_length=7, trainer_params=dict(max_epochs=1)), + [LagTransform(in_column="target", lags=[5, 6])], + ), + ], + ) + def test_predict_subset_segments_failed_not_implemented_predict(self, model, transforms, example_tsds): + self._test_predict_subset_segments(example_tsds, model, transforms, segments=["segment_2"]) + + +class TestPredictNewSegments: + """Test predict on new segments on suffix of train dataset. + + Expected that there are no NaNs after prediction and targets are changed compared to original. + """ + + def _test_predict_new_segments(self, ts, model, transforms, train_segments, num_skip_points=50): + # create tsdataset with new segments + train_segments = list(set(train_segments)) + forecast_segments = list(set(ts.segments) - set(train_segments)) + train_ts = select_segments_subset(ts=deepcopy(ts), segments=train_segments) + test_ts = select_segments_subset(ts=deepcopy(ts), segments=forecast_segments) + df = test_ts.to_pandas() + + # fitting + train_ts.fit_transform(transforms) + test_ts.transform(train_ts.transforms) + model.fit(train_ts) + + # forecasting + import torch # TODO: remove after fix at issue-802 + + torch.manual_seed(11) + + test_ts.df = test_ts.df.iloc[(num_skip_points - model.context_size) :] + prediction_size = len(ts.index) - num_skip_points + forecast_ts = make_predict(model=model, ts=test_ts, prediction_size=prediction_size) + + # checking + forecast_df = forecast_ts.to_pandas(flatten=True) + assert not np.any(forecast_df["target"].isna()) + original_target = TSDataset.to_flatten(df.iloc[(num_skip_points - model.context_size) :])["target"] + assert not forecast_df["target"].equals(original_target) + + @pytest.mark.parametrize( + "model, transforms", + [ + (CatBoostModelMultiSegment(), [LagTransform(in_column="target", lags=[5, 6])]), + (LinearMultiSegmentModel(), [LagTransform(in_column="target", lags=[5, 6])]), + (ElasticMultiSegmentModel(), [LagTransform(in_column="target", lags=[5, 6])]), + (MovingAverageModel(window=3), []), + (SeasonalMovingAverageModel(), []), + (NaiveModel(lag=3), []), + (DeadlineMovingAverageModel(window=1), []), + ], + ) + def test_predict_new_segments(self, model, transforms, example_tsds): + self._test_predict_new_segments(example_tsds, model, transforms, train_segments=["segment_1"]) + + @to_be_fixed(raises=NotImplementedError, match="Method predict isn't currently implemented") + @pytest.mark.parametrize( + "model, transforms", + [ + ( + DeepARModel(max_epochs=1, learning_rate=[0.01]), + [ + PytorchForecastingTransform( + max_encoder_length=5, + max_prediction_length=5, + time_varying_known_reals=["time_idx"], + time_varying_unknown_reals=["target"], + categorical_encoders={"segment": NaNLabelEncoder(add_nan=True, warn=False)}, + target_normalizer=GroupNormalizer(groups=["segment"]), + ) + ], + ), + ( + TFTModel(max_epochs=1, learning_rate=[0.01]), + [ + PytorchForecastingTransform( + max_encoder_length=21, + min_encoder_length=21, + max_prediction_length=5, + time_varying_known_reals=["time_idx"], + time_varying_unknown_reals=["target"], + categorical_encoders={"segment": NaNLabelEncoder(add_nan=True, warn=False)}, + static_categoricals=["segment"], + target_normalizer=None, + ) + ], + ), + (RNNModel(input_size=1, encoder_length=7, decoder_length=7, trainer_params=dict(max_epochs=1)), []), + ( + MLPModel(input_size=2, hidden_size=[10], decoder_length=7, trainer_params=dict(max_epochs=1)), + [LagTransform(in_column="target", lags=[5, 6])], + ), + ], + ) + def test_predict_new_segments_failed_not_implemented_predict(self, model, transforms, example_tsds): + self._test_predict_new_segments(example_tsds, model, transforms, train_segments=["segment_1"]) + + @pytest.mark.parametrize( + "model, transforms", + [ + (CatBoostModelPerSegment(), [LagTransform(in_column="target", lags=[5, 6])]), + (LinearPerSegmentModel(), [LagTransform(in_column="target", lags=[5, 6])]), + (ElasticPerSegmentModel(), [LagTransform(in_column="target", lags=[5, 6])]), + (AutoARIMAModel(), []), + (ProphetModel(), []), + (SARIMAXModel(), []), + (HoltModel(), []), + (HoltWintersModel(), []), + (SimpleExpSmoothingModel(), []), + (BATSModel(use_trend=True), []), + (TBATSModel(use_trend=True), []), + ], + ) + def test_predict_new_segments_failed_per_segment(self, model, transforms, example_tsds): + with pytest.raises(NotImplementedError, match="Per-segment models can't make predictions on new segments"): + self._test_predict_new_segments(example_tsds, model, transforms, train_segments=["segment_1"]) diff --git a/tests/test_models/test_simple_models.py b/tests/test_models/test_simple_models.py index 37365d455..3d30231de 100644 --- a/tests/test_models/test_simple_models.py +++ b/tests/test_models/test_simple_models.py @@ -3,14 +3,13 @@ import pytest from etna.datasets import TSDataset +from etna.datasets import generate_ar_df from etna.metrics import MAE from etna.models.deadline_ma import DeadlineMovingAverageModel from etna.models.deadline_ma import SeasonalityMode -from etna.models.deadline_ma import _DeadlineMovingAverageModel from etna.models.moving_average import MovingAverageModel from etna.models.naive import NaiveModel from etna.models.seasonal_ma import SeasonalMovingAverageModel -from etna.models.seasonal_ma import _SeasonalMovingAverageModel from etna.pipeline import Pipeline from tests.test_models.utils import assert_model_equals_loaded_original @@ -124,9 +123,10 @@ def test_sma_model_predict_fail_nans_in_context(simple_df): ], ) def test_deadline_get_context_beginning_ok(freq, periods, start, prediction_size, seasonality, window, expected): - df = pd.DataFrame({"timestamp": pd.date_range(start=start, periods=periods, freq=freq)}) + timestamp = pd.date_range(start=start, periods=periods, freq=freq) + df = pd.DataFrame({"target": 1}, index=timestamp) - obtained = _DeadlineMovingAverageModel._get_context_beginning(df, prediction_size, seasonality, window) + obtained = DeadlineMovingAverageModel._get_context_beginning(df, prediction_size, seasonality, window) assert obtained == expected @@ -151,10 +151,11 @@ def test_deadline_get_context_beginning_ok(freq, periods, start, prediction_size def test_deadline_get_context_beginning_fail_not_enough_context( freq, periods, start, prediction_size, seasonality, window ): - df = pd.DataFrame({"timestamp": pd.date_range(start=start, periods=periods, freq=freq)}) + timestamp = pd.date_range(start=start, periods=periods, freq=freq) + df = pd.DataFrame({"target": 1}, index=timestamp) with pytest.raises(ValueError, match="Given context isn't big enough"): - _ = _DeadlineMovingAverageModel._get_context_beginning(df, prediction_size, seasonality, window) + _ = DeadlineMovingAverageModel._get_context_beginning(df, prediction_size, seasonality, window) @pytest.mark.parametrize("model", [DeadlineMovingAverageModel]) @@ -167,6 +168,14 @@ def test_deadline_model_predict(simple_df, model): _check_predict(ts=simple_df, model=model(window=1), prediction_size=7) +def test_deadline_model_fit_fail_not_supported_freq(): + df = generate_ar_df(start_time="2020-01-01", periods=100, freq="2D") + ts = TSDataset(df=TSDataset.to_dataset(df), freq="2D") + model = DeadlineMovingAverageModel(window=1000) + with pytest.raises(ValueError, match="Freq 2D is not supported"): + model.fit(ts) + + def test_deadline_model_forecast_fail_not_enough_context(simple_df): model = DeadlineMovingAverageModel(window=1000) model.fit(simple_df) @@ -179,7 +188,7 @@ def test_deadline_model_predict_fail_not_enough_context(simple_df): model = DeadlineMovingAverageModel(window=1000) model.fit(simple_df) with pytest.raises(ValueError, match="Given context isn't big enough"): - _ = model.forecast(simple_df, prediction_size=7) + _ = model.predict(simple_df, prediction_size=7) def test_deadline_model_forecast_fail_nans_in_context(simple_df): @@ -199,6 +208,25 @@ def test_deadline_model_predict_fail_nans_in_context(simple_df): _ = model.predict(simple_df, prediction_size=7) +def test_deadline_model_context_size_fail_not_fitted(simple_df): + model = DeadlineMovingAverageModel(window=1000) + with pytest.raises(ValueError, match="Model is not fitted"): + _ = model.context_size + + +def test_deadline_model_forecast_fail_not_fitted(simple_df): + model = DeadlineMovingAverageModel(window=1000) + future_ts = simple_df.make_future(future_steps=7, tail_steps=100) + with pytest.raises(ValueError, match="Model is not fitted"): + _ = model.forecast(future_ts, prediction_size=7) + + +def test_deadline_model_predict_fail_not_fitted(simple_df): + model = DeadlineMovingAverageModel(window=1000) + with pytest.raises(ValueError, match="Model is not fitted"): + _ = model.predict(simple_df, prediction_size=7) + + def test_seasonal_moving_average_forecast_correct(simple_df): model = SeasonalMovingAverageModel(window=3, seasonality=7) model.fit(simple_df) @@ -207,19 +235,20 @@ def test_seasonal_moving_average_forecast_correct(simple_df): res = res.to_pandas(flatten=True)[["target", "segment", "timestamp"]] df1 = pd.DataFrame() - df1["target"] = np.arange(35, 42) + df1["target"] = np.arange(35, 42, dtype=float) df1["segment"] = "A" df1["timestamp"] = pd.date_range(start="2020-02-19", periods=7) df2 = pd.DataFrame() - df2["target"] = [0, 2, 4, 6, 8, 10, 12] + df2["target"] = [0.0, 2, 4, 6, 8, 10, 12] df2["segment"] = "B" df2["timestamp"] = pd.date_range(start="2020-02-19", periods=7) answer = pd.concat([df2, df1], axis=0, ignore_index=True) - res = res.sort_values(by=["segment", "timestamp"]) - answer = answer.sort_values(by=["segment", "timestamp"]) - assert np.all(res.values == answer.values) + res = res.sort_values(by=["segment", "timestamp"]).reset_index(drop=True) + answer = answer.sort_values(by=["segment", "timestamp"]).reset_index(drop=True) + + pd.testing.assert_frame_equal(res, answer) def test_naive_forecast_correct(simple_df): @@ -230,20 +259,20 @@ def test_naive_forecast_correct(simple_df): res = res.to_pandas(flatten=True)[["target", "segment", "timestamp"]] df1 = pd.DataFrame() - df1["target"] = [46, 47, 48] * 2 + [46] + df1["target"] = [46.0, 47, 48] * 2 + [46] df1["segment"] = "A" df1["timestamp"] = pd.date_range(start="2020-02-19", periods=7) df2 = pd.DataFrame() - df2["target"] = [8, 10, 12] * 2 + [8] + df2["target"] = [8.0, 10, 12] * 2 + [8] df2["segment"] = "B" df2["timestamp"] = pd.date_range(start="2020-02-19", periods=7) answer = pd.concat([df2, df1], axis=0, ignore_index=True) - res = res.sort_values(by=["segment", "timestamp"]) - answer = answer.sort_values(by=["segment", "timestamp"]) + res = res.sort_values(by=["segment", "timestamp"]).reset_index(drop=True) + answer = answer.sort_values(by=["segment", "timestamp"]).reset_index(drop=True) - assert np.all(res.values == answer.values) + pd.testing.assert_frame_equal(res, answer) def test_moving_average_forecast_correct(simple_df): @@ -254,7 +283,7 @@ def test_moving_average_forecast_correct(simple_df): res = res.to_pandas(flatten=True)[["target", "segment", "timestamp"]] df1 = pd.DataFrame() - tmp = np.arange(44, 49) + tmp = np.arange(44, 49, dtype=float) for i in range(7): tmp = np.append(tmp, [tmp[-5:].mean()]) df1["target"] = tmp[-7:] @@ -262,7 +291,7 @@ def test_moving_average_forecast_correct(simple_df): df1["timestamp"] = pd.date_range(start="2020-02-19", periods=7) df2 = pd.DataFrame() - tmp = np.arange(0, 13, 2) + tmp = np.arange(0, 13, 2, dtype=float) for i in range(7): tmp = np.append(tmp, [tmp[-5:].mean()]) df2["target"] = tmp[-7:] @@ -270,10 +299,10 @@ def test_moving_average_forecast_correct(simple_df): df2["timestamp"] = pd.date_range(start="2020-02-19", periods=7) answer = pd.concat([df2, df1], axis=0, ignore_index=True) - res = res.sort_values(by=["segment", "timestamp"]) - answer = answer.sort_values(by=["segment", "timestamp"]) + res = res.sort_values(by=["segment", "timestamp"]).reset_index(drop=True) + answer = answer.sort_values(by=["segment", "timestamp"]).reset_index(drop=True) - assert np.all(res.values == answer.values) + pd.testing.assert_frame_equal(res, answer) def test_deadline_moving_average_forecast_correct(df): @@ -340,9 +369,10 @@ def test_deadline_moving_average_forecast_correct(df): df2["timestamp"] = pd.date_range(start="2020-05-20", periods=20) answer = pd.concat([df2, df1], axis=0, ignore_index=True) - res = res.sort_values(by=["segment", "timestamp"]) - answer = answer.sort_values(by=["segment", "timestamp"]) - assert np.all(res.values == answer.values) + res = res.sort_values(by=["segment", "timestamp"]).reset_index(drop=True) + answer = answer.sort_values(by=["segment", "timestamp"]).reset_index(drop=True) + + pd.testing.assert_frame_equal(res, answer) def test_seasonal_moving_average_predict_correct(simple_df): @@ -352,19 +382,20 @@ def test_seasonal_moving_average_predict_correct(simple_df): res = res.to_pandas(flatten=True)[["target", "segment", "timestamp"]] df1 = pd.DataFrame() - df1["target"] = np.arange(39, 46) + df1["target"] = np.arange(39, 46, dtype=float) df1["segment"] = "A" df1["timestamp"] = pd.date_range(start="2020-02-12", periods=7) df2 = pd.DataFrame() - df2["target"] = [8, 10, 5, 7, 2, 4, 6] + df2["target"] = [8.0, 10, 5, 7, 2, 4, 6] df2["segment"] = "B" df2["timestamp"] = pd.date_range(start="2020-02-12", periods=7) answer = pd.concat([df2, df1], axis=0, ignore_index=True) - res = res.sort_values(by=["segment", "timestamp"]) - answer = answer.sort_values(by=["segment", "timestamp"]) - assert np.all(res.values == answer.values) + res = res.sort_values(by=["segment", "timestamp"]).reset_index(drop=True) + answer = answer.sort_values(by=["segment", "timestamp"]).reset_index(drop=True) + + pd.testing.assert_frame_equal(res, answer) def test_naive_predict_correct(simple_df): @@ -374,20 +405,20 @@ def test_naive_predict_correct(simple_df): res = res.to_pandas(flatten=True)[["target", "segment", "timestamp"]] df1 = pd.DataFrame() - df1["target"] = np.arange(39, 46) + df1["target"] = np.arange(39, 46, dtype=float) df1["segment"] = "A" df1["timestamp"] = pd.date_range(start="2020-02-12", periods=7) df2 = pd.DataFrame() - df2["target"] = [8, 10, 12, 0, 2, 4, 6] + df2["target"] = [8.0, 10, 12, 0, 2, 4, 6] df2["segment"] = "B" df2["timestamp"] = pd.date_range(start="2020-02-12", periods=7) answer = pd.concat([df2, df1], axis=0, ignore_index=True) - res = res.sort_values(by=["segment", "timestamp"]) - answer = answer.sort_values(by=["segment", "timestamp"]) + res = res.sort_values(by=["segment", "timestamp"]).reset_index(drop=True) + answer = answer.sort_values(by=["segment", "timestamp"]).reset_index(drop=True) - assert np.all(res.values == answer.values) + pd.testing.assert_frame_equal(res, answer) def test_moving_average_predict_correct(simple_df): @@ -397,7 +428,7 @@ def test_moving_average_predict_correct(simple_df): res = res.to_pandas(flatten=True)[["target", "segment", "timestamp"]] df1 = pd.DataFrame() - df1["target"] = np.arange(39, 46) + df1["target"] = np.arange(39, 46, dtype=float) df1["segment"] = "A" df1["timestamp"] = pd.date_range(start="2020-02-12", periods=7) @@ -407,10 +438,10 @@ def test_moving_average_predict_correct(simple_df): df2["timestamp"] = pd.date_range(start="2020-02-12", periods=7) answer = pd.concat([df2, df1], axis=0, ignore_index=True) - res = res.sort_values(by=["segment", "timestamp"]) - answer = answer.sort_values(by=["segment", "timestamp"]) + res = res.sort_values(by=["segment", "timestamp"]).reset_index(drop=True) + answer = answer.sort_values(by=["segment", "timestamp"]).reset_index(drop=True) - assert np.all(res.values == answer.values) + pd.testing.assert_frame_equal(res, answer) def test_deadline_moving_average_predict_correct(df): @@ -476,9 +507,10 @@ def test_deadline_moving_average_predict_correct(df): df2["timestamp"] = pd.date_range(start="2020-04-30", periods=20) answer = pd.concat([df2, df1], axis=0, ignore_index=True) - res = res.sort_values(by=["segment", "timestamp"]) - answer = answer.sort_values(by=["segment", "timestamp"]) - assert np.all(res.values == answer.values) + res = res.sort_values(by=["segment", "timestamp"]).reset_index(drop=True) + answer = answer.sort_values(by=["segment", "timestamp"]).reset_index(drop=True) + + pd.testing.assert_frame_equal(res, answer) @pytest.mark.parametrize( @@ -530,32 +562,18 @@ def test_context_size_deadline_ma(model, freq, expected_context_size): @pytest.mark.parametrize( "etna_model_class", - (SeasonalMovingAverageModel, MovingAverageModel, NaiveModel, DeadlineMovingAverageModel), -) -def test_get_model_before_training(etna_model_class): - """Check that get_model method throws an error if per-segment model is not fitted yet.""" - etna_model = etna_model_class() - with pytest.raises(ValueError, match="Can not get the dict with base models, the model is not fitted!"): - _ = etna_model.get_model() - - -@pytest.mark.parametrize( - "etna_model_class,expected_class", ( - (NaiveModel, _SeasonalMovingAverageModel), - (SeasonalMovingAverageModel, _SeasonalMovingAverageModel), - (MovingAverageModel, _SeasonalMovingAverageModel), - (DeadlineMovingAverageModel, _DeadlineMovingAverageModel), + NaiveModel, + SeasonalMovingAverageModel, + MovingAverageModel, + DeadlineMovingAverageModel, ), ) -def test_get_model_after_training(example_tsds, etna_model_class, expected_class): - """Check that get_model method returns dict of objects of _SeasonalMovingAverageModel class.""" +def test_get_model(example_tsds, etna_model_class): pipeline = Pipeline(model=etna_model_class()) pipeline.fit(ts=example_tsds) - models_dict = pipeline.model.get_model() - assert isinstance(models_dict, dict) - for segment in example_tsds.segments: - assert isinstance(models_dict[segment], expected_class) + model = pipeline.model.get_model() + assert isinstance(model, etna_model_class) @pytest.fixture diff --git a/tests/test_pipeline/conftest.py b/tests/test_pipeline/conftest.py index e3dbb3464..eb88f93a4 100644 --- a/tests/test_pipeline/conftest.py +++ b/tests/test_pipeline/conftest.py @@ -8,6 +8,7 @@ from etna.datasets import TSDataset from etna.models import CatBoostPerSegmentModel +from etna.models import NaiveModel from etna.pipeline import Pipeline from etna.transforms import LagTransform @@ -25,6 +26,16 @@ def catboost_pipeline() -> Pipeline: return pipeline +@pytest.fixture +def naive_pipeline() -> Pipeline: + """Generate pipeline with NaiveModel.""" + pipeline = Pipeline( + model=NaiveModel(lag=7), + horizon=7, + ) + return pipeline + + @pytest.fixture def catboost_pipeline_big() -> Pipeline: """Generate pipeline with CatBoostPerSegmentModel.""" @@ -218,7 +229,7 @@ def masked_ts() -> TSDataset: @pytest.fixture -def ts_run_fold() -> TSDataset: +def ts_process_fold_forecast() -> TSDataset: timerange = pd.date_range(start="2020-01-01", periods=11).to_list() df = pd.DataFrame({"timestamp": timerange + timerange}) df["segment"] = ["segment_0"] * 11 + ["segment_1"] * 11 diff --git a/tests/test_pipeline/test_autoregressive_pipeline.py b/tests/test_pipeline/test_autoregressive_pipeline.py index 939d3bad4..7c9b77006 100644 --- a/tests/test_pipeline/test_autoregressive_pipeline.py +++ b/tests/test_pipeline/test_autoregressive_pipeline.py @@ -27,6 +27,8 @@ from etna.transforms import LagTransform from etna.transforms import LinearTrendTransform from tests.test_pipeline.utils import assert_pipeline_equals_loaded_original +from tests.test_pipeline.utils import assert_pipeline_forecasts_given_ts +from tests.test_pipeline.utils import assert_pipeline_forecasts_given_ts_with_prediction_intervals DEFAULT_METRICS = [MAE(mode=MetricAggregationMode.per_segment)] @@ -75,7 +77,7 @@ def test_private_forecast_context_ignorant_model(model_class, example_tsds): with patch.object(TSDataset, "make_future", make_future): pipeline = AutoRegressivePipeline(model=model, horizon=5, step=1) pipeline.fit(example_tsds) - _ = pipeline._forecast() + _ = pipeline._forecast(ts=example_tsds) assert make_future.mock.call_count == 5 make_future.mock.assert_called_with(future_steps=pipeline.step) @@ -97,7 +99,7 @@ def test_private_forecast_context_required_model(model_class, example_tsds): with patch.object(TSDataset, "make_future", make_future): pipeline = AutoRegressivePipeline(model=model, horizon=5, step=1) pipeline.fit(example_tsds) - _ = pipeline._forecast() + _ = pipeline._forecast(ts=example_tsds) assert make_future.mock.call_count == 5 make_future.mock.assert_called_with(future_steps=pipeline.step, tail_steps=model.context_size) @@ -197,10 +199,10 @@ def test_forecast_with_fit_transforms(example_tsds): pipeline.forecast() -def test_forecast_raise_error_if_not_fitted(): - """Test that AutoRegressivePipeline raise error when calling forecast without being fit.""" +def test_forecast_raise_error_if_no_ts(): + """Test that AutoRegressivePipeline raises error when calling forecast without ts.""" pipeline = AutoRegressivePipeline(model=LinearPerSegmentModel(), horizon=5) - with pytest.raises(ValueError, match="AutoRegressivePipeline is not fitted!"): + with pytest.raises(ValueError, match="There is no ts to forecast!"): _ = pipeline.forecast() @@ -275,6 +277,7 @@ def test_predict(model, transforms, example_tsds): assert len(result_df) == len(example_tsds.segments) * num_points +@pytest.mark.parametrize("load_ts", [True, False]) @pytest.mark.parametrize( "model, transforms", [ @@ -291,7 +294,51 @@ def test_predict(model, transforms, example_tsds): (ProphetModel(), []), ], ) -def test_save_load(model, transforms, example_tsds): +def test_save_load(load_ts, model, transforms, example_tsds): horizon = 3 pipeline = AutoRegressivePipeline(model=model, transforms=transforms, horizon=horizon, step=1) - assert_pipeline_equals_loaded_original(pipeline=pipeline, ts=example_tsds) + assert_pipeline_equals_loaded_original(pipeline=pipeline, ts=example_tsds, load_ts=load_ts) + + +@pytest.mark.parametrize( + "model, transforms", + [ + ( + CatBoostMultiSegmentModel(iterations=100), + [DateFlagsTransform(), LagTransform(in_column="target", lags=list(range(3, 10)))], + ), + ( + LinearPerSegmentModel(), + [DateFlagsTransform(), LagTransform(in_column="target", lags=list(range(3, 10)))], + ), + (SeasonalMovingAverageModel(window=2, seasonality=7), []), + (SARIMAXModel(), []), + (ProphetModel(), []), + ], +) +def test_forecast_given_ts(model, transforms, example_tsds): + horizon = 3 + pipeline = AutoRegressivePipeline(model=model, transforms=transforms, horizon=horizon) + assert_pipeline_forecasts_given_ts(pipeline=pipeline, ts=example_tsds, horizon=horizon) + + +@pytest.mark.parametrize( + "model, transforms", + [ + ( + CatBoostMultiSegmentModel(iterations=100), + [DateFlagsTransform(), LagTransform(in_column="target", lags=list(range(3, 10)))], + ), + ( + LinearPerSegmentModel(), + [DateFlagsTransform(), LagTransform(in_column="target", lags=list(range(3, 10)))], + ), + (SeasonalMovingAverageModel(window=2, seasonality=7), []), + (SARIMAXModel(), []), + (ProphetModel(), []), + ], +) +def test_forecast_given_ts_with_prediction_interval(model, transforms, example_tsds): + horizon = 3 + pipeline = AutoRegressivePipeline(model=model, transforms=transforms, horizon=horizon) + assert_pipeline_forecasts_given_ts_with_prediction_intervals(pipeline=pipeline, ts=example_tsds, horizon=horizon) diff --git a/tests/test_pipeline/test_hierarchical_pipeline.py b/tests/test_pipeline/test_hierarchical_pipeline.py index 8424a29a1..c7622b642 100644 --- a/tests/test_pipeline/test_hierarchical_pipeline.py +++ b/tests/test_pipeline/test_hierarchical_pipeline.py @@ -1,20 +1,29 @@ +import pathlib from unittest.mock import Mock +from unittest.mock import patch import numpy as np +import pandas as pd import pytest from etna.datasets.utils import match_target_quantiles from etna.metrics import MAE from etna.metrics import Coverage from etna.metrics import Width +from etna.models import CatBoostMultiSegmentModel from etna.models import LinearPerSegmentModel from etna.models import NaiveModel +from etna.models import ProphetModel from etna.pipeline.hierarchical_pipeline import HierarchicalPipeline from etna.reconciliation import BottomUpReconciliator from etna.reconciliation import TopDownReconciliator +from etna.transforms import DateFlagsTransform from etna.transforms import LagTransform from etna.transforms import LinearTrendTransform from etna.transforms import MeanTransform +from tests.test_pipeline.utils import assert_pipeline_equals_loaded_original +from tests.test_pipeline.utils import assert_pipeline_forecasts_given_ts +from tests.test_pipeline.utils import assert_pipeline_forecasts_given_ts_with_prediction_intervals @pytest.mark.parametrize( @@ -79,7 +88,7 @@ def test_raw_forecast_correctness(market_level_constant_hierarchical_ts, reconci model = NaiveModel() pipeline = HierarchicalPipeline(reconciliator=reconciliator, model=model, transforms=[], horizon=1) pipeline.fit(ts=market_level_constant_hierarchical_ts) - forecast = pipeline.raw_forecast() + forecast = pipeline.raw_forecast(ts=market_level_constant_hierarchical_ts) np.testing.assert_array_almost_equal(forecast[..., "target"].values, answer) @@ -94,7 +103,7 @@ def test_raw_forecast_level(market_level_simple_hierarchical_ts, reconciliator): model = NaiveModel() pipeline = HierarchicalPipeline(reconciliator=reconciliator, model=model, transforms=[], horizon=1) pipeline.fit(ts=market_level_simple_hierarchical_ts) - forecast = pipeline.raw_forecast() + forecast = pipeline.raw_forecast(ts=market_level_simple_hierarchical_ts) assert forecast.current_df_level == pipeline.reconciliator.source_level @@ -260,3 +269,156 @@ def test_interval_metrics(product_level_constant_hierarchical_ts, metric_type, r forecast_params={"prediction_interval": True, "n_folds": 1}, ) np.testing.assert_array_almost_equal(results[metric.name], answer) + + +@patch("etna.pipeline.pipeline.Pipeline.save") +def test_save(save_mock, product_level_constant_hierarchical_ts, tmp_path): + ts = product_level_constant_hierarchical_ts + model = NaiveModel() + reconciliator = BottomUpReconciliator(target_level="market", source_level="product") + pipeline = HierarchicalPipeline(reconciliator=reconciliator, model=model, transforms=[], horizon=1) + dir_path = pathlib.Path(tmp_path) + path = dir_path / "dummy.zip" + pipeline.fit(ts) + + def check_no_fit_ts(path): + assert not hasattr(pipeline, "_fit_ts") + + save_mock.side_effect = check_no_fit_ts + + pipeline.save(path) + + save_mock.assert_called_once_with(path=path) + assert hasattr(pipeline, "_fit_ts") + + +@patch("etna.pipeline.pipeline.Pipeline.load") +def test_load_no_ts(load_mock, product_level_constant_hierarchical_ts, tmp_path): + ts = product_level_constant_hierarchical_ts + model = NaiveModel() + reconciliator = BottomUpReconciliator(target_level="market", source_level="product") + pipeline = HierarchicalPipeline(reconciliator=reconciliator, model=model, transforms=[], horizon=1) + dir_path = pathlib.Path(tmp_path) + path = dir_path / "dummy.zip" + pipeline.fit(ts) + + pipeline.save(path) + loaded_pipeline = HierarchicalPipeline.load(path) + + load_mock.assert_called_once_with(path=path) + assert loaded_pipeline._fit_ts is None + assert loaded_pipeline.ts is None + assert loaded_pipeline == load_mock.return_value + + +@patch("etna.pipeline.pipeline.Pipeline.load") +def test_load_with_ts(load_mock, product_level_constant_hierarchical_ts, tmp_path): + ts = product_level_constant_hierarchical_ts + model = NaiveModel() + reconciliator = BottomUpReconciliator(target_level="market", source_level="product") + pipeline = HierarchicalPipeline(reconciliator=reconciliator, model=model, transforms=[], horizon=1) + dir_path = pathlib.Path(tmp_path) + path = dir_path / "dummy.zip" + pipeline.fit(ts) + + pipeline.save(path) + loaded_pipeline = HierarchicalPipeline.load(path, ts=ts) + + load_mock.assert_called_once_with(path=path) + load_mock.return_value.reconciliator.aggregate.assert_called_once_with(ts=ts) + pd.testing.assert_frame_equal(loaded_pipeline._fit_ts.to_pandas(), ts.to_pandas()) + assert loaded_pipeline.ts == load_mock.return_value.reconciliator.aggregate.return_value + + +@pytest.mark.parametrize( + "reconciliator", + ( + TopDownReconciliator(target_level="product", source_level="market", period=1, method="AHP"), + TopDownReconciliator(target_level="product", source_level="market", period=1, method="PHA"), + BottomUpReconciliator(target_level="market", source_level="product"), + BottomUpReconciliator(target_level="total", source_level="market"), + ), +) +@pytest.mark.parametrize( + "model, transforms", + [ + ( + CatBoostMultiSegmentModel(iterations=100), + [DateFlagsTransform(), LagTransform(in_column="target", lags=[1])], + ), + ( + LinearPerSegmentModel(), + [DateFlagsTransform(), LagTransform(in_column="target", lags=[1])], + ), + (NaiveModel(), []), + (ProphetModel(), []), + ], +) +def test_save_load(model, transforms, reconciliator, product_level_constant_hierarchical_ts): + horizon = 1 + pipeline = HierarchicalPipeline(reconciliator=reconciliator, model=model, transforms=transforms, horizon=horizon) + assert_pipeline_equals_loaded_original(pipeline=pipeline, ts=product_level_constant_hierarchical_ts) + + +@pytest.mark.parametrize( + "reconciliator", + ( + TopDownReconciliator(target_level="product", source_level="market", period=1, method="AHP"), + TopDownReconciliator(target_level="product", source_level="market", period=1, method="PHA"), + BottomUpReconciliator(target_level="market", source_level="product"), + BottomUpReconciliator(target_level="total", source_level="market"), + ), +) +@pytest.mark.parametrize( + "model, transforms", + [ + ( + CatBoostMultiSegmentModel(iterations=100), + [DateFlagsTransform(), LagTransform(in_column="target", lags=[1])], + ), + ( + LinearPerSegmentModel(), + [DateFlagsTransform(), LagTransform(in_column="target", lags=[1])], + ), + (NaiveModel(), []), + (ProphetModel(), []), + ], +) +def test_forecast_given_ts(model, transforms, reconciliator, product_level_constant_hierarchical_ts): + horizon = 1 + pipeline = HierarchicalPipeline(reconciliator=reconciliator, model=model, transforms=transforms, horizon=horizon) + assert_pipeline_forecasts_given_ts(pipeline=pipeline, ts=product_level_constant_hierarchical_ts, horizon=horizon) + + +@pytest.mark.parametrize( + "reconciliator", + ( + TopDownReconciliator(target_level="product", source_level="market", period=1, method="AHP"), + TopDownReconciliator(target_level="product", source_level="market", period=1, method="PHA"), + BottomUpReconciliator(target_level="market", source_level="product"), + BottomUpReconciliator(target_level="total", source_level="market"), + ), +) +@pytest.mark.parametrize( + "model, transforms", + [ + ( + CatBoostMultiSegmentModel(iterations=100), + [DateFlagsTransform(), LagTransform(in_column="target", lags=[1])], + ), + ( + LinearPerSegmentModel(), + [DateFlagsTransform(), LagTransform(in_column="target", lags=[1])], + ), + (NaiveModel(), []), + (ProphetModel(), []), + ], +) +def test_forecast_given_ts_with_prediction_interval( + model, transforms, reconciliator, product_level_constant_hierarchical_ts +): + horizon = 1 + pipeline = HierarchicalPipeline(reconciliator=reconciliator, model=model, transforms=transforms, horizon=horizon) + assert_pipeline_forecasts_given_ts_with_prediction_intervals( + pipeline=pipeline, ts=product_level_constant_hierarchical_ts, horizon=horizon, n_folds=2 + ) diff --git a/tests/test_pipeline/test_pipeline.py b/tests/test_pipeline/test_pipeline.py index 31358459e..5f2a13818 100644 --- a/tests/test_pipeline/test_pipeline.py +++ b/tests/test_pipeline/test_pipeline.py @@ -1,5 +1,4 @@ from copy import deepcopy -from datetime import datetime from typing import Dict from typing import List from unittest.mock import MagicMock @@ -14,7 +13,6 @@ from etna.metrics import MAE from etna.metrics import MSE from etna.metrics import SMAPE -from etna.metrics import Metric from etna.metrics import MetricAggregationMode from etna.metrics import Width from etna.models import CatBoostMultiSegmentModel @@ -30,13 +28,17 @@ from etna.models.base import PredictionIntervalContextRequiredAbstractModel from etna.pipeline import FoldMask from etna.pipeline import Pipeline +from etna.pipeline.base import CrossValidationMode from etna.transforms import AddConstTransform from etna.transforms import DateFlagsTransform +from etna.transforms import DifferencingTransform from etna.transforms import FilterFeaturesTransform from etna.transforms import LagTransform from etna.transforms import LogTransform from etna.transforms import TimeSeriesImputerTransform from tests.test_pipeline.utils import assert_pipeline_equals_loaded_original +from tests.test_pipeline.utils import assert_pipeline_forecasts_given_ts +from tests.test_pipeline.utils import assert_pipeline_forecasts_given_ts_with_prediction_intervals from tests.utils import DummyMetric DEFAULT_METRICS = [MAE(mode=MetricAggregationMode.per_segment)] @@ -107,7 +109,7 @@ def test_private_forecast_context_ignorant_model(model_class): pipeline = Pipeline(model=model, horizon=5) pipeline.fit(ts) - _ = pipeline._forecast() + _ = pipeline._forecast(ts=ts) ts.make_future.assert_called_with(future_steps=pipeline.horizon) model.forecast.assert_called_with(ts=ts.make_future()) @@ -122,7 +124,7 @@ def test_private_forecast_context_required_model(model_class): pipeline = Pipeline(model=model, horizon=5) pipeline.fit(ts) - _ = pipeline._forecast() + _ = pipeline._forecast(ts=ts) ts.make_future.assert_called_with(future_steps=pipeline.horizon, tail_steps=model.context_size) model.forecast.assert_called_with(ts=ts.make_future(), prediction_size=pipeline.horizon) @@ -166,7 +168,7 @@ def test_forecast_with_intervals_other_model(base_forecast, model_class): pipeline = Pipeline(model=model, horizon=5) pipeline.fit(ts) _ = pipeline.forecast(prediction_interval=True, quantiles=(0.025, 0.975)) - base_forecast.assert_called_with(prediction_interval=True, quantiles=(0.025, 0.975), n_folds=3) + base_forecast.assert_called_with(ts=ts, prediction_interval=True, quantiles=(0.025, 0.975), n_folds=3) def test_forecast(example_tsds): @@ -221,7 +223,7 @@ def test_forecast_prediction_interval_builtin(example_tsds, model): @pytest.mark.parametrize("model", (MovingAverageModel(), LinearPerSegmentModel())) -def test_forecast_prediction_interval_interface(example_tsds, model): +def test_forecast_prediction_interval_not_builtin(example_tsds, model): """Test the forecast interface for the models without built-in prediction intervals.""" pipeline = Pipeline(model=model, transforms=[DateFlagsTransform()], horizon=5) pipeline.fit(example_tsds) @@ -232,7 +234,7 @@ def test_forecast_prediction_interval_interface(example_tsds, model): assert (segment_slice["target_0.975"] - segment_slice["target_0.025"] >= 0).all() -def test_forecast_prediction_interval(splited_piecewise_constant_ts): +def test_forecast_prediction_interval_correct_values(splited_piecewise_constant_ts): """Test that the prediction interval for piecewise-constant dataset is correct.""" train, test = splited_piecewise_constant_ts pipeline = Pipeline(model=NaiveModel(lag=1), transforms=[], horizon=5) @@ -279,106 +281,86 @@ def test_forecast_prediction_interval_noise(constant_ts, constant_noisy_ts): @pytest.mark.parametrize("n_folds", (0, -1)) def test_invalid_n_folds(catboost_pipeline: Pipeline, n_folds: int, example_tsdf: TSDataset): """Test Pipeline.backtest behavior in case of invalid n_folds.""" - with pytest.raises(ValueError): + with pytest.raises(ValueError, match="Folds number should be a positive number"): _ = catboost_pipeline.backtest(ts=example_tsdf, metrics=DEFAULT_METRICS, n_folds=n_folds) -def test_validate_backtest_dataset(catboost_pipeline_big: Pipeline, imbalanced_tsdf: TSDataset): - """Test Pipeline.backtest behavior in case of small dataframe that - can't be divided to required number of splits. - """ - with pytest.raises(ValueError): - _ = catboost_pipeline_big.backtest(ts=imbalanced_tsdf, n_folds=3, metrics=DEFAULT_METRICS) - +@pytest.mark.parametrize( + "min_size, n_folds, horizon, stride", + [ + (1, 10, 1, 1), + (9, 10, 1, 1), + (10, 10, 2, 1), + (19, 10, 2, 2), + (28, 10, 2, 3), + ], +) +def test_invalid_backtest_dataset_size(min_size, n_folds, horizon, stride): + """Test Pipeline.backtest behavior in case of too small dataframe for given number of folds.""" + df = generate_ar_df(start_time="2020-01-01", periods=100, n_segments=2, freq="D") + df_wide = TSDataset.to_dataset(df) + to_remove = len(df_wide) - min_size + df_wide.iloc[:to_remove, 0] = np.NaN + ts = TSDataset(df=df_wide, freq="D") + pipeline = Pipeline(model=NaiveModel(lag=horizon), horizon=horizon) + + with pytest.raises(ValueError, match="All the series from feature dataframe should contain at least .* timestamps"): + _ = pipeline.backtest(ts=ts, n_folds=n_folds, stride=stride, metrics=DEFAULT_METRICS) + + +def test_invalid_backtest_metrics_empty(catboost_pipeline: Pipeline, example_tsdf: TSDataset): + """Test Pipeline.backtest behavior in case of empty metrics.""" + with pytest.raises(ValueError, match="At least one metric required"): + _ = catboost_pipeline.backtest(ts=example_tsdf, metrics=[], n_folds=2) + + +def test_invalid_backtest_metrics_macro(catboost_pipeline: Pipeline, example_tsdf: TSDataset): + """Test Pipeline.backtest behavior in case of macro metrics.""" + with pytest.raises(ValueError, match="All the metrics should be in"): + _ = catboost_pipeline.backtest(ts=example_tsdf, metrics=[MAE(mode=MetricAggregationMode.macro)], n_folds=2) + + +def test_invalid_backtest_mode_set_on_fold_mask(catboost_pipeline: Pipeline, example_tsdf: TSDataset): + """Test Pipeline.backtest behavior on setting mode with fold masks.""" + masks = [ + FoldMask( + first_train_timestamp="2020-01-01", + last_train_timestamp="2020-04-03", + target_timestamps=["2020-04-04", "2020-04-05", "2020-04-06"], + ), + FoldMask( + first_train_timestamp="2020-01-01", + last_train_timestamp="2020-04-06", + target_timestamps=["2020-04-07", "2020-04-08", "2020-04-09"], + ), + ] + with pytest.raises(ValueError, match="Mode shouldn't be set if n_folds are fold masks"): + _ = catboost_pipeline.backtest(ts=example_tsdf, n_folds=masks, mode="expand", metrics=DEFAULT_METRICS) + + +def test_invalid_backtest_stride_set_on_fold_mask(catboost_pipeline: Pipeline, example_tsdf: TSDataset): + """Test Pipeline.backtest behavior on setting stride with fold masks.""" + masks = [ + FoldMask( + first_train_timestamp="2020-01-01", + last_train_timestamp="2020-04-03", + target_timestamps=["2020-04-04", "2020-04-05", "2020-04-06"], + ), + FoldMask( + first_train_timestamp="2020-01-01", + last_train_timestamp="2020-04-06", + target_timestamps=["2020-04-07", "2020-04-08", "2020-04-09"], + ), + ] + with pytest.raises(ValueError, match="Stride shouldn't be set if n_folds are fold masks"): + _ = catboost_pipeline.backtest(ts=example_tsdf, n_folds=masks, stride=2, metrics=DEFAULT_METRICS) -@pytest.mark.parametrize("metrics", ([], [MAE(mode=MetricAggregationMode.macro)])) -def test_invalid_backtest_metrics(catboost_pipeline: Pipeline, metrics: List[Metric], example_tsdf: TSDataset): - """Test Pipeline.backtest behavior in case of invalid metrics.""" - with pytest.raises(ValueError): - _ = catboost_pipeline.backtest(ts=example_tsdf, metrics=metrics, n_folds=2) - -def test_generate_expandable_timeranges_days(): - """Test train-test timeranges generation in expand mode with daily freq""" - df = pd.DataFrame({"timestamp": pd.date_range("2021-01-01", "2021-04-01")}) - df["segment"] = "seg" - df["target"] = 1 - df = df.pivot(index="timestamp", columns="segment").reorder_levels([1, 0], axis=1).sort_index(axis=1) - df.columns.names = ["segment", "feature"] - ts = TSDataset(df, freq="D") - - true_borders = ( - (("2021-01-01", "2021-02-24"), ("2021-02-25", "2021-03-08")), - (("2021-01-01", "2021-03-08"), ("2021-03-09", "2021-03-20")), - (("2021-01-01", "2021-03-20"), ("2021-03-21", "2021-04-01")), - ) - masks = Pipeline._generate_masks_from_n_folds(ts=ts, n_folds=3, horizon=12, mode="expand") - for i, stage_dfs in enumerate(Pipeline._generate_folds_datasets(ts, masks=masks, horizon=12)): - for stage_df, borders in zip(stage_dfs, true_borders[i]): - assert stage_df.index.min() == datetime.strptime(borders[0], "%Y-%m-%d").date() - assert stage_df.index.max() == datetime.strptime(borders[1], "%Y-%m-%d").date() - - -def test_generate_expandable_timeranges_hours(): - """Test train-test timeranges generation in expand mode with hour freq""" - df = pd.DataFrame({"timestamp": pd.date_range("2020-01-01", "2020-02-01", freq="H")}) - df["segment"] = "seg" - df["target"] = 1 - df = df.pivot(index="timestamp", columns="segment").reorder_levels([1, 0], axis=1).sort_index(axis=1) - df.columns.names = ["segment", "feature"] - ts = TSDataset(df, freq="H") - - true_borders = ( - (("2020-01-01 00:00:00", "2020-01-30 12:00:00"), ("2020-01-30 13:00:00", "2020-01-31 00:00:00")), - (("2020-01-01 00:00:00", "2020-01-31 00:00:00"), ("2020-01-31 01:00:00", "2020-01-31 12:00:00")), - (("2020-01-01 00:00:00", "2020-01-31 12:00:00"), ("2020-01-31 13:00:00", "2020-02-01 00:00:00")), - ) - masks = Pipeline._generate_masks_from_n_folds(ts=ts, n_folds=3, horizon=12, mode="expand") - for i, stage_dfs in enumerate(Pipeline._generate_folds_datasets(ts, horizon=12, masks=masks)): - for stage_df, borders in zip(stage_dfs, true_borders[i]): - assert stage_df.index.min() == datetime.strptime(borders[0], "%Y-%m-%d %H:%M:%S").date() - assert stage_df.index.max() == datetime.strptime(borders[1], "%Y-%m-%d %H:%M:%S").date() - - -def test_generate_constant_timeranges_days(): - """Test train-test timeranges generation with constant mode with daily freq""" - df = pd.DataFrame({"timestamp": pd.date_range("2021-01-01", "2021-04-01")}) - df["segment"] = "seg" - df["target"] = 1 - df = df.pivot(index="timestamp", columns="segment").reorder_levels([1, 0], axis=1).sort_index(axis=1) - df.columns.names = ["segment", "feature"] - ts = TSDataset(df, freq="D") - - true_borders = ( - (("2021-01-01", "2021-02-24"), ("2021-02-25", "2021-03-08")), - (("2021-01-13", "2021-03-08"), ("2021-03-09", "2021-03-20")), - (("2021-01-25", "2021-03-20"), ("2021-03-21", "2021-04-01")), - ) - masks = Pipeline._generate_masks_from_n_folds(ts=ts, n_folds=3, horizon=12, mode="constant") - for i, stage_dfs in enumerate(Pipeline._generate_folds_datasets(ts, horizon=12, masks=masks)): - for stage_df, borders in zip(stage_dfs, true_borders[i]): - assert stage_df.index.min() == datetime.strptime(borders[0], "%Y-%m-%d").date() - assert stage_df.index.max() == datetime.strptime(borders[1], "%Y-%m-%d").date() - - -def test_generate_constant_timeranges_hours(): - """Test train-test timeranges generation with constant mode with hours freq""" - df = pd.DataFrame({"timestamp": pd.date_range("2020-01-01", "2020-02-01", freq="H")}) - df["segment"] = "seg" - df["target"] = 1 - df = df.pivot(index="timestamp", columns="segment").reorder_levels([1, 0], axis=1).sort_index(axis=1) - df.columns.names = ["segment", "feature"] - ts = TSDataset(df, freq="H") - true_borders = ( - (("2020-01-01 00:00:00", "2020-01-30 12:00:00"), ("2020-01-30 13:00:00", "2020-01-31 00:00:00")), - (("2020-01-01 12:00:00", "2020-01-31 00:00:00"), ("2020-01-31 01:00:00", "2020-01-31 12:00:00")), - (("2020-01-02 00:00:00", "2020-01-31 12:00:00"), ("2020-01-31 13:00:00", "2020-02-01 00:00:00")), - ) - masks = Pipeline._generate_masks_from_n_folds(ts=ts, n_folds=3, horizon=12, mode="constant") - for i, stage_dfs in enumerate(Pipeline._generate_folds_datasets(ts, horizon=12, masks=masks)): - for stage_df, borders in zip(stage_dfs, true_borders[i]): - assert stage_df.index.min() == datetime.strptime(borders[0], "%Y-%m-%d %H:%M:%S").date() - assert stage_df.index.max() == datetime.strptime(borders[1], "%Y-%m-%d %H:%M:%S").date() +@pytest.mark.parametrize("stride", [-1, 0]) +def test_invalid_backtest_stride_not_positive(stride, catboost_pipeline: Pipeline, example_tsdf: TSDataset): + """Test Pipeline.backtest behavior on setting not positive stride.""" + with pytest.raises(ValueError, match="Stride should be a positive number, .* given"): + _ = catboost_pipeline.backtest(ts=example_tsdf, n_folds=3, stride=stride, metrics=DEFAULT_METRICS) @pytest.mark.parametrize( @@ -394,7 +376,7 @@ def test_generate_constant_timeranges_hours(): ), ), ) -def test_get_metrics_interface( +def test_backtest_metrics_interface( catboost_pipeline: Pipeline, aggregate_metrics: bool, expected_columns: List[str], big_daily_example_tsdf: TSDataset ): """Check that Pipeline.backtest returns metrics in correct format.""" @@ -406,47 +388,263 @@ def test_get_metrics_interface( assert sorted(expected_columns) == sorted(metrics_df.columns) -def test_get_forecasts_interface_daily(catboost_pipeline: Pipeline, big_daily_example_tsdf: TSDataset): +@pytest.mark.parametrize( + "ts_fixture", + [ + "big_daily_example_tsdf", + "example_tsdf", + ], +) +def test_backtest_forecasts_columns(ts_fixture, catboost_pipeline, request): """Check that Pipeline.backtest returns forecasts in correct format.""" - _, forecast, _ = catboost_pipeline.backtest(ts=big_daily_example_tsdf, metrics=DEFAULT_METRICS) + ts = request.getfixturevalue(ts_fixture) + _, forecast, _ = catboost_pipeline.backtest(ts=ts, metrics=DEFAULT_METRICS) expected_columns = sorted( ["regressor_lag_feature_10", "regressor_lag_feature_11", "regressor_lag_feature_12", "fold_number", "target"] ) assert expected_columns == sorted(set(forecast.columns.get_level_values("feature"))) -def test_get_forecasts_interface_hours(catboost_pipeline: Pipeline, example_tsdf: TSDataset): - """Check that Pipeline.backtest returns forecasts in correct format with non-daily seasonality.""" - _, forecast, _ = catboost_pipeline.backtest(ts=example_tsdf, metrics=DEFAULT_METRICS) - expected_columns = sorted( - ["regressor_lag_feature_10", "regressor_lag_feature_11", "regressor_lag_feature_12", "fold_number", "target"] - ) - assert expected_columns == sorted(set(forecast.columns.get_level_values("feature"))) +@pytest.mark.parametrize( + "n_folds, horizon, expected_timestamps", + [ + (2, 3, [-6, -5, -4, -3, -2, -1]), + (2, 5, [-10, -9, -8, -7, -6, -5, -4, -3, -2, -1]), + ( + [ + FoldMask( + first_train_timestamp=pd.Timestamp("2020-01-01"), + last_train_timestamp=pd.Timestamp("2020-01-31 14:00"), + target_timestamps=[pd.Timestamp("2020-01-31 17:00")], + ), + FoldMask( + first_train_timestamp=pd.Timestamp("2020-01-01"), + last_train_timestamp=pd.Timestamp("2020-01-31 19:00"), + target_timestamps=[pd.Timestamp("2020-01-31 22:00")], + ), + ], + 5, + [-8, -3], + ), + ], +) +def test_backtest_forecasts_timestamps(n_folds, horizon, expected_timestamps, example_tsdf): + """Check that Pipeline.backtest returns forecasts with expected timestamps.""" + pipeline = Pipeline(model=NaiveModel(lag=horizon), horizon=horizon) + _, forecast, _ = pipeline.backtest(ts=example_tsdf, metrics=DEFAULT_METRICS, n_folds=n_folds) + timestamp = example_tsdf.index + np.testing.assert_array_equal(forecast.index, timestamp[expected_timestamps]) -def test_get_fold_info_interface_daily(catboost_pipeline: Pipeline, big_daily_example_tsdf: TSDataset): + +@pytest.mark.parametrize( + "n_folds, horizon, stride, expected_timestamps", + [ + (2, 3, 3, [-6, -5, -4, -3, -2, -1]), + (2, 3, 1, [-4, -3, -2, -3, -2, -1]), + (2, 3, 5, [-8, -7, -6, -3, -2, -1]), + ], +) +def test_backtest_forecasts_timestamps_with_stride(n_folds, horizon, stride, expected_timestamps, example_tsdf): + """Check that Pipeline.backtest with stride returns forecasts with expected timestamps.""" + pipeline = Pipeline(model=NaiveModel(lag=horizon), horizon=horizon) + _, forecast, _ = pipeline.backtest(ts=example_tsdf, metrics=DEFAULT_METRICS, n_folds=n_folds, stride=stride) + timestamp = example_tsdf.index + + np.testing.assert_array_equal(forecast.index, timestamp[expected_timestamps]) + + +@pytest.mark.parametrize( + "ts_fixture, n_folds", + [ + ("big_daily_example_tsdf", 1), + ("big_daily_example_tsdf", 2), + ("example_tsdf", 1), + ("example_tsdf", 2), + ], +) +def test_backtest_fold_info_format(ts_fixture, n_folds, request): """Check that Pipeline.backtest returns info dataframe in correct format.""" - _, _, info_df = catboost_pipeline.backtest(ts=big_daily_example_tsdf, metrics=DEFAULT_METRICS) + ts = request.getfixturevalue(ts_fixture) + pipeline = Pipeline(model=NaiveModel(lag=7), horizon=7) + _, _, info_df = pipeline.backtest(ts=ts, metrics=DEFAULT_METRICS, n_folds=n_folds) + + expected_folds = pd.Series(np.arange(n_folds)) + pd.testing.assert_series_equal(info_df["fold_number"], expected_folds, check_names=False) expected_columns = ["fold_number", "test_end_time", "test_start_time", "train_end_time", "train_start_time"] assert expected_columns == sorted(info_df.columns) -def test_get_fold_info_interface_hours(catboost_pipeline: Pipeline, example_tsdf: TSDataset): - """Check that Pipeline.backtest returns info dataframe in correct format with non-daily seasonality.""" - _, _, info_df = catboost_pipeline.backtest(ts=example_tsdf, metrics=DEFAULT_METRICS) - expected_columns = ["fold_number", "test_end_time", "test_start_time", "train_end_time", "train_start_time"] - assert expected_columns == sorted(info_df.columns) +@pytest.mark.parametrize( + "mode, n_folds, refit, horizon, stride, expected_train_starts, expected_train_ends, expected_test_starts, expected_test_ends", + [ + ("expand", 3, True, 7, None, [0, 0, 0], [-22, -15, -8], [-21, -14, -7], [-15, -8, -1]), + ("expand", 3, True, 7, 1, [0, 0, 0], [-10, -9, -8], [-9, -8, -7], [-3, -2, -1]), + ("expand", 3, True, 7, 10, [0, 0, 0], [-28, -18, -8], [-27, -17, -7], [-21, -11, -1]), + ("expand", 3, False, 7, None, [0, 0, 0], [-22, -22, -22], [-21, -14, -7], [-15, -8, -1]), + ("expand", 3, False, 7, 1, [0, 0, 0], [-10, -10, -10], [-9, -8, -7], [-3, -2, -1]), + ("expand", 3, False, 7, 10, [0, 0, 0], [-28, -28, -28], [-27, -17, -7], [-21, -11, -1]), + ("expand", 1, 1, 7, None, [0], [-8], [-7], [-1]), + ("expand", 1, 2, 7, None, [0], [-8], [-7], [-1]), + ("expand", 3, 1, 7, None, [0, 0, 0], [-22, -15, -8], [-21, -14, -7], [-15, -8, -1]), + ("expand", 3, 2, 7, None, [0, 0, 0], [-22, -22, -8], [-21, -14, -7], [-15, -8, -1]), + ("expand", 3, 3, 7, None, [0, 0, 0], [-22, -22, -22], [-21, -14, -7], [-15, -8, -1]), + ("expand", 3, 4, 7, None, [0, 0, 0], [-22, -22, -22], [-21, -14, -7], [-15, -8, -1]), + ("expand", 4, 1, 7, None, [0, 0, 0, 0], [-29, -22, -15, -8], [-28, -21, -14, -7], [-22, -15, -8, -1]), + ("expand", 4, 2, 7, None, [0, 0, 0, 0], [-29, -29, -15, -15], [-28, -21, -14, -7], [-22, -15, -8, -1]), + ("expand", 4, 2, 7, 1, [0, 0, 0, 0], [-11, -11, -9, -9], [-10, -9, -8, -7], [-4, -3, -2, -1]), + ("expand", 4, 2, 7, 10, [0, 0, 0, 0], [-38, -38, -18, -18], [-37, -27, -17, -7], [-31, -21, -11, -1]), + ("expand", 4, 3, 7, None, [0, 0, 0, 0], [-29, -29, -29, -8], [-28, -21, -14, -7], [-22, -15, -8, -1]), + ("expand", 4, 4, 7, None, [0, 0, 0, 0], [-29, -29, -29, -29], [-28, -21, -14, -7], [-22, -15, -8, -1]), + ("expand", 4, 5, 7, None, [0, 0, 0, 0], [-29, -29, -29, -29], [-28, -21, -14, -7], [-22, -15, -8, -1]), + ("constant", 3, True, 7, None, [0, 7, 14], [-22, -15, -8], [-21, -14, -7], [-15, -8, -1]), + ("constant", 3, True, 7, 1, [0, 1, 2], [-10, -9, -8], [-9, -8, -7], [-3, -2, -1]), + ("constant", 3, True, 7, 10, [0, 10, 20], [-28, -18, -8], [-27, -17, -7], [-21, -11, -1]), + ("constant", 3, False, 7, None, [0, 0, 0], [-22, -22, -22], [-21, -14, -7], [-15, -8, -1]), + ("constant", 3, False, 7, 1, [0, 0, 0], [-10, -10, -10], [-9, -8, -7], [-3, -2, -1]), + ("constant", 3, False, 7, 10, [0, 0, 0], [-28, -28, -28], [-27, -17, -7], [-21, -11, -1]), + ("constant", 1, 1, 7, None, [0], [-8], [-7], [-1]), + ("constant", 1, 2, 7, None, [0], [-8], [-7], [-1]), + ("constant", 3, 1, 7, None, [0, 7, 14], [-22, -15, -8], [-21, -14, -7], [-15, -8, -1]), + ("constant", 3, 2, 7, None, [0, 0, 14], [-22, -22, -8], [-21, -14, -7], [-15, -8, -1]), + ("constant", 3, 3, 7, None, [0, 0, 0], [-22, -22, -22], [-21, -14, -7], [-15, -8, -1]), + ("constant", 3, 4, 7, None, [0, 0, 0], [-22, -22, -22], [-21, -14, -7], [-15, -8, -1]), + ("constant", 4, 1, 7, None, [0, 7, 14, 21], [-29, -22, -15, -8], [-28, -21, -14, -7], [-22, -15, -8, -1]), + ("constant", 4, 2, 7, None, [0, 0, 14, 14], [-29, -29, -15, -15], [-28, -21, -14, -7], [-22, -15, -8, -1]), + ("constant", 4, 2, 7, 1, [0, 0, 2, 2], [-11, -11, -9, -9], [-10, -9, -8, -7], [-4, -3, -2, -1]), + ("constant", 4, 2, 7, 10, [0, 0, 20, 20], [-38, -38, -18, -18], [-37, -27, -17, -7], [-31, -21, -11, -1]), + ("constant", 4, 3, 7, None, [0, 0, 0, 21], [-29, -29, -29, -8], [-28, -21, -14, -7], [-22, -15, -8, -1]), + ("constant", 4, 4, 7, None, [0, 0, 0, 0], [-29, -29, -29, -29], [-28, -21, -14, -7], [-22, -15, -8, -1]), + ("constant", 4, 5, 7, None, [0, 0, 0, 0], [-29, -29, -29, -29], [-28, -21, -14, -7], [-22, -15, -8, -1]), + ( + None, + [ + FoldMask( + first_train_timestamp=None, + last_train_timestamp=pd.Timestamp("2020-01-31 10:00"), + target_timestamps=[pd.Timestamp("2020-01-31 14:00")], + ), + FoldMask( + first_train_timestamp=None, + last_train_timestamp=pd.Timestamp("2020-01-31 17:00"), + target_timestamps=[pd.Timestamp("2020-01-31 21:00")], + ), + ], + True, + 7, + None, + [0, 0], + [-15, -8], + [-14, -7], + [-8, -1], + ), + ( + None, + [ + FoldMask( + first_train_timestamp=pd.Timestamp("2020-01-01 1:00"), + last_train_timestamp=pd.Timestamp("2020-01-31 10:00"), + target_timestamps=[pd.Timestamp("2020-01-31 14:00")], + ), + FoldMask( + first_train_timestamp=pd.Timestamp("2020-01-01 8:00"), + last_train_timestamp=pd.Timestamp("2020-01-31 17:00"), + target_timestamps=[pd.Timestamp("2020-01-31 21:00")], + ), + ], + True, + 7, + None, + [1, 8], + [-15, -8], + [-14, -7], + [-8, -1], + ), + ( + None, + [ + FoldMask( + first_train_timestamp=None, + last_train_timestamp=pd.Timestamp("2020-01-30 20:00"), + target_timestamps=[pd.Timestamp("2020-01-31 00:00")], + ), + FoldMask( + first_train_timestamp=None, + last_train_timestamp=pd.Timestamp("2020-01-31 03:00"), + target_timestamps=[pd.Timestamp("2020-01-31 07:00")], + ), + FoldMask( + first_train_timestamp=None, + last_train_timestamp=pd.Timestamp("2020-01-31 10:00"), + target_timestamps=[pd.Timestamp("2020-01-31 14:00")], + ), + FoldMask( + first_train_timestamp=None, + last_train_timestamp=pd.Timestamp("2020-01-31 17:00"), + target_timestamps=[pd.Timestamp("2020-01-31 21:00")], + ), + ], + 2, + 7, + None, + [0, 0, 0, 0], + [-29, -29, -15, -15], + [-28, -21, -14, -7], + [-22, -15, -8, -1], + ), + ], +) +def test_backtest_fold_info_timestamps( + mode, + n_folds, + refit, + horizon, + stride, + expected_train_starts, + expected_train_ends, + expected_test_starts, + expected_test_ends, + example_tsdf, +): + """Check that Pipeline.backtest returns info dataframe with correct timestamps.""" + pipeline = Pipeline(model=NaiveModel(lag=horizon), horizon=horizon) + _, _, info_df = pipeline.backtest( + ts=example_tsdf, metrics=DEFAULT_METRICS, mode=mode, n_folds=n_folds, refit=refit, stride=stride + ) + timestamp = example_tsdf.index + + np.testing.assert_array_equal(info_df["train_start_time"], timestamp[expected_train_starts]) + np.testing.assert_array_equal(info_df["train_end_time"], timestamp[expected_train_ends]) + np.testing.assert_array_equal(info_df["test_start_time"], timestamp[expected_test_starts]) + np.testing.assert_array_equal(info_df["test_end_time"], timestamp[expected_test_ends]) + + +def test_backtest_refit_success(catboost_pipeline: Pipeline, big_example_tsdf: TSDataset): + """Check that backtest without refit works on pipeline that supports it.""" + _ = catboost_pipeline.backtest(ts=big_example_tsdf, n_jobs=1, metrics=DEFAULT_METRICS, n_folds=3, refit=False) + + +def test_backtest_refit_fail(big_example_tsdf: TSDataset): + """Check that backtest without refit doesn't work on pipeline that doesn't support it.""" + pipeline = Pipeline( + model=NaiveModel(lag=7), + transforms=[DifferencingTransform(in_column="target", inplace=True)], + horizon=7, + ) + with pytest.raises(ValueError, match="Test should go after the train without gaps"): + _ = pipeline.backtest(ts=big_example_tsdf, n_jobs=1, metrics=DEFAULT_METRICS, n_folds=3, refit=False) @pytest.mark.long_1 -def test_backtest_with_n_jobs(catboost_pipeline: Pipeline, big_example_tsdf: TSDataset): +@pytest.mark.parametrize("refit", [True, False, 2]) +def test_backtest_with_n_jobs(refit, catboost_pipeline: Pipeline, big_example_tsdf: TSDataset): """Check that Pipeline.backtest gives the same results in case of single and multiple jobs modes.""" ts1 = deepcopy(big_example_tsdf) ts2 = deepcopy(big_example_tsdf) pipeline_1 = deepcopy(catboost_pipeline) pipeline_2 = deepcopy(catboost_pipeline) - _, forecast_1, _ = pipeline_1.backtest(ts=ts1, n_jobs=1, metrics=DEFAULT_METRICS) - _, forecast_2, _ = pipeline_2.backtest(ts=ts2, n_jobs=3, metrics=DEFAULT_METRICS) + _, forecast_1, _ = pipeline_1.backtest(ts=ts1, n_jobs=1, n_folds=4, metrics=DEFAULT_METRICS, refit=refit) + _, forecast_2, _ = pipeline_2.backtest(ts=ts2, n_jobs=3, n_folds=4, metrics=DEFAULT_METRICS, refit=refit) assert (forecast_1 == forecast_2).all().all() @@ -460,10 +658,10 @@ def test_backtest_forecasts_sanity(step_ts: TSDataset): assert np.all(forecast_df == expected_forecast_df) -def test_forecast_raise_error_if_not_fitted(): - """Test that Pipeline raise error when calling forecast without being fit.""" +def test_forecast_raise_error_if_no_ts(): + """Test that Pipeline raises error when calling forecast without ts.""" pipeline = Pipeline(model=NaiveModel(), horizon=5) - with pytest.raises(ValueError, match="Pipeline is not fitted!"): + with pytest.raises(ValueError, match="There is no ts to forecast!"): _ = pipeline.forecast() @@ -476,11 +674,13 @@ def test_forecast_pipeline_with_nan_at_the_end(df_with_nans_in_tails): @pytest.mark.parametrize( - "n_folds, mode, expected_masks", + "n_folds, horizon, stride, mode, expected_masks", ( ( 2, - "expand", + 3, + 3, + CrossValidationMode.expand, [ FoldMask( first_train_timestamp="2020-01-01", @@ -496,7 +696,45 @@ def test_forecast_pipeline_with_nan_at_the_end(df_with_nans_in_tails): ), ( 2, - "constant", + 3, + 1, + CrossValidationMode.expand, + [ + FoldMask( + first_train_timestamp="2020-01-01", + last_train_timestamp="2020-04-05", + target_timestamps=["2020-04-06", "2020-04-07", "2020-04-08"], + ), + FoldMask( + first_train_timestamp="2020-01-01", + last_train_timestamp="2020-04-06", + target_timestamps=["2020-04-07", "2020-04-08", "2020-04-09"], + ), + ], + ), + ( + 2, + 3, + 5, + CrossValidationMode.expand, + [ + FoldMask( + first_train_timestamp="2020-01-01", + last_train_timestamp="2020-04-01", + target_timestamps=["2020-04-02", "2020-04-03", "2020-04-04"], + ), + FoldMask( + first_train_timestamp="2020-01-01", + last_train_timestamp="2020-04-06", + target_timestamps=["2020-04-07", "2020-04-08", "2020-04-09"], + ), + ], + ), + ( + 2, + 3, + 3, + CrossValidationMode.constant, [ FoldMask( first_train_timestamp="2020-01-01", @@ -510,10 +748,48 @@ def test_forecast_pipeline_with_nan_at_the_end(df_with_nans_in_tails): ), ], ), + ( + 2, + 3, + 1, + CrossValidationMode.constant, + [ + FoldMask( + first_train_timestamp="2020-01-01", + last_train_timestamp="2020-04-05", + target_timestamps=["2020-04-06", "2020-04-07", "2020-04-08"], + ), + FoldMask( + first_train_timestamp="2020-01-02", + last_train_timestamp="2020-04-06", + target_timestamps=["2020-04-07", "2020-04-08", "2020-04-09"], + ), + ], + ), + ( + 2, + 3, + 5, + CrossValidationMode.constant, + [ + FoldMask( + first_train_timestamp="2020-01-01", + last_train_timestamp="2020-04-01", + target_timestamps=["2020-04-02", "2020-04-03", "2020-04-04"], + ), + FoldMask( + first_train_timestamp="2020-01-06", + last_train_timestamp="2020-04-06", + target_timestamps=["2020-04-07", "2020-04-08", "2020-04-09"], + ), + ], + ), ), ) -def test_generate_masks_from_n_folds(example_tsds: TSDataset, n_folds, mode, expected_masks): - masks = Pipeline._generate_masks_from_n_folds(ts=example_tsds, n_folds=n_folds, horizon=3, mode=mode) +def test_generate_masks_from_n_folds(example_tsds: TSDataset, n_folds, horizon, stride, mode, expected_masks): + masks = Pipeline._generate_masks_from_n_folds( + ts=example_tsds, n_folds=n_folds, horizon=horizon, stride=stride, mode=mode + ) for mask, expected_mask in zip(masks, expected_masks): assert mask.first_train_timestamp == expected_mask.first_train_timestamp assert mask.last_train_timestamp == expected_mask.last_train_timestamp @@ -530,7 +806,7 @@ def test_generate_folds_datasets(ts_name, mask, request): """Check _generate_folds_datasets for correct work.""" ts = request.getfixturevalue(ts_name) pipeline = Pipeline(model=NaiveModel(lag=7)) - mask = pipeline._prepare_fold_masks(ts=ts, masks=[mask], mode="constant")[0] + mask = pipeline._prepare_fold_masks(ts=ts, masks=[mask], mode=CrossValidationMode.expand, stride=-1)[0] train, test = list(pipeline._generate_folds_datasets(ts, [mask], 4))[0] assert train.index.min() == np.datetime64(mask.first_train_timestamp) assert train.index.max() == np.datetime64(mask.last_train_timestamp) @@ -548,7 +824,7 @@ def test_generate_folds_datasets_without_first_date(ts_name, mask, request): """Check _generate_folds_datasets for correct work without first date.""" ts = request.getfixturevalue(ts_name) pipeline = Pipeline(model=NaiveModel(lag=7)) - mask = pipeline._prepare_fold_masks(ts=ts, masks=[mask], mode="constant")[0] + mask = pipeline._prepare_fold_masks(ts=ts, masks=[mask], mode=CrossValidationMode.expand, stride=-1)[0] train, test = list(pipeline._generate_folds_datasets(ts, [mask], 4))[0] assert train.index.min() == np.datetime64(ts.index.min()) assert train.index.max() == np.datetime64(mask.last_train_timestamp) @@ -563,17 +839,103 @@ def test_generate_folds_datasets_without_first_date(ts_name, mask, request): (FoldMask("2020-01-01", "2020-01-07", ["2020-01-08", "2020-01-11"]), {"segment_0": 95.5, "segment_1": 5}), ), ) -def test_run_fold(ts_run_fold: TSDataset, mask: FoldMask, expected: Dict[str, List[float]]): - train, test = ts_run_fold.train_test_split( +def test_process_fold_forecast(ts_process_fold_forecast, mask: FoldMask, expected: Dict[str, List[float]]): + train, test = ts_process_fold_forecast.train_test_split( train_start=mask.first_train_timestamp, train_end=mask.last_train_timestamp ) pipeline = Pipeline(model=NaiveModel(lag=5), transforms=[], horizon=4) - fold = pipeline._run_fold(train, test, 1, mask, [MAE()], forecast_params=dict()) + pipeline = pipeline.fit(ts=train) + forecast = pipeline.forecast() + fold = pipeline._process_fold_forecast( + forecast=forecast, train=train, test=test, pipeline=pipeline, fold_number=1, mask=mask, metrics=[MAE()] + ) for seg in fold["metrics"]["MAE"].keys(): assert fold["metrics"]["MAE"][seg] == expected[seg] +def test_make_backtest_fold_groups_refit_true(): + masks = [MagicMock() for _ in range(2)] + obtained_results = Pipeline._make_backtest_fold_groups(masks=masks, refit=True) + expected_results = [ + { + "train_fold_number": 0, + "train_mask": masks[0], + "forecast_fold_numbers": [0], + "forecast_masks": [masks[0]], + }, + { + "train_fold_number": 1, + "train_mask": masks[1], + "forecast_fold_numbers": [1], + "forecast_masks": [masks[1]], + }, + ] + assert obtained_results == expected_results + + +def test_make_backtest_fold_groups_refit_false(): + masks = [MagicMock() for _ in range(2)] + obtained_results = Pipeline._make_backtest_fold_groups(masks=masks, refit=False) + expected_results = [ + { + "train_fold_number": 0, + "train_mask": masks[0], + "forecast_fold_numbers": [0, 1], + "forecast_masks": [masks[0], masks[1]], + } + ] + assert obtained_results == expected_results + + +def test_make_backtest_fold_groups_refit_int(): + masks = [MagicMock() for _ in range(5)] + obtained_results = Pipeline._make_backtest_fold_groups(masks=masks, refit=2) + expected_results = [ + { + "train_fold_number": 0, + "train_mask": masks[0], + "forecast_fold_numbers": [0, 1], + "forecast_masks": [masks[0], masks[1]], + }, + { + "train_fold_number": 2, + "train_mask": masks[2], + "forecast_fold_numbers": [2, 3], + "forecast_masks": [masks[2], masks[3]], + }, + { + "train_fold_number": 4, + "train_mask": masks[4], + "forecast_fold_numbers": [4], + "forecast_masks": [masks[4]], + }, + ] + assert obtained_results == expected_results + + +@pytest.mark.parametrize( + "n_folds, refit, expected_refits", + [ + (1, 1, 1), + (1, 2, 1), + (3, 1, 3), + (3, 2, 2), + (3, 3, 1), + (3, 4, 1), + (4, 1, 4), + (4, 2, 2), + (4, 3, 2), + (4, 4, 1), + (4, 5, 1), + ], +) +def test_make_backtest_fold_groups_length_refit_int(n_folds, refit, expected_refits): + masks = [MagicMock() for _ in range(n_folds)] + obtained_results = Pipeline._make_backtest_fold_groups(masks=masks, refit=refit) + assert len(obtained_results) == expected_refits + + @pytest.mark.parametrize( "lag,expected", ((5, {"segment_0": 76.923077, "segment_1": 90.909091}), (6, {"segment_0": 100, "segment_1": 120})) ) @@ -724,6 +1086,51 @@ def test_predict(model, transforms, example_tsds): assert len(result_df) == len(example_tsds.segments) * num_points +@pytest.mark.parametrize("load_ts", [True, False]) +@pytest.mark.parametrize( + "model, transforms", + [ + ( + CatBoostMultiSegmentModel(iterations=100), + [DateFlagsTransform(), LagTransform(in_column="target", lags=list(range(3, 10)))], + ), + ( + LinearPerSegmentModel(), + [DateFlagsTransform(), LagTransform(in_column="target", lags=list(range(3, 10)))], + ), + (SeasonalMovingAverageModel(window=2, seasonality=7), []), + (SARIMAXModel(), []), + (ProphetModel(), []), + ], +) +def test_save_load(load_ts, model, transforms, example_tsds): + horizon = 3 + pipeline = Pipeline(model=model, transforms=transforms, horizon=horizon) + assert_pipeline_equals_loaded_original(pipeline=pipeline, ts=example_tsds, load_ts=load_ts) + + +@pytest.mark.parametrize( + "model, transforms", + [ + ( + CatBoostMultiSegmentModel(iterations=100), + [DateFlagsTransform(), LagTransform(in_column="target", lags=list(range(3, 10)))], + ), + ( + LinearPerSegmentModel(), + [DateFlagsTransform(), LagTransform(in_column="target", lags=list(range(3, 10)))], + ), + (SeasonalMovingAverageModel(window=2, seasonality=7), []), + (SARIMAXModel(), []), + (ProphetModel(), []), + ], +) +def test_forecast_given_ts(model, transforms, example_tsds): + horizon = 3 + pipeline = Pipeline(model=model, transforms=transforms, horizon=horizon) + assert_pipeline_forecasts_given_ts(pipeline=pipeline, ts=example_tsds, horizon=horizon) + + @pytest.mark.parametrize( "model, transforms", [ @@ -740,7 +1147,7 @@ def test_predict(model, transforms, example_tsds): (ProphetModel(), []), ], ) -def test_save_load(model, transforms, example_tsds): +def test_forecast_given_ts_with_prediction_interval(model, transforms, example_tsds): horizon = 3 pipeline = Pipeline(model=model, transforms=transforms, horizon=horizon) - assert_pipeline_equals_loaded_original(pipeline=pipeline, ts=example_tsds) + assert_pipeline_forecasts_given_ts_with_prediction_intervals(pipeline=pipeline, ts=example_tsds, horizon=horizon) diff --git a/tests/test_pipeline/utils.py b/tests/test_pipeline/utils.py index 506c286d2..84b73e3b7 100644 --- a/tests/test_pipeline/utils.py +++ b/tests/test_pipeline/utils.py @@ -1,6 +1,7 @@ import pathlib import tempfile from copy import deepcopy +from typing import List from typing import Tuple import pandas as pd @@ -9,17 +10,30 @@ from etna.pipeline.base import AbstractPipeline -def get_loaded_pipeline(pipeline: AbstractPipeline, ts: TSDataset) -> AbstractPipeline: +def get_loaded_pipeline(pipeline: AbstractPipeline, ts: TSDataset = None) -> AbstractPipeline: with tempfile.TemporaryDirectory() as dir_path_str: dir_path = pathlib.Path(dir_path_str) path = dir_path.joinpath("dummy.zip") pipeline.save(path) - loaded_pipeline = pipeline.load(path, ts=ts) + if ts is None: + loaded_pipeline = pipeline.load(path) + else: + loaded_pipeline = pipeline.load(path, ts=ts) return loaded_pipeline +def select_segments_subset(ts: TSDataset, segments: List[str]) -> TSDataset: + df = ts.raw_df.loc[:, pd.IndexSlice[segments, :]] + df_exog = ts.df_exog + if df_exog is not None: + df_exog = df_exog.loc[:, pd.IndexSlice[segments, :]] + known_future = ts.known_future + freq = ts.freq + return TSDataset(df=df, df_exog=df_exog, known_future=known_future, freq=freq) + + def assert_pipeline_equals_loaded_original( - pipeline: AbstractPipeline, ts: TSDataset + pipeline: AbstractPipeline, ts: TSDataset, load_ts: bool = True ) -> Tuple[AbstractPipeline, AbstractPipeline]: import torch # TODO: remove after fix at issue-802 @@ -29,10 +43,67 @@ def assert_pipeline_equals_loaded_original( torch.manual_seed(11) forecast_ts_1 = pipeline.forecast() - loaded_pipeline = get_loaded_pipeline(pipeline, ts=initial_ts) - torch.manual_seed(11) - forecast_ts_2 = loaded_pipeline.forecast() + if load_ts: + loaded_pipeline = get_loaded_pipeline(pipeline, ts=initial_ts) + torch.manual_seed(11) + forecast_ts_2 = loaded_pipeline.forecast() + else: + loaded_pipeline = get_loaded_pipeline(pipeline) + torch.manual_seed(11) + forecast_ts_2 = loaded_pipeline.forecast(ts=initial_ts) pd.testing.assert_frame_equal(forecast_ts_1.to_pandas(), forecast_ts_2.to_pandas()) return pipeline, loaded_pipeline + + +def assert_pipeline_forecasts_given_ts(pipeline: AbstractPipeline, ts: TSDataset, horizon: int) -> AbstractPipeline: + fit_ts = deepcopy(ts) + fit_ts.df = fit_ts.df.iloc[:-horizon] + to_forecast_ts = deepcopy(ts) + + pipeline.fit(ts=fit_ts) + forecast_ts = pipeline.forecast(ts=to_forecast_ts) + forecast_df = forecast_ts.to_pandas(flatten=True) + + if ts.has_hierarchy(): + expected_segments = ts.hierarchical_structure.get_level_segments(forecast_ts.current_df_level) + else: + expected_segments = to_forecast_ts.segments + assert forecast_ts.segments == expected_segments + expected_index = pd.date_range( + start=to_forecast_ts.index[-1], periods=horizon + 1, freq=to_forecast_ts.freq, name="timestamp" + )[1:] + pd.testing.assert_index_equal(forecast_ts.index, expected_index) + assert not forecast_df["target"].isna().any() + + return pipeline + + +def assert_pipeline_forecasts_given_ts_with_prediction_intervals( + pipeline: AbstractPipeline, ts: TSDataset, horizon: int, **forecast_params +) -> AbstractPipeline: + fit_ts = deepcopy(ts) + fit_ts.df = fit_ts.df.iloc[:-horizon] + to_forecast_ts = deepcopy(ts) + + pipeline.fit(fit_ts) + forecast_ts = pipeline.forecast( + ts=to_forecast_ts, prediction_interval=True, quantiles=[0.025, 0.975], **forecast_params + ) + forecast_df = forecast_ts.to_pandas(flatten=True) + + if ts.has_hierarchy(): + expected_segments = ts.hierarchical_structure.get_level_segments(forecast_ts.current_df_level) + else: + expected_segments = to_forecast_ts.segments + assert forecast_ts.segments == expected_segments + expected_index = pd.date_range( + start=to_forecast_ts.index[-1], periods=horizon + 1, freq=to_forecast_ts.freq, name="timestamp" + )[1:] + pd.testing.assert_index_equal(forecast_ts.index, expected_index) + assert not forecast_df["target"].isna().any() + assert not forecast_df["target_0.025"].isna().any() + assert not forecast_df["target_0.975"].isna().any() + + return pipeline diff --git a/tests/test_transforms/sklearn/test_interface.py b/tests/test_transforms/sklearn/test_interface.py deleted file mode 100644 index f38d6f098..000000000 --- a/tests/test_transforms/sklearn/test_interface.py +++ /dev/null @@ -1,280 +0,0 @@ -from typing import List - -import numpy as np -import pandas as pd -import pytest - -from etna.datasets import TSDataset -from etna.datasets import generate_const_df -from etna.transforms import BoxCoxTransform -from etna.transforms import MaxAbsScalerTransform -from etna.transforms import MinMaxScalerTransform -from etna.transforms import RobustScalerTransform -from etna.transforms import StandardScalerTransform -from etna.transforms import YeoJohnsonTransform - - -@pytest.fixture -def multicolumn_ts(random_seed): - df = generate_const_df(start_time="2020-01-01", periods=20, freq="D", scale=1.0, n_segments=3) - df["target"] += np.random.uniform(0, 0.1, size=df.shape[0]) - df_exog = df.copy().rename(columns={"target": "exog_1"}) - for i in range(2, 6): - df_exog[f"exog_{i}"] = float(i) + np.random.uniform(0, 0.1, size=df.shape[0]) - - df_formatted = TSDataset.to_dataset(df) - df_exog_formatted = TSDataset.to_dataset(df_exog) - - return TSDataset(df=df_formatted, df_exog=df_exog_formatted, freq="D") - - -def extract_new_features_columns(transformed_df: pd.DataFrame, initial_df: pd.DataFrame) -> List[str]: - """Extract columns from feature level that are present in transformed_df but not present in initial_df.""" - return ( - transformed_df.columns.get_level_values("feature") - .difference(initial_df.columns.get_level_values("feature")) - .unique() - .tolist() - ) - - -@pytest.mark.parametrize( - "transform_constructor", - ( - BoxCoxTransform, - YeoJohnsonTransform, - StandardScalerTransform, - RobustScalerTransform, - MinMaxScalerTransform, - MaxAbsScalerTransform, - StandardScalerTransform, - RobustScalerTransform, - MinMaxScalerTransform, - ), -) -def test_fail_invalid_mode(transform_constructor): - """Test that transform raises error in invalid mode.""" - with pytest.raises(ValueError): - _ = transform_constructor(mode="non_existent") - - -@pytest.mark.parametrize( - "transform_constructor", - ( - BoxCoxTransform, - YeoJohnsonTransform, - StandardScalerTransform, - RobustScalerTransform, - MinMaxScalerTransform, - MaxAbsScalerTransform, - StandardScalerTransform, - RobustScalerTransform, - MinMaxScalerTransform, - ), -) -def test_warning_not_inplace(transform_constructor): - """Test that transform raises warning if inplace is set to True, but out_column is also given.""" - with pytest.warns(UserWarning, match="Transformation will be applied inplace"): - _ = transform_constructor(inplace=True, out_column="new_exog") - - -@pytest.mark.parametrize( - "transform_constructor", - [ - BoxCoxTransform, - YeoJohnsonTransform, - StandardScalerTransform, - RobustScalerTransform, - MinMaxScalerTransform, - MaxAbsScalerTransform, - StandardScalerTransform, - RobustScalerTransform, - MinMaxScalerTransform, - ], -) -@pytest.mark.parametrize( - "in_column", - [ - "exog_1", - ["exog_1", "exog_2"], - ], -) -def test_inplace_no_new_columns(transform_constructor, in_column, multicolumn_ts): - """Test that transform in inplace mode doesn't generate new columns.""" - transform = transform_constructor(in_column=in_column, inplace=True) - initial_df = multicolumn_ts.to_pandas() - transformed_df = transform.fit_transform(multicolumn_ts.to_pandas()) - - # check new columns - new_columns = extract_new_features_columns(transformed_df, initial_df) - assert len(new_columns) == 0 - - # check that output columns are input columns - assert transform.out_columns == transform.in_column - - -@pytest.mark.parametrize( - "transform_constructor", - [ - BoxCoxTransform, - YeoJohnsonTransform, - StandardScalerTransform, - RobustScalerTransform, - MinMaxScalerTransform, - MaxAbsScalerTransform, - StandardScalerTransform, - RobustScalerTransform, - MinMaxScalerTransform, - ], -) -@pytest.mark.parametrize( - "in_column", - [ - "exog_1", - ["exog_1", "exog_2"], - ], -) -def test_creating_columns(transform_constructor, in_column, multicolumn_ts): - """Test that transform creates new columns according to out_column parameter.""" - transform = transform_constructor(in_column=in_column, out_column="new_exog", inplace=False) - initial_df = multicolumn_ts.to_pandas() - transformed_df = transform.fit_transform(multicolumn_ts.to_pandas()) - - # check new columns - new_columns = set(extract_new_features_columns(transformed_df, initial_df)) - in_column = [in_column] if isinstance(in_column, str) else in_column - expected_columns = {f"new_exog_{column}" for column in in_column} - assert new_columns == expected_columns - - # check that output columns are matching input columns - assert len(transform.in_column) == len(transform.out_columns) - assert all( - [f"new_exog_{column}" == new_column for column, new_column in zip(transform.in_column, transform.out_columns)] - ) - - -@pytest.mark.parametrize( - "transform_constructor", - [ - BoxCoxTransform, - YeoJohnsonTransform, - StandardScalerTransform, - RobustScalerTransform, - MinMaxScalerTransform, - MaxAbsScalerTransform, - StandardScalerTransform, - RobustScalerTransform, - MinMaxScalerTransform, - ], -) -@pytest.mark.parametrize( - "in_column", - [ - "exog_1", - ["exog_1", "exog_2"], - ], -) -def test_generated_column_names(transform_constructor, in_column, multicolumn_ts): - """Test that transform generates names for the columns correctly.""" - transform = transform_constructor(in_column=in_column, out_column=None, inplace=False) - initial_df = multicolumn_ts.to_pandas() - transformed_df = transform.fit_transform(multicolumn_ts.to_pandas()) - segments = sorted(multicolumn_ts.segments) - - new_columns = extract_new_features_columns(transformed_df, initial_df) - - # check new columns - for column in new_columns: - # create transform from column - transform_temp = eval(column) - df_temp = transform_temp.fit_transform(multicolumn_ts.to_pandas()) - columns_temp = extract_new_features_columns(df_temp, initial_df) - - # compare column names and column values - assert len(columns_temp) == 1 - column_temp = columns_temp[0] - assert column_temp == column - assert np.all( - df_temp.loc[:, pd.IndexSlice[segments, column_temp]] - == transformed_df.loc[:, pd.IndexSlice[segments, column]] - ) - - # check that output columns are matching input columns - assert len(transform.in_column) == len(transform.out_columns) - # check that name if this input column is present inside name of this output column - assert all([(column in new_column) for column, new_column in zip(transform.in_column, transform.out_columns)]) - - -@pytest.mark.parametrize( - "transform_constructor", - [ - BoxCoxTransform, - YeoJohnsonTransform, - StandardScalerTransform, - RobustScalerTransform, - MinMaxScalerTransform, - MaxAbsScalerTransform, - StandardScalerTransform, - RobustScalerTransform, - MinMaxScalerTransform, - ], -) -def test_all_columns(transform_constructor, multicolumn_ts): - """Test that transform can process all columns using None value for in_column.""" - transform = transform_constructor(in_column=None, out_column=None, inplace=False) - initial_df = multicolumn_ts.df.copy() - transformed_df = transform.fit_transform(multicolumn_ts.df) - - new_columns = extract_new_features_columns(transformed_df, initial_df) - assert len(new_columns) == initial_df.columns.get_level_values("feature").nunique() - - -@pytest.mark.parametrize( - "transform_constructor", - [ - BoxCoxTransform, - YeoJohnsonTransform, - StandardScalerTransform, - RobustScalerTransform, - MinMaxScalerTransform, - MaxAbsScalerTransform, - StandardScalerTransform, - RobustScalerTransform, - MinMaxScalerTransform, - ], -) -@pytest.mark.parametrize( - "in_column", [["exog_1", "exog_2", "exog_3"], ["exog_2", "exog_1", "exog_3"], ["exog_3", "exog_2", "exog_1"]] -) -@pytest.mark.parametrize( - "mode", - [ - "macro", - "per-segment", - ], -) -def test_ordering(transform_constructor, in_column, mode, multicolumn_ts): - """Test that transform don't mix columns between each other.""" - transform = transform_constructor(in_column=in_column, out_column=None, mode=mode, inplace=False) - transforms_one_column = [ - transform_constructor(in_column=column, out_column=None, mode=mode, inplace=False) for column in in_column - ] - - segments = sorted(multicolumn_ts.segments) - transformed_df = transform.fit_transform(multicolumn_ts.to_pandas()) - - transformed_dfs_one_column = [] - for transform_one_column in transforms_one_column: - transformed_dfs_one_column.append(transform_one_column.fit_transform(multicolumn_ts.to_pandas())) - - in_to_out_columns = {key: value for key, value in zip(transform.in_column, transform.out_columns)} - for i, column in enumerate(in_column): - # find relevant column name in transformed_df - column_multi = in_to_out_columns[column] - - # find relevant column name in transformed_dfs_one_column[i] - column_single = transforms_one_column[i].out_columns[0] - - df_multi = transformed_df.loc[:, pd.IndexSlice[segments, column_multi]] - df_single = transformed_dfs_one_column[i].loc[:, pd.IndexSlice[segments, column_single]] - assert np.all(df_multi == df_single) diff --git a/tests/test_transforms/sklearn/test_power_transform.py b/tests/test_transforms/sklearn/test_power_transform.py deleted file mode 100644 index ae64fe465..000000000 --- a/tests/test_transforms/sklearn/test_power_transform.py +++ /dev/null @@ -1,109 +0,0 @@ -from typing import Any - -import numpy as np -import numpy.testing as npt -import pandas as pd -import pytest -from sklearn.preprocessing import PowerTransformer - -from etna.datasets import TSDataset -from etna.transforms import AddConstTransform -from etna.transforms.math import BoxCoxTransform -from etna.transforms.math import YeoJohnsonTransform - - -@pytest.fixture -def non_positive_df() -> pd.DataFrame: - df_1 = pd.DataFrame.from_dict({"timestamp": pd.date_range("2021-06-01", "2021-07-01", freq="1d")}) - df_2 = pd.DataFrame.from_dict({"timestamp": pd.date_range("2021-06-01", "2021-07-01", freq="1d")}) - df_1["segment"] = "Moscow" - df_1["target"] = 0 - df_1["exog"] = -1 - df_2["segment"] = "Omsk" - df_2["target"] = -1 - df_2["exog"] = -7 - classic_df = pd.concat([df_1, df_2], ignore_index=True) - return TSDataset.to_dataset(classic_df) - - -@pytest.fixture -def positive_df() -> pd.DataFrame: - df_1 = pd.DataFrame.from_dict({"timestamp": pd.date_range("2021-06-01", "2021-07-01", freq="1d")}) - df_2 = pd.DataFrame.from_dict({"timestamp": pd.date_range("2021-06-01", "2021-07-01", freq="1d")}) - generator = np.random.RandomState(seed=1) - df_1["segment"] = "Moscow" - df_1["target"] = np.abs(generator.normal(loc=10, scale=1, size=len(df_1))) + 1 - df_1["exog"] = np.abs(generator.normal(loc=15, scale=1, size=len(df_1))) + 1 - df_2["segment"] = "Omsk" - df_2["target"] = np.abs(generator.normal(loc=20, scale=1, size=len(df_2))) + 1 - df_2["exog"] = np.abs(generator.normal(loc=4, scale=1, size=len(df_2))) + 1 - classic_df = pd.concat([df_1, df_2], ignore_index=True) - return TSDataset.to_dataset(classic_df) - - -@pytest.mark.parametrize("mode", ("macro", "per-segment")) -def test_non_positive_series_behavior(non_positive_df: pd.DataFrame, mode: str): - """Check BoxCoxPreprocessing behavior in case of negative-value series.""" - preprocess = BoxCoxTransform(mode=mode) - with pytest.raises(ValueError): - _ = preprocess.fit_transform(df=non_positive_df) - - -@pytest.mark.parametrize( - "preprocessing_class,method", ((BoxCoxTransform, "box-cox"), (YeoJohnsonTransform, "yeo-johnson")) -) -def test_transform_value_all_columns(positive_df: pd.DataFrame, preprocessing_class: Any, method: str): - """Check the value of transform result for all columns.""" - preprocess_none = preprocessing_class() - preprocess_all = preprocessing_class(in_column=positive_df.columns.get_level_values("feature").unique()) - value_none = preprocess_none.fit_transform(df=positive_df.copy()) - value_all = preprocess_all.fit_transform(df=positive_df.copy()) - true_values = PowerTransformer(method=method).fit_transform(positive_df.values) - npt.assert_array_almost_equal(value_none.values, true_values) - npt.assert_array_almost_equal(value_all.values, true_values) - - -@pytest.mark.parametrize( - "preprocessing_class,method", ((BoxCoxTransform, "box-cox"), (YeoJohnsonTransform, "yeo-johnson")) -) -def test_transform_value_one_column(positive_df: pd.DataFrame, preprocessing_class: Any, method: str): - """Check the value of transform result.""" - preprocess = preprocessing_class(in_column="target") - processed_values = preprocess.fit_transform(df=positive_df.copy()) - target_processed_values = processed_values.loc[:, pd.IndexSlice[:, "target"]].values - rest_processed_values = processed_values.drop("target", axis=1, level="feature").values - untouched_values = positive_df.drop("target", axis=1, level="feature").values - true_values = PowerTransformer(method=method).fit_transform(positive_df.loc[:, pd.IndexSlice[:, "target"]].values) - npt.assert_array_almost_equal(target_processed_values, true_values) - npt.assert_array_almost_equal(rest_processed_values, untouched_values) - - -@pytest.mark.parametrize("preprocessing_class", (BoxCoxTransform, YeoJohnsonTransform)) -@pytest.mark.parametrize("mode", ("macro", "per-segment")) -def test_inverse_transform_all_columns(positive_df: pd.DataFrame, preprocessing_class: Any, mode: str): - """Check that inverse_transform rolls back transform result for all columns.""" - preprocess_none = preprocessing_class(mode=mode) - preprocess_all = preprocessing_class(in_column=positive_df.columns.get_level_values("feature").unique(), mode=mode) - transformed_target_none = preprocess_none.fit_transform(df=positive_df.copy()) - transformed_target_all = preprocess_all.fit_transform(df=positive_df.copy()) - inversed_target_none = preprocess_none.inverse_transform(df=transformed_target_none) - inversed_target_all = preprocess_all.inverse_transform(df=transformed_target_all) - np.testing.assert_array_almost_equal(inversed_target_none.values, positive_df.values) - np.testing.assert_array_almost_equal(inversed_target_all.values, positive_df.values) - - -@pytest.mark.parametrize("preprocessing_class", (BoxCoxTransform, YeoJohnsonTransform)) -@pytest.mark.parametrize("mode", ("macro", "per-segment")) -def test_inverse_transform_one_column(positive_df: pd.DataFrame, preprocessing_class: Any, mode: str): - """Check that inverse_transform rolls back transform result for one column.""" - preprocess = preprocessing_class(in_column="target", mode=mode) - transformed_target = preprocess.fit_transform(df=positive_df.copy()) - inversed_target = preprocess.inverse_transform(df=transformed_target) - np.testing.assert_array_almost_equal(inversed_target.values, positive_df.values) - - -@pytest.mark.parametrize("preprocessing_class", (BoxCoxTransform, YeoJohnsonTransform)) -@pytest.mark.parametrize("mode", ("macro", "per-segment")) -def test_fit_transform_with_nans(preprocessing_class, mode, ts_diff_endings): - preprocess = preprocessing_class(in_column="target", mode=mode) - ts_diff_endings.fit_transform([AddConstTransform(in_column="target", value=100)] + [preprocess]) diff --git a/tests/test_transforms/sklearn/test_scalers_transform.py b/tests/test_transforms/sklearn/test_scalers_transform.py deleted file mode 100644 index 75b0b4f51..000000000 --- a/tests/test_transforms/sklearn/test_scalers_transform.py +++ /dev/null @@ -1,145 +0,0 @@ -from typing import List -from typing import Optional -from typing import Union - -import numpy as np -import numpy.testing as npt -import pandas as pd -import pytest - -from etna.datasets import TSDataset -from etna.transforms import MaxAbsScalerTransform -from etna.transforms import MinMaxScalerTransform -from etna.transforms import RobustScalerTransform -from etna.transforms import StandardScalerTransform -from etna.transforms.math.sklearn import SklearnTransform -from etna.transforms.math.sklearn import TransformMode - - -class DummySkTransform: - def fit(self, X, y=None): # noqa: N803 - pass - - def transform(self, X, y=None): # noqa: N803 - return X - - def inverse_transform(self, X, y=None): # noqa: N803 - return X - - -class DummyTransform(SklearnTransform): - def __init__( - self, - in_column: Optional[Union[str, List[str]]] = None, - inplace: bool = True, - out_column: Optional[str] = None, - mode: Union[TransformMode, str] = "per-segment", - ): - super().__init__( - in_column=in_column, - inplace=inplace, - out_column=out_column, - transformer=DummySkTransform(), - mode=mode, - ) - - -@pytest.fixture -def normal_distributed_df() -> pd.DataFrame: - df_1 = pd.DataFrame.from_dict({"timestamp": pd.date_range("2021-06-01", "2021-07-01", freq="1d")}) - df_2 = pd.DataFrame.from_dict({"timestamp": pd.date_range("2021-06-01", "2021-07-01", freq="1d")}) - generator = np.random.RandomState(seed=1) - df_1["segment"] = "Moscow" - df_1["target"] = generator.normal(loc=0, scale=10, size=len(df_1)) - df_1["exog"] = generator.normal(loc=2, scale=10, size=len(df_1)) - df_2["segment"] = "Omsk" - df_2["target"] = generator.normal(loc=5, scale=1, size=len(df_2)) - df_2["exog"] = generator.normal(loc=3, scale=1, size=len(df_2)) - classic_df = pd.concat([df_1, df_2], ignore_index=True) - return TSDataset.to_dataset(classic_df) - - -@pytest.mark.parametrize( - "scaler", - ( - DummyTransform(), - StandardScalerTransform(), - RobustScalerTransform(), - MinMaxScalerTransform(), - MaxAbsScalerTransform(), - StandardScalerTransform(with_std=False), - RobustScalerTransform(with_centering=False, with_scaling=False), - MinMaxScalerTransform(feature_range=(5, 10)), - ), -) -@pytest.mark.parametrize("mode", ("macro", "per-segment")) -def test_dummy_inverse_transform_all_columns(normal_distributed_df, scaler, mode): - """Check that `inverse_transform(transform(df)) == df` for all columns.""" - scaler.mode = TransformMode(mode) - feature_df = scaler.fit_transform(df=normal_distributed_df.copy()) - inversed_df = scaler.inverse_transform(df=feature_df.copy()) - npt.assert_array_almost_equal(normal_distributed_df.values, inversed_df.values) - - -@pytest.mark.parametrize( - "scaler", - ( - DummyTransform(in_column="target"), - StandardScalerTransform(in_column="target"), - RobustScalerTransform(in_column="target"), - MinMaxScalerTransform(in_column="target"), - MaxAbsScalerTransform(in_column="target"), - StandardScalerTransform(in_column="target", with_std=False), - RobustScalerTransform(in_column="target", with_centering=False, with_scaling=False), - MinMaxScalerTransform(in_column="target", feature_range=(5, 10)), - ), -) -@pytest.mark.parametrize("mode", ("macro", "per-segment")) -def test_dummy_inverse_transform_one_column(normal_distributed_df, scaler, mode): - """Check that `inverse_transform(transform(df)) == df` for one column.""" - scaler.mode = TransformMode(mode) - feature_df = scaler.fit_transform(df=normal_distributed_df.copy()) - inversed_df = scaler.inverse_transform(df=feature_df) - npt.assert_array_almost_equal(normal_distributed_df.values, inversed_df.values) - - -@pytest.mark.parametrize( - "scaler", - ( - DummyTransform, - StandardScalerTransform, - RobustScalerTransform, - MinMaxScalerTransform, - MaxAbsScalerTransform, - StandardScalerTransform, - RobustScalerTransform, - MinMaxScalerTransform, - ), -) -@pytest.mark.parametrize("mode", ("macro", "per-segment")) -def test_inverse_transform_not_inplace(normal_distributed_df, scaler, mode): - """Check that inversed values the same for not inplace version.""" - not_inplace_scaler = scaler(inplace=False, mode=mode) - columns_to_compare = normal_distributed_df.columns - transformed_df = not_inplace_scaler.fit_transform(df=normal_distributed_df.copy()) - inverse_transformed_df = not_inplace_scaler.inverse_transform(transformed_df) - assert np.all(inverse_transformed_df[columns_to_compare] == normal_distributed_df) - - -@pytest.mark.parametrize( - "scaler", - ( - DummyTransform, - StandardScalerTransform, - RobustScalerTransform, - MinMaxScalerTransform, - MaxAbsScalerTransform, - StandardScalerTransform, - RobustScalerTransform, - MinMaxScalerTransform, - ), -) -@pytest.mark.parametrize("mode", ("macro", "per-segment")) -def test_fit_transform_with_nans(scaler, mode, ts_diff_endings): - preprocess = scaler(in_column="target", mode=mode) - ts_diff_endings.fit_transform([preprocess]) diff --git a/tests/test_transforms/test_encoders/test_mean_segment_encoder_transform.py b/tests/test_transforms/test_encoders/test_mean_segment_encoder_transform.py index 0ac9bced2..a57ac6ea2 100644 --- a/tests/test_transforms/test_encoders/test_mean_segment_encoder_transform.py +++ b/tests/test_transforms/test_encoders/test_mean_segment_encoder_transform.py @@ -9,11 +9,11 @@ from tests.test_transforms.utils import assert_transformation_equals_loaded_original -@pytest.mark.parametrize("expected_global_means", ([[3, 30]])) +@pytest.mark.parametrize("expected_global_means", [{"Moscow": 3, "Omsk": 30}]) def test_mean_segment_encoder_fit(simple_df, expected_global_means): encoder = MeanSegmentEncoderTransform() encoder.fit(simple_df) - assert (encoder.global_means == expected_global_means).all() + assert encoder.global_means == expected_global_means def test_mean_segment_encoder_transform(simple_df, transformed_simple_df): @@ -22,6 +22,38 @@ def test_mean_segment_encoder_transform(simple_df, transformed_simple_df): pd.testing.assert_frame_equal(transformed_df, transformed_simple_df) +def test_subset_segments(simple_df): + train_df = simple_df + test_df = simple_df.loc[:, pd.IndexSlice["Omsk", :]] + transform = MeanSegmentEncoderTransform() + + transform.fit(train_df) + transformed_test_df = transform.transform(test_df) + + segments = sorted(transformed_test_df.columns.get_level_values("segment").unique()) + features = sorted(transformed_test_df.columns.get_level_values("feature").unique()) + assert segments == ["Omsk"] + assert features == ["exog", "segment_mean", "target"] + + +def test_not_fitted_error(simple_df): + encoder = MeanSegmentEncoderTransform() + with pytest.raises(ValueError, match="The transform isn't fitted"): + encoder.transform(simple_df) + + +def test_new_segments_error(simple_df): + train_df = simple_df.loc[:, pd.IndexSlice["Moscow", :]] + test_df = simple_df.loc[:, pd.IndexSlice["Omsk", :]] + transform = MeanSegmentEncoderTransform() + + transform.fit(train_df) + with pytest.raises( + NotImplementedError, match="This transform can't process segments that weren't present on train data" + ): + _ = transform.transform(test_df) + + @pytest.fixture def almost_constant_ts(random_seed) -> TSDataset: df_1 = pd.DataFrame.from_dict({"timestamp": pd.date_range("2021-06-01", "2021-07-01", freq="D")}) diff --git a/tests/test_transforms/test_encoders/test_segment_encoder_transform.py b/tests/test_transforms/test_encoders/test_segment_encoder_transform.py index 8a8891bb3..18bb32249 100644 --- a/tests/test_transforms/test_encoders/test_segment_encoder_transform.py +++ b/tests/test_transforms/test_encoders/test_segment_encoder_transform.py @@ -1,5 +1,6 @@ import numpy as np import pandas as pd +import pytest from etna.transforms import SegmentEncoderTransform from tests.test_transforms.utils import assert_transformation_equals_loaded_original @@ -21,6 +22,40 @@ def test_segment_encoder_transform(dummy_df): assert codes == {0, 1}, "Codes are not 0 and 1" +def test_subset_segments(dummy_df): + train_df = dummy_df + test_df = dummy_df.loc[:, pd.IndexSlice["Omsk", :]] + transform = SegmentEncoderTransform() + + transform.fit(train_df) + transformed_test_df = transform.transform(test_df) + + segments = sorted(transformed_test_df.columns.get_level_values("segment").unique()) + features = sorted(transformed_test_df.columns.get_level_values("feature").unique()) + assert segments == ["Omsk"] + assert features == ["segment_code", "target"] + values = transformed_test_df.loc[:, pd.IndexSlice[:, "segment_code"]] + assert np.all(values == values.iloc[0]) + + +def test_not_fitted_error(dummy_df): + encoder = SegmentEncoderTransform() + with pytest.raises(ValueError, match="The transform isn't fitted"): + encoder.transform(dummy_df) + + +def test_new_segments_error(dummy_df): + train_df = dummy_df.loc[:, pd.IndexSlice["Moscow", :]] + test_df = dummy_df.loc[:, pd.IndexSlice["Omsk", :]] + transform = SegmentEncoderTransform() + + transform.fit(train_df) + with pytest.raises( + NotImplementedError, match="This transform can't process segments that weren't present on train data" + ): + _ = transform.transform(test_df) + + def test_save_load(example_tsds): transform = SegmentEncoderTransform() assert_transformation_equals_loaded_original(transform=transform, ts=example_tsds) diff --git a/tests/test_transforms/test_inference/common.py b/tests/test_transforms/test_inference/common.py new file mode 100644 index 000000000..5a38de52d --- /dev/null +++ b/tests/test_transforms/test_inference/common.py @@ -0,0 +1,19 @@ +from typing import Set +from typing import Tuple + +import pandas as pd + + +def find_columns_diff(df_before: pd.DataFrame, df_after: pd.DataFrame) -> Tuple[Set[str], Set[str], Set[str]]: + columns_before_transform = set(df_before.columns) + columns_after_transform = set(df_after.columns) + created_columns = columns_after_transform - columns_before_transform + removed_columns = columns_before_transform - columns_after_transform + + columns_to_check_changes = columns_after_transform.intersection(columns_before_transform) + changed_columns = set() + for column in columns_to_check_changes: + if not df_before[column].equals(df_after[column]): + changed_columns.add(column) + + return created_columns, removed_columns, changed_columns diff --git a/tests/test_transforms/test_inference/conftest.py b/tests/test_transforms/test_inference/conftest.py new file mode 100644 index 000000000..a2295302e --- /dev/null +++ b/tests/test_transforms/test_inference/conftest.py @@ -0,0 +1,154 @@ +import numpy as np +import pandas as pd +import pytest + +from etna.datasets import TSDataset +from etna.datasets import duplicate_data + + +@pytest.fixture +def regular_ts(random_seed) -> TSDataset: + periods = 100 + df_1 = pd.DataFrame({"timestamp": pd.date_range("2020-01-01", periods=periods)}) + df_1["segment"] = "segment_1" + df_1["target"] = np.random.uniform(10, 20, size=periods) + + df_2 = pd.DataFrame({"timestamp": pd.date_range("2020-01-01", periods=periods)}) + df_2["segment"] = "segment_2" + df_2["target"] = np.random.uniform(-15, 5, size=periods) + + df_3 = pd.DataFrame({"timestamp": pd.date_range("2020-01-01", periods=periods)}) + df_3["segment"] = "segment_3" + df_3["target"] = np.random.uniform(-5, 5, size=periods) + + df = pd.concat([df_1, df_2, df_3]).reset_index(drop=True) + df = TSDataset.to_dataset(df) + tsds = TSDataset(df, freq="D") + + return tsds + + +@pytest.fixture +def ts_with_exog(regular_ts) -> TSDataset: + df = regular_ts.to_pandas(flatten=True) + periods = 200 + timestamp = pd.date_range("2020-01-01", periods=periods) + df_exog_common = pd.DataFrame( + { + "timestamp": timestamp, + "positive": 1, + "weekday": timestamp.weekday, + "monthday": timestamp.day, + "month": timestamp.month, + "year": timestamp.year, + } + ) + df_exog_wide = duplicate_data(df=df_exog_common, segments=regular_ts.segments) + + rng = np.random.default_rng(1) + df_exog_wide.loc[:, pd.IndexSlice["segment_1", "positive"]] = rng.uniform(5, 10, size=periods) + df_exog_wide.loc[:, pd.IndexSlice["segment_2", "positive"]] = rng.uniform(5, 10, size=periods) + df_exog_wide.loc[:, pd.IndexSlice["segment_3", "positive"]] = rng.uniform(5, 10, size=periods) + + ts = TSDataset(df=TSDataset.to_dataset(df).iloc[5:], df_exog=df_exog_wide, freq="D") + return ts + + +@pytest.fixture +def positive_ts() -> TSDataset: + periods = 100 + df_1 = pd.DataFrame.from_dict({"timestamp": pd.date_range("2020-01-01", periods=periods, freq="D")}) + df_2 = pd.DataFrame.from_dict({"timestamp": pd.date_range("2020-01-01", periods=periods, freq="D")}) + df_3 = pd.DataFrame.from_dict({"timestamp": pd.date_range("2020-01-01", periods=periods, freq="D")}) + generator = np.random.RandomState(seed=1) + + df_1["segment"] = "segment_1" + df_1["target"] = np.abs(generator.normal(loc=10, scale=1, size=len(df_1))) + 1 + + df_2["segment"] = "segment_2" + df_2["target"] = np.abs(generator.normal(loc=20, scale=1, size=len(df_2))) + 1 + + df_3["segment"] = "segment_3" + df_3["target"] = np.abs(generator.normal(loc=30, scale=1, size=len(df_2))) + 1 + + classic_df = pd.concat([df_1, df_2, df_3], ignore_index=True) + wide_df = TSDataset.to_dataset(classic_df) + ts = TSDataset(df=wide_df, freq="D") + return ts + + +@pytest.fixture +def ts_to_fill(regular_ts) -> TSDataset: + df = regular_ts.to_pandas() + df.iloc[5, 0] = np.NaN + df.iloc[10, 1] = np.NaN + df.iloc[20, 2] = np.NaN + df.iloc[-5, 0] = np.NaN + df.iloc[-10, 1] = np.NaN + df.iloc[-20, 2] = np.NaN + ts = TSDataset(df=df, freq="D") + return ts + + +@pytest.fixture +def ts_to_resample() -> TSDataset: + df_1 = pd.DataFrame( + { + "timestamp": pd.date_range(start="2020-01-05", freq="H", periods=120), + "segment": "segment_1", + "target": 1, + } + ) + df_2 = pd.DataFrame( + { + "timestamp": pd.date_range(start="2020-01-05", freq="H", periods=120), + "segment": "segment_2", + "target": ([1] + 23 * [0]) * 5, + } + ) + df_3 = pd.DataFrame( + { + "timestamp": pd.date_range(start="2020-01-05", freq="H", periods=120), + "segment": "segment_3", + "target": ([4] + 23 * [0]) * 5, + } + ) + df = pd.concat([df_1, df_2, df_3], ignore_index=True) + + df_exog_1 = pd.DataFrame( + { + "timestamp": pd.date_range(start="2020-01-05", freq="D", periods=8), + "segment": "segment_1", + "regressor_exog": 2, + } + ) + df_exog_2 = pd.DataFrame( + { + "timestamp": pd.date_range(start="2020-01-05", freq="D", periods=8), + "segment": "segment_2", + "regressor_exog": 40, + } + ) + df_exog_3 = pd.DataFrame( + { + "timestamp": pd.date_range(start="2020-01-05", freq="D", periods=8), + "segment": "segment_3", + "regressor_exog": 40, + } + ) + df_exog = pd.concat([df_exog_1, df_exog_2, df_exog_3], ignore_index=True) + ts = TSDataset(df=TSDataset.to_dataset(df), freq="H", df_exog=TSDataset.to_dataset(df_exog), known_future="all") + return ts + + +@pytest.fixture +def ts_with_outliers(regular_ts) -> TSDataset: + df = regular_ts.to_pandas() + df.iloc[5, 0] *= 100 + df.iloc[10, 1] *= 100 + df.iloc[20, 2] *= 100 + df.iloc[-5, 0] *= 100 + df.iloc[-10, 1] *= 100 + df.iloc[-20, 2] *= 100 + ts = TSDataset(df=df, freq="D") + return ts diff --git a/tests/test_transforms/test_inference/test_inverse_transform.py b/tests/test_transforms/test_inference/test_inverse_transform.py new file mode 100644 index 000000000..c85ee8483 --- /dev/null +++ b/tests/test_transforms/test_inference/test_inverse_transform.py @@ -0,0 +1,1859 @@ +from copy import deepcopy + +import pandas as pd +import pytest +from pandas.util.testing import assert_frame_equal +from ruptures import Binseg +from sklearn.linear_model import LinearRegression +from sklearn.tree import DecisionTreeRegressor + +from etna.analysis import StatisticsRelevanceTable +from etna.datasets import TSDataset +from etna.models import ProphetModel +from etna.transforms import AddConstTransform +from etna.transforms import BinsegTrendTransform +from etna.transforms import BoxCoxTransform +from etna.transforms import ChangePointsSegmentationTransform +from etna.transforms import ChangePointsTrendTransform +from etna.transforms import DateFlagsTransform +from etna.transforms import DensityOutliersTransform +from etna.transforms import DifferencingTransform +from etna.transforms import FilterFeaturesTransform +from etna.transforms import FourierTransform +from etna.transforms import GaleShapleyFeatureSelectionTransform +from etna.transforms import HolidayTransform +from etna.transforms import LabelEncoderTransform +from etna.transforms import LagTransform +from etna.transforms import LambdaTransform +from etna.transforms import LinearTrendTransform +from etna.transforms import LogTransform +from etna.transforms import MADTransform +from etna.transforms import MaxAbsScalerTransform +from etna.transforms import MaxTransform +from etna.transforms import MeanSegmentEncoderTransform +from etna.transforms import MeanTransform +from etna.transforms import MedianOutliersTransform +from etna.transforms import MedianTransform +from etna.transforms import MinMaxDifferenceTransform +from etna.transforms import MinMaxScalerTransform +from etna.transforms import MinTransform +from etna.transforms import MRMRFeatureSelectionTransform +from etna.transforms import OneHotEncoderTransform +from etna.transforms import PredictionIntervalOutliersTransform +from etna.transforms import QuantileTransform +from etna.transforms import ResampleWithDistributionTransform +from etna.transforms import RobustScalerTransform +from etna.transforms import SegmentEncoderTransform +from etna.transforms import SpecialDaysTransform +from etna.transforms import StandardScalerTransform +from etna.transforms import StdTransform +from etna.transforms import STLTransform +from etna.transforms import SumTransform +from etna.transforms import TheilSenTrendTransform +from etna.transforms import TimeFlagsTransform +from etna.transforms import TimeSeriesImputerTransform +from etna.transforms import TreeFeatureSelectionTransform +from etna.transforms import TrendTransform +from etna.transforms import YeoJohnsonTransform +from etna.transforms.decomposition import RupturesChangePointsModel +from tests.test_transforms.test_inference.common import find_columns_diff +from tests.utils import select_segments_subset +from tests.utils import to_be_fixed + + +class TestInverseTransformTrainSubsetSegments: + """Test inverse transform on train part of subset of segments. + + Expected that inverse transformation on subset of segments match subset of inverse transformation on full dataset. + """ + + def _test_inverse_transform_train_subset_segments(self, ts, transform, segments): + # select subset of tsdataset + segments = list(set(segments)) + subset_ts = select_segments_subset(ts=deepcopy(ts), segments=segments) + df = ts.to_pandas() + subset_df = subset_ts.to_pandas() + + # fitting + transform.fit(df) + + # transform full + transformed_df = transform.transform(df) + inverse_transformed_df = transform.inverse_transform(transformed_df) + + # transform subset of segments + transformed_subset_df = transform.transform(subset_df) + inverse_transformed_subset_df = transform.inverse_transform(transformed_subset_df) + + # checking + assert_frame_equal(inverse_transformed_subset_df, inverse_transformed_df.loc[:, pd.IndexSlice[segments, :]]) + + @pytest.mark.parametrize( + "transform, dataset_name", + [ + # decomposition + ( + ChangePointsSegmentationTransform( + in_column="target", + change_point_model=RupturesChangePointsModel(change_point_model=Binseg(), n_bkps=5), + ), + "regular_ts", + ), + ( + ChangePointsTrendTransform( + in_column="target", change_point_model=Binseg(), detrend_model=LinearRegression(), n_bkps=5 + ), + "regular_ts", + ), + (BinsegTrendTransform(in_column="target"), "regular_ts"), + (LinearTrendTransform(in_column="target"), "regular_ts"), + (TheilSenTrendTransform(in_column="target"), "regular_ts"), + (STLTransform(in_column="target", period=7), "regular_ts"), + (TrendTransform(in_column="target"), "regular_ts"), + # encoders + (LabelEncoderTransform(in_column="weekday"), "ts_with_exog"), + (OneHotEncoderTransform(in_column="weekday"), "ts_with_exog"), + (MeanSegmentEncoderTransform(), "regular_ts"), + (SegmentEncoderTransform(), "regular_ts"), + # feature_selection + (FilterFeaturesTransform(exclude=["year"]), "ts_with_exog"), + (GaleShapleyFeatureSelectionTransform(relevance_table=StatisticsRelevanceTable(), top_k=2), "ts_with_exog"), + (MRMRFeatureSelectionTransform(relevance_table=StatisticsRelevanceTable(), top_k=2), "ts_with_exog"), + (TreeFeatureSelectionTransform(model=DecisionTreeRegressor(random_state=42), top_k=2), "ts_with_exog"), + # math + (AddConstTransform(in_column="target", value=1, inplace=False), "regular_ts"), + (AddConstTransform(in_column="target", value=1, inplace=True), "regular_ts"), + (LagTransform(in_column="target", lags=[1, 2, 3]), "regular_ts"), + ( + LambdaTransform(in_column="target", transform_func=lambda x: x + 1, inplace=False), + "regular_ts", + ), + ( + LambdaTransform( + in_column="target", + transform_func=lambda x: x + 1, + inverse_transform_func=lambda x: x - 1, + inplace=True, + ), + "regular_ts", + ), + (LogTransform(in_column="target", inplace=False), "positive_ts"), + (LogTransform(in_column="target", inplace=True), "positive_ts"), + (DifferencingTransform(in_column="target", inplace=False), "regular_ts"), + (DifferencingTransform(in_column="target", inplace=True), "regular_ts"), + (MADTransform(in_column="target", window=7), "regular_ts"), + (MaxTransform(in_column="target", window=7), "regular_ts"), + (MeanTransform(in_column="target", window=7), "regular_ts"), + (MedianTransform(in_column="target", window=7), "regular_ts"), + (MinMaxDifferenceTransform(in_column="target", window=7), "regular_ts"), + (MinTransform(in_column="target", window=7), "regular_ts"), + (QuantileTransform(in_column="target", quantile=0.9, window=7), "regular_ts"), + (StdTransform(in_column="target", window=7), "regular_ts"), + (SumTransform(in_column="target", window=7), "regular_ts"), + (BoxCoxTransform(in_column="target", mode="per-segment", inplace=False), "positive_ts"), + (BoxCoxTransform(in_column="target", mode="per-segment", inplace=True), "positive_ts"), + (BoxCoxTransform(in_column="target", mode="macro", inplace=False), "positive_ts"), + (BoxCoxTransform(in_column="target", mode="macro", inplace=True), "positive_ts"), + (MaxAbsScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (MaxAbsScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (MaxAbsScalerTransform(in_column="target", mode="macro", inplace=False), "regular_ts"), + (MaxAbsScalerTransform(in_column="target", mode="macro", inplace=True), "regular_ts"), + (MinMaxScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (MinMaxScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (MinMaxScalerTransform(in_column="target", mode="macro", inplace=False), "regular_ts"), + (MinMaxScalerTransform(in_column="target", mode="macro", inplace=True), "regular_ts"), + (RobustScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (RobustScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (RobustScalerTransform(in_column="target", mode="macro", inplace=False), "regular_ts"), + (RobustScalerTransform(in_column="target", mode="macro", inplace=True), "regular_ts"), + (StandardScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (StandardScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (StandardScalerTransform(in_column="target", mode="macro", inplace=False), "regular_ts"), + (StandardScalerTransform(in_column="target", mode="macro", inplace=True), "regular_ts"), + (YeoJohnsonTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (YeoJohnsonTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (YeoJohnsonTransform(in_column="target", mode="macro", inplace=False), "regular_ts"), + (YeoJohnsonTransform(in_column="target", mode="macro", inplace=True), "regular_ts"), + # missing_values + ( + ResampleWithDistributionTransform( + in_column="regressor_exog", + distribution_column="target", + inplace=False, + ), + "ts_to_resample", + ), + ( + ResampleWithDistributionTransform( + in_column="regressor_exog", distribution_column="target", inplace=True + ), + "ts_to_resample", + ), + (TimeSeriesImputerTransform(in_column="target"), "ts_to_fill"), + # outliers + (DensityOutliersTransform(in_column="target"), "ts_with_outliers"), + (MedianOutliersTransform(in_column="target"), "ts_with_outliers"), + (PredictionIntervalOutliersTransform(in_column="target", model=ProphetModel), "ts_with_outliers"), + # timestamp + (DateFlagsTransform(), "regular_ts"), + (FourierTransform(period=7, order=2), "regular_ts"), + (HolidayTransform(), "regular_ts"), + (SpecialDaysTransform(), "regular_ts"), + (TimeFlagsTransform(), "regular_ts"), + ], + ) + def test_inverse_transform_train_subset_segments(self, transform, dataset_name, request): + ts = request.getfixturevalue(dataset_name) + self._test_inverse_transform_train_subset_segments(ts, transform, segments=["segment_2"]) + + +class TestInverseTransformFutureSubsetSegments: + """Test inverse transform on future part of subset of segments. + + Expected that inverse transformation on subset of segments match subset of inverse transformation on full dataset. + """ + + def _test_inverse_transform_future_subset_segments(self, ts, transform, segments, horizon=7): + # select subset of tsdataset + subset_ts = select_segments_subset(ts=deepcopy(ts), segments=segments) + train_df = ts.to_pandas() + ts.transforms = [transform] + subset_ts.transforms = [transform] + + # fitting + transform.fit(train_df) + + # transform full + transformed_future_ts = ts.make_future(future_steps=horizon) + transformed_future_df = transformed_future_ts.to_pandas() + inverse_transformed_future_ts = transform.inverse_transform(transformed_future_df) + + # transform subset of segments + transformed_subset_future_ts = subset_ts.make_future(future_steps=horizon) + transformed_subset_future_df = transformed_subset_future_ts.to_pandas() + inverse_transformed_subset_future_df = transform.inverse_transform(transformed_subset_future_df) + + # checking + assert_frame_equal( + inverse_transformed_subset_future_df, inverse_transformed_future_ts.loc[:, pd.IndexSlice[segments, :]] + ) + + @pytest.mark.parametrize( + "transform, dataset_name", + [ + # decomposition + ( + ChangePointsSegmentationTransform( + in_column="target", + change_point_model=RupturesChangePointsModel(change_point_model=Binseg(), n_bkps=5), + ), + "regular_ts", + ), + ( + ChangePointsTrendTransform( + in_column="target", change_point_model=Binseg(), detrend_model=LinearRegression(), n_bkps=5 + ), + "regular_ts", + ), + ( + ChangePointsTrendTransform( + in_column="positive", change_point_model=Binseg(), detrend_model=LinearRegression(), n_bkps=5 + ), + "ts_with_exog", + ), + (BinsegTrendTransform(in_column="target"), "regular_ts"), + (BinsegTrendTransform(in_column="positive"), "ts_with_exog"), + (LinearTrendTransform(in_column="target"), "regular_ts"), + (LinearTrendTransform(in_column="positive"), "ts_with_exog"), + (TheilSenTrendTransform(in_column="target"), "regular_ts"), + (TheilSenTrendTransform(in_column="positive"), "ts_with_exog"), + (STLTransform(in_column="target", period=7), "regular_ts"), + (STLTransform(in_column="positive", period=7), "ts_with_exog"), + (TrendTransform(in_column="target"), "regular_ts"), + # encoders + (LabelEncoderTransform(in_column="weekday"), "ts_with_exog"), + (OneHotEncoderTransform(in_column="weekday"), "ts_with_exog"), + (MeanSegmentEncoderTransform(), "regular_ts"), + (SegmentEncoderTransform(), "regular_ts"), + # feature_selection + (FilterFeaturesTransform(exclude=["year"]), "ts_with_exog"), + (GaleShapleyFeatureSelectionTransform(relevance_table=StatisticsRelevanceTable(), top_k=2), "ts_with_exog"), + (MRMRFeatureSelectionTransform(relevance_table=StatisticsRelevanceTable(), top_k=2), "ts_with_exog"), + (TreeFeatureSelectionTransform(model=DecisionTreeRegressor(random_state=42), top_k=2), "ts_with_exog"), + # math + (AddConstTransform(in_column="target", value=1, inplace=False), "regular_ts"), + (AddConstTransform(in_column="target", value=1, inplace=True), "regular_ts"), + (AddConstTransform(in_column="positive", value=1, inplace=True), "ts_with_exog"), + (LagTransform(in_column="target", lags=[1, 2, 3]), "regular_ts"), + ( + LambdaTransform(in_column="target", transform_func=lambda x: x + 1, inplace=False), + "regular_ts", + ), + ( + LambdaTransform( + in_column="target", + transform_func=lambda x: x + 1, + inverse_transform_func=lambda x: x - 1, + inplace=True, + ), + "regular_ts", + ), + ( + LambdaTransform( + in_column="positive", + transform_func=lambda x: x + 1, + inverse_transform_func=lambda x: x - 1, + inplace=True, + ), + "ts_with_exog", + ), + (LogTransform(in_column="target", inplace=False), "positive_ts"), + (LogTransform(in_column="target", inplace=True), "positive_ts"), + (LogTransform(in_column="positive", inplace=True), "ts_with_exog"), + (DifferencingTransform(in_column="target", inplace=False), "regular_ts"), + (DifferencingTransform(in_column="target", inplace=True), "regular_ts"), + (DifferencingTransform(in_column="positive", inplace=True), "ts_with_exog"), + (MADTransform(in_column="target", window=14), "regular_ts"), + (MaxTransform(in_column="target", window=14), "regular_ts"), + (MeanTransform(in_column="target", window=14), "regular_ts"), + (MedianTransform(in_column="target", window=14), "regular_ts"), + (MinMaxDifferenceTransform(in_column="target", window=14), "regular_ts"), + (MinTransform(in_column="target", window=14), "regular_ts"), + (QuantileTransform(in_column="target", quantile=0.9, window=14), "regular_ts"), + (StdTransform(in_column="target", window=14), "regular_ts"), + (SumTransform(in_column="target", window=14), "regular_ts"), + (BoxCoxTransform(in_column="target", mode="per-segment", inplace=False), "positive_ts"), + (BoxCoxTransform(in_column="target", mode="per-segment", inplace=True), "positive_ts"), + (BoxCoxTransform(in_column="positive", mode="per-segment", inplace=True), "ts_with_exog"), + (BoxCoxTransform(in_column="target", mode="macro", inplace=False), "positive_ts"), + (BoxCoxTransform(in_column="target", mode="macro", inplace=True), "positive_ts"), + (BoxCoxTransform(in_column="positive", mode="macro", inplace=True), "ts_with_exog"), + (MaxAbsScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (MaxAbsScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (MaxAbsScalerTransform(in_column="positive", mode="per-segment", inplace=True), "ts_with_exog"), + (MaxAbsScalerTransform(in_column="target", mode="macro", inplace=False), "regular_ts"), + (MaxAbsScalerTransform(in_column="target", mode="macro", inplace=True), "regular_ts"), + (MaxAbsScalerTransform(in_column="positive", mode="macro", inplace=True), "ts_with_exog"), + (MinMaxScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (MinMaxScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (MinMaxScalerTransform(in_column="positive", mode="per-segment", inplace=True), "ts_with_exog"), + (MinMaxScalerTransform(in_column="target", mode="macro", inplace=False), "regular_ts"), + (MinMaxScalerTransform(in_column="target", mode="macro", inplace=True), "regular_ts"), + (MinMaxScalerTransform(in_column="positive", mode="macro", inplace=True), "ts_with_exog"), + (RobustScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (RobustScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (RobustScalerTransform(in_column="positive", mode="per-segment", inplace=True), "ts_with_exog"), + (RobustScalerTransform(in_column="target", mode="macro", inplace=False), "regular_ts"), + (RobustScalerTransform(in_column="target", mode="macro", inplace=True), "regular_ts"), + (RobustScalerTransform(in_column="positive", mode="macro", inplace=True), "ts_with_exog"), + (StandardScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (StandardScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (StandardScalerTransform(in_column="positive", mode="per-segment", inplace=True), "ts_with_exog"), + (StandardScalerTransform(in_column="target", mode="macro", inplace=False), "regular_ts"), + (StandardScalerTransform(in_column="target", mode="macro", inplace=True), "regular_ts"), + (StandardScalerTransform(in_column="positive", mode="macro", inplace=True), "ts_with_exog"), + (YeoJohnsonTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (YeoJohnsonTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (YeoJohnsonTransform(in_column="positive", mode="per-segment", inplace=True), "ts_with_exog"), + (YeoJohnsonTransform(in_column="target", mode="macro", inplace=False), "regular_ts"), + (YeoJohnsonTransform(in_column="target", mode="macro", inplace=True), "regular_ts"), + (YeoJohnsonTransform(in_column="positive", mode="macro", inplace=True), "ts_with_exog"), + # missing_values + ( + ResampleWithDistributionTransform( + in_column="regressor_exog", + distribution_column="target", + inplace=False, + ), + "ts_to_resample", + ), + ( + ResampleWithDistributionTransform( + in_column="regressor_exog", distribution_column="target", inplace=True + ), + "ts_to_resample", + ), + (TimeSeriesImputerTransform(in_column="target"), "ts_to_fill"), + # outliers + (DensityOutliersTransform(in_column="target"), "ts_with_outliers"), + (MedianOutliersTransform(in_column="target"), "ts_with_outliers"), + (PredictionIntervalOutliersTransform(in_column="target", model=ProphetModel), "ts_with_outliers"), + # timestamp + (DateFlagsTransform(), "regular_ts"), + (FourierTransform(period=7, order=2), "regular_ts"), + (HolidayTransform(), "regular_ts"), + (SpecialDaysTransform(), "regular_ts"), + (TimeFlagsTransform(), "regular_ts"), + ], + ) + def test_inverse_transform_future_subset_segments(self, transform, dataset_name, request): + ts = request.getfixturevalue(dataset_name) + self._test_inverse_transform_future_subset_segments(ts, transform, segments=["segment_2"]) + + +class TestInverseTransformTrainNewSegments: + """Test inverse transform on train part of new segments. + + Expected that inverse transformation creates columns, removes columns and reverts values back to original. + """ + + def _test_inverse_transform_train_new_segments(self, ts, transform, train_segments, expected_changes): + # select subset of tsdataset + train_segments = list(set(train_segments)) + forecast_segments = list(set(ts.segments) - set(train_segments)) + train_ts = select_segments_subset(ts=deepcopy(ts), segments=train_segments) + test_ts = select_segments_subset(ts=deepcopy(ts), segments=forecast_segments) + train_df = train_ts.to_pandas() + test_df = test_ts.to_pandas() + + # fitting + transform.fit(train_df) + + # transform + transformed_test_df = transform.transform(test_df.copy()) + + # inverse transform + inverse_transformed_test_df = transform.inverse_transform(transformed_test_df.copy()) + + # checking + expected_columns_to_create = expected_changes.get("create", set()) + expected_columns_to_remove = expected_changes.get("remove", set()) + expected_columns_to_change = expected_changes.get("change", set()) + flat_test_df = TSDataset.to_flatten(test_df) + flat_transformed_test_df = TSDataset.to_flatten(transformed_test_df) + flat_inverse_transformed_test_df = TSDataset.to_flatten(inverse_transformed_test_df) + created_columns, removed_columns, changed_columns = find_columns_diff( + flat_transformed_test_df, flat_inverse_transformed_test_df + ) + + assert created_columns == expected_columns_to_create + assert removed_columns == expected_columns_to_remove + assert changed_columns == expected_columns_to_change + pd.testing.assert_frame_equal(flat_test_df[changed_columns], flat_inverse_transformed_test_df[changed_columns]) + + @pytest.mark.parametrize( + "transform, dataset_name, expected_changes", + [ + # encoders + (LabelEncoderTransform(in_column="weekday", out_column="res"), "ts_with_exog", {}), + ( + OneHotEncoderTransform(in_column="weekday", out_column="res"), + "ts_with_exog", + {}, + ), + # feature_selection + (FilterFeaturesTransform(exclude=["year"]), "ts_with_exog", {}), + (FilterFeaturesTransform(exclude=["year"], return_features=True), "ts_with_exog", {"create": {"year"}}), + ( + GaleShapleyFeatureSelectionTransform(relevance_table=StatisticsRelevanceTable(), top_k=2), + "ts_with_exog", + {}, + ), + ( + GaleShapleyFeatureSelectionTransform( + relevance_table=StatisticsRelevanceTable(), top_k=2, return_features=True + ), + "ts_with_exog", + {"create": {"year", "weekday", "month"}}, + ), + ( + MRMRFeatureSelectionTransform(relevance_table=StatisticsRelevanceTable(), top_k=2), + "ts_with_exog", + {}, + ), + ( + MRMRFeatureSelectionTransform( + relevance_table=StatisticsRelevanceTable(), top_k=2, return_features=True + ), + "ts_with_exog", + {"create": {"monthday", "positive", "weekday"}}, + ), + ( + TreeFeatureSelectionTransform(model=DecisionTreeRegressor(random_state=42), top_k=2), + "ts_with_exog", + {}, + ), + ( + TreeFeatureSelectionTransform( + model=DecisionTreeRegressor(random_state=42), top_k=2, return_features=True + ), + "ts_with_exog", + {"create": {"month", "year", "weekday"}}, + ), + # math + ( + AddConstTransform(in_column="target", value=1, inplace=False, out_column="res"), + "regular_ts", + {}, + ), + (AddConstTransform(in_column="target", value=1, inplace=True), "regular_ts", {"change": {"target"}}), + ( + LagTransform(in_column="target", lags=[1, 2, 3], out_column="res"), + "regular_ts", + {}, + ), + ( + LambdaTransform(in_column="target", transform_func=lambda x: x + 1, inplace=False, out_column="res"), + "regular_ts", + {}, + ), + ( + LambdaTransform( + in_column="target", + transform_func=lambda x: x + 1, + inverse_transform_func=lambda x: x - 1, + inplace=True, + ), + "regular_ts", + {"change": {"target"}}, + ), + (LogTransform(in_column="target", inplace=False, out_column="res"), "positive_ts", {}), + (LogTransform(in_column="target", inplace=True), "positive_ts", {"change": {"target"}}), + ( + DifferencingTransform(in_column="target", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + (MADTransform(in_column="target", window=7, out_column="res"), "regular_ts", {}), + (MaxTransform(in_column="target", window=7, out_column="res"), "regular_ts", {}), + (MeanTransform(in_column="target", window=7, out_column="res"), "regular_ts", {}), + (MedianTransform(in_column="target", window=7, out_column="res"), "regular_ts", {}), + ( + MinMaxDifferenceTransform(in_column="target", window=7, out_column="res"), + "regular_ts", + {}, + ), + (MinTransform(in_column="target", window=7, out_column="res"), "regular_ts", {}), + ( + QuantileTransform(in_column="target", quantile=0.9, window=7, out_column="res"), + "regular_ts", + {}, + ), + (StdTransform(in_column="target", window=7, out_column="res"), "regular_ts", {}), + (SumTransform(in_column="target", window=7, out_column="res"), "regular_ts", {}), + ( + BoxCoxTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "positive_ts", + {}, + ), + (BoxCoxTransform(in_column="target", mode="macro", inplace=True), "positive_ts", {"change": {"target"}}), + ( + MaxAbsScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + ( + MaxAbsScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + MinMaxScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + ( + MinMaxScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + RobustScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + ( + RobustScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + StandardScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + ( + StandardScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + YeoJohnsonTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + (YeoJohnsonTransform(in_column="target", mode="macro", inplace=True), "regular_ts", {"change": {"target"}}), + # timestamp + ( + DateFlagsTransform(out_column="res"), + "regular_ts", + {}, + ), + ( + FourierTransform(period=7, order=2, out_column="res"), + "regular_ts", + {}, + ), + (HolidayTransform(out_column="res"), "regular_ts", {}), + ( + TimeFlagsTransform(out_column="res"), + "regular_ts", + {}, + ), + ], + ) + def test_inverse_transform_train_new_segments(self, transform, dataset_name, expected_changes, request): + ts = request.getfixturevalue(dataset_name) + self._test_inverse_transform_train_new_segments( + ts, transform, train_segments=["segment_1", "segment_2"], expected_changes=expected_changes + ) + + @pytest.mark.parametrize( + "transform, dataset_name", + [ + # decomposition + ( + ChangePointsSegmentationTransform( + in_column="target", + change_point_model=RupturesChangePointsModel(change_point_model=Binseg(), n_bkps=5), + ), + "regular_ts", + ), + ( + ChangePointsTrendTransform( + in_column="target", change_point_model=Binseg(), detrend_model=LinearRegression(), n_bkps=5 + ), + "regular_ts", + ), + (BinsegTrendTransform(in_column="target"), "regular_ts"), + (LinearTrendTransform(in_column="target"), "regular_ts"), + (TheilSenTrendTransform(in_column="target"), "regular_ts"), + (STLTransform(in_column="target", period=7), "regular_ts"), + (TrendTransform(in_column="target"), "regular_ts"), + # encoders + (MeanSegmentEncoderTransform(), "regular_ts"), + (SegmentEncoderTransform(), "regular_ts"), + # math + (DifferencingTransform(in_column="target", inplace=True), "regular_ts"), + (BoxCoxTransform(in_column="target", mode="per-segment", inplace=False), "positive_ts"), + (BoxCoxTransform(in_column="target", mode="per-segment", inplace=True), "positive_ts"), + (MaxAbsScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (MaxAbsScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (MinMaxScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (MinMaxScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (RobustScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (RobustScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (StandardScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (StandardScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (YeoJohnsonTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (YeoJohnsonTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + # missing_values + ( + ResampleWithDistributionTransform( + in_column="regressor_exog", distribution_column="target", inplace=False + ), + "ts_to_resample", + ), + ( + ResampleWithDistributionTransform( + in_column="regressor_exog", distribution_column="target", inplace=True + ), + "ts_to_resample", + ), + ( + TimeSeriesImputerTransform(in_column="target"), + "ts_to_fill", + ), + # outliers + (DensityOutliersTransform(in_column="target"), "ts_with_outliers"), + (MedianOutliersTransform(in_column="target"), "ts_with_outliers"), + (PredictionIntervalOutliersTransform(in_column="target", model=ProphetModel), "ts_with_outliers"), + ], + ) + def test_inverse_transform_train_new_segments_not_implemented(self, transform, dataset_name, request): + ts = request.getfixturevalue(dataset_name) + with pytest.raises(NotImplementedError): + self._test_inverse_transform_train_new_segments( + ts, transform, train_segments=["segment_1", "segment_2"], expected_changes={} + ) + + @to_be_fixed(raises=NotImplementedError, match="Per-segment transforms can't work on new segments") + @pytest.mark.parametrize( + "transform, dataset_name", + [ + # timestamp + (SpecialDaysTransform(), "regular_ts"), + ], + ) + def test_inverse_transform_train_new_segments_failed_not_implemented(self, transform, dataset_name, request): + ts = request.getfixturevalue(dataset_name) + self._test_inverse_transform_train_new_segments( + ts, transform, train_segments=["segment_1", "segment_2"], expected_changes={} + ) + + +class TestInverseTransformFutureNewSegments: + """Test inverse transform on future part of new segments. + + Expected that inverse transformation creates columns, removes columns and reverts values back to original. + """ + + def _test_inverse_transform_future_new_segments(self, ts, transform, train_segments, expected_changes, horizon=7): + # select subset of tsdataset + train_segments = list(set(train_segments)) + forecast_segments = list(set(ts.segments) - set(train_segments)) + train_ts = select_segments_subset(ts=deepcopy(ts), segments=train_segments) + test_ts_without_transform = select_segments_subset(ts=deepcopy(ts), segments=forecast_segments) + test_ts_with_transform = select_segments_subset(ts=deepcopy(ts), segments=forecast_segments) + test_ts_without_transform.transforms = [] + test_ts_with_transform.transforms = [transform] + train_df = train_ts.to_pandas() + + # fitting + transform.fit(train_df) + + # prepare df without transform + test_ts = test_ts_without_transform.make_future(future_steps=horizon) + test_df = test_ts.to_pandas() + + # transform + transformed_test_ts = test_ts_with_transform.make_future(future_steps=horizon) + transformed_test_df = transformed_test_ts.to_pandas() + + # inverse transform + inverse_transformed_test_df = transform.inverse_transform(transformed_test_df) + + # checking + expected_columns_to_create = expected_changes.get("create", set()) + expected_columns_to_remove = expected_changes.get("remove", set()) + expected_columns_to_change = expected_changes.get("change", set()) + flat_test_df = TSDataset.to_flatten(test_df) + flat_transformed_test_df = TSDataset.to_flatten(transformed_test_df) + flat_inverse_transformed_test_df = TSDataset.to_flatten(inverse_transformed_test_df) + created_columns, removed_columns, changed_columns = find_columns_diff( + flat_transformed_test_df, flat_inverse_transformed_test_df + ) + + assert created_columns == expected_columns_to_create + assert removed_columns == expected_columns_to_remove + assert changed_columns == expected_columns_to_change + pd.testing.assert_frame_equal(flat_test_df[changed_columns], flat_inverse_transformed_test_df[changed_columns]) + + @pytest.mark.parametrize( + "transform, dataset_name, expected_changes", + [ + # encoders + (LabelEncoderTransform(in_column="weekday", out_column="res"), "ts_with_exog", {}), + ( + OneHotEncoderTransform(in_column="weekday", out_column="res"), + "ts_with_exog", + {}, + ), + # feature_selection + (FilterFeaturesTransform(exclude=["year"]), "ts_with_exog", {}), + ( + GaleShapleyFeatureSelectionTransform(relevance_table=StatisticsRelevanceTable(), top_k=2), + "ts_with_exog", + {}, + ), + ( + MRMRFeatureSelectionTransform(relevance_table=StatisticsRelevanceTable(), top_k=2), + "ts_with_exog", + {}, + ), + ( + TreeFeatureSelectionTransform(model=DecisionTreeRegressor(random_state=42), top_k=2), + "ts_with_exog", + {}, + ), + # math + ( + AddConstTransform(in_column="target", value=1, inplace=False, out_column="res"), + "regular_ts", + {}, + ), + (AddConstTransform(in_column="target", value=1, inplace=True), "regular_ts", {}), + (AddConstTransform(in_column="positive", value=1, inplace=True), "ts_with_exog", {"change": {"positive"}}), + ( + LagTransform(in_column="target", lags=[1, 2, 3], out_column="res"), + "regular_ts", + {}, + ), + ( + LambdaTransform(in_column="target", transform_func=lambda x: x + 1, inplace=False, out_column="res"), + "regular_ts", + {}, + ), + ( + LambdaTransform( + in_column="target", + transform_func=lambda x: x + 1, + inverse_transform_func=lambda x: x - 1, + inplace=True, + ), + "regular_ts", + {}, + ), + ( + LambdaTransform( + in_column="positive", + transform_func=lambda x: x + 1, + inverse_transform_func=lambda x: x - 1, + inplace=True, + ), + "ts_with_exog", + {"change": {"positive"}}, + ), + (LogTransform(in_column="target", inplace=False, out_column="res"), "positive_ts", {}), + (LogTransform(in_column="target", inplace=True), "positive_ts", {}), + (LogTransform(in_column="positive", inplace=True), "ts_with_exog", {"change": {"positive"}}), + ( + DifferencingTransform(in_column="target", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + (MADTransform(in_column="target", window=14, out_column="res"), "regular_ts", {}), + (MaxTransform(in_column="target", window=14, out_column="res"), "regular_ts", {}), + (MeanTransform(in_column="target", window=14, out_column="res"), "regular_ts", {}), + (MedianTransform(in_column="target", window=14, out_column="res"), "regular_ts", {}), + ( + MinMaxDifferenceTransform(in_column="target", window=14, out_column="res"), + "regular_ts", + {}, + ), + (MinTransform(in_column="target", window=14, out_column="res"), "regular_ts", {}), + ( + QuantileTransform(in_column="target", quantile=0.9, window=14, out_column="res"), + "regular_ts", + {}, + ), + (StdTransform(in_column="target", window=14, out_column="res"), "regular_ts", {}), + (SumTransform(in_column="target", window=14, out_column="res"), "regular_ts", {}), + ( + BoxCoxTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "positive_ts", + {}, + ), + (BoxCoxTransform(in_column="target", mode="macro", inplace=True), "positive_ts", {}), + ( + BoxCoxTransform(in_column="positive", mode="macro", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + MaxAbsScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + ( + MaxAbsScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {}, + ), + ( + MaxAbsScalerTransform(in_column="positive", mode="macro", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + MinMaxScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + ( + MinMaxScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {}, + ), + ( + MinMaxScalerTransform(in_column="positive", mode="macro", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + RobustScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + ( + RobustScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {}, + ), + ( + RobustScalerTransform(in_column="positive", mode="macro", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + StandardScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + ( + StandardScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {}, + ), + ( + StandardScalerTransform(in_column="positive", mode="macro", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + YeoJohnsonTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + (YeoJohnsonTransform(in_column="target", mode="macro", inplace=True), "regular_ts", {}), + ( + YeoJohnsonTransform(in_column="positive", mode="macro", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + # timestamp + ( + DateFlagsTransform(out_column="res"), + "regular_ts", + {}, + ), + ( + FourierTransform(period=7, order=2, out_column="res"), + "regular_ts", + {}, + ), + (HolidayTransform(out_column="res"), "regular_ts", {}), + ( + TimeFlagsTransform(out_column="res"), + "regular_ts", + {}, + ), + ], + ) + def test_inverse_transform_future_new_segments(self, transform, dataset_name, expected_changes, request): + ts = request.getfixturevalue(dataset_name) + self._test_inverse_transform_future_new_segments( + ts, transform, train_segments=["segment_1", "segment_2"], expected_changes=expected_changes + ) + + @pytest.mark.parametrize( + "transform, dataset_name", + [ + # decomposition + ( + ChangePointsSegmentationTransform( + in_column="target", + change_point_model=RupturesChangePointsModel(change_point_model=Binseg(), n_bkps=5), + ), + "regular_ts", + ), + ( + ChangePointsTrendTransform( + in_column="target", change_point_model=Binseg(), detrend_model=LinearRegression(), n_bkps=5 + ), + "regular_ts", + ), + (BinsegTrendTransform(in_column="target"), "regular_ts"), + (LinearTrendTransform(in_column="target"), "regular_ts"), + (TheilSenTrendTransform(in_column="target"), "regular_ts"), + (STLTransform(in_column="target", period=7), "regular_ts"), + (TrendTransform(in_column="target"), "regular_ts"), + # encoders + (MeanSegmentEncoderTransform(), "regular_ts"), + (SegmentEncoderTransform(), "regular_ts"), + # math + (DifferencingTransform(in_column="target", inplace=True), "regular_ts"), + (DifferencingTransform(in_column="positive", inplace=True), "ts_with_exog"), + (BoxCoxTransform(in_column="target", mode="per-segment", inplace=False), "positive_ts"), + (BoxCoxTransform(in_column="target", mode="per-segment", inplace=True), "positive_ts"), + (BoxCoxTransform(in_column="positive", mode="per-segment", inplace=True), "ts_with_exog"), + (MaxAbsScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (MaxAbsScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (MaxAbsScalerTransform(in_column="positive", mode="per-segment", inplace=True), "ts_with_exog"), + (MinMaxScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (MinMaxScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (MinMaxScalerTransform(in_column="positive", mode="per-segment", inplace=True), "ts_with_exog"), + (RobustScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (RobustScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (RobustScalerTransform(in_column="positive", mode="per-segment", inplace=True), "ts_with_exog"), + (StandardScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (StandardScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (StandardScalerTransform(in_column="positive", mode="per-segment", inplace=True), "ts_with_exog"), + (YeoJohnsonTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (YeoJohnsonTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (YeoJohnsonTransform(in_column="positive", mode="per-segment", inplace=True), "ts_with_exog"), + # missing_values + ( + ResampleWithDistributionTransform( + in_column="regressor_exog", distribution_column="target", inplace=False + ), + "ts_to_resample", + ), + ( + ResampleWithDistributionTransform( + in_column="regressor_exog", distribution_column="target", inplace=True + ), + "ts_to_resample", + ), + ( + TimeSeriesImputerTransform(in_column="target"), + "ts_to_fill", + ), + # outliers + (DensityOutliersTransform(in_column="target"), "ts_with_outliers"), + (MedianOutliersTransform(in_column="target"), "ts_with_outliers"), + (PredictionIntervalOutliersTransform(in_column="target", model=ProphetModel), "ts_with_outliers"), + ], + ) + def test_inverse_transform_future_new_segments_not_implemented(self, transform, dataset_name, request): + ts = request.getfixturevalue(dataset_name) + with pytest.raises(NotImplementedError): + self._test_inverse_transform_future_new_segments( + ts, transform, train_segments=["segment_1", "segment_2"], expected_changes={} + ) + + @to_be_fixed(raises=NotImplementedError, match="Per-segment transforms can't work on new segments") + @pytest.mark.parametrize( + "transform, dataset_name", + [ + # timestamp + (SpecialDaysTransform(), "regular_ts"), + ], + ) + def test_inverse_transform_future_new_segments_failed_not_implemented(self, transform, dataset_name, request): + ts = request.getfixturevalue(dataset_name) + self._test_inverse_transform_future_new_segments( + ts, transform, train_segments=["segment_1", "segment_2"], expected_changes={} + ) + + @to_be_fixed(raises=Exception) + @pytest.mark.parametrize( + "transform, dataset_name, expected_changes", + [ + # feature_selection + # TODO: working incorrectly, should fail + (FilterFeaturesTransform(exclude=["year"], return_features=True), "ts_with_exog", {"create": {"year"}}), + ( + GaleShapleyFeatureSelectionTransform( + relevance_table=StatisticsRelevanceTable(), top_k=2, return_features=True + ), + "ts_with_exog", + {"create": {"monthday", "positive", "weekday", "year", "month"}}, + ), + ( + MRMRFeatureSelectionTransform( + relevance_table=StatisticsRelevanceTable(), top_k=2, return_features=True + ), + "ts_with_exog", + {"create": {"positive", "monthday", "weekday"}}, + ), + ( + TreeFeatureSelectionTransform( + model=DecisionTreeRegressor(random_state=42), top_k=2, return_features=True + ), + "ts_with_exog", + {"create": {"year", "month", "weekday"}}, + ), + ], + ) + def test_inverse_transform_future_new_segments_failed_error( + self, transform, dataset_name, expected_changes, request + ): + ts = request.getfixturevalue(dataset_name) + self._test_inverse_transform_future_new_segments( + ts, transform, train_segments=["segment_1", "segment_2"], expected_changes=expected_changes + ) + + +class TestInverseTransformFutureWithTarget: + """Test inverse transform on future dataset with known target. + + Expected that inverse transformation creates columns, removes columns and reverts values back to original. + """ + + def _test_inverse_transform_future_with_target( + self, ts, transform, expected_changes, gap_size=7, transform_size=50 + ): + # select subset of tsdataset + history_ts, future_full_ts = ts.train_test_split(test_size=gap_size + transform_size) + _, test_ts = future_full_ts.train_test_split(test_size=transform_size) + train_df = history_ts.to_pandas() + test_df = test_ts.to_pandas() + + # fitting + transform.fit(train_df) + + # transform + transformed_test_df = transform.transform(test_df.copy()) + + # inverse transform + inverse_transformed_test_df = transform.inverse_transform(transformed_test_df.copy()) + + # checking + expected_columns_to_create = expected_changes.get("create", set()) + expected_columns_to_remove = expected_changes.get("remove", set()) + expected_columns_to_change = expected_changes.get("change", set()) + flat_test_df = TSDataset.to_flatten(test_df) + flat_transformed_test_df = TSDataset.to_flatten(transformed_test_df) + flat_inverse_transformed_test_df = TSDataset.to_flatten(inverse_transformed_test_df) + created_columns, removed_columns, changed_columns = find_columns_diff( + flat_transformed_test_df, flat_inverse_transformed_test_df + ) + + assert created_columns == expected_columns_to_create + assert removed_columns == expected_columns_to_remove + assert changed_columns == expected_columns_to_change + pd.testing.assert_frame_equal( + flat_test_df[changed_columns], + flat_inverse_transformed_test_df[changed_columns], + ) + + @pytest.mark.parametrize( + "transform, dataset_name, expected_changes", + [ + # decomposition + ( + ChangePointsSegmentationTransform( + in_column="target", + change_point_model=RupturesChangePointsModel(change_point_model=Binseg(), n_bkps=5), + out_column="res", + ), + "regular_ts", + {}, + ), + ( + ChangePointsTrendTransform( + in_column="target", change_point_model=Binseg(), detrend_model=LinearRegression(), n_bkps=5 + ), + "regular_ts", + {"change": {"target"}}, + ), + (BinsegTrendTransform(in_column="target"), "regular_ts", {"change": {"target"}}), + (LinearTrendTransform(in_column="target"), "regular_ts", {"change": {"target"}}), + (TheilSenTrendTransform(in_column="target"), "regular_ts", {"change": {"target"}}), + (STLTransform(in_column="target", period=7), "regular_ts", {"change": {"target"}}), + (TrendTransform(in_column="target", out_column="res"), "regular_ts", {}), + # encoders + (LabelEncoderTransform(in_column="weekday", out_column="res"), "ts_with_exog", {}), + ( + OneHotEncoderTransform(in_column="weekday", out_column="res"), + "ts_with_exog", + {}, + ), + (MeanSegmentEncoderTransform(), "regular_ts", {}), + (SegmentEncoderTransform(), "regular_ts", {}), + # feature_selection + (FilterFeaturesTransform(exclude=["year"]), "ts_with_exog", {}), + (FilterFeaturesTransform(exclude=["year"], return_features=True), "ts_with_exog", {"create": {"year"}}), + ( + GaleShapleyFeatureSelectionTransform(relevance_table=StatisticsRelevanceTable(), top_k=2), + "ts_with_exog", + {}, + ), + ( + GaleShapleyFeatureSelectionTransform( + relevance_table=StatisticsRelevanceTable(), top_k=2, return_features=True + ), + "ts_with_exog", + {"create": {"month", "year", "positive"}}, + ), + ( + MRMRFeatureSelectionTransform(relevance_table=StatisticsRelevanceTable(), top_k=2), + "ts_with_exog", + {}, + ), + ( + MRMRFeatureSelectionTransform( + relevance_table=StatisticsRelevanceTable(), top_k=2, return_features=True + ), + "ts_with_exog", + {"create": {"weekday", "monthday", "positive"}}, + ), + ( + TreeFeatureSelectionTransform(model=DecisionTreeRegressor(random_state=42), top_k=2), + "ts_with_exog", + {}, + ), + ( + TreeFeatureSelectionTransform( + model=DecisionTreeRegressor(random_state=42), top_k=2, return_features=True + ), + "ts_with_exog", + {"create": {"year", "month", "weekday"}}, + ), + # math + ( + AddConstTransform(in_column="target", value=1, inplace=False, out_column="res"), + "regular_ts", + {}, + ), + (AddConstTransform(in_column="target", value=1, inplace=True), "regular_ts", {"change": {"target"}}), + ( + LagTransform(in_column="target", lags=[1, 2, 3], out_column="res"), + "regular_ts", + {}, + ), + ( + LambdaTransform(in_column="target", transform_func=lambda x: x + 1, inplace=False, out_column="res"), + "regular_ts", + {}, + ), + ( + LambdaTransform( + in_column="target", + transform_func=lambda x: x + 1, + inverse_transform_func=lambda x: x - 1, + inplace=True, + ), + "regular_ts", + {"change": {"target"}}, + ), + (LogTransform(in_column="target", inplace=False, out_column="res"), "positive_ts", {}), + (LogTransform(in_column="target", inplace=True), "positive_ts", {"change": {"target"}}), + ( + DifferencingTransform(in_column="target", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + (MADTransform(in_column="target", window=7, out_column="res"), "regular_ts", {}), + (MaxTransform(in_column="target", window=7, out_column="res"), "regular_ts", {}), + (MeanTransform(in_column="target", window=7, out_column="res"), "regular_ts", {}), + (MedianTransform(in_column="target", window=7, out_column="res"), "regular_ts", {}), + ( + MinMaxDifferenceTransform(in_column="target", window=7, out_column="res"), + "regular_ts", + {}, + ), + (MinTransform(in_column="target", window=7, out_column="res"), "regular_ts", {}), + ( + QuantileTransform(in_column="target", quantile=0.9, window=7, out_column="res"), + "regular_ts", + {}, + ), + (StdTransform(in_column="target", window=7, out_column="res"), "regular_ts", {}), + (SumTransform(in_column="target", window=7, out_column="res"), "regular_ts", {}), + ( + BoxCoxTransform(in_column="target", mode="per-segment", inplace=False, out_column="res"), + "positive_ts", + {}, + ), + ( + BoxCoxTransform(in_column="target", mode="per-segment", inplace=True), + "positive_ts", + {"change": {"target"}}, + ), + ( + BoxCoxTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "positive_ts", + {}, + ), + (BoxCoxTransform(in_column="target", mode="macro", inplace=True), "positive_ts", {"change": {"target"}}), + ( + MaxAbsScalerTransform(in_column="target", mode="per-segment", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + ( + MaxAbsScalerTransform(in_column="target", mode="per-segment", inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + MaxAbsScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + ( + MaxAbsScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + MinMaxScalerTransform(in_column="target", mode="per-segment", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + ( + # setting clip=False is important + MinMaxScalerTransform(in_column="target", mode="per-segment", clip=False, inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + MinMaxScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + ( + # setting clip=False is important + MinMaxScalerTransform(in_column="target", mode="macro", clip=False, inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + RobustScalerTransform(in_column="target", mode="per-segment", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + ( + RobustScalerTransform(in_column="target", mode="per-segment", inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + RobustScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + ( + RobustScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + StandardScalerTransform(in_column="target", mode="per-segment", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + ( + StandardScalerTransform(in_column="target", mode="per-segment", inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + StandardScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + ( + StandardScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + YeoJohnsonTransform(in_column="target", mode="per-segment", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + ( + YeoJohnsonTransform(in_column="target", mode="per-segment", inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + YeoJohnsonTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + (YeoJohnsonTransform(in_column="target", mode="macro", inplace=True), "regular_ts", {"change": {"target"}}), + # missing_values + ( + ResampleWithDistributionTransform( + in_column="regressor_exog", distribution_column="target", inplace=False, out_column="res" + ), + "ts_to_resample", + {}, + ), + ( + # this behaviour can be unexpected for someone + TimeSeriesImputerTransform(in_column="target"), + "ts_to_fill", + {}, + ), + # outliers + (DensityOutliersTransform(in_column="target"), "ts_with_outliers", {}), + (MedianOutliersTransform(in_column="target"), "ts_with_outliers", {}), + (PredictionIntervalOutliersTransform(in_column="target", model=ProphetModel), "ts_with_outliers", {}), + # timestamp + ( + DateFlagsTransform(out_column="res"), + "regular_ts", + {}, + ), + ( + FourierTransform(period=7, order=2, out_column="res"), + "regular_ts", + {}, + ), + (HolidayTransform(out_column="res"), "regular_ts", {}), + ( + TimeFlagsTransform(out_column="res"), + "regular_ts", + {}, + ), + (SpecialDaysTransform(), "regular_ts", {}), + ], + ) + def test_inverse_transform_future_with_target(self, transform, dataset_name, expected_changes, request): + ts = request.getfixturevalue(dataset_name) + self._test_inverse_transform_future_with_target(ts, transform, expected_changes=expected_changes) + + @pytest.mark.parametrize( + "transform, dataset_name, expected_changes", + [ + (DifferencingTransform(in_column="target", inplace=True), "regular_ts", {}), + ], + ) + def test_inverse_transform_future_with_target_fail_difference( + self, transform, dataset_name, expected_changes, request + ): + ts = request.getfixturevalue(dataset_name) + with pytest.raises(ValueError, match="Test should go after the train without gaps"): + self._test_inverse_transform_future_with_target(ts, transform, expected_changes=expected_changes) + + # It is the only transform that doesn't change values back during `inverse_transform` + @to_be_fixed(raises=AssertionError) + @pytest.mark.parametrize( + "transform, dataset_name, expected_changes", + [ + ( + ResampleWithDistributionTransform( + in_column="regressor_exog", distribution_column="target", inplace=True + ), + "ts_to_resample", + {"change": {"regressor_exog"}}, + ), + ], + ) + def test_inverse_transform_future_with_target_fail_resample( + self, transform, dataset_name, expected_changes, request + ): + ts = request.getfixturevalue(dataset_name) + self._test_inverse_transform_future_with_target(ts, transform, expected_changes=expected_changes) + + +class TestInverseTransformFutureWithoutTarget: + """Test inverse transform on future dataset with unknown target. + + Expected that inverse transformation creates columns, removes columns and reverts values back to original. + """ + + def _test_inverse_transform_future_without_target( + self, ts, transform, expected_changes, gap_size=28, transform_size=7 + ): + # select subset of tsdataset + history_ts, future_ts = ts.train_test_split(test_size=gap_size) + future_ts_without_transform = future_ts + future_ts_with_transform = deepcopy(future_ts) + future_ts_without_transform.transforms = [] + future_ts_with_transform.transforms = [transform] + train_df = history_ts.to_pandas() + + # fitting + transform.fit(train_df) + + # prepare df without transform + test_ts = future_ts_without_transform.make_future(future_steps=transform_size) + test_df = test_ts.to_pandas() + + # transform + transformed_test_ts = future_ts_with_transform.make_future(future_steps=transform_size) + transformed_test_df = transformed_test_ts.to_pandas() + + # inverse transform + inverse_transformed_test_df = transform.inverse_transform(transformed_test_df.copy()) + + # checking + expected_columns_to_create = expected_changes.get("create", set()) + expected_columns_to_remove = expected_changes.get("remove", set()) + expected_columns_to_change = expected_changes.get("change", set()) + flat_test_df = TSDataset.to_flatten(test_df) + flat_transformed_test_df = TSDataset.to_flatten(transformed_test_df) + flat_inverse_transformed_test_df = TSDataset.to_flatten(inverse_transformed_test_df) + created_columns, removed_columns, changed_columns = find_columns_diff( + flat_transformed_test_df, flat_inverse_transformed_test_df + ) + + assert created_columns == expected_columns_to_create + assert removed_columns == expected_columns_to_remove + assert changed_columns == expected_columns_to_change + pd.testing.assert_frame_equal( + flat_test_df[changed_columns], + flat_inverse_transformed_test_df[changed_columns], + ) + + @pytest.mark.parametrize( + "transform, dataset_name, expected_changes", + [ + # decomposition + ( + ChangePointsSegmentationTransform( + in_column="target", + change_point_model=RupturesChangePointsModel(change_point_model=Binseg(), n_bkps=5), + out_column="res", + ), + "regular_ts", + {}, + ), + ( + ChangePointsTrendTransform( + in_column="target", change_point_model=Binseg(), detrend_model=LinearRegression(), n_bkps=5 + ), + "regular_ts", + {}, + ), + ( + ChangePointsTrendTransform( + in_column="positive", change_point_model=Binseg(), detrend_model=LinearRegression(), n_bkps=5 + ), + "ts_with_exog", + {"change": {"positive"}}, + ), + (BinsegTrendTransform(in_column="target"), "regular_ts", {}), + (BinsegTrendTransform(in_column="positive"), "ts_with_exog", {"change": {"positive"}}), + (LinearTrendTransform(in_column="target"), "regular_ts", {}), + (LinearTrendTransform(in_column="positive"), "ts_with_exog", {"change": {"positive"}}), + (TheilSenTrendTransform(in_column="target"), "regular_ts", {}), + (TheilSenTrendTransform(in_column="positive"), "ts_with_exog", {"change": {"positive"}}), + (STLTransform(in_column="target", period=7), "regular_ts", {}), + (STLTransform(in_column="positive", period=7), "ts_with_exog", {"change": {"positive"}}), + (TrendTransform(in_column="target", out_column="res"), "regular_ts", {}), + # encoders + (LabelEncoderTransform(in_column="weekday", out_column="res"), "ts_with_exog", {}), + ( + OneHotEncoderTransform(in_column="weekday", out_column="res"), + "ts_with_exog", + {}, + ), + (MeanSegmentEncoderTransform(), "regular_ts", {}), + (SegmentEncoderTransform(), "regular_ts", {}), + # feature_selection + (FilterFeaturesTransform(exclude=["year"]), "ts_with_exog", {}), + ( + GaleShapleyFeatureSelectionTransform(relevance_table=StatisticsRelevanceTable(), top_k=2), + "ts_with_exog", + {}, + ), + ( + MRMRFeatureSelectionTransform(relevance_table=StatisticsRelevanceTable(), top_k=2), + "ts_with_exog", + {}, + ), + ( + TreeFeatureSelectionTransform(model=DecisionTreeRegressor(random_state=42), top_k=2), + "ts_with_exog", + {}, + ), + # math + ( + AddConstTransform(in_column="target", value=1, inplace=False, out_column="res"), + "regular_ts", + {}, + ), + (AddConstTransform(in_column="target", value=1, inplace=True), "regular_ts", {}), + (AddConstTransform(in_column="positive", value=1, inplace=True), "ts_with_exog", {"change": {"positive"}}), + ( + LagTransform(in_column="target", lags=[1, 2, 3], out_column="res"), + "regular_ts", + {}, + ), + ( + LambdaTransform(in_column="target", transform_func=lambda x: x + 1, inplace=False, out_column="res"), + "regular_ts", + {}, + ), + ( + LambdaTransform( + in_column="target", + transform_func=lambda x: x + 1, + inverse_transform_func=lambda x: x - 1, + inplace=True, + ), + "regular_ts", + {}, + ), + ( + LambdaTransform( + in_column="positive", + transform_func=lambda x: x + 1, + inverse_transform_func=lambda x: x - 1, + inplace=True, + ), + "ts_with_exog", + {"change": {"positive"}}, + ), + (LogTransform(in_column="target", inplace=False, out_column="res"), "positive_ts", {}), + (LogTransform(in_column="target", inplace=True), "positive_ts", {}), + (LogTransform(in_column="positive", inplace=True), "ts_with_exog", {"change": {"positive"}}), + ( + DifferencingTransform(in_column="target", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + (MADTransform(in_column="target", window=14, out_column="res"), "regular_ts", {}), + (MaxTransform(in_column="target", window=14, out_column="res"), "regular_ts", {}), + (MeanTransform(in_column="target", window=14, out_column="res"), "regular_ts", {}), + (MedianTransform(in_column="target", window=14, out_column="res"), "regular_ts", {}), + ( + MinMaxDifferenceTransform(in_column="target", window=14, out_column="res"), + "regular_ts", + {}, + ), + (MinTransform(in_column="target", window=14, out_column="res"), "regular_ts", {}), + ( + QuantileTransform(in_column="target", quantile=0.9, window=14, out_column="res"), + "regular_ts", + {}, + ), + (StdTransform(in_column="target", window=14, out_column="res"), "regular_ts", {}), + (SumTransform(in_column="target", window=14, out_column="res"), "regular_ts", {}), + ( + BoxCoxTransform(in_column="target", mode="per-segment", inplace=False, out_column="res"), + "positive_ts", + {}, + ), + (BoxCoxTransform(in_column="target", mode="per-segment", inplace=True), "positive_ts", {}), + ( + BoxCoxTransform(in_column="positive", mode="per-segment", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + BoxCoxTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "positive_ts", + {}, + ), + (BoxCoxTransform(in_column="target", mode="macro", inplace=True), "positive_ts", {}), + ( + BoxCoxTransform(in_column="positive", mode="macro", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + MaxAbsScalerTransform(in_column="target", mode="per-segment", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + (MaxAbsScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts", {}), + ( + MaxAbsScalerTransform(in_column="positive", mode="per-segment", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + MaxAbsScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + ( + MaxAbsScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {}, + ), + ( + MaxAbsScalerTransform(in_column="positive", mode="macro", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + MinMaxScalerTransform(in_column="target", mode="per-segment", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + (MinMaxScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts", {}), + ( + # setting clip=False is important + MinMaxScalerTransform(in_column="positive", mode="per-segment", clip=False, inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + MinMaxScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + ( + MinMaxScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {}, + ), + ( + # setting clip=False is important + MinMaxScalerTransform(in_column="positive", mode="macro", clip=False, inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + RobustScalerTransform(in_column="target", mode="per-segment", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + (RobustScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts", {}), + ( + RobustScalerTransform(in_column="positive", mode="per-segment", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + RobustScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + ( + RobustScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {}, + ), + ( + RobustScalerTransform(in_column="positive", mode="macro", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + StandardScalerTransform(in_column="target", mode="per-segment", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + (StandardScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts", {}), + ( + StandardScalerTransform(in_column="positive", mode="per-segment", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + StandardScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + ( + StandardScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {}, + ), + ( + StandardScalerTransform(in_column="positive", mode="macro", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + YeoJohnsonTransform(in_column="target", mode="per-segment", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + (YeoJohnsonTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts", {}), + ( + YeoJohnsonTransform(in_column="positive", mode="per-segment", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + YeoJohnsonTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {}, + ), + (YeoJohnsonTransform(in_column="target", mode="macro", inplace=True), "regular_ts", {}), + ( + YeoJohnsonTransform(in_column="positive", mode="macro", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + # missing_values + ( + ResampleWithDistributionTransform( + in_column="regressor_exog", distribution_column="target", inplace=False, out_column="res" + ), + "ts_to_resample", + {}, + ), + ( + # this behaviour can be unexpected for someone + TimeSeriesImputerTransform(in_column="target"), + "ts_to_fill", + {}, + ), + # outliers + (DensityOutliersTransform(in_column="target"), "ts_with_outliers", {}), + (MedianOutliersTransform(in_column="target"), "ts_with_outliers", {}), + (PredictionIntervalOutliersTransform(in_column="target", model=ProphetModel), "ts_with_outliers", {}), + # timestamp + ( + DateFlagsTransform(out_column="res"), + "regular_ts", + {}, + ), + ( + FourierTransform(period=7, order=2, out_column="res"), + "regular_ts", + {}, + ), + (HolidayTransform(out_column="res"), "regular_ts", {}), + ( + TimeFlagsTransform(out_column="res"), + "regular_ts", + {}, + ), + (SpecialDaysTransform(), "regular_ts", {}), + ], + ) + def test_inverse_transform_future_without_target(self, transform, dataset_name, expected_changes, request): + ts = request.getfixturevalue(dataset_name) + self._test_inverse_transform_future_without_target(ts, transform, expected_changes=expected_changes) + + @pytest.mark.parametrize( + "transform, dataset_name, expected_changes", + [ + (DifferencingTransform(in_column="positive", inplace=True), "ts_with_exog", {"change": {"positive"}}), + (DifferencingTransform(in_column="target", inplace=True), "regular_ts", {}), + ], + ) + def test_inverse_transform_future_without_target_fail_difference( + self, transform, dataset_name, expected_changes, request + ): + ts = request.getfixturevalue(dataset_name) + with pytest.raises(ValueError, match="Test should go after the train without gaps"): + self._test_inverse_transform_future_without_target(ts, transform, expected_changes=expected_changes) + + # It is the only transform that doesn't change values back during `inverse_transform` + @to_be_fixed(AssertionError) + @pytest.mark.parametrize( + "transform, dataset_name, expected_changes", + [ + ( + ResampleWithDistributionTransform( + in_column="regressor_exog", distribution_column="target", inplace=True + ), + "ts_to_resample", + {"change": {"regressor_exog"}}, + ), + ], + ) + def test_inverse_transform_future_without_target_fail_resample( + self, transform, dataset_name, expected_changes, request + ): + ts = request.getfixturevalue(dataset_name) + self._test_inverse_transform_future_without_target(ts, transform, expected_changes=expected_changes) + + @to_be_fixed(raises=Exception) + @pytest.mark.parametrize( + "transform, dataset_name, expected_changes", + [ + # feature_selection + (FilterFeaturesTransform(exclude=["year"], return_features=True), "ts_with_exog", {"create": {"year"}}), + ( + GaleShapleyFeatureSelectionTransform( + relevance_table=StatisticsRelevanceTable(), top_k=2, return_features=True + ), + "ts_with_exog", + {"create": {"month", "year", "weekday"}}, + ), + ( + MRMRFeatureSelectionTransform( + relevance_table=StatisticsRelevanceTable(), top_k=2, return_features=True + ), + "ts_with_exog", + {"create": {"weekday", "monthday", "positive"}}, + ), + ( + TreeFeatureSelectionTransform( + model=DecisionTreeRegressor(random_state=42), top_k=2, return_features=True + ), + "ts_with_exog", + {"create": {"year", "month", "weekday"}}, + ), + ], + ) + def test_inverse_transform_future_without_target_failed_error( + self, transform, dataset_name, expected_changes, request + ): + ts = request.getfixturevalue(dataset_name) + self._test_inverse_transform_future_without_target(ts, transform, expected_changes=expected_changes) diff --git a/tests/test_transforms/test_inference/test_transform.py b/tests/test_transforms/test_inference/test_transform.py new file mode 100644 index 000000000..9ed8ace5f --- /dev/null +++ b/tests/test_transforms/test_inference/test_transform.py @@ -0,0 +1,1644 @@ +from copy import deepcopy + +import pandas as pd +import pytest +from pandas.util.testing import assert_frame_equal +from ruptures import Binseg +from sklearn.linear_model import LinearRegression +from sklearn.tree import DecisionTreeRegressor + +from etna.analysis import StatisticsRelevanceTable +from etna.datasets import TSDataset +from etna.models import ProphetModel +from etna.transforms import AddConstTransform +from etna.transforms import BinsegTrendTransform +from etna.transforms import BoxCoxTransform +from etna.transforms import ChangePointsSegmentationTransform +from etna.transforms import ChangePointsTrendTransform +from etna.transforms import DateFlagsTransform +from etna.transforms import DensityOutliersTransform +from etna.transforms import DifferencingTransform +from etna.transforms import FilterFeaturesTransform +from etna.transforms import FourierTransform +from etna.transforms import GaleShapleyFeatureSelectionTransform +from etna.transforms import HolidayTransform +from etna.transforms import LabelEncoderTransform +from etna.transforms import LagTransform +from etna.transforms import LambdaTransform +from etna.transforms import LinearTrendTransform +from etna.transforms import LogTransform +from etna.transforms import MADTransform +from etna.transforms import MaxAbsScalerTransform +from etna.transforms import MaxTransform +from etna.transforms import MeanSegmentEncoderTransform +from etna.transforms import MeanTransform +from etna.transforms import MedianOutliersTransform +from etna.transforms import MedianTransform +from etna.transforms import MinMaxDifferenceTransform +from etna.transforms import MinMaxScalerTransform +from etna.transforms import MinTransform +from etna.transforms import MRMRFeatureSelectionTransform +from etna.transforms import OneHotEncoderTransform +from etna.transforms import PredictionIntervalOutliersTransform +from etna.transforms import QuantileTransform +from etna.transforms import ResampleWithDistributionTransform +from etna.transforms import RobustScalerTransform +from etna.transforms import SegmentEncoderTransform +from etna.transforms import SpecialDaysTransform +from etna.transforms import StandardScalerTransform +from etna.transforms import StdTransform +from etna.transforms import STLTransform +from etna.transforms import SumTransform +from etna.transforms import TheilSenTrendTransform +from etna.transforms import TimeFlagsTransform +from etna.transforms import TimeSeriesImputerTransform +from etna.transforms import TreeFeatureSelectionTransform +from etna.transforms import TrendTransform +from etna.transforms import YeoJohnsonTransform +from etna.transforms.decomposition import RupturesChangePointsModel +from tests.test_transforms.test_inference.common import find_columns_diff +from tests.utils import select_segments_subset +from tests.utils import to_be_fixed + + +class TestTransformTrainSubsetSegments: + """Test transform on train part of subset of segments. + + Expected that transformation on subset of segments match subset of transformation on full dataset. + """ + + def _test_transform_train_subset_segments(self, ts, transform, segments): + # select subset of tsdataset + segments = list(set(segments)) + subset_ts = select_segments_subset(ts=deepcopy(ts), segments=segments) + df = ts.to_pandas() + subset_df = subset_ts.to_pandas() + + # fitting + transform.fit(df) + + # transform full + transformed_df = transform.transform(df) + + # transform subset of segments + transformed_subset_df = transform.transform(subset_df) + + # checking + assert_frame_equal(transformed_subset_df, transformed_df.loc[:, pd.IndexSlice[segments, :]]) + + @pytest.mark.parametrize( + "transform, dataset_name", + [ + # decomposition + ( + ChangePointsSegmentationTransform( + in_column="target", + change_point_model=RupturesChangePointsModel(change_point_model=Binseg(), n_bkps=5), + ), + "regular_ts", + ), + ( + ChangePointsTrendTransform( + in_column="target", change_point_model=Binseg(), detrend_model=LinearRegression(), n_bkps=5 + ), + "regular_ts", + ), + (BinsegTrendTransform(in_column="target"), "regular_ts"), + (LinearTrendTransform(in_column="target"), "regular_ts"), + (TheilSenTrendTransform(in_column="target"), "regular_ts"), + (STLTransform(in_column="target", period=7), "regular_ts"), + (TrendTransform(in_column="target"), "regular_ts"), + # encoders + (LabelEncoderTransform(in_column="weekday"), "ts_with_exog"), + (OneHotEncoderTransform(in_column="weekday"), "ts_with_exog"), + (MeanSegmentEncoderTransform(), "regular_ts"), + (SegmentEncoderTransform(), "regular_ts"), + # feature_selection + (FilterFeaturesTransform(exclude=["year"]), "ts_with_exog"), + (GaleShapleyFeatureSelectionTransform(relevance_table=StatisticsRelevanceTable(), top_k=2), "ts_with_exog"), + (MRMRFeatureSelectionTransform(relevance_table=StatisticsRelevanceTable(), top_k=2), "ts_with_exog"), + (TreeFeatureSelectionTransform(model=DecisionTreeRegressor(random_state=42), top_k=2), "ts_with_exog"), + # math + (AddConstTransform(in_column="target", value=1, inplace=False), "regular_ts"), + (AddConstTransform(in_column="target", value=1, inplace=True), "regular_ts"), + (LagTransform(in_column="target", lags=[1, 2, 3]), "regular_ts"), + ( + LambdaTransform(in_column="target", transform_func=lambda x: x + 1, inplace=False), + "regular_ts", + ), + ( + LambdaTransform( + in_column="target", + transform_func=lambda x: x + 1, + inverse_transform_func=lambda x: x - 1, + inplace=True, + ), + "regular_ts", + ), + (LogTransform(in_column="target", inplace=False), "positive_ts"), + (LogTransform(in_column="target", inplace=True), "positive_ts"), + (DifferencingTransform(in_column="target", inplace=False), "regular_ts"), + (DifferencingTransform(in_column="target", inplace=True), "regular_ts"), + (MADTransform(in_column="target", window=7), "regular_ts"), + (MaxTransform(in_column="target", window=7), "regular_ts"), + (MeanTransform(in_column="target", window=7), "regular_ts"), + (MedianTransform(in_column="target", window=7), "regular_ts"), + (MinMaxDifferenceTransform(in_column="target", window=7), "regular_ts"), + (MinTransform(in_column="target", window=7), "regular_ts"), + (QuantileTransform(in_column="target", quantile=0.9, window=7), "regular_ts"), + (StdTransform(in_column="target", window=7), "regular_ts"), + (SumTransform(in_column="target", window=7), "regular_ts"), + (BoxCoxTransform(in_column="target", mode="per-segment", inplace=False), "positive_ts"), + (BoxCoxTransform(in_column="target", mode="per-segment", inplace=True), "positive_ts"), + (BoxCoxTransform(in_column="target", mode="macro", inplace=False), "positive_ts"), + (BoxCoxTransform(in_column="target", mode="macro", inplace=True), "positive_ts"), + (MaxAbsScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (MaxAbsScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (MaxAbsScalerTransform(in_column="target", mode="macro", inplace=False), "regular_ts"), + (MaxAbsScalerTransform(in_column="target", mode="macro", inplace=True), "regular_ts"), + (MinMaxScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (MinMaxScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (MinMaxScalerTransform(in_column="target", mode="macro", inplace=False), "regular_ts"), + (MinMaxScalerTransform(in_column="target", mode="macro", inplace=True), "regular_ts"), + (RobustScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (RobustScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (RobustScalerTransform(in_column="target", mode="macro", inplace=False), "regular_ts"), + (RobustScalerTransform(in_column="target", mode="macro", inplace=True), "regular_ts"), + (StandardScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (StandardScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (StandardScalerTransform(in_column="target", mode="macro", inplace=False), "regular_ts"), + (StandardScalerTransform(in_column="target", mode="macro", inplace=True), "regular_ts"), + (YeoJohnsonTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (YeoJohnsonTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (YeoJohnsonTransform(in_column="target", mode="macro", inplace=False), "regular_ts"), + (YeoJohnsonTransform(in_column="target", mode="macro", inplace=True), "regular_ts"), + # missing_values + ( + ResampleWithDistributionTransform( + in_column="regressor_exog", + distribution_column="target", + inplace=False, + ), + "ts_to_resample", + ), + ( + ResampleWithDistributionTransform( + in_column="regressor_exog", distribution_column="target", inplace=True + ), + "ts_to_resample", + ), + (TimeSeriesImputerTransform(in_column="target"), "ts_to_fill"), + # outliers + (DensityOutliersTransform(in_column="target"), "ts_with_outliers"), + (MedianOutliersTransform(in_column="target"), "ts_with_outliers"), + (PredictionIntervalOutliersTransform(in_column="target", model=ProphetModel), "ts_with_outliers"), + # timestamp + (DateFlagsTransform(), "regular_ts"), + (FourierTransform(period=7, order=2), "regular_ts"), + (HolidayTransform(), "regular_ts"), + (SpecialDaysTransform(), "regular_ts"), + (TimeFlagsTransform(), "regular_ts"), + ], + ) + def test_transform_train_subset_segments(self, transform, dataset_name, request): + ts = request.getfixturevalue(dataset_name) + self._test_transform_train_subset_segments(ts, transform, segments=["segment_2"]) + + +class TestTransformFutureSubsetSegments: + """Test transform on future part of subset of segments. + + Expected that transformation on subset of segments match subset of transformation on full dataset. + """ + + def _test_transform_future_subset_segments(self, ts, transform, segments, horizon=7): + # select subset of tsdataset + subset_ts = select_segments_subset(ts=deepcopy(ts), segments=segments) + train_df = ts.to_pandas() + ts.transforms = [transform] + subset_ts.transforms = [transform] + + # fitting + transform.fit(train_df) + + # transform full + transformed_future_ts = ts.make_future(future_steps=horizon) + + # transform subset of segments + transformed_subset_future_ts = subset_ts.make_future(future_steps=horizon) + + # checking + transformed_future_df = transformed_future_ts.to_pandas() + transformed_subset_future_df = transformed_subset_future_ts.to_pandas() + assert_frame_equal(transformed_subset_future_df, transformed_future_df.loc[:, pd.IndexSlice[segments, :]]) + + @pytest.mark.parametrize( + "transform, dataset_name", + [ + # decomposition + ( + ChangePointsSegmentationTransform( + in_column="target", + change_point_model=RupturesChangePointsModel(change_point_model=Binseg(), n_bkps=5), + ), + "regular_ts", + ), + ( + ChangePointsTrendTransform( + in_column="target", change_point_model=Binseg(), detrend_model=LinearRegression(), n_bkps=5 + ), + "regular_ts", + ), + ( + ChangePointsTrendTransform( + in_column="positive", change_point_model=Binseg(), detrend_model=LinearRegression(), n_bkps=5 + ), + "ts_with_exog", + ), + (BinsegTrendTransform(in_column="target"), "regular_ts"), + (BinsegTrendTransform(in_column="positive"), "ts_with_exog"), + (LinearTrendTransform(in_column="target"), "regular_ts"), + (LinearTrendTransform(in_column="positive"), "ts_with_exog"), + (TheilSenTrendTransform(in_column="target"), "regular_ts"), + (TheilSenTrendTransform(in_column="positive"), "ts_with_exog"), + (STLTransform(in_column="target", period=7), "regular_ts"), + (STLTransform(in_column="positive", period=7), "ts_with_exog"), + (TrendTransform(in_column="target"), "regular_ts"), + # encoders + (LabelEncoderTransform(in_column="weekday"), "ts_with_exog"), + (OneHotEncoderTransform(in_column="weekday"), "ts_with_exog"), + (MeanSegmentEncoderTransform(), "regular_ts"), + (SegmentEncoderTransform(), "regular_ts"), + # feature_selection + (FilterFeaturesTransform(exclude=["year"]), "ts_with_exog"), + (GaleShapleyFeatureSelectionTransform(relevance_table=StatisticsRelevanceTable(), top_k=2), "ts_with_exog"), + (MRMRFeatureSelectionTransform(relevance_table=StatisticsRelevanceTable(), top_k=2), "ts_with_exog"), + (TreeFeatureSelectionTransform(model=DecisionTreeRegressor(random_state=42), top_k=2), "ts_with_exog"), + # math + (AddConstTransform(in_column="target", value=1, inplace=False), "regular_ts"), + (AddConstTransform(in_column="target", value=1, inplace=True), "regular_ts"), + (AddConstTransform(in_column="positive", value=1, inplace=True), "ts_with_exog"), + (LagTransform(in_column="target", lags=[1, 2, 3]), "regular_ts"), + ( + LambdaTransform(in_column="target", transform_func=lambda x: x + 1, inplace=False), + "regular_ts", + ), + ( + LambdaTransform( + in_column="target", + transform_func=lambda x: x + 1, + inverse_transform_func=lambda x: x - 1, + inplace=True, + ), + "regular_ts", + ), + ( + LambdaTransform( + in_column="positive", + transform_func=lambda x: x + 1, + inverse_transform_func=lambda x: x - 1, + inplace=True, + ), + "ts_with_exog", + ), + (LogTransform(in_column="target", inplace=False), "positive_ts"), + (LogTransform(in_column="target", inplace=True), "positive_ts"), + (LogTransform(in_column="positive", inplace=True), "ts_with_exog"), + (DifferencingTransform(in_column="target", inplace=False), "regular_ts"), + (DifferencingTransform(in_column="target", inplace=True), "regular_ts"), + (DifferencingTransform(in_column="positive", inplace=True), "ts_with_exog"), + (MADTransform(in_column="target", window=14), "regular_ts"), + (MaxTransform(in_column="target", window=14), "regular_ts"), + (MeanTransform(in_column="target", window=14), "regular_ts"), + (MedianTransform(in_column="target", window=14), "regular_ts"), + (MinMaxDifferenceTransform(in_column="target", window=14), "regular_ts"), + (MinTransform(in_column="target", window=14), "regular_ts"), + (QuantileTransform(in_column="target", quantile=0.9, window=14), "regular_ts"), + (StdTransform(in_column="target", window=14), "regular_ts"), + (SumTransform(in_column="target", window=14), "regular_ts"), + (BoxCoxTransform(in_column="target", mode="per-segment", inplace=False), "positive_ts"), + (BoxCoxTransform(in_column="target", mode="per-segment", inplace=True), "positive_ts"), + (BoxCoxTransform(in_column="positive", mode="per-segment", inplace=True), "ts_with_exog"), + (BoxCoxTransform(in_column="target", mode="macro", inplace=False), "positive_ts"), + (BoxCoxTransform(in_column="target", mode="macro", inplace=True), "positive_ts"), + (BoxCoxTransform(in_column="positive", mode="macro", inplace=True), "ts_with_exog"), + (MaxAbsScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (MaxAbsScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (MaxAbsScalerTransform(in_column="positive", mode="per-segment", inplace=True), "ts_with_exog"), + (MaxAbsScalerTransform(in_column="target", mode="macro", inplace=False), "regular_ts"), + (MaxAbsScalerTransform(in_column="target", mode="macro", inplace=True), "regular_ts"), + (MaxAbsScalerTransform(in_column="positive", mode="macro", inplace=True), "ts_with_exog"), + (MinMaxScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (MinMaxScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (MinMaxScalerTransform(in_column="positive", mode="per-segment", inplace=True), "ts_with_exog"), + (MinMaxScalerTransform(in_column="target", mode="macro", inplace=False), "regular_ts"), + (MinMaxScalerTransform(in_column="target", mode="macro", inplace=True), "regular_ts"), + (MinMaxScalerTransform(in_column="positive", mode="macro", inplace=True), "ts_with_exog"), + (RobustScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (RobustScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (RobustScalerTransform(in_column="positive", mode="per-segment", inplace=True), "ts_with_exog"), + (RobustScalerTransform(in_column="target", mode="macro", inplace=False), "regular_ts"), + (RobustScalerTransform(in_column="target", mode="macro", inplace=True), "regular_ts"), + (RobustScalerTransform(in_column="positive", mode="macro", inplace=True), "ts_with_exog"), + (StandardScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (StandardScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (StandardScalerTransform(in_column="positive", mode="per-segment", inplace=True), "ts_with_exog"), + (StandardScalerTransform(in_column="target", mode="macro", inplace=False), "regular_ts"), + (StandardScalerTransform(in_column="target", mode="macro", inplace=True), "regular_ts"), + (StandardScalerTransform(in_column="positive", mode="macro", inplace=True), "ts_with_exog"), + (YeoJohnsonTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (YeoJohnsonTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (YeoJohnsonTransform(in_column="positive", mode="per-segment", inplace=True), "ts_with_exog"), + (YeoJohnsonTransform(in_column="target", mode="macro", inplace=False), "regular_ts"), + (YeoJohnsonTransform(in_column="target", mode="macro", inplace=True), "regular_ts"), + (YeoJohnsonTransform(in_column="positive", mode="macro", inplace=True), "ts_with_exog"), + # missing_values + ( + ResampleWithDistributionTransform( + in_column="regressor_exog", + distribution_column="target", + inplace=False, + ), + "ts_to_resample", + ), + ( + ResampleWithDistributionTransform( + in_column="regressor_exog", distribution_column="target", inplace=True + ), + "ts_to_resample", + ), + (TimeSeriesImputerTransform(in_column="target"), "ts_to_fill"), + # outliers + (DensityOutliersTransform(in_column="target"), "ts_with_outliers"), + (MedianOutliersTransform(in_column="target"), "ts_with_outliers"), + (PredictionIntervalOutliersTransform(in_column="target", model=ProphetModel), "ts_with_outliers"), + # timestamp + (DateFlagsTransform(), "regular_ts"), + (FourierTransform(period=7, order=2), "regular_ts"), + (HolidayTransform(), "regular_ts"), + (SpecialDaysTransform(), "regular_ts"), + (TimeFlagsTransform(), "regular_ts"), + ], + ) + def test_transform_future_subset_segments(self, transform, dataset_name, request): + ts = request.getfixturevalue(dataset_name) + self._test_transform_future_subset_segments(ts, transform, segments=["segment_2"]) + + +class TestTransformTrainNewSegments: + """Test transform on train part of new segments. + + Expected that transformation creates columns, removes columns and changes values. + """ + + def _test_transform_train_new_segments(self, ts, transform, train_segments, expected_changes): + # select subset of tsdataset + train_segments = list(set(train_segments)) + forecast_segments = list(set(ts.segments) - set(train_segments)) + train_ts = select_segments_subset(ts=deepcopy(ts), segments=train_segments) + test_ts = select_segments_subset(ts=deepcopy(ts), segments=forecast_segments) + train_df = train_ts.to_pandas() + test_df = test_ts.to_pandas() + + # fitting + transform.fit(train_df) + + # transform + transformed_test_df = transform.transform(test_df.copy()) + + # checking + expected_columns_to_create = expected_changes.get("create", set()) + expected_columns_to_remove = expected_changes.get("remove", set()) + expected_columns_to_change = expected_changes.get("change", set()) + flat_test_df = TSDataset.to_flatten(test_df) + flat_transformed_test_df = TSDataset.to_flatten(transformed_test_df) + created_columns, removed_columns, changed_columns = find_columns_diff(flat_test_df, flat_transformed_test_df) + + assert created_columns == expected_columns_to_create + assert removed_columns == expected_columns_to_remove + assert changed_columns == expected_columns_to_change + + @pytest.mark.parametrize( + "transform, dataset_name, expected_changes", + [ + # encoders + (LabelEncoderTransform(in_column="weekday", out_column="res"), "ts_with_exog", {"create": {"res"}}), + ( + OneHotEncoderTransform(in_column="weekday", out_column="res"), + "ts_with_exog", + {"create": {"res_0", "res_1", "res_2", "res_3", "res_4", "res_5", "res_6"}}, + ), + # feature_selection + (FilterFeaturesTransform(exclude=["year"]), "ts_with_exog", {"remove": {"year"}}), + ( + GaleShapleyFeatureSelectionTransform(relevance_table=StatisticsRelevanceTable(), top_k=2), + "ts_with_exog", + {"remove": {"weekday", "year", "month"}}, + ), + ( + MRMRFeatureSelectionTransform(relevance_table=StatisticsRelevanceTable(), top_k=2), + "ts_with_exog", + {"remove": {"weekday", "monthday", "positive"}}, + ), + ( + TreeFeatureSelectionTransform(model=DecisionTreeRegressor(random_state=42), top_k=2), + "ts_with_exog", + {"remove": {"year", "month", "weekday"}}, + ), + # math + ( + AddConstTransform(in_column="target", value=1, inplace=False, out_column="res"), + "regular_ts", + {"create": {"res"}}, + ), + (AddConstTransform(in_column="target", value=1, inplace=True), "regular_ts", {"change": {"target"}}), + ( + LagTransform(in_column="target", lags=[1, 2, 3], out_column="res"), + "regular_ts", + {"create": {"res_1", "res_2", "res_3"}}, + ), + ( + LambdaTransform(in_column="target", transform_func=lambda x: x + 1, inplace=False, out_column="res"), + "regular_ts", + {"create": {"res"}}, + ), + ( + LambdaTransform( + in_column="target", + transform_func=lambda x: x + 1, + inverse_transform_func=lambda x: x - 1, + inplace=True, + ), + "regular_ts", + {"change": {"target"}}, + ), + (LogTransform(in_column="target", inplace=False, out_column="res"), "positive_ts", {"create": {"res"}}), + (LogTransform(in_column="target", inplace=True), "positive_ts", {"change": {"target"}}), + ( + DifferencingTransform(in_column="target", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res"}}, + ), + (MADTransform(in_column="target", window=7, out_column="res"), "regular_ts", {"create": {"res"}}), + (MaxTransform(in_column="target", window=7, out_column="res"), "regular_ts", {"create": {"res"}}), + (MeanTransform(in_column="target", window=7, out_column="res"), "regular_ts", {"create": {"res"}}), + (MedianTransform(in_column="target", window=7, out_column="res"), "regular_ts", {"create": {"res"}}), + ( + MinMaxDifferenceTransform(in_column="target", window=7, out_column="res"), + "regular_ts", + {"create": {"res"}}, + ), + (MinTransform(in_column="target", window=7, out_column="res"), "regular_ts", {"create": {"res"}}), + ( + QuantileTransform(in_column="target", quantile=0.9, window=7, out_column="res"), + "regular_ts", + {"create": {"res"}}, + ), + (StdTransform(in_column="target", window=7, out_column="res"), "regular_ts", {"create": {"res"}}), + (SumTransform(in_column="target", window=7, out_column="res"), "regular_ts", {"create": {"res"}}), + ( + BoxCoxTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "positive_ts", + {"create": {"res_target"}}, + ), + (BoxCoxTransform(in_column="target", mode="macro", inplace=True), "positive_ts", {"change": {"target"}}), + ( + MaxAbsScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + ( + MaxAbsScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + MinMaxScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + ( + MinMaxScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + RobustScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + ( + RobustScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + StandardScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + ( + StandardScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + YeoJohnsonTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + (YeoJohnsonTransform(in_column="target", mode="macro", inplace=True), "regular_ts", {"change": {"target"}}), + # timestamp + ( + DateFlagsTransform(out_column="res"), + "regular_ts", + {"create": {"res_day_number_in_week", "res_day_number_in_month", "res_is_weekend"}}, + ), + ( + FourierTransform(period=7, order=2, out_column="res"), + "regular_ts", + {"create": {"res_1", "res_2", "res_3", "res_4"}}, + ), + (HolidayTransform(out_column="res"), "regular_ts", {"create": {"res"}}), + ( + TimeFlagsTransform(out_column="res"), + "regular_ts", + {"create": {"res_minute_in_hour_number", "res_hour_number"}}, + ), + ], + ) + def test_transform_train_new_segments(self, transform, dataset_name, expected_changes, request): + ts = request.getfixturevalue(dataset_name) + self._test_transform_train_new_segments( + ts, transform, train_segments=["segment_1", "segment_2"], expected_changes=expected_changes + ) + + @pytest.mark.parametrize( + "transform, dataset_name", + [ + # decomposition + ( + ChangePointsSegmentationTransform( + in_column="target", + change_point_model=RupturesChangePointsModel(change_point_model=Binseg(), n_bkps=5), + ), + "regular_ts", + ), + ( + ChangePointsTrendTransform( + in_column="target", change_point_model=Binseg(), detrend_model=LinearRegression(), n_bkps=5 + ), + "regular_ts", + ), + (BinsegTrendTransform(in_column="target"), "regular_ts"), + (LinearTrendTransform(in_column="target"), "regular_ts"), + (TheilSenTrendTransform(in_column="target"), "regular_ts"), + (STLTransform(in_column="target", period=7), "regular_ts"), + (TrendTransform(in_column="target"), "regular_ts"), + # encoders + (MeanSegmentEncoderTransform(), "regular_ts"), + (SegmentEncoderTransform(), "regular_ts"), + # math + (DifferencingTransform(in_column="target", inplace=True), "regular_ts"), + (BoxCoxTransform(in_column="target", mode="per-segment", inplace=False), "positive_ts"), + (BoxCoxTransform(in_column="target", mode="per-segment", inplace=True), "positive_ts"), + (MaxAbsScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (MaxAbsScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (MinMaxScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (MinMaxScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (RobustScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (RobustScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (StandardScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (StandardScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (YeoJohnsonTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (YeoJohnsonTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + # missing_values + ( + ResampleWithDistributionTransform( + in_column="regressor_exog", distribution_column="target", inplace=False + ), + "ts_to_resample", + ), + ( + ResampleWithDistributionTransform( + in_column="regressor_exog", distribution_column="target", inplace=True + ), + "ts_to_resample", + ), + ( + TimeSeriesImputerTransform(in_column="target"), + "ts_to_fill", + ), + # outliers + (DensityOutliersTransform(in_column="target"), "ts_with_outliers"), + (MedianOutliersTransform(in_column="target"), "ts_with_outliers"), + (PredictionIntervalOutliersTransform(in_column="target", model=ProphetModel), "ts_with_outliers"), + ], + ) + def test_transform_train_new_segments_not_implemented(self, transform, dataset_name, request): + ts = request.getfixturevalue(dataset_name) + with pytest.raises(NotImplementedError): + self._test_transform_train_new_segments( + ts, transform, train_segments=["segment_1", "segment_2"], expected_changes={} + ) + + @to_be_fixed(raises=NotImplementedError, match="Per-segment transforms can't work on new segments") + @pytest.mark.parametrize( + "transform, dataset_name", + [ + # timestamp + (SpecialDaysTransform(), "regular_ts"), + ], + ) + def test_transform_train_new_segments_failed_not_implemented(self, transform, dataset_name, request): + ts = request.getfixturevalue(dataset_name) + self._test_transform_train_new_segments( + ts, transform, train_segments=["segment_1", "segment_2"], expected_changes={} + ) + + +class TestTransformFutureNewSegments: + """Test transform on future part of new segments. + + Expected that transformation creates columns, removes columns and changes values. + """ + + def _test_transform_future_new_segments(self, ts, transform, train_segments, expected_changes, horizon=7): + # select subset of tsdataset + train_segments = list(set(train_segments)) + forecast_segments = list(set(ts.segments) - set(train_segments)) + train_ts = select_segments_subset(ts=deepcopy(ts), segments=train_segments) + test_ts_without_transform = select_segments_subset(ts=deepcopy(ts), segments=forecast_segments) + test_ts_with_transform = select_segments_subset(ts=deepcopy(ts), segments=forecast_segments) + test_ts_without_transform.transforms = [] + test_ts_with_transform.transforms = [transform] + train_df = train_ts.to_pandas() + + # fitting + transform.fit(train_df) + + # prepare df without transform + test_ts = test_ts_without_transform.make_future(future_steps=horizon) + test_df = test_ts.to_pandas() + + # transform + transformed_test_ts = test_ts_with_transform.make_future(future_steps=horizon) + transformed_test_df = transformed_test_ts.to_pandas() + + # checking + expected_columns_to_create = expected_changes.get("create", set()) + expected_columns_to_remove = expected_changes.get("remove", set()) + expected_columns_to_change = expected_changes.get("change", set()) + flat_test_df = TSDataset.to_flatten(test_df) + flat_transformed_test_df = TSDataset.to_flatten(transformed_test_df) + created_columns, removed_columns, changed_columns = find_columns_diff(flat_test_df, flat_transformed_test_df) + + assert created_columns == expected_columns_to_create + assert removed_columns == expected_columns_to_remove + assert changed_columns == expected_columns_to_change + + @pytest.mark.parametrize( + "transform, dataset_name, expected_changes", + [ + # encoders + (LabelEncoderTransform(in_column="weekday", out_column="res"), "ts_with_exog", {"create": {"res"}}), + ( + OneHotEncoderTransform(in_column="weekday", out_column="res"), + "ts_with_exog", + {"create": {"res_0", "res_1", "res_2", "res_3", "res_4", "res_5", "res_6"}}, + ), + # feature_selection + (FilterFeaturesTransform(exclude=["year"]), "ts_with_exog", {"remove": {"year"}}), + ( + GaleShapleyFeatureSelectionTransform(relevance_table=StatisticsRelevanceTable(), top_k=2), + "ts_with_exog", + {"remove": {"weekday", "year", "month"}}, + ), + ( + MRMRFeatureSelectionTransform(relevance_table=StatisticsRelevanceTable(), top_k=2), + "ts_with_exog", + {"remove": {"weekday", "monthday", "positive"}}, + ), + ( + TreeFeatureSelectionTransform(model=DecisionTreeRegressor(random_state=42), top_k=2), + "ts_with_exog", + {"remove": {"year", "month", "weekday"}}, + ), + # math + ( + AddConstTransform(in_column="target", value=1, inplace=False, out_column="res"), + "regular_ts", + {"create": {"res"}}, + ), + (AddConstTransform(in_column="target", value=1, inplace=True), "regular_ts", {}), + (AddConstTransform(in_column="positive", value=1, inplace=True), "ts_with_exog", {"change": {"positive"}}), + ( + LagTransform(in_column="target", lags=[1, 2, 3], out_column="res"), + "regular_ts", + {"create": {"res_1", "res_2", "res_3"}}, + ), + ( + LambdaTransform(in_column="target", transform_func=lambda x: x + 1, inplace=False, out_column="res"), + "regular_ts", + {"create": {"res"}}, + ), + ( + LambdaTransform( + in_column="target", + transform_func=lambda x: x + 1, + inverse_transform_func=lambda x: x - 1, + inplace=True, + ), + "regular_ts", + {}, + ), + ( + LambdaTransform( + in_column="positive", + transform_func=lambda x: x + 1, + inverse_transform_func=lambda x: x - 1, + inplace=True, + ), + "ts_with_exog", + {"change": {"positive"}}, + ), + (LogTransform(in_column="target", inplace=False, out_column="res"), "positive_ts", {"create": {"res"}}), + (LogTransform(in_column="target", inplace=True), "positive_ts", {}), + (LogTransform(in_column="positive", inplace=True), "ts_with_exog", {"change": {"positive"}}), + ( + DifferencingTransform(in_column="target", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res"}}, + ), + (MADTransform(in_column="target", window=14, out_column="res"), "regular_ts", {"create": {"res"}}), + (MaxTransform(in_column="target", window=14, out_column="res"), "regular_ts", {"create": {"res"}}), + (MeanTransform(in_column="target", window=14, out_column="res"), "regular_ts", {"create": {"res"}}), + (MedianTransform(in_column="target", window=14, out_column="res"), "regular_ts", {"create": {"res"}}), + ( + MinMaxDifferenceTransform(in_column="target", window=14, out_column="res"), + "regular_ts", + {"create": {"res"}}, + ), + (MinTransform(in_column="target", window=14, out_column="res"), "regular_ts", {"create": {"res"}}), + ( + QuantileTransform(in_column="target", quantile=0.9, window=14, out_column="res"), + "regular_ts", + {"create": {"res"}}, + ), + (StdTransform(in_column="target", window=14, out_column="res"), "regular_ts", {"create": {"res"}}), + (SumTransform(in_column="target", window=14, out_column="res"), "regular_ts", {"create": {"res"}}), + ( + BoxCoxTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "positive_ts", + {"create": {"res_target"}}, + ), + (BoxCoxTransform(in_column="target", mode="macro", inplace=True), "positive_ts", {}), + ( + BoxCoxTransform(in_column="positive", mode="macro", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + MaxAbsScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + ( + MaxAbsScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {}, + ), + ( + MaxAbsScalerTransform(in_column="positive", mode="macro", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + MinMaxScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + ( + MinMaxScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {}, + ), + ( + MinMaxScalerTransform(in_column="positive", mode="macro", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + RobustScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + ( + RobustScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {}, + ), + ( + RobustScalerTransform(in_column="positive", mode="macro", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + StandardScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + ( + StandardScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {}, + ), + ( + StandardScalerTransform(in_column="positive", mode="macro", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + YeoJohnsonTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + (YeoJohnsonTransform(in_column="target", mode="macro", inplace=True), "regular_ts", {}), + ( + YeoJohnsonTransform(in_column="positive", mode="macro", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + # timestamp + ( + DateFlagsTransform(out_column="res"), + "regular_ts", + {"create": {"res_day_number_in_week", "res_day_number_in_month", "res_is_weekend"}}, + ), + ( + FourierTransform(period=7, order=2, out_column="res"), + "regular_ts", + {"create": {"res_1", "res_2", "res_3", "res_4"}}, + ), + (HolidayTransform(out_column="res"), "regular_ts", {"create": {"res"}}), + ( + TimeFlagsTransform(out_column="res"), + "regular_ts", + {"create": {"res_minute_in_hour_number", "res_hour_number"}}, + ), + ], + ) + def test_transform_future_new_segments(self, transform, dataset_name, expected_changes, request): + ts = request.getfixturevalue(dataset_name) + self._test_transform_future_new_segments( + ts, transform, train_segments=["segment_1", "segment_2"], expected_changes=expected_changes + ) + + @pytest.mark.parametrize( + "transform, dataset_name", + [ + # decomposition + ( + ChangePointsSegmentationTransform( + in_column="target", + change_point_model=RupturesChangePointsModel(change_point_model=Binseg(), n_bkps=5), + ), + "regular_ts", + ), + ( + ChangePointsTrendTransform( + in_column="target", change_point_model=Binseg(), detrend_model=LinearRegression(), n_bkps=5 + ), + "regular_ts", + ), + (BinsegTrendTransform(in_column="target"), "regular_ts"), + (LinearTrendTransform(in_column="target"), "regular_ts"), + (TheilSenTrendTransform(in_column="target"), "regular_ts"), + (STLTransform(in_column="target", period=7), "regular_ts"), + (TrendTransform(in_column="target"), "regular_ts"), + # encoders + (MeanSegmentEncoderTransform(), "regular_ts"), + (SegmentEncoderTransform(), "regular_ts"), + # math + (DifferencingTransform(in_column="target", inplace=True), "regular_ts"), + (DifferencingTransform(in_column="positive", inplace=True), "ts_with_exog"), + (BoxCoxTransform(in_column="target", mode="per-segment", inplace=False), "positive_ts"), + (BoxCoxTransform(in_column="target", mode="per-segment", inplace=True), "positive_ts"), + (BoxCoxTransform(in_column="positive", mode="per-segment", inplace=True), "ts_with_exog"), + (MaxAbsScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (MaxAbsScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (MaxAbsScalerTransform(in_column="positive", mode="per-segment", inplace=True), "ts_with_exog"), + (MinMaxScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (MinMaxScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (MinMaxScalerTransform(in_column="positive", mode="per-segment", inplace=True), "ts_with_exog"), + (RobustScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (RobustScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (RobustScalerTransform(in_column="positive", mode="per-segment", inplace=True), "ts_with_exog"), + (StandardScalerTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (StandardScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (StandardScalerTransform(in_column="positive", mode="per-segment", inplace=True), "ts_with_exog"), + (YeoJohnsonTransform(in_column="target", mode="per-segment", inplace=False), "regular_ts"), + (YeoJohnsonTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts"), + (YeoJohnsonTransform(in_column="positive", mode="per-segment", inplace=True), "ts_with_exog"), + # missing_values + ( + ResampleWithDistributionTransform( + in_column="regressor_exog", distribution_column="target", inplace=False + ), + "ts_to_resample", + ), + ( + ResampleWithDistributionTransform( + in_column="regressor_exog", distribution_column="target", inplace=True + ), + "ts_to_resample", + ), + ( + TimeSeriesImputerTransform(in_column="target"), + "ts_to_fill", + ), + # outliers + (DensityOutliersTransform(in_column="target"), "ts_with_outliers"), + (MedianOutliersTransform(in_column="target"), "ts_with_outliers"), + (PredictionIntervalOutliersTransform(in_column="target", model=ProphetModel), "ts_with_outliers"), + ], + ) + def test_transform_future_new_segments_not_implemented(self, transform, dataset_name, request): + ts = request.getfixturevalue(dataset_name) + with pytest.raises(NotImplementedError): + self._test_transform_future_new_segments( + ts, transform, train_segments=["segment_1", "segment_2"], expected_changes={} + ) + + @to_be_fixed(raises=NotImplementedError, match="Per-segment transforms can't work on new segments") + @pytest.mark.parametrize( + "transform, dataset_name", + [ + # timestamp + (SpecialDaysTransform(), "regular_ts"), + ], + ) + def test_transform_future_new_segments_failed_not_implemented(self, transform, dataset_name, request): + ts = request.getfixturevalue(dataset_name) + self._test_transform_future_new_segments( + ts, transform, train_segments=["segment_1", "segment_2"], expected_changes={} + ) + + +class TestTransformFutureWithTarget: + """Test transform on future dataset with known target. + + Expected that transformation creates columns, removes columns and changes values. + """ + + def _test_transform_future_with_target(self, ts, transform, expected_changes, gap_size=7, transform_size=50): + # select subset of tsdataset + history_ts, future_full_ts = ts.train_test_split(test_size=gap_size + transform_size) + _, test_ts = future_full_ts.train_test_split(test_size=transform_size) + train_df = history_ts.to_pandas() + test_df = test_ts.to_pandas() + + # fitting + transform.fit(train_df) + + # transform + transformed_test_df = transform.transform(test_df.copy()) + + # checking + expected_columns_to_create = expected_changes.get("create", set()) + expected_columns_to_remove = expected_changes.get("remove", set()) + expected_columns_to_change = expected_changes.get("change", set()) + flat_test_df = TSDataset.to_flatten(test_df) + flat_transformed_test_df = TSDataset.to_flatten(transformed_test_df) + created_columns, removed_columns, changed_columns = find_columns_diff(flat_test_df, flat_transformed_test_df) + + assert created_columns == expected_columns_to_create + assert removed_columns == expected_columns_to_remove + assert changed_columns == expected_columns_to_change + + @pytest.mark.parametrize( + "transform, dataset_name, expected_changes", + [ + # decomposition + ( + ChangePointsSegmentationTransform( + in_column="target", + change_point_model=RupturesChangePointsModel(change_point_model=Binseg(), n_bkps=5), + out_column="res", + ), + "regular_ts", + {"create": {"res"}}, + ), + ( + ChangePointsTrendTransform( + in_column="target", change_point_model=Binseg(), detrend_model=LinearRegression(), n_bkps=5 + ), + "regular_ts", + {"change": {"target"}}, + ), + (BinsegTrendTransform(in_column="target"), "regular_ts", {"change": {"target"}}), + (LinearTrendTransform(in_column="target"), "regular_ts", {"change": {"target"}}), + (TheilSenTrendTransform(in_column="target"), "regular_ts", {"change": {"target"}}), + (STLTransform(in_column="target", period=7), "regular_ts", {"change": {"target"}}), + (TrendTransform(in_column="target", out_column="res"), "regular_ts", {"create": {"res"}}), + # encoders + (LabelEncoderTransform(in_column="weekday", out_column="res"), "ts_with_exog", {"create": {"res"}}), + ( + OneHotEncoderTransform(in_column="weekday", out_column="res"), + "ts_with_exog", + {"create": {"res_0", "res_1", "res_2", "res_3", "res_4", "res_5", "res_6"}}, + ), + (MeanSegmentEncoderTransform(), "regular_ts", {"create": {"segment_mean"}}), + (SegmentEncoderTransform(), "regular_ts", {"create": {"segment_code"}}), + # feature_selection + (FilterFeaturesTransform(exclude=["year"]), "ts_with_exog", {"remove": {"year"}}), + ( + GaleShapleyFeatureSelectionTransform(relevance_table=StatisticsRelevanceTable(), top_k=2), + "ts_with_exog", + {"remove": {"month", "year", "positive"}}, + ), + ( + MRMRFeatureSelectionTransform(relevance_table=StatisticsRelevanceTable(), top_k=2), + "ts_with_exog", + {"remove": {"weekday", "monthday", "positive"}}, + ), + ( + TreeFeatureSelectionTransform(model=DecisionTreeRegressor(random_state=42), top_k=2), + "ts_with_exog", + {"remove": {"year", "month", "weekday"}}, + ), + # math + ( + AddConstTransform(in_column="target", value=1, inplace=False, out_column="res"), + "regular_ts", + {"create": {"res"}}, + ), + (AddConstTransform(in_column="target", value=1, inplace=True), "regular_ts", {"change": {"target"}}), + ( + LagTransform(in_column="target", lags=[1, 2, 3], out_column="res"), + "regular_ts", + {"create": {"res_1", "res_2", "res_3"}}, + ), + ( + LambdaTransform(in_column="target", transform_func=lambda x: x + 1, inplace=False, out_column="res"), + "regular_ts", + {"create": {"res"}}, + ), + ( + LambdaTransform( + in_column="target", + transform_func=lambda x: x + 1, + inverse_transform_func=lambda x: x - 1, + inplace=True, + ), + "regular_ts", + {"change": {"target"}}, + ), + (LogTransform(in_column="target", inplace=False, out_column="res"), "positive_ts", {"create": {"res"}}), + (LogTransform(in_column="target", inplace=True), "positive_ts", {"change": {"target"}}), + ( + DifferencingTransform(in_column="target", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res"}}, + ), + (DifferencingTransform(in_column="target", inplace=True), "regular_ts", {"change": {"target"}}), + (MADTransform(in_column="target", window=7, out_column="res"), "regular_ts", {"create": {"res"}}), + (MaxTransform(in_column="target", window=7, out_column="res"), "regular_ts", {"create": {"res"}}), + (MeanTransform(in_column="target", window=7, out_column="res"), "regular_ts", {"create": {"res"}}), + (MedianTransform(in_column="target", window=7, out_column="res"), "regular_ts", {"create": {"res"}}), + ( + MinMaxDifferenceTransform(in_column="target", window=7, out_column="res"), + "regular_ts", + {"create": {"res"}}, + ), + (MinTransform(in_column="target", window=7, out_column="res"), "regular_ts", {"create": {"res"}}), + ( + QuantileTransform(in_column="target", quantile=0.9, window=7, out_column="res"), + "regular_ts", + {"create": {"res"}}, + ), + (StdTransform(in_column="target", window=7, out_column="res"), "regular_ts", {"create": {"res"}}), + (SumTransform(in_column="target", window=7, out_column="res"), "regular_ts", {"create": {"res"}}), + ( + BoxCoxTransform(in_column="target", mode="per-segment", inplace=False, out_column="res"), + "positive_ts", + {"create": {"res_target"}}, + ), + ( + BoxCoxTransform(in_column="target", mode="per-segment", inplace=True), + "positive_ts", + {"change": {"target"}}, + ), + ( + BoxCoxTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "positive_ts", + {"create": {"res_target"}}, + ), + (BoxCoxTransform(in_column="target", mode="macro", inplace=True), "positive_ts", {"change": {"target"}}), + ( + MaxAbsScalerTransform(in_column="target", mode="per-segment", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + ( + MaxAbsScalerTransform(in_column="target", mode="per-segment", inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + MaxAbsScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + ( + MaxAbsScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + MinMaxScalerTransform(in_column="target", mode="per-segment", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + ( + MinMaxScalerTransform(in_column="target", mode="per-segment", inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + MinMaxScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + ( + MinMaxScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + RobustScalerTransform(in_column="target", mode="per-segment", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + ( + RobustScalerTransform(in_column="target", mode="per-segment", inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + RobustScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + ( + RobustScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + StandardScalerTransform(in_column="target", mode="per-segment", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + ( + StandardScalerTransform(in_column="target", mode="per-segment", inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + StandardScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + ( + StandardScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + YeoJohnsonTransform(in_column="target", mode="per-segment", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + ( + YeoJohnsonTransform(in_column="target", mode="per-segment", inplace=True), + "regular_ts", + {"change": {"target"}}, + ), + ( + YeoJohnsonTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + (YeoJohnsonTransform(in_column="target", mode="macro", inplace=True), "regular_ts", {"change": {"target"}}), + # missing_values + ( + ResampleWithDistributionTransform( + in_column="regressor_exog", distribution_column="target", inplace=False, out_column="res" + ), + "ts_to_resample", + {"create": {"res"}}, + ), + ( + ResampleWithDistributionTransform( + in_column="regressor_exog", distribution_column="target", inplace=True + ), + "ts_to_resample", + {"change": {"regressor_exog"}}, + ), + ( + # this behaviour can be unexpected for someone + TimeSeriesImputerTransform(in_column="target"), + "ts_to_fill", + {}, + ), + # outliers + (DensityOutliersTransform(in_column="target"), "ts_with_outliers", {}), + (MedianOutliersTransform(in_column="target"), "ts_with_outliers", {}), + (PredictionIntervalOutliersTransform(in_column="target", model=ProphetModel), "ts_with_outliers", {}), + # timestamp + ( + DateFlagsTransform(out_column="res"), + "regular_ts", + {"create": {"res_day_number_in_week", "res_day_number_in_month", "res_is_weekend"}}, + ), + ( + FourierTransform(period=7, order=2, out_column="res"), + "regular_ts", + {"create": {"res_1", "res_2", "res_3", "res_4"}}, + ), + (HolidayTransform(out_column="res"), "regular_ts", {"create": {"res"}}), + ( + TimeFlagsTransform(out_column="res"), + "regular_ts", + {"create": {"res_minute_in_hour_number", "res_hour_number"}}, + ), + (SpecialDaysTransform(), "regular_ts", {"create": {"anomaly_weekdays", "anomaly_monthdays"}}), + ], + ) + def test_transform_future_with_target(self, transform, dataset_name, expected_changes, request): + ts = request.getfixturevalue(dataset_name) + self._test_transform_future_with_target(ts, transform, expected_changes=expected_changes) + + +class TestTransformFutureWithoutTarget: + """Test transform on future dataset with unknown target. + + Expected that transformation creates columns, removes columns and changes values. + """ + + def _test_transform_future_without_target(self, ts, transform, expected_changes, gap_size=28, transform_size=7): + # select subset of tsdataset + history_ts, future_ts = ts.train_test_split(test_size=gap_size) + future_ts_without_transform = future_ts + future_ts_with_transform = deepcopy(future_ts) + future_ts_without_transform.transforms = [] + future_ts_with_transform.transforms = [transform] + train_df = history_ts.to_pandas() + + # fitting + transform.fit(train_df) + + # prepare df without transform + test_ts = future_ts_without_transform.make_future(future_steps=transform_size) + test_df = test_ts.to_pandas() + + # transform + transformed_test_ts = future_ts_with_transform.make_future(future_steps=transform_size) + transformed_test_df = transformed_test_ts.to_pandas() + + # checking + expected_columns_to_create = expected_changes.get("create", set()) + expected_columns_to_remove = expected_changes.get("remove", set()) + expected_columns_to_change = expected_changes.get("change", set()) + flat_test_df = TSDataset.to_flatten(test_df) + flat_transformed_test_df = TSDataset.to_flatten(transformed_test_df) + created_columns, removed_columns, changed_columns = find_columns_diff(flat_test_df, flat_transformed_test_df) + + assert created_columns == expected_columns_to_create + assert removed_columns == expected_columns_to_remove + assert changed_columns == expected_columns_to_change + + @pytest.mark.parametrize( + "transform, dataset_name, expected_changes", + [ + # decomposition + ( + ChangePointsSegmentationTransform( + in_column="target", + change_point_model=RupturesChangePointsModel(change_point_model=Binseg(), n_bkps=5), + out_column="res", + ), + "regular_ts", + {"create": {"res"}}, + ), + ( + ChangePointsTrendTransform( + in_column="target", change_point_model=Binseg(), detrend_model=LinearRegression(), n_bkps=5 + ), + "regular_ts", + {}, + ), + ( + ChangePointsTrendTransform( + in_column="positive", change_point_model=Binseg(), detrend_model=LinearRegression(), n_bkps=5 + ), + "ts_with_exog", + {"change": {"positive"}}, + ), + (BinsegTrendTransform(in_column="target"), "regular_ts", {}), + (BinsegTrendTransform(in_column="positive"), "ts_with_exog", {"change": {"positive"}}), + (LinearTrendTransform(in_column="target"), "regular_ts", {}), + (LinearTrendTransform(in_column="positive"), "ts_with_exog", {"change": {"positive"}}), + (TheilSenTrendTransform(in_column="target"), "regular_ts", {}), + (TheilSenTrendTransform(in_column="positive"), "ts_with_exog", {"change": {"positive"}}), + (STLTransform(in_column="target", period=7), "regular_ts", {}), + (STLTransform(in_column="positive", period=7), "ts_with_exog", {"change": {"positive"}}), + (TrendTransform(in_column="target", out_column="res"), "regular_ts", {"create": {"res"}}), + # encoders + (LabelEncoderTransform(in_column="weekday", out_column="res"), "ts_with_exog", {"create": {"res"}}), + ( + OneHotEncoderTransform(in_column="weekday", out_column="res"), + "ts_with_exog", + {"create": {"res_0", "res_1", "res_2", "res_3", "res_4", "res_5", "res_6"}}, + ), + (MeanSegmentEncoderTransform(), "regular_ts", {"create": {"segment_mean"}}), + (SegmentEncoderTransform(), "regular_ts", {"create": {"segment_code"}}), + # feature_selection + (FilterFeaturesTransform(exclude=["year"]), "ts_with_exog", {"remove": {"year"}}), + ( + GaleShapleyFeatureSelectionTransform(relevance_table=StatisticsRelevanceTable(), top_k=2), + "ts_with_exog", + {"remove": {"month", "year", "weekday"}}, + ), + ( + MRMRFeatureSelectionTransform(relevance_table=StatisticsRelevanceTable(), top_k=2), + "ts_with_exog", + {"remove": {"weekday", "monthday", "positive"}}, + ), + ( + TreeFeatureSelectionTransform(model=DecisionTreeRegressor(random_state=42), top_k=2), + "ts_with_exog", + {"remove": {"year", "month", "weekday"}}, + ), + # math + ( + AddConstTransform(in_column="target", value=1, inplace=False, out_column="res"), + "regular_ts", + {"create": {"res"}}, + ), + (AddConstTransform(in_column="target", value=1, inplace=True), "regular_ts", {}), + (AddConstTransform(in_column="positive", value=1, inplace=True), "ts_with_exog", {"change": {"positive"}}), + ( + LagTransform(in_column="target", lags=[1, 2, 3], out_column="res"), + "regular_ts", + {"create": {"res_1", "res_2", "res_3"}}, + ), + ( + LambdaTransform(in_column="target", transform_func=lambda x: x + 1, inplace=False, out_column="res"), + "regular_ts", + {"create": {"res"}}, + ), + ( + LambdaTransform( + in_column="target", + transform_func=lambda x: x + 1, + inverse_transform_func=lambda x: x - 1, + inplace=True, + ), + "regular_ts", + {}, + ), + ( + LambdaTransform( + in_column="positive", + transform_func=lambda x: x + 1, + inverse_transform_func=lambda x: x - 1, + inplace=True, + ), + "ts_with_exog", + {"change": {"positive"}}, + ), + (LogTransform(in_column="target", inplace=False, out_column="res"), "positive_ts", {"create": {"res"}}), + (LogTransform(in_column="target", inplace=True), "positive_ts", {}), + (LogTransform(in_column="positive", inplace=True), "ts_with_exog", {"change": {"positive"}}), + ( + DifferencingTransform(in_column="target", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res"}}, + ), + (DifferencingTransform(in_column="target", inplace=True), "regular_ts", {}), + (DifferencingTransform(in_column="positive", inplace=True), "ts_with_exog", {"change": {"positive"}}), + (MADTransform(in_column="target", window=14, out_column="res"), "regular_ts", {"create": {"res"}}), + (MaxTransform(in_column="target", window=14, out_column="res"), "regular_ts", {"create": {"res"}}), + (MeanTransform(in_column="target", window=14, out_column="res"), "regular_ts", {"create": {"res"}}), + (MedianTransform(in_column="target", window=14, out_column="res"), "regular_ts", {"create": {"res"}}), + ( + MinMaxDifferenceTransform(in_column="target", window=14, out_column="res"), + "regular_ts", + {"create": {"res"}}, + ), + (MinTransform(in_column="target", window=14, out_column="res"), "regular_ts", {"create": {"res"}}), + ( + QuantileTransform(in_column="target", quantile=0.9, window=14, out_column="res"), + "regular_ts", + {"create": {"res"}}, + ), + (StdTransform(in_column="target", window=14, out_column="res"), "regular_ts", {"create": {"res"}}), + (SumTransform(in_column="target", window=14, out_column="res"), "regular_ts", {"create": {"res"}}), + ( + BoxCoxTransform(in_column="target", mode="per-segment", inplace=False, out_column="res"), + "positive_ts", + {"create": {"res_target"}}, + ), + (BoxCoxTransform(in_column="target", mode="per-segment", inplace=True), "positive_ts", {}), + ( + BoxCoxTransform(in_column="positive", mode="per-segment", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + BoxCoxTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "positive_ts", + {"create": {"res_target"}}, + ), + (BoxCoxTransform(in_column="target", mode="macro", inplace=True), "positive_ts", {}), + ( + BoxCoxTransform(in_column="positive", mode="macro", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + MaxAbsScalerTransform(in_column="target", mode="per-segment", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + (MaxAbsScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts", {}), + ( + MaxAbsScalerTransform(in_column="positive", mode="per-segment", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + MaxAbsScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + ( + MaxAbsScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {}, + ), + ( + MaxAbsScalerTransform(in_column="positive", mode="macro", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + MinMaxScalerTransform(in_column="target", mode="per-segment", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + (MinMaxScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts", {}), + ( + MinMaxScalerTransform(in_column="positive", mode="per-segment", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + MinMaxScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + ( + MinMaxScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {}, + ), + ( + MinMaxScalerTransform(in_column="positive", mode="macro", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + RobustScalerTransform(in_column="target", mode="per-segment", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + (RobustScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts", {}), + ( + RobustScalerTransform(in_column="positive", mode="per-segment", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + RobustScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + ( + RobustScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {}, + ), + ( + RobustScalerTransform(in_column="positive", mode="macro", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + StandardScalerTransform(in_column="target", mode="per-segment", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + (StandardScalerTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts", {}), + ( + StandardScalerTransform(in_column="positive", mode="per-segment", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + StandardScalerTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + ( + StandardScalerTransform(in_column="target", mode="macro", inplace=True), + "regular_ts", + {}, + ), + ( + StandardScalerTransform(in_column="positive", mode="macro", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + YeoJohnsonTransform(in_column="target", mode="per-segment", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + (YeoJohnsonTransform(in_column="target", mode="per-segment", inplace=True), "regular_ts", {}), + ( + YeoJohnsonTransform(in_column="positive", mode="per-segment", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + ( + YeoJohnsonTransform(in_column="target", mode="macro", inplace=False, out_column="res"), + "regular_ts", + {"create": {"res_target"}}, + ), + (YeoJohnsonTransform(in_column="target", mode="macro", inplace=True), "regular_ts", {}), + ( + YeoJohnsonTransform(in_column="positive", mode="macro", inplace=True), + "ts_with_exog", + {"change": {"positive"}}, + ), + # missing_values + ( + ResampleWithDistributionTransform( + in_column="regressor_exog", distribution_column="target", inplace=False, out_column="res" + ), + "ts_to_resample", + {"create": {"res"}}, + ), + ( + ResampleWithDistributionTransform( + in_column="regressor_exog", distribution_column="target", inplace=True + ), + "ts_to_resample", + {"change": {"regressor_exog"}}, + ), + ( + # this behaviour can be unexpected for someone + TimeSeriesImputerTransform(in_column="target"), + "ts_to_fill", + {}, + ), + # outliers + (DensityOutliersTransform(in_column="target"), "ts_with_outliers", {}), + (MedianOutliersTransform(in_column="target"), "ts_with_outliers", {}), + (PredictionIntervalOutliersTransform(in_column="target", model=ProphetModel), "ts_with_outliers", {}), + # timestamp + ( + DateFlagsTransform(out_column="res"), + "regular_ts", + {"create": {"res_day_number_in_week", "res_day_number_in_month", "res_is_weekend"}}, + ), + ( + FourierTransform(period=7, order=2, out_column="res"), + "regular_ts", + {"create": {"res_1", "res_2", "res_3", "res_4"}}, + ), + (HolidayTransform(out_column="res"), "regular_ts", {"create": {"res"}}), + ( + TimeFlagsTransform(out_column="res"), + "regular_ts", + {"create": {"res_minute_in_hour_number", "res_hour_number"}}, + ), + (SpecialDaysTransform(), "regular_ts", {"create": {"anomaly_weekdays", "anomaly_monthdays"}}), + ], + ) + def test_transform_future_without_target(self, transform, dataset_name, expected_changes, request): + ts = request.getfixturevalue(dataset_name) + self._test_transform_future_without_target(ts, transform, expected_changes=expected_changes) diff --git a/tests/test_transforms/test_math/test_differencing_transform.py b/tests/test_transforms/test_math/test_differencing_transform.py index 717471c26..ee2ea1ed2 100644 --- a/tests/test_transforms/test_math/test_differencing_transform.py +++ b/tests/test_transforms/test_math/test_differencing_transform.py @@ -1,4 +1,5 @@ from typing import List +from typing import Tuple from typing import Union import numpy as np @@ -39,6 +40,26 @@ def df_nans() -> pd.DataFrame: return df +@pytest.fixture +def df_nans_middle() -> pd.DataFrame: + """Create DataFrame with nans in the middle of the segment.""" + timestamp = pd.date_range("2021-01-01", "2021-04-01") + df_1 = pd.DataFrame({"timestamp": timestamp, "target": np.arange(timestamp.shape[0]), "segment": "1"}) + df_2 = pd.DataFrame({"timestamp": timestamp, "target": np.arange(timestamp.shape[0]) * 2, "segment": "2"}) + df = pd.concat([df_1, df_2], ignore_index=True) + df = TSDataset.to_dataset(df) + df.iloc[5:10, 0] = np.NaN + return df + + +@pytest.fixture +def df_segments_split(df_nans) -> Tuple[pd.DataFrame, pd.DataFrame]: + """Create a pair of DataFrames with different segments.""" + train_df = df_nans.loc[:, pd.IndexSlice["1", :]] + test_df = df_nans.loc[:, pd.IndexSlice["2", :]] + return train_df, test_df + + @pytest.fixture def df_regressors(df_nans) -> pd.DataFrame: """Create df_exog for df_nans.""" @@ -82,29 +103,33 @@ def check_interface_transform_autogenerate_column_regressor( def check_transform( - transform: GeneralDifferencingTransform, period: int, order: int, out_column: str, df: pd.DataFrame + transform: GeneralDifferencingTransform, + period: int, + order: int, + out_column: str, + fit_df: pd.DataFrame, + df: pd.DataFrame, ): """Check that differencing transform generates correct values in transform.""" - transformed_df = transform.fit_transform(df) + transform.fit(fit_df) + transformed_df = transform.transform(df) for segment in df.columns.get_level_values("segment").unique(): series_init = df.loc[:, pd.IndexSlice[segment, "target"]] series_transformed = transformed_df.loc[:, pd.IndexSlice[segment, out_column]] - series_init = series_init.loc[series_init.first_valid_index() :] - series_transformed = series_transformed.loc[series_transformed.first_valid_index() :] - - assert series_init.shape[0] == series_transformed.shape[0] + order * period - for _ in range(order): - series_init = series_init.diff(periods=period).iloc[period:] + series_init = series_init.diff(periods=period) - assert np.all(series_init == series_transformed) + assert series_init.equals(series_transformed) -def check_inverse_transform_not_inplace(transform: GeneralDifferencingTransform, df: pd.DataFrame): +def check_inverse_transform_not_inplace( + transform: GeneralDifferencingTransform, train_df: pd.DataFrame, test_df: pd.DataFrame +): """Check that differencing transform does nothing during inverse_transform in non-inplace mode.""" - transformed_df = transform.fit_transform(df) + transform.fit_transform(train_df) + transformed_df = transform.transform(test_df) inverse_transformed_df = transform.inverse_transform(transformed_df) assert transformed_df.equals(inverse_transformed_df) @@ -116,10 +141,10 @@ def check_inverse_transform_inplace_train(transform: GeneralDifferencingTransfor assert inverse_transformed_df.equals(df) -def check_inverse_transform_inplace_test( +def check_inverse_transform_inplace_filled_test( transform: GeneralDifferencingTransform, period: int, order: int, df: pd.DataFrame ): - """Check that differencing transform correctly makes inverse_transform on test data in inplace mode.""" + """Check that differencing transform correctly makes inverse_transform on filled test data in inplace mode.""" ts = TSDataset(df, freq="D") ts_train, ts_test = ts.train_test_split(test_size=20) ts_train.fit_transform(transforms=[transform]) @@ -140,6 +165,19 @@ def check_inverse_transform_inplace_test( assert np.all(future_ts.to_pandas() == ts_test.to_pandas()) +def check_inverse_transform_inplace_unfilled_test(transform: GeneralDifferencingTransform, df: pd.DataFrame): + """Check that differencing transform correctly makes inverse_transform on unfilled test data in inplace mode.""" + ts = TSDataset(df, freq="D") + ts_train, ts_test = ts.train_test_split(test_size=20) + ts_train.fit_transform(transforms=[transform]) + + future_ts = ts_train.make_future(20) + + # check values from inverse_transform + future_ts.inverse_transform() + assert future_ts.to_pandas().isna().all().all() + + def check_inverse_transform_inplace_test_quantiles(transform: GeneralDifferencingTransform, df: pd.DataFrame): """Check that differencing transform correctly makes inverse_transform on test data with quantiles.""" ts = TSDataset(df, freq="D") @@ -257,7 +295,7 @@ def test_general_interface_transform_inplace(transform, df_nans): DifferencingTransform(in_column="target", period=1, order=1, inplace=False, out_column="diff"), ], ) -def test_general_transform_not_inplace(transform, df_nans): +def test_general_interface_transform_not_inplace(transform, df_nans): """Test that differencing transform doesn't change in_column in transform in non-inplace mode.""" transformed_df = transform.fit_transform(df_nans) @@ -281,25 +319,39 @@ def test_general_fit_fail_nans(transform, df_nans): transform.fit(df_nans) -@pytest.mark.parametrize( - "transform", - [ - _SingleDifferencingTransform(in_column="target", period=1, inplace=False, out_column="diff"), - DifferencingTransform(in_column="target", period=1, order=1, inplace=False, out_column="diff"), - ], -) -def test_general_transform_fail_not_fitted(transform, df_nans): - """Test that differencing transform fails to make transform before fitting.""" - with pytest.raises(AttributeError, match="Transform is not fitted"): +@pytest.mark.parametrize("inplace, out_column", [(False, "diff"), (True, "target")]) +def test_full_transform_fail_not_fitted(inplace, out_column, df_nans): + """Test that DifferencingTransform transform fails to make transform before fitting.""" + transform = DifferencingTransform(in_column="target", inplace=inplace, out_column=out_column) + with pytest.raises(ValueError, match="Transform is not fitted"): _ = transform.transform(df_nans) +@pytest.mark.parametrize("period", [1, 7]) +def test_single_transform_inplace_new_segments(period, df_segments_split): + """Test that _SingleDifferencingTransform generates correct values in transform on new segments in inplace mode.""" + train_df, test_df = df_segments_split + transform = _SingleDifferencingTransform(in_column="target", period=period, inplace=True) + check_transform(transform, period, 1, "target", train_df, test_df) + + +def test_full_transform_inplace_fail_new_segments(df_segments_split): + """Test that DifferencingTransform transform fails to make transform if new segments are present in inplace mode.""" + train_df, test_df = df_segments_split + transform = DifferencingTransform(in_column="target", period=1, order=1, inplace=True) + transform.fit(train_df) + with pytest.raises( + NotImplementedError, match="This transform can't process segments that weren't present on train data" + ): + _ = transform.transform(test_df) + + @pytest.mark.parametrize("period", [1, 7]) @pytest.mark.parametrize("inplace, out_column", [(False, "diff"), (True, "target")]) def test_single_transform(period, inplace, out_column, df_nans): """Test that _SingleDifferencingTransform generates correct values in transform.""" transform = _SingleDifferencingTransform(in_column="target", period=period, inplace=inplace, out_column=out_column) - check_transform(transform, period, 1, out_column, df_nans) + check_transform(transform, period, 1, out_column, df_nans, df_nans) @pytest.mark.parametrize("period", [1, 7]) @@ -310,22 +362,68 @@ def test_full_transform(period, order, inplace, out_column, df_nans): transform = DifferencingTransform( in_column="target", period=period, order=order, inplace=inplace, out_column=out_column ) - check_transform(transform, period, order, out_column, df_nans) + check_transform(transform, period, order, out_column, df_nans, df_nans) -@pytest.mark.parametrize( - "transform", - [ - _SingleDifferencingTransform(in_column="target", period=1, inplace=True), - DifferencingTransform(in_column="target", period=1, order=1, inplace=True), - ], -) -def test_general_inverse_transform_fail_not_fitted(transform, df_nans): - """Test that differencing transform fails to make inverse_transform before fitting.""" - with pytest.raises(AttributeError, match="Transform is not fitted"): +@pytest.mark.parametrize("period", [1, 7]) +@pytest.mark.parametrize("inplace, out_column", [(False, "diff"), (True, "target")]) +def test_single_transform_nans_middle(period, inplace, out_column, df_nans, df_nans_middle): + """Test that _SingleDifferencingTransform generates correct values in transform with NaNs in the middle.""" + transform = _SingleDifferencingTransform(in_column="target", period=period, inplace=inplace, out_column=out_column) + check_transform(transform, period, 1, out_column, df_nans, df_nans_middle) + + +@pytest.mark.parametrize("period", [1, 7]) +@pytest.mark.parametrize("order", [1, 2]) +@pytest.mark.parametrize("inplace, out_column", [(False, "diff"), (True, "target")]) +def test_full_transform_nans_middle(period, order, inplace, out_column, df_nans, df_nans_middle): + """Test that DifferencingTransform generates correct values in transform with NaNs in the middle.""" + transform = DifferencingTransform( + in_column="target", period=period, order=order, inplace=inplace, out_column=out_column + ) + check_transform(transform, period, order, out_column, df_nans, df_nans_middle) + + +@pytest.mark.parametrize("period", [1, 7]) +def test_single_transform_not_inplace_new_segments(period, df_segments_split): + """Test that _SingleDifferencingTransform generates correct values in transform on new segments in non-inplace mode.""" + train_df, test_df = df_segments_split + out_column = "diff" + transform = _SingleDifferencingTransform(in_column="target", period=period, inplace=False, out_column=out_column) + check_transform(transform, period, 1, out_column, train_df, test_df) + + +@pytest.mark.parametrize("period", [1, 7]) +@pytest.mark.parametrize("order", [1, 2]) +def test_full_transform_not_inplace_new_segments(period, order, df_segments_split): + """Test that DifferencingTransform generates correct values in transform on new segments in non-inplace mode.""" + train_df, test_df = df_segments_split + out_column = "diff" + transform = DifferencingTransform( + in_column="target", period=period, order=order, inplace=False, out_column=out_column + ) + check_transform(transform, period, order, out_column, train_df, test_df) + + +@pytest.mark.parametrize("inplace, out_column", [(False, "diff"), (True, "target")]) +def test_full_inverse_transform_fail_not_fitted(inplace, out_column, df_nans): + """Test that DifferencingTransform fails to make inverse_transform before fitting.""" + transform = DifferencingTransform(in_column="target", inplace=inplace, out_column=out_column) + with pytest.raises(ValueError, match="Transform is not fitted"): _ = transform.inverse_transform(df_nans) +def test_full_inverse_transform_inplace_fail_new_segments(df_segments_split): + """Test that DifferencingTransform fails to make inverse_transform if new segments are present in inplace mode.""" + train_df, test_df = df_segments_split + transform = DifferencingTransform(in_column="target", period=1, order=1, inplace=True) + transform.fit(train_df) + with pytest.raises( + NotImplementedError, match="This transform can't process segments that weren't present on train data" + ): + _ = transform.inverse_transform(test_df) + + @pytest.mark.parametrize( "transform", [ @@ -364,7 +462,7 @@ def test_general_inverse_transform_fail_test_not_right_after_train(transform, df def test_single_inverse_transform_not_inplace(period, df_nans): """Test that _SingleDifferencingTransform does nothing during inverse_transform in non-inplace mode.""" transform = _SingleDifferencingTransform(in_column="target", period=period, inplace=False, out_column="diff") - check_inverse_transform_not_inplace(transform, df_nans) + check_inverse_transform_not_inplace(transform, df_nans, df_nans) @pytest.mark.parametrize("period", [1, 7]) @@ -372,7 +470,24 @@ def test_single_inverse_transform_not_inplace(period, df_nans): def test_full_inverse_transform_not_inplace(period, order, df_nans): """Test that DifferencingTransform does nothing during inverse_transform in non-inplace mode.""" transform = DifferencingTransform(in_column="target", period=period, order=order, inplace=False, out_column="diff") - check_inverse_transform_not_inplace(transform, df_nans) + check_inverse_transform_not_inplace(transform, df_nans, df_nans) + + +@pytest.mark.parametrize("period", [1, 7]) +def test_single_inverse_transform_not_inplace_new_segments(period, df_segments_split): + """Test that _SingleDifferencingTransform does nothing during inverse_transform on new segments in non-inplace mode.""" + train_df, test_df = df_segments_split + transform = _SingleDifferencingTransform(in_column="target", period=period, inplace=False, out_column="diff") + check_inverse_transform_not_inplace(transform, train_df, test_df) + + +@pytest.mark.parametrize("period", [1, 7]) +@pytest.mark.parametrize("order", [1, 2]) +def test_full_inverse_transform_not_inplace_new_segments(period, order, df_segments_split): + """Test that DifferencingTransform does nothing during inverse_transform on new segments in non-inplace mode.""" + train_df, test_df = df_segments_split + transform = DifferencingTransform(in_column="target", period=period, order=order, inplace=False, out_column="diff") + check_inverse_transform_not_inplace(transform, train_df, test_df) @pytest.mark.parametrize("period", [1, 7]) @@ -390,43 +505,34 @@ def test_full_inverse_transform_inplace_train(period, order, df_nans): check_inverse_transform_inplace_train(transform, df_nans) -@pytest.mark.parametrize( - "transform", - [ - _SingleDifferencingTransform(in_column="target", period=1, inplace=True), - DifferencingTransform(in_column="target", period=1, order=1, inplace=True), - ], -) -def test_general_inverse_transform_inplace_test_fail_nans(transform, df_nans): - """Test that differencing transform fails to make inverse_transform on test data if there are NaNs.""" - ts = TSDataset(df_nans, freq="D") - ts_train, ts_test = ts.train_test_split(test_size=20) - - ts_train.fit_transform(transforms=[transform]) +@pytest.mark.parametrize("period", [1, 7]) +def test_single_inverse_transform_inplace_filled_test(period, df_nans): + """Test that _SingleDifferencingTransform correctly makes inverse_transform on filled test data in inplace mode.""" + transform = _SingleDifferencingTransform(in_column="target", period=period, inplace=True) + check_inverse_transform_inplace_filled_test(transform, period, 1, df_nans) - # make predictions by hand only on one segment - future_ts = ts_train.make_future(20) - future_ts.df.loc[:, pd.IndexSlice["1", "target"]] = np.NaN - future_ts.df.loc[:, pd.IndexSlice["2", "target"]] = 2 - # check fail on inverse_transform - with pytest.raises(ValueError, match="There should be no NaNs inside the segments"): - future_ts.inverse_transform() +@pytest.mark.parametrize("period", [1, 7]) +@pytest.mark.parametrize("order", [1, 2]) +def test_full_inverse_transform_inplace_test(period, order, df_nans): + """Test that DifferencingTransform correctly makes inverse_transform on filled test data in inplace mode.""" + transform = DifferencingTransform(in_column="target", period=period, order=order, inplace=True) + check_inverse_transform_inplace_filled_test(transform, period, order, df_nans) @pytest.mark.parametrize("period", [1, 7]) def test_single_inverse_transform_inplace_test(period, df_nans): - """Test that _SingleDifferencingTransform correctly makes inverse_transform on test data in inplace mode.""" + """Test that _SingleDifferencingTransform correctly makes inverse_transform on unfilled test data in inplace mode.""" transform = _SingleDifferencingTransform(in_column="target", period=period, inplace=True) - check_inverse_transform_inplace_test(transform, period, 1, df_nans) + check_inverse_transform_inplace_unfilled_test(transform, df_nans) @pytest.mark.parametrize("period", [1, 7]) @pytest.mark.parametrize("order", [1, 2]) def test_full_inverse_transform_inplace_test(period, order, df_nans): - """Test that DifferencingTransform correctly makes inverse_transform on test data in inplace mode.""" + """Test that DifferencingTransform correctly makes inverse_transform on unfilled test data in inplace mode.""" transform = DifferencingTransform(in_column="target", period=period, order=order, inplace=True) - check_inverse_transform_inplace_test(transform, period, order, df_nans) + check_inverse_transform_inplace_unfilled_test(transform, df_nans) @pytest.mark.parametrize("period", [1, 7]) diff --git a/tests/test_transforms/test_math/test_sklearn_transform_interface.py b/tests/test_transforms/test_math/test_sklearn_transform_interface.py index f38d6f098..1ad8a9650 100644 --- a/tests/test_transforms/test_math/test_sklearn_transform_interface.py +++ b/tests/test_transforms/test_math/test_sklearn_transform_interface.py @@ -278,3 +278,335 @@ def test_ordering(transform_constructor, in_column, mode, multicolumn_ts): df_multi = transformed_df.loc[:, pd.IndexSlice[segments, column_multi]] df_single = transformed_dfs_one_column[i].loc[:, pd.IndexSlice[segments, column_single]] assert np.all(df_multi == df_single) + + +@pytest.mark.parametrize("inplace", [False, True]) +@pytest.mark.parametrize( + "in_column", + [ + "exog_1", + ["exog_1", "exog_2"], + ], +) +@pytest.mark.parametrize( + "mode", + [ + "macro", + "per-segment", + ], +) +@pytest.mark.parametrize( + "transform_constructor", + [ + BoxCoxTransform, + YeoJohnsonTransform, + StandardScalerTransform, + RobustScalerTransform, + MinMaxScalerTransform, + MaxAbsScalerTransform, + StandardScalerTransform, + RobustScalerTransform, + MinMaxScalerTransform, + ], +) +def test_transform_not_fitted_fail(transform_constructor, mode, in_column, inplace, multicolumn_ts): + df = multicolumn_ts.to_pandas() + transform = transform_constructor(mode=mode, in_column=in_column, inplace=inplace) + + with pytest.raises(ValueError, match="The transform isn't fitted"): + _ = transform.transform(df) + + +@pytest.mark.parametrize("inplace", [False, True]) +@pytest.mark.parametrize( + "in_column", + [ + "exog_1", + ["exog_1", "exog_2"], + ], +) +@pytest.mark.parametrize( + "mode", + [ + "macro", + "per-segment", + ], +) +@pytest.mark.parametrize( + "transform_constructor", + [ + BoxCoxTransform, + YeoJohnsonTransform, + StandardScalerTransform, + RobustScalerTransform, + MinMaxScalerTransform, + MaxAbsScalerTransform, + StandardScalerTransform, + RobustScalerTransform, + MinMaxScalerTransform, + ], +) +def test_inverse_transform_not_fitted_fail(transform_constructor, mode, in_column, inplace, multicolumn_ts): + df = multicolumn_ts.to_pandas() + transform = transform_constructor(mode=mode, in_column=in_column, inplace=inplace) + + with pytest.raises(ValueError, match="The transform isn't fitted"): + _ = transform.inverse_transform(df) + + +def _check_same_segments(df_1: pd.DataFrame, df_2: pd.DataFrame): + df_1_segments = set(df_1.columns.get_level_values("segment")) + df_2_segments = set(df_2.columns.get_level_values("segment")) + assert df_1_segments == df_2_segments + + +@pytest.mark.parametrize("inplace", [False, True]) +@pytest.mark.parametrize( + "in_column", + [ + "exog_1", + ["exog_1", "exog_2"], + ], +) +@pytest.mark.parametrize( + "mode", + [ + "macro", + "per-segment", + ], +) +@pytest.mark.parametrize( + "transform_constructor", + [ + BoxCoxTransform, + YeoJohnsonTransform, + StandardScalerTransform, + RobustScalerTransform, + MinMaxScalerTransform, + MaxAbsScalerTransform, + StandardScalerTransform, + RobustScalerTransform, + MinMaxScalerTransform, + ], +) +def test_transform_subset_segments(transform_constructor, mode, in_column, inplace, multicolumn_ts): + df = multicolumn_ts.to_pandas() + train_df = df + test_df = df.loc[:, pd.IndexSlice[["segment_0", "segment_2"], :]] + transform = transform_constructor(mode=mode, in_column=in_column, inplace=inplace) + + transform.fit(train_df) + transformed_df = transform.transform(test_df) + + _check_same_segments(transformed_df, test_df) + + +@pytest.mark.parametrize("inplace", [False, True]) +@pytest.mark.parametrize( + "in_column", + [ + "exog_1", + ["exog_1", "exog_2"], + ], +) +@pytest.mark.parametrize( + "mode", + [ + "macro", + "per-segment", + ], +) +@pytest.mark.parametrize( + "transform_constructor", + [ + BoxCoxTransform, + YeoJohnsonTransform, + StandardScalerTransform, + RobustScalerTransform, + MinMaxScalerTransform, + MaxAbsScalerTransform, + StandardScalerTransform, + RobustScalerTransform, + MinMaxScalerTransform, + ], +) +def test_inverse_transform_subset_segments(transform_constructor, mode, in_column, inplace, multicolumn_ts): + df = multicolumn_ts.to_pandas() + train_df = df + test_df = df.loc[:, pd.IndexSlice[["segment_0", "segment_2"], :]] + transform = transform_constructor(mode=mode, in_column=in_column, inplace=inplace) + + transform.fit(train_df) + inv_transformed_df = transform.inverse_transform(test_df) + + _check_same_segments(inv_transformed_df, test_df) + + +@pytest.mark.parametrize("inplace", [False, True]) +@pytest.mark.parametrize( + "in_column", + [ + "exog_1", + ["exog_1", "exog_2"], + ], +) +@pytest.mark.parametrize( + "transform_constructor", + [ + BoxCoxTransform, + YeoJohnsonTransform, + StandardScalerTransform, + RobustScalerTransform, + MinMaxScalerTransform, + MaxAbsScalerTransform, + StandardScalerTransform, + RobustScalerTransform, + MinMaxScalerTransform, + ], +) +def test_transform_new_segments_macro(transform_constructor, in_column, inplace, multicolumn_ts): + df = multicolumn_ts.to_pandas() + train_df = df.loc[:, pd.IndexSlice[["segment_0", "segment_1"], :]] + test_df = df.loc[:, pd.IndexSlice["segment_2", :]] + transform = transform_constructor(mode="macro", in_column=in_column, inplace=inplace) + + transform.fit(train_df) + transformed_df = transform.transform(test_df) + + _check_same_segments(transformed_df, test_df) + + +@pytest.mark.parametrize("inplace", [False, True]) +@pytest.mark.parametrize( + "in_column", + [ + "exog_1", + ["exog_1", "exog_2"], + ], +) +@pytest.mark.parametrize( + "transform_constructor", + [ + BoxCoxTransform, + YeoJohnsonTransform, + StandardScalerTransform, + RobustScalerTransform, + MinMaxScalerTransform, + MaxAbsScalerTransform, + StandardScalerTransform, + RobustScalerTransform, + MinMaxScalerTransform, + ], +) +def test_transform_new_segments_per_segment_fail(transform_constructor, in_column, inplace, multicolumn_ts): + df = multicolumn_ts.to_pandas() + train_df = df.loc[:, pd.IndexSlice[["segment_0", "segment_1"], :]] + test_df = df.loc[:, pd.IndexSlice["segment_2", :]] + transform = transform_constructor(mode="per-segment", in_column=in_column, inplace=inplace) + + transform.fit(train_df) + with pytest.raises( + NotImplementedError, match="This transform can't process segments that weren't present on train data" + ): + _ = transform.transform(test_df) + + +@pytest.mark.parametrize("inplace", [False, True]) +@pytest.mark.parametrize( + "in_column", + [ + "exog_1", + ["exog_1", "exog_2"], + ], +) +@pytest.mark.parametrize( + "transform_constructor", + [ + BoxCoxTransform, + YeoJohnsonTransform, + StandardScalerTransform, + RobustScalerTransform, + MinMaxScalerTransform, + MaxAbsScalerTransform, + StandardScalerTransform, + RobustScalerTransform, + MinMaxScalerTransform, + ], +) +def test_inverse_transform_new_segments_macro(transform_constructor, in_column, inplace, multicolumn_ts): + df = multicolumn_ts.to_pandas() + train_df = df.loc[:, pd.IndexSlice[["segment_0", "segment_1"], :]] + test_df = df.loc[:, pd.IndexSlice["segment_2", :]] + transform = transform_constructor(mode="macro", in_column=in_column, inplace=inplace) + + transform.fit(train_df) + transformed_df = transform.inverse_transform(test_df) + + _check_same_segments(transformed_df, test_df) + + +@pytest.mark.parametrize( + "in_column", + [ + "exog_1", + ["exog_1", "exog_2"], + ], +) +@pytest.mark.parametrize( + "transform_constructor", + [ + BoxCoxTransform, + YeoJohnsonTransform, + StandardScalerTransform, + RobustScalerTransform, + MinMaxScalerTransform, + MaxAbsScalerTransform, + StandardScalerTransform, + RobustScalerTransform, + MinMaxScalerTransform, + ], +) +def test_inverse_transform_new_segments_per_segment_non_inplace(transform_constructor, in_column, multicolumn_ts): + df = multicolumn_ts.to_pandas() + train_df = df.loc[:, pd.IndexSlice[["segment_0", "segment_1"], :]] + test_df = df.loc[:, pd.IndexSlice["segment_2", :]] + transform = transform_constructor(mode="per-segment", in_column=in_column, inplace=False) + + transform.fit(train_df) + inv_transformed_df = transform.inverse_transform(test_df) + + pd.testing.assert_frame_equal(inv_transformed_df, test_df) + + +@pytest.mark.parametrize( + "in_column", + [ + "exog_1", + ["exog_1", "exog_2"], + ], +) +@pytest.mark.parametrize( + "transform_constructor", + [ + BoxCoxTransform, + YeoJohnsonTransform, + StandardScalerTransform, + RobustScalerTransform, + MinMaxScalerTransform, + MaxAbsScalerTransform, + StandardScalerTransform, + RobustScalerTransform, + MinMaxScalerTransform, + ], +) +def test_inverse_transform_new_segments_per_segment_inplace_fail(transform_constructor, in_column, multicolumn_ts): + df = multicolumn_ts.to_pandas() + train_df = df.loc[:, pd.IndexSlice[["segment_0", "segment_1"], :]] + test_df = df.loc[:, pd.IndexSlice["segment_2", :]] + transform = transform_constructor(mode="per-segment", in_column=in_column, inplace=True) + + transform.fit(train_df) + with pytest.raises( + NotImplementedError, match="This transform can't process segments that weren't present on train data" + ): + _ = transform.inverse_transform(test_df) diff --git a/tests/test_transforms/test_outliers/test_outliers_transform.py b/tests/test_transforms/test_outliers/test_outliers_transform.py index 3bb734f3b..d6de47fd4 100644 --- a/tests/test_transforms/test_outliers/test_outliers_transform.py +++ b/tests/test_transforms/test_outliers/test_outliers_transform.py @@ -155,6 +155,46 @@ def test_inverse_transform_raise_error_if_not_fitted(transform, outliers_solid_t _ = transform.inverse_transform(df=outliers_solid_tsds.df) +@pytest.mark.parametrize( + "transform", + ( + MedianOutliersTransform(in_column="target"), + DensityOutliersTransform(in_column="target"), + PredictionIntervalOutliersTransform(in_column="target", model=ProphetModel), + ), +) +def test_transform_new_segments_fail(transform, outliers_solid_tsds): + df = outliers_solid_tsds.to_pandas() + train_df = df.loc[:, pd.IndexSlice["1", :]] + test_df = df.loc[:, pd.IndexSlice["2", :]] + + transform.fit(train_df) + with pytest.raises( + NotImplementedError, match="This transform can't process segments that weren't present on train data" + ): + _ = transform.transform(test_df) + + +@pytest.mark.parametrize( + "transform", + ( + MedianOutliersTransform(in_column="target"), + DensityOutliersTransform(in_column="target"), + PredictionIntervalOutliersTransform(in_column="target", model=ProphetModel), + ), +) +def test_inverse_transform_new_segments_fail(transform, outliers_solid_tsds): + df = outliers_solid_tsds.to_pandas() + train_df = df.loc[:, pd.IndexSlice["1", :]] + test_df = df.loc[:, pd.IndexSlice["2", :]] + + transform.fit(train_df) + with pytest.raises( + NotImplementedError, match="This transform can't process segments that weren't present on train data" + ): + _ = transform.inverse_transform(test_df) + + @pytest.mark.parametrize( "transform", ( diff --git a/tests/utils.py b/tests/utils.py index e279d7ec9..3da2bee25 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -1,9 +1,38 @@ +import functools +from typing import List + import numpy as np +import pandas as pd +import pytest +from etna.datasets import TSDataset from etna.metrics.base import Metric from etna.metrics.base import MetricAggregationMode +def to_be_fixed(raises, match=None): + def to_be_fixed_concrete(func): + @functools.wraps(func) + def wrapped_test(*args, **kwargs): + with pytest.raises(raises, match=match): + return func(*args, **kwargs) + + return wrapped_test + + return to_be_fixed_concrete + + +def select_segments_subset(ts: TSDataset, segments: List[str]) -> TSDataset: + df = ts.raw_df.loc[:, pd.IndexSlice[segments, :]] + df = df.loc[ts.df.index] + df_exog = ts.df_exog + if df_exog is not None: + df_exog = df_exog.loc[:, pd.IndexSlice[segments, :]] + known_future = ts.known_future + freq = ts.freq + return TSDataset(df=df, df_exog=df_exog, known_future=known_future, freq=freq) + + def create_dummy_functional_metric(alpha: float = 1.0): def dummy_functional_metric(y_true: np.ndarray, y_pred: np.ndarray) -> float: return alpha