From eb4fd2fa858697ddaf77a23853806b49aefae9e0 Mon Sep 17 00:00:00 2001 From: Simon B Date: Wed, 22 Apr 2020 20:53:37 -0300 Subject: [PATCH 01/23] Transfer acf and related functions from plotting to stat_tools --- gtime/plotting/plotting.py | 5 +- gtime/plotting/preprocessing.py | 128 -------------- gtime/plotting/tests/test_preprocessing.py | 68 -------- gtime/stat_tools/tests/test_tools.py | 99 +++++++++++ gtime/stat_tools/tools.py | 191 +++++++++++++++++++++ 5 files changed, 293 insertions(+), 198 deletions(-) create mode 100644 gtime/stat_tools/tests/test_tools.py create mode 100644 gtime/stat_tools/tools.py diff --git a/gtime/plotting/plotting.py b/gtime/plotting/plotting.py index 34f2c5d..aeda0b3 100644 --- a/gtime/plotting/plotting.py +++ b/gtime/plotting/plotting.py @@ -1,8 +1,9 @@ import matplotlib.pyplot as plt import pandas as pd import numpy as np -from typing import Union, List, Callable, Optional, Dict -from gtime.plotting.preprocessing import seasonal_split, acf, pacf +from typing import Union, List, Callable, Optional +from gtime.plotting.preprocessing import seasonal_split +from gtime.stat_tools.tools import acf, pacf from scipy.stats import norm diff --git a/gtime/plotting/preprocessing.py b/gtime/plotting/preprocessing.py index e26c13c..4d5aa8f 100644 --- a/gtime/plotting/preprocessing.py +++ b/gtime/plotting/preprocessing.py @@ -1,8 +1,5 @@ import pandas as pd -import numpy as np from typing import Optional, Union, Callable -from scipy.linalg import toeplitz -from scipy.stats import zscore def _week_of_year(t: pd.Period) -> str: @@ -142,129 +139,4 @@ def seasonal_split( return df.set_index(["_Season", "_Series"]).unstack(level=0) -def _normalize(x: np.array) -> np.array: - """ - Scales x to mean(x) == 0 and std(x) == 1 - - Parameters - ---------- - x: np.array, array of float to be scaled - - Returns - ------- - np.array, scaled array - - """ - - if len(x) <= 1 or x.std() == 0.0: - return np.zeros(len(x)) - else: - return zscore(x) - - -def _autocorrelation(x: np.array) -> np.array: - """ - Autocorrelation via np.correlate for a scaled array `x` - - Parameters - ---------- - x: np.array, input array - - Returns - ------- - np.array, autocorrelation for all lags - - """ - - n = len(x) - return np.correlate(x, x, mode="full")[-n:] / n - - -def _solve_yw_equation(r: np.array) -> np.array: - """ - Solution to Yule-Walker equations via Töplitz matrix - - Parameters - ---------- - r: autocorrelation coefficients - - Returns - ------- - np.array: partial autocorrelation function - - """ - - R = toeplitz(r[:-1]) - try: - return np.linalg.solve(R, r[1:]) - except np.linalg.LinAlgError: - print("Solution is not defined for singular matrices") - return [np.nan] - - -def yule_walker(x: np.array, order=1) -> np.array: - - """ Estimate ``order`` parameters from a sequence using the Yule-Walker equations. - http://www-stat.wharton.upenn.edu/~steele/Courses/956/Resource/YWSourceFiles/YW-Eshel.pdf - - Parameters - ---------- - x : np.array, input time series - order : order of the autoregressive process - unbiased : bool, debiasing correction, False by default - - Returns - ------- - rho : np.array, autoregressive coefficients - """ - - if order == 0: - return np.array([1.0]) - - r = _autocorrelation(x) - rho = _solve_yw_equation(r[: order + 1]) - return rho - - -def pacf(x: np.array, max_lags: Optional[int] = None) -> np.array: - - """Partial autocorrelation estimate based on Yule-Walker equations - - Parameters - ---------- - x : np.array, a time series - max_lags : int, maximum number of lags to be calculated - - Returns - ------- - pacf : np.array, partial autocorrelations for min(max_lags, len(x)) lags, including lag 0 - """ - - n = x.size - if max_lags is None or max_lags > n: - max_lags = n - x = _normalize(x) - pacf = np.array([yule_walker(x, i)[-1] for i in range(max_lags)]) - return pacf - - -def acf(x: np.array, max_lags: Optional[int] = None) -> np.array: - - """ Autocorrelation estimate function - - Parameters - ---------- - x : np.array, a time series - max_lags : int, maximum number of lags to be calculated - - Returns - ------- - acf : np.array, partial autocorrelations for min(max_lags, len(x)) lags, including lag 0 - """ - n = x.size - if max_lags is None or max_lags > n: - max_lags = n - x = _normalize(x) - acf = _autocorrelation(x) - return acf[:max_lags] diff --git a/gtime/plotting/tests/test_preprocessing.py b/gtime/plotting/tests/test_preprocessing.py index 92d80ca..7221037 100644 --- a/gtime/plotting/tests/test_preprocessing.py +++ b/gtime/plotting/tests/test_preprocessing.py @@ -7,15 +7,9 @@ from gtime.utils.hypothesis.time_indexes import giotto_time_series, period_indexes from gtime.plotting.preprocessing import ( seasonal_split, - acf, - pacf, _get_cycle_names, _get_season_names, - _autocorrelation, - _normalize, - _solve_yw_equation, _week_of_year, - yule_walker, ) @@ -69,65 +63,3 @@ def test_seasonal_split_shape_named(self, df, cycle, freq, agg): if freq is None: freq = df.index.freqstr assert split.stack().shape == df.resample(freq).agg(agg).dropna().shape - - -class TestAcf: - @given(x=st.lists(st.floats(allow_nan=False), min_size=1)) - def test_autocorrelation(self, x): - autocorr = _autocorrelation(np.array(x)) - expected = np.correlate(x, x, mode="full")[-len(x) :] / len(x) - np.testing.assert_array_equal(autocorr, expected) - - @given( - x=st.lists( - st.floats( - allow_nan=False, allow_infinity=False, max_value=1e20, min_value=1e20 - ), - min_size=1, - ) - ) - def test_scale(self, x): - scaled_x = _normalize(np.array(x)) - assert scaled_x.mean() == pytest.approx(0.0) - assert scaled_x.std() == pytest.approx(1.0) or scaled_x.std() == pytest.approx( - 0.0 - ) - - @given(x=st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=2)) - def test_solve_yw(self, x): - rho = _solve_yw_equation(np.array(x)) - if not np.isnan(np.sum(rho)): - assert len(rho) == len(x) - 1 - - @given( - x=st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=2), - order=st.integers(min_value=1), - ) - def test_yule_walker_abs(self, x, order): - pacf = yule_walker(np.array(x), order) - if not (np.isnan(np.sum(pacf)) or len(pacf) == 0): - assert all(abs(pacf) <= 1) - - @given( - df=giotto_time_series(min_length=1, allow_nan=False, allow_infinity=False), - max_lag=st.one_of(st.integers(min_value=1, max_value=100), st.none()), - ) - def test_acf_len(self, df, max_lag): - df_array = np.ravel(df.values) - res = acf(df_array, max_lag) - if max_lag is None: - max_lag = len(df) - assert len(res) == min(max_lag, len(df)) - - @given( - df=giotto_time_series( - min_length=1, allow_nan=False, allow_infinity=False, max_length=50 - ), - max_lag=st.one_of(st.integers(min_value=1, max_value=100), st.none()), - ) - def test_pacf_len(self, df, max_lag): - df_array = np.ravel(df.values) - res = pacf(df_array, max_lag) - if max_lag is None: - max_lag = len(df) - assert len(res) == min(max_lag, len(df)) diff --git a/gtime/stat_tools/tests/test_tools.py b/gtime/stat_tools/tests/test_tools.py new file mode 100644 index 0000000..f8a7e5f --- /dev/null +++ b/gtime/stat_tools/tests/test_tools.py @@ -0,0 +1,99 @@ +import numpy as np +import pytest +import hypothesis.strategies as st +from hypothesis.extra.numpy import arrays +from hypothesis import given +from gtime.utils.hypothesis.time_indexes import giotto_time_series +from gtime.stat_tools.tools import normalize, autocorrelation, solve_yw_equation, yule_walker, acf, pacf, mat_square, arma_polynomial_roots, loglikelihood_ns + + + +class TestAcf: + @given(x=st.lists(st.floats(allow_nan=False), min_size=1)) + def test_autocorrelation(self, x): + autocorr = autocorrelation(np.array(x)) + expected = np.correlate(x, x, mode="full")[-len(x) :] / len(x) + np.testing.assert_array_equal(autocorr, expected) + + @given( + x=st.lists( + st.floats( + allow_nan=False, allow_infinity=False, max_value=1e20, min_value=1e20 + ), + min_size=1, + ) + ) + def test_scale(self, x): + scaled_x = normalize(np.array(x)) + assert scaled_x.mean() == pytest.approx(0.0) + assert scaled_x.std() == pytest.approx(1.0) or scaled_x.std() == pytest.approx( + 0.0 + ) + + @given(x=st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=2)) + def test_solve_yw(self, x): + rho = solve_yw_equation(np.array(x)) + if not np.isnan(np.sum(rho)): + assert len(rho) == len(x) - 1 + + @given( + x=st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=2), + order=st.integers(min_value=1), + ) + def test_yule_walker_abs(self, x, order): + pacf = yule_walker(np.array(x), order) + if not (np.isnan(np.sum(pacf)) or len(pacf) == 0): + assert all(abs(pacf) <= 1) + + @given( + df=giotto_time_series(min_length=1, allow_nan=False, allow_infinity=False), + max_lag=st.one_of(st.integers(min_value=1, max_value=100), st.none()), + ) + def test_acf_len(self, df, max_lag): + df_array = np.ravel(df.values) + res = acf(df_array, max_lag) + if max_lag is None: + max_lag = len(df) + assert len(res) == min(max_lag, len(df)) + + @given( + df=giotto_time_series( + min_length=1, allow_nan=False, allow_infinity=False, max_length=50 + ), + max_lag=st.one_of(st.integers(min_value=1, max_value=100), st.none()), + ) + def test_pacf_len(self, df, max_lag): + df_array = np.ravel(df.values) + res = pacf(df_array, max_lag) + if max_lag is None: + max_lag = len(df) + assert len(res) == min(max_lag, len(df)) + + +@st.composite +def arma_params(draw, max_dim): + p = draw(st.integers(min_value=0, max_value=max_dim)) + q = draw(st.integers(min_value=0, max_value=max_dim)) + params = draw(arrays(np.float, shape=(p + q + 2), elements=st.floats(min_value=1e-10, max_value=1e10, allow_nan=False, allow_infinity=False))) + return params, p + +class TestMLETools: + @given(m=st.integers(min_value=1, max_value=100), n=st.integers(min_value=1, max_value=100)) + def test_mat_square(self, m, n): + x = np.random.random((m, n)) + q = np.random.random((n, n)) + res = mat_square(q, x) + assert res.shape == (m, m) + + @given(data=arma_params(max_dim=10)) + def test_arma_polynomial_roots_abs(self, data): + params, len_p = data + res = arma_polynomial_roots(params, len_p) + assert all(res >= 0) + + @given(nu=st.floats(allow_nan=False, allow_infinity=False), + F=st.floats(min_value=1e-10, allow_nan=False, allow_infinity=False)) + def test_loglikelihood_ns(self, nu, F): + loglike = loglikelihood_ns(np.array([[nu]]), np.array([[F]])) + expected = -0.5 * (np.log(2 * np.pi * np.abs(F)) + nu*nu/F) + assert float(loglike) == pytest.approx(expected) diff --git a/gtime/stat_tools/tools.py b/gtime/stat_tools/tools.py new file mode 100644 index 0000000..7af03e4 --- /dev/null +++ b/gtime/stat_tools/tools.py @@ -0,0 +1,191 @@ +import numpy as np +from typing import Optional +from scipy.linalg import toeplitz +from scipy.stats import zscore + + +def mat_square(q: np.array, x: np.array): + """ + Quadratic form x'Qx for vector or matrix x + + Parameters + ---------- + x : np.array, variable + q : np.array, coeficient matrix + + Returns + ------- + np.array + + """ + + return np.linalg.multi_dot([x, q, np.transpose(x)]) + + +def loglikelihood_ns(nu: np.array, F: np.array): + + """ + Conditional loglikelihood value for one observation + + Parameters + ---------- + nu : np.array, residual + F : np.array, residual variance matrix + + Returns + ------- + np.array + + """ + + return -0.5 * (np.log(2 * np.pi * np.abs(F)) + mat_square(np.linalg.inv(F), nu)) + + +def arma_polynomial_roots(params: np.array, len_p: int): + """ + Checks stationarity and invertibility of ARMA model returning roots of its backshift operator polynomials. + + Parameters + ---------- + params: np.array, ARMA model parameters: [mu, sigma, phi, theta] + len_p: int, degree of AR, to parse the parameters + + Returns + ------- + np.array, with polynomial roots and ``passing_values`` in place of mu and sigma to satisfy constraints + + """ + passing_value = 2.0 + phi = params[2:2 + len_p] + theta = params[2 + len_p:] + phi_roots = np.abs(np.roots(np.r_[-phi[::-1], 1.0])) + theta_roots = np.abs(np.roots(np.r_[theta[::-1], 1.0])) + return np.r_[passing_value, passing_value, phi_roots, theta_roots] # TODO refactor 2.0 + + +def normalize(x: np.array) -> np.array: + """ + Scales x to mean(x) == 0 and std(x) == 1 + + Parameters + ---------- + x: np.array, array of float to be scaled + + Returns + ------- + np.array, scaled array + + """ + + if len(x) <= 1 or x.std() == 0.0: + return np.zeros(len(x)) + else: + return zscore(x) + + +def autocorrelation(x: np.array) -> np.array: + """ + Autocorrelation via np.correlate for a scaled array `x` + + Parameters + ---------- + x: np.array, input array + + Returns + ------- + np.array, autocorrelation for all lags + + """ + + n = len(x) + return np.correlate(x, x, mode="full")[-n:] / n + + +def solve_yw_equation(r: np.array) -> np.array: + """ + Solution to Yule-Walker equations via Töplitz matrix + + Parameters + ---------- + r: autocorrelation coefficients + + Returns + ------- + np.array: partial autocorrelation function + + """ + + R = toeplitz(r[:-1]) + try: + return np.linalg.solve(R, r[1:]) + except np.linalg.LinAlgError: + print("Solution is not defined for singular matrices") + return [np.nan] + + +def yule_walker(x: np.array, order=1) -> np.array: + + """ Estimate ``order`` parameters from a sequence using the Yule-Walker equations. + http://www-stat.wharton.upenn.edu/~steele/Courses/956/Resource/YWSourceFiles/YW-Eshel.pdf + + Parameters + ---------- + x : np.array, input time series + order : order of the autoregressive process + unbiased : bool, debiasing correction, False by default + + Returns + ------- + rho : np.array, autoregressive coefficients + """ + + if order == 0: + return np.array([1.0]) + + r = autocorrelation(x) + rho = solve_yw_equation(r[: order + 1]) + return rho + + +def pacf(x: np.array, max_lags: Optional[int] = None) -> np.array: + + """Partial autocorrelation estimate based on Yule-Walker equations + + Parameters + ---------- + x : np.array, a time series + max_lags : int, maximum number of lags to be calculated + + Returns + ------- + pacf : np.array, partial autocorrelations for min(max_lags, len(x)) lags, including lag 0 + """ + + n = x.size + if max_lags is None or max_lags > n: + max_lags = n + x = normalize(x) + pacf = np.array([yule_walker(x, i)[-1] for i in range(max_lags)]) + return pacf + + +def acf(x: np.array, max_lags: Optional[int] = None) -> np.array: + + """ Autocorrelation estimate function + + Parameters + ---------- + x : np.array, a time series + max_lags : int, maximum number of lags to be calculated + + Returns + ------- + acf : np.array, partial autocorrelations for min(max_lags, len(x)) lags, including lag 0 + """ + + n = x.size + if max_lags is None or max_lags > n: + max_lags = n + x = normalize(x) + acf = autocorrelation(x) + return acf[:max_lags] \ No newline at end of file From e503b3e870236ae20acaf894208f6b0140ac5b57 Mon Sep 17 00:00:00 2001 From: Simon B Date: Thu, 30 Apr 2020 13:43:54 -0300 Subject: [PATCH 02/23] CSS estimator --- gtime/stat_tools/mle_estimate.py | 70 ++++++++++++++++++++++++++++++++ 1 file changed, 70 insertions(+) create mode 100644 gtime/stat_tools/mle_estimate.py diff --git a/gtime/stat_tools/mle_estimate.py b/gtime/stat_tools/mle_estimate.py new file mode 100644 index 0000000..28209c7 --- /dev/null +++ b/gtime/stat_tools/mle_estimate.py @@ -0,0 +1,70 @@ +import numpy as np +from scipy.optimize import minimize +from scipy.signal import lfilter +from .tools import durbin_levinson_recursion + + +def _run_css(params, X, len_p, errors=False, transform=True): + + mu = params[0] + nobs = len(X) - len_p + if transform: + phi = np.r_[1, -_transform_params(params[2:len_p + 2])] + theta = np.r_[1, _transform_params(params[len_p + 2:])] + else: + phi = np.r_[1, -params[2:len_p + 2]] + theta = np.r_[1, params[len_p + 2:]] + + y = X - mu + init = np.zeros((max(len(phi), len(theta)) - 1)) + for i in range(len_p): + init[i] = sum(-phi[:i + 1][::-1] * y[:i + 1]) + eps = lfilter(phi, theta, y, zi=init)[0][len_p:] + if errors: + return eps + else: + ssr = np.dot(eps, eps) + sigma2 = ssr / nobs + loglikelihood = -nobs / 2. * (np.log(2 * np.pi * sigma2)) - ssr / (2. * sigma2) + return -loglikelihood + + +def _transform_params(param: np.array): + + param = np.tanh(param/2) + return durbin_levinson_recursion(param) + + +class MLEModel: + + def __init__(self, order, method='mle'): + + self.length = max(order[0], order[1] + 1) + self.order = order + self.method = method + p0 = np.random.random(order[0]) #TODO can be better? + q0 = np.random.random(order[1]) + self.parameters = np.r_[0.0, 0.0, p0, q0] + + def fit(self, X): + + mu = X.mean(keepdims=True) + sigma = X.std(keepdims=True) / np.sqrt(len(X)) + self.parameters[0] = mu + self.parameters[1] = sigma + + Xmin = minimize(lambda phi: _run_css(phi, X, len_p=self.order[0]), x0=self.parameters, method='L-BFGS-B') + + fitted_params = Xmin['x'] + self.ml = Xmin['fun'] + self.mu = fitted_params[0] + self.sigma = fitted_params[1] + self.phi = _transform_params(fitted_params[2:self.order[0] + 2]) + self.theta = _transform_params(fitted_params[-self.order[1]:] if self.order[1] > 0 else np.array([])) + self.parameters = np.r_[self.mu, self.sigma, self.phi, self.theta] + return self + + def get_errors(self, X): + + errors = _run_css(self.parameters, X, self.order[0], errors=True, transform=False) + return errors From e888c27281a7a890faf342ded5c6be6a9d858dfe Mon Sep 17 00:00:00 2001 From: Simon B Date: Thu, 30 Apr 2020 17:25:45 -0300 Subject: [PATCH 03/23] Levinson recursion added --- gtime/stat_tools/tools.py | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/gtime/stat_tools/tools.py b/gtime/stat_tools/tools.py index 7af03e4..2212358 100644 --- a/gtime/stat_tools/tools.py +++ b/gtime/stat_tools/tools.py @@ -41,6 +41,31 @@ def loglikelihood_ns(nu: np.array, F: np.array): return -0.5 * (np.log(2 * np.pi * np.abs(F)) + mat_square(np.linalg.inv(F), nu)) +def durbin_levinson_recursion(x: np.array): + """ + Durbin-Levinson algorithm to fix autocorrelation + # TODO theoretical review required + + Parameters + ---------- + x: np.array, input data, model parameters + + Returns + ------- + x: np.array, transformed array + + """ + + t = x.copy() + x = x.copy() + for i in range(1, len(x)): + a = x[i] + for j in range(i): + t[j] += a * x[i - j - 1] + x[:i] = t[:i] + return x + + def arma_polynomial_roots(params: np.array, len_p: int): """ Checks stationarity and invertibility of ARMA model returning roots of its backshift operator polynomials. From e181a8fa485fe3d77be7f2845e836e03c0bed4ff Mon Sep 17 00:00:00 2001 From: Simon B Date: Thu, 30 Apr 2020 18:09:17 -0300 Subject: [PATCH 04/23] ARIMA model --- gtime/forecasting/arima.py | 247 +++++++++++++++++++++++++++++++++++++ 1 file changed, 247 insertions(+) create mode 100644 gtime/forecasting/arima.py diff --git a/gtime/forecasting/arima.py b/gtime/forecasting/arima.py new file mode 100644 index 0000000..a739dae --- /dev/null +++ b/gtime/forecasting/arima.py @@ -0,0 +1,247 @@ +import numpy as np +import pandas as pd +from typing import Tuple +from gtime.forecasting.simple_models import SimpleForecaster +from gtime.stat_tools.mle_estimate import MLEModel # TODO better import + + +def _arma_forecast(n: int, x0: np.array, eps0: np.array, mu: float, phi: np.array, theta: np.array) -> np.array: + """ + Forecasts next ``n`` steps of ARIMA process. + + Parameters + ---------- + n: int, number of steps to forecast + x0: np.array, initial conditions, previous observations for the AR process + eps0: np.array, initial conditions, previous residuals of the MA process + mu: float, process mean + phi: np.array, AR coefficients + theta: np.array, MA coefficients + + Returns + ------- + np.array, ``n``-step forecast + + """ + len_ar = len(phi) + len_ma = len(theta) + phi = phi[::-1] + theta = theta[::-1] + x = np.r_[x0, np.zeros(n)] + eps = np.r_[eps0, np.zeros(n)] + trend = mu * (1 - phi.sum()) + for i in range(n): + x[i + len_ar] = trend + np.dot(phi, x[i:i + len_ar]) + np.dot(theta, eps[i:i + len_ma]) + return x[len_ar:] + + +def _arma_insample_errors(x: np.array, eps0: np.array, mu: float, phi: np.array, theta: np.array) -> np.array: + + """ + Forecasts next ``n`` steps of ARIMA process. + + Parameters + ---------- + x: np.array, test time series + eps0: np.array, initial conditions, previous residuals of the MA process + mu: float, process mean + phi: np.array, AR coefficients + theta: np.array, MA coefficients + + Returns + ------- + eps: np.array, in-sample errors + + """ + + len_ar = len(phi) + len_ma = len(theta) + phi = phi[::-1] + theta = theta[::-1] + n = len(x) - len_ar + x_f = np.zeros(n) + eps = np.r_[eps0, np.zeros(n)] + trend = mu * (1 - phi.sum()) + for i in range(n): + x_f[i] = trend + np.dot(phi, x[i:i + len_ar]) + np.dot(theta, eps[i:i + len_ma]) + eps[i + len_ma] = x[i + len_ar] - x_f[i] + return eps + + +class ARIMAForecaster(SimpleForecaster): + """ + ARIMA forecaster + + Parameters + ---------- + order: Tuple[int, int, int], model order of AR, I and MA + method: str, estimation method + + Examples + -------- + >>> import pandas as pd + >>> import numpy as np + >>> from gtime.model_selection import horizon_shift, FeatureSplitter + >>> from gtime.forecasting import ARIMAForecaster + >>> idx = pd.period_range(start='2011-01-01', end='2012-01-01') + >>> np.random.seed(1) + >>> df = pd.DataFrame(np.random.random((len(idx), 1)), index=idx, columns=['1']) + >>> y = horizon_shift(df, horizon=5) + >>> X_train, y_train, X_test, y_test = FeatureSplitter().transform(df, y) + >>> m = ARIMAForecaster(order=(1, 0, 1), method='css') + >>> m.fit(X_train, y_train).predict(X_test) + y_1 y_2 y_3 y_4 y_5 + 2011-12-28 0.508831 0.508736 0.508830 0.508736 0.508829 + 2011-12-29 0.871837 0.148431 0.866452 0.153777 0.861146 + 2011-12-30 0.119179 0.895486 0.124959 0.889750 0.130652 + 2011-12-31 0.476250 0.541073 0.476733 0.540594 0.477208 + 2012-01-01 0.046294 0.967829 0.053154 0.961020 0.059913 + + """ + + def __init__(self, order: Tuple[int, int, int], method: str = 'css-mle'): + self.order = order + self.max_degree = max(order[0], order[2]) + self.n_ar = order[0] + self.n_ma = order[2] + self.method = method + self.model = None + + def _deintegrate(self, X: np.array) -> np.array: + """ + Desintegrates X returning its difference of ``self.order[1]`` order and recording initial values to ``self.diff_vals`` for invertability + + Parameters + ---------- + X: np.array, input data + + Returns + ------- + X: np.array, difference of ``self.order[1]`` order of X + + """ + n = len(X) + i_order = self.order[1] + target_lenth = n - i_order - self.n_ar + self.diff_vals = np.zeros((target_lenth, i_order)) + for i in range(i_order): + self.diff_vals[:, i] = np.diff(X, n=i)[self.n_ar + 1:self.n_ar + target_lenth + 1] + X = np.diff(X, n=i_order) + return X + + def _integrate(self, X: np.array) -> np.array: + """ + Reverse transformation of ``self._desintegrate(X)``, restores initial order based on ``self.diff_vals`` + + Parameters + ---------- + X: np.array, input data + + Returns + ------- + np.array, integrated time series + + """ + for i in range(self.order[1]): + X = np.concatenate([self.diff_vals[:, [-i-1]], X], axis=1).cumsum(axis=1) + return X + + def _set_params(self, model: MLEModel, x: np.array): + """ + Extracts fitted model parameters for easier access + + Parameters + ---------- + model: MLEModel, fitted model + x: np.array, training series used to calculate residuals + + """ + self.errors_ = model.get_errors(x) + self.mu_ = model.mu + self.phi_ = model.phi + self.theta_ = model.theta + self.model = model + + def fit(self, X: pd.DataFrame, y: pd.DataFrame): + """ + Fit the estimator. + + Parameters + ---------- + X : pd.DataFrame, shape (n_samples, n_features), train sample. + + y : pd.DataFrame, Used to store the predict feature names and prediction horizon. + + Returns + ------- + self : ARIMAForecaster + Returns self. + + """ + len_stored_values = self.n_ar + self.order[1] + self.last_train_values_ = X.iloc[-len_stored_values:] if len_stored_values > 0 else X.iloc[:0] + np_x = X.to_numpy().flatten() + np_x = self._deintegrate(np_x) + model = MLEModel((self.n_ar, self.n_ma), self.method) + model.fit(np_x) + self._set_params(model, np_x) + super().fit(X, y) + return self + + def _extend_x_test(self, X: pd.DataFrame) -> (pd.DataFrame, np.array): + """ + If test time series directly follows the train one, adds last values of train observations and errors for ARIMA forecast. + Otherwise assumes previous observations equal to the first one in test time series. + Future errors are assumed to be 0.0. + + Parameters + ---------- + X: pd.DataFrame, test time series + + Returns + ------- + X: pd.DataFrame, extended time series required for predictions + errors: np.array, error forecast required for predictions + """ + n = len(X) + train_test_diff = X.index.min().start_time - self.last_train_values_.index.max().end_time + if train_test_diff.value == 1: + X = pd.concat([self.last_train_values_, X]) + errors = self.errors_[-self.n_ma:] + else: + last_index = pd.period_range(periods=self.n_ar + self.order[1] + 1, end=X.index[0])[:-1] + last_values = pd.DataFrame([X.iloc[0].values[0]] * len(last_index), index=last_index, columns=X.columns) + X = pd.concat([last_values, X]) + errors = np.zeros(self.n_ma) + return X, errors + + def _predict(self, X: pd.DataFrame) -> np.array: + """ + Create a numpy array of predictions. + + Parameters + ---------- + X: pd.DataFrame, shape (n_samples, 1), required + The time series on which to predict. + + Returns + ------- + np.array + """ + n = len(X) + X, errors = self._extend_x_test(X) + np_x = X.values.flatten() + np_x = self._deintegrate(np_x) + errors = _arma_insample_errors(np_x, errors, self.mu_, self.phi_, self.theta_) + + res = [_arma_forecast(n=self.horizon_, + x0=np_x[i:i+self.n_ar], + eps0=errors[i:i+self.n_ma], + mu=self.model.mu, + phi=self.model.phi, + theta=self.model.theta + ) + for i in range(1, n+1)] + y_pred = self._integrate(np.array(res)) + + return y_pred[:, self.order[1]:] From fc691c990c72dea616b5502bc3e726492e11e11b Mon Sep 17 00:00:00 2001 From: Simon B Date: Thu, 30 Apr 2020 18:12:42 -0300 Subject: [PATCH 05/23] Imports and pipeline --- gtime/forecasting/__init__.py | 2 ++ gtime/time_series_models/__init__.py | 2 ++ gtime/time_series_models/arima.py | 13 +++++++++++++ 3 files changed, 17 insertions(+) create mode 100644 gtime/time_series_models/arima.py diff --git a/gtime/forecasting/__init__.py b/gtime/forecasting/__init__.py index 2810ce8..dd38520 100755 --- a/gtime/forecasting/__init__.py +++ b/gtime/forecasting/__init__.py @@ -13,6 +13,7 @@ DriftForecaster, AverageForecaster, ) +from .arima import ARIMAForecaster __all__ = [ "GAR", @@ -25,4 +26,5 @@ "DriftForecaster", "AverageForecaster", "MultiFeatureMultiOutputRegressor", + "ARIMAForecaster" ] diff --git a/gtime/time_series_models/__init__.py b/gtime/time_series_models/__init__.py index 4a6ea4e..adf7dc8 100644 --- a/gtime/time_series_models/__init__.py +++ b/gtime/time_series_models/__init__.py @@ -4,6 +4,7 @@ from .base import TimeSeriesForecastingModel from .ar import AR +from .arima import ARIMA from .simple_models import ( Naive, SeasonalNaive, @@ -18,4 +19,5 @@ "SeasonalNaive", "Average", "Drift", + "ARIMA" ] diff --git a/gtime/time_series_models/arima.py b/gtime/time_series_models/arima.py new file mode 100644 index 0000000..98eee85 --- /dev/null +++ b/gtime/time_series_models/arima.py @@ -0,0 +1,13 @@ +from gtime.forecasting import ARIMAForecaster +from sklearn.compose import make_column_selector +from gtime.feature_extraction import Shift +from gtime.time_series_models import TimeSeriesForecastingModel + + +class ARIMA(TimeSeriesForecastingModel): + + def __init__(self, horizon: int, order, method): + features = [ + ("s1", Shift(0), make_column_selector()), + ] + super().__init__(features=features, horizon=horizon, model=ARIMAForecaster(order, method)) \ No newline at end of file From ab2c26fb4c2191608776573441e014231efc7aea Mon Sep 17 00:00:00 2001 From: Simon B Date: Thu, 30 Apr 2020 18:25:10 -0300 Subject: [PATCH 06/23] Docstrings and formating --- gtime/stat_tools/mle_estimate.py | 58 ++++++++++++++++++++++++++++++-- gtime/stat_tools/tools.py | 37 -------------------- 2 files changed, 55 insertions(+), 40 deletions(-) diff --git a/gtime/stat_tools/mle_estimate.py b/gtime/stat_tools/mle_estimate.py index 28209c7..3f7b4f7 100644 --- a/gtime/stat_tools/mle_estimate.py +++ b/gtime/stat_tools/mle_estimate.py @@ -4,7 +4,25 @@ from .tools import durbin_levinson_recursion -def _run_css(params, X, len_p, errors=False, transform=True): +def _run_css(params: np.array, X: np.array, len_p: int, errors: bool = False, transform: bool = True): + """ + Conditional sum of squares estimate + http://www.nuffield.ox.ac.uk/economics/papers/1997/w6/ma.pdf + + Parameters + ---------- + params: np.array, ARMA model parameters + X: np.array, training time series + len_p: int, degree of AR, used to parse the params array + errors: bool, whether or not return residuals. -Loglikelihood is returned otherwise + transform: bool, whether to transform AR and MA parameters to impose stationarity and invertability + + Returns + ------- + loglikelihood: float, -ln(likelihood function) + errors: np.array, residuals + """ + mu = params[0] nobs = len(X) - len_p @@ -30,6 +48,18 @@ def _run_css(params, X, len_p, errors=False, transform=True): def _transform_params(param: np.array): + """Transforms parameters to impose stationarity and invertability + Jones, R. H. (1980). Maximum likelihood fitting of ARMA models to time series with missing observations. Technometrics 22, 389-395 + + Parameters + ---------- + param: np.array, initial parameters + + Returns + ------- + np.array, transformed parameters + + """ param = np.tanh(param/2) return durbin_levinson_recursion(param) @@ -46,8 +76,19 @@ def __init__(self, order, method='mle'): q0 = np.random.random(order[1]) self.parameters = np.r_[0.0, 0.0, p0, q0] - def fit(self, X): + def fit(self, X: np.array): + """ + Fits MLE model, maximising likelihood function by selecting model parameters + Parameters + ---------- + X: np.array, training time series + + Returns + ------- + self: MLEModel + + """ mu = X.mean(keepdims=True) sigma = X.std(keepdims=True) / np.sqrt(len(X)) self.parameters[0] = mu @@ -64,7 +105,18 @@ def fit(self, X): self.parameters = np.r_[self.mu, self.sigma, self.phi, self.theta] return self - def get_errors(self, X): + def get_errors(self, X: np.array): + """ + Returns the residuals of ``X`` given fitted model parameters + + Parameters + ---------- + X: np.array, time series + + Returns + ------- + errors: np.array, residuals + """ errors = _run_css(self.parameters, X, self.order[0], errors=True, transform=False) return errors diff --git a/gtime/stat_tools/tools.py b/gtime/stat_tools/tools.py index 2212358..2ba6a82 100644 --- a/gtime/stat_tools/tools.py +++ b/gtime/stat_tools/tools.py @@ -4,43 +4,6 @@ from scipy.stats import zscore -def mat_square(q: np.array, x: np.array): - """ - Quadratic form x'Qx for vector or matrix x - - Parameters - ---------- - x : np.array, variable - q : np.array, coeficient matrix - - Returns - ------- - np.array - - """ - - return np.linalg.multi_dot([x, q, np.transpose(x)]) - - -def loglikelihood_ns(nu: np.array, F: np.array): - - """ - Conditional loglikelihood value for one observation - - Parameters - ---------- - nu : np.array, residual - F : np.array, residual variance matrix - - Returns - ------- - np.array - - """ - - return -0.5 * (np.log(2 * np.pi * np.abs(F)) + mat_square(np.linalg.inv(F), nu)) - - def durbin_levinson_recursion(x: np.array): """ Durbin-Levinson algorithm to fix autocorrelation From f75acb5dc87eb950497e8579c41bcaeeb4aa22b5 Mon Sep 17 00:00:00 2001 From: Simon B Date: Thu, 30 Apr 2020 18:53:02 -0300 Subject: [PATCH 07/23] Tests for helper functions updated --- gtime/stat_tools/tests/test_tools.py | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/gtime/stat_tools/tests/test_tools.py b/gtime/stat_tools/tests/test_tools.py index f8a7e5f..81f3f1a 100644 --- a/gtime/stat_tools/tests/test_tools.py +++ b/gtime/stat_tools/tests/test_tools.py @@ -4,7 +4,7 @@ from hypothesis.extra.numpy import arrays from hypothesis import given from gtime.utils.hypothesis.time_indexes import giotto_time_series -from gtime.stat_tools.tools import normalize, autocorrelation, solve_yw_equation, yule_walker, acf, pacf, mat_square, arma_polynomial_roots, loglikelihood_ns +from gtime.stat_tools.tools import normalize, autocorrelation, solve_yw_equation, yule_walker, acf, pacf, arma_polynomial_roots, durbin_levinson_recursion @@ -78,12 +78,6 @@ def arma_params(draw, max_dim): return params, p class TestMLETools: - @given(m=st.integers(min_value=1, max_value=100), n=st.integers(min_value=1, max_value=100)) - def test_mat_square(self, m, n): - x = np.random.random((m, n)) - q = np.random.random((n, n)) - res = mat_square(q, x) - assert res.shape == (m, m) @given(data=arma_params(max_dim=10)) def test_arma_polynomial_roots_abs(self, data): @@ -91,9 +85,15 @@ def test_arma_polynomial_roots_abs(self, data): res = arma_polynomial_roots(params, len_p) assert all(res >= 0) - @given(nu=st.floats(allow_nan=False, allow_infinity=False), - F=st.floats(min_value=1e-10, allow_nan=False, allow_infinity=False)) - def test_loglikelihood_ns(self, nu, F): - loglike = loglikelihood_ns(np.array([[nu]]), np.array([[F]])) - expected = -0.5 * (np.log(2 * np.pi * np.abs(F)) + nu*nu/F) - assert float(loglike) == pytest.approx(expected) + @given(x=arrays(dtype=float, shape=st.integers(min_value=1, max_value=10), + elements=st.floats(allow_nan=False, allow_infinity=False, min_value=-1, max_value=1, exclude_min=True, exclude_max=True))) + def test_durbin_levinson_recursion(self, x): + transformed_x = durbin_levinson_recursion(x) + y = transformed_x.copy() + y2 = transformed_x.copy() + for j in range(len(y) - 1, 0, -1): + b = y[j] + for kiter in range(j): + y2[kiter] = (y[kiter] - b * y[j - kiter - 1]) / (1 - b ** 2) + y[:j] = y2[:j] + np.testing.assert_array_almost_equal(x, y, decimal=4) From 05e3c8addced514a7219dd1af6972a9254700d79 Mon Sep 17 00:00:00 2001 From: Simon B Date: Mon, 20 Apr 2020 12:17:18 -0300 Subject: [PATCH 08/23] Description --- examples/ARIMA documentation.ipynb | 372 +++++++++++++++++++++++++++++ 1 file changed, 372 insertions(+) create mode 100644 examples/ARIMA documentation.ipynb diff --git a/examples/ARIMA documentation.ipynb b/examples/ARIMA documentation.ipynb new file mode 100644 index 0000000..9ce4d54 --- /dev/null +++ b/examples/ARIMA documentation.ipynb @@ -0,0 +1,372 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Problem formulation" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-14T18:44:30.927583Z", + "start_time": "2020-04-14T18:44:30.912369Z" + } + }, + "source": [ + "## Basic ARMA model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Basic ARMA(p, q) model can be presented as:\n", + " \\begin{equation}\n", + " x_t = \\mu + \\varepsilon_t + \\sum_{i=1}^p \\phi_i x_{t-i} + \\sum_{i=1}^q \\theta_i e_{t-i}\n", + " \\end{equation}\n", + "where $\\varepsilon_i$ are error terms which are expected to form a white noise process (i.e. are independent identically distributed random variables with $\\varepsilon_i \\sim N(0, \\sigma^2)$).\n", + "The key obstacle in analysing and fitting an ARMA model is that error terms $\\varepsilon_i$ are not observable, nor can they be simply calculated as it is in case of, for example, linear regression ($\\varepsilon = Y - \\alpha - \\beta X$). The equation above \n", + " \\begin{equation}\n", + " \\varepsilon_t = x_t - (\\mu + \\sum_{i=1}^p \\phi_i x_{t-i} + \\sum_{i=1}^q \\theta_i e_{t-i})\n", + " \\end{equation}\n", + "essencially makes $\\varepsilon_t$ a function of $\\{\\varepsilon_{t-1}...\\varepsilon_{t-p}\\}$ which, in turn, can only be calculated recursivelly through previous values of $\\varepsilon$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Likelihood function" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to fit the model to available data $X_n = \\{X_1, ..., X_n\\}$ and find optimal parameters $\\mu, \\sigma, \\phi, \\theta$ we need to maximize the likelihood function, which means to find a set of parameters, for which the joint probability of $\\{X_1, ..., X_n\\}$ is the highest:\n", + " \\begin{equation}\n", + " L = f(X_n | \\mu, \\sigma, \\phi, \\theta)\n", + " \\end{equation}\n", + "which is, from what we know of conditional probabilities, equivalent to:\n", + " \\begin{equation}\n", + " L = \\prod_{i=1}^n f(X_i | X_{i-1}, \\mu, \\sigma, \\phi, \\theta)\n", + " \\end{equation}\n", + "or\n", + " \\begin{equation}\n", + " l = \\ln(L) = \\sum_{i=1}^n f(X_i | X_{i-1}, \\mu, \\sigma, \\phi, \\theta)\n", + " \\end{equation}\n", + "If we assume that the errors $\\varepsilon$ are Gaussian then $x_t$ are also expected to be Gaussian as a linear combination of $\\varepsilon$, $x_0$ and some fixed model parameters. Which means that:\n", + " \\begin{equation}\n", + " l = \\sum_{i=1}^n -\\frac{1}{2} \\big( \\ln(2\\pi|F_i|) + \\nu_i F_i^{-1}\\nu_i \\big) \n", + " \\end{equation}\n", + "where\n", + " \\begin{equation}\n", + " \\nu_t = x_t - E(x_t|x_1...x_{t-1}) \\quad and \\quad F_t = E(\\nu_t \\nu_t' |x_1...x_{t-1}).\n", + " \\end{equation}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# State space representation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "The problem can be reformulated in matrix form using a state space representation with $m$-dimensional vectors $\\alpha_t$ such that:\n", + " \\begin{equation}\n", + " \\alpha_t^i = \\phi_i x_{t-1} + \\alpha_{t-1}^i + \\theta_{i-1} \\varepsilon_t\n", + " \\end{equation}\n", + "where $m = \\max(p, q+1)$ and where the coefficients $\\phi_i$ for $p*Here I interpret $\\varepsilon_t$ as a vector of errors while $R$ is a square matrix. In literature it is also shown as a vector of $\\theta$ multiplied by a constant error but in this case Kalman filter update equation would have a dimensionality mismatch." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Kalman filter" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Kalman filter is a recursive algorithm which allows us to forecast the distribution of $x_t | x_1...x_{t-1}$ so that we can calculate $\\nu_t$ and $F_t$ and the likelihood function. The algorithm works with $\\alpha_t$ and consists of two steps:\n", + "- predicting the estimate for the next $\\alpha_t$ and its correlation matrix $P_t$ :\n", + " \\begin{equation}\n", + " \\hat{\\alpha_t} = K\\alpha_{t-1} \\\\\n", + " \\hat{P_t} = KP_{t-1}K' + RQR' \\\\\n", + " \\hat{x_t} = Z\\hat{a_t} + \\mu\n", + " \\end{equation}\n", + "- updating the values of $\\alpha_t$ and $P_t$ based on actual $x_t$:\n", + " \\begin{equation}\n", + " \\Gamma_t = \\hat{P_t} Z' F_t^{-1} \\\\\n", + " P_{t} = \\hat{P_t} - \\Gamma_t Z \\hat{P_t}'\\\\\n", + " \\alpha_t = \\hat{\\alpha_t} + \\Gamma_t \\nu_t\n", + " \\end{equation}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$\\nu$ and $F$ obtained via Kalman filter procedure\n", + " \\begin{equation}\n", + " \\nu_t = x_t - \\hat{x_t} \\\\\n", + " F = Z \\hat{P_t} Z' \\\\\n", + " \\end{equation}\n", + "allow us to calculate $l$ and thus to minimize it using one of the numerical minimization algorithms." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "code_folding": [ + 2 + ] + }, + "outputs": [], + "source": [ + "class KalmanFilter:\n", + "\n", + " def __init__(self, mu, sigma, phi, theta):\n", + " self.phi = phi\n", + " self.theta = theta\n", + " self.mu = mu\n", + " self.sigma = sigma\n", + " m = len(phi)\n", + " R = np.concatenate((np.ones(1), self.theta[:-1]))\n", + " self.R = np.diag(R)\n", + " K = np.concatenate((self.phi[:-1].reshape((-1, 1)), np.identity(m - 1)), axis=1)\n", + " self.K = np.concatenate((K, np.concatenate((self.phi[-1:], np.zeros(m - 1))).reshape(1, -1)))\n", + " self.Q = sigma ** 2 * np.identity(m)\n", + " self.Z = np.zeros((1, m))\n", + " self.Z[0, 0] = 1.0\n", + "\n", + " def update(self, a_hat, p_hat, F, nu):\n", + " gain = multi_dot([p_hat, np.transpose(self.Z), np.linalg.inv(F)])\n", + " a = a_hat + multi_dot([gain, nu])\n", + " p = p_hat - multi_dot([gain, self.Z, np.transpose(p_hat)])\n", + " return a, p\n", + "\n", + " def predict(self, a, p, x):\n", + " a_hat = np.matmul(self.K, a)\n", + " p_hat = mat_square(p, self.K) + mat_square(self.Q, self.R)\n", + " x_hat = np.matmul(self.Z, a_hat) + self.mu\n", + " F = mat_square(p_hat, self.Z)\n", + " nu = x - x_hat\n", + " return a_hat, p_hat, x_hat, F, nu" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def _likelihood(X, mu, sigma, phi, theta, errors=False):\n", + "\n", + " loglikelihood = 0.0\n", + " m = phi.size\n", + " kalman = KalmanFilter(mu, sigma, phi, theta)\n", + " p = np.identity(m)\n", + " a = np.zeros((m, 1))\n", + " eps = np.zeros(len(X))\n", + " for i, x in enumerate(X):\n", + " a_hat, p_hat, x_hat, F, nu = kalman.predict(a, p, x)\n", + " LL_last = -0.5 * (np.log(2 * np.pi * np.abs(F)) + mat_square(np.linalg.inv(F), nu))\n", + " a, p = kalman.update(a_hat, p_hat, F, nu)\n", + " eps[i] = nu\n", + " loglikelihood += LL_last\n", + " if errors:\n", + " return eps\n", + " else:\n", + " return -float(loglikelihood)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conditional sum of squares (CSS)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Conditional sum of squares is a simplification of state space representation with an assumption that initial unobserved value of $\\alpha_0$ is known (for example $\\alpha_0 = 0$). In this case instead of estimating both expected value and covariance matrix of $\\alpha_t$ we can perform explicit calculations:\n", + "\\begin{equation}\n", + "\\varepsilon^*_t = x_t - Z\\hat{\\alpha_t} - \\mu \\quad \\text{where} \\quad \\hat{\\alpha_t} = K \\hat{\\alpha_{t-1}} + K R \\varepsilon^*_{t-1}\n", + "\\end{equation}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "and thus:\n", + " \\begin{equation}\n", + " l = \\sum_{i=1}^n -\\frac{1}{2} \\big( \\ln(2\\pi\\sigma^2) + \\frac{\\varepsilon_i^* \\varepsilon_i^*}{\\sigma^2} \\big)\n", + " = -\\frac{1}{2} \\big( n \\ln(2\\pi\\sigma^2) + \\frac{1}{\\sigma^2} \\sum_{i=1}^n \\varepsilon_i^{*2} \\big)\n", + " \\end{equation}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I still don't fully understand how these manipulations turned $F$ (which is $\\hat{P}[1, 1]$) into a simple $\\sigma$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "which is a much simple model yet it is proven to asymptotically converge to MLE estimates[6].\n", + "Recursive error calculation can be represented as an IIR filter[7] where $x_t$ is an input signal and $\\varepsilon^*_t$ is output signal. It allows us to use ``lfilter()`` from ``scipy.signal`` package which performs such calculation effeciently." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def _run_css(params, X, len_p, errors=False, transform=True):\n", + "\n", + " if len(params.shape) > 1:\n", + " print(params.shape)\n", + "\n", + " mu = params[0]\n", + " nobs = len(X) - len_p\n", + " phi = np.r_[1, params[2:len_p + 2]]\n", + " theta = np.r_[1, params[len_p + 2:]]\n", + "\n", + " y = X - mu\n", + " eps = lfilter(phi, theta, y)\n", + " if errors:\n", + " return eps\n", + " else:\n", + " ssr = np.dot(eps, eps)\n", + " sigma2 = ssr / nobs\n", + " loglikelihood = -nobs / 2. * (np.log(2 * np.pi * sigma2)) - ssr / (2. * sigma2)\n", + " return -loglikelihood" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Stationarity and invertability" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Arima model is stationary if absolute value of all the roots of the polynom:\n", + "\\begin{equation}\n", + " \\phi(z) = 1 - \\sum_{i=1}^{p}\\phi_i z^i\n", + "\\end{equation}\n", + "is greater than 1." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Arima model is invertible (i.e. can be converted to an AR($\\infty$) model) if absolute value of all the roots of the polynom:\n", + "\\begin{equation}\n", + " \\theta(z) = 1 + \\sum_{i=1}^{p}\\theta_i z^i\n", + "\\end{equation}\n", + "is greater than 1." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Materials:\n", + " 1. https://otexts.com/fpp2/non-seasonal-arima.html - basic problem formulation\n", + " 2. https://uh.edu/~bsorense/kalman.pdf - \n", + " 3. https://www.stat.purdue.edu/~chong/stat520/ps/statespace.pdf\n", + " 4. http://www.stat.ucla.edu/~frederic/221/W17/221ch3.pdf\n", + " 5. https://github.com/rlabbe/Kalman-and-Bayesian-Filters-in-Python - general information about filters\n", + " 6. https://www.nuffield.ox.ac.uk/economics/Papers/1997/w6/ma.pdf - relationship between CSS and MLE\n", + " 7. https://en.wikipedia.org/wiki/Infinite_impulse_response - general information on IIR\n", + " 8. http://www-stat.wharton.upenn.edu/~stine/stat910/lectures/08_intro_arma.pdf - general ARIMA information + stationarity conditions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "giotto", + "language": "python", + "name": "giotto" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From ee025be8835749ffaacd5ffe6aa4bf8af9e413d0 Mon Sep 17 00:00:00 2001 From: Simon B Date: Wed, 22 Apr 2020 16:22:47 -0300 Subject: [PATCH 09/23] Description update --- examples/ARIMA documentation.ipynb | 62 ++++++++++++++++++++++++------ 1 file changed, 50 insertions(+), 12 deletions(-) diff --git a/examples/ARIMA documentation.ipynb b/examples/ARIMA documentation.ipynb index 9ce4d54..3f9ca18 100644 --- a/examples/ARIMA documentation.ipynb +++ b/examples/ARIMA documentation.ipynb @@ -68,6 +68,18 @@ " \\end{equation}" ] }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-20T23:33:15.417663Z", + "start_time": "2020-04-20T23:33:15.371065Z" + } + }, + "source": [ + "*Something about replacing $F_t$ with $\\sigma^2$..." + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -83,9 +95,9 @@ "\n", "The problem can be reformulated in matrix form using a state space representation with $m$-dimensional vectors $\\alpha_t$ such that:\n", " \\begin{equation}\n", - " \\alpha_t^i = \\phi_i x_{t-1} + \\alpha_{t-1}^i + \\theta_{i-1} \\varepsilon_t\n", + " \\alpha_t^i = \\phi_i x_{t-1} + \\alpha_{t-1}^{i+1} + \\theta_{i-1} \\varepsilon_t\n", " \\end{equation}\n", - "where $m = \\max(p, q+1)$ and where the coefficients $\\phi_i$ for $p*Here I interpret $\\varepsilon_t$ as a vector of errors while $R$ is a square matrix. In literature it is also shown as a vector of $\\theta$ multiplied by a constant error but in this case Kalman filter update equation would have a dimensionality mismatch." + " or $x_t = Z \\alpha_t + \\mu$ where $Z = \\begin{bmatrix}1 & 0 & ... & 0 \\end{bmatrix}$.\n", + " " ] }, { @@ -154,7 +164,7 @@ "$\\nu$ and $F$ obtained via Kalman filter procedure\n", " \\begin{equation}\n", " \\nu_t = x_t - \\hat{x_t} \\\\\n", - " F = Z \\hat{P_t} Z' \\\\\n", + " F_t = Z \\hat{P_t} Z' \\\\\n", " \\end{equation}\n", "allow us to calculate $l$ and thus to minimize it using one of the numerical minimization algorithms." ] @@ -163,9 +173,7 @@ "cell_type": "code", "execution_count": null, "metadata": { - "code_folding": [ - 2 - ] + "code_folding": [] }, "outputs": [], "source": [ @@ -226,6 +234,35 @@ " return -float(loglikelihood)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Initial conditions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As it is shown in (9) initial conditions of Kalman filter process for atationary ARMA model can be estimated as:\n", + "\\begin{equation}\n", + "\\alpha_1 \\sim N(0, \\sigma^2 Q_0) \n", + "\\end{equation}\n", + "where $Q_0$ is obtained from $m^2$-dimensional equation:\n", + "\\begin{equation}\n", + "vec(Q_0) = vec(RR') (I_{m^2} - K \\otimes K)^{-1}\n", + "\\end{equation}\n", + "where $\\otimes$ is Kronecker product and $vec(x)$ is a stacked vector of columns of $x$. It means that\n", + "\\begin{equation}\n", + "\\alpha_1 = \\begin{bmatrix}\n", + "0 \\\\ ... \\\\ 0 \n", + "\\end{bmatrix} \n", + "\\quad and \\quad\n", + "P_1 = \\sigma^2 Q_0.\n", + "\\end{equation}" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -337,7 +374,8 @@ " 5. https://github.com/rlabbe/Kalman-and-Bayesian-Filters-in-Python - general information about filters\n", " 6. https://www.nuffield.ox.ac.uk/economics/Papers/1997/w6/ma.pdf - relationship between CSS and MLE\n", " 7. https://en.wikipedia.org/wiki/Infinite_impulse_response - general information on IIR\n", - " 8. http://www-stat.wharton.upenn.edu/~stine/stat910/lectures/08_intro_arma.pdf - general ARIMA information + stationarity conditions" + " 8. http://www-stat.wharton.upenn.edu/~stine/stat910/lectures/08_intro_arma.pdf - general ARIMA information + stationarity conditions\n", + " 9. Time Series Analysis by State Space Methods by J. Durbin and S.J. Koopman " ] }, { From 46dbb49ec3b8b5ff040ef20215bf63e07c9dce94 Mon Sep 17 00:00:00 2001 From: Simon B Date: Thu, 30 Apr 2020 19:09:07 -0300 Subject: [PATCH 10/23] Test notebook --- examples/ARIMA documentation.ipynb | 19 - examples/arima-tests.ipynb | 928 +++++++++++++++++++++++++++++ 2 files changed, 928 insertions(+), 19 deletions(-) create mode 100644 examples/arima-tests.ipynb diff --git a/examples/ARIMA documentation.ipynb b/examples/ARIMA documentation.ipynb index 3f9ca18..6a7cf57 100644 --- a/examples/ARIMA documentation.ipynb +++ b/examples/ARIMA documentation.ipynb @@ -68,18 +68,6 @@ " \\end{equation}" ] }, - { - "cell_type": "markdown", - "metadata": { - "ExecuteTime": { - "end_time": "2020-04-20T23:33:15.417663Z", - "start_time": "2020-04-20T23:33:15.371065Z" - } - }, - "source": [ - "*Something about replacing $F_t$ with $\\sigma^2$..." - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -291,13 +279,6 @@ " \\end{equation}" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "I still don't fully understand how these manipulations turned $F$ (which is $\\hat{P}[1, 1]$) into a simple $\\sigma$" - ] - }, { "cell_type": "markdown", "metadata": {}, diff --git a/examples/arima-tests.ipynb b/examples/arima-tests.ipynb new file mode 100644 index 0000000..2997c37 --- /dev/null +++ b/examples/arima-tests.ipynb @@ -0,0 +1,928 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-30T22:04:14.049436Z", + "start_time": "2020-04-30T22:04:14.040417Z" + }, + "scrolled": true + }, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.append('../')\n", + "import numpy as np\n", + "np.set_printoptions(precision=2)\n", + "import pandas as pd\n", + "from statsmodels.tsa.arima_model import ARIMA as ARIMA_sm\n", + "from gtime.preprocessing import TimeSeriesPreparation\n", + "from gtime.time_series_models import ARIMA, AR\n", + "from sklearn.compose import make_column_selector\n", + "from gtime.feature_extraction import Shift\n", + "from sklearn.metrics import mean_squared_error\n", + "from scipy.stats import normaltest\n", + "from numpy.linalg import multi_dot\n", + "from scipy.linalg import toeplitz\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-16T19:44:20.066710Z", + "start_time": "2020-04-16T19:44:20.055096Z" + } + }, + "source": [ + "## TIme series" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-30T22:03:45.008193Z", + "start_time": "2020-04-30T22:03:43.691450Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df_sp = pd.read_csv('https://storage.googleapis.com/l2f-open-models/giotto-time/examples/data/^GSPC.csv', parse_dates=['Date'])\n", + "df_close = df_sp.set_index('Date')['Close']\n", + "time_series_preparation = TimeSeriesPreparation()\n", + "df_real = time_series_preparation.transform(df_close)\n", + "\n", + "df_real.plot();" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-30T22:03:45.623887Z", + "start_time": "2020-04-30T22:03:45.023073Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df_white = pd.DataFrame(np.random.standard_normal(500))\n", + "time_series_preparation = TimeSeriesPreparation(start='01-01-2010', freq='1D')\n", + "df_white = time_series_preparation.transform(df_white)\n", + "\n", + "df_white.plot();" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-30T22:03:46.053057Z", + "start_time": "2020-04-30T22:03:45.659585Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "arm_np = np.zeros(501)\n", + "mean = 0.0\n", + "ar = -.4\n", + "ma = -.7\n", + "eps = np.random.standard_normal()\n", + "for i in range(1, 501):\n", + " arm_np[i] = mean + ar * arm_np[i-1] + ma * eps\n", + " eps = np.random.standard_normal()\n", + "arima_np = arm_np.cumsum()\n", + "df_arima = pd.DataFrame(arima_np)\n", + "time_series_preparation = TimeSeriesPreparation(start='01-01-2010', freq='1D')\n", + "df_arima = time_series_preparation.transform(df_arima)\n", + "df_arima.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Test functions" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-30T22:03:46.070766Z", + "start_time": "2020-04-30T22:03:46.055277Z" + } + }, + "outputs": [], + "source": [ + "def train_test_plot(df_train, df_test, df_pred, train_error, test_error):\n", + " fig, ax = plt.subplots(1, 3, figsize=(15, 5))\n", + " df_train.plot(ax=ax[0])\n", + " df_test.plot(ax=ax[0])\n", + " df_pred.plot(ax=ax[0])\n", + " ax[1].hist(train_error)\n", + " ax[2].hist(test_error)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-30T22:04:16.993064Z", + "start_time": "2020-04-30T22:04:16.694642Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Basic AR results results:\n", + "Fitted parameters: mu=-0.02, p=[-0.04 0.01 0.02 -0.01]\n", + "RMSE: 1.12\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "array([-0.04, 0.01, 0.02, -0.01])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def run_giotto_ar(df, test_size, p):\n", + " model = AR(horizon=test_size, p=p)\n", + " df_train = df\n", + " df_test = df.iloc[-test_size:]\n", + " model = model.fit(df_train)\n", + " pred_g = model.predict()\n", + " y_pred = pd.DataFrame(pred_g.values[0], index=df_test.index, columns=['time_series'])\n", + " print('Basic AR results results:')\n", + " print(f'Fitted parameters: mu={model.model.estimators_[0].intercept_:.2f}, p={model.model.estimators_[0].coef_}')\n", + " print(f'RMSE: {mean_squared_error(y_pred, df_test.values):.2f}\\n')\n", + " return model.model.estimators_[0].coef_\n", + "\n", + "mar = run_giotto_ar(df_white, 100, 4)\n", + "mar" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-30T22:04:03.459274Z", + "start_time": "2020-04-30T22:04:02.507938Z" + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Giotto results mle:\n", + "Fitted parameters: mu=-0.00, p=[-0.94], q=[-0.06 -1. 0.03 0.03]\n", + "AR roots abs:[1.06]\n", + "MA roots abs:[5.76 4.86 1.04 1. ]\n", + "Train error mean: -0.45, std: 20.82\n", + "LL: 5150.12\n", + "RMSE: 46634.80\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def run_giotto_arima(df, test_size, order, method='css-mle', plot=True):\n", + " model = ARIMA(horizon=test_size, order=order, method=method)\n", + " df_train = df\n", + " df_test = df.iloc[-test_size:]\n", + " model.fit(df_train)\n", + " pred_g = model.predict(df_test.iloc[[0]])\n", + " y_pred = pd.DataFrame(pred_g.values[0], index=df_test.index, columns=['time_series'])\n", + " phi = model.model.phi_\n", + " theta = model.model.theta_\n", + " mu = model.model.mu_\n", + " train_errors = model.model.errors_\n", + " print(f'Giotto results {method}:')\n", + " print(f'Fitted parameters: mu={mu:.2f}, p={phi}, q={theta}')\n", + " print(f'AR roots abs:{np.abs(np.roots(np.r_[-phi[::-1], 1.0]))}')\n", + " print(f'MA roots abs:{np.abs(np.roots(np.r_[theta[::-1], 1.0]))}')\n", + " print(f'Train error mean: {train_errors.mean():.2f}, std: {train_errors.std():.2f}')\n", + " print(f'LL: {model.model.model.ml:.2f}')\n", + " print(f'RMSE: {mean_squared_error(y_pred, df_test.values):.2f}\\n')\n", + " if plot:\n", + " test_errors = df_test - y_pred\n", + " train_test_plot(df_train, df_test, y_pred, train_errors, test_errors.values)\n", + " return mu, phi, theta\n", + " \n", + "mu, phi, theta = run_giotto_arima(df_real, 100, (1, 2, 4), 'css')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-30T22:04:25.565186Z", + "start_time": "2020-04-30T22:04:24.633139Z" + }, + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Statsmodels results css:\n", + "Fitted parameters: mu=-0.00, p=[-0.94], q=[-0.06 -1. 0.03 0.03]\n", + "AR roots abs:[1.06]\n", + "MA roots abs:[1. 1.04 4.86 5.76]\n", + "Train error mean: -0.45, std: 20.82\n", + "LL: 5150.12\n", + "RMSE: 49918.90\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def run_sm(df, test_size, order, method='css-mle', plot=True):\n", + " df_train = df.iloc[:-test_size]\n", + " df_test = df.iloc[-test_size:]\n", + " m2 = ARIMA_sm(df_train, order)\n", + " f = m2.fit(method=method)\n", + " y2, _, _ = f.forecast(test_size)\n", + " y_pred = pd.DataFrame(y2, index=df_test.index, columns=['Forecast'])\n", + " print(f'Statsmodels results {method}:')\n", + " print(f'Fitted parameters: mu={f.params.const:.2f}, p={f.arparams}, q={f.maparams}')\n", + " print(f'AR roots abs:{np.abs(f.arroots)}')\n", + " print(f'MA roots abs:{np.abs(f.maroots)}')\n", + " train_errors = m2.geterrors(f.params)\n", + " print(f'Train error mean: {train_errors.mean():.2f}, std: {train_errors.std():.2f}')\n", + " print(f'LL: {-f.llf:.2f}')\n", + " print(f'RMSE: {mean_squared_error(y2, df_test.values):.2f}\\n')\n", + "# print(normaltest(train_errors))\n", + " if plot:\n", + " test_errors = df_test.values.flatten() - y2\n", + " train_test_plot(df_train, df_test, y_pred, train_errors, test_errors)\n", + " return f, m2\n", + "\n", + "f = run_sm(df_real, 100, (1, 2, 4), 'css')" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-30T22:06:37.630038Z", + "start_time": "2020-04-30T22:06:37.617303Z" + } + }, + "outputs": [], + "source": [ + "def run_tests(df, order):\n", + " run_sm(df, 100, order, 'css', plot=True);\n", + "# run_sm(df, 100, order, 'mle', plot=False);\n", + " run_giotto_arima(df, 100, order, 'css', plot=True);\n", + "# run_giotto_arima(df, 100, order, 'mle', plot=False);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Simple AR check" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-30T22:07:05.061525Z", + "start_time": "2020-04-30T22:07:03.277417Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Basic AR results results:\n", + "Fitted parameters: mu=-0.02, p=[-0.03 0.01]\n", + "RMSE: 1.11\n", + "\n", + "Statsmodels results css:\n", + "Fitted parameters: mu=-0.02, p=[-0.03 0.01], q=[]\n", + "AR roots abs:[ 8.15 11.34]\n", + "MA roots abs:[]\n", + "Train error mean: 0.00, std: 0.96\n", + "LL: 550.05\n", + "RMSE: 1.10\n", + "\n", + "Giotto results css:\n", + "Fitted parameters: mu=-0.02, p=[-0.03 0.01], q=[]\n", + "AR roots abs:[11.34 8.15]\n", + "MA roots abs:[]\n", + "Train error mean: 0.00, std: 0.96\n", + "LL: 550.05\n", + "RMSE: 1.10\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df = df_white\n", + "order = (2, 0, 0)\n", + "run_giotto_ar(df, 100, 2)\n", + "run_tests(df, order)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-30T22:06:57.988638Z", + "start_time": "2020-04-30T22:06:56.238373Z" + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Basic AR results results:\n", + "Fitted parameters: mu=3.58, p=[0.98 0.02]\n", + "RMSE: 44772.60\n", + "\n", + "Statsmodels results css:\n", + "Fitted parameters: mu=3261.40, p=[0.98 0.02], q=[]\n", + "AR roots abs:[ 1. 49.74]\n", + "MA roots abs:[]\n", + "Train error mean: -0.02, std: 20.81\n", + "LL: 5153.70\n", + "RMSE: 52639.91\n", + "\n", + "Giotto results css:\n", + "Fitted parameters: mu=2442.07, p=[0.98 0.02], q=[]\n", + "AR roots abs:[53.98 1. ]\n", + "MA roots abs:[]\n", + "Train error mean: 0.80, std: 20.81\n", + "LL: 5154.55\n", + "RMSE: 63810.54\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df = df_real\n", + "order = (2, 0, 0)\n", + "run_giotto_ar(df, 100, 2)\n", + "run_tests(df, order)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Simple ARI check" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-30T22:07:16.405933Z", + "start_time": "2020-04-30T22:07:14.892834Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Statsmodels results css:\n", + "Fitted parameters: mu=-0.00, p=[-0.71 -0.36], q=[]\n", + "AR roots abs:[1.68 1.68]\n", + "MA roots abs:[]\n", + "Train error mean: 0.00, std: 1.11\n", + "LL: 604.02\n", + "RMSE: 1.14\n", + "\n", + "Giotto results css:\n", + "Fitted parameters: mu=-0.00, p=[-0.68 -0.32], q=[]\n", + "AR roots abs:[1.76 1.76]\n", + "MA roots abs:[]\n", + "Train error mean: 0.00, std: 1.11\n", + "LL: 604.32\n", + "RMSE: 1.12\n", + "\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2kAAAE6CAYAAACMDRrWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOy9eZwcVbn//3m6Z8u+MUAWIPGCIJINAogBFYIJyKbI6nLBrxpU9KeiuYSLrIIGQb33IosoMYCAQBRQEyUIxIiBrIRkICGThIFMFjLZZyaZme6u8/ujq7prObX0Mt09yef9euF0V50656nqzng+82yilAIhhBBCCCGEkMogVm4DCCGEEEIIIYRkoUgjhBBCCCGEkAqCIo0QQgghhBBCKgiKNEIIIYQQQgipICjSCCGEEEIIIaSCqCrHoocccogaOXJkOZYmhHQTy5Yt266Uqi+3HYXA302EHJjw9xMhpBIJ+t1UFpE2cuRILF26tBxLE0K6CRF5r9w2FAp/NxFyYMLfT4SQSiTodxPDHQkhhBBCCCGkgqBII4QQQgghhJAKgiKNEEIIIYQQQiqIsuSk6UgkEmhubkZHR0e5TTkoqKurw4gRI1BdXV1uUwghhBBCCCE2KkakNTc3o1+/fhg5ciREpNzmHNAopbBjxw40Nzdj1KhR5TaHEEIIIYQQYqNiwh07OjowZMgQCrQSICIYMmQIvZaEEEIIIYRUIBUj0gBQoJUQPmtCCCGEEEIqk4oSaYQQQgghhBBysEORRgghhBBCCCEVBEWaye7du3H//fcDADZv3oxLLrmkzBb58/GPf7zcJhBCCCGEEEK6CYo0E7tIGzZsGGbPnl1mi7wkk0kAwMKFC8tsCQliadNOjJw+Bxt37iu3KYQQQgghpAdSMSX47dz2l7fw9ua9RZ3z+GH9ccsFH/U9P336dKxfvx7jxo3DMcccg9WrV6OhoQGzZs3Cc889h/b2djQ2NuKHP/whurq68Nhjj6G2thZz587F4MGDsX79elx77bVoaWlB79698Zvf/AbHHXecdq1nnnkGt912G+LxOAYMGIAFCxYglUph+vTpmD9/Pjo7O3Httdfimmuuwfz583HTTTdh0KBBWLNmDdauXYu+ffuira0NAHD33Xfj6aefRmdnJz73uc/htttuQ3t7Oy677DI0NzcjlUrhpptuwuWXX17U50n8eXrpRgDAv9dtxxWnHFlmawghOkZOn9NtczfNOK/b5iaEHPh01+8n/m7qWVSkSCsHM2bMQENDA1asWIGmpiacf/75mXMNDQ1444030NHRgaOPPhp33XUX3njjDXz/+9/Ho48+iu9973uYOnUqHnzwQRxzzDFYtGgRvvWtb+Hll1/WrnX77bfjhRdewPDhw7F7924AwMMPP4wBAwZgyZIl6OzsxMSJEzF58mQAwPLly9HQ0ODpaTZv3jw0NjZi8eLFUErhwgsvxIIFC9DS0oJhw4Zhzpz0P/I9e/Z0xyMjPghYOZMQQgghhORPRYq0II9XOTjzzDPRr18/9OvXDwMGDMAFF1wAABg9ejRWrlyJtrY2LFy4EJdeemnmms7OTt/5Jk6ciKuvvhqXXXYZLr74YgBpwbVy5cpMmOWePXvQ2NiImpoanHLKKdqm0/PmzcO8efMwfvx4AEBbWxsaGxtxxhln4Ac/+AGuv/56nH/++TjjjDOK9iwIIYQQQggh3UtFirRKo7a2NvM6Fotl3sdiMSSTSRiGgYEDB2LFihWR5nvwwQexaNEizJkzByeddBKWLVsGpRTuvfdeTJkyxTF2/vz56NOnj3YepRRuuOEGXHPNNZ5zy5cvx9y5c/GjH/0IkyZNws033xz1dgkhhBBCCCFlhIVDTPr164fW1ta8ru3fvz9GjRqFZ555BkBaPL355pu+49evX49TTz0Vt99+O+rr67Fx40ZMmTIFDzzwABKJBABg7dq1aG9vD1x3ypQpmDlzZiY/bdOmTdi2bRs2b96M3r1740tf+hKmTZuG5cuX53VfpDBUuQ0ghBBCCCE9EnrSTIYMGYKJEyfihBNOwEc+8pGcr3/88cfxzW9+E3fccQcSiQSuuOIKjB07Vjt22rRpaGxshFIKkyZNwtixYzFmzBg0NTXhxBNPhFIK9fX1eO655wLXnDx5MlavXo3TTjsNANC3b1/8/ve/x7p16zBt2jTEYjFUV1fjgQceyPl+SP4IU9IIIYQQQkgBiFKl/3v/hAkT1NKlSx3HVq9enZc4IvnDZ949TP/jSvxhyUb89OLRuPIgqu4oIsuUUhPKbUch6H43kQMTVnc8uODvJ9KTYHXHg4eg300MdySEEEIIIYSQCoLhjt3InXfemclTs7j00ktx4403lskiQgghhBBCSKVTsEgTkToACwDUmvPNVkrdUui8BwI33ngjBRkhhBRAd4YlEpIvInIEgEcBHIZ0naiHlFL/KyKDATwFYCSAJgCXKaV2aa6/CsCPzLd3KKUeKYXdhJCeQzHCHTsBnKWUGgtgHIBzRORjRZiXEEIIIaQSSQL4gVLqeAAfA3CtiBwPYDqAl5RSxwB4yXzvwBRytwA4FcApAG4RkUEls5wQ0iMoWKSpNG3m22rzP1YfJwc9ZajJQwghpAQopbYopZabr1sBrAYwHMBFACyv2CMAPqu5fAqAF5VSO00v24sAzul+qwkhPYmiFA4RkbiIrACwDelfPIuKMS8hPRGW4CeEkIMHERkJYDyARQAOU0ptMU9tRToc0s1wABtt75vNY4QQkqEohUOUUikA40RkIIBnReQEpVSDfYyITAUwFQCOPPLgKUtOCCGEkAMTEekL4I8AvqeU2iu2v9IppZSIFBRTwb1T5cJ8WdLdFLUEv1JqN4BXoHHbK6UeUkpNUEpNqK+vL+ayRWH37t24//77AQCbN2/GJZdcUmaL/Pn4xz9ebhNIBBSjfgkh5IBFRKqRFmiPK6X+ZB7+QESGmueHIh1h5GYTgCNs70eYxzxU+t6JENJ9FCzSRKTe9KBBRHoB+DSANYXOW2rsIm3YsGGYPXt2mS3ykkwmAQALFy4ssyUkmAM03rFjD7Ctx/3TJoSQoiNpl9nDAFYrpX5hO/VnAFeZr68C8Lzm8hcATBaRQWbBkMnmMUIIyVCMcMehAB4RkTjSou9ppdRfC5rxb9OBrauKYJqNw0cD587wPT19+nSsX78e48aNwzHHHIPVq1ejoaEBs2bNwnPPPYf29nY0Njbihz/8Ibq6uvDYY4+htrYWc+fOxeDBg7F+/Xpce+21aGlpQe/evfGb3/wGxx13nHatZ555Brfddhvi8TgGDBiABQsWIJVKYfr06Zg/fz46Oztx7bXX4pprrsH8+fNx0003YdCgQVizZg3Wrl2Lvn37oq0tXavl7rvvxtNPP43Ozk587nOfw2233Yb29nZcdtllaG5uRiqVwk033YTLL7+8uM+THHw8cgGw5U3g1j3ltoQQQsrNRABfBrDKzMkHgP8GMAPA0yLyVQDvAbgMAERkAoBvKKW+ppTaKSI/BrDEvO52pdTO0ppPCKl0ChZpSqmVSCfM9mhmzJiBhoYGrFixAk1NTTj//PMz5xoaGvDGG2+go6MDRx99NO666y688cYb+P73v49HH30U3/ve9zB16lQ8+OCDOOaYY7Bo0SJ861vfwssvv6xd6/bbb8cLL7yA4cOHY/fu3QCAhx9+GAMGDMCSJUvQ2dmJiRMnYvLkyQCA5cuXo6GhAaNGjXLMM2/ePDQ2NmLx4sVQSuHCCy/EggUL0NLSgmHDhmHOnHS89J493FSTIrDlzXJbQAghFYFS6lX4h01M0oxfCuBrtvczAczsHusIIQcCRSkcUnQCPF7l4Mwzz0S/fv3Qr18/DBgwABdccAEAYPTo0Vi5ciXa2tqwcOFCXHrppZlrOjs7feebOHEirr76alx22WW4+OKLAaQF18qVKzNhlnv27EFjYyNqampwyimneASadc28efMwfnxaI7e1taGxsRFnnHEGfvCDH+D666/H+eefjzPOOKNoz4JEhyX4CSGEEEJIPlSmSKswamtrM69jsVjmfSwWQzKZhGEYGDhwIFasWOE3hYMHH3wQixYtwpw5c3DSSSdh2bJlUErh3nvvxZQpUxxj58+fjz59+mjnUUrhhhtuwDXXXOM5t3z5csydOxc/+tGPMGnSJNx8881Rb5cUCEvwE0IIIYSQQihqdceeTL9+/dDa2prXtf3798eoUaPwzDPPAEiLpzff9A8NW79+PU499VTcfvvtqK+vx8aNGzFlyhQ88MADSCQSAIC1a9eivb09cN0pU6Zg5syZmfy0TZs2Ydu2bdi8eTN69+6NL33pS5g2bRqWL1+e130RQgghhBBCSg89aSZDhgzBxIkTccIJJ+AjH/lIztc//vjj+OY3v4k77rgDiUQCV1xxBcaOHasdO23aNDQ2NkIphUmTJmHs2LEYM2YMmpqacOKJJ0Iphfr6ejz33HOBa06ePBmrGt7Cyad+DFUxQd++ffH73/8e69atw7Rp0xCLxVBdXY0HHngg5/shhcNoR0IIIYQQkg+iypA4M2HCBLV06VLHsdWrV+cljg523tnais5kCscd3g81VfGcruUz7x5ufHYVHl/0Pn782RPw5Y8dVW5zisetA8yf+kI0IrJMKTWhhBYVHd3vJlJeemLD2KYZ55XbBOKCv59IseHvJlIMgn43Mdyxx5MW2SxSQQghhBBCyIEBRVo3cuedd2LcuHGO/+68884ir5KuUkGNRorCtjXpPoVU/YQQQgghZYM5ad3IjTfeiBtvvLFb17AqCXJPXYH0xA/licuA3e8Bp14DDPa2fSCEEEIIId0PPWk9nGy19x4oCA5QenQJ/ozqN/zH9ETxSQghhBDSg6BI6+Fk9tTlNYMcKIhZfIYijRBCCCGkbFCk9XjMnDTumyuOHvmRxEyRZqTKawchhBBCyEEMRZqNeDzuKPLR1NRUbpMAAE1NTXjiiSe056zIuh4pCEjlkfGkBYk0ftsIIYQQQroTFg6x0atXL6xYsSLn65LJJKqquu9RWiLtC1/4gudcJv+JrrSKQdCDk9KieNL4XSOEEEII6VboSQuho6MDX/nKVzB69GiMHz8er7zyCgBg1qxZuPDCC3HWWWdh0qRJAIC7774bJ598MsaMGYNbbrklM8ejjz6KMWPGYOzYsfjyl78MAPjLX/6CU089FePHj8fZZ5+NDz74AADwz3/+M+PJGz9+PFpbWzF9+nT861//wrhx4/DLX/5Saye3zaQoxOhJI4QQQggpNxXpSbtr8V1Ys3NNUec8bvBxuP6U6wPH7N+/H+PGjQMAjBo1Cs8++yzuu+8+iAhWrVqFNWvWYPLkyVi7di0AYPny5Vi5ciUGDx6MefPmobGxEYsXL4ZSChdeeCEWLFiAIUOG4I477sDChQtxyCGHYOfOnQCA008/Ha+//jpEBL/97W/xs5/9DD//+c9xzz334L777sPEiRPR1taGuro6zJgxA/fccw/++te/emwWYU5apdIjPxOhJ40QQgghpNxUpEgrF7pwx1dffRXf+c53AADHHXccjjrqqIxI+/SnP43BgwcDAObNm4d58+Zh/PjxAIC2tjY0NjbizTffxKWXXopDDjkEADLjm5ubcfnll2PLli3o6urCqFHpnlQTJ07Eddddhy9+8Yu4+OKLMWLEiECbs9GO3DhXCj26BH+kwiH8rhFCCCGEdCcVKdLCPF6VQp8+fTKvlVK44YYbcM011zjG3Hvvvdprv/Od7+C6667DhRdeiPnz5+PWW28FAEyfPh3nnXce5s6di4kTJ+KFF14ItIEl+ElRiVI4hH8QIIQQQgjpVpiTFsIZZ5yBxx9/HACwdu1avP/++zj22GM946ZMmYKZM2eira0NALBp0yZs27YNZ511Fp555hns2LEDADLhjnv27MHw4cMBAI888khmnvXr12P06NG4/vrrcfLJJ2PNmjXo168fWltbA+00AvbNbR0JpIyAvleEWNCTRgghhBBSdijSQvjWt74FwzAwevRoXH755Zg1axZqa2s94yZPnowvfOELOO200zB69GhccsklaG1txUc/+lHceOON+OQnP4mxY8fiuuuuAwDceuutuPTSS3HSSSdlQiEB4H/+539wwgknYMyYMaiursa5556LMWPGIB6PY+zYsZ7CIZmcNJ+NczJlYMP2dry3Y1+xHgmJSI8MQRXzV0Jg4RBCCCGEENKdVGS4Y7mwvGB26urq8Lvf/c5z/Oqrr8bVV1/tOPbd734X3/3udz1jr7rqKlx11VWOYxdddBEuuugiz1i/8MiXX35ZezysAr/lYetM0pNWKnpyShpL8BNCCCGElB960no4bJNGikrM/LuNChL1lfdlE5Hvi8hbItIgIk+KSJ2IjBKRRSKyTkSeEpGacttJCCGEEBIFirSeTqZwSOVtnMP46d9W44Rbgguj9GR63icCWwn+pP+YCvuLgIgMB/D/AZiglDoBQBzAFQDuAvBLpdTRAHYB+Gr5rCSEEEIIiU5FibQemcNTZvLtk1YJz/rX/9yAts4AMUBKT88tHFIFoJeIVAHoDWALgLMAzDbPPwLgs2WyjRByACIiM0Vkm4g02I49JSIrzP+aRGSFz7VNIrLKHLe0dFYTQnoKFSPS6urqsGPHjooQDz2RXB6bUgo7duxAXV1d9xnk4pGFTVjf4s35O5DpkblpUQqHVNi/UaXUJgD3AHgfaXG2B8AyALuVUtZfAZoBDNddLyJTRWSpiCxtaWkphcmEkAODWQDOsR9QSl2ulBqnlBoH4I8A/hRw/Znm2AndaCMhpIdSMYVDRowYgebmZnCTlBu793WhrTOFfXVV2NWr2nM+ZSh8sKcD8ZgAu7OirK6uLrRRdrFQSuGWP7+FfrVVWHXblJKsSfKkB3rSRGQQgIsAjAKwG8AzcG2cglBKPQTgIQCYMGFCZd0cIaRiUUotEJGRunOSDnO5DGmPPiGE5EzFiLTq6mqMGjWq3Gb0OG58dhUeX9SMr54+Cjed/xHP+c279+P8x17G0AF1eO2GSWWwMOt4aT3IQht75G4/08zaALr2AXuagfoPl9emcM4G8K5SqgUARORPACYCGCgiVaY3bQSATWW0kRBycHEGgA+UUo0+5xWAeSKiAPza/GORBxGZCmAqABx55JHdYighpDKpmHBHkh+WEKiwCDQHFWxaXiil8NeVm5FI6SsgWnmCPZKYrXDI7K8A950MJDudYyrvy/Y+gI+JSG/zr9eTALwN4BUAl5hjrgLwfJnsI4QcfFwJ4MmA86crpU4EcC6Aa0XkE7pBSqmHlFITlFIT6uvru8NOQkiFQpHWw7Fy+Cq5uuOBlmf494at+PYTb+D+V9aX25TiY5XgN5LAhvnma3foY2V9nkqpRUgXCFkOYBXSv9ceAnA9gOtEZB2AIQAeLpuRhJCDBrOA0cUAnvIbY+bSQim1DcCzAE4pjXWEkJ5CxYQ7kvwwTGdOJesgo4Jty4cd7V0AgK17OwLHVfJn4ou9BL91A27PYAXemFLqFgC3uA5vADc+hJDSczaANUqpZt1JEekDIKaUajVfTwZweykNJIRUPvSk9XAMy5Pms3GuhO10JXv5iIuY+SvBSKIyvj2EEFKZiMiTAF4DcKyINIuI1YvxCrhCHUVkmIjMNd8eBuBVEXkTwGIAc5RSfy+V3YSQnkFFeNKSKQMxEcRiPTiXp0xYXqqw7XQ5n2wFOl6IH2Kr7mh9cO4PkB8oIYRAKXWlz/GrNcc2A/iM+XoDgLHdahwhpMdTEZ60o2/8Gy5/6LVym9EjsbxU3DeXnp5cH8QXe+EQX+nPLxshhBBCSHdSsEgTkSNE5BUReVtE3hKR7+Yzz5KmXYWaclCScXb4bJxLUbTjiUXv4/UNO3zPH6wCskfetiMnzapeSU8aIYQQQkgpKUa4YxLAD5RSy0WkH4BlIvKiUurtIsxNQsjmpOnPl2I//d/PrgIANM04T29DiFxRSvWosvWhoaU951a8xDSFQyjKCCGEEEJKSsGeNKXUFqXUcvN1K4DVAIYXOi+JRtSctHIStsfvqdUfS6LFtqwEls0qxUppYractGwXPtegHvqBEUIIIYT0EIpaOERERgIYD2CR5txUAFMB4Mgjjyzmsgc1KsSTZlSAFyTMgvQ99Dz3U7T7KpBfn5H+edLVhc8VBbFXdzRh4RBCCCGEkJJStMIhItIXwB8BfE8ptdd9Xin1kFJqglJqQn19fbGWPejJRqT55aSV0BgfwsRKT/Wk+SE9UHBmsD4ru0ijJ40QQgghpKQURaSJSDXSAu1xpdSfijEniUZoTloJbfEj1ONUEVbmTg+WYgFoRBo9aYQQQgghJaXgcEdJV3x4GMBqpdQvCjeJ5EJGpJWxumMYYSZUgImRWLetFXv2J3qOwflg3du//9d+0D2oVNYQQgghhByUFMOTNhHAlwGcJSIrzP8+U4R5u5W/rdqCF97aWm4zCiZTOKSCPWlhRpQqb64zmcK729vzvv7sXyzA5x/I9vPr0VUcC+FAFqmEEEIIIRVAMao7vqqUEqXUGKXUOPO/ucUwrjv55uPLcc1jy8pqw/6uFKb/cSV27+vKe45snzS/8+kz5SxxH16CvzR2XD97Jc68Zz5aOxLduk6PFm+6D8NzjCKNEEIIIaQ7KVrhEJI7Ty15H39YshH/84/GvOcIq+5YCU6P8BL8pTHy1XXbAQAdCSNkJCGEEEIIIeWDIq2MJM1YxVgBrpfQnLS8Zy4eYTaUurpjqQqV5Kw9m/4NtG/vFlsioRTQ9oH+eNB7QgghhBBSVCjSykRbZxI729NhjvECPoWMwKloT1pY5ZDS2FEq8pbcsz4DzDxHf64UH+TcHwINs3WL69937AFuHQCseLK7LSOEEEIIOagoajNrEp2T7/gH9idSAIBYLH9PWohGq7hm1qf99CW8dsMkx/lS21hoH7NutXaHT+irUt2f7Lbkt/5r697vei/987VfAeOu7D67CCGEkDwZOX1OuU0gJC/oSSsTlkADgHgBm2/LS+UndCpAozls2LKnw3O+EoRkPuQq9lo7EuhMpvQnQ72N5cyjY+EQQgghhJBSQpFWAcQL8KSFN7Mu/4Y6tLpjiezIrpdeMWUojJw+B3e/sCa36yMa7L7v0bfOw2fvW+gzOESElVOk+XnSenQZS0IIIYSQyoUirQIoqHCIuXf3L8Gf99TFo0KqO7qzxZLmw/vNgnfzmm1J0078q7HFu0rAx7l6y179CcPHw2ZBTxohhBBCyEEDRVoFUJTqjhWgxjoSeqHh2eJ7PDPdY0+4JflhfVxrtrbiyw8vLsqcFe1JI4QQQgghJYUirQIopLpj1MIhpYhM++x9/9Yed2syd8n9UpfgL7hwSHfYW8kijSX4CSGEEEJKCkVakZn173dx/r3/yumagqo7WhvmCijBv2Zrq94Gl3Hu8MZSFw6x7OnuZXOav5JFGsMbCSGEEEJKCkvwF5lb//J2ztcUUt3RyGi0Cm5m7fGcOQ+Uzsb0c+5ucSbm55nTMpUs0vw8afSoEUIIIYR0C2X3pFVCLlW56dbqjhXwfL05ac73RonjHQvVGFGf6YHrSSv/d4oQQggh5ECm7CKt1PlInvXLbQAKKxxiCQHfPml5z1w4u9q7MP+dbR5RU+4Up0y4Yzc/nZzmDxVpZfwky/2BEUJIBSIiM0Vkm4g02I7dKiKbRGSF+d9nfK49R0TeEZF1IjK9dFYTQnoKZRdp5fb0JIzyV80rxJOmInrSuqtwSNDn95VZS3D175agvdNZ9dEb7tjDPGkh561HXVRPWlnlNj1phBCiYRaAczTHf6mUGmf+N9d9UkTiAO4DcC6A4wFcKSLHd6ulhJAeR9lFWrkdWclU+TechRQOyeak6SlncYz1LW0AgETKKUC8hUOKblYgmRBR832uIjEVYnBet1PJ4Y70pBFCiAel1AIAO/O49BQA65RSG5RSXQD+AOCiohpHCOnxVIBIK++GryJEWgFertCctPynjkSU+d227Xf1Uyu1NzXrSctv3W75zlaySAulBP0dCCGk5/BtEVlphkMO0pwfDmCj7X2zecyDiEwVkaUisrSlpaU7bCWEVChlF2nlphLCHauK4Enzk0t2PbG/K4WJM17Gv9dtz3s97/rhgsXtqTrlzpdccxTNnJzId9lUxK9MTiKwokUawx0JISQiDwD4DwDjAGwB8PNCJlNKPaSUmqCUmlBfX18M+wghPYSyi7Rye9LcoXjloLDCIdGrO65vacOm3fvxk7mr817PO3/QyahzBA9cvWUvlr+/S3vuhj+tws/nveN77a9ebsSCtc6/Puaak6aUctgY9p3tlpy0Sgt33LsFUCn9eEIIOUhRSn2glEoppQwAv0E6tNHNJgBH2N6PMI8RQkiGsvdJO1Bz0pRSmX5ZYRRWOMT86XPeer4CyeRSFSIKPetHUGJhYiVshnP/N90cvGnGeZ5zTy5+HwCwd38Cpx9Tj8P712H0iAGZ8/fMW5u51rptI+yhufjPmYvR0tqZeR+1IqgCsLcjgf511REGV7BIcz+ozr3AA6f5nyeEkIMUERmqlNpivv0cgAbNsCUAjhGRUUiLsysAfKFEJhJCeghl96SVvbpjnp60rqSBbXs7fM/ncluFaKZsTppfCX6vB6iQQiWe+QPuU7l++lEMb+ojr72Hrz+6FBf86lV/e1zaLIrAbO1I4F+N27Fma2vmWCqivbOXNWPMrfOw9oPW8MFGiFeqkjxpyU79OEIIOYgQkScBvAbgWBFpFpGvAviZiKwSkZUAzgTwfXPsMBGZCwBKqSSAbwN4AcBqAE8rpd4qy00QQioWetLyNGDa7Dfx/IrNaLzzXFTHvVrXUAqxiAUVCtEolsDxvQ3zeCJlYG9HEkBhhUo800ewPawaYqnTAsNCRO1sb+vyHAu7H+tjf3/nPgDAO1tb8eHD+oUYVWZPGis2EkJITiilrtQcfthn7GYAn7G9nwvAU56fEEIsepwnbXtbJ17fsKNo6+frSftbw1YA/hv2nNKR8twf/3NtC9a3tAeuZx3fsqcDV81cDKC44Y6RCoeEjCl5nzTXzyBSGgUZKtJcRPIUhsaEduMzevt5YNTFWc8AACAASURBVMub0deu6EqThBBCCCE9n7J40jbu2pd5neve89IHX8O729u1+Un5kHdOWshluYTw5bv9vu0v2egI33BHzeF4UXPSwgnTNKV24uRSgj+h+X6EirR82oqV05P29H+GDAgTaSzBTwghhBBSTMriSUvZNr655iO9u930HBVpZ5/MM9ZO5/358V/fzp7Ppfq6UjAMhXlvbfW9r2TKwIqNux3HopTu1z7fIu6pgz4/lQnF9I7JpVpisbC0aSbcMWT8r15uxCUPLPQcz9XeaJ60MJFWxnBENrMmhBBCCCkpZRFp9i1evjlpuYScbWvtQLPNe+ecJ7/1rX2qfQP+8KvvZl7n6kl7csn7mPrYMjyztFk75p55a/HZ+/6NtzbvAQA0bW9He2e22EQuzay7MydN97noRZr/HMXCrwqjddSyS3xU6z3z1qK9y1vQw/2dSaQMR9ise9VI39Vy56TlQiXZQgghhBByAFKWcEfHBj3PYL+koVAVjzbWap6sC5HM1yOXyWvyE0c5JaUBm3btB5AWlDoscbbDLGTxqXvmu6bwC3f0Hi9mTpp72UTKQDzm/GB0zkqnUO8eleauwujpj5bnsm57T/rxizAU0HDbFHN+/bqBVLRIY04aIYQQQkgpqYDCIbmNt7xA+VZldJPvNEGhfEHHtXNBZQSFX3n8fOtK6A4X0pfNjfs+O5PeDbzuWdiPdVfwnH9RF2e4Y65/KHDPu7cjibbOpO/4sO/CCbe8gJmvrgtetJJK8FOkEUIIIYR0K2UKd7Rt0HPcoVsCI1WkJtQFe9J8zuci/pTKPge/oh7WM/Nzgvnehi4lrRsLh+jC/sLDHbvJk+b6EDLNrA2vDTnNG1at0nXaUMH3mEgZkFAVXkmetJCeboQQQgghpCDKHu6Ya6hbWmCovAt+pNfPrvmF3y7Csh+djSF9a/Oby8eMXITHM8uaMXr4AAD+oYjWdH75U7l49NZva0MiZWj7u1nMf2cbkimFs48/LMh0z/y6apk605xNtgOX8PC3VVsgIjjnhMMDx/l5W7OetPxUWtgfCNxnDaVCm34LKjjckZ40Qggh3czI6XPKbQIhFUXZCods3ZPOvbJv8vd3pfBq4/bAa62KhoWEO7r3nM+t2Jz3HH7iKBftuey9XZi1sAmAv6cs1B6/45oTm3bvx0/mrg6c7+rfLcHXHl0avq57/67xkha7cMg3H1+Ob/x+Weg433BHd25ajuTqSVMqRA4qQMIEY0V50ijSCCGEEEK6k7KItI5ECh/76UtY1bzHsaH972dX4UsPL8qU2ddhhQMWItLcoqGQcDv/cMf85sy7qEcOOWkAsKRpZ37ruOePUCRDJ5YK8aZGJczbmu+qflUjfcerkFYFUIhBo1rt9ndXCcx8Gm1TpBFCCCGEdCtFEWkiMlNEtolIQy7XNW5rdez/Gre1AgBaOxK+18SKkJPm3mMXIhL8wwzzm8+vpkcm3NHvfA7VHQF9xcV8cM+uW033LJzhjt4B67a15SyG3Ph50qz17M/m/15qxLjb50WbN8yT5noKoeGOCojZwx0NswiJPferu4RRpHk9rsFuMYUQQgghhKQplidtFoBzcr3I7WHwy7eyY4U7JgpQGW5RUIgW8C/Br9C8ax+W5uixCqu86Hc2l+qOQPG8V7rQvuzaXjGkvc51umHTHpz9i3/ioX9tKMi2XMIdf/HiWuze5//HATu6vDvd/HY7gj1prpy0VAKY+1/Ajw+xDeomkWbkUQSEnjRCCCGEkG6lKIVDlFILRGRkrtcZYbk6GjKetCLmpBWiV3w9VQo4/a5XAOj7s/nhW4I/5En556RFLyiSD97QUd2Y4Ovs5w1D4UfPpR2yy9/bFbj2t59YHnjevwR/YeRatCbsWSulEHfEfyaAxb92j8ppzchEqdTIcEdCCCGEkJJSspw0EZkqIktFJFuNIiRXR0cmJy2lcP3slXlVA/J60oqfk5Zv5cCw6o4QP89UbgVM8hG5HYkUHnutyRGG6Al31KVW6ey1vbaff23DDqzYuNs87rxmQ0ub4/1fV24JtNe3umMm3DHwcl9yfXbpEvz+5xUAEZcnzTOonJ40d3xw5ZXgF5GBIjJbRNaIyGoROU1EBovIiyLSaP4cVG47CSGEEEKiUDKRppR6SCk1QSk1wTqWztUJCYVzEc9UdzTw1NKNednizikqpHBIyXLSzJ8CcYiEAb2qMfaIgQFi0ed4Hvb98h9rcdPzb2HOqqw4cueN6cRpaHVH23F7nzW39Wf9/J852evpk5axx5pdY2uEDy6saI37+2SokHBHBWfhkJKKNP8m3Nm1e4Qn7X8B/F0pdRyAsQBWA5gO4CWl1DEAXjLfE0IIIYRUPGWp7mjh9jBEKWwYL0YJftceszty0vItehHWaFrEae8xh/bFgF7Vvvfg60nLQ6Xtau8CAOzr8t/Y68MdtZVDtOftOXmFRmTaRVpnMmVvDuA7f5TnEuZJ03kXw8JRHc2sjRxFmmEAi38DdO0LtEtvQD6FQ1zXfLAKePvPua9dJERkAIBPAHgYAJRSXUqp3QAuAvCIOewRAJ8tj4WEEEIIIblRZpGmchZIcU1OmmEo/Pqf63HFQ69FXtdOIWKgGH3S7MT9yzdq16yOx9Ieohxzz/IJd7QKuwT1ONPNqkvhMnxcafZwz0Lz5uz3+MXfLMoul/GkBV/jR1jhEDeGofCJn72iPWfZEisk3HH1n4G5PwReuTMnu9LG5ZOTprnm6S/nvnbxGAWgBcDvROQNEfmtiPQBcJhSynL7bgWg7cxuD8VuaWkpkcmEEEIIIf4UqwT/kwBeA3CsiDSLyFejXKd8wsCCtsAZT5pto5wwDPz0b2vw+gZvJUVdKGNRc9L8PFj55qTZPpHjbvobLrj3Vcd8AqeQqIoLRIJy4/Tk4+mz9JNfPpn7vfIZEzSHXaPm8wTtnji7t3WprQiJdVT33Ygk0sL6r7lTuBSw0/RCesaaP2P2i3IVafvNe+vcG2iX3oA8ctIqL9yxCsCJAB5QSo0H0A5XaKNKf9jaD9ceil1fX9/txhJCCCGEhFGs6o5X5nUdXOGOEa7JNrPObhQTAZ4N+6Z7Z3sXBvep8XjvCvHX+IY7OrxNKjSM0cLehqAjYWDVpj3O8yIeT5oK6MMVVH2yGOhC+7w26I7ZPKG283GHJ817XZi4rLKJtJRLTGVy0sw5siIyOyZKGG1oTprrqQSFUGbCHR05aV2AxJxiKDDc0Qw/jVUH2qW/Noonzf2+SF+e4tEMoFkpZblLZyMt0j4QkaFKqS0iMhTAtrJZSAghhBCSA+UNd/TpHxVUyCOmyUlLJP03sHYBd+KPX8T8d7Z55i+kcIifx8x+X7nkz/k3pbbNbbvd6rhARHL23OWTk6bD+/l5wxh1n7FbxFo4c9K817UH5MMBbpGmH5P1pFnjnKGzYQR523a0dXrXC+mRBgAx2MSSkUiLNOckAQaZnrd4PiItQuGQCm9mrZTaCmCjiBxrHpoE4G0AfwZwlXnsKgDPl8E8QgghhJCcqajCIWGVQx59rQnv72gHAKTs4Y5+u3F4m16/u73d46EpJNzRb79u3+znkv/lF0lnzSDiFFhVZk6avyct3L5CiNJzzrJ3ykezKUF2UXnn3NWYOONlAOGFU9o7gz0/znBH/cPM2ug1NpInzcdz+/eGrTjpjn9gkSvsNqyyI6Cp7hhzObkDPWmmSHNfE4VI4Y5FuKb7+Q6Ax0VkJYBxAH4CYAaAT4tII4CzzfeEEEIIIRVPUcId8yXdzDpaTpphKNz8/FuZ9/YNeFeQSHN52Qb1rtHkUQXb2ZFI4a3Ne3HSUd42S35ekk7burl40vwLkWRz0uxjauIxdEoqIOwy3NOXK87CIS6vpHat9M8PH9YPL7z1gWfgezuyVQntGk1nY1unJl/LRlU8+3cH/2bWZrijLpwywnPxE3+L302Ls8Ztzn5uQR9/NtfQJdIk7hqoWbNjLzDrM8AhpgMpV09aWwsw/67wcT2gBL9SagWACZpTk0ptCyGEEEJIoZTVk5ZI+Vd3/OTdr+D++esy792bZ7vwCaq2N3eVs+FxRyKVU+GQ597YhPP+71/4/AMLsXn3fs95P/vbOrNhZKkcqgHqRt70XAOWv787c97uBUuH94lvsGMxm1lnC4dkr3XPog1tNNdyhDL6rOGon2EoPO3qhXf2LxYE2mjvM+ffzNrfhiiC2u/Z+TkBo3jSBDbhYySAmFukaebYMB/YugpomJ1+n2tO2p+/A6z8Q4SBlS/SCCGk1IjITBHZJiINtmN3i8gaEVkpIs+KyECfa5tEZJWIrBCRpaWzmhDSUyirSEumDK0nSpD2rvzs7+9kjrn3xfaNclC440027xsA7E9ovE4B+/LvPbUC61vSIZbtnd78HT9PWkciGxIWVg0wbL7HXn8v89owlCfcMSb+dvjdWn7Rjl4VEhTuaIk5S6TEI5TXt9/H6xt24r9mr8zNQtsafuI4I9J0nrQCRJpvI/IIz9oT7ujJSdN8h9zHcvWkdbWFjwE05SorMtyREEJKzSwA57iOvQjgBKXUGABrAdwQcP2ZSqlxSildFAAh5CCnzJ40Q1/BL0IYWiKlMpvioHBHNx0JI+8S/DpPid+Vdu9eTjlpIUOVa0y1VYJfI2L3dSV9xVs+njQd7mfXvGs/tuzZ72h4bS0Vi9CoulCz7ELJrzhKJtwxz5w0v3n98umChJ/1/Ioi0uw5aYYBrP6rf5Jj2mD/c86Fwm0hhJCDDKXUAgA7XcfmKaWs/wN8HcCIkhtGCDkgKKtI60oph4iwtoydCe9f6t1iIGUYmfC5oBL8btLhjs5juj33X97cjJHT5ziOPbVkI0ZOn+PwkvkJPEf1ySLkpNltdYY7xiDwVnf84TNv4vibXwjwpEWzSScwgppZf/3RpTjtpy/jPx9e7JnD3qi6ULv8sHvrfHPSAjxpUcSrn+7xkzzBJfjTP2P2YhyproiFQ1zzxmuyr998Anjqi8Cy3/muHa3pBTQPqjgCnxBCDnD+H4C/+ZxTAOaJyDIRmeo3gYhMFZGlIrK0paWlW4wkhFQm5Q931Bzf1+UVae7Nc9JQmU2/PdzRLSqGD+zleN+RSHnm+u2r72Lrng7Hsfvnr/fY8Jt/vQsA2LUv25g4Ss5XLjlpoZ40pfTNrF3XPfvGpsx4/TrRbArzLPnNY28enQl3tH3b/LxLhVadtHuz3LZbpyx78hVpvuGreYQ7WqccWYVGUpOTpvOkuUWaLdxxn/nH3Z0b/BenJ40QQroFEbkRQBLA4z5DTldKnQjgXADXisgndIOUUg8ppSYopSbU19d3k7WEkEqk/OGOtk2xtWfcZ3qq4jHBQwvWY2Xzbo94SaZU1pNmq6To9loMHVDneN+RSGmFy8trnH1ud7V3ecZYuHOrOpMptLQ6+2PZN/K55KSFJTApOIVRPGaKNJ/xvi0CImoh+1qR9/SAmSfnXCsWYYIgu9yCW0c8oJm1u2CILtwxikjzi64VH5UWXDhEmdfawx27olV39IQ72q6p6ZP+GTXvLAhPThpFGiGE+CEiVwM4H8AXlc9fSpVSm8yf2wA8C+CUkhlICOkRlLUEf8LQV3fcZxboqK2K4Sdz1wAAVtz8aceYpKEyYsmek2bfEH//qRUOjw5g5aR516yOOzfYdm+ZG3du1bWPv4F/rP7AMSbRXTlpynmPVTFJhzvmmHsW1SadJ81+xE+ADOpdgz37E44xjnBHX/Hob1cUkejISfPTEoWGO/rY6Fc4JFCkWdfaqztqc9I0cwTlpGVE2j74k4PqDlqXEEIIAEBEzgHwXwA+qZTS/gIWkT4AYkqpVvP1ZAC3l9BMQkgPoLwiLWk4vBnWltEKd6ytimVeuzfPKcPIiCV7kQ77H/mtkD87O9o7MW32m57jNVXZTbFSytHnLAil4BFoln0WSUOhK2kgZSj0qol7xtoJC0M0lHKIj3hMgABPWqEFQvyu37a3A/e+vA6fHT9Me35A72rsNkWaJSCdJfhzD8OM4omLib8nzb62YaQ9oG6C8sey8/oVDtGP1w0fOX0Orjj5CNzwmY+kr7ULHyMJxPIoHKIU8LvzgP07gU+ZBcUSmj1Cwx+B3kMY7kiKijuHl5ADHRF5EsCnABwiIs0AbkG6mmMtgBfN8PvXlVLfEJFhAH6rlPoMgMMAPGuerwLwhFLq72W4BUJIBVNekZYytA4CqzJgbVUcgOWNcY5JGsrsEebMSQvbZP9j9Tbt8V++uBafGT0U1fEYXnzbK7rs2IWEn9iwe6BShsKFv3oVa7a2omnGeSFzB572hjuKGWTnc11Qe4Io2AVJZkuv0o3F//7WVgzopS/7vsFsW5CeI/3T7oH0u8+gj8/PU+UYYxsU1Cftlj+/5WhtkLU1/Hn55c35PWo/L+cflmzEDeeaIs0d7hilcIhHpBnAe6+mX1v5abpwx9n/L/1zlDYFQrOOW6SxBD8hhCilrtQcfthn7GYAnzFfbwAwthtNI4QcAFRAM2vvBtbyntm9W55m1imV2ZDbwx3z9Rw17diX8bxtcRUR8WCv8eCznN27lzQU1mxtjWSH34beft5+j/G4ICb+zayjlJQPwiHSHI2i0888SgESXZ803X0qpf8+WETzpNnW9S0cAq1AAwJCJG34PVOdZy49Z1C4oy4nLZFfTpr9vfUcg8Idd+mfgc7KUFsIIYQQQkjRKKtI27q3w8eTlt7s2vPEPCLNlpOWcIQ75i9KrFy43qEhidnXSilHGJ+F3YOVzMGbFaZ53J60KrNwiJ+4yUW0pgzlsTW0jH2EebPhjrZjmnGGCvYkRstJi+Kt81/k+RWbHC0WdPh5a/1CZJMB1T2tqeKwl+DX5KRBAS/fAdx3qvdi7cTmfF3tAWMifjc8njSKNEIIIYSQ7qSsIq3xg1bthnfWwiYAQHXc7klzjrH3SbNXYoySU+SH5ZELm8EuiAwFrUizi5tcvFnhfdKcxVbisRgE/vvtIIHg5tO/+CeOvvFvDhET9jyjPG7LXgnxpKWMYE+aX7NoP9wCM4qwfHzR+/jj8ubAef3+EPDk4ve1x9198pTj+6PxpO3fpS/Bv+BuoGWN85h7jPt1IkikRRVbbpFWmHeWEEIIIYQEU1aRtrcjiW17s6GF7k24Q6S5+6SlVKa2wp1zV/uOy4Uu0xMSFnLoFBIK1RqR5s5Ji0qU6o6OPmkxgYi3mXV27ehejw3b2z026Hq8Oe4+73BH/big+eIRRJr9cj/BF2byfk2fPjtBuW463J+B/fOzXmVE2uAPAVtXaqo75hruaL4OCneMKtLoSSOEEEIIKSllLRwCANvbAkrd2/OLNOGOuhylQjxpnRmRFjzOKQScxSoy9rly0qIS7knT9EmDv81uL04UHI247X3SzNIhSkULc7SwpnNWd9SN07dkyKwfwZFmaLxU7utzE+GF4/Zm2r8P1lIxS/gMHQesfykt1uxEre7oPhckqPL2pFGkERJEd1W6DCs8RQgh5MCh7CLNquQIeLs2Dehdk3ntDXdUvn2ulr23E5t22z100SK0upIG/rpyM6b/aVXgOMdeWCFTZdJph6F9HUYUAWG4PGkIuL8wL977O/bhE3e/gvp+tY41stdnbdeJpChyJtMnzfac/t6wVTMu2N4ohUPsV/tWWwyZo8CCmB7cIt2er5j1gJo/+w8DOvbA868hijDSFQ4JvK6IOWljrwTw62jzEUIIIYSQQMou0vZ32Tes/rg374mUofV4KAV8/oHXHMckZG6LzqSBp5cG5yMBXm9N3N3TCk4PVi55YVEKh6Q8njR/8RK09sjpczDpuEMBAC2tnZnjDk9aSFn5KCX+LVFpD1f8xYtrvePCqjtGCM7V5Xt5xwTPUXRPmiZUN2tM+kemmXVVnXncFXIZpZm1o+xohDL5+XrEdNcNPym/uQghhBBCiIey5qQBQIetbLnbi2T34njP+XvS8qUrZSARoYm1MyfLWYVSZ0du4Y4haytnw+6quJieQv2FyRAv3ktrvH3j7CIl7PpIIs0SIiGOMMPnM7XI1ZPml5/ol78Xdl2+uCtmJgzvHybEuvGMSAvIN/M75m6I7VhBQ2Qx6hqnE4Bxfb88QgghhBCSO+UXabYiDe4to93j4M41Sxr6IhO6nLQom3sgHe4YTXTYc4r0uXGOEvy2Tf/zKzZFnluPcuWkxRAT/614Pn3S7LpMp9GUysqcrgiiVhfuqB8XfP+RqjvaLvfLTwx7JEXWaIGeNMtEyXjSzBBf94PXCaMgkZbcrx/jGB+xKbX7eejmjNd4jxFCCCGEkLwou0jbn7B70pzn7N4o9541mTL0xSc0O+yoldujijRnSF3am+XGGTKYnfO7f1gReW4dhnKKjyoz3NESN9v2dmDeW9l8r1x6tGXs9fGk6R5jFJGW6ZMW8kGkS/D7nw/zxAERPWkhz7iQ4jNjRgzwHHN/Bg6RZlrsCXdMmQV1MlUeNTa5hZvd7mRn9rKOPcDfb8gey4wvYuGQGD1phBBCCCHForJEmuuc3QOhq+6oDXcsqLpjytEY2w9HM2v4NbNW2te5zK0jHe7oykmzFQ657NevYepjyzLn8/KkOQqHaPL+kF0vyr1Zn4n7Obkfm7LlpJ15bL1nnigeUYfteX4XorQV8OPrZ3zIc8xTOMQRxpv+mSnBX2UWcLG8XPXHOQfaMRLO93bxlLB50l75CfD6/cCKx13jfW/DyeOXAK8/oF/HIl729FZCCCGEkAOGsoi0XtVxfPw/hgBw9aTyCLHsZtAt0vwaH+tERdQmyNE9adnXhgKqNRUt7N6TjkTEsDJEKMEPp7epyhJp5vumHc6+WPnk6K14f7f2eus52kvwd0YKd0z/dIc7uj+XlK1PWm2Vq5kzInrSXJ9N2BgdheQ11lV77XYL2ZTmjw+ZnLS4KdIsj9oXnkr/1AmjQE+aVd1UZV8rpS/TH4W/T9evY0FPGiGEEEJI0SiLSDv60L544EvpanAdtk1+UE6ae9+c9AmN0+VQRYx2TBcOyScnTVuCPztmX0hzZDth8sBdpj7tnRJf4ZGPJ+1rjy7NvNYJFvv9d+UQHup+TG5Bms5JS7/WhZBGEdv2oiDucEerCmaYEDZU/t602qpgwQ64SvD75aSluoDDTgB6DzEH6kRa0vk+Zes5mPGkqayYi8Vdwi6Xe7Q9e60njSKNEEIIIaRYlC3csa46vbS9cIgupNHCLRbSG1+NJ01Xlj+iTZ0JI2K4o7Pwg65PWjJPkRbezNrpQayKxcycO/11+eSkOe3R2ZB93ZUMvzdLOLtz0ty3ati8o9Vx71czqidt5PQ5+PLDi3w9YlFK8M9ZtSV8MXjzHfWhr/45aRZvGi245rB6GDEzbDDZlZ48MCfNLdJsOWd2T5olqiTuvCYXISohIi3GcEdCCCGEkGJRNpFWY27CoxYOcXs2/HLSdCInakn1hKEieoZsr6G0Xh97qGYu4Y6ZHsQBG2hndce0fyjfZtZhaJ+nLSyxuNUds95RndiJVILfvP5fjds9AtPysoU9kbc378W3n3gjdC2dTfpKn/5hvJa9vzCWY2HvXthvWZfsAGATaVE8aUmbJy0T4mg4PWn2io72OXsN8s5vR2y/KnRVIelJI4QQQggpGmUTaSKC2qpYoEhz5qQ5z/nlpOkEWdTmxIahcs9JM/RVC+3eks5cctJM+4PyqezCy+qTtqO9C08uft8zPpeiJTp0nkm7bVFErV/hEN28KuNJ04U7hi7lELcpnx5vYaGM725vD1/Issn1XneL7l5zCU11R+uyhCWGUqYnzTpjF1SW/e6cNLsnLWHPQ7N70nxEWlhOmUOksbojIYQQQkh3UtbqjrVVMUe4o5uUvU+apteUbqutz6GKZk/KUNpQNO989k22XnzY7ejKo7qjn7A0XOGOMZGM9+aGP60KtCMfdILGUNnn1LBpb4Q50j/DPGEpQ2Xs1Yc75tbM+pHX3nOcs3LS/DTa0AHpYh0f7O3QD9Dg8aSFVPoEsgI+ZqvKGTNt67TmS3XB6UmzTaAU0NYCtLzjXCipyUmDynq+JOYKd7SJLQn5VRAm0uhJI4QQQggpGmVNJKmtjmNXe3Zj6d47b96T3Sx7wx2NopfgN5SK1vfLdY0u3DFhE0dRvHPZuc2QvABPmv1cTIILo7i9OLliv9zSD4ahcpr32TfSDbzDcsqULdyxSlMxM5dwx8AxPgGP06YcizvmrMZO23cyFJdJ2nBH13fKKsEfk3Th/ThSmRL8nZlwx05nTppDGCng/8YDXa3OhRw5abrCITGXR07z4frCnLQDgZHT55TbBEIIIYREoKyetLrqmKPARlAYmlt8pQylD23U7B+/9LEjI9ljqGg5aS2t2c2wUlkPjR17wY6cRFqIJ03B+Sysjb4fUTyDQdjtsO7z5y+uxYaW6CGBFmHhjvYS/HmHO0YoE+P3NROJVpzEcY3rve5693fKEm2xmEApha/H56DKrMzYKVZSYiot0KybtgujVJdXoAG2YiEAOtvSP40E8P5rprEuT1ou1R3pSSOEEEIIKRllFWm6kDY/3HoskfLpk+Y69ty1E3HikSFFEaxrI4YG/vLFtZnXSimtMEjm6Umz7slPSBjKKU5Fgu3OpwS/zh7AKYB25OJtMgnzhBlGdj2dd9J+/UeG9tfOEc2Tpkcgkbx1fjbp3gPez8ASbXFTYCtI5h+i86mKTZna5ph5jt4Ye7hjR7bXHdo+yM7nl5MW1qjCUd1R8wSZk0YIIYQQUjSKItJE5BwReUdE1onI9PAr0rgLbgQV+NA1s9YWtXBtiGviscg5aVHH9avLhnZ1pQzs2Z/wjHF60pwTR6nc6OsRUl5PWtBzKzQn7Ru/X44VG9Mb/gIiSQGEe8Ls1R3Dwh3vvXK8do4oJgY9L53IGjGol+94+/CYhOcnAlnRns5JUzBsvtgOXQiiuMIUt6zQG2MPd9y/23teX2WmiAAAIABJREFUpfSVGd03oj0f5kljuCMhhBBCSLEoWKSJSBzAfQDOBXA8gCtF5Pgo17o3tEEi4Cu/W+J4nzQMbWije0NcUxWL3Jg4qqCxewB/8PSb2uIZjsIhrpykoHWyhUP05xW8YZ7d6UkDgGeXN6fXLlCl6cJC7diLoujCHWOif+2YI+B+t5oFQYLCHd3fyS+eeiSmn3uc75z20VXxWKSQzC5HuCPSIs20qRMa75ZbpPnh50mzMFLesv1Rsd/YO3O95+lJI4QQQggpGsXwpJ0CYJ1SaoNSqgvAHwBcFGlxd3PjHBb19aS5jtVWxSLPG1Wk2cMX/URQULhjkHAKzUlTTjtjIoHz+ZWhz4VtrZ14d3s7Nu7aHz44AJ3wsmPYiqJUhVR39AtLjNRCIeCce9qPDO2v9eplx2cviEu0cMmuTHVHK9wxButbes2iW/Fo/37uVaKJNMPm0U1pwlGNlD5p01ojkJDzzEkjhBxkiMhMEdkmIg22Y4NF5EURaTR/avMtROQqc0yjiFxVOqsJIT2FYoi04QA22t43m8cciMhUEVkqIktbWlrSi7tWz8VT45eTphNpUVVa1H5qUcScvWCHu3hH0DrWM/DbkxsKsE8nEuw9KrRwCJAuSX/mPfPx8pptkcYfd7hbZKSpq47j+2d/2Pc6ezGYKl0za9v3xU8MRfIc+jx/EfF40mIigd4x+7lBvatDi6MAWU9a3O5Js52/e8gg7I0JMl9ciUWLNdUJMzsqwJOWS7ijDnrSCCEHH7MAuJOEpwN4SSl1DICXzPcORGQwgFsAnIr0H7pv8RNzhJCDl5IVDlFKPaSUmqCUmlBfXw/Am5OWi5zwLcHvEjc1VbFIFf/S10Ybt/S9XaFjEjaPRWcOnrSwnDQF5fCOxUQQpMMSETxpfWurcNSQ3r7nN/g0dz5ysP6aIX1rtMdFgI8fPcR3HWcJfl11R7G91s8RxZPm9/gFXvFXFQ/2jtnPHTagLlJ1yA6zuXk8JunwVVvhEIuJRx2BL8V34OdLf44n+vXG/P2bsLa6Gm1BYioVEspoBOSkhREm4piTRgg5yFBKLQCw03X4IgCPmK8fAfBZzaVTALyolNqplNoF4EV4xR4h5CCnGDurTQCOsL0fYR4LxdP4NweV5tfPzB0CWVsVj1zwIqonLQp2wefukxXk+WrasQ+fvPsV/PrLJ2nPp8Md06+r44IjB/cOnC8VwZN2+tGHYNyRAzHjb2u053fv8xZGAUwvpQY/XSgigSImZShbdcfgcEd/kRalBL+fJ82b61YTjwUG+tntOLx/nUNI+rG3I/08+9TETU9aDDGNSZvFQMPbjyE1qB+waxEwYigAoF/KwLBkEkOlBsNUDMPadmBoMolh6MTQWAyDDUNvs0o5qzs67yTE6pDz9KQRQggAHKaU2mK+3grgMM2YSBFIQDoKCcBUADjyyGjthAghBwbFEGlLABwjIqOQFmdXAPhClAuDctJiElxt0U+keao75pCTFmWDHxVHuKMR3ZO2+N30H+WeXa7XucpWXOOt285BTVWs4MIhKaW0nqsw6qrjeht9nrjY/ldHOidNaQt4AO7CIc7zp4wcjOOH9ceshU0hVudWgr86HvOE5TqvyXL4gDqPd1hHa0fa4xWTdLijcoU7fn5vG27esROx4SdBfe0lbL/rCGz56IXYvOZZbK6KY3NVFbZUVaG5Lo4lkkL7ECtKpgvoMwJ1hsLhySSGJ5Np8ZZMpX+2bcSwfUegHoDnkwvVaMxJI4SQXFBKKREpaGOhlHoIwEMAMGHChOJtUgghFU/BIk0plRSRbwN4Aem930yl1FtRrvWEO9o8HPGYwAgQTX5Np92Cxcr7iUIyh35moXOZwqw6Lh7xF+T5svC7P4WsALSETHDhkPC1otijo8bHkxZUPTFor//vdduhoBAT0Yod+5Fc+5nZCbpdtzisjktgVUq7HV8/40ORcgAtkZYye+ylc9Ky1926w4yeUQoignolqK8egDHt+5wTDTsCKtGOvTvWYktVFTb3PxxbunZhc20fbJYUtlTFsbq2N3bGTUn23mzgvdmoGnkEDrOEmyXiaoBhdbUYlkzh8GQS3oDVME8awx0JIQTAByIyVCm1RUSGAtAlc28C8Cnb+xEA5pfANkJID6IoOyul1FwAmrrcwbg9FHbvWHrz67/h9fN66So+Dh1YF8meRBHK1VtYm/WqWMzj9Yvi3fLb7CdSCg2b9wDIepaCwjSj5GhdMHYYdubRnNov3DHIUxW01f/VK+vwtdNHpaskaj1pAeGOIQLQjp8YT4c7ej1pUQqHfOesozFsYC9s3LnPf7DJXrOvnqFUJtzRscTkO4F5NyL7JH2qO0oMInEMMBQGdCVwXEcCaGsDetcB+7Znhu0TwdaqODaf+jVs7jMYWxbfZ3rj4ljUqw4t8TgMAdAnG5VTbwiGdnWkwyqTKQyLxzHMqEu/TibRx/2dK0A0E0LIAcSfAVwFYIb583nNmBcA/MRWLGQygBtKYx4hpKdQ1j9/u70WH7R2+p6Lis4rdOaxh+LJr38Mf2/Ygkdee8/32mJ60ixPWNqTFr1PmoWfuPrp3NUZkWflPxXiSXv9hkk4fEAdfvfvd0NtcuMn0vxUmk4EuXlj424z3NF7zi7cdNOE9WGz8HteAu8fDqrjMa3wd16lt9GPVjMnzTCQqe6YMuf59ad/DbxnNqu21k11AYse1Cwdc1ZdtKo7urxavZXChxJJfKjXcGDoScCunzjOJwB8MOQobGnfik2meNvc9xBsUQpv1dbgpT5VSIgA/Q7NXNM/lcIwU7ANSyYx9K1HQ++bEEIOJETkSaQ9YoeISDPSFRtnAHhaRL4K4D0Al5ljJwD4hlLqa0qpnSLyY6TTRQDgdqWUuwAJIeQgp6wizb1htwuKKLk9OuwbcPsUp/3HELz49geB1xbRkYbORFpkVcVjeYk0v3BHncAIClcMy7Ozepfl87Rrq3LPSXN/rJ/8cD3+ubYl837t1lbEfPqNBeWkQTO3H3e/8I7ePvF+76rjAhXwDN1r5pKTZpjhjgqCLhF8fm8bPj7s48D7K50XJH3604k4RZpVXt8vP8xIaqs7VgMYYQhGdHTiZJh/KKkZAWzbkL4MwPb+h2Fz5650WKWZF7e5/6F4X/bg9V512Lf07tD7JoSQAwml1JU+pyZpxi4F8DXb+5kAZnaTaYSQA4CKEmmOc3l60uzesGqXW6SUEVldKQMx03PU6Qp3DPbMpMmliIm7MInbjiAsj2U+z7u2OrecNIjX2+UuWNLamUSfmrhP4RDRvjanzktoug10V2esrooFfhZuM6M8Rqu6YybcUQkSAtRYDy4jvEK+Ax5PmlmF0y8/LKhPWlDeHYBDkykc2tmFcZ22sNj//Dfwy+OhAOyZ/h4GXc02P4QQQgghxaBkfdJ02Dfig/vU+J7LBfuG2h26lueUeROPCeIxr1CKFO7oU71SR4RWaL5Y4iw/T1oeOWluUeMjxrSFQ2yHPClpkr+wd8yhKcEfNK0lOjP6KgdPWspIPysDMSREUJ1pXm3OESbm3SLNMEWaryfNCOqPELyWrr+aCDDgSAiAgXUDg68nhBBCCCGRKatIs29+Lz1phOuc/6bx0H61mdduT4xdELk3+lE20MVEzLC9Yuak6YjimfMj84zyeDa+4Y4Bfcjcy+ibVuuFngR60qJmpPkj8Ia8VsdjWgUb83lsUf64sK8rLXiUUlBKIQmFDhH0MvLwpMVsn4HlJfPrWRboSQtBV7gEAnzjX8B338xvTkIIIYQQoqXMIi27oT360L6Oc7rCERZ11XH0qUlvTvv3cm5I7eLG7Vkpdf25uCnS3Bv/QnLSdESZz494ST1p3nBHbVijj9Cxi27RLV2ED9gdOlod1+fHVZluWuucNSQXZ166BD+wv3o/DBEMT5oCyrq5sI/VnZNmEfcJdzRSeo+YDrfQ1nngRIBeA4FBI6PNSQghhBBCIlEx4Y7unltBBRgUFBb815n44zc/7tmX20WaWwCU2pOWDnf0rhlFVEXpt2URVII/DEtk5NN3LPc+ad5wR50nzWry7L3e9lpzzi4AP3Vsvd6IAETE89yr4zGt9rNCad2Ribl8xwxD4Z2trdhXnS4McmTCJdJCDY7px/p50oxkWqi5GX0pvE/U9QH4tAAghBBCCCHFp2I8aTUu11lYftGQvrU46ahBnk2/fZPtDXfM09A80eU4AdH6pOUS7piLoHOT8aTl8Wz8qzvqEXjFYNydOIho3ijvPE4B2Ktab1sQAu9zr47HtN9Fy5OWT7ijhaGAG/60Cvtq2gEARyXNnLKo4Y5+5VL8ctI6dgPzf+o8NuQY4PO/DTdW64ErtW86GBGJi8gbIvJX8/0oEVkkIutE5CkR8fboJoQQQgipQMor0mwb2iqXSAvaZNu9LG7PhT1M0H2uHIVDdBv8KJ6vXESafT6rpH5UMrlVOV2Vxq+6o58rTZeTpgtr9fNGTRg5OPPaLdJi4gyk7FWTh0gTr4Cujutz3bLPLf/vmOVRrUn0wXlt7RhifeaZcMc8xbdfdcdls4BtbzuP7Wg013QZ7gl39CkcUll8F8Bq2/u7APxSKXU0gF0AvloWqwghhBBCcqS84Y62PJ4ql7joXRutO0BwuKN7bInDHX2qFH790aWh17rL9gdhD5+0eySjeHWkgHDHvKo7uo7pPGlxEU+vtR9/9gRcOHZYdi4Bfv3lk3CmGdZYFXPmjvXOV6S5wx2rYlrR6OeBzOU5Wn9QGNQ+DDNadmSfTWRPms8YP5FWCNrqjpUT7igiIwCcB+C35nsBcBaA2eaQRwB8tjzWEUIIIYTkRkWEO8ZEvLlJAV4EpyfNeS6RtJXgL7Mnrcqn6MTufYnQa6OERFrYRZrdc5dLQ/CihjsG9UlzLaTPSfNeenj/OudUAkz56OH45IfTIi3mCncc2Cv3yDaBtxJnTTymfTaZ/nIaj15UrM/NcP8zLFT8+IU7BhJit7a6Y0XxPwD+C+ne2wAwBMBupZRVzrIZwHDdhSIyVUSWisjSlpYW3RBCCCGEkJJSEeGOItkcn5zncG2KHdUd3RvmEodnVcX0+UxRSOZZgt++Wi6PdNjAXtEHm/h50vzCOfXhjt7nI5rCIX1dntVsVcX0z7gr3HFQnzzSj7ThjjGt8PKripnPx224Z4ka7uj3fbYKhww4Eqjtnz0e1z0TK24zpHBILuuXGBE5H8A2pdSyfK5XSj2klJqglJpQX597wRlCCCGEkGJT5nDH7EbbnUsV1Y/kCXd0eJWc50rtSaupCm6EHERXnuGOdnIJ75x49CE4/ehDIo8HAnLSfNCVudB60jTTDneJSHfp+3jMqQCH5CPS4M0FjMf0TzHzR4UCwh0tvCLNeh/hX4FOyFkl+KvrgI990zavzvPps0akfLjKEGkAJgK4UESaAPwB6TDH/wUwUEQsdT8CwKbymEcIIYQQkhtl9qSZP8VbOCRoj2hvluwOn0skA5pZl3hTWeVTgj8KXWZuVJTLDR+R5u75FcapowaHjulfl/VouStyWgSX4PdWZQSAU0YNxiVmQ3Od0DlsQK3jvbvgiVtMHT7AGR4ZBYG+UqZOd2W/u65wx7w+7zw9aX7nrZw0iQEpW2htqiu6DVGokJw0pdQNSqkRSqmRAK4A8LJS6osAXgFwiTnsKgDPl8lEQgghhJCcqIicNIE3J80qHHHGMbl5d4KaWZfak+YXKufHCcOzoWmWwLKuv/+LJ/pe55e/lmuP6ygCo3dNVqRV59HM2r2EJdKOPawfquPZBtHuOdz5b+IOd3TlpI06pI//TfjZJ6IVtjotlM2nNMdE9P3qPIe+4Y75YO+dJrF0bzQLq/jH5x/WXJePSKsYT5of1wO4TkTWIZ2jprlxQgghhJDKoyKaWccEmQ06APSxVea7/OQjMhvbi8YNgxt3aJy9BH+5+6RVxyUnYWjPu7I8glGE04SRg3K2rRjoBAeQ9XROOMppl7vhtH2OmNi8Y+L0lo4dMcDXBuszjUm2SMvA3tUY1DufwiFAQuNJ0+XYWfl4uXhnm2ach0P71XqO+xcOyaO6o8SdIu3Q472XHHFqhHmjUHkiTSk1Xyl1vvl6g1LqFKXU0UqpS5VSneW2jxBCCCEkCpXhSRNnWOD8aWdmvBd2T5SuWqF7kxxUOMSv/1Z3UR2P5dzc2MISC1EqNP780nH4788cByC7Zf9QfZ+M0Il627k+nrBiL1M/8SHn/BBN4ZD0HArOap8DTZE19RMfwvPfPt3fZvPzr7KFOw7pU4MaHy9fEHbbTrIJTJ1Ic/fxiyrWdN/BvAuH6IhVIVsMJAaMvQL45kJgyNHe+Z2Lut5HKRxSGeGOhBBCCCEHGhUi0pxNmOtt3oaYZLeLluCxbx/de157TpHbC+Ue+9IPPol/TvtUXrZHoSruzcEK4vih2XBHyyM4oFe6Ul9N3L8ISa+aOMaOGJh+o4BH/98pePqa0zLnqyOWecy16IW7t52FpS3c593VHUWyYwylMvcXE+ATxxyCe68cjx9M/nCgDVaYob0E/yF9vd6qKNiF1v1fPBFNM84DAOgKbdaaIs1aM2q4ozXe/hxUIYVD3BUbYy5Pmghw2EedRUNimgIin77NWQkyikCs/HBHQgghhJAeSZnDHU0jRHwLh9hFjs4rFVyC3znW7e34j/q+OGpI7rlLUamOxyL3KvvHdZ/AeWOGeo7ffMHxuP6c43DWcYcGCr46UzSklMInPlyPQ/rWZrb4fmLKTa5bbj8voSVYdI2q7feQzlGzRJqzsbaI4IKxw3x7sVlYRVPisez1A3unhe2Kmz+N/6iP/vnaH6+9vYCueqb1vHMVttZwe6iooQrok1bnCgWNxW1KMOY8HjT/h6cAN2yMvm56ohzHE0IIIYSQKFRMn7Rqnw1/zNb/yhrvaGbtGt9l86S5RUQ5CodEDXc8+tB+Wvv61/3/7d15lFxVvS/w76+qq4d0RpIOmdMxCWACCYE2JGEwTN4wSEBBQGVwQlAEHJY3gk+ucrkXr/MV3sP48DqsOKCA8kRkurjE5QUZXphBEaKAXEBRBnkk6e7f++OcU7Wrap+xTp1zqvv7WQu764y7qk+O51e/vX+7grPWL3YyRQH7e+XwzSIi3udka8NFx+6J97+xoTtizM/HL0Pnnbfxb2r+Lb3XXdW/qTbNfRaF937NYNgb3zh1QndokOfH7C6plqxSb1etm2Yc3ns0/ybJC4doffYLcDNmliBNGoK0vU6IeI4AzKQRERERtUVX+CbtY45BasqkVbepLas+0MM/SjMzaY0P+1k/U3aVBDtjndOWKTTWBhyr1w1GbOX4e7pKeLlh2fH7zENfd30AEyUrZE6c7Z9Js69v7O5YMsYijozWujv6VPa3t2e01t3RFgDFYe5lTi8wYhuT5n52O4ZHEp3DGc/nXKstjUnrbQjSSl1GNRWfLo5SAo7+MnD/DwMOzDFpRERERHnJNUgrV4O05gdrL3thBg62IKJxyXBddcf6dUkmGm5FpatUV20yjDW2qAvSBH4Pz173O1s5/ok9XfjzK/VzZCX9KMwg0H9MmlrXm90bvQW1MWm1TGmcv5NX1KMstTFpUbuYNjG/ECiHdHd0g+J+tyJn1GqS3hcHU/oqeGW7Ux6/pTFpkbs7Gv/UpdQ8li0RZtKIiMaTwU3X5d0EakE7/37eOH5KTyG6OwJSVzjEZD5vly3dHZvHpIVnetJ0zMrmaQGq5xeJFTDYuvmZ7y+wu2NANcNJvZXE52+0w5gsvNenK2Etk1bfJmno7iio/Y1GR9UoqhH9M/Ni4HK5uVus2ZYo/DqU2gIwr3vpxr3n4t+OX4HT1w1GO4d7innT+qrLfEvwh2bSpLm7o1nd0Xw/ZeMakFL966TY3ZGIiIioLXKu7lj73a+ce10JfkvQ1ficuCOgBH/ambRHLtqAfzt+he/6kVGNFXDYYsq6IC2ou2PFf+yVOf9a0LGixLQvb69Njtxb8bl8vLFwjd1Nq/9Ta4O3zagxJi1ObD3iTj5tZtL85m8LIwIca5mLb+X8qdiwfFbdMq8E/47hUbxtaH5Td13fc7g/5+8yobqspcmsGzNp5mTWdd0dGzJpYdelX4B4uvEtHLs7EhEREbVFvtUdjW5djZk0W9ELawn+hgdcM9PTPE9avPatCJhEGXACo95KGecfuYd1kuKdI6OxxlfZMjlmvBEUZAZl0ib2NgdpUbqOhumplPHoP29ommy6Op7QaNK/HLdX3bgxrw3VTJrW3mucYLqaSStJ9fOLMgG4jQD48kmr8MS/Htm0bv+lM+peeyX4X9sZbUzabrtOdM7hvrfZU3qr6/yDtAh5wOXHAksOB6YscF6bY9LqBgCGVHds4nPugdcbx2EmjYiokYjsLiJbjf9eEpHzGrZZLyIvGtt8Kq/2ElExFaK7oxrl1z1ecZC67o62wMJYNDCppy5Ia67uGO+h8tqzD8Bb9pkbut0ZBy3GkpkTm5YPj2qsc9o2bRjC5cv7LE9ePb9p3SRbJs16/uC2/utb9sLl79yn+rq3UkJPV7kpKLKNJ3z7fguazitonCctQSbNG5NWsmfSbJUZ/Xjv397ttP61l0V8LULhkHsvfBOubZiQu6tUwocPc+aA08TdHRXomQS880fAtIVuQ32qO5qZNNs8aVGVcx3GSkRUeKr6qKrurap7A9gXwKsArrFsepu3nap+JttWElHRFaK6Y9CjaF3mxVaC313/wYMXY2QU+PptjzdtX9s2QSMjPuPbjr1zZLSpgmLcY9TNKxbyBh67+Ahrl9B+a3fH4EBEpDlGOHn1grrX3T5pQq/OhjVb15RJK7n7aGCQ5Mfs7mgeN22Nx3zdDGf+tTlT+myb1/EmJK8/HvChQ5fiSzf/trVMWnUfLw3ZZexvZtIaujsmVWKQRkQUw6EAfq+qf8i7IUTUWQoxmbUt26HGg35zhqS2fbVYhAi6y1JXia9pMusED+9x58EyDY9ovMIh1u6O0cakAU5FQtt7nGTp7mg9VMQiJbXNna0OWjpQt7w2mbVln4YXXdXCIbW/V5y/ktfd0QzIkwZpQbs1rvqH5bPw3ffuh1PWLGz5XC2NSavt5P6IWN0xKQZpRERxnATgez7r1orIvSJyvYgst20gImeIyF0ictfzzz/fvlYSUeHkXDgkSiat9ntQ4RARqU5i7Ln4uL3qt03Qxqjd5WwB1vDoaKyue7baKXXZreiHqmMbkxZWOCROoHPuoUvxq388uPra+8iiVKv0XpvdHeMYNbo7etMP+E0NECawO6nbtnWLp+PmjxwEEcG6JTNij3/ztjY/G//qjnEObBQL8X4PC9I2XlZfCMTkd92XUqgKSUQ0DohIN4BjANgmpbwHwEJVXQngqwB+bDuGqm5W1SFVHRoYGLBtQkRjVDGCNMvzoLdIRJqKiNR3d/SOVT+31T9u2ANzp9Z3RUsWBETbzt7dUWM9xNsCPXOZ+WB/0Ubrl25W1jFp1sIh0bN2plJJMNvo9lf9e4UcxCkk4vxuFg6Jw8ucdpVqWdS2ZNLcdbOn9GHJzEmJju8nne6O7j6VPgSPSZPam1n1TmCwfqxcje3cYv8mgYiIbI4AcI+qPtu4QlVfUtVX3N9/BqAiIjMatyOi8SvfyayrQZfzQHjUitlY+7rpddvUZdIsT9Fmt0izQqTtgT/Js3tL3R1HR1suHGI+E3vrZ07qwSlrByMfd2rkiZYjH7JJ2PQBnlGt76pqZtJqY9Kin9cMzMyALRn//WpfKLRyRRhnMk7lO5l1nHN5+1T6grs7ttLVMY251YiIxo+T4dPVUURmAXhWVVVEVsP50vwvWTaOiIqtpa/FReQEEXlQREZFZCj2yRtK6l/29n3wTneMj1khsJotszx814I0oNsoQ59GiXmzHUkMj2isgMG2qdmFs1b9MN47WTSjP9Jky/WFQ2ovbvv4wfj1pkMC9zW3/x9HL8OMid2YObl5WoL685kl+JN1d/QCs7KZSaur7hj9WEGn94Ll0ZSCNPO9pptJmxDc3bGlIC1asE9ENN6JSD+AwwFcbSw7U0TOdF8eD+ABEbkXwL8DOEnT+haQiMaEVjNpDwB4C4CvJdnZUgekqjrXljmZtfhu3jQmzT7mKtvCIXOn9lnH0flr3rbuPbk/4yaKusqCU9YuxDd/vS3k7PbCIebEy1Fs2HMWNuw5y14Qxjyf0fNuZFSTdXfUWmBWHZ+WtLtjwLpaxi/RoQPP5TsmLdYB3X26eo1lZhra/acepfx+3zT7hc9MGhFRJKr6dwDTG5Zdbvx+KYBLs24XEXWOljJpqvqwqj6adH/vYdr63OtlyIwWli3lAs1gzpZ1qpOku2PEL7bMqpJzpvTi8nfugy+euHfLmTRzf7NIShxJuv+lUcXe1k5vfjF3i7pxiYkyaSPNY9LMy+TDhy+NfcwgaWXSIlV3jJUGdIOvVrs7vvcW4AO329cxk0ZERESUicyqANjKyJYaxqSZ7Jm05u1r3SIROiYtUSbN5zl52ezJda+HR+o33LDnbEzpq1TnAYvCFtSYXTiTjNkCgHKpFOt5H7AXMUnDhO4uXP2BdQCcv1GtwqcmCgzPWr8Yy+dMxobls4yJrWuf2YY9Z2PxQH+kYwUFv1EqkcZhfr6qKXR37HEnU6/r7mgcN2qQNm8ImDTLvo6VHYmIiIgyERpBiMjNIvKA5b+NcU5kKyMbmEnzGmgGaQGtbcqk2cr1x2mwyy+4+f7719S9HnYnVW4Upxy8bcu6TJr7M26w6RwjXngRlHzbdXIPDlyavAiVF+B++PDdqudxujvG/wsNzujHdecciGn93dWsWuN1Ynvnh+wxs2lZlO6OUTKr6xZPxxsGpwVuU59J8yvBH+Nv1jvF+VnpRWB1x8hdKS3nZndHIiIiokyEjklT1cPadfJSwLOomSHzeBkS+5i0hvFbtjm6Qp5PTxyajzlT+/BYj7ZeAAAgAElEQVSlm39bXebXvW1yb/0D67DR3dHcI86YNFuQ0mUZZxe392K5oUS+HzVaHpRVuuP81i6J3koZ2y45CgBw++NOMaukJfhNtkwaAOsFc9b6xfjPR56rWxalBL9PLF7nu+9bg6f++ioO+OytAcczMmlNKxMkuLvdTFpXHzCyvfk43li0qMe2Xfded8c9jgYe+Wn8NhIRERFRJDmX4HceGEcCMgYSkkmLVYLfJ1dy7dn7o69SxtJdnfmvzCAtai5j54h9yzjjwWxBQndd4ZBk1R3LJUF/Txe2XXIUBjf5TF7c2JZYZ0iuWpBjNN6ccjbVMWkNh+mtNBfLsFf/9D+/F2xH7b3q9zeqDhczlvkXDgm5+sx/N11uJU0d9anuWGleFpcXpL3t28DIzuTHISIiIqJArZbgP05EngKwFsB1InJDnP27Io1Jqy2zTX7tZX9KUh/QWB/CfZ7BV8ybWg3QmtoRMUobHrGnWKoP9xHiD1v7uiyBZ/wxaQmCn5SitN5KCR/fsLvv+tpk1hq7IEojsxy/afOp+/qe1xR0+kP2mInT1w3i08fsGaktfkGadz0Fz5OWoLuj1xVxZAfS6e5oO4dRIbLSG7wtERERESXWUiZNVa8BcE3ik7tPyiMBdc1FxM1wKLq87o51hUNq23XVBWn2Y3nMghzBmtu2q2X+r2Gf9xBl3J3HFqTUV3dMlklLVN0RQF+lHJjljOKRi44IPo9R2r7V7o6jRjl+07xpE7B60S74zRMvVJfF/Qwr5RL+6ZjlkbcPy7gFz5PmvY4TpLlZrpGdtd9tQVrkY1r7IEdvDxEREREllmt3R28MmS2+qQZfxjJrd8fquvrujraua+az+30XvilSGxufS6/5wDrMm9Y8b9hOv0ya26a+Shmv7hgJPJctbLAFbllk0kQEWy9s23DEqrKRTU1SOMRU6+7YfJzRhous1XOFCe3uGKUEf6NDPwXc8hn7Oi8wG93pU4Lf7fKpEQbV+RkNvn6JiIiIKB2ZleC3Cap86HVjFKn9bisc4j18d5XCJ7P2AreerpJ1nJK9HfVWLZiGgUmWTFrImLQ1r5uOT4dkYsIChwnd5UjbNbch/p9ZBOjpKqOnK9rnlFS1uqPWJrNOWv5/2Ke7o3d8k/X6SDFuC/sbRRqT1vgNwR5v9j/glPnOz8lzjaNbSvBHqXxiOzcAKIM0IiIioizkG6QFBA+1TFpw4ZBaRT+p68Joe0hO0p0u6uTFZgl+c5ey0UXztHWDgccICxJmTel1t4v3RhLEaIm6SCZRKxwS/301Gg0K0iJk0tKcG86Wzas/WW2sou+YtMavCCbP9j/e7kcAb78SWPcho3CI2SB3zFpLmbTh5PsSERERUWQ5d3cMyKQZBRa8MWnVB2vj2XXUCNLMTJrtQT1JDBAwXK5OWHXHaGPSgtfPdoO0uPFTkkxaomIjCcyY6GQl17xueuvdHd0P2db2xmA7revDT1h9jmquSwSjfpNZN35BEDSZtAiw2z/Ufm+Uxpg0dnckIiIiykSumbRK0OzUFtaH79HauvoiG7YjSMA6uyiTFwPh1R2jCMvkeHOdBRVasYnahLqK7knSbwnMmtKLX3xsPc4/co/WC4cEZtLqX8et7hhXWMDprRfEKMEvJWD9J4CusMqKtiAtjTFpzKQRERERZSHXTFrQmDQbW6VEL0PSVSrVPZzbHtTbmRza6RM4xek2GLap193xL3/fEfmYQLJuhFll0gBgcEY/gNaLecQpHGItyJJBd0dp+KJAJEbhECkB6zcB8/cDvnOs/8mr57aMSWPhECIiIkpZ1Hl449p2yVFtOW4nKHwmzXzWNSsBempzY9UHFraH5CQl7NOaJy3KccKCqT632Mn2ndEelt+yam6k7WyyGpNmajWTtdssZ647L5g1NRYOKQlw5fvX4pQ1C1s7qQ+/91ItiONtB4k+T1opYhGXoO6OzKQRERERFV7OhUOCxqQ1RzX2sUbeulJd8GULeLzdo1Z2BGoP1WH8eiB62cJIY9JC1nvHitrb8fMnrMSj/7wh2sYNGucay0KrmbRzDlmCqz+wDqsWTGtaZyvBv3rRLrjo2Nrk1JlWd6zLpEXt7hi1gZY6/6WYhUPMf397neAuYyaNiIiIKAuFmCctiBls2YI0rXZ3lLrugkGFIXoiT2Td+vy95Rhju8Ie7L1xYlHHpJVKgp6o2Zemc3VekNZVLmEfS4AG2DJptu6O6fHrLlrr7ljr9ug7mXXSa68a5JlBWtwxae7Jz9nq7HP/D5lJIyIiIspIYcekvWHRLvjJ1j9hgpH1Cpr/qlyShjFpzcf0HozjBGlRS/CbzOxbdRxdpP6Owau9apiNAUccN3/kIPzxhVdDt8tyTJqnnadsKsFvvT7SO1/Ye/FWl0Sag7TI4aLPdZBmd0cRoMspWMMxaURERETZKOw8aZ996wrccN5BmNbfXX1m9bIftsmsyyWp66IXlCmJM0Fz1Hho+ZzJ1uVxgp2wTb3MY9zqjqYlMyfhkD12ta4zj5o0SGsl0Gl1nrQg7z1gUd1re9YuvfOHvZdqJg2WedKqYgRhdetLzduVA8r3Bx8MqHhBGjNpRERERFko7DxpvZUydncLQXjs3R1r68xiIfbJrN1MWiVGd8eI2333fWtwzx//inf9x511y7tSLBziZR5bCdKiShKk/ejMtZg9tS/xOaOc8tvvXp2oF+Dp+y/C6fsvwm6fvB47hkftQXyGyUMzk9YUHFa7Oybu79i8KLRsf4PqRIWlWiatkvxvS0RERETR5dzdMV4izxbwjBhj0sJK8Ecdk3b9uQdiSl/FPVe0B+UpfRUMLXTGQ5mZqnJDIPq+Axfh67c9AQCY3NuFl16rZSfCYoS488q1IsmYtKHBXVo6Z8kYp+XnoN0GWjpHLTjyX5eFkmXYWHNLEgZptg+wMiH5sSq9wGGfBnZLVoSGiIiIiOLJN0iLGQh43RnNMV9eVqlUkrrsiC1T4sVbYd0dXz+71nUxTjJjUm8Ft3/iUEyf2F1d1jgVwAVHLUN/Txe+fPPvcPr+izClr4K/bx/2bbMpy2IeuYxJyyAGrVVVzP791bXDKyBiLiy7143XXbHcDauwi9JWOKQSM5NW/TfmHuOA82LuT0RERERJFb66o8k295n3vNpY3dEWY2wfdoomxKruGKuFzXN01cbR1Y5UnTRZFe8xxkqZb++qs9ZV50XzZJlJyyNIyyJw8j57ayYtw8CtMVj8+4Yvo3/x/s7CnonAwRcArz8m7CjRl7eSSSMiolhEZBuAlwGMABhW1aGG9QLgKwCOBPAqgNNV9Z6s20lExZVrkBY3ELBNDD3qW92x+djbh53qdLHGpLVYg9/2jOtXYd3cdt+FzaXksw3Ssq8p02oJ/ii8U1i7w7b97M289mzf6x3o7zcyZ2/8eO33s34NPPugZe+QwiLm59nKmDQiIkriYFX9s8+6IwAsdf/bD8D/cn8SEQHIOUiLK6gEf1epVJcJsU3GvH2nl0mLXt3Rq9Fx3mFLcdyquXGaW8cW6zUuk5AwIWjKgjSY7clnnrT2n8M7hS1rlmXSyAtIq5nWoC8Ddl3u/OeJWt2xrrtjwkxaLqErEdGYtxHAt9W5+d8uIlNFZLaqPpN3w4ioGDoySDMfZ2vVHeu3tWVlXnMzab0JqjsetNsAFk7vj7yfp1oCQpuXNW0bVoI/w+xWLt0dMwgIzEmk8zl/w093eayCnbP3BnomA2/8x+j7xB6T5mJ3R6LCGNx0XduOve2So9p27HFKAdwoIgrga6q6uWH9XABPGq+fcpcxSCMiAB0SpNWyH/7bNHbPs41fS5JJ86KrxI+q1a6Nxpg0yzIgvLtfpSu7B+Y8MmlZxAO2oDnL81d7EXqFQyxjFkP1TQU+8aT/+upJzO6OScvnM0gjIkrgAFV9WkRmArhJRB5R1V/GPYiInAHgDABYsGBB2m0kogLriAEn3uNryW8wF5qDClvSadWCqQCA9btHL+PedO4UVB/Mm7o7Bgua/Dtttu6iY0KL1e3T4l1O79p/EAAwqSfpZNMRxb52LIEeERFFoqpPuz+fA3ANgNUNmzwNYL7xep67rPE4m1V1SFWHBgZam4KGiDpLRwRpnm63KuNZ6xc3rWvsnmfrrrdqwTQ8ctEGrN99ZuRzNo4dSso6Jq3hdWh3xzaPSTPlkUnLwpb37oeTVy/A5L58ksiN3Rw/ePASbLvkKPR1x8juZqF6wY7N64CIqF1EpF9EJnm/A3gTgAcaNrsWwKniWAPgRY5HIyJTR3R39HSVxLfffGNQ5hdU9VbiPQx/9eRV+Navt2H5nMnhG1sEjXNqyqSFzZPW5uqOZpe7PMaktVhIM5IV86Zixbyp1nVZJo2yKffPAIuIKAe7ArjGvc93Afiuqv5cRM4EAFW9HMDP4JTffwxOCf535dRWIiqoQgRpsyYHFzWojkkLeOiMGqTFNX+XCfjk0csS72/roek3Ji3MeMmk5dXDLo950toj576cGROR+QC+DefBSAFsVtWviMguAH4AYBDANgBvU9W/5tVOIhofVPVxACstyy83flcAH8yyXUTUWXIP0u7+5GHoiZjdCnqwbQwq8sgE2SwemAgAOHGo1vW8Npl1vGON9eqOecvyHbc3RktjPFlHBXrDAD6qqve4XYzuFpGbAJwO4BZVvURENgHYBCBGSUwiIiKifOQepE2f2BO6TW+ljO3Do4HbNBa6KEqMMTCpp6mLZtJn5yyLeYzLIG2sd3f8wB1AJWaVxw4oHOKO43jG/f1lEXkYTinrjQDWu5t9C8AvwCCNiIiIOkDuQVoUV521Fjc8+GzgeLKm6o6d8HCZdwMCnL5uUd5NyFwW86R52hsD+1xZM/eIcYgiX53+RGQQwCoAdwDY1RiI/99wukPa9mGJayIiIiqUjgjSlsychCUzJwVuE6W6Y1HU5uoq1oPwvGkTAACfOnoZlsycmHNrspdtJq2NB0+lu2PnEZGJAK4CcJ6qvmRmK1VV3Ullm7iTzG4GgKGhoWL9oyQiIqJxqSOCtCga5xArciatWjikYI+Db9xtAFedtQ6r5turH1J6sszaJVOwizOEiFTgBGhbVPVqd/GzIjJbVZ8RkdkAnsuvhURERETRddQ8aUEaE2cZ1tiIrcgP6PsunDZ2J7IOkem7LvpHvGCt87MrfMxo3sRJmV0B4GFV/aKx6loAp7m/nwbgJ1m3jYiIiCiJMZNJayzEUC5wJs2TNFeRZSn+cSXlj/VLJ67E9H57kNPeTG8KE1Ef/w3ghceB7v5UWtRm+wM4BcD9IrLVXXY+gEsAXCki7wHwBwBvy6l9RERERLGMmSCt0Vjt7nj9uQdil/7udBtEANLPcB63al7AuTLQyr+B7n5g1l7ptaWNVPVX8P9ID82yLURERJSewU3XteW4jZXXi6ilIE1EPgfgzQB2APg9gHep6t/SaFiritxlz8v6xZ3MGgBeP3ty2s0pjCSfR5rGXOEQIiIiIupIrY7cugnAnqq6AsBvAXyi9Salo8jVHT18li6WbCezzmGeNCIiIiLqCC0Faap6o6oOuy9vB+Dfv6tN5kzptS4v8pi04rYsX15g3RcwH147ZTPBtCOXedKIiIiIqCOkOSbt3QB+kOLxIrnunAPx/Cvbm5YXOEYrdNvytGbRdJxzyBKcum4w76a0TTUQ5DxpREREROQjNEgTkZsBzLKsukBVf+JucwGAYQBbAo5zBoAzAGDBggWJGmszrb8b0yyFNIrc3bGok1nnrVQSfORNu+d2/iyuGO9vXuRpGIiIiIgoX6FBmqoeFrReRE4HcDSAQzUg6lDVzQA2A8DQ0FDbo5Mid3f0MEQrljFTOISIiIiIOlqr1R03APg4gDeq6qvpNCkdRX4IznLsE0WXRXbL+9u390wM/4mIiIg6WavVHS8FMAnATSKyVUQuT6FNqShyINTKPGnURhleMplMEVHgfwNERERE5K+lTJqqLkmrIeOJ9+g8yiitUDLt7tjOg/O6IiIiIuporWbSKAlmOAop03nSMinBz+uMiIiIqBMxSMsR8x3jGbs7EhEREZEdg7Qc8NG5mLIYx+idoa1D0tjdkYiIiKijMUjLAQuHFFMm86R558oky8WvA4iIiIg6EYO0HNRKvTNKK5IxUziEiIiIiDoag7QcMZNWLJnMk+b9zKRwCBERZU1E5ovIrSLykIg8KCLnWrZZLyIvutMXbRWRT+XRViIqrpZK8FMyrOdQTFn+XUpZnIwXGhFRHoYBfFRV7xGRSQDuFpGbVPWhhu1uU9Wjc2gfEXUABmk5qHZ2ZMKD2oEXVscb3HRd3k0gooRU9RkAz7i/vywiDwOYC6AxSCMi8sXujjmoFg5htzRqC86TRkRUBCIyCGAVgDssq9eKyL0icr2ILPfZ/wwRuUtE7nr++efb2FIiKpoxF6Qdt2ouJvd2RoKQCY9iGTO9A3smOz97J+fbDiKicUxEJgK4CsB5qvpSw+p7ACxU1ZUAvgrgx7ZjqOpmVR1S1aGBgYH2NpiICqUzopkYvnTi3nk3IVRXyYmNu8pjJSoYG7IoHJKJoXcDIzuB1Wfk3RIionFJRCpwArQtqnp143ozaFPVn4nI/xSRGar65yzbSUTFNeaCtE7w5pVz8MCfXsS5hy7NuylkGDOZtHIFWHd23q0gIhqXxJkI8woAD6vqF322mQXgWVVVEVkNp2fTXzJsJhEVHIO0HHR3lXDhm63dzylHYyVGIyKiXO0P4BQA94vIVnfZ+QAWAICqXg7geABnicgwgP8H4CRVDoIgohoGaUQuGTOpNCIiyouq/goh3/up6qUALs2mRUTUicZc4RCipLII0RgHEhEREVEYZtKIMsTOLERURO2am2/bJUe15bhERK1o53ykad33mEkjcjHLRURERERFwCCNyJXFmDQGgkREREQUhkEaUQ7Y7ZGIiIiI/DBIIyIiIiIiKhAGaUQ5YLdHIiIiIvLD6o4F84bBaZjYwz/LWMfujkRERETkh9FAwfzwzHV5N4HaiBk0IiIiIgrD7o5EGWIGjYiIiIjCMEgjIiIiIiIqEAZpRBlid0ciIiIiCsMxaTTuVcqCnSPZ9EM8ZuUcPPD0S5g1pTeT81F7DW66Lu8mEBVau/6NbLvkqLYcl4ioKBik0bj38/MOwtY//i2Tc73vwNfh1LWD6K2UMzkfERGNP/wCiajzMUijcW/xwEQsHpiYyblEhAEaEREREQXimDQiIiIiIqICYZBGRERERERUIAzSiIiIiIiICqSlIE1ELhKR+0Rkq4jcKCJz0moYERERERHReNRqJu1zqrpCVfcG8FMAn0qhTURERERERONWS0Gaqr5kvOwHkM1kU0RERERERGNUyyX4ReRiAKcCeBHAwQHbnQHgDABYsGBBq6clIiIiIiIak0IzaSJys4g8YPlvIwCo6gWqOh/AFgBn+x1HVTer6pCqDg0MDKT3DoiIAojIBhF5VEQeE5FNebeHiMa+sPuOiPSIyA/c9XeIyGD2rSSiIgvNpKnqYRGPtQXAzwBc2FKLiIhSIiJlAJcBOBzAUwDuFJFrVfWhfFtGRGNVxPvOewD8VVWXiMhJAD4L4MTsW0tERdVqdcelxsuNAB5prTlERKlaDeAxVX1cVXcA+D6cexURUbtEue9sBPAt9/cfAThURCTDNhJRwbU6Ju0SEdkdwCiAPwA4M8pOd9999ysi8mjCc06BM/4tq/0AYAaAPyfct5Xz5tXmVs/Nz7r95y1ie3dPeMx2mgvgSeP1UwD2Mzcwx8sCaOXeBLT+7y4tRWkHUJy2FKUdQHHaUpR2ADHbIp+NffyFsfdILvS+Y26jqsMi8iKA6Wj4DFK+P/kp0nUQhO1MF9uZrmo7Y96ffO9NLQVpqvrWhLs+qqpDSXYUkc2qekb4luns5+57V9btTWHfxG1O4dz8rNt83iK2V0TuSnLMvKnqZgCb0zhWq//u0lKUdgDFaUtR2gEUpy1FaQdQrLYUSZr3Jz+d8tmzneliO9PVjna2Ok9aHv5Pxvu1qpXz5tXmVs/Nz7r95+209ublaQDzjdfz3GVERO0S5b5T3UZEuuD0UvhLJq0joo7QcUGaqiZ6SEy6X6taOW9ebW713Pys23/eTmtvju4EsFREFolIN4CTAFybc5uIaGyLct+5FsBp7u/HA/hPVeVcs0RU1fI8aQm1NXXfBp3WXqAz2wx0Zrs7rc3tam/hPgd3rMfZAG4AUAbwDVV9sI2nLMpnUJR2AMVpS1HaARSnLUVpB1CstrTE774jIp8BcJeqXgvgCgDfEZHHALwAJ5DLS6d89mxnutjOdKXeTuEXN0RERERERMXRcd0diYiIiIiIxjIGaURERERERAXS1iBNRF5p5/HTJiLHioiKyB55tyWusM9aRH4hIoUoYSoi80TkJyLyOxH5vYh8xR1c7bf9eSIyIcs2+rSD1zOFEpGLROQ+EdkqIjeKyJyc2vE5EXnEbcs1IjI1j3a4bTlBRB4UkdE87kMiskFEHhWRx0RkU9bnN9rxDRF5TkQeyKsNbjvmi8itIvKQ+3c5N8e29IrIb0TkXrctn86rLeNZke4XQfK+l4Qpyr0mSFHuQ0GKdI8K0u77FzNp9U4G8Cv3Z2QiUm5Pc8YeEREAVwP4saouBbAbgIkALg7Y7TwAuQdpHYjXcz4+p6orVHVvAD8F8Kmc2nETgD1VdQWA3wL4RE7tAIAHALwFwC+zPrF7PV8G4AgAywCcLCLLsm6H65sANuR0btMwgI+q6jIAawB8MMfPZDuAQ1R1JYC9AWwQkTU5tWU8K9L9Ikhu95IwBbvXBPkminEfClKke1SQtt6/2h6kichEEblFRO4RkftFZKO7fFBEHhaRr7vR540i0tfu9gS1E8ABAN4Dt8qSiKwXkV+KyHXuNyOXi0jJXfeKiHxBRO4FsDavdpvc9v7UeH2piJyeY5NsDgHwmqr+BwCo6giADwN4t4j0i8jnReQB99u8D4nIOQDmALhVRG7Nsd0AeD1TOFV9yXjZDyCX6kyqeqOqDrsvb4czV1MuVPVhVX00p9OvBvCYqj6uqjsAfB/Axjwaoqq/hFPJL1eq+oyq3uP+/jKAhwHMzaktqqpeL4WK+x8rmmWsSPeLIDnfS8IU5l4TpCj3oSBFukcFaff9K4tM2msAjlPVfQAcDOALbjYFAJYCuExVlwP4G4C3ZtAePxsB/FxVfwvgLyKyr7t8NYAPwflWZDGcb3AA5+HrDlVdqaq/yry1nWs5gLvNBe5D7R8BvBfAIIC93W/ztqjqvwP4E4CDVfXgjNtqw+uZQonIxSLyJIB3IL9MmundAK7PuxE5mQvgSeP1Uyjg/9nnRUQGAawCcEeObSiLyFYAzwG4SVVzawsBGN/3i1bwXtMGRbhHBWnn/SuLIE0A/IuI3AfgZjgX7K7uuidUdav7+91wHtDzcjKcbz3g/vS6iP3G/VZkBMD34GQnAGAEwFXZNnHMWw/ga963eapaxG96eD0TRORmN+Pb+N9GAFDVC1R1PoAtAM7Oqx3uNhfA6TqypV3tiNoWKhY3434VgPMaMsCZUtURt3vwPACrRWTPvNoylhXpftFqO2l8KMo9Kkg7719ZTGb9DgADAPZV1Z0isg1Ar7tuu7HdCIBcuoeJyC5wuuHtJSIKZ/JJBXAdmtOW3uvX3AfdIhlGfeDd67dhjh4CcLy5QEQmA1gAYFseDYqJ1zNBVQ+LuOkWAD8DcGEe7XC7Ox8N4FBt86SYMT6TrD0NYL7xep67bFwTkQqch58tqnp13u0BAFX9m9utfQOcsUeUoiLdL4IU+F4ShveaFBXxHhWkHfevLDJpUwA85z7QHgxgYQbnjOt4AN9R1YWqOuh+A/4EgAPhRMWL3LE7J8IpxFBUfwCwTER6xKnMdGjeDbK4BcAEETkVqA60/QKcgaw3AHi/iHS563Zx93kZwKTsm2rF65kCichS4+VGAI/k1I4NAD4O4BhVfTWPNhTEnQCWutd9N5wxmtfm3KZcuV20rwDwsKp+Mee2DLj/fwV3HO/hyOnfzHjG+0UqeK9JSZHuUUHaff9qW5DmPmhvh/NN8pCI3A/gVBTz5nsygGsall3lLr8TwKVwBi0+Ydkud95nrapPArgSTgR/JYD/m2vDLNxv544DcIKI/A5OFanXAJwP4H/DGZt2n1vA4u3ubpsB/FxyLBzC65liuMTtmnMfgDcByKt08KVwvty4SZzpAC7PqR0QkeNE5Ck4RWmuE5Ebsjq32336bDhfAj0M4EpVfTCr85tE5HsA/gvA7iLylIi8J492ANgfwCkADnGvja0icmRObZkNpzDUfXDuTzep6k9D9qH0FeZ+ESTPe0mYIt1rghToPhSkSPeoIG29f0m7MtoishLA11V1dVtOkAERWQ/gY6p6dN5tCTIWPuuiGwufcadcz0RERETjXVsyaSJyJpyiBJ9sx/Gphp91+/EzJiIiIqIstS2TRkRERERERPFlUTiEiIiIiIiIIkolSBOR+SJyq4g8JCIPisi57vJdROQmEfmd+3Oau3wPEfkvEdkuIh9rONYGEXlURB4TkU1ptI8ojpSv52+IyHMiwnLSRERERBRJWpm0YQAfVdVlANYA+KCILAOwCcAtqroUTul1L+h6AcA5AD5vHsQtx34ZgCMALANwsnscoiylcj27vglnzgwiIiIiokhSCdJU9RlVvcf9/WU4pUfnwpkj6FvuZt8CcKy7zXOqeieAnQ2HWg3gMVV9XFV3APi+ewyizKR4PUNVfwkniCMiIiIiiiT1MWkiMghgFYA7AOyqqs+4q/4bwK4hu88F8KTx+il3GVEuWryeiYiIiIhiSzVIE5GJcCbNPU9VXzLXuZMYs5QkdQxez0RERESUh9SCNBGpwHmg3aKqV7uLnxWR2e762QCeCznM0wDmG6/nucuIMpXS9UxEREREFFta1R0FwBUAHlbVLxqrrn0Z26cAAADSSURBVAVwmvv7aQB+EnKoOwEsFZFFItIN4CT3GESZSfF6JiIiIiKKLZXJrEXkAAC3AbgfwKi7+Hw443iuBLAAwB8AvE1VXxCRWQDuAjDZ3f4VAMtU9SURORLAlwGUAXxDVS9uuYFEMaR8PX8PwHoAMwA8C+BCVb0iw7dDRERERB0mlSCNiIiIiIiI0pF6dUciIiIiIiJKjkEaERERERFRgTBIIyIiIiIiKhAGaURERERERAXCII2IiIiIiKhAGKQREREREREVCIM0IiIiIiKiAvn/QS3mOaktSooAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df = df_white\n", + "order = (2, 1, 0)\n", + "run_tests(df, order)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-30T22:07:33.012134Z", + "start_time": "2020-04-30T22:07:31.564040Z" + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Statsmodels results css:\n", + "Fitted parameters: mu=0.77, p=[-0.02 -0.06], q=[]\n", + "AR roots abs:[4.23 4.23]\n", + "MA roots abs:[]\n", + "Train error mean: 0.00, std: 20.78\n", + "LL: 5147.77\n", + "RMSE: 46983.52\n", + "\n", + "Giotto results css:\n", + "Fitted parameters: mu=0.77, p=[-0.02 -0.06], q=[]\n", + "AR roots abs:[4.23 4.23]\n", + "MA roots abs:[]\n", + "Train error mean: 0.00, std: 20.78\n", + "LL: 5147.77\n", + "RMSE: 45068.92\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df = df_real\n", + "order = (2, 1, 0)\n", + "run_tests(df, order)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-30T22:07:34.409667Z", + "start_time": "2020-04-30T22:07:33.016391Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Statsmodels results css:\n", + "Fitted parameters: mu=-0.01, p=[-0.32 0.01], q=[]\n", + "AR roots abs:[ 2.91 47.31]\n", + "MA roots abs:[]\n", + "Train error mean: 0.00, std: 0.72\n", + "LL: 435.19\n", + "RMSE: 10.55\n", + "\n", + "Giotto results css:\n", + "Fitted parameters: mu=-0.01, p=[-0.32 0.01], q=[]\n", + "AR roots abs:[47.31 2.91]\n", + "MA roots abs:[]\n", + "Train error mean: -0.00, std: 0.72\n", + "LL: 435.19\n", + "RMSE: 11.30\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df = df_arima\n", + "order = (2, 1, 0)\n", + "run_tests(df, order)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Full ARIMA check" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-30T22:07:49.825647Z", + "start_time": "2020-04-30T22:07:47.983614Z" + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Statsmodels results css:\n", + "Fitted parameters: mu=0.00, p=[0.56 0.03], q=[-1.6 0.6]\n", + "AR roots abs:[ 1.64 18.49]\n", + "MA roots abs:[1. 1.67]\n", + "Train error mean: 0.00, std: 0.96\n", + "LL: 547.51\n", + "RMSE: 1.10\n", + "\n", + "Giotto results css:\n", + "Fitted parameters: mu=0.00, p=[0.56 0.03], q=[-1.6 0.6]\n", + "AR roots abs:[18.5 1.64]\n", + "MA roots abs:[1.67 1. ]\n", + "Train error mean: 0.00, std: 0.96\n", + "LL: 547.51\n", + "RMSE: 1.10\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df = df_white\n", + "order = (2, 1, 2)\n", + "run_tests(df, order)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-30T22:08:05.450001Z", + "start_time": "2020-04-30T22:08:03.866579Z" + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Statsmodels results css:\n", + "Fitted parameters: mu=0.00, p=[-0.26 -0.07], q=[-0.76 -0.24]\n", + "AR roots abs:[3.89 3.89]\n", + "MA roots abs:[1. 4.23]\n", + "Train error mean: -0.04, std: 20.78\n", + "LL: 5143.23\n", + "RMSE: 43110.28\n", + "\n", + "Giotto results css:\n", + "Fitted parameters: mu=0.00, p=[-0.26 -0.07], q=[-0.76 -0.24]\n", + "AR roots abs:[3.89 3.89]\n", + "MA roots abs:[4.22 1. ]\n", + "Train error mean: -0.04, std: 20.78\n", + "LL: 5143.23\n", + "RMSE: 41591.34\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df = df_real\n", + "order = (2, 2, 2)\n", + "run_tests(df, order)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "ExecuteTime": { + "end_time": "2020-04-30T22:08:19.701916Z", + "start_time": "2020-04-30T22:08:18.201000Z" + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Statsmodels results css:\n", + "Fitted parameters: mu=-0.00, p=[-1.4 -0.6], q=[ 0.14 -0.76 -0.31]\n", + "AR roots abs:[1.29 1.29]\n", + "MA roots abs:[1.03 1.77 1.77]\n", + "Train error mean: -0.02, std: 0.73\n", + "LL: 438.80\n", + "RMSE: 31.23\n", + "\n", + "Giotto results css:\n", + "Fitted parameters: mu=-0.00, p=[-0.66 -0.3 ], q=[-0.62 -0.1 -0.24]\n", + "AR roots abs:[1.83 1.83]\n", + "MA roots abs:[2.03 2.03 1.03]\n", + "Train error mean: -0.02, std: 0.74\n", + "LL: 441.53\n", + "RMSE: 37.08\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA28AAAE6CAYAAACBE2qRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeZwcdZk/8M9TVd0990yOyUUSQiCEOwHCJaIIgUWBxesnoqvuLoIr6wWriCACLgoigqgryiEKsnjghYtXOJTDkJBgCCEJOSDkvjP3TB9V398fVdVdVV090z0zPdXT83m/XrzSXV1d/Z2kE/rp5/k+jyilQERERERERJVNi3oBRERERERENDAGb0RERERERKMAgzciIiIiIqJRgMEbERERERHRKMDgjYiIiIiIaBQwol6A18SJE9WsWbOiXgYRDbPly5fvVUq1Rr2OoeC/T0TVh/82EVEl6u/fpooK3mbNmoVly5ZFvQwiGmYi8mbUaxgq/vtEVH34bxMRVaL+/m1i2SQREREREdEowOCNiIiIiIhoFGDwRkRERERENAoweCMiIiIiIhoFGLwRERERERGNAgzeiIiIiIiIRgEGb0Q06onIj0Rkt4is8hwbLyKLRGS98+s457iIyHdEZIOIrBSRE6JbOREREVHxGLwRUTX4MYDzAseuAfCkUmoOgCed+wDwTgBznP8uB3D3CK2RiIiIaEgYvBHRqKeUegbA/sDhiwD8xLn9EwDv9hx/UNleANAiIlNHZqVERICIzBCRp0VktYi8KiKfdY7fKCLbRGSF89+7ol4rEVUWI+oFEBGVyWSl1A7n9k4Ak53bBwHY4jlvq3NsBwJE5HLY2TnMnDmzfCslorEmA+C/lFIviUgjgOUissh57E6l1O0Rro2IKlhFZt7mfvmP+N5T66NeBhFVCaWUAqAG8bx7lFILlFILWltby7AyIhqLlFI7lFIvObc7AayB/SUSEVG/Ki7zppRCMmPh9r+sw6fOmhP1coho9NolIlOVUjucssjdzvFtAGZ4zpvuHKNRZNY1j5ft2ptuPb9s1yYKEpFZAI4HsATA6QA+JSIfBbAMdnbuQMhzWBVAw6pc/6by39PhV3GZt4xV8pfjRFShtndtx7/+6V+jevnHAHzMuf0xAL/zHP+o03XyVADtnvJKIqIRIyINAH4F4HNKqQ7YDZQOBTAfdin3t8Kex6oAorGr4oK3VMbK3v7jK/w8RTRa7e3di4//5eNYd2Bd2V9LRB4BsBjAXBHZKiKXArgVwDkish7AQuc+APwBwOsANgC4F8AVZV8gEVGAiMRgB24PK6V+DQBKqV1KKVMpZcH+9+nkKNdIRJWn4somn1izK3v7kw+/xHQr0SjUnmzH5Ysux97evbj33HsxH/PL+npKqUsKPHR2yLkKwH+WdUFERP0QEQFwP4A1Sqk7PMeneioB3gNgVdjziWjsqrjM22d/tsJ3/4d/2xjRSohoMHrSPbjiySuwqX0T7nrHXZjXOi/qJRERVZrTAXwEwFmBsQC3icgrIrISwDsAXBnpKomo4lRU5s1S+fvdbvnjWnz8jNnQNYlgRURUirSVxlV/uwqr9q7Ct97+LZw27bSol0REVHGUUs8BCPtg84eRXgsRjS4VlXkr1KzEuw+OiCqTpSzc8PwNeH7b8/jKqV/BwoMXRr0kIiIioqpSUcGbWSh4Mxm8EVW6by//Nn7/+u/x6eM/jfcd/r6ol0NERERUdSoreDOZeSMajR5e8zAeePUBXDz3Ylx27GVRL4eIiIioKlVU8FawbJKZN6KKtejNRfjG0m/g7Jln40snfwl2EzUiIiIiGm4VFbwVKptMM/NGVJFW7F6BLz37JRzXehxuPeNW6Joe9ZKIiIiIqlZFBW8ZKzxIY+aNqPJs6diCzzz1GUyum4zvnvVd1Bg1US+JiIiIqKpVVPBWsGEJM29EFaU92Y4rnrwCFix8f+H3Ma5mXNRLIiIiIqp6FTXnjd0miSpf2kzjqr9ehW1d23Dfuffh4KaDo14SERER0ZhQUcEb57wRVTalFL625GtYunMpvv7Wr+OEySdEvSQiIiKiMaPsZZMicp6IvCYiG0Tkmv7OZdkkUWV7cPWD+NX6X+GyYy/DhYdeGPVyiIiIiMaUsgZvIqID+B8A7wRwFIBLROSoQucz80ZUuZ7d+izuWH4HFs5ciE8d/6mol0NEREQ05pS7bPJkABuUUq8DgIj8DMBFAFaHnZwxLXz8rYdg/swWPLNuDw6f3IibH1+DNPe8EUXq9bbXcfUzV+PwcYfja2/9GjSpqF5HRERERGNCuT+BHQRgi+f+VudYKAXgfSdOxwXHTcNt75+HdxwxCQAblhBFqSPVgc88/RnE9Ti+847voC5WF/WSiIiIiMakyL8+F5HLRWSZiCxr0k0cObUp+1hct5eXZNkkUSRMy8QXn/kitnVtw51n3ompDVOjXhIRERHRmFXu4G0bgBme+9OdY1lKqXuUUguUUgsOnjLe9+SEYS+PZZNE0fjeiu/huW3P4Usnf4mdJYmIiIgiVu7g7UUAc0TkEBGJA/gggMeKfXLcCd7YsIRo5C16cxHue+U+vG/O+/CBuR+IejlEREREY15ZG5YopTIi8ikAfwagA/iRUurVYp8f0xm8EUVhY9tGXPfcdTiu9Thce8q1US+HiIiIiDACQ7qVUn8A8IfBPNfNvHHPG9HI6Up14XNPfw61Ri3uePsdiOvxqJdERERERBiB4G0oYrqGphoD+7qSUS+FaExQSuH656/Hls4tuPfcezG5fnLUSyIiIiIiR+TdJgcytbkWO9r7ol4G0Zjw4OoH8cTmJ3DliVfipCknRb0cIiIiIvKo+OBtSnMNdnYweKPySZsW1uzoiHoZkVu+aznuXH4nFs5ciI8e9dGol0NEREREARUfvE1trmHmjcrqa4+vwTvvehab9/VEvZTI7Ovdh6v/djUOajgIXz39qxCRqJdERERERAEVH7xNaqrB3q4kTEuFPt7Wk4JS4Y8RFWP5mwcAAAd6UhGvJBqmZeKaZ69Be6odd5x5BxrjjVEviYiIiIhCVHzwNr4uBqWA9t607/iW/T14dPlWzP/qIjzw/KZoFkdUBe595V68sOMFXHvKtZg7fm7UyyEiIiKiAiq62yQAjKu325Tv705hfH2uZfkZtz2dvf3k2l3497ceMuJro+oyFisFX9z5Iu5++W5cMPsCvOew90S9HCIiIiLqR8Vn3sbV2QFbm6ekjWWSVA5j7W21v28/vvjMFzGzcSauP/V67nMjIiIiqnAVn3kb78m8ufZ1+/cmCfihkwZPwY7azDEUvVnKwnXPXYf2ZDvuXng36mJ1US+JiIiIiAZQ8Zm3lroYAKCtJ7fnrTdlRrUcqmLpjBX1EkbMQ6sfwnPbnsMXTvoC97kRERERjRIVH7y5ZZP7PWWTwc6TbuaEaCgyBTqaVptX972Kb7/0bZw982xcPPfiqJdDREREREWq+OCtLq4DAHo82baMNXYyJFRem/f1YNU2e0B3yqz+91VPugdX/+1qTKiZgJvechP3uRERERGNIhW/501EUBPTkEzngre0OTYyJFR+n//ly9nbY6Fs8palt2BL5xbc/0/3oznRHPVyiIiIiKgEFZ95A4CamI5eT/BWaGA3Uam8Wdxq/1Lgz5v+jN9u+C0+fuzHcdKUk6JeDhERERGVaHQEb4aOPl/mrfozJDQyvOFaNZfj7uzeiZsW34TjJh6HT87/ZNTLISIiIqJBGBXBW21cR18698F6rDSWoPLzTgdIVWnZpDsWIGNlcMsZtyCmxaJeEhERERENwqgI3hKG5iubzFR5eRuNHO87qVrLJh9a/RCW7lyKa06+BjObZka9HCIiIiIapFERvNXE/GWT1VzeRiPMk3qrxnLcdQfW4a6X7sJZM87Cew57T9TLISIiIqIhGBXBW21MR9JbNlmlGRIaef7MW3UFbykzhWufvRZN8Sbc8JYbOBaAiIiIaJSr+FEBAFAT07C3KzekO7jnTTGWo0HyvneqrWzy+yu+j9cOvIbvnvVdjK8ZH/VyiIiIiGiIRkXmLa9sssoyJBSN7zy5Hq9sa8/er6bM24rdK/DAqw/gvXPeizNnnBn1coiIiIhoGIyK4K02pqMv4xkVEMi8sRqMBuOORet893d39kW0kuHVk+7Bdc9dhyl1U/CFBV+IejlERERENExGRfCWiOnoTeWyIiYbllAZ/PSFzTjQnRr4xAp310t3YXPnZtz81pvREG+IejlERERENExGRfBWE9OQ9A3p5p43Ko993cns7Zv/bzWWvrE/wtWU7sWdL+J/1/4vPnTEh3DSlJOiXk5FEJErReRVEVklIo+ISI2IHCIiS0Rkg4j8XETiUa+TiIiIaCCjInib2JBAZzKDth47K8Juk1QubT1pLH1jP3a09+K+597AB364OOolFa0n3YPrn78eMxpn4LMnfDbq5VQEETkIwGcALFBKHQNAB/BBAN8AcKdS6jAABwBcGt0qiYiIiIozKoK3BQePAwAs3rgPAMsmaXjd9v7jsrcP9KTxgR8uxum3PhXhigbnjuV3YHvXdtx8+s2oi9VFvZxKYgCoFREDQB2AHQDOAvCo8/hPALw7orUR0RgkIjNE5GkRWe1UBnzWOT5eRBaJyHrn13FRr5WIKsuoCN7mz2xBa2Mi22AiWDbZ2ZeJYllUJd42pxXPXv0OAMABJ7trjbLk7os7X8TPX/s5Pnzkh3HC5BOiXk7FUEptA3A7gM2wg7Z2AMsBtCml3H84tgI4KOz5InK5iCwTkWV79uwZiSUT0diQAfBfSqmjAJwK4D9F5CgA1wB4Uik1B8CTzn0ioqxREbwlDB2XnDwT63d3IZWxkAlk3l7Z1o7vPbU+otXRaCUCfPqswzCluQYtdTEAwL6u0dewpCfdg688/xXMaJyBz5zwmaiXU1Gcb60vAnAIgGkA6gGcV+zzlVL3KKUWKKUWtLa2lmmVRDTWKKV2KKVecm53AlgD+0uki2BXAwCsCiCiEGUL3kTkmyKyVkRWishvRKRlKNeb0lQDwG4oERzSDQC3/2Vd3jGiQkxLQSnA0Oy/Ag0JA4YmoeMCkp4xFZXou//4LrZ2bcVNb7kJtUZt1MupNAsBvKGU2qOUSgP4NYDTAbQ4ZZQAMB3AtqgWSERjm4jMAnA8gCUAJiuldjgP7QQwucBzWBVANEaVM/O2CMAxSqnjAKwD8KWhXGxig90Mbk9nkg1LaEg+/8uX8c/few4AYOj2kEARQWONgT2dybzzu5OVG7yt2L0CD695GBfPvZjdJcNtBnCqiNSJiAA4G8BqAE8DeL9zzscA/C6i9RHRGCYiDQB+BeBzSqkO72NKKQUg9AMPqwKIxq6yBW9Kqb949pS8APvb7UGb2JgAAOztSiJjsmEJDd6jy7fi1e32/yNjem7Ce0zX0JPKD9S6k5W5pzJlpnDj32/E5PrJ+NwJn4t6ORVJKbUEdmOSlwC8AvvfvHsAfBHAVSKyAcAEAPdHtkgiGpNEJAY7cHtYKfVr5/AuEZnqPD4VwO6o1kdElckY+JRh8e8Afh72gIhcDuByAJg5c2bBC7Q2OMFbZwoZSyGmS17jEtNS0DUJezpRKLds0r4toYFapTbEufeVe7GxfSO+f/b3OYy7H0qpGwDcEDj8OoCTI1gOERGcSoD7AaxRSt3heegx2NUAt4JVAUQUYkiZNxF5whl8G/zvIs8518HuqvRw2DWKTf27DSXaelPoS1uhQVpXhWZIqHJ5M29GocxbqvLeV+sPrMd9r9yHC2ZfgDOmnxH1coiIqDSnA/gIgLNEZIXz37tgB23niMh62Ht2b41ykURUeYaUeVNKLezvcRH5VwAXADjbqd0etJqYDgDY3ZHEj55/I/Scu/+6Ede884ihvAyNMYbuybzpEhqoVcqXAmYmg2RfNxJ1Dbhx8Y1ojDXi6pOujnpZRERUIqXUcwAKlQqdPZJrIaLRpZzdJs8DcDWAf1ZK9Qz1ejFdg64JVm5rL3jOD/62cagvQ2OM4cngxjQNPSHNSboiLJtcfP/ngRubYZkmVn3rXai7fSbu+P3VWLlnJb5w0hcwrsae37r8Dw+gr6crsnUSERERUfmVs9vk9wA0AljklAP8YKgXTBgaVm/vGPhEoiLFjdxfAV3zZ95OP2wCgGgblszfbI/72b9nG+b1LsFOXcej+/+Et0x7Cy6YfQEAYM2SP+PEpZ/Dyz/6dGTrJCIiIqLyK1vDEqXUYcN9zYSh4UBPGpoAy798Djbv78GWAz0YVxfHh+9bMtwvR2OAt2FJTJfsnreHP34Kjp7WhPlfXRRp2WS31KEWKezc+DImAvj6hHGwAHz51C/D3u8O9LXbM37iPTsjWycRERERld9IdZscFglDB5DG1OZajKuPY1x9HPNmtGDL/iFXZdIYZQQalpjOAPiGhIHGGrtJTqTBm9aAiVYbure/hqfqavF0fR2u3H8AMxpnZM9RZtr+VfSolklEREREI6CcZZPDriZmL7exxh9zzhhfh0+8bbavBI6oGL5uk579b4mYvccypguSmejmCvZp9QCAnr1r8LUJ4zAnlcJH2jthZnIBpWXZtxm8EREREVW3URXt2Jk3oMnJiHjVxnWkMhYsa0hNLanKBZue+ua8eQK5uNOFMq5rSEUYvKX1WgDAS6knsEfXcdOe/YgBSKf6cieZTvCmjapEOhERERGVaHQFbwUyb0AusEuZ0X3QpspnBoJ7X9mkJ5Bzs7hxI9rgTbfSWJ5I4KfNjXh3VzeOTaUAAKlUMnuOZTLzRkRERDQWjKrgrcYJ0MKDN/tHSaYZvFFhmUDwFtP9DUtclRK87dV6cef4FrSaJr6w70D2uJlO5U5i2SQRERHRmDCq6qxymbf8skn3sWTGBJD/OBGQH7x597l5M29uJjduaJFlc/f27sUV0zIAEvjS3v1o9JR8ZtK5zJtyMm/QGLwRERERVbNRlXlzs2v9lU1G2VyCKl8mEIh5M2+6k3kTsbtNAtHueZtQMwFX7EvipF4N7+/0D+B2g7e+ni6csvpmAMy8EREREVW7URW8uUmTsMxbjS/zRhSu37JJJwvXXBuD7tyOG3pkmTcRwYc7OvEJcwHigccyTtnkqqcfyR1kwxIiIiKiqjaqgred7XaHvWktNXmPuZm3Pu55o35kTH/w1lSbC3gMJ5AbV5cLlaLc89aXNlGrklCxurzHTCfzlt67KXuM3SaJiIiIqtuoCt7W7eoEABx7UHPeY9mGJcy8UT8ylh2IHTm1Cbe891hMba7NPuY2LGmpy2V2EyNQNnn4dX/E5372j7zjv3zxTfzCPBPjDz8dy0++A0mVW5cbvOltb+SewLJJIiIioqo2qoK3c46aDACYNaE+7zF2m6T+bGvrxa6Ovmzm7fK3HYJLTp7pO8ctlczLvJW5bDJlWvjtiu15x7e1p3ATLsPhZ34QJ77rUmw49yfZx8xMGgAQS7blnqD43iciIiKqZqOqzurbH5yPryVNaJ4Oga5EjA1LqLDTb30KAPDEVW8H4O8s6XKPeTNvcUNDe296BFaYryuZRmMi91dUN/Izb/GMp5GJMzKAiIiIiKrTqAreEoae3dsWVB+3j0f1QZtGB7ds0gj5AsAtm/Rl3iLsNtnVl0G9J3jTYonsbTd4S5i54E0US4aJiIiIqtmoKpvsz6yJ9UgYGlZta496KVTB3LJJQ89/67vVkePrR65sUilV8LGuZCY7sgAAdE/wZjllk7WWJ3iz+MUFERERUTWrmuAtpms45qBmrNzK4I38LM94AHdUQFjmrStpBz/BsslyZt6CZb6/+cdWrN3ZAQDo7MugwTPT0IjlgkorY48KqFM92IUJzkFm3oiIiIiqWdUEbwAwqTGBAz2pqJdBEfrdim144Pk3fMc6k7m9YKZbNqmHBW/2ec21/uCtnPsog9e+8ucv47xvP5tdj3fPmxHPZd5UJgllWWhQPXh92vnYLpMginveiIiIiKpZVQVvcUPD+t1deGjxpqiXQhH57M9W4Kbfr/Yda+/JlROmnbJJPSTz1tlnBz/eUkV7z1v5Mlr9jbboSvozb96ySdNMo6+3GzExgUQTTBgQZt6IiIiIqlpVBW8xZx/T9b97NeKVUCVp681lY02nbDIWsufNDd4aPQFTosx73jp6c9my4P63rj7/njdN8zTryaTQ2bbXPl7bDEt0aMy8EREREVW1UdVtciBxo6piURqCzft6kLYsHNra4AuQlr95AEB45s19/wTLJsu5523hHX/L3s5YgeAt0LDEK7NrLV7/7T8wCUD9QUfCWquz2yQRERFRlauu4C0km0Jj09u++TQA4OWvnIsd7b3Z43csWgcAiIXMebvrg/Px+ModOLS1IXsspmuwFJAxrdAOlUMRzLSlAxm+lGn5vpBomTg1e/vU7Q/a5ygdh84/E9ueYvBGREREVO2qK3hj5o0CzrjtKXT05ZcThmXepjbX4uNnzPYdc99TqTIEb96MIABfhs+yFJTyrzOeqEH7p9eh+buHZ4/tl/GYUt9ol01ySDcRERFRVauqaCcW0kGQxrawwA0oPtB3s7nlKJ3c3dnnu+/dW2c6WTld/O9p3dNxEgDSYpd4WtDZbZKIiIioylVZ8Jb7cTJlbDJBlam/gddBiWKDN2N4g7fOvlzny10dSd9j3tdwG6vogS8kYoHgLeMGb6JDY9kkERERUVWrquDNm03pK2OTCapMfeni/8zDuk2Gcd9TwzHr7XcrtuHYG/+Cdbs6AQD7uv3B21u/8XT2tllgmHjM8AdvCvbjisEbERERUdWrruDN84G8N8UPsmNNd6r4ssFiyybdDF2wmchg/OTvmwAAuzrscslkP8Gm23lSC5RNaoGgUzmPM/NGREREVP2qK3jzZt7S/CA71vQki/8zL3nP2zAEb+t3dQEADKfTZdoqfM1CmbcgcUpFLc2ABr7niYiIiKpZVQVv3lK4XgZvY05XsoTMW4llk8Ox563TWZ+bxcuYhffo5fa8FbdOSwxm3oiIiIiqXNmDNxH5LxFRIjKx3K8VY9nkmLa/O1X0ucV2Ji02eHt1ezueWbenqGu613KDuEtOnpF3TjZ4k/7X6ZZNKtGhs9skERERUVUr65w3EZkB4FwAm8v5OmGYeRt79nYlBz4JdkAmAwRF2XOdLwS++efXsOzNA9j49XeFnnf+d54DAGy69fwBr+mWYKadzFtNTPc9LgJknJLKgcomXUp0GKr44JWICpt1zeNRL6FkxfzbQ0REo1+5M293ArgaQPE93IfA2yqewdvYU2zwlihh2LabeVvyxn6YlippHEEhubJJ+9e6uD9400XgbocLGyYeJjXxSExXO7Fr68Yhr4+IiIiIKlPZgjcRuQjANqXUywOcd7mILBORZXv2FFd2Vow0RwWMOXu7iss8FdusJOzc4RgZ4F4j7ZRGJgx/8KZpks28DRy82Y+3Hn8BAGDryr8OeX1EREREVJmGFLyJyBMisirkv4sAXAvgKwNdQyl1j1JqgVJqQWtr61CW40vvpftpBkHV58VN+/Hg4k15w7drPSWJnznrMAClBW/B6w3HXkpv5i2mC4zA/jtNPHveisy81dS3AACsdHHZRyIiIiIafYa0500ptTDsuIgcC+AQAC87e4umA3hJRE5WSu0cymv2v6DczUw/bdip+vy/HywGAMwcX4fN+3uyx8fVxXDzuccgZmh4c283gPzZaf2J6/6sWE/axLhBrM8NxoBcw5KMpWBoGmKaP0DURWCq4kYFuEO69VjMeaH0IFZHRERERKNBWcomlVKvKKUmKaVmKaVmAdgK4ISyBm4AFPI/INPYMqWpxne/uS6O9504Hf88bxpiThathNgtL0s3UOat0J64ZCb3PPe9mcpYMEIyb2lTZccIaEVm3oxYAgBgMXgjIiIiqlpVNedt/oxcTiRjsWxyLGqo8SeTx9XFsrfdURJDCd4GGv5eaJh3Xzp3PFs2aVmI6RqMQAOVhhqj6CHdLjd4Y+aNiIiIqHqNSPDmZOD2lvt15k5pxJJrzwaQ6+RHY0twj1iLJ3iLOxkuQQllk8HMWyB4602Z+Mj9S7L3CzU0Ccu8ZUyFmC6YMa4WALDwyMk47+gpqE/o2bLJYve86bE4AEAFgreujgNY8p2PoLN9f1HXISIiIqLKVVWZNwCocTr3pdiwZEwKDrVuqYtnbw8q8xbIivUEyiZf3LQfz67PfS9RqFzXm3l7aXMb3tjbjbRp73k7c+4k3PvRBbju/CPRUGPAskpvWBJzgrdg5m3Vr7+JU/Y/hlW/uqWo6xARERFR5aq64M3dP8TM2+ix9I392OJpMjIUB0+s891vqc0vmyxFTBdcceah2a6TwT1vwa8ICgVv3szbcxv24h23/9Upm7Tfr+ccNRmHTKyH4YwJcPe89Re8LWs6B4lLfgIAMLKZN/+4BOU+Pd1X+IckIiIiolGh6oI39wN6msHbqPGBHy7GGbc9PaRrHDW1CQBw1TmH+46P82be3IYlJVxXRHD1eUfgj589A0D+nrfeVMZ3v1DZ5Gce+UfesYyp8va76ZrAtBSsbLfJwn9Fj73iQcw47Fj7PMMJUq0M1i57EpZpr1MMey+cmGN3hICItIjIoyKyVkTWiMhpIjJeRBaJyHrn18E0ESUiIiIaUVUYvNkfzTnnbWzJWBbeecyUvIHXzZ49b519dknhUdOaSr5+XdxuhBLc89bW4y9TvO43r4Q+f92urrxjKdPKa0iia4K9XSms2dHh3C+8ppjbpASAaBrSSseEHc/giP97L5b+7Gv2cd0OXoPB2ws/vREv/fGBwhevLncB+JNS6ggA8wCsAXANgCeVUnMAPOncJyIiIqpoVRe8iUi29IxGl/bewXdKTJsqtCzSm3l7x9xJOPeoyfjqRceUfH132Hdwz1tbYM1/37iv6GvaQ7rzM28AcPPja5z7hf+KaoEZdBnomJbeYj+2b51zkh10iuVf56kb7sQJSz5X9FpHKxFpBvA2APcDgFIqpZRqA3ARgJ84p/0EwLujWSERjVUi8iMR2S0iqzzHbhSRbSKywvnvXVGukYgqT9UFb4C9742Zt9Hng/e8MOjnpjL5gVBDwsAps8dn74I4IPIAACAASURBVE9rqcU9H12AiQ2J4NMHlIjZ1w6WTR7oSeWdG7bvbVKj/ZqzJuT25GUslc0Uu6zAiItiRwUAdvCWgL0eJXZg5+6B8wZvqeSY2v92CIA9AB4QkX+IyH0iUg9gslJqh3POTgCTw54sIpeLyDIRWbZnz54RWjIRjRE/BnBeyPE7lVLznf/+MMJrIqIKV5XBW0zTuOdtlPA2lnFLBQcjbVqIG/5A52vvOQZNNbECzyiN27AkuKetvSc/W7irIz84iuka3nfCdNTGc3Po0qaVt+ctWJapldAaMyMGYuI838m4uY1KNCeI2/b6Guy/5eiir1kFDAAnALhbKXU8gG4ESiSVPVk99NsepdQ9SqkFSqkFra2tZV8sEY0dSqlnAHCOCxGVpDqDN4PB22hRqMFHqdIhJYj9NfsolYggYWhIBoKr7lT+0O4d7fnBWzJjIW5o2VlzQG7Om1ewLNPQ84O3tef/Ci/M/WLecRO5Msps5i3jBG+WE7w99lVMQdlHLlaSrQC2KqXcYXyPwg7mdonIVABwft0d0fqIiII+JSIrnbLK0GZKrAogGruqMngzNMm2WqfKFiwx3N+dX4ZYjEzInrewwGcoEoaGP726Ex/44WKs2tYOIL+MEgB2hmTeUhkTCUPzDf1OWyovwAyOIggbFXDESQtx6iXX5h3PwJNldDNvTvBWk7bXq/R48GlVTSm1E8AWEZnrHDobwGoAjwH4mHPsYwB+F8HyiIiC7gZwKID5AHYA+FbYSawKIBq7qjJ4i+ka97yNEsHM2/vv/vugrpMKybwFs1pDlYjpeHNfD5a+sR8vvG43JulLm5g3owUrvnIOTpplf0F6ICQATZl25s27RnufXv+Zt+DQ8f5kxJN50+zbkrG7TB6c2oB0KllS8PbyU7/Arq0biz6/gn0awMMishL2B6KvA7gVwDkish7AQuc+EVGklFK7lFKmUsoCcC+Ak6NeExFVlioN3oRlk6NEMPP2+t7uQV0nbVq+kkQAqInpBc4enJqYJ/By3l/JjIUaQ0NLXRyPXHYqgPDsYdopkfRm0rqTmfzMW3rgzFshpuT208EJ5NwRAXWSxOrnfgOl1/ie09db+Pd73jOXQb/vrKJfv1IppVY431Afp5R6t1LqgFJqn1LqbKXUHKXUQqUU950QUeTccm7HewCsKnQuEY1NxsCnjD6GrnFUwCiRzOSXHZbKHmqN0G6Tw8k7Q84NOpNpEy3OOAJD19BcG8vrQGlaCqalENd1XwOSzr50XmlnsGyylNJPy/vXWdnr0zJ92I8mpJCALL0PaJ3ne053xwHU1NY7T7Gw47+PwO7a2ahL7cPhACaiDYt/dDVO+/fbil4HERENTEQeAXAmgIkishXADQDOFJH5sJsobQLwicgWSEQVqTqDN03w51d3wbRUSZkLGnlhDUtSTnOPYrlZ1mDnxrr4cAdv/pJHAOhLW76M3Pj6OP60aiduuPBo6Jrgyp+vwJb9PQCAuKHBWwV5oCeNxkA3zNq4P1tYStmk6SmbFKe7pGYl0aU1oi0+BYlMB7o1/+9JT+cBTJg8HQCwed0KHKx2YVrPLt85p23+IQAGb0REw0kpdUnI4ftHfCFENKpUZdnk2p2dMC2FR5dviXopNICw4O3yh5aVdA23hDG4f2y4M2/eMsxs8JYxfRm5N/Z2Y3dnEn94xR4h9pt/bMOyNw8AcIK3wDVbG/x70O7+lxN89wdbNpkN3swk0hJHRq9Do9mG4zb92PeclKdscufKJ4p+LSIiIiIaeVUZvLmCJWhUedwg6MvnH5k99tfXSmt7nHauEczW1SeGd8+bN/N233Nv4E+rdqAvbfoyb821diYtuHfNXZ8EMmkTAgPDpzbXYt6Mluz9UsYdWN7gzRkNoFspZCQB06jHNLUL9eLvhJnu68reVvs3Ff1aRERERDTyqjp4a22sGfgkipS75+34mS14y6ETBnUNt7NocM9bOcsmAeCOReucsslckPjb/zwdQPgIgbguCCbSJgaCNwAwPfs1SxlVF7NygZmbeYuZvchoCVixet+5bWgAAGT6cpm3WPeO4l+MiIiIiEZcVQdvluK4gErnZt4Shj7o2XzpbNmk/+083Psdw7pXJjOm7/jUZvsLg86+DFTg/Reeectv3e9tlFrKz3CYmWvr7w7lrjG7kIo1wor7g7c9Fz0CAMgk7f14q57/PU7sfKro1yIiIiKikVeVDUuuOudw3LFoHccFjALufrW4oSE9yA6hhfa8Dbdg5g1wGpZ4jicMDTFd0J3MoDtQthvX9eyet7q4jp6UienjavOu6WbeEoaGGqP00s+9aIFmpe3XsbqwJ9YEiTf611JjB3Nmyg7eul96tOD1LCXV/S0PERHRKDDrmsejXgJVgKr8TPbeEw4CgEFncmjkJNO5QMUNtkvNmHmzd+UUvH72dT2ZNxFBQ8JAVzKDjt6073xvt8lvvn8enr36HZg+ri7vdTKW/b596NJToA0ie3hAn5jNvDWobliJJiDR4Dsn5gZvTubNqptoPxdNedfj3yIiIiKiylCVwZtbPjfYTA6NHHcmWmNNLBtsl5pBS2aDqPK+nYPX7/MEnl71CQNdfRl09OUHb+6cNxFgxvj8wA2w58IBdnauFCtOvxtLjrgGpha3G5WkU6iXPqhEM7Qaf/AWd2a7nfzyl7F/9zZIsgOdqhZv1M/Lu64AsEw2/yEiIiKKWlWWTRpOtoKZt8q3YXcXxtfHMb4+ni1/lLyG+v1LOs1B3CDqj589I7Tb41AF97z1Oc1WgsdzmbeM77ihSTbz1t9+TPd9G7bHrj/zz/kQAODVr/8RupVGV/t+tACQ2maojD+QrKnLBXPb1i6FlupCt9TD0v0NVF4zjsDczFr0pfqyw7yJiIiIKBpVmXlzhzVzz1vlW7+7C3Mm2YHEybPGAyg945QMlE0eObUJJ8wcN4yrhHN9/18Xt+QzGGQ11tjBm9tx8pKTZwAApo+rzTYssfr5XsHNvNUMMpNoajHoKo3ujn0AAL22BS2HHO87xxuIaZoGI92JPq0OluZvoJLS7exgKukfMUBEREREI68qg7d4NnirvMzbI0s3Y9HqXVEvo2JsO9CLmU754E0XHY0jpzahoaa0hHAueCtz2WTg+rnMW37ZZLcnePvwKQdj49ffhYMn1GfLJoOdKL1MFT76oFimFkdrZge2r3zavk79OMxdcBYy1+Xm5xmxXJCW7ulAPNOJPr0ByvCP10gbdpCXTvYOai1ERERENHyqMngzdLdssvIyb1/69Su47MFlecfve/Z1LHl9HyxLoTuZCXlmvtXbO0Z9INidzGSDtYSh47iDmrMZrWK5s+LKHbwFM2xu/BXsCBnTNaRM5Qsq3SYsEnhumG++/zgcN70ZE+rzxwgUw9JrMA6dOGnFdcgoDZPmnAjADthemPQBvDD7M77zM90HEDd7kNTroQJlkyaDNyIiIqKKUdV73tL91aZVmJsfXwMA+MTbZ+OHf3sdq7/6TwMOmX7Xd54FAGy69fyyr284bNjdiX/78Yv4zRWnY2JDAkopdKcyqPf8nImYls1oFSvXsbLc3SbDg8NgUBfTBRnTymbeanzdKO1fVT89HM+cOwlnzp006HWaei57tqZmHo6dNTd7/9Qr7s073+ptQ63Zhc7ag/Iyb+5w73SKZZNEREREUavKzJuIwNCkIjNvA/nfJZsB5DoZVpN7n3kDW/b3YtHqXVBK4c19PbAUUJfIBTc1MX0QmbcR6jZZIDgMvq6uaTAtFVrOueBgey/erAnla/7hDcDSscZ+znT0tiOh+uwsWywQvMXt/YjuMG8iIiIiik5VZt4Au3QyU8GZt+1tvZjWYg9o9u5/crM1ZgWvfbA0J4axlMKP/74JN/1+NQC7O6MrYdiZN6VUtrnHQEaqbLJQcJhXNqkJ0lYu8+adA/cvpx6MM+a0YtbEMgZvntLHjNFQ8LztH1uCaT85BVqyDQYyUJoBCWTe3PlwmVSyLGul6sehskRERMOnrJ92ReTTIrJWRF4VkdvK+VpBMU3LDlGuRG+59ans7aRnnW6TlerslOk26wD+/OrO7FFveWhNTIdSpTWbCXabLJdC1w82LDF0QcYMz7yJSFkDNwBQsVrP7fBZcgAw7ZAjsA2ToKU6oMECNAN6Q6vvHC1hZ+5Mlk0SERERRa5swZuIvAPARQDmKaWOBnB7uV4rTMzQkKmwId3BgGzjni4ACC0THCh4szyZudFSHqq5+72U8gXW9Z7RAG6gU8q+N/f3Lz5CmbcZ42tx4bxp2ePBPW+6piFjqbz5cyNFDE/wJv2/do9WDyPdBV2ZUKKjtnWm73Gtxg7eMik2LCEiIiKKWjk/VX4SwK1KqSQAKKV2l/G18th73ka+9PCB59/A7X9+LfSxvsDg6LO/9TcAubI/r4EyTx19uaHLyQrOMHpl2+QD6PUErHWeskm3PX4pf3Yp00RMl2xHx3JxyyObamI456jJ2ePBckq3YUkyYyFhaEWXfw4b3761/l87qdcjlumC7mTeWiYf4nvcqHUyb2mWTRIRERFFrZzB2+EAzhCRJSLyNxE5qYyvlSema3kBUF/axMNL3ux3xtZQ3fT71fje0xuyWTX/6+cHWb94cUvo8YEyb12ecQLlDt7+vmEvbnzs1SFfx42tLEuhozcXfHozb7FBDFhPpq2yl0wCuSDNtBQO8TQcCWbeDE1DxlToS5t5j40E8ZRNDiStNyBudkOHBaXpmHhQIHhzMm9mshuvfv0MrP7a6cO6ViIiIiIq3pAalojIEwCmhDx0nXPt8QBOBXASgF+IyGwViJxE5HIAlwPAzJkzg9cZNLthiT8AuOUPa/CTxW/ioJbabCv2OxatwzHTmnDu0WE/xuCd/a2/5bXwD2beAODqX63EnRfPyzs+UObJG5huO9CL8YOcCVaMD923BABww4VHDSmL5D7XUv7fC++eN3dGXyn7Fd0MV7m5r5GxFGZOqMs77nKb5YzUuvKU8GeUjjWgJrkJOkxAdNTU1uPV+DwcnXoZABCrbwYAJLetxAmplWVZLlUGNhYhIiKqfEP6ZKmUWqiUOibkv98B2Arg18q2FIAFYGLINe5RSi1QSi1obW0NPjxohiYhe8y6AcAXgHznyfW4/KHlw/a6/QkL3gDg9j+vyzuWGiDz5N3nduH3nhvawoo01O6dWjZ4U+hJ5X4vmmpzwVt8MJm3jDmiwZtlKTTV5K/ZZWj2FwdRZd586vL+yvlY8QYcpHbCELtsEgCOvvYZ7EULACBR1wQAaNo9Mn9HiIiIiKiwcn7i/S2AdwCAiBwOIA5gbxlfzyesbPJATwpA/oftkVJodtu2tvxmEAM1ISmlG+NwGWp5ZrZsUin0pk18+qzDsOjKt2H6uFwWyy2b3N1Z/B6rZMYqe7MSwG5EAgBmYIxBMBtpOO+9vnREmTcnuW0pwYkfuqHfU624Zw6clgs0kx/9E144/PNoaLG/UJme2pB9zMzkSnaJiIiIaOSU85PljwDMFpFVAH4G4GPBkslyiulaXgDU1mPvs3KzWuXu0hjMtJXSQXGg4CyYmfrmn9fi0h+/WPziBmGooxc0J3pzs251cQNzJvuHSMecsskP3vNCwUxl0EjteTOc9Q9U0uqe1xNZ5s1e34sTL0Isnuj3TC3j+eLAE7wdNPtInPqh6xFP2PvnGlVuSHcmkxrGtRIRERFRsco2pFsplQLwL+W6/kDChnS3O00y3BbuPUUGB4PV1pPGlObcB+JigxEASA8w5iC4n+9/nt5Y2uIGYajBm5ug+vYT6wEAdfH8wCbmyVQl01ZRwU8yYxYcoD2cmmpjAICFR9r7JU+dPR4vvL4/7zx3396GXZ04LBCcjgixf8+UFhvw1Hh3bt6eaPn/HMQSdudKTTyjKdIpJGoKz48jIiIiovIoW/AWtZim5WWn3A6NbuatJ1ne4O1ATwpTmnNt2wuVTYZJDxAopTLh2Z8t+3swY3x5PlgPNXgL5l1rQwKzmJYLwqwiE7Uj1RikuTaGpdeenW0O89NLTwndB+hm3ra39+GzC+eUfV1B887/BJbsWoUjL7llwHNjp34ceMrZMxkSvCVq8geKZ9LpvGNEREREVH7RbP4aATFDCgYb7lBnb7v9cnD32LlKyrwNUJpXaAD5Gbc9XfRrlCpsHl0pgsF0bVjmTc/tH+tOFffnYwdvI1OeOKmpBoazL8/QtdDMoOEJQGe3NozIurxq6hpwyqceQPP4gRsAHfu292AnnPO0/J9FNwz0KH/pZYYz34iIiIgiUbWZt6aaGHZ3hH/IzGbeigwOBqs3FdjzVkLwVig4yz4+Qg1LvNsUh9qwJLjm0MybJ4P21m88jSXXno3JTTV553klMyZaagcuERwp3gC0Pl75f8XcP5WwskkA6JZ61CH3d8nMMPNGRERE1alco3OCI8QGq2ozby11MRzoSeOF1/dBKeULQtyMXHeZyyaDwU7fAMHPpMZchmOgEsWBRgkMl46+XIA71NcMBqRhe96CnUAfWbp5wOsm09aI7Hkrlu7JvDUkRkHw5m5GLBS8af7sYSbNhiVEREREUaicT7zDrLk2jr1dSXzwnhfw6PKtvrlibvlf9zCXTf76pa2++8Eyw+QAmbcH/u0knDHHnss10Ew1N4s1N6QhxnA29WzzlH4mS9izFyZYCho28DsWCN6+/cR6/H1j/xMmRrJsshiGN/OWqJx1FWavV0LKJgGgz/C/x0x2myQiIiKKRNUGb+PqcmV0q7a1+/a3ZTNvTtnkcM19u+oXL/vuB4OdYBll0NHTmnHnxfMBDDyk2s1ifeXCo/Ie6x3GLpr7u3Mf1IeceQs8PyzI9AY+rut/u6rf647UkO5i+comR0PmzflV9PC1pgPBm8XMGxEREVEkKucT7zBr8QRvbb1pdHrK/5KBsslyDXjOL5ssHFT94hOnAch1WxyoYYkbgIaVHnb1DV9G0Z2N533NwVi8cR9+u2J79v5N/3w0Tjt0Qt55YYH0vOkt/V47NULdJovlLZuspHUVorKZt/DgLRP3B28Z7nkjIiIiikTlf7IcpObaePb2gZ50aObNbVhSvuAt2LAkPPhpTBg4+ZDxAOwumUAxmTc7uPNmdpqdph2dw1gO6su8DSF4e3LNruztH/zLCfjYW2YVVTYJAM11/TcjSWassv0ZDkZMy/1cYT9j5XHWqIeXTVqJZgCAqezzLJZNEhEREUWi8mu6BqnZ032wrSfly0blZd6GqWwyKBjshHWbvHLh4fjwqTOz993gJVhiGOQ+7s28TaiPo703PayZN++4g6GMCvAGmecdM7XgebFA2eT4+viAnTUrb89b5QSSxXAzb1qBzJuqsTOfvUigAX3c80ZEREQUkdH1KbME3qCmK5nxZd6SgT1vxQ6DLlVe2aQn8zbTGaR95NRGTGzIdZl0BzynBiqbdB6v87Sin9BgZxuHc37d5v09udccQuat2MYdsUAGLaZLv1nIjGnBtFRFlSca2mjItuW43SZFD89wanV2VtiAHbxbLJskIiIiikTlfOIdZt4B0AJ/1uiRpZvxs6Wbs90mBypRLNVV5xyO2pgeuudtdms9Vt54Lk6bbe/3ag7MJxORAQMWIJd58wYt4+vt4K1zGDNvT67ZjeNn2pmXoTQsqSty3llM878lDU3zvW4yY2LBzYvw6PKtaO9NZ3+PK2lUQFjTlUqmBug2qTfYHVDjcL7sMBm8EREREUWhcj7xDrPgAGi3ZNE9fs2vX8mODxjugdcZ0547FhwNkEybqDF0NNXE8JULj8Jt7zsuu9fNqz5h+BqFhHGDO+8eMTcQHEp5o5dpKWxr68WCg8c56y//bLlg2WTc0HzNW9p709jblcLnf/ky5t30l1zwVkllk04AOrW5/+HilaZQt8lYox28aWL/OWSSPXjp9guxceXfR2xtRERERFTFwVtNXvBmf8j3Zrrc8sK0NbxBScpUiOtaaNlkjZMhqk8Y+MBJM0IbWsyd3Ii1Ozv6fQ03oPEGO+7PNtBIgmK5AWJDwr7uUDJvxWY39UDJYUwX3/6/YIWrG6hWUtmkO8Zhxri6iFdSnOyetwLBW6K51Xe/9/XFOKHrGWQe+1zZ10ZEREREOZXziXeY1XjK6ExLZTNv3hECbrfJvrSFpW/sH7bXzmbeQhqWBIPKMEdNa8LaHZ39Ni15/JUdAPzdDN3gLawxymC4wZq7Xy3485Si2OAtGMzGdM333ODwcjcbWEllk+4XBcdOb454JcXqv2yyvmWS736scxsAoCeeP+qBiIiIiMqncj7xDjNvkJTKWNnB1d7g7UB3rjTxAz9cPGyvnbEUEoae1+Cjt8jg7cSDx6E3beLlrW2hj29v68WG3V15x7OZt2Eqb0w7648bGuKGNqRyTDdTuOTaswc8d5qn3NDQNV/zFssJ3g5qqQUAXPbgMgCVVTZ59hGTcPO7j8HV582NeilFyWXewhuW1Acyb3V9OwEAqdrWsNOJiIiIqEyqNnjz7gVLmRb60hZiuqDe0zhj077uYXu9p9fuzt5Om/bQ6GTGhFIKr25vBwD0pMzQodpBZxzWChHg+Q37Qh83rfA9ek0DZN72d6dw3W9eKTozlyvN1JDQtSF1m3SfO6kxMcCZwIOXnpK9HdcF6YyFXy7bgh3tvZ75dvbv43oniK2ksklNE/zLqQdXVEDZv/7LJhtbJmDJkddi5dvvBwBMTNmZN3f+GxERERGNjMr5xFtGPSkT3ckMamK6ryyvZ5j2hgHAv/34xeztcXVxJ3iz8LsV23H+d57Dn1/die5kBg2JgbsuNtfF0FIbw+7OvtDHC+09a6qNIW5oBYOz2//yGh5eshm/W7GtiJ8oV+poaIK4MbTgLW1aiOtaUUOrva32Y7qGAz0pfOHRlfjI/UuzgWuwe+XoCZQqj/tVQKGySQA45eIvYuKsYwAAE9UB+3x2nSQiIiIaUWMmeHvohTehiaCI2GFIZk+sx6fPPiwbRK3b1QkAWL+rE93JjG9YdX+aa2No7w1v+V9o/1hTjYHamD5gZm2gGXLB13HLJgcbvO3pTOL7f91YdMMTb6t9Q9eyQfaezmQ2eAvOjYtXUOZttHHnvGlGeNmkS4/Zj7tdJ8VMlndhREREROQzpj7xtvemUSh2G67ByhefNAMJQ0dtTEdv2sxeN20qdKdM1BdRNgm4wVt4ZsMNor560dG+4401MdTENN8wcK+Ys5b+GqF4+comjfwGLMW679nXSzrf8Mx6i+uCzj7790HXJNvJMT/zNqbeysPMaVgi/f8e6kbcd3/avhfQ15O/97ISiYguIv8Qkf9z7h8iIktEZIOI/FxE4gNdg4iIiChqY/4TrzvDbPq42mG5ntsYpT5hoCdpQnMCJndwdrGZt6Z+gjc3I3bwhHrf8UYn89ZbIPPm7gMsdq6dd5bcUDJvpWbFvJm3mK5lRzpoArhTHYJBcCV1mxxtVPYrjf7fF7GYP76ZobZj5T2XlWlVw+6zANZ47n8DwJ1KqcMAHABwaSSrIqIxS0R+JCK7RWSV59h4EVkkIuudX8dFuUYiqjxj7hNvsGzylvcei4kNcUxrGabgzSnxa0gY6EpmoDsv2OFkj0opm+womHmzP2THdf8fn51507FiSxtUcCAa7BJEIHzP3E9feBMvbT7gf51s8ObseRvknLfgOgcS82Te7FEB9s+iSS7zFvx95J63oVMDzDs04vnNZpq7SsuqRkFEpgM4H8B9zn0BcBaAR51TfgLg3dGsjojGsB8DOC9w7BoATyql5gB40rlPRJQ19oK3QOFkXcLAnEmNRWejBtLtzI6rixvoSeUyb24gVkzDEiC/bLIvbWLWNY/j1y9tzQZRccP/s9THdazd2YnN+3vw+5U78q5pZMsm83/WL/92Fd77/b/7jrmjAuyySX3QowJKzbzpvj1vudu6Jp49byybHC5u5i0s4PeqqW3IO2Zq/e+TqxDfBnA1ADc6nQCgTSnlbirdCuCgKBZGRGOXUuoZAMEhsxfB/kIJ4BdLRBSiqj/xvnT9Ofj0WYf5jgUzbzFdYOgy6KzS6u0dvj1kbmDUkNDRncpA1/yZt2JGBQC54M39QL2j3e48+e0n1ufmr+n+a3k7Obr7xLzcQCgzQIYl+7NYuT1v8SGMCig1sPLuP/Rm7TQRT7fJQNkkg7fBk+LKJnXDQEr5g2ZTKjt4E5ELAOxWSi0f5PMvF5FlIrJsz549w7w6IqI8k5VS7revOwFMjnIxRFR5iksDjVLj6+PZTNf4+ji+/p5j8djL/jb5MU1DTNeKDmi81u7swLu+8yw+c/YctNTF0NaTxuf/yR7MXJcwoBSQdJqHuJ0jS8m8mZbd5KQhYaDL2TO3eX8Pfvz3TfbajcJNVlpq8/svuHve0gNkGXe09+Luv27MDv12yyZ7esK7X/bHtFRR4wHC1hm8rWm5GXf1wYYlRQw/p3ApzS4ZHqhhCQBIIMCzKj/zdjqAfxaRdwGoAdAE4C4ALSJiONm36QBC52cope4BcA8ALFiwYHjS80RERVBKKREJ/XdHRC4HcDkAzJw5c0TXNdJmXfN4Wa676dbzy3JdGhnlel+MBlWfrnCbbnzwpBk475gp0DX/j2zogpguSGdK/1z2xh57yPeaHR0AgI+ddjAmNtj7gtyyvrbeFIBc2WQpe94AZEsnD/Skso89t2EvgFxg8+h/nIbvfeh4AMDdHz4BQHh2LaaHd5sMlsv99h/b8eDiN/HdpzZkXyc+yG6Tp3z9Sdzw2KslPcfb+NMbvOki2WxgXYKZt+Ey6V8fwuIZH8dh89464Lkx8ZfOVnrwppT6klJqulJqFoAPAnhKKfVhAE8DeL9z2scA/C6iJRIRee0SkakA4Py6O+wkpdQ9SqkFSqkFra2tI7pAIopW1X/iTXna3QPA9RccieNntmQfj+kaDF1DusTMW9q0cMsf1wIAGhMGkmnLl/1xuyG+usXNkAAAIABJREFU7gR4g2lYAgDtPfbz9nen8s5xSwoXzBqPC46bBgA4aloTgPB9bW4LfjcAcpmB+8E5cXHDHhUwmLLJvV2lzwLzZupinj1vmghMFZ55G65RD2NR67RZOO3Sb0G00v85sLRR22H/iwCuEpENsPfA3R/xeoiIAOAx2F8oAfxiiYhCVH3w5h00DQCTGmtw2/uOyz5uaIK4rpXcsORnL27B5v09AICGGgPJjOnL/rhB2t/W2ftkcqMCit/zBuSCvtDgLSTb5O6xCwZkQC6jFRzyHSyjDO7/MzQpOfP2coGOl8W64sxD8cv/OC1QNikwnbVOaPAHDaWWZtLwqPTMm5dS6q9KqQuc268rpU5WSh2mlPp/SilOHCeiESUijwBYDGCuiGwVkUsB3ArgHBFZD2Chc5+IKKvqg7f3HG83kTv/2KnZY7rm72BoaJIX0Axk5Za27G1NBJbyN9cIC56A0ua8AbmyybDgLRbSgj87yy3k9d1DwUA1GKylMpZvjpo7pLvYpi5Pv7YbF/3P83hk6Rbf8VLiq6vPOwInzRqPlrpccKB7Mm/j6+N48bqFxV+QykIJ9xoSEQ2GUuoSpdRUpVTMKe++Xym1Tyl1tlJqjlJqoVIq2I2SiMa4sgVvIjJfRF4QkRVOt7aTy/Va/Tl8ciM23Xo+Zk3MDbT2Bj0igpihDdjEI8gbHLkBlndQ9FvnTAx9XrDcr5DgnreeVH6b/v4yb2F73iwn8MnPvOUHb95r22WTOpIFhn8HvbnXLhVdvaPdd3zF9ecW9XyvSU012dsiuaDY0DS0NubPHaORpVn5XyoQERERUXmUM/N2G4CblFLzAXzFuV8R9MD+qNggMm9p08LEhjg0yTUT8Q6KbqqJ4RNvm+17Tm1Mz3vtQpqdjJPb6CRl5gdO3v1g2WPuvraQYNQNfNKBrNxAwZvbsKTYzJv7M3r3yNXH9ezPVIrJngBN8zQscV/j9MMmlHxNGrrFc+25sQzeiIiIiEZOOUcFKNhtuQGgGcD2Mr5WSYxA0GPoWl4HxoFkTIXx9XGMr4/jgNNUJNjxMBisFLvfDQAa4gY0yWXewpqFxEPKJvV+Zrm5JYfBnzWsjNIbvBm6ZOe8KVVE63/n8V8s25pb1yAbikz2ZN4ylgUrELw99O+nDDCdjMrhiHMvxcYNv4BYpY+PICIiIqLBKWfm7XMAvikiWwDcDuBLYSdFMQTXCHTVi+n5ZZPJjIntbb0Fr5GxLBiahtq4gTYn8xYsYwzOWit2vxtgN+docgZ1A+HBW1gQZWTLJvNDGrd/yEANSlIZyxcYxp09b5YKv25Qbyr/A32hPYADmdSUy7ylTZV9fffn1DQZdGBIg9fQ1IKMxKBbKSz71nux5aYjo14SERERUdUbUvAmIk+IyKqQ/y4C8EkAVyqlZgC4EgVacUcxqySvbFKXvFEB1/56Fd5y61N5bfNdaVMhpgvqYjp2dfQByA/OWgKZt1I7WjZ7grdi9+S5QY3ZT9lkMuP/mYJlk8mMhbih47BJDQByZZNAeBAZ5HbW9L3GIIO3uriBez5yIt5+eCtSGQum8+fEgC0aGWW/D2KxOEwtDt1KYUHnk5ihKiaxTkRERFS1hlQ2qZQq2O5PRB4E8Fnn7i8B3DeU1xpOwb1iMV2DUnZw4wYFz663s4B7OpOYMb4u7xoZy4Kha6iL6+hL2wHF1OYa3znj6/2Zt239ZPLCeIO3Ytv0u+sPBkupjIVfLre7P67Z0Yk9nclsw4/ggHK3bPKnl56MV7d3QHdGBdjP7cCeziTe6eneGRQWvJValup17tFT8PRru7F6RwfcyzB4i8b2Dz+NPRv+gRMBmGIgbpb2niYiIqKxY9Y1j0e9hKpTzrLJ7QDe7tw+C8D6Mr5WSYIf/N09cN4MlBt47WjvC71G2lQwNEGdJ9s2JRC8zZ3c6Lt/fj8BTxhv8OYtbbz+gqPwibfPDn2OiD36wAxkEu/+60Zs2W9/0N7blcTp33gq+1h+2aSJhK5hQkMCbzvczoa6wdv7f7AYn3z4pX7XHRa8DTLxlmWXtjLzFrWZh8/Hie/6NwD2gO7WDDNuRERERCOlnA1LLgNwl4gYAPoAXF7G1ypJLLDnzd3ftbsjiZkT7CybOwR6R3t4ZiFjWqiLGzj2oCb8/mX7A+zEen/r+nGezNvLN5ybLWksVlNtLJutS3lKHS+aPw0TGwq3ydc1ySvR3NXpD0K95Y9h3SbrAiMNvJ00B9LpDBYfTnFdQzpj5bpNcih35EwtjvHoiHoZRITyfbu96dbzy3JdIiIanLJl3pRSzymlTlRKzVNKnaKUWl6u1yqVFgii3Fb/n3/05eyx8U4gtrNA5i1jKRi64MJ50wpeFwDuvHgevnvJ8WiujZXUsASwM28dIXveamP9B1KGJkU1FnHlBW+BbpNAfjOW/kYr9KZNzPbM1RsOiZiG7pSJm36/GkCuqyZFR2mlj34gIiIiosErZ+Zt1Dh19gT8z9MbfZkxd1/czo7+yiY1TG2uxWOfOj1b3hj0nuOnD3pdbtmkUsqXKRsweNO1kro7uoGY++MHu00C+WMJetOmb9i5V1/axOSmGpx3zBR8/68bi15Hf4I/c6lZTBp+lhYf+CQiIiIiGjbl3PM2apwxpxUHtdTi7xv3YdW2dgC5ssJCmTfTsrIBxHHTW3DGnOHvlDmhPo60qdDRm/EFb2EZPi8jZOi46ieWS2X8s9OCQ7oBO/Pl1ZsK78IJAH1pCzUxDafOHr4B2jWB4E1j2WTkMg2l7eEkIiIioqFh8OZwm5Zc8N3nAOSCt0INSzKmyhv2PdzcAdU7O/qQMi2Mq4vh4289ZMDnGboMMvMmeHLNLmza1wMrEO0lgpm3foK3ZMZEwtDxtsNb8dL15+CX/3EafnPFW4peT5jaODNvlWbOhVf57ltm4fcEEREREQ0dyyYdwe6FbgfGQpm3tGUVLBscLm73ys37e7DtQC8unDcNX77gqAGfZ2j5Q8cB//0jpzZlb7vBm64JvvPUBgDA6h3+RhTBTFxvgfl3QC7zBthdO8fXjx9wzQMJlk2y22T0Jk6Z6bufTieR0PPHahARERHR8GDmzeHtQLmjvRd/fc2e87a7sy80y5RxRgWU0xQn83bZg8uQMq28+XSF2Jm3wg1F3n54qy8Y82bejnKCutf3dPueU1rwZuaVOQ5VMHgTlk1WhPX6YdnbZmb4u4wSERERUQ6DN4c3k/NvD7yYvW0pYMWWtrzz06aCUebM26Qm/ziAvn4CJi/d6TbZlzZx1xPr0Zc2fXveDE18Q7NTZm7P2wRnvMG3L57vu2ZwVEBfgbLJ//zfl7C7M4mEMby/N8MdDNLwmPmFZ7F4pj0FJJ1m8EZERERUTiybDLF2ZycAYGpzDXa09+HlrW047dBc841lm/Zjb1ey6EzYYCUMHTFdsiWQbQU6WgYZzpy3hxa/iTufWJfXbCS4Jy7pBIUxXZC2LCQMDe8+/iDfc4rNvD2+cgeA4Q+2GLxVpkRNHbQ6uyzWTCcjXg0REVH0yjV3kQgY45m3QwaYRZYwNGgCdPVlfMff/4PFAOy9ZeVW48l4tfUUG7xp6E5l0NZrz6/r6ssEMm+abw5cMpPb85bOqLyxAEBpZZMAhj3zFmxYQhVEt+e9WZnMACcSERER0VCM2czbKzee62s4EtabMem0zC80kLrc3SYBu0V/p5PQKDRLLsjQBc+u34tn1+8FgLzOkbqnbFIphQPddpBnNzqxEAsJvILBWI9TNnnlz1fgT6t2Ys1/nxdYd3n3vFHlEM3+Z6R97zaYVgaTpx8a8YqIiIiIqtOYDd4aa2K++ypkEFqfM4g6VSB4885eKxfvXrM5kxqKes7eTn/5mhn42QxdsGlfD17f04Wn1u7Gfc+9AcAO8tIFGqMEO2t2JzO45f+3d+/xVdVnvsc/z85VSAiCeAGkphqLCIKAUM0wI9Ih2qKOjKB2bEtnzsAobQ8eZcRBnIGX9uA47cwcW6E6UsfLtAes0s5AC20tw7R0EAhIY6OEtOkh0BZqC5LUhFye88deiTsh931Zyc73/XrxYu91+z1rZe+197N/t2+X8+r+o9F9m73N/HPNvZiqoCdik7c/uOy8hB5b4mNBzdulr9wUXfB3p0KMRkRERCR9Depmk92pb4xOB/DVH1Wx9SfRvlwv/LiqdX1Xc50lSmx/tS+2G0SkM8faTW/w3pkmPKZusWWUzBu+8J/8+xvHWpc3NXswquXZL4uCc7L4/G2TWp/vqfotX/nPn7U+3/7TX7epoaxPcGKbG3MdNiy6JqHHlvhYZtsfQo4f/XlIkYiIiIikNyVvXahraKIhSEIe/MZBmpudVd988/31jSlI3oKat6njhpOX07eK0p2HTrBxb3Xr84yYvnqxFWTRmreO+7wBfHzmOH72+Y8C8Lvatk04/+rFfWzce6T1eWe1lX3Vch1mFo44q/+dhMsibZO36rIfKoETERERSQJ9C+5CswNBS8CMiPG7359psz4VNW8tNU7th+rvjap3ft/meWyzyNhRJ5uanYbGricfj0SMnMwIx069d9a6xpiJwRPdpLRgSBbPffoavvKJaQk9rsQv0q7mzcte4fxnplD67a+GFJGIiIhIelLyFuigyxv3Xn9p60gmTU3OtEe/12Z9dyMuJkLLQCG9qW2Kbd7Ykdg57WIHM2lqDvq8ZXY9EMs52Rn8ol1CCG0HcCm6oGf983rj+g+dz/Ah2Qk/rsQnktm2Rnja6dcAqD9WFkY4IiIiImlLyVsn8nIy+esbx7cmN6frzx4GvaeTZsejZX6z3iRvH585jr+cVdjp+sxIxzVvzU6nfd5ita9xvGnihQCcDqZUuHnyaD4+Y1yP45WBrX2zyRaRvFEpjkREREQkvSl560Rjc7TZX0eDJl46Kjo/3KQxw5MeR0vNW2/nTeuqmWXEYpK3jmreukne2g9G0lIb9m4wlcHUccMxS/40CtI/tG822cI1abeIiIhIQg3aqQLa83YzvQW521nLAR7+2AQuGp7LB89LfNPA9vpS89bd9m1q22L7vAUDlvR2TrX83OjL6N26aPKmOdkGl0hGJ8lbfU2KIxERERFJb0reAu37vHVV85aTFWH8hcNSEFU8NW+db98Yc1Kxg5k0BzVvw3J79rKYP3UMr5Qeba1xO/VetNnkOdlK3gaTzmreOHM6tYGIiIj00CUrtoQdgkifqNlkJ1rym44m745n5Mfeaql5622ZXSVvzR2NzkK05u1MN6NNxrr8gnwAflMTbR7XMmdcKq+PhC8j8/1BZI4zovVxpKE2jHBERERE0paSt0DH6UzHNW+xE0YnW19GmwTI6mHNWyz36BD/Xe0ba95VF3HD+PN58MbxbZbnpPD6SPgiGe/X1FYN/3Dr4wwlbyIiIiIJpW/ZgY5q2DpbnsqapWG50SZpp+sautmyrU7ys+i6mJWfuvYDbdbVNTR1Okl3excMy2XDomsoCmrgWuT0cH9JDxlZ0Zq3034OnnlO6/LMRiVvIiIiIomkb9ndCLvmrSQYhr++oXeTXjd3kb3FDliS225wkbrG5jaTeHels+aVva0llIGtqSE6eX3l0Ck0Zw1tXZ7ZdPZcgCIiIiLSd/qW3QeprHm7/IJ8vvrpa1j5sSt6tV9L08gbxp/P8CFtB5SITd5ysjLY+/BH+NycIiBa89Zdn7fnPn0Nn7vhsk7Xq8/b4PLBiR9m94SVXLrk3yB7SOvyHCVvIiIiIgml0SYDXbQyPEuq+3TN/tD5vd6npebt0lFD2bDoGmrrG7nyb7cBbfu85WZFOC8vh7ycaMLVk+Tt+g+dz/VdxKSat8HFIhFmLvzr6OPY5K1ZyZuIiIhIIil568D1HxrFfR+5vNP1uQOgZqmltu2CYbkADM15/08dOzF3y7m0TNzd7PEnp0reBi/LzGl9PMSVvImIiIgkkpK3FjFVb5+94TImXzy800172icsTH86dSwZEeOWyaNblz39iWnk5Wbywo9/0bqspc9bRuT9c4q32WNv56STNGLv/+3P8fdCDEREREQk/ehbdmDVvAmtjzMi71+Wf1gw+axtzfp/8haJGPOnjiUzpgnk3Csv5LpLz+O6S0e2LmupJcuLqZmLd0AW1bwNYjHJ21Crp6mpKcRgRERERNJLXN+yzWyBmb1pZs1mNr3duofM7LCZvW1mJfGFmXyzx5/PuBHR/jqZMbVQt08b2/r4c3OK+GwXA3UMFHd/+AN8+IPRyZRbzvXymOH+4615U/I2eJm1/dvX1pwKKRIRERGR9BNvs8kyYD7wldiFZjYBuBO4EhgNfM/MLnf3AfEzfGYnzSL/sOg8pl8yIsXRJJ6ZMTIv2jcpEiRvRRfkta6Pt9ljT+eJkzTULnl77/TvGFYw8N8zIiIiIv1BXN+y3b3c3d/uYNWtwNfdvd7dfw4cBmbEU1YqZUY6viyZaZSUtIxG2VLzNiT7/Tw+3uRNfd4Gr1FXFAOwL+96AOpU8yYiIiKSMMn6lj0GOBLzvDpYdhYzW2xme81s74kTJ5IUTs84bROa9gbCQCU91TJdQKSD/nvtJ+7urYHQJ1CSo3DCNZx56NdkXH0XAE0bPx1yRCIiIiLpo9vkzcy+Z2ZlHfy7NREBuPvT7j7d3aePGjUqEYeMI5bo/xmdJm/pU6PUUvPW0bn2peZs2UeK4o5J0kN2Ti4ZmdkAfLC5KtxgRERERNJIt33e3P0jfTjuUeDimOdjg2X9mnczU3dnNXID0ejh5wBwbjAfHETPr7HZyelDzduyj1zOP32vImHxycBWNKMEfgDHGUHvp5gXERERkY4ka563bwH/ZmZfJDpgSRHwepLKSpl0qnlb+bEruO7SkW0GYMloSd7SpM9aQ0MD1dXV1NXVhR3KoJGbm8vYsWPJPWco+/Jv4Pyat8IOSURERCRtxJW8mdltwJPAKGCLmR1w9xJ3f9PMNgI/BRqBpQNhpMmcYH6zzrpsdTYK5UCUm5XBTZMuarMsKyNCfWNz3H3e+ovq6mry8/O55JJL1A8vBdydd955h+rqagoLC2mOZJPlDaHGZGYXA88DFwAOPO3u/2xmI4D/C1wCVAEL3f13YcUpIhLLzKqA00AT0Oju07veQ0QGi3hHm3zV3ce6e467X+DuJTHrHnP3S939Q+7+7fhDTb6vLrqGz80pYkzQpLC9dKp560hL/7d0qXmrq6tj5MiRStxSxMwYOXJka01nc0Y2mYSbvBH98eh+d58AfBhYGkxlsgL4vrsXAd8PnouI9Cez3X2KEjcRiZWsZpMD0gdGDuV//fHlna7P6mQKgXSRGWfy9v37/4iausZEhhQ3JW6p1eZ6Z2STHXLy5u6/BH4ZPD5tZuVER769Fbg+2OxfgR3AgyGEKCIiItJjSt56IZ2aTXak5fyy+5i8XToqr/uNZNDwjByy/UzYYbQys0uAq4HdwAVBYgfwK6LNKjvaZzGwGGDcuHHJD1JEJMqB7WbmwFfc/enYlbo3iQxe6V2VlGBpn7ylec2ipJZn5pBNI97cHHYomFke8A1gmbu/G7vO3R3ocKzZ/jSViYgMKn/g7lOBm4g29/7D2JW6N4kMXvq23gvp3mzyy382lY9OupCLCjru8ye9c/LkSZ566ikAjh07xu233x5yRJ277rrrEn/QjGwi5jQ2hj5oSRbRxO0ld38lWPxrM7soWH8RcDys+ERE2nP3o8H/x4FXgRnhRiQi/UV6ZyMJFkmjed46MuXi4Tz1Z9M6naRceic2eRs9ejQvv/xyyBGdrbEx2kdx165dCT+2ZeYAcKb+vYQfu8cxRDvhPQuUu/sXY1Z9C/hU8PhTwDdTHZuISEfMbKiZ5bc8BuYCZeFGJSL9hfq89cD/nj+Jr/7o52GHIXFY/e9v8tNj73a/YS9MGD2Mv735yk7Xr1ixgsrKSqZMmUJRURHl5eWUlZXx3HPPsXnzZmpra6moqOCBBx7gzJkzvPDCC+Tk5LB161ZGjBhBZWUlS5cu5cSJEwwZMoRnnnmG8ePHd1jWpk2bWL16NRkZGRQUFLBz506amppYsWIFO3bsoL6+nqVLl7JkyRJ27NjBqlWrOPfcc3nrrbc4dOgQeXl51NTUAPDEE0+wceNG6uvrue2221i9ejW1tbUsXLiQ6upqmpqaWLVqFXfccUfXFyhI3hrqQ51nrxj4BPATMzsQLPsbYC2w0cz+AvgFsDCk+ERE2rsAeDUYACoT+Dd3/064IYlIf6HkrQfumjGOu2aoQ7D0ztq1aykrK+PAgQNUVVUxb9681nVlZWXs37+furo6LrvsMh5//HH279/Pfffdx/PPP8+yZctYvHgx69evp6ioiN27d3Pvvffy2muvdVjWmjVr2LZtG2PGjOHkyZMAPPvssxQUFLBnzx7q6+spLi5m7ty5AJSWllJWVkZhYWGb42zfvp2Kigpef/113J1bbrmFnTt3cuLECUaPHs2WLVsAOHXqVLfn3x9q3tz9h0BnVclzUhmLiEhPuPvPgMlhxyEi/ZOSNxkUuqohC8Ps2bPJz88nPz+fgoICbr75ZgAmTZrEwYMHqampYdeuXSxYsKB1n/r6+k6PV1xczKJFi1i4cCHz588HoonYwYMHW5trnjp1ioqKCrKzs5kxY8ZZiVvLPtu3b+fqq68GoKamhoqKCmbNmsX999/Pgw8+yLx585g1a1a35xjJygVCr3kTERERSRtK3kRCkJOT0/o4Eom0Po9EIjQ2NtLc3Mzw4cM5cOBAZ4doY/369ezevZstW7Ywbdo09u3bh7vz5JNPUlJS0mbbHTt2MHTo0A6P4+489NBDLFmy5Kx1paWlbN26lYcffpg5c+bwyCOPdBmTZUXPqfFMeDVvIiIiIulEA5aIJEl+fj6nT5/u077Dhg2jsLCQTZs2AdGk6o033uh0+8rKSmbOnMmaNWsYNWoUR44coaSkhHXr1tHQEB3t8dChQ9TW1nZZbklJCRs2bGjt/3b06FGOHz/OsWPHGDJkCHfffTfLly+ntLS023OIZEZr3hrPqOZNREREJBFU8yaSJCNHjqS4uJiJEydyxRVX9Hr/l156iXvuuYdHH32UhoYG7rzzTiZP7rgbxPLly6moqMDdmTNnDpMnT+aqq66iqqqKqVOn4u6MGjWKzZs3d1nm3LlzKS8v59prrwUgLy+PF198kcOHD7N8+XIikQhZWVmsW7eu2/gzWmvelLyJiIiIJIJF56ftH6ZPn+579+4NOwxJE+Xl5X1KmiQ+Lde97L++ycTvf5I3536NicUf2+fu08OOLR7pfn+6ZMWWsEOQfqhq7cfCDiGpzEz3pn5O9yZJF725n3Z1b1KzSRFJisycIQA01f8+5EhERERE0oOaTYoMII899lhrP7gWCxYsYOXKlSFF1Lnc/HMBaHiv+2kFRERERKR7St5EBpCVK1f2y0StI7l5wwFo+r2SNxEREZFEULNJEUmKocNGANBcp+RNREREJBGUvIlIUgzNK6DZDa97N+xQRERERNKCmk2KSFJEMjJ4187B6vs2152cTaOuiYiIDG6qeRORpPk9Q8g4o+RNREREJBGUvIkkycmTJ3nqqacAOHbsGLfffnvIEXXuuuuuS8px34sMJbNByZuIiIhIIih5E0mS2ORt9OjRvPzyyyFHdLbGxkYAdu3alZTj12UMJbuxJinHFhERERls1OdNBodvr4Bf/SSxx7xwEty0ttPVK1asoLKykilTplBUVER5eTllZWU899xzbN68mdraWioqKnjggQc4c+YML7zwAjk5OWzdupURI0ZQWVnJ0qVLOXHiBEOGDOGZZ55h/PjxHZa1adMmVq9eTUZGBgUFBezcuZOmpiZWrFjBjh07qK+vZ+nSpSxZsoQdO3awatUqzj33XN566y0OHTpEXl4eNTXRJOuJJ55g48aN1NfXc9ttt7F69Wpqa2tZuHAh1dXVNDU1sWrVKu64445uL1FjJIesprq+XV8RERERaUPJm0iSrF27lrKyMg4cOEBVVRXz5s1rXVdWVsb+/fupq6vjsssu4/HHH2f//v3cd999PP/88yxbtozFixezfv16ioqK2L17N/feey+vvfZah2WtWbOGbdu2MWbMGE6ePAnAs88+S0FBAXv27KG+vp7i4mLmzp0LQGlpKWVlZRQWFrY5zvbt26moqOD111/H3bnlllvYuXMnJ06cYPTo0WzZEh0w49Spng3/3xzJJqNRzSZFRNKdBlQSSQ0lbzI4dFFDFobZs2eTn59Pfn4+BQUF3HzzzQBMmjSJgwcPUlNTw65du1iwYEHrPvX19Z0er7i4mEWLFrFw4ULmz58PRBOxgwcPtjbXPHXqFBUVFWRnZzNjxoyzEreWfbZv387VV18NQE1NDRUVFcyaNYv777+fBx98kHnz5jFr1qwenWdzJItMb+jZRRERERGRLil5EwlBTk5O6+NIJNL6PBKJ0NjYSHNzM8OHD+fAgQM9Ot769evZvXs3W7ZsYdq0aezbtw9358knn6SkpKTNtjt27GDo0KEdHsfdeeihh1iyZMlZ60pLS9m6dSsPP/wwc+bM4ZFHHuk2LiVvIiIiIomjAUtEkiQ/P5/Tp/vWZHDYsGEUFhayadMmIJpUvfHGG51uX1lZycyZM1mzZg2jRo3iyJEjlJSUsG7dOhoaosnToUOHqK2t7bLckpISNmzY0Nr/7ejRoxw/fpxjx44xZMgQ7r77bpYvX05paWmPzqM5kk0GjT3aVkRERES6ppo3kSQZOXIkxcXFTJw4kSuuuKLX+7/00kvcc889PProozQ0NHDnnXcyefLkDrddvnw5FRUVuDtz5sxh8uTJXHXVVVRVVTF16lTcnVGjRrF58+Yuy5w7dy7l5eVce+21AOTl5fHiiy9y+PBhli9fTiQSISsri3Xr1vXoHDySRZZq3kREREQSwty97zubLQD+DrgCmOHue4PlfwysBbKBM8Byd+94pIVYXb0KAAAR0klEQVQY06dP97179/Y5HpFY5eXlfUqaJD6x1333lz7N5b/5LiNWH93n7tNDDi0u/eH+pAEBJNWq1n4s7BCSysx0b0oQ3Z9Eutab+2lX96Z4a97KgPnAV9ot/w1ws7sfM7OJwDZgTJxlicgA4xnZZLmaTYqIiIgkQlzJm7uXA5hZ++X7Y56+CZxjZjnu3vlweSLSrccee6y1H1yLBQsWsHLlypAi6ppHsslGzSZFREREEiEVfd7+FCjtLHEzs8XAYoBx48alIByRgWvlypX9NlHriGVkkW2qeRMZqJLVFC7dm2OKiCRLt8mbmX0PuLCDVSvd/Zvd7Hsl8Dgwt7Nt3P1p4GmIttvuLh4RGTg8IyvsEERERETSRrfJm7t/pC8HNrOxwKvAJ929si/HEJGBzTJzut9IRERSQoOKiAx8SZnnzcyGA1uAFe7+o2SUISIDQEZ22BGIiIiIpI24kjczu83MqoFrgS1mti1Y9RngMuARMzsQ/Ds/zlhFZICxTCVvIiIiIokSV/Lm7q+6+1h3z3H3C9y9JFj+qLsPdfcpMf+OJyZkkYHh5MmTPPXUUwAcO3aM22+/PeSIOnfdddcl5bgRNZsUERERSZikNJsUkbbJ2+jRo3n55ZdDjuhsjY3RkSB37dqVlOOr5k1EREQkcVIxVYBI6B5//XHe+u1bCT3m+BHjeXDGg52uX7FiBZWVlUyZMoWioiLKy8spKyvjueeeY/PmzdTW1lJRUcEDDzzAmTNneOGFF8jJyWHr1q2MGDGCyspKli5dyokTJxgyZAjPPPMM48eP77CsTZs2sXr1ajIyMigoKGDnzp00NTWxYsUKduzYQX19PUuXLmXJkiXs2LGDVatWce655/LWW29x6NAh8vLyqKmpAeCJJ55g48aN1NfXc9ttt7F69Wpqa2tZuHAh1dXVNDU1sWrVKu64445ur5GSNxEREZHEUfImkiRr166lrKyMAwcOUFVVxbx581rXlZWVsX//furq6rjssst4/PHH2b9/P/fddx/PP/88y5YtY/Hixaxfv56ioiJ2797Nvffey2uvvdZhWWvWrGHbtm2MGTOGkydPAvDss89SUFDAnj17qK+vp7i4mLlzo7N2lJaWUlZWRmFhYZvjbN++nYqKCl5//XXcnVtuuYWdO3dy4sQJRo8ezZYt0ZHKTp061aNroGaTIiIiIomj5E0Gha5qyMIwe/Zs8vPzyc/Pp6CggJtvvhmASZMmcfDgQWpqati1axcLFixo3ae+vsN57gEoLi5m0aJFLFy4kPnz5wPRROzgwYOtzTVPnTpFRUUF2dnZzJgx46zErWWf7du3c/XVVwNQU1NDRUUFs2bN4v777+fBBx9k3rx5zJo1q0fnGclS8iYiIiKSKEreREKQk/N+UhOJRFqfRyIRGhsbaW5uZvjw4Rw4cKBHx1u/fj27d+9my5YtTJs2jX379uHuPPnkk5SUlLTZdseOHQwdOrTD47g7Dz30EEuWLDlrXWlpKVu3buXhhx9mzpw5PPLII93GlaFmkyLSgWTON1a19mNJO7aISNg0YIlIkuTn53P69Ok+7Tts2DAKCwvZtGkTEE2q3njjjU63r6ysZObMmaxZs4ZRo0Zx5MgRSkpKWLduHQ0NDQAcOnSI2traLsstKSlhw4YNrf3fjh49yvHjxzl27BhDhgzh7rvvZvny5ZSWlvboPAouvITdI2/t0bYiIiIi0jXVvIkkyciRIykuLmbixIlcccUVvd7/pZde4p577uHRRx+loaGBO++8k8mTJ3e47fLly6moqMDdmTNnDpMnT+aqq66iqqqKqVOn4u6MGjWKzZs3d1nm3LlzKS8v59prrwUgLy+PF198kcOHD7N8+XIikQhZWVmsW7euR+dwcdFkLi56Hj73Qu9OXkRERETOYu4edgytpk+f7nv37g07DEkT5eXlfUqaJD4dXXcz2+fu00MKKSH6w/0pmU3NRNJFb5pNDrZ7k+4hIuFJ1L1JzSZFREREREQGADWbFBlAHnvssdZ+cC0WLFjAypUrQ4pIOqJft0VERCQZlLxJWnN3zCzsMBJm5cqV/TpR60/NsEVERETSjZpNStrKzc3lnXfeUUKRIu7OO++8Q25ubtihiIiIiKQl1bxJ2ho7dizV1dWcOHEi7FAGjdzcXMaOHRt2GCIiIiJpScmbpK2srCwKCwvDDkNEREREJCHUbFJEBiUzu9HM3jazw2a2Iux4RERa6P4kIp1R8iYig46ZZQBfBm4CJgB3mdmEcKMSEdH9SUS6puRNRAajGcBhd/+Zu58Bvg7cGnJMIiKg+5OIdKFf9Xnbt29fjZm9HcchCoBTKdgn1nnAb/qwX7zl9nX/vsYbb7nx7htP3IMp5v4a74f6eNxkGQMciXleDcxsv5GZLQYWB0/7cn+K9/3WX+m8Bp50Pbezzsse79X+H0hkMAnS7f2pi3tT2H9nlT+4y+8PMfTb8hN1b+pXyRvwtrtP7+vOZva0uy/ufsv49mm3/96+xJyAcvu0f1/jjbfcBOzb57gHU8z9NV4z29uX44bN3Z8Gnu7r/vG+3/orndfAk67nlq7n1Z3O7k1hXw+VP7jL7w8xDIby063Z5L+naJ9EiLfcgRi3Yk5+uQMt3rAcBS6OeT42WCYiEjbdn0SkU2mVvLl7r79A9mWfRIi33IEYt2JOfrkDLd4Q7QGKzKzQzLKBO4FvhRyTiAjo/iQiXehvzSb73DwpRAMt5oEWb4uBGPdAizmZ8fara+HujWb2GWAbkAFscPc3k1BUvzrvBNJ5DTzpem5pd15x3p/Cvh4qf3CXD+HHkPblm7snuwwRERERERGJU1o1mxQREREREUlXSt5EREREREQGgFCSNzOrCaPcvjKzPzEzN7PxYcfSW91dazPbYWb9YphlMxtrZt80swozqzSzfw46a3e2/TIzG5LKGDuJQ69n6ZSZPWFmb5nZQTN71cyGhx1TIpjZAjN708ya+8s9JB5mdqOZvW1mh81sRdjxJIKZbTCz42ZWFnYsiWRmF5vZD8zsp8Fr8H+GHVPYuns/mtk4M6sxswdSWb6Z/bGZ7TOznwT/35DK8oN1DwXv67fNrCQZ5bcrb4qZ/beZHTCzvWY2I9lldhDDZ4PPnTfN7O9TXX4Qw/3Bd43zUlxuKJ+5qfwMUc1bz9wF/DD4v8fMLCM54aQfMzPgFWCzuxcBlwN5wGNd7LYMCD15G4D0ek6t7wIT3f0q4BDwUMjxJEoZMB/YGXYg8Qpe218GbgImAHeZ2YRwo0qI54Abww4iCRqB+919AvBhYGma/L3i0d378YvAt0Mo/zfAze4+CfgU8EIqyw9eF3cCVxJ9LzyVgs+yvwdWu/sU4JHgecqY2WzgVmCyu18J/EMqyw9iuBiYC/y/VJdNCJ+5qf4MCS15M7M8M/u+mZUGv8jcGiy/xMzKzeyZ4BeD7WZ2TphxAn8A/AXRGwBmdr2Z7TSzLUGWvd7MIsG6GjP7gpm9AVwbVtyxgnj/I+b5l8xsUYghdeQGoM7dvwrg7k3AfcCfm9lQM/sHMysLfkn5rJl9DhgN/MDMfhBi3IBez9I5d9/u7o3B0/8mOmfTgOfu5e7+dthxJMgM4LC7/8zdzwBfJ/rlZ0Bz953Ab8OOI9Hc/ZfuXho8Pg2UA2PCjSpcXb0fzexPgJ8DyRhRt8vy3X2/ux8Lnr4JnGNmOakqn+j7+OvuXu/uPwcOE32/J5MDw4LHBcCxLrZNhnuAte5eD+Dux1NcPsA/An9N9FqkVEifuSn9DAmz5q0OuM3dpwKzgS8EtS8ARcCXg18MTgJ/GlKMEL3433H3Q8A7ZjYtWD4D+CzRDPtSor/4AAwFdrv7ZHf/YcqjHbiuBPbFLnD3d4n+avM/gEuAKcEvKS+5+/8hekOc7e6zUxxrR/R6lp74c5L767f0zRjgSMzzagZ5MjBQmNklwNXA7nAj6Z+CH+weBFaHHQvRz77SlqQiRcJ4by8DnjCzI0RrvVLd2uJyYJaZ7Taz/zSza1JZePDj9VF3fyOV5XYiVZ+5KX2dhTnPmwGfN7M/BJqJnuQFwbqfu/uB4PE+ol/cw3IX8M/B468Hz/8DeN3dfwZgZl8jWpvxMtAEfCOEONPZ9cBTLb+kuHt//CVZr+dBzMy+B1zYwaqV7v7NYJuVRJt7vZTK2OLRk/MSCUuQmHwDWBb82JfW+vh+/DvgH9295v3fE1Nafsu+VwKPE21Kl/LyE62rWIA5wH3u/g0zWwg8C3wkheVnAiOINim+BthoZh/0BM4N1k35f0Mcf+d4yx/In7k9FWby9mfAKGCauzeYWRWQG6yL/VWmCQilmZmZjSDanG+SmTnRyTId2MLZVcEtz+uCJn/9SSNta1lzO9swRD8Fbo9dYGbDgHFAVRgB9ZJez4OYu3f5wRw0U54HzEnkB2iydXdeaeQocHHM87HBMumnzCyLaOL2kru/EnY8qdDH9+NM4PZg0IrhQLOZ1bn7l1JUPmY2FngV+KS7V/blGHGUn5T3dlexmNnzQMsgOpuAf4m3vF6Wfw/wSvBZ87qZNQPnASeSXb6ZTQIKgTeCHwvGAqVmNsPdf5Xs8mPiWERqP3NT+hkSZrPJAuB48EV3NvCBEGPpzO3AC+7+AXe/xN0vJtpufBYww8wKg75BdxAdAKK/+gUwwcxyLDrqzpywA+rA94EhZvZJaO38+QWiHe63AUvMLDNYNyLY5zSQn/pQO6TXs3TIzG4k2vb/Fnf/fdjxSIf2AEXBeyCbaH/Qb4Uck3QiaJL+LFDu7l8MO57+zN1nBff7S4B/Aj7fl8Str4LvHFuAFe7+o1SVG+NbwJ3B959Cot0YXk9ymceAPwoe3wBUJLm89jYT7b6BmV0OZBMdOCbp3P0n7n5+zGuuGpiayMStOyF95qb0MyTlyVvwBbyeaDXmdDP7CfBJ4K1Ux9IDdxH9tSjWN4Lle4AvEe0o/fMOtgtdy7V29yPARqKjMW0E9ocaWAeCX0ZuAxaYWQXREYLqiFa//wvRvm8Hg4EzPh7s9jTwnTAHLNHrWXrgS0R/ZPiuRYeOXh92QIlgZreZWTXRgWy2mNm2sGPqq6BJ9meI/lBUDmx096QN7pAqQRPoHwMfMrNqM/uLsGNKkGLgE8ANwXvqgJl9NOygwhT2+7GL8j8DXAY8EvO3Oj9V5Qfv441EW/d8B1iagtYkf0m03/sbwOeBxUkur70NwActOkXI14FPDaQWHwmQ8s/cVH+GWKr/nmY2GXjG3VM+70WimNn1wAPuPi/sWLqSDte6v0uHazxQXs8iIiIig11Ka97M7K+ArwEPp7LcwUjXOvl0jUVEREQklVJe8yYiIiIiIiK9F+aAJSIiIiIiItJDSU3ezOxiM/uBmf3UzN40s/8ZLB9hZt81s4rg/3OD5ePN7MdmVm9mD7Q71o1m9raZHTazFcmMW6QjCX49bzCz40GHYhERERGRbiW75q0RuN/dJxCdLHCpmU0AVgDfd/ciokPEtyRjvwU+R3RG+lbBsPFfBm4CJgB3BccRSaWEvJ4DzwE3Jj1iEREREUkbSU3e3P2X7l4aPD5NdPjMMcCtwL8Gm/0r8CfBNsfdfQ/Q0O5QM4DD7v4zdz9DdOjTW5MZu0h7CXw94+47iSZ3IiIiIiI9krI+b2Z2CXA1sBu4wN1/Gaz6FXBBN7uPAY7EPK8OlomEIs7Xs4iIiIhIr6UkeTOzPKKTAS9z93dj1wUTB2rISxkw9HoWERERkTAkPXkzsyyiX3RfcvdXgsW/NrOLgvUXAce7OcxR4OKY52ODZSIplaDXs4iIiIhIryV7tEkDngXK3f2LMau+BXwqePwp4JvdHGoPUGRmhWaWDdwZHEMkZRL4ehYRERER6bWkTtJtZn8A/BfwE6A5WPw3RPsJbQTGAb8AFrr7b83sQmAvMCzYvgaY4O7vmtlHgX8CMoAN7v5Y0gIX6UCCX89fA64HzgN+Dfytuz+bwtMRERERkQEmqcmbiIiIiIiIJEbKRpsUERERERGRvlPyJiIiIiIiMgAoeRMRERERERkAlLyJiIiIiIgMAEreREREREREBgAlbyIiIiIiIgOAkjcREREREZEB4P8DUMZWsAKMJxcAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df = df_arima\n", + "order = (2, 2, 3)\n", + "run_tests(df, order)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 47775e2cc97eb4d764127f58a8dbfc8149d50b67 Mon Sep 17 00:00:00 2001 From: Simon B Date: Sun, 3 May 2020 09:49:22 -0300 Subject: [PATCH 11/23] Stat_tools imports organized --- gtime/forecasting/arima.py | 2 +- gtime/plotting/plotting.py | 2 +- gtime/stat_tools/__init__.py | 12 ++++++++++++ 3 files changed, 14 insertions(+), 2 deletions(-) create mode 100644 gtime/stat_tools/__init__.py diff --git a/gtime/forecasting/arima.py b/gtime/forecasting/arima.py index a739dae..79c3092 100644 --- a/gtime/forecasting/arima.py +++ b/gtime/forecasting/arima.py @@ -2,7 +2,7 @@ import pandas as pd from typing import Tuple from gtime.forecasting.simple_models import SimpleForecaster -from gtime.stat_tools.mle_estimate import MLEModel # TODO better import +from gtime.stat_tools import MLEModel def _arma_forecast(n: int, x0: np.array, eps0: np.array, mu: float, phi: np.array, theta: np.array) -> np.array: diff --git a/gtime/plotting/plotting.py b/gtime/plotting/plotting.py index aeda0b3..0d3ac59 100644 --- a/gtime/plotting/plotting.py +++ b/gtime/plotting/plotting.py @@ -3,7 +3,7 @@ import numpy as np from typing import Union, List, Callable, Optional from gtime.plotting.preprocessing import seasonal_split -from gtime.stat_tools.tools import acf, pacf +from gtime.stat_tools import acf, pacf from scipy.stats import norm diff --git a/gtime/stat_tools/__init__.py b/gtime/stat_tools/__init__.py new file mode 100644 index 0000000..3775c8a --- /dev/null +++ b/gtime/stat_tools/__init__.py @@ -0,0 +1,12 @@ +""" +The :mod:`gtime.stat_tools` module contains statistical functions: autocorrelations, MLE estimates etc. +""" + +from .mle_estimate import MLEModel +from .tools import acf, pacf + +__all__ = [ + "MLEModel", + "acf", + "pacf" +] \ No newline at end of file From 0b2baac4bca21ba13776b63797122ab7dd5e5bdd Mon Sep 17 00:00:00 2001 From: Simon B Date: Sun, 3 May 2020 14:12:52 -0300 Subject: [PATCH 12/23] OLS as initial estimate --- gtime/forecasting/arima.py | 6 ++-- gtime/stat_tools/__init__.py | 4 +-- gtime/stat_tools/mle_estimate.py | 58 ++++++++++++++++++++++++++++---- 3 files changed, 57 insertions(+), 11 deletions(-) diff --git a/gtime/forecasting/arima.py b/gtime/forecasting/arima.py index 79c3092..dcef3c3 100644 --- a/gtime/forecasting/arima.py +++ b/gtime/forecasting/arima.py @@ -2,7 +2,7 @@ import pandas as pd from typing import Tuple from gtime.forecasting.simple_models import SimpleForecaster -from gtime.stat_tools import MLEModel +from gtime.stat_tools import ARMAMLEModel def _arma_forecast(n: int, x0: np.array, eps0: np.array, mu: float, phi: np.array, theta: np.array) -> np.array: @@ -146,7 +146,7 @@ def _integrate(self, X: np.array) -> np.array: X = np.concatenate([self.diff_vals[:, [-i-1]], X], axis=1).cumsum(axis=1) return X - def _set_params(self, model: MLEModel, x: np.array): + def _set_params(self, model: ARMAMLEModel, x: np.array): """ Extracts fitted model parameters for easier access @@ -182,7 +182,7 @@ def fit(self, X: pd.DataFrame, y: pd.DataFrame): self.last_train_values_ = X.iloc[-len_stored_values:] if len_stored_values > 0 else X.iloc[:0] np_x = X.to_numpy().flatten() np_x = self._deintegrate(np_x) - model = MLEModel((self.n_ar, self.n_ma), self.method) + model = ARMAMLEModel((self.n_ar, self.n_ma), self.method) model.fit(np_x) self._set_params(model, np_x) super().fit(X, y) diff --git a/gtime/stat_tools/__init__.py b/gtime/stat_tools/__init__.py index 3775c8a..2254470 100644 --- a/gtime/stat_tools/__init__.py +++ b/gtime/stat_tools/__init__.py @@ -2,11 +2,11 @@ The :mod:`gtime.stat_tools` module contains statistical functions: autocorrelations, MLE estimates etc. """ -from .mle_estimate import MLEModel +from .mle_estimate import ARMAMLEModel from .tools import acf, pacf __all__ = [ - "MLEModel", + "ARMAMLEModel", "acf", "pacf" ] \ No newline at end of file diff --git a/gtime/stat_tools/mle_estimate.py b/gtime/stat_tools/mle_estimate.py index 3f7b4f7..ae63400 100644 --- a/gtime/stat_tools/mle_estimate.py +++ b/gtime/stat_tools/mle_estimate.py @@ -65,16 +65,60 @@ def _transform_params(param: np.array): return durbin_levinson_recursion(param) -class MLEModel: +def _np_shift(x: np.array, max_lag: int): # TODO possible merge somehow with Shift() + """ + Lag matrix up to ``max_lags`` for a time series ``x`` + + Parameters + ---------- + x: np.array, input array + max_lag: int, number of lags + + Returns + ------- + res: np.array, lag matrix + """ + + n = len(x) + res = np.zeros((n, max_lag)) + for i in range(n-1): + lim = min(i, max_lag) + start = max(0, i - max_lag + 1) + res[i+1, :lim+1] = x[start:i+1][::-1] + return res - def __init__(self, order, method='mle'): + +def _ols_arma_estimate(X: np.array, n_ar: int, n_ma: int): + """ + Simple OLS estimate for ARMA(n_ar, n_ma) process fitted on ``X`` + + Parameters + ---------- + X: np.array, input array + n_ar: int, degree of autoregressive components + n_ma: int, degree of moving average components + + Returns + ------- + params: fitted parameters array + + """ + lags = _np_shift(X, n_ar) + ar_coef = np.linalg.lstsq(lags, X, rcond=None)[0] + residuals = X[n_ar:] - np.dot(lags[n_ar:], ar_coef) + ols_lags = np.c_[lags[n_ar:], _np_shift(residuals, n_ma)] + params = np.linalg.lstsq(ols_lags, X[n_ar:], rcond=None)[0] + return params + + +class ARMAMLEModel: + + def __init__(self, order, method='css'): self.length = max(order[0], order[1] + 1) self.order = order self.method = method - p0 = np.random.random(order[0]) #TODO can be better? - q0 = np.random.random(order[1]) - self.parameters = np.r_[0.0, 0.0, p0, q0] + self.parameters = np.zeros(order[0] + order[1] + 2) def fit(self, X: np.array): """ @@ -86,13 +130,15 @@ def fit(self, X: np.array): Returns ------- - self: MLEModel + self: ARMAMLEModel """ mu = X.mean(keepdims=True) sigma = X.std(keepdims=True) / np.sqrt(len(X)) self.parameters[0] = mu self.parameters[1] = sigma + self.parameters[2:] = _ols_arma_estimate(X, self.order[0], self.order[1]) + Xmin = minimize(lambda phi: _run_css(phi, X, len_p=self.order[0]), x0=self.parameters, method='L-BFGS-B') From 8545c9827f2e5fd127595e15ede29a10bc7a2d00 Mon Sep 17 00:00:00 2001 From: Simon B Date: Sun, 3 May 2020 16:55:15 -0300 Subject: [PATCH 13/23] MLE CSS tests --- gtime/stat_tools/mle_estimate.py | 1 + gtime/stat_tools/tests/test_mle.py | 49 ++++++++++++++++++++++++++++++ 2 files changed, 50 insertions(+) create mode 100644 gtime/stat_tools/tests/test_mle.py diff --git a/gtime/stat_tools/mle_estimate.py b/gtime/stat_tools/mle_estimate.py index ae63400..adc1017 100644 --- a/gtime/stat_tools/mle_estimate.py +++ b/gtime/stat_tools/mle_estimate.py @@ -91,6 +91,7 @@ def _np_shift(x: np.array, max_lag: int): # TODO possible merge somehow with Shi def _ols_arma_estimate(X: np.array, n_ar: int, n_ma: int): """ Simple OLS estimate for ARMA(n_ar, n_ma) process fitted on ``X`` + Based on Box, G. E. P., G. M. Jenkins, and G. C. Reinsel. Time Series Analysis: Forecasting and Control. Parameters ---------- diff --git a/gtime/stat_tools/tests/test_mle.py b/gtime/stat_tools/tests/test_mle.py new file mode 100644 index 0000000..f21935c --- /dev/null +++ b/gtime/stat_tools/tests/test_mle.py @@ -0,0 +1,49 @@ +import numpy as np +import pytest +import hypothesis.strategies as st +from hypothesis.extra.numpy import arrays +from hypothesis import given, settings +from gtime.stat_tools import ARMAMLEModel + + +class TestMLEModel: + # test (0,0,0) + # test roots!!! + # test on constant + def test_zeros(self): + x = np.zeros(100) + model = ARMAMLEModel(order=(0, 0), method='css') + model.fit(x) + assert model.mu == pytest.approx(0.0) + + def test_ar(self): + x = np.array([(-1) ** i for i in range(100)]) + model = ARMAMLEModel(order=(1, 0), method='css') + model.fit(x) + assert model.phi == pytest.approx(-1.0) + + @given( + x=arrays(dtype=float, shape=st.integers(min_value=10, max_value=100), + elements=st.floats(max_value=1e15, min_value=-1e15, + allow_infinity=False, allow_nan=False), unique=True), + order=st.tuples(st.integers(min_value=1, max_value=3), st.integers(min_value=1, max_value=3)) + ) + @settings(deadline=None) + def test_random_likelihood(self, x, order): + model = ARMAMLEModel(order=order, method='css') + model.fit(x) + assert not np.isnan(model.ml) + + + @given( + x=arrays(dtype=float, shape=st.integers(min_value=10, max_value=100), + elements=st.floats(max_value=1e15, min_value=-1e15, + allow_infinity=False, allow_nan=False), unique=True), + order=st.tuples(st.integers(min_value=1, max_value=3), st.integers(min_value=1, max_value=3)) + ) + @settings(deadline=None) + def test_random_errors_len(self, x, order): + model = ARMAMLEModel(order=order, method='css') + model.fit(x) + errors = model.get_errors(x) + assert len(errors) == len(x) - order[0] \ No newline at end of file From 1fad3ca08f75bcab5fee89d1c4dc85b9a034c2f3 Mon Sep 17 00:00:00 2001 From: Simon B Date: Sun, 3 May 2020 17:44:58 -0300 Subject: [PATCH 14/23] ARIMA forecaster tests --- gtime/forecasting/arima.py | 3 ++- gtime/forecasting/tests/test_simple_models.py | 14 ++++++------- gtime/forecasting/tests/tests_arima.py | 21 +++++++++++++++++++ gtime/stat_tools/tests/test_mle.py | 4 +--- 4 files changed, 31 insertions(+), 11 deletions(-) create mode 100644 gtime/forecasting/tests/tests_arima.py diff --git a/gtime/forecasting/arima.py b/gtime/forecasting/arima.py index dcef3c3..f0968bc 100644 --- a/gtime/forecasting/arima.py +++ b/gtime/forecasting/arima.py @@ -179,6 +179,7 @@ def fit(self, X: pd.DataFrame, y: pd.DataFrame): """ len_stored_values = self.n_ar + self.order[1] + self.last_train_date_ = X.index.max().end_time self.last_train_values_ = X.iloc[-len_stored_values:] if len_stored_values > 0 else X.iloc[:0] np_x = X.to_numpy().flatten() np_x = self._deintegrate(np_x) @@ -204,7 +205,7 @@ def _extend_x_test(self, X: pd.DataFrame) -> (pd.DataFrame, np.array): errors: np.array, error forecast required for predictions """ n = len(X) - train_test_diff = X.index.min().start_time - self.last_train_values_.index.max().end_time + train_test_diff = X.index.min().start_time - self.last_train_date_ if train_test_diff.value == 1: X = pd.concat([self.last_train_values_, X]) errors = self.errors_[-self.n_ma:] diff --git a/gtime/forecasting/tests/test_simple_models.py b/gtime/forecasting/tests/test_simple_models.py index 9a94b87..61d54e5 100644 --- a/gtime/forecasting/tests/test_simple_models.py +++ b/gtime/forecasting/tests/test_simple_models.py @@ -2,7 +2,7 @@ import pandas as pd import pytest from pandas.util import testing as testing -from hypothesis import given, note +from hypothesis import given import hypothesis.strategies as st from gtime.utils.hypothesis.time_indexes import giotto_time_series from gtime.model_selection import horizon_shift, FeatureSplitter @@ -16,13 +16,13 @@ @st.composite -def forecast_input(draw, max_lenth): - length = draw(st.integers(min_value=2, max_value=max_lenth)) - horizon = draw(st.integers(min_value=1, max_value=length - 1)) +def forecast_input(draw, max_length, min_length=2): + length = draw(st.integers(min_value=min_length + 1, max_value=max_length)) + horizon = draw(st.integers(min_value=1, max_value=length - min_length)) X = draw( giotto_time_series( min_length=length, - max_length=max_lenth, + max_length=max_length, allow_nan=False, allow_infinity=False, ) @@ -33,9 +33,9 @@ def forecast_input(draw, max_lenth): class SimplePipelineTest: - def setup(self, data, Model): + def setup(self, data, model): X_train, y_train, X_test = data - self.model = Model + self.model = model self.model.fit(X_train, y_train) self.X_test = X_test self.y_pred = self.model.predict(X_test) diff --git a/gtime/forecasting/tests/tests_arima.py b/gtime/forecasting/tests/tests_arima.py new file mode 100644 index 0000000..0933cc5 --- /dev/null +++ b/gtime/forecasting/tests/tests_arima.py @@ -0,0 +1,21 @@ +import numpy as np +import pandas as pd +import pytest +from pandas.util import testing as testing +from hypothesis import given, settings +from gtime.forecasting.tests.test_simple_models import forecast_input, SimplePipelineTest # TODO to utilities? +import hypothesis.strategies as st + +from gtime.forecasting import ARIMAForecaster + + +class TestNaiveModel(SimplePipelineTest): + + @given(data=forecast_input(50, 10), + order=st.tuples(st.integers(min_value=0, max_value=4), + st.integers(min_value=0, max_value=2), + st.integers(min_value=0, max_value=4)) + ) + @settings(deadline=None) + def setup(self, data, order): + super().setup(data, ARIMAForecaster(order=order)) diff --git a/gtime/stat_tools/tests/test_mle.py b/gtime/stat_tools/tests/test_mle.py index f21935c..9775270 100644 --- a/gtime/stat_tools/tests/test_mle.py +++ b/gtime/stat_tools/tests/test_mle.py @@ -7,9 +7,7 @@ class TestMLEModel: - # test (0,0,0) - # test roots!!! - # test on constant + def test_zeros(self): x = np.zeros(100) model = ARMAMLEModel(order=(0, 0), method='css') From 004cb846dec802038f44506d5b5416a9eccb6dd3 Mon Sep 17 00:00:00 2001 From: Simon B Date: Sun, 3 May 2020 21:04:38 -0300 Subject: [PATCH 15/23] ARIMA pipeline test --- examples/arima-tests.ipynb | 280 +++++++++--------- gtime/forecasting/tests/tests_arima.py | 4 - gtime/time_series_models/tests/test_arima.py | 25 ++ .../tests/test_simple_models.py | 5 +- 4 files changed, 172 insertions(+), 142 deletions(-) create mode 100644 gtime/time_series_models/tests/test_arima.py diff --git a/examples/arima-tests.ipynb b/examples/arima-tests.ipynb index 2997c37..1c0e747 100644 --- a/examples/arima-tests.ipynb +++ b/examples/arima-tests.ipynb @@ -2,11 +2,11 @@ "cells": [ { "cell_type": "code", - "execution_count": 10, + "execution_count": 1, "metadata": { "ExecuteTime": { - "end_time": "2020-04-30T22:04:14.049436Z", - "start_time": "2020-04-30T22:04:14.040417Z" + "end_time": "2020-05-03T17:03:12.616448Z", + "start_time": "2020-05-03T17:03:06.910909Z" }, "scrolled": true }, @@ -44,11 +44,11 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": { "ExecuteTime": { - "end_time": "2020-04-30T22:03:45.008193Z", - "start_time": "2020-04-30T22:03:43.691450Z" + "end_time": "2020-05-03T17:03:14.521238Z", + "start_time": "2020-05-03T17:03:12.986344Z" } }, "outputs": [ @@ -76,17 +76,17 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": { "ExecuteTime": { - "end_time": "2020-04-30T22:03:45.623887Z", - "start_time": "2020-04-30T22:03:45.023073Z" + "end_time": "2020-05-03T17:03:14.893338Z", + "start_time": "2020-05-03T17:03:14.524070Z" } }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -107,27 +107,27 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": { "ExecuteTime": { - "end_time": "2020-04-30T22:03:46.053057Z", - "start_time": "2020-04-30T22:03:45.659585Z" + "end_time": "2020-05-03T17:03:15.276685Z", + "start_time": "2020-05-03T17:03:14.901752Z" } }, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -163,11 +163,11 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": { "ExecuteTime": { - "end_time": "2020-04-30T22:03:46.070766Z", - "start_time": "2020-04-30T22:03:46.055277Z" + "end_time": "2020-05-03T17:03:15.289256Z", + "start_time": "2020-05-03T17:03:15.280662Z" } }, "outputs": [], @@ -183,11 +183,11 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 6, "metadata": { "ExecuteTime": { - "end_time": "2020-04-30T22:04:16.993064Z", - "start_time": "2020-04-30T22:04:16.694642Z" + "end_time": "2020-05-03T17:03:15.594315Z", + "start_time": "2020-05-03T17:03:15.291363Z" } }, "outputs": [ @@ -196,18 +196,18 @@ "output_type": "stream", "text": [ "Basic AR results results:\n", - "Fitted parameters: mu=-0.02, p=[-0.04 0.01 0.02 -0.01]\n", - "RMSE: 1.12\n", + "Fitted parameters: mu=-0.02, p=[-0.03 0.02 0.03 -0.05]\n", + "RMSE: 1.10\n", "\n" ] }, { "data": { "text/plain": [ - "array([-0.04, 0.01, 0.02, -0.01])" + "array([-0.03, 0.02, 0.03, -0.05])" ] }, - "execution_count": 11, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -231,11 +231,11 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "metadata": { "ExecuteTime": { - "end_time": "2020-04-30T22:04:03.459274Z", - "start_time": "2020-04-30T22:04:02.507938Z" + "end_time": "2020-05-03T17:03:16.458785Z", + "start_time": "2020-05-03T17:03:15.600586Z" }, "scrolled": true }, @@ -244,19 +244,19 @@ "name": "stdout", "output_type": "stream", "text": [ - "Giotto results mle:\n", + "Giotto results css:\n", "Fitted parameters: mu=-0.00, p=[-0.94], q=[-0.06 -1. 0.03 0.03]\n", "AR roots abs:[1.06]\n", - "MA roots abs:[5.76 4.86 1.04 1. ]\n", + "MA roots abs:[5.75 4.85 1.04 1. ]\n", "Train error mean: -0.45, std: 20.82\n", "LL: 5150.12\n", - "RMSE: 46634.80\n", + "RMSE: 46634.73\n", "\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3MAAAE9CAYAAAChhDtPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeXzV1Z3/8dfnZiUQwhZRNkHBBZFdRCltlQpWca3btFrbsYOj9DfVWipWrSOVGawzbWfaitWBsS5TK9axTqGKVhjGoiC7KEjYlE2JQAJJyHbz+f1xv7ncJDcLcJObkPfz8ciD7/d8z/d7PzdT7+RzzzmfY+6OiIiIiIiItC2hZAcgIiIiIiIiR0/JnIiIiIiISBukZE5ERERERKQNUjInIiIiIiLSBimZExERERERaYOUzImIiIiIiLRBqckOoCE9evTw/v37JzsMEUmwlStXfu7uucmO43jo80nkxKPPJhFpjRr6bGrVyVz//v1ZsWJFssMQkQQzs4+THcPx0ueTyIlHn00i0ho19NmkaZYiIiIiIiJtkJI5ERERERGRNkjJnIickMxsu5m9b2ZrzGxF0NbNzN4ws7zg365Bu5nZv5vZZjNbZ2Yjkxu9iIiISONa9Zq5eCoqKti5cyelpaXJDqXdyMzMpE+fPqSlpSU7FJGjdZG7fx5zPh34i7vPMrPpwfm9wFeBQcHP+cDs4F8RERGRVqvRZM7MMoElQEbQ/yV3fyjm+r8Df+vunYLzDOAZYBSwD7jR3bcH1+4DbgPCwD+4++tHG/DOnTvJzs6mf//+mNnR3i5Hyd3Zt28fO3fuZMCAAckOR+R4XQV8OTj+LbCYSDJ3FfCMuzvwrpl1MbNT3H1PUqIUERERaYKmTLMsAy5292HAcOBSMxsLYGajga61+t8GHHD3gcDPgUeDvoOBm4BzgEuBx80s5WgDLi0tpXv37krkWoiZ0b17d42ESlvkwEIzW2lmU4K2njEJ2qdAz+C4N7Aj5t6dQZuIiIhIq9VoMucRRcFpWvDjQSL2GPDDWrdcReQbb4CXgAkWybyuAl5w9zJ33wZsBsYcS9BK5FqWft/SRn3B3UcSmUI51cy+GHsxGIXzo3mgmU0xsxVmtiI/Pz+BoYqIiIgcvSYVQDGzFDNbA+wF3nD3ZcB3gVfjTEOKfsPt7pVAIdAdffMtIi3I3XcF/+4F/pvIl0efmdkpAMG/e4Puu4C+Mbf3CdpqP/NJdx/t7qNzc9v0vsIiIiJyAmhSMufuYXcfTuQPnDHBN9zXA79MdEBt4ZvvgoICHn/8cQB2797Nddddl+SI6nfhhRcmOwSRFmdmHc0su/oYmAisB14Fbg263Qr8MTh+FfhmUNVyLFCo9XIiIiLS2h3V1gTuXgAsAi4CBgKbzWw7kGVmm4Nu0W+4zSwVyCFSCOWE+eY7Npnr1asXL730UpIjqquyshKApUuXJjkSae92bH6fXVs/aOmX7Qm8bWZrgeXAfHd/DZgFXGJmecBXgnOABcBWItO/nwLubOmARURERI5Wo8mcmeWaWZfguANwCbDS3U929/7u3h8oCQqeQM1vvq8D3grWprwK3GRmGWY2gEgJ8OWJfTstY/r06WzZsoXhw4dz/fXXM2TIEACefvpprr76ai655BL69+/Pr371K372s58xYsQIxo4dy/79+wHYsmULl156KaNGjWL8+PFs3Lix3teaN28eQ4YMYdiwYXzxi5ElP+FwmGnTpnHeeecxdOhQfvOb3wCwePFixo8fz5VXXsngwYMB6NSpU/RZjz32WPSehx6KFCQtLi7m8ssvZ9iwYQwZMoTf//73if+FSbv18cZV9H3uC/R+pmVHiN19q7sPC37OcfeZQfs+d5/g7oPc/Svuvj9od3ef6u6nu/u57r6iRQMWEREROQZN2WfuFOC3QcGTEPCiu/+pgf5zgGeDkbr9RCpY4u4fmNmLwIdAJTDV3cPHE/zD//MBH+4+eDyPqGNwr848dMU5DfaZNWsW69evZ82aNWzfvp3JkydHr61fv57Vq1dTWlrKwIEDefTRR1m9ejV33303zzzzDHfddRdTpkzhiSeeYNCgQSxbtow777yTt956K+5rzZgxg9dff53evXtTUFAAwJw5c8jJyeG9996jrKyMcePGMXHiRABWrVrF+vXr62wjsHDhQvLy8li+fDnuzpVXXsmSJUvIz8+nV69ezJ8/H4DCwsJj/t2J1HbqCxclOwSR49Z/+vxmee72WZc3y3NFRFqr5vo8hfb7mdpoMufu64ARjfTpFHNcSmQ9Xbx+M4GZRxljm3LRRReRnZ1NdnY2OTk5XHHFFQCce+65rFu3jqKiIpYuXcr11x/5FZWVldX7vHHjxvGtb32LG264gWuvvRaIJGbr1q2LTu8sLCwkLy+P9PR0xowZE3c/uIULF7Jw4UJGjIj8n7KoqIi8vDzGjx/PPffcw7333svkyZMZP358wn4XIiIiIiLSfJoyMtdqNTaClgwZGRnR41AoFD0PhUJUVlZSVVVFly5dWLNmTZOe98QTT7Bs2TLmz5/PqFGjWLlyJe7OL3/5SyZNmlSj7+LFi+nYsWPc57g79913H7fffnuda6tWrWLBggU88MADTJgwgR//+MdNfbsiDcpLHcSgyrxkhyEiIiJyQjqqAigSkZ2dzaFDh47p3s6dOzNgwADmzZsHRJKstWvX1tt/y5YtnH/++cyYMYPc3Fx27NjBpEmTmD17NhUVFQBs2rSJ4uLiBl930qRJzJ07l6KiyJaBu3btYu/evezevZusrCxuvvlmpk2bxqpVq47pfYnEk14V2Wz+AJ2THImIiIjIiadNj8wlS/fu3Rk3bhxDhgzh7LPPPur7n3/+ee644w4eeeQRKioquOmmmxg2bFjcvtOmTSMvLw93Z8KECQwbNoyhQ4eyfft2Ro4cibuTm5vLK6+80uBrTpw4kQ0bNnDBBRcAkcIozz33HJs3b2batGmEQiHS0tKYPXv2Ub8fkbjc6VEV2V4k1SuSHIyIiIjIiccihSZbp9GjR/uKFTWLym3YsOGYEig5Pvq9y9FaPuf7jNkxhwpPIUyIzIc/j14zs5XuPjqJ4R23eJ9PcmJSAZT2Q59NIs1LBVCOTUOfTZpmKSLNYsyOOQDkW3fSqExyNCIiIiInHiVzrcTMmTMZPnx4jZ+ZM0/owp9yAvKqKlYvfI7KivJo26GULqSYE67UVEsRERGRRNKauVbi/vvv5/777092GCLHZeOy1xixdCosnRptO9jxVDi4iYryMlJS05IYnYiIiMiJRSNzIpIwVaVF0eMd1guAyp6R4j4V5fXvpygiIiIiR0/JnIgkTPhwQfQ4RBUfpZ6JpURG4yorlMyJiIiIJJKSORFJmHB5afQ40w8TtjQsNR2ASo3MiYiIiCSUkjkRSZhw+eHocZYfJmypWEokmdM0SxEREZHEUjJ3DAoKCnj88ccB2L17N9ddd12SI6rfhRdemOwQpB0Jx0yl7GDlVFkqobT04FppfbeJiIiIyDFQMncMYpO5Xr168dJLLyU5oroqKyP7ei1dujTJkUh7cnbe7BrnVaFUQtXTLLU1gYiIiEhCte2tCf48HT59P7HPPPlc+OqsBrtMnz6dLVu2MHz4cAYNGsSGDRtYv349Tz/9NK+88grFxcXk5eXxgx/8gPLycp599lkyMjJYsGAB3bp1Y8uWLUydOpX8/HyysrJ46qmnOOuss+K+1rx583j44YdJSUkhJyeHJUuWEA6HmT59OosXL6asrIypU6dy++23s3jxYh588EG6du3Kxo0b2bRpE506daKoKFJh8LHHHuPFF1+krKyMa665hocffpji4mJuuOEGdu7cSTgc5sEHH+TGG29M7O9U2o3OlNQ4N/foNMuwCqCIiIiIJFTbTuaSZNasWaxfv541a9awfft2Jk+eHL22fv16Vq9eTWlpKQMHDuTRRx9l9erV3H333TzzzDPcddddTJkyhSeeeIJBgwaxbNky7rzzTt566624rzVjxgxef/11evfuTUFBpFLgnDlzyMnJ4b333qOsrIxx48YxceJEAFatWsX69esZMGBAjecsXLiQvLw8li9fjrtz5ZVXsmTJEvLz8+nVqxfz588HoLCwsDl+ZdIOFO77jByg3FNJt8jIsFEF1SNzSuZEREREEqptJ3ONjKAlw0UXXUR2djbZ2dnk5ORwxRVXAHDuueeybt06ioqKWLp0Kddff330nrKy+v/IHTduHN/61re44YYbuPbaa4FIYrZu3bro9M7CwkLy8vJIT09nzJgxdRK56nsWLlzIiBEjACgqKiIvL4/x48dzzz33cO+99zJ58mTGjx+fsN+FtC8bfncvYwHwaJtjpAZr5qoqypMSl4iIiMiJqm0nc61QRkZG9DgUCkXPQ6EQlZWVVFVV0aVLF9asWdOk5z3xxBMsW7aM+fPnM2rUKFauXIm788tf/pJJkybV6Lt48WI6duwY9znuzn333cftt99e59qqVatYsGABDzzwABMmTODHP/5xU9+uSJSnRf63937OxYw6+Eak0YxQauS/gbCSOREREZGEUgGUY5Cdnc2hQ4eO6d7OnTszYMAA5s2bB0SSrLVr19bbf8uWLZx//vnMmDGD3NxcduzYwaRJk5g9ezYVFZGCEps2baK4uLjB1500aRJz586Nrp/btWsXe/fuZffu3WRlZXHzzTczbdo0Vq1adUzvS9q3LeuWcsGe5wDod0PsiLmRUj0yF9Y0SxEREZFE0sjcMejevTvjxo1jyJAhnH322Ud9//PPP88dd9zBI488QkVFBTfddBPDhg2L23fatGnk5eXh7kyYMIFhw4YxdOhQtm/fzsiRI3F3cnNzeeWVVxp8zYkTJ7JhwwYuuOACADp16sRzzz3H5s2bmTZtGqFQiLS0NGbPnt3gc0Ti2bvivzk9OO7QsXONaympmmYpItIYM8sElgAZRP4+e8ndHzKzAcALQHdgJXCLu+sDVUQAMHdvvFeSjB492lesWFGjbcOGDceUQMnx0e9dGrLiZ19j9ME3AQjfv5eUmScBsKrTF+l2+UP0//0EVo75BaMu+zYAZrbS3UcnLeAEiPf5JCem/tPnN8tzt8+6vFmeK8cumZ9NZmZAR3cvMrM04G3ge8D3gZfd/QUzewJY6+71fvOqzyZpzZrr8xRO7M/Uhj6bNM1SRI7Ljs3vRxM5gJS0DHbZyQBUZOaSkhZZM+eVmmYpIlIfjygKTtOCHwcuBqo3tP0tcHUSwhORVkrJXCsxc+ZMhg8fXuNn5syZyQ5LpFEHdnwUPS71NAB2nHwJAFWdTjpSzTKsWUEiIg0xsxQzWwPsBd4AtgAF7l4ZdNkJ9I5z3xQzW2FmK/Lz81suYBFJOq2ZayXuv/9+7r///mSHIXLUKlY+Gz3OfPjzyIFXAZDWrT9paZmRJu0zJyLSIHcPA8PNrAvw38BZTbzvSeBJiEyzbL4IRaS1aXRkzswyzWy5ma01sw/M7OGg/Xkz+8jM1pvZ3GB+Nxbx72a22czWmdnImGfdamZ5wc+tzfe2RKQleFUVww4tqdN+zt88wjun/QMjLvsOlpJS3bmFoxMRaZvcvQBYBFwAdDGz6i/f+wC7khaYiLQ6TZlmWQZc7O7DgOHApWY2FnieyDdG5wIdgO8E/b8KDAp+pgCzAcysG/AQcD4wBnjIzLom7q2ISEsrKT5EqlXxbp9v8/nfvx9tz87pxgXf/AkpqamEQpFkzqvCyQpTRKTVM7PcYEQOM+sAXAJsIJLUXRd0uxX4Y3IiFJHWqNFplh4pd1lnQa67L6juY2bLiXxbBHAV8Exw37tm1sXMTgG+DLzh7vuDe94ALgV+l6D3IiItrORQAR2BUE5vepzcL26fUCj4zkgjc9LMmrNKmkgLOAX4rZmlEPmy/UV3/5OZfQi8YGaPAKuBOckMUkRalyatmQs+WFYCA4Ffu/uymGtpwC1EyudCZGHujpjbqxfr1tcuIm1UyaEDAKR0yKm3j6UEHzNK5kRE6uXu64ARcdq3EpnRJCJSR5OqWbp72N2HExl9G2NmQ2IuPw4scff/S0RAbaEiU0FBAY8//jgAu3fv5rrrrmvkjuS58MILkx2CnMD2blgKQEpGx3r7aGROREREpHkc1dYEMQtyLwUws4eAXCIbWlbbBfSNOa9erFtfe+3XeNLdR7v76Nzc3KMJr8XEJnO9evXipZdeauSOlldZGalivHTp0iRHIiey0ObXAOg+YGj9faqTOa2ZExEREUmoRqdZmlkuUOHuBTELch81s+8Ak4AJ7jW+cn8V+K6ZvUCk2Emhu+8xs9eBf4opejIRuO94gn90+aNs3L/xeB5Rx1ndzuLeMfc22Gf69Ols2bKF4cOHM2jQIDZs2MD69et5+umneeWVVyguLiYvL48f/OAHlJeX8+yzz5KRkcGCBQvo1q0bW7ZsYerUqeTn55OVlcVTTz3FWWfFrz48b948Hn74YVJSUsjJyWHJkiWEw2GmT5/O4sWLKSsrY+rUqdx+++0sXryYBx98kK5du7Jx40Y2bdpEp06dKCqKLHl87LHHePHFFykrK+Oaa67h4Ycfpri4mBtuuIGdO3cSDod58MEHufHGGxP6O5UTl3kVH4f6cOrAc+vtEy2AopE5ERERkYRqypq5+hbkVgIfA++YGcDL7j4DWABcBmwGSoBvA7j7fjP7CfBe8NwZ1cVQ2ppZs2axfv161qxZw/bt25k8eXL02vr161m9ejWlpaUMHDiQRx99lNWrV3P33XfzzDPPcNdddzFlyhSeeOIJBg0axLJly7jzzjt566234r7WjBkzeP311+nduzcFBQUAzJkzh5ycHN577z3KysoYN24cEydOBGDVqlWsX7+eAQMG1HjOwoULycvLY/ny5bg7V155JUuWLCE/P59evXoxf36kcEBhYWFz/MrkBNWp7DMK03s22CcUrJkz19ZHIiIiIonUlGqW9S3IjXtvUMVyaj3X5gJzjzLGejU2gpYMF110EdnZ2WRnZ5OTk8MVV1wBwLnnnsu6desoKipi6dKlXH/99dF7ysrq30x53LhxfOtb3+KGG27g2muvBSKJ2bp166LTOwsLC8nLyyM9PZ0xY8bUSeSq71m4cCEjRkT+T1lUVEReXh7jx4/nnnvu4d5772Xy5MmMHz8+Yb8LObFVlJdxRuUmlne6rMF+1dMsI3vhioiIiEiiNKmapTRdRkZG9DgUCkXPQ6EQlZWVVFVV0aVLF9asWdOk5z3xxBMsW7aM+fPnM2rUKFauXIm788tf/pJJkybV6Lt48WI6doxfiMLdue+++7j99tvrXFu1ahULFizggQceYMKECfz4xz9u6tuVdqxw/156AFWZDW8XWT3NUgVQRERERBLrqAqgSER2djaHDh06pns7d+7MgAEDmDdvHhBJstauXVtv/y1btnD++eczY8YMcnNz2bFjB5MmTWL27NlUVFQAsGnTJoqLixt83UmTJjF37tzo+rldu3axd+9edu/eTVZWFjfffDPTpk1j1apVx/S+pH1ZMf8pCvMj9YtSTjqzwb6hFCVzIiIiIs1BI3PHoHv37owbN44hQ4Zw9tlnH/X9zz//PHfccQePPPIIFRUV3HTTTQwbNixu32nTppGXl4e7M2HCBIYNG8bQoUPZvn07I0eOxN3Jzc3llVdeafA1J06cyIYNG7jgggsA6NSpE8899xybN29m2rRphEIh0tLSmD179lG/H2lfdm//iNHv/YCy5WlgYOkdGr0n7KZkTkRERCTBzFtxUYLRo0f7ihUrarRt2LDhmBIoOT76vUu1bR++x4AXvxI9X3XBrxg56ZYG76l4qBsr+tzCBX/3bwCY2Up3H92sgTazeJ9Pklz9p89PdghHZfusy5MdgtSizyaR5tWcn9Mn8mdqQ59NmmYpIkel5MBnNc7TMuvfMLyaY1ClkTkRERGRRFIy10rMnDmT4cOH1/iZOXNmssMSqeNw/vYa51ldT270njAhLtjzDGve+K9mikpERESk/dGauVbi/vvv5/777092GCIN2vfZTk5e+6vo+UcZQzhz6IWN3ldJpAjK8L/eAZd8vdniExEREWlP2uTIXGte53ci0u9bqu18+tv08T3R85JeFzTpvkOh7OYKSURERKTdanPJXGZmJvv27VOC0ULcnX379pGZmZnsUKQV6Fa2q8Z5pac06b4yy2qOcERERETatTY3zbJPnz7s3LmT/Pz8ZIfSbmRmZtKnT59khyGtQEUoA2LqmFSkNC1Jc2umgERERETasTaXzKWlpTFgwIBkhyHSPtWqSGnWtCzNkzQJwMxSgBXALnefbGYDgBeA7sBK4BZ3LzezDOAZYBSwD7jR3bcnJWgRERGRJmpz0yxFJDmW/+4RTqvazvKuk3m373cASMns1KR7naQNzX0P2BBz/ijwc3cfCBwAbgvabwMOBO0/D/qJiIiItGpK5kSkScZ89BgA4T5jGP43D/POgO8y4sqpTbp3YHhLc4YWl5n1AS4H/iM4N+Bi4KWgy2+Bq4Pjq4JzgusTrKnDjiIiIiJJomRORBpVWVEePR5+6W1kZnXigltnkpaekcSoGvUL4IccWeXXHShw98rgfCfQOzjuDewACK4XBv1rMLMpZrbCzFZo3a6IiIgkm5I5EWnU2jeeBWAfOXTo2LSplclkZpOBve6+MpHPdfcn3X20u4/Ozc1N5KNFREREjlqbK4AiIi2v/NONABR//dW6w1Wt0zjgSjO7DMgEOgP/BnQxs9Rg9K0PUL3Xwi6gL7DTzFKBHCKFUERERERaLY3MiUijUg7uZC/d6HfG8ON6ThWweu/qxATVAHe/z937uHt/4CbgLXf/BrAIuC7odivwx+D41eCc4Ppbrs0sRUREpJXTyJyINCpUVU65pR/z/TtSU3m1U0f+1CmLnX/+ZgIjO2r3Ai+Y2SPAamBO0D4HeNbMNgP7iSSAIiIiIq2akjkRadRZhX+lkx0+qnsKywp5dcurzN86nw/69gJg9OFS/u5L/8TX+FpzhBmXuy8GFgfHW4ExcfqUAte3WFAiIiIiCaBkTkQa1dRELlwV5p097zB/63xe2/YalV7JoK6DuPNAAVcVFdOrMgyDrm3maEVERETaByVzItKgjzeu4tRG+uwp2sOCbQv43cbf8VnJZ3RK68RVA6/i+jOvZ3C3wdjDXVokVhEREZH2RMmcSDtTWFJBSorRKaNp//nv/+QDTgXe6X8HF8S0V3kVC7YtYN5H81i1dxUAw3KH8f1R3+fLfb9MVlpW4oMXERERkSglcyLtzMhH3iBc5Wz758sws0b7l+35CIAh1/wQgB2HdvDMB8/w5idv8vnhz8lOz2bq8KlcPuBy+nbu26yxi4iIiMgRjSZzZpYJLAEygv4vuftDZjYAeAHoDqwEbnH3cjPLAJ4BRhHZp+lGd98ePOs+4DYgDPyDu7+e+LckIvHsPVjK4o/yCVdFKu7vKjhMn66Nj575od0cpCPrizdy+yu3R9tzO+Ty4NgHuWbgNaSlpDVb3CIiIiISX1NG5sqAi929yMzSgLfN7M/A94Gfu/sLZvYEkSRtdvDvAXcfaGY3AY8CN5rZYCLlvs8BegFvmtkZ7h5uhvclIrXc9tsVvL+rMHr+2cGyGsncvqIy5v51G7eM7c/JOZnR9pcsjykDusMbRxK56WOm842zv9EygYuIiIhIXI1uGu4RRcFpWvDjwMXAS0H7b4Grg+OrgnOC6xMsMpfrKuAFdy9z923AZuKUCBeR5vHRp4dqnJdW1Pwe5YX3dvDrRVsY+89/oaCkHIgkeAs7FUT73DXyLt6/9X0lciIiCWRmfc1skZl9aGYfmNn3gvZ/NLNdZrYm+Lks2bGKSOvSpDVzZpZCZCrlQODXwBagwN0rgy47gd7BcW9gB4C7V5pZIZGpmL2Bd2MeG3uPiDSjZVv3UR6uqtFWVlkzmctKT4ke5x8qo0tWOv/vd6u5ac8ZbMuo4qkfvtykNXYiInLUKoF73H2VmWUDK83sjeDaz939X5IYm4i0Yo2OzAG4e9jdhwN9iIymndVcAZnZFDNbYWYr8vPzm+tlRNqVG598t05bWUXN5K6k/Ehy9/LqXQAs3bKPp0r+lvBJ9yUkkctHWxSIiNTm7nvcfVVwfAjYgL7wFpEmaFIyV83dC4BFwAVAFzOrHtnrA+wKjncBfQGC6zlECqFE2+PcE/saT7r7aHcfnZubezThiUgc1QVPaiurrJnMFZVVRo9nL95S49ovbhyRkFg0rici0jAz6w+MAJYFTd81s3VmNtfMuiYtMBFplZpSzTIXqHD3AjPrAFxCpKjJIuA6IhUtbwX+GNzyanD+TnD9LXd3M3sV+C8z+xmRAiiDgOUJfj8iUsvBwxVx22OnWZZVhvnd8k/ompXGgZJI/90FhwHokpVGTlZiqlW60jkRkXqZWSfgD8Bd7n7QzGYDPyFSq+AnwL8CfxvnvinAFIB+/fq1XMAirUj/6fOb5bnbZ13eLM9NlKaMzJ0CLDKzdcB7wBvu/ifgXuD7ZraZyJq4OUH/OUD3oP37wHQAd/8AeBH4EHgNmKpKliLNr6BWMle9Ni52ZO7jfSUUlFRwRs/saNuFs94C4OtjEveHgZI5EZH4gorhfwCed/eXAdz9s2CpSxXwFPUUjtOsJpH2q9GROXdfR2S4v3b7VuJ8qLh7KXB9Pc+aCcw8+jBF5FgdCCpT/vRrQ7l+dB8OllYy7OGFNdbMVVe2/M7401i2bX+N+z/eX5KwWEJUNd5JRKSdCap+zwE2uPvPYtpPcfc9wek1wPpkxCcirVeTqlmKSNtVGEybHNSzE2YWMzJ3ZGC8NEjsMtNCjOnfjeXbjyR0t4w9NWGxGPHX74mItHPjgFuA981sTdD2I+BvzGw4kWmW24Hb498uIu2VkjmRE9iL7+1g1msbAeiSlQ5AasgIWc1pltWJXWZaCs//3fkMuv/P0Wtj+ndLWDwamRMRqcvd3yZ+jagFLR2LiLQtR1XNUkRanx37S/j7Z1dSUl5Z59oP/7CO/cWRaZZdgyImZkZGakqNZC46MpeaQlpKzY+FUOj417ltufbPlHsqKUrmRERERBJGyZxIG+bujP/pIl774OlzwsIAACAASURBVFPu/v2aOtdPys6IHmdnHqlImZEWYsOeg9ERueo1c5lpzfORcPrQC1nV82uEXMmciIiISKIomRNJEHePOzrWnFZ9UhA9fv2Dz+pc75hxZCZ1SswIW3llFf+X9zn3vfw+EJvMpTRXqGAhTbMUERERSSCtmRNJkHkrdvLDP6zjhSljObV7FqfkdGj21/ybp95t8HqVxy84Up3WvbxqF/90zbn8z7pIsbSMZhqZA/BQiqZZioiISJvS2vevUzInkiCvf/ApADc9GUmwWmKTybNOzmbdzsJ6r9eXzKWlhqA8Mhp31oOvRdubd2QuBVMyJyIiIpIwmmYpchwKSypYGCRxJ+dktvjrjz614UqTleH4yVxqPUVNMlObd5qlRuZEREREEkfJnMhxuOv3q5ny7Ep2FxzmUOmR9XLVe7k1p6VbPuc/l26LVqkcdFKnOn2q18J9bWSfGu0hi5/MpaUcf+XKeoVSSDHHq5TQiYiIiCSCkjmR4/DxvhIAXlyxg1fX7o62N+t0xcDXn1qGO3TrmM7koacQjjOl8nBFmClfPI1/vWFYjfb6RuasniQvISzyO6lSMiciIiKSEErmRI5DdofIqNgv3syLtl0xrFezV7X8YPeRdXI/uXoIaSmhOlMqq6qc0ooqOsRJLFPijMDN/dboxAcaKxT5uAmHW7bip4iIiMiJSsmcyHFIj5MUndajI6UVVVRVxV+vlgiX//vbANz+pdO48PQepISMcK3Xe/T1jQB0iDPlMzVU9z/9vl2zmiHSGNUjc0rmRERERBJCyZzIcdhdUFrj/Oax/eiYEUlaVnx8oNlfv3OwEXhairGr4DAeTLUsr6ziN/+7FYBzenWuc1+82ZRpKUc+Dk7r0RGA5fdPSFisFor8XooK9iXsmSIiIiLtmZI5kWMUrnI+PVhKz84ZAPTp2oFHrj6Xy4f2AmDB+3ua5XXLKsPR4yG9cwDI+6wIgOueeAeATZ8divYZPyi3zjP2Hiyr05aVcWQEb8H3xrP2oYmclJ3ACp3Fn0de++lvJO6ZIiIiIu2Ykjk5YSz+aC/DZyykuKxlpvHtKyojXOUMPiUy8pWbHUnqenfpwEnZGdFKkom268BhADpnpnLh6d0BKAre88qPD/D+zkI2fhpJ5mZ/Y2TcZ8Tbfy4r/ci2k5lpKeQE6wETxcKRBLJ3+daEPldERESkvVIyJyeMX761mYKSCtbvqn8T7UTaESRVXxnck2tG9ObxmMQp3hq2RHlr414A/vPb50WnRv7w0jOj1/+0bjcFJeUAXDiwR9xnxNuaIKuZK3C6RWINuapZioiIiCRCauNdRNqGkztHpgR+erC0kZ7HZ8f+En67dDv/uykfgCqHn984vEafkFncrQISofBwBQDD+nSJtg3v2zV6/JslW5k2KZLcZabF/74m3pq5UD3bFSRMUABFG4eLiIiIJIaSOTlh9KxO5gqbN5l74b1P+I+3t0XPh/XJqdMnJWTNUs2y//T5QGRvudSYgiW1k7bD5WFCBukp8ZO5+jYNb1bVI3NK5kREREQSQsmcnDCyghL8zbVmrjJcxT//eSMrtu+Ptv3DhEEMjRkhq5YSMsLNtzMBXbNqrmfLTK05RbK0IkxmWkq9m4DXbu7RKT2h8cXjQTXLEM34ixERERFpR7RmTk4Yf1q3G4CycPOM/Czftp85b29j7c4ja/Kqp3bWFjKadZ+5bh1rJl+1p0iWVkaSufrc/ZUzosdm8NLfX5jYAOOx6mROI3MiIiIiiaCROTlhbN9XAkT2WGsOGXGSo9htAmI1RwGUfUVHthPoktXwSFpJeZjM1Pq/q7n1wv7cMLov/7LwI+6+5Aw6ZbTAR0EwMpdqSuZEREREEkHJnJwQYhOn5ppm6XEKmnSoZ/QrZBa3/P/x+OVbm6PH1ZuF1+fg4YoGR+YAOqSn8ODkwQmJrUlMEwFEREREEkl/XckJ4fOYUasXV+xsltcorag7opRSTwXI5kjmPth9ZHpnx4yGE7U3N+wlvYGRuaRQMiciIiKSUI3+dWVmfc1skZl9aGYfmNn3gvbhZvauma0xsxVmNiZoNzP7dzPbbGbrzGxkzLNuNbO84OfW5ntb0t7sKjjcrM8vqwxz85xlddrPDjYMr632NMt5K3bwSTAN9FiVlB+Z0rnoo72N9m9tyZxZ8+5jJyIiItLeNGWaZSVwj7uvMrNsYKWZvQH8FHjY3f9sZpcF518GvgoMCn7OB2YD55tZN+AhYDTgwXNedfcDiX5T0v7sDpK58/p3ZUt+ccKfn/dZUY3zObeOZmifLuRmZ8TtHwoZiz7K5/HFm7njS6cz7aV1dEhLYcNPLj2m16+qcj7YfTB6vrsg/vYLIYskkhVhJ7W59407StXVLEVEREQkMRr96t7d97j7quD4ELAB6E0kIaselsgBdgfHVwHPeMS7QBczOwWYBLzh7vuDBO4N4Nj+shWp5XfLPwEie80luvAIwPz399Q4P29At3oTOYCUII/66WsfReM5XBG/WEpjfr1oMxf96+IabZeec3KdfmsfmsjahybSt1sWAGn17DGXLPVtkyAiIiIix+aoCqCYWX9gBLAMuAt43cz+hUhSWF3bvDewI+a2nUFbfe21X2MKMAWgX79+RxOetGN/3bwPiJTsb45kbvbiLQBceHp3RvbrSnYj1R9j19KFj2Pt3OdFZTz2+kd12uMVLsnpECmK0jM7k635xa0umauzuZ2IiIiIHJcm/7VnZp2APwB3uftB4A7gbnfvC9wNzElEQO7+pLuPdvfRubm5iXiknODcndNzOwKQmZZSJ5k7UFxOQUn5UT1zx/4SioKqmP+Xlx9t/6+/G8sPJp3Z6ChTKOZ67Xj+suEzvv2fy+NWx6ztqSVba5z/6/XDeP4753NyTvz97QD2HopMwUxNaWXJkwqgiIiIiCRUk/66MrM0Ionc8+7+ctB8K1B9PA8YExzvAvrG3N4naKuvXeS4LN6UH10nF7KahUcOl4e5Ze4yhs94g9ImTnOsCFcx/qeLGPLQ6wBs+/z41uBV1krmbvvtChZ9lF+nPZ7f1ErmTumSybiBPRq8p/p30cpSOVpjRCIiIiJtWVOqWRqRUbcN7v6zmEu7gS8FxxcDecHxq8A3g6qWY4FCd98DvA5MNLOuZtYVmBi0iRyX3TGVLFNDFp3W+O7WfZz949dYvytSOOTjJlaTnBeztUFxWSUHD1ccdUyxg27hcPykrbGtC/I+O1SnrbH95QDO7Z3TaJ+k0DRLERERkYRqypq5ccAtwPtmtiZo+xHwd8C/mVkqUEqwzg1YAFwGbAZKgG8DuPt+M/sJ8F7Qb4a770/Iu5B2LSVIEr49rn90SwB353835dfoV9TEzcR/9N/vR49f/+BTisoiI3rXjqyzxLNesevk6huBa2yW5atrd9dpq14X15CrR/Tm/V2FJH7l4PFSMiciIiKSSE2pZvm2u5u7D3X34cHPgqB9lLsPc/fz3X1l0N/dfaq7n+7u57r7iphnzXX3gcHPfzbnG5P2ozjYf+2ur5wRLTwSrnKKSmsmb8VNTOZiff/FtRwqjYzMPfq1oU2+b+XHR3bcKA/X3Wy8OsaGHC4P0yEtha3/dFm0rSkjc+nBWrkE71l+/FpwZM7MMs1suZmtDfbHfDhoH2Bmy4J9MH9vZulBe0Zwvjm43r/FghURERE5RqpIIG3e4fJIkpaVnhJN5iqrvE7y1tRk7qyTs7lkcM/o+d5DZZx1cvYxV4fcuOdg3PbGplmWh6vISAsRiqmM2Smz8cH0VlfFMmAtWwClDLjY3YcBw4FLg2nfjwI/d/eBwAHgtqD/bcCBoP3nQT8RkRZhZn3NbJGZfRh8AfW9oL2bmb1hZnnBv12THauItC6t868+kaPwP2sje8ClpYRIDxKZyirnUK3k7b+Cvegac7giTFb6kQ2ui8sqyW5CElWf2M2+q2JG4xqrf/LMOx9TUFJzvV5KEzYCr07mWtvAXEuOzAUzBKp3ek8LfpzI+t6XgvbfAlcHx1cF5wTXJ5g2xhORllMJ3OPug4GxwFQzGwxMB/7i7oOAvwTnIiJRSuakTasIV/FRTKGQtGCKYUVlVZ2RuP/L+7zR57k7BSUVdIzZR+5wRZjMtJQG7mrYnsLS6HFx+ZGYqpphPzyAAcE2Det3FTbL84+VpXds2dczSwnW+e4F3gC2AAXuXv1/hNi9LqP7YAbXC4HucZ45xcxWmNmK/Pz82pdFRI6Ju+9x91XB8SFgA5HPpdgvmmK/gBIRAZTMSRu3Klib9r0JgwBIDUalKsJVddak9eiU3ujztuQXU3i4gqG9c5g26UwACkoqjiuZ+13MiOD8dXuixw1Ns1y2dV+N80EndWry6w3v04WzT+nMQ1fU3Vg8mUZOvh2A5V0nt8jruXvY3YcT2QZlDHBWAp6pfTBFpFkFa3ZHAMuAnkFFcIBPgZ713CYi7dSxzx0TaQUKg20Dqte4VU+z/OuWz1m2rWax1E4Z9f/P/ZN9JVz3xFL2HioDYHT/bizbFkmo9hQeTli5/+kvH6mUGW4gmbvxyXcBuGF0HwAWfG98o2vsqoVCxp+/N/44omweqWnpHKQjnlr/hufNwd0LzGwRcAHQxcxSg9G32L0uq/fB3BlU6M0B9sV9oIhIMzGzTkT29b3L3Q/GzvZ2dzezuP+PwMymEFQV79evX0uEKiKthEbmpE2r3m6gOlFLS438P767f7+2Tt/CevaL+3hfMV98bFE0kQM4OSczug1AaUVVsyz3akpu1iEYEUxLCZGReuyjg61FS63jM7NcM+sSHHcALiEybWkRcF3Q7Vbgj8Hxq8E5wfW33FtdPVAROYGZWRqRRO55d385aP7MzE4Jrp9CZNp4HZo1INJ+KZmTNi2azAUFSuqr5JgaMg6UVBDv7/Pl2+pud5ieEqqRbK365ECdPg1Z9IMvM+/vL2gwCaxva4LDwVYLAJnpbT+Bq6NlcqRTgEVmto7I3pZvuPufgHuB75vZZiJr4uYE/ecA3YP276MiAyLSgoKCS3OADe7+s5hLsV80xX4BJSICaJqltHGHSmuNzNWTzHXKTKWgpIJFH+3l4rNqLjmIt5l4WorRo1NG9Dz2uCkG9OjIgB4dSTGj0p3uHdPZV1xeo0990yY/2V8SPe5wHGv1WqMsLyW1tPlnL7r7OiJrTmq3byWyfq52eylwfbMHJiIS3zjgFuD9oHATwI+AWcCLZnYb8DFwQ5LiE5FWSiNz0qYVlVWSlmJkpEb+p1xdzbK273xhAAC7DhwGYOXH+7n+iaWUlFdSVll3U28zY+xp3aLnD1x+9jHFVxmMvp3bp+6au6r4e4mzfV9x9LihdX5tUZqFGVW0ONlhiIi0Ku7+trubuw919+HBzwJ33+fuE9x9kLt/xd3rTiURkXZNyZy0acVllXTMSKV6kXh9I3NXDOsFQEYw0vXDl9bx3vYDfLyvhNKKyLTG/5325Rr3xC48H3VqN45HvKSsvgIoG2I2Gf/ayD7H9boiIiIicuJSMidt2qHSSjqmH0mU6kvm0oORu+q93ao33y6rrKKssor0lBB9u2bFvffmscdfGaxPnGfnxeyPF+vg4UqyM1LZ9s+X0bVj49spiIiIiEj7pGRO2qRZf97IrXOX89+rd3FyzpFS97HJXOyoVkowylY97TEUnJeUV1JaESYjNUQoVHeK5vZZl/PI1eced7wZqSFmXVvzObsLDsftWx4Ok54aqjEyKCIiIiJS24m1IEfajSf+d0v0eO+h0uhx7Jq59NQjx9UjcdVFR1KDfofLw5RVVkWnXz55yyi6H2Wxk6ZITw1FRwerhesp6lheWVWnr4iIiIhIbUrmpM2pCNesHDKgR6focezIXOxxdTJXGWRQ1SN1xeVhCkrKSQ2uTzzn5GaJOT0lFI2hWrieCijllVX1ThcVEREREammZE7anANBif9xA7vz1837uHZE7+i1GiNzKSH+6zvnk5OVVmdk7lCwHcE//G51i8Scnhqqk6DVyknZsb+EKc+uJDsjVSNzIiIiItIoJXPS5ry1cS8AVwztxa+/PpIuWUeKhMSuM0tLDXHhwB5AZG0cRNbM/eLNTWzNLybWxWed1KwxpzVhZO7Zdz+OVrI8uXMmIiIiIiINUTInbc70l98HYOeBwzUSOThS2AQgK2bD7epEatafN8Z95i1jT010mDVERuZqJ3M1+2THbF/w6cFSREREREQaorlc0qZ8XlQWPa490gUQ2xJb1j+lkcqQGc08rTFkkBKq+Ro/f3MT+YeOvJ/OHdKaNQYRERERObEomZM24/OiMkY/8iYAXbLS+PsvnV6nT4/sI5Uou8Umc3ESv1hpzZTM3faFAQB8drCMTZ/W3VfuP/5va/Q4NUVbEYiIiIhI0ymZkzbj4OGK6PF9Xz2LDukpdfp0ipmq2LWetXTxVG8mnmhjT+sOQM/OGZzTu3Od67EJXHll/OqWIiIiIiLxaM2ctBllMclO58zGpyTGjszFM6JfF1Z/UgBASUX4+IKrxyWDe/Kn//cFzunVOW5CGZtwxr6/Bf8wvlniEREREZETh0bmpM1Y+fGB6PGA3I6N9m8smZt763l8J5gGOaB74887VkN650QTuUe/di5Pf/s87rnkDIAaWxCUVUSSud/cMorBveqO4omIiIiIxGo0mTOzvma2yMw+NLMPzOx7Mdf+n5ltDNp/GtN+n5ltNrOPzGxSTPulQdtmM5ue+LcjJ7JwMBXyP745mrNObjzZ6ZLV8Ohd147pPDB5MBtmXEr/Hs2XzMW68bx+fPnMk7jlgkj1zOpNzAHKKsOkpRiTmmnjchERERE5sTRlmmUlcI+7rzKzbGClmb0B9ASuAoa5e5mZnQRgZoOBm4BzgF7Am2Z2RvCsXwOXADuB98zsVXf/MLFvSU5U1Rt+jzq1a5P6196kuz7x1t41t9QgtnDMWr3SiioyUls+FhERERFpmxpN5tx9D7AnOD5kZhuA3sDfAbPcvSy4tje45SrghaB9m5ltBsYE1za7+1YAM3sh6KtkTpqkek1ZZlrbT3hSg+qaFTEbhxeXVZKVhMRSRERERNqmo1ozZ2b9gRHAMuAMYLyZLTOz/zWz84JuvYEdMbftDNrqaxdp1OHycHTD7/QEbCMw9rRux/2M41GdzIWDaZbuTsHh8hrVOEVEREREGtLkvxzNrBPwB+Audz9oZqlAN2AscB7wopmddrwBmdkUYApAv379jvdx0sZVhqv41n++R7/uWQB0zUprdM+4pvjNzaOP+xnHIyVkhOzIaOP/5X3O6x98ltSYRERERKRtaVIyZ2ZpRBK559395aB5J/Cyuzuw3MyqgB7ALqBvzO19gjYaaI9y9yeBJwFGjx7dPJt/SZsx688beXvz57A5cv7HqV9IyHMz05NbyNXM6JieSkl5ZEuEd7buS2o8IiIiItL2NKWapQFzgA3u/rOYS68AFwV9zgDSgc+BV4GbzCzDzAYAg4DlwHvAIDMbYGbpRIqkvJrINyMnlr9u/pz/eHtbjbbszGOfhvjwledEj9ObWBylOWVlpFBSXgk0vViLiIiIiEi1pvxlPA64BXjfzNYEbT8C5gJzzWw9UA7cGozSfWBmLxIpbFIJTHX3MICZfRd4HUgB5rr7Bwl9N3LCWLIpn2/OXV6nvbHtBgDuvfQsNu8tqtN+64X9Gdonh0Ub98bdwLuldUxPpagsksyVBP/+fsrYZIYkIiIiIm1IU6pZvg3U95fvzfXcMxOYGad9AbDgaAKU9ik2kZt60en8etEWRp/atUlJ2B1fPr3eayP6dWVEv6ZtbdDcIiNzkWmWxeWV5GZncP5p3ZMclYiIiIi0FZrbJa3epeecAsDpuZ2SHEliZaWnUhyMyBWXhemobQlERERE5CioDrq0Os8v+7jG+bl9cpj9jZF86czcJEXUPDplpJJ/qAyAkvJKstL1n6OIiIiINJ3+epRW5R9f/YCnl24H4PYvnsblQyOjcl8995QkRtU8OqSnUHC4HIiMzGmPORERERE5GvrrUVqV6kTupOwM7rvs7OQG09wcduw/TGW4ivyiMk7P7ZjsiERERESkDdGaOWlVhvftAsArU8clOZLml5udAUBJRZhP9pXQv4eSORERERFpOiVz0mpUVTkf7yvm+lF96NWlQ7LDaXb9umUB8Mm+EsrDVQzormRORERERJpOyZy0Gls/L+JASQXn9e+W7FBaRFpKZJuFAyWRdXNdstKTGY6IiIiItDFK5qTVWPnxAQBG9W8d+8A1t9SUyH9+5ZVVAISSv4+5iIiIiLQhSuakVaiqcrbmF5OWYu1mumFqkL0VlFQAkKJsTkSk3TKzuWa218zWx7T9o5ntMrM1wc9lyYxRRFofVbOUVuEb/7GMd7buo2+3DoTaSVKTFozM3TNvLQClFVXJDEdERJLraeBXwDO12n/u7v/S8uGISFugkTlJuldW7+KdrfsAqGpH+UxqSs2ktbI9vXkREanB3ZcA+5Mdh4i0LUrmJOnu+v2a6PGYAe2j+AlAaqjmf37uSQpERERas++a2bpgGmb7WFQuIk2mZE6SrlvHdLp1TGfxD77MT64ekuxwWkxarZE5R9mciIjUMBs4HRgO7AH+NV4nM5tiZivMbEV+fn5LxiciSaZkTlqEe2QPuf/86zZ+8eamGtfKK6u4angv+vfoSKeM9rOMs7qapYiISDzu/pm7h929CngKGFNPvyfdfbS7j87NzW3ZIEUkqdrPX86SNOEq58pfvc0Huw9G2+788kC2fV7MpF8sAeCk7MxkhZc0abUKvWiapYiIxDKzU9x9T3B6DbC+of4i0v5oaECa3YY9B2skcgBfePQtlm3bFz0/KTujpcNKutojc+0hmXu3598kOwQRkVbJzH4HvAOcaWY7zew24Kdm9r6ZrQMuAu5OapAi0upoZE6a3fpdhQB8YWAPTu2exfPLPmHvoTL2FJZG+9Su7Nge1H7P7SCXA9P3RyIi8bh7vG+75rR4ICLSpugvK0k4d+ftvM+pqoqkJ3P/ug2AR68byiWDe0b7bfr0UPT4i4Pa3xz/tDrVLNtFOiciIiIiCaJkThJuwfufcvOcZfzX8k8A+LSwlIvOzKV3lw6kx0wt/MvGvQC8ftcX6doxPSmxJlO7HJkTERERkYRRMicJ4+6UVYZ5de0uAP6y4TMKD1dwqKySc3vnAJBSq+jHyZ0zOfPk7BaPtTWovTXBBad1T1IkIiIiItIWKZmThHlu2Sec+cBrvP7BZwAs+iifkT95A3fokhUZeQtX1Rx/+sb5/Vo8ztYidtPwZT+aQN9uWUmM5sRiZn3NbJGZfWhmH5jZ94L2bmb2hpnlBf92DdrNzP7dzDYHm/OOTO47EBEREWmckjlJmHe37KvTVp28dQumUZ5/Wvca6+a+e/HAlgmuFYqdZll7xPJE5dZi77MSuMfdBwNjgalmNhiYDvzF3QcBfwnOAb4KDAp+phDZqFdERESkVVMyJwnTIT0lehybsAFkpkWupYSM700YBEDvLh2wlvvjvtVJi1k/WLsYihwfd9/j7quC40PABqA3cBXw26Dbb4Grg+OrgGc84l2gi5md0sJhi4iIiByVRv+CrG+6Usz1e8zMzaxHcF7vdCUzuzWY3pRnZrcm/u1IsuwvLuePa3ZxZs9sts+6nL//0mk1rl901pFqlef06sw/XjGYl++8sKXDbFVSY0bj2s/WDC2ftJpZf2AEsAzoGbMB76dA9bcOvYEdMbftDNpEREREWq2m/GVV33QlzKwvMBH4JKZ/3OlKZtYNeAg4HxgDPFS9XkXavn97cxMVYWfvocjecSP7deWm8/pGr2ekHhm1MzO+NW4APTtntnicrUl66pH//NrLNMuWZmadgD8Ad7l7jZ3rPbIXxFEVETWzKWa2wsxW5OfnJzBSERERkaPXaDLXwHQlgJ8DP6TmH0T1TVeaBLzh7vvd/QDwBnBp4t6KJMuO/SVs31cCwAOXDwYiCdusrw0F4OvtuMhJQ6qnnkLNKZcntBbMWc0sjUgi97y7vxw0f1Y9fTL4d2/QvgvoG3N7n6CtBnd/0t1Hu/vo3Nz2tzeiiIiItC6pR9M5drqSmV0F7HL3tbXWPdU3XUnTmNqYnQdKOCk7s8YIUqw9hYe54J/fip6PH9SDr43qU6PP9lmXN2uMbVlsAqeRucSyyIfSHGCDu/8s5tKrwK3ArODfP8a0f9fMXiAye6AwZjqmiIiISKvU5OGA2OlKRKZe/gj4caID0jSm1uFweZgvPLqI+15+P+51d+eJxVtqtA0+pXNLhCZtWoslreOAW4CLzWxN8HMZkSTuEjPLA74SnAMsALYCm4GngDtbKlARERGRY9Wkkbna05XM7FxgAFA9KtcHWGVmY6h/utIu4Mu12hfXfi13fxJ4EmD06NFHtZ5FEqesMgzAH1btZHCvzlw/ug+dM9Oi16c8u5I3Pvysxj1nK5mTVsLd36b+zHFCnP4OTG3WoEREREQSrCnVLOtMV3L39939JHfv7+79iUyZHOnunxKZrvTNoKrlWI5MV3odmGhmXYPCJxODNmmFyiurosc/+dOH3P3CmhrX39wQSeQmDz1SvV3JnDTmjKt+yLrM0ckOQ0REROSE0JRplvVNV6pP3OlK7r4f+AnwXvAzI2iTVqgsJpkD+MvGvUQGLyKG9unC2NO68auvR3eeoGfnjBaLT9qm7j37MHT6X5IdhoiIiMgJodFplo1MV6ru0z/muN7pSu4+F5h7dCFKMlz167/Wabt5zjIeuuIczuiZzb6iMsb071bjeseMo6qnIyIiIiIix6Gd1EOXo7Fhz0H2F5fXaf/r5n1M/PkSKsNV7Csqp3un9BrX2015fRERERGRVkBDKVLHio8PAHDPJWfQr3sWuwoO89PXPopeH3j/nwEIV8W9XUREREREWoCSOanjwVfWA/DdiwdiZsx9e1vcfu9tjyx5fPvewj7nigAAIABJREFUizhUWtli8YmIiIiIiJI5qSW2yEn1ZvCfHSyNtv148mBm/OlDAP7xysEA9Oma1YIRnliW3z+BkrJwssMQ+f/t3XmYVNW57/Hv23MzzzMKKqI4gNwODpiIQQWHiMdz46PmKmoSbowmMYMnmsSYxAwaj+bRxCQHFYdchwyOiZ4gMeJwjAoSBBGBFjQyt6LN1DR093v/2Lurq4fq7iq6qnZ1/T7PU0/vWnuod+2q3l1vr7XXEhERkRykZE6a2R62sH3vzMNjZVedciivrNvGyH5l9C5r+sgcPLhXxuPrbob0LoPe2Y5CRERERHKRkjlppnHgkwE9mwY3KS8p5IkrpgJw14trATh4cE/69ShpfQAREREREckIDT8ozby/bTcAw/qUtbn+7EkjmDS6H/ddNiWTYYmIiIiISAtqmZNmlq3/GIAjR/Vtc/2Q3mU8HrbSiYiIiIhI9qhlTppZW7WLkf3K6VNWnO1QRERERESkHUrmpJkPd7WeDFxERERERKJH3SwFgN/9412Wb6jm+dVVTBs/ONvhiIiIiIhIB5TMCQDXPbEitlxapAZbEREREZGo07d2aeXqGeOzHYKIiIiIiHRAyVweq6tv4MU1Veyrb6DAmsoPGaJZrEVEREREok7dLPPMug928eKaKiYf0J+nl2/i1wvfabb+1vMmZikyERERERFJhpK5PHPqrc9T1+Btrjv+oIGcO3lUhiMSEREREZFUqJtlHnH3hIkcwOwTxmQuGBEREYkxs3lmttXM3owrG2BmC8xsTfizfzZjFJHoUTKXRzZ8XNOqbMqYAbx9w0xe/94pzDxyWBaiEhEREeBeYGaLsmuAZ919HPBs+FxEJEbJXB6prtkXW75s6lgARg0op6y4kIG9SrMVloiISN5z9xeAbS2KZwH3hcv3AedkNCgRiTwlc3lk6/ZaAP70pePp36MYgN6lum1SREQkooa6+6ZweTMwtK2NzGyOmS02s8VVVVWZi05Esk7JXB6p2hkkc0P7lDH5wKDb/WlHqGuliIhI1Lm7A23e+O7uc929wt0rBg8enOHIRCSb1CyTR2rrGgAoKy5k6iGDeOP7p9E3bKETERGRyNliZsPdfZOZDQe2ZjsgEYkWtczlkdp99QCUFAVvuxI5ERGRSHsSmB0uzwaeyGIsIhJBHSZzZjbazJ4zs7fMbIWZfS0sv9nM3jazZWb2mJn1i9vnWjOrNLNVZjYjrnxmWFZpZhqRKYPe+3AX28MBUEqLlMOLiIhEiZk9BPwDGG9m683s88CNwKlmtgY4JXwuIhLTmW6WdcA33X2JmfUGXjezBcAC4Fp3rzOzm4BrgW+b2QTgfOAIYATwNzM7NDzWHcCpwHpgkZk96e5vdXGdpIU9++o56eaFAJhBSaGSORERkShx9wsSrJqe0UBEJKd0+K3e3Te5+5JweQewEhjp7s+4e1242SvAqHB5FvCwu9e6+zqgEpgSPirdfa277wUeDreVNFu9ZUdseXifMgoKLIvRiIiIiIhIV0iqicbMxgDHAK+2WHUZ8N/h8kjg/bh168OyROWSZm9t3B5bLispzGIkIiIiIiLSVTqdzJlZL+AR4Cp33x5X/l2CrpgPdEVAmiulfc+9vZX5KzYTjFDcOUvf/zi2PEiTg4uIiIiIdAudmprAzIoJErkH3P3RuPJLgLOA6d6UXWwARsftPioso53yGHefC8wFqKio6HzGkgd+sWA1tz27JvZ8+mFDKCo0/uuiioT77Kqt4+FFQYPo2RNH8NXph6Q9ThERERERSb8OkzkzM+BuYKW73xpXPhP4D+Akd98dt8uTwINmdivBACjjgNcAA8aZ2ViCJO584MKuqkh39uHOWuobvFkiB/Ds28F0M6u37GDDRzWcfNiQVvs++cbG2PLtFxyT3kBFRERERCRjOtMyNxW4CFhuZkvDsu8AtwOlwIIg3+MVd/+Su68wsz8AbxF0v7zC3esBzOxKYD5QCMxz9xVdWptuaFN1Dcf/7O/tbnPaL14A4J5LP8HJ45sndO9vC/LsXyqRExERERHpVjpM5tz9JYJWtZaebmefnwA/aaP86fb2k9ZaJnI/mnUEQ/uU8X9/93qrbS+9ZxF3XlzBtPGDKS4soKHB+fXCdwA48ZBBGYlXREREREQyQxOORdj2PftalU0+oD8zjhjG81dP4ztnHNZq/RfvX8zvw3vkdu2ti5X3LuvU7ZEiIiIiIpIjlMxF2HsfBF0kr54xni9+ciwA44f1BuDAgT2xNhtMoa6+gaeXb6K6JkgGb/r3oyjSROEiIiIiIt2Kmmsi7N0PdwFw9Ki+TD14EF8/9VCK45KyHbV1be73gz+/BcC3ZwYtd33KitMcqYiIiIiIZJqSuQjbsSdI1sYN6U1BgdGjpPnbtb2meTfMn517FNc+ujz2vHLrTgD6lCuZExEREZHOGXPNU9kOQTopp/ve7dlXz84ErVPdwebqGgD6lLedc1fHJXM3zDqCsyeOaLZ+xcbqYH+1zImIiIiIdDs5m8zt2LOPw677K0deP79Zec3e+tjyXS+u5eb5b2c6tC7z91VbqTiwf6sWuUY74gZIuej4MfQsbb7d25t3AImTQRERERERyV05l8ztrWsA4PGlTZNhX/ngEgC+9vA/Ofz7f+XVtR9StaOWHz+1kjueewd3z0qsyXqnaicf794be75t517GDOqZcPvrzpoAwMTR/WJlT1wxlfLiQgb2LImVqWVORERERKT7yakmmxdWV3HxvNdalf9l2Sa+cepOnggTvBUbt9OvR1MyU12zr9nzKGpocKbf8jwHDerJLy88hoE9S9lb780GPGnpwIE9qfzJ6c3KJo7ux8obZvL86ipmh+dK0xKIiIiIiHQ/kW6Z+3DnXtZWBYN4VNfs49cLKxNu++lbno8tFxZY7H4xgDn3v0717tZztiWy/qPdfO6uV9i2a2/HG3eRyrCeaz/YxZm3v8SJN/2dvXX1lBa1/xYVFRa0Oe1Av7hBTzQtgYiIiIhI9xPpJpuN1TV8+pbnWf3j05n4w2c6vd+m6j28U9U0MMpr725j4o+C/e+8uIJTJwxtd/+7XlzH/1R+yMOL/sWXpx3C8vXVPLdqK1+dPi61isRZsbGahauquOLkQ2Jl9Q3Oab94AYDSogJq6xqoa3C276mjuLDtueQ60lcjWEoeM7N5wFnAVnc/MiwbAPweGAO8C5zn7h+ZmQG3AWcAu4FL3H1JNuKW/JLO0eLevfHMtB1bRESiIyeabF6qrEq47pcXHEPvFgN/VG7dkbB74hfvX9zh6/UsLQRgXVUwz9tnfvUSty5Y3SX33p15+0vcPH8VTy3bFCu77+V3Y8sj+pU32/7FNR+k9Dr9eiiZk7x2LzCzRdk1wLPuPg54NnwOcDowLnzMAX6ToRhFRERE9ktOJHO1+xraLJ9/1af4zMQRHDmyb7Py7TV1bN6+J6VWrX31Ddzx3DtA0ML306dXxtb9OS4B219XPNj0j/87ngu6j/YuK2LL9j3NtptxxLCUjt9bg55IHnP3F4BtLYpnAfeFy/cB58SV3++BV4B+ZjY8M5GKiIiIpC4nkrnLH2i7x9P4Yb2b/QQoKjCqa/axYMUWDhyYeCTIRDZXNyVTL1V+wNwX1saeX/PIsqSPF+9fH+5u9vw7jy3nd6+8R1lx0BJ47emHsztuagWAWZOazx3XWYUFqXXPFOnGhrp7439kNgON/a1HAu/Hbbc+LBMRERGJtEgnc8P7lrUq+/m/H92q7JgDmobmP+XwoazasoO99Q3s3JP8hOJrtu5IuK4x0br1mVXc9Nfk56+75+V1AIwNpxt48NV/cd3jb1JcaJw9cQTjh/Vqtv03Tj2Ugwb3anWczrrvsik8fsXUlPcX6a486DOddL9pM5tjZovNbHFVVeLu3yIiIiKZEOkBUAxr9m1ryXWnMqBnCSeNH9ys6+XpRw5n17/Vc84xI7j0nkWx8sZ73wDOnTyShgbnqeXtd5W87N7gnroDB/bgvbAl7fDhfVi5aTvQ/Ib1b888rFP1qK2rZ/otz9N4y915FaObJYM1++opLy5k3NDezfZrb1qCzjjp0MH7tb9IN7PFzIa7+6awG+XWsHwDMDpuu1FhWSvuPheYC1BRUZEbE1iKiIhItxXpljmL6yl458UVDAgnwh7ap4wDBvaIrSspKuDCYw+gR0lRs+RvYM9SGnsb3nreJA4c2JN99d6pgUxOOHhgbHlEGy2EyVhbtYv1H9Ww4eMaAHbVNm8x3LK9lvKSQvqUFXNgi3qJSJd5EpgdLs8Gnogrv9gCxwHVcd0xRURERCIr0tlCQ1zSNap/eTtbNqmta2qxKy0u4LXvnsLCb00DmpKjffWJk7nG17nouDGxsrKSwgRbd85tf1vT7PnnTxzbapvy8DWev/rkWPJYkuK0BCL5zsweAv4BjDez9Wb2eeBG4FQzWwOcEj4HeBpYC1QCdwJfzkLIIiIiIkmLdDfLHiVF7AY+OW4Qhw3r3eH2AP8xYzyfu+tVAMyMQb1KGdSrFCA2uuW++oZ2W73OnTySvnFD+5cVpZ7MvfzOB6zcvL1ZWf+whTFecdyAJXUNQbKpljmR1Lj7BQlWTW9jWweuSG9EIiIiIl0v0tlCj5JC3rj+NH73+WMx61wr1dRDBnHnxRUADGgx11pRQWPLXNtTHUDQsldaVEBZXCJ16oQhrbYrMDrVXfPCO1+N3XsX7+oZ45u/blxMjS2SSuZERERERCSRyGcLfcuTny/tU4cOYs6nDuIHZx/RrLw4TI72tpPM7a1roLSokNLipta4mUcO57qzJjTbrsFhZ237o2XWtJhmIN4VJx/CS98+Ofb88pMOji03tszt7wAoIiIiIiLSfUW6m2WqSosK+c4Zh7cqL4l1s2y7Re2JpRuortlHbV09pS1axQ4f3rqb55btte1Ozr1t997Y8tA+pXzhxIM4aXzTCJOj+vfggS8cy1sbt9OvR1PXy8YGvxIlcyIiIiIikkC3TOYSaWzpqkvQMnfz/FUALHnvY4paTLrdVivZ5uo9HDIk8TxwH+0KkrlLThjD5dMOZmif1qNiTj1kEFMPGdSsrKy4gOoadbMUEREREZHE8ipbaEzIEt0zt/6jYOqAnbV1sXv0hvQubbZvvE3VNe2+3md/+w8AzjhqeJuJXCI9SoIcWy1zIiIiIiKSSIfZgpmNNrPnzOwtM1thZl8LyweY2QIzWxP+7B+Wm5ndbmaVZrbMzCbHHWt2uP0aM5ud6DXTpTEh21vXupvlLc+sii1fOnUMAI99+QSe+uonW207JpwL7uo/LWv39Wr2BffM9UhyaoPy8H49tcyJiIiImb1rZsvNbKmZLc52PCISHZ3JFuqAb7r7BOA44AozmwBcAzzr7uOAZ8PnAKcD48LHHOA3ECR/wPXAscAU4PrGBDBTSoqapiZo6feL3gegV2kRX/jkQQAcc0B/Boctc40tdACHDu3cNAkApUUFHDGiT1Jx9iwNkrn6ho5HyxQREZG8cLK7T3L3imwHIiLR0WEy5+6b3H1JuLwDWAmMBGYB94Wb3QecEy7PAu73wCtAPzMbDswAFrj7Nnf/CFgAzOzS2nSgvakJGtOmvXVtd8Ec0a+cP37peABmTRrJlLEDmDJ2QMLXemF1FQCXTh3b6WkVGpWH3Sx370s8GqaIiIiIiOS3pPrxmdkY4BjgVWCou28KV20GhobLI4H343ZbH5YlKm/5GnPMbLGZLa6qqkomvA7FulmGydxflm3k6eWbmm3T3rQFnxgzgNe/dwpnHj2c0qKCdueru3jeawDs3tv+9AVtmRO2DCbboiciIiLdkgPPmNnrZjYn28GISHR0Opkzs17AI8BV7r49fp0Hs2d3SZ9Ad5/r7hXuXjF48OCOd0hCYzfL659YQW1dPVc++E++/MASAKp21ALw/RbzybU0sFfQ3bKksCBhK15898hUukqeOG4Q7954JkN6d37QFBEREem2TnT3yQS3slxhZp+KX5nOf4SLSLR1amoCMysmSOQecPdHw+ItZjbc3TeF3Si3huUbgNFxu48KyzYA01qUL0w99OQ1tsyt2bqT19Zti5UvXBWEXl5cyGUnju3UsUqKEidzjYkhJD/4iYhIdzbmmqeyHYJIznH3DeHPrWb2GMHYAy/ErZ8LzAWoqKjQDfcieaQzo1kacDew0t1vjVv1JNA4IuVs4Im48ovDUS2PA6rD7pjzgdPMrH848MlpYVnGxE8vsO6DXbHlD3YG88FNSKJbY0lRQcIumRs+bpqy4IQWc8iJiIiIdJaZ9TSz3o3LBN+f3sxuVCISFZ1pmZsKXAQsN7OlYdl3gBuBP5jZ54H3gPPCdU8DZwCVwG7gUgB332ZmNwCLwu1+5O5NzWMZEJ/M3ffyu7HlxvnBf3buUZ0+VnvdLGv2BgOXXD1jPCePH5J8oCIiIiKBocBj4WBqRcCD7v7X7IYkIlHRYTLn7i8BiYZjnN7G9g5ckeBY84B5yQTYlYoLm6rxTlVTy9wv/14JwKBepa32SaS9bpb7GoLy4w8emEqYIiIiIgC4+1pgYrbjEJFoyqtZqeNb5uI1drnsW16c1LESJXN19UF39eKCvDq9IiIiIiKSQXmVbSRK5gD6lBVRWND5+eBK27ln7ub5bwMkdTwREREREZFk5FUyV9JOMtertFMDezYdK0zmgl6lTTZ+XMPqLTuB5t06RUREREREulJeJXPFRa2Tq8aulWXFyU0hUFJYgDssXF3FI6+v56Sbn6Ny606+/8SK2DZF7SSPIiIiIiIi+yOvso2W3SxvmHUER44MpiMoKUruVDRuf+k9i3jyjY289+FuVmys5qPde2Pb1CXohikiIiIiIrK/8iqZK2pxD9vI/uUcPixI5kqTbZmLS/4awq6WtXUNvP7eR7HyAwf2TDVUERERERGRduVVMhfO0RLTt7yEPo3dLJNsmesZd49dQXjcPfvqY2WXnDAm6dY+ERERERGRzsrrbGPyAf1iSVky0xIAfOboEbHlxhwx/n65b888bP8DFBERERERSSBvk7nbLzgGM6NXadC9cl+S97eVlzR1y1y4qqrZuu+deXiz9SIiIiIiIl0tb5O5sycGLWuNLXOJ5oxLhRI5ERERERFJt+QmV+uGYslcXdclc+3NZyciIiIi0TPmmqfSctx3bzwzLcdNV7ySW/I+6+idhmSuf4+SLjuWiIiIiIhIW/I+mWucLLw2hWRu1qQRbZYP61u2XzGJiIiIiIh0JO+TuYMH92La+MHcet6kpPedccSwNstH9Cvf37BERERERETalffJXHlJIfdeOoUJI/okve8ZRw2PLV947AEAFBca/XskN82BiIiIiIhIsvJuAJRxQ3qxe299xxsm6bBhvYFg8JOWk5OLiIiIiIh0tbxL5hZ846S0HHdwr1IAavZ1faIoIiIiIiLSUt4lc13t7988iaKCAj6u2QtAg2c5IBERERERyQtK5vbTQYN7ATDaNeiJiIiI5I50zlOWrrnVRKS5vB8ApavoPjkREREREckkJXMiIiIiIiI5SN0su9iwPpowXERyXzq7X4mIiEjX6LBlzszmmdlWM3szrmySmb1iZkvNbLGZTQnLzcxuN7NKM1tmZpPj9pltZmvCx+z0VCe7VvxwBguvnpbtMEREREREJA90ppvlvcDMFmU/B37o7pOA74fPAU4HxoWPOcBvAMxsAHA9cCwwBbjezPrvb/BR07O0iLLiwmyHISIiIiIieaDDZM7dXwC2tSwG+oTLfYGN4fIs4H4PvAL0M7PhwAxggbtvc/ePgAW0ThBFRERERESkk1K9Z+4qYL6Z/SdBQnhCWD4SeD9uu/VhWaJyERERERERSUGqydzlwNfd/REzOw+4GzilKwIyszkEXTQ54IADuuKQIiIiIpJB6RpEKRfnr9OAUpJOqU5NMBt4NFz+I8F9cAAbgNFx240KyxKVt+Luc929wt0rBg8enGJ4IiIiIiIi3VuqLXMbgZOAhcCngTVh+ZPAlWb2MMFgJ9XuvsnM5gM/jRv05DTg2pSjFhERkYTUKiIikh86TObM7CFgGjDIzNYTjEr5ReA2MysC9hB2iwSeBs4AKoHdwKUA7r7NzG4AFoXb/cjdWw6qIiIiIiIiIp3UYTLn7hckWPW/2tjWgSsSHGceMC+p6EREMsTMZgK3AYXAXe5+Y5ZD6pDuwxDJD7l4fRKRzEj1njkRkW7DzAqBOwjmypwAXGBmE7IblYiIrk8i0r5U75kTEelOpgCV7r4WILzvdxbwVlccXC1oIrIf0np9EpHcpmRORKTtuTCPzVIsIpGVi/+Y6AaDtuj6JCIJRTqZe/3113ea2SqgL1Cd5O7J7pPs9oOAD5KKKP0xpXKekq1HJmJK93uRj3VIZZ901mF8EseNjPh5MIHG61O6pXKtiRrVIftyPX5IsQ52U1KbH5js8aMgS9cmyMLnKsn3sy259rugeNMvKzF31bUp0skcsMrdK8xsrrvP6XjzJsnuk8L2i929ImIxpXKekqpHhmJK63uRj3VIMaa01cHMFnf2uBnSqbkw3X0uMDdTQUFq15qoUR2yL9fjh+5RhxR1eH3KxrUJcvM9ybWYFW/65WLM8XJlAJQ/Z2CfVF4jWemOqTvUIdV90nn87lCHVPbJxOcpKhYB48xsrJmVAOcTzJspIpJtuj6JSEJRb5kDwN2T/lKZ7D6pvEay0h1Td6hDqvuk8/jdoQ6p7JOJz1NUuHudmV0JzCcY+nueu6/IclgiIro+iUi7op7MZbzLQBKiHFsyukM9VIdoSKYOkauvuz8NPJ3tONoQuXOVAtUh+3I9fugedUiJrk9dKtdiVrzpl4sxx1gwz7eIiIiIiIjkkly5Z05ERERERETiKJkLmdloM3vOzN4ysxVm9rWwfICZLTCzNeHP/mH5YWb2DzOrNbNvtThWPzP7k5m9bWYrzez4XKuHmY03s6Vxj+1mdlUu1SFc9/XwGG+a2UNmVpaDdfhaGP+KTL0H+1GPz5nZMjNbbmYvm9nEuGPNNLNVZlZpZtdksh65wsw+G57nBjOraLHu2vDcrTKzGXHlkT2vZvYDM9sQdx05I25dm/WJmiif3/aY2bvh7+FSC0ePTfR7GxVmNs/MtprZm3Flia41Zma3h+/LMjObnL3I84eZfcWC7zYrzOznceWRvT6Z2TfNzM1sUPg84WfHzGaHn7U1ZjY7w3HeHJ7bZWb2mJn1i1sX2fMbL2rxQErfY3Lv2uLuegRdTYcDk8Pl3sBqYALwc+CasPwa4KZweQjwCeAnwLdaHOs+4AvhcgnQLxfrEXfMQmAzcGAu1YFgotV1QHn4/A/AJTlWhyOBN4EeBPe4/g04JMKfpxOA/uHy6cCrcZ+hd4CDwt+JN4AJmapHrjyAwwnm4FsIVMSVTwjPWSkwNjyXhVE/r8AP2rquJKpPtuNtI85In98OYn8XGNSirM3f26g8gE8Bk4E3O4oZOAP4b8CA4xqvNXqk9f05OfwbVBo+HxL+jOz1iWBKh/nAe42/D4k+O8AAYG34s3+43D+DsZ4GFIXLN8V91iN7flvEH6l44uJK9ntMzl1b1DIXcvdN7r4kXN4BrCRIBmYRJGeEP88Jt9nq7ouAffHHMbO+BH+Q7g632+vuH2ekEnRdPVqYDrzj7u+lLfA4XVyHIqDczIoIEqKNaQ6fMKauqsPhBBeS3e5eBzwPnJuBKhDGlWw9Xnb3j8LyVwjmQwKYAlS6+1p33ws8HB5D4rj7Sndva7LfWcDD7l7r7uuASoJzmqvnNVF9oiZXz28ibf7eRoW7vwBsa1GcKOZZwP0eeAXoZ2bDMxNp3rocuNHdayH4uxWWR/n69AvgP4D4ASISfXZmAAvcfVv4d2wBMDNTgbr7M+HfeWj+9zPK5zde1OIBkv8eQw5eW5TMtcHMxgDHAK8CQ919U7hqMzC0g93HAlXAPWb2TzO7y8x6pivW9uxnPeKdDzzUpcF10v7Uwd03AP8J/AvYBFS7+zNpCzaB/Xwf3gQ+aWYDzawHwX+MRnewT1qkUI/PE/x3C4IL5/tx69aHZdI5ic5fLpzXK8OuKvPiuvXlQtyQO3G2xYFnzOx1M5sTlu3P34FsSRRzLr83uepQgr9Hr5rZ82b2ibA8ktcnM5sFbHD3N1qsimS8LVxGx38/oxQvRC+eVjr5PSby9Wgp6lMTZJyZ9QIeAa5y9+1mFlvn7m5mHQ3/WUTQTeQr7v6qmd1G0Hx7XbpibksX1KPxOCXA2cC1aQm0/dferzqEXxxnESTYHwN/NLP/4+7/L41ht4xhv+rg7ivN7CbgGWAXsBSoT2PIbUq2HmZ2MkEyd2JGA80BZvY3YFgbq77r7k9kOp791V59gN8ANxAkFjcAtxB8SZH0O9HdN5jZEGCBmb0dvzKZvwNRkYsx55oOfp+LCLogHkdwW8AfzOygDIbXSgfxfoeg62JkdOb6b2bfBeqABzIZW3fXVd+Lo0jJXBwzKyZ4ox9w90fD4i1mNtzdN4XNrFsTHwEIMvj17v5q+PxPBMlcxnRRPRqdDixx9y3piDWRLqrDKcA6d68Kj/kowT1dGUnmuup9cPe7CbvtmtlPCT5jGZNsPczsaOAu4HR3/zAs3kDzFsVRYVnecfdTUtitvfOX1fPa2fqY2Z3AX8KnufJ5yJU4Wwl7JuDuW83sMYIuUKn+HcimRDHn7HsTZe39PpvZ5cCj7u7Aa2bWAAwii9enRPGa2VEE/8h9I/zSPgpYYmZT2ol3AzCtRfnCTMTbyMwuAc4CpofnGSJ8/W8hsr+TSX6PiWw9ElE3y5AFv+13Ayvd/da4VU8CjSMazQba/c+5u28G3jez8WHRdOCtLg43oa6qR5wLyHAXyy6sw7+A48ysR3jM6QR9pdOuK9+H8D/rmNkBBPfLPdi10bb72knVI4zxUeAid18dt/0iYJyZjQ1be88PjyGd8yRwvplgCNyvAAADlUlEQVSVmtlYYBzwGhE/ry3uM/g3gm7DkLg+URPp85uImfU0s96NywStE2+S+t+BbEoU85PAxRY4jqAb/aa2DiBd5nGCQVAws0MJBrn4gAhen9x9ubsPcfcx7j6G4J+gk8PvaIk+O/OB08ysf9iz57SwLCPMbCbB/X1nu/vuuFWRO78JRC0eIKXvY7l3bfEIjMIShQdBdzAHlhF0ZVtKcH/SQOBZYA3BKE4Dwu2HEVwcthN04VsP9AnXTQIWh8d6nMyOhtSV9egJfAj0zeH34ofA2wRfZH5HOApXjtXhRYJ/CLxB8N+6KL8XdwEfxW27OO5YZxCMIvUOQZeSjNUjVx4ECc96oBbYAsyPW/fd8NytImj1jPx5DX/nloefnyeB4R3VJ2qPKJ/fdmI+KLxevAGsaIw70e9tVB4E/zjcRDAQ1HqCrtqJrjUG3BG+L8uJG/1Vj7S9PyUEPVveBJYAn45bF+nrE3Gju7b32SHoBl4ZPi7NcIyVBPdqNf79/G2unN+oxhPGlOz3mJy7tlgYuIiIiIiIiOQQdbMUERERERHJQUrmREREREREcpCSORERERERkRykZE5ERERERCQHKZkTERERERHJQUrmJK3MrN7MlprZCjN7w8y+aWbtfu7MbIyZXZipGEVEREREcpGSOUm3Gnef5O5HAKcCpwPXd7DPGEDJnIiIiIhIOzTPnKSVme10915xzw8CFgGDgAMJJhXuGa6+0t1fNrNXgMOBdcB9wO3AjcA0oBS4w93/K2OVEBERERGJICVzklYtk7mw7GNgPLADaHD3PWY2DnjI3SvMbBrwLXc/K9x+DjDE3X9sZqXA/wCfdfd1Ga2MiIiIiEiEFGU7AMlrxcCvzGwSUA8cmmC704Cjzex/h8/7AuMIWu5ERERERPKSkjnJqLCbZT2wleDeuS3ARIL7N/ck2g34irvPz0iQIiIiIiI5QAOgSMaY2WDgt8CvPOjf2xfY5O4NwEVAYbjpDqB33K7zgcvNrDg8zqFm1hMRERERkTymljlJt3IzW0rQpbKOYMCTW8N1vwYeMbOLgb8Cu8LyZUC9mb0B3AvcRjDC5RIzM6AKOCdTFRARERERiSINgCIiIiIiIpKD1M1SREREREQkBymZExERERERyUFK5kRERERERHKQkjkREREREZEcpGROREREREQkBymZExERERERyUFK5kRERERERHKQkjkREREREZEc9P8B3WB45fhNaVYAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -296,11 +296,11 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 8, "metadata": { "ExecuteTime": { - "end_time": "2020-04-30T22:04:25.565186Z", - "start_time": "2020-04-30T22:04:24.633139Z" + "end_time": "2020-05-03T17:03:17.238109Z", + "start_time": "2020-05-03T17:03:16.462550Z" }, "scrolled": false }, @@ -359,11 +359,11 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 9, "metadata": { "ExecuteTime": { - "end_time": "2020-04-30T22:06:37.630038Z", - "start_time": "2020-04-30T22:06:37.617303Z" + "end_time": "2020-05-03T17:03:17.251700Z", + "start_time": "2020-05-03T17:03:17.245323Z" } }, "outputs": [], @@ -384,11 +384,11 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 10, "metadata": { "ExecuteTime": { - "end_time": "2020-04-30T22:07:05.061525Z", - "start_time": "2020-04-30T22:07:03.277417Z" + "end_time": "2020-05-03T17:03:19.034570Z", + "start_time": "2020-05-03T17:03:17.257051Z" } }, "outputs": [ @@ -402,25 +402,25 @@ "\n", "Statsmodels results css:\n", "Fitted parameters: mu=-0.02, p=[-0.03 0.01], q=[]\n", - "AR roots abs:[ 8.15 11.34]\n", + "AR roots abs:[7.1 9.4]\n", "MA roots abs:[]\n", - "Train error mean: 0.00, std: 0.96\n", - "LL: 550.05\n", + "Train error mean: -0.00, std: 1.00\n", + "LL: 565.86\n", "RMSE: 1.10\n", "\n", "Giotto results css:\n", - "Fitted parameters: mu=-0.02, p=[-0.03 0.01], q=[]\n", - "AR roots abs:[11.34 8.15]\n", + "Fitted parameters: mu=-0.02, p=[-0.03 0.02], q=[]\n", + "AR roots abs:[9.38 7.09]\n", "MA roots abs:[]\n", - "Train error mean: 0.00, std: 0.96\n", - "LL: 550.05\n", + "Train error mean: 0.00, std: 1.00\n", + "LL: 565.86\n", "RMSE: 1.10\n", "\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -432,7 +432,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -452,11 +452,11 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 11, "metadata": { "ExecuteTime": { - "end_time": "2020-04-30T22:06:57.988638Z", - "start_time": "2020-04-30T22:06:56.238373Z" + "end_time": "2020-05-03T17:03:20.961649Z", + "start_time": "2020-05-03T17:03:19.038239Z" }, "scrolled": true }, @@ -479,11 +479,11 @@ "\n", "Giotto results css:\n", "Fitted parameters: mu=2442.07, p=[0.98 0.02], q=[]\n", - "AR roots abs:[53.98 1. ]\n", + "AR roots abs:[53.89 1. ]\n", "MA roots abs:[]\n", "Train error mean: 0.80, std: 20.81\n", "LL: 5154.55\n", - "RMSE: 63810.54\n", + "RMSE: 63820.28\n", "\n" ] }, @@ -501,7 +501,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -528,11 +528,11 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 12, "metadata": { "ExecuteTime": { - "end_time": "2020-04-30T22:07:16.405933Z", - "start_time": "2020-04-30T22:07:14.892834Z" + "end_time": "2020-05-03T17:03:34.709039Z", + "start_time": "2020-05-03T17:03:33.225055Z" } }, "outputs": [ @@ -541,26 +541,26 @@ "output_type": "stream", "text": [ "Statsmodels results css:\n", - "Fitted parameters: mu=-0.00, p=[-0.71 -0.36], q=[]\n", + "Fitted parameters: mu=-0.00, p=[-0.71 -0.35], q=[]\n", "AR roots abs:[1.68 1.68]\n", "MA roots abs:[]\n", - "Train error mean: 0.00, std: 1.11\n", - "LL: 604.02\n", - "RMSE: 1.14\n", + "Train error mean: 0.00, std: 1.15\n", + "LL: 618.98\n", + "RMSE: 1.48\n", "\n", "Giotto results css:\n", "Fitted parameters: mu=-0.00, p=[-0.68 -0.32], q=[]\n", "AR roots abs:[1.76 1.76]\n", "MA roots abs:[]\n", - "Train error mean: 0.00, std: 1.11\n", - "LL: 604.32\n", - "RMSE: 1.12\n", + "Train error mean: -0.00, std: 1.15\n", + "LL: 619.25\n", + "RMSE: 1.13\n", "\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -572,7 +572,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -591,11 +591,11 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 13, "metadata": { "ExecuteTime": { - "end_time": "2020-04-30T22:07:33.012134Z", - "start_time": "2020-04-30T22:07:31.564040Z" + "end_time": "2020-05-03T17:03:36.370882Z", + "start_time": "2020-05-03T17:03:34.712523Z" }, "scrolled": true }, @@ -616,9 +616,9 @@ "Fitted parameters: mu=0.77, p=[-0.02 -0.06], q=[]\n", "AR roots abs:[4.23 4.23]\n", "MA roots abs:[]\n", - "Train error mean: 0.00, std: 20.78\n", + "Train error mean: -0.01, std: 20.78\n", "LL: 5147.77\n", - "RMSE: 45068.92\n", + "RMSE: 45021.77\n", "\n" ] }, @@ -636,7 +636,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -655,11 +655,11 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 14, "metadata": { "ExecuteTime": { - "end_time": "2020-04-30T22:07:34.409667Z", - "start_time": "2020-04-30T22:07:33.016391Z" + "end_time": "2020-05-03T17:03:38.007505Z", + "start_time": "2020-05-03T17:03:36.379232Z" } }, "outputs": [ @@ -668,26 +668,26 @@ "output_type": "stream", "text": [ "Statsmodels results css:\n", - "Fitted parameters: mu=-0.01, p=[-0.32 0.01], q=[]\n", - "AR roots abs:[ 2.91 47.31]\n", + "Fitted parameters: mu=0.00, p=[-0.43 0.02], q=[]\n", + "AR roots abs:[ 2.15 26.81]\n", "MA roots abs:[]\n", - "Train error mean: 0.00, std: 0.72\n", - "LL: 435.19\n", - "RMSE: 10.55\n", + "Train error mean: 0.00, std: 0.68\n", + "LL: 413.09\n", + "RMSE: 2.77\n", "\n", "Giotto results css:\n", - "Fitted parameters: mu=-0.01, p=[-0.32 0.01], q=[]\n", - "AR roots abs:[47.31 2.91]\n", + "Fitted parameters: mu=0.00, p=[-0.43 0.02], q=[]\n", + "AR roots abs:[26.81 2.15]\n", "MA roots abs:[]\n", - "Train error mean: -0.00, std: 0.72\n", - "LL: 435.19\n", - "RMSE: 11.30\n", + "Train error mean: 0.00, std: 0.68\n", + "LL: 413.09\n", + "RMSE: 3.08\n", "\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2kAAAE6CAYAAACMDRrWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeZwcdZk/8M9TVX3MPZNkcl/k4A4ECNeCiCQgBBRQ1wVZxFUXDzwXZYPuij92deOxIuwqmhUFlRUVVFBc7hskkkA4whWO3NfkmCNz9Pn9/VFV3dXV1edUHzP9eb9evLq7urrqO52eoZ5+nu/zFaUUiIiIiIiIqD5otR4AERERERERpTFIIyIiIiIiqiMM0oiIiIiIiOoIgzQiIiIiIqI6wiCNiIiIiIiojhi1OOmkSZPU3Llza3FqIqqQtWvX7lFKddd6HKPBv01E4xP/PhFRPcr3t6kmQdrcuXOxZs2aWpyaiCpERDbVegyjxb9NROMT/z4RUT3K97eJ5Y5ERERERER1xJcgTUQ6ReR2EXlVRF4RkZP9OC4REREREVGj8avc8XoA9yilPiAiQQDNPh2XiIiIiIiooYw6SBORDgCnAfgIACilogCioz0uERERERFRI/Kj3PEgAD0AfiYiz4nIT0Skxb2TiFwuImtEZE1PT48PpyUiIiIiIhp//AjSDADHArhRKXUMgEEAK9w7KaVWKaWWKKWWdHeP6S64REREREREFeNHkLYVwFal1Grr8e0wgzYiIiIiIiIq0aiDNKXUTgBbROQQa9NSAC+P9rhERERERESNyK/ujp8FcKvV2fEtAP/g03GJiIiIiIgaii9BmlJqHYAlfhyLiIiIiIiokfmymDVl2rx3CHNX3I01G/fVeihERERERDTG+FXuSA5PvLEHAHD72q1YMndCjUdDNP6JyBcBfByAAvAizJLraQBuAzARwFoAl1rrONIYMnfF3RU57saV51bkuEREjYh/q/3HTFoFidR6BETjn4jMAPA5AEuUUkcC0AFcBOBbAK5TSi0AsB/Ax2o3SiIiIqLiMUgjovHAANAkIgaAZgA7AJwBc0kQALgFwAU1GhsRERFRSRikVYCCqvUQiBqGUmobgO8C2AwzOOuDWd7Yq5SKW7ttBTCjNiMkIiIiKg2DNCIa00SkC8D5AA4CMB1AC4CzS3j95SKyRkTW9PT0VGiURERERMVjkFZRnJRGVAXLALytlOpRSsUA/A7AKQA6rfJHAJgJYJvXi5VSq5RSS5RSS7q7u6szYiIiIqI8GKQR0Vi3GcBJItIsIgJgKYCXATwM4APWPpcBuLNG4yMiIiIqCVvwE9GYppRaLSK3A3gWQBzAcwBWAbgbwG0i8u/WtptqN0qqN5VqFw00dstoIiLyB4O0ClDsG0JUVUqpawBc49r8FoATajAcIiIiolFhuWMFcZ00IiIiIiIqFTNpREQ0apUsHyQiImo0zKQRERERERHVEQZpFcApaUREREREVC4GaRWgrM4hnJJGRERERESlYpBWAYkkc2lERERERFQeBmk+2zcYRTzBII2IiIiIiMrDIM1Hr+8awLH/dj9+uXpTrYdCRERENSYis0TkYRF5WUTWi8jnre1fF5FtIrLO+m95rcdKRPWFLfh99PaeQQDApr1DALhOGhERUYOLA7hSKfWsiLQBWCsi91vPXaeU+m4Nx0ZEdYyZNB8F9fp/O/cNRvHl3z6P4Wii1kMhIiIa15RSO5RSz1r3BwC8AmBGbUdFRGNB/UcVY0jAFaTVY/+Q6x94Hb9duxW3P7u11kMhIiJqGCIyF8AxAFZbmz4jIi+IyE9FpKtmAyOiusQgzUcBPbO+MVGHDUQMK5CMxJhJIyIiqgYRaQVwB4AvKKX6AdwIYD6AxQB2APjPHK+7XETWiMianp6eqo2XiGqPQZqPdC0zSIu7Umk9AxF86pdr0T8SS2175LXdeHl7f1XGBwAhwwrS4smqnZOIiKhRiUgAZoB2q1LqdwCglNqllEoopZIA/gfACV6vVUqtUkotUUot6e7urt6giajmGKT5yL0+2o6+4YzHP3j4DfzfSztx+5p0qeFHfvYMlt/weFXGBwC9w2aAyEwaERFRZYmIALgJwCtKqe85tk9z7HYhgJeqPTYiqm8M0nzkDtKeenMvvn3Pq6nHmtXuMalqUwb5x+e3439XbwYARBLMpBEREVXYKQAuBXCGq93+t0XkRRF5AcC7AHyxpqMkorrDFvw+SngEXz985E1cdfahAAC7r4gdzEWrXHK4ZuO+1P1IjEEaERFRJSmlngDgtSDPn6s9FiIaW5hJ85E7k+amWXPW7GCubziWb3ffiWPhtkic5Y5ERERERPWIQZqPvIK0oJF+i3W73DFpB2nRjH1vX7sVc1fcXZXgjY1DiIiIiIjqE4M0H3kFaSHH2ml290d7t96hzGDs5qfeBgBs3jtUoRGmbe8dzugySURERERE9cG3IE1EdBF5TkT+5NcxxxqvhiDOTJpdbhhLJPH0W3ux50AEANAU0M19rYAumqh8KeLTb+3DMdfeX/HzEBERERFRafxsHPJ5AK8AaPfxmGOKV8NE99ppAPBfD72B/3roDbSFzbd/WmcYQDqgq1QporiGkkgq7B+MoqslWJHzERERERFR6XzJpInITADnAviJH8cbq+LJ7ODKuaC1u5vjwEgcANAWMoO1gJ4ZpPUNxfDUG3vKHs9ILIGv37UeA1ZZo3g0mNq4d7Ds4xMRERERkf/8Knf8PoCrADR0Nwq73PHbHzgqtS3mCMxytdy3A7mQYZY9jkTNcseP//wZfOgnqzEUjZc1nl8/swU3P7URNzy4Iec+7nlxRERERERUW6MO0kTkPAC7lVJrC+x3uYisEZE1PT09oz1tXbLLHU86aGJqW9RRA5mr7X08YQdp5j/HoBWkvbitDwAwUuaaZnZ543AskfHYaf9QNHsj0RgjIoc4FopdJyL9IvIFEZkgIveLyAbrtqvWYyUiIiIqxI9M2ikA3isiGwHcBuAMEfmleyel1Cql1BKl1JLu7m4fTlt/7Nb6ui5437EzAOQvd7TZZZL2nLTBSNw6nvl8uZk0u3wyFs+9ftu+QQZpNPYppV5TSi1WSi0GcByAIQC/B7ACwINKqYUAHrQeExEREdW1UQdpSqmrlVIzlVJzAVwE4CGl1N+PemRjkB2Q6SL43gcX44vLDkYiqVKt+aNenUWQbt1vd3cctIIye9HrkVh53R5TQZp1Xo9EGssdaTxaCuBNpdQmAOcDuMXafguAC2o2KiIiIqIicZ00H9lBlWa9qwEj3XIfACI5yhZjiczX7e6PIJZIpoK3oWi5QZp5fjs4ZLkjNYiLAPzKuj9FKbXDur8TwBT3zo1Qik1ERERji58t+KGUegTAI34ecyyxyx0NK9oKWLfxIjNpdrB281MbsXlfekHr4TKDNHsc9pw3L8yk0XgiIkEA7wVwtfs5pZQSkaxfBqXUKgCrAGDJkiW5f1mIiIiIqoSZNB85yx2BdCbr53/ZCKDwnLSYI4h76NXdqfvDZZQ77j0QwRX/+2zWcd36Rxik0bhyDoBnlVK7rMe7RGQaAFi3u3O+koiIiKhOMEjzkZ1JS5c7mne+fc9rAMwg7fi5Xbj6nEMzXmcHd7kyXuVk0u56fnvqfrrcMbve8UCkvKYk1CD2vQX85Ye1HkUpLka61BEA7gJwmXX/MgB3Vn1ERERERCVikOYje06arlmZNC399v52zRYMxxJoDRl4/3EzM15nB2e5yiHLyaQlHF0l8zUOsRfUJvJ0y3uBe68GRvprPZKCRKQFwJkAfufYvBLAmSKyAcAy6zERERFRXfN1TlqjswOjVJBmpMOilf/3KtrCBuZ1t2QEb0C63DGeI0grp3FILKE87zvN6GzCAQZplI8dnKn6X6deKTUIYKJr216Y3R6JiIiIxgxm0nyUcM1JMxzB2JT2MPpH4mgPBzKCN12TVCYtVzBVTgv+RDJ9UW1n0pxHv/XjJ+LsI6diwJqTtn57H3b2jZR8nka3fzAKpcZxrwm7RDZZXvMaIiIiIiodgzSfjMQS+N79rwNIZ9IMTTKe7x+Oob3JSK1fBgBhQ0M8qaCUytngo5xMmtci2s45b6csmITWkIHBaAKJpMK5NzyBk1c+WPJ5GlnfUAzH/Nv9+M69r9V6KJWTCtJiwLM/B/ZvrOlwiIiIiBrBuAnSbnlqI776+xdrdv7HN+xJ3bcbdDjnmO0biiKeVGgPBzKCt3BABwAkVe4ujKOdk/b2nkFs6x3Gzv7hjH3awma1q908ZDwnhCrBXnT8h4+8WeORVJBYfyJiQ8BdnwV+ek5tx0NERETUAMbNnLRr7loPAPjGhYtqcv6kR4TjLFO01yNrCwcyuiyGrA6QsUQyI/tlawsZZXV3dB4rEk/ilJUPZR/bFaRRaRIe/17jjh2kRa11+4b25N6XiIiIiHwxLjJp23qHC+9UYV5ZKK/gqr0pMy62M2mJpPKck9Yc0ssL0vKsjWbrbgsBAHbUwfvnt96haMXP4cx8rrjjhYqfrzasLxRiVpAmmtmWPx6p3ZCIiIiIxrlxEaSd+q3sLJHTu697DMuvf7yiY/DKpC2a2WHezuhIbWsPBzL2CVlBWjzhPSetKaCXVe6YqwmJ0yFT2wEAr+4cKPn49eylbX1YfO39+MNz2yp6Hmcm7bZntlT0XDVjZ32jg+ZtfAS44Rjg8e/VbkxERERE49y4CNIKzaV6bdcAXt5R2XWevDowHjdnAl74+lk496hpqW2tYXcmzfwniCeTiCeSOHpWJ46amQ7qmoJGWY1Dcq255jS9I4y2sIFXd9b/GlilsP+tnfMEK8EdCJfThbP+uTJptgM7qz8UIiIiogYxLoI0p1esC/Sn3tyDB1/ZVbXzDuYIpNrDATRZ2TIAaA1lBmn2nLS4Ve64cHIrvnFBel5dU0DDSCyBeCKJuSvuxo1FNqkYKSKwExFMbgth/2CsqGOOBX1D1ftZ4snMQLhnYByWALrnpNn0UPXHQkRERNQgxl2Qdo5V1vih/1mNj92ypmrnHY7mbr7hDNKag3rGc/actHhSIRJPIqBrGfPWmoJmueNgxAy6rnvg9aLGs6/IOVlBQ0ckPj4yQK/s6MfR196HO9eZZY4KlW3s4W700nNgPAZpdiZtMHN79ED1x0JERETUIMZdkOZWrbb8dhDlJewIzFqCmZk0O2g7MBLH3sEIJreFMuatNQUMDEbi2DNoBgDFNATZ1juMR1/vKWrcQUNDJF74mGPBk2+Y5Y3rNvdW5XxxV7njnvGYSbPLHd2ZtMj4KpElIiIiqifjPki7dfXmqpxnqMhMWpMrkzarqxkA8Ku/boZSwMyuplRrfHv/V3cOYOl/PgrAXE+tkE17B4te8yyka6nFrse6zfvMQGLWhOaqnM8dMO+vQkfJqnjhN8DXO8xmIal10lyZtAgzaURERESVMu6DtGrJNScNyAzS7Dlo9rZ53S0AgJuf2ggAmNHVBEM39/mb+RPRHMgM6gCzvfxreToy9g8XPy8rZM15sz2zcV/Rr6032/abSwkYuhTY0x+xpLtxyBgMdnteB255T7p7IwA8+i3ztm+bo7ujO5M2vjqCEhEREdWTcRGkNXkEMtU2lGdB6K6WdPmivZB1S8gc8/TOJgT19D+DnVlb/ZWl+OlHjs/KvAHAhT98Cu/+/mM5z9dXIEjrak6PJ6hrGS3+//ZHf8n72npmL8qdygxWeK3phKtxyJic23ffV4G3HwPedixRoVmZ3GTcMSfNFaRxThoRERFRxYyLIG3hlNai9ksWUytYpnyZNHvRaCc7+ArqWur5BZNbU6V6U9rDCAd0z7XT3t5jZj1UjprGQkHaX65emrofNLSsFv+VfJ8qacQKzqpVvpndgn8MZtKUNWbN8WVAKkiLOcodmUkjIiIiqpZxEaTFEgoBR4lbriCjmLXDymXPSfuP9y3Kem5iS3aQ1hwwL4QNXUPIWitt6WGTs/ab3tmU85xeP8/W/UN4ZuN+6Frukr+wI/MYNLSs9b3suV1jzaCVSbMzg5UONd2NQ8bkOmlJa8zi+LzYAVs8ityNQ5hJIyIiIqqUugvS9h6I4I61W0t6TTyRzAg8cgVjkQpmOoaiCbxj4SRcfMLsrOe8AqZmq9xRKZUqd3SWPdo+/o6D8C/nHuZ5zmGP7N2p33oY97+8C+2uRbNzCepa1nFe3zU2syT2XLx8nTb95F4nbUx1yYwOAk/faJY0AoB4ZNJiQ445aa7GIfFh6zYCjPRVdqxEREREDabugrRP/fJZXPnb57G9d7jo18STCs4wKFeQNlLBOUNDkUTWGmj52PsORROpRhcBjyAtZOiY3+1dzjnsyty8vD3dFr2jKeDe3VMooGEoNraDtIdf3Y0fP/pmqszzQJ75gX4a05m0h74B3LMC2GjNRRPHZy8VpA0jlUlzlzsmooBSwC8uBFZmfzFBREREROUrLt1SRVv3mxeDiRLmRcWTyVRDDgCI5choVDKTNhiNZ62B5vSTDy+B7ijJtEsgndkYryANyCxPdHLPJVt+Q7r5Q7PHWL5x4ZFZTVaCup7Vrn9b74jn+erVP9z8TE3O686kjZk5aQ99A3j6B5nbnHPS7KxafDj3nDTADNQ2PVmZMRIRERE1sLrLpMWt4KzYdb4AM6Nht7IHcpe7VbL73lA0kSph9LLs8Cl41yHpOWfXnn8EPnvGArzz4MkQ2Jk073lk4YD3P5NXuaMtaGj49OnzcelJc1LbLjlxDt537Mys/WwrzjkUM7uaxmaXQg+5Gqv4Je76ImHMvG+PfTt7W0Ymzfocx4a9yx11a45l3LF4d6L4ZR+IiIiIKL+6C9Ls695SmnzEEgqHTm3HP599KADgtO887LlfJTMdg5H8mTS3zuYgrjzrEOiapK6DQ0ZpmTR3uaNT0NBw1dmH4t8uODLvOJxBWmdTACFDG1tzq/KofuOQMfC+De/33u5Z7jjknUkLd5i3zsCM3R6JiIiIfFN35Y5JK/tRShv1eDKJgC6Y2ZW7EyIA7B4YwcBIM9rCxc3XKlYiqRCJJz1LDIth589ylTvmWgfOXe7o5Az4nr56KVSOkMW5n6YJQoZe0bJQv+WbB3bnuu2Y2h7G1cu9G6+Mlnt5hDGRSet53Xu7nXXc9BTQv92875yT5uzuGG4HBncDCUcmjUEaERERkW/qLpNmz0UrJZMWTygYmpaRFXJqszodfuyWNTjm2vtHP0gXu/1+KY1DvBQzJ+2keRNS94ejuRtkOI81tSOMaR3eAawzSNNFEApoYyPYsPQMRDIeT3atSffjx96q2Lnd8ybHRHC7703v7SoBJJPAz84B9rxmbosNI5WPHNyd3jfUZt7GGaQRERERVULdBWn2GmelZNJiCTOT5tXCHgC6moOp++55RH6wM1r55qQVI5AjyHRm0pYdNiXrvJ7HyjG/zc0Z2Bq6jLlyR3cnR3sx8GqwP0tHzmhHV3Ogot1DfbN/k/f26CDw11WZ22JD6Rb9TnaQ9vaj6W2//6Q/4yMiIiKi+gvS7AtfdylZodcYuuTMpHU1e5c3btk3hL0HIp7PFSMaT+LTt67Fc5t7AaCkOWkZrElpuYLMkKNxiDPzlW9OmiZFBmmOc2pilzuOgWDDMugI0poC+qizmaWwP6N3XXEqTjhoQv234B/YCTy60vu5P38JuOefM7dFDphB2qyTMrcHrSDtj59Pb9v1on/jLIOIdIrI7SLyqoi8IiIni8gEEblfRDZYt101HSQRNRwRmSUiD4vIyyKyXkQ+b23n3yciyquugrREUqUCj2IzaUopJJL5yx07HZk0p3d8+2Gc9B8PljdYAC9t78OfX9yJT/5yLQCgNTS6OWlBwzuwChkaPnzyHNzxqb/J+BnzdXcs1tSOcOq+ro3tTFpTUM/ZfKUS4gkFTcy5fOGAjtd3HcC963dW7fwl25pnqYLezd7bknFgwjxgiqMBjZ1Jqy/XA7hHKXUogKMBvAJgBYAHlVILATxoPSYiqqY4gCuVUocDOAnAFSJyOPj3iYgKqKsg7b8e2pC6X2ygELM67OUrd8y3sHMsUX75o3tOUmu4zCDNis1yzUkTEVx7/pE4bk5XRpAWTypE4gn0j2S3Py8ykYZ3Htyduq+JGWyMpSDNudyCrglCOZqsVELc+nIAANqtZjSf+MXaqp2/ZHY3xmmLPZ70+MDsfxtIJgBNAz7xGKBbX3aE2ys2xHKISAeA0wDcBABKqahSqhfA+QBusXa7BcAFtRkhETUqpdQOpdSz1v0BmF8gzQD/PhFRAaMO0nKl8suxdlO6Pfhv1mwp6jX2gsKGnjuTZuiCFh/L4GKJJAZGYlklmeVm0my5gjSnoJ7+OaLxJC5a9TSO+vp9uOel8jI4zkXAU5m0Oi3biyWSOOEbD+DuF3aktjnLHQOapIKlaognkjCsuX+5SmrrSmzYvJ13evZzusf4928yF6zWDHPttBYroK+/TNpBAHoA/ExEnhORn4hIC4ApSin7w7ITwBSvF4vI5SKyRkTW9PT0VGnIRNRoRGQugGMArAb/PhFRAX5k0nKl8ks2zVF699Cru7F/MFrwNXYmzNAkdyYKUnaWy8unfrkWi75+X1a54WjLHXWtcPrLGYjGEsnUfDi75DJ9zCJTaY7zGprd3bE+M2k7+0aweyCCb/75ldS2AUeQpuvimTVNVqBZDGBn0sz3LldJbV2x1zpr6c5+TvP47CYiwGBP+jm7iUj9BWkGgGMB3KiUOgbAIFylQ8pc2dzzg6CUWqWUWqKUWtLd7fHeEBGNkoi0ArgDwBeUUv3O5/j3iYi8jDpIy5PKL9mk1lDhnVziVjYroGs55yOJIGeWrRwPvGK2I9/nCiJbRplJK4bz58i7TEHxMVoq0Eitk1anQdoeq8nLhJZ0QOTMpOniHaSVspxDKUZiCQQNM7PZ1TKGMmmtk7Of01zj1x1BZypIs76UqL8gbSuArUqp1dbj22EGbbtEZBoAWLe7c7yeiKhiRCQAM0C7VSn1O2sz/z4RUV6+zklzpfLdzxVM2bvneCVU7gzISCyBU1Y+hIdfM4+Vr7ujoLhSwlJt3jeU8bit7DlpxUdUznl3sbg/GSI7SNPFLHes1y6Fu6010Sa25gjSNO8grVI/z87+EUztML9Y6GwaC5k0K0ibdWL2c5qrHLhjVvp+j7Vump1JC7qCtNkn+zO+MimldgLYIiKHWJuWAngZwF0ALrO2XQbgzhoMj4gamJj/g78JwCtKqe85nuLfJyLKy7fIJV8qHyguZR+JJzNK/vKVqW3aO4RtvcP42p0vAQACmpazcYhI5lpjpVBKYe6KuzNK7Gwb92YGaeV2FrR/4jwxaUpmJs2f4MOw3jdNA0KGjnhSpTKU9WR3/wiAzEyas9zR0DTPIK1SmcGdfSOpRcJLiLNrJzYI6CGga072c+45aR0z0/ebOs1bZb2P7kxaxyzgiPf5N87yfBbArSLyAoDFAL4JYCWAM0VkA4Bl1mMiomo6BcClAM4QkXXWf8vBv09EVIAv9Xk5Uvkli8QTaAsb6B0yu9Dly6TZDRvsBZ1bQkaeTJpklSKqYiIiAHacuOqxt/CV5YdlPLdp72Dmecq8Uj90WhvWbNqPziKaTzgDwXyZtFJG4syk2e/htt5hzJnYUsJRKs/OpDkDsR29w6n7uiZoCmZ/BiKxygRp23uHceJBEwAAh0ytuxLAbLFhIGAGlfjSBmD/RuCmM83HkieTdt73zdtc5Y6xIWDGcb4PtxRKqXUAlng8tbTaYyEisimlnkDu/yXz7xMR5eRHd8dcqfySRWLJjAWh43na4+uugKgtbOQsadQ0ZHR3XL+9L7VodiF290gvG/cM5nyuFP963uH41T+ehIOnFL7QdzcO8UOqcYgumGDNrfrxY2/5cmw/2e32nfH1pn1DqYYzhi6phikLJ7em9hmJJ/D5257DB3/8l1GdXykFpRRufvJt/M9jb6F/JI6pViZtWkcTPn36fAT0Ok6pxYaAoBV4t04GOmennxvYnrlvuAPomguc8S/pTFquxiGxYeAd/1SRIRMRERE1Ij8yaXYq/0URWWdt+4pS6s+lHigST6LJEUwlc2S7BkZiOP27j2Rsa28K5LlAFjQ7Mmnn3vAEXr723anHr+7sx6FTvdd+cs+Te3xDej5d/0i61O6RL52e49yFhQwdJ8+fWNS+zpLOfA0xSsnq2cGtJoLzF8/AP9/xYlGll9VmL3RuB6fJpMLWfcM4amYHdvSNQNcEpx3cjS+/+xBcevIc3Ld+F7702+cRiSVx5zozCOkbiqGjzHb5/3rnS/jl05mLPk/vTHckNTQpOvivqu3rgGlHZ2bSgPwNQIwQ8PnnM7cl44gB2J4YwqamMDYFAtgUMLA5sRmb7zi7IkMnIiIiakSjDtIKpPJLEoknMoIQd4Bk29UfydrWFjZyBiYiQGsw80d1LmJ99vcfx8aV53q+1r7otg/9xV8/77nf7AnNntv95pyzF/VprpV9TF0zF7Oe0h6qWNv60bDXb7t19Wb84zvmoSmoI5pIYlpnE7BpPwxNoGuCK961AAAwpd1s6hGJp+furd/eh79ZMKms87sDNACpOWkAoGsalDKDR62I5RQq6pU/AUN7zYzZry4Czv9BdpAW8PjMTlyIxN4N2KHi2LztKWwa2ITN/ZuxqX8TNs+YjK2GgcRDnwCmmh0i2xJJzFZxHNV9FO7FvVX64YiIiIjGt8r3jC9BJJ5EKKDh3KOm4e4XduQM0ryWE8m3iLEAOHpWJ37tWCC72FLBhBXM2ZfcR85oxyOvZXenrNZFuTMOjSWSGdmbzy1diFWPvYmRWLK0OWlWBlITe700rS4zQsOOLo2nf/cR/OmzpwIATjhoAv74/HZcdPzsjP3DVrOYEcecNGf20w/Otf3s9zGWTCLk7paYz/5NwNZngIPPBkKthfcvxq8vMW/f/R/m7c4XzXJHKzBTSmHX0C5sDofMbJgRwMaAgc2twJa2WYht/wOw/Q8AgCajCbPbZuOQSBRnDQ5h9ru/izm/vwJzYnF0JZOQ9/4XcOyH8R18x5+xExERETW4ugnSbnzkTTy+YQ9OmjcB5y6ygrQcNXdem/O1vxcBLlesbQQAACAASURBVD5hFh59fTfuXb8LQP75bk4xa06agtnKfVJrCJoA/3bBkfjq718q6hh+agulg9FYQiFoaIhbzVM6mwJYffUyfPDHf8Hnli4o+pipddIkPTct31y8WnG30rfXTTt8WptnJrTTajBi7weYpbJ+mtKeWe4I5M4A57TpKeAPnwQ+95x/QRrMz+xeFcPmUAibBjdiU2IXNhsKm+56Pzb3b8ZIYgSYNgUAEEwqzI7HMBdBvLOvB3MOOR+zF1+KOe1z0N3UbWapv95hHvjg9wORfzTvX9M7RlpbEhEREY0ddROkfeueVwGY87P0Ahe77q1BXUtlTbwIBCKCJXMmpIK0ojNp1hiUAg7913tw/uLpmD2hGfMmpS+mF83oKOpYfuhoDuChK9+JL/32eUQTSYQMLdXhsjmoo6M5gHu/eFpJx9Q1s8TUngNYr3Orhl1B2kvb+gAAE1u8F0GfNaEZIuZyDbaBEjNpq9/ai3ndrehu8z6Hs5GL/bkt+b2z298nysvy9UX6sLF/Y7ossX8zNk6fis0BA4MbfgJMnwIMvgxDgJkIYnbLVJw47UTMaZuD2W88gjnrfo2p8YTZRWjh0cD+9cCkY4Cpx2ee6JhLged+kbmmGgM0IiIiIt/VRZDmDJhChpbq3JgrSHNnwQotIu1ViVhskOY+12AkgYCu4eApZpD2bxcciUtP8lh3qoLmdbeiJWRgYCSe0dGytczFtN0ZIEPT6nKdtBFXK/3v3vc6gMzFrZ3CAR1T28N4YWtvalupQdrfrXoaAPDQle/Meu62y0/KeGy/j8VmaW0PvL4PywAgEc25z4HogYz5YXYwtmlgE/oifan9NNEwrWUa5iQSWDwSwZzDLsDsZ3+FOQvOwfRdr8GYMA9Y+oP0gWe+C1jzv+nHygqEjXSGMOU9NwDLv2veP/pDwPP/m70PEREREY1aXQRp+4fSF6ehQDqT9t7/fhLf/sBR+OCSWRn7u0vxnIsbe7EbisQcr4u5LqTven473nv09KzXugPF3qEogoaGia0hbPjGOakL82oLGRr2JZIZHTDzzcvLx55LZb+vhi6ll+xVgbvc0dYayv0xntHZhAdf3Z16XG6547LvPZq1zb1Aum4FzKWWit77yj4cZuhQB7bhwD4DWwa2ZAZi/Zuwd2RvxmumtkzFnLY5OGvOWZjTPgez22ZjTscczGqdhYAeSJcmTj4JGP4ZoHQgEQN01++Ke300u82+4fE7pWmAZgVvF/wQuPDGkn5OIiIiIipOfQRpg+kL55ChZXQwvOr2F7KCNHcWzDkvKB/n4s8HIpkZlc/96jnPIM1dutY7HEtl7nKty1YNAV1DLJHM6PDY3lRekDazqxnPbe5FUDcv2A1NsoLYeuAVpM3vbsm73MDH3zEPazatTT0uJZPm7HDpFbO6S2wDZcxJU0phTzSB8+ZNR/zJL2U8N6lpEma3zcZpM0/D7Oduw9yhfsz++KOY1T4bTUZTjiO6xKxSz2TMzNRlBWmu9y6ZJ5OW73VERERE5Ju6CNL2DaYzaW1hIyNIA4AXtvbi/pd34cqzDgGQnQWbnGO+kM2+nnQGd33D2aVlvUNRdDZnXsRmZ9JiBTN31WAGaSrjvShU9pnLf7xvEU4/uBuLZprZF0PX6jSTlp2huvHvj8v7mkOnZq4FNhApPpMWK5ARCwcyg3S9jHLHoWgCO5u2Ii6COU2T8YnjvoD5nfMxp30OWgIt6R3vv9687ZiXnsNWjBGrFDI2DMRHsl/r7kKprJ/ZyP87RURERESVUxdBmrPccfGszqwg7f03PoVYQuFvj5uFbb3DWeVk3e0FgjRklzv2DWdfrO85EMkK0tzn6huOImTkWQS4SoKGhmg8mRF4llvu2Boy8P7jZqYe65oUPWevmtyNQwBgUmv+f3v3PL1SMmmFAlV3uWO6bLT4IG3fYBSB4cn41P4+fPKU66DNX5b/Bcl4iUFav3m74T7zNiuT5soG25k0nUEaERERUa3Url7PYa+VSXvHwkk4+8ipWUGanS067TsP4+L/eTorUzG5LX9plp1Jc77utZ0HsvbzuoB3X6jHEipjwe1aCegaDkTiGQFBuZm07GPXZ3dHr3LHzgIlns75apqUtk5aofcg5J6TZnXJTJQwJ23fYBQSm4BP9/ZBK+Z1yRI7QI70Zj52Z8jcc9LsxiGlBIJERERE5Ku6yKTtO2AGaTdddjyChpZaryuXSDx9sX7awd1Yvmhq3v3toznnkN26elPWfu55aoD3hXot56LZmgJ6VjYw3zIEpdA1DfGkd5OOWkkmFSKO+XfzJrVgweTWgouIhxwt8mdPaC6pcUihskV3Ji1QRgv+fUNRxOxfwzzdHVMSJTY+GenLfOwOvrIyadbvgFYXfxqIiIiIGlJdXIntG4ygLWyk1pwq1DHxQCQdQFzznsMxrSPdROGI6e1Yv70/Y//Dp7cDAD5zxgLoGvDkG3uxbosrwwDggEeWxetC3bk2Vq1M7ahcOVpAk7prwe8M0ADgB5cci8OmtRd8nbOpyLzuVry4rS/P3pkKdWkM6Jmf03LmpPUMREoL0koNnrOCNFe5o3tOmn18d/BGRERERFVTF1diewejmOhoxuEud3Q74MiGuAO6P37mVHxh2cLU45PnTcSFx8wAYJa+ffndh+Zs/OFV7uh1oV4PQZozMO1qDuDqcw717di6Vn8t+N3z0crJZs6ZWFomrdB74O4qWc6ctG37hxG3Sw6LyZKVWu6435Uxds81yyp3tMbuDt6IiIiIqGpqH23AnJfjDJwKlTs6yxLdAZ2mSUYQ9anT52ddTOdaV2vAo9zR60K9Hsodp3Wk5+G965DJ+MQ75/t2bLu9fz1xz0cLlREodzUHMRJLlr2QudNXlx+Wtc0oY07a1v3D6Gy1ujgmiwnSigwymyeat3s3mLeHn2/eZpU7un7XDnqHedvSXdx5iIiIiMh3tY82YAdp6W/4DT1/kObMeNkXxk4Ba9s/nDIXpx2cfbHZYgVpFx2fuf6aZ7mjR5CmVO2zTM5mKf963uG+HrseM2nuIK2cbKbdWKXYDo/5MmJHWcsVOBlllDtu3T+E7o5W80FR5Y5FZtKcn1HNAEJWaWi+ddJEB868Fvjss0B79pqBRERERFQddRGkucsdC2XSBvJk0oB0kJcr0LAvpudOasGZh09JbT/gWEPriQ178JGf/RUxx1yoqdai2b1DJTZvqIDZE5tx4yXH4oWvn4Uun9dtM/T6W8zaXe5YSofNry4/DF9+9yGpDGqxJY/5MmJeXyToZSxmvXsggq52O0jLMa6X73QMqsggzTl3TQ+m55jl69r4xfXm8xP9y8oSERERUelqHqS9sXsAPQMRTGgtfk5aZiYte9+5k8zysbkTW7KeA9IZkpagnpEVc5ZRfvTmZ/DIaz0ZHRRPnDcBANDrsRB2LZyzaFrZa6PlE9DqbzFr90LWgRIyaf942jxc8a4FaLPeq2IzafkCVa8vEuzALVbCezcYiSMcsrKiXkGaUsBvPpx+XGwmzVkWqQWKm2PWPq24YxMRERFRRdW8u+Oy7z0GABmZtILdHZ2NQzwyGu86ZDJu/+TJOHZ2l+fr7QyJoWsZVWHOQCBqzVuKJuozk1ZJui4FOxtWW1a5YxnzAjusNdX6PRYy92IHqkfOaMdL2zI7hnqV2ZYzJ204mkAwZJX6epU7xkcyHxcdpDn20410g5A6W1qBiIiIiLLVNJPmXO8so3GIR5DmDOKcGS+vi2UAWDJ3Qs41tOw5Q7omSDqiNOd4UtscgVt3Wyj1uvEsoNXXYtZ3rtuGS36yOmObu/19MTqbzSDtp09uLGpeof0eXHnmIVnPeX3s7M/FT5/YmPOY23qHsavfDLyUUhiKJRBKBWkewWNsOPNxsY1DnEGaM5Om6iv4JiIiIqJsNQ3StvemswQTCmTS7AAJyCxXKydgOmm+2fnusKntcMYikVj2Baxzfa5ZE5rx1eWH4cZLjiv5nGOJrmklNb+otM/fti5rm7tjZzHsIO2BV3bh/pd3FdzfXivOc96jVybNChyfeGNPzmOesvIhnPjNBwGYn61EUqEpFDLnjHkFYLGhzMfFZMKSSTMYczYJsTNpipk0IiIionpXs3LHRFLh3vU7U4+bg+mheM33mdQaAjAAoPCctEL+9riZOP3gbkxuD2dk0kY8MmnOMruALvjH0+aVfL6xJlBn5Y4i6WaFP/uH47HvQHlzAu1yRwAoJlFoZ9K8m4Rk71+o4Y3bcNT8bDUFdDPb5VXuGHUHaUWUO9r7hNqBoT1m8GcHlSx3JCIiIqp7Ncuk/ezJt7Hy/15NPZ7XnW7y4ZW5mORoLOLszperpDEfEcFka35ZRrmjRybNGbjlKq0cb3RN6iqT5nTE9Ha8/7iZZb22KZBunpFrrTwne06aoWl4/7GZ59Q9PgsLJ7eiszmQcZ58hqwvAJqDupn18ix3dAVpW/5a+MB2Ri7UZt4m4g2RSRORjSLyooisE5E11rYJInK/iGywbr0nqhIRERHVkZpFHZv2pi8+3/rmcitTZvIO0tLP9xfZna8Yi2Z0AgBmdDZllDbanIFbofXbxgtD1xBPqrpYDw4AnO96sQGQ53Ecma5iMoUxR7njt96/CI99+V2p53SPrJmI4G9LCCCHo+bnuCmom63vvTJp7jlpD1yTuQaal1QmzQrSkjFg1onm/WlHFz2+MepdSqnFSqkl1uMVAB5USi0E8KD1mIiIiKiu1SRIOxCJ4xdPb0oPwhWUeQZpjjlpfvrSWQfjj585FUfP6kg1Dkkmnc1EHEFag2TSjDLW+6okZ3AVHkWQ5lTMOnD2zx/QBYauZZRL6jkC9pChIxJPFBXgDkXtTJqRJ5M26LFtKHubk13SGLYW3E7EgEOXA//0KrBgWcFxjTPnA7jFun8LgAtqOBYiIiKiotQk6thbYE6RV5Zigs8LNtsMXcOimR3WxbUZkMUcWZaIY05a42TSzJ+znjo82gJltN53OvuIqQDSWbJ87J/f/tLA+e/v9RkFgHBAQ1IVFwTaQVpLUAeMYLrdfnTQLFGMDAC/fH/2CyMD+Q9sB3uhdvO2yarwG//roCkA94nIWhG53No2RSm1w7q/E8AU94tE5HIRWSMia3p6eqo1ViIiIqKcahKkOeeB/fQjS7KezzUn7RsXHlmxMYUMLdUkxHmB7cykBRosk1YvQZqfofFVZ5vt9IsJ0r74a7OrpJ1BdWbxcnUVDRnmPl7LObilGocEdTOQGt5vPvHN6cBtFwP/kaN0slCQZpc7JiLm7bSjCo5lnDhVKXUsgHMAXCEipzmfVGZ6M+tDrZRapZRaopRa0t3dXaWhEhEREeVWk6jDWUZ3xqFZX2znbHl+yYlzUo+XHTYZl5w427cxhQwtFZDFHRfwzovt8b4+ms0ORtwLSNdKGd32c7Izcf0jcfzmmS14Y3fugMfOdNkZNOe/f67PQjhgHn/EowmN26A1J605aADNk4BBR+v+Dfdl7jzv9PT9SObC2lnsxiEHnQZMXAiceW3BsYwHSqlt1u1uAL8HcAKAXSIyDQCs2921GyERERFRcWrSgj9ZYL6O1/Wvu9TwfcfOxPJF/pVvhQJ6qkmIM5M27GrB3wjszocDI/GMhi21IhB4JEDKEjTMIOrb97yaWsrhT589FUfO6MjYz/lFgtcyD35k0nqHzGCqoykANE8Etqw2Sx29LP0a8NYj5v2CmTTr3K1Tgc+uKTiO8UBEWgBoSqkB6/5ZAK4FcBeAywCstG7vrN0oiYiIiIpTo3LH/M97LVTsbtoxmi5/XsxMmtnwwVkKd8C5Jtso50ONFW1hs0HGAR+7aNYLO5PmXGtvR585F+ylbX346M3PIBJPZGQRvQKynEGalUnrH45jKBrHl3/7PPYPes/B7B0yt3c2W0Fa9ADw8/O9Bx5yBJHFljvqRX4H86HfAJ94rLh969cUAE+IyPMA/grgbqXUPTCDszNFZAOAZdZjIiIiorpWk0xaOfkodybNvhj2SzigI6nMeVjONcIGIqNbOHssagvbmTSPboO14Gu5Y/bB7H/Wq25/AS/v6Mcv/rIJdzy7zfGa7M9ars+CnUlbfsPjuOY9h+O3a7eiLRzA195zeNa++4diaA7qZnmpHXhtfSb7oEu/BgSa0o+LbRyiFfnrffC7i9uvjiml3gKQtb6AUmovgKXVHxERERFR+WoSpBWrPWyk1kRzN+3wqxW7LWTYc4kSGd0dBzIyaY0RpNnljn6uR1eul7f3I+qxfl25vAIue+6ZncD997tfyXjeK2um5enuaLNLJlWOUs39Q1F0NVtdS1smWls9Sju75prrqNkKBWl2yWSwJf9+RERERFSXfAnSRORsANcD0AH8RCmVt6SomNlFv/3kyZg7sQXHf+MBANkBUiXKHQGz4UOucsdGaRzSbpc7RmofpH3zz+mA6Z0Hj77zXtAjSLMD8VwNSryyZoUyaQAwGDGDv1wBXe9QzCx1BIB3rgCevB7oPhToyQwSYYQzs2J2F8hc7CDObsFPRFU1d8XdFTnuxpXnVuS4RERUf0ZdMygiOoAfwGx7fTiAi0Uku7bLoZiFfo+fOwHdjgWs3RfFfmfSmoLmRfBwNJFR7pjROKRBWvDXU7njvG4zG3T2EVPxo78/btTHcy+cDhT+OT0zaTmCNOfmbb1DGdvczUT2DToyacFmYPIR3p0bjTCgOT7vB3blHW/qGAzSiIiIiMYkP6KOEwC8oZR6SykVBXAbgBzdD0z2+lt2MFAMd9OOsM9z0uyx9I/Ecq6h1TDljuF0d8das8sTf3DJseZ6YhXQbwVpuX5eZ3asEGdXyI177CDN/Nwsuiazrf7ASAztTY7fAd0ARvqyDxpoAjRHueNAoSDNzqS1FT1uIiIiIqoffkQ6MwBscTzeam3LICKXi8gaEVkDAO85ejqeuOqMok/izqT5Xe7Y5ghMci3i7O4wOV4FdA3hgFYX5Y7ReBJdzYGKlprawdlgJI6ZXU0Zz912+Umptv3FOHn+RHxx2cEAgL9u3GdutIYedQT/SilE4kmEnQGgFjA7PLoZocxyx6IzaQzSiIiIiMaiqkUdSqlVSqklSqklADC9M4yO5kChl6W4s1h+lzu2hdLzsGI5GlU0SiYNMNvw10O5YzSeLClIKtXMrqZUkBaJJ3Hm4VPQFkoHRO7P2Q0XH4Olh07OeTwRweeXLczY9uNH30q127cllcfPpuf4fTCazOdOuwqYcmQRQdoAAAGCrfn3IyIiIqK65MfV7zYAsxyPZ1rb8vJq4JCPO4sV8vnC3TkPK5Yzk9ZAQVrIqIvujtFEZYO0iS1B7B2M4rdrtmBgJG5+Lh3/zO6y2vcePR03feT4gse9/qLFGY9vfOTNjMexRBKReDLzc5yrZX4gbHY1OeOrwPwzgAO78588MmBm0Rok80tEREQ03vhxFfcMgIUicpCIBAFcBOCuQi/yaoWef//MAMlrwevRsIO0rfuH8afnt2c8d/K8ibj+osW+n7OetYWNuljMOhpPlhzQl6K7LYQ9AxF8+fYXAABBQ8tYli1cwnw0p/MXZ1b8ugPeeFIhEk8g5MzU5QrSDEcJZrgDSESAeCT3ySP9LHUkIqoDIvJTEdktIi85tn1dRLaJyDrrv+W1HCMR1adRt+BXSsVF5DMA7oXZgv+nSqn1BU9cYumgPSfpzitOwZpNBVqQl6HNajv/vftfz3ruoO6WrIvu8a5eyh0j8QSCZQZKxZjUGsLzW9PNOgK6ltG50a+y2kgss7Nj3CuTlqvc0Rm82R0bIwfMuWpehnvZ2ZGIqD7cDOC/Afzctf06pdR3qz8cIhorfFknTSn1ZwB/LuU1pWZH7Mzb0bM6cfSszpJeW9R4DA0hQ0PEYz7a2o3+B4X1ri1sYFf/SK2HkR3I+OjcRdPQ3RbC3gPprJQ7k+ZX8rTfFfCOxJJQyvV7oOUI0sId6ft2hizS51gA232ybUBHY32pQERUj5RSj4nI3FqPg4jGHl+CtHIUW+4Y0AWxhKrKQtJtYQORA9Gs7Z9butBj7/GtNWTUTXdHv+ekXXX2IehoCuCSE+fg53/ZCOcUxKCupVrmHzylFZPbcmSrivCLj52AS2/6KwBgV39meaL93oacc950j1/HT68GjGD6cSpIG8h94t7NwPRjyhozjW+VWmSZiEr2GRH5MIA1AK5USnl+GywilwO4HABmz55dxeERUa3VrLNAseWOf7jiFHzujAUlz2ErR67s3rlHTav4ueuNWe5YB0Fawv9M2qdPX4BLTpwDAOhoysxeBQwtlT372nlHjGoe4jsWdqfu73d1dxyKWkGauwW/mzNAAwoHaZEDwNBeoJP/MyciqlM3ApgPYDGAHQD+M9eOzs7Y3d3duXYjonGoZkFasUHXEdM78E9nHVLh0ZgaqTFIIZqY2Z5bntpY03FUunGIe6HqkK6lPgfuZjXluPtzp+LY2Z3oHcosdxyMmHPUgoW6O+quTF6hIK3faqzaPrOc4RIRUYUppXYppRJKqSSA/wFwQq3HRET1p2ZBWiUvvMvFjuVpi2eb8/5uXb2pZmO44AdPYv32/oq24A+5WuwHDEnNSfPjvEdM78Dph0zOKh0dtMsdjQLlju7ALdU4JEeQZi+GHWbjECKieiQizvKcCwG8lGtfImpcNZuTVo05ZqWy5yLpmiCRY620RnHeUdOx+q19uOPZrUgkqzMn0G3dll4A/gRLuYRcXxYEdT31OfCrxLarJZi1bbDYcsdAOPNxKpPW732y6JD1uibv54mIqGpE5FcATgcwSUS2ArgGwOkishiAArARwCdqNkAiqls1C9LqMQSyL85XXXocpnU04bv3vYbzF0+v8ahqZ2ZXE4aiCUTiCTQHa/ZRqVh3RyA7kxZ0zEnz67xdzdnB11A0kX0Odwv+876f2dkRSD8e2ud9stiweRtoKWeoRETkI6XUxR6bb6r6QIhozKldkKbqL0yzc0UTWoI4fHo7fvqR42s6nlqzM0mxuAKyk0HjgntOWkAX3zNpE5qz37y39wwCcM9JcwVpXXOzDxYIAy3dQN8W75PFBq39mEkjIiIiGqtqNgsrWY9BmhWl1TJrVE/sxhmxZPbacZXmDOJf3JajtM8H7lJK52O/Sjy7Pdr4P75hDwBXJk1zLZyda7HqjllAb64gzc6kMUgjIiIiGqtqF6RV/7q/oKCVVWGTR1Mqk5ao/j+Wc0rgtI5w7h1HyV3SGHKUO/r1RcLk9uzxv7LDDDxDAUdg5i531HOkLztn58mkWXPSgix3JCIiIhqrahak1V8eDfjBh47Bh0+eg/ndrbUeSl0wrCAtnqj+v5bduGX5oqm47oOLK3Yed7mjrmn4krXkw+Q2f4LD9rCRc35bRpdTcWXScgVp7TOA/h3ez7FxCBEREdGYV7O6vnpMVs3rbsW15x9Z62HUDbvcMVqTTJoZpB05owMdHo03/OLVOfKCY2bggmNm+HYOEcHk9hC27BvOei6jcYndPt/mtW4aAASbzYyZUtlp31S5Y/MoRkxERERUe3NX3F2R425ceW5FjuunmmTSJrQEcd7R0wrvSDUVqINMml7h2lN3hqtScyUntpjzy05ZMBHvWDjJ+/wjrrl37jlqNiMEQAGJWPZzsUFzAexcryUiIiKiuleTIG1GZ1NWmRnVn1rOSUtYwVKl12er5BpsXuf5m/mTMkocM84f6ct8keQYm2GVMsazM3OIDbPUkYiIiGiMq9mcNKp/ht3dsRbljlYmTatwJs1wBIEfP/UgHD2zs6Ln0UQyWvtnfFnhzqTlCtLsBa5jI9nPRYcatmmIiOgi8pyI/Ml6fJCIrBaRN0Tk1yIyTheSICIiovGGQRrlZGd84skaljtWOJMmjiDwX847vGLns49raIKA4QzSHL+CXXPM2/OuA2afbHZx9JI3kzYEGJXrhlnnPg/gFcfjbwG4Tim1AMB+AB+ryaiIiIiISsQgjXKysz+xeO1a8GsVDtKqxc4IapqkGrIAriDt7G8Bl/4BWPJR4KP3ZLfkt+XLpCXjubtCjmMiMhPAuQB+Yj0WAGcAuN3a5RYAF9RmdERERESlYZBGOdkZn1gNMml2A49xEqOlMmm6pDOUQV3LyOQh2AzMf1fhg+XLpCUTjdo05PsArgJgf6MwEUCvUipuPd4KwLNlp4hcLiJrRGRNT09P5UdKREREVACDNMopoFlBWg0yadXq7mirdAORVJCma6lz5Vo7rSDD7BTpmUlTjRekich5AHYrpdaW83ql1Cql1BKl1JLu7m6fR0dERERUupqtk0b1z24cEk/WLkirRrnjI186Ha3hyv4qGKlMWrpxSMYaaaUI5MukxXOvrzZ+nQLgvSKyHEAYQDuA6wF0iohhZdNmAthWwzESERERFY2ZNMrJDiaiNVgnzS53rEYmbe6kFkxqDVX0HJqzcYij3LEsRoE5adJYmTSl1NVKqZlKqbkALgLwkFLqEgAPA/iAtdtlAO6s0RCJiIiIStJwX7lT8ewGF/FarJNWpe6O1ZJqwa8Jgtb7WnaJpZ1JG94HfGchcMGNwMJl5rZkohEzabn8M4DbROTfATwH4KYaj4eIiKiguSvurshxN648tyLHpcrg1RzlVMvFrFONQ8ZJkObMCNrva9kBqJ1J2/kSMLgbeOAaV5DWWJk0J6XUIwAese6/BeCEWo6HiIiIqBwsd6Sc0otZ16Lc0bytVuOQSrODzWRSpbpmSrk/W9acNMdxkvGGDtKIiIiIxgMGaZRTsIaZtFTjkPERo6WCzYRSqUxa2T9boNm8XXuzeauSQDxq3We5IxEREdFYxyCNcjKsYCJeg0xaNbs7VoNuZSUTSZWak6aVm0kLt2c+3r0e+HerdXxjdnckIiIiGlcYpFFOduOQaA3npI2XcsdUJi2ZzqRVRDLRcN0diYiIiMYbBmmUk72YdS0zaeOlu6P9cySSKtXVsbM5UP4BBgZ1/gAAIABJREFUP/G49/YGbxxCRERENB4wSKOcNE2ga4K1m/dX/dzjrrujI0gbGIkDAA6a1FL+Aacd5b2d5Y5EREREYx6DNMrrb+ZPxGOv9yAar27Jo11hOW7KHbV045C9g2aTjwWT2/w9iVLs7khEREQ0DvArd8rr1AWT8PiGPYgnkwhWMaZPNw6p2ikryplJ+9gpB2EklsAlJ8729ySv3wvsfxuYfZK/xyUiIqIxr1KLZFNljCpIE5HvAHgPgCiANwH8g1Kq14+BUX0wUm34qzsvTdnljuMkk/bJ0+ZjZ98IPnzyHLSFA/jK8sP8P8mv/s68ZSaNiIiIaEwbbZ7ifgBHKqWOAvA6gKtHPySqJ8HUgtZVLndU46txSEdzANf93WK0hUfRLKRY7O5IRERENKaNKkhTSt2nlIpbD58GMHP0Q6J6Uqu10tKLWY+PIK2q2DiEiIiIaEzzc8bPRwH8X64nReRyEVkjImt6enp8PC1VUiBV7ljdTFpynGXSqopBGhEREdGYVjBIE5EHROQlj//Od+zzVQBxALfmOo5SapVSaolSakl3d7c/o6eKCzjKHe3sVjWMt+6OVcU5aURERERjWsGv3JVSy/I9LyIfAXAegKXK7vZA44ZhtVfccyCKM/7zUXzzwkX4kN9dCT18/a71AMZPd8eqEr5pRERERGPZqK7mRORsAFcBeK9SasifIVE9sTNptz2zGQDwfy/tqMp5t/UOA2C5Y1n4XQkRERHRmDbar9z/G0AbgPtFZJ2I/MiHMVEdseekvbStDwAwpT2ceq5vKIaNewYren6WO5ZBJWo9AiIiIiIahVF1GFBKLfBrIFSfDCuT9rYVjO0fjKaeW37D49jWO4yNK8/19ZzOuW/CIC23tmnAgEdmM8kgjYiIiGgs4+QVyivgWsx6/1A6SLNLEgFgJJbAFf/7LDbvHX3VazSe7iTJcsc8PvkkMO3o7O3MpBERERGNaQzSKC97Tppt/1DMc7+/vLkXd7+wA1+766VRnzMjSGMmLbeWid5BGjNpRERERGMagzTKy3C1V9znKHfMYMVSfnTpjyTSQQa7OxYwYV72NmbSiIiIiMY0XgJTXna5IwDM725B33AMByLxrP3sfJcfqzDYpZUAyx0L6j40e1uyuguPExEREZG/GKRRXs5yx+PmdAEA3tx9IGOfZFJB87EskeWOJViwDDjuI8CJn0xvYyaNiIiIaExjkEZ5GY5M2pI5EwAAb7iCtHhSIWFl0PxYossZpGnMpOWnB4D3XA9MOSK9jXPSiIiIiMY0BmmUlzOTtmhmB0SATfsyOzjGk8lUYJX0IUrLCNKYSSuOHkrfb8BMmoiEReSvIvK8iKwXkf9nbT9IRFaLyBsi8msRCdZ6rETUOETkpyKyW0RecmybICL3i8gG67arlmMkovrEII3ycs5Jm9QawsSWEHoGRjL2iSVUKrDyJZOWcAZpoz9eQzAcsUdjZtIiAM5QSh0NYDGAs0XkJADfAnCdtabjfgAfq+EYiajx3AzgbNe2FQAeVEotBPCg9ZiIKAODNMrLcERJHU0BTG4LYVd/JGOfeCKJiB2kwd9Mmh9BX0PQHOvSq8ZrHKJMdh1uwPpPATgDwO3W9lsAXFCD4RFRg1JKPQZgn2vz+TD/HgH8u0REOTBIo7wCRvojEjQ0TGkPYbcrkxZPViaTdvEJs9DVwuq0oojjV9kZsDUQEdFFZB2A3QDuB/AmgF6llN2OdCuAGR6vu1xE1ojImp6enuoNmIga1RSl1A7r/k4AU3LtyL9PRI2LQRrlFXAtVDalPYydfZmZtOFoAl/5/YsA/G0c8qET5oz+YI3CGaSd+5+1G0cNKaUSSqnFAGYCOAGAx/oEnq9bpZRaopRa0t3dXdExEhE5KXPdmpz/5+TfJ6LGxSCN8jL0zElhXS1B9A1nLmi9+u29qft+ljsGDE5IK5odpC04E2iZVNux1JhSqhfAwwBOBtApInZqcSaAbTUbGBGRaZeITAMA63Z3jcdDRHWIQRrlZc9J624zuwe2hgzEEgqReLo5haPPhy+ZtJh1wKDOj2fRRDdvG3A+GgCISLeIdFr3mwCcCeAVmMHaB6zdLgNwZ21GSESUchfMv0cA/y4RUQ6NOXmFiiYi+MmHl2DRzA4AQHPQDAY+96vnUvsciMRS92NJ/zJpQYNBWtEMqwV/sLm246idaQBuEREd5pdPv1FK/UlEXgZwm4j8O4DnANxUy0ESUWMRkV8BOB3AJBHZCuAaACsB/EZEPgZgE4AP1m6ERFSvGKRRQcsOT89pbgmZH5l71+9Kbds3mA7SIrHRt3+PJBiklWzOKcAZ/wIc99Faj6QmlFIvADjGY/tbMOenERFVnVLq4hxPLa3qQIhozGGQRiVpDWV/ZPYPpueobd0/jIGRGNrCgbLPYWfSQrpe9jEajqYBp3251qMgIiIiIh8wVUElafEI0n69Zkvq/oFIHE9s2DOqc4xY2bhQgB9PIiIiImo8vAqmkrQEC2e3IvHRNa8YiSUgAoRY7khEREREDYhXwVQSr0ya7YaLzSlBscTogrThaAJNAR0ibMFPRERERI2HQRqVxGtOGgBM7wjj+LldAIDEKDs8jsTNII2IiIiIqBExSKOSNOcodzR0Dbq1plp8lEHacDSJMIM0IiIiImpQDNKoJF3NQc/tuiYwNPPjNOpMWiyBMJuGEBEREVGDYgt+KommCVa+bxFW/O7FzO2CVCZttHPSRmIJNBXRoISIqJHMXXF3xY69ceW5FTs2ERGVjukKKlmnRzZN1wQB3QzSRptJG44lEDYYpBERERFRY2KQRiXras5eqFoT8W9OGjNpRERERNTAGKRRyVrD2VWyhu7fnLThaIKNQ4iIiIioYTFIo5J5ljtamTQRID7KOWmReJIt+ImIiIioYTFIo5LN6GzCp06fDwBot7JqR87oAAAYmvjQgp/dHYmIiIiocfFKmMry7iOmAgDmTmrBry8/CV97z+EAzAYivjQOYSaNiIiIiBqULy34ReRKAN8F0K2U2uPHMam+WT1CkFQKJ86bmNpuaNqoM2mxRBIhg98fEBER0ehUcukKokoa9ZWwiMwCcBaAzaMfDo0Vmtjt9jO3G7qMek5aNJ5EQGeQRkRERESNyY8r4esAXAVgdOkTGlPsdvtJV9ZstHPSkkmFeFIxSCMiIiKihjWqK2EROR/ANqXU8z6Nh8aI2ROaAQCfOWNBxvbRzkmLJc0sXJDljkRERETUoArOSRORBwBM9XjqqwC+ArPUsSARuRzA5QAwe/bsEoZI9aglZGDjynOzthuahlii/CAtGreCNGbSiIiIiKhBFQzSlFLLvLaLyCIABwF4Xsz5STMBPCsiJyildnocZxWAVQCwZMkSlkaOU4YuSCTLn5NmB3gBXfwaEhERERHRmFJ2d0el1IsAJtuPRWQjgCXs7tjY9FHOSYsl7HJHtuAnIiIiosbEmjLylTHKOWl2uSMzaURERETUqHxZJw0AlFJz/ToWjV36KOakKaXQOxQDwMYhRERERNS4eCVMvgqMYk7ajx59C+/57ycAsHEIFU9EZonIwyLysoisF5HPW9sniMj9IrLBuu2q9ViJiIiIisErYfLVaOak/fH57an7XCeNShAHcKVS6nAAJwG4QkQOB7ACwINKqYUAHrQeExEREdU9XgmTr0YzJ00c09BY7kjFUkrtUEo9a90fAPAKgBkAzgdwi7XbLQAuqM0IiYiIiErDK2Hyla4J4qNYJ83GTBqVQ0TmAjgGwGoAU5RSO6yndgKYkuM1l4vIGhFZ09PTU5VxEhEREeXDK2HyVUDX8NeN+7DijhdKet2ajfuwZd9Q6nHQYHdHKo2ItAK4A8AXlFL9zueUUgqA57cHSqlVSqklSqkl3d3dVRgpERERUX4M0shXumYGV7c9s6Wk133gR39B/0g89Tioc500Kp6IBGAGaLcqpX5nbd4lItOs56cB2F2r8RERERGVgkEa+cpe52y0AsykUZFERADcBOAVpdT3HE/dBeAy6/5lAO6s9tiIiIiIyuHbOmlEAPDUm3tT95VSECkv2OKcNCrBKQAuBfCiiKyztn0FwEoAvxGRjwHYBOCDNRofERERUUkYpJGvvrL8UHzzz68CAIZjCTQHy/uIcZ00KpZS6gkAub4NWFrNsRARERH5gVfC5KvLT5uPb164CADQPxwvsHdubMFPRERERI2KmTTyXXuT+bHqH4lhake44P5m471MIQZp1MDmrri71kMgIiKiGuKVMPmuLRwAAAyMxIra32vxa/sYRERERESNpm4yabFYDFu3bsXIyEith9IQ/n979x5eVX3ne/z9zQUiEJBbrYBKRmnxAiGKOBqZcrGgI2L1CGprp7SdB0aoxRuHMIgKIxwsOu0cq3C0cvCC7QGrWIWROFWa+jAFJFyMDRLQVAJWEAoSlFzge/7YKyGBJASy9147yef1PDzstdZvrfVdi+XP/d2/y0pLS6NXr16kpkY/GeqYFnmsDnzVuCStoo6XX1dN5S8iIiIi0tokTJJWUlJCeno6vXv3Pu0ZAaVx3J29e/dSUlJCRkZG1I+flhp5x1lZReOm4684Gp1p+0VEREREWoKE6e54+PBhunbtqgQtDsyMrl27xqzVMjU58m9YUUc3xrpUROndaiIiIiIiLUHCJGmAErQ4iuW9TkmKPFaNTb4qG5nMiYiIiIi0BgnT3VFajpSgJa2ykd0Yy9WSJiIirYyZFQMHgSNApbsPDDciEUkkStIk6qpeRF3XhCB1qTiiJE1ERFqloe7+edhBiEjiSajujmHav38/Tz31FAC7du3illtuCTmi+l111VVhh9CglCBJq2xk8nV8d8fXf3J11GMSEREREWku1JIWqErSJk6cSI8ePXj55ZfDDukElZWVpKSksHr16rBDadCx7o6Na0mr2d3x1oHn0K9Xp5jEJSIikkAcyDUzB/6Puz99fAEzGw+MBzj33HPjHF589c5ZHnYI0orE8nkrnnt9VI6TkEnazNc/4M+7vojqMS/q0ZGHbri43u05OTls376dAQMG0KdPHwoLCykoKGDRokUsW7aMQ4cOUVRUxP333095eTkvvPACbdu2ZcWKFXTp0oXt27czadIk9uzZQ7t27XjmmWfo27dvnedaunQpM2fOJDk5mU6dOpGXl8eRI0fIyclh1apVlJWVMWnSJCZMmMCqVauYMWMGnTt3ZsuWLWzdupUOHTpQWloKwLx581iyZAllZWXcdNNNzJw5k0OHDjF27FhKSko4cuQIM2bM4NZbb43q/WxIatKpdXesmcx1SEvIR1JERCTarnb3nWb2NeAtM9vi7nk1CwSJ29MAAwcO1CxbIq2IvhEH5s6dS0FBARs3bqS4uJhRo0ZVbysoKGDDhg0cPnyYCy64gEcffZQNGzZwzz338Pzzz3P33Xczfvx4FixYQJ8+fVizZg0TJ07k7bffrvNcs2bNYuXKlfTs2ZP9+/cD8Oyzz9KpUyfWrVtHWVkZ2dnZjBgxAoD8/HwKCgpOeKdZbm4uRUVFrF27Fndn9OjR5OXlsWfPHnr06MHy5ZFfCQ4cOBCLW1av6pa0oLvjpwe+YtzCdSz60eWc3emME8rXHJOWriRNRERaAXffGfy928xeBQYBeQ3vJSKtRUJ+I26oxSsMQ4cOJT09nfT0dDp16sQNN9wAQL9+/di8eTOlpaWsXr2aMWPGVO9TVlZW7/Gys7MZN24cY8eO5eabbwYiCdfmzZuru1keOHCAoqIi2rRpw6BBg+p86XRubi65ublkZWUBUFpaSlFREYMHD+a+++5j6tSpjBo1isGDB0ftXjRGSlLt96T9es0nfPjZQf7fuh3cfc03TihfO0lLjU+QIiIiITGz9kCSux8MPo8AZoUclogkkIRM0hJN27Ztqz8nJSVVLyclJVFZWcnRo0c588wz2bhxY6OOt2DBAtasWcPy5cu57LLLWL9+Pe7OE088wciRI2uVXbVqFe3bt6/zOO7OtGnTmDBhwgnb8vPzWbFiBQ888ADDhw/nwQcfbOzlNpmZkZJk1S1pVf0zjLrfzVazW2T7NsmxDk9ERCRsZwGvBu8sTQFecvc3ww1JRBKJZncMpKenc/DgwdPat2PHjmRkZLB06VIgkjxt2rSp3vLbt2/niiuuYNasWXTv3p0dO3YwcuRI5s+fT0VFBQBbt27l0KFDDZ535MiRLFy4sHp82s6dO9m9eze7du2iXbt23HHHHUyZMoX8/PzTuq6mSEm26hayox5JwpLqeX92zVkg01KVpImISMvm7h+5e2bw52J3nx12TCKSWNSSFujatSvZ2dlccsklXHjhhae8/+LFi7nzzjt55JFHqKio4LbbbiMzM7POslOmTKGoqAh3Z/jw4WRmZtK/f3+Ki4u59NJLcXe6d+/OsmXLGjzniBEjKCws5MorrwSgQ4cOvPjii2zbto0pU6aQlJREamoq8+fPP+XraarUpKTqFrKqeUGsniStQkmaiIiIiEg1JWk1vPTSSyesGzduHOPGjateLi4urnNbRkYGb77ZuJ4Kr7zyygnrzIw5c+YwZ86cWuuHDBnCkCFDaq2rajkDmDx5MpMnT661/fzzzz+h22S8paYkUXk06O5YnaSdvLvjGeruKCIiIiKtnLo7SkxExqRFki8PRqU1qiUtRY+kiIiIiLRuakmLodmzZ1ePU6syZswYpk+fHlJE8ZOafKy7Y1VLWlI9Wdq+Q+UAjLz4LC47r3Nc4hMRERERSVRK0mJo+vTprSIhq0tKstXo7hi0pNVTdse+L0lPS2HBHZfV2yVSREREGqd3zvKwQxCRJmpy3zIzu8vMtpjZB2b2s2gEJc1fre6OJ5k45C/7vuTcLu2UoImIiIiI0MSWNDMbCtwIZLp7mZl9LTphSXMX6e5Y+z1p9XV33LHvS/p8LT1OkYmIiIiIJLamtqTdCcx19zIAd9/d9JCkJajrPWn1+bL8CB3PUM9bOX1mttDMdptZQY11XczsLTMrCv7WgEcRERFpFpqapH0DGGxma8zsD2Z2eX0FzWy8mb1nZu/t2bOniaeVRJeSlETl0drdHWtOtV9TeeVR2mhWR2maRcC1x63LAX7v7n2A3wfLIiIiIgnvpN+Mzey/zKygjj83Euku2QX4e2AKsMTqGVjk7k+7+0B3H9i9e/eoXkQ07N+/n6eeegqAXbt2ccstt4QcUf2uuuqqsEM4qTY1ujtWqTxuuUp55VHaJOv9aHL63D0P2Hfc6huB54LPzwHfiWtQIiIiIqfppEmau1/j7pfU8ec1oAR4xSPWAkeBbrEOOhZqJmk9evTg5ZdfDjmiE1VWVgKwevXqkCM5uZTkYxOHVHV3rGpZq+mZvI84WFapljSJhbPc/dPg81+Bs+oqpFZ+ERERSTRNHQi0DBgKvGNm3wDaAJ83Oar/zIG/vt/kw9Ty9X5w3dx6N+fk5LB9+3YGDBhAnz59KCwspKCggEWLFrFs2TIOHTpEUVER999/P+Xl5bzwwgu0bduWFStW0KVLF7Zv386kSZPYs2cP7dq145lnnqFv3751nmvp0qXMnDmT5ORkOnXqRF5eHkeOHCEnJ4dVq1ZRVlbGpEmTmDBhAqtWrWLGjBl07tyZLVu2sHXrVjp06EBpaSkA8+bNY8mSJZSVlXHTTTcxc+ZMDh06xNixYykpKeHIkSPMmDGDW2+9Nbr38yRSkpM4VH4EOPay6qop+WuavaIQgDbJmtlRYsfd3czq7G/r7k8DTwMMHDiw4QGUIiIiInHQ1CRtIbAwGKxfDvzA/SSzRCSouXPnUlBQwMaNGykuLmbUqFHV2woKCtiwYQOHDx/mggsu4NFHH2XDhg3cc889PP/889x9992MHz+eBQsW0KdPH9asWcPEiRN5++236zzXrFmzWLlyJT179mT//v0APPvss3Tq1Il169ZRVlZGdnY2I0aMACA/P5+CggIyMjJqHSc3N5eioiLWrl2LuzN69Gjy8vLYs2cPPXr0YPnyyHtSDhw4EItb1qA2yUmUVUSStPLKoCXtuDFpr+SXHCuvljSJvs/M7Gx3/9TMzgY0sZGIiIg0C01K0ty9HLgjSrEc00CLVxiGDh1Keno66enpdOrUiRtuuAGAfv36sXnzZkpLS1m9ejVjxoyp3qesrKze42VnZzNu3DjGjh3LzTffDEQSrs2bN1d3szxw4ABFRUW0adOGQYMGnZCgVe2Tm5tLVlYWAKWlpRQVFTF48GDuu+8+pk6dyqhRoxg8eHDU7kVjdU9vw8YdfwOOtaQdP3HIvUs2VX9WkiYx8DvgB8Dc4O/Xwg1HJHHF6uXHxXOvj8lxRURaOs173ght27at/pyUlFS9nJSURGVlJUePHuXMM89k48aNjTreggULWLNmDcuXL+eyyy5j/fr1uDtPPPEEI0eOrFV21apVtG/fvs7juDvTpk1jwoQJJ2zLz89nxYoVPPDAAwwfPpwHH3ywsZcbFd3T09h7qJzKI0erk7S/fVlevf3IcePT2iQrSZPTZ2a/BoYA3cysBHiISHK2xMx+DPwFGBtehCIiIiKNp2/GgfT0dA4ePHha+3bs2JGMjAyWLl0KRJKnTZs21Vt++/btXHHFFcyaNYvu3buzY8cORo4cyfz586moqABg69atHDp0qMHzjhw5koULF1aPT9u5cye7d+9m165dtGvXjjvuuIMpU6aQn59/WtfVFGd1bIs7fF5aXp2kvbphJ2s+2gvA56W1WxrbpGh2Rzl97n67u5/t7qnu3svdn3X3ve4+3N37BBMgHT/7o4iIiEhCUktaoGvXrmRnZ3PJJZdw4YUXnvL+ixcv5s477+SRRx6hoqKC2267jczMzDrLTpkyhaKiItyd4cOHk5mZSf/+/SkuLubSSy/F3enevTvLli1r8JwjRoygsLCQK6+8EoAOHTrw4osvsm3bNqZMmUJSUhKpqanMnz//lK+nqc5KTwPgsy8OU16jm+PmkgNc8Xdd+fTA4Vrl1d1RRERERCRCSVoNL7300gnrxo0bx7hx46qXi4uL69yWkZHBm2++2ajzvPLKKyesMzPmzJnDnDlzaq0fMmQIQ4YMqbWuquUMYPLkyUyePLnW9vPPP/+EbpPx1i090iX089IyviqvrF5flYzt2PdlrfKpmt1RRERERARQd0eJkfZtIt0XS8sq+fOuL6rXtw2StPV/+Vut8m3VkiYiIiIiAqglLaZmz55dPU6typgxY5g+fXpIEcXPGUGStnHH/ur3pQEkJ0VazDbs2F+rvLo7ioiIiIhEKEmLoenTp7eKhKwu7dpEHq0Nn9ROxsoqj/J+yQE2HZ+kJWviEGl+YjVtuUhLoan9RUROj5ovJCba1WhJq+lwxRFu+OW7J5RP0pMoIiIiIgIoSZMYqW+MWVnl0TrXu9e5WkRERESk1VGSJjFhdmy2xruGXVD9+XDFsfFpPx3eh/S0SLfI419uLSIiIiLSWilJqyE5OZkBAwZU/6k53X6YiouL63w9QHNx26Bz2fTQCAAOHj42HX/HtBSyzu0MwFE1pYmIiIiIAJo4pJYzzjiDjRs3nvJ+lZWVpKTE7lZWJWnf/e53Y3aOWDrzjFTat02hc7tUdh889hLrdm1S+F839+MXb23lqvO7hRihiIiIiEjiUEvaSRw+fJgf/vCH9OvXj6ysLN555x0AFi1axOjRoxk2bBjDhw8HYN68eVx++eX079+fhx56qPoYzz//PP379yczM5Pvf//7ALz++utcccUVZGVlcc011/DZZ58B8Ic//KG6JS8rK4uDBw+Sk5PDH//4RwYMGMDPf/7zON+BpquaRCQtNZm/Hjhca33PM89g3phMTcEvIiIiIhJIyJa0R9c+ypZ9W6J6zL5d+jJ10NQGy3z11VcMGDAAgIyMDF599VWefPJJzIz333+fLVu2MGLECLZu3QpAfn4+mzdvpkuXLuTm5lJUVMTatWtxd0aPHk1eXh5du3blkUceYfXq1XTr1o19+/YBcPXVV/OnP/0JM+NXv/oVP/vZz3j88cd57LHHePLJJ8nOzqa0tJS0tDTmzp3LY489xhtvvBHVexIvVePT0lKT+eyLspCjERERERFJbAmZpIWlru6O7777LnfddRcAffv25bzzzqtO0r797W/TpUsXAHJzc8nNzSUrKwuA0tJSioqK2LRpE2PGjKFbt0h3vqryJSUl3HrrrXz66aeUl5eTkZEBQHZ2Nvfeey/f+973uPnmm+nVq1fsLzxOPv78UK1ljUMTERERETlRQiZpJ2vxShTt27ev/uzuTJs2jQkTJtQq88QTT9S571133cW9997L6NGjWbVqFQ8//DAAOTk5XH/99axYsYLs7GxWrlwZs/hjLee6vvzty/Lq5TYpSZTXmIK/bYpeYC0iIiIicjwNBDqJwYMHs3jxYgC2bt3KJ598wje/+c0Tyo0cOZKFCxdSWloKwM6dO9m9ezfDhg1j6dKl7N27F6C6u+OBAwfo2bMnAM8991z1cbZv306/fv2YOnUql19+OVu2bCE9PZ2DBw/G9Dpj4V++dT7Trruwevmte/6BB66/kAV3XMrUa/ty7SVfDzE6EREREZHElJAtaYlk4sSJ3HnnnfTr14+UlBQWLVpE27ZtTyg3YsQICgsLufLKKwHo0KEDL774IhdffDHTp0/nW9/6FsnJyWRlZbFo0SIefvhhxowZQ+fOnRk2bBgff/wxAL/4xS945513SEpK4uKLL+a6664jKSmJ5ORkMjMzGTduHPfcc09c70G0nNe1Pf88+O/CDkNEREREJKGZhzAuaODAgf7ee+/VWldYWMiFF15Yzx4SC7rnEk1mtt7dB4YdR1PUVTc1pHfO8hhGIyL1KZ57/SmVb231k+omkfCcSv3UUN2k7o4iIiIiIiIJREmaiIiIiIhIAkmoJC2Mrpetle61iIiIiEhiSpgkLS0tjb179yp5iANUs3BGAAAKS0lEQVR3Z+/evaSlpYUdioiIiIiIHCdhZnfs1asXJSUl7NmzJ+xQWoW0tLQW9aJsEREREZGWImGStNTUVDIyMsIOQ0REREREJFQJ091RRCQWzOxaM/vQzLaZWU7Y8YiIgOomEWmYkjQRabHMLBl4ErgOuAi43cwuCjcqEWntVDeJyMkoSRORlmwQsM3dP3L3cuA3wI0hxyQiorpJRBoUypi09evXl5rZh6e5eyfgQBz3A+gGfH6a+zblvM0x5qbs35SYm3Lepl5vGPc6EZ+Nb57mMWOpJ7CjxnIJcEXNAmY2HhgfLDalbmoumvrfWXPTmq631VyrPQqc2vWeF7NgTs9J6yZIqPopUZ6tRIkDEieWRIkDEieWUOMI6qcqJ4ul3roprIlDPnT3gaezo5k97e7jT14yOvsF+74X73ijsG8oMTdl/6bE3MTzNvV6436vE/HZMLP3TueYYXP3p4Gnw44jXpr631lz05qutzVdK7SO602U+ilR7nWixAGJE0uixAGJE0uixAFNi6U5dnd8Pc77NVVTztscY47G/vE+b1jxNuXcze0eh2UncE6N5V7BOhGRMKluEpEGNbskzd1P60vi6e7XVE05b3OMORr7x/u8YcXblHM3t3sconVAHzPLMLM2wG3A70KOSUREdZOINCis7o6hN92fouYWLyjmeGpucccq3oS7D+5eaWY/AVYCycBCd/8g5LDClnD/TjHWmq63NV0rNOPrbYZ1U6Lc60SJAxInlkSJAxInlkSJA5oQi7l7NAMRERERERGRJmh23R1FRERERERaMiVpIiIiIiIiCSSmSZqZlcby+NFmZt8xMzezvmHHcqpOdq/NbJWZhT4dqZn1MrPXzKzIzLab2X8Eg6brK3+3mbWLZ4z1xKFnWVoEMxtjZh+Y2dFEqBNixcyuNbMPzWybmeWEHU8smdlCM9ttZgVhxxIPZnaOmb1jZn8OnuXJYcfUWpjZfcH/W7qFGMO/mdlmM9toZrlm1iOkOOaZ2ZYgllfN7Mww4ghiCbVeT5T6NlHqwmjVUWpJq+124N3g70Yzs+TYhNOymJkBrwDL3L0P8A2gAzC7gd3uBkJP0pohPctSnwLgZiAv7EBiJXiOnwSuAy4Cbjezi8KNKqYWAdeGHUQcVQL3uftFwN8Dk1r4v29CMLNzgBHAJyGHMs/d+7v7AOAN4MGQ4ngLuMTd+wNbgWkhxQEh1usJVt8uIjHqwqjUUTFP0sysg5n93szyzex9M7sxWN/bzArN7Jkgy8w1szNiHU9DcQJXAz8mMhUuZjbEzPLMbHnwC8ECM0sKtpWa2eNmtgm4Mqy4awrifaPG8i/NbFyIIR1vGHDY3f8vgLsfAe4BfmRm7c3sMTMrCH6VusvMfgr0AN4xs3dCjBvQsywtg7sXuvuHYccRY4OAbe7+kbuXA78Bbgw5pphx9zxgX9hxxIu7f+ru+cHng0Ah0DPcqFqFnwP/Ewh1xjl3/6LGYntCisfdc929Mlj8E5F33YUi5Ho9YerbRKkLo1VHxaMl7TBwk7tfCgwFHg9aVAD6AE+6+8XAfuB/xCGe+twIvOnuW4G9ZnZZsH4QcBeRXwfOJ/JLBUQqhjXununu78Y92ubpYmB9zRVBZfsJ8M9Ab2BA8KvUYnf/38AuYKi7D41zrHXRsyzSPPQEdtRYLkFf4lskM+sNZAFrwo2kZQt+lNzp7pvCjgXAzGab2Q7ge4TXklbTj4D/DDuIkKi+bUBT6qh4vCfNgDlm9g/AUSL/cGcF2z52943B5/VEvqSH5XbgP4LPvwmW3wDWuvtHAGb2ayItFC8DR4DfhhBnSzUEeKrqVyl3D/2XkDroWZZmwcz+C/h6HZumu/tr8Y5HJBaCXgO/Be4+rnVFTkND9Qbwr0S6OoYei7u/5u7TgelmNg34CfBQGHEEZaYT6d62OBYxnEoskliaWkfFI0n7HtAduMzdK8ysGEgLtpXVKHcECKWLmJl1IdIVr5+ZOZEXSzqwnBOb0auWDwfd9RJJJbVbR9PqKxiSPwO31FxhZh2Bc4HiMAI6RXqWpVlw92vCjiFkO4Fzaiz3CtZJC2FmqUS+/Cx291fCjqclqK/eMLN+QAawKeg80gvIN7NB7v7XeMZSh8XACmKUpJ0sjmBIyShguMf4xcMJXK+rvq1DNOqoeHR37ATsDr7UDgXOi8M5T9UtwAvufp6793b3c4CPgcHAIDPLCMbv3EpkMoZE9RfgIjNrG8wyNDzsgI7ze6Cdmf0TVA82fZzIQM+VwAQzSwm2dQn2OQikxz/UOulZFmke1gF9gue9DZGxmb8LOSaJkqCb+bNAobv/e9jxtHTu/r67fy34f0pvIt3ZLo1VgnYyZtanxuKNwJaQ4riWyBi90e7+ZRgxJAjVt8eJVh0VsyQt+LJdRuRXjoFm9j7wT4T0H9NJ3A68ety63wbr1wG/JDLo7+M6yoWu6l67+w5gCZFZfpYAG0IN7DjBr0w3AWPMrIjIbEiHiXSj+BWRsWmbgwksvhvs9jTwZpgTh+hZlpbEzG4ysxIik8QsN7OVYccUbUG36Z8Q+fGnEFji7h+EG1XsBN2X/xv4ppmVmNmPw44pxrKB7wPDLDIN+0Yz+8ewg5K4mVs1yRiRLphhvYLhl0R+RH4reAYXhBRHqPV6ItW3CVQXRqWOsli1zppZJvCMuw+KyQniwMyGAPe7+6iwY2lIS7jXiawl3N/m8iyLiIiISIxa0szsX4BfAw/E4vhyjO51bOn+ioiIiEi8xawlTURERERERE5dPCYOERERERERkUaKSpJmZueY2Ttm9mcz+8DMJgfru5jZW2ZWFPzdOVjf18z+28zKzOz+4451rZl9aGbbzCwnGvGJnIooP88LzWy3mRWEcS0iIiIi0vxEqyWtErjP3S8C/h6YZGYXATnA7929D5Hp16uSrn3AT4HHah4kmJL9SeA64CLg9uA4IvEUlec5sAi4NuYRi4iIiEiLEZUkzd0/dff84PNBIlNw9iTy/orngmLPAd8Jyux293VAxXGHGgRsc/eP3L0c+E1wDJG4ieLzjLvnEUniREREREQaJepj0sysN5AFrAHOcvdPg01/Bc46ye49gR01lkuCdSKhaOLzLCIiIiJyyqKapJlZByIvzr3b3b+ouS14kbGmkpRmQ8+ziIiIiIQhakmamaUS+UK72N1fCVZ/ZmZnB9vPBnaf5DA7gXNqLPcK1onEVZSeZxERERGRUxat2R0NeBYodPd/r7Hpd8APgs8/AF47yaHWAX3MLMPM2gC3BccQiZsoPs8iIiIiIqcsKi+zNrOrgT8C7wNHg9X/SmQczxLgXOAvwFh332dmXwfeAzoG5UuBi9z9CzP7R+AXQDKw0N1nNzlAkVMQ5ef518AQoBvwGfCQuz8bx8sRERERkWYmKkmaiIiIiIiIREfUZ3cUERERERGR06ckTUREREREJIEoSRMREREREUkgStJEREREREQSiJI0ERERERGRBKIkTUREREREJIEoSRMREREREUkg/x+6qG28xQCDZwAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -699,7 +699,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -725,11 +725,11 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 15, "metadata": { "ExecuteTime": { - "end_time": "2020-04-30T22:07:49.825647Z", - "start_time": "2020-04-30T22:07:47.983614Z" + "end_time": "2020-05-03T17:03:46.377644Z", + "start_time": "2020-05-03T17:03:44.670383Z" }, "scrolled": true }, @@ -739,26 +739,26 @@ "output_type": "stream", "text": [ "Statsmodels results css:\n", - "Fitted parameters: mu=0.00, p=[0.56 0.03], q=[-1.6 0.6]\n", - "AR roots abs:[ 1.64 18.49]\n", - "MA roots abs:[1. 1.67]\n", - "Train error mean: 0.00, std: 0.96\n", - "LL: 547.51\n", - "RMSE: 1.10\n", + "Fitted parameters: mu=0.00, p=[-0.19 0. ], q=[-0.85 -0.15]\n", + "AR roots abs:[ 4.97 78.06]\n", + "MA roots abs:[1. 6.53]\n", + "Train error mean: 0.00, std: 1.00\n", + "LL: 564.78\n", + "RMSE: 1.09\n", "\n", "Giotto results css:\n", - "Fitted parameters: mu=0.00, p=[0.56 0.03], q=[-1.6 0.6]\n", - "AR roots abs:[18.5 1.64]\n", - "MA roots abs:[1.67 1. ]\n", - "Train error mean: 0.00, std: 0.96\n", - "LL: 547.51\n", - "RMSE: 1.10\n", + "Fitted parameters: mu=0.00, p=[-0.19 0. ], q=[-0.85 -0.15]\n", + "AR roots abs:[76.15 4.97]\n", + "MA roots abs:[6.54 1. ]\n", + "Train error mean: 0.00, std: 1.00\n", + "LL: 564.78\n", + "RMSE: 1.09\n", "\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2kAAAE6CAYAAACMDRrWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOy9eZwcVbn//3m6ZyaTfR2WJECiRBbJJiGIERWCicqql9Xlgtd7w1X0h6JchousgoYL6r1fZDFIDCAii4JLogSFGBHISkgCCZkEBjJZyGSfmWS2rvP7o6u6azmnqnqZ6Z7J5/164XRXnTrnqerOeD7zbKKUAiGEEEIIIYSQ8iBRagMIIYQQQgghhGShSCOEEEIIIYSQMoIijRBCCCGEEELKCIo0QgghhBBCCCkjKNIIIYQQQgghpIyoKMWiI0aMUGPGjCnF0oSQLmLFihU7lVI1pbajEPi7iZDeCX8/EULKkbDfTSURaWPGjMHy5ctLsTQhpIsQkXdLbUOh8HcTIb0T/n4ihJQjYb+bGO5ICCGEEEIIIWUERRohhBBCCCGElBEUaYQQQgghhBBSRpQkJ01HR0cHGhoa0NraWmpTDgmqq6sxevRoVFZWltoUQgghhBBCiIuyEWkNDQ0YOHAgxowZAxEptTm9GqUUdu3ahYaGBowdO7bU5hBCCCGEEEJclE24Y2trK4YPH06B1g2ICIYPH06vJSGEEEIIIWVI2Yg0ABRo3QifNemJiMhcEdkhImtdx4aJyPMiUmf/HGofFxH5fyKyUURWi8hHSmc5IYQQQkh8ykqkEUJIBPMAfMZ3rBbA35RS4wD8zX4PAJ8FMM7+bxaA+7vJRkIIIYSQgqBII4T0GJRSiwHs9h0+H8DD9uuHAVzgOv6ISvMqgCEicmT3WEoI6c2IyFEi8qKIvCkib4jI1fZxrWdfc/3l9pg6Ebm8e60nhPQEKNJs9u7di/vuuw8AsHXrVlx44YUltsjMxz72sVKbQEg5cbhSapv9ejuAw+3XowBsdo1rsI95EJFZIrJcRJY3NjZ2raWEkN5CJ4DvKqVOBPBRAFeJyIkwe/YziMgwADcDOBXAVAA3m8QcIeTQhSLNxi3SRo4ciaeffrrEFgXp7OwEALz88ssltoSEsbx+N8bUzsfm3QdKbcohh1JKAVA5XjNHKTVFKTWlpqamiywjhPQmlFLblFIr7ddNANYh/Ucgk2ffzUwAzyuldiul9gB4HsEwbkLIIU7ZlOB3c+sf38CbW/cXdc4TRw7Czed+2Hi+trYWmzZtwqRJkzBu3DisW7cOa9euxbx58/Dss8+ipaUFdXV1+N73vof29nY8+uij6NOnDxYsWIBhw4Zh06ZNuOqqq9DY2Ih+/frhwQcfxPHHH69d66mnnsKtt96KZDKJwYMHY/HixUilUqitrcWiRYvQ1taGq666CldeeSUWLVqEG2+8EUOHDsX69euxYcMGDBgwAM3NzQCAu+66C08++STa2trw+c9/HrfeeitaWlpw8cUXo6GhAalUCjfeeCMuueSSoj5PYubJ5WnnzT837sSlU48usTWHBO+LyJFKqW12OOMO+/gWAEe5xo22j5EexJja+V0yb/3ss7tkXnLoISJjAEwGsARmz76bWF5+e+5ZSOfU4uij+f8nhwr8vUeAMhVppWD27NlYu3YtVq1ahfr6epxzzjmZc2vXrsVrr72G1tZWHHvssbjzzjvx2muv4Tvf+Q4eeeQRfPvb38asWbPwwAMPYNy4cViyZAm+8Y1v4IUXXtCuddttt+G5557DqFGjsHfvXgDAQw89hMGDB2PZsmVoa2vDtGnTMGPGDADAypUrsXbt2kBPs4ULF6Kurg5Lly6FUgrnnXceFi9ejMbGRowcORLz56f/ke/bt68rHhkxIGDlzG7mDwAuBzDb/vl71/FvishvkA4r2ufaPBFCSMGIyAAAvwXwbaXUfnflZKWUEpGcPPt+lFJzAMwBgClTphQ0FyGkZ1GWIi3M41UKzjjjDAwcOBADBw7E4MGDce655wIAxo8fj9WrV6O5uRkvv/wyLrroosw1bW1txvmmTZuGK664AhdffDG+8IUvAEgLrtWrV2fCLPft24e6ujpUVVVh6tSp2qbTCxcuxMKFCzF58mQAQHNzM+rq6nD66afju9/9Lq677jqcc845OP3004v2LAgpJSLyOIBPARghIg1I53XMBvCkiHwNwLsALraHLwDwOQAbARwA8NVuN5gQ0msRkUqkBdpjSqnf2YdNnn03W5D+PeYwGsCirrSVENLzKEuRVm706dMn8zqRSGTeJxIJdHZ2wrIsDBkyBKtWrYo13wMPPIAlS5Zg/vz5OPnkk7FixQoopXDPPfdg5syZnrGLFi1C//79tfMopXD99dfjyiuvDJxbuXIlFixYgO9///uYPn06brrppri3S0jZopS6zHBqumasAnBV11pECDkUkbTL7CEA65RSP3GdMnn23TwH4IeuYiEzAFzfheYSQnogLBxiM3DgQDQ1NeV17aBBgzB27Fg89dRTANLi6fXXXzeO37RpE0499VTcdtttqKmpwebNmzFz5kzcf//96OjoAABs2LABLS0toevOnDkTc+fOzeSnbdmyBTt27MDWrVvRr18/fPnLX8a1116LlStX5nVfpDAYl0IIIb2WaQC+AuBMEVll//c5pMXZp0WkDsBZ9nuIyBQR+QUAKKV2A/gBgGX2f7fZxwghJAM9aTbDhw/HtGnTcNJJJ+GEE07I+frHHnsMX//613H77bejo6MDl156KSZOnKgde+2116Kurg5KKUyfPh0TJ07EhAkTUF9fj4985CNQSqGmpgbPPvts6JozZszAunXrcNpppwEABgwYgF/96lfYuHEjrr32WiQSCVRWVuL++9nDtzsRpqQRQkivRin1EmBMQNZ59pcD+HfX+7kA5naNdYSQ3oCkI4K6lylTpqjly5d7jq1bty4vcUTyh8+8a6j97Wr8Ztlm/OgL43HZIVTdUURWKKWmlNqOQtD9biKlhVXOSDHg7yfSk+DvvUOHsN9NDHckhBBCCCGEkDKC4Y5dyB133JHJU3O46KKLcMMNN5TIIkIIIYQQQki5U7BIE5FqAIsB9LHne1opdXOh8/YGbrjhBgoyQgghhBBCSE4Uw5PWBuBMpVSz3TPkJRH5s1Lq1SLMTQghhBBCCCGHFAWLNLsXUbP9ttL+j9XHySFPCWryEEIIIYSQXkBRCoeISFJEVgHYAeB5pdSSYsxLSE+EJfgJIYQQQkghFEWkKaVSSqlJAEYDmCoiJ/nHiMgsEVkuIssbGxuLsSwhhBBCCCGE9DqKWoJfKbUXwIsAPqM5N0cpNUUpNaWmpqaYyxaFvXv34r777gMAbN26FRdeeGGJLTLzsY99rNQmkBgoRv0SQgghhJA8KFikiUiNiAyxX/cF8GkA6wudt7txi7SRI0fi6aefLrFFQTo7OwEAL7/8coktIeH00njH1n3Ajh73T5sQQgghpMdRjOqORwJ4WESSSIu+J5VSfypoxj/XAtvXFME0F0eMBz4723i6trYWmzZtwqRJkzBu3DisW7cOa9euxbx58/Dss8+ipaUFdXV1+N73vof29nY8+uij6NOnDxYsWIBhw4Zh06ZNuOqqq9DY2Ih+/frhwQcfxPHHH69d66mnnsKtt96KZDKJwYMHY/HixUilUqitrcWiRYvQ1taGq666CldeeSUWLVqEG2+8EUOHDsX69euxYcMGDBgwAM3N6Votd911F5588km0tbXh85//PG699Va0tLTg4osvRkNDA1KpFG688UZccsklxX2e5NDj4XOBba8Dt+wrtSWEEEIIIb2aYlR3XA1gchFsKSmzZ8/G2rVrsWrVKtTX1+Occ87JnFu7di1ee+01tLa24thjj8Wdd96J1157Dd/5znfwyCOP4Nvf/jZmzZqFBx54AOPGjcOSJUvwjW98Ay+88IJ2rdtuuw3PPfccRo0ahb179wIAHnroIQwePBjLli1DW1sbpk2bhhkzZgAAVq5cibVr12Ls2LGeeRYuXIi6ujosXboUSimcd955WLx4MRobGzFy5EjMnz8fALBvHzfVpAhse73UFhBCCCGEHBIUw5NWfEI8XqXgjDPOwMCBAzFw4EAMHjwY5557LgBg/PjxWL16NZqbm/Hyyy/joosuylzT1tZmnG/atGm44oorcPHFF+MLX/gCgLTgWr16dSbMct++fairq0NVVRWmTp0aEGjONQsXLsTkyWmN3NzcjLq6Opx++un47ne/i+uuuw7nnHMOTj/99KI9CxIfluAnhBBCCCH5UJ4irczo06dP5nUikci8TyQS6OzshGVZGDJkCFatWhVrvgceeABLlizB/PnzcfLJJ2PFihVQSuGee+7BzJkzPWMXLVqE/v37a+dRSuH666/HlVdeGTi3cuVKLFiwAN///vcxffp03HTTTXFvlxQIS/ATQgghhJBCKGp1x57MwIED0dTUlNe1gwYNwtixY/HUU08BSIun1183h4Zt2rQJp556Km677TbU1NRg8+bNmDlzJu6//350dHQAADZs2ICWlpbQdWfOnIm5c+dm8tO2bNmCHTt2YOvWrejXrx++/OUv49prr8XKlSvzui9CCCGEEEJI90NPms3w4cMxbdo0nHTSSTjhhBNyvv6xxx7D17/+ddx+++3o6OjApZdeiokTJ2rHXnvttairq4NSCtOnT8fEiRMxYcIE1NfX4yMf+QiUUqipqcGzzz4buuaMGTOwZu0bOOXUj6IiIRgwYAB+9atfYePGjbj22muRSCRQWVmJ+++/P+f7IYXDaEdCCCGEEJIPokqQODNlyhS1fPlyz7F169blJY4Odd7a3oS2zhSOP2IgqiqSOV3LZ9413PDMGjy25D384IKT8JWPHlNqc4rHLYPtn/pCNCKyQik1pRstKjq6302ktIypnd8l89bPPrtL5iXlCX8/kZ4Ef+8dOoT9bmK4Y48nLbJZpIIQQgghhJDeAUVaF3LHHXdg0qRJnv/uuOOOIq+SrlJBjUaKwo716T6FVP2EEEIIISWDOWldyA033IAbbrihS9dwKglyT12G9MQP5dcXA3vfBU69EhgWbPtACCGEEEK6Hoq0Hk622nsPFAS9lB5dgj+j+i3zGKV6+E0SQgg5VOiq/C5CuhqGO/ZwMnvq0ppBegtiF5+JEmmEEEIIIaTLoEjr8dg5adw3lx098iNJ2CLNSpXWDkIIIYSQQxiKNBfJZNJT5KO+vr7UJgEA6uvr8etf/1p7zgk665GCgJQfGU9amEjjt40QQkRkrojsEJG1rmNPiMgq+796EVlluLZeRNbY41hXnxASgDlpLvr27YtVq7S/T0Pp7OxERUXXPUpHpH3xi18MnMukBtGVVjYIenC+VhxPGr9rhBACAPMA/AzAI84BpdQlzmsR+TEAfWPJNGcopXZ2mXWEkB4NPWkRtLa24qtf/SrGjx+PyZMn48UXXwQAzJs3D+eddx7OPPNMTJ8+HQBw11134ZRTTsGECRNw8803Z+Z45JFHMGHCBEycOBFf+cpXAAB//OMfceqpp2Ly5Mk466yz8P777wMA/v73v2c8eZMnT0ZTUxNqa2vxj3/8A5MmTcJPf/pTrZ3cNpOikKAnjRBC4qCUWgxgt+6ciAiAiwE83q1GEUJ6DWXpSbtz6Z1Yv3t9Uec8ftjxuG7qdaFjDh48iEmTJgEAxo4di2eeeQb33nsvRARr1qzB+vXrMWPGDGzYsAEAsHLlSqxevRrDhg3DwoULUVdXh6VLl0IphfPOOw+LFy/G8OHDcfvtt+Pll1/GiBEjsHt3+vf5xz/+cbz66qsQEfziF7/A//zP/+DHP/4x7r77btx7772YNm0ampubUV1djdmzZ+Puu+/Gn/70p4DNIsxJK1d65Gci9KQRQkgROB3A+0qpOsN5BWChiCgAP1dKzek+0wghPYGyFGmlQhfu+NJLL+Fb3/oWAOD444/HMccckxFpn/70pzFs2DAAwMKFC7Fw4UJMnjwZANDc3Iy6ujq8/vrruOiiizBixAgAyIxvaGjAJZdcgm3btqG9vR1jx6Z7Uk2bNg3XXHMNvvSlL+ELX/gCRo8eHWpzNtqRG+dyoUdXp49VOITfNUIIieAyhHvRPq6U2iIihwF4XkTW2545DyIyC8AsADj66KO7xlJCSFlSliItyuNVLvTv3z/zWimF66+/HldeeaVnzD333KO99lvf+hauueYanHfeeVi0aBFuueUWAEBtbS3OPvtsLFiwANOmTcNzzz0XagNL8JOiEqdwCP8gQAghRkSkAsAXAJxsGqOU2mL/3CEizwCYCiAg0mwP2xwAmDJlCn/5EnIIwZy0CE4//XQ89thjAIANGzbgvffew3HHHRcYN3PmTMydOxfNzc0AgC1btmDHjh0488wz8dRTT2HXrl0AkAl33LdvH0aNGgUAePjhhzPzbNq0CePHj8d1112HU045BevXr8fAgQPR1NQUaqcV8qu7ubUDKSuk7xUhDvSkEUJIoZwFYL1SqkF3UkT6i8hA5zWAGQDW6sYSQg5dKNIi+MY3vgHLsjB+/HhccsklmDdvHvr06RMYN2PGDHzxi1/EaaedhvHjx+PCCy9EU1MTPvzhD+OGG27AJz/5SUycOBHXXHMNAOCWW27BRRddhJNPPjkTCgkA//u//4uTTjoJEyZMQGVlJT772c9iwoQJSCaTmDhxYqBwSCYnzbBx7kxZeHtnC97ddaBYj4TEpEeGoIr9KyG0cAghhBAReRzAKwCOE5EGEfmafepS+EIdRWSkiCyw3x4O4CUReR3AUgDzlVJ/6S67CSE9g7IMdywVjhfMTXV1NX75y18Gjl9xxRW44oorPMeuvvpqXH311YGxl19+OS6//HLPsfPPPx/nn39+YKwpPPKFF17QHo+qwO942No66UnrLnpyShpL8BNCSDyUUpcZjl+hObYVwOfs128DmNilxhFCejz0pPVw2CaNFJWE/XcbFSbq+WUjhBBCCOlKKNJ6OpnCIT1v4/yjP6/DSTeHF0bpyfS8TwSuEvyd5jH8iwAhhBBCSJdSVuGOSqlMjhWJR7590sohX+rnf3+71CYQPywcQgghhBBScsrGk1ZdXY1du3aVhXjoieTy2JRS2LVrF6qrq7vOIB8Pv1yPTY3BnL/eTI/8c0OcwiH8N0oIIYQQ0qWUjSdt9OjRaGhoQGNjY6lN6VHsPdCO5rYUDlRXYE/fysD5lKXw/r5WJBMC7M2Ksurq6shG2cVCKYWb//AGBvapwJpbZ3bLmiRP6EkjhBBCCCk5ZSPSKisrMXbs2FKb0eO44Zk1eGxJA7728bG48ZwTAue37j2Icx59AUcOrsYr108vgYVZx0tTW0ieUy+kR0qZTDNrC2g/AOxrAGo+VFqbCCGEEEIOMcom3JHkhyMEyjkCrYxNywulFP60eis6UvoKiD06rzLhKhzy9FeBe08BOtu8Y8r5y0YIIYQQ0gsoG08ayQ8nh6+cqzv2tjzDv6zdjm/++jV856wP4eqzxpXanOLilOC3OoG3F9mv/aGPvevzJMVhTO38UptACCGE9BroSevhWLYzp5x1kFXGtuXDrpZ2AMD2/a2h48r5MzHiLsHv3IDfM9gjb4wQQgghpOdAkdbDsRxPmmHjXA7b6XL28hEfCftXgtWJ8vj2xENEviMib4jIWhF5XESqRWSsiCwRkY0i8oSIVJXaTkIIIYSQOJSFSOtMWbB6m7ulm3AeW9TTK2WWFB0vPQhxVXd0Pjj/B1hmH6iIjALw/wGYopQ6CUASwKUA7gTwU6XUsQD2APha6awkhBBCCIlPWYi0Y2/4My6Z80qpzeiROF6qMts3HxL05PogRtyFQ4zSvyy/bBUA+opIBYB+ALYBOBPA0/b5hwFcUCLbCCGEEEJyomCRJiJHiciLIvKmHW50dT7zLKvfU6gphyQZZ4dh49wdRTt+veQ9vPr2LuP5Q1VA9sjb9uSkOdUry9uTppTaAuBuAO8hLc72AVgBYK9Syun70ABglO56EZklIstFZDn7NBJCCCGkHCiGJ60TwHeVUicC+CiAq0TkxCLMS2KQzUnTn++O/fR/P7MGl8551Xg+Kietp1V/jAwt7cketoSmcEiZfz4iMhTA+QDGAhgJoD+Az8S9Xik1Ryk1RSk1paampousJIQQQgiJT8EiTSm1TSm10n7dBGAdDH+xJsUnbk5aKYna4/fUdMRu0WLbVgMr5nXHSmkSrpy0bBc+36Cy+8DOAvCOUqpRKdUB4HcApgEYYoc/AsBoAFtKZSAhhBBCSC4UNSdNRMYAmAxgieYcQ4q6ABXhSbPKwAsSZUFP86Q5dMt9/fx04I95RRDnh7irO9qUeeEQpMMcPyoi/STdSXw6gDcBvAjgQnvM5QB+XyL7CCGEEEJyomgiTUQGAPgtgG8rpfb7zzOkqGvIRqSZctK60RgDUWKlp3rSTEhJa2kWiPNZuUVamXvSlFJLkC4QshLAGqR/r80BcB2Aa0RkI4DhAB4qmZGEEEIIITlQET0kGhGpRFqgPaaU+l0x5iTxiMxJ60ZbTER6nMrCytzpwVIsBI1IK39PGpRSNwO42Xf4bQBTS2AOIYQQQkhBFCzS7PCihwCsU0r9pHCTSC5kRFoJqztGEWVCGZgYi407mrDvYEfPMTgfnHv75/+5D/oHdZc1hBBCCCGHJMUId5wG4CsAzhSRVfZ/nyvCvF3Kn9dsw3NvbC+1GQWTKRxSxp60KCO6K2+urTOFd3a25H39WT9ZjH+5P9vPr0dXcSyE3ixSCSGEEELKgGJUd3xJKSVKqQlKqUn2fwuKYVxX8vXHVuLKR1eU1IaD7SnU/nY19h5oz3uObJ800/n0GSmhooguwd89dlz39GqccfciNLV2dOk6PVq86T6MwDGKNEIIIYSQrqSo1R1Jbjyx7D38Ztlm/O9f6/KeI6q6Yzk4PaJL8HePkS9t3AkAaO2wIkYSQgghhBBSOopSOITkR6cdq5gowPUSmZOW98zFI8qG7q7u2F2FSnLWnvX/BGqOA/qP6BJ7IlEKaH5ffzzsPSE9kDG187ts7vrZZ3fZ3IQQQg4N6EkrEc1tndjdkg5zTBbwKWQETll70qIqh3SPHd1F3pJ73ueAuZ/Rn+uOD3LB94C1T+sW179v3QfcMhhY9XhXW0YIIYQQckhBkVYiTrn9r7hv0SYAQCKRvyctQqOVXTPr0370t8D57rax0D5mXWrtLkPoa3c8o2W/iLe2837Pu+mfr/ys62wihJAyRUTmisgOEVnrOnaLiGyJKqQmIp8RkbdEZKOI1Haf1YSQngJFWok42JHKvE4WEO7oeKlMQqcMNJrHhm37WgPny0FI5kOuYq+ptQNtnSn9yUhvYynz6Fg4hBBCNMwDoAt/+GlYITURSQK4F8BnAZwI4DIRObFLLSWE9Dgo0sqAZAGetOhm1qXfUEdWd+wmO7LrpVdMWQpjaufjrufW53Z9TIP99z3+loW44N6XDYMjRFgpRZrJk9ajy1gSQkhhKKUWA9idx6VTAWxUSr2tlGoH8BsA5xfVOEJIj4cirQwoqHCIvXc3l+DPe+riUSbVHf3ZYp32w3tw8Tt5zbasfjf+UdcYXCXk41y3bb/+hGXwsDnQk0YIIT2Fb4rIajsccqjm/CgAm13vG+xjAURklogsF5HljY3B/78hhPReKNLKgKJUdywDNdbaoRcagS1+wDPTNfZEW5Ifzse1fnsTvvLQ0qLMWdaeNEIIIXG5H8AHAUwCsA3AjwuZTCk1Ryk1RSk1paamphj2EUJ6CBRpZUAh1R3jFg7pjsi0C+79p/a4X5P5S+53dwn+gguHdIW95SzSWIKfEEJioZR6XymVUkpZAB5EOrTRzxYAR7nej7aPEUJIBoq0IjPvn+/gnHv+kdM1BVV3dDbMZVCCf/32Jr0NPuP84Y3dXTjEsaerl81p/nIWaQxvJISQWIjIka63nwewVjNsGYBxIjJWRKoAXArgD91hHyGk58Bm1kXmlj++mfM1hVR3tDIarYybWQc8Z94D3Wdj+jl3tTgT+/PMaZlyFmkmTxo9aoSQQxgReRzApwCMEJEGADcD+JSITEL6/wLqAVxpjx0J4BdKqc8ppTpF5JsAngOQBDBXKfVGCW6BEFLGlFyklUMuVanp0uqOZfB8gzlp3vdWN8c7Fqox4j7T3utJK/13ihBCSo1S6jLN4YcMY7cC+Jzr/QIAgfL8hBDiUPJwx+7ORwqsX2oDUFjhEEcIGPuk5T1z4expaceit3YERE2pU5wy4Y5d/HRymj9SpJXwkyz1B0YIIYQQcohRcpFWak9Ph1X6qnmFeNJUTE9aVxUOCfv8vjpvGa745TK0tHmrPgbDHXuYJy3ivPOoi+pJK6ncpieNEEIIIaQ7KblIK7UjqzNV+g1nIYVDsjlpekpZHGNTYzMAoCPlFSDBwiFFNyuUTIio/T5XkZiKMDiv2ynncEd60gghhBBCupUyEGml3fCVhUgrwMsVmZOW/9SxiDO/37aDvn5q3e1NzXrS8lu3S76z5SzSIumG/g6EEEIIIYcQJRdppaYcwh0riuBJM8klt5442J7CtNkv4J8bd+a9XnD9aMHi91RNveNvvjmKZk5O5LtsKuZXJicRWNYijeGOhBBCCCHdSclFWqk9af5QvFJQWOGQ+NUdNzU2Y8veg/jhgnV5rxecP+xk3DnCB67bth8r39ujPXf979bgxwvfMl77sxfqsHhDo28978849rltjPrOdklOWrmFO+7fBqiUfjwhhBBCCCmIkpfg7605aUqpTL+sKAorHGL/NJx3nq9AMrlUhYjCwPoxlFiUWIma4bP/l24OXj/77MC5x5e+BwDYf7ADHx9XgyMGVWP86MGZ83cv3JC51rltK+qh+fjXuUvR2NSWeR+3IqgCsL+1A4OqK2MMLmOR5n9QbfuB+08znyeEEEIIIQVRck9ayas75ulJa++0sGN/q/F8LrdViGbK5qSZSvAHPUCFFCoJzB9yn8r300QxvKkPv/Iu/uOR5Tj3Zy+Z7fFpszgCs6m1A/+o24n125syx1Ix7X16RQMm3LIQG95vih5sRXilysmT1tmmH0cIIYQQQjpwOUQAACAASURBVIpCyUVayT1peRpw7dOvY+oP/2YUebkIj0I0irOO8Tbs4x0pC/tbOwEUVqgkMH0M26OqIXZ3WmBUiKibnc3tgWNR9+PEO763+wAA4K3tMURaqT1prNhICCGEEFI2lFyk5epJ29nchlff3lW09fP1pP157XYA5g17TulIee6P/76hEZsaW0LXc45v29eKy+cuBVDccMdYhUMixnR7nzTfzzBSGgUZKdJ8xBLskTGhXfiM3vw9sO31+GuXdaVJQgghhJCeT0ly0jbvOZB5neve86IHXsE7O1u0+Un5kHdOWsRlOXnS8rMAt/7xjewcpnBHzeFkUXPSoonSNN3txMmlBH+H5vsRKdLyaStWSk/ak/8aMSBKpLEEPyGEEEJIMSmJJy3l2vjmmo/0zk7bc1SknX1nnrF2Ou/PD/70ZvZ8LtXXlYJlKSx8Y7vxvjpTFlZt3us5Fqd0v/b5FnFPHfb5qUwoZnBMLtUSi4WjTTPhjhHjf/ZCHS68/+XA8VztjedJixJpJQxHZDNrQgghhJBupSQizb3FyzcnLZeQsx1NrWhwee+88+S3vrNPdW/AH3rpnczrXD1pjy97D7MeXYGnljdox9y9cAMuuPefeGPrPgBA/c4WtLRli03k0sy6K3PSdJ+LXqSZ5ygWpiqMzlHHLjGo1rsXbkBLe7Cgh/8705GyPGGz/lVjfVdLnZOWC+VkCyGEEEJIL6Qk4Y6eDXqewX6dlkJFMt5Yp3myLkQyX49cJq/JJI5ySkoDtuw5CCAtKHU44myXXcjiU3cv8k1hCncMHi9mTpp/2Y6UhWTC+8HonJVeod41Ks1fhTHQHy3PZf32nvyD52EpYO2tM+359euGUtYijTlphBBCCCHdSRkUDsltvOMFyrcqo598pwkL5Qs7rp0LKiMoTOXx860roTtcSF82P/77bOsMbuB1z8J9rKuC58xFXbzhjrn+ocA/7/7WTjS3dRrHR30XTrr5Ocx9aWP4ouVUgp8ijRBCCCGkSylRuKNrg57jDt0RGKkiNaEu2JNmOJ+L+FMq+xxMRT2cZ2ZyghlvQ5eS1oWFQ3Rhf9Hhjl3kSfN9CJlm1lbQhpzmjapW6TttqfB77EhZkEgVXk6etIieboQQQgghpCBKI9Jce75cQ90cgZFvwY/0+tk1v/iLJdjVnH9zXtPeORfh8dSKBrTbHihTKKIznSl/KheP3qYdzZGtBxa9tQN/ffP90DG6+XXVMnWmeZtsRy7j4c9rtuEvdguEMEze1qwnLT+VFvUHAv9ZS6nIpt+CMg53pCeNEEIIIaRbKVnhkO370rlX7k3+wfYUXqrbGXqtU9GwkHBH/57z2VVb857DJI5y0Z4r3t2DeS/XAzB7yiLtMR3XnNiy9yB+uGBd6HxX/HIZ/v2R5dHr+vfvGi9psQuHfP2xlfjPX62IHGcMd/TnpuVIrp40pSLkoAIkSjCWlSeNIo0QQgghpCspiUhr7Ujhoz/6G9Y07PNsaP/7mTX48kNLMmX2dSSlcJHmFw2FhNuZwx3zmzPvoh455KQBwLL63fmt458/RpEMnVgqxJsalyhva76rmqpGGseriFYFUEhAo1rd9ndVCcx8Gm1TpBFCCCGEdClFEWkiMldEdojI2lyuq9vR5Nn/1e1oAgA0tXYYr0kUISfNv8cuRCSYwwzzm89U0yMT7mg6n0N1R0BfcTEf/LPrVtM9C2+4Y3DAxh3NOYshPyZPmrOe+9n8v7/VYdJtC+PNG+VJ8z2FyHBHBSTc4Y6WXYTEnfvVVcIo1rwB12CXmEIIIYQQQtIUy5M2D8Bncr3I72Ew5Vu5ccIdOwpQGX5RUIgWMJfgV2jYcwDLc/RYRVVeNJ3NpbojUDzvlS60L7t2UAxpr/OdXrtlH876yd8x5x9vF2RbLuGOP3l+A/YeMP9xwI0u7043v9uOcE+aLyct1QEs+C/gByNcg7pIpFl5FAGhJ40QQgghpEspSp80pdRiERmT63VWVK6OhownrYg5aYXoFaOnSgEfv/NFAPr+bCaMJfgjnpQ5Jy1+QZF8CIaO6saEX+c+b1kK33827ZBd+e6e0LW/+euVoefNJfgLI9eiNVHPWimFpCf+swNY+nP/qJzWjE2cSo0MdySEEEII6Va6LSdNRGaJyHIRyVajiMjV0ZHJSUspXPf0aoypnZ+zLUFPWvFz0vKtHBhV3RFi8kzlVsAkH5Hb2pHCo6/Ue8IQA+GOutQqnb2u1+7zr7y9C6s277WPe695u7HZ8/5Pq7eF2mus7pgJdwy93Eiuzy5dgt98XgEQ8XnSAoNK6UnzxwezBD8hhBBCSFfSbSJNKTVHKTVFKTXFOZbO1YkIhfORTGRL8D+xfHNetvhzigopHNJtOWn2T4F4RMLgvpWYeNSQELFoOJ6HfT/96wbc+Ps3MH9NVhz588Z04jSyuqPruLc1gPe6M3/895zsDfRJy9jjzK6xNcYHF1W0xv99slREuKOCt3BIt4o0cxPu7Nr0pBFCiB9dPr6I3CUi60VktYg8IyJDDNfWi8gaEVnl+eM1IYTYlKS6o4PfwxCnsGGyGCX4fXvMrshJy7foRVSjaRGvveMOG4DBfSuN92D0pOWh0va0tAMADrSbN/b6cEdt5RDteXdOXqERmW6R1taZcjcHMM4f57lEedJ03sWocFRPM2srR5FmWcDSB4H2A6F26Q3Ip3CI75r31wBv/iH3tQkhpGczD8F8/OcBnKSUmgBgA4DrQ64/Qyk1yf3Ha0IIcSixSFM5C6SkJifNshR+/vdNuHTOK7HXdVOIGChGnzQ3SXP5Ru2alclE2kOUY+5ZPuGOTmGXsB5null1KVyWwZXmDvcsNG/OfY9fenBJdrmMJy38GhNRhUP8WJbCJ/7nRe05x5ZEIeGO6/4ALPge8OIdOdmVNi6fnDTNNU9+Jfe1CSGkB6OUWgxgt+/YQqWU85fMVwGM7nbDCCG9gmKV4H8cwCsAjhORBhH5WpzrlCEMLGwLnPGkuTbKHZaFH/15PV59O1hJURfKWNScNJMHK9+cNNcncvyNf8a597zkmU/gFRIVSYFIWG6cnnw8fY5+MuWT+d8rw5iwOdwaNZ8n6PbEub2ty11FSJyjuu9GLJEW1X/Nn8KlgN22FzIw1v6ZcF+Uq0g7aN9b2/5Qu/QG5JGTxnBHQgiJw78B+LPhnAKwUERWiMgs0wTufP7GxsYuMZIQUp4Uq7rjZXldB1+4Y4xrss2ssxvFjhDPhnvTvbulHcP6VwW8d4X4a4zhjh5vk4oMY3RwtyFo7bCwZss+73mRgCdNhfThCqs+WQx0oX1BG3THXJ5Q1/mkx5MWvC5KXFa4RFrKJ6YyOWn2HFkRmR0TJ4w2MifN91TCQigz4Y6enLR2QBJeMRQa7mj/0TZRGWqX/to4njT/+yJ9eQghpJciIjcA6ATwmGHIx5VSW0TkMADPi8h62zPnQSk1B8AcAJgyZQp/+RJyCFHacEdD/6iwQh4JTU5aR6d5A+sWcB/5wfNY9NaOwPyFFA4xeczc95VL/py5KbVrbtftViYFIpKz5y6fnDQdwc8vGMao+4z9ItbBm5MWvK4lJB8O8Is0/ZisJ80Z5w2djSLM27aruS24XkSPNABIwCWWrI60SPNOEmKQ7XlL5iPSYhQO6QHNrEVkiIg8bSfsrxOR00RkmIg8LyJ19s+hpbaTENL7EZErAJwD4EvK8H8ASqkt9s8dAJ4BMLXbDCSE9AiK4knLl0Bp8ghv0yOv1OO9XS0AgJQ73NG0G0ew6fU7O1tw/BGDfHbkv+k07dfdm/2UpVCZjDlfhLAQ8QqsimQCnalUiCct2r5CiNNzzrF35ocPx3NvvJ8e59r437FgHW7945v4Z+2ZkR7HlrZwz4833FH/MLM2Bo2N5UkzeG7/snY7/vNXKzDusAGe41GVHQFNdcdEhVdAhXrSbJGWyOOfc6xwxyJc0/X8H4C/KKUuFJEqAP0A/DeAvymlZotILYBaANeV0khyaJBPa5g45NJzk5QGEfkMgP8C8EmllLaak4j0B5BQSjXZr2cAuK0bzSSE9ABKXjhE5wHSF59QuOn3b6ClPb1BdG/A28NEms/LNrRflSaPKtzO1o4UVhgaK5u8JG2udXPxpJkLkWRz0txjqpKJdE6aMewy2tOXK97CIT6vpHat9M8PHT5QO/DdXQewZe9BAF6drrOxuU2Tr+WiIpn9SpubWdvhjrpwyhjPxST+lr6Tzoms2+Ht5xb28WdzDX0iTXyqXifSWvcDD3wc2LY6/T5XT1pzI7DozuhxZV6CX0QGA/gEgIcAQCnVrpTaC+B8AA/bwx4GcEFpLCSE9EYM+fg/AzAQ6RDGVSLygD12pIgssC89HMBLIvI6gKUA5iul/lKCWyCElDEl9aR1pMzVHT9514u45JSj8I1PHQsguHl2C5+wansL1ngbHrd2pHIqHPLsa1twzwt12NTYgpdrz8TIIX191+qva27LekFSOVQD1I288dm1WPne3sx5txcsHd4nxmDHYjazzhYOyV7rn0Ub2miv5QllNKzhqZ9hKTzp64V31k8CIfse3H3mzM2szTbEEdSmZ2dyAsbxpAlcwsfqABJ+kaaZ4+1FwPY16f+A3HPS/vAtYIMpp92zuO9teYk0AGMBNAL4pYhMBLACwNUADldKOb8AtiO9MQpgJ+3PAoCjjz66660lhPQKDPn4DxnGbgXwOfv12wAmdqFphJBeQEk9aZ0pS+uJEqS9K//zl7cyx/z7YvdGOSzc8cbfv+F5f7BDExoYsi//9hOrsKkxHWLZ0hbM3zF50lo7siFhUdUAo+Z79NV3M68tSwXCHRNitsN0a/lFOwZVSFi4oyPmHJGSjFFe330fr769G//19OrcLHStYRLHGZGm86QVINKMjchjPOtAuGMgJ03zHfIfy9WT1t4cPQbQlKssu3DHCgAfAXC/UmoygBakQxsz2HkhptyQOUqpKUqpKTU1NV1uLCGEEEJIFCX2pFn6Cn4xwtA6UgoJu7FzWLijn9YOK+8S/DpPielKt3cvF69V1FDlG1PplODXiNi2zpRRvOXjSdPhf3YNew5iSL9KDO5b6RqT/pmI0ai6ULPcQslUHCUT7phnTpppXlM+XZjwc55fUUSaOyfNsoC3FgDHfc7b18FrsNEu30LRtpSWBgANSimnGd7TSIu090XkSKXUNhE5EsCOkllICCEklK7K5SSkp1JST1p7SnlEhLNlbOsI/qXeLwZSlpUJnwsrwe8nHe7oPabbc//x9a2BXxhPLNuMMbXzPV4yk8DzVJ8sQk6a21ZvuGMCgmB1x+899TpOvOm5EE9aPJt0AiOsmfV/PLIcp/3oBfzrQ0sDc7gbVRdqlwm3t86YkxbiSYsjXk2OUZPkCS/Bn/6ZcBfjSLUHi4BohZFv3mRV9vXrvwae+BKw4pfGteM1vYDmQRVH4BcLpdR2AJtF5Dj70HQAbwL4A4DL7WOXA/h9CcwjhBBCCMmZ0oc7ao4faA+KNP/mudNSmU2/O9zRLypG+XLIWjtSgbl+8dI72L6v1XPsvkWbAjY8+I93AAB7DmQbE8fJ+colJy3Sk6aUvpm177pnXtuSGa9fJ55NUZ4l0zzu5tGZcEfXt83kXSq06qTbm+W33Tnl2JOvSDOGr+YR7uic8mQVWp2anDSdJ80v0lzhjgfsxu673zYv3ns8aQDwLQCPichqAJMA/BDAbACfFpE6AGfZ7wkhhBBCyp6SirSOlOXZlDt7xgO2pyqZEMxZvAmrG/YGxEtnSmU9aa5Kin6vxZGDqz3vWzv0IYAvrPdGQu1paQ+McfDnVrV1ptDY5O2P5d7I55KTFpXApOAVRsmELdIM440tAmJqIfdasff0gJ0n510rEWOCMLv8gltHMqSZtb9giC7cMY5IM0XXikGlhRcOUfa17nDH9njVHQPhjq5rqvqnf8bNOwsjkJNWfiJNKbXKziuboJS6QCm1Rym1Syk1XSk1Til1llJqd6ntJIQQQgiJQ2lz0ix9dccDdoGOPhUJ/HDBegDAqps+7RnTaamMWHLnpLk3xN95YpXHowM4OWnBNSuT3g2221vmx59bddVjr+Gv6973jOnoqpw05b3HioSkwx1zzD2La5POk+Y+YhIgQ/tVYd/BDs8YT7ijUTya7YojEj05aSYtUWi4o8FGU+GQUJHmXOuu7qjNSdPMEZaTlhFp2jY9Njmo7rB1CSGEEEJIUSmtJ63T8ngznC2jE+7Yp8Lc8yplWRmx5C7S4f4jvxPy52ZXSxuuffr1wPEq11pKKU+fszCUQkCgOfY5dFoK7Z0WDmrCOP1EhSFaSnnERzIhQIgnrdACIabrd+xvxY3PrjVW1hzcrzLrscqEO7pz0nIPw4zjiUuI2ZPmXtuyC6v4Ccsfy85rKhyiH68bPqZ2Pmp/uzpbgt8tfKzOYLGPOJ40pYBfng3cdxpQ2S99rEMj0tb+Nl2+v3eFOxJCCCGE9BpKHu6o2xMfaHc8adnwrUC4o6XsHmHenLSoTfZf1+3A6oZ9geM/fX5DZp7n3wyKLjduIWESG24PVMpSOO9nL+GEm6J7Vcar7ugKdxQ7yM5wXVh7gji4BUlmS6/SjcUfffVdvLi+UXvd240tmWsdE9weSNN9hn18Jk+VZ4xrUFiftJv/8Ab+5f5XAudMws6NKW/O9KhNXs7fLNuc+dwC4Y5xCocERJoFvPsSsOPNbH6aLtzx6X8DHjk/LQbjEOizUHYl+AkhhBBCehUlFmlK6zlxPGlu71agmXVKZTbk7nDHfD1H9bsOZDxv23xFRAK4azwYlnN79zothfXbm2LZYdrQu8+77zGZFCTE3Mw6Tkn5MDwizdMoOv3M4xQg0fVJ092nUvrvg0M8T5prXWPhEG/vOTdxNK3pmeo8c+k5w8IddTlpHfnlpLnfO88xLNxxj/4Z6KyMtIUQQgghhBSNkoq07ftbDZ609GbXnScWEGmunLQOT7hj/qLEyYXrV5UMHedeQinlCeNzcHuwOnPwZkVpHr8nrcIuHGISN7mI1pSlArZGlrGPMW823NF1TDPOUuGexHg5aXG8deZFfr9qi6fFgg6Tt9YUItsZUt3TmSoJdwl+TU4aFPDC7cC9pwYv1k5sz9feEjIm5ncj4EmjSCOEEEII6UpKKtLq3m/SbnjnvVwPAKhMuj1p3jHuPmnuSoxxcopMOB65qBncgshS0Io0t7jJxZsV3SfNW2wlmUhAYN5vhwkEP5/+yd9x7A1/9oiYqOcZ53E79kqEJy1lhXvSTM2iTfgFZhxh+diS9/DblQ2h85r+EPD40ve0x/198pTn+6PxpB3coy/Bv/guoHG995h/jP91R5hIiyu2/CKtMO8sIYQQQggJp6QibX9rJ3bsz4YW+jfhHpHm75OWUpnaCncsWGcclwvttickKuTQKyQUKjUizZ+TFpc41R09fdISApFgM+vs2vG9Hm/vbAnYoOvx5rn7vMMd9ePC5kvGEGnuy02CL8rkqAIvYbluOvyfgfvzc15lRNqwDwDbV2uqO+Ya7mi/Dgt3jCvS6EkjhBBCCOlWSirSAGBnc0ipe3d+kSbcUZejVIgnrS0j0sLHeYWAt1hFxj5fTlpcoj1pmj5pMNvs9+LEwdOI290nzS4dolS8MEcHZzpvdUfdOH1Lhsz6MRxplsZL5b8+NxFeOH5vpvv74CyVcITPkZPSIi1WM2tNdUf/uTBBlbcnjSKNEEIIIaQrKWmfNCBbyREIdm0a3K8q8zoY7qiMfa5WvLsbW/a6PXTxIrTaOy38afVW1P5uTeg4z15YIVNl0muHpX0dRRwBYfk8aQi5vygv3nu7DuATd72ImoF9PGtkr8/arhNJceRMpk+a6zn9Ze12zbhwe+MUDnFfbay2GDFHgQUxA/hFujtfMesBtX8OGgm07kPgX0McYaQrHBJ6XRFz0iZeBuDn8eYjhBBCCCGhlFykHWx3b1jN+DfvHSlL6/FQCoHS6hIxt0Nbp4Unl4fnIwFBb03S39MKXg9WLnlhcQqHpAKeNLN4CVt7TO18TD/+MABAY1Nb5rjHkxZRVj5OiX9HVLrDFX/y/IbguKjqjjH8vrp8r+CY8DmK7knThOpmjUn/yDSzrqi2j/tCLuM0s/aUHY1RJj9fj5juulEn5zcXIYQQQggJUPJwx1ZX2XK/F8ntxQmeM3vS8qU9ZaEjRhNrb06Wtwqlzo7cwh0j1lbeht0VSbE9hfoLOyO8eH9bv0Njg9v28OtjiTRHiEQ4wizDZ+qQqyfNlJ9oyt+Lui5f/BUzO6zgHybEufGMSAvJNzMd8zfE9qygIbYY9Y3TCUCnLxshhBBCCCmY0os0V5EG/5bR7XHw55p1WvoiE7qctDibeyAd7hhPdLhzivS5cZ4S/K5N/+9XbYk9tx7ly0lLICHmrXg+fdLcukyn0ZTKypz2GKJWF+6oHxd+/7GqO7ouN+UnRj2SImu0UE+aY6JkPGl2iK//weuEUZhI6zyoH+MZH7Mptf956OZMVgWPEUIIIYSQvCi5SDvY4fakec+5vVH+PWtnytIXn9DssONWbo8r0rwhdWlvlh9vyGB2zqt/syr23Dos5RUfFXa4oyNuduxvxcI3svleufRoy9hr8KTpHmMckZbpkxbxQaRL8JvPR3nigJietIhnXEjxmQmjBweO+T8Dj0izLQ6EO6bsgjqZKo8am/zCzW13Z1v2stZ9wF+uzx7LjC9i4ZAEPWmEEEIIIcWivESa75zbA6Gr7qgNdyyoumPK0xjbhKeZNUzNrJX2dS5z60iHO/py0lyFQy7++SuY9eiKzPm8PGmewiGavD9k14tzb85n4n9O/semXDlpZxxXE5gnjkfUY3ue34U4bQVM/MfpHwgcCxQO8YTxpn9mSvBX2AVcHC9XzfHegW6sDu97t3jqcHnSXvwh8Op9wKrHfOONt+HlsQuBV+/Xr+OQLHl6KyGEEEJIr6EkIq1vZRIf++BwAL6eVAEhlt0M+kWaqfGxTlTEbYIc35OWfW0poFJT0cLtPWntiBlWhhgl+OH1NlU4Is1+X7/L2xcrnxy9Ve/t1V7vPEd3Cf62WOGO6Z/+cEf/55Jy9UnrU+ErQY+YnjTfZxM1RkcheY3VlUG7/UI2pfnjQyYnLWmLNMej9sUn0j91wijUk+ZUN1XZ10rpy/TH4S+1+nUc6EkjhBBCCCkaJRFpxx42APd/OV0NrtW1yQ/LSfPvmzsNoXG6HKqY0Y7pwiH55KRpS/BnxxyIaI7sJkoe+MvUp71TYhQe+XjS/v2R5ZnXOsHivv/2HMJD/Y/JL0jTOWnp17oQ0jhi210UxB/u6FTBjBLClsrfm9anIlywA74S/KactFQ7cPhJQL/h9kCdSOv0vk+5eg5mPGkqK+YSSZ+wy+UeXc9e60mjSCOEEEIIKRYli1GqrkxvZt2FQ3QhjQ5+sZDe+Go8abqy/DFtauuwYoY7egs/6PqkdeYp0qKbWXs9iBWJhJ1zp78un5w0rz06G7Kv2zuj780Rzv6cNP+tWi7vaGUyKHbietLG1M7H6eNG4LjDBxrHhNqrFOav2Ra9GII9+PShr+actMw8zv86BTg624HKvhE5aX6R5so5c3vSHFElSe81uQhR941qc9IY7kgIIYQQUixKlpNWZW/C4xYO8Xs2TDlpOpETt6R6h6VieoZcr6G0Xh93qGYu4Y6ZfXDIBtpb3THtH8q3mXUU2ufpCkssbnXHrHdUJ3ZileC3r/9H3c6AwHS8bFFP5M2t+/HNX78WuZbOJn2lT3MYr8eTJols2GBnKwDJirQ4nrROlyctE+JoeT1p7oqO7jn7Dg3O70Zcvypcc1gAmkSwvaM5/HpCCCGEEBKbkv35W0TQpyIRKtK8OWnec6acNJ0gi9uc2LJU7jlplr5qodtb0pZLTpptf1g+lVt4OX3SdrW04/Gl7wXG51K0RIfOM+m2LY6oNRUO0c2rMp40Xbhj5FIecZsy9HiLCmV8Z2dL9EKOTb73ulv095rr0FR3FKXSQsgJG0y12zdsT+gWVEqlz/lz0tyetA53Hprbk5a+xgJwAArNySSaEwk0V1WhBdVoFkFLIoGmRML+mX7fnKxAC1R6bMvraD5qJFrsMQCApd8PeUqEEEIIISQXShqj1Kci4Ql39JNy90nT9JrSbbX1OVTx7ElZShuKFpzPvcnWiw+3He15VHc0CUtLKY8wSIhkvDfX/25NqB35oBM0lso+p7Vb9seYI/0zyhOWslTGXn24Y27NrB9+5V3POScnzaTRjhxcjW37WvH+/lb9AA1pm7IT6ryFAU9aKpuj5/WkucIdU+3wetLSPywAB9qa0Ly/Ac07VqO5T1VaRImg5cC7aBo0MP3+4Ca0jBiG5kQSzQffRPORh6Nl/c/R9NbP0XLM6Ky48nBY4Eg/y8IAy0J/BQxIpTBAWTg8UY3+B3emj1sKAy0LA6Z9Bxfie7GfGyGE9HREZC6AcwDsUEqdZB8bBuAJAGMA1AO4WCm1R3Pt5QCcv27drpR6uDtsJoT0HEor0iqT2NOSDdHy75237stuloPhjlbRS/BbSsXr++W7Rhfu2OESR3G8c9m57ZC8EE+a+1xCwguj+L04ueK+3NFIlqVymveZ19INvKNyypQr3LFCIyJyCXcMHWMIeLx25nG4ff467HZ9JyPxmaQNd/R9p5wS/AlJF95PIoU3UtuwYkA/NNb/EXuHD0VTMonmqiY0P3cFmkcdgebNT6fFlQjUE9Oyk408Ivv6YB0wPB222M/ajQF9q9PiyupMi6vqEeg/5BgMeP1JDLAUBiigv9WJAZZC/z5DMLBlJ/pbyhZlaQGWqVVZ0TfbIPvEjwE7V3tv8qjp8Z8ZIYT0DuYB+BmAR1zHagH8TSk1W0Rq7ffXuS+yhdzNAKYgvaVYISJ/0Ik5QsihS0lFWnVlwlNgIywMzS++UpbShzZqtMOXP3o0fvVqMBQw1E9UwwAAIABJREFUcK2Kl5PW2JQNK1Mq66Fx4y7YkZNIi/CkKd85Z6NvIo5nMAz3Ws59/vj5DRjevyrnuaLCHd0l+PMOd4xRJsb0NROJV5zEc43vve56/3fKEW2JhEApha9W/AG3qjWwhg1CxeaFGNS/HwalLAyAwoCKvqjp6MSAoUdgwO5VaRF15o3o//zNaaHleLoshQEfPBMDNixMi6vRU4GGpekFB6SA5kbg9MuAo08DXpxjG5/IhkImBgNtIeLUk5PG6o6EEKKUWiwiY3yHzwfwKfv1wwAWwSfSAMwE8LxSajcAiMjzAD4D4PEuMpUQ0gMpqUjThbSZ8OuxjpShT5rv2LNXTcPbjc2xRFrc0MCfPr8h81oppRUGnXl60px7MgkJS3nFqUi43fmU4NfZA3gF0K5cvE02UZ4wy8qup/NOuq8/4chBWLctGGoZz5OmRyCxvHUmm3TvgeBn4Ii2pC2w91YdhCWCG3buwcVfnI/Ezz+RHjhqCjDjQeDlwcAJpwJrF6WPv/IroEmTN5dC9h9Ka7bXHZrfz9yhJ4/NI7Yi7tt9X+yTRgghJg5XSjnlgbcDOFwzZhSAza73DfaxACIyC8AsADj66KOLaCY5FBlTO7/L5q6ffXaXzX2oUpTqjiLyGRF5S0Q22u79WPgLboQV+NA1s9YWtfBtiKuSidg5aXHHDazOatv2lIV9BzsCY7yeNO/EcSo3Gj1CyitEEyKhz63QnLT//NVKrNqc3vAXEEkKINoT5q7uGBXueM9lk7VzxDEx7HnpRNbooX2N493DExKdnwhkRXs6J01hd590A/JpBw8i4TSzdk/u9ngBwLZVemPchUMO7g2eVylvdUfTjWjPR3nSWIKfEELcqPT/2Rf0/5xKqTlKqSlKqSk1NTVFsowQ0hMoWKSJSBLAvQA+C+BEAJeJyIlxrvVvaMNEwFd/uczzvtOytKGN/g1xVUUidmPiuILG7QH87pOva4tneAqH+HKSwtbJFg7Rn1cIhnl2pScNAJ5Z2ZBeu0CVpgsLdWMpd580nSdN/9ozR8j9brcLgoSFO/q/k1869WjUfvZ445zu0RXJRKyQzHZPuCOQVEmccrAVozpTvrBBg0gz4S7B36oRaVYqWLY/Lu4be2tB8Dw9aYQQAgDvi8iRAGD/3KEZswXAUa73o+1jhBCSoRietKkANiql3lZKtQP4DdIx2dGL+5sb57Co0ZPmO9anIhF73rgizR2+aBJBYeGOYcIpMidNee1MiITOZypDnws7mtrwzs4WbN5zsKB5dMLLjeUqilIRUd3RFJYYq4VCyDn/tCccOUjr1cuOz16QlHjhku2Z6o7pcMejmo7A3O070v8Yk7pcP4kn0iyXRzelCUe1UvqkTWeNUCLOMyeNEEIA4A8ALrdfXw7g95oxzwGYISJDRWQogBn2MUIIyVAMkRYrtlpEZonIchFZ3tjYmF7ct3ounhpTTppOpMVVaXH7qcURc+6CHf7iHWHrOM/AtCe3FOCeTiTce1Ro4RAAeH9/K864exFeWK/7g2CQ448YqD1eXZnEd876kPE6dzGYCl0za9f3xSSGYnkODc9fRAKetIRIqHfMfW5ov8rI4ihA1pOWtD1pVkYAKZ/Yse2URLxYU50wc6NCPGm5hDvqoCeNEHKIISKPA3gFwHEi0iAiXwMwG8CnRaQOwFn2e4jIFBH5BQDYBUN+AGCZ/d9tThERQghx6LZEEqXUHABzAGDKlCkKCOak5SInjCX4feKmqiIRq+Jf+tp445a/G10lt8PlsWjLwZMWlZOmoDzesYQIwnRYRwxP2oA+FRg+oArv7jqgPf+2obnz0cP64b3dwWuGD9BXfhQBPnbscPz0r3o7vCX4ddUdxfVaP0ccT5rp8QuC4q8iGe4dc587fHB1rOqQrXZz82RC0uGrbi+V25Om3CIthictFRHKaIXkpEURJeKYk0YIOcRQSl1mOBXoSaKUWg7g313v5wKY20WmEUJ6AcXwpOUdWx1o/JuDSjP1M/OHQPapSMYueBHXkxYHt+Dz98kK83zV7zqAT971YiZ/yk863DH9ujIpOHpYv9D5UjE8aR8/dgQum2quGrX3QLAwCmB7KTWYdKGIhIqYlKVc1R3Dwx3NIi1OCX6TJy2Y61aVTIQG+rntOGJQtUdImtjfmn6e/auStifNda9aT5oh3HHIMcCwD2bfW/rPKTtdylvd0UOB4Y70pBFCCCGEFI1iiLRlAMaJyFgRqQJwKdIx2dGLh3jSojwSJpEWqO6YQ05anA1+XDzhjlZ8T9rSd3bj3V0H8MxKvc5VruIab9z6GfStShZcOCSllNZzFUV1ZVJ73OQFFNf/6kjnpCltAQ/AXzjEe37qmGG44mNjIix27NOjK8FfmUwEwnK912Q5YnB1wDuso6k17fFKSDrcUbln0YkdU6hh36FAwvUZpGyRVmGoRhlWOCRSozEnjRBCCCGkuyg4Rkkp1Ski30Q66TUJYK5S6o041wbCHV0ejmRCYIWIJlPTab9gcfJ+4tCZQz+zyLlsYVaZlID4C/N8OZjuTyErAB0hE144JHqtOPboqDJ40sKqJ4bt9f+5cScUFBIiWrHjPpJrPzM3YbfrF4eVSQmtSum24z9O/0CsHEBHpKXsHnt5hztKwivgHAFWUQV0aoq8WKl4YZNaojxpDHckhBBCCCkWRemTppRaoJT6kFLqg0qpO2Iv7lvd7R2L2oSbvF66io9HDqmOZU9HEcrVOzib9YpEIuD1i+PdMm32O1IKa7fuA5D1LIWFacbJ0Tp34si8RI8p3DHMUxW2ys9e3Ii2DitdJVHrSQsJd4wQgG5MYjwd7hj0pMUpHPKtM4/FyCF9Y9mw3+6rZykVDHdMJIAZzj8h50kawh39Is3xpJlCD8MKh/g/mcM+HHYLmsvzF82EEEIIIcRLUURavvi9Fu83tRnPxUXnFTrjuMPw+H98FJefdkzotcX0pDmesLQnLX6fNAeTuPrRgnV4/s33AWQLaRTiSXv1+um4YPKovPbYJpFmUmk6EeTntc177XDH4Dm3cNNNE9WHzcH0vATBPxykRVpoVprRRhNNdk6aZcFX3dGZ0jbCEd+pdmDJA5ql/SLNru5o8mpZITlpkdUdKcIIIYQQQrqLkoo0/4bdLSji5PbocG/A3VOc9sHhSIYlFyE8DC5X2jrSIqsimchLpJnCHXUCIyxcMSrPzuldls/T7lORe06a/2P95IdqPO83bG9CwtBvLCwnDZq5Tdz13Ft6+yT4vatMhhc78a+ZS06aZYc7KpNIc9CFLjqL68IdTflhVmcO1R1j/GMY+4mYcxFCCCGEkFwoK5HmOZenJ83tDav0ibLudAa0pywkbM+RP3RRF5LpJ5ciJv7CJH47wnA8lvk87z6VueWkQYLeLn/Bkqa2TiSMhUNE+9qeOi+h6TfQ7zWrrEhE5KSFv9fhVHfMhDsqk0iL+A4Ywx0NnrRcwh396DxwF2i8e4QQQgghpGDKJtxxWP8q47lccIsbv+MszynzJpkQJBNBoRQr3NFQvVJHjFZoRhxxlp8nLY+cNL+oMYgxbeEQ16FASprkL+w9c2hK8Id60mxLMjU+cvCkpaz0s7L8/wydOaLEfKBwiC3SjJ40K6w/QvhaOg+cCDDY3LqBEEIIIYTkR4k9adnXF5082nfOvGk8bGCfzGu/J8YtiPwb/Tgb6GIidtheMXPSdMTxzJnIPKO8CocYwh1D+pD5l9E3rdYLPQn1pMXNSDMjCIa8ViYTWgWbMDy2OH9cONCeFjxKqXRLBWO4YwyR5i7B73jJ8iocEoG2KqQA//kP4OrX85uTEEIIIYRoKZtwx2MPG+A5pysc4VBdmUT/qvTmdFBf74bULW78npXuLn2QtEWaf+NfSE6ajjjzmUh2qyctGO6oDWs0CB236Na2DivCB+wPHU3npAUnrrDdtM45Z0guzrx0CX6Yc9KiPlZ/TppDMqRwSNycNL/Q1nngRIC+Q4ChY+LNSQghhBBCYlE24Y7+nlthBRgUFBb/1xn47dc/FtiXu0WaXwB0tyctHe4YXDOOqIrTb8shrAR/FI7IyKcEf+590oLhjjpPmtPkOXi967XmnFsAfuq4GuSKaPIHK5MJrfZzQmn9kYm5fMcsS+Gt7U2acMeY/yz94Y4Z40IKh+hyy8ZfhOAT9X0AphYAhBBCCCGk6JSNJ63K5zqLyi8aPqAPTj5maGDT795kB8Md8zQ0T3Q5TkC8Pmm5hDvmIuj8ZDxpeTwbc3VHPYKgGNRV3IzjjQrO4xWAfSv1toUhCD73ymRC+110PGn5hDs6WAq4/ndr8g93NJVLMeWkte4FFv3Ie2z4OOBffhFtrNYD192+aUIIIYSQQ4PSijTXhrbCJ9LCNtluL4vfc+EOE/SfK0XhEN0GP47nKxeR5p7PKakfl0xuVU5XpTFVdzS50nQ5abqwVpM3asqYYZnXfpGWEG8gZd+qPESaBAV0ZVKf65Z9bvl/xxyPamSftFwxVXdcMQ/Y8ab32K46e02fDYFwR0PhEEIIIYQQUnRKG+7oyuOp8ImLfn0MG00f4eGO/rHdHO5oqFL4H48sj7y2LYfqju7wSbdHMo5XRwoId8yruqPvmM6TlhQJ9Fr7wQUn4byJI7NzCfDzr5yMM+ywxoqEN3esX74izR/uWKFvZm3yQObyHJ0/KJj7pMURaZoxJpFWCNrqjgx3JIQQQgjpCsoi3DEhEsxNCvEieD1p3nMdna4S/CX2pFUYik7sPdAReW2ckEgHt0hze+5yaQhe1HDHsD5pvoX0OWnBS48YVO2dSoCZHz4i0ww74Qt3HNLX29IhDoJgJc6qZEL7bDL95TQevbhkPWl55qSZMIU7hhJht7a6IyGEEEII6QrKItxRJJvjk/Mcvk2xp7qjf8PczeFZFQl9PlMcOvMswe9eLZdHOnJI3/iDbUyeNFM4pz7cMfh8RFM4ZIDPs5qtqpj+mfSFOw7tn7tIgzbcMaEVXqaqmPl83HmHO5q+z07hkMFHA30GZY8ndc/EiduMKBySy/olQkSSIvKaiPzJfj9WRJaIyEYReUJE8vhSEEIIIYR0PyUOd8xutP25VHH9SIFwR49XyXuuuz1pVRXhjZDDaM8z3NFNLuGd044dgY8fOyL2eCAkJ82ArsyF1pOmmXaUT0T6S98nE14FODwfkYZgLmAyoX+KmT8qFBDu6BAUac77GP8KdELOKcFfWQ189OuueXWeT8MasfLhykukAbgawDrX+zsB/FQpdSyAPQC+VhKrCCGEEEJypMSeNPunBAuHhO0R3c2S/eFzHZ0hzay7eVNZYSjBH4d2OzcqzuWWQaT5e35FcerYYZFjBlVnPVr+ipwO4SX4g1UZAWDq2GG40G5orhM6hw/u43nvL3jiF1NHDPaGR8ZBoK+UqdNd2e+uL9wxr887T0+a6byTkyYJIOUKrU21x7chDmWUkyYiowGcDeAX9nsBcCaAp+0hDwO4oDTWEUIIIYTkRlnkpAmCOWlO4YjTx+Xm3QlrZt3dnjRTqJyJk0ZlQ9McgeVcf9+XPmK8zpS/lmuP6zgCo19VVqRV5tHM2r+EI9KOO3wgKpPZBtH+Ofz5b+IPd/TlpI0d0d98Eyb7RLTCVqeFsvmU9piYvl+d59Bcgj8P3L3TJJHujebgFP/4l4c01+Uj0srKk/a/AP4LgPMBDgewVynlPIAGAKNKYRghhBBCSK6URTPrhCCzQQeA/q7KfJecclRmY3v+pJHw4w+Nc5fgL3WftMqk5CQM3XlXjkcwjnCaMmZozrYVA53gALKezinHeO3yN5x2z5EQl3dMvN7SiaMHG21wPtOEZIu0DOlXiaH98ikcAnRoPGm6HDsnHy8X72z97LNx2MA+gePmwiF5VHeUpFekHXZi8JKjTo0xbxzKQ6SJyDkAdiilVuR5/SwRWS4iyxsbG4tsHSGEEEJI7nRBre74uIs/uMMCF117Bq745VLPGEBfrdC/SQ4rHGLqv9VVVBoqA5pwe74csRCnQuOPL5qESUfV44cL1me27B+o6Y/6nS0AHNETvX6ujyeq2MusT3wAyx/N7psFEljDKcGv4K32OcQWWbM+8QH89+dOMNtsf/4VrnDH4f2rUGXw8oXhtu3kY4Zixbt7AOhFmr+PX1yxpvsOFrVPWqIC2WIgCWDipcCRE4An/xXYtdE7v3dR3/s4X5iyCXecBuA8EfkcgGoAgwD8H4AhIlJhe9NGA9iiu1gpNQfAHACYMmVK/p3hCSGklzOmdn6pTSDkkKE8wh3F24S5xuVtSEh2u+gIOfcuyr/ndecU+b1Q/rF/++4n8fdrP5WX7XGoSAZzsMI48chsuKPjERzcN12pryppLkLStyqJiaOHpN8o4JF/m4onrzwtc74yZpnHXIte+HvbOTjawn/eX91RJDvGUipzfwkBPjFuBO65bDK+O+NDoTY4YYbuEvwjBgS9VXFwC637vvQR1M8+GwCgK7TZxxZpzppxwx2d8e7nEOyTlkPhEH/FxoTPkyYCHP5hb9GQhKaAyKdv9VaC7ApV30Uopa5XSo1WSo0BcCmAF5RSXwLwIoAL7WGXA/h9iUwkhBBCCMmJEoc72kaIGAuHuEWOrghHeAl+71i/t+ODNQNwzPDcc5fiUplMxO5V9tdrPoGzJxwZOH7TuSfius8cjzOPPyxU8FXboiGlFD7xoRqMGNAns8U3iSk/uW65TUVRHMGia1Ttvod0jpoj0ryNtUUE504caezF5uAUTUkmstcP6ZcWtqtu+jQ+WBP/83U/Xnd7AV31TOd55ypsneHuUFFLFdAnrdoXCppIupRgwns8bP4PzQSu3xx/3fREOY7vdq4DcI2IbEQ6R02TjEcIIYQQUn6UTZ+0SsOGP+Hqf+WM9zSz9o1vd3nS/CKiFIVD4lZ3PPawgVr7BlVX4uuf+mDaUxRyvVMO311ExHlOOht+cMFJuPKTH/Acy9UxYvLQOev6P1P3Z+m8r8h8pirQ+ywOzv26xbCT3zikX1WkyDPhDpdUGq9SdUU2TDMXnHt0fyb5Fw5RXu8XYHvMNCJNfCJt/EUx1wihTDxpbpRSi5RS59iv31ZKTVVKHauUukgp1VZq+wghvR8ROU5EVrn+2y8i3/aN+ZSI7HON+f/bu/c4Oaoyb+C/p3t6Lpnck8n9MjEJxAQSgmNMwsWEgIaLRBQFVBBvEQQBL68G8IXXZdmF9f4Kn2Xj4qq78YICmldEbosf8OOKQDZyC1EEFJAFFlRAliQz87x/VFX36e5T1+6uqp75fT+fMNNV1VWnu2uKevo55zkXZdVeIsqnXIxJs2bSyttUlpVv6OEfpZmZtNqb/bTvKTsKgn2xjmnLFBprA/bV7QYjtnL8XR0FvFSz7MSD56CnszqAiZIVMifO9s+k2dfXdncsGGMRh4Yr3R19Kvvb2zNc6e5oC4DiMJ9lTi8wZBuT5r53eweHEh3DGc/nnKsNjUnrrgnSCh1GNRWfLo5SAI77MnD/9wN23FZj0oiIckNVdwM4CABEpAhnPOz1lk3v9L5UIiKqlYvJrAtSf2PtZS/MwMEWRNQuGayq7li9LslEw40odUTPpAE+mb6qIC28u6OtHL9ZNbKyr8jNqmIGgf5j0tS63uze6C2ojEmrZErjfE5eUY+iVMakRe1iWsf8QqAY0t3RDYp73fc2ajVJ7zP0xhoCDY5Ji9zd0TgHpFA/li2R/GXSiIhyZgOA36nq77NuCBG1l1x0dwSkqnCIybzfLlq6O9aPSQvP9DTT8SvqpwUoH18kVsBgC8LM1xfY3TGgmuG47pLvurDj19prTBbe7dOVsJJJq26T1HR3FFQ+o+FhNYpqRH/PvJi8WKzvFmu2JQq/DqW2AMzrXrrpoNn4hxOX4/S1/dGO4R5izqSe8jLfEvyhmTSp7+5oVnc0X0/ROAekUP04qRx2dyQiypmTAXzHZ90aEfm1iNwoIstsG3CKEKLRK+PqjpXf/cq5V5XgtwRdtfeJewNK8Dc7k/bwJRvxDycu910/NKyxAg5bTFkVpAV1dyz5j72KmkmLEtO+tKcyOXJ3yef08cbC1XY3Lf+n0gZvm2FjTFqc2HrInXzazKT5zd8WRgR4q2UuvhVzJ2LjshlVy7wS/HsHh/HOgbl13XV9j+H+nDt5THlZQ5NZ12bSzMmsq7o71mTSws5LvwDxdKP8Mrs7EhH5EpFOAMcDsPUt3wFgvqquAPBVAD+07UNVt6rqgKoO9PX1ta6xRJQ7uejuCGhdJs1W9MJagr/mBtfM9NTPkxavfcsDJlEGnMCou1TEBccssU5SvG9oONb4Klsmx4w3goLMoEza2O76IC1K19EwXaUidv/txrrJpsvjCY0m/d0JB1aNG/PaUM6kaeW1xgmmy5m0gpTfvygTgNsIgC+fvBKP/f0xdesOWTy16rFXgv/VfdHGpO03faxzDPe1zZzQXV7nH6RFyAMueyuw6ChgwjznsTkmrWoAYEh1xzo+x+4z5qxjJo2IKMjRAHao6jO1K1T1RVV92f39JwBKIjK1djsiGr1y0d1RjfLrHq84SFV3R1tgYSzqG9dVFaTVV3eMd1O5/exD8baDZ4dut/nwhVg0bWzd8sFhjXVM26Y1Q7h8ee/lKavm1q0bZ8ukWY8f3Na/f9uBuOo9B5cfd5cK6Ooo1gVFtvGE73rDvLrjCmrnSUuQSfPGpBXsmTRbZUY/3uu3dzutfuxlEV+NUDjk1xe/CdvPPrRqWUehgI8d6cwBp4m7OyrQNQ54zw+ASfPdhvpUdzQzabZ50qIqZlpriIionZwCn66OIjJD3P/ZiMgqOPdjz6fYNiLKuVxUdwy6Fa3KvNhK8Lvrz1q/EEPDwNfufLRu+8q2CRoZ8R7ftu99Q8N1FRTj7qNqXrGQF/DIpUdbu4T2Wrs7BgciIvUxwimr5lU97vRJE3p1NqzZurpMWsF9jgYGSX7M7o7mfputdp+vmerMvzZrQo9t8ypmkZDK/oCPbliML936m8YyaeXneGnIDuP5ZiatprtjUgUGaUREYUSkF8BRAD5sLDsDAFT1KgAnAjhTRAYB/A+AkzXOt4pENOJlesdVLCcM6q9Latzo12dIKtuXi0WIoFisrsRXN5l1gpv3Rq6Yg0Mar3CItbtjtDFpAHzHRY2zdHe07qqmSElo2Qp3+8MX9+E///Dn8vLKZNaW59Q86CgXDql8XnE+Ja+7oxmQJw3Sgp5Wu+rNy2bg2x98A1a/ZkrDx2poTFrlSe6PiNUdk2KQRkQUSlX/CmBKzbKrjN+vAHBF2u0iovaRceGQKJm0yu9BhUNEpDyJsefSEw6s3jZBG6N+sWULsAaHh2N13bPVTqnKbkXfVRXbmLSwwiFxAp1zNyzGzz+9vvzYe8uiVKv0HpvdHeMYNro7etMP+E0NECawO6nbtrULp+DWjx8OEcHaRVNjj3/ztjbfG//qjnF2bBQL8X4PC9I2XVldCMTkd94XmlAVkoiIiIgC5aO7o+V+0FskInVFRKq7O3r7qs4kfXrjEsyeWN0VLVkQEG07e3dHjXUTbwv0zGXmjf0lm6zVeq2sY9KshUOiZ+1MhYJgptHtr/x5hezEKSTi/G4WDonDy5x2FAR73PGILcmkuetmTujBomnjEu3fT3O6O7rPKfUgeEyaVF7MyvcE7NB2bLF/k0BERERETZVxd0cv6HJuCI9dPhNrarqPVWXSLHfRZrdIs0Kk7YY/yb17Q90dh4cbLhxi3hN766eN68Kpa/oj73di5ImWI++yTtj0AZ5hre6qambSKmPSoh/XC9IKIlUBWzL+z6t8odCcIQPma/SdzDrOsbznlHqCuzs20tWxGXOrEREREVGohr4WF5F3iMiDIjIsIgOxD15TUv/Kdx2M96x2qtSZFQLL2TLLzXclSAM6jTL0zSgxb7YjicEhjRUw2DY1u3BWqh/GeyULpvZGmmy5unBI5cGdn1qPX2w5IvC55vb/+7ilmDq2E9PG109LUH08swR/su6OXmBWLFSCtKrJrBPEOda2uh/DcJOCNPO1NjeTNia4u2NDQVq0YJ+IiIiIGtNo36UHALwNwB2JDl5fB6SsPNeWOZm1+G5eNybNPuYq3cIhsyf2WMfR+avftuo1uT/jJoo6ioJT18yPcPTq8WKeuZPHYNbE8CqGno0HzMA9nznKOndb1Rx3Rs+7oWFN1t1RK4FZeXxa0u6OAesqGb9Euw48lu+YtFg7dJ/T0W0sM9PQbpAWpfx+zyT7ic9MGhEREVEqGuruqKq7gGRVE4HKzbT1vtfLkBn3q0VLuUAzmLNlnaok6e4YMXNiVpWcNaEbF71lKdYsnIov3rw78rFsQYqZiTOLpMSRpPtfM6rY29rpzS/mblE1LjFRJm2o0sWxklWrrP/YUYtxxr/tiL1fP83KpEWq7hgrDegGX412d/zgbcCEOcA/H1W/jpm0tte/xadQDBEREeVKalUARGSziNwjIvc899xzzsFrxqSZ7Jm0+u0r3SIROiYtUSbN5z556czxVY8Hh6o33HjATEzoKZXnAYvCFtSYXTiTjNkCgGKhEOt+H7AXMWmGMZ0duO4jawE4n1GlwqcmCgzPXLcQy2aNx8ZlM4yJrSvv2cYDZmJhX2+kfQUFv1EqkcZhvr+qTeju2OVOpl7V3dHYb9Qgbc4AMG6GfR0rOxIRERGlIjSCEJFbReQBy79NcQ6kqltVdUBVB/r6+gCEZNK8BppBWkBr6zJptnL9cRrs8gtuvvvh1VWPB91JlWvFKQdv27Iqk+b+jBtsOvuIF14EJd+mj+/CYYunxtqfyQtwP3bUfuXjON0d439C/VN7ccM5h2FSb2c5q1Z7nthe+RFLptUti9LdMUpmde3CKXh9/6TAbaozaX4l+GN8Zt0TnJ+lbgRWd4zcldJybHZ3JCIiIkpFaHdHVT2yVQcvBNyLmhkyj5chsY9Jqxm/ZZujK+T+9KSBuZjhlaaPAAAgAElEQVQ1sQdfuvU35WV+3dvGd1ffsA4a3R3NZ8QZk2YLUjos4+zi9l4s1pTI96NGy4OySndd0Ngp0V0q4vHLjgUA/PLR5wEkL8FvsmXSAFhPmDPXLcS/P/xs1bIoJfh9YvEq3/7Qajz5p1dw6OW3B+zPyKTVrUyQ4O50M2kdPcDQnvr9eGPRou7bdt573R2XHAc8/OP4bSQiIiKiSDIuwe/cMA4FZAwkJJMWqwS/T65k+9mHoKdUxOLpzvxXZpAWNZexb8i+ZZzxYLYgobOqcEiy6o7FgqC3qwOPX3Zs5DEprensWK9ckGM43pxyNuUxaTW76S7VF8uwV//0P74XbEftver3GZWHixnL/AuHhJx95t9Nh1tJU4d9qjuW6pfF5QVp7/wWMLQv+X6IiIiIKFCjJfhPEJEnAawBcIOI3BTn+R2RxqRVltkmv/ayPwWpDmisN+E+9+DL50wsB2h17YgYpQ0O2VMs5Zv7CPGHrX0dlsAz/pi0BMFPk6K07lIBn9q4v+/6ymTWmrgAjccsx2/aetrrfI9rCjr8EUum4fS1/fjs8QdEaotfkOadT8HzpCXo7uh1RRzai+Z0d7Qdw6gQWeoO3paIiIiIEmu0uuP1AK5PfHD3TnkooK65iLgZDkWH192xqnBIZbuOqiDNvi9Pp6U8vF1926Zb5v8a9HkNUcbdeWxBSnV1x2SZtETVHQH0lIqBWc4oHr7k6ODjGKXtG+3uOGyU4zfNmTQGqxZMxq8ee6G8LO57WCoW8H+OXxZ5+7CMW/A8ad7jOEGam+Ua2lf53RakRd6ntQ9y9PYQERERUWKZdnf0xpDZ4pty8GUss3Z3LK+r7u5o67pm3rvfd/GbIrWx9r70+o+sxZxJY+q22+eXSXPb1FMq4pW9Q4HHsoUNtsAtjUyaiGDnxS0bjlhWNLKpSQqHmCrdHev3M1xzkjV6rDCh3R2jlOCvteEi4La/sa/zArPhfT4l+N0unxphUJ2f4eDzl4iIiIiaI7US/DZBlQ+9bowild9thUO8m++OQvhk1l7g1tVRsI5Tsrej2sp5k9A3zpJJCxmTtvo1U/DZkExMWOAwprMYabv6NsT/mEWAro4iujqivU9Jlas7amUy66Tl/wd9ujt6+zdZz48mxm1hn1GkMWm13xAseYv/DifMdX6On23s3VKCP0rlE9uxAUAZpBERERGlIdNMWlDwUMmkBRcOqVT0k6oujLab5CTd6aJOXmyW4DefUjS6aL53bT8u3v6g7z7CgoQZE7rx22dfjj12K0GMlqiLZBKVwiHJJ0X3DAcFaREyac2cG86Wzas+WGWsYuR50sbP9N/f/kcD77oGWHQkcMfn3f2YDXLHrDWUSRtM/lwiIiIasaIWpovLqwY+GmXc3TEgk2YUWPDGpJVvrI1712EjSDMzabYb9SQxQMBwuSph1R2jjUkLXj9zglOsIW78lCSTlqjYSAJTxzpZydWvmdJ4d0f3Tba1vTbYbtb54SesPkc51yWCYb8grfYLgqDJpEWA/d5c+b1WM8aksbsjERERUSoy7e5YCpqd2sJ68z1cWVddZMO2BwlYZxdl8mIgvLpjFGGZHG+us6BCKzZRm1BV0T1J+i2BGRO68bNPrsMFxyxpvHBIYCat+nHc6o5xhQWc3npBjBL8UgDWnQ90hFVWtAVpzRiTxkwaERERURpyOybNxlYp0cuQdBQKVTfnthv1ViaH9vkETnG6DYZtOsPNpD3/172R9wkk60aYViYNAPqn9qKjWEi1cIi1IEsK3R2l5osCkRiFQ6QArNsCnPLd4IOXj20Zk8bCIURERES5l/tMmnmva1YC9FTmxqoOLGw3yUlK2DdrnrQo+wkLpnrcYid79kW7WX7bytmRtrNJa0yaqdFM1n4znLnuvGDWVFs4pCDANR9eg1NXz2/soD78Xku5II63HST6PGmFiEVcgro7MpNGRERElHvZZtICAgFbN0P7WCNvXXUmxhbweE+PWtkRqNxUh/HrgehlCyONSQtZ7+0ram/Hz79jBXb/7cZoG9eonWssDY1m0s45YhGu+8harJw3qW6drQT/qgWTcclbK5NTp1rdsSqTFrW7Y9QGWur8F2IWDjH//g58h7uMmTQiIiKiNORinrQgZrBlC9K03N1RqroLBhWG6Io8kXXj8/cWY4ztCrux98aJRR2TVigIuqJmX+qO1X5BWkexgIMtARpgy6TZujs2j1930Up3x0q3R9/JrJOee+UgzwzS4o5Jcw9+zk7nOfd/n5k0IiIiopRkW4I/YEza6xdMxo92/hFjjKxX0PxXxYLUjEmr36d3YxwnSItagt9kZt/K4+gi9XcMXu1Vw6wNOOK49eOH4w8vvBK6XZpj0jytPGRdCX7r+dG844W9Fm91QaQ+SIscLvqcB83s7igCdDgFazgmjYiIiCgdGXd39D/85W9fjpvOOxyTejvL96xe9sM2mXWxIFVd9IIyJXEmaI4aDy2bNd66PE6wE7apl3mMW93RtGjaOByxZLp1nbnXpEFaI4FOo/OkBfngoQuqHtuzds07fthrKWfSgPoxaWUxgrCq9YX67YoB5fuDdwaUvCCNmTQiIiKiNOR2nrTuUhH7u4UgPPbujpV1ZrEQ+2TWbiatFKO7Y8Ttvv2h1djxhz/hff9yd9XyjiYWDvEyj40EaVElCdJ+cMYazJzYk/iYUQ75rfevStQL8PRDFuD0QxZgv8/ciL2Dw/YgPsXkoZlJqwsOy90dE/d3rF8UWra/RnmiwkIlk1ZK/tkSEY0mIvI4gJcADAEYVNWBmvUC4CsAjgHwCoDTVXVH2u0kovzKuLtjvESeLeAZMsakhZXgjzom7cZzD8OEnpJ7rGg3yhN6ShiY74yHMjNVxZpA9EOHLcDX7nwMADC+uwMvvlrJToTFCHHnlWtEkjFpA/2TGzpmwRin5efw/foaOkYlOPJfl4aCZdhYfUsSBmm2N7A0Jvm+St3AkZ8F9ktWhIaIaJRar6r/7bPuaACL3X9vAPCP7k8iIgBZB2kxAwGvO6M55svLKhUKUpUdsWVKvHgrrLvja2dWui7GSWaM6y7hl+dvwJSxneVltVMBXHjsUvR2deDLt/4Wpx+yABN6SvjrnkHfNpvSLOaRyZi0FGLQSlXF9F9fVTu8AiLmwqJ73njdFYudsAo7KW2FQ0oxM2nlvzF3H4eeF/P5REQUYBOAb6nzTfAvRWSiiMxU1aezbhgR5UPuqzuabHOfefertdUdbTHGnkGnaEKs6o6xWlg/R1dlHF1lT+VJk1XxAWOslPnyrj1zbXleNE+ambQsgrQ0Aifvvbdm0lIM3GqDxb9u/DJ6Fx7iLOwaC6y/EHjt8WF7ib68kUwaERHFpQBuFhEF8E+qurVm/WwATxiPn3SXVQVpIrIZwGYAmDdvXutaS0S5k2mQFjcQsE0MPexb3bF+33sGnep0scakNViD33aP61dh3dz2dfPrS8mnG6SlX1Om0RL8UXiHsHaHbfnR63nt2XPgu9Hba2TO3vipyu9n/gJ45kHLs0MKi5jvZyNj0oiIKK5DVfUpEZkG4BYReVhV74i7Eze42woAAwMDrR+QTkS5kWmQFldQCf6OQqEqE2KbjHnPPi+TFr26o1ej47wjF+OElbPjNLeKLdarXSYhYULQlAXNYLYnm3nSWn8M7xC2rFmaSSMvIC1nWoO+DJi+zPnniVrdsaq7Y8JMWiahKxFRe1PVp9yfz4rI9QBWATCDtKcAzDUez3GXEREByLgEf1zlTJqxrFLdsXpbW1bmVTeT1p2guuPh+/Vh/pTeyM/zlEtAaP2yum3DSvCnmN3KpLtjCgGBOYl0Nsev+ekuj1Wwc+ZBQNd44I2fjv6c2GPSXOzuSEQUi4j0isg473cAbwLwQM1m2wGcJo7VAP7C8WhEZGqLTFol++G/TW33PNv4tSSZNC+6SnyrWu7aaIxJsywDwrv7lTrSu2HOIpOWRjxgC5rTPH65F6FXOMQyZjFUz0Tg/Cf815cPYnZ3TFo+n0EaEVFM0wFc717fOwB8W1V/KiJnAICqXgXgJ3DK7z8CpwT/+zJqKxHlVFsEad7ta8FvMBfqgwpb0mnlvIkAgHX7Ry/jXnfsJijfmNd1dwwWNPl3s9m6i44IDVa3bxbvdHrfIf343E27Ma4r6WTTEcU+dyyBHhERhVLVRwGssCy/yvhdAZyVZruIqL20RZDm6XSrMp65bmHdutruebbueivnTcLDl2xEdyl6Jq127FBS1jFpNY9Duzu2eEyaKYtMWhq2ffAN+M6vnsD4nmxO/dpujmetX4Sz1i/KpC2ByifsyDwPiIiIiPKsrYK0joLg8cuOta6rDcr8gqo4ARoAfPWUlfjmLx7Hslnjwze2CBrnVJdJC5snrcXVHc0ud1mMSWuwkGYky+dMxPI5E63r0kwapVPunwEWERERUTvKRZA2Y3xwUYPymLSAm86oQVpccyePwWeOW5r4+bYemn5j0sKMlkxaVj3sspgnrTVYpZloJOrfckPL9u33BSgREWUj8yDt3s8cia6I2a2gG9vaoCKLTJDNwr6xAICTBiqVdiuTWcfb10iv7pi1NF9xa2O0ZownY6BHRERElJXMg7QpY7tCt+kuFbFncDhwm9pCF3mJMfrGddV9Q5n03jnNYh6jMkgb6d0dP3IXUIpZ5bENCoeIyFwA34JTUU0BbFXVr4jIZADfA9AP4HEA71TVP2XVTiIiIqKo2mKetGvPXIP/9eb9A8eT1VV3bIObyzznKk5fuyDrJqQujXnSPK2NgX3OrGlLgEnzI+4iz2dnnUEAn1DVpQBWAzhLRJYC2ALgNlVdDOA29zERERFR7mWeSYti0bRxWDRtXOA2Uao75kVlrq583QjPmTQGAHDRcUuxaNrYjFuTvnQzaS3ceVO6O7YPdwLYp93fXxKRXQBmA9gEYJ272TcB/AxAjBnAiYiIiLLRFkFaFLVziOU5k1YuHJKvGA1v3K8P1565Fivn2qsfUvOkmbVLJmcnZ0Qi0g9gJYC7AEx3AzgA+C843SFtz9kMYDMAzJs3r/WNJCIiokhaVTCpHYoltUV3xyhqE2cp1tiILc836K+bP2nkTmQdItVXnfe3eN4a52dH+JjRvBCRsQCuBXCeqr5ornMnjrVGnqq6VVUHVHWgry/6RPdERERErTJiMmm1hRiKOc6keZLmKtIsxT+qNPlt/dJJKzCl1x7ktDbT24SJqE/8OvDCo0Bnb1Na1GoiUoIToG1T1evcxc+IyExVfVpEZgJ4NrsWEhEREUU3YoK0WiO1u+ON5x6Gyb2dzW0QAWh+hvOElXMCjpWCRv4GOnuBGQc2ry0tJM43NFcD2KWqXzRWbQfwXgCXuT9/lEHziIiIiGJrKEgTkc8BeAuAvQB+B+B9qvrnZjSsUXnusudl/eJOZg0Ar505vtnNyY0k70czjbjCIaPHIQBOBXC/iOx0l10AJzi7RkQ+AOD3AN6ZUfuIiIiIYmk0k3YLgPNVdVBELgdwPnJSPS3P1R09o+9eOt/Sncw6g3nSRihV/Tn8X+yGNNtCRERE1AwNlddQ1ZtVddB9+EsA/v27WmTWhG7r8jyPSctvy7LlBdY9AfPhtVI6E0w7MpknjYiIiIjaQjPHpL0fwPeauL9IbjjnMDz38p665TmO0XLdtiytXjAF5xyxCKet7c+6KS1TDgQ5TxoRERER+QgN0kTkVgAzLKsuVNUfudtcCGAQwLaA/bRkLqJJvZ2YZCmkkefujnmdzDprhYLg42/aP7Pjp3HGeJ95nqdhICIiIqJshQZpqnpk0HoROR3AcQA2aEDUoapbAWwFgIGBgZZHJ3nu7uhhiJYvI6ZwCBERERG1tUarO24E8CkAb1TVV5rTpObI801wmmOfKLo0slveZ9/aIzH8JyIiImpnDRUOAXAFgHEAbhGRnSJyVRPa1BR5DoQamSeNWijFUyaVKSJy/DdARERERP4ayqSp6qJmNWQ08W6dhxml5Uqq3R1buXOeV0RERERtrdFMGiXBDEcupTpPWiol+HmeEREREbUjBmkZYr5jNGN3RyIiIiKyY5CWAd4651Ma4xi9I7R0SBq7OxIRERG1NQZpGWDhkHxKZZ4071ipZLn4dQARERFRO2KQloFKqXdGaXkyYgqHEBFRZkRkrojcLiIPiciDInKuZZt1IvIXtzL2ThG5KIu2ElF+NVTdkRrDTFq+pDJPmvczlcIhRESUgUEAn1DVHSIyDsC9InKLqj5Us92dqnpcBu0jojbATFoGWM8hn9L8XAppHIwnGhFR6lT1aVXd4f7+EoBdAGZn2yoiajcM0jJQ7uzIhAe1Ak8sIqJcEJF+ACsB3GVZvUZEfi0iN4rIMp/nbxaRe0Tknueee66FLSWivGGQloFy4RB2S6OW4DxpRERZE5GxAK4FcJ6qvlizegeA+aq6AsBXAfzQtg9V3aqqA6o60NfX19oGE1GujLgg7YSVszG+uz2G2jHhkS8jpndg13jnZ/f4bNtBRDRKiUgJToC2TVWvq12vqi+q6svu7z8BUBKRqSk3k4hyrD2imRi+dNJBWTchVEfBiY07iiMlKhgZ0igckoqB9wND+4BVm7NuCRHRqCPOHCtXA9ilql/02WYGgGdUVUVkFZwvzZ9PsZlElHMjLkhrB29ZMQsP/PEvOHfD4qybQoYRk0krloC1Z2fdCiKi0eoQAKcCuF9EdrrLLgAwDwBU9SoAJwI4U0QGAfwPgJNV2b+GiCoYpGWgs6OAi99iHSNMGRopMRoREWVHVX+OkP+lqOoVAK5Ip0VE1I4YpBG5ZMSk0oiIaDTr33JD1k0gyrVW/o08ftmxTdnPiCscQpRUGiEa40AiIiIiCsMgjShFHHFARERERGHY3ZHIxSwX5QW7KlHaWnXONavbDxHRaMNMGpErjTFpDASJiIiIKAyDNKIMsNsjEREREflhkEZERERERJQjDNKIMsBuj0RERETkh4VDcub1/ZMwtosfy0jH7o5ERERE5IfRQM58/4y1WTeBWogZNCIiIiIKw+6ORCliBo2IiIiIwjBIIyIiIiIiyhEGaUQpYndHIiIiIgrDII1GvVIxvcjp+BWzAAAzJnSndkwiIiIiai8sHEKj3k/POxw7//DnVI71ocNeg9PW9KO7VEzleERERETUfhik0ai3sG8sFvaNTeVYIsIAjYiIiIgCMUgjIkqof8sNWTeBiIiIRiCOSSMiIiIiIsoRBmlEREREREQ50lCQJiKXiMh9IrJTRG4WkVnNahgREREREdFo1Ggm7XOqulxVDwLwYwAXNaFNREREREREo1ZDhUNU9UXjYS8Abaw5RERENFK0qrjO45cd25L9EhHlRcPVHUXkUgCnAfgLgPUB220GsBkA5s2b1+hhiYiIiIiIRqTQ7o4icquIPGD5twkAVPVCVZ0LYBuAs/32o6pbVXVAVQf6+vqa9wqIiAKIyEYR2S0ij4jIlqzbQ0QjX9h1R0S6ROR77vq7RKQ//VYSUZ6FZtJU9ciI+9oG4CcALm6oRURETSIiRQBXAjgKwJMA7haR7ar6ULYtI6KRKuJ15wMA/qSqi0TkZACXAzgp/dYSUV41Wt1xsfFwE4CHG2sOEVFTrQLwiKo+qqp7AXwXzrWKiKhVolx3NgH4pvv7DwBsEBFJsY1ElHONjkm7TET2BzAM4PcAzojypHvvvfdlEdmd8JgT4Ix/S+t5ADAVwH8nfG4jx82qzY0em+9164+bx/bun3CfrTQbwBPG4ycBvMHcwBwvCyDs2tTo31UrsE3RsE3h8tYewKdNcnns/cxvRmMiCr3umNuo6qCI/AXAFNS81pjXpzTk8Rzx0y5tbZd2Au3T1kzbGfP65HttarS649sTPnW3qg4keaKIbFXVzeFbNud57nPvSbu9TXhu4jY34dh8r1t83Dy2V0TuSbLPrKnqVgBbo2zb6N9VK7BN0bBN4fLWHiCfbUpTnOtTGtrp82iXtrZLO4H2aWu7tDNMo/OkZeH/pfy8RjVy3Kza3Oix+V63/rjt1t6sPAVgrvF4jruMiKhVolx3ytuISAecXgrPp9I6ImoLbRekqWqim8Skz2tUI8fNqs2NHpvvdeuP227tzdDdABaLyAIR6QRwMoDtGbeJiEa2KNed7QDe6/5+IoB/V1XONUtEZQ3Pk5ZQblL3EbVbe4H2bDPQnu1utza3qr25ex/csR5nA7gJQBHA11X1wQZ2mbvXCLYpKrYpXN7aA+SzTYH8rjsi8jcA7lHV7QCuBvCvIvIIgBfgBHLtoJ0+j3Zpa7u0E2iftrZLOwMJv7ghIiIiIiLKj7br7khERERERDSSMUgjIiIiIiLKkZYGaSLyciv332wi8lYRURFZknVb4gp7r0XkZyKSi3KkIjJHRH4kIr8Vkd+JyFfcwdV+258nImPSbKNPO3g+E0TkEhG5T0R2isjNIjIrB236nIg87LbrehGZmIM2vUNEHhSR4SyvPSKyUUR2i8gjIrIlq3aYROTrIvKsiDyQdVsAQETmisjtIvKQ+5mdm4M2dYvIr0Tk126bPpt1m8iRx+uNTV6uQUHyeH2yyds1y08er2WNYCat2ikAfu7+jExEiq1pzsgjIgLgOgA/VNXFAPYDMBbApQFPOw9A5kFaG+L53BqfU9XlqnoQgB8DuCjrBgG4BcABqrocwG8AnJ9xewDgAQBvA3BHVg1wz+UrARwNYCmAU0RkaVbtMXwDwMasG2EYBPAJVV0KYDWAs3LwPu0BcISqrgBwEICNIrI64zaRI4/XG5vMr0FBcnx9svkG8nXN8pPHa1liLQ/SRGSsiNwmIjtE5H4R2eQu7xeRXSLyNTfavVlEelrdnqB2AjgUwAfgVlkSkXUicoeI3OB+03GViBTcdS+LyBdE5NcA1mTVbpPb3h8bj68QkdMzbJLNEQBeVdV/AQBVHQLwMQDvF5FeEfm8iDzgfkP3URE5B8AsALeLyO0ZthsAz2cCVPVF42EvgMyrL6nqzao66D78JZx5mTKlqrtUdXfGzVgF4BFVfVRV9wL4LoBNGbcJqnoHnIp+uaCqT6vqDvf3lwDsAjA74zapqnq9F0ruv8z/1iif1xubnFyDguTy+mSTt2uWnzxeyxqRRibtVQAnqOrBANYD+IKbTQGAxQCuVNVlAP4M4O0ptMfPJgA/VdXfAHheRF7nLl8F4KNwvuVYCOdbGcC5ObtLVVeo6s9Tb237WgbgXnOBe9P7BwAfBNAP4CD3G7ptqvp/AfwRwHpVXZ9yW214PhNE5FIReQLAu5GPTJrp/QBuzLoROTEbwBPG4yfRxv/DToOI9ANYCeCubFviZBpEZCeAZwHcoqqZt4nq8HqTHK9PLZSna1lSaQRpAuDvROQ+ALfCOQGnu+seU9Wd7u/3wrlBz8opcL7FgPvT6yL2K/dbjiEA34GTnQCAIQDXptvEEW8dgH/yvqFT1Tx+a8PzeRQQkVvdjG7tv00AoKoXqupcANsAnJ2HNrnbXAinu8e2vLSJ2oebgb8WwHk1GeNMqOqQ2614DoBVInJA1m0aLfJ4vUnaThp98nYtSyqNyazfDaAPwOtUdZ+IPA6g2123x9huCEAm3cNEZDKcbngHiojCmXxSAdyA+u4V3uNX3RvdPBlEdeDd7bdhhh4CcKK5QETGA5gH4PEsGhQTz+dRQFWPjLjpNgA/AXBxC5sDILxNbtfm4wBs0JQmwIzxPmXlKQBzjcdz3GVUQ0RKcG5qtqnqdVm3x6Sqf3a7u2+EM86IWiyP1xubNrgGBeH1qQXyfC2LK41M2gQAz7o3tOsBzE/hmHGdCOBfVXW+qva735A/BuAwON/eLXDH7pwEpxBDXv0ewFIR6RKn2tKGrBtkcRuAMSJyGlAeOPsFOINSbwLwYRHpcNdNdp/zEoBx6TfViufzKCcii42HmwA8nFVbPCKyEcCnAByvqq9k3Z4cuRvAYvec74QzPnN7xm3KHbfL9tUAdqnqF7NuDwCISJ/7/zG443uPQg7+1ojXmybi9anJ8ngta0TLgjT3RnsPnG+aB0TkfgCnIZ8X2VMAXF+z7Fp3+d0AroAz+PAxy3aZ895rVX0CwDVwvmm8BsB/ZtowC/cbtxMAvENEfgunMtSrAC4A8M9wxqbd5xaweJf7tK0Afppl4RCez2S4zO1Ocx+ANwHIQ4nfK+B8kXGLOFMDXJV1g0TkBBF5Ek4hmhtE5Ka02+B2nT4bzhdAuwBco6oPpt2OWiLyHQD/AWB/EXlSRD6QcZMOAXAqgCPc82eniByTcZtmwikYdR+c69YtqvrjkOdQOnJ3vbHJwzUoSF6vTzY5vGb5yeO1LDFpVZZaRFYA+JqqrmrJAVIgIusAfFJVj8u6LUFGwnuddyPhPW6X85mIiIhotGtJJk1EzoBTlOAzrdg/VfC9bj2+x0RERESUppZl0oiIiIiIiCi+NAqHEBERERERUURNCdJEZK6I3C4iD4nIgyJyrrt8sojcIiK/dX9OcpcvEZH/EJE9IvLJmn1tFJHdIvKIiGxpRvuI4mjy+fx1EXlWRFg2moiIiIgiaVYmbRDAJ1R1KYDVAM4SkaUAtgC4TVUXwym97gVdLwA4B8DnzZ245divBHA0gKUATnH3Q5SmppzPrm/AmduHiIiIiCiSpgRpqvq0qu5wf38JTinR2XDmEPqmu9k3AbzV3eZZVb0bwL6aXa0C8IiqPqqqewF8190HUWqaeD5DVe+AE8QREREREUXS9DFpItIPYCWAuwBMV9Wn3VX/BWB6yNNnA3jCePyku4woEw2ez0REREREsTU1SBORsXAmzT1PVV8017mTGLOUJLUNns9ERERElIWmBWkiUoJzQ7tNVa9zFz8jIjPd9TMBPBuym6cAzDUez3GXEaWqSeczEREREVFszaruKACuBrBLVb9orNoO4L3u7+8F8KOQXd0NYLGILBCRTgAnu/sgSk0Tz2ciIiIiohuqT4EAAACxSURBVNiaMpm1iBwK4E4A9wMYdhdfAGcczzUA5gH4PYB3quoLIjIDwD0Axrvbvwxgqaq+KCLHAPgygCKAr6vqpQ03kCiGJp/P3wGwDsBUAM8AuFhVr07x5RARERFRm2lKkEZERERERETN0fTqjkRERERERJQcgzQiIiIiIqIcYZBGRERERESUIwzSiIiIiIiIcoRBGhERERERUY4wSCMiIiIiIsoRBmlEREREREQ58v8BLuG8d1YSZTgAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -770,7 +770,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -789,11 +789,11 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 16, "metadata": { "ExecuteTime": { - "end_time": "2020-04-30T22:08:05.450001Z", - "start_time": "2020-04-30T22:08:03.866579Z" + "end_time": "2020-05-03T17:03:48.013582Z", + "start_time": "2020-05-03T17:03:46.382521Z" }, "scrolled": true }, @@ -811,12 +811,12 @@ "RMSE: 43110.28\n", "\n", "Giotto results css:\n", - "Fitted parameters: mu=0.00, p=[-0.26 -0.07], q=[-0.76 -0.24]\n", - "AR roots abs:[3.89 3.89]\n", - "MA roots abs:[4.22 1. ]\n", - "Train error mean: -0.04, std: 20.78\n", - "LL: 5143.23\n", - "RMSE: 41591.34\n", + "Fitted parameters: mu=-0.00, p=[-0.82 -0.06], q=[-0.18 -0.81]\n", + "AR roots abs:[12.11 1.35]\n", + "MA roots abs:[1.23 1.01]\n", + "Train error mean: -0.42, std: 20.87\n", + "LL: 5148.38\n", + "RMSE: 45521.01\n", "\n" ] }, @@ -834,7 +834,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -853,11 +853,11 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 17, "metadata": { "ExecuteTime": { - "end_time": "2020-04-30T22:08:19.701916Z", - "start_time": "2020-04-30T22:08:18.201000Z" + "end_time": "2020-05-03T17:03:49.603863Z", + "start_time": "2020-05-03T17:03:48.017866Z" }, "scrolled": true }, @@ -867,26 +867,26 @@ "output_type": "stream", "text": [ "Statsmodels results css:\n", - "Fitted parameters: mu=-0.00, p=[-1.4 -0.6], q=[ 0.14 -0.76 -0.31]\n", - "AR roots abs:[1.29 1.29]\n", - "MA roots abs:[1.03 1.77 1.77]\n", - "Train error mean: -0.02, std: 0.73\n", - "LL: 438.80\n", - "RMSE: 31.23\n", + "Fitted parameters: mu=-0.00, p=[-1.57 -0.57], q=[ 0.2 -0.93 -0.13]\n", + "AR roots abs:[1.01 1.73]\n", + "MA roots abs:[1.06 1. 7.3 ]\n", + "Train error mean: -0.01, std: 0.69\n", + "LL: 417.56\n", + "RMSE: 10.81\n", "\n", "Giotto results css:\n", - "Fitted parameters: mu=-0.00, p=[-0.66 -0.3 ], q=[-0.62 -0.1 -0.24]\n", - "AR roots abs:[1.83 1.83]\n", - "MA roots abs:[2.03 2.03 1.03]\n", - "Train error mean: -0.02, std: 0.74\n", - "LL: 441.53\n", - "RMSE: 37.08\n", + "Fitted parameters: mu=0.00, p=[0.48 0.32], q=[-1.92 1. -0.09]\n", + "AR roots abs:[2.65 1.17]\n", + "MA roots abs:[9.26 1.24 1. ]\n", + "Train error mean: -0.00, std: 0.68\n", + "LL: 411.86\n", + "RMSE: 6.69\n", "\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -898,7 +898,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -921,6 +921,18 @@ "display_name": "Python 3", "language": "python", "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.1" } }, "nbformat": 4, diff --git a/gtime/forecasting/tests/tests_arima.py b/gtime/forecasting/tests/tests_arima.py index 0933cc5..876fa01 100644 --- a/gtime/forecasting/tests/tests_arima.py +++ b/gtime/forecasting/tests/tests_arima.py @@ -1,7 +1,3 @@ -import numpy as np -import pandas as pd -import pytest -from pandas.util import testing as testing from hypothesis import given, settings from gtime.forecasting.tests.test_simple_models import forecast_input, SimplePipelineTest # TODO to utilities? import hypothesis.strategies as st diff --git a/gtime/time_series_models/tests/test_arima.py b/gtime/time_series_models/tests/test_arima.py new file mode 100644 index 0000000..30394d1 --- /dev/null +++ b/gtime/time_series_models/tests/test_arima.py @@ -0,0 +1,25 @@ +from hypothesis import given, settings +import hypothesis.strategies as st +from gtime.utils.hypothesis.time_indexes import giotto_time_series +from gtime.time_series_models.arima import ARIMA + + +class TestARIMA: + @given(x=giotto_time_series( + min_length=20, + max_length=100, + allow_nan=False, + allow_infinity=False, + ), + order=st.tuples(st.integers(min_value=0, max_value=4), + st.integers(min_value=0, max_value=2), + st.integers(min_value=0, max_value=4)), + horizon=st.integers(min_value=1, max_value=10) + ) + @settings(deadline=None) + def test_arima_oos_forecast(self, x, order, horizon): + model = ARIMA(order=order, method='css', horizon=horizon) + model.fit(x) + x_test_oos = x.iloc[[-1]] + y_pred = model.predict(x_test_oos) + assert y_pred.shape == (1, horizon) diff --git a/gtime/time_series_models/tests/test_simple_models.py b/gtime/time_series_models/tests/test_simple_models.py index acbd304..4e12d24 100644 --- a/gtime/time_series_models/tests/test_simple_models.py +++ b/gtime/time_series_models/tests/test_simple_models.py @@ -2,7 +2,7 @@ import numpy as np import pytest from pandas.util import testing as testing -from hypothesis import given, note +from hypothesis import given import hypothesis.strategies as st from gtime.utils.hypothesis.time_indexes import giotto_time_series @@ -52,7 +52,6 @@ def test_fit_predict(self, x): model = SeasonalNaive(horizon=horizon, seasonal_length=seasonal_length) model.fit(df) y_pred = model.predict() - note(y_pred) assert y_pred.shape[1] == horizon if seasonal_length < horizon: assert all(y_pred.iloc[:, 0] == y_pred.iloc[:, seasonal_length]) @@ -65,7 +64,6 @@ def test_fit_predict(self, x): model = Average(horizon=horizon) model.fit(df) y_pred = model.predict() - note(y_pred) assert y_pred.shape == (horizon, horizon) assert pytest.approx(y_pred.diff(axis=1).sum().sum(), 0) means = [df.mean()] + [df.iloc[:-i].mean() for i in range(1, horizon)] @@ -79,6 +77,5 @@ def test_fit_predict(self, x): model = Drift(horizon=horizon) model.fit(df) y_pred = model.predict() - note(y_pred) assert len(y_pred) == horizon assert pytest.approx(y_pred.diff().diff().sum().sum(), 0) From 7014d3a98dbf0e440729b68cd27c28bac35e1acc Mon Sep 17 00:00:00 2001 From: Simon B Date: Tue, 5 May 2020 14:34:47 -0300 Subject: [PATCH 16/23] Description update --- examples/ARIMA documentation.ipynb | 61 +++++++++++++++++++++++------- 1 file changed, 47 insertions(+), 14 deletions(-) diff --git a/examples/ARIMA documentation.ipynb b/examples/ARIMA documentation.ipynb index 6a7cf57..d727c08 100644 --- a/examples/ARIMA documentation.ipynb +++ b/examples/ARIMA documentation.ipynb @@ -295,16 +295,20 @@ "source": [ "def _run_css(params, X, len_p, errors=False, transform=True):\n", "\n", - " if len(params.shape) > 1:\n", - " print(params.shape)\n", - "\n", " mu = params[0]\n", " nobs = len(X) - len_p\n", - " phi = np.r_[1, params[2:len_p + 2]]\n", - " theta = np.r_[1, params[len_p + 2:]]\n", + " if transform:\n", + " phi = np.r_[1, -_transform_params(params[2:len_p + 2])]\n", + " theta = np.r_[1, _transform_params(params[len_p + 2:])]\n", + " else:\n", + " phi = np.r_[1, -params[2:len_p + 2]]\n", + " theta = np.r_[1, params[len_p + 2:]]\n", "\n", " y = X - mu\n", - " eps = lfilter(phi, theta, y)\n", + " init = np.zeros((max(len(phi), len(theta)) - 1))\n", + " for i in range(len_p):\n", + " init[i] = sum(-phi[:i + 1][::-1] * y[:i + 1])\n", + " eps = lfilter(phi, theta, y, zi=init)[0][len_p:]\n", " if errors:\n", " return eps\n", " else:\n", @@ -343,20 +347,49 @@ "is greater than 1." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "*** Add about transformation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Initialization of $\\phi$ and $\\theta$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A simple estimate of ARMA coefficients typically improves the convergence speed against random or zero-valued initialization, such as the following scheme:\n", + "- first, AR-coefficients $(\\phi')$ are estimated via simple linear regression and OLS:\n", + "\\begin{equation}\n", + " x_t = \\mu + \\sum_{i=1}^p \\phi'_i x_{t-i} + r_t\n", + "\\end{equation}\n", + "- then the residuals $r_t$ can be used for a second linear regression, this time with MA components $\\theta'$:\n", + "\\begin{equation}\n", + " x_t = \\mu + \\sum_{i=1}^p \\phi'_i x_{t-i} + \\sum_{i=1}^q \\theta'_i r_{t-i} + \\varepsilon_t \n", + "\\end{equation}\n", + "the obtained parameters $\\phi'$ and $\\theta'$ can be used as an initial value in MLE or CSS optimization process." + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Materials:\n", " 1. https://otexts.com/fpp2/non-seasonal-arima.html - basic problem formulation\n", - " 2. https://uh.edu/~bsorense/kalman.pdf - \n", - " 3. https://www.stat.purdue.edu/~chong/stat520/ps/statespace.pdf\n", - " 4. http://www.stat.ucla.edu/~frederic/221/W17/221ch3.pdf\n", - " 5. https://github.com/rlabbe/Kalman-and-Bayesian-Filters-in-Python - general information about filters\n", - " 6. https://www.nuffield.ox.ac.uk/economics/Papers/1997/w6/ma.pdf - relationship between CSS and MLE\n", - " 7. https://en.wikipedia.org/wiki/Infinite_impulse_response - general information on IIR\n", - " 8. http://www-stat.wharton.upenn.edu/~stine/stat910/lectures/08_intro_arma.pdf - general ARIMA information + stationarity conditions\n", - " 9. Time Series Analysis by State Space Methods by J. Durbin and S.J. Koopman " + " 2. https://uh.edu/~bsorense/kalman.pdf - Kalman filter for ARIMA case\n", + " 3. https://github.com/rlabbe/Kalman-and-Bayesian-Filters-in-Python - general information about filters\n", + " 4. https://www.nuffield.ox.ac.uk/economics/Papers/1997/w6/ma.pdf - relationship between CSS and MLE\n", + " 5. https://en.wikipedia.org/wiki/Infinite_impulse_response - general information on IIR\n", + " 6. http://www-stat.wharton.upenn.edu/~stine/stat910/lectures/08_intro_arma.pdf - general ARIMA information + stationarity conditions\n", + " 7. Time Series Analysis by State Space Methods by J. Durbin and S.J. Koopman \n", + " 8. https://www.jstor.org/stable/2335856 - on model coefficients initialization" ] }, { From 2ad88965871ad51aa9e4b76158089335ecad7845 Mon Sep 17 00:00:00 2001 From: Simon B Date: Tue, 5 May 2020 16:38:27 -0300 Subject: [PATCH 17/23] Base model class refactored --- gtime/forecasting/__init__.py | 2 + gtime/forecasting/arima.py | 4 +- gtime/forecasting/base.py | 74 ++++++++++++++++++++++++++++++++ gtime/forecasting/naive.py | 79 ++--------------------------------- 4 files changed, 82 insertions(+), 77 deletions(-) create mode 100644 gtime/forecasting/base.py diff --git a/gtime/forecasting/__init__.py b/gtime/forecasting/__init__.py index 1886713..feab737 100755 --- a/gtime/forecasting/__init__.py +++ b/gtime/forecasting/__init__.py @@ -6,6 +6,7 @@ from .gar import GAR, GARFF, MultiFeatureMultiOutputRegressor, MultiFeatureGAR from .trend import TrendForecaster from .online import HedgeForecaster +from .base import BaseForecaster from .naive import ( NaiveForecaster, SeasonalNaiveForecaster, @@ -15,6 +16,7 @@ from .arima import ARIMAForecaster __all__ = [ + "BaseForecaster", "GAR", "GARFF", "MultiFeatureGAR", diff --git a/gtime/forecasting/arima.py b/gtime/forecasting/arima.py index f0968bc..8ee80f8 100644 --- a/gtime/forecasting/arima.py +++ b/gtime/forecasting/arima.py @@ -1,7 +1,7 @@ import numpy as np import pandas as pd from typing import Tuple -from gtime.forecasting.simple_models import SimpleForecaster +from gtime.forecasting import BaseForecaster from gtime.stat_tools import ARMAMLEModel @@ -68,7 +68,7 @@ def _arma_insample_errors(x: np.array, eps0: np.array, mu: float, phi: np.array, return eps -class ARIMAForecaster(SimpleForecaster): +class ARIMAForecaster(BaseForecaster): """ ARIMA forecaster diff --git a/gtime/forecasting/base.py b/gtime/forecasting/base.py new file mode 100644 index 0000000..7054794 --- /dev/null +++ b/gtime/forecasting/base.py @@ -0,0 +1,74 @@ +import pandas as pd +from abc import ABCMeta, abstractmethod +from sklearn.base import BaseEstimator, RegressorMixin +from sklearn.utils.validation import check_is_fitted + + + +class BaseForecaster(BaseEstimator, RegressorMixin, metaclass=ABCMeta): + + """Base abstract class for simple models """ + + def fit(self, X: pd.DataFrame, y: pd.DataFrame): + + """Fit the estimator. + + Parameters + ---------- + X : pd.DataFrame, shape (n_samples, n_features), train sample, required for compatibility, not used for a naive model. + + y : pd.DataFrame, Used to store the predict feature names and prediction horizon. + + Returns + ------- + self : BaseForecaster + Returns self. + """ + + self.y_columns_ = y.columns + self.horizon_ = len(y.columns) + + return self + + @abstractmethod + def _predict(self, X: pd.DataFrame): + + """Create a numpy array of predictions. A virtual method to be implemented in child classes. + + Parameters + ---------- + X: pd.DataFrame, shape (n_samples, 1), required + The time series on which to predict. + + + """ + + raise NotImplementedError() + + def predict(self, X: pd.DataFrame) -> pd.DataFrame: + + """A wrapper to convert the result of ``_predict`` to a pd.DataFrame with appropriate indices. + + Parameters + ---------- + X: pd.DataFrame, shape (n_samples, 1), required + The time series on which to predict. + + Returns + ------- + predictions : pd.DataFrame, shape (n_samples, self._horizon) + The output predictions. + + Raises + ------ + NotFittedError + Raised if the model is not fitted yet. + + """ + + check_is_fitted(self) + np_prediction = self._predict(X) + predictions_df = pd.DataFrame( + np_prediction, columns=self.y_columns_, index=X.index + ) + return predictions_df diff --git a/gtime/forecasting/naive.py b/gtime/forecasting/naive.py index f7b9c07..7cb8248 100644 --- a/gtime/forecasting/naive.py +++ b/gtime/forecasting/naive.py @@ -1,80 +1,9 @@ import numpy as np import pandas as pd -from abc import ABCMeta, abstractmethod -from sklearn.base import BaseEstimator, RegressorMixin -from sklearn.utils.validation import check_is_fitted +from gtime.forecasting import BaseForecaster -class BaseNaiveForecaster(BaseEstimator, RegressorMixin, metaclass=ABCMeta): - - """Base abstract class for simple models """ - - def fit(self, X: pd.DataFrame, y: pd.DataFrame): - - """Fit the estimator. - - Parameters - ---------- - X : pd.DataFrame, shape (n_samples, n_features), train sample, required for compatibility, not used for a naive model. - - y : pd.DataFrame, Used to store the predict feature names and prediction horizon. - - Returns - ------- - self : BaseNaiveForecaster - Returns self. - """ - - self.y_columns_ = y.columns - self.horizon_ = len(y.columns) - - return self - - @abstractmethod - def _predict(self, X: pd.DataFrame): - - """Create a numpy array of predictions. A virtual method to be implemented in child classes. - - Parameters - ---------- - X: pd.DataFrame, shape (n_samples, 1), required - The time series on which to predict. - - - """ - - raise NotImplementedError() - - def predict(self, X: pd.DataFrame) -> pd.DataFrame: - - """A wrapper to convert the result of ``_predict`` to a pd.DataFrame with appropriate indices. - - Parameters - ---------- - X: pd.DataFrame, shape (n_samples, 1), required - The time series on which to predict. - - Returns - ------- - predictions : pd.DataFrame, shape (n_samples, self._horizon) - The output predictions. - - Raises - ------ - NotFittedError - Raised if the model is not fitted yet. - - """ - - check_is_fitted(self) - np_prediction = self._predict(X) - predictions_df = pd.DataFrame( - np_prediction, columns=self.y_columns_, index=X.index - ) - return predictions_df - - -class NaiveForecaster(BaseNaiveForecaster): +class NaiveForecaster(BaseForecaster): """Naïve model, all predicted values are equal to the most recent available observation. @@ -251,7 +180,7 @@ def _season_roll(self, start: int, horizon: int) -> np.array: ) -class DriftForecaster(BaseNaiveForecaster): +class DriftForecaster(BaseForecaster): """Simple drift model, calculates drift as the difference between the first and the last elements of the train series, divided by the number of periods. @@ -330,7 +259,7 @@ def _predict(self, X: pd.DataFrame) -> np.array: return predictions -class AverageForecaster(NaiveForecaster): +class AverageForecaster(BaseForecaster): """ Predicts all future data points as an average of all train items and all test items prior to is From 232f1ae22c433bafdd5098d55e2ec952b318c608 Mon Sep 17 00:00:00 2001 From: Simon B Date: Tue, 5 May 2020 16:38:39 -0300 Subject: [PATCH 18/23] Notebooks removed --- examples/ARIMA documentation.ipynb | 424 ------------- examples/arima-tests.ipynb | 940 ----------------------------- 2 files changed, 1364 deletions(-) delete mode 100644 examples/ARIMA documentation.ipynb delete mode 100644 examples/arima-tests.ipynb diff --git a/examples/ARIMA documentation.ipynb b/examples/ARIMA documentation.ipynb deleted file mode 100644 index d727c08..0000000 --- a/examples/ARIMA documentation.ipynb +++ /dev/null @@ -1,424 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Problem formulation" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "ExecuteTime": { - "end_time": "2020-04-14T18:44:30.927583Z", - "start_time": "2020-04-14T18:44:30.912369Z" - } - }, - "source": [ - "## Basic ARMA model" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Basic ARMA(p, q) model can be presented as:\n", - " \\begin{equation}\n", - " x_t = \\mu + \\varepsilon_t + \\sum_{i=1}^p \\phi_i x_{t-i} + \\sum_{i=1}^q \\theta_i e_{t-i}\n", - " \\end{equation}\n", - "where $\\varepsilon_i$ are error terms which are expected to form a white noise process (i.e. are independent identically distributed random variables with $\\varepsilon_i \\sim N(0, \\sigma^2)$).\n", - "The key obstacle in analysing and fitting an ARMA model is that error terms $\\varepsilon_i$ are not observable, nor can they be simply calculated as it is in case of, for example, linear regression ($\\varepsilon = Y - \\alpha - \\beta X$). The equation above \n", - " \\begin{equation}\n", - " \\varepsilon_t = x_t - (\\mu + \\sum_{i=1}^p \\phi_i x_{t-i} + \\sum_{i=1}^q \\theta_i e_{t-i})\n", - " \\end{equation}\n", - "essencially makes $\\varepsilon_t$ a function of $\\{\\varepsilon_{t-1}...\\varepsilon_{t-p}\\}$ which, in turn, can only be calculated recursivelly through previous values of $\\varepsilon$." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Likelihood function" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In order to fit the model to available data $X_n = \\{X_1, ..., X_n\\}$ and find optimal parameters $\\mu, \\sigma, \\phi, \\theta$ we need to maximize the likelihood function, which means to find a set of parameters, for which the joint probability of $\\{X_1, ..., X_n\\}$ is the highest:\n", - " \\begin{equation}\n", - " L = f(X_n | \\mu, \\sigma, \\phi, \\theta)\n", - " \\end{equation}\n", - "which is, from what we know of conditional probabilities, equivalent to:\n", - " \\begin{equation}\n", - " L = \\prod_{i=1}^n f(X_i | X_{i-1}, \\mu, \\sigma, \\phi, \\theta)\n", - " \\end{equation}\n", - "or\n", - " \\begin{equation}\n", - " l = \\ln(L) = \\sum_{i=1}^n f(X_i | X_{i-1}, \\mu, \\sigma, \\phi, \\theta)\n", - " \\end{equation}\n", - "If we assume that the errors $\\varepsilon$ are Gaussian then $x_t$ are also expected to be Gaussian as a linear combination of $\\varepsilon$, $x_0$ and some fixed model parameters. Which means that:\n", - " \\begin{equation}\n", - " l = \\sum_{i=1}^n -\\frac{1}{2} \\big( \\ln(2\\pi|F_i|) + \\nu_i F_i^{-1}\\nu_i \\big) \n", - " \\end{equation}\n", - "where\n", - " \\begin{equation}\n", - " \\nu_t = x_t - E(x_t|x_1...x_{t-1}) \\quad and \\quad F_t = E(\\nu_t \\nu_t' |x_1...x_{t-1}).\n", - " \\end{equation}" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# State space representation" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "\n", - "The problem can be reformulated in matrix form using a state space representation with $m$-dimensional vectors $\\alpha_t$ such that:\n", - " \\begin{equation}\n", - " \\alpha_t^i = \\phi_i x_{t-1} + \\alpha_{t-1}^{i+1} + \\theta_{i-1} \\varepsilon_t\n", - " \\end{equation}\n", - "where $m = \\max(p, q+1)$ and where the coefficients $\\phi_i$ for $p" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "df_sp = pd.read_csv('https://storage.googleapis.com/l2f-open-models/giotto-time/examples/data/^GSPC.csv', parse_dates=['Date'])\n", - "df_close = df_sp.set_index('Date')['Close']\n", - "time_series_preparation = TimeSeriesPreparation()\n", - "df_real = time_series_preparation.transform(df_close)\n", - "\n", - "df_real.plot();" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-03T17:03:14.893338Z", - "start_time": "2020-05-03T17:03:14.524070Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAAEECAYAAAA1X7/VAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOx9d7wdRd3+M7un3fRuIAkkhNBbINJCkY5dfKWI5SevigV9xYKiiAL214q8NlREUVGwoBB6CS0QSCcQTAhJSCO93Jvccs7Z+f2xO7vTd0+59+xN9vl88sk9W2ZnZ2e+853nW4ZQSpEhQ4YMGfovnFZXIEOGDBkyNIZMkGfIkCFDP0cmyDNkyJChnyMT5BkyZMjQz5EJ8gwZMmTo58gEeYYMGTL0c+Ra8dBRo0bRiRMntuLRGTJkyNBvMXfu3M2U0tHy8ZYI8okTJ2LOnDmteHSGDBky9FsQQlbpjmfUSoYMGTL0c2SCPEOGDBn6OTJBniFDhgz9HC3hyDPs+SiXy1izZg26urpaXZW9AqVSCePHj0c+n291VTK0AJkgz9ArWLNmDQYPHoyJEyeCENLq6uzRoJRiy5YtWLNmDSZNmtTq6mRoATJqJUOvoKurCyNHjsyEeB+AEIKRI0dmq5+9GJkgz9BryIR43yFr694DpRSel+5035kgz5AhQwYLvnDnIhzwlXtbXQ0rMkGeYY/E9u3b8fOf/xwAsG7dOrznPe9pcY3MOPnkk1tdhQwW/H3emlZXIRaZIM+wR4IX5Pvuuy/+9re/tbhGKiqVCgBg1qxZLa5Jhv6OzGslQ6/j+rtfxEvrdja1zMP2HYKvv/1w4/mrr74ay5cvxzHHHIMpU6ZgyZIlWLx4MW699Vbcdddd2LVrF5YtW4YvfOEL6OnpwW233YZisYh7770XI0aMwPLly3HFFVdg06ZNGDBgAH7961/jkEMO0T7rzjvvxPXXXw/XdTF06FA88cQTqFaruPrqqzFz5kx0d3fjiiuuwMc+9jHMnDkT1157LYYPH46XX34ZS5cuxaBBg9DR0QEA+P73v4877rgD3d3duOCCC3D99ddj165duOiii7BmzRpUq1Vce+21uPjii5vanhn6NzJBnmGPxHe/+10sXrwYCxYswMqVK/G2t70tPLd48WLMnz8fXV1dOPDAA/G9730P8+fPx2c/+1n84Q9/wJVXXonLL78cv/zlLzFlyhTMnj0bn/zkJ/Hoo49qn3XDDTfggQcewLhx47B9+3YAwG9/+1sMHToUzz//PLq7uzF9+nSce+65AIB58+Zh8eLFiqvggw8+iGXLluG5554DpRTveMc78MQTT2DTpk3Yd999MWPGDADAjh07eqPJMvRj9HtBTinFp26fj0veOAGnTlGSgmVIAWyacytwxhlnYPDgwRg8eDCGDh2Kt7/97QCAI488EosWLUJHRwdmzZqFCy+8MLynu7vbWN706dPxoQ99CBdddBHe/e53A/CF8qJFi0JKZ8eOHVi2bBkKhQKOP/54rb/3gw8+iAcffBBTp04FAHR0dGDZsmU49dRT8fnPfx5f+tKX8La3vQ2nnnpq09oiw56BPUCQAzMWrceMReux8rtvbXV1MvQDFIvF8G/HccLfjuOgUqnA8zwMGzYMCxYsSFTeL3/5S8yePRszZszAcccdh7lz54JSiptuugnnnXeecO3MmTMxcOBAbTmUUnz5y1/Gxz72MeXcvHnzcO+99+KrX/0qzjrrLHzta19L+roZ9gL0e2Nnur07M7QKgwcPRnt7e133DhkyBJMmTcKdd94JwBewCxcuNF6/fPlynHDCCbjhhhswevRorF69Gueddx5+8YtfoFwuAwCWLl2KXbt2WZ973nnn4ZZbbgn58rVr12Ljxo1Yt24dBgwYgPe///246qqrMG/evLreK8Oeiz1AI89EeQYVI0eOxPTp03HEEUfg0EMPrfn+P/3pT/jEJz6Bb37zmyiXy7jkkktw9NFHa6+96qqrsGzZMlBKcdZZZ+Hoo4/GUUcdhZUrV+LYY48FpRSjR4/GXXfdZX3mueeeiyVLluCkk04CAAwaNAh//OMf8corr+Cqq66C4zjI5/P4xS9+UfP7ZNizQVohCKdNm0abtbFEuephyjX3AUBGraQIS5YsqUuAZqgfWZv3DiZe7RuZ0yBfCCFzKaXT5OP9n1rJFPIMGTL0AdK8+u//1ErGkmfoI3zrW98KeXOGCy+8ENdcc02LapShL0EpkNaUNv1fkGdyPEMf4ZprrsmE9l4Mj1I4SKck7/fUSob0Is1L0T0NWVv3PtLcwv1ekGf9N50olUrYsmVLJmD6AGxjiVKp1Oqq7NFIc1fu/9RKqufJvRfjx4/HmjVrsGnTplZXZa8A2+otQ+/BS7Ekb1iQE0JKAJ4AUAzK+xul9OuNlpsUKc/3vtcin89n245lyNBHaIZG3g3gTEppByEkD+ApQsh9lNJnm1B2LLKle4YMGfoCaRY1DQty6kvSjuBnPvjXZ6+c4rbNkCHDHoQ0UytNMXYSQlxCyAIAGwE8RCmdrbnmckLIHELInGbypilu2wwZMuxBSLOoaYogp5RWKaXHABgP4HhCyBGaa26mlE6jlE4bPbqJ6WbT3LoZMmTYY5BmGrep7oeU0u0AHgNwfjPLtT4zk+QZNHj6lc34+G1zUz34MvQvpLknNcNrZTSAMqV0OyGkDcA5AL7XcM0SIhunGXS47HfPo6fqoafqoZhzW12dDHsAqNfqGpjRDK+VfQD8nhDiwtfw76CU3tOEchMhk+MZMmToC6R59d8Mr5VFAKY2oS71Pr9Vj87QD5B1jwzNQpr7Uv8P0W91BTJkyLBXYI93P2wlUty2GVKANA++DP0Lae5Je4AgT3PzZmg1shQOGZKAUool63fGXNNHlakD/V+Qt7oCGdKJIG10NtFnSIJ/L1yHN9/4JO5fvN54TZr7Uv8X5HW07WtbdmNnV7n5lcmQOmQaeYYk+M/r7QCA5Zt2Ga9Jc1fq/4K8juY97fuP4YKfPd0LtcmQOqR59GXoV0ixQr4HCPI6G9c282bYc5AZOzMkQZJekua+1P8FeasrkCHVyPpHhmYhzX2p/wvyFM+SGVqPNGtRGdKDJN0kzbJmDxDkra5BhjQjE+QZkoDZ2gixXJPirtTvBXmGDFakePBlSB8IzJI8E+S9iDQ3bobWI3M/zNAspDlpVr8X5NnSOYMNaR58GVKEBN0kzUpBvxfkKW7bDC0EWyCnefBlSA9YN7Fz5OntTP1fkNfYuF42svsdrvv3i7hn0bq67k3z4MvQOrR3lXHdv19EV7kqHLfI8VQrjf1fkNd4fUbF9D/cs2gdnlq2ua57s8+dQYc5q7bh1lkr8eK6HYnvSbNS0P8FeY1tmynk/Q8erX8CzibuDDowoVz1xN+Z+2HLUCO1kuavkUELSmk44Gq/t7l1ybBngPWLaqDZsd8EBL9+4lW87aYn1Xv6qnJ1oBl7dtaMNds6sXrrbkwYMaDhsmrXyNP8OTLokGnkGZoNtjLX9Y9v3bvEcE96+1JLNPJtu3vwpb8vakpZtXPkTXlshj6ER2ndgyj73Bl0YFRKpQaBkGI53v+plVobt9oLknx3TwVvu+lJvLAmueEkQ3JQWv93S7OBqtl4ZMkGnPDthxVPjAwqQo2cUSvB8b2WIyeETCCEPEYIeYkQ8iIh5DPJ7mv0yT5qDfjojYG94LXtWLx2J75tWJLt7Vi3vROfvn1+3QKmIY08JYNvxeZdOOTa+7BqS++lT77hnpewYWc3Xt/R1WvP2FMQGTtFjtyGPZ1aqQD4PKX0MAAnAriCEHJY3E22nAa1IA1eK6xMp9+vb3oHc1Ztw90L12HVlt113e9RCq9GYydTFNJCpf1j3hp0lT38a0F9/vBJ4CXwvMjgg3WLai8I551d5T5fCTYseiil6yml84K/2wEsATAu7r5mdbZaZ8neoFbCAdSkyWlPA1u+1m+wrH/ApVmLajZ4z4sMdniyRp5gZZ+kK63asgtHXfcg/jj7tYbqVyuaqkMSQiYCmApgdjPLtaHWcdobM2USfm1vRrVBQU4prTsiN21yvDfrEwryBvshpRTLNrQ3XqEUw+h+aGm8JP331c0+dfbwSxsaq2CNaJogJ4QMAvB3AFdSSndqzl9OCJlDCJkT/G7Wo2uCTh509lTxtX8trntD5mhJm0lyHVj71CvE6B7gftiXPaPRbvj7WStxzo+fwJyVW5tToRSC9Qu5f/BNJyt96ehJejRFkBNC8vCF+J8opf/QXUMpvZlSOo1SOg1oXseu2WtFc8Pf5q3BH55ZhRsfXlZnHfwynUyOayEvY+PwwpodmHj1DLz8+s7w/mqaR1FK0KxJa2HgfVWvTaM/oWLpWHJ3TbMHVDO8VgiA3wJYQin9UfL7Gn2yj1q9VnRL9GLOb4Ztu3vqq0PITWbQgUVlJhU0LEHWYy9vCu6rP9lZWjRyht5Mq8tetdFXDhWTPdh4HyoXlsaS+05aDOc6NONTTQfwAQBnEkIWBP/e0oRyE6F2jlw9NqTkB7i2d1UaqoOTUStaVMNlbLLrewLJn3eJ4iZWK1Iz+IK+0ascORprq6gcH3uy0ZR9h9CPXOPxo7aj2q49FQ+VevNHxOBfC9Zi4tUzsHZ7Z+y1DYfoU0qfQguV0Vq7rG4Gbiv4zdBRpyDPOHI75MESh3IwMAo5xxpKbQMTQmlZDvdFz6B1tpWpnD0ZrF/JkZ0iRy7eo2uXg756Hw7dZwju+8yp2uf8be4aDCq6OP+IfWqu49/nrQUALN3QjnHD2qzXtmzx1DyOvEZqRXM9EzTt3fUaO/3/MzmuR+S1kuz6csW/MO86RqNUUsQ9c8POLvzmyVdTI/AbQTTpNVbO3uCFRaV+xd6ZbzpZ6TO165L1im9HiC/cuRAf/+O8huqYBC1JmgU0T3uttc/qGocJmnqpFVaLzNipR63GTkatFDhBXj9dYL/vU3+eh+dXbsObDh6NA8cMrvMZzapNc0pvdFLaG1aYsvuhfBxQlYc0T/Z7gEZuP//Ne17CW26MUlLq6Cw289YryMPIzj2448ehu1LFxKtn4LZnVirnqjVSKz0ctRLRBfXVK+6+3T1+2oDOnvp4zmO/8RB+9/QK9bnykr0PukazNHKE/Tn5LV+96wVMvHpGgw/uO5jsCbzwlr9hq8R4ks/QOkHetI5tb97fPLUCL3FLH90SPdLI66NW2P17sRzHjt1+2934yCvKuVqNneUKM3Y6DfO+cbcVAo+lnjoMVpRSbN3Vg+vvfkk47nkUB3zlXnynj3PvNGoYDssJxlQtxs4/Ptu3kYyNgjXRjs4yrr1rcTihixq5fE9rRHmSlVELHYyaI/Vq7bM2QV6u01k5EuR7ryS38aq1hugzY2fOIVpq5bZnVuLpV5Jt/Rb3zLwbCPJK7YLclAJ1RZAY63ezVqonDfX5wG9n4ycPL625DkLRwf/NMnbuyd2ZveNNj76C255dhb/NXeMf5xRDZULsRTm+euturNhcf0K1fq+R15w0S0etNKjBMMGzB/f7WEQumOq5Wv3I2YRKuXv4T3Ttv17E+36TLAtE3DOLDWjkpmCSeau2AQAO3WdIeCxOu31y2Wb8pM6ANIZm+ZFHuYPSDUpp3by1qV/w/UzhyG3lsRvrbPtT//cxnPGDmdpz6aZWEl63u6eCXd1m7roZXiuNCnJ2/97MkdsShzFqJemnYhOjn742KL/ebxRHrWg08ieWbkqUK6PCaQWX/vpZ3L3QD2R6Ya0fGTluWKnW2jaERj18GBrRyPvSIHjWjx7HUdc9WNe9ploKHLnitWJ+t1099TpKmFFLU6Y+duuYGx7C4V9/wHi+1m6jFeQNdr5KiznydQkCBnob0WSmnmNCOOmEyQQ5r3HV+o2SprENOXJOkH/wlufwkT/MiX0G/z6zlm/Bp2+fDyCKR+gu906giAlN8yMP/q+HKuyN7KImvLppF9otSp4NpgmHP2zzaJEhO0r0tSxIPbUSx13WTK30gkbOIrtaoZHfv/h1nPzdRzHzPxv7/NkA8J37luBr/1pstRNUa9QUGbXi79XpH6s7+2HMVB8ZO2vf9MJkU2Hv2anZSKM3xZzsG10PuivVcAVcT2+uZeu0VsLURLyAVwKCLOV11DGhVKoeVibgxZO0aAuplWb5kddKrajHGhbkLdTIF63ZDgBYvLY128z96vFX8YdnVlnbIDJ2JitTpFYaE06xGnkDxk5Tv2HynRfkfdE3ImNn/WW8+cYnMWv5FgDp18gbQRKOXNXIze+m83iLo5m+fe/LeNMPZmL9Dv2Kmsm2JEpM6qmVWFjeUdepdI3iCbNw7R0x1EZbYB5KCy1vc8FM6ke+bVcPPn37fGzZ5Scv8ygXuFG3+2GM10qgkXfVQYOUDQZS1p/qKbMWVD2KbbuiRG9y/pB68OqmSEPsbxp5T8VLvJ2gqVvYOPJaqBUgvi1mLfc9r7btsrs9J5kcU0+txMH2ijoDhE4g8N4H9WgU7IO1MrKz1UFnkeeOjVqxl/Hzma/g7oXrsKm9G4DIkde61RtDrB95oJHraJA4mPoKE6Q6odLM73TD3S9i6jcewu6gn+s8fBpBPdkPeyuBVBKc8YOZOOTa+xNdW5/XillD39WtfmtbilxbuVH5QTl7kiC/a/5a/PHZVcpx28DgvV1Yo+uuF2fh2uoFRB+sFRx5mByqz58sIpGxM0aK6ZIU1Zs0K3x2QvdDmyZ3z6J1+NNste+ZBljIkfdw1EpsTWvH3YvWA4iiU1ltWhlK3kpqhc8SuGbbbnz8trnCN0gEiyyQm5V/19BAz43Eelxadc9L0vf7DUd+5V8X4Kt3LVaO2zhyXpDbthvjP0g9AqPqqR+xr9CsuePxpZuwYPX2uu+PViU298MYQS795jnyJALi/sWvY27gwx2WGXMbO22jQT715/m45p9q36sYlgls/Naj5deCMPVqeCB4fpMEeVwxa7btVrjhtBg7567ahvtffB2vbu7Qnq+HI5dfjW/nyNMKyrFGkWqNvFkqiu0d+eUOawydQOAbqhFqpRV9mDVjo2P32zOW4Bcz1fD6pAjbrYGAIPm077WS3Nj58T/OxX/9YpZUhv0+Gw0SB9PSmQnY3hbkco6f0DjWpH5IKfC5vy7ACd9+WHv+lO89hgt+LrZ3kvFz1g9n4oo/15cRMCmY8dr0XevjyMXf/LvqZEBSaiVOqU21sbMv0tjyGrlt30i+oerRZsKP2BJJ7rdko77DXZWqNqFYUthcMEOvlZjydQEY0fKyvnrF3ca+d12C3Oi14h/vqXiq54OmRvVSIfJ9jdJQMjxK8Y/5a7FhZ7fxmlc2ihpvEu1x+aZdmBHQQr0F5hpqSoZmqqbAkXuSO6J0rY5a8TRaeqNItbGTx4adXQ34CZuxi+PHrNQKPwvXo5FXk3HAvYFQI2+wnJ6K1xC3ajP4snbZ2VXGTx9ZlnjVQ2ukVkxl2M/7/9cjyKuGmYmvKiuXzW+66tT9buHzROqqWRx5ffai1hk7efRU/HbfbYi4NBoYueN8ZDFg18jDtBLcNQ1z5DXs+NRCY6ffs9fv6MQJ336k/oRBlnfkBydrDF2j8MfqGVRsQLdQIW8YPRWvIU3O5oLJJsdvzliCHz20FA+8+Lq2DJ2G2XBAUMxtrN5JXAXvmr8Wv37i1fC3aenM11WmV3b3VBVNrW4FQFqtRG1VX3HGB9SAtHDkoUZeI7UiRHZyioTuHoFaqaoyICm1EjfukvSPllMrG4Nl28ylmxLdJw92m4FRJ8jjAoLqGVTlVlIrDA1qYd0Vr6GJyBYQVJW0atOSU368RynWB54INYfoh2XYr7NFYcq48q8L8C0uNW2c1wrAa+R+jW6dtRL/96hoi6hX8MqaOEOzVob19Ie0BAQxbdjMkcdPwpSj9gA7tRJx5HpqZUdnGROvnhFuLA5EfcLUZnuk+yFDtxSBZ+uzgiCXOr1pk9V6BlW1KgqqvkSz3A8b18gDP3Kd10piKkX8/djLG3FpkOWwt9wPZVdBsS9QfO/+l433GjlyTxXkPF7f0SWVE3W6WmiRiFqRjgdlbNjZhf97dJlQZrnq4YAvz8Bfn4/PH26riqmeadHImbHT5H6YhCOvenbjJz9hsufx9/OCnKWo5Vd0unK0dUqzIK8X8oexC/KoIUNqRXbZQv0aOaUUv3t6BbbuZpGILRDkFu416UYZlFL0VBsT5Gwpq5uf5WJNod/y8xesjtIO1B0QFHOelbszaCtZi/rFzOXGe00cOf8anT0eVmzehSeXRStOeUXCF1OLMmDyM2ZFfPr2+fjBg0uxZH17eK6jqwKP+uHhcbAZ68yTWEo48qDuu2ulVqR85IJGLt3DUydsMhYnTc0kYHEGMCHdGnmd98lLYNsrJqZW6jR2Pr9yG66/+yU8FKQ8bYkgD/6XKaZ5r23Dkdc9GNbNBrbKaWQMhgFBmh4lCydTBKzcevyg6K0QfVbu9mCHI95AVY5pEFPSLEFTq1Zxxg9m4tlXt3LHzBx5LQayyN1QFuT+b+a1xZ+PJv749ty+u8d4zjTh1Ls5C49P3z4fX/rboobKYLtMdRk1cjud4f9NhXGlo/4YKlX1W/AToeLzzx0zUivsOX0lyAkhtxBCNhJC1KgJA+r93PJS1dYhuyrRtWxMsut5N7l6jZ2K0aoV1IpBI39pnb+93aMvxwvyHo3rVK1IEhDEYPKbVYxJlmVtUsTdxsrd3ukLrTJH3cUl0jKG6FNqTaMrlyt4P1SSvye7zWaEk88TkpyK27Zbv6LzPBrmXpfBP3vGovV1BZndvXAd/jpndc338WB92mjsNNznScqDzWuF15TDjJ3BpyUQ5UPk868+M05J6Utj560Azq/lhrATWq6Zs3KrcqwWjZz3IWVLH11yJ5la6eiu4CO/fz42z7css5IqI11lf6PinzcQgBPVQS8UBxVzAIAOTQ4IGUywUArcOWc1/vjsKvw92PoqKUKOXHMu+UbEkmYpGJ78dvvWjJfkm6xIHhDkJ1ziNco4QW5MmuVR5IOliU6bUqgVro7X3/Oi9ZkCDNQKDYWGGCiku8YGk0b++2dW4iqDxswLtyv+PA/v+tnT8Q/qBbA23m3QyI3GTkF5EH/Lt/DftuKpyhDfl8rWOAttVaJI3b7SyCmlTwBQpa4FcQNsU3s33vPLZ5TjqkZuLkPQyKmZWpF3zr5/8et4eMlGfP+B/1jr6EofJamhamenr+nc8tTKRNcngfzkgYEgt+2uxBBSK5Tiqr8twlfvWozP37nQurSWEQ7gRBq5HnKHlr/Vn2a/hl8/uSJxnXRl2M7v6CwLQjaO5jBr5EDOJeHfMmT6gS/nH/PW2ivMwRTJGe7WpFkV1OJrvr1TCr+verhr/los36QPewfiOfLe8OzSvQvr0424H3oyRy6NMlEjt4folzX5mJgSZkr1wJBEkOdir2gSCCGXA7gcAApjD0RXTxUX/+oZvP3ofbXXd1f0H0CO1LJSKwJH7v+v25JMyH5IKYYPyAMAtsUIMldaJyWlViIt2nw9pRRrtnViwogB1rLYwJCbgW2YkCThfU9FT63IHkI2MEpCv2dnMo1cHihqfZIH7YQUQg3L1u27y6EABuI1cpvXCusbuucrHHmDPvImY2f0mxrP2SArAb99agW+c9/Lyjf+FBduH+c7HWd3qAceBVypTkxwmtwPk2Y/pIKSJ16rCwgyceRhX9L0fZNdgY2HVBk7KaU3U0qnUUqnAcDCNTswe8VWbSIsQBWSDIpGbnkmf2249Ak1x+g6fjBXPYohbb4g327gCBmcOgT5qi278NW7XvDrYrn8Rw8txan/+xhWbbHvIGJKSMXeM4lGHrpqSUExtYQY99iWjsqgSciRW7jepIi7hwqCvEc/+AwwBgRRinyQHlevkZupFblONpj8yOXNkysa74kkT+C1WUopXt/ZFZQhXncPF24fNwZ6w46kK5NFdprcD021oJIsEFYzlufKAUEUooAO4wk0zzSNs9BBI02CXEacH7lMWzAoHLnmHX/00FLMf22b4H7ohRp58HzuepmLZefiqAUlOClBH/2fvyzAAy9u0N7P46YgaCROo45239Ev+5JRK36bbmqX/Jtr8EBg+1PqvlpyjVz6LR2opT5RmckFy/bOsmBsjDd2mjeWYIqITvOLM5InlXXsMkUDl2gu0eimX8HpwAtBjya7hwXHmUL1eeHWvFQCujb2j5k4crNGLq5exK3fJEqM175jAoKYINcpOqZ+JrtM27AHuB+q2sxPH1mGC34+SxsQJPOHgJr9kP3aussuyGXBUg2WYra8HVTqKDrIEwuPXd0VPLVss1L3nZ0VfO1fi0PBzTpBLcbOzR3i+27d3YPnViQzfTAaRr/Vm/jblLfd5rWi+23CvS+sDyfAJBz5kJLPMO7YXRZoj+6YFYl5z04gbxPkkmeKLMhrDaAyUSuslXsEN7jg/wQ6eacUh5FE8LLJzUTL8QI+jjJIuv2eXiOvN/sh/7fstWJ+LqMW+Uv4d+2yjA/Te9oytspolvvh7QCeAXAwIWQNIeTD8ffYz5vqHmfs5DuH3o+cLTujCiguR0w4arZv4qEIGo/ixw8txSHX3m9e0gkdQ/+SMtXD46TvPIL3/3Y2lqzfKVz71zmr8YdnVuGWp1YI7yRr5JRS/H3uGoFvNnWk/771eVz0q2fCYBkZ/ITDyrNtvhwHE0Wge54Nn/xTxNnGuh9yVFp7d6UmasXmfui6jCNXz8flWkkycF9+fWf0PMVILN7Pu1TWsosQP35koWYCU25MglyXMZDHg1wenqSbQsjtxwLcAJuxU/8ygrFT4sjlyU8Xoi8mzeLGh0UjNykMtvxQMprltfJeSuk+lNI8pXQ8pfS3jZZpWvrEceT84OssexhQcAGofJM5RD9Zh5XvA/yP+PMgEjCJkcUkZGyRpmxyCTVOWZsLrmcdS+7IDy/ZiM/fuRA/fmhZeMw06JiNwFTPiiDIk1MrxmAM+XeMhp4ESUL0WR/x3Q9VQX7oPkO09xpzrfDuh3UYO5O85/k/eTL827QFGTPh8PUMi07QlCK1QhNp8VESsujernI1bMsyVxd5oly8dgcuv21u+PvoGx5MZOCWxwClvN2ntjDVz3sAACAASURBVBB9mSOnwjnxWm0aWw1vDohted2/XwxD9oEUaeT1wMR3zlq+GbOWbzYOQHk5yzf8js4yvjkjSmrUXa5iQMFfNsuRnaYQ/ctvm4uNEldsfAfNAGTHkljnTZ9HdofUgWlZNmGiw47ApWzjzugd47xTTGXx9TR5vuiOmcqLW7rL9/3q8eWhBldvmVUKtOV9Qd5tEOQFySXi8aWbcNR1D+BfC/Sugh4Fx5Gr520h+kDtBkH5FSOK3MKRJxDKfApY2fBnwn2LX8cX/7ZQ6FPHfuMhvDPwJ+eF28z/iInydnSqKz/dXpgydBMhe+ckK2MesqJl8/jhtzeMIjuj8wI7EExIyza249ZZK4VVY5yxM9WC3FT5S389G5f+eraxoW2eFN+972Xc/pyfDIgQXxMYWPQHqbzTDE8B8A21dVdPaGiMg6INc1Uz7x7D3S+95Ef/MAf/75bnEu1Y1FP1sG57J+a9po+cq0UYxPlLmyZVnUaue2xSjTOuxnI5tz27KvSYSKrlK+cDw2Qx56C74qGHN3YG7cJcOcPnPrMKO7sqePn1duhQ9ShygdfKys2q15HiR14nhRReL1EAcjvxGl/IkSd4hOwskIQjf3zpJtwxZ42gke/uqWLJ+p3orlSFPnPlXxdg9dbdYQIvnVKS5JnHffNhQfmqejRB0iyTchL9rXqtyOPd/13Ku9qNJYR0xoHbdC5YqfUkoDZZ+alyP5QRVznjcl7RyKO/+WVYziHoLFcxMNDIKx7FKxs7BI3dVJekRhb5Pr7T2VzTTHV/6KUNeHzpJqEDXHzzs/jZY6+gq1wVNp8uVylO+9/HsNAQAs0P5rjB0G0xzgJmwcs/g7VZXL53wGLkjemvKhfKReyaBqal0A/8djaeXLYZDiEo5V0jtZKTEsiYNiuI6kWRCzRyPu0tQ1nqX6x9zj50jPVdGOR38qhED4Z2IB8Vzbkk4Cf4o294EOu2J1upAvpV3pyV25RxcdGvnsGX/v4CuspV7bdKOqctfT0KUqI0Uvg6y9WavGP4KxWO3KCRl/JuSBnx14iKjj/G2EpNN3Zk1OJ+2GcBQTJkzVrmVo3UirQO5WdJ3pDgEIKushdp5B7FP+dHYeeC+yH1c2OwRybd5URu4HbOOBoXrSXXnU+qJAu+7z/wH3R0V4RMfOWqZ50M5URMxZxrvDZWIzec1qVrbYRaiU2wr+Hao51Z9PfYSnwy8P5xHIJS3kFX2dMK8rykkcflLq9SKgQWyZCNW+y9meYft5pqlwzYHkfpAVFbsOGgy/lB4bvX3vbMKlxxxoFKTIQOjyfcMwAQd0Zi9dm+u4yhgWGZYX2Q0rfqUW1/Nie3Mq9qqpRyVJ8/qZTyYv9P5n4oZz8U72H1LeUczo9cP2my1Y1OyzaNvzglhUcLqZUYrcO0nK/KQiH6m++LrkNQrnpo4zhyQZhJxk4WwAGIBhnbbCh3vM0d3cZzDCK1Ev29hbtXN5C3Sq6BccE6VUEbsF8btwIxfQvdM5Jp5IbyauwTHqXaASReYy0SgN9vijkXXRVJI2fUiiSU47wpPIpQI9ehXPW0VAjrg3GCfKfEJfNb4vnPZxq5X4cejdcKpRTX/HMxfvjQUsxavsX6vHrA+gP/WcpVdQ9ThkqVar9h1aPaMajYBSQ6skcTjGO7PzrOlyOtoKVr2bli3o3nyIM6sP5V9WjkHqoZf0+/sjncKzXVHHkcTHVXPEW4v4U8BvAbshRoORWPClynbOws8oKcG8y22VBx8xJyK+iFo8CzGT56khm4lomwm+M6meDj744T9KaOpFse6i41GYlkxNFtcpN6NN6yn2RZ7YYaeVUQ0qxd+EkeMAeZhPXyqELHiHVSPaX458QNXNkoyLcD+w0g7ORiEE50Dcv4GOZsqZGbt0FH1/mrSLP2qXv+Ay++jmO/+ZAijOUxIq5IKHoqVZTyfnvqVlDGid8TrxE1crnOgSDPObEcOat/T1VVeLoFG4Z//H3BhirytSakVpCb3PdkAckPVN6lkL17MR8ZOwvcgJSNnfzyWci9YtPI5dUBNZ+L6stfr//oST5cnEbOP5+3HeiEdt0aOVWfoRuM8vt0Vzzc+8J6zVK1Nu8ZynknmJosCT3KOPLuiidE0rJ3qlmQx1ArgChcK5Igj6OYZL9+T9Ja1RB9VVD4x/2/2aTTzM3DdcKzXKXGcVExUCsrNu/C9t1ldHRXsLungnN+9Dhmv7pFaSM5FXW5SkMaR7eCMr2puvmynioBov7oc+RsBRK1vUA9SikDdAm3/GeoderXglxePgKimw8D/0sQzkGDtuUjLUfQyIVcK0CeT5bEa+QJeWgZJqFEDX/HearIFvM4QS5o5Jyg1vnl1hv4Uq2qz9C1iXz/TY8uwyf/NA8PL9mY6DnheYVa4fNAGzSsJPwiISjlfGMnHwnLIjBlQd7JGTtNScJs1Aog9TG2RE/Ike/slDlySSNnhrfgt0lQsOewSaeZeVB0k13FM9t1ytIOVWMGFwFwtheP4omlm7BsYwduevQVq8tmlfoBQUNKeWNdzGlsub89e2RnyJHnnQTUihjxyk+uOurL9G4mpFeQa6IJCzlH9c/m3pEfO+xDMSOHLMi37y7jzB/ODM55wrmk1ArfwLKLmlkj18/wQnRpgg9nEr6MF9UZIrvKVYFmYYgLujDSXJrJIomxk3F/W3d1C8fjcqmo3hrxHHkS0eQ6BMXA2MlHwvZU/XYp5EShzG8fJn93wB/wOdc+tAThGrxXUmOnjiMXvVb8/1nb8HyxkAskuNCWF6Ze6IRnT8UzKiBVT9TW2eTJKwhzVm4DABwzYZhSV74PV6p+ezCNnPX/DTu7sHSD7zJqelVhZUzFyGj5FrZfQjHnarMfisZOsT08GpUXJ8iTuB+2zGtFB36W0oXHF1xHo5HbZ1Zey5F1pFc37QrOiVqXQH8kNHYOLLjCBzEaO/m/NdqRX3eNRm7QBtTyqXK+u+LhpXU78ZafPokpYwYBMKTYNMBs7FTLSEKtROUmuy48r1nasgFkdD9MpJH7g3FTuRsd3RW4DkHVo+GkV5CEMl9kwXUEf2tWl3wstaKu+tg9NuXhzjmr8fd54qYfHhXtIOydw+A0TUAQEI03lqCumRsnd2pcNMtVavzG8jm2SmACsOpRLF7n7+FayjtKG/HfgAn/kFoJyjjle4+iXKVY+d23JoqNoJSGgUzsN8PcVVvxl+dXh/WJNpYIroVemYqeoxrV/WeodUrSh1MlyPkX0lErhZyjUBamd+R9PAEIOVR4dFd8/1V5sMrl6MCXN6iUE7bGMlIfMfUFkg0o2RfZVrfusodlgSaybKPvb8vTLfVuoMDfxjQinRAyu5CJv+OiYVW/fX7TW/09STnyQs5BT8CRDx+Qx+aOKKWtTbsu5FwAqjugazF2AhFt01Wuhu2fxNip25nHo1RJOQtEtFPFICiYUsQO6cZH3iV17cOppVaqnrGsiucJ/VDWyD0vSktR8dSxzAtKxkMzQc7qojP6yrCtjPl7eINzKe9GSbNoRLGIglyNHdB5rYSuqK6jNYyakCpqhdcq2jUaeV6rkUfQvTBPregEZHtXBRXPU3jQsEwrD85r5OKcyOq5u6eCWa9E2QqTuPI1YuwMqRXJECkn6xF4cw3dwsOsvahakE4W25JLJbmOQZdUS7fpre0eHfiAoI6uSigAZAGrg+yaCPhtkE/IkR9y7f341J/nC8+pde8FWZCH+XZiqBV5+0Nd+w8o1Kfr6QQ577Xy8dMnC+cqVSoINGZjYH2zSil2B/YL31VRLJvfDYz9PUSiVhheWrfTSBeKudvFc/zqn/HvAFDKuUoaW5nuUjXyqLQejQ1jCOdv3/8EecUuyH2N3DxL6gQSL8h1DdLeVYFHYVwKJ9bIi5IgDzrsVX9bhEt/MxtrY/b/jDd2iuiJ0ZJk9ybZi4LvWHHpWm97ZhUmXj1Dsf7zAke3Y7uuLjwUr5Ua3sl/VqTFm59hLRIA535Y8bCrp4JhAwoAov6k48EZdNo6n4/cBN1EzFaFtXqPUKrmDgeiNikbNPLlAbXIvplekJsDyWzQrajL3BgsyjYljwr1ZJMaE8pVj4aBUGVP9UfnNV7Wt4cYvFbe8tMn8eyret95G8XJP5LXi4p5PiAoutcmyCmN5IdOIx81qKCtkwkpE+TRy2qNna6jDAB+ltS51rEOI0e/hc/pLCsBQTys7oe8Rq4Icv/ckmA3e9aZTKWJG7nWr5Gz9pA7kU0jj+PIGRe4VdpoQ9zlHspz5XNxx2M5cq2xk2lAyZ6hA2EBQeUqOrorGCZr5BahrFMA/MjO5MZOhsjYWZtK7lExBz4TBmySM3Hk4TGmkWvOtdUpyFdt3a0cK1c8bGr3DdzFvOwc4An9MB9y5JExuyNQ7ipVNTe6oJiU9Rw5D1NiPH6VaUsHwp8r5d2QSglzOnlie3Zpxhg7L+TCCf4s5hxMGTMIx+43rD8KcnVW5VHIaagVXiPXeF+wzHa+JVttzPauiuLRwsM2pvhBoWjkkhEuzjNACNlNkOvFJMj/vWAdFq7erniUKIKc7/gJc8vI8kzXnrVo5EpAVY2b0FIqRsoleYYOfEBQR1cFQ4M9W00h+jxkBYBSP4gk1v2w4infOeLI1etvfXoF7nthvXoC/mQlcuT+/5WQIzfTBUDUR3VtaEvtIIPvYnKysAEFFy+u2xnmOpJtUrJGziZC1k97Kl74jpWqp0w6vHcJkx0yR85DHq8MvHjpkuTJ9+5/OfR64Z9f4Gwb7LCskWsVHN2KCZHcmDBiANoKbrpD9GVQAGu3RfSDTrjkXZ2xM3pJ2S8ZiKgVo0be5WvkRmOnjSOXZmUesoCJdi/Xl2Xy+2ZQDIMGGuLVzbvwzp89jU07I9e+7oqnCBZRI9e7H8qTG5H8fmSBU3AdQ2RnMtojTvOQT/O5VhpxP2R+5B71t3sb1hZQK2Ea2+SCnNUxLiCop+opybfyBn9uz6O47u6X8Aku9an4TCrQBxGlQsNnMehsBmxI6do/zvuG4fp3HI5JowaGv7dwu2u5DsGAQk7YDKMojZdKlQoUX0EydvIr9IqncuT8+zMBPKiYC7OgAnqffxm8cqILJPrDMyuD6zhBzq36mXCWJyYd5GhPvwxWD79fuo5KJ+uQGkG+qb0bl936fPhbp5UWco6ajzym3BIXEKTL5dHeVQ7cxZJTK7c+vQL3vrBe+OiDS3pqhf+wQLyXDRDvkQLEBwS9sHZH+Hd3uaokReJXPLq2Pmr8UPzuQ28U6yhz2tKkOnHUAAO1kkxbjvUj1xo7Y/zIE2gzhEQTcU/Fw+BSDg6J2tgmzGSBzeoRp5GXqxS7JEHBCwQezNOIx3uPnxD+TSVjZ+R+qKNW1LrYOHKboZeHQ8zvnHcJ8i4R+pnKkXvCFniy+yEfBFWpql4rvNbNUsYWc47v/RE8l6c/zVvRmXltsb7RdUUuDQg7PHfVNjzw4garrYR54ehcRymlcAjgErsLNENqBLmcP0InXIo1uB8y8O6Heo48hlrRPOC6u1/CJ/80LxRs8649RzEKMQGj48F0EPKWaIR0rZGdPVUPA4M6dVc8ZTNrMdpTLcshRKFj5IlQZkL2HzmwJj/yWq/TpUSIvAX09yS1G5Y4znZQMYccJwB0wowNULldo2jJOPdDD7ulLIZMC5X76dxV24Tf33jn4Zg8ehD3zEh7dEgctaL5PqHLXP0aOSFEyS8zOBCcLiHIu44wcSmCvCpRK0FZoSDnNHKdsZMP0vrKP18I6u6gEOSZB0Q6JclWdLYsl3w/DykxTeIv22qO8eY6G0bV8w3mqdbIZRoCUBtWJ8yY++HyTR340O+eQ1eCXMOhRm4IRmjvKqNS9YyCXBYe/HKYJeIaMbCgzLxRMifxt3GfTsHLJH5XlFhBHqTuJMTXyOUOFqeRuw5RlqLyJCr/HjO4qN0/0WzslDV8+7fU0Vzx2Q/jBwGlIhdcKrjIOSSiVjR9g2mf8kqHPS5eI/fMGrnUDq/vFA1zpbwrTC5X/Hkebnl6BQDfDTY0dobuh3qvleiYuGrkkVQjdx2irE5KgSKhOydz7xVPtBmwaNqQWuEUPV2mRHlS9MtwUMy5YRm8spUkERybHI+fNCI8Fk6SwXUfOWVS+G4Vz1PGt83jKfw+mo0/qpTCcQjaCq51ZcDQIkGuPlZNrKRWPu8SVDyK6/79Imb+ZxNmr9gaS62wDsM08kLOwafPPDA8vzPO2Cl9mNc4a7yf5c7/iPKmw7J/sy7roHB9jcbOnor9zXsqHhxu5xudIGedTjdpuoQok5POa4THwGJOQ3+Y6ygLlVqTZrHyPc8cMZhkMeBRKnhRlHIOck5EBei0a6ZpKRp5SK3Yh1ZPVdXITQFBcn78Ut5VBOP6HV3IOX5gk0yVdPb4e2ZO/sq9uGPOaqUurPhGqRW5v4Rt5BBFM1W8VmRjpyOuTgRB7qn9WWfQzLt+/2ffMYkHDj8OmUb+oZMnKtextnrPtPHhyrWq4e5tgpy9QrdGI/c8CpcQDC7ltK6cMloS2SkbzXTQc+QuKlWPy9pGYpfOxZwDQthg941+vNBl208liex8783PCoK8EjQ2oA5o2b85bgMEvmNqBXmNQq+n4mFQKRdqJLK2xTwdBhRyWv97QlRtUy5DXq04hNS0/6R8ircN8JFtpueH93meZWMJg4CXPAr4VSLTeE35yIGIw5WFV8iRJ8h+KGvkoSCXXkZuw7a8qzXEteVdEEJQ9Xwtm7XXjs4ydnX7Css/56v7jLLydV0qbmXB4FMr4rX5sI0cVSOXvVYkY6c8gTDqlRB9QJBu16ZCjlEr8Rotg873m6eB2DAPKTQneu8qVVcKSfzwRT/y6H+H+IFH7V0VUEoVZZFHUzRyQsj5hJD/EEJeIYRc3YwydcKMhQszIZZzSKxGnncduISEaTJdR5xGKlX/uMzZMfCD6plXt4SBPW151581w84q3hdq5KGxk2nkSaiVxo2d3VUviFj03er48tl4Y365Wo3cIUb+l0HutK6jyYdimWn5c1t39QiCTScITZOXLYeH0bjMnaAUiiB3OY1cS60EH1ye7B4PNhRORK3IHHlAJ8grD9nAX8q7yOfU8ksFN+DIRXvQjs6y1fuKrcx019hcL3k4mhVcPtTIo79HDSrixkuOUa4tVz1hIpe5eSbIhw8ooKJZgZlyM/EaeaVK8caJw63vwfexzlCQq8KYPd91nPBddBMMCy5LitCn3/OplSFtOfRUPXzujoW4+FfPGO9rWJATQlwAPwPwZgCHAXgvIeQw+z32Mh1iEOSOb+xkHTvnOlrO+YDRkRtUPufAcQiqgV9nzhGNeKxTmP3I9QPAdYigkSvUiicOjrjAlZoFeQy1Uq56gX+0z7HxQnN0kCKUdX5dWxMCxdipaOTSb5eQmsLu+cnoFckzQ7ekN+ayrqpLbYbNHd14ZMkG5bjs41vivn8p7/gaucXYyYKE5Pnm07f74fZJIjt3Ke6HemOn7K/fVnC01E1bMAHxgVIF10F7V9k68Ud+5JpVcA3UitxOeY5+ygf1PXLcELzzmHFa2k6Xa4WBCfJhbXkl5S3gKwIymLGTz1mis8/J9WBgqx6ZBgKib+QSwnHkaqzKQE4jj+sTAL/xhy9bWCqAf85fi9krthrva4ZGfjyAVyilr1JKewD8BcA76y3syrOnYN9hbVphlnNJmKIS0Gs9Y4eUMH3yqPB3Plj6VKtMI3eEicS0eQCDSRDt6qmElmVA/UgVrvMAkdZrkmtxgly+LS7RFQtKacu76CxXBZ/vMYNLADj3J8PSU5YVcieV24YQn+oStstK6Ie/bKO4I73OW8IkjMpVatxP8h/z1uLDv5+jaL9yKDbv11zM+Ry0LdcK01RNgzOOW+6peGHuEAaT+2FZaudiztX2/ba869NbNKL2Rg4q+P7xu808a3tXBb99aoV2okzqtaLVyFkbuSRcQTANVdHIZY5cei5TOoYOyAfuh/F1KgTuh93l+gQ5S2HAT2ahoGWC3CVhgrRv37sEd8wRM1O6DgnlzZBSPJPNR2a7DhFyrtjQDEE+DgBvQVkTHKsLbz5iH0Eb4pELtGD2wSlUDbe7UhU6Sd71taty1UO1yjRy7voyM2jVlmuFUl8QsgElD6zQj1zSyGXwSymGRiI7eTiBRt5ZFrfRYkn727vKYSpYWS4QqAOTf4dK1cNn/rJAOK/bIdzmA8tHcr6ysSOMwgUMGrmhrMde3oifPLzM+By57oCaXoA3wJfyjvA9dXUJvVYMy8tkHHkyY6fs9tlWcLV8aangeynxIfvsW2/pUDVWhuv+/SK+cc9LmKmZDOPcKBmIxo+c2RZczjWRRVvqFB8xRF/VyEt5B6Wci4qnRnbqkHcdFPOcRk7jBbmuj+lW67xGzlblD72krvwc7nwSmoXnyAkhiYQ/0IdeK4SQywkhcwghc7o69XkOAL/R8i4xaOR+chp+n0aZc5ajGPO5aHkVcuTcIGBRYCZO09ZhdnZVQo5U/thyZGfEvekFirDrfQJBvi4mCRfgd7K2vIuunqrQQccM8Qd3R1cl7ORtmg6u+JFzZch5V4aUclwaAv09Mnjhun57F8YPbwt/azlySzRrHBTKR0hpSlHKiRw5T13o6IWI/9X3G9m+IKNc9RRPi4JBkMupC0p5Vxul2JZ34BDfjvTiWj+KcnKQf36LtIkHDzbWdAZUU56ZC6aOw4XHjQ9/2zhyhzMIMsGk61u6XCsMOzrLGFTM+6tyT79RswymkfMcecF1rBQHa3ueS+ftZ5vau3HE1x/AwtXbAQS2JEt5OYeEMiKJdh16rVAK10l2D9AcQb4WwATu9/jgmABK6c2U0mmU0mltbSVjYcWcz//pqIOcS4QMap7GR7m74gkNmwtc8Oas3IZ/zl+jCAimkZvyR+syyDHs7CyHHVTWIOStn8rSb/k6cSOI+K2ptlmWygxu4IfaWa4KE8XoQUwjr4SDWHbNoqBWjlyebL7xriPCJaSXmFqJytjU0R1OMIDefc9EJ8m0iQ6KIJfqKBg7c6J7n86wyCZu2djJYNLUGXS75Zjy8cgpJBiFIoNx5HcvXBdGSU8ZMxgAsNmikTOwPjb9wJHhMRNFdPykEbhs+iSh7rL2zu7lffKHGDTycpViY3u3ci/Dzs4yBpdy/qpcE9mpQ8EVvVaYjczG+7M+fsHUaJLilbRnXt2Cju4K/hq4cfJeKzrwk9jQBEI5NDx7jCPvO438eQBTCCGTCCEFAJcA+Lf1DksfL+Qco6U87/iz65ptvgsgn6SG4Y0ThyvUSiHnYNnGDniUBbrw7oeRB4wObFDpVgg7u8rhQOY7Hku3ywsYU+BKuLNIjdRKErgBR767pyKUP3qIP5G2d1fCZ+mWnDY/cr6OC792rm/A4vxpGWxcJs/9bmzvCicYwJBV0GSvSCTIzWV5VNS6SnlHEEo2asWkeZsEPEO5qrpMht4PGjfPCSOi1Upb3lXsFwCjXMRjB70h0Mg7zBo5A3vqVecdEh4zjUXZb1wXoh9q5ISE7oEmQd7ZUxECn+Q27654GFh0kQto0gRyPAwICjXywBPExPsXXCfsF4M4AcoLcj4POeB/Z9dCo+U4768J3IrThJBaYV4rpT7SyCmlFQCfAvAAgCUA7qCUvmi7x+ZHXsw5xuUc05L4DXd5auXEA0bgN//vjdEgC5Y9/Ayc44wPQOQraloeMaWpWxNdtbOzwmnk0f3FnE8BTfvmw+Gxsuen3pTzqIRZEnkhqQ3Rj/DBk/bX1lVGFBkmhjQzgfmNe17C5+7weW5ZkBPoIjvVOn7vv44MswWyNly/oyuilhJo5JRSbGrvDr1pAL1GbrILtCcQ5ArvzP2mkkYuGxProVZscrwU8LbypM4UDCGlcdUL6EIHf/zwCXjnMfuilHe0Y6ik0dRZKL+NI2dg1eEnJ5NGTggRXG6Jhlph7pQ5l6AzWPkywSRf+9rW3cLEplOsBhVzYVBgkrQPrhPt/AT4ShQLmtKhmI8EOd8GvPuh7KacRCNngv79J+6Phz93Ov7v0qnG6wVqhfStsROU0nsppQdRSidTSr+V9D5dhKfPkUfHeR5O7lRVKmrkR+w7FIOKuZAmYZ2Fb3zXcURjZ4xGzj6sUSMPPjg/2Et5FxVPTGRUqXp460+fUoJAeL4/rFPMjj0nTx4l8Mkm8F4rppS7Ty7bHNRZ/RYqj+mhs6eKI697APcu8lOqjhxYVK4/+0eP45og34V1z9NgEuvorqCr7ImCvAavlSQaOe8f/JHfz8Fn/jI//O1RMY6gKBk7de5nrC+aGBReUF3zlkOFc6W8q3Wh0xmLD7zmPjy8ZANyLsEpU0bhxkumghCifW6bhjsfGWxQINs0AODSE/YTfjOliJ9DdcFQgJqLx9EGBEXuh2wPz9DYKb3Aii27tffyGFTMI+c4Qt7vOLDIZsAfg65DjJMTP5nzr8L3DVkO6OIthPOcsXNwKYcDxwzS+qUPC5ShMBNlEKIfZ5wN65voqiaDvbZuG6mCK0aByXw3D3lWZstAdj+7Wm44Xpth/JlZI/efoct30MPtvMN3jmJO3QCjXPXw0vqdkBFut0XtGjkPh0QTx9mHjsH333OU9jqXBBy5ZOxsK+gGifotdPlj1u3oRHtXBT999BUA4rKTv5xZ8K1+5ME5ttkAc4v0y0pu7OyoUSN/eMkGPL9ym3COp0KKkjKhWx3kOI8MHXiDuppnxEG5Itp3hpRyETWleU2575s4cvk4EwS6yU7WLlm3E97dIPR01IpsZ+KNncywO6QtSKQlvY+cv1xHfwwq+isleRLUGeoZeI2cceRmQc5HcOpXZLL9Komxc1ygdDE5pHs828yE35iCfcskPHlLBDmTo3IDsPB5vuH4ASb376on7hRSkJa7obbMddhK1ZOolRj3Qw1HzofdssGXz0kauTQaTfnDWXRlnPuhGJkZBSGceMBITBgxQFu2Kzq9zAAAIABJREFU4yBwPxQjO0t5V+kcLAc3Dx1HnpcGq7jaia7ftruM51ZsTUStMEHOa+S6sWFyP6xVkMuQT8k0ga4uYWqGBF4rsjAsBBM933cnjxkULsFvf+41RXGQy9DNHzK1cs1bDvUjmx2ibSOZYmBaM9+/TStVoghylXvmjZ3MI4ZRK7INgQX8sDJ0E8igUk6JJQGAsUPNzhOFnBOG/jOvNRNHzit8fPX4usqbKPMBQTo4DsFvPjgN3333kWH/1rmOspUKnzSLNcG44frxLTwn9opehNxJWMcQNHLupeWgBtnYyTomu4cVz3fYctVTcq34z7ZHdvKCfMzgYjiQWJ35zrGru4L7X3xdKMekTa4J3Aj56FKd14ogyJ1IS7QtFXOOE2orfC6KAYUc5l57Dn7xvmPDY2xpx0Pub5UqVVzhBI1c+p4X/eoZux95MMBYsAdv2Inz+uDRoQnPlmET5LroYP576gyXrA+ZvVa4sjSUQ0/VEwzBx08aEfbbVzZ24MZHRL94ecLQauSFyAg6sODio6cdAMBPAqZrI3mlyvbJ5TcSN/HJsruhLNiBiJZxCAnTzIb2FMP3ZX3ZSK0Em8uwT3bB1HG47cPHa8sCEBo7aZAHxU6t8KtLEqbh5cFPsA4JOPCYBGljhpRwyfERjaV79yPGDQWgcuQAcJkmaZeMllIrcmfUufIJWp4UhutR0Ys8StIjaeQuL8ipYCbiOfI//Pfx+H+SITHkyLkPWMq7GBE49zOByj9j/Q7VT96UJ2RNkISLz/ei08h5jZ5w2g9zr9TBcQjags65i4sibAuSQvEBCrJrFAVVOtx9i1/HWT98XDgmUitqB7Vp5Oyd2OCQB1JS2KIWGWwpcnWneDpFVxf2uZN4rciCg+0961GKsUNK+P57jsLnzzlY4KZlLxNZizx83yHKM3mNPC9w/q7WICz3G5bze0DRHpgFBKuWhBy5Q0goqAYFk4RJ9oUrXAO1kneIkFvnv6dPwniLxhqOqSCOxDZeBI3cAR783Gm4/aMnCtfw/ShUPC3Uiq778/3psukT8e9PTcfZh77Bvx7RdoFMWbjojRPw2bMPMj4DaLFGLs/gbowg3yIJcj/LW/SbCVOm0bMOyRurKp4naEuhpd4hOO2g0TjwDYPFZwQX8Junug4Jl0msQ/J1Hs5pt5eesF8wcNUvWsg5WBNsb+dxglxnWOUnAp9aYRq5Y9SaXBL5h/NZG5mWzu9qNFSjkcvf52FNzhKBWtEJcpuxM3inSJBHA6kGOR5rU4irh+4c71KmG6dsMJq9VswceT7oD8wd9sJpE1DIOUL7qWND/MbDBhTw0g3nCcdY9kNAnIjMGrlYZntXRfGzNglypo3y7yvXkfVLQoDfX/ZG3HXF9PAerd3BIaGWp3vuwMCRgTd2xijD4bt0lX0t3uE0cvnTyRz5PkPbcNLkkTDBlJ6Dh261x19+wOhBOGr8MCEGI0rIFV3IbAsmtFyQ//L9x+Gcw/zZKMptoe/QV549Rbi/SkX3Qzn/BeN9FY1cIyWikGvxuKfRyHOug1GBCx/rkHzHm/mFM8K/Rw0s+C5TVU/hpccPa8Nq5hNPaagR6DRynppxSFRfW4CD6zihcHz05Wg/UybceUEu+6sSEG07ySi4HJ+q0aKsfuRVcZIsCgMp9tE1oWZqRRJSMpywvxg4cu6TqMmkSMiR84JIpCqIuAuNRljIz24rRB5ZvLcJs5PIkBWAnZ1lDJDC/018siNr5I6qmTJlgxB/4jlmwrDwnKjNs+sjNwSdllvMuWHbhYLc0P4/vPBo/56gTzGOnjd2yjy8yJHHd8A4Owmgz/7JT4ARDez/TylVNmxn9bahNdRKUGkC4PwjxuIjp0wCwBse1WUtIT6P9LvLon0kPU+0/PPGFSCiC2SOXGu8YrOrIZqR15JzgkYe0Ddc9N/QAflQuBbzURDDwGIObz5ibHjduOFtWLvdp2FEjtxTOgfvBeMblqJJy6iRO3qLPhucvKeKrqMkydbGC19tuk+pI/MGTWbs7OY0cpa5shZqhcd7j5+AL55/sHLcRq3o6B+5D8rViTRyfZmiMIwumjhyQJhLyKNi9Cx/j0uIsNJI8i3a8q7W+C5vdMwgKwA7uyrCvpZy3XnoNHJ5ImeTic7nnZ/AWB/NOU7YBrpApLxLwhB91jSmdvmvwG2ZvSOzEblOFHAoT468Rh6XYgGIKDmrRq45xn9z1rzs2NINHSFLIK7q7KK6pRo5+74HSXQG38HYn+yVeOFT9ajArUReK/7/zJmeFzCVKtWqe0yzlgWILrKTp1Z6DNkTWUdlrmwsu9vwgREvPaiYCz0FqhK1YssFTkik/eZcmyAnyiC+8ZJjwsHCR69peeBEGjnvraPWQ9aE+ehNJlxDaiXn4t+fOgWzv3JW3YL88tMma41UVq+V4NO+9ch9cPahYwCIE5vOQMZkVpIQfV7AzbzqjDD3j0fNE5ZDxHgCnUDVuRrqIo1138Wvl3i8o7uibIRg9lqRPXtUjpzXyGXw97IVopAWQcOZFIL0HVUv0lrj5jc2NnZzGnkhHDviM0oGrxUTbFlYGXTdjn8s+4asiC//4wUs39Sh1CFOI2/JDkEM7CV44QZIg0jqBbxFvcoZO8cNa8PpB432jwcjk3liKF4rmrqwjiV3uiggiKNWHILTDxqNm594FfsFrn+KIA8K8nebIWF2NzlnBlvy8hr55o5uf/Bxq2E+nN0fNGaN3HVIkAbTEazseZfgncdEiSn5CU432JLIUv7ZuuAFeWnJD9bI2OkF+awJCrkcBhVzdVMrDtG7d4Ube2i0bxbG/jPOiycnceR88iX/mH4Fx8Cn/JU1X5aN06PU+J6OQ9Bdjb6dTuuTD7Xl3fAb8GOopFkp+fVQy1Q0coOSQKDSIzJHbsrV71+vEeSBIdNUt5zjhMfZt4ib8FkfZ370PEcuP2NzYIM7ZOxgHDF+qLVcIOpTtVIrwsrLUdtoyfp2pdy4tMgt2upNxXmHvwEjAoHOdx5Z4+F5XS9wP3QI8PTVZ4bH+ST0gNjhK56aDAowb931i5nLcdG0CYL/qOsQTD9wFBZ+7dxQkMnLSpcT5Mz3teJRMZQ/76KzJwpW4Ae87K/KJ5giiDohgcqRl3L+juUuAc48ZAxGDixgy64eq1aq98xIoJHnkmnkHzvtAEwcNRB/fT7KeMzeqatcDTaK1tMMtUCOOGS45amVuPTXs7H4etFA+NmzD8LlgZseD94Yx3sJhc+JMXTxxm3dFmjlCuu7pomAChq5zv6gcuRuuEFG3HfR3Q+oW5OZ7C8OIQI9otvqjRVvU5wAkVopB5OXjkrIc7m/b3/uNaEcprzIYDKF5XHhOXL52z0RpPH92fuOTZTjhD3Ouj+rTiPXCHK+Kl+4c2FwTL+q06El1AobBPzms7/6wDR8591+hCLPXcmbG/NZ+pixUx70zB0tdLKXnm9b6smde2N7N3780FJFIwd8LpzVR+7wrBg/d4yDea9tw+6eqjCztuXdkB+uelQbCh6+q+BHHnmtVDxPeTarE9M+/ucs30hsS08h90Wd+6FyDxGFlI4jZxrJGYeMwXuP308YPCG1Uqkq2ry84XBSue44ao4YIPK4kSMIT5kyUrspb04S1LJGxB5hEsS8cVqXFZBp5Ka5srOnKnDkuqW1/GheIxepFb1Grks9O7CQkCN3ZBdNjTJjUQRcQSOPoj3ZYZ1Gns9FGvncVdvCdwDMEw5LZfFakAKAp8lkAfzDC4/GCZNGhPlpksImx7XGTp0gj7FRxW3m3RKNPO8S9ABC2krxfG0audwETOiNDPhYuS11/SuaMNRzneUqunr4Za5OW5A58kgjX7+jK6RQchJ3GVIr1LwBNKAGIrDJrlylShvJRl/bsuwnFx+D0YOL2KzJjhcnPP2cH9wSXiMwmEDTaR5se66usidstQaonjsOIYk2E3ANGjkDy5wZXm8YIOGenEFRNjuEDhULtRJx5PrVIeB78ogaufp8WYEp5d1Q++YFoVmQ++1V5VSdARK1Yno/QsQJU8eRy/yvcI5XADiqgx3VCa6C62CT1E8jmwCBbrP5sUNLcAiwKnC/5ZNmyZPFfx03PjSS1gKbkNVTK9HfIf2kuZdvt7idmlqikZv2JmTgO62sFRZzLmYFNIq/sYQqcK4480B84k2T8Z7go8ibT+is6Daf0LzrCCk2dXJRNYaRoL6O4PrFu4W1Bcm1ylUvMHaac0as5JIKEc5DQNZcxXfRd1ge75o6DtMPHKUIhSTuh/JSVreE75a4TF5w7egsY2dXOaRWeCi5uhOq5A6BNU3yis2SIDeUG1JXMRqfSdD1VMweJ1FAkJlC6irHa+Qy2gomjdzAc2u8cQZKqxPTYx1pEtf5kbN74/oRy/cuaKCuWrecQ5Tt8dj3M020edfB2CGlUCN3DMbOA8fUpoULdajZ2Mm1m4Yjl88BKfVaiSPuTX7kDGz5Vw2cVmTBPKSUx5fOPyT8uMqkqNXI9V4r/jkiBNToJgJZWLIPIwsogVoJBg3b5d7UGXn/W1ZH9mHl/RyBqM2KGr7UhCRW+jjoND85KZncvqu37kZX2VO8a+SgqLjADwZi0MjZ+63aIlIrxlwpbIAFv2XagLW6kVqRUirwYO6H1EKtdJWrQuxC3OcZN6wNQ0p5rSA3KQiEqO8vJ7JLmqZX50cel5OdQReWL/upAz618vlzxQhHXdI6+bHjhw8Ix6/gRx5c+JYjx+Lhz52eqK462CM7Y6gVy6pFSCcc05YtEeRx2oX8QQGxI7OBEeYjj+kvusaUoVv6h/V1Hazeat9aTZ5R2SvI2pAwwIJBx5JamUKHDxg1UPjNUytMI3/4c6eFQUqhIM+rA8SEet39eOgEOTPaysETY4PNLVZv7UR3paq0kxytmbR+rqPPds/k6qotMrVi0shFJcDUhqamPXhs5FKrrir91Ko290NZI49Lv/3Q505DIeeEFFVcGl5ALyxlY6fZPVKlUUz5YOLkOe+BRbh75GcUgrQSbztqH+5eVZDLVMe44W3hitp1SORHHrpHNtb37ZGduuvVe21BZ0BKNfI48NpPmJKWe0/2oSoeRQI5LjTmmYeM0SZyittMd92OTmXZaQMrp5hzpZBnkVoBgK4eL9TIf3TR0UpZOtdGlkpgnyDz24FjBuOxL5yOp750RkTraDQdc30Tv5oRMs8NRBo5G1usc04c5btt+hp5VXGRk3Oy10Kt2LT3F9buEMs1vDjrD4zjNAfGqPf/8v3H4dj9oj0fZUERbr/nmTXyFZt34QO/fS78HZd/O5q8/Xbkrza5H7qOSkvKyoTrEPz0vVMVAS9XWxcQFL2b/dtFG1BwlKpDtCsZQPXx98/5/58waQTu+PhJwn3CXrBOlKLYJkRlvPyN83HFGZO15+x+5Hb3Q1uEcOq9VgDg6jcfgv/9L30ebb5h9DOV/z9LmhX3IVhTfuasKfjVB46z8la6sja2d4FSYKKkGdsQ+ZE7eO6as8LjOu6yq1IN0lYSvPtY1dgif0RCgPefsB9u/+iJOO/wKFJ0cCmP8cMHhJ2HDeok1EqjWolfT/U5oUYurXhGDCyglPeNV11lz6iRf/H8g/HtC45MvEz3vVbM18rpXOOoFdaWtiyAMkYPLkjXiOfbCi4o9VdipnaX99iM08h5d1dA3NDDZOzU7eoj+427DsE7jt43VBj4e3n4HkyqwuFfa6+7TkDrVguRi7Cj3Mv+/9rbD1OoyHHDIkHuOpGdign/JF2rlHctE6JNkKvHdNSK3pMu+lsXICWUaT3bi/j46ZNx0RsnaM/xH0rXSOzlZyxajw07u2I7Csssds5hb0DedRTjJxB1El17MQPLiIFqzm4TWDkEBMMGFLRubEwj7+ypolqlscv8sOzA0HTS5JGG4JdAkBus8zrIg0bXRvUg5MgZtUKiwVjKu3hkyQa8sHaHImyYsfD4iSNw6Qn7WQcLD9kIx2PyaHUijkunygaibOzkk63p6iA8Q7qGTy0s3/7AlacJmx9Hz0umkbMJsSIIcvMkpKMv5GsAjc1CqrduUtDRojqwCSDH0WK6Cbngqv2ZPZNNtLrkdOOG84Lc4SYOs11MW0/DqsymBOm+mpyjxlQHnZuiCemkVvilU9gZ1Jd6af1O/GvButiOctLkkVj53bdyOX91zzR/VJZL2bYTiYy3HOnzeOGOKEG5vMbTxnPkXP7hMw8ZI2gRqiHV/mzm8hcaO5NQK73UExhFIlvnXeK///JNu4TzDEyQM0NdUurHJeYdYXWeCaaNc+VVkGxkY9CtFEyaKVMEGE2xu7uq9LeDxw7GxJHqhBNHrYTG9aC9eI8imRZhGDesTXVdzcl19/9Xjc86jVw6xpSZmG/H7+3JrnUJMbrV6pJJsXO67QD5NLe8+6GOtrUhieeQDN0ErKOJdeNPjOy0P7ulIfom6NxzeCiucrXSAkHjEhJpVjaOnAUu6QJHTPjieYfg8lMPCHN+uw4Bqr6R8ufvOxZd5WpIfTCvFSZUbvmQnxhs4tUzAJjD/01gg7ggGXVs0Lkf2vDsl89KpLV3yRp5UBU+MyMALN/YIdzHqBWmTSbVmggxXzuSy/PCYNTIpZE1db/huOuK6XjXz54GEK1YdPfLg9JxCO759Cl4Q2DgZe/d0V0JDdQ89KkOtNU03ssL8jFD1B10Hvn86Zg8epBSf3mPTjYWVb9+SL91HLmqhOmgC9BxHFULDfMLca7CYZIttjG7JnMoTwuJAUHmMa9DHE+tg97YySulMNah/yTNMiCneVFbX6i1eVkf5wer65o/KtswuRaN3HWIIDh4zeEtR+6Ddx87PjJ2MkFu6FDyR4xTDCJqRXVFM6FWr5WxQ0vYZ2j8BtDdEkce/S8a1lZvFb1JmCBigqk2akV/Lsm+pAz85gpR2ep1uqZVKQY/cydLtBZRK1XDlm1qoUk3G2b38sFT/OqOgeUIkt/JpDTIu1apHDmpmyPnqRXd/XLd5M3VAYS2pf01dqxS3g3b3nWilBZy0Fcc4oQpAMz4n1OE32ccMka5hn8vG/0kCPKYSqZeI4/bRglAzZKchp4IBCxgM5yddRx5kKGQCZV67IJsohColYJIrZg+luxDGrcCYVGFkR95fIWb4bWiAxMArMohtSJp5Dd/cJr2/mKNGrnr6EP0Af1EbBLkOqEv1EGTajQsU+bIFRc/v+yO7or2fj7Hu/y8OOiMnftqBHnoGmigLxhY+6gcuUqjyG0ZfXN7ncWAoOBiqvZJeeMYflxcNG0C3j11nFHYjh/ehk3t3YH7oajFJ9bIEwySw/cdijcfMRb3LX4dz375LLxhiLri4ovRJc2Sz/l17UWNnBByISHkRUKIRwjRj8Q6IOwQlKCR69XIeU8Em9cK2yatFmpFhm4LK6Y97e6phruX6KDyljHUCuPIa/Ajj1v+1gtZIy9xO4mz9z/rkDGYfuAo7f1MMCXl8B1inugGarRskyAfrNm5XFdskmRjqvuhSCHI0HnIJNXI2eTNa+T6SYn9n0yQy4+X31pHrbB74vpWZMR0xPB1R1xdyVs5qtSLuZOwVYkYEFSbH3lSjvzHFx+DRz5/OsYOLcVGbNp87fnX6W33w8UA3g3giQbLEaDjkGyvUStHzgYF/+FzmuUaQ6iRW0LoAeCuK6bj3v85VXvO5rXCUmwaqRXNUt0GNoiZZpdEkPcWZI6ceRB4NBLSJcsEGQr+xBw5wWlTRuNNB4/GhBGiJipHLQJmj45BRTX7HS/0eLl232dOxY2XHBP+1lErPNryUT10Qo4X5Cw/elKOnD3blukSiMaMbOeQV2+1BAQdus8QXDA1SpMclhynkXOD/KQDfI+dYrD/qG7bR6aJJ6E6GJjBk+fIbUGA1nrGoJR3rYm3tEmzNO0sbE7Sm+6HlNIllNL/NFKGDnF+5DK6NNtYJQHvzRFpKOp1LCl9nD/2MROG4TDNpriAPgKNCTK2e7nJg6JWY2dF0siT+JHLA7pe98NDxoqbhMheKxMCQb5hR1copG22h6TL3x9eeDRu/sBxfnkFF7dedjwmjRIHk04jN3n0DNJo5PrBBhy6zxC86eAxxusU90Nu4tK9Fv+9jt3fDyxKqpGbBPkHTtwfb+UiIhlkI6ba1/TPkevtEF/z//HF0YTGKMy4ERxqmxT43/cchYc+exqGtuXhOOL34Wk5/5nJFTimQPAcOSGMiktO2zUD+jS2doouNQFBhJDLCSFzCCFzNm3aZL2Wb7Ak2rZus2IbPI4jl59je14Sf2wT+CxtDMWcA9ch2BmkbTPNukoK1ZhqyBx5X2rk933mVJxx8OjwN/s2rFNOCIxs63Z0hdqwTZCHIdsxg2jCiAE4lwuO8p8pXjOgkFMmNdP3ttERgOpWxgscNYBL/M27A+oGcJErixmsE8rxsDxZkH/jXUfg++9RA/DksWOiVkzPYbCNG9u5iSMHhG1HQVHKu5gSRC27RM0DD9TnPXLcfsMxenAR+wxtC/sACzpKrpE3R5ATroltBmE5iZgNsSOcEPIwIWSx5t87E9YbAEApvZlSOo1SOm306NHWa+XdWfx61PK0uLr4/+sEHD8LPn31mYKxIolmawLTyGUNY2DBDTfCMIaLG9y6TGBjmAmBJH7krE0Yl3jqFPEbvWFIMfR0sEEetE+9stmvc/BuLFx6/Y7OUDPV+Tmz3Z0Y4qiVJBsvDCi4idMs6AS5TiCxQ/zzFWOn9F15I6/uk/P9jAUHfeCk/eMrjWii/OBJE5Vzun4jp0KQ+7hxKzvZxVJzWcSR6/Gfb56Phz53upLXhn+2dozWoRkftu8QPH/N2Rg9uBjlWIHowhgH2StnUg2R3jx03ii6duavi6NWYr1WKKVnJ65hk8B7qjRTgDN4FkHON964YW0YPbiIDTv9HMhxyd1tMA2IQcUctgeCXBZGv7vsjVi/vcu4aUUcTHmXbThg9ED8/RMnK9b22V85G5RSbO7oqc9rJ3h/5rJ4/MQR4USj85t+8MrTwnYH4jVy3WQl3zOgkMPPLj0Wl/5mduL68tA4rYQQ6MBYjtyukfPCdNywNqz87ltj68swtC1vvF73TrJbodyOpglUx5HLYPScqb+w78/6vbpvgF6Q1xOYw4On64a05bSGbR348bnw6+cak9zFIW6HIAb+mOMQfOjkibjeUGbq/ch7w5uCdTDdfoRyp+M7UiNLK/ZOcg72gcVcqJHLE8UZB4/BpSfsV7NGzsA6WhINhq+VydpOiL/ptC6IJQ589sMnv3gGbrxkanhO5w00ZkgJR3L7Jsa9gk4jV/Z7Lbo4+cBRuOm9U5Vrk0DLkUOl5OL8of1NhM1UnphkrXlDVCeUZZtocmpF/q0R5DEaufxM2S5jolYa5arzHEf+l8tPwkc1W/3pwI/PoW15QQHZb8SAMBVIHIgkoIFk3k/XveNwc90SPdlYIXIBgJsAjAYwgxCygFJ6XsxtsRA58uD/Jgp01sEmjRyAtds6cenxUc4XJYkQ17GZplSPRnriASOxdEMHhrSJlIEoyA3UilOfRl4M65tAkCclYesE/wps+c+emUSziRu82tWVdIjlsa9XoxM5cst1MYIc8LXy9m411wogauTNFORJEo8pe5MGdT9mwjAsWL09PK4EBGmqydooTvFgE5c8qZiolVq8VbTP48ZFLfSIjad+4otnJC5H8MpjHLnmuqSJ4oAGBTml9J8A/tlIGToIGnkvcCssWGLc8DbM+arIHJkS9TALd7249m2H4dIT9lOi7AYVc2FUo6n8pC5h6n3pWXDptEE2bpO8Tdw76zhEHUcO1P8dE3s3KLSDek2pwAS5nVpplqdEUpi8Vu742EnoqXo44usPAND7kctI6n5oplb0E5ltW8Yk4DXy2u5rzrcQIjuZ52WM10ocUh/Z2Rv92LNoCvLz+B1IGlkV5F0Hh4xVXRMHFl3s7NJz5GEdDKHPcbBtHScjFKpNmDi1Gd80HzJceid4Zlw/yGuiV02737h1CoKk18vP1b27LZK4lROw/Gw+uyB/LhFHnnCVF/VviVoxGCIbp1bMvLQNiaLME0CI7LQEBNXiXplKQc4Lrt7gyJn7YVzUFRDN3kk8P+rBwGIuTL1pMqaaE/bbUY8GId/xwZP2rzmiVTd+dW0dZwzjETd4dW3HDwRCouAfVlYcxXLTe6eGwWByebXUVdvPLO6uvdXXkkB1dTVx5PI7qtfEbYfHwL6D3thpngTrlQwhtVJjCY0aWRnYXqmU2v3Ia0EqBbnrigOQ/78ZiDqYes6WA5kFFbB0uM0A7+ZmpFYSDi4Z8nU6l7oQBuXphncekehZ9SCpMQxIzrOa7hlYyIXtESVpsgvMtx+9b2wdtP6/Cb6PbQDX6w3RDCSd/OVqy+8xdkgpcUAQu1XugoWco22LMG1AopqqYH2lVrncVHsFIahSGiqOunep1mC3SqUgFzny4P8mls9CfPXuh9K1HLVyzIRhuPd/TlWiFxsBHzZuGkS1Zj+cfuBIPP3KFuHY41e9CYNLati5jGZOmCcdMBLPvLol/sIaBJ8JWq8Vrtl4X/WkGrkMwdhpuy5BuVEKVfVcmqgVE2wuls9++SwMKLq4d9F6APGfNxTkkuC69q2HwXGAJ5c9JRxvVKDWu1dnM+0VLiGognLebGpQY1yaBR6pFOSC10ovUCsfOfUAtHdX8OFTJinnZM0iF2rk/v+mEPx6MaioChgZJk8CE2750BvR2SP6B++v2ayAR7N2BPLL8nHJ8ROsgvyKMw7Eis278I6j9jVewxBr7IzTyLnVSLhlWI3UUzMN7za3s1YK8rjAEwab++HYIP93ZMy2txs7L8st5n76pOQR4jZIrbTa2Mk/m7XbEI2SVYsgT49bAwedRt5MtBVcfOUth2oDUUwceW8tdwUB06QQ/WLODTe0SAo2mBrl6uR62LDvsDb8+aMnYuiA+JVCnJarG2T8PU3XyBt017Tt1djKJGeJ90aftOyuAAAQPklEQVRNwJGfdegYjBpUwH9rFCbxZv8/U4tOGDEgdFkFmhcQVDNH3kyf/uAdoi36XMyVPOj2KI3cZhTqDch9pMBRK70BnaYoIy7ApBk4ZcoovO+E/fDpM6c0rcyiIbNgPahotvACfH9s0ybGfLPxgrzWnWGi8nQceX3fIq0aeVLItda1w5jBJcz56jmJy0o6OTZKcZDAiFprMc0ydgLRd9dFeTKMGpRcGUulIM/1coi+DbKhKtylO8HmDPWA1/SNG0vUGaJfC/Kug29dcGRTy2xmNU2J0f7+iZPRHrhvynAN1Er9Gnl0faNElJUjb6FGnhRNpZlqLKuRVBkMk0cPwn4j43MHic/tBWrFkNrh5+87NkwelqhuTatZE9HbfuQ2yB2UhfE3o/PoUEwQ/FFrGttWozeiROV0qwyjBxeNdgs2MAYXc8JKI8w9XytHzn2GT5w+GbNf3YpTDBtixMGqkdcgyP/80RNa4uXSzHHJEqmdPDlZWzbD6Hj/lafVfE+zqRU1b330+/AabXGpFOTizNe3QkvuIyyvSEd3RXN140gSjl1vrpVWo5lam0mQ28Y0a6fTDhqN44K83kDkzVLr5My3+xHjhipRwbWAfdIksQw2JBV+Jtx4yTHYsLML37735Zrua2YfPGD0IMy6+kxhk2Qbmml0rAXNfC5LocuD/10z7deUWjUZfEfuDfdDG+RZcv/AyPL6jq5eeZ5uBxTbNUDfr1LSgB4DR27r8KYITmZDqlWzc0LhW9NtWuTCzREaL6sRvPOYcbj8tMk139dsZWLfYW2JJ/56I3MbRTPdDx1C1FTADv/3HiDIeTh9LMnlzrR/wKP1mkbuJuHIZQ+BdEvykQN9I00zl/xmjdzcFtF+iOI1lTCStj6OvBmtzwZtf1ldySAtlBy9RXPGIalrZhI4xJ56o5Y8K0BKqRUefd3N5bE9IcFmCo2Ap1ZMHFwr3dHqwQ3vOgLH7j8cJ0wa0bQyTcZOm0Bh31L+psytq9adZqIo42T3nTplFJ5ctll7rtb9Insb93z6FGzb3ZP4+lZOQJEfeR/Trs3WyKXiBGqlxiGffkHe4uWTzte8mcgn0MibaS3vCwwp5bU71DSCnop+X1ab5mIKgz9o7CAcP2kEvvKWQ+uqi+mJh4wdjJdfbw9///6y441h1iwBU1pWV3LaiWED8ti+W+8NBPS9gsUjzJbYxCC2vobW2OnswRq5aTn7qw8chy0dPfjKP1/olefx+MvlJ4Z0QbORxGslLYO9lWAc+YdOnoj5r23DwjU7ACSjVuTOU8y5uONjJ9VcBza4zj1cv4HAvz41PaRtAH9gOgaRxxYDpvp/9uyDMHFU764GbXj8qjOU6GAeadDI+zMIsb9HzS6ZjVaoVTgv2Gi32YJc134nHjCyqc/gIVIr5o/344uPxmf/urDX6pF2MI78w6dMwoQRh2Pi1TMA2FdszRY2OdfBrKvPxEhDoEYx58KWl4xHHLXymbObF5hVD4a25TG0zRxxy5r2n588GYvX7uijWvlgXHVfUyvNhOsQuxJS42SVekEex0t+/e2HYd32zqY9r9YlTaMQqRUzMXbB1PH9UpBfccZkrN7a+PdhniZySl2710rDj1Wwr7QxSL0IBXk/1S5Zu0/dbzim7jc85urmolb//zTCISq1wqPWVUfqBXmcVnXZ9El9+rxmo5W7wfQFrjrvkKaW15aXBbn52nDyTyGV2ioXumahlV21nzaZAIfEKCF7gh85j77u6H39PDEgaE/oor0L2ficxI88hXLc6BrZX5CGeqegCnUjTiOv9d36jUbeVx+trw2LhQQBQRkiqLvvWK5N8Ui35VrpD0hD0/byfuFaHLf/cLxxYuNutXsdtZKC/tKrKCTkyPd2vP3ofXH3wnXKcdvEa9qwIA2w5VrpD2ilJ9WIwIPsqvMO7vNn//0TJzelHMchcGnzqJWGBDkh5PsA3g6gB8ByAJdRSrc3Uqb6jGaWlj4IvqP9VT3rA9x48TH44YVH13RPmqmVKB95337zn1x8DNp7KUq5r1DKu1j53be2uhoNwSF2Yd3XIfoPATiCUnoUgKUAvtxgeQpYR89E3N4NxyE15+lO88TYqsjOd00dhw+cuH/fPjSDAtchzY0UbeRmSumDlFI2vT8LYHzjVRKR3qGYIe1gSkAKmRVlq68MexcIIU11j20mKfvfAO5rYnkAOI086/AZOHzmrCmxqQvY0tVLoyRHazTyDOlAHLVSK2I5ckLIwwDGak5dQyn9V3DNNQAqAP5kKedyAJcDwH777Ze4gllHz6DDZ885CJ895yDrNWnuO1FK3BRXMkOvwSWkqWp0rCCnlFqz5xNCPgTgbQDOohb3AErpzQBuBoBp06YlVpH6cxhuhtbCSbGxM6NW9m40PX1EIzcTQs4H8EUAp1NKdzenSj4e/txpqHp9v7FEhj0HafYjJxm1sldj/PC2plJ+jfqR/x+AIoCHgiXis5TSjzdcKwAHjvE3Hl2zranzQ4a9CKFbfgpV8kwj37vxgxpdaePQkCCnlB7YrIqYkHGIER75/OnY1N7d6mr0GzAhmca81X0dsZwhXWh2srTUR3Y2c5/E/o7Jowdh8uhBra5Gv0Ga/cgZMkUlQzOQ+pjwzNiZoV6wvpNG78M0pw/I0P+Qeo08Ulj6TqCPHVLCmw4e3WfPc0iUbztD8xAJy9bWQ4eMG8/QTKRfkLfgmc9+5aw+fd68a89BuZpCadPPkWZRyeqWzmClDP0NqRfkewOGDeid/UAz+EijsTPNqwUb7v7UKVi+qaPV1cggod8I8mwlmqFWpLnPRB41/QtHjh+KI8cPbXU1MkhIvbEzQ4ZGkUqtN5hkMmolQzOQekGedfMM9SO9Wm+aPWoy9D+kXpAzpHiVnCGl+P/t3W2sHFUdx/Hvr8VaaW2lqaG19MGQChQFtLU+BJJWeIFKUlAUqwkQH5DEgCXyAtHIC4MhkRo1kGgRhJgKISlYBINCU4MkBnuL2lYqD0orCnKjjdImttD274s5997ltvepO7NzZvf3SZrunp098z/ZPf979syZmbynVuqOwLpJ9oncIxZrV47foYE/Moe97tRKkH0iH5Dz6MryNPSVyS9ZKuNpH2ue7FetzJ4+haULT+Ca80a/9rTZcDmf/j6pocsPrVo//cL7+N+rhyb8vuwT+XGTJ5V252rrTVkmy6zvXmR1+eDJs4/pfY2ZWjGbqIHxeI6pMufYrHmcyK1rZTyzMnStFY/IrQRO5Nb1crzC4OCqlfxCswZyIreulfOIfGhqxZnc2udEbl0vx1TpmRUrkxO5da2cT4PX4KqVmgOxruBEbl3rtLkzALjkvfNrjuRIgyPyLH8vWNNkv47c7FjNmTmVXTd9tO4wjmrwFobO41YCj8jNanDO4uLEj3NPO7HmSKwbtDUil/RNYBVwGOgHLo+IF8sIzKybvXPezGx/LVjztDsi/3ZEnBERZwEPAt8oISYzM5uAthJ5RLzS8nQanvEzM+u4tg92SroRuBT4L7BylO2uAK4AWLBgQbu7NTOzRGOdvizpUWDOUV76WkRsbNnuq8DUiLhhrJ0uW7Ys+vr6JhqrmVlPk7Q1IpYNLx9zRB4R541zH+uBXwBjJnIzMytPW3Pkkha3PF0F/Lm9cMzMbKLanSO/SdIpFMsPdwNXth+SmZlNRFuJPCI+XlYgZmZ2bMY82FnJTqW9wNMlVzuTYuVMbnUBzAb+VWJ9ZcdXRZ1ltxnc7lzrg7zb3YT2jjfGUyLizUeURkTH/wF9FdS5Lse6qmhv2fE1oc1ud7715d7uJrR3vDGOtN9uutbKzzOtqwpVxJd7m8HtzrW+qpQVZxPa21aMdU2t9MVR1kJ2q15rL/Rmm8HtrjuOTqmrvSPtt64R+bqa9luXXmsv9Gabwe3uFXW196j7rWVEbmZm5emmOXIzs57kRG5m1nCVJnJJ+6qsPzeSLpQUkk6tO5ZOG+uzlvRrSV1xMEzSSZI2SnpW0l8kfU/SlFG2XyPp+E7GWBX36Tx5RF6u1cDj6f9xkzS5mnCsbJIE3Af8LCIWA+8ApgM3jvK2NUBXJPIe1Ig+XXkilzRd0iZJT0raLmlVKl8kaaek2yT9SdKvJL2p6niqImk6cDbwOeBTqWyFpMckPSTpaUk/kDQpvbZP0lpJfwQ+UF/k5UntfbDl+S2SLq8xpCp8CNgfET8GiIhDwDXAZyVNk3SzpB2Stkm6StLVwNuAzZI21xh3adyn8+vTnRiR7wcuioj3UNx4Ym0a1QAsBm6NiNOB/wBNvnbLKuDhiHgG+Lekpal8OXAVsAQ4GfhYKp8GPBERZ0bE4x2P1o7V6cDW1oIo7pT1N+DzwCLgrIg4A1gfEd8HXgRWRsSIN15pGPfpzPp0JxK5gG9J2gY8CswDBm4d/nxE/CE93krRCZpqNXBPenwPQz/FfhcRf00jt7sp/sIDHAI2dDZEq9gK4IcRcRAgIvbUG05l3Kcz69Nt3+ptHD4DvBVYGhGvSdoFTE2vHWjZ7hDQyJ9hkmZR/OR+l6QAJlPcv/QhjryP6cDz/emL0E0O8vrBwdSRNmywp4CLWwskzQAWALvqCKgG7tOvV3uf7sSIfCbQnz7wlcDCDuyz0y4GfhIRCyNiUUTMB54HzgGWS3p7mke7hOLASbfaDSyR9EZJbwHOrTugCmwCjpd0KQwe1FoL3An8EviipOPSa7PSe/YCR16xrrncpzPr05Ul8vRlPkBxC7hlkrZT3KS5G+8itBq4f1jZhlS+BbgF2EnxRRi+XeMNfNYR8QJwL7Aj/f/7WgOrQBSnQl8EfELSs8AzFHPG1wM/opgr35YOeH06vW0d8HDTD3a6T+fbpys7RV/SmcBtEbG8kh00gKQVwLURcUHdsVTJn3Vv8Oecb5+uZEQu6UqKgwBfr6J+y4c/697gzzlvvmiWmVnDlTIilzRf0mZJT6UTAb6cymdJeiSdyvyIpBNS+amSfivpgKRrh9V1flpo/5yk68qIz8wmpuQ+fYekfkk76mhLLyhrauUg8JWIWAK8H/iSpCXAdcCmdCrzpvQcYA9wNXBzayVpBcCtwIcpFtuvTvWYWWeV0qeTO4HzK4+4h5WSyCPipYh4Mj3eS3E0dx7FmVF3pc3uAi5M2/RHxBbgtWFVLQeeS4vtX6VYhL+qjBjNbPxK7NNExGMUid4qUvrBTkmLgHcDTwAnRsRL6aV/MnT210jmAS+0PP97KjOzmrTZp60DSk3k6SIzG4A16foTg9L6Wx9ZNWsQ9+lmKC2RS3oDxQe+PiLuS8UvS5qbXp8L9I9RzT+A+S3PT0plZtZhJfVp64CyVq0IuB3YGRHfaXnpAeCy9PgyYOMYVW0BFqfTX6dQXDrygTJiNLPxK7FPWweUso5c0tnAb4DtwOFUfD3FnNq9FBcU2g18MiL2SJoD9AEz0vb7gCUR8YqkjwDfpbhIzR0RMdoF+82sAiX36bsprgw5G3gZuCEibu9gc7qeTwgyM2s43+rNzKzhnMjNzBrOidzMrOGcyM3MGs6J3Mys4ZzIzcwazonczKzhnMjNzBru/6fg+RJSfoh+AAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "df_white = pd.DataFrame(np.random.standard_normal(500))\n", - "time_series_preparation = TimeSeriesPreparation(start='01-01-2010', freq='1D')\n", - "df_white = time_series_preparation.transform(df_white)\n", - "\n", - "df_white.plot();" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-03T17:03:15.276685Z", - "start_time": "2020-05-03T17:03:14.901752Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "arm_np = np.zeros(501)\n", - "mean = 0.0\n", - "ar = -.4\n", - "ma = -.7\n", - "eps = np.random.standard_normal()\n", - "for i in range(1, 501):\n", - " arm_np[i] = mean + ar * arm_np[i-1] + ma * eps\n", - " eps = np.random.standard_normal()\n", - "arima_np = arm_np.cumsum()\n", - "df_arima = pd.DataFrame(arima_np)\n", - "time_series_preparation = TimeSeriesPreparation(start='01-01-2010', freq='1D')\n", - "df_arima = time_series_preparation.transform(df_arima)\n", - "df_arima.plot()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Test functions" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-03T17:03:15.289256Z", - "start_time": "2020-05-03T17:03:15.280662Z" - } - }, - "outputs": [], - "source": [ - "def train_test_plot(df_train, df_test, df_pred, train_error, test_error):\n", - " fig, ax = plt.subplots(1, 3, figsize=(15, 5))\n", - " df_train.plot(ax=ax[0])\n", - " df_test.plot(ax=ax[0])\n", - " df_pred.plot(ax=ax[0])\n", - " ax[1].hist(train_error)\n", - " ax[2].hist(test_error)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-03T17:03:15.594315Z", - "start_time": "2020-05-03T17:03:15.291363Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Basic AR results results:\n", - "Fitted parameters: mu=-0.02, p=[-0.03 0.02 0.03 -0.05]\n", - "RMSE: 1.10\n", - "\n" - ] - }, - { - "data": { - "text/plain": [ - "array([-0.03, 0.02, 0.03, -0.05])" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "def run_giotto_ar(df, test_size, p):\n", - " model = AR(horizon=test_size, p=p)\n", - " df_train = df\n", - " df_test = df.iloc[-test_size:]\n", - " model = model.fit(df_train)\n", - " pred_g = model.predict()\n", - " y_pred = pd.DataFrame(pred_g.values[0], index=df_test.index, columns=['time_series'])\n", - " print('Basic AR results results:')\n", - " print(f'Fitted parameters: mu={model.model.estimators_[0].intercept_:.2f}, p={model.model.estimators_[0].coef_}')\n", - " print(f'RMSE: {mean_squared_error(y_pred, df_test.values):.2f}\\n')\n", - " return model.model.estimators_[0].coef_\n", - "\n", - "mar = run_giotto_ar(df_white, 100, 4)\n", - "mar" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-03T17:03:16.458785Z", - "start_time": "2020-05-03T17:03:15.600586Z" - }, - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Giotto results css:\n", - "Fitted parameters: mu=-0.00, p=[-0.94], q=[-0.06 -1. 0.03 0.03]\n", - "AR roots abs:[1.06]\n", - "MA roots abs:[5.75 4.85 1.04 1. ]\n", - "Train error mean: -0.45, std: 20.82\n", - "LL: 5150.12\n", - "RMSE: 46634.73\n", - "\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "def run_giotto_arima(df, test_size, order, method='css-mle', plot=True):\n", - " model = ARIMA(horizon=test_size, order=order, method=method)\n", - " df_train = df\n", - " df_test = df.iloc[-test_size:]\n", - " model.fit(df_train)\n", - " pred_g = model.predict(df_test.iloc[[0]])\n", - " y_pred = pd.DataFrame(pred_g.values[0], index=df_test.index, columns=['time_series'])\n", - " phi = model.model.phi_\n", - " theta = model.model.theta_\n", - " mu = model.model.mu_\n", - " train_errors = model.model.errors_\n", - " print(f'Giotto results {method}:')\n", - " print(f'Fitted parameters: mu={mu:.2f}, p={phi}, q={theta}')\n", - " print(f'AR roots abs:{np.abs(np.roots(np.r_[-phi[::-1], 1.0]))}')\n", - " print(f'MA roots abs:{np.abs(np.roots(np.r_[theta[::-1], 1.0]))}')\n", - " print(f'Train error mean: {train_errors.mean():.2f}, std: {train_errors.std():.2f}')\n", - " print(f'LL: {model.model.model.ml:.2f}')\n", - " print(f'RMSE: {mean_squared_error(y_pred, df_test.values):.2f}\\n')\n", - " if plot:\n", - " test_errors = df_test - y_pred\n", - " train_test_plot(df_train, df_test, y_pred, train_errors, test_errors.values)\n", - " return mu, phi, theta\n", - " \n", - "mu, phi, theta = run_giotto_arima(df_real, 100, (1, 2, 4), 'css')" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-03T17:03:17.238109Z", - "start_time": "2020-05-03T17:03:16.462550Z" - }, - "scrolled": false - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Statsmodels results css:\n", - "Fitted parameters: mu=-0.00, p=[-0.94], q=[-0.06 -1. 0.03 0.03]\n", - "AR roots abs:[1.06]\n", - "MA roots abs:[1. 1.04 4.86 5.76]\n", - "Train error mean: -0.45, std: 20.82\n", - "LL: 5150.12\n", - "RMSE: 49918.90\n", - "\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "def run_sm(df, test_size, order, method='css-mle', plot=True):\n", - " df_train = df.iloc[:-test_size]\n", - " df_test = df.iloc[-test_size:]\n", - " m2 = ARIMA_sm(df_train, order)\n", - " f = m2.fit(method=method)\n", - " y2, _, _ = f.forecast(test_size)\n", - " y_pred = pd.DataFrame(y2, index=df_test.index, columns=['Forecast'])\n", - " print(f'Statsmodels results {method}:')\n", - " print(f'Fitted parameters: mu={f.params.const:.2f}, p={f.arparams}, q={f.maparams}')\n", - " print(f'AR roots abs:{np.abs(f.arroots)}')\n", - " print(f'MA roots abs:{np.abs(f.maroots)}')\n", - " train_errors = m2.geterrors(f.params)\n", - " print(f'Train error mean: {train_errors.mean():.2f}, std: {train_errors.std():.2f}')\n", - " print(f'LL: {-f.llf:.2f}')\n", - " print(f'RMSE: {mean_squared_error(y2, df_test.values):.2f}\\n')\n", - "# print(normaltest(train_errors))\n", - " if plot:\n", - " test_errors = df_test.values.flatten() - y2\n", - " train_test_plot(df_train, df_test, y_pred, train_errors, test_errors)\n", - " return f, m2\n", - "\n", - "f = run_sm(df_real, 100, (1, 2, 4), 'css')" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-03T17:03:17.251700Z", - "start_time": "2020-05-03T17:03:17.245323Z" - } - }, - "outputs": [], - "source": [ - "def run_tests(df, order):\n", - " run_sm(df, 100, order, 'css', plot=True);\n", - "# run_sm(df, 100, order, 'mle', plot=False);\n", - " run_giotto_arima(df, 100, order, 'css', plot=True);\n", - "# run_giotto_arima(df, 100, order, 'mle', plot=False);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Simple AR check" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-03T17:03:19.034570Z", - "start_time": "2020-05-03T17:03:17.257051Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Basic AR results results:\n", - "Fitted parameters: mu=-0.02, p=[-0.03 0.01]\n", - "RMSE: 1.11\n", - "\n", - "Statsmodels results css:\n", - "Fitted parameters: mu=-0.02, p=[-0.03 0.01], q=[]\n", - "AR roots abs:[7.1 9.4]\n", - "MA roots abs:[]\n", - "Train error mean: -0.00, std: 1.00\n", - "LL: 565.86\n", - "RMSE: 1.10\n", - "\n", - "Giotto results css:\n", - "Fitted parameters: mu=-0.02, p=[-0.03 0.02], q=[]\n", - "AR roots abs:[9.38 7.09]\n", - "MA roots abs:[]\n", - "Train error mean: 0.00, std: 1.00\n", - "LL: 565.86\n", - "RMSE: 1.10\n", - "\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "df = df_white\n", - "order = (2, 0, 0)\n", - "run_giotto_ar(df, 100, 2)\n", - "run_tests(df, order)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-03T17:03:20.961649Z", - "start_time": "2020-05-03T17:03:19.038239Z" - }, - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Basic AR results results:\n", - "Fitted parameters: mu=3.58, p=[0.98 0.02]\n", - "RMSE: 44772.60\n", - "\n", - "Statsmodels results css:\n", - "Fitted parameters: mu=3261.40, p=[0.98 0.02], q=[]\n", - "AR roots abs:[ 1. 49.74]\n", - "MA roots abs:[]\n", - "Train error mean: -0.02, std: 20.81\n", - "LL: 5153.70\n", - "RMSE: 52639.91\n", - "\n", - "Giotto results css:\n", - "Fitted parameters: mu=2442.07, p=[0.98 0.02], q=[]\n", - "AR roots abs:[53.89 1. ]\n", - "MA roots abs:[]\n", - "Train error mean: 0.80, std: 20.81\n", - "LL: 5154.55\n", - "RMSE: 63820.28\n", - "\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3gAAAE9CAYAAABZZMC4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeXyU1dn/8c81k41A2COyNii4sIMRF6StUMFWBWvdnlaLrS1WbR+3UrHuVn8PalvbWpfaSl1qq2KttYoFW0FcQUBWQcIqmxICBJKQbXJ+f8ydySSZbGQmk0m+79crr7nn3Oe+55qoY64551zHnHOIiIiIiIhI4vPFOwARERERERGJDiV4IiIiIiIibYQSPBERERERkTZCCZ6IiIiIiEgboQRPRERERESkjVCCJyIiIiIi0kYkxTuA+vTs2dNlZWXFOwwRibJly5btdc5lxjuO5tDnk0jbo88mEWmNmvrZ1KoTvKysLJYuXRrvMEQkysxsW7xjaC59Pom0PfpsEpHWqKmfTZqiKSIiIhJHZpZmZkvMbKWZrTWzu732p8xsi5mt8H5GxTtWEWn9WvUInoiIiEg7UAJMcM4VmFky8K6ZveGdm+GceymOsYlIglGCJyIiIhJHzjkHFHhPk70fF7+IRCSRJVyCV1ZWxo4dOyguLo53KO1GWloa/fr1Izk5Od6hiIiItElm5geWAYOAR5xzi83sauA+M7sD+C8w0zlXEuHa6cB0gAEDBrRg1CLSGjWY4JlZGrAISPX6v+ScuzPs/O+A7zvnOnnPU4FngJOAPOAS59xW79wtwJVAAPhf59y8pga8Y8cOMjIyyMrKwsyaerk0kXOOvLw8duzYwcCBA+MdjoiISJvknAsAo8ysK/APMxsG3AJ8DqQATwA3A/dEuPYJ7zzZ2dka+RNp5xpTZKVyXvhIYBRwtpmdCmBm2UC3Gv2vBPY75wYBDwH3e32HAJcCQ4GzgUe9b6uapLi4mB49eii5ayFmRo8ePTRiKiIi0gKccweABcDZzrndLqgE+DMwNr7RiUgiaDDB8z5Yas0L95KzB4Gf1bhkKvC0d/wSMNGC2dhU4HnnXIlzbguwkSP8oFJy17L0+xYREYkdM8v0Ru4wsw7AWcB6M+vttRlwPrAmflGKSKJo1Bq8OuaFXwe86pzbXSMB6AtsB3DOlZtZPtDDa/8wrN8Or01ERESkPesNPO39veUDXnTOvWZmb5lZJmDACuBH8QxSRBJDo/bBc84FnHOjgH7AWDP7MnAR8HC0AzKz6Wa21MyW5ubmRvv2UXHgwAEeffRRAHbt2sWFF14Y54jqdvrpp8c7BBEREamHc26Vc260c26Ec26Yc+4er32Cc26413ZZ2IwqEZE6NWmj87B54WcSHM3baGZbgXQz2+h12wn0BzCzJKALwWIroXZPP6+t5ms84ZzLds5lZ2ZmNu3dtJDwBK9Pnz689FLr256mvLwcgPfffz/OkUi7l7cJ9m2OdxQiIiIi7UKDCV4d88KXOeeOds5lOeeygCKvqArAq8A07/hC4C1vf5dXgUvNLNXMBgKDgSXRfTstY+bMmWzatIlRo0Zx0UUXMWzYMACeeuopzj//fM466yyysrL4/e9/z69//WtGjx7Nqaeeyr59+wDYtGkTZ599NieddBLjx49n/fr1db7WnDlzGDZsGCNHjuTLX/4yAIFAgBkzZnDyySczYsQI/vCHPwCwcOFCxo8fz5QpUxgyZAgAnTp1Ct3rwQcfDF1z553BQqiFhYWcc845jBw5kmHDhvHCCy9E/xcm7Vfup/DwGPjd6HhHIiIiItIuNGYNXsR54fX0fxJ41hvR20ewcibOubVm9iLwCVAOXOuVBD5id/9rLZ/sOticW9QypE9n7jxvaL19Zs2axZo1a1ixYgVbt27l3HPPDZ1bs2YNH3/8McXFxQwaNIj777+fjz/+mBtuuIFnnnmG66+/nunTp/P4448zePBgFi9ezDXXXMNbb70V8bXuuece5s2bR9++fTlw4AAATz75JF26dOGjjz6ipKSEcePGMWnSJACWL1/OmjVram1pMH/+fHJycliyZAnOOaZMmcKiRYvIzc2lT58+vP766wDk5+cf8e9OpJZHVPBNEl/WzNdjct+ts86JyX1FRFqrWH2egj5TwzWY4DnnVgH1fv1euQeed1xMcH1epH73Afc1McaEcuaZZ5KRkUFGRgZdunThvPPOA2D48OGsWrWKgoIC3n//fS66qOpXVFJSa8/SkHHjxnHFFVdw8cUXc8EFFwDBZG3VqlWhqaH5+fnk5OSQkpLC2LFjI+5XN3/+fObPn8/o0cF/lAUFBeTk5DB+/Hhuuukmbr75Zs4991zGjx8ftd+FiIiIiIi0rEZV0WytGhppi4fU1NTQsc/nCz33+XyUl5dTUVFB165dWbFiRaPu9/jjj7N48WJef/11TjrpJJYtW4ZzjocffpjJkydX67tw4UI6duwY8T7OOW655RauuuqqWueWL1/O3Llzue2225g4cSJ33HFHY9+uSP36jIZdH8c7ChEREZF2o0lFViQoIyODQ4cOHdG1nTt3ZuDAgcyZMwcIJl4rV66ss/+mTZs45ZRTuOeee8jMzGT79u1MnjyZxx57jLKyMgA2bNhAYWFhva87efJkZs+eTUFBsADXzp072bNnD7t27SI9PZ3LLruMGTNmsHz58iN6XyIRlRYFH9N7xDcOERERkXYioUfw4qVHjx6MGzeOYcOGceKJJzb5+ueee46rr76ae++9l7KyMi699FJGjhwZse+MGTPIycnBOcfEiRMZOXIkI0aMYOvWrYwZMwbnHJmZmbzyyiv1vuakSZNYt24dp512GhAsvvKXv/yFjRs3MmPGDHw+H8nJyTz22GNNfj8iETkHB71CuYGy+MYiIiIi0k5YsMBl65Sdne2WLl1arW3dunVHlFRJ8+j3Lk321r2w6EHwJQV/bvsidMrMljnnsuMYXbNF+nyStklFVtoPfTaJxJaKrByZpn42aYqmiMTGogeDj537QKA0vrGIiIiItBNK8FqJ++67j1GjRlX7ue++Nl1wVNoi52DdaxAor2rrmAmuonqbiIiIiMSE1uC1Erfeeiu33nprvMMQaZ5t78EL36ne1mMQ7FwGFWXg10eOiIiISCxpBE9EoqekoOq4x6DgY+9RwUdN0xQRERGJOSV4IhI9JQerjisC0Dcb/MnB56qkKSIiIhJzmi8lItFTXlx1XFoAGb3DEjyN4ElsxbI6m4iISKLQCJ6IRE95SdVxSUEwufOnBJ8rwRMRERGJOSV4R+DAgQM8+uijAOzatYsLL7wwzhHV7fTTT493CNKehCd45YdrJHiaoikiIiISa0rwjkB4gtenTx9eeumlOEdUW3l5sCT9+++/H+dIpF15+4Hqz33JWoMnIiIi0oISew3eGzPh89XRvefRw+Hrs+rtMnPmTDZt2sSoUaMYPHgw69atY82aNTz11FO88sorFBYWkpOTw09/+lNKS0t59tlnSU1NZe7cuXTv3p1NmzZx7bXXkpubS3p6On/84x854YQTIr7WnDlzuPvuu/H7/XTp0oVFixYRCASYOXMmCxcupKSkhGuvvZarrrqKhQsXcvvtt9OtWzfWr1/Phg0b6NSpEwUFwcqGDz74IC+++CIlJSV885vf5O6776awsJCLL76YHTt2EAgEuP3227nkkkui+zuV9qMkv/pzVxFM8kBTNEVERERaQGIneHEya9Ys1qxZw4oVK9i6dSvnnntu6NyaNWv4+OOPKS4uZtCgQdx///18/PHH3HDDDTzzzDNcf/31TJ8+nccff5zBgwezePFirrnmGt56662Ir3XPPfcwb948+vbty4EDBwB48skn6dKlCx999BElJSWMGzeOSZMmAbB8+XLWrFnDwIEDq91n/vz55OTksGTJEpxzTJkyhUWLFpGbm0ufPn14/fVgcYL8/Bp/oIs0VtG+4KM/pSqZcxWaoikiIiLSghI7wWtgpC0ezjzzTDIyMsjIyKBLly6cd955AAwfPpxVq1ZRUFDA+++/z0UXXRS6pqSkpK7bMW7cOK644gouvvhiLrjgAiCYrK1atSo0NTQ/P5+cnBxSUlIYO3ZsreSu8pr58+czevRoAAoKCsjJyWH8+PHcdNNN3HzzzZx77rmMHz8+ar8LaWcW3Bd8dK6qzUxVNEVERERaUGIneK1Qampq6Njn84We+3w+ysvLqaiooGvXrqxYsaJR93v88cdZvHgxr7/+OieddBLLli3DOcfDDz/M5MmTq/VduHAhHTt2jHgf5xy33HILV111Va1zy5cvZ+7cudx2221MnDiRO+64o7FvV6RKivfv3tBvwuoXvUZTFU0RERGRFqQiK0cgIyODQ4cOHdG1nTt3ZuDAgcyZMwcIJl4rV66ss/+mTZs45ZRTuOeee8jMzGT79u1MnjyZxx57jLKy4JS3DRs2UFhYWO/rTp48mdmzZ4fW4+3cuZM9e/awa9cu0tPTueyyy5gxYwbLly8/ovcl7dzuVfDeb4PHE8O+IDDTFE0RERGRFqQRvCPQo0cPxo0bx7BhwzjxxBObfP1zzz3H1Vdfzb333ktZWRmXXnopI0eOjNh3xowZ5OTk4Jxj4sSJjBw5khEjRrB161bGjBmDc47MzExeeeWVel9z0qRJrFu3jtNOOw2ATp068Ze//IWNGzcyY8YMfD4fycnJPPbYY01+PyJ8OrfqOKXGKLLf+5jRCJ6IiIhIzJkLXy/TymRnZ7ulS5dWa1u3bt0RJVXSPPq9S73+/sOqaZm35cK9mcHjIVPhq7fAo6fCRU8Fp28CZrbMOZcdn2CjI9Lnk8RX1szX4x1Ck2yddU68Q5Aa9NkkElux/Jxuy5+pTf1s0hRNEWmevE1ha+6ApBTo5hX66dRLUzRFREREWpASvFbivvvuY9SoUdV+7rvvvniHJdKwfVuqjpPSgo9DpgQfOx2lKpoiIiIiLUhr8FqJW2+9lVtvvTXeYYg03Yq/VB3f9kXw0VUEH7t+qWoEr7zu7UBEREREJDoaHMEzszQzW2JmK81srZnd7bU/Z2afmtkaM5ttZsleu5nZ78xso5mtMrMxYfeaZmY53s+02L0tEWkRzsEnr9Zu//LP4Gt3wbBvgfm9vhUtGZmIiIhIu9SYKZolwATn3EhgFHC2mZ0KPAecAAwHOgA/8Pp/HRjs/UwHHgMws+7AncApwFjgTjPrFr23IiItrqwIXADG/xRu2lDVntYZzrgBfH4w72NGCZ6IiIhIzDWY4LmgAu9psvfjnHNzvXMOWAL08/pMBZ7xTn0IdDWz3sBk4E3n3D7n3H7gTeDsaL8hEWlBJd5+kJ37QEavyH3Mgo9K8ERE6lTPjKmBZrbYmxn1gpmlxDtWEWndGlVkxcz8ZrYC2EMwSVscdi4ZuBz4t9fUF9gedvkOr62u9oTj9/urFUPZunVrvEMCYOvWrfz1r3+NdxjSnlQmeKmd6+7j0xRNEZFGqGvG1P3AQ865QcB+4Mo4xigiCaBRCZ5zLuCcG0VwlG6smQ0LO/0osMg59040AjKz6Wa21MyW5ubmRuOWUdehQwdWrFgR+snKymrUdeXl5TGNSwmetLidy4KPKel199EUTRGRBtU1YwqYALzktT8NnB+H8EQkgTRpmwTn3AFgAd7USjO7E8gEbgzrthPoH/a8n9dWV3vN13jCOZftnMvOzMxsSnhxVVxczPe+9z2GDx/O6NGjWbBgAQBPPfUUU6ZMYcKECUycOBGABx98kJNPPpkRI0Zw5513hu7xzDPPMGLECEaOHMnll18OwL/+9S9OOeUURo8ezde+9jW++CJYpfDtt98OjSCOHj2aQ4cOMXPmTN555x1GjRrFQw891MK/AWmXPn0j+Jh5Qt19KhO8ikDs4xERSWA1Z0wBm4ADzrnKb4gjzn5KhC/HRaTlNLhNgpllAmXOuQNm1gE4C7jfzH5AcF3dROeqfTX/KvBjM3ueYEGVfOfcbjObB/y/sMIqk4BbmhP8/UvuZ/2+9c25RS0ndD+Bm8feXG+fw4cPM2rUKAAGDhzIP/7xDx555BHMjNWrV7N+/XomTZrEhg3BohPLly9n1apVdO/enfnz55OTk8OSJUtwzjFlyhQWLVpEjx49uPfee3n//ffp2bMn+/btA+CMM87gww8/xMz405/+xAMPPMCvfvUrfvnLX/LII48wbtw4CgoKSEtLY9asWfzyl7/ktddei+rvRKROLgA9j4Mex9bdRyN4IiKN4pwLAKPMrCvwD4LF7Bpz3RPAEwDZ2dkudhGKSCJozD54vYGnzcxPcMTvRefca2ZWDmwDPrBgEYWXnXP3AHOBbwAbgSLgewDOuX1m9gvgI+++9zjn9kX13bSQyima4d59911+8pOfAHDCCSfwpS99KZTgnXXWWXTv3h2A+fPnM3/+fEaPHg1AQUEBOTk5rFy5kosuuoiePXsChPrv2LGDSy65hN27d1NaWsrAgQMBGDduHDfeeCPf+c53uOCCC+jXrx8iLS5/J3Rp4N89bZMgItIk3pfqC4DTCBarS/JG8SLOfhIRCddgguecWwWMjtAe8Vqvqua1dZybDcxuYox1amikrbXo2LFj6Ng5xy233MJVV11Vrc/DDz8c8dqf/OQn3HjjjUyZMoWFCxdy1113ATBz5kzOOecc5s6dy7hx45g3b17M4heJKFAGu5bD6Mvq7xcawdOXyiIidalrxhTBpTEXAs8D04B/xi9KEUkETVqDJ3UbP348zz33HAAbNmzgs88+4/jjj6/Vb/LkycyePZuCguA66p07d7Jnzx4mTJjAnDlzyMvLAwhN0czPz6dv3+B0+6effjp0n02bNjF8+HBuvvlmTj75ZNavX09GRgaHDh2K6fsUCTm8P/jYoXv9/UIJntbgiYjUozewwMxWEZzt9KZz7jXgZuBGM9sI9ACejGOMIpIAGjNFUxrhmmuu4eqrr2b48OEkJSXx1FNPkZqaWqvfpEmTWLduHaeddhoAnTp14i9/+QtDhw7l1ltv5Stf+Qp+v5/Ro0fz1FNPcdddd3HRRRfRrVs3JkyYwJYtWwD4zW9+w4IFC/D5fAwdOpSvf/3r+Hw+/H4/I0eO5IorruCGG25o0d+BtCOrX4JM7wuMnsfV39enNXgiIg2pZ8bUZmBsy0ckIolKCd4RqBx9C5eWlsaf//znWu1XXHEFV1xxRbW26667juuuu65W32nTpjFt2rRqbVOnTmXq1Km1+tY1pfOtt96qL3SR5tu/Df5+Jfi9LzCSOzR8jfnikuB5a4eXAjudc+ea2UCC05x6AMuAy51zpWaWCjwDnATkAZc457a2eMAiIiIizaQpmiLSNKWFwcdASfAxqfZIdS1xSvCA64B1Yc/r2jD4SmC/1/6Q109EREQk4SjBE5GmKdpb/XlyPZucVzJfi++DZ2b9gHOAP3nPjbo3DJ7qPcc7P9HrLyIiIpJQlOCJSNPk76j+vGNmw9eYH977DayfG5uYIvsN8DOgcuiwB3VvGNwX2A7gnc/3+ouIiIgklIRM8JzKrbco/b4lpCAXFj1Y9XzAadB7RMPX+ZODj8//T2ziqsHMzgX2OOeWRfm+081sqZktzc3NjeatRURERKIi4RK8tLQ08vLylHS0EOcceXl5pKWlxTsUaQ3+eQ3s21z1POuMxl3XoWts4qnbOGCKmW0lWFRlAvBbvA2DvT7hGwbvBPoDeOe7ECy2Uo1z7gnnXLZzLjszsxEjlyIiIiItLOGqaPbr148dO3agb89bTlpaGv369Yt3GNIahCd3AL7kxl2XkhH9WOrhnLsFuAXAzL4K/NQ59x0zm0PkDYNf9Z5/4J1/y+lbJBEREUlACZfgJScnM3DgwHiHIdI+1dwSIaVj465rPfVKbgaeN7N7gY+p2jD4SeBZbyPhfcClcYpPREREpFkSLsETkTiqOajV2MQtjgmec24hsNA7jrhhsHOuGLioRQMTERERiYGEW4MnInHywaPwxRoY8134ys3BtkaP4OmjRkRERKQlaARPRBpn3i3Bx/6nwLBvQVIajPpO467dvTJ2cYmIiIhIiBI8EWlYoLzqeNi3gmvxxt8Yv3hEREREJCLNmxKRhq17NfjYMbN2oRURERERaTWU4IlIw/ZuCD5+7434xiEiIiIi9VKCJyINy98OGb2h5+B4RyIiIiIi9VCCJyINKy8NFlURERERkVZNRVZEpGGfvgGlh+IdhYiIiIg0QCN4ItIwJXciIiIiCUEJnojUL/fTeEcgIiIiIo2kBE+knckvKqOgpLzhjpUqK2hOuC02AYmIiIhI1GgNnkg7M+beNwlUOLb83zcws4Yv2JsTfBx7VbNeN9/nY21KCp+s/lOz7iMiIiIidWswwTOzNGARkOr1f8k5d6eZDQSeB3oAy4DLnXOlZpYKPAOcBOQBlzjntnr3ugW4EggA/+ucmxf9tyQikew5WMzCT3MJVDgAdh44TL9u6Q1feGg3pHWBtM6Nfq29h/fySd4nrNm7hvX71rOhXx92JnsfN8t/eyThi4iIiEgjNGYErwSY4JwrMLNk4F0zewO4EXjIOfe8mT1OMHF7zHvc75wbZGaXAvcDl5jZEOBSYCjQB/iPmR3nnAvE4H2JSA1XPr2U1TvzQ8+/OFhSLcHLKyhh9ntbuPzULI7uUrUlQmnBPpI7dCPSWF+gIsDWg1vZsH8DGw9sZG3eWtblrWNf8b5Qn6zOWQwpLeXCQwUMKSllyPWf0u2KbjF5jyIiIiLtXYMJnnPOAQXe02TvxwETgG977U8DdxFM8KZ6xwAvAb+34DywqcDzzrkSYIuZbQTGAh9E442ISP0+/bx6JczisurfrTz/0XYeWbCJRxZsYsUdZ9E1PYW8ghI2rllDv65d6e0q2HloJ6v2ruKTvE/4dN+nrMlbQ2FZIQB+8zOwy0DG9x3P4G6DGdJjCEN7DCU9OR3u6lL1QmldY/5eRURERNqrRq3BMzM/wWmYg4BHgE3AAedcZaWGHUBf77gvsB3AOVduZvkEp3H2BT4Mu234NSISQ4s351EaqKjWVlJePcFLT/GHjnMPldA1PYWf/O1jOnfuyq6OJRx44avsL9kPQKo/lWO6HMM5A89hWM9hDOkxhKwuWaT6U2P/ZkRERESkTo1K8LxplKPMrCvwD+CEWAVkZtOB6QADBgyI1cuItCuXPPFhrbaSsuoJX1FpVcL38sc7ufnsE3h/Ux4dBqSSnhLg7H6nMKLnCEZkjuC4bsfh9/lr3rJhnXo1/RoRERERabQmVdF0zh0wswXAaUBXM0vyRvH6ATu9bjuB/sAOM0sCuhAstlLZXin8mvDXeAJ4AiA7O9s17e2ISE2VRVVqKimvnuCFb53w2MJN3Hx28Hucw9u/z4e3n0OX9OTYBSkiIiIiUdHgPnhmlumN3GFmHYCzgHXAAuBCr9s04J/e8avec7zzb3nr+F4FLjWzVK8C52BgSbTeiIhEdvBwWcT28CmaJeUB/rbkM7qFJXG7DhwGoGuH9Cgmd43YlkFEREREjlhjNjrvDSwws1XAR8CbzrnXgJuBG71iKT2AJ73+TwI9vPYbgZkAzrm1wIvAJ8C/gWtVQVMk9g7USPAq19qFj+BtyyviQFEZx/XKCLWdPustAL49NopTpRuz756IiIiIHLHGVNFcBYyO0L6ZYBXMmu3FwEV13Os+4L6mhykiR2p/USkAD3xrBBdl9+NgcTkj755fbQ1eZUXNH4w/hsVb9lW7ftu+ougF4yoa7iMi0s6YWX+Cewj3Ilip/Ann3G/N7C7gh0Cu1/Xnzrm58YlSRBJFk9bgiUjiyS8KjuAN7tUJMwsbwasaQC/2kr20ZB9js7qzZGtVknf5qV+KXjBK8EREIikHbnLOLTezDGCZmb3pnXvIOffLOMYmIgmmMVM0RSRBvfjRdm6asxKArukpACT5DJ9Vn6JZmeylJft57oenVLvH2Kzu0QuoQrOyRURqcs7tds4t944PEax1oK2kROSIKMETSXDb9xXxo2eXUVRaXuvcz/6+in2FwSmalQVUzIzUJH+1BC80gpfkJ9lf/WPB54vCurmr3gF/CmjZrYhIvcwsi+DSmMVe04/NbJWZzTazbnVcM93MlprZ0tzc3EhdRKQdUYInksCcc4x/YAH/Xvs5N7ywotb5ozKqNh7PSKuqhJma7GPd7oOhkbvKNXhpyTH6SOg9Ak7+AVRoiqaISF3MrBPwd+B659xB4DHgWGAUsBv4VaTrnHNPOOeynXPZmZmZLRaviLROSvBEosQ5F3EULZaWf3YgdDxv7Re1zndMrVpm6w8biSstr+CdnL3c8vJqIDzBO4LNyxvLfBrBExGpg5klE0zunnPOvQzgnPvCORdwzlUAfyRCcTsRkZqU4IlEyZylOxhyxzw+3JzH7vzDLfKa//PHD+s9X+Eib3Jemeq9vHwnxWUB/rVqNxAc2YsZn19r8EREIjAzI7jN1Drn3K/D2nuHdfsmsKalYxORxKMqmiJRMm/t5wBc+kQw6do665yYv+YJR2ewakd+nefrSvCSk3xQGky2Trj936H22I7g+VVFU0QksnHA5cBqM6ucb/9z4H/MbBTBrRO2AlfFJzwRSSRK8ESaIb+ojMVb8pg09GiO7pLW4q+f/aXu9SZ45YHICV5SHYVT0pI0RVNEpKU5596lanJFOO15JyJNpimaIs1w/QsfM/3ZZew6cJhDxVXr7yr3moul9zft5c/vbwlVxxx8VKdafSrX1n1rTL9q7T6LnOAl+6NQMbMuPm8Er45RRRERERFpPiV4Is2wLa8IgBeXbufVlbtC7TGd6uj59h8X4xx075jCuSN6E4iQOB0uCzD9y8fwq4tHVmuvawTP6kj8osK834mmaYqIiIjEjKZoijRDRofg6Nlv/pMTajtvZB/e/OTzmL7u2l1V0zJ/cf4w5izdUWs6ZkWFo7isgg4Rkk1/hJG62VdkRz/QcD7v+yQVWhEREZEoy5r5ekzu2xI1FaJNI3gizZASIVE6pmdHissqqKiI3VTEc373LgBXfeUYTj+2J36fEajxevfPWw9AhwjTRZN8tf/T798tPQaRhgmN4CnBExEREYkVJXgizbDrQHG15zWF60oAACAASURBVJedOoCOqcFEZum2/TF//c7e5uXJfmPngcM4b5pmaXkFf3h7MwBD+3SudV2kmZjJ/qqPg2N6dgRgya0Toxesz0vwiusuCiMiIiIizaMET+QIBSocnx8splfnVAD6devAvecP55wRfQCYu3p3TF63pLxqBGxY3y4A5HxRAMCFj38AwIYvDoX6jB+cWeseew6W1GpLT60a6Zt73XhW3jmJozKiWBm0cG/w8aXvR++eIiIiIlKNEjxpMxZ+uodR98ynsKS84c5RkFdQQqDCMaR3cIQsMyOY6PXt2oGjMlJDFSyjbef+4CbqndOSOP3YHgAUeO952bb9rN6Rz/rPgwneY98ZE/EekfbHS0+pWpKbluyni7e+MGrKvaTyi7XRva+IiIiIhCjBkzbj4bc2cqCojDU7W2YK4HYv0frakF58c3RfHg1LpiKtiYuWt9bvAeDP3zs5NK3yZ2cfHzr/2qpdHCgqBeD0QT0j3iPSNgnpsa78ad7HjapoioiIiMSMqmhKm3F05+B0ws8PFjfQs3m27yvi6fe38vaGXAAqHDx0yahqfXxmEbctiIb8w2UAjOzXNdQ2qn+30PEfFm1mxuRgwpeWHPk7nEhr8Hx1bJ0QNZVr8FRFU0RERCRmlOBJm9GrMsHLj22C9/xHn/Gnd7eEno/s16VWH7/PYlJFs7IEcPeOKSSFFUWpmcgdLg3gM0jxR07w6troPKZCI3hK8ERERERiRQmetBnp3nYAsVqDVx6o4P/eWM/SrftCbf87cTAjwkbSKvl9RiB2uyTQLb36+ri0pOrTK4vLAqQl++vcuLxmc89OKVGNLyKfNjoXERGRxJKI++tpDZ60Ga+t2gVASSA2CcSSLft48t0trNxRtcavclpoTT4jpvvgde9YPSGrOb2yuDyY4NXlhq8dFzo2g5d+dHp0A4zENEVTREREJNY0gidtxta8IiC4B1wspEZImMK3LAgXiyIreQVVWxt0Ta9/xK2oNEBaUt3f30w7PYuLs/vzy/mfcsNZx9EptQU+Cnza6FxEREQk1pTgSZsQnkzFaoqmi1A0pUMdo2Q+s4hbETTHw29tDB1XbnBel4OHy+odwQPokOLn9nOHRCW2RjFNGBARERGJNf3FJW3C3rDRrReX7ojJaxSX1R4Z9NdReTIWCd7aXVVTQzum1p+8/WfdHlLqGcGLC4vxNgwiIiIi0nCCZ2b9zWyBmX1iZmvN7DqvfZSZfWhmK8xsqZmN9drNzH5nZhvNbJWZjQm71zQzy/F+psXubUl7s/PA4Zjev6Q8wGVPLq7VfqK3yXlNNadozlm6nc+8KaRHqqi0amrjgk/3NNi/9SV4cajcKSIiItLONGaKZjlwk3NuuZllAMvM7E3gAeBu59wbZvYN7/lXga8Dg72fU4DHgFPMrDtwJ5ANOO8+rzrn9kf7TUn7s8tL8E7O6sam3MKo3z/ni4Jqz5+cls2Ifl3JzEiN2N/nMxZ8msujCzdy9VeOZcZLq+iQ7GfdL84+otevqHCs3XUw9HzXgchbQfgsmFyWBRxJsd7Xrql8GsETERERibUGv+J3zu12zi33jg8B64C+BJO0yuGLLsAu73gq8IwL+hDoama9gcnAm865fV5S9yZwZH/titTwtyWfAcG98KJd3ATg9dW7qz0/eWD3OpM7AL+XWz3w709D8RwuO7LiIo8s2MiZv1pYre3soUfX6rfyzkmsvHMS/bunA5Bcxx54cdOCa/DMLM3MlpjZSm/mwd1e+0AzW+zNMHjBzFK89lTv+UbvfFaLBSsiIiISRU0qsuL90TMaWAxcD8wzs18STBQr66z3BbaHXbbDa6urveZrTAemAwwYMKAp4Uk79t7GPCC4fUAsErzHFm4C4PRjezBmQDcyGqg6Gb42L9CMtXh7C0p4cN6ntdojFUfp0iFYeKVXRhqbcwtbX4JHi44olgATnHMFZpYMvGtmbwA3Ag855543s8eBKwnOMrgS2O+cG2RmlwL3A5e0ZMAiIiIi0dDovwDNrBPwd+B659xB4GrgBudcf+AG4MloBOSce8I5l+2cy87MzIzGLaWNc85xbGZHANKS/bUSvP2FpRwoKm3SPbfvK6LAq8b5Tk5uqP2vPzyVn04+vs4NxCv5ws7XjOe/677ge39eErEqZ01/XLS52vNfXTSS535wCkd3ibz/HsCeQ8Hpm0n+VjZFswVH8LwZBJXzapO9HwdMAF7y2p8GzveOp3rP8c5PtIb+IYuIiIi0Qo36i8v7BvzvwHPOuZe95mlA5fEcYKx3vBPoH3Z5P6+trnaRZlm4ITe07s5n1YubHC4NcPnsxYy6502KGzlFsixQwfgHFjDsznkAbNnbvDV95TUSvCufXsqCT3NrtUfyhxoJXu+uaYwb1LPeayp/F60uO2nhfMnM/Ga2AthDcEr4JuCAc65yH43wWQShGQbe+XygR4sGLCIiIhIFjamiaQRH59Y5534ddmoX8BXveAKQ4x2/CnzXq6Z5KpDvnNsNzAMmmVk3M+sGTPLaRJplV1gFzSSfhaZEfrg5jxPv+DdrdgaLk2xrZBXLOWHbLBSWlHPwcFmTYwofnAsEIidyDW2jkPPFoVptDe1/BzC8b5cG+8RHyyZ4zrmAc24UwS+TxgInNPeeZjbdqxq8NDc3t+ELRERERFpYY9bgjQMuB1Z734YD/Bz4IfBbM0sCivHWzQFzgW8AG4Ei4HsAzrl9ZvYL4COv3z3OuX1ReRfSrvm9kaHvjcsKbU/gnOPtDdX/AC9o5AboP//H6tDxvLWfU1ASHPm7YEytJaN1Cl93V9dIXUMzNF9duatWW+U6u/qcP7ovq3fmE/2ViM0UpxmPzrkDZrYAOI1g0ackb5QufBZB5QyDHd5nWhcgL8K9ngCeAMjOzm51v2IRERGRxlTRfNc5Z865Ec65Ud7PXK/9JOfcSOfcKc65ZV5/55y71jl3rHNuuHNuadi9ZjvnBnk/f47lG5P2o9DbH+76rx0XKm4SqHAUFFdP6AobmeCFu/HFlRwqDo7g3f+tEY2+btm2qt0/SgO1N0ivjLE+h0sDdEj2s/n/fSPU1pgRvBRv7V2U91mPgpZL8Mws08y6escdgLMIVgBeAFzodZsG/NM7ftV7jnf+LdeYRZIiIiIirUyTqmiKtEaHS4OJW3qKP5TglVe4WgldYxO8E47OoH/3dN785AsA9hwq4YSjM464KuX63Qcjtjc0RbM0UEFqsg9fWEXOTmkN/yfb+qpnelqwyArQG3jazPwEv8h60Tn3mpl9AjxvZvcCH1NVHOpJ4Fkz2wjsAy5tyWBFREREokUJniS8f60M7lGX7PeR4iU35RWOQzUSur8u+YyvD+/d4P0OlwVIT6nalLuwpJyMRiRWdQnfoLwibNSuoRorz3ywrVabvxGbl1cmeK1u+KkFp2g651YR3NKlZvtmqgpChbcXAxe1QGgiIiIiMdVKv+oXaZyyQAWfhhUjSfamJ5aVV9QasXsnZ2+D93POcaCojI5h+9wdLguQluyv56r67c4vDh0XllbFVBGD/foABnpbRqzZmR+T+x+x5PR4RyAiIiLS5inBk4S23Fvrdt3EwQAkeaNXZYGKWmvcenZKafB+m3ILyT9cxoi+XZgx+XgADhSVNSvB+9uSz0LHr6/aHTqub4rm4s3V63sMPqpTo19vVL+unNi7M3eeV3sz9Lga4e0bPua78Y1DREREpA3TFE1JaPneFgZnDekFEJqi+d6mvSzeUr1Ia6fUuv91/yyviAsff589h0oAyM7qzuItwSRrd/7hqG09MPPlqgqdgXoSvEue+BCAi7P7ATD3uvENrtmr5PMZb1w3vhlRxog/CdK6QFKHeEciIiIi0mZpBE8SWuXWB5XJW3JScIrmDS+srNU3v4797LblFfLlBxeEkjuAo7ukhbYkKC6riMnyscbkax28kcNkv4/UpCMfRWw9Wt326yIicWdm/c1sgZl9YmZrzew6r727mb1pZjneY7d4xyoirZ8SPElooQTPK4JSVwXJJJ+xv6iMSJXvl2ypvR1jit9XLQFb/tn+Wn3qs+CnX2XOj06rNzGsa5uEw962DwBpKW0hqaup1ZV/ERGJt3LgJufcEOBU4FozGwLMBP7rnBsM/Nd7LiJSLyV4ktAOFdcYwasjwatMABd8uqfWuUgboCf7jZ6dUkPPw48bY2DPjpyc1T20CXuPjrXX/9U15fKzfUWh4w7NWPvXKpUWQGFuw/1ERNoR59xu59xy7/gQwX07+wJTgae9bk8D58cnQhFJJErwJKEVlJST7DdSk4L/KldW0azpB2cMBGDn/sMALNu2j4sef5+i0nJKymtvRG5mnHpM99Dz28458YjiK/dG6Yb3q72GryLy/udszSsMHde3bjAhVZTD2n/EOwoRkVbLzLIIbvOyGOjlnKuszvU50CtOYYlIAlGCJwmtsKScjqlJmDdSVtcI3nkj+wCQ6o2I/eylVXy0dT/b8oooLgtOiXx7xlerXWNh8ytP+lJ3miNSolZXkZV1YRujf2tMv2a9roiIJA4z6wT8HbjeOXcw/JwLrjGI+D8OM5tuZkvNbGlurmZJiLR3SvAkoR0qLqdjSlXyVFeCl+KN8FXuPVe5YXhJeQUl5RWk+H307xZ5n7bLTh3Q7Dj7Rbh3Ttj+feEOHi4nIzWJLf/3DbpFmNopIiJtj5klE0zunnPOvew1f2Fmvb3zvYHa6wwA59wTzrls51x2ZmZmywQsIq2WEjxJSLPeWM+02Uv4x8c7ObpLWqg9PMELH/2qXAtXOWXS5z0vKi2nuCxAapIPn6/29M6ts87h3vOHNzve1CQfsy6ofp9dBw5H7FsaCJCS5Ks2gigiIm2XBT/wnwTWOed+HXbqVWCadzwN+GdLxyYiiaeNLfCR9uLxtzeFjvccKg4dh6/BS0mqOq4csassbJLk9TtcGqCkvCI0dfOJy0+iRxMLqjRGSpIvNIpYKVBHMcnS8opafUVEpE0bB1wOrDazFV7bz4FZwItmdiWwDbg4TvGJSAJRgicJpyxQvTrJwJ6dQsfhI3jhx5UJXrmXVVWO6BWWBjhQVEqSd37S0KNjEnOK3xeKoVKgjiorpeUVdU41FRGRtsc59y51bxQ6sSVjEZHEpwRPEs7+wlIAxg3qwXsb87hgdN/QuWojeH4ff/3BKXRJT641gnfI2xrhf//2cYvEnJLkq5W01chT2b6viOnPLiMjNUkjeCIiIiJyRJTgScJ5a31wjfl5I/rwyLfH0DW9qhBJ+Lq15CQfpw/qCQTX2kFwDd5v/rOBzbmFhJtwwlExjTm5ESN4z364LVRB8+jOaYiIiIiINJUSPEk4M19eDcCO/YerJXdQVTwFID1sk/DK5GrWG+sj3vPyU78U7TCrCY7g1UzwqvfJCNtK4fODxYiIiIiINJXmgUlC2VtQEjquOSIG1RcwhG8x4G+gImVqjKdE+gz8vuqv8dB/NpB7qOr9dO6QHNMYRERERKTtU4InCWNvQQnZ9/4HgK7pyfzoK8fW6tMzo6oCZvfwBC9CMhguOUYJ3pVnDATgi4MlbPi89r53f3pnc+g4ya9tEURERESkeZTgScI4eLgsdHzL10+gQ4q/Vp9OYdMcu9WxNi+Syg3Qo+3UY3oA0KtzKkP7dq51PjypKy2PXFVTRERERKSxtAZPEkZJWALUOa3h6YzhI3iRjB7QlY8/OwBAUVmgecHV4awhvXjtJ2cwtE/niElmeBIa/v7m/u/4mMQjIiIiIm2bRvAkYSzbtj90PDCzY4P9G0rwZk87mR94UygH9mj4fkdqWN8uoeTu/m8N56nvncxNZx0HUG07hJKyYIL3h8tPYkif2qN9IiIiIiINaTDBM7P+ZrbAzD4xs7Vmdl3YuZ+Y2Xqv/YGw9lvMbKOZfWpmk8Paz/baNprZzOi/HWnLAt40yj99N5sTjm44AeqaXv8oX7eOKdx27hDW3XM2WT1jl+CFu+TkAXz1+KO4/LRg1c7KjdcBSsoDJPuNyTHabF1ERERE2r7GTNEsB25yzi03swxgmZm9CfQCpgIjnXMlZnYUgJkNAS4FhgJ9gP+Y2XHevR4BzgJ2AB+Z2avOuU+i+5akrarcpPykL3VrVP+aG4vXJdJavlhL8mILhK39Ky6rIDWp5WMRERERkbajwQTPObcb2O0dHzKzdUBf4IfALOdciXduj3fJVOB5r32LmW0ExnrnNjrnNgOY2fNeXyV40iiVa9TSkhM/CUryqnqWhW12XlhSTnockk0RERERaTuatAbPzLKA0cBi4DhgvJktNrO3zexkr1tfYHvYZTu8trraRRp0uDQQ2qQ8JQpbGpx6TPdm36M5KhO8gDdF0znHgcOl1aqAioiIiIg0VaP/mjSzTsDfgeudcwfNLAnoDpwKnAy8aGbHNDcgM5sOTAcYMGBAc28nCa48UMEVf/6IAT3SAeiWntzgnnaN8YfLspt9j+bw+wyfVY1KvpOzl3lrv4hrTCIiIiKS+BqV4JlZMsHk7jnn3Mte8w7gZeecA5aYWQXQE9gJ9A+7vJ/XRj3tIc65J4AnALKzs2OzOZkkjFlvrOfdjXthY/D5P689Iyr3TUuJbwFZM6NjShJFpcHtGT7YnBfXeERERESkbWhMFU0DngTWOed+HXbqFeBMr89xQAqwF3gVuNTMUs1sIDAYWAJ8BAw2s4FmlkKwEMur0Xwz0ra8t3Evf3p3S7W2jLQjn8J495ShoeOURhZgiaX0VD9FpeVA4wvCiIiIiIjUpzF/LY8DLgdWm9kKr+3nwGxgtpmtAUqBad5o3loze5Fg8ZRy4FrnXADAzH4MzAP8wGzn3NqovhtpMxZtyOW7s5fUam9o6wOAm88+gY17Cmq1Tzs9ixH9urBg/Z6Im463tI4pSRSUBBO8Iu/xhemnxjMkEREREUlwjami+S5Q11/Dl9VxzX3AfRHa5wJzmxKgtE/hyd21Zx7LIws2kf2lbo1KzK7+6rF1nhs9oBujBzRum4VYC47gBadoFpaWk5mRyinH9IhzVCIiIiKSyDQvTFq9s4f2BuDYzE5xjiS60lOSKPRG7gpLAnTUFgkiIiIi0kyqyS6tznOLt1V7PrxfFx77zhi+cnxmnCKKjU6pSeQeKgGgqLSc9BT95ygiIiIizaO/KKVVuevVtTz1/lYArvryMZwzIjh69/XhveMYVWx0SPFz4HApEBzB0x54IiIiItJc+otSWpXK5O6ojFRu+caJ8Q0m1hxs33eY8kAFuQUlHJvZMd4RiYiIiEiC0xo8aVVG9e8KwCvXjotzJLGXmZEKQFFZgM/yisjqqQRPRERERJpHCZ60GhUVjm15hVx0Uj/6dO0Q73BibkD3dAA+yyuiNFDBwB5K8ERERESkeZTgSauxeW8B+4vKODmre7xDaRHJ/uCWD/uLguvwuqanxDMcEREREWkDlOBJq7Fs234ATspqHfvUxVqSP/ifX2l5BQC++O+9LiIiIiIJTgmetAoVFY7NuYUk+63dTFVM8jK6A0VlAPiV4YmIiIhIM6mKprQK3/nTYj7YnEf/7h3wtZNEJ9kbwbtpzkoAissq4hmOiIiIiLQBGsGTuHvl4518sDkPgIp2lOMk+asnsuXt6c2LiIiISEwowZO4u/6FFaHjsQPbR4EVgCRf9f/8nItTICIiIiLSZmiKpsRd947B6pEvX306Pb294dqD5BojeA5leCIi7ZWZzQbOBfY454Z5bXcBPwRyvW4/d87NjU+EIpIoNIInLcK54B53f35vC7/5z4Zq50rLK5g6qg9ZPTvSKbX9fOdQWUVTREQEeAo4O0L7Q865Ud6PkjsRaVD7+Wta4iZQ4Zjy+3dZu+tgqO2arw5iy95CJv9mEQBHZaTFK7y4Sa5RTEZTNEVE2i/n3CIzy4p3HCKS+DSEIDG3bvfBaskdwBn3v8XiLXmh50e1o6mZlWqO4LWLBO+0H8c7AhGRRPNjM1tlZrPNrH1sFCsizaIET2Juzc58AM4Y1JPvnDIAgD2HStidXxzqU7OiZHtQ8z23h/wOa3//nEVEmuEx4FhgFLAb+FWkTmY23cyWmtnS3NzcSF1EpB1RgidR55zj3Zy9VFQEU5bZ720B4P4LR3DWkF6hfhs+PxQ6/vLgzJYNshVIrlVFs12keC3CzPqb2QIz+8TM1prZdV57dzN708xyvMduXruZ2e/MbKP3TfmY+L4DERFwzn3hnAs45yqAPwJj6+j3hHMu2zmXnZnZ/v5/KiLVKcGTqJu7+nMue3Ixf13yGQCf5xdz5vGZ9O3agZSwaYn/Xb8HgHnXf5luXiXN9qRdjuC1nHLgJufcEOBU4FozGwLMBP7rnBsM/Nd7DvB1YLD3M53gt+YiInFlZr3Dnn4TWBOvWEQkcSjBk6hxzlFSHuDVlTsB+O+6L8g/XMahknKG9+0CgL9GYZGjO6dx/NEZLR5ra1Bzm4TTjukRp0haUstM0XTO7XbOLfeODwHrgL7AVOBpr9vTwPne8VTgGRf0IdC1xh9WIiIxZWZ/Az4AjjezHWZ2JfCAma02s1XAmcANcQ1SRBKCqmhK1Pxl8Wfc/krVl4sLPs1lzC/exDnomh4coQtUVB+nqlyT1x6Fb3S++OcT6dW5/VUSbQleVbrRwGKgl3Nut3fqc6ByznBfYHvYZTu8tt1hbZjZdIIjfAwY0H7/3RWR6HPO/U+E5idbPBARSXgawZOo+XBTXq22yoSucjPzU47pUW0d3o8nDGqZ4Fqh8CmaNUc226wWLrJiZp2AvwPXO+eqlXJ1wUWPTZoZq3UuIiIi0topwZOo6ZDiDx2HJ3EAacnBc36fcd3EwQD07doBa8dVFZPD1iPWLLgizWdmyQSTu+eccy97zV9UTr30Hvd47TuB/mGX9/PaRERERBJKg39V1lWNLuz8TWbmzKyn97zOanRmNs2rXpdjZtOi/3YkXvYVlvLPFTs5vlcGW2edw4++cky182eeUDXaMbRPZ+46bwgvX3N6S4fZqiSFjdq1n20iWuZ9WvCbgyeBdc65X4edehWo/OyZBvwzrP273ufXqUB+2FROERERkYTRmDV4ldXolptZBrDMzN50zn1iZv2BScBnYf3Dq9GdQrAa3Slm1h24E8gmOC1qmZm96pzbH8X3I3Hy2/9soCzg2HMouLfdmAHduPTk/jz/UXBZU2pS1eiemXHFuIFxibM1SUmq+n6l3UzRbDnjgMuB1Wa2wmv7OTALeNErXrANuNg7Nxf4BrARKAK+17LhioiIiERHgwme9y32bu/4kJlVVqP7BHgI+BlV34JDWDU64EMzq6xG91XgTefcPgAzexM4G/hb9N6OxMP2fUVszSsC4LZzhgDBJG7Wt0bw/Efb+XY7LqRSn8ppq1B9umab1kJTcp1z71L3cOHECP0dcG1MgxIRERFpAU2qohlejc7MpgI7nXMra6yjqqsaXV3t0krt2F/EURlp1Uaawu3OP8xp//dW6Pn4wT351kn9qvXZOuucmMaYyMKTOo3giYiIiEg0NHrYILwaHcFpmz8H7oh2QGY23cyWmtnS3NzcaN9eGulwaYAz7l/ALS+vjnjeOcfjCzdVaxvSu3NLhCYJTYmsiIiISCw1KsGLUI3uWGAgsNLMthKsOLfczI6m7mp0japSpzLkrUNJeQCAvy/fwZPvbuFgcVm189OfXcbTH2yr1naiEjwRERERkbhqTBXNWtXonHOrnXNHOeeynHNZBKdbjnHOfU7d1ejmAZPMrJuZdSNYnGVebN6WNFdpeUXo+BevfcINz6+odv4/674A4NwRvUNtSvCkQadeA8fWWgInIiIiIlHSmBG8ymp0E8xshffzjXr6zwU2E6xG90fgGgCvuMovgI+8n3sqC65I61MSluAB/Hf9HoJ1KIJG9OvKqcd05/ffDu2CQa/OqS0WnySoTplw+csN9xMRERGRI9KYKpr1VaOr7JMVdlxnNTrn3GxgdtNClHiY+sh7tdoue3Ixd543lON6ZZBXUMLYrO7VzndMbVLNHhERERERibJ2UptdmmLd7oPsKyyt1f7exjwmPbSI8kAFeQWl9OiUUu18uyn1LyIiIiLSSmnIRWpZui249/xNZx3HgB7p7DxwmAf+/Wno/KBb3wAgUBHxchERERERiRMleFLL7a+sAeDHEwZhZsx+d0vEfh9tDS6hfPfmMzlUXN5i8YmIiIiISGRK8KSa8EIqlRvYf3GwONR2x7lDuOe1TwC4a8oQAPp1S2/BCNuWJbdOpKgkEO8wRERERKSNUIIn1Rz0RuJuO+fEUNv1XzuOD7fso2/XNDLSqv6VOTazU4vH19YclZEGGfGOQkRERETaCiV4Uk1lcZXuHasKqHRI8fPPa8cB8Kd3NgNwbGZHuqan1L6BiIiIiIjEjcoeSjXb9xUBcHTntIjnp4zqw6j+XXn6+2NbMiwREREREWkEjeBJNat2HABgWL8uEc8flZHGK95onoiIiIiItC4awZNqNucW0rdrBzqnJcc7FBERERERaSIleFJNXmHtDcxFRERERCQxaIqmAPDsB1tZvTOftzfk8tXjM+MdjoiIiIiIHAEleALA7f9cGzpOTdLAroiIiIhIItJf8lLLjMnHxzsEERERERE5Akrw2rHyQAXv5ORSFqjAZ1Xtg47SztsiIiIiIolIUzTbmS17C3knJ5cxA7oxd/VuHl24qdr5X188Mk6RiYiIiIhIcynBa2fO+vXblFe4iOdOO6YHF4zp18IRiYiIiIhItGiKZjvinKszuQOYdnpWywUjIiIiIiJRpxG8dmTngcO12sZmdeeZK8dSWFJOj06pcYhKRERERESiRSN47Uj+4bLQ8ffHDQSgX/cOpCX7ldyJiIjEkZnNNrM9ZrYmrK27mb1pZjneY7d4xigiiUEJXjuy52AJAC/96DS6pScDkJGqQVwREZFW4Cng7BptM4H/OucGA//1nouI1EsJXjuSN60XPgAAIABJREFUWxBM8Hp1TmPMl4JfAk4aenQ8QxIRERHAObcI2FejeSrwtHf8NHB+iwYlIglJwzftSEl5BQBpyX7GDerJyjsm0cUbyRMREZFWp5dzbrd3/DnQK57BiEhi0AheO1JSFgAgJSn4j13JnYiISGJwzjkgYilsM5tu9v/bu/M4uao67+OfX6/Z9z0hJIEQCEuAJwICSjBAwiJxHOUF+EBANM8gOOLCCDiIyqggAz6gqIMQBB9WBSQKjyECARkMJMSQEEKSJgHJ3hDo7J1092/+uKcq1Ut1d1V3Vd/q/r5fr3r1rXOX+p3b1bfrV+fcc2yRmS2qrKzMc2QiEjctJnhmdoCZPW9mb5rZcjP7Wii/xczeMrOlZvaEmfVL2edaM6sws5VmNi2lfHooqzAz9SPPo3c/2Mm2MMhKeYnyehERkQKw2cyGA4SfW5rayN3vcvfJ7j558ODBeQ1QROKnNZ/0a4BvuvtE4ATgCjObCMwDjnD3o4BVwLUAYd35wOFENwv/wsyKzawYuBM4E5gIXBC2lRzbs6+WU26Zzx3PVWAGZcVK8ERERArAHGBmWJ4JPNmBsYhIgWjxk767b3T3xWF5O7ACGOnuz7h7TdhsATAqLM8AHnb3andfC1QAx4VHhbuvcfe9wMNhW8mxVZu3J5eH9+lGUZF1YDQiIiLSkJk9BPwNmGBm68zsMuAm4HQzWw2cFp6LiDQro0FWzGwMcAzwSoNVXwQeCcsjiRK+hHWhDOC9BuXHZ/L6kp03N2xLLncrK+7ASERERKQp7n5BmlVT8xqIiBS8VvfVM7NewGPAVe6+LaX8O0TdOB9oj4B0o3Dznn9rC3OXbyK617p1lrz3UXJ5kCY0FxERERHptFrVgmdmpUTJ3QPu/nhK+SXAOcBU359xrAcOSNl9VCijmfIkd78LuAtg8uTJrc9iuoCfzlvF7c+uTj6feugQSoqN/7poctp9dlbX8PDCqOH03Ekj+NepB+c8ThERERER6RgtJnhmZsA9wAp3vy2lfDrwb8Ap7r4rZZc5wINmdhswAhgPvAoYMN7MxhIlducDF7ZXRTqzD3ZUU1vn9ZI7gGffigbTWrV5O+s/3M2phw5ptO+c1zckl++44JjcBioiIiIiBW/MNU91dAjSBq1pwTsJuAhYZmZLQtl1wB1AOTAvygFZ4O7/4u7LzexR4E2irptXuHstgJldCcwFioHZ7r68XWvTCW2s2s3Hf/xcs9uc8dMXAbj30o9x6oT6Sd57W6Pc+2dK7kREREREOr0WEzx3f4mo9a2hp5vZ54fAD5sof7q5/aSxhsndD2YcztA+3fg/v32t0baX3ruQX188mSkTBlNaXERdnfOL+W8DcPLBg/ISr4iIiIiIdBxNiBZj2/bsa1R27Oj+TDt8GC9cPYXrzjq00fov37+IR8I9dzv31iTLe3fLaMBUEREREREpQErwYuzd96PulVdPm8CXPzEWgAnDegNw4MCeWJMNq1BTW8fTyzZStTtKEG/+5yMp0eTmIiIiIiKdnpp1YuydD3YCcNSovpx00CC+fvohlKYkatura5rc73t/fBOAb0+PWvj6dCvNcaQiIiIiIhIHataJse17ogRu/JDeFBUZPcrq5+Pbdtfvwvnjzx5Z73nFlh0A9OmuBE9EREREpCso6Ba8PftqqalzepUXdDXS2lS1G4A+3ZuuX1VKgnfjjMM5d9IIrn18WbJs+YaqaH+14ImIxE4uhyF/56azc3ZsERGJt4Jtwdu+Zx+HXv9njrhhbr3y3Xtrk8t3/3UNt8x9K9+htZvnVm5h8oH9G7XcJWxPGYTloo+PoWeDRPetTduB9AmiiIiIiIh0LgWX4O2tqQPgD0v2T+B95YOLAfjaw3/nsO/+mVfWfEDl9mr+46kV3Pn827h7h8Saqbcrd/DRrr3J51t37GXMoJ5pt7/+nIkATDqgX7LsyStOontpMQN7liXL1IInIiIiItI1FFTTzourKrl49quNyv+0dCPfOH0HT4akb/mGbfTrsT/Bqdq9r97zOKqrc6be+gLjBvXkZxcew8Ce5eyt9XqDqjR04MCeVPzwzHplkw7ox4obp/PCqkpmhnOlKRKkqzGz2cA5wBZ3PyKUDQAeAcYA7wDnufuHZmbA7cBZwC7gEndf3BFxi4iIiLRVrFvwPtixlzWV0UAhVbv38Yv5FWm3/dStLySXi4ssef8ZwKz7X6NqV+M55dJZ9+EuvnD3Arbu3Nvyxu2kItRzzfs7OfuOlzj55ufYW1NLeUnzv6KS4qImp0DolzKwiqZIkC7oN8D0BmXXAM+6+3jg2fAc4ExgfHjMAn6ZpxhFRERE2l2sP/lvqNrNp259gb01dUz6/jMsWLO1VfttrNrDkvc+Sj5/9Z2tTPrBM4y55inmvbm5xf3v/uta/rviAx5e+A8Alq2r4o5nV2dXiQaWb6jizufrJ6q1dc4ZP30RIJnQ1dQ52/bUUFrc9Fx3LemrkTOlC3P3F4GGF4wZwH1h+T7gMynl93tkAdDPzIbnJ1IRERGR9hXrBC/hpYrKtOt+dsEx9G4wuEjFlu1puzZ++f5FLb5ez/JiANZWRvPQffrnL3HbvFXtci/f2Xe8xC1zV/LU0o3Jsvtefie5PKJf93rb/3X1+1m9Tr8eSvBEGhjq7ok/vE3A0LA8EngvZbt1oUxERESk4BREgle9r67J8rlXfZJPTxrBESP71ivftruGTdv2ZNX6ta+2jjuffxuIWgJ/9PSK5Lo/piRlbXXFg/tv8Um06PXuVsLmbXvqbTft8GFZHb+3BlYRScujb2sy/sbGzGaZ2SIzW1RZmf6LJxEREZGOUhAJ3uUPND3ewYRhvev9BCgpMqp272Pe8s0cODD9CJTpbKran2C9VPE+d724Jvn8mseWZny8VP/4YFe959c9sYzfLniXbqVRi+G1Zx7GrpRpHgBmHD0iq9cqLsqua6dIJ7Y50fUy/NwSytcDB6RsNyqUNeLud7n7ZHefPHjw4JwGKyIiIpKNWCd4w/t2a1T2k38+qlHZMaP3TxNw2mFDWbl5O3tr69ixpybj11y9ZXvadYnk67ZnVnLznzOfX+/el9cCMDZMffDgK//g+j+8QWmxce6kEUwY1qve9t84/RDGDe7V6Ditdd8Xj+MPV5yU9f4incwcYGZYngk8mVJ+sUVOAKpSunKKiIiIFJRYj59vWL0+VIuvP50BPcs4ZcLget02zzxiODv/qZbPHDOCS+9dmCxP3EsH8NljR1JX5zy1rPnPbV/8TXSP3oEDe/BuaHE7bHgfVmzcBsCYa55Kbvvt6Ye2qh7VNbVMvfUFErfwnTf5gHoJ4u59tXQvLWb80N719mtuioTWOOUQtTBI12RmDwFTgEFmtg64AbgJeNTMLgPeBc4Lmz9NNEVCBdE0CZfmPWARERGRdhLvBM/23yTz64snMyBM3j20T/2WvbKSIi48fjRQ/6aagT3LWfv+TuocbjvvaH46bxX7ah13J5r6Kr0TDxqYTPBG9O2WTPCysaZyJ+s+3J18vrO6fsvi5m3VdC8rpk+30nqJZVkLUySISNPc/YI0q6Y2sa0DV+Q2IhEREZH8iHUGUZcyauWo/t2b2XK/6pr9LXvlpUW8+p3TmP+tKcD+hGlfbfqxFRKvc9EJY5Jl3cqK02zdOrf/pf4UC5edPLbRNt3Da7xw9amMCF1Ty7KcIkFERERERLqmWCd4PcqiBsZPjB/EocN6t7B15N+mTUgumxmDepUzJtzzlhhVc19t06NyJnz22JH0TZlmoFtJ9gney2+/z4pN9Vv/+oeWyFSlKYOi1NRFCaha8EREREREJBOxziB6lBXz+g1n8NvLjm+xS2XCSQcP4tcXTwZgQIO54EqKEi146RO86po6ykuK6JaSXJ0+cUij7YqMVs2Ld+GvX0l2uUx1dUoiClCdElOi5VIJnoiIiIiIZCL2GUTf7pnP5/bJQwYx65Pj+N65h9crLw0J095mEry9NXWUlxRTXrq/1W76EcO5/pyJ9barc9hR3fwonbsbTHmQ6opTD+alb5+afH75KQcllxMteG0dZEVERERERLqWWA+ykq3ykmKuO+uwRuVlyS6aTbe8PblkPVW791FdU0t5g9azw4Y37iK6eVt1sxOKb921N7k8tE85Xzp5HKdM2D+y5aj+PXjgS8fz5oZt9Ouxv9tmomGwTAmeiIiIiIhkoFMmeOkkWsRq0rTg3TJ3JQCL3/2IkgYThTfVmrapag8HD0k/T92HO6ME75ITx3D5lIMajf4JUZfSkw4eVK+sW2kRVbvVRVNERERERDLTpTKIRJKW7h68xFQGO6prkvf8DeldXm/fVBurdjcqS/X5X/0NgLOOHN5kcpdOYnAZteCJiIiIiEgmWswgzOwAM3vezN40s+Vm9rVQPsDM5pnZ6vCzfyg3M7vDzCrMbKmZHZtyrJlh+9VmNjN31WpaIknbW9O4i+atz6xMLl960hgAnvjKiTz1r59otO2YgT0AuPr3S5t9vd37onvwemQ4zUL3cP+fWvBERERERCQTrckgaoBvuvtE4ATgCjObCFwDPOvu44Fnw3OAM4Hx4TEL+CVECSFwA3A8cBxwQyIpzJeykvTTJDyy8D0AepWX8KVPjAPgmNH9GRxa8BIteQCHDG3dlA0A5SVFHD6iT0Zx9iyPErzaupZH6RQREZHOzczeMbNlZrbEzBZ1dDwiEm8tJnjuvtHdF4fl7cAKYCQwA7gvbHYf8JmwPAO43yMLgH5mNhyYBsxz963u/iEwD5jerrVpQXPTJCRSqb01TXffHNGvO7/7l48DMOPokRw3dgDHjR2Q9rVeXFUJwKUnjW31FA8J3UMXzV370o/CKSIiIl3Kqe5+tLtP7uhARCTeMuoDaGZjgGOAV4Ch7r4xrNoEDA3LI4H3UnZbF8rSlTd8jVlmtsjMFlVWVmYSXouSXTRDgvenpRt4etnGets0N4XCx8YM4LV/P42zjxpOeUlRs/PpXTz7VQB27W1+KoWmzAotiJm2/ImIiIiISNfW6gTPzHoBjwFXufu21HUezfjdLv0J3f0ud5/s7pMHDx7c8g4ZSHTRvOHJ5VTX1HLlg3/nKw8sBqByezUA320w311DA3tFXTXLiovStvaldq3MppvlyeMH8c5NZzOkd+sHZhEREZFOy4FnzOw1M5vV0cGISLy1apoEMyslSu4ecPfHQ/FmMxvu7htDF8wtoXw9cEDK7qNC2XpgSoPy+dmHnrlEC97qLTt4de3WZPn8lVHo3UuL+eLJY1t1rLKS9AleIlmEzAdYERHpzMZc81RHhyBSiE529/VmNgSYZ2ZvufuLiZUh6ZsFMHr06I6KUURiojWjaBpwD7DC3W9LWTUHSIyEORN4MqX84jCa5glAVejKORc4w8z6h8FVzghleZM61cHa93cml9/fEc1XNzGDLpFlJUVpu3Ou/2j/9AknNpjjTkRERCQT7r4+/NwCPEE0WF3q+pz1fhKRwtOaFryTgIuAZWa2JJRdB9wEPGpmlwHvAueFdU8DZwEVwC7gUgB332pmNwILw3Y/cPf9zWh5kJrg3ffyO8nlxJzmP/7ska0+VnNdNHfvjQZHuXraBE6dMCTzQEVEREQAM+sJFLn79rB8BvCDDg5LRGKsxQTP3V8C0g0DObWJ7R24Is2xZgOzMwmwPZUW76/G25X7W/B+9lwFAIN6lTfaJ53mumjuq4vKP37QwGzCFBEREUkYCjwRRuQuAR509z93bEgiEmetugevs0htwUuV6K7Zt3tpRsdKl+DV1EYDq5QWaaJyERERyZ67rwEmdXQcIlI4ulQGki7BA+jTrYTiotbPV1fezD14t8x9CyCj44mIiIiIiLRVl0rwyppJ8HqVZ9aYmRhkJeqRut+Gj3azavMOoH6XUBERERERkVzrUgleaUnjhCvRLbNbaWbTGZQVF+EO81dV8thr6zjlluep2LKD7z65PLlNSTMJpYiIiIiISHvrUhlIwy6aN844nCNGRlMjlJVkdioS219670LmvL6Bdz/YxfINVXy4a29ym5o0XThFRERERERyoUsleCUN7okb2b87hw2LErzyTFvwUhLCutBNs7qmjtfe/TBZfuDAntmGKiIiIiIikrEuleCFIYaT+nYvo0+ii2aGLXg9U+7ZKwrH3bOvNll2yYljMm4VFBERERERaYsunYEcO7pfMlHLZIoEgE8fNSK5nMgbU++/+/b0Q9seoIiIiIiISAa6bIJ3xwXHYGb0Ko+6Zu7L8H657mX7u3TOX1lZb92/n31YvfUiIiIiIiL50GUTvHMnRS1wiRa8dHPaZUPJnYiIiIiIdIQum+AlJBO8mvZL8Jqbb09ERERERCRXMpvduxPqnYMEr3+PsnY7loiIiIjk3phrnsrJcd+56eycHDdX8Urh6/JNTYkJzquzSPBmHD2iyfJhfbu1KSYREREREZFsdPkE76DBvZgyYTC3nXd0xvtOO3xYk+Uj+nVva1giIiIiIiIZ6/IJXveyYn5z6XFMHNEn433POnJ4cvnC40cDUFps9O+R2ZQLIiIiIiIi7aHL3YM3fkgvdu2tbXnDDB06rDcQDbDScEJ1ERERERGRfOhyCd68b5ySk+MO7lUOwO597Z88ioiIiIiItEaXS/Da23PfPIWSoiI+2r0XgDrv4IBERERERKTLUoLXRuMG9wLgANfAKiIiIiIi0rGU4LUT3XcnIiIihSSX86jlau43EWmZEjwREWlEE+iKiIgUpi4/TUJ7G9ZHk5yLiIiIiEjHaDHBM7PZZrbFzN5IKTvazBaY2RIzW2Rmx4VyM7M7zKzCzJaa2bEp+8w0s9XhMTM31elYy78/jflXT+noMEREREREpItqTQveb4DpDcp+Anzf3Y8GvhueA5wJjA+PWcAvAcxsAHADcDxwHHCDmfVva/Bx07O8hG6lxR0dhoiIiIiIdFEtJnju/iKwtWEx0Ccs9wU2hOUZwP0eWQD0M7PhwDRgnrtvdfcPgXk0ThpFRERERESkDbIdZOUqYK6Z/SdRknhiKB8JvJey3bpQlq5cRERERERE2km2Cd7lwNfd/TEzOw+4BzitPQIys1lE3TsZPXp0exxSRERERPIoVyPxFuL0CxqVWPIt21E0ZwKPh+XfEd1XB7AeOCBlu1GhLF15I+5+l7tPdvfJgwcPzjI8ERERERGRrifbFrwNwCnAfOBTwOpQPge40sweJhpQpcrdN5rZXOBHKQOrnAFcm3XUIiIikpZaT0REuq4WEzwzewiYAgwys3VEo2F+GbjdzEqAPYQulcDTwFlABbALuBTA3bea2Y3AwrDdD9y94cAtIiKSAXX7ERERkYZaTPDc/YI0q/5XE9s6cEWa48wGZmcUnYhInpjZdOB2oBi4291v6uCQREQAXZ9EJDPZ3oMnItJpmFkxcCfRXJ4TgQvMbGLHRiUiouuTiGQu23vwREQ6k+OACndfAxDuI54BvNkeB1dXShFpg5xen0Sk81GCJyLS9Fydx3dQLCKxVYhfVnSCgWF0fRKRjMQ6wXvttdd2mNlKoC9QleHume6T6faDgPcziij3MWVznjKtRz5iyvXvoivWIZt9clmHCRkcNzZS5+kEEtenXMvmWhMnhR4/qA5xkVUd7OaMNj8w0+PHQQ6vTbF737Ti9xm7mFtQaPFC4cUcy3hbeC83jDmja1OsEzxgpbtPNrO73H1Wy5vvl+k+WWy/yN0nxyymbM5TRvXIU0w5/V10xTpkGVPO6mBmi1p73Dxp1Vyd7n4XcFe+goLsrjVxUujxg+oQF52hDllq8fqUq2tTIZ7zQou50OKFwou50OKFtsdcKIOs/DEP+2TzGpnKdUydoQ7Z7pPL43eGOmSzTz7eT3GxEBhvZmPNrAw4n2heTxGRjqbrk4hkJO4teAC4e8YfNDPdJ5vXyFSuY+oMdch2n1wevzPUIZt98vF+igt3rzGzK4G5RMOQz3b35R0cloiIrk8ikrG4J3h57QqVoTjHlonOUA/VIR4yqUPs6uvuTwNPd3QcTYjducpQoccPqkNcdIY6ZKUDr0+FeM4LLeZCixcKL+ZCixfaGLNFc5OLiIiIiIhIoSuUe/BERERERESkBUrwAjM7wMyeN7M3zWy5mX0tlA8ws3lmtjr87B/KDzWzv5lZtZl9q8Gx+pnZ783sLTNbYWYfL7R6mNkEM1uS8thmZlcVUh3Cuq+HY7xhZg+ZWbcCrMPXQvzL8/U7aEM9vmBmS81smZm9bGaTUo413cxWmlmFmV2Tz3oUAjP7fDjHdWY2ucG6a8N5W2lm01LKY3tOzex7ZrY+5RpyVsq6JusTR3E+x80xs3fC3+ESC6PWpvu7jQszm21mW8zsjZSydNcaM7M7wu9lqZkd23GRdx5m9lWLPrssN7OfpJTH9hpkZt80MzezQeF52veGmc0M76XVZjazA2K9JZzfpWb2hJn1S1kX23Mcx1hSZfFZJRbXDzMrNrO/m9mfwvOxZvZKiOsRiwZVwszKw/OKsH5Miwd3dz2ibqrDgWPDcm9gFTAR+AlwTSi/Brg5LA8BPgb8EPhWg2PdB3wpLJcB/QqxHinHLAY2AQcWUh2IJoddC3QPzx8FLimwOhwBvAH0ILpn9i/AwTF+P50I9A/LZwKvpLyH3gbGhb+J14GJ+apHITyAw4jmB5wPTE4pnxjOVzkwNpzH4rifU+B7TV1T0tWno+NNU4dYn+MWYn8HGNSgrMm/27g8gE8CxwJvtBQzcBbw/wEDTkhca/Ro0/k/NfyPKQ/Ph4Sfsb0GEU0fMRd4N/F+T/feAAYAa8LP/mG5f57jPQMoCcs3p7yfY3uOU2KPTSxNxJbpZ5VYXD+AbwAPAn8Kzx8Fzg/LvwIuD8tfAX4Vls8HHmnp2GrBC9x9o7svDsvbgRVECcIMooSN8PMzYZst7r4Q2Jd6HDPrS/RP6p6w3V53/ygvlaD96tHAVOBtd383Z4GnaOc6lADdzayEKEnakOPwCTG1Vx0OI7rw7HL3GuAF4LN5qAIhrkzr8bK7fxjKFxDN1wRwHFDh7mvcfS/wcDiGBO6+wt2bmpx4BvCwu1e7+1qgguh8Fuo5TVefOCrUc5xOk3+3ceHuLwJbGxSni3kGcL9HFgD9zGx4fiLttC4HbnL3aoj+L4XyOF+Dfgr8G5A6oES698Y0YJ67bw3/p+YB0/MZrLs/E/6XQ/3/kXE+xwlxiqWeTD+rEIPrh5mNAs4G7g7PDfgU8Ps08Sbq8Xtgatg+LSV4TQhNn8cArwBD3X1jWLUJGNrC7mOBSuDe0Ox6t5n1zFWszWljPVKdDzzUrsG1Ulvq4O7rgf8E/gFsBKrc/ZmcBZtGG38PbwCfMLOBZtaD6FunA1rYJyeyqMdlRN+QQXShfS9l3bpQJi1Ld+4K4ZxeGbq/zE7pDlgIcScUUqwNOfCMmb1mZrNCWVv+D3SUdDEX8u8mrg4h+n/zipm9YGYfC+WxvAaZ2Qxgvbu/3mBVLONtwhdp+X9knGKOUyxptfKzShzq8n+JvpyoC88HAh+lfAGQGlMy3rC+KmyfVtynScg7M+sFPAZc5e7bUhNkd3cza2nY0RKiLiZfdfdXzOx2ombh63MVc1PaoR6J45QB5wLX5iTQ5l+7TXUIHyhnECXdHwG/M7P/7e7/L4dhN4yhTXVw9xVmdjPwDLATWALU5jDkJmVaDzM7lSjBOzmvgcacmf0FGNbEqu+4+5P5jqetmqsP8EvgRqJE40bgVqIPNJIfJ7v7ejMbAswzs7dSV2byfyAuCjHmuGnhb7aEqPviCUS3DDxqZuPyGF4jLcR7HVGXx1hpzXXezL4D1AAP5DO2zq69PvvmmpmdA2xx99fMbEouXkMJXgozKyV6Yzzg7o+H4s1mNtzdN4bm2y3pjwBEGfc6d38lPP89UYKXN+1Uj4QzgcXuvjkXsabTTnU4DVjr7pXhmI8T3SOWlwSvvX4P7n4Pocuvmf2I6D2WN5nWw8yOIupycKa7fxCK11O/5XFUKOtS3P20LHZr7tx16DltbX3M7NfAn8LTQnovFFKs9YQeDLj7FjN7gqh7Vbb/BzpSupgL9nfTkZr7mzWzy4HH3d2BV82sDhhEB16D0sVrZkcSfXn7evgQPwpYbGbHNRPvemBKg/L57RlvczEnmNklwDnA1HCuIcbX+RSx/pvL8LNKR9flJOBciwYf6wb0AW4n6ipaElrpUmNKxLsu3HLUF/ig8WH3UxfNIPRlvQdY4e63payaAyRGWpoJNPstu7tvAt4zswmhaCrwZjuHm1Z71SPFBeS5e2Y71uEfwAlm1iMccypRv+yca8/fQ/gGHjMbTXT/3YPtG22zr51RPUKMjwMXufuqlO0XAuMtGiGqjKjb75xcx99JzAHOt2gUrbHAeOBVYn5OG9zP8E9E3Y0hfX3iKNbnOB0z62lmvRPLRK0cb5D9/4GOlC7mOcDFFjmBqAv+xqYOIK32B6KBVjCzQ4gG0nifGF6D3H2Zuw9x9zHuPoboi89jw2ewdO+NucAZZtY/9PA5I5TljZlNJ+qWd66770pZFbtz3IQ4xVJPFp+5OvT64e7Xuvuo8N49H3jO3b8APA98Lk28iXp8LmzffGukx2D0mzg8iLqSObCUqBvcEqL7nQYCzwKriUaXGhC2H0Z0QdlG1P1vHdAnrDsaWBSO9QfyOEpTO9ejJ9E3BH0L+HfxfeAtog83vyWMDlZgdfgr0ZcErxN94xfn38XdwIcp2y5KOdZZRCNbvU3UVSVv9SiEB1EStA6oBjYDc1PWfSect5VELaOxP6fh721ZeO/MAYa3VJ84PuJ8jpuJeVy4XrwOLE/Ene7vNi4Poi8TNxINNrWOqJt3umuNAXeG38syUkae1SPr819G1MPlDWAx8KmUdbG+BpEyamxz7w2ibuIV4XFpB8RZQXQvVeJ/5K8K5RzHLZYGcWX6WSU21w+iVuXEKJrjiBIttfJBAAACH0lEQVT7CuB37B/Rtlt4XhHWj2vpuBZ2FBERERERkQKnLpoiIiIiIiKdhBI8ERERERGRTkIJnoiIiIiISCehBE9ERERERKSTUIInIiIiIiLSSSjBk5wys1ozW2Jmy83sdTP7ppk1+74zszFmdmG+YhQRERER6SyU4Emu7Xb3o939cOB04Ezghhb2GQMowRMRERERyZDmwZOcMrMd7t4r5fk4YCEwCDiQaDLknmH1le7+spktAA4D1gL3AXcANxFNBlkO3Onu/5W3SoiIiIiIFAgleJJTDRO8UPYRMAHYDtS5+x4zGw885O6TzWwK8C13PydsPwsY4u7/YWblwH8Dn3f3tXmtjIiIiIhIzJV0dADSpZUCPzezo4Fa4JA0250BHGVmnwvP+wLjiVr4REREREQkUIIneRW6aNYCW4juxdsMTCK6H3RPut2Ar7r73LwEKSIiIiJSoDTIiuSNmQ0GfgX83KO+wX2Bje5eB1wEFIdNtwO9U3adC1xuZqXhOIeYWU9ERERERKQeteBJrnU3syVE3TFriAZVuS2s+wXwmJldDPwZ2BnKlwK1ZvY68BvgdqKRNRebmQGVwGfyVQERERERkUKhQVZEREREREQ6CXXRFBERERER6SSU4ImIiIiIiHQSSvBEREREREQ6CSV4IiIiIiIinYQSPBERERERkU5CCZ6IiIiIiEgnoQRPRERERESkk1CCJyIiIiIi0kn8DyPRT4bIxmdmAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "df = df_real\n", - "order = (2, 0, 0)\n", - "run_giotto_ar(df, 100, 2)\n", - "run_tests(df, order)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Simple ARI check" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-03T17:03:34.709039Z", - "start_time": "2020-05-03T17:03:33.225055Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Statsmodels results css:\n", - "Fitted parameters: mu=-0.00, p=[-0.71 -0.35], q=[]\n", - "AR roots abs:[1.68 1.68]\n", - "MA roots abs:[]\n", - "Train error mean: 0.00, std: 1.15\n", - "LL: 618.98\n", - "RMSE: 1.48\n", - "\n", - "Giotto results css:\n", - "Fitted parameters: mu=-0.00, p=[-0.68 -0.32], q=[]\n", - "AR roots abs:[1.76 1.76]\n", - "MA roots abs:[]\n", - "Train error mean: -0.00, std: 1.15\n", - "LL: 619.25\n", - "RMSE: 1.13\n", - "\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2kAAAE6CAYAAACMDRrWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOydeZwUxd3/PzWzF8slIBqBGIgS8UBAiUbRJEoCMRqNPh7RJI+a/B58jEm84iNKNGr0CV6PSXyiRoNBjdGIZxRUYhSJD8p9KivLIsJyyHIte+/MdP3+mOmZ6p7q7ppjd2aWzzsvMj3d1VXV3TNrfebzrW8JKSUIIYQQQgghhBQHoUJ3gBBCCCGEEEJICoo0QgghhBBCCCkiKNIIIYQQQgghpIigSCOEEEIIIYSQIoIijRBCCCGEEEKKiLJCNHrggQfK4cOHF6JpQkgXsXTp0p1SysGF7kcu8G8TIT0T/n0ihBQjfn+bCiLShg8fjiVLlhSiaUJIFyGE+LTQfcgV/m0ipGfCv0+EkGLE728Twx0JIYQQQgghpIigSCOEEEIIIYSQIoIijRBCCCGEEEKKiILMSSOZEYlEUF9fj/b29kJ3Zb+hqqoKw4YNQ3l5eaG7QhSEEI8DOAvADinlMYl9AwH8DcBwABsBXCil3COEEAB+B+DbAFoBXCalXFaIfhNCCCGEZAJFWglQX1+Pvn37Yvjw4YiPO0lXIqXErl27UF9fjxEjRhS6O8TJTAD/C+BJZd9UAP+UUk4XQkxNvL8RwBkARib+nQjg4cQrIYQQQkhRw3DHEqC9vR2DBg2iQOsmhBAYNGgQncsiREo5H8Bu1+5zADyR2H4CwHeV/U/KOB8AOEAIcUj39JQQQgghJHso0koECrTuhfe7pDhYSrktsb0dwMGJ7aEANivl6hP7HAghpgghlgghljQ0NHRtTwkhhBBCDKBII4T0GKSUEoDM8JxHpZTjpZTjBw8u6bVuCSGEENJDoEgjhJQ6n9lhjInXHYn9WwB8Xik3LLGPEEIIIaSooUgjRuzduxcPPfQQAGDr1q04//zzC9wjb04++eRCd4F0L38HcGli+1IAryj7/13E+QqARiUskhBCCCGkaKFII0aoIm3IkCF4/vnnC9yjdKLRKABgwYIFBe5JkbF5MXBbf2BXXaF7kjNCiGcAvA/gCCFEvRDixwCmA/imEKIWwDcS7wFgDoANANYDeAzATwrQZUIIIYSQjGEK/hLj9lc/xEdb9+W1zqOG9MOvvnO0b5mpU6eirq4OY8eOxciRI7F27VqsWbMGM2fOxMsvv4yWlhbU1tbiF7/4BTo7O/HUU0+hsrISc+bMwcCBA1FXV4errroKDQ0NqK6uxmOPPYZRo0Zp25o1axZuv/12hMNh9O/fH/Pnz0csFsPUqVMxb948dHR04KqrrsIVV1yBefPm4ZZbbsGAAQNQU1ODdevWoU+fPmhubgYA3HvvvXjuuefQ0dGBc889F7fffjtaWlpw4YUXor6+HrFYDLfccgsuuuiivN7TomLlM/HXureBQYcVti85IqW82OPQRE1ZCeCqru0R6WqGT53dJfVunH5ml9RLCNk/6Kq/TQD/PpE4FGnEiOnTp2PNmjVYsWIFNm7ciLPOOit5bM2aNVi+fDna29tx+OGH4+6778by5ctx7bXX4sknn8Q111yDKVOm4JFHHsHIkSOxcOFC/OQnP8Hbb7+tbeuOO+7Am2++iaFDh2Lv3r0AgBkzZqB///5YvHgxOjo6MGHCBEyaNAkAsGzZMqxZsyZtTbO5c+eitrYWixYtgpQSZ599NubPn4+GhgYMGTIEs2fH/8A2NjZ2xS0jhBBCCCEkKyjSSowgx6sQnHbaaejbty/69u2L/v374zvf+Q4AYPTo0Vi1ahWam5uxYMECXHDBBclzOjo6POubMGECLrvsMlx44YU477zzAMQF16pVq5Jhlo2NjaitrUVFRQVOOOEE7aLTc+fOxdy5czFu3DgAQHNzM2pra3Hqqafi+uuvx4033oizzjoLp556at7uBSGEEEIIIblCkUZyprKyMrkdCoWS70OhEKLRKCzLwgEHHIAVK1YY1ffII49g4cKFmD17No4//ngsXboUUko8+OCDmDx5sqPsvHnz0Lt3b209UkrcdNNNuOKKK9KOLVu2DHPmzMEvf/lLTJw4Ebfeeqvp5RJCNHRl6A8hhBCyv8HEIcSIvn37oqmpKatz+/XrhxEjRmDWrFkA4uJp5cqVnuXr6upw4okn4o477sDgwYOxefNmTJ48GQ8//DAikQgAYN26dWhpafFtd/LkyXj88ceT89O2bNmCHTt2YOvWraiursYPfvAD3HDDDVi2bFlW10UIIYQQQkhXUFJOWmNbBJt2tWL0sP6F7sp+x6BBgzBhwgQcc8wxOPLIIzM+/+mnn8aVV16JO++8E5FIBN/73vcwZswYbdkbbrgBtbW1kFJi4sSJGDNmDI499lhs3LgRxx13HKSUGDx4MF5++WXfNidNmoS1a9fipJNOAgD06dMHf/nLX7B+/XrccMMNCIVCKC8vx8MPP5zx9ZQWGa3tTAghhBBCCoyIJ0DrXsaPHy+XLFmS8Xln/+97WFXfuN9lvVm7dm1WwojkRo+5769dCyx5HDjzfuDL/6/LmhFCLJVSju+yBrqBbP82kdILd9zf/juyv8O/TyTfMLsjyQd+f5tKKtxxVT2z8BFCCCGEEEJ6NiUV7kh6FnfddVdynprNBRdcgGnTphWoR4QQQgghhBSekhRpUkoIIQrdDZIj06ZNoyDrDgoQ0kwIIYQQQrKnJEUaISQb+MMGIYSQ/YtSmy9LiE1JzUmzoTFACCGEEEII6amUpkgrdAcIIYQQQgghpIsoTZFGK40QQgghhBDSQylNkVboDuyH7N27Fw899BAAYOvWrTj//PML3CNvTj755EJ3ocjgN4YQQgghpJQoTZHGMWe3o4q0IUOG4Pnnny9wj9KJRqMAgAULFhS4J0UKM6ISQgghhJQEJZndUe7PzsDrU4Htq/Nb5+dGA2dM9y0ydepU1NXVYezYsRg5ciTWrl2LNWvWYObMmXj55ZfR0tKC2tpa/OIXv0BnZyeeeuopVFZWYs6cORg4cCDq6upw1VVXoaGhAdXV1XjssccwatQobVuzZs3C7bffjnA4jP79+2P+/PmIxWKYOnUq5s2bh46ODlx11VW44oorMG/ePNxyyy0YMGAAampqsG7dOvTp0wfNzc0AgHvvvRfPPfccOjo6cO655+L2229HS0sLLrzwQtTX1yMWi+GWW27BRRddlN97Wozw1w1CCCGEkJKgNEUax5rdzvTp07FmzRqsWLECGzduxFlnnZU8tmbNGixfvhzt7e04/PDDcffdd2P58uW49tpr8eSTT+Kaa67BlClT8Mgjj2DkyJFYuHAhfvKTn+Dtt9/WtnXHHXfgzTffxNChQ7F3714AwIwZM9C/f38sXrwYHR0dmDBhAiZNmgQAWLZsGdasWYMRI0Y46pk7dy5qa2uxaNEiSClx9tlnY/78+WhoaMCQIUMwe3Y8LW9jY2NX3LIigg4aIYQQQkgpUZIibb8mwPEqBKeddhr69u2Lvn37on///vjOd74DABg9ejRWrVqF5uZmLFiwABdccEHynI6ODs/6JkyYgMsuuwwXXnghzjvvPABxwbVq1apkmGVjYyNqa2tRUVGBE044IU2g2efMnTsX48aNAwA0NzejtrYWp556Kq6//nrceOONOOuss3Dqqafm7V4UJ/xVgxBCCCGklKBIIzlTWVmZ3A6FQsn3oVAI0WgUlmXhgAMOwIoVK4zqe+SRR7Bw4ULMnj0bxx9/PJYuXQopJR588EFMnjzZUXbevHno3bu3th4pJW666SZcccUVaceWLVuGOXPm4Je//CUmTpyIW2+91fRySxfOSSOEEEIIKQlyThwihKgSQiwSQqwUQnwohLg9Hx3zg+GO3U/fvn3R1NSU1bn9+vXDiBEjMGvWLABx8bRy5UrP8nV1dTjxxBNxxx13YPDgwdi8eTMmT56Mhx9+GJFIBACwbt06tLS0+LY7efJkPP7448n5aVu2bMGOHTuwdetWVFdX4wc/+AFuuOEGLFu2LKvrIoQQQgghpCvIh5PWAeB0KWWzEKIcwHtCiNellB/koW4t+3XikAIxaNAgTJgwAccccwyOPPLIjM9/+umnceWVV+LOO+9EJBLB9773PYwZM0Zb9oYbbkBtbS2klJg4cSLGjBmDY489Fhs3bsRxxx0HKSUGDx6Ml19+2bfNSZMmYe3atTjppJMAAH369MFf/vIXrF+/HjfccANCoRDKy8vx8MMPZ3w9hBBCCCGEdBUinwtDCyGqAbwH4Eop5UKvcuPHj5dLlizJuP7hU+OJHj68fTJ6V+4/kZpr167NShiR3Ogx9/3Vq4GlM4GzHgDG/6jLmhFCLJVSju+yBrqBbP82kdTf51Jh4/QzC90F0o3w79P+S6n9bQL492l/wu9vU17WSRNChIUQKwDsAPAPnUATQkwRQiwRQixpaGjIqT36aIRkAOODCSGEEEJKiryINCllTEo5FsAwACcIIY7RlHlUSjleSjl+8ODBubaX0/mkOLjrrrswduxYx7+77rqr0N3qwTBxCCGEEEJIKZDXmEEp5V4hxDsAvgVgTT7rJsWDlBItHVH0qSrPqZ5p06Zh2rRpeeoVIYQQUlwIIT4P4EkAByMeCPSolPJ3QojbAPwHADu06GYp5ZzC9JIQUozkI7vjYCHEAYntXgC+CaAm13r9oI9WWD7b14ENO1vQ0hEtdFcIIYSQYiYK4Hop5VEAvgLgKiHEUYljD0gpxyb+UaARQhzkw0k7BMATQogw4qLvOSnla3mo1xNGOxaWjmgMABCJWQXuCTGDXxhCCCkEUsptALYltpuEEGsBDC1srwghpUDOIk1KuQrAuDz0JYNGu7U1QnoGXMyaEEIKhhBiOOLjpYUAJgD4qRDi3wEsQdxt26M5ZwqAKQBw6KGHdltfCSGFJy+JQ7obrpPW/YTD4WRyjzO+fhK2bN5U6C4BADZu3Ii//vWvhe4GIYQQ4okQog+AFwBcI6XcB+BhAIcBGIu403a/7rx8Jl0jhJQWJbnYGMMdu59evXphxYoVAIBPd7WgsS1idF40GkVZWdd9zGyRdskll3RZG4QQQki2CCHKERdoT0spXwQAKeVnyvHHAHTpNBFCSOlRok4aKQba29tx+eWXY/To0Rg3bhzeeecdAMDMmTNx9tln4/TTT8fEiRMBAPfeey++/OUv49hjj8WvfvWrZB1PPvkkjj32WIwZMwY//OEPAQCvvvoqTjzxRIwbNw7f+MY38Nln8f+Wvfvuu0k3b9y4cWhqasLUqVPxr3/9C2PHjsUDDzzQzXeAEEII8UYIIQDMALBWSvk/yv5DlGLnghmxCSEuStJJ25+5e9HdqNmd3+SZowaOwo0n3Ohbpq2tDWPHjgUAHDz087j3j0/hT398GEIIrF69GjU1NZg0aRLWrVsHAFi2bBlWrVqFgQMHYu7cuaitrcWiRYsgpcTZZ5+N+fPnY9CgQbjzzjuxYMECHHjggdi9ezcA4JRTTsEHH3wAIQT+9Kc/4Z577sH999+P++67D3/4wx8wYcIENDc3o6qqCtOnT8d9992H117jj5Ce0HomhJBCMQHADwGsFkKsSOy7GcDFQoixiP/uvBHAFYXpHiGkWClJkcbFrLsfXbjjB+8vwHXXXA0AGDVqFL7whS8kRdo3v/lNDBw4EAAwd+5czJ07F+PGxfPLNDc3o7a2FitXrsQFF1yAAw88EACS5evr63HRRRdh27Zt6OzsxIgRIwAAEyZMwHXXXYfvf//7OO+88zBs2LDuuwGlxN5NwAG6CeZMHEIIId2JlPI96P/4MuU+IcSX0hRphe5AAQlyvIqF3r17J7ellLjppptwxRXOHwoffPBB7bk/+9nPcN111+Hss8/GvHnzcNtttwEApk6dijPPPBNz5szBhAkT8Oabb3ZZ/0uWuneAp74L/NsMYPT5he4NIYQQQgjJgtKck7Y/q7Qi4qSTJ+Dpp58GAKxbtw6bNm3CEUcckVZu8uTJePzxx9Hc3AwA2LJlC3bs2IHTTz8ds2bNwq5duwAgGe7Y2NiIoUPjy8g88cQTyXrq6uowevRo3Hjjjfjyl7+Mmpoa9O3bF01NTV16nSXF9tXx163LC9sPQgghhBCSNaUp0ny8tHdqduCx+Ru6sTf7Lz+e8p+wLAujR4/GRRddhJkzZ6KysjKt3KRJk3DJJZfgpJNOwujRo3H++eejqakJRx99NKZNm4avfe1rGDNmDK677joAwG233YYLLrgAxx9/fDIUEgB++9vf4phjjsGxxx6L8vJynHHGGTj22GMRDocxZswYJg7xhL9qEEIIIYSUEiUV7ihEwkXzGXNePnMxAOA/vvrF7unUfoLtgqlUVVXhz3/+c9r+yy67DJdddplj39VXX42rr746reyll16KSy+91LHvnHPOwTnnnJNW1is88u233/brOrHhYtaEEEIIISVBiTpphBA9/HYQQgghhJQ6JSnSCCEB0DUjhBBCCClZSlKk7Y+JQ7jsQPfC+00IIYQQQgpFaYq0/Sykq6qqCrt27aJw6CaklNi1axeqqqoK3ZXM0X1G+LEhhBBCCCkpSitxCOLjzf1NqwwbNgz19fVoaGgodFcAALtbOtHaGUN0VwV6VYQL3Z0uoaqqqsQXy9aFOzIEkhBCCCGkFCgpkWazn2k0lJeXY8SIEYXuRpKrnl6G2au34X8vGYezjhxS6O4QQgghhBDSoyjNcMf9zUojxBh+NwghhBBCSp2SEmkikbGOGq044HMoYhzZHXv+gxJCXCuE+FAIsUYI8YwQokoIMUIIsVAIsV4I8TchREWh+0kIIYQQYkJJiTQ6aEUCpzYVL37fkR6all8IMRTAzwGMl1IeAyAM4HsA7gbwgJTycAB7APy4cL0khBBCCDGnpEQaKRKolUuAninIfCgD0EsIUQagGsA2AKcDeD5x/AkA3y1Q3wghhBBCMqKkRBrDHbuWrXvbMHzqbKzZ0ljorpBMiHYAr14DtOwsdE8KgpRyC4D7AGxCXJw1AlgKYK+UMpooVg9gqO58IcQUIcQSIcSSYsmgSgghhJD9m5ISaTb72zpp3cU7H+8AADy9cJNR+R4aPVd6fPgSsPTPwNxfYn+0OYUQAwCcA2AEgCEAegP4lun5UspHpZTjpZTjBw8e3EW9JIQQQggxp6REmq0J6KR1NbzBJYkV0+/v+V+YbwD4RErZIKWMAHgRwAQAByTCHwFgGIAtheogIYQQQkgmlJRIs+nxQ84CIcBw0tIk+fMFHHPRdtV5lOtxbALwFSFEtYjHRE8E8BGAdwCcnyhzKYBXCtQ/QgghhJCMKE2RRhXRJWQavsjHUCTYD05KJH/CqJkNPHgcsPa1gnWru5BSLkQ8QcgyAKsR/7v2KIAbAVwnhFgPYBCAGQXrJCGEEEJIBpQFF8k/GxpasK89gn5V5YVongQQKL56rCFTqqhOWoJdtfHX7au7vTeFQEr5KwC/cu3eAOCEAnSHEEIIISQnCuKktXRG8caa7VmfTwOna6D2KlEcTpoOfmMIIYQQQkqJEg137Jp6IzEL/1z7WddUXkL0xOyZe1o6MWf1tkJ3o4uRAV+OnvdcCSGEEEJ6IgUTadm4Nqk5U10z2Lx/7jr8+IklWFC3f643FWjIFIB97RHsbunMuZ4rnlqKnzy9DDv2teehV0WG6YMrpgdLCCGEEEI8oZOm8OmuFgDA3tZI1zRQAG6YtRLDp84udDey5vhf/wPH/fofOddTv6cVABCxeqBQEfbXWEkckkR6bBNCCCGEkGIl58QhQojPA3gSwMGIjwIflVL+Ltd6/eiqoaYt/nrS3KxZS+sL3YWciMTy87R7tjyxnTTLvxidNEKSdOWPVxunn9lldRNCCNk/yIeTFgVwvZTyKABfAXCVEOKooJNEpvne0fXreNlzsbLoWo9AZChPS2nI3xMFeJKgcEeTL8xt/YHnf5S/PhFCCCGEkKzJWaRJKbdJKZcltpsArAUwNOi8bAbLXZ3QIjWW7ZFDeWN6cgb+ninAlYvyfXgBT3bNC/noDCGEEEIIyZG8zkkTQgwHMA7AQs2xKUKIJUKIJbm201Viza61Zw7kDTC87lJy0Gyy+czELIlfvbImOZ+taPFz0tR9DHckhBBCCCkJ8ibShBB9ALwA4Bop5T73cSnlo1LK8VLK8fHyWbSRYbjj9sZ2DJ86G+/X7TIq36ND4nyIWRLRWGo+k+n9LaX7lHq25r1e+ukePPH+p7juuZVd1Kt8oVnMWgtFGiGEEEJIKZAXkSaEKEdcoD0tpXwxH3X6YSoilm/aAwCYueAT05qz61CJc9aD7+Hwaa8rQ/2edx+ycUkt+4NW7LfD4aTpOlvsF0AIIYQQQlRyFmkingFkBoC1Usr/MT8vm8biL6YiorI8fnntkYCsdwnsMXloP4t3XLstbnxmk8ylVEjqrWz0StHfFkMnjeGOhBBCCCElQT6ctAkAfgjgdCHEisS/b+ehXk9Mx5pVZWEAQEc0ZlZv4rUHaxUzeuRYXib+3/ziSkbT2OukaTvcheukWRbwxk3A7g35rZcQQgghZD8n53XSpJTvIQuvIdN079lgO2kdUVMnbX9PwZ8ZpaJhgOyctOSSDF3Qn7ySDHe0/C9QPdbRBKx+Hjj+suw/8Ds+BD54CNj4HvCf/8quDkIIIYQQkkZeszsWG3bYYodpuGPitTsEZHcj82gLlfLdsbK4D8Uv2k0Thyi8MRV47Rpgo0tcLX0ivmZap0FGy5xiSAkhhBBCiBclKdJMx4RWoly7abhjSqX1ODJzkHLjucWb8eHWxhxryS/2NWWkJ0pFe2SzmHXb3vhru+s5vXtP/LXVLCMqIYQQQgjJPzmHO2ZLLu6E6bwi2z3K3EnreZjcsXw5Rv/1wioAwMbpZ+anwjyQjZNYOs6q6qS5rtNrnbRwRfw12uEqn/iuFL99SAghhBDSYykpJy05FHWNQ/+6cBN2NneklbedNOPEISUetvXprhY8sWCj9lgmYX7deR9qP2vCG2u2d1t72VxakF55Y802vL56W3YdygfaL4au0xqRFot4lDERaaX9fSGEEEIIKVZKSqTZqEPDT3a24OaXVuNnf12eVs4WJqYp+G1KNRX9+Y+8j1/9/UO0R9JFqYk4KcRlf/OB+fjPvyxNvpdSYvaqbWjrNBPWptiXn5lYNSv3n39ZhiufXpZ5p/KG4qS5O60+VPVYmS3S3E6avep3Bn8aSvPrQgghXY4Q4vNCiHeEEB8JIT4UQlyd2D9QCPEPIURt4nVAoftKCCkuSlOkKYPNlo4oAGBvm9sRAKyElWbupMVfS3XM2diafg9sMko9n4/OZMm/anfiqr8uw2/fWpfXenNZl7roNbvdwQ3zgHenO/d5LXCdDHfsdO6Xmf2gQQghxJcogOullEcB+AqAq4QQRwGYCuCfUsqRAP6ZeE8IIUkKJtKycauS405lXzQhxCrC6fXZ4Y6RmOEcthIP3/Lrv5GTpsjT5o4orn9uJRo14jdVZ/7ul13X+h3NAICWzqhn2dX1jRg+dTbWfdaUdTtGZZMp+ItcpWmvyTTcsdOjjMd92rYS6GzJrH+EELKfIqXcJqVclthuArAWwFAA5wB4IlHsCQDfLUwPCSHFSkk5abqxaCQW/+W/LJx+KZmmW8/FbSkmdJedUXZHCTyxYCNeWFaPP75bl7+O+WAL6e372gEAh/Tv5Vl2dmL+11trPzOu3xZnVgb3wS5b9E6aL16JQ8rjr26RlvwSaBy1jmbgj18Fnv9Ren2EEEJ8EUIMBzAOwEIAB0sp7cnM2wEc7HHOFCHEEiHEkoaGhm7pJyGkOCgpkWajjg0jiYWqy7VOWnYiLZu1tIoBv/6buIQ6p9K/fLB6sSxpNL/s9TXb0NoZxfbGuEirrgh7lg0FZJzXITVbRc3mRcA7/21YWHNN2mejirTK+Ks7cYgtznQiLdqe6hshhBBjhBB9ALwA4Bop5T71mJRecemAlPJRKeV4KeX4wYMHd0NPCSHFQuHCHX2OvbisXrvOVmrcmfpbFknYHeUuJ01KmfEP/baQKdUsj36Bal1xSSb36Y7XPsKRt76RdDy9uPrZFbjpxdVoTQi6qE+Iqr1IeSwTWyxBZo5iAT8HM74JvHu3WVnTbpokDoGPk5actFnS1iIhhHQrQohyxAXa01LKFxO7PxNCHJI4fgiAHYXqHyGkOClKJ+2651bizN+/53lc76S5RVr2jlhXjM23NbahZvu+4II5kArpS7+AQqXgf3bxJgAIFGkAsHFnC8oSNlmnT/lQokxGzzfpMmZ8Sglk+wyYk6a7T57rpPmItB69kiAhhOQfEf8PyAwAa6WU/6Mc+juASxPblwJ4pbv7RggpbkpqMWs7gYMzcUhiTlrIWaFE5k6LzGIgb8pJv3kbQNcs8PzC0nrc+MKqZL+1JkjeWzUTs5nqvXAibNVP1Hmtl+fbj+Rr5nei6CWJ7kYIXUyosm2n2PdaJ81dZ+tu79BIQgghXkwA8EMAq4UQKxL7bgYwHcBzQogfA/gUwIUF6h8hpEgpmEjLBXX82JkIiysv0yUOybDeZP2lFe74m9fXJrNcAnoh0iXhjgaCxy7hJZhDQv+c/ESaHe6YyXOyXTfTU3Y2d+DyPy82rr+wGF6UevG2wPJaJ00VYLEocM8I4LDT4+9tgZesr+hlLCGEFAQp5Xvw/iM5sTv7QggpLQo4Jy37gZ06OI8mBvMV2jlp2am0rnDSuhNd/73uhTr3zw7ry2aKU1A7lofmSsvKmTjdf05aos4snpPpR2Lz7tbkdvFHO2aRgt8WYWnrpGlEmkwkfql7O1G1SC9DCCGEEELyRlHOSfNCl30wmYJfE+6YuZMWsEZUiaATSrpx/IdbG33n/gW3Y7AvIGOmW1zb5fIxJ62hqQOPzq9zJJHJZp5iQTWalEDDx8CHL/sVSt/lUJa6B6U4abqQSIdIc59PkUYIIYQQ0pWUVLijbnzdaScOKcs9cUhXzknrTrROmqacne4+WcZwoTg/xy1do8X3xDyeha+tPvsAACAASURBVLp0gkTqGfjOSTN00n7+zHK8v2EXTjl8cMZz0YomWYi0gD+cEN8+Oj3jqUEFyqbGSbNiLkGmS8HvunfJX0uCl1YghBBCCCGZUzAnzWTQPOXJJdq5TOpYsyPqEe4ImblIS7yW6jppNjonTbt2Wo6XadJOUvhaEv+3fiduenG147g7K6d9fiTqF+5oNidtX3skrU/ZXHNBBZsqljpbgT98Bfj0fVcZ4wBVzTnSJd50TppbMLuctGIRtIQQQgghPYTCiTSDceXcjz7D9n0ptycV7pg6ucNjMWspMx+Q24P+YtFoW/e2YWezex2rYLQOVwaZGL0E9MadLdi6ty2rdmJS4vt/WohnFm1y7E9bOiHx6p84JP4aJKZ12qPkBLgqkHasBRrWAm/e7C5kWJfGSUtbQ9VApHFOGiGEEEJIl1JAJ82wnHbiU2rTFmnhUPqlZJyCP/FaLAP5k6e/jfF3vmVQ0ilQta6ZLuOjRxmvy//6ffNw8vS3vSvQtJ26p/o608V1wknzeXa2kxb0eDXSI6vZhlJKPPCPddjdkkqysXFnC4ZPnY0Vm/cGnj971TYs/XR3Fi3DKYS8xJFx4hBNvdLyEG8ZOGmEEEIIISSvFGxOmmnmxQCNho5oLLHPLMQv07ZKEe11GGRizDwZZvAJyQW21SUCpEyGELqzOybnpEWDBUBQf+221Wi8bJZX+FftTrzzcQM+2dmC3188DgAw7+MdAIAXl9UHnn/VX5cByHKNPLW/ng6WT+IQr3XSHGIsQ5Fmp+C3OCeNEEIIIaQrKLrsju5BtOqG6RYxthOHuMfeWYU7Jl6LxUnLFl3/TZKJJMMdDcWPSdv2u5hDpHnXlZyTZrBOmulzEhDJjmSTFMZegy5TZzYvOJw09/pk0L832edIHKKbk+aRcATQfBE5J40QQgghJJ8UTKTZA+zWzqhjv3s8GNUssKU6OLZIsyy3OMg8cYjdeIlrNG3/H3m3DluU+WTa8/LQjt+cNBtHIg/XufZ7vxT8YcMU/PZhIdTPTPYPt1KzYHqXoxVpBk5a0L6kY+bK7gidSPN4Fgx3JIQQQgjpEgqaOOS5xZtx1K1v4pOdLcn97oF3p0+WPyC16LHb5Iin4M+ub6Wegl+nXWYu2Ij/98QS33LGzpRPCn61DsuSijGT2v/XRZuwrTEhGNP6EH81W8w6QKQhFe5o6hLa6LyhyvJw6nh3ZTQMTI+PDJw0ZdsOVbRi0Is3zkkjhBBCCCkUBRVpb364HQBQt6M5ud8tkLROmlLGDovThdntryn4vfrvdi3TyM549Kwiojw71Ri79ZUP8e8zFmmbTCYOcTlp97xRk9xOisQsHlMuT1bnpHX5R0UVQpb9/NLuml8FHg9KddI0x/dsBBY+mijjDnfkOmmEEEIIIV1JQbM7BjkxgH5uklMI2CGK7iQYmYc7JsuXtkbz7H669+Msed/cjxN7zW6ANmOk8rgiihvmns9lZ0r0Sl7ifu4PzatLbpsuZu3sa+IczUnNHVHUNTSn7XdTWV7gKZy2+2XkYAWFO9qT9Cx92ZemAK/fALTtDXbSuE4aIYQQQkheKficNDfu3Wq4o9AsYhxNOmmaNjJNwZ9MLlHaKs20/+5iO5o6tPtNzwecwq0jknJaHnm3Lr0wXHPSEv8DgE6fcMdU+4Zz0iBSa+AB+PvKrTj1nreTwvH7j32Aife/G9heVVk4sEze0TlpWYc7es1JC7jXXCeNEEIIIaRbKVgKfkj9vJ+MnTTfcEfz7sz7eAc+3Lovrf58o6af78o2dLjbzfU69U5oartNEWl/X7lVX4d7TlricUdiFj7e3qQ9xzIU0/ZRkUruCCmBG59fhbZIDB3RGKoryrCyvtHzXBXVSdMtrN4lmIi0XBKHWFGPsh59AHwSmBBCCCGEkHxQwHBH/cDQPfDWzUlTT434Jg4xH0Bf9ufFnn3IJ7Z7s35HE4ZPnY356xry3kau3Tc+XbdotrKvPeI9Z8lL5NjvY5bE5N/O9203cDFre500patq//zuk+4zUJlnJ+3uN2qS6615kq2T5jjmMyfNcmd3TCvoHe7IddIIIYQQQrqEgiYO0eEeeDvCHe1zlUGn7aSluUce+RJy6Vs+sK9v2aa9AIBXVugdpny04cbt33WFmFPbbu0MHsR7Lfnlvxab/WrupKn77Pcxn/N17ZeHzRxQvzXeVB6eV+f4cUDfEaWuWCR9n+d5eQp3tCyfcMfkHQ7uDyGEEEIIMSYvIk0I8bgQYocQYo3pOV5Cwj04Vge8ulNSKfjTHRn3PtPFiP0EQmNrJNj98MHuk50p0Gs9sKD5Vn7kkvgj3rb/ebpFxXV1+os0fYZGk9wt9j0MvEVJwZdeP+A/Z1G7+Hdi3/bGdtz6yoea4xJv13yGkdNex5ot6SGUWaF2OCnSPG6aY5+lOa4LdwwQfGnrqAFMwU8IIYQQ0rXky0mbCeBbmZzgJRBeXr7F8V47J005tdMjcYiUTqdkzZZGHHbzHLxjILD8tNyUp5bgsj8vxt7WzsB69HU7RVqHR0hgVOnE8Kmz8e3f/QttBs4U4DPudhkeXiLn010tuPdNO9OjNzohqe5qMwl31Ihrv74Bqefz0vIt+Cgxj9APtSpLyuRtiLoetNoXnYCzj8/9aLtnv95aG/98razfG9gvIxxOWqfdEXch3Ynp29k4adLyPk6RRgghhBDSJeRFpEkp5wPYndk5+v23vfqR4726qLHOwbHnrOlC39RdqxPOxptr9ANs53neg1Y7VbuXAxaE7ebZ85s6ovp63K7fR9v2YX6t2fw1rzBA06C02h3B6egBD2mgijSTcEfXufZl+7mB6vNZumlPYN3q/YiHO8bvhFuIOVw2TfOWBDY0NGPZp3s8zpGIJT6v4Xwlh8l1Tpoj7lfnpLkWs3ajm7NWhOukCSEOEEI8L4SoEUKsFUKcJIQYKIT4hxCiNvE6oND9JIQQQggxodvmpAkhpgghlgghlgDxbH/vb9gVeJ5ODKlDykhU77xIOAfh1RVxUdRiIBz8nDSRyniRFXbdFXa4o4dI0zmImS4p0NUEhTsaibQ0BzQRvuqjgVXRVV3uncwjmXZfpu8D0uekOcSc5uIsKXH6/e/iZWUe4RuK6I9ZMllnONQFIi3ppGX6A4FP7KaRk1YS66T9DsAbUspRAMYAWAtgKoB/SilHAvhn4j0hhBBCSNHTbSJNSvmolHK8lHI8ACz6ZLdRYgl9uGNqUBnxcNLii1mn3vdKDObbOqPBffXY3xGNocFeS0xzbNID7+K92p3+dSf6GUoMbDui+nugmz/nl+hCxdNJy1MKfv/5YqntViXc0a1ZdElg3Od7tq+UscW3tpymvFTajrrWYnOGRQb3AwB2taTCXqVMPbeysN6tyxijxCEBbaSysaTXG5TdUTcnrchS8Ash+gP4KoAZACCl7JRS7gVwDoAnEsWeAPDdwvSQEEIIISQzCpbd0RSHSNOYWPZAW+ukqY5LRXxJOLOMg/pB780vrlHKOI8t/mQP1n3WjPvmfuxbtz2ITy3arB/ouudLqecG4aXl0rM75iYg9OGOqb3tyr32Sl+ve25BfVNvQ3Wl91J/qSQkeofMLWYtn2Ne+1RiUiafmy3CTYW1EVmFOzoKKpvKnDQ/kadz0opvMesRABoA/FkIsVwI8SchRG8AB0sptyXKbAdwsO5k1eVvaMj/khiEEEIIIZlSAiJNP9fsv+esxfCps70Xs5bOAbntbGSTFt7m/Tpvl2zJp/EpeV8e7j/tJTnnKvHaEfEQaZrrNl2/zdtJMzrdmKDEIeq9tsM73X1RBZf6zPzdutTRcoOwQq/sjm7R655flt6ufzuWlEnnrCwU8qwnI4zCHXNx0nwSg9jH0+ovunXSygAcB+BhKeU4AC1whTbK+AdLe6Gqyz948OAu7ywhhBBCSBD5SsH/DID3ARwhhKgXQvw4H/UC3mtOPTp/Q+K4l5PmDHe0B8sm86S8BtbSse0s09gWD0U7oLoiua+hqQMfbnWmYp/6wip8tq892Ya3k5a+f91nzdjR1G7Q/8AiiXLZCYhXV3qv7eaV3bE87BJpyRT8eqHkO03K4Xj5lNOMyaUS7+gn0rTz7YK0kJV6bvblBmW4D0QX7ui+Lv+blV5erTcrJ83dbsHnpNUDqJdSLky8fx5x0faZEOIQAEi8Zr92BiGEEEJIN5Kv7I4XSykPkVKWSymHSSln5KNewEukybTjOsGhhprZg+XWSPCctNfXbMfwqbOT88+SrRq4MLaTEolZ+PJdb+HM37/nKPfPmh341SsfJsWF6qQ1tkWwrz2irR+IL358yt3vBPbfa9AtXIPpLBNUplrRNKM+h3ZFpJV5OF5eIYd+AtLhvnmu9SaTgtzLIfNLHJJtuKN9T8MJJ80r3LGpPaLdn0Y+56Q5wh0Tz8YKShxS/OukSSm3A9gshDgisWsigI8A/B3ApYl9lwJ4pQDdI4QQQgjJGO8JPd2IXxieV7ijTdRLpEn9gLy1I9hJW7E5vsbVp7taMLhvpbaM59JRidfdLf7rqNl9UxOHjLl9LgBg4/QztdcN6LNBuu9fVztpNlqnStlW3UD3HDsR4GZ5zXcTQgSmygeAGe99gp3NnYkyypw0pHwfd9tOkaZv3w9LSsQS12yLUq95hKNvm5vcXr+jGYcf1EdfqeNiM1jM2nHMJ9wxyEnbsxGo7OfcV3xz0gDgZwCeFkJUANgA4HLEf4R6LuHsfwrgwgL2jxBCCCHEmKIQaX5o10lTjttixnLNQZNwjW8Tg2WTOWk2faqct0cVJV6Db3ugHxgaZ4c7Gq6TlgmeiUPcYi7HzINBTpr67GKuuD8pgQXrd6Kpw+ls+t0/SwJhEex4AfElHpJtudq1s1ymCUSP61DP9aM9EkuK0fc37MKA3hUYPqja/yQA3/79v7DuzjP0B3VOWtpcsKBwRZ2TZpjd8ZnvpYu0ZB1FMycNUsoVAMZrDk3s7r4QQgghhORKUSQOkRK46cVVeGbRprRjusHyk+9vTG7bKfillGlzilQRcvnMxQCc86SCcIcHqtjOnGVJh9AyWYw5fl78td1DpOnmpJlinmAkuMzD8+pw+v3ztMf0bldqW3UD3YlQtu9rxyV/WugjfNIPRJVnnWov2HH0Kp8m0pRbrl8nzauvcU65+x0s3hhPIPPo/A347h/+z9HGBx7rAnoJdQBAR5PSAY9wR9/n7eWk2fsCEocAQMc+53t3Cv7iWCeNEEIIIaTHUBwiDcAzizbjphdXpx3TOUofbNidOteeCybTE3vkukSVf2KJ+JubX1qNL/3y9ZQw0jhB2xrb0uq2D3s5ZrrsjqaYrpNmmh5+Q0OLdr8+uYYizHzCHbX1IdX3fe3pcwfte+VICOOhb9SELM7PhXKu75y09DpNxG+7K1un+ny/9+gHmPHeJ2kCsCLs8zX887eUymyRloGD5SXCkk5aFIFz2tIoynBHQgghhJAeQ1GEO/oNflUh4RYZ7jrmfrg9+V7K3OdcpaX1V/uVGJ8+u3hz4n386O/fXo/xwwcmU/4DwEm/eTuwbjcmosYTw1NzXyct/fyrn12R3HaGO5q1ZXdJ5y6lRFpwuKPTSXPWb3+M/BezTq/3d/+s9eu6lk27Wx3vf/3aRxj/BecyDX2rDL+G2SQOcWR39Ap3zPBzUJxz0gghhBBCegxFIdJ8Fy5WBvdBCxxf+fQy1778ijS/Y+r7y2cuDhQlQQIplzlpXqe6JW4ubQD6sf1H21KhcWpmTtPwTV/BrnPSPIo7RZ7yGVLnFbraisYsdERjqCwL5+zC2uxtTc/i6Bbg/XqVm1Vmr5NmRZ1q0zdxiOKkZZM4RIu9ThpFGiGEEEJIV1AU4Y5+A2JzBybdFclVpPmFO8Ys6Qzty9A1CioSzSE/ftB8ONM+5Ioq0kzb8itm31f1+rzErtq2VzZI93O68ullOOKXb/jWmyn6dfCcdfeuDJtVFovot33vmtQfz6uTxjlphBBCCCH5pEhEmr9DZhMU7qgiZe5z0tL75QyzU+vPNDyxK8MdPZ20vGd3zP81+FWZFGmqIeRRVpfMJX6u9EzBv/TTPUb9yATdOn/u2zJU7AY2vhfsTFmqSFPW8DN10tz74xtZhC0KINoBzPvvVB2EEEIIISRvFIlI8ztm6AppEt7l6oa4x9duR8aRbj5jkRbUtr6ASSI9r+tOX0+tawfXvlkLPfB7ZvY9VsWl55w0h5PmLGOL/UzCWbNFdw/c4vgbsfnAzDOdwktHNk5a0DppgCalfwAiBDRtc7VBCCGEEELyRXGINB/FYhruqBtU5zplJmh+lHNNsMwaCxKQOgcGACrL0h+ZW7d5VR2NSTQr65KZZnf0Iuj0TNaki9fn735mMidNTf/vTghi3y+/DJr5CgXViXf3rt6Viamh0gLenAbUL/HolJLxMpqNk+Yl0tIzafoiBFDWS18XIYQQQgjJmaIQaX6OizO7o3cd7nFqXrI7+ix27F6XLd/hjl7i1Ddde0DdNdubcMyv3ky+z9UACTq9pSPDwT/859PpsjuauKW65cHc9bjpUifNnXTGlo0tDcD7/ws8e4m+MjtxiHvbFy8nTb0RmT8nT8FHCCGEEEJypjhEmo8LZTpvyj3w3bK3LWenyH2+eyFky/U+E4JcPi/RV1EWnGTC9LK7IrujjRBwuHam+N0X+3moz8FETDkTjSj1+bSVr8QhOkfU/XmXMvE13JlI8d/nIH1lnuGOPsTjfu03yv4cwh0hnOdTpBFCCCGE5JWiSMHv66RlKdIufuwDnDtuqNG5XgNyv7ZjrtA8r/BEL9xu0PodzY7jXinrdeGOfnXno5wXfq5XRTiUlUjzI5XdMYVRSKvLPUuuk+Zzcr7CHSOakEr35z3ppNkibcAIYHv6wu5OkdYB1C+Nzw0LCnd0h092NAGf/p/SAUPBZyOEtytHiprhU2cXuguE7FcIIR4HcBaAHVLKYxL7bgPwHwAaEsVullLOKUwPCSHFSvE7aYbjP10xc7Hitd8v3BE5OWlq1W+s2Y5vPjBfOSY950tVVxg4aYZ9yFWI+N3eirJQxnPS4nVmFu6oe8Yz3vvEWafHdneEO2qdNC+RtndT/LX/MI9OqSKtE/jT6cDfvg/fJ77yGSDaFt+2r+kft7rqzVRM00kjhBBDZgL4lmb/A1LKsYl/FGiEkDSKQ6T5OGm5CC1TEeLVhm/onSUdY9NM5qQJ4WxTXQDarttL9JksfGwaqpdzCn6fYyaOn45ME4foLvXXr33kqlM9Qa0vu35kgu6z7RZuyVQmnbab6jH5UnXSosqcNGNBmSjX4XRts0ocwjlphBASiJRyPoDdhe4HIaT0KAqR5hcqqIoVv+zzOmFiKvC8BFH6nDTnsWyzO8ZdOO/2o5ZExKNPVeUm4Y5m/cjZLfKZs1dukOBEW6WP9ItaEn98tw5/XbjJqLyNen/j5UViv/cz69I5aV5OWsR2vDz6FXM5aUlM7eZEufIq5/5sRBqdNEIIyYWfCiFWCSEeF0IMKHRnCCHFR9HPSctlflXMJ8W6ilcTliWxcMMu3PzSasz++amuc3JMHKKe6+pAJGYh5iH62iMW3q/bhZMOG+RZt3HikAyEiE60uPeot6Cii5y037xeY1zeRp0X5hTHPv3Ik5WmnZPmatiSbpHmESbqtZj1okcz61R5tfN9jOGOhBDSjTwM4NeI/2f01wDuB/AjXUEhxBQAUwDg0EMP7a7+FQTOmSXESVE4aR05Jg4pDwttaGJrxGxOlJcQjEmJO177CHUNLVi/o9mV3dE54M80Bb+jLtdAPhqTnvUt/XQPLn7sg7REIyqmwjYTs0hX1r3PyoeTZhDuCADhUPCC1DbqjwBSppZy8BKpQeu1ZUJmTlprYofH59Yru+PuDYa9sZ20Xs7dOScOoUgjhBBTpJSfSSljUkoLwGMATvAp+6iUcryUcvzgwYO7r5OEkIJTFCLNL3GII9zRY6G08nBIO1hv6zRzCDxFmpUarAuRnnRCFVp+CyO7ic9JS713C7KIZQWK033t3gProJ7YLlEm7p/uHrlDDdUyJuu56TBJHAKoIi24zs5YSvTI1AwwT7fSknkIBbXb1vwA4f5RIj3c0ctJiwKhxJxEdTFrU+xrKnOLtGxS8FOkEUJINgghDlHengtgTaH6QggpXopDpPk4ac5M3/qBc1lIaB2Ylg5TJ81rf0qIhVwqzbKkS2iZD1RXbt7rEGZuQeDnpNmYzM/zXFpApmdJDEJXUreAuE024Y5S+gtMVaSVJUSaeo2tnVHHfDUb9fPlCHdUBLizHzIjl9GPvy3ZDAAIKW2kJw6xDwQ5aZ2pUEXTddJUlsyIC8E0Jy2HOWmhMoo0QgjxQAjxDID3ARwhhKgXQvwYwD1CiNVCiFUATgNwbUE7SQgpSop+TprJvClPJ80w3NFLzFhWSsi4nTR34pBMXKmtje2ODIRuQRaNeafgt/FyFYFUn71uXcySKA9nNu9K76R5l9GJtHBIBN4nP+GofhaSTppS37SX1uCl5VvSznN8vhzPLD9O2qEDq7Fpd6tvmbJwKNmP9HDHxL2KuFLlu4lFgIpqoKPROSctE1bPShdpWYmsRB9DZVwnjRBCPJBSXqzZPaPbO0IIKTmKwkn7+8qtnsdyCXdsNQ539GhbcVRCrrbdA/lM56Q52nEJsni4Y/rAecyw/sntkI+VZnfLc2mBpJNm3kezOWmpbV24Y9hHWPq1Y6PeE12444dbG7XnqeGFEsqctMRud6+sDOeklfk9jATlSpk0kWaaOCQWAcoqEydluVC47gZnFe5o37wwnTRCCCGEkDxTFE6aHyaORllYH+7YahDuePr98xyCol9VGfa1xwfA8ZDGVMWq42ZZzpC4TLM7qrjdwmhMn4JfXSNN+AQ8WtL5mtaePSctzw6IiZOGgEfi97xVd9EWfGr5hqaUu3TaEYPxzscNAJwizdKEmQp3IoyAfrgJGYi0snAI9sWnZXe0NyItiR0+2R3LEunzswl3tElT15mGO4ZSdTDckRBCCCEk7xSFk+aHWXZHDyfNINxxQ0MLarY3AQDu/O4xqK5I6VbVSYtZMi1xiNqmLtW6Ke6ww0hMnzhEdRL9TCmZdMq8wzjVckZ9NEgcoo7Vy8OpDtoLW4cNxIzfpDS1D7q69rSmhMvhB/VJbqtzwCRSAtcWfTonLZN7Y+Kklfk6ae5wR4/PbbRdcdIydb8U3PV7teeFY05aOPPzCSGEEEKILyUh0v66cBPW72jy9I7KwwKWBL4wqDrt3EwICeEQP6qT5q5LzfwYf5+9m5A2J83Sz0lTr99fpPm3F/O4Jj+0RdPCHVUnLZzcriqPb5toNF8nTZM4xKu83SYA/Pat2lSXZUpceqfgzywU1ER8qmXSnbTEsWh7YoeP6LEzM2Yb7gikBNYp1wW3p0URaWWVroW1CSGEEEJIrpREuOPNL61GRTiEvlX67paFQrBkDP2ryrXHvXA7Gu6xtqUM1i1Xxj+3k5bTnLS0xCGWNlukicix+6a+erWXSZd1gs43cYgSQmqHPpYFpOWXad6cE/V5hcP+KfgrPbJLSuWcaMzCc4s3pz0797MOwsRJU++N5zppyU76CP6yisRJeRBpg0cl6spUpEmk1lyrBtr2Zt8XQgghhBCSRkk4aYD/WmrliTlpmThDUkp8sGGXY587OUjMx0mzpDNcMJN10ty46+6MWlrRp4Y7+okI+5Df0gJAZtkdo5r77w4JdCQOUUSSPX/MxHHyc9LUbJ1loZBvedVJU5FSJq+7uSOK/3phVXqZgH64MZmT1tqZ6nu6SHN3wE+kJeakWZFUOv5MUUMVgczDFaVM1VFRDUTbmOGREEIIISSPFL1IM5nrZc9Jk9I/DFDllRVb8e+PL3Lsc+ePUB0VSzp9nvRwx+wHqW5B1hG10jI+Ak4nzU9EmDppHT7C1+sclfR10lQnLdVZu98mjpPfWL9NETp2VWp5xzw4T5GWCnNs7tC7UdLKbL6eyXUd0r8quZ0W7ihdX0PfcEdlTtrBR5t1MORyoG2BFU44zxm7cjJ148t7x1/tUE1CCCGEEJIzRS/S/NZQsykLi2T4oUmad0Cfrt3t9MSsVAKJmJUu4JzhjtnPSXPPZ2uPxBDR1Kc6aX6i0O6W3zppALCzyXytLZ2z596jzvEqV0IbbafJ7VS62bS71ZGJ0Y3qRiWdNEsVhqk2vcMdZfL6W7xEGjJLwR/kEN79b6MdiUyCwx0DnC0Rigsr06yKXiLN3p9puKNURFpFws2763OZ1UEIIYQQQjzJi0gTQnxLCPGxEGK9EGJqPuq06YimBpBeY/y4kxYXCSahZ0BqjSyVkBBOt0xZLystu6MloeqoHIw0uE2zjqhHdke1fb9wx+Ri1h7ZHRP7GzIRaRpnb19bxOFueYY7hszCHdsj8RvqVUwNd7Q/C2qb5UqbXuGOlkwJuxaPJRoyXczaFoxefH5gtUOgpmd3dHfARzRJGRdXsUj+RFrG4Y5Wqo5sQy4JIYQQQognOYs0IUQYwB8AnAHgKAAXCyGOyrVeGyMnLSQgE6GJpk6abhDuDneU0hU6qIY3ZjiQ98M936s9EtM6VyHHnLTUcXdR03XSMhJpGmdv1tJ6TPrtu6l2VVdLMyfNJCwQ8BZzqiBMtqncB7X+Ki8nzSTcMcPFrIN+GOhVHnY8u4g73NH9mfUTX1YsLq6sqLkD5hZplkuk/esBs3pSHUTyy1DRO8NzCSGEEEJIEPnI7ngCgPVSyg0AIIR4FsA5AD7KpJJvHHkQ3lq7I22/Hf7m58JUlIWSST6M1uKC3mXSJw5JbbvPz1euBLcQ7Yha2kQdaveSGRotiX3tzoWNTZy0ts4YmjxEio5bXlmj3b95d5vSbmq/KtLsfps+m3hYZ3rfVZFmX79aSn1GnnPSkHJAvcIdj7/zLe1i3F4Eic/qijKHDeoO6bQsV1t+zpa0pMaUrAAAIABJREFUgFB5XKCZfgDb1eyLMt1J62wyqydZhaSTRgghhBDSheQj3HEogM3K+/rEvoyoLNMPqm1HKT4O1g+GK8vCiFrxuUamQkDnlLjXSXPOSdMlDsmPSnMnkmiPxLThjqqItA8/NG+9Z/ict5MG7Gw2d9EA4P/W7wos45WC3zTcMVneww1VFyePSYmQ8HYUvZy0aEwm77eXSAPMHNxkfwNFmtNJS0sckraatk/b0opnZbQyCHfU1QGRyu6YeQXKnDQ6aYQQQggh+abb1kkTQkwBMAUAKj53eNrxIOci5OGu2OfGBZWZEJBSahcyDgm3EErJsrTFrGUeRZrOSdOm4E9t2+Lk3XUNaeWkq4ybmMZ9ywfOxayVxCEZpOD3K9fWmRJVliUREsLRpmXgpKnitEUTPmnK0UP6IWZJ1GxvCnTSqsrDjnl26aI6g8Qh0kqFO2Yj0l69Ov4qwvEEJNlAJ40QQgghpEvJh5O2BcDnlffDEvscSCkflVKOl1KO11XilY3PJijcsbUzhi172wxFmn6NMCGEw6tzOGmu8Mb4fLXApoxwh7+1R2LaRB2O7I6JznxhUMrJ+Pnphyf6Zs+j07dnSYnm9hwWQ/bAkcQjByfNa1php3JP4k6acC6D4OHkqTz5/qfJbT8nLYihB/TCiAPj9z5oTprbSdvb6hTIaSLNN3FILJ4630Sk+QkoEcpepAHOddIIIYQQQkheyYdIWwxgpBBihBCiAsD3APw900qCnLR4CJxXuGN6kgo/3OnzbULCKYQsRYi5RZ0q4LLFXtdLdVbCIZFw0tIH4M510uKvQw7oBQD4wqBqTPnaYYlj9nwt7zlpTV0g0qSHSMqXk6bO07OsuJhzOGlqEpGwf1uDeldo3UqV/r3KPY8JxXU1cdLUj6U7YUl6Cn6TcMdYcFbGij7ex0Qo7qZlg1QSh5Qz3JEQQgghJN/kLNKklFEAPwXwJoC1AJ6TUn6YaT1BTppbe913wRjl3NRg00QIWNI7Bb/azo6mdjS2xV2PmHSl4M8wA6AOW8ioywz0rSrD1r1t2kW8nSn4nYuhPfMfX0lb4Nkvu6NXZsNc8ErBbztNptkdvdZTU0VVLBHu6Fi7TnmmvTzCHW0G96006If3MQFhnBAlHBK+a8Q5nlOoLCDcMYMU/JVBIi3g63/aL4EvnqbrBJ00QgghhJAuJC9z0qSUcwDMyaUOXeKQcEgk54KFQ04BdcTBfZPbTkEQ3JYl9S5YKOQUCC8uS0VtRmLOtcssw8QhRxzcFx9/ps+eFw6JpHNms7c1gtfXbNeWd8yXS/QlakmUhQSGHNArmf1w6ad70Nga0YZ0AgknrUtEmlcK/vhr0GLWNl4Opeqk2YlD7Gvc2dyBzpiFK79+GL47dig+P9BfPBzUrwo12/2zGvr1Vyiuq4n49CoiBBBTfysp722wTlq+wh0D+j3mIqDXAcCGd9L7kBRpPkKQEEIIIYRkRbclDglCF+6oiiK3W6GOLzMNdwS81kkTnuPWu1//2Nk3w8Qhfaq8b3EoJFAWEsaZBN2hmCNumg0pgaryUOJ4/Njcjz7DZ48vxIMXH6etJ2Yh73PSnluyGf/1/Krke112R9O09l4OoOqkVVeE0d4ZS5Ydf+dbAOKC6YjP9dWd7uDAPhWBZYTPZykkRFJ4mbi3wiNUtywknOGOFdUB4Y4x88Qhft+FkEHikHCFvoy0UnZtn4P86yCEEEIIIRmTjzlpeSEo3NHtaqjvHfOfjMIdJTTRhAgL77C07fvaXXWYLVNlzzs7+bBBacdCQqAiHEpLye6F2jVLSWRSlrAP1b6v3tLoOSctZkk0tUeMww9NmPl/Gx3vneukibT++eElftUQ0MF9KgGRXta0jYHVwSLN9/Yoc9JM2vRyeN3JT1DeK8BJs+ekRVOhj5599PlOCcMU/NprUz78fu0TQgghhJCsKCmRpg4X1UGvmiTCZIhueWR3dLfhRyRqGTlpdpbDow7pp2kv3nfT/COOxCEal1EdTwv34F/BkvE5aX4uX6a4m3Jkd0yKGcO6vJw0RcwO7lupFUemyUkG9Qmek+bn/Amk7reJ2PVy5cIhgU5EsT0cjt/D8t4GiUMSTpoVi7tdvr30OuQzJ+2Me4CTfw70OdjDSVMSh+SSIZIQQgghhGgpmhGW17pWNuGQcAgBNaxRHSSb6B3/7I4GFQBobIsYJQ6xXT7dumxCCIeYAYC5134VR2oEHeAMmXOmu093dGKWxCPz6rT12IlDelfkUaS5rs8xJy0pInNz0tTw1wP7VKKxLYKZCzbik50tyf0mGm3at49Er/Lgj77Z2n1A2GAipFe3wkJgaWw5vnnoUESAuJMmY/F5Z0D6vDJpOVPwh70zUPp+mKX0FlgHHQlM+nXifC8nzQpugxBCCCGEZEXRiDSvda1s3GNBdcCvDpLdDtkxQ9MFj7T85qSZDTr3tEaMnDR7oK9dlw1IE2lfOrgvjjxEP6dK1QJq20kR5Cr/tyWbtfXEpEQkJo3niJngvhW6EFTT4bzXbY0o6RvPOOZzye331u9Ma8uPUEig3ODagz6TdlNB6f4B7x8PQiEByPgPFO0hkQp3DJcDJ/8s7mipWIk5aTFbpAU4aX0OBg48Iv1QtMNbpKn71e9DWS9g4BediUMggEtf8+kDIYQQQgjJlKIRaZUBzkY45Ap3VMeOyhu3Y3XMkP74x7VfdeyzpPRIwW8uJPa2dhqtk2aLMJ3rFhJCO8DXZboEnML0Z88sT27bc9JMTQ3LkojGrLzOSXPPf6soS9VtN5Ozk5aYk/bslK/g5MMPTKsfcDqsV3zti9p6ykIC5Qbul+k8Sb/Lqq6IP0uvz0pZSEDIuKPZIQRQ0TvupEkLgADCLrfTMSfNSjluOkQIuP5j4KeL0o9F2wxFmrI9bRswYAQcc9JECBhxKtdLI4QQQgjJI0Uz6z/ItXBnbVRD+1Sh414DOhQS6OdalNg7Bb93dsde5WG0RVIJHfa0dqa1paPcN9wx3UkDgAoPZ8YzZC7DcMKYFXfSygLueSa4L099PmEDMeNXl00koXSrXKGxqnxX2/3RhBH447sb0uoJhfTi2E2Q02g35ZU4ZNG0icm+el1TKCQAK/41bBe2k2alwhHdIiyZgr/VLNzR76abiDT1U2fXJzXhjiZJSAghhBBCiBEFddJGHpRaY0k3J+0gZcFhdxibmiBC3XaLL507JqEXTSElY99XvjjQdY6z/F7jcMd4fbpwRynj63u58RJbXmLARHCoWFIiErM8xWA2uO9FWSg93NHUuNM9GyCVOMRdjVqv+jnxmwdmIlCDRZp/GOfgPpXoVxUXUZ4iTQBCxss81a8fUFaVctKESBdhZ9ytpODPIXEIkLmTlqxTkzikCBKICCHCQojlQojXEu9HCCEWCiHWCyH+JoQITulJCCGEEFIEFHRkdctZRyW3daFlP584MrntTurhmCqjzknTOTqusWo8cUh6f1Rx9MXBzkV6I66c/XvbIo5EFl7YAtKr7N7WSNo+r9A4L1Mk07DFmAVELSu/TprrvdrXpJNmGEzqvZi1TKs7vS31gL7+spAwEqimc9K8notzXTufz0piTtoz/fuiXkYSLpXGSavqDwyfoIg06S/SgqzLTOek2cccTlqibHE4aVcDWKu8vxvAA1LKwwHsAfDjgvSKEEIIISRDCirSQkIkMxPqXAt1fOi3TlrYZ05aSLP2mfRJwW+XdYtGt8iKWRItnT7rWSWwBaSXO6TDM8mEZxr3zB6jnTikLCRwy1lHYUj/KuNzH/6+foFs9+WposTunvGcOVdd/XuV49CB1cnEIW6xp4ohp5Pm4UiGhEPYe2Ga3dFEfPrqeSslxB5q34hdXnPSVEGUzO7oF7GcrUgT3mWEALatAFp3OdsQhRVpQohhAM4E8KfEewHgdADPJ4o8AeC7hekdIYQQQkhmFFikAYN6x0MadU6aOvgNh1LriYVDTuFVrrgibhdGY6QZpeB3z3vS0RkNnpRmu1w6Uehm1W2TAHiHxnmJnPJMwx0TiUMqykL48Skj8Jt/O9b4XK8+uO+7lMAvJn0JL/7k5IwWfdbx7dGHoLIslBTKaeaOsq224WUwlhnPSfP/DKSuK7Aqz4XFAUDKlNB6tXM7vn5QNWb064MN0SZEVfFjCyZHCn4fJy3I3fI67jUnDQBad8dfX7vWWbbw4Y6/BfBfAOwv5SAAe6WU0cT7egBDC9ExQgghhJBMKejISgiBgb3jg0xdOKAQKZcsHBLJ7T9ccpwjHb3DSbPSnTT3HC9LOp2ekw8bBADoXVnm6aQB6WKoMxrspCXDHQ2MtOT8JY8BvZdjY7qAs00ycUiGqfEB7/ly7sdXXhbCT08fieMOHZDqX9ZT4CTCIZEWcmoTVRpXRZrn3L5Q+vp0OoyXhTARnz7PX1jpyT9+O/AAnLP9dZz80e9wySEH4/ZBA/Bcr3KsbFiJViGAWCQ4u+Po8/37lE24Y7RdX7aA4Y5CiLMA7JBSLs3y/ClCiCVCiCUNDQ157h0hhBBCSOYUNLtjSADnjB2Cj7btwwG90h0Bgfh8phhkfA0zABccPwzfOuZzjoQb/nPS0p0Oy5KOzIwzLz8Bn+xswRcP7O3rpJWHQ4jEUsKsw8BJCwc4aT897XD87zvrA+sB/J2hICrLQsn+xhKJQ+w5aZkYXLqi01+vcYjjy04ejqEH9Eq+D+fopAFOIequp13JuqnqKr/EIUYizSfcMf55NBe5vhpdOr+Gz23ZhogQ2Dj6XKwNW/j403fxZu/eeD4cAub8AALA8L4WRlX0xahwC0b1qsIRHZ0Y5E43Ou6H/p3KRqS5r8Q+XthwxwkAzhZCfBtAFYB+AH4H4AAhRFnCTRsGYIvuZCnlowAeBYDx48ebxyUTQgghhHQRhRVpIYEpX/0izj1uKA7qmz4vKumkxeIJIdTRkz1QL1McNiA9QUMoJNIcqFPveQfHf2FA8n15WOCIz/VNtJnupNlZx91iyESk2ULIK3HIeccNTRNpmYY7BjlpMy//MmYtqcfs1dsAJMIdLZl0Bk0TegB6ofXIu3WO998d54wqC8qCGIT73ru7oC6N4HTS9PWFDcMdg9ZJC2pHxS9xiJQpN+yDgaej9yczAQDH9jkMZx80Clg4CxLAtv6HYO2//QE1Sx7Fx58txYrKcryOPcDnDgIAHBSN4ojOCEZ1dmJURydGtWzDsL7DEDJKte+133VxaRlibCetcKa8lPImADcBgBDi6wB+IaX8vhBiFoDzATwL4FIArxSsk4QQQgghGVBwJ00IoRVoQFw8ONPrKz/cJ/b1Kg+75qS52xDasag6aFbD4uwt1Umzi7rdlw6TcEdhhzvqB+k6gTUqIRiH9K/C1sZUeJlnCv6AAbI7w2XUijtp5dk4aQZl3Zdk37YcjDRnQhBXPe2dHiLNJzzUZDHrXNdJU/FN7qiEO/bet01pIJSccyYADJEhDDl0IibWrwVWvQEAaPzSZNRsmoeaigp8XFGBtZXlWFDdHzEAeOlM9C7vjSMGHIFRAwdgVGcnjujsxOGdEVTY9WsvzCcFv/T4YaLAiUM8uBHAs0KIOwEsBzCjwP0hhBBCCDGiICItNZUnKPsccMc5R+O651YmRZM98LbHvEMH9AqYk6Z3cLycrVS4Y/oAdldLp+N9R8TESfMPd9SJtB985QsYPewAPLtoE55dvFnpnL6NoKUAhHAKieaOKKIxmRR3OWgnLW7RYl9jtuGOaU6aq8dtjnBH5ViuiUMMlygwuSr/FPzK13Dvp86K1TlnthCqTq3h17+sF05s78CJ7anw347xl2P9Sf+Bml01qNldg4/3fIyX+/ZGaygu/sukxBc7Ixi1+DcY1a9vUrz1sz9HGYU7Fn5OmoqUch6AeYntDQBOKGR/CCGEEEKyoSAizXTQLgCcd9wwPL1wE0JCOBJqDOxdgd+cNxqnjzoIO/alBqi6FPw6MdjUHk3bZ7cJAFWazH7hkHAIIqNwx2TiEP0gXeeCCSEw9vNxkabidb+CRFpIOGXNnpbOhJOWeUIPk5UE0tcxyzHcMZE4xKt+R7ijTzm1TK5z0gD1x4bAqnznpKlOGiKtSgMhZxih3VAvZaF192LXACqPuwxHDzoaRw86OrnPuq0/NpWVoaayAh9XlGNtRQUWbF+Mvw9Khf0OjURxRGcnRtXOwqi2CRg1cBQ+J13Pzf0BSGZ3LA6RRgghhBDSEyiISAslRZp/OXtwHxJxJ0INdwSAi084FACwqznlcKWn4Bfadva2dqbvREoIVWqcNHfdJin4k4lDNKP0cEj4TuVJD93Ul2sPCLsUruQpu1s6E3PSbCfNXD75OkLJfrqcNFuk5eCkOUSa63hbZ+o5qNep9uOoQ/rho237kv0xWbbANNzR6Lr8jDQoAufivwEPn5SoOBxfuDrZYKI/1apIcyXcOemnwJCxaW2EAAyPRjE8GsW3WhI7f7QCO+/+PGoqKxLhkuWoqajAO7XPQdb+DQDQP9wLoz53UFy81b2KUaEYRkD5w5GM+aRII4QQQgjJF4Vx0ux5WkFhevarEElxoBsPq/t02R11IqSxLaJvM1G0UuOkuXtrMidNXSftiR+dgEsfX+Roy2RR5WR5DzHV3KF3BW3cbuKe1k5EolYy5C+TDP4Gy715hjvmMidNXbDbLYoc2R018wsB4PkrT8JRt76Z7E9ZXlLwm1+Xv7gN4YZde3BCeztw8FHK7rDTobJFWi8fkZbBoukIhXGgZeGUtnac0paa+9j6kwVYhwhqdtegZsM/8HHrv/C3vn3Q8d7NQDVQ8YXPY2SkE6M6Izjik9k4cuhJ+FIuD5cQQgghhDgoaLijV8ihTSoxQ1wceA0/1XGpezAcFkI7iPYSGyn3Lv0k9/g3k+yOUcvC1740GNd+40t44K118b6FhENUBOElploCRJqAU0jsbulExFITh5j3we0m6nD3076Xpq3c/O1R+O85NY59FYrz5e5uk3L9XuGO1RWpj3o8cUhwb8pNszsaXJnfbbMg8O/7mjQVh5xO2qDD4q+9UiGK6YtZezR07h+Bl65Ir19DdXlvjB0wHGMPGguI/sCi5xEF8MnVS1Dzt4vwcecu1FRU4K3qXnhh1UPAqocg9Ll/CCGEEEJIFhQkb7Y9aA9ygFKZHAVkItwxaKg/5atfdLYV0os0zzYTr14LSqvY4Y6/v3icZ5lhA+LrhZ1y+IEAgKu/MRL3/Nux8b4JgbBB2F2qc/qyLR3+jp57GYI9rZFE4pDMHS4TJ80t+kJJsR3c0HfGDMGwAdWOfRLOzJruWuavSy1AbJzd0cBJU4Xc29d/zbOcWbSj942zvD7T/7+9O4+Wq67yBf7ddafkZp5zyb1JIAkJIWQgNyEhSAYCJAQJCImgTILmIaBAy8OAPu3Gho4KdvuUtTQtNPikUWyg4ZknEGj60aynyNDMEECMGAQC0kwKIcnd749zTtWpU2ce6pyq+/2slXVvnTrDruFWzq79O/snLdXDCE/8kfFzwLDKMuc1aV7Z4JyTgX0Oduw/zJ+/EVsrgGkjpuHjuwUXv/U2fvTaTvzHy6/g7qN/gu+t+B4+v7fTfzdEREREFFouSdo+wwfihHkTsGLGWN/1rJPsUqly7ul2QmydAM8YPwSrZ3VV78NjuKOX8km+7Vz3+s8scF3XqqTZJ252mjiyE7++9Aicu2xqVUzWT7+JqMMkikCY4Y7V1a13P9jtuCatotc2f5ybMNekOTtWRhnu6NaNU9WRpPnsqMWlz4ZbfGG6O9qrcoM6aovO5YQ+xMvktY5RIfZphW8laV1zKslZS2slwappHOITTE1HF4/j2oN1rtNX+UJAAHQNGo9lPcvweR3qfVwion5KRK4TkZ0i8pRt2UgR2SoiL5g//f/jJaJ+KZckra1F8PefnFs1F5kb+zxURnLgfgI6dIBxojq7e1jNCX7JY7hj0DHtFSOva5Osa9IGdXg/DhHB+GEDqk74raSlRcS3uuQ8sQ8z1NAjiqrj/JfZNKU8mbV515Qxg7A8IHEO1zjEcbucpIVIjDy6cdqbeFj33nruoTXr+R3DustoHBL81vebQFvsgYTgVYGsVIhdlEqVa9L6HNXSDjMpqhnu6Cdkkmb/O3M+cHXEwcYhRER+rgewyrFsI4B7VXUagHvN20REVXJJ0qISETz68tt48/2PXM+Le0Z24rZzD8Xla2fV3GdUkaJX0uxVLK9rk6zhjoNdqizl2H2OURLxraQ5BTVa8WJMGl65be2m0jzDHNIWoolJmDzRu7sjMG3sYN9tRVzyAqijkmb8PHjiCPSMHOhcuWY9Z1wtpXDPe3VHyWQVT68Eu0+BPt9KmvneciZp5apabQv+0Lz+Lqpidb4YbMFPRBSWqt4P4C3H4rUAbjB/vwHA8XUNiogaQi6NQ8Jym1/L67xy3sQRrvc75wgLPqbxs0+Bi4/aH9PHD/U8obeGOw4b2Iar1s3BxT9/3HN/bstKJamqsAXxStL++uMzXZdbvKpTzo6ZLSX/yp59Gz+1r4G5HMDPz1mMuZdv9Y/V/H3a2MF4Yef7OOngbtz19GtV61icFTF7wuR8LCUB9sJs2OLyvF981P646u7ny7ft67i9TOWJ1cMMd/RarhpwTZqVpDmGtA7wqKT5BROnA6NzG2eyWJ7MuiG+7yGqi8kbt2Sy3+2b1mSyX6q7car6qvn7awDGea0oIhsAbACAiRMn1iE0IiqKQp9ZlcoJU/gKkjMliz7c0TrxVpy/YhqOnDmuKhG4/bwl2PLFwwBUKmklEZw0vztUPNb6xs/wcQHuSdq/nrcEZy7Z13c7r8Tr9Xc+NGM0tLYEP1fxWvAbz58CGN7pPzzPqPoZ2/eM7MT2TWtw6NTRnsMTnUNRqy6ncqwrtkqaM2mdMX4IFk8ZXbWstSpJq31ioryv/Cpp6pWklWyNQ2qStOHGz7DdHQGEHp+pfsMdPTqaspJGRBSZqs+1HMb9m1W1V1V7x4wZU8fIiChvhU7S3CoVQXUx59Az+0l/uGOi5pj2BGFOz3CMH2r0G99lS9I89+dyl33YnR/np/YelwwpTAt/+yr2xOOPZpJmJcFGJc1/X3Ems7YmBt8dYsoCwDY/nm2Zfchp1eNxNACpzi9qK2mA+/Ou6j11gPOYzjjD8Epu+1S9kzQpAYPMxHH2+ur7rOGOJUcxPG4lzZ5kDRxeHUPV/r0qaUzSiIhCel1EugDA/Lkz53iIqICKnaTFqKQ5V40ynNB+zKpr0hyJgHUtl9U4xPfc1zVJs+6LFpvb8xCU6FViMLbtsCU7nz7EGDqxZ69xX6ujVb8bt4rQsIHV10U5Q7KO+dHe4CTN66X26u7YUnIOd6yoqaSVr71zSdKgNa9Ha9XcbDGGCnrEVbVcA1rwDxgGXPYqsOzS6vusSlqk5MjnMUww2/N/+pZKYui2jbOSVm5VyiSNiCikOwCcYf5+BoDbc4yFiAqq2Ema+dOenASdKztPhqOeXAdV0oDKELtwlTS3YXJmJS2F4Y6hWsnbYrC6JE4fNwTLphudHPfaKmlxhjs6kzTneX1Hq3ECvztEkuZVcaqazNq23Dkptd97pTxfm0di61dJ88uFw3Td9B7u6HdNmvm+a++sfTBWJe2jPzuP5B2E34u77gZg+VeBqUe4x1DevTNJYyWNiMiLiNwE4FcApovIDhE5G8AmAEeKyAsAVpq3iYiqJErSRGSdiDwtIn0i0ptWUJX9Gz/9rjNycp4MR73u65iDjHnWptq6EDqTNKuyVknSvPfndpffsDs/bpW0MLsoiWBgmzEszkrS7OfrVvLXWirFahwyvLM6SXN2iSxX0jyGO9qfa69OiW7dHQH/57BmuKNt6gMn1dqhtPbH4Z5sV7YN4j1Pms9wR79mHFaS9sHbwQcv83lth00Alv53l7kGnI1DPJK0UBNjExH1L6p6iqp2qWqbqnar6rWq+idVPUJVp6nqSlV1dn8kIkpcSXsKwCcA3J9CLC6ME8RIwx0dt6O03weAdb09eO4bqzBp1KDyMudwRysxsJKOMHNzucUUVOVzPuy4LfhFKtWu3Xtr92ENdwxTSRs7ZAB+tmFR1ZBBZyXNWd2z5sPb5ZGk/WzDIlxwxDTjhrrXguxJmv019bsmzcla0/WaNNS+VqG7OwL45QUf8z4wat/DsyYY3RlHdLYHV9LcWNeNfehI0tLu7lgz3HGv+/1M0oiIiIhSk+jMSlWfVdVtaQXj5DaxdNTEJmolDUDNJNutjkqaiFR1FfSvpNXeaRVIwjT9sHNrHOJ8vKctmlR7PAGGDTQqaX/etafm/j3lSpp/C/4bzlqIlQeMxSH7jcKMriHl5c4krS1iJa29tVTeR9U1ZVK9Tnm5bZ2aa9J8kpRyJc38edW6OVX3+ydp3pU0ADiga6jncY24qm9ftHJ/PHP50Rjc0Qr1nCfNZwihdU3ah+84j+QTRYw/Bg53JCIiIqq7Qn/97XZNWjDncMdkDR+A2jbvQCXxMCZfjlZJs9YPmlrKOfSvzy1Jc9z+m+MOdD3eMHNI4i6X6t9ecwhbUAv+pfuPsc1dV1lxyIDqDoPOSpXV3dGrcUhJKvOWeb3WVa+BbffOJiB+75TyROXmMU6a340bzlpYXlY7dUC41zXM23PiyM7qWEqCzvZW+PZe9kt8xs4wf/rPkZdY4DxpbBxCRERElLbAJE1E7hGRp1z+rY1yIBHZICIPi8jDb7zxRthtAFSfBEdL2NJJ0pzDHYFKZSeoGuZ2r7UsamwuIxVruDXFKInUNvew2WO7Ji1OF0NnEut8voIah5SkMqm3Z3fHVnvjkMrvzkTKmTDajRncYWzv0hBEUft6BM6T5nmkWn993IHYfNp8TB9nVCCt943ROMSrkubz59k1Bzj3QWDJBdXLU5/MmpU0IiIionoLTNLMi1pnufyL1DI2zoSMlU6LlRPPoOuyalvwV9++dPWMUMe2c6v11+5TAAAe3klEQVSoWJU0+8l794iBtRu7nBdbIYZN0rpHDMTV6+aUK2krZozFxtUzsP+4wTUVGjcClw6MNnN7jKFz6xf0xBoe6jYc1C5ouKNIJWlRuA9Z9GwcYt44Z+kUfPfkuThs6mjnpmXXn7UAV55wEEYOqkwAXX4NNPo1aRavZid2A9tbcNSB48vHaLFlh74t+P2MneGSHIVI0kZMBk68NihkayPH7j3mSWMljYiIiCg1xR7uaJ4f7rWdtO8JKCc5c7goQ9i84/CupNmTwNvPW4I7zl/ie3ygMmwxbCgXrtwfJ87vLieo6+Z345ylU3D3RUtrrp9zUxLBfqONDoqL9xsFoPrUu3tEJ7ZvWmMMZ4xx3VJri+Aba2uHWVqsGN2algBmkmY+j9UJWiWWqiTNsS0AdLa3YO3cCb6VwK5hA/Epc2445/ZGJa16fft7xXW/Caq09jkAfSezjmq/ZX5HNX587EvAQSeF219QJc3a5+EXh9sfEREREQVK2oL/BBHZAWAxgC0icleiYBznquUTWdt5oVvzDDtnFaamDXsKwx+ByhA++/5GDe7A7O7h1cd32dZ6CIEJo+OhWo89zgTdIwa148UrVmPD0v181w27a/vT2FqS8tQFboIqacY1acY61Q+5cqvdo7tjTWUqourr1LwTev950qIftzLcEfFa8LvZ+DJw4AnB69kTr1IbcOAnfNYN2pe5wqgpwcclIiIiolC8L+AJQVVvA3BbSrEYCZV9MmJbi3NL0DVpznsPmjCs6naYyZ/DCH1Nmsv9VkUs7PVfzgYqUbtCWklda0upnOx47SJODhs0v5rVOGTXHmf7djM+EY9KWoXXcEfrPZI4SUP0Slp5OG6M41r7VoSYzDqsAcP87y83+bDt92tvBuw04HlN6UsPIiIiIqoo1HDHmtM9ayia7cTdq/mE0/RxQ/DAl5dj39GDqpbHraRdecJBuP28ylDGDpdJod24V9LiJVtWchc1IbGvbTXD8E7SoiWOgNEoxDdJM6uO3pU0e0XL/Sj2ZiRVQzLNX51dHsMqXxqmtY/duc+tFx2OUxdVhkuWV49RSrOO1dcHn8YhaV/n5ZKkBW5SqI8IIiIion6hUGdgzhN9ZwUJCN84ZFhnG7pH1DbViHsy/6lDJmJOT2UoY7mSFrA/t9zFejzBLfi9totYSbMF0dbqf9DQSaxtvZZSyfexlIc7eiTYYmvBrx6TWVdVQF1CjJt8lzuIQmsqac59Ths3BL2TRsY6jpP9fROrBX8cbpW0sNsQERERUd0UKklznnxbJ9D2xCzwmjT4N+WImuB46QibpLlkFHvLjUNCVq2sBiq2SaejsK9uVe+8GoTEeXaCJsG2Goe0+mRyLbZkqRyLPS9zuQ4NqMQbdxhrqWpfjkpaSkNj7cpz5GXVOMT/6I6fYTYp1kcEERERUX9QqDMw56mj22iysJU0ryQkbiXNqb083DH6eEcrxqAEz3l91sbVMzBj/JByy/zQXA7jFXbUXhWAkcz4JWktJcElq6bjXz6/2HMdK3n2enmrmoUE3B+FfZhlTQt+l31WJZEu10xGPW6fS8OSygGyqqRFea5YSSMiIiKqt0SNQ9JWM9zRul7Itiy4u2P1tk5xG0w4WddZBTcOqV0Wt5I2u3s47rzw8PBBmuzHCUoo4rXgLwWe95+7bGrAcQ1ejUPsL1t1d8eUGocEzJPmJLC9P+NkaQixbVaVNA53JCIi6ncmb9yS2b63b1qT2b77q0Ilac7zQSth6KuaJy1c4xDPSpHtjh+eNr9cEYuqMpl1QBwuy8rXlpmx/PC0+YHzvyVRlaSZx/YKO/Qlabbf20qSOPkVW7Lkxq3tvl3c44tH8gf4D88Eap/Df/rMArSVSjj12gdDb/Otk2bjqru3AX9yWTlOWdNPrGvSClVsJyIiIuoXipWkOW/brtuxBFXSRg9pBwDM2se9Hbl9uOPRB46PHqSpMpm1f3LgVi1bM7sL//78G7hk1fTEcYRhD9G6Pmzs0AGu64bt7mjX2uLfgj+MciUN7omaW9t9+3ZRO2W67tfZOCRkfmINgVw+fWzk4y+bPhbLpo8FrhxcOyF0VglSpP2ykkZERERUb8VK0ry6O9qKZ30BSdqM8UNx+3lLcOA+Q13vT69xSO1k1m7c7u5sb8U1nzo48Bhp1dbsSc0BXUPxrRNneyaGcSezTvq0WgmRVs2TZ4/Lo3GIVG8f+bi2yawjV9JiDHf0fLtc9orLygVswb/+x8DNp6cXEhERERHVKFaS5rGgap60gCQNQFWrfKe0G4fE6e4YVdJ91JxnL+jxXDdORay1RWJV4OwqQ1vd709aqfNin8zaeYTg6RXc7/9kbw9GDW5PIbgCtuCfuTa9eIiIiIjIVbGSNM9r0irL9vaFuybNS9ot+IP2liS3OPuwffHLJ1/DoVNHxd8JoiU4ccINqjhFObBXCl5yqZ7ZNovdvMNvMuu417l986TZgeuEijezFvxRNuE1aURERET1VrAkzb27Y3XjkGSDAONeu+RkVdL6krT2CzC7eziev2J14v1EyTXcqkMzxg/But7q6ltV45AU5hOr7u5Y+5za43Lr7hj3ZbBPZq2O44Z93qIcOlr3+4wqaZrsi46yeaemsx8iIiIiqlKoJM15Uly+Ji3CPGlB0hruaFVZAlvaF6DvQpThkm7xnrt8Ko6bs4/nNpNGDYoTVhW3al9150Xbcrj/7mV2t3sTGft+VWvfW2GHcGaWp4d983zmTuCDt8Ls0PyZxkV0AHrPDr8fIiIiIgqtUElabSWt0tTBkjRJS2uetNby5Mv+8aRxTVpSURJFt2TJ7SmzXpuLVu6PqWMHx4rrF184DM+8+m5VjH2qrkmPW/XMzutVeOxrR5Y7WrqxX5MWtUpbmccv/HanL5qMS255At0jBgavHPaatEnek4RXifONgd9wRw6FJCIiIspEoc6y0mjBH2TIgLZE21vKlbSAcIpQSYtyTZprQuaTaHYNc2/lH8asCcOw3hxGaR0j1Dxp1cGZ27lvOLyzPVySpkD3iIE4a8m+vjHbDxMnAV+/oAfbN63BiEEhGouk3t3RFKn05/MYi/DmJiIiImpCxUrSvFrwpzjcMZWue6hU0gKTtFSOlky0a9LCLQtzXxT2dvZBMXjNmZbkuIBCRPC1j88MuZ3tuJkNd8zqzzPKcEdW0oiIiIjqrVBnWTXdHV0racmaHgzvTKuSZjx1XhUcS1at46OI0h7fbV2/rZO23nceQ+Ex3NGWaUYZ7hgkSbfPzF/arFrwpzKxG5ikEREREWWkUGdZXumB/ZwyaXdHaxLqpCrXpPmvl0eOduzsrqrbkSppbstch0B6rx+HW5dGe5XM6zEkfX7dWvgvmDwi0j4y6++ZdhJU3l9KlbRC1ImJiIiImk+hGoc4q05ZXJOWlkp3x4DGITlkaX//ybm4fO0sHPyNrZFjcK2k+WyfxXDHhfuOREdrCZ87fL/y/YEVydjzpNXu9yefPQS79gRXbDN/ZVO/Ji1GJc33mrRCfcfTVCZv3JJ3CERERJSjQiVptZNZG+xJWl9BkrTWlnCVtDy0tZQwMkxjChdu3Sr9qmv21+z0xZOwYPLIWMfdZ5jR7XDxlFEYNbgD2/62en44rxzNPkwyjnILftuyjtaWcsW1tSSBXwwEDXmNLbMEP63hjqykEREREWWhUEmaVdUQsRpIGLc3fWI2vn7H03jng93YnfCaNAC47szexPsouQzPawZ7XYaTul+nJlU/AeDytbNiH3fiqE488OXl5WTNyauStn5BD37+yA4s3m90rOO6TfNg9/8uXYF3/rLbY1uY28Y6dLBCXJPGxiFERERE9VaoJM0iML7rt07Lj583AasPGo/pX70zcXdHAFgxY1zifVS6O9bGc87SKfjB//1t4mPkwaoarZgxFn96fxce3/FOQOOQ6Me456+W4qlX3qlZ3j2i03MbryRtweSR2L5pTfQgyvs1fnq9q8YOGYCxQ9ynGThk31EAgGXTx8Y+vq+shjumtQ2TNCIiIqJMFOosqzKEzvjFfmLeZnZTHD24o+5xufGbFHvj6hl1jCRdVvfMAW0lDGw3kgT/EW/RT/ynjh2M4+dNiLRNSnOQu+w3fkV0Ts9wvHTlMThsWrwqXqDUG4ekPJk1EREREWWiUJW0cpLmuA0YrdK/e/JczJ8UrfNeVqxr0oo82vGuCw/HQ9vfirSNValsKZXQ1mKcoPs17ajXVUlZNWCpjACMeU1bVtkjkP5wR0uTteAXkR4APwYwDsaf5GZV/a6IjATwMwCTAWwHsF5V/yuvOImIiIjCKlaSFnDKv3ZutOpLlqx50twabRTF9PFDMH38kEjbWFMctJaknKS5PkaXxiFZyioXst5zYV/Fur7cWbXg1wjXdTZAkgZgD4AvqeqjIjIEwCMishXAmQDuVdVNIrIRwEYAX84xTiIiokCN2OE3q5iTXNLS6ApzlgV4T2ZdRJVr0nIOJGVWJc1I0ozHuHuv90l9UGKdlsymMqi0hyyezK5JS6sFfzH+QFX1VVV91Pz9PQDPApgAYC2AG8zVbgBwfD4REhEREUVTqCStfH2QebteCUAcLeXJrIt4dh+f1TiktaVSSfvIreOj9bPRK2kBjUM8t0s9EreDpHyUEZOMn52j0omhOJW0MhGZDGAegAcBjFPVV827XoMxHNJtmw0i8rCIPPzGG2/UJU4iIiIiPwUb7miwrg8qyBf1rlqD2gI2KKtxSEtJ0G4mabt9Jnau10sUOJl1TM73XKGk/ZiXfhnYZx4wdWWEGPwSsWL9gYrIYAC3ALhQVd+1V19VVUXE9UVW1c0ANgNAb29vAd8IRERE1N8U6qtw65zK6rJf5CStWStpKw8Yh47WEk5dNKncHMVtuKOzE2fWMhvtaHUSzbIBSFSf/TcjoUpbSxswY03EJ7MxKmki0gYjQbtRVW81F78uIl3m/V0AduYVHxEREVEUxaqkOU4eizzcsdVsHNJcKRqwz/CB2Pa3qwGgPNxxt8/cdPUb7pjNgQa1t+D85VNx7JyuTPYfS/d8418RNMBk1mJ8cFwL4FlV/Y7trjsAnAFgk/nz9hzCIyIiIoqsWEma83Zxc7SmraTZtfWH4Y4iuPjo6Znsuyn4T5JXvzj8LQFwGoAnReQxc9llMJKzm0XkbAC/B7A+p/iIiGqIyHYA7wHYC2CPqvbmGxERFUmiJE1Evg3g4wA+AvBbAJ9R1bfj7s95Il6YU0AX5XnSmjdHQ3urmaS5DXc0X516DXcs0mjEfqUBKmmq+gC8Py6OqGcsREQRLVfVN/MOgoiKJ+lZ1lYAs1R1NoDnAVyaZGfF+WI+mFVJa+IcLWQL/vqoVzJITo1xTRoRERFRM0lUSVPVu203fw3gpCT7a6QT8co8ac2bpm342BS8/NYHOP3QyTX3VRqH1DcmqjO+wEREWVEAd5udZ39odpqtIiIbAGwAgIkTJ9Y5vFqNOMkyUaNK86vwswD80uvOMHMRNeI1aU2co2FYZxu+d8o8DB3Q5rlOVteKUUE0wHBHIqIGdZiqHgxgNYDzRORw5wqqullVe1W1d8yYMfWPkIhyE3iWJSL3iMhTLv/W2tb5CoA9AG702k+YD5pGOt/vD41DQmmg1ywN/e/V5nBHIqIsqOor5s+dAG4DsDDfiIioSAKHO6qq78y3InImgGMBHKEJx/5988TZ+NZd27D9zT/j5bf+kmRXmesP16SF0c9ytIr+8sCtb07aOr3vIyKiSERkEICSqr5n/n4UgMtzDouICiTRV+EisgrAJQCOU9XEWdWsCcPw47MWlhtWFFl5nrR+mqXVezJryokIcPTfAZ+7z+U+VtKIiGIaB+ABEXkcwG8AbFHVO3OOiYgKJOk8ad8H0AFgq3my/mtVPSdpUI2Q97QE9IQf3tmGt/+yu07R1F+5BX/OcVAdLD7X4w6++kREcajqSwDm5B0HERVX0u6OU9MKxF1xTwJbA5K0e/5qKd54b1edoiHKAStpRERERJlIWknrt4IqaaMHd2D04I46RVN/HOVITNKIiIiIssGzrJiCKmlETY+ZOhEREVEmmKTFFFRJI2p6rKQRERERZaKYwx0z6Bxy9bo5eO/D9Bp5WF0NT188KbV9NqJGaPJCGWGSRkRERJSJYiZppjRHU504vzu9nZleuvIYjvii/otvfiIiIqJM8KvwBEol6ffzhCWcv7zhrJ41HisPGIuLj5qedyhERERE1KQKXUmj4rKS0/6VogGDOlrxozMW5B0GERERETUxVtKIiIiIiIgKpJBJWn+rzhAREREREVkKmaRZ+vfVXsXG14aIiIiIKBuFTtKoAbDsSURERESUKjYOoVj6eVNLIiKiwpq8cUveIRBRQqykUSLKUhoRERERUaoKmaT1t7m3iBqKtOQdAREREVFTK+Rwx6vXz8HVdz+PnpGdeYdCRE5feBjY+VzeURARERE1rUImafMnjcQ/f25R3mGQD+uSNBY9+6GR+xn/iIiIiCgThRzuSMUn7BxCRERERJQJJmmUCCtpRERERETpKuRwRyo+1tGIiOory7bq2zetyWzfREQUHStplAgLaURERERE6WKSRkREREREVCBM0oiIiIiIiAqESRrFwuaORERERETZYJJGiSjbOxIRERERpYpJGsVywrxuAMABXUNzjoSIiIiIqLmwBT/FsmZ2F9bMZstmIiIiIqK0sZJGRERERERUIKykUcO46XOLsKevL+8wiIiIiIgyxSSNGsbiKaPyDoGIiIiIKHOJkjQR+QaAtQD6AOwEcKaq/jGNwIiIim7yxi15h0BERERNKGkl7duq+j8AQES+COBrAM5JHBUREREREfVrjfhl6PZN6TTWS9Q4RFXftd0cBICTZhERERERESWQ+Jo0EbkCwOkA3gGw3Ge9DQA2AMDEiROTHpaIiIiIiKgpBVbSROQeEXnK5d9aAFDVr6hqD4AbAZzvtR9V3ayqvaraO2bMmPQeARERERERURMJrKSp6sqQ+7oRwP8B8PVEEREREREREfVjia5JE5FptptrATyXLBwiIiIiIqL+LVGSBmCTOfTxCQBHAbgghZiIiFIjIqtEZJuIvCgiG/OOh4gI4GcTEflL1DhEVU9MKxAiorSJSAuAawAcCWAHgIdE5A5VfSbfyIiKpdHaXKfV4jov/GwioiBJK2lEREW2EMCLqvqSqn4E4KcwhmYTEeWJn01E5CtxC/44HnnkkfdFZFvMzYfBaPdfr+0AYDSAN2Num+S4ecWc9Nh8rrM/bhHjnR5zn1maAOAPtts7ABxiX8E+PQiAJJ9NRZH0b78RNPtjbPbHByR8jPLNyJtMinusjAR+NgGRPp+K+J5hTOEwpnAaJqaIn0+en025JGkAtqlqb5wNRWSzqm4IXjOd7cxtH653vClsGzvmFI7N5zrj4xYxXhF5OM4+86aqmwFszjuOtCT9228Ezf4Ym/3xAf3jMaYh7OdTEZ9PxhQOYwqnP8bUiMMd/3edt0sqyXHzijnpsflcZ3/cRos3L68A6LHd7jaXERHliZ9NROSr4ZI0VY11khh3u6SSHDevmJMem8919sdttHhz9BCAaSKyr4i0AzgZwB05x0RExM8mIvKV13DHRhta1GjxAo0ZM9CYcTdazFnFW7jnQVX3iMj5AO4C0ALgOlV9Ouewsla41yEDzf4Ym/3xAf3jMXrK4LOpiM8nYwqHMYXT72ISVc1y/0RERERERBRBww13JCIiIiIiamZM0oiIiIiIiAok0yRNRN7Pcv9pE5HjRURFZEbesUQV9FyLyL+LSCFal4pIt4jcLiIviMhvReS75oXTXutfKCKd9YzRIw6+n6khiMi3ReQ5EXlCRG4TkeF5x5QGEVklIttE5EUR2Zh3PGkTkR4RuU9EnhGRp0XkgrxjyoKItIjIf4rIL/KOpZkU8e9eRNaZ7+W+PM9BivjZISLXichOEXkq71iAYn7+iMgAEfmNiDxuxvQ3ecdkqcfnGCtp1U4B8ID5MzQRackmnOYjIgLgVgD/qqrTAOwPYDCAK3w2uxBA7klaA+L7uf/aCmCWqs4G8DyAS3OOJzHzfXkNgNUAZgI4RURm5htV6vYA+JKqzgSwCMB5TfgYAeACAM/mHUQTKuLf/VMAPgHg/rwCKPBnx/UAVuUdhE0RP392AVihqnMAzAWwSkQW5RyTJfPPscyTNBEZLCL3isijIvKkiKw1l08WkWdF5B/N7PhuERmYdTx+cQI4DMDZMFrhQkSWicj9IrLF/AbmByJSMu97X0SuFpHHASzOK247M95f2G5/X0TOzDEkNysAfKiq/wQAqroXwEUAzhKRQSJylYg8ZX4T+AUR+SKAfQDcJyL35Rg3AL6fqTGo6t2quse8+WsYczA1uoUAXlTVl1T1IwA/BbA255hSpaqvquqj5u/vwTgBmJBvVOkSkW4AawD8KO9Ymk0R/+5V9VlV3ZZzGIX87FDV+wG8lXccliJ+/qjBGsXUZv7LveNhvT7H6lFJ+xDACap6MIDlAK42qykAMA3ANap6IIC3AZxYh3i8rAVwp6o+D+BPIjLfXL4QwBdgfPsyBcY3QgAwCMCDqjpHVR+oe7SN60AAj9gXqOq7AF4G8FkAkwHMNb8JvFFV/yeAPwJYrqrL6xyrG76fqdGcBeCXeQeRggkA/mC7vQNNlsDYichkAPMAPJhvJKn7BwCXAOjLO5Am1yx/92noV58daSjS5485rPAxADsBbFXV3GNCnT7H6pGkCYArReQJAPfA+MMYZ973O1V9zPz9ERgn6Hk5Bca3KzB/WkPEfmN++7IXwE0wqhMAsBfALfUNsektA/BD65tAVS3MN0w2fD9TIYjIPWbV2flvrW2dr8AYwnJjfpFSVGYl/BYAF5pfYjUFETkWwE5VfSRwZXJVxL/7MDFR4yja54+q7lXVuTAqwwtFZFae8dTzc6wek1l/GsAYAPNVdbeIbAcwwLxvl229vQByGR4mIiNhDMM7SEQUxsSSCmALasuq1u0PzRPdItmD6sR7gNeKOXoGwEn2BSIyFMBEANvzCCgivp+pEFR1pd/95lDnYwEcoc0xIeYrAHpst7vNZU1FRNpgnCDdqKq35h1PypYAOE5EjoHxuTlURH6iqqfmHFfDKOLffVBMBdAvPjvSUOTPH1V927zsZRWMax3zUrfPsXpU0obByDh3i8hyAJPqcMyoTgLwv1R1kqpOVtUeAL8D8DEYWfu+5rU7n4TRiKGofg9gpoh0iNHV6Yi8A3JxL4BOETkdKF/QezWMC2jvAvDfRKTVvG+kuc17AIbUP1RXfD9T4YnIKhhDMY5T1b/kHU9KHgIwzXz/tsO41vKOnGNKlTl0+loAz6rqd/KOJ22qeqmqdqvqZBiv378xQUtPk/7dp6HpPzvSUMTPHxEZY57PwrzO/0gAz+UZUz0/xzJL0swT7V0wyu29IvIkgNOR85Pr4RQAtzmW3WIufwjA92FcQPk7l/VyZz3XqvoHADfD+IbhZgD/mWtgLsxv9k4AsE5EXoDRgepDAJfBuADzZQBPmA0sPmVuthnAnXk2DuH7mRrM92F8sbFVRB4TkR/kHVBS5jDo82F8mfMsgJtV9el8o0rdEgCnAVhhvm6Pmd/WEoVRuL97ETlBRHbAaEi1RUTuqncMRf3sEJGbAPwKwHQR2SEiZ+ccUhE/f7pgNI57Asb5y1ZV7TdTd0hW1XARmQPgH1V1YSYHqAMRWQbgYlU9Nu9Y/DTDc110zfAcN8r7mYiIiKi/y6SSJiLnwGhK8NUs9k8VfK6zx+eYiIiIiOops0oaERERERERRVePxiFEREREREQUUipJmoj0iMh9IvKMiDwtIheYy0eKyFYRecH8OcJcPkNEfiUiu0TkYse+VonINhF5UUQ2phEfURQpv5+vE5GdIpJnu1giIiIiaiBpVdL2APiSqs4EsAjAeSIyE8BGAPeq6jQYrdetpOstAF8EcJV9J2Y79msArAYwE8Ap5n6I6imV97PpehhzehARERERhZJKkqaqr6rqo+bv78FocToBwFoAN5ir3QDgeHOdnar6EIDdjl0tBPCiqr6kqh8B+Km5D6K6SfH9DFW9H0YSR0REREQUSurXpInIZADzADwIYJyqvmre9RqAcQGbTwDwB9vtHeYyolwkfD8TEREREUWWapImIoNhTJp7oaq+a7/PnMSYrSSpYfD9TERERER5SC1JE5E2GCe0N6rqrebi10Wky7y/C8DOgN28AqDHdrvbXEZUVym9n4mIiIiIIkuru6MAuBbAs6r6HdtddwA4w/z9DAC3B+zqIQDTRGRfEWkHcLK5D6K6SfH9TEREREQUWSqTWYvIYQD+A8CTAPrMxZfBuI7nZgATAfwewHpVfUtExgN4GMBQc/33AcxU1XdF5BgA/wCgBcB1qnpF4gCJIkj5/XwTgGUARgN4HcDXVfXaOj4cIiIiImowqSRpRERERERElI7UuzsSERERERFRfEzSiIiIiIiICoRJGhERERERUYEwSSMiIiIiIioQJmlEREREREQFwiSNiIiIiIioQJikERERERERFcj/B4l6N1z+hq7fAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "df = df_white\n", - "order = (2, 1, 0)\n", - "run_tests(df, order)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-03T17:03:36.370882Z", - "start_time": "2020-05-03T17:03:34.712523Z" - }, - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Statsmodels results css:\n", - "Fitted parameters: mu=0.77, p=[-0.02 -0.06], q=[]\n", - "AR roots abs:[4.23 4.23]\n", - "MA roots abs:[]\n", - "Train error mean: 0.00, std: 20.78\n", - "LL: 5147.77\n", - "RMSE: 46983.52\n", - "\n", - "Giotto results css:\n", - "Fitted parameters: mu=0.77, p=[-0.02 -0.06], q=[]\n", - "AR roots abs:[4.23 4.23]\n", - "MA roots abs:[]\n", - "Train error mean: -0.01, std: 20.78\n", - "LL: 5147.77\n", - "RMSE: 45021.77\n", - "\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "df = df_real\n", - "order = (2, 1, 0)\n", - "run_tests(df, order)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-03T17:03:38.007505Z", - "start_time": "2020-05-03T17:03:36.379232Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Statsmodels results css:\n", - "Fitted parameters: mu=0.00, p=[-0.43 0.02], q=[]\n", - "AR roots abs:[ 2.15 26.81]\n", - "MA roots abs:[]\n", - "Train error mean: 0.00, std: 0.68\n", - "LL: 413.09\n", - "RMSE: 2.77\n", - "\n", - "Giotto results css:\n", - "Fitted parameters: mu=0.00, p=[-0.43 0.02], q=[]\n", - "AR roots abs:[26.81 2.15]\n", - "MA roots abs:[]\n", - "Train error mean: 0.00, std: 0.68\n", - "LL: 413.09\n", - "RMSE: 3.08\n", - "\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "df = df_arima\n", - "order = (2, 1, 0)\n", - "run_tests(df, order)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Full ARIMA check" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-03T17:03:46.377644Z", - "start_time": "2020-05-03T17:03:44.670383Z" - }, - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Statsmodels results css:\n", - "Fitted parameters: mu=0.00, p=[-0.19 0. ], q=[-0.85 -0.15]\n", - "AR roots abs:[ 4.97 78.06]\n", - "MA roots abs:[1. 6.53]\n", - "Train error mean: 0.00, std: 1.00\n", - "LL: 564.78\n", - "RMSE: 1.09\n", - "\n", - "Giotto results css:\n", - "Fitted parameters: mu=0.00, p=[-0.19 0. ], q=[-0.85 -0.15]\n", - "AR roots abs:[76.15 4.97]\n", - "MA roots abs:[6.54 1. ]\n", - "Train error mean: 0.00, std: 1.00\n", - "LL: 564.78\n", - "RMSE: 1.09\n", - "\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "df = df_white\n", - "order = (2, 1, 2)\n", - "run_tests(df, order)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-03T17:03:48.013582Z", - "start_time": "2020-05-03T17:03:46.382521Z" - }, - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Statsmodels results css:\n", - "Fitted parameters: mu=0.00, p=[-0.26 -0.07], q=[-0.76 -0.24]\n", - "AR roots abs:[3.89 3.89]\n", - "MA roots abs:[1. 4.23]\n", - "Train error mean: -0.04, std: 20.78\n", - "LL: 5143.23\n", - "RMSE: 43110.28\n", - "\n", - "Giotto results css:\n", - "Fitted parameters: mu=-0.00, p=[-0.82 -0.06], q=[-0.18 -0.81]\n", - "AR roots abs:[12.11 1.35]\n", - "MA roots abs:[1.23 1.01]\n", - "Train error mean: -0.42, std: 20.87\n", - "LL: 5148.38\n", - "RMSE: 45521.01\n", - "\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "df = df_real\n", - "order = (2, 2, 2)\n", - "run_tests(df, order)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "ExecuteTime": { - "end_time": "2020-05-03T17:03:49.603863Z", - "start_time": "2020-05-03T17:03:48.017866Z" - }, - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Statsmodels results css:\n", - "Fitted parameters: mu=-0.00, p=[-1.57 -0.57], q=[ 0.2 -0.93 -0.13]\n", - "AR roots abs:[1.01 1.73]\n", - "MA roots abs:[1.06 1. 7.3 ]\n", - "Train error mean: -0.01, std: 0.69\n", - "LL: 417.56\n", - "RMSE: 10.81\n", - "\n", - "Giotto results css:\n", - "Fitted parameters: mu=0.00, p=[0.48 0.32], q=[-1.92 1. -0.09]\n", - "AR roots abs:[2.65 1.17]\n", - "MA roots abs:[9.26 1.24 1. ]\n", - "Train error mean: -0.00, std: 0.68\n", - "LL: 411.86\n", - "RMSE: 6.69\n", - "\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "df = df_arima\n", - "order = (2, 2, 3)\n", - "run_tests(df, order)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.1" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} From 61270524c9ef9b34d6826fbe13c91dfa82382b2b Mon Sep 17 00:00:00 2001 From: Simon B Date: Tue, 5 May 2020 16:43:28 -0300 Subject: [PATCH 19/23] (p, d, q) renamed --- gtime/forecasting/arima.py | 39 +++++++++++++++++--------------------- 1 file changed, 17 insertions(+), 22 deletions(-) diff --git a/gtime/forecasting/arima.py b/gtime/forecasting/arima.py index 8ee80f8..baf77c3 100644 --- a/gtime/forecasting/arima.py +++ b/gtime/forecasting/arima.py @@ -100,16 +100,13 @@ class ARIMAForecaster(BaseForecaster): """ def __init__(self, order: Tuple[int, int, int], method: str = 'css-mle'): - self.order = order - self.max_degree = max(order[0], order[2]) - self.n_ar = order[0] - self.n_ma = order[2] + self.p, self.d, self.q = order self.method = method self.model = None def _deintegrate(self, X: np.array) -> np.array: """ - Desintegrates X returning its difference of ``self.order[1]`` order and recording initial values to ``self.diff_vals`` for invertability + Desintegrates X returning its difference of ``self.d`` order and recording initial values to ``self.diff_vals`` for invertability Parameters ---------- @@ -117,16 +114,14 @@ def _deintegrate(self, X: np.array) -> np.array: Returns ------- - X: np.array, difference of ``self.order[1]`` order of X + X: np.array, difference of ``self.d`` order of X """ - n = len(X) - i_order = self.order[1] - target_lenth = n - i_order - self.n_ar - self.diff_vals = np.zeros((target_lenth, i_order)) - for i in range(i_order): - self.diff_vals[:, i] = np.diff(X, n=i)[self.n_ar + 1:self.n_ar + target_lenth + 1] - X = np.diff(X, n=i_order) + target_lenth = len(X) - self.d - self.p + self.diff_vals = np.zeros((target_lenth, self.d)) + for i in range(self.d): + self.diff_vals[:, i] = np.diff(X, n=i)[self.p + 1:self.p + target_lenth + 1] + X = np.diff(X, n=self.d) return X def _integrate(self, X: np.array) -> np.array: @@ -142,7 +137,7 @@ def _integrate(self, X: np.array) -> np.array: np.array, integrated time series """ - for i in range(self.order[1]): + for i in range(self.d): X = np.concatenate([self.diff_vals[:, [-i-1]], X], axis=1).cumsum(axis=1) return X @@ -178,12 +173,12 @@ def fit(self, X: pd.DataFrame, y: pd.DataFrame): Returns self. """ - len_stored_values = self.n_ar + self.order[1] + len_stored_values = self.p + self.d self.last_train_date_ = X.index.max().end_time self.last_train_values_ = X.iloc[-len_stored_values:] if len_stored_values > 0 else X.iloc[:0] np_x = X.to_numpy().flatten() np_x = self._deintegrate(np_x) - model = ARMAMLEModel((self.n_ar, self.n_ma), self.method) + model = ARMAMLEModel((self.p, self.q), self.method) model.fit(np_x) self._set_params(model, np_x) super().fit(X, y) @@ -208,12 +203,12 @@ def _extend_x_test(self, X: pd.DataFrame) -> (pd.DataFrame, np.array): train_test_diff = X.index.min().start_time - self.last_train_date_ if train_test_diff.value == 1: X = pd.concat([self.last_train_values_, X]) - errors = self.errors_[-self.n_ma:] + errors = self.errors_[-self.q:] else: - last_index = pd.period_range(periods=self.n_ar + self.order[1] + 1, end=X.index[0])[:-1] + last_index = pd.period_range(periods=self.p + self.d + 1, end=X.index[0])[:-1] last_values = pd.DataFrame([X.iloc[0].values[0]] * len(last_index), index=last_index, columns=X.columns) X = pd.concat([last_values, X]) - errors = np.zeros(self.n_ma) + errors = np.zeros(self.q) return X, errors def _predict(self, X: pd.DataFrame) -> np.array: @@ -236,8 +231,8 @@ def _predict(self, X: pd.DataFrame) -> np.array: errors = _arma_insample_errors(np_x, errors, self.mu_, self.phi_, self.theta_) res = [_arma_forecast(n=self.horizon_, - x0=np_x[i:i+self.n_ar], - eps0=errors[i:i+self.n_ma], + x0=np_x[i:i+self.p], + eps0=errors[i:i+self.q], mu=self.model.mu, phi=self.model.phi, theta=self.model.theta @@ -245,4 +240,4 @@ def _predict(self, X: pd.DataFrame) -> np.array: for i in range(1, n+1)] y_pred = self._integrate(np.array(res)) - return y_pred[:, self.order[1]:] + return y_pred[:, self.d:] From ff913c3bb998b31de3ef99dd5d23a66d02e58258 Mon Sep 17 00:00:00 2001 From: Simon B Date: Tue, 5 May 2020 18:16:55 -0300 Subject: [PATCH 20/23] Minor refactoring based on #174 --- gtime/forecasting/arima.py | 27 ++++++++++---------- gtime/stat_tools/mle_estimate.py | 1 - gtime/time_series_models/tests/test_arima.py | 3 +++ 3 files changed, 16 insertions(+), 15 deletions(-) diff --git a/gtime/forecasting/arima.py b/gtime/forecasting/arima.py index baf77c3..e5eae0f 100644 --- a/gtime/forecasting/arima.py +++ b/gtime/forecasting/arima.py @@ -118,9 +118,9 @@ def _deintegrate(self, X: np.array) -> np.array: """ target_lenth = len(X) - self.d - self.p - self.diff_vals = np.zeros((target_lenth, self.d)) + self.deintegration_partial_value = np.zeros((target_lenth, self.d)) for i in range(self.d): - self.diff_vals[:, i] = np.diff(X, n=i)[self.p + 1:self.p + target_lenth + 1] + self.deintegration_partial_value[:, i] = np.diff(X, n=i)[self.p + 1:self.p + target_lenth + 1] X = np.diff(X, n=self.d) return X @@ -138,7 +138,7 @@ def _integrate(self, X: np.array) -> np.array: """ for i in range(self.d): - X = np.concatenate([self.diff_vals[:, [-i-1]], X], axis=1).cumsum(axis=1) + X = np.concatenate([self.deintegration_partial_value[:, [-i - 1]], X], axis=1).cumsum(axis=1) return X def _set_params(self, model: ARMAMLEModel, x: np.array): @@ -176,11 +176,11 @@ def fit(self, X: pd.DataFrame, y: pd.DataFrame): len_stored_values = self.p + self.d self.last_train_date_ = X.index.max().end_time self.last_train_values_ = X.iloc[-len_stored_values:] if len_stored_values > 0 else X.iloc[:0] - np_x = X.to_numpy().flatten() - np_x = self._deintegrate(np_x) + X_numpy = X.to_numpy().flatten() + X_numpy = self._deintegrate(X_numpy) model = ARMAMLEModel((self.p, self.q), self.method) - model.fit(np_x) - self._set_params(model, np_x) + model.fit(X_numpy) + self._set_params(model, X_numpy) super().fit(X, y) return self @@ -199,7 +199,6 @@ def _extend_x_test(self, X: pd.DataFrame) -> (pd.DataFrame, np.array): X: pd.DataFrame, extended time series required for predictions errors: np.array, error forecast required for predictions """ - n = len(X) train_test_diff = X.index.min().start_time - self.last_train_date_ if train_test_diff.value == 1: X = pd.concat([self.last_train_values_, X]) @@ -224,20 +223,20 @@ def _predict(self, X: pd.DataFrame) -> np.array: ------- np.array """ - n = len(X) + X, errors = self._extend_x_test(X) - np_x = X.values.flatten() - np_x = self._deintegrate(np_x) - errors = _arma_insample_errors(np_x, errors, self.mu_, self.phi_, self.theta_) + X_numpy = X.values.flatten() + X_numpy = self._deintegrate(X_numpy) + errors = _arma_insample_errors(X_numpy, errors, self.mu_, self.phi_, self.theta_) res = [_arma_forecast(n=self.horizon_, - x0=np_x[i:i+self.p], + x0=X_numpy[i:i+self.p], eps0=errors[i:i+self.q], mu=self.model.mu, phi=self.model.phi, theta=self.model.theta ) - for i in range(1, n+1)] + for i in range(1, len(X)+1)] y_pred = self._integrate(np.array(res)) return y_pred[:, self.d:] diff --git a/gtime/stat_tools/mle_estimate.py b/gtime/stat_tools/mle_estimate.py index adc1017..b3e4c79 100644 --- a/gtime/stat_tools/mle_estimate.py +++ b/gtime/stat_tools/mle_estimate.py @@ -23,7 +23,6 @@ def _run_css(params: np.array, X: np.array, len_p: int, errors: bool = False, tr errors: np.array, residuals """ - mu = params[0] nobs = len(X) - len_p if transform: diff --git a/gtime/time_series_models/tests/test_arima.py b/gtime/time_series_models/tests/test_arima.py index 30394d1..769a4a4 100644 --- a/gtime/time_series_models/tests/test_arima.py +++ b/gtime/time_series_models/tests/test_arima.py @@ -23,3 +23,6 @@ def test_arima_oos_forecast(self, x, order, horizon): x_test_oos = x.iloc[[-1]] y_pred = model.predict(x_test_oos) assert y_pred.shape == (1, horizon) + + + From 9fc10e812c102ec19aaf900b0e6074cf691df642 Mon Sep 17 00:00:00 2001 From: Simon B Date: Tue, 5 May 2020 18:46:58 -0300 Subject: [PATCH 21/23] Testing bug fixes #174 --- gtime/forecasting/arima.py | 9 ++++++--- gtime/forecasting/naive.py | 2 +- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/gtime/forecasting/arima.py b/gtime/forecasting/arima.py index e5eae0f..efc4395 100644 --- a/gtime/forecasting/arima.py +++ b/gtime/forecasting/arima.py @@ -31,7 +31,10 @@ def _arma_forecast(n: int, x0: np.array, eps0: np.array, mu: float, phi: np.arra eps = np.r_[eps0, np.zeros(n)] trend = mu * (1 - phi.sum()) for i in range(n): - x[i + len_ar] = trend + np.dot(phi, x[i:i + len_ar]) + np.dot(theta, eps[i:i + len_ma]) + try: + x[i + len_ar] = trend + np.dot(phi, x[i:i + len_ar]) + np.dot(theta, eps[i:i + len_ma]) + except: + print(i, x, phi, theta) return x[len_ar:] @@ -223,7 +226,7 @@ def _predict(self, X: pd.DataFrame) -> np.array: ------- np.array """ - + len_test = len(X) X, errors = self._extend_x_test(X) X_numpy = X.values.flatten() X_numpy = self._deintegrate(X_numpy) @@ -236,7 +239,7 @@ def _predict(self, X: pd.DataFrame) -> np.array: phi=self.model.phi, theta=self.model.theta ) - for i in range(1, len(X)+1)] + for i in range(1, len_test+1)] y_pred = self._integrate(np.array(res)) return y_pred[:, self.d:] diff --git a/gtime/forecasting/naive.py b/gtime/forecasting/naive.py index 7cb8248..73a1090 100644 --- a/gtime/forecasting/naive.py +++ b/gtime/forecasting/naive.py @@ -56,7 +56,7 @@ def _predict(self, X: pd.DataFrame) -> np.array: return predictions -class SeasonalNaiveForecaster(BaseNaiveForecaster): +class SeasonalNaiveForecaster(BaseForecaster): """Seasonal naïve model. The forecast is expected to follow a seasonal pattern of ``seasonal_length`` data points, which is determined by the last ``seasonal_length`` observations of a training dataset available. Parameters From fbbc056dcd3693a96cc6d156122f860f1ae8229d Mon Sep 17 00:00:00 2001 From: Simon B Date: Tue, 5 May 2020 18:58:35 -0300 Subject: [PATCH 22/23] Testing bug fixes #174 --- gtime/forecasting/arima.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/gtime/forecasting/arima.py b/gtime/forecasting/arima.py index efc4395..6a6bda8 100644 --- a/gtime/forecasting/arima.py +++ b/gtime/forecasting/arima.py @@ -31,10 +31,7 @@ def _arma_forecast(n: int, x0: np.array, eps0: np.array, mu: float, phi: np.arra eps = np.r_[eps0, np.zeros(n)] trend = mu * (1 - phi.sum()) for i in range(n): - try: - x[i + len_ar] = trend + np.dot(phi, x[i:i + len_ar]) + np.dot(theta, eps[i:i + len_ma]) - except: - print(i, x, phi, theta) + x[i + len_ar] = trend + np.dot(phi, x[i:i + len_ar]) + np.dot(theta, eps[i:i + len_ma]) return x[len_ar:] From ae117e588d3e8374462981b27a1b8646c3809e15 Mon Sep 17 00:00:00 2001 From: Simon B Date: Tue, 5 May 2020 20:06:46 -0300 Subject: [PATCH 23/23] Black formating --- gtime/forecasting/__init__.py | 2 +- gtime/forecasting/arima.py | 69 +++++++++++++------- gtime/forecasting/base.py | 1 - gtime/forecasting/gar.py | 26 ++++++-- gtime/forecasting/tests/tests_arima.py | 19 ++++-- gtime/stat_tools/__init__.py | 6 +- gtime/stat_tools/mle_estimate.py | 54 +++++++++------ gtime/stat_tools/tests/test_mle.py | 42 +++++++----- gtime/stat_tools/tests/test_tools.py | 40 ++++++++++-- gtime/stat_tools/tools.py | 10 +-- gtime/time_series_models/__init__.py | 2 +- gtime/time_series_models/arima.py | 5 +- gtime/time_series_models/tests/test_arima.py | 27 ++++---- 13 files changed, 198 insertions(+), 105 deletions(-) diff --git a/gtime/forecasting/__init__.py b/gtime/forecasting/__init__.py index feab737..8b9ce14 100755 --- a/gtime/forecasting/__init__.py +++ b/gtime/forecasting/__init__.py @@ -27,5 +27,5 @@ "DriftForecaster", "AverageForecaster", "MultiFeatureMultiOutputRegressor", - "ARIMAForecaster" + "ARIMAForecaster", ] diff --git a/gtime/forecasting/arima.py b/gtime/forecasting/arima.py index 6a6bda8..8c73400 100644 --- a/gtime/forecasting/arima.py +++ b/gtime/forecasting/arima.py @@ -5,7 +5,9 @@ from gtime.stat_tools import ARMAMLEModel -def _arma_forecast(n: int, x0: np.array, eps0: np.array, mu: float, phi: np.array, theta: np.array) -> np.array: +def _arma_forecast( + n: int, x0: np.array, eps0: np.array, mu: float, phi: np.array, theta: np.array +) -> np.array: """ Forecasts next ``n`` steps of ARIMA process. @@ -31,11 +33,15 @@ def _arma_forecast(n: int, x0: np.array, eps0: np.array, mu: float, phi: np.arra eps = np.r_[eps0, np.zeros(n)] trend = mu * (1 - phi.sum()) for i in range(n): - x[i + len_ar] = trend + np.dot(phi, x[i:i + len_ar]) + np.dot(theta, eps[i:i + len_ma]) + x[i + len_ar] = ( + trend + np.dot(phi, x[i : i + len_ar]) + np.dot(theta, eps[i : i + len_ma]) + ) return x[len_ar:] -def _arma_insample_errors(x: np.array, eps0: np.array, mu: float, phi: np.array, theta: np.array) -> np.array: +def _arma_insample_errors( + x: np.array, eps0: np.array, mu: float, phi: np.array, theta: np.array +) -> np.array: """ Forecasts next ``n`` steps of ARIMA process. @@ -63,7 +69,9 @@ def _arma_insample_errors(x: np.array, eps0: np.array, mu: float, phi: np.array, eps = np.r_[eps0, np.zeros(n)] trend = mu * (1 - phi.sum()) for i in range(n): - x_f[i] = trend + np.dot(phi, x[i:i + len_ar]) + np.dot(theta, eps[i:i + len_ma]) + x_f[i] = ( + trend + np.dot(phi, x[i : i + len_ar]) + np.dot(theta, eps[i : i + len_ma]) + ) eps[i + len_ma] = x[i + len_ar] - x_f[i] return eps @@ -99,7 +107,7 @@ class ARIMAForecaster(BaseForecaster): """ - def __init__(self, order: Tuple[int, int, int], method: str = 'css-mle'): + def __init__(self, order: Tuple[int, int, int], method: str = "css-mle"): self.p, self.d, self.q = order self.method = method self.model = None @@ -120,7 +128,9 @@ def _deintegrate(self, X: np.array) -> np.array: target_lenth = len(X) - self.d - self.p self.deintegration_partial_value = np.zeros((target_lenth, self.d)) for i in range(self.d): - self.deintegration_partial_value[:, i] = np.diff(X, n=i)[self.p + 1:self.p + target_lenth + 1] + self.deintegration_partial_value[:, i] = np.diff(X, n=i)[ + self.p + 1 : self.p + target_lenth + 1 + ] X = np.diff(X, n=self.d) return X @@ -138,7 +148,9 @@ def _integrate(self, X: np.array) -> np.array: """ for i in range(self.d): - X = np.concatenate([self.deintegration_partial_value[:, [-i - 1]], X], axis=1).cumsum(axis=1) + X = np.concatenate( + [self.deintegration_partial_value[:, [-i - 1]], X], axis=1 + ).cumsum(axis=1) return X def _set_params(self, model: ARMAMLEModel, x: np.array): @@ -175,7 +187,9 @@ def fit(self, X: pd.DataFrame, y: pd.DataFrame): """ len_stored_values = self.p + self.d self.last_train_date_ = X.index.max().end_time - self.last_train_values_ = X.iloc[-len_stored_values:] if len_stored_values > 0 else X.iloc[:0] + self.last_train_values_ = ( + X.iloc[-len_stored_values:] if len_stored_values > 0 else X.iloc[:0] + ) X_numpy = X.to_numpy().flatten() X_numpy = self._deintegrate(X_numpy) model = ARMAMLEModel((self.p, self.q), self.method) @@ -202,10 +216,16 @@ def _extend_x_test(self, X: pd.DataFrame) -> (pd.DataFrame, np.array): train_test_diff = X.index.min().start_time - self.last_train_date_ if train_test_diff.value == 1: X = pd.concat([self.last_train_values_, X]) - errors = self.errors_[-self.q:] + errors = self.errors_[-self.q :] else: - last_index = pd.period_range(periods=self.p + self.d + 1, end=X.index[0])[:-1] - last_values = pd.DataFrame([X.iloc[0].values[0]] * len(last_index), index=last_index, columns=X.columns) + last_index = pd.period_range(periods=self.p + self.d + 1, end=X.index[0])[ + :-1 + ] + last_values = pd.DataFrame( + [X.iloc[0].values[0]] * len(last_index), + index=last_index, + columns=X.columns, + ) X = pd.concat([last_values, X]) errors = np.zeros(self.q) return X, errors @@ -227,16 +247,21 @@ def _predict(self, X: pd.DataFrame) -> np.array: X, errors = self._extend_x_test(X) X_numpy = X.values.flatten() X_numpy = self._deintegrate(X_numpy) - errors = _arma_insample_errors(X_numpy, errors, self.mu_, self.phi_, self.theta_) - - res = [_arma_forecast(n=self.horizon_, - x0=X_numpy[i:i+self.p], - eps0=errors[i:i+self.q], - mu=self.model.mu, - phi=self.model.phi, - theta=self.model.theta - ) - for i in range(1, len_test+1)] + errors = _arma_insample_errors( + X_numpy, errors, self.mu_, self.phi_, self.theta_ + ) + + res = [ + _arma_forecast( + n=self.horizon_, + x0=X_numpy[i : i + self.p], + eps0=errors[i : i + self.q], + mu=self.model.mu, + phi=self.model.phi, + theta=self.model.theta, + ) + for i in range(1, len_test + 1) + ] y_pred = self._integrate(np.array(res)) - return y_pred[:, self.d:] + return y_pred[:, self.d :] diff --git a/gtime/forecasting/base.py b/gtime/forecasting/base.py index 7054794..2196c23 100644 --- a/gtime/forecasting/base.py +++ b/gtime/forecasting/base.py @@ -4,7 +4,6 @@ from sklearn.utils.validation import check_is_fitted - class BaseForecaster(BaseEstimator, RegressorMixin, metaclass=ABCMeta): """Base abstract class for simple models """ diff --git a/gtime/forecasting/gar.py b/gtime/forecasting/gar.py index b81d157..aa6fdd9 100644 --- a/gtime/forecasting/gar.py +++ b/gtime/forecasting/gar.py @@ -51,7 +51,9 @@ def _rename_columns( for y_column, columns in X_columns.items(): dict_explanations[y_column].columns = columns else: - raise TypeError(f'X_columns must be a list or a dict. Detected: {type(X_columns)}') + raise TypeError( + f"X_columns must be a list or a dict. Detected: {type(X_columns)}" + ) return dict_explanations @@ -139,7 +141,9 @@ def predict(self, X: pd.DataFrame) -> pd.DataFrame: if self.explainer_type is not None: self.explanations_ = self._explanations_as_dataframe( - index=y_p_df.index, y_columns=self.y_columns_, X_columns=list(X.columns), + index=y_p_df.index, + y_columns=self.y_columns_, + X_columns=list(X.columns), ) return y_p_df @@ -210,7 +214,9 @@ def fit(self, X: pd.DataFrame, y: pd.DataFrame): """ self.y_columns_ = y.columns - self.target_to_features_dict_ = self._compute_target_to_features_dict(X.columns, y.columns) + self.target_to_features_dict_ = self._compute_target_to_features_dict( + X.columns, y.columns + ) return super().fit(X, y) def predict(self, X: pd.DataFrame) -> pd.DataFrame: @@ -233,11 +239,15 @@ def predict(self, X: pd.DataFrame) -> pd.DataFrame: if self.explainer_type is not None: self.explanations_ = self._explanations_as_dataframe( - index=y_p_df.index, y_columns=self.y_columns_, X_columns=self.target_to_features_dict_ + index=y_p_df.index, + y_columns=self.y_columns_, + X_columns=self.target_to_features_dict_, ) return y_p_df - def _compute_target_to_features_dict(self, X_columns: List[str], y_columns: List[str]) -> Dict[str, List[str]]: + def _compute_target_to_features_dict( + self, X_columns: List[str], y_columns: List[str] + ) -> Dict[str, List[str]]: X_columns, y_columns = list(X_columns), list(y_columns) target_to_features_dict = {} @@ -345,7 +355,11 @@ def predict(self, X: pd.DataFrame) -> pd.DataFrame: y_p_df = pd.DataFrame(data=y_p, columns=self.y_columns_, index=X.index) if self.explainer_type is not None: - X_columns = list(X.columns) if self.target_to_features_dict_ is None else self.target_to_features_dict_ + X_columns = ( + list(X.columns) + if self.target_to_features_dict_ is None + else self.target_to_features_dict_ + ) self.explanations_ = self._explanations_as_dataframe( index=y_p_df.index, y_columns=self.y_columns_, X_columns=X_columns ) diff --git a/gtime/forecasting/tests/tests_arima.py b/gtime/forecasting/tests/tests_arima.py index 876fa01..3c4eab6 100644 --- a/gtime/forecasting/tests/tests_arima.py +++ b/gtime/forecasting/tests/tests_arima.py @@ -1,17 +1,22 @@ from hypothesis import given, settings -from gtime.forecasting.tests.test_simple_models import forecast_input, SimplePipelineTest # TODO to utilities? +from gtime.forecasting.tests.test_naive import ( + forecast_input, + SimplePipelineTest, +) # TODO to utilities? import hypothesis.strategies as st from gtime.forecasting import ARIMAForecaster class TestNaiveModel(SimplePipelineTest): - - @given(data=forecast_input(50, 10), - order=st.tuples(st.integers(min_value=0, max_value=4), - st.integers(min_value=0, max_value=2), - st.integers(min_value=0, max_value=4)) - ) + @given( + data=forecast_input(50, 10), + order=st.tuples( + st.integers(min_value=0, max_value=4), + st.integers(min_value=0, max_value=2), + st.integers(min_value=0, max_value=4), + ), + ) @settings(deadline=None) def setup(self, data, order): super().setup(data, ARIMAForecaster(order=order)) diff --git a/gtime/stat_tools/__init__.py b/gtime/stat_tools/__init__.py index 2254470..e2602d6 100644 --- a/gtime/stat_tools/__init__.py +++ b/gtime/stat_tools/__init__.py @@ -5,8 +5,4 @@ from .mle_estimate import ARMAMLEModel from .tools import acf, pacf -__all__ = [ - "ARMAMLEModel", - "acf", - "pacf" -] \ No newline at end of file +__all__ = ["ARMAMLEModel", "acf", "pacf"] diff --git a/gtime/stat_tools/mle_estimate.py b/gtime/stat_tools/mle_estimate.py index b3e4c79..2c55f54 100644 --- a/gtime/stat_tools/mle_estimate.py +++ b/gtime/stat_tools/mle_estimate.py @@ -4,7 +4,13 @@ from .tools import durbin_levinson_recursion -def _run_css(params: np.array, X: np.array, len_p: int, errors: bool = False, transform: bool = True): +def _run_css( + params: np.array, + X: np.array, + len_p: int, + errors: bool = False, + transform: bool = True, +): """ Conditional sum of squares estimate http://www.nuffield.ox.ac.uk/economics/papers/1997/w6/ma.pdf @@ -26,23 +32,25 @@ def _run_css(params: np.array, X: np.array, len_p: int, errors: bool = False, tr mu = params[0] nobs = len(X) - len_p if transform: - phi = np.r_[1, -_transform_params(params[2:len_p + 2])] - theta = np.r_[1, _transform_params(params[len_p + 2:])] + phi = np.r_[1, -_transform_params(params[2 : len_p + 2])] + theta = np.r_[1, _transform_params(params[len_p + 2 :])] else: - phi = np.r_[1, -params[2:len_p + 2]] - theta = np.r_[1, params[len_p + 2:]] + phi = np.r_[1, -params[2 : len_p + 2]] + theta = np.r_[1, params[len_p + 2 :]] y = X - mu init = np.zeros((max(len(phi), len(theta)) - 1)) for i in range(len_p): - init[i] = sum(-phi[:i + 1][::-1] * y[:i + 1]) + init[i] = sum(-phi[: i + 1][::-1] * y[: i + 1]) eps = lfilter(phi, theta, y, zi=init)[0][len_p:] if errors: return eps else: ssr = np.dot(eps, eps) sigma2 = ssr / nobs - loglikelihood = -nobs / 2. * (np.log(2 * np.pi * sigma2)) - ssr / (2. * sigma2) + loglikelihood = -nobs / 2.0 * (np.log(2 * np.pi * sigma2)) - ssr / ( + 2.0 * sigma2 + ) return -loglikelihood @@ -60,11 +68,11 @@ def _transform_params(param: np.array): """ - param = np.tanh(param/2) + param = np.tanh(param / 2) return durbin_levinson_recursion(param) -def _np_shift(x: np.array, max_lag: int): # TODO possible merge somehow with Shift() +def _np_shift(x: np.array, max_lag: int): # TODO possible merge somehow with Shift() """ Lag matrix up to ``max_lags`` for a time series ``x`` @@ -80,10 +88,10 @@ def _np_shift(x: np.array, max_lag: int): # TODO possible merge somehow with Shi n = len(x) res = np.zeros((n, max_lag)) - for i in range(n-1): + for i in range(n - 1): lim = min(i, max_lag) start = max(0, i - max_lag + 1) - res[i+1, :lim+1] = x[start:i+1][::-1] + res[i + 1, : lim + 1] = x[start : i + 1][::-1] return res @@ -112,8 +120,7 @@ def _ols_arma_estimate(X: np.array, n_ar: int, n_ma: int): class ARMAMLEModel: - - def __init__(self, order, method='css'): + def __init__(self, order, method="css"): self.length = max(order[0], order[1] + 1) self.order = order @@ -139,15 +146,20 @@ def fit(self, X: np.array): self.parameters[1] = sigma self.parameters[2:] = _ols_arma_estimate(X, self.order[0], self.order[1]) + Xmin = minimize( + lambda phi: _run_css(phi, X, len_p=self.order[0]), + x0=self.parameters, + method="L-BFGS-B", + ) - Xmin = minimize(lambda phi: _run_css(phi, X, len_p=self.order[0]), x0=self.parameters, method='L-BFGS-B') - - fitted_params = Xmin['x'] - self.ml = Xmin['fun'] + fitted_params = Xmin["x"] + self.ml = Xmin["fun"] self.mu = fitted_params[0] self.sigma = fitted_params[1] - self.phi = _transform_params(fitted_params[2:self.order[0] + 2]) - self.theta = _transform_params(fitted_params[-self.order[1]:] if self.order[1] > 0 else np.array([])) + self.phi = _transform_params(fitted_params[2 : self.order[0] + 2]) + self.theta = _transform_params( + fitted_params[-self.order[1] :] if self.order[1] > 0 else np.array([]) + ) self.parameters = np.r_[self.mu, self.sigma, self.phi, self.theta] return self @@ -164,5 +176,7 @@ def get_errors(self, X: np.array): errors: np.array, residuals """ - errors = _run_css(self.parameters, X, self.order[0], errors=True, transform=False) + errors = _run_css( + self.parameters, X, self.order[0], errors=True, transform=False + ) return errors diff --git a/gtime/stat_tools/tests/test_mle.py b/gtime/stat_tools/tests/test_mle.py index 9775270..783a9e2 100644 --- a/gtime/stat_tools/tests/test_mle.py +++ b/gtime/stat_tools/tests/test_mle.py @@ -7,41 +7,53 @@ class TestMLEModel: - def test_zeros(self): x = np.zeros(100) - model = ARMAMLEModel(order=(0, 0), method='css') + model = ARMAMLEModel(order=(0, 0), method="css") model.fit(x) assert model.mu == pytest.approx(0.0) def test_ar(self): x = np.array([(-1) ** i for i in range(100)]) - model = ARMAMLEModel(order=(1, 0), method='css') + model = ARMAMLEModel(order=(1, 0), method="css") model.fit(x) assert model.phi == pytest.approx(-1.0) @given( - x=arrays(dtype=float, shape=st.integers(min_value=10, max_value=100), - elements=st.floats(max_value=1e15, min_value=-1e15, - allow_infinity=False, allow_nan=False), unique=True), - order=st.tuples(st.integers(min_value=1, max_value=3), st.integers(min_value=1, max_value=3)) + x=arrays( + dtype=float, + shape=st.integers(min_value=10, max_value=100), + elements=st.floats( + max_value=1e15, min_value=-1e15, allow_infinity=False, allow_nan=False + ), + unique=True, + ), + order=st.tuples( + st.integers(min_value=1, max_value=3), st.integers(min_value=1, max_value=3) + ), ) @settings(deadline=None) def test_random_likelihood(self, x, order): - model = ARMAMLEModel(order=order, method='css') + model = ARMAMLEModel(order=order, method="css") model.fit(x) assert not np.isnan(model.ml) - @given( - x=arrays(dtype=float, shape=st.integers(min_value=10, max_value=100), - elements=st.floats(max_value=1e15, min_value=-1e15, - allow_infinity=False, allow_nan=False), unique=True), - order=st.tuples(st.integers(min_value=1, max_value=3), st.integers(min_value=1, max_value=3)) + x=arrays( + dtype=float, + shape=st.integers(min_value=10, max_value=100), + elements=st.floats( + max_value=1e15, min_value=-1e15, allow_infinity=False, allow_nan=False + ), + unique=True, + ), + order=st.tuples( + st.integers(min_value=1, max_value=3), st.integers(min_value=1, max_value=3) + ), ) @settings(deadline=None) def test_random_errors_len(self, x, order): - model = ARMAMLEModel(order=order, method='css') + model = ARMAMLEModel(order=order, method="css") model.fit(x) errors = model.get_errors(x) - assert len(errors) == len(x) - order[0] \ No newline at end of file + assert len(errors) == len(x) - order[0] diff --git a/gtime/stat_tools/tests/test_tools.py b/gtime/stat_tools/tests/test_tools.py index 81f3f1a..5a66941 100644 --- a/gtime/stat_tools/tests/test_tools.py +++ b/gtime/stat_tools/tests/test_tools.py @@ -4,8 +4,16 @@ from hypothesis.extra.numpy import arrays from hypothesis import given from gtime.utils.hypothesis.time_indexes import giotto_time_series -from gtime.stat_tools.tools import normalize, autocorrelation, solve_yw_equation, yule_walker, acf, pacf, arma_polynomial_roots, durbin_levinson_recursion - +from gtime.stat_tools.tools import ( + normalize, + autocorrelation, + solve_yw_equation, + yule_walker, + acf, + pacf, + arma_polynomial_roots, + durbin_levinson_recursion, +) class TestAcf: @@ -74,19 +82,39 @@ def test_pacf_len(self, df, max_lag): def arma_params(draw, max_dim): p = draw(st.integers(min_value=0, max_value=max_dim)) q = draw(st.integers(min_value=0, max_value=max_dim)) - params = draw(arrays(np.float, shape=(p + q + 2), elements=st.floats(min_value=1e-10, max_value=1e10, allow_nan=False, allow_infinity=False))) + params = draw( + arrays( + np.float, + shape=(p + q + 2), + elements=st.floats( + min_value=1e-10, max_value=1e10, allow_nan=False, allow_infinity=False + ), + ) + ) return params, p -class TestMLETools: +class TestMLETools: @given(data=arma_params(max_dim=10)) def test_arma_polynomial_roots_abs(self, data): params, len_p = data res = arma_polynomial_roots(params, len_p) assert all(res >= 0) - @given(x=arrays(dtype=float, shape=st.integers(min_value=1, max_value=10), - elements=st.floats(allow_nan=False, allow_infinity=False, min_value=-1, max_value=1, exclude_min=True, exclude_max=True))) + @given( + x=arrays( + dtype=float, + shape=st.integers(min_value=1, max_value=10), + elements=st.floats( + allow_nan=False, + allow_infinity=False, + min_value=-1, + max_value=1, + exclude_min=True, + exclude_max=True, + ), + ) + ) def test_durbin_levinson_recursion(self, x): transformed_x = durbin_levinson_recursion(x) y = transformed_x.copy() diff --git a/gtime/stat_tools/tools.py b/gtime/stat_tools/tools.py index 2ba6a82..cc0fd3c 100644 --- a/gtime/stat_tools/tools.py +++ b/gtime/stat_tools/tools.py @@ -44,11 +44,13 @@ def arma_polynomial_roots(params: np.array, len_p: int): """ passing_value = 2.0 - phi = params[2:2 + len_p] - theta = params[2 + len_p:] + phi = params[2 : 2 + len_p] + theta = params[2 + len_p :] phi_roots = np.abs(np.roots(np.r_[-phi[::-1], 1.0])) theta_roots = np.abs(np.roots(np.r_[theta[::-1], 1.0])) - return np.r_[passing_value, passing_value, phi_roots, theta_roots] # TODO refactor 2.0 + return np.r_[ + passing_value, passing_value, phi_roots, theta_roots + ] # TODO refactor 2.0 def normalize(x: np.array) -> np.array: @@ -176,4 +178,4 @@ def acf(x: np.array, max_lags: Optional[int] = None) -> np.array: max_lags = n x = normalize(x) acf = autocorrelation(x) - return acf[:max_lags] \ No newline at end of file + return acf[:max_lags] diff --git a/gtime/time_series_models/__init__.py b/gtime/time_series_models/__init__.py index adf7dc8..412ca86 100644 --- a/gtime/time_series_models/__init__.py +++ b/gtime/time_series_models/__init__.py @@ -19,5 +19,5 @@ "SeasonalNaive", "Average", "Drift", - "ARIMA" + "ARIMA", ] diff --git a/gtime/time_series_models/arima.py b/gtime/time_series_models/arima.py index 98eee85..fb5eff4 100644 --- a/gtime/time_series_models/arima.py +++ b/gtime/time_series_models/arima.py @@ -5,9 +5,10 @@ class ARIMA(TimeSeriesForecastingModel): - def __init__(self, horizon: int, order, method): features = [ ("s1", Shift(0), make_column_selector()), ] - super().__init__(features=features, horizon=horizon, model=ARIMAForecaster(order, method)) \ No newline at end of file + super().__init__( + features=features, horizon=horizon, model=ARIMAForecaster(order, method) + ) diff --git a/gtime/time_series_models/tests/test_arima.py b/gtime/time_series_models/tests/test_arima.py index 769a4a4..d26e385 100644 --- a/gtime/time_series_models/tests/test_arima.py +++ b/gtime/time_series_models/tests/test_arima.py @@ -5,24 +5,21 @@ class TestARIMA: - @given(x=giotto_time_series( - min_length=20, - max_length=100, - allow_nan=False, - allow_infinity=False, - ), - order=st.tuples(st.integers(min_value=0, max_value=4), - st.integers(min_value=0, max_value=2), - st.integers(min_value=0, max_value=4)), - horizon=st.integers(min_value=1, max_value=10) - ) + @given( + x=giotto_time_series( + min_length=20, max_length=100, allow_nan=False, allow_infinity=False, + ), + order=st.tuples( + st.integers(min_value=0, max_value=4), + st.integers(min_value=0, max_value=2), + st.integers(min_value=0, max_value=4), + ), + horizon=st.integers(min_value=1, max_value=10), + ) @settings(deadline=None) def test_arima_oos_forecast(self, x, order, horizon): - model = ARIMA(order=order, method='css', horizon=horizon) + model = ARIMA(order=order, method="css", horizon=horizon) model.fit(x) x_test_oos = x.iloc[[-1]] y_pred = model.predict(x_test_oos) assert y_pred.shape == (1, horizon) - - -