From f1dc8b5168c8b657c8a03d218ec4614b31fa278e Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Fri, 25 Oct 2024 09:30:14 +0100 Subject: [PATCH 01/26] getting started --- docs/getting_started.md | 34 ++++++++++++++++++++++------------ 1 file changed, 22 insertions(+), 12 deletions(-) diff --git a/docs/getting_started.md b/docs/getting_started.md index a3659adf15..78db5f67f8 100644 --- a/docs/getting_started.md +++ b/docs/getting_started.md @@ -12,19 +12,29 @@ package. If you want help with scikit-learn you may want to view the very latest algorithms for time series machine learning, in addition to a range of classical techniques for the following learning tasks: -- {term}`Time series classification` where the time series data for a given instance -are used to predict a categorical target class. -- {term}`Time series extrinsic regression` where the time series data for a given -instance are used to predict a continuous target value. -- {term}`Time series clustering` where the goal is to discover groups consisting of -instances with similar time series. -- {term}`Time series similarity search` where the goal is to evaluate the similarity +- {term}`classification`, where a collection of time series labelled with + a discrete value is used to train a model to predict unseen cases. +- {term}`regression`, where a collection of time series labelled with + a continuous value is used to train a model to predict unseen cases. +- {term}`clustering`, where a collection of time series without any + labels are used to train a model to label cases. +- {term}`similarity search` where the goal is to evaluate the similarity between a time series against a collection of other time series. - -Additionally, it provides numerous algorithms for {term}`time series transformation`, -altering time series into different representations and domains or processing -time series data into tabular data. - +- {term}`anomaly detection` where the goal is to find values or areas of a + single time series that are not representative of the whole series. +- {term}`segmentation` where the goal is to split a single time series into + regions where the series are sofind areas of a time series that are not + representative of the whole series. + +`aeon` also provides core modules that are used by the specific task modules +above +- +- {term}`transformation`, where a either a single series or collection is transformed + into a different representation or domain. +- {term}`distances`, measure the dissimilarity between two time series or + collections of series, which includes functions to align series. +- {term}`networks`, provides core models for deep learning for all time series tasks. +- The following provides introductory examples for each of these modules. The examples use the datatypes most commonly used for the task in question, but a variety of input types for From 327746d4376797fee1e993a4b9951a14a8ea6149 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Fri, 25 Oct 2024 20:44:50 +0100 Subject: [PATCH 02/26] getting started --- aeon/datasets/_single_problem_loaders.py | 21 +++++++-- docs/getting_started.md | 59 ++++++++++++++++-------- 2 files changed, 56 insertions(+), 24 deletions(-) diff --git a/aeon/datasets/_single_problem_loaders.py b/aeon/datasets/_single_problem_loaders.py index 3d0a48379a..555c4b5222 100644 --- a/aeon/datasets/_single_problem_loaders.py +++ b/aeon/datasets/_single_problem_loaders.py @@ -658,12 +658,17 @@ def load_lynx(): return y -def load_airline(): +def load_airline(return_type="pd.Series"): """Load the airline univariate time series dataset [1]. + Parameters + ---------- + return_type: str, valid series type, default="pd.Series" + The type of series to return, either "pd.Series", "pd.DataFrame or "np.ndarray". + Returns ------- - y : pd.Series + y : pd.Series, np.ndarray or pd.DataFrame Time series Examples @@ -698,12 +703,21 @@ def load_airline(): # make sure time index is properly formatted y.index = pd.PeriodIndex(y.index, freq="M", name="Period") y.name = "Number of airline passengers" + if return_type == "np.ndarray": + return y.to_numpy() + elif return_type == "pd.DataFrame": + return pd.DataFrame(y) return y def load_uschange(y_name="Consumption"): """Load MTS dataset for forecasting Growth rates of personal consumption and income. + Parameters + ---------- + y_name: str, default="Consumption" + Name of target variable (y) + Returns ------- y : pd.Series @@ -742,9 +756,6 @@ def load_uschange(y_name="Consumption"): path = os.path.join(MODULE, DIRNAME, name, fname) data = pd.read_csv(path, index_col=0).squeeze("columns") - # Sort by Quarter then set simple numeric index - # TODO add support for period/datetime indexing - # data.index = pd.PeriodIndex(data.index, freq='Y') data = data.sort_values("Quarter") data = data.reset_index(drop=True) data.index = pd.Index(data.index, dtype=int) diff --git a/docs/getting_started.md b/docs/getting_started.md index 78db5f67f8..7d33ba2181 100644 --- a/docs/getting_started.md +++ b/docs/getting_started.md @@ -25,6 +25,8 @@ between a time series against a collection of other time series. - {term}`segmentation` where the goal is to split a single time series into regions where the series are sofind areas of a time series that are not representative of the whole series. +- {term}`forecasting` where the goal is to predict future values for a time + series. `aeon` also provides core modules that are used by the specific task modules above @@ -37,36 +39,37 @@ above - The following provides introductory examples for each of these modules. The examples use the datatypes most commonly used for the task in question, but a variety of input -types for -data are available. For more information on the variety of -estimators -available for each task, see the [API](api_reference) and [examples](examples) pages. +types for data are available. For more information on the variety of +estimators available for each task, see the [API](api_reference) and [examples] +(examples) pages. -## Time Series Data +## A Single Time Series A time series is a series of real valued data assumed to be ordered. A univariate time series is a singular series, where each observation is a single value. For example, the heartbeat ECG reading from a single sensor or the number of passengers using an -airline per month would form a univariate series. +airline per month would form a univariate series. Single time series are stored +either in a `pd.Series`, a `pd.DataFrame` or a `np.ndarray`. We recommend using +numpy arrays, as algorithms use arrays internally whenever possible. ```{code-block} python >>> from aeon.datasets import load_airline ->>> y = load_airline() # load an example univariate series with timestamps ->>> y.head() -Period -1960-08 606.0 -1960-09 508.0 -1960-10 461.0 -1960-11 390.0 -1960-12 432.0 -Freq: M, Name: Number of airline passengers, dtype: float64 +>>> y = load_airline(return_type="np.ndarray) # load an example univariate series +>>> y[:5] +606.0 +508.0 +461.0 +390.0 +432.0 ``` A multivariate time series is made up of multiple series, where each observation is a vector of related recordings in the same time index. An examples would be a motion trace of from a smartwatch with at least three dimensions (X,Y,Z co-ordinates), or multiple financial statistics recorded over time. Single multivariate series input typically -follows the shape `(n_timepoints, n_channels)`. +follows the shape `(n_channels, n_timepoints)` when stored in numpy arrays. This is +generally called wide format. You can also use dataframes, and many of our legacy +baked in datasets load by default into this format. ```{code-block} python >>> from aeon.datasets import load_uschange @@ -81,13 +84,31 @@ Quarter 1971 Q1 1.897371 1.987154 1.909734 3.657771 -0.1 ``` -We commonly refer to the number of observations for a time series as `n_timepoints`. If a series is multivariate, we refer to the dimensions as channels +to direclty load a multivariate series in numpy format, you can use the +`return_type` argument + +```{code-block} python +>>> from aeon.datasets import load_uschange +>>> y, X = load_uschange("Quarter", return_type="np.ndarray") # load an example +multivariate series +>>> X[:5, :] +0.615986 0.972261 -2.452700 4.810312 0.9 +0.460376 1.169085 -0.551525 7.287992 0.5 +0.876791 1.553271 -0.358708 7.289013 0.5 +-0.274245 -0.255272 -2.185455 0.985230 0.7 +1.897371 1.987154 1.909734 3.657771 -0.1 +``` + + +We commonly refer to the number of observations for a time series as `n_timepoints`. +If a series is multivariate, we refer to the dimensions as channels (to avoid confusion with the dimensions of array) and in code use `n_channels`. Dimensions may also be referred to as variables. Different parts of `aeon` work with single series or collections of series. The -`anomaly detection` and `segmentation` modules will commonly use single series input, while -`classification`, `regression` and `clustering` modules will use collections of time +`anomaly detection`, `forecasting` and `segmentation` modules will commonly use single +series input, while `classification`, `regression` and `clustering` modules will use +collections of time series. Collections of time series may also be referred to as Panels. Collections of time series will often be accompanied by an array of target variables. From 8208dd089b6ea03dd1079c26fe04f1f2afc6d3f9 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Mon, 28 Oct 2024 17:59:07 +0000 Subject: [PATCH 03/26] forecasting loaders --- aeon/datasets/_single_problem_loaders.py | 541 ++++++++++-------- aeon/datasets/tests/test_load_forecasting.py | 59 +- .../tests/test_single_problem_loaders.py | 78 ++- 3 files changed, 366 insertions(+), 312 deletions(-) diff --git a/aeon/datasets/_single_problem_loaders.py b/aeon/datasets/_single_problem_loaders.py index 3d0a48379a..f3328ffa0f 100644 --- a/aeon/datasets/_single_problem_loaders.py +++ b/aeon/datasets/_single_problem_loaders.py @@ -509,253 +509,6 @@ def load_cardano_sentiment(split=None, return_type="numpy3d"): return X, y -# forecasting data sets -def load_shampoo_sales(): - """Load the shampoo sales univariate time series dataset for forecasting. - - Returns - ------- - y : pd.Series/DataFrame - Shampoo sales dataset - - Examples - -------- - >>> from aeon.datasets import load_shampoo_sales - >>> y = load_shampoo_sales() - - Notes - ----- - This dataset describes the monthly number of sales of shampoo over a 3 - year period. - The units are a sales count. - - Dimensionality: univariate - Series length: 36 - Frequency: Monthly - Number of cases: 1 - - References - ---------- - .. [1] Makridakis, Wheelwright and Hyndman (1998) Forecasting: methods - and applications, - John Wiley & Sons: New York. Chapter 3. - """ - name = "ShampooSales" - fname = name + ".csv" - path = os.path.join(MODULE, DIRNAME, name, fname) - y = pd.read_csv(path, index_col=0, dtype={1: float}).squeeze("columns") - y.index = pd.PeriodIndex(y.index, freq="M", name="Period") - y.name = "Number of shampoo sales" - return y - - -def load_longley(y_name="TOTEMP"): - """Load the Longley dataset for forecasting with exogenous variables. - - Parameters - ---------- - y_name: str, default="TOTEMP" - Name of target variable (y) - - Returns - ------- - y: pd.Series - The target series to be predicted. - X: pd.DataFrame - The exogenous time series data for the problem. - - Examples - -------- - >>> from aeon.datasets import load_longley - >>> y, X = load_longley() - - Notes - ----- - This mulitvariate time series dataset contains various US macroeconomic - variables from 1947 to 1962 that are known to be highly collinear. - - Dimensionality: multivariate, 6 - Series length: 16 - Frequency: Yearly - Number of cases: 1 - - Variable description: - - TOTEMP - Total employment - GNPDEFL - Gross national product deflator - GNP - Gross national product - UNEMP - Number of unemployed - ARMED - Size of armed forces - POP - Population - - References - ---------- - .. [1] Longley, J.W. (1967) "An Appraisal of Least Squares Programs for the - Electronic Computer from the Point of View of the User." Journal of - the American Statistical Association. 62.319, 819-41. - (https://www.itl.nist.gov/div898/strd/lls/data/LINKS/DATA/Longley.dat) - """ - name = "Longley" - fname = name + ".csv" - path = os.path.join(MODULE, DIRNAME, name, fname) - data = pd.read_csv(path, index_col=0) - data = data.set_index("YEAR") - data.index = pd.PeriodIndex(data.index, freq="Y", name="Period") - data = data.astype(float) - - # Get target series - y = data.pop(y_name) - return y, data - - -def load_lynx(): - """Load the lynx univariate time series dataset for forecasting. - - Returns - ------- - y : pd.Series/DataFrame - Lynx sales dataset - - Examples - -------- - >>> from aeon.datasets import load_lynx - >>> y = load_lynx() - - Notes - ----- - The annual numbers of lynx trappings for 1821–1934 in Canada. This - time-series records the number of skins of - predators (lynx) that were collected over several years by the Hudson's - Bay Company. The dataset was - taken from Brockwell & Davis (1991) and appears to be the series - considered by Campbell & Walker (1977). - - Dimensionality: univariate - Series length: 114 - Frequency: Yearly - Number of cases: 1 - - This data shows aperiodic, cyclical patterns, as opposed to periodic, - seasonal patterns. - - References - ---------- - .. [1] Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988). The New S - Language. Wadsworth & Brooks/Cole. - - .. [2] Campbell, M. J. and Walker, A. M. (1977). A Survey of statistical - work on the Mackenzie River series of - annual Canadian lynx trappings for the years 1821–1934 and a new - analysis. Journal of the Royal Statistical Society - series A, 140, 411–431. - """ - name = "Lynx" - fname = name + ".csv" - path = os.path.join(MODULE, DIRNAME, name, fname) - y = pd.read_csv(path, index_col=0, dtype={1: float}).squeeze("columns") - y.index = pd.PeriodIndex(y.index, freq="Y", name="Period") - y.name = "Number of Lynx trappings" - return y - - -def load_airline(): - """Load the airline univariate time series dataset [1]. - - Returns - ------- - y : pd.Series - Time series - - Examples - -------- - >>> from aeon.datasets import load_airline - >>> y = load_airline() - - Notes - ----- - The classic Box & Jenkins airline data. Monthly totals of international - airline passengers, 1949 to 1960. - - Dimensionality: univariate - Series length: 144 - Frequency: Monthly - Number of cases: 1 - - This data shows an increasing trend, non-constant (increasing) variance - and periodic, seasonal patterns. - - References - ---------- - .. [1] Box, G. E. P., Jenkins, G. M. and Reinsel, G. C. (1976) Time Series - Analysis, Forecasting and Control. Third Edition. Holden-Day. - Series G. - """ - name = "Airline" - fname = name + ".csv" - path = os.path.join(MODULE, DIRNAME, name, fname) - y = pd.read_csv(path, index_col=0, dtype={1: float}).squeeze("columns") - - # make sure time index is properly formatted - y.index = pd.PeriodIndex(y.index, freq="M", name="Period") - y.name = "Number of airline passengers" - return y - - -def load_uschange(y_name="Consumption"): - """Load MTS dataset for forecasting Growth rates of personal consumption and income. - - Returns - ------- - y : pd.Series - selected column, default consumption - X : pd.DataFrame - columns with explanatory variables - - Examples - -------- - >>> from aeon.datasets import load_uschange - >>> y, X = load_uschange() - - Notes - ----- - Percentage changes in quarterly personal consumption expenditure, - personal disposable income, production, savings and the - unemployment rate for the US, 1960 to 2016. - - - Dimensionality: multivariate - Columns: ['Quarter', 'Consumption', 'Income', 'Production', - 'Savings', 'Unemployment'] - Series length: 188 - Frequency: Quarterly - Number of cases: 1 - - This data shows an increasing trend, non-constant (increasing) variance - and periodic, seasonal patterns. - - References - ---------- - .. [1] Data for "Forecasting: Principles and Practice" (2nd Edition) - """ - name = "Uschange" - fname = name + ".csv" - path = os.path.join(MODULE, DIRNAME, name, fname) - data = pd.read_csv(path, index_col=0).squeeze("columns") - - # Sort by Quarter then set simple numeric index - # TODO add support for period/datetime indexing - # data.index = pd.PeriodIndex(data.index, freq='Y') - data = data.sort_values("Quarter") - data = data.reset_index(drop=True) - data.index = pd.Index(data.index, dtype=int) - data.name = name - y = data[y_name] - if y_name != "Quarter": - data = data.drop("Quarter", axis=1) - X = data.drop(y_name, axis=1) - return y, X - - def load_gun_point_segmentation(): """Load the GunPoint time series segmentation problem and returns X. @@ -964,7 +717,174 @@ def load_unit_test_tsf(return_type="tsf_default"): ) -def load_solar(): +# forecasting data sets +def load_shampoo_sales(return_array=True): + """Load the shampoo sales univariate time series dataset for forecasting. + + Parameters + ---------- + return_array : bool, default=True + return series as an np.ndarray if True, else as a pd.Series. + + Returns + ------- + np.ndarray or pd.Series + Shampoo sales dataset + + Examples + -------- + >>> from aeon.datasets import load_shampoo_sales + >>> y = load_shampoo_sales() + >>> type(y) + + >>> y = load_shampoo_sales(return_array=False) + >>> type(y) + + + Notes + ----- + This dataset describes the monthly number of sales of shampoo over a 3 + year period. The units are a sales count. + + Dimensionality: univariate + Series length: 36 + Frequency: Monthly + Number of cases: 1 + + References + ---------- + .. [1] Makridakis, Wheelwright and Hyndman (1998) Forecasting: methods + and applications, + John Wiley & Sons: New York. Chapter 3. + """ + name = "ShampooSales" + fname = name + ".csv" + path = os.path.join(MODULE, DIRNAME, name, fname) + y = pd.read_csv(path, index_col=0, dtype={1: float}).squeeze("columns") + if return_array: + return y.values + y.index = pd.PeriodIndex(y.index, freq="M", name="Period") + y.name = "Number of shampoo sales" + return y + + +def load_lynx(return_array=True): + """Load the lynx univariate time series dataset for forecasting. + + Parameters + ---------- + return_array : bool, default=True + return series as an np.ndarray if True, else as a pd.Series. + + Returns + ------- + np.ndarray or pd.Series/DataFrame + Lynx sales dataset + + Examples + -------- + >>> from aeon.datasets import load_lynx + >>> y = load_lynx() + >>> type(y) + + >>> y = load_lynx(return_array=False) + >>> type(y) + + + Notes + ----- + The annual numbers of lynx trappings for 1821–1934 in Canada. This + time-series records the number of skins of + predators (lynx) that were collected over several years by the Hudson's + Bay Company. The dataset was + taken from Brockwell & Davis (1991) and appears to be the series + considered by Campbell & Walker (1977). + + Dimensionality: univariate + Series length: 114 + Frequency: Yearly + Number of cases: 1 + + This data shows aperiodic, cyclical patterns, as opposed to periodic, + seasonal patterns. + + References + ---------- + .. [1] Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988). The New S + Language. Wadsworth & Brooks/Cole. + + .. [2] Campbell, M. J. and Walker, A. M. (1977). A Survey of statistical + work on the Mackenzie River series of + annual Canadian lynx trappings for the years 1821–1934 and a new + analysis. Journal of the Royal Statistical Society + series A, 140, 411–431. + """ + name = "Lynx" + fname = name + ".csv" + path = os.path.join(MODULE, DIRNAME, name, fname) + y = pd.read_csv(path, index_col=0, dtype={1: float}).squeeze("columns") + if return_array: + return y.values + y.index = pd.PeriodIndex(y.index, freq="Y", name="Period") + y.name = "Number of Lynx trappings" + return y + + +def load_airline(return_array=True): + """Load the airline univariate time series dataset [1]. + + Parameters + ---------- + return_array : bool, default=True + return series as an np.ndarray if True, else as a pd.Series. + + Returns + ------- + np.ndarray or pd.Series + Airline time series + + Examples + -------- + >>> from aeon.datasets import load_airline + >>> y = load_airline() + >>> type(y) + + >>> y = load_airline(return_array=False) + >>> type(y) + + + Notes + ----- + The classic Box & Jenkins airline data. Monthly totals of international + airline passengers, 1949 to 1960. + + Dimensionality: univariate + Series length: 144 + Frequency: Monthly + Number of cases: 1 + + This data shows an increasing trend, non-constant (increasing) variance + and periodic, seasonal patterns. + + References + ---------- + .. [1] Box, G. E. P., Jenkins, G. M. and Reinsel, G. C. (1976) Time Series + Analysis, Forecasting and Control. Third Edition. Holden-Day. + Series G. + """ + name = "Airline" + fname = name + ".csv" + path = os.path.join(MODULE, DIRNAME, name, fname) + y = pd.read_csv(path, index_col=0, dtype={1: float}).squeeze("columns") + if return_array: + return y.values + # make sure time index is properly formatted + y.index = pd.PeriodIndex(y.index, freq="M", name="Period") + y.name = "Number of airline passengers" + return y + + +def load_solar(return_array=True): """Get national solar estimates for GB from Sheffield Solar PV_Live API. This function calls the Sheffield Solar PV_Live API to extract national solar data @@ -973,16 +893,21 @@ def load_solar(): unknown. The returned time series is half hourly. For more information please refer - to [1, 2]_. + to [1]_. + + Parameters + ---------- + return_array : bool, default=True + return series as an np.ndarray if True, else as a pd.Series. Returns ------- - pd.Series + np.ndarray or pd.Series + Example Sheffield sloar time series References ---------- .. [1] https://www.solar.sheffield.ac.uk/pvlive/ - .. [2] https://www.solar.sheffield.ac.uk/pvlive/api/ Examples -------- @@ -993,6 +918,118 @@ def load_solar(): fname = name + ".csv" path = os.path.join(MODULE, DIRNAME, name, fname) y = pd.read_csv(path, index_col=0, parse_dates=["datetime_gmt"], dtype={1: float}) - y = y.asfreq("30T") + y = y.asfreq("30min") y = y.squeeze("columns") + if return_array: + return y.values return y + + +def load_uschange(y_name="Consumption"): + """Load MTS dataset for forecasting Growth rates of personal consumption and income. + + Returns + ------- + y : pd.Series + selected column, default is Consumption + X : pd.DataFrame + columns with explanatory variables + + Examples + -------- + >>> from aeon.datasets import load_uschange + >>> y, X = load_uschange() + + Notes + ----- + Percentage changes in quarterly personal consumption expenditure, + personal disposable income, production, savings and the + unemployment rate for the US, 1960 to 2016. + + + Dimensionality: multivariate + Columns: ['Quarter', 'Consumption', 'Income', 'Production', + 'Savings', 'Unemployment'] + Series length: 188 + Frequency: Quarterly + Number of cases: 1 + + This data shows an increasing trend, non-constant (increasing) variance + and periodic, seasonal patterns. + + References + ---------- + .. [1] Data for "Forecasting: Principles and Practice" (2nd Edition) + """ + name = "Uschange" + fname = name + ".csv" + path = os.path.join(MODULE, DIRNAME, name, fname) + data = pd.read_csv(path, index_col=0).squeeze("columns") + data = data.sort_values("Quarter") + data = data.reset_index(drop=True) + data.index = pd.Index(data.index, dtype=int) + data.name = name + y = data[y_name] + if y_name != "Quarter": + data = data.drop("Quarter", axis=1) + X = data.drop(y_name, axis=1) + return y, X + + +def load_longley(y_name="TOTEMP"): + """Load the Longley dataset for forecasting with exogenous variables. + + Parameters + ---------- + y_name: str, default="TOTEMP" + Name of target variable (y) + + Returns + ------- + y: pd.Series + The target series to be predicted. + X: pd.DataFrame + The exogenous time series data for the problem. + + Examples + -------- + >>> from aeon.datasets import load_longley + >>> y, X = load_longley() + + Notes + ----- + This mulitvariate time series dataset contains various US macroeconomic + variables from 1947 to 1962 that are known to be highly collinear. + + Dimensionality: multivariate, 6 + Series length: 16 + Frequency: Yearly + Number of cases: 1 + + Variable description: + + TOTEMP - Total employment + GNPDEFL - Gross national product deflator + GNP - Gross national product + UNEMP - Number of unemployed + ARMED - Size of armed forces + POP - Population + + References + ---------- + .. [1] Longley, J.W. (1967) "An Appraisal of Least Squares Programs for the + Electronic Computer from the Point of View of the User." Journal of + the American Statistical Association. 62.319, 819-41. + (https://www.itl.nist.gov/div898/strd/lls/data/LINKS/DATA/Longley.dat) + """ + name = "Longley" + fname = name + ".csv" + path = os.path.join(MODULE, DIRNAME, name, fname) + data = pd.read_csv(path, index_col=0) + data = data.set_index("YEAR") + data.index = pd.PeriodIndex(data.index, freq="Y", name="Period") + data = data.astype(float) + + # Get target series + y = data.pop(y_name) + return y, data diff --git a/aeon/datasets/tests/test_load_forecasting.py b/aeon/datasets/tests/test_load_forecasting.py index cf90835307..e1ed0999af 100644 --- a/aeon/datasets/tests/test_load_forecasting.py +++ b/aeon/datasets/tests/test_load_forecasting.py @@ -7,66 +7,9 @@ from pandas.testing import assert_frame_equal import aeon -from aeon.datasets import load_forecasting, load_from_tsf_file, load_uschange +from aeon.datasets import load_forecasting, load_from_tsf_file from aeon.testing.testing_config import PR_TESTING -_CHECKS = { - "uschange": { - "columns": ["Income", "Production", "Savings", "Unemployment"], - "len_y": 187, - "len_X": 187, - "data_types_X": { - "Income": "float64", - "Production": "float64", - "Savings": "float64", - "Unemployment": "float64", - }, - "data_type_y": "float64", - "data": load_uschange(), - }, -} - - -@pytest.mark.skipif( - PR_TESTING, - reason="Only run on overnights because of intermittent fail for read/write", -) -@pytest.mark.parametrize("dataset", sorted(_CHECKS.keys())) -def test_forecasting_data_loaders(dataset): - """ - Assert if datasets are loaded correctly. - - dataset: dictionary with values to assert against should contain: - 'columns' : list with column names in correct order, - 'len_y' : length of the y series (int), - 'len_X' : length of the X series/dataframe (int), - 'data_types_X' : dictionary with column name keys and dtype as value, - 'data_type_y' : dtype if y column (string) - 'data' : tuple with y series and X series/dataframe if one is not - applicable fill with None value, - """ - checks = _CHECKS[dataset] - y = checks["data"][0] - X = checks["data"][1] - - if y is not None: - assert isinstance(y, pd.Series) - assert len(y) == checks["len_y"] - assert y.dtype == checks["data_type_y"] - - if X is not None: - if len(checks["data_types_X"]) > 1: - assert isinstance(X, pd.DataFrame) - else: - assert isinstance(X, pd.Series) - - assert X.columns.values.tolist() == checks["columns"] - - for col, dt in checks["data_types_X"].items(): - assert X[col].dtype == dt - - assert len(X) == checks["len_X"] - @pytest.mark.skipif( PR_TESTING, diff --git a/aeon/datasets/tests/test_single_problem_loaders.py b/aeon/datasets/tests/test_single_problem_loaders.py index 9436c37964..f8ce59d087 100644 --- a/aeon/datasets/tests/test_single_problem_loaders.py +++ b/aeon/datasets/tests/test_single_problem_loaders.py @@ -9,18 +9,23 @@ import aeon from aeon.datasets import ( # Univariate; Unequal length; Multivariate load_acsf1, + load_airline, load_arrow_head, load_basic_motions, load_covid_3month, load_from_tsf_file, load_italy_power_demand, load_japanese_vowels, + load_longley, + load_lynx, load_macroeconomic, load_osuleaf, load_plaid, + load_shampoo_sales, load_solar, load_unit_test, load_unit_test_tsf, + load_uschange, ) from aeon.utils.validation._dependencies import _check_soft_dependencies @@ -41,7 +46,7 @@ @pytest.mark.parametrize("loader", UNEQUAL_LENGTH_PROBLEMS) -def test_load_dataframe(loader): +def test_load_unequal_length(loader): """Test unequal length baked in TSC problems load into List of numpy.""" # should work for all X, y = loader() @@ -63,7 +68,7 @@ def test_load_numpy3d(loader): @pytest.mark.parametrize("loader", UNIVARIATE_PROBLEMS) def test_load_numpy2d_uni(loader): - """Test equal length TSC problems load into numpy3d.""" + """Test equal length univariate TSC problems can be loaded into numpy2d.""" X, y = loader(return_type="numpy2d") assert isinstance(X, np.ndarray) assert isinstance(y, np.ndarray) @@ -123,3 +128,72 @@ def test_load_covid_3month(): assert len(X) == len(y) assert X.shape == (201, 1, 84) assert isinstance(y, np.ndarray) + + +def test_shampoo_sales(): + """Test baked in loader of shampoo sales.""" + y = load_shampoo_sales() + assert isinstance(y, np.ndarray) + y2 = load_shampoo_sales(return_array=False) + assert isinstance(y2, pd.Series) + assert y2.shape == (36,) + assert y.shape == y2.shape + + +def test_lynx(): + """Test baked in loader of lynx data.""" + y = load_lynx() + assert isinstance(y, np.ndarray) + y2 = load_lynx(return_array=False) + assert isinstance(y2, pd.Series) + assert y2.shape == (114,) + assert y.shape == y2.shape + + +def test_airline(): + """Test baked in loader of lynx data.""" + y = load_airline() + assert isinstance(y, np.ndarray) + y2 = load_airline(return_array=False) + assert isinstance(y2, pd.Series) + assert y2.shape == (144,) + assert y.shape == y2.shape + + +def test_solar(): + """Test function to load solar data.""" + y = load_solar() + assert isinstance(y, np.ndarray) + y2 = load_solar(return_array=False) + assert isinstance(y2, pd.Series) + assert y2.shape == (289,) + assert y.shape == y2.shape + + +def test_uschange(): + """Test if uschange dataset is loaded correctly.""" + y, X = load_uschange() + assert isinstance(y, pd.Series) + assert len(y) == 187 + assert y.dtype == "float64" + assert isinstance(X, pd.DataFrame) + col_names = ["Income", "Production", "Savings", "Unemployment"] + + assert X.columns.values.tolist() == col_names + for col in col_names: + assert X[col].dtype == "float64" + assert len(X) == len(y) + + +def test_longley(): + """Test if longley dataset is loaded correctly.""" + y, X = load_longley() + assert isinstance(y, pd.Series) + assert len(y) == 16 + assert y.dtype == "float64" + assert isinstance(X, pd.DataFrame) + col_names = ["GNPDEFL", "GNP", "UNEMP", "ARMED", "POP"] + assert X.columns.values.tolist() == col_names + for col in col_names: + assert X[col].dtype == "float64" + assert len(X) == len(y) From d4e801dabf281d9ede3799725792e4e3e3ef74f6 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Mon, 28 Oct 2024 19:54:40 +0000 Subject: [PATCH 04/26] testing with airline --- aeon/testing/data_generation/hierarchical.py | 2 +- .../series/tests/test_series_plotting.py | 2 +- docs/getting_started.md | 24 +++++++++++-------- 3 files changed, 16 insertions(+), 12 deletions(-) diff --git a/aeon/testing/data_generation/hierarchical.py b/aeon/testing/data_generation/hierarchical.py index 178ee25f7b..34a94df4cc 100644 --- a/aeon/testing/data_generation/hierarchical.py +++ b/aeon/testing/data_generation/hierarchical.py @@ -139,7 +139,7 @@ def _bottom_hier_datagen( rng = np.random.default_rng(random_seed) - base_ts = load_airline() + base_ts = load_airline(return_array=False) df = pd.DataFrame(base_ts, index=base_ts.index) df.index.rename(None, inplace=True) diff --git a/aeon/visualisation/series/tests/test_series_plotting.py b/aeon/visualisation/series/tests/test_series_plotting.py index c3c878ec19..b54c1f9fbc 100644 --- a/aeon/visualisation/series/tests/test_series_plotting.py +++ b/aeon/visualisation/series/tests/test_series_plotting.py @@ -17,7 +17,7 @@ plot_spectrogram, ) -y_airline = load_airline() +y_airline = load_airline(return_array=False) y_airline_true = y_airline.iloc[y_airline.index < "1960-01"] y_airline_test = y_airline.iloc[y_airline.index >= "1960-01"] series_to_test = [y_airline, (y_airline_true, y_airline_test)] diff --git a/docs/getting_started.md b/docs/getting_started.md index a7fc41b778..60f508204f 100644 --- a/docs/getting_started.md +++ b/docs/getting_started.md @@ -51,7 +51,7 @@ the heartbeat ECG reading from a single sensor or the number of passengers using airline per month would form a univariate series. Single time series are stored by default in a numpy array as algorithms use arrays internally whenever possible. We can also handle `pd.Series` and `pd.DataFrame` objects, but these are simply -converted to `np.ndarray` internally. +converted to `np.ndarray` internally. The airline data ```{code-block} python >>> from aeon.datasets import load_airline @@ -74,14 +74,12 @@ follows the shape `(n_channels, n_timepoints)` when stored in numpy arrays ```{code-block} python >>> from aeon.datasets import load_uschange >>> data = load_uschange() # load an example multivariate series ->>> data[:5] - Consumption Income Production Savings Unemployment -Quarter -1970 Q1 0.615986 0.972261 -2.452700 4.810312 0.9 -1970 Q2 0.460376 1.169085 -0.551525 7.287992 0.5 -1970 Q3 0.876791 1.553271 -0.358708 7.289013 0.5 -1970 Q4 -0.274245 -0.255272 -2.185455 0.985230 0.7 -1971 Q1 1.897371 1.987154 1.909734 3.657771 -0.1 +>>> data[:,:5] +[[ 0.61598622 0.46037569 0.87679142 -0.27424514 1.89737076] + [ 0.97226104 1.16908472 1.55327055 -0.25527238 1.98715363] + [-2.45270031 -0.55152509 -0.35870786 -2.18545486 1.90973412] + [ 4.8103115 7.28799234 7.28901306 0.98522964 3.65777061] + [ 0.9 0.5 0.5 0.7 -0.1 ]] ``` We commonly refer to the number of observations for a time series as `n_timepoints`. @@ -89,10 +87,12 @@ If a series is multivariate, we refer to the dimensions as channels (to avoid confusion with the dimensions of array) and in code use `n_channels`. So the US Change data loaded above has five channels ( ) and 187 time points. +## Single series estimators Different `aeon` module work with single series or collections of series. Estimators in the `anomaly detection` and `segmentation` modules use single -series input (they inherit from `BaseSeriesEstimator`). +series input (they inherit from `BaseSeriesEstimator`). The functions in `distances` +take two series as arguments. ### Time Series Anomaly Detection (TSAD) @@ -102,6 +102,10 @@ series input (they inherit from `BaseSeriesEstimator`). Coming soon, we are relaunching our forecasting module. +### Time Series Distances + + + ### Transformers for Single Time Series Transformers inheriting from the [BaseSeriesTransformer](transformations.base.BaseSeriesTransformer) From 63becd50c10f511b8d3e3c56ae8de528fdb523c4 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Mon, 28 Oct 2024 20:10:49 +0000 Subject: [PATCH 05/26] notebook --- examples/datasets/provided_data.ipynb | 1222 +++++++++++-------------- 1 file changed, 538 insertions(+), 684 deletions(-) diff --git a/examples/datasets/provided_data.ipynb b/examples/datasets/provided_data.ipynb index 0d1f632569..ba3529e161 100644 --- a/examples/datasets/provided_data.ipynb +++ b/examples/datasets/provided_data.ipynb @@ -2,58 +2,62 @@ "cells": [ { "cell_type": "markdown", - "metadata": {}, "source": [ "# Provided datasets\n", "\n", "`aeon` ships several example data sets for machine learning tasks in the module\n", "`datasets`. This notebook gives an overview of what is available by default. For\n", "downloading data from other archives, see the [loading data from web notebook](load_data_from_web.ipynb). For further details on the form of the\n", - "data, see the [data loading notebook](data_loading.ipynb).\n", - "\n", - "## Forecasting\n", - "\n", - "Forecasting data are stored in csv files with a header for column names. Six standard\n", - " example datasets are shipped by default:\n", - "\n", - "| dataset name | loader function | properties |\n", - "|----------|:-------------:|------:|\n", - "| Box/Jenkins airline data | `load_airline` | univariate |\n", - "| Lynx sales data | `load_lynx` | univariate |\n", - "| Shampoo sales data | `load_shampoo_sales` | univariate |\n", - "| Pharmaceutical Benefit Scheme data | `load_PBS_dataset` | univariate |\n", - "| Longley US macroeconomic data | `load_longley` | multivariate |\n", - "| MTS consumption/income data | `load_uschange` | multivariate |\n", - "\n", - " These are stored in csv format in time, value format, including a header. For\n", - " forcasting files, each column that is not an index is considered a time series. For\n", - " example, the airline data has a single time series each row a time, value pair:\n", - "\n", - " Date,Passengers\n", - " 1949-01,112\n", - " 1949-02,118\n", - "\n", - "Longley has seven time series, each in its own column. Each row is the same time index:\n", + "data, see the [data loading notebook](data_loading.ipynb)." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "## Time series clustering, classification and regression\n", "\n", - " \"Obs\",\"TOTEMP\",\"GNPDEFL\",\"GNP\",\"UNEMP\",\"ARMED\",\"POP\",\"YEAR\"\n", - " 1,60323,83,234289,2356,1590,107608,1947\n", - " 2,61122,88.5,259426,2325,1456,108632,1948\n", - " 3,60171,88.2,258054,3682,1616,109773,1949\n", + "We ship several datasets from the UCR/TSML archives. The complete archives (including\n", + " these examples) are available at the [time series classification site](https://timeseriesclassification.com)\n", + " and the [UCR classification and clustering site](https://www.cs.ucr.edu/~eamonn/time_series_data_2018/).\n", + " All the archive data can be loaded from these websites or directly\n", + "from the web in code, see [data downloads](load_data_from_web.ipynb). All\n", + " data is provided with a default train, test split. Problem loaders have an argument\n", + " `split`. If not set, the function returns the combined train and test data. If\n", + " `split` is set to `\"test\"` or `\"train\"`, the required split is return. `split` is\n", + " not case sensitive. They can also be loaded with the functions `load_classification`\n", + " and `load_regression`, which also return meta data. See the notebook [data loading](data_loading.ipynb) for details. The data X is stored in a 3D\n", + " numpy array of shape `(n_cases, n_channels, n_timepoints)` unless unequal length,\n", + " in which case a list of 2D numpy array is returned.\n", "\n", - "The problem specific loading functions return the series as either a `pd.Series` if\n", - "a single series or, if multiple series, a `pd.DataFrame` with each column a series.\n", - "There are currently six forecasting problems\n", - "shipped." - ] + "| dataset name | loader function | properties |\n", + "|-----------------------------|:-------------:|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------:|\n", + "| Appliance power consumption | `load_acsf1` | univariate, equal length |\n", + "| Arrowhead shape | `load_arrow_head` | univariate, equal length |\n", + "| Gunpoint motion | `load_gunpoint` | univariate, equal length |\n", + "| Italy power demand | `load_italy_power_demand` | univariate, equal length |\n", + "| Japanese vowels | `load_japanese_vowels` |

univariate, unequal length |\n", + "| OSUleaf leaf shape | `load_osuleaf` | univariate, equal length |\n", + "| Basic motions | `load_basic_motions` | multivariate, equal length |\n", + "\n" + ], + "metadata": { + "collapsed": false + } }, { "cell_type": "markdown", "source": [ - "### Airline\n", + "### ACSF1\n", "\n", - "The classic Box & Jenkins airline data. Monthly totals of international\n", - " airline passengers, 1949 to 1960. This data shows an increasing trend,\n", - " non-constant (increasing) variance and periodic, seasonal patterns. The\n" + "The dataset is compiled from ACS-F1, the first version of the database of appliance\n", + "consumption signatures. The dataset contains the power consumption of typical appliances. The recordings are characterized by long idle periods and some high bursts of energy consumption when the appliance is active.\n", + "\n", + "The classes correspond to 10 categories of home appliances: mobile phones (via chargers), coffee machines, computer stations (including monitor), fridges and freezers, Hi-Fi systems (CD players), lamp (CFL), laptops (via chargers), microwave ovens, printers, and televisions (LCD or LED).\n", + "\n", + "The problem is univariate and equal length. It has high frequency osscilation." ], "metadata": { "collapsed": false @@ -62,30 +66,39 @@ { "cell_type": "code", "source": [ - "import warnings\n", - "\n", - "from aeon.datasets import load_airline\n", - "from aeon.visualisation import plot_series\n", + "import matplotlib.pyplot as plt\n", "\n", - "warnings.filterwarnings(\"ignore\")\n", + "from aeon.datasets import load_acsf1\n", "\n", - "airline = load_airline()\n", - "plot_series(airline)" + "trainX, trainy = load_acsf1(split=\"train\")\n", + "testX, testy = load_acsf1(split=\"test\")\n", + "print(type(trainX))\n", + "print(trainX.shape)\n", + "plt.plot(trainX[0][0][:100])\n", + "plt.title(\n", + " f\"First 100 observations of the first train case of the ACFS1 data, class: \"\n", + " f\"({trainy[0]})\"\n", + ")" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-09-25T22:58:18.616123Z", - "start_time": "2024-09-25T22:58:08.862906Z" + "end_time": "2024-09-25T22:58:20.673104Z", + "start_time": "2024-09-25T22:58:20.238813Z" } }, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "(100, 1, 1460)\n" + ] + }, { "data": { - "text/plain": [ - "(
,\n", - " )" - ] + "text/plain": "Text(0.5, 1.0, 'First 100 observations of the first train case of the ACFS1 data, class: (9)')" }, "execution_count": 1, "metadata": {}, @@ -93,10 +106,8 @@ }, { "data": { - "text/plain": [ - "
" - ], - "image/png": "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" + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -107,16 +118,17 @@ { "cell_type": "markdown", "source": [ - "### Longley\n", - "This mulitvariate time series dataset contains various US macroeconomic\n", - " variables from 1947 to 1962 that are known to be highly collinear. This loader\n", - " returns the series to be forecast (default TOTEMP: total employment) and other\n", - " variables that may be useful in the forecast\n", - " GNPDEFL - Gross national product deflator\n", - " GNP - Gross national product\n", - " UNEMP - Number of unemployed\n", - " ARMED - Size of armed forces\n", - " POP - Population\n" + "### ArrowHead\n", + "The arrowhead data consists of outlines of the images of\n", + "arrowheads. The shapes of the projectile points are converted into\n", + "a time series using the angle-based method. The classification of\n", + "projectile points is is an important\n", + "topic in anthropology. The classes are based on shape\n", + "distinctions, such as the presence and location of a notch in the\n", + "arrow. The problem in the repository is a length normalised version\n", + "of that used in Ye09shapelets. The three classes are called\n", + "\"Avonlea\" (0), \"Clovis\" (1) and \"Mix\" (2).\n" ], "metadata": { "collapsed": false @@ -125,24 +137,36 @@ { "cell_type": "code", "source": [ - "from aeon.datasets import load_longley\n", + "from aeon.datasets import load_arrow_head\n", + "\n", + "arrowhead, arrow_labels = load_arrow_head()\n", + "print(arrowhead.shape)\n", + "plt.title(\n", + " f\"First two cases of the ArrowHead, classes: \"\n", + " f\"({arrow_labels[0]}, {arrow_labels[1]})\"\n", + ")\n", "\n", - "employment, longley = load_longley()\n", - "plot_series(employment)" + "plt.plot(arrowhead[0][0])\n", + "plt.plot(arrowhead[1][0])" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-09-25T22:58:18.803829Z", - "start_time": "2024-09-25T22:58:18.622082Z" + "end_time": "2024-09-25T22:58:20.861894Z", + "start_time": "2024-09-25T22:58:20.689090Z" } }, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(211, 1, 251)\n" + ] + }, { "data": { - "text/plain": [ - "(
, )" - ] + "text/plain": "[]" }, "execution_count": 2, "metadata": {}, @@ -150,10 +174,8 @@ }, { "data": { - "text/plain": [ - "
" - ], - "image/png": "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" + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -164,11 +186,12 @@ { "cell_type": "markdown", "source": [ - "### Lynx\n", + "### BasicMotions\n", "\n", - "The annual numbers of lynx trappings for 1821–1934 in Canada. This\n", - " time-series records the number of skins of predators (lynx) that were collected\n", - " over several years by the Hudson's Bay Company. Returns a pd.Series" + "The data was generated as part of a student project where four students performed our activities whilst wearing a smart watch.\n", + "The watch collects 3D accelerometer and a 3D gyroscope It consists of four classes, which are walking, resting, running and\n", + "badminton. Participants were required to record motion a total of five times, and the data is sampled once every tenth of a second,\n", + "for a ten second period. The data is multivariate (six channels) equal length." ], "metadata": { "collapsed": false @@ -177,24 +200,27 @@ { "cell_type": "code", "source": [ - "from aeon.datasets import load_lynx\n", + "from aeon.datasets import load_basic_motions\n", "\n", - "lynx = load_lynx()\n", - "plot_series(lynx)" + "motions, motions_labels = load_basic_motions(split=\"train\")\n", + "plt.title(\n", + " f\"First and second dimensions of the first train instance in BasicMotions data, \"\n", + " f\"(student {motions_labels[0]})\"\n", + ")\n", + "plt.plot(motions[0][0])\n", + "plt.plot(motions[0][1])" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-09-25T22:58:19.214127Z", - "start_time": "2024-09-25T22:58:19.016116Z" + "end_time": "2024-09-25T22:58:21.053382Z", + "start_time": "2024-09-25T22:58:20.879846Z" } }, "outputs": [ { "data": { - "text/plain": [ - "(
, )" - ] + "text/plain": "[]" }, "execution_count": 3, "metadata": {}, @@ -202,10 +228,8 @@ }, { "data": { - "text/plain": [ - "
" - ], - "image/png": "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" + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -216,11 +240,16 @@ { "cell_type": "markdown", "source": [ - "### PBS_dataset\n", + "### GunPoint\n", "\n", - "The Pharmaceutical Benefits Scheme (PBS) is the Australian government drugs\n", - " subsidy scheme. Data comprises of the numbers of scripts sold each month for immune sera\n", - " and immunoglobulin products in Australia. The load function returns a pd.Series." + "This dataset involves one female actor and one male actor making a motion with their\n", + "hand. The two classes are: Gun-Draw and Point: For Gun-Draw the actors have their\n", + "hands by their sides. They draw a replicate gun from a hip-mounted holster, point it\n", + "at a target for approximately one second, then return the gun to the holster, and\n", + "their hands to their sides. For Point the actors have their gun by their sides. They\n", + "point with their index fingers to a target for approximately one second, and then\n", + "return their hands to their sides. For both classes, The data in the archive is the\n", + "X-axis motion of the actors right hand.\n" ], "metadata": { "collapsed": false @@ -229,24 +258,28 @@ { "cell_type": "code", "source": [ - "from aeon.datasets import load_PBS_dataset\n", + "from aeon.datasets import load_gunpoint\n", "\n", - "pbs = load_PBS_dataset()\n", - "plot_series(pbs)" + "gun, gun_labels = load_gunpoint(split=\"test\")\n", + "plt.title(\n", + " f\"First three cases of the test set for GunPoint, classes\"\n", + " f\"(actor {gun_labels[0]}, {gun_labels[1]}, {gun_labels[2]})\"\n", + ")\n", + "plt.plot(gun[0][0])\n", + "plt.plot(gun[1][0])\n", + "plt.plot(gun[2][0])" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-09-25T22:58:19.433684Z", - "start_time": "2024-09-25T22:58:19.242052Z" + "end_time": "2024-09-25T22:58:21.247394Z", + "start_time": "2024-09-25T22:58:21.075323Z" } }, "outputs": [ { "data": { - "text/plain": [ - "(
, )" - ] + "text/plain": "[]" }, "execution_count": 4, "metadata": {}, @@ -254,10 +287,8 @@ }, { "data": { - "text/plain": [ - "
" - ], - "image/png": "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" + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -268,10 +299,12 @@ { "cell_type": "markdown", "source": [ - "### ShampooSales\n", - "\n", - "ShampooSales contains a single monthly time series of the number of sales of\n", - "shampoo over a three year period. The units are a sales count." + "### ItalyPowerDemand\n", + "The data was derived from twelve monthly electrical power demand time series from\n", + "Italy and first used in the paper \"Intelligent Icons: Integrating Lite-Weight Data\n", + "Mining and Visualization into GUI Operating Systems\". The classification task is to\n", + "distinguish days from Oct to March (inclusive) (class 0) from April to September\n", + "(class 1). The problem is univariate, equal length.\n" ], "metadata": { "collapsed": false @@ -280,32 +313,28 @@ { "cell_type": "code", "source": [ - "from aeon.datasets import load_shampoo_sales\n", + "from aeon.datasets import load_italy_power_demand\n", "\n", - "shampoo = load_shampoo_sales()\n", - "print(type(shampoo))\n", - "plot_series(shampoo)" + "italy, italy_labels = load_italy_power_demand(split=\"train\")\n", + "plt.title(\n", + " f\"First three cases of the test set for ItalyPowerDemand, classes\"\n", + " f\"( {italy_labels[0]}, {italy_labels[1]}, {italy_labels[2]})\"\n", + ")\n", + "plt.plot(italy[0][0])\n", + "plt.plot(italy[1][0])\n", + "plt.plot(italy[2][0])" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-09-25T22:58:19.594227Z", - "start_time": "2024-09-25T22:58:19.439671Z" + "end_time": "2024-09-25T22:58:21.419932Z", + "start_time": "2024-09-25T22:58:21.266319Z" } }, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - }, { "data": { - "text/plain": [ - "(
, )" - ] + "text/plain": "[]" }, "execution_count": 5, "metadata": {}, @@ -313,10 +342,8 @@ }, { "data": { - "text/plain": [ - "
" - ], - "image/png": "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" + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -327,15 +354,18 @@ { "cell_type": "markdown", "source": [ + "### JapaneseVowels\n", "\n", + "A UCI Archive dataset. See this link for more [detailed information](https://archive.ics.uci.edu/ml/datasets/Japanese+Vowels)\n", "\n", - "### UsChange\n", + "Paper: M. Kudo, J. Toyama and M. Shimbo. (1999). \"Multidimensional Curve Classification Using Passing-Through Regions\". Pattern Recognition Letters, Vol. 20, No. 11--13, pages 1103--1111.\n", "\n", - "Load MTS dataset for forecasting Growth rates of personal consumption and income. The\n", - " data is quarterly for 188 quarters and contains time series for\n", - " Consumption, Income, Production, Savings and Unemployment. It returns a pd.Series to\n", - " forecast (by default, the series Consumption) and a pd.DataFrame containing the\n", - " other series." + "9 Japanese-male speakers were recorded saying the vowels 'a' and 'e'. A '12-degree linear prediction analysis' is applied to the raw recordings to obtain time-series with 12 dimensions and series lengths between 7 and 29. The classification task is to predict the speaker. Therefore, each instance is a transformed utterance, 12*29 values with a single class label attached, [1...9].\n", + "\n", + "The given training set is comprised of 30 utterances for each speaker, however the\n", + "test set has a varied distribution based on external factors of timing and\n", + "experimental availability, between 24 and 88 instances per speaker. The data is\n", + "unequal length" ], "metadata": { "collapsed": false @@ -344,17 +374,27 @@ { "cell_type": "code", "source": [ - "from aeon.datasets import load_uschange\n", + "from aeon.datasets import load_japanese_vowels\n", "\n", - "consumption, others = load_uschange()\n", - "print(type(consumption))\n", - "plot_series(consumption)" + "japan, japan_labels = load_japanese_vowels(split=\"train\")\n", + "plt.title(\n", + " f\"First channel of three test cases for JapaneseVowels, classes\"\n", + " f\"({japan_labels[0]}, {japan_labels[10]}, {japan_labels[200]})\"\n", + ")\n", + "print(f\" number of cases = \" f\"{len(japan)}\")\n", + "print(f\" First case shape = \" f\"{japan[0].shape}\")\n", + "print(f\" Tenth case shape = \" f\"{japan[10].shape}\")\n", + "print(f\" 200th case shape = \" f\"{japan[200].shape}\")\n", + "\n", + "plt.plot(japan[0][0])\n", + "plt.plot(japan[10][0])\n", + "plt.plot(japan[200][0])" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-09-25T22:58:19.784741Z", - "start_time": "2024-09-25T22:58:19.608190Z" + "end_time": "2024-09-25T22:58:21.705366Z", + "start_time": "2024-09-25T22:58:21.437860Z" } }, "outputs": [ @@ -362,14 +402,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "\n" + " number of cases = 270\n", + " First case shape = (12, 20)\n", + " Tenth case shape = (12, 23)\n", + " 200th case shape = (12, 13)\n" ] }, { "data": { - "text/plain": [ - "(
, )" - ] + "text/plain": "[]" }, "execution_count": 6, "metadata": {}, @@ -377,10 +418,8 @@ }, { "data": { - "text/plain": [ - "
" - ], - "image/png": "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" + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -391,46 +430,44 @@ { "cell_type": "markdown", "source": [ - "### Solar\n", - "Example national solar data\n", - " for the GB eletricity network extracted from the Sheffield Solar PV_Live API.\n", - " Note that these are estimates of the true solar\n", - " generation, since the true values are \"behind the meter\" and essentially\n", - " unknown. The returned pandas DataSeries is half hourly." - ], - "metadata": { - "collapsed": false - } - }, - { + "### OSUleaf\n", + "\n", + "The OSULeaf data set consist of one dimensional outlines of leaves. The series were\n", + "obtained by color image segmentation and boundary extraction (in the anti-clockwise\n", + "direction) from digitized leaf images of six classes: Acer Circinatum, Acer Glabrum,\n", + "Acer Macrophyllum, Acer Negundo, Quercus Garryana and Quercus Kelloggii for the MSc\n", + "thesis \"Content-Based Image Retrieval: Plant Species Identification\" by A. Grandhi.\n", + "OSULeaf is equal length and univariate" + ], + "metadata": { + "collapsed": false + } + }, + { "cell_type": "code", "source": [ - "from aeon.datasets import load_solar\n", + "from aeon.datasets import load_osuleaf\n", "\n", - "solar = load_solar()\n", - "print(type(solar))\n", - "plot_series(solar)" + "leaf, leaf_labels = load_osuleaf(split=\"train\")\n", + "plt.title(\n", + " f\"First three cases of the test set for OSULeaf, classes\"\n", + " f\" ({leaf_labels[0]}, {leaf_labels[1]}, {leaf_labels[2]})\"\n", + ")\n", + "plt.plot(leaf[0][0])\n", + "plt.plot(leaf[1][0])\n", + "plt.plot(leaf[2][0])" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-09-25T22:58:20.194929Z", - "start_time": "2024-09-25T22:58:19.800676Z" + "end_time": "2024-09-25T22:58:21.910360Z", + "start_time": "2024-09-25T22:58:21.726272Z" } }, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - }, { "data": { - "text/plain": [ - "(
, )" - ] + "text/plain": "[]" }, "execution_count": 7, "metadata": {}, @@ -438,10 +475,8 @@ }, { "data": { - "text/plain": [ - "
" - ], - "image/png": "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" + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -452,60 +487,14 @@ { "cell_type": "markdown", "source": [ - "## Time series clustering, classification and regression\n", - "\n", - "We ship several datasets from the UCR/TSML archives. The complete archives (including\n", - " these examples) are available at the [time series classification site](https://timeseriesclassification.com)\n", - " and the [UCR classification and clustering site](https://www.cs.ucr.edu/~eamonn/time_series_data_2018/).\n", - " All the archive data can be loaded from these websites or directly\n", - "from the web in code, see [data downloads](load_data_from_web.ipynb). All\n", - " data is provided with a default train, test split. Problem loaders have an argument\n", - " `split`. If not set, the function returns the combined train and test data. If\n", - " `split` is set to `\"test\"` or `\"train\"`, the required split is return. `split` is\n", - " not case sensitive. They can also be loaded with the functions `load_classification`\n", - " and `load_regression`, which also return meta data. See the notebook [data loading](data_loading.ipynb) for details. The data X is stored in a 3D\n", - " numpy array of shape `(n_cases, n_channels, n_timepoints)` unless unequal length,\n", - " in which case a list of 2D numpy array is returned.\n", - "\n", - "| dataset name | loader function | properties |\n", - "|-----------------------------|:-------------:|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------:|\n", - "| Appliance power consumption | `load_acsf1` | univariate, equal length/index |\n", - "| Arrowhead shape | `load_arrow_head` | univariate, equal length/index |\n", - "| Gunpoint motion | `load_gunpoint` | univariate, equal length/index |\n", - "| Italy power demand | `load_italy_power_demand` | univariate, equal length/index |\n", - "| Japanese vowels | `load_japanese_vowels` |

univariate, unequal length/index |\n", - "| OSUleaf leaf shape | `load_osuleaf` | univariate, equal length/index |\n", - "| Basic motions | `load_basic_motions` | multivariate, equal length/index |\n", - "\n" - ], - "metadata": { - "collapsed": false - } - }, - { - "cell_type": "code", - "source": [], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-09-25T22:58:20.220860Z", - "start_time": "2024-09-25T22:58:20.216870Z" - } - }, - "outputs": [], - "execution_count": null - }, - { - "cell_type": "markdown", - "source": [ - "### ACSF1\n", - "\n", - "The dataset is compiled from ACS-F1, the first version of the database of appliance\n", - "consumption signatures. The dataset contains the power consumption of typical appliances. The recordings are characterized by long idle periods and some high bursts of energy consumption when the appliance is active.\n", - "\n", - "The classes correspond to 10 categories of home appliances: mobile phones (via chargers), coffee machines, computer stations (including monitor), fridges and freezers, Hi-Fi systems (CD players), lamp (CFL), laptops (via chargers), microwave ovens, printers, and televisions (LCD or LED).\n", - "\n", - "The problem is univariate and equal length. It has high frequency osscilation." + "### PLAID\n", + "PLAID stands for the Plug Load Appliance Identification Dataset. The data are intended for load identification research. The first version of PLAID is named PLAID1, collected in summer 2013. A second version of PLAID was collected in winter 2014 and released under the name PLAID2.\n", + "This dataset comes from PLAID1. It includes current and voltage measurements sampled at 30 kHz from 11 different appliance types present in more than 56 households in Pittsburgh, Pennsylvania, USA. Data collection took place during the summer of 2013. Each appliance type is represented by dozens of different instances of varying makes/models.\n", + "For each appliance, three to six measurements were collected for each state transition. These measurements were then post-processed to extract a few-second-long window containing both the steady-state operation and the startup transient )when available).\n", + "The classes correspond to 11 different appliance types: air\n", + "conditioner (class 0), compact flourescent lamp, fan, fridge,\n", + "hairdryer , heater, incandescent light bulb, laptop, microwave,\n", + "vacuum,washing machine (class 10). The data is univariate and unequal length." ], "metadata": { "collapsed": false @@ -514,25 +503,27 @@ { "cell_type": "code", "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "from aeon.datasets import load_acsf1\n", + "from aeon.datasets import load_plaid\n", "\n", - "trainX, trainy = load_acsf1(split=\"train\")\n", - "testX, testy = load_acsf1(split=\"test\")\n", - "print(type(trainX))\n", - "print(trainX.shape)\n", - "plt.plot(trainX[0][0][:100])\n", + "plaid, plaid_labels = load_plaid(split=\"train\")\n", "plt.title(\n", - " f\"First 100 observations of the first train case of the ACFS1 data, class: \"\n", - " f\"({trainy[0]})\"\n", - ")" + " f\"three train cases for PLAID, classes\"\n", + " f\"( {plaid_labels[0]}, {plaid_labels[10]}, {plaid_labels[200]})\"\n", + ")\n", + "print(f\" number of cases = \" f\"{len(plaid)}\")\n", + "print(f\" First case shape = \" f\"{plaid[0].shape}\")\n", + "print(f\" Tenth case shape = \" f\"{plaid[10].shape}\")\n", + "print(f\" 200th case shape = \" f\"{plaid[200].shape}\")\n", + "\n", + "plt.plot(plaid[0][0])\n", + "plt.plot(plaid[10][0])\n", + "plt.plot(plaid[200][0])" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-09-25T22:58:20.673104Z", - "start_time": "2024-09-25T22:58:20.238813Z" + "end_time": "2024-09-25T22:58:22.119236Z", + "start_time": "2024-09-25T22:58:21.932521Z" } }, "outputs": [ @@ -540,15 +531,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "\n", - "(100, 1, 1460)\n" + " number of cases = 537\n", + " First case shape = (1, 500)\n", + " Tenth case shape = (1, 300)\n", + " 200th case shape = (1, 200)\n" ] }, { "data": { - "text/plain": [ - "Text(0.5, 1.0, 'First 100 observations of the first train case of the ACFS1 data, class: (9)')" - ] + "text/plain": "[]" }, "execution_count": 8, "metadata": {}, @@ -556,10 +547,8 @@ }, { "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAm8AAAGzCAYAAAB5IvBBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAADkWklEQVR4nO19d7hU1fX2OzO30EGkSUcsWFAQg2I3ErHEErsxEbHFWGJLjCaxRGP41FgSY4nJT02MvUdjwx4VFRELdhCk9965M/v7Y+6cOWWfs8taZ2au7vd5eC53Zu6affY5Z5+137XWuzJCCAEHBwcHBwcHB4cWgWy1B+Dg4ODg4ODg4KAP57w5ODg4ODg4OLQgOOfNwcHBwcHBwaEFwTlvDg4ODg4ODg4tCM55c3BwcHBwcHBoQXDOm4ODg4ODg4NDC4Jz3hwcHBwcHBwcWhCc8+bg4ODg4ODg0ILgnDcHBwcHBwcHhxYEVudt+vTpyGQyuPvuuznNfifw6quvIpPJ4JFHHqn2UCqO0rG/+uqr1R4KCU1NTbjooovQp08fZLNZHH744cY27r77bmQyGbz33nv8Awzhq6++wv7774+OHTsik8ngiSee8L5/+vTpqX9/NdC/f3+cdNJJ1R5GzaOlXcvfZXzbnruZTAZXXHFFtYehjUKhgO233x5XX3218d9u3LgRffr0wa233mr8t0bOW+lmlP27+OKLjb9cB3/84x/xxBNPaH/+tttuw9FHH42+ffsik8kkLtTLli3D6aefjq5du6Jt27bYd9998f7770s/+5///Ac77bQTWrVqhb59++Lyyy9HU1OT4dF8t3Hrrbd+axYYGe68805cd911OOqoo/DPf/4T559/fuxna2EuRo8ejY8//hhXX3017rnnHuy8887s3zFnzhxcccUV+OCDD7Q+/9Zbb+GKK67AsmXL2MfioI+Wdi2X8MwzzyCTyaBnz54oFAqxn1uxYgV+//vfY8cdd0S7du3QunVrbL/99vj1r3+NOXPmeJ876aSTYp95zz33nPe5jz/+GEcddRT69euHVq1aoVevXvjBD36Am2++OfC9L7zwAk455RRsv/32yOVy6N+/P/scmMDdb3Tcf//9mDlzJs4+++zA6xMnTsQBBxyADh06oH379th///0j62B9fT0uuOACXH311Vi3bp3ZFwsD3HXXXQKAuPLKK8U999wT+Ddp0iRRKBTE2rVrRVNTk4nZRLRt21aMHj1a+/P9+vUTnTt3FgcccICoq6uL/dt8Pi9222030bZtW3HFFVeIv/71r2LbbbcV7du3F19++WXgs88884zIZDJi3333FXfccYc455xzRDabFWeccQbhyIJ45ZVXBADx8MMPs9msNWy33XZi7733jryez+fF2rVrRT6fr/ygGHHssceKXr16aX02bi5K99iECROYRxfEmjVrBADx29/+NvB6U1OTWLt2rSgUCizfM2HCBAFA3HXXXVqfv+666wQAMW3aNJbvD2PdunViw4YNqdj+NqElXct+/PjHPxb9+/cXAMS4ceOkn5k6daoYMGCAyOVy4rjjjhN//etfxR133CHOPvtssemmm4ott9zS++zo0aNFY2Nj5Hl3zz33iDlz5gghhHjzzTdFQ0OD2GKLLcRVV10l/v73v4vLLrtM7L///mLgwIGB7x49erRo1aqV2G233UTv3r1Fv379yMc8bdo0o3vMj7TvNxsAEJdffnm1h6GNHXfcUZx++umB1yZOnChatWolttxyS/GnP/1JXHvttaJ///6iQ4cO4vPPPw98dunSpaKhoUH83//9n9H31tl4mgceeGDsLr1Vq1bKv1+9ejXatm1r89VKvPbaax7r1q5du9jPPfLII3jrrbfw8MMP46ijjgIAHHPMMdhqq61w+eWX47777vM++8tf/hI77LADXnjhBdTVFaesQ4cO+OMf/4hzzz0XgwYNSuVYqoU1a9agTZs2Ffu+bDardd3UOhYsWIBOnTpVexhaWLhwIQBExpvL5ZDL5RL/VgiBdevWoXXr1mkNTwuFQgEbNmwwunYaGxtTHNG3By3pWi5h9erVePLJJzF27FjcdddduPfeezFy5MjAZ5qamnDEEUdg/vz5ePXVV7HHHnsE3r/66qtxzTXXBF6rq6vDT37yk9jvvfrqq9GxY0dMmDAhMmcLFiwI/P7HP/4Rf//731FfX48f/vCHmDx5ssWROtQKJk2ahA8//BDXX3994PVLL70UrVu3xvjx47HpppsCAH7yk59gq622wm9+8xs8+uij3mc7deqE/fffH3fffTdOPvlk/S838fRUOynZDmD06NGibdu2YsqUKeLAAw8U7dq1E4cddpgQQogvv/xSHHHEEaJ79+6isbFR9OrVSxx77LFi2bJlQoiiBx7+Z8LCJbF2Rx99tOjevXuE7Tn99NNFmzZtxLp164QQQnzyyScCgLjlllsCn5s9e7YAIK666irlOKZOnSqOOuoosckmm4jWrVuLXXbZRTz99NOBz5SYtwceeEBccsklonv37qJNmzbikEMOETNmzAh8VjVvJdxzzz1ip512Eq1atRKbbLKJOPbYYyO29t57b7HddtuJ9957T+y5556idevW4txzzxUHH3ywGDBggPR4dt11VzFs2DDv9zvvvFPsu+++omvXrqKhoUFss8024tZbbw38Tb9+/SLnsrRbLx37K6+8Evibhx56yBv/pptuKk444QQxa9aswGdK19esWbPEYYcdJtq2bSu6dOkiLrzwwggDfP/994uddtpJtGvXTrRv315sv/324qabbpIeox+rVq0SF1xwgejdu7doaGgQW221lbjuuus8dqp03Yf/hY9HZy5K99gbb7whzj//fNGlSxfRpk0bcfjhh4sFCxZEbD3zzDNijz32EG3atBHt2rUTBx10kJg8eXLi8Vx++eWR7y8xAKXv9+/E+/XrJw4++GDx3HPPiWHDhonGxkZx4403CiGEeOGFF8Tuu+8uOnbsKNq2bSu22morcckllwghyuc1/C+OIZCNyz8WAOKss84S//73v8W2224r6urqxOOPPy6EKDIII0aMEJ07dxatWrUSO+20k5TF7tevX2BNMJ1vGT777DNx9NFHiy5duohWrVqJrbbaSvzmN7/x3p8+fbr4+c9/LrbaaivRqlUr0blzZ3HUUUdF2I4NGzaIK664QmyxxRaisbFRdO7cWey+++7ihRdeiHzfkUceKTbZZBPR2Ngohg0bJp588kmtsX7brmU/7rnnHpHNZsXcuXPFNddcIzp06CDWrl0b+MwDDzwgAIirr75ay2ZpfUnC1ltvLfbZZx/tcZZw8MEHGzNvS5cuFaNHjxYdOnQQHTt2FCeeeKKYNGlS5L768MMPxejRo8WAAQNEY2Oj6N69uxgzZoxYtGiR9xnV/aazrpti7dq14vLLLxdbbrmlaGxsFD169BA/+tGPxJQpU7zPIMS8cd4/c+fOFSeddJLo1auXaGhoED169BCHHnpowNayZcvEZ599FnmeynDZZZeJhoaGCJvfvn17cfTRR0c+f/DBB4uGhgaxcuXKwOt//vOfRSaTEYsXL1Z+ZwlWzNvy5cuxaNGiwGtdunSJ/XxTUxNGjRqFPfbYA3/605/Qpk0bbNiwAaNGjcL69etxzjnnoEePHpg9ezaefvppLFu2DB07dsQ999yDU089FcOHD8fpp58OABg4cKDNkCOYNGkSdtppJ2SzwbS/4cOH44477sCXX36JwYMHY9KkSQAQYRp79uyJ3r17e+/HYf78+dhtt92wZs0a/OIXv8Cmm26Kf/7znzj00EPxyCOP4Ec/+lHg81dffTUymQx+/etfY8GCBbjpppswcuRIfPDBB2jdurXWvJXsXHrppTjmmGNw6qmnYuHChbj55pux1157YdKkSYEd4uLFi3HggQfiuOOOw09+8hN0794dw4YNw4knnogJEybge9/7nvfZb775Bm+//Tauu+4677XbbrsN2223HQ499FDU1dXhqaeewplnnolCoYCzzjoLAHDTTTfhnHPOQbt27fDb3/4WANC9e/fYebv77rsxZswYfO9738PYsWMxf/58/PnPf8abb74ZGX8+n8eoUaOwyy674E9/+hNefPFFXH/99Rg4cCB+/vOfAwDGjRuH448/Hvvtt5+3s/7ss8/w5ptv4txzz40dhxAChx56KF555RWccsopGDJkCJ5//nn86le/wuzZs3HjjTeia9euuOeee3D11Vdj1apVGDt2LABgm222kdrUmYtzzjkHm2yyCS6//HJMnz4dN910E84++2w8+OCD3mfuuecejB49GqNGjcI111yDNWvW4LbbbsMee+yBSZMmxebTHHHEEejUqRPOP/98HH/88TjooIMSWWoA+OKLL3D88cfjZz/7GU477TRsvfXW+OSTT/DDH/4QO+ywA6688ko0NjZiypQpePPNN73jv/LKK3HZZZfh9NNPx5577gkA2G233WLH9eWXX+L+++/HjTfe6K0pXbt29T7z8ssv46GHHsLZZ5+NLl26eMf45z//GYceeihOOOEEbNiwAQ888ACOPvpoPP300zj44IMTj013vmX46KOPsOeee6K+vh6nn346+vfvj6lTp+Kpp57yEpgnTJiAt956C8cddxx69+6N6dOn47bbbsM+++yDTz/91GO5r7jiCowdO9Zb81asWIH33nsP77//Pn7wgx8AAD755BPsvvvu6NWrFy6++GK0bdsWDz30EA4//HA8+uijkfXEj2/jtezHvffei3333Rc9evTAcccdh4svvhhPPfUUjj76aO8z//nPfwAAP/3pT5X2/Ag/7+rr6721tl+/fhg/fjwmT56M7bff3siuCYQQOOyww/DGG2/gjDPOwDbbbIPHH38co0ePjnx23Lhx+PrrrzFmzBj06NEDn3zyCe644w588sknePvtt5HJZJT3m866boJ8Po8f/vCHeOmll3Dcccfh3HPPxcqVKzFu3DhMnjw59tnOef8ceeSR+OSTT3DOOeegf//+WLBgAcaNG4cZM2Z419jjjz+OMWPG4K677lIWN7311lvYfvvtUV9fH3h9/fr10shEyfeZPHkydt11V+/1YcOGQQiBt956Cz/84Q/1JlTbzRPlnZTsnxDxzBsAcfHFFwdslXYLqhwv05w33b9t27atOPnkkyOv//e//xUAxHPPPSeEKOcEhBkrIYT43ve+J3bdddfEMZx33nkCgPjf//7nvbZy5UoxYMAA0b9/f4/5K7EUvXr1EitWrPA++9BDDwkA4s9//rMQQm/epk+fLnK5XGR3+fHHH4u6urrA63vvvbcAIG6//fbAZ5cvXy4aGxvFhRdeGHj92muvFZlMRnzzzTfea2vWrImMYdSoUWLzzTcPvBaXGxNm3jZs2CC6desmtt9++8DO+emnnxYAxGWXXea9Vrq+rrzyyoDNoUOHBtjBc889V3To0ME4H/OJJ54QAMQf/vCHwOtHHXWUyGQygR1jicXUgSpPaOTIkYG8s/PPP1/kcjlvN7hy5UrRqVMncdpppwX+ft68eaJjx46R18Mo3avXXXed9PvDzJv/nijhxhtvFADEwoULY7+HM+cNgMhms+KTTz6JvBe+Bjds2CC233578f3vfz/wehzzpprvOOy1116iffv2gftBCBGwJbs/xo8fLwCIf/3rX95rO+64ozj44IMTv2+//fYTgwcP9iIDpe/abbfdArlaMnxbr2UhhJg/f76oq6sTf//7373XdtttNy/KU8LQoUNFx44dtY5LiPL6Ev7nP94XXnhB5HI5kcvlxIgRI8RFF10knn/+eWVupSnzVjp/1157rfdaU1OT2HPPPSP3mOyau//++wUA8frrr3uvJd1vuuu6Lu68804BQNxwww2R9/zXB0LMG9f9s3TpUumaF0bputVZs3r37i2OPPLIyOuDBw8WW221VeB5s379etG3b18BQDzyyCOBz8+ZM0cAENdcc43yO0uwkgq55ZZbMG7cuMA/FUoMSAmlXcvzzz+PNWvW2AyDhLVr10rzX0r5M2vXrg38jPts6f04PPPMMxg+fHggt6Jdu3Y4/fTTMX36dHz66aeBz5944olo37699/tRRx2FzTbbDM888wwAvXl77LHHUCgUcMwxx2DRokXevx49emDLLbfEK6+8Evh8Y2MjxowZE3itQ4cOOPDAA/HQQw9BCOG9/uCDD2LXXXdF3759vdf8O4wSK7v33nvj66+/xvLlyxPnR4b33nsPCxYswJlnnhnIZzr44IMxaNAg/Pe//438zRlnnBH4fc8998TXX3/t/d6pUyesXr1a61r145lnnkEul8MvfvGLwOsXXnghhBB49tlnjezp4vTTT0cmk/F+33PPPZHP5/HNN98AKO6sly1bhuOPPz5wjnO5HHbZZZfIOaZiwIABGDVqVOC1Evv55JNPJlb2cWLvvffGtttuG3ndfw0uXboUy5cvx5577hlbPR6Gar5lWLhwIV5//XWcfPLJgfsBQMCWf2wbN27E4sWLscUWW6BTp06B8XXq1AmffPIJvvrqK+n3LVmyBC+//DKOOeYYrFy50jvnixcvxqhRo/DVV19h9uzZseP9Nl/LDzzwALLZLI488kjvteOPPx7PPvssli5d6r22YsWKwPqqg1atWkWed/4cpx/84AcYP348Dj30UHz44Ye49tprMWrUKPTq1ctj+jjwzDPPoK6uLvAszeVyOOeccyKf9V9z69atw6JFizymR/ee4F7XH330UXTp0kU6Xv/1kTQOyv3TunVrNDQ04NVXXw1cE2GcdNJJEEJoSQotXrwYm2yySeT1M888E19++SVOOeUUfPrpp5g8eTJOPPFEzJ07FwAifkPJRpjhTYKV8zZ8+HCMHDky8C8JdXV16N27d+C1AQMG4IILLsA//vEPdOnSBaNGjcItt9xidVHYoHXr1li/fn3k9VK5bumCKf2M+6wqafubb77B1ltvHXm9FIYIPxy23HLLwO+ZTAZbbLGFp7ulM29fffUVhBDYcsst0bVr18C/zz77LJJE26tXLzQ0NETGeOyxx2LmzJkYP348AGDq1KmYOHEijj322MDn3nzzTYwcORJt27ZFp06d0LVrV/zmN78BAKvzWZoT2bwNGjQoMmetWrUKhNaA4s3gv0HPPPNMbLXVVjjwwAPRu3dvnHzyyYFS/6Sx9OzZM7Lgx50/LoSdgdLNXTqm0gL1/e9/P3KOX3jhhcg5pmLAgAGR14499ljsvvvuOPXUU9G9e3ccd9xxeOihh1J15GTjAICnn34au+66K1q1aoXOnTuja9euuO2227SvP9V8y1DaHKhCZWvXrsVll12GPn36oLGxEV26dEHXrl2xbNmywPiuvPJKLFu2DFtttRUGDx6MX/3qV/joo4+896dMmQIhBC699NLIOb/88ssBRBPk/fg2X8v//ve/MXz4cCxevBhTpkzBlClTMHToUGzYsAEPP/yw97kOHTpg5cqVRuPP5XKR592wYcMCn/ne976Hxx57DEuXLsW7776LSy65BCtXrsRRRx0V2aDb4ptvvsFmm20WSXGQrZNLlizBueeei+7du6N169bo2rWrd+/o3hPc6/rUqVOx9dZbe0V/uuC6fxobG3HNNdfg2WefRffu3bHXXnvh2muvxbx584yPxQ8/uVHCGWecgd/85je47777sN1222Hw4MGYOnUqLrroIgCInMOSjSQnNgyrnDdTNDY2RnLLAOD666/HSSedhCeffBIvvPACfvGLX2Ds2LF4++23I84eNzbbbDPPC/aj9FrPnj29z5Ve79OnT+Szw4cPT3WcMqjmrVAoIJPJ4Nlnn5VWDoYvnDgH9JBDDkGbNm3w0EMPYbfddsNDDz2EbDYbyCGZOnUq9ttvPwwaNAg33HAD+vTpg4aGBjzzzDO48cYbK8LIqKojAaBbt2744IMP8Pzzz+PZZ5/Fs88+i7vuugsnnngi/vnPf6Y+RlPEHVPpJi/N6z333IMePXpEPme6QKogu0Zat26N119/Ha+88gr++9//4rnnnsODDz6I73//+3jhhRe0zgvHOP73v//h0EMPxV577YVbb70Vm222Gerr63HXXXcFqsaToJpvCs455xzcddddOO+88zBixAhPFPm4444L3B977bUXpk6d6t3X//jHP3DjjTfi9ttvx6mnnup99pe//GWEBS1hiy22II+XG2lfy1999RUmTJgAILr5BYq5cKWc6UGDBmHSpEmYOXNmZD3nQENDA773ve/he9/7HrbaaiuMGTMGDz/8sOdcVwrHHHMM3nrrLfzqV7/CkCFD0K5dOxQKBRxwwAFaa3ItrOslcN0/AHDeeefhkEMOwRNPPIHnn38el156KcaOHYuXX34ZQ4cONR7bpptuGrvBu/rqq/HLX/4Sn3zyCTp27IjBgwd7zu9WW20V+GzJRlLtQBgVcd6SMHjwYAwePBi/+93v8NZbb2H33XfH7bffjj/84Q8AzDxREwwZMgT/+9//UCgUAo7lO++8gzZt2niTO2TIEADFUJ7fUZszZw5mzZrlLQpx6NevH7744ovI659//rn3vh9hylcIgSlTpmCHHXYIvJ40bwMHDoQQAgMGDIhcJCZo27YtfvjDH+Lhhx/GDTfcgAcffBB77rmn59gCwFNPPYX169fjP//5T2CHLQt16J7L0px88cUX+P73vx9474svvojMmS4aGhpwyCGH4JBDDkGhUMCZZ56Jv/3tb7j00ktjH3r9+vXDiy++iJUrVwYYi7jzpwvqdV1K7u3WrZuS+U4T2WwW++23H/bbbz/ccMMN+OMf/4jf/va3eOWVVzBy5Ejj47SZl0cffRStWrXC888/H0hvuOuuu4xtmWDzzTcHAKXcwyOPPILRo0cHQm3r1q2TCqN27twZY8aMwZgxY7Bq1SrstddeuOKKK3Dqqad631dfX291zr+t1/K9996L+vp63HPPPRFH8Y033sBf/vIXzJgxA3379sUhhxyC+++/H//+979xySWXkMatQqnITUYS2KBfv3546aWXsGrVqsAGPPx8Wbp0KV566SX8/ve/x2WXXea9Lgsnxp07k3VdFwMHDsQ777yDjRs3RhL8k8B1//jHceGFF+LCCy/EV199hSFDhuD666/Hv//9b+NjGjRoEKZNmxb7/iabbBJImXrxxRfRu3fviLxYyUZcYZAMVettumLFikiHgsGDByObzQZClG3btk1F/fmoo47C/Pnz8dhjj3mvLVq0CA8//DAOOeQQ7yGw3XbbYdCgQbjjjjuQz+e9z952223IZDKeRlwcDjroILz77rte6BEo6hHdcccd6N+/fyR/51//+leA1n/kkUcwd+5cHHjggQD05u2II45ALpfD73//+whzIITA4sWLlfNTwrHHHos5c+bgH//4Bz788MNIyLS0WPq/Z/ny5dIHp+653HnnndGtWzfcfvvtgWvh2WefxWeffaZVPRhG+Jiz2aznEMtC4iUcdNBByOfz+Otf/xp4/cYbb0Qmk/HOiymo1/WoUaM8rcGNGzdG3i/puKWJJUuWRF4rbXZKc1rSc9Q9VtPPA8VrMJPJBO7P6dOnG3VmsUHXrl2x11574c4778SMGTMC7/nvh1wuF7kPb7755sB4geg12q5dO2yxxRbeXHbr1g377LMP/va3v0kdAtU5/7Zey/feey/23HNPHHvssTjqqKMC/371q18BKKrgA8V1f/Dgwbj66qsDa3IJK1eu9KpmdfHKK69IGdpSnrIsrGmDgw46CE1NTbjtttu81/L5fKSLg2xNBoqVwWHE3W8m67oujjzySCxatChy/cnGGh4Lx/2zZs2aSBeDgQMHon379oFnwPLly/H5559rhYZHjBiByZMnJz5DSnjwwQcxYcIEnHfeeZFI5MSJE5HJZDBixAilnRKqxry9/PLLOPvss3H00Udjq622QlNTk7dz8iedDhs2DC+++CJuuOEG9OzZEwMGDMAuu+wSa/epp57Chx9+CKCY3PjRRx95LN6hhx7qPbCPOuoo7LrrrhgzZgw+/fRTdOnSBbfeeivy+Tx+//vfB2xed911OPTQQ7H//vvjuOOOw+TJk/HXv/4Vp556qtJTvvjii3H//ffjwAMPxC9+8Qt07twZ//znPzFt2jQ8+uijkZPYuXNn7LHHHhgzZgzmz5+Pm266CVtssQVOO+007XkbOHAg/vCHP+CSSy7B9OnTcfjhh6N9+/aYNm0aHn/8cZx++un45S9/qXOacNBBB6F9+/b45S9/GTk3ALD//vt7jNbPfvYzrFq1Cn//+9/RrVu3yANm2LBhuO222/CHP/wBW2yxBbp16xZh1oAis3DNNddgzJgx2HvvvXH88cd7UiH9+/dPbNUTh1NPPRVLlizB97//ffTu3RvffPMNbr75ZgwZMiTxHB5yyCHYd9998dvf/hbTp0/HjjvuiBdeeAFPPvkkzjvvPGvpGt25iEOHDh1w22234ac//Sl22mknHHfccejatStmzJiB//73v9h9992liyQnrrzySrz++us4+OCD0a9fPyxYsAC33norevfu7e02Bw4ciE6dOuH2229H+/bt0bZtW+yyyy6xuWulXKLf/va3OO6441BfX49DDjkkUdT74IMPxg033IADDjgAP/7xj7FgwQLccsst2GKLLQI5L2ngL3/5C/bYYw/stNNOOP300zFgwABMnz4d//3vf71WOD/84Q9xzz33oGPHjth2220xfvx4vPjii554Zwnbbrst9tlnHwwbNgydO3fGe++9h0ceeSTQdueWW27BHnvsgcGDB+O0007D5ptvjvnz52P8+PGYNWuWt/bJ8G28lt955x1MmTIl0pqohF69emGnnXbCvffei1//+teor6/HY489hpEjR2KvvfbCMcccg9133x319fX45JNPcN9992GTTTYx6lN5zjnnYM2aNfjRj36EQYMGYcOGDXjrrbfw4IMPon///oFisI8++sgrYpgyZQqWL1/uPZ923HFHHHLIIbHfc8ghh2D33XfHxRdfjOnTp2PbbbfFY489FnEyOnTo4OVzbdy4Eb169cILL7wgZYji7jeTdb0k66SS1jjxxBPxr3/9CxdccAHeffdd7Lnnnli9ejVefPFFnHnmmTjssMOkf8d1/3z55ZfYb7/9cMwxx2DbbbdFXV0dHn/8ccyfPx/HHXecZ8dEKuSwww7DVVddhddeew3777+/9/rrr7+OK6+8Evvvvz823XRTvP3227jrrrtwwAEHSKWpxo0bh9133z1yTInQrksVNJHeML7++mtx8skni4EDB3rCe/vuu6948cUXA5/7/PPPxV577SVat24toCHSG1faHR6XEEIsWbJEnHLKKWLTTTcVbdq0EXvvvXfssT3++ONiyJAhorGxUfTu3Vv87ne/026zUxLp7dSpk2jVqpUYPnx4rEjv/fffLy655BLRrVs30bp1a3HwwQcHZAh0500IIR599FGxxx57iLZt24q2bduKQYMGibPOOkt88cUX3md0JAFOOOEEr+Rfhv/85z9ihx12EK1atRL9+/cX11xzjVcW7i9Bnzdvnjj44INF+/btA+X2cSK9Dz74oBg6dKgnuJgk0htGSYCyhEceeUTsv//+olu3bqKhoUH07dtX/OxnPxNz585NPHYhilIG559/vujZs6eor68XW265ZUDYtAQTeYW4uYi7x+Lm6JVXXhGjRo0SHTt2FK1atRIDBw4UJ510knjvvfcSv99UKkRWgv/SSy+Jww47TPTs2VM0NDSInj17iuOPPz7SXu7JJ5/0RHVl92EYV111lejVq5fIZrOBsaBZpFeG//u///OEPwcNGiTuuuuuyDVQOhaZVIjufMswefJk8aMf/ci7v7feemtx6aWXeu8vXbpUjBkzRnTp0kW0a9dOjBo1Snz++eeRsfzhD38Qw4cPF506dRKtW7cWgwYNEldffXVknZk6dao48cQTRY8ePUR9fb3o1auX+OEPfxiRH5Dh23Ytn3POOQKAmDp1auxnrrjiCgFAfPjhh95rS5cuFZdddpkYPHiwaNOmjWjVqpXYfvvtxSWXXBJYE3REep999llx8skni0GDBol27dp5rbLOOeccMX/+/MBnk+S2dCSxFi9eLH760596Ir0//elPpSK9s2bN8q7Jjh07iqOPPtqTowi3noq733TX9ZtvvlkqJSTDmjVrxG9/+1sxYMAAUV9fL3r06CGOOuqowPkLj5Hr/lm0aJE466yzxKBBg0Tbtm1Fx44dxS677CIeeuihwBhNpEKEEGKHHXYQp5xySuC1KVOmiP3331906dLFW5PGjh0r1q9fH/n7ZcuWiYaGBvGPf/xD6/tKyAjBkJHr4ODg4ODg8J3DMcccg+nTp+Pdd9+t9lCqgnvuuQdnnXUWZsyYYdVS7qabbsK1116LqVOnGrUcrFrOm4ODg4ODg0PLhRACr776qhf6/S7ihBNOQN++fXHLLbcY/+3GjRtxww034He/+51xr2jHvDk4ODg4ODg4tCA45s3BwcHBwcHBoQXBOW8ODg4ODg4ODi0IznlzcHBwcHBwcGhBcM6bg4ODg4ODg0MLQtXbY1UThUIBc+bMQfv27VNrw+Xg4ODg4ODACyEEVq5ciZ49e0p7p3/b8Z123ubMmZNKc2IHBwcHBweH9DFz5kz07t272sOoOL7TzlupOfPMmTPRoUOHKo/GwcHBwcHBQQcrVqxAnz59vOf4dw3faeetFCrt0KGDc94cHBwcHBxaGL6rKU/fvUCxg4ODg4ODg0MLhnPeHBwcHBwcHBxaEJzz5uDg4ODg4ODQguCcNwcHBwcHBweHFgTnvDk4ODg4ODg4tCA4583BwcHBwcHBoQXBOW8ODg4ODg4ODi0IznlzcHBwcHBwcGhBcM6bg4ODg4ODg0MLgnPeHBwcHBwcHBxaEJzz5uDg4ODg4ODQguCcNwcHBwcHBweHFgTnvFUR65vy1R5CABuaCli9vonFVqEgWOwIwWNnQ1OBxY4QgmVME79Zin+Nn85ii2uuv60QQmDNBvp1vXzNRjzw7gwsX7uRbGve8nVoytOvyS/nr8TMJWvIdgC+e83hu4tCgWd9dFDDOW9VwkezlmHwFS/gry9/RbKzoamAI259E1c+9Sl5TMfdMR57XvsK+UF3yytTMPSqcZi6cBXJzutfLsSQK8fhuclzSXZmLlmDoVe+gCv+8wnJTqEgcNgtb+In//cOeYH63ROTcdmTn+CzuStJdh6cMANDrnwBE79ZSrKzaNV6XPLYR/hw5jKSHQB4a8oifLN4NdnOuo15rGLYTPz+qU8x5MpxmLKAdj3+c/x0XPzYx7hn/HSSncmzl2PXsS/hN49/TLKzan0TDrn5DRx3x9skOwBw0SMfYq/rXiFv3lavb8I7Xy9GnrihWLRqPa56+lN8NZ92f6zZ0ISjb38Lt706lWQHAG568Uv8v2c/J9v551vTccStb2L5Gtom4KXP5mOPa17Gu9OWkOzkCwLPfjwXC1asI9lZ35THfje8hp//+32SHQc9OOetSpg8ewU2NBXw/oxlJDtfL1qF92csw+OTZpHH9OncFViyegMWrFhPsvPGV4uwfO1GfDRrGcnO218vxvK1G/HW1MUkO5/PW4nVG/JkB2fJmg34aNZyvDmF/nBaua64cFOdkzenLMaKdU2Y+A1tAX/+k3m4/92ZuPPNaSQ7M5eswY//8Q7OvJe+gB9+y5vY57pXsW4jjaH+cNYybGgq4EuiI7B0zQYAwDLiQ3faoqJj+/VCmoO7dPUGrG8qYB7xoQsAr3yxEDOXrCWP6ZrnPsexd7yNcZ/OJ9l56sM5+L83puH/3qBdj5Nnr8CE6Uvx0HszSXY25gv480tf4fbXpmLFOtr5f3jiTLw/Yxnen0Fbj175YgFmLV2L/321kGTn9S8X4uf3vo+r/vsZyc6spWsxbdFq8ngc9OCctyoh38zcUJ2ApjyPHQAoNEdx8kRWqXxstPFwzVHp76l2/OFJ8hw122oq0CaJa67XbSw0/6Q5SgtXFR3/RatoGwAhBD6ftxKLVq33nCZbFJjOf/mc1Yadgu/+oDLB3hwR7cxdXnQk5xMdyjUbitfhWuL1WApNk++zgkBpajYSUzBKazbXdcTBcgLAktW0e5brGnLQg3PeqoR886JCdiiabxSOtKfSAsfnLNEWudJiUGBylMiOst95Y5oj4hQhn+eda6oTyGbHN72lh50tmpidN67rkWrHfz1S7/8m5nuWa6NEPmeC5z5L495ns1Nj6yMHkeCghnPeqoTS84jrhqHuLIUQ3gOAb3EimSkfG/Hh7bFTTItc+P8UW7XCvHE9vLns5AOOSW08nNiZN+J1XWC8Hrmcbq4HOLcdDubN+3+NXI/eHHGtjzXilDrowTlvVUKeieXy2Ckqg5PKzpJpF09eLHlZToBhvj3GtDZ2314IjrjucjtKQO2El8psKRMbxMi81YqzVGDaKBWYHAoupzRwPdbYZrJWnMkyo+wqlysB57xVCXmm/DK2naXgexDUGg3vzTVj2JQ836W8F+qDgIsxYwq/sj0IAo5ybT3kqM5kE5MdVjaoxnJw+Rk8KqNc/nuy011r91oK96xj39KHc96qhNKNS05aZtrtpMF0cCZk08bDy3ICfA9LvpAgyQx/6IR6XHnG61HwOl1kZ7L5ZHE5pUWbNXLevqX5XH4/i48JJpmp2bkG6HPkoIZz3qqE0o1LXcC5QiesOUZcYSGmXXwazBtfLk5tMG9cDi4f61o+Hi42iCvcSXfcm8fFeT0SxiSE4LuOmBzlNEJ5FASYN66weY3NEbkwyPf31LXfQQ3nvFUJXMxbgKrmYt6YEqlrhw1immtG541bvoK+iw/aswVbqJsxBFPgcijYJB74czApYXz/MLgKFmrOMSHn35b/XyuRCe70FKrDVXBh04rCOW9VAtvuK89zw3Ayb9wVh7Um8cAxJm4np1aYN790DVcYnysvtHYYk9JPRqaDcPqDLCdPkVGtOTh0qRA+JpgrTMktgcPKBDvnLXU4561KqLVCg3Sq+0hm2Bc5ai9JrrnmlHhoYpoj7gKaok2mzUSNPJz47DQ7ypxMB8GWfwliY95qxeHmYt7SKOgiTjZXZS9XFTXnuuaghnPeqgR/oQEFXGxQKtV9NcK8cQkZc8015w6VL/zaHFpm1B6jODlpbCbYxHW5wlScTAfhvPkdG7oeGs91xJ1WQmWCufILAf+mlGSGvVODY95aFpzzViWkIh5JcShSqO6rlUqxWhPq5GJMAP7wK6/qP8/Dko19YarI5KoQ52LwAD7mrVa6R3gFXTXCBDcxpaf4/56rOKR20gF4rkcHPTjnrUqoNXHdNMICtbIjTGOuKY5AGsxbrcx1PsDiUBwKfuaN7ig3S3zUTEjQ/3/7izvAvLE5uDXC4OWZHFzG9bHchpBkpubWWf/xUM+bgxrOeasSao0NSqdvZ23sCNOYa8oDnLfwgVczjNOhoNhKJUzFVHHIpbDPyrwRDi0NmSB6pTnXeHz/Z7oeKdd1sA0hz3pEXh9LUjpMmxsOWw5qOOetSihwLXJMbBCrAG2N7QhrTciYVXJE0Mfj//taYd4Cc0RuTM/DdHh2mASIuYpMANrGxD8OLjkVrupnXge3+kxw8N63NhOwxSWGzmWHw5aDGs55qxLYWqT4Cw3YmLfa2BFy5c8E87Do4wFox5YK81YjyfipzBFRgJaN6fDscLFTjEwHRSokz3POAEbmLZXQcvWZ4GDFOrVlFy9jxitd45y3tOGctyqBux0R8O3bEZYlPngeKEWblNwg/rmms4rNdmokGZ9tjlKQwKFf1/xdKChMMJ9ILyPzxhSiTiMHk+06ItxrnPqFBa71kUl30DFvlYVz3qoEboV9v02qHbYqKKbFicwqMYmZ+sdBmmtGWRZ25q1GVNbTkMChOxT08QB8TDBXO6I02r6RZTCY1sc0dAe5covpGyWmMD4X88Z4HTmo4Zy3KoFPXDUNpsN+PP4+ieReeVy771pj3vI8DwKgfK5qJb+w1qQZOJkOti4UKTgUlHuNM4xfcxqPXOFOpjnyj4csiivo4wEY5Yac81ZROOetSiikEDblYzqY+iQysTicyt8k5i2VvBeeOeIM5ZHGwzRHtcbgATXIBqXQ17hWtBn55F1qy8FNhXljumc5iQSn85Y+nPNWJZQLFvhYpVqQr+DsAcilIB5cMHmYN1reC+ccMeVhsSXR8z/kasV543rI1RobxFnZW3beSGb4nMBUCrpqg3nLMz1DSscmRO0UYjmo4Zy3KiGNBt61kERfYKruAvhYJb4ekFwPXf//ayN0ws2YUG1xzTUv05GCg1sDbFA6zFtthE3981sL8j6c1yPXhotrfXTOW2XhnLcqodYaeAfskB6WjKwS18OSKX+qFtkgrtBJrTlvXA851hyjFNigWnhY1nLBApd0CdVWGtXPXEVG37b10UEPznmrEmqteqkmmTeuXAyuhTeFBZxLKoStRypn3gtpjvwaZtW/P/x/z8sGEcR1uVhOpus6WIhB7GbB1oWCa33kabPFVWTit8WVW+y3aWXHOW8VhXPeqoRaq17iYvBqkXljcyjyPMfGlYcD8Cctc+a90B6W5f9zbUq4ZFA4w6YkcV0u5q0GmZcmpi4UfGy53CZpPDXSI5drg+OYt8rCOW9VQq2Fl1IRV62RsACb8+b7Uy5WiTLXwe4BjA85JiaYK/xeK0nUXNI1XOK6XOx9rTF4fltcmxKqLS4mmHWOmK7HNFJvnPOWPpzzViWksmAySTPUyg1cc84bm1p7+f+1MtdsoRO/Y0Lptcuk1s4py1IKd7K2a2NqKM/FBNcK8+Jn3SkFXWxtrbiYNyaW0z8OzvWR615zHRbSh3PeqgSuh0pgMSA8LNPIneNK7GZ13riqRJlYpVpxTNIInZGYN6buAWlcj01EHYxgk/Pq57wFWCXKXDM6JoF0EIKpbzPzxlawwHTPcqYoOKhRM87b66+/jkMOOQQ9e/ZEJpPBE088kfj5V199FZlMJvJv3rx5lRkwETXHvKUQguHrk8i4s2TSZ+Mq6qhF5o2rupNkh4nBa2KSivD/PZVUaOJylrjYSa78QsaUiVrTC6zFvDBvc8uoO1gLRW8OeqgZ52316tXYcccdccsttxj93RdffIG5c+d6/7p165bSCHnBV23KE8pLQ3uKXOZf4Fmc+ISMy//nKupgYzlZQ3lMzBvX9ciVDsD0kKOwZUU75f+zFWPUAKsUuK6ZKinD/ze2U2MSH1ypF4WCQGkYvAU01b8eHfRQV+0BlHDggQfiwAMPNP67bt26oVOnTvwDShl8bJDcpilqnXkTQiCTyVR1TGzMWwo6X9SHZa3tvoMPb6Z+tEy9dom+G9uGq9YqewOMco20WuIK5aayXtdIiz2u64hrU+qgh5ph3mwxZMgQbLbZZvjBD36AN998M/Gz69evx4oVKwL/qoVa28ml0W+RcwGnrAVsDAVTUQdXniJnjkkaeS9cD0tKihnXHHHlqYXHVAtsEFdlL+fDmysSUGt9ZNNw3GunoKv8f8e8pY8W67xtttlmuP322/Hoo4/i0UcfRZ8+fbDPPvvg/fffj/2bsWPHomPHjt6/Pn36VHDEQaSxa66F8EIgx4gxdMLVk7QW5FRSYd5qZgFPww5PUj/XuS8IYks7rnuNKUzJNUdcuZxAOlX0pOsxz3M9comYs+bOsd2zjnmrJGombGqKrbfeGltvvbX3+2677YapU6fixhtvxD333CP9m0suuQQXXHCB9/uKFSuq5sCxtW3h2skxCdBy5hgF58jeDpeQcbACrvoLL9c1FB4Hm9PFxuBZm2HMCxOR3+tydmF8rsrePFOYMo38WzLzlvfbqq2NG+V6TCXflXrvs+UFym06pIMW67zJMHz4cLzxxhux7zc2NqKxsbGCI4oHVxVcQDiWxAb4/l8D7JQQgvGhkgLzVgMNxTkrKfnYIB6GgstOGhpWpd9tF082NigNR6DGipWKtuztcG24gueMwLyloadZgy3t8kQ5HQc1WmzYVIYPPvgAm222WbWHoYXaW8D5qqBk/ze2E/pTykOlluVU2FjOGklaDl7XPOOpiRyj0PVXC22tUkmZqAHpkqgtyiaAZ31kY964Nu2ha4gmZMzUt1XI/++QDmqGeVu1ahWmTJni/T5t2jR88MEH6Ny5M/r27YtLLrkEs2fPxr/+9S8AwE033YQBAwZgu+22w7p16/CPf/wDL7/8Ml544YVqHYIR+BZwrp2c7/81wXIFV0jSmFIQMq4FfTbOput8ye/8jBmbDiIj81a8PnN2Y2LbBNRW8juXsHJ4HFxdKLhSJriua65Qd9EWYBnFD+XhUY6tIP2/QzqoGeftvffew7777uv9XspNGz16NO6++27MnTsXM2bM8N7fsGEDLrzwQsyePRtt2rTBDjvsgBdffDFgo5ZRa9IcbO2RuB66oXufsvtOI/m5FvJVuK6h8DhIba1SyFXjcii4GDyAj3ljS5moheuRk3kLzFH1w+ZsbbaYxKdlm4lc1m4zEWSnrYcUyuW0t+Ogh5px3vbZZ59E6vfuu+8O/H7RRRfhoosuSnlU6aHWmLc02iNxVdIBtRGmYmvZxCY7kE7YlEt2grSL5+r4kIJIa3FMTOxLDaQ6pMEEU+wIIQJpE2wtm2pgjtiYN8YwflDnj2mT7Ji31PGtynlrSeBiqPh28fzhJVp+WfB30qLCtfBy7Zq5zllKYdNaYBXZNiUpjAeoDbacj1XknyNeR5npnq2xY+NMK6FtJvw6f9Zm2PICHfTgnLcqgWvB5JLm4JMc+fYyb2nkq3DKV3AJENfEwymlxG4OO5y2aqHJeTryLjzOJNlWCg4um14g07kv2rI2lUqI2jFv6cM5b1VCrYni1lrbFnmCuKWtVHbN1c/Dic6Rna2ILEsNOLh8m5IadN6Y2KBaZsxqZa4DDi6BDuKqok8jB6/4e20VUTidt/ThnLcqIZVqulpg3lJawGvtAV6LwrG2cxQeQm04JjzdA1ILmzKx07V3XVf/4R3R1ONycAn+BFt6Sg2G8dPQr3QdFtKHc96qAE6mg0+awf//2luc2PL52B6WTAK0jHIBtnMUkWVhYoK5pGu4epLWpENRY/calx0h7M9/OBmf79iYxHVrzOGm2krj2Fxv0/ThnLcqIHxd0/oJcrFBtdW2JbzO1kIeFhfzxlZAwbSAR+a6JuRUUhBXpTB4nA5FCkn0tRZ+BeyvI05HmeueTaW7CuPGrRaK3jh1Jx3UcM5bFcAZEmRj3mqsbQsnG8QWpmQqha+1UF50rnmOjU00uibSCvjCVGmEzWuh8IGr0CCt4hAuAdpvE/NWKAj4D4eNwXPOW+pwzlsVwBoSTCEPqxbatoQXyJpj3ghrU1raY2zMGxOrWAvt2vh6CIfuWcsLIJwyUQvCsVwVmXybiXQc5VpYH/l0MJkcZc50AMZeyw5qOOetCgjfMHzikTVQcRQ+NktTnHIBaTAdjnmLs8XFvPLPUS0Wh/A1S6++Ha7q5/B54ttwVZ8x42Knwn9bCywnV+6cgx6c81YFhHNvaiEZP42cDtnvlbYT/tuaWMBT2MUDnDlG1kMKzhGlzVYKDgWXE0CxFbHDlIdHY3G4Ks3D2ow8zBufSHP15Ya42Cm2e59xneXacDnowTlvVUB6zBuPQ8HZMLkmnLc0xEyZFjku5gWwd5aijgnTQ64GQ3nWFZBp2akB5o2v0jz4O5uDy7SucRUssK1FjBEO201AWiFqFzZNH855qwLSy3ljYt44Q3lcO0JLO6wCtGl0ISA8UdLafdeCXEB6PUmr61BE2xpVn+ng03gMMW9c1+O3iHlLo5MNQAjj12B6ioMenPNWBaRVucbVwJszN4iPDbJcnEJ/VgvSDMHcEGszkoXX7uHEGcqrte4BkRBclR2KWpTASUMqgmKLdXMb2ARYm2FMvQjatC3o4prrtHKLHfOWPpzzVgVEcowIqwrXbietqjw2NoiJ6WCTZmDrk8jIvFmaYmXeaqx7AFfyO9/DMiUJHCYhYy47st91kRYTXGvMG2C/eYv2NmWKcNTA9eigB+e8VQERBXEK+8LEdKQXpmJig5iYDjbmjZKMH3C4rc1IHJPqzjUQYt64xEwZ2SC2HMwaE6BlY94Yw/hsoWUmWZZa6NnMdT2ysZwpdQ6h3PsOenDOWxUQvWGYRFFrTJoBsHdOuIo6IswbVz5XDTJv1Z5roBalQniYrrTSAWohx4grjM91bJFCnFro2ZsSE2w9R1wsJ6PygZMKqSyc81YFRB8oFFspMB1MD93i73YHx7WzjDBvNdB4ORimgnXeS1RXy3KuORfwFB5yXDlGxd+ZGIoqF+IAjJuAPI8dLueNqxVZWiFqVuatyjlvrBs3383mct7Sh3PeqoDoA6UGxHVT2lnaHlrEjvUix8i8MRV1sIXy8jzHxtXNQgiRSqEBzeHmYt5SYvC4mA5K+J3JTq2p/qeVMsF1zgB7BjfC4FlvJviqn7nmyEEPznmrAqI7QntbXGxQWjtLNubNNkzFxE6Fx1ATRR2hP2PTerIOdwV/r4XkZz7GLPx7decaCDMdPOF3ip1aU/3nLFZKoxUZxVbkOrIO4wd/57rXnPOWPpzzVgVE5QJqoQoqnZ0lm/4Qm4K4lRkAjEUdTGGhCBtUc3PNcz2y6g5aP+R4mLe0dLUo+eFBR9k+jJ9WSLAWmDeudAC+gi6ee59Td9Axb5WFc96qgAjzVgO7HbZqKqb8qdSqBGuhJylTWCg1NuhblIzPlWOWVpUg3z1b/Vy1aPjdbkxcDi5nykRa9751kVFK62MtdPtx0INz3qqA8CJCaeDsN1WLzBvfg4Bn901i3phCJ3wLb0psEJcMBtOmhLUHZJUZM1ZZlsA9a20mRcasuuPhaiEF1H5aSbWvx0JBBNImKPe+gx6c81YFhBcR6zLvlDSjaBVwPA5FehVnNcC8sS28yXZ1wVdA0QKYN645qoHWT0GHovq5aly6g2k5yt+qgi429p7JDuOzyEEPznmrAqIXuqUdpgdK2Fa+YN+2JTVpBi4Gj7CmpJX3Um3mjS2MW4MCtGmFl7jmyPbYhAgxHTXATnLpDrKNh1ECJw39wuLvtcW8cbWPc85b+nDOWxXAlYeVVo4RYC/WWWuSCtFFrgaZtyqr9XMxZqklP9dEiPrb+7BM69ismTeutBLGzUSgWImpu0rYrgmiXXq4zln1r0cHPTjnrQqotSRq2d/aV0El27UdT01UQKbVQoxL4qPKTmD4kqFJM5SNfZsc5dQKemrQwbXWZmRKK0lLloWXeavy9cgUxndh08rDOW9VAFt1V0qOSdG2pZ0aY97SYihY55pL4oONMakF5s3/f0oYn4nlZmInU2sozpSML/tdF2zajEzXI+f66P9TF8aX2GHMd3XQg3PeqoD0QoKUnSUT8ybCv387nDfOJtd8DbxrizHhTRAPyzzY2am1CkiunKe0KnsptthCgkybG9b10XeeaqGAhs1OWsVzrto0dTjnrQpg21ky3jBRRsDODle7lbRyMeznOmSXM++FiVmo9hxxhYNltriYLq48LD623MpMapW9AF8Yn2tTwsXgcYWWHfOmHg/l3nfQg3PeqgCuZsC8O0smRiClHAqu8BJbgjgj88bF4rDNUZXnWmaLK8es6hWQXGHclCp7Aco9ko7uYC0WdVQ7Nyw1J5BrLXLMW+pwzlsVUJM5HUw3cWrVS1zjqXIeDiBhzGybU6e1a67yLl72t2xCrUzaY3zXtZUZ1uuR7/wn29VFrclphGVZZLYrPabUhJVt1yLG69FBD855qwLYqrJSZN7Y8qeqvbNkyp/hYgIBvrY9EVapysfGVSUISMKUTE43173Gd11Xl+EGJNej9bGl1f/VykxqQrYy2/q2aqugi2vTznV/OOjDOW9VQGo5HZzMG9uuubZ2qGzVVKT8wuDvtSYXwJWDWRPMW40xr1wdSHiZt+Dv1db64got83Vpif6d/RyFfq+2dE1Km3bHvKUP57xVAbWY08HWA7LGZDC4igPCi6UQlFxFLqaDaeENPVGqrTsY7tlbtM3EUFW5kpaLDeLMMUqNDWJjp6zMpNZnmWKLraCLSS8wtVZkznlLHc55qwLY2CCmxVL2t1wJ4mwCtFVnAqNPEHtJhbDtKjtvoT/jqn7lCnUXbVuZqrkKSC42KM2ct+qzOMHf2dJKmOwA1Xdyaq3ozTFvlYdz3qqA1JoK10DbFi75ErYWOWxsUPQ1+4dcOsybvRPIwwakFeos2q5uk/OSnUym+fcqM2/hv6MwwWkVB1WdnQrbsQ2ZS/6u2k5OWkVG1WZdHfThnLcqgG33zajzVnO5ajXWIkfKvBGZhWymZLvKu3imtlZpyBd4zpI181b8w4ZcljSm0jkq2aFWQDbUNY+H6Cg11pWXcGr+FHWOSn9Xuq6p61pdsyHqdV2fa7bDkF9WGhP12EpzTV3XPDvWPVKLk5QjHhfXfeagD+e8VQEFtsWyeMOUFicOdsp7qBBtUY8tPEfUJHpvPMRQZ8kOZUyl88b1AC/ZIY+HONdhh4Ij/EZ1lkqmyNe1CM61tbhuaY5yPHYa/M4b8bxR54jLTtjBtc935L2uc9lM2cmxdpZ47tlCeI6I6Snk9TFyf9i3tHPQg3PeqoDI7pu4s+TaxQH+hwrPwkveydXRdpZN+XTGA9AZKm/BtA3niKAjYJ+MX/xJnWuuh7dsM2Gf9xRylInXddkxpRVQNFDtiOB4/LZNEb5nua5rajI+3VFGwA71uALOG9VZYr6uqWF8qjMZXmeLtq1MOWjCOW9VQGQBZ7qBOSQeamX3HV54qTkdXMxLXTPLSRlTmQ3KBcZoCm7mzWNwiXIaXCFKvy17hiJoh9q3s4GZMaOy7n4m2ObY/JW9ZKfLu9dynm2SnRzNweVaHz3nLUNn3iIRBet7DUE7TGF8rnNWHKPz3tKEc96qAK6HXCHk4BRfM7cVeFhyOW9MIWEqq8jtUNT5dt/UXTM1vBh2BMgLL3kzwesoB5gOJsaUzw4X80ZjOur9zJuFI5CXbdyY8vCozlJ5PFZm2O4P2b1v71Dy3GuR1AtbORUutpQxjO+gB+e8VQF8uSHRUJ7NzZfndN6YHIEo81bdh6UsdEJmg9hzg2rD6eJyAnOZDD1BPK18LsvnEleOkZTpsLAlvfeJMij84Xfivc/kmGSz/uvRyhTf9eix91R2MuhwkwsoGApoHPTgnLcqgC03SLKA2yyY/u+vZ6o4YwsLMSWIcz1QcpkMchlaFRxXZRZbcQgzO+m3Y5O0XHIectkMskzOGxfL2VgKdROlS6iOkn8zkfUqconOG1PSOhvzxrYW8aQn1GUzyGZKGzceh5IrMsG1PlIleQKbCYJ0lYMaznmrArhK88s73Vz5NeICXk9lBLgWp9LOkpj3wr37zuXKu28bW/4m19zMG91OyTEhOoHEpGW/VASVeeOfI2Y7VIcil0Fd1v7aloZNmY6NmupAdrgFkx2fo1yWL7EyxXcdRYo6eCITtpFOx7xVHs55qwIiu2+mMJWtrWBIsPgaV+4Dn5yGlRn+sGmGxgYFHWWaY8IVpuS6HsMhmOJr5g+V0rnPMjBvXDk9fPI+vHaK12PwNSM7vhuLWyaILeeN0Y4VE+xnObM05i2ttZ+8PlIleXx2Mp5+paWH66AF57xVAVy7b+9hSazwKX1/0XljKhDgkh1gklTgzHmjsEGcCeLe7psoORK+jrhC3YAdQ1EKAaXBvFmHupkkZzw2qJ7GcgavR/sxySp7a46dZGLwADtmqeSEBJg36ppdY9I1jfWl+8PKjDeebBa+tBI7Ww56cM5bFRCpyiLmvdTlMt5uh7L7LuZzFV/jEmqttuArtx1qHlYwQbz4ACezQVTmjb3IxB/GN1/Bm/zMW4ZHmoF6PXLpYbGH8X05b1ZSIb4QNbWyly8Zv3TOmKR0iJtbf/Wzx7xZrNkB/UIm6RouJ5Auhl26jrK+gi7nvaUJ57xVAeFFhZxEny0n0VPYoDrfLp5L74dccVYrYSpvAc/SmDfJAk6t8CIv4FyskkR7zI55812PxO4hfKKoPHbCmwnquc9lM6gjXNtlxoTReaPmzYYYZXL3AGJaSZOvgMa79y2OjVOSiZudpBaGlebIfx053y1dOOetCgiH8qrdtiWYYwTamMLtX6y7ByBgp9oJ4uWHJUhskP84yGwQM9PBV93nFzK2yXmLbkpsnBxWAdpQaJksZMzEBNZls+Xr0XKOinboArSRe43YOYRbcsRv22Y8/mpTCoPnH1OtbEobiFXUecl15Ji3dOGctyog7ODY7r49Oj9Da9sSzDEiLphsCy+PuGrYwRHC3hEAmpk3r9DA3jEBfA2zmUIe1Q53lcVMy0nLFAeXqqknyy9ky+VkYpSpbd+C2mP2bJBfAqfaYXy+oqfgXPtfs7GTzWR89z6ReWO+Z8mbbbbIBF3E3EEPznmrAsJMBzUkRGXemiTVfVyNjtn0kKhsAJOYaS4DX4jafDzlBwG84pBarMqzgT9/iiO0HHgQkPMLa2OuuYSV/WwQJdxZ2oDkchnkqJuJPE/nEPZeq0zV+HU5YnoKY2Uv22aCqaBLLqxtZcpBE855qwK4KjILkoecDRtUkFX3sclOWJmJ7iwtnUluORVqQm7eF+6iVq6xMxRMnRqyxPCSXwaDxLwFmA6e6k42cVUiE+xng2hzVPxZl+Vg3oo/uUWjqdd1vU++gut6rHaleZkAaC56IobxG4nj8Z5FObqQsYMenPNWBXA/LIPyFTZ2mpm3DO2hC0jCplXeWYaT8f22jcYjSo4JSAm55XAXyCxnaUz1zMUhtnb8+VMccirUEEwqPXvZKnJ5mGBqr13/vV9HYDn9trja/nEWdVAYM2mEw8pO8bgyGXonm/RakfExb853SxfOeasC+B4E5UWFstvxwl052kM3kCBeI5IKMuaNwuJQmbeChHmrldygsnQNrU8iVU7Fy53LlXUHbRxcWdiUzHSQ5X2iFblcoWU7+Yriz7qAAG11HYFw71/qvU9NK5FGOKzsFH9yyLKkJV1DZUuD15Hz3tKEc96qgHDlGpUNoLZtafLrvDGFBRqpbBATg+ft4gPyFYQwFRMbVMx5ozEd4euILO9CbJEjux4puUF+3UFy03VyPhcT0xHa3AAMbFCGgXljEKAtbwJo+oXh3r9U1j3gdFk4uNzMWzZDYwL9Y6Kzk0G2tCBg1YXCnzJBvY4c9OCctypAptFj1bbFV21K2e3IwlQUNgAohwWsF/Cw1pO1g1P8WZejMW/lsACITEeJVfIzeFzMG1f/V5odsnSNpOMHnZ2qDSY4HwoJAjQ2KCjNYGHHL4NBuK5lPXu5HFy6nAqRMQsI0NKvR1ZBZKb1sZGaVtJ8XVOvIwd9OOetCpCF8mzuvdIu0h/utFkwpQ9dovPGJYNCz50rt7ahMGZ+qRAa01Fi3ugl9dHCFysz7HYChQaEcKe/1y41d46azxVua8VaAUlgg4KiqBZ2/OKqTPqFXA4uV+5cNhBRsOj4EZijkm0e9r7aIWpZSztK4QtVyNhBH855qwKk8hWEh1M2Q9vtcDEmsgRxWxaHTVJBkmdCYt58BQu03Dmag+O3RWXMonNNZN5ytFBeMPxKYDp84VeufK5GxgpI7zWmtlZc16OVg8O4cePr+FH8GSygsbHjnyP7Y5MWmVTbeQuxnIDtPVveJFOL3hz04Jy3KqAsp1HuAUml4Sm7nYDzxqDWDtClQsKSI1SxX7Jav6R3HzmUR3BwAH+uWqkHpJUZyVzT8l5ymbJmGMWhIPeRlenOsbGctmyQL0xJkK+QtSOisZP+69rYjJR1p/bJ9HqbElklv3QNJa2kyOCh2Q7PXLMVGlDF0IlpJVypNw76cM5bFRBOEgVoThebrla2/NClJFED/lJ4IhtEZTqa/8xP51sxb+wPS1obGSGEZPfNM9dFW0Q2iOAol1lOah/ZqPi0dcsmNia4eY5yPOK61PwpP6Ncnmt7BwfwJ9EbmwmMia/jB7GgK2DHfjNZLqAAKc0F4GPeZFJKpHs2QytWctCHc96qgHApPGD3UAkwbwSnK5CrRBDqlD28udggagk7lcWRJj9THWUC0+H/ajLLKRMyJlackZLoA+wUPYzPyrwxaeplmSq7A2w5MZczS7geA90DiGH8sEgvWTg2SyvoCgjQUoqVfOx9lrDOAn7Wnbg+hrr92I7JS1HI0dZZB304560KKJfCZ7zXqMwbqW2LTBSVsPvKBpxJGhtEb7VTDpty9ICklvnLnTebHKPy3zRQWc58cK794zSBrAKSdB0Rd/Fc6QD+v2Nj3nyFLyTGLEO71/xV1FzMm8e6Wz67w/e+bRcKmYg5pcgoIEBL2tzAO2c2xyVj3VmEjAn3rF/5wDFvlUHNOG+vv/46DjnkEPTs2ROZTAZPPPGE8m9effVV7LTTTmhsbMQWW2yBu+++O/VxcqC0qAUaeBMWpzTYIDbGhLojZEpa9iets5X5k3qkEpk3399QHVyuFmL+cCdFmsOfq8ZxzjjycLi6B5THRCt8kbUjsruOomwQOW+WqKmXRlEHiTGTrGtUoW9SDp7vu6kFNGXpIlrUJS9b+121aaqoGedt9erV2HHHHXHLLbdofX7atGk4+OCDse++++KDDz7Aeeedh1NPPRXPP/98yiOlw98MmtTRQMgcAdrCy7VDpT8sS3R+zno8xe+PipBS5oic8yaZazLzxtUIPEcroCkEHJNmOzaOQD7KllILHyjnTKZhZl/d53dwedkgCvOWDeS80Vguao9Ur7K3nriZ8OWpUsLmMgFavnvf2Ewwv7CeKGTMFcb3bdwoKTwO+qir9gBKOPDAA3HggQdqf/7222/HgAEDcP311wMAttlmG7zxxhu48cYbMWrUqLSGyYIAG5TJABCkRSVQKUaywyQ5QkzG9v8dOUzlsZy0HaFcUoG2gJfHY2wmwLxRWz+F8wv94zSBjHnjUrSnSDOQq1Z9f0NvTO93cO1bbcnaEdFkMLK0nFDfeMiaet5mgq+AhlbQVS4OyXCkTASiADTmzWtMzxHGZ1nX4KRCKoSaYd5MMX78eIwcOTLw2qhRozB+/PjYv1m/fj1WrFgR+FcNSCvFCAu4PwTDtvBSQ4LMOUa2eS9+qRBKbhAXixPYfZNylSQ5b5ZJRv5eopQwfvn8g9TWilvDjNyuS1JJSa3uKzq4xddo+VM05k02R7QOJPTeluFkfOqYshlqQVfxJ1k0WnY9WlxGMlkW6jqb9T9DSGHzLOk6ctBHi3Xe5s2bh+7duwde6969O1asWIG1a9dK/2bs2LHo2LGj969Pnz6VGGoE0hAcmXmzv4n9ixxHLkZAcoSpus/Wljxp3WI8TDpGAZaTocgkm6Etuv7vD4TgKHOdy5LEdaXdA4ibCQ7WFWBgOQPac4S8QCnzRrw/OFjOQLcXYzNFW0zyFd4c5ahFRv4wvn2YkqtYKQ3njZN5owoQO+ihxTpvNrjkkkuwfPly79/MmTOrMg55CI5Qwp4tMx0kiY8cMRdDlvfCpKvlf81qTP6WTVTHlCLNIGnZxMfgGZuJ2MoSzluQfQnaNoG0bycx/MqROwfQmeDARomFxaExHXLdQZ6QIJV5q8/SmDf/HHHJslAKFvga3Jf/pp6YX8a/KaULEDvooWZy3kzRo0cPzJ8/P/Da/Pnz0aFDB7Ru3Vr6N42NjWhsbKzE8BLhsSbExFUZ80bqb0jNxZD1kiR2D6A3TJYxCxbjkTlLlLxApurXIKNIe1iWztt6WPZ/lbBKZOaN0mbLtynhYJWAKBOcRcbIlr+6j9T6K7Bx4y0yorc0s7/PAmNqPm/5gqhqAZUsJEzNweToZJPNgHQNAf4wPo/cVEAmyFWbpooWy7yNGDECL730UuC1cePGYcSIEVUakT68hvJZYpjSqzYtV/dRxXVpzJuvvx1h91UoCJTue64uFNSOBtwhOLZKSobKXlkIjpRjRAzlSZk3m3OWj84R5bgAoJ6pqKOYomBvh6vVklfZm6OxnFL2ltgjl5rzWJDc+3bVz2VnkkMqhIvlqiMWqgGM4uOBDjT2hTgO+qgZ523VqlX44IMP8MEHHwAoSoF88MEHmDFjBoBiyPPEE0/0Pn/GGWfg66+/xkUXXYTPP/8ct956Kx566CGcf/751Ri+Efy98ii71PKikiXlYshyjOxyMYo/g7tv+wcTEGI6bB4qMgFiJqeLjQlky5+hOW9Z4nmTFb5Q8wIpWnhc4tNBpqPMtFHOP7nVkue803KM/NXYNAZPVhhkbCYgQOtng6givSxhU6podIpdWjjC+KRNQKC7TvE1x7yli5px3t577z0MHToUQ4cOBQBccMEFGDp0KC677DIAwNy5cz1HDgAGDBiA//73vxg3bhx23HFHXH/99fjHP/5R8zIhQDCRlpIf4l9UOCQ+ggK0xmbKC3iGxuD4F7R6assmX1iAJZ+LyCpJmUAi08FVsEBlOvwPcBZ2MkPdTPCwrjKmw/+67Zio7DRQ3LjRctXK9yyJ5ZK1xrPJ4/V9td9ZohZ1UAq6+IpDyvcHT2VnJnA9kiSQcrRUl+A9S5N3ctBDzeS87bPPPhAJF42se8I+++yDSZMmpTiqdCCr7qPcMGwSH0TmrcDFvPn+puRQ5AvCasGUFQhY5XNxMW+SnpSUfC5qMrb/76hCnbLzT3JwckTmTcpyEu1kyg9LtpZNxDwsWj4fvPGQQnmBsBl9cwOA3CczeN6ax0my4+uIY7XOojweysZNwiiXxlmfi/uruDFJNhPkzWTwNYd0UDPM23cJstwgyg2TzRJlJyT5KnbhrijzQs0xovYSlSUb04pDaA8U2UPXao48RhFszhtVUqFJwixQHRMODbO6QF4YD4PnH6cJpC2bqGwQKQ9LwgbVQEgQYAhTBs6bfUGXTAbDrlgpynJypXD4X7eyxUQk+OfaOW/pwjlvVYA0N4is+l98jfJACS6WxmaChQ85+4XAv8BSHwbB6j77B7isqIPak5KUh+WNJ+tj8JDIXsfBH36n6PPJZVmIDg6hC4W0apWYO5fxFRpY5Ybledu15chrCDw7HE5XgL0l5M6VxkRi3gIMVck+hS3l62RDaSEmSwWxtSUvNKFu3IK2HdKBc96qAH/BAgdj5q/woYVysiSpkEDohIt5o4ZzJA8VUlGHjwnkki+gVXaW5QIA8zmKSxAnPSyJjmmgewChCwVb1apvfor27HN6Sn9SR51rWaoDhQ0iphX4u3RwhN4BeuFL0MG1Lw4J6mkybSRz9veHbCNpa0uaWkA4b1SZIAd9OOetCshLbmJqIi2JefMtTpS2LVxl5347xXHRma5A6IzSSzJHS8iVORQ0OY0sfL6b8Zj8H+fKe6I6pjIpHS7H3Spk7mM6AHjzbeeYFqJj4spTpfY1Jmy4ymsILQczwrwxyfJQ0lOkzBvxeuRIK/HrctrbirZqpNjJEs+Zgz6c81YFBMJLLC2SmGQHAouTfVUeNfHdz7wUx8XAmJHFTP0P3eJrVFaJI5cvmwkyb6bHFn5Y8oRy+YoxuKQZKLlz/rSCoj2GysUAQ1XFXruyVAcKe58BKYzvb/uWydCY1+A6i+Yx0eaII7QckIkhXkMle4D5sQkhvM0b/TqCNxYKIeGgD+e8VRicN0yTbzHgEY+kJb/LH0w0dqo4LgJj5s8No7BBvrAAiXmTPQgIoRwy8+Z7JuaIxxbI6clxVK6BlvOUL4cEWYpMSsxbJvi60ZgkYfNq9tr1i6tyMG912SwoYfxwiJrSjziYh0XoI8tcSVssVCuNkXYNlezZ2AoUh5CPTcK8OectVTjnrcLgvGEC8hWEXbO/FJ4jD4eLeSuNhSXHjNgw2b84kZg3yYOAnBfmZ94MbUWZt+L/KQ5lIHeOFO6i9e2UyXJQNyXFn3Ysd/zGzZ7l9rP3VFaJp6UZSJuJiPNGylUs/ixuJoP2jexINlyU65Eu0Fx2Skv2APN7339vUu/Zprz/2JzzVgnUjM7bdwVNcc5bFfNVAtWGTGEBlnyeHD3nLeCYUuz4wgKkXTzTg8Bvx5f2QmPefAKbNsnvckV7SriLFjKXV60yMB2WYs/+eyrQ2ojSii7HxHJmymwQ7d4PMm+m5y081+UNjvGQQtIcDH1kMxmUWtlStSJpOcrw7HjjsrAVJhJIxUE+JpjCcjvowzFvFUYhvNvhYt4YQifUcKesatGmbUvcAk5deDnCAsVja37NyhGIJqxbMYE+Bi9DsBVh3gjHJu0lSQl35WhFJvKqVdp1DdjnGAWrqP0hQQKrxMpyZhnsZEjMWzhEzVUlTGHe2CQ+AuOhsJxB5i1neW2HnbcsKURdXmcpbLmDPhzzVmFEmTeem5hDD4lcARfoZhBsa5UtbVl17MQ8LEkPXk7HNGfPTgVz53iYN6C4aOYhzHff4QRxhtBZcDPB45hQmA5OWQ7/T/PK3hDzRnIoo4KvtGMDLbRYkN/7ppuJclV31rMHcIjZ2l/X/krz8GtGdiTajCzV+Ja2As4bURA7WI1vvyl10Idj3iqMQuiGobRt8efP8In9ciSaB3ff1KRllhY5GSaGgmxH0oWAIZRn+wD3h7sAsITOgpsJYzNsjkmgsteba/MKyAjTYTmmOOaNKq7Kkl+azdJCi/6wGSGM769YL9kDqBIftLC5v9K8nJ5CrMYnOO7+vFmA53qk3rNcDe4d9OGctwojjnmjaEYFFnBimy2enS6x4sz3IACIzJufDczR54ie/I6IHerD2//T1nkrnS6SDIZEmsMuib74kyutwL8psbFVEExz7bvu6nzFGFwtkshzxNSGjhLG928kS/YAas5jlhQ2DwrQ2ufgBdgpTubN8vz70xwyXMxboOOLc97ShHPeKoyCt0NB8yJXfJ2UuMol+JlhYgMy1IqzINNhu2suFARKf0LdfctZJRrzxtWP1v/T9NiizBs9d5LKUEj7bVK7YvicN2M2KB8z15abkuKY7CUe/Lao16OMnSTl3+aCThdXtSmJDcqCdK8FBGgJOXhBcd3ia9TrGrC/98NV/TzXEa3AzEEfznmrMJpCD0tKybisQICWF5Zlkxyh5L3kfU4pAOsqqHApPBuDx2aHoQKOi3lr9m14RHH94rrGZqQhQUoYP8y8md5r3DlGYaaDUrDCdT1SBWgj8j7EUB61YMG/cQtej7TriNKBJmineO9TCrrqcuG5NlwfQ3PNEQnwV1G7nLd04QoWKoxwmIqnbQvfwsvRtiWXBTHvJYZ5M3QEItVUlDnyN4NmysHjyi/z/7TOeWumgGm5QWX2hdIjV+Z0kTY3OSLzxsR0xOVyUisXSYyyTICWkMtJDuXFhASNJUf8G7cMU0FXIPROrH71NZS3L+gKFnXYro/eGsLSFYXWR9hBH455qzDCYSpK3ktBcsNQcygobVvCORS2C29Yx8g2F8M/F1TxSH+LJK7qV478svDCaxvKKzsmxddJ/S0Dc2RsRtpCjOTgZIIPy6ozHWHxadI9S8vnkjJvhCpqahg/LhmfoqlXvNcI15FUgNbYjLQDSXisRnaaTeQsUxTiWU4aE0wJdTvowzlvFYZfmqH4k7KoSHKDiHkvlLYtkcXA8tgizJvlYhCo7iPuvvkq1yTMG9FOaVyAxYPA92Aq/qQU0MgWcEryM61ziKwVWXFMdo5AhHmzZDoibd/ILDfDZiJLrVjnqcgNM2+2m9uwDAYllBfYJBO0+WQdSMJjNbMTklMxHFIsy8kWfnfeW5pwzluFEQ5T0dig4k//4kTrS0hr2xJu4G27GISr+8q7ZvO8lxL8u2YSq8Rqxz7vJZIgbjmm8FzbhvICEjgBB9fITOC7qf02/XYymbKEhS3TEQ0J2jEdEYkHpspuKjtJKqCIY96IIWrb859KJxuutn/hzYRtoUHz09s2TBnLchLvtRzh3nfQh3PeKozwLp7GBvFohvmrqShhM79mVGlcNrbiHgQ0RXueHpCBuaYu4BmGBTzsKFs/CEJMB/FhSWm1I0vspoTxw6yiTdUyQK+ADDNv3saN2NaK0mvXL19BKqAIM2+WbGBYENeWeQ1v3DgKuugdaMp5gQHnzTIkTE294WTeZLI8rmAhXTjnrcKIXcCtbpjiT78jQJEc8fftJMkFhHaE5mGqskir345p3kt0cSL0JJXkdNgJK/sWOULeS9gxoeYGhYtDqH0SWUJ5GZ4wfmmD5NkynKP4dAC7nLfyeBiYtxyt165cgJa2KfH/rAXmjSqD4t9wk9jSUqQkGxQyti18CV9Httd1RBDZcI6EEAFbrmChMnDOW4XBVSUIlG8Oam6QfwHnaSNEa20TYd4sGbNomKr4OiWng8y8+av7CHkvkWOznKM4uQBKdR+1OCSYh0WX0qEKvvqLA0rjsrHDuXELVuQGx2kCmQBt8XW780/N5wtXrdrOEZeQrf9v/DIYdmxpmZ3MEEKwXNe1N9chbT5jZtr38SDzZmTGwRDOeaswYneohjeMEMK7aYK5QRZhqmY7fjaIltOB5p+2O0J58rNtHhYL8ybJV7GZa39eIEW+Iu7hZC2KGgrjGzN4vs9Ti0M8RyBHC+PHbSZsRXrJFZDh/EKGjgZFpiNrNZ6inagArd++LvKhObIvNCj+jBYrUTduPJsJnjxF2pgileZc6SmWBEC4stcxb5WB03mrMNha7YRyOihtWwKK9gxtW7yHJZHpiOS8WS7g5fArrOwAYaajdFzGZmKTlo2PLcahsF14w8ybcSgnhnmjSDP4Q3m08Gvxd2oBDVl7LLQpsWaVYvK5qOxk4Hq0PP+lY7IP5cXMkWWeIkdlr/8eEaHXrOyEpGKsxZ7Jgsih9BSOlIlA72cjMw6GcM5bhRFutWP7cAq02snS2rb4d2BcVVkle/7Xte3EtCOyXVTKDg69Ko+a0+F/EPjzXoyPjZt5i2wmTCspi5/PZOg9cgMaZhxdKHIl5s3u/HPlBnGzSiUbJMdE0jnExlbYoaAm0UeuR2qeIuF6DDNdAJ3BA+ydd3++o9+e+SYA0vHYhsxLtnKEYiUHfbiwaYURltOg3sAlG7S2LdGqVYp8RVTMlIfpoOeGNL9ulRtUdijK4qrGZgIPJ4qQcd6Xp1iyV3ydy3kzMhPos+u3Q+kcks2WiwxIYfwQ88qWY0RkOqj5XCUbHDmY/iITmzGFQ9TWhQZxfWSJLCepZ7NkjjiKOmylWfhakcn1NG1D5iVbZUbRyIyDIZzzVmHE3cAU5y2YY0Rs2+LfXdoWCBAfTnFMh22CuMe8NT+9bZKNZY2XrRwKNlax+JPq4MZXCdoxb9Qik+J38zBvUcFXO1vR64iZ5SRI4HBVP4eZN2sHlyrxwdZHFgE7tIKu8pgo0jVsxUFc4XcmQWR/BCLYXcV5b2nCOW8VRlgzyjY3KJZ5Y2oEHv4OHYTzTGwd0wiDR8zFiDwIiKE8jocllcWJ1dXiClPZMm/MOUYsXSi869HOVkSkl6Exvf8nVZaFtJnwsThZwr3PLfFRniM7h7spxEzTCrqi1yPlui45gNbFQSHH1LbjSzhv1no8vq5B/hQem+vRQR/OeaswYnMxqAs4oW1LXN4LtcKLi3mz3TWH+3ZSpBn8zBulH20cO0nNn7Kdo0gIxvI6iqsQpjIUlC4UUYbCzhGI23CRw68c9z6x125EFJe64eLK5/LmKPi6/nggHY9dQVf0eqQwyqVjYmPeiFWikXPGJDfknLd04Zy3CoN7953NgKQZBPhyOjLBvBdqEr3tjjC8qFCFY0uLG4UJLB1CXTbr26ES+nYSxxRewG3nKDZPkbiAczBv/kpKjjGV9iXU0LKtuC7XHIWLQzh67UY6vhA1FanpIGV5FyLzFsnnMrtnhRBSJphWHELLC4wUvtjaYZKuidxnlteQgxmc81ZhRBZwW4FFJsmRsC2SUGdY68my6iicY2RdBRVilazZAH81lY/psNlYcuUFhs8/ta0VufAhBVHUbJbWhSLKCNjmvMUIxxK7WdiGzCOsEkGbMRzKsz62mPwpawe3+bTb6vzFs0pGZgL3ePHepzDBIebN8rxx5byxV7+G1zSnFZIqnPNWYXgPXWqlEFNVlv+7c1miUGcc82baAzJOM4prR0gJU+WIgsgxeS/UBZPaUJ5c+ODTZqPYAYLnn9KFgu/8I/D3VHaKXrAgz+fikK+wzZ0Mb9xsC1/imDdq5xDbgq5AMn6O2I84Hzo2okwU17oWFrEm32cEJthBH855qzAiLUlsQ3lxTiChyTVdhDSO6TJcwMOOKTH8yrWzLI2lnGNiZCZgK0vOe2k+tnCuErmFmKUTGFclaNE5JK6Ahkt7jI15s71niY5ymHnjYDm9MVmy5ZGiDm9MZuOJdGkhpkxE732z8finIZch9iNmlkCKXNe2mwmP5aRVY4dz8FzOW7pwzluF4e3iyRo9fMwb1wM8frdrNp5ISLi0GHC1IyJ0D/AXh1Aq1+qoelgxzFvecLLjwl3WhQ852gIedpT9zht1TNYMRajwxZbpijAv1vd+MJ+L1CM1fK9ZsuURx9Sy8CXMBlGLlaIsF4F5IzLBXCkK3nUUJgCsw/il6zH4uvZ4wnYITLCDPpzzVmGEd/HWTEec82Zxw0RCZ9byFfLdrqmTE95Z2jNvTLkhIRHK0kOzIIpMkdmYQsyCNfsSwywYnv6Ss5cNObjW1yPRwQk4yjliF4qYvCe+/ClLh8JjOnjGQ+ojG6s7aMe8RdNBDMcTPjay5AhC47FjOUtjCkgp2bbsohYHxTF4xMIwj3kj27E7Zw5mcM5bhRHOn7ENUYZ3OywyGGT5CvmDwD5fhXZskcbLROYFKFYscoiZUo8twrzaMh3NXxsRMyXmc1EFcYHiMdG6UMg3AdQQNRfTQW1HFLmGCK2fovIlZnbiu6vYMm80JrgQmmsqy1myEXDeLFt2RZk3y4Iurh6p3rkPvm5vx+6cOZjBOW8VRmSxJOd0FH+ntG3xcjHI8hXyMKW5CGXo2Ii5StTiEP9xZcJipkSHwlq+JDZ/xshMZI5sz1mYCbRtaxVw3qhh/JgcM7Z2RFWSwCmHXxGwky8IYyY4Lv3CnHljatcWk4xvf84QHI8ly5XNFCWZ/EwwF0NFZSe5ctWs7TDdZw5mcM5bhREOU9EFFoM7S0r7Fy5JjciuuaUzbzFsAKct6+rOyLGZ7uIhHQ+dCWZg3pjD+Lb3SJwdrsRu2+btYXmP4ntGptjZcmroLPb+sB5PiHkjyrtQNDVjK3uJ7CQbY8ZUHGJ7DTmYwTlvFUY4TGUrO+HtCEM5HaY3nhBlAVpq6XlcEj01X8V+PHLVfzJbxilfQW1rRc4xYmpOHckxan6d0rczpTA+W09SYqjbluX0d/so/sz43tO/AMKVvf6f9mw5jxMYWYuYxmMv71GeY/YiM+uKXKqQcbqbG8e8pQvnvFUY4TCVbduWWObNcrH027BlX7zQWS58bJaOCZF545JmiEtYt7IVZieJ0gzRY+Nh3qi5fN4DxTL8ms1wqvXzPJyovU2jRSZ2GmaF0L0fFNY2sOP7WnpxEC+Lw92yybpgIcRyAoTzH5PqYLpxj2ozotkO13h47g8bIWMHfTjnrcKItDaxvIHzvoec354tyxUYE7N8BdkOsfEyF2MSDlHa2ApX91kLGTMxC5EG92TWFc0/Lc9Z6LgAxqIO4sPJO/+WMijRNlvB103thO/94nv6F1Jg4xYqNDDeTMZsSszlXUK5c0zJ+PQ+y+XXrO+RUMoMtVitbMduExBOvaCmTJQL3spuhRPqTQ/OeaswYuUrDK/xCPNmudvx36hRNsiWEaAtmHHNstmEY4l2/InLtsxbdI6IeS9M/Q25GIqSM0ANUQK0nrSBMTH12qVeR7nQQ44r37Voy9yOf0zWBQsxmxLbvp1sQrbE8ZTXIh/zZrlRKn11hOkyZae5it7iOtlYsuXlgjffdzjmLTU4563CiGPe6P0/7XY7MubN9uEUFg+1txPcydmGu7hFMf25RdY5NKHzZi1kHHberJmOoENBPWdsRQa+vEI681b8vSz2bJdfGpGdsGWCPZYrOE7t8cTMddGW/rGFZTAAQsoEU6/dfHgNYWJdbR3l8BpCG1OQVbRmumJ6SFvPNXU8Scybc95Sg3PeKox44VhTO+FdU/Q9HfhveKqkRtzO0lrMMhQWsN8108Jm4Z1uwJbtLjV0/m3D5tTddzhPkXrOyCHKkBMAEIo6wnl4nh0jM5JiDB6mg0viIZvNoORbmMxRWIC2ZAuwL6II9+ytGvMWYZWC49QfT/y9b507W2KouBgzJpbT3k7Cs8iFTVODc94qjHCrHWq5uJR5M7j5pMwbdWcZtmNdTRdkKLiYN+rOEvAxS0Rb1oUmoeuI3NYqpXZtpmMqP+DK1zO5qIPYazfc1orMKjHnc/ltmRwaJ/MWdnDtCw14cjAjkkxMDe4Bxjw8okwU9d6PEAnU8cieRRa9th304Jy3CiO+gbPtTpe22/FX92WIIqSxDbPJ7V/smLdY7SnTsFloxxywZclyUvNeIrt4W1aR6XqMY95Mx+SFhCSOsnWP3Ij4tKUdpkIc6v0hK+qwyVULC9AW/09jX3Ih5s1240YuxAlFAajFIVSpECGEF5mICGKT136aHXqhWrDlo2+qHPOWIpzzVmFw9SSNS34GzBbMcLgjOKYqqaxHBGiLr9vumsM5eKZpGLI8LJs8PP+iGB0T0+6bXLmWAvNmsplIClETQ8tcxSH0lk1M975kjmwKFgKVvZbFSuF7xJZ5Y0vGj0gyFRcR24Iu+fVozij7x0It6ApLMlHTU7gkmShCxg76cM5bhcG1s4zumsrvmdgqOzjl18o3ntGQyjkUkf6GdsxbOZTXzLyZslNMukrS0IkFGyir7KVrK4VyjKiVa9b5PHL9QsCQeUtgOkxOm1+ANhtizKjFIfRm6UyOsmQzYSMVIs0vJIYErQtfwhs361AepOMBzNZHWbGSzUYpuHEr/eQ5/1SWk7xxkwkZW55/B304563CiN19E3tJBhp42+QYSUUoTZ2cUC9R4oMgIs1gyk7F6LzZCiIHHYrgezrwL+DRRuC2rGLQnm0FZKRCmNi83bYLhXyuzR0T/1dyMW+eHdu2VkzOW2n8sjC+yZg4K3tlRRQ2dtiZN1laidX66HNwLTZKicwbF2NGZTmZ7ARsOectNTjnrcJgy+lISKQ1ovN9eS+eHSaGwlbMNBLupDJ4oUXOuhVZ4CFnXino/2w4tExm3mwd5bDuHFGAltqFIqm6z4zpKJ9jT5aFqXsAta1VtNKcxir5bXGxnHRpDpodLpmgsFSI6Zhk1c82zJv/mgu3NDRnzJgkmWL7I9POGcWWgz6c81ZhxPekZHDeLGzJqvu4wotcLXLIcxQKLxREMaymbyfKdJQWYJsQNcAnhRCp7rN1lMPdLGzzXkJzbWor/GACfNejwUNOJoPBtilhYijs234FGW7A7ryxCtAWuI6tNKbw5obWQsq2oCvM4AF2YXO/gxYWVyaLRlPnmmgnLMnkt+X6m6YH57xVGGGhTuuHbkLSso3zJts1sclXEAsNuPpt2rNBxZ+szBtbnknoQUBcwG2OC5CzODbnLVyxDMCqqCNJBsO2EIfMKrGFqBEYj+2YeAVouVhF+XVt6gOE87lsC7qkc22Rhxdg3ppNWaeVcPVsDotPM4mq+8dkuvY76MM5bxVGRHaAqY8oYLeTKy+W5deqLV8RdijojckRsAPY7b4DeS+Z4HeYjEfmmNiyOOGiDnquUvB17fFInLesxfUYrlj22zSTZSn/P5qHpW2maEuE7HDlcvquaxsmWDrX5BC15XUUciis+xEXwte1ZRQgImQbfU/LTgLLaVNtmstmfJJMlnPN3LPZ60fMtAEE7FMLHPThnLcKI/ywtG3bEi4X99u0W8B9oqhExixccWicjB/D4FWdeQswHRbMW+m4JLt4uh5WaazUOUqBeTMJd5YeusTrOsC8UUV6Y8RMbR2ccD4XYMYsyVImbO4Red5s8D1bW9b9iGNSL4yLjEIsp618BRfLyVX0BPAxb+VnCA97n2N4hjjowzlvFUYc08HKvNmETnxXgs3OMiBCGWI6yCKU1F18iXmzrIAMi1ACdkxHOA/HPyZ6O6qslZ0wO+k9UIjjAexYRalIL+FhmcnQCxZKjkOYLacWdfjnyqwnqeQ6spkjaeqFufPul2WJVnZTNyU8zBtgFxYMO+4AjeUMrtc8bLlt7lxsBxLiOusfk8t5Sw/Oeasw4nKMbGUHqItTOYk62o7IRnIEiO6+qWKmtkxHVMjYznmTiaJScox4m64Tmbdw3kvpgUJkAgH4qo3NtceosgOyh7f9XIdz3uweukldKGzEdWXaY/SwafGnmX5h+f/kfsSxuoNGZqRsEGUTIL33LXTeqHPtHxNdTiW0SbYM44d7CBf/b3evOejDOW8VRnjhpTJvsqo8I4fCYzrKr9kwb7IeqVxiplSmI5z8bGpLJkJJ2n3naHaABObNehdf/J2s80Zsa5UkzWB3XdPnOiw+bVNpDESvx6CQsXlbKyqDKxOgzVmkcchkWaz7EYfGZB/q5olMJG8mLASRc9H7g9wfmdiTNLzZLo7JfDwy5s05b+nBOW8VRtyuqVptW6TMm01IUNI9gCpCSa1cK4QWlUwmY1VoEGbw/GOySlqWMW+WCzjX7ttzcHNEO1K5ACbVf2KbLds8rLhWS9TEbr9jacS8STYTdRbnTb6GwNyOVJaFpx8xdXMjzZ20KuiSOW/640kKm1I1Hun3fnCui7ZMBLGjzxDnvKUP57xVGNFk/GzkPR1wt23x27FZMGXMG1WEkq2aSraoWMyRLJ/LStFeNteWrb/ITEfooVJOEKc5k8UxlWzp25GGqSzC5knMND0PKzhWXYRZdyrzJr0ebeZIIoFjLYicCV2PlnJDZFkWybFRwu/SXE7ipsT2ng1vlKwLw5KYN4N7Nml9dM5benDOW4Xh7ZpCIRj/e1p2ZKGTErNgJGYaz1AYMR1+5y1cCm8sg9Fsh5iQG2be/LZs5ki2+7aVCyjBlnmLyk5Y5hjF5GHZ5ipR+23KHgQ2YfOkcBd9jpiYN38Yn9jWyk5OJcpO2aQ6JDJvlnJDVMkRaU4wU84biXmThKitUx1CgthUUXW/o0tly23XbAd9OOetwvB23zLmzWhRiephcTFvNoyZnHkrjZW2gLMyb1aCr/GLk41QJ3WHKmu6bst0xFX3AXYsjozlNBlT4mbC6qFLGw8gmSOizhtXoYH02KjMm0X+lEwQmZw7WWKDiO3assR7LSyG7R+bCfMmq1rlkgopr/tGZmLtAHS23JbldtCHc94qjHJ4qbknpXXbFjTboe2aExNyLR662QzoIpThUJ6l81YWRC6/xsWY2e3iZQu4+Rz5PxpmOmwrcuXyFTbsZPk1G5ZTyryRHBzaeIBotbEtqyC710jiusR2RNLxENaQ4L1Pc3DDYXwqy2k7Jq6m63I75pGJQkGg9PGoJJNdUQdVuoaLCXYwQ005b7fccgv69++PVq1aYZdddsG7774b+9m7774bmUwm8K9Vq1YVHK0dwg85+7YtUUeAIvEhrxI0f+gGk1aD32E8JirT4bUiozEUMqkQO+ct+LfF/5feMz9nQHrNqQFbdjLKclITxCnFIXVE1tX/vVQmOJzvWhyf/b1GbUeUGMa3SuGgJ6zHse4FYdqPOP6etamip3b8kFb2ZoLfYTIe/zishYxDfYQDBV1sRR3OeUsLNeO8Pfjgg7jgggtw+eWX4/3338eOO+6IUaNGYcGCBbF/06FDB8ydO9f7980331RwxHYIP+R817sV8ybLDTJ6yEkcEwobkA0wHTxq/XTmLbrbtVkwqa3ImkJVi/7x2Dpv5KbSIUYgmETPw7xVNSRIFA71Mx2RhuKW1zVVm1HOKpnnmHEJ0JYdk/Jr1EKDcGN64zElOKY2Dq60EMfEjox5y5nLsvi/M3zvm+e8Be34bVHn2jlv6aNmnLcbbrgBp512GsaMGYNtt90Wt99+O9q0aYM777wz9m8ymQx69Ojh/evevXsFR2yHMotT/N2+bYuEeauiHWm5OLFvJ9UxkS+8wfe0xiMLUxESu8nMm0SWhepQlBx/+y4U8U6XlfPm29RYOV1MbFBgrskhweZ7zX8d5SwcAWk+V3S8KkgZZZIsS3mu7TX1ghsc6zB+wqbUxMGVz7U9E5yVRDjIzJs319pmmj8v20zyPENs134HfdSE87ZhwwZMnDgRI0eO9F7LZrMYOXIkxo8fH/t3q1atQr9+/dCnTx8cdthh+OSTTxK/Z/369VixYkXgX6UhTYC12X1LQjB2jFnzGKi7b1/eSwnWDkU+SOdTKzKpPUmloRNCYre0ktLk4Z1PWMBtq/KITIfM6aKE4MhFJhLxaYozCSAizWDumDTbIT7ApSwOgTGTpV7YFCtliefe/3lpAY1NGJ+poKtOMkc26Sn+DaCNxEde4rzZChlLw51WTDAC4wD8hSaGHqWDNmrCeVu0aBHy+XyEOevevTvmzZsn/Zutt94ad955J5588kn8+9//RqFQwG677YZZs2bFfs/YsWPRsWNH71+fPn1Yj0MHSZIK1NCJjZOTxLzZyQ7Q815KH6e2bZEniDe/R6yAtGLemIRjk9gg02T8KPPm+x4b5y1HY18SQ4LUnDeq85aJXo8mKN1rZPkKidPFlURvtZmQ3Pu2Eh9JzhuVLbeTQZEweATmLSfZbNvY8duyvx55riPZM6Qs72M0JAcD1ITzZoMRI0bgxBNPxJAhQ7D33nvjscceQ9euXfG3v/0t9m8uueQSLF++3Ps3c+bMCo64CL4bRkLnW+zApEn0BDkNajJ20VZQBsW2bUsS82aXP0XbNcvbEdkzeP6m6zasAhB1lmzD+FKGgpQ/5Z+j4k+qLAulOMBvi5MJpoRyqWsI1z0rLXywlPgIH5vf2TE7Np6CrsTcuSrm4MnvfW0zsWOyux6Df+sfk2Pe0kNdtQcAAF26dEEul8P8+fMDr8+fPx89evTQslFfX4+hQ4diypQpsZ9pbGxEY2MjaaxUcFdByXfxJuOJT6Inyw7YMm+RXpJlm02FAnLZnP2YMiU7tDCVza45SS7AKnfOv4tnapFT+n++IOzypyRjMmJxmOYokQ2wFZ8uMcG+0JIQwpPHUI+JJ9yZxE5a2SH22pWySkSJDyrzljQm6j1rde9LmGBKDp78uMwcJdmYbORLpPeaxbPIwQw1wbw1NDRg2LBheOmll7zXCoUCXnrpJYwYMULLRj6fx8cff4zNNtssrWGyIGnXbCNmKs9XIDZMtmE6EnaWtsxbTsa8WTQ5l7b/sQhTsbUiy9DmmotVAGKux9J1RNRnY0t+tpJTCY4BsGOD/A/okilrJjhFxswrWLC6Z2l9jXnv/aAt237EXGNKakNo02JPWpFrU7Euvfe1zcSOyetta+NQOuatoqgJ5g0ALrjgAowePRo777wzhg8fjptuugmrV6/GmDFjAAAnnngievXqhbFjxwIArrzySuy6667YYostsGzZMlx33XX45ptvcOqpp1bzMJSQJQnzl2cbjEeyk7NiOmTVXRZMhxAi0h4r2raFwLwRcsyorcjkLBeBeSPm4cSNidIeje68Bf+2+H8bVikpD8eOeSkxbNZMMFeumoQxs2NMSvd++TVKsRLHcYVlWUr/35AvkLXHbI4tiXkz2dxIK3JtrkeZvIct8yYZk01vW86oi4M+asZ5O/bYY7Fw4UJcdtllmDdvHoYMGYLnnnvOK2KYMWMGsr6LbOnSpTjttNMwb948bLLJJhg2bBjeeustbLvtttU6BC1IQ2eEh4p8wdS/ieWhvOb3qpD3klRNVRyTtik2x0QWqiDZkc01dfdtkYcTN6asxXUkb/9j4SgzyQ5ImTdKpbFkroHqNPAO54QWbcLYThLzVo0uLbJCHKCZGcobbpSSch4t7jVpXqBN9TOVCQwJ6wL+yA2Mwvjl67H8WulSoAoZ21xHDmaoGecNAM4++2ycffbZ0vdeffXVwO833ngjbrzxxgqMihdJit3UMn+SxAc5xyiBebNgufy2glpPtIbJNrtm2UMuSwlRy+baYhdPdZQCY5ImrevbkbGBbIndVvIV0crOrI2Dk493TMrfo8e8JW64iK3xbNhJ2cPbpliJuwgLCKZxFJ3ugpVUDHVzK3VM2YSVeZjAcF6gn5FNHJNEtsoqrUTGBFt2M3HQR03kvH2XIA95mD94ZQniJImPwOJU/MnGThGZN862LTTGrPyajYOT+CAgak/Z6rwlObgmjnKShh31eqTIV1CZN3mXDhrzJjtvNuykrCLXTgYjKqdSnd6/Mcxb83/5xqRtJiYnmHAdpZgu4/8ekzGRC7oSCAnHvKUH57xVGEkUs10vSdpuR8q8NT8J7NgpxgWcaispGZ8YXrLaxUsKKEgyMUQ7/s/LGTMLO/7r2qJ7QJryFV5o0aaSTsIqFMdrzuJI732j6zr4t8X/20vgSFs/VeM+k7DuQFk/zmZM0o4vRpsSmfPe/B02TlcKERfbilx5SgCBeSO2tHMwg3PeKgwps1DapTA5S3TmjYfpoOzi/ePw26I/wCl2yq9RdvEy1pUzBGMkZJwg1GrkmJQe4DJRVKvE7uj9QZWKsAlRy7oiZLMZlH61ErOVyUUQ8wJJwrHSe9bEKY3Pd7QJUQNx12Pl71l5IY458+bZkd37xFZkts5b4rOIaa4d85YenPNWYXCLNcoWTCsB2lSYDvvjitgiMWZcDB6ReWOea1m/RUBfvkIIIbVlxZhJcsOsGGWmxO4kNohaHOK3ZXU9ElskJbW1smmWLl9DtM1Ii0MoIUGA4fwzseXyMGXwO4zsUJk3734tv2YvZJywHlldR455qySc81ZhJElq8O2aicwLcy5Gk8FWt+zgIFA1xce+EI7N9/y2SzTnZZUCzFvOfAH3f04qPWBTREFt/8PNvJGZ6eDfhm1Rr0c24ViLc8bNvFFb9cmOyz+matz7cpbbXJZFGuGwGI9cWNf83i/E3PuUgi5qLqeDGZzzVmFIc4wojY6JzJssLGDDmEgr6TymQ9uMNFfFP6ZqMG/lkIcsf4bGmKXBvGk7bzE5RjaOaRKjTD1nFPkKOjMdw7wxbXC48wLJ7L2XMqFtRjoem37Eshws//iqmcYRYJUywfHqQJpbbCUTU97clmAjZBxo+xbI52y2Q2TLbVJvHMzgnLcKwh+mIjNvCcnvNouKtNrQRmFfOh6DMIW3EARf53IoSHaITKAsQZzUCFxyXCa2OItDuER6uQpx5HMU/A5bO/4x2TAd0nvfhOUsjUnS1spKSsd/z1I2kpJwMKC/eZOxUwCRMZPkmNk5uL7x2BRQSNhJLubN/7vVvS/pQGM0Jpl8iYW8j4MZnPNWQfjvBy5JDZm2DlUZn6KwL10sTRKEY5i3nIVDmSSITC3qoMiyyJgXm3wumeMO6C+YnM4bp8o+QA/BJOkX2jgmETbI8LzJGtwDtsKx8cyblQwG8f6Q5XKGu1DoQLZJ8o+Pms9ldWyyfC6rOWr+2xSu6+Lvze/r3vsxrLuNFmLSXDvmLT04562CCDwsmZpBZyW7ZmpPShtx3STxYTO9sGhYALBjX0q5dkEZFJvQmcwRsLfDNdcyxx2g777ZmDfKdUScaynzRnBMYpk3zbkuqELUVmOiJYjLmGAr6ZIEO0VbunaisiyA3XUk3XARWEWZxqMN88ZVqBa+Hk3bWvmfEcEx2VfSyphXEzsOZnDOWwURT1VTQmeSPCybXDUiE5jEmBQEtPNeZE4AUF7QzRK7ER0TIUGcWgrPPddx8hW6znL6zBtvYje1u4a3ubGopMvGsEG6TIf/OqGGzvjyuaKbG1L4VbIpMbEl6xzht0u9Hm3SU5okXQgohTjy9BTaXAPm4rrxrch4Nu6ut2n6cM5bBaFMELeRnZCq/lssTkTtsaSEXBNb5UU3FDYtMW9GY4rvS2gnzSBhOqzyZ2TyBbSHN2AurhtX2csny4Lm8dg8dGWskraZ5GR8IssZGFMV8guTjs3seiz+lMu7aJtJLFYB9M+b7H7126VKxdgJIiewk8S8Wa65BsyFjEtzncnwFVBJq42d85YanPNWQcRR1eXFycCWhHmzCr8mtP8h2/HLVxg+5HKhK5Mi8yBP7OaZIztphvJrXJV0gLm4blxlr9WYpD0XKT1yo+MhJ+MzsZzBMVk4bxLhYKpjQmHepGyQwVyrhGN1bRUYmTcpG2g1RzysUl6ySbYRw5ZV9QdtmV2P4bnmakXnmLf04Zy3CiKOqrZp25KXhPKqKaeRzye3EdKWr5A4pf4xWck8SOaaS1KhKsxbzAJuyrwpK3ttHk6BY4O5HdkcEeQrZHMNmDAU8rk2vR7jmA5PmsGKCY7eszZttuTslLYZqVSETT/iJkkY1z8+Xcckrqqflp4StUPVLyzn4GmbiS3qMF37Vew9VbHAhuV2MINz3iqI2AWcwLzJcjHYnDcj5qX5b+MqIA1zMaIOhRmLI4TwwhGyvKdqtCIrL3Ll1zjDpqasiaqyl87gWrBKMsbMq+y0YIMk6QCADUMRU/2saccT+83IzxlVzNaOnUxqs2XDvNEYM5Ud3Y2S/+u4BGhlc2RV+CCtfjWYa0UY39h5i2GUjbRCE65HV22aHpzzVkHELeCUnDc2yRFyHk68jpGJrfiHZfP71BwjZl01Gz0kKatEZKf849N9yMVW9locm+eYEqVrkpuca5sps0ExmwnTXLXIZsLwAR4n9muVpyoJ5dlsAJPabBnZkYwnOCbNOZKMB/A7OWZzDcTkc9WK2K8v581UyDiOCTZPT6GxnEBMVb+FHQczOOetgohbwLkYM0q+gpwJNLGDqB1C2DTqUDSzOBY6RvJjsykOoc0Rd3/DXGSOTNmg0i6e3s1ClhtWxyRdU2dxzmRsgP//XMybtlRICm22ZKwidY6sUjhi8qdMNyaxoTxDiQ//0OXHRltnad0syq/ZbW6jqSB+W9S5tmPeij+pkjMOZnDOWwURt4Bztf+h2KEvclHmzS9fQWbeSnYsmDc5Y6ZlJjQmIvOW+NC1cJSI4c44xsRmE5CoYWf0kJNfR8X3TMYjkcGgbCaIDIWqzRa59RdTWytSGJ8aypMw0/7xWTFvxDC+7LzZdKBJYt4Ak3Ut+rf+36lzbZcOklT44py3tOCctwoidgG3SX5PqDizKYWnL+DFn+GHnGmoIu5haSoe6f+cXInevDhEbocW7qIo7Ecqci2Zjojgp2H3gLjWT3Zh/KgdyvUYx7yR58jwXlOxU9T8qTqLvMBkBo/GKNvYiruuTec6lnmzKKBJZJU4W9qZMm9ElrPkeMZej8TQsmPe0odz3iqIuDJvq923tOLMXppBtoDbyA7ElZ5rt22JeciZtm2JY97KLI6WmeCYJGX+VAFamwbesYUGhk5XbOGD6YMgxnmzSweIPpzs5FTi2QCTMcWJ9JoyC3EVwjQ5Fcn1aGFHunEjttgr/m4m0hzHKJvOtZ95k62PXAwuvV2b/WaCzLzF2bFp15dwPTrmLT04562CkLWjAWiMmWxnadW7USoeSWPwbGylwbxR86ekc2SxyMkWcJsG3jJpBsCCeVNIjlAdZTbpmtJxEXPnbMYUd8+aMguxyfile5aJ6bArVqJJ18Qn0Te/b9iFIpzLac3eZ0Li0zbMm4zBtWmzlZBfaDImZcECdTNh6HQFqvol66PJde1gBue8VRAyJwCwzTOQ7eTMd/HSXCUvp8O8J2mUMTPdNSfbsSl88C/glKKOAGNmw3RIFnCbBt5c0gyxzJvlgyBsq5rSNTKWMzAm7R6Q8n6bpsyCrDUa4LtnTfKnEq4jtrk2Ci3GObhm/TbL50zOvOU116M48Wm7XM5o1wcbVikv2XDVJPNmmQ4AhATjDSMuDuZwzlsFEZv3YsG8yXtANr9H7SXp5T1om4kNnRjnq8Q85Ix330yskv+zQabDQsNMsoDbtRFK3gSQq/tMQ4KxTa4tHnIJuZzU/EL/mPSrlpvHELZjyCzIpFQA83tWKUBL3Lj5731t+YoYVrH0LDfduMXes8bMdPB1UkEXsem6zOEOCBkbbpTiniGmVdTUFB7/54KtGs37GjuYwTlvFQRX5Zr/s/RqKpmd0njMmTeuxYCchxX7QOF5yJnm4AE+x0Syiy9+j1lD+egCbrZgyhLfi3YMd9+KziFGIUFJIrWVdIlEpNc/Jv054snljG+zVWLLzc598W8lzBtR7NfPnlCT6D3mjepQGMqXqMSnbdJK6DqYcZtSw3s2Nvxudq8pC3Gsqvpp3VUczOCctwpCVXFmmtgbtmWarwAkK9GbtG2JT1o2W+hUDJ62HQWDZzNHUuaNseLMuKF8TI4RV+jENEE8rnMIdVNiIzsgE+kFYNytgauKOnZzYyhAHBeizlmEqWS5k35/h1qMUfqViw3SnaN48Wn7tBJqUUfsptQwL5ArVy1WJihrdh3FXo8WRIKDGZzzVkHEPnQNxUyDVLXM6aI95MoODgPzZlm5SHUCuXpSAuXcv+DiBKPx+D8bJ2RMZt6YRFFNGTNV5xCrVjuSMBW1ZY9/jNrOUgzzZhuiDrNBpsnvqkIco5QJBfNmyr7EsUpk5s2ba90G96VrSN6lxS49hVbUEdvWyvBei51rYyFj+XiMmbeYlAnHvKUP57xVEGzMm+9z8v6GNgt4tEeqSd5LbEJ2zvDYUmbw7Oao+W+Z+nbGChkztbahM29mDIVagNZiE0BMEFeH8WnMm+1ch+2YHpsqbEpnOaPv644pUtRhmoelkFIyZd6o0iV+W/55scvBjBY+2Ngq37NUIeMY5s2w32qgk43PlGPe0odz3ioIlZwGVVfLZvctW5xsxEy9HLO4HKOqMW8xeS8WFWdS+Qoi8wZYSHMoH3LUuS7+NBVFjWc5tcwAiCkOsZAdUFfT6drhZt6ITIf/3pfJ+xDZoADzZnodEYuMVFJK+qHumI2klUivhHmzuPdlkiPFMVleR3GMGdP1qM9Ml++zgCyLxRw5mME5bxVE3I1nK4MBxOy+DfJeZGGBgJipaXUndWepsmPMTgVftwt5BP/W1k7cgmlajKFk3kzZ0hpi3qTaYzbSDEzMm5LFoTJvpuxUCsxbwE4m+r7umGKLg3TzpyQNzv126cy0fUEXvfo57tjM2EBlrhrT9WjsKBPPmYM5nPNWQcTnhhCcN6K4rqwlDaWNEDmUF6OrZd/6Kdwj1X7hJVecMTGvXHMd39Yo+D2644lPB9AyExiTLEwlhAUbFMe8UTclzb+azjVXm60w02HDvMnWo0wmY5yrqGRxtOc6+Hcl2CbjU5P6CwWB0tDJG7e4YzMtWGCaa9maFrBjyLxxyF85mME5bxWEcodquFiGq/usxCMl4UVKA28yQ1FaLGOrBM0eumGtJ9OF168gLisOscmf4RIgjpOdMM0LjCRRG5+zmHNv0W8zKUHc/136dmKYN202qPnY4uaImBNaZkwMmcDYXCUGdtIyD49arORJjsTc+6ZakVSHIq6S0qYfsVJOhdiBxlTIWNWqUfeeVfW1de2x0oNz3iqIuEXOmnkhVhzF2eJs4G3K4sQ+dC0fKHFaTzZhKinzZhGiZjv/kTkq/qQmLZsW0MS2fjKs7AyMScK8FW1V9tjiw/h244k/91pm4tcQi7xAtlZLkg2gnZ3g33l2TJm3uPZxzCHqfEG/HzGXkHGsSK8hyx3frs3MTlyxig076WAG57xVEPF6SJYPlBg7XIr2AD2nx5TFkbX98o/JNJQTMmMdNguPyWb3rXxYUjXDDKUZ4hzlOkPpGmVXDEOJh+LfxjBvpuwL8aESvykxzXkryMdjKEDLxZYBabRZC75ubieOnbK793kFaOWbW93pjmO6jOVUYpwu43tNee5pxSE2wtoOZnDOWwWhYt5M2xFRGZy4Mdm0bYnX1Wq2Yxhe4mr/Esu8aSvjl/8v6yVp9LBUOG/Gav1x+TNER9l0MxHX+sk0HByoopaIohqNybtHqGxQ3GYiOuZkO8WfsVIRukwHU6UxUNYvjJ7/4Hfpjykd5o1LcsS0oCugpykRjS5+hhrujn6Xlp3Y1AstM/HMNFMUwKaPrIMZnPNWQajCC6a5GBwLOFe1UHwvSUPmLSbkYbtrptrxL84yIWMjsd+4qkxDoc74EJxh/kyMo2zczYJp9+0ft98R9NvVrlxkGlM8i2MqQKuSHGGq7rO496PMq10lLZ3BS06i17/3FQweJ/Om6SzFi+IasuWKe1ZfWDuGmWaqfK8zzFF2MIdz3iqI8u4r+LqpNEPc4mSTRK+UVDCtgoqwL8H3lXZiFifjti0xDxTT0HIs82YVpir+jE/spy3gxnMUx7xYMmaxbIChUwrI8wtNbKnYF/Njo4micov9sjhvqjQOphwz4w0g+d4Pfr9nxzJvNq4wrGjLjHmjSnxwtbVS6WBSi5VMryEHczjnrYIoxN4wwfdVKC1O1J2u/7NxCbDGTBeReSs5pnFyGmTmzbCow784yyrObGxRq/LiWU7DORLBvwvbMWbe4uwYVnYCwWOzCeNzVUCWjy34unfPEhvc8+Xg8bHutqLR5CIjZTK+4eaWWNClYm+LtrRMxaZxmObOqtpaGWvhRYgEUwdXJTninLe04Jy3CkKmqVb83U4UNa61ic0CzlWZFV6czGUw0Gwnbtds1raFyryVtdkQ0NUK5r2YsXhUIeO4BdycWZA/5LjZKVO2DIgPU7IxVMYh6vCGq/meNWSCqcybMleJkXU3zgskSnzkVQweNXfO8t6Pm5+iLVq421TIWL32m46H1oFGybo65y01OOetgpC1WgHMd/FxrVasCha4NJFiHFPzHKPkfBVjSQUyE5jMTgDm+XPUh2XcAm4+18HvD9sxd9zlTIfpcQGy0Fnwu3THRHZMvEra4Oum92xs6ydb8emYXCVdIWO/fiFVo0vF3pOZN8v7I5adMnQmw9dQgAkmdn0wZ8yCfxexY9z/Nfi6cboM0zlzMIdz3iqI+F2KqZyGoo2Mph0hRPyu2TQPL6bizJh9UVScURO7uZ0AwDzvKU7ig7qAm7OcPAUUsayScYiy+DN8XMXX7O4RcpjSE+mNYd6ohQY50/sjeVOiayuYjE9jX7wxMfXbDK8htkUm1ErKuM2Wja1YFs9WyDj2ujaT5Ymba2q6jA0T7GAG57xVEPFyGmY7VC59Jv/HqOK6KuaNWozBJmZq7CjJH5Yk7bGYuTadI3KDe0VDedMkaqq8S9LDsvQS3VG2DJ3Fif3qXo8KO6bh17hNif8zSQjIssRo4RknvzMl41PD+Mq8QKJsUcAWkcWzDZvH29EyE9/txVYMPUFPUVfI2MEMznmrIFT5KtqJ72zVXfFhKvvwYtoyKFRJheD71nYsWojF6WqZiuvG90nk3cWbyhfEObg2fTvDKMlXsMlFsIWENa/HvPwhZ8t0xG1K/J/RsQPEO5TGshNxc82VjF/hkHmcowRYMGZsG+5010euog7/7y5ymg6c81ZBqHaEZDbAcLcTJ4MB+MKLTAyVcZ9Eqphp7ALOk/OWzWZQGqIp0xknZFxpqRiVo2wsQEq9rhMellkuhoqpyXnWknmjSkXES6BEx6xjR2bLljGlSnzEymAwdaDhkmWxscXVikzd1op4HTHdH342V3cdcTCDc94qiFj5Cqbdt+luJ04Gozgm3uo+47ZW1J0lV45JjB0bW/GFBqaCr8zMQixjpmVG2TmCel0DhHskTi7CkA2KD+ObMR2x7JSh4x5Xjatry1/dSGdeS2OImSMqg2dY+KJaH43tZCT3fpXYQFXqDb0Qy2zdL5+zUMTF/yxyvlsqcM5bBRG3gNsK0FJ3O/6PRHdgwe+yHhNz/hSXY0Ld6QZsmVYJxwgZs7GThgtvpK2VoSwLG/OmkWNEZqgMGby4PLyyALGWmdhNiXFeWEzKhP9XU+YtPN22if2xbdZMhWxj7Zjeszyt0cL3h9+2zr3vLwyjMmaxqTdMDq5pQVf5nAVfDxZ0Oe8tDTjnrYJQlYubsgpxuy9Ab7cTCJ1Q2SDvYRl83TZ/hrprjnNMrHNMknbfpo5A3FwzMa9UB7fO0DFRnTNd+QotR9k0V42YY+Zp85EZMx7mLY55yWQyRkyn/xrKxGwCTHstU+Ur4tu1GbJBTPll5XMWfUx6RUYaN4n/62ILVojXta2dWCkl46IOuaMMOOYtLTjnrYLgyjNQhRaLttR3TOkz4fYvftumjEBkt5szZToqExKkNl03tRXQ1UqLebVk3qj9NlW9VgG9OeIMU3FVLqqYN3N2ktZmK455Acycd518LtMeueQk+th8ruCYVVB1IDFnuaLvmWy4AsUhYafLtkCAWBgWrzkZHXOinbjiOYsWYg5mcM5bBcFd4RP30C3aUtuJU/z32zbdgcVKKpjaIYbgVHlYumxZXNP1gC2NyQ4s4MTcIHWhgWnII+6hq2UmNg/LVL7CO64kR1nDTqEgUJrKuLnWD78224kVRNYy47v3g6+b5uDFMS9F2+bOmzREbcviEK+j+I2bnbxPkg6iXkFXPPNmkurgPx9kIWPFptRUSif6DDHMdU7os+wVdDmpkFTgnLcKgqsCLq5yzXS3k6irZRwS5Nl9q6qpTBXtqY5SklyAyQM8kGPEltMTM0ds4SWzZPwkJtiIDaKyShqVlKYFAhHGhKsdkS3rTmQn45hJgH8zqS0cG7spCX6P7njiCsOK36W2E7e5KdrSTysJSDLF9SMmOsrmqTcxskVMhQ82thzM4Jy3CoIr0Txu922624nL5wHsK8Wou2+VZphuaDHOjmk4OO64ALPE/qTdt3EjeC7mjakvoarIBDAMmyblvJmGqZjmKF7wVctMrLwPlwCtf0wmbJCM5eQK5VqnKMR0e6HOUbAfscY9m1BAU3pJZ46SJZl4WE7z1Av5eLjSE2xsOZjBOW8VhGrXZLyzTAp3GuwIeWQwVMdGrFw0LHzw2Cliy564XKWgLbUd/zzS2/bIF0zj3Te3cGgCE6zD4OrpatFC1MYFNEpNRR6RXnOmQ5ZEr39sSSyncRFFTHjRtsgoLhmfLoPhY9507tmEAhpb5o3MmMVs3GyZN668WWqqg4M5nPNWQSgFP4k5HQFbOjvCBA0z05LxOIaqzCxomVHmz1CFjG1D1OFcJcAsaT0x78VywYwwr0whOGvGhI15i3dMTEPUcflTZBFSS4c7VoDWeDzR90zY6SRH2bqtVUwyPrU4xHpzE7PO+r/Lxg5gNkflNBdEKnuNhYxjmGDzda34M3auiWxpwJZz3lKBc94qiFjBTyaNHsCUeYt3As0bgcewONa5QfJFxThXKXH3rbHwxlTRBsbEFMojV9Nx5SqVzplpUUfITiaTMdIL1AkJajFvvnFHJQyCY1ZBnQ5gxuBRBWjjpBkAM1ZRaw2hdldhTsYnz7Uh85a0uTWZo1TmmvwMkRcZ2RZ0cfR/dTCDc94qCHWrHRp1Dpjl0CSFX41zcUq7S+JOjo15i8nnC+a96O+aJVEBK6ZDuvs2rciNCVOZiusqqwRZijr0NwFJCeImzJv/vIZNVZt5iwvjas91TJ6i37bRdZ20hmjS5arqZ7bOIcQ5ygXufQPmLWl9pLKcpptbhdwUVeLDWk6FwTF1MINz3ioI1Y6w0sxbEtNhOyY+YUyqnbg2Qr7dt8GuOYnp0Np96+ziTZm3sOyEdYiapkSfWNRhEH7Xka/QKsTxzXVUgFZ/PEAKotEx17WukHHcGuK3pTfX8vvD/5oO+ZIky2K+4VJs3AyLlWRCxh4TbCIVItm52TBvsjXE/p4Nr2s8QsbGBV2JRR1m583BDM55qyCUVVnGi1xCbpDBoiLbNZmwQf72L+Rji5NBMQhRFr+v+DN5920yR9H3jKQZEpKfTVnOuNBZ2Y4p8xZ83daZpDJviUn0Of1jS87DsUsHiDgUOf37o2gnOZ9L15aedI3+9Shl8AzYoKT8wmol48f1EPbbNmKCidI1SWK/xoUvsQ5u8H39McXMtSGDl3Q96p43BzM4562CiK2msnXemEJ5SbtvrVJ430fiGLPKt3+JEY71V0AasUFJSfQGbFBCdZ95KE9ux1i+IsYJND5n0k1AcMx640kKL6nHk8QEmoYp485/zpBViAvjB5w3ooNrlDKhxeApzSQW4tgm48eFBKkCtH7bVHbS6N731jRaIY7/+2LlVIhiz+ZzrdYK1bXlYAbnvFUQcTtC+7wwnqTlpPwZraR+f45R3K7Z0BEgJ+PHMHh1lg/LpJwOnblOYkzsc4NoLXJUzJvxOZPNUc6kjVDzwzIpTEWsEvQYPF2nK6bamFuaofgZA+dNJs1g0R4rmZ3Sn2v/35Vg3Ec2jnkzLsSRCysDpnME6Xj8r5EZPEPmjautVdwaYlzQpZEOonveHMzgnLcKQrX7zhf02rYkygWUeolSc4wMdk2Ju2/bxsvEHpBxx5a1fFhKWSUDZiGRDbLNDYptkUNT/TctoEiqWjbJe/FCeYmskno8Wgniuk5XTLWxtZxGzDnTHZOWNINJHlaiPpfSTOAeojJmTUz3Ppd8RRKrZGZHg+XULlYq/oxGbyzTAWKkS/yfsbHjt+WYt3TgnLcKInb37bvwda7zQsxD12/LZNeUtCM0seP/uxJsezdGk/H1RTGDdmiMWdIc2TFvNMkRIJ59KZ97LTPxYr+W8hWJgq8GhQbJBTT6mnoshTgxx2YsZFs6tphzBuixgTqbAJM5StbUMxREJl5HXEyw3hwZsJxEpyvRjrHOXyHwd7Z2YmWr/MybQVGHjOV0zFu6cM5bBRHX5Np/4ZuJR0bfM2FxvJ1uwu5bi3nzPXRid9/auUExu2+DRtD+zyUyZiZzlMQqGT0Iou/Z5zzSmDeuSkodx9RkrqUFNEZhKnnfRlM7/jGFH07GzJuiHy1gyLwRc9XKjnv0PRvHJJOJzrexBJIiHYAq7+K3TZ1rk2NLHI+BgyuE8Db3qUnXcDJvhoypgxmc81ZBqNq/FD+jYSdJqNNgt1NIuPGMcuf8zBtTy6bo7ls/dwpI3n2b7AgT7RgsvFqSI6ZsUNwCrrlWqhbwgoBWGL88R9H3rBK7E86ZSS9JTgkcLuYtbMdUyFhPKkS9iMRpBfrHaLQpkbKudj1JY0V6DXPn5HNU/KmV6sAk75M4Hou5lo3JWN5H0RpP11Yiy21Yke1ghppy3m655Rb0798frVq1wi677IJ333038fMPP/wwBg0ahFatWmHw4MF45plnKjRSO6gKFvyfSbYTH8ozESFNFEUt5c7p5Co1j1m6+7ZmKOTK+Cy7b4MFk2v3XRYxjr5n6uCodLV0k5+5FnAd5o3MUBhsJpKkIkyYN78EDlc+F1VOJUmawYZ5k16PBgUCSQnr9kn0RFYpoSuKySYwiXW3kQkiF4Yltn0zc5RimWDLavykFB7d4iAHM9SM8/bggw/iggsuwOWXX473338fO+64I0aNGoUFCxZIP//WW2/h+OOPxymnnIJJkybh8MMPx+GHH47JkydXeOT6iGME/DeQFvOWGO4s/jQSoUzKxdCyE/wbP0yZjvhG4HYilNRQhQ6DxyU5YiKnIRuTqeyAnhI98TpizjHSk66Jvz+4JHBMczn5hIwTkugNOmzotNkySZmQn3se+QrTgq6kFAWT9IukxvQ2MkG8hWExoWXD9JTIpiSbQWnpNbtno++ZOpQOZqgZ5+2GG27AaaedhjFjxmDbbbfF7bffjjZt2uDOO++Ufv7Pf/4zDjjgAPzqV7/CNttsg6uuugo77bQT/vrXv1Z45PqIy8XxOypczJvOboerhD2ufD1oh8ZQGOdhJS28XPkqFo6JxIzZ7jspdGLZRzZxM2HAUCQLvvI4bzpzpHPuTfvRxt2zlWbeEqUZDBzKJDbIJCSclF/IJRxrWtAVp18ImBU+JbOK5msIV9ETEN9dhSqIDNjeszTW3cEcNeG8bdiwARMnTsTIkSO917LZLEaOHInx48dL/2b8+PGBzwPAqFGjYj8PAOvXr8eKFSsC/yqJkj8lk6/wdjtG7VZkN56+nSSGwoTF8Zg3BuctNomesQLSZtfMJs1AZd4Cu29aeEnVzcJ0TFQpBB2JB7N+tPFhU7IEjm3unDT8DuMxJSaI6wh0J7U1smE5k5g3w3s/cl371icqG8Q11ybXdVKkxEZuCOCTUuKrpI2+55y3dFETztuiRYuQz+fRvXv3wOvdu3fHvHnzpH8zb948o88DwNixY9GxY0fvX58+feiDN0A+YZdqE4KT2zHPn0naEZKZN+vKRSLzxsSYeSxOooNLPWeWu2+mNmvJBTS0Y7NKok+Ya5PxUItVdFo/cThvZkLG8dejkQSOzhxRq1+Z731dWzpskNl1RCsy0mlpZn7vh+wYCxlrrI8GmwDHvFUeNeG8VQqXXHIJli9f7v2bOXNmRb8/qW2LTfK7fNdc+i6e3bcW86YTXiDmBpnaYdtZJjJv5n07qZIjwd03zxxRmTe9xG71eHTC+OQiE8+OhoaZhgSOsaMsecgZCRknMW82c5Rkx6DFHjWXD4gP5QUKaMgMrn4eXtzmBjCLBORjtNkAs+vIvzZmwuK6tswbkVVMvvfNmFcHM9RVewAA0KVLF+RyOcyfPz/w+vz589GjRw/p3/To0cPo8wDQ2NiIxsZG+oAtkXQT12UzWA/NxSCxGbDFLj6RCdTPwaMmrCfZKtkRoriIyVgeP7ScNy0R0iRWMfhdOuORt5DS3zUH815inDdjTb2gnZJ8RUFoyqlohahNkugTWBxiIU6ZeVOaCTh4ZAHaGAmcwJiMZFlorKKOuCo1HcBaKiTJeSMLGRd/GlXjJ0gp6YVfS9/NtClJyp3jZN4MNjjyfNfgdznwoiaYt4aGBgwbNgwvvfSS91qhUMBLL72EESNGSP9mxIgRgc8DwLhx42I/XwtI3qWaM2+JzAJ112zwsIxjcPy2jfOwiLtvvcVJYzyJC695onky80Z0cBjZydKDl8p02TBv0hCMQU/SRLFfg7kuzaNMAse0wX2SfIXNA5xLfJrKBiVKjhhUvifJsgTCpkxskEnYNOleMynqSCzEYVrTjEXME/sIq+0krWum1cYOZqgJ5g0ALrjgAowePRo777wzhg8fjptuugmrV6/GmDFjAAAnnngievXqhbFjxwIAzj33XOy99964/vrrcfDBB+OBBx7Ae++9hzvuuKOah5EIPabL4CZOylVjY954Fjnz8FKC81YQqM8RxmTyAC81Syfu4rXOmZE+Fx/LGRvyypuHcyJjMprreHaKm3nTISd1rmtdJpirgIbrntWaIyM7Mqe0eQOgJYgb/f4SSgVdQpheR/FskMk9m3SvmRR1JDpdBpttno2bOpRrNNfS6zr4GQde1Izzduyxx2LhwoW47LLLMG/ePAwZMgTPPfecV5QwY8YMZH0LxG677Yb77rsPv/vd7/Cb3/wGW265JZ544glsv/321ToEJbRKz4lOl1HuXALTYcQEMjkU/t13mMXzL1gmTFdy31alGc+hkh+b+S4+mXU1UcanPXQBlYJ8FkBBk32JZxZM5CuSrkeTY9NjAvUfTEnXEFC81rJIdt64JWe4kuip92w5tBh9z0ZYOW5MddkMNuaF5j2rZpRNClYSw+8GsixkOxrnjCNsapJaoDPXznlLBzXjvAHA2WefjbPPPlv63quvvhp57eijj8bRRx+d8qj4oCP6SA13mux2yrum6HsmYqY6LJfWLj5p9x3QwjMYU2Lf1iowb0Q2iLOXYFM+3ukqvWQi0pwYEja6rqPv2Wwm6CFzNdNR+pwuE8znvEXfM5Kv0CpWojJvBuyU73zEX0eCzLxxifRyp6dQZVk4pUKMinqYUoEczFETOW/fFegII9ILDWwEP3lK6pOS8U0YRZkt/4JlNCaiMGYSg2dTHEKV00iWitBnFYCysywN5eYMJGc0JHAqybzpSEUYMW8azpv+mGgbHC1pBp28wMSiJ16W0yQvDFDcswZ5WOSCLo3epmQ7JsVKGsLKurbYjo0pjO9gDue8VRCJC3iplyhxwbRjKKLvmeyatWQwDBpBy2z5FyyzMcWHhPV2zfLxAGa7Xa68wKQcExNWofi5JObNfExcSfRUNiiJUbaZayXzRhXWtkqZiL5nZkfj3FcwiV7JvFmwQYl2iDlmVnlhaTJvVVsf1XPkChbSgXPeKgid8KKRNANxt6PDUFSSnfIvOlw7QlkVnJmdBFbJooF3kuwAPWFdf66B5M4YRtdRTIWw344eW5qQO2cxHqpwqI4ALaDHdOmFTU0cAdqx6bBBXCFqU+aNeu/rMMEmVavJIuZKMwpG2YThVq/7gGn+XPQ9szniEZ53MIdz3ioIdhHSpDJ/I3X06HtWVVDS9i/Bz+jYAeRzZNPaKFEUVcsOmu3Qds1cWnhc+TzFzyXl8xk4OQkJ2WbnLPjdATvM1zUXq8Rpy6TamHzOdNYQJofCpKVZNoOIAK3fvgmLRxVD12lrZeJwk0XVNSRHAPUcFQoCpUs2aX3U2wSU7NDYcgdzOOetgtBJ7jUR2EzW6DGwk1C5ZpT3kMC8mTpvyQKrJsxC9D0zZoGHDUoWDmViTJrnuiRfkQQhhJfzxiaFkMhQGMx1gh2TLhRJ17UJWyazUxIy9n8u0ZZOpTm1AtZGrT8hd5Iqg+E9vIliv377RjmYxOtRz47SjILBM+n4UPyp3Ewoji3Q9k2a72p+zyYxb7qbSQczOOetgkgWtNS/iZMWFZPdDhcTmJzY3fwZYsECAJ9mmAnTwbOz5JprukyMuo+sji2Vo2wSNufqb1maa3oIjmmuRfz9CuhvTJIEaANjolbAGjx0kxm84k+juaY6SvnkuTZLLWj+fnI/4mY7TA530lybOJNSTTWD/q/+96U9m23mmnjPOpjDOW8VRDnhVMa8FX9SwwJGDEVpPExN1xNVtonJr4DZwymZDTTfWSaynMS2RmYh6uDfBOzkDBZw35gTmTdyOyJzx1R+PeqzQTrhJbPrWr5M6oa8Ag/LxFZLVAFai81NQv9PI5ZTFlr0OQFCcf6T1kbA9N5PcHJsmODE61ppRrG51Y9MJOWoloSMdWzpbtyoc2QqX+JgBue8VRCJzJtBwUJSkqgRQ1Ha7VIXOZ1kfCOmI8Z5s0jsl7OcFnaS5sikoTiZ5eLffScW0FCZN5M5Srweiz/1Ch+C3+2HTUFPzOWozbwFwlSyTYCVkHH8sVFlWby5Jp77YBK9np24ueYq6mErWOFi3ozyC+MdJRNbgf7IxLU/kXk1uK4dzOGctwpBlSRqFKb07NDCnVp9Mk0YChljYiCBkk9IfLceU1JVXgUlHhLbI5nIBejmvRiETalhc51cTqpwrBXzRgx1K5m3ZvOqMakcZTsh4/hjM0sriL5n1LNXY651bJUZPHrOG9e9r9PWqpLOZNL9EbClYjk1r0ejVnQJzKvOde1gDue8VQiqJFETxiwpSdRI4iOJzrcoWEhi3oyKDCR2ADs2MLHikJrPZ7JrLomiJjEvxN13wHlTLJjaOW8Gu28qy5nc/qf4U+96bP4bYkFP0niAsqOhGpPKUWYTfDVaQxKYN4ucJ6p8RRLL5X/d7LxJ7Njcs+RcTiYmMGE8AVuKez/AvMnOm0XuJPW6djCHc94qBGWSqNGuufgzkXkzCOVRGTwuO94uXqau6rOlxZjlEx5OFtpKZHYywTHla5ET/b7Y8fivR/J502A6jOwkMG9a7JS66Ta1wb3flmpMSubNaq55WEX65oZHviIpB69oS7+gKzG32MAxYY9MkHNCNZ037fzC5OvapGo5UexXpy2GgzGc81YhKJOWjRgzdd6Tjh2dRHMT6RLVAq6y5e3ilcybRp5JYpiy9H2VDJ2oH3LUFjmZTEZ7TP58riRdLTLLyaXWb5E7KWWDLFiFuIelLrOgEp/mynethpCxTkhQx5baMSn+NNlMJjFvZp1saGkuSfesSU5o0nUdsKVYH5WMssXGPVHs1/luqcA5bxVCIGxKZhbUC6bObkcnIZfarstk961MyDVYDLwxJVQukkMnRg+54N9I7RDzwkzGpP8gILKcOYOHE1NuUCJbypT47n9dRxQVSHCUDfJCtQRoDQoNqGyQzlwD6vlWh031+vbq5habhZZl4zHYJCfcsyYV66rrUddZUjHKRhv3RAUF/c22gzmc81Yh+B9e8t138+e0FoMEOwYOTmISvcHDUoed8n8u1k6Cg+Mfp45j6rGBCZWLVAFam5AwlzK+LMfEP07lw1KVP2PDdFGrjblC1BoOd0FAKV+hHaaiOiYWFYdJOUYmxUFUmZiknFAT+QrlpqT5ZWX4VblJNrlnNZg3rfQUtS4ndTx++6r1UTe/kGvj7pi3dOCctwohoKsluWfM8rB0dKx4mDczdkrWu4+fedPZyCUfm94uXm1Hf/ddWsDI4a6SgxOTF6hrK8kp9ds3uo64CgQSHG6uBHEdW1wFNPqMif51lKTNaFIclNjJxMBxj3e6eDYTdZr3rCqX00pOhVpkoqHLabIWxc11neb6mJTC4X9d69i0ijqc95YGnPNWIfgXcHmOUfBzSdCRi9Bi3phyjMqOQPS9rEHoJInB87+u2lkWFAu4mSCyeo6ozJtZr9Vk5k13J6/afZeTlpVDSmQ5TZLok0Wjzdus0ZPo40WD/bZ0nbd4sV8TdlItzUEV6TW6HnUrIDWT6GOvR817Vrs4hCrLYnHvyzY36dz7yTdtkjMJlO81rTnSKepQm3GwgHPeKgT17puHeSvv4nUYkwQ7VondycwbffettyNUJYh7u3iqCKmBxEeSkLEuqwAkhxb9r6tD1LpsEI3BtWqRROzbqeu8Ka+jhPGYjMnfdF0GO4kPGouTaMfiulY6b5ryFUrmzeDeJ8uyMM2RTgsxHVtc935SGLc4TmjZKdpqvraJUSAHczjnrUJQlcKblfkXfybtCPXatmjYISb2mgh1qsJU5TlKHk9Bkfdis9vlmiM5GwCW8RRtaYapVPkzunOtyXSYSTOkL6wMaBQaMImilkPdyXNNlWXhvq6p4/HbV89RcihPlzHTFaDVakWW4JgayfskzbURE6x376vnqPhTxbyZSYUkOW+OeksDznmrEHR3TUayEwktSfTatiQxeDZhKvnlpHts+rlBegm5/r8J2DFhFphYpaTEbhMmUMV0mM+1/H2buabm83HlYCbNtf+eUZ1/laSCtjSDgsGzyXuSSjNwt9ki5in67avmKGkj6R+TygnUvx4TzRRtJXR8MYuUqOca0Bd7ps+RSk+z9Dna+XfOW7pwzluFoOrbaVLmz8YGNX9Enj8T/C698cjf183pUe4sNfOw/GOWVnjZqKMn5XMRJRVYmTfdUJ5uHhY1x4hL583CeSMzb4oNl25+qa4oqplIcwLzZpDPRW6x57GKqs2EajzxG1JA/7pWzrVBKC9xnTXJUdbICwMYmDfDe18liKwjy1KCY94qD+e8VQi8zBsXGxSfkG3DvMU5At6YNJXoY+fI08NS7eIVzJtNmCqhkpIaOinNmxD6eS+xLKemZlh5MyF/X7cYQyXNYDPX5OrnBDYgk8l4uWe6zJtaKoQmzWCi9ZUsiqrfhSBJ7NckRK1i3nTDlNrMG/GcmTBvya3IDOZaQ5alOCa9ey322DTzlNUSOMWfukVPgJzFMynocjCHc94qhKRQjv91qhSCTYucRGkGg1CeMrFbk3lTsZNGvSQT5ojat9WzQw0J+ityddlJ+RRpd9jQdbiVdlT6hQZzxLYp0cxVozIdOUMmmJrUrxagDX5f4pg8O+mxnP7XVURXE1dlr271K5F5M1IHSGLeDKrxVXOtXUCjdHDNe/YmpfC43qbpwDlvFYLuIkdlKKxYJeni1LyzNAnBxC28mnl4ysWpdGxUBs9qjuIraY3EfmVznTNfwOOYN9M5ipki7ST6APMm3QRktez4x0SWU9F+gFMZCjMmmFz4oNmlxYR1T64SFNpCxqpNqe4cqWQwqOyUiXxFsvNmk/Mm7/+pK2ScxOD5x6k/RyqxX9r1aBLGdzCHc94qBNXixMVQGAksJiy8Nsr4akkFhR0Fg6fNBinyC23mOqlPolFP0gQZDP/3xdrxzr38fd3zr828KcdTPKmZTJwjAC07RVsJmxKTZHzFw0lbOFaZG2Q21+SHbiH5YWnEvCVUHAaKOhSmVCyn9j2ry+ARq1ZtmDe+Nmvy900lZ6it8ZRiv5oFXSrW3USWxcEcznmrELwbRhEWUO12hBDl9lhJLZuoScsG/RZVC6/p7jtujrR3hAlVYoBZQnaSk6N7XIB+0rJSzFSXedN0BNSMiWo8zd+rSH6mspPlXTztoeu3rzvXynuWyATbOG+JbLkB80ZmghUsp658hW4yvvq6Lv6kznXxu+L10GxCy6p7VldORVnZq5nqoEpPobLuJhI4DuZwzluFoGpHZLqLB2LyXjRznoBkhsqEVVI5AvptWxTMm+6OUDXXJsfmORSS8XjnTGkmmeX0O2/aYqby93VZRf1cJT3mTZX8rCX4mVeLT+vMtb7Eh95cK9lysiiq2XjibFmxQWxMcPJ1pBsSphcs8Mw14NNDS2hFZhQ2VTldSge3eTxMYVNq8Vx5rpNlWXTWWQdzOOetQtDNV1DtUIM6Rgl2DEJ5VLkAFQ1v2jCZKqmQ1I4GMBRFTejbasK8JUqF+F7SbSOkEkUlM2+aYXOV4KeNfEUio6zDciqZLj2GSlukV1cqRJkTqscExo3JSsg4wTHRsaUrg6KfjE+TrlEL0Jozb0nXo1b7QM3cSW0h41gmWO+6VkmFmMoEKVlX57ylAue8VQjKB4EmY+Z/P0mJXme3k8QG+m9IXb0fVQk7X8smvR1qbNN1k4dcwhzpMopAckgwk8nwsUGGLA61qCNJcqJoR19SQaehvM5cq8akmxum6kKh23hb1fbNinlLct4MNlxJIUFAnwlWseW6joCKvddlg+IdHL3rOpCekjTXGpsS1b1mLDmjaGtFraLWZkuZ1msHOzjnrULQDcHoslMAA/OmGcqjNjnPabIvymbppgu4yo7BwpvcVFqDeWOqgNTNw9JllZRhfGL41SyJXu286TFvSByTroZheTMhf1+bMdOcayrLZeK8ldnJ+NQLrTGprkdj5o0YEtQMUVLTU4w2gNpOTrIdXUZZXytSMde6eYoMIWoHczjnrULQf+jq2QGSmTezBVzBvGk+VLgeTtQdoZdET7RTtJXAvOX0zhmgMUeG7As1aVlXgFY3aTnejo3YcwLzJqCUr1DlPel2tNBl3sibG22Wk2cD4LclOzS/fIV6M6lb3VmZ61pb3oWYnmLTj1ZdjKG3cVcxymT9Qua51llnHczhnLcKgasHYDBpOckOjXnzP0Ar9VBpSsgvC9hRLryKB4rBjlBHXFdHdkBf+Z2LoUgek24ejrJgQckoonk8agYnMUxlImba/LaKedPvJSl/31QGQ3XudaUZOMJUqtxJ0yIj5cat0sybaq6J6Skmyfj65z/Zjop5Nb2u0xb7NXkWOZjDOW8Vgv7ilGzH/9DNJFWcGbBKSaKoxTHphpe4Qnny97kYPNMQZZwtG5aTmtyrrxmWPB4uNkjNumomUasEaP3yFcTE7pJ5ffmK5CR6ck9KJpbTRMhYmaKg3daKl8WpFQFaJfNmooOpOm+6KTMqiQ9DVjHtuXbOW7pwzluFoJ+QS0ta1U0Q9tuSsYF+h46aY2YaOiGLqzLllzUxOm+6zJuuALF610xk3jQLaJJyAoPj0Xt4x43JSL4ir7hHNBkK5b2my05yMW+K+8xIyFiTxVO3teK517jYIC4BWlV6Ssm+EPQcM657n20NMYyUcORgOpjDOW8VguqGKe/kFHY0d8xGoRNZMr6B86ZqKm0e8pC/b8riUEM5BRUbZJDToc2+qNggbcc0eTzKh25ObzxJie+B8Zj0SUyY6/BnpWNS3Wu6rGIh/v6wskNkzFQ6X0ZCxtpzpNgEMOU8coXguARoVekpgfWRGDY3FzImtrXKq6qxTddr57xVA855qxB0d826/T85k5aVkhpERsA8hyLOEQh+Tm2Hj3njauDNtftWH5viOtItoNBkp2KGYxyC8f+NzI6OLVVYqNKMmdKOJmOmKsTgFDLWvR7L7EscWx78PtV4uApo+CqNY9JTjDa3eoyZdpFRzL2mvV6L4OfD4CtWcs5bmnDOW4WgYqe0xSwZbxjdHaFaHb35u9kqxeTvs+/iDdggcoschbOkz77wsIql3bdKD0tbuoSY9+IvQlHKV1CZLl3GjOmcqdgpXSFjXQFaHiFj02OTv68rX6Erg6IdolRUGmuHzBUOl/87420pqp+9ji+JZsoOZcxk64vr6qW5cBXiuGrTdOCctwrBu2HILFflnDdvTEo6v3hsVO2xvNIRKP7UdXBU+TO6duJslfPC1PIV3phi5shUzJTOUDR/nugEcreiAuLDVKWh6udO0u41rtZPqipqXSFjXQFaPSHjEmPKc95UbLmSedPtQEO9P5g2Sf550w53K+59XakQ6jNELfbLM9ceIaGhp+lgDue8VQhK5o3JeeMUj9QNneWZHgRer1VF5aLujjD2QaDbI9XvUEhs+Z1M3fOm6oxA3e3q75qbHW6ig6MdEjJgp2RhqoAtYqcO/TC+ZiGOijFTVlGXvo+HdVXmqSk2Jf7voOap6haHqGUwmNggw3tfNR49W8kbd+3uOppsqbYdhTNJnyP97ioO5nDOW4WgzHkz3VkqdoQ6ux2lI8Cch6e/k5O/z7VrZttZ+sapzwYqepJqJy1Tj634UyU7oO2UqkKCRDYgYIvYqcM8jE+zo2aneNMBVExwoIqa2G9VmUSveV0ru6Iws0G616Pq/mAZk/Yc8ayzKtbVVCZGJYbtct7SgXPeKgQ+xkTFvPH0kgT8u2+FHU02UL+kPia8pLsj1OzUQLdTHqc+Gyh/X/f8aye/a7IBVMZMW5qByJb5v4OLnaxUcZA6lzP4OevxaOYFBip7iR0/VBsl/XOWPB5uNoiag+d/T18UVyGIzKRfqSuDomQ5Ndd9arqMgx2c81YhaItikvt/Bj8Xh0JBoLRWxCf3mu3A2JLxY65Ktt237nEp9MJSYd4MwovSMXExb5ohc+2kfsUOQOUE+sdKrTjUlVPhd96IzJtKFFVTyFhV2QvwpXHoX48qYWW9e1bNmAU/F2tHIcnj/w59Fi/Gji4bqBiTMcutFJ/WnGtioZqDHZzzViHo9u2k54ZoNidWtH8JjEn1kCsdmyqHQpsxUY2Hyk6Ww0uJdjTnWmtMyqo8vWPjEo5VMm+aYTN98eFEM8rwa8CW6tjyeg8V3blOWzjW1I4qrUBly59SQS3qUBbiGDK46mT8RDPa9yyVvfV/hz6LlxxRYMt3Jq5F5dzSRDPahWE6QsYO5nDOW4WgWpy0d3HKFinFn0YyGModoV7bFjX7QlvATXe6ZOatVOIfu9ONfmesLUXFobbshOJhacpOqfJetGU5FKETXfY2iXkz1/pKl+XUzQvTbh+nHVpOPi7VmALMm+r8a+v80Rg83fZxylC3UoC2+JOqYQbo55fqMm9UmShttlS1FhmmFcRrBfoKuhz7xg7nvFUIygof411c8g2j2u0EZTAUOWYVqhTTnSPdhxw9pyP4+TAymYy+/pQivKjPUOgJteo+dFXXETX5WVe+oknhKPttabM4qpZd2hIfXIwZLfyqZPA0nbfyNZTw4PXkKzSZN6bcSXUVfaIZDQFa3eKQ5AIKQM9596enqCIcbOykdt6s/H0ultN/uC7vjR/OeasQdHeo5IelP3SiWXEWm0SvyZgpKw4N6XzlLl638TJXNRXj7js2p0eboSj+VAnQKuUrlA5F8HMqO1ThWNVxAfrOUkHxkPMeuoqnk640h5rl5un9q1tFrbJVmmsdVomaoqAt9qydp6jHltNlYoLfa2tLJ7/QVBBbKaytK12j7CFNm2sTKSUHczjnrULQZYPIYaqc7gKuZt5MJRVUx8a2i9dlApWCuIlmjEJ5VIdCf9eczFCZ776TGQqqpIK+fEUyowj4nK4EO0II9bF5zFusmcD30CVwgp+Ps0MuDsjqCRmrZDmMxqTb8YUoZKw/R82fVznumgw39d4PVPZS50hzo8RmRzOFh0NKycEcznmrEJQPOU2hRiPmLXEB9zFvMeuTsbiu6gGu+XBSzZG29phSBkGv/2eiQ8EUFtJmFlRhIVN2SsW8EcV+tdkghcPtt5Vsx/d55UaJJhViWhzCJsuR4FDoOO8qBs//HdoFC2yOacx4DIWVYze32vdH8Sf13g+mp1DniOc60s7BZErh8X+nAx+c81Yh6MoXkFs/+V5PsqWjaK+9qOQre2yVe6AkPwgCthIelv6FS71gJg5JWUShm9OjzbwRQ+a68hU60gxcTEdWe67VTBdAT343vT8S5St0QnkadvQZM9X1aMrg0Zg3LvmKJqZ7P7hJpt2zXCFqLhFrdXpK9LMOfHDOW4WQV1SJagssarJcKlsmu28l+6Jqa2XY+on8IGCz0/x54u47oGhPZQOVzclLn9N8EBDPma4MhmpMXGyQjvNmyryppXR4NhMc8hUmc8QRNi29nXabLdP0BNVc6xZ06V2P8deRXiuy4Hcqx8TFcqocXM282TgHN1DQ5apN2eGctwqBi3lTPSx1dzsmC7gu+xIvF2GWP0XOxWDLDeHJDfIvXMpkY03mLX7hNdzFKyU+9DYTqgeBakxa0gwaxxbUL+Rh3qjiqmybCa050nDeFCyX/z1q9bN52JSWf6ubg6myZebgqseTPCZTkWauuU6XeQPK64Jj3vjhnLcKQXe3o1vdF3fj6e52tBYnQ8Ys/tiKP3VZRWp1H1tOB1PFmRbzxpSHxd3kXFs0WOdhqTFHyQ9LtR0dAVp9ljOZedNlFSq1KdG11aRIcwDKbJBad7D4U63zp3kdKa5H5UZSc5MM6LGTcefeP9akSmqdNlva2nN5veuRGn7nSk/x23I5b/xwzluFoLuzpArQ6trisqNjy5R5q1hOhyarUIk8LL5ds15vW648LGX1s7Z8hc6DQM1Q+B+k1E2AsqOBITOtDuOqHt5qLTyjggWNuVY773oyKNRNqXZoWVG16r++dNjJBN/Nd2zxn9FbZ8264lD7I7Ndj4pnmv87HPPGD+e8VQjlAgH5+7o3nkpywv9e0mKgUo/3v8dVuUi2o1tNpWLwPEYxWb7CaI40HpZJtrR3zSqnKxP9Thm42aAkbT49+QodJjj4WRlK85PJqENn+gwFj5SOuoBCde6LPxP7v2poM+qFX4s/k+ZICOHlvCkZM+r1aNy3U/6+/zrVSStJZN68Y4v33vJahTjq8eiMyXSO4lNveOa6+J7ete1gDue8VQgqHSNdLTSdh5yOLa7qPp0xmebPxNox7rcZN9d64pE6c6SzS/W/F2fKnFmImyO9uVY5ysa6gxVgg3T6Uuokmhv3yCX3kdWca12xX51jq+Bc+z9vMx6dMXndXnQ3bhrMW5ItVRtCv63EOdJwlHX7rSo7I2jOkapiXbc/tqpdW/E957ylBee8VQiqZsBc/e0AvZ28ip3yf4c206VizJSsYvB7Y+1oLyry9wNtW3SYt4Q5MprrbIIsi27yu+5cEx1c496WVDZIw6HIajAUenZ45tq0YEFlJ18QiUywjuq/zrEZzVHCOdPp0sI9R9TcOf91qsPgJrKcGnOk02bLfI5U/ZFpWpE695n/fce8VQfOeasQVDdenSY7Vcp7obJBJgwelXnzOhoo21qp2q1UmHljmiMtO9q7Zl7GTLWL50haZmeDiI6JscSHolOHLquk6hxStJVkR609pnNsRuykxuam+HlFf2TydW3GBmnNkcb1mFRJqWcn+FmpHdM5UjLBiWaUDqUuE1guxlAXdTjnjR/OeasQyjee/P3S9a+b90Jl3rR23xrsi7/xcuxuV5PFyavsGOcYyd/XbZhsNEdJzJvGw9J0962UwdAOwSiYN83xJDJvRmxQ/JLExiqZSnyoeuRqVkCqevYWx5SQP6Wh+l/JOTJj3vS6mcTnBUa/M2lMXOykVn5h4hylwLwp+iPr9myuxFzr5oU6mMM5bxVC+cYjMm8ai4FJHpbOjlCnKqtoKznPRPvY4pgObTs8zJsWi6MxRzoSD7pskKpAQJt5U4TxTVlO6rEZMXhcdsiMmR5DoWTwAnlYSXbU/TaN5kiDndLZlBQ/r7r3Y80Ex0Rlg0xYRZ17P2mONO59LxVEYzxUlrucO5loRnuuVULGqrxZ/3sqWR4HczjnrUJQUd4e86Z8ECDRDqDHdGkxJgatdoq2YuxoL07Fn0rmTclOKuba93IlmDcudgrwFwjEMGa6ThdTI3CT3EmdHKNEVsmADaLmcxVtJW+UtBmKfPKx+e0nsSZG+YUac6TD4OlsSoq2VHaSH95NiiR63YpMvaplg+tIZ53VYd4SnEDte1bFBGvOtYpRDsj7aLT+0iMSEofkYAHnvFUIXLsdrbyXnPomNmEodJ03LuZNubNU2SmJWWq0bSGzk0whGN2Kw/ID3H48/u9RiwbrPixpFWcmDB69alVvrlUFNLp5WHlFbpDffiLzppFE7937GnPEde8nFeLoskEFRW4YV/9PQK9q3aiKWmeOdJg3zf7I6vUx1kxgTLHajP5+xMRj0w3lOpjDOW8VQllgkbbb0cl7KSeJaoyHuPv2j5XOvCXPkWlFrtYcaZT568yRVvKzTp6iqp+gwhEojZWaIK6bq6KTIK6TtKxTiOONKeHC1nmgcIk0m+pzxWo8BrTH1JphSdeRN9calb2JdpjyZnXDZso2W8Y9UmnXow7LyT5H2pW9qjlSzbUB80ZNK/FC1IlDcrBATThvS5YswQknnIAOHTqgU6dOOOWUU7Bq1arEv9lnn32QyWQC/84444wKjdgcqt2u/m5HnfeiJR5pULmWyCr5FhwV80ZNxi+NlWoH8M2RxkOOPEe1yLzpOm+FZPkKrf6GOmyQCH5v4pgSDs1jFJOcSY2HbkCAlo0Nig91e0LGGpsJrfZYlbDD6Ch7VZkKNkifCaaNSa+tFQ8TrGMnWNlLY8vL65GaCaaGTXULVhzMUVftAQDACSecgLlz52LcuHHYuHEjxowZg9NPPx333Xdf4t+ddtppuPLKK73f27Rpk/ZQraHa7WrvdhQMHlC+mZKTn4s/Ex+6Oom9fuYtxpR2j1RNdlI3QVxrjohyASZzpMeWJodOSsOl9ttUbiZ8Yy2I+CpprbZWWnmBJq3IdNIBaGHcYDoADxukmqMmITSZDuqx8bZ9o577wJiIzBtX5xguEfNyFS1NTiPQH5nJeVPZAZLZQJ2CBV05HQdzVN15++yzz/Dcc89hwoQJ2HnnnQEAN998Mw466CD86U9/Qs+ePWP/tk2bNujRo0elhkqCbjsi/2dt7PhtaTFvWnb0dpaxArS6bJCiYXaZLdNtKM5zbHQ7apZTh8XxO8rkBt6qzUTOfz0WkMvmpJ/jCy8FP5tsJ/YjPoc7/jMmD10gKYlejy3V3Uw0FTSdNyLTZTbXGswLkeX0v08N45usjzrsZPIc6fTaNRiP5maCOkdq8enoZ2XQOTZdOR0Hc1Q9bDp+/Hh06tTJc9wAYOTIkchms3jnnXcS//bee+9Fly5dsP322+OSSy7BmjVrEj+/fv16rFixIvCvUih4DxW186ZTnk1nlaC2o8F0mTxQtBsvK+ZIYcaMedNYMLXmSOdhmThHxZ+67YjiHpipMG8azhL94aSxmdDI6dFi3gyrqPnCVExMF9FZMpvrSoVN9UJ5ugVddAZXw06m9NmE8ejkKZo6b6oiI82NW9yx6Rd06ctWOeaNH1Vn3ubNm4du3boFXqurq0Pnzp0xb9682L/78Y9/jH79+qFnz5746KOP8Otf/xpffPEFHnvssdi/GTt2LH7/+9+zjd0E6mbA0c/a2AH02JcmLeYtqxyPSU6HrnhkbN6Lph0zdpKL5VTPtc4uXicHD9Bg3pgc5aKtAgA586bnKOszFIl2vLyn2I+YMYEarAKgniPdwged8LvWHCXaMZhrMoNnEFok5nKG87CykH+nWRGFejzJjqk+W0513EvXUCZDZ4J1Q8J5FRMsgt8rg64EkoM5UnPeLr74YlxzzTWJn/nss8+s7Z9++une/wcPHozNNtsM++23H6ZOnYqBAwdK/+aSSy7BBRdc4P2+YsUK9OnTx3oMJlDlYpR2O/mCSG5Jo7OoaDBmerkhwe+UwWSxVLdtST42XTta2mMmnRGIDyeV5ETxPSjtBMKmigWc2vopyATH29FzcIPfKYNZ7lz8gLTsaDwsdaQZdJ230ttUxkxvjqBvR2M8bBs3YhV1wHkrCNTL9xJ6bKBGEr137yfOEZrt8LCTSXZUUip+O7p5gZXIU9WVd3IwR2rO24UXXoiTTjop8TObb745evTogQULFgReb2pqwpIlS4zy2XbZZRcAwJQpU2Kdt8bGRjQ2Nmrb5ITJbkdLYJPKBmmNR828mVR36TJmKseEasf/nlZOj46dhG28CfOmE4JJsqXNvKnC+JryFXoivcxskE71K9O5938+DP0uFGrmTafaWO/Ysvp2mApxtDZuTFXUAB8bSN+U8PTa1Zkjo2tIeT2qz7+pzl8cdB1KB3Ok5rx17doVXbt2VX5uxIgRWLZsGSZOnIhhw4YBAF5++WUUCgXPIdPBBx98AADYbLPNrMabNrSYLo38KaMSdg07OnlYWnZ0dnGK+1fFdJUZxaKUQ1yBBBtjZtA9IOnY9Oao+FM7iT7GFFcFZEm+Qgg9R0Dn2JIcytXrmxLH4/+OSthZsz4PoDjPcdeZjn5hoSCwdkNeOSadxG69Yyv+rMQcLVm9HgBQHydgBz/LlTDXG5qUVdTZwGZCbksIgaVrNqrHpLEJ/GDmMgDAJm0aEuwkjwcAvlpQlLxq2xj/qNWZoznL1gEAGusSev9q2FmxbiNWrC3OUWM9rY/wktUbAAD1xOpnBztUvWBhm222wQEHHIDTTjsN7777Lt58802cffbZOO6447xK09mzZ2PQoEF49913AQBTp07FVVddhYkTJ2L69On4z3/+gxNPPBF77bUXdthhh2oeTixMdjs6jBkXs0DOVTIqqedh3pRjYpJC0OoeoBHK05qjnAbz5psfVWUvtboP0BPY1AnBqfpSrl7fhCc/nAMAGNK3k8Z44o/t/ndnFO30odl5YELRzo4adpKc23GfzceiVRvQvrEOA7u1U48pxtbsZWvx2pcLAaiOLZkNasoX8NB7szTsqNmgu9/6BgCw28BN4+3kdM7ZTABA385tsEmb+sTxJNn631eLMG3RarSuz2GoznUUc2wTv1mCSTOWoaEui8OG9Eqwk3xdr9uYx7/fLs7R4UPjVRN05ujON6YBAEZtFx+N0un4cf87M7C+qYAtu7XDgE3bJthKnqPJs5djwvSlyGaAEQnnX3cz6WCOqjtvQLFqdNCgQdhvv/1w0EEHYY899sAdd9zhvb9x40Z88cUXXjVpQ0MDXnzxRey///4YNGgQLrzwQhx55JF46qmnqnUISug85Ew6GnDl9GjlPXCxU7q5ajrOGznHTH+OEjbxWsfGlYOXRoJ4YrKxRm6QTjhH1QP0vndmYNmajRjQpS0O3D6eOVexAe9NX4J3pi1BfS6DU/ccEG9HwVCsWLcR94wvPnTP2FueguG3ky/IhYyFELjllSkAgBN364d2CeyL6tjueG0qmgoCuw3cNNGhVNl5+qO5mLFkDTq3bcAx34vP91XN0eTZy/H6lwuRzQA/20s9R3F21jflccfrUwEAP99noJLlTLJ1+2tFO8cN74NOCYyZqrftP/5XdJR+NKQXuraPT7NRHduj78/CktUb0KtTaxyQ4HSp7rNpi1bj+U+LxXun77V5vB3FfbahqYA73ywe22l7ba7Xazlmjm5rnutDduyJPp3j9VV11yMHc1S92hQAOnfunCjI279//8Di2KdPH7z22muVGBobuCu8qIKvesxb83dqtG1hZd40KiB1mLfKzJEG86Y1R1COh1OawUTMNO7Qpi9ajY9mLQeQHF5KYgTWbczjjv99DQD4+d4DNZlA+bH9tdlROmpYb2zWsXW8HYVw6L/f/gYr1zdhy27t8INtuivHU7RVDg+X8L+vFuGjWcvRuj6Hk3ePdyb9tmTHtnDlejwwochOnb3vFtZ2CoWyM3nKHgPQpiF++VexQbe9Wn549900/uGtYoMenTgb81esR48OrXDETvEsV9FWUQtPdt4+mrUMb01djLpsBqfuGe/glOwA8vM/Y/EaPP9J0VE6JWEDACTPUaEgPCfwlD0GoC5hB6hiuP/+v68hBLDfoG7Ysnv7BDvJTOCTHxTnunuHRhw2JJ4JDIxJYuvrhavwzMdzARQd7iS4sGl6qAnm7bsAdq0nIvuiZ0ed/MyVtOrvHkANm5Z8zYrOtYYWmlbBAvmc6S2WTQa9RGWMwMZ8Aec+MAlrNuSx6+adE0MnSWzQwxNnYeHK9ejZsRUOH5r88E5iOibPXo5XvygyQUlsWcCOZFOybmPeC1GdsfdALXaiOKboHJWcyeOH98Wm7ZILpZLm6B9vfI31TQUM7dspcZ6B5Dl64dP5+GrBKrRvVYefjuinaSd6XF8vXIVnJus9vJPYoKZ8wWPLTt9rczTWxZSQerbij61k59AhPdGrU7zjDiTP0V1vTUNBAHtt1RVbJThKKjsvfjYf0xatRodWdYkMJ5DcvH3hyvV4ZGIxzJ3EuhXtIHY8hYLA35s3SWN2H6Ce64Rj+9trZWdyUI8OijE55y0tOOetQtB6gHOHzsgsTvCzqY5HRwZDu2Eyb/sfPaZLo1k6kXnTYgK12wgFPy8fU/zu+8ZxX+LDWcvRsXU9bjx2iBVjtjFfwO3NDM7P9h6IhoRk7IAdyXhKjNKhO/ZEv4RcnqKdeIbiofdmYtGqYqjrUE12AoiyJhOmL8G705agIZdVPnT9tsJztGzNBvy7OYR79r5bxIYVI3ZCx+YP4Y4e0R8dWslzy8J2ZJsSk4d30lw/9dEczFiyBpu2bcDxw/sm2vGPKTxHXy9chWcnF9kyleMOlBmz8D2yfO1GPNTMcJ66RzLr5h+P7F4rOUon7JocLg/Ykdyy/xo/HRuaCtixTycMH9BZYac41zIh41e/XIAv569Cu8Y6/HgXjbmOmaO5y9fisUlFZ/LMfTXm2jlvqcE5bxWCSVm9HtNF7G/I1P6FKw8rIEBLZd6Yct60+hIanTPaXHNVGgN6RR1xBTTjpy72cl7+3xGDE0OUQPwu/skP5mD2srXo0q4RxyrYCSA+D2fKgpV4rjnUdaYirFi0A+l4NuYL+NtrxYfuz/bePLFiEQjOXZg1+evLRUfpyGG90aNjK/WYYubo7remY/WGPLbZrAO+P6ib7E+DdmLm6PWvFuHj2c0hXA3HpMyYBI8r+PBWz3VcRWahIHDrK8Vr6OQ9BqB1QzITBMRXZfrDiiq2DAjmKvrx4IQZWL0hj626t8OeW3ZR24m51ybNWIoJ05eiPpfBSbv1N7ATnOvV65vwr1Lu5V6bKx33wOY2tB6Vrusf79JX6bj7bYWP7R//m4aNeYFdBnTGsH7JzmSSHQc6aiLn7bsAM4ZKh8WJ/y4tx0SnAjIT/M7E8ejkl+l2D4gZUyaTQTZTZI24mLdEgc28xlxrlOebCYfKQ3lfzl+JVz4vVhvaVhqvWLcRz02ehycmzca6jep+q7KH3LI1G3DBQx9ACODYnfvgwMFqaR5ZVWa+IHDrq0UH59Q9B6BVnOqqwg4A3PrqVAgBjNquu9bDOy4P66kPS85kA47ZWe1M+q8v/y378azleO3LhchlM/i5BhME+JgO37GtWt+Eu96cDgA4a9/4ZP6AnZg5uqXZmfzxLn3RuW18fmLUTvD14MN7E6WduE3JC5/O0w7herYkbNCCFevw6MTZANQh3BJkbNDGfAF3N8/1qXuoHaWAHRF1cADg0B17oXsHteMex3I+9N5MLF+7Ef03bYP9EwoeSvALCvuFjD+YuQzvTFuCumwGY3bvr7QDyNeRpas3eNXcOo67347rsMAP57ylgBc/nY+XPp8feG3VuqK2kg7TcdurU9G1/SzpZz6bu6LZjpoNeuqjuZi6cJX0Mx/PXq4cT0m+4sNZy3DJYx9JPzN3+Tq1neb3lq7ZGGtnQ5PaeQOKD94N+QKufuYztInZrZuM6Z63p+O1LxdIPzNh+pLmzybMdfOC+doXCz39pDCmNGs96Yxn6oJVOOu+97F+Yx7rmwpYuHI9pixYFVj8OrWO3zmXrqEN+QIufrQ810tWb8CrXy7EhqbyE+IH23ZHj4SHS8nWP9+ajoFd26Fj63q88Ol8zF2+DgO6tMVlh2wb+7eyY5swbQm23aw9tt2sI17+fAG+XrgaHVvX4ye7aj68m+1MWbAKr325EIN7dSzKjHxQlBk5e98tNe0Ufy5buxGvf7kQQ/t2QtuGOi8Jf8zues6k3xn/z0dzsOuAzti8a7tACDcpmV9m67UvFqJzmwYM2qw97n37GyxfuxGbd02uwg0eW9HOR7OWYfzUxdi+Vwd8Nncl3p2uH8L125m1ZA1e+mw+dujdCXXZDO57x/Dh3Xxc6zcW8NSHc7BD747os0kbLx/wpN3UIdywrVe/WIA2DTn07NQad745HRvyBezcbxPs3F/NBPmP7f0ZSzGkTycM7NoOz06ehznL16FLuwZluDxsZ8r8VXh/xlJs37Mj5i1fh2eb8wFP20vNcPqPa/Gq9fjfVwuxU99N0FiX9ZzAU/fcPHHtCNsBgHGfzseIgZuiS7tGr5r3sCG9lCx5+Nhe/WIB2jbmsHWP9rj7relYsyGP7Xp2wF4azKTfjqrji4M5nPOWAibPWe5pF/mRySBxoerUrHH04mdyZ8KPOD2k4nvFnfWHM5fhw2axSdVnk75j1tK10uMJfLat+rjWbswr7bRrrEtsKt6pTT0WrFzvPbATx6RxbG9OWYw3sVhhRz3Xn89bic/nrSSPZ/HqDfjvR3Ol72/fqyO269kRP0pI7G/bWIf6XAYb88KrUPRji27t8KOhvXCoosQfADq1acCc5es8XbAS6rIZ/Pm4IYnCo350bD62/3w4B//5cA6yGXgJ0yft1l+ZE+QfDwB8NGs5Rt9Z1Hxs11iHfEFgr626YnDvjkZ2lqzegBPvfBfZDNC/S1t8vXA12jfqM0HZbAYdWtVhxbomXPrEZABA24YcVjeL8p6pyQT5x3T3W9Nx91vTUZ8ra/mpqnCDdopz/eoXC/HqFwu9MQHAUTv31mKC/OP5etFqnPLP9wAU53rtRrOHd4fWdchmipuJc+6fBABo31iHleub0Lo+hzGKKtzwsS1evQF/+O9n+MN/P0OvTq09oVidXLfwsd3/7kzc/+5MbNKm3mOZTxzRX8txL40HAN6dvgRH3PoWWtVnsWnbRq/gQZUPGB7PgpXr8dP/exe5bAZ9O7fB7GVrsWnbBhw1rLeWnfpcBm0aclizIe/N9eZd2mLa4tUA1AUPsmP72+tf42+vf128Hpv7yZ65jzr3sgQnFZIeMkImUPQdwYoVK9CxY0csX74cHTro3Wg6eOfrxXh32pLI69ts1gEjt42XHpiyYCWe/2S+cpfStX0jjhzWOzYnZ/Gq9Xjs/dlYtzGfaKd1Qw5H7tQbm8SEUdY35fHIxFlYsmpDop1sNoMDt++BzbvGi5A+N3kuvpovZwH9GD6gM3bZPL6ibtKMpXjjq0VKO303bZMosDlzyRo89dGcxFAuUFzEjhrWJzYnZ8W6jXh04iyPWY1DQ10Whw+ND6MUCgKPT5qNRavWo7Eui1b1OTTWZ9G+sR7b9OyAnh1baS+Y//tqYcRpr8tlsccWXbBdzw7adr6YtxLPfDwXy9cWVdmXr92IleubcMzOfbQfKACwaNV63Pv2DHw0axk+mr0cC1cWlfnbN9bh9Yv2jb3+wljflMdDE2bivW+W4qNZyzFt0WrvvYd+NkKZ0F2CEALPTp6HFz+djwnfLMHMJWu9936+z0D8+oBB2sf2/oylePrDufh49jJMnr0Ca5vvuYMG98CtJwzTtjNzyRo8OGEmPp69HB/NWuZ1CujTuTVevnAfZf5dCSvXbcR978zABzOX4aNZyzF7WfHYGnJZvHjB3tpMYL4g8Oj7s/D214vx8azlmLJwlVcNfvtPdsIBmkwgALz25UK8+Ol8fDR7OT6bswIbmuODp++1OX5z0Dbadj6buwIPvzcL732zBJ/MWeGF9Lbq3g7PnbtXYjqBHwtXrsc946djwvSlmDRzqZdC0FiXxVsXf19ZGVzCuo153PfODLw1dTHe+2YJlq0pM+/3nDIce26p7jAEFK/Hpz6ai5c/m48J05d65wwALvjBVvjFfnqMMlCMFjz5wWxMmLYUX8wvbyb33bor7hozXNvON4tXe9fjx7OXe8c2sGtbvHD+3tqbiTe+WoTP563A0L6baIXZTZDW87ulwDlv3+GT7+BQDcxfsQ6fzFmOvp3bYouErgMqLF+7EZ/MXo7G+qxW8nQc5i1fhwnTl2D+inX4ya79tJmXMPIFgakLV2HaotXYbeCmaK8ZDgxDCIHZy9bis7krsW3PDkrpiyQsXrUeH89ejm7tW2HbnvZr3Or1TfhkzgpszBew+xZ6rJsMG5oK+HL+SsxZthb7bN1NWWGcNJ5JM5bh07nLMXKb7okbxyRszBcwefZyTJqxDNv27IBdEzaOSSg0n/sJ05eibWMuceOowpxlazFh+hIsXrUBJ+zaVynrEYdlazbg/RlLMWXBKhw+pBe6abKuYQghMGvpWnw+byUG9+qoVYBTCXzXn9/OefsOn3wHBwcHB4eWiO/689tJhTg4ODg4ODg4tCA4583BwcHBwcHBoQXBOW8ODg4ODg4ODi0IznlzcHBwcHBwcGhBcM6bg4ODg4ODg0MLgnPeHBwcHBwcHBxaEJzz5uDg4ODg4ODQguCcNwcHBwcHBweHFgTnvDk4ODg4ODg4tCA4583BwcHBwcHBoQXBOW8ODg4ODg4ODi0IznlzcHBwcHBwcGhBcM6bg4ODg4ODg0MLQl21B1BNCCEAACtWrKjySBwcHBwcHBx0UXpul57j3zV8p523lStXAgD69OlT5ZE4ODg4ODg4mGLlypXo2LFjtYdRcWTEd9VtBVAoFDBnzhy0b98emUyG1faKFSvQp08fzJw5Ex06dGC17RCEm+vKwc115eDmunJwc105cM21EAIrV65Ez549kc1+9zLAvtPMWzabRe/evVP9jg4dOrjFoEJwc105uLmuHNxcVw5urisHjrn+LjJuJXz33FUHBwcHBwcHhxYM57w5ODg4ODg4OLQgOOctJTQ2NuLyyy9HY2NjtYfyrYeb68rBzXXl4Oa6cnBzXTm4uebBd7pgwcHBwcHBwcGhpcExbw4ODg4ODg4OLQjOeXNwcHBwcHBwaEFwzpuDg4ODg4ODQwuCc94cHBwcHBwcHFoQnPPm4ODg4ODg4NCC4Jy3FHDLLbegf//+aNWqFXbZZRe8++671R5Si8fYsWPxve99D+3bt0e3bt1w+OGH44svvgh8Zt26dTjrrLOw6aabol27djjyyCMxf/78Ko3424P/9//+HzKZDM477zzvNTfXfJg9ezZ+8pOfYNNNN0Xr1q0xePBgvPfee977Qghcdtll2GyzzdC6dWuMHDkSX331VRVH3DKRz+dx6aWXYsCAAWjdujUGDhyIq666KtDY3M21HV5//XUccsgh6NmzJzKZDJ544onA+zrzumTJEpxwwgno0KEDOnXqhFNOOQWrVq2q4FG0LDjnjRkPPvggLrjgAlx++eV4//33seOOO2LUqFFYsGBBtYfWovHaa6/hrLPOwttvv41x48Zh48aN2H///bF69WrvM+effz6eeuopPPzww3jttdcwZ84cHHHEEVUcdcvHhAkT8Le//Q077LBD4HU31zxYunQpdt99d9TX1+PZZ5/Fp59+iuuvvx6bbLKJ95lrr70Wf/nLX3D77bfjnXfeQdu2bTFq1CisW7euiiNvebjmmmtw22234a9//Ss+++wzXHPNNbj22mtx8803e59xc22H1atXY8cdd8Qtt9wifV9nXk844QR88sknGDduHJ5++mm8/vrrOP300yt1CC0PwoEVw4cPF2eddZb3ez6fFz179hRjx46t4qi+fViwYIEAIF577TUhhBDLli0T9fX14uGHH/Y+89lnnwkAYvz48dUaZovGypUrxZZbbinGjRsn9t57b3HuuecKIdxcc+LXv/612GOPPWLfLxQKokePHuK6667zXlu2bJlobGwU999/fyWG+K3BwQcfLE4++eTAa0cccYQ44YQThBBurrkAQDz++OPe7zrz+umnnwoAYsKECd5nnn32WZHJZMTs2bMrNvaWBMe8MWLDhg2YOHEiRo4c6b2WzWYxcuRIjB8/vooj+/Zh+fLlAIDOnTsDACZOnIiNGzcG5n7QoEHo27evm3tLnHXWWTj44IMDcwq4uebEf/7zH+y88844+uij0a1bNwwdOhR///vfvfenTZuGefPmBea6Y8eO2GWXXdxcG2K33XbDSy+9hC+//BIA8OGHH+KNN97AgQceCMDNdVrQmdfx48ejU6dO2Hnnnb3PjBw5EtlsFu+8807Fx9wSUFftAXybsGjRIuTzeXTv3j3wevfu3fH5559XaVTfPhQKBZx33nnYfffdsf322wMA5s2bh4aGBnTq1Cnw2e7du2PevHlVGGXLxgMPPID3338fEyZMiLzn5poPX3/9NW677TZccMEF+M1vfoMJEybgF7/4BRoaGjB69GhvPmVriptrM1x88cVYsWIFBg0ahFwuh3w+j6uvvhonnHACALi5Tgk68zpv3jx069Yt8H5dXR06d+7s5j4GznlzaHE466yzMHnyZLzxxhvVHsq3EjNnzsS5556LcePGoVWrVtUezrcahUIBO++8M/74xz8CAIYOHYrJkyfj9ttvx+jRo6s8um8XHnroIdx777247777sN122+GDDz7Aeeedh549e7q5dmhxcGFTRnTp0gW5XC5SdTd//nz06NGjSqP6duHss8/G008/jVdeeQW9e/f2Xu/Rowc2bNiAZcuWBT7v5t4cEydOxIIFC7DTTjuhrq4OdXV1eO211/CXv/wFdXV16N69u5trJmy22WbYdtttA69ts802mDFjBgB48+nWFDp+9atf4eKLL8Zxxx2HwYMH46c//SnOP/98jB07FoCb67SgM689evSIFPU1NTVhyZIlbu5j4Jw3RjQ0NGDYsGF46aWXvNcKhQJeeukljBgxoooja/kQQuDss8/G448/jpdffhkDBgwIvD9s2DDU19cH5v6LL77AjBkz3NwbYr/99sPHH3+MDz74wPu3884744QTTvD+7+aaB7vvvntE8ubLL79Ev379AAADBgxAjx49AnO9YsUKvPPOO26uDbFmzRpks8FHXi6XQ6FQAODmOi3ozOuIESOwbNkyTJw40fvMyy+/jEKhgF122aXiY24RqHbFxLcNDzzwgGhsbBR33323+PTTT8Xpp58uOnXqJObNm1ftobVo/PznPxcdO3YUr776qpg7d673b82aNd5nzjjjDNG3b1/x8ssvi/fee0+MGDFCjBgxooqj/vbAX20qhJtrLrz77ruirq5OXH311eKrr74S9957r2jTpo3497//7X3m//2//yc6deoknnzySfHRRx+Jww47TAwYMECsXbu2iiNveRg9erTo1auXePrpp8W0adPEY489Jrp06SIuuugi7zNuru2wcuVKMWnSJDFp0iQBQNxwww1i0qRJ4ptvvhFC6M3rAQccIIYOHSreeecd8cYbb4gtt9xSHH/88dU6pJqHc95SwM033yz69u0rGhoaxPDhw8Xbb79d7SG1eACQ/rvrrru8z6xdu1aceeaZYpNNNhFt2rQRP/rRj8TcuXOrN+hvEcLOm5trPjz11FNi++23F42NjWLQoEHijjvuCLxfKBTEpZdeKrp37y4aGxvFfvvtJ7744osqjbblYsWKFeLcc88Vffv2Fa1atRKbb765+O1vfyvWr1/vfcbNtR1eeeUV6fo8evRoIYTevC5evFgcf/zxol27dqJDhw5izJgxYuXKlVU4mpaBjBA+eWkHBwcHBwcHB4eahst5c3BwcHBwcHBoQXDOm4ODg4ODg4NDC4Jz3hwcHBwcHBwcWhCc8+bg4ODg4ODg0ILgnDcHBwcHBwcHhxYE57w5ODg4ODg4OLQgOOfNwcHBwcHBwaEFwTlvDg4ODg4ODg4tCM55c3BwcHBwcHBoQXDOm4ODg4ODg4NDC4Jz3hwcHBwcHBwcWhD+PyaCMtsJyzqSAAAAAElFTkSuQmCC" + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -570,42 +559,44 @@ { "cell_type": "markdown", "source": [ - "### ArrowHead\n", - "The arrowhead data consists of outlines of the images of\n", - "arrowheads. The shapes of the projectile points are converted into\n", - "a time series using the angle-based method. The classification of\n", - "projectile points is is an important\n", - "topic in anthropology. The classes are based on shape\n", - "distinctions, such as the presence and location of a notch in the\n", - "arrow. The problem in the repository is a length normalised version\n", - "of that used in Ye09shapelets. The three classes are called\n", - "\"Avonlea\" (0), \"Clovis\" (1) and \"Mix\" (2).\n" + "## Regression\n", + "\n", + "We ship one regression problem from the [Time Series Extrinsic Regression]\n", + "(http://tseregression.org/) website and one soon to be added." ], "metadata": { "collapsed": false } }, { - "cell_type": "code", + "cell_type": "markdown", "source": [ - "from aeon.datasets import load_arrow_head\n", + "### Covid3Month\n", "\n", - "arrowhead, arrow_labels = load_arrow_head()\n", - "print(arrowhead.shape)\n", - "plt.title(\n", - " f\"First two cases of the ArrowHead, classes: \"\n", - " f\"({arrow_labels[0]}, {arrow_labels[1]})\"\n", - ")\n", + "The goal of this dataset is to predict COVID-19's death rate on 1st April 2020 for each country using daily confirmed cases for the last three months.\n", + "This dataset contains 201 time series, where each time series is the daily confirmed cases for a country.\n", + "The data was obtained from WHO's COVID-19 database.\n", + "Please refer to https://covid19.who.int/ for more details" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "source": [ + "from aeon.datasets import load_covid_3month\n", "\n", - "plt.plot(arrowhead[0][0])\n", - "plt.plot(arrowhead[1][0])" + "covid, covid_target = load_covid_3month()\n", + "print(covid.shape)\n", + "plt.title(\"Response variable for Covid3Months data\")\n", + "plt.plot(covid_target)" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-09-25T22:58:20.861894Z", - "start_time": "2024-09-25T22:58:20.689090Z" + "end_time": "2024-09-25T22:58:22.385200Z", + "start_time": "2024-09-25T22:58:22.146164Z" } }, "outputs": [ @@ -613,14 +604,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "(211, 1, 251)\n" + "(201, 1, 84)\n" ] }, { "data": { - "text/plain": [ - "[]" - ] + "text/plain": "[]" }, "execution_count": 9, "metadata": {}, @@ -628,10 +617,8 @@ }, { "data": { - "text/plain": [ - "
" - ], - "image/png": "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" + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -642,12 +629,15 @@ { "cell_type": "markdown", "source": [ - "### BasicMotions\n", + "### CardanoSentiment\n", "\n", - "The data was generated as part of a student project where four students performed our activities whilst wearing a smart watch.\n", - "The watch collects 3D accelerometer and a 3D gyroscope It consists of four classes, which are walking, resting, running and\n", - "badminton. Participants were required to record motion a total of five times, and the data is sampled once every tenth of a second,\n", - "for a ten second period. The data is multivariate (six channels) equal length." + "By combining historical sentiment data for Cardano cryptocurrency, extracted from\n", + " EODHistoricalData and made available on Kaggle, with historical price data for the\n", + " same cryptocurrency, extracted from CryptoDataDownload, we created the\n", + " CardanoSentiment dataset, with 107 instances. The predictors are hourly close price\n", + " (in USD) and traded volume during a day, resulting in 2-dimensional time series of\n", + " length 24. The response variable is the normalized sentiment score on the day\n", + " spanned by the timepoints." ], "metadata": { "collapsed": false @@ -656,29 +646,31 @@ { "cell_type": "code", "source": [ - "from aeon.datasets import load_basic_motions\n", + "from aeon.datasets import load_cardano_sentiment\n", "\n", - "motions, motions_labels = load_basic_motions(split=\"train\")\n", - "plt.title(\n", - " f\"First and second dimensions of the first train instance in BasicMotions data, \"\n", - " f\"(student {motions_labels[0]})\"\n", - ")\n", - "plt.plot(motions[0][0])\n", - "plt.plot(motions[0][1])" + "cardano, cardano_target = load_cardano_sentiment()\n", + "print(cardano.shape)\n", + "plt.title(\"Response variable for cardano data\")\n", + "plt.plot(cardano_target)" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-09-25T22:58:21.053382Z", - "start_time": "2024-09-25T22:58:20.879846Z" + "end_time": "2024-09-25T22:58:22.582032Z", + "start_time": "2024-09-25T22:58:22.410134Z" } }, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(107, 2, 24)\n" + ] + }, { "data": { - "text/plain": [ - "[]" - ] + "text/plain": "[]" }, "execution_count": 10, "metadata": {}, @@ -686,10 +678,8 @@ }, { "data": { - "text/plain": [ - "
" - ], - "image/png": "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" + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -700,75 +690,25 @@ { "cell_type": "markdown", "source": [ - "### GunPoint\n", + "## Segmentation\n", "\n", - "This dataset involves one female actor and one male actor making a motion with their\n", - "hand. The two classes are: Gun-Draw and Point: For Gun-Draw the actors have their\n", - "hands by their sides. They draw a replicate gun from a hip-mounted holster, point it\n", - "at a target for approximately one second, then return the gun to the holster, and\n", - "their hands to their sides. For Point the actors have their gun by their sides. They\n", - "point with their index fingers to a target for approximately one second, and then\n", - "return their hands to their sides. For both classes, The data in the archive is the\n", - "X-axis motion of the actors right hand.\n" + "Two of the UCR classification data have been adapted for segmentation." ], "metadata": { "collapsed": false } }, - { - "cell_type": "code", - "source": [ - "from aeon.datasets import load_gunpoint\n", - "\n", - "gun, gun_labels = load_gunpoint(split=\"test\")\n", - "plt.title(\n", - " f\"First three cases of the test set for GunPoint, classes\"\n", - " f\"(actor {gun_labels[0]}, {gun_labels[1]}, {gun_labels[2]})\"\n", - ")\n", - "plt.plot(gun[0][0])\n", - "plt.plot(gun[1][0])\n", - "plt.plot(gun[2][0])" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-09-25T22:58:21.247394Z", - "start_time": "2024-09-25T22:58:21.075323Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 11 - }, { "cell_type": "markdown", "source": [ - "### ItalyPowerDemand\n", - "The data was derived from twelve monthly electrical power demand time series from\n", - "Italy and first used in the paper \"Intelligent Icons: Integrating Lite-Weight Data\n", - "Mining and Visualization into GUI Operating Systems\". The classification task is to\n", - "distinguish days from Oct to March (inclusive) (class 0) from April to September\n", - "(class 1). The problem is univariate, equal length.\n" + "### ElectricDevices\n", + "\n", + "The UCR ElectricDevices dataset series are grouped by class label and concatenated to create\n", + " segments with repeating temporal patterns and characteristics. The location at which\n", + " different classes were concatenated are marked as change points.\n", + "\n", + "this function returns a single series, the period length as an integer and the\n", + "change points as a numpy array." ], "metadata": { "collapsed": false @@ -777,63 +717,60 @@ { "cell_type": "code", "source": [ - "from aeon.datasets import load_italy_power_demand\n", + "from aeon.datasets import load_electric_devices_segmentation\n", + "from aeon.visualisation import plot_series\n", "\n", - "italy, italy_labels = load_italy_power_demand(split=\"train\")\n", - "plt.title(\n", - " f\"First three cases of the test set for ItalyPowerDemand, classes\"\n", - " f\"( {italy_labels[0]}, {italy_labels[1]}, {italy_labels[2]})\"\n", - ")\n", - "plt.plot(italy[0][0])\n", - "plt.plot(italy[1][0])\n", - "plt.plot(italy[2][0])" + "data, period, change_points = load_electric_devices_segmentation()\n", + "print(\" Period = \", period)\n", + "print(\" Change points = \", change_points)\n", + "plot_series(data)" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-09-25T22:58:21.419932Z", - "start_time": "2024-09-25T22:58:21.266319Z" + "end_time": "2024-09-25T22:58:22.990281Z", + "start_time": "2024-09-25T22:58:22.610956Z" } }, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Period = 10\n", + " Change points = [1090 4436 5712 7923]\n" + ] + }, { "data": { - "text/plain": [ - "[]" - ] + "text/plain": "(
, )" }, - "execution_count": 12, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" }, { "data": { - "text/plain": [ - "
" - ], - "image/png": "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" + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 12 + "execution_count": 25 }, { "cell_type": "markdown", "source": [ - "### JapaneseVowels\n", - "\n", - "A UCI Archive dataset. See this link for more [detailed information](https://archive.ics.uci.edu/ml/datasets/Japanese+Vowels)\n", - "\n", - "Paper: M. Kudo, J. Toyama and M. Shimbo. (1999). \"Multidimensional Curve Classification Using Passing-Through Regions\". Pattern Recognition Letters, Vol. 20, No. 11--13, pages 1103--1111.\n", + "### GunPoint Segmentation\n", "\n", - "9 Japanese-male speakers were recorded saying the vowels 'a' and 'e'. A '12-degree linear prediction analysis' is applied to the raw recordings to obtain time-series with 12 dimensions and series lengths between 7 and 29. The classification task is to predict the speaker. Therefore, each instance is a transformed utterance, 12*29 values with a single class label attached, [1...9].\n", + "The UCR GunPoint dataset series are grouped by class label and concatenated to create\n", + " segments with repeating temporal patterns and characteristics. The location at which\n", + " different classes were concatenated are marked as change points.\n", "\n", - "The given training set is comprised of 30 utterances for each speaker, however the\n", - "test set has a varied distribution based on external factors of timing and\n", - "experimental availability, between 24 and 88 instances per speaker. The data is\n", - "unequal length" + "this function returns a single series, the period length as an integer and the\n", + "change points as a numpy array." ], "metadata": { "collapsed": false @@ -842,27 +779,18 @@ { "cell_type": "code", "source": [ - "from aeon.datasets import load_japanese_vowels\n", - "\n", - "japan, japan_labels = load_japanese_vowels(split=\"train\")\n", - "plt.title(\n", - " f\"First channel of three test cases for JapaneseVowels, classes\"\n", - " f\"({japan_labels[0]}, {japan_labels[10]}, {japan_labels[200]})\"\n", - ")\n", - "print(f\" number of cases = \" f\"{len(japan)}\")\n", - "print(f\" First case shape = \" f\"{japan[0].shape}\")\n", - "print(f\" Tenth case shape = \" f\"{japan[10].shape}\")\n", - "print(f\" 200th case shape = \" f\"{japan[200].shape}\")\n", + "from aeon.datasets import load_gun_point_segmentation\n", "\n", - "plt.plot(japan[0][0])\n", - "plt.plot(japan[10][0])\n", - "plt.plot(japan[200][0])" + "data, period, change_points = load_gun_point_segmentation()\n", + "print(\" Period = \", period)\n", + "print(\" Change points = \", change_points)\n", + "plot_series(data)" ], "metadata": { "collapsed": false, "ExecuteTime": { - "end_time": "2024-09-25T22:58:21.705366Z", - "start_time": "2024-09-25T22:58:21.437860Z" + "end_time": "2024-09-25T22:58:23.230150Z", + "start_time": "2024-09-25T22:58:23.046130Z" } }, "outputs": [ @@ -870,78 +798,92 @@ "name": "stdout", "output_type": "stream", "text": [ - " number of cases = 270\n", - " First case shape = (12, 20)\n", - " Tenth case shape = (12, 23)\n", - " 200th case shape = (12, 13)\n" + " Period = 10\n", + " Change points = [900]\n" ] }, { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" + "ename": "NameError", + "evalue": "name 'plot_series' is not defined", + "output_type": "error", + "traceback": [ + "\u001B[1;31m---------------------------------------------------------------------------\u001B[0m", + "\u001B[1;31mNameError\u001B[0m Traceback (most recent call last)", + "Cell \u001B[1;32mIn[12], line 6\u001B[0m\n\u001B[0;32m 4\u001B[0m \u001B[38;5;28mprint\u001B[39m(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m Period = \u001B[39m\u001B[38;5;124m\"\u001B[39m, period)\n\u001B[0;32m 5\u001B[0m \u001B[38;5;28mprint\u001B[39m(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m Change points = \u001B[39m\u001B[38;5;124m\"\u001B[39m, change_points)\n\u001B[1;32m----> 6\u001B[0m \u001B[43mplot_series\u001B[49m(data)\n", + "\u001B[1;31mNameError\u001B[0m: name 'plot_series' is not defined" + ] } ], - "execution_count": 13 + "execution_count": 12 + }, + { + "cell_type": "markdown", + "source": [], + "metadata": { + "collapsed": false + } }, { "cell_type": "markdown", "source": [ - "### OSUleaf\n", + "## Time Series Forecasting\n", "\n", - "The OSULeaf data set consist of one dimensional outlines of leaves. The series were\n", - "obtained by color image segmentation and boundary extraction (in the anti-clockwise\n", - "direction) from digitized leaf images of six classes: Acer Circinatum, Acer Glabrum,\n", - "Acer Macrophyllum, Acer Negundo, Quercus Garryana and Quercus Kelloggii for the MSc\n", - "thesis \"Content-Based Image Retrieval: Plant Species Identification\" by A. Grandhi.\n", - "OSULeaf is equal length and univariate" + "Forecasting data are stored in csv files with a header for column names. Six standard\n", + " example datasets are shipped by default:\n", + "\n", + "| dataset name | loader function | properties |\n", + "|----------|:-------------:|------:|\n", + "| Box/Jenkins airline data | `load_airline` | univariate |\n", + "| Lynx sales data | `load_lynx` | univariate |\n", + "| Shampoo sales data | `load_shampoo_sales` | univariate |\n", + "| Pharmaceutical Benefit Scheme data | `load_PBS_dataset` | univariate |\n", + "| Longley US macroeconomic data | `load_longley` | multivariate |\n", + "| MTS consumption/income data | `load_uschange` | multivariate |\n", + "\n", + " These are stored in csv format in time, value format, including a header. For\n", + " forcasting files, each column that is not an index is considered a time series. For\n", + " example, the airline data has a single time series each row a time, value pair:\n", + "\n", + " Date,Passengers\n", + " 1949-01,112\n", + " 1949-02,118\n", + "\n", + "Longley has seven time series, each in its own column. Each row is the same time index:\n", + "\n", + " \"Obs\",\"TOTEMP\",\"GNPDEFL\",\"GNP\",\"UNEMP\",\"ARMED\",\"POP\",\"YEAR\"\n", + " 1,60323,83,234289,2356,1590,107608,1947\n", + " 2,61122,88.5,259426,2325,1456,108632,1948\n", + " 3,60171,88.2,258054,3682,1616,109773,1949\n", + "\n", + "The problem specific loading functions return the series as either a `pd.Series` if\n", + "a single series or, if multiple series, a `pd.DataFrame` with each column a series.\n", + "There are currently six forecasting problems\n", + "shipped." ], "metadata": { "collapsed": false } }, { - "cell_type": "code", + "cell_type": "markdown", "source": [ - "from aeon.datasets import load_osuleaf\n", + "### Airline\n", "\n", - "leaf, leaf_labels = load_osuleaf(split=\"train\")\n", - "plt.title(\n", - " f\"First three cases of the test set for OSULeaf, classes\"\n", - " f\" ({leaf_labels[0]}, {leaf_labels[1]}, {leaf_labels[2]})\"\n", - ")\n", - "plt.plot(leaf[0][0])\n", - "plt.plot(leaf[1][0])\n", - "plt.plot(leaf[2][0])" + "The classic Box & Jenkins airline data. Monthly totals of international\n", + " airline passengers, 1949 to 1960. This data shows an increasing trend,\n", + " non-constant (increasing) variance and periodic, seasonal patterns. The\n" ], "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-09-25T22:58:21.910360Z", - "start_time": "2024-09-25T22:58:21.726272Z" - } - }, + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 14, "outputs": [ { "data": { - "text/plain": [ - "[]" - ] + "text/plain": "(
,\n )" }, "execution_count": 14, "metadata": {}, @@ -949,28 +891,42 @@ }, { "data": { - "text/plain": [ - "
" - ], - "image/png": "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" + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 14 + "source": [ + "import warnings\n", + "\n", + "from aeon.datasets import load_airline\n", + "from aeon.visualisation import plot_series\n", + "\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "airline = load_airline(return_array=False)\n", + "plot_series(airline)" + ], + "metadata": { + "collapsed": false + } }, { "cell_type": "markdown", "source": [ - "### PLAID\n", - "PLAID stands for the Plug Load Appliance Identification Dataset. The data are intended for load identification research. The first version of PLAID is named PLAID1, collected in summer 2013. A second version of PLAID was collected in winter 2014 and released under the name PLAID2.\n", - "This dataset comes from PLAID1. It includes current and voltage measurements sampled at 30 kHz from 11 different appliance types present in more than 56 households in Pittsburgh, Pennsylvania, USA. Data collection took place during the summer of 2013. Each appliance type is represented by dozens of different instances of varying makes/models.\n", - "For each appliance, three to six measurements were collected for each state transition. These measurements were then post-processed to extract a few-second-long window containing both the steady-state operation and the startup transient )when available).\n", - "The classes correspond to 11 different appliance types: air\n", - "conditioner (class 0), compact flourescent lamp, fan, fridge,\n", - "hairdryer , heater, incandescent light bulb, laptop, microwave,\n", - "vacuum,washing machine (class 10). The data is univariate and unequal length." + "### Longley\n", + "This mulitvariate time series dataset contains various US macroeconomic\n", + " variables from 1947 to 1962 that are known to be highly collinear. This loader\n", + " returns the multivariate time series as a numpy array or a pandas DataFrame wit\n", + " the following columns:\n", + " TOTEMP - Total employment\n", + " GNPDEFL - Gross national product deflator\n", + " GNP - Gross national product\n", + " UNEMP - Number of unemployed\n", + " ARMED - Size of armed forces\n", + " POP - Population\n" ], "metadata": { "collapsed": false @@ -978,71 +934,30 @@ }, { "cell_type": "code", - "source": [ - "from aeon.datasets import load_plaid\n", - "\n", - "plaid, plaid_labels = load_plaid(split=\"train\")\n", - "plt.title(\n", - " f\"three train cases for PLAID, classes\"\n", - " f\"( {plaid_labels[0]}, {plaid_labels[10]}, {plaid_labels[200]})\"\n", - ")\n", - "print(f\" number of cases = \" f\"{len(plaid)}\")\n", - "print(f\" First case shape = \" f\"{plaid[0].shape}\")\n", - "print(f\" Tenth case shape = \" f\"{plaid[10].shape}\")\n", - "print(f\" 200th case shape = \" f\"{plaid[200].shape}\")\n", - "\n", - "plt.plot(plaid[0][0])\n", - "plt.plot(plaid[10][0])\n", - "plt.plot(plaid[200][0])" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-09-25T22:58:22.119236Z", - "start_time": "2024-09-25T22:58:21.932521Z" - } - }, + "execution_count": 21, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " number of cases = 537\n", - " First case shape = (1, 500)\n", - " Tenth case shape = (1, 300)\n", - " 200th case shape = (1, 200)\n" - ] - }, { "data": { - "text/plain": [ - "[]" - ] + "text/plain": "(
, )" }, - "execution_count": 15, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" }, { "data": { - "text/plain": [ - "
" - ], - "image/png": "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" + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 15 - }, - { - "cell_type": "markdown", "source": [ - "## Regression\n", + "from aeon.datasets import load_longley\n", "\n", - "We ship one regression problem from the [Time Series Extrinsic Regression]\n", - "(http://tseregression.org/) website and one soon to be added." + "longley = load_longley(return_array=False)\n", + "plot_series(longley[\"TOTEMP\"])" ], "metadata": { "collapsed": false @@ -1051,12 +966,10 @@ { "cell_type": "markdown", "source": [ - "### Covid3Month\n", "\n", - "The goal of this dataset is to predict COVID-19's death rate on 1st April 2020 for each country using daily confirmed cases for the last three months.\n", - "This dataset contains 201 time series, where each time series is the daily confirmed cases for a country.\n", - "The data was obtained from WHO's COVID-19 database.\n", - "Please refer to https://covid19.who.int/ for more details" + "The annual numbers of lynx trappings for 1821–1934 in Canada. This\n", + " time-series records the number of skins of predators (lynx) that were collected\n", + " over several years by the Hudson's Bay Company." ], "metadata": { "collapsed": false @@ -1064,123 +977,75 @@ }, { "cell_type": "code", - "source": [ - "from aeon.datasets import load_covid_3month\n", - "\n", - "covid, covid_target = load_covid_3month()\n", - "print(covid.shape)\n", - "plt.title(\"Response variable for Covid3Months data\")\n", - "plt.plot(covid_target)" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-09-25T22:58:22.385200Z", - "start_time": "2024-09-25T22:58:22.146164Z" - } - }, + "execution_count": 22, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(201, 1, 84)\n" - ] - }, { "data": { - "text/plain": [ - "[]" - ] + "text/plain": "(
, )" }, - "execution_count": 16, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" }, { "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjUAAAGzCAYAAADXFObAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOx9ebwcRbX/d/a7ZSF7ApGwSYhAAoGE8JCABAOiPn6EsOkjRAR8EhCiPMWngLgEBWJ4EkGebE9B9kURoyEQBAkEEiI7sgey7ze56yz9+6Onqk9VV29zu2f6zq3v55PM3Jme7uru6qpT3/M95yQMwzCgoaGhoaGhodHLkax1AzQ0NDQ0NDQ0woA2ajQ0NDQ0NDTqAtqo0dDQ0NDQ0KgLaKNGQ0NDQ0NDoy6gjRoNDQ0NDQ2NuoA2ajQ0NDQ0NDTqAtqo0dDQ0NDQ0KgLaKNGQ0NDQ0NDoy6gjRoNDQ0NDQ2NuoA2ajQ06hRLly5FIpHA0qVLA//2nHPOQUtLi69tE4kErrrqqsDHcEKhUMB//dd/YfTo0Ugmkzj55JND23fcEOQeHXPMMTjmmGMib1Ot8OGHHyKRSOC6666r+rHPOeccjBkzpurH1Qgf2qjRcMQdd9yBRCLB/6XTaey+++4455xzsGbNmlo3T6NOcdttt+Haa6/FqaeeijvvvBOXXnppVY778MMP48QTT8SQIUOQzWYxatQonHbaaXjyySercvyg6OjowLnnnosDDzwQAwYMQEtLC8aPH48bbrgB+Xxe2Paqq65CIpFAMpnExx9/bNtXa2srGhsbkUgkMGfOnEjb/fjjj4dqBNcaP/vZz/DII4/UuhkaZaRr3QCN+OPqq6/GXnvthc7OTjz//PO444478Oyzz+K1115DQ0NDrZun4YCjjz4aHR0dyGaztW5KIDz55JPYfffd8ctf/rIqxzMMA1/72tdwxx134JBDDsHcuXMxYsQIrFu3Dg8//DCOO+44/OMf/8CRRx4Z+rF7co86Ojrw+uuv4wtf+ALGjBmDZDKJ5557DpdeeileeOEF3H333bbf5HI5/OEPf8B//dd/CZ8/9NBDFZ9DUDz++ONYuHBh3Rg2P/vZz3DqqafWNaPYm6CNGg1PnHjiiTjssMMAAF//+tcxZMgQ/PznP8cf//hHnHbaaTVunYaMzs5OZLNZJJPJXml0bty4EQMHDgxtf6VSCd3d3Y7X4vrrr8cdd9yBSy65BPPnz0cikeDf/fd//zd+97vfIZ2OZqjsyT0aNGgQnn/+eeGzb3zjGxgwYABuvPFGzJ8/HyNGjBC+/8IXvqA0au6++26cdNJJePDBBytqi4ZGXKDdTxqB8dnPfhYA8N577wmfv/XWWzj11FMxaNAgNDQ04LDDDsMf//hHYZt8Po8f/ehH2G+//dDQ0IDBgwfjqKOOwuLFi/k2TM/x/vvvY/r06WhubsaoUaNw9dVXQy4q39bWhm9/+9sYPXo0crkc9t9/f1x33XW27Rit/sgjj+DAAw9ELpfDZz7zGSxatEjYbufOnbjkkkswZswY5HI5DBs2DMcffzxWrlwpbPfCCy/ghBNOwIABA9DU1ISpU6fiH//4h+t127BhA9LpNH70ox/Zvnv77beRSCRw4403AgC2bt2K73znOzjooIPQ0tKC/v3748QTT8Q///lP4XdMk3HPPffgBz/4AXbffXc0NTWhtbVVqdd45plnMHPmTHzqU59CLpfD6NGjcemll6Kjo0PZZj/3QIU1a9bga1/7GoYPH86v9W233eb6G6apeOqpp/D6669ztydrf9B7fdddd+Ezn/kMcrmc7T4zdHR0YN68eRg7diyuu+46waBh+I//+A9MmjRJuCYzZ87EoEGD0NTUhCOOOAJ//vOf+fdB7rOTpuaWW27BPvvsg8bGRkyaNAnPPPOM67WjYNqQ7du3274766yzsGrVKrz11lv8s/Xr1+PJJ5/EWWedpdzfxo0bce6552L48OFoaGjA+PHjceeddwrbUD0Ma3sul8Phhx+OF198kW93zjnnYOHChQAguLZluO2DtXn27NnYY489kMvlMHLkSPz7v/87PvzwQ8/rw8aAhoYGHHjggXj44YeV21133XU48sgjMXjwYDQ2NmLixIl44IEHhG0SiQTa2tpw55138nM555xzAAAfffQRvvnNb2L//fdHY2MjBg8ejJkzZ/pqo0bl0EyNRmCwh3K33Xbjn73++uv4t3/7N+y+++743ve+h+bmZtx33304+eST8eCDD+L//b//B8D07c+bNw9f//rXMWnSJLS2tuKll17CypUrcfzxx/P9FYtFnHDCCTjiiCPwi1/8AosWLcKVV16JQqGAq6++GoDpNvjyl7+Mp556Cueeey4mTJiAv/71r7jsssuwZs0am/vi2WefxUMPPYRvfvOb6NevH/7nf/4HM2bMwOrVqzF48GAA5kr3gQcewJw5czBu3Dhs2bIFzz77LN58800ceuihAEz3yIknnoiJEyfiyiuvRDKZxO23347Pfe5zeOaZZ4QJkGL48OGYOnUq7rvvPlx55ZXCd/feey9SqRRmzpwJwJw4H3nkEcycORN77bUXNmzYgN/85jeYOnUq3njjDYwaNUr4/Y9//GNks1l85zvfQVdXl6M74/7770d7ezv+8z//E4MHD8by5cvxq1/9Cp988gnuv/9+YVs/90CFDRs24IgjjuDGxdChQ/GXv/wF5557LlpbW3HJJZcofzd06FD87ne/w09/+lPs2rUL8+bNAwAccMABge/1k08+ifvuuw9z5szBkCFDHEWgzz77LLZu3YpLLrkEqVTK8ZzouR155JFob2/HxRdfjMGDB+POO+/El7/8ZTzwwAP4f//v/wW6zyrceuutuOCCC3DkkUfikksuwfvvv48vf/nLGDRoEEaPHm3bvru7G62trejo6MBLL72E6667DnvuuSf23Xdf27ZHH3009thjD9x99938Ht57771oaWnBSSedZNu+o6MDxxxzDN59913MmTMHe+21F+6//36cc8452L59O771rW8J2999993YuXMnLrjgAiQSCfziF7/AKaecgvfffx+ZTAYXXHAB1q5di8WLF+N3v/ud8vy99gEAM2bMwOuvv46LLroIY8aMwcaNG7F48WKsXr3aVfD7t7/9DTNmzMC4ceMwb948bNmyhRtHMm644QZ8+ctfxle+8hV0d3fjnnvuwcyZM/HYY4/xa/W73/2Oj2Xnn38+AGCfffYBALz44ot47rnncMYZZ2CPPfbAhx9+iJtuugnHHHMM3njjDTQ1NTm2U6MHMDQ0HHD77bcbAIwnnnjC2LRpk/Hxxx8bDzzwgDF06FAjl8sZH3/8Md/2uOOOMw466CCjs7OTf1YqlYwjjzzS2G+//fhn48ePN0466STX486aNcsAYFx00UXCvk466SQjm80amzZtMgzDMB555BEDgPGTn/xE+P2pp55qJBIJ49133+WfATCy2azw2T//+U8DgPGrX/2KfzZgwADjwgsvdGxbqVQy9ttvP2P69OlGqVTin7e3txt77bWXcfzxx7ue229+8xsDgPHqq68Kn48bN8743Oc+x//u7Ow0isWisM0HH3xg5HI54+qrr+afPfXUUwYAY++99zba29uF7dl3Tz31lNBOGfPmzTMSiYTx0Ucf8c/83gPDMK/tlVdeyf8+99xzjZEjRxqbN28WjnPGGWcYAwYMULaBYurUqcZnPvMZ4bOg9zqZTBqvv/6663EMwzBuuOEGA4Dx8MMPe25rGIZxySWXGACMZ555hn+2c+dOY6+99jLGjBnD75nf+yzfo+7ubmPYsGHGhAkTjK6uLr7dLbfcYgAwpk6damvTH/7wBwMA/3fYYYcZr7zyirDNlVdeaQAwNm3aZHznO98x9t13X/7d4YcfbsyePdswDPPa0f6/YMECA4Dx+9//nn/W3d1tTJkyxWhpaTFaW1sNwzD7JgBj8ODBxtatW/m2jz76qAHA+NOf/sQ/u/DCCw3V1ON3H9u2bTMAGNdee61tH16YMGGCMXLkSGP79u38s7/97W8GAGPPPfcUtpX7aXd3t3HggQcK988wDKO5udmYNWuW7Viqfr5s2TIDgPF///d/gduu4Q/a/aThiWnTpmHo0KEYPXo0Tj31VDQ3N+OPf/wjX91s3boVTz75JE477TTs3LkTmzdvxubNm7FlyxZMnz4d77zzDo+WGjhwIF5//XW88847nselURhs1d/d3Y0nnngCgCk4TKVSuPjii4Xfffvb34ZhGPjLX/5iOw+2igKAgw8+GP3798f777/PPxs4cCBeeOEFrF27VtmmVatW4Z133sFZZ52FLVu28HNta2vDcccdh7///e8olUqO53TKKacgnU7j3nvv5Z+99tpreOONN3D66afzz3K5HJJJ8/EsFovYsmULWlpasP/++9tcYQAwa9YsNDY2Oh6XgW7T1taGzZs348gjj4RhGHj55Zdt23vdAxmGYeDBBx/El770JRiGwa/P5s2bMX36dOzYsUPZfi8EvddTp07FuHHjPPfb2toKAOjXr5/vdkyaNAlHHXUU/6ylpQXnn38+PvzwQ7zxxhsA/N9nGS+99BI2btyIb3zjGwLbds4552DAgAHK3xx77LFYvHgx7r//fnzjG99AJpNBW1ub4zHOOussvPvuu3jxxRf5q5Pr6fHHH8eIESNw5pln8s8ymQwuvvhi7Nq1C08//bSw/emnny4wuMxVTZ8xL3jto7GxEdlsFkuXLsW2bdt873fdunVYtWoVZs2aJVzL448/XtlX6LOybds27NixA5/97Gd991/6+3w+jy1btmDffffFwIEDK3oGNPxBGzUanli4cCEWL16MBx54AF/4whewefNm5HI5/v27774LwzDwwx/+EEOHDhX+Mfp948aNAMxIqu3bt+PTn/40DjroIFx22WV45ZVXbMdMJpPYe++9hc8+/elPA7DcXx999BFGjRplm5AOOOAA/j3Fpz71KdtxdtttN2Fg/MUvfoHXXnsNo0ePxqRJk3DVVVcJAzIzxmbNmmU719/+9rfo6urCjh07HK/lkCFDcNxxx+G+++7jn917771Ip9M45ZRT+GelUgm//OUvsd9++yGXy2HIkCEYOnQoXnnlFeX+99prL8djUqxevRrnnHMOBg0ahJaWFgwdOhRTp04FANt+/dwDGZs2bcL27dtxyy232K7P7NmzAVh9IQiC3mu/16N///4ATC2V33bsv//+ts/ldvi9z6r9A8B+++0nfJ7JZGz3gmH48OGYNm0aTj31VNx000344he/iOOPPx7r169Xbn/IIYdg7NixuPvuu3HXXXdhxIgR+NznPufYnv32248b2E7nyyA/Y8w4CWJ8eO0jl8vh5z//Of7yl79g+PDhOProo/GLX/zC8XzpuQD2awtAeU8fe+wxHHHEEWhoaMCgQYMwdOhQ3HTTTa7PN0VHRweuuOIKrgFjz/D27dt970MjOLSmRsMTkyZN4tFPJ598Mo466iicddZZePvtt9HS0sKZie985zuYPn26ch/Mv3/00Ufjvffew6OPPoq//e1v+O1vf4tf/vKXuPnmm/H1r3890vNw0kwYRGh62mmn4bOf/Swefvhh/O1vf8O1116Ln//853jooYdw4okn8nO99tprMWHCBOX+vJLWnXHGGZg9ezZWrVqFCRMm4L777sNxxx2HIUOG8G1+9rOf4Yc//CG+9rWv4cc//jEGDRqEZDKJSy65RMkE+WFpisUijj/+eGzduhXf/e53MXbsWDQ3N2PNmjU455xzXBkmv2D7+OpXv4pZs2Yptzn44IN7fBwv+LkeADB27FgAwKuvvhp6SK6f+xwFTj31VPz3f/83Hn30UVxwwQXKbc466yzcdNNN6NevH04//XSb0VIp/DxjYezjkksuwZe+9CU88sgj+Otf/4of/vCHmDdvHp588kkccsghwRqtwDPPPIMvf/nLOProo/HrX/8aI0eORCaTwe23364MlVfhoosuwu23345LLrkEU6ZMwYABA5BIJHDGGWeE8qxpqKGNGo1ASKVSmDdvHo499ljceOON+N73vsdXkJlMBtOmTfPcx6BBgzB79mzMnj0bu3btwtFHH42rrrpKMGpKpRLef/99zgwAwL/+9S8AVnTHnnvuiSeeeAI7d+4UVvAssmPPPfes6BxHjhyJb37zm/jmN7+JjRs34tBDD8VPf/pTnHjiidx91b9/f1/nqsLJJ5+MCy64gLsm/vWvf+Hyyy8XtnnggQdw7LHH4tZbbxU+3759e8WT4quvvop//etfuPPOO3H22Wfzz2nkGYWfeyBj6NCh6NevH4rFYsXXR4Wo7vVRRx2F3XbbDX/4wx/w/e9/31MsvOeee+Ltt9+2fa5qh5/7rNo/YDKClD3J5/P44IMPMH78eM9zYpFsbmzAWWedhSuuuALr1q1zFOyy9rzyyisolUqC4dOT666KdqoE++yzD7797W/j29/+Nt555x1MmDAB119/PX7/+98rt6fXVoZ8Tx988EE0NDTgr3/9q8BK33777bbfOp3PAw88gFmzZuH666/nn3V2diqj0jTCg3Y/aQTGMcccg0mTJmHBggXo7OzEsGHDcMwxx+A3v/kN1q1bZ9t+06ZN/P2WLVuE71paWrDvvvuiq6vL9jsW9gqYq7Qbb7wRmUwGxx13HAAz50axWBS2A4Bf/vKXSCQSOPHEEwOdV7FYtE0Ew4YNw6hRo3j7Jk6ciH322QfXXXcddu3a5XquThg4cCCmT5+O++67D/fccw+y2ayNJUilUrbV7f3339+jTM5swqb7NQwDN9xwg+NvvO6B6hgzZszAgw8+iNdee832vZ/ro0LY95qhqakJ3/3ud/Hmm2/iu9/9rpJR+P3vf4/ly5fzdixfvhzLli3j37e1teGWW27BmDFjBG2Gn/ss47DDDsPQoUNx8803o7u7m39+xx132CbDzZs3K9v729/+lu/LCfvssw8WLFiAefPmOUbrsfNdv369oA0qFAr41a9+hZaWFu66DILm5mYA6pBzP2hvb0dnZ6fw2T777IN+/fopxxGGkSNHYsKECbjzzjuF53zx4sVcC8WQSqWQSCRQLBb5Zx9++KEyc3Bzc7PyXFTP8K9+9SthnxrhQzM1GhXhsssuw8yZM3HHHXfgG9/4BhYuXIijjjoKBx10EM477zzsvffe2LBhA5YtW4ZPPvmE51cZN24cjjnmGEycOBGDBg3CSy+9xEOoKRoaGrBo0SLMmjULkydPxl/+8hf8+c9/xve//30MHToUAPClL30Jxx57LP77v/8bH374IcaPH4+//e1vePTRR3HJJZcIomA/2LlzJ/bYYw+ceuqpGD9+PFpaWvDEE0/gxRdf5KutZDKJ3/72tzjxxBPxmc98BrNnz8buu++ONWvW4KmnnkL//v3xpz/9yfNYp59+Or761a/i17/+NaZPn25LNvfFL34RV199NWbPno0jjzwSr776Ku666y5HXYUfjB07Fvvssw++853vYM2aNejfvz8efPBBR72Dn3ugwjXXXIOnnnoKkydPxnnnnYdx48Zh69atWLlyJZ544gls3bo1cNvDvtcUl112GV5//XVcf/31eOqpp3DqqadixIgRWL9+PR555BEsX74czz33HADge9/7Hv7whz/gxBNPxMUXX4xBgwbhzjvvxAcffIAHH3zQ5sbxus8yMpkMfvKTn+CCCy7A5z73OZx++un44IMPcPvtt9vu/e9//3vcfPPNOPnkk7H33ntj586d+Otf/4rFixfjS1/6kqNOhkEOx1bh/PPPx29+8xucc845WLFiBcaMGYMHHngA//jHP7BgwQLfAmuKiRMnAgAuvvhiTJ8+HalUCmeccYbv3//rX//Ccccdh9NOOw3jxo1DOp3Gww8/jA0bNnjuZ968eTjppJNw1FFH4Wtf+xq2bt2KX/3qV/jMZz4jLFJOOukkzJ8/HyeccALOOussbNy4EQsXLsS+++5r0wBOnDgRTzzxBObPn49Ro0Zhr732wuTJk/HFL34Rv/vd7zBgwACMGzcOy5YtwxNPPMHTR2hEhKrHW2n0GrCQ7hdffNH2XbFYNPbZZx9jn332MQqFgmEYhvHee+8ZZ599tjFixAgjk8kYu+++u/HFL37ReOCBB/jvfvKTnxiTJk0yBg4caDQ2Nhpjx441fvrTnxrd3d18m1mzZhnNzc3Ge++9Z3z+8583mpqajOHDhxtXXnmlLcx5586dxqWXXmqMGjXKyGQyxn777Wdce+21Qri1YdhDVRn23HNPHo7Z1dVlXHbZZcb48eONfv36Gc3Nzcb48eONX//617bfvfzyy8Ypp5xiDB482Mjlcsaee+5pnHbaacaSJUt8XdvW1lajsbHRFi7L0NnZaXz72982Ro4caTQ2Nhr/9m//ZixbtsyYOnWqENbLQoLvv/9+2z5UId1vvPGGMW3aNKOlpcUYMmSIcd555/HQ9ttvv51vF+QeQArpNgzD2LBhg3HhhRcao0ePNjKZjDFixAjjuOOOM2655RbPa6MK6TaMnt9rLzzwwAPG5z//eWPQoEFGOp02Ro4caZx++unG0qVLhe3ee+8949RTTzUGDhxoNDQ0GJMmTTIee+wx5T697rPqHhmGYfz617829tprLyOXyxmHHXaY8fe//91271988UVj5syZxqc+9Skjl8sZzc3NxqGHHmrMnz/fyOfzwv5oSLcbVNduw4YNxuzZs40hQ4YY2WzWOOigg4S+YhhWOLYqzFruH4VCwbjooouMoUOHGolEgod3+93H5s2bjQsvvNAYO3as0dzcbAwYMMCYPHmycd9997meG8ODDz5oHHDAAUYulzPGjRtnPPTQQ8asWbNsId233nqrsd9++xm5XM4YO3ascfvtt/PrSPHWW28ZRx99NL/PbDzZtm0bv24tLS3G9OnTjbfeeksYczTCR8IwAii4NDSqgHPOOQcPPPCA0r2joaGhoaHhBK2p0dDQ0NDQ0KgLaKNGQ0NDQ0NDoy6gjRoNDQ0NDQ2NuoDW1GhoaGhoaGjUBTRTo6GhoaGhoVEX0EaNhoaGhoaGRl2gzyTfK5VKWLt2Lfr16xdamm4NDQ0NDQ2NaGEYBnbu3IlRo0Z51inrM0bN2rVrMXr06Fo3Q0NDQ0NDQ6MCfPzxx9hjjz1ct+kzRg1L5/3xxx+jf//+NW6NhoaGhoaGhh+0trZi9OjRvspy9Bmjhrmc+vfvr40aDQ0NDQ2NXgY/0hEtFNbQ0NDQ0NCoC2ijRkNDQ0NDQ6MuoI0aDQ0NDQ0NjbqANmo0NDQ0NDQ06gLaqNHQ0NDQ0NCoC2ijRkNDQ0NDQ6MuoI0aDQ0NDQ0NjbqANmo0NDQ0NDQ06gLaqNHQ0NDQ0NCoC2ijRkNDQ0NDQ6MuoI0aDQ0NDQ0NjbqANmo0NDQ0NDQ06gLaqNHQ0NDQ0NAIhJc+3IrfP/8RDMOodVME9Jkq3RoaGhoaGhrh4PKHXsU7G3dh8l6DsN/wfrVuDodmajQ0NDQ0NDQCoa2rAADYVX6NC7RRo6GhoaGhoREIJUN8jQu0UaOhoaGhoaERCKWyliZumhpt1GhoaGhoaGgEgmZqNDQ0NDQ0NOoChmZqNDQ0NDQ0NOoBzP2kmRoNDQ0NDQ2NXg1my2imRkNDQ0NDQ6NXo1SmaOJl0lRo1CxcuBBjxoxBQ0MDJk+ejOXLlztu+/rrr2PGjBkYM2YMEokEFixYYNuGfSf/u/DCC/k2xxxzjO37b3zjG5U0X0NDo4f4y6vrcN1f347dKk1DQ6M6MLhQOF5jQGCj5t5778XcuXNx5ZVXYuXKlRg/fjymT5+OjRs3Krdvb2/H3nvvjWuuuQYjRoxQbvPiiy9i3bp1/N/ixYsBADNnzhS2O++884TtfvGLXwRtvoaGRgj42V/exI1PvYt3Nu6qdVM0NDRqgLrR1MyfPx/nnXceZs+ejXHjxuHmm29GU1MTbrvtNuX2hx9+OK699lqcccYZyOVyym2GDh2KESNG8H+PPfYY9tlnH0ydOlXYrqmpSdiuf//+QZuvoaERAjrzJQBAV/lVQ0Ojb6FUD0xNd3c3VqxYgWnTplk7SCYxbdo0LFu2LJQGdXd34/e//z2+9rWvIZFICN/dddddGDJkCA488EBcfvnlaG9vd9xPV1cXWltbhX8aGhrhgPnT4zagaWhoVAf82Y/ZEBCooOXmzZtRLBYxfPhw4fPhw4fjrbfeCqVBjzzyCLZv345zzjlH+Pyss87CnnvuiVGjRuGVV17Bd7/7Xbz99tt46KGHlPuZN28efvSjH4XSJg0NDRE8m2iN26GhoVEbsGc/bgub2FXpvvXWW3HiiSdi1KhRwufnn38+f3/QQQdh5MiROO644/Dee+9hn332se3n8ssvx9y5c/nfra2tGD16dHQN19DoQyhqpkZDo0/DiKmmJpBRM2TIEKRSKWzYsEH4fMOGDY4i4CD46KOP8MQTTziyLxSTJ08GALz77rtKoyaXyzlqeDQ0qoU317Wiq1DChNEDa92UUMGZZ23UaGj0SZRiOgYE0tRks1lMnDgRS5Ys4Z+VSiUsWbIEU6ZM6XFjbr/9dgwbNgwnnXSS57arVq0CAIwcObLHx9XQiAKGYeCs/30eZ9yyDB3dxVo3J1QUY7pK09DQqA7iGv0U2P00d+5czJo1C4cddhgmTZqEBQsWoK2tDbNnzwYAnH322dh9990xb948AKbw94033uDv16xZg1WrVqGlpQX77rsv32+pVMLtt9+OWbNmIZ0Wm/Xee+/h7rvvxhe+8AUMHjwYr7zyCi699FIcffTROPjggys+eQ2NKGEYwLb2PACgrbuAxmyqxi0KD3xAi9uIpqGhETkMw4gtWxvYqDn99NOxadMmXHHFFVi/fj0mTJiARYsWcfHw6tWrkUxaBNDatWtxyCGH8L+vu+46XHfddZg6dSqWLl3KP3/iiSewevVqfO1rX7MdM5vN4oknnuAG1OjRozFjxgz84Ac/CNp8DY2qgepN6k17EtcKvRoaGtGDDmdxGwMqEgrPmTMHc+bMUX5HDRXAzBbsx5L7/Oc/77jd6NGj8fTTTwdup4ZGLUEf9jqzaawU6fV2YhoaGp4whPfxGgN07ScNjYhQ30xNPP3pfQGd+aI2JjVqCnFsq2FDFNBGjYZGRIjzg98TGIZhRT7EbJVW79jRnsfkny3BN+9aWeumaPRh0LEtbga2Nmo0NCICNWTqSVAbZ396veODLW3Y0ZHHqo+317opGn0YRoxd69qo0dCICOJqpoYNCRn17FaLO3gmZ33ZNWqIOI8B2qjR0IgIBqn1GLcHvycoxph6rndYWVz1ddeoHeLM1mqjRkMjIsR5NdMTCAOaLtJdVehQeo04IM5jmzZqNDQiQr0KhYul+A5o9Q4dSq8RBwjjWcy6ojZqNDQigpinJmZPfg9Qr8Zab4DF1OgLr1E7GJqp0dDoezDqdPKvV2OtNyCulZE1+hZKWlOjodH3ID74MXvyewAanl4/Z9U7ENfKyBp9C0JkZ8xGAW3UaGhEhDiL6XqCej2v3gAd0q0RB+joJw2NPoh6zVNTrFO3Wm9ASYd0a8QAhjC2xasvaqNGQyMiGHXqfjK0pqZmYJdbG5MatUScs6Vro0ZDIyLUa5SQdj/VDpqp0YgDRE1NvKCNGg2NiFCvQmEhT41OvldVWELh2rZDo28jzgs2bdRoaESEOFey7Qnq1a3WG8CFwrFbH2v0JcTZBa2NGg2NiFCveWooUxOz8azuofPUaMQBukq3hkYfRJzFdD1BnHNU1Dt0RmGNOCDOujpt1GhoRASxRlINGxIy4pxNtN5B89TEjfbX6DvQmhoNjT6IetXUxHmVVu8oxZj21+g7iHMQhDZqNDQiQpyzbvYEcV6l1TviXEhQo+8gzos0bdRoaESEemU0RKFw/ZxXb0Cc84No9B3EWS+ojRoNjYgQZ4q2JzBiPKDVO2heoHrqUxq9CzRAIG5DgDZqNDQiQr3WftLup9qhXvtUrdCZL2L1lvZaN6PXgRrXcYuA1EaNhkZEqFf9gxjVVT/n1RugEx+Gi+/c/08cfe1TeHNda62b0qsQ54WNNmo0NCJCvYY+19O59DbEeTLpjVi91WRp3t/UVuOW9C7ojMIaGn0QpTplNOpVAN0bUK86rVqBsY4d+WKNW9K7EOcxQBs1GhoRoRTj1UxPUKrTpIK9AVpTEy5Y/+3oLtS2Ib0MtOvFrR9qo0ZDIyLUbe2nGK/S6h2GYNToa99TlDRTUxHi7AbVRo2GRkSoV1dBnIvZ1TvqVadVKzADvb1bGzVBEGfjWhs1VUJrZ17n9OhjiPNqpicQzqueTqwXIM5aht4IztRooyYQBNd67ZqhhDZqqoC12ztw2E+ewCX3rqp1UzSqiHqt/VSvhTp7A+qV/asV2DXU7qdgEHR1MRsEtFFTBXywuQ3dhRLe0LkQ+hTqNadIvZ5Xb4ChhcKhQrufKkOc3aDaqKkC2MAfN4tWI1qIbpoaNiRkCLWfatiOvggd/RQu2HOpmZpgEMskxKsjaqOmCmBzQDFmN18jWlAbtp7ufb261XoDtPspXBS1pqYixLnrVWTULFy4EGPGjEFDQwMmT56M5cuXO277+uuvY8aMGRgzZgwSiQQWLFhg2+aqq65CIpEQ/o0dO1bYprOzExdeeCEGDx6MlpYWzJgxAxs2bKik+VUHG3yKmqnpU6jXyV9PrLWDFgqHC66p0UZNIMS5HwY2au69917MnTsXV155JVauXInx48dj+vTp2Lhxo3L79vZ27L333rjmmmswYsQIx/1+5jOfwbp16/i/Z599Vvj+0ksvxZ/+9Cfcf//9ePrpp7F27VqccsopQZtfExjaqOmTqNckdfUa1dUboMPpwwXry+3a/RQIcV7YBDZq5s+fj/POOw+zZ8/GuHHjcPPNN6OpqQm33XabcvvDDz8c1157Lc444wzkcjnH/abTaYwYMYL/GzJkCP9ux44duPXWWzF//nx87nOfw8SJE3H77bfjueeew/PPPx/0FKoO5rfVRk3fQpwf/J4gzqu0eke9lt6oFSz3k84oHARx1nYFMmq6u7uxYsUKTJs2zdpBMolp06Zh2bJlPWrIO++8g1GjRmHvvffGV77yFaxevZp/t2LFCuTzeeG4Y8eOxac+9SnH43Z1daG1tVX4VytwoXDc7r5GpKhXRkMQCtfRefUGxDnqpDdC136qDHHOlh7IqNm8eTOKxSKGDx8ufD58+HCsX7++4kZMnjwZd9xxBxYtWoSbbroJH3zwAT772c9i586dAID169cjm81i4MCBvo87b948DBgwgP8bPXp0xe3rKbhQOG53XyNS1KumRgjp1n26qqjXPlUrsEuoNTXBoKt0e+DEE0/EzJkzcfDBB2P69Ol4/PHHsX37dtx3330V7/Pyyy/Hjh07+L+PP/44xBYHg9bU9E3U6+RfrwxUb0CcV8i9EUUtFK4IcXatp4NsPGTIEKRSKVvU0YYNG1xFwEExcOBAfPrTn8a7774LABgxYgS6u7uxfft2ga1xO24ul3PV8FQTrAPoQahvoV4nfzFPTR2dWC9AvVZ+rxVYX27PF2EYBhKJRI1b1DtQN5qabDaLiRMnYsmSJfyzUqmEJUuWYMqUKaE1ateuXXjvvfcwcuRIAMDEiRORyWSE47799ttYvXp1qMeNCqwDFOopA5uGJ+K8mukJdARO7VCvhnKtwC6nYQBdBT0++0WcGcNATA0AzJ07F7NmzcJhhx2GSZMmYcGCBWhra8Ps2bMBAGeffTZ23313zJs3D4ApLn7jjTf4+zVr1mDVqlVoaWnBvvvuCwD4zne+gy996UvYc889sXbtWlx55ZVIpVI488wzAQADBgzAueeei7lz52LQoEHo378/LrroIkyZMgVHHHFEKBciSlgZhWvcEI2qIs6rmZ6gKAxodXRivQD1aijXCrQvd3QX0ZBJ1bA1vQdxZgwDGzWnn346Nm3ahCuuuALr16/HhAkTsGjRIi4eXr16NZJJiwBau3YtDjnkEP73ddddh+uuuw5Tp07F0qVLAQCffPIJzjzzTGzZsgVDhw7FUUcdheeffx5Dhw7lv/vlL3+JZDKJGTNmoKurC9OnT8evf/3rSs+7qmD3vJ6yymp4w6jTyV+HdNcO9dqnagXqSu3IF7FbDdvSmyAs2GrYDhUCGzUAMGfOHMyZM0f5HTNUGMaMGeNpyd1zzz2ex2xoaMDChQuxcOFC3+2MC3RG4b6Jeg2/rdfz6g2oV/avFpDF+7qopX/EuahtLKKf6h3CJKBngT6DemU0aB+OG/Vc7xBp/9q1ox4gP5M6Aso/4qzt0kZNFUA7gHZB9R3E2e/cE9Rr9fHegHo1lGsBeSzWCfj8QzM1fRx0QtMuqL6DOEcI9AS0D8dtQKt3xHky6W2QDfJ2XSrBN4S+F7NuqI2aKoBOaNqo6Tuo1zo9MR7P6h5xpv17G2SmplMzNb4R5yg8bdRUAdr91DdRr4Ja7QKpHXSZhPAg910tFPaPOI8B2qipArRQuG+iXiegonBeNWxIL8c7G3bif//+ProK/ifTkmbJlCgUS/jtM+/jjbX+CxfLY7HW1ARAjAXr2qipArSmpm+iXvUP9Xpe1ca1f30bP338TSx9e5Pv3wg6LT2WcDz//lb85M9v4mePv+n7N/JYrKOf/CPOblBt1FQBdPDRRk3fQZwf/J5AFArXsCG9HLu6TGHqzk7/AlUqbtXX3sLOzjwA65r6gSwF0O4n/4hzZKc2aqoAQSgcsw6gER3qtZxAnP3pvQlWUk7/cfH16tLsKQrlQTbINZE31e4n/4jzGKCNmiqgpN1PfRL1Wvgxzqu03gR2HYsBcv3Uq/i8p+D19QJcE+1+qhz0uY9bN9RGTRWgk5X1TQgh3XU0A4kZhWvYkF4OowKmRtd+UoMZKEGuiTZqKge9cnEb2rRRUwVo91PfRL2uquNMPfcmsEm1EKBzxLmQYC3BrmUQJtwW0q3dT74R51Ip2qipArT7qW+iXid/UStUw4b0cljupyATMX2vLz5DkWtq/P9GvuyaqfGPONcg00ZNFUBvujZq+g6MOhV1ilqh+jmvaoNdu4qZGn3tOYpcU9MD91Nel0nwizgv2LRRUwXokO6+iXp1P+mQ7nBQCVMj5AjS+jyOUgWammpnFF63owOPrlqDQhBleEwR51xV6Vo3oC9AU8Z9E3FezfQE9Xpe1Qa7doViZROxvvYWKnE/VVso/JPH3sSfX12H/g0ZHDt2WKTHihpxzsGlmZoqQGtq+ibqlakx6vS8qg1L3FpZnhp97S0wF16QQAzZKIw6T8229m7htTfDcPyj9tBGTRUglEnQq6s+g3rV1BRjHPnQm8AuXTBNjbCHUNvTm1GqQFMj25JRMzWVRGjFFXFmDLVRUwXogpZ9E3F+8HsCUaxaw4b0clgZhYNoajRTowKTqQTRGckLzKiNGna4enhm4qyp0UZNFUBvepBVmUbvRr26n+rVWKs2uKZGh3T3GOxaBGEOmTGZTZvTYNTuJ2ZE1QNbX4pxsIA2aqoAzdT0TdTr5C8WVayf86o22KWrNGGcHkosMLF1kGvCDKCWnBkvUygZ6C5EF5lUCTMXVwh5amrXDCW0UVMFaE1N30T91n7SE2sYKFYwyem6W2r0JE8NM2qAaNkatqCth/sW53xJ2qipAnT0U99EvTI1xRgPaL0JlbifdO0nNSrJU8P6cS6dRDqZABCtrqaSvERxBT2DuPVDbdRUAdoP3jdRr4yGDukOB8yNV2lItx5KLFhMjf/fsMueSibQmEkBANq7o8sqzKOf6uC+GTHuh9qoqQJEpqaGDdGoKurVmBUzCtfPeVUbFZVJEPRMYbeo96KSKt1s22QigcasadRE6n6qQMwcV8R5waaNmipArP2krZq+gnrNUxPnAa03obKCltqgVIEbNQGuJWN3kklYRk2k7qc6FQrHrB9qo6YK0ExN34TAaNTRfRfGsJgNaL0JlWlq6Ht97RkqqtJd/k0qYbmfomVqxNfejDgb19qoqQIEoyZmHUAjOvQN91MNG9LLwVfuFdd+Cr1JvRb8WlYQ/ZRMJtCUZZqa6KOf6mEsiHNkpy5oWQXoPDV9E/U6AcV5ldabwPpEsOR7+tqrUKhIU2O+JhMJNGTM9X1nhExNJSH8cUWco/A0U1MFCHlq6qBDa/hDvboK6tVYqzYsjUWQ6CfrfR11qR7DYkEC/Mag7idzfR8pU1NBLp24Is79UBs1VQAds7T7qe+gXlfVcRYJ9iawibjSPDX62luwNDWVuJ8soXC07if22vvvm5BaoIbtUEEbNVWATr7XN6FrP2m4gV26Slwm8vu+jory1DCmJplAU1koHKX7qRLdT1yhC1r2cdAHTRs1fQf1OvlroXA4YJNboWKhsL74DDyxXQX6JJqnphrJ9+rhmYlzP9RGTRUQZ1HVq5/swBNvbKh1M+oScc662RMEXaV1dBfx3LubUdD5DARUkrekNzA1Kz7aiq/f+SI+2tJWtWPSa+jXBcW6oykUZkxNlAUty69xvXEBIIwBMXustVFTBcTZ/fSfd63A1//vJWxo7ax1U+oO9VrNWujDPk7rf558B2f99gU8smptdI3qhagk+qk3aGruWf4xnnhzIxa9tr5qx6xEvM7z1CQTSJVnwijH5/oSCsf3HLRRUwXE2f20vT0vvGqEhzhTtD1B0PNav8M0mLXhLMKoiKmJP/uXL1MgQYy1nqKS0h3U/ZRKJAL9thJYzFxkh6ga4pyDqyKjZuHChRgzZgwaGhowefJkLF++3HHb119/HTNmzMCYMWOQSCSwYMEC2zbz5s3D4Ycfjn79+mHYsGE4+eST8fbbbwvbHHPMMUgkEsK/b3zjG5U0v+qIM1PD2pOvhyctZugNroJKELSgZSUp7PsCKstTQ9/H83oWanC/KzFqeJmEhJmAT95P2KikPlVcEWdJRWCj5t5778XcuXNx5ZVXYuXKlRg/fjymT5+OjRs3Krdvb2/H3nvvjWuuuQYjRoxQbvP000/jwgsvxPPPP4/Fixcjn8/j85//PNraRJ/seeedh3Xr1vF/v/jFL4I2vyYQaj/FrANwsaKecEJHb3AVVIJiwAGNJx2ro2sQBixxa2VVuuP6yFrVqGtj1Pg9rOB+qgJTU0m0W1wRZ8YwcEbh+fPn47zzzsPs2bMBADfffDP+/Oc/47bbbsP3vvc92/aHH344Dj/8cABQfg8AixYtEv6+4447MGzYMKxYsQJHH300/7ypqcnRMJLR1dWFrq4u/ndra6uv30UBYSCK2UhUqmBg1fCH3jABVYKgA1pJMzU2UCO30tpPcZ0crey+1TsmDSDzy7bQMgnVZGrixtZXgjiz0IGYmu7ubqxYsQLTpk2zdpBMYtq0aVi2bFlojdqxYwcAYNCgQcLnd911F4YMGYIDDzwQl19+Odrb2x33MW/ePAwYMID/Gz16dGjtC4o4F7Rkq6l8gLBSDX/oDa6CSlAKSPXXYuUed1Sqsyv1AvavFkZs0D5pbme+phIJpLhRE3rTyPHqyf1E38frfAIxNZs3b0axWMTw4cOFz4cPH4633norlAaVSiVccskl+Ld/+zcceOCB/POzzjoLe+65J0aNGoVXXnkF3/3ud/H222/joYceUu7n8ssvx9y5c/nfra2tNTNshAEsRh2gVDJ45wySK0PDH+qXqaHvvU+sngSSYYFet8rz1ITapNBQSR2mnh/T6ly+o5+IpqaaQuF6IMXjrKmJXUHLCy+8EK+99hqeffZZ4fPzzz+fvz/ooIMwcuRIHHfccXjvvfewzz772PaTy+WQy+Uib68fCKuIGI1ERYECr4MnLWaI82qmJwiafK8Wk1zcUWlkHH1M43o5a5FkTrwu8XQ/sV3HaWFbKeqmTMKQIUOQSqWwYYOYrG3Dhg2+tS5umDNnDh577DE89dRT2GOPPVy3nTx5MgDg3Xff7fFxo4awKouTUUPaopma8NEXQrr9nFY9aQnCAp2EK81TE9c+xRZI1WxfsQIGi/0mlUgglbDvJ2zUU/STwNbG7LkOZNRks1lMnDgRS5Ys4Z+VSiUsWbIEU6ZMqbgRhmFgzpw5ePjhh/Hkk09ir7328vzNqlWrAAAjR46s+LjVQly1FSXN1EQKgdGoo8sblIGqJHNuvaPSNA+9oZhoLUL4qWHo93qyy5ckmpqo2hxXtr5S1FX009y5czFr1iwcdthhmDRpEhYsWIC2tjYeDXX22Wdj9913x7x58wCY4uI33niDv1+zZg1WrVqFlpYW7LvvvgBMl9Pdd9+NRx99FP369cP69WYmygEDBqCxsRHvvfce7r77bnzhC1/A4MGD8corr+DSSy/F0UcfjYMPPjiUCxEl4pqnRmBqYtSuekFviFSpBIFDuutohRoWRE2NDunuKaihEEf3kzAHxPS+BYGwsKldM5QIbNScfvrp2LRpE6644gqsX78eEyZMwKJFi7h4ePXq1UgmLQJo7dq1OOSQQ/jf1113Ha677jpMnToVS5cuBQDcdNNNAMwEexS33347zjnnHGSzWTzxxBPcgBo9ejRmzJiBH/zgB0GbXxMIeWpiNBIJFHg9PGkxQ5xXMz1B0ImV9bM49f1ao/LoJ/o+nteTnU81m1dJkVX2m1QyeqFw0IVA3GEgvudTkVB4zpw5mDNnjvI7ZqgwjBkzxtNy9vp+9OjRePrppwO1MU6Iq7aCPmg6o3D4iOt97ykCh3TXUShrWKg8T038mRp2PtU0Yit51th2qUT0TI3A2sb1xgVAnOva6dpPVUBvcD/FqV31gt6wqq4Eoq7De/taTHJxRyh5amJH/JuohbuxENDQptslSO2nqAjrSso4xBlxdoNqo6YKqHQAixq0Y+Zj1K56gVgmoYYNCRlBV8VW1urImtTrIOvZ/OpAghqUtUAtjBpRiOvvN6w/mlW6IxYKxzgBayUQLlPM+qE2aqoAI6ZMjRAxUA9PWsxQt0xNhRmF6+ka9BSyERM0YRwQXzeGFf1UxWP2xP2UTCDBQroji36yH7c3I86pBbRRUwXEOaMwg45+Ch9xpmh7gqBsgQ7ptkO+FH5TKogRdSE2KETUItliRVW6WfQTDemOqM31pq+L8/loo6YKiOvqig4EuvZT+KhXpoYa5oGS79XRNegp5P7g1+CL82TCUOsq3XEsk0CvRT0Y9zH2PmmjphoQmZratUOG+KBVjyt+/NV1+LdrnsQ/P95etWPWAvWqqQlKPfPopzoYzMNCGEZN3JPv1Sqk27c+iYd0VzdPTVyN0SCQ2do49UVt1FQBRkyZmlKNmJon3tyANds78Oy7m6t2zFqg3gYyhqAMlC6TYIe8hvBv1Fjv43o1ax/S7e83Rc7URB/9JGhq6kC+KBsxcRretFFTBcS1HEGtClrWIo16LVC37qeAVL8WCtshXwu/mrY4CzQZirWo/VRBeoqaRT/F9L4FgXxv49QXtVFTBVB7IU5BRrUqk8COVe/i5PoVCsurNPeTK2mmxobK3U/q93FCLYTCleSpMThTg8jdT5W4x+IMeQ0cpzPSRk0VEFc3RK3KJPSVSU6ojxKj+95TyKtZr9vIVqZx0pPVGvbop/rT1FSTlBZrP/n7Da39FLVQmO62HsY9zdT0ccS1QwvupypSSJqp6d2Qz8VrQGNdq97djUEgGyRFHxafYRhSuv2wWxUOauFurCRPDfuNWSah/FlUTI3gforkEFWFfAoxsmm0UVMNxJWpoRFP1TQwLOFoTEflkBDX+95T2N1P/raPk0Ffa8i6Cj+aNvk6x7VP1SajMHlfQfSTJRTW7ic/0ELhPo741n6y3lfT/VTsK0yNEPFQP+calHpmLGA9CCTDQiXRTzZjMswGhQTDMIimpnrHpUah/4zC5msiEb1QOK5Z5StFULa2mtBGTRVA73ecJnIh+V4Nop/q4eF2Q73mqZFvmzdTU36t8/sdBJVEP8V5ImGoRZ07wzAqElBb7iciFNbJ93xBa2r6OOKaUbhWDBJbVcXJwIsClfj5ewPkvuKtqWFC4fq5Bj2FfCkqYmpieDlrUY3aZuz5FV0r3E9Rre3ofuN434LCbmDXph0qaKOmCohr7SchpLuq0U/l49eDYs4FvSH8NihUegBPo0ZnFLahEqamN2hqamHU2I3sYL+j7qdqZBSO0xxQMeRziNEpaaOmCogrU0MfrnxVo5/6BlPTGxKlBYXqlnndxpJmamyQr0UlTE0cHx9B21KlIUW+dr7LJJQ3SyUTSEYsFK63oIE4u0K1UVMFCCHdMbr51MCqpvspbtFPL324FV/61bNY8dG2UPcr10epNt7duBNfvvFZPPHGhtD2qeonXpMIz1MTj9sdC9hCuisyauIzljAImX2rxdTI19K3UcM0NdELhQUGK47WKMw2nnP7clzzl7c8t41zX9RGTRUgaldq2BAJolC4ikZN+XrEhalZ9Np6vLpmB/72xvpQ91vr1dnStzfhlU924E+vrA1tn6rzcLuNpZKVWyWug3ktYE++5z0w2C5fDC9nLUKXe+p+SiYTSLE8NZExNeS4MTIAKD7c0oalb2/CXS985LmtLVggojZVAm3UVAGiURMfq0aoSVVN91ORrdzj8SjwAnwha3zoJF4LoyaK0HnVebhNXmLSsXjc7zhANvD8PAvydY7T6pghaF2wMGDPcB2MqUkmYLmfqqCpidEUICBIVGqc+6I2aqqAWoQ5+gGd7GqRfC8uTE1U0TlC9tcanGoUAt2gmppKCg32BdiZGj/uJ/nv+F3PQg3ut3zt/Gtqyu6nahS0rPECxw+CjMtxjsTTRk0VIApGa9gQCWL0U9/NU8Mm/7AfzKCFH8MGG0jDHESDMjVxTTxZa1RSJqE3CIVr4X6yXRefQxl3PyWiFwr3hjw1pQCLoDhH4mmjpgqIK1MjuJ/6sKYmqgKbtc7lwOzUMO1VOuCV5wHN1FQAe5mESlbH8bueAlNTM02NT6am/FykkgmefC8q11CtWVs/4Kk2fFw/zdT0ccR1tVqrMgmWpiYezuWo3E+1jhDg7qdQmRrrfTrpXdm4kpo8fQHyMOBPx+C+jzhAjPKp/jGByjQ1UVfprkX+nqCgjLUXW6OZmj6OWoVOe4G2y0/0RVjgvtuYJN+LKjlcrR98ZjSG2efovpI+JoLeQLvXAvbke36in+LP1PSq5HvcqCFVuqvgfoqTAUARJBxfMzV9HHHNU0PbUtWCljxvSTyuRVQan1o/+IyJC3MQZRMpTVjmtvtKCg32JlRqCFeWp8b97zigFvdbHlN7UqXbMKIxFntDQcsgHgVbSHeMTkkbNVWAYKXHqEMLQmEd/RT6JFFr9xMX/oV4XGt1a/7z2j8lIOI6mFeKpW9vxME/+hv+/Mq6wL+ViRlfmpoK3SzVRC00VPbr4u93vC+T6CcgmnZTV3+c5gCKIB6FWo9tbtBGTRUQ17oftctTE75bpCeIYvI39+f+d9SIgoFiu6IRI26XrZ7dTy9+uBW7ugpY9v7mwL+1sQsVaGpiNJRwiNFP9u8Nw0B3IdyxRr6WvkO6y80w3U/EqIngwoqJOEPffSgIklOq1q51N2ijpgqIa/QTdTlVM6MwO1TcmJow700lhR/DBmegIoh+SiYSJPrJjamJ/2BeKdg6oBLXrdw/Kol+itNEwuClqfn2/f/E5J89ga1t3aEdU77+fp9joUxCwjJqopAXCixIDO8bILGqHn3annwvihZVBm3UVAFCnpoY3f1aRWUVuIA1LtFP5deIooQYjCqfLru/4Z4XcT/x6Cfn7es5pJtdi3wFRk0l0U+9wajxCule/sFWbGvP471Nu0I7ZqX5e6wyCRDdT5EwNdb7OAq8gWBMjf0ax+ectFFTBdAOEBd2AhAH0mpW6Y6fpsY893Az78aHqYnE/ZRMgE0DfbVMgtWPgz879ugnP0aN+HccL6dXSDdjVcIMTKg0pLtImJpkImJNTS9wwwqsamBNTSRNqgjaqKkCal3Y0AlRRz99tKVNqdWJX0bh8mudGTXseGGuDFVZWP0yNXFiKcNAT1IT2Jkab8NIvo8xGko4vNxPbPEUqni9JF8Xf/tmm8lC4Sj6qZxVPo5sTZBkrHa9YHzORxs1EcMwDDGkO0YDe5T5c557bzOmXrsUP/nzm7Zjck1NTPLUWOUEwtyn4rMqn24USQVpSHfCT56aXqAlqBSW+6kCpkbqDPVS+8mvURMmS9vjKt2JBIhNE0k/tRteoR+ixwjiKo6zga2NmohhV4nHx0qnY3E+ZH3Lh5vbAcDmO48jDWuFdEfL1FT7vkdSJoGtbn2GdMvRMHHp+2GgJ25U+Zr5qf1UqZulmhALWtq/z0eQTVw2QvyOK2w7ZqDz/hzBuGRj5mJ474J4FORv49QXtVETMdRuiBo0RAH6YBlG2JlnzUGrM1+UPvdPcVYL0WhPan/fgxSo8wt2jRI+Q7ptk3dM7nkY6BFTI12GyqKfAh82clBjRWXAMv1RmCytbB8FrdLNjBnmgopEKFyK/3MglM0JqKmJkU1TmVGzcOFCjBkzBg0NDZg8eTKWL1/uuO3rr7+OGTNmYMyYMUgkEliwYEFF++zs7MSFF16IwYMHo6WlBTNmzMCGDRsqaX5VoeobcenQdgo8vNUTeyg6XIya2EQ/RZCnhl5aP4xGFIjC/UTDYNl5ueapkQfzOI1+PQQ7t8qMmuCTnD1PTfyuJZ0MVWUdLKYmvLbL45bfXVtGTUJ4jWJ8jrMRwBAkSWycE0EGNmruvfdezJ07F1deeSVWrlyJ8ePHY/r06di4caNy+/b2duy999645pprMGLEiIr3eemll+JPf/oT7r//fjz99NNYu3YtTjnllKDNrzpUNzsuRo2tUnAEEQmdeXHAKfQRpoZOOOlyYZmaFbSMgIFKJuBLU2NjF+Jhx4aCWuepicfTI8JNlxHVs19pqDu7f4yhSUVYqdvmIouREcAQJJeO3cCOokWVIbBRM3/+fJx33nmYPXs2xo0bh5tvvhlNTU247bbblNsffvjhuPbaa3HGGWcgl8tVtM8dO3bg1ltvxfz58/G5z30OEydOxO23347nnnsOzz//fNBTqCpUNzvMDr2jI4/n3ttc0cTlNuj0FJyp6RaZmjgW94wiozA9NTZYVvvBZzqNKM4rmbSKALrt35YYLU6jXw/B3U8VPXvy38ELWtrCwoslPPfuZrR1FQK3Jyy4ZRSmjFa40U/i30GZGm7UJCJ0Pxny3/F7DsQM88HcT3E6n0BGTXd3N1asWIFp06ZZO0gmMW3aNCxbtqyiBvjZ54oVK5DP54Vtxo4di0996lOOx+3q6kJra6vwrxaImqm5+k9v4Kz/fQF/f2dT4N/ajJoQFaVsX10F0aiJM1MTauZdct/5CrBGTE00yfcSYJlqXEO661hTY4V0h+F+8vMb6W/pN39+dR3O+u0LmL/4X4HbExbcku/RJIVR5qnx65azop/Mv1kyyUjcT7K7JobPQZAK6+xbK6t4RI2qAIGMms2bN6NYLGL48OHC58OHD8f69esraoCffa5fvx7ZbBYDBw70fdx58+ZhwIAB/N/o0aMral9PoRSMhtgDPtrSBgDY2NoV+Le1YGrimGE2Su2J6aZhn4W2e39tiMJYIxOBpalxcT/Jq+iY3PMwwPpLGO6nSvLUyGPLhtZO4bUWcJsYKVMTblBCZYazrKmJcvFRaRuriWBVusssF09aGJ/zqdvop8svvxw7duzg/z7++OOatEMpFA7xoWntzFe8z0qymvoF19RIxevkkO44iB2j0dSYr2KSuhoxNaHqF8zXZNJn8r1eoCWoFMxAqyQdQmXRT+Lf8qVk+6hl/ie3jMK0XaGONRVGhbH7x4yZagqFY2jTCGyht1FjvqZ8lEqpNtJBNh4yZAhSqZQt6mjDhg2OIuAw9jlixAh0d3dj+/btAlvjdtxcLueo4akmlIUNQ+wBrR2m/7ySBzFS9xMxFPLFEjIp036W83EUSwbSqYTt99VENNFP1irQD6MRBaJgoGjCMgPe16030O6VomcZhYOv3L10DOzZqqVb1z9TE95YU2kkTlFiathzWh2jJn7PQZAcYmwsSycT6EK8nutATE02m8XEiROxZMkS/lmpVMKSJUswZcqUihrgZ58TJ05EJpMRtnn77bexevXqio9bLdB7nS4/NWEOOjs68uXj9HxgraQwnxOogUTDuuXwyzjoakrEAAttn+VdJRLwxWhEgSjKJPCMwj4ZqHoO6WanVqs8NfIvOFNTwxAzd01NSbldT1GppoZdpqQU/RRFF5VPN47uJ3rd/Ba09FPUttoIxNQAwNy5czFr1iwcdthhmDRpEhYsWIC2tjbMnj0bAHD22Wdj9913x7x58wCYQuA33niDv1+zZg1WrVqFlpYW7Lvvvr72OWDAAJx77rmYO3cuBg0ahP79++Oiiy7ClClTcMQRR4RyIaICHYjSqQQKJSO0Dt1dKHGDIQymJtzcEda+OvNF9G/IAFCvUA3DwDfvWolRAxvxwy+OC60NfsHaGuaDaWlP/JUTiAJRFrRMJIAkK2npsnt58orjYF4pelSlu4LrIncfJ7anltdYTL5nTpSs/9PrFKWmJnD0k5ynpgqamlgyNQH0jiXC1ADgrG0cENioOf3007Fp0yZcccUVWL9+PSZMmIBFixZxoe/q1auRTFoE0Nq1a3HIIYfwv6+77jpcd911mDp1KpYuXeprnwDwy1/+EslkEjNmzEBXVxemT5+OX//615Wed9VABaOpkCe3nWU9DVCpUSP+HWalbtqezm7nFVqhZGDtjk785bX1SCcTNTFqLEFtmIyG+SqUE6jyApodL9QJhITBFn0Yg/Wdp6ZyZqSyKt0yIyF+z/YR5nMcFPKhDcMSykcmFK4wwo67n8rTVSrC6CebyDuGz0Gw2k/ma6p88eJkowU2agBgzpw5mDNnjvI7ZqgwjBkzxhcd6LZPAGhoaMDChQuxcOHCQG2tNQTBaMgPTWunlY8iDPdTFNFPANBJwrpteUtKBvIFq8hdoVhCOlVd/XrUoc+1FgqHykCR8zIC1n6ibaoHsPOuVpVu+Td2pqZUfo0HUwOY95sxenFyP9FCw6mqRD+Jf8eRqfEb/USvb8pHrqpqo26jn+ICOgmE/dC0dlCmJvjv7a6BEJkaMtDTsG67IVUSBrvuGqwy2SGjyLybEEKfQ9u9L0TifiIh3QkfRk09134Ks0yCH8PIM/keb0/trrE8pggJ3QIwAUFQSWQRPX4thMJxNO79Rj/Rr5hBGKfT0UZNxKAaBJ6xMqR5u1VwP1UwsEodN8zBkIa5dgpCYQVTQ47bXai+UcMGnHCZGvM1maydpibKTMk0pNtt9yotgWEYuOSel/HzRW+F1q5aoCdVug2+2BH35ec3DE45gGrL1Di3MV+IhqmRDUI//Z0eXhYKR1OlW74uMbICyvBbpVtILJqqzdjmBm3URAwqGE3y6KdwJu4dPWRq7CHd0VDCNPpJdUy60u2qgVHDIrXCfDCFKKEaUbSW5iUqt5r4mVsb6N/rdnTikVVr8b9/fz+0dtUC3BguBc+3xLo8S3XgS1PDonUcMiAUemBkhQU3poaWkwg1pLsCpkaV8TtKoXBvyFNDDS23PiQEv8RQU6ONmohBBaNpvhIIZ98sRw1Q2YNoK2gZQZVuQCxqqdLU0ON25WvB1JRfQy2TYL4mEv6S1EWBKN1PKSGqy7sN9G9mxDINVW8FPbegLCebGLIp/8VOrYgT9W96UrYhLNiiuqhRQxYsYTaxksgi0f1kvkYpFLbX+oqRFVCG3zw19PL6WdhUG9qoiRgqwWhYKwHqfqqEzpR/EypTQ/ZF3U8qHYDgfiqKZRWqgSgmf1pXxnLT1IqpCe/YQki3H6ZGoQOhBm8tNFRhgT4uQXU17H5k0mWmxpemxnx1Yv4KEfTjoJBX+EaJfhdN8j1bH/Nx/vQ31SiT4FXiIg6g182tffQrzdT0QVDBaNgrAUEoHDumJoimhm5bA6FwxNFPtar9RM8nrGMXFUa622VT5WOh/b8WzFxYEOj6wEyN+ZpJ+R8TrCyujKkRv+fC5RrGC7uxJt1RlUmwaWq8f0ONLXuZhNCaxtEr8tQY/vozbXsyQkOwUmijJmJQYWXo0U89ZGqqUdASkDU1ckbhkvAA1Sb6qcxohHj+Yp6aGgmFfa68goBrhQShsAtToxjMa62hCguC+ymgIcHuh6Wp8R/SbWW+dWBqahr95FzrrVClPDW+3E9UUyMxNdFEP0nHj6H7iTbJt1CYs4ZRtSo4tFETMQxhZWt+FlaH3kE1NZW4nyoIK/ULIfle3tmXXiwZgiFTi5V7lILahE9BbRQIUsvF9z5LFvPoh4GSu1SxJLalq1B9d2NYKPlc2arA7k227H4KUvuJa/Ns19Z8dvI1nGHc8rFEladGXoz4cbXS6836cdjJUSl6m1DYbW0phHTzRLvxOSFt1EQMztQkLNo4Lu4neSAOMxNpwUFTY2dqDGHbak9y4oMcgfspCV9umihAL3VYAzVlC3zlqVG4nwqCUVMnTE1gTY35mg0S/URYMnMf6kVJnJLvCSHd5DkPkxWtpEo3Dalngnc2P0cjFO4F7ief0Wm03zkZ2LWENmoihrBiDz2jcM/KJESZGE1kavxraqqdpyYK3QndVxxqP8nve4KgmZJVIb6CEduLNTWCayXg9WWTOq9e70tTY746MzXmB7WMfnIN6Y6IqbGNKQHcTykSHx+lULg3JKH0y+yKTE38NDUVlUnQ8A+h9hNbCYSlqenoae0ny5VgGOHS1k7J9+KWpyaKiR9Qux1rKhQO6bLSjMK+hMKKwTyRoPe7F7ufBKFwUE2N+cqEwoGYGoeEZ3HIU+NWJJcas1GkGWAI4n5ifZi+r0ZG4TgZAQwCa+3SPKFMQo3SVbhBMzURwxKMJqwOEBpT07PaT6zj5nhYaTQFLV2T75VKNc0oLBg1oWpqzNdETITCYZ2byECxz5z3rar9JLobey9TQ0+t0jw1QZga7vpzMCZ7kuE4LNjrMFnvuyNiamw6Hh9dykpkaGdqIjFqKmhjtSEyNc4NpJeHueyqna7CDdqoiRh0RRC6+6mHTA2b9HLpVKjtAmRNjXuVbiH5Xi3dT1FoaghTU/U8NYJrLZxjBw3ptqfNl0K6ezFT0xNNDU++lw4S/SS6TFR11IDaup/cCpiKTE34GYXTAVwh8rUEohUKVxKhVW3QW+fWhageqVZ6QTdooyZiCHlqQqQ3O/NFwQDoSZkExtSEWfvJiamxCUeLYvK9WgqFoyknYAkRq706o/cgLINNDOku79tn+CdrkyAU7sWaGrFYY89Cuv2EYdvz1KhdPSUjXAM9CHxrakIca9i1T6f8u0KK5PlksBadoTWNozcUtPQ7FlK21s/21YY2aiIG7QCc3gyhA1CRsHmcCpia8m9ymfDdT36T7xVqLRQWHuTw2BTqdqxVSHck7ieiw6q0oGWhHvPU9DT5ni92wXy1op/E7+mzVSsXlN39RK4RGRPCfBbkOlq+mJqSM1MTSe0nBWMZNzjpn2SoggViZNNooyZqUKouTJ8trftU6T4tpsZ0P0UVkeAmFC6WajvJVRIO6gdinpoa1X6KIk8NMdb8RHXZ7zekkO54up8Mw8C7G3e6Tj49yVPDyyQE0tSUmZqUu6bG7/6igD260XqfL0RjdMmRZEGS7wlC4Qj1IfLpxtCmEccLl2vAvvFbKqXa0EZNxFAxNWF0AJmp6UmZhGyArKZ+4aSpUQmFu2MiFFb9XSms+1672k9CnpqQLit1P/lKvqcSCtdQQ+UXd72wGtPm/x13LvvQcZseZRQubx4sT4356qipKVbenrBgYyQcXHRRZBQOkjOFC4UJUxNl9JM8PscxpFtwP7kZ81QnqpmavgeqqQmztggVCQP+fPIyOFPD3U9hUsLWvtyin+xMTXVX7lElxYpD7adCBHQ/TQNQUUHLUu/IU/PRlrbya7vjNn7pehVkoXAQTY2ToFVgampUKsFWJsFBTB3FWBPI/SRdSyDa6KdeUdCSNMnNyGZNF7OKx+d8tFETMejkxldYITw0O2SjphKmRhIKV8P95KWpqfbK3RZqGZqmxnI71iKk2zAMMZoh5JDuVMJf7SfPgpYxdT8xjYwbeylMAgFXKux+ZIIwNZIORP4JbWt8NDXW+3xEeWrYvpiBGCRPTdWinyJaPIUJv9GS4oKtPAZE27RA0EZNxBAFo/4TbXmB5qgBKjOUSnwwKGtqIhMKOzMGZkbhGrqfIqKF2embmaTLn1VxILP58ENzq9mpZ1f3kyLqIy8YNfFkapih7cYoiO6nYNeXXZZK8tQwTY25H7WhEKYrOQjcsvuKGYVDzIkluZ/8XEv2G0LURBz9JB0/5u4n94zCwdjaakMbNRGDdoB0mNFPZaamJxFV7Dc8pDvM1ZND7Sd5kqg1U+NWq6YnKCmYmmo+9275QnoC7k9PWhOCe5Vu+++LvSD6ifVJt6gmYcIOeB48pDvNFjpB8tRYwza99EL0U43cT66aGsrUhNg8NtakufvJ+zdUG8YQaUFLFwYrLvArNKc60QR0RuE+B6VQOBSmxjRqBjZmAFQa/WS+5gL49f3COfpJ8rkXS8Jg54epWfLmBvz0z2+EwizZqoaH7aZJ1qb2U1S1Zmh/9sXUyPfbkPPUxNv95JpZtQfMCPtplkzEXuMCu6VpMhHT+yy2pzazjC1PDfmbZhQOM/me5crzL8hnTaGamrCTo1L0htpPJQfWzw6yYONFuuNzPtqoiRhCteYIQrp3a84Kx6mkbSykO8yIiaI0wLKVr2w0FEqGcFw/Gotr//o2/veZD/DPT7aH2k7V35VCDOlmn4Wya19w0zb0aL+C+8n8zD2kW/y7VOodVbo5U+Ny00TXSrALLCffk/fn9puUYNRY39PrGqbREAR27Yj1vhCRUNge0u39Gyp4Z+C1+SKJfpL/jo8RwOBXKCwwNbr2U98DLWyYCtH/yNxPuzX1hKkpGzURRD/JK1fG1qirdAeb5Nq6C+V99nzgjqrQnMr9VE2mJiqtkJhRuLKClsVeZNQ4sYGGYYiun6BlEqSJGPC+R1SkbX2mXl2HmR3cDcWSgf+49QVc+ehrALwyCvtlAgK2QWJq4lgmoZKim9WG3wzkqoheranpQxAFoyEyNcz91JQVjhOsbYyp8S9W9LtfeVcsrFt2cRVKwZPvsSReYVDs0YV0m6+1qv1kizoK2VhLJABUVNASkoYq3u4nJ0Pfnm+pUqbGmlS99iFX6QacNTXVcm98sq0dz7yzGfe8+LHZRhf3U15wP4Vo1FTA1FDBO0N13U+hH6LHEAxk14hG8zWRYIoazdT0KdAVO/OFhxL9JDE1lUQT8OR7vPaTv31s3NmJC+9eiWXvbVF+rzo/lo9ExSAEFQpzV1YIFLuKOQoDlKGrBUWrKiQZzn7N10qjn2wFLWOap4YzNQ4nJ59XpWUS2LMHePc9q/aTN1NTLU0NO05XoQRD0kuZ7bPei9FP4Rs16QCaRbeQ7ihcQ1EJ98OEf6EwZaHNz+LEPKVr3YB6R3RCYVFTUwnbzAaWoFW6F7+xAX9+ZR2KRQNT9hls+57uJ5dOoqtQspgaxQo3aEh3t49wW7+wuZ9Cjn6qVdhjddxP5meuOS0Ug3lv0tQ4LRbkUw7qfpKLUwIB3E9kIqa/EPLUVIkKkF2JrlW6I2KSepJ8jzI1YY7PMliTEgnzfZyMAAa/Ro0qTUmcTkczNRFDlYQtzJDu3bj7Kfg+ZfeT35Du9i7TQOl0cB3QwbVfg2k3O2tqSoHdERZTE777KbzQZ/PVL6MRNuS5OKzzEjMKe0ebqJiwWmaQ9gtmaDsxMHK/CZoOgW2eJsahF9taiiNTI+nh2DmoMs3SBUuYRo0suvZV+0lVJiHCPDVc95MM19UfJuhlc6/9RAxCnaem74H13UTITM3OLpOpGdCTkG4pT43f1R2biPzoDVpyplHT0e2mqQnmjmCDYxgDtyrjbRhQ56mpHVMT1qGpWDXhRygsRZn0tugnp2fC7n4KmFG4fA2SyQRna/wzNSRPDTlsLfLUyNmheXZfZmA4GFpRZC+3hMLev7HKJFifRSoUZgZpgDb2BNvbu7HkzQ2BGDuhoKVrlW7zVVjYVNbMSKCNmohBa4yEydSwztqQ8b86oaDRG0HLJLCoo26HB4aubpuyZaam4KCpKRrCfpz2ybcnIuQwDBD5nMMyPChFSyf0aiF6Y81fqLpcDqBo9I7aT1aeGvXJydc3cPQTMXrZYsfLELFcf/b9lEpSNFaVQrqF4qT5kt2oIW0ShcLhtY/dC5Z8z88zLJecACIWCleg++kJfr7oLZx750v46+sbfP9GcD+5uZRr7Fr3gjZqIgbNU5MKid6k0UVB9TAMgu4lE6xMgsXUOKxiyQPcmDX3zZkaNugRQ0ocGN3dEWGLDVVp/MOAmKem+u4nt3T1PUHQUHXVyl1kauLqfnLPKGxzPwVkRqjR6ze9v+V+Sto+s9VUqxFTU5Ceb6eMwqEKhWXD2Y9QmDyfDFEKhVmTqHEfJdZs7wQAbN7V5fs3TokcZRjCwkZravoc1INXz6waOiBkK3xI6PaVMjVOAzkzUlLJBGeSuCEk6XiKkvvJi6kJOytpdIyG+Zqs0Womqugny0j3F6puq0ZtGMJ9i737yaGP2ZNIVsbUJBJWiLZ3SLf5SsWtTqxltaOfAHNcsIl2S+pnO1yhMMrH9L944NFPglDYfI2CReELvQC5dHqCtrI8IUg/8KvJov2wFiy0F7RREzGEFXtITI3IstgHD1/tIm2wNDV+jRrTQHHSEdCBraHMJLHfyOLkQkl0P7HQUCfQGjuR5KkJvfZTbVYzUaVlpyHdfkLVrb5g9X1ZXBpHFDzy1Mj9JCgzQvtHUKZGCKUFY2rEBlXL/SRHP3F9S9reNwqRGTXmfhmD5cf9xDapmvtJFjNHbAQwoybIwk9IvucjojGRgK7SXe+4+A8v4+t3viQ8VHTFHpYQjQ5YjKkJOsGLTE3Ktl83sInIyahhDE4qmUCD5H5ix7DcZmLtJ8NwP5ewV3u2yT80TY3ldqxF7Se3dPU9AQ3pVkW4OLWDRqb0htpPPG2Aw4XrcZ4aVnsoaQUQeD1/nPVVZHOOqtyHF2RXopwp2amURCQh3QpDyus3NPopWveT7CIL/RACWNb1IPOCEP3k5n4qv/otlVJt6Dw1IaGrUMQf/7kWALCjI29l+qUr9pBWAtQI4L7roEaNYh/BmRqHAZ9oajhTw4TCCqZGNo66CiUhfTwFyyYcpL1uiCr5nhUhEI/aT2GXfxBTpHu3I0v0DoXe5H5ymH1sQuEK3U90sePJ1JTka2/UXFNTEgxUi6nJKkS7sh7OMAxB01JxG8qHyAYJ6SbXn4EZl1HMz6yNXCgcuftJHW3qBqecQjJo362bKt0LFy7EmDFj0NDQgMmTJ2P58uWu299///0YO3YsGhoacNBBB+Hxxx8Xvk+UqWz537XXXsu3GTNmjO37a665ppLmRwKnxEWGavDqMVNj/b5S4VlPNDVsInIa8KmmpjFr7ttJKCzXfgLcV+9hMzX2wo/hTv5inprqPfnVcD/50dSwW0tFnLJgNI45O5ib0yn/jE3DUqH7KZFIVKapkQxlu6amWtFP1nHbu63nViXalRcvYd12axHlXyjMo5+IUZXwaVxWAjlCK46aGmqguguFzdcErDEgTkrhwEbNvffei7lz5+LKK6/EypUrMX78eEyfPh0bN25Ubv/cc8/hzDPPxLnnnouXX34ZJ598Mk4++WS89tprfJt169YJ/2677TYkEgnMmDFD2NfVV18tbHfRRRcFbX5kcMqWSVfsYQnR2ICVSSUqjqiibcwGzFPDmJruQEyNWiisYmrcxMJhRz9FNfkLQuHyfa9qnpqImBrufqJaIZftuTsibRl2ctv8ZJGuNpgx4zdPjZfAXQY1UNhk7DUuqDQ17Dc2pqZKhiLVbDCXB2AX7dJUDAxhGV6yCNdPV+fXX3A/lfcXqfsp+gVOoVjiC88g45mQp8ZnSHddVOmeP38+zjvvPMyePRvjxo3DzTffjKamJtx2223K7W+44QaccMIJuOyyy3DAAQfgxz/+MQ499FDceOONfJsRI0YI/x599FEce+yx2HvvvYV99evXT9iuubk5aPMjQ9EhXFHMR1GZ/kVGgWhWKqUzaZVaNqj6zYrKmRqHQanAB5kkD+nulJgarqkpGraJwy13Sdi5LuS5KHRNTYS1n3a05x2/i4ypUQ1oLvuWNTXFkmHrZ3EL6zYMA161n3qap0ZgcH3WhHMLpbUltayS+0lgaroso0Z2i6v0d+Gxh8ENhiIxzhmiLJNgDzsP/RAcbYQxqzT6yb32k/laKxbaC4GMmu7ubqxYsQLTpk2zdpBMYtq0aVi2bJnyN8uWLRO2B4Dp06c7br9hwwb8+c9/xrnnnmv77pprrsHgwYNxyCGH4Nprr0WhUFDswURXVxdaW1uFf1HCi6lJhsjU8Ic4maxYp0NDGtOpYPvgmhqHFTYbUNPJBBoyLPpJXDlkBabG/6o39Dw1kmHUW2o/PfXWRoy/+m+45e/vKb+XL2FY4zTbj1j7yW378v0mtLt8zeOmqymWrER2jlmzbSHdQRcV5muw6CfzNSGwZIypkaOfqsXUWMdpU7ifnDQ/8m8pFjzxL5x4wzPY2elstAv7kSOLAiTfIyl/Ik6+Z75WQ1PTRozLIAs/v0Jhmnst4WMMqDYCCYU3b96MYrGI4cOHC58PHz4cb731lvI369evV26/fv165fZ33nkn+vXrh1NOOUX4/OKLL8ahhx6KQYMG4bnnnsPll1+OdevWYf78+cr9zJs3Dz/60Y/8nlqP4RTjr1pd9VxTU9aspBJWRFWFRk0yaT1oflO9d3noDcQ8NeXop7zM1LAVSwl54k7LFw1XpqYr5PoxUTE1bL+pRDTJ995YZxrpb67b6XB8yf0UllutZO/PbgO0nIxN1tQA8csqLKbzd09bwNCTMgl+mRpBoOmlqalSQUt6L9uJ+0nOKKxqj9Pz+8dVa/H+5ja8umYHjtxniGcb5IgrP49wkfRjhmqUSahGSDe9D1EwNczfLOjqYhTUHbvop9tuuw1f+cpX0NDQIHw+d+5c/v7ggw9GNpvFBRdcgHnz5iGXy9n2c/nllwu/aW1txejRoyNrNx38qHVMIxZSIa0EuHuHDIhBJ2NavoE9aH4p6y6feWpo8j25oCXLr9NdLPFBqDmXxvb2vKs7Iu/g5qsU8nULO0pIdBWE9+B7ukciClVXTayuyfds7id7m+PmfqJMYb6ojtKRT7nyPDXwnZTTjfavnaaGMDVdCqFwuX3smrIq1W5tZIscv+OkvfaTD6aGuN8ZomRqZN1PlBmFd5H7ULGmxgdTk1C4QeOAQEbNkCFDkEqlsGGDWE9iw4YNGDFihPI3I0aM8L39M888g7fffhv33nuvZ1smT56MQqGADz/8EPvvv7/t+1wupzR2ooITUyO6n0LKU8PdO5b7KXCeGsVK0bf7qcyWGIb5Gzow0LbQ5HuMqZHdER2Esm7OmkaNm3A0HzJTI6+YwlpBiXlqyvsO8cm3ksP5YxJCr/2U9Jl8TyGQtBs18WJqZLdqyRALHwIKpibg9TUU44Lf2k8qg7Kn0ViVQox+MhkCmnuHtY+1J5NK8lIZTn2S6YP8jmlWXSX/kaB00cFgRaf6OmwgsFOxEgSGfwwG6n6qNPrJXShsvib4f9EyT0ERSFOTzWYxceJELFmyhH9WKpWwZMkSTJkyRfmbKVOmCNsDwOLFi5Xb33rrrZg4cSLGjx/v2ZZVq1YhmUxi2LBhQU4hMjhVyFXVygmLqUklK3c/CULh8oid95t8j4RcKwWARMjMhMLMxcCuTS4tam0Aq6K32yQnaGpCGH2im/zN16hqP3kxNVExUKqQ7iDJ90z3k6ypiRdTI19TZR+XNTUVFrRMJPyHIrvVE7P342plFKbRT+Z9pIkZWbvYNcwkE54LMWYg+s2xwg1nLk72027zVTBqIhQKy9FPUaYxEDQ1Feap8aWpIXNafEyaCtxPc+fOxaxZs3DYYYdh0qRJWLBgAdra2jB79mwAwNlnn43dd98d8+bNAwB861vfwtSpU3H99dfjpJNOwj333IOXXnoJt9xyi7Df1tZW3H///bj++uttx1y2bBleeOEFHHvssejXrx+WLVuGSy+9FF/96lex2267VXLeocM5T435GkQQ6H0sS4PChG5B6UxuGCUSyJDVg4p5kdFZoPR8ietmrH2ztOXE/VSQNDWSWwoAmnJlA8jFqAm79lPUSeqiqv3EroPXape3J2QGyq9WiB2X1iiT2xw3TY3MFKomX3v0U2WLCoGp8SkUVhmUtXI/qaKfqFucfc3cxpl0EkahhG44T7gFbrD76xdW4IR/N6+1qLM+q0aZhHSFecWCoK1CTU3JYQ6TIepEy7+Nkf8psFFz+umnY9OmTbjiiiuwfv16TJgwAYsWLeJi4NWrVyNJJOVHHnkk7r77bvzgBz/A97//fey333545JFHcOCBBwr7veeee2AYBs4880zbMXO5HO655x5cddVV6Orqwl577YVLL71U0MzUGk4VaGk12LAeGlqGIEV8mkEydAruJ8KtF0olpJIpp58hXywJ7VdlFaZMEhcKs5Buyf3EjJpUMoHGDDNqaqepCUtfqdI/hPncFzwoenv18XCOS0O6LdvXhalh95uE+Mbe/SR1Aj8i16BCYfZzypQGqf2UkPqUPfledSYZVfSTYPBKTE06mUQxWWZiHB4I1na/52AvxeH9mxIZoxiiLJNQieEl45l3NmFDaxdOnbiH63ZtgqbGf7+k181P8r24VumuSCg8Z84czJkzR/nd0qVLbZ/NnDkTM2fOdN3n+eefj/PPP1/53aGHHornn38+cDurCSemRpkO3WcH2LKrC6+u2YGj9xsqJImiGTRT0udp2fnvABpimCFGaKFoIOfSK+QJyC3/RDpFQrodmBqmtUknE3zic2VqQo9+ioapUeapCXGiyXOmxl8a//CqdJuvKaqpcRk33dxPTDQaN/eTbKgrw5GlfuLXdcugovC989Sg/BsVUyMbYjVgapimJmWvC8bak00lUCy5C6PZtn6f76JhjTf0mH5+kxDcT+U2R2AQsiapMi37xaX3/hObd3Xh6P2GYFj/BsftKtXUOOlCZViudS6piRVTowtahgQ6qND3KkGg34fmqj+9gXNufxHPvrtZOpb1EAtGTYCOVSSTLjWEvAbDTqmEgcqooULmRs7UiJSyrKnJppI8zNtVKBx2RuGI3U9inppQdg3Amnj95lGJIqmgn5Bu+yraYmqas94aqlrAztTYzy+sKt0JwS3tFf1E+5QXU1MtTQ0xarqsBYrMejB3aTqV9ExCytrup0ioYVg5hYLUflKVSQgr5YYKtuinCm4Py9uzs8s5Pxsg56kJPicA7tewpFiwxcim0UZNWBCsXCoU5m6e4D7bT7a1AwDWt3YKnxc4lSsaNUHGMRp2nSb78BoM7UyNyv1ENTXMeCkKbWSsDGNw0qkEN3T8CoVDYWps7qdwGY2osm56CoUjEkCz/fg11rhRk7b6Pns+mnOiiDwukI0aN6EwmxMrrdJNFzteE51bn6qZpoacdxuJfpKNLjZmZVLWeONkCLK2+3Gd0H6dDuJ+IowjQ3WEwvZCn37B3XIefa3SjMJ+NTXqorbxsWq0URMS6KDmVPspqFB4V6c5SDgJF9OppKDeD7LCoNFPiQBiRZmpUekNRE0NcymxPDWMqRFDGzOpJDd03Jia7pCZmshDnyMSCrPr6DdPTXjuJ9pvzM9c89RIq+iiAQVT0/vcT+x6spQFQZkRGp5trd79MTVUx8+aZi+TUP3oJ8bUpIh+0NLUWJO6WwoJIZuzjz5bEIya4O4nOn7yRWcEEzQXCld4DIMI7L36WqVMDb1ubteeeh/imFFYGzUhwTlPDZ3cgnVo1jltRg0VClP3U5DwvZI4QPrNKiyvqlUlDSjVytiXfNF8KOXaTwwZ4n5yFQoXqPEY3+gn8cEPfzXTXXBfzUZWJkEI6a7A/VSyyiQ0+wjhjwKGYeD9TbscjTHZIFBdY1kbFtT9RCdVvzXhrNxHVtRjzZkaQShsaWrYuMLO08oannRdQAVlYmnfywbI1luSxj+AaB4j6I6sSUHYJArf2X5RGVNjGGLBUbdrqHKtV7NYrxe0URMSnDIKG8LgFYypYb5T2XCg7p1UpUyNpP73yyJ1FmSmxr69ZXQlOVMDmMaKXPuJIZ3yJxQOPU9NVNFP3E0TTZ4aztQ4XAN5UAo/o3Cw5HuqMglNWW93YxT43fMf4XPXP427Xlit/F5+3lSuJXZezBCvNPopUO2n8iFUmVyjYhy9oGKlaQAD+4wlNEyn3Ivw0knYj0uPHr+SMgnVcj9Zxn1lxwhyXSqp/SQ3x228UC3YYmTTaKMmLPjLKMw+8+4BhmE4MjUWE5JURkX5aq9Ev7IVhNcD40coTMMXsyQRRFe+ZJVJkIwak6kxJzm/7qdIMgo73Jv27gL+9M+12OUh0rP2Y74mI1rNWNFP6n3aku/VyK1mK5NAhcKMqclX1/30weY2AMCH5VcZNveTUigsMo5BmRGacbqS2k9y6Y1aRT+p+h/V1LDrRLOMu2VQLgpu/KCaGv9MOH8+aZmEiITC9Nnzm2hRhlPBZBWE6Ce/CQwDGMWqfqg1NXUI5yrdlKrzz9R05Iv8wXNyP7EVTyXlF6juBbBWEGEIhRnVbObgSPJ2dhWsHDeyUZNOJny5n+i1CINil/fhdA3vfO4jXPSHl3Hjk+/62q9Q+4mvAHvQUAl57n5yMGoiYmrY7RZyVLhszwtakhVqocbuJ/b8OLErtugnlftJYmqKJSOQ4VgRUyOskMXPahX9pHoGUwrXZJ4Ihd0Yaxoa7+f5FpiaZIDoJ6YNq0JGYdqeILofCmrseWpquoNramy14rSmRsMx+klgavwbNUwkDKjcT5JRU0H5hZK8D5/1Z+RVtVuZBPYA0wgoJ/dTNu1PKBx29JPNTeOwzw3lCLRn393ka7+qOj2hRj/VSCjMMwonE54MFD2mkqmpkfuJHb/boa/bjRoFo1D+jGbTDpKrRshfVUHtJ8/op5ozNeXvuVFjMTVplwWUkMTUj/uJ9L0UNxj8t1vQ1FSYnd3zWCrdT8BjCMaep/spuKbGri10ea5VmpoYFUrQRk1IcGJqDMXg5WcyprkI7NFPln8aqKz6N80oDFi0qNdD4Cf5nswC5YhWxkkoLDI1fvPUhCAU9rlCYYnF3ljbitZyvgg3sN1EXvvJZ0HL8Go/WQOaV/I9em1pJXj2cVONop/YNXNmagzpb/t2JYmpMfcb/PmrLE9Nwpb0rFYZhVXHSacsdpLda5pR2G0RVgjI1NAkokHcvNz9rnA/he1Kobvzmz1aRiChcAXRT6pzdvqtamyLkfdJGzVhoejwMAo1XgL4bGnHtDE1RIhrvgZ/GGX6lbufPASPdk2N88PADCU28Hfmi5amJqPQ1GS885Y4hc5XCnuUkHqfHeU2lQxgxUfbPPcruJ8i0NR4lkmwMVDhHJftVtBNOJyX4BpQsHAtNcpTw9rlxAgGSb6XrdCoYZeMhj8Hq/0k5YGpkftJZYgpNTXla5pNu6ePKATU1LDzTJKgCT/DgiGNfwAxakK+dJXm0qGgfdJLlF5JRmHVOTvNU+rUAvGxarRRExKcHkZq1Qbx2QruJwehMKsjwqneQEyN+coGVP95avwzNWwFyus/EYNIKRQuP/CqMHGGsPPU2IXC6u06iJ96+QdbvffLJ6BoVoCeBS0jYmrE8g9s3+ptxXBbpquiBUxro6lhVaCdJgd7SLfCcJeiusz9VuJ+CqKpsSYTK0dQuT2k9IR5DjVkahTup26uA0zyxY5qHCwEcLOY+zBfUwFTJ8hMNVAZ4+0HtD2ZChagcptcRbwlA+354LWfVAaM00/ZlsmIWOieQhs1IcFXnpoAiZfc3E9UiEtf5c7+v39/H99/+FUlQ1C0MTXO+TYMw+ATgOwqUPvFy+0rT2Rs4G8nhoFNKJxKcPbGr1A4jMFHHpSd3U9Wm154f4vnfktk0PQT+hwUgQtahnRwVUZhJwaKHlOll7I0NdV1P7GB3smokbU2SvcTMdz9amKE3xNdgv88NearW0Zh9lzVoqAlA9UPciaJC4Xd89QUHMZRx+MrNV7erChf1FWhTAIdItMVamr8XpeOfFFwBVWqqTF/q34+VFW6dZ6aOoSzpsZ8pe4nP8Zzm4tRIwtxUw7G0g1L3sHdL6zGh1vabfuX89SwV9Vq8/zfrcCR1zyJnZ15O1NTcB6Y2AqUuZWogE2VfI+J6HzXfgphNepXUEtZplc+2cGrjnvtV1V8MAx4hXRHnafGz8pYlUOEMm1NNar9xFyYPRIKK5iWILlqOJOXDM7UJBKwJd+TtWq11tSwvsHaRaOf3HQlhYDuZZpvhhooXj+1MmNbn1Uj+ilToaZGEFC7TCA08inIcVTPsNNhrBxc9mrxcYA2akKCH6YmUPSTi6Ymz42GZHnf6v2yFfBOhbDVJhRm0SmKgf7FD7di084uvLepzbaqVhlB1kBj7rPBB1OTEZia6kU/+Q197pCydL68epvrfqn7SV61hgFe0NJnRuGwVlJ0MvainlVGDdPPJBJAY7Y2mhouFHboZ7L7yY2pSZFcTEEMiUoCCERDWa2pYckuw8i27Qeq8SJFxMBWSLf5miGlXbwyCrO+vbG1Eyf9zzO464WP7Md3NGr8X0ur3eV9Rhj9ZLnegu3Dr1uOLhy9tqWg5U8YnDU15msiogVbT6GNmpDgnafGf30lANjpqqlRu5/og2K6jMzjqBLG8cGg3CkzvG3OYZY7OlRMjbOmJuPC1Mgh3TT5nqtQmDBDUUQ/Oa3SmPtpj90aAQAveOhqRO1J+JoaK/rJgSWJyP2kFEA7bCsO5mVNDVuxJ/2VxYgCrH/6dT851SgCykxLKjhTYz1/pMBjAKGwU/QTZ2pioqmR89TQjMIqw0tws5TPYfmHW/H62lY88vIa2/ZWaHYCCTKkeD1r9HcMQfKIBYHoavTXPhlOi2YZbV2VMTVWcId1PZzGV1HbpZmaukXRwZKmA1GQKCU395OVnZMJhe3uJxolJFvvdFs5gkr1wDCmaEdHXqGpUVHIoqYmp2BqbGUSkiRPjU+hcChMjZTI0Gl1woyaY/YfCsBkr9ygyuUQVZVuFQtjz78TznHdstra22C+ppJWhA/ry6mkv6rsUSBw8j1lmQTzNZVIkGzcwd1PiUSCPydekYeGYjJh+5GZmuppauxtViWctJIwemhqBDeLeJ9U7kLqRqKRTF6PmoqZiMz9RMTMlep28orrooJs1ASNfkoRd6ijUJjMaTqjcB1DZGqs3qBKmBXU/dTlMMjKBolozVu/kTs63ZatHNyEwmywbVUwNa4FLaXoJ1ZoLZmwjseQTZM8NS5p80V6OgSjxrBoccDZlcJC2Q8Y2R8AsLWt23W/JeWD39PWWlAZzhQ2Bios9xMRWHolFaQiTjrhALIwvEYh3U6aGgdhPgV1P3GW0yc7Qo3AZMLKhOuXqaG0P9uXrWxDlap0OzM14uTNjNk00dR4RT9ZehzzVXVONH0EZV28xlhV9FNkQmGa1qNCw0mIfnK5t0xT01gec4NGP4kpBhyEwrAWbDqjcB2j6GBJ80kgGX5INzMaVAXiqJtG5X6SVypOFHqxZFVvNd1PkqbGRSickvLUtJfboZzk/DI1IUc/WbWJnO+NYRicZRrQmLG1Q7lfwZi19hMGDMOQQtvdJ10gfPeTmIvEYVviYqErYkBKtljl2k/MSOl2cHv5yc4rCIW5psbfBEJ3b/7en/tKXXNHbHMcop9SKXudO3ZtzOgn5zbSay27WN3SRyST1gRLj+sEdmh1mQTXnwZGkbSR3rdiycDVf3oDf3l1nec+Cj4Xc4yV79+Y9txW3UbvgBZxwWa+19FPdQg/tZ+CJN+jhoj8MFP/NEBCxclx6aTnxtTwgpYOkx89dmtHnq+qsy4DuWx0sYGWMTXMHUHnOd+amrDdTzzfCFvZ2PfZVSjxB5kbNZ6uAvM1ipBuP8XneC6jAEX+ghxbXKWp900zSyclIzaVTNbM/SQzADKcypKo9pFK0gWBT6pfYGqIUeTxexX7xyYTtiJnrGjtNTWi1oItfjKkFpw6jNg+jrpVpKfReIGin/j4Z33mFEXaUwjuGnLur63Zgdv+8QGu/evbnvvwG9LNxno2TvkdI6lHwcsVr9TU+DpKdaCNmpDgHP1kvpod2r6tE3a5hXRLRoMq7Xjep1FjFbRUsySCUdNpMTUtDWnl9oA1CMm1nxjbwSIA2Kt5fL9lEtTGY6XgtahcJn/KTvVvyJTb4W9VLZZJCOfRt1WRVk26klst7OinlGLisrWBTBwyU+P3fkeBvJemxlZA1sv95M8oYaD9Npl0F+lT0MreMu0fK6YmoQjp5kyN1W/c9Hj0eysE33kBJS+SPPPUGNbvGKISCguuHbIQYONyhw+m0m/yPbZwZOOUb6aGMrAuQm7Aet4TsAvW4wBt1IQEr9pPZpSD/7LzbkYNzwNTnrBUTA0dsHcphMJymQSWM6S92zkkcAdhalrK2WDVGhwHpqbL0tQA4kSXTiUE95PToBR2RmHOaKSds5yya5JJJdBUDkP2WpWr3E9hjZWyxkOdxp8Za/77nB8Eyb9DXVWShMoUCvtIthgFvGo/2UsOOBuNyUQCmXSZqfHpt6CXizI1fvtUQqFnYve3IaCWoqdQVulOJnhUpRzSbWYUdjYe8opxNO9yv1RJEM3jurebRp/Rdsv7DQOU3aSh7l38vLyP5bdMQqVMDWXuLZe1elsrsajdDRoHaKMmJIi1n6z3qoRZQd1P9tpPZSaEh3Tb9+vN1JivzCBqLtfhaZe2pfvZ0ZHn+gdm1LgXtGSaGompSTGmxhpETPeT1R2dVu9R5amxdEn2bZhR05hJcebDKccJg5uroKewMQkqF6DE1EQR/eQ3+Z7K/ZQm0U/5ohH66tgNXrWf3NhKBsrUpAMyNbL7iddd8ypoSUTanhmFq1al295mWtCSt48k30u5JKCj+5OLtioXUGQyTpA+5tWf2C0Qop/o70NkHgwlC2Lw/udHi+WbqVEYNX7GHRr95KXDY58miPdBa2rqEM6aGvOVZhQ2DO9O4CYUlqtgW8IuatRY73d1uwiFJaamrVtOrmftp7WjwKOf+jUwo0Y1MImGAgszZUwNb3dKNmqsLMNOmhU6oYeRp6YkT/6K+8IS7zVl01ZhxkDht+Kxego/pR1Y8xiLEF70E2Vq3P3p1KixCYUlI9ZLeB0mGKPitELOS7oxt9pP1CjxG9JN70UiYblhg7F/4vVkgQosJ1T13E/ma5ZQcSoRuZVR2GJq1Mn3VEyNi/tJCnjwK1yl7AkD8YaHamTTvkJdtmzh5scALTiM7TJY9FP/slED+DsX2ka3KuqAU1oHz0NUDdqoCQmCpkYIt7U6gJCt0aOj+dLU+HQ/qZgaHhZeHpBZxWRbngOZqSm7CiyjxltTI+epYQ+NyNRYkwPgLBYOPU+NtMJV0c7M592UTfmewNhuBE1NSPO2zchVGpbWJGL+HZb7yXwV3U9O21qGs5qpocxc9VxQRQ9NjZzzRW24m6+UqfFv1FjvafSTd54a6zeyoWzX1FTHSGT9jDG9gBhezSZL7n4ieWqUyfcUUaSuQmFpgefXHSIbQ/L7MDUiYgSsdXz2HPvpN2Kou5v7iUU/WUaNHwOXz1NJb8E0HQPk38cB2qgJCZ61nwj1CLjTm8WSIWhbZI1JXtKsyCnJzW083E9+mRrJqGFMjaWp8Y5+kvPUyJmQzW2TSCQSrllmaZZkIGRNjcvkz4yxhkyKr0hLhvskpEppH55QWG3kip+Zr1Z7wzJq7C4lp1WxFW6rYmoSwgRXTbFwnk+WhtKIZdeXPROq+yxEi3CjxKf7iQqFEyDuJ39MTYKskNn8xia6XJWT77HjsGsFMF2G+d7gRo3lfnJjasRyAKIxo5r85YAHv88aTTdA2y3vNwyoQ/EDGjUBk+/1b7Duh59zUaVfcHQ/RTi2hQFt1IQExzw1RNxHmQm3hZRclAyQGQpZU2MXdnULeWoUQmFpMGh2YGqoEbGzM89ZixYX9xP7jGtqMmKeGjYJCNFPZWNGVc1Z1RbANBh7KuizaU9c3U8pIWmgGw1srWYoJd6jpnL4EbKyfscTndUgpJv2MdmokXMYVbP+k1PqA/5Zue+x2lRuId3JZMJKXOk7T421P/PaBHU/2UXanF0qu3ANI/woHhXYMQSmRlHQkk3KmVTSYpZdggzob606Z3Z9iCz4lQt9OsFiJpyEwq4/DwQVY1kqWQu3ko9xTFU+QoU2KZ+W/FsnCHlqPIwaWRMGaPdTXcIrT43sB3cbAKmehqFb0JKIE5aKLvTL1LA2NZeZF7tRQ0XPJlsDAC0559Bme56aslC4bBCxAYgOIhlpW9XK3U2UXCks7Yl39FNjNiWUd3DT1URZ+8nJHan6LGz3k+gCcXer0QlH5X4CUJX6T3f84wP8/vmP+N9ekSTsM57zxUWITWs3+c9TY71PJGhG4iDuJ3Ey4W7UjNU/q+GCYhMsZWpock12rt2cqXHX1AhMjeR+AuzXWA7N9jvJFsm15O2OSChsLQREg4E+x16Rc37z1OxSuJ+CaGr8MDUloR+a77VRU4dwjn4yX2moHODB1HTZrW3BqHEsk6AerFVGjbWKNv9udgjpdhqo3TU1IgvEtAlyxAFlrpg+KOfK1DgbUJXCCn129sVTTQ1tsxttHGXtJ3lQU14XiYEKa34T3U/iZ05tULqffBixYaCtq4AfPfYGrvzj67xPidoz1cTKJmrnRHZCnhoeceR8Dp35Ir52x4v4v2UfCq4rACQjsV+mhrB/UDM1Tu0OG+xaMnc0UE6+55BROJ2ymClVvxHcy9ztpF6s0eNzpsZnrhl5/ANE1iZUTQ0Z9yi7qRrTnVBUMPUqMDa8X0OaH8uPcStEP3kswizjOvyxLQxooyYkeOWpSSb8rwR2Mr9oY5oP/iqBbCYpP8jWPoToJ7eMwkmmqXFyP6kfCPfoJ1konBK+V2lqMpKoWDXJuSX6qxRB3E+NmRQSiQTXqbgaNUwcKPide9RUDj+aGluemrDcTwpdh9Ou2TVIJ9W1nwBEnqumM1/krphuSaMBqO8hm2zcchIJ0U8uzAPDytXb8ORbG3HHPz60CS39l0kwXxMJe5ZqNVMT/UQjG4CAWmvBMgpnPZgaMYkpu1/OzJrsZvUbaUhdeRRRFLUU8zVZ16UrgFHj2/1UHr+bs2nXfEAyrOea1n5yMmqsuUNnFK5jeGUUZp2FV6h1GcCY+6k5m+buDlpjiVGVsnEghnRb++8qlGzHk4XC3P3ULUc/qbura54akmgLgBDlomo3YBkVbpoa9hmNkuopUyO7adzdT2nh+Kq6V3y/VP8Qci4HWxVpV/dTeK4vwzAstk0RgWNrg+IaMLDVOs9k7XItewJhlc+EmcQQdmMEXd1PNPrJR/I89kx3F0s212/GZ1JOdUJHkamhC4jqaGpY9JPE1Mgh3UQHyJlll+K55r7FcwMU2bSL4rX0Hf1UEn/HwK5rmO4nNqbQ5HvUyAbCdD+V545cmsw13udCq52nPQw7pWBdMzX1ByemRn542CTjpsdoIxSilWXXWsnKE7Gquqw88bVJYmG7ULjsfupyjn6iYD50f+4nkanhhThTdqPGKtdgX7mzAU2g2EM2alQTAXU/AfCVq8Ygg0TYtZ9sugIXobCbsRYUdBf+8tRYxretTEL572zK+1r2BHlp4iiVDIFZcuu/jS45XwT3kw+mhS0W8sWSkJEV8F87impq5MnbCuG33ILVqNTNrxVhalKkFIIV0l1uX9ojT41i8u72wdQEzVMj/44hilIJdAFJxwJayNXT/aRgsGQUiiW0lo3n3Zoyjhnsr/rj6/j3hf8Q2FEa/aRKEUIhaGqkz+IAbdSEBD95agBrknEbwJj7qSWX5oM+pSqt6CLGeNjbID/8cgI+OU9DM3M/dRek8HH7A5RLJ11rzNiFwk5MjfU5G9jdo59KfJsg1KobeO0nlyR1HeVrx40aP+4nytCFHdLtJ6MwM9bS4bmf5KgHr/OiWaudaP4MZyKrYNQUDduKWBm9J7mflGkLCNtiZRR2YV/Li4VC0RCME4CGdHu5nwjzJYXTF8iYwNtTFabGPEZzluapsYd08+inpFeeGrtLRvWZdXzzlV0Py73jr93O7if33wcBvd+UVXcz1mTkXa4Bw/ZyEEciYeoxUw7G46Or1uCfH2/Hexvb+GdC9BPX4ngwNYDOKFzP8MxTkxBXpm6dmLufcmnlJO8U0k0nl26p48taGVlgx5iakgGei0Y+L4aGTIobISrjoyC5x5w0NVR0y66LtXK3H9dyPyUdH9igsDEait0x9xNjnHgbXSZidfhtj5rKIU9+6oy35quVFbfnxxWMmqR3qLrVx1QFLcuuyYiZGlGLULJdK6WmpiiyD+5CYcK0uNxg9vx1F0s2PYffMguU9mdLZNYOupAImjenJ2DXl7qfaHSWXL8pk064PrsqNws9D7mfMOOSjSXycZ0gBy0wpCSGKQyIBoODpsajvX7KJGxv7wZgFrNMu1RDt0LkaUCLNR+kXYTcgHsUXhygjZqQ4Kf2E0A1BAHdT8qQbhb9ZKcZ5ZWvLBaWhcKNxEVEdTWqQb8hkyS5OZyZGrZNQ8aJqbEGFPYA+mFqMmkrjFbllw8CX8n3ZPeTD3eDRdHCtqruKWSDz23S5ZqaMNxP5HT9hKoLAklHpsafSLZSCGGzxZKNmXFLHcCeCZWxIpZJ8GZq2DNdKBq2MSGoUFjl+qP11iyjIXr3k8XUiJoaOaRbVdBS1W/EPDVMA+XMHLOoINn95MWKWvdP/NzL9VIJxHpp1vG7pL7pBkEb5tC2rW0mUzOoOQsAjv2AGYZiHT2U22jp37yT70FX6a5nqJJGAXaVPRvE3VamuxTup24F/WjVfrIfV+7IdqYGwj6SyYQyAkpFz+fS7uUCZPeYzNSwlYAqpNtP8j2Rqelh9JMsFFY8nJ3dolGTDaCpUaW07ynkydOPYRnGseWkcZ5CYULxJ6XZgxuxCvdqmJBFpn6YGnZ92f1WuUloJtuMD00Me6bzxZIt+sltgUBhRZ3Axv5Rpsbv/noKw7CuZ1OOamqSNrcEdx2nknwRpi5QGdD9xK6lFAnqmadGWtTxtrsYXJVCGf1Ushvc7u21M/UytraZTM1uTWYqECemxqpSr5inaJkED02N6Fp3bX5VUZFRs3DhQowZMwYNDQ2YPHkyli9f7rr9/fffj7Fjx6KhoQEHHXQQHn/8ceH7c845h4cpsn8nnHCCsM3WrVvxla98Bf3798fAgQNx7rnnYteuXZU0PxJ4RT/JA5ibhsAyajLKvC2yZkVd+0nsZbJRIxe0BGgCPktA5snU+ChomZOYGtZeytRkbUaNXSjMrkE2leRGUI81NeXrwPLUqMskiO4nP7oodYRAj5rKYQ/pdtZ8uIWqBwXdh3BeDl1ZDrcVmLmU9DxUQyhctEcBuhnl7H6r7jOdqCwNi7dLuVAyiLFnfkcnHzc2T8nUSNFPdOKM2v1EnxWZqZGFwjwikpRJUD1rytpPLu4nS+Bq/t2TMgn096EKhctNlvV1QfLU+AnpZu6n3ZrKTI2i/EaxZBD2TOF+SiaUzD+Fm7YrDghs1Nx7772YO3currzySqxcuRLjx4/H9OnTsXHjRuX2zz33HM4880yce+65ePnll3HyySfj5JNPxmuvvSZsd8IJJ2DdunX83x/+8Afh+6985St4/fXXsXjxYjz22GP4+9//jvPPPz9o8yODnzw1ANXUeK/qmnMppbuKdUY+WSj8wDLTsbPT3f0EWGK/duJ+UlHquXSKD+RuuWMspkbsZjz6STHJuWksaKXfsDQ1wdxPaWFbN8NUnacmnAffFtaqaHMU7idDcj95RZrI4bZ0AmEDpxszFwbyksDeK3GhYVgCzkY3oTBhoTI+NCzUpcvOlWvLfJfesLsx2GdUZ2flzYnW/USvJdXUyFW66TX1enZV42heYG/UmhrWn/yXSbDaSqEKumD4aEsb5t67Cv/asNN13/ZjWYYXd+0YhhB95HWv/NR+2sqMmrL7SRX95JRNm/ZnFfMvng/K23rr6mqBwEbN/Pnzcd5552H27NkYN24cbr75ZjQ1NeG2225Tbn/DDTfghBNOwGWXXYYDDjgAP/7xj3HooYfixhtvFLbL5XIYMWIE/7fbbrvx7958800sWrQIv/3tbzF58mQcddRR+NWvfoV77rkHa9euDXoKkcBPnhrAGsT9CIXFkG4VU8M0NfaJyx7S7RD9RJ5pNmkLFcL5qtXqKg2ZJI8Wcsvyyyb/RCIhlBdQRT/ZQrpdku+FGf3EJ/9y+1QPp8395Cv6ia5m4LjvSuAn+V5BNtbCdj/5oJ7lCDuaq4YZAn6uZU8g6zFkw0POj0OvZZNr7Sfz1XeeGsJ+sskswdlb6yF0m9ysfCeqkG6y0vZZILOnEJka4n6SDHm6XSblnoZfiPJRVOd2SmfAjBG/CwiaRJLCLZvuAys+wUMvr8Eflq923beMkmAwWO4xVUSrE/zkqdkmuZ9UjB2dR2jfF/oPuz+OQmFy7UJ2rYeBQEZNd3c3VqxYgWnTplk7SCYxbdo0LFu2TPmbZcuWCdsDwPTp023bL126FMOGDcP++++P//zP/8SWLVuEfQwcOBCHHXYY/2zatGlIJpN44YUXlMft6upCa2ur8C9K+Kn9BNA8LP7cT1lFhl259pPlfrL2YTNqut3z1JjHs5dKYCujwc05/llDJuXqfpLz1AAiW8MebMrUZAKEdNOBsacDt9Pk/9KHW/Hih1sBAO1583408jw13rooK0IAnoLawG32IxS25anp+XFl9xObEAyHTDUyxS8yNd73OwzkJYrfHtIt/22dS2MmzX8ngz7XVu0nb6EwYJ2r5X7yx9SIeWrEdhTJmOA3mV9PQftDE02+lxLLJNBz8tLDiWOn2YfcanUVpbHGr6tXNf4B7kLh7e2mELej2zn79YbWTvzoT6/j/U2WNIIzG1JqAyHK1DNPjTNbxbCt3D6LqbGfi8j42N1PNOzcy/0URbqKMBDIqNm8eTOKxSKGDx8ufD58+HCsX79e+Zv169d7bn/CCSfg//7v/7BkyRL8/Oc/x9NPP40TTzwRxXICtvXr12PYsGHCPtLpNAYNGuR43Hnz5mHAgAH83+jRo4OcamD4qf0E+Iucoe4nVfgw69Q8pFuZfE/sZE7RT5QtYWK/XV326KchLVn+WS5taVpsIZYlKw8HNVpoAj62kkylqFEjuSOU1b8tCtt6YHs2GbKHkWpqugsl/Mety/Eft76Aju6iUCaBttVPSHdCMQH1FPI1d5sc2PUMY4IT3R/+mRqVhordP8vIj2ZQFIsheod002trVem2X186Cfip0k2Nmi5u1CiYGl/sH8DSnrEupYp+ior9YqCRhwJTQzU1JdGQpJoa1eVSuVZFsbfaqGHH4245j/4uZ1SnbQfUzyobF92e+7tfWI3b//Eh/m/ZR7ZjJROiu7+TJN/zzCjsEIhCwZiaQWVNDQ/td6gJKBcrNtvobdSIxnW5H7q2vrpIe28SPc444wz+/qCDDsLBBx+MffbZB0uXLsVxxx1X0T4vv/xyzJ07l//d2toaqWHjJOSiEQuAP2HkLkVIt0jLiquMitxPEm0L0KzC9uinIS0WU5PLpIiOwHmCpUYLZWr4hKbQ1Pgpk5Clq72QQrrZcUuGgY58kWcRXrejgzNX9uR7zsdWVWcPS+JQqzIJVCdEX500NTamJmC0Wxjolqh3OzMjXUvyd0PamY2kDIGfjMC7BKPG7E/WRGxOJMWSXfNDIQiFpegiKs73mpTCAmtrIiEuWmgbDENkyzIeIeeqHExyAkX5e3ZMIDhTY4t+4saY/TdMl9jlMnZ/vLUdgDjeWtnFxczaHd3+Mwr7cj+VNTUDmVBYwdgJ2kyl+0n9OwqqqeFsbYysmkBMzZAhQ5BKpbBhwwbh8w0bNmDEiBHK34wYMSLQ9gCw9957Y8iQIXj33Xf5PmQhcqFQwNatWx33k8vl0L9/f+FflHDW1FgrdsBf4rY2hftJlafGT5mE/g12nQzdltKhVlZhe/TTYImpYRR3yXBODEWZGpX7ibJE9uR7iugnEtLtlAI8CAzDigSg+6PXet2OTm7gNEoh3W6GKV/NJMOPELBnVXV2j3gl0gqCksS8yGHFMvhAqYp+kpiaqFgFORxYvlbyc2ilDbCqb6tW0TRaJEieGoAwNWT09ePCohF1cukNutBxcw2HCWpQUKOGuseKhiG0LUmMQK/oJ8C89k4uE7Z/gLCBPp81mUHnbXcxCHd2mu4dt7F7zfYOs90OIlxqQ3Xk7W5+JxQCuJ8GSe4nJ6arW2BqiOHlwSzTdBVhs9BhIJBRk81mMXHiRCxZsoR/ViqVsGTJEkyZMkX5mylTpgjbA8DixYsdtweATz75BFu2bMHIkSP5PrZv344VK1bwbZ588kmUSiVMnjw5yClEBsc8NdLq1g/dvrPTcj/JId00N4QVPaFiasz3zL/qzNRYTxkTCtNt2QMxsCkr1HLKECNFxSIBolZAcD8po5985KlhGYXT4UQ/0Z9miJuGns9HW9q5gcKuTzChMI1UqbipAuzsggtTE5H7CfCuiMwnM4nZAaqoqZHodnmlLz+HPLIwaRnuqgSPyugnl2tM0yR05UX3EwBfhogvTU0yPL2ZF2iUI03bkE6pQ5cz3Lh1zqNjM1qK4vMo9xOZDfT7rMkZ1RnchMI015AT1u5gRg1d2Jqv1F0DiEaNWzZqwGf0E3M/NYtCYacFt6p4KM0p5VkmgRjXMbJpgkc/zZ07F//7v/+LO++8E2+++Sb+8z//E21tbZg9ezYA4Oyzz8bll1/Ot//Wt76FRYsW4frrr8dbb72Fq666Ci+99BLmzJkDANi1axcuu+wyPP/88/jwww+xZMkS/Pu//zv23XdfTJ8+HQBwwAEH4IQTTsB5552H5cuX4x//+AfmzJmDM844A6NGjQrjOvQYRYfOYhMKe9S6KZWsTJNNWXvyPSGSgIUxJuydkG3PqEhbQUspMgVQC4WtQT7BWZ+GdEowSJzqkjgxNWmFpkauE+Va+ymVdF3tUby3aRcuf+gVTgtT0AGUaWoMQzwfKvizNDXmtm5CYdasSGo/+WJqzFe3/DtBIRvonC3wGPxcq7L7zKZbKYRMrAE0NVSMrppw2LWgeWqczqGrUBT6CnNf0AlOpX+wHVORH4QzNSSzrpNrOGzQKEyBiU0mBZdrN3luAeri8WZq7Joadd+XhcJe0X4WwyN+7sbUeGlqiiUD63d0AhADO6zoJ/Gei64g93vlVSbBLGZpMjVszFcxNWJqEPs+zVpm7mNGlGNbGAisqTn99NOxadMmXHHFFVi/fj0mTJiARYsWcTHw6tWrkSQ95cgjj8Tdd9+NH/zgB/j+97+P/fbbD4888ggOPPBAAEAqlcIrr7yCO++8E9u3b8eoUaPw+c9/Hj/+8Y+Ry1k6jrvuugtz5szBcccdh2QyiRkzZuB//ud/enr+oSGs2k908Mulk7aVLD2ORevbj8sekoGNptXuWCaBPGRMKNymEApnUkkMaMxgW3seOZJ8D1Ar6hOSKI5mFbZq3tgnObfoMKugpf/V6N0vrMYfln+Mof0aMPf4Twvf0fmDRj/RB//9zW3lY1rskJWnxvnYwgTEI0Fcm+obwTQ1lpuwp5ATNnplby1KRlDtmRrDnnxPLg5a7svZdNLVOKDu22RK/K0MeUHBqjNTksAyjPz0KbueiRoY1WNqLIMim0oikTD7AmWLzOgn9tyKKSi8qnSb25QkJljd97lL1GeeGkOxqDP/Nl9VRhFj0J366uZdXfz+OSe2Syh/65WnJu9i2AHAjo48fw7ZmK8qHOrkfmK/FbMeO7ifyq+mYF38fRxQkVB4zpw5nGmRsXTpUttnM2fOxMyZM5XbNzY24q9//avnMQcNGoS77747UDurCcHnqdTUmH+75XcBRAufGjVdCqNGjn6iDzLbjuUssGUUJitNBpYVtE1IvscmxwQGlB+WhnSKd37ZXSML9xhonhu5EGcy4W+SEzU19gdWBZZIsF06f0AcuLhQuCRWz/2gbNQ0kegOPzoQGtIduqZGHthdcgVRAXRPwfpFrsxYefnTrcEc5VdnTU1kBS0lg1ueNJ2Ew+mkFeHH9nHVH19HZ76Ia2YcLDAELBLJyYUgP3ty9BNAKnW7GjXma4L8zhb9lLI0NZGHdJNnPZFIIJdOojNfspUGoQJ/QO0ut/ZpNzKFPCs2DZS4b7/PmmpRB5CxVMXUMKPGoa9+sq3D1i6A5sQRNTXieXi1t6R8z7CNF7NM837LmRqHPD+qNlIW0Mv9FEVi0TAQ2P2koUZRQeUBYgcAvDU1VmSEqTORB/2iwr2jLpMgu598CIUVZRJoJtD+ZaOG+c/Z8VV1qdISr0uZGuZTlyc2wL0WUCVVulmCKbckgbS9RSmvxuqy24oW/PRT+0ldpTucB19OGKfMKCwJhcOY4Dbu7AIADOtnMqhe4ZyyayBoAdMwICYbK9kmBPk55P2dFE0tlAx0dBdxx3Mf4p4XP8aO9rxgsPHoJ4dzkFlS1repnsOq9K3eB52khYg6F01N1CHdcg069oxTTU2xRNheH0yNSgQvhiSL38sifssl6txuGiDgJBSWm0ZdiE59de12tVHD9pVKsDJA9t96CoWpca6YO2SRMKCOYnKqo0Wjn9wKjgJSQcsE+8y1+VWFNmpCghxyx2687H7yWuUzESEbIORBnw56VkFLeydk27M6IE7uJ8qoqMsklLdLJTGifwMA68HJSitZp/0CYv0na+Uuupzo+apr8lhGjd/Jmg9EHkYNY9CcmKdGgakpG3MuEzH7nSpSpadQhb06HZ+dVxgG1abWslHT3zRqvITCdr2D9V1KcjdWo/ZToWTYJkUn0XWG6LYKpZItJJuu9C1DXJ2Uzc7U2N1PTB/nxNTQWywayuYkQ11BYWXb9oL8rOeI0WKFdBvcCM9KDIJXRmGAuZ/UkzJgjZcs/N4rcsf8znpvcz856H1omRmnxQw1aroVmhp5vKbwWpx5hXTzYpbEqFFqapzy1JA2elUqZ8MPNdA0U1OHkDsA+9Mxo7DDhMhWccwIkEPAZcoXcGdqdisr4du6i8JqTyUUZllBdykKWmZTCVx6/Kfx43//DL54sBmVllaIPHlEREp8cBtcmRprWz8ZhbMp/0X72OpZZjcANVNjGOpju7mf7n1xNWbc9By27Ori2/DVWVKkaN/btAtfv/NFrPp4u2u7Xc9J0ii4MTV+XRGGYeAXi97CIy+vcdxmQ6spghzezzRuPZPvSREmglBYFoZXwf2UL9iFwm7uDKpzkUOyqcE2tMxcMSZLhryg6Fa4n9Ie4t6SwNRYEw9lHQDzmeLtjlxTIz7rB+0+AE3ZFPYc1CSEdFO2l7Wf/p5Cvj8yYysbPTJT48cdUpJYLwqLqRF/v4saNT6YGsoAyhIEOTcOEKxMgupZtkokEKZGESRAjyOU3iEuMjchN+AuWI8DYpF8rx5gF7CVkEqm7LWfPKI92CqODfZyNBD7HZ0gLEGYtR/WeZn7qVgyo6pYaDUvNihEP9mZmjxhakYNbMR/TBnDv1MloSsQo4si56KpSSuYGnehsP/aT25MjUrAV5Q0NQxNGetRkdmkPyz/GKs+3o7lH2zFiQeZBp8ql4NhAH9ctRZPvLkRw/o3YMLoga5tdzynsoHWkE4qXSrsPABRKGwYhqDHoHh/cxt+vfQ9DGjM4ORDdlduw91P/SX3kxNTY8trY++zfkTXPYEgFJZYOPl7wOon6VRCMLbllToVTY8c2Mi32dVV4FGEDDahsCJPTcrDEKGTbCIpsmQFib3lk1mVop/YJHjL2YehI19ESy6NHR2mO6RUMvjCgj03bpGL8uROs+4C9uvDvm/IyEaNd7sBu4HBjTFpB7sUZS5krNneabVTwfaqGEsGb/cT7ccqTU25REKTO1PjmFGY3EuVMURhzWn0mY6PVaOZmhBQKhm2h4h1CCemxksobHM/SSHdQo4XxeqC7Z+JewHxwZQjWQCap8bO1FAXEYPqXGQ/O4OQnIsZM2xio1FSbgUtC9ZE7V9Tw5gau2uADso0FFSljWggTI1caZ0NrEIYpyqjsGHweyC7JIKATWKNLgUX5QSNgLvfu718z3d05B1r22zcaQ7aTFPjlRPELaOwFdJddt3UKKRbNmB5LqRUUjC2t3d0K/eTTCbQkkujXzndwTqyWmewuZ+UeWrcmRp67+QVMj2nVJJW6Y6aqZHcKuVrwdrI2i2HdKsmW2ufEhPTrb4/DOzZY+OlH3eIcL1kobADU8PCpQF/7idV9JOqWj3f3uNeyRG1spCZCYVZjhrAO/qJLiQos6wquyOCjm3W719bswPz/vIm7n/pY9dziRraqAkBqpvPHlhbSDdnXtQdxtLUiMnoWGe0illat06lVmfbN6STXORKB1drULaO3axMvscGefuDmFHk1qChpRSqMglsRUAT+fkraEnz1LhPhmwAUtG79BrQMEbVtk0Zu/uJ7ZsNrIIfnTB0dKBlOYDaXYrieYHf23KblHlquFFj3Te33B00gzMzXmQwpmZo2f0UVFOjYhe98jb1FKLBba/Srao1BIgRdgA48wCY95lOAgAwaoDJ1qzdYb92dqGwWKUboBmFvZkaOZS2IBk1bsntwoTTs87aATDhvSW+Nr9zdonK98fG1NjcT6KB74epYVF8iYQYAEB/b2Nq/LifdjhoaqQ5QBYnA34yCqv7KQPT1Az0ZGrIezpuE8MrSJ4aOga8tX4nfvP0+/jTK+tczyVqaKMmBCiFmkWZqZHodo88NWxyz6bMh46HdPPoIvsEocoonEkneVQTHVxVBd2ay+6njrwlhMwTdkSGpQ8y8PLqbXj45U+4gZOWjCAxOZfI1Kjy1bjVfjIzCvsbuC2mxtlFk0qIad1VJRqUmpryPplfv8thdUYHWubac6v06wV2b9mArDTYDPt9c3PVUZbJSRuysdXJ/aTep5v7iUc/RR3SLUXOyP1FNqZoJXg3o0YOCR410DT01iqYGufoJ+szHj7uYKTbhcIWoyBGRLrn1wkTMlNDQSc7dr5+hMLy/enwcD+xnD8NUmSVW0g3M1Basml77SeHtqmK/FK0dRV4FW95G6uvmH+rNTX+3U+AvZ9s50yNIvrJIYxbyHrM76V7AkJAHNtoAk45dL9W0EZNCHCj/2WRWMYlugewHlKZqbGS79mNBjehcDaV5FoZ6laSFfmAFdINWJMvs+ZljYzZBmsgvuTeVbj03n/irfU7bfsF1GUS3KKfXDU1Kf8RHq5GDdHU0Guo0ncoo584U2M/hlOeGnYPqG4pKNh1YG1SsVXsI3pt3Sh52nZmvFAYhoFNDiHd7Ht7G0QDXF3QkjEU0UzAlBHNF0u2ycCmqVGkDQAgTFiiUWN+xnQ1ftxPKqGwV54aQVNDaH8a+cTaU63ke0WHBQxAF1p2F7Z7SLfIVNuYGuk5tod0s7a5GDVdrAyNXVLqVCaBaqryRcPm/pGNWXEscGYs6T7d4JepYXnJAB+aGtJGaqS7lYowP0d5WzGtA3PxU/1kLaCNmhDgVhtGph69hcIOmhobU0OYD4UPlCcRSyVI/hk7UyNm/U3ywZK5R2iIqwx6LuvKIrmPtrSX2+fM1MgMjdKoUSbfs084XgM3uw5KoTAx7FKEdVBtq8pTw/bdoXQ/UaaGfQZ05MtMTb7ySZzdExZRpswoXD5+1idTIxg1CvfT9vY8vy5DuVFjfa/adYEMlICUl4UzNSnb8cNEQdIT2Gs/yStgq78nEpZYuJUwNV3Fkm2iGjWgzNQEcD+JzJU782iQZgorZMMeEVmt5HtO+jnWRrN9ZAUvsSlKoXD5M2akdMoZn0MQCrP70dJgN2qsxY36Nwxyv2GFLPuVx1ohsqj8lker2i+XZ0Zh+VrJxq9KKKy6zp7J94jQ3MnApkEQ1A3KzjmnmZreD6GGUDopfMY7QPlKswFHlVyOfm4L6ZY0NaI+wXylqwe64lS5n1iTqfGRSNgNIDehMFtt7+iwJrx15UE95Zp8T1yxCCHdvsokJD3DDhncEmZRpoYOAHKWUsDJ/WQItKvKqBHz1FhMTUeoTI2zUc10DIB7QjJ6vVXuJ/bZwKYMEWWSfauYGmniF6N9mKYmWqZGptsZu+CUD4m6n2g7qfspXyjZkleOYkzNDh9C4XI/EfLUBA3pJn2KFpakr/mige/c/0+ceMMzjjl0egIrwaOz+4lqarIpu1EjM3ys3zKDvVNy08rjQifPU+MvyzVA3E8uTI2sP6NMjaoda8uLuj2HNAGQXDtSZm21psZrcSYzNeLxtyncT55MjSQ+BsrRTx5CYTq2uRmvtYI2akIApaKz0ipJZmq8o5/c3U98VUbdT0qmxlqp91NpaqRVNEOzFAFFGR8ZbCCm7or15UFdFhaLyfdEpoaKnt0LWlqraK/VBP+NFApPwcPaSd4PWvtpj0GNfNvGrDUAUqFwJ5ksqBaH3nca0s3LNoQiFFav7qlxG5b7SY58AmSmxtmwUmYUTjGmxt3I7ynklamsR5L7GV0MAFZSPEFTUyzx1Tc7p5FMKLxdxdTItZ/s7iev3DKyUJiyf3JEpCU6LuGRl9fgzXWt+HCzvaCrHzyw4hM89+5m5XdumhqB+ZRDusn2YlSPwf9m44Wb+8kwDM6SNmTFHDiumpryONhPwdQ41T3aSaKfAHu/Ye6nMYOb+XnZI2Ardz/JLmY5SzDrnwOVeWrULiel+ynpo/ZT+WMqFDYM6xnWRk0dwMrNYneLOAuF1R3GllFYEs6ylZxKKCx09JI1OA8o+1npwFw01AMSL2rJNDUu7if22SaysreYGtn95MzUZBXup5JhX7WKidHsD6wKfvLUpIn7qUSYmk8NauLbUqaGrvI7iRtJ5Uenq2oAhKnpuVCYRz/JqeXJgJ4h9Ihr9JOH+4mLhMuRT4CsqbHvk11yVdRHWtJTVYepsbQw7H66RT8BlvEla2pkFooKheUJlTE1jBlgCxeVkefM1FjvxVT7hs14ZPta39rJz0c2DvxgzfYOfOf+f+KSe1cpv3eLfqL3mj0jsqYGUC/EAMvo7JQYJmrAU0OYu594SLbTWVn3oznr5n4SdyC7n+T+yoyavYY027aR5wAlU+Mxjtmql5O/hWKWQTQ1CvdTKuFdLFhIV0FC4NkYktNGTe8HHVRkASstOw94CyNt0U+ScLagGEjk3AqGYRBjJIGBjab1zihKuc0UbOBljAIbZNUh3WYbqLuCZZ31k3xvn2EtAIB9y6/0fOk5878rqP3UpXANMdDViRj9ZH4+amAjP05jxi4UzhdLQnSGOoxTHMTYiq89X3RdTbqBu59YIkWXVVwySVb1fqOflEyNKBIGxPNydz+h/GqfxN2YuTAg51Bi/bmRGzWS4SwxNdTFyqCKfhpR1tR0FUpc38DAFggsZxTr16L7KcnbqAKtt2P+lhnhlL1lRoP5SgssVmLUbCw/y9ul82Fw1dSQz9ixLaZGrfOi71nR1E5Je0bvFz2nRp9FVgFgp4umxqnMwi7Z/ST1V7aYG00WQlZuMZTbZnfDMngxzm5CYTau92tIC4tPVeh83sHAofOUU64evi1hoammRjM1dQSaRVdO32/LU+MhjHTKU+MW/SQfk654MukkV8RvbyNMjYP7ia1gGWXe7crUmL+lTE3eYaCjZRLYMQ/91G5Y/v3jcMUXx5F9EqNGdg0owm29NDXswVUZkXS1baWdt47bmElhaIs5iTc6JN+jAys1wiy/cwIJcunaygyNU+ZiP5BdKDb3ExmMBL1QT5ia8mdD+1tGDe06qtsg9zGVUJhmPI5C2CqnhWfXivVzW/I9yYhn7RQ0NcWSLXowl05hSLmvyJEwbJXPSpao3U9lQ9kjpFte7ZcMw+YGYsn3PtlquZxkwa0fsHPuViQtBNSJQBnoR12SoUjHBoFFIOfOxj85pJv2U2bwpJKWODpJGFcnuGlqnJgam6ZGup7McB1MNC3MQDYk417F1HgxlXJ7KEP93qY2AMDo3ZqEbZRMDXU/KWr2mQs8d9c+NbAFTQ1n0lPK31UL2qgJAayDpRSTrd395M7UWJoa9+gnQSgsheDRfWeSSU5J0qyoqpBugDA15YHYLflemjM19klQNoIEpobsa1j/BmFVZ0ZwQDhnBlrtN2ieGpVmg+siiDjO3LbIz4GxSMP7W24XmkuHupG6yCCmCuk2j2m1t7O7UqNGZBvsAx5hahK0YrKLUUP6zLb2vO3aW0yNdR1Eo8Z70qP3mbse085GbBiwMTXMqCmXvbCXSVC7n4ToJyIUpv3GKVcNm0RZZAq71vTRS3swNXYXBvvcfp2ZlmJLm/W8V+LubCUTuYrpcdXUqJgaSXwNiK5Teu4NnKlxdj91SjlqAJ/J99w0NU5CYQext7zPllyajPHmPtyMe9V5qSAbu9QgeWNtKwBg3Kj+4rmwucgxT42dWabeBi+mJkH1grBrp2oFbdSEAIGpkbLsWh3AfLXy1Kg7jFv0ExXSUa2EvLoQjJpUgovHKC2uGpQBUiqhPAjKdDxFVqGpYbBrauy0qAqJRMJRPJon1X79MDWFopX5VSkUJlEjSro8lcA1Mw7CzV89FIeP2Y1/T4XCNKqkmxs11jGoUFhGe76yCCjmQpHreDHQ8U+smOy8T/lab9ol3lPmihjeX+1+UmtqxEmP9jUuxKXMXAS6moI0oHORNXM/STmJLHerKBSmkxplLmhXZlmF10lh3WzCY+4n1r+ClEmwFUUkglg7U2N/viqJfqLslMqocctTI2hqpMmOPg9C9Wli7LExwC2jsJyjBvBXJmGnW54aB5Hsri5JKCzdJyb8b85ZLiBLU2Nuk3Qx7t2YmlLJWiSxcZSOe2+uKxs1I0WjRl2l28H9ROYDOp+s29GB/1v2oZBXi/dF/p+UZFEbNb0flD1JS35MOR+MLPyV4RT9BJiGUF6xOrJWF9Z2gPmAp5IJvkLc0a5wP0k9oJkn6mPJ90R/PQV7aFo77ZOzTEkLyfcUKxUKr3DbbJpqapwHA8H1oLje7Kd04gcsWjubTmKP3ZpwwoEjhfBlqouitWnYMZzCb2VUGgFlEwrLTA11P/llamRmplWcmFVMjVfyPbnvK8skkAnRi6nZ1taN+1782CbadIMcwsqFwhkHTY3sflJM2CqhMACMZEwNCesulQy+QGDPoVXQkjKU7tFPshubTt7cuFBcZ4ZKNDWUnVK5ryxjyksobDGfZtvV7mNaAoZ9LzNM9JmW6z7R47oRH/7cT+LnsvtJTgLIxsumbMqWtkOu/0dvT7ODtouCGiUNin77RtmoOUAyalS1n4TCmA7uJ2oM/c+Sd3DFo6/joZVr+La0Lwo1vqS5q1bQRk0IoFEAsoBVFvh5hnRL0U85STirWh3JqwuaWyaRSHD3ExUKW5E/YhfgId08+snZ/ZRx6bzuTI27UZOTxNEMNPmeH6ZGFu7Kq2Caa4Q2SR6EZdAyCSpNjRCpkhTdNBSVuAQMw+BUtBXSLZ4X/VsWQTtBNig2ELGwYRgk+skppNu+T7mgpexmBERmzktX8Ju/v4//evAV3LN8tet2FHIGVa5HctDUyO4n1YRNhcKC+4kxNSSsu530D6Zto65JBr9MjSwUNmB3SasMscrcT15MjT9NjSwUpm2lfZKWgGGMt7tQWHTD0v26ifDZ2ObX/WQYBjeE2FhK+41hGB5MjfQckD7D2CI3oTB9ntkzz679jo48F4T7YWq8op9koTAbB2j+JZp7jZ6LZmrqCJT+tWtqzG1kTY0T1S53DBru3F0oQVX7ycn9xH5raWryvEM6MTVNJPlekdCeKko742Kc2Atapsh3HkyNA5tlRT95Z70EVCJQ2U1j3Te3laUMGpbfqXA/RcnU0HviKBQmDBR9dRNPyvWuNhGd1K6uAqf6hwlCYeu8lJoamakhl4Eyf25ZpClYZJ1TbSoV6D0vlKxFATdq5Iy1svvJkakx31NDjTE1dAJgK/hkAujXYIXbmp8RI0/SYciwC4Wtz+XQalWIdSVC4VYP95ObpkaY7KSQbrONCr0HYZzY951c32Z301jZhK398qR/PoTCqpBu1bPSVbAE5iy5He03sgA9JzHNlAWhx2Dbm+fuZtRY3+WkLOJvlVma3Qc28tQd/FwUmaWdMgqrxsJiyeB9gEoXVJoagDJn2qjp9aArFqc8NVxT41XQUor1p3RgN3m46ArSSSjMBgKmqekumCHIhmFYwjBb8j3zoWnvKgptVCffc+4+8vYNiuR7TnCa5NR5avwbNfL+VAmnAJJXw+HhpGH2dAWsNmrU0Q5AZfWf6KDEBkTZsJP1UkGjnwDRcGDvW3JprrlisCZXhVHjg6kBvMXzDMwFEOS6yXQ7u1a+3U+Kvkr1R6JQ2J6Aj9YZkg0kdZmEYJoaVfSTqs2VuZ+oUNjeLlemhj5PBWemhp4v1wumkvx68IzBCv2YJRQO5n5yC+lOSmMpYDFWiQQRe5M+0E6SKzZl07b+7JanpoUzNS7upyI1akRBuZPrCfDD1Fif0zbSsZWd+7Y2O8tvhnRb58JKv+iClnUAKjilSeHEKBjz85ynUNhu7dJJ3koORpkalI9plLcTdTDN2RTffnt7Xnjg7cn3LPeTKDhWMDXSpE8TP/lJvucEVaXuYskyxMw8Nd7RT/JE3SWxEYLAO2EfhJ1qmNBrsUsSkALigOomFK5kohHCXh00NTznhBRC6lomoXyt+pcHepqrRuV6YnCr1C1nv1aFdANW//bKKsxz/ARguGRhpBzSTZkOcxvR/aTSktEwYzp5M/fT+tZOvk8hKkZ6XsQ8Ne7MoyGxXjzqhAQPpF10QHJotB9QoXCXiqlxyVND22gJ7xXuJ8WES8dR9ltVCL5KKOxmZDO4lklgYyn5Pd1e5Rpn7qyGTFIIL+eaGok5pX2GLRL8uJ+SCXsZHqfIJ3q8goPLSVWfSi7uywxbUboA3h6arqJL4WasBbRREwJolAfNGSNHwQDWYEnTaFNY0U/2WkPdxSLvoEIiM0mcLLufTF2NlYBP1lxQsBVse3dReNCURo30208P60faJH6XSVmh2p7uJzbJOTyM2bQ/psa+Cpcmf4XiH6BMjbqddHCmq1kn91PCkampwKihWVQ5Fa1moGSmxrVMQvlaseRhNEyf56hRGDVu0Sa2UFZFnwX8ZxVmBmQQfYisIWDXqoFMhCqdATdqFH1VMGrI10P75ZBImOfNqiYLTI3kFhLdT+6LHdn9RJPvyUyNysjoqqCAqqCpUURPyQJlGSlumNi1FqpFCS2ea2lqmFFjZzQ6Jf0hIEaFOcEtpJtnyCXt4mUVcmkli8z1NOU2ylnjizaWzToeC8xwyk8EiO5Fedx7wyHyydxexdTQ6001h9aYQQNPWB+gCRjZtU1AdK3LxZhrBW3UhIACWSlRA0N2QwAiu6EaxLsk9xMgrmRVlK+8ulDllhlYDifd3p4XQ34dku91dFvuJyoeo5ANnf2GW5mBZYFlIpGwis5V4H7qllgjP9FPTpocBllXxJrV5ampsdpPB34e0k0Oo4p4YKjEqKETGIvCcop+4ivDANFPe+xmsg3U/cRC9tVGjTPdby9oSfosLWLqU1PDJpe2ANfNy/0EiH1LrnWmYmpokUU5oqtFqrPG9Ru5tM1IFo089/5sj6CxDFXZuFD120pYQTGk294uXoXd4XlmfYPmfWJwj35K8AWTXIVbFf0kMDVJ5/7IjtdGRL0yrGfF+oy5PVtIxl6BqWGRTzkxt1heWuTwRUZQoTBhxGix0nyxhHc27AKgNmpUbJiYIJRE6VJXfLnvd+WLfIyiTA0VutM7rxKE1wLaqAkBTOwmRz8JUTCSUBhQi4W7FP5nKpylYY8M8qTF3E90EGG+4O3teTHkVxqQ2ADR3l10DedWfU7LHahWbyz3jl+hsECVFqhR4y+jsFO2WAZ50mWvHQq6nCKVtFgnOSkb3S+g9qMzVBKRIoilHVxwcmLFpGT0qtDFjRrG1FhGDWMdaLZUBuoGkeEnozAgZmh2AzMQglQ4l4WR7FrRiVCVZZW1SSWGp6yFfF958dhOZoAx10XKJuAV3U+iVkIGs3USnKkx/zbgj6mpxP3kJRR209QA1v22aj+JBiDdBwCBhWZ9u8OH+0lMvie2TUYb6TtuVbrpM7yTuJ/8MDVZyfApSc8BNQKb/Whq6KKZMP3vbdqF7mIJ/XJpvhihSCvZMPWYSI1mdg2oIbOt3QoyodnSVQEW2qipA1BtBlvhOTI1ZGCTcx0A9jIJ9L0Z/WSnfN1CuhkGkLBuOeMsBaN5O/JF3j6nyZ0OUv1yaYwcYOUwUfn1qfjZDaqBg0aFJRLeRdfk36v+tlZA5XbxlaW7UDiRsPzmNH9Fd9Fu1MjCToqeMDUZQkU7CoXZJJcQ+4cKMlOzeVcX72vcqGkJqKkpf6as0q3Q1MgRWDKYwNPvdaPh74CYfC+dTNoyv5ptkNxPin5MWQtbRu6yS2NnOVkbKzfSnE3bGBR19JNfpsY6R1tBS8V1DsrUGIYhZRR2ZmqckmnaNDXkeeIFPBVMTSaZ5N/zsG0uFCZjglJT4+5+YqxKJpVQRumoyiRYVb0zXGdHxxKaowaw3NaOyfdIl2GGlVv0U1ERFVYolbie5oCR/ZVjqlq3JB7Hqk9lZ4O2SUVcmRFJ+yId1jq1ULh+oNTUlNSaGhrNpFqZsk5G/ZI02oZa7fK+2WSmyi2zG6nUTSc3eZXVxJmagrLOFAUdpAc2ZwT3hGr19qWDR2HsiH4YO6Kf7TsKVZFDOSU6NR6dYBMKy+4nTgubf6ekCcDt4WTfqdxPVsijfWVNUUlGYVoqQjUxAHaGxE/lYtbvRg5oQDJhGikszf7mXebrICVTY1/ZMliMkbit+Zn13hKGuzFJRX59/TJcRekZLBRFUa1Ky8MXDTz6SSEUpu4n6ca2yEwNibTJSu4n+ohkPITv9uR71j2VjXPKoLJK8yqjxA1t3UWxpEcFTA3rd12KxZGbUDhNmFiGRoWwu0NyTQHe0U/UHajSuqny1DCBunkPXZianKipYdsUJYNUGdLtwtTkyf2l5TQYm7rHIDtLA3hHP7H9AGJEE2ufPH6yxQ3vi0mJqVF4GWoBO/+mERh08qfRTyo3BGB2+kKpqNbUKJgaIfqJuLoYrAHC/FvF1DD307a2buGBlS186n5SubEo5P0PbbGYGtXq7QekcKUb5MrkgDWRsAGMu15cXBZO4boMspvGosvdNTW8jV0SUyMVsKP3vKfup/964J/4eGsHLv/C2HLbxL4mnheU5+XHAGzImIUZN+7swsbWLgzv34CtbebgqXI/WUJh+z7llTy7nGZ9L7v7ya1MQhsJm/XL1KgqG4tMTRJAUTB25RBiNVOjjn4CgJZyLhpZU9OSS9sMpMqYGtGdWaLRTwqmZq8hzXh/c1tg9xN1PQFOQmHx+ZEh93lBKJywGAd5f5SRYGiShN2pZMq6V2S/bsJ1gIRzK1xP5rmUf0+Zmk67UJjeJ+bSYm2U3amGxJwKyfd8RD9Zoe6i251rijJqYW4qZR8fnFzyTtnVKba357HHbs5MjVzKoVbQRk0IKJLBW9TU2N0QgPlwd+SLrpoamteFakxUCa/k6BZVZe0BJAGfUzFLQBQKc8GxQycXhMhNWQzpZ016XroZN6iS77HrwoyuoBmFVX8XpYlCnqDdVhzs3AWmRqabySWg7xsySXTmS76NGsMw8ODKNSiWDPyrLAw09Vvq1b18Xm5sCm87ce8N6182anZ2Ahjgy/3kytRIjJHc7zKSsFKFXcR49JunRvV8sYkwnUooJ6h2aYJSMjXlyUT1/PSThMJslT+gMWN3PymeYa+ClnIETcmwa2roszdmSDMAdUi2G3bIRo2L+8mRqZE+zngyNYxFS9oWRbJR05BJWewtzSjswdS0eRg17u6nNN8vjcxsJy5GwOrPrGwA21dCeh4Bi91xZ2qo1qhs/JYsd5CTUaNyT8v9y84mOScLZRobMqspt621UaPdTyFA0NQI0U/WNjJTA3hFP9ndT2b0k90lJAuFC8RFwWAJhbsdi1kCVvXiQslK/e2kLRGZmgyasmmevM/JZeUHcp4HgKyg04ypsa/0ZHgKhT0ElqpssnIbKVPDwvSpkI6B3v8hZeOg3edEkyduE1YB2i2sXV5BqwZqGZbbM8nrOzF6m7mh1O4n89W99pP5N+tv8uTuh6nZSQoK+mZqFAYCmwjSSXV5BrZvro8gfYB9xiZT1fPDJkvWL5gupV+DKvme9Z4LhR2jn9hvxInRUEQ/0WePGTU9ZWpURhE7bsrhOZGfJ29NDdGOSPtszFhGCDN+LKGwPfrJSVOzi9wPZZsV7qdWzrZllO4nztTk1EwNO0U5xQJghXS7aQNpUsIMcbt3Sayi7VxcXHzy35bL2tlIZRobytSoNq21+0kbNSHAOU8NdT9Z22cZ1azQEKjqZ9AHia9mFKs8e54awqSQkG422Kv0fVR0xwY2p06ucm8xXU2PmBrFwMHdTyEyNV5RI740NdLgT4sd0t3R+Y8xHn6ZGjohMaNGlb2awR7VZX7uJ6NwNpXiSfY2tnahu1DiE7Ta/eS8MpaZGsfrLAkrVaBMTaFkeIZ/O+2PXfN0igqF7f2MCeZpW1kfZ/dD9fwwoTBb3bP+0b9BwdQoosGcIsDkGnI8+knJ1FjH2WuwadQE1dTYmRrnMglOz7qsWRE1NeZ76uaheid5n9l0kp87W7Spaj+xQzqNC24Vus12JWzt2kV1UQoW2X/0E4RXwOpnpv5L3eaCML9YbnfWV+n5U8j5ywCFpqYkamrc3U/d5fNh56HOwaWNmjqAyNRYk60jU+MQ7VEoWnloBE0NeUjkOi/suOyY5nZ29xNNvifnTaCgDAAb2Jy0JWnB/WQaTcyocYqI8AOVpob59Jn/3Ff0k1wmQfrbxmi4aABkWCtrO50rizoB0dUwpGwc+HWj0AllTdmocSvqyY3W8iGDRD9l00lu1GzY2cldT6lkAgMaM7bfWW4QZ6ZGvr62Ccujcj0AW2VuPwZhnrBPDJ2EqZEFyoZh2PQRguHenCnvo8xQuDA1uzhTUzZqGjM29kHF3vplaixj0q6pYf22f0OatDkgUyNVpXYrk+D0rMvXR2BqlCJWa2xTsaZyjhhV7ScvobCn+4kknmPYVb6H/RyEwlb0E3M/icYyX+SoNDU56lZzMGqK9vmlUCpZmc8dxinVGOm00KNtdDJqLKGw2m3PoKOf6gBFmt6b0KpOmho6mHYXSnj2nc3o6BYFi9T9lCEPUkGRxZO7F1j0U4G5qOwD8vb2vK3Amgxm+bOBzcmoySqYGua6cHPdeEFOXgXYhcKqVYgMWaMhP9C2pFi2gdTFqHHINtxVLNpEnfL7wS3lFb9PpkZp1KSTQs4KuspzSnrnGv1EjJqh/cvup9YubCmLhHdryir7C68Wrdi3UyE/eXJXJTSTIRs1fiLHaM4Z1h87FEYNm3y6SKHKJokRBKw+zqC6Hv1sTI352r8hYxvs6ZjAx43AmhrDZlx8eng/nHLo7vjO9P358xKFUDhsTY1VTNTO1FjCbuu+qms/ma9O+jFP95PE1BiGgY/LVbD7N2RsxSoBGv0kGsKWXoW1TeF+IrXUnAxaVSBKoeSHqVFcY2kQsNxP5fNPuAuFATG6k54XOzenvGbVgjZqQoBQQ4hPtiVhIEooVmX5Ygn3vfQxvnrrC7jp6feESZeuamhuBB6+SRNZSStxVUj3wMaypqYjb2MoZLABnTE1TvoYFVPz1SP2xLH7D8Xnx41Q/sYPcopJjlUZbszImpqeMDXmq2oFBXgYNQ7f0QrOdHf0UnNNTQ/cTxlpRUWvgy2k20f0ExM+UqZmE2FqVK4nc9/mq2oSsVxaIrsmi2/9ZBTeKTEHfq4dDX9n94sbNamkJVAub0eNTLbqTisMdwbV82PX1DCmxp6nRkxG6KyzA9yin+zGRSqZwPzTJuDsKWP48xK0TAJ79tkpKkO6vWo/uWhqrOgn+4SbJqHLDGYIPjP8ykxNQXRJm+1lRraDURNQKLxy9Ta8u3EXcukkjth7kJJFlpkaWavlltqAusGcmBpqtFLjl42JDQ5lCVS6Q9amRilDs6pKNwPLP8aEwva+aG1ba5YG0NFPoUDodGSyVbkhAKKpKZbw8dZ2AMDqLW1W0reUOGHRQZ+LxsjEIGeMlWs/AZbRQSuvOq2wzIezi6/W/IZ0A8CUfQZjyj6Dldv7hTL5nkQ1V5KnxnQNGbjk3lXIppLYc7CZw4NdB5lFd3tA3Ywa1iJ63xMCU1PW1PhcPdPJ1srOmhTuX7FkgOkFHZPvOQz0hmEIBsjw/pZQeKuLSBhwT77XIYluufvJgalx1dT0wP2USSVQLCUBFHk7TaGw6CZgrqdsOkkMMMrUiO43pfuJMzXms0M1NTb3E9l3xqM/y2MJFWjz8Uex+GBMDXNdexWTZWBjBAvvryz6ye5CYrCeX2u/PKOwgqlRuZ84exugSrenpkYSCv/++dUAgC+PH4WBTVllsV2ZqbGi6kS9ijqjsNV2p6zCecH9ZLm9O72YGqlPGYbB99WcS6Ejb9USpPWp5Gv/qUFNWLejkwuF2aVlt9es1G0I515L1L4FdQCRqbEsaZVgFBAHcU5TdxZIhW6xk9LVQV7BsqTIxEI7Lp14GzIpbhCsLhtSqnBVwLLi2cDm5EpSGTVhwE0ozB5gf9FPdqp1e3sej65ai/tXfMIf0qQ0+cvtUMHJj91dLNlEnfL7IQHdTyrjJ51yZmocyyQ4jPR0hSgyNV287hNzmclwCuk2DINHd1miWwjtYlAlW5SxS2Jq2rr8u59o9mAGGtLNFhMdXPCZErZjGOjD/URrPxWKJV5nqH+jl/tJnAhlyO6nhAtTQ0H1JkF0NYypYQauOvme5XZXwebOdcmtBdCMwnYXCHU/Fbj7yS4UlhORyvDS1NA8NVt2deHPr6wDAPzHlD0BWAsdKhWwdFhi8j22jZ05tY6XS6esMG0PpobOL0WiqfEM6eYMvrV/1lZZzKxyP7HFHxMKu2lqeq1Rs3DhQowZMwYNDQ2YPHkyli9f7rr9/fffj7Fjx6KhoQEHHXQQHn/8cf5dPp/Hd7/7XRx00EFobm7GqFGjcPbZZ2Pt2rXCPsaMGYNEWW3N/l1zzTWVND900JUS7UiWG0I9WXYXDf6Q7ezMKyOfAFFIyQYSVR0V1hZV8j3AMjweWrkGAHDongOV58NW1kwP4Kew48Amu4i0UvBBQSEUZgYf9xe7JK1SMTW09gsLWZbzqFjtcF7VyteE3WLqfnLS1AwN6H5STShZmakh10F2L3pV6aZUei6d5O6xQsnAe5vaADi7n5yS71FROxt0nYTCslZCBbumxvvaFYhLTb5fKo1GuxT5RNsG2NkqFVPDNTWdBcFl1q8hbXOpqKKfehLSrTIuKIsRxKhhz/7w/mZf6FQYnKrs5hSijjAhPF+qxJE0T418vzLE/cTGN7VQ2HytNKSbGkX3vfQJuosljN9jAA7eYyAA9YLLylMjampYO2WWjfabHAnMcGIqlZoaEv2Uy6jHZy6FKF9X2resTMYim5RKJmzj4J7lCDrG2lp9UTwvdj61RuAW3HvvvZg7dy6uvPJKrFy5EuPHj8f06dOxceNG5fbPPfcczjzzTJx77rl4+eWXcfLJJ+Pkk0/Ga6+9BgBob2/HypUr8cMf/hArV67EQw89hLfffhtf/vKXbfu6+uqrsW7dOv7voosuCtr8SCAwNYRWlUP5GHinL5R4bZidnQVlNmFAzFNDU2Yz0E5YNAyoNDWAtdJ85p3NAIATDhypPB8uFOYh3T7cTw6TXiVQDRxyple+YvERpsz/JgMBAGxo7RT2RQebRMJ5BQrYry1b+VEXoVOeGup+cotIYujotg92dqbG2kYWQHsl3xO0XKkksukkn8DfXNcKABjUbE+857Zvep1lds1JUyOXsaCQNTV+WC5mrKnynqjKJDCDl678qQEmG+6q7tGSszIKM6azKZsScoyofu9Z0FLK+ZPgn7szNcmkxUipDBMnsLYPLQv/1Xlq7GORcGyFjpBBpYmj+XZsTE3K0tnYop8UeWqcCFy/Id3FkoG7XvgIgKkTZHDNKMzLJIhGiuUOFtvI9ucUSclAy2CkybaBmRqSQqSRGzViG2kZHwZWamO7lKdGVQKmVzI18+fPx3nnnYfZs2dj3LhxuPnmm9HU1ITbbrtNuf0NN9yAE044AZdddhkOOOAA/PjHP8ahhx6KG2+8EQAwYMAALF68GKeddhr2339/HHHEEbjxxhuxYsUKrF69WthXv379MGLECP6vubm5glMOH3Sl5EdTQ33DFlND3U8OQkohpNvufjLbonY/AVauGsCcvI7df6jyfGT3k1yzxjqPBH9tdvDrVgJViK+cPdNX9JMsFC6UBHZENmrofcqmksocDAzytWXhzl2+8tRYBqAqqkSGyv2USTkX9nQSQBdLwLfv+ydOWPB3YdXOrnOarNKYC+rt9TsBAIMc3E9WvhTJqKFJ7qQw/Mo0NWI0jh+Wq0CeAztTY0++J2uAaJsBf9FPvKBlZ0GIfGLtEH5PmRqPMgky5c/sCMMwiGBXPZyzNAhBynK0cvdTmampIE8NHZfkyU6dQ8ViflRsHjX8DMMSyqry1DgZ8N7uJ3MH//x4Oz7Z1oGWXBpfGj/Kdh6U3WyX3JZyhJSTsJbpVyzxr/reWzpKMWUIW+z4Tb5H22wJhZn7qfybhF0oPKbM1OzqKphMtC3vjjhu1hqBWtDd3Y0VK1Zg2rRp1g6SSUybNg3Lli1T/mbZsmXC9gAwffp0x+0BYMeOHUgkEhg4cKDw+TXXXIPBgwfjkEMOwbXXXotCwdmv3tXVhdbWVuFfVFBHPxm2zsxAk41Zmpq8MpswIJcusFO+svtJrjTMwMK6AeCz+w1Bvwa1y6jJJ1Ozx25NGD2oEcfsP8zVAAgK1WpIpporrdLtatQk/T+c8vds4nLMU0NWNXRy9DM5q4wadnxVvg85YzQNU/3La+vw1vqdeH2t9Tx0K9yeLN8QO/YQD6GwfBvaFSJGxzw1fjQ1NqGwH02NxVhmpD5Mk++x48rZhM3fOuvG3KKfugolbC6Hw/dvFLUWDAKT4VHQkk061urYuu5exkWjlAnZD9izz1I0uOep8eN+ks6duFEYrHQV9uinTEoUdtMs25Sp8SqTQEseqMDuCUtn8bmxwwSjQbXgYvtscihoaRkB4vOYS5sLEyvyzUHzRhfN5Bp05f0yNSX+G3YOspiZ6n7k+7nHbo3cgNne0a0ormptGwf3U6Dop82bN6NYLGL48OHC58OHD8dbb72l/M369euV269fv165fWdnJ7773e/izDPPRP/+/fnnF198MQ499FAMGjQIzz33HC6//HKsW7cO8+fPV+5n3rx5+NGPfhTk9CoGXSmJmhpR3MdAOz1bOezqKvBBR/aR0sR5PEKAMjXkfalEyySIBx7QaA3K0w90DrluLGsKvJLvNWRSWPqdY5U0fE/gWqU7419Twx7ipmwK7d1mAVGa8I4N1NZgY/3WqTQE/55snE0lubFFmRp6X9jbpowpDAxS/6lTsY1VRTqBLojXwSYUJuGzbOL+ZFs7Ju65GwArCSQ1athkxuAU/WQxNeLnbqyHzf3kwVIAlhZiQGMGOzryPkO6LaZGdlNmktT9xDQ1ouATEBcP/RrSSCUT1mSuin4iDMC67abRzAxeM1zWro+hx/F0P0mrYzFPjfpBZM9Mlw9WkGEHN2qYpqYCpsZlkeCWQ0VV0JIaOvmiIbSnIUs1Ne6u1l2k5IFXmwHgRGmclA3wfLHE38uamm6uVxH3zdrIrgkPVXfwmdEyCQJTo6hSrjqXkmGOCRZzSQ0p2f0kXoNEwnzmBjRmsK09j+3teVv0k8DU9DajJmrk83mcdtppMAwDN910k/Dd3Llz+fuDDz4Y2WwWF1xwAebNm4dczu7vv/zyy4XftLa2YvTo0ZG0WxX9VCwaysELEIWRzMo3DKvGjmzt0grbOcn9AkjuJxL9JA8kLCQ1lUzg+ANEQ5OCTUQscsNNMOs3RDQIlBmFWaRDgDw1TGjcnEuXq46XlJMhj8oRNADu50UNxoZMUmizOk+N+QczGJuyaXTmu32FdatW2KwPqaLA7EnvzM+pC+eTckIxgJTmIP2FuR0YgkY/caYmY19FO9UEcs1T02UJV3d05HnfdAOvyJ1KIF2yazrkPDUqdokyPM05M01+R4mVSbD3kVQywY1ollOoP3H7plNJfp7053wF7lsobH3uZVwwJkOlzVKBRm31JPrJbbJTaeIKRChs19SIQmFm6CcSYr/1cj/t4poatSFA29yQSWKq5KKXmRo6njRJBS1Z8k9LYyceI8uCHvh5eWlqLE9AZ95i7Z2ZGuu6FA2LwU+nkrbSJLSSOL32Lbk0kskEdmvKYlt7Htvaum0eCJGpCU+GUCkCmVVDhgxBKpXChg0bhM83bNiAESPUK/8RI0b42p4ZNB999BEWL14ssDQqTJ48GYVCAR9++KHy+1wuh/79+wv/ogJdKYmaGg+hMNHUAMDmXSZdLQ8Ag8puo20kG7BQ0NKn+4mtuo7Ye5CrsLdJ0sf0pDhlJcimyrk1FExNroI8NS2kEq6KGVFFP3mtOORweTZAibWfxBUPYA2mbCCq1P3Ejk+zCjNY7ifzbzZIUbEtNWpU7ifWVxgGOwqFzVebUJhR44T16FFG4XLbGYPkx/3Eq8ynknamgHwmGzXNDpqa5lxKjDp0cLmy/saNGuLqoO0Q8tSUJyDDUPdpeSxRRj85PKcNAd1PtEQCc0N25ks23RSdbFVwc+fKrj9zf5a70N5HRGE3LXCrEuSrhoXuQokb8P18MDXHfHqYwNoBYuQqYLF7GZIiwJZ8z1aLzXI/mb9lWiGP6KekZdhRd6xj9FNKnBdoVKzMUlL2kRrHjGVkInlaZieuTE2gFmSzWUycOBFLlizhn5VKJSxZsgRTpkxR/mbKlCnC9gCwePFiYXtm0Lzzzjt44oknMHiwd/K2VatWIZlMYtiwYUFOIRIomZqSOrQXsDpzV6EorDg372RMjWhUDCRMDev48qqMhu1aZRLEbU6ZuAfO++xe+PG/H+h6PnIyJ7fMulFANeDJQmE/eWrYQ8x1DpL7iYGtftyiNWTQh7cxmxJWcOo8NQmh/cxw9FP/iZ27HCJrtt3OWMnuJzboi0ZNO3+vNGr6W+4np7pP9Lzs7iexhhJgJmYcv8cAnHLo7sK2QTQ1zNjy5X4qEKGw5IqlAmZr1e3sfkokzHuXVUTayGBiYVbSgmrX6DMp5qmx/lC54eT0EGxrWtDSmakpr+59up+YnqY5mxIYDTk6TeVmpaAfy9efGclsIQeIhRtlF6Wcp4ZH/khjlZORDYi5jZyZGuv9CQoXvdVniuV92tMAMBakWzJqZGaDGzUeeiqqo2TXmj0PiYSzjoX2hwIxarKKyD/K7tJxkLGM3FvQnndkDc19196oCex+mjt3LmbNmoXDDjsMkyZNwoIFC9DW1obZs2cDAM4++2zsvvvumDdvHgDgW9/6FqZOnYrrr78eJ510Eu655x689NJLuOWWWwCYBs2pp56KlStX4rHHHkOxWOR6m0GDBiGbzWLZsmV44YUXcOyxx6Jfv35YtmwZLr30Unz1q1/FbrvtFta1qBiqTJiipsa+6gDslXDZAy530kHlDrWzq8BXKLKQLpVIoAjDNU9N/4YM/vukcZ7n05SprVGjCvGVQ7rZoMf8xaoJhvu6cxaLonJbqNxPQYTCDekU0QEVXfPUsFBSKv72Althj+zfgLU7TJ0Gu/80bwUDGwTlvBgsmg2QmBpFBmrK1OzWlHGcwGlhRQqV6HbUwEY8Ouco2z68op+KRAs0tL//CufdZOVflNxP1J3R7eZ+KretOZtGIpEQnk2nLtKPMTU7mPtJnfcm5WBEqyY3WVOjKmjpGP2U8d/XAKufDGjMCHqNznxR+JuWNVDB6fwAYEQ59f66cn8GxGg1N/dTN2FcGxzcWqo8NcwQaMjYhcgMrJ9nUgl87gD7glmuwM0M4WZFn7GKRZb3LT2PbJzzinwrKDSbbIEiM1UUQgBJkUTFpkmFekUbUwJTY/ZdquuUI/EsEzseTE1go+b000/Hpk2bcMUVV2D9+vWYMGECFi1axMXAq1evRpJ08iOPPBJ33303fvCDH+D73/8+9ttvPzzyyCM48ECTLVizZg3++Mc/AgAmTJggHOupp57CMcccg1wuh3vuuQdXXXUVurq6sNdee+HSSy8VNDO1hJDxkbgDvDIKs4y2DE5GTf/GDBIJc1XGtpFXZckkgKIY0l2p1SxTrj0pTlkJVJqaLkkUJzywhoEk7G2UmRon9xMPfSaXK5D7KZsSNTWSD52+Z5N8QxD3U3mb0YOauFFjuZ/sjJUT3U2ZmjXbOrgxyAbfnOB+spgaJ5EwIGo7KFSaGieo7jcFpdpZu/yFdFsLgIy0azH5nhjSLWQUTjJjVEyBD7i4n8oTwfodolAYkNxPVChMV9VKpkacSCgj4Rn9VL4HfvPUsMVW/8YMNzCKJcMWAeUlUHYL9WX1hNYToyZP3CyqkO40uV88cEBiarixpzhVq+6Tc6LQsSP6YUBjBl84aKRw3/h5SOweZ2pydsNVrv3ETkl2P3llkxYE1OVt2bk4lUgAxP5ZKJUsjVnSmakxQ7qtfTCmZhApiGxPvmdt3yuNGgCYM2cO5syZo/xu6dKlts9mzpyJmTNnKrcfM2aMY/ZHhkMPPRTPP/984HZWC4WS3ZL2k6dmW1kYzGAZNWJHTSUTGFhWn28tp6qWBxJes8SFqfEL+UFxWolFBVX0kz1PjegvVs2dFlNjJcZTCoUVAlavaycYNemk4H5yY2qYUROEqWHnvufgJrzwwVYAVsSQKt+HLBRmx95JmJruYgmbdnVheP8GB/eTxdQ46WkAZ2GmVwVhCq5BKKjHATaAZ9NJ7gbzk1GYGvc0yWEiURYKS8e1mBq7+6lZKlYIuLifuBFt7lcUCqvdT7Tv5YsGNu7sREd3kWdzdaofZBhW5JtTe3hknl9NDcuvU253QzqJtu6iTZPDhb2OLJ71Xp7s3JgaGrrMQPMKuRVzdCuT4BXODQAjBzRi5Q+PdzTUWBtKhml8qpgap9pPsjs4y91PjG11YiotOQHbB3OluS0akiTazklTw7RBNPqJ5b8qlgyiqbEkEHy+5kaNda3iENJd+xbUAdS1OZyZGtaZ7UxNWVOjEH4xnybrT7bspCSawCmjsF/IQuFqW99MKOwnTw3g7IvuUhg1HXmVpkac/AEf0U/k+0bK1BSsFZEQ0l2+hM0k+gnwV9Syo7xCZpk9AWt1p06+Z626zG3Mz+WsvKyYKnc/kfvckElx6tkp8R4gClbFNtvdT07wZGpYavtc2tIi+an9VLKvTNnfgF3Q2a7QAY3ezbzmew81jQuqDXEWCosrfLrizzgwNYkEqUJdKmHmzctwwoJnuCFq5alhvzVfTaZGrbNjqNT9xO5/A2d6xN97MTVuId0jBzQCMBdyzKgWQ5dlYbG1YKTuJydNjdL91Oke+aRqtwz6jOSLBndnC5oayf1UlGQI7FLk5Ognj4zCVCjMnmUnkTADLYCZJ8+5LE42ZHa33FbmOmVs7Za2bndNjTZq6gMFh4zCsriPgXVMViCMgZV2V7mN5Ggl2X/OjltyySjsF3ampkbuJwVTI+epAZxz1bCHuB9xPzG6mEJ20wDBhMINacuo6SqW+IBDJzMrpDslvPpxo3QS95PcPlW+D2ZMpyVjTTZqmK5GFdINWGJhp7pPgNW35TnEcj95k8GqyscUbGJvaSBGTRChcDoprPzZQO+kqaFGzX7D++GJuUdjwRmHAPDH1MhMANXU0H4r/zzNw3VL+GhLOzryRe6esYtNy9cdVKyqnqydjBIn0Mriwu8l95NX7Sc34f1uTRn+zGzcaZ4jDcFXamrSFlPDcu40SJO6W/QTM9acIp/8gD733YUSN66poWR3P5mfywYDZ2o8o58sTwAb99kz6+XepYtsOi/YSjnYFkLmK2NGR5THAhbRB9j7Ij2nWqL2LagDOFVRdVrJWJoa0ahhE4MbU8PgFP0kMjVhaWpqIxQulAyUyqHxTrWfzO3UgwGbrJpJlld1nho7U+NFo9JrIjM1LB8MndzYg28XCnszDmwy6t+Q4bmG3KKfbGUSuKZGZAZZBJTK/QRYYmE395OTpkYV/eQEWXwpYydJbR+E4WL9IiuFdLNJ2ClPjdz/9x3Wj7uUfGlqpBT8gqZGEBrbJ25AHBdYeLXlyjZf2S9LhoGdXaIRIsPJKHHCTqnoIxuPZPdT0YMhckuRkEgk+ETJDDeqHZGZUhqWT7VxsvvJLU+NH/eTF9LJBD9GV7GoZmok5tFJ5G3LCl4u/9AqPacWg2XXGjkl3qPtBUSmhjKX3eVjygtw1jdZn9pjN5NZY+yueD7W8XIxiH6qfQvqAKpQRNZBAWf3k9Mgo0pgtJtUTE9eHVn1fQwh6qMSyBNRrYTCgDkw0CgotjKjdY+cctXImpp8Ue1+kisfAwE1NRlRU8MmhRYyeLI+0FQBU0Or8TKhrJ2pUQiFpWgLJ6bGMmrE+z5upJnbaf8RLY5t80y+58v9JK4aZVhZYNOBQuGdClra3U9izhE3Q4xeIyc3RYuNqSGaGvIbO4Nr19px95NNKMyYWbsRIoOt5v0YggCd/JmmRp3nhjIIKtDLo3qeZF0NjaayLQSTYjVrJ6EwzaIrw7pOlTM1ppvQetbVTE2Cfw+IJQhoG62cW+V+WCrh54vexiFXL8aqj7fz/VF3tmzUeDI1pMCyyv2UJ8lCadvYYVjf3b1s1NDo0YRi3Mz5CAyIGtqoCQE0IZ6oqTG/dxIKO0HFEsgRKI55akqk5k2FVKD8oNQqTw1gsit0MKUrE6+swmyyYu6n7qLF1AxpsdgHy/1E2xDA/ZQRmZpWxSRjEwqX3TJ+BK9UJD1yYIOwH1XkhD2jsHidmFbi4zJT4+R++q8TxuLxiz+L6Z9xLqnhpGFoD6KpUSRbpKAr7CDGYEEIYaVMjfnenqfGu81ZB6EvhZ2pUYd0y+MCe6a3CkaNee7ySppqmbwm6wYHpsUJ3E3DNTXqRZiquC6FW0FLwB4BVSDuJ1uemhTNAO0tFC4pxoSdnXYGtRLkiFHjpqmxku+JbWMGNms711IVDaxcvQ3FkoFX1+zg+xO0RtICU3a/yRCYGpq3iRTRpIvCFG+juV/Wd5uyadvCWsXUxCFPTe1bUAdQ5RFwq/0k33j5e5VRM9DmflL7kouGVeOj8pBuOaNwtYXCot+a5+ZxEHz6ZWrMlZU5CH1qUCPfTqWp8fIN08mtIUPy1BRLlrBV0NSYr2zwayzXqwmSp6Yxm8Lc4z+N84/eG8eVy1yo2CrL7cmOLXawsSNMBsbO1IjnnE0nMW5Uf9dipbSwotDmACHdmQqYmo7uomfUJDfuSeQMYPUbOZNxh4P7icLNfcQgT5r9HNxPdk2N3f1kGTWyC8N8LRqGoDlSgdd+Cuh+apGEwnLtKMpQqyBoLRRsr42pKTpP3mkpYZwlFFaPpSr3kxej5Rc0usktTw2LOpKjn074zAhM/fRQzDxsD2H7fLHE9UytJIdZnkSFyayYl/uJL2iKBhfOi9mZDeFaJaUxg7KMjK1hUDE1WlNTJxDz1FCmRk5SZEJmAYa2iJoFFYU3qFm0km0h3YIgLGxNTXXdT4lEQtBZyMUsGbyYGktTw6KpDLSX3U80kiileDiDuJ8aJaZGtSJMSEwNCxv2FdJNDISD9xiI73/hAM4GqKp029xP0qnsP6IfAFP0Z7ory+6tCgakpMMkEsj9RAdY1Qq7y5pkGcNVIG5WJ9DnQHA/pSSjhuUc8eN+ckieR0GZGto3AFkoLE/cTGtnTWhMnyUnPGOvnfmSxUiG5H6y+q8sFFZHPzkXtLTeK91PTFPTahrXqoAL/vtk0gp9LpW4zsyRqamCUWMWJLbnqREjpEo2g3TvoS2482uTcNiYQQDECCXWRmrUUO1SRrou3pqaZHkfNNN8UjDo6bViY+qQcsTj7gMtQ4a+p+fjFrpfC8SqoGVvhVP0k3OeGvHvkQMbsXGnlS5cxbDITI08SFCjprtg0biVoCGT5Mn+VMeqBrLpJLrLFXCdjBqVnoTBMKzrwAax7kKJP4iCUaMQCqtWlhSumhrDCkFmOGzP3fDqJztw8B4DAFhZm73cT4Zh2HL0UKQU18ApTw3DXkOakU4meD4UJ6bGDxJQMzWW+8lH9BOdBEol5JLiedLKytRI6uguuhbQY5N9OpVEhgzcbKBnxsfOzjxKJLmcu6aGMC1Omhpy32nkEyD2G9km4kJhF/cTX0mXX5mrKJEAWhyutZPQ1wny5K9yPxk+qoN7reBt7iciiHWLfuouGJwJlMcEt+gn2VirFJYQuOjK1ACma1d+HmXQ7L6cqSFiYVUZHga/0U8FKSkrjX6iLC+7fgu/cijWbOsQIi53H2i9p9u6JVmsBWrfgjqAU/STk/tJ1rqMJHV2AHX0k6ypkTs3+zOMjMKJREJ4WKod0g1Qirdky1HDwKjYj7d14HPXLcVtz37Av6Mak2aFpuZT5aRmgF17AvSAqSmWeDQKHTz/64SxWHXl8dh3mMmS+I1+olW/ZVEkoC6TUJSYGnkw7d+Y4dqcj7d2WEZNBf2FTa62PDUVRD8Bal0NjSbLkhTvXroamq9J5bZkxRo37ewSWAw3Q8ypzAEFdQPJEUnC7xVsBOCkqRFznTBjkl32lmzaJflesIKW/7+9Lw+zqjjz/p279t5N792sDYKA7CgtrknoERyjoowrGZchEA0kZnAIH3kiZJvg6Bc1GqOTZ9zm02jG7zOYGEMeFNFEWlSWGFwQCIvS3WxNL/R2t/r+OLfq1KlbZ7kLvVzr9zw8t7n33HurbtWpeuv3/t73NVISCHlquPfzG6FVck4n5rM6nquGGjXMCPV4Eq7n89TwBS1FJtBrMR8BSLVuqYC2rc9CU8MfWsPRGBsjq/lCjdm+SIyxkjQBIsDJG7yJ5R3camrEABK+jhZ/JqRjNq6iAJdMMFcoT3Q/xR+555zy5vQHBr4FWQBp9JONUDghEVWJYNS4iX4STzKsFlL67ifAvBmlKjhOBzzzYcVU0N9gyyfH8PcTXXj5r03sNV6fQRPe8RmFR3I3qJjPBXChqeGSsAU5o6YvwmtqzIsnP65uBa+9IaMfcqbGoJcpxIKW4mKaH/CypHKftXZLk++5hVVBy1TcT4A8VfxpLqQbcF/hPCLJywEYvws1ajp6I8yQ0DT7jcKVpobLg1KUKxo1du6nRE1NB4t+Mr9H/Gq7jdpwP7nV1Fi5n4z38+5Oq+rgTlXvKVNztLMP0RgxFetNYGo8RgFS3v0kukyp0SfT2WUi+gkwr02y6Cc+kSLPhIjjTUHXbn7c+bqApjIJKTM1MeF+MA5hUYn7SYYRw0T3k2JqshYGU+MxuYGYL1X4lUVjg97cFDJtQ0KeGouMwpEYMdG4qcJU1K+fyyQA5qKWfUKOGgr6W38WF7zyyQz5E78YjQIAo8oMKtUItTReT5qpkYV0S76XgrJHXQ6ZcalBJ4qkjXbEF09uEY+I7idhocoL+lAVZwdPnO4zop9ScT9ZaBh6bVxmIjzcYi1jasTfM4/TI/3ur03404ct0s8N8Zoabg7T37EozvwARv6NXL91gUDApfuJMzBEY8Pe/WTN1IjpIcQ22m3UhlDYmakhhCTkc2Eh3RErpsbK/WT8LdvsyguCLB3/idN9XBSpJ8EQ58tahCLEJqOwtftJlj8qFfBCYRlTA5hLf1jtAxT0Hj55OtGYBcyaGtHocAqhttJa8kaXSShss2UkamrirOEg09QMfAuyAHxmTTGREiBhahLqoJgni8yoKc4VmRrRFaM/8gtXOgxLnl9Op/YX+FwPVu4natjRJHK8FoFuaB5NLqarLMxhC09K0U+uQrqtN5qS+Hi2CZXaRVjpiSjYosUxU4ypEfLUUOQHvMxIPtUdTs/9FP/oBE2Ni/BoHlaVurv6ImyxL2DhpfpnHjzZhbte2IlvPb9TGjnFhwjz9wKdN5qmMZH+obhR46QB4pOLWd0W/KlddD/x7oMErR2LfjLmhHWeGvN32m3UyYR090V44TFlahLfb2JqUgzp9no0VMXZsub2XqOshVdjdYsAfS3QNF6vGLMJ6dYfZe4n0a2WKvh7nWlqhNILfk53YxUwQiEzZjtkTI038WDjdGgwCt6ay+fwiSf5gpt2Br3I1NArVUbhLIRl7SdWr0VYvITVsCTXb9qwZda3z+sxGTYiU0MXEL4SbzoMC38C6u+QbsBIchaKxhJKJFAwpqZVZ2o6eiNsI+PFr+KNluv3wuvRUBZX+NPuaUnQqHaaGjcnQlr2or0nbJkeHUgsDyFCFv1kFKeTb4D5QSPnxKmuUFpCYVm0iUnc7NqoMXQFgG6Y3frku5jygz/ho+YOAIaBQD/zvYOtIEQfa7E4LGAuaMlHjfDMAnVBHTzZBcDZCDPlmbHYzINc2QxRKBxw4X5qk4R0077IKH/ArfvJ2ajhhcdUzC5zP8lym4jg7ycr5rOKEwuLBTLpukMPcCadXZJCYT6fj12VbjcIcgaLUaJCzsjxQmEr44/OzZNdRrBIR69EUyNJSuh0fzH3dJSYmEu6N0SixFgvbAwaQD9Y84JoejnfJFXQMktgin7iLGPLgpbCDZ4f9JlzWVgsALyuRlxI6ALLn6bSYVj4xX0g/KT8aUgskUBBFz9+saa+aKYT8Xri+R2M34L2jRYppIn4vKZF2P6343+THL+H3czdfRHWXqu09YDB1BBi9p+LMIwD+RjINDXURmJaIWEC5gd8zKg61R1KU1OjP/In496wIY50E/2kfzcNu9fbcri1G29+ehyE6KG/184cjlmjS1j7AeD9g6fY+1u7ZUYNx9SYhMLG39SoOXySMjX2m4SbMgmAEflmx9SItxWf34SCbsTU0KGpHRKNGmf3k5syCbyrj84bWZXvKHe6tzLu+P5ZzS0jAqrHlFFYf9Q/l96L9PlwhDBXmHhf0LYkVI0PR1mbMyUUNjE1Fu6nU11hNp5W64EVU0PvKbq/+CWammSS78k0ZqGoc3QWhaZpTCysafI8NXbRiP0FFdKdAUQ51T4fZuw2o3BB0IfCHB+Ox8O6rRTkw/IDOHiyW7qQ0AWWLjyaZi/6ckKeianpf/cTn7XTOk9N4u90qjuMsoKgKSU4oC+M9Oalp5ufXTcDnx7txNThxfHP44yaJGo/5fi9bBM/yS1MdtWAKfPW3hPGqe4Qygrk9ZWckthJ89SIQuEETQ3vfgqxvqRyypIl3+NLGLjR1AAGg0FZo5YOPSJmTFketqz6sulaOn4ft3Sw51pPWxs1fq/HrAHh5jM1ag6lYtTY3F8FOT6c7ApJhMK8pkZgaiSfR/Ut1AVXGq/DJdpTVon3AC6kO6InLLRzMciKscoKYjqxD4AY/SS/rrpI3ySbO3oZYynWNaO/maEfi+FEfK0UjTkrdyjtl9ejuXaJWoEaLF19UeZmFe91Ok+a23UWOS/gtWRVGEMnuJy6Q1HkB33mQBThd0yuoKWV+yl+rQNTA+i6mk+PnjaNrUk7pZia7AA/6bxc9JNV7Sdxw8wPek2LiNXmQjcimTvIYGqMhdxu8XJCrilEceCYmnCUj34SNDWSBZWeaEWdCM+s0EWtujgHl0yokJ44nIXCxrW8poa6T/ICXke3HQ3Tb+1ywdRYaWq4ZI8UIp2cqKnxYVj8xM9ralIyauKP/MmYtjngS6TLrcCPNwAcjRs1VUK6A8AYP/4wLmNqeMG8LKMwYCS+PMTcT/bnPDdCYcAQNSeGdNu5nxJ//85e/cROjWVaMV28td24nwiBqY6aDLLEkUbtJz76yWCnrWCKfrK4F2ok7ifRmBELkDa39aKpvReaBkyMJ5Jk32lRJoFlXQ760loXAWMO/P3EaQD6fBRTbtBxpuHq1NUt/bx4P0UZEHUFmsokCAc5J6Ewr0Pi3U8yIbObe5UyNaZLVfRT9oGv/cTnBRDrtVCIpxbK1FBYUXjMqJFMPqapoRtKmpMrj7tZBkIozLuf+hw0NTyoyFLUifCFCK02Lv4nc6zSzb3OV+mmcENxU3diq0QPQuGkqWFZVmVC4XiT+M2FhiwzpqYrXfdTIlPTk6RIGEjM7kuNmuriRKNGduKV/Yb0s/gQVsDM8FGmpstlCLqbjMKAYYxVF5sZOHPtJwivJX5eOErQF4mx/tHNUTSI7Fyd/NxxKpUgy7rLJ+873tmHZ985xNYZqxw1ehuNv63mFhWf7mnp5IxQs4CffgfVgVAW76yKggSmxqpMQqZy1ABGXz49qhs1o8vyLYuTNsfbWmpT6d4qeozmquHLJKTH1HDGkdcwdqIWh28ZRsRTQWiDmKlR7qcMwMzUpKapMTE1Vu6n+CYoNWooUxOniNM1RAZcKEyFdlHnPDU8aK4H/lSif16ipkZEMkyNSVMjuZHd5MIo5XQtVrAKXaXgmUEKkanhf6b8gH5Spd/d1hNmmiJaWDIZsD2N20RY5FMSFXt5oTUAtLTr7oVqG6aGx8kk3E9+ifuJIj9D7qe1X52MyyZX4ZLx5gRm9gUt5XOuozeMk6f134OOWzJCYX9cVxaN6VqUYljPTVndMj753r1//AT/b8fnuO2CMQDsfwOvi/upfmwZPBrwSUsne87HNDRmTY24pk0fWZLweVZlEmT9ShWGUaO3ua48z/Kao3GmpjzfmqmxWl8NpoarNp+gqXHL1Bh5gPgCr6EIF/3khqmJh3XzVw622k/KqMkA+OgnM1PjHNJNy8Dzi5KlUDjf2v3EjBpa/DFdpiYwsEyNn2NqaJ9EqlW2oCa4nxhTk+h+EsHf1G4qqV8wrgw94SiG5QVMWhrAPkcNBa9rsYJTvhefzP1ko6mhvv+SuIEcjREWdZFenhrjuWQS71FYMTVy91Pibyv7DXn3UywmN0ZEoybXyf1kY5TwGFOejzHl+QnPm9xPwvy10q519kbY/KIGaDIh3YA+f073RRxrjYkVugGz0HjnYV2c/cHnbXqbbTZCN6G+pfkBzBo1DO8fMkTfjKGhxg1zQ5k/w86oEV05mar7BBhzoC3OCo8pk40z1dRQpsbaqLFaX2lYtxHSLYl+cmRqjEACWYHXMBf95EpTw9xPHPvLvT4Yop+UUZMB8P5lafI9G6Ew873nutfUyDZz+hz1HbsVaFrBZNQMRPI9qVBY0NRIFgPqfmLhvBKjxmrjcsqrwUPTNDz39Xr2dyruJ8bU2LifWDp4hzw10oKWLKSbM2rifQ/6vMgPeNEViuJEnOXIVEh3T5iWSHC/vPAJzQDDxWCnqQF09vJUdzjBqATACvjpTI3xPH//icVkkxEKp6LDt3U/CfdZeUEQJ0734Wh7L9PClDJNjcDUOIQp5/g9ON1nFvvKIEscSZnI1q4Qjnbq47I37npxLxS2nltfmVRpMmr8LPqJPuqfIx72ZowoSfgsekksXr28qa0XZ1cXGlohF4cNJ4j3icx4pW2l89gqEACwZuhoVCSvNRJ/x2Sin0KSjMLhJKKfAGB8ZQGKc/2m2nmDjakZ+BZkAfiMwvwEpQt0QuZQycmZ3mwBn7XAl4ZzipVaAWNiNbXFtQiSzSAZmITCAzBRqVHQ3hO2dD/x2gh6c4tMjRE5YVxr5WIwMzXON7imaWysREPUTuNAQYuUuhEKWwkCeWbwx698hAUPvYUdh9oA8JmSOdcbF6UhFknNVPK9npC9ISaDUZVd7y8VWIqaFMBseFx4VjkAuWEY5u5LfjxleWooMuV+soLPVihsFlzSSskH45FZQZ+H9T1ZpiYoEfvKICslQJmalo5exoDQGkV2TI1bjdq8iVWm/9PfISH6yWfePM8WRMIAVyaBENz1wi7Mf+gtfNTUcUaYGoo6G0auVRB4yyAezuh7KVMjy4NG4cjUUCY3GjOMfJ/HlHqEMbsumJrCHD/e+u6X8eIdc9lzpozCSiicHTBpaoRiZkDi4qVpBv1HT870ZrO7+anYTGZk0LlEs+uK9aSShSmkO43Q8FRRG29/c3uPY54aADi7ugiAnhcCMDbHoJSpsWA90lDxi9e7cT+VsggkZ6GwE1PTG47iqbcP4JOWTnY6ZBmTuX7x7IlIiadyyqIbDp8fiYZ0J+N+YkxNRI8aPNZpzdTwBjctuicTChth/UKeGiFyjd/onNxPbpLvuX2/uIfwrxXmGMEDNDFgeUHQKGiZRJ4awBgLJ/eTNPrJZuO0qvsEuGdqJlQVmLLVsqgn0Q3FHWLOqS2Szlcj+gn425F2AMDupvaMVegGJEyNxP0kXmMX/ST+NlS30sESLxr5lsS12H30E2EehYCQt4keAN0a6cW5ftOcoL95IM2I20xBGTVpIhYj7PQiCrmoZSybK9Qap5sfvdnskhfNGFmCr06rwbJLxia8RifkkTY9L4IsaiQZmDU1/T9NauM3dlNbD/oiVkyN8cNOrokbNXEDIRwxR1LwfbAWCht/J9tnjzD27qKfKFPjRigsbw9t5+enehAj+sJy43kj0TCpCg2T9RMwv87wTESJUCQ1FX94bXyeNcXnHWAYYslFP+mN7IvqkT6U5awslLif4vOgND/Axl3mfopYVH0W6f5Kjq3JVPI9K9iGdAvzh64JB0/oRg1vhCbL1ORwuWrsICslYOfisI1+4kO6beaWpmmYN7GS/V/U1FB3FH9wmC5xPQHG70IjtQDgyKmeMxL9BOjrd7nEYBHXD3v3k3kwaYRRIlOjGw38updM9BPvfuJ/S3poTNUeoe8bDK4nQGlq0oZYrZafcGJqcx5+nweIJ1cCDE2N3cYS8Hnwi5tnSV+j30G/s1aoJ5Us6M3i0dJL4pcqDKOml+WyEBdXflOZXKNT0VS818dlFAbMv6uV1sPtImyFgM+DSNwIyVT0k5NQmI4NPc0PH5aLexdNk14D6MUsxe/n258s6AL8+SnDqElFKMwyCkdijGkqLwhI2zQ6Xoz0/LGlJl2SmFguxEV72FUirigMYv9xd2USAhlkauzy1BTm+NkGTBMD8qf9RKbGwajxuStqaRSzTHQ/Ge023I32mhrjbyd37lcmVeGZxkMAjE2eupeNPDXGZ8yQiIT179Sv4Y3cI2097OCZEaaGG6cx5XlSdkJkbu3cT6IBRFkrKtqOSIT/0RiBR3P+XXmmhh6yfV6zO5YeGlNd5z0WLviBgjJq0oRYrdYrWVRlk55OZJoJlC7OqZ4kxAkpVv5OFnTjHwiWBjCMspaOXsPgE5ka7sacJDA1CdFPXD+cDAQgtX4HfB62obtiavJdMDUuaz9RpkSspAuY+1XAGXRi5fdU/OF0AaZuTyDVPDV6G0PRGIt8krE0ADB79DC88q2LMLosj41TJEbQ0Rsx1UeLcNEeMa5v4kZQwX2PY0HLtJkaXpMjviYyNXGjptWZqXFydzL3k4NRY5d8j+LCs8rx570nADhoapIQkJ4/thTTR5agPD/A1ksjpNssHAbkkU+A/AB55FQP608mmBre/S9zPQEypsa9UTMyLsI1hMLmTMt+j4YQnCvKA+boJ1ZuQTh8U6YmlfkMKKYm60AnCqBvHrS6bIzwmprE99ENhG4yM0eWYOU/TMDs0cNSaoc4IWvSZWrii+BAGTUVhUH4PBoiMYLDcRbCKk9NSZ4fNfHNvK1bz8AajtoIhS3KF6SjqRHfY5e2nqI0blR09kYQjsakv7Vznpq4hiBuW4uVdAHzQs8LhROMmjSZGsqUGO4n98sLFcqf6OxjImsrF6qmaZgSL22hf48X3aEoTnWFmFHDJ7/0ez0mIbNYXoOPgEqmoGUqtwZvuCSWSRA1NXpf6KZTZjJqeJ2Uc/Zq6tamIm4e+4514mhHHy48q1wqFObzZhXl+HDxeMOosTvdJ1MgNujz4uXlF5qeE/PUlOYHcFZlAfICXowpS8wNA3B5kzg0tfdguKbfF5kwavhK7TKRMJB4L9mFdItCYaapiSffkzE1gDsm1MTUcAVeqa4zFDWiS1NhHgFjnAeLUTM4WjGEYWZqzCcKK6EwYEwA6n7yeDR8e954Fs2RLBKYmjSFwnTjH6iJ6vVobFPrsqjIS/tcU5zLEhOGojF0h6K2eWqsxKCZcD9RFLlYPIty/czgtXJBOQmFxZOyE1PDF96jpRIoUulzdXEOPJqefp+GhlOhsFNiMB4zRpUAAN47dMo2R40MdMPgXQ5hLobb5zVnYk1kalLT1GTe/cQzNf6EDZjXZfDvdbNRVxXp7+UZNQA43tmHa365FV97YhsOnuhi2hOe+Qn6POw0Prm2COMqCow220Y/pcd8igJhr0fDxrsuxsvLL7RkKGRrbXNbL2M9Mq2pccPUFAZ9tlpJE0MX9DGtm6xMAmC4Kd0UjzTyWMUkEaFxHVskPaaGDvNgiHwClFGTNnhNDR1cejMzTY3kVzaEwpmpasovIAGvx9aH6wbjKwtxzczhuPPScek2LWXUCht0Qp4aZtTkIJerv3SqO8Q2NVn0k1Wm22Q0ADLw3+HGd+/1aCys+pRFWHefY54awR9fKmNqjL+tmBpNSy3KLeDzMOODbpjdKbif5tSVAQB2H2nHgbgw1m1agjKJG483asQyCaK41WzUuK/9lMomwH93Qp6aBPeTeQ7xp33+q93MtfGVuiFCU/tT/MfGT9DZGwEhwF8/b5O6nzRNY/fRObXFJnbCraYmFYNZ1NTof9tH2MiaE4rGmNg609FPshw1gFn/U2rjegLMc6Io18/c7R3xul8iU+NLmakxoqj0NurfSzU1qQqFmabGIWdOf2FwtGIIg88hIPqCqWVsp6nJz0AyKMB8aqwuzkk7tM7r0fDgDTOwVBJp1V8QWQerPDU18f5StqaNK9JopFh3jn5Kpkq3DPxJxe2J0Kn+E9PUOFT4pRhekkjLy5Lv6d9tLLbphGMauhpd15OKpmZ4SS6Gl+QiGiPY/MkxAPIcNTIMkyQxpAcKgBo1/MZozdQ41n5KM09NgNvs7MokFOb4E9i+MkujxnmuTajShfT7jhnlCLYfOoX/u/1z9v/dR9rZqV3Ms0RZt3NqizCyNM8It7aJfuLnUyoGM83HlQzLYzWHu5LQujkh4Mb9xF3jdMD0CcYs/e3bu8MJmk3+0SnxHsBpaqKGcUTbRseOaWpSFgrD9LkDjcHRiiEM0YoGDAFryMb9lGmjhj81pisSHiyoFVxoojuDbqZUX8GXHegT3E+m6CeL39yThAZABv473OSpAZxLJTCjxoJqTgwHtXc/mbLxcu6ndNyMYgSUk8vMCvV1pQCMCJzKNNxPEU7PJmZiFX8zXlNjpbeicFsmwQqu3U9BX8IcsnY/ObMPZ1XpTM2h1m70hqOIxgjW/W43AMOw5rP6ipqwEcNy4fVoOHd0KfxeD0bFNS22tZ88htYiFYNZZCZcvcemJA2QGaaGHniKcnzstxPBzxO7YpaAeU4U5/qZLqyzL8L2ECCxXISb+0sW/STWw6OamtSjXJWmJqsQjRpMDQX92y5PDZ0Abjc/J/ATUnTbDFUkup/MN/E3LhmL3624ENefOxKAkXflVHdYIhSWb+w8MhH9ROF28RzmENbtVigM6PNOpkPhWTx+vvFMTTrhmNSQOtImup+Sm9tz4kYNhVv3UynL99PHngsxqp2eSrlDhySkmyLP7772U0oZhXn3k8f6NZn7yUoo7IZ9qCgIoiTPD0KA/cdPY9dnbdh9pAMFQR9+snAqAJ2pAfRcRmLfnrz1PLy8/EJmzIyNMxRW9ar0NuqPqZ7gxdpPbiAaijOFKKlMMDVjy/Ph82ioH1tmaazxTK8sjw0Pfm4W5RpaKkKMCCj+OoOpcTZqzHlqjBQH/CPNXZSKka6/T38MuND49AdU9FOa4Os+URiaGmum5oZzR4IQkrIwWAT/Hekm3hsscNTUeD2YxiXhopt0W3fIXihspU/hygqk5lpI3v1UmpfoOuHhWNCS2wiri3PkdcFM0U/W7qdUYeV+skoYaIWUjZqCxHITkaiZatc0DX6vhnCUJIbb5gcwc1QJYsR53GiSxUiMpCQUtnU/OQqF5SHdbuoZaZqG8ZUFeO/gKew7dpqN1cXjy3HBOF3PRF12MoO8sijHxJyNrSgAPj7mqvZTqid4OreT0bfxP6nXo2HW6GHYdqCVvVaQpKEtw8jSPDSumZeQvJKH38TU2Bs1/LVFOXq23qDPg75IzOSWFqOf3Bg1Mk2NXzCO+tJ2P8XHeZC4n5RRkyaYpkYiRLSq/QQAi2aPwKLZIzLWDn4+1WaLUcOFpWua803Di25DQvK9gNdYAKyYGjpOqVYlD3CskFvmw8hVIxcKuy2TAMhdT4CoqTE+JzfgRa7fi55wNKPuJ1YmwYH1EFFXns+KOAZ8HttNg4chFO5DLEbw6bFOZsiZaz55EI5GExZvj0fDS3deAELcRTTRJItnXihszurLM19akkwNAIyvKsR7B0/h06Od+OBznZWpryvFsPwAKguDOBbPwOvm8ybG6y7Z1TjzSMYgGbjR7SR8J68tLMoxFV4sCPhSDlsWIdYMExHg+myXTRgwG7NFuUYy1uOdfSajxigbof8erpgaKoWIxEwpDvjHdKOf6NsGi1BYGTVpQqqpoUJhG6Ym0+Bv1nRz1AwW8JoaN4mmhjH3U4ir+0OpVt79ZFGlm2oAUjxx0O8qzPG71hDY1X8ihHBCYXmbeOpaJhIGzG4Ose/D8vzoaU/XqDES8BFCUhIKA/pGXT+2FH/4oBnVRe7F7qzcRHcYj2zehwdf+xSLZukHBv6w4fdq6AnLN1m9OKm7dtIki6nsj7xbwm2eGgAok+gyNE13Ubh1ddIIqI+bO7E9rp85P87SnF1dyIwaNzmWvjqtFt2hKC6N196SgdfUpAKjoKX7H5ofk+HDck1sr5t+ZQqBpNxPZqZGf/SZjBqvJBAl14URQa/ly2P4BfaaZplOO/ppkDA1g6MVQxh89BOFGP2UocOBLbxZ6H7iKXg3pxKp+4kxNdQNYR01kO4iTH3Kyfjt7eo/9UViLL27pfuJW/CtmBp+bohCWMoUpWPU1BTnQtP0KIqTXaGUaj9RULGwKBK3A3XLHOvoxf955yAAYMOuIwDMBirtoxgGnyzoCTelPDXce8TDjl9wP/H6J1lGWvp+t/ONRkC99elxdIeiKMnzY0Kl/txEruK1GyMp4PPga+ePZtlvZaBdTTWBp6GpScao4e6HeEQdRSb0NG6RjPuJn6NUJEwf6bog04S509TEdTNcIVMxIrQ3zTIJKqNwlsGOqbHT1GQa/KTPFqEwoIf6ftLS6UrpzwuFaSCkGP2UZ8P4GHR5ikaNlzI17m8ru/pPfOVr6zIJRluHWxk1pugnkamJGzVpnLICPg+qi3LQ3N6Lz0/1pFT7ieK62SPx9+NduGJajev30D40t/ey5wy3sNn9BKTuDqGQVT93C1NGYhumpijHB69HQ0HQh9N9EenG6NGAKJJnauiaVV9XygwzWuUeyNzm70mT+SyPu20qHNw3pu/UzOug2ahJP/LJLfhxlrFsPMzuJ7/pUWbU0PnrZk2kbrDDrUbSRT9LEpthTc0gMWpSasWjjz6KMWPGICcnB/X19Xj33Xdtr3/xxRcxceJE5OTkYOrUqXj11VdNrxNCsHbtWtTU1CA3NxcNDQ3Yu3ev6ZrW1lYsXrwYRUVFKCkpwZIlS3D6tDmR1EAgGhcKyyzpsE3tp0yDLiBBn8cyzHAoghpobvy1ZqZG31hF/7FVNmGAp7vTcz8lE9FmV/+J5o/wezXLNrnS1FhEP/Hfn+6CRDePQye7mI8+2ZBuQDeEfnDVOThvTKnzxXGImwYvnOV/N+qCTEajIUOQMT4pGDUm95P5NVEorD/qfZG7n5JjaioKg6baWPXxhIeAmalxkw3bDdLd7JZdMha/XDwLN84ZlcR3Gn8PH5aL3ICXaa76k6nh+2xX9wkQjJp4G6kbinc/UdC/xVp4MlwyoQIBrwd7j51m7/UIjHRfJL3DN2Nqhqr76Te/+Q1WrlyJdevWYceOHZg+fTrmz5+PY8eOSa/funUrbrrpJixZsgQ7d+7EwoULsXDhQuzevZtdc9999+Hhhx/G448/jm3btiE/Px/z589Hb69x8lq8eDE+/PBDbNq0Ca+88greeustLFu2LIUuZxY0ysIUWsvy1NAq3We+HfTUV5OBxHuDCdQNYZWnhcewfIOpsYp+snOJpLsIBzlNjVvYRT855agBBPeThaaGzg2Z640awOmGY1KDat8x46CRbEh3qijK9ZnuvwdumMH+Np1wPakbIzzo/EjF/cS3R3y/UbhRY+PEjBqp+wmma5xAI6Aozh9rGDVnVRZwn5eZQ1G67qfCHD/+cWpNUuU2+I2ZGtr0YNSfTA2/wYs11kT4hYzC+qM+ptSoMRnnSeSpGV2Wj69fXMe9l2d84u6nNPPUDPmMwg888ACWLl2K22+/HZMnT8bjjz+OvLw8PPnkk9Lrf/7zn2PBggVYtWoVJk2ahB//+MeYNWsWfvGLXwDQWZqHHnoI3//+93H11Vdj2rRp+O///m80NTVhw4YNAICPP/4YGzduxH/913+hvr4eF110ER555BG88MILaGpqkn5vX18fOjo6TP/OBAxNDZ+/Qv/78zjl159C4WwRCVPQBcmNK4NGPx3t6GV0a3JGjf6YLlOTiqamKxTFD373IX74e+Pfz1/7FIB1NmHAWIg0zVpLRedffsCXYPBmwv0EGBFQr/6tmbXHTcbTTEDPJq334+Lx5fiHyVWYGa8lxRuospxFqcCfIfeTuIdQg6cwx8exMPomJ3c/6dfYRSCJGB/X1RTn+k3sTI7fy+oYuQkRd4OBCPU1GTVxQ3s4M2r6X1NTlONzPCTRIsj69X7T418/awMgZ2rcCIUBYMVXzmIRsWbjSP+cg/GCwana+gZTMzjy1CQ120KhELZv346GhgbjAzweNDQ0oLGxUfqexsZG0/UAMH/+fHb9gQMH0NLSYrqmuLgY9fX17JrGxkaUlJTg3HPPZdc0NDTA4/Fg27Zt0u9dv349iouL2b+RI0cm01XXkGlqSuLWNs1wSq3uMwlq4VvVIhmqoEm+nMR2gFHZmy+uSDc7+mgXikmp+VTdd/Q73BZiBPSFlrqEnt56EE+9bfzbsEs32O3SrNM2jy7Ns1w86TWyKAy64KfrshxXqY/T/uP6AlmWH+xXxnBkvObVTXFXxc3xR37eUM0V74JJBdRll8rneD0a08uITBY1yisLjflDC1HKCpXSTdopvJjH1Hj27QvPKktgiqaO0F+rLHL/eXaga5JYOPVMIuj3IOD1IOjzsN+Mzs3KJH6ndEHn2vBh1kJq8/UBaJoxlvSA0hTXifFzje4vpS61RnkBH+756mT9Pdz9QNcrulYWpXhfFDHDe3DIHpLabU+cOIFoNIqqqirT81VVVfjkk0+k72lpaZFe39LSwl6nz9ldU1lZaW64EPcQ1AAAENNJREFUz4fS0lJ2jYg1a9Zg5cqV7P8dHR1nxLAZWZqHFV8+y7SwrL1yMl7e1YRoLIa8gA83nndmDCoe18wcDkII5p9Tfca/qz/RMKkKP144BRe5SFJYlOPHY1+bjV2f6eGqI4blYXp8oT5/bBl+es1UzKkbZvn+88aU4t5rp2L2aOtr7HBz/SjkB734x6nuRa4ej4Zf/fNsvL3/hPR1DRoWTLEe03EVBXjg+ummyskiRpXl4ec3zjDl7KC4cnoteiNRzJtUJXmne/zj1Bq0doVZVt9LJ1Q6vCOz+I9F0/Bxcwcuj/9W/zR7BLweDTO4jLI/XjgFOw6dwqxRqY0vxborJ2Pb31tx/lj3uh8ej//zbHT2RhKMoglVBfjf1003MSj/a8EkzB1bJr2vf3HzLBzr6EvKiL7uXD3UvWFS4visXjARs0cPw5XTa11/nh2+fHYlfrJwCi4en5kEo26Q4/fisa/Ngs/rYW6rJReNRUVBEFfPGN5v7Tintgj3/dM0nFNb5HwxgF8unoVTXSG2j1w7awR6w1G094ShQcNl5xj3592XnY3ZY0px2WT39+yCKdV4bPEs1HDG8bfnjUdNcS5C0Sj8Xg/+KcW8ad/80jiMrcjHNbMyl3ctLZAkcOTIEQKAbN261fT8qlWryJw5c6Tv8fv95Ne//rXpuUcffZRUVlYSQgh5++23CQDS1NRkuua6664j119/PSGEkH//938nEyZMSPjsiooK8stf/tJV29vb2wkA0t7e7up6BQUFBQUFhYFHMvt3Uu6n8vJyeL1eHD161PT80aNHUV0tP01WV1fbXk8fna4RhciRSAStra2W36ugoKCgoKDwxUJSRk0gEMDs2bPx+uuvs+disRhef/11zJ07V/qeuXPnmq4HgE2bNrHr6+rqUF1dbbqmo6MD27ZtY9fMnTsXbW1t2L59O7tm8+bNiMViqK+vT6YLCgoKCgoKClmKpBWsK1euxK233opzzz0Xc+bMwUMPPYSuri7cfvvtAIBbbrkFw4cPx/r16wEAd911Fy699FL87Gc/wxVXXIEXXngB77//Pn71q18B0CMXvvOd7+AnP/kJxo8fj7q6Otxzzz2ora3FwoULAQCTJk3CggULsHTpUjz++OMIh8NYsWIFbrzxRtTWZsb/q6CgoKCgoDC0kbRRc8MNN+D48eNYu3YtWlpaMGPGDGzcuJEJfQ8fPgwPF958wQUX4Ne//jW+//3v43vf+x7Gjx+PDRs2YMqUKeya7373u+jq6sKyZcvQ1taGiy66CBs3bkROjiGAe+6557BixQrMmzcPHo8HixYtwsMPP5xO3xUUFBQUFBSyCBohtLpMdqOjowPFxcVob29HUZE7RbqCgoKCgoLCwCKZ/XtwpABUUFBQUFBQUEgTyqhRUFBQUFBQyAooo0ZBQUFBQUEhK6CMGgUFBQUFBYWsgDJqFBQUFBQUFLICyqhRUFBQUFBQyAooo0ZBQUFBQUEhK6CMGgUFBQUFBYWsQNIZhYcqaI7Bjo6OAW6JgoKCgoKCglvQfdtNruAvjFHT2dkJABg5cuQAt0RBQUFBQUEhWXR2dqK4uNj2mi9MmYRYLIampiYUFhZC07SMfnZHRwdGjhyJzz77LCtLMKj+DX1kex+zvX9A9vdR9W/o40z1kRCCzs5O1NbWmmpLyvCFYWo8Hg9GjBhxRr+jqKgoaycroPqXDcj2PmZ7/4Ds76Pq39DHmeijE0NDoYTCCgoKCgoKClkBZdQoKCgoKCgoZAWUUZMBBINBrFu3DsFgcKCbckag+jf0ke19zPb+AdnfR9W/oY/B0McvjFBYQUFBQUFBIbuhmBoFBQUFBQWFrIAyahQUFBQUFBSyAsqoUVBQUFBQUMgKKKNGQUFBQUFBISugjBoFBQUFBQWFrIAyatLEo48+ijFjxiAnJwf19fV49913B7pJKWH9+vU477zzUFhYiMrKSixcuBB79uwxXfOlL30JmqaZ/t1xxx0D1OLk8YMf/CCh/RMnTmSv9/b2Yvny5SgrK0NBQQEWLVqEo0ePDmCLk8OYMWMS+qdpGpYvXw5gaI7fW2+9hSuvvBK1tbXQNA0bNmwwvU4Iwdq1a1FTU4Pc3Fw0NDRg7969pmtaW1uxePFiFBUVoaSkBEuWLMHp06f7sRfWsOtfOBzG6tWrMXXqVOTn56O2tha33HILmpqaTJ8hG/d77723n3sih9P43XbbbQltX7BggemawTx+gHMfZfekpmm4//772TWDeQzd7A1u1s7Dhw/jiiuuQF5eHiorK7Fq1SpEIpGMt1cZNWngN7/5DVauXIl169Zhx44dmD59OubPn49jx44NdNOSxptvvonly5fjnXfewaZNmxAOh3HZZZehq6vLdN3SpUvR3NzM/t13330D1OLUcM4555ja/5e//IW99q//+q/4/e9/jxdffBFvvvkmmpqacO211w5ga5PDe++9Z+rbpk2bAADXXXcdu2aojV9XVxemT5+ORx99VPr6fffdh4cffhiPP/44tm3bhvz8fMyfPx+9vb3smsWLF+PDDz/Epk2b8Morr+Ctt97CsmXL+qsLtrDrX3d3N3bs2IF77rkHO3bswEsvvYQ9e/bgqquuSrj2Rz/6kWlcv/Wtb/VH8x3hNH4AsGDBAlPbn3/+edPrg3n8AOc+8n1rbm7Gk08+CU3TsGjRItN1g3UM3ewNTmtnNBrFFVdcgVAohK1bt+KZZ57B008/jbVr12a+wUQhZcyZM4csX76c/T8ajZLa2lqyfv36AWxVZnDs2DECgLz55pvsuUsvvZTcddddA9eoNLFu3Toyffp06WttbW3E7/eTF198kT338ccfEwCksbGxn1qYWdx1111k3LhxJBaLEUKG/vgBIL/97W/Z/2OxGKmurib3338/e66trY0Eg0Hy/PPPE0II+eijjwgA8t5777Fr/vjHPxJN08iRI0f6re1uIPZPhnfffZcAIIcOHWLPjR49mjz44INntnEZgKx/t956K7n66qst3zOUxo8Qd2N49dVXk6985Sum54bKGBKSuDe4WTtfffVV4vF4SEtLC7vmscceI0VFRaSvry+j7VNMTYoIhULYvn07Ghoa2HMejwcNDQ1obGwcwJZlBu3t7QCA0tJS0/PPPfccysvLMWXKFKxZswbd3d0D0byUsXfvXtTW1mLs2LFYvHgxDh8+DADYvn07wuGwaTwnTpyIUaNGDcnxDIVCePbZZ/Ev//Ivpqr0Q338eBw4cAAtLS2mMSsuLkZ9fT0bs8bGRpSUlODcc89l1zQ0NMDj8WDbtm393uZ00d7eDk3TUFJSYnr+3nvvRVlZGWbOnIn777//jND6ZwpbtmxBZWUlzj77bNx55504efIkey3bxu/o0aP4wx/+gCVLliS8NlTGUNwb3KydjY2NmDp1Kqqqqtg18+fPR0dHBz788MOMtu8LU6U70zhx4gSi0ahpkACgqqoKn3zyyQC1KjOIxWL4zne+gwsvvBBTpkxhz998880YPXo0amtr8cEHH2D16tXYs2cPXnrppQFsrXvU19fj6aefxtlnn43m5mb88Ic/xMUXX4zdu3ejpaUFgUAgYbOoqqpCS0vLwDQ4DWzYsAFtbW247bbb2HNDffxE0HGR3YP0tZaWFlRWVppe9/l8KC0tHXLj2tvbi9WrV+Omm24yVUD+9re/jVmzZqG0tBRbt27FmjVr0NzcjAceeGAAW+sOCxYswLXXXou6ujrs378f3/ve93D55ZejsbERXq83q8YPAJ555hkUFhYmuLWHyhjK9gY3a2dLS4v0PqWvZRLKqFFIwPLly7F7926T3gSAyY89depU1NTUYN68edi/fz/GjRvX381MGpdffjn7e9q0aaivr8fo0aPxP//zP8jNzR3AlmUeTzzxBC6//HLU1tay54b6+H2REQ6Hcf3114MQgscee8z02sqVK9nf06ZNQyAQwDe+8Q2sX79+0NcZuvHGG9nfU6dOxbRp0zBu3Dhs2bIF8+bNG8CWnRk8+eSTWLx4MXJyckzPD5UxtNobBhOU+ylFlJeXw+v1Jii8jx49iurq6gFqVfpYsWIFXnnlFbzxxhsYMWKE7bX19fUAgH379vVH0zKOkpISTJgwAfv27UN1dTVCoRDa2tpM1wzF8Tx06BBee+01fP3rX7e9bqiPHx0Xu3uwuro6QbgfiUTQ2to6ZMaVGjSHDh3Cpk2bTCyNDPX19YhEIjh48GD/NDCDGDt2LMrLy9mczIbxo/jzn/+MPXv2ON6XwOAcQ6u9wc3aWV1dLb1P6WuZhDJqUkQgEMDs2bPx+uuvs+disRhef/11zJ07dwBblhoIIVixYgV++9vfYvPmzairq3N8z65duwAANTU1Z7h1ZwanT5/G/v37UVNTg9mzZ8Pv95vGc8+ePTh8+PCQG8+nnnoKlZWVuOKKK2yvG+rjV1dXh+rqatOYdXR0YNu2bWzM5s6di7a2Nmzfvp1ds3nzZsRiMWbUDWZQg2bv3r147bXXUFZW5vieXbt2wePxJLhthgI+//xznDx5ks3JoT5+PJ544gnMnj0b06dPd7x2MI2h097gZu2cO3cu/va3v5kMVGqgT548OeMNVkgRL7zwAgkGg+Tpp58mH330EVm2bBkpKSkxKbyHCu68805SXFxMtmzZQpqbm9m/7u5uQggh+/btIz/60Y/I+++/Tw4cOEBefvllMnbsWHLJJZcMcMvd4+677yZbtmwhBw4cIG+//TZpaGgg5eXl5NixY4QQQu644w4yatQosnnzZvL++++TuXPnkrlz5w5wq5NDNBolo0aNIqtXrzY9P1THr7Ozk+zcuZPs3LmTACAPPPAA2blzJ4v+uffee0lJSQl5+eWXyQcffECuvvpqUldXR3p6ethnLFiwgMycOZNs27aN/OUvfyHjx48nN91000B1yQS7/oVCIXLVVVeRESNGkF27dpnuSxoxsnXrVvLggw+SXbt2kf3795Nnn32WVFRUkFtuuWWAe6bDrn+dnZ3k3/7t30hjYyM5cOAAee2118isWbPI+PHjSW9vL/uMwTx+hDjPUUIIaW9vJ3l5eeSxxx5LeP9gH0OnvYEQ57UzEomQKVOmkMsuu4zs2rWLbNy4kVRUVJA1a9ZkvL3KqEkTjzzyCBk1ahQJBAJkzpw55J133hnoJqUEANJ/Tz31FCGEkMOHD5NLLrmElJaWkmAwSM466yyyatUq0t7ePrANTwI33HADqampIYFAgAwfPpzccMMNZN++fez1np4e8s1vfpMMGzaM5OXlkWuuuYY0NzcPYIuTx5/+9CcCgOzZs8f0/FAdvzfeeEM6L2+99VZCiB7Wfc8995CqqioSDAbJvHnzEvp+8uRJctNNN5GCggJSVFREbr/9dtLZ2TkAvUmEXf8OHDhgeV++8cYbhBBCtm/fTurr60lxcTHJyckhkyZNIj/96U9NRsFAwq5/3d3d5LLLLiMVFRXE7/eT0aNHk6VLlyYcCgfz+BHiPEcJIeQ///M/SW5uLmlra0t4/2AfQ6e9gRB3a+fBgwfJ5ZdfTnJzc0l5eTm5++67STgcznh7tXijFRQUFBQUFBSGNJSmRkFBQUFBQSEroIwaBQUFBQUFhayAMmoUFBQUFBQUsgLKqFFQUFBQUFDICiijRkFBQUFBQSEroIwaBQUFBQUFhayAMmoUFBQUFBQUsgLKqFFQUFBQUFDICiijRkFBQUFBQSEroIwaBQUFBQUFhayAMmoUFBQUFBQUsgL/H8ATZtdflhg3AAAAAElFTkSuQmCC" + "text/plain": "
", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABSwAAAFfCAYAAABEEoKYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAADqFElEQVR4nOzdeXhU9b0/8PfsM5lksieTsIRIWAVEcCFCrexVrHrF/mpr1dbtalEUe1FoFRXcilWrFrULil28Vq3WCq0QVi8CogjIvoYkkH2ZLJPZz/z+mDknCVknObO/X8+T54E5JzPfTDIz53zOZ1F4vV4viIiIiIiIiIiIiCKAMtwLICIiIiIiIiIiIhIxYElEREREREREREQRgwFLIiIiIiIiIiIiihgMWBIREREREREREVHEYMCSiIiIiIiIiIiIIgYDlkRERERERERERBQxGLAkIiIiIiIiIiKiiKEO9wKigSAIKC8vR1JSEhQKRbiXQ0REREREREREFFW8Xi+am5uRm5sLpbLnHEoGLPugvLwcQ4YMCfcyiIiIiIiIiIiIolpZWRkGDx7c4z4MWPZBUlISAN8TajKZwrwaIiIiIiIiIiKi6NLU1IQhQ4ZIcbaeMGDZB2IZuMlkYsCSiIiIiIiIiIion/rSbpFDd4iIiIiIiIiIiChiMGBJREREREREREREEYMBSyIiIiIiIiIiIooYDFgSERERERERERFRxGDAkoiIiIiIiIiIiCIGA5ZEREREREREREQUMRiwJCIiIiIiIiIioogR1oDlsGHDoFAoOn0tWLAAAGC327FgwQKkp6cjMTER8+fPR1VVVYf7KC0txbx585CQkICsrCwsXrwYbre7wz5bt27FpEmToNPpUFBQgDVr1oTqRyQiIiIiIqIwsjrdcLoFVLc44HQLsDrdvX8TERGFVVgDll999RUqKiqkr6KiIgDAD37wAwDAokWL8Omnn+KDDz7Atm3bUF5ejhtvvFH6fo/Hg3nz5sHpdGLHjh145513sGbNGixbtkzap7i4GPPmzcP06dOxb98+PPTQQ7jrrruwfv360P6wREREREREFFJ2lwcrt5yC+akNMD+5AeanNuCFLadgd3nCvTQiIuqBwuv1esO9CNFDDz2EtWvX4sSJE2hqakJmZibeffdd3HTTTQCAo0ePYsyYMdi5cyemTJmC//znP7j22mtRXl6O7OxsAMCbb76JRx99FDU1NdBqtXj00Uexbt06HDx4UHqcm2++GRaLBZ999lmf1tXU1ITk5GQ0NjbCZDLJ/4MTERERERGRrKxON1ZuOYUVRcc7bVs2eyQWTx8Oo1YdhpUREcWnQOJrEdPD0ul04q9//SvuuOMOKBQK7NmzBy6XC7NmzZL2GT16NIYOHYqdO3cCAHbu3Inx48dLwUoAmDt3LpqamnDo0CFpn/b3Ie4j3kdXHA4HmpqaOnwRERERERFR9NAolXhte3GX217dXgyNMmJOh4mI6DwR8w79z3/+ExaLBT/96U8BAJWVldBqtUhJSemwX3Z2NiorK6V92gcrxe3itp72aWpqgs1m63Itzz33HJKTk6WvIUOGDPTHIyIiIiIiohCy2F2w2Fxdb7O50GjvehsREYVfxAQsV69ejauvvhq5ubnhXgqWLl2KxsZG6ausrCzcSyIiIiIiIqIApOg1SDFout5m0CBZ3/U2IiIKv4gIWJaUlGDjxo246667pNvMZjOcTicsFkuHfauqqmA2m6V9zp8aLv6/t31MJhMMBkOX69HpdDCZTB2+iIiIiIiIKHq4BAELp+V3uW3htHy4BCHEKyIior6KiIDl22+/jaysLMybN0+6bfLkydBoNNi0aZN027Fjx1BaWorCwkIAQGFhIQ4cOIDq6mppn6KiIphMJowdO1bap/19iPuI90FERERERESxx6hVY8mMAjw+e4SUaZli0GDZ7JFYMqOAA3eIiCJY2KeEC4KA/Px8/OhHP8Lzzz/fYdt9992Hf//731izZg1MJhMeeOABAMCOHTsAAB6PBxMnTkRubi5WrlyJyspK3Hrrrbjrrrvw7LPPAgCKi4sxbtw4LFiwAHfccQc2b96MhQsXYt26dZg7d26f1sgp4URERERERNFpT5kFo7MTUdPiRGaiFmUNdozOTgz3soiI4k4g8bWwX1LauHEjSktLcccdd3Ta9vLLL0OpVGL+/PlwOByYO3cuXn/9dWm7SqXC2rVrcd9996GwsBBGoxG33347li9fLu2Tn5+PdevWYdGiRXjllVcwePBg/OlPf+pzsJKIiIiIiIii14vbTmHjiVpMHmTCnnNNKMgwYscD08K9LCIi6kHYMyyjATMsiYiIiIiIotP3/rALG47X4LlrxuCxz47CI3hx9NHpGJnJLEsiolAKJL4WET0siYiIiMLB6nTD6RZQ3eKA0y3A6nSHe0lERCSz+lYnAGBsdiLmjMwEAPxlz9lwLomIiHrBgCURERHFJbvLg5VbTsH81AaYn9wA81Mb8MKWU7C7POFeGhERyaje5gIApCVocevkwQCAv+05C0FgsSERUaRiwJKIiIjijtXpxnObT2JF0XFY/CeyFpsLy4uO4/nNJ5lpSUQUQ+pbxYClBtePMyNJp8aZBhu2F9eHeWVERNQdBiyJiIgo7miUSry2vbjLba9uL4ZGyUMkIqJY4BG80oWptAQtDBoVbrooBwDwl29YFk5EFKl4NE5ERERxx2J3SSewnbbZXGi0d72NiIiiS/v3+lSDBgBw6yRfWfgH+8thYxsQIqKIxIAlERERxZ0UvQYp/hPXTtsMGiTru95GRETRRRy4k6hTQav2nf5eeUE6hqYY0GR349NDVeFcHhERdYMBSyIiIoo7LkHAwmn5XW5bOC0fLkEI8YqIiCgYpP6VBq10m1KpwC2TBwEA/rKnLCzrIiKinjFgSURERHHHqFVjyYwCPDZ7hJRpmWLQYNnskVgyowBGrTrMKyQiIjmIGZZpCR0z58Vp4Z8dq0F1syPk6yIiop7xaJyIiIjikl6jwvdGZeHR6QWoaXEix6SDW/BCr1GFe2lERCST+nYDd9obnZWES4ek4KsyC/533zk8+J0LwrE8IiLqBjMsiYiIKG4tXXcE+c9swnVv7caXpQ3MrCQiijFSSXhC597EYpblX/dwWjgRUaRhwJKIiIjiVn2rC7VWJw5WNqOkwRbu5RARkczEkvDULgKWN1+cC7VSgT1nG3G4sjnUSyMioh4wYElERERxq85/IgsAFU3sYUZEFGsauikJB4AMow7XjMkCAPzlG2ZZEhFFEgYsiYiIKC55vV6pVBAAypvsYVwNEREFQ4M0JbxzhiUA/GSSryz8b3vOwiN4Q7YuIiLqGQOWREREFJesTg+cHkH6f0UjA5ZERLGmbUp45wxLALh2bDZSDBqcbbRj66naUC6NiIh6wIAlERERxaU6q7PD/yuaWRJORBRrehq6AwB6jQo/uCgHAIfvEBFFEgYsiYiIKC7V21wd/s+ScCKi2NOWYdl1wBIAbps8BADw4bcVsDrcIVkXERH1jAFLIiIiiktihqVRqwIAlDfa4fWyfxkRUSxpy7DsuiQcAK4YlooL0hNgdXrwn2PVoVoaERH1QB3uBRARERGFg3gSe2F2EnaXWWB3C7DYXEjt4aSWiIiih9frlbLpe8qwVCgUeOg7F2BIigGzR2aiusWBFL0GLkGAUctTZiKicGCGJREREcWlOn+ZYG6yHqn+6bEVTexjSUQUK5odbmnyd08ZlgBwx2VDseesBYNXFMH85AaYn9qAF7acgt3lCcVSiYjoPAxYEhERUVyqazc5NtekB8A+lkREsUTMpNerlTBoVN3uZ3W68estJ/H0xhOw+DMyLTYXlhcdx/ObT8LqZF9LIqJQY8CSiIiI4lL7ybG5yToADFgSEcWS+nYXpnqiUSrx2vbiLre9ur0YGiVPm4mIQo3vvERERBSX6v1Dd9LbZViyJJyIKHa0vzDVE4vdJWVWdtpmc6HR3vU2IiIKHgYsiYiIKC6JJ7LpRg3MLAknIoo5fQ1Ypug1SDF0vU+KQYNkfc/fT0RE8mPAkoiIiOJSVz0sKxiwJCKKGX0tCXcJAhZOy+9y28Jp+XAJguxrIyKinqnDvQAiIiKicBADlukJGni9vimyDFgSEcWOen+Zd2ovGZZGrRpLZhQA8PWstNhcSDFosHBaPpbMKIC+h4E9REQUHAxYEhERUVxqKxXUQqPyFZ2Us4clEVHMkDIsDT1nWAKAXqPC4unDsXj6cNS0OGE26eARvAxWEhGFCUvCiYiIKO4Iglc6kW0/dKe8yS5lWxIRUXTraw9LkVGrxk//dy+ue2s3PjlYCaOW+T1EROHCd2AiIiKKO00ONwR/XDItQQOFwvdvh1tAg83Va78zIiKKfA1SD8u+D81J0KpxsLIZZ+ptwVoWERH1ATMsiYiIKO7UWX0nsQkaFfQaFXRqlXRCW8GycCKimNC+9UdfmZN0AHwZ90REFD5hD1ieO3cOP/nJT5Ceng6DwYDx48fj66+/lrZ7vV4sW7YMOTk5MBgMmDVrFk6cONHhPurr63HLLbfAZDIhJSUFd955J1paWjrs8+233+I73/kO9Ho9hgwZgpUrV4bk5yMiIqLII57Ephvbsm7al4UTEVH0C7QkHAByk32fBZX8LCAiCquwBiwbGhowdepUaDQa/Oc//8Hhw4fx4osvIjU1Vdpn5cqVePXVV/Hmm2/iyy+/hNFoxNy5c2G3t32A3HLLLTh06BCKioqwdu1afP7557jnnnuk7U1NTZgzZw7y8vKwZ88evPDCC3jyySfxhz/8IaQ/LxEREUWGOqlMsC3rRgpYNvIklYgoFtTbOr/X9yYnyfdZUNHMbHsionAKaw/LX//61xgyZAjefvtt6bb8/Hzp316vF7/97W/x2GOP4frrrwcA/PnPf0Z2djb++c9/4uabb8aRI0fw2Wef4auvvsIll1wCAHjttddwzTXX4De/+Q1yc3Pxt7/9DU6nE2+99Ra0Wi0uvPBC7Nu3Dy+99FKHwCZRe1anGxqlEha7Cyl6DVyCwMbbREQxoq7dwB2RGLCsaGbAkogo2nm93rYMS0PfMyxzTL6S8ApmWBIRhVVYMyz/9a9/4ZJLLsEPfvADZGVl4eKLL8Yf//hHaXtxcTEqKysxa9Ys6bbk5GRcfvnl2LlzJwBg586dSElJkYKVADBr1iwolUp8+eWX0j5XXnkltNq2k5K5c+fi2LFjaGho6LQuh8OBpqamDl8UX+wuD1ZuOQXzUxtgfnIDzE9twAtbTsHu8oR7aUREJAOpJLxdmaDZJPYtY1YNEVG0s7k8cLgFAAFmWIoXr5oc8Hq9QVkbERH1LqwBy9OnT+ONN97AiBEjsH79etx3331YuHAh3nnnHQBAZWUlACA7O7vD92VnZ0vbKisrkZWV1WG7Wq1GWlpah326uo/2j9Hec889h+TkZOlryJAhMvy0FC2sTjee23wSK4qOw2LzndBabC4sLzqO5zefhNXpDvMKiYhooMShO6ldZViyJJyIKOqJF6bUSgUSdao+f1+Of+hOq8uDZgeP+4mIwiWsAUtBEDBp0iQ8++yzuPjii3HPPffg7rvvxptvvhnOZWHp0qVobGyUvsrKysK6HgotjVKJ17YXd7nt1e3F0CjDPquKiIgGqN7WxdCdZA7dISKKFe0H7igUij5/n1GnRpLO1waKnwdEROET1shLTk4Oxo4d2+G2MWPGoLS0FABgNpsBAFVVVR32qaqqkraZzWZUV1d32O52u1FfX99hn67uo/1jtKfT6WAymTp8Ufyw2F1SZmWnbTYXGu1dbyMiouhR78+wTDO0ZViKWTXsW0ZEFP3quxiu1le5Uh9LtgghIgqXsAYsp06dimPHjnW47fjx48jLywPgG8BjNpuxadMmaXtTUxO+/PJLFBYWAgAKCwthsViwZ88eaZ/NmzdDEARcfvnl0j6ff/45XK62QFNRURFGjRrVYSI5EQCk6DVI6aYxd4pBg2R935t2ExFRZJKG7hi7mBLOvmVERFFPzKRPSwj82L2tjyUvYBERhUtYA5aLFi3Crl278Oyzz+LkyZN499138Yc//AELFiwAACgUCjz00EN4+umn8a9//QsHDhzAbbfdhtzcXNxwww0AfBmZ3/ve93D33Xdj9+7d+OKLL3D//ffj5ptvRm5uLgDgxz/+MbRaLe68804cOnQIf//73/HKK6/g4YcfDtePThHMJQhYOC2/y20Lp+XDJQghXhEREcmtp6E7To8gbSciougkZVgaAs+wbD94h4iIwkMdzge/9NJL8fHHH2Pp0qVYvnw58vPz8dvf/ha33HKLtM8jjzwCq9WKe+65BxaLBdOmTcNnn30GvV4v7fO3v/0N999/P2bOnAmlUon58+fj1VdflbYnJydjw4YNWLBgASZPnoyMjAwsW7YM99xzT0h/XooORq0aS2YUQPB68bsvzsBicyHFoMHCaflYMqMAek3fm3YTEVFkquuiVFCnViE9QYO6Vhcqmuwdsi+JiCi6tO9hGSiz2CKkmRmWREThEtaAJQBce+21uPbaa7vdrlAosHz5cixfvrzbfdLS0vDuu+/2+DgTJkzA//3f//V7nRRfdGolLh2agrIZs1DT4kRWog5eeBmsJCKKEVKGpbHjiWxush51rS6UN9kxLoc9rImIopX4Pp86gJLwSmZYEhGFTdgDlkSRqL7Vhevf+goZRi3MSTq4PAIOLZ4e7mUREZEM3B5BGq52fqlgrkmPAxXNKOdJKhFRVBvI0J0cf4sQTgknIgqfsPawJIpUJQ2tAACv14tTdVYcq7HicFVzmFdFRERyaLC19ac8v1QwRxq8w5NUIqJo1jCAkvBcDt0hIgo7BiyJulDSYAMAFGQYMXVYGgBg66m6cC6JiIhkIpYJmvRqqFUdD4XErBqepBIRRTc5MiwrmpltT0QULgxYEnXhjD/DMi81Ad8dng4A+Pw0A5ZERLFAHLiT3sVJLLNqiIhiQ72t/xmWOUm+z4ImuxutTres6yIior5hwJKoC2KG5dBUA64angHAl2Hp9XrDuSwiIpKBNHCni5PYXKkknFk1RETRTMqwNASeYWnSq2HQ+E6VK/h5QEQUFgEHLL/55hscOHBA+v8nn3yCG264Ab/85S/hdDplXRxRuJTU+zIsh6Um4NIhKTBolKi1OnG4qiXMKyMiooGqs3ZfJpjDDEsiophQP4AelgqFou3zoJmfB0RE4RBwwPK///u/cfz4cQDA6dOncfPNNyMhIQEffPABHnnkEdkXSBQOYoZlXqoBWrWyXR/L2nAui4iIZCCVhBu7KglvmwzLrHoioujkcHtgdXoA9C9gCbTLuG9khiURUTgEHLA8fvw4Jk6cCAD44IMPcOWVV+Ldd9/FmjVr8I9//EPu9RGFxRl/wHJYWgIA4Ep/H8ttHLxDRBT1xKybVEPnk1izv2+Zy+OVAptERBRdxAnhCgWQrO9fwDInSRy8wwxLIqJwCDhg6fV6IQgCAGDjxo245pprAABDhgxBbS2zzyj6NdpcsPibdOelGgAAV/kDluxjSUQU/XrKsNSqlcjw386sGiKi6NT+wpRSqejXfZilFiH8LCAiCoeAA5aXXHIJnn76afzlL3/Btm3bMG/ePABAcXExsrOzZV8gUaiJ5eDpCRok6tQAwD6WREQxpKGHoTtAu0nhzKohIopK9bbuexX3VY6/RUglexoTEYVFwAHL3/72t/jmm29w//3341e/+hUKCgoAAB9++CGuuOIK2RdIFGolDb6BO3mpCdJtOrUKV/j7WLIsnIgouokZlt2dyEp9LBt5kkpEFI2kgTtdtP7oq5wkXrwiIgondaDfMGHChA5TwkUvvPACVCqVLIsiCqe2/pWGDrd/d3g6Np2oxbZTtfj51GFhWBkREclBnBLeXYalWAZYzqwaIqKoNJAJ4SIxw5Il4URE4RFwwLI7er1errsiCisxw3JouwxLoHMfS4Wif/1wiIgovNpOZLvLsGTfMiKiaFbfSyZ9X+Ty4hURUVgFHLBMTU3tMlCjUCig1+tRUFCAn/70p/jZz34mywKJQq2k3p9hmdoxw/LSISnQq5WosTpxpKoFY81J4VgeERENUE9Dd4D2AUuepBIRRSNp6M6AMiz10n053B7o1KwmJCIKpYB7WC5btgxKpRLz5s3DU089haeeegrz5s2DUqnEggULMHLkSNx333344x//GIz1EgVdVz0sgY59LLeyjyURUVRyuD2wOj0Aehi6k+zvYcmAJRFRVJIjwzItQQOtyne6XMmMeyKikAs4w3L79u14+umnce+993a4/fe//z02bNiAf/zjH5gwYQJeffVV3H333bItlChUSrrpYQn4+lhuPsk+lkRE0UrMulEqgGR91wFLadACT1CJiKJSg23gPSwVCgXMSTqUWmyoaHYgLy2h928iIiLZBJxhuX79esyaNavT7TNnzsT69esBANdccw1Onz498NURhZjV4UaNfxjD+RmWQFsfy22nfX0siYgouogDd1INGiiVXfcizk1umwwrCHyvJyKKNm0Zlv0PWALtB+8w456IKNQCDlimpaXh008/7XT7p59+irQ0X7ms1WpFUhL7+1H0KbX4sitNejVSDJ0PcC4b6utjWd3ixNHqllAvj4iIBqi3gTsAYE7ynaC6PF6p3yUREUUP6b3e0P+ScKCtjyUz7omIQi/gkvDHH38c9913H7Zs2YLLLrsMAPDVV1/h3//+N958800AQFFREb773e/Ku1KiEDhT7+tfOayL7EqgrY/l5pO12HqqDmOyGZgnIoomvQ3cAQCNSolMoxY1VifKm+zITNSFanlERCSDtotTA82w5KRwIqJwCTjD8u6778a2bdtgNBrx0Ucf4aOPPkJCQgK2bduGO++8EwDwi1/8An//+99lXyxRsIn9K/NSO/evFF15gb8snIN3iIiijngS293AHZFUFs6sGiKiqCPH0B2gXUl4MwOWREShFnCGJQBMnToVU6dOlXstRGF3RgxY9tBUW+xjufVULbxeLxSKrnugERFR5Knr40lsrkmP/eVNzKohIooyHsGLRrsbgAwZlv4hbJwSTkQUev0KWAqCgJMnT6K6uhqCIHTYduWVV8qyMKJwKG3wlYTnpXSfYXl+H0uWhRMRRQ9x6E5vJ7Fmf1YNA5ZERNHF4p8QDvgGrA0Eh+4QEYVPwAHLXbt24cc//jFKSko6TUlWKBTweDyyLY4o1MQMy2Fp3Qcs9RoVCvNSseVUHftYEhFFmXpb70N3AF+GJcCScCKiaCOWg5v0aqhVAXdA60AautPMzwIiolAL+B383nvvxSWXXIKDBw+ivr4eDQ0N0ld9fX0w1kgUMiVihmU3Q3dE3x2eAYB9LImIok29P8Myvc8BS2bVEBFFk7YJ4QPLrgSAnCRfhmV1iwNuj9DL3kREJKeAMyxPnDiBDz/8EAUFBcFYD1HY2F0eKZOmpwxLoK2P5bbTdexjSUQURaShO8Zehu6Ik2EbGbAkIoomcg3cAYDMRB1USgU8ghdVLQ4MSu75HIGIiOQTcIbl5ZdfjpMnTwZjLURhVWbxlYMnaFS9Zt6IfSyrmh04VtMSiuUREZEM+jp0J4c9LImIolJb64+BZ1iqlApkJ4p9LFkWTkQUSgFnWD7wwAP4xS9+gcrKSowfPx4aTccPggkTJsi2OKJQat+/sreMSb1GhSl5qdh6qg5bT9ZhdBb7WBIRRQMpw7KXE1kxw7Ky2QFB8EKpZCY9EVE0kErCZciwBHwXsMqb7GwRQkQUYgEHLOfPnw8AuOOOO6TbFAqFVBbLoTsUrfrav1L03eHp2HqqDttO1+HeK4YFcWVERCQHr9fb5wzL7CQdFArALXhRa3Uiy9/HjIiIIptYEp4iQw9LAMhJ0gNo5OAdIqIQCzhgWVxcHIx1EIXdmXpfhmVeat9601w1PB1PAdh6in0siYiiQavTA4fbNzSht9YfGpUSmUYtqlucKG+yM2BJRBQl2jIs5QlYmk1iSTgzLImIQinggGVeXl4w1kEUdqUBZlhePjQVunZ9LFkWTkQU2cS+ZmqlAok6Va/755r0qG5xoqLJjomDkoO9PCIikkGDjEN3gHZD2BiwJCIKqT4N3fnXv/4Fl8sl/bunr0A8+eSTUCgUHb5Gjx4tbbfb7ViwYAHS09ORmJiI+fPno6qqqsN9lJaWYt68eUhISEBWVhYWL14Mt9vdYZ+tW7di0qRJ0Ol0KCgowJo1awJaJ8WHkobAMiz1GhUK81IBALvONARtXUREJI86q+8kNt2o7VNWfNtJKssAiYiihdwZluIQtkp+FhARhVSfMixvuOEGVFZWIisrCzfccEO3+/Wnh+WFF16IjRs3ti1I3bakRYsWYd26dfjggw+QnJyM+++/HzfeeCO++OILAIDH48G8efNgNpuxY8cOVFRU4LbbboNGo8Gzzz4LwFfCPm/ePNx7773429/+hk2bNuGuu+5CTk4O5s6dG9BaKbad8WdYDkvrW4YlAMyfkIMHv3MBZo/MRHWLAyl6DVyCAKM24ORlIiIKsr4O3BGZmVVDRBR15JwSDgA5/s8CloQTEYVWn6IqgiB0+W9ZFqBWw2w2d7q9sbERq1evxrvvvosZM2YAAN5++22MGTMGu3btwpQpU7BhwwYcPnwYGzduRHZ2NiZOnIgVK1bg0UcfxZNPPgmtVos333wT+fn5ePHFFwEAY8aMwfbt2/Hyyy93G7B0OBxwONquoDU1Ncn6M1PkcXkEnGv0HYT0NcMSAG6/ZAhWbjmJn/19Hyw2F1IMGiyclo8lMwqg1/RebkhERKHT14E7olx/Vg0DlkRE0UMcupNmkGlKeJI/YMmhO0REIdWnkvBgOnHiBHJzc3HBBRfglltuQWlpKQBgz549cLlcmDVrlrTv6NGjMXToUOzcuRMAsHPnTowfPx7Z2dnSPnPnzkVTUxMOHTok7dP+PsR9xPvoynPPPYfk5GTpa8iQIbL9vBSZzlrsELyATq1EdmLfBitYnW68sPUUnt54Ahb/lVyLzYXlRcfx/OaTsDrdvdwDERGFklQS3sesG7EkvJIBSyKiqBGskvCqZgcEwSvLfRIRUe/6FbDctGkTrr32WgwfPhzDhw/Htdde26Gsu68uv/xyrFmzBp999hneeOMNFBcX4zvf+Q6am5tRWVkJrVaLlJSUDt+TnZ2NyspKAEBlZWWHYKW4XdzW0z5NTU2w2Wxdrmvp0qVobGyUvsrKygL+2Si6lPjLwYemGKBU9m3at0apxGvbi7vc9ur2YmiUYb8eQERE7Yhlgql9zbBMZg9LIqJoIgjetgxLmYbuZCfpoFAAbsGLWv+FLyIiCr6AG+29/vrrePDBB3HTTTfhwQcfBADs2rUL11xzDV5++WUsWLCgz/d19dVXS/+eMGECLr/8cuTl5eH999+HwdD3sly56XQ66HR9y7Kj2HDGP3BnWFrf/+4sdpeUWdlpm82FRrsLmX3M1iQiouBry7Ds20msWAbIknAioujQ7HBDTIJMlSnDUqNSItOoRXWLE+VNdmQl8fieiCgUAk4Be/bZZ/Hyyy/jf//3f7Fw4UIsXLgQ7777Ll5++WVp0E1/paSkYOTIkTh58iTMZjOcTicsFkuHfaqqqqSel2azudPUcPH/ve1jMpnCGhSlyCJlWKb2feBOil6DFEPXB0IpBg2S9fIcJBERkTwaxKE7xj6WhCf7J8OyDJCIKCqI5eAGjRIGGfvJc/AOEVHoBRywtFgs+N73vtfp9jlz5qCxsXFAi2lpacGpU6eQk5ODyZMnQ6PRYNOmTdL2Y8eOobS0FIWFhQCAwsJCHDhwANXV1dI+RUVFMJlMGDt2rLRP+/sQ9xHvgwgASur9GZYBDNxxCQIWTsvvctvCaflwyTygioiIBibQoTvZib4yQI/gRQ3LAImIIl69Td5ycFGOP6uSg3eIiEIn4IDlddddh48//rjT7Z988gmuvfbagO7rf/7nf7Bt2zacOXMGO3bswH/9139BpVLhRz/6EZKTk3HnnXfi4YcfxpYtW7Bnzx787Gc/Q2FhIaZMmQLAFyQdO3Ysbr31Vuzfvx/r16/HY489hgULFkgl3ffeey9Onz6NRx55BEePHsXrr7+O999/H4sWLQr0R6cYJmZY5gWQYWnUqrFkRgGWzR4pZVqmGDRYNnsklswogFEbcMcFIiIKIjFg2dehO2qVElmJnBRORBQt5B64IzIzw5KIKOQCjqiMHTsWzzzzDLZu3SplKe7atQtffPEFfvGLX+DVV1+V9l24cGGP93X27Fn86Ec/Ql1dHTIzMzFt2jTs2rULmZmZAICXX34ZSqUS8+fPh8PhwNy5c/H6669L369SqbB27Vrcd999KCwshNFoxO23347ly5dL++Tn52PdunVYtGgRXnnlFQwePBh/+tOfMHfu3EB/dIph/elhCQB6jQqLrrwAi6cPR02LE7kmPVyCAL2MJShERCSPthPZvmfe5Jp0qGp2oLzRjosHJQdraUREJANp4I5B5gxL/6TwCg5hIyIKmYADlqtXr0ZqaioOHz6Mw4cPS7enpKRg9erV0v8VCkWvAcv33nuvx+16vR6rVq3CqlWrut0nLy8P//73v3u8n6uuugp79+7tcR+KXx7BizKLL2AZSIalyKRXI/+ZTTDp1fjnTy/BBRmJci+RiIhkEOjQHQDINemx91wTKpqZVUNEFOmClWEpDmGr5GcBEVHIBBywLC4uDsY6iMKmvMkOt+CFWqlArr/cIxAKhQI6tRIHK5tRarEzYElEFIG8Xi/qbYEN3QHaygDLG5lVQ0QU6cQMy1SZe1jmJvs/C5hhSUQUMgH3sGzP6/XC6+XUTIpuYv/KISkGqJSKft3HIOkghlddiYgiUZPdDY9/0ndgJeF8fyciihbBy7AUS8L5WUBEFCr9CliuXr0a48aNg16vh16vx7hx4/CnP/1J7rURhcSZerEcPLD+le2JActzjTyIISKKROLAHYNGCUMAfYZz/X3LWAZIRBT5GoIVsJSG7jiYsENEFCIBl4QvW7YML730Eh544AFp6M7OnTuxaNEilJaWdhh4QxQNxAzLYf3oXykSD2LO8aorEVFE6s/AHaDt/b2cF6SIiCJevc0/dEfmknCzP8PS6RHQYHPJfv9ERNRZwAHLN954A3/84x/xox/9SLrtuuuuw4QJE/DAAw8wYElRp8Q/IXyoDBmWFTyhJSKKSGKGZSADd4D2JeHsW0ZEFOmki1MGeTMs9RoVUg0aNNhcqGhyMGBJRBQCAZeEu1wuXHLJJZ1unzx5MtxutyyLIgolKcMyrf8ZloOYYUlEFNHEk9j0AMsExYBlVYtD6oFJRESRSRy6E4yAYo6JfSyJiEIp4IDlrbfeijfeeKPT7X/4wx9wyy23yLIoolASMyzZw5KIKHbVWft3EpuVqIVSAXgEL2pamGVJRBTJgjV0B+AQNiKiUAu4JBzwDd3ZsGEDpkyZAgD48ssvUVpaittuuw0PP/ywtN9LL70kzyqJgkQQvFLAciA9LNsfwAiCF8p+ThsnIqLgEEvC04yBncSqVUpkJepQ2exAeZMdZv/7PRERRRav1xvUgGX7wTtERBR8AQcsDx48iEmTJgEATp06BQDIyMhARkYGDh48KO2nUDBgQ5GvusUBh1uAUgEMTun/Sah4AOPyeFHX6kRmok6uJRIRkQz6O3QH8F2U8gUsHZgk98KIiEgWrU4PnB4BQHBKwsXBOxXNzLAkIgqFgAOWW7ZsCcY6iMLijD+7clCyHhpVwB0SJFq1ElmJWlS3OHGu0c6AJRFRhKnv59AdwBew/OZcI/uWERFFsHqb78KURqWAUauS/f7FBIVKZlgSEYVE/yM0RDFAHLiTN4BycJFYFs4+lkREkae/Q3cAwOwftMC+ZUREkav9wJ1gVPtx6A4RUWj1q4fl119/jffffx+lpaVwOp0dtn300UeyLIwoFM7Ui/0r+z9wRzQoWY995U2cFE5EFIH6O3QH4KAFii1WpxsapRIWuwspeg1cggCjtl+nBEQRRWr9YZC/fyXQ9llQ0cwMSyKiUAg4w/K9997DFVdcgSNHjuDjjz+Gy+XCoUOHsHnzZiQnJwdjjURBI2ZYDpUjw9I/KbycGZZERBFHHLqTHuDQHaDt/Z1lgBTt7C4PVm45BfNTG2B+cgPMT23AC1tOwe7yhHtpRAPWlmEZnIClWBJe3miH1+sNymMQEVGbgAOWzz77LF5++WV8+umn0Gq1eOWVV3D06FH8v//3/zB06NBgrJEoaKQJ4WkyZFiafPfBDEsiosjTlnkTeIZlThJLwin6WZ1uPLf5JFYUHYfF3+vPYnNhedFxPL/5JKxOd5hXSDQwAxmu1hfiZ0Gry4NmB18vRETBFnDA8tSpU5g3bx4AQKvVwmq1QqFQYNGiRfjDH/4g+wKJgknWHpbJ/hNaZlgSEUUUj+CFxe7vYWnsR0l4MkvCKfpplEq8tr24y22vbi+GRsnW9hTd2gKWwcmwNOrUSNL52idUMOOeiCjoAj4ySU1NRXNzMwBg0KBBOHjwIADAYrGgtbVV3tURBZHX65W3hyV7nBERRSSLzQWxei+1H73NxL5lVc0OeASWAVJ0sthdUmZlp202FxrtXW8jihZiSXhqkDIsAQ7eISIKpYADlldeeSWKiooAAD/4wQ/w4IMP4u6778aPfvQjzJw5U/YFEgVLXasTrf6eTUNS5Bi64y8JZ4YlEVFEEftXJunU0KoDzyLLStRBqQAEL1Ddwqwaik4peg1SugnYpxg0SNYHJyuNKFTqbcHNsASAnCQO3iEiCpWARwL+7ne/g93uC8j86le/gkajwY4dOzB//nw89thjsi+QKFjE/pXmJB30GtWA72+Qv2Sw1uqEw+2BTj3w+yQiooETywTT+3kSq1IqkJ2kQ0WTA+VNdmnwAlE0cQkCFk7Lx/Ki4522LZyWD5cgQBt4LgNRxGgQh+70o1dxX4ktQphhSUQUfAEFLN1uN9auXYu5c+cCAJRKJZYsWRKUhREF25l6XwuDYWkD718J+K7m6tRKONwCyhsdyE+X536JiGhg6qzi5Nj+n8TmmvRwebxotnPQAkUno1aNJTMK4AXw2vZiWGwupBg0WDgtH0tmFMhy8ZYonILdwxLwJToAbAFFRBQKAQUs1Wo17r33Xhw5ciRY6yEKGTHDMk+G/pUAoFAokGvSo7i+FeVNdgYsiYgihFgSnm7s/0nsK9ePw0WDTGi0ueF0C3AJAozagAtViMJKr1Hh/12Ug0emD0dNixNZiTp44WWwkmJCKAKWYoZ9JYfuEBEFXcBH2pdddhn27duHvLy8YKyHKGTOSAFL+QKLg5J9AUv2sSQiihxtJ7H9y7C0uzz47Fg1rn1rN7PSKOq9uO001h6ugjlJB7vLg+NL2YOeYoM4dGcg2fS94dAdIqLQCThg+fOf/xwPP/wwysrKMHnyZBiNxg7bJ0yYINviiIKptMFXEi5XhiXQNkn2XJNNtvskIqKBqRvASazV6cbKLafw9MYT0m0Wm0vqA7h4+nBmWlJUOV7TglqrE7X+VgmNNheSuxnGQxRNQpJhyaE7REQhE/AR9s033wwAWLhwoXSbQqGA1+uFQqGAx+ORb3VEQXSm3hdUHCZnwNLfiLu8kQcxRESRYiBDdzRKJV7bXtzltle3F+OXM0cMaG1EoXa0uqXD/4vrWzFxUHKYVkMkD7vLg1aX7zyUGZZERLEh4IBlcXHXB+1E0aZEyrCUsSTcn2HJRtxERJFjIGWCFrsLFpur6202FxrtLmQm6ga0PqJQqbU6pAD+OHMSDlY2M2BJMaHB/z6tVAAmXfCy3sVqqka7G61ONxKYYU9EFDTKQL+hpKQEgwYNQl5eXoevQYMGoaSkJBhrJJKd7yTTN+lVzpLwQf4My3ONLAknIooU4pTw/gzdSdFrkNJNuWyKQYNkPUtpKXocq7YCAIamGHChOQmAL8OSKNqJgfhUgwZKpSJoj2PSq2HQ+E6hKzh4h4goqAIOWE6fPh319fWdbm9sbMT06dNlWRRRsInZlRlGLYwyXoWVelhy6A4RUcSQ+poZAs+wdAkCFk7L73Lbwmn5cAnCgNZGFErHanzl4KOyjBiW5qswYcCSYkEoBu4AvlZo4qTwimYe7xMRBVPAAUuxV+X56urqOg3gIYpUwehfCbRlWJY32eH1emW9byIi6h9x6E66MfATWaNWjSUzCrBs9kgp0zLFoMGy2SOxZEYBB+5QVDnm7185MjMR+f6A5RkGLCkGhGLgjignSexjyQxLIqJg6vNR9o033gjAd1Xppz/9KXS6tn5NHo8H3377La644gr5V0gUBMHoXwm0Dd2xuQRYbC6kBvkqLxER9W4gQ3cAQK9R4eHvXoDF04ejpsWJXJMeLkGAXqOSc5lEQXdczLBsF7A8XceAZThZnW5olEpY7C6k6DVwCQIvhPRDqDIsAbRlWLJnPRFRUPX50zA52deM2+v1IikpCQZDW2aaVqvFlClTcPfdd8u/QqIgONPgy7DMS5M3w9KgUSEtQYP6VhfONdoZsCQiCjOnW0Czw9ezeCAnskk6NQavKEJ6ghb/vusyDE6R94IXUSgcq/H1sByV1S7DsqG12woqCi67y4OVW07hte3FsNhcSDFosHBaPpbMKOAFkQCFMsPSLJWEM8OSiCiY+lwS/vbbb+Ptt9/GE088gdWrV0v/f/vtt/H73/8eS5cuRUZGRr8X8vzzz0OhUOChhx6SbrPb7ViwYAHS09ORmJiI+fPno6qqqsP3lZaWYt68eUhISEBWVhYWL14Mt9vdYZ+tW7di0qRJ0Ol0KCgowJo1a/q9TooNpUHKsATa9bHkVVciorATs24UCnQ7PKcvFAoFBC9wsLIZda1dTw0nimQuj4BTdf6AZaYRQ1MMUCh8VSFVDLyEnNXpxnObT2JF0XFY/BOuLTYXlhcdx/ObT8LqdPdyD9SeOCU8FMkCuSZfpWElj/WJiIIq4B6WTzzxhOy9Kr/66iv8/ve/x4QJEzrcvmjRInz66af44IMPsG3bNpSXl0ul6YCvFH3evHlwOp3YsWMH3nnnHaxZswbLli2T9ikuLsa8efMwffp07Nu3Dw899BDuuusurF+/XtafgaKL2MNSzgnhIqmPJQfvEBGFnZh1k6LXQDXAybFp/oBnPQOWFIWK61vh8nhh0CgxONkArVqJwf5jFg7eCT2NUonXthd3ue3V7cXQKAM+TYtrUkn4AC5M9VVOUlvPeiIiCp6wfxK2tLTglltuwR//+EekpqZKtzc2NmL16tV46aWXMGPGDEyePBlvv/02duzYgV27dgEANmzYgMOHD+Ovf/0rJk6ciKuvvhorVqzAqlWr4HT6PrTefPNN5Ofn48UXX8SYMWNw//3346abbsLLL78clp+XIkOLw4Vx5iQMT5d/UJTYx5IZlkRE4TeQgTvnE0sNxRNjomgiDtwZlZkIpT94n89J4WFjsbukzMpO22wuNNp5YSQQYoZlSIbumDh0h4goFMIesFywYAHmzZuHWbNmdbh9z549cLlcHW4fPXo0hg4dip07dwIAdu7cifHjxyM7O1vaZ+7cuWhqasKhQ4ekfc6/77lz50r30RWHw4GmpqYOXxQ7muwu7Hn4u/jkjsswIsMoe8nNILEknBmWRERhN9CBO+2lGrQd7pMomrTvXyliwDJ8UvSabttUpBg0SNYHP/AWSzh0h4go9oQ1YPnee+/hm2++wXPPPddpW2VlJbRaLVJSUjrcnp2djcrKSmmf9sFKcbu4rad9mpqaYLPZulzXc889h+TkZOlryJAh/fr5KPLYXR68uO0UhqzYiOHPboL5qQ14Ycsp2F0e2R4jlwcxREQRo07Gk1gxc6ehm6wookh2zD8hfGRmW8BymBSw7PqYmILHJQhYOC2/y20Lp+XDJQghXlF0C+XQHTHDsq7VBaebvyciomCRNWDZ2tr3q7NlZWV48MEH8be//Q16vV7OZQzY0qVL0djYKH2VlZWFe0kkg7bm5ieC2txc7GHJDEsiovCrs/pLwuXIsExgD0uKXselkvC2djjSpHBmWIacUavGkhkFeHz2CCnTMsWgweOzR2DJjAIYteowrzC6tAUsg59hmZ6ghUbla6tQ2czjfSKiYAk4YDlz5kycO3eu0+27d+/GxIkT+3w/e/bsQXV1NSZNmgS1Wg21Wo1t27bh1VdfhVqtRnZ2NpxOJywWS4fvq6qqgtlsBgCYzeZOU8PF//e2j8lkgsHQ9cAVnU4Hk8nU4YuiX6iamzNgSUQUOeplnBwrngizhyVFIzHDkiXhkUOvUeHmiYNQ9vgsFP9yJsoen4VLhqTA4/WGe2lRp60kPPgZlgqFQhq8wz6WRETBE3CERq/XY8KECfj73/8OABAEAU8++SSmTZuGa665ps/3M3PmTBw4cAD79u2Tvi655BLccsst0r81Gg02bdokfc+xY8dQWlqKwsJCAEBhYSEOHDiA6upqaZ+ioiKYTCaMHTtW2qf9fYj7iPdB8SNUzc3FkvCqFgdcHpaJEBGFU1uG5cADlqn+LKgGZlhSlGlodaK6xfdaGJnROWBZarHBzWOWsPjLnrPIf2YT/vrNWcx6cyeuf+sr/HFXabiXFVXcHgGNdl+lVCgCloCvLDzDqEWLQ95e+ERE1CbgWoN169Zh1apVuOOOO/DJJ5/gzJkzKCkpwdq1azFnzpw+309SUhLGjRvX4Taj0Yj09HTp9jvvvBMPP/ww0tLSYDKZ8MADD6CwsBBTpkwBAMyZMwdjx47FrbfeipUrV6KyshKPPfYYFixYAJ3O11vk3nvvxe9+9zs88sgjuOOOO7B582a8//77WLduXaA/OkU5sbl5V0FLOZubZyXqoFYq4Ba8qGp2YHBK15m8REQUfGJwMd048Pd4TgmnaCUO3Mk16ZGkbzv8zzXpoVUp4fQIONtol3paUuhUtThQa3XCC+COy4biy1ILXv78FBZMHQaNKuzzUaOCpV3SQUqIhhW9dN2FmJBrgsXmhtMtwCUILOOHrwWXRqmExe5Cil4TkuclHI9JRKHRr1fyggULcPbsWfz617+GWq3G1q1bccUVV8i9Nrz88stQKpWYP38+HA4H5s6di9dff13arlKpsHbtWtx3330oLCyE0WjE7bffjuXLl0v75OfnY926dVi0aBFeeeUVDB48GH/6058wd+5c2ddLkU1sbr686HinbWJzc60MbV2VSgVyTDqUWew412hnwJKIKIzkHbrjuw8O3aFoc6yL/pWA75glL9WAE7VWFNe3MmAZBtXNvpLi7EQdbp08GMvWH0OZxY739p3DrZM5+LMvxP6VyXo11CEI8tpdHvznaDXmrd4Ni82FFIMGC6flY8mMAug1qqA/fqSyuzxYueUUXtteHLLnJRyPSUShE3DAsqGhAXfddRc2bdqE3//+99i2bRvmzJmDlStX4uc///mAFrN169YO/9fr9Vi1ahVWrVrV7ffk5eXh3//+d4/3e9VVV2Hv3r0DWhtFP6NWjf+5ajgErxe/++JMUD/UBiUbfAFLTgonIgorMWApx9CdNA7doSjVVf9KUX5aghSwnB7qhRGqxIBlkg56jQoPficfv/z3Ubyw5RR+MmkwFApFmFcY+UI5cMfqdGPlllN4euMJ6TZxiCcALJ4+PC6z+8TnZUW7xJBgPy/heEwiCq2AL0GNGzcOVVVV2Lt3L+6++2789a9/xerVq/H4449j3rx5wVgjkWx+v/MMJg1Owblls1H15BxUPjEHi6cPl/0KXK7J15KAg3eIiMJLzhNZaeiOjSXhFF2O9xCwHMbBO2FV1eILWJqT/O2sCochUafCwcpm/OdodU/fSn6hHLgTqiGe0SYczwt/F0SxL+BX8b333ovPP/8c+fn50m0//OEPsX//fjidPICnyPbJoSrcuOYrfHygApmJOmjVyqBcectN9pWBlzPDkogorIIxdKfF4eFQNYoqx6p9PSxHZXadYQkAZxiwDDmv14uqZt97VHaiL2CZYtDgnil5AIAXtpwK29qiSduFqeAHLEM1xDPahON54e+CKPYFHLB8/PHHoeziasXgwYNRVFQky6KIgsHpFvB1mQUAMHlwSlAfa5B/Ung5MyyJiMLG5vLA7vYFFuU4kU0xtN0HJ4VTtPAIXpys6z1gyQzL0LPYXHD6L35k+zMsAeCh71wAjUqBbafr8GVJQ7iWFzXqZexV3BtxiGeX22Qc4hltwvG88HdBFPv6lSdtsViwYcMG/PWvf8Wf//xn6esvf/mL3Osjks3+8ibY3QLSEjQYeV7TebkNSvYFLFkSTkQUPmJ2pVqpgEk/8Gx6lVIhnRyxLJyiRUlDKxxuATq1EkNTOw8CZMAyfMRycJNe3aE90eAUA265eDAA4IWtJ8OytmgiZlimdhO8kpM4xLMr4hDPeBSO54W/C6LYF/DR+6effopbbrkFLS0tMJlMHRpBKxQK3HrrrbIukEguO0vqAQBThqYGvYF5rphhyZJwIqKwqWvX10yu9/20BA0sNhcH71DUECeEj8gwQqXs/DrIT/cFMSuaHLC5PDBwsm7IVLWbEH6+X1w1HGu+LsPHBytxvKYFI7vIjiWfelvohu4YtWosmVEAwNcnkZOpfYxaNX4RouGm7R9zyYyCkD4mEYVWwAHLX/ziF7jjjjvw7LPPIiEhIRhrIgqKnf6SmsJhqUF/LGZYEhGFXzAmx6YZNDgNTgqn6HFUHLjTTcArPUGLRJ0KLQ4PShpaMTorKZTLi2tS/8qkzgHLC81JuHZMNtYeqcKL207h9zddFOrlRY2GEA7dAQC9RoXF04fjkekFqG5xwJykg8frjfsA2YtbT0nDTatbHMgwalHT4gzq86JSKnD50FQ8OqMANS1OZCb6Pu/j/XdBFCsCLgk/d+4cFi5cyGAlRZ2dZ/wBy7y0oD+WmGHZ7HCj2e4O+uMREVFnbQN35DuJTfXfl9gzjSjSiQN3RmZ13Q5HoVC0lYXXsSw8lM6fEH6+R2YMBwD8+euzqGTVTreCcXGqN0atGg//6xCue2s3Vu8uDcoQz2jz0YEK3LjmK2w+UYt3955D/jOb8PhnR4P6mF8U1+P7b+3G8Gc34bq3duOi32zj7yJIrE43nG4B1S0OON0CrE6e41LwBRywnDt3Lr7++utgrIUoaMob7Si12KBUAJcNTQn64yXp1UjS+T4szzXZgv54RETUWTDKBMX7auhmMilRpDnuz7AcndV9SXFbH0ses4SSWBKe1UVJOABMHZaGwrxUONwCXt1eHMqlRZX6EGdYitKNGhysbMbhqpaQPm4ksthcOFTVDAC4ZEgKpg/PQK3ViX8erERrEANbnxyqBABcPjQVByubcbq+FU43e1fKze7yYOWWUzA/tQHmJzfA/NQGvLDlFOwuT7iXRjEu4MsP8+bNw+LFi3H48GGMHz8eGk3HD4brrrtOtsURyUXsXzk+x4REXWiuug1K1uNodQvKGx0sryIiCoO2DEv5ApbiUAeWhFO0ONZLSTgADOPgnbCoFHtYdpNhqVAosHj6cNy45mu8seMMfjljBBJlGCAWa9oyLEMbsByW6nvdlPB1gy9LG+D1AsPTE5CdpENWohb5aQkorm/Fp4er8MOJg2R/TK/Xi38dqgIA3HbJYKw7UgXB6+tfneOvdqOBszrdWLnlFFYUHZdus9hcWO7//+Lpw5nVSkET8F/W3XffDQBYvnx5p20KhQIeD6PsFHl2SOXgwe9fKRIDlsywJCIKD2nojlG+k1gxw5Il4RQNmuwuVDT5gmI9BSzFDMszDLyEVHUvAUsAuG6sGVePzsQ9U4ZBpVKgusWBFL0GLkFgkMBPAS/GmZOQmdD98xgM0uumga+bL4p9ySFXDPO13lIoFLj54lw8t+kk/nfvuaAELA9WNqO4vhU6tRLfG5WF9AQtaqxO1FoZsJSTRqnEa91keL+6vRi/nDkixCuieBJwSbggCN1+MVhJkWpXCAfuiAaZOHiHiCicgtHXTMywbGCGJUWB4zW+/pXZSTokG7oP3OczwzIsxB6WXU0JFymVCrz3k0uw56wFg5YXsRzzPFaHG3se/i4+ueMyDEtPCGlfvWFSoN8Gr9cbsseNROJw0yvanWv9yB+k/M/Ramkwkpz+5S8HnzUiA0adGhlG32d9TQsvKMrJYnfB0k0bHIvNhUY7j4coeAIOWJ4+fToY6yAKGofbgz1nGwGEZuCOKIeTwomIwkrMgpRz6I5YcsgelhQN2srBux64I2LAMjyq+pBhaXW68Zttp/D0xhNS0EAsx3x+88m4Hnxhd3mwcuspDFmxEcOf3YScEAdyh6TooVAArS5PXAfJ3B4BX5aKAcu2c61xOSaMz0mCy+PFRwcqZX9csRz8ugvNACBNCK+1xu/vIhhS9BqkdHPBK8WgQbI+tK0YKL4EHLAsKCjA9OnT8de//hV2OwMxFPm+OdsIp0dAhlGL4emhm24vZlhWcKojEVFYBCPDkiXhFE2OVvsCliN7KAcH2gKWDTYXGhmMDwmv19unDMveyjE1yoBP52KC1enGc5tPYkXR8bAFcnVqlXS8H8/B/gOVzWhxeGDSqzE2u2Pf/pv9WZb/u/ecrI9Z3mjHV2UWKBTA98dmA4CUYcmApbxcgoCF0/K73LZwWj5cAoccUfAE/An3zTffYMKECXj44YdhNpvx3//939i9e3cw1kYki/YlCgqFImSPO4gZlrKxOt1wugVUtzjgdAtxnU1ARH0XjKE7YoYlh+5QNDhe3fvAHQBIbFdOGc+Bl1Bqsrvh8E8zzk7q/j2K5Zhdi5RA7jD2scSOM77+lYV5qVApO55riQHLLadqZU3i+PRw23Rwsz9onC6WhFsdsj0OAUatGktmFOCx2SOkTMsUgwaPzRqBJTMK2EtXZjzv7Sjgd/KJEyfilVdeQXl5Od566y1UVFRg2rRpGDduHF566SXU1NQEY51E/Sb2r5wSwoE7AAOWcrG7PFi55RTMT21g3yYiCki9/yQ/nUN3KE4d8/ewHJXVc8ASAC5gWXhIidmVSTo1Eno44Wc5ZtciJZA7LNUAwNfHMl7tlIabdm69lZ+egMK8VHi9wN/3lcv2mGI5uJhdCQCZRl+mMjMs5afXqPDdC9JR9vgsnF02G2WPz8LFg5J5nisznvd21u9LT2q1GjfeeCM++OAD/PrXv8bJkyfxP//zPxgyZAhuu+02VFRUyLlOon7xer1hmRAOALliSXizA4IQ3424+ysSyn2IKDp5vV4oAIwzJ0mZY3KQhu7YXHxvp4gmCF6cqPVlWI7uQ8AyP50By1CqbOq9fyXAcszuREogdxgD/fjijDghvOtzrZsv9mVZvidTWXiz3Y1NJ2oBANf7+1cCbSXhdQxYys7qcGPuH3Yh/5lNUCmAez/8FvPf+Rpv7iwJ99JiBs97u9bvgOXXX3+Nn//858jJycFLL72E//mf/8GpU6dQVFSE8vJyXH/99XKuk6hfyiw2lDfZoVIqcMnglJA+tjlJB6UC8AheVLewNKE/IqXch4iiT5PdjRNLZ+CTOy5DplEn24Feqr8kXPACzY74PHik6FBmscHmEqBRKaQssJ4w8BJabf0re76gIpZjLps9skM55rLZI+O6HDNSArni66YkTkvCzzXaUNJgg1LhK8/uyv+7KBdKBbC7zIKTtdYBP+b6Y9VwegQUZBgxJrvtYow0JZwBS9ntOdsIwQvo1EpkJ+nxg4tyAQB/2VMGlyc+L5rIjee9XQv4E+6ll17C22+/jWPHjuGaa67Bn//8Z1xzzTVQ+p/A/Px8rFmzBsOGDZN7rUQBE/tXTsw1wagL7QGdWqVEdpIOFU0OnGuyS/1VqO/6Uu6T2UOjeiKKT3aXBy99fhqvbS+GxeZCikGDhdPysWRGAfQa1YDu26BRwaBRwuYSUN/qQnI3GT5E4SZOCC9IN0Kt6v1ERxy8c4YBy5Doy4RwkV6jwuLpw/HI9AJUtzhgTtLB4/UO+P0smomBXMHrxe++OCP7e31f5cd5oF8sB5+QY0KSvutzrewkHWaOyEDR8Vq8t+8cHps1ckCP+elhcTp4dof5BJwSHjy7/FPgp/iD0teMzoI5SYfKZgfWHq7Cf43PCefyYgLPe7sWcJj2jTfewI9//GOUlJTgn//8J6699loolUqcPXsW99xzDwAgKysLq1evln2xRIHaGab+lSJxciD7e/RPpJT7EFH0CEVJjdTH0saTIopcgfSvBBh4CTUxwzKrjyegRq0aj649jOve2o0/7CqJ28zK9vQaFWaOyEDZ47NwbtlsVD4xB4unDw9pIHdYqphhaYvLNiFt5eCd+1e296OLBwMA/vebc/B6+/88uT0C1h3xBSzbl4MDnBIeTF/6z6kvG5oCwJeYc9slQwAAq78sDdeyYgrPe7sWcMDyxIkTWLp0KXJyOkbR6+rqpCClVqvF7bffLs8KiQZgZ5j6V4py/YN3yhmw7JdIKfchougRipIasY8lJ4VTJDvmnxA+spcJ4aK2DEvbgAIK1DeBZFiKdBolDlY2o9QSvwNeznfn+/uR/8wmlDfaoVUrQx7IHZyih1IBONyCFISOJ+K5Vnf9K0X/Nc4MnVqJI9Ut+Laiqd+Pt724HvWtLqQnaDqd32X4LybWtDj5HiYjr9fblmHZ7jm/4zJfwPKzY9U418j3pIHieW/X4rMQnuKCzeXB3nONALqeWhcK4uCdc00MWPaHUavGI9ML8NisEezbRER9EorJsWn+PpYNDFhSBBNLwkdlGvu0/9AUAxQKoNXlQXULM5SCTexvbg4gYClmY9bw9wPAN1jqrMWOWqtT1uFqgdColBiS4usRG2/ZyTaXB9/4z7V6y7BMNmgwb0wWAOB/9/Z/WvgnhyoBANeOze7U6kIsCXd6BLQ44neqstzONtpR0eSASqnA5MHJ0u0jMxPxnfw0CF5gzVdlYVxhbDBq1Vg8fTjPe88Tnz81xYU9Zy1wC16Yk3QYltZ7s/lgGJTMkvCB+mD/OUwanIKzj89GTYsDGYlaNDvccd23iYi6J5bUdBW0lKukRioJb2XQgCKXmGHZ15JwrVqJwcl6lFnsKK5vDSjzjwLXnwxLMWDJYY4+NVYnnB4BCkVbVVM4DEtNQEmDDWfqW3sN3MWSr0p951q5Jj3y+jDY6+aJg/DRgUq8t/ccnr16NJRKRa/f057X68W/Don9K82dtido1VKP6Vqrs9uemhQYsRx8Qk4SEs4Lmt15+VD8X3E93v6qDEtnjAj4d0odrfqiWDrvtTrdSNZr4BKEuD7vZYYlxaz25eDtGzKHkphhWcEMy357Y0cJblzzFf5371k8vv4o8p/ZhG2n6sK9LCKKUKEoqREnhdd3k8lJFG5Whxtn/RdLR/WxJBxgH8tQqhQDlgEMUcjyZ5AxYOlT2uArQ8016aHpw2CpYJHaKTTEV1nsjhKxf2XfzrXmjc1Gkk6NUotNmjMQiEOVzSiub4VOrcSckZld7tM2KZyvEbmI5eCXdTEF/qYJOTDp1Thd14qtPD8bEK/Xi1VfnMGNa77ClpO1yEzUhaXNRaTp809/44039rjdYrEMdC1Esgr3wB2AGZYDVVzXit1lFigVwLVjzdhR0oBaqxNH/VkjRETnC8Xk2DQDMywpsh2v9Q3cyTBqkR5AqWx+WgI+P13PgGWQeb3eAWZY8r0HAMr8ffPEkuxwyUuLz5JwKTmkl/6VIoNGhf8aZ8af95zFu3vPYWp+YNmoYjn4rBEZMOq6DmNkGnUo87cJIHnsLrUAaJsQ3l6CVo2bJw7CH3aV4K3dpZgxIiPEq4sdX5ZaUGaxI1Gn4vPYTp8DlsnJyb1uv+222wa8ICI5eL1eKWAZztKMQcm+AxgGLPvn7/vPAQCmF2QgO0mH0f4skWMMWBJRD3RqJS4bmoKyGbPQ4vAg1SBvSY2UYckelhShpHLwPvavFA1jhmVINDvcsLt92d6BZFhmGjsOFQlXBVGkEDMsh4SxHBxoNyk8jl43Xq8XO/wTwqcGcK5188WD8Oc9Z/Hh/nK8cv2FnfpQ9qSncnBRRrvXCA2cyyPg6zILAODyvJQu97nzsqH4w64S/ONABV5rdSI1ITz9ZKPdB/t9vV2/P9YMQxyXgJ+vzwHLt99+O5jrIJLVmXobqpod0Kg6NgcONTHDssHmgs3l4ZtPgN7f53vj/uHEXADAaH8fLmZYElFPalqcuO6tr5CZqEXJr2ZBq1ZCK2MXnDR/M/TuhvsQhZs4cGdkH/tXitomhcdP4CUcxOxKo1bVbaZYV9oPFWmyu5FsGHhP3mhW5p+WPqQP/RODKR5bKRyvsaKu1QW9WomJuX0/15o5IgNX5KVi8fQCuL1e1Lc4kOLv09dT6Wt5ox1flVmgUADfH5vd7X7ia4QZlvI4UNEEu1tAikGDkRldf55cMiQZE3JM+LaiCe/uPYcFU7tuy0PdEwQvPvzWd977g4tywryayMIelhSTdvp7qlycmxzWJrXJel/zZ8D3QUt9d6y6BfvKm6BWKnDjeN8btxiwPFbTAkHwhnN5RBTBjtf6gjUJGlVQPgM4dIci3fEaX0l4IP0rgfgMvIRDVT8mhAO+8stEne89jX0sgbOWyCgJF4d7llps8MTJ8amYXXnpkBRo1X0PKWhUSqy963LsOWtB7lNFMD+5AeanNuCFLadgd3U/2fvTw75y8MuHpsJs6j6jVmyBUcvPZ1nsKrEAAC4bktLtQB2FQoE7LhsCAHhrd2molhZTvixtkMrBvzcqK9zLiSgMWFJM2uHvqTKljz1VgkWhULAsvJ/+7s+unDMyUwoO5KclQKNSwOYSpKvqRETnO+EP1ozICKwctq/SWBJOEa6tJLx/AcvShvgJvIRDf/pXitjHsk1phAQsByUboFYq4PJ442bQ5hf+c60rAuxDaXW68fLnp/D0xhNSlYLF5sLyouN4fvNJWJ3uLr+vrRy8++xKgCXhctvtH7hzeS8zIW6ZNBhalRJ7zzXhm7OWEKwstrzvLwe//kJzXE8E7woDlhSTdon9K/PC179SNMh/FfBcnBzAyMHr9eK9fb7+lf/PXw4OAGqVUgpAHK1hWTgRdU0cODIiwGBNX7GHJUUyr9crlYSPygosaJ9r0kOrUsIteKXsNZJfVbMvmBJI/0pRW8CSGZZlFt+x9dAwByxVSgWGpsbX4J2d/gzLKwIcbqpRKvHa9jNdbnt1ezE0ys7hiWa7G5tO1AIArhvbff9KoK3Pax2nhMtCnBB++dCUHvdLN2rxX+N9v5vVu8uCvayY4isHrwAA/OCi3F72jj9hDVi+8cYbmDBhAkwmE0wmEwoLC/Gf//xH2m6327FgwQKkp6cjMTER8+fPR1VVVYf7KC0txbx585CQkICsrCwsXrwYbnfHKzNbt27FpEmToNPpUFBQgDVr1oTix6MwsTrc2F/RBKDvU+uCiZPCA3egohlHq1ugUytx/XmNtdnHkoh6czLYGZb+KeENNmZwUOQ512iH1emBSqnABWmBvQaUSgXy4izwEg6Vzb5jwqx+ZFhKg3fivEefyyOgwv88hjvDEmgbvHOmIfZfN/WtThzxH4cHeq5lsbu67f9ssbnQaO+8bVdpPUx6NQoyjBiT3fOFSDHDkj0sB66+1Sm1F7m8iwnh57vjsqEAgHe/OQtbD+X91NGu0gaca7QjSafGnJGZ4V5OxOlTwHLSpEloaPBF15cvX47WVnneiAcPHoznn38ee/bswddff40ZM2bg+uuvx6FDhwAAixYtwqeffooPPvgA27ZtQ3l5OW688Ubp+z0eD+bNmwen04kdO3bgnXfewZo1a7Bs2TJpn+LiYsybNw/Tp0/Hvn378NBDD+Guu+7C+vXrZfkZKPJ8VWaBR/BiULI+Ig5gcvwZluXMsOwzcTr41aOzOjWUH8WAJRH1QuxhOTLACcl9JZaE21wCD8op4ojZlRekJQTUW04kloWfZsAyaMQelv3JsMxkhiUAX2De6wV0aqUUxA2nYWL/17rYz0ze6S8HH5VpRIYxsL/hFL0GKd0Mi0oxaGDUqvFVaQO8Xi+sTjecbgGjs5JQ/KuZ+Putk6FQdN1HUZTBgL5sdpdaAPgu/qb34TU2syADeakGNNrd+OhARZBXFzvaysGzWQ7ehT4dxRw5cgRWqy+6/tRTT6GlRZ5Awfe//31cc801GDFiBEaOHIlnnnkGiYmJ2LVrFxobG7F69Wq89NJLmDFjBiZPnoy3334bO3bswK5duwAAGzZswOHDh/HXv/4VEydOxNVXX40VK1Zg1apVcDp9b1Jvvvkm8vPz8eKLL2LMmDG4//77cdNNN+Hll1+W5WegyLPTXw5eGGCJQrCIGZYcutM3Xq9X6l/5w4md0+KlwTsMWBJRFwTBi5O1wc2wNOnVUPmbzzewLJwizLFq39//6AAnhIuGcfBO0FUPqIelL3AQ7z0sxV7mg5P13Q4DCSVx8E48ZFju8A83LRwWeOstlyBg4bSup0jfP3UYNhyvwe3v7UN9qwsrt5yE+akNyHt6I4as2Ih/HqzscTAPAGT6A6jMsBw4scVab+XgIqVSgZ9d6suy/NAfhKOeCYIXH+5nOXhP1H3ZaeLEifjZz36GadOmwev14je/+Q0SE7s+CGqf3RgIj8eDDz74AFarFYWFhdizZw9cLhdmzZol7TN69GgMHToUO3fuxJQpU7Bz506MHz8e2dltzXfnzp2L++67D4cOHcLFF1+MnTt3drgPcZ+HHnqo27U4HA44HG1XLZuamvr1M1F4iG+ukVAODrQvCY/9K65y2HO2EafrWpGgUeHaMZ0ba4/OTALADEsi6tq5JjtsLgFqpUIKvMhNoVAg1aBBrdWJ+lYncpO7n1hKFGpihuXIfvZwFTMszzBgGTRV/mDjQIbu1MR5hmWkDNwRiSXhJXHwuhEzLK/ox7mWUavGkhkFAHw9Ky02F1IMGiyclo/F04fj2Y0n8Ot5Y/DK/53G0xtPSN9nsbmwoug4FAAWTx8Oo7brMIaYYdlgc8HtEaBWcWRHf/V14E57d10+BBflmjBrZAaqmu1INWjhEoRuf1/xbkdJPcqb7DDp1ZgziuXgXenTX86aNWvwxBNPYO3atVAoFPjPf/4DtbrztyoUioADlgcOHEBhYSHsdjsSExPx8ccfY+zYsdi3bx+0Wi1SUlI67J+dnY3KykoAQGVlZYdgpbhd3NbTPk1NTbDZbDAYOn/IPffcc3jqqacC+jkoMni93nYZluEfuAP4GtgDQHlTfB9Y9pU4bOf7F2bDqOv8PiMOEKhsdkgHOUREouNiOWx6AjRBPFFpC1gyw5Iiy/F+DtwR5TPDMujEKeHmgWRYNsf3caWYYRnugTuieHnduDwCvvQHsqb2I8MSAPQaFRZPH45fzhyBRrsLyXqNFNR65poxcLgF3P7evi6/99XtxfjlzBHd3rfYssXr9Q3G60+fWPKdU3/pLwnvS/9KUVqCFnvOWvCzv+/rEIxeMqOA5c5deN+fXXnDhWbo1Hx+utKngOWoUaPw3nvvAQCUSiU2bdqErKwsWRYwatQo7Nu3D42Njfjwww9x++23Y9u2bbLcd38tXboUDz/8sPT/pqYmDBkyJIwror46WWtFrdUJrUqJiweZwr0cAO1Kwpvs8Hq9vfZeiWeC4MX7PZSDA4BJr0GuSY/yJjuOVbcEdNWPKJpYnW5olEpY7C6ktDuYp56dCPLAHZF4UtTQzfAAonARW6aMGmCGZawHXsJJDFgOpIdlvPfoEyeED46QgKVYEl7WaI/pzL795U2wuQSkGjT9fo8BIB3PiH/P2nad6hr7MJgns5vXjlqlRFqCBvWtLtRanQxY9tOJWisabC7o1UpMyOnbObXV6cbKLac6ZcYuLzoOoOfM2HgkCF7841vfeS/LwbsX8DupIAiyBSsBQKvVoqCgAJMnT8Zzzz2Hiy66CK+88grMZjOcTicsFkuH/auqqmA2+6YGm83mTlPDxf/3to/JZOoyuxIAdDqdNLlc/KLo8M25RowzJ2FmQXrEXKUQMywdbgF1rfF9cNmbnSUNONvoS4v/3qju32c4KZxind3lwcotp2B+agPMT26A+akNeGHLqV57NxFwXOxfOYATqb5IS/BlOdXzfZ0iiM3lQYk/86zfAct03/FxRZODQ6WCoMXhRqv/eR1YD8s4z7BsEEvCI6MlR06SHlqVEh7Bi7Mx3Ld+xxl//8q81KD1Du1tME+yvufqKk4KHzixxdqkwcl9Ht6mUSrx2vbiLre9ur0YGmVsBvH764sz9ahociBZr8ZsTgfvVr/+ak6dOoUHHngAs2bNwqxZs7Bw4UKcOnVKlgUJggCHw4HJkydDo9Fg06ZN0rZjx46htLQUhYWFAIDCwkIcOHAA1dXV0j5FRUUwmUwYO3astE/7+xD3Ee+DYofV6cZ1F5rxyR2X4cOfXgqr0x3uJQEAtO2mF56L4QMYOYjl4DdcaO6xbECaFF7DgCXFHqvTjec2n8SKouNShoF4hfr5zScj5r0tUp0McYYlS8Ipkpyua8WF2UkYnp6AzMT+TU5OT9AiUef7DC6JgwEioVbpz65M0KiQ2EXrm96IPSxrrU54BK+sa4smZY2RVRKuVCqQl+ofvBPD2ck7xP6V+cFrvdXTYJ6F0/LhEoQev79tUnh8B/UHoj/l4JY+ZMZSG3E6+A3jzH0OCsejgJ+Z9evXY+zYsdi9ezcmTJiACRMm4Msvv8SFF16IoqKigO5r6dKl+Pzzz3HmzBkcOHAAS5cuxdatW3HLLbcgOTkZd955Jx5++GFs2bIFe/bswc9+9jMUFhZiypQpAIA5c+Zg7NixuPXWW7F//36sX78ejz32GBYsWACdzvdhfu+99+L06dN45JFHcPToUbz++ut4//33sWjRokB/dIpgYjbSoOVFGP7sJgxaXhRR2Ui5nBTeK4/gxYff+vp4/L9uysFFnBROsYxXqAfmeK04cCS4AUsx+6PexgwOigxWpxvD0xPwyR2XYf8vrpKy+AKlUCjaysLrYjfwEi5VA5gQDrQFYwRvfGd4l0XY0B2g/aTw2B20KWZYXhHElkziYJ5ls0dKn7UpBg2WzR6JJTMKei0rzmSG5YB9KU0I7/vveaCZsfHEI3jxj285HbwvAr6st2TJEixatAjPP/98p9sfffRRzJ49u8/3VV1djdtuuw0VFRVITk7GhAkTsH79euk+Xn75ZSiVSsyfPx8OhwNz587F66+/Ln2/SqXC2rVrcd9996GwsBBGoxG33347li9fLu2Tn5+PdevWYdGiRXjllVcwePBg/OlPf8LcuXMD/dEpQon9Mlb4+2MAkdcvY5BJj/3lTTjXxIBld7adqkNVswNpCRrMGtFzWjxLwimWNdj637sp3rk9Ak77AyzBz7D0TyJlhiVFAPHC7WvnTd3t76CD/LQEHKhoRnF97AZewqWqZWABS027Hn3VLc64/DywOtxSdvvQ1EgKWMZ2/9cyiw1nG+1QKRW4dEhKUB+ru8E8fXk/Sze2ZSFT4Fqdbnxb0QQAmJKX0ufvEzNjl7c7JxeJmbHa/hX4xpztxXWobHYgxdD7eW+8CziKc+TIEbz//vudbr/jjjvw29/+NqD7Wr16dY/b9Xo9Vq1ahVWrVnW7T15eHv7973/3eD9XXXUV9u7dG9DaKHr0lo3U0yS5UBEzLFkS3r2/7/eVg//X+Jxe0+LFgOXJWitcHiGok4CJQsUjePGXr8vwg4m5SDFougxa8gp1z8402OAWvNCrlRicHNyTWA7doUgRjAu3sR54Cae2gTv9K9kHfGXh9a0u1LQ4ACTJtLLoIZaDm/RqmCLoM3FYqu91UxKjr5svin3ZlRfnmmDsRzuDQPU0mKcnbSXhDFj2xzfnGuEWvDAn6QLKYBYzYwHfOTinhHdPmg7OcvBeBfxOk5mZiX379mHEiI5BoH379sk6jIeor/rSLyPcV58HMWDZI5dHkNLib+6lHBzwZawatSpYnR6crmuVeloSRYOupn8fq27B3R/sx95zTUhN0OL+qcM6TFkU8Qp1z477+9qOyDQGbRiAqK2HJU+IKLyCceFWLAmP5V584dJWEt7/YTGZRi2OAqhuic/3n1Jx4E6QL0wFSgz0n4nR3q/fVjRhnDkJsyJ8QIhYEl7HgGW/fFliAQBMyUuFQhHYsVT7zNjyJjsyE7WwOj0MVrbjEbz46IC/DRrLwXsVcMDy7rvvxj333IPTp0/jiiuuAAB88cUX+PWvf42HH35Y9gUS9UbslxHJ2UjipPAKloR3aVdJA5QKBbKTdLhqeEav+yuVCozKTMQ35xpxtLqFAUuKGl2Vbd4/dRgemJYPm0tAikGDZocbS2eOgFKh4BXqAJ2oDc3AHQBIM4hTwplhSeEVjAu3+cywDJqBloQDbYN34nVSeJnFdzwdSeXgQGy/bqxONx6bNRJ3T8lDTpIOVqc77C23uiNlWMZpQH+gviz19a+8bGhKv75f/LtYuu4wNp2sw+s3jsdNDMxJ/u+0rw1aqkGDmSN6P++NdwG/yzz++ONISkrCiy++iKVLlwIAcnNz8eSTT2LhwoWyL5CoN9HQL4MZll0TM82GpSWg+FczcbSqBao+ZkWNzmoLWF4f5HUSyaG7sk0xk/KdH12MYakGKbAgXqGubHYg3ajBWYudwcpeHBcnhGcG/yJGKqeEU4QIxoXbWA68hFu1VBLe/4ClOAE+fgOWvgzLwSn9z1INhmH+AOq5RjucbiFmSj3l7pEbbBkcujMgYsBySgADd7qSoFOj1urEgcpm3HSRHCuLDduL65Fh1OL7F2azrVkfBBywVCgUWLRoERYtWoTm5mYAQFJS/PVOochh1Krx6IwCCF4vfvfFmYj8IGXAsrOuDn4emJaPC81JffqdjeKkcIoyPZVt/u6LM3hs1sgOJzfiFeqNJ2qwZN0RXJRrQtF/F4ZkrdHqpH9CeEgyLNnDkiJEMC7cigHLBpsLjTYXkruZ/EqBq5RKwgfWwxKI45LwCJwQDviyZvVqJexuAWUWG4aH4LMo2KJhuOn5xIA+A5aBK2+0o8xih1IBXDLAwUrjzSYAwAH/AJ94Jybq/GTyYCz67gVsWdBHA3p3YaCSIsWpWismDU5B2eOz0Or0BDRJLhTEgGWN1RlTV1z7q7uDnxVFx6FA3w5+pEnhNQxYUnTob9nmdy9IR63Via2n6lDT4gh7T95IJmZYjswMXUm4xeaCR/D2OTucSG5GrRqPTJf3wm2iTo0Moxa1VieK61sxcVByEFYen+QsCa+1xmeG5Vl/wHJohAUsFQoFhqUl4Gh1C840tMZEwDIahpuer23oTny+PgZCzK4cZzYhcYCDlcbn+GJFDFhGX5ZyJInvqAnFjC9LLbhxzVe4/X/3IjNRB61aGVFX+9ITtNCqlP6Df3549nbwo1H2/tYkBSyrW+D1emVdH1EwiGWbXW7roWxzeIYRFw8ywSN48cmhymAuMarZXR4p62ZERuhKwgF0G4gmCpV/HqzApMEpOPv4bFQ9OQeVT8zB4unDB3QixLLw4KiStSQ8PjN0yiI0wxJoKws/U28L80rk0ZeLrZFGDFjaXAJane4wrya67CoZWP/K9ibk+DIsT9e3osURv78Hq9ON5zafxIqi49JrScxSfn7zSVj5N9ojBiwpJuz3X7nJS00I80q6plAo8K87LkXxr2ZCoVDA6Rbi+s1JjoOfERlGKBS+/eP1gJ2ii1i22RWxbLM7N03wNSv/cH9FUNYWC07VtcLrBUx6NbIS+19q2VcalRKJOl8wiJPCKdxWf1mKG9d8hTVflcp24ZYBS/lZHW5YnR4AA82wjN8ell6vV7o4FWkZlkDbpPBYed3092JrOCXp1ND6ewOyLDwwUv/KvIH1rwSAzEQdspN08HqBQ5XNA76/aCVHok4847NDMeHb8kYAwEW5pjCvpGt2lwfbi+sxZMVGDFpeBPNTG/DCllOwuzzhXlpYyHHwo9eopJOpo9Xx+yFI0cOoVWPJjAI8NmuE9PefYtBg2eyRWDKjoMfgwvwJOQCATSdr2fOmG8f97SFGZhihUISmPFssC2cfSwqnWqsD207XAQCuHp0t2/3mp8dW4CUSiOXgBo0SSQMot4znHpb1rS7YXL4LfJE2dAdoC1iWNMTG62YgF1vDRaFQtCsLj7/XSH+5PQK+LvOdU18+wIE7ogliWXhl/JaFR2OWciQJKGDpcrkwc+ZMnDhxIljrIQqY1+vF/nLfm2AkBizFNPCnN55gGrifSxDwwLRhXW4L5OBndGZbWTiFjtXphtMtoLrFEffZwoGqaLJL/XYDKdscmZmICTm+svB/sSy8SydqQzchXJTGSeEUAT45WAXBC1w8yCQFGeWQn5aADKOWbVdk1L4cfCAXVsSApcXmgtMdeQGjYBKzK7MStdCpI6/3W6xlJhu1aiyePrxfF1vDiYN3AnewshmtLg9MejXGZMlzLDVOGrwTv8kl0ZilHEkCeofRaDT49ttvg7UWon4pabCh0e6GRqXAmKzIGwQVjc2qg+10bSvun5oPrxcDGhAwKisR/z5azYBlCLFp9MBsOVWHu97fj2vHZOFfd14OAH2e3nvTRTn4tqIJH35bgZ9dNjSYy4xK4sCdUEwIF6Ul+E6IWBJO4fTxAV+riP8anyPr/V49Kgu3TBqE2hbfwECXIERscCJayDFwBwBSDRqolAp4BC9qrU7kJkdepmGwlEVwOTgADPO3p4qVHpYA8K9DVVKPXKvTHXHDTbsiZlgyYNl3Yjn4pUNSoJRpkOD4HE4KF7OUl7cbNisSE3X6ei4QjwI+6vjJT36C1atX4/nnnw/GeogCJmZXjslKisjp2/2dDByr3B4BP/37XthcAt7+4UQ8NmskGu2ufh38iIN3jjFgGRLdTXcXP4D7Mt093u044zsYvDAn8GzwmybkYNlnx7DxRA0aWp1ITQh+n8ZocrLW9z4wIgQTwkXMsKRwa7S5sPFELQBgvowBS7vLgz/tLuXFKZlVNskTsFQqfSWvVc0OVLc44jJgGYkDdwBgWJpvXeVNdjjcnojMAg3U1lO1+OOuUqy4ehR+NXMkgL5fbA0XqSQ8Dtsm9NeXJRYA8pWDA+1Kwiua4PV6Q9ayJ5KILaEEr3dAiTrxKuAzS7fbjbfeegsbN27E5MmTYTR2PDF46aWXZFscUV9Ecjk40JYG3lXQMh7TwFftOIO955qQYtAgPy0BWrVSCtgGevDTflI4BR+zhQdu55l6AMAV/WhmPjorCRdmJ+FQVTM+PVyF2y4ZIvfyopqYYTkyBBPCRWKJDwOWFC7rjlTB6REwOisRY7LlqTLhxangETMss2S4UJ2V2BawjCelDb6A5eAIDVhmGLUwalWwOj0oabBhZAjblATL/nO+c61Qfr4OFDMsA1ff6kSGUSvLwB3RmOwkKBVAXasLlc0O5Jji5+JKe80Ot9QSyur0ICUKspQjRcCXRg4ePIhJkyYhKSkJx48fx969e6Wvffv2BWGJRD37tsLXHHhCPzKWQiEam1UHy1mLDY9/dhQA8Py8McgaYIaBGLAssdjQyj6KQcem0QNT3+rEEX9wvXBY/w4Gb7rIl0HFaeEdNdvdqPT3hgtthqU4dIcnRBQeHx/w9bT9r/Fm2e6TE02DR+phOcDjHyB+B++cbbQDiNyScIVC0a4sPPr7WLo9Ar6tiOzkkK4wYNl3Ym/6l28Yh+JfzcTUfh6jdsWgUUmter6N47Lwz0/X4cY1X+HaP+1GVqIOWrWSF/76KOBnacuWLcFYB1G/RXqGpZgGDvgO9OM5DXzRJ4fQ4vCgMC8Vd8nQgy/DqEVaggb1rS6cqLXiotxkGVZJ3WG28MDs9JeDj8o0IsPYv5PVmybk4qkNx7HheA0abS4kd9PEO96c8JeDZxq13TY2DwaxJLyBGZYUBq1ON/5ztBqAvOXgbGUTPGI2pFnWgGW8ZVj6goCRWhIO+MrCD1U140xD9PexPFFrhd0twKhVYXh66C4IDlRbwDK+Xh+BCkVv+gk5JhyrseJARTPmjsqS5T6jzfZiX4XVmOzoyVKOFP2+RHry5EmsX78eNpvvjZgTBCkcmu1unKrzHbhEasASAPQaFRZPH46yx2fh9C9noqKPk4FjybrDVfjHgQqolAq8MX+CLM2cFQoFy8JDyOkRcP/UYV1ui7ds4f7YUeI7WCkcltbv+xibnYjRWYlwegSsPVIl19KinlQOHsLsSoA9LCm81h+rQavLg2GpBlw8SL4LdpxoGjztp4QPlDgFuSbOMsjKLP4My9RIDljGzqTwff7EkAk5JqhkGsQSCpn+C8PMsOye1enGc5tPYkXRcekildj+4/nNJ2GVqXptnL8K8mAcZ1iKPeyn5ff/HCBeBRywrKurw8yZMzFy5Ehcc801qKjwlaXdeeed+MUvfiH7Aol6cqDS98aXa9JH/NV+o1aN2W/uxHVv7cbu0oa4SgNvdbpx/8cHAACLrrwAE2QMLo9iwDJkPj1UhQem5eOxWSOkk9kUgwbLZo/EkhkFcfU33R87in0HK1cMoNRGoVDgpgliWXi5LOuKBSdqxQnhob1ynSr2sGRJOIXBR+2mg8s5yICtbIKnyl++LUdJeKY/gyyeMiw9ghfnmnwByyEpkdsLTywJL4mBgGWkV7J1h0N3eheq9h/j/YN34rUk3Opw45tzvhZ2UweQtBCvAv4rXLRoETQaDUpLS5GQkCDd/sMf/hCfffaZrIsj6k20fYgm6dU4WNksZYXGi+VFJ1DSYMPQFAOemD1S1vsenclJ4aFQ1ezAzz/6Ft99fQd+PGkQKp6YjdO/nImyx2fFXbZwf7g8AnaX+QKWAz1YuWlCLgDgs2M1aLazdysAnKgJ/YRwoF0PS2ZYUog53QI+PezLsr5RxnJwoK2VzbLZI3lxSmbB6GFZ0xw/AZmKJjs8ghdqpQLmpMgNWOanx06G5f5yX6BlooxZ3KHAHpa9C1VvenHOxJHqFrg98XfBa3eZBR7Bi8HJ+ojODI9UAR9xbNiwAevXr8fgwYM73D5ixAiUlJTItjCivtjn/xCVM2MvmIaKV1wbov8Apq+OVDXjpW2nAACv/dc4GHXynuiwJDw0Hl17GI12N4anqzAiIxEOtwfXvbUblc0OHH7kKp7A9mJ/eRNsLgGpBg1GDXBi6PicJIzIMOJErRXrjlTh5osHybTK6NWWYRmmkvBuDviJgmXTiRo02d0wJ+lQKONEV5HYymbJjAJUNjuQlaiDF15enBqAVqcbzQ7fRSY5SsLjsYdlmcXXimxQsj6iy5OH+YMSsdDDUiwJnxgl51oisWVCXasTguCVpRVVrAlVb/phqQkwalWwOj04UWvFmOwkWe43WnxxxtcSamp+mqzVEPEi4AxLq9XaIbNSVF9fD50usktyKfZ8K2ZYRuiE8PPl+Q9gSmLgAKYn4rS56hYH8lIT8P5tl+D+qcPw/Qvlm2IqEgOWx2paIAjspRsM207V4s97zkKhAF6fPx4qpQIJWjWaHW7UWp0MFveBeLBSmJc64INmhULRNi38W5aFA+17WIa2JFzMsKxvdbKXN4XURwd908FvGGcO2om4UavGqbpWXPfWbkx+eRsvTA1QlT8TUqdWwqQf+HOZlRh/JeFi/8pIHrgDtPWwrGp2wObyhHk1/VfZZEdVswNKBTDOHF1BpnT/57PgBRp4UbFLoWr/oVQqpL+feCwL/8I/cIfl4P0TcMDyO9/5Dv785z9L/1coFBAEAStXrsT06dNlXRxRTzyCFwcqmgFET0m4GLAsjeGApThtzvzUBpif3IDBK4rwzVkLnp83NiiPl5+WAI1KAZtLkK68k3xcHgELPvL1H71nSh4uG9qWycPs1r4TJ4RfIVOzbbEs/N9HqtHiiO+y8DqrUzoZKcjofEE1mNL85bIujxdWZ/SelAZb+4tYTrcgWyP/eOX2CPjEH7CcP0HecvDzDUrW42BlM47VWNHK39uAVLW0DdyRI8tGKgmPo5LXUv9xXqQHLFMNGikofSaKy8LF7MqRmYlIiLILFtp2FwZYFt41sf3H47OD35t+vD+5SDx3jxcewYudJf6WUBy40y8B/xWuXLkSM2fOxNdffw2n04lHHnkEhw4dQn19Pb744otgrJGoS6fqrGh1eaBXK0NeBthfeSmxXRJudbqxcssprCg6Lt1msbnw9MYTUCoUWDx9uOwZGmqV7/d/uKoFR2takJcW2oBFrPvt56dxuKoFGUYtnrl6dIdto7ISsf5YDQOWfbDDn2F5hUylmxNzTbggPQGn61rxn6PV+MFFubLcbzQ67u9fOThZH/ITqgStChqVAi6PF/WtTiTK3PIiFogXsV7bXgyLzYUUgwYLp+VjyYwClhf30/bietRanUhL0ODKC9KD+ljJejWSdL6M+jKLXRp0R4ET+1eaZehfCbSVvFqdHlgdbtlb7kSisigJWCoUCgxLTcC3FU04U98atSWwYuutaCsHF2UatWiy+6qBRoV7MRFKr1Hhe6Oy8Mj0AjTa3MgwauESBNk/n9sClvGVYXmwsglNdjcSdSqMj7Is5UgRcIbluHHjcPz4cUybNg3XX389rFYrbrzxRuzduxfDhw8PxhqJuiQO3BlnToJaJc8Us2ATMyzLLPaYLF8O1bS58zHTLzjKLDY8tcEXfF557Vip/FXEgUd9U9rQirONdqiUClw6JEWW+1QoFJg/ntPCgfD1rwR8vwdp8A5LzjqxOt14bvNJrCg6LvXIsthcWF50HM9vPslMy376h386+HUXmqEJ8vGPQqHAUH9wqJRVDAMiZVjKFLBM0qmhU/t+//GSZdkWsIzcgTui/DTf66a4PnpfN23DTaNr4I5ImhRujZ+2Cf3x0/f2If+ZTThTb4VWrQxK+48J/knh8Raw/KLYl11ZmJcaNfGKSNOvv8bk5GT86le/knstRAERP0QnRNGH6KBkPZQKwOkRUNnsQG5y5B9wBaIv0+YyZWg0f75RDFgGxcOfHEKry4Np+Wm4bfLgTtsZKO6bHf5y8ItzTbJmwPzgoly8sPUU1h2pRqvTHXXlWnIR+1eOCHH/SlGaQYOqZgfqOSm8k94uYv1y5ogQryj6CYIX//SXg8s9Hbw7Q1MNOFTVHNPtbEJBzLDMkilgqVAokJWoRZnFjuoWh9Q3MZaJAcuhEZ5hCUCq+DkTxVVV+86JE8KjM8OSk8J712x3t134DeJxlJhheabBhia7CyaZBvpEOrGH/RXsX9lv/QrzNjQ04De/+Q3uvPNO3HnnnXjxxRdRX18v99qIevRtFE6tU6uUGOQPUsZiWbg4ba7LbTJOmzufNHiHgTPZbDpejX8cqIBKqcCqG8d3OdRBLHEqrm+FPYqbygfbDn/vmkKZD1YmD05GXqoBrS4PPjtWI+t9R5MT/pLwkZnhaQ0iTQpv5QnR+fpyEYsCs7vMgnONdiTp1Jg1IiMkjzmEGZayqGxu62Epl7ZJ4fHx/hMtJeGAbzIyAJREaQ9Lq8ON4/5A1sQoSg5pL9Poe30wYNm9/RW+oPSgZH1QkkpEaQla5Jp858AHK+Onj6U4cGca+1f2W8ABy88//xzDhg3Dq6++ioaGBjQ0NODVV19Ffn4+Pv/882CskahL4htstAzcEeX5D2Bi8cA/VNPmzjc60xc4Y6bfwEiDMZodmDIsDR/99FI8c/Uo6aro+bIStUgxaCB428pyqbMdxeLVVXn6V4oUCoU0cGP90WpZ7zuahLMkHGg/KZzBt/OF6yJWLPvIXw4+b0xWyHqADhXb2TDDckCqm+UtCQfaDd6Jg0nhdpdHCsxGQ8Ay359hWRylAcuDlc3wen09V+X8mw2ldLEkPE4C+v2x95wvAejiEASl460svMxiQ6nFBpVSgcuHynsOEE8Crh9bsGABfvjDH+KNN96ASuU7UPJ4PPj5z3+OBQsW4MCBA7Ivkuh89a1OlFnsAIAJ3QRTIlVeqgHbi4GSGDzwF6fNAb5yv1ANWBiV5QtUVDY7pMekwHQ1GOP+qcOwtIeSTYVCgdFZidhV0oCj1S3dBjbjWYvDjf3+A7OpQSgHuXXSYHwnPx2zRmagutmBFIMGLkEISv+hSOT1eqWA5cgwlYSn+t9v2MOyM/Ei1vJ2g9hE4kUsbf+KfeKS1+uVApahKgcH2spvyxpj77gllNpPCZdLpj8gEw8Zlmcbfcf9CRqVlNkeyYb5e1ieidLj/WgfuAO0lYTXMcOyW+Lv+aIQlP2PyzHhs2M1cTMpXMyunJhr4lDGAQj4mTt58iQ+/PBDKVgJACqVCg8//DD+/Oc/y7o4ou6I/SuHpRqQHGXBKTFTIRYDloBv2tydlw3B4unDUWd1wpykD8q0ufZMeg1yTXqUN9lxrLoFl8s0iTleDGS6++jMtoAldfZVmQUewYshKXoMDkJGyKisRPzjQAV+9vd9cTmBuaLJAavTA6WiLZsl1FKlknAGLM9n1KrxyPQCCF4vfvfFGelv9IFpw+Lmb1RO31Y04XRdK/RqJb43OitkjysN3YnR45ZQqZIyLLW97Nl3mVJJeOxnWLYfuKNQdG5TE2nEkvBaqxMtDnfUBSz2ReGsgPNlJrKHZW/EPqUXDwr+73l8nGVYsn+lPAK+rD1p0iQcOXKk0+1HjhzBRRddJMuiiHrTNrUu+q76SSXhMdjDUvSfYzXIf2YTVm45GbRpc+fjAJj+G8h091HsH9qjYB6siBOYn954Im4nMB/396/MT0uAVh2eTL22knCeEHXljZ1nMGlwCs4+Phvnls1G2eOzMHVYGoOV/fB/p+uRYdRi7qjMkAY/2vew9Hq9IXvcWCNmWJqT5Bu4mJUolrzGfsBSDJhHQzk4ACQbNFIG/pkoLAvfH4WzAs7XNiWcn89dcboFqZ9kaErCfX9LByqb4+KzRMywDEaFVTzp09HOt99+K/174cKFePDBB3Hy5ElMmTIFALBr1y6sWrUKzz//fHBWSXSeb6P4ql9ejGdYAsDpulbUWp1Q9hDoktuorERsPlmLozUMnAVqINPdGSju2U7/hPBgBCw5gTn8/SuBtqE7Dcyw7KTV6cZzm06gvtWFdXdehu9ckIaRz29GRZMDxx6dHrbJ7tHG6nRDo1Ti+2Oz8bPLhqCiyR7Sxx+UrIdCATjcAmpanLJNuY4ndpcHTXbfRaRg9LCMh5JwsSXBkNToCFgCvrLwhnMunGmwYVwUtc3xCN624aZROiEc4JTw3hyuaobL40WyXi21MAim0VmJUCkVsNhcONdoD0rlUaRotrvxrdgSKp+VfwPRp4DlxIkToVAoOkTCH3nkkU77/fjHP8YPf/hD+VZH1I1oHbgDdAxYer3eqChrCVRxnS+IcEEISzQ5Kbz/xMEYXQUtexuMMSa7LWApCN4up4nHK0HwYmeJGLCU/2BlIIHmWHG8xh+wDGPgS8ygYYZlZ3/75hzqW13IT0vAnFFZUCkVuDA7CRVNDnx6uAoPf5cBy9501V841G0ftGolcpJ8bVdKLTYGLPtBLAfXqpRI1suXHStlWFrjKMMyOXqCHPlpCdh7rinqBu+crLWi1eWBQaPEiIzofZ/OZMCyR3vPiX1Kk0NyPqpTqzAq04jDVS34tqIppgOWu0obIHh97esGRdF7ViTqU/pTcXExTp8+jeLi4h6/Tp8+HdCDP/fcc7j00kuRlJSErKws3HDDDTh27FiHfex2OxYsWID09HQkJiZi/vz5qKqq6rBPaWkp5s2bh4SEBGRlZWHx4sVwuzuWwm3duhWTJk2CTqdDQUEB1qxZE9BaKXK4PAIOVfqCUhdF0dVKkdgLqtnh7jbYEO1O+w/MLkgPfcCSmX6BG8h09/y0BGhUCrS6PDjLgQwdHKlugcXmQoJGFZThYJzADJyo9b3eR2aGM8PSd0LEoTsdeb1eKQN4wdRhUPkvZswbmw0AWHu4qtvvJR+x7cOKouNhb/sg9t8utfB9vj8q2/WvlDMwIAaP4yHD8qz/b29oFGVYim2goq0kXCwHn5Bjkt67o5GYYdnscMPh9oR5NZFnXxiyaKWy8BgfvLPdXw4+LZ/l4APVp4BlXl5en78CsW3bNixYsAC7du1CUVERXC4X5syZA6vVKu2zaNEifPrpp/jggw+wbds2lJeX48Ybb5S2ezwezJs3D06nEzt27MA777yDNWvWYNmyZdI+xcXFmDdvHqZPn459+/bhoYcewl133YX169cHtF6KDMeqW+D0CEjUqcI2ZGEgErRq6QM0Vg/8T9f5A5ZhyLA8WWuFy9N9gI06E6e7PzZrhBQASzFosGz2SCyZUdBjD1KNSomCdF+wiMHijnb4+1dePjQFGpX87REGEmiOFSdqIqcknEN3Otp6qg4HK5uRoFHhjsuGSrd/3x+w/L/iejQwK7VHA+kvLDcO3hmYYEwIB9pPCXfEfE+4MouvFUK09LAEgGH+4+CSKOtbL02OjsLWW+0l6zVSwJVZlp2FcuCOSGyNcLAytgfv7ODAHdn0qyahvLwc27dvR3V1NYTzTogWLlzY5/v57LPPOvx/zZo1yMrKwp49e3DllVeisbERq1evxrvvvosZM2YAAN5++22MGTMGu3btwpQpU7BhwwYcPnwYGzduRHZ2NiZOnIgVK1bg0UcfxZNPPgmtVos333wT+fn5ePHFFwEAY8aMwfbt2/Hyyy9j7ty5ndblcDjgcLSVVjQ1xfYLKtrs9/eDuCjHFLXlp3mpBtRanShpsEX9wcD5LDaXlGk0LIQBy0EmPYxaFaxOD07XtUrDYKhvdGolLh+aikdnFKDF4UGqQdPn6e6jsxJxpLoFR6tbMGdU6CbXRjqxf2VhkA5WxEAz4AtexNuUcI/gxSn/xZGRYSwJl4bu2Hgy1J4YaLvtksEdMoEvSDdibHYiDle14LNjNfjRxYPCtcSIF0ltH9oP3qHAtU0Ilzlg6f/9uzxeNNrd3Wbdx4LSdlPCo4WYWBFtJeGxMHAHAJRKBTKMWlQ1O1DT4mRpbjuC4JUyLEMZsBxv9k0K/zaGJ4W7PQJ2+VtCMcNy4AIOWK5Zswb//d//Da1Wi/T09A5lDQqFIqCA5fkaG31R/rQ03y92z549cLlcmDVrlrTP6NGjMXToUOzcuRNTpkzBzp07MX78eGRnZ0v7zJ07F/fddx8OHTqEiy++GDt37uxwH+I+Dz30UJfreO655/DUU0/1++eg4NofxQN3RHmpBuw52xiTg3fEg7KsRG1Ip5gqlQqMykzEN+cacbS6hQHLAB2vseL7b+3G4GQ9Ti2dCY1aCW3fkvCl55oZlh21TQgPXrNtvUaFxdOHY8mMAlQ2O5CVqIMX3pgPVgK+TC+nR4BWpQxrxo2YYdni8MDlEYKSTRttiuta8cmhSgDAA11kAV871ozDVSex7nAVA5Y9GEh/YbmJZbhlMXjcEgpShqWME8IBwKBRIUmnRrPDjeoWR8wGLBttLjQ7fC0QoqmH5TD/6+ZMfXS9btoyLKM7YAkAGQm+gCUzLDs6Xd+KZocbOrVSqlILBbEk/Gh1S8weM+2vaILV6UGKQYOx2UnhXk7UC/gv5PHHH8eyZcvQ2NiIM2fODKiHZXuCIOChhx7C1KlTMW7cOABAZWUltFotUlJSOuybnZ2NyspKaZ/2wUpxu7itp32amppgs3X+AFm6dCkaGxulr7Kysn7/XCQ/cWpdNH+IDk2NzhKRvjgtDtxJD32JJvtY9p9YupCflgCNOrCPBg486qymxSFNsJ6SF9zpgEatGmctNlz31m6MXbkFBnXsBysB4Li/f2VBRkJYe2y1DxpxUrjPqh3F8HqBOSMzMaaLg3WxLPw/R6vhZguPbkVS2wexJLyMGZb9UtWuh6XcpME7MdzHUvy7S0vQwBjCi+EDJVYaNdhcaIySPsdVzQ5UNDmgUADjo3BWwPkyEzl4pytiOfg4c1JIg4ZDUw0w6dVwebwxe97whb9/ZWFeatRWg0aSgP86W1tbcfPNN0Mpc9+cBQsW4ODBg3jvvfdkvd/+0Ol0MJlMHb4ockhX/aL4Q1ScFB6LvaDC0b9SNCorERlGLVocoRtEECt2lPS/fHlMli8gcSRGDzz6Q5wOPjY7USoZDqZhaQk4UWtFqcUWdaVn/RUJ/SsBQKVUSFlNLAsHWhxurP6yFEDX2ZWAL4ifnqBBg80lZSJTZ2Lbh8dnB95fWG4cujMw1c3B6WEJAFmJ4uCd2J0U3lYOHj3ZlQCQqPP1rc8walHZbA/3cvpkv/88a0SGMaSVUsEizg2oYcCyg73+3/PEEJaDA76K3FgvCxcDllNZDi6LgKOOd955Jz744ANZF3H//fdj7dq12LJlCwYPHizdbjab4XQ6YbFYOuxfVVUFs9ks7XP+1HDx/73tYzKZYDBE1wdfvKtssqO6xQmFwndFKFqJActYLAkXJ4SHsn+l6CeTBqH4VzNx15ShcLqFkE5QjXY7z7RdDQzUqCxfwKiy2dFtv7V4I11dDVGzbbVKibHZvkzXg5WxPXlRdNyfwToijP0rRRy80+Yve86i0e7G8PQEXD266562KqUC14zxZVl+ymnhPdJrVJg1IhNlj8/C2WWzUfnEHCyePjzkbR/EvoGVzQ5O2+2HtpJw+QOWYgZZLAcsxQzLoVEWsASAv986GcW/mgmTXhMVx6bS5Ogobr3VXrqRGZZd2XfO378yDL9ncfDOgRg8XvV6vfjC38N+ahBbQsWTgC+bPPfcc7j22mvx2WefYfz48dBoOvZKeemll/p8X16vFw888AA+/vhjbN26Ffn5Ha/ET548GRqNBps2bcL8+fMBAMeOHUNpaSkKCwsBAIWFhXjmmWdQXV2NrCzfgXFRURFMJhPGjh0r7fPvf/+7w30XFRVJ90HRQxy4MyLDGFUlIefLi+GS8DP+gOUF6aENWNpdHqz5ugyvbT8Td8NHBqqh1YnDVb7syP4ELE16DXJNepQ32XGsugWXB7kEOhqIGZZXhPC5GGc2Ye+5JhysbML148whe9xwOVHj+5sdmRneDEsASDNocBoMWHq9XmnYzv3T8nsshbp2bDb+sucs1h6uwm++f2Golhh1vF4vbnrna3gBbLp3CnJN+j73F5ZTeoIWBo0SNpeAsxY7hoc5sznaVAYxwzJTyrCM3YCMmGE5OMoClnaXB1tO1mL+O19HzbHp/hhovdVeJgOWXdorTQgP/e95vNk/KTwGMyzP1NtQ3mSHRqXApUNSwr2cmNCvgOX69esxatQoAOg0dCcQCxYswLvvvotPPvkESUlJUs/J5ORkGAwGJCcn484778TDDz+MtLQ0mEwmPPDAAygsLMSUKVMAAHPmzMHYsWNx6623YuXKlaisrMRjjz2GBQsWQKfzfYDfe++9+N3vfodHHnkEd9xxBzZv3oz3338f69atC/THpzCTPkSjuBwcaMuwrG5xwubywBChBy39EY6ScKvTjZVbTmFF0QnpNovNheVFxwEAi6cPD2npXLT5stQCACjIMCKrn9kfo7MSUd5kx1EGLOF0C/iqzAIgtOUgF/qzzg/F4BXrrog9QsNdEg4AqVKGZXyfEG08UYuj1S1I1Knws0uH9Ljv3FGZ0KgUOF5jxfGalrBOeo9kFU0O1FidUCqA4WHoDS1SKBQYmmLAsRpf6wkGLAMTrCnhQFsPy1jOsDxr8ZVTR1OGpXhs+vTG6Do2FUvCo31CuEgsCa+N4ddHoCqb7KhsDl+f0gm5sVsSLra5mTQoGQkR+PqORgFfon3xxRfx1ltv4ciRI9i6dSu2bNkifW3evDmg+3rjjTfQ2NiIq666Cjk5OdLX3//+d2mfl19+Gddeey3mz5+PK6+8EmazGR999JG0XaVSYe3atVCpVCgsLMRPfvIT3HbbbVi+fLm0T35+PtatW4eioiJcdNFFePHFF/GnP/0Jc+fODfTHpzD7VpoQHt0foqkGDYxaX5AylhrYewQvzjSEPsNSo1RKWT3ne3V7MTQy99yNNeLAnYFkA0qTwmvYx/Kbc41wuAWkJ2hCGkwT22TEQ0m40y1I2dyREOgS+5Q2xHlLhNf+z/c+/NNLh8LUywRrk16D716QDgBYy7Lwbol9u0dnJYb95GdoDPffDia7y4NGu68MODgBS999xnIGWZnUw1LeKevBFI3HpjaXRxpcGerehsGSwQzLTsSy/5Fh6lM6zp9hWWaxx1wrKTFgeUWIWkLFg4D/QnU6HaZOnSrLg3u93l730ev1WLVqFVatWtXtPnl5eZ1Kvs931VVXYe/evQGvkSJLW5lCdH+IKhQK5KUacLiqBSUNtog44ZbDuUYbXB4vNCoFBiWH7iq4xe7q9gPPYnOh0e6SSqaos53SwJ3+Byw5KbzNjnYHK4FWHgyEGLA8Wt0Cp1uANsBp79HkdL0VghdI1KlgDkIAIFCpBvawPFlrxbqjvsDj/VOH9el7rh2bjY0narH2cBUe/u7wIK4uerWV7YX/uGdIiu9CJAfvBEbMfNSoFNJ7hZykoTvNsZtBFo1Dd6Lx2PRgRTMEr6+MOhI+W+UgPse1cV4B0V64P1dSDBoMSdGjzGLHgYomfMd/8TIWiD3sp3HgjmwCPpt58MEH8dprrwVjLUQ9srs8UvZWLJQpxGIfS7EcPC81AaoeepfJLUWvkSaodtpm0CC5l0yfeOb2CPiy1N9vcQBXA8WA5VEGLLHzzMCfz/4YkmKASa+GW/DieIxnuh5vNyE8lEHh7ogZlvFcEv72V6XweoFrRmf1+SLctWN9g3f+r7geDXH83PVEHIwQCRdqxXJcBiwDU9Xs+9vOTtQF5f1K7NEXqz0sBcEblSXh0Xhsuk+aHG2KiM9WOUhTwmP09dEf+86FZ0J4exPEwTsVsVMV1NDqxKEq38/DDEv5BJxhuXv3bmzevBlr167FhRde2GnoTvtybSI5Ha5qhkfwIi1Bg0HJ0VMS0p2hMTgpvLg+9P0rAcAlCFg4LV/qC9Tewmn5cAlCWIYURIODlc1ocXhg0qsxNjup3/czxh+wPFlrhcsjQKOKz+fbNx1QzLAMbS9PhUKBceYk7DjTgIOVzdIUxlh0QgpYRkZ2ujglvCHOMiytTjc0SiUsNhd+OXMELh2Sigxj30/CL0g3Ymx2Ig5XteCzYzX40cWDgrja6CQGEMIxGOF84nFLWQwdt4RCMCeEA+0yLGO0R1+N1QmnR4BCAeRG0fF/NB6b7ouRSrb22peEe73emAnEDsReaRJ8+D5XxuWYsO5INQ5Uxk4fy50lDfB6fRfTg/V+H48CDlimpKTgxhtvDMZaiHrUfuBOLHzY5MVgL6jT/oBlfognhBu1aiyZUQDA1xcoWiYxRoId/mzAy4emDCgrdlCyHkatClanB6fqrBid1f/gZzQrbbAhw6iFQgFcEobpgBe2C1jGsvImG8aZkyJmiqlY5hlPPSztLg9WbjmF19q9594/dRh+OXNEQPdz7VgzDledxNrDVQxYnqfR5sIpf+XCxAgIIIjZbbHUezsUqoI4IRxoG7pT2+qER/CGtMIlFMTj5JwkfVRdDI3GY9NYG7gDtAUs3YIXTXY3koPQliGaNNvdOOkfWhjOViPj/W2MDsTQ4B0xYWEqsytlFXDA8u233w7GOoh6tS9GBu6IYrEkvDgME8JFeo0Ki6cPxy9njkB5kx2ZiVrYXUJEHhBGkl0lvg/XwryBfbgqFAqMzkrEnrONOFrdEpcBS6vTjewkHT654zJkJ+og9KFPs9zERuaHYuiK9fmsTjdWfG8M7p/mQE6SDlanO+yTVuOtJFycfruiXeaQxebC0xtPQKlQBDT99vtjs7Fyy0n852h1XGdnd0WcoDokRY90/0l3OElDdyw2ZioFoLLZV86cFaSMGzEg4/X63oMirS/iQJU1+gKW4t9fNBGPTR+dUYCqZgeyk3zHBpF4bCoIXik5JBIukMjFoFFJF9RrrM64D1jur/AFpQcl68P6XiGWhB+sbI6Zz5Mdxb4kkKnsXykrHhVS1Pg2xsoU8mKwJFzMsAzlhPD2jFo1tGolFn1yEPnPbMJuf29G6t6OErHf4sDLl+O5j6WYbZa7vAjDn92EwSuK8MKWU7C7PCFdhzh450CMZliKz/PgFb7nOXd5eJ7n84kl4fEydEfO6bdT8lKRYdTCYnNJzerJRxyMECnBg8H+clyr0xNX2cQDVeXvnResEkG1Sol0/3tQLPaxFDMsh0RROXh7Rq0af/66DNe9tRsL/vFt2C+wded0fSusTg/0aiVGZhrDvRxZcVJ4m73+vsgXh/lzZVRWIjQqBZrs7pioNnS6BbQ43MgwajE1P7QtoWJdwO+Y+fn5PUbAT58+PaAFEXXF6/Vif4UYsIyNDEuxtOpsox1ujwB1DGSVnK7zlRjkhyHDsj2dWoVaqxMHKptx9ZjssK4lklU22XG6rhUKBXD50IF/uI6K00nh3WWbiX2rAsk2GygxYHm6rhVWhxtGXWSeGPVHJD3P54vFDEupP6XdhRS9Bi5BgFGrRmWTHR6vV7bptyqlAteMzsKf95zF2iNVuKogQ84fI6qJlSXhHIzQnl6jQlaiFtUtTpQ22KS/e+pZdZBLwgHfJOS6VheqWxy4ELFV4SC2IBgShRmWogvSjThY2QyXRwj3UrolDmIZn2OKiXOS9jKNWpQ02BiwRLsLYWHui6xRKTE6KxEHKprxbUUT8sJ87jgQVqcbaqUC799+idSig+QT8LvRQw89hAcffFD6+vnPf47CwkI0NjbinnvuCcYaiVBmscFic0GtVGBsdmQMWRioHJMeaqUCHsGLiubob5RudbilK/sXpIf3yuy4HN/B+qEYzTKTy05/duU4c5IsJTKjM+Mzw1LObLOBykzUSVk8h6ti6/cQSc/z+dr3sBSE0LcCkJuYyWp+agPMT26A+akNWLnlJOpbnZj/ztdIMcg7/VacFr72cNWA1x5LxABCJAzcEXFSeODEHpbmIA5hEE+SY3HwzlkxYBlFE8LPJ567nKxrhcMd3oqA7sRa66322iaFx97rI1BSn9IIuBA2IceEDKMWlVF8HiweL+U85av8GbJiY0RU/sSSgFMRHnzwwS5vX7VqFb7++usBL4ioK2JPldFZidCpI6/vS3+olAoMSTGguL4VJQ2tUX0gBrRNCE/t4UQ2VMb7+/jFUiPnYBAH7gy0f6VojH/K+JHqlpjpR9MXFrtLtmwzOYwzJ6Gq2YGDlU24dGhKyB432CLteW4v1V+OKXiBZkd0N/XvLpN1RdEJeL3A4ukF+LrMggemDcOKohOdvr8/02/njMqERqXA8Rorjte0YGRmbFyYHAinW8ChKt9Ft0gpCQd8fQS/PtsYEyV8oRLsKeFA+0nhsZdBVhoDActckx7JejUa7W4cr7FifE7kBQVjceCOiCXhPk63IA1lDHdJOAAsmTECb940AfWtLjjdglTJES0iufInlsiWjnD11VfjH//4h1x3R9TBiVorxpmTMC3GmtjGUh/LcPevbG98TlvgzB3B5TfhtlMauCNPr5WCjAQoFUCT3R3VV0sDlaKXN9tsoC70l4XH2qTwSHue2zNoVDBofIdU0d7HsqdM1t99cQZXj87Cd4dnYOmMEVg2e6T0O0kxaLBs9kgsmVEQ8AG6Sa/Bdy9IBwB8eohZlgBwuKoZLo8XKQaNdKwQCYYwwzJgwZ4SDkC6WBOLGZZlFt/QoqFRHLBUKBQY67+oe7gqMj+b98XgwB1Rhv/1URPnAcv2nyvD0sL7erK7PHh//zkMWbEReU9vhPmpDVGXmRjJlT+xRLZn8cMPP0RaWmwFkygyWJ1u3Fs4DJ/ccRlevO5CWJ3ucC9JNjEVsAzjhPDzDUtNgFGrgsMt4EStNdzLiUgOtwdfl/mupssxcAfw9Q4V2wHEU1m4SxCwcFp+l9vEbLNQGicFLGMrwzjSnufzSX0sbdF9QtRbJmuT3bdNnH5b+cQcVD05B5VPzMHi6cP7Pf2WZeEdtQUPTBGVrS5Oai5jwLJPHO62AUXBzbAUS16j+/3nfE63gAr/lPVozrAEgLHmyG1XVNPiwLlG3/M8IQKzPweKGZY+bYPcwvu5YnW68dzmk1hRdEI63hAzE5/ffDJqzvX7UvlDAxdwjurFF1/c4Q/c6/WisrISNTU1eP3112VdHJHYF+K17cWw2FxIMWiwcFo+lswo6PdJUSQZmuoL7pU0tIZ5JQMnZlgOi4CApVKpwDhzEr4steBARbNUqkxt9p5rgtMjIMOoRUGGfD1HR2cm4mStFUerWzA9ToZnGLVqPDK9AILXi999cSbs71ViS4RYy7A0atV4dEbkPM/nS0vQ4FyjPeozLMVM1q4Ows/PZBUzKcXsrkDKwM/3/bFmPPTJIRytaUGjzRXVZfVyaBuMEFnZTlIPyxi40BoKYom2WqmQet0GQ6bRn0EWYxmW5U12eL2AVqVEpjG6h1mIfSyPRGB/abH1VkGGEUn62CthFQOWdfEesCyPjAG2vWUm/nLmiBCvqH8COV6i/gv4HemGG27o8H+lUonMzExcddVVGD16tFzrIoqLvhBihmUsHPifqYucknAAuNBswpelFhysbML/Q264lxNxdpzxlYNfMSxV1quso7ISsfZIVVxlWALA2sOVmDQ4BWcfnw2r041k/1TlcATRxLKziiYH6qxOpEf5SV5735y1YNLgFJQ9PgutTk9Yn+fzSYN3ojxg6RIEWftT9lV+egKK/nsKpuSlotHmhkGjirp+VnLady4y+8kNTfF9xjPDsm/EcvCsRB2UyuBlNMXq0B1pQniKPqjPXyhc6P9sPhSBJeHtM7pjkRjsjveS8P3SILfwXgiL5J7kgRArf5a3i1WIgnm8FG8CPgp84okngrEOok5i5epLT2KqJLzeV3od7gnhIrGPZaxlmcllp8wDd0Sjs3wZBMfiLGD5wf4K/ONABV64dix+cdVwAAPLNhuIJL0aw1INONNgw6HKZlw5PD0s6wiG9cdq8PTGE7ivMA+r5k8AEL7n+XxSSXhrdJ8QGbVqPPidC+D1IqSZrHaXB9tO1+EHf94TcdmzoSYIXimAEO4Ty/OJJeHlTXa4PAI0qsh4/UUqqX9lUnAvHMXq0J1YGLgjEi8mnqi1wukWoFVHzmunuM43K0CunuaRhiXhkfW5EiuZiUatGg9deUHEVv7Eivi8bE1RIVauvvRELK0qaWiN6qnKXq83onpYApwU3hOv14sv2mVYymmMWPJUHT+BYrdHwKaTtQAQMYPBxplNONNgw8EYC1iKk+0jccKqOCm8vpvPrWhRa3Xgqtd34Omrx6DiiTlosruCnskqVlQ83S6rM9YqKgJRXN+KZocbOrVSuggUKTKNWmhVSjg9Asob7ciLkM/8SCVOCDcn6YP6OFlJsZ1hGc0Dd0SDkvUw6dVosrtxvKYF4yLkc8zqdOOF749FVYsTOUk6WJ3umHu/ZcDS17orUj5XYiUz0WJzYeYbO/D4nFGoeGI2muzhrbCKVX3+S1AqlVCpVD1+qdWx9eZG4RXJE2HlIl4xtrkE1EVxVk5lswN2twCloi37ItzEDMvT9a2wOqKjeXOolDTYUNnsgFqpwCVDUmS971GZvoOgMosdLXHyvH99tlG6qir389lfF/r//g/E0OAdt0fAl6W+gOXUCAkMt5dmiI0My3WHq3G4qgVPbTgGnVqJzEQdtGplUE9gOWmzo33lvrK9ceakiMtgVCoVGJLiC75xUnjvQjEhHGjLsGy0u+F0h3cAmZzECeGDYyBg2X5SeKSUhYuzAgav2Ijhz25C7vKiqJvU3BeZ/pYJFpsLLk/svD4CIfZFHh8BnytGrRpLZhRg2eyR0rl+ikGDZbNHYsmMgqgJmL/zdRn2ljdh2WdHfX12Q3C8FI/6/Gx+/PHH3W7buXMnXn31VQhhntBJscXXRyu/Qw9LUTRdfemJXqOCOUmHymYHShpsyDBGZ8aomF05JMUQ9g9BUWaiDtlJOlQ1O3CoqhmXDY3NMpf+EPtXXjwoGQaZrwCmG7XINGpRY3XieE0LJg1OkfX+I9GGYzUAgFkjMqCKkB5b4yN4Gml/7a9ogtXpQbJeLfUCiyRShmWU97D89HAlAOC6C80he8x4qKgIxN5z/n5yEVYOLhqaYsCpulYGLPtAzLDMCuKEcMB3kV+lVMAjeFFjdWBQcvQH+ACg0ebCOHMSRmTERibv2Owk7CppwOEIGLwTD7MCRKkGLRQKwOv1Dd4xm4Kb8RyJxAthF0XI54peo8Li6cPxy5kjUNXsQJpRg7MWe9RkJgqCF2/sOAMA+PkVw6K2SjIa9Pld6Prrr+9027Fjx7BkyRJ8+umnuOWWW7B8+XJZF0fxzddHKx/eGO8LkZdqkAKWk6M0uFNcH1nl4KJx5iRUNTtwsJIBy/Z2lvj7V8pcDi4anZWImuJ6HK2Oj4Bl0fFqAMDskZlhXkmbce0mhUdzu4n2vigW2xikReTwhTR/lkB3gbdoYHd5sN4fgL/uwuyQPW6s9LOSy/7yyBy4IxoaQwMDg83m9GCcOQnD0oIbIFEqFcg0alHZ7EB1izMmApZWpxt/+MEEX6myKTZKlcVJ4Ycj4GJiPMwKEKmUCqQZNKhrdaE2XgOW/gthF+dGRsASgPR6/tfhSjy14TjmjMzEX2+ZFOZV9c3GEzU4XmOFSa/GTyYPDvdyYlq/3vXLy8vxxBNP4J133sHcuXOxb98+jBs3Tu61UZw7XWfF99/ajWdC2EcrHPJSE/BlqQUlDa3hXkq/iRmW+REycEc0zpyETSdq2cfyPOLAnStkHrgjGpWViP/zByxjXeP/b+++46Mqsz6A/2YyLb2Q3hMSepPQewnBsgriiq4FLK+oK2VlFwUBQbDrYkFcV3dFXRs2iriLJIB0kBYhCCSkkJDeJmWS6ff9Y+YOCUwyKTO5Zc738+EPkkvmmeHJLec5zznNBhwrVAPgV8Cyb6g3PKQSqJsNKKnXiuLh9VrAkp+LD2JourPvchU0ehMi/VQY3oNZGGKpZ+UsbIYl140R2sKWs6EMy/Zp9Ea8NWsQyht1PVIbMNRHaQ1YCr+OJbtVeeOhfFElLAy07n74nQdbwt0tsz3ER4nqJoPbdgo/Y+sQzr+FsP6hvqjS6LE/r1owi+zvW7Mr54+IgY9S2AspfNepu7+6ujo8++yzSEpKwvnz57Fnzx78+OOPFKwkLvHPo1dwobwR/zxa0GN1tLgQK4JO4fm2DuH8yrBkG3NQp/BrGnVG/GYN4Loq8ONOncL35VbBZGaQHOyNeB5lGCtlHugTbFlAEMP8tzSKstavjOdf/UoACBLBlvDt58sBALcPDOvRB4a26lmtSk0WVD0rZ6ho0KGkXguJBBjCk6Yc12PvW4oEfN/iatdqA6b3WG3AUB9xNN7R6I14Ze9lrE/PtgXU2K3Kr+69DI1euPWxr+8UziV36BXQkjs33imr16KsQcfb68qYuADIPSQortPakmD4rKCmCT/+brlf+vO4eG4H4wY6HLB8/fXXkZiYiJ07d+Krr77CkSNHMHHiRFeOjbgxndGEzSeKAABPjI3ndjAuFieCrVV86xDOok7hNzpRpIbJzCAmQOWyIvZswPJipfgDlmz9Sj5lV7IGWTM5zpUKP2B5pbYZJfVayKQSjIoN4Ho4dgk9YGk2M9hpvQGf1YP1K1lsPauyNWkoXZOGotWpGB7tjya9uJo/OMLWGUsO9uZt1kYsZVi2i6uAG9t4p7JR2AEZMTfhivZXwVcpg9HMIKdKw+lYDGYzFo6Pt/s9NrNdTELcOGCZWWJ5DuoT7A1vHl5XvBQyjLI2rdyfV83tYDrgg6NXwDDAjD7B6Mtxx3V30OEz/vLly6HVapGUlIRPP/0Uc+bMsfuHEGf47mwpqjR6RPurcFv/UK6H41Lsjb+gt4Rba1gm8CxgOSDMBxIJUNGoR0WDsDMOnIVtuDPOhVlq/UMtgbLsSg1MZsZlr8MH6dmWgGVaXx4GLK2r6OdF0Cn8cItGUV48zbYLtHYJr20W5sPQ6eI6lNRr4aP0wNSkXpyMwVshg0ImRZivErM3n8CcT07iizPFnIyFK+yD5TAe1Rm7ni3DkgKWdnEVcAuxZVgK8xzE6shWZaGydAq3BDi4borXbLA0N12VmizoTs0d1csasBR6QL8rrm0H5+91ZVJvy33HgVx+Byy1BhP+ffwKAODP4xI4Ho176PCZaN68eYKoJ0DE4QNrXYjHxsRBxpOu064SF2gJ8gk1w1JrMKGkXguAf1vCvZUyJAZ5Ibe6CVllDZjm4i6dQsDWrxwb57o6gLGBnlDJpNAazSioaULvYH7VNnWWvGoNcqubIJNKMKU3NwGe9rAZlmLYEs7WrxyfwM/t4MC1DMtmgxnNBhM8BVZnbft5S3fwmX1CoZRxP/Y7BoZjT04VPjtZhEUT3OehINP6YDmMh3XGWDHWmrh1WiPqmg3wb2NbqbviqjYg+zOFviVc7E24BoT74nihmvM6lv84UoCvzhRj05zBWJXaB3Ui7RXAsm0JF3Cd6a66dl3hb8BycmIvvLLnMu8zLLdklqC6yYDYAE/8YUDPNSd0Zx0OWH7yyScuHAYh15wrrcfhglrIpBL83+hYrofjcuyW8OomAzQ6Iy9T9dtzpbYZDAP4KD1sNwN8MjjCD7nVTThXVo9pycFcD4dTZjODY4VswNJ1gR8PqQR9QnxwtrQeFysaRRuwZLMrx8YFwo+HD1CDWhT3N5kZePCws3ZHHbHVr+Rnwx0A8FPJ4CGVwGRmUNtkgKe/sB74frTWr7xjED9uwO8dFom/7jiPU1frcL6swdasQuyEkGHprZQhyEuOmiYDitTNFLC8DlcBN7aGZaXAA5YGsxmLJsRjfXrODd8TQxOugWHcN94xmMz44GgBSustNXMV1l4BAAT92baHzUCudsMt4RqDCcHeCl5nWI6NC4KHVIIrtc24UtOEOJ7t2mNtOmzJnn9iXJyg76uFRJxnJCJo/7BmV84eFI4IPxW3g+kB/p5y+KssQUohNt7Jq7Y23Any5mUWtpjq+HVXdlUjapoM8JRLXZ69Y6tjKeLGO2zAcgYPt4MDQGIvb6hkUjQbzMivEW7JCXWzAees29r52nAHsGz1C/Rk61gK64GooKYJZ0vrIZUAt/bjR8AyxEdpKwnz2ckijkfTMzQ6Iy5Za//y+cESoDqW7WG73tvjytqAobYMS2Gdf67nJffA4gmJot2qPIAHAcvvz5aitF6HcF8l7h4Sydk4elKwtzgC+p2h0RuhN5qx8c7ByF85HSOi+Xtd8VXJkGK97h3I52eW5a+FtTh5tQ5KmRSPjhJ/UhVfUMCS8EqD1ojPT18FIP5mOy2x28KFWMeSrV/Jt+3gLFuncGq8Y8tSGxkTALmLSy30FXnjHaPJjD05VQCANB423AEsma7sg1GWgOtYHrtSC4axnGPCeb6IdS1gKawaa2y3ywkJQbY6X3wwb0QMAOCL08Wir4cLAGdL68EwQISfEmE8L2ESK4KGga7irZDh2WlJPR5wu9Z0R9gBmYycKkzcdBgjYwJQuiYN5WvTULYmDcum9hbFVmU2Wzy7krtO4e9Zs8QWjImDQuYe4YBgL/dquqM1mPD6vlyEv7AbvV/eg5j1GXjnYD60Bv42smPrWO7PreF4JPZtOlwAALhnaKRLynoQ+9zjDEUE44vTV9GoM6FPiDdnRf+5wG4LF2aGpSVgGc/T1P3BEZYbw/PlDTC7wQNve9iA5dgeyFJjMywviTTD8kSRGnVaIwI95UiJDuB6OG0SQ4Yx23CHz9mVLLaOZW0b9ev4aoe1fuUdHHQHb8+t/UMR5CVHSb0WGTmVXA/H5YSwHZwVQxmW7dqXU4Xh0QG4ujq1xwJuoSJpuvP3X3JxsaIRGTlVUFq3KitkUsFnVrJadgq/zEGn8NNX1ThiLb31+Ni4Hn99rrABpko3CFhq9Ea8svcy1qdn20pTqJsNWJeejVf3XoZGb+R4hPZNTrQ23uFhHcvKRh22ZJYAAJ4a7z51tfmAApaENxiGwQdHLV23Hh8bx8vtxa7CZipcEeCNfwGbYcnTgGVSL28oZVJo9CYUCDCD1ZmqGnUI9lZgnAsb7rD6WwOWFzguKu8qu63bwVOTg3ldw+Zap3Dh/j8cEUDDHVaQNYNDSFvC1c0G7Ld25bydZwXklTIP3DssCgDwn5NXOR6N650RQMMdFrslnDqF2/fduVLM+eQEXt+X22MBtxBvS0CmyWCCRsfPgIQjZ0vqsTu7ElIJ8JeJiVwPxyVadQrn4B7pvUMFAIC5QyPdovQWy9Z0R6MHw4g7gUEulWLjoXy733v3UD7kUn6GgCYkBEEqAS5XaVBSp+V6OK3863gh9CYzRsYEYGRsANfDcSv8nK3ELR27UouzpfVQyaSYb90G5i6E3Cmc71vCZR5SW/BMyFlm3aHRG6EzmvHW7EHIXzkdExNdH/jpE2JptFPdZECVRtjb0+xh61em8nQ7OOtap3Bhbgk3mMw4XqgGIKwMSyFtCd91sQJGM4P+oT5IDvHhejg3YO8HtmaVol4rnM+1K34TUIYlbQlvG8MwyLBeI8b1YKMwH6UHVNbtvULNsnzrQC4A4K7BEUjg6X2lM/TnqI5lZaMOX2UWAwAWtlFnVazYgKXOaIZGz99t0c6g1hrsNv0CLIuUdTy9lvp7ym3XPz51CzeazPinNanqqfHx3A7GDVHAkvAGm11577AoW5aKu2AzFYRWw5JhGNuWcL4GLIFrdSzPCTRo0x1sDZuIFjVs3j7g+ho2XgqZrdSB2BrvqJsNtiDaDIEELLMrNdAZhXeDnllcjyaDCQGectvCA58FshmWzcIJFrDbwW/n2XZw1ogYf/QL9UGzwYxvfyvlejguYzSZcc5aa5nvDXcAarrTnkuVjbhap4VSJsXExJ4rbySRSFo03hHeQmFJnRZfnrEE05ZO7s3xaFzL1im8h3c/fHS8EDqjGSOi/THazbLEvBXXAvqVAg3od1SASm6rn3vD9zzl8FfZ/x4fXKtjyZ+A5YG8ajRZO63PHeoeTar4hNOA5YEDB3D77bcjMjISEokE27Zta/V9hmHw/PPPIyIiAp6enkhNTUVOTk6rY2pqanD//ffDz88PAQEBePTRR9HY2Prh+OzZs5g4cSJUKhViYmLw+uuvu/qtkU6q1ujxzW+WuhBPjHOfeiqsOIFmKlQ36dFg3XYUH8jfgKUty8zNMiy5rmHTL9QHwd4KlDcI78GpPfsuV8FkZtAnxJu3tVtZUf4q+KsstbKyK3u+VlZ3sfUrx8UFQsrjrfcstulOrUAyLPVGM/53sQIAMGsgv7aDsyQSCeaNiAYA/OeUeLuFX6rUQGs0w1cp422JlZbYDMviOq1bNETqjN2XLNmVExKC4NnDTWLYOpZCrNO38XA+DCYGExKCMLoHStdwid0S/nt5zy3oGkxmfHCkAIAlu9KdSm8BlmtJy23hYmYwm7G4jQzaxRMSYDBz0+ypI/hUx5Ltsp4U7I38ldOx+/Exomj8JTScBiw1Gg2GDh2KTZs22f3+66+/jnfffRcffPABjh8/Dm9vb8ycORNa7bWaBvfffz/Onz+P9PR07Ny5EwcOHMCCBQts36+vr0daWhri4uJw6tQpvPHGG1i7di0+/PBDl78/0nGbTxRBZzRjeJQ/RsYEcD2cHscGLEvqtTCY+HsRuR6bXRnpp+L1CdyWYelmncK5rmHz8q39kL9yOkbHBkJvNPO2yHdnsfUr+Z5dCVhu0K813hHe/D/CBiwFUL8SEF7TnYP51ajTGhHqo8CoWP4GCB4YHg2JBDiQV4P8amHtROgotn7l0Eg/QQTnw31VkEklMJoZlDXwq9YY1zKyqwBwc40QaoZlo85o23L5V5FnVwItOoVXNfbYff+2rDJcrdMi1EeBe4a5Z5bYtYClsH4/OstbIcPyaUlYlZpsy7QM8JTj+Rl9sHxaEq8bWE1MDIJEYtmdxWXCQ8su6/EvWXaobTtXxusu62LF6Wy95ZZbcMstt9j9HsMwePvtt7Fq1SrMmjULAPDZZ58hLCwM27Ztw7333osLFy5g165dOHHiBEaMGAEA2LhxI2699Va8+eabiIyMxBdffAG9Xo+PP/4YCoUCAwcORGZmJjZs2NAqsEm4YzYz+OfRAgCW7Ep3W/EDLDeYSpkUOqMZV9VawdTtyed5/UqWbVtslWVbrFLG3+CqM3Wkhg3bNdHZtAYTtmWVYeOhAqibDQjwlGPxhAQsn5bE6+B2R7D1K9MEELAELI13DhfUIktgjXcYhrFlWE4QQP1KoGUNS2Fkb2w/Xw4AuG1AGK+bR0UHeGJ6UjAycqrw2akirEnry/WQnC6z5FrAUgg8pBJE+atwpbYZhbXNiPL35HpIvKA3mvFLHncByxBbp3BhBWQ+/rUQ6mYDkoO9edf8yxViAjzho/RAo86Ey1UaW01LV3rPuoD92Jg4t7kPvl6IgDOQO+t8eQOGRwegaHUqmvQm+KvkMJjNvL8HD/JSYHC4H86W1uNAXjXu5mALtkZvxOv7crE+Pdv2NXaHGgAsm9qb10FfseFtDcv8/HyUlZUhNTXV9jV/f3+MHj0aR48eBQAcPXoUAQEBtmAlAKSmpkIqleL48eO2YyZNmgSF4lpNxJkzZ+LSpUuora21+9o6nQ719fWt/hDXycipRG51E/xVMvzJ2g3U3UilEkHWsbTVr+T59rUofxUCPOUwmRnR1VNsD1c1bK5tRc/hZCu6K+VWaZBX3QSZVIIpvYO5Hk6HsAF7oXUKL6hpRmm9DnIPiWA6MgZ5sl3C+Z9hyTAMfrTWr5zF0/qVLc2zNt/5z6mrouzwmlksnPqVLKpjeaNjV2rRqDMhxFuBoRE9H3wOsWVYCicgYzSZ8c5BSzDt6UmJgsgw7i6JRIIBoT13bf6tpA4H82sgk0rwxFj3K73FCva2/H6IfUs4AHx68irmfHICz+68gBAfJRQyqWCCbFzXseR6hxppjbefdlmZ5SY6LKz1KltYWJjte2VlZQgNDW31fZlMhqCgoFbH2PsZLV/jeq+88gr8/f1tf2Ji3KtjdU/774UKBHsr8OCIGHgrhXEidQV2W/gVAdWxZDuE8z0jVCKRYLBtW6ywgjbdwVUNGzFf6He36PzqqxLG+epap3Bhzf1DBZYb1eFR/j1eB66rAgXUJfxcaQOu1DZDJZMiNZn/wfc7B4XDR+mBvOomW+atWDAMY8uwFFTAUqD1t10pPcdyjUjtE8JJ4I3dEl4poAzLrVllyK9pQi8vua1erTsYYM2qPN8DncI3HioAANw1JMKts6F7uUkNS5OZwXfW3hC39At1cDT/TLKWAeKqjqVQu6yLlXCfGl1oxYoVqKurs/0pKhJvkXcuafRG6IxmLJmUiPyV07FqejLXQ+JUrLVpjZAClvkC6BDOGuSGdSy9FTIsmZjQ4zVsxHyhzxBQ/UoWWysrv6YJjTrhZLcezrfsghgnkO3ggLBqWO743bJoO6NPCLwEkHXhrZThj4MtW8M+PXmV49E4V5G6GTVNBsikElszDiGIoQzLG7DXCK4WAWxNdwSSYckwDP7+Sy4A4M/jEwRxLnKWAdZr8wUXN96p1ujx5WnLOXPhePuL2O4ixNs9toQfyq9GWYMOAZ5yQd2vsiZZG+9klTVwUm9UyF3WxYi3AcvwcMv2pPLy8lZfLy8vt30vPDwcFRUVrb5vNBpRU1PT6hh7P6Pla1xPqVTCz8+v1R/iXGwh24gXdqP3y5ZCtu8fKXDrQra2DEu1kLaEW7oOJ/B8SzgAW4al0LLMuuNsST3Gv3cYw6MDULpmBsrXpqFsTRqWTe3t0ho2Yr3QG01m7LlsqU2W1kc4K9bB3kqE+1qyboS0LZxtuDNeIA13gGtbwtXNBt53Tt6RZQlY3s7T7uD2sNlX3/5WgmYR3S+csW4HHxjuK6jacuyW8CIKWAIAapv0OFGkBsDdopbQmu4cLqjBr0VqKGVSPDUunuvh9Ch2ccLV1+VtWWXwUcpwU5QfxsXzt7laT2Cb7lSLPGC5JdOSXTl7UDgUMt6Ge9oU6qtE/1DL78fBvJ7fUVFc14yF4+Ptfo/vXdbFiLczOCEhAeHh4dizZ4/ta/X19Th+/DjGjh0LABg7dizUajVOnTplO2bv3r0wm80YPXq07ZgDBw7AYLiW7ZCeno6+ffsiMNC9T9pcuVbfLlt09e26w1YLSiAZlgaTGUV1ls6giUHeHI/GMbZTeFaZ+2RYrt19CRcrGrElsxhKmUeP1bDhaiu6q/1apEa91oggLzmGRwtn2yYADI4QVsBe3WywbZMbL6AMS3ZLOIA2s4z5oLS+GVqjGSE+Ctw+gP/1K1mTEnshLtAT9VojtmfZL+sjROx28GECabjDoi3hre29XAUzA/QP9UF0ADfbbq813RFGQGbD/jwAwIMp0Qj1dU0TQL4aGObaTuEavRF6oxnTk4ORv3I6vn4gxS0bm7YU7AZbwo0mM344VwoAmMtBwxpnYetY9vS28IKaJtz7+SksmpCA1TOE12VdjDgNWDY2NiIzMxOZmZkALI12MjMzUVhYCIlEgr/85S948cUXsWPHDpw7dw7z5s1DZGQkZs+eDQDo378/br75Zjz22GP49ddfcfjwYSxcuBD33nsvIiMtv6D33XcfFAoFHn30UZw/fx5btmzBO++8g6VLl3L0romY69t1R5zAbvyL1M0wmRmoZFJb9hafsdtii9RaXgcSnOXUVTW2ZZVBKgGen9GnR1/bWyHD8mlJeH5Gn1YX+tUzkgV9od99ybLVb3pSMK87KtszMFxYAfujBTVgGCAp2BthAji/sOQeUvhaazHztVO4Rm9EoKcC2x8ZhfznUuGjFE5Gn1QqwQMplizLbVmlHI/GeTKLrQFLAdWvBKjpzvXSsy0Z+KkcbsFsmWHJ9+ZUV2qu1aNdOjmR49H0vNhAS6dwg4nB5SqNU382u5Mt/IXdSLTuZPvidLFb72QDWmwJF0gGclfsz6tGRaMeQV5yTBdAfeq2TE7s+YClwWTGfV+cxomiOizeloVlU5JQtiatx3aoEfs4fWo8efIkpk6davs7G0ScP38+PvnkEzzzzDPQaDRYsGAB1Go1JkyYgF27dkGlUtn+zRdffIGFCxdi+vTpkEqluOuuu/Duu+/avu/v74/du3fjqaeeQkpKCoKDg/H8889jwYIFPfdGSSsdqW/Hdjl0J3HWGpaF6maYzQzvuySyHcITgrx4P1bAEjCLCVChSK1FVlk9JiT04npILvXCz9kAgPtuikJ/6yp+T1LJPbBsam88Nz0ZNU16+Kpk2GfdTi1UudUaBHsrMKOv8OoBCa1T+OECS/3K8QLcvhboKUeDzsjLOpbsQ+zGQ/lQNxsQ4CnH4gkJWD4tSTA34Y+OisGI6ACk9glGeYMOgZ5yGMxmwS6EAECzwYRgb4VgMyxrmgzQ6Ixu3TgRADJyuK9xzAZkjGYG6mYDAr0UnI2lLRq9EXKpFFKpBHnPTUdmcT36hfb8fQrXJBIJ+of64kSRGr+XNzjtXk2jN+L1fblYn55t+xq7kw0Alk3tLejzZXe4Q4blN9ZmO3cOjoDcQ7hJQJOtGZaZJfW2+xVXe/7nSzh2pRb+KhleubU/fKzXNDYuoeDv5mRR4/RsNWXKlHZX/yQSCdatW4d169a1eUxQUBC+/PLLdl9nyJAhOHjwYJfHSZzLXyVDgKfcbtBSyPXtuis6QAWpBNAZzaho1CHcT+X4H3HI1iFcAPUrWYPD/VCk1uJcaYOoA5a/FtZi54VyeEglWN3D2ZUtsTfEIT5KjH7nAE4X1+Pfc4fi4VGxnI2pK9iHq3U398MHfxwCrUF4W9qF1in8cL4l60ZIDXdYQV5yFFqbqPCJWB5iw31V+PhqER7ekinYoCtLozdCJpXiH38cilAfBYwmfmfEXc9PJYefSoZ6rRFFdc1uGXRi5VZpkFfdBJlUYssM4oJK7mH7P6nU6HkXsLS3aLJoQgJSov0F9/vrDAPDLAHL82WNuGuIc36mo51sz7lxk1M2YFljrTMttN0yjhhMZvxw1rL74B4BbwcHgAg/FZKDvZFTpcGh/Br8YYBr622nZ1fitb2XAQAf3T0U8QJ6vhU7ChOTHpVbpcHenCoqZGuH3EOKSGuQUgidwm0ZlgLoEM5yl07ha3++BAB4cHg0kkO47zjrIZXg7qFRAIB/HCngdjCd1HJbFdsgbOOhfMFtqxpgzdwwmhnU8nSrMstgMuPXIjbDUogBSwWCvRUw8exaJoZyLGwN7BczcgRfA9te88G3DuQJ7twitPrbrpJu7Q4+Lj4QvipuA/98bbzTVg379QL8/XWW/tbGOxcqnLeY2JGdbO6qlzVgyTD8LdvSHfsuV6G6yYAQbwWm9BZ+YgZbx3J/rmu3hZc36DDvqzMAgAVj4vBHgQd7xYb/d6dENKo1etz27+P464+/Y8nExBvq21Eh2xadwgVw419gzbBMFFDAkm08IpRtsV1xpKAGuy5VwkMqwaoZ/FlFf2RUDBQeUpy8WocThWquh9MhYmoQ5qOUYddjo5G/cjq0RjP0RjNvx3+muA7NBjOCvOToF8p9wL2zXrylL/JXTsewqABefc5ieIgVQ9AVENe5hepYWrDbwbmsX8lit4XzrfGOWH5/nWmgC8q1BKjkbW6fdeedbIAlOaR3Ly8MCvdFLc92QTjDFut28DlDIiAT8HZwVk/UsTSbGcz/6gzKG3QYFO6Lt2YNdNlrka4R/kwmgqAzmjDnkxPIrtSgSW+CmWGwbGpvKmR7HbaO5ZXaJo5H4lhetaVAuBA6hLPYbbHnyhp4X4y+q9ZYsysfGhmDxF78+b8J8VHinmGWFcv3j9h/YOEbMT1caQ0mHMqvQcz6DEStS0f4C7vxxr5cXmZzsU0YxsUFCaI+bktagwn/vVCBmPUZiFnPr89ZDA+xYgi6AuI6t8QIrGGgKxhNZuy9bHmgnpHMfcAylO0U3sCvDEux/P46E7v74VJlI4xO6hSuM5lpJ1sbNHojMv86GdsfGYW4IE9BLQ45ojease1cGQBhdwdvia1jebq4Dg1a5/1fafRG6K0l2HQmM54YF49hkX746oEUeLp5LIKPhHNHRATLbGbwyJbfcDC/Bn4qGX76v9EI8VHCWyGDQiZFiI8SCpnUrTMrWTECyrDME2CGZb9QH3hIJVA3G1Bcp+V6OE63P7cKe3KqIPeQYBUPaxQ9OS4eAPB1ZgmqBVDwXCwPV0LbRnsk37IdfFyCsBru8P1zbjaYBP8QK4agKyCecwtwLcOyyI0zLE9erbPVYxwRE8D1cGwNIviWYSmW319nig3whLfC2im82jmdwr8/W4JFExKwKjWZdrK1wJbhiFmfgd4v70HEC+m8WVB0hj05lahtNiDMV4lJHNbRdaaYAE8kBHnBZGZsi9nd1bLUU/ja3Yhal47TV9XY/+dxtoxnwi8UsCQu9/zPl/DVmWLIpBJ8P38EnQzaESeQWlDqZoOtoYSQmu4oZR7oG2LJOhRbHUuGYWzZlY+OikUcD/9fRscGYHiUP3RGMzafKOJ6OA6J5eFKSNlcDMPgkPWmVGj1K/n+OX9wtEDwD7EGsxmLJyTY/Z5Qgq6AeM4twLVO4Xy/b3Eltn7l9KRgXjTxCPVRIthbARnPEoV0RuEvmjibVCpBf2vpk9/LG7v988obdPjL9vOY/P4RPJASTTvZrMRUhqMtbHfwuwZH8OI85CyTEi33gvudsC28rXnwYkYO/r4/TxTzQIz485RCRKNlmrXWYMKImAD0C/XBh3cPxXQebJXhM7aGJd9rQeVbsytDvBXwUfL/IbelwWzjHZHVsdx3uRoH8mqg8JDytgOkRCKxZVl+cLQAZjO/t+UbzOLYViWkbK686iaUN+gg95DwIlOpM/j8OV+saMDqXZcw+f0jeHR0rGAfYr0VMiyflnRDDexVqcn42xRhdDkHgLIGrSjOLQDVsASAjGy2fmUwxyOxeGB4FPJXTseDKTG8qqP7wdErgl80cQVn1rFc+b+LqNca4a3wQFIvb9rJZsX3BcXu0hlN2JZl2Q7Oll8SCzZb9IATGu+IfR6IlfueuYhLsGnWGw/l27bHLBwfj6OLJsC/jWwCco1Qalja6lcKaDs4a1C4L7YAyBJRhiXDMNiw/zIAYMHYOERbHyD56E83RWLZzt+RV92Eny9V4Jb+YVwPqU37LldhkTWb673DBbZz2uIJCVg+LUkwQR42m8teMI1v2Vwnr6oxKNwXMf4qwdUR4uvnzDAMlm4/D6OZQe9eXrbrDLttVCGwtWuV3APLpvbGc9OTUac1WBpKXazAg1+ewffzR/C+7unh/Bos2noOPy8YA0DY5xag5ZZwLcxmhvefv7M1aI04esVSxiKtTyjHo7Hch3+VWYyNh/g1r44W1GD5fy9g84ki/Pf/RmNVah/UaQ3wV8lhMJsFNeedrb+1juWF8u4FLE9dVWPziUIAwDuzB7nd72J7OrKgyF4ThWj3pUrUaY2I9FMJbneKI2wdyxNFamh0Rnh3I1FG7PNArChgSZxGozfi9X25WJ+ebfsam2YtlUiwbKpwsh+4wmZYyj2kaNAa4MujQEJL+TWWTAo+NXXpqEHhlgzLLBFkWGr0RsilUlQ36bFl3gjsyanCmFh+1/3zUsjw0MgYvH0gD+8fKeBtwLKsXouHvs5EqI8SWx5MEfTDFbuNdl2LczOLzebiQ9BKozfijoHhGBUbiHBfJTR6o6CuGXz9nP97oQK7LlVC7iHBhjvE0f2SnRchPkrUaPR4ZEsm6rRGfHHmKh5MieF4dG07W1KP2z/+FepmA1bvuog3bh8o6HMLAET6qyCVAHqTGZUaPcJ83eth75fcKttiQALHi7jX7sNzbF9jt70C4Ow+vNlgwsNbMsEwwKiYAMQHCXvRxNkGWgOW57sRsGQYBku2ZYFhgPuHR2GcyIJW3cXXBUVn+da6HfyPQyNEF6hOCPJCtL8KWqMZZ0vrMbaLc9toMsNXKRP1PBAr975CEKeiNOvu81bKsPPRUchfOR0ag4lXW3laYjMshVS/kjU4wrqSXeG8joxcaFk0OmpdOmLWZ+DUVTX8VPwP8Dw5Ng4A8N+LFciv5l82McMwePL7s6hpMsBL7oF+oT6C3lbV3jbaZ3iykMTO56h16ej98h5ErRNeMfz2PmeutjvqjWYs3XEeALBkYiKSQ3x6fAyuFuStwPJpljIYq/93ibdz5nKVBjM/OgZ1swHj4wOx4Y6B8FUKv/mg3EOKCD8VAPesY5meUwUASO3Dfckjvt6Hr951EdmVGkT4KfHWLHEsmjiTrVN4habL96VfninGkYJaeCs88Opt/Z05PFEQS/1je7QGE7afLwcgnu7gLUkkEnw3fwTyV05HTIBnl56N86ubMPn9I9h9qVI05VjcCUWQiNPwuX6XUGgNJhy7UouY9RmIfCEd4S/s5uVDO1vDUogBy/hAL3grPKAzmpFT5ZyOjD2traLR69NzBFE8PDnEB2l9QsAwwD+PXeF6ODf48kwxtp8vh9xDgs33DoPcQ/iXSnYbLVu78OrqGbgpyh+PbMmEieNaomIqht/ycy5dk4ai1am4Kcrf1kiop71zMA85VRqE+SqxKpWftW2dYfHEBET5q1CobsamwwVcD+cGJXVapP3zKMobdBga6YcfHx0NLwEGJ9tyrY4l/xagXC39UgUAYAYPApZ8vA8/UlCDtw7kAQD++cehCPRS9PgY+C4u0BNecg/oTWbkdmERt1FnxLM7LwAAVkxPRpQ/f8sCcUUIC7ddtetSBRp0RsQEqHi/y6ortAYTfrpQjpj1GYh9MaPdZ+OWfTTYwOaO82UYtmE/jl6pxUt7srFs6o3zwN3r6PKd8J/CCG+IqeslF9iH9hczcnj/0J5nvaESYg1LqVSCQdYC5+dKhbktnK9ZFJ3BNt/59/ErvArIl9ZrsXhrFgBg9Yw+tiZNYuCtuJbNVafV4+Etmfjmt1K8d9j+XOopYpjPLbGfc5ivEm8fyMNdn57Ek9+dhc7YtXlu7wa8I8rqtXgxw7I19JVb+8NPxNdgT7kHXpjZFwDw8p6cNoM2PaXl/5nOaMbv5Q1QyT2QFOyNXY+NafNeSahiBdIw0NmK1M24VKmBVAJMS+K+4Q7f7sObDSY8Yt0KPi8lGn8YwM8SMFyTSiXoH8Z2Cu/8fekre3NQUq9FQpAXlk5KdPbwRKOthds3f8nlemjd8k2mdTv4kEjRbQe/tqDt+Nm45c6z8LW7Ef7Cbry29zLGxgUiyl+F8fGB+ObBEfBVylrNA6E1H3RHwnoKILzVpDfi2JUaSrPuBqE8tJvMDLyVHgj2ViBRgBmWADAowg/B3gpUNOq4HkqX8DGLorNu6x+KmAAVqpsM+PZsCdfDAXBtK3htswHDo/zx7NQkrofkMhF+nnj1Vsu2sZX/vYiCGu4yo8Qwn9uyeEIiwn2VyK1uwrsHOx8YtncD3tGs++f+exENOiNGxgRgXkp0V4YvKPNHxGBgmC9qmw14de9lzsZx/f9ZxAu7cSCvGgeeGo99T4wVZY3HGDbD0s22hKdbu4OPig3kRRCab9teV/3PshU80k9FW8Ed6Gody7xqDTbst2Swvnn7AAq6ONBy4fbk1Vrc9elJvLk/F/UCvc9o0hvx4++W7eBi6w4OOH42lkCCFT/9juzKRryyN+eGnTovZuRg46F8bHkwBfueHGern9tyHgi1HIs74UcEhAia3mjG3Z+dwhPfn8OiCQlYTWnWXSKEh3aN3gijmcH380cif+V09PIW5taepZMSkb9yOu4YGM7bOqHt4VsWRVfIPKR4fGw8AOAfR/ixLfyL08XYIbKt4O1ZMCYOkxKD0GQw4cnvz4JhuNka7q+SCX4+t8VXJcPL1sDwixk5KG/o+CJJd7bKnyhU45OTRQDcp1ush1SCV6y12949mIciDrL92vo/ezEjB+8dykeAl3DncntiAzwR7K2A+GdZaxnWgGVqMvfZlQC/6ugev1KLtw+yW8GH0FZwB9hO4b93siHk+t3Z0BnNmJ4cjNmDwl0xNNGamNAL/UJ90Kgz4T+nrnI9nC45lF8DT7kH4gM9MTImgOvhOJ2jZ+OKRh2OFNQiyl+FjYcK7B733uEC9A3xgUzk9/RiRv9zpFtMZgbzvz6D/12swJXaJhSqm/EMpVl3Cd+DUGzWSMQLu9H75T2IWZ+BN3/hX31NR7QGE77OLEbM+gzEv9R+LRS+qtcaRJHN/OioWMg9JDh2pRZnS+o4HUt5gxZLtlm2gj8vsq3gbZFKJfjw7qFQyqT4+VIlPj/d8zfs6mYDDuSJOzt/Xko0UqL90aAzYtWuix3+d13NujebGaz52fI6D6ZEY0yc+GpateW2/qGYlBgErdGMtbsv9fjrC2WnhLP9YUAY8ldOx5JJiYJcBOwKs5lBcZ0Wwd4KpPXlvn4lq+W217K11+roHu6BOrq2UggNOgyK8MX380di+bTeuI22gjs00Fqq6PfyRofHsp9zab0W7901GFsfGon35wyBROJuSwbdI5FIbOWJ3j9cwNmibVewc6B/qC/yV07HDw+NFOX/v6Nn43BfJe4ZFolqDf+TfkjXifPOifQIdvvklswSyD0k+H7+SKREB1CadRfxbStPS2JpitGZWih8pTOa8MT3Z7FoQgJWpSYLOps5zFeJJRMSsfWhkUgO8XFYo6+rtfza0vLn+Srl+Pc9w3DX4HBRbwW/Xp8QHzw/ow8A4Ont51HRiQzA7jKZGdz3+Sks2ZaFxRMTRVsEXSqV2LZDfvxrIc4Udyw4X9vc/g24+robcHY+lzXo8O38Edj+8Ei88YcB3Ru8wEgkErx6m+U9f3qiCOc7ma3UXULYKeFsWoMJm08UImZ9BhJe2iPIRcDO0uiNMJjN+ORPNyF/5XQMi/TnekitsPfhoT7X6uj+dcfvMLuwwVqrUggv7EbM+gycvqrG6hl9XfaaYsJuCa/S6NvtFN7yc45al275nIvViAlQ9dRQRWVeSjS8FR64UNGIX3KruR5Oh7ScA3EvZSBmfQa2ZpWJ8pzr6NnYxDD48/gEhPsqeZ30Q7qHApakSxiGwTM7L+BfxwshlQBf3DccN/cL5XpYgtbeVp5nOX5oF0vWiBjexzM7L+CHc2WY9fGvWDIxUfDZzGtm9sGpq2pErUtvt0Zfd2r52XP9z4ten47TV9X45E83ud22kb9N6Y2hkX6oaTLg6R3ne+x1V+26iF2XKnGltgkVjTpRF0GfkNAL9wyLBMMAT2/PcpjJUVLXDF+lR7s34N4KDzy9PQsFNZpW8zl6veUh9uRVNfxUwg72dsWYuEDcNTgCZgZY8dOFHn1tvu+UcDYxLAJ21rXdJumC2G3y5Lh4+KlkOFtaj+/OlrrkNdorhfCaSOeBs8UFemLHIyNxaflUVDXp7S7KtvU5r0/PEe3vm6v5e8rxgLXG8/uHC7gdTAe0PQfEec5t69n4+gVtPif9kO5zr6cy0i0ts5G0RjPGJwShX6gPPrx7KP44VHyFfrnQ1laeT08UcTousWSNCP19bMsqtQVcV6b2QS9vhaCzmTV6I17fl4sXM+w/7DbojChv0KGyUWe3mHZXH4rbe7h6Y1+u6G74HJF7SPHR3UMhlQBfnSnGT9YC7q60JbMYr1kbo/xr7jAMCPMVfXb+a7f1h0omxYG8Gvxwru3AwdmSeox+9xDSs6va3Cq/cHw80rOr8M7BfPxW0oCX99z4++HOD7Ev3doPHlIJdl4ox9F812+FBYAGrfs1HxTDImBnCHG3SZCXAk9bO0ev3X0JJhdkWbrbPHAFvcmMXwvViFmfgcgX0m9YlDWbGcjoc3aJp6zbwredL8NVDmofd4Y7/q5d393d3oJ2RwObRJjEN6uJS1yfjRS1zpKNdGzxBDwyKpbr4YlKy608uy5W4K5PT+JvP/7O2UX0ZJEaPgpxNMUQcvZLQU0THtnyGwDgr5PFURPK0Y2XVAJMef8wvBQebRbT7soNmjve8DkyIiYAT0/qjX6hPpBJJU7den+930rq8MiWTADAsim98aebopz68/kqNtALf5vSGwCw7Mff7WZk7cmpxKT3D6O4Tot/HbuC5dOS7d6APzc9GbEBKjwwPAqpfYLxXhuZIe46n/uE+GB1ajK2PjQSQ6P8XTaXWepmA2Z+dMztmg8KfRGws4R67fjLxEQEeclxsaIRX55xfq1id5sHzsYGwu0t3r68JwcZ2ZUY/c5BlNRr6XN2gUERfpiUGASTmcGHx/jRBLItagelYsQ6BzqyoN2RwCYRJn5eWUmPclQXrr1spA3783i5oiwWcwZHYHx8IJoMJix34dY2e3Mgu7IRszf/ilHvHER6dqUoskba2zKwcHw8tEZ+bukymMz40+enoG42YHRsAF6+tR/XQ3IKRw85lY16DAjzRWWj3qk3aO56w+fIupl9cOCp8ThcUOO0rffXq9boMHvzCTQbzJjZN8TWQdtdPDM1CZF+KhTUNuOtA3mtvvefU0W45aPjqNcaMTmxFz677yZ4Kdq+AR8eHYDP7huOBp2R5rMdy6Ym4dRVNaLXt19uoruqNXqkfnAUx67UorxBh4pGnds0HxTyImBXOKory9ffNX9PuW2x5IXd2TC0UyOxSz/fzeaBs7UXCH/vcAHGxgeiUW9EqI+CPmcXYZvvfHS8EHojP59pzpbUwdtBqRh3nwNi36njrihg6ebaqwvXqDPgYF41pBKJIFeUxUAikeCd2YMgkQBfninGYRdsbbM3B17bexmBnnJkV2oglQAnimrbzPQRUtZIe3VCF01IwNId53lZh+q5/17E8UI1Ajzl+OqBFMhFUmPR0cNuhJ8K38wbgUg/lcNafieL1A5fz2gy4/NTRXTD1wYzgI2H8trcom9vMasjmZgtj/OUy/DWrEFI6xOML+8fDg+p+LpatsdHKcMrt/VDv1AfDI7whc76uTQbTPBVypEU7I17h0Vi14LRCPRSAHB8Ax7kSQ+x19PojXi1jYwlZ27drWjQYdoHR3C6uA4h3grsfXIsBob7uc1DU3uLgIsEtJjZESeL1PAR8LVj0fgEhPookFfdhE9POq/MUHZlI3653Hb5CiEtanPF0eJtg9aI3Y+PAcOA6vS5yJ2DIhDuq0R5g67dki1cMJrMWJ+ejRFvH0RGO6ViaA4QsRLnHRTpELZ+3Pr0bNvX2Bt6M8NgeHQAnt91EdsfGeVwRTnER9lTw3Y7w6MD8MioWPz7eCGWbMvC8SUTnfaQ39YceDEjBwDw77lDEeglR79QS/fCZVN747npyajTGuCvksNgNgsua4TdMtDyfVRqdLjlo2M4XVyPykY9vps/gtOgoEZvhFwqhVprgJ9ShvEJQfjpQjlevrUf4oO8OBuXs7EPu+tazD/W4gkJMJrNUMpk0BpNbR63cHw8dmdX4a5PT+D/Rsfitdv6Q+4htX1+AdZ5+uuVWizaloXfyxuxVSnHwvHxtnl+/esazGYo3HA9z5LlUWD3e+8eyseK6cm2v7MLHRsP5UPdbECApxyLJyRg+bSkVucEe8ctHB+PHx4aCS+RBnEcuf+maNzaPwzvHMjDvK8yW30uRxdNgK9SBmknzvGOfo/ccT472rr7XIu53Bktz83+Kjl+K62HwcQg3FeJjMfHYkC4b3eGLTjsIiBg+VxbzuWF4+NR3qBDYi9h/54zDIN3D+XjmZ2/45sHRwj22uGtlGH5tGQs3XEe69Oz8WBKNJSy7t2//VZSh5kfHkOQlwIHnxoPqUTSah7YuyaQG7GLt/aetQI85QjystQrB2D3940+5+5TyKR4bEwc1qdn4/0jBbiXo1I1La8xASo56rQGLPrhHL6xNsz6JbcKL9/an37XiFsR9l0E6RZHWxCKVqfivUMKhPko272Q8nlFWSxeurkfvvutBKeL6/Dxr4V4bExch/7d9Rc+g9ncKtPD0RxYldrHdpMEwPZv2QA1X2/MHbn+fUT5e+L1PwzEbf8+jh9/L8eDX57BFxxlf7UV4DmyaEKbmR1C1dbD7vU3Xu0d9+y0JKxPvwSGAQ7m1cBoZvDWgcvYeKig1ee3aEICzAwQ5GU5l62Ynkw3fNdxlOVRWq/F0u3nsWpGMrafL8P69JxW32cDZsum9oa3QtbugohUIrEd526ajSa8ezCvVdCjO59LR3+P3ImjuVzeqENedRMmJATBQypxeK0E2j43H3hqPBp1BsQHeffEW+Mde4uARwpqMPn9I5AAOLZ4InwF0q3++nnQbDBh7e5LeOeg5T5pf24VXhJwsOCJsXF485dcFKm1+NfxQjw13n62Xkccu1KLW/91HOpmAyL9VADEsajNhc4sOtn7faPP2TkWjInFy3tycCi/BmdL6jEk0q9HX7+ta8zGOYNRoG7G4gkJ+NNNUZBY7xNoDhB3IWEYxvnt4kSmvr4e/v7+qKurg59fz568XKmiUYfwtbvb/H7Z2jSE+iih0Rvxxr5cuxfS52f0cduHzp729oE8LN1xHsHeCmQvn+YweKU1mPDK3st2M6AuVjRgW1Y55o+MQe+X97T5M8rXprlV9ux/L5Tjzk9OwGBiMH9ENP49d1inMp26y16AhyXm3zX2IbHljZe999necQdyq6E3m3Egt9pu9suq1GTMGRKB+EAv2+9OR1/XXeiNZoS/sLvNxami1akY8dYBnHx6EmLWZ7R73Mx/HsXPj49t97iyNWmtFkTchaPPuaufC83nazoylxNe2oNB4b7Y+vBIbNif1262cKPOiDd+cb9zc1eVN+iQ8tYBlNRrcfeQCHz9YAokEn6Xf7B3z8QudqX+8ygeHRWLRRMSIJFIBP279o8jBXjqh3OI8FPi8orp8OxCkGNvThVmbf4VGr0J4+IDsfPR0aJbUO1pWoMJr+69LMhAuJjM/ewkvjtbigVj4vDBH4f02Ou2d/+/KjUZSyYmope3osfGQ4irdSa+5n5PCsTGUf24AGvmZFt1/4RWv1Donhofj/6hPqjS6PHC7kvtHttWoyS242BBrRbvHymgAt7XubV/GL56IAUeUgmOF6pxprjOpd2SryfUDqTd1dF6b+0dN6l3L0xK6NVmt+T3DhdgQKhvq/nuLnXmOqq9enSLJyTAYDLj3TsHoabJcbOkMF8VKpzcLEksXNVRl+bzNY7mcnaFBgzDYMnERPzdGoi0d6385XIVbtrwCyQSuOW5uavCfJX4dl4K5B4SfHu2FBv25zn+Rxxqr7nkxkP5+N//jcHiiYm2oKuQf9ceHRWLuEBPlNbr8I8jBR36Ny3rEGsNJjTqjYgJ8ERqcjB+fmwMBSudgDoc88Ofrc13vjh9FXVtXKddwdGON1+lcM4xhDgb3WG5MYcPpy0K99KFlHtyDynemjUQALDpcAEulDe0fayDC9+MPsG4d1gk1E0GKuB9nTmDI7D1oRHY/+dx2H6+zGXdku1xVSDDXdDn1z2OFqcCPBWY0SfUVibEHkuzJCVeuqW/w2ZJ7rYgwnK3zspccDSXb4r2x9XnZ2Bm35B2FzlGxgbATymn4HsXjI0PwoY7LPcsy/97Ab9cruJ4RG1zdM8ULKLMJoVMitUz+gAAXt17GY269hdir2/MGLkuHSeL1Di8cDx+fGQUvCmQ4jRCDoSLxeTevTAwzBcavcmpzanaa1KYU9mI8kYdXWMIaQMFLN1YZzMn6ULKvbS+obhjYBiSgr1R3aS3e/EzmMyobmr/4UqjN+HdOwcjKsCTsmftmJoUjPcO57u8w2xLZ0vq4KOQUSCjGygQ1H0dWZxytNhlNDPoF+YDYycWxdxJZxYLSdc5mstKmQfqdcZ2r5X1WiM2zRlMwfcu+vO4eDyYEg2TmcG9n5/CVXUz10Oyq7bZvRa75qVEY2bfEHx091B4SCVt7iJpL/P0nYP5MFJVMSIyEokET1qzLL8+UwxnVM67PujPJkBo9EYs3noO4987jCAvun8lpC3uGY0gNlS8WXjenT0InnIPbDyUjzs+PmGrdbNoQgKenpSI+z4/hW/nj2i3UVJAiwsfzYEbOeqW7IwOs2xjB53BjBX/u4B/HS/ED/NHCrYDKR9Qt2TncNRcyxnNkty5Lhd9Lj3H0Vx21J23l5cCEX4qy4MlnVs6TSKR4B93DcbZ0nrojGZcrtIg1EfZbnMjV2irqVJNkx6bDhdg6eREt2ouKfOQ4pt5I/DGvst4eEtmq3PQM1OTcCCvGievqrF0Uu92SyF09V6IED6bPyIacYGemJLUC2UNOvTyUjisrd7WOa2t5oPr0rNhZhhMSw7BpiMFOFdaT9cYQtpAAUsims7P7qKXtwKv7bt8Q4fZ9enZYBgGC8bG40BuNRZNiG/VxZdl78JHc6A1R1uLKzU6GE0M4oK8ADi+YQHsd/9bNCEei8Yn4GBeDRgGOJxfg7Uz+wq2AynXKBDUczq60EELIvbR58IPHV3koHNL13kpZNj+8Eh4yT3w7qF8zPn0pMPPryPX1I4eZ+/au3hCAp6enIibPzqGk0V1GBLh51aLhRq9EW/+knvDfSQbRBkeHYBvMktw//Boh5mn7tSYkbgHSx37Wjz41Zl2z1VtnVvY44wmM2QOyk1cXT0Dv/9tKvqG+WBYpD8AusYQcj3qEt4BYu0SToTJUffTkjUzIJNIYDQz1HGwizraYXbO4HC8eftAvPFL2zcsgOPuf5N794LCQ4qJib1sxwu1Aykf0OdHCOmoznTnpXNL11iugZftLqJe32XdXrfutoIFjo5zdO0dHh2AtT9fwtuzBmJMXKDb3DM5use5unoGXtubgxXTkxG5Lr3N48rWpEEhE08gl5D2zhmrZyTjnmFR2H2pEjP7huDrzGK757RVqckYFx+I5T9dwNaHR6H3y3vafL3ytWmtgv50jSHuojPxNbcKWG7atAlvvPEGysrKMHToUGzcuBGjRo1y+O8oYEn4pKJRh/C1u9v8fsuLH134ukajN+KNfbl2s25Wz+iDtD7BmPT+EfwwfyROXVXbzcpYPaMP7rspCtuzyrBoYgKi6KafEEJ4ia6VruUoQFb8/Ax8faYYqcnB+NevRXaDBWxg00vugUa9CW/+0lZQoQ/mpUTj2JVa3DUkot2AW8nzM6DwkEIqtXT/dpd50NH7yPbuha4PNBMiBh1JWBjx1gGcfHoSYtZndPs4uv8n7qoz8TW3+Q3ZsmULli5dijVr1uD06dMYOnQoZs6ciYqKCq6HRkindKaxCDVK6pr2GlKtmJaE8Qm9kLN8GtLa6TC78VA+ogNU+OlCOcoaqPsfIYTwFV0rXctRmZXyBh0+OVGEIG9FuzUTAWDwm79AKkGbx208lI9wPyU+PHYFpQ6uvQ06oy1YCbjPPOjofWRnm3MSInSOzlW1TQYsGBuHmqb2j2vUmXDgqfEAA2qyR0g3uc2VZsOGDXjsscfw8MMPAwA++OAD/PTTT/j444+xfPlyjkdHSMdRY5Ge4ajGXGIvb1Q0tv8wVNNkwO0DwhHuq3Srgv6EEEIIy1FzozBfJcbFB6KqUd9+/ehGPfqG+KDCwXE1TQaMjw9EmA9de+3pzH0k1dsl7sTRuSrUR4mnJ/WG3mhu97hAT7ktc5LqHxPSPW4R1dDr9Th16hRSU1NtX5NKpUhNTcXRo0dvOF6n06G+vr7VH0L4gla8e46jbAtHWQphPkr8bWpvmBmGVlgJIYS4JTZAZs/iCQkwMwxeuW0AIvxU7V5TI/xUeP+uwYhycFyYjxIv3zYADOjaa09n7yPdJfOUEEfnKvac0dHjgGtB/7I1aShfm4ayNWlYNrU3BSsJ6SC3uOJUVVXBZDIhLCys1dfDwsJw8eLFG45/5ZVX8MILL/TU8AjpNFrx5gfqMEsIIYS0r6PXQEfXVKPZjDBfFTR6I117u4nuIwm5UUfPGZ09t7BBfrbHAO2EI6Tj3KLpTklJCaKionDkyBGMHTvW9vVnnnkG+/fvx/Hjx1sdr9PpoNPpbH+vr69HTEwMNd0hhNyAOswSQgghjnXkGtjRaypdewkhrtLRcwadWwjpGuoSfh29Xg8vLy989913mD17tu3r8+fPh1qtxvbt29v999QlnBDSHrphIYQQQpyDggWEEEKIeFGX8OsoFAqkpKRgz549tq+ZzWbs2bOnVcYlIYR0BdV3IoQQQpyjo9dUuvYSQggh4uY2V/alS5di/vz5GDFiBEaNGoW3334bGo3G1jWcEEIIIYQQQgghhBDCPbcJWN5zzz2orKzE888/j7KyMgwbNgy7du26oREPIYQQQgghhBBCCCGEO25Rw7K7qIYlIYQQQgghhBBCCCFdRzUsCSGEEEIIIYQQQgghgkQBS0IIIYQQQgghhBBCCG9QwJIQQgghhBBCCCGEEMIbFLAkhBBCCCGEEEIIIYTwhtt0Ce8Oti9RfX09xyMhhBBCCCGEEEIIIUR42LhaR/p/U8CyAxoaGgAAMTExHI+EEEIIIYQQQgghhBDhamhogL+/f7vHSJiOhDXdnNlsRklJCXx9fSGRSLgejkvU19cjJiYGRUVFDlvLE9IRNKeIK9C8Iq5A84o4G80p4go0r4gr0LwizkZzirSHYRg0NDQgMjISUmn7VSopw7IDpFIpoqOjuR5Gj/Dz86OTCnEqmlPEFWheEVegeUWcjeYUcQWaV8QVaF4RZ6M5RdriKLOSRU13CCGEEEIIIYQQQgghvEEBS0IIIYQQQgghhBBCCG9QwJIAAJRKJdasWQOlUsn1UIhI0JwirkDzirgCzSvibDSniCvQvCKuQPOKOBvNKeIs1HSHEEIIIYQQQgghhBDCG5RhSQghhBBCCCGEEEII4Q0KWBJCCCGEEEIIIYQQQniDApaEEEIIIYQQQgghhBDeoIAlIYQQQgghhBBCCCGENyhgSQghhBBCCCGEEEII4Q0KWIrIgQMHcPvttyMyMhISiQTbtm1r9f3GxkYsXLgQ0dHR8PT0xIABA/DBBx/Yvl9TU4NFixahb9++8PT0RGxsLBYvXoy6urpWP2fx4sVISUmBUqnEsGHDeuCdEa50d04BwOOPP47evXvD09MTISEhmDVrFi5evHjDa33yyScYMmQIVCoVQkND8dRTT7nyrREOOWNeTZkyBRKJpNWfJ554otUxdK5yH86YUwBw9OhRTJs2Dd7e3vDz88OkSZPQ3Nzc6piffvoJo0ePhqenJwIDAzF79mwXvjPCJWfMq7KyMjz44IMIDw+Ht7c3hg8fju+//77VMS+99BLGjRsHLy8vBAQEuPhdEa45Y17l5ubizjvvREhICPz8/DB37lyUl5ff8Fp0vnIPjuZUeXk5HnroIURGRsLLyws333wzcnJyWh3z4YcfYsqUKfDz84NEIoFarb7hdehc5V66O686GlsA6DmQtI0CliKi0WgwdOhQbNq0ye73ly5dil27duHzzz/HhQsX8Je//AULFy7Ejh07AAAlJSUoKSnBm2++iaysLHzyySfYtWsXHn300Rt+1iOPPIJ77rnHpe+HcK+7cwoAUlJSsHnzZly4cAE///wzGIZBWloaTCaT7ZgNGzZg5cqVWL58Oc6fP4+MjAzMnDnT5e+PcMMZ8woAHnvsMZSWltr+vP766zf8LDpXuQdnzKmjR4/i5ptvRlpaGn799VecOHECCxcuhFR67Vbp+++/x4MPPoiHH34Yv/32Gw4fPoz77rvP5e+PcMMZ82revHm4dOkSduzYgXPnzmHOnDmYO3cuzpw5YztGr9fj7rvvxpNPPuny90S41915pdFokJaWBolEgr179+Lw4cPQ6/W4/fbbYTabbT+Hzlfuo705xTAMZs+ejby8PGzfvh1nzpxBXFwcUlNTodFobMc1NTXh5ptvxnPPPdfm69C5yr10d151NLZAz4GkXQwRJQDM1q1bW31t4MCBzLp161p9bfjw4czKlSvb/DnffPMNo1AoGIPBcMP31qxZwwwdOtQZwyUC4Kw59dtvvzEAmMuXLzMMwzA1NTWMp6cnk5GR4fQxE/7r6ryaPHkys2TJkg69Bp2r3EtX59To0aOZVatWtflzDQYDExUVxfzrX/9y6niJMHR1Xnl7ezOfffZZq2OCgoKYjz766IbX2Lx5M+Pv7++0MRP+68q8+vnnnxmpVMrU1dXZvq9WqxmJRMKkp6czDEPnK3d2/Zy6dOkSA4DJysqyfc1kMjEhISF2z0P79u1jADC1tbVtvgadq9xPd+cV6/rYAj0HEkcow9KNjBs3Djt27EBxcTEYhsG+ffuQnZ2NtLS0Nv9NXV0d/Pz8IJPJenCkRCg6O6c0Gg02b96MhIQExMTEAADS09NhNptRXFyM/v37Izo6GnPnzkVRUVFPvhXCIx2dV1988QWCg4MxaNAgrFixAk1NTRyNmPCdozlVUVGB48ePIzQ0FOPGjUNYWBgmT56MQ4cO2X7G6dOnUVxcDKlUiptuugkRERG45ZZbkJWVxdXbIhzryLlq3Lhx2LJlC2pqamA2m/H1119Dq9ViypQp3A2c8JqjeaXT6SCRSKBUKm3/RqVSQSqV2s5ZdL4iLJ1OB8AyR1hSqRRKpbLVNY6QzujqvLo+tkDPgcQRCli6kY0bN2LAgAGIjo6GQqHAzTffjE2bNmHSpEl2j6+qqsL69euxYMGCHh4pEYqOzqn3338fPj4+8PHxwf/+9z+kp6dDoVAAAPLy8mA2m/Hyyy/j7bffxnfffYeamhrMmDEDer2ei7dFONaReXXffffh888/x759+7BixQr85z//wQMPPMDhqAmfOZpTeXl5AIC1a9fisccew65duzB8+HBMnz7dVo+p5TGrVq3Czp07ERgYiClTpqCmpoabN0Y41ZFz1TfffAODwYBevXpBqVTi8ccfx9atW5GUlMThyAmfOZpXY8aMgbe3N5599lk0NTVBo9Hgb3/7G0wmE0pLSwHQ+Ypc069fP8TGxmLFihWora2FXq/Ha6+9hqtXr9rmCyGd1ZV5ZS+2QM+BxBEKWLqRjRs34tixY9ixYwdOnTqFv//973jqqaeQkZFxw7H19fW47bbbMGDAAKxdu7bnB0sEoaNz6v7778eZM2ewf/9+9OnTB3PnzoVWqwUAmM1mGAwGvPvuu5g5cybGjBmDr776Cjk5Odi3bx8Xb4twrCPzasGCBZg5cyYGDx6M+++/H5999hm2bt2K3NxcDkdO+MrRnGLrvj3++ON4+OGHcdNNN+Gtt95C37598fHHH7c6ZuXKlbjrrrts9XklEgm+/fZbbt4Y4VRHzlWrV6+GWq1GRkYGTp48iaVLl2Lu3Lk4d+4chyMnfOZoXoWEhODbb7/Fjz/+CB8fH/j7+0OtVmP48OG2mrt0viIsuVyOH374AdnZ2QgKCoKXlxf27duHW265pVWNZkI6o7Pzqq3YAj0HEkdon6+baG5uxnPPPYetW7fitttuAwAMGTIEmZmZePPNN5Gammo7tqGhATfffDN8fX2xdetWyOVyroZNeKwzc8rf3x/+/v5ITk7GmDFjEBgYiK1bt+JPf/oTIiIiAAADBgywHR8SEoLg4GAUFhb27JsinOvMvGpp9OjRAIDLly+jd+/ePTZewn8dmVP2zkMA0L9/f9t5yN4xSqUSiYmJdK5yQx2ZV7m5uXjvvfeQlZWFgQMHAgCGDh2KgwcPYtOmTXY71RP31tFrYFpaGnJzc1FVVQWZTIaAgACEh4cjMTERAJ2vSGspKSnIzMxEXV0d9Ho9QkJCMHr0aIwYMYLroREB6+i8ai+2QM+BxBFaVnETBoMBBoPhhhUPDw+PVh0F6+vrkZaWBoVCgR07drSqS0FISx2dU9djGAYMw9hqn4wfPx4AcOnSJdsxNTU1qKqqQlxcnAtGTvisq/MqMzMTwLUbH0JYHZlT8fHxiIyMbHUeAoDs7GzbeSglJQVKpbLVMQaDAQUFBXSuckMdmVdsXd3Ons+I++rsNTA4OBgBAQHYu3cvKioqcMcddwCg8xWxz9/fHyEhIcjJycHJkycxa9YsrodERKC9eeUotkDPgcQRyrAUkcbGRly+fNn29/z8fGRmZiIoKAixsbGYPHkyli1bBk9PT8TFxWH//v347LPPsGHDBgDXTihNTU34/PPPUV9fj/r6egCWlQ4PDw8AlgymxsZGlJWVobm52RYoGDBggK0uIRGH7s6pvLw8bNmyBWlpaQgJCcHVq1fx6quvwtPTE7feeisAoE+fPpg1axaWLFmCDz/8EH5+flixYgX69euHqVOncvK+iWt1d17l5ubiyy+/xK233opevXrh7NmzePrppzFp0iQMGTLE9nPpXOU+ujunJBIJli1bhjVr1mDo0KEYNmwYPv30U1y8eBHfffcdAMDPzw9PPPEE1qxZg5iYGMTFxeGNN94AANx99909/6aJy3V3XvXr1w9JSUl4/PHH8eabb6JXr17Ytm0b0tPTsXPnTtvPLSwsRE1NDQoLC2EymWznqqSkJPj4+PToeyau1915BQCbN29G//79ERISgqNHj2LJkiV4+umn0bdvXwB0vnI3jubUt99+i5CQEMTGxuLcuXNYsmQJZs+e3apBWFlZGcrKymw/59y5c/D19UVsbCyCgoIA0LnK3XR3XnUktkDPgcQh7hqUE2fbt28fA+CGP/Pnz2cYhmFKS0uZhx56iImMjGRUKhXTt29f5u9//ztjNpvb/fcAmPz8fNvrTJ482eExRBy6O6eKi4uZW265hQkNDWXkcjkTHR3N3HfffczFixdbvU5dXR3zyCOPMAEBAUxQUBBz5513MoWFhT39dkkP6e68KiwsZCZNmsQEBQUxSqWSSUpKYpYtW8bU1dW1eh06V7mP7s4p1iuvvMJER0czXl5ezNixY5mDBw+2+r5er2f++te/MqGhoYyvry+TmprKZGVl9dTbJD3MGfMqOzubmTNnDhMaGsp4eXkxQ4YMYT777LNWrzN//ny7r7Nv374efLekpzhjXj377LNMWFgYI5fLmeTkZLvnMzpfuQ9Hc+qdd95hoqOjGblczsTGxjKrVq1idDpdq5+xZs0auz9j8+bNtmPoXOVeujuvOhpboOdA0h4JwzBMlyKdhBBCCCGEEEIIIYQQ4mRUw5IQQgghhBBCCCGEEMIbFLAkhBBCCCGEEEIIIYTwBgUsCSGEEEIIIYQQQgghvEEBS0IIIYQQQgghhBBCCG9QwJIQQgghhBBCCCGEEMIbFLAkhBBCCCGEEEIIIYTwBgUsCSGEEEIIIYQQQgghvEEBS0IIIYQQQgghhBBCCG9QwJIQQgghhBBCCCGEEMIbFLAkhBBCCCGEEEIIIYTwBgUsCSGEEEIIIYQQQgghvPH/doyoo3fA5yoAAAAASUVORK5CYII=" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 16 - }, - { - "cell_type": "markdown", "source": [ - "### CardanoSentiment\n", + "from aeon.datasets import load_lynx\n", "\n", - "By combining historical sentiment data for Cardano cryptocurrency, extracted from\n", - " EODHistoricalData and made available on Kaggle, with historical price data for the\n", - " same cryptocurrency, extracted from CryptoDataDownload, we created the\n", - " CardanoSentiment dataset, with 107 instances. The predictors are hourly close price\n", - " (in USD) and traded volume during a day, resulting in 2-dimensional time series of\n", - " length 24. The response variable is the normalized sentiment score on the day\n", - " spanned by the timepoints." + "lynx = load_lynx(return_array=False)\n", + "plot_series(lynx)" ], "metadata": { "collapsed": false } }, { - "cell_type": "code", + "cell_type": "markdown", "source": [ - "from aeon.datasets import load_cardano_sentiment\n", + "### PBS_dataset\n", "\n", - "cardano, cardano_target = load_cardano_sentiment()\n", - "print(cardano.shape)\n", - "plt.title(\"Response variable for cardano data\")\n", - "plt.plot(cardano_target)" + "The Pharmaceutical Benefits Scheme (PBS) is the Australian government drugs\n", + " subsidy scheme. Data comprises of the numbers of scripts sold each month for immune sera\n", + " and immunoglobulin products in Australia. The load function returns a numpy array\n", + " or a pd.Series." ], "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-09-25T22:58:22.582032Z", - "start_time": "2024-09-25T22:58:22.410134Z" - } - }, + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 23, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(107, 2, 24)\n" - ] - }, { "data": { - "text/plain": [ - "[]" - ] + "text/plain": "(
, )" }, - "execution_count": 17, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" }, { "data": { - "text/plain": [ - "
" - ], - "image/png": "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" + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 17 - }, - { - "cell_type": "markdown", "source": [ - "## Segmentation\n", + "from aeon.datasets import load_PBS_dataset\n", "\n", - "Two of the UCR classification data have been adapted for segmentation." + "pbs = load_PBS_dataset(return_array=False)\n", + "plot_series(pbs)" ], "metadata": { "collapsed": false @@ -1189,14 +1054,10 @@ { "cell_type": "markdown", "source": [ - "### ElectricDevices\n", - "\n", - "The UCR ElectricDevices dataset series are grouped by class label and concatenated to create\n", - " segments with repeating temporal patterns and characteristics. The location at which\n", - " different classes were concatenated are marked as change points.\n", + "### ShampooSales\n", "\n", - "this function returns a single series, the period length as an integer and the\n", - "change points as a numpy array." + "ShampooSales contains a single monthly time series of the number of sales of\n", + "shampoo over a three year period. The units are a sales count." ], "metadata": { "collapsed": false @@ -1204,64 +1065,45 @@ }, { "cell_type": "code", - "source": [ - "from aeon.datasets import load_electric_devices_segmentation\n", - "\n", - "data, period, change_points = load_electric_devices_segmentation()\n", - "print(\" Period = \", period)\n", - "print(\" Change points = \", change_points)\n", - "plot_series(data)" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-09-25T22:58:22.990281Z", - "start_time": "2024-09-25T22:58:22.610956Z" - } - }, + "execution_count": 24, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Period = 10\n", - " Change points = [1090 4436 5712 7923]\n" - ] - }, { "data": { - "text/plain": [ - "(
, )" - ] + "text/plain": "(
, )" }, - "execution_count": 18, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" }, { "data": { - "text/plain": [ - "
" - ], - "image/png": "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" + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 18 + "source": [ + "from aeon.datasets import load_shampoo_sales\n", + "\n", + "shampoo = load_shampoo_sales(return_array=False)\n", + "plot_series(shampoo)" + ], + "metadata": { + "collapsed": false + } }, { "cell_type": "markdown", "source": [ - "### GunPoint Segmentation\n", "\n", - "The UCR GunPoint dataset series are grouped by class label and concatenated to create\n", - " segments with repeating temporal patterns and characteristics. The location at which\n", - " different classes were concatenated are marked as change points.\n", + "### UsChange\n", "\n", - "this function returns a single series, the period length as an integer and the\n", - "change points as a numpy array." + "Load MTS dataset for forecasting Growth rates of personal consumption and income. The\n", + " data is quarterly for 188 quarters and contains time series for\n", + " Consumption, Income, Production, Savings and Unemployment. It either a numpy array or\n", + " a pd.DataFrame." ], "metadata": { "collapsed": false @@ -1269,56 +1111,68 @@ }, { "cell_type": "code", - "source": [ - "from aeon.datasets import load_gun_point_segmentation\n", - "\n", - "data, period, change_points = load_gun_point_segmentation()\n", - "print(\" Period = \", period)\n", - "print(\" Change points = \", change_points)\n", - "plot_series(data)" - ], - "metadata": { - "collapsed": false, - "ExecuteTime": { - "end_time": "2024-09-25T22:58:23.230150Z", - "start_time": "2024-09-25T22:58:23.046130Z" - } - }, + "execution_count": 20, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - " Period = 10\n", - " Change points = [900]\n" + "\n" ] }, { "data": { - "text/plain": [ - "(
, )" - ] + "text/plain": "(
, )" }, - "execution_count": 19, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" }, { "data": { - "text/plain": [ - "
" - ], - "image/png": "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" + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 19 + "source": [ + "from aeon.datasets import load_uschange\n", + "\n", + "data = load_uschange(return_array=False)\n", + "consumption = data[\"Consumption\"]\n", + "plot_series(consumption)" + ], + "metadata": { + "collapsed": false + } }, { "cell_type": "markdown", - "source": [], + "source": [ + "### Solar\n", + "Example national solar data\n", + " for the GB eletricity network extracted from the Sheffield Solar PV_Live API.\n", + " Note that these are estimates of the true solar\n", + " generation, since the true values are \"behind the meter\" and essentially\n", + " unknown. The returned data is half hourly." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "from aeon.datasets import load_solar\n", + "\n", + "solar = load_solar()\n", + "print(type(solar))\n", + "plot_series(solar)" + ], "metadata": { "collapsed": false } From ddd240fd77e95fa6a2dadc5ceacf0e632443d6c3 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Mon, 28 Oct 2024 21:23:19 +0000 Subject: [PATCH 06/26] load_airline --- aeon/visualisation/series/_series.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/aeon/visualisation/series/_series.py b/aeon/visualisation/series/_series.py index 47b1203322..4bf4116b17 100644 --- a/aeon/visualisation/series/_series.py +++ b/aeon/visualisation/series/_series.py @@ -57,7 +57,7 @@ def plot_series( -------- >>> from aeon.visualisation import plot_series >>> from aeon.datasets import load_airline - >>> y = load_airline() + >>> y = load_airline(return_array=False) >>> fig, ax = plot_series(y) # doctest: +SKIP """ _check_soft_dependencies("matplotlib", "seaborn") @@ -217,7 +217,7 @@ def plot_lags(series, lags=1, suptitle=None): -------- >>> from aeon.visualisation import plot_lags >>> from aeon.datasets import load_airline - >>> y = load_airline() + >>> y = load_airline(return_array=False) >>> fig, ax = plot_lags(y, lags=2) # plot of y(t) with y(t-2) # doctest: +SKIP >>> fig, ax = plot_lags(y, lags=[1,2,3]) # y(t) & y(t-1), y(t-2).. # doctest: +SKIP """ @@ -317,7 +317,7 @@ def plot_correlations( -------- >>> from aeon.visualisation import plot_correlations >>> from aeon.datasets import load_airline - >>> y = load_airline() + >>> y = load_airline(return_array=False) >>> fig, ax = plot_correlations(y) # doctest: +SKIP """ _check_soft_dependencies("matplotlib", "statsmodels") @@ -386,7 +386,7 @@ def plot_spectrogram(series, fs=1, return_onesided=True): -------- >>> from aeon.visualisation import plot_spectrogram >>> from aeon.datasets import load_airline - >>> y = load_airline() + >>> y = load_airline(return_array=False) >>> fig, ax = plot_spectrogram(y) # doctest: +SKIP """ _check_soft_dependencies("matplotlib") From 109315b6cbde7726a55cc2599a5fe1206cee6505 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Tue, 29 Oct 2024 09:04:59 +0000 Subject: [PATCH 07/26] remove now redundant test --- .../tests/test_single_problem_loaders.py | 7 -- docs/getting_started.md | 17 ++- examples/visualisation/plotting_series.ipynb | 111 ++++++------------ 3 files changed, 49 insertions(+), 86 deletions(-) diff --git a/aeon/datasets/tests/test_single_problem_loaders.py b/aeon/datasets/tests/test_single_problem_loaders.py index de5cc76540..5a3b139445 100644 --- a/aeon/datasets/tests/test_single_problem_loaders.py +++ b/aeon/datasets/tests/test_single_problem_loaders.py @@ -102,13 +102,6 @@ def test_basic_load_tsf_to_dataframe(): assert metadata["contain_equal_length"] is False -def test_load_solar(): - """Test function to load solar data.""" - solar = load_solar() - assert type(solar) is pd.Series - assert solar.shape == (289,) - - def test_load_covid_3month(): """Test load covid 3 month.""" X, y = load_covid_3month() diff --git a/docs/getting_started.md b/docs/getting_started.md index 60f508204f..7f9ebece6b 100644 --- a/docs/getting_started.md +++ b/docs/getting_started.md @@ -64,10 +64,11 @@ converted to `np.ndarray` internally. The airline data 432.0 ``` -A multivariate time series is made up of multiple series, where each observation is a -vector of related recordings in the same time index. An examples would be a motion trace -of from a smartwatch with at least three dimensions (X,Y,Z co-ordinates), or multiple -financial statistics recorded over time. Single multivariate series input typically +A multivariate time series is made up of multiple series or channels, where each +observation is a vector of related recordings in the same time index. An examples +would be a motion trace from a smartwatch with at least three dimensions (X,Y,Z +co-ordinates), or multiple financial statistics recorded over time. Single +multivariate series input typically follows the shape `(n_channels, n_timepoints)` when stored in numpy arrays (sometimes called wide format). @@ -85,7 +86,9 @@ follows the shape `(n_channels, n_timepoints)` when stored in numpy arrays We commonly refer to the number of observations for a time series as `n_timepoints`. If a series is multivariate, we refer to the dimensions as channels (to avoid confusion with the dimensions of array) and in code use `n_channels`. So -the US Change data loaded above has five channels ( ) and 187 time points. +the US Change data loaded above has five channels ( ) and 187 time points. For more +details on our provided datasets and on how to load data into aeon compatible data +structures, see our [datasets](datasets) notebooks. ## Single series estimators @@ -96,8 +99,12 @@ take two series as arguments. ### Time Series Anomaly Detection (TSAD) +Anomaly detection is + ### Time Series Segmentation (TSS) +Segmentation is the process of dividing a time series into segments or regions. + ### Time Series Forecasting (TSF) Coming soon, we are relaunching our forecasting module. diff --git a/examples/visualisation/plotting_series.ipynb b/examples/visualisation/plotting_series.ipynb index 56bae98104..7131c9ea03 100644 --- a/examples/visualisation/plotting_series.ipynb +++ b/examples/visualisation/plotting_series.ipynb @@ -16,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "a15118bbccbbbc8a", "metadata": { "ExecuteTime": { @@ -25,20 +25,11 @@ }, "collapsed": false }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/aadya/.local/lib/python3.10/site-packages/dask/dataframe/_pyarrow_compat.py:23: UserWarning: You are using pyarrow version 13.0.0 which is known to be insecure. See https://www.cve.org/CVERecord?id=CVE-2023-47248 for further details. Please upgrade to pyarrow>=14.0.1 or install pyarrow-hotfix to patch your current version.\n", - " warnings.warn(\n" - ] - } - ], + "outputs": [], "source": [ "from aeon.datasets import load_airline, load_arrow_head\n", "\n", - "airline = load_airline()\n", + "airline = load_airline(return_array=False)\n", "airline_train, airline_test = airline[:-24], airline[-24:]\n", "arrowhead_X, arrowhead_y = load_arrow_head()" ] @@ -55,7 +46,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "5b28f2f926786622", "metadata": { "ExecuteTime": { @@ -76,7 +67,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "initial_id", "metadata": { "ExecuteTime": { @@ -88,10 +79,8 @@ "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -103,7 +92,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "cb341d617667f9e8", "metadata": { "ExecuteTime": { @@ -115,10 +104,8 @@ "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -130,7 +117,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "b42a42fea9dbe62d", "metadata": { "ExecuteTime": { @@ -142,10 +129,8 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAArQAAAJJCAYAAABbMqQdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB1JUlEQVR4nO3deXQUVfr/8U8nkBAkEEhIhICIgSAohBgMjopIRBEUVHCdwQ394gLD/AQEkXFfGEXEDRVwFxUXFMEFdQzigoIGgYGwBGQJm9BAIEBIIF2/P5juobP0kvRSlX6/zvEcqaquutW3G56+9dzn2gzDMAQAAABYVFS4GwAAAADUBgEtAAAALI2AFgAAAJZGQAsAAABLI6AFAACApRHQAgAAwNIIaAEAAGBpBLQAAACwNAJaAAAAWBoBLRBkW7ZsUYcOHar879RTT1WXLl103nnn6Y477tC///3vSq9//vnn1aFDB40YMSJgbVq/fn3AzuXJjBkz1KdPH3Xu3FlnnXWWXn755ZBctzaC8X5HAudneu3atWG5vt1u1/79+3069vjv5MGDB4PcstDYsWOHHn30UV100UXq3LmzMjMzddVVV+ntt9/WkSNHwt08IOjqhbsBQCQ5/fTTFRMT4/qzYRgqKyvTli1blJubq9zcXP31r3/VAw88EJTrb9y4UQ8++KAaN26s5557LijXcJo9e7YeeeQRSVLr1q0VHx+vli1bBvWaiExvvPGGnn/+eb333ntq3LhxuJsTcsuXL9ett96qffv2qX79+jr55JN14MABLV++XMuXL9c333yj6dOnKzY2NtxNBYKGgBYIoWeffVatWrWqtP3IkSN64YUX9PLLL+vdd99Vjx49lJOTE/Drz507Vz///LP69OkT8HNXNG/ePElS//799dRTTwX9eoHyt7/9Tf369VOjRo3C3RRL+eKLLyQd+/ESahMmTAj5Nc2itLRU//jHP7Rv3z7l5OTo8ccfV9OmTSVJv/32m+666y4tWrRITz/9tMaNGxfm1gLBQ8oBYAL169fXXXfdpczMTEnSu+++G+YW1d6ePXskSd26dQtzS/zTrFkzpaWlKSUlJdxNsZS0tDSlpaW5PYFA8H311Vfatm2bUlJSNGnSJFcwKx377jmfksycOVOlpaXhaiYQdAS0gIn06tVLkvSf//wnzC2pvaNHj0oSAQ4QRIsXL5YknXfeeWrYsGGl/eecc47q16+vw4cPhyx3HggHUg4AE3E+5vZ1osr+/fv15ptv6uuvv9bmzZsVFRWltm3bql+/fho8eLAaNGjgOrZDhw6u///qq6/UoUMHZWdn6+233/bpWr/88ovefvtt/f7779q/f78SEhJ05plnasiQIercubPruHvuuUeffPKJ68/jxo3TuHHjfLqWYRj66KOP9Mknn2j16tUqKytTUlKSsrKydOONN6pLly6VXuNwODR79mzNmjVLa9asUVlZmVq1aqWLLrpIt9xyi+Lj492Od7bvmWee0bp16zRjxgyVlpbqlFNO0VtvvaXXX39dL7zwgvr06VMpz/jAgQN644039NVXX2nz5s2Kjo5Wenq6Bg4cqEGDBik6OrpS+7755hu99957WrFihQ4dOqSEhAR16dJFf/3rX3Xuuef69N47rV69WjNmzNCvv/6qnTt36ujRo0pMTFRWVpaGDBmi0047rdJrDh8+rHfffVezZ8/W5s2bFRcXp/POO0//7//9Pz377LP65JNPNGHCBA0cONDtdfPnz9fHH3+s5cuXa8+ePapXr55OPPFEnXfeebr11lvVvHlzt+Odn6+5c+cqPT3d7b1+9tlndfLJJ2vKlCn69ddfdfDgQbVu3VoDBgzQkCFDKv3o2b17t6ZNm6bvvvtOW7duVUxMjFq3bq1evXrppptuUkJCgqRjE/heeOEF1+v69+8vSXrrrbfUvXt3v95bp9LSUn300Uf6+uuvtXbtWhUXF6tBgwZq27at+vbtq8GDB1f5I23FihWaNm2afv/9d+3bt09paWkaPHiwunfvrgsuuECpqanKzc11HV+Tz3pVBg8erDPPPFMnnXRSlfvLyspUXl4u6X8/MoG6iIAWMJHNmzdLklq0aOH12I0bN+rmm2/Wtm3bFB0drfbt28vhcCg/P18rV67UnDlz9Oqrr7oCjzPOOEPbt2/X9u3blZCQoFNOOcUVeHgzadIkTZs2TZKUlJSkU089VYWFhfriiy80b948jR8/XoMHD5YknXzyyTrjjDO0evVqHTp0SCeffLKaNWvm07UeeOABvf/++7LZbGrTpo1OOOEEbdmyRZ999pm+/PJLPffcc+rdu7fr+LKyMv3973/Xd999J0lKTU1VkyZNVFBQoJdeekmfffaZXn/99SrzOt944w0tXbpUJ598so4ePaoGDRp4zJvdsmWLhgwZok2bNqlevXo6+eST5XA49Pvvv+v333/X119/rRdffNEt2Jk2bZomTZokSWrVqpVat26t7du369tvv9W3336r++67z/W+efPJJ59o/PjxKi8vV9OmTdW2bVsdOHDA9f589dVXev3113XmmWe6XnPgwAENHTpUeXl5ioqKUvv27VVaWqrZs2fr+++/V5s2baq81vjx4/XRRx9Jklq2bKn09HTZ7Xb98ccf+uOPP/Tll1/q008/dXu87ckvv/yi0aNHS5Latm2ruLg4rV+/XpMnT9ayZcv00ksvuY7dvXu3rrzySm3btk0nnHCC2rVrp6NHj2rdunVavXq1vvjiC3344Ydq0qSJWrRooTPOOENLliyRJHXq1EkNGjSo9CPGV8XFxbrxxhu1cuVKRUdH66STTlKLFi20detW1wSrhQsX6pVXXnF73RdffKExY8boyJEjatq0qdq3b68NGzbo3nvvrTYX3t/PenVOPfVUnXrqqdXunz9/vhwOh+rVq6e2bdv694YAVmIACKrCwkIjPT3dSE9PNwoLC6s9rqioyDjrrLOM9PR045FHHnFtf+6554z09HTj73//u2tbWVmZ0adPHyM9Pd0YPHiwsX37dte+P/74w+jfv7+Rnp5u/PWvf3W7RlXn8uaTTz4x0tPTjdNOO8348MMPDYfDYRiGYRw9etSYNm2a0aFDB6NDhw7Gjz/+6Pa6K664wkhPTzdmzZrl03XWrl1rpKenG2eddZaxdu1a1/bS0lLjwQcfNNLT040LLrjA7TWPPPKIkZ6ebvTt29dYuXKla/uePXuM4cOHG+np6cYVV1xhlJeXu/aNHTvW1R+vv/66a/vu3bsNw6j6PTp69Khx+eWXG+np6cbtt99u7Nq1y7WvoKDA6Nu3r5Genm48+uijru179+41TjvtNKNz587G4sWL3c710ksvGenp6UbXrl2NQ4cOeX1vdu3aZWRkZBjp6enGq6++ahw9etS1b/PmzcaAAQOM9PR049Zbb3V73UMPPWSkp6cbvXv3NgoKClzbf/31V6N79+6u9+H4Pvr2229dbfv555/dzrdo0SKja9euRnp6ujFt2jS3fc5zrVmzxrXt+Pd66NChbu/bm2++6dq3bNky1/Z//etfRnp6ujFixAjj4MGDbvd54YUXGunp6cYLL7zg9dqeHP+dPHDggGv7hAkTXJ+nLVu2uLYfPXrUeOONN6ps77Zt24wuXboY6enpxjPPPGMcOXLEMAzDOHjwoHHPPfe4XtOrVy/Xa2ryWa+JgwcPGr179zbS09ONO+64o9bnA8yMHFogjAzD0P79+/X999/r1ltv1Z49exQfH69bbrnF4+s+//xzbdiwQUlJSXrxxRd14oknuva1bdtW06ZNU8OGDfXbb79pwYIFtWqj85HuiBEjdOWVV8pms0mSoqOj9X//93+6/vrrZRiGnnnmmVpdx1m/NDMzU+3bt3dtj4mJ0ZgxY3TOOeforLPOcqVj/Pnnn5o5c6bq16+v559/Xp06dXK9pmnTpnrqqafUsmVLrVy50u1Rr1NKSopuvPFG15+bNWtWbdu++eYb5efnq23btnrmmWeUlJTk2teuXTs988wzioqK0nvvvafdu3dLOjaCfuTIEbVt29Zt1DQ6Olq33367LrzwQl188cUqKiry+t448yS7du2qIUOGuKU2tG7dWkOGDJHkXl94z549mjlzpmw2m55//nm1a9fOta9bt27VVgZYuHCh6tevr8GDB+uss85y25edna1+/fpVupY3CQkJevbZZ93etxtuuMH1mHzp0qWu7c7PQf/+/d1yQlu3bq3Ro0crJyfH55Fhfy1evFg2m03jxo1Tamqqa3t0dLRuvPFGV3vXrVvn2vfqq6/q8OHDuvDCC/WPf/xD9eode/DZsGFDPfbYY27pOBXv0dfPek2Ul5dr9OjR2rx5s2JjYzVy5MganwuwAlIOgBC64IILPO5v2rSpnnvuOa8pB84gtX///lU+Xj3xxBN14YUX6tNPP9V3332nnj171qi969evV2FhoaKionTttddWecwNN9ygt956S8uXL9fu3buVmJhYo2s50wIWLFigV155Rf3793dVGoiLi9Nrr73mdvz333+vI0eOKCMjQ2lpaZXOFxsbq969e+utt97S999/X+nxbUZGhis49+bbb7+VJPXu3bvKWp7p6elKT0/X6tWr9csvv+iSSy5RamqqoqOjtXr1aj311FO65ppr3FIfjs/99KZfv37q169ftbPU4+LiJEklJSWubd9//73Ky8uVkZFR5SPpXr16qWXLltq2bZvb9n/+858aN26cK+/Sl2t5k52d7ZbP7dS2bVtt3rxZBw4ccG1zBo1PPfWU6tevr7POOsv1nl900UW66KKLfL6uvz7++GOVlZWpfv36lfaVlZW5atwef+/z58+XJF199dWVXuP83lSc5OnvZ91fR48e1ZgxY1yf2/vuu8/tBw1QFxHQAiFUcWGFqKgoNWzYUCkpKcrMzFTfvn2rnKlc0caNGyVJHTt2rPaYTp066dNPP3UdWxPO17Zq1aragvXORROKi4u1cePGGge0Xbp00YUXXqhvvvlGEydO1MSJE9WhQwede+656tWrl7KyshQV9b+HSs4Rwk2bNum6666r8py7du2SJG3YsKHSvoqTmjxxXmvevHnKy8ur8pgdO3a4Xat58+a6/vrr9cYbb2j69OmaPn26Tj75ZJ177rnq2bOn/vKXv1QZOHlSv3595eXlac2aNSosLNTmzZu1evVqbdmyRdKxCXIV23z8ZMCKTj311EoBrXRsRLK0tFS//PKL60fNpk2btHLlSu3du1fSsacLvqquBJozyD2+3UOGDNEXX3yhDRs2aOjQoYqLi1O3bt3Uo0cPXXDBBVXWcQ6kmJgY7dq1S3l5edqwYYO2bNmi9evXa/Xq1a5A1nnvzkVRpOrf5+OfHDj5+1n3x6FDh3TXXXe58srvuusuXXXVVTU6F2AlBLRACFW3sIK/nI8iTzjhhGqPce6rzWNLX64jHXu8WlxcXOtlRJ999lm99957+vDDD7V69WqtWbNGa9as0auvvqrU1FTde++9rpFW56heUVGRa1JQdY4fAXTyZ9Uk5+sLCwtVWFjo8dji4mLX/48bN06nnXaa3n33XS1dulQbN27Uxo0bNWPGDDVt2lQjR46scmSvKl9//bUmTZrk9gPFOdHroosu0tdff+12vDOVwTmiWpWq+tXhcGjq1Kl644033NIhYmNj1aVLFzkcjmqD+up4C9yPD45bt26tTz/9VC+++KK+/vpr7d27Vz/88IN++OEHPf744+rZs6ceeeSRoNQJ3rdvn/71r39p7ty5bsvFJiQk6JxzznH78SDJFdxLqvaHaHXfHX8+677as2ePhg4d6hoRvvvuu3Xrrbf6dQ7AqghoAQty/uNZVaDm5AysfBnxrc11AnUt6djI4ODBgzV48GBt375dP//8s3766SdX+aYRI0bogw8+0Omnn+4K1P72t7/p/vvvr9V1vXFe69lnn9XFF1/s12sHDBigAQMGaPfu3frll1/0008/af78+dqzZ4/uu+8+NWvWzGvg8uOPP2rEiBEyDEO9evVSnz591KFDB1fFgB9//LFSQOtss6cfGVXte/bZZ/Xyyy+rXr16Gjx4sLKzs9W+fXuddNJJqlevnp5++mm/A1p/nXjiiXr44Yf14IMP6j//+Y9+/vlnff/991qyZIkWLFig22+/XR9//LHPKSO+MAxDt99+u5YsWaJmzZpp8ODB6tKli9q1a+dKAbr22mvdAtrjP+8HDx6sMv2nuvffn8+6L7Zv366bb75ZGzZsUHR0tB566CFGZhFRmBQGWJCz/M6qVauqPWblypWSVG19Sn+us3XrVu3fv7/KYzZs2KBDhw5JUrVloHzhXHt+69atko6VLhs4cKAmTZqk7777Tunp6SovL9fnn38u6Vh5MEn6448/qj3n+vXr9Z///Ef79u2rcbuk/92Xp2v9/vvvWrt2rQ4fPizpWJ5lfn6+69F/YmKiLrnkEj3++ONasGCBzj77bEnSnDlzvF7/tddek2EYGjhwoF5++WVdccUV6tSpkytodaY7HM+ZM+mcgFSVgoICtz8fOXJEb731liTp0Ucf1X333ac+ffrolFNOcU12qupagbR9+3YtXLhQhmEoKipKGRkZuv322/Xuu+/q9ddflyTl5+e7TcwKhN9//11LlixRvXr1NHPmTA0bNkw9evRwy2eveO/x8fGukeI1a9ZUed6q3n9/P+ve7NmzRzfddJM2bNigmJgYPffccwSziDgEtIAFOSd5ffbZZ26PuJ127NjhmhByfPF+54iWr/mPaWlpOumkk+RwODRz5swqj3nnnXckHZsY5U9eakVPPvmkrrrqKk2dOrXSvvj4eNdIlTPfskePHoqKitLixYurDDSPHj2qO++8U1deeaUrEKqp888/X5I0e/bsKidmFRYWavDgwerfv79+//13SdLbb7+tK664Qo8//nil42NiYpSVleV2P544A5+qcqYNw9DHH38sSW4TuXr27Kl69erpP//5T5VB1aJFiyqlT+zZs8f146Sqa+3evduVmxmMIv1lZWW69NJLdfPNN2vZsmWV9nfr1s2VvnD8vfr7ua6K8z1u1KhRlT/MfvrpJ23fvl2S+70768w6+6CiWbNmVdrm72fdE4fDoX/84x/auHGjGjRooGnTpvmdqgDUBQS0gAX169dPbdu2ld1u15133uk2cuScTFNSUqLMzEy3ygrOfL6qJgJVZ9iwYZKk5557TrNmzXIFDeXl5XrllVc0Y8YMSdKoUaNqdU/OVZ4++ugjffrpp27ByeLFizVv3jxJx5b4lI6NPPfv31/l5eW6/fbbXSPS0rFcyLvvvlsbN25Uw4YNq5005qtLL71UJ598sjZt2qS///3vrslm0rGJc3feeaeOHj2qjh076i9/+YskqW/fvoqOjtaPP/6oV155xS0IWrt2rd5//323+/HEORr94Ycfym63u7bv3LlTo0aNcqUAHB9sp6SkaNCgQTIMQyNGjHAL+leuXKkxY8ZUuk5iYqJr8t9rr72msrIy175Vq1bplltucY12V1dxoTZiYmJcVQz++c9/uk3mKysr09NPP60jR44oNTXVbda+89G/P5/ripzvcVFRkd59913XdofDoW+++cat7NXx78stt9yiBg0aaN68eXrxxRddgXZZWZkmTJjgKrl2PH8/65589NFHrms89NBDrs8fEGnIoQUsKCYmRlOmTNGtt96qxYsX64ILLlC7du3kcDhUUFAgwzDUoUMHTZ482a1mqXMm9ooVK1x5mBWXd63o8ssv19q1a/Xqq6/q3nvv1eTJk3XiiSeqsLBQRUVFio6O1t133+0axaypM888UzfffLNef/11jRkzRk888YRatGihvXv3ukbPrrnmGp1zzjmu19x///3atm2bfv31Vw0cOFAnn3yyGjZsqA0bNqikpET169fXc889V+sJRM73+5ZbbtGCBQt0/vnnq127djpy5Ig2btyo8vJynXjiiXrxxRddr2ndurXGjRunRx99VBMnTtS0adPUqlUrHTx4UJs2bZJhGDr//PMrLTlblTvuuEM//fST1q5dq5ycHLVt21ZHjx7Vxo0bdfToUWVnZysvL09lZWUqKipyLQ07ZswYrVixQitXrtQll1yi9u3bq7y8XOvWrdOJJ56opKQk2e1212ekXr16GjZsmCZMmOAq+daqVSvt27fPlTvavXt3LVq0SDt37qzVe1qdsWPHKi8vTwUFBbrkkkvUunVrnXDCCSosLNT+/fsVGxurxx9/3JUCIR37XC9ZskQjR47UKaecorvuusvvZYU7d+6sCy64QN9++60eeughTZ06VUlJSdq2bZv27NmjuLg4ZWRkaNmyZW733rp1az388MO655579Oyzz+rtt99WamqqNm3apP379+v000/XihUr3L6HNfmsV8dZ4qt+/fp6//33XT+UqnLfffdVWXUBqAsYoQUsKi0tTbNnz9Ydd9yhtm3bauPGjdq+fbs6d+6se++9Vx9++GGlerZnn322Ro4cqRNPPFFbt27VypUrfXqsOWbMGL3++uvq1auXjh49qtWrV+uEE07Q5Zdfrg8++EA333xzQO5p7Nix+te//qXs7GyVl5e7ls/t0aOHnnvuOT388MNuxzdq1Eivv/66Hn74YWVlZWn37t1au3atGjdurP79++ujjz5Sjx49AtK2du3a6dNPP9Udd9yhU045RRs3btTmzZt10kknaciQIfrkk0/UsmVLt9dcf/31evHFF3XeeecpOjpaa9as0d69e9WtWzc9+uijeumll9wCs+p07dpVn3zyiS666CIlJiZq3bp1stvtyszM1GOPPaY333zTVcDfWRfV+f688847Gj58uNq0aaMNGzZo7969uvLKK/Xhhx+6lvo9vkbsTTfdpJdffllnnnmmoqOjtXbtWpWVlal3795688039dJLL6l+/foqKCjwWvGhJhISEjRz5kwNGTJEbdu21Y4dO1RQUKDGjRvr6quv1ty5cyst+PD444+re/fuMgxDGzdu1KZNm2p07WeffVbjxo1Tx44dVVxcrIKCAsXHx+uaa67R7Nmz9fe//13Ssfqxx39vLrvsMs2YMUM9e/ZUeXm51q5dq9atW+upp55yfTcq1uH197NelT179rhGsY8cOaIlS5Z4/K+q9CSgrrAZtUk6AgBY1tlnn63du3fr3XffdeX0IrDeffddPfTQQzr77LNrncsNoHqM0AJAHVRQUKCcnBxXDnRF+fn52r17t+rVq+dx8QV4ds899+iKK66ocnllSfrhhx8keV4EBUDtEdACQB3Upk0bHThwQP/+97/12muvuVUF+OOPP3T33XdLki655BJX6gH81759e+Xn52vSpEluNWrLyso0bdo05ebmKiYmRoMGDQpjK4G6j5QDAKijZs+erXvuuUeGYahp06ZKTU1VcXGxNm/eLMMwdPrpp+u1115TkyZNwt1Uyzp06JCuvfZarVmzRtHR0WrTpo3i4uJck9jq16+vhx56iIAWCDICWgCow1avXq3XXntNy5Yt044dO9SgQQO1adNGl1xyia677jrFxMSEu4mWd/jwYc2aNUtz5sxRYWGhiouL1bx5c2VnZ+v666/XaaedFu4mAnUeAS0AAAAsjRxaAAAAWBoBLQAAACyNgBYAAACWRkALAAAASyOgBQAAgKUR0AIAAMDSCGgBAABgaQS0AAAAsDQCWgAAAFgaAS0AAAAsjYAWAAAAlkZACwAAAEsjoAUAAIClEdACAADA0ghoAQAAYGkEtAAAALA0AloAAABYGgEtAAAALI2AFgAAAJZGQAsAAABLI6AFAACApRHQAgAAwNIIaAEAAGBpBLQAAACwNAJaAAAAWBoBLQAAACyNgBYAAACWRkALAAAASyOgBQAAgKUR0AIAAMDSCGgBAABgaQS0AAAAsDQCWgAAAFgaAS0AAAAsjYAWAAAAlkZACwAAAEsjoAUAAICl1Qt3A8Jt9+5iGUZgz2mzSYmJ8UE5N4KDPrMe+sx66DProc+spS72l/OevIn4gNYwFLROD+a5ERz0mfXQZ9ZDn1kPfWYtkdhfpBwAAADA0ghoAQAAYGkEtAAAALA0AloAAABYGgEtAAAALI2AFgAAAJZGQAsAAABLI6AFAACApRHQAgAAwNIIaAEAAGBpBLQAAACwNAJaAAAAWBoBLQAAACytXrgbAAAAqlbuMLR06z7ZD5QpqVGMuqY2UXSULdzNAkyHgBYAABPKLbBrUu467TxQ5tqW3ChGo3LaKad9UhhbBpgPKQcAAJhMboFdY+fkuwWzkrTzQJnGzslXboE9TC0DzImAFgAAEyl3GJqUu87jMU/PX69yhxGiFgHmR0ALAICJLN26r9LIbEV/Fpdq6dZ9IWoRYH4EtAAAmIjdSzDr73FAJCCgBQDARJIaxQT0OCASENACAGAiXVObKNlLsJoSH6uuqU1C1CLA/AhoAQAwkegom0bltPN4zMheadSjBY5DQAsAgMnktE/SEwM6VRqpTYmP1RMDOlGHFqiAhRUAADChnPZJ6pmWyEphgA8IaAEAMKnoKJuyWieEuxmA6ZFyAAAAAEtjhBYAAFhGucMgDQOVENACAABLyC2wa1LuOreV1JIbxWhUTjsmykU4Ug4AAIDp5RbYNXZOfqVlgXceKNPYOfnKLbCHqWUwAwJaAABgauUOQ5Ny13k85un561XuMELUIphNWAPasrIyPfTQQzrzzDN19tln6+mnn5ZhHPsw5ufn66qrrlJGRoYGDRqkFStWuL32s88+U+/evZWRkaFhw4Zpz5494bgFAAAQZEu37qs0MlvRn8WlWrp1X4haBLMJa0D76KOPauHChXr11Vc1adIkffDBB3r//fd16NAhDR06VN26ddPHH3+szMxM3XbbbTp06JAkafny5Ro/fryGDx+u999/X/v379e4cePCeSsAACBI7F6CWX+PQ90TtklhRUVFmjVrll5//XV16dJFkjRkyBAtW7ZM9erVU2xsrMaMGSObzabx48fr+++/17x58zRw4EDNmDFDffv21eWXXy5JevLJJ9WrVy8VFhaqdevW4bolAAAQBEkVVkyr7XGoe8I2QpuXl6dGjRopOzvbtW3o0KGaMGGCli1bpqysLNlsx8pw2Gw2nXHGGVq6dKkkadmyZerWrZvrdS1atFDLli21bNmykN4DAAAIvq6pTSotA1xRSnysuqY2CVGLYDZhC2gLCwuVmpqq2bNn6+KLL9YFF1ygKVOmyOFwaNeuXUpOTnY7PjExUTt27JAk7dy50+N+AABQd0RH2TQqp53HY0b2SqMebQQLW8rBoUOHtGnTJs2cOVMTJkzQrl27dP/99ysuLk4lJSWKiXH/JRYTE6OysmO5MYcPH/a43x+2IHz2necMxrkRHPSZ9dBn1kOfWY+Z+uyC9CQ9OaCTnqpQhzYlPlajeqUpJ506tGbqr0Dx9V7CFtDWq1dPBw4c0KRJk5SamipJ2rZtm9577z21adOmUnBaVlamBg0aSJJiY2Or3B8XF+d3OxIT42t4B+E9N4KDPrMe+sx66DPrMUufXZ0Ur0FnnazFG/ZoZ/FhJcc3UHbbZozMVmCW/gqlsAW0zZs3V2xsrCuYlaS2bdtq+/btys7Olt3uXiDZbre70gxSUlKq3N+8eXO/27F7d7GMAJets9mOfZiCcW4EB31mPfSZ9dBn1mPWPmvfJEbtmxx7Urt3z4Ewt8Y8zNpfteG8J2/CFtBmZGSotLRUGzZsUNu2bSVJf/zxh1JTU5WRkaHp06fLMAzZbDYZhqElS5bo9ttvd702Ly9PAwcOlCRt375d27dvV0ZGht/tMAwFrdODeW4EB31mPfSZ9dBn1kOfWUsk9lfYJoWdcsopOv/88zVu3DitXr1aP/zwg6ZNm6brrrtOF198sfbv36/HHntM69at02OPPaaSkhL17dtXknTdddfp008/1YcffqjVq1drzJgxOv/88ynZBQAAEIHCurDCU089pZNOOknXXXedxo4dq7/97W+6/vrr1ahRI02dOtU1Crts2TJNmzZNDRs2lCRlZmbq4Ycf1pQpU3TdddepSZMmmjBhQjhvBQAAAGFiM4xIG5R2Z7cHJ4c2KSk+KOdGcNBn1kOfWQ99Zj30mbXUxf5y3pM3YR2hBQAAAGqLgBYAAACWRkALAAAASyOgBQAAgKUR0AIAAMDSCGgBAABgaQS0AAAAsDQCWgAAAFgaAS0AAAAsjYAWAAAAlkZACwAAAEsjoAUAAIClEdACAADA0ghoAQAAYGkEtAAAALA0AloAAABYGgEtAAAALI2AFgAAAJZGQAsAAABLI6AFAACApRHQAgAAwNIIaAEAAGBp9cLdAAAAULVyh6GlW/fJfqBMSY1i1DW1iaKjbOFuFmA6BLQAAJhQboFdk3LXaeeBMte25EYxGpXTTjntk8LYMsB8SDkAAMBkcgvsGjsn3y2YlaSdB8o0dk6+cgvsYWoZYE4EtAAAmEi5w9Ck3HUej3l6/nqVO4wQtQgwPwJaAABMZOnWfZVGZiv6s7hUS7fuC1GLAPMjoAUAwETsXoJZf48DIgEBLQAAJpLUKCagxwGRgIAWAAAT6ZraRMlegtWU+Fh1TW0SohYB5kdACwCAiURH2TQqp53HY0b2SqMeLXAcAloAgGWVOwzlFRbpq1U7lVdYVGdm/ue0T9ITAzpVGqlNiY/VEwM6UYcWqICFFQAAllTXFx7IaZ+knmmJrBQG+ICAFgBgOc6FBypyLjxQV0Yxo6NsymqdEO5mAKZHygEAwFJYeABARQS0AABLYeEBABUR0AIALIWFBwBUREALALAUFh4AUBEBLQDAUlh4AEBFBLQAAEth4QEAFRHQAgAsh4UHAByPOrQAAEuy4sID5Q7DUu0FrIKAFgBgWVZaeKCur2wGhBMpBwAABJlzZbOK9XOdK5vlFtjD1DKgbiCgBQAgiFjZDAg+AloAAIKIlc2A4COgBQAgiFjZDAg+AloAAIKIlc2A4COgBQAgiFjZDAg+AloAAIKIlc2A4COgBQAgyFjZDAguFlYAACAErLiyGWAVBLQAAISIlVY2A6yElAMAAABYGgEtAAAALI2AFgAAAJZGQAsAAABLI6AFAACApRHQAgAAwNIIaAEAAGBpBLQAAACwNAJaAAAAWBoBLQAAACyNpW8BAADgUbnD0NKt+2Q/UKakRjHqmtpE0VG2cDfLhYAWAAAA1cotsGtS7jrtPFDm2pbcKEajctopp31SGFv2P6QcAAAAoEq5BXaNnZPvFsxK0s4DZRo7J1+5BfYwtcwdAS0AIGKVOwzlFRbpq1U7lVdYpHKHEe4mAaZR7jA0KXedx2Oenr/eFN8bUg4AABHJCo9RgXBaunVfpZHZiv4sLtXSrfuU1TohNI2qBiO0AICIY5XHqEA42b0Es/4eF0xhDWi/+eYbdejQwe2/ESNGSJLy8/N11VVXKSMjQ4MGDdKKFSvcXvvZZ5+pd+/eysjI0LBhw7Rnz55w3AIAwGKs9BgVCKekRjEBPS6YwhrQrlu3Tr169dKPP/7o+u/RRx/VoUOHNHToUHXr1k0ff/yxMjMzddttt+nQoUOSpOXLl2v8+PEaPny43n//fe3fv1/jxo0L560AACzCn8eoQCTrmtpEyV6C1ZT4WHVNbRKiFlUvrAHt+vXrlZ6erubNm7v+a9y4sb744gvFxsZqzJgxSktL0/jx43XCCSdo3rx5kqQZM2aob9++uvzyy3XqqafqySef1IIFC1RYWBjO2wEAWICVHqMC4RQdZdOonHYejxnZK80U9WjDHtCefPLJlbYvW7ZMWVlZstmOvUE2m01nnHGGli5d6trfrVs31/EtWrRQy5YttWzZslA0GwBgYVZ6jAqEW077JD0xoFOlkdqU+Fg9MaCTaSZQhq3KgWEY2rBhg3788UdNnTpV5eXluvjiizVixAjt2rVL7dq5/yJITExUQUGBJGnnzp1KTk6utH/Hjh0haz8AwJqcj1E9pR2Y5TEqYAY57ZPUMy2RlcKqsm3bNpWUlCgmJkbPPPOMtmzZokcffVSHDx92bT9eTEyMysqO/eVz+PBhj/v9YQtCXzjPGYxzIzjoM+uhz6zHLH1WL9qm0TntNGZOfrXHjOqVpnrRfLjM0mfwTTD7q160Td1OSgj8ib3w9V7CFtCmpqZq0aJFatKkiWw2mzp27CiHw6G7775b2dnZlYLTsrIyNWjQQJIUGxtb5f64uDi/25GYGF/zmwjjuREc9Jn10GfWY4Y+uzopXo0bN9BDc/O1fd9h1/YWTRrogf6ddPHpLcLYOvMxQ5/Bd5HYX2FdWCEhIcHtz2lpaSotLVXz5s1lt7vXALTb7a40g5SUlCr3N2/e3O827N5dLCPAlVlstmMfpmCcG8FBn1kPfWY9Zuuzbic20uxbztTvW/bJfrBMSSfEKLPVsceodntxuJtnCmbrM3hWF/vLeU/ehC2g/eGHHzR69Gh99913rpHVVatWKSEhQVlZWZo+fboMw5DNZpNhGFqyZIluv/12SVJGRoby8vI0cOBASdL27du1fft2ZWRk+N0Ow1DQOj2Y50Zw0GfWQ58dU+4wTJ3fdjwz9VmUzVZphSOztM1MzNRn8C4S+ytsAW1mZqZiY2P1z3/+U8OGDVNhYaGefPJJ3Xrrrbr44os1adIkPfbYY7r22ms1c+ZMlZSUqG/fvpKk6667Ttdff726du2qzp0767HHHtP555+v1q1bh+t2ACBsWMIVQKQLW9muRo0a6dVXX9WePXs0aNAgjR8/Xtdcc41uvfVWNWrUSFOnTnWNwi5btkzTpk1Tw4YNJR0Lhh9++GFNmTJF1113nZo0aaIJEyaE61YAIGxYwhUAJJthRNqgtDu7PTg5tElJ8UE5N4KDPrMe+uxYmsGA6Yu8lp/69NZsU6Qf0GfWQ59ZS13sL+c9eRPWhRUAADXHEq4AcAwBLQBYFEu4AsAxBLQAYFEs4QoAxxDQAoBFOZdw9YQlXAFEAgJaALCo6CibRuW083jMyF5pppgQBgDBREALABaW0z5JTwzoVGmkNiU+Vk8M6EQdWgARIaxL3wIAai+nfZJ6piVaZqUwAAg0AloAqAOioyov4QoAkYKUAwAAAFgaAS0AAAAsjYAWAAAAlkYOLQAgoModRtAnqIXiGgCsg4AWABAwuQV2Tcpdp53HLbeb3ChGo3La6YL0wJQQ83QNypQBkYmUAwBAQOQW2DV2Tr5boClJOw+UaeycfOWutQf/GgW1vwYA6yGgBQDUWrnD0KTcdR6PmTR/vcodRlCv8XQtrwHAmghoAQC1tnTrvkqjphX9WVyqxRv2BP0a7/++laAWiDAEtACAWrN7CTSddhYfDvo1Jn/3hwZMX0T6ARBBCGgBwOTKHYbyCov01aqdyissMuXoY1KjGJ+OS45vEPRrSOTUApGGKgcAYGJWmdHfNbWJkhvFeEwJSImPVXbbZtq750DQrlHR0/PXq2daIiW9gDqOEVoAMCkrzeiPjrJpVE47j8eM6pVWq8DSl2tU9GdxqZZu3Vfja6LusMKTDtQcI7QAYEK+zugP9+hjxQUOJvTvqMnz17sF4SnxsRrZK005AahDm9M+SU8M6FRp1NoTX3NvUXdZ5UlHsETCQiQEtABgQr7O6F+6dZ+yWieEplEVVBck3HV+mpo2rB+0fzxz2iepZ1qi3v99qyZ/94fX4/3JvUXd43zSUZHzSccTAzrV6aA2UoJ5Ug4AwIR8HVUM1+ijp3SIcZ+t0r7DR9WnY7KyWicEZSQoOsqmazJTlewlWE2Jj1XX1CYBvz6sIdJrF1spbam2CGgBwIR8HVUMx+ijWYIEX3JqR9YybxfW5s+TjrrGLN/TUCGgBQATcs7o9yRco49mChKcObUV36uU+Ng6/ygZ3pn9SUcwmel7Ggrk0AKACTlHH6vK/XMK1+ij2YIEZ05tXZ/0Av+Z+UlHsJntexpsBLQAYFLVzeh3VQ0I0+ijGYOE6Chb2CbHwbx8rY9cF/Oszfg9DSYCWgAwMTOOPkZykABrMfOTjmCLtO8pObQAYHLO0cdgVg3wtz1MxoJVRGqedaR9TxmhBQD4zazpEEBVzPikIxQi6XtKQAsAqJFIDRJgTZGaZx0p31MCWgBAjUVqkABYSSR8T8mhBQAAgKUR0AIAAMDSCGgBAABgaQS0AAAAsDQCWgAAAFgaAS0AAAAsjYAWAAAAlkZACwAAAEsjoAUAAIClsVIYAIRZucOo88tSAkAwEdACQBjlFtg1KXeddh4oc21LbhSjUTntlNM+KYwtAwDrIOUAAMIkt8CusXPy3YJZSdp5oExj5+Qrt8AeppYBgLUQ0AJAGJQ7DE3KXefxmKfnr1e5wwhRixAK5Q5DeYVF+mrVTuUVFtG/QICQcgAAYbB0675KI7MV/VlcqqVb9ymrdUJoGoWgIr0ECB5GaAEgDOxegll/j4O5kV4CBBcBLQCEQVKjmIAeB/MivQQIPgJaAAiDrqlNlOwlWE2Jj1XX1CYhahGCxZ/0EgA1Q0ALAGEQHWXTqJx2Ho8Z2SuNerR1AOklQPAR0AJAmOS0T9ITAzpVGqlNiY/VEwM6MVGojiC9BAg+qhwAQBjltE9Sz7REVgqrw5zpJZ7SDkgvAWqHEVoAAIKI9BIg+BihBYAwojZpZHCml1Ts65T4WI3slUZfA7VEQAsAYeKsTVqRszZpJOTRljsMv9It/D3eTEgvAYKHgBYAwsDX2qQ90xLrbMDj7+h0XRjNjo6ysfIbEATk0AJAGASqNmm5w1BeYZG+WrVTeYVFlinO7+/KWay0BcATRmgBIAwCUZvUqiOW/o5OM5oNwBtGaAEgDGpbm9TKI5a/b/FvdJqVtgB4Q0ALIOKF47F9bZa+9XXE0qzpB/aD/o1Os9IWAG9IOQAQ0cL12N5Zm7SqKgdO1dUm9WfE0owTkJJO8G90mpW2AHjDCC2AiBXux/Y1XfrW6iOWma38G52uzWg2gMjACC2AiGSWiUY1qU1q9RFLf0enazOaDSAyMEILICKZaaKRszZpn47Jymqd4DUwqwsjlv6OTtd0NBtAZGCEFkBEsvJj+7oyYunv6DQrbSGUrLwqXSQioAUQkaz+2L5nWqJuO7uN3luyVfsPH3VtT4mP1cheaZYZsfR35SxW2kIoWLXGcyQjoAUQkZyP7T2lHZj1sX1V/9g2jo3WtVmtNKT7SV5Hkcw28mS29oRaqO8/0t9vb5yTRStyThYlxcWcCGgBRCSrPrav7h/b/aXlmrZwk9KSTvD4j63ZRp7M1p5QC/X9R/r77Y1ZJovCf0wKAxCxrDbRqLYLKoS7TJnZ2xNqob7/SH+/fWGmyaLwj2kC2qFDh+qee+5x/Tk/P19XXXWVMjIyNGjQIK1YscLt+M8++0y9e/dWRkaGhg0bpj179oS6yQDqgJz2SZrzf9318tVd9Gi/U/Xy1V306a3Zpgtmpdr9Y2u21cXM1p5QC/X9R/r77SsrTxaNdKYIaD///HMtWLDA9edDhw5p6NCh6tatmz7++GNlZmbqtttu06FDhyRJy5cv1/jx4zV8+HC9//772r9/v8aNGxeu5gOwOH/LZoVLbf6xNdvIk9naE2qhvv9If799ZfXJopEs7AFtUVGRnnzySXXu3Nm17YsvvlBsbKzGjBmjtLQ0jR8/XieccILmzZsnSZoxY4b69u2ryy+/XKeeeqqefPJJLViwQIWFheG6DQAIutr8Y2u2kSeztSfUQn3/kf5++6ou1HiOVGEPaJ944glddtllateunWvbsmXLlJWVJZvt2CiJzWbTGWecoaVLl7r2d+vWzXV8ixYt1LJlSy1btiykbQeAUKrNP7ZmG3kyW3tCLdT3H+nvt6+ck0U9MeNkUYQ5oP3555/122+/6c4773TbvmvXLiUnJ7ttS0xM1I4dOyRJO3fu9LgfAMyo3GEor7BIX63aqbzCIr/zFWvzj63ZRp7M1p5QC/X9R/r77Q+rTRbFMWEr21VaWqoHHnhA999/vxo0aOC2r6SkRDEx7h+kmJgYlZUdexRy+PBhj/v9YQvCjyznOYNxbgQHfWY9Vuuz3LV2PVVFuaTROe2Uk+77P5AXpCfpyQGdKp0rJT5Wo3qlVXuuetE2jc5ppzEeypSN6pWmetHBe0OP7zMztCecQn3/Nb2e1b5ngXJBepLOb5eo37fsk/1gmZJOiFFmK/PX662L/eXrvYQtoH3hhRd0+umnq0ePHpX2xcbGVgpOy8rKXIFvdfvj4uL8bkdiYrzfrzHDuREc9Jn1WKHP5q3YrrFz8lVxPHbXf8slvTT4DF18egufz3d1UrwGnXWyFm/Yo53Fh5Uc30DZbZt5/cf26qR4NW7cQA/Nzdf2fYdd21s0aaAH+nfyqw214ewzs7QnXEJ9/7W5nhW+Z8FwcXLjcDehRiKxv8IW0H7++eey2+3KzMyUJFeA+tVXX+nSSy+V3e5eD89ut7vSDFJSUqrc37x5c7/bsXt3sYwAVymx2Y59mIJxbgQHfWY9Vumzcoeh+2evqBTMSnJte+DTlcpMPsHv0Z/2TWLUvsmxp1V79xzw6TXdTmyk2becWeXIk91e7Nf1/VVVn4WzPWYQ6vv393pW+Z7hmLrYX8578iZsAe3bb7+to0f/t/74U089JUkaPXq0fv31V02fPl2GYchms8kwDC1ZskS33367JCkjI0N5eXkaOHCgJGn79u3avn27MjIy/G6HYShonR7McyM46DPrMXuf/b7Ft3JJv2/Zp6zWCSFpU5TNVulaoXwPnX1WcQnW3unNXUG9mfs00ELdHzW5ntm/Z3AXif0VtoA2NTXV7c8nnHCCJKlNmzZKTEzUpEmT9Nhjj+naa6/VzJkzVVJSor59+0qSrrvuOl1//fXq2rWrOnfurMcee0znn3++WrduHfL7AABPKJdUNZZgtb6KP0i6ppo/xxR1V9gCWk8aNWqkqVOn6oEHHtAHH3ygDh06aNq0aWrYsKEkKTMzUw8//LCee+457du3T+ecc44eeeSRMLcaACqjXFJluWuPLcFakXMJVmaSmx8/SGA2NsOItEFpd3Z7cHJok5Lig3JuBAd9Zj1W6bNyh6EB0xd5TDtIiY/Vp7dm1/nRLZtNatqskf7y+L95Pyyiqu9ZbkHVP0ic+EESPlb5e9EfznvyJuwLKwBAXUahdneLN+xhCVYLK3cYmpS7zuMxT89f73eNZaC2CGgBIMgo1P4/O4sPez9IkZdTbBVLt/o2yZEfJAg1U+bQAkBdk9M+ST3TEiN+Ek1yfAPvBymycoqthEmOMKsaB7SGYWjv3r2KiopSQkJCAJsEAHVTdFTlckmRJrttMyU3ivGaQ8sSrObEJEeYlV8B7fbt2zVz5kz98MMPWrNmjRwOhyQpOjpanTp10nnnnaeBAweqZcuWQWksAMDaoqO8L8EaSTnFVtM1tQk/SGBKPgW0e/bs0cSJE5Wbm6uzzz5b1113ndq1a6eEhAQ5HA7t3btXa9as0ZIlS3TZZZepV69eGjt2rBITE4PdfgCAxeSkH8sprlj2KSU+ViN7pUVUTrHVOCc5eqpywA8ShINPZbsGDhyo66+/Xpdeeqnq16/v8diSkhLNmTNH7733nmbPnh2odgYNZbsg0WdWRJ9ZT8U+ozC/+VX3PauqDi0/SMKvLv696GvZLp8C2iNHjngNZAPxmnAgoIVEn1kRfWY99Jn1eOozfpCYT138jvka0PqUcuAMTDdv3qzi4mJ16NBB9eq5v/TIkSNaunSpzjzzTLfXAACAuodJjjATn+rQ/vnnn7rqqqt00UUXadCgQTrvvPM0a9Yst2P27dunG264ISiNBAAAAKrj0wjtI488osTERP3www8yDENvvfWW7r//fq1bt05jx451HRfhq+gCMDkekQJA3eRTQLt48WK99957at68uSRp9OjR6tq1q+666y4dPXpU48ePlyTZbPzDAMCcqprEktwoRqNy2jGJBQAszqeUg7i4OO3du9dtW+/evTV58mS99957euKJJ4LSOAAIhNwCu8bOya9UO3PngTKNnZOv3AJ7mFoGAAgEnwLafv36afz48Zo3b57279/v2t67d2898cQTevvttzVmzJigNRIAaqrcYWhS7jqPxzw9f73KHaRMAYBV+RTQ3nXXXbrwwgv16KOPauXKlW77LrnkEk2fPl0bNmwISgMBoDaWbt3ncVUjSfqzuFRLt+4LUYsAAIHmUw5tTEyMRo8erdGjR1c58esvf/mL/v3vf2vFihUBbyAA1IbdSzDr73EAAPPxaYT2eNVN/IqOjlZGRkatGwQAgZTUKCagxwEAzMfvgBYArKRrahMlewlWU+Jj1TW1SYhaBAAINAJaAH4pdxjKKyzSV6t2Kq+wyPSTqaKjbBqV087jMSN7pVGPFgAszKccWgCQrFvLNad9kp4Y0KlS21PiYzWyV5qp2+4Ni0UAQC0C2gcffFAjRoxQs2bNAtkeACblrOVakbOW6xMDOpk6MMxpn6SeaYlhCf6CFXRa9QcG+CECBFqNA9o5c+bolltuIaAFIoCvtVx7piWa7h/lcAcOwQo6rf4DI5LxQwQIvBoHtFWV7wJQN/lTyzWrdUJoGuWDcAcOwQo6rfwDI9JZ/YdIuH8gAtXxK6A99dRT3cp2XXTRRTIMQzabTatWrQp44wCYgxVruYY7cAhm0GnVHxiRzuo/RML9AxHwxK+A9ttvv5V0bHS2f//+mjZtmlq2bBmUhgEwD6vVcvUlcPjXNwUqPVKu5P+W7Ap0ABHMoNOKPzBg7R8iuWutPbKMus+vgDY1NdXtzyeeeGKlbQDqHmctV0//GJuplqsvgcPekiO6/8s1koIzyhTooPP4R727D/n2GrP8wKiNuvSI26o/RModhp6y8MgyIkONc2hTU1NVrx5Vv4BI4KzlWtUIjZOZarn6GxAEY5QpkKPaVT3qjbJJnkoAm+kHRk3VtUfcVnvS4bR4wx7LjiwjctR4YYXPPvtMLVq0CGRbAJiYs5ZrxVW3UuJjTfe4saYBwdPz1wdsoYhArVDmzAWuGFB4a6aZfmDURHX37fzxkVtgD1PLas6qq9btLD7s03FmG1lGZGGIFYDPwlnL1R++pEhUJZCjTIEY1fYlF7jiSG1dWSzCypOnqmO1Jx1OyfENfDrObCPLiCwEtAD8Eh1lM/1jRV8Ch+oEcpSptiuU+ZIL7DCku84/RYkNY0z7A8NfVp485Y0VV63LbtvMUjn0iEwEtADqpOoCB28CPcpUm1FtX4PrxIYx6tMxubZNNQ2rTp7ylVWedDhFR9k0OqedxlhsZBmRxe+A9tdff1VmZmalCWFlZWX6/vvv1bt374A1DgCqU+4w9PP63Vq/rUhJJ1QdEBwfOOwsLtXT89er6PDRas/ZuEE9lTsMlTuMgP7jXNNRbatOIqqtSLhvKzzpOF5OuvVGlhFZ/A5ob7jhBv3000+VlrwtKCjQyJEjtXz58oA1DgCq4s/s9+MDh9j60R7TEPYfPqphH/3HNDPprVYuLVAi9b7NXqLMaiPLiCw+BbTvvvuuHn74YdlsNhmGoXPOOafK484+++yANg4AKqrNCmA57ZN0fbdWeidvi8cqAWYpFm/VSUS1FYn3bZUSZVYbWUbksBmG4VONml9//VUOh0M33nijnn/+eTVp8r9fxjabTXFxcUpPT1dMjLUeAdntxfLtHfCdzSYlJcUH5dwIDvrMGsodhgZMX+R15O7TW7OrDHaqC4Zrcq5QqirYseKjXn+/Z3Xlvr3x9rkM5w8r/m60lrrYX8578sanEdry8nKdeeaZko4tf9uiRQtFRXkuYXv06FEWXgAQULWZ/e5LKShfzxVqkfqoNxLuu66WKANCzaeFFa666irNnj1bR44cUWpqqsdgtrS0VB9++KGuuuqqgDUSAKTazX73JRiuzTWPV+4wlFdYpK9W7VReYVFAFmtwPurt0zFZWa0TIia4qev37c+PNADV82kI9ZVXXtHEiRM1YcIEnXvuuTr77LOVlpampk2bqry8XEVFRVqzZo3y8vL0/fffq2fPnpo2bVqw2w4gwvg6q333obJKlQpqWuLJ35n0VsmFhDnU9RJlQKj4FNA2a9ZMEyZM0JYtW/TBBx9oxowZWrNmjRwOhyQpOjpaHTp0UI8ePTRr1iy1bt06qI0GEJl8XQFs8nd/6J3ftrgFkTUp8eTvTPraTFhDZIqEEmVAKPiV5NqqVSuNHDlSI0eOVHl5ufbtO/YIpGnTprLZ6tZjIADm488KYBWDyJosh+vPTHpyIVETkVqiDAg0n3Jojzd27Fh9//33ko6N3DZr1oxgFkDIOFcAS/ZxxOrp+etd6Qejctr59JqU+Fi/R1NDmQsZjBxdhIcvn8u6VqIMCAa/yxA0atRI48eP15EjR3TRRRepX79+6t69O0EtgJDJaZ+k89sl6rM1dj3y+SqPxx5fqaC65XCTG8Xo8i4tdFJCXI1n0tc0F9LfYvrk6NY91X0u62KJMiBY/A5o77vvPv3zn//Ur7/+qnnz5mn06NGSpL59++qSSy5R165dA91GAKgkOsqmpPhYn449PogMVimomuRC+huckqNbd0VCiTIgmGpUKNZmsyk7O1vZ2dkaOXKkXnnlFb3++uuaMWOGWrZsqauvvlo33XSTYmN9+8cGAGoiOb6BT8dVDDaDsdqRv7mQ/gan5OjWfazCBdSc3zm0knTw4EF99tlnGj58uM4991x9+eWXuvnmm/Xpp5/q4Ycf1rx583TnnXcGuq0A4Ca7bTOvubShmlDjTy6kr8Hp8bmx1CsFgOr5PUJ7xx13aOHChWrcuLH69u2rt956S126dHHtT09P1/79+zV+/PiANhQAKoqOsml0TjuN8VD1IJQTanzNhazJimfUKwWA6vkd0CYlJWnq1KkeJ4J169ZNH374Ya0bBwDe5KSba0KNL7mQNQlOqVcKANXzO6B95JFHvB7TvHlzNW/evEYNAgB/mW1CjbdcyJoEp9QrBYDq1SiHFgDMxhlE9umYrKzWCaaeGOUMTj2pGJxSrxQAqkdACwAhVtPgtLpFJWqyEAQA1CU1KtsFAKidmhbTN1t6BQCYAQEtAIRJTYNT6pUCgDsCWgAII4JTAKg9cmgBAABgaQS0AAAAsDRSDgBErHKHEfDJVcE4JwDAMwJaACFlloAvt8BeqcJAcqMYjcppV+PyV8E4JwDAOwJaACFjloAvt8CusXPyK23feaBMY+fk16imazDOCQDwDTm0AHxW7jCUV1ikL/P/1Lt5W/Rl/p/KKyxSucPw+lpnwFdx6VZnwJdbYA9Ws92UOwxNyl3n8Zin56/36Z6CeU4AgO8YoQXgk6pGV52OH2WtKqVAkk8BX8+0xKCnHyzduq/Kezjen8WlWrp1n8/ltIJxTgCA7whoAXhV3eN0J+co6/XdWumr1TsrpRRc0aWFaQI+u5d2+HtcsM5ZE2bJTwaAUCOgBeCRL4/Tnd7+bUulbTsPlGnqwk0+vT7YAZ8kJTWKCehxwTqnv8ySnwwA4UAOLQCPfHmcHijBDPicuqY2UbKX66TEx7pSJcJ1Tn+YJT/ZH8587K9W7fQ5DxsAqsMILQCPQjFqKgU34DtedJRNo3LaeUyhGNkrza9H9cE4p698nZAWivxkX+WutespRpMBBBAjtAA8CsWoqRS8gK8qOe2T9MSATpVGVVPiY2tcXisY5/SFPxPSzGDeiu0aY7HRZADmxwgtAI+cj9MDkXYw9Ow2mr18u9u5UuJjNbJXWsACPl8nRuW0T1LPtMSATqIKxjm9McuENF+UOww9NLf6UWzJfKPJAKyBgBaAR748TvdFSnyshnQ/SUO6nxS0gM/fiVHRUbaAV1UIxjk9McOENF/9vmWftu877PEYypsBqAlSDgB4Vd3jdKeU+Fhd362Vx3M4UwqcAV+fjsnKap0Q0GDWahOjAiHcE9L8YT/o2yjxgnW7g9wSAHUNI7SACZmxnujxj9N3Fpdqb8kRNY2rr+T/BkvRUTad3rJxpRHSQKcUVMWKE6MCJZwT0vyVdIJvo8TzVu3UP3qeYoo2A7AGAlrAZMxcT9Tb4/Rw5JBKrNTlHEEPx48Jf3Rp2Vg2m2R4qdC1t+RIne0rAMER1oB206ZNevjhh7VkyRI1adJEgwcP1q233ipJKiws1H333aelS5eqZcuWuvfee3Xuuee6Xrtw4UI9/vjjKiwsVEZGhh577DG1bt06XLcCBER1K3I5H5sHc7Z8oIQ6h1Sy1sSoYAnXjwl/LN+232sw61SX+wpA4IUth9bhcGjo0KFq2rSpPvnkEz300EN66aWXNHfuXBmGoWHDhikpKUmzZs3SZZddpuHDh2vbtm2SpG3btmnYsGEaOHCgPvroIzVr1kx33nmnDF//pgRMyNfH5hSgr8xKE6OCKVj5yYHiaw6tVPf7CkBghW2E1m63q2PHjnrwwQfVqFEjnXzyyfrLX/6ivLw8JSUlqbCwUDNnzlTDhg2Vlpamn3/+WbNmzdLf//53ffjhhzr99NM1ZMgQSdKECRN0zjnnaPHixerevXu4bgmolUh/bF4bnVs0VpRN8hTrR9mOHYfw8TWHtmlcfVNMYgNgHWEboU1OTtYzzzyjRo0ayTAM5eXl6ddff1V2draWLVumTp06qWHDhq7js7KytHTpUknSsmXL1K1bN9e+uLg4nXbaaa79gBXx2Lzm/rN9v8dgVjoW7P5n+/7QNAhVymzVRC2aNPB63Jje7Uw3ugzA3EwxKSwnJ0fbtm1Tr1691KdPHz3++ONKTk52OyYxMVE7duyQJO3atcvjfn/YgvB3pvOcwTg3gsMMfebPY3M+W+595uujbPvBMt67MKoXZdMD/Tvp9hlLqj3m+m6tdGGH5iFsFTwxw9+N8F1d7C9f78UUAe1zzz0nu92uBx98UBMmTFBJSYliYtz/cY+JiVFZ2bF/tLzt90diYnzNGx7GcyM4wtlnFzZrpBZfrdWOfYdV1WCjTdKJTRrowq6tQjJ6Ve4wtHjDHu0sPqzk+AbKbtvMlKNmiYnxSmvp23c/rWWCkpL4XobTxYnxennwGXpobr7bIguJJ8TokctOV78uLcLYOlSHf8+sJRL7yxQBbefOnSVJpaWlGj16tAYNGqSSkhK3Y8rKytSgwbFHVbGxsZWC17KyMjVu7H9+3O7dxT7PuvWVzXbswxSMcyM4zNJnd/U8RWOqqSdq/Hf/3j0Hgt6O3LV2PVVF6bDROe2Uk26OKgvH99kp8fW9Ls+bEh+rU+Lry24vDmErcTxnn53ZopFm33Kmft+yT/aDZUo6IUaZrY5VZKB/zMUsfzfCN3Wxv5z35E1YJ4UtXbpUvXv3dm1r166djhw5oubNm+uPP/6odLwzzSAlJUV2u73S/o4dO/rdDsPwXhOxpoJ5bgRHuPusl5d6or3aJwW9fZ5Kh40xYekww5CibL4tLhBls/GdNAFnn1Wc3EjfmFe4/26EfyKxv8IW0G7ZskXDhw/XggULlJKSIklasWKFmjVrpqysLL322ms6fPiwa1Q2Ly9PWVlZkqSMjAzl5eW5zlVSUqL8/HwNHz489DcCBFg464laecUtqywuAAAIvLAFtJ07d9Zpp52me++9V+PGjdPWrVs1ceJE3X777crOzlaLFi00btw43XnnnZo/f76WL1+uCRMmSJIGDRqkV199VdOmTVOvXr00ZcoUtWrVipJdqDPCsTiBZP3SYVZYXAAAEHhhK9sVHR2tF198UXFxcbrmmms0fvx4XX/99brhhhtc+3bt2qWBAwdqzpw5mjJlilq2bClJatWqlZ5//nnNmjVLV155pYqKijRlyhTZ6tK0PiAM6kLpMLMvLgAACLywTgpLSUnRCy+8UOW+Nm3aaMaMGdW+tmfPnurZs2ewmgZEJFbcAgBYUdhGaAGYT9fUJkr2EqymxMeyihMAwFQIaAGTK3cYyiss0lerdiqvsEjl3pbEqoXoqGPVAjwZ2SuNx/gAAFMxRR1aAFXLLbBXmrWf3ChGo3LaBW3WPtUCAABWQ0ALmJSnerBjg1wPlmoBAAArIaAFTMgM9WDDVToMAAB/kUMLmJA/9WABAIh0jNACJmS1erDlDsMtPaFzi8b6z/b9pCsAAEKCgBYwISvVg61q4lqUTTq+GEOwJ7IBACIbKQeACVmlHqxz4lrF9IiKlcWcE9lyC+whbB0AIFIQ0AImZIV6sL5MXKvo6fnrg1pH14pCWWcYAOoqUg4AkzJ7PVhfJq5V5JzIRvWEY8JRZxgA6iICWsDEvNWDrTgZK5STr2o6Ic0sE9nCzZ86w+HsZwCwAgJawOSqqwcbytG9qgKqmk5IM8NEtnDzp87wgvW7GcUFAC8IaAGT8WU0LpSriFUXON/VK03JjWL8Sjsww0Q2M/C1zvDrizZr6sJNlfaFYrU4ALASAlrARHwZdQ3lKmKeAudxc1fp+m6t9PZvW3w+X7gnspmFr2kX7y3Z6nF/sFeLAwCroMoBYBLVlcCqWPIqVKuI+RI4f71mlyZc2rFSibGK8VVKfCyjicfxNe1i/+GjHvezWhwAHMMILWAC/oy6hmoVMV8D56YN62vO/3VnpTA/OOsMe3p/Gzeo5zWglZhkBwASAS0QNs5c2Z3FpVq+bb/Po66FRSU+nb+2k6/8CZyrmrhGaa7qOesMV5XO4XTtGamaVkX+bEVMsgMAAlogLKrKlfXFzuJSfbJ8u9fjkv87KlobVlp+14q81RnumZao2cu3e/yMMMkOAI4hoAVCrLqJVr7YW3LEpyD48i4tav2I35fH4gRUteOtzrC3UVwm2QHAMUwKA0KoJsvFOqXEx6ppXH2fjj0pIa5G1zieFZbfrQuc6Rp9OiYrq3WC2/vpHMWtOOmOSXYA4I4RWiCEarJcrNPIXmlq0sC3r2yg0gDMvvxuucPQb5uL6vTkM2+juAAAAlogpGoyI/344LHcYYQ8DcCsAVXuWrsmL1is7fsOu7bV1RW0qlstDgBwDCkHQAj5O3J61/mn6NNbs10BWrjSADw9Fg+H3AK7xszJdwtmpco1ewEAkYGAFggh50QrX6TEx+qazNRKwWOk51X6WrO33GGEqEUAgHAj5QAIIV/qjzp5Gmk1axpAKPizUhqP6QEgMhDQAiFW3UQrJ18nXEVqXmWoVkoDAFgHAS0QBsePsO4sLtXekiNqGldfyf+d0BUJI601xYIPAICKCGiBMInUEdbaYsEHAEBFTAoDYCnHV3qobhybBR8AILIQ0AKwnJz2SXpyQCed2KSB2/ZIqfQAAHBHygEAS8pJT9Kgs07WN0u3RFylBwCAOwJaAJYVHWVTt5MSZFByFgAiGikHAAAAsDRGaAGTKncYEblwAgAA/iKgBY5T7jD0+5baBZGBCERzC+yVFl5IbhSjUTntmPAEAEAFBLTAf81bsV33z15RqyAyEIFoboG9yqVxdx4o09g5+cziBwCgAnJoAUm5a+26Y8aSSsX6nUFkboHd+zn+G4jW5hzlDkOTctd5PObp+etV7mAWFAAATgS0iHjlDkNP5a6TpxDRWxAZqEB06dZ9HlfAkqQ/i0u1dOs+j8cAABBJCGgR8QIRRAYqELV7OYe/x9VGucNQXmGRvlq1U3mFRZYfFa5r9wMA+B9yaBFxKk7a2llc6tPrPAWRgQpEkxrF+HQeX4+rqbo2Ka2u3Q8AwB0BLSJKboFdT31boF0Hj7i2NWkQ7dNrPQWRgQpEu6Y2UXKjGI+jvSnxseqa2sSn69VEXZuUVtfuBwBQGSkHiBjOwOb4YFaS9h0u9/raKJu0t+RItfudgagn1QWixz8KX7p1n+7qlebxPCN7pQWtHm1dm5RW1+4HAFA1RmgREcodhh77em2NX+8wpHFzVylqgK3K0bzoKJtG5bSrciTQqapAtKpH4U0ahO9r6U8ucFbrhNA0qhbq2v0AAKrGCC0iwpLCIu0/fNTrcd7GPT2N5uW0T9ITAzpVGqlNiY+t8rF2dWW+9nlpZzBHFM00KS0Q6tr9AACqxggtLMufFbl+Kyzy6ZzewkRvo3k57ZPUMy3Ra7t8eRRe0zbUhlkmpQVq2V+z3A8AILgIaGFJ/s5atwUw5dTbaF50lM1rsOnLo/DatKGmzDIpLVAVCcxwPwCA4CPlAJbjbUWu6T9vqlRr9IxWCQG7fiBG82obkG4uKql1G6rizAX2JJiT0gKx2trxwn0/AIDQIKCFpfjyqH7awk365xerdfsHyzVg+iLlFtiV1TrB62SrhLh6Na5U4K+mDevX6vWzl28PWh6tv7nAgRKsigThuh8AQOiQcgBL8fdR/fG1Ru+9KN1jFYJ/Deqi/fsPa4yflQpqorZn2HmgLKgz833NBQ6kYFYkCMf9AABCh4AWllLTR/VPz1+vT2/N1hMDOlXKz0xpFKtROWm6+PQWstuLqz4mPlYje6UFbDRvz6Hqa9r6Ktgz833JBQ6kYFckCPX9AABCh4AWllLT/FXnyF51I3X1ov83UheK0bxA5OHWtZn5VCQAANQUAS0sxZdZ69Vxjuz5MlIX7NG82tyHVDdn5lORAABQU0wKg6X4Mmu9OmYa2avNfUh1c2Y+FQkAADVFQAtLKXcYatKgnq47I1UJcb5XCjDjyJ632feRODOfigQAgJog5QCWUVXB/YQG9dS3U4oaN6inqQs3Vftas47secvXjcSZ+VQkAAD4i4AWluAsuF9R0eGjem/JVteIZrCrEwSDp3zdSJ2ZH6n3DQCoGQJamJ6vBfc/vTWbkT0AACIQAS1Mz9+C+4zsAQAQWZgUBtMLdsF9AABgbYzQwvQouG9e5Q6DFA8AQNgR0ML0KLhvTlVVnUhuFKNROe1MPQkPAFD3kHIA04uEgvvlDkN5hUX6atVO5RUWqdxhhLtJHjmrTlT8kbHzQJnGzslXboE9TC0DAEQiRmhhCc6C+1Ysy+WN1UY6fa060TMt0dI/MgAA1kFAC8uoiwX3q6uv6xzpNOPqWP5WnQAAINgIaGEpdangvlVHOqk6AQAwGwJaWEZdm1FvlpFOf99Xqk4AAMyGgBaWYLU8U1+YYaSzJu8rVScAAGZDlQOYntlm1AeqIkG4Rzpr+r5GQtUJAIC1hDWg/fPPPzVixAhlZ2erR48emjBhgkpLSyVJhYWFuummm9S1a1f169dPP/74o9trFy5cqEsvvVQZGRm64YYbVFhYGI5bQJD5mmcaqjJXuQV2DZi+SLd/sFz//GK1bv9guQZMX1SjoNo50ulJsEY6a/u+OqtOVGx/SnysKSeyAQDqtrAFtIZhaMSIESopKdE777yjyZMna/78+XrmmWdkGIaGDRumpKQkzZo1S5dddpmGDx+ubdu2SZK2bdumYcOGaeDAgfroo4/UrFkz3XnnnTIMc9fuhGdVjXz6k2cabIEeKQ7nSGcg3tec9kma83/d9fLVXfRov1P18tVd9Omt2QSzAICQC1sO7R9//KGlS5fqp59+UlLSsX8AR4wYoSeeeELnnXeeCgsLNXPmTDVs2FBpaWn6+eefNWvWLP3973/Xhx9+qNNPP11DhgyRJE2YMEHnnHOOFi9erO7du4frllAL1eVypjdv5NPrgz2jPlgVCcJVXzdQ+bt1qeoEAMC6whbQNm/eXK+88oormHU6cOCAli1bpk6dOqlhw4au7VlZWVq6dKkkadmyZerWrZtrX1xcnE477TQtXbqUgNaCPNVi3Xlgj0/n8CXPtDZVEoJZkSAc9XXDnb8LAEAghS2gbdy4sXr06OH6s8Ph0IwZM3TWWWdp165dSk5Odjs+MTFRO3bskCSv+/1hC0LM4DxnMM5d1/gy8ulNSnysMls18fh+566166kqRoBH57RTTnqS1z6zH/RxRPNgWY36vV60Td1OSvD/hTWU2cq3SgXe3tdw4ntmPfSZ9dBn1lIX+8vXezFN2a6JEycqPz9fH330kd544w3FxLiPDMXExKis7Ng/viUlJR73+yMxMb7mjQ7jueuKn9fv9jry6c1Dl52mlOTGlbaXOwwt3rBH3+Tv0Gs/bay0f9d/c19fGnyGLj69haTq+yytpW9tTGuZoKQka/T7w5efrjtmLJEkHZ997vy7o7r31Wz4nlkPfWY99Jm1RGJ/mSKgnThxot58801NnjxZ6enpio2NVVFRkdsxZWVlatCggSQpNja2UvBaVlamxo39/8d39+5iBXoumc127MMUjHPXNQVb99bq9dedkapuJzaS3V7str2qEdmKnF3zwKcrdUbKCUpu3rjaPjslvr5PI5qnxNev1Baz6nZiIz0xoFPlkev4WI3qlVbl+2omfM+shz6zHvrMWupifznvyZuwB7SPPPKI3nvvPU2cOFF9+vSRJKWkpGjdOvfH0Ha73ZVmkJKSIrvdXml/x44d/b6+YShonR7Mc9cVew8dqdXre7ZLrPQeV5eTW50/i0u1pHCfLm7euNo+i7Idq0jg6bwje6UpymYLWZ8HYuW0Xu2TdF41+btW+ezyPbMe+sx66DNricT+CmtA+8ILL2jmzJl6+umndfHFF7u2Z2RkaNq0aTp8+LBrVDYvL09ZWVmu/Xl5ea7jS0pKlJ+fr+HDh4f2BlBr2/YdrvFrq6rRWtOcXF9yZMNVkaAqgVw5jUoFAACrC1tAu379er344osaOnSosrKytGvXLte+7OxstWjRQuPGjdOdd96p+fPna/ny5ZowYYIkadCgQXr11Vc1bdo09erVS1OmTFGrVq2ocGAx5Q5DX63aWePXV1Wj1ZdqBFVJOsG32fzhqEhQkaeqEGPn5LOwAQAg4oQtoP32229VXl6ul156SS+99JLbvjVr1ujFF1/U+PHjNXDgQLVp00ZTpkxRy5YtJUmtWrXS888/r8cff1xTpkxRZmampkyZIltdmtYXAZZu3aeiw0e9HmeT+6QlTyOiNalHmxIfqy4tG+vn9bu1fluRkk7wHKSGc0QzWPVwAQCwsrAFtEOHDtXQoUOr3d+mTRvNmDGj2v09e/ZUz549g9E0hIivwec1mS11fvskn0ZEa1I39aIOzXX5K4sD8vg+2IJZDxcAAKsK+6QwRC5fg8/z2yf5HJx1TfVeX9UpJT5WF3Vorrd/21Jpn1kf3wdqhS8AAOqSqHA3AJHLGXx6UtXEL0+io45VI/DkujNS9fLVXfTxkDP11WrPObxPz1+vcod5poqywhcAAJUR0CJsfAk+q5r45Y2zGkHFYLlpXH1dd0aqerZLVNfUJnrz10KfH9+bRTB+BAAAYHWkHCCs/CmF5U/d1eOrESxYt1tf5v+pvSVH9N6SrXpvyVY1aVBP+3yYkCaZ6/G980eAt3q4TAgDAEQSAlqEVFVBqS+lsGpSdzU6yqZ9h4/qvSVbK+3zNZiVwv/4vuJ71jMt0TT1cAEAMAMCWoSMt6C0uolfNa27WtNFFo4X7sf3nt6zOf/XPaz1cAEAMAtyaFFJucNQXmGRvlq1U3mFRbWeFFXuMPTKz5s0dk5+pZxVZ1CaW2Cv9rW+1F2tqo01XWTheOF8fO8M5Kt7zxas362s1gnq0zFZWa0TCGYBABGLEVq4CeSSqs7zPfVtgXYdPOLxuOoWA6hN3dXa5r7ednabsD2+ZwEFAAB8xwgtXLyNCFY3iurtfN6CWan6agK1qbtam9zX5EYxurn7STV+fW35E8gDABDpCGghqXaP9mt6vopqE5RWdZwvJa6qMyqnXVhHPllAAQAA3xHQQlLgRwRrkr9a06C0uolbvtS5bdzAPesmJT7WFKuDsYACAAC+I4cWkgI/IujvyKGnoPSu89M07rNV1b7W08Qtb3VuXeXCDpYprWWCTomvryhb1efypw5ubfmyhG+4KzAAAGAWBLQWF6ggy9eRvj92H1ReYZHX6/g7clhdUJpbYNfk79ZX+Rpf6656q3Ob1TpBNpuUlBQvu71YRhVZFYGeLOcNCygAAOA7AloLC2SQ5cuIoCS9tqhQry0q9HodX8+X0ihWI3OqDkqrqz/r9P/OP8Xn+4yOslVb59abmtbBrS1/VlEDACCS2QyjqvGoyFHdiFxteBvtCwRvwV5Ngqx/r92lcXOrf7Tv73W8tXHo2W00pPtJVY4yljsMDZi+yOsj909vzQ7IKGV1fRbqdlQllKkOVhKK7xkCiz6zHvrMWupifznvyRsmhVlQoCsSODWNq+93WzxdJ6d9kib076iEaiZe/d9f2lQbmJmlbJUZ2uEcXWYBBQAAqkZAa0HBCrJqUgLK03VyC+yaPH+9ig4fdW1LiKuv/9fTe6qAWcpWmaUdAACgeuTQWlCwgqyaloCq6jrVpRsUlRzRuM9WKSrK5jGoNUvZKrO0AwAAVI8RWgsKVpBV04UIKl4nECkRtak/G0hmaQcAAKgeAa0FBSvI8mUhgoqaNKhX6TqBSInwpS2BKFtV7jCUV1ikeat26uf1uysF2aFqBwAAqDkCWgsKZpDlLBXl60jtvsNHtWD9brdtgUqJqK4tgVrNK7fArgHTF+n2D5brn5+v1nXTf1H/aYuUW2APaTsAAEDtULbLomW7pKrr0AaqRqmzVNTO4lI98e8CHTziqPbYimWr8gqLdPsHy71e4+Wru/hUGzYYZatqUvaM8lnmUhfL09R19Jn10GfWUhf7y9eyXUwKszBvK2DVhrNUVF5hkcdgVvpf+oAzOPV32VZvgWJtFkWoiq85vj3TEoPaDgAAEBgEtBYX7CCrJukD/izbGuolZSX/cnwJYAEAMD9yaOFRTSsq+JJ36nzsXzG4dC4pWzGXNVCoLQsAQN3CCC088jd94HieUiJq+tg/EKgtCwBA3cIILTyqbUWF6pZtDeeSstSWBQCgbiGghVfBKFsVzsf+1JYFAKBuIeUgwvlaiirQFRXC/djfGaQHq+wZAAAIHQLaCFFV4Lpg/W6/KgwEsqJCbXJzA8UtSD9YprSWCTolvr6ibIzMAgBgJQS0FlLTwv5VlcZq3KCe9h8+WulYZ4WBYK+A5U9pr2ByBul1sRg1AACRgoDWImpar7W6FbGqCmaPF6wKA8fjsT8AAAgEAlqTqS41oKqg1NtoarnD0ONfr61RO0K1sEBtc3NZjhYAABDQmkh1o7CHj3peera60dS8wiLt8zIS60moFhaoaW5uOFYZAwAA5kPZLpPwtGqWt/SA6uq1LtlSVKs2mXlhgXCtMgYAAMyHgNYEfFk1y5uqRlNrM7nJzAsL+LrKWLmD2V0AAEQCAloT8GXVLG+qGk3tVov8VzMvLBDOVcYAAID5kENrArXNVa1uNPWM1gmKj41WcWl5ta+1STp+HNMKFQbCucoYAAAwHwJaE6htrmp1o6kL1u/2ukjA4/07qmlcfUtVCQj3KmMAAMBcCGhNwJdVsyT/RlOrqz/r1LhBPY2/KN3UI7HVMcMqYwAAwDwIaE0gOsqmK7q00NSFmzweZ0i66/xTlNgwxuNoqi+TpuLqRatnWqJP7TNbrVezrDIGAADMgYDWJFonxPl0XGLDGPXpmOy27fiAs2nD+irYecD7pKkDvi2cYNZar6wyBgAAnAhoTaKmeaFVBZy+8jZpqrq0BW8rlPmrpiPAtV1lDAAA1A0EtCZQ7jDkcBhq3KCex0UUKuaFesuT9cZTEO1rrdeqVijzR21HgGu6yhgAAKg7qEMbZrkFdg2Yvkh3fvQfryuCHZ8XWtvFGLxNmgpFrVdW+wIAAIFAQBtG1QV0FTWNq6/rzkhVkwb1XKtf1XYxBm+TpoJd65XVvgAAQKCQchAmPlUiqB+l2Ogo7S05oveWbNV7S7a6HscfOeqo0XV9nTQV7Fqv/owAk1IAAAA8IaANE18CupIjDpUccQ9cnY/jh57dxu9r3nX+KbomM9WnnNdg13pltS8AABAopByESW0DtdnLtyvZj9HRlPhYn4NZ6X+1Xj2pTa1XVvsCAACBQkAbJrUN1HYeKNMVXVr4fLyn4LPcYSivsEhfrdqpvMIiV96qs9ZrxcA5JT621iW7nCPAnrDaFwAA8AUpB2Hi63K3nrROiKtycYHjecuZ9VY2K1i1XlntCwAABAoBbZj4EtB506xhfZ3ZpqlbwNm0YX3ZJO05dMRr8OnrwgnBqvXKal8AACAQCGjDqLqALqFBPRV5qUkrSc6CVtUFnJ5W4ArVwgnesNoXAACoLQLaMKsqoNtZXKr7v1zj9bV7Dx2pdp+3VAIzlc1itS8AAFAbBLQmUDGgyyss8ul11U0s8yWVwNc6tvYDZR5HegEAAMKNgNaEfJkw1qRBvSorAPiaSnB/n3Sf2rK5qEQDpi+qdqQXAAAg3CjbZUK+1IDdd/ioFqzfXWm7r6kENslr2awmDepp2sJNlc7nHOnNLbB7fD0AAEAoENCGQHV1Xj3pmZaoxg08D6A/PX99pXP5umDDnkNHvAbN3lpZ1fUBAABCjZSDIPM2Oas6S7fu034vlQ6qmrTlzwpcWa0Tqi2bdXnnEzV14Sa/rk+uLQAACAcC2iDKXetbndeq+DrSWvE4X/Jvj1+Bq7qyWf9es8uv69c0cAcAAKgtUg6CpNxh6CkfJmdV98jen5HW4/mSf1txBS5nlYU+HZOV1TpB0VE2v67vrKpAri0AAAgHAtogWbxhj891XqviHGn15PiR1uM5F2yo+PqU+FiPo8I1uX7nFo19qqpAri0AAAgWUg6CZGfxYZ+Oqy61wJelcSuOtB6vtitw+Xr9/2zfb5oFGgAAQGRihDZIkuMb+HScp0f7tR1prSqVwB++XL+mub4AAACBwghtkGS3bebX5Kzq1Haktba8Xb+mub4AAACBQkAbJNFRNo3OaacxNUwZqHiucD6u93R9f6sqAAAABBopB0GUk177yVmBVpNFHjypSVUFAACAQGKENsjCnTJwvGDVinXm2la1QMPIXmnUoQUAAEFFQBsC4U4ZkOSqFVuRL4s8+MJMgTsAAIgspkg5KCsr06WXXqpFixa5thUWFuqmm25S165d1a9fP/34449ur1m4cKEuvfRSZWRk6IYbblBhYWGom20Z5Q4jJLVia1tVAQAAoCbCHtCWlpZq5MiRKigocG0zDEPDhg1TUlKSZs2apcsuu0zDhw/Xtm3bJEnbtm3TsGHDNHDgQH300Udq1qyZ7rzzThkGxfursnTrvlot8gAAAGBmYQ1o161bp6uvvlqbN2922/7LL7+osLBQDz/8sNLS0nTbbbepa9eumjVrliTpww8/1Omnn64hQ4aoffv2mjBhgrZu3arFixeH4zZMj1qxAACgLgtrQLt48WJ1795d77//vtv2ZcuWqVOnTmrYsKFrW1ZWlpYuXera361bN9e+uLg4nXbaaa79cEetWAAAUJeFdVLYX//61yq379q1S8nJyW7bEhMTtWPHDp/2+8MWhDRP5zmDce6ayGzlW63YzFZNTNPmUDNbn8E7+sx66DProc+spS72l6/3YsoqByUlJYqJcR8tjImJUVlZmU/7/ZGYGF/zhobx3P56+PLTdceMJZKk4zONnZ+Thy47TSnJjUPeLrMxU5/BN/SZ9dBn1kOfWUsk9pcpA9rY2FgVFRW5bSsrK1ODBg1c+ysGr2VlZWrc2P+AbPfuYgV6LpnNduzDFIxz11S3ExvpiQGd9FTFOrTxsRrVK03dTmwku704jC0MLzP2GTyjz6yHPrMe+sxa6mJ/Oe/JG1MGtCkpKVq3zr3MlN1ud6UZpKSkyG63V9rfsWNHv69lGApapwfz3DXRq32SzqumVqyZ2hlOZuszeEefWQ99Zj30mbVEYn+FvWxXVTIyMrRy5UodPnzYtS0vL08ZGRmu/Xl5ea59JSUlys/Pd+1H9agVCwAA6hpTBrTZ2dlq0aKFxo0bp4KCAk2bNk3Lly/XlVdeKUkaNGiQlixZomnTpqmgoEDjxo1Tq1at1L179zC3HAAAAKFmyoA2OjpaL774onbt2qWBAwdqzpw5mjJlilq2bClJatWqlZ5//nnNmjVLV155pYqKijRlyhTZ6tK0PgAAAPjEZkT48lp2e3AmhSUlxQfl3AgO+sx66DProc+shz6zlrrYX8578saUI7QAAACArwhoAQAAYGkEtAAAALA0AloAAABYGgEtAAAALI2AFgAAAJZGQAsAAABLI6AFAACApRHQAgAAwNIIaAEAAGBp9cLdgHCz2YJ3zmCcG8FBn1kPfWY99Jn10GfWUhf7y9d7sRlGXVntFwAAAJGIlAMAAABYGgEtAAAALI2AFgAAAJZGQAsAAABLI6AFAACApRHQAgAAwNIIaAEAAGBpBLQAAACwNAJaAAAAWBoBbQ2VlZXp0ksv1aJFi1zbCgsLddNNN6lr167q16+ffvzxR7fXLFy4UJdeeqkyMjJ0ww03qLCwMNTNjkh//vmnRowYoezsbPXo0UMTJkxQaWmpJPrMrDZt2qRbbrlFmZmZOv/88/XKK6+49tFn5jZ06FDdc889rj/n5+frqquuUkZGhgYNGqQVK1a4Hf/ZZ5+pd+/eysjI0LBhw7Rnz55QNzliffPNN+rQoYPbfyNGjJBEv5lRWVmZHnroIZ155pk6++yz9fTTT8u52Cv9RUBbI6WlpRo5cqQKCgpc2wzD0LBhw5SUlKRZs2bpsssu0/Dhw7Vt2zZJ0rZt2zRs2DANHDhQH330kZo1a6Y777xTrDwcXIZhaMSIESopKdE777yjyZMna/78+XrmmWfoM5NyOBwaOnSomjZtqk8++UQPPfSQXnrpJc2dO5c+M7nPP/9cCxYscP350KFDGjp0qLp166aPP/5YmZmZuu2223To0CFJ0vLlyzV+/HgNHz5c77//vvbv369x48aFq/kRZ926derVq5d+/PFH13+PPvoo/WZSjz76qBYuXKhXX31VkyZN0gcffKD333+f/nIy4JeCggJjwIABRv/+/Y309HTjl19+MQzDMBYuXGh07drVOHjwoOvYG2+80XjuuecMwzCMZ555xhg8eLBr36FDh4zMzEzX6xEc69atM9LT041du3a5ts2dO9c499xz6TOT+vPPP41//OMfRnFxsWvbsGHDjAceeIA+M7G9e/ca5513njFo0CBj7NixhmEYxocffmjk5OQYDofDMAzDcDgcxoUXXmjMmjXLMAzDuPvuu13HGoZhbNu2zejQoYOxefPm0N9ABBo1apQxadKkStvpN/PZu3ev0alTJ2PRokWubVOnTjXuuece+uu/GKH10+LFi9W9e3e9//77btuXLVumTp06qWHDhq5tWVlZWrp0qWt/t27dXPvi4uJ02mmnufYjOJo3b65XXnlFSUlJbtsPHDhAn5lUcnKynnnmGTVq1EiGYSgvL0+//vqrsrOz6TMTe+KJJ3TZZZepXbt2rm3Lli1TVlaWbDabJMlms+mMM86otr9atGihli1batmyZSFte6Rav369Tj755Erb6TfzycvLU6NGjZSdne3aNnToUE2YMIH++i8CWj/99a9/1b333qu4uDi37bt27VJycrLbtsTERO3YscOn/QiOxo0bq0ePHq4/OxwOzZgxQ2eddRZ9ZgE5OTn661//qszMTPXp04c+M6mff/5Zv/32m+6880637d76Y+fOnfRXmBiGoQ0bNujHH39Unz591Lt3bz311FMqKyuj30yosLBQqampmj17ti6++GJdcMEFmjJlihwOB/31X/XC3YC6oqSkRDExMW7bYmJiVFZW5tN+hMbEiROVn5+vjz76SG+88QZ9ZnLPPfec7Ha7HnzwQU2YMIHvmQmVlpbqgQce0P33368GDRq47fPWH4cPH6a/wmTbtm2u/nnmmWe0ZcsWPfroozp8+DD9ZkKHDh3Spk2bNHPmTE2YMEG7du3S/fffr7i4OPrrvwhoAyQ2NlZFRUVu28rKylx/wcfGxlb68JSVlalx48ahamLEmzhxot58801NnjxZ6enp9JkFdO7cWdKxoGn06NEaNGiQSkpK3I6hz8LrhRde0Omnn+72JMSpuv7w1l8Vn4Ah8FJTU7Vo0SI1adJENptNHTt2lMPh0N13363s7Gz6zWTq1aunAwcOaNKkSUpNTZV07EfJe++9pzZt2tBfIuUgYFJSUmS329222e121zB/dfubN28esjZGskceeUSvv/66Jk6cqD59+kiiz8zKbrfr3//+t9u2du3a6ciRI2revDl9ZjKff/65/v3vfyszM1OZmZmaO3eu5s6dq8zMTL5jJpeQkODKu5SktLQ0lZaW8j0zoebNmys2NtYVzEpS27ZttX37dr5n/0VAGyAZGRlauXKlDh8+7NqWl5enjIwM1/68vDzXvpKSEuXn57v2I3heeOEFzZw5U08//bQuueQS13b6zJy2bNmi4cOH688//3RtW7FihZo1a6asrCz6zGTefvttzZ07V7Nnz9bs2bOVk5OjnJwczZ49WxkZGfr9999dZdMMw9CSJUuq7a/t27dr+/bt9FcI/PDDD+revbvbE49Vq1YpISFBWVlZ9JvJZGRkqLS0VBs2bHBt++OPP5Samsr3zCl8BRas7/iyXUePHjX69etn/L//9/+MtWvXGlOnTjW6du1qbN261TAMwygsLDQ6d+5sTJ061Vi7dq3xj3/8w+jfv7+rzAaCY926dUbHjh2NyZMnGzt37nT7jz4zp6NHjxoDBw40hgwZYhQUFBjfffedcfbZZxtvvPEGfWYBY8eOdZUIKi4uNs466yzjkUceMQoKCoxHHnnEOOecc1xl15YsWWKcdtppxgcffGCsWrXKGDx4sHHbbbeFs/kRo7i42OjRo4cxcuRIY/369cZ3331nnHvuuca0adPoN5MaOnSocc011xirVq0yvv/+e+Oss84y3nzzTfrrvwhoa+H4gNYwDGPjxo3G3/72N+P00083LrnkEuOnn35yO/67774zLrroIqNLly7GjTfeWOdqwJnR1KlTjfT09Cr/Mwz6zKx27NhhDBs2zDjjjDOMc845x3jppZdcQSl9Zm7HB7SGYRjLli0zLr/8cqNz587GlVdeaaxcudLt+FmzZhk9e/Y0unbtagwbNszYs2dPqJscsdauXWvcdNNNRteuXY1zzjnHeP75513fM/rNfPbv32/cfffdRteuXY2//OUv9FcFNsNgCR0AAABYFzm0AAAAsDQCWgAAAFgaAS0AAAAsjYAWAAAAlkZACwAAAEsjoAUAAIClEdACAADA0ghoAaAO2L17twYOHKgjR47IMAy98847rn0ffPCBJk+eHMbWAUBwEdACQB0wceJE/e1vf1P9+vX166+/6uGHH3btGzhwoL7++mu3deABoC4hoAUAi9uyZYu+/fZb9e/fX5JUcQHIevXq6YorrtD06dPD0TwACDqWvgUAC/jnP/8pu92ul19+2bXtkUce0f79+3XiiSdqy5Ytmjx5srZs2aILLrjAdcxbb72l7t27a/369Ro4cKB++OEHNW7cOBy3AABBwwgtAFjAJZdcop9++kkHDhyQJDkcDn311Ve65JJL9MMPP+jss8+WJLVo0ULPP/+8JOnHH39UZmamJCktLU1NmjTRr7/+Gp4bAIAgIqAFAAvo3r27mjRpotzcXEnSb7/9piNHjuicc87RmjVrlJaWJkmKjo5WkyZNJEnNmzdXTEyM6xzt2rVTfn5+6BsPAEFGQAsAFhAVFaW+fftq3rx5kqQvv/xSF154ofbv3y+Hw6GmTZt6PUdCQoJ2794d7KYCQMgR0AKARVx66aX68ccfdeDAAX3zzTe65JJLZLPZJB1LQfDG4XAoKoq/9gHUPfzNBgAWkZGRoZSUFE2fPl2GYSg7O1sJCQmKjo7W3r17Xcc5g9yK9u7dq6SkpFA1FwBChoAWACykX79+ev3113XxxRcrOjpaUVFROvXUU7VmzRrXMXFxcZKkFStWqLS01LV97dq1Ou2000LeZgAINgJaALCQfv36qbS0VP369XNt69Gjh5YsWeL6c4cOHXTOOefo2muv1YIFCyRJf/zxhw4ePKjs7OyQtxkAgq1euBsAAPCd3W5XamqqzjjjDNe2QYMGaeDAgSopKVFcXJxiYmL02muvub3uiy++UP/+/V2jtwBQlzBCCwAWsHPnTn355ZeaOHGirrzySrc82ZNOOkk9e/bU3Llzq3ztkSNH9Omnn2rIkCGhai4AhBQBLQBYQHFxse699141bdpUN998c6X9Y8eO1TvvvKOysrJK+2bNmqU+ffq4atUCQF3D0rcAAACwNEZoAQAAYGkEtAAAALA0AloAAABYGgEtAAAALI2AFgAAAJZGQAsAAABLI6AFAACApRHQAgAAwNIIaAEAAGBp/x/uJ3uxHywqtQAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -157,7 +142,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "769cb73481bd34c1", "metadata": { "ExecuteTime": { @@ -169,10 +154,8 @@ "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -184,7 +167,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "11d12a5fcc64775a", "metadata": { "ExecuteTime": { @@ -196,10 +179,8 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABLsAAAMrCAYAAAChx5A2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeXhU5d0+8PvMPskkGbJCEiAhYRGEsKMmKqvW1lrFpbWtrdXfa6si2kWRooiAira2CthWX21tX9+3at23WgERDa6syp5AAklIyDrJTGafOb8/JjMkMEnmzJLZ7s91cV06Z5bnnDwzMHe+z/cRRFEUQURERERERERElABk0R4AERERERERERFRuDDsIiIiIiIiIiKihMGwi4iIiIiIiIiIEgbDLiIiIiIiIiIiShgMu4iIiIiIiIiIKGEw7CIiIiIiIiIiooTBsIuIiIiIiIiIiBIGwy4iIiIiIiIiIkoYDLuIiIiIiIiIiChhKKI9gGhrazNCFKM9itAIApCVlZYQ50LRwTlEoeIcolBxDlGoOIcoFJw/FCrOIQoV51BgvNdpMEkfdokiEmYiJdK5UHRwDlGoOIcoVJxDFCrOIQoF5w+FinOIQsU5FB5cxkhERERERERERAmDYRcRERERERERESUMhl1ERERERERERJQwGHYREREREREREVHCYNhFREREREREREQJg2EXERERERERERElDIZdRERERERERESUMBh2ERERERERERFRwmDYRURERERERERECYNhFxERERERERFRGAiCALlcBkEQoj2UpKaI9gCIiIiIiIiIiOKZXC6DoFIgRaOAweKAXquE2eqEaHfC5XJHe3hJh2EXEREREREREVGQ5HIZtDo11m2txobKWl/YtbSiGMvmlcBisjHwGmIMu4iIiIiIiIiIgiSoFFi3tRprNlX5bjNYHFi96QgA4M7yIsBij9LokhN7dhERERERERERBUEQBKRoFNhQWev3+PrKGqRoFOzhNcQYdhERERERERERBUEmE2CwOGCwOPweN1gc6LQ4IZMx7BpKDLuIiIiIiIiIiILgdovQa5XQa5V+j+u1SmRoFXC7xSEeWXJj2EVEREREREREFARRFGG2OrG0otjv8Tsqij27MooMu4YSG9QTEREREREREQVJtDuxbF4J3KKIjdtP78a4pLwId1YUw2mxRXuISYdhFxERERERERFRkFwuNzoMZkwv1KPu/oUw2ZzQa5X44HALKp7aju+OzcZvKoqiPcykwrCLiIiIiIiIiCgEte1mLH7+K4wepsWOX5wHo82JhlYTDjWbcKTFhIuKhmHOSD1kMgFut8hljRHGsIuIiIiIiIiIKATHDVYAgE4p8zWjv3piHrYea8c3Ld1QaFVI02t9SxzNVidEuxMulzuaw05YDLuIiIiIiIiIiEJw3GABAIzWa/vc/vhl46FJ02L9J8dw/f/u8oVdSyuKsWxeCSwmGwOvCGDYRUREREREREQUAm9l1+gMTZ/bU3UaPFF5DGs3V/luM1gcWL3pCADgzvIiwGIfsnEmC1k0X9xut+PBBx/ErFmzcMEFF+APf/iDb93qgQMHcO2116KsrAxXX3019u3b1+ex77zzDhYuXIiysjLcfvvtaG9vj8YpEBEREREREVGSO955dmWXIAhI0SiwobLW72PWV9YgRaOAIAhDMcSkEtWwa+3atfj000/x3HPP4fHHH8fLL7+Ml156CWazGbfccgtmzpyJ1157DdOmTcPPf/5zmM1mAMDXX3+NFStWYMmSJXjppZfQ1dWF5cuXR/NUiIiIiIiIiChJ+Sq79Kcru2QyAQaLAwaLw+9jDBYHOi1OyGQMu8ItassYDQYDXn31Vfztb3/DlClTAAA33XQT9u7dC4VCAbVajXvuuQeCIGDFihX4+OOP8f7772Px4sV44YUXcNlll+HKK68EADz22GOYN28e6urqMHLkyGidEhERERERERElGVEU/fbscrtF6LVK6LVKv4GXXqtEhlYBo81/GEbBi1rYtXPnTuh0OsyePdt32y233AIAuP/++zFjxgxfKZ8gCJg+fTr27NmDxYsXY+/evfiv//ov3+NGjBiB/Px87N27V3LYlQjVgt5zSIRzoejgHKJQcQ5RqDiHKFScQxQKzh8KFedQcms1O2B2uCEAGJmh6TUPRFisTiytKPb16OptaUUxLFYnAJFzKECBXp+ohV11dXUoKCjAG2+8gb/85S9wOBxYvHgxbr31VrS0tKC0tLTP/bOyslBV5Wno1tzcjNzc3LOONzU1SR5HVlZa8CcRYxLpXCg6OIcoVJxDFCrOIQoV5xCFgvOHQsU5lJyquzsAAIV6DQqGZ5x1/N75nnxjfWVNn90Y751fCo1SDujUvvtyDoVH1MIus9mM48eP48UXX8QjjzyClpYWrFy5ElqtFhaLBSqVqs/9VSoV7HbPDgVWq3XA41K0tRnR0xM/bgmC5w2RCOdC0cE5RKHiHKJQcQ5RqDiHKBScPxQqzqHktre2DQAwMk2N1lbjWcflchnuKi/CsvmlOGW0IS9NDavNCYvJCpPLDYBzKFDe6zSYqIVdCoUCJpMJjz/+OAoKCgAAJ0+exD//+U+MHj36rODKbrdDo/E0elOr1X6Pa7VaSCWKSJiJlEjnQtHBOUSh4hyiUHEOUag4hygUnD8UKs6h5FTb069rVIbW78/f6XQDTjue+7wWf9/TiGnDdfj9peP9PhfnUHhEbTfGnJwcqNVqX9AFAMXFxWhsbEReXh5aW1v73L+1tdW3dLG/4zk5OZEfOBERERERERFRD387MfqTqVFiX5MRB5u7h2JYSS1qYVdZWRlsNhtqamp8tx07dgwFBQUoKyvD7t27IfbEmaIoYteuXSgrK/M9dufOnb7HNTY2orGx0XeciIiIiIiIiGgonPBWdukHXm1WkO7pzdXQZY34mJJd1MKuMWPGYO7cuVi+fDkOHTqETz75BM888wyuv/56fOtb30JXVxceeughVFdX46GHHoLFYsFll10GALj++uvx5ptv4l//+hcOHTqEe+65B3PnzpW8EyMRERERERERUSgCrewqTPccbzLZ4ejp1UWREbWwCwB+//vfY9SoUbj++uuxbNky/OhHP8INN9wAnU6Hp59+Gjt37sTixYuxd+9ePPPMM0hJSQEATJs2DatXr8ZTTz2F66+/HhkZGXjkkUeieSpERERERERElGRsTjdOGm0AgNGDVHZlpyihlgsQATSabEMwuuQVtQb1AJCWlobHHnvM77EpU6bg9ddf7/exixcvxuLFiyM1NCIiIiIiIiKiAdV3WSEC0CplyElRDnhfQRBQkK7BsQ4LGrpsGJUhfZM9CkxUK7uIiIiIiIiIiOLVCe8SxgwtBEEY9P7evl31nezbFUkMu4iIiIiIiIiIgnC809OcfrB+XV4FPX276ru4jDGSGHYREREREREREQXhdHP6wJYkFnJHxiHBsIuIiIiIiIiIKAjHDcFVdjWwsiuiGHYREREREREREQVBamVXASu7hgTDLiIiIiIiIiIiiURRPF3ZlRFYZddIb88uow2iKEZsbMmOYRcRERERERERkUQdVieMdhcAYGSAYdeINE9lV7fdhU6bM2JjS3YMu4iIiIiIiIiIJPJWdQ3XqaBVygN6jFYpR3aKEgD7dkUSwy4iIiIiIiIiIomk9uvyKuxZyljXyb5dkcKwi4iIiIiIiIhIIqk7MXqxSX3kMewiIiIiIiIiIpLIV9mVIa2yq6CnsovLGCOHYRcRERERERERkUTHO0Or7KpnZVfEMOwiIiIiIiIiIpLIW9k1SmLYNZKVXRHHsIuIiIiIiIiIAACCIEAul0EQhGgPJaY5XG5fzy3pyxjZsyvSGHYRERERERERJTm5XAaFVoU0vRYOpRxpei0UWhXkcsYG/jR02eAWAY1ChlydStJjvT27mkx2OFzuSAwv6SmiPQAiIiIiIiIiih65XAatTo11W6uxobIWBosDeq0SSyuKsWxeCSwmG1wMZfrw7sQ4KkMDmcQquOwUJdRyATaXiEaTDaMkVobR4BjREhERERERESUxQaXAuq3VWLOpCgaLAwBgsDiwetMRPLr1KAQV62TOdLwzuH5dgGepqLe6q76TfbsigWEXERERERERUZISBAEpGgU2VNb6Pb6+sgYpGgV7eJ3BW9k1Wh9cVRb7dkUWwy4iIiIiIiKiJCWTCTBYHL6KrjMZLA50WpyQyRh29XbC4G1OL72yCzjdt6ueOzJGBMMuIiIiIiIioiTldovQa5XQa5V+j+u1SmRoFXC7xSEeWWw73hlaZVchK7siimEXERERERERURIRBAFyuQyCIKCh04KPj7ZhSXmR3/surSiG2eqEKDLs6u24t7IriJ5dAFDYU9nVwMquiGCXOSIiIiIiIqIkIJfLIKgUSNEofDsuNrZ2Y2NlLZ6/fhoEQcCGyhq/uzHSaQarAwarEwCC3kmxwBd2sbIrEhh2ERERERERESU4uVwGrU6NdVursaGy1hdoLSkvwvPXT4Oh04y7yotw7/xSnDLakKdTw2p3wmKyweVyR3v4McXbrysnVYlUlTyo5/AuY6w32iCKIjcACDOGXUREREREREQJTlApsG5rNdZsqvLdZrA4sHZzFWSCgDvLi+C02PH8jjr8eUc9xmdq8afvToziiGOXbyfGIKu6AGBEmifs6ra70GlzYlg/PdMoOOzZRURERERERJTABEFAikaBDZW1fo+vr6xBikYBQRCQnaLEviYj9jWbhnaQceR4Z2j9ugBAq5QjO8UTcNV3ciljuDHsIiIiIiIiIkpgMpkAg8UBg8Xh97jB4kCnxQmZTPA1Tq/vsrEpfT98lV1B7sTo1ftaU3gx7CIiIiIiIiJKYG63CL1WCX0/S+X0WiUytAq43SLy0/sur6OzhboTo1dBz7Vmk/rwY9hFRERERERElMBEUYTZ6sTSimK/x5dWFMNsdUIURaQo5cji8roBhauy6/SOjKzsCjeGXUREREREREQJTrQ7sWxeCe5bONZX4aXXKrFy0Tgsm1cC0X66imtkTwhTxxDmLG5RhD5FhexUFUZnhFbZ5duRkZVdYcfdGImIiIiIiIgSnMvlhtloxayRetTdvxBGqxPDUpQwW52wmGxwudy++xamq7GnycjKrl7kchkElQIpGgVevXEWcnUq2O1OiHZXn2snRSEruyKGYRcRERERERFREmjotOJ7f/sKeToV9iy5AEa7028T+sIMbwjDsAvwBF1anRrrtlZjQ2UtDBYH9FolllYUY9m8krPCwkCxZ1fkMOwiIiIiIiIiSgLV7WYAQIpSDpkIiPC/22IBdwnsQ1ApsG5rNdZsqvLdZrA4sHrTEQDAneVFgMUu+Xm917nJZIcjyOow8o89u4iIiIiIiIiSwNGesKskc+DG6t5eUnWsOIIgCEjRKLChstbv8fWVNUjRKCAIguTnzk5RQi0XIAI4aWSwGE4Mu4iIiIiIiIiSQHWbJ+wqzUwZ8H4je5YxsmcXIJMJMFgcMFgcfo8bLA50WpyQyaSHXYIgcEfGCGHYRURERERERJQEjrZbAAAlg4Rd3sbprWYHLA5XxMcVy9xuEXqt0reD5Zn0WiUytAq43f6XhA6mgDsyRgTDLiIiIiIiIqIk4O3ZNVhll16jQIrSExck+/I6URRhtjqxtKLY7/GlFcUwW/03+g8Ed2SMDIZdRERERERERAnO5nSjrmdZYukgPbsEQcDIdC5l9BLtTiybV4L7F431VXjptUqsXDQOy+aVQLQ7g37uQt9mALzO4cTdGImIiIiIiIgSXE2HBSKANJUcOamqQe9fmKHB4TYzm9QDcLncsJhsuG7KCNwzrxTt3Q7kpqlgtjphMdngCmEnRe8yRlZ2hRcru4iIiIiIiIgSnG8nxqyUgHYO9FUcdTKEATyB1++2VKH4oS34369OwGiwwGmxhxR0AejVoJ6hYjgx7CIiIiIiIiJKcN5+XSXDBl7C6OWrODIyhPHa39yN1m47MtXyoHt0nanQ16DeFrbnJIZdRERERERERAnvaIDN6b0KM9izqze3KOJgiwkAMDFXF7bnHZHmCbu67S50WBxhe95kx7CLiIiIiIiIKMFVt1sAACUBhl3eBvV17CUFADhusMDscEMtF1AySIN/KbRKObJTPE3vT3RYwva8yY5hFxEREREREVECE0XxdGVXVoCVXT3L6xqNNrjcXF63v7kbADAhJxUKWXijFG9/tBMGhl3hwrCLiIiIiIiIKIG1WxwwWJ0AgOIAe3bl6dRQyAQ43SJOmVjdtb+5ZwljTviWMHp5g0VWdoUPwy4iIiIiIiKiBHa0ZwljYboaKUp5QI+RywRfP6l6LmX0hV2Twtivy6uAlV1hx7CLiIiIiIiIKIH5dmIMsF+X18ieiqO6LjapPxDRsEuN7FQVABGCIIT9+ZORItoDICIiIiIiIqLIOeoLu6Q1Vi/M0AB1nUm/I2On1eFr1D8xNzWszy2Xy/D9mSPxy4Xj0Npthy5NDbPVCdHuhMvlDutrJROGXURERERERBRXBEGATCbA7RYhimyePphgK7sK0jzL6xqSfBnjgRZPc/qCNDX0GmXYnlcul0GrU+OFrdXYUFkLg8UBvVaJpRXFWDavBBaTjYFXkBh2ERERERERUVyQy2UQVAqkaBS+YIBVMIM72ubpBVUqMewqzPD27Eruyi7vEsaJYV7CKKgUWLe1Gms2VfluM1gcWL3pCADgzvIiwGIP62smC/bsIiIiIiIiopjnrYJ5YnsNRjy4yffnye210OrUkMv59dYfp9uN2p7G59J7dnkqu5J9GeP+Zk9l16QwLmEUBAEpGgU2VNb6Pb6+sgYpGgV7eAUpqp8GmzZtwvjx4/v8Wbp0KQDgwIEDuPbaa1FWVoarr74a+/bt6/PYd955BwsXLkRZWRluv/12tLe3R+MUiIiIiIiIaAj0roIxWBwATlfBPLr1KAQVFy75c8JghcMtQquQoaCn4XygCjM8YVddlzWpl4vubwl/c3qZTIDB4vDN5TMZLA50WpyQyRh2BSOqYVd1dTXmzZuHyspK35+1a9fCbDbjlltuwcyZM/Haa69h2rRp+PnPfw6z2bPO+Ouvv8aKFSuwZMkSvPTSS+jq6sLy5cujeSpEREREREQUIayCCd7RDk9VV/EwLWQSr09+miccMzvcMFidYR9bPHC5RRxu8VZ2hS/scrtF6LVK6LX+e4DptUpkaBVwu5M3ZAxFWMKu9vb2oFLeo0ePYty4ccjJyfH9SU9Px3vvvQe1Wo177rkHJSUlWLFiBVJTU/H+++8DAF544QVcdtlluPLKKzFhwgQ89thj2LZtG+rq6sJxOkRERERERBRDWAUTvKNtnqIRqf26AECrlCM7xRPGJGvfrmMdZlicbmiVMhTppe1mORBRFGG2OrG0otjv8aUVxZ5+dElcURcKyWHXqVOn8Mtf/hIHDx6EzWbDj3/8Y5SXl2P+/Pk4dOiQpOc6evQoioqKzrp97969mDFjhi+VFwQB06dPx549e3zHZ86c6bv/iBEjkJ+fj71790o9HSIiIiIiIopxrIIJnncnxjGZwQU1vqWMSdq3y9uv65zsVMjDHKaKdieWzSvBykXjfHNbr1Vi5aJxWDavBKI9OavpwkHyouZVq1bBbDZDr9fjtddew5EjR/Diiy/irbfewpo1a/C///u/AT2PKIqoqalBZWUlnn76abhcLnzrW9/C0qVL0dLSgtLS0j73z8rKQlWVZ4eC5uZm5ObmnnW8qalJ6ukgEapcveeQCOdC0cE5RKHiHKJQcQ5RqDiHKBScP/FAxEmDBUvKi7B2c9VZR5dWFMNidQIQo/JzjOU5dLQn7CrNSglqfCPTNdjTaERDly0mzy/SDnj7deXpwn7+brcb1m4b7iovwvIFpWgy2pCdqkKjwQprtw1utzspr/lAAr0eksOuzz//HK+99hpGjBiBzZs3Y8GCBSgrK0NmZiYuv/zygJ/n5MmTsFgsUKlUeOKJJ1BfX4+1a9fCarX6bu9NpVLBbvdsuWm1Wgc8LkVWVprkx8SqRDoXig7OIQoV5xCFinOIQsU5RKHg/IldVS0m/OSfu/HWTbMBABu318JgcUCvVWJpRTHunV8KjVIO6KQ1YA+3WJxDxwyeiqyZY7KRnS19fGOHpwGHW9DqcAf1+HhX3XP9ZhdnRfz8//plHf78aS1unDUSj10+MaKvlegkh11qtRo2mw2dnZ344osv8PjjjwMA6uvrkZGREfDzFBQU4IsvvkBGRgYEQcA555wDt9uNu+++G7Nnzz4ruLLb7dBoNL4x+Duu1Uovy2xrMyLel8AKgudDNRHOhaKDc4hCxTlEoeIcolBxDlEoOH9ikyAIkMkEdFocuPzvO1HVZsZtr3yNv1w9GcsXjMUpow25OjVsdicsJitMLncUxxqbc8hoc6LJaAMAZMuA1laj5OfIUnq6H1Wf6grq8fFud30nAGB0iiKi5y8IQGl2Clq77fjwcDNazxsZsdeKZ9732mAkh10LFy7EXXfdBY1Gg4yMDMydOxfvvfceHn74YVx11VWSnkuv1/f5/5KSEthsNuTk5KC1tbXPsdbWVt/Sxby8PL/Hc3JypJ4ORBEx9WEUikQ6F4oOziEKFecQhYpziELFOUSh4PyJDXK5DIJKgRSNAgaLA7nZGjz63Un440fVeODiYritDrx5oAkPf1KLnBQlXrx2SrSH7BNrc6iqpzl9TqoSaWpFUGMrSPcUndR32mLq3IZCh8WBkz1h4cQcXcTP/+IxWQCAvU1GGK1O6NSSIxvqIblB/apVq/CDH/wAs2bNwt///ndfldUvfvEL/OpXvwr4eT755BPMmTMHFovFd9vBgweh1+sxY8YM7N6927frgCiK2LVrF8rKygAAZWVl2Llzp+9xjY2NaGxs9B0nIiIiIiKi+COXy6DVqfHE9hqMeHATRjy4CYVrNmFXvQHv/td5yM/wrObJTlFhX5MR+0+Zojzi2Ha03fN9O5idGL1GpnuWhtYl4W6M+5s982tUhgZpQxA8jRqWglEZGrhE4KuGroi/XiKTHHYtXboUF154IVasWOFrIn/llVfixz/+sW/3xEBMmzYNarUa9913H44dO4Zt27bhsccew//7f/8P3/rWt9DV1YWHHnoI1dXVeOihh2CxWHDZZZcBAK6//nq8+eab+Ne//oVDhw7hnnvuwdy5czFyJMv8iIiIiIiI4pWgUmDd1mqs2VQFg8UBADBYHFi7uQq//+goBJUncMhP8wQwLd122KO4fDHWeZvTl4QQdnl3Y2wzO2B2uMIyrnjhDbsm5eqG7DXPG+lpD/VZvWHIXjMRSQ67du3aBYUi9ERTp9PhueeeQ3t7O66++mqsWLEC3//+9/H//t//g06nw9NPP42dO3di8eLF2Lt3L5555hmkpHjeoNOmTcPq1avx1FNP4frrr0dGRgYeeeSRkMdERERERERE0SEIAlI0CmyorPV7fH1lDVI0CgiCgOwUJdRyASKAxp5lZnS2am/YNUx6f2uvDLUCqSo5AOBkV3Jd6wPN3QCASbmpQ/aaF4zUAwA+O2EYstdMRJJTqx/+8If45S9/iR/84AfIz8+HWt13t4tZs2YF/Fxjx47F3/72N7/HpkyZgtdff73fxy5evBiLFy8O+LWIiIiIiIgodslkAgwWh6+i60wGiwOdFicUMgGiKGBEmhq1BitOGm0YrQ8+zElkvsqurOAruwRBQGG6GodbzajvsqI0hOeKN/tbhr6y6/xRegDA7kYjzA4XUpTyIXvtRCI57PrTn/4EAFi5cuVZxwRBwMGDB0MfFRERERERESUVt1uEXquEXqv0G3jptUpkaBUw2jzHCtI1qDVY0ZBk1UaBcosijoWhZxcAjEzX4HCrGXWdydO3y+l243Crp7JrYs7QhV1Feg1G6FRoNNmx82QXLhw9bMheO5FIDrsOHToUiXEQERERERFREhNFEWarE0srirF605Gzji+tKIbZ6vRtZFbQ0zi9IQkbpwfipNEGi9MNhUzAqJ6+W8Hy9u2qT6JrXd1mgd0lIlUlxyh9aNdPCkEQcP4oPV470IzPThgYdgVJcs8uAHC5XPjoo4/w/PPPo6urC3v37oXRaAz32IiIiIiIiCiJiHYnls0rwX0Lx0KvVQLwVHStXDQOy+aVQLQ7fff1Nqk/yZ5dfh1t8yxhLNJroJQH9dXf53SwmDzX2ruEcWJOKmQSNuMLh/O9fbvqDEP6uolEcmVXY2MjbrrpJnR2dqKzsxMLFizAs88+i927d+PZZ5/FhAkTIjFOIiIiIiIiSnAulxuHGwyYXqhH3f0L0W1zIUOrgNnqhMVkg6vXzosF6Z5qm2QKYKQ42uFZwhjKToxehenJV9l1IAo7MXqd37Mj486TXbA53VArQgsrk5HkK7Z69WrMnDkTn3zyCVQqFQDgD3/4Ay644AI89NBDYR8gERERERERJY/Pjhuw+PmvcNVzX0LhcMJosMBpsfcJugCgwFfZlTwBjBTenRhD7dcFeHp2AUB9EvXs2h/FsKs0MwU5qUrYXCJ2N3YN+esnAslh144dO3DTTTdBLj+9I4BSqcRtt92Gffv2hXVwRERERERElFz2Nnla5IzWa+ByuX09us6Un4RL66TwLmMckxn6TpXenl0njTY43e5B7p0Y9jd7m9OnDvlrC4KA8wv1AIBPuZQxKJLDLo1Gg7a2trNur6mpgU439IknERERERERJY49PZUs04anDXg/7zJGg9WJbrsr4uOKNx1WB84dnoaJYahMyk1VQSET4BKBUyZ7GEYX29otDuSmqZGTqsI5Q7gTY2/nj9IDAD470RmV1493knt2/eAHP8DKlStxzz33APCEXF9++SX++Mc/4tprrw37AImIiIiIiCg5ON1ufHPKs3xs6oiBw650tQI6lRwmuwsnjVaMzRr6CpxYJJfLICrlqFx6IZpNduSnqz27WNqdZy0FDfg5ZQLy09Q40WlFfZfVFzQmGrlcBkGlwGh9Ct68aTZydSrY7a6Qrl2wvH27vjrZCYfLHfImA8lGcth1++23Iz09HatWrYLFYsEtt9yCrKws3Hjjjbj55psjMUYiIiIiIiJKAodbzbA43dCp5AE1Vi9IV+Nwqxknu2wMu+AJa7Q6NdZtrcaGyloYLA7otUosrSjGsnklZzX5l6IwQ4MTnVbUddowpzDMA48Bkbx2wRifnYpMrQLtFif2NBkxqyBjyF47EUgOuwDghhtuwA033ACz2QyXy4W0tIETdyIiIiIiomQjCAJkMgFut9hv3ynqy9uva8rwNMgEYdD7F6RpcLjVjAYj+3YBgKBSYN3WaqzZVOW7zWBxYPWmIwCAO8uLAEtwyxBH9vRIS9QdGSN57YIhEwScN1KP94604vO6ToZdEkkOuzZu3Oj3dkEQoFQqkZubiwsvvBBZWVkhD46IiIiIiCiW+Qu0vEuhUjQKX3VIqMvIksWeRk/YNVi/Lq/TTeoTM4CRQhAEpGgU2FBZ6/f4+soaLF9QCqPVEVT4WpDAOzJG+toF67zCDLx3pBWf1Rlwx3mjhux1E4HksKumpgbvvfcehg8fjnPPPReiKOLgwYM4efIkpk6dCqPRiLVr1+LZZ5/F1KlTIzBkIiIiIiKi6Oov0BKcLqhTVDGzFCre7GnyNKcfrF+XV0Ead2T0kskEGCwOGCwOv8cNFgc6LU5Po3mX9MCmMF2D7FQVVAo5BEFIqGrFSF+7YF3Q06T+i/pOON1uKGTs2xWooJYxXnPNNVi1ahXkcjkAwO1246GHHoLZbMYjjzyCv/zlL1i3bh1efPHFsA6WiIiIiIgo2gbq7fPri8dg3dajMbMUKp7YnG4caO4GAJRJrOw6yWWMcLtF6LVK6LVKv6GNXqtEhlYBo81/oDMQuVyG75Xl478uGoNWkx1pYWh6H0vcbhEZmshcu1BMzNEhXS1Hl82FfadMmDoifUhfP55JjgU//PBD3HTTTb6gCwBkMhl+/OMf4/333wcAfOc738GhQ4fCN0oiIiIiIqIY0bu3j/eLscHiwJ8+rYVCLsOGyhq/j1tfWYMUjQJCAL2oktGBFhMcbhGZWgVGZQS22593ad1JVnZBFEWYrU7cUVHs9/jSimJPQCWxIssb7j6/qx4j12xG8cNbMOLBTXhyey20OjXkcbpLoCAIngpNQcAXdQZsqWrBkvIiv/cN9tqFSi4TMKdQj+xUFY4arPzskEByZVd2djZ27NiB4uK+b6CdO3dCr9cDAFpbW6HT6cIyQCIiIiIiolgxUG+f4WlqnDLaYm4pVLzw9uuaOjw94C/1vmWMRitEUUz6MEC0O/Hri8dAFEVs3O5/Ga1Usda4PVRnLkHO0CjhPmXC058exz9+OA0yQcD6ypqwXLtwjPX3V0zCmJxUtHXbkZaWWBV1kSQ57LrjjjuwYsUK7Ny5E5MnT4Yoiti/fz/effddrFy5EjU1NVi2bBm+853vRGK8REREREREUTNQb58mow05OlXMLYWKF76wK8B+XQAwoifsMjvcMFidGKZVRmRs8cLlcuPxTUcwqzgLDSsXwWh1IkOrgNnqDKpfXKw2bg9Wf0uQl5QX4R8/nAaHxY47y4uwfEEpOi2hXbtwjfWVr+rY/y8IkusNr7jiCvztb3+Dw+HAiy++iFdeeQUOhwP/+Mc/cM0118BoNOLHP/4x7rnnnkiMl4iIiIiIKGp690U6U2u3HR8dbcPSMC8jSxZ7mjxhV6D9ugBAq5Qjq+dnwb5dHu8casbi57/CaztPQOFwwmiwwGmxBxWMBNq4XSaLj4q6/pYgr91chfWf1EClVsJpscNosIR87SI11tWbjuDRrUchqIJqwZ40gro6M2fOxMyZM/0emzJlCqZMmRLSoIiIiIiIiGKRty/S0opi3zKu3mrazFg2vxQAYmYpVDzotrtwpM3TnH6ahMouAChIV6PN4kBDlxWTcpO7nU633YUDzSYAwLk5upBDmkg2vR9qUqvUornUONEq6qJBctjlcDjwxhtv4JtvvoHTefZvJR555JGwDY6IiIiIiCjWiHYn7plXArefvkg3zx4JW7fNtxSqscuztNFotnPZ0QC+OWWEWwRG6FTI06klPTY/XY2vT5lY2QVgT1MXXCKQn6ZGfnpgTf4HMli4G0/VioFWqcVCT714Gmuskhx2rVixAh988AEuvPBCNqEnIiIiIqKk43K58cmhU5heqEfd/QvRbXOd3dvH4YLR6sDSN/fh8xOdeOKy8VhUkhXtoces0/260iU/Nj/NE+rUc0dG7GjoAgDMyJd+Hfsj2p1YNq8EQHxXK8ZTlVo8jTVWSQ67Nm3ahKeeegrl5eWRGA8REREREVHMe+dQC576sg7/NaMQj1w6Dkbb2cuJRFGEShDQ2m3H/mYTw64BBNOvy6sg3VMJdrLLGtYxxaOdJz1h18wwhl0ulxsW09nVigZTfFUrxlOVWjyNNVZJblCflpaGvLy8SIyFiIiIiIgoLmyr7QAATMtPg8vl7vdLp7eH1P6ePkrknzfsktqvCwAKenZkTPZljKIoYkdP2DWjIHxhF+AJvLyN21e8cwDFD23BG3sb4ibo8hLtTvxmbgnuWzjWt8mEXqvEykXjsGxeCUS7M8ojPM1bUbdy0biYH2ssklzZdeutt+Khhx7Cfffdh9GjR0Oh4A4ARERERESUPFrNduzrCa8uHD1swPtOyvGEXQcYdvXLYHWgpsMCINjKLs8yxoYkX8Z43GBFm9kBlVzAlDzp1zEQoigiTSVHa7cduxuNuO7c4RF5nUhxudz4x+e1mF6oR/39i2CyOc9eghwjzqyoazLakJ2qQkuXNebGGoskJ1X//d//jebmZlx++eV+jx88eDDkQREREREREcWqT3qquibmpCI3VTXgfSflpgIAjnVYYHa4kKKUR3x88WZvT1VXkV6DYT0VLFLk9yxjbDTa4BZFyAQhrOOLFztOdgIAzs3VQa2QvIgrYFN7qu+8P7d4869vmrCttgOPXzYeP51W4HcJcqxwudyAxQ6j1YG1m6vw5sFmLKsowk+m5kd7aDFPcti1bt26SIyDiIiIiIgoLniXMF5cNHBVFwDk6tTITlGi1ezAoZZuTA9jL6VE4W1OH0xVFwAM16kgEwCHW0RLt13ybo6JwtucfmZBRkRfZ1rPz2l/swkOlxtKeeSCtXCzOFz4vM4AAJidnx431VGe/n9Aa7cdh1u7oz2cuCA57Jo9ezYAwGQy4cSJEygtLYXdbufOjERERERElPBEUcTHPWHXRQGEXQAwMUeHj493YH+ziWGXH6f7dQV3bRQyGYbr1DhptKGhy5a0YVckmtP7UzRMi3S1HF02Fw61dmNyhJZMRsIX9Z2wuUTkp6kxNisl2sORZFy2p0q0qs0c5ZHEB8kRrN1ux3333YfZs2fjmmuuwalTp3Dvvffi5ptvRmdnZyTGSEREREREFBOOdVjQYLRBJRcwp1Af0GO8SxkPtLAiwx9vZdfUIJrTe+UneZP6brvLtwnCzDA3pz+TTBB8VXjen1282FrTDgCYWzwMQpwtd/WGc0dY2RUQyWHXY489hurqarz++utQqz0fKHfccQc6Ojqwdu3asA+QiIiIiIgoVniXMM4syECqKrD+W94dGdmk/mzNJhtOGm0QAEzJC361kLdvV0OXNUwjiy97m4xwicAIncrXsD+SpvZU4e2Js75dH9V43r9zizKjPBLpxvWEXY0mO4w27sQ4GMlh1wcffIAVK1Zg/PjxvtvGjx+PNWvW4OOPPw7r4IiIiIiIiGLJxxL6dXlN9IZdLaaYbYQdLd6wZFxWClJVkrvs+BSkecOu5Kzs8jannzFEy2SnxmFlV5PRhkOt3RAAXCjh/RsrMjRK5Ok8G2Ic4VLGQUkOu7q7u6HVas+63e12w+VyhWVQREREREREscbpdqPyuPSwa2xWCpQyAV02F+qStPKoP1VtZpw7PC3k8MFbzZSsyxh9/boi3Jzey7vk9GCLCRZHfOQAH9V6ljBOHZGGzCB2/YwF3uquqjYuZRyM5LBr/vz5+OMf/wiT6XQJbl1dHdauXYuLL744rIMjIiIiIiKKFbsbjTDaXdBrFJgioSm3Si7DuGzPl9T9zfySCgByuQwKrQr3XDIBb940G09eUwaFVgV5kDv7FSTxMkZRFE/vxDhElV0FaZ5dRl0ifL3CYl08L2H0Gpvl6f93pJWVXYOR/EmycuVKyGQyzJ49GxaLBVdffTUWLVqE9PR03H///ZEYIxERERERUdR90rOEsWKUHnKZtObW7Nt1mlwug1anxhPba1C4ZhNKHt6CgtWb8OT2Wmh16qACr2RuUH+804pWswNKmYDJw4PveyaFIAi+6q546Nvl7rWL6tzi+FvC6DW+JzQ/LKGySxAEyOWyuGvIHyrJi6LT0tKwYcMG1NXV4ejRo3A6nSguLkZJSUkkxkdERERERBQTvM3pLy6WXhkyMUcH4FTcVMFEkqBSYN3WaqzZVOW7zWBxYPWmIwCAO8uLAItd0nPm9yxjPGWyw+FyQxlkhVg88lZ1Tc7TQaMIbNOEcJg6PA2bj7bHRd+ufadMaLM4oFPJh6yvWSSM66nsqgqgZ5dcLoOgUiBFo4DB4oBeq4TZ6oRod8Llckd6qFEX1CfA0aNHodfrMXfuXKjVarzwwgv417/+Fe6xERERERERxQSTzYkdPX2RLhotvTJkYq7nS2qyh12CICBFo8CGylq/x9dX1iBFo5BchZKdooRKLkAE0GhKruoub7+uoQ5xvDsy7o2Dyq6tNZ5+XRWj9XEdhI7t6dl1wmAdsFda7+rJEQ9u8v0JpXoy3kg+w5deeglXXHEFDh48iAMHDuDWW29FXV0dnnzySTz55JORGCMREREREVFUfVbfCadbxKgMDYqGnb1h12C8yxhrDVZ0253hHl7ckMkEGCwOGCwOv8cNFgc6LU7IJC4TlQnC6aWMSbYj486enRiHqjm9V1nPjoxVbWaYbLE9pz+qjf9+XYAn1M3UKiACONref3VX7+pJ73vNWz356NajEELY+TReSA67nn32WTz66KOYPXs2Xn31VZxzzjl49tln8cc//pHVXURERERElJC29VSGSNmFsbfsFBXydCoAwIGW5G1S73aL0GuV0PezG55eq0SGVgG3W5T83N6ljA1J1LfL7HD5Nj2YWTC0lV25qSoUpKkhAth7Knaru7rtTnxV7wkE47lfF+CpjPQ2qT/cz1LGSFVPxhvJYdepU6cwY8YMAMDWrVuxcOFCAMDw4cPR3Z28H9pERERERJS4vM2tLwoy7AKASTlsUi+KIsxWJ5ZWFPs9vrSi2NNXSJQedhUkYWXX3iYjnG4Rw3Uq3/kPJV+T+hju27X9hAEOt4jReg2Kh6VEezghG9ezlLGqnx0ZI1U9GW8kh11jxozB22+/jVdeeQUnT57EwoUL4XA48Ne//hUTJkyIxBiJiIiIiIiipqXbDqVSjpxUFSqC6NfldbpvV3IXCYh2J+6ZV4L7Fo71VXjptUqsXDQOy+aVQAxymWd+uifsaeiyhm2ssc7bnH5mfnpUKnXiYUfGRFnC6OXt23Wknx0ZI1k9GU8kL9RctmwZ7rrrLnR2duKHP/whSkpKsHr1amzatAl/+ctfIjFGIiIiIiKiIefdzWyMPgVv3jQbeToVbHZX0LuZeft2JXuTepfLjaoGA6YX6lF3/0J021zI0CpgtjphMdmC3imuMMmWMQqCgFarE9mpqqjtMDh1uOd1Y7myy7sEOd6XMHqNz/aE5kf6qezqXT3p3eG0t1CqJ+OJ5LDr/PPPx2effQaj0YiMDE8DvNtuuw3Lly+HUuk/OSQiIiIiIoon3t3M1m2txobKWhgsDui1SiytKMayeSVBhTLesOtAiwluUYQswXvmDOTrRiN++to+XDh6GF7/0TQYbY6Qv3wnS4N6bwibolHgngVj8bvvTUJrlw1yGYIOCoNVNtwzp090WtFmtiMrRTWkrz+YRqMNGpUCebrQqjJjiXcZY43BArvLDZWfnRVFuxO/mVsCtyhi43b/n1+JLqgW/JWVlZg0aRIA4JVXXsEHH3yAiRMn4rbbboNKFVuTm4iIiIiISKreu5l5eXczA4A7y4sAi13Sc5ZkaqGWCzA73DhusCRE/6BgVfU0185OUYYtoPEuYzxpTNxljJEIYUORoVFizDAtjnVY8HWTCfPGhH+poCAIkMkEuN1iwIGoNxAcG6aqzFgyIk0NnUoOk92Fmg6Lr9KrN5fLjb99VoPphXrU378IJpszLNWT8URyz66nnnoKd955J+rr6/Hll19i5cqVGDFiBDZt2oRHHnkkEmMkIiIiIiIaMpHazUwhk/m+mCZ7366qnn5D3iqVcPA2aG+3OGF2uML2vLGkdwjrbUDuDWEf3XoUgiqoepaQePt27W7qCuvzyuUyKLQqpOm1cCjlSNNrodCqIPdTyXTm47Q6NZ7YXoOC1ZtQ8vAWFK7ZjCe310KrUw/6+Fjn2ZGxp0l9PzsyAsAr3zRh8fNf4ZlPjkLhcMJosMBpsSdF0AUEEXa9/PLL2LBhA8rKyvDmm29i1qxZePDBB7Fu3Tq89957kRgjERERERHRkInkbmYT2bcLAHCk50v62DCGXelqBXQqOYDEXMoYqRA2VGXDw78jY+/AasSDm3x/AgmsYjEQDDdvSHyk1X9obna48EV9JwBgTkEGXC53wvfoOpPksKuzsxNjxoyBKIr46KOPMG/ePACATqeDy5WY6TkRERERUTwTBMGzrCeJe0RJEcndzHr37UpWoij6KlLGZp29BCtYgiD4qrsaEnApYyRD2FBMi8COjMEGVrEaCIbbuJ4K0cP9VHZ9dsIAu0tEYboaJZnaoRxazJAcdk2YMAHPPfccNm7ciPb2dixatAinTp3CH/7wB0ydOjUCQyQiIiIiomAEuwwo2fXezcyfUHYzm5TLZYxNJjtMdhfkAjAmzF/EfX27ErCyK5IhbCjOzU2DTABOmexoCsNOmKEEVrEaCIbb6WWM/j9HPqrtAADMLc6M+2AvWJL/llu1ahV27NiBv//97/j1r3+NgoICPPvss2hoaMADDzwQiTESEREREZFEoSwDIs9uZsvmleC+hWN94YJeq8TKReOwbF4JRLszqOf1VnbVdVrRZQvuOeLdkZ4v6EXDtH53kgtFfpoGAHAyDKFLrIlkCBuKVJXc14tudxiqu0IJrGI1EAy38T0VkdVtZrj8nMu2mnYAwNyixNiBMhiSF6tOmDABb775Zp/b7r77bu7CSEREREQUQyKxm2AycbncaGwxYXqhHnX3L4TJ5oI+DLuZ6TVKFKSp0WC04UCzCeeN1Id34HGgKgL9urwKeyq76rsSbxkj4Alhf33xGLhFERu3+9+NMRrKhqfhYEs39jR24bKx2SE9V+/Ayl/g5Q2sjLazj3kDwTsqivp89nlFKxAMt5EZGmgUMlidbtR1WlE07HSFZEOXFYfbzJAJwIUMu6Q5ePAgqqqq4HZ7PuBFUYTdbseBAwfw4IMPhnWAREREREQkTSDLgJYvKIXR6oj7L32R9E2TEYv/uQdlI9Kw5WezYLSF53pNzNWhwWjD/qQPu8LXr8srHpcxCoIAmUyA2y0OOr8cThd++sJO3HxeERpWLoLR6kRGGELYUE0bkYYXv2lCrcECuVwW0Ln0RxRFnGgzY0l5EdZulh5YuW0OLK0YA1FETAWC4SSXCSjJ1GJ/czcOt3X3Cbu29SxhnDYiHXqN/wq3ZCA57Nq4cSM2btyI7OxstLW1IS8vD62trXC5XFi0aFEkxkhERERERBIEugxIIRPgdiPgL9rJ5lDPTme5KaqwhggTc1Oxu8mITrsbgiAk3XX37sQ4LgKVXflpGmSnqqDr6ekUy9dWLpdBUCmQolH4Ahmz1QnR7ux3vn1Q3YZ3D7Vg27F27Ln9fOi1qrCFsKEoHz0Mr984CwvHZcNkcwZ0Lr31Dvz+faQFv/v0OLb84nwAfQOrJeVFgwZWlbUdWL6lGo9+5xw0PrAInZbYCATDbVxWKvY3d6OqzYxLS0/f/hGXMAIIIux66aWX8OCDD+L73/8+5s+fj7///e/IyMjAL3/5S4waNSoSYyQiIiIiIgkCWgakUcAsAGkSvmgnm0MtnrBrQk74KpDkchluqxiDtd+dhNZuO9LS1El33b1NtcO9jFEul+H80mzUrFiAZpMdaemxe229PfXWba3Ghkr/1UdnjlkURTzx2XEAwI3T8pGmUsTEecnlMkwtzsK6D6vxs5f2BHQuvR/bO/DL0CiRka6F0y3iof8cwgOXjMeKhWNhsDigUyvwweEWfHm0FROz+39P/m13Aw41m/Dq7nqcn6eDQibERCAYbt6w+Ejr6Sb1LreIj3s1p09mksOujo4OXHjhhQCAc845B7t378YVV1yBX/7yl1i6dCl+85vfhH2QREREREQUuN6NrL09unpbdck4ONwi/lhZ0+8yn1j4Eh1t3squc8IUdnkDjhckBByJxmB1oKXbE8COzQxf2OW9tk/GybUNpqfex8c7sLvRCI1Chp/PGjmUwx2QoFLg0a3VfZYcBtIfsL/Ab0l5EbYvKYfTbIPT6oDR5oRSJuBX7x7Ef++oxxXjc/DfV07yO5Zmkw3vHWkFANw4rQCiKMLlSqyQy2tcT+B3uKdSEgC+PmVEh9WJNJUc0/PTojW0mCB564u8vDzU1dUBAEpKSnDgwAEAgE6nQ3t7e9ADueWWW3Dvvff6/v/AgQO49tprUVZWhquvvhr79u3rc/933nkHCxcuRFlZGW6//faQXpuIiIiIKNGIdifunut/N8GfzhyJx3q+nHorv7xfTh/dehSCKqjWvglFFMXTlV0DVJFI0TvgSNbrXtXq+WKen6aGTh2+842naxtIT72UnmWYvT3x2QkAwI/KRiA3NTY2iAv2XID+f2ZrN1fhyU9qoNB4ztETWLnxwynDAQDvHGnBiU6L39d74etGON0iZuan+3Y+TVTeyq6qNrOvau2jGk9V14VFw6CQJfeOu5LP/tprr8WvfvUrbNu2DQsXLsTLL7+Mv/71r1i7di0mTJgQ1CDeffddbNu2zff/ZrMZt9xyC2bOnInXXnsN06ZNw89//nOYzZ4Pxq+//horVqzAkiVL8NJLL6GrqwvLly8P6rWJiIiIiBKRy+XGyzvrML1Qj/r7F6LpgUvQ+MAi3FVeBI1Sjo3ba/0+bqAvp8mkyWRHp80JuQCUhqECKZRQIJEcicBOjPF2bQPtqSeTnR7vV/Wd+PSEAUqZgNtnx05VVzDnAgT3M5uYo8NFo4fBLQLP7Ww46zFOtxsv7GkEAPxsen6QZxQ/iodpoZAJ6La7cNLo6WG2rZb9urwkh12/+MUvcPfdd0Oj0WDKlClYvnw53n33XYiiiIcffljyAAwGAx577DFMnjzZd9t7770HtVqNe+65ByUlJVixYgVSU1Px/vvvAwBeeOEFXHbZZbjyyisxYcIEPPbYY9i2bZuv4oyIiIiIiICXvm7E4ue/wh8/rILC4YTRYIHb7oTBYpf85TTZeKu6SjJToFaEXiERbCiQaCLRryverm3vnnr+6LVKZGgVcLtPL7/z9uq69tw8FKRrhmScgQjmXIDgf2a/mFUIAHhhbyOMNmefY5uOtqPBaEOmVoHLx+cEe0pxQymXYUzPLoxVbWYYbU581dAFALg4yft1AUGEXQBw5ZVXYs6cOejo6MAll1yCV199Fc899xzGjBkj+bkeffRRfO9730Np6entA/bu3YsZM2b4UlxBEDB9+nTs2bPHd3zmzJm++48YMQL5+fnYu3dvMKdDRERERJRwLA4XPulpVFw+Ug+Xyw1RFIP+cppsvP26wrWEkdfdoyoCOzHG27Xt3VPPnyXlRWg12iCKIgRBwDGDBXtOmSATgKXnxdamcIOdy9KKYs8mAWc0hw/2ZzZvTCbGZqbAZHfhf79u7HPs77s91V4/nDICGoU82FOKK97Q+HBrN7afMMDpFlE8TIsivTbKI4s+yQuX3W431q9fj3/961++Plm5ubn40Y9+hFtuuUXSc3322WfYsWMH3n77baxatcp3e0tLS5/wCwCysrJQVeVpeNfc3Izc3Nyzjjc1NUk9HcRIJWtIvOeQCOdC0cE5RKHiHKJQcQ5RqDiHzvZpnQEWpxv5aWpMyk3tdW1EWAZoXr+0ohgWqxOAmDTX09/88YVdOalhug687sDpZYzjssN1XYFYuLaSP4McTiybVwK3KPbZJGJJeRHuqCjGkle/xqPfOQcj9FqMkMtRs2IB9jZ0YqxeE1ON9gH4zgXwLD88c3MAa7fNz3UJ7mcmFwT8fHYhfvP+ETy3swH/NbMACpkMxzrM2FrTAQHAT6blx+V7KJi/x8Znp+LdI62oajej1uDpYza3eFhcnn+gAj03yWHXI488gg8++AC//vWvce6558LtduObb77B+vXrYbfbsWTJkoCex2az4YEHHsDKlSuh0fQtw7RYLFCp+jbcU6lUsNs9OzhYrdYBj0uRlZU4OxQk0rlQdHAOUag4hyhUnEMUKs6h0z7eVgMA+O65w5GTk37W8Xvne3653PvL6R0Vxbh3fik0SjmgUw/peGNB7/lT3eH54ji7JBvZ2eGbV/6u+9Ikue4Whwt1XVYAwHljc5GdFt5zjYU5LeUzyOpwYUahHnX3L0S33QW9RoluuxMPba7CxqunYIOf3VKne88lBt09rwT3zi9Fk9GGHJ3n+7pWpYB2gM0Bls0vPSvwG+z9cOvFpXjk4xqc6LSisrEb15Tl49HPPC2NLh2fg5mluWc9Jp5ImUPTizKBT4+jptOGpp6+XVdMKQjrZ1a8khx2vfnmm9i4cSNmz57tu23ChAkoKCjAb37zm4DDro0bN+Lcc8/FhRdeeNYxtVp9VnBlt9t9oVh/x7Va6aV6bW1GiLFRzRo0QfC8IRLhXCg6OIcoVJxDFCrOIQoV51Bfoijinf2eVQ8XFaSjtdV41n3kchnuKi/C8gWlaDbZkZmixNEWEywmK0yxVjkSYWfOH7coYn+T55oVqGV+r1+wel/3U0YbslJVaOiwJMV1/+aU5/oO0yggWG1otUkvVhiIvzldPURzOpjPoD2NXbjq77swPjsF22+ZA6PNAVEUsXxeCZ6srMHazVW++3p3lgSAu8qL4LSG99qFS6fNicX/3ItGow1bfzYDeYMEjFtr2jHdG/jZXMjQKmC2Ogf9mf10aj7+8Olx/PdntajI1+HNbzxLGn90bl5Y369DKZg5NELt6Ux1rK0bmSkqDE9TY8owddxeg0B4r9NgJIddGo0GSuXZ62rT09Ml7W7x7rvvorW1FdOmTQMAX3j1n//8B5dffjlaW1v73L+1tdW3dDEvL8/v8Zwc6U3oRBEJ8w+iRDoXig7OIQoV5xCFinOIQsU55HGgpRv1XTZoFDJcMErv95o4nW7AaYfT6sDb+5uw6sOjmJWfjucXnzv0A44R3vlT22GBxemGWi5gdIY2rHOq93V/5vPjeOarevzg3DzcP7ckfC8So4609t6JUQj7e7X3tf33wWbct7kKk3NT8eJ1ZeF9oQFI+Qza3+xZKpubqoLL5XmQIAjQaZUD7pa6fEEpjFbHWX2wYkG6SgHRLaK1247txw24amLegPd/82Az/u/rJtxdUYRlF43xBX6D+fnskbh4fC7mj81Gu9mB3b+5GJ8ca8OM7NSYvC5SSJlD43N0eP3GWVg4LhvNJjvydGrY7E6IdmfsLXcdYpIb1N9zzz347W9/i61bt8JgMMBkMmHHjh24//778dOf/hQnT570/RnI//zP/+Dtt9/GG2+8gTfeeAPz58/H/Pnz8cYbb6CsrAy7d+/2TVJRFLFr1y6UlXk+pMrKyrBz507fczU2NqKxsdF3nIiIiIgomW2qbgMAVIzWI2WQJU+iKKIoXYPWbju+bOiM+y+K4XCwZyfGcdmpkEdoBz9RFJGlUaC12449TYlbhdGbtzn92KzwNP3vjyiKGJ+lRWu3HV/Ud8Ieo1/6DzSbAACTcnW+2+JtZ0l/KkbrAQCVJwwD3k8URXzcs4nG9BFpvk00BiOXy1CYm4av6gwYuWYzRq/djJFrNuOz4x3QpWsgl4e+e2o8kMtlGKZPwc56z3UoeXgLCtdswpPba6HVqZPmOvRHcmXXb37zGwDArbfe6qvk8k7IgwcP4o9//KNv14iDBw/2+zwFBQV9/j811fOBN3r0aGRlZeHxxx/HQw89hB/84Ad48cUXYbFYcNlllwEArr/+etxwww2YOnUqJk+ejIceeghz587FyJEjpZ4OEREREVHC2XzUE3ZdUpIV0P2nDE+DWi6gzezAsQ4LSjLDt1NePAr3Toz9mTrcsxTn6yaj7ztUIovEToz9mZCdiiytEm0WB/Y0GjG7MCPirynVgZ5QdWLO6bCr9y6F/gIv7y6FRpv/MCwWlI/S4y9f1WP7IGHXsQ4L6rtsUMkFnDdSH/DzCyoF1m2tPmuZ55pNVRAg4M7yIsASm8s8w6m/6+Bd7pos16E/ksOuLVu2RGIcfeh0Ojz99NN44IEH8PLLL2P8+PF45plnkJLi+VCcNm0aVq9ejfXr16OzsxPl5eVYs2ZNxMdFRERERBTr2sx27DjZBQBYEGDYpVbIUDY8DV82dOHL+k6GXS2nd2KMpPHZqVDLBXTZXKg1WFA8LLGv+5E2z3UdOwRhl0wQUD5Kj7cOt6DyREfMhV2iKOJgi6eya2Juap/bzYPsUmi2OmO6AvP8kXrIBaCmw4L6LisK0zV+7+et6ppVkDFoBaqXIAhI0SiwobLW7/FYX+YZLrwOg5Mcdp1ZkRUu69at6/P/U6ZMweuvv97v/RcvXozFixdHZCxERERERPFqa0073CIwMSe13y+Z/swuzPCEXQ2duH7KiAiOMPYNVWWXUi7DxFwddjcasafRmNBhl9PtxrF2zw6XY7OH5jzLR/eEXccN+NUFQ/KSATtlsqPd4oRcODv8E+1OLJvn6eF25q6dy+aVwGKyRWPIAUtTK1A2PA27Go3YftyA708e7vd+23rCrouKhgX83IEu81TIBF8ftETE6zC45F7ESURERESUYDYdbQcALCoNrKrLa1aBp/Llq/qusI8pnthdbhztCWUiXdkFnF7KuDfB+3YdN1jhcIvQKmWSQthQVIzyhCg7GjphdbqG5DUDdaCnqqs0MwUaRd+qJpfLDYvJhjvLi9D4wCI0PXAJGh9YhDvLi2Ax2eKi8Xj5aM+1336iw+9xp9uNyuOeYxdLCLt6L/P0x7vM0+1O7ICH12FwDLuIiIiIiBKEw+XG1mM9YdcYqWFXOgCgqt2M9n6qBZLB0XYznG4RaSo5CtLUEX+9siQJu4709OsqzUyBbIh6k5VkajFcp4LNJWJHQ2yFuN6dGM/p1Zy+N5fLDafFDqPBAoXDCaPBAqfFHhdBFwBcOEoPAKg8bvC7jG5PoxFGuwt6jQJT8tICft7eyzz9iYdlnuHA6zA4hl1ERERERAniq4YudNqcyNQqMD0/XdJjs1JUKM3U9jxPZySGFxd69+saiobxZSN6mtSfMsGdwF9Mq3r6dQ1Fc3ovoadvF+AJXWKJt7Jr4iDVg6IoBrxLYSyZVZgBpUxAg9GG4wbrWce9/boqRukl73jqXea5ctE4X2WTXqvEykXjsGxeCUS7M/QTiAO8DgOT3LMLAFwuFz755BPU1tZi8eLFqKmpwZgxY5CWFngiS0RERERE4bWpZxfGBWOyJH+BBDxLGavbLfiyvhOXlmaHe3hxYaj6dXmNy0qBViGDye7CsXYLSocwDBpK3p0Yx2YNzXX1qhg9DK8eaEbliQ4A/qtgouFAT2XXxH4qu+JdilKOGfnp+Ly+E58c70DRMG2f495+XRcXZ0p+7t7LPJcvKEWnxYkMrQJmqzNulnmGA6/DwCRXdjU2NuK73/0ufvvb3+J3v/sdOjs78eyzz+Kyyy7D4cOHIzFGIiIiIiIahCAIONFlRXaqCosC3IXxTN4d676KsSVfQ8kXdg1Bvy4AUMhkmNQTeOxJ4KWM3mWMQ1nZBQAVo/UAgN2NRnTHSKWLzelGdbvnegxW2RXPvNe+8oShz+3ddqdvx1gpzel7i/dlnuHC69A/yWHX6tWrMWPGDHzyySdQqVQAgD/84Q+44IILsHbt2rAPkIiIiIiI+ieXy6DQqpCm1+LJxVNQs2IBvjc1H3K59I4ls3ua1O9p7ILNmZxflnzLGIeosgs4vZQxUft2iaLYq7JraMOuURlajMzQwOkW8UV9bCzPre7pC5ehViB/CPrCRUv5qNNN6nsvw/y0rhNOt4hRGRoU6bX9PTwg8brMM9x4Hc4m+W/AHTt24KabboJcfnrHCKVSidtuuw379u0L6+CIiIiIiKh/crkMWp0aT2yvwYgHN6Hk4S0YuWYznvrsBLQ6teTAqyRTiyytEjaXiK9PJWbwMpBuu8vXX2ioKruA0zsyfp2gYddJow3ddhcUMgHFw0ILN4JR0dO3a/sZFUbRcqDZ069rUu7Q9IWLlhn56dAoZGjpdvgq+wBgW41nEw0puzASSSU57NJoNGhrazvr9pqaGuh0ibnemIiIiIgoFgkqBdZtrcaaTVUw9OygaLA4sHrTETy69SgElbQWvYIgYGbProxfxUgVzFCqauuGCCA7RYnsFNWQva53R8avTxnhcideZYa3qqtYr4UyiIrDUFWM9oQqsdKkfn9P2NXfToyJQq2Q+apFK493+G73Nqdn2EWRJPmT5gc/+AFWrlyJjz76CIAn5Hr11Vdx//3345prrgn3+IiIiIiIyA9BEJCiUWBDZa3f4+sra5CiUUiuHPH27foyCft29d6JcSiVZqYgRSmD2XG6l1Mi8Vb1jM2OTvN9b2XX16eM6LQ6ojKG3g70zLNE7tflVd7Tt8tbVddktOFwmxkCgPLRDLsociTvxnj77bcjPT0dq1atgsViwS233IKsrCzceOONuPnmmyMxRiIiIiIiOoNMJsBgcfgqus5ksDjQaXFCIRPgcgVeLeStxPiyoROiKCb0MqszHRzinRi95DIBk/PS8EV9J/Y2GTF+iF8/0qraPNd1qPt1eQ1PU6M0U4vqdgs+q+vEt8ZGd6fRAy2eyq6JOYld2QWcDho/PWGAWxTxcU+FV9nwNGRqlVEcGSU6yWEXANxwww244YYbYDab4XK5kJaWFu5xERERERHRANxuEXqtEnqt0m/gpdcqkaFVwGiTVslSNjwNarmANrMDNR0WjMmMTkARDdFoTu9VNtwTdu1pMuK6c4cP+etHUlWUdmLsrXzUMFS3W1B5vCOqYVdztx0t3Q4IQMKFmv5MHZEGnUqODqsTB5pN2NazhDHYXRiJAhVU2HX8+HHs27cPDsfZf3FeeeWVoY6JiIiIiJKQIAiQyQS43SJ3lAqAKIowW51YWlGM1ZuOnHV8aUUxzFan5GupVshQNjwNXzZ04cuGzqQKuw5GaRkj0KtvV4I1qRcEAXK5DNmpKozNil64UzFaj7/vORn1JvUHe6q6iodpkaqSD3Lv+KeQyXBeYQY2H2vHJ8cNvn5dDLso0iSHXc8++yx+//vfIyMjA6mpfT+sBEFg2EVEREREksjlMggqBVI0ChgsDui1Sk9IY3fC5XJHe3gxTbQ7sWxeCdyiiI3ba33Xb2lFMZbNK4HFZAvqeWcXZnjCrvou/GDyiDCPOja1m+1oMtkBRKeyy7sj475TJjjdbihkQ9/IfSBSw+je7+u//3A6cnUqWKxOyJyuqLyvL+hZTnegpRutZvuQbkDQ28Hm5OnX5VUxehg2H2vH20dakJum7tO4nihSJIddf/3rX3H33XezPxcRERERhUwul0GrU2Pd1mpsqPQf1jDw6p/L5UbdKSOmF+pRd/9CmGwu6LUKmK3OkK7drIIMAHX4Mol2ZNzfU1FVmK5GmjqoBTAhGZOphU4lh8nuwpE2c8z0cwomjI7F93V2igrn5KTiYEs3Pj1hwBUTcsP6/N7edoIgDBgG+vp1JfhOjL0tGpuNstGZWDguG80mO/J0atjs/IUGRZbkXxfYbDZccsklkRgLERERESUZQaXAuq3VWLOpytd3ymBxYPWmI3h061EIqqEPHeLN53UGLH7+K1zy58+gdDhhNFjgtNhD+hI5qyAdAFDVbkZ7Pw3wE82+nrArGlVdACATBEzJ8wQgextjYymjN7R6YnsNRjy4yffnye210OrUkMv9f52M1ff16V0ZTZ4QLwybL8jlMii0KugytGg22aDL0EKhVfV7bfb3VHadkySVXXK5DFOLMrGz3oCRazaj5OEtKFwz+BwiCpXkmfXd734X//d//8c+CkREREQUEkEQkKJRYENlrd/j6ytrkKJRJNVugMHwBiOj9Rq4XO6w/Ds9K0WF0kwtAOCrhuSo7vKFXVEMIXx9u07FRtgVTGgVy+/rb0/Ixes3zsLDV0yCQylHmn7gYGowZ4aBw1d9MGAY6HC5caRnZ8pJSVLZ5Z1DazfHVvBJiU/yzDKZTHjllVfwzjvvoLCwEEpl3+1C//GPf4RtcERERESUuGQyAQaLw+9OgoDnC1GnxQmFTIDLxV+09mdPUxcAYNqI8O6QPqsgA9XtFhxoNuHb43PjYuOAYDc5EAQBZrsT2amqqFbceMOuPTFQ2RVIaLV8QSmMVkefax2r72u5XIZFk4Zj3YfV+NlLe8KytLJ3GOjlDXIA4M7yIsBi9x072m6B3SVCp5JjZIYmLOcVy4KdQ0ThIDnsKioqwi9+8YtIjIWIiIiIkojbLUKvVUKvVfr9YqzXKpGhVcBoS45ldMEQRdEXjHiDknC5dFwOrpsxEovG5cBoi+2NA4Ld5KD34x64ZDw2Lp6MdpMNciAq5zi1J7Dc32yCw+WGMopLvIINrWL1fS2oFHi0p8LIa6BgatDnCyLI8fbrOicnFbIkqFiN1eCTkoPksGvJkiWRGAcRERERJRlRFGG2OrG0otj3hbO3OyqKPIEFf+PfrxOdVnRYnVDKhLA2NJfLZbh6eiEe3Rq+KphICbYZeiw2US/Sa5GulqPL5sLh1m6cmxfeAFOKYEMrz/vagSXlRX2CJa+lFcVD/r6ORIVRMEHOgRbvTozJsYQxVoNPSg4BhV3Lly/HihUroNPpsHz58gHv+8gjj4RlYERERESU+ES7E8vmlcAtiti4/XTgsKS8CEvKi9HQakJeqiraw4xZ3qquSbk6qBXhqwISVAo89lH4qmAiSepSslAfF0mCIGDK8DRUHjdgT5MxqmFXKGH0P3fW446KYgDo877uHSQOpUhUGAUT5Bxs9u7EmBzN6QebQ9EIPil5cOsDIiIiIooal8uNU20mTC/Uo+7+hWh8YBEaH1iEuSVZuPhPn+IXb+6Hm1+E+rWnp6n61DD264rlBuNnCnassXyOU71N6ptMQ/7aZxLtTtw9twT3LRwLvdbTq1mvVeK+hWOxpLwYnx9tPesxX9QbcOc7B3Hxnz7F98tGoPGBRWh64BI0PrAId5YXRaVirncw5Y83mHK7A/+s6R3k+HOHnyAn2Sq7gNO/0Fi5aFyfObRy0Tgsm1cC0e6M8ggpUQVU2dW7WouVW0REREQUTp8eN+DHr3yDWYXp+PdPZsJocyJNFHGiw4xDDjee3dmAn88aGVTj8US3p9HTnD6c/briqc+OlLG63fDNoVg+R+/P8ninFXK5LKpz3uVy41876zC9UI/6+xfCZHMhQ6vArvpOXPynT3Gy04J/3zADY7NTIZMJaDbZ8F9vHoBLBCZmpyBHLsBosEAhE2C0Ra8JeaQqjES7E3ddNMZvZeqdFxbD3asysMPiwEmjp6Itmjt+DjWXyw2LyYY7y4uwfEEpOi1OZGgVMFudMbUcmhJPQGHXxo0bA35C9vQiIiIiIim+qO8EAJQOS/F98SkapsUD80rwtz2NmDJqGNL0WkmNx5OBWxSx95Sn+ieclV3x1GcnkLGmaxQwQ0Raz330WiVMFgfSNbF5jnNG6vH6jbOwcFw2TDZn1Of8mwdO4c1DLVg5dwyWXlAEo82BkWo50pQy5GdoYRIE3/tz1PAM/PmaMjzzaQ1+f+k4CIIAURSjHooCpyuMAE/lXjiWVjZ2WXHD33Zg5aXjcXLlIhhtTqRrFHj/UAsqNm7HrTML8IPJIwCcbk4/MkODdLXk1tlxzeVyAxY7jFZH1INPSh4Bvcu++OKLgJ4sFkqZiYiIiCi+fFFnAADMKczoc/tNMwpxc8UYPPHxMfz0xdhukh4N1W1mdNtd0CplGJeVErbnjac+O4ONddUl4+B0i3hie+1ZlTe/vHhMTDVRBzxN80vyM/Dyh7GxMYBbFFF5wgAAmJ6f7ntttUKGF64rwzB9CtZ/cgzff2FXn2v7r5/Ogq07tt6fvSuM7p1fiiajDbk6FWx2V9DX9U9fnMCexi6s+c8hVAxPRU52GtraTNhd24ZDzSY88OFRzB+ThdxUFQ40e5cwJk9V15liJfik5BBQ2PU///M/vv9+5513UF5ejmHDhkVsUERERESUHKxOl6/v1Jlhl0ytxBOfHIuLJunR4L1uk3N1UMjC24o3ElUwkdLfJgdLK4px48yReGzr2Y32126uQnaqCvfOL4VMEGLmHL1N82Nlzh9s6Uab2QGtUoYZ+el9jmVnaPFE5dnvz7WbqyAThJh8f3orjKpajPjRq/vQYrLhs/+ag1SVXPJzNZtseH73SQDA3eVFvttFUcTPZxXi9YPN+OaUCfdtrsIz35uEui4rzh2ehtlnfM4RUWRIrp988MEH8fLLLzPsIiIiIqKQ7W0ywu4SkZOqRPEwre/2QBqIL19QCqM1eZfDnG5Onz7IPaXrXQWzbH4pThltyNWpYbPHXp8dl8uN+pbTmxyYbC7otQpYrE6olXJs3F7r93GrPjiCX5w/Gnf19BLqsnqWoEWrl1AszvlPjncAAM4v1EMlPx2oxuJYpRiuU8NgtuOUyY5djV24cLT077ZPfVkHi9ON6SPSMH9MZp9jCpkMf/jWeHzrHztxuN2CLgCPXzUZp0x2jEhTw2LjUmyiSJP8K6A5c+bg7bffht0eWyk9EREREcUfb7+uOQUZfVpiBNpAXCZL3jYaexrDvxNjby6XG06LHf/5ugFX/PVLXLjxEzgt9pj8gv7liQ4sfv4rLPzTp1A6nDAaLHDbnTBY7APOIYPFCbfdCVOnBTk6NUydlqid41DMeUEQIJfLAm4/4w27LhytH/KxRpq3wuqLuk7Jj2022fB3b1VXRZHf6zlleBpWLSjFttsuwN93NqBwzWaUPLwF+as34cnttdDq1JDLw1uRSUSnSa7samtrw5/+9Cf85S9/QWZmJtRqdZ/jW7ZsCdvgiIiIiCixeb9onrm0J56apEeDw+XG/mZPw+tpYdyJ0Z/JeWnY32SECKDJaMPwNPWgjxlqu3uCvyK9xhdUud2QMIc81UfRrEKK5JyXy2UQVAqkaBQBb/TgcLnxWc/788KivpVPifD+nFOYgdcONPsCdyk2fnG6qmtecWa/9/tFeTGerKyJmWWpRMlEcth13XXX4brrrovEWIiIiIgoibhFEV82eL5onjdS3+dYPDVJj4ZDrd2wOt1IV8tR1Gv5ZySkqxWYmJuK/c3d+LKhE1dMyI3o6wXDW+U2rdeSTilzKBb22QrXnBcEATKZALdbhCiKkMtl0OrUWLe1GhsqawNuer+n0YhuuwuZWgUm5eoiMtZo8vYI3HGyE063O6C+d4IgwGB14N2qVgDAPRXF/VbJCYIAnVbZ7zLaWF/qSRTvJIddV111VSTGQURERERJ5lBrN7psLqQoZZiUe/YOZf01SV9SXhRzTdKHmjfcKRueBtkQJDVzCvXY39yNL+pjL+wSRRG7G7sAnL2kM54a7QOhjbe/6i1BANZtrcaaTdKqi7xLGMtHDfM7x+Lt2p5pfHYqMtQKdNqc2HfKNGDvu97X1mKS4+CyefjieAfKMrVwu/0HVYEu9VTIBO5QSBQBAYVdP/nJT7Bx40akp6fjhhtuGHCN9z/+8Y+wDY6IiIiIEpd3CePM/Ay/VRW9m6QvX1CKdrMD6RoFtlW3odtohdjPl8xkEMnm9P7MKczAX3c1BLXkK9KOG6zosDqhkguYmNO3AunMOdRpcSJDG70m9IPpPd5755eiyWhDjk4Fm23g8fZXvXXvvFLcddGYoBrJ99evy99Y4+HankkmCJhVmI7NR9vxRX1nv++l/q7tHRVFOH90ab/nmghLPYniWUBh1+zZs6FUKgF4GtQTEREREYXK15z+jH5dvblcbsBih9HqgCCKmLyhErUdFrz9o2ln9flKJr5lexHu1+U1u8ATBOxvNsFocyJNLXmBSMR4q7om5eqgVvgPTb1zSCETYLTF9rIx73g7zTb88MW9qG4z438Wn4vp+f0Hm4JK4bd664Vd9fjh9ALJ1UXddhd2nPRc14F2Koy3a3umOYUZ2Hy0HV/Wd+Lns0b6vU9/13bNpioIEPqtjEuEpZ5E8Sygv6WWLFni97+JiIiIiIL1pTfsGjl4aCWKIuQAZuane8Kuwy1JG3ZZHC4cau0GAJRFaCfGM+WnazAyQ4O6Tit2nuzC3AGacg+13b5+XQNfC1EU42q5mEwQkKVR4PNuOz6qae837BIEASkahd/qrSajDcNSpFcXfVnfCbtLREGaGsUB9ISLt2vrdV6hHgDwRUNnT++2viuYBrq2QN/KOO8mB73F+1JPongm+VcyFosFL730Eqqrq+FyuXy32+12HDhwAP/+97/DOkAiIiIiSjz1XVY0GG2QC8B0CUvxLh+fg1f2n8I7h1vw4PySIelXFWv2N5vgdIvITlGiYAh3RjyvMAN1nVZ8Ud8ZY2GXpwJp2hAt6RxKc4sz8e6RVnxU24FflRf5vc9AvaFau+3YfKS13+qiO/qpLvItYSwaNmALm3hXNjwNarmAlm4HajosGJOZ0ue4lL5b/np3xftST6J4NviWE2e477778PTTT8NiseCtt96Cw+FAdXU13n33XXznO9+JxBiJiIiIKMF83tOva/LwNKSq5AE/bl7xMKSq5DhptGFXzzKrZHO6X1fakAYR3kq6z2Oob5fT7cY3p0wABq/sikcXF3mWEO5o6ITR5vR7n969ofx55MMqLJtfipWLxvnuo9cqcd/CsbjrwmKI9rOf93S/rv6XMCYCtULm69Xlrx/dYNfWWxnXX5N6wBN4OS12GA0WKBxOGA0WOC12Bl1EESY57Pr444/x+OOP4/HHH0dJSQluvPFG/Otf/8KNN96IqqqqwZ+AiIiIiJKedwnjeRKXImoUclxSkgUAeOdwS9jHFQ9O9+sa2komb2+13Se7YI+RL+qHW82wON1IU8lRckZVTiIYrddizDAtXOLpAOpMvXtD+fOt8bmw2124s7wIjQ8sQtMDl+DkykWYVpCBi57ajsPNpj7377A4fAFif83pE4k3xPUXdnmv7R0VRX4fK6Xvlmepp5s9uoiGiOSwy2azoaioCAAwduxY7Nu3DwDw/e9/Hzt27Ajr4IiIiIgoMQXSnL4/V0zIAeAJu5Lxi+PensquoerX5TU2KwXDNApYnKerqaLNW91XNiItYZe0zi32VFdtq/UfdgGe3lB3zy3BfQvH9qneWrloHJbNK4HL5uhTXWTqtODp7TXYf8qERytr+jzX9hMGiADGZ6UgTzd0y2SjxRu4f9ngv2JRtDtx54Vj+r22/irjiCj6JIddJSUl+PTTTwF4wq6dO3cCAIxGI2w2NtgjIiIiooEZrA5fg/VZBdLDrnnFmUhRylDXZfMt6UsWJpsTVW1mAMDUIdqJ0UsmCL4qmC9jZCmj9+efiP26vLz90T6qae/3Pi6XG3/8sArTC/Wov99TvdX4wCLcWV7UpzdU7+qiey/0VIK9dagF35w6/T7yVpBVFCX2EkavmQXpEAAcbbegufvsXRX3NXWhYuN2zCjU+yrj/F1bIootksOuJUuWYNWqVXj55Zfxve99D1u2bMEvfvEL3HnnnbjwwgsjMUYiIiIiSiDeoKQkU4ucVJXkx2uVcixM0qWMe08ZIQIoTFcHde1CNcfXt8sw5K/tj7c5/fQE7NflVT5SD4VMQK3BitoOi9/7ON1ubPz8BBY//xXe2l0XUG+oSbk6XHVOLgBg3cenq7uSpV+Xl16jxIScVADAV35C3Od2NuBQswnPfVrDvltEcURy2LVgwQL8+9//xpw5czBixAj83//9H4qLi3H99dfj4YcfjsQYiYiIiCiBhLKE0euK8Z6ljG8dSq6ljFVtZpw7PA0XRanqpndlV7Sve7fdhUMtngrBoa5yG0o6tQKzCjyVax/V+q/u2lbTgeZuOzK1Clw4eljAvaGWXVgEuQBsPtaOL+oNOGWyQatSIFenwgUjg39/xps5/fTtMlgdeOXAKQDAzTMK2XeLKI4ognnQyJEjff89YcIETJgwIWwDIiIiIqLE9mUYwq75Y7KgVchwotOKb06Zhrx/VSgEQYBMJsDtFgP+0iyXyyCoFLh97lhcM3MUhqepYbU5IdqdQ1pdUjY8DRqFDO0WJ6rbzRiblTpkr32mfc1GuEQgT6fCiLTE7i01tzgTn9V14qOaDtw4reCs4y/tawIALJ6YB5U88HqG4mEp+OGUEfiq0QhdmhalhcPw5k2zkadTwWZ3Dfn8ipY5hRl4fvfJs8Kuf37dBIvDjXNyUnF+EoV/RIlAcmUXEREREVGw7G43HACyU1UhhV2pqtNLGd+Ok6WMcrkMCq0KaXotHEo50vRaKLQqyAcJJ+RyGbQ6NZ7YXoPCNZtQ8vAWFKzehCe310KrUw/6+HBSyWW+JYP+dq8LF0EQPAHfAE3nd3t3pRyRNuD9EsHcnkq+T453wHFG+GSwOvB+VSsA4PvnDpf83MsvHoNtt12AD6tbkb/aM78K12yOyvyKFu9n0TenjOjuaTjvcot4blcDAOD/zShI+DlGlGgS/5OLiIiIiKLOG/RkZerwyk9noWbFAozNzwjpi/TlPUsZ346DXRl7B1YjHtzk+xNIoCCoFFi3tRprNlXBYHEAAAwWB1ZvOoJHtx6FoApqsUbQZvez5CscpASC3rBr6vDEbU7vNTkvDZlaBUx2F3b19CnzeutQC2wuEROyUzE5Tyf5ufMyU7GhsgZrN8fG/IqGgnQNCtPVcInAzpOeebXpaBvqOq3QaxRYPDEvyiMkIqkC+tfF9u3bYbefvTMFEREREdFgegc93sqRkWs248ntx0OqHFlUkgmNQoaaDguOtHkad8dq9UWggdWZFU2CICBFo8CGylq/z7u+sgYpGsWQnnd//Y1CJTUQTIbm9F5ymeBrGP9RTUefYy9941nC+P1z8yTPA+/82ri91u/xaMyvaJlzxk6jz+30VHX9aMoIpCjlURsXEQUnoH9ZLFmyBO3tnmaICxYsQEdHxyCPICIiIiLyiFRlUqpKgZ9ML8DrN87C9JJsNJts0GUEtjRwKAUSWKVqFFD6qWiSyQW0ddt91+1MBosDnRYnZLKhCyNmFWRAJgDHDVY0GW1he14p86Td4sBxgxUA4qpfWyjmFWcCALbWnG5Sf7TdjB0nuyAXgKsnSa8+kskEGCyOmJpf0dJ7p9HDrd34+HgHZAJw4/T8KI+MiIIR0L8s0tPT8dRTT2H69OloaGjAu+++C53Of4nslVdeGc7xEREREVEcCyToWb6gFEarQ/JSRLlchseumITff3QUP3tpDwwWB/RaJZZWFGPZvBJYTLaYaK49WKAwPE0Npxv44/YabKis9Z3HHRVFWFoxBhlKGfRapd/H67VKZGgVMNr8P3ckpKkVmJijw75mE75s6MQVE3JDfk6p82RPT1VXSaYWeo0y5NePBxf39O3a02hEh8WBYVqlrzH9vOJM5OmkN+l3u0XotcqYml/R4l2ee7zTiveq25CdqsKs/HSMytBGeWREFIyAwq6VK1diw4YN+PTTTyEIAp599lnIZGf/tkwQBIZdREREROQTaOWIQibA5ZIWdgkqBR7fdhRrN1f1eb7Vm44AAO4sLwIs0W/FMVig8LvvTsSjPRVNXgaLA2s2VUEUgZvnjMIdFUV9jnstrSiG2eoc8p5lswszsK/ZhC/qwxN2SZ0np/t1JUdVFwDkp2swPisFh9vM+OR4By4fn4NX9p0CAFwXRGN6ABBFEWarE0srin3vm96iNb+iYWJeGt6+aTbmlmah2WTHikvHo7nLCrlMiInQnIikCSjsWrBgARYsWAAAmD9/Pl555RVkZmZGdGBEREREFP8iVTkSyYqxcBsoUMhOVWF+aTZu+L/dfh+7cXst7ls4FvfOK4UAAesra/xWsA21OYUZ+OuuBhxpM0Mul8HtFiVdZ0EQIJMJvsdZHE4M02kCniend2JM/Ob0vc0tzsThNjO21rRDr1GiwWhDhlqBS8dmBf2cot2JZfNKACBm5tdQ8/aL++Kretzwz90xWyVKRIGT3CDhww8/BOBpWn/06FG43W4UFxfjggsugFKZHCXERERERBSYSFWORLJiLBJEuxP3zCuBWxSxcfvppYqrLhkHo9U54HkYLE6oXC7cWV6E5QtK0WlxIkOrgNnqjNqX8IuKM/H6jbOwcFw2TFYn9ClKz8/R7hxwPHK5DIJKgRSNwncNOkw23PHaAfx09mgsKS/qU6nn1XueiKLoa04/LUn6dXnNLR6Gp3fU45tTJuSla5CdqsJ3xmZDowi+gbrL5YbFZIup+TXUvP3iYr1KlIgCJznsOnXqFG699VbU1NSguLgYLpcLx48fR35+Pv72t78hL4/bshIRERHRaf0FPaFUjsRbryGXy41Pq5oxvVCPuvsXotvmQoZWAYvVCa0mgPMwOCA6XDBaHVDIBBht0atYk8tlGJWXhv/df0pSrzRv9cy6rdV9epMtKS/C09dNxR2vfY3/vm4qZELfCrYl5UX45UVj4OoJG+q7bGg1e67DuXn++wgnqoriTLz5s1mYPzYbzSY7Vn/7HLQabZALCCmUcrncgMUeE/NrqMVTlSgRBU5y2LVq1SpkZWXhb3/7GzIyPE38Ojo6cPfdd+Ohhx7C+vXrwz5IIiIiolhx5vIrGpzL5cauY21nBT2hVI7EY6+hN/c346kv63DT9AI89q3xvkBBBAI+D1EUo16pFmwVTO/dFns/zvs8T1wxCQ6zvU+FUZpGgfcPNeOCDZW476JiLCzJwqFWE84dnoYsjSKkiqZ4I5fLkKlT46tdJ/HTFyOzIUMszK+hFm9VokQUGMl7Mn/++ee4++67fUEXAAwbNgy/+c1vsH37dknPdfz4cdx8882YNm0a5s6di2effdZ3rK6uDjfeeCOmTp2Kb3/726isrOzz2E8//RSXX345ysrK8JOf/AR1dXVST4WIiIgoYHK5DAqtCml6LRxKOdL0Wii0Ksjlkv85lZT+U9WCxc9/hf/3z91QOJwwGixwWuwhfTn39hpauWgc9FpPOw29VomVi8Zh2bwSiHZnuIYfFpuPtQEAZhekw+Vynw6w4ug8AqmCSdEoIAiCpMdt3F6LYTo13G4RTosdRoMFCocTJoMZb+xpwMFmE/7w2XHYFXJcNWMU3rxpNt675fykeg/2Dhm9wYw3ZHx061EIKsl1DIS+VaL+eKsr3W4GXUTxRPInYkZGBjo7O8+6vaurS1LPLrfbjVtuuQWTJ0/G66+/juPHj+NXv/oV8vLycPnll+P222/HuHHj8Oqrr2Lz5s1YsmQJ3nvvPeTn5+PkyZO4/fbbcccdd+DCCy/EU089hdtuuw1vvfXWWX+xEhEREYWqv+VXbF4cuMrjBgDAlDxd2K7Vmb2GGrtsyNGpYrLXUH2XFYdbzZAJnibjvcVTz6Rgq2CkPq53hdHDi8bCIYp4cvEUbKis6XcpbCxdp3DjUrvIiccqUSIanORfg3znO9/Bfffdh88++wwmkwkmkwnbt2/H/fffj29/+9sBP09rayvOOeccrFq1CkVFRbj44otx/vnnY+fOnfj8889RV1eH1atXo6SkBD//+c8xdepUvPrqqwCAf/3rXzj33HNx0003YezYsXjkkUfQ0NCAL7/8UurpEBEREQ2q9/IrVlRIZ3e58WW955el5aP0YX1ul8sNp8UOU6cFS1//BsUPbcGbexpiLvj48Fg7AGBmfjqG+akg8Z6Ht6IpHJVvkRBsFUwo1TMquQxPfO9cbKisSdqqpkDDQpmMv/gPRjxVVxJRYCSHXXfeeSemTZuGm2++GbNmzcKsWbPw85//HBdccAHuueeegJ8nNzcXTzzxBHQ6HURRxM6dO/HVV19h9uzZ2Lt3LyZOnIiUlBTf/WfMmIE9e/YAAPbu3YuZM2f6jmm1WkyaNMl3nIiIiChcgl22RaftOtkFi9ONrBQlJmSnRuQ1RFHEhLw0tHbb8cHRtoi8Rig294xpQUnWgPfzVDS5Y7aKpHcVjD/9VcEE+zjA8x7MSFVh4/Zav49Nhvcgl9pFVu/qysYHFqHpgUvQ+MAi3FlelPBVg0SJSvKvQFQqFdatW4ff/va3qK2thUqlwqhRo/oEU1LNnz8fJ0+exLx583DppZfi4YcfRm5ubp/7ZGVloampCQDQ0tIy4HEpEuHvRO85JMK5UHRwDlGoOIcoVLE8h+TywCoqlHLP8is2sD/b9hMGAEDFKH3EKk8EAbhiUh5+/9FRbD7aBpfohkIWG72cbE43PjneAQBYOCYzJue5JA5PFQyAPrsmepcUWrtt/s/RMfCunP09Tup7MBix/BnkIcIyyFI7i9UJQIzhc4htbrcbsNphsjmglAkwdZ5eEhrINY39OUSxjnMoMIFen6DrfdPT0zFlypRgH97H+vXr0drailWrVuGRRx6BxWKBSqXqcx+VSgW73bOry2DHpcjKSgt+4DEmkc6FooNziELFOUShitU5ZHe6odcq/X7Z1muVSNMooJarYHG6oJTJYLA6oNco4XC7kZrgy6sC8cVJIwDgW5OGIzs7cj/j84eJyEpRos3swGGjAxeXZEfstaTYdKQFZocbI9LVmDtpRMJUIN09rwS/XTAWTUYrslJVONlphValgHaAOb+1qsW3K6fZ7kJGz/tksMcN9h7Ua5VQKdQhn1OsfgZ53Tu/FMDZIeO980uhUcoBXejXgEIT63OIYh/nUHjExL++Jk+eDACw2Wz4zW9+g6uvvhoWi6XPfex2OzQaDQBArVafFWzZ7Xakp6dLfu22NiPi/ZeuguB5QyTCuVB0cA5RqDiHKFSxPocUGlW/FRVLyouwvbYd0wsy8OQnx/w2sLd2J+8yGIvDhc+Oe/pVTcvSorXVGJHX8c6hBWMy8fK+U3h5Zx0mZcTGF//XdtUDAOYVDUNbmynKowkvqyDg1b0n8ci2GkwfnoYXrp084P2f3l6Dl/edwl0XjMb980pgtHmqZywDPmrg96BnCaQDXVbpv/j2ivXPIC+5XIa7/G5kYIUpST9jYkW8zCGKXZxDgfFep8FELexqbW3Fnj17sHDhQt9tpaWlcDgcyMnJwbFjx866v3fpYl5eHlpbW886fs4550gehygiYSZSIp0LRQfnEIWKc4hCFatzyG3vf/nVry4egx11Bjzx8TGs3Vzle4y3eTYA3FleBNEZ/BfxePZlfRfsLhEjdCoU6bUR//leWpqNl/edwvtVbXhgbklMVFFtOdbTr2tMVkzO71CIooiZw9PR2m3HR7Xt6LQ6ka72/xXD7nLj/SrPv+HnFQ2D0xl4OOO2D7x00mKyheXaxupnkJfT6QacdjitDihkgi8spNgR63OIYh/nUHhIbmTwzjvvwGAwhPzC9fX1WLJkCU6dOuW7bd++fcjMzMSMGTOwf/9+WK1W37GdO3eirKwMAFBWVoadO3f6jlksFhw4cMB3nIiIiCicXC433tt70rf8qnfzYpfFjguKMpO6efZAKk94elVVjB42JNdgXvEwqOQCajosqG43R/z1BlPbYUF1uwUKmYCLioZFezgRMSEnFeOyUmB3ifigurXf+31c24Eumwu5qSrMKsiQ9BpsIN5XrG9kQEQUbZLDrgcffBDt7e0hv/DkyZMxadIk/Pa3v0V1dTW2bduG3/3ud/jFL36B2bNnY8SIEVi+fDmqqqrwzDPP4Ouvv8Y111wDALj66quxa9cuPPPMM6iqqsLy5ctRWFiIOXPmhDwuIiIiIn9e3teExc9/hTX/PgiFwwmjwQKnxQ5RBDqtgzfPjlRj9li3/bgBAFA+Sj8kr6dTK3yv9UF19Hdl9FZ1zS5I77fiKRFcPj4HAPDWoZZ+7/P2Yc+x74zLhjyI94PL5YbTYofRYOnzHky2oIuIiAYnOeyaM2cO3nnnnaCawfcml8vxpz/9CVqtFt///vexYsUK3HDDDfjJT37iO9bS0oLFixfjrbfewlNPPYX8/HwAQGFhITZs2IBXX30V11xzDQwGA5566qmk/Y0pERERRZbT7cbmo57Qonykvk9Fhdst+hpk+6PXKpGhVcDtTr4KDJPNid2NXQA8lV1D5dJST2P6/0Q47BIEAXK5bMB/g2455vkl8YKSrIiOJdq8YddHNe0w2pxnHXf0WsL43Qk5Ib0Wq5qIiGgwkn+91NbWhj/96U/4y1/+gszMTKjVfRt/btmyJeDnysvLw8aNG/0eGz16NF544YV+H3vxxRfj4osvDvi1iIiIiIL1ZX0XDFYnMrUKzCzouyGOKIowW52DNM92JuUX88/rO+ESgdF6DUZmaIbsdReVZuHeTVX4qqETrWY7slNUgz9IArlcBkGlQIpG4esdZbY6IdqdfaqMLA4Xtp8wAAAWjMkM6xhizcScVJRkanG03YJNR9uweGJen+OVxw0wWJ3ITlHivEJ9dAZJRERJQ3LYdd111+G6666LxFiIiIiIYpK3D9GCMVlQyM4ujBcDaJ6djLxBz1AtYfQqTNfg3Fwd9jWbsOVoO74/eXjYnlsul0GrU2Pd1mq/O2/27h/16QkDrE43CtLUmJCdGrYxxCJBEHD5+Bw8+dkJvH245ayw6/QSxpygljASERFJITnsuuqqq3z/3dnZibS0NAiCwCWERERElJBEUcT7PcvhLi31vxStd/Ps5QtK0dhlQ45OBZPFkZTNs70qj59uTj/ULi3Nwr5mEz6obg1r2CWoFFi3tRprNvW/8yYsnnYfm31LGDOT4t/K3+0Juz481o5uuxOpKs9XDafbjX9XecIu73JHIiKiSJLcs0sURfz5z3/GnDlzcP7556OhoQF33303Vq5cGXIfLyIiIqJYU91uRk2HBSq5gHnF/S9F6908+56396P4oS34++fHkzboMlgd+OaUCQBQMcSVXQBw6VhP364Pa9phdbqCeo4ze3IJgoAUjQIbKmv93v/MnTfrjTZkp6owf0xi9+vyOjdXhyK9BlanG5uPnt7QavsJA9otTmRplbhglLRdGImIiIIhOex66qmn8NZbb2HdunVQqTz9D6666ips374djz32WNgHSERERBRN3ibnF4zUQxfAbnqiKOLc7FS0dtvx5qHmSA8vZn16wgARwNjMFOTp1IPeP9ym5OkwXKeC2eHGpz3LKQMll8ug0KqQptfCoZQjTa+FQqvCCaMNp4y2AXfeNNlcUGiVSB+Wgj9fW4aaFQvw7XNHQC6X/M/uuONdygicXrYIAO/0/Pdl47L9LgMmIiIKN8l/27z++utYvXo15s2b5/utVXl5OR599FH8+9//DvsAiYiIiKLpA+8Sxp5KoUB4d5v7vK4TTcbk7NdV2RMwVYzWR+X1BUHAJT3LTj+t6xx010Qvb0+uJ7bXYMSDm3x//lhZg1E5OmSlqvrdeXP2KD1SVHL8sdLz2JKHt2Dkms3Y+NlxaHXqpAi8vtsTdm0+1oZuuwsut4h3j7T2OUZERBRpkv/GbWtrQ25u7lm3p6enw2w2h2VQREREFFlnLs8i/1rNdnzV0AkAvuAkEIXpGszMT4cI4K1eFS7JZPtxA4Chb07f27XnjsDrN87Cw1dM6lOhNVDo1Lsnl7eCy2BxYO3mKqyvrEGnxYE7Kor9PvaZa8uw7sOqsx67etMRPLr1KASV5Ha5cadseBpGZmhgcbixtaYdn9cb0GZ2YJhGEdW5QEREyUVy2HXeeefhueee63ObyWTCH/7wB8yZMydsAyMiIqLw6295VjJUnARjy9F2uEVPL6LCdI2kx37vHM8vB988mHxLGVu67TjU2g0AuCBKAYdcLsO8iXnYWW/AyDWbfRVaT26v7bfKarCeXBu31yI7VYV755Vg5aJxvgovvVaJdd8+BxNydAH380pUgiD4Krg+qm3HriYjslNV+NbYbCj5OUNERENE8q+XVq1ahSVLlqC8vBw2mw233XYbTp48ifz8fPz5z3+OxBiJiIgoDLzLs9ZtrcaGyloYLA7otUosrSjGsnklSb1rYH8+qPYsv5JS1eV1xfgcrNxSjR0nu1DfZZUclsUyQRAgkwlwu0WIonjW8V2NXTh3eBoyVHJkpaiiMEJPhdajW6uxdvPguyZ6yWQCDBbHgD25DBYnVC6Xb+fNTosTGVoFrHYXOiz2AR/baXFCIRPgcp19zRLJ96eMwKKJw7FwXDZaTHYsWzQeTZ1WyOUCP2OIiGhISA67hg8fjldeeQWfffYZjh07BqfTieLiYlRUVEDGhpNEREQxq/fyLK/BvvwnM6vThQ9rPDvKXRpE2DU8TY3zRmbgs7pOvH2oBbfOHhnuIQ45uVwGQaVAikbhC0vNVidEuxMul9t3/OoZo1A+Pg/D09Sw2k4fHyqB7Jq4fEEpjFZHn7DO7Rah1yqh1yr9hlZ6rRIZWgWMBgdEhwtGqwMKmQCjzXNfvV47+GNt/sOwRCGXyzBzTBYe+bAaP3tpD0N1IiKKiqDTqeHDhyMvLw9FRUUoLi5m0EVERBTDAvnynwxLrKT49IQBZocbw3UqTBmeFtRzfG+CZynjG3G4K+OZfd36a9zuXRaoVMp9xwvWeJqzF6weeNlgpARSodVpcUIm6zvfRVGE2erE0n56ci2tKPaEez0BmSiKcLncEEVR8mMTlTdUX7s5efuWERFR9En+26axsRH33HMPvvrqK2RkZEAURRiNRsyfPx8PPfQQ9Hp9BIZJREREUpy5zCzQL//JsMQqEIIgYH9rN7JTVVhUkgVZkCHgd8bn4Lebq7Cn0YhagwVFem2YRxp+/VVvCQIGrAxcWlEcM5WDAVdo+amyEu1OLJtXArcoYuN2/8t9++N9LOAJkKU8NhEEW1FHREQUbpLDrvvuuw9yuRxbtmxBQUEBAKC2tha//e1vsXLlSqxfvz7sgyQiIqLA9BdUNHeYMTIvPemXWA2m9/W76fzikHsN5aaqcMEoPSqPG/DWoWYsPW90BEYdPv31dbt3XinuumhMvyHG/+6qx28XjI2ZkKN3lZU3bOttoCorl8uN+mYjphfqUXf/QphsTt/7aLAleC6XGxaT7ax+XoE8NhEwVCciolghuZ78q6++wn333ecLugCgqKgIK1euxMcffxzWwREREVHg+ltm9sT2GmQOS8Gnte1YUl7k97HJssRqIGdevzEPb8HINZvxP7saQlqG513K+ObBlnAONyJ693XrvQTthV31aDbZ+g0xtEo5OoJYNhhJ3iqrM3dNXLloHJbNK4Fod/b72A+qWrH4+a/w3f/+HEqHC0aDBU6LPaCwyuVyw2mxw2iwQOFwSnpsvOtdUeePN1R3u5P3c4aIiIaG5H+1lZSU4MiRs39DVldX1ycAIyIioqHVX1CxZlMVNlTWQKeSY9m80qC+/CeD/q5fqL2GvjMuG3IB2NdswtF2cziHHFYDLUFrMtowLKX/EMPicGFYjIUcvausGh9YhJoVC1B3/0L8oGzEoFVWHx7zbEwwdXiaryeXVL37eSUL9i0jIqJYEdC/2t544w3ff5933nlYsWIFDhw4gMmTJ0Mul+Pw4cN4/vnn8bOf/SxS4yQiIqIBDNYrZ+P2WqxYOBZmo9W3xKqxy4YcnQrdFkdSLLEaSCR7DWWlqHBR0TBsrenA5mNtGJej8/VSiyUDLUFr7bZj85HWfpcF/mh6ISyO4JYNRpLL5QYsdhitDry0uwG/r6zFBYUZ+O8rJ/X/GLeIbbWesGv+mMyhGmrCSPa+ZUREFBsCCrvO7MM1bNgwvPfee3jvvfd8t6WlpeHVV1/FbbfdFt4REhER0aAC7pUjAq6eL/93v3MA22o6sKyiCD+Zmj/EI44tke41dOP0Qiy9uBQLx2X36QEl2p0xEzIO1tT9kQ+rsPXWCwD4DzFsZnvMhhyiKGJqng6t3XZsqWmH1emCRiH3e9+9TUa0W5xIV8sxIz99iEca/5K9bxkREcWGgMKuDz/8MNLjICIiohBI3X1OFEVMyErBq/tO4Z3DLUkfdoWye99g5HIZrp5RiHUfVuNnL+3xGwLFQgAwWFP3b43Phd3uGjDEcMdwyFE2PA0jdCo0muyoPG7AwpIsv/fbWuOp6rpo9DAoZMH1aUt2vSvqFDIBRht3XyQioqEVVPOJQ4cO4dixY7Dbz94++sorrwx1TERERCRRMLvPfXd8Dh7aVoPK4x1otziQ2U+/pWQQyu59gxFUCjy6tRprN1f5bvP2AgOAO8uLAMvZ/6aKBtHuxG/mlsAtiti4vbbfYK6/ECOWQw6ZIOBbY7Pxt90n8e+q1n7DLm+/rnlcwhgyT9+y2Pj5ExFRcpEcdv3+97/Hs88+i6ysLKjV6j7HBEFg2EVERBQlot2Juy4aM2BQ0VvxsBScm6vDvmYT/n2kFT8qGxGlkccG0e7Ery8O/PoFIpK9wCLB5XJj7fuHcF5JNurvXwSTzX911mAhRqyGHJf1hF3vV7XisUvGQX7G7pAdFgd2NXYBAOYVM+wiIiKKV5LDrpdeegkPPfQQrr766kiMh4iIiIJU227GTW9+hVWXTsDJlYvQZR18Gdnl43Owr9mEdw63JH3Y5XK5seKt/bh04nA0rFwEYwDXbzCR7gUWbg6XG8/uqMNjn9TgjR9NRcXozJiqzgrV+aP0SFPJ0Wp2YNfJLswqzOhz/OPaDrhFYHx2CgrSNVEaJREREYVKciOCtLQ0TJ48ORJjISIiohCs+6QGXzca8fiHVTAazFA4nDAaLHBa7P0GNd8dnwMA+Ph4BwxW6f2oEklLtx3P7ajH4ue/wp5jrQFdv8H07gXmj7cXmNsdG2FS5XED2i1OZKUoMSs/HS6XO2GCLgBQyWW+5YvvV7eedfzDnn5d81nVRUREFNckh13Lli3D6tWr8eWXX6K+vh4nT57s84eIiIiG3jenjHhl/ykAwAM9O+IFElSUZqXgnJxUON0i/lPVFvFxxrJX95+C0y1i6og0lGamhCXo6d0LzJ9QeoFFwpuHmgF4QtBEbc5+2dhsAMB7R1r7XHdRFH3N6dmvi4iIKL5JXsZotVqxf/9+/OQnP4EgnO5zIIoiBEHAwYMHwzpAIiIiGpgoinhw61EAwOKJuSgbnibp8d8dn4ODLd1463Azvj95eCSGGPNEUcT/fd0IAPjRlPAu5xTtTizrCSDXV9b4eoHdUVEUdC+wSLC73HjviKfa6XsTcqM8msiZPyYTKrmAYx0WVLWZMS47FQBwoKUbp0x2aJUyzDljeSMRERHFF8lh1+9+9ztcd911uO6666DRsJcBERFRtG2taccnxw1QyQUsv8h/BdFALh+fg8cqa7GtpgNdNifS1UFt1hzXdjUacbjNDI1ChivPCW/Q43K5YTHZcGd5EZYvKEVrtx16rRKf13YE3QssErbVdqDT5kRuqiqhw540tQIXjh6GLcfa8e+qVl/Y5a3qKh+lh0Yhj+YQiYiIKESS69Ptdjt+/OMfo6SkBAUFBWf9ISIiChdBECCXy/pUEtNpgiBAkAlY/3kdAODm6QUYlaGV/Dzjs1MxPisFDreID/z0MUoG/+yp6rp8fE5Ewj6Xyw2nxQ6jwQKLyYbSh7dg0TOfY3+TMeyvdaZA30dvHuxZwjgh56xdChPNt3qWMv676vR8//AY+3URERElCslh10033YSnn34aNltslNwTEVHikctlUGhVSNNr4VDKkabXQqFVQS5PzB5CUvW+PjaFHB/cej7eumkW7g6iqsvr8p5G9W8dagnXMONGt92F13uCnh9OiewyTlEUkaGSY9oIz1LTF79pjNhrSXkfWZ0uX/BzZQIvYfS6tNTTpH53oxFNRhtMNie+rO8E4FnmSERERPFN8q8ut2/fjj179uCNN95AdnY25PK+Zd5btmwJ2+CIiCj5yOUyaHVqrNtajQ2Vtb7+Rksrin39jWJl2Vc09Hd97qgowoLS0qCvz+UTcvD4p8fxUU07jDYn0pJoKeO7R1pgsrswWq/B+SP1Q/KaP5wyAu9XteHl/afw24vHQBXmIFfq++jDY+0w2V3IT1NjZkF6WMcSi/J0aszIT8fOk134T3Ur8nRqONwiivQaFA9LifbwiIiIKESS/yW7ePFiLF68OBJjISIigqBSYN3WaqzZVOW7zWBxYPWmIwCAO8uLAIs9SqOLvv6uz5pNVRAgBH19zslORWmmFtXtFnxyogPfnZAHt1uMmV0CI8nbmP76ySMgG6IlswvGZCI3VYXmbjs2H23Dt8flhPX5pb6PvBV9V0zIGbJrEG2Xjc3GzpNd+LTOgEnD05CdqmJVFxERUYKQHHZdddVVkRgHERERBEFAikaBDZW1fo+vr6zB8gWlMFodcRXCCIIAmUwIOTyK5PURBAE3zSzEOfl6LBqXA6PNUwlktjoh2p0JW013rN2Mz+o6IROA75+bN2Svq5DJcN25edj4RR3+9+vGsIZdUueJ2eHCf6oTfxfGM101KRczirOwcFw2Wkx23LtoPBoNFsjlsoSd70RERMlCcth1ww03DNjg9B//+EdIAyIiouQlkwkwWBwwWBx+jxssDnRanFDIBLhcsR92yeUyCCoFUjQK3zIyf+FRoGFYJK+PXC7DkotL8djWavzspT1xs3w0lCBREARsO2FAdqoKZXk65KcP7S7T108egY1f1OHDY+1oMtowPE0dlueVOk+2HG2D2eHGyAyNr5dYopPLZZhQOAyvfxhf852IiIgCIznsmjNnTp//dzqdqKurw7Zt23DrrbeGbWBERJR83G4Req0Seq3S7xd1vVaJDK0CRpv/L/GxJJCeSQACCsO8Inl9BJUCv/uoGms3x8fy0UCDxMEee92Mkbj94hI0dAx9RU9pVgrmFGbgi/pOvLSvCXeePzoszytlngiCgD2nTMhOVeF7E3KSZudT7zLPeJnvREREJI3ksGvJkiV+b3/ttdfwwQcf4Oabbw55UERElJwau6zY1WrGkvKiPl9CvZZWFHsCjThYwjhYz6RfVhRDpZRJasTvdruxq64z7Ncn3paPhrKJQaxtgHD95OH4or4T//ymCUvPGxWWsMnhcuHL4x39zpMl5UWo67AgS6tEikaBX84fi0eumIR2ow1yAQlf0RRv852IiIikC9tWS7NmzcKDDz4YrqcjIqIk0HsJWku3Dde+tBcyuQwf314OmSBgfWVNvxVRsSyQL9O/vngMHvlw8MqS3tdo/efH8erBFmy77QIIAgasGJMi3paPhrKJQaxtgHDFhBys2FKNmg4LdjUZMbtQL3lJZu854na7cfd/jmBXk8nvPFlSXoS7LhwDEcAfPzmGjdujH/gNtXib70RERCSd5LDr5MmTZ93W3d2N5557DgUFBWEZFBERJTZ/S9D2tJshk8vQabajqcWIO8uLsHxBKZqMNmSnqnDSYImbL+GDfZlWyASoFHJs3F7r9/j6yhr8dkEpzAC0PdcoQ6PEjOJsvHqwBW/tbcBd5cX47YKx6LQ4kaFVwGx1Bn194mn5aChVObFY0ZOqUuDWOSNRXpKDiyRuDODvfXSwyYhdTSYcaTHh06oWP/PEgSajFf/cczJpl/DF03wnIiKi4EgOu+bPn39Wib0oihgxYgQefvjhsA2MiIgSU3/LyJaUF+Hj2y9AfbMReakqOC12GK0OvLCjDk9+dgIXjMzAf39vUrSHH5DBvkyPzUlF5wBh2PA0NVwi8MfttdjQq7ptSXkRPr2jAm6L3Xd9FDIBRlto4YwoijBbnVhaUewLPHqLpeWjUqtyelc9yWQCOsyxVdEjl8uw8lvnSN4YYKD30bbbLsDbextwQWHGWfMEAMZkpw4YtCb6Er54mu9EREQUHMlh15YtW/r8vyAIUCqVyM7OTpqmpkREFLz+lpGt3VwFQRBwV3kRnD1VJaIoYk5BBlq77dhU3QaTzQmdOmwr8CNmsC/T35s4HBkDhGG/++5ErPuwGmt6PdZ7jWSC4Ku8EUUxbKGMaHdi2bwSAOizfPSOiqKYWj4aSFWOTq3ACUM38oal9ql6qm0zY6ROE1MVPcFuDDDw+wi4q7y4z/vIO0/kchmX8KH/+R5Py6WJiIiofzKpDygoKOjzJz8/Hzk5ybN7DxERBW+wZWQbKmuQolH0+TtlSp4OJZlaWJxuvF/dOkQjDZ33y/R9C8dCr1UC8IQpKxeNwx0VRbDYHFhaUXzW47JTVZhfmo0NlTV+n3e9n2sUDi6XGxaTDXeWF6HxgUWou38h6u5fiPLRmTAbrTGzfLR3kOjPkvIifHq8HVnDUvHE9hqMeHCT78//7m6AzeXCkvIiv48d6oqeQJZV+vtZD/4+qu13jvQOC/3xBn5ud+IGXcDZ873pgUvQ+MAi3FleFDfLpYmIiKh/Af163N/SRX8EQcDmzZtDHhQRESWmYBpDC4KAq87Jxe+3H8frB5pxzaThQznkoLlcbnQYzJg5Uo+6+xfCaHViWIrS11sLgN/KklWXjIPR6oxK5Y3L5QZ6lr25nS6cu3E7jndY8OK1UzBvTGZYXysU3iDRLYpnNVi/e24JvmnswobKmrOqpdZurkKOToXlC8bGxAYIwTZKD6XBOpfwndZ7vodjOTARERHFjoDCrjvuuKPfY2azGX/961/R0NCAadOmhW1gRESUeIJtDH3VOXn4/fbj+Ki2A21mO7JSVEM15JB8fKwdP3zlG0zO0+HDm2bBaOgbIngrS5YvKPU1ELdYndBqots8WxRFaOQyXFqShWd21OPpHXUxFXa5XG50dVowy0+QaDfbMK0wA99+7ku/j33gP0fw8/NG464zrnsoDf6DFez7IdQG61zC11c4lwMTERFRbAgo7Lrqqv/P3n3HN1XufwD/nCQd6aClLbsIZRSQUSpTWqaAqODAPVCvV0EFXFfBKipTBL0ucOG6Kvy8CLi9KqA4AAUEAVGBFgoU6N4j6yTn90eakLRJ2zTrJPm8X6++2uYkJ8/JeZI8+eb7fJ+rHF7+3XffYdWqVairq8PSpUtxzTXXeLRxREQU+GwLhItGE/blVWJORne7rBsLZ1klvRKjMKhDDA4W1uDLI8W4LT0wVv/9LrcMAJDeKdbhtDBnmSUSIIvMmzuHdMFbe09jW245DhfXom+7aK/fZ0vtPV2JK9b9jtTEKOyYOcIaSGxJTaoKjQiVQfR7Rk9rs6zczc6yncLn74AfERERkTe4XLMLAM6cOYN77rkHc+fOxahRo/DNN98w0EVERHaUSgVU6nDExqthCFMiNl6NkxoRy77LxtzMFDwxqXEtq/nje0LSiw73N/38DgCAj/8q8tkxuEOSJGw9VgoAmNAjsdnrGo0ma3DCknnz5KRUlx4jT+sWr8alvZMAAGt+O+2T+2ypnXkVAIDeiVEwmSTrY+dKTaqGj7s/ODvXT0zq3eS5lvQi5jmpCdeSPmI0mswrNVZozIG/Cg1EjZ6BLiIiIgoKLi1pJYoi3n77bbz22mvo1q0b1q1bx6mLRETUiFKpgDomAs9sy8Gq7edqKs3J6I53bxiMvbmleCAjBY9d1LvFWSVX9G2HRduO4dfTlThTpUWXNpE+PirXHC/X4GSFFmEKAWO6xbt0Wzll3swa1hVfHi3Bxj8LkDUmBe2i5TGF9Jf6YNeFXePtLg+0mlQNz3VZnQFtIlX4PrsEZeV1CFc4rplqNJrwyo/HcEFyPE4/MRE1OmOr+gin8BEREVEwanFm165du3DFFVfgzTffxAMPPIBPPvmEgS4iInJICFfhmW05WLIl2zqdzFIgfPWOXIxISXQ5q6Rzm0hc2DUOAPDp3/LP7rJkdV3YNR7R4S59twRAPpk3w7q0QXqnWOiMEt77/axP79sZ0WTC7jNVAIBR58U32i6XzLiWsj3XYQYRY1dvxxXv7sG6/c4fb43BiJU/52L6f/bg4715zM4iIiIistGi0ffDDz+Mr776Cl26dMHChQvRoUMH7N271+F1hw0b5tEGEhFRYBEEAVGRKqzafsLh9lXbT+Cxi3qjWmtwOavkqvM7YGdeJT75uwizR5znoRZ7x3fHzfW6LurpXmF3f2feCIKAu4d1xazP/8K7v5/BnJFdEalS+q09APBHYQ1q9UbERajQN6lxHTE5Zca5QpIkQAKuPr8D9p2txprfTuO29M5QOFgRe9NfhSitMyC5TQQu6pEg22MiIiIi8ocWBbu+/PJLAMDp06fx8MMPO72eIAj4+++/PdMyIiIKSAqF0GyB8EqNCJVCcDmIM7VPO2RtycYfhTXILq1F70T5FEy3VasXrdPsJjZTrysQTO2ThC6xEThTrcPX2aW4ZkBHuzpZvvbLqQoAwIiucVA2Mc3PUfH/QHDjwI5Y8XMujpdrsOVYKS7ulWS3XZIkrNljrqF255BkqBStKsFKREREFLRaFOw6fPiwt9tBRERBwrZAuKOAl6VAeLXOcTCsKQnqMIxLaYutx8qwOacUfdvH+jXo4szPJyugN0o4Ly4SPRPU/m6O21QKBR4dm4LkpFhMTE1CjU5EvDrMXPtKL/o8q2hnXiUAYFSDel2O+DszrjWiw1WYkdYZr+zOwxt7TjcKdv2QW44jpXWIDlfi5rROfmolERERkXzxq0AiIvIo2wLhjrhbIPyOocn45PZheGRyH+sqjyp1OJRK+bylfV8/hXFizwQIDqagBRqlUoF/jErB3tMV6LpkKzot2oJOi7bgpR0noI6J8OljbzRJ2HW6AgCsNdyC0T+HdIFSAHacqsChwmq7bW/8lgcAuGlgR7SJcL0eHBEREVGwk88nAyIiChqSXsS88T2xYGJvjxYIVyoVuDytiyyCLs5IkoTvjpuL018UBFMYAfOCAyu25WDpVvsFBxZvOYoV245BaEUB/tb6q7gGVTojYsKVGNAhxmf362td2kRiWt/2AIA3fjttvfzv4hpsyy2HQgDuHJrsr+YRERERyRq/DiQiIo8zGk346XAhLkiOR94TE1GrM3qkQLht0MXCEnQBgPszugMavScOodWOlNThdJUOkSqFw5UCA01zCw68vD0XWRf1si444M79WH43tZ9f6qcwDu8SF/S1qmYNTcanfxfhk7+KsGBsD3SIicCa+sDXJb2T0D0+8KfIEhEREXlDcI8SiYjIb/7vQD6m/2cPHv3sEFQGEdUVGogafesDXS0IukRFqvw+bdCS1ZVxXjyiwvy7aqEntHTBAYWTQvHNUSoVUKnDEROnRlGNDjFxTU9LtRT+v/C84J3CaHFB5zYY3qUNDCYJ6w8VoEpvxI8nygEAdw/r6ufWEREREckXM7uIiMjjRJMJXx8tAQCM7d7WIwXMvbnKoydtra/XNaFHgt/a4EmeXHBAEAQoFIJ1UQGlUgF1TASe2ZaDVdtPoEJjQLw6DPdlpmD++J6NsgBNkoRfLcGuFhSnDwbzx/SAIiIME1OTUF5nwOFHJ+DXE+UYnKiGyRRYhfeJiIiIfMWvmV2FhYW47777MHz4cIwePRrLly+HTqcDAOTl5eH222/H4MGDcemll2L79u12t925cyemTp2KtLQ03HrrrcjLy/PHIRBRiBAEAUqlwmHWUFPbQtXOU5Uo1RiQoFYhw0NT+WyDLo5Ygi7+DABU60TsPm2eZndRkAS7PLHggCV7KzZebbeogCJChWe25WDJlpbVAjtSUosyjQh1mAKDO8Z67iBlSqlUYMrATtYadect3YquS7bip9xSRMVGyqJGHREREZEc+W2UJEkS7rvvPmg0Gqxbtw4vvPACtm3bhhdffBGSJGH27NlISkrCpk2bcMUVV2DOnDk4e/YsAODs2bOYPXs2pk+fjo0bNyIhIQH33nuv7JaeJ6LA5+xDulKpaHJbqPvySDEA4JLe7TxWV8nbqzx6wk8nyiGaJPRMUCOlbZTf2uFpkl7E/PE98eSkVLsFBxZM7N3sggOW7K0Xd+RaFxTotGgL3tydh6iIMJempVrqdQ3rHIewEHieCeHmYGDDhQGWbMn2+cIARERERIHEb6Ok48ePY//+/dixYweSkpIAAPfddx9WrFiBMWPGIC8vD//9738RFRWFnj174pdffsGmTZswd+5cbNiwAQMGDMAdd9wBAFi+fDkyMjKwe/dujBgxwl+HRERBpqkpVo+O7wkJAp7Zlt2i6VehxGiS8NVRc7Dr8r7tPLpvS9AFMAdDLI/7nIzueHBMDxi9XJy+4TS8htsOl9UhKTo8aFZhtDAaTdDU6HB/RndkXdQL5XUGxEaq8F12CcrKaxHeREDTErBZssV+UYG1+07jpgu6uDQt9ZdTFQCAC7sGf70uXy0MQERERBSM/BbsateuHd566y1roMuipqYGBw4cwPnnn4+oqHPfig8ZMgT79+8HABw4cABDhw61blOr1ejfvz/279/PYBcReYyzD+mLtxzF1YM6YePBfIfbAHmsCugvv56uQEmdAfGRnpvCaNEw6FKpEdEmUoWvDxdh7Ks78Npl/dAr0b2MKkcBLaVSASFchahIlTXAVqcVrRlNlm13Z/bAE1P6orBSC6VSCKqAp9FoAjR6VGsNCBOA8W/vwm9nqvDypX1x/cCODm/TVMCmoFqHtlEtrwUmSRJ2WovTx3vqsGQrUGrUEREREcmR34Jdbdq0wejRo63/m0wmrF27FiNHjkRxcTHat29vd/3ExEQUFBQAQLPbXREMJXYsxxAMx0L+wT7UWFMf0pOiw9EjMQqrtuc6vK0l46JGF1gZF01lLTV/23O/z01hTEK4yvNTzUwmE6DVo0ZnQJhCQE2lHq/8fBwH86vx8LdH8MlNg6FoRWdWKhUQwlRQ2wS0NFoRgtGIcHV4qzL8tLXBmOEnQZKAST0T8duZKqw/VIAbBjkOdimVzgM2JbV6bD1agvsyU6xBYlv3ZaZAoxUBSBAE4FiZBiV1BkQoBVzQOTboX68kqWULA9ToDUH/WLQU38vIHew/5C72IXIX+1DLtPTxkU2xh2effRZ//fUXNm7ciP/85z8IDw+32x4eHg693pwlodFomtzuisTE4ClwG0zHQv7BPmSvqEbn8ENmx9gIFNXom8y4qNKKaJcY4+0mekytXkSYQoEKrQHxkWEwmEyIbkU9oPi2MfhfdikA4Jbh5yEpyTd96u0b0jHguR/wS14lPj1Wjpkju7m8D63BiOXf52CVzfTI+zJT8K+xPfDMtmOtyvB7ZHzPVj2OgWDW6B545udc7DhVgRqFEt0THGfU6UWT04DN8u+zse2eUQAaT0t9YEwPc32wmAgAwMc55lUuR3ZLQHLHeO8clMzU6sUmg4GiSUJiAL3O+Arfy8gd7D/kLvYhchf7kGfIYgT+7LPP4r333sMLL7yA1NRUREREoKKiwu46er0ekZGRAICIiIhGgS29Xo82bdq4fN+lpdUIoMQLhwTB/IQIhmMh/2AfakwQBMTFqR1+SC+o1qF9THiTGRdtIlUoLa2RfWaXUqlAZHQEVjrIWnIlM8nSh74+eBoF1Tq0iVAiLSESJSXVPjgKIBpA1ugUrP2jAF3aREAnGu2ysySD2ORxqCLD8cKO3EZBq1d3nsD8Cb0cZvG1NMMvEPpBa0QByDwvHj+frMAbPx/DvzK6O7yeFK7CnIzuWLo1u9G2KX3aw6A34oH6aalVWhGxEeZpqaNWbcdjo7tjSm9zuYPNf5mzt4d2ivFZv/I3pVLhsEad7fNTU6Xxcyvlg+9l5A72H3IX+xC5i32oZSyPU3P8HuxasmQJPvzwQzz77LO4+OKLAQAdOnRATk6O3fVKSkqsUxc7dOiAkpKSRtv79evn8v1LEoKmIwXTsZB/sA+dI0kSajUGhx/SS2r1OF5a12TGRZ1WhMkUAA9mmPO6ZIC59pgktjxr9ou/zVMYp/ROQphC4dP+dNewrpg1pide+vk4Zny4v8WLBgiCALWTKasdYyNQWN36DL9KjQiVIARGX2iF6wd0xM8nK7D+jwI8eGE3u5UTLV7+ORf3jTUHbFbvcL6Yg1FnQLvEGJSW1mDLXwU4XFSDB/53GNv+MQwdYyNQrhWRFB2OkcnxIfM6JYqNa9TFqVWo04ohvQhGc/heRu5g/yF3sQ+Ru9iHPMOvwa7Vq1fjv//9L55//nlMmTLFenlaWhrWrFkDrVZrzebau3cvhgwZYt2+d+9e6/U1Gg3++usvzJkzx7cHQERBbf2+05ibmQKg8Yf03olRmD++F4DG06/uH50CUwAUp/f0am8mk4Qv6ut1Tevj2VUYW0IVGYYXtx+3C062ZNGApgqBF1Tr0M5JFl9LMvxsC6wHo0tT2yF6SzZOVGix+0wlRiTH220/XlaHFT8ex6Y/C/HVHcPw+MTeTgM2lj4mSRIeG9MDO05VwCAB5SYgtW0U3rohHe1jwqHViRAMxpAJ9NguDKBSCKgOsFqARERERP7g+crBLXTs2DG8+uqruOuuuzBkyBAUFxdbf4YPH45OnTohKysL2dnZWLNmDQ4ePIhrrrkGAHD11Vdj3759WLNmDbKzs5GVlYXk5GSuxEhEHlOhNeDxLdkY++pO3JjWGflPTULBU5OR/9Qk3J/RHXU1OmhqtLg/o7t129knJ+GC5DhkrN6BNXvy/H0IzWrpam8KRcuqQP56qhwFNXrEhisxtnuCJ5varJYE7qIiVQ4zj0ymc4XAGyqp1eOHY6W4rz7o2XCbJcPPEUuGXzAHJqLDlZiWag5srv+jsNH2p3/KhWiSkBwTjhhJQnWFBiqDiOoKDUSN3mnAKkKlwHtXD8SP947C1pwSdFq0BT2f/g5dl2zFqp0noY6JgFLptyGMX0iSBKPRFNT9iYiIiMhT/DZS/O6772A0GvHaa68hMzPT7kepVOLVV19FcXExpk+fjs8//xyvvPIKOnfuDABITk7GqlWrsGnTJlxzzTWoqKjAK6+84vBDDBFRa7z0yylUaEVIJhPaKuDwQ7rRaIKo0Vu31VRqcOhUOQ4X1WDh98fw25lKCIJgXuVPhq9PTQV5gHOZSS2ZgicIAnbkliEpOhwX905ChBdWYWyKO4E7SZJQpxUxx0nNqdzSOsyf0AtPTkq1Plbx6jA8OSnVmuHnaNv88T0h6UXPHKCMXTewAwDg88NF0BiM1sv3nKnEF0eKoRCABeN6AHAtYNOtfSxW78jF0q3Z1vNqydRbse0YhCAt/E9ERERE7hOkEP+KsKQk8Iu/CQKQlBQbFMdC/sE+ZO9UpQYZb+6G3ihh3TUDMbFnYotvK0kSZn72F46Wa/D85f0xvleidYpjnVaEpG+6ULqvaZUKvLk7z2Hx8AUTe+PGwZ2RpHQeqFMqFRDCVYiKVCG/yjzlL79CgwSVwqfHKQgCYuPV6LRoi9MphflPTUJ1hcZhoOVEpRbdO7bBqu25DutK6er0kFRKREWq7KbhWYJZlseg4TY5nWtvMUkShr/+K/KqdHhtWj9MP78DJEnC5et+x+4zVbhpUEe8cEnfZvdj+zoEuHc+KTTxvYzcwf5D7mIfInexD7WM5XFqDr8WJSJq4JmfcqE3SsjsFo+Lerg2HU8QBKya1g/qWDVe/vk4blq3r8WF0n1BEAQoFOaC6SfK6/DAN0fwyT+GA7CvSzY3szvmZKRg3Ks7cd+Irph+fge720qSBKVSAXVMBJ5xspKjL4/Tkp3V3KIBzgIjT32XjROVOrx5zSDndaUMRud1k0K4ppJCEHDdgI74986T+Ca7BNcO7ITN2cXYfaYKapUC85xM82xyny3M1FMpBBiNofNYExEREVHLMNhFRAGnYdDFk/v8o6Aam/4qAgA8Oa5nq6YfxsREtqpQujfZZmBZglJlpXUo04j4539/xzvXDW4Q5DHg2e9z8HdRDVbvzsNF/Tqga1u1XZaaIKDZlRx9eZySXsT88eZV/xouGvDQ2B4Q6xy3Ze/ZKnyTXQqFAAh6g3laqpOglXkanuM+19S2YHfrBV2QmdoeE1OTUK0VMS09GR9HR+LI2Up0io1weX+2U2xDtfg/EREREbUeg11EFDAcBWzcnS7WcJ/DerXDx7cPww9HCpHWsfn02IY8vcKhJzjLwJqT0R0/zc5AWVktJJ0B1XrRLshz/8iu0BmNeHRSn0bT+x4d3wsPjOkhq+M0Gk3Q1Ohwf0Z3ZF3UC5UaEbGRKnxzuAgXv/EL3r2yPxKjwhvd7umfjgMArhvQEb0To0M6aNUaSqUCvTrHYcP3OfjH+v12/evRCb2gbUWGn7uZekREREQU2hjsIqKA4I0pc00FgZZN7Q9drev7lOP0KyFc5TADa+nWbAiCgAcyukPU6BsFeRSCgAUTU/HC9txGWWpr953GTRd0kdVxAuaAl+2UwiqNDk/872/8VVyLpT8eb1Q76qcT5dh+sgLhSgEPOylQT02z9K+GfWTp1mwoBKHVGX7OMvVsn/NERERERI6E1rrdRBSwbAM2nlqZzdk+l27NxrM/tG6fnlzh0BOayzRbtT0XUZEqh9M1BUFAlDoMq3c0vm1BtQ5to+RznA1ZVv1TCAJWTk4FAPzfwQLsOV1pdx1LVtetgzuja1ykX9oayFqSyeisfzXHNlMv/6lJKHhqMvKfmoT7M7r7te4dEREREckfg11EJHue+kAtCIJ52qIgeO1Duu30K0d8Pf2qpZlmCkXj42zqtiW1emw9WiKb42zKsOQ43DCwIwBg/pajMNUX1992ohy/51dDHabA/Rd283MrA5M7/asljEYTRI3eXEfNIKK6QgNRo2egi4iIiIiaxGmMREGkqcLt3ijq7ivuTg10VOtLqzd6bbphU4XSHx7XE/pa706/sj3XJpOEuMjWFfpurkj48u+zse2eUQDkP83siXE9cLxCg6yLUtGmbTSqtAZMHdwFH0dF4O+zFWgf3biWFzXPV4XkWUeNiIiIiFzBYBdREGiqcDsAjxd19zV3PlA7q8s1f3xPPDCmp1c+pDsslB6hwjdHinD7/+3Dq5f1bdW0ruY46gd/F1SjpKwMczK629VUsmgqA6u5IuFT+rSHXm+0HmeVVkSbSBXqtKLsppl1iI3E5lkX4rkfjnmsiDqxkDwRERERyRODXUQBrqnC7Y+O7wkJAp7Zlu2xou7+YPlAPTezu12RdYumPlA7K86e9b/DuKRfB8zNTMESL3xIb1go/WRZDW75v33QGEy4ok87TOmd1Kr9OtNUsf0HRvfAsK7xUAiCyxlYLSkSbjSaUKMzoF1iDEpLa/xWp6spQrgK//7xmMeLqBMLyRMRERGR/AhSiH/dWlJSjUB/BAQBSEqKDYpjIdep1OF4cUeuwyDQgX+NxcaD+Q6DOU9OSsX99avwBUIfUigEIDIcL/18HKt32AdzHhnXE4a6xnV8BEFAbLwanRZtcZi9Nfy8eGy7ZxRWfJ/TZCDHU5b9eBwv/3oKfZOise2OoVC4kd3VcFpqU/3giUm98VBmD5gkCVGRKlRqRMSpVS3O8LPNGHN2Wzn3oeb6Qbw6DPlPTUJ1hYYZSK3Ukj7SHDn3IQoM7EPkDvYfchf7ELmLfahlLI9Tc1igniiANVVkPSk6HD0So7Bqe67D27qzSpo//HqqAqNf2YFhXeOtK7OdeXIS0rvE4aLXd+JYSW2j2zRX62v3qQrU6Y14INM3q73NHtEVbSKUOFxSi0/+LmrVPpRKBVTqcMTGq2EIUyI2Xo0wdTiiIsOaWHHxBCIjlDBqDa0q9B3oRcK9XUSdAr+PEBEREVFwYbCLKIA19SG+Y2wEimr0QfMB/z+/n8Hhohr897c86wfqyrJaPLP1KH47XYV/fvonNAaj3YqLtsXZHYlXhyEmQglR07ogkKviI8Mwe8R5AICVP+fCaJKsbW0Jy1TFF3fkotOiLdafdQfOtjiYYy70bWpVBpM7t/Un25pvjljqs8lx+mWgCdQ+QkRERETBhcEuogDW1If4gmod2seEB8UH/JI6Pb44UgwAuD29s/UDtVIh4M0r+iMxKgwigHyDyS7j6ViNHttzzcXZHbGty+WrD+l3DemCC8+LxwtXDkRcQrS1rSp1OJTKpl+SbeuPWQJbFRoDFm0+ijaRqqA4195gW0TdERZRJyIiIiIKLgx2EQUwy4d4R8Gcklo9jpfWOf2APzeze8B8wP/wYAH0RgmDO8VicKc2dts6xUZg3bWD8OO9o/DV30V2GU9fHS7CBV3i8PC4nnhyUqo1GBSvDsOTk1Ixf3xP64qVvtJGHY7/3TUSe09XoMvic219accJqGMinAa8mpqyWlKrx/c5JQzmNMFSRF0u/YCIiIiIiLyHqzESBbgDp8owtz7IYVu4/b7MFPROjML88b0A2K+SNiejO+ZkpOC7vwsxtntb6zQ6QRBkFxAxmiS8t/8sAOD2wZ0dXmdYSiJe2J7rcKU9QQAeyuyB+zO6I+uiXnbFs/2xGqUQrsLzPzVeFXBx/SICzlYFbK7u1CNf/IW9D44BwBXxHDEaTdDU6GTTD4iIiIiIyHsY7CIKYJIk4ZFvjqJWNOHd69Lw+MTedh/i6+oDHA0/4P9+uhJjX90JlULAx92GoGucGkU1OsTFqV1eQc3btuWWIa9Si/hIFa7o177RdkvG0+odJxzeftX2E3jsot6ortCgWmuASiGgWmfwS1CvqewswBykyrqoF6q1jdtnO2XVUcCroFoHpQA8wGCOU0ajCdDo/d4PiIiIiIjIuxjsIgpgXx4pxt6zVYgKUyBaMpmLrDv6EN/gA353tQqTeiZgwcV9sWp7bqOMMEsmkBwCJO/+fgYAcP2AjogKUzba3tKV9lQKAUajCUaj/4IbrrXVvp2SJKFGY8CcjO52WWEW92WmoFYrQtToITKY0yRzfTY+LkREREREwYo1u4gClN5owtIfjwMA7h3eFR1iIpossm67TakQsHByH6yqn/pnW+x88ZajWLHtGIRw/8fCT1Vq8N2xMgDAbemOpzAG0kp77rb13V0nMTczBQsm9m6y7hRXxCMiIiIiolDGYBdRgHp//1mcqNCiXXQY7h3e1aXbCoKAKHWY06l/L2/PRVSkylrLy1/e358PCcCYbm3RMyHK4XUCaaW95to6t4m2nq7S4smtORj76k7ckt4F+U9NQsFTk5H/1CTcn9FdNpl4RERERERE/ub/1A0iclmVTsS/6wNV8zJTEO1iFpY70+l8QRAEiJKEb3NKAAC3O8nqsrCstAfIvzi7s7bOyeiO+zJTIGoct3XxtmPQiia0jVAiXpCcT1klIiIiIiIKcQx2kc8JggCFQoDJJDX6kN7UNjr3+Lyz7wzKNCJ6J0ThpkEdXd5Pc8XOLdPpqnWOg2HeolQqIISrEBWpQmmtHnsfGoufjpViaLsooInuEEgr7Tlr6+YjxRj9yg5c1isR80bbZ379mleBzw4XQwCw9KJe1lUzWXeKiIiIiIioMQa7yGdsAxmWbBbLyn8AnG6TU6DCX2wfu/I6Ax6b0hfDeiRBMIhQKVyfjWw7nW7xlqONtvtj6p9SqYA6JgLPbMvBqu3nCubPzeyOcT0Tmw1aBdJKe47aerakBoeLanC0uAZjurfFyK7x5mmkAvDvnScBALekdcKADrF+bj0REREREZG8MdhFPuEskHFfZgoeHd8TEgQ8sy270TY5rQroL84euzkZ3ZE1oVerH5+mptPNG98TWi9P/WuYxSeEq/DMthws2XJupcEKjQFLtmRDgID7M7oDGn2z+w2kjCfbtk4/vwN+yC3D+kOFeP6XU/ioVxJio8JRUqvHVzNHYlt2CfrGR/q5xURERERERPLHYBf5hLNAxuItR3H1oE7YeDDf4TYALQ5yBCtnj93SrdlQCC0PAjXUcDpdlVZEVLgSm48UY8Nvebi0d5IHj+IcRxl+Gq0IdWQYVm0/4fA2L2/PRdZFvVCtlW+2lic8PbE3SrUi1t0yBKu252L1DvsMt4t6tz64SUREREREFCq4GiN5nSAIiIpUOQxkJEWHo0diFFZtz3V4W7msCugvTT12gPuPj9FogqjRo6ZSg3YxEXj9p2O4+r3fsPSHYzB5IahkyVJ7cUcuOi3aYv35vwNnW1QwX6EI7n4QE6HC29emYdX2XCzdmm19PCwZbiu2HYPg4mIEREREREREoYbBLvK6plb+6xgbgaIafVAGOQRBMGcxuRGoa+mqie4+PpZsqav7tUdchArHyjT4JrvErX0CjR8D2yw120DOws1H0SZShXh1mMP9WArmm0zBm9UFmB+v9nGRWF2/0mZDoR78JSIiIiIiagkGu8jrbFf+a6igWof2MeFBFeRQKhVQqcMRG6+GIUyJ2Hg1VOpwKJWuP92aeuwAzz8+MREq3H5BZwDA6l15rZ4y6OgxCFOHI8rJVMWSWj2+zynBfZkpjXcG/xTM9wdfBTeJiIiIiIiCGYNd5HVGkwl78yowJ6N7o20ltXocL61zGuSYk9EddQFUp8nZNL2XdpyAOibC5YCXZdXEuT4MAt15QRdEKAXsPVuFXacrXb59a6cqPvLFX5g/oReenJRqDe7Fq8Pw5KRUzB/f07pqZzDzdXCTiIiIiIgoGDHYRV5hO31t8bZjuHPDQczNTMETk3o3CmT0TozC/PGNgxwLJvbG3MwUrPw+x7xanwemBXqbs2l6i7cctau35MqxSHoRD4xOwYKJjR87bwSB2sdE4LoBHQGYs7tc1dqpigXVOigF4IGM7sh/ahIKnpqM/Kcm4f6M7iFTlN0S3Az1DDciIiIiIiJ3sNIxeVTDlfbaRIZhUv9O2HayAlv/yscDGSl47KLeqNSIiFOrUKcVUVejAwDrqoCWbSdKajHu1Z2QAFw9uAsGdo62rkxXpxUh6UVZBUBaUkz+sYt6oQ6A2mYlwuaO5URZHW7/9E8sntIXZ5+chCrtucfOW0Gge4Z3xdoD+dhyrBSHi2vRt110i27X1GNgO1XRstKmrfsyU1CrFSFq9BC1BqgUAqp1gZPV5ymSXsT88T0BmPuMpZ/cl5mC+eN7QlP/fCEiIiIiIiLHGOwKcYIgQKEQYDJJbgcVLNPXntmWg1XbT1g/pM/J6I5f5mbCqNFD1OhR7SyQ0WBbglLA/NEpuGRgJ6zanovJb+5y+MFfLgGv5uotdYyNgFECXthxAqucBDEcHcuru0/hUEE1XtiWjcyOMT4JAvVMiMKlqUn46mgJ1h7Ix/KLU1vUR5p7DB754i/sfXAMgKYDOZIkwWgMrSCXhdFogqZG1yj4683gJhERERERUTBhsCtENczA8kS2lO30NYsKjQFLt2ZDIQi4P6M7oNE3GchouG3awE54cUculm6136clM8iyTzmwrbfkKNjz7LTz8cz3OVhik9XU3LEU1eiw7kA+AOCBC7v5NAg0b0wP3DkqBRNTk1CtFdE2qvk+0txjYDtVkYEc54xGU6Pgb6hluBEREREREbUWa3aFoJYWUXelrlRLpvBFRapcqrfljX16U51exPbjZQ4L8SdFh2NCrySs2p7r8LbOjuW1PaehM0oY2rkNMs6L90KrHVMqFRjaIxF7T1eg65Kt6Ly4ZYX2zxXU7+5wu2WqokGjR3WFBiqDiOoKDUSNnoEuB8zBTRMDXURERERERC5gZlcIcpaBZckwejAzBYIkuZT11dz0tQqNAZUaESqF0OLMJG/s05uytmTj98Ia/DR7FBSCYDdNb+HkVFRrRZeOpUxjwH9+PwMAeGBUN58G9Sx9pDUZdZJexP2je0CSgNU7TnCqIhEREREREfkUg10hprlsqW+OFGH+hF545vscl+pKNTd9LV4dhji1CtU6x8EeR7yxT0+yrXe27sBZfPhHARQCsO94aaN6SxqtCHWka8fy1m+nUWcwYUD7GEzskeDT42ouoy7rol6o1jqeWvdnQTVmffk3nr60H/KfmsSpikRERERERORTnMYYYprLlsqa0NtaV8pyHUtGz4ptxyCEO46PSpKEg2eqHE7hA8zT1+q0okvTsSxT4u7LTHG4fW5md5f36QlKpQIqdThi49UwhCkRE6dGSsc26Ns+BvMyU5DeMdZciN9mmp5Bo0ed1uD0WOZkdEdZjQ6SJEEQBGiNJnzydzEA4P4Lz/NpVldLM+oUCsdtWvPbaRwuqsHbO3M5VZGIiIiIiIh8jpldIaapbKmk6HBMTE3CP9bvd3jbpjJ63vv9DN7Zn48f7x0FQYDdaowNp6+5QtKLmD++p/X+bVd4nJORgqLyOiRE+q4bN7Xi5PY5GTBp9JBM5sem4TS9po5lbmYK7v/kDzxzaT90iIuEtkaPA4+MxY7cMqQnRgE+DOi5k1FXUqfHxj8LAAB3D+vKqYpERERERETkcwx2hRhJknC8uBZzMrrb1WMCgI6xESiva1mNLJMJ1il820+W4bGtORBNEtbtPoUHMlLw2EW9PTJ9zWg0QVOjazQt8OfjZRj76k50jg7H/1070GeZTy1ZcVJ0UsvK2bGU1+ix8JvDeOmqgVi1PdeuztXczO4YnZLg0+l/thl1i21WjrRoKqPuvd/PQmeUMLhTLIZ1aeOL5hIRERERERHZ4TTGELPjVDmuX7cPczNT8MSk3ohXhwEwZ+vcckEy2sdEWC9ryJzto4IiXGWdwhcbr0aYOhy9kqJxVb/2uGlAh0ZT+NydvmY0mhrtU200Ire0Ft/nlmHtgXyXVo5sLU+sDunoWJQGEYsm98Gq7blYujXbbvroki3ZTU4f9RZLFtqTk1Lt+siCib0xNzMFNTXaRrfRika8s89cUP/uocmyWSWTiIiIiIiIQgszu0KApZD6yYo63PnpnyjTiFjyzWEsmtKnUQZWnc7gNKNn4eRU6I0SXtiR22gK38+zM6Cr1VoDHN6Yvma7z9SkaDw2pgc+/LMQqV3iEBuvbvHKkQ3ZFppvqv6XJ1eHtD0WQRAQGxWG1TtOOLxucwXhvcFZFtq2nBKMeWUnxp4Xj8UX9bK7zSd/FaGkzoDOsRGY2qedT9pJRERERERE1BCDXUFMqVRACFchKlKFijoDUpPb4q3r0/HB7lN4eFQ3iBoDqrXm4Ey1zhxIUSoVDutKzc1Mwa1Du2Llthy76Y8tncLnDXePOA+zx/XCiz8fx60f7m/xypEWdo9PCwJl3lod0pNBNE8yGk2ARo9qrcHaR6oqtThcVIPs4hpcP7Aj+rePAWAO3r3x22kAwJ1DuiBMyaRRIiIiIiIi8g8Gu4JUU4XU37/5AuhqzYGghhlYzjJ6NFoR6jCFrLKPVJFheHH78UbBN0tW2v0Z3QEnwTdnj0/DQJlt1pfBaMTvpysd1jsDWrfiJOC9IJqn2PaR8T0SMDU1CV8eLcGjm4/is5vToRAE/HSyHH8X1yIqTIFb0jr5pZ1EREREREREAGt2BS3bQuq2NaCWbs3Gsz80XQPKUV0pk15sUfaRQuGjQvFu1s9y9vgs3nIUK7YdgzIiDCp1uF1tsuO1IpZuzXZY7+zJSamYP74nJL3o8rHYFoR3pLVBNG9ZfFEvRIUpsPtMFT46VABBEPDtsTIkRYfjxkGdEBfpuOYbERERERERkS8wsysIWAI6giBAkqQWBYJakoVlm9FjMkFW2UfuTP1r7vH55kgR5k/ohWe+z8Eqm6mcczK6490bBuPgqXKPrjgJnCsID9hPH7XNNJOLLm0i8XBGd3z0VxF6dopDTJwaj03ugxenD0RVrR5KSfLZypFEREREREREDTHYFcBsa04V1egQF6dGnVZEbZ0O2hq9R2tA2WYfOSpe7+vsI3em/jUXKMua0BvPfJ+DJTbHacmKEwTggYwUc+abTS0rd4/b2fRRd4No3nLviPMwd3xvvPTzcdzyf7+7XC+NiIiIiIiIyFs4jTFAWWpOvbgjF50WbUHHhZvRadEWvLgjF5FREWgbFWadZteQJRBkMrkWoLFkHz05KdVjU/haq7mpf3MzuzsNvtkGyhpKig7HxNQkrNqe63C/q7afsE6PlOozmDwV4HM0fVTU6GUZNApTh+Pl+nppjqaBNjVNloiIiIiIiMibGOwKUM5qTi3Zko2Xt+eirFaPuZndHd62tVlYttlH+U9NQsFTk5H/1CTcn9HdL5k8zoJvCyb2xpyMFBzJr3R8O0nC8eJazMno3mhbx9gIlNf5tzaZp4NonuZuvTQiIiIiIiIib2L6RQBqLtiwescJLJjYG4+O7wUBgkdrQBmNJsDDU/hay9nUv10nyzH21Z3Q6EVsuW1Io4LpO09V4Iltx/Dd3RdCEGC3GuMtFySjfUyEbGqTyZE79dKIiIiIiIiIvI3BrgDUkmBDhUZEuNHotRpQtsXr/clR8K1TuAK1OhF5lVrM/eow/jN9AJQKBRQKAacq6vDPTw+hTCNi8TeHsXhKn0aF5ut0BtnUJpMjd+qlEREREREREXkbpzEGoKZqTgHngg2iGDg1oNxlO/UvPjIMb1/ZH+FKASerdCg0SIiNV8OgUqJ3clu8dX06rjy/PR4e1Q2ixtDo8THp5FObTI6aq5fGgCARERERERH5EzO7ApCrKyPKJQvLl9I6xuK1K/pj6qDOWLU9F6tfPzdVcU5Gd3xw8xDoanXWAJnt4xNoKyP6g6VeGgCPTpMlIiIiIiIicpcsMrv0ej2mTp2KXbt2WS/Ly8vD7bffjsGDB+PSSy/F9u3b7W6zc+dOTJ06FWlpabj11luRl5fn62b7lZxWRpSrKwd1wqrtuY1WDFy6NRvP/tD0ioGBtDKiP8htsQIiIiIiIiIiC78Hu3Q6HR566CFkZ2dbL5MkCbNnz0ZSUhI2bdqEK664AnPmzMHZs2cBAGfPnsXs2bMxffp0bNy4EQkJCbj33ntDatpUw2BD4UIGG2yZi/iHYfWOEw63t3TFQLmvjOhPDAgSERERERGRHPk12JWTk4PrrrsOp06dsrv8119/RV5eHhYvXoyePXti1qxZGDx4MDZt2gQA2LBhAwYMGIA77rgDvXv3xvLly3HmzBns3r3bH4fhN5ZgQ02lBu1iIlBTyWCDRUtXDFQomg52UfMYECQiIiIiIiI58WvNrt27d2PEiBF48MEHMXjwYOvlBw4cwPnnn4+oqCjrZUOGDMH+/fut24cOHWrdplar0b9/f+zfvx8jRoxwqQ3NJPYECMn6OziOx32S1LIVA2v0Bj5mOPc84GNBrcU+RO5iHyJ3sQ+RO9h/yF3sQ+Qu9qGWaenj49dg10033eTw8uLiYrRv397ussTERBQUFLRouysSE2Ndvo1cBdOxeEKtvuki/qJJQmJijB9aJl/sQ+Qu9iFyF/sQuYt9iNzB/kPuYh8id7EPeYYsV2PUaDQIDw+3uyw8PBx6vb5F211RWlqNQJ99JQjmJ0QwHIsnKZWKJlcM1NbqoKnS+LmV8sA+RO5iHyJ3sQ+Ru9iHyB3sP+Qu9iFyF/tQy1gep+bIMtgVERGBiooKu8v0ej0iIyOt2xsGtvR6Pdq0aePyfUkSgqYjBdOxeIIonivin3VRL1RqRMSpVajTiizi7wT7ELmLfYjcxT5E7mIfInew/5C72IfIXexDnuH31Rgd6dChA0pKSuwuKykpsU5ddLa9Xbt2PmsjBQauGEhEREREREQUWmQZ7EpLS8Off/4JrVZrvWzv3r1IS0uzbt+7d691m0ajwV9//WXdTtQQVwwkIiIiIiIiCg2yDHYNHz4cnTp1QlZWFrKzs7FmzRocPHgQ11xzDQDg6quvxr59+7BmzRpkZ2cjKysLycnJLq/ESEREREREREREwUWWwS6lUolXX30VxcXFmD59Oj7//HO88sor6Ny5MwAgOTkZq1atwqZNm3DNNdegoqICr7zyCgSu0UlEREREREREFNJkU6D+yJEjdv9369YNa9eudXr9sWPHYuzYsd5uFhERERERERERBRBZZnYRERERERERERG1BoNdREREREREREQUNBjsIiIiIiIiIiKioMFgFxERERERERERBQ0Gu4iIiIiIiIiIKGjIZjVGfxEEf7fAfZZjCIZjIf9gHyJ3sQ+Ru9iHyF3sQ+QO9h9yF/sQuYt9qGVa+vgIkiRJ3m0KERERERERERGRb3AaIxERERERERERBQ0Gu4iIiIiIiIiIKGgw2EVEREREREREREGDwS4iIiIiIiIiIgoaDHYREREREREREVHQYLCLiIiIiIiIiIiCBoNdREREREREREQUNBjsIiIiIiIiIiKioMFgFxERERERERERBQ0Gu3xMr9dj6tSp2LVrl/WyQ4cO4frrr0d6ejquu+467N+/3+FtDxw4gH79+uH06dPWy2pra7FgwQKMHDkSY8aMwZo1a5ptw86dOzF16lSkpaXh1ltvRV5ensPrLViwAKtWrXLtAMnrWtOHLr/8cvTp08fu5+jRowAASZLw3HPPYeTIkRg+fDhWrlwJk8nUZBua6kMGgwHPPvssMjMzMXLkSKxYsQKiKHruASC3eboPVVVV4fHHH8eoUaMwcuRIPProo6iqqmqyDU31ocrKykb3NWLECM89AOQ2T/chW4sWLcKMGTOabcOXX36JiRMnIi0tDbNnz0ZZWVmj60iShDvuuAMff/yx6wdJXuXpPvTXX3812jZ9+vQm29BUH2rN+Ip8y5N9aNeuXY0ut/ycPXvWaRua6kOt6ZPkO55+DeJnstDTmj60e/duXHHFFUhLS8N1112Hw4cPW7fxM5kXSOQzWq1Wmj17tpSamir9+uuvkiRJUklJiTRkyBBpwYIFUk5OjvTuu+9KgwcPls6cOWN3W71eL02dOlVKTU2V8vLyrJc/+OCD0uTJk6XffvtN2rNnjzR+/HjpnXfecdqGM2fOSIMHD5befvtt6ejRo9L9998vTZ06VTKZTHbXW7NmjZSamiq9/PLLHnwEyF2t6UOiKEoDBw6Udu/eLRUVFVl/DAaDJEmS9Pbbb0tjx46V9uzZI/3yyy9SZmam9NZbbzltQ3N96LnnnpNGjRol/fDDD9KhQ4ekK664QlqyZImXHxlqKW/0oQceeECaPn269Mcff0iHDh2SrrnmGmnu3LlO29BcH/rtt9+k4cOH291XSUmJlx8Zailv9CGLvXv3Sn369JFuueWWJttw4MABadCgQdInn3wi/f3339Itt9wizZw50+46RqNRWrx4sZSamipt2rTJg48Aucsbfeizzz6TrrjiCrttZWVlTtvQXB9ydXxFvuXpPqTT6ewuKyoqkm666Sbp3nvvddqG5vqQq32SfMcbr0H8TBZaWtOHTp06JQ0aNEhatWqVlJubKy1YsEAaP368pNPpJEniZzJvYLDLR7Kzs6XLL79cmjZtmt2T4q233pIuuugiSRRF63X/+c9/Ss8995zd7V999VXphhtusAt2lZaWSqmpqdIvv/xivd5XX30lZWRkOG3Hiy++aPchoq6uTkpPT7e2p7q6Wpo7d640bNgwaezYsXxhlZHW9qETJ05Iffv2lbRarcP9jh071u6D4KeffiqNHz/eaTua6kMmk0lKT0+XNm7caN2+f/9+qX///lJNTU3rDpw8xht9qLa2VurXr5+0f/9+62X79u2T+vXr57TPNfc69NFHH0nXX3+9+wdMHuet1yFJkiSdTidddtll0vXXX99ssOuRRx6R5s+fb/3/7NmzUp8+faRTp05JkiRJBQUF0i233CKNGzdOGjp0KINdMuKtPvT8889LDz30UIvb0VQfas34inzHm69DFl988YU0dOhQqbS01Ol1mnsdcrVPkm94o//wM1loaW0fevrppxud84suukj6+++/JUniZzJv4DRGH9m9ezdGjBiB9evX212el5eH/v37Q6lUWi/r06ePXcpjbm4u1q1bh0cffdTutpbpjGlpaXa3LS4utpvqaOvAgQMYOnSo9X+1Wo3+/ftb7+/06dPQ6XT4+OOP0bVr11YdK3lHa/tQTk4OOnXqhIiIiEb7LCwsRH5+PoYNG2a9bMiQIThz5gyKiooctqOpPlRWVoba2tpGfdJgMODQoUOtOm7yHG/0IYVCgddffx39+vWzu9xoNKK2ttZhO5p7HcrJyUH37t1bcYTkbd7oQxZr1qxBnz59kJGR0Ww7GvahTp06oXPnzjhw4AAA4M8//0SnTp2wadMmxMbGunKI5GXe6kPHjh1z6XWjqT7UmvEV+Y43X4cA89SfF198EXfffTcSEhKcXq+51yFX+yT5hjf6Dz+ThZbW9qHdu3dj8uTJ1m1qtRpbt25F3759+ZnMS1T+bkCouOmmmxxenpSUZDdXFwAKCgpQXl4OwDx398knn8TcuXORmJhodz3L/4WFhdY30/z8fABAeXk5kpOTG91fcXEx2rdv32g/BQUFAIC+ffvijTfecPHoyBda24eOHTuGsLAwzJo1C4cOHUJKSgrmzZuHQYMGobi4GADs+kRSUpJ1Hw37CtB0H4qLi0NYWBgKCwvRq1cvAPZ9kvzLG30oMjISY8aMsbvt+++/jz59+jj9kNDc69CxY8cgiiKuueYaFBYWYujQocjKynLYH8m3vNGHLNs//PBDfPbZZ/jwww+bbUdRUVGTfWjChAmYMGGCy8dH3ufNPmQymTBt2jRUV1djzJgxmDdvHmJiYhzeX1N9KD09HYBr4yvyHW/1IYuvv/4a1dXVuPnmm5tsR3OvQ672SfINb/QffiYLLa3tQ3l5eYiMjMR9992H3377Db169cKTTz6JXr168TOZlzCzy88mT56MgwcP4qOPPoIoivj555/x3XffwWAwAAA2btwIg8GA6667rtFtu3TpgsGDB2PZsmWoqKhAcXExVq9eDQDW2zek0WgQHh5ud1l4eDj0er2Hj4x8pbk+lJubi8rKSlx77bVYs2YNevbsidtuuw35+fnQarUAYNcnLH876xNN9SGVSoVJkybh+eefR0FBAaqrq7FixQqoVCqnfZL8z50+1NDatWvx9ddfY968eU7vr7nXoePHj6OmpgZZWVl44YUXUFRUhLvvvhtGo9GDR02e5E4fsv1SxzKwa45Wq+V7WZBxpw8ZDAbk5eXBYDDg6aefxrJly7Bv3z488sgjTu+vqT7UmvEV+Z+n3ss++ugjXHPNNYiMjGzy/prqQ63pk+Rf7vQffiYjoPk+VFdXh+eeew7Dhg3Dm2++iU6dOuH2229HbW0tP5N5CYNdfpaamoolS5Zg+fLlGDhwIF544QXceOONiI6ORnFxMV544QUsXrwYgiA4vP3KlStRVFSEkSNH4tJLL8UVV1wBAIiJicGTTz6J9PR068/Zs2cRERHR6Amj1+uhVqu9fqzkHU31IQBYsmQJtm7diokTJ6J///5YuHAhkpOT8dlnnzl8EbX8rVarW9WHFixYgOjoaIwdOxZjxozBBRdcgLi4OH6TKWPu9CFb69atw9KlS5GVlYXMzEwAaFUf+uqrr7B27VoMGTIEQ4cOxcsvv4y///7bOjWE5MedPrR+/XoYjUZcf/31Dvd955132vUhAHwvC0Lu9KGwsDD8+uuvePXVVzFw4EBkZGTgmWeewffff4/CwsJW9aGmxlckT554LystLcVvv/2Gyy+/3G7frvah5vokyY+7/Yefyai5PqRUKjFhwgTMmDED/fv3x5IlS2AymfD999/zM5mXcBqjDFx99dW48sorUVpaivbt22PlypVITk7G9u3bUV5ebv0AIEkSAGDq1Km4++67cffdd6Nbt2747LPPUFpaitjYWJw6dQoKhQKdO3fG/fffj3/+85/W+2nfvj06dOiAkpISu/svKSlpVG+HAouzPgQAKpXK7kVNEAT06NEDhYWF6NChAwBzGqzl+pY02nbt2rWqDyUmJuL9999HRUUFIiIiIEkS/v3vf6NLly7eewDIba3tQxZvv/02Vq5ciXnz5uG2226zXt6aPtRwoJeYmIj4+Hh+QJC51vahHTt24NChQ7jgggsAmL8FNxqNSE9Px1dffYVly5ZZv/G0cNaH2rVr5+WjJG9y53Wo4eC9Z8+eAMzTilrTh5oaX5F8ufte9vPPPyM5ORl9+vSx229r+lBTfdIy/iJ5caf/8DMZAU33oXbt2iElJcV63fDwcHTp0gX5+fkYPnw4AH4m8zRmdvnZr7/+igcffBBKpRLt27eHJEn4+eefMWLECEyaNAnffPMNPv30U3z66adYs2YNAHMR3xtuuAEmkwl33HEHjhw5gsTERISHh+OHH37A+eefj5iYGCQmJqJbt27WH5VKhbS0NOzdu9d6/xqNBn/99Zdd8ToKLE31IQCYMWOGNZUaAEwmE44cOYIePXqgQ4cO6Ny5s12f2Lt3Lzp37oz27du3qg898sgj2L59O+Lj46FWq/Hjjz8iMTHROl+c5MedPgQAn3zyCVauXImsrCy7N2IALvehmpoaDBs2DL/++qt1e2FhIcrLy633R/LjTh967rnn8NVXX1nf62644QYMGDAAn376qXUwZ9uHADTqQ/n5+cjPz+d7WQBzpw/l5OQgPT0deXl51u1///03VCoVunXr5nIfam58RfLk7nsZABw8eNAaeLflah9qrk+S/LjTf/iZjIDm+9DgwYNx5MgR6/X1ej3y8vKQnJzMz2RewswuP0tJScG2bdvwf//3fxg9ejTefvttVFZW4sorr0R0dLTdoMqyskPnzp0RHx8PAIiMjMS///1vPPbYY8jJycErr7yClStXOr2/q6++Gm+//TbWrFmD8ePH45VXXkFycrL1SUiBp6k+BJgLNb/yyivo168fUlJS8P7776O6uhpXXXUVAODGG2/Ec889h44dOwIA/v3vf+OOO+5wen/N9aH4+Hi88MILaN++PcrLy7FkyRLMnDkTCgVj63LlTh+qqKjA4sWLcdVVV+Gyyy6zfgsFAAkJCXYr0lg01YcEQcCQIUOwfPlyLFmyBEqlEsuWLcPo0aMbfdNO8uFOH2oYPIiLi0NkZGSTHwhvvPFGzJgxA4MHD8bAgQOxbNkyjBs3jitWBTB3+lBUVBS6deuGJ554Ao899hiqqqrw1FNP4dprr0VcXJzD+2uuD7k6viL/c3c8BADZ2dkYPXp0i+6vqT5kMplc7pPkX+70H4VCwc9k1Gwfuu2223DzzTdjyJAhGDVqFN566y1ERERg3LhxAPiZzCsk8rnU1FTp119/tf6/bds2acqUKVJaWpp06623Sjk5OQ5vl5eXJ6Wmpkp5eXnWy4qKiqRZs2ZJgwcPli666CJp48aNzd7/Dz/8IE2ePFkaNGiQdNttt0mnTp1yeL1bbrlFevnll108OvIFV/qQyWSSXnvtNWncuHHSgAEDpJtvvlk6cuSIdbsoitLTTz8tDR06VBoxYoT07LPPSiaTqcn7b6oP1dTUSI888og0ZMgQafTo0dIbb7zhwSMnT/FUH/ryyy+l1NRUhz+2r1UNNdWHKioqpEcffVQaMWKElJ6eLj388MNSRUWFFx4FcocnX4dsvfzyy9Itt9zS7P1v2rRJGjt2rDR48GBp9uzZUllZmcPrjR8/Xtq0aZOLR0e+4Mk+dPbsWWn27NnS0KFDpeHDh0tLliyRdDpdk/ffVB9qzfiKfM/Tr0NTpkyRPvzwwxbff1N9qDV9knzLk/2Hn8lCk6uf67ds2SJdfPHF0oABA6QbbrhBOnr0qHUbP5N5niBJ9YWgiIiIiIiIiIiIAlwI5bAREREREREREVGwY7CLiIiIiIiIiIiCBoNdREREREREREQUNBjsIiIiIiIiIiKioMFgFxERERERERERBQ0Gu4iIiIiIiIiIKGgw2EVEREREREREREGDwS4iIiIiIiIiIgoaDHYREREREREREVHQYLCLiIiIiIiIiIiCBoNdRCRrkiT5uwl+FerHT0RERI0F6vggUNvtKaF+/ES+xGAXEXnFv/71L/Tp0wfvvPNOq25fUFCAmTNn4syZMx5umX/MmDEDM2bMcOk2e/fuxcyZM63/nz59Gn369MHHH3/s6eYRERGRm2bMmIE+ffrY/QwYMADjxo3DokWLUFlZ6ZH7+e677zB//nzr/7t27UKfPn2wa9euFu/j448/Rp8+fXD69Olmr+vumA7guA7guI7I11T+bgARBZ/q6mps3boVqampWL9+Pf7xj39AEASX9rFz5078+OOPXmphYNiwYQOOHTtm/b99+/ZYv349zjvvPD+2ioiIiJw5//zz8dRTT1n/NxgM+PPPP/H888/j77//xocffujymKih//znP3b/9+/fH+vXr0evXr3c2q8jnhjTARzXARzXEfkaM7uIyOO+/PJLAMDjjz+OEydO4Ndff/Vzi4JDeHg4Bg8ejISEBH83hYiIiByIiYnB4MGDrT/Dhg3D7bffjlmzZuH333/HgQMHvHafMTExHt83x3Tew3EdkXcx2EVEHrdp0yZceOGFGDlyJLp164b//ve/dtsnTJiARx991O4y23T6jz/+GFlZWQCAiy66yHpdo9GIdevWYdq0aRg0aBDGjRuH5557Djqdzm5fP/74I2644QYMHjwYmZmZePLJJ1FVVWXdfuLECdx3333IyMjA4MGDMWPGDOzdu9e63ZJW/u6772LKlClIS0vDpk2bsGrVKkyaNAmrV6/G8OHDkZmZaZ2SsGHDBlx22WXW6QqrVq2C0Wh0+hiVlZVh0aJFGD9+PAYMGIDhw4dj9uzZ1ukEjz76KD755BOcOXPGmuLuKN29pcfy9ddf47777kN6ejqGDx+OBQsWoK6urvmTSURERG4bMGAAAODs2bMAzGOaNWvWYOrUqRg0aBAGDx6MG264wS6Y5Gjccfnll2P37t3YvXu3deqio2mMW7duxU033YT09HQMGDAAU6ZMwbp161xud3NjOoDjOoDjOiI5YrCLiDwqOzsbf/zxB6688koAwJVXXonvvvsOJSUlLd7HuHHjcM899wAAVq9ejXvvvRcA8OSTT2L58uWYOHEiXnvtNdx8881Yu3Yt7r33XmvBz23btmHWrFlITEzEiy++iIcffhhbt27Fgw8+CADIycnB9OnTcfr0aSxYsADPPfccBEHAbbfdht27d9u1Y9WqVbjrrruwcuVKZGRkADAPUn/88Ue88MILyMrKQlxcHN544w088cQTuPDCC/H666/j5ptvxptvvoknnnjC4fFJkoRZs2Zhx44dePjhh/H2229jzpw5+OWXX6xTH+69916MHTsW7dq1w/r16zFu3LhG+3HlWJ566il06dIFr776Kv75z39i48aNeO2111p8ToiIiKj1cnNzAQBdu3YFADz33HN49dVXcf311+Ott97CkiVLUFFRgfvvvx8ajcZ6u4bjjueffx7nn38+zj//fKxfvx79+/dvdF8//PADZs+ejf79++PVV1/FqlWr0LVrVyxevNilzDJPjOkAjusAjuuI/IE1u4jIozZt2oT4+HhMmDABAHDVVVdh1apV2LhxI+6+++4W7SMhIcFav6Bfv35ITk5GTk4ONm7ciH/961/W4p4ZGRlo37495s2bh59++gljx47FqlWr0K9fP6xevdpaUyI8PBwvvfQSSkpKsHr1aoSHh+P999+3pvuPGzcOU6dOxcqVK7Fx40ZrOy655BJcffXVdm0TRRHz58/H0KFDAZhrWVgGqwsWLAAAZGZmIj4+HgsWLMA//vEP9O7d224fRUVFUKvVdvsZMWIETp06hfXr1wMAzjvvPCQkJFhT3AE0+sbOlWMZO3astZjthRdeiB07duCHH37Av/71rxadEyIiImqeJEkQRdH6f2VlJXbv3o3XXnvNmmUFmMcCDz74oF2R84iICMydOxdHjhyxvvc3HHcAsL7nW67TUE5ODq666io8/vjj1svS09MxYsQI7Nq1C2lpaS06Fk+M6QCO6wCO64j8gcEuIvIYg8GAzz//HBMnToRWq4VWq0V0dDSGDBmCjz76CDNnzoRC0bqEUss3Wpdddpnd5ZdddhmysrKwa9cujBgxAn/99Rfmzp1rVzz10ksvxaWXXmrdz/jx4+3qWqhUKlx22WV45ZVXUFtba728X79+Dttie/nvv/8OrVaLCRMm2A1uLQPDHTt2NBoUdejQAe+//z4kScLp06dx8uRJHD9+HPv27YNer3fpMWnpsTQcEHfs2DFoVkQiIiKSiz179jTKtlIoFBg1ahQWL15sHZ/8+9//BmCe/nb8+HGcPHkS27ZtA4BGYwFn4xFn7rzzTgBAbW0tcnNzcerUKfzxxx8O9+2MN8d0AMd1zh4TjuuIPIfBLiLymB9++AGlpaXYuHGj3bdPFj///DPGjh3bqn1baii0a9fO7nKVSoW2bduiuroalZWVkCQJiYmJTe4nKSmp0eVJSUmQJAk1NTXWy6KiohzuIzo62vp3RUUFANgtJW2rqKjI4eWff/45nn/+eeTn5yM+Ph79+vVDZGSk03Y74sqxqNVqu+soFArrFAEiIiLyjP79+2PRokUAAEEQEBERgU6dOjUqHv/HH39g0aJF+OOPP6BWq9GrVy907twZABq9P9uOO1qirKwMTz31FLZu3QpBENCtWzdrxlFL3/u9OaYDOK5zhOM6Is9isIuIPGbTpk3o2rUrli1bZne5JEmYM2cO/vvf/1oHRg2LfDZXVDMuLg4AUFxcjC5dulgvNxgMKC8vR9u2bRETEwNBEFBWVmZ3W51Oh19//RVpaWmIi4tzWGuiuLgYANC2bVunAxlH2rRpA8Bce6N79+6NtjsatPz222+YP38+ZsyYgX/+85/o0KEDAGDlypV2RUib4+ljISIiIvdER0dj4MCBTV6npqYGd955J/r06YOvvvoKPXr0gEKhwI8//ohvv/3W7TY8/PDDOH78OP7zn/8gPT0d4eHh0Gg0+Oijj1q8D1fGdADHdRzXEckPC9QTkUcUFxfj559/xmWXXYYRI0bY/YwcORJTpkzBjz/+iMLCQsTExKCgoMDu9g0HAw1T44cPHw4A+Oqrr+wu/+qrr2A0GjFkyBBER0ejX79+1mkAFj/99BNmzpyJoqIiDBs2DNu2bbP7dsxoNOKrr77CwIEDER4e7tJxp6WlISwsDIWFhRg4cKD1R6VS4fnnn7euwmPr999/h8lkwty5c60DIqPRiJ07dwIATCaTw8egIU8fCxEREXnf8ePHUVFRgVtvvRW9evWyvt//9NNPAM6NA5xpbnywd+9eTJ48GSNGjLCOBVq6b8C1MR0Ajus4riOSJWZ2EZFHfPrppxBFsVHtBYsrr7wSGzZswEcffYTx48fjjTfewBtvvIG0tDR8//33dkttA+e+WduyZQvGjBmDXr164aqrrsLLL78MjUaDYcOG4e+//8bq1asxYsQIjB49GgBw33334Z577sFDDz2EK6+8EiUlJXj++ecxceJEpKamYs6cOfjpp59w6623YubMmQgLC8PatWuRl5eHt956y+Xjbtu2Le6880689NJLqKmpwYgRI1BYWIiXXnoJgiCgb9++jW4zaNAgAMDixYtx9dVXo7KyEuvWrcPhw4cBmL8NjYmJQZs2bVBSUoIff/zRYZ0JTx8LEREReV9KSgpiYmLw+uuvQ6VSQaVS4dtvv7VOF7RdjdGRNm3a4Pfff8cvv/yC888/v9H2QYMG4YsvvkD//v3RsWNH7Nu3D2vWrIEgCM3uG3BtTDd37lyO6ziuI5IlZnYRkUd8/PHH6N27N1JTUx1uHzJkCJKTk7FhwwbMmjUL1157Ld5++23cc889KC4ubpQmP2LECIwaNQr//ve/sWLFCgDAsmXLMHv2bHzxxReYOXMm1q1bh1tvvRVvvvmm9duy8ePH4/XXX8epU6cwe/ZsvPTSS5g2bRqeffZZAEDv3r3xf//3f0hMTERWVhYeeeQRSJKE999/H6NGjWrVsT/wwAN49NFHsWXLFtx111149tlnMWTIEKxduxaxsbGNrj9ixAg8+eST+P3333HXXXfhmWeeQefOnbF69WoA574NnT59Orp06YLZs2fj008/bbQfbxwLEREReVdsbCxeffVVSJKE+++/H/PmzcPZs2exdu1aREdH47fffmvy9jfffDPCwsJw1113WTO2bD3zzDNIS0vDkiVLMHv2bHz33XdYtGgRMjMzm9034NqYzmg0clzHcR2RLAkSK9kREREREREREVGQYGYXEREREREREREFDQa7iIiIiIiIiIgoaPgl2KXX6zF16lTs2rXL6XX++usvXHvttUhLS8PVV1+NQ4cO2W3/8ssvMXHiRKSlpWH27NmNlqQlIiIiCmUcbxEREVGo8nmwS6fT4aGHHkJ2drbT69TV1WHmzJkYOnQoPv74Y6Snp2PWrFmoq6sDABw8eBCPP/445syZg/Xr16OqqgpZWVm+OgQiIiIiWeN4i4iIiEKZT4NdOTk5uO6663Dq1Kkmr/e///0PERERmDdvHnr27InHH38c0dHR+OabbwAAa9euxSWXXIIrr7wSffv2xcqVK/Hjjz8iLy/PF4dBREREJFscbxEREVGo82mwa/fu3RgxYgTWr1/f5PUOHDiAIUOGQBAEAIAgCLjggguwf/9+6/ahQ4dar9+pUyd07twZBw4c8FrbiYiIiAIBx1tEREQU6lS+vLObbrqpRdcrLi5Gr1697C5LTEy0puIXFRWhffv2jbYXFBR4pqFEREREAYrjLSIiIgp1slyNUaPRIDw83O6y8PBw6PV6AIBWq21yOxERERE1jeMtIiIiClY+zexqqYiIiEYDKb1ej8jIyCa3q9Vql++rrKwaktT6ttpas+Mk/rvvDIwO9qcUgBsu6IKZGd08c2fUYoIAJCTEevRcU+vwXMgLz4d88FzIhzvnwnLbQMHxFnkSX8fkg+dCXng+5IPnQj58Md6SZbCrQ4cOKCkpsbuspKTEmkrvbHu7du1cvi+TCR7r6JP7tsebv5yEycH+FAJwcd/2MJk8c1/UcvWlSDx6rql1eC7khedDPngu5MOdc2G5baDgeIs8ia9j8sFzIS88H/LBcyEfvhhvyXIaY1paGn7//XdI9UctSRL27duHtLQ06/a9e/dar5+fn4/8/Hzrdn85r60aCyanQmHz4CsE88+Cyano2tb1b0KJiIiIvIHjLSIiIgpWsgl2FRcXQ6vVAgCmTJmCqqoqLFu2DDk5OVi2bBk0Gg0uueQSAMCNN96Izz77DBs2bMDhw4cxb948jBs3Dl27dvXnIQAApg3oiLUzLrD+f+MFXbDxH8MwbUDHVu/zVLkGq3/OxeNf/o3VP+fiVLnGE00lIiKiEMPxlnMcbxEREQUP2QS7MjMz8b///Q8AEBMTgzfeeAN79+7F9OnTceDAAaxZswZRUVEAgPT0dCxevBivvPIKbrzxRsTFxWH58uX+bL6d5Phz3yjendHdrW8YPz9UgGvf3YO1e/Kw9Wgx1u7Jw7Xv7sEXh7gSEhEREbmG4y3HON4iIiIKLoIkhfZs1ZISzxen0xiMGPPyDgDAz/dlIDJM2ar9nCrX4Np39zitSbHxH8OYqt8CggAkJcV65VyTa3gu5IXnQz54LuTDnXNhuS01xvFW8OPrmHzwXMgLz4d88FzIhy/GW7LJ7KLGPj9UAGe11wQAn/HbRiIiIiK3cLxFREQUfBjskrH8Si2cBTml+u1ERERE1HocbxEREQUfBrtkrFNcZJPfNHaKi/Rlc4iIiIiCDsdbREREwYfBLhm7fEDHJr9pvMKNFYeIiIiIiOMtIiKiYMRgl4yd11aNBZNTobD5ulEhmH8WTE5lsVQiIiIiN3G8RUREFHxU/m4ANW3agI7o2yEGN72/DwBw4wVdcHVaZw68iIiIiDyE4y0iIqLgwmBXAEiOPzfQmpXRHepWLq1NRERERI5xvEVERBQ8OI2RiIiIiIiIiIiCBoNdREREREREREQUNDiNMQSdKtfg80MFyK/UolNcJC4f0BHnsSYFEREREREREQUBBrtCzOeHCrBs81EIMC+nLQD4YE8eFkxOxTQurU1EREREREREAY7TGEPIqXINlm0+CpMEGCXY/V66+SjyyjX+biIRERERERERkVsY7Aohnx8qgOBkmwDgs0MFvmwOEREREREREZHHMdgVQvIrtZCcbJPqtxMRERERERERBTIGu0JIp7jIJjO7OsVF+rI5REREREREREQex2BXCLl8QMcmM7uuYIF6IiIiIiIiIgpwDHaFkPPaqrFgcioUNuldCsH8s2ByKrq2VfuvcUREREREREREHqDydwPIt6YN6Ii+HWJw0/v7AAA3XtAFV6d1ZqCLiIiIiIiIiIICg10hKDn+XGBrVkZ3qMOUfmwNEREREREREZHnMNhFRATgVLkGnx8qQH6lFp3iInH5gI44jxmPREREREREAYfBLnILAwQUDD4/VIBlm49CgHmxBgHAB3vysGByKqZx4QYiIiIiIqKAwmAXtRoDBBQMTpVrsGzzUZgcLFW6dPNRDO4Sx5p2REREREREAYSrMVKr2AYIjBLsfi/dfBR55Rp/N5GoRT4/VADByTYBwGeHCnzZHCIiIiIiInITM7uoVVoSIJgzOsWXTaIQ46kptPmVWjhI6gJgzljMr9S61U4iIiIiIiLyLQa7qFUYICB/8uQU2k5xkU0GbjvFRbrXWCIiIiIiIvIpTmOkVmGAgPzF01NoLx/QscnA7RWsP0dERERERBRQGOyiVmGAgPzF0zW2zmurxoLJqVDY7FQhmH8WTE5lcXoiIiIiIqIAw2mM1CqWAMFSm1XsLMECBgjIm7wxhXbagI7o2yEGN72/DwBw4wVdcHVaZ7f6sadqihEREREREZFrGOyiVvNGgICoOd6aQpscf67fzsroDnWYslX7ATxbU4yIXCcIACDU/z73vyRJ9T/+axsREREReR+DXeQWTwYIAGbDUPMuH9ARH+zJc7hNDlNobWuKNbR081EM7hLHgDCRC5wGriDBaAKMkgSTSYJJkmCUAKNJMv9I5t+i0QSDUYJokhAdrkSXuEhIjHYRERERBTUGu0g2mA1DLSH3KbQtqSk2Z3SKL5tEJBstClzVB6ks/xtN5y6zDVwZTSaYJECSJOtvSQJM9b8lSWo05VkdxsVTiIiIiEIBg10kC8yGIVfIeQqtN2qKEcld4yCWecqgKMEclDIBBpMEo2SCWB+sEo0m6I2WwFZTgav64JU/D5CIiIiIAorPg106nQ6LFi3C5s2bERkZiTvuuAN33HFHo+vNmDEDu3fvbnT59OnTsXz5clRWVmL48OF22+Lj47Fr1y6vtZ28h9kwwe9UuQZfHCpAqc6IxAglprk5RdXTU2g9xVs1xYj8oTVBLIPRBL1ozsAy1WdqSSZzEMv6PyNXXsfxFhEREYUynwe7Vq5ciUOHDuG9997D2bNnMX/+fHTu3BlTpkyxu96qVatgMBis/x84cAAPPPAAbrrpJgBATk4O4uPj8eWXX1qvo1AofHMQ5HHMhglujqaovh+kU1TlXlOMyFkAy2QNYtXXuzKaf4v1NbCaDWKZGk8bJP/heIuIiIhCmU+DXXV1ddiwYQPefPNN9O/fH/3790d2djbWrVvXaPAVHx9v/dtoNOKFF17AnXfeiYEDBwIAjh8/jpSUFLRr186Xh0BewmyY4BVqU1TlXlOMgk/D4JX5MnMdLNEEmCSTuf5VfdBKNEkQJfM0QtFoDmIZjJI14GWymT5oMjmufUXyxvEWERERhTqfBrsOHz4MURSRnp5uvWzIkCF4/fXXYTKZnH5T+PHHH6OyshJ33XWX9bKcnBx0797d200mH/FWNoynp86R60Jxiqqca4qR/DUVvDIXbTcHr8xF2wHRZKrPxkJ9AXfLlELbOljnAleWYBYFL463iIiIKNT5NNhVXFyMtm3bIjw83HpZUlISdDodKioqkJCQ0Og2kiThrbfewq233oro6Gjr5ceOHYMoirjmmmtQWFiIoUOHIisrC+3bt3epTYKzT+FusN2lILh/H0KDv+W0P0/tq1uCGk9cnIol3zbOhnni4lScl+B6kODzPwqw1MHUuScuDr6pc3KWX9XMFNUqbav6jZyfFwDQ1aam2N0Z3aEOl0dNMVv2K+KRt5x7fBtPHbQEqUwmCRV1elQbjNYMLKMJ5sCVqb6Qu7FxEXdL/SvWwWq55t6X3XleyOW5xPGWB/YH+ZzPQMH3FPnguZAXng/54LmQD1+Mt3wa7NJoNHYDLwDW//V6vcPb7Nq1CwUFBbjuuuvsLj9+/DgSEhKQlZUFSZLwwgsv4O6778aGDRugVLb8Q2ViYqyLR9G8Or1o/TshMQZR4e49zLb7S0yS1/48ua9/jIvFyD7tcclL2wEAd2Sm4JYR3dA9KbqZWzaWW1JrN43M1pJvj2L8gM6t2i+5rmfHNvjuaAkcfRIXBAE9O7ZBUpLrz0M5Py+8sT9v8sbrYKgyGE3WqYJGkwlGoznzyrbulbmIu9E6dVCSzE8PU11N/d+2qw8KgKAEVIBSBcgvZBpYYmMjkJAQ06LrBvLzguMt9/cn99dtOQvk506w4bmQF54P+eC5kA9vngufvotHREQ0GmRZ/o+MdFyT6dtvv8WYMWPsakoAwFdffQVBEKy3e/nll5GZmYkDBw7gggsuaHGbSkurPf5tuEZvtP5dVlqDOjdXibPdX2lJDerczBDx5P483bYYm5NxW3pnqGFCSUm1y/t576fcJqfO/eenY5gzJrimzsnVpJ4JeOPHYw63SZKEyT0TWnWO5fy88Mb+vEEQzG8w3ngdDETOpg8aTfU1r2yKtRslyW71QUvdK5OpcbZVS1YgFASgTZsoVFXV8Vx4kRomlKnMmXTOuPO8sNzW3zjecn9/cn3dljO+p8gHz4W88HzIB8+FfPhivOXTYFeHDh1QXl4OURShUpnvuri4GJGRkWjTpo3D2/z888+YM2dOo8vVavtpbYmJiYiPj0dhYaFLbbJ8o+5JtrvzxP6lBn/LaX9ybdvZZlZ3PFup5QtcC5wq1+DzQwXIr9SiU1wkLm9FzbOu8U0XbE+OV7fqXMi173lrf544F85443VQTmyDWJa/jfWrBxpNgFhfA8tS+8oSwLKsPOiLwu2Wxz+Yz4NctLS/B/LzguMtD+wPgXv+/S2QnzvBhudCXng+5IPnQj68eS58Guzq168fVCoV9u/fj6FDhwIA9u7di4EDBzosllpWVoa8vDwMGTLE7vKamhqMHz8eq1atwsiRIwEAhYWFKC8vR48ePbx/ICR73lrd0ZsBB7n5/FABljWoefbBnjwsmOx6zTMWbHePJ89FMGmYiWVdgdB4Lohlyb6yC2DVB7VMpsaZVyYTVx6kwMfxFhEREYU6nwa71Go1rrzySixcuBBPP/00ioqK8M4772D58uUAzN86xsbGWlPls7OzERERgeTkZLv9xMTEYMiQIVi+fDmWLFkCpVKJZcuWYfTo0ejTp48vD4lkyhurO4ZSwOFUuQbLnNQ8W7r5KAZ3iXM5UJXcoGB7pJvTTUKFN85FIHCYjWUyQZRgzb4STeeCWXrxXCDLLohlOpeVRRQqON4iIiKiUOd47WkvysrKQv/+/XHbbbdh0aJFmDt3LiZPngwAyMzMxP/+9z/rdUtLS9GmTRsIDsrtr1ixAueffz5mzpyJGTNmoEuXLnjuued8dhwkb+e1NU+dU9h0HYVg/lkwOdXl4IBtwMEowe730s1HkVeu8fAR+NfnhwqazIz77FCBL5sT0oL1XJiDWAIUCgFKpQKCQoARgM4kocZgQrlWRFGdHqcrtThWUoe/C6txuLAGRwurkV1UjWNFNcgtrsXJklqcLqtDUZUWFXV61GpFaPRGaA1G6EVzMXgGuigUcbxFREREoczny8yo1WqsWLECK1asaLTtyJEjdv9feumluPTSSx3uJy4uzvoNJZEjnpw615KAw5zRrhe89/S0SE/tL7+Zmmf5ldpWt5FcE6jnwhLMMv8tnCvubpRgsFmVUC8aoRNN0BtN57KwTOasLCOjVEStxvEWERERhTKuqUxBzVNT57wRcPD0tEhP7s9bNc/IdXI+F4JwbpqhSQIM9dMKDfUBLdFoMgeybKYXmupXMrQEtIiIiIiIiDyNwS6iFvB0wMHTdZg8vT9v1Dyj1vH3ubBkaAmC+f4MRnMBeL3RZP3R6I3WzCyjNTuL0weJiIiIiMg/fF6ziygQXT6gY5OZXa4GHDxdh8nT+/N0zTNqPV+cC0EAFArB+mPCudpZpXUGnK3SmetmFdTgSH3NrOPFNThZWouz5RqU156rlaUXzdldDHQREREREZG/MLOLqAUsAYelNtlTluBDawIOnp4W6Y1plp6seUbu8dS5sM3SMkqA3iihrFaPMo0IvWiCxmCE1mCqr5dlMmdpMUOLiIiIiIgCDINdRC3kyeCPp6dFequuk23Ns1kZ3aFuZc0zcp+r58IS1AIAg8k87dBSP6tWb4RONMJolBAdY0B5RR3rZxERERERUdBgsIvIBZ4K/ni6DpO/6zqR/9hla5kk6E0SdIb6WloGI+r0RohGc5aW5cdWRH2NLSIiIiIiomDBYBeRH3h6WqSn90fyphAEiAAM9dlaWoMJdXrzVETRVD8F0Sg5ndoKAIXVOuzMLUOVwYQ2YQqMSklAh9gIXx0CERERERGR1zDYReQnnq6JxRpbweVcxpYAvdGEOtFk3Xa4qAZhSgFGk1RfDN61zKyduWX4YM9p6wqLAoDNh4sxY1gyRqUkePZAiIiIiIiIfIzBLiI/8nRNLNbYClyWqYgmwJytJZqgNRhRoxWhE42o1YvW69bqRESoWreYbmG1Dh/sOQ0JgCVGZgmVfbDnNHolRaM9M7yIiIiIiCiAMdhFRORjtllbBqM5sKUxGFFnMKJOJ8JglKx1tiwMomfqau3MLTNndDnYnSAAO3LLcNWgTh65LyJvs0zHLa3VIzE6nNNxiYiIiAgAg11ERF4nQIBCIUACoDOaoNWbg1s1WhF6owkGowmi0eQwAOVppbV6p/cj1W8nCgR203Elc7CW03GJiIiICGCwi4jI4wRBgNKyQgCAMo0exRqgTidCNEowNMja8qXE6HDnmV3124nkzuF03PrfnI5LRERERK0r+kJERFaCACgUAiAAGqMJpXV6nCirs24/WVaHokotarQitAaj3wJdADAqJcF5ZpcEZDAjhgKAZTquI5bpuEREREQUupjZRUTkIkvNLQmAVjShTm8uIF+jE2EQzVMSNYZzqyf6YnpiS3WIjcCMYcnWrBgAUNRnes0YlsxsGPI6T9TZ4nRcIiIiImoKg11ERM2wBLcAQCdKqBNF1OqMqNaKMBhNMIgmmOQU0WrGqJQEnNdWjaWbswEAE3onYUzPRAa6yOs8VWeL03GJiIiIqCkMdhEROaCor7llKShfqzeiSmuAQTT5teaWp7SLORfYmjagIyJU7s1q56p41BxP1tkalZKAzYeLHW7jdFwiIiIiYrCLiAjmFRMtagwmVBt0qNaI0InG+tUSAzu45U1cFY9awlJny2E2Vn2drasGdWrRvjgdl4iIiIiawmAXEYUkQRCgUAAGowSNaEKZ5lyNnxMlNVA4q35NdrgqHrWUp+tscTouERERETnDYBcRhQRrcMsEaEUj6vTmmltagxEG0YRanWi9rsEoIULFYFdLeDJbh4KbN+pseXo6LhEREREFBwa7iCgoWYrKmyRAUx/cqtGJqNMbIRrNdbdsP3RzkmLrcFU8ainW2SIiIiIiX2Gwi4iCwrnglgStaEKd3ohavXnVRIOD4BZ5BlfFo5ZinS0iIiIi8hUGu4goINlOMtQZJWg1Imr1Imp0IkTRBINRgonRLa9jtg65gnW2iIiIiMgXGOwiooBgqbkl1tfcKteeq7F1rKQGCggMbvmBN7J1Cqt12JlbhtJaPRKjwzEqJQEdGAzxG0+fD9bZIiIiIiJvY7CLiGRJoRAgCAIMRpN5WqLBiBpLQXmjfUF5ncHED8x+5MlsnZ25Zfhgz2nr1EhBADYfLsaMYckYxSwxn+P5ICIiIqJAxGAXEfmdpd4WAOiMJmgNJmhEc3BLJ5rrbYkNam6ZmMQlK57I1ims1lkzxCzn2vL7gz2n0SspmtPdfIjng4iIiIgCFYNdRORzgmDO3JJgDm5p9CZo9CKqdUYYRGN9cIvRrFCzM7fMebF7AdiRW4arBnXyfcNCFM8HEREREQUqBruIyOsEQYBSca6kfJlWhEkjokYrQqxfKdHIVK2QV1qrd7piplS/nXyH54OIiIiIAhWDXUTkUQ2nJOpECRrRiNJqnfU6J0tqEaZkjS2ylxgd7jyTqH47+Q7PBxEREREFKga7iMgtllUSjfWrJGpFEzR6I6p15qwt0ShBrC8yb8EkLnJkVEoCNh8udrhNkoCMVhZED7XVHT11vN46H0RERERE3sZgFxG1mLOsrdr6VRJFowmiSeKURGqVDrERmDEs2VoUHQAU9ZlFM4Ylc3XHFvDk8XrjfBARERER+QKDXUTklIBzdba0RhN0Wslh1hZDW+Qpo1IScF5bNZZuzgYATOidhDE9E1sVWAm11QS9cbyePB9ERERERL7CYBcRAXCctVWuOVeA+nhxDZQKBbO2yOvaxZwLpEwb0BERqtbVd/PWaoJynRbpreP11PkgIiIiIvIVBruIQpRCIUAQBBhMEnSiEVqDCRqDETU6EQajCaLRhDqd0Xp9nSghQsVAFwUOb6wm6I1pkZbgWZXBhDZhilYHz7h6IhERERGRmU+/ntXpdHjssccwdOhQZGZm4p133nF63XvuuQd9+vSx+9m2bZt1+3/+8x+MHj0a6enpeOyxx6DRaHxxCEQByVxEXoCgEKA3SajSG1FQrUN2cQ2OFFYjp6gGJ0pqkV+hQbXGAK3eCNEocXoiBTTLaoKOtGY1QdtpgiYJdr8/2HMaRTYrjrbUztwyLPz6CLYcKcavx0ux5UgxFn59BDtzy1zel6ePlwIXx1tEREQU6nya2bVy5UocOnQI7733Hs6ePYv58+ejc+fOmDJlSqPrHjt2DM8++ywuvPBC62VxcXEAgG+//RarV6/Gs88+i8TERGRlZeHZZ5/Fk08+6bNjIZI7pUIBIwCdaM7YqjMYUacTrXW2RE5HpCDn6dUEPT1N0GGNrfptramxxdUTyYLjLSIiIgp1Psvsqqurw4YNG/D444+jf//+mDRpEu68806sW7eu0XX1ej1Onz6NgQMHol27dtaf8HDzt9Lvv/8+brvtNowfPx6DBg3CokWLsGnTJn7bSCFJEHAua8vmU7g1a6u4BidLa1FUqUWNZdVEBrooBFhWE7RNdlII5iyn1qwm6OlpgpbgmSOW4JkrPH28FJg43iIiIiLyYbDr8OHDEEUR6enp1suGDBmCAwcOwGQy2V33+PHjEAQBXbt2bbQfo9GIP/74A0OHDrVeNnjwYBgMBhw+fNh7B0AkE4IgQKkUIAkCNEYTSjUiTlVocLiwBseKaqzXq9QYoNEbYRBNTj+gEwW7USkJeHxyb+v/E3onYdElfVpVX8vT0wS9UWPLk8dLgYnjLSIiIiIfTmMsLi5G27Ztrd8WAkBSUhJ0Oh0qKiqQkHBuIH78+HHExMRg3rx52L17Nzp27Ii5c+di7NixqKqqgk6nQ/v27c8dhEqF+Ph4FBQUuNwuZx9c3GG7S/MKdx7cH+S1Pzm3rdH+AvBc2K6QqDdK0NZPSazVieZAltEE0SjBVP+JWSfaf5CRK28876j1gv18eGo1QU9PE7QEzxxOi0Tra2xx9cSmNfdeYNnWmueFHJ5LHG95aH+Qx/kMJO48d8izeC7khedDPngu5MMX4y2fBbs0Go3dwAuA9X+93v7b6+PHj0Or1SIzMxMzZ87Eli1bcM8992D9+vVISkqyu63tvhrupyUSE2Ndvk1z6vSi9e+ExBhEhbv3MNvuLzFJXvuTc9sa7i+QzoXRJEGjN6JOL6KuPrilM5hgNEkwmiRICiVUkcpGT2Ct4dzqiW3aqBEZpnSrfZ7cn+2+YmPl1bZQ35/czodcH7u4uCjMGtsDb/x03BqgUgjmLKxZY3qgd3Jbl/Z38aDO2HzESfAMwJRBXRAXF+lyO+X6+Hljf67uKzY2AgkJMS3atzfGB77A8ZZn9ueJ9/hQFajPnWDEcyEvPB/ywXMhH948Fz57F4+IiGg0OLL8HxlpP5i/9957MWPGDGuB1L59++LPP//ERx99hAcffNDutrb7UqvVLrertLTa41O8NPpzg++y0hrUufnBwHZ/pSU1qAuXz/7k3LaG+5PjudAazmVinSmqAiCgTm9EjU6EQTTBYDQHuFrKNrOrqkoDnZsZHZ7cn+2+qqs10Cnl07ZQ35/czoecH7vBHWLw+KTeWLo5G4B5muCYnoloHxuByso6l/YVBWDG0GRrkXqgPngmmS9Xw+TyPgF5P36e3p+r+1LDhDIVYGridVUQzAOv1owPLLf1J463PLM/T7zHhxp3njvkWTwX8sLzIR88F/Lhi/GWz4JdHTp0QHl5OURRhEplvtvi4mJERkaiTZs2dtdVKBTWgZdFjx49kJOTg/j4eERERKCkpAQ9e/YEAIiiiIqKCrRr187ldkmS4ykk7rDdnSf2LzX4W077k3PbGu1PBufCMi3RJAEa0YjyunMfInKKaqAUFNYpicEsBA4xoPB8uMaT0wRHpSTgvLZqh8Ez8o6Wvhd4Y3zgCxxveWh/CMzzLweB+twJRjwX8sLzIR88F/LhzXPhs0Ie/fr1g0qlwv79+62X7d27FwMHDoRCYd+MRx99FFlZWXaXHT58GD169IBCocDAgQOxd+9e67b9+/dDpVKhb9++Xj0GIldZVkqEAGjri8mfrNDgcGE1copqcKrsXNaGXpRCItBFRPYaBs8Y6CJ3cLxFRERE5MNgl1qtxpVXXomFCxfi4MGD2Lp1K9555x3ceuutAMzfOmq1WgDAhAkT8MUXX+DTTz/FyZMnsXr1auzduxe33HILAOCmm27C22+/ja1bt+LgwYNYuHAhrrvuulal1RN5kjW4pRCgM0oos6yUWFSDnKIanCypRVGlFrU6EXrRBBdmKBIRETWL4y0iIiIiH05jBICsrCwsXLgQt912G2JiYjB37lxMnjwZAJCZmYnly5dj+vTpmDx5Mp566im89tprOHv2LHr37o233noLycnJAIDLLrsMZ86cwZNPPgm9Xo/JkyfjkUce8eWhEAE4Ny1RAs6tlKg3okZrgMEowSCamK1FREQ+xfEWERERhTqfBrvUajVWrFiBFStWNNp25MgRu/+vvfZaXHvttU73NXPmTMycOdPjbSRqKb0kQa8TUaszolorwmA0QXSxoDwREZGncbxFREREoY5rKhM1w5K9ZZSAGpvVE48V1UAhCAxuEREREREREckIg11EDigUAgBAJ0qoNYio1oqo0Ymo0Rqs19EaTG6twkZEREREREREnsdgFxHOZW+ZJAl1ogm1dSKqNCK0BiMMNlMTDUZmcRERERERERHJGYNdFLIEQYBCIUBvNKFWZ0SNTkSV1gCDaIJBNIFhLSIiIiIiIqLAw2AXhRSFon7lRIMJNXoDqrQiNHoRBtEEkbW3iIiIiIiIiAIeg10UMmpEEyr1OlRqDNCLJhhEIxjfIiIiIiIiIgouDHZRUFIoBJgarJ6YW2xePZGIiIiIiIiIgheDXRQ0FAoBJgB1BiOqakRUaPSo1pxbPdFglBChYrCLiIiIiIiIKJgx2EUBTRAECEJ9gKtOREWdATqDEXrRnNHF1ROJiIiIiIiIQguDXRRwLAEujWhCjc6AijoDNAYRegNXUCQiIiIiIiIKdQx2UUAQBPM0Ra1oQrVWREWdHhq9EXoWmSciIiIiIiIiGwx2kWwJMAe4DCYJ1VoRlRoDanUi9KIJRka4iIiIiIiIiMgBBrtItqr0RhRrDKjRitAZjAxwEREREREREVGzGOwi2VAoBIg2VbdOlNZAKSj82CIiIiIiIiIiCjQMdpFfCYK54HydwYjyagMKqjTWbaIRULKHEhEREREREZELGEogvxAEARCAap0RZXU6VGlE6A1GaEWTv5tGRERERERERAGMwS7yKYVCgFECKrQGlNboUasXYWCAi4iIiIiIiIg8hMEu8gmFQoDeZEJ5jR6ltXpo9Sw4T0RERERERESex2AXeU3DelzldXroDEYwxkVERERERERE3sJgF3mco3pcOoPR380iIiIiIiIiohDAYBd5jEIQIAkC63ERERERERERkd8w2EUeU1SrQ63eyHpcREREREREROQ3DHaRWwRBsP59plyDMKXCj60hIiIiIiIiolDHyAS1ikIhQGuScLK8znoZk7mIiIiIiIiIyN+Y2UUuEQTABAEFNTqUVOtQUWfwd5OIiIiIiIiIiKwY7KIWUygEVGpFFFbrUK0xwCQxlYuIiIiIiIiI5IXBLmqWQiFAZ5RQUKFBRa0eeq6wSEREREREREQyxWAXOWWuPS+guFaPomodNDoRzOUiIiIiIvKcU+UafH6oAPmVWnSKi8TlAzrivLZqfzeLiCigMdhFDimVAqp1RhRUaVGlMcDI6vNERERERB71+aECLNt8FAIACYAA4IM9eVgwORXTBnT0c+uIiAIXg11kRxAEiJKE/AotSmv10BmM/m4SEREREVHQOVWuwbLNi89XdAAARYlJREFURx2uaL5081EM7hKHrszwIiI/C9TsUwa7yEpQCCjXGFBQpUWdTgTrzxMRERERecfnhwogONkmAPjsUAHmjE7xZZOIiOwEcvapwt8NIP+zFKDPLavDydJa1GoZ6CIiIiIi8qb8Sq3TerhS/XYiIn+xzT41SrD7vXTzUeSVa/zdxCYx2BXiJAjIr9bhWEkNSqt1EI2MchEREREReVunuMgmM7s6xUX6sjlERHZakn0qZz4Ndul0Ojz22GMYOnQoMjMz8c477zi97g8//IArrrgC6enpmDZtGr777ju77UOHDkWfPn3sfmpra719CEHnWGktzpZroNGzNhcREVEw4HiLKDBcPqBjk5ldV8h8ihARBbdAzz71ac2ulStX4tChQ3jvvfdw9uxZzJ8/H507d8aUKVPsrnf48GHMmTMH8+bNw9ixY7F9+3bcf//92LhxI/r27YvCwkJUV1dj69atiIw8941HVFSULw8nIAmCANuwVrXGgAgVE/yIiIiCBcdbRIHhvLZqLJiciqU2ReoV9WkUCyansjg9EflVoGef+izYVVdXhw0bNuDNN99E//790b9/f2RnZ2PdunWNBl9ffvklRo4ciVtvvRUA0K1bN3z//ff4+uuv0bdvXxw7dgzt2rVD165dfdX8oKBQCCjXijhRUuPvphAREZEXcLxFFFimDeiIvh1icNP7+wAAN17QBVendZZNoCtQV2EjIvddPqAjPtiT53BbIGSf+izYdfjwYYiiiPT0dOtlQ4YMweuvvw6TyQSF4lx20VVXXQWDwdBoH9XV1QCAnJwcpKRwZZKWEgQBoiThdIUW5bU61Oo4ZZGIiCgYcbxFFHiS488Fj2ZldIc6TOnH1pwTyKuwEZH7Aj371GfBruLiYrRt2xbh4eHWy5KSkqDT6VBRUYGEhATr5T179rS7bXZ2Nn755RfccMMNAIBjx45Bo9FgxowZyM3NRb9+/fDYY4+1akAmOMvLc4PtLgXB/fsQGvztyv4UCgHlGhH5VZqQX2XRG+eaWofnQl54PuSD58L7mntftmxrzbmQw/njeMtD+4M8zmcgcee5E+o83fc8cS5sV2FraOnmo0hPjpP9B1254HNDPnguXHf5wI7o1yEGN9pkn14z2P3sU1+Mt3wW7NJoNHYDLwDW//V6vdPblZWVYe7cubjgggtw0UUXAQCOHz+OyspKPPTQQ4iJicGbb76J22+/HV999RViYmJcaldiYqyLR9K8Or1o/TshMQZR4e49zLb7S0xq+f40ehFnKjQoN5igDA9Hm/rHW2s4l9nVpo0akW58e+TJfXl7f7Gx8m5fsO+P50K++5Pb+Qikxy7Yz4Xc9+fqvmJjI5CQ0LJxgjfGB77A8ZZn9ufKeIvsBepzx5+81ffcORdv/3YGgiDA0TflgiBg87EyzJ/S153mhRw+N+SD58I1UW3OBbYev2KAR98fvXkufPYuHhER0WiQZfnftuiprZKSEvzjH/+AJEl4+eWXran3b7/9NgwGA6KjowEAzz33HMaOHYtt27Zh2rRpLrWrtLTa49lOtisblpXWoM7NDwa2+ystqUFdeNP7UygEVGhEnHWSzaUTTda/q6o00LlRoN6T+/L2/qqrNdAp5du+YN8fz4V89ye38xFIj12wnwu578/VfalhQpkKMDlKVagnCOaBV2vGB5bb+hPHW57ZX0vGW2TPnedOqPN03/PEuThWUAXJyY0lScKxgiqUlFS70crQYKl5Vqo1IjFSyZpnfsbXqdbxxvujL8ZbPgt2dejQAeXl5RBFESqV+W6Li4sRGRmJNm3aNLp+YWGhtWDq+++/b5d2Hx4ebvetZUREBJKTk1FYWOhyuyTJ4RcWbrHdnSf2LzX429n+LLW58svNtbn0Nh8CyPPnmVqP50JeeD7kg+fC+1r6vuyN8YEvcLzlof0hMM+/HATqc8efvNX33DkXndo0swpbm0ie52Y4qnn2/m7WPJMDvk65xpvvj948F+59PeuCfv36QaVSYf/+/dbL9u7di4EDB9oVSwXMKwndeeedUCgUWLt2LTp06GDdJkkSJk6ciI8//tju+idPnkSPHj28fhxypVAIqNSJyCmuRVGVhoEuIiKiEMTxFlFoO1WuweqfcjH3w9+x+qdcnCrXtGo/lw/oCGefPwNhFTZ/s615ZpRg93vp5qPIa+V5IaKW81lml1qtxpVXXomFCxfi6aefRlFREd555x0sX74cgPlbx9jYWERGRuKNN97AqVOn8MEHH1i3Aeb0+9jYWIwbNw6rVq1Cly5dkJCQgJdeegkdO3bE2LFjfXU4siEIAkRIOFOpRVkNs7mIiIhCGcdbRKHLYSZRK1dPDPRV2Pzt80MFTWbGfXaoAHNGc7VbIm/yaeXNrKwsLFy4ELfddhtiYmIwd+5cTJ48GQCQmZmJ5cuXY/r06fj222+h1Wpx7bXX2t3+qquuwjPPPINHHnkEKpUK//rXv1BTU4ORI0dizZo1UCpDq7aCQiGgQiuioEqLGq2BqZhERETE8RZRCGpu9cTBXVxfPXHagI7o2yEGN9mswnZ1mvursIWC/Eptk5lx+ZVaXzaHKCT5NNilVquxYsUKrFixotG2I0eOWP/+5ptvmtxPREQEHn30UTz66KMeb2MgYDYXEREROcPxFlHo8VYmUXL8ucDWrIzuULu5EESo6BTXTM2zOMcLhgQySzH+/EotOsVFshg/+R3XVA4wCsFcm4vZXEREREREBDCTSG4uH9ARH+zJc7gtGGueOZpC+0Erp9ASeYrPCtSTZ5yu0uJkaS2qNQx0ERERERFRaGYSyZml5pnC5qQoBPNPsNU8YzF+kisGuwKAQjj3KllUpeW0RSIiIiIisuLqifIzbUBHrJ1xgfX/Gy/ogo3/GBZ0mU4tmUJL5A8MdsmYIAgwwpzNZcFsLiIiIiIishVKmUSBxLbm2d0Z3YPyPHAKLckVa3bJlO1Ki6U1On83h4iIiIiIZIyrJ5I/cAotyRWDXTIjCAJEyX6lRWZzERERERG1TiitEtcwkyiSqyeSl4VaMX4KHAx2yYhtNhdXWiQiIiIicg9XiSPyLssU2qX1ReoBWKfTcgot+RODXTLgKJuLiIiIiDxLcDbXBrCbhiM0c11qzPJ4yelxs10lrqGlm48iPTlOFh/EPdn37PYluH8++Lxwj6fPh1xdPrAj+nWIwY02U2ivGSy/KbRyfJ0KBK6+DsglaYfBLj8TBKDGYMSZCg2zuYiIiIi8xCABdXqj0+0aw7ltFXojdByTuUQAYKzSolprdFqs2tc+2n+2ye3r95/FnaO6+6YxTfBk37Pbl86ISDe/Q+fzwj2ePh9yFhMVbv37hmFdoQ5TokLn/DXXH+T4OhUIXH0diApTIkwGAUUGu/xMEATU6ERUawz+bgoRERFRUBIEc6DrVGktjI7SfADoxHOD+ZMlNYhQsdaRq9rojKiq0vi7GVbHimudfpEs1W/PLa7xaZsc8WTfs93XCQ/0Yz4v3OPp81FYrcOO42UoqdUjKTocGT0S0CE2wt1mekSg9BW5vU4FAlfOrVIh4LzEaMRHKP2eyMNgFxERERGFBKNJchrsMprs/3Z2PXLOJMnrcUuICoMgOJ5SI9Rvl0N7Pdn3PN2P+bxwjycfv525Zfhgz2lrnxYE4Ju/izBjWDJGpSR4oLXuCZS+IrfXqUAQKOe2IYW/G0BERERERORpo1ISnGd2SUCGDAIERC1RWK3DB3tOQ4I5WGP7+4M9p1FUrfNzC4nkh8EuIiIiIiIKOh1iIzBjWLJdcWWFYM7qmjEsGe1lMv2LqDk7c8ucFgUXBGBHbplvG0QUADiNkYiIiIiIgtKolASc11aNpZuzAQATeidhTM9EBroooJTW6pusP1daq3d5n4XVOuzMLUNprR6J0eEYlSKf+l9EnsBgFxERERFRCAm1D7ntYs4d27QBHRGh4uQWCiyJ0eFN1p9LjA5vvKEJjup/bT5cLJv6X0SewGAXEREREVGI4Idc94VasJD8b1RKAjYfLna4zdX6c7b1vyzBM8vvD/acRq+kaGY+UlBgsIuIiIiIKATwQ677GCwkf7DUn7M8fwFz/TlJcr3+nKX+l8Mssfr6X1cN6uSZhruBQWVyF4NdREREREQhIFA+5MoVg4XkT56qP+eN+l+exqAyeQInrBMRERERhYBA+JArZ1wRj/ytYf251gRXLfW/HGlN/S9Psw0qmyTY/f5gz2kUVev82j4KHAx2ERERERGFAG99yC2s1uGTg/l4+ftsfHIwH4VB+mGUwUIKBqNSEpz3Yxfrf3kDg8rkKZzGSEREREQUAjxZ5NrCbroRzEGzYJ1u5OkV8Yj8wZP1v7yBQWXyFGZ2ERERERGFAMuHXNukCYVgDtS05kNuo+lGUnBPN5J7RgxRS41KScDjk3tb/5/QOwmLLukjiwC13KdZUuBgsIuIiIiIKER48kNuqE038nSwkMifPFH/yxsYVCZP4TRGIiIiIiIZK6zWYWduGUpr9UiMDseolAR0cOODacMPuRGq1n3/HYrTjTy1Ih4ROSb3aZYUOBjsIiIiIiKSKbuaWJI5Y0ouNbFCtYaVp4KFROQYg8rkCXxlJiIiIiKSoUY1sSCvmlicbkRE3iLXaZYUOBjsIiIiIiKSIbnXxGINKyIikitOYyQiIiIikqFAqInF6UZERCRHDHYREREREclQoNTEYg0rIiKSG74TERERERHJEGtiERERtQ6DXUREREREMsSaWERERK3DaYxERERERDLFmlhERESuY7CLiIiIiEjGWBOLiIjINT59p9TpdHjssccwdOhQZGZm4p133nF63b/++gvXXnst0tLScPXVV+PQoUN227/88ktMnDgRaWlpmD17NsrK/Lv0MhEREZEccLxFga6wWodPDubjrV9O4pOD+Sis1vm7SUREFGB8GuxauXIlDh06hPfeew9PPfUUVq9ejW+++abR9erq6jBz5kwMHToUH3/8MdLT0zFr1izU1dUBAA4ePIjHH38cc+bMwfr161FVVYWsrCxfHgoRERGRLHG8RYFsZ24ZFn59BFuOFGNvXiW2HCnGwq+PYGcuA61ERNRyPpvGWFdXhw0bNuDNN99E//790b9/f2RnZ2PdunWYMmWK3XX/97//ISIiAvPmzYMgCHj88cfx008/4ZtvvsH06dOxdu1aXHLJJbjyyisBmAd148ePR15eHrp27epSuzQGo9NVblpLYzDa77+J6yoEAVqDETrR5PQ6ttuaul5LeXJ/cm4b9yev/cm5bdyfvPYn57Zxf/Lan6v70hqM0OiNMDXxxi8AqNOL0Oibfv92eFuh+et4G8dbjgn119GJRhiddBVP93VPkvPz0JP7K6rR4YM9pyEB1v5i+f3BntM4r63abkqnr9sXCPuTc9tCkZzPh5zb5o39WTT32Zsac+VcKBXm99sIAc2+L3t7vCVIkqeHHo7t27cPt9xyC/bv34/w8HAAwK5du3DXXXdh//79UCjOJZk98cQT0Ol0WLlypfWyRx99FOHh4Vi8eDEuvvhi3HXXXbjmmmus2ydMmICHHnoIU6dOdaldA576FjU60c2jIyIiolAXE6HCoUUX+7UNHG8RERFRMGvpeMtn0xiLi4vRtm1b68ALAJKSkqDT6VBRUdHouu3bt7e7LDExEQUFBQCAoqKiJrcTERERhSKOt4iIiIh8OI1Ro9HYDbwAWP/X6/Utuq7lelqttsntrvjm7hEeT6sHzKl1CYkxKCutaXL/CoWA/GodzpRrPN8IAmA+F7GxalRXa7xyrqnleC7khedDPngufKNDmwh0jVfDZGpiGmML37+d3dbfON5yfr0KnREnSmqcTmP0NJ1owrzP/wIArLz8/KBfQdETr2NfHCrA99klcPQUVQjAhN5JmDago3sNDQFyfk/x9PNC7vsD5H0+QontuX32ivMRrpRXX5H7/lpKqQC6J8UgPkLZ7Puyt8dbPgt2RURENBocWf6PjIxs0XUt13O2Xa1Wu9yuyLCmT0JrCQIQFa5CXTP7VygERIYpg34A5G+RYUro3HxBI8/guZAXng/54LnwvsgwJSLDlM0Gu1ry/u3stv7G8Zbz60WagAiVEsYmzr+3RKgUITHWc/d1bHTPRHx3tMThNkkCxvRMDInH0RMC4T3F088LOe8vEM5HKAlXyrevBML+mqKsj280977vi/GWz55xHTp0QHl5OUTxXL2G4uJiREZGok2bNo2uW1Ji/0ZXUlJiTaV3tr1du3Zeaj0RERGR/HG8RYGsQ2wEZgxLhgBzJpcg1P8GMGNYMtrHul6cnoiIQpPPgl39+vWDSqXC/v37rZft3bsXAwcOtCuWCgBpaWn4/fffYamdL0kS9u3bh7S0NOv2vXv3Wq+fn5+P/Px863YiIiKiUMTxFgW6USkJWHRJH0zq0w5DkuMwqU87LLqkD0alJPi7aUREFEB8FuxSq9W48sorsXDhQhw8eBBbt27FO++8g1tvvRWA+VtHrVYLAJgyZQqqqqqwbNky5OTkYNmyZdBoNLjkkksAADfeeCM+++wzbNiwAYcPH8a8efMwbtw4l5fBJiIiIgomHG9RMGgfG4GrBnXCnRd2w1WDOjGji4iIXObTicNZWVno378/brvtNixatAhz587F5MmTAQCZmZn43//+BwCIiYnBG2+8gb1792L69Ok4cOAA1qxZg6ioKABAeno6Fi9ejFdeeQU33ngj4uLisHz5cl8eChEREZEscbxFREREoc5nBeoB87eNK1aswIoVKxptO3LkiN3/gwYNwieffOJ0X9OnT8f06dM93kYiIiKiQMbxFhEREYU6LglBRERERERERERBg8EuIiIiIiIiIiIKGgx2ERERERERERFR0GCwi4iIiIiIiIiIggaDXURERERERBTyimp01r+/OFSAwmpdE9cmIjljsIuIiIiIiIhC2s7cMjy9Odv6//fZJVj49RHszC3zY6tIrhgYlT8Gu4iIiIiIiChkFVbr8MGe05BsLjNJgATggz2nUcRABtlgYDQwMNhFREREREREIWtnbhkEwfE2QQB2MIhB9QIlMMrMMwa7iIiIiIiIKISV1uohSY63SfXbiYDACIwy88yMwS4iIiIiIiIKWYnR4c4DGPXbiQD5B0YDJfPMFxjsIiIiIiIiopA1KiXBeQBDAjJSEnzbIJItuQdGAyHzzFcY7CIiIiIiIqKQ1SE2AjOGJUMAoBDMQQGFYA5ezBiWjPaxEf5uIsmE3AOjcs888yWVvxtARERERERE5E+jUhLQKykaO3LLUFqrR2J0ODJSEhjoIjuWwOgHe05DEMwBJAHmQJccAqOWzDNHAS85ZJ75EoNdREREREREFPLax0bgqkGd/N0Mkjk5B0ZHpSRg8+Fih9vkkHnmSwx2ERERERERERG1kFwDo3LPPPMlBruIiIiIiIiIiIKAnDPPfInBLiIiIiIiIiKiICHXzDNf4mqMRERERERE5HVFNTrr318cKkBhta6JaxMRtR6DXURERERERORVO3PL8PTmbOv/32eXYOHXR7Azt8yPrSKiYMVgFxEREREREXlNYbUOH+w5DcnmMpNkLp79wZ7TKGKGFxF5GINdRERERERE5DU7c8sgCI63CQKwg9ldRORhLFBPRERERCFBqXDyadsr92X/ty/v218UQmgcZyCQ27koqzNAkhxvk+q3t6a9gfI8k9v5CEVy7ytyb19LyandDHb5mSRJSFCHQxtrREWdHqLRybsAEREREbWKJAFRYUqclxjts/vUGIzWv7slxUAdpvTZffuDACA2NhLVEUpwNOtfcjwXPdtFY29ehcOAl1C/PaVdjMv7DYTnmRzPRyiy7Svdk2IQKbO+Egh9uaWiwpROg9u+xGCXn0kSEKYAuidEoTRChcJqHep0or+bRURERBRUwgQgPsJ3Hx4ibL7cjg9XQh0euB9cWkIQgMQ2kVAanGfwkG/I8VxcN7gzPtp3xun26wd3btXzMxCeZ3I8H6HIrq9EKGUX7AqEvtxScunnDHbJhGSSkBQdjpgIFfKrtMzyIiIiIvIwXw7ApQZ/y2Xw722SFDrHKndyOhdd49VYMDkVSzcfhQDzc8Lye8HkVCTHq1vV1kB6nsnpfIQiu74iw3MRSH05UDDYJSMmk4RwhcAsLyIiIiIiCirTBnTE4C5x+OxQAfIrtegUF4krBnRE17ZqfzeNQkBehcb69+s7TmB6Wmecx74X1BjskiFmeRERERERUbDp2laNOaNT/N0MCjGfHyrAss1Hrf//d98ZfLjvDBZMTsW0AR392DLyJkXzVyF/sM3y6to2ClERjEsSERERERERtdSpcg2WbT4Kk03uiFECTBKwdPNR5JVrnN+YAhqDXTJnyfLq2S4aSbERUCnls5QnERERERERkVx9fqgAzj5BCwA+O1Tgy+aQDzHYFQBMJgnhArO8iIiIiIiIiFoqv1ILZwWBpPrtFJwYNQkg1lpekSrkV7KWFxEREREREZEzneIim8zs6hQX6cvmkA8xsyvAMMuLiIiIiIiIqHmXD+jYZGbXFSxQH7R8FuySJAnPPfccRo4cieHDh2PlypUwmUxOr79//37ccMMNSE9Px8UXX4wNGzbYbb/88svRp08fu5+jR4862VvwYS0vIiIiaojjLSIionPOa6vGgsmpUAiAUoDd7wWTU9G1rdrfTSQv8Vla0Lvvvosvv/wSq1evhiiKeOSRR5CYmIh//vOfja5bXFyMu+66CzfeeCOeeeYZ/Pnnn8jKykK7du0wbtw4GI1GnDhxAmvXrkX37t2tt2vbtq2vDkcWbLO8SiNUKKzWoU4n+rtZRERE5CccbxEREdmbNqAjBneJw+eHClCqMyIxQonLB3RkoCvI+SzY9f777+O+++7D0KFDAQAPP/wwXnrpJYeDr61btyIpKQkPPfQQAKB79+7YtWsXvvjiC4wbNw6nT5+GwWDAoEGDEBER4atDkC3W8iIiIiKA4y0iIqL/b+/eo6Su7/uPv74zs3Pb2QvsLnsBVFZFUBKwIHiamgSr1qaxSrI5rT2REEiPPeFyTosk3nKOjdicCLTFaBpJjRU12kTSmJqco/W0J0YbDb/luARTCSwSCbLLLsi6t7l8L78/vjPDLnthkZ2Z7848H+cQZr/f2W8+w5tx3rz28/l8RzN7WkTrPj5HtbUV6u7ulcM/l4teXsKuzs5OHTt2TFdddVX22OLFi3X06FEdP35cM2bMGPb8a665RvPnzx9xnb6+PknSwYMH1djYSOM1BLO8AAAobfRbAAAArryEXV1dXZI0rMmqra2VJHV0dIxovmbNmqVZs2Zlvz5x4oR++tOfav369ZKk9vZ2lZWV6fbbb9e+ffs0Z84cfeUrX9FHP/rRcx6bkaOtrjLXzdX1x+Q4qosFVZGe5fU+s7yG1YIEv7CohbdQD++gFvljGON/Np/P53feP/PPQL/lLb8/NZh9/Ohrh/XZRU26oIiXzHi5FqWmlGphnPHYi6+5lOrhdV6uxVT4uzyZ8tFvTVrYFY/H1dnZOeq5gYEBSVIwGMweyzxOJpNnve769etVW1urv/iLv5AkvfPOO+rp6dHnPvc5bdiwQT/4wQ/0hS98QT/72c/U2Nh4TuOuqak4p+efq1xffzwzamLq7E3oeE9ccXPszWlLRWVltNBDQBq18Bbq4R3UIrcqKkKaPj02oecW8vN7PPRbhbn+ufrB/zuiO3ftzX797J739Myeo/rmZz+qzy2ZXcCR5Z7XalHKSqEWA8nTK1lqamOKBr17p/pSqMdU4cVaTKW/y5Mpl7WYtD/BtrY2rVy5ctRzmzZtkuQ2Wpmp8JmmKxIZ+ydc/f39+vKXv6zDhw/r+9//fva5999/v+LxuGIxt2G97777tGfPHj3//PP6m7/5m3Ma94kTuVmvaxhu4XJ1/YmK+AzNiPh1rCelU/1JmXbpTRkwDPcfkB98MMCMiQKjFt5CPbyDWuRHRLZOBtyl/2M5n8/vzPfmEv3WcF7pt4Z69/1B3blrr4b+NbPSg/vqrr26pCpUlJsie7EWpaqUajGYtLKPT3T3aSDoL+BoRldK9fA6L9diKvxdnkz56LcmLexatmyZ9u/fP+q5zs5ObdmyRV1dXdnp8pmp9nV1daN+T19fn770pS/p3Xff1RNPPDHsLkCBQCDbeEmSYRhqbm4e8yed43Gc3C4ZyfX1z8ay3L28LpweVSwU0PES3Msr8+fvtf+glSJq4S3UwzuoRf5M9HO50J/fY6HfKsz1z8Xzv+7QWCssDEk//nWH1l0zJ59Dyisv1aLUlUItnDMee/n1lkI9pgov1mIq/V2eTLmshS83lx2uvr5eTU1Nam1tzR5rbW1VU1PTiP0jJMm2ba1bt06///3v9eSTT+rSSy8ddv62227Tww8/POz5+/fvV3Nzc+5exFRnO6orD6q5tlw1FSEFfEW+CBgAgBJDv+UNx3riGqtvd9LnAQBAbuVtIeitt96qrVu3qqGhQZK0bds2rV69Onv+5MmTCoVCKi8v13PPPac33nhD//Iv/6LKysrsTyXLyspUXV2ta6+9Vo888ojmz5+vOXPmaOfOnert7dWKFSvy9XKmJNt2FPKdvmPj8d6EBhPmmA0ZAACYWui3Cq+xKjzuzK7GqnA+hwMAQEnKW9i1Zs0anThxQuvWrZPf71dLS4tWrVqVPd/S0qIVK1Zo/fr1evHFF2Xbtm6//fZh11i6dKmefPJJrVq1SolEQps3b1Z3d7cWLlyoxx9/fNhUe4wjPcurMlSmjt64Tg0klWQDewAApjz6rcL78wUNenL3kVHPOZJuXtCQ3wEBAFCCDMcpldWgo+vuzt2GqbW1FTm7/mQxfIZ64qY6PoirP27K9vJgz0NVVVQ9PQOFHgZELbyGengHtci9hqqwZldHzrpB/Yf9/M58L0YqtX7rP/d1aPNLv5UhN+DK/H7vDXN1U5GGXV6tRSkqpVoMpix9/KHXJEmvbPiYImXe29S7lOrhdV6uxVT4uzyZ8tFvlcb9LDEmx3ZUFfKroi6m430JnehLDLsTBAAAAM7NTQsatGhmlZ7f16FjPXE1VoV184KGorwLIwAAXkTYBTmOZMhRY0VIVeGAOnoT6hlIyrQ8FncDAABMEbOnRYr6rosAAHhZXu7GiKnBth2F/T7NmR7VhTXlKg8HZHDTRgAAAAAAMIUwswsjOLajaeEyVYQC6uxN6GR/UokUSxsBAAAAAID3MbMLo3IcR35Js6vDaq4t17TyoPw+pnkBAAAAAABvI+zCuCzLUXmZTxfXlGv29KiioYCIvAAAAAAAgFcRduGsHMed6VVXHtQldTHVVYUVDPBXBwAAAACA83Xk1GD28aOvHda77w+O82xMBIkFJsy2HZUZ0oXVEV1UU67KaFA+drAHAAAAAOBD+cm+Dt325J7s18/sOarPPb5b/7mvo4CjmvoIu3DObNtRZcivS2rL1TQtokjQX+ghAQAAAAAwpbz7/qAeeOm3sp3Tx2zH/bX5pd/qCDO8PjTCLnwojiMZjqPGipCaa2OqrQipjKWNAAAAAABMyE/2dYy5J7Yh6Xlmd31ogUIPAFObbTsK+w1dND2q3oSlE/0J9cZNJVOWnLN/OwAAAAAAJelYT3zMfzc76fP4cAi7MCkc21FF0KfKUFQDKUvvD6T0/kBSiZQ1bEomAAAAAACQGqvC487saqwK53M4RYV1Z5g0jpOZ6eXTzKqwLp0R06zpUZWHA/L72MgeAAAAAICMP1/QMO7MrpsXNORzOEWFsAs54d650VB9LKTLZlTootpyVUeD7OsFAAAAAICkC6ZFdO8Nc+UzJL+hYb/fe8NczZ4WKfQQpyyWMSKnbNuRIWlauEzTImXqTVg6OZDQB4Ps6wUAAAAAKG03LWjQoplVen5fh471xNVYFdbNCxoIus4TYRfywnEcydHpfb1i7OsFAAAAAMDsaRGtu2ZOoYdRVAi7kFeO4wZfmX296iqCen8gpZP9SQ0mLVmkXgAAAAAA4DwQdqFgbNtRQO6+XrXlIfXEUzrRl1R/0lTKtAs9PAAAAAAAMAURdqHgTu/rFRi2r1dv3FQyZct2mO0FAAAAAAAmhrALnuE47v9UBH2qCpcrnrLVm0jp1GBKA0lLSdMSuRcAAAAAABgPYRc8x3Eky7JV5pNqokHVlgc1YNrqTZg6NZBSImkqadrcyREAAAAAAIxA2AVPcxxHjiOFfYai5UHNKA9qIGXpg7gbfCVNS0n29wIAAAAAAGmEXZgy7PSdGiN+n8orQqqPBdWfsvVBPKWewZSSKVspi+ALAAAAAIBSRtiFKSkTfJUHfKqoDKuhIqy+hKkPEqY+GEwpmbJk2ix0BAAAAACg1BB2YcrL3M2xIuhXVTggsyKk3qSlDwZT6o2nWOYIAAAAAEAJIexCUbFtRz5J1SG/pkcCSlgh9SctpXx+JQf9Spk2M74AAAAAAChihF0oSu4dHR0FZGhaOKCamgpNK5P6Erb6EqZ64ymlTFsp7uoIAAAAAEBRIexC0XPSaVZAhqpDfk0LB2RXhjVgWu4+X4OmEilLKcuWxawvAAAAAACmNMIulBTHkZx0+hX1+xSLhdQQCylu2upPWupLpNSXsNxZX9zZEQAAAACAKYewCyUtc1fHoM9QKBJQbXmZUpajgZS73PGDeEpJ01LStLMzxAAAAAAAgHcRdgFpmX2+fJJiZT5VhkJqrAxpMGWpP313x8GUxSb3AAAAAAB4GGEXMIbMrK+w36dI1K8ZsZASlqX+pK3+zCb3liOTvb4AAAAAAPAMwi5gAhzHyd7dMbvJfVVYCdPWYMrd6L4vYcq0bKVMRzZrHgEAAAAAKAhfvv6PHMfR1q1bdfXVV2vp0qV68MEHZdtjbwC+efNmXXbZZcN+PfXUU9nzL7zwgq677jotXLhQa9eu1cmTJ/PxMgA5TnrWl+0o5DM0LRzQBdURzZsR06V1FbqwtlwzqsIqDwcUCvjkMwo9YgBAqaDfAgAAyOPMrscff1wvvPCCHn74YZmmqU2bNqmmpkZr1qwZ9fnt7e3auHGjVqxYkT0Wi8UkSXv37tU999yjv//7v9e8efP0wAMP6K677tKjjz6al9cCDDX0Do8hv6FwIKDaaJlsx1HctDWQtNSfNNWfsJSy3Ls8MvELAJAL9FsAAAB5nNm1c+dObdiwQUuWLNHVV1+tO+64Q08//fSYz29vb9fll1+uurq67K9IJCJJeuqpp/Snf/qnuuWWWzRv3jw9+OCD+vnPf64jR47k6+UAY8rO/HLc/b5qokFdOC2qy+ordMmMmC6sKVddRUjloYCCAZ8MZn4BACYJ/RYAAECewq7Ozk4dO3ZMV111VfbY4sWLdfToUR0/fnzE8/v6+tTZ2amLLrpo1Ou1tbVpyZIl2a8bGxvV1NSktra2SR87cL4cx5FtOzIcRxG/T7XRoObURDW3vkIXp8Ovmtjp8MtH+gUA+BDotwAAAFx5WcbY1dUlSZoxY0b2WG1trSSpo6Nj2HHJ/SmjYRj6zne+o1deeUXV1dX64he/mJ1if/z48RHfU1NTo46OjnMeW65yhcx1yS0Kz3u1cGTbkl9SecCnWJlfM2JBWbYUNy0NmrYGEqb6k5ZSprvssVju9ji0FizlLDzq4R3UIn8MY/zPg/P5zCj05wz9FgqJWnhHKdXCOOOxF19zKdXD66iFd+Sj35q0sCsej6uzs3PUcwMDA5KkYDCYPZZ5nEwmRzz/0KFDMgxDzc3N+vznP6/du3fra1/7mmKxmK6//nrF4/Fh18pcb7RrnU1NTcU5f4+Xro+Jm2q1sGxHg0lLA0lTA0n3jo9J0w2+zCkeflVWRgs9BAxBPbyDWuRWRUVI06fHJvRcr35m0G8V5vqYOGrhHaVQi4GkmX1cUxtTNJi3LanPWSnUY6qgFt6Ry1pM2n8N2tratHLlylHPbdq0SZLbaIVCoexjSdl9IYa65ZZbtHz5clVXV0uS5s2bp8OHD+uZZ57R9ddfr1AoNKLRSiaTo17rbE6c6M3JT9ENwy1crq6PiZvqtfAbUqXPUGXEr6TlU9y0NZhyw6940t303rQc2VPgxRmG+4/5Dz4YmJK1KDbUwzuoRX5EZOtkIL2v4hjO5zMj8725RL813FT/jC8m1MI7SqkWg0kr+/hEd58Ggv4CjmZ0pVQPr6MW3pGPfmvSwq5ly5Zp//79o57r7OzUli1b1NXVpVmzZkk6PdW+rq5uxPMNw8g2XhnNzc16/fXXJUn19fXq7u4edr67u3vUa52Neye9c/42z1wfEzdVa+GO2R340KWP9bGgzMzSx5StgaSp/oQp03I8u/Qx8+c/FetQjKiHd1CL/JnoZ4FXPzPotwpzfUwctfCOUqiFc8ZjL7/eUqjHVEEtvCOXtcjLBvX19fVqampSa2tr9lhra6uamppG7AUhSdu3b9eqVauGHXv77bfV3NwsSVq4cOGwax07dkzHjh3TwoULc/MCAI9xHEeWdXrT+5pIQBdURzSvvkKX1sc0py6mWdOjqo4GFc1ufF/oUQMAcol+CwAAwJW3Rc233nqrtm7dqoaGBknStm3btHr16uz5kydPKhQKqby8XMuXL9eOHTv02GOP6frrr9err76qH//4x9q5c2f2WrfddpsWLVqkj3zkI3rggQf0yU9+UrNnz87XywE8xU3E3Ug8aBgKhfwywgEZlWGlLFtxy1Y8aWkgZak/Ycm0bJm2u/wRAFA86LcAAADyGHatWbNGJ06c0Lp16+T3+9XS0jLsp4ktLS1asWKF1q9fr49+9KPavn27HnroIW3fvl0zZ87Utm3bdOWVV0qSrrzySn3961/XQw89pJ6eHn3sYx/T/fffn6+XAnje6fDLkU9S1O9TedSvWsOd4p00nfSdHy31xU0lTNsNwKbI3l8AgNHRbwEAAEiG45T2v2y7u3O3YWptbUXOro+JoxZj8/kMGYahlO0oYVqKp05vfp8Jv0zL1mT+sVVVRdXTMzCJV8T5oB7eQS1yr6EqrNnVkbNuUP9hPzMy34uR6LeKH7XwjlKqxWDK0scfek2S9MqGjylS5s0N6kulHl5HLbwjH/2Wd+/NCiDn3H/wubO/In6fogGfjGiZJClh2UqYjgZNS/1xU/FUZvmj48nN7wEAAAAAkAi7AAwxdO+vMsNQWZmhiqBfvlhQVvrOj3HT1mDSUl/SVMrMzewvAAAAAAA+LMIuAONy7/zoPg77fYoEfJoecWd/JW1b8RSzvwAAAAAA3kHYBeCcDJ39FZChGLO/AAAAAAAeQtgF4LxNdPbXQMKUv8yneMCnFHd+BAAAAADkAGEXgEk33uyvisqoOkM+DSRtDSRN9SVMpdIzv1j6CAAAAAA4X4RdAPLCcRzZtlQW8Cns9ykc8akmWiZHUty0FTctDSQtN/wybaUsd/kjAAAAAADngrALQEEMnf0V8hkKhwKaFnaXPiYsW/GUrcGUG365G9+z7xcAAAAA4OwIuwB4wtDwq8wwVBb0qyockFEZVtKy3U3vU5b60nd9dGd+2WLlIwAAAABgKMIuAJ5l244kR35J5QGfYmV+1ceCStlSwrQ0mLTUn7LUnzBlppc+En4BAAAAQGkj7AIwZWTu+uiTFPH7FI36VGsEZTuO4qatgaSl/qSp/oQ78ytl2eKGjwAAAABQWgi7AExZQ5c+hv0+RaJ+1ZYHZTnKbnjfGzc1mLJkEn4BAAAAQEkg7AJQNBzHkeNIhjIzv/yakV72GE9ZGkhZ6h1MKW7aSpk2G94DAAAAQBEi7AJQtIYue4wGfCov86s+FlLKsjWQsjWQMrMb3puWo5RlF3rIAAAAAIDzRNgFoGS44Zcjn6RYmU+VoZCMCvduj4MpWwNJU71xUwkzc7dH5n0BAAAAwFRD2AWgZA2922Mm/GqoCClh2YqnbPUnLfUmUkqm3P2+LG71CAAAAACeR9gFAGl2OswqMwyVBf2qCgckhZQwHQ2Y7l0ee+NmetYX4RcAAAAAeBFhFwCMIRt++aTqUEDTwmVyqqRB09Zg0lJ/0lRfwpRpujO/yL4AAAAAoPAIuwBgAhzH3fNLksI+Q5FIQDXRMtmOkw2/+hKmBpLufl8py5ZD+AUAAAAAeUfYBQAfwtDwK+L3KRr1qy4WVMqW4qalgaS75NG90yPhFwAAAADkC2EXAEwC906Pkk9S1O9TedSv+lhQKctR3LIVT1rqT1kaSJgyLYcN7wEAAAAgRwi7ACAHRgu/ag3JlpRM3+1xMGWpL24qmZ75ZTL7CwAAAADOG2EXAOSB4zjZICtoGAqF/KoOB2RUhpWybMUtd9+vgfTsr5TlcMdHAAAAAPgQCLsAoABO7/nlDJv9ZaRnfyVMW3HTVjw9+ythWjJth9lfAAAAAHAWhF0A4BFDZ3+FfIbCIb+M9OyvpGW7AVjKUty0s3d9tCxbpu0wAwwAAAAA0gi7AMCjhs7+8kuKBnwqL3NnfxmGoZRluyGY5Shh2hpMpu/+aDuyLEeWbYsMDAAAAECpIewCgCnk9Owvd/lj2O9TJCAZ4YCkoBy5G+An0wFYImVpIGkpadmybFuW5cgkAQMAAABQxAi7AGCKOz0DzFVmGCoLGIqV+WREy9xZYLajVHopZMKyFU+aGkzZCgV8CgZ8smxHtu2IGAwAAADAVEfYBQBF6sxN8EM+Q6GgX4YRkFEelGFIkVhYJ8I+JczTYVg8lZkJ5gZgFnuCAQAADzpyajD7+NHXDuszC5t0wbRIAUcEwCsIuwCgxGSWQhqGFAkGFPb7FPLJDcHS+4FZjht+mbajpOW4SyNTluIp290Y33ZkOafDMAAAgHz6yb4OPfDSb7NfP7PnqJ7Zc1T33jBXNy1oKODIAHgBYRcAQNLw/cCk9HJIv6FoQJKGBGG2nV4W6YZgKctJ3yXSkmm5AZidCcKG3GESAABgMrz7/qAeeOm3w27Ek3m8+aXfatHMKs1mhhdQ0gi7AADjygRgI4KwgKHyMp8kIxuEmbYj03ZnhJmWOzssZTtKpCwlLHeDfNtxZ4NlAjEmhgEAgHPxk30dMsY4Z0h6fl+H1l0zJ59DAuAxhF0AgA/tzCDM0OkZYfJLhuGXYbjtaGZWmOlkgjBHKduRmdk437Rl2rYbgGWXSUo2U8MAAMAQx3riY95Ux0mfB1Da8hp2OY6jbdu26bnnnpNt22ppadEdd9whn8834rl33nmn/uM//mPE8WXLlmnnzp2SpCVLlqi3t3fY+T179qi8vDw3LwAAcE6G3ynS/T0gQwG/obBf2Rlh0um9wkzbkZUJwtJLJk3TdvcNGzI7zHZ0eskkyyWBLPotAMWusSo87syuxqpwPocDwIPyGnY9/vjjeuGFF/Twww/LNE1t2rRJNTU1WrNmzYjn3nPPPdq4cWP266NHj+q2227TypUrJUmdnZ3q7e3Vyy+/rHD49H/MotFo7l8IAGBSjB6GSQG/oZDfkGGcXiYpDZkdZktWejlkZnaYZac30jfdTfTPDMOYJYZSQb8FoNj9+YIGPbn7yKjnHEk3s0E9UPLyGnbt3LlTGzZs0JIlSyRJd9xxh7Zv3z5q81VRUaGKiors13feeaduvPFGXXfddZKk9vZ21dXVafbs2fkZPAAg74Yvk3QfS1LAkAKGIfkyQVhgWCDmyF0qmZkpZlrp3x03GEuZ7sb6pp0OxRxHTnr/MHeWGHuJYeqi3wJQ7C6YFtG9N8zV5pd+K0Nud5D5/d4b5rI5PYD8hV2dnZ06duyYrrrqquyxxYsX6+jRozp+/LhmzJgx5vf+8pe/1O7du/Xiiy9mjx08eFBz5rDpIACUurECMZ8k37D9w6QzZ4k5jiPTkax06GXZ6VDMdmeNmemlk5lgzBkyW8xJB2MsoYSX0G8BKBU3LWjQoplVen5fh471xNVYFdbNCxoIugBIymPY1dXVJUnDmqza2lpJUkdHx7jN144dO7RixQo1NjZmj7W3t2twcFC33Xab3nnnHc2fP1933333OTdkxliLvc/T6X9M5eb6mDhq4R3UwltKsx6ng6nM8km/JL8v/Yfgz+wfJp0ZjNnpWWKZu0madiYcs2U5cmeMWXb2LpR2eonmsNlitnvszGxsaC0IznLL3Sdu/PNDfz/Xaxca/RYKhVp4RynV4oLpEa3/uLcD+VKqh9dRC+/IR781qWFXPB5XZ2fnqOcGBgYkScFgMHss8ziZTI55zSNHjuj111/XPffcM+z4oUOH1NPTo7/7u79TLBbTd7/7Xa1atUo//elPFYvFJjzmmpqKsz/pPOT6+pg4auEd1MJbqMfkszMh2NBZYumN9830OdNylLLdJZVWOgQLTo+5YZjjzk9jOeXkqqgIafr0ifUIXn5f0G/l//qYOGrhHdTCW6iHd1AL78hlLSY17Gpra8tuaHqmTZs2SXIbrVAolH0sSZHI2FNNX3zxRc2fP1+XXHLJsOOPPfaYUqlU9k5AW7du1Sc+8Qn9z//8j2666aYJj/nEid6c/BTdMNzC5er6mDhq4R3UwluoR/4FDPdulIah9CewT0bIL8dxVF4Z0fun+mWlZ4xZdnrPsfTeYynTvTNlKr0ZvzPKjLHMbDLKObqIbJ0MuGHkWM7nfZH53lyj3zqN/455B7XwDmrhLdTDO6iFd+Sj35rUsGvZsmXav3//qOc6Ozu1ZcsWdXV1adasWZJOT7Wvq6sb85q/+MUv9Md//McjjgeDwWE/tQyFQpo1a9aYP+kci3snsHP6Fk9dHxNHLbyDWngL9cifzP5iZxyVYUihgF8BGe5KyjH3GXO/ziyltNIB17BwLP04ld5rLGnZ6c33hwZkpbvf2ET/vnv5fUG/lf/rY+KohXdQC2+hHt5BLbwjl7Xw5eayI9XX16upqUmtra3ZY62trWpqahpz/wjHcfTrX/9af/AHfzDi+HXXXacf/ehH2WMDAwP63e9+p+bm5ty8AAAA8szJ7Ptlu78sy5GVDq98ksoMQyGfoWjAp4qgX9PCAdVFg2qsCOmC6oguqY3q8voKzWuo0Lz6Cs2dUaFLZsTUXBfTnLpyXVhTrtk15WqsjqgmFlJltEzl4YCioYDCZX4FAz6V+X3y+wz2t5gi6LcAAADyuEG9JN16663aunWrGhoaJEnbtm3T6tWrs+dPnjypUCiUnSp/9OhR9ff3j5hSbxiGPvnJT+pb3/qWZs6cqenTp2v79u1qaGjQJz7xify9IAAAPGTknSndr6X03Sl9Upl86VljPp111pgtmZnZYpYt05FSpqWk5Shp2umlk+lfdunOFvMa+i0AAFDq8hp2rVmzRidOnNC6devk9/vV0tKiVatWZc+3tLRoxYoVWr9+vSTpxIkTkqSqqqoR19q0aZMCgYA2btyovr4+XX311dqxY4f8fn9eXgsAAFPZWYMxw11KGcoGYn4Zxum7VWaWQppDllGatiNzgqEYm+/nDv0WAAAodYbjlPbPX7u7c7dham1tRc6uj4mjFt5BLbyFenhHMdXCMDSxUCw9e8y9Q6W7v1jmDpbZ5ZuZDfedyQnIGqrCml0dOesG9R+2FpnvxUj0W8WPWngHtfAW6uEd1MI78tFv5XVmFwAAKG6ZoOpMAUkBnyH5TgdhYy2jtB2lN99PL6m03a+tMwIy03KUsh3Ztp0NxiY7IAMAAMDUQ9gFAADybrxllIbSDYphnHFnSvfsmQGZo9OB2GgBWeZYwMcu+wAAAKWAsAsAAHje6VBs4gFZ5suhAdl4SxgBAABQHAi7AABA0Rp9BhkAAACKma/QAwAAAAAAAAAmC2EXAAAAAAAAigZhFwAAAAAAAIoGYRcAAAAAAACKBmEXAAAAAAAAigZhFwAAAAAAAIoGYRcAAAAAAACKBmEXAAAAAAAAigZhFwAAAAAAAIoGYRcAAAAAAACKBmEXAAAAAAAAigZhFwAAAAAAAIoGYRcAAAAAAACKBmEXAAAAAAAAigZhFwAAAAAAAIoGYRcAAAAAAACKBmEXAAAAAAAAigZhFwAAAAAAAIoGYRcAAAAAAACKBmEXAAAAAAAAigZhFwAAAAAAAIoGYRcAAAAAAACKBmEXAAAAAAAAigZhFwAAAAAAAIoGYRcAAAAAAACKBmEXAAAAAAAAigZhFwAAAAAAAIoGYRcAAAAAAACKRt7DLsdxtHr1av3oRz8a93lHjhzRqlWrtGjRIn3qU5/Sq6++Ouz8//7v/+rTn/60Fi5cqJUrV+rIkSO5HDYAAMCUQb8FAABKWV7DLtu2tXnzZr322mvjPs9xHK1du1a1tbXatWuXbr75Zq1bt07vvfeeJOm9997T2rVr9ZnPfEbPPfecpk+fri9/+ctyHCcfLwMAAMCz6LcAAECpy1vY1dnZqS984Qv67//+b1VWVo773Ndff11HjhzR17/+dV188cW6/fbbtWjRIu3atUuS9MMf/lALFizQ6tWrdemll+ob3/iGjh49ql/96lf5eCkAAACeRL8FAACQx7DrrbfeUmNjo3bt2qWKiopxn9vW1qbLL79c0Wg0e2zx4sV68803s+eXLFmSPReJRHTFFVdkzwMAAJQi+i0AAAApkK//o2uvvVbXXnvthJ7b1dWlGTNmDDtWU1Ojjo6OCZ0/Fz6flIvZ+IaR2+tj4qiFd1ALb6Ee3kEtvON8apH53kKi30KhUAvvoBbeQj28g1p4Rz76rUkLu+LxuDo7O0c9V1dXN+ynhmczODioYDA47FgwGFQymZzQ+XMxffr4P/U8X7m+PiaOWngHtfAW6uEd1MI7vFoL+q3CXB8TRy28g1p4C/XwDmrhHbmsxaSFXW1tbVq5cuWo5x555BFdd911E75WKBTSqVOnhh1LJpMKh8PZ82c2Wslk8qx7UwAAAExl9FsAAABnN2lh17Jly7R///5JuVZ9fb0OHjw47Fh3d3d2Kn19fb26u7tHnJ8/f/6k/P8DAAB4Ef0WAADA2eVtg/pzsXDhQr311luKx+PZY62trVq4cGH2fGtra/bc4OCgfvOb32TPAwAAYHz0WwAAoFh5Juw6efKk+vv7JUlLly5VY2Oj7rrrLh04cEA7duzQ3r171dLSIkn67Gc/qz179mjHjh06cOCA7rrrLs2aNUvLli0r5EsAAADwNPotAABQCjwTdrW0tOh73/ueJMnv9+vb3/62urq69JnPfEY/+clP9Mgjj6ipqUmSNGvWLH3rW9/Srl271NLSolOnTumRRx6R4YXbIAEAAHgU/RYAACgFhuNw000AAAAAAAAUB8/M7AIAAAAAAADOF2EXAAAAAAAAigZhFwAAAAAAAIoGYRcAAAAAAACKBmFXDiQSCd19991asmSJ/uiP/ih71yPk33/913/psssuG/Zrw4YNhR5WSUkmk/r0pz+tN954I3vsyJEjWrVqlRYtWqRPfepTevXVVws4wtIyWj02b9484n3y1FNPFXCUxa2zs1MbNmzQ0qVLdc011+gb3/iGEomEJN4b+TZeLXhfeB/9lnfQbxUe/Za30G8VHv2WdxSq3wpMylUwzIMPPqh9+/bpiSee0HvvvaevfvWrampq0o033ljooZWcgwcPavny5br//vuzx0KhUAFHVFoSiYQ2btyoAwcOZI85jqO1a9dq7ty52rVrl15++WWtW7dOP/vZz7K3u0dujFYPSWpvb9fGjRu1YsWK7LFYLJbv4ZUEx3G0YcMGVVZW6umnn1ZPT4/uvvtu+Xw+feUrX+G9kUfj1eKrX/0q74spgH7LO+i3Cot+y1votwqPfss7CtlvEXZNsoGBAf3whz/Ud7/7XV1xxRW64oordODAAT399NM0XwXQ3t6uuXPnqq6urtBDKTkHDx7Uxo0b5TjOsOOvv/66jhw5omeffVbRaFQXX3yxfvnLX2rXrl1av359gUZb/Maqh+S+T9asWcP7JA8OHTqkN998U6+99ppqa2slSRs2bNA3v/lNffzjH+e9kUfj1SLTfPG+8C76LW+h3yoc+i1vod/yBvot7yhkv8Uyxkn29ttvyzRNXXnlldljixcvVltbm2zbLuDISlN7e7suuuiiQg+jJP3qV7/SsmXL9O///u/Djre1tenyyy9XNBrNHlu8eLHefPPNPI+wtIxVj76+PnV2dvI+yZO6ujr967/+a/bDPqOvr4/3Rp6NVwveF95Hv+Ut9FuFQ7/lLfRb3kC/5R2F7LeY2TXJurq6NG3aNAWDweyx2tpaJRIJnTp1StOnTy/g6EqL4zh655139Oqrr+rRRx+VZVm68cYbtWHDhmH1QW781V/91ajHu7q6NGPGjGHHampq1NHRkY9hlayx6tHe3i7DMPSd73xHr7zyiqqrq/XFL35x2FRiTJ7Kykpdc8012a9t29ZTTz2lq6++mvdGno1XC94X3ke/5R30W4VFv+Ut9FveQL/lHYXstwi7Jtng4OCID/bM18lkshBDKlnvvfdeth7//M//rN///vfavHmz4vG47r333kIPr2SN9R7h/VEYhw4dkmEYam5u1uc//3nt3r1bX/va1xSLxXT99dcXenhFb8uWLfrNb36j5557Tv/2b//Ge6OAhtbirbfe4n3hcfRb3kG/5U30W95Cv1VY9Fvekc9+i7BrkoVCoRFvlMzX4XC4EEMqWTNnztQbb7yhqqoqGYah+fPny7Ztbdq0SXfddZf8fn+hh1iSQqGQTp06NexYMpnk/VEgt9xyi5YvX67q6mpJ0rx583T48GE988wzNF85tmXLFj3xxBP6p3/6J82dO5f3RgGdWYtLL72U94XH0W95B/2WN/GZ4i30W4VDv+Ud+e632LNrktXX1+v999+XaZrZY11dXQqHw6qsrCzgyEpTdXW1DMPIfn3xxRcrkUiop6engKMqbfX19eru7h52rLu7e8R0YuSHYRjZD5iM5uZmdXZ2FmZAJeL+++/X448/ri1btuhP/uRPJPHeKJTRasH7wvvot7yFfst7+EzxFj5XCoN+yzsK0W8Rdk2y+fPnKxAIDNvgrrW1VR/5yEfk8/HHnU+/+MUvtGzZMg0ODmaP/d///Z+qq6vZy6OAFi5cqLfeekvxeDx7rLW1VQsXLizgqErX9u3btWrVqmHH3n77bTU3NxdmQCXg4Ycf1rPPPqt//Md/1J/92Z9lj/PeyL+xasH7wvvot7yDfsub+EzxFj5X8o9+yzsK1W/RDUyySCSiW265Rffdd5/27t2rl19+Wd/73ve0cuXKQg+t5Fx55ZUKhUK69957dejQIf385z/Xgw8+qC996UuFHlpJW7p0qRobG3XXXXfpwIED2rFjh/bu3auWlpZCD60kLV++XLt379Zjjz2md999V9///vf14x//WKtXry700IpSe3u7vv3tb+uv//qvtXjxYnV1dWV/8d7Ir/FqwfvC++i3vIN+y5v4TPEWPlfyi37LOwrZbxmO4ziTciVkDQ4O6r777tNLL72kWCymNWvWjEgskR8HDhzQP/zDP+jNN99UeXm5/vIv/1Jr164dNtUeuXfZZZdp586dWrZsmSTpd7/7ne655x61tbXpwgsv1N13360//MM/LPAoS8eZ9Xj55Zf10EMP6fDhw5o5c6b+9m//VjfccEOBR1mcduzYoW3bto16bv/+/bw38uhsteB94X30W95Bv+UN9FveQr9VOPRb3lHIfouwCwAAAAAAAEWDZYwAAAAAAAAoGoRdAAAAAAAAKBqEXQAAAAAAACgahF0AAAAAAAAoGoRdAAAAAAAAKBqEXQAAAAAAACgahF0AAAAAAAAoGoRdAAAAAAAAKBqEXQAAAAAAACgahF0AAAAAAAAoGoRdAAAAAAAAKBr/H8NBhEfr24IWAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -211,7 +192,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 9, "id": "ba89cf21", "metadata": {}, "outputs": [ @@ -219,16 +200,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/aadya/.local/lib/python3.10/site-packages/scipy/signal/_spectral_py.py:2014: UserWarning: nperseg = 256 is greater than input length = 144, using nperseg = 144\n", - " warnings.warn('nperseg = {0:d} is greater than input length '\n" + "C:\\Code\\aeon\\aeon\\visualisation\\series\\_series.py:399: UserWarning: nperseg = 256 is greater than input length = 144, using nperseg = 144\n", + " _, _, _spectrogram = spectrogram(series, fs=fs, return_onesided=return_onesided)\n" ] }, { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -240,16 +219,14 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 10, "id": "6ec98c7a", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -271,7 +248,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 11, "id": "1159a8d269205935", "metadata": { "ExecuteTime": { @@ -287,7 +264,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 12, "id": "8a180ef590247e0", "metadata": { "ExecuteTime": { @@ -299,10 +276,8 @@ "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -314,7 +289,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 13, "id": "b2e554f7d59afe0c", "metadata": { "ExecuteTime": { @@ -326,10 +301,8 @@ "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -341,7 +314,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 14, "id": "2ac0bb80aef62f98", "metadata": { "ExecuteTime": { @@ -353,10 +326,8 @@ "outputs": [ { "data": { - "image/png": "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", - "text/plain": [ - "
" - ] + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -365,14 +336,6 @@ "source": [ "_ = plot_collection_by_class(arrowhead_X[:9], arrowhead_y[:9])" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "99b77c31", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 6cbaa0d6b0030f6c4f9a46eb3e0fb66f1a06451f Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Tue, 29 Oct 2024 09:21:38 +0000 Subject: [PATCH 08/26] refactor load_airlines to numpy --- aeon/anomaly_detection/_stray.py | 7 ++----- aeon/datasets/_single_problem_loaders.py | 2 +- aeon/transformations/series/_dobin.py | 3 ++- aeon/transformations/series/tests/test_boxcox.py | 4 +++- aeon/transformations/series/tests/test_yeojohnson.py | 3 ++- 5 files changed, 10 insertions(+), 9 deletions(-) diff --git a/aeon/anomaly_detection/_stray.py b/aeon/anomaly_detection/_stray.py index cf82893671..3ebce07a08 100644 --- a/aeon/anomaly_detection/_stray.py +++ b/aeon/anomaly_detection/_stray.py @@ -66,13 +66,10 @@ class STRAY(BaseAnomalyDetector): -------- >>> from aeon.anomaly_detection import STRAY >>> from aeon.datasets import load_airline - >>> from sklearn.preprocessing import MinMaxScaler >>> import numpy as np - >>> X = load_airline().to_frame().to_numpy() - >>> scaler = MinMaxScaler() - >>> X = scaler.fit_transform(X) + >>> X = load_airline() >>> detector = STRAY(k=3) - >>> y = detector.fit_predict(X, axis=0) + >>> y = detector.fit_predict(X) >>> y[:5] array([False, False, False, False, False]) """ diff --git a/aeon/datasets/_single_problem_loaders.py b/aeon/datasets/_single_problem_loaders.py index 6950ecada7..7dc1f89bf0 100644 --- a/aeon/datasets/_single_problem_loaders.py +++ b/aeon/datasets/_single_problem_loaders.py @@ -891,7 +891,7 @@ def load_uschange(return_array=True): This data shows an increasing trend, non-constant (increasing) variance and periodic, seasonal patterns. - Channels: ['Consumption', 'Income', 'Production', + Channels/Columns: ['Consumption', 'Income', 'Production', 'Savings', 'Unemployment'] Series length: 187 Frequency: Quarterly diff --git a/aeon/transformations/series/_dobin.py b/aeon/transformations/series/_dobin.py index 73a15a2fd3..e2cf6a3a7e 100644 --- a/aeon/transformations/series/_dobin.py +++ b/aeon/transformations/series/_dobin.py @@ -64,7 +64,8 @@ class Dobin(BaseSeriesTransformer): >>> import numpy as np >>> import pandas as pd >>> from aeon.datasets import load_uschange - >>> _, X = load_uschange() + >>> X = load_uschange(return_array=False) + >>> X.drop(columns=["Consumption"], inplace=True) >>> scaler = MinMaxScaler() >>> X = scaler.fit_transform(X) >>> model = Dobin() diff --git a/aeon/transformations/series/tests/test_boxcox.py b/aeon/transformations/series/tests/test_boxcox.py index fa98c9ab65..6274924ddb 100644 --- a/aeon/transformations/series/tests/test_boxcox.py +++ b/aeon/transformations/series/tests/test_boxcox.py @@ -12,12 +12,13 @@ def test_boxcox_against_scipy(): + """Test BoxCoxTransformer against scipy implementation.""" y = load_airline() t = BoxCoxTransformer() actual = t.fit_transform(y) - excepted, expected_lambda = boxcox(y.values) + excepted, expected_lambda = boxcox(y) np.testing.assert_array_equal(actual, excepted) assert t.lambda_ == expected_lambda @@ -28,6 +29,7 @@ def test_boxcox_against_scipy(): "method, sp", [("mle", None), ("pearsonr", None), ("guerrero", 5)] ) def test_lambda_bounds(bounds, method, sp): + """Test lambda bounds for BoxCox.""" y = load_airline() t = BoxCoxTransformer(bounds=bounds, method=method, sp=sp) t.fit(y) diff --git a/aeon/transformations/series/tests/test_yeojohnson.py b/aeon/transformations/series/tests/test_yeojohnson.py index ddbf3e2ff7..37058346c4 100644 --- a/aeon/transformations/series/tests/test_yeojohnson.py +++ b/aeon/transformations/series/tests/test_yeojohnson.py @@ -11,11 +11,12 @@ def test_yeojohnson_against_scipy(): + """Test YeoJohnsonTransformer against scipy implementation.""" y = load_airline() t = YeoJohnsonTransformer() actual = t.fit_transform(y) - excepted, expected_lambda = yeojohnson(y.values) + excepted, expected_lambda = yeojohnson(y) np.testing.assert_almost_equal(actual, excepted, decimal=12) assert t._lambda == expected_lambda From 5912e9608de1e344e925aa150e983ed2af80f70f Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Tue, 29 Oct 2024 09:51:17 +0000 Subject: [PATCH 09/26] notebook --- docs/getting_started.md | 17 ++++++++++------- examples/datasets/provided_data.ipynb | 2 +- 2 files changed, 11 insertions(+), 8 deletions(-) diff --git a/docs/getting_started.md b/docs/getting_started.md index 7f9ebece6b..09772b7099 100644 --- a/docs/getting_started.md +++ b/docs/getting_started.md @@ -26,7 +26,7 @@ between a time series against a collection of other time series. regions where the series are sofind areas of a time series that are not representative of the whole series. - {term}`forecasting` where the goal is to predict future values for a time - series. + series (coming soon!). `aeon` also provides core modules that are used by the specific task modules above @@ -37,21 +37,24 @@ above collections of series, which includes functions to align series. - {term}`networks`, provides core models for deep learning for all time series tasks. - -The following provides introductory examples for each of these modules. The examples -use the datatypes most commonly used for the task in question, but a variety of input -types for data are available. For more information on the variety of +There are dedicated notebooks going into more detail for each of these modules +(linked above). This guid is meant to give you the briefest of +introductions to the main concepts and +code to get started. For more information on the variety of estimators available for each task, see the [API](api_reference) and [examples] (examples) pages. ## A Single Time Series A time series is a series of real valued data assumed to be ordered. A univariate -time series is a singular series, where each observation is a single value. For example, +time series has a single value at each time point. For example, the heartbeat ECG reading from a single sensor or the number of passengers using an airline per month would form a univariate series. Single time series are stored -by default in a numpy array as algorithms use arrays internally whenever possible. +by default in a numpy array (algorithms use arrays internally whenever possible). We can also handle `pd.Series` and `pd.DataFrame` objects, but these are simply -converted to `np.ndarray` internally. The airline data +converted to `np.ndarray` internally. The airline series is a classic example of a +univariate series from the forecasting domain. The series is the monthly totals of +international airline passengers, 1949 to 1960, in thousands. ```{code-block} python >>> from aeon.datasets import load_airline diff --git a/examples/datasets/provided_data.ipynb b/examples/datasets/provided_data.ipynb index ba3529e161..d852d8e85f 100644 --- a/examples/datasets/provided_data.ipynb +++ b/examples/datasets/provided_data.ipynb @@ -1169,7 +1169,7 @@ "source": [ "from aeon.datasets import load_solar\n", "\n", - "solar = load_solar()\n", + "solar = load_solar(return_array=False)\n", "print(type(solar))\n", "plot_series(solar)" ], From 52956bea98f55e9068d1083cd9ee5576ac8c076d Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Tue, 29 Oct 2024 10:24:05 +0000 Subject: [PATCH 10/26] getting_started.md --- docs/getting_started.md | 31 +++++++++++++++++-------------- 1 file changed, 17 insertions(+), 14 deletions(-) diff --git a/docs/getting_started.md b/docs/getting_started.md index 09772b7099..a43bae9f02 100644 --- a/docs/getting_started.md +++ b/docs/getting_started.md @@ -12,19 +12,20 @@ package. If you want help with scikit-learn you may want to view the very latest algorithms for time series machine learning, in addition to a range of classical techniques for the following learning tasks: -- {term}`classification`, where a collection of time series labelled with - a discrete value is used to train a model to predict unseen cases. +- [classification](#classification), where a collection of time series labelled with + a discrete value is used to train a model to predict unseen cases [more details](./classification.ipynb). - {term}`regression`, where a collection of time series labelled with - a continuous value is used to train a model to predict unseen cases. + a continuous value is used to train a model to predict unseen cases [more details](./regression.ipynb). - {term}`clustering`, where a collection of time series without any - labels are used to train a model to label cases. + labels are used to train a model to label cases [more details](./clustering.ipynb). - {term}`similarity search` where the goal is to evaluate the similarity -between a time series against a collection of other time series. -- {term}`anomaly detection` where the goal is to find values or areas of a - single time series that are not representative of the whole series. +between a time series against a collection of other time series [more details](./similarity_search.ipynb). +- [anomaly detection](#Anomaly Detection) where the goal is to find values or areas of a + single time series that are not representative of the whole series. More details + to follow. - {term}`segmentation` where the goal is to split a single time series into regions where the series are sofind areas of a time series that are not - representative of the whole series. + representative of the whole series [more details](./segmentation.ipynb). - {term}`forecasting` where the goal is to predict future values for a time series (coming soon!). @@ -32,17 +33,17 @@ between a time series against a collection of other time series. above - - {term}`transformation`, where a either a single series or collection is transformed - into a different representation or domain. + into a different representation or domain. More details coming soon. - {term}`distances`, measure the dissimilarity between two time series or - collections of series, which includes functions to align series. + collections of series, which includes functions to align series [more details](./distances.ipynb). - {term}`networks`, provides core models for deep learning for all time series tasks. - There are dedicated notebooks going into more detail for each of these modules (linked above). This guid is meant to give you the briefest of introductions to the main concepts and code to get started. For more information on the variety of -estimators available for each task, see the [API](api_reference) and [examples] -(examples) pages. +estimators available for each task, see the [API](api_reference) and [examples](https://www.aeon-toolkit.org/en/latest/examples.html) +pages. ## A Single Time Series @@ -91,7 +92,7 @@ If a series is multivariate, we refer to the dimensions as channels (to avoid confusion with the dimensions of array) and in code use `n_channels`. So the US Change data loaded above has five channels ( ) and 187 time points. For more details on our provided datasets and on how to load data into aeon compatible data -structures, see our [datasets](datasets) notebooks. +structures, see our [datasets](./datasets.ipynb) notebooks. ## Single series estimators @@ -100,7 +101,8 @@ in the `anomaly detection` and `segmentation` modules use single series input (they inherit from `BaseSeriesEstimator`). The functions in `distances` take two series as arguments. -### Time Series Anomaly Detection (TSAD) +### Anomaly Detection + Anomaly detection is @@ -186,6 +188,7 @@ may vary between cases. ``` ### Time Series Classification (TSC) +:term:`classification` Classification generally uses numpy arrays to store time series. We recommend storing time series for classification in 3D numpy arrays of shape `(n_cases, n_channels, From b2151eefa47a3e364ba33998b80fa4b30047c717 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Tue, 29 Oct 2024 13:35:20 +0000 Subject: [PATCH 11/26] getting started --- docs/getting_started.md | 44 +++++++++++++++++++++++++++-------------- docs/glossary.md | 2 +- 2 files changed, 30 insertions(+), 16 deletions(-) diff --git a/docs/getting_started.md b/docs/getting_started.md index a43bae9f02..b5f76209fa 100644 --- a/docs/getting_started.md +++ b/docs/getting_started.md @@ -16,14 +16,14 @@ classical techniques for the following learning tasks: a discrete value is used to train a model to predict unseen cases [more details](./classification.ipynb). - {term}`regression`, where a collection of time series labelled with a continuous value is used to train a model to predict unseen cases [more details](./regression.ipynb). -- {term}`clustering`, where a collection of time series without any +- [clustering](#clustering), where a collection of time series without any labels are used to train a model to label cases [more details](./clustering.ipynb). - {term}`similarity search` where the goal is to evaluate the similarity between a time series against a collection of other time series [more details](./similarity_search.ipynb). - [anomaly detection](#Anomaly Detection) where the goal is to find values or areas of a single time series that are not representative of the whole series. More details to follow. -- {term}`segmentation` where the goal is to split a single time series into +- [segmentation](#Segmentation) where the goal is to split a single time series into regions where the series are sofind areas of a time series that are not representative of the whole series [more details](./segmentation.ipynb). - {term}`forecasting` where the goal is to predict future values for a time @@ -32,17 +32,19 @@ between a time series against a collection of other time series [more details](. `aeon` also provides core modules that are used by the specific task modules above - -- {term}`transformation`, where a either a single series or collection is transformed +- [transformation](#Transformation), where a either a single series or collection is + transformed into a different representation or domain. More details coming soon. -- {term}`distances`, measure the dissimilarity between two time series or +- [distances](#Distances), measure the dissimilarity between two time series or collections of series, which includes functions to align series [more details](./distances.ipynb). -- {term}`networks`, provides core models for deep learning for all time series tasks. +- [networks](), provides core models for deep learning for all time series tasks. - There are dedicated notebooks going into more detail for each of these modules -(linked above). This guid is meant to give you the briefest of +(linked above). This guide is meant to give you the briefest of introductions to the main concepts and -code to get started. For more information on the variety of -estimators available for each task, see the [API](api_reference) and [examples](https://www.aeon-toolkit.org/en/latest/examples.html) +code for each task to get started. For more information on the variety of +estimators available for each task, see the links above, the [API](api_reference) and +[examples](https://www.aeon-toolkit.org/en/latest/examples.html) pages. ## A Single Time Series @@ -103,19 +105,31 @@ take two series as arguments. ### Anomaly Detection +Time series anomaly detection (TSAD) is .... -Anomaly detection is +### Segmentation -### Time Series Segmentation (TSS) +Time series segmentation (TSS) is the process of dividing a time series into +segments or +regions. -Segmentation is the process of dividing a time series into segments or regions. +### Forecasting -### Time Series Forecasting (TSF) +A new module for time series forecasting (TSF) is coming soon, we are relaunching our +forecasting module. -Coming soon, we are relaunching our forecasting module. - -### Time Series Distances +### Distances +Distances between time series is a primitive operation in very many time series +tasks. We have an extensive set of distance functions in the `aeon.distances` module, +all optimised using numba. They all work with multivariate and unequal length series. +```{code-block} python +>>> from aeon.datasets import load_japanese_vowels +>>> from aeon.distances import dtw_distance +>>> data = load_japanese_vowels() # load an example multivariate series +>>> d = dtw_distance(data[0], data[1]) # calculate the dtw distance between the +first two series +``` ### Transformers for Single Time Series diff --git a/docs/glossary.md b/docs/glossary.md index f660adadaf..048350c354 100644 --- a/docs/glossary.md +++ b/docs/glossary.md @@ -50,7 +50,7 @@ Time series machine learning from {term}`time series` data. `aeon` is a library for time series machine learning algorithms. -Forecasting +Time series forecasting A {term}`Time series machine learning` task focused on prediction future values of a {term}`time series`. From acf1ca2491852a82313434a01118a5fd09679273 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Tue, 29 Oct 2024 14:01:29 +0000 Subject: [PATCH 12/26] getting started segmentation --- docs/getting_started.md | 21 ++++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) diff --git a/docs/getting_started.md b/docs/getting_started.md index b5f76209fa..1ab7cdfe48 100644 --- a/docs/getting_started.md +++ b/docs/getting_started.md @@ -109,9 +109,24 @@ Time series anomaly detection (TSAD) is .... ### Segmentation -Time series segmentation (TSS) is the process of dividing a time series into -segments or -regions. +Time series {term}`segmentation` (TSS) is the process of dividing a time series into +segments or regions that are dissimilar to each other. This could, for +example, be the problem of splitting the motion trace from a smartwatch into +different activities such as walking, running, and sitting. It is closely related to +the field of change point detection, which is a term used more in the statistics +literature. Full information is available in the [segmentation notebooks](Segmentation.ipynb). + +The `aeon` +```{code-block} python +>>> from aeon.datasets import load_airline +>>> from aeon.segmentation import ClaSPSegmenter +>>> series = load_airline() +>>> clasp = ClaSPSegmenter() # An example segmenter +>>> clasp.fit(data) # fit the segmenter on the data +>>> clasp.fit_predict(ts) +[51] +``` + ### Forecasting From 5fd7146e7725245d7ff393bc70ebf84980583f07 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Tue, 29 Oct 2024 14:12:56 +0000 Subject: [PATCH 13/26] format links --- docs/getting_started.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/docs/getting_started.md b/docs/getting_started.md index 1ab7cdfe48..4ab754db2f 100644 --- a/docs/getting_started.md +++ b/docs/getting_started.md @@ -12,11 +12,11 @@ package. If you want help with scikit-learn you may want to view the very latest algorithms for time series machine learning, in addition to a range of classical techniques for the following learning tasks: -- [classification](#classification), where a collection of time series labelled with - a discrete value is used to train a model to predict unseen cases [more details](./classification.ipynb). -- {term}`regression`, where a collection of time series labelled with - a continuous value is used to train a model to predict unseen cases [more details](./regression.ipynb). -- [clustering](#clustering), where a collection of time series without any +- Classification, where a collection of time series labelled with + a discrete value is used to train a model to predict unseen cases [more details](examples/classification/classification.ipynb). +- Regression, where a collection of time series labelled with + a continuous value is used to train a model to predict unseen cases [more details](https://www.aeon-toolkit.org/en/latest/examples/regression/regression.html). +- Clustering, where a collection of time series without any labels are used to train a model to label cases [more details](./clustering.ipynb). - {term}`similarity search` where the goal is to evaluate the similarity between a time series against a collection of other time series [more details](./similarity_search.ipynb). From 46b1a48e1898f65f6f5305b91457d96be20a1472 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Tue, 29 Oct 2024 15:26:42 +0000 Subject: [PATCH 14/26] format links --- docs/getting_started.md | 124 ++++++++++-------- .../similarity_search/similarity_search.ipynb | 7 +- 2 files changed, 77 insertions(+), 54 deletions(-) diff --git a/docs/getting_started.md b/docs/getting_started.md index 4ab754db2f..ec60044713 100644 --- a/docs/getting_started.md +++ b/docs/getting_started.md @@ -13,32 +13,32 @@ the very latest algorithms for time series machine learning, in addition to a ra classical techniques for the following learning tasks: - Classification, where a collection of time series labelled with - a discrete value is used to train a model to predict unseen cases [more details](examples/classification/classification.ipynb). + a discrete value is used to train a model to predict unseen cases ([more details](examples/classification/classification.ipynb)). - Regression, where a collection of time series labelled with - a continuous value is used to train a model to predict unseen cases [more details](https://www.aeon-toolkit.org/en/latest/examples/regression/regression.html). + a continuous value is used to train a model to predict unseen cases ([more details](examples/regression/regression.html)). - Clustering, where a collection of time series without any - labels are used to train a model to label cases [more details](./clustering.ipynb). -- {term}`similarity search` where the goal is to evaluate the similarity -between a time series against a collection of other time series [more details](./similarity_search.ipynb). -- [anomaly detection](#Anomaly Detection) where the goal is to find values or areas of a + labels are used to train a model to label cases ([more details](examples/clustering/clustering.ipynb)). +- Similarity search where the goal is to evaluate the similarity +between a time series against a collection of other time series ([more details](examples/similarity_search/similarity_search.ipynb)). +- anomaly detection where the goal is to find values or areas of a single time series that are not representative of the whole series. More details to follow. - [segmentation](#Segmentation) where the goal is to split a single time series into regions where the series are sofind areas of a time series that are not - representative of the whole series [more details](./segmentation.ipynb). -- {term}`forecasting` where the goal is to predict future values for a time + representative of the whole series ([more details](examples/segmentation/segmentation.ipynb)). +- forecasting, where the goal is to predict future values for a time series (coming soon!). `aeon` also provides core modules that are used by the specific task modules above - -- [transformation](#Transformation), where a either a single series or collection is +- [transformation](#Transformations), where a either a single series or collection is transformed into a different representation or domain. More details coming soon. - [distances](#Distances), measure the dissimilarity between two time series or - collections of series, which includes functions to align series [more details](./distances.ipynb). -- [networks](), provides core models for deep learning for all time series tasks. -- + collections of series, which includes functions to align series ([more details](examples/distances/distances.ipynb)). +- networks, provides core models for deep learning for all time series tasks. + There are dedicated notebooks going into more detail for each of these modules (linked above). This guide is meant to give you the briefest of introductions to the main concepts and @@ -103,13 +103,9 @@ in the `anomaly detection` and `segmentation` modules use single series input (they inherit from `BaseSeriesEstimator`). The functions in `distances` take two series as arguments. -### Anomaly Detection - -Time series anomaly detection (TSAD) is .... - ### Segmentation -Time series {term}`segmentation` (TSS) is the process of dividing a time series into +Time series segmentation (TSS) is the process of dividing a time series into segments or regions that are dissimilar to each other. This could, for example, be the problem of splitting the motion trace from a smartwatch into different activities such as walking, running, and sitting. It is closely related to @@ -127,12 +123,6 @@ The `aeon` [51] ``` - -### Forecasting - -A new module for time series forecasting (TSF) is coming soon, we are relaunching our -forecasting module. - ### Distances Distances between time series is a primitive operation in very many time series tasks. We have an extensive set of distance functions in the `aeon.distances` module, @@ -146,26 +136,16 @@ all optimised using numba. They all work with multivariate and unequal length se first two series ``` +### Anomaly Detection -### Transformers for Single Time Series +Anomaly detection (AD) is the process of identifying observations that are significantly +different from the rest of the data. -Transformers inheriting from the [BaseSeriesTransformer](transformations.base.BaseSeriesTransformer) -in the `aeon.transformations.series` package transform a single (possibly multivariate) -time series into a different time series or a feature vector. +### Forecasting -The following example shows how to use the -[AutoCorrelationSeriesTransformer](transformations.series.AutoCorrelationSeriesTransformer) -class to extract the autocorrelation terms of a time series. +A new module for time series forecasting (TSF) is coming soon, we are relaunching our +forecasting module. -```{code-block} python ->>> from aeon.transformations.series import AutoCorrelationSeriesTransformer ->>> from aeon.datasets import load_airline ->>> acf = AutoCorrelationSeriesTransformer() ->>> y = load_airline() # load single series airline dataset ->>> res = acf.fit_transform(y) ->>> res[0][:5] -[0.96019465 0.89567531 0.83739477 0.7977347 0.78594315] -``` ## Collections of Time Series @@ -216,11 +196,11 @@ may vary between cases. (12, 20) ``` -### Time Series Classification (TSC) -:term:`classification` +### Classification -Classification generally uses numpy arrays to store time series. We recommend storing -time series for classification in 3D numpy arrays of shape `(n_cases, n_channels, +Time Series Classification (TSC) generally uses numpy arrays to store time series. We +recommend storing time series for classification in 3D numpy arrays of shape ` +(n_cases, n_channels, n_timepoints)` even if each time series is univariate (i.e. `n_channels == 1`). Classifiers will work with 2D input of shape `(n_cases, n_timepoints)` as you would expect from `scikit-learn`, but other packages may treat 2D input as a single @@ -260,19 +240,19 @@ All `aeon` classifiers can be used with `scikit-learn` functionality for e.g. model evaluation, parameter searching and pipelines. Explore the wide range of algorithm types available in `aeon` in the [classification notebooks](examples.md#classification). -### Time Series Regression (TSR) +### Regression Time series regression assumes that the target variable is continuous rather than discrete, as for classification. The same input data considerations apply from the classification section, and the modules function similarly. The target variable should be a `numpy` array of type `float`. -"Time series regression" is a term commonly used in forecasting. To avoid confusion, -the term "time series extrinsic regression" is commonly used to refer to the traditional -machine learning regression task but for time series data. +TSR is a term commonly used in forecasting when used in conjunction with a sliding +window. However, the term also includes "time series extrinsic regression" where the +target variable is not future values but some external variable. In the following example we use a [KNeighborsTimeSeriesRegressor](regression.distance_based.KNeighborsTimeSeriesRegressor) -on an example time series extrinsic regression problem called [Covid3Month](https://zenodo.org/record/3902690). +on an example time series regression problem called [Covid3Month](https://zenodo.org/record/3902690). ```{code-block} python >>> from aeon.regression.distance_based import KNeighborsTimeSeriesRegressor @@ -290,9 +270,9 @@ KNeighborsTimeSeriesRegressor() 0.002921957478363366 ``` -### Time Series Clustering (TSCL) +### Clustering -Like classification and regression, time series clustering aims to follow the +Like classification and regression, time series clustering (TSCL) aims to follow the `scikit-learn` interface where possible. The same input data format is used as in the TSC and TSER modules. This example fits a [TimeSeriesKMeans](clustering._k_means.TimeSeriesKMeans) clusterer on the @@ -317,9 +297,49 @@ After calling `fit`, the `labels_` attribute contains the cluster labels for each time series. The `predict` method can be used to predict the cluster labels for new data. -### Time Series Similarity Search (TSSS) +### Similarity Search + +The goal of Time Series Similarity Search is to find the best matches between a +query time series and a database (collection) of time series which are usually +longer than the query. -Add simple use case for similarity search. + +```{code-block} python +>>> from aeon.datasets import load_arrow_head +>>> X, y = load_arrow_head(split="train") +>>> query = np.array([1,2,3,2,1,0]) +>>> kmeans.fit(X) # fit the clusterer +TimeSeriesKMeans(n_clusters=3) +>>> kmeans.labels_[0:10] # cluster labels +[2 1 1 0 1 1 0 1 1 0] +>>> rand_score(y, kmeans.labels_) +0.6377792823290453 +``` + +## Transformers + +We split transformers into two categories: those that transform single time series + and those that transform a collection. + +### Transformers for Single Time Series + +Transformers inheriting from the [BaseSeriesTransformer](transformations.base.BaseSeriesTransformer) +in the `aeon.transformations.series` package transform a single (possibly multivariate) +time series into a different time series or a feature vector. + +The following example shows how to use the +[AutoCorrelationSeriesTransformer](transformations.series.AutoCorrelationSeriesTransformer) +class to extract the autocorrelation terms of a time series. + +```{code-block} python +>>> from aeon.transformations.series import AutoCorrelationSeriesTransformer +>>> from aeon.datasets import load_airline +>>> acf = AutoCorrelationSeriesTransformer() +>>> y = load_airline() # load single series airline dataset +>>> res = acf.fit_transform(y) +>>> res[0][:5] +[0.96019465 0.89567531 0.83739477 0.7977347 0.78594315] +``` ### Transformers for Collections of Time Series diff --git a/examples/similarity_search/similarity_search.ipynb b/examples/similarity_search/similarity_search.ipynb index 2ad7fcc5b2..86132f3a51 100644 --- a/examples/similarity_search/similarity_search.ipynb +++ b/examples/similarity_search/similarity_search.ipynb @@ -5,9 +5,12 @@ "id": "5083d23c-e27f-4d14-a8d2-12e11a6aff42", "metadata": {}, "source": [ - "# Time Series Similarity search with aeon\n", + "# Time Series Similarity Search with aeon\n", "\n", - "The goal of Time Series Similarity search is to asses the similarities between a time series, denoted as a query `q` of length `l`, and a collection of time series, denoted as `X`, which lengths are superior or equal to `l`. In this context, the notion of similiarity between `q` and the other series in `X` is quantified by similarity functions. Those functions are most of the time defined as distance function, such as the Euclidean distance. Knowing the similarity between `q` and other admissible candidates, we can then perform many other tasks for \"free\", such as anomaly or motif detection.\n", + "The goal of Time Series Similarity Search is to asses the similarities between a time\n", + " series, denoted as a query `q` of length `l`, and a collection of time series,\n", + " denoted as `X`, with lengths greater than or equal to `l`. In this\n", + " context, the notion of similiarity between `q` and the other series in `X` is quantified by similarity functions. Those functions are most of the time defined as distance function, such as the Euclidean distance. Knowing the similarity between `q` and other admissible candidates, we can then perform many other tasks for \"free\", such as anomaly or motif detection.\n", "\n", "\"time" ] From d5c71d74797ee1518e5a81e13dd3b91f9cd25e88 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Tue, 29 Oct 2024 17:33:39 +0000 Subject: [PATCH 15/26] format links --- docs/getting_started.md | 84 ++++++++++++++++++++++++----------------- 1 file changed, 49 insertions(+), 35 deletions(-) diff --git a/docs/getting_started.md b/docs/getting_started.md index ec60044713..01503a265b 100644 --- a/docs/getting_started.md +++ b/docs/getting_started.md @@ -15,15 +15,15 @@ classical techniques for the following learning tasks: - Classification, where a collection of time series labelled with a discrete value is used to train a model to predict unseen cases ([more details](examples/classification/classification.ipynb)). - Regression, where a collection of time series labelled with - a continuous value is used to train a model to predict unseen cases ([more details](examples/regression/regression.html)). + a continuous value is used to train a model to predict unseen cases ([more details](examples/regression/regression.ipynb)). - Clustering, where a collection of time series without any labels are used to train a model to label cases ([more details](examples/clustering/clustering.ipynb)). - Similarity search where the goal is to evaluate the similarity -between a time series against a collection of other time series ([more details](examples/similarity_search/similarity_search.ipynb)). +between a query time series and a collection of other longer time series ([more details](examples/similarity_search/similarity_search.ipynb)). - anomaly detection where the goal is to find values or areas of a single time series that are not representative of the whole series. More details to follow. -- [segmentation](#Segmentation) where the goal is to split a single time series into +- Segmentation where the goal is to split a single time series into regions where the series are sofind areas of a time series that are not representative of the whole series ([more details](examples/segmentation/segmentation.ipynb)). - forecasting, where the goal is to predict future values for a time @@ -31,12 +31,12 @@ between a time series against a collection of other time series ([more details]( `aeon` also provides core modules that are used by the specific task modules above -- -- [transformation](#Transformations), where a either a single series or collection is + +- Transformations, where a either a single series or collection is transformed into a different representation or domain. More details coming soon. -- [distances](#Distances), measure the dissimilarity between two time series or - collections of series, which includes functions to align series ([more details](examples/distances/distances.ipynb)). +- Distances, which measure the dissimilarity between two time series or + collections of series and include functions to align series ([more details](examples/distances/distances.ipynb)). - networks, provides core models for deep learning for all time series tasks. There are dedicated notebooks going into more detail for each of these modules @@ -92,9 +92,9 @@ follows the shape `(n_channels, n_timepoints)` when stored in numpy arrays We commonly refer to the number of observations for a time series as `n_timepoints`. If a series is multivariate, we refer to the dimensions as channels (to avoid confusion with the dimensions of array) and in code use `n_channels`. So -the US Change data loaded above has five channels ( ) and 187 time points. For more +the US Change data loaded above has five channels and 187 time points. For more details on our provided datasets and on how to load data into aeon compatible data -structures, see our [datasets](./datasets.ipynb) notebooks. +structures, see our [datasets](examples/datasets/datasets.ipynb) notebooks. ## Single series estimators @@ -172,10 +172,27 @@ learning. We use the terms case and instance interchangably when referring to a single time series contained in a collection. The size of a collection of time series is referred to as -`n_cases`. Collections of time typically follows the shape ` -(n_cases, n_channels, n_timepoints)` if the series are equal length. , but -`n_timepoints` -may vary between cases. +`n_cases` in code. Collections have the shape ` +(n_cases, n_channels, n_timepoints)` if the series are equal length. We +recommend storing collections in 3D numpy arrays of shape ` +(n_cases, n_channels, n_timepoints)` even if each time series is univariate (i.e. +`n_channels == 1`). Collection estimators will work with 2D input of shape `(n_cases, +n_timepoints)` as you would +expect from `scikit-learn`, but it is possible to confuse a collection of +univariate series of shape `(n_cases, n_timepoints)` with a single multivariate +series of shape `(n_channels, n_timepoints)`. This potential confusion is one reason +we make the distinction between series and collection estimators. + +If `n_timepoints` varies between cases, we store a collection in a `list` of 2D numpy +arrays, each with the same number of channels. We do not have the capability to use +collections of time series with varying numbers of channels. We also assume series +length is always the same for all channels of a single series. + +Collection estimators closely follow the `scikit-learn` estimator interface, using +`fit`, `predict`, `transform`, `predict_proba`, `fit_predict` and `fit_transform` +where appropriate. They are also designed to work directly with `scikit-learn` +functionality for e.g. model evaluation, parameter searching and pipelines where +appropriate. ```{code-block} python >>>from aeon.datasets import load_basic_motions, load_plaid, load_japanese_vowels @@ -198,23 +215,17 @@ may vary between cases. ### Classification -Time Series Classification (TSC) generally uses numpy arrays to store time series. We -recommend storing time series for classification in 3D numpy arrays of shape ` -(n_cases, n_channels, -n_timepoints)` even if each time series is univariate (i.e. `n_channels == 1`). -Classifiers will work with 2D input of shape `(n_cases, n_timepoints)` as you would -expect from `scikit-learn`, but other packages may treat 2D input as a single -multivariate series. This is the case for non-collection transformers, and you may -find unexpected outputs if you input a 2D array treating it as multiple time series. - -Note we assume series length is always the same for all channels of a single series -regardless of input type. The target variable should be a `numpy` array of type `float`, -`int` or `str`. +Time series classification (TSC) involves training a model on a labelled collection +of time series. The labels, referred to as `y` in code, should be a `numpy` array of +type `float`, `int` or `str`. Internally the labels are converted to `int` for use +in a training algorithm. The classification estimator interface should be familiar if you have worked with `scikit-learn`. In this example we fit a [KNeighborsTimeSeriesClassifier](classification.distance_based.KNeighborsTimeSeriesClassifier) with dynamic time warping (dtw) on our example data. + + ```{code-block} python >>> import numpy as np >>> from aeon.classification.distance_based import KNeighborsTimeSeriesClassifier @@ -234,16 +245,15 @@ KNeighborsTimeSeriesClassifier() Once the classifier has been fit using the training data and class labels, we can predict the labels for new cases. Like `scikit-learn`, `predict_proba` methods are available to predict class probabilities and a `score` method is present to -calculate accuracy on new data. - -All `aeon` classifiers can be used with `scikit-learn` functionality for e.g. -model evaluation, parameter searching and pipelines. Explore the wide range of -algorithm types available in `aeon` in the [classification notebooks](examples.md#classification). +calculate accuracy on new data. Explore the wide range of +algorithms available in `aeon`, including the very latest state-of-the-art, in the +[classification notebooks](examples.md#classification). ### Regression -Time series regression assumes that the target variable is continuous rather -than discrete, as for classification. The same input data considerations apply from the +Time series regression assumes that the target variable is not a discrete label as +with classification, but is instead a continuous variable, or target variable. The +same input data considerations apply from the classification section, and the modules function similarly. The target variable should be a `numpy` array of type `float`. @@ -253,6 +263,9 @@ target variable is not future values but some external variable. In the following example we use a [KNeighborsTimeSeriesRegressor](regression.distance_based.KNeighborsTimeSeriesRegressor) on an example time series regression problem called [Covid3Month](https://zenodo.org/record/3902690). +More info in our [regression notebook](examples/regression/regression.ipynb)). + + ```{code-block} python >>> from aeon.regression.distance_based import KNeighborsTimeSeriesRegressor @@ -295,13 +308,14 @@ TimeSeriesKMeans(n_clusters=3) After calling `fit`, the `labels_` attribute contains the cluster labels for each time series. The `predict` method can be used to predict the cluster labels for -new data. +new data. See our clustering notebook for [more details](examples/clustering/clustering.ipynb) + ### Similarity Search -The goal of Time Series Similarity Search is to find the best matches between a +The goal of time series similarity search is to find the best matches between a query time series and a database (collection) of time series which are usually -longer than the query. +longer than the query. [more details](examples/similarity_search/similarity_search.ipynb) ```{code-block} python From 2132a804a60b87f981b91a42a3f67b9338c45e3a Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Tue, 29 Oct 2024 18:11:32 +0000 Subject: [PATCH 16/26] anom detection --- docs/getting_started.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/getting_started.md b/docs/getting_started.md index 01503a265b..fd87208385 100644 --- a/docs/getting_started.md +++ b/docs/getting_started.md @@ -139,7 +139,8 @@ first two series ### Anomaly Detection Anomaly detection (AD) is the process of identifying observations that are significantly -different from the rest of the data. +different from the rest of the data. More details to follow soon, once we have +written the notebook. ### Forecasting From 0392d073d092b312974f98cfc1b9431e16067d42 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Wed, 30 Oct 2024 08:40:17 +0000 Subject: [PATCH 17/26] getting started --- docs/getting_started.md | 37 +++++++++++++++++++++++-------------- 1 file changed, 23 insertions(+), 14 deletions(-) diff --git a/docs/getting_started.md b/docs/getting_started.md index fd87208385..3d6d8d9b3b 100644 --- a/docs/getting_started.md +++ b/docs/getting_started.md @@ -20,24 +20,24 @@ classical techniques for the following learning tasks: labels are used to train a model to label cases ([more details](examples/clustering/clustering.ipynb)). - Similarity search where the goal is to evaluate the similarity between a query time series and a collection of other longer time series ([more details](examples/similarity_search/similarity_search.ipynb)). -- anomaly detection where the goal is to find values or areas of a +- Anomaly detection where the goal is to find values or areas of a single time series that are not representative of the whole series. More details - to follow. + coming soon. - Segmentation where the goal is to split a single time series into regions where the series are sofind areas of a time series that are not representative of the whole series ([more details](examples/segmentation/segmentation.ipynb)). -- forecasting, where the goal is to predict future values for a time - series (coming soon!). +- Forecasting, where the goal is to predict future values for a time + series (new module coming soon). -`aeon` also provides core modules that are used by the specific task modules -above +`aeon` also provides core modules that are used by the modules above: - Transformations, where a either a single series or collection is transformed into a different representation or domain. More details coming soon. - Distances, which measure the dissimilarity between two time series or collections of series and include functions to align series ([more details](examples/distances/distances.ipynb)). -- networks, provides core models for deep learning for all time series tasks. +- Networks, provides core models for deep learning for all time series tasks ([more + details](examples/networks/deep_learning.ipynb)). There are dedicated notebooks going into more detail for each of these modules (linked above). This guide is meant to give you the briefest of @@ -53,7 +53,7 @@ A time series is a series of real valued data assumed to be ordered. A univariat time series has a single value at each time point. For example, the heartbeat ECG reading from a single sensor or the number of passengers using an airline per month would form a univariate series. Single time series are stored -by default in a numpy array (algorithms use arrays internally whenever possible). +by default in a numpy array (algorithms use numpy arrays internally whenever possible). We can also handle `pd.Series` and `pd.DataFrame` objects, but these are simply converted to `np.ndarray` internally. The airline series is a classic example of a univariate series from the forecasting domain. The series is the monthly totals of @@ -132,8 +132,7 @@ all optimised using numba. They all work with multivariate and unequal length se >>> from aeon.datasets import load_japanese_vowels >>> from aeon.distances import dtw_distance >>> data = load_japanese_vowels() # load an example multivariate series ->>> d = dtw_distance(data[0], data[1]) # calculate the dtw distance between the -first two series +>>> d = dtw_distance(data[0], data[1]) # calculate the dtw distance ``` ### Anomaly Detection @@ -142,6 +141,16 @@ Anomaly detection (AD) is the process of identifying observations that are signi different from the rest of the data. More details to follow soon, once we have written the notebook. +```{code-block} python +>>> from aeon.datasets import load_airline +>>> from aeon.anomaly_detection import STOMP +>>> stomp = STOMP(window_size=200) +>>> scores = est.fit_predict(X) # Get the anomaly scores +``` + + + + ### Forecasting A new module for time series forecasting (TSF) is coming soon, we are relaunching our @@ -152,7 +161,7 @@ forecasting module. The estimators in the `classification`, `regression` and `clustering` modules learn from collections of time -series (they inherit from the class `BaseSeriesEstimator`). Collections of +series (they inherit from the class `BaseCollectionEstimator`). Collections of time series will often be accompanied by an array of target variables for supervised learning. @@ -309,14 +318,14 @@ TimeSeriesKMeans(n_clusters=3) After calling `fit`, the `labels_` attribute contains the cluster labels for each time series. The `predict` method can be used to predict the cluster labels for -new data. See our clustering notebook for [more details](examples/clustering/clustering.ipynb) +new data. See our clustering notebook for [more details](examples/clustering/clustering.ipynb). ### Similarity Search The goal of time series similarity search is to find the best matches between a query time series and a database (collection) of time series which are usually -longer than the query. [more details](examples/similarity_search/similarity_search.ipynb) +longer than the query. See our notebook for [more details](examples/similarity_search/similarity_search.ipynb) ```{code-block} python @@ -340,7 +349,7 @@ We split transformers into two categories: those that transform single time seri Transformers inheriting from the [BaseSeriesTransformer](transformations.base.BaseSeriesTransformer) in the `aeon.transformations.series` package transform a single (possibly multivariate) -time series into a different time series or a feature vector. +time series into a different time series or a feature vector. More info to follow. The following example shows how to use the [AutoCorrelationSeriesTransformer](transformations.series.AutoCorrelationSeriesTransformer) From 8a1fccc258e548165912372f065da4575323c11e Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Wed, 30 Oct 2024 12:50:56 +0000 Subject: [PATCH 18/26] getting started --- docs/getting_started.md | 84 +++++++++++++---------------------------- 1 file changed, 26 insertions(+), 58 deletions(-) diff --git a/docs/getting_started.md b/docs/getting_started.md index 3d6d8d9b3b..171fc039c7 100644 --- a/docs/getting_started.md +++ b/docs/getting_started.md @@ -184,8 +184,7 @@ We use the terms case and instance interchangably when referring to a single tim contained in a collection. The size of a collection of time series is referred to as `n_cases` in code. Collections have the shape ` (n_cases, n_channels, n_timepoints)` if the series are equal length. We -recommend storing collections in 3D numpy arrays of shape ` -(n_cases, n_channels, n_timepoints)` even if each time series is univariate (i.e. +recommend storing collections in 3D numpy arrays even if each time series is univariate (i.e. `n_channels == 1`). Collection estimators will work with 2D input of shape `(n_cases, n_timepoints)` as you would expect from `scikit-learn`, but it is possible to confuse a collection of @@ -267,7 +266,8 @@ same input data considerations apply from the classification section, and the modules function similarly. The target variable should be a `numpy` array of type `float`. -TSR is a term commonly used in forecasting when used in conjunction with a sliding +Time series regression is a term commonly used in forecasting when used in +conjunction with a sliding window. However, the term also includes "time series extrinsic regression" where the target variable is not future values but some external variable. @@ -326,20 +326,33 @@ new data. See our clustering notebook for [more details](examples/clustering/clu The goal of time series similarity search is to find the best matches between a query time series and a database (collection) of time series which are usually longer than the query. See our notebook for [more details](examples/similarity_search/similarity_search.ipynb) - + The following example shows how to use +the [TopKSimilaritySearch](similarity_search.top_k_similarity.TopKSimilaritySearch) +class to extract the best `k` matches, using the Euclidean distance as similarity +function. ```{code-block} python ->>> from aeon.datasets import load_arrow_head ->>> X, y = load_arrow_head(split="train") ->>> query = np.array([1,2,3,2,1,0]) ->>> kmeans.fit(X) # fit the clusterer -TimeSeriesKMeans(n_clusters=3) ->>> kmeans.labels_[0:10] # cluster labels -[2 1 1 0 1 1 0 1 1 0] ->>> rand_score(y, kmeans.labels_) -0.6377792823290453 +>>> import numpy as np +>>> from aeon.similarity_search import TopKSimilaritySearch +>>> X = [[[1, 2, 3, 4, 5, 6, 7]], # 3D array example (univariate) +... [[4, 4, 4, 5, 6, 7, 3]]] # Two samples, one channel, seven series length +>>> X = np.array(X) # X is of shape (2, 1, 7) : (n_cases, n_channels, n_timepoints) +>>> topk = TopKSimilaritySearch(distance="euclidean",k=2) +>>> topk.fit(X) # fit the estimator on train data +... +>>> q = np.array([[4, 5, 6]]) # q is of shape (1,3) : +>>> topk.predict(q) # Identify the two (k=2) most similar subsequences of length 3 in X +[(0, 3), (1, 2)] ``` +The output of predict gives a list of size `k`, where each element is a set indicating +the location of the best matches in X as `(id_sample, id_timestamp)`. This is equivalent +to the subsequence `X[id_sample, :, id_timestamps:id_timestamp + q.shape[0]]`. + +Note that you can still use univariate time series as inputs, you will just have to +convert them to multivariate time series with one feature prior to using the similarity +search module. + ## Transformers We split transformers into two categories: those that transform single time series @@ -486,48 +499,3 @@ the available `scikit-learn` functionality. >>> gscv.best_params_ {'distance': 'euclidean', 'n_neighbors': 5} ``` - -## Time series similarity search - -The similarity search module in `aeon` offers a set of functions and estimators to solve -tasks related to time series similarity search. The estimators can be used standalone -or as parts of pipelines, while the functions give you the tools to build your own -estimators that would rely on similarity search at some point. - -The estimators are inheriting from the [BaseSimiliaritySearch](similarity_search.base.BaseSimiliaritySearch) -class accepts as inputs 3D time series (n_cases, n_channels, n_timepoints) for the -fit method. Univariate and single series can still be used, but will need to be reshaped -to this format. - -This collection, asked for the fit method, is stored as a database. It will be used in -the predict method, which expects a single 2D time series as input -(n_channels, query_length), which will be used as a query to search for in the database. -Note that the length of the time series in the 3D collection should be superior or -equal to the length of the 2D time series given in the predict method. - -Given those two inputs, the predict method should return the set of most similar -candidates to the 2D series in the 3D collection. The following example shows how to use -the [TopKSimilaritySearch](similarity_search.top_k_similarity.TopKSimilaritySearch) -class to extract the best `k` matches, using the Euclidean distance as similarity -function. - -```{code-block} python ->>> import numpy as np ->>> from aeon.similarity_search import TopKSimilaritySearch ->>> X = [[[1, 2, 3, 4, 5, 6, 7]], # 3D array example (univariate) -... [[4, 4, 4, 5, 6, 7, 3]]] # Two samples, one channel, seven series length ->>> X = np.array(X) # X is of shape (2, 1, 7) : (n_cases, n_channels, n_timepoints) ->>> topk = TopKSimilaritySearch(distance="euclidean",k=2) ->>> topk.fit(X) # fit the estimator on train data -... ->>> q = np.array([[4, 5, 6]]) # q is of shape (1,3) : ->>> topk.predict(q) # Identify the two (k=2) most similar subsequences of length 3 in X -[(0, 3), (1, 2)] -``` -The output of predict gives a list of size `k`, where each element is a set indicating -the location of the best matches in X as `(id_sample, id_timestamp)`. This is equivalent -to the subsequence `X[id_sample, :, id_timestamps:id_timestamp + q.shape[0]]`. - -Note that you can still use univariate time series as inputs, you will just have to -convert them to multivariate time series with one feature prior to using the similarity -search module. From ebe58ccd3f586ef8ee8deafc5462d6efca18f849 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Wed, 30 Oct 2024 12:59:21 +0000 Subject: [PATCH 19/26] getting started --- aeon/datasets/_single_problem_loaders.py | 18 ++++++++---------- .../tests/test_single_problem_loaders.py | 15 ++------------- 2 files changed, 10 insertions(+), 23 deletions(-) diff --git a/aeon/datasets/_single_problem_loaders.py b/aeon/datasets/_single_problem_loaders.py index 7dc1f89bf0..1becf5ede8 100644 --- a/aeon/datasets/_single_problem_loaders.py +++ b/aeon/datasets/_single_problem_loaders.py @@ -899,13 +899,12 @@ def load_uschange(return_array=True): Parameters ---------- return_array : bool, default=True - return series as an np.ndarray if True, else as a pd.DataFrame. + return series as an np.ndarray if True, else as a pd.DataFrame in wide format. Returns ------- np.ndarray or pd.DataFrame - US Change dataset. If an np.ndarray is returned the data is in shape (5, - 187). If a pd.DataFrame is returned the data is in shape (187, 5). + US Change dataset, shape (5,187). Examples -------- @@ -915,7 +914,7 @@ def load_uschange(return_array=True): (5, 187) >>> data = load_uschange(return_array=False) >>> data.shape - (187, 5) + (5, 187) References ---------- @@ -932,7 +931,7 @@ def load_uschange(return_array=True): data = data.drop("Quarter", axis=1) if return_array: return data.to_numpy().T - return data + return data.T def load_longley(return_array=True): @@ -958,13 +957,12 @@ def load_longley(return_array=True): Parameters ---------- return_array : bool, default=True - return series as an np.ndarray if True, else as a pd.DataFrame. + return series as an np.ndarray if True, else as a pd.DataFrame in wide format. Returns ------- np.ndarray or pd.DataFrame - US Change dataset. If an np.ndarray is returned the data is in shape (6, - 16). If a pd.DataFrame is returned the data is in shape (16, 6). + US Change dataset, shape (6, 16). Examples -------- @@ -974,7 +972,7 @@ def load_longley(return_array=True): (6, 16) >>> data = load_longley(return_array=False) >>> data.shape - (16, 6) + (6, 16) References ---------- @@ -992,4 +990,4 @@ def load_longley(return_array=True): data = data.astype(float) if return_array: return data.to_numpy().T - return data + return data.T diff --git a/aeon/datasets/tests/test_single_problem_loaders.py b/aeon/datasets/tests/test_single_problem_loaders.py index 5a3b139445..6f895afeca 100644 --- a/aeon/datasets/tests/test_single_problem_loaders.py +++ b/aeon/datasets/tests/test_single_problem_loaders.py @@ -138,13 +138,7 @@ def test_uschange(): assert data.shape == (5, 187) X = load_uschange(return_array=False) assert isinstance(X, pd.DataFrame) - col_names = ["Consumption", "Income", "Production", "Savings", "Unemployment"] - - assert X.columns.values.tolist() == col_names - for col in col_names: - assert X[col].dtype == "float64" - assert X.shape[0] == data.shape[1] - assert X.shape[1] == data.shape[0] + assert X.shape == data.shape def test_longley(): @@ -155,9 +149,4 @@ def test_longley(): X = load_longley(return_array=False) assert isinstance(X, pd.DataFrame) - col_names = ["TOTEMP", "GNPDEFL", "GNP", "UNEMP", "ARMED", "POP"] - assert X.columns.values.tolist() == col_names - for col in col_names: - assert X[col].dtype == "float64" - assert X.shape[0] == data.shape[1] - assert X.shape[1] == data.shape[0] + assert X.shape == data.shape From 895daad35632646889184a0e7c786978fa5a293b Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Wed, 30 Oct 2024 14:50:30 +0000 Subject: [PATCH 20/26] notebook --- aeon/datasets/_single_problem_loaders.py | 2 +- examples/datasets/provided_data.ipynb | 242 +++++++++++++---------- 2 files changed, 140 insertions(+), 104 deletions(-) diff --git a/aeon/datasets/_single_problem_loaders.py b/aeon/datasets/_single_problem_loaders.py index 1becf5ede8..b073823df9 100644 --- a/aeon/datasets/_single_problem_loaders.py +++ b/aeon/datasets/_single_problem_loaders.py @@ -891,7 +891,7 @@ def load_uschange(return_array=True): This data shows an increasing trend, non-constant (increasing) variance and periodic, seasonal patterns. - Channels/Columns: ['Consumption', 'Income', 'Production', + Channels: ['Consumption', 'Income', 'Production', 'Savings', 'Unemployment'] Series length: 187 Frequency: Quarterly diff --git a/examples/datasets/provided_data.ipynb b/examples/datasets/provided_data.ipynb index d852d8e85f..00589b950f 100644 --- a/examples/datasets/provided_data.ipynb +++ b/examples/datasets/provided_data.ipynb @@ -100,7 +100,7 @@ "data": { "text/plain": "Text(0.5, 1.0, 'First 100 observations of the first train case of the ACFS1 data, class: (9)')" }, - "execution_count": 1, + "execution_count": 53, "metadata": {}, "output_type": "execute_result" }, @@ -113,7 +113,7 @@ "output_type": "display_data" } ], - "execution_count": 1 + "execution_count": 53 }, { "cell_type": "markdown", @@ -166,9 +166,9 @@ }, { "data": { - "text/plain": "[]" + "text/plain": "[]" }, - "execution_count": 2, + "execution_count": 54, "metadata": {}, "output_type": "execute_result" }, @@ -181,7 +181,7 @@ "output_type": "display_data" } ], - "execution_count": 2 + "execution_count": 54 }, { "cell_type": "markdown", @@ -220,9 +220,9 @@ "outputs": [ { "data": { - "text/plain": "[]" + "text/plain": "[]" }, - "execution_count": 3, + "execution_count": 55, "metadata": {}, "output_type": "execute_result" }, @@ -235,7 +235,7 @@ "output_type": "display_data" } ], - "execution_count": 3 + "execution_count": 55 }, { "cell_type": "markdown", @@ -279,9 +279,9 @@ "outputs": [ { "data": { - "text/plain": "[]" + "text/plain": "[]" }, - "execution_count": 4, + "execution_count": 56, "metadata": {}, "output_type": "execute_result" }, @@ -294,7 +294,7 @@ "output_type": "display_data" } ], - "execution_count": 4 + "execution_count": 56 }, { "cell_type": "markdown", @@ -334,9 +334,9 @@ "outputs": [ { "data": { - "text/plain": "[]" + "text/plain": "[]" }, - "execution_count": 5, + "execution_count": 57, "metadata": {}, "output_type": "execute_result" }, @@ -349,7 +349,7 @@ "output_type": "display_data" } ], - "execution_count": 5 + "execution_count": 57 }, { "cell_type": "markdown", @@ -410,9 +410,9 @@ }, { "data": { - "text/plain": "[]" + "text/plain": "[]" }, - "execution_count": 6, + "execution_count": 58, "metadata": {}, "output_type": "execute_result" }, @@ -425,7 +425,7 @@ "output_type": "display_data" } ], - "execution_count": 6 + "execution_count": 58 }, { "cell_type": "markdown", @@ -467,9 +467,9 @@ "outputs": [ { "data": { - "text/plain": "[]" + "text/plain": "[]" }, - "execution_count": 7, + "execution_count": 59, "metadata": {}, "output_type": "execute_result" }, @@ -482,7 +482,7 @@ "output_type": "display_data" } ], - "execution_count": 7 + "execution_count": 59 }, { "cell_type": "markdown", @@ -539,9 +539,9 @@ }, { "data": { - "text/plain": "[]" + "text/plain": "[]" }, - "execution_count": 8, + "execution_count": 60, "metadata": {}, "output_type": "execute_result" }, @@ -554,7 +554,7 @@ "output_type": "display_data" } ], - "execution_count": 8 + "execution_count": 60 }, { "cell_type": "markdown", @@ -609,9 +609,9 @@ }, { "data": { - "text/plain": "[]" + "text/plain": "[]" }, - "execution_count": 9, + "execution_count": 61, "metadata": {}, "output_type": "execute_result" }, @@ -624,7 +624,7 @@ "output_type": "display_data" } ], - "execution_count": 9 + "execution_count": 61 }, { "cell_type": "markdown", @@ -670,9 +670,9 @@ }, { "data": { - "text/plain": "[]" + "text/plain": "[]" }, - "execution_count": 10, + "execution_count": 62, "metadata": {}, "output_type": "execute_result" }, @@ -685,7 +685,7 @@ "output_type": "display_data" } ], - "execution_count": 10 + "execution_count": 62 }, { "cell_type": "markdown", @@ -718,12 +718,12 @@ "cell_type": "code", "source": [ "from aeon.datasets import load_electric_devices_segmentation\n", - "from aeon.visualisation import plot_series\n", "\n", "data, period, change_points = load_electric_devices_segmentation()\n", "print(\" Period = \", period)\n", "print(\" Change points = \", change_points)\n", - "plot_series(data)" + "plt.title(\"Electric Devices Segmentation\")\n", + "plt.plot(data)" ], "metadata": { "collapsed": false, @@ -743,22 +743,22 @@ }, { "data": { - "text/plain": "(
, )" + "text/plain": "[]" }, - "execution_count": 25, + "execution_count": 63, "metadata": {}, "output_type": "execute_result" }, { "data": { - "text/plain": "
", - "image/png": "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" + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" } ], - "execution_count": 25 + "execution_count": 63 }, { "cell_type": "markdown", @@ -784,7 +784,8 @@ "data, period, change_points = load_gun_point_segmentation()\n", "print(\" Period = \", period)\n", "print(\" Change points = \", change_points)\n", - "plot_series(data)" + "plt.title(\"Gunpoint Segmentation\")\n", + "plt.plot(data)" ], "metadata": { "collapsed": false, @@ -803,18 +804,23 @@ ] }, { - "ename": "NameError", - "evalue": "name 'plot_series' is not defined", - "output_type": "error", - "traceback": [ - "\u001B[1;31m---------------------------------------------------------------------------\u001B[0m", - "\u001B[1;31mNameError\u001B[0m Traceback (most recent call last)", - "Cell \u001B[1;32mIn[12], line 6\u001B[0m\n\u001B[0;32m 4\u001B[0m \u001B[38;5;28mprint\u001B[39m(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m Period = \u001B[39m\u001B[38;5;124m\"\u001B[39m, period)\n\u001B[0;32m 5\u001B[0m \u001B[38;5;28mprint\u001B[39m(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m Change points = \u001B[39m\u001B[38;5;124m\"\u001B[39m, change_points)\n\u001B[1;32m----> 6\u001B[0m \u001B[43mplot_series\u001B[49m(data)\n", - "\u001B[1;31mNameError\u001B[0m: name 'plot_series' is not defined" - ] + "data": { + "text/plain": "[]" + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" } ], - "execution_count": 12 + "execution_count": 64 }, { "cell_type": "markdown", @@ -879,20 +885,20 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 65, "outputs": [ { "data": { - "text/plain": "(
,\n )" + "text/plain": "[]" }, - "execution_count": 14, + "execution_count": 65, "metadata": {}, "output_type": "execute_result" }, { "data": { - "text/plain": "
", - "image/png": "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" + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -906,8 +912,10 @@ "\n", "warnings.filterwarnings(\"ignore\")\n", "\n", - "airline = load_airline(return_array=False)\n", - "plot_series(airline)" + "airline = load_airline()\n", + "# plot_series(airline)\n", + "plt.title(\"Airline data\")\n", + "plt.plot(airline)" ], "metadata": { "collapsed": false @@ -934,20 +942,27 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 66, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(6, 16)\n" + ] + }, { "data": { - "text/plain": "(
, )" + "text/plain": "[]" }, - "execution_count": 21, + "execution_count": 66, "metadata": {}, "output_type": "execute_result" }, { "data": { - "text/plain": "
", - "image/png": "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" + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -956,8 +971,10 @@ "source": [ "from aeon.datasets import load_longley\n", "\n", - "longley = load_longley(return_array=False)\n", - "plot_series(longley[\"TOTEMP\"])" + "longley = load_longley()\n", + "print(longley.shape)\n", + "plt.title(\"Total employment\")\n", + "plt.plot(longley[0])" ], "metadata": { "collapsed": false @@ -977,20 +994,20 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 67, "outputs": [ { "data": { - "text/plain": "(
, )" + "text/plain": "[]" }, - "execution_count": 22, + "execution_count": 67, "metadata": {}, "output_type": "execute_result" }, { "data": { - "text/plain": "
", - "image/png": "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" + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -999,8 +1016,9 @@ "source": [ "from aeon.datasets import load_lynx\n", "\n", - "lynx = load_lynx(return_array=False)\n", - "plot_series(lynx)" + "lynx = load_lynx()\n", + "plt.title(\"Lynx numbers\")\n", + "plt.plot(lynx)" ], "metadata": { "collapsed": false @@ -1022,20 +1040,20 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 68, "outputs": [ { "data": { - "text/plain": "(
, )" + "text/plain": "[]" }, - "execution_count": 23, + "execution_count": 68, "metadata": {}, "output_type": "execute_result" }, { "data": { - "text/plain": "
", - "image/png": "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" + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -1044,8 +1062,9 @@ "source": [ "from aeon.datasets import load_PBS_dataset\n", "\n", - "pbs = load_PBS_dataset(return_array=False)\n", - "plot_series(pbs)" + "pbs = load_PBS_dataset()\n", + "plt.title(\"PBS\")\n", + "plt.plot(pbs)" ], "metadata": { "collapsed": false @@ -1065,20 +1084,20 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 69, "outputs": [ { "data": { - "text/plain": "(
, )" + "text/plain": "[]" }, - "execution_count": 24, + "execution_count": 69, "metadata": {}, "output_type": "execute_result" }, { "data": { - "text/plain": "
", - "image/png": "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" + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -1087,8 +1106,9 @@ "source": [ "from aeon.datasets import load_shampoo_sales\n", "\n", - "shampoo = load_shampoo_sales(return_array=False)\n", - "plot_series(shampoo)" + "shampoo = load_shampoo_sales()\n", + "plt.title(\"Shampoo sales\")\n", + "plt.plot(shampoo)" ], "metadata": { "collapsed": false @@ -1111,27 +1131,20 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 70, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - }, { "data": { - "text/plain": "(
, )" + "text/plain": "[]" }, - "execution_count": 20, + "execution_count": 70, "metadata": {}, "output_type": "execute_result" }, { "data": { - "text/plain": "
", - "image/png": "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" + "text/plain": "
", + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -1140,9 +1153,9 @@ "source": [ "from aeon.datasets import load_uschange\n", "\n", - "data = load_uschange(return_array=False)\n", - "consumption = data[\"Consumption\"]\n", - "plot_series(consumption)" + "data = load_uschange()\n", + "plt.title(\"Consumption\")\n", + "plt.plot(data[0])" ], "metadata": { "collapsed": false @@ -1152,8 +1165,7 @@ "cell_type": "markdown", "source": [ "### Solar\n", - "Example national solar data\n", - " for the GB eletricity network extracted from the Sheffield Solar PV_Live API.\n", + "Example national solar data for the GB eletricity network extracted from the Sheffield Solar PV_Live API.\n", " Note that these are estimates of the true solar\n", " generation, since the true values are \"behind the meter\" and essentially\n", " unknown. The returned data is half hourly." @@ -1164,13 +1176,37 @@ }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 71, + "outputs": [ + { + "ename": "TypeError", + "evalue": "input must be a one of (, ), but found type: ", + "output_type": "error", + "traceback": [ + "\u001B[1;31m---------------------------------------------------------------------------\u001B[0m", + "\u001B[1;31mTypeError\u001B[0m Traceback (most recent call last)", + "Cell \u001B[1;32mIn[71], line 6\u001B[0m\n\u001B[0;32m 4\u001B[0m plt\u001B[38;5;241m.\u001B[39mtitle(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mSolar\u001B[39m\u001B[38;5;124m\"\u001B[39m)\n\u001B[0;32m 5\u001B[0m plt\u001B[38;5;241m.\u001B[39mplot(solar)\n\u001B[1;32m----> 6\u001B[0m \u001B[43mplot_series\u001B[49m\u001B[43m(\u001B[49m\u001B[43msolar\u001B[49m\u001B[43m)\u001B[49m\n", + "File \u001B[1;32mC:\\Code\\aeon\\aeon\\visualisation\\series\\_series.py:70\u001B[0m, in \u001B[0;36mplot_series\u001B[1;34m(labels, markers, colors, title, x_label, y_label, ax, pred_interval, *series)\u001B[0m\n\u001B[0;32m 67\u001B[0m \u001B[38;5;28;01mfrom\u001B[39;00m \u001B[38;5;21;01mmatplotlib\u001B[39;00m\u001B[38;5;21;01m.\u001B[39;00m\u001B[38;5;21;01mticker\u001B[39;00m \u001B[38;5;28;01mimport\u001B[39;00m FuncFormatter, MaxNLocator\n\u001B[0;32m 69\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m y \u001B[38;5;129;01min\u001B[39;00m series:\n\u001B[1;32m---> 70\u001B[0m \u001B[43mcheck_y\u001B[49m\u001B[43m(\u001B[49m\u001B[43my\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mallow_index_names\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43;01mTrue\u001B[39;49;00m\u001B[43m)\u001B[49m\n\u001B[0;32m 72\u001B[0m series \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mlist\u001B[39m(series)\n\u001B[0;32m 74\u001B[0m n_series \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mlen\u001B[39m(series)\n", + "File \u001B[1;32mC:\\Code\\aeon\\aeon\\utils\\validation\\series.py:532\u001B[0m, in \u001B[0;36mcheck_y\u001B[1;34m(y, allow_empty, allow_constant, enforce_index_type, allow_index_names)\u001B[0m\n\u001B[0;32m 502\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mcheck_y\u001B[39m(\n\u001B[0;32m 503\u001B[0m y,\n\u001B[0;32m 504\u001B[0m allow_empty\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mFalse\u001B[39;00m,\n\u001B[1;32m (...)\u001B[0m\n\u001B[0;32m 507\u001B[0m allow_index_names\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mFalse\u001B[39;00m,\n\u001B[0;32m 508\u001B[0m ):\n\u001B[0;32m 509\u001B[0m \u001B[38;5;250m \u001B[39m\u001B[38;5;124;03m\"\"\"Validate input data.\u001B[39;00m\n\u001B[0;32m 510\u001B[0m \n\u001B[0;32m 511\u001B[0m \u001B[38;5;124;03m Parameters\u001B[39;00m\n\u001B[1;32m (...)\u001B[0m\n\u001B[0;32m 530\u001B[0m \u001B[38;5;124;03m If y is an invalid input\u001B[39;00m\n\u001B[0;32m 531\u001B[0m \u001B[38;5;124;03m \"\"\"\u001B[39;00m\n\u001B[1;32m--> 532\u001B[0m y \u001B[38;5;241m=\u001B[39m \u001B[43mcheck_series\u001B[49m\u001B[43m(\u001B[49m\n\u001B[0;32m 533\u001B[0m \u001B[43m \u001B[49m\u001B[43my\u001B[49m\u001B[43m,\u001B[49m\n\u001B[0;32m 534\u001B[0m \u001B[43m \u001B[49m\u001B[43menforce_univariate\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43;01mTrue\u001B[39;49;00m\u001B[43m,\u001B[49m\n\u001B[0;32m 535\u001B[0m \u001B[43m \u001B[49m\u001B[43mallow_empty\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mallow_empty\u001B[49m\u001B[43m,\u001B[49m\n\u001B[0;32m 536\u001B[0m \u001B[43m \u001B[49m\u001B[43mallow_numpy\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43;01mFalse\u001B[39;49;00m\u001B[43m,\u001B[49m\n\u001B[0;32m 537\u001B[0m \u001B[43m \u001B[49m\u001B[43menforce_index_type\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43menforce_index_type\u001B[49m\u001B[43m,\u001B[49m\n\u001B[0;32m 538\u001B[0m \u001B[43m \u001B[49m\u001B[43mallow_index_names\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mallow_index_names\u001B[49m\u001B[43m,\u001B[49m\n\u001B[0;32m 539\u001B[0m \u001B[43m \u001B[49m\u001B[43m)\u001B[49m\n\u001B[0;32m 541\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m allow_constant:\n\u001B[0;32m 542\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m np\u001B[38;5;241m.\u001B[39mall(y \u001B[38;5;241m==\u001B[39m y\u001B[38;5;241m.\u001B[39miloc[\u001B[38;5;241m0\u001B[39m]):\n", + "File \u001B[1;32mC:\\Code\\aeon\\aeon\\utils\\validation\\series.py:276\u001B[0m, in \u001B[0;36mcheck_series\u001B[1;34m(Z, enforce_univariate, enforce_multivariate, allow_empty, allow_numpy, allow_None, enforce_index_type, allow_index_names, var_name)\u001B[0m\n\u001B[0;32m 273\u001B[0m valid_data_types \u001B[38;5;241m=\u001B[39m VALID_DATA_TYPES\n\u001B[0;32m 275\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(Z, valid_data_types):\n\u001B[1;32m--> 276\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mTypeError\u001B[39;00m(\n\u001B[0;32m 277\u001B[0m \u001B[38;5;124mf\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;132;01m{\u001B[39;00mvar_name\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m must be a one of \u001B[39m\u001B[38;5;132;01m{\u001B[39;00mvalid_data_types\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m, but found type: \u001B[39m\u001B[38;5;132;01m{\u001B[39;00m\u001B[38;5;28mtype\u001B[39m(Z)\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m\"\u001B[39m\n\u001B[0;32m 278\u001B[0m )\n\u001B[0;32m 280\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m enforce_univariate \u001B[38;5;129;01mand\u001B[39;00m enforce_multivariate:\n\u001B[0;32m 281\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mValueError\u001B[39;00m(\n\u001B[0;32m 282\u001B[0m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m`enforce_univariate` and `enforce_multivariate` cannot both be set to \u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[0;32m 283\u001B[0m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mTrue.\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[0;32m 284\u001B[0m )\n", + "\u001B[1;31mTypeError\u001B[0m: input must be a one of (, ), but found type: " + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from aeon.datasets import load_solar\n", "\n", - "solar = load_solar(return_array=False)\n", - "print(type(solar))\n", + "solar = load_solar()\n", + "plt.title(\"Solar\")\n", + "plt.plot(solar)\n", "plot_series(solar)" ], "metadata": { From bd54e46cedf4182771c6682c6f9b0aef71d73fbd Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Wed, 30 Oct 2024 14:57:30 +0000 Subject: [PATCH 21/26] dobin --- aeon/transformations/series/_dobin.py | 23 +++++++++++------------ 1 file changed, 11 insertions(+), 12 deletions(-) diff --git a/aeon/transformations/series/_dobin.py b/aeon/transformations/series/_dobin.py index e2cf6a3a7e..98de8f36f0 100644 --- a/aeon/transformations/series/_dobin.py +++ b/aeon/transformations/series/_dobin.py @@ -64,19 +64,18 @@ class Dobin(BaseSeriesTransformer): >>> import numpy as np >>> import pandas as pd >>> from aeon.datasets import load_uschange - >>> X = load_uschange(return_array=False) - >>> X.drop(columns=["Consumption"], inplace=True) - >>> scaler = MinMaxScaler() - >>> X = scaler.fit_transform(X) + >>> X = load_uschange() + >>> min = MinMaxScaler() + >>> Xt = min.fit_transform(X.T) >>> model = Dobin() - >>> X_outlier = model.fit_transform(X, axis=0) - >>> X_outlier.head() - DB0 DB1 DB2 DB3 - 0 1.151965 0.116488 0.286064 0.288140 - 1 1.191976 0.100772 0.050835 0.225985 - 2 1.221158 0.078031 0.034030 0.249676 - 3 1.042420 0.188494 0.218460 0.205251 - 4 1.224701 0.020028 -0.294705 0.199827 + >>> X_outlier = model.fit_transform(X) + >>> X_outlier.T.head() + DB0 DB1 DB2 DB3 DB4 + 0 4.786838 -1.332530 -1.891908 1.566322 0.753280 + 1 7.290015 0.149297 -1.242303 0.558777 0.474924 + 2 7.297553 0.419074 -1.688429 0.282187 0.573991 + 3 0.954141 -1.639316 -0.423461 1.552961 0.434186 + 4 3.702288 2.066720 -1.807646 -1.777854 0.422556 """ _tags = { From c11651b297f3f3a6cddee5005e5332885dda8416 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Wed, 30 Oct 2024 16:51:02 +0000 Subject: [PATCH 22/26] solar --- examples/datasets/provided_data.ipynb | 45 +++++++++++++-------------- 1 file changed, 21 insertions(+), 24 deletions(-) diff --git a/examples/datasets/provided_data.ipynb b/examples/datasets/provided_data.ipynb index 00589b950f..8d917034b7 100644 --- a/examples/datasets/provided_data.ipynb +++ b/examples/datasets/provided_data.ipynb @@ -8,6 +8,7 @@ "`aeon` ships several example data sets for machine learning tasks in the module\n", "`datasets`. This notebook gives an overview of what is available by default. For\n", "downloading data from other archives, see the [loading data from web notebook](load_data_from_web.ipynb). For further details on the form of the\n", + "data, see the [data loading notebook](data_loading.ipynb).\n", "data, see the [data loading notebook](data_loading.ipynb)." ], "metadata": { @@ -885,13 +886,13 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 73, "outputs": [ { "data": { - "text/plain": "[]" + "text/plain": "[]" }, - "execution_count": 65, + "execution_count": 73, "metadata": {}, "output_type": "execute_result" }, @@ -905,15 +906,9 @@ } ], "source": [ - "import warnings\n", - "\n", "from aeon.datasets import load_airline\n", - "from aeon.visualisation import plot_series\n", - "\n", - "warnings.filterwarnings(\"ignore\")\n", "\n", "airline = load_airline()\n", - "# plot_series(airline)\n", "plt.title(\"Airline data\")\n", "plt.plot(airline)" ], @@ -1176,21 +1171,15 @@ }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 72, "outputs": [ { - "ename": "TypeError", - "evalue": "input must be a one of (, ), but found type: ", - "output_type": "error", - "traceback": [ - "\u001B[1;31m---------------------------------------------------------------------------\u001B[0m", - "\u001B[1;31mTypeError\u001B[0m Traceback (most recent call last)", - "Cell \u001B[1;32mIn[71], line 6\u001B[0m\n\u001B[0;32m 4\u001B[0m plt\u001B[38;5;241m.\u001B[39mtitle(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mSolar\u001B[39m\u001B[38;5;124m\"\u001B[39m)\n\u001B[0;32m 5\u001B[0m plt\u001B[38;5;241m.\u001B[39mplot(solar)\n\u001B[1;32m----> 6\u001B[0m \u001B[43mplot_series\u001B[49m\u001B[43m(\u001B[49m\u001B[43msolar\u001B[49m\u001B[43m)\u001B[49m\n", - "File \u001B[1;32mC:\\Code\\aeon\\aeon\\visualisation\\series\\_series.py:70\u001B[0m, in \u001B[0;36mplot_series\u001B[1;34m(labels, markers, colors, title, x_label, y_label, ax, pred_interval, *series)\u001B[0m\n\u001B[0;32m 67\u001B[0m \u001B[38;5;28;01mfrom\u001B[39;00m \u001B[38;5;21;01mmatplotlib\u001B[39;00m\u001B[38;5;21;01m.\u001B[39;00m\u001B[38;5;21;01mticker\u001B[39;00m \u001B[38;5;28;01mimport\u001B[39;00m FuncFormatter, MaxNLocator\n\u001B[0;32m 69\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m y \u001B[38;5;129;01min\u001B[39;00m series:\n\u001B[1;32m---> 70\u001B[0m \u001B[43mcheck_y\u001B[49m\u001B[43m(\u001B[49m\u001B[43my\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mallow_index_names\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43;01mTrue\u001B[39;49;00m\u001B[43m)\u001B[49m\n\u001B[0;32m 72\u001B[0m series \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mlist\u001B[39m(series)\n\u001B[0;32m 74\u001B[0m n_series \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mlen\u001B[39m(series)\n", - "File \u001B[1;32mC:\\Code\\aeon\\aeon\\utils\\validation\\series.py:532\u001B[0m, in \u001B[0;36mcheck_y\u001B[1;34m(y, allow_empty, allow_constant, enforce_index_type, allow_index_names)\u001B[0m\n\u001B[0;32m 502\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mcheck_y\u001B[39m(\n\u001B[0;32m 503\u001B[0m y,\n\u001B[0;32m 504\u001B[0m allow_empty\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mFalse\u001B[39;00m,\n\u001B[1;32m (...)\u001B[0m\n\u001B[0;32m 507\u001B[0m allow_index_names\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mFalse\u001B[39;00m,\n\u001B[0;32m 508\u001B[0m ):\n\u001B[0;32m 509\u001B[0m \u001B[38;5;250m \u001B[39m\u001B[38;5;124;03m\"\"\"Validate input data.\u001B[39;00m\n\u001B[0;32m 510\u001B[0m \n\u001B[0;32m 511\u001B[0m \u001B[38;5;124;03m Parameters\u001B[39;00m\n\u001B[1;32m (...)\u001B[0m\n\u001B[0;32m 530\u001B[0m \u001B[38;5;124;03m If y is an invalid input\u001B[39;00m\n\u001B[0;32m 531\u001B[0m \u001B[38;5;124;03m \"\"\"\u001B[39;00m\n\u001B[1;32m--> 532\u001B[0m y \u001B[38;5;241m=\u001B[39m \u001B[43mcheck_series\u001B[49m\u001B[43m(\u001B[49m\n\u001B[0;32m 533\u001B[0m \u001B[43m \u001B[49m\u001B[43my\u001B[49m\u001B[43m,\u001B[49m\n\u001B[0;32m 534\u001B[0m \u001B[43m \u001B[49m\u001B[43menforce_univariate\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43;01mTrue\u001B[39;49;00m\u001B[43m,\u001B[49m\n\u001B[0;32m 535\u001B[0m \u001B[43m \u001B[49m\u001B[43mallow_empty\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mallow_empty\u001B[49m\u001B[43m,\u001B[49m\n\u001B[0;32m 536\u001B[0m \u001B[43m \u001B[49m\u001B[43mallow_numpy\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43;01mFalse\u001B[39;49;00m\u001B[43m,\u001B[49m\n\u001B[0;32m 537\u001B[0m \u001B[43m \u001B[49m\u001B[43menforce_index_type\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43menforce_index_type\u001B[49m\u001B[43m,\u001B[49m\n\u001B[0;32m 538\u001B[0m \u001B[43m \u001B[49m\u001B[43mallow_index_names\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mallow_index_names\u001B[49m\u001B[43m,\u001B[49m\n\u001B[0;32m 539\u001B[0m \u001B[43m \u001B[49m\u001B[43m)\u001B[49m\n\u001B[0;32m 541\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m allow_constant:\n\u001B[0;32m 542\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m np\u001B[38;5;241m.\u001B[39mall(y \u001B[38;5;241m==\u001B[39m y\u001B[38;5;241m.\u001B[39miloc[\u001B[38;5;241m0\u001B[39m]):\n", - "File \u001B[1;32mC:\\Code\\aeon\\aeon\\utils\\validation\\series.py:276\u001B[0m, in \u001B[0;36mcheck_series\u001B[1;34m(Z, enforce_univariate, enforce_multivariate, allow_empty, allow_numpy, allow_None, enforce_index_type, allow_index_names, var_name)\u001B[0m\n\u001B[0;32m 273\u001B[0m valid_data_types \u001B[38;5;241m=\u001B[39m VALID_DATA_TYPES\n\u001B[0;32m 275\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(Z, valid_data_types):\n\u001B[1;32m--> 276\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mTypeError\u001B[39;00m(\n\u001B[0;32m 277\u001B[0m \u001B[38;5;124mf\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;132;01m{\u001B[39;00mvar_name\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m must be a one of \u001B[39m\u001B[38;5;132;01m{\u001B[39;00mvalid_data_types\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m, but found type: \u001B[39m\u001B[38;5;132;01m{\u001B[39;00m\u001B[38;5;28mtype\u001B[39m(Z)\u001B[38;5;132;01m}\u001B[39;00m\u001B[38;5;124m\"\u001B[39m\n\u001B[0;32m 278\u001B[0m )\n\u001B[0;32m 280\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m enforce_univariate \u001B[38;5;129;01mand\u001B[39;00m enforce_multivariate:\n\u001B[0;32m 281\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mValueError\u001B[39;00m(\n\u001B[0;32m 282\u001B[0m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m`enforce_univariate` and `enforce_multivariate` cannot both be set to \u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[0;32m 283\u001B[0m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mTrue.\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[0;32m 284\u001B[0m )\n", - "\u001B[1;31mTypeError\u001B[0m: input must be a one of (, ), but found type: " - ] + "data": { + "text/plain": "[]" + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" }, { "data": { @@ -1206,12 +1195,20 @@ "\n", "solar = load_solar()\n", "plt.title(\"Solar\")\n", - "plt.plot(solar)\n", - "plot_series(solar)" + "plt.plot(solar)" ], "metadata": { "collapsed": false } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false + } } ], "metadata": { From a7195a609f032fd41ce2fcb224315801fc3b1754 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Thu, 31 Oct 2024 10:53:32 +0000 Subject: [PATCH 23/26] distances --- docs/getting_started.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/getting_started.md b/docs/getting_started.md index 171fc039c7..d1acff37c8 100644 --- a/docs/getting_started.md +++ b/docs/getting_started.md @@ -132,7 +132,8 @@ all optimised using numba. They all work with multivariate and unequal length se >>> from aeon.datasets import load_japanese_vowels >>> from aeon.distances import dtw_distance >>> data = load_japanese_vowels() # load an example multivariate series ->>> d = dtw_distance(data[0], data[1]) # calculate the dtw distance +>>> dtw_distance(data[0], data[1]) # calculate the dtw distance +14.416269807978 ``` ### Anomaly Detection From 4686bd400936bbecc658f50d5eb7d6aaf08d6713 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Thu, 31 Oct 2024 10:56:31 +0000 Subject: [PATCH 24/26] distances --- docs/getting_started.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/getting_started.md b/docs/getting_started.md index d1acff37c8..f4524c0085 100644 --- a/docs/getting_started.md +++ b/docs/getting_started.md @@ -96,7 +96,7 @@ the US Change data loaded above has five channels and 187 time points. For more details on our provided datasets and on how to load data into aeon compatible data structures, see our [datasets](examples/datasets/datasets.ipynb) notebooks. -## Single series estimators +## Single series modules Different `aeon` module work with single series or collections of series. Estimators in the `anomaly detection` and `segmentation` modules use single @@ -222,6 +222,7 @@ appropriate. >>> X4[0].shape (12, 20) ``` +## Collection based modules ### Classification From f4be506baa0dcb4e98a4dda67876945cfa31c9fb Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Thu, 31 Oct 2024 10:57:36 +0000 Subject: [PATCH 25/26] distances --- docs/getting_started.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/getting_started.md b/docs/getting_started.md index f4524c0085..c91b5ca304 100644 --- a/docs/getting_started.md +++ b/docs/getting_started.md @@ -98,7 +98,7 @@ structures, see our [datasets](examples/datasets/datasets.ipynb) notebooks. ## Single series modules -Different `aeon` module work with single series or collections of series. Estimators +Different `aeon` module work with individual series or collections of series. Estimators in the `anomaly detection` and `segmentation` modules use single series input (they inherit from `BaseSeriesEstimator`). The functions in `distances` take two series as arguments. @@ -164,7 +164,7 @@ The estimators in the `classification`, `regression` and `clustering` modules learn from collections of time series (they inherit from the class `BaseCollectionEstimator`). Collections of time series will often be accompanied by an array of target variables for supervised -learning. +learning. The module `similarity_search` also works with collections of time series. ```{code-block} python >>> from aeon.datasets import load_italy_power_demand From 4949df5aa345dbce4979519dda1330a21e179fa0 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Sun, 3 Nov 2024 16:47:10 +0000 Subject: [PATCH 26/26] getting started --- docs/getting_started.md | 22 ++++++++++------------ 1 file changed, 10 insertions(+), 12 deletions(-) diff --git a/docs/getting_started.md b/docs/getting_started.md index c91b5ca304..ba347c79f4 100644 --- a/docs/getting_started.md +++ b/docs/getting_started.md @@ -12,28 +12,26 @@ package. If you want help with scikit-learn you may want to view the very latest algorithms for time series machine learning, in addition to a range of classical techniques for the following learning tasks: -- Classification, where a collection of time series labelled with +- **Classification**, where a collection of time series labelled with a discrete value is used to train a model to predict unseen cases ([more details](examples/classification/classification.ipynb)). -- Regression, where a collection of time series labelled with +- **Regression**, where a collection of time series labelled with a continuous value is used to train a model to predict unseen cases ([more details](examples/regression/regression.ipynb)). -- Clustering, where a collection of time series without any +- **Clustering**, where a collection of time series without any labels are used to train a model to label cases ([more details](examples/clustering/clustering.ipynb)). -- Similarity search where the goal is to evaluate the similarity +- **Similarity search** where the goal is to evaluate the similarity between a query time series and a collection of other longer time series ([more details](examples/similarity_search/similarity_search.ipynb)). -- Anomaly detection where the goal is to find values or areas of a - single time series that are not representative of the whole series. More details - coming soon. -- Segmentation where the goal is to split a single time series into +- **Anomaly detection** where the goal is to find values or areas of a + single time series that are not representative of the whole series. +- **Segmentation** where the goal is to split a single time series into regions where the series are sofind areas of a time series that are not representative of the whole series ([more details](examples/segmentation/segmentation.ipynb)). -- Forecasting, where the goal is to predict future values for a time +- **Forecasting**, where the goal is to predict future values for a time series (new module coming soon). `aeon` also provides core modules that are used by the modules above: - Transformations, where a either a single series or collection is - transformed - into a different representation or domain. More details coming soon. + transformed into a different representation or domain. ([more details](examples/transformations/transformations.ipynb)). - Distances, which measure the dissimilarity between two time series or collections of series and include functions to align series ([more details](examples/distances/distances.ipynb)). - Networks, provides core models for deep learning for all time series tasks ([more @@ -258,7 +256,7 @@ predict the labels for new cases. Like `scikit-learn`, `predict_proba` methods a available to predict class probabilities and a `score` method is present to calculate accuracy on new data. Explore the wide range of algorithms available in `aeon`, including the very latest state-of-the-art, in the -[classification notebooks](examples.md#classification). +[classification notebooks](examples/classification/classification.ipynb). ### Regression