From ba32f9d91ab56d0d28cc0232048a7073bd9751c1 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Tue, 5 Sep 2023 15:15:18 +0100 Subject: [PATCH 01/31] base similarity search --- aeon/similarity_search/__init__.py | 2 + aeon/similarity_search/base.py | 62 ++++++++++++++++++++++++++++++ 2 files changed, 64 insertions(+) create mode 100644 aeon/similarity_search/__init__.py create mode 100644 aeon/similarity_search/base.py diff --git a/aeon/similarity_search/__init__.py b/aeon/similarity_search/__init__.py new file mode 100644 index 0000000000..1dae06a365 --- /dev/null +++ b/aeon/similarity_search/__init__.py @@ -0,0 +1,2 @@ +# -*- coding: utf-8 -*- +"""BaseSimilaritySearch.""" diff --git a/aeon/similarity_search/base.py b/aeon/similarity_search/base.py new file mode 100644 index 0000000000..0068087069 --- /dev/null +++ b/aeon/similarity_search/base.py @@ -0,0 +1,62 @@ +# -*- coding: utf-8 -*- +"""BaseSimilaritySearch.""" +from abc import ABC, abstractmethod + +import numpy as np + +from aeon.base import BaseEstimator +from aeon.distances import get_distance_function + + +class BaseSimiliaritySearch(BaseEstimator, ABC): + """BaseSimilaritySearch.""" + + _tags = { + "capability:multivariate": False, + "capability:missing_values": False, + "X_inner_mtype": "numpyflat", + } + + def __init__(self, distance="euclidean", n_nearest=1, normalise=False): + self.distance = distance + self.n_nearest = n_nearest + self.normalise = normalise + + def fit(self, X, y=None): + """For now, assume X is 1-D numpy. + + Do we put normalising X here? If there are multiple queries, then it makes + sense. to be decided. Do we even want to call it X? + """ + if not isinstance(X, np.ndarray) or X.ndim != 1: + raise TypeError("Error, only supports 1D numpy atm.") + # Get distance function + self.distance_function = get_distance_function(self.distance) + self._n_nearest = self.n_nearest + if self.normalise: + # normalise here + X = X + self._X = X + self._fit(X, y) + return self + + def predict(self, q): + """Predict: find the self._n_nearest subseries in self._X to q. + + As determined by self.distance_function. + + What to return? + """ + if not isinstance(q, np.ndarray) or q.ndim != 1: + raise TypeError("Error, only supports 1D numpy atm.") + if len(q >= len(self._X)): + raise TypeError("Error, q must be shorter than X.") + return self._predict(q) + + @abstractmethod + def _fit(self, X, y): + ... + + @abstractmethod + def _predict(self, X): + ... From 1ad9ecac72ce56a11a076783dda9d7cf73c52afe Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Tue, 5 Sep 2023 15:24:57 +0100 Subject: [PATCH 02/31] slow search example --- aeon/similarity_search/SlowSearch.py | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 aeon/similarity_search/SlowSearch.py diff --git a/aeon/similarity_search/SlowSearch.py b/aeon/similarity_search/SlowSearch.py new file mode 100644 index 0000000000..59a8a5b383 --- /dev/null +++ b/aeon/similarity_search/SlowSearch.py @@ -0,0 +1,26 @@ +# -*- coding: utf-8 -*- +"""First similarity search.""" +import numpy as np + +from aeon.similarity_search.base import BaseSimiliaritySearch + + +class SlowSearch(BaseSimiliaritySearch): + """First similarity search.""" + + def __init__(self): + super(SlowSearch, self).__init__() + + def _fit(self, X, y): + return self + + def _predict(self, q): + index = 0 + min_d = np.Inf + l2 = len(q) + for i in range(0, len(self._X) - l2 - 1): + d = self.distance_function(q, self._X[i : i + l2 - 1]) + if d < min_d: + index = i + min_d = d + return [index] From f5fc6b766f595ed9690fe25fd8192222708cfdb8 Mon Sep 17 00:00:00 2001 From: Antoine Guillaume Date: Tue, 26 Sep 2023 14:54:34 +0200 Subject: [PATCH 03/31] =?UTF-8?q?[ENH]=20Similarity=20search=20base=20clas?= =?UTF-8?q?s=20and=20TopK=20search=20with=20na=C3=AFve=20Euclidean=20dista?= =?UTF-8?q?nce=20(#756)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Adding TopKSimilarity Search class with euclidean distance profiles * Removing old normalization attributes * Removing old normalization attributes in predict --------- Co-authored-by: MatthewMiddlehurst --- aeon/similarity_search/__init__.py | 5 + aeon/similarity_search/base.py | 153 +++++++++++++++--- .../distance_profiles/__init__.py | 12 ++ .../distance_profiles/_commons.py | 39 +++++ .../distance_profiles/naive_euclidean.py | 57 +++++++ .../normalized_naive_euclidean.py | 61 +++++++ .../tests/test_naive_euclidean.py | 38 +++++ .../tests/test_normalized_naive_euclidean.py | 58 +++++++ aeon/similarity_search/tests/__init__.py | 2 + .../tests/test_top_k_similarity.py | 33 ++++ aeon/similarity_search/top_k_similarity.py | 52 ++++++ 11 files changed, 484 insertions(+), 26 deletions(-) create mode 100644 aeon/similarity_search/distance_profiles/__init__.py create mode 100644 aeon/similarity_search/distance_profiles/_commons.py create mode 100644 aeon/similarity_search/distance_profiles/naive_euclidean.py create mode 100644 aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py create mode 100644 aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py create mode 100644 aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py create mode 100644 aeon/similarity_search/tests/__init__.py create mode 100644 aeon/similarity_search/tests/test_top_k_similarity.py create mode 100644 aeon/similarity_search/top_k_similarity.py diff --git a/aeon/similarity_search/__init__.py b/aeon/similarity_search/__init__.py index 1dae06a365..384b36a870 100644 --- a/aeon/similarity_search/__init__.py +++ b/aeon/similarity_search/__init__.py @@ -1,2 +1,7 @@ # -*- coding: utf-8 -*- """BaseSimilaritySearch.""" + +__author__ = ["baraline"] +__all__ = ["TopKSimilaritySearch"] + +from aeon.similarity_search.top_k_similarity import TopKSimilaritySearch diff --git a/aeon/similarity_search/base.py b/aeon/similarity_search/base.py index 0068087069..3da4ad9e4b 100644 --- a/aeon/similarity_search/base.py +++ b/aeon/similarity_search/base.py @@ -1,57 +1,145 @@ # -*- coding: utf-8 -*- """BaseSimilaritySearch.""" + +__author__ = ["baraline"] + from abc import ABC, abstractmethod import numpy as np from aeon.base import BaseEstimator -from aeon.distances import get_distance_function +from aeon.similarity_search.distance_profiles import ( + naive_euclidean_profile, + normalized_naive_euclidean_profile, +) +from aeon.utils.numba.general import sliding_mean_std_one_series class BaseSimiliaritySearch(BaseEstimator, ABC): - """BaseSimilaritySearch.""" + """BaseSimilaritySearch. + + Attributes + ---------- + distance : str, optional + Name of the distance function to use. The default is "euclidean". + normalize : bool, optional + Wheter the distance function should be z-normalized + store_distance_profile : bool, optional + Wheter to store the computed distance profile in the attribute + "_distance_profile" after calling the predict method. + """ _tags = { - "capability:multivariate": False, + "capability:multivariate": True, "capability:missing_values": False, - "X_inner_mtype": "numpyflat", } - def __init__(self, distance="euclidean", n_nearest=1, normalise=False): + def __init__( + self, distance="euclidean", normalize=False, store_distance_profile=False + ): self.distance = distance - self.n_nearest = n_nearest - self.normalise = normalise + self.normalize = normalize + self.store_distance_profile = store_distance_profile + + def _get_distance_profile_function(self): + dist_profile = DISTANCE_PROFILE_DICT.get(self.distance) + if dist_profile is None: + raise ValueError(f"Unknown distrance profile function {dist_profile}") + return dist_profile[self.normalize] + + def _store_mean_std_from_inputs(self, Q_length): + n_samples, n_channels, X_length = self._X.shape + search_space_size = n_samples * (X_length - Q_length + 1) + + means = np.zeros((n_samples, n_channels, search_space_size)) + stds = np.zeros((n_samples, n_channels, search_space_size)) + + for i in range(n_samples): + _mean, _std = sliding_mean_std_one_series(self._X[i], Q_length, 1) + stds[i] = _std + means[i] = _mean + + self._X_means = means + self._X_stds = stds def fit(self, X, y=None): - """For now, assume X is 1-D numpy. + """ + Fit method: store the input data and get the distance profile function. + + Parameters + ---------- + X : array, shape (n_samples, n_channels, n_timestamps) + Input array to used as database for the similarity search + y : TYPE, optional + Not used. + + Raises + ------ + TypeError + If the input X array is not 3D raise an error. + + Returns + ------- + TYPE + DESCRIPTION. - Do we put normalising X here? If there are multiple queries, then it makes - sense. to be decided. Do we even want to call it X? """ - if not isinstance(X, np.ndarray) or X.ndim != 1: - raise TypeError("Error, only supports 1D numpy atm.") + # For now force (n_samples, n_channels, n_timestamps), we could convert 2D + # (n_channels, n_timestamps) to 3D with a warning + if not isinstance(X, np.ndarray) or X.ndim != 3: + raise TypeError( + "Error, only supports 3D numpy of shape" + "(n_samples, n_channels, n_timestamps)." + ) + # Get distance function - self.distance_function = get_distance_function(self.distance) - self._n_nearest = self.n_nearest - if self.normalise: - # normalise here - X = X + self.distance_profile_function = self._get_distance_profile_function() + self._X = X self._fit(X, y) return self - def predict(self, q): - """Predict: find the self._n_nearest subseries in self._X to q. + def predict(self, Q): + """ + Predict method: Check the shape of Q and call _predict to perform the search. + + If the distance profile function is normalized, it stores the mean and stds + from Q and _X. + + Parameters + ---------- + Q : array, shape (n_channels, q_length) + Input query used for similarity search. + + Raises + ------ + TypeError + If the input Q array is not 2D raise an error. - As determined by self.distance_function. + Returns + ------- + array + An array containing the indexes of the matches between Q and _X. + The decision of wheter a candidate of size q_length from _X is matched with + Q depends on the subclasses that implent the _predict method + (e.g. top-k, threshold, ...). - What to return? """ - if not isinstance(q, np.ndarray) or q.ndim != 1: - raise TypeError("Error, only supports 1D numpy atm.") - if len(q >= len(self._X)): - raise TypeError("Error, q must be shorter than X.") - return self._predict(q) + if not isinstance(Q, np.ndarray) or Q.ndim != 2: + raise TypeError( + "Error, only supports 2D numpy atm. If Q is univariate" + " do Q.reshape(1,-1)." + ) + + if Q.shape[-1] >= self._X.shape[-1]: + raise TypeError("Error, Q must be shorter than X.") + + if self.normalize: + self._Q_mean = np.mean(Q, axis=-1) + self._Q_std = np.std(Q, axis=-1) + self._store_mean_std_from_inputs(Q.shape[-1]) + + return self._predict(Q) @abstractmethod def _fit(self, X, y): @@ -60,3 +148,16 @@ def _fit(self, X, y): @abstractmethod def _predict(self, X): ... + + +""" +Dictionary structure : + 1st lvl key : distance function used + 2nd lvl key : boolean indicating wheter distance is normalized +""" +DISTANCE_PROFILE_DICT = { + "euclidean": { + True: normalized_naive_euclidean_profile, + False: naive_euclidean_profile, + } +} diff --git a/aeon/similarity_search/distance_profiles/__init__.py b/aeon/similarity_search/distance_profiles/__init__.py new file mode 100644 index 0000000000..46c52a7bb3 --- /dev/null +++ b/aeon/similarity_search/distance_profiles/__init__.py @@ -0,0 +1,12 @@ +# -*- coding: utf-8 -*- +"""Distance profiles.""" + +__author__ = ["baraline"] +__all__ = ["naive_euclidean_profile", "normalized_naive_euclidean_profile"] + +from aeon.similarity_search.distance_profiles.naive_euclidean import ( + naive_euclidean_profile, +) +from aeon.similarity_search.distance_profiles.normalized_naive_euclidean import ( + normalized_naive_euclidean_profile, +) diff --git a/aeon/similarity_search/distance_profiles/_commons.py b/aeon/similarity_search/distance_profiles/_commons.py new file mode 100644 index 0000000000..f6c38190d3 --- /dev/null +++ b/aeon/similarity_search/distance_profiles/_commons.py @@ -0,0 +1,39 @@ +# -*- coding: utf-8 -*- +"""Helper and common function for similarity search distance profiles.""" + + +from numba import njit + +INF = 1e12 + + +@njit(cache=True) +def _get_input_sizes(X, Q): + """ + Get sizes of the input and search space for similarity search. + + Parameters + ---------- + X : array, shape (n_samples, n_channels, series_length) + The input samples. + Q : array, shape (n_channels, series_length) + The input query + + Returns + ------- + n_samples : int + Number of samples in X. + n_channels : int + Number of channeks in X. + X_length : int + Number of timestamps in X. + q_length : int + Number of timestamps in Q + search_space_size : int + Size of the search space for similarity search for each sample in X + + """ + n_samples, n_channels, X_length = X.shape + q_length = Q.shape[-1] + search_space_size = X_length - q_length + 1 + return (n_samples, n_channels, X_length, q_length, search_space_size) diff --git a/aeon/similarity_search/distance_profiles/naive_euclidean.py b/aeon/similarity_search/distance_profiles/naive_euclidean.py new file mode 100644 index 0000000000..9da59974d5 --- /dev/null +++ b/aeon/similarity_search/distance_profiles/naive_euclidean.py @@ -0,0 +1,57 @@ +# -*- coding: utf-8 -*- +"""Naive Euclidean distance profile.""" + +__author__ = ["baraline"] + +import numpy as np +from numba import njit + +from aeon.distances import euclidean_distance +from aeon.similarity_search.distance_profiles._commons import INF, _get_input_sizes + + +def naive_euclidean_profile(X, Q): + """ + Compute a euclidean distance profile in a brute force way. + + It computes the distance profiles between the input time series and the query using + the euclidean distance. The search is made in a brute force way without any + optimizations and can thus be slow. + + A distance profile between a (univariate) time series X_i = {x_1, ..., x_m} + and a query Q = {q_1, ..., q_m} is defined as a vector of size $m-(l-1)$, + such as P(X_i, Q) = {d(C_1, Q), ..., d(C_m-(l-1), Q)} with d the euclidean distance, + and C_j = {x_j, ..., x_{j+(l-1)}} the j-th candidate subsequence of size l in X_i. + + Parameters + ---------- + X: array shape (n_instances, n_channels, series_length) + The input samples. + + Q : np.ndarray shape (n_channels, query_length) + The query used for similarity search. + + Returns + ------- + distance_profile : np.ndarray shape (n_instances, series_length - query_length + 1) + The distance profile between Q and the input time series X. + + """ + return _naive_euclidean_profile(X, Q) + + +@njit(cache=True, fastmath=True) +def _naive_euclidean_profile(X, Q): + n_samples, n_channels, X_length, Q_length, search_space_size = _get_input_sizes( + X, Q + ) + distance_profile = np.full((n_samples, search_space_size), INF) + + # Compute euclidean distance for all candidate in a "brute force" way + for i_sample in range(n_samples): + for i_candidate in range(search_space_size): + distance_profile[i_sample, i_candidate] = euclidean_distance( + Q, X[i_sample, :, i_candidate : i_candidate + Q_length] + ) + + return distance_profile diff --git a/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py b/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py new file mode 100644 index 0000000000..e78b4607e3 --- /dev/null +++ b/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py @@ -0,0 +1,61 @@ +# -*- coding: utf-8 -*- +"""normalized_naive_euclidean_profile.""" + +__author__ = ["baraline"] + +import numpy as np +from numba import njit + +from aeon.distances import euclidean_distance +from aeon.similarity_search.distance_profiles._commons import INF, _get_input_sizes + + +def normalized_naive_euclidean_profile(X, Q, X_means, X_stds, Q_means, Q_stds): + """ + Compute a euclidean distance profile in a brute force way. + + It computes the distance profiles between the input time series and the query using + the euclidean distance. The search is made in a brute force way without any + optimizations and can thus be slow. + + A distance profile between a (univariate) time series X_i = {x_1, ..., x_m} + and a query Q = {q_1, ..., q_m} is defined as a vector of size $m-(l-1)$, + such as P(X_i, Q) = {d(C_1, Q), ..., d(C_m-(l-1), Q)} with d the euclidean distance, + and C_j = {x_j, ..., x_{j+(l-1)}} the j-th candidate subsequence of size l in X_i. + + Parameters + ---------- + X: array shape (n_instances, n_channels, series_length) + The input samples. + + Q : np.ndarray shape (n_channels, query_length) + The query used for similarity search. + + Returns + ------- + distance_profile : np.ndarray shape (n_instances, series_length - query_length + 1) + The distance profile between Q and the input time series X. + + """ + _Q = (Q - Q_means) / Q_stds + return _normalized_naive_euclidean_profile(X, _Q, X_means, X_stds) + + +@njit(cache=True, fastmath=True) +def _normalized_naive_euclidean_profile(X, Q, X_means, X_stds): + n_samples, n_channels, X_length, Q_length, search_space_size = _get_input_sizes( + X, Q + ) + distance_profile = np.full((n_samples, search_space_size), INF) + + # Compute euclidean distance for all candidate in a "brute force" way + for i_sample in range(n_samples): + for i_candidate in range(search_space_size): + # Extract and normalize the candidate + _C = X[i_sample, :, i_candidate : i_candidate + Q_length] + _C = (_C - X_means[i_sample, :, i_candidate]) / ( + X_stds[i_sample, :, i_candidate] + ) + distance_profile[i_sample, i_candidate] = euclidean_distance(Q, _C) + + return distance_profile diff --git a/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py b/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py new file mode 100644 index 0000000000..21724a7168 --- /dev/null +++ b/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py @@ -0,0 +1,38 @@ +# -*- coding: utf-8 -*- +""" +Created on Sun Sep 10 12:21:00 2023 + +@author: antoi +""" + +import numpy as np +import pytest +from numpy.testing import assert_array_almost_equal + +from aeon.distances import euclidean_distance +from aeon.similarity_search.distance_profiles.naive_euclidean import ( + naive_euclidean_profile, +) + +DATATYPES = ["int64", "float64"] + + +@pytest.mark.parametrize("dtype", DATATYPES) +def test_naive_euclidean(dtype): + X = np.asarray( + [[[1, 2, 3, 4, 5, 6, 7, 8]], [[1, 2, 4, 4, 5, 6, 5, 4]]], dtype=dtype + ) + Q = np.asarray([[3, 4, 5]], dtype=dtype) + + dist_profile = naive_euclidean_profile(X, Q) + + expected = np.array( + [ + [ + euclidean_distance(Q, X[j, :, i : i + Q.shape[-1]]) + for i in range(X.shape[-1] - Q.shape[-1] + 1) + ] + for j in range(X.shape[0]) + ] + ) + assert_array_almost_equal(dist_profile, expected) diff --git a/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py b/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py new file mode 100644 index 0000000000..278f6072f8 --- /dev/null +++ b/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py @@ -0,0 +1,58 @@ +# -*- coding: utf-8 -*- +""" +Created on Sun Sep 10 12:21:00 2023 + +@author: antoi +""" + +import numpy as np +import pytest +from numpy.testing import assert_array_almost_equal + +from aeon.distances import euclidean_distance +from aeon.similarity_search.distance_profiles.normalized_naive_euclidean import ( + normalized_naive_euclidean_profile, +) +from aeon.utils.numba.general import sliding_mean_std_one_series + +DATATYPES = ["int64", "float64"] + + +@pytest.mark.parametrize("dtype", DATATYPES) +def test_normalized_naive_euclidean(dtype): + X = np.asarray( + [[[1, 2, 3, 4, 5, 6, 7, 8]], [[1, 2, 4, 4, 5, 6, 5, 4]]], dtype=dtype + ) + Q = np.asarray([[3, 4, 5]], dtype=dtype) + + search_space_size = X.shape[-1] - Q.shape[-1] + 1 + + X_means = np.zeros((2, 1, search_space_size)) + X_stds = np.zeros((2, 1, search_space_size)) + + for i in range(2): + _mean, _std = sliding_mean_std_one_series(X[i], Q.shape[-1], 1) + X_stds[i] = _std + X_means[i] = _mean + + Q_means = Q.mean(axis=-1) + Q_stds = Q.std(axis=-1) + + dist_profile = normalized_naive_euclidean_profile( + X, Q, X_means, X_stds, Q_means, Q_stds + ) + + _Q = (Q - Q_means) / Q_stds + expected = np.array( + [ + [ + euclidean_distance( + _Q, + (X[j, :, i : i + Q.shape[-1]] - X_means[j, :, i]) / X_stds[j, :, i], + ) + for i in range(X.shape[-1] - Q.shape[-1] + 1) + ] + for j in range(X.shape[0]) + ] + ) + assert_array_almost_equal(dist_profile, expected) diff --git a/aeon/similarity_search/tests/__init__.py b/aeon/similarity_search/tests/__init__.py new file mode 100644 index 0000000000..b81642462e --- /dev/null +++ b/aeon/similarity_search/tests/__init__.py @@ -0,0 +1,2 @@ +# -*- coding: utf-8 -*- +"""Similarity search Tests.""" diff --git a/aeon/similarity_search/tests/test_top_k_similarity.py b/aeon/similarity_search/tests/test_top_k_similarity.py new file mode 100644 index 0000000000..769b5055eb --- /dev/null +++ b/aeon/similarity_search/tests/test_top_k_similarity.py @@ -0,0 +1,33 @@ +# -*- coding: utf-8 -*- +""" +Created on Sat Sep 9 14:12:58 2023 + +@author: antoi +""" + + +import numpy as np +import pytest +from numpy.testing import assert_array_equal + +from aeon.similarity_search.top_k_similarity import TopKSimilaritySearch + +DATATYPES = ["int64", "float64"] + + +@pytest.mark.parametrize("dtype", DATATYPES) +def test_TopKSimilaritySearch(dtype): + X = np.asarray( + [[[1, 2, 3, 4, 5, 6, 7, 8]], [[1, 2, 4, 4, 5, 6, 5, 4]]], dtype=dtype + ) + Q = np.asarray([[3, 4, 5]], dtype=dtype) + + search = TopKSimilaritySearch(k=1) + search.fit(X) + idx = search.predict(Q) + assert_array_equal(idx, [(0, 2)]) + + search = TopKSimilaritySearch(k=3) + search.fit(X) + idx = search.predict(Q) + assert_array_equal(idx, [(0, 2), (1, 2), (1, 1)]) diff --git a/aeon/similarity_search/top_k_similarity.py b/aeon/similarity_search/top_k_similarity.py new file mode 100644 index 0000000000..a18d206f27 --- /dev/null +++ b/aeon/similarity_search/top_k_similarity.py @@ -0,0 +1,52 @@ +# -*- coding: utf-8 -*- +"""TopKSimilaritySearch.""" + +__author__ = ["baraline"] + +from aeon.similarity_search.base import BaseSimiliaritySearch + + +class TopKSimilaritySearch(BaseSimiliaritySearch): + """ + Top-K similarity search method. + + Attributes + ---------- + k : int, optional + Number of nearest matches from Q to return. The default is 1. + + """ + + def __init__(self, k=1): + self.k = k + super(TopKSimilaritySearch, self).__init__() + + def _fit(self, X, y): + return self + + def _predict(self, Q): + if self.normalize: + distance_profile = self.distance_profile_function( + self._X, Q, self._X_means, self._X_stds, self._Q_means, self._Q_stds + ) + else: + distance_profile = self.distance_profile_function(self._X, Q) + """ + Would creating base distance profile classes be relevant to force the same + interface for normalized / non normalized distance profiles ? + """ + if self.store_distance_profile: + self._distance_profile = distance_profile + + search_size = distance_profile.shape[-1] + + _argsort = distance_profile.argsort(axis=None)[: self.k] + + """ + return is [(id_sample, id_timestamp)] + -> candidate is X[id_sample, :, id_timestamps:id_timestamps+q_length] + """ + return [ + (_argsort[i] // search_size, _argsort[i] % search_size) + for i in range(self.k) + ] From c258de7ea515eeca1262103ce05b08ee72ab9ecc Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Tue, 26 Sep 2023 15:58:03 +0100 Subject: [PATCH 04/31] format --- aeon/similarity_search/base.py | 12 ++++++------ .../{SlowSearch.py => slow_search.py} | 0 2 files changed, 6 insertions(+), 6 deletions(-) rename aeon/similarity_search/{SlowSearch.py => slow_search.py} (100%) diff --git a/aeon/similarity_search/base.py b/aeon/similarity_search/base.py index 3da4ad9e4b..c6b0ad3ecb 100644 --- a/aeon/similarity_search/base.py +++ b/aeon/similarity_search/base.py @@ -20,12 +20,12 @@ class BaseSimiliaritySearch(BaseEstimator, ABC): Attributes ---------- - distance : str, optional - Name of the distance function to use. The default is "euclidean". - normalize : bool, optional - Wheter the distance function should be z-normalized - store_distance_profile : bool, optional - Wheter to store the computed distance profile in the attribute + distance : str, default ="euclidean" + Name of the distance function to use. + normalize : bool, default = False + Whether the distance function should be z-normalized. + store_distance_profile : bool, default = =False. + Whether to store the computed distance profile in the attribute "_distance_profile" after calling the predict method. """ diff --git a/aeon/similarity_search/SlowSearch.py b/aeon/similarity_search/slow_search.py similarity index 100% rename from aeon/similarity_search/SlowSearch.py rename to aeon/similarity_search/slow_search.py From 11410322cd4e9eb76d2ba865578ca3c51a710ed8 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Tue, 26 Sep 2023 17:27:58 +0100 Subject: [PATCH 05/31] add init --- aeon/similarity_search/distance_profiles/tests/__init__.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 aeon/similarity_search/distance_profiles/tests/__init__.py diff --git a/aeon/similarity_search/distance_profiles/tests/__init__.py b/aeon/similarity_search/distance_profiles/tests/__init__.py new file mode 100644 index 0000000000..e69de29bb2 From ae4b49ad90e785acb2045b02f7e65e6d98f68458 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Tue, 26 Sep 2023 18:52:35 +0100 Subject: [PATCH 06/31] call constructor --- aeon/similarity_search/base.py | 1 + 1 file changed, 1 insertion(+) diff --git a/aeon/similarity_search/base.py b/aeon/similarity_search/base.py index c6b0ad3ecb..a2dd5c7780 100644 --- a/aeon/similarity_search/base.py +++ b/aeon/similarity_search/base.py @@ -40,6 +40,7 @@ def __init__( self.distance = distance self.normalize = normalize self.store_distance_profile = store_distance_profile + super(BaseSimiliaritySearch, self).__init__() def _get_distance_profile_function(self): dist_profile = DISTANCE_PROFILE_DICT.get(self.distance) From a64e29bc648fdb166cfc719362c46d35dd1eba70 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Mon, 2 Oct 2023 16:49:45 +0100 Subject: [PATCH 07/31] add similarity base to register --- aeon/registry/_base_classes.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/aeon/registry/_base_classes.py b/aeon/registry/_base_classes.py index 15e6d26f62..6a81242629 100644 --- a/aeon/registry/_base_classes.py +++ b/aeon/registry/_base_classes.py @@ -43,6 +43,7 @@ from aeon.networks.base import BaseDeepNetwork from aeon.performance_metrics.base import BaseMetric from aeon.regression.base import BaseRegressor +from aeon.similarity_search.base import BaseSimiliaritySearch from aeon.transformations.base import BaseTransformer from aeon.transformations.collection import BaseCollectionTransformer @@ -64,6 +65,7 @@ BaseCollectionTransformer, "time series collection transformer", ), + ("similarity_search", BaseSimiliaritySearch, "similarity search"), ] From 1a1858ba345c0faf02d3d9ff8a3c32f24049b42e Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Thu, 5 Oct 2023 08:52:03 +0100 Subject: [PATCH 08/31] add similarity-search to tagging --- aeon/registry/_base_classes.py | 2 +- aeon/registry/tests/test_lookup.py | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/aeon/registry/_base_classes.py b/aeon/registry/_base_classes.py index 6a81242629..2c957a93fc 100644 --- a/aeon/registry/_base_classes.py +++ b/aeon/registry/_base_classes.py @@ -65,7 +65,7 @@ BaseCollectionTransformer, "time series collection transformer", ), - ("similarity_search", BaseSimiliaritySearch, "similarity search"), + ("similarity-search", BaseSimiliaritySearch, "similarity search"), ] diff --git a/aeon/registry/tests/test_lookup.py b/aeon/registry/tests/test_lookup.py index 80f7fc5016..a0926f5697 100644 --- a/aeon/registry/tests/test_lookup.py +++ b/aeon/registry/tests/test_lookup.py @@ -22,6 +22,7 @@ "network", "collection-transformer", "collection-estimator", + "similarity-search", ] # shorthands for easy reading From 33557bcd11a314662b6952ba2c5c4641b01b8ac8 Mon Sep 17 00:00:00 2001 From: Antoine Guillaume Date: Thu, 5 Oct 2023 15:14:30 +0200 Subject: [PATCH 09/31] Bugfixes for constant case and input alteration during normalization --- .../distance_profiles/_commons.py | 27 ++++++ .../normalized_naive_euclidean.py | 25 ++++-- .../tests/test_naive_euclidean.py | 25 +++++- .../tests/test_normalized_naive_euclidean.py | 84 +++++++++++++++---- 4 files changed, 135 insertions(+), 26 deletions(-) diff --git a/aeon/similarity_search/distance_profiles/_commons.py b/aeon/similarity_search/distance_profiles/_commons.py index f6c38190d3..3038e7e5e9 100644 --- a/aeon/similarity_search/distance_profiles/_commons.py +++ b/aeon/similarity_search/distance_profiles/_commons.py @@ -4,6 +4,7 @@ from numba import njit +AEON_SIMSEARCH_STD_THRESHOLD = 1e-7 INF = 1e12 @@ -37,3 +38,29 @@ def _get_input_sizes(X, Q): q_length = Q.shape[-1] search_space_size = X_length - q_length + 1 return (n_samples, n_channels, X_length, q_length, search_space_size) + + +@njit(fastmath=True, cache=True) +def _z_normalize_2D_series_with_mean_std(X, mean, std, copy=True): + """ + Z-normalize a 2D series given the mean and std of each channel. + + Parameters + ---------- + X : array, shape = (n_channels, n_timestamps) + Input array to normalize. + mean : array, shape = (n_channels) + Mean of each channel. + std : array, shape = (n_channels) + Std of each channel. + + Returns + ------- + X : array, shape = (n_channels, n_timestamps) + The normalized array + """ + if copy: + X = X.copy() + for i_channel in range(X.shape[0]): + X[i_channel] = (X[i_channel] - mean[i_channel]) / std[i_channel] + return X diff --git a/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py b/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py index e78b4607e3..6965179f1d 100644 --- a/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py @@ -7,7 +7,11 @@ from numba import njit from aeon.distances import euclidean_distance -from aeon.similarity_search.distance_profiles._commons import INF, _get_input_sizes +from aeon.similarity_search.distance_profiles._commons import ( + AEON_SIMSEARCH_STD_THRESHOLD, + _get_input_sizes, + _z_normalize_2D_series_with_mean_std, +) def normalized_naive_euclidean_profile(X, Q, X_means, X_stds, Q_means, Q_stds): @@ -37,25 +41,30 @@ def normalized_naive_euclidean_profile(X, Q, X_means, X_stds, Q_means, Q_stds): The distance profile between Q and the input time series X. """ - _Q = (Q - Q_means) / Q_stds - return _normalized_naive_euclidean_profile(X, _Q, X_means, X_stds) + # Make STDS inferior to the threshold to 1 to avoid division per 0 error. + Q_stds[Q_stds < AEON_SIMSEARCH_STD_THRESHOLD] = 1 + X_stds[X_stds < AEON_SIMSEARCH_STD_THRESHOLD] = 1 + + return _normalized_naive_euclidean_profile(X, Q, X_means, X_stds, Q_means, Q_stds) @njit(cache=True, fastmath=True) -def _normalized_naive_euclidean_profile(X, Q, X_means, X_stds): +def _normalized_naive_euclidean_profile(X, Q, X_means, X_stds, Q_means, Q_stds): n_samples, n_channels, X_length, Q_length, search_space_size = _get_input_sizes( X, Q ) - distance_profile = np.full((n_samples, search_space_size), INF) + # With Q_stds = 1, _Q will be an array of 0 + Q = _z_normalize_2D_series_with_mean_std(Q, Q_means, Q_stds) + distance_profile = np.full((n_samples, search_space_size), 1e12) # Compute euclidean distance for all candidate in a "brute force" way for i_sample in range(n_samples): for i_candidate in range(search_space_size): # Extract and normalize the candidate _C = X[i_sample, :, i_candidate : i_candidate + Q_length] - _C = (_C - X_means[i_sample, :, i_candidate]) / ( - X_stds[i_sample, :, i_candidate] + + _C = _z_normalize_2D_series_with_mean_std( + _C, X_means[i_sample, :, i_candidate], X_stds[i_sample, :, i_candidate] ) distance_profile[i_sample, i_candidate] = euclidean_distance(Q, _C) - return distance_profile diff --git a/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py b/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py index 21724a7168..01a3b40723 100644 --- a/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py @@ -7,7 +7,7 @@ import numpy as np import pytest -from numpy.testing import assert_array_almost_equal +from numpy.testing import assert_array_almost_equal, assert_array_equal from aeon.distances import euclidean_distance from aeon.similarity_search.distance_profiles.naive_euclidean import ( @@ -36,3 +36,26 @@ def test_naive_euclidean(dtype): ] ) assert_array_almost_equal(dist_profile, expected) + + +@pytest.mark.parametrize("dtype", DATATYPES) +def test_naive_euclidean_constant_case(dtype): + # Test constant case + X = np.ones((2, 1, 10), dtype=dtype) + Q = np.zeros((1, 3), dtype=dtype) + dist_profile = naive_euclidean_profile(X, Q) + # Should be full array for sqrt(3) as Q is zeros of length 3 and X is full ones + search_space_size = X.shape[-1] - Q.shape[-1] + 1 + expected = np.array([[3**0.5] * search_space_size] * X.shape[0]) + assert_array_almost_equal(dist_profile, expected) + + +def test_non_alteration_of_inputs_naive_euclidean(): + X = np.asarray([[[1, 2, 3, 4, 5, 6, 7, 8]], [[1, 2, 4, 4, 5, 6, 5, 4]]]) + X_copy = np.copy(X) + Q = np.asarray([[3, 4, 5]]) + Q_copy = np.copy(Q) + + _ = naive_euclidean_profile(X, Q) + assert_array_equal(Q, Q_copy) + assert_array_equal(X, X_copy) diff --git a/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py b/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py index 278f6072f8..5093119efc 100644 --- a/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py @@ -7,7 +7,7 @@ import numpy as np import pytest -from numpy.testing import assert_array_almost_equal +from numpy.testing import assert_array_almost_equal, assert_array_equal from aeon.distances import euclidean_distance from aeon.similarity_search.distance_profiles.normalized_naive_euclidean import ( @@ -27,32 +27,82 @@ def test_normalized_naive_euclidean(dtype): search_space_size = X.shape[-1] - Q.shape[-1] + 1 - X_means = np.zeros((2, 1, search_space_size)) - X_stds = np.zeros((2, 1, search_space_size)) + X_means = np.zeros((X.shape[0], X.shape[1], search_space_size)) + X_stds = np.zeros((X.shape[0], X.shape[1], search_space_size)) - for i in range(2): + for i in range(X.shape[0]): _mean, _std = sliding_mean_std_one_series(X[i], Q.shape[-1], 1) X_stds[i] = _std X_means[i] = _mean Q_means = Q.mean(axis=-1) Q_stds = Q.std(axis=-1) - dist_profile = normalized_naive_euclidean_profile( X, Q, X_means, X_stds, Q_means, Q_stds ) - _Q = (Q - Q_means) / Q_stds - expected = np.array( - [ - [ - euclidean_distance( - _Q, - (X[j, :, i : i + Q.shape[-1]] - X_means[j, :, i]) / X_stds[j, :, i], - ) - for i in range(X.shape[-1] - Q.shape[-1] + 1) - ] - for j in range(X.shape[0]) - ] + _Q = Q.copy() + for k in range(Q.shape[0]): + _Q[k] = (_Q[k] - Q_means[k]) / Q_stds[k] + + expected = np.full(dist_profile.shape, np.inf) + for i in range(X.shape[0]): + for j in range(search_space_size): + _C = X[i, :, j : j + Q.shape[-1]].copy() + for k in range(X.shape[1]): + _C[k] = (_C[k] - X_means[i, k, j]) / X_stds[i, k, j] + expected[i, j] = euclidean_distance(_Q, _C) + + assert_array_almost_equal(dist_profile, expected) + + +@pytest.mark.parametrize("dtype", DATATYPES) +def test_normalized_naive_euclidean_constant_case(dtype): + # Test constant case + X = np.ones((2, 2, 10), dtype=dtype) + Q = np.zeros((2, 3), dtype=dtype) + + search_space_size = X.shape[-1] - Q.shape[-1] + 1 + + Q_means = Q.mean(axis=-1, keepdims=True) + Q_stds = Q.std(axis=-1, keepdims=True) + + X_means = np.zeros((X.shape[0], X.shape[1], search_space_size)) + X_stds = np.zeros((X.shape[0], X.shape[1], search_space_size)) + for i in range(X.shape[0]): + _mean, _std = sliding_mean_std_one_series(X[i], Q.shape[-1], 1) + X_stds[i] = _std + X_means[i] = _mean + + dist_profile = normalized_naive_euclidean_profile( + X, Q, X_means, X_stds, Q_means, Q_stds ) + # Should be full array for 0 + + expected = np.array([[0] * search_space_size] * X.shape[0]) assert_array_almost_equal(dist_profile, expected) + + +def test_non_alteration_of_inputs_normalized_naive_euclidean(): + X = np.asarray([[[1, 2, 3, 4, 5, 6, 7, 8]], [[1, 2, 4, 4, 5, 6, 5, 4]]]) + X_copy = np.copy(X) + Q = np.asarray([[3, 4, 5]]) + Q_copy = np.copy(Q) + + search_space_size = X.shape[-1] - Q.shape[-1] + 1 + + X_means = np.zeros((X.shape[0], X.shape[1], search_space_size)) + X_stds = np.zeros((X.shape[0], X.shape[1], search_space_size)) + + for i in range(X.shape[0]): + _mean, _std = sliding_mean_std_one_series(X[i], Q.shape[-1], 1) + X_stds[i] = _std + X_means[i] = _mean + + Q_means = Q.mean(axis=-1, keepdims=True) + Q_stds = Q.std(axis=-1, keepdims=True) + + _ = normalized_naive_euclidean_profile(X, Q, X_means, X_stds, Q_means, Q_stds) + + assert_array_equal(Q, Q_copy) + assert_array_equal(X, X_copy) From cf724218ad7b82a28a1479c49b8b6a68d161e639 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Sat, 7 Oct 2023 17:45:09 +0100 Subject: [PATCH 10/31] typo --- .pre-commit-config.yaml | 12 ++++++------ aeon/distances/_bounding_matrix.py | 3 +-- 2 files changed, 7 insertions(+), 8 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index b96dbf0f44..7662945686 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -62,12 +62,12 @@ repos: args: [ "--convention=numpy" ] additional_dependencies: [ toml, tomli ] - - repo: https://github.com/pre-commit/mirrors-mypy - rev: v1.0.1 - hooks: - - id: mypy - files: aeon/ - additional_dependencies: [ pytest ] +# - repo: https://github.com/pre-commit/mirrors-mypy +# rev: v1.0.1 +# hooks: +# - id: mypy +# files: aeon/ +# additional_dependencies: [ pytest ] - repo: https://github.com/mgedmin/check-manifest rev: "0.49" diff --git a/aeon/distances/_bounding_matrix.py b/aeon/distances/_bounding_matrix.py index 23264c2630..621f5330ea 100644 --- a/aeon/distances/_bounding_matrix.py +++ b/aeon/distances/_bounding_matrix.py @@ -1,4 +1,3 @@ -# -*- coding: utf-8 -*- __author__ = ["chrisholder"] import math @@ -11,7 +10,7 @@ def create_bounding_matrix( x_size: int, y_size: int, window: float = None, itakura_max_slope: float = None ): - """Create a bounding matrix for a elastic distance. + """Create a bounding matrix for an elastic distance. Parameters ---------- From fbda7559364ffb82660d85987f1b6852de82e3ed Mon Sep 17 00:00:00 2001 From: "pre-commit-ci-lite[bot]" <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com> Date: Sat, 7 Oct 2023 16:47:28 +0000 Subject: [PATCH 11/31] [pre-commit.ci lite] apply automatic fixes --- aeon/registry/_base_classes.py | 1 - aeon/registry/tests/test_lookup.py | 1 - aeon/similarity_search/__init__.py | 1 - aeon/similarity_search/base.py | 1 - aeon/similarity_search/distance_profiles/__init__.py | 1 - aeon/similarity_search/distance_profiles/_commons.py | 1 - aeon/similarity_search/distance_profiles/naive_euclidean.py | 1 - .../distance_profiles/normalized_naive_euclidean.py | 1 - .../distance_profiles/tests/test_naive_euclidean.py | 1 - .../distance_profiles/tests/test_normalized_naive_euclidean.py | 1 - aeon/similarity_search/slow_search.py | 1 - aeon/similarity_search/tests/__init__.py | 1 - aeon/similarity_search/tests/test_top_k_similarity.py | 1 - aeon/similarity_search/top_k_similarity.py | 1 - 14 files changed, 14 deletions(-) diff --git a/aeon/registry/_base_classes.py b/aeon/registry/_base_classes.py index 2c957a93fc..5dcf6a19e2 100644 --- a/aeon/registry/_base_classes.py +++ b/aeon/registry/_base_classes.py @@ -1,4 +1,3 @@ -# -*- coding: utf-8 -*- """Register of estimator base classes corresponding to aeon scitypes. This module exports the following: diff --git a/aeon/registry/tests/test_lookup.py b/aeon/registry/tests/test_lookup.py index a0926f5697..783a10f021 100644 --- a/aeon/registry/tests/test_lookup.py +++ b/aeon/registry/tests/test_lookup.py @@ -1,4 +1,3 @@ -# -*- coding: utf-8 -*- # copyright: aeon developers, BSD-3-Clause License (see LICENSE file) """Testing of registry lookup functionality.""" diff --git a/aeon/similarity_search/__init__.py b/aeon/similarity_search/__init__.py index 384b36a870..2206d43ff5 100644 --- a/aeon/similarity_search/__init__.py +++ b/aeon/similarity_search/__init__.py @@ -1,4 +1,3 @@ -# -*- coding: utf-8 -*- """BaseSimilaritySearch.""" __author__ = ["baraline"] diff --git a/aeon/similarity_search/base.py b/aeon/similarity_search/base.py index a2dd5c7780..ecf79320e0 100644 --- a/aeon/similarity_search/base.py +++ b/aeon/similarity_search/base.py @@ -1,4 +1,3 @@ -# -*- coding: utf-8 -*- """BaseSimilaritySearch.""" __author__ = ["baraline"] diff --git a/aeon/similarity_search/distance_profiles/__init__.py b/aeon/similarity_search/distance_profiles/__init__.py index 46c52a7bb3..73f74ffc59 100644 --- a/aeon/similarity_search/distance_profiles/__init__.py +++ b/aeon/similarity_search/distance_profiles/__init__.py @@ -1,4 +1,3 @@ -# -*- coding: utf-8 -*- """Distance profiles.""" __author__ = ["baraline"] diff --git a/aeon/similarity_search/distance_profiles/_commons.py b/aeon/similarity_search/distance_profiles/_commons.py index 3038e7e5e9..df6b61eb19 100644 --- a/aeon/similarity_search/distance_profiles/_commons.py +++ b/aeon/similarity_search/distance_profiles/_commons.py @@ -1,4 +1,3 @@ -# -*- coding: utf-8 -*- """Helper and common function for similarity search distance profiles.""" diff --git a/aeon/similarity_search/distance_profiles/naive_euclidean.py b/aeon/similarity_search/distance_profiles/naive_euclidean.py index 9da59974d5..91995911e2 100644 --- a/aeon/similarity_search/distance_profiles/naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/naive_euclidean.py @@ -1,4 +1,3 @@ -# -*- coding: utf-8 -*- """Naive Euclidean distance profile.""" __author__ = ["baraline"] diff --git a/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py b/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py index 6965179f1d..17bc599e0c 100644 --- a/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py @@ -1,4 +1,3 @@ -# -*- coding: utf-8 -*- """normalized_naive_euclidean_profile.""" __author__ = ["baraline"] diff --git a/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py b/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py index 01a3b40723..d532743622 100644 --- a/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py @@ -1,4 +1,3 @@ -# -*- coding: utf-8 -*- """ Created on Sun Sep 10 12:21:00 2023 diff --git a/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py b/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py index 5093119efc..89fe9f7278 100644 --- a/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py @@ -1,4 +1,3 @@ -# -*- coding: utf-8 -*- """ Created on Sun Sep 10 12:21:00 2023 diff --git a/aeon/similarity_search/slow_search.py b/aeon/similarity_search/slow_search.py index 59a8a5b383..2084b127a8 100644 --- a/aeon/similarity_search/slow_search.py +++ b/aeon/similarity_search/slow_search.py @@ -1,4 +1,3 @@ -# -*- coding: utf-8 -*- """First similarity search.""" import numpy as np diff --git a/aeon/similarity_search/tests/__init__.py b/aeon/similarity_search/tests/__init__.py index b81642462e..0ddd46e48e 100644 --- a/aeon/similarity_search/tests/__init__.py +++ b/aeon/similarity_search/tests/__init__.py @@ -1,2 +1 @@ -# -*- coding: utf-8 -*- """Similarity search Tests.""" diff --git a/aeon/similarity_search/tests/test_top_k_similarity.py b/aeon/similarity_search/tests/test_top_k_similarity.py index 769b5055eb..d11257133c 100644 --- a/aeon/similarity_search/tests/test_top_k_similarity.py +++ b/aeon/similarity_search/tests/test_top_k_similarity.py @@ -1,4 +1,3 @@ -# -*- coding: utf-8 -*- """ Created on Sat Sep 9 14:12:58 2023 diff --git a/aeon/similarity_search/top_k_similarity.py b/aeon/similarity_search/top_k_similarity.py index a18d206f27..abd1ec6c6f 100644 --- a/aeon/similarity_search/top_k_similarity.py +++ b/aeon/similarity_search/top_k_similarity.py @@ -1,4 +1,3 @@ -# -*- coding: utf-8 -*- """TopKSimilaritySearch.""" __author__ = ["baraline"] From f440c3ea3d5f198ed5e39478f6a8d1110159daae Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Sat, 7 Oct 2023 18:00:54 +0100 Subject: [PATCH 12/31] typo --- .../distance_profiles/naive_euclidean.py | 3 +-- aeon/similarity_search/slow_search.py | 3 +-- aeon/similarity_search/top_k_similarity.py | 13 ++++--------- 3 files changed, 6 insertions(+), 13 deletions(-) diff --git a/aeon/similarity_search/distance_profiles/naive_euclidean.py b/aeon/similarity_search/distance_profiles/naive_euclidean.py index 9da59974d5..c18f2b26a9 100644 --- a/aeon/similarity_search/distance_profiles/naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/naive_euclidean.py @@ -1,4 +1,3 @@ -# -*- coding: utf-8 -*- """Naive Euclidean distance profile.""" __author__ = ["baraline"] @@ -11,7 +10,7 @@ def naive_euclidean_profile(X, Q): - """ + r""" Compute a euclidean distance profile in a brute force way. It computes the distance profiles between the input time series and the query using diff --git a/aeon/similarity_search/slow_search.py b/aeon/similarity_search/slow_search.py index 59a8a5b383..e6fee62163 100644 --- a/aeon/similarity_search/slow_search.py +++ b/aeon/similarity_search/slow_search.py @@ -1,5 +1,4 @@ -# -*- coding: utf-8 -*- -"""First similarity search.""" +"""Example basic similarity search to demonstrate the use case.""" import numpy as np from aeon.similarity_search.base import BaseSimiliaritySearch diff --git a/aeon/similarity_search/top_k_similarity.py b/aeon/similarity_search/top_k_similarity.py index a18d206f27..f7de3307f0 100644 --- a/aeon/similarity_search/top_k_similarity.py +++ b/aeon/similarity_search/top_k_similarity.py @@ -1,4 +1,3 @@ -# -*- coding: utf-8 -*- """TopKSimilaritySearch.""" __author__ = ["baraline"] @@ -31,10 +30,8 @@ def _predict(self, Q): ) else: distance_profile = self.distance_profile_function(self._X, Q) - """ - Would creating base distance profile classes be relevant to force the same - interface for normalized / non normalized distance profiles ? - """ + # Would creating base distance profile classes be relevant to force the same + # interface for normalized / non normalized distance profiles ? if self.store_distance_profile: self._distance_profile = distance_profile @@ -42,10 +39,8 @@ def _predict(self, Q): _argsort = distance_profile.argsort(axis=None)[: self.k] - """ - return is [(id_sample, id_timestamp)] - -> candidate is X[id_sample, :, id_timestamps:id_timestamps+q_length] - """ + # return is [(id_sample, id_timestamp)] + # -> candidate is X[id_sample, :, id_timestamps:id_timestamps+q_length] return [ (_argsort[i] // search_size, _argsort[i] % search_size) for i in range(self.k) From 9fcd4d3d5e0e2cc2c6296156abfa59ab04d933a3 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Sat, 7 Oct 2023 18:13:20 +0100 Subject: [PATCH 13/31] docstrings --- aeon/similarity_search/slow_search.py | 4 ++-- aeon/similarity_search/top_k_similarity.py | 6 ++++-- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/aeon/similarity_search/slow_search.py b/aeon/similarity_search/slow_search.py index 2084b127a8..47f314f870 100644 --- a/aeon/similarity_search/slow_search.py +++ b/aeon/similarity_search/slow_search.py @@ -1,11 +1,11 @@ -"""First similarity search.""" +"""Basic similarity search to demonstrate the basic use case.""" import numpy as np from aeon.similarity_search.base import BaseSimiliaritySearch class SlowSearch(BaseSimiliaritySearch): - """First similarity search.""" + """Slow similarity search.""" def __init__(self): super(SlowSearch, self).__init__() diff --git a/aeon/similarity_search/top_k_similarity.py b/aeon/similarity_search/top_k_similarity.py index f7de3307f0..9aea188ab9 100644 --- a/aeon/similarity_search/top_k_similarity.py +++ b/aeon/similarity_search/top_k_similarity.py @@ -9,10 +9,12 @@ class TopKSimilaritySearch(BaseSimiliaritySearch): """ Top-K similarity search method. + Finds the closest k series to the query series based on a distance function. + Attributes ---------- - k : int, optional - Number of nearest matches from Q to return. The default is 1. + k : int, default=1 + The number of nearest matches from Q to return. """ From 55ebc865beb4420e27f4ca6be464bfe72fc5eef5 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Sat, 7 Oct 2023 18:18:27 +0100 Subject: [PATCH 14/31] docstrings --- aeon/similarity_search/base.py | 12 +++++------- .../distance_profiles/_commons.py | 8 ++++---- .../distance_profiles/naive_euclidean.py | 15 ++++++++------- .../normalized_naive_euclidean.py | 9 +++++---- 4 files changed, 22 insertions(+), 22 deletions(-) diff --git a/aeon/similarity_search/base.py b/aeon/similarity_search/base.py index ecf79320e0..289b6962e6 100644 --- a/aeon/similarity_search/base.py +++ b/aeon/similarity_search/base.py @@ -1,4 +1,4 @@ -"""BaseSimilaritySearch.""" +"""Base class for similarity search.""" __author__ = ["baraline"] @@ -68,7 +68,7 @@ def fit(self, X, y=None): Parameters ---------- - X : array, shape (n_samples, n_channels, n_timestamps) + X : array, shape (n_cases, n_channels, n_timestamps) Input array to used as database for the similarity search y : TYPE, optional Not used. @@ -150,11 +150,9 @@ def _predict(self, X): ... -""" -Dictionary structure : - 1st lvl key : distance function used - 2nd lvl key : boolean indicating wheter distance is normalized -""" +# Dictionary structure : +# 1st lvl key : distance function used +# 2nd lvl key : boolean indicating wheter distance is normalized DISTANCE_PROFILE_DICT = { "euclidean": { True: normalized_naive_euclidean_profile, diff --git a/aeon/similarity_search/distance_profiles/_commons.py b/aeon/similarity_search/distance_profiles/_commons.py index df6b61eb19..b5916d7f6f 100644 --- a/aeon/similarity_search/distance_profiles/_commons.py +++ b/aeon/similarity_search/distance_profiles/_commons.py @@ -21,10 +21,10 @@ def _get_input_sizes(X, Q): Returns ------- - n_samples : int + n_cases : int Number of samples in X. n_channels : int - Number of channeks in X. + Number of channels in X. X_length : int Number of timestamps in X. q_length : int @@ -33,10 +33,10 @@ def _get_input_sizes(X, Q): Size of the search space for similarity search for each sample in X """ - n_samples, n_channels, X_length = X.shape + n_cases, n_channels, X_length = X.shape q_length = Q.shape[-1] search_space_size = X_length - q_length + 1 - return (n_samples, n_channels, X_length, q_length, search_space_size) + return (n_cases, n_channels, X_length, q_length, search_space_size) @njit(fastmath=True, cache=True) diff --git a/aeon/similarity_search/distance_profiles/naive_euclidean.py b/aeon/similarity_search/distance_profiles/naive_euclidean.py index c18f2b26a9..affd4705c7 100644 --- a/aeon/similarity_search/distance_profiles/naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/naive_euclidean.py @@ -14,17 +14,18 @@ def naive_euclidean_profile(X, Q): Compute a euclidean distance profile in a brute force way. It computes the distance profiles between the input time series and the query using - the euclidean distance. The search is made in a brute force way without any + the Euclidean distance. The search is made in a brute force way without any optimizations and can thus be slow. - A distance profile between a (univariate) time series X_i = {x_1, ..., x_m} - and a query Q = {q_1, ..., q_m} is defined as a vector of size $m-(l-1)$, - such as P(X_i, Q) = {d(C_1, Q), ..., d(C_m-(l-1), Q)} with d the euclidean distance, - and C_j = {x_j, ..., x_{j+(l-1)}} the j-th candidate subsequence of size l in X_i. + A distance profile between a (univariate) time series :math:`X_i = {x_1, ..., x_m}` + and a query :math:`Q = {q_1, ..., q_m}` is defined as a vector of size :math:`m-( + l-1)`, such as :math:`P(X_i, Q) = {d(C_1, Q), ..., d(C_m-(l-1), Q)}` with d the + Euclidean distance, and :math:`C_j = {x_j, ..., x_{j+(l-1)}}` the j-th candidate + subsequence of size :math:`l` in :math:`X_i`. Parameters ---------- - X: array shape (n_instances, n_channels, series_length) + X: array shape (n_cases, n_channels, series_length) The input samples. Q : np.ndarray shape (n_channels, query_length) @@ -32,7 +33,7 @@ def naive_euclidean_profile(X, Q): Returns ------- - distance_profile : np.ndarray shape (n_instances, series_length - query_length + 1) + distance_profile : np.ndarray shape (n_cases, series_length - query_length + 1) The distance profile between Q and the input time series X. """ diff --git a/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py b/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py index 17bc599e0c..8d2a10d78c 100644 --- a/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py @@ -21,10 +21,11 @@ def normalized_naive_euclidean_profile(X, Q, X_means, X_stds, Q_means, Q_stds): the euclidean distance. The search is made in a brute force way without any optimizations and can thus be slow. - A distance profile between a (univariate) time series X_i = {x_1, ..., x_m} - and a query Q = {q_1, ..., q_m} is defined as a vector of size $m-(l-1)$, - such as P(X_i, Q) = {d(C_1, Q), ..., d(C_m-(l-1), Q)} with d the euclidean distance, - and C_j = {x_j, ..., x_{j+(l-1)}} the j-th candidate subsequence of size l in X_i. + A distance profile between a (univariate) time series :math:`X_i = {x_1, ..., x_m}` + and a query :math:`Q = {q_1, ..., q_m}` is defined as a vector of size :math:`m-( + l-1)`, such as :math:`P(X_i, Q) = {d(C_1, Q), ..., d(C_m-(l-1), Q)}` with d the + Euclidean distance, and :math:`C_j = {x_j, ..., x_{j+(l-1)}}` the j-th candidate + subsequence of size :math:`l` in :math:`X_i`. Parameters ---------- From bc75368676527958d82d9ead8eba2c689e49003c Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Sat, 7 Oct 2023 18:21:25 +0100 Subject: [PATCH 15/31] docstrings --- aeon/similarity_search/base.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/aeon/similarity_search/base.py b/aeon/similarity_search/base.py index 289b6962e6..f24bc0e08a 100644 --- a/aeon/similarity_search/base.py +++ b/aeon/similarity_search/base.py @@ -3,6 +3,7 @@ __author__ = ["baraline"] from abc import ABC, abstractmethod +from typing import final import numpy as np @@ -62,6 +63,7 @@ def _store_mean_std_from_inputs(self, Q_length): self._X_means = means self._X_stds = stds + @final def fit(self, X, y=None): """ Fit method: store the input data and get the distance profile function. @@ -99,6 +101,7 @@ def fit(self, X, y=None): self._fit(X, y) return self + @final def predict(self, Q): """ Predict method: Check the shape of Q and call _predict to perform the search. From 7398eac1864d915c9433256c4d36d0743472d044 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Sat, 7 Oct 2023 18:23:03 +0100 Subject: [PATCH 16/31] docstrings --- aeon/similarity_search/distance_profiles/tests/__init__.py | 1 + 1 file changed, 1 insertion(+) diff --git a/aeon/similarity_search/distance_profiles/tests/__init__.py b/aeon/similarity_search/distance_profiles/tests/__init__.py index e69de29bb2..566dda7367 100644 --- a/aeon/similarity_search/distance_profiles/tests/__init__.py +++ b/aeon/similarity_search/distance_profiles/tests/__init__.py @@ -0,0 +1 @@ +"""Tests for distance profiles.""" From c7d927fb68f73b644e2fdfec6fc2ad134f83068d Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Sat, 7 Oct 2023 18:23:51 +0100 Subject: [PATCH 17/31] docstrings --- aeon/similarity_search/base.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/aeon/similarity_search/base.py b/aeon/similarity_search/base.py index f24bc0e08a..f74d7514bc 100644 --- a/aeon/similarity_search/base.py +++ b/aeon/similarity_search/base.py @@ -82,9 +82,7 @@ def fit(self, X, y=None): Returns ------- - TYPE - DESCRIPTION. - + self """ # For now force (n_samples, n_channels, n_timestamps), we could convert 2D # (n_channels, n_timestamps) to 3D with a warning From c5b4a33dc20ce41830479e7968e303eba4bfbfb7 Mon Sep 17 00:00:00 2001 From: Antoine Guillaume Date: Sun, 8 Oct 2023 10:32:56 +0200 Subject: [PATCH 18/31] Fixing typos --- aeon/similarity_search/__init__.py | 3 +- .../distance_profiles/__init__.py | 1 + .../distance_profiles/_commons.py | 4 +- .../distance_profiles/naive_euclidean.py | 4 +- .../normalized_naive_euclidean.py | 3 +- docs/api_reference/similarity_search.rst | 43 +++++++++++++++++++ 6 files changed, 52 insertions(+), 6 deletions(-) create mode 100644 docs/api_reference/similarity_search.rst diff --git a/aeon/similarity_search/__init__.py b/aeon/similarity_search/__init__.py index 384b36a870..b44fc2118e 100644 --- a/aeon/similarity_search/__init__.py +++ b/aeon/similarity_search/__init__.py @@ -2,6 +2,7 @@ """BaseSimilaritySearch.""" __author__ = ["baraline"] -__all__ = ["TopKSimilaritySearch"] +__all__ = ["BaseSimiliaritySearch", "TopKSimilaritySearch"] +from aeon.similarity_search.base import BaseSimiliaritySearch from aeon.similarity_search.top_k_similarity import TopKSimilaritySearch diff --git a/aeon/similarity_search/distance_profiles/__init__.py b/aeon/similarity_search/distance_profiles/__init__.py index 46c52a7bb3..3c700fc7e9 100644 --- a/aeon/similarity_search/distance_profiles/__init__.py +++ b/aeon/similarity_search/distance_profiles/__init__.py @@ -4,6 +4,7 @@ __author__ = ["baraline"] __all__ = ["naive_euclidean_profile", "normalized_naive_euclidean_profile"] + from aeon.similarity_search.distance_profiles.naive_euclidean import ( naive_euclidean_profile, ) diff --git a/aeon/similarity_search/distance_profiles/_commons.py b/aeon/similarity_search/distance_profiles/_commons.py index 3038e7e5e9..3af8f78aa4 100644 --- a/aeon/similarity_search/distance_profiles/_commons.py +++ b/aeon/similarity_search/distance_profiles/_commons.py @@ -5,7 +5,6 @@ from numba import njit AEON_SIMSEARCH_STD_THRESHOLD = 1e-7 -INF = 1e12 @njit(cache=True) @@ -53,6 +52,9 @@ def _z_normalize_2D_series_with_mean_std(X, mean, std, copy=True): Mean of each channel. std : array, shape = (n_channels) Std of each channel. + copy : bool, optional + Wheter to copy the input X to avoid modifying the values of the array it refers + to (if it is a reference). The default is True. Returns ------- diff --git a/aeon/similarity_search/distance_profiles/naive_euclidean.py b/aeon/similarity_search/distance_profiles/naive_euclidean.py index 9da59974d5..f5444f2571 100644 --- a/aeon/similarity_search/distance_profiles/naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/naive_euclidean.py @@ -7,7 +7,7 @@ from numba import njit from aeon.distances import euclidean_distance -from aeon.similarity_search.distance_profiles._commons import INF, _get_input_sizes +from aeon.similarity_search.distance_profiles._commons import _get_input_sizes def naive_euclidean_profile(X, Q): @@ -45,7 +45,7 @@ def _naive_euclidean_profile(X, Q): n_samples, n_channels, X_length, Q_length, search_space_size = _get_input_sizes( X, Q ) - distance_profile = np.full((n_samples, search_space_size), INF) + distance_profile = np.full((n_samples, search_space_size), np.inf) # Compute euclidean distance for all candidate in a "brute force" way for i_sample in range(n_samples): diff --git a/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py b/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py index 6965179f1d..af1594b125 100644 --- a/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py @@ -53,9 +53,8 @@ def _normalized_naive_euclidean_profile(X, Q, X_means, X_stds, Q_means, Q_stds): n_samples, n_channels, X_length, Q_length, search_space_size = _get_input_sizes( X, Q ) - # With Q_stds = 1, _Q will be an array of 0 Q = _z_normalize_2D_series_with_mean_std(Q, Q_means, Q_stds) - distance_profile = np.full((n_samples, search_space_size), 1e12) + distance_profile = np.full((n_samples, search_space_size), np.inf) # Compute euclidean distance for all candidate in a "brute force" way for i_sample in range(n_samples): diff --git a/docs/api_reference/similarity_search.rst b/docs/api_reference/similarity_search.rst new file mode 100644 index 0000000000..a9880c1e58 --- /dev/null +++ b/docs/api_reference/similarity_search.rst @@ -0,0 +1,43 @@ +.. _similarity_search_ref: + +Time series Similarity Search +========================== + +The :mod:`aeon.similarity_search` module contains algorithms and tools for similarity search tasks. + + +Similarity search with a known query +------------------------------------ + +.. currentmodule:: aeon.similarity_search + +.. autosummary:: + :toctree: auto_generated/ + :template: class.rst + + TopKSimilaritySearch + + +Distance profile functions +-------------------------- + +.. currentmodule:: aeon.similarity_search.distance_profiles + +.. autosummary:: + :toctree: auto_generated/ + :template: function.rst + + naive_euclidean_profile + normalized_naive_euclidean_profile + + +Base +---- + +.. currentmodule:: aeon.similarity_search + +.. autosummary:: + :toctree: auto_generated/ + :template: class.rst + + BaseSimiliaritySearch From bc515033afa07247ed79f73d5c66e56b6a51b92c Mon Sep 17 00:00:00 2001 From: Antoine Guillaume Date: Sun, 8 Oct 2023 11:34:00 +0200 Subject: [PATCH 19/31] Adding some docs, adding base class arguments to topk, more expressive exception messages --- aeon/similarity_search/base.py | 15 +++++++- aeon/similarity_search/top_k_similarity.py | 18 +++++++-- docs/getting_started.md | 43 ++++++++++++++++++++++ 3 files changed, 72 insertions(+), 4 deletions(-) diff --git a/aeon/similarity_search/base.py b/aeon/similarity_search/base.py index f74d7514bc..6cee2289ac 100644 --- a/aeon/similarity_search/base.py +++ b/aeon/similarity_search/base.py @@ -133,7 +133,20 @@ def predict(self, Q): ) if Q.shape[-1] >= self._X.shape[-1]: - raise TypeError("Error, Q must be shorter than X.") + raise ValueError( + "The length of the query q should be shorter than the length of the" + "data (X) provided during fit, but got {} for q and {} for X".format( + Q.shape[-1], self._X.shape[-1] + ) + ) + + if Q.shape[0] != self._X.shape[1]: + raise ValueError( + "The number of feature should be the same for the query q and the data" + "(X) provided during fit, but got {} for q and {} for X".format( + Q.shape[0], self._X.shape[1] + ) + ) if self.normalize: self._Q_mean = np.mean(Q, axis=-1) diff --git a/aeon/similarity_search/top_k_similarity.py b/aeon/similarity_search/top_k_similarity.py index 9aea188ab9..27304d3579 100644 --- a/aeon/similarity_search/top_k_similarity.py +++ b/aeon/similarity_search/top_k_similarity.py @@ -15,12 +15,24 @@ class TopKSimilaritySearch(BaseSimiliaritySearch): ---------- k : int, default=1 The number of nearest matches from Q to return. - + distance : str, default ="euclidean" + Name of the distance function to use. + normalize : bool, default = False + Whether the distance function should be z-normalized. + store_distance_profile : bool, default = =False. + Whether to store the computed distance profile in the attribute + "_distance_profile" after calling the predict method. """ - def __init__(self, k=1): + def __init__( + self, k=1, distance="euclidean", normalize=False, store_distance_profile=False + ): self.k = k - super(TopKSimilaritySearch, self).__init__() + super(TopKSimilaritySearch, self).__init__( + distance=distance, + normalize=normalize, + store_distance_profile=store_distance_profile, + ) def _fit(self, X, y): return self diff --git a/docs/getting_started.md b/docs/getting_started.md index 79fc11aff2..112938ce2c 100644 --- a/docs/getting_started.md +++ b/docs/getting_started.md @@ -22,6 +22,8 @@ instance are used to predict a continuous target value. instances with similar time series. - {term}`Time series annotation` which is focused on outlier detection, anomaly detection, change point detection and segmentation. +- {term}`Time series 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 @@ -632,3 +634,44 @@ 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 to 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 accept 3D collection of time series as input types. This collection asked for the +fit method is stored as a database, which will be used in the predict method. The +predict method expect a single 2D time series. All inputs are expected to be in numpy +array format. Then 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_samples, n_channels, n_timestamps) +>>> 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 6bbe5287d34f7eb5591970053225a78583c3c2b4 Mon Sep 17 00:00:00 2001 From: Antoine Guillaume Date: Sun, 8 Oct 2023 11:46:27 +0200 Subject: [PATCH 20/31] Change notation of query from Q to q --- aeon/similarity_search/base.py | 36 ++++++------- .../distance_profiles/_commons.py | 8 +-- .../distance_profiles/naive_euclidean.py | 16 +++--- .../normalized_naive_euclidean.py | 22 ++++---- .../tests/test_naive_euclidean.py | 24 ++++----- .../tests/test_normalized_naive_euclidean.py | 50 +++++++++---------- .../tests/test_top_k_similarity.py | 6 +-- aeon/similarity_search/top_k_similarity.py | 6 +-- 8 files changed, 84 insertions(+), 84 deletions(-) diff --git a/aeon/similarity_search/base.py b/aeon/similarity_search/base.py index 6cee2289ac..9b5da86343 100644 --- a/aeon/similarity_search/base.py +++ b/aeon/similarity_search/base.py @@ -100,67 +100,67 @@ def fit(self, X, y=None): return self @final - def predict(self, Q): + def predict(self, q): """ - Predict method: Check the shape of Q and call _predict to perform the search. + Predict method: Check the shape of q and call _predict to perform the search. If the distance profile function is normalized, it stores the mean and stds - from Q and _X. + from q and _X. Parameters ---------- - Q : array, shape (n_channels, q_length) + q : array, shape (n_channels, q_length) Input query used for similarity search. Raises ------ TypeError - If the input Q array is not 2D raise an error. + If the input q array is not 2D raise an error. Returns ------- array - An array containing the indexes of the matches between Q and _X. + An array containing the indexes of the matches between q and _X. The decision of wheter a candidate of size q_length from _X is matched with Q depends on the subclasses that implent the _predict method (e.g. top-k, threshold, ...). """ - if not isinstance(Q, np.ndarray) or Q.ndim != 2: + if not isinstance(q, np.ndarray) or q.ndim != 2: raise TypeError( - "Error, only supports 2D numpy atm. If Q is univariate" - " do Q.reshape(1,-1)." + "Error, only supports 2D numpy atm. If q is univariate" + " do q.reshape(1,-1)." ) - if Q.shape[-1] >= self._X.shape[-1]: + if q.shape[-1] >= self._X.shape[-1]: raise ValueError( "The length of the query q should be shorter than the length of the" "data (X) provided during fit, but got {} for q and {} for X".format( - Q.shape[-1], self._X.shape[-1] + q.shape[-1], self._X.shape[-1] ) ) - if Q.shape[0] != self._X.shape[1]: + if q.shape[0] != self._X.shape[1]: raise ValueError( "The number of feature should be the same for the query q and the data" "(X) provided during fit, but got {} for q and {} for X".format( - Q.shape[0], self._X.shape[1] + q.shape[0], self._X.shape[1] ) ) if self.normalize: - self._Q_mean = np.mean(Q, axis=-1) - self._Q_std = np.std(Q, axis=-1) - self._store_mean_std_from_inputs(Q.shape[-1]) + self._q_mean = np.mean(q, axis=-1) + self._q_std = np.std(q, axis=-1) + self._store_mean_std_from_inputs(q.shape[-1]) - return self._predict(Q) + return self._predict(q) @abstractmethod def _fit(self, X, y): ... @abstractmethod - def _predict(self, X): + def _predict(self, q): ... diff --git a/aeon/similarity_search/distance_profiles/_commons.py b/aeon/similarity_search/distance_profiles/_commons.py index a781a69c34..bb8428f7b2 100644 --- a/aeon/similarity_search/distance_profiles/_commons.py +++ b/aeon/similarity_search/distance_profiles/_commons.py @@ -7,7 +7,7 @@ @njit(cache=True) -def _get_input_sizes(X, Q): +def _get_input_sizes(X, q): """ Get sizes of the input and search space for similarity search. @@ -15,7 +15,7 @@ def _get_input_sizes(X, Q): ---------- X : array, shape (n_samples, n_channels, series_length) The input samples. - Q : array, shape (n_channels, series_length) + q : array, shape (n_channels, series_length) The input query Returns @@ -27,13 +27,13 @@ def _get_input_sizes(X, Q): X_length : int Number of timestamps in X. q_length : int - Number of timestamps in Q + Number of timestamps in q search_space_size : int Size of the search space for similarity search for each sample in X """ n_cases, n_channels, X_length = X.shape - q_length = Q.shape[-1] + q_length = q.shape[-1] search_space_size = X_length - q_length + 1 return (n_cases, n_channels, X_length, q_length, search_space_size) diff --git a/aeon/similarity_search/distance_profiles/naive_euclidean.py b/aeon/similarity_search/distance_profiles/naive_euclidean.py index 5374656696..365f73ffa4 100644 --- a/aeon/similarity_search/distance_profiles/naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/naive_euclidean.py @@ -9,7 +9,7 @@ from aeon.similarity_search.distance_profiles._commons import _get_input_sizes -def naive_euclidean_profile(X, Q): +def naive_euclidean_profile(X, q): r""" Compute a euclidean distance profile in a brute force way. @@ -28,22 +28,22 @@ def naive_euclidean_profile(X, Q): X: array shape (n_cases, n_channels, series_length) The input samples. - Q : np.ndarray shape (n_channels, query_length) + q : np.ndarray shape (n_channels, query_length) The query used for similarity search. Returns ------- distance_profile : np.ndarray shape (n_cases, series_length - query_length + 1) - The distance profile between Q and the input time series X. + The distance profile between q and the input time series X. """ - return _naive_euclidean_profile(X, Q) + return _naive_euclidean_profile(X, q) @njit(cache=True, fastmath=True) -def _naive_euclidean_profile(X, Q): - n_samples, n_channels, X_length, Q_length, search_space_size = _get_input_sizes( - X, Q +def _naive_euclidean_profile(X, q): + n_samples, n_channels, X_length, q_length, search_space_size = _get_input_sizes( + X, q ) distance_profile = np.full((n_samples, search_space_size), np.inf) @@ -51,7 +51,7 @@ def _naive_euclidean_profile(X, Q): for i_sample in range(n_samples): for i_candidate in range(search_space_size): distance_profile[i_sample, i_candidate] = euclidean_distance( - Q, X[i_sample, :, i_candidate : i_candidate + Q_length] + q, X[i_sample, :, i_candidate : i_candidate + q_length] ) return distance_profile diff --git a/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py b/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py index 86298326ee..244da14182 100644 --- a/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py @@ -13,7 +13,7 @@ ) -def normalized_naive_euclidean_profile(X, Q, X_means, X_stds, Q_means, Q_stds): +def normalized_naive_euclidean_profile(X, q, X_means, X_stds, q_means, q_stds): """ Compute a euclidean distance profile in a brute force way. @@ -32,38 +32,38 @@ def normalized_naive_euclidean_profile(X, Q, X_means, X_stds, Q_means, Q_stds): X: array shape (n_instances, n_channels, series_length) The input samples. - Q : np.ndarray shape (n_channels, query_length) + q : np.ndarray shape (n_channels, query_length) The query used for similarity search. Returns ------- distance_profile : np.ndarray shape (n_instances, series_length - query_length + 1) - The distance profile between Q and the input time series X. + The distance profile between q and the input time series X. """ # Make STDS inferior to the threshold to 1 to avoid division per 0 error. - Q_stds[Q_stds < AEON_SIMSEARCH_STD_THRESHOLD] = 1 + q_stds[q_stds < AEON_SIMSEARCH_STD_THRESHOLD] = 1 X_stds[X_stds < AEON_SIMSEARCH_STD_THRESHOLD] = 1 - return _normalized_naive_euclidean_profile(X, Q, X_means, X_stds, Q_means, Q_stds) + return _normalized_naive_euclidean_profile(X, q, X_means, X_stds, q_means, q_stds) @njit(cache=True, fastmath=True) -def _normalized_naive_euclidean_profile(X, Q, X_means, X_stds, Q_means, Q_stds): - n_samples, n_channels, X_length, Q_length, search_space_size = _get_input_sizes( - X, Q +def _normalized_naive_euclidean_profile(X, q, X_means, X_stds, q_means, q_stds): + n_samples, n_channels, X_length, q_length, search_space_size = _get_input_sizes( + X, q ) - Q = _z_normalize_2D_series_with_mean_std(Q, Q_means, Q_stds) + q = _z_normalize_2D_series_with_mean_std(q, q_means, q_stds) distance_profile = np.full((n_samples, search_space_size), np.inf) # Compute euclidean distance for all candidate in a "brute force" way for i_sample in range(n_samples): for i_candidate in range(search_space_size): # Extract and normalize the candidate - _C = X[i_sample, :, i_candidate : i_candidate + Q_length] + _C = X[i_sample, :, i_candidate : i_candidate + q_length] _C = _z_normalize_2D_series_with_mean_std( _C, X_means[i_sample, :, i_candidate], X_stds[i_sample, :, i_candidate] ) - distance_profile[i_sample, i_candidate] = euclidean_distance(Q, _C) + distance_profile[i_sample, i_candidate] = euclidean_distance(q, _C) return distance_profile diff --git a/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py b/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py index d532743622..31f9a463bd 100644 --- a/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py @@ -21,15 +21,15 @@ def test_naive_euclidean(dtype): X = np.asarray( [[[1, 2, 3, 4, 5, 6, 7, 8]], [[1, 2, 4, 4, 5, 6, 5, 4]]], dtype=dtype ) - Q = np.asarray([[3, 4, 5]], dtype=dtype) + q = np.asarray([[3, 4, 5]], dtype=dtype) - dist_profile = naive_euclidean_profile(X, Q) + dist_profile = naive_euclidean_profile(X, q) expected = np.array( [ [ - euclidean_distance(Q, X[j, :, i : i + Q.shape[-1]]) - for i in range(X.shape[-1] - Q.shape[-1] + 1) + euclidean_distance(q, X[j, :, i : i + q.shape[-1]]) + for i in range(X.shape[-1] - q.shape[-1] + 1) ] for j in range(X.shape[0]) ] @@ -41,10 +41,10 @@ def test_naive_euclidean(dtype): def test_naive_euclidean_constant_case(dtype): # Test constant case X = np.ones((2, 1, 10), dtype=dtype) - Q = np.zeros((1, 3), dtype=dtype) - dist_profile = naive_euclidean_profile(X, Q) - # Should be full array for sqrt(3) as Q is zeros of length 3 and X is full ones - search_space_size = X.shape[-1] - Q.shape[-1] + 1 + q = np.zeros((1, 3), dtype=dtype) + dist_profile = naive_euclidean_profile(X, q) + # Should be full array for sqrt(3) as q is zeros of length 3 and X is full ones + search_space_size = X.shape[-1] - q.shape[-1] + 1 expected = np.array([[3**0.5] * search_space_size] * X.shape[0]) assert_array_almost_equal(dist_profile, expected) @@ -52,9 +52,9 @@ def test_naive_euclidean_constant_case(dtype): def test_non_alteration_of_inputs_naive_euclidean(): X = np.asarray([[[1, 2, 3, 4, 5, 6, 7, 8]], [[1, 2, 4, 4, 5, 6, 5, 4]]]) X_copy = np.copy(X) - Q = np.asarray([[3, 4, 5]]) - Q_copy = np.copy(Q) + q = np.asarray([[3, 4, 5]]) + q_copy = np.copy(q) - _ = naive_euclidean_profile(X, Q) - assert_array_equal(Q, Q_copy) + _ = naive_euclidean_profile(X, q) + assert_array_equal(q, q_copy) assert_array_equal(X, X_copy) diff --git a/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py b/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py index 89fe9f7278..ce90852b54 100644 --- a/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py @@ -22,35 +22,35 @@ def test_normalized_naive_euclidean(dtype): X = np.asarray( [[[1, 2, 3, 4, 5, 6, 7, 8]], [[1, 2, 4, 4, 5, 6, 5, 4]]], dtype=dtype ) - Q = np.asarray([[3, 4, 5]], dtype=dtype) + q = np.asarray([[3, 4, 5]], dtype=dtype) - search_space_size = X.shape[-1] - Q.shape[-1] + 1 + search_space_size = X.shape[-1] - q.shape[-1] + 1 X_means = np.zeros((X.shape[0], X.shape[1], search_space_size)) X_stds = np.zeros((X.shape[0], X.shape[1], search_space_size)) for i in range(X.shape[0]): - _mean, _std = sliding_mean_std_one_series(X[i], Q.shape[-1], 1) + _mean, _std = sliding_mean_std_one_series(X[i], q.shape[-1], 1) X_stds[i] = _std X_means[i] = _mean - Q_means = Q.mean(axis=-1) - Q_stds = Q.std(axis=-1) + q_means = q.mean(axis=-1) + q_stds = q.std(axis=-1) dist_profile = normalized_naive_euclidean_profile( - X, Q, X_means, X_stds, Q_means, Q_stds + X, q, X_means, X_stds, q_means, q_stds ) - _Q = Q.copy() - for k in range(Q.shape[0]): - _Q[k] = (_Q[k] - Q_means[k]) / Q_stds[k] + _q = q.copy() + for k in range(q.shape[0]): + _q[k] = (_q[k] - q_means[k]) / q_stds[k] expected = np.full(dist_profile.shape, np.inf) for i in range(X.shape[0]): for j in range(search_space_size): - _C = X[i, :, j : j + Q.shape[-1]].copy() + _C = X[i, :, j : j + q.shape[-1]].copy() for k in range(X.shape[1]): _C[k] = (_C[k] - X_means[i, k, j]) / X_stds[i, k, j] - expected[i, j] = euclidean_distance(_Q, _C) + expected[i, j] = euclidean_distance(_q, _C) assert_array_almost_equal(dist_profile, expected) @@ -59,22 +59,22 @@ def test_normalized_naive_euclidean(dtype): def test_normalized_naive_euclidean_constant_case(dtype): # Test constant case X = np.ones((2, 2, 10), dtype=dtype) - Q = np.zeros((2, 3), dtype=dtype) + q = np.zeros((2, 3), dtype=dtype) - search_space_size = X.shape[-1] - Q.shape[-1] + 1 + search_space_size = X.shape[-1] - q.shape[-1] + 1 - Q_means = Q.mean(axis=-1, keepdims=True) - Q_stds = Q.std(axis=-1, keepdims=True) + q_means = q.mean(axis=-1, keepdims=True) + q_stds = q.std(axis=-1, keepdims=True) X_means = np.zeros((X.shape[0], X.shape[1], search_space_size)) X_stds = np.zeros((X.shape[0], X.shape[1], search_space_size)) for i in range(X.shape[0]): - _mean, _std = sliding_mean_std_one_series(X[i], Q.shape[-1], 1) + _mean, _std = sliding_mean_std_one_series(X[i], q.shape[-1], 1) X_stds[i] = _std X_means[i] = _mean dist_profile = normalized_naive_euclidean_profile( - X, Q, X_means, X_stds, Q_means, Q_stds + X, q, X_means, X_stds, q_means, q_stds ) # Should be full array for 0 @@ -85,23 +85,23 @@ def test_normalized_naive_euclidean_constant_case(dtype): def test_non_alteration_of_inputs_normalized_naive_euclidean(): X = np.asarray([[[1, 2, 3, 4, 5, 6, 7, 8]], [[1, 2, 4, 4, 5, 6, 5, 4]]]) X_copy = np.copy(X) - Q = np.asarray([[3, 4, 5]]) - Q_copy = np.copy(Q) + q = np.asarray([[3, 4, 5]]) + q_copy = np.copy(q) - search_space_size = X.shape[-1] - Q.shape[-1] + 1 + search_space_size = X.shape[-1] - q.shape[-1] + 1 X_means = np.zeros((X.shape[0], X.shape[1], search_space_size)) X_stds = np.zeros((X.shape[0], X.shape[1], search_space_size)) for i in range(X.shape[0]): - _mean, _std = sliding_mean_std_one_series(X[i], Q.shape[-1], 1) + _mean, _std = sliding_mean_std_one_series(X[i], q.shape[-1], 1) X_stds[i] = _std X_means[i] = _mean - Q_means = Q.mean(axis=-1, keepdims=True) - Q_stds = Q.std(axis=-1, keepdims=True) + q_means = q.mean(axis=-1, keepdims=True) + q_stds = q.std(axis=-1, keepdims=True) - _ = normalized_naive_euclidean_profile(X, Q, X_means, X_stds, Q_means, Q_stds) + _ = normalized_naive_euclidean_profile(X, q, X_means, X_stds, q_means, q_stds) - assert_array_equal(Q, Q_copy) + assert_array_equal(q, q_copy) assert_array_equal(X, X_copy) diff --git a/aeon/similarity_search/tests/test_top_k_similarity.py b/aeon/similarity_search/tests/test_top_k_similarity.py index d11257133c..1dc03e6870 100644 --- a/aeon/similarity_search/tests/test_top_k_similarity.py +++ b/aeon/similarity_search/tests/test_top_k_similarity.py @@ -19,14 +19,14 @@ def test_TopKSimilaritySearch(dtype): X = np.asarray( [[[1, 2, 3, 4, 5, 6, 7, 8]], [[1, 2, 4, 4, 5, 6, 5, 4]]], dtype=dtype ) - Q = np.asarray([[3, 4, 5]], dtype=dtype) + q = np.asarray([[3, 4, 5]], dtype=dtype) search = TopKSimilaritySearch(k=1) search.fit(X) - idx = search.predict(Q) + idx = search.predict(q) assert_array_equal(idx, [(0, 2)]) search = TopKSimilaritySearch(k=3) search.fit(X) - idx = search.predict(Q) + idx = search.predict(q) assert_array_equal(idx, [(0, 2), (1, 2), (1, 1)]) diff --git a/aeon/similarity_search/top_k_similarity.py b/aeon/similarity_search/top_k_similarity.py index 27304d3579..fd5c0c4888 100644 --- a/aeon/similarity_search/top_k_similarity.py +++ b/aeon/similarity_search/top_k_similarity.py @@ -37,13 +37,13 @@ def __init__( def _fit(self, X, y): return self - def _predict(self, Q): + def _predict(self, q): if self.normalize: distance_profile = self.distance_profile_function( - self._X, Q, self._X_means, self._X_stds, self._Q_means, self._Q_stds + self._X, q, self._X_means, self._X_stds, self._q_means, self._q_stds ) else: - distance_profile = self.distance_profile_function(self._X, Q) + distance_profile = self.distance_profile_function(self._X, q) # Would creating base distance profile classes be relevant to force the same # interface for normalized / non normalized distance profiles ? if self.store_distance_profile: From ed746d57b9757123de778e194785051d1863f9b7 Mon Sep 17 00:00:00 2001 From: Antoine Guillaume Date: Mon, 16 Oct 2023 23:28:15 +0200 Subject: [PATCH 21/31] Adding example notebook and module img, updating docs and correcting some typos in variable names --- aeon/similarity_search/base.py | 15 +- aeon/similarity_search/top_k_similarity.py | 36 +++ docs/api_reference.rst | 1 + docs/index.md | 18 ++ .../similarity_search/distance_profiles.ipynb | 49 ++++ examples/similarity_search/img/sim_search.png | Bin 0 -> 195055 bytes .../similarity_search/similarity_search.ipynb | 259 ++++++++++++++++++ 7 files changed, 372 insertions(+), 6 deletions(-) create mode 100644 examples/similarity_search/distance_profiles.ipynb create mode 100644 examples/similarity_search/img/sim_search.png create mode 100644 examples/similarity_search/similarity_search.ipynb diff --git a/aeon/similarity_search/base.py b/aeon/similarity_search/base.py index 9b5da86343..d72bc69e26 100644 --- a/aeon/similarity_search/base.py +++ b/aeon/similarity_search/base.py @@ -24,7 +24,7 @@ class BaseSimiliaritySearch(BaseEstimator, ABC): Name of the distance function to use. normalize : bool, default = False Whether the distance function should be z-normalized. - store_distance_profile : bool, default = =False. + store_distance_profile : bool, default = False. Whether to store the computed distance profile in the attribute "_distance_profile" after calling the predict method. """ @@ -45,12 +45,14 @@ def __init__( def _get_distance_profile_function(self): dist_profile = DISTANCE_PROFILE_DICT.get(self.distance) if dist_profile is None: - raise ValueError(f"Unknown distrance profile function {dist_profile}") + raise ValueError( + f"Unknown or unsupported distance profile function {dist_profile}" + ) return dist_profile[self.normalize] def _store_mean_std_from_inputs(self, Q_length): n_samples, n_channels, X_length = self._X.shape - search_space_size = n_samples * (X_length - Q_length + 1) + search_space_size = X_length - Q_length + 1 means = np.zeros((n_samples, n_channels, search_space_size)) stds = np.zeros((n_samples, n_channels, search_space_size)) @@ -72,7 +74,7 @@ def fit(self, X, y=None): ---------- X : array, shape (n_cases, n_channels, n_timestamps) Input array to used as database for the similarity search - y : TYPE, optional + y : optional Not used. Raises @@ -83,6 +85,7 @@ def fit(self, X, y=None): Returns ------- self + """ # For now force (n_samples, n_channels, n_timestamps), we could convert 2D # (n_channels, n_timestamps) to 3D with a warning @@ -149,8 +152,8 @@ def predict(self, q): ) if self.normalize: - self._q_mean = np.mean(q, axis=-1) - self._q_std = np.std(q, axis=-1) + self._q_means = np.mean(q, axis=-1) + self._q_stds = np.std(q, axis=-1) self._store_mean_std_from_inputs(q.shape[-1]) return self._predict(q) diff --git a/aeon/similarity_search/top_k_similarity.py b/aeon/similarity_search/top_k_similarity.py index fd5c0c4888..5e72e10cbc 100644 --- a/aeon/similarity_search/top_k_similarity.py +++ b/aeon/similarity_search/top_k_similarity.py @@ -35,9 +35,45 @@ def __init__( ) def _fit(self, X, y): + """ + Private fit method, does nothing more than the base class. + + Parameters + ---------- + X : array, shape (n_cases, n_channels, n_timestamps) + Input array to used as database for the similarity search + y : optional + Not used. + + Returns + ------- + self + + """ return self def _predict(self, q): + """ + Private predict method for TopKSimilaritySearch. + + It compute the distance profiles and return the top k matches + + Parameters + ---------- + q : array, shape (n_channels, q_length) + Input query used for similarity search. + + Raises + ------ + TypeError + If the input q array is not 2D raise an error. + + Returns + ------- + array + An array containing the indexes of the best k matches between q and _X. + + """ if self.normalize: distance_profile = self.distance_profile_function( self._X, q, self._X_means, self._X_stds, self._q_means, self._q_stds diff --git a/docs/api_reference.rst b/docs/api_reference.rst index 1641fcde86..eee564fab9 100644 --- a/docs/api_reference.rst +++ b/docs/api_reference.rst @@ -22,6 +22,7 @@ For an overview of the aeon modules see the :ref:`examples`. api_reference/distances api_reference/transformations api_reference/annotation + api_reference/similarity_search api_reference/datasets api_reference/data_format api_reference/deployment diff --git a/docs/index.md b/docs/index.md index 3ddd32a0e7..bc2fa525b9 100644 --- a/docs/index.md +++ b/docs/index.md @@ -172,6 +172,24 @@ Annotation Annotation ``` +:::{grid-item-card} +:img-top: examples/similarity_search/img/sim_search.png +:class-img-top: aeon-card-image +:text-align: center + + +Similarity search + ++++ + +```{button-ref} /examples/similarity_search/similarity_search.ipynb +:color: primary +:click-parent: +:expand: + +Similarity search +``` + ::: :::{grid-item-card} diff --git a/examples/similarity_search/distance_profiles.ipynb b/examples/similarity_search/distance_profiles.ipynb new file mode 100644 index 0000000000..a4db064509 --- /dev/null +++ b/examples/similarity_search/distance_profiles.ipynb @@ -0,0 +1,49 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2be06527-dbbe-4c32-af27-0b0ff904311d", + "metadata": {}, + "source": [ + "# Deep dive in distance profile" + ] + }, + { + "cell_type": "markdown", + "id": "39d92f2c-e323-4f16-b1cf-d4ef09b15b05", + "metadata": {}, + "source": [ + "## What are distance profiles ?" + ] + }, + { + "cell_type": "markdown", + "id": "e5ab1135-04bc-4367-8af6-426f07b53203", + "metadata": {}, + "source": [ + "## Mueen's algorithm for normalized euclidean distance" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (Spyder)", + "language": "python3", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/similarity_search/img/sim_search.png b/examples/similarity_search/img/sim_search.png new file mode 100644 index 0000000000000000000000000000000000000000..fe5fe146d39efaae96d720b93adce6fe491b15ae GIT binary patch literal 195055 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

(tymX#z)-Yd|y`h&6|6)iWD9UvobzF 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

jSh-g@2V!}ycJ>=OCE;S-78F$6m1opMqi z=`ts77FB&g@PgI|_&>P;utEzc>w^%M4n=SXY1c*7E$euA{iu1a($+8m$sYtbLgaS_ zgqDl5EPI^DjPIBoCkx7NgJxHD-+?PGX;^Oy63nilPHB(vhN$f9p2SlxX7R-3u4z!% zBHxsECoKiGnmv!^oFUU_A#b%`5#=^ckCh8m+_?&>1L1#Ph#NKZEL*^uK4OSUUO!fN z8&hYN&DW(k>fJEnfEXvHhKj{KfZkaW_=mtl7~IbX^cH#U6GqJ@^(z(%=SNOCb$tDq zxBK#2LwQMuL25F4Y1~%7x9i6WVrmvhs5MzmY<#f|?gbhmnm#>}!7pky+3QT9e^v0Z zz+ZesO=ciy_A+~(OcT>QN=LnlFAdS-32e?$8Ctx z->c>SM+GVTsF%?{F^?BJ-4t`RJvN+T|JUqdr4|;sW>ZHohrQoVp@7MOVGy&ZljS`g zh{au;KyJ~MI?x&%FgEm;!~k;rAJ$@^Q-?)<-tSC|bK@$=SNJ8va`3e`C^nNHn5pd4 z6hF2C$rz7%fh_jrk$5h`+DNBfU;K;}<7UM+a`ntl*{AX)iX1!OU7nibmI0bFjr>Zh z_)zxMa#v^1-Y^>H1rxHR`mOGmdNEN5%>~Jb_#&@ZV2k^$G?jgtFg5D_jHn5kMg`Nk zvX6>~;Jd}o4CtDOEX|)_SJEp}9B}|dS4^xOYpkfj4`u@e?Hrve85zIbp9{9vm_S$h z=;gU(vi_JjwR}i@P+4Lm5_=pOJ|1-aqR$WY17BdAfb`orW9oRlfj7g!W_3ycxL*pgrEEpt_AC`9irl>hs2dWJak;lng@2q*T!wxYn-$otz=5aE2rNQNhH^DY=RzHZbi*a8Vb6+4$rkT}bo7--&M4I+_U#S_CV zle!gTfp#^W2b41EWxay8IL?K#ln%CL zRPqN$#vx>x>c`Fn<8|}H7&>rAe!=sWw4&gkz5nl$Q@@kBKfK04j%Wlij`&0n)DA$* z=(=#EZAgNq0{r^+(%V;1h3P7n)~Q{gIrn7YIkok%+Im}bVDMc$&4FP6)iPbj+fIGf z{6kXQa%-LpRUk{kGBxKQAB3i5fx05DV`EA5=g-e%rvn;J{nh-IxxeI1Z{GFKQH_Ea zf1FJjRIe^C-+X_$rEYZ6+XT8Qj;kz-iy{>15K4yJFH+o;d4)6;p*!Y49&ooqF3LZ) zXh+rx_NixSgTW?W{`V9i2q(}pv1D7@hFfp{LFP7-8;;H>I?h(;$R7 zVmFDvO;L-wmn!HK2O5!w!L_?kT^}8KzSZa_aBrPfGQit@ixWY{E-er4>}l~2g{`^| zs05ECEDOW}V3}(tN{x!^IE|43P&mZ+f0zXHN??CA!ogx)POR)L@7W0wH3X!<#DD3e z5LR9qn1#GjG&y>CBY2z|ljd)?lr`T!bGG@BM*90$Z7nX`#we|=kaW`iUPBo_O#a_V z;qa%7gIv!#txHDg|3MI>^rx0)sNma<(}Su!UWvuNc52*X)P#0u503Sb;Wd;FKI zbGMA`M6#N7E)cmaou?sD<@{f@sA%+ZWSN!*9+-6U|#4Gcy7#4YjG`o?bcJxWv*3-?v?&tS*u|@3Aw|8 z#N;~=A!Dw8vQ9E=q@##ottNVnBp~(?xAQHhzXV4lY!nGS0U^G{<=FYfXdIk=ClDslJEOsoZ>r`q_W*b7-UTl|kq&V`DO^dKoI*{vKD&ye zB=3G;JQOo_$>o(`(j*wZ5_qEmw8Yi_u*h!cYtexKsCJay0~PH`^Bij)KC?L}MrY1H zl{@NszKM6~M~rrMDo5nMH<=+U0I$!U1IS!%aRBt!6`sgxA)O03k0~g%oV5Og>QR0c za5l16h&_{|Ju$4a7T=GIvv_Tn5gsz%q|PJ|&JGQ2eQRS{oM^Z`!SJqoW6_=?IV8hZ zKe^H{Tx|Q#M%qp`Byl5uWzMz!oiC_sMMPBv+4r@MiW`Z;lyBd%d6KxnoCm__MnGSq zc=2w4KCC%`t0t@2@rywX#=8c_Vb6hV0HMl#%A*}X;#?>NanAKeyJe(`(IT_ zb(R|A5XbmJLV?LoZtII8K3r(y*2zLP+K$H#<6Z9UWi6A7c-67uxxh+a$P0B2)qmze z@c&>cbqc$?I-q;}t~;7}HR7lHtHN`#E&0PI4or6)fC^7R?zy&b{ne}YJ%Qefh%L<( zaR&Jt!D6*IcP2+s)z6Q`c4x$nz@4FiQTPm#W-mskQ+JJ}aI6`V5E+zLX)yQBX5gl@ zf5G{UTnvCawAmcq9NP?taIOt^a#?67A@NIwu;vklJ%;bTK}1jWs}RjM!bdiDA3Z6; zvJ+L>lqM}OG^1Mn;1oe|{NI(Jf#ei#0b_AihS-$B0Rh>M7s+MNEr{oGFa@tg3lZ3R z8W==Sme=4)ID zy@b%YUo@RJq0OUR(dE*jC81s^$iGg}C;oVM4=bJS zT?6LQL}~D?ppW2v@Jaqjx8Il+d7PEI*v-vGp!=>UH7D! zzDhzG5zQm)5>gJ@dpd#UV7`u;2B~LDL3O*Us475)4LaA<5uc!si=+#xZTH{$QVR<}*k~Z2H>87EDrU+ps8j`S9B%pDvB( z?Y8BxJdDWt4JRYfqiFN1wb-WIX9A!Vxq2+y4Uxnv%tJ2e4HdVd61Yw{c;3#PP;sdW|p z$lHQJ3vW##7s~8q^3^C?l)(Y_JV-R#EgH4RgPt<+KOmMBvQBKOavr?m!1V*Mv3=I9 zFO*y#eHq>Xz+*0s9gL#mFLcgT}Peo)Kp{;AX$&unPM z*UkPHkIA8HWdtT>^g3blCn0}2CGP5L0}wb0`}gi6RqOr4g-tYM(aSW#)TSg3HYXF{yE(KDsAc`A=tq(;%R|yjcW1NbH~auVW(= zlO|qH&~$;28V0r*Q=IIq5eP>0knB?`CbxY73X{h%4jHn)*I{!&TeYx1gG;Z^19R*dE2=(;&bS4;zk>Myse>U%iR9!$;=Nf??Xsn8uG_d z(@y>(9Z!!6rY4&wRL@3Ha1{HG9GYuLY6y!M3D^B6Q8uVNd!7_#7HWFvyuRGC?#rM* zbiz^4rwN^#@k`zVQ8&^2g)cOp&cGFMjK3l>MEba!DSHX(q1@2?pvJYuby`{;%?tM= zYo0Jn!M6!Z%Z6c8JZ=lXfRK>({DRNqz;qxSBzH$p|HLhRh5&{3DC*WVx5ts)#(yj) z#MiduA1>0%6X>%XxqI5)q`b!@kbb{LqmU#5ledM+8H3xH5cr}eb zUXjvbQA6td{`%SR%y*A0dU1q>r31|2_zrm2H3_*#>OQmTPTJd5R+EKjUQv41!wrk@ zrM-@I(`nQ+yXhgAc4gYxICjc8siz?Zt7I-2N%e<1b8^2r%1so>YrF&t}gT#1=2;BF=!j~ z5J8=K?2&$Y6wl_>C$7GHsl=`Qt^CX@>k=U2Q6v&mf4M$K+h=|CQ{ASwZ|v#bQheP4 z!cV1X^KSS{ErwmX1x19EY7ZwRg%C;9mvSzd5tB3Ejr3{Tc#VQkZh5+zBWiOz{5RM^ z*s9Rl7A{5daUrM-1H+`NCF#BV0<@riF%D3}5-azg>V!(>*S51Gk7U&5r}*eY4s-2w zB=Pqei3~e1tvCeUv%{eiP-9;6o%b%x`B*-k)uLo4kzG{>{mDEE>e#IiRwqwHGgK={ z3z73Q-Jq^dtjcawi4W9k!nM)pM{y=(xv__Xnr|8HUkT$!Y!RRg%MTXHWxyy@aoWRR z1ER0M&6tn1oUqyR%3LFQ{p?+IEa{AvMMisJ_w5+dd3g+-cJ*7Zq2;{ zGy_1wr6z;@1JiXvF6G+E8rcq$0Vn(=l zGOZHR&8*f>J6qNOy_xWaUewhSxVcGz1;nZ>6ES)7P7^^dGTLM~ zJ2oVj`yT>YtKDSWTqQmhZke=?;qg+B>+f)Yl!(%vbnik z5w=ga2?|0gK6X?iL^J6ac67##1}5}?3QLh#msFy(MWV{EdpskX^}{hh1{v^-q$c%O zU9zQz(NDlk=OM`|0EAifNQelVWL{@@=k?a-$j{Vd2vP2=vl^~7=Nq#MKVDVVbck6A`2gVYI3p5uaEsoz>S zUI?-@wNNt1cqJHDCsL}DJGIV_>o(hjAzu9b1F$Bc{>PS}J+1KU7#Ctt@uIq0V=kLU zH%9pa7-P-^iCN|h?hF@_n7;U9i?%Q~2<;IDNz2IyTXvK$pHcaYbI?L7nCHf8aYV!x z>1_6rA!8x{-*>^)9itDyIK|x&90$Hml^c5%87(<_!S@J1%LP-8M7w^ND)2ouou}#( z?5m8Q)v)}R-@w;`mOiA^#43Uv3*-BSkAIvyjjME6%}lCDe3MyIR>{Jn^Z2>2hZ#lDKD~4W;L8wl?4Sp3l!e z@+igov~I_{t?@^E-R#Z};Y8b_ru&6%1|MwB4tXiw>{%x&USEx^iUA@r75~?IJuzv! zN$ncfim9C`4effn3cn{vns=&IZkTMfDqMLyDh9%F_k+Dg5Wil2pk$0wG$!$FR`VaP zj(c~m5#54X6aNGmCgN=Sp!5)z7ZE!{1RNSCyfs7Qx|DD2Xm zi*$!b*U}A32upLn`@1uDE`K|t%=o_V^PK0L&v|wFwy?G+(^XGg)Wa%x;hEv~`2 zI5weA+b-TT`#AWp#49kRS_9`9see?20_6^C+7f){jd)#670skPY%ccsu{RRf8bR&|#kbm~5E3t}@u^*KoBLru?x69O=veH=Pfy#iJ)qb$94YE^6?$$T z81wNX^uKfb8-ko_wg6$HAaCD_x$8dV`n|&58ct`ha@QDa?Rmh{asP&?KVhy}pifr> zK6BqvG3A9!eyB7ta#B&sqQ=bQ3x{sJ=09OcF^#UFc`I=*A)MGVR&+jS`THZY(DwmlkL#BuTR zc&=;P;4x`PnuNHB?r=v)77ol4>OegwCI2krBjV4s%aBHnG*=bx;q_%ovd>aX=f$(R z*7Ng4W*5XHu<~i6GSz=xc8|T9-v@$M7jh?dJeIIuSAqRpg@%Y^-Zp8u$aNI zvwS@&o)RcIk1+pxpx*`v`4kV}v$w(5;?FY=BrZo?YE+HY@1)!VVEW-Sx-{6UNB_;zYz7uQ2sp1NYQL^^dM; zw9k_2U^7Aiy`E@;6!`imTj8yTYn^aOF*y?3)t>$`CHj^l0jsrrUVo6nV^7!Dw_M$5 zRLfTsqh8+Q#EyvBCETFg@5MIeDax+Uj3=HbmDrrZhs+F2+K7~Z8SnWn`vRMbf1^?J z!tL=XoqlC!z@6Q`yInNxN*{Daz*&lOIG{!kJQZF1>f!E*$@qJ9e)#YWDO?-6^6jPuYg2I_t097YBOW?qwh0k^J@O%kF~3aiVzD zGg1FFiV#;z8<%g5CK)`p{yq`*OHLky?e(YnB;!|Y&0Q&V*%yK##w_M(5~22P>0lBJvyj{&mye0uAs@tGei z*r8>hD{gf(!LJ}n>~|2qw*b_Iv;HOnzRfQTo?0&8-Pa`w!LHGekFx*EF$m8bNL)fM z$bj)V%hwK$L1Xq8K`oM6HoWsCtXWMpzgnLJC-;##r@;6jHPzAB9EvXQra2NnF89CZ zda2%D;tR>GBKH73Py0eDXG4W5>Cp9vd){mXcB>Iu6gAQ!$==3SDVuXOQ^aA59<%EY zeM|8Tewzf?Fg_e@H~w7gQAyZK{8ou(GhR*Yi*So6ProoZE!EozNG08jN(3h?DST?C zw&z=m$EVa*je0k+x1F zhLEHZl%z;T7Et2CFpQ7Z;D|VN$aJ8eB1t`}Z^{01CrImYiTZf^HE$3~kr@=+>`Sez zg3+iiw^}@au`xEmHb7hu9N*ACQEZjvjlGaCD!%hzGuVNK0 z9PFb4>I%cOsk{ptd{>A6NsSWtk!u&Bq6`osc+ zLi&c2HQ}d0m{8;-C1sFHXT&1E6J4bXSPK?lA)YA(H>;784=^3kwk~7Y<-~B*LoxrR zv(5+l4bI61*daRcCUhg+kgH3RS&LVg1e1&a1GE5phzFW<^Ufrcz4Z57-a(7P!& zIn`!jX|kBk{xkZR`?)P!O@RP56XA;{W`pyTaU^Yd_6<<0PO`+cC>#A2+K9?A))h$^ zP9hfu6Q|~eZ|T-^Xx@rEC>(zQkY@j_a9=eKosWr5liIfPCz6X1`L%QXgZR$hNlTh` zpNrb48$O&bt+w=ta*yBTvW?}ygD$LhCFQ<@r0xZM=NgU2mW7Q@oG%d(|98Lb3{CdD z0aOW1up@ID=jyApJ)aDXdcw;rWL#BG)0m_QoUO`a%{P}9B~Hb&GsRP%sS^^NIrMo1 zV++G*EtLMo;9kBbEVb}|dyWBV?I&)dG2vu%641_2V)d5D?Hi`j8lW)ddo{+vD_ioS zS$E`&EJWItVc`u@Uv@G?oQHu6Er!JFf$19V#8M-Tx6Sl^gXK5G(C6*m)C)Fa9;xc& zrn3!8D{my_g+?VE0@+;CDmYR27=QJ9GD#xZP5p^}P6y{>=AygI?E1y{`^EuvPj4Eyyjx>AaA4da=?L&-S@!rw-{vH7!WKou?EW0U!;)AWA%9vk^44u`Z@ zH4f_|DCd8I;ty?Yd!C(7I@ASY>yhJ`s-fvRN4ew{$C$z?wsHGUyo`mkKhclr;0({< z&bT6NOWKlt-8iAIY`Jpd)tU8sCPi|UPBG>A*+_vGkLRzk-~7^%*DNftV#qjR|zZNPZNNHoie9cg2^8;NdQ-8Ay=fGaQ zeI|})leh9AA%k^aRx5$Z8B%;a;Z$Avf?N#`wwMv4<8z3&^Z&^eO(~Zmv6D%mHBSsEKd>`xwVUrEpeDd!=~>fih=K@5#pTd>h~8~ zXHM6y88BTje^)Vhyi=Rn!Wi~sUR!d`3C{}2HNU|z0xUe0+4&yA)WS*U@X~nJDP6tx zli>}m32=3H-CO*bdscbZ-YY*f#$eW@mhj{tkz8qfi>Hs)#r^_YW#+#-}S zTI6rv?(Rx0-gr>?4u+BDW&%fhpSnk!RxKfCa^|QO+9i(c99AKTPXPL3A2Y(Ox3KwY z7CyOCBchA!JS3bPD_?z1MaqkpbuH2eb%G^+dv%gu*zXg5kFuLWSjxfI9;?^h@s`Fp zEs-@qES!<@)_&WUqTpF-OG6K8W2rjimAE0B7A3HMe9^Bi)K(;7uHlMzO5&Bsj}#-8 zJ8GKIU-VP8d??NGNRjftnMIR>qr4^6urgoU1!8jLmpEDmw-TGf>mt)(L-=f&kN!+W zC1n?^+ZddK`yg-%vh$^SpWe@m-Fx1?_B@!O_zk~1OO5a7Ku*3ola>Qhm7(lqrZl)O zel7i(I;#i->eT4`GtTmA$21-yT0O?dj5fT(#h(vonOrIQ#!m6~WcEHa&Cf!r^{#>R z2jbAouK%W2q4sKiNBOKuJ6?eUI%rt2st8?$b3?PV%v%eO9VOJ(J<;z|U`Q z)*6oFZTcNyNWl=Yh1Z9@J;l*4auZo*Cz4YFtX~zoDkWaZO!Wn!Rdq_23SW`Dv!$-FE{|0HuN`D(pA+2u8>CuGkMZT& zfS@64-MJ`bCMW`H(%`2&7BH7!?C-eJ)vaA&yn7dmSsW99@{(Jnhf-I3HQz%=4OrqJ z>58l2!&I<%7hA{AU#UrG)GaCvaj+dQopVPF+F(t)RbdV-(_C!E`%P9Kja-$fdi&oY zzAp7(6qD_v>v0}Es(5z=60DzqLo*!iuwcrFP(h==Zr_~oh*$q2+*(jZLUcFFq`OE^ zOh13)rnC{J>~8)oFNEO>7vN?lY&i+6t=x04kStV{vjH^*z$9BrnXEruCxO9H4r0XT zY%r`K6A*$jrTg=Sp~>?H`noNpiPPNyP#OOipyh&JZ|6OKT!`z{30K*=zomPXE~VXj z6yyTEeiv435R?ItP!I&*?(@IT64pT0sy_&k#Yxg6`ucSDSm@8qpR;i&efI6QVD-6c zmw`{-8DtyTpz-1dYF8e1{2PEOfqRQ#&;2Ax;g}8?Tp#bhQEeSTYX0IIQoO+6Nkp3; z%LGPFG#;32TvRuCbYwrUot2cb>*-j!Od4K`>qb1gAJ}-Tc?tC@|9~^^o}6wNHBl8{ zUX$$Ezf)ery3{P1t+ck&+1n~RUdrrB_-POk^z z1Oj@6R<8eMu}4h(9)my6aQ}v=f9;XPsk&2$%H05lC{QR>FZkEXDPSY!?^;7-cRx6J zCz6hrJQV=Xo`$A0OR=A6I!gkjGlY>nCJw^%UDc@F%7Y%VTK4E|F_1|$|GOe+HKJD6baaYSV-Hm*x}x*9&58>EwTUnyf4 z9PbviJ^2%_t=r_+vO6E74o@$CnRQ_oj1KPUw-noJ5Vnzm*H%Nr-OlVy_wU>#I)dgP zX19W^c75?EHBM_xE|N^yd(EoOv~1Z6eew7bvn?)19`F;NB^bgq`)~%^Md72O<35K} z&gk^X?Zd|#*K6+QJ6Z`=*Ato^yH#Jatn1a|@7%fl_eSoe_NaO_f8#~$!b@{2ZM(+p zSd*`e0&io>KmC18*)yL^k^mdteJnu$l~H%j=}d2Vp#GdAeQ&bcM_bZ&zfvCE0OG$9 zY5g)d^gkNi7A+`adSQwf26t*`_VOf^)=V>>SQoDX%KfNZ2Tx5Qq^hw>ib3 z1t~n-ndfgxazM+vP)}Vl&$FRR*2*?Vt(~M~$_>B_r~$~go_sdcndoA~oogTXPP|3{ zERaq6DQA0twOE(~R(CXkflV(#keI)3MSKK5o5tQe@}`=WSjz(n=I19Q*MZ*_ z+}z3b@0vpJ}FblUmN|$RZD8vkJMOA4)7)kT{$yaOLwj@7jG6Y>mAS zF;hUO(sJ@(GqF^fq=G#-t9#0~};zY34P(j`H}b z1A!?mnRz#{^Dou`W$w>`K1RA*3p`ip_cp{zOBMz1f<*M1b$;RJ53}}f zy{!4EV)aNna+^OC(|O`0y*cV`QqC#l3{0IyI);vzMLhv1;Kmi{_wE&ff2`q&X>= zj*dh%T0@+p7A)PnP>+X;bsjxl;0p{hVjY;b@=*@I-)soA>IjLh6&Df|yTdvXnk$&+>y$%x%i;zs4=dXU)4 z3SXr{e?gCCf1$Uk*7cBi3HJANTqPp(6PR;oz z3cT1lw=iTtc$r-RF&stR25I-L`HWs{B*eyw-Cov`E@oEPrGu`(aJ-zv(t`#$1+rik zu9_|}OS;Qre#7iu$$QH`{ZT zIFs;#n~y6$4Z(7v0kQ8At^0!1n=16EfktfA2oxrG!Yzf`R76lXH4Q?oKGcbFe%q*R zV3xFsGs$+rSrVzL?UeXLH9unw`|KlvvE&0k7J&0M)s+9f8*GyCy$FoUGH8cM>^`Co zmDW=m@O_Vc;n#wpoev$}#<4Z!q|S%$^c#3ahVr@ks%aSlO`!_}0JNd)G1N8ufZN?4 zRcwbbU+9q(*zqvr;EbO6AZq37WKwU3+q~5YfIq;RZ;9zH-W&xW-NJ^R^6NFX?4s|& zEKNR~1aWJDOU>n+#)*1AXRyXm$~oLpMH8)Nh{zS)o!3o=qa~HB042s=YckSeP%Suj zHvirv2yBt7d&%h6??-!l+y>`*vkwcE!q6axtq}n&vDzV>gxVB5nOU)xUDgRK8^q9* zy3;Zv*<-ZP@IU#(^{xzFe3Q7EikN8e!AUK7$8ZSLwNCYRmPJnAFbS!lz#mLPi<<9ZLAI1)yq5KC2h)Ct1&wamDGi+&;O^;*;k%)~XwmnX^_g zUQaqy#s2@Ic$*RN0W)On&<16+QvI;M zgvkUNfgOP(%l!KT)bWg0zuhA@T?eVY*a)u*nUtbbxw?cd9rY09tt}_`7QAsUB~6hp zBVU?Ma0(fW(V^NZo+|e;(*-CR2OO-fQiA0o-)Wp_UsHIv6Upc^x;A~2f4 z31xQtn9WUDpMezDK}+A&3C){f`$rowxUlF!w4?BvA(vSzGV(yY`KZdoeztcbVe-bG zu2!7*y+b;;@WnpMT$UOZ^S_A2t4=nL$@mUjnO!{f>b`#U;rax0H0`^pLEcd9tY>0B zJUX-{rvunFF0w)c-}RqgL#iiTEr-r-axqZebuHqTA5}rKqr}X{CU+$|V!^0ZmNk3y zJyOV-SF5-q==Q+7{^rX)_+BS8h63}x8yZPMbuQTGyWK?jF%;oymHyjyphD>H)Z2^<}+)aAx5emVeQ=E_W z-{vIHhCTAEmf>l;U-d}5-p*oK-$WJ7JT#oh?2&bI&I3}`@?@9yRMdEcqd09Hy~yEx z*vy7;kgAm6G@)H>@+kWibE8+FQBLhgc7{L!Y=bKdor9K^;_L=Xm3OnMV+7j1QDINt z??!B)F!0EhjShYbJ_a3?1>3h*8%hA|C}_CL*6TVXO}h8@%@Bo8k>gX2v zEM?C;_@y&-%zgFpeq_-f`V*bOv-yY3fzGdYIxC1ekAA0D=8vgY+kv3NQAZ?!6}YQG z%zftO29FS4>oYo1vzy{2qV%%@{zx2YkwN^Khy~x)JM~Df$7uBf!psx)NoI*3d*}f9 zkEbV*c|N_@l!xX=+pvk?J-mrH*K?HHy6?Z{bNiuo^3|?pQW>v7S%Y_ef@Ml@=oK9& z9^Qp{u&S>@*?eC&*+dUGl>E1K7+sEdU)y=qmA2&uUe&7odT~DPHoppNu4jQk7i2H+ zic6^P&6Q>eRY>!QbX|CCMs8ehzI0k8X`w4%ERWp5CAYt$ZQ!?_5DvlsD-aKvu*sY2 zF0RxDZ^PZpI{mm}Sm&6W0^4Wf@N`$^SlX!lJ+E0)H-Xe=a%1Z^T{Dqf1M9e zKFdpso3;1(&{^r(=LjWz)#oG#sgflm?9=on#g(HF)H>mhEzJ^~3GiS!plOr8yfDFm zAn$YOz|T51wfkhO3#e}WV=sOSR{gzX9Pa~xTU~-5^V%c$;r1fK{!Qvg$jdtF;;*vI zcdlk?`vGXdd8T673(wB{Ed~5|w1O5zdv;~WOUFKWlUs`PO3<1f)w``X%y9}Vm8`5? zsE9n65hRIAIENK+?uTow4dctCve8YbBIUo|8WGf$zNPH6z(~2p3orGWGeb(LJ(qP1 z+>HJ!X|*J?A*2r-MS!6d(mD-NO2!hr1qE+HoH? zL)dj(aU|GC1z=3PAxf}cryx}+C0Q-g3E^_ZW6T27)FZ`NChrD77MIXye7<{#dN zocEG4;0GXU`LQu2=~@i%V=`yUI{SjDwJl<*j6uVhk2wVM-Lh#J^`K{3S^L4IEYlLO zEf-Syerc2YXNepJ*eM~Z{Vzeyl1j+wohc3_V&tqMkSy}qP7VV0po=eG8OYWzWdt4_ zAYY5>V719L>x$ei`Mg#VR6e`q1B|1?tLH1or{Dg{Y|RUS9@XFcScxZqMW6$^zZl-b zJ)f;dZS13)g&5?a@_)OIJ|nBW*Ff5o1JTX=nFs36W-kZV47rGE{+NtVP`}Fe;mDih~YGo4AJ|3hYK@REXxtF*1B*Zb8VC0ad z{&0_qB*~Ov67q>=>J^Tri)hdXe8XiizA^z3=!=G6^_4k_@UEmNPa7V0;g;<# z^bs0;Ge+l!OZ}Ub_X9nC?h0v}Jc&*o;Rp-naO4QkTt>^-57Ls&W{!xy6x;n+4L(|3 zY73)sw&P=(c{F+P^X}Srm11<`2}n1t7wAa+Lg|T@>r zrUI&0j|G)|&p4Iz&UajJK}Tw7AoxrD-F&Ag9NFE90Qk}+phX7sMULvFhT12AF!~3b zB-WtgW>d@QT!7GF^FDBYE%q~H1);KWk}x;W$A_2ItM&T*=hx06M*Ge0QY;&J$ZkVA z?R3l1D(noag+5<$5JM+?{}hD?fSd|`(cU;2KzWC|Cec@M%bu`cQ{J5Q2McO86F{Pz zZwE=okBBI;7~nUq4@U$|!&RMM)PBF=a&Vq;SoS${UdM$L+g#VoSGW!i*(dI(*RP8k z4|YWvi)-*flw>>OL87;Y+v!mB_Vk+g`=x)mKc92;i<3hcklF~Bx;w4xG;poXf_q1#-=BwDQ}co{ zkK%F2XX@Ki*-bo1u1x#;&9nQ&+L2*#@X6!9@X51Q*>zMHg20sPiHv9nuB=?WD)K2C2nwbq-Ju3;FSy!RG;vg@BQk!)SD zZ_hf7e=W&u$02pOT zgc@oaN%wHg!kWX>FsgSOB_sETY{dR-3<* z=iP*#NytMiqr43774=9htaOmhJj|gV-(3s8_`>n}a^LST7(>7D^gVEs_7ts&ulC#& zkE5h}H)gkX*0$6r3q2FgjPsmGyA*sqKdQjw@rRod!=Wq&1ww-YW7y@4teWZ+efV8f zd^Y!0%^qnos_9w!1TZ>}6=qu};j5x;kjC`l_qjwj3WlU~ZTtTjyF6wOi_+&E)uJt+ zjIFbY1beH-ZCnz6rEuZ4xTuOI#5O9Z>A9?;<%s8l?i(GSI0#NE(1;$T#|-S9s)uiV z1!FHM?aZ?L@%@BeHg|4k;;(YQvjC|c+(t??!-i&H=&xL2Qz?~ z#@&5k=F<66mtuhLY0KZA#kLw-@N9hD$iRzUl%xT7JiJ93oqUIXuh$s$FRcwpN*#wI z%iV?1+@cecd~P^mDeT-(`}24q=Npg?)NXvOXauT25_o@=O#0chP|x?CUJy>!9P2a? zwC0BJn!FBVBXQx~V3_XI+bYXPQojS(jZrQ(mAK%?tI?Lu>`j5SNRH$<@h0x*%}G(U z8Np%gVt-+ZhTBHG$6O|jO6!+_`v4`^H;^yx7@Ap-Hkq&Diid}h`vT#H+nsJVvwSJK z%VEBB*}VHL>z&?jA1U%r_Yx=_$Nd)Q#S5I&VMBJU^*QlKx)^AvrEG|zNzVMnAFR;$ z%9PNToy~S(C#47Tm-#c;FWdq<>VFps9)rh6XQMMM0`+E7lzGNgtqz#R|HIy8)tE?r zub4m~h_(&zTTmmee&=v3`0=zq#D{33QWSpqh6_5aZ*VO-Ux_l)E;)aI^T~&9QiZ3E zxI-|z*A8)FP&Is)95AVq=|7p>*Jx{trst)q*{Ma|_^>=0H=(AkX)yC#p+?|%==^?D z;nn?9puyBtk4V_*7a=km;8(y8yN3Dic_k$gW%4ZQP7W+*X4m_~*utL(QXP@TpD*2U zauXtIbwTh?$gw<&I%n!P_Nbqw?p8Ag$g^%hn<+cv3p4HPyt8#*Y5}P~ORg2$rD^ug zV}DD77tuBDOVVZ>2I>@ekms_7G3!>|rLPi_6P*cVWEhXCv z|7aR=tMmjf?0P-S8TjqMJ8EsCPc;YR+`@MW3M$M|lrlYR|E?Q6Z0orUTa@VC`AcFs z?1AK~>%>6>eSZNgjYsFJ9#WC3e`fF#Zt*n3(%@5KW|0Us%zRag`>{VZ!I7m0(#icx z(V;+WmlcE)lt>bGKuI5(_vUl7{&+Q9ik^Fee!SBSL)PFjj+M>Qa9xDJQ}DqPKMrx}D`iM1HH8SqjpR{U)au!n!iGy*j`zeHcWG z@c!-3$?Iwa0(glX3W&(4S3Tllar`+sw%eIDXB%F z6N-v@CWfypKDRkjh>a6}`FGg;M4f4FEW3IW4bIg0$UJfinh(Ba;i#P0{%54taC$e> zg9%}NoFzjwR2P1kh#m>5O~lch9k5BRMYvzWIGjG@)KXn$ip$ z#9FW7W<_bk1nzHE;g2&e)FvXc>_6B`rLn6Q?gMOE0cx3GJj*4}KljD$xdlZ>myhS^ zI~UZao1{EB!JM`nQq^7to*PB9GlwMwq_kGYU6OhqBL}sdR5OTwS5FJb`q&hG<14P? zyQYWImvLCl%^fHjSmxsAkIF7Z;9wQ$tvPcYOn4h?eP$HernEgedQ8M znG=xs+-}}}q+drxTqPp-=8)b+m3FIGQ^KHby81jiX%_@6!o#NQ#R$Xp@1#^QObMEb z)%1PqVqiN(k2avR6h`;Wj&!O#^tXYXb!BFLV(@d`D+=2M#>T#iuk;~p&dSD3kbrBV z**-@su3AaatqrKt%^l-9SGlcL&(SyF6?^Tp(Srfmv)cm|E(votvpJ&(uM9ko-Z%5s z3gn!oGp&>7!_|4K^->Jnp!ci5fRMqVfYs5SW&7u-aaB$n+l;2+! zwLEUr9ms_Yr)xKvL0q7)WvG3=la~|tl_HZ`<^Dt{_IQ@r1%D+2V#z)1{C*@znr(|q zfoj$!G?neJpT*6E<9-=0=A zH0%lq$^7rdY%k1Zg(e;Ge`lBeywYI$53-kLfkXDn*(_0lC3*S7wuBC)epO*!np+Rw zD~q%z^wYl*51TJRuc;=;qAkQUM}O|q38oRWXL?O!xAL|^!lX3>L_Hv8Loqg@trU(I zUcIG%>>cr*Tf~xaPuzI+njdY(MZ!*l|Ah3pdzy#HB_#e)z-ifQI$lvs<#Va@=eI5f zL0@)xmIYb!lmR&==h3zvsN9lMyn1H3+05Rsik7LDWmqERuw;dna_Lic--r`?bEB~M z72=z@;w89ymxONo*Wnw#pBLU+yxq`=oYxnhh6VF&!_4~>WL=lAQy+()PCWM0EiK7d z5@#gZ+Lt7co9rao_;*51-iYcm7x?|ChnjOxb|~3-(I~>bGU0xJLG&co!bsLqq#&)J zBNJAmkQTED7h$yRiDW6yixSw?e(ZuT@67^jqhhr@%04b>pY*#jU2)~JejM*YZD?6eMk z*|Ne$FM@6mwOZhi5r*zjmVtDjvzg#(zAnQu>oG zgpF^mc3vJ$5#?D*E`?3xIXfH$xX8$5QiC|1H!$>S^qKC?xP|Mwj@Ml;(pFbFpCg$RT)Q z3s*dvs$CZ3&~|GS2eVn6J-^*76;U@Kv_6_=>Gv?AKLj6INnD?PPAT=Z%Qb>hvJW=Hp8m4WY4=dQS`-Gf;J8zJW>AcM`DJMmYLV*Q2t`_~Zpzr6jZ%DH!~cM!v?dzUW_2kwHC zAjxguw-=r(cGm^fz%cZv_-J{Sh6b|Hqz#c*GOX%&k5x*~b#yqY^E?X!o)(t<1hYi< z@)Nxv4h~n-h5yk^narBppG9p^z6@ydH)>$IIl{w|0~|zd;ArjeYHw0pFXi|qE9Jvk zN`nt6HaVUDkSAA>=weeeY3R|7D_dwchgiy`W+_q$4UUIPnKIm(!SP?P82Axgl_>Rd zj=dJBzR?4<$>>iKVyEROEdEv!^x{Dz_!thF%s)*0i_HW(8NPohf%smUc`9U+b4^Lzw4tXCog2UbMXg>g#Q{GpvUe{Qf0P7m3ue z|L76LA^F7{hinrN5VyiBpRR_{SUqDFce|Oe$Ee1-OM*@wvzV$F^D0g3eFb!@Z$ZsM z{qC?uG^Z?{ttbht7u=lvBS+^+fwAdW*Nk?iGJG!R1n+!ft^EgxSe~T3dCnOnD(Ykv zj4xXk9AyscjPs`JcBpdv6bUGh5S)Kq#}|g41kzZe|3>q%*G4QY@5^kF3LE!@8D>O?qntp$#709msQc``a=W%>_j(D7uq*WY+tS=d|u z4%$GeNDnVB9yE>R>U5O>RPch+LT{ch-TwCV2Y`M>fT<3J%)EjF1RW`?U0fX#wV7danVew@h{9hQ&;z(Nm`EF z^pD8?>DHL`%&M(Id&J3j04g6a1JGCJPG|-+Y z99;_xQzWovKm?CHB0PDhb*0z7d+WYa5VGU1?e+Q|bLSCsZv06sZHkFQnb$3IbxOa} z8o@i;!6Z%eVr@@oJAGk6G1I3|Nup>zfVrZcL;7vc!7g=T3gu!^)MIaflRR^lCNZN6 z`H%rl%CX<6j4}gngJr*_jgEL23UiVA18rLX{F;)atO~<4^BVNGcPz6~9HlO&ob9iy zduO&O<^a~Kzw{Fl%G$Dmf&B9Y+&@WkwEC^E+g%-n-%jR6L7nYTSyCz@EP49X*gPT+co2Wlh{sJLnbY{3b#(%zn@KFK3y}eF;eR&Q?-zoq zWaxvH8sqXzroE9zTE?O3N39M--N(-nBrAIl7{6Y*b(N$%2 zTz%9PsmS!x-k=fhTJj26e7L@ydm{1v$k<^~?2&5;0c7Fkpg(xqH;1+Aa9(&o--Mc6 zxh>vrcd-U2;Ys++o^KPllh5}vXM~O!6gsYz`kT5wO+JaAbFKSTvtEs1V)^*8>cBWg zP~H7cuOKj{m@BB43Ws@L$022~ta zR^AyX?zi-{pD+SrX?Y%PVwfwtPgHQBT~UV;B{&e8iQXB3F`+g#nE#^aR1L}?PU&Xy zbKk-Z^MO)2I^ks=H~FyRxca0RxqJxJj^0-Y6@^9lCw&<_2=zye{l%u@QOhST$*^EU zPQ8bp(z#x==#;%XgA3chXh$C^)%F8zVEi{hh^ zH5cut&|bd#ti0+N_d=@*emJ2i+@pB`s&d@fU+HCDFskTrlfVUaB~$BOfs6Z-X0cVM z>(DRwb+=RoFG!^)flNBN_QQL%4X>VO8%*3_om$GLdwwgN{1H?X`Y4pY2?)`K+*7g& zq-1@-1D5dT+Hm$08$b|`zaxYx%{p%V?G@|5rB>rtS+u0Xbt1W++n%z55_5B~tqqGe#JoSbzL{|5hLqyOuAn{h z6rNpEB@nwmR(8YdHG7uDRzC!_SL~Lg^K0#Rmt%h|(7RioR?yowJ=e*-Z-y1d$2Spk zc&*n~ZegbDvgcmtsW8TmOZUv}#_iIijeqYj{ncIibOHZv$N;Q()~5MRJ2qrWm0{u~ za-5+69`4XE1V>$dT;N{IC2NFj6#QJw+WdG^{G$-*o85@KS!&8_=;;K6F%ZrVltfz0 zI&h9l<6%C!V=IQpbhl#j2-2a-=@jA^&-C%`&L-hX5tuI>GK8!)bb4?tiZ$dee@2sm zQd=t2=|Rz}v1W~F!0;hdli?nC>>0WKl{fNqFVluiwQ&PI&+_D^0z`~E<(vr1&CL$l z4;{c2W~Vl>*IXj~u5p$5_!KzmYQAJ4v|(1Sws$YYhb*;`P`yRQ>$CI|Vhsf2E1?Rp zoSJmsW8wZ-FJb>C@8AX9w)L5QTNCP4cRmGbU5d%^P;IMVd>iLDQr9Cw@_x_S@Vl|$ z_F@?O-SW(B!6voItg?aKIW_ry?IdN^U8Ab$X2uEUdG5ggVb?F;Mm|yeBM3T-$?p=% z`Y& zV=!r37_L&O2}zH#TakCNIP&F}lUv~Hu<80w#2g=U6Bd6gulgER!@M`P+NYl<{*aAq znFuBKEO~FlZ`_=D%1w3#diiSxFR|nP)yuUPFm)0RN9OGH$d`LSt%FI^LXXcHWgcaV zfZc|0e?qy!zs04LG^u^(nNfk=%?$waX#mqW+N=(>k@?ad(l-)KrT0Giv*m`+^u?F$ zuA%8C@{|b?crQ-M3cp5}eKS5FUy)x4C>`b&?;rQhc;hx5sEd*OOGHf319hVF)AJLpaN!)sJW6SGV(CV`7$^7Ndyhbc;a}evQqbky{(}WW>7nWT>~zn{ zq#v|6&~5OmMn*rw3pZb$GVOgZ%-p3g-{x?K?Aj!oOkQJ4avES>1+a*;vPJE|XS zZ#73aw1()$HNyLQB{HP`WcJ~Q{Q7x{`V(@=F{iea@o~puz%S2$e_yJ5c$SOaz=qYo zM^eAr>B$-#VVE^c_*ih6AOSE zHvc#nyMY555}{iwJd{pLehN?QM8hsc#PM*m)97SqqVN-P0o6hHzF6{^Y)G*bq{x z8}_`AxFFgaH%jZOzkoP}Pm*-)%5Velyh>S`zqnT+JJLf5*a*8E$o9%02$HyS9lL+j4MO`50 z{NzCjX;+8K;&3GDIV(QD{!SO*#?n0ZT*HMkK<5^1+roZOfl@bzw#@V}SU6$5p;=j9$+N`GL$uo=M0nfaRO9=~s)UrsG$3ZSan{_e{op7tia z_e%W0h2lm;YMjeRDI1>)8oxx-;lRfD;KZcQaZZ7|bw5$h9%RoXao=Nz9)U(%tTbZ&lc9x!xgN61)oR%Nf0a5czVpxtA5~X1q|Hm?CuMbb6fu~y zB@MxD6tM(m8cgu+IPudSS>#Z4Gh0@rMWp|3Bkze??sDMOAJoR(`D9h&roo!NItuM6 zF9OH`I`q=4yEd&x)o+cu-rRyOI8}4~4v~l^*5=`B#Z)ExJ7v-kgYzwgRPI->f|~9Qi)g%1efi)9}&SV3O&N)1^!qwvozNqLmls_e6 z;{bSG#*pXT)3j@?wd)0?OKTn>@4nm7Kg17xT}MhgUYkE-0s`}U93oXcavmbEaj8FH z+wV+5A{AmDPepoS1Ru~9&sP}24~+|Qu6Qo|@_q>DgmhuzzBrUv6hxlpK7e(Ui&ce} ze7&o8?QHO++#Mw;y5P0sV89X^!=o&g9d_E3D4&F6Aw0@@0nCE15DphTpBMzcP6Rjs z=h?g8Cy4T&gZ4MEUPSfK>R3Em@d^IO4)>m`o&bup!51g0l(uV1R=R8M2W~;PXv|_3 zSz=6@u!`=mi-@aQRG%iv+5TnA(LB`!>?`xcU@jUM$8CX`8x?m1UJ5bt#$hoXp$mkOXoc&MW1zJi^2)*w@grK-fPaZ?ghLTV~Uv zTfbZTl0*@g``2!_u^hSuxh^4>7xkQ;1<39~%wPlgmiLXoYY3vafm5M(F$$c5~fQYsY2ODKZOgfvcH}x;IAm4q$~lR-vJNYl^za5)Hj72@@50Bnbyvu;6F1DlLo zKzdEXg zcftF(+vThW-ITZ24qQ)WtM|{q+H+M%p}p2#C+&n9ukzq1HDlw<`+~e`#la99+`hI3 zRQc#AyT~cNJJF;B1_rqyR0axR#6Ql=J9$E+sn1?)Hf|0MD?ZCAoA*6#T;mW~#T{Mh zKIi#?ICl$&)=;WYe|Ytgs5MJ(rV{z#3YA$86-%M#m11-@DHFS2ENFW5t`Pch9glsz?LW?X%yc*K`|DE|`a_3yVwn$m#-u9V4CN2#kT^va(d$gO4|YtI zjoJQ-Js%sB&QuRqhddW|);r9w$iLnJ@VV=VNm6G8@iS*D!$`vQM+H%+SuI9h?Swl7 zI>>KMaMU-5=#*-4Wo+qP!uL7z%7LC|WW3H(^tA=+de?ge~SEcJTdfnAj&;H|RWo0x}gKWuwYN42xtxFG{$uO*8Q1e7>-(C(c(V}B09 zOlZqxZ^wB$BwZcbvFvOM_{gpMa-Ft!EHN^k;zjsrYwOx)B18)0nPiB6%6kKY$T>Vn zV@Vj>udD~04on8$J}?@;m+%xF*uT){A6lweqvx2i+{Ij>^|axh-+$^Id`LNWt7(-X z>l~z!gdHYJ5HqK$>ydl^`&|Rl z&GGf8G-oEXpk}hauwA^Tw|%z1%!E5nz&Y|X9}iwKr{^f170v&r{ZjufcLJyotN#k3 zP}|-i(ljzT^2FSEz?u93pK4hzrUe0G(#09cSgea(X>P%^jhTCY4(eSC`8YV_n8};- zri@8xRx&pj#`Op9|J%y|X)I@$P9pgRLY(JeuE{gJ%5a{=&N*~8;|s8BKOQ&keK*&s z=ij)V%JJmGC-$@7hj^u?SA@=js!rJ@#WGaS?v!A-07uM^i-mYOat5PhCOOY&WZEgP zO0LCf&_hH9dciUnI`lf_7ojaimoK84C;D^tXpwQE)udWYX=aeMZrj$if@ zgYI~;KVZYN=EUR%ZAgz}{MpzE9aZ(~AZgE?f9QCfk%$4;=XEw1;`59)Y(*@?{XVOR6~sky{(UtYb&^@rOLOi2sp=K1&-uMD@c zup z4!w|_?&29TEC5BnG5UO&E}94O;%)CAXKnjuKPm>Jkt^)DR$V2_Pa9I2fLK$(4ZMxC zFek+sC~a(Kym~n&Vy?0Dzhd5H>#0XWk||-53MVi9ls|&XvRog%G%Ln0s6L>eD=*i_ z(L5mo_Zj!w==iS16ic;&&O(|{?2u^E2OL9iEx%`0DZznH<=Z$~8kliQ+<99FWlDV? zCiuiC>>-sH?E?_fgDbCwhSFIi6FTrX`BKt<9Z8q^in#7YkSWa_nKC(yqKtvp&$ zK0NMQsZ~*oSYe(b;+6J(J14#b*;!-|Lrs@iC@`Hf`_WK;QGEyoHA!qtmgGr&!hZTl znDa?=>;a5q5s;h>-?Hw^Do$`kX6_oV?WKxt)&Zu*1eTU zuI5nlVJTLDER&W;LZ7Qi<}~)r)9z|7x|cy~U6mPao3}x>d%IxUiqQb>ND*n)H4pDB zWL;ESaSGZus#p-iR^-7Qc-xKf1DOM^uUKqke0oHLnAmXyl*}gVsrQi&RYet!k&{4( z@u}4CAHsu@j9tD^wbCOCP(9yJaPF`955>yYy=`wnzW>P2e7F|-_IhZ}R^C2W=1jd@ zTd;KQgZ9Hcx~JN0+F44GQLl%LzmY2?PJXC3XhvI*sjdmtpZSo_?s~GL@4{FslS4a? zM3Bgpt2gZb4f_!*5bd!fL~6HP$ndqLW*~HOSH+-i(a$=SNBO?8VOe6%wtN>Q|M}OJ zpaVoDJCFwb6g@45uaz$&hOa`|a;OSKS;{_NN~MEwZzG;{z3h;{Q%KQJDdE*ae+94D zEi+r)a@QPvj2$t*kXgU4URdPc%4X!!{O0>!D9sLoXiSY-Ii9inDM9oA= z!o#zJOhVc`bw9k#yD9v=;d9puNLKLb`B3b1rHQ={sEGlE;i$KrDQlm&`7JjBmCexeRGO!qF-YhKOo}KsGKv~@n^`HV($dl;7;bkw z7@tF%mwEh9Mlf`3b!zgN=sZNIQO(2Wn|F{`c;d`j?{vibz`0sk6w%3?`wLXEm3^kf z=L{srP1z3Y1BQ>B#q4Ffu4f+)wQSx*@2O$hs8u#9hlUfcxI(W^qmpBWkZ%SzzVFcv zBw8uEo?M7c@W@-E^NFrp1;D)IT;=?R3pqhEzw3i8Wchb**9he8+J$o!P+z#EJeb$1 z=VlTVvscpK-9M%4R)FgDW9x<;Y#gSVTE`Di_``6iQgHd}-n1F)C8oy(E-d zdm|9_xM{D|+hqv<{aanHp}Pvd(Ny(oXvFqAoW&etz6aRL6fntfb3J>XC17*Cl#7OU zFT?sfaY4*CPC_78oA_18$;&EoY@5BvYUOBkAj6$X9V)QnxtL5F{O*0}yDr5ah#AUb zt|KS&hQV}shiT-biWn{V`g3c5QgGSkBgsMZ;AMqT54%REbpY|o9C)IRLMI|w0SZ~9 zG4iK=f?9CW22&>y@-VgY^Olz8)>bekBR$^NyS2W4+gp-6D9ox5wvCpIhnU;YrD15K z^`*oggrjLBfeaxPh-gdTiHs*8Y}}XzdEr9gK0uRtM7Ay-B|{)>%t7wsZy9CPOgak zb7}R49M)|;mN;QBbyH1V4>n^b^HhQj1 z`h;R|X6P@qIx_`p-+n}AXUR8J&<}-3g%ZB=aw=%Ln)viXn}x*7c3E5F`Wy8p-hC`t z-n2Otqkxxm#b-cU4G38yN@FY;KTf$WF1e7j9EKc!$@Q`BQdF@)%%>Nq2pD#{9Xx+y zd+wmH#hPbL0m?W$akB0jI)YPf zuW5^{68pqF?o6F}oN+z9qrOr1MYyYK(mAxPR*CsXy;X4i@!Dt#-aR6&)CzSwp{h8I z4DwyKu@&r-{!?j+m~iIr7+JBq1|sZ6i_>cc~7E!+i>Sz>p64Y@4Lb)?=L5cX#YJA zrpsk6c60tn^--jbY7j0xyZk|*Ktr6DW?dR4`o!uOTTJaSt?_G&@oiHoM=gGN|LMk* zijj$pI{!D@Vvima9lw4rqlQ{&rQ?fUY?O7vEOBsA)i;rJBH>dq-9Ow+J(KV)JexfLp>D+p!$afQZGxk@gxesMyePPcY@~9Ob zSX$;s@h(JAJfN>)Lf!h-q9thZu2%IEI*itJtwpWzp z%e&LXrKsoMRdt)^(+o$l<(amI2hlyThN z7>7p99v_LKx1oparC(4%4~XKdee6ennODw()+LC9bpm(I7a{#BwLucnoY&Fbx%01b zjs}iT8nM64vIz}8p;AiB<|*%&r<$v1#O4^?d5~P=k3Bt>LdRO!UVWP1*a$6Xg!)L9-fiCC0}Y(qO8Pcfa_o+jWAp@ZpX z9V>;dKN>f36g2hNw2Ah{I9o-PYZkNL@+l}Rn!LqBefJ;-j7zk)4Bg2EvLDOUPV~f8 zP0u+1YZMK{RSqd`eMW(x79lNO&B-=LpZpXuZCn(hJfPy4?Th=(chP8YLXzqvBoDM7 z4c+qTj&6`J4jo*pl@NK}EoT>2YZgztLv+VH`zKSnk0#A z2X+`2m~sl*@Ia5U;UiyEp%1optw%#S6n6vO>#(soe)WG_?eLh+sB8eXvDwukOvt;SJ2)Pwfv{uV-XOVK$J zuLobiGFX4w6pZF(dpweFgEH;Qev<2h6N=?lo)eN0G?=`U#em(@2GpW(ZC#BX42 zq$?GMCx;8gii`6O@I7gj>WNAdLaABAWQd9&!Msomp5D(&TOJd2FV=bkE+5A$B`wZ5 zwy8%Wbs`bG_pX(YL%E|3^ks`ir^UlPdGs1+Qi6{16pMqfhq^Q&@T8?W*)F8T4Y~Zh z;w7OqGl--+80U_!H`a?pD~ztH=+Uqn@@#H&+k*iTjvtbj#XAjMyEHH?EcZjqe0?WkQi2m*oZi=n2;Ys`foTf{g zT#=AMypkI2Eqi?EfnQpV9)=tkvXcNq8-GK7DWjZsXe*u`B2P|nH>BcV#zU?j`|dsT;0S>oMXpF|t?^R9uUW3v=mo)7T6RJt%##Pl#wt4%?4T+Jz4 zeo*~EIPme(K85>+BHd!M+cId!qDJ)n@AHA+xln+%vG`119KN1w^k|9bOgCgk*O1@yMLy4v%Gee&sO={D;+E?PaQ(=CwnxQNuQzUIysvpT7< z`lwQ`FlkXz*d6AuUme?_&Y@bJ-rNgXq;i!dDB+Qy)!v!r#>YqWL1S71;b4)JRrtkj zR`5x38NJ9_ZmR50cxOfQ1Y78zqKnoa^Zmx(a_{l!@x2amNH)Ur@@40bxZ|)>9*H_} zFYVI{cA17KYx0tdMQg(P<#El?Iz73Ha0M+Osdaj-Ml{|OKwxmZSINB;ePJP<*edEU z?10QM;$0xhoO(4eZl5cHBK6GZL(m4&LmheRG9M;63xoKJMMvNY6xxKyHXW9%H9Ywb zGTsx>w3?$E%VKUXf3MAZ#>rqe%LdmNKa(=xWWFm@Q3vJ#87>PeHH8MNd3E@n<6a_rx?n+Op|K*B z#$(EH-Xgqr!mAkX{(}>XX;@r}_v_5-Wao66iQ#oG^+((neiNUy>+I>TguPMGAG1el zp{vU4s;eB3#TLr!g#y{RlWcXbw@&l$`(gJ<>)FjECg8!$nXiK@b8v-jH!ew3vwyp9 z-Lm-ATwOXmy?5?XYg=*l5LTJZ{!SS)9M#9DXiJOwE1LD~rCp?nH36D8JKeKTr9Q>- zV3DacSoPmxgoJSXgP zjTgCMWV+V@KRND>v0mPEXm#sXvk=}@aB+?z@&R2WkuCapE~n=Lj%9mOEkfiWZ&R7jG_k3v{Vv7r$lC5CS*0FTCWKje z7aO6&KgHcv+9G075T(rCd{ksg3A=R29Rzk*iVuRppOs3z9Te1SrX;P}5)A(U>G|D2 zq6m5#LA_y3ZoL1^(DTi*F`rqyL{Y@CpXojBv)`h5!0&v{OZQU zYa{Rpo^bs({%dFXa@eOMHpPS4-k~Q9zG}+KnfHcr)_*HU#o}EbwF}F?PTZ-l_4$*K zUbg0Na|+YE(hdB0v@mzM~;%S6q1pw03xi z_o~Wcc$9g(es?#hs%a?61KsY3cBrn$CbU2pAP=`v2Z^MGrAWs48Z@JJ4}w;tRDFdH zxL0b9jZ7NmV%t$mM62@|+cGSUWXa)xS^m&=JO{>o2+q(LE`PVcHMZoi%$zVQQ zQMh$6kJ*vBn|AL~v&gAS?@s3q<-2@!Pbn?7O!>KkxDTMx5D})mX)8hVS7qARvE)!q zNImF7Q40S$qyAD=p8tI04wy2YEg#H8;B%pga*Gfx&HX|YCUCZ&aSgw+&?&rPyiL%p z@p_0VBV#>qcd1R_+9Z{`OSNU^6sRq^nkZ}|W-Q9z=guA6si#MfyGviDOH0SrIs-a; zMT1xA?p1)MOl_Q3@4PT{$ja#jxuga1srhf?7)IwDi{H5pcs8;3Jx@K_{tS7$!3$~W zdZ?I^-m2!|5dVUcjp*)zP~gyzn}8{$Rr5`si0>+pl9DGtWgNb_lULq$0JM%n|#CI)G5L{20)IoZ9<#LW71QdeH=cE zVYx=i@Zu>`((_?aT;xH5!7Vt<M;)e&}xaGa_w4oy&?6SXW)&+%@ z!6-_T)?9_WRo^H45%??y-Cr;WKEwAHzQxDWn9o&4zxBP>gKwCacB4k{Z!OSaH364A zg_wxl^X)o#*Yt-}9D-m4t4HR{ZT=CM`zj?bJfI#M4jEwfqD>#_wSq#?aEHw$?c*F1 zHCv^4H4|OtrARO~Q9Ei(@S*_kv5cO$cP8V^t0A{iacGS%Zlbb`@mgVQrkH-@OWfzW zOE30eP**)EWgVWQ%mS$WPKC=|O(6|`j)QYVpoR_P~v-F1z zByfZ}96~&bo_u?rTdi|oj`IE!e@}~AsAJoSB2wG+Ghz{)G%5jA<#WNWd4rq38ae9F z95#y`TZbJ+DfvWPa8~bKGsF}?ULyL9pw6~4uld#vJPMA9QGxy{mQXbryLv>%#k4?j z3eC=mAVscr+R4O6%5zl6N-LU z@K6~eBzX$-y~LYs$@E0X%G?%Gs~?`WQfFhS&u0~ z>j70H3x0v$)jzfDhHK`;w*((Pf8Vh&P%S~5Quhc@V8m^rfjM#tPzMBV6M+vZ0 zC;h!l35FGWlyj?p)IPY07;r5Wv8cU*9qC|R7b4?j^iA%4+WW+G&RlHjQGw1}PT~#< z$O~sHs%wz)B?!gEKZ0T+-stG)o~D}<#`A-=Cq$6TE)viBc~`)zClP7-PYSpE7am!- zX&;gb>1FRPX6db^w}2oh{dSyq{|s9F`Kz5-^e-2F%w&izryw$-K^9% zK6%CIRo838yp(J4Vp{2)m!S4q2AzOq^hFMHM5Mdgd*6%5&;m*tV%xw!d>VPKq)hWF z;8|9EttS`qzl{K1P_f|R-IAe3y+fAU8=cU6j%NZrp!}uc47$j`k&Of-Hx%>UFIl8r zOo0s7>N?e{EwOYI2m}b4T-v&Re0JcxbGcSJ{|;W{)KT;IU{>v4;~>`{-Z+`;$F*20~vc+wVE4ENd$()=D4QerhAWYLQqTfv@+B zo^)J99vnjxsW|SHkAHmT|I$?-D2?P+WW`#=s~PQpaeoC$Sg!tWE$<%6|7H?+2U>o@ zKX_qW6&1LHBtU6hlfw0IgOF)NUD5Mb^a<>WMbhP=NuUXiW@B4aGN1(HipUWH_5S@r zYpfEHfRW5rL~2LBlb!uIAUHJ$MWAPzE8+8c>0T*FOesiz1X}Wg#0wG?wjEGLS!+@< zW-wszu+(-#s^)m~gZ@mZK9Hg*P_6hDtL34BhK2?vk%3e;%ij#`_ z^fgI!RW8B}LvID+s=7nNCC6PClN{v@E2_uP?#N4f64s*;MNdMjow|q2B^#vtWDfkE zX`(0(G?~Z+e!kGu0=4B-=J68^u2TQ)oKPmE%l&X#{lTEt6j~1sGnt{%Z+PpGmQ7B@ zYj?86ug|A^S34MEyH6kBUM8}a`X;&y8&(XXcNj83;*%n2;Pu4oUY#)&K*x8X+Kym@^Whp{}={Hdv?%?LRw+wS65g6#WR%P4d%UO&?V0EA*J9K#^R3H%rq@guIoA`rhs-Ir`~E zc68nY#+Nj_V%gpPzez4w#riZFu@S{!E{x8ojg|bwpqt@rytY02J7PM{WcmYN=NzA@ z0`tnN5l7}{MZ?KJbmi9@_d|yh)fWGIQr+2K18&wsUvy>~)+s5cHBLDq2M7Aado<4f z78KG2_H=pacZ;vhhzMR!B3H|=Uv&<9G-5>dQPAlKC=c z1_i@nclaEwpdLdwZIm7Bt_%xuX`n(|qv-?cz7)v>vk@V>!ZD&rh%G{TaG3u-I#0$S zPm!ck|4Z^9MqqZDye}cHL_yXO2g>M;4kpz#Gf>REl*U<0& zrPgA0Hw#YhC5=fv8;lNyaN2(ZDfwxKwcNd7g#~3NSBJo~}Cay9*>LFJ5>T0L8)# z_&2rRrszd|Pdf7>IGR)p2sA@tfP&lwLvbxvrBK>xySHC^JE)Lu!$l zW_~390EQOqhtMxx%=5D_+@zi?H~s?M*}Crzwv-Y`qjnX3ieAC$(BX^k+sZ)uX)bPW zbVXRjkH1iv-gBoYAizW5J$){^U+)?KF~e}z@h9!#dG(!$5k)7&{(n6G8~1%KU1mHfzdd^$K#z{tRE)mAok1y#{TOM+o6kRV`{dPT>l+{NAo9ZL0zN@R~nV zCj(|AAK{bW_i#`lqqYhrP@iO+f{K34LC{RFn5XO5?|#&V`o{G9@wL%F4Rjkb_o$M{ zttl2FAPSvGTnQ-u{@rcpr1YdtK5v?+(X|vX{ueg{Dt%JebmH6_-GeTS&uc+*WrvhQ z+SAm!6CdQ!H2ovTs$d+@mO{qVt_TBCK=1ie>H!Bx7D=cY*}pHC5>nq-c`(}m>)0yg z3Mnl|ZNwhe2MtY?$ZKjjr_0u~2v<|`1@!|h%XD?zhARK?7UYob*y=$ zsHgW&6)@OT-|)Fn+yrbh=v2$(6fI~X5yK8Z`QKVLa)JBY>x;7GCqQxg)oF0fj{Njs zC~nP`3E{&DY%qX1O|_5Q?#sj`y)8jr3=O1Txu}*nmEJ^R#$&DrT|W8pddB^i9_`NH z12BQ0PY440@;fOSWG!t9p_ll83!c?lbMw?l*WSXtJ|~h4M{|X zoUQ@84W&;~s!DYGtosl*t!~_hB4*-f&q@^du4}eB>fx^n*~6pkTO$awwD%eU^FFVC^5oqa zL7C&i{8@{}rV(WbiLWpV=DjJbIweN#dNLSk8xA#a|1Nx?17;LHDseVYs0>rcTb>*`42bn6;O)B+72*C+iLQtuNMZ!I9X zX^GsW-&rlyr`&|I#cc~K87Erva+&HKY0ujjFXJN}FRrw14Qkw0F7fY<=gG-=T*8u% zjswsKD58rDFJIZLZMnb9d%NndQtR{{&!MKIVW8n??bDB{(&3QDH8OIQ_c!7q>-ZXN zMd?KoYpuRVoi#er5udG48>Zp(hLf{Xq6STW>jL?yquz}V?^LNa^_$7~)Ovq4ZLZ{p zNII^~R2@T)C9eWH5(X$70^mI{DNmq+AC2zm{=!tCJ;fyRQi`)mIBDRO;2sSe(gLj1#sICLR& z10!lH7?$*`)Ih~PNknK?cPxgE=-^V$rLVj3#%}9qR<%5Wov6#r#)w(lF}qs`eHI>u%L{WQIsYe0Gr-ef&5rYLvyQSr5%G4&-W}- zkQBTNw%qfZG0&`5;ikc3jBZ+ElSz_1#n;!%ItG46>0dDrFsbjmG{3PZIi99d+PuS@xk1zmYTdFGcVr~2U}roetN}h`boLhqhyhf4H;?C@27e2z4gf6 zEPv+|X*E2#gmKwx)xIM4TLwwH4^$UCi^|m>_OGCJGj-5ZXZb|Z)E$orEf)tP6XLhd zvh81f3Sts`lMp$jzkVJXf317r@_MnPYYS2!Vk$;Bse13kC{oc}36p2NU{x5CU|9lv zaM5Llo&~FBJ>GP6JFkd6W3%z<=);EXoqHHBDD}F+*fPci|6iWA=K4Hp9@^R(W6b-O z%1^Lvve{C3C>eZvSXhc+LZvieg2NL#DKn^Gp`V0HDoG`R8@Iu-J!t2M@fZb+EjY`O9O`vU=w=4*;F zbWV}O^9~Xc(pPdu#v!wFeM7?pdP~&`6aC7opy1$NKYzA|fdBi~AFqC4EP`bpN_I-@ zQ~GxFOGO*#dX^EqFK-RY5#^s)0a=@kCPm7l)rn30x^=b|1lPvdn#4Zd@R76qsKUITp57H#gIOGWbfD8eHPUN!sjxt_)qyxX40Gpwx7 z(`ss*IijVfXH)z4Hw6vA76-2mv>}b|20Ib)Y^L$_P?Pa&oyx0ID8#bz-`@oHk4XSt z{ciC_x!*rYHj&rm!AW$(b^i%5>;L?`+|!KknR_&nI!jVqPE3^=d0;(9(?#B~9MMuw zzuryHrv7{Ray1*`SuKe#T#;$o)&~;SvNOWoP&7Hi)+Lg-?fbhED8hL^RhrG{ijo&K zoW?)Gf72fFO-oi*qQA@eM=QKi#^7dTMRySwiIhLi5t-CF&K8-p9kFsR<%75P_MLDFcBrU zY`U&I-kBN#U*{YKdxQFavvi1O)$Rg`aYzSC;&ngt1)GhOfp2tFR2)6DRUqpv3Y1pn zzooPLd+FYS-=n0Z?F+f8w1ikx*1x8wk8W^<$46?x)&~Y~|9wNm4{BW$@QT-Dp|%1% zGHPljwMDa;(hjrpi9!vv7aSI5qW}K#zmG86{qoeH&$8_chCyG#K{#|g=lcv|cmMV0 zjZy`Pdq2C3ais-)r0;#bxe7oezCtV#MN@h@mJXhXNQotx=5*CJxs&aQpT=Xu5Of(8 zV)tX&^C8b0JyG&lb(_F>H`su|vxU5(MjFRO=Pdld5PTLKTy) zb(x`e1ecjM?)>-DA@+{DTF^A&O2Rus38<9Rt^M%>!7~-sblqcP3EBr=QRa5G6ktGU z(??&`ErO@<`G2{?Bx>;1-y_93Z9f$YR1GNKIPR;@RGKH?i#YslM*hKS{0;v+l#pxG z4Ee9S1%LktCT9o#Y0dzatUFSS7+C5{I5gG~;yx8Zez~4t`LnoqI7GPC5xRf%8Z7@%a^OC~38_=Q|ZoIO^4&rRR5U z`|UW)e?Kc?Cii+%uM)8iPRE@Dmfeus8%GwjiELSlthj+anad#B!UzJ3>X!dZ8 zJ@D&M-*HQ?ceHN5jgEeTeNB2*rC~pzU^Bor6({!Zrz27Sb){&^O&$%r2hAu)3yu(# z;2F`-7cZ5x+$$at^G@^rx9Lc|{yc+Jtlim)51G;_4Cm+PpXB8!?RO@lE6wM){Y~jr z%b7?}|NVSY!ar;I?`tG48o7n5hyT3>KMA(V{<+@&{xSQ_vy%TFJmTMTAN?Pn^X`xN z`tMDty?@>IfB*9Tf6PB?@&CcK`S_Q4`=wZ@{u){j3;USDuQ6Gq#mM8Z8v#y;xRg{F z*qq8zJbSDg(m$)NFX22*rVAwF;E*K=^kw|~DZJ=;>;8k&I-O3lUKw}-8t%0UqY)t& z_&z;VqLojgP4DYZbq?k*{52NKMc(t@zE3`{_x~uhUJ;$CvCSIKQ9pP-TL3aX@k7)k>%vIl^!;;4Zys)# z?_-^)BmE>PG;Dt*JA^8DF_~=asLgsFyZLO~ z&{rZD1Co>D*00!JIK&fbR%JRh_`_27SJybi4HoKlz7{*khQyaSc}@%b)sMMw?rmzW zo&2(&z(23E^okX|uD?E=dt*M!s#0MRZ3b!7Fqz1GS)f)G1JFTl4^_&pTTzhsxGnNG zOcAqe8<(Xst=o&(`pf;g!HxxSkJGZ09u3EZwM21JK0a7K%TY7RlQ`LP%P$BYa0Hxz z9Iy@s#MW6#HYiK*RG;6q1SKa|d*E#@+dW$?xXlo8T36j#im6@P-yc{hX zPGbIGe)&f7%5&I8-v9@Mj#e?BDZF|Nc8vg`N5GQK@-8RgM)HAYchri`$QgV|K4R;^ z2WOOKwj)nQkLU;BBzkm$9#6~7`XgSweW@pS96#lv+`WcT9Esa&sOK-0GJ|zY`553~ zy10x&qBF@h8`JYB((!p5^5;D+_hcC#+^yR!?OV-Euy~WP8HbHbTES$A(k+}=6&?L` z;|?jGH6KOg%JQEj*&F16MghA%5mLW3U6R2IpSP9rDZ=Zo1JJd8?2d{g-PE%lFXiCr z#>;&kL<}KRC?}i&kqhnz;KG17Fu%N9{^lS+pgZcdTtCH#v2_t~S=YBOKfw1;@&rxG z=$8wfb2OcYVn>qXgUxT#&)mhi$8OhAE;YFn-TC7CIdIchl8K@SWRIs|7db{lrkv05 z?)a{}w6HIm$#}QQb;f0Ar=RKkNwxLLYO^=WI>i+SX0peHvGieKZL5UZz$QkdHp;z6 z5s?&P@4vs2OiZABaTp&PYj`thd3LaL1c(IgylNRPV$UmU!?kzC04nq35gs?oWY{@E z7wP+A=)XV2e#KeR*mC?TIyr>HXtL00J7~mYm2s_>PotI z!CZ916!%K}8D^?Gf+jkP_aXv0Eoo^n!O3)4b`dq}>IigVKpIV$YekW)9e`(jt%1ugXWIaIH$1k;Q0J*|XFM+@)wA5L+7{i{x@y%{X^8-Lk-;J=PYL;4 z%2}#*c#F(q1#YiwU%!6MOtO?EVmzhg*#J-x;KI1IDB^B-*tR|e`&A5pfZ==6WJ-&j z)MU(%CTqT6E} zc6{Own=sRLYw**}@uc`p#v?c!`J9HYDX&&PK~_(^D9%31Tk0YxOj&8++l#3tZp;Pb zi^CTJ9>5MIh+Q4u^G|-Z(^%NhhjMeACD221dnU#rBx3ZlF!|B_rs$Kcv95FXyHY=W zx86TCcRjw?DFSb@TO8r)4Bd~VO0xTAi}WHDFN(zN;BC*~Aba@P+QtSCJ)c2;oDT8f zka>#RQDB)aBi6rG5d%z!dmDd0L)gW57Q?Va5I2%_xgxAIuti1vyy>=O z#A1uqT|{KC=t|s)m_+tJn_D--wjjAK0H)fWX{_%e)#!3!0{hyO3I{mSI>^Cy>+l#@ zpXFzZ_bvgvq5_bcg~AcqblW&q$s&k7#7ZxT?rx9yz8J)RoyMpy>XFs}UEqiXp^yM3 z@zdMQJT&pA8mLDA$|Xdm6!u&3bSt{ZQt{rCgD_1NYM6?OE7Wd_sbyC$JP3?V7DR>c zavpV4Byl)a5!|`>a@$K=Bz}3iH$ZWN%@R5mCj9-r9Rz(i`rM`Uxd(;tRBjdTwe$P^-Tr!Zh!^(p z$9MZ*;l>0{B^@6OqYP0cJGF+)|GSTkIW28t|91-^89wKOK5Z8^jGJZw`#LDAx{0G% zoGD>eQ&VFgj|*b}UIto@bP86f3O{;?z_K3m(=kq5cx!ND6tT3x#b(A}Ynk?iGNtO> ze2L_iaxcju3O~H!*A4pzyJbV~_hu^wD9C|Dw7&_b1V>05=UGYG`%Rz+UFYy4l9M?u zE5)N0zh+F4@I@qHYTmCC!529aYIR1@XONrIs)*p5wF-~xi-;gwKF;Cq91UbTW97zj z8_g7Fcco~T+9;HLw=ll^{;t9Ia2)MIoT2edmkZeHfo?6bA`V6w=Gh~vvs7u%aA5Vq zL7)%e)y;bNpat)XJwGBzKCt<80k51*jA@~WykdKpQ>(#Rp-7Vt_O)A##C>%)gS|fx zDMB@_3i&hI;N0$pd7uk8_D`l*ba@!0z%GbrWW{tukQA#ajuk|1R^HwOlI;%}`bW>V z%ZB(_GGzYRhcM4uxTgR;Av(X<>3clC&E+!fc(2J^1zHvwTC4emQvDC$3!eyFJ^eGu74^Ge>?> z9$o^yfZC4Xx`qHC=tqnQMnG{C*PN<)KB~DUdZmy5P+&>F0ui@e1c=BJA~_!#FHOCT zs$3tJ@A2ASsQWOMDLFvRT?Dg0fVB4jq_xtkl(w6lBixjkGxp6PIxZcPnmC&np|u~j zr#ryPU3R577NG1w3e{B*WVU}=uXGwbOKNN}T{ZDqj8Lv~D8MJeYJ?IyOzR-H8TTn% zzQ>j~z<2Zl{wWDpU`XKBt)C;SmGK1!05xXkz`X?|YVWj^6Q{Z;WJwWijs6P8KX;uC zD5_Na*Q~r4oa;@l`s3!L)rSsXHtLCp6=E^6jvgcf)faEVh4GRV*C%g&IK!WUg^2tE zuJ@|IQRv1|QeUbm@L-~+Q!CN+$3O4jraIkUm@_-C83+uFa|FlE3$XkISWub~^a#%X=C5|mQ5+%pFInoaw7`s3f zG!k(O?$&%6ZV(F1AylOKkMXP$nNmq6q8>|oZ*X81)Zk7mKuyVNVcq^4ib!HU7fung zwY0rsHW7Y7HOEThvCfeC*F%ZVcWOM(;KPc!FJHbiSd9fA`xB&uBCMR9ox$OoL}y#d z`^-AX<<=?&dV)AzP*$(ukl2+loAIU4f|)IOXpYHiBYmAdOS-dc}Ax?sJCdtFZtd==9C=h>4GVLm*h2k@<| zl->y?tv$*>)I_(Vp3yudMiy>AXO3sUJ#th*JnC4W)RN9q?CBMzQx2UaHVIGi0Dcx- zj51sdwU-)iUp-(SU(#Yh*zlKt8D0ts3hIy13dW`HkKvd#<*w&&u&QVN7Q6W9VN(N?)awhtZy~iB6I>(gV2Cinr*2IZrQmlI0=CWUyu-8*?Uuh}uArLwg?ypEPm8UfHH%%H5*vh!rQ7fGTh&dQ;*?Y5vSwK!f$Wa z(I7>w@F$F|@V0{@eE!0aYsC`itH~I8wbgjj!bm{a{t&ymIf`upBt6ZFBk_*MFNE=T zX0}8TJog_;%W?bba$DY|NOw4Ok3HAUy?}$)XcrL58>+h=_ zc3K3m5?*Sz1?WnMP5{v>K$Pa;`-3$HYgt(E)#o4R>UH!X3s#AUXk~tQ@KJ!nDQGZe zM@s*oaXE-K(fOoyr|>(oUT2i?z$rMTh!R?|ov9*@aKhGl0-9OieeuD86Po>6X*wlk zQGY1Pk{j0>m&c035I3iebK|~jy`O@xFW;uMPz6z|6`s@)xrt$GzE#gtq(`ju%_ZXy z+Udd2!`t|!OAGzos$6ht4A2kLX}3H8GU)~0uAjogrTGe^u~hYf+u+_uSA%*BMb8kn zkrA9n>ZXGlhUlR=#BzJ>;0HQ0AiYs@aHy<5XhlbqkZ{`WM=NQ*1~9PL4N+Axsbcse z{AjM;xlC>sH#xqoo*)PWlC`iwo+P14Bzhxs#-|KL!eHrbEzdTbF!vDKS0Ax`ZD^;h z>jViU&pv-7lQBT|WMLTM$GPEJx|BbwesikU;Vta8)mx3uP%VhdsA)!gXgX8+ix-@r zK@qeBr>nt?J*6NnOr&pkFm|LUE$*bMm&*vl0h|*8!ys`;#A*ecF zCUWu5U+NaxB-DW;Mw!RhboGhLVh4LX;I` z1I9Tzu$&Hry=sg8o>KY>78Gpy`ue~$AYuc0X!@Sq;Tdr*umJ|>(dIW-=QfMZ8$BSr zAE5B~r!^3eo4_MT7O-N9tz9mpm^XaKq7Nnx4%4imFK#tuWVDG7 z$6^R-KNWt6Wmw0o>jnNsAPbN@27TdRtv{jvFKhh~#JjvjT`M(6f|L`$%Y5&w1o_0C zzCIR;^#!Z`I&jIAX|uQjg6OlY8%06y#}WHiH_1_<+}3klBb5%}ApwiWuI90Xr=JcG zP4LXoSa44$0S7z9=X3;fNZ<6^mjW2IHe7nuIC_BwYs|(A{z)iyBlL^s6Zx<9x}`Wr?|wG@-e>3FT=aK0J=FtQvLnC^h+W-+2;fc1QdW=d5=oiK1P!bz zhXqQ^Y1J%|iH_^>@A4P^Uov8#VF&>{JxccFdiy*SW-cwtPoI2USP2(kaGbXeu+@HU zHk|r)5EXKOGAK@SajB?KqJ^*{Zhvet;@zJA)YD~!k> z*qI|S7K%d3XFgv&0$|+wI=6(`$c-mpH3tmO05FX`kK?jkk87gmQ8G?bcN+c78W@Mo zRsjQ9U4vCmfsxbP7Qp8Ig}n+5hmt`)4^%}0%=r7g=|qL85-=wUBkm>}gGt{~QY=Nu zCvp{R7XSbm3c{fUSYYXv;dG(b9t2%|df|Kqq5*{9o{mO8Fm@!`WYBX1juycEU5eVG zc5=7I(TTDD?ScHcv*wdW0#(jT0BZ=kjMeCMhTtCo7LXIR2g(GEZZfa7Cksp~;~d*S zmhWp7IE4~m7Y}r&I8_3UgyrZJ=EjX?qu3w6jzG>QAmB4QA4uRB0?1k2xWGieEa{QnmaRx~Ap^(Qpn~gjmy;ru@)u`rd*Kq{GVN=lnM9ORs zf~qBd@P1|7_leBO@|S&D%`JXqdHK(x!rRUyc8nfCYfS+Y@J~FCyrz^ zA8`W=V>c?EI%(CsO)yKr-OkAP_NYe6_cX>0nXu~E3~Fi`KFEJh7^%n zg_SWB$!3TGa~8C#ba6T9+hz5C8Yq_)moHU+Q?+@3=+IZKKvWfi?E>-({&a%FLPa2+ zNr)u*6BtI!3<8QLE0t#Qw&{GG0ETll3wG4H-m&R@^pw2TjTG_Bk3Yx(vBW|V$?twq zok_BzPBMRE3&NqnrjEP=&+k*t9K;9+O2|dJR1Sgt?@84$juJqbvm7-!`=!v4vLrbz z2O9K23#t}v6d#IY;B1q4oTcHPCjkI#KpR!~e0wA#06(yd@e7Ia%qD-~rAxD{7}1(= zd%EsqzRHUFG=}3!C`T`_yq2PCc#T?Hjp>&kS!~7G za&5%Xf35|`PEoboNJn&8zP0IMJI~-Vyqh9i9N;1RbK3DXJvCo{XkD%Jb|Ze^{#==jM1ssm7nd@Kk|;ZYlKk<6AF~C+h~GiiN0tlKbflusyreC8gRecUWwy9HE-$ zT>>{cq8=A~tUY6rhyzXo4tVr%(6VNO%a2HLYwHs1Xc9Lv4rK|6Ky}x>3MqkWFW@n{ zYc`TiMZ4`TI&VS1yBKnH1Gr`}Abz!hwNni`hail6V+hqRTa{prio`b?j0C{~x;EGpwoX3;V{x zILe@-QU(!3L_i>*^bR5&0qK%ZlwOh`ozN{Ph!m+p2)#%N2!v1r7LXcB=!7CjuhKib zJ38h6yw~&i!HX}1lXK4A>t6Tzt+m};)xXcWkI`hCfAM&d_kYG1%9gePV$489=w+au zGK-E5_v0lBeZD(dj$lP71DT%yR7f91PJz7@tOSAD9fjq( zV}D2WD%R&?Zrz&TS%cz>Duvj1&xdh!zX%ItcsF;D-Q0rQSOIk*!vs+2L)DKB?Ul6h z16!D~Tjaf;Ca-2}OHxh9bFF|%SicLX3$6!?GbU^XdV~5O>BHlDgP?4ucefy48W=m) zvMnniT*<*+cbRf?e}(}8uPH5I??ue%l~z%1a8wxbFD#F=Ct zE!n-<8|ym$SI+JOC^F$K#ti;P-G}!O$BpdZLcTm$d7-Pz&Y*3I#6I%Lq$AKlNj!e0 z#22q6Hhc6aeH*~eIfEJ;9JHa6I!u(@e$gG<`Mog$$R0f{iH1u1tTP{~Qn04ghGwWK z`WY)(FSG7Y4)0PP@pA*T|0ItIZ`MWYC~5Cp&;rvGFgq#sRjrGwD}{TG0^%Z3<)9H^ zo8gI$ozS$dt$>+o-3(vWKLJd% zXo?D=P&%w3i=cAH)9s)<7lLN30L$r%^rd-#u|@(d-tp#vnK#v6x7KQEghlRN*!Vp6 zT2$uaA9YOyZXyY+;>*B3ly*_gH^e5L(kd^Sd-=E83%uWeB47U*+)niiDKz|T`}o;A zgyB!pI?WWgU3|_tWw)SNzN=0XmI4;CVB;sCrNDb#U&yWmhvM>G$v^9Huk5a4+l`Rx z{?C7-O?qan`FLA_23=;S8QS}KZj%~w;lfq%N30Txp#dU?-J#%#vJG}=(HW@U2nF?Z zt(nhAal*T+{*k5xZ}%D6XK4Qq_G7h#8qfel0$~NH~NLEMZrjmPJy36qGsNQ^Q}Q;!%w97QMN8 zjcV_D>NlSN{KpfrN3wt+qOWRn_1|f{`aKg?g=usg{{TCI<~OSZEe}NQs-NHVEkG$# zdE?8@8GjGkWG_O4SS)d7@cEewq7iH?2B5SOn5;O5#uuu#0Bs%dlBDi$ipt8L{^I1| z1*idbTlYG{hH8Vcg?^dw7ngq~`;f=}>Y zpGgU*?H(IlVt>Z?&-b>Xn0)G#a=}nVvd$`q^^}FB5kbbi)10}8cr~XS(fivUe|^KX zZ;-r&u2O3HMsGRrkHBM3h)%40GOhr2QO*0^eWameJsS7c4B*04)~1eWg!T{5?!WTC z0P*E50*Nu3u|Wo44HbEVbF@>IH(dF7cwEkV0A;su)ui06>$5N2pJ+;%8_f?0u0QL7EFTt5HWcf`}!G=;(wFAo=V1AqI)++7Rc z-e&?hQmeqp`ah}mkD>6uY|iahZtmU9E{YJ!Q#uPhoxL8MJp?$hOj7s-@B*_H<31X7 zw7M6PDrIPTeaI%~SQ(U_bt$~5!`j|MvkQ}CZKo&3;0 zT!f(Wgd&BmaJ{areS1?O6Ccsp`#uNbk%$A{p|A4d#)9A8Tu%G^?L$^jUw7x96hRF2 zR2us&7B{wl2((-f{vY7XtS8FE9{$zj)_pe`Tr<<`k=m z7EMqYw(lC2JKoinSgpTIyzvikLq&D+@2ji?JHr%kAw+ICNqQ`DQ_L*4+0IYWmj(xl zEvL4~PVo=V=Ll3U3Rcc#quYM}_X7fdft>bJ|Dpm1^F6sY8n3#(*;pbQ0oBgSEQWN0 zzTr2o9rk@;PT3;C`>u0&@MrCQt%djAxq*#^WKanpmD+0C)&N^&7YGQ9N5&`Nw@aWJ zC;C5E`;)g~Ljd<$r5$+J5?()2QHoae!53XXFS{DBCQ$X-7oLNkO)G(?YSob}Gp*wc z4W;-~Hu{D@DkQm))JohJ3_ z8IjDUMNm*%1F?aAA8T5azWf4>4#^6DFpdf7BUuX*WMz0@_=Emykm61b$6x&Hs&JivK_ zD<&xdf)kTo1|VCB?|_&k?REoK7$oL(-#pSjeT}#VjClW}^%OLA79?_(_ydrd^OpX{ z+gbf043OejC7ijPjsFm8#wlx*Kf3GM$ zbuw`0(I|Cb{o{7l6%QyciXG4S@BNAlQKf*s^2*{*z6CCl%e6(3!`u`t1X4g1n~r3}QD2ct z1nU|g^VJOv<4}{4px_N<1sH_TTKR7TAaRIIXi(NPVf9(OBXmjP`x~K2KrV@9^rYUI z=P0fOIB81(H)&F`z2g7DNps+Tco5$HBq0OeJON2e({QCL@qNK%E%Cd{RSW#~AT*;m zdSteTZwS=#Mc02w5QLusl6$5uh)rW$?Q4&cW$Gwd?EuT)H)1jc^)0UC8 z;dnaVxHNlktq>RwHm%xZ^nVK?0njYq*E0z~VzyjVxq6)f84r6eU|mMs`~I{13f>Ncm|s`%_?cZUD2pZTk+&~?ECnHAFxMVDc}FKo-%r{ zFe3_KoMSKxwq0Vz(Ig(A)UBy^pSRs$2V_$eK=VKvc6@aB3#E6OZpZNc6z>7WN%%XO zH$h=?6I0{5wOp9kQxx$2htBHy$w04v7SaDKC#6uuFXrZNJGJP*w`W=bd79^I(z7rY zsXq8F1-gRo0wLZCM;YnrT7dVNobW#nA^7J*u&Mz@YwOQM)*nE5Z)<9#g)Z6uujhH- z`m;C%{=lz)fo;Gq1wVcha+y@kc?TH)MR;PIDq0i)3SEyMr-4VFn)(r}B>3PzkT)AW z9YP>hZC$LT9);4aag9Jxu9yDr&&j~bfOrR2_6GpyZ5TTMDaBy^%%X5W(gV9VM+?*T zH*X&`@}d&8)^D5LvYx^h$0%pYUM?%82@Vhw44?sQ|Lea)!*w}1bHE#2r?92c6rv9} zhKY5z>VO7GguLZ9tx^TqR9n;WAt1Hwl}8JpWi9YsU~m!tM$*|5rWlu^jA|e9>~CEY zjtE{HEj4Ei@T{G58nI>tn}2q4M)?>zVP~h$D*K9^Su&Re=QVMkE(ahdr?Fi{k{TgSf<;GztG7@q_Dg5OQ-Xls8lN4bocz-Vxnr}xbCU?NpxQ%_3(^;3@uut?RR;}=8+OTB+4dFdiCfeinM)9)Ygu5 zE_Ef2ouuNq{A*L8u}wySeFFxfa?Qb7s}0>CV3Dqa%vt0{T_}H56P$(gkKqzR$H346 zVyT6)2cA*FlLh>F-UBEkQ~BF-;S1W-zU)SmKABCi1!!tl4Zmm;uWg zV^nLx^Rr{JURf?+?OB-1ieu@dcEtS{viZ)Z?yIM$5`JOvnL)seXa&L6N!kB`^p8La zKW8(!3`o}KpJm3$oLppvN`z>}10z%S*uga)fIB3yi!dV`_rRt@esi$lXjiTKYyEK4 z1?7X9u&I9+eDD3Q!t(*E49jeATamQ_Q6~;9<0%K$m zS!eamtqEzRtV%a+!sef6RK!U{zpAZezaH{apejZGY}lI{D$56+gQf|kg0#>)Ly^z` z>6I~BwK=oD4(;-IIz|3h%hU7az%KtQp+ zEV{~26h8i$B1<9{v-t)%0#FVm!yENhmCLIuQ`N@I(kzWWYLE3eicielg9Rz`KGGW_ zwu`{55hKNoYG(V}$2KUQM|!S?bnhTkP4`8R+jq#|v*e+6eFX_gzn^LZ0IE{!GL3=c% zi@-3Uec+^ns0kLIOw-oibjv+7*O`L307RmC6}0f?A}t?>NbgLW+#2!u$aGEoM@AdW zn47GzrC!HR#LiGTOp_qV=N`CyY6W8lXF0<40kQGGeQQaMTigG`x13$}sIZ{w$#-`V zSz6dDS~>;(;dnMPf^+r3((bjSx`>7?)BVYTyG!itYVUn1J!2JwTK2S`%}k_Zh6HO90hNZ70Pu8Ufyk)80 zl86}W+4gH!vh;5LV1{kG5zP4SU09A4h=X2^mMlYZ7^MtqCtCN4fOWP$EO#XJ#rWey z10g_M0VX^^5OZ zpYDW|VYq*_;Yeo$6T?GUn) zwWo#}C~qPlV0e7vo5 zSDi@<394qtzLJv*624*cyBE%b0dPQ2AyCcnnslKuEv7ui#1S4J!l^>_x zH+|=%OciPTt2YoRGu!spCkJ&+9F$kr+f+iWlwxpVlwh!0%HB_2-5Ju90&YJu9<(Gn zohxrVzIsaD*H_B%`5@0i#V3iV?vk`O^Zj3?FICr>3hN)a9@ z0>qJM4^T!n`7W~xwIsqm@pn+z|M#o<%4AqzWh0md43lf;{zC0&tF)-ykW?*mm=^fF zDEH(6tDkK$oXm9W!9lsCmbI$)RtSH)i{w$iGX+a`VPg4Ccm;Y8aWXj&*Q>0S3_*vQ zbbfe}hZUFYe#NJyq?5RZrk-0=bHkjVThc+lh+k#X$x%72&uMgSXhPi3TT?-AqR8Lt znaSq2)0LZpxog%*dUGdI+5f#cN=|$b;~8w$gWCvZ!E|l>&m)P;xi+JqBKaDIheIyy z#Uqp3IU9Gb8T5h4d6Qru!B00uK7EmAgsYNzl+?3!&Z9Zm?@XJjmE}19?y8E=?-^&+ zksxE!?VhA&Zdh}P57l0V(9ZX{;9(+I0miVoTOy8%0;RLPX(0z&Gcp+JCwPhP?~k^u z%7IEv#17c64sEZCwoGk@MR(+2qe+CLO3j(F;<3WWI%yH(KKN^_sUQ`{$$xHgM%%-x z26(Ldg43&}21{?X#zp0H$NYuf+*=uYWgbKR(%wrtE)Djt)V7m2k1m{dseg=}dXpiE z)-k?3gNPZ1NP$NNwqf>ywso^i=O2yNtatbBg_?>!3?Fm9qfrzND90XfPz7exgUFN7%cGZlXgZf}`b?P@wZ$;Xn!;IcIchlP4zCZvo7W#s(olr}ppf!1 zP&ILPGtQu~4izgI>y1GCT0s0C(TzpdAQ7gXF(!MVvRdQ_2Oa3kB*BvCtMUDc9v~$qM88oGUWzQMc%RDD=xBN?c>D-W2GJX-t&Wb1HHfz z1KX0xEXDn~BoCX%4$jsFX6Y>`+wk^GW2abPwAwXdmKFjA-e3PI4Em)#| z0C!x{`Jqp>uq`8ykrm_G~bz*hC>>Ty#XVKJL0tVb;R<; zmOmW*d{y+5ck|C-wvv(lho!6*ttLmGJZp}C)&><&O$$9@$-H>L%kF0vsB$0Uvx2c; zP=d>Rla>u#z&&rAFf46rS&o~=P)R%H!29cO&0|&MHx?NPCG&mn1km-Mt19ljM0%ywOJ?9h$Z{5h+I*m(|W7vf#Q%RPG-2 zgbiKG2P2yWJWV|+-mrEWwo4VFQMiI1TdB~i+e1dJ#HNvcA+aV(Ncx?M=a*3f`grZr zJ^_VcdbB+ym{7%SUW<<9?FcA&i1a}w@|jil`qDk9v=QLF4NH@>5sO;Pj_p<#9w-W* zkfQ|P{&po(O5TMcHGIWl@`fq$4JUO*Tm;nQh}hVLo6CqtlB zHqGNy(5|Qcd^0I230n3n}qk zsHS%zez`o=XPeW!8Q~|O#{d@$fR*9giFM|*egcC5-&ArA`Vv3Q+s6@0-S4?EuDljJDdGtfQb#E9YjCTp7d;2oelJK(f3!>c)Qg zof`o>X!MBBdGWK#R8jF}0Z`mmzl&3mtdOikgc1}C#UE3Ik8N6(KC~T9GT9B#*79I@ zs`akAODzlEl};YTBmx{4NS&!?DVw)5O3aQda(zV+SUAWcjGxR0aW**1o=+|LyDM9j z8xs5h8*BuoH$FKxxRHJ8fic)p=jjL)#bt*Df7D5rl=c)_*BuD@pq|zo?2_I^XM8hy zPy-v?vq>1=z0#l02llQ&e!Us$?=h%l{ z5A{9UYn@xb1o%{#)^5jYXBRjl_YRgS?bmF_QoO%&`Fct``Jpn_Z_Yu}PnV!V#dZhx zZ5r#$J1L;8=|Q@A&DZrjq$<#5XhKR0cNR=LDl#NOgBi4FG?3Dsk5nIPL@T?u85)y4 zs;=cwsh%&5Llh^AonPv0f!{O)I;8JKQ;;LRC2QMv#zd~uN>m{H98VQ(Uxwf1xgq{m zuxI-WtE0Y?r`o}Eedx!yg^~yKR4st&rMyG(pY5co)Yda{$Z+04X3}S>_uS-j3twp+ zr9$jiNjM!AiT!s-n@QwEO_&z?yjPA=fce1(E&k)}{rT*9`b;tQ+JwqaZ_an6%wN!0JABR~=w$u$;KKl6Q#+8e1aTW%<7U1yx-D6~JD0oG z?u7^`ZA3{Yp848-orw-y&I$6NrR~p+pGH>HX#_%<^}-^c8NY9q0@;OmCPbW$imsKD z`|$zt7o*8mo14-+>iRd%1b%9a||==!vexS(jc=Bo0s??5xvc?JcVJ_bGdG~b?g&IQRmUqsV@J#MZcSl z?;UW3%5ZT|c2@WadRq8c1c|!{M`sKw>;=9ka5~~jKG%b9bK0B1s500fA-}U$0F4wa7M3chr z0sXCE{%!em+`>8)8-us+LH$0B)u!@xdJ4$xC4=C_?J7ehCXBB-`~FV31h_5-$V z1+)QIm`cQ#Wq)_WSca0pr~#;G?gGaLYMlKtHkgQgPf09wi?nEk&XxHwHeQe~dEKM# z_OQs%fTS**>e-l0x{*`N6g&2D`R(Nyk+=SeDR7~@3K5RRlkYkH9*Qubr5A;BC+A78 z@Ct37{42j-hv_vwz9pM|dn4+Lq?ib7HG}bEfU_dkZY%Y3tXO4FV|0I$dxZbWaHjwK zbL#dK;D;I%`rAEQ-$U(&X4P=|Zfx&vRnXg5Q}6=q zED*OsH>iRmj{WiVw~j&-yOqrk9TJ$7#E@Er2X$OIO_Z%Fz}qUlW@}S$usmg3Nxzn| zqkc!1G}>eV(WO!AM_yphZm|)tSTDas`(sE8XX&`z=R>>DD+o(dSHER(Dyp|+vq7z2 zU0A;8S`y05NQkGd5V5qR5bK|!@%85y6N*qY%J3G+Y3iUo+egJi^GkOGR**g?fo*pw zbFbcEv_+wmI>tN`{n<|vRrd&{BQqrSRu0o^?$C=f5ARCn)r58RvFzp4B0ZJ{1uCg; zYK59=#=X`zi8(8K{20?MDV#Wg@tFd<2WT3M$wCzNITa4k73*KjeQ-YjZ!q=!mSdaY z1hC+EeYSLWPO!-WW5N|0>T?I7Q+u!wo1nGOrHW(OXiX7_#Y!DCtnAh9ZoZ+tL;vZ7 znV*a$q3kb3Mo!JOiU1=~$BVG z7o>{)-7)_iX5RpzPG&8h{&&Pym{cP4i0Mos9a~!L;0i z@%UG2sOo4ta`dawq#Mknnm-pnArCGc{q$CD^=J2?o*Zt7?=!#LK>8 zMS9HJ&&(h;W{uD8P{pQxU6Qr=sa)BI2tGynI$V*NIgEbu{Y406|7s5dQ(euHow0b0 zn*s_a(PmcF<4I3-t32xp+8{pnG_T1yKRhFJ(jtdZ*IjP7x@a+M^u~Edh+lO@5qo%! zD3Mv5w+0;laXX^kCSs-1&Z0G<_P7e~xVSsvme*-$JLEkNf|51jNNezebxxa^**Bcq zLEHB6)90gO!5fxb#4!%^7o-IPoY$SS{Bi?+i|0Dk_=wy2& zU%)9az%3N7EC4r8C?ApVA1Ob6q!1Okxw$!A&g-YrYHeTjmNnwc0tsIXP7!aoW#Z{t zxbpCBMDaW!oQU9{WoKCI;)zDm4+fha*k zvS)U`_}EI#940Ql-^V0};^0uDJ>Zl9&3zLX3kx{mz6fTa^yf*pGYJR7+c{WbaTsfk z-MCX`&l(Uu&aVfq?6s%Vy{k1lUy+$HgLB|E^;@^+v1q5BXj}s2-(OqH-!7N6y>5)z zUvDO7z;Uj@vV$c7#}R@E=fTe}fO2XA2U5jW&Ykg!t@imF=8iIU=Yo1M} zMQv_F6AQkAo=R!HVp2v>k=&WK_`Oj%N8_j6L#{!s?BP^0h64;~ex-O8r{NEHHwV92 zn`%5~FZ-mbC_`M+cUPuDY&I zw#VBvof#{NyTFBYz7!(TTa7Zb%eywA5^$mF!(8+&N9(UqL@gboeM4GIzgmIYi7d|O zDhXFN#xWm9i|(NtUF$ugEa>Lq=dP2P7g>@PEHnIOZal9l=Zoes&+vA)<>xH|VbXP4 zP-f<=Sc#Kk>jM~UN|<#weH-tG<$X~Op0k;-edEt=66hc9&qQ~&s!vhDUdCGU0N zk3MD?)H91QaC_O)iH1RKd`ov`mv&)<2l85GY{w($zS)Q7H#OA<8?~f5AB}`Ew^CF+ z8gbJHb28A%7?Hwf2nKiFq9NQ&reETAM`m(7%U+$T9@g&?mC87Sk7d${dW8G7{L=Nz z!)X1OQT=OjTpeX>C3cOh=knhcTgdeF;=hPE=ts}jcC>Op+5E;9N?YkR?Vur`zyBb0 zeF4muEE(Bmwd&4B`Bffze!*0#hWf*C^863(7l`eo96WlO^UO>$jcL|rOwplBzb+!D zAl8$sz$NM^4#B;JQR#I%$C3XTWP?fR$q%uExDmB`p)>3!56cI`Z*|Dx^A{unYwND{ z2GsSGK&4PZgVug(WPtPY_laW;f~Yk7jkVgpCO?j~F12BV*U6)Kf?9AW?Glzs8((*=Y2qV#v& zn~>b@jz)*HX9%~p$SK<~XNp*F#;5eDP)zGnRid6yOtNsz^CW*O+Yk?0Kj1o|Cb5-T z`y=}JM+RxW5+j6nB9{ox$LlvFn+3ubC-w=Vf)U=^tCJ!n$MTERFXs53bbqGN6dZUP z7`mTWU+$gZW1*AEwlVXC{Hn%mgD^Es^IL13fSk!Ph-{VLJ-?)n2KO1(&0Hk|a|n7d z?cM1>xuE-@6-OIQio0J9zfXa(fKAWUe5DV_vz*0}`vXX=6RDh^ugZz95xzYqa#!S<>E$pY^VJUcSbJoA4RF?e^ac$cyDs%piGFCF6 z(%HFz-)ANzLwxD8%yXpibn%kM;a()X7gG3aWl6`0`F{6fZ+u^-DvSAUyXJ<;CnB(o zu{5g>Bydl*ojSB#{m%@&7EfX*v#+u*0OmS+u>ePFlg;I}AX4?+7nEtuonJ_MjM(L* znnkyMq1lIreq8gLdF!*ya{C4q_qCsl5EWa9{o{`ngO%;X*RgS1HqFYgV#1F(i{cT5 z%6YJ?O7H1`245PBp>v;!dlWO^Pbq@&3}?lrpet3N|iySP{t?F#KYm5#7qU! zW#}ztO0GX5?(PWeU4&b?_xJOt2?F&k72sM%k&HTP?X>D# zS8YhQXoW%do;9*|z^JR>nj+x{xEJ>`txkO0}vqWFuhjc~D=E z8RE`yC)#yti_!o0TRVNl5lg}2MY#R*!%&!wDKYgbc(wN-$<^g`eQ@wlQ zU#mZmL&V8C?Ppfe3anbOI@onjVEl|8^rhe;3vfXs*J}bLqr!ImB~SlYo*S)FJ#N?J zSAuhM5u9_Dl!x6MSbQvu47zZ^U~D=UMGtJ=z~y(br*Ms#|LGjw*%QX3Au6@R9v#AP zcTjhoeRuH3c|n{f9!xJ>B?>^$Jt8+&K<-@JW>TdTS1{7j;+&!hBXAYxhFyfJ7%^y~ zoinK4m=3Y>s3W>6lJzQVG`2U?VKG%*^C$;?$ZFW55^L)JwTb@rg~bwU=r zegZhtelSWtq3e1hZF7j%mz{%PwlkGI zL4e`K6k#pc=Xvx#mw-&cHs>dP^W4raO>)&jMC?!i7nverT)?qYoXKJ5Y19v*gw|6l zuad!Z5v4wMVNJ%P{e~}-F>kjTsE1s3O6?s10H8SD!sk#*V1U)91!JFzgb)cktht{w z6mSeqMOr26d2V-XQFm3JV#Bf@AR}Dhh3mwaAoS$&F)?OrY#k$Vv)Bhrd8% zK8N?8I`NVB@5Og^PDxY~+nN61QOfZLt=jvfIC}5z;Jb4;|3;Ozq|1+!A@L-g_FnbFlJ=BE zIwbI}bp;fhZBg#6_7-5uNFO2-NtLz%PHH2GUfY@Obqg5bGr8=eQTphWy8{nJ^C_p{ z9&Kye2G!0`ceCFV^B(pa{#K&otRBFOoMBewFY+rh!N+?EB==cfftdLG2&-%_{$P}N zbl7u-=ALeZ`ZjAMb^hxl%N8l~MAnku70BqST%(+qf6R}P?6(UWtu7om$B4vghQ6Rw z^o?Z2%?iDrJnMe>FnWALd~$(l0fV}CY)XBH)%L2m*Mn)0S7bbxGG6>M42zj9l-ZXs zd(ZAILz&S_4^1i=_@1Pd?mE@o{{zO_t>oTbTISp9`VCA5Uu=VP_~TUL5FZ$k3;Wjb zc)DVgL91Ain7w}E8wJD&=$Z-(?)|9@LF04%pI^D)KM8kMy=EG4UT0-vy(TPmigfOKy*OpAzg6Mv;h*F=&aiZWLp>`^p+H z9wWOW7Ww)yGV+CTwt+pl248$9uix0SYE|Oej49YV;wVfM$!mW1MQTU3yqXg1QGAyO zkN1zZ^D*_<`&qe{ihtL(&4ur6B95~k6JQD0mR=bJsWf-ArzCcS>Z+il@!k4ohJLhM zuyc0S>(C$Hlxh46r3ppu#jhMjD+*0^){|`}i5Fj4OJU<+BJSELJOhS2z{`K6tSSmB zTHJ@vJA}L)&^JU#uSIF8n zqkp8_?vbzULCZVF9J_hs;~3Gn6QC#%vb*pFb2KcMP@>FV?U@u!Hy4{c<1pbRF2k67 zyB~H5-q;tGskKxx6ZgS!I2Av5F7{17?};!kE^fb@iUhB<_Zk#&IDL<0gp)5;l7OSX_O%3jRXxz+>yqNYWUpI*!)* z$%XB>uj9C|((Jyayhps;gxoCGOxX_oiceYC8eC)tF?D%4sHs8fyHAEiv*fm+Le-fK zxRdt%{NEwmU4HG#r(P097J;8Ve;CaAu5m$92ggm4A67Kiam#nPi+L9+{4EIowVR<}DC)hm;okHb#qgPV*>>#X z^1773uV7&<7##E2#_>xv!WQ0)D26)RvT#fp>D22|LD^j)-HF>O<*DPYopY6!wvQrV zjxpo7IT}2FKu$CmLqe+U4`UcQm^q|wr=7IJO}ST*EIm!_CX}PqH@qH>`6zE8AQ5Ih zF*Q%to!2%r8=JoOhsCvOOSP?=fE05HDtbGkNpgRBk>6&tPuS{k6e;|;)sZa9(OyFz zRPsr8GG(NoRvPuC%cXbD53`Y~Nc!xqdElP0L=aIDOOlnX(Z(~yMzr5a#7{QNhb_-g zc@Gy9rM1{Na^-Do2Gze?@F5Q9?zp}E=5v|AsDceI=7uma{FWuC>Co$Oh)142anGmB zg~6@TxcD*pV1_`gRSe{mV_L1z9;=`Jv8c`IqLTS)#$p6n>C*pfpltvrN;g|Ht3%}s z=6OShSN&du;*VGQpG%LK%=NVs{Fv3?!M(MIXA0)bFhd+$Hs&?63-g{_+i|}?wbGee z=#Q(4<;JJKJdeGiURuyn*Y#dZAmBJuwr{fWiFfH11yStCE_C1GEy7WQR;G5^$`e@f zb_6E62V%%hU+j*fyRzUDH_G>#5q8(1V=Fc#`_dw#ikl$J8m0OCL{!-5u-^e;w-2RC zqja>ttJ@JG0{nlJRzX+aBji#o=~KGMa!|nLd`~1;y}HRYt9Gb~y^JXUVeH;gGq_B` zeUmgqsu>~uMTNOI$~KZLt1I#2hS1KxZk@dnB8ChnJX#=`Z+M(5!KHp*VWf@K&|0Q1 zlMhghh+AVELk(UQdlMI6?q8AQ2RCxOql%(k9{pUUeQmI4f|}io!G&dm_&A8H4wwh~ z8%rw-^cQo3AyA$3JRM>}{b-1%xu*FF>ajYX8eF}5Oclp>O=jEcTbP86l~KRgjD6Md zV56HzM2tv)L0b1qiaNqP^Ap%G)t%}5O3Ujh+jbhyfoH*8rhahum+LMcH8?pwooqI% z5f_@-9S_Gd2vGKZt#dDoMqGwN2f*GK$5Jq@_(z`;e{uF_H}xkLO44&-i@;=LBbK%V zbP;$$2XMg_#ZzAcj*(N^k3*H6_D0=CKfWVr2xm>d-fxsTt7Jx65MKI(Wixh4wufa{ zS@T-7=9%+O_%jqqcz4vE(i#s%7cNbp^WIZ)Cc1pjPOT8m#_P+Myc2iIC~K0EH+Sup z#uuhkv*X>$+%zq_@zzM(fN1CEnySW$IlFM?q|2LrbxPl>+I>uK69x}TA1{F-WbqjP zHjC7qqMN56pA((b@>qsSt(!hygXl}=1;BRqmA;sCWC6Y*rtZk*!@+8sKP8dMg;i%q zPi8}8kKG5y*YYi^s_=U~e%yxR`zE(#xC-p5WljJ1Ak(s{+!d}1a(|e*iFIdx1;ao^ z8ph6IaTU`sFw}8oQSL{^jN*P-95o%0&$TF7d(Qph)%3<6l=D{rj${2PPhp|*Gwi#e zA_1SZIgkj=qe)WUXvXvV>w70}*4~5&zRTv{-Xxw4sC@L{j}_D6%%=O+2(FegDJuG3 z^Vz95n8?JvC*&wAu+TYezrQTAG;gHaYTZxadMO zKAhb7B%$>-8Dig{IX9Ze8;q%REA4*W4k8VNXy`i|W}+!jx%v6J%V4fwrqL_TX(#sT znX*Bx&@NTive6GchMA(>3<&ihg{N4l;cksY;k?VmBO}Y=^!FT!!>~4;aeo*kK*fpx zEH&rvsNsDgDwZL)c6aHV(Chnp*6Cf(Myd0cAZa6QX7~np)&;^Y($RdN+H#6Z*&&MD zYrEw+6fM`;5GH4zA~1e4g{{g>1f%en zV-q>3i!{Ed*J9gF$zq6P+I^PybDxEDs$I2=4qiG4WmZXll4mG{^D9WDu??Z0`n>HH zibCP%Ap2cRD(=n<5*5YtLbmKO7pmsuq9@0W(KjiiG9}8H?9Xnm0Uvo16j`QVV^?$R zJr{iIBJ62yFcKY4kb!KAdOC8T^Z{CtKZATbdJ3@z#C*r`)We*tZP!{kCvnfz4ZD@4 ztAAQsi#(ANyFcCIOqKieSN&8~a963CXlO|P~-H@fQHucixFLYdOcjwe(4utW1V> z7?fe9MpE=ZA@s(m7k`+ZybvW&mCK4jT5tZHA}ilryD=Sszn4L8ZHy08giD3IYS(ZbyGeR6{(2lgfCiY){`u( zG)qG$xZ707Hbc{bxj=lKtc+4&ML^QQ^0L#^_O>rqzs$6NLTW0+-y?Q8eidl&C8%)l zJNe8;5fD9e0?NBVgS_RKv2m=dyFWNM+^8ikx1f;Bh{@J+-kmX!0 zlR?sq`OI(HUf3X%v+{6ubEIVKm9P5#f#*<9i-atxF_tLud@XwK?LJ(GKa#x|upmR1 zle@VqMU2B>xxuNV@erNP1&eyOoCbUCfQrttKv#f0GVK#xcE{pdC&S~jTLBYV&ajyG zNe0>iVLb0Vo%6`s*Z(`}6t*D)xnUU)pzfsY%3fn{GDe7e5U?F`zkvT%Z|1tl+Q)&x zwKf$R>zg!>p2qxYhyYtakyt}H=O@~a)(hpvmtB-&N^jn~prQM*EemGne7Xa!2FE}f z%MTw3b}5Ey1azrT4&OojnAe%^D#0CU8E_Ao@wAFom_O=^;}5C*lsdN3FSjtx5#?2k zm@%tdT~*V9rT<`#SvOJ=sM?Hj(Wl4n`3oS0Lo{g`;dQZIWm%@>gNHU5oL}siQ@y%p z3W8FRH4KhROGc=HQU>)NyY@fecIa@D~T2}?J|^^42GEL!AZrS!UtBAWtF=-vuBV0H)A zZLqO|OVuP>W~_y!pn0peE9!Dsh2EQfj))N6T^Tapj1SeCw?`!8hH{3p47a~w?~cnk zUR%mZ+}a9YyxD&z;qm8FnGN$Az z#$|{6$Qy69VSbY2M8C}tHyOiVcf{Jirh{SJH^ED@Tf?*u6J&sU;{ zz;9VNnlv34HVcn0lM|N3M$1&yqYLw&E!zSM zgUj=H{C5emXHq8O5J$UD$+WL^%<|SrReIhJn({Wuvv*45{_6k*z3sUJ_|bxl>K0UE zB}fa03^Fax!_*70OQzOc!ct-!#SJO#_cZ!dkV4F<_Dv0OJ&&`LsxQw>gMQd{#6f5p z)T**Pt9OBZRgzW9X0JxX6n1=!^eBv;gz8W{?xAuAJ7o_^F7I7&)0p(LvF}ar7M9lN zP~Pa;Ytn05(*5as@pTV*0N41*`CMfBKTqzvJM~H-M}@qD#_a4!+JV>-g;vA)I14!% z?;^eDgYsihWGfK+b9%v0?SLQx(+f4l&=#vK#+4C$gG*#w!!lN}jLOic&*&zhdG$vM zI2q`TcN+FyU2^5!Wk0_-_<$}uS-L>FzXP?Ep`_LyMT}b;#HGoF6(AAYXxyr*g_PG1 z700xP`-}BUH=g1h#=-f=aDv2Pm{UN-_^O)A=9kNpdyTc8U*!#;2sQ5B&wpu7yOdgC z4wW~)SlXhoCAfF$_Gm}3#7D+eVlv2$1?Mb8@_cu*43>*&wnj8FXMd$JpE^I(ipc2% zIe5|ptZpm7sG%kfsn>?U@ux3W2#RAXJrg3ZtWMo;{s)m)b1l^rG=N!AX5BWH(#Ds#{k7xL-7lzPAh!H=}E%Ry2h`-oexG7SjI zNThO_jlkGix4OFD(NKxgQg##M?#8n%kk${J%jn3Zi17NDZr2>r2+UGvE znhKubfq{-{s+#rQkh|WfVSTKoQ;!+2+$+~Tzf29>9few9x0Za4w?AJ1Ic~PHod*8Z zSR$|XJaMrou6fZK=3kY7u}hSF?D(ZunD;@wjhaR17k`{J8OdebrTNM*gjaRR5($0T z9e{={3{biW^J~Yf+34k+Ud|81L8&=FooYGAkRT=EdMOqV5(zL1E3;2p3BnyRxyp>} zr*+-WxI2v>FlmK)#pkG1Av4+eH7zu37%@GqiNbTS%Qt=~cNl#oHpilq-|-3f0U*X~ zAK<7t@0KX|Sa=vG)XYdEM6F3qO)`+1nN;@x5brW~S!SNkH)SlsI@5UKVu$aap; zvsDXqyx(gxshQcAfj_M~LjP)OjY~-k95q)p%iq6!^zN1@eDqdCozR#Fbw0Z=y;R)i zhnh`N+ZD?;`f;qG6uOZqO>pk&$oty;;c{%fAAccV)t^q;D>V{{7dWvY4`+X41E(W_ zPCY6rwR*>M=)8G$QOzqn#RYsFw`_U40-wgAldI;WZ|G zORA)S#6xO2{qB@ca5_GLavW9%MC}%O%H?|iXG09bNqq*gb40D!*4$$9U)kNA0J%@> zx*pAk?dyqT#rmtm7l%b#y5Hmhohtb+`Z61`5MEKDNumBj!|L;SSf)Xm*XX#F9hPQsq@Y znW%b05zt%G4o8*Ces-sVT|~3e{6;$1@Fm5O(6+{t@kn8vHMtdmCxux3>~R820#ag` zrQ{GGosrVrBK@Q`JM@M&)1VH;GmIX1xnl=MIq|F!iW<6yW2tKoZ|@!D%q8I&KKeW56I!)S2(*ctt_;D9-l5;jaDKcxG?kM*96n8cK6LlC5y-Y(@OjH;Uv9K0KYk zMw2}smK`^nt8O}E(~P=kxNF1->A_4rwnkZ(X2rkH4rAvkj{TbULGu42>b&Er{@?%K zQlas-j!IKT#-WgzlpI+{vYlgP<#5iCy(y)P$UH*Go`(+Sylf(S?{$o_r9+w7zo+;2 z{ki@Ar7=)b-b!4jH5pH6WflJk&QMfJ^vM!=T$Mz)s!F3`X zz3q-oBD8|BxKJ4g&t)`Xp&UQEq?``2S`1QEJ!YRiaI$hH`Di~cnyK!#E5Ar=#4mg$ z?2j~WiiSK6u5Z!JwK^;1@*?!!W{mmFFZ1%a$CXrtr+DqSBddo#+Q$3Fz}65l+#-l< zBRwur!cmJ+9ht`)@BA?n0BZ=p1)TS`>+!!X4(Sd4tT4erm7iAsCstxOW|m3B6Y7X0V9hELn*;kOm0pve~qcP;YFJ%gk_ zou?@zjC^}&==yHmTn4;ID#E7kiZkMvlX3H-Z2p*T-3QbG42OK>oeX~#U=?oKVbN=y zTJ9()B)rj4HerXf!_;xigFd$}_JePXyX5;H&x!lCjw9jkg04k$cfO?@R&ECQ9Ld#^ zDduVtPa9$!>;Hxtc_ySpx(hIxB~D=h5~u{GWSSfE)vRfkxKuEcbIXZ5=F~b-wv*`+ z?BO__d$Ak+_UiBUcF>dEx;ba99YV*1y6@74pJqj00TUQ^uBfG{nDNyFFjsPOUti^3 zY1>&PI{J@4z+c?h{)NNnl!^Pkv(4?%PVM{_!ZVuA441qtnv#0&cjMDT!@fH890w`=ng6i9*j?Z){p8Y0VhtR^SJ1K3hBs2jJOvJ9o5deLmvDUYJ}A?eAb*)n zY0#h~LumlbQ1J~XILgiFwJH{N+C%Mo#v_++NvN5tpI>^aGw};c{&Cx- zcue#=aQ;FqapvxFN^Gcm$;72G>sllJo~`}&-A2gUAptLo6*w zmYMwe!W#Z{BGh$bC5SfXF&dst`;CKZ7aNQuQH?+FkJG$4`kd_&)W9=s9y61hEt@2N z%R`i)409Tv{lF3xY_$t?XYUm%Kic$meEcTrt5fpw7-ZIM>H(r_!^c|$U-WJLlHlEl zs^0Yo`{XO{nt66!&PUELj@O+LUt)_>UNMTP{zlO!i&)nzBwi?Z269QiKFXbX(Eq>b zloF8sbSiT^iRqT9JRaI_tBlNq&3ZRHUrpaYqKb%V=agn(N*;fVBE2}-uG6uvTL%3W zt9l8lu$HuM7I9^S{&~+y4KIr#kk|S3WpqvQne|STb!EodY%ouxGd_|VxGdW5*=&kV zIQELYtTKvg4VgO^ri)Bn4)zH5HmWN2yOmC74H6wq5~r^6PqmF{a@u_`!6W|)eVUKL105T21rngaUni8Qemw_(lZz#k!}3-b>HVk1T>KF&iTGmUbIfN zi$6mkrK^E(- zVXeCmD+5M8jRUOTIVd?M7abt6^ke2OmPMz}xK*}jv+}+Vm_-H7}`A$^) zxvDM0-b%k=20==e#8{*Y?_;I@bMqkCvs=A-N;!1-2?tIhe@-cG5|t`F!;qb0OYMrP zJtE6%RNlN(iWS5bczaj6Viw1{9~y0ack9HxII0aFXFEJCuLsseeAJ3YVADNma1H?h z_Y~FmypNGZVoZ;M>7!y;3$@kF;>#<(XRcl2fY0}ESjSpyo!k^>8gqw$`pD zP>js@g&6{Qaa(q_p4s_Qxk+NJK@~}#yw!?D_!MK)aE_bD^x^Wi&Z(OBmL6J~K+ly? zmEfK4%L3KK6zUWZ0X{Spv86CRA@Iy_r7~*~?@DPEGyDI638Rk&@`9-}w58;yifF)pQ z>zmS{GjHx~2u#@8ru~|a`^R2I-ra`mP>LI^FFauyD2_^wt;k>cK|@w(&B}9^ce^E? zdkPRnY%rZ{hVPTW?@$9s89+#-;h!hzeTrBn#+c0BZ2#LdRD5c@kTzm2NF2o724uE{-9Il*QL zv?V3Lks-d2%{?baUE_%!RDYcIx~JL$a+P!G6&r;=Z1(mr`by~PBN`2_HYwGob7Kta zGJ>bYjJiT#wTn`(d3c_0PmBI~p|=%V%2 z<&nS;@SHdd3W!bLM@zu#FYh4wDBv?8>;U^K~>@IZdv3FrYAZgT~e9}6PrTdls>X1*j#Twu94~80L zm#TPdZJTvg@643OM%G!`7UZz^zt)?6o+AzBvkI)F1!SzSU?A6Fy#CdgW_19O(?egA z6Yv3A6Xh5uFr?Dd(6eJ0L@0uCK zo4pGFI==7GRlGhn%FlYC zCpEax*Lz-Wr+Axd1romb-mj>UQe ziGw?x&wEEdxUW@S-(7c@{IcON5q)z8lwvJNutxmUzNBWu{tGlucqI6>$I;>1P|*?5_Qy_{b?;F*Rxt` zJr_U%nY_-;OZFyiY?1?)yLr*-8iR|ZTTtMZYjg``Sj#3b0m)=$0~|4om#*SnfMqV9y(UwOdwL&B|R*sHY@(HmKk zb@fId{OD=`^fv)hs*y)jSR5qArKDLTH`75JNdl`WnXI_?JuOHygJP;b9*Tce<47b1 z;7p<{x;A<8MbPi8{odlLzfcD8i8=);k(khsWJ-L-0H#Hq7T8pm1 z9q@)i`ZRB!Q&=)$Byw5!OI60*yM+jrO$$!AWchmWqZu%Mm13k%DP38sQeXUHjg^pG z)e;MNVVNi!T~dfzc?^Mtp#l%H@|Wz?F1(nQ;ZK zu##wFNq;$^-4vq%#-cID$zFMRVdiW7)x<;B<+Sm{!IN<}a<9i+$%P>LQLM0XI|l=a zm4tZ}F+Qa1T6W1dVMgAf;M|f#wMYo@tc7JksLN_8ceujYBJr5_d;)cgr&|>*F593uyc2C;YV7+U*lZr29-Z|wK7&5(cLpM|OkJda15KS+DZJuq*PegR*ZuAwA+#?>alQt?kR1{HT%vzPVhWjU_LC<%cBWT3X1 zS#NY6O6dY4by+aMIwHLND}G5}UNi)JH=R{Y^eDDyv<9cDAcj6J>a()W7hZ#r9-m_X z$^$_?XNP{=;BFMZ_A_Ma?fRa-eoI^(EI9y&$oH}QQu4{%P?S5{hoKr`&y4h z7YL5YnQeo@>_l;GXnHznyuxcgvYyrdvmrTs{L>5_fMn6hE$(aCr|TVF0qVHI=`|p? zPx;xu|?&zYq$^l=Ysb;dL&?m zaXadjRPP_oI;F_PA7WwKu9S)iA$`zLDjjk{uJSGBh;GLb{}!=%H1rrVcV7V}KLXKJ zu6Q2gd4{DGCUUVmT|i$La3Wom3gMQirJVF!F;R9hHqUp@lg9 z3FN?e&t`-yPh?A6WX{IZ;v81(PRihp)mFRG;`-Acxjf>4Eudf_PFNU@pC^|iADgA<+as4NNp7*q=_@jV$ixdP2) z#6C6PJ=3ggEnmyK4fP#SRW(4~1F;$BVshcxFWk$t-@g;Z@h*wO z4w*X;Y>}H0z7hLe`L*18-IU+mi?8tFFkL)zJhAm9+`e~1TBoi3!OA56jsH8*l$3$h zg#X_!W6WyPFYBC6lwg=nHPp-VJ#g`H>v7-9+y^C2CA*6&-)8J5{%)wg-PzBNSx=#i zB+6s3sJ=TuwE!%ZQsm7A>hPYsqD^?jxwVFDBC#&)>iEbf%VTKf_;GB=bH5fZ)s_b_ zkU>6%J~qb|?U@skp-|Ete@qpw%vyuR(Y+qVmn>Z7Xan8JPWRDP8y7S`^6RA-g_|JB zs1g6s;&VZ6ZpS?DrpaAR{8sxv?(=asXXIlh+ti61^-crZAc|`~ok*{~yXrO&OHHAf0Dy*1{%fm-5^4>&VpfqDJCSDOgImb?K zXbL7QtyN%qj%_-1effFH9cm?TCy&O>x00u=Dj0mzi77tOq~u~( zziccz@&OJ$Dq~Sz?04Q8YoJeRkKnodd51_Fz59TDgj*}F4Awu~!Mlwp8SrcChWvN_ zbY`@un-vM}Q{aRwJLPblvRg+VIQ*|+dIOyYHk;i1J_tIR=jW0FO0yp7;Rirnh<}YI)J0>8*V#U zS-QO>1|aKgg}Mi0hd$={fWt2xIx~75!he(k9#;p+MKFbp zTjHFI;<+!}&L^#9Y=q}#q0P9Q+l__S5sasHG(IyX{jyqG*o-dKNCtet#la#98FwN3 zNYXL$>zMyl%@5EBR-9|~h2E4v7^yU=in}Z!E1w^td|K?{Us0LK(Jod;lEx%d(x(F` zgk!ZpwfO{P8^IA+V5bRy-VV}dJ-0iCF+P5PC%;yHqF4vETNqnPHxLmoE3xY5C(*cx? z(xN;!{2YnxCq7t{98PZ~IA#XPWBkTImeA_WN>|b|Ad7k6qpa6)%2-e4>feIEqMaY_ z1f_l9ONhr|uy`lmA`0&rYco}|B12*Nk5xn7_9`Xq=rJmfE*(0@AqlkGj6&fCabhog zWv!X)ESeF_T=bsGPP|?VeeP2luYA~ z7}A|CJHV5_-X0KpqjtMa(;~$`i$nY!44F4Z)`HNemt}l`5e-&5sE~UQi_VVWc%(QR z;z@WHmpHtQK0v!GqJ{6VxAa|SR7<@XNNyj_Yjq+jf~Lt{-^2~R@I$q0KfF=g^*hPL z(|7xWhOmv_AYIf#oo>K|?7xyM);SUIY-`g^m`{N`W|a5nDpXTt9pv`6#q?8zs~2p37N0 zeEtjfI&WOZG6x)f!`bI}6m9);P%5j72ccbC_ zvPZaH!I^|KY&=Ux2-ERy>Ab^v6!P6(zo_2?$L0pY<#2xZ335|6VK=v#>DTxX;A`e z54{9YES`lw4;gW~{e^7Fu*|M1B3c+7af?8Gz zn~Miy-^)-!dH@IN`;%zz?btR+?;i?V z92|3P(F|wCtTk0L2bNYbZV$glP)KYfgl$5_SdTjSX{<{M_|Y91{;|5S3p;G*G=zs` zFvEEm4q`o$>zS^3Rgb(6YZfcL4NLG|_V4b&FsBEm2jFZO(%lw5SqbQ>%xX`zq#&+? zaO_?pt8ia-KrF%h7l?>THh;}3X&~r2<53d9qbEg-v4KO;{VD}H6>|1EvHm8gkDFhI zqzWq|m1J-ui zP9Jx<8oCWYA6;f|zl0DrlWCi}^O0yO@iC*D%34}cuwcI=Au93lsZ(~>O-&1`ndD(TMs)ifODx{h{Wl# z@_eJS4_PWUy1kHi49CF%wCRin#Ak4N0XTJ%gg zy}ER9x75Ud`~Yntdr*sfC0DOoGm7P*%*i2!sPe*F^v^D#XN{@H()H&DyJ`(2WK#@3 zka3Dkei!5` z??QgA!s{->CpV>1%@-9lbFJ3m)nfU3&L)F^S`&3jw`J0KX{U1EM@B#5CMU(7L|NAU zA>rrTQDAVBd_>?uq?_N?+~v(lNeM^2zrCC|3F)5Xge;rhidUm;Z*Pbs$x zoa|O6l=@i15VpZ>x3rT0%1_s$x1JdycxP+B*N?RlbbgZEvpMZ!bohM4jA*~i%i_Wl zu0FTn)X>So@mY_QZ+?A(Davke$!GgqzrM=+aRZ0G`~$S(J)3pkq!Eb)>#}{S$?;3i z+mQ}FlEuDrBS=!Zj?F8i&ay;N%&^wWQ%>sxacr^Q2F!{@B8FBNMho6$yF3k22Sv#r z023%!AFMVOdQw&W;C^gjhWy}V_B^2|!0@={Ao~Jv><-h1f_Qnu1x{f(t3qdCvflhLq|eqzFIGs^%MG?q=;?jh6>dULR?YE*<*Zn~g z>GS4G4u1-Z4kQM7KSN-RwT6z}Pl5(Y4W0|+6cLx6AS%5a`*77)_(6-(!e`xzN123P z91^#Q_*&-WX^Tm#UI-qW(~*VsI>kDM(s(wFr8GgT`m~g@_FS5+xwWd9R<_0w3g9U4 z6_N{E)22e5l=^Z7<0Pe9du&K1gR=uC45K;^=kw)49M2R1kt45cO$KyVgd6_s+nGV! zPeE(Q3rrfIhvz0Oq#P;O25v(yHr1zvME`8+WccW5ge2bShLR3@cAN3i{py93SeQ;9 z#NONreZSRX#$Rwhv7!O%Zv)0l&NVhKY0Iv^a&~RaM@0U10MD$R=s>H}gw&4AlpX*y z?O&&>FK>VBmKl66@xX$#m~tEGd>KFi-oIRX^nY5JHYvoPNtYG+&3?q$&jF(na*35xpi+kCy}sa!Ja0t86b+~)3i?M)u%)D~l7~26XI?|Ns!YLePDtPG z%%S_=&}CV2adkB!D7=N--;SI+A0e06-FZ)QAUFxGJ}k!0QTcFnqBEu`De0r&pxj1f z#V=}Tx}{ad5XrV+-Mhdfrcdcnpmv?^r(=zW(n98!1;Ol9yNu5Pw0~r0N!%9aXn-xB zEP{z!SbnmAQ?v}Z+SP#NPNaP@s=v7|Ili`QYMHnr51GbEM`aEACZ~rD*)qrXoETLK zz0@^;Ma1Y#c#iDARGC!cXV=?x4Lq4YR$S|lTKbaq=loL5?%P7_Tr%W{EC8nJq70@} z`LT+V&@I)4`^K^4CYN6ltqHX=rqXtm8|x0DE9$|0oNPyIo|$kK&>s){FP@-%hZ92Wg-$N0Y66;Uc>LF9V$2>`gJfgE4$PN+8{wS|O{G+MRRkk9!_fE9)9;3QL5i$E3r_ zu#@>CC1dY3lR9KKE2LXXl~bF&%aTG@aT9VbF3}YeJfg@tN~N^oT8B8g8HrY=_S}Xt zzWxcMSye&8?+M2u)Umi{qND)aTkeZG6TCaUHp2LG%e`f7J84xXuT^f`%6?k;6Yn`P z5}2bcDAr|RX=M7{-v`S%6ggDE4!)GrRKM_!s#T@EiCq04bL^njNO57Yd|rz#Rl0ik zTq~d1YYrrFMe0&sA>GKdAxi$o@LguMA77+q_S2T_JR8)#8KWWL zh+m6|f!)D8RS=Zkx^HX;Ch?t|#7QBDwPYAo+eapsjI$4{G!dM#1!iw@iwu(;VwZb# z(p;?L+#-a4le6KjyWM)jm6eT>XsZ*HHq8fzG+uyP)EUCR$fyO+h7yB;x5cAIHY`z0 z@i3!K!`X400=qdYFwOO35aU$X#4lAcV7Gu-{gXnlr?o?>o)dw zL%>a*%d-yP-SZ22P4^(s48jELYz@7~ssXJ*l)tsL${JX@9CfIauPgd&KcoW+or_suAk{vzhtJ7;s}hU)I3RlA*(&8XVs){(00QwXfCapVvz zUnm05Fbu2?CICNnfA6QDt)E32V{rmiETY%E;!aey7-G6}?kw0) zILUN<9L=6c;a`OIMwI8IYsox?OU721MqWh31UR+<(AL1>HE0tSkCzIW0S+E8^w0H4 zh;!JdA2V0iz*?xXpN;1b3$!ceUgvA%Hjw?C!@Mh&Zotl3agLDL(F1^N%g_<(3?i z;*8ymv_#+)hEe#b3~q3xKF%`|kZvlZ@YqwPyKAor)XA$PC^{sal6Sv42g^jT9$_xc zOqaxLtoTKl*cTk^yEYaSLZkG5zXLn2K+yv77bSl51D(fonl2MMhlfOTRX%fOKI{tG z!79ggq^a^V$Rg3Wqg_QMhug`cruk0+Ky_YGpj%BlSJ#;oy^#jQ1YiKq11t5I?L!SN z+=$L{KSNVE{&vHL`>?FIS~jcX{{83Em7-)?`-IzIZN!nxW~~~=8S;w>p1);JN@R8V z)Ytk8Vu0CPansHgdZ_`eYUo_P!8RI_C~$9o$;-g16n615X1W{v@3bu`to^>r8N`h` z4~mu6bQ*L7>5)*}GcJF3w9ISg4u4qA|DH;k#4oG_%}>~Bgz@BLlFMhr`9<;af(ySA zxi+fsg_l=~IFu`;$##W* zB7hLQ5kU#3o;tLeIqIEQJQdWmjjEZkQ1)EbwZ@mam=M&vCPOobd|<&-mm?&?($` z>)b(=bT0AA+j+G4(KqZU>)bjef%}wy1fSBKDD$K0&JPKJamS4OSg1;wl3w&D&Rpju zgl?s@*j@CC)CG0CpIshp+}zHUMR0faElhuCB+vyDV?Z3>R}F4hZ_{$c<9I z=!KB^W2*d7u%(-h1|KL|f`Pb4Z`PD0&@37OSkLx_ogmmhx^#Qv(6JJv|30Un+@O-%W5INE>~Xrp9?p_G%%wdt;gYvu);0`9DWw_Zhgt zA8P@>@Z#uYRgyke4I)>(+-pv>+_0nZ+b|3}lD6W0!}Nc3Zt@JrsIWR2tEqRXU(V@I zBb4H4cMQBp2a510>je4S7wdkg>wCP0Zprn3r8ZchBWRMkWw6un8=5lRiogW8&^3!$ z9T+QY?+HzL{H{+WO_?k`ptJuDpXXlrHP8QzhZfHRyS^a?WEqrRZ|g4BS(rI?qIWIu zWX5f^$kRB9mC=aqHP-^7;@FAm^K_u}r%hbjc6LDt^_=Rg2Oi$YL;t7Mw7OQP8Adiv zXw4NvJ%yEUh)l@vytng5-qyaN{o1v->j3mBWYN*g1#vo>YDKzQgYE zd8a4zCy&Jqg`PLF=FMq*Gc`L6;F27jSFE85j9KY@UDH@Sv*_jI0HnLYnez9X;{TB- zv-my2flm||V8I~D+9n(x2xp=x#Gr*rY#7iv+)qyQ_}0>aQm@mg#Sdv^@w~hQJ&c`r zOw}94U(XR#{S(MTO7~!T3HL|3HeS6r zV0Srb@{2rmRJ~-91F?8d#m_uN(}pVk&=}n9Ciz8M1Q+4BF=}xkZy`@^20^^u!`e(h zqrk=k`%&+^&pp_!2Tfw_c@o*8sR1}bdcQGX@pJN|aPAqPH#0Su;}Zo&LPb3cU}qNY zW%E7yL*}Lr9*TmW<=1$*-~Rq=M-u++y3Nck#+LU|qQhljuxcoZcihAjX{rT4CYgPl zirOJOgsBSa!3zK>2l#h~Gz)=4i@$qc2Q<`@p`*3wE#aG6JXvIoUDc9Aqo(hf~=vPQ{{w(?lON?OYEEcoot8t}YyC#@ zA~k>8G><%@^A~_GypbYaLfOsVkVf7J&Oiot#XpBQ=J5zi?sD2{0wtjRk<8P|BX&66 zpDWHgF7{7Qwu#ZPeAuHPbZ;&3AfmgrA2BfL?YtoD(K>$=Y@;6o2-}u8WT3J<5_ZbF z(F1xzM{Uou7!Z@MwJ6MRBT_5Ad6=6}4JWYSmhqJ<@DnmFUu5a;3>FR@Q_}fQhGo0>9Al8}tPD_)w{Oa!WuCHiGRAxK z_HC@Mr`YCTEclvESACvcpX|)wv}4camk)jbD{!u!C&KGEG1?QxZ4~pE9Rx}Hvs@&o zmV$>o06Lf-`P)&8S-Z)=aB}ZtU(aXl3LS#qU_S0k6gS3+BS zqaC*fCpjsrSAb#EBQdI+d&BJB_1OP4g%5-y{@u}%45k^V*@iH9Akw|`yQXoR%B&)~ zIo-_j0eZV};4|Yohb)X#zsl+Tb#`)0y;V`7n*rja=mkLAqOl7MdQ>DnXeb4o{1}qW z_gZ^F+Gxh#**kmQ);kPnO^w0R66OCGk-5ZigCo3xK>DfE6?bkY5HfaDoF@id%vFPj zuC4j7+Q#=JSE8C@Q_J75HesZxo$p+4r?zQ#_8gOp9*M}FSqvshSW0h&@~$c7+W?l& zCr7Y;hiX;xvq=Kg8v%2V|7~WGdr^>*AOu_V8;&E;j}4D&jV>j zWwN{xL7aNzQse;$+Q??o zJU1MYr+lwD&*0`JV_S{C8HX%H-+wH`4fanC!gf@6c7fJod?kMS6b!ITUId*T`*lls zEb0te;Hh_p?1)w!EX4RPnV!rVLV2*-aG(|eWY0OnCgT?7a4fpgA7*^6Tv?SKKSPKVG0+0z{>&fUrW4Ob5?B4VM4_#wrZLrb$#P&Vvq#&@PzpWK_`xdHa=)Lnx<2~3Lk?G*H1*g|)gY%w$ z6M-|DXm2=8@p|ofhjdleLeHKVt)==5LWM8xFAog7t!eCq5W#<{#y`_Zk1UNTb{5#} zxBv5`x$9*iT)S(^wOC#oSH9T)Nbf@gpc&&7Nf-=%}JCu-|O&m~^V(GVAB zxAk00IV06T#o!H2lC#(8Hb)$Iy&$OmL5@nL%(;IDDSj%OOEEEWCY*z^(oYY;>xEsK zpVHuj?YG=Nvy>$Grre+Px;$)#g6<42_`6CVWKxI-!uCa)&{jukMX*(ZASZXnV2MNK@xPl5!KRBr4o{o(nUf_|iki{m6|O~==v_3W(FV{E78i-n zcbXU(dSYb*;g!KdAZ{v(wmiF}%*63)nVPNbg%_AV%_=e+q&*p{T~#`?cUiX4_1uMp z5)me_xDErCFJcSuXLr=oVTw22>6+w}n7cZN#8;Vq0ee{}2tOq_#Hlw!_sIE5M`}vfyn73zMoa9ADkKQiP~B34{PhHyYof^=qoX=Cxc4vntyEJ{Y}VQV?^^iY& zGh|4@)d%4hbY$Sf2~M_qx@ienK4ahe;0jhC(3{LD4nH;mLS+*&IVK!MI)rgC3U`pA zikgy(-3K%uSh#dXxu9>LZCPF4Qt{n9=_O4+56w_)197Y2$K$*Z*j`v^@xh?HNkOCe zLeu{Jq6tiUbm-c>8Up|D&CEN9ofmz8orihon)9Wy@g(ex0hO-d#nmeUR4EUaH%{pa z-Hr)R`&e%{mfq_JTnX2_^G9t=FIW)a;*sYA5{gzQ+y=?XJ9lr*xFporGE=(_hxc0) zvY-tm{Ylkc`-)2S_@#x*>IF46cjDq7+{wm0%kNnP6Vis_-)u^(|G7Onz zt{ukDD%$W~D(Ei-%kWTk(x-HfX2kstuCH0E?QgiCIi!70FTMbjQG9uhy_x32DQprU zKg%afN0-2mYh2A_wx?_rtewm5aglT<07*3D_?sTT3+O$K&vYND44CL%k&VfIp^Kw7 z#KQRyQjwzTom36LC*g9oje)E6DV&zTI|j)Hwj2M}|2Cp7=D~y}vnszSq-Y`2A&W@% z5_a!-pAldq7Uj?NaQ191q;dc8JP6^fq(1=oe9+QgJMTMY-P(Qp)EJ}R2t{pdQx;8n zQUi@C>l{f(sICeU72d7eSmKDE=&`um^`sAwo zgy)BNm>e6als$Xseu2mk?8C6;4`!rRjXBd_gOdO-5D$Nt;~1})KX>7QSloN-a-WMn zduqXu)3e87MpVn@r+Wg%+8BW&R82z{CIrZhZ#g-vu|oQom~$LR1ewAOPL^Sq--&rn z?dw-8mJDG34ltVlmexw3@Y{|B*wVEWc+MlTjesuVRnK+AHDBY`L92-2HPB$|;eqlj z*dB}ADjdGl$O+XG2t{SWPUmeat;}tC%gkM;fmUj@-BCDU!=$D|;p>WTMo`CmXL0DX z+5559WjV%FSb2AR$F?ZM*7(U@`}y2m*5Gr)T+=!yjokNlv^-R`98=YMrNC;4#}@${ zUG$vZL`2xsz${#&;zGv&zdBe};YSVBtkaeHiHaCn%dq0lBMqjVnHq-pcrA539}-*REORZ-af!(;Edv40b^ z`8I>iT3A1J&BRkj^B^OzZky zB9_lY{EwO$`e%e+Mj55G5Xz>H>HoTSaw_ze!~r{T_)^lV6ln2?_Q>Zrbgk#;o^`{*M24UwUN~6aJehohs(X(?OuQ=Mel_D z-*!ZCt$6=!`B#3#dh_4@`^>8Gnn6Qm;FZYP_=Vi(V3iZ>C?4;+I$TT{F0>u}3Wln2 z2yClF$%Np!(@zwJ%`kRp1vimpN;=`F8{As2Cb!{B@O-CG+N}M_2EsU-j7+=P8H(c9QD(gv?;IoL_HF?gZ<6mm&vj;I^B(ZB_X zAh1_q0oo8{YePKro2S;t;FY5EyKhZw1IUtvmXT!+i~f&hPETz488_yh`9U90b9nc) z8CTU0@8cUh49YsZpJEUQ6_AqtXE0Z5DpQEDENi{)2Q2|75jP8U_3&I!;=XKfhqYV};7CX99*J90gqBsyaL?@N(3<{)b48$=W0fyo!GGm;6i@mn__vM9E?J0?K&!Q_Rp$JG2=pjSGq+Z07Dg z%&l@ov5adL|IXl7*fz?P&uOjDSt4ElTLgKHWXT*5TYH8LI9mR2JqRA%pt~{%zO=Qu zm=^NK5yJa;wQB0w_%XZRwp7W452CT-8kD^=J)qZMcd3x^i9QTWeeFJu;SPFqi6BZZ zW59|E%GCLMBn>IL!xC| zNBJ}=UoZ5vz?#R}csM8RJpc9UnrVMi`TVZ?F`VY)Pu-wL8?I(Vly- zm*e1Gq(NbM>~oQ#VJ`Ij{&1Hd!Es*8{h~%=d@WhTsQDU=Z|X0 zK(5nyQi!NL)+5;=yu0L?0eV7?ePL}nnk_6|gvV|5UH`{osOEsP#WTsh_$#7s+i>)E zN^*t8m$;!dc@@Y+?c6s8CgS35CHRGt1%gWn{V|ERaYGy6$;ExmHEF2rSUU+wD=lo`;YfMC=U7M3d-@a*Y{5ijq z)oY4LfA^jV9C;o>RzHbL*_4kI-_FTv^4$67n&Nu-tNh}4i1|)V%fTMXZo_NZzjN9s z^@h4#K>tQR+$z)oZ~bLH*L|ndyi9k}I-uPq+ZZEe@N+uUdZfW+OBr2mE4$#<*NXQw z=%`r2NNpB(ws?1XjoPIqzS@`nzwGFCccIS4-$&{2lRi4XyH`T~L95CooGDhcMNK{G z@$aw8V9(UOz#EbgvVJafeb8Sw*B^D@#`9*XK2fUG`v zE$qd^zPlu~)uHpGNypcnxO$+s-2TQ#_kypT9q&!1R$*2%Be&3Mjdb>c598)c+s0OV5_rkd7NeEt_yR8>kMx}R z7ja2j_^^u9DOLB03-H7x3D#RhmIc=yQ{E+0ALpi988(sZV_Pn@t|OZM>}IRIo;dKD zWpRZQW?!5i@d+wF=@j_hYc)mUeVX*5ReH{f{PP1jv-eCxJ?4R(kH#+ya4hn0=)`g& zvHaGmIVVk~UhkGRR5^S0RXGpwXE@@TRGgzez+BVx%!|=(6B_~(xu%;5=Z=2!Ilh` zQQm8k<%23a0m<&;ynd*iADj?WE@(pYK1P*(mLQaI>6MrqhuX^3AH(QWgOvN?4P8I! zmv0{p)0{e|Uzv)g9;xs$HN5>H!!=9sgUqT!N*k z&h;D6_KAk5luSRboi$uhr(~S=@5DQCsK*bU+qF9azYaNMfe5+;}{ZC9a-9By7(;d z4_j~86~#FIbd6*=tX;_q#XA zaDJRw&!zL*)Vn!@wae>QSY^)sEjnVXV97I8&i!$6_(!Czs(5zq9&Ybx+o;})SK041 z5?UG|4eJG!%PAIpZCAMjm@GZt&iP@i_VA5_1{|#tvoRyqm@V#eiSCS~Cu8(jOpEnN zUi7w44sSWiHS~|J-UXfV>kIVxeBEUlk7>yV-Riz2(NKdA6nCSI@o$FC)xz)}J;4VS zP00%ORtN1Q`-%{Jx!-uAQyBa&4@~fBN%SE9YbxYS==d?IDFgxA@qf>No_8N&9=`W3 z(pM@&vfZjfseiCnRG3pu3I&qDGQA?d^HfD7?m@Tbv8q+kgM92!*#|g)D&WL9eR5j~ z+u*Q6DwL1iROzZho5+41ykTGX{fiDHNSV-D0mnC`294@xjxvpoC9}NLPM}BLX~2|m zwdD(ex`w%5WlT%-{OjqbnXfSovh@G?)O>m*5x;6W8sUdnAL(3y3(#}fVS_sK@dkQa z0vqIlA`xR2s7|ri3kkdZ!|j~s5)}pF^SJ#n8z5PDIAnFDwIiOb<+XS(D;0fyH9~}e+pad=dTLgvc_ox zvfTwbY1Zv?zrT0u(2zV;AB&8<%R0YVL}}Kn+9l!isJ1nkCr(-gJ>$f7jEA-IOU-$P zKiwY?AL^c+oz1+gv59gTWG(!jv&Ti$=zFNNHz3ympCcJNHI!N|W7NpX8#}l#e7z#3R%`@}8_khKh?KFCHO3c-_ zj(S#wn=>JNj-}T#(%o4uHki* zAn}&ndYyEuXzNU;o87pv32jC}V{o=5J>yUudi5@&fsj)8#HU2@PDqwc6ffF*v*2sp zq98O8XSebUCOGx?&f(D6>q-Gh_a9m{m@jBwd@Gb-Pv0FBIo*^OAJpv9`cRI0L6-l=?bp|?C`!@$)9)J79RBB*U&(Nur zPLK3bjWP+>MYCGF64=z@%XKw#{P86UlpzD4v{H)@XT5V9sSmy(I;{=lI}5tKY~5XE z;QQC{1_E$Ot-HdD_miASAMJ(d=G;GK)=?ty=6XRc_{lx@2-jJ}Cq0`%DF86#z0Ibf zK52Kmg4x$$0LMnE8@bM{ebNq6{SbGBRwe#d0W%55ru+RffkW0rNIFP-CJfta!@(B? zwX3=W>5~o1>o&Arj28SQk;{Xi|6gvtz;9BXv{~M$>p$zt=X|=_FWf4?!C|Gt+$Ws2 zLfj$EPL`PTXTcU8U*!z=!Va7B+5-YBlSB6f>DT=ud*X-2{xM4tucSQcVCoWqer)0< zi{Mw7n0w`dCu}fhVSWvBrK+5}p2?zY<&Gl)RI}#a*vb5O!|(IfqVN=TOOLyi!xViI z=t$h|>!|zRZbI-_=iNA)N1bB1V`0dAJ~a?~!|@5v;4U|_sWGE9+}@B8$zV4w>KeMp zS+<+wP{cIVL5LOU`ZI?8%t^yH(Db=*GKX{KTK^ z)w`uBXXv=4T5~tXDo$c>I>TR$%RdcFU*p~|)-UY*J#_@UA-8305*$Mc!?&4p`WiSFPo>Zg)v47s#y%#b7g^Q+MxSCp6QmbaX^%>dPK8Pj@J zQ)-IJ)%+)LTQ=rtUw^;j%0PPMVw_wb@Rgs;N}B!Bdq&+)gpgIay)qBDR@~FQXEV+@ zaEEansbrLWw?8NSa%Tv9iKG!mppXe+LqzGVA011;BYtP07yLiySWLHPU(i>L3gT+7 zVb$S_4q6>gb`o(PXKCy9ENFnE@$iYLSx@ie@pmQ;nIE){)P2E8MRA8aV2w)CGEHml z#9;)^OxUkWeTArCu`D!mo5lVMt)I2;lI?xPRLBZbU-iLVJJk)*?r4pgMbkw!vPSfi z);Gwwh+P`gXy@H*>iVW{d(xxBvGhp%<>QEZ&8AG1V~;x}aRDB4u8F9x!V~#+``Y(Q zc_nErZXP{)L8~)SezZX7NuswE`-h;_TjiC6(*>_LFXPPxnqM|;Z?VE?cbue9v~#4C zNDMxB#a`wxRj&_L5o#dRyq#|y?r2Pd9NYc6>uWQ9LTPX?%4?jEV)aG2SH75}M~)S2 za7eN)mivuLHs%r2{*?b>?cqg-DUzZaC&pukDDGb>ZbStUxYocjmGQ)3=PjIStNozE z_b0->?(Lg{o%B+_)&7A{f!nL);DgYx5y5cWZqFn+zKyYHV; zPWShStrRQwxS8xtpn+8 z{y;7eynb3}wooeGStYTV758Li?7n!#9*P8MFk#dmL~4 zW@0N%gb)M|ICX9d0uX1iv+L35&cTBsNhnqRSH^dm>)jB$m>cD0gY3-+R+LcnWBJE6 zOp`}}$X+@O7+!qw93~!;#bRf}|p6GYA$_rtBA?0y<2Q-aJKna*H5C+hVqk-H zf1x79!`*1wjkr7`al8bMStjVg=jtmkH5ETz@0!=24w;11Rv1fLhSSMvU}9=?v^5x! z?opHzT>M;(X@hXaT43^9?*UHnrHOFo{sjx2qz+iR5L2kne#MYrXFmv?KZSmzAA~BwKHVfM53f?q5SYjNb?#m< zOaLZaw15@yMq#|5>hdjVrSiJJH_WP>5I&dg%RVzUHeLxiJ=v^CWwHs;cW)*8^L3&- zZprl&>E~q*)8u{mqU1E3Ef~caRAd=?yu9~sF~0vY-P7M!aFTPLs;h+9Qz^Aez9+b% zw^HN~Xw2nGqit4#(kDr`hxZkSNop^(ZX>4;K&K51c1ZDj*+rq*twux`8y1g5z*4t( z(`ueKjeO_Z7^KIpb!yb7u-g7tL37ftGAHVh_5owE#fVezmfU9tm=PC1`HV z$8>fUc)nSClfy!FbX!**ACp@bo}c{seJ_QL6z+D~^Z6xHmxc)wovEC97{AnP@WkuL zTgf&>Ved8B^wDGF=-WIZSwO$c8giKXClOI_jJt68QDZdpw>49I^Im=9gbq$B2Xslh z&x11Pw!`9D4XP-o32S1~)3h!Zi(@N9ls!8ps?KX{cujE2=_b!haS?)FeTtlDu7*9R zjn?tF381BEhh~PMF!2$SP@Y=9Z!Vgj!zxHBI4lu2MQQr7aDgr5FvB=o2hv3fKMcJs zJk0!@UDQ!KqVdYNt11v6zOEV;LkcHrc@^*MU!>Mf+tD2V5)S3oQzTb2dSU}tv$8Ij zhowoleim0a@CYLz8C}LH1$}*eX(ARD7Rb4v&9b4(JsKxLKZM>OinIlM?c*4A>=?1R z%ZDq`e`Qz#MxDHM>bIP)%=r3#kGqXv{=h5QY(MX&k&*N>THG;9fY_kKUJyOFxe2(Y z9r8yd83hw~B{#vqSnj~u_t#8+Ku;@4cjs+&ztI8B)N@1eNO|1}ibJ5aFf7I5;(sM9 zx6evxlm#EN+F889Kw6~Y^uF}|gxHCzEU^Zi^==Exkt7&`inWoN_&_^l4C7^&dIoxo z(wjI@R;l~{h9A5-PyPByQ!OJ(sH3QZNa|Las+pn@X2mkv_v_C*9tHMaL#?AO3PP^s z4nXX*7QFJf;AGb{Z2v2d&_6(Jbb2e#f!-%ci~^rl-0+4CUdDwi22!~BLO{(mKWpJ1~NrRN}UD7x@kRdm^c!bPSj&72CqRJ-*sjr%+|4Wmax z{tHWJ7YrE3=`7+ zJ}KsK!F;kF_q8G))f`KSPI=Cap37txr+1=)T>W_GsrG?Jl6C=)dh>(*e-8Ite|7}X zAwl)CR+mm`{ecB&PJ-9@*TBUS0vX>8rycj*CLoRnTq>u+t2SGI9uSyI8V1XKkV_?rvZ zV%R>RMG|G!t+i3Dx^m8}KHD<73M5PA{69749Vlnu62tMjUf7dYg}Q!;>%zwE)wqNlxHH@F%yWzWLudRwO@cyRcl49}`$0gqRWRR@ z|LAl2!2rkjHgt;@Jx$XYR2!0pdsxxv3`Qj6>>kW>4}4&OE21){BgZ>a=sB3|5mW|O z2ap0x9F6KKZyCQux+?IfT4%Nn9FM!nJ(0}tyMNjhjXse;G1zIv-m%kKk=}Kv6#C?* zs&xOWsZXX0e3;09BF*aOW6u^EPerw5N_yp3k)W;<# zsC|||(3`D1$-3-x=yHs6(nYY>V}tPK0jda$A2@gz2|bzZlnnj|8?olo^VGe%{-|nU z`Qn8Ol|MOyxBf^}kk>R7Kab{VHVzluf(p+149jOxy0nDq)imPR*FznCKLs*wCD6jk zDA&m0>r@v4S2@gDLh7s0XxXoo5j0G)7o}(~;L%w3y~LbTHCDFpnycz-)4;vQ(67Ne zZC97~hZR#JBdJ#jrf5j|z89HN@dphQ+aB^0hs1~cjhd#wL0M&?AVTO?4N&xf$Yu`^c-lBv6xq@PlAV<~A>SDPnp-Tz5i`101CvWRD1orb`#FxP#AaiM07E z-2T3PQ9(O=em2s0pJ=Ix;(jWx+*l$i1|;?Lt;Rt$814FtTIZ?jn{;>mpqpjryxav9 zNLK(jzwNtPmwua5jgf1j@)IEDy3Fa*rVw!JbDZX1i%H**3_k{i_KL^liULyR9`~g{ zE~FPDM~PnC=Gd{fEOu(3bT_ zM*wl$$Qv6@s0Ubeg$%!r;(E%;_=tts#(ZZ1qDV(D8rmO5A;6aQixPhC@=hi-YNdAo zE%i1>FE(4q`VZOX;nF*YF(2^MGyQoRQ9mb-M0#1gBc+2jpD*S;m}$ptt@5dFtJr zp{y3`6>Sc@kfU&kypxr^w+ckBxy3Yvd0XUFH*aWe%Y@5F3HT!o>Y*q1!_cL-=z1#0 zdDjic2)z!A)A`D4_}?4_Jq6+#bzrM%hBdjXLwn7i-W{NRX%mpw@9P*w$1zS4MfvN# zv^}Yc77S;TCnX-9<$UKx566Bo&1HJVAFJ=k`Z}id_t{i8|NKLXkx@*qog_+~D)(LN zf0G!?f{3Dzu~41wl0Y8V?44DpLFca=6-#lkaid%2UcTFUwKD#|cd8;M!N()OcxXMu zG6<^$=WJxz&Oh#7VuCeqlm~*rlreTq&ae>XKQP93ING48X%9tKiLg~hf=1^DZOE^I zLsy5%uquZUwvm)_pv_@RR9@^$U@fJ$u-8J?LyOqo-$lEyenHCAzgW>`W2n107(c0j z!HWlubGuPKS+dT`cT`;z zR(|*HU0K|IY1NQ7XG3NVSMU!~BaW<#Zy~wEXlH)18iAU`c7N)GNpUpU#@?R%J)gE= z2NMi7gDJUfzO)gZSf`3oJaukqoEncz{63ezQ@Sf0bQR*8nBmvvZ<-DZP@3$vTH9gW zb~0nT-&w%p*yIAX4ix>Grbav1?{^98%+-<*0xxv+_FmnKZ>bMl1!u<`q}%;tzrUq1k;Ld!#4+viL`~M2`Kj`4-Qkj*{)KnqHjNd!i!RA~e%wn0nJ3z`vpvvedh<#;-oOt{bDG?M-~(CSTd}wIfs#;W4&001j25 zj4o>MH_=1e{?_b~NH{;ti3Sqkjz6`Y(s3OvMMiJ1HP^xc;o=34OL-~!A#ecvfje)! zr0nHkoqyz(04nR-C|@J{cxvpmA>zH68?igd*@}RqcSobjzCjE*{nUEg*vHZK&Enp* z=22~=J#5A|Q=7|VUE=S>^^fO5&IPe{q({s8`{`Whk2Y#=LNl>%yA~(poaq(G?lU0j z{WqGgFWJQUalHId+IY*|Z88zKJx928&T7;3aAVRNNYlTrOiN-R;?9;up~H;2(rtlj zdq7Y7H$-6e7n6-ZPUuN-W2AQN1oNPDF5RC`Av~Qau`y~V!O)u2fpqi1-gw=71(@9w z3*Tw@$j-D5C8*nK^SSCHxJ>#g6KgbQy%T6$TTDgdN$8wO8ZWw`?yi)gv2=N*L=J9H zVT>`0P5b+2`P$5T$TG!BjOgcQ!l7?F?|_j53GikRs`!%qx1vbBQZK{z)3*T}4$3g3 z9$&3FT%j7fo_CuDm3;g@IZqXGLOT5_dRKndjfZ)jOX58gRHPO)jZTy4gIOZYJwoyu zlVnOSOuUZEEj@G%d$=^82(oUd0g+W8Hq7=%Npa>^-;J#x@6jSRwukIJ`A@mJ5-Wry z*{1%MiJvL>PzG1Y&x!h_N_(^P-N6he`{%cjiHRDzMOYaIPavG(yXvb78BFq=>_+Mz zXnP&!cfQ${O?Dk~v^sVBCOHEViQk;~8dC*Zny3=4-4QpTrX&a0b4 z%)aX;G2PVB(NQ-qL$X?(gvFil(%cpB#MqI~1puRxhHln1V#{t9o8v^0K3;tOKn5Ct zl!KL%VzYZZk~b?_7pznZENZ4mmrRWU|Jpu)>g;`v^^#|G`k|XG{-Qd@=3lNb6X)6f zTw#lHrw%5DgUFnM%i14hdIE4h9D;UPZ(>_V7@QomPahco;Sn0w^}f_=yuF{Dr%YQC zE%+>Ll$9GZG3RbweSqa`OCc~aYlCP~gW_*b#th{}KJvgbLcqS2CmWuq zvjNQk3icu9O`MIm=x@iqwAVZ?hw%P}i$byYxbfFEr3G3X<#KDuQYE6GEfRD)LnE*( zRbw*H$8CTZ=bN%Bt}6lX8Zn43_#RvJp_aR!v_qkdyE=Ugcfz0QO3bv!GD5}T`a2|0 z7t`Ov9-arH`Bw~6KY(Rc%cIBpe16?AdFJIsVCvIVBp;-Gu?P-sJl)Ts_+lE?(?%Qd z4gFS|-s}0PFP=xkVNhk|x0XJGAOph*_}h&Z5N(ZKdRkE zhrbH7nuKLb))(Jpy&3imrF|S7Iqkc(uul;3!32#Z2FO9hrmVDLZSo9!X%Z(pB`Yg? zPC5O&m}E=k+?wCB@HKQXtG`OOUF3b^FuqfD=V(HbdNbG5rYpMT7)5k(TgDVoArGr` zf6-(4fb$r&P}K?L@hIlBSLI($o9) z%VjiOtbH+I9%aQsUK+B&&ALZ3L3SFF!%Ijhmz&mr+HW_`reAG!9kqpoP!n(>`dTJI z1e*BrCk4k$Un5)z7JtSsuo$NOOv6a)%jdiX9UQURiL>^1L{6Vg9$Vv`H`2UiJR2Y5 z&7F4H_-0c|>5-$I1yW@fdz~avpjzarmiYFmZaIT4LXp}7Oc3#aSJ?2~utqbsDqqv^qgo=*f=4 z+a#9{+mm!|gS-!#J5DFUSD!t%#i?+yhF0TC^vk?@juUxzDb8cFy;CzMm|)@-!@$&g+n!u%VJJ=Qt0xo6gqJAp0mk@%fAH1a4xFO!aBJ1X&BIB< zU>qcmr!&lJPttqrB3s|qS>-4NcZ1d&N{>;QmF9=iIP-!Bz;?pIGlOJHYo zAnVL_`|cfM^lbDgoSIi1K}wMfD*@F*i_)cE_tPeVoCUU*111{uhxrAZN9}tt3e_I( zr9)EJb?sdX;tGgh6|E`h(O)$SSZQ$1m9=w-RtuY=y_`N3}H6v|rBl*c^M4j`NS^{UJHLL24O#w$JJYuR<)^W%NF* z7|W>l^pB9=48V=fqPRk*tyBue5^Idb&DFV7q^LB;-)?M1+~@CJHhMAIp^%2f-OmK5>~1eO)v7Kn1CD=1B-hF z$Wrr~J}XsTb4SC)l9pJ;L$KZErux=!Y|Id&*wzCB8#7oa-)+Erm{_a0+frA?qm~%h zoe#Ri>&*~$>_(tRE-+Y|8PgX<3vLbHGi0>LB2v++K$HmI`vAIfwCl^M$}0vc1;TUd zNRulb50nL3cWj;@{cdt{?wCpTBfX?(e|xBH%4JrdU|qDTTK`SKvlN z?5Mt+%!lGR>a|mahvKK=Gh?Utc`9>2$x< zzJ4L24QLR5cL#g0eD&~a4`q`^w4@JsSo&FL;%W=~F%q&oG|jQayq%FtRdF_@K60#6 zW24*Y5BOX@l+6@IBYK&84Bk%z3%+uCNRF@-+jx*`FRXa>&%PeWHp|~j%0B~)B32Bb zJyyT=pJaw=D?0y}2N=aYV0-kpQpg_1fIK8@0YOEO5?=pR^>lPZF(s!6S+O$8vdQ`u zY3C@+TWwkal|?&U?3dN%4ce~SZtkj5Yv-Kzw|vCptXn)7E&ei*4!+gh$lSM<_3~#RNN-)p0m^)pwS_C7e z(0vA7(U+Q8oGfpSp!8GjAzW=OCQrn4<*;Vl43nQ#xY1NG&B!~xbHCI6z`J5YOre)gCe_*bO1}&6tCZY6kFKuOEZqwWu zps~7JkGA?rEUJyt1!3Jg$9?3|r_gEOrt(FbaYU#NB$iP<<$u1vPru4r&w>KCP~A(% zt2wCv5T1dfk=9AkVG~nRvSpCjp#nkZ>=YURPW^wPxP+Ljd=pNOhr|3cx~PNLfq@i& zN0l7BK7(Kd^}!{X$rMKD!P+R0isBVcdaO3YLQnstIn~_b)lT~@1nIiY`PBP7QC;x6mdO+k8<^Sw}TC?&piHa2%6e)B$i!gX2x77 z2HAOT(spFwv`mbr)y)KJZ3V3L34oh`i2fl}a6$Qs>rq@vwA7;&mTtw}?TMK+|=~+ql(tE z2FBOp_pr869CyXz4hoR&-mPMXYhfgL;vAp`MpMi>$$}6zh(@8v{qBB0NKM7-pfg<`BO; zA0gq4$qZxL>QeQpqumUP*(^;DU-tS#3jAndz{BxzXoLjBe3(eya6ntVgTWkRm1I zcox&b%Le)Jc4-yH;m~yzdw=nnU*{^&5Uz*lJ~=tpJWEWv(cG>s!n1wJ{PX!jlaqh+ za*d3P>b0zLyAul-n~MfJg6b5%>6XN5#NDXnR2+@MNsG#_Zyti0<&*B%A!WSMRxu9y z9UhrQm{kips6rLK&IV|@Rxt<5wxD8=M2!qrg%wl+Ma%E4U~RqxR}tMiJQ;Bm4u!>O zgf$=jnDst*|Jv+%%PMB4Cnbv1Pp_V{e>S%Tf6wu@Fwdr`Memg7RC=_f`Kr^tebKPA z7cD9fKB%PFVmf+H3o$y82=0?_<=s*xhU>})#6cwO)dnK0!Iq;67J5l9@}ggcW30n8 z)1o48al!)=NF3qgDHauk)Dt=)Md?5I5XmQ8zI6KoIv@}p8m71swle>@M5l@M+R;e{ zB+Rs%FPam1bIQIL@Jj6DVpjKmGc2Kw2lR&!w#ug`1dl!$sng->?_ptd#BlwC`n6V7 zE5Nuv1Mez0?QlCIMo<-8GYDkuL0C__?Zy&*%Z_nn3IEpvN4@A)^F1L4=c7S5!~# zvR@`qJj7vwqE~Z#a-273Bf6oFkskCd4|ley_?PBvy5lAg(iEgc&s0^SR0BWbDQTU` zy90*o!U=4{*h#C+c`}7$8oFOA1*pAYO#ym*J89Z5`P1yV-Jbxs!p25-EPZ^1 zPE;Lg9RtWfw-x)ZRjk zs@~*658+K6=9Tim;GKHC<%UKZAE0epOSBN0>#(}~dNgs#W;29vO{~QP!J+>|DwBQ@<*!(*eC%?Ki{)j9`oOb)18M4D(f3U)|6ah<-9@fOd zu)W@Ym3`)FI@d_wTUsOix)|8{hmbm+m`bd@Fr3$fvTg+Y`klV}#~pMq7>0W27^BGJ z5o)+u?uQKt*Uuu&TGWF-9NDdIZg#hZEm&<9&_cr+?G#~xhvc;`=jCK#N$O5;rBQ*98{cyPA zed)5s`GeK4kmuPUHLIO(vLre9oH^@@8&}GT_X*Mmr(um?)Vr-h%fQwCJ)8J_J~r)g z?>M8XUtd?r{o(_A;T}+Ki=h{%O|e}US{9B8i-*m6q!W!wYzpH%=w4tp+y`ap-yefF zC+JFhqPJ@2|APsNn_|&cl3c<#xe!K}&e8&(LK2R$4+Y-ClIXJcwwWBjI{SZ(K9>r0 zTt96jXmWaCsP(L^vj@^dRc}4rQIa9f`TWn;v6>yMdq%=hWVy=#9ZAO@3zZ^Pz3Sdu z?mzd=A+G-@_8F4tw%VAQW5<3sGMoTe3&;Mei2h%JnF^$kZt-uDs4PpizvP2Z42*ON z#OTKVw7M-F``6+``m~xl95-XpBK`dP!PXC6z3Mi4Apf(VTDeopO0}fablfE_kIiUu zlKrKV1j_ZYmBWAU4#k)TDz_|{mSyE-2Bm_r?ZEWW`|J5X?oF$YzxxEk zY`SPZ=z?VyiH3r|3{oDT>!t0;(MIIT=Bb?wg(OM&(}N}G^2b*zy;Qha6?bW8rei#} zPZpbNDTDLWboG}5GNGkV!5h<_{vvIkKd^owm5+LnXfC`L)-)ab06(|RGxxAlJYGkZ zLOWip_-B84;UW*M|7G~s3I^J}Fwz^dN}o5oxhH1_T~YEK)uE;Pbc`CQ^;+`3TItFq zTQnWt_%KIM1+GlXZIU#Chg~9bM(gPkbOwl>Z=`b7kd*Zo^~*LM{fA+2EB6)xv})b8 zX_#Q43 z&zkbO9&nZ=vhV<1Mdg{`CacB3?sGRoBh-H3A;n@nBE%8#W%Pn_G{d{`)>bKg1gb>V z{gRT1BR6_gSy_@@UcSD%Lx&%v+xM%q|@O&6Xw92|5w#+k?e%PbB+9cTbi5nE0 z>R8f5jJl5EX7RFSTrH`t1itwLVFg&VrqWLTC>WOPTx#Dk5Dl%(sGfADC&W;F3qtv?v8f%1UBvXPY73uRz%~h^@Gva+RP}hcDyOGeZ~AL62j<4XRWR1R zw-fM#=vE8jLC}b40F%De{@b{eVYIKv;z$-degcUqWK%`orw6bzik^|d zIlh>nSvbGOivX1F{dFzbwTK3oqM7Z&_2%`HJitc32ez|lXeZ@ng(Bi;j6yG_J)<9N zQ2J^Ej`&>~^J~rZqTJl^*VZsAD-rEjhlz<1%9@-+R|)uBniaCw}y=k`o^WZ z3&wOu*JjRcpvp2qsi`)c0@c@x zteZO_10Twb?e3YqtFF4rAGV=0swH~Nj#U$e5-WUb!1383q38s~(?4{0^ApqhN^9BM%#NRE50*`> ztTyHzl4^YL`%U!TE4FOCTaV#vqsJY{>{NBmMfbRA$A+zzUsqs*Hm|ghmj6gh4#yiB z00SLVdnnw}h*;vKpC0g~NiFjU^|vmUhc_xIC$z3{j1I#$%KiAC^lYDUVu@NKi+RJC zp8VS8rSf01dHckbHYSDhl1qh+iJxybbBDMmCRPNso5c}3JRmEUNv;3rgnRh3g3#3L zO&x}T%jD&~T_#|!H*i#w|C{l^_Tn>YwcO$QcLngrHRmGyRd=ahR;rR8A+WqMQ+;Ra z4?|9vIdVhOT~CS0mCg91#8yeHRaNt@ewigX6*CVCv)4@O$?x`9F6U+_wA%mXytw@Q zD&&!cyU45+8@uqJ4R7li2?;FPF9Za68L(vZbK&FXi6*mg!IO{o=W0BwK`X(nL9lPt2HB7{mv67Lb4Xx7-A<@5^L`%@Bs?XRO$m^;&l$PS0?JI`F*2bTBzx zF2rvOVQN!al)CQ`GGrB#UxD&vepp5-Zau-W;mxJU@~7KG*n{_oZw-roh)W5nfM60d zq%_QNWgc(6)42LHye?`>+Q>R|m?W(oKYBFp^tozo^q4lj^;C3sHuI`{)NYJo^AnHY z*t+h81{5M2#m^if>gko_K$ zqwP=nrLOU)e%Gi0Kg^q@v3&&aIHewZ=4(N0q+ne~hLx%3SEvsQH5XE&tS#5d{g86d zx)8z$9_&B&Ae!~* zS#SXjnPbsbz9CctykXH|9%o|xR00ofS1jdCNkRJ$4-;OCBHkdkBKVlm459d4@K8TUDn8<>u~`R0uO?ES~BH zj7oyY>>R}#>J+@)A|XE3_AuBq4+IXfq(mkzw4Izm)!))#Vlql4fw+c<^? z>^$pIjei_I#zt+h$o`GQ_22(muLUmF+1=Ze40niVSM)PkR5vBDswb#zx?wuT~gTTBA5I-!m zLOhyrNm%zr9bUa7kBd+EV>r0RM}EUUWA)(hEi2T+hp`WP4X4&rjr3=UyqEYTMsC|> zuK9Qfd!+`k0@S*MPa6_6WCXg(oc`^tz-H%OX|EC9V9$(OY;gyWxbFLVO4p9)Dew`f=>w=H<)bU%!d`EBey@_2}q+hE0*w!Wy7S zUyo*WiUUj83YK0e;_K=!YI>M9}YMTW>?pH>TcaHFm?2VDr zBZ9+xH`$y*%*9Nl0$i9G(Wg&I&G*)d$Zbw%Sh~e#n%+XGzXwi}<^*IwlgqP#AjNU} zV7bmI_+)|!#r)UQYY{+n`2)Gi0m8eBYRHV{+CQxL%awPyB>}BOqGnWstruX?`RNo-e}pWu z;XGCJjnklKr^nv-`qjR3Dn@GFH?h=WmBX}0?OY2!7l#cj*yL2SG(RkyYmkmF2zhIf zv}`Lve&?Rp#{Vo&F@{EmHl|eJ;7M5m<4~6H^T*=4_o8egsNY$Cm`v=kDHWNe?xR^M z?U4Ko^rU>>s}dwXn`Koij(iqvf6Q!i&=+q-ul?&TIXle|S9sY? zkl&rP^C2k)d*d{U_*BiJ$&Cb1CI1Jp^oSiHxH znvM8e24*iw5up^t6#teS^NS6SK{HH0`al_iSj6HV7lN?mBAZ5RVJj1x_TQ!lC-Hc$ zwZM^kw=!45d;%N9R3ToZI%7r)?p3FRUw}FU2#xik_FX-I`IPT`Kp^W&M!9A?I6(wC zc9^e~`agkQZtF+5rT>g$B_NQj+NW;-eR$FL(?s2{{l^z9skoVn%ePW}L(NnYc*V zxhqH#73dKj12Cg^7de3WfP1P*DJgwYt;afr>DwD675*8se>)&2BYw1g^P!~eN?_cw zhuA`t4_rh@%@ID!lsDpK>;L_Y$#0fFdOy>}=CO5US|grwTVcF$cd@%s%j))Z%CE4& zZ_g9w9y+jYI{17-aVtOY_LiPC$a7U9{NU7iQ)VKQh1K7*v--pf7>-7>HuZ{pQ&05L zyxx7+WJG#h{MLffnF0mGpBg&;I$pueW2HxHx*qB0J>^J*k5Hfb zR^2G`Oi8MK-b~L8=kISJcH#Q?++esW(NvJz0b$(E=(v@b7bpAT+=;sCGd6#2AUmF{2wetf5@2Wj zj|>2~Xkz+n-=(#Yuk(Co)uZL*L+(|3m9N__!HQ$hZQSBzlDd+qsl0ri_7T(>aNS#) z7Vfbx0DYrpM)C`6D!Q(~n4*-jpxo@4PDI;}U6^ylOBqbWpfPH|G;~bMwcC1{$)+~g zku6-O6WoR@b&c`M#mcO>L)s?+j21iNA8l(D*LoZ3#9uC|alr%iE7}%a*p3!IZ2fSH z9fii2yr)C02Op0mYkU}_m2<_;CN!4wVM0CRoV7{9x(ga{Gd^%W?Kh^z(ywS80QKGW zRV?Fn7RaFbA)uSpfHOMfjmE;`u2G+K0OR0EaCG(>HmTVg`jZzugtHZvePNiKt^?8M zmdvAigSn(rYU3|DKB2C3uM8b zL4BiT)M}Pkw7hOL2~<{L!@mVaxKdXt?^NjkW&fERAgm_7r(&GFwe}K9AR;%0Z&ZBEfHME zz7DJmmIFUZFSV>6vtleRElui8_S*PES$--n z`XN8-Kuq9eQK5(0jL5j`Xs#?bbTP>7!(gK*Ff=*&J7ThZ!s1^0NegT2WqQjxUi53e z{=*s$iO(GXeO%QgbW3eSlL)7fW&sykn#?OeT5OXlkPXy<*i1;K*$Z`dMl2t|Uv-3} zhj^7&l!|J7_qzaSXi|YLuPlvND51^0QfNJ3QrL-%-6Uaq>PAnLDqUW!x5;TI+vK3a zwV91J6xhJavV_H>0RC8di>1g1;LM_I#ScvyW%L$lcfb5tee6qdtY^5FE%Jl}*z|)B zzEIGCW!dSe9Ja@i5Ax6+;i>ouV*EkUTqA1wQd7YpyKPi( z8LzdZq`@VIBmMh8T*NeVbP$=r`1-w0Mm_1UI1ag^k{$DqwC!;{#bhqZzwXNO5f%`} zlBcGo1`m4<52KK9@@&((vg;34DX-k!f5cQ;qv!oCfbDT65FP}WHvtjA!o5C!JT7XW zx=(s0vy>Oz5;P7>{GrxUc*H?wFDdo{Ki1!9%D8{s-e8=P&YV-+Kl8{%u^pN+gW zHoLT(_z*mwpUsQFyV;fq2>$z?MaTT;P8K1*xmZZpGgU19I3v!@1R|!=`Tfyvl;o%A zI`8uyUcEY6hi!&4XpNii%ekURyjG=t30h)Okpl1`Z7gkpZB$G>fQMl%Gb6)DGhu5KITAycy1hAGA+n9y9?_+I<`ODz1h2KsW) zes&XGMmG8vMZ9QwdzCWcw*U#$VV0yyAj-V$^Lkl)BU?mxntcAOOu@4|_TQUTAwd_{ zf$qHy+}89oEWPnRa9^7DCE@Ek=XIGLSray(!`WuqN&;3p+PjP>3OAy*G1PQJg<{@G zpg=X%GEkhghLImti5A@bY*Yj47|%#sMOka+82M3W@_J5~U9nU^&L#{nIw^oOqTN1; z4j=@SDyizzVfPAd-@LmCnrFCUSA}l<$SdgpFj>GlHhX6A^S-?*=rvFSf@K69S?df& zZP6(yck2Oq*WsKk0j!D2+3+K?RUd=rfG;ZqSjT{0d^!=vmmQG1kITGS8C~L>gw8>{sBTp*Y|?TeUGrFcB>msd9EGv`4b`y4bx3^ zXB$`BEDAwu2Qy*>r4uK>psaPR11Q1^LbH5{lZO9$?Tc!`Y&AJIO79JdboJQ1QDYtd zYbMpLj-<@ERSgQaCzSFEftR@=-g)(u#m6AR!G>GjulyNDZKX#DFL%%@9L_ba%H(cZ2kI4)^b$>qQ$If9zSD**>*Jks z*R#Y@=)lXVX5Lyt2B>dQPA<@EKb%x1@l(Cac^U_3^qf~TM{^kTMr~sCm;DzHsqn2> zVHz3_R+Z=$^3w3n#*jD@myrDmuDgRBpF-A>8khlj^b0z2z@=(AuaOo=O`BvQKc9=G zI7y-oQNz4kgQUeh=?gfe3(W#sjEvlUb(3YZw*BVQI@Z9rK%cbPYnP<#ipk|))1 z?9=8+BRWq?%1Is+Iq*N(`rBk~fR3soekXVPZHqmssKoTG9&_!?if3NT(&wYk>jg0q zNu=Bn%a=pIFXgvynHCf5!bG+kDR9)=wlbU98iM?$Ph((dx9Oe-51z6gP$;xaJiHa@ zV+%UY3i+vG!FAAc+Kw-fy9^HPBQ$zHC*wwi%3*2Q*p=3Pu<;u?8v6;SU#HyjbFdY79oV&KX*rJXTXaqgq%12_10~Hrvy>a~ znH$ya-j@>`2h@RU%6shnlonMSg;LEy=DkhOwBFwnjSFX(@A`C*DPK#xoMt5sH6G() zgAE3y;2$6F7!3SY>#ddKsPVMe-0%7|rB^uqhgZ+CTD+wwUa>js(dR#ueu?D9XEjo~ zzgLw2veVgn8r$uqwZ}d~!!rH_A8@fqwZJ4x6!BzM;C=XJuC<2W(0xI}dd{{W0$&aO zdOo-leXZvDh`y!o&V<*V&^yc*h}rF+P>LaBY)!aJ+Z-24?)EAwe{U)*bak?)eXchP z)Nq1yO-8urCQUW{jY4AFoD6Av#LoWJ3e3kly^^;t=Vf4fV-x=W8^borQg$cxoPl(A z9&n|dMk>x0_-j9huva|#)3P#@J+*mf)kORxE~j)Fh-YHF&Q^65g%bk?;p3)EENhM@ z>!tFtD)SeupP3SyE2~7<=RR=L^BBJv7f@#6{Lb>+wX(IUzYJYjQa2B{(R;;H`CqsE{ScQ#Bv#a#&5FDa04kW4gV(gexWPxGtQ%;-1=Ma!mC`z7+1}* zNjE9eDy5hlpnvPL@8=)hbhOaAIJcC2$}Q8FwatY8Va~0hD2z#SK%h~E0)`*Vr>Jto zmzizceDvub>`RVErJQp;!E=AXPk%-lWdhk~ib~o{5`GTVr!%7ttm>{Fqc>)|;#NGE zf}k;fPBZ|8aLKVrE>_@fiqz-zvX@{ChA2S=dO5#hzf1wObYYL!iTz#o`DVYdy&tQ@ z#M6KLeYOB|tx_H@rLgdgW%)c6%OrJvTADNz=Jri0LByqS5^VPrE9to>-Y~VkRf#|s zQ;_N_k;oRwd{H?{5Rg?;GnH&<)BFl^YRmR9H^_cU?D+h9A+K(*sOHGa;I-ee4u_`p zqn)d6PqOvD16wBzlh8%LIK9bX8Zl(Px>YaG=Mx#T=s}iRE6dKVsRKwb@!aY4N8mF+ zzp!1Yvzr_B_&_pxqH(`CsF#4?bj8Z*rR*XX>YnJrQRhuzo6ludIooEQ)a#LEKejis z{-8M7uwzff6(kV~Y{-7SwFYv7hG&^iJ7O4R#=?dibN4*j%nd^B`6E!N7HjUrkFrsP z_kVAv>{u)!9WTC_4sY8;bLsHG)P1OHnXyVJG_ie>tSsNvkH|MDkD^aAE!;k$io8NV zVR;X%Z^ptdtNlGk#pXA@tza)E}4`pXFr`feNe?k>Y!t7RrX0mh8*PFvr zbF(=>wfDL8OoQKLDOUZOAz(rlAKgO}!GXY%c=q2-JSj;MHPilavCIOE=*q8goqFbjDClQS8SXzPdSB(tkHE1o`?0!mi3Rv>S>Z&h=YE&{BU zx}AG#&-e2cLq_vG_gTx=3OnYicDp0rDv1u!-pgX-L+VTbPL%O*jz+h7=Q?(x+e{CX z?S?rZ8+Vd1GcQm`dl|7VD}MYL=j!spYi~IIYh)yoES-&?2;eh!3nyvBbS_tSgO!w=`gJj4!EKgLv$=)wqo&ZCP3GvW%GagibTQo4 zAZT2{$9sRU&gLlaLp}(yG$@Ln%&|#cg;q5ngKd(ZIX~B_ReSsCp&aXd&=wT{ zGa21pSr`}fh^sE$KA~S)Rvg8;az?&au>||cY=`ZXsFmyaD+`ZtYkc#k&gq5dQTzqx z0cc7K=oX2)c0D)c_L<=`q*{Sor$CiI0jnjQKwY>`XsvK4szP6W7Y~adhFIFdgv*fHJ??q z^H`D$$Upf^WeP-FQo=$JLH|K(nSdk?itsw`(Qs+aL!2fR5CZQOf`{IoAZTZ_Fvixr_>l{w>4;WKZW;fmDKFiMeQ|m;4?X;}e$r_JF ziFtH!Nr@mMU;d|H@WsR|4`g%zvj6I-R)Tf?t?r)p7xX(j0>3-qtf!9=jYiHlTt!gOu*B1S>{Ba2IHb^if$`rz8*jl*TSrwIx$S?{bopD-1U5<* zsc8HH8o@FCk5i3UY`5EmKr5U=yAvkjet>%G1Dtr!4|C2uzKg5#SLgChyTxnqxdXmj zNZR_y_5_E;)5HLl9Jq_<2BF)xU*w1|57?IXq{jEJmC!o;pAw5l={F zTq@Q|yB?TSa#tn4J{Y(4r7K^xKTL`1$p0gkvkYRZJY%BL8al)jhCt3w21 zs_#e*2vZn*Y?6WI`Pa0IP)$s)4}A6C^{IN^mgRi2J^!;WzSar|3s{vTLP)I+s&)Mr z)tp4?OshGE>J{v*;hU^}hT1e6x&9>_V!F5*-d`ONzp_`^`d(R+;lz@s59|y}^!zIa zaq5QOJ|(&VdO%d?CXOYNDT*JxiMh@{ILdFSux*pf`qt=zuE6q+CI}I-@a_^i7~FRM zyz4|ZtS&^1(a8TORd4hhJ({DOe7rw4S%&;HT6K}@0IM7?)3Cg@=o}%z+qqw|p3w@B z9W~E`MC4p=V!E-k`uhx8_4`cHUCi+2p!*#*!_)wT?2`61+V&}0`V_Oo5WnA>&-VE7 zXXO-`Hh}!rK)JGrt#Gyz10w0O+zwA4Ln?#V;wX=fD~h4HIh+w$76?8i`%lP`cE{m1 zc&$xxcIemeb{`T9YUeh_Odhpg^P@iW+fYbtA9cEXaL$YtphwcMyd;E0#BMXmCpwad z>%;hc-!I+nhXhSiYETED2=BFRxgZlk-H`Q|KjCdiFU&{sOTR>I50i~Qqwaw&H=`gP zCU6X~V<20D?E8mrYs#%eI4=T%KpFDAR_tR0H49xoH8B2YXURTI%~~a?XMV`mTq!?w z8b7KAYsm}(sUO4t{xv(VmSoJzpM^>DB+{w75J3Xj5f~q?5LT)hH>U>!)ZRjuKP1i zn~d}LDPK-U&w&>D3$9ng!6dEn9MyB7G(+NGguG}6jmV<=sZ;Gq;_lJ0!}0#HN0{IO z&7swe!kB4klM>`Z;h%RLpQdOoJNfb$nKDk8!M;(~etxmA*$mNTn9>8g#_zMzvd@wH zPN9_xY^_Vb0{;zT4GdHDK9beEH{r!ZQyAcpCsQ}Ox}mhFmD!$4^nym!KBkx2fB5=R znPa38cxc5XJle}P13!Rk@JLne{!Kn0PjGlZe%xH~Ymr}!jfhx&awqA?_UNAOSKXQ2 z^s1BPCx=YhOdEe;zW3XU%7`C51(#~pr_mf(1pYr}itp*;CmyQdk$)vW5K`qw3*Yse z0dl{USOTX^z|UBnJlF6kl#)PPZ&r7u_ktq#0c2H$uzKFfH+_2o09UzvgBhdZSMZZ& zuKBc%x&s@&(QjABd@mV10fCc=nfiRh=<4H@Y@CHv8)%X_ypB3_=N8abUqOvk1Is4v z3_%6hVDSqD*if+sa=OYzaUdR^XSSs(>JXS&gQjI+G^R?>M_lQE7wUql9q1+RxW>as$1oBRrlfZv#Da! zpO0&fnzIuXRNwg#dM2}2!1@-#G*$?Sy-)vrrM@HvoP-Rwc5HIQ=uYluRrMcbXc}Hy zpagJ?2DKRzwdvdFp{RuQ=TIV%TC%B-ua2e3(`QR3wr#l_6&9lF1)mSQ2mnjnBGe`- zD52q|km8`ZSN7Acja~BLrRM+=gE5o&K&G&WlyI?ev)6c>oH-PjCu1yz4RFoJ+0Ui4>}`|B>G~>v z$WUlmSjdKlOuxiK$kZqY5Z7Pt&)*bLU`7F%Sp|X@Sw_ccRap4}#@AW%i#*>XkWCOr zq`yv{!P4Nh*VP3Wnb(iX3)@_oCQI~q-IJ-?pMJ!kI#h=J^^K?MW~h%nv6D9~hg8y> z0u{p1ih`!t%Hhbc_2Bck!Q~Wdqa};X{fU*&4C-Lp@~Z_+4O56 zD*8J0S${1Lne~jTV366=rcrlwH$+wFlpzv#7iB}#I@T{-Ml`VME#{to3XSmF?REP@ zusSkD7u{=~>&wIeI-qUo7;)Z2_txX5;)8Y=&c8IHN7q70MJgrj_&-+<4x1AMriY1` zAALV=X%DvmL&QfjN8L_FpuPPH>_xORHP^q0y!kX{7SH(hL2V z%|_2=!}MWLD5W~D%8wcToufGJ4?nP?nCQtpGQXBkL!IC;DsyXUTXZrbC>V~O+de5> z4*v{#Fs&}G5GHPhGGO+b>3$K2nkxC0d{Jw0v)w#u$HHEc6O2zryhJquIDBrkD9u6f zXFWmZs@P{;>pPg7^v^1HS+eq%9b{HHW~I1ja^P5h`AP`{pf6@p)bI0*|GVoi)2m{I zE!4>fDpuC?QaU~Nb8t^sXT%oFmgK@HWqZj9Q~emgDp?cUqyNwS-5h?817~nGfIX<* z^iaYfXMQ8a8VozV`_~Dn1d>XDpsRzJf0DssILD?I&)Y~7IoY-uswr=uEMPRY+WlQ4bqSYtG{#A1_%xDYCup4P_f2{@ROtofPXX zn`CL;6o^Nf0`1JCMf!WE=7XJ($WolWheeza7C03McurjNg|yAW40c^El%j@2(q)X~ ztUEYjr|2m2bg=Da%5{-cA#&*ZQ85HXt)N0 zy_1o}C&nMwdq24D_1pC++vEHU@vm082L-2#V@i`I2nyLIEK*jT*vymM47AK2lO>__ zx}I@^Wa)8@bS&nfBiQC3wSh+b)N2+%iY=f#bvJ%i>c;YW#)v0t?{0%Bw_ie9+CRa* z|HaOzVR)Nyj5hOXZt3(pBm!WXIA6zwcnc%o9To*HA{8n&%{k8-kT$)r#z*p=zncm0 z`2K+%<;9^YnE@di07$YlMc9Xj_*|1x^B=wFAx!0IepexX{&(WqOLyq4YELKdM*2!LCki6TlA&tbf~qW=w9HN?Sf?vFX~6L)X=I6jDQoNKoo`Sv z_b$CvCO>z0t;dUzzR^&EoPdUp-CI=be~~x#YUOMVw{`6xY&a^9N**qtnMry)M@KbdfnVmN_7z{N{=_HlM}N3lH-ZAIwSVgu?A84 zIg|zZU~jv}qza819l0snqT<%)C5fbcAw5hi2eni%Du(yI18e=)T1bI$Fx4O^(05CZ zO2V~r3f{lsoHV`tR@Hc{dgfS9 zw3jUnQR)>qaUp14Ja$U*J-Tj{0UQwLRR^qkqrleYRhZbZsmtkh%Tzvo#7)rGwSBmb z50){*SQ3r5oAia*PcqCHatag>YBU`LOz9Q-EPKtol-*Jk zy8h^yIjwl%p!SLx!1SgZOKT3(2p+dzg=3=S<; ze5N29wzAas4^WA8T$djT9?eA>|9=&`s(~GX0K208xf_-_GT9Eqx!o2*(^(D&w-hyP z>j@_s)vWvo&zddL3;#q*SDypnwSEqn{WhcgnKss1pH`0TZOd0TxTZqhe z@b6Ew2h1wzRwpw&{ICIFsxz~D!YVdlH{@uC#lFBXLq`dRFGt#lpB4V+B6<~IGu=zQ zV5K3!UbQ6=$Ejcc?s-h>i~HKT1$sWa+rU6n1LsSKW9aO1L8^;nWDZ)Irh~~hH^=(Z z9ri>eRaisQuSBmi36paTW(4K(Nl~C@oV!%`Q)1xQKAFJWdS}r+BFvcnNhZTJys7Yz74@AR;JQ@w!u%Ca z-oqyFBLe`hGM9z&;dz}_He**|gN)&1nl%Ax+v)flRPct`x~{d3#Dfuc@ikflEv-#@ z&&M2H{OBYIk;v-)Pew0`t3F}m3P!0s5igvtgOAAQv#;;f%PXHN83)H07j?ny6dx=z zRV3zOv1&NCnlV6bn(vqAh{nnDXRde~H*#(g#+`A!%q{E`d$B(Bq@cfSLZjiC{${(( z$aVZxsi=1pXugFK0n}zr0w2x~9`5K2Bmo^2zsQS&a?2RPBX^z=j3alqcf4c~Pb;0y zU4B=!?W9;C*?E|W?8JkOfSpt_OfjlvQ~Y@6J`gnUSh0WZu~-EJRlG4y;n>bT6U!|b zj;eezF-^zBD z`Prr6n#Foy2m4No__^}=@kp(Zp_HASotxhn6b73IWbX)|!5c8Mb;Ge-^6^QPI3`=r zqG_7uS=9|99{PNk$N9g;`&EfI-sEK2viCn|hwk_P9cmno1>1AG4C2GH%_PA-;kge1 zqkrqkhucKrmAwZ`&Kvb@|FI7kU${g{@&_@{uv!n1jx-)L`%?B>hLU(J&PL-*4Zr4b z#lPXUO!&FYgW|;;p;A+W*aX*@;hQsm7>XIkDt_IQa=CQ^)AvI@R=l1)>@qXQ6AFJs zluXQWH1p^VN9W1w-iXnNZUx(9eZ^YX9CYeXRpw|s=TMTeR@bDuC7LR2QxKnlB90LY z>ZVCe*sYYS|0#GUb2N(PaFSiHvsJIz&$W61{uj=PGkqACcEp*e_sQO43l~2xI~ju9 z2avi%_et{tx7&(!9K7ZY$)tW(g6kIDVM<#X%kw9pk-a*^thzZ{Bp5Pox%V|TnC@)g zHwV%`U(7PYk$6J(8D@Za3<4E+IV7SEF+r#gcOYZ0CLUGuO8bu%pY39AfIX$_u~D0* zQ(O9k9&w>d8`#A1DGmZTtOR1bU9+nT^5XO2!0XSCYPa-BLrVx-D#|5Giqmug6-uoZ zTIYx+ni;DR*mF5r+T?jVmB60doBt}chg|4lOm|CWM*HOi+@r_#+AVMv%j_N(2Y}#qV zd3?2jOAGi{PqQd`BZ|8cxNOJTCfbK)CZ2~)cztzg(dG{2Y32g}`Xal7mP8=i^3HCR zQm>o#&jC0oN0ZrPBjE1}%aBajWJ%3%Lsp|zqv+-he~6S(Z$d8In74@bmsR&6SEN8S;iMO2g>@RqAs z_bsL$$ibm(0@xi8#)CNp&}}_m0#--3vhGE}ur{HUx`uxK3D45wCE~l8deMFGxS;3S zsT@-z%WfNfee;DQ!;wIPxDM!Zz(Yg6*YM&y3aL~4qI+D))EpV9nWWsqi*YzRecHF^ zdk3M@-F}L;pk;&X9GpkS2-{q;M~x8#d3q2|jcY`5>a-N0d z^!>=v6e(06*K|o_6iI;S1;7JvdEbBpO$+V=cu3``S&khm4`NbQz4n-#d=Ecd<$EoY z&R%oqE5eogJnkpI#%z~BwRT=~>j6exN8^r>^S|jcD((@d3+V|URaC*dcMa=B2p}!_ zVSo26+HXa?{H8>qO@`B9Iaf(9MC%nx;0jir61!`)n-hAXjiSw`%iLUO^BB~-x z8+0{nD<{Mac`NM4Y1Oc>^G{#D2Q(~kG^;aQlz>V<(aV z`}GW)NGD{S*>dq5AT55CQ8cV{)05-u9cnJM2QsQuHjxOH+7F_{RZ{luM`?pF{s-0r z)DfDXnQvZzZBdnjNjoK6q64D1Plns=05SFf zjWjx(a*DxCQ8n8rtJcRE3HJd_ChxuLa++-y-$*N<-aoy>uKzRds0tOvxE3!6uqAjmyn6VpnnB$^B26PNLFb#Q$u@uuWN8DEJU3kS1c{xkUy~W8)L{7IF zcGik|+JXDSW8fJZH1K73aBz-Rgm9-<_+EnugeXt&?Wan443#_PAUiT%H)qe%0HzR_ ztF(ive5~~sM74wh2Va4R+}YqKsLGeXYI7xCvng0UhO(~_AN-lDr)wkRSvl~|S40?% z++wJ~2_h4KU=vl`m}tua^$YxUdffw>Bq~3!aIqeDv@@UNn`rDa-XO0ph?nVq(%2lU zXH+&l-BLOZ);CdQUnDkbC0legXQgCGW+(j$u_;en8yyodN$I8rcy9o2MaMiLTUGT6 zn#bqWrNW<~%k1AP7yr(BF%|cM+|p0&J&X5AIBC*RKtE_;22+1)H*($FB4H`kT$A~@ z9x6`d^`o1BU~iw~&>o%x3=^>Zpy2(vrAnnoL<2F(O7$NlM;dheLKaYd@24v8?-(w( zz%++HIawLKA;!V|su9IyjWA;u@=gaZ_4B(pSYTzvJP!CWcP0vt(8^cftZRT(1oO=KLFs%a zPfrx!V94cFtUNiI+Vo`cI^Ru7dqZ^-R8E>r|i?OtP< zl{#q_BBK;nEUp8#2~$755!)xk#Hd;Zc5%G_9K`kvLaOpvX_O^Y2R$0PZf%BN;_!hRzxgdnv!N# zs$_^WIw#kP>jDj^<>{-Ujl+i{-jvCjg@tvK7kUY%)E@VCT)p1(b)^n_YU*r|)^j`y z#xw`vMru5|%dVndy->pRxOe{IbWyy!#j;|VdC?AR>5XKpJ>igQ&_a9-3zXB>fC|9Wy8&n252GlgmihN;tP!|!#p~OI)Nu5u? zl<)VIXYfZa``u)#$qK?+(}6FwhxAOyo^NH$w%_QNEY6wpYD@F&+wYrCjM{{F{-rA* zvMQ2ahfO$r=rnb%-tt-#TkXhc8`|Kxnf>dZ)2k9vV2eG?C@UR-AD35e+88D$!xYcg zy#uI)74o7W2?^~`^j-^OO_U_5^&b^wJf@Ok8@3q#5-RhGf#P!Fm3!;g3%Nr%C*-v1 z+DCyNZW{UPEArT+Qz~f=hNRdA;Ku9k0wL(ptWaTjCcqO)(tzK%fIM41aeD1~#b|c9 z0Z4TK)(#ag3xc8OKL;UWfn$D5VmQ|EZ06g2l#X1OM3T4b+g8Y6Wm29kI4?zAqhwPT zmRd+oO?F{@)}sZT)ef@CS1~}dD1nVro%OsEBp1UB&(_BzKhSLt7UcKsgyVMTbGgj7 zHm!zNTgR!EY#h>*8r-oMO|)i8{Adokh8x30E$5_~Nt}m7bnR8UT_9P?E#Sm!rUDtA zH*-!<$b%DgX5il*Hq~F9(WlDW{9vH>hhTTlko>4kauS>NBIqlv+>OJV`H6?D#GOLd zut)#8Jq&$=JdEKO|5N@oE5aC;i?H5;Ktur!*iZYmN9Qw?Ow}CNZp|ja#45;7)@6<~ zM^)5)|1ow#Cs_z}yYfIuIS?H&I2R9aqE^ex4-=Sm1J)$y`Ro#wmdx2}4peo~qlJPI zs%D{>z8V;@?yyE(Z3N2&gn@z{w_`9m*|yPY#gEMD#LR*{@(7=iMj)G!aD8C=eHks5 zI4r>;?1Dre?{$a;=+!eq|M=>86`@C~(DXMtWJ9WDq2vaV@LtZQINhXGpe(gQzj$#g za{0uFrj15F{speTbS-)(l>*Swfl)#|JwIZMLKe8zU;p3VYFGdyA}ES9Wb)>kaH=5( zR+DKWXG}a*g4Tt(sK8k+aR-Ub&nRcg8jX^HztUW`-ND_V0jaL zj;CBNi@nrOib^cdbHKo*14z-fiFIXi)=u3y#yS1YjZ2{L(!EJ)9qo~)rDB}Ap2saQ z^I@N+W5$P28?whS@O?I|`7Cet zll%cxj(m^Vkn^o%5g@=i((8k|>_toO6ah7=#Y$DU)|chlM6V3vg+~1i@`$5$`JMSW zJd?Jr#f_&X^fj2y`1k9cshjp*jGb<)tr1f$1G~(5?5&##%p~ko*q2q~}58 z46h$evq-7sm<7`clH~>yx_E$;k*4#`uD)0ecV9t%mKM4frHbfLXf88cu^rDlUZCO? z5XvSGgi-yVmSaC%SOC=1%G{xo>KDuECLC!^N5B!it)uG}-y3@(B=+onYpqWJNB-F= zY=MSvb%B^K)MLieWLkXy3XAucOOsaIwJaX*p8e`2wi{GAEN;)czPtI)l=iLreOr{TX-Z9v~&+h zD8A%nen>F&D)4+)?Y`3_1f0)@8r77)SizU>yR0p=Y!pb#E;=qoKAgVr1a#2^HBghCZ z3IY*y5Ym95;qmG1G(p=**Uk1h2Af_kU#K48I8A^xLFkzV2kVF{f1XCqyXb*>IBAYo z!_rp+)(0>$@ejNj-(2j1+)tY{!QL7Kk}}WTe4x?$>ktTWH^@QA4i*c7o-A}x%y5Q% zqOOkUs!6>?Jz5q5d&5n-|9+=~&p3BZsPM@bMz5b90#lRY4!-5nixS#g3J8F}@j0+L zdi&ZWLr8;le`odGtmKEXCF{%lNk#vm1j=D}tjat)<5>L~^-w$`e3KcQWqaUp!`I6c z3+yOPTs(_WY-8plyzTeydG-KWKxH}K2D!IUoM@WRYg5C1QwhZO4(R_jx^6%TJ|sMf z(DA)13)*dvTY`(%_2#AeaQda68NQdOYbcotAg-H+^F*}d$1`jLQJ}>I%|Q5PGcg@reZB$*H?zG$ zqEj#D{Wt~0`0+tguxt73kHfU4>beKh37JFOU`bku&!AEK$9{Ou+^I`T`FUO_os1sS zH-~SGg)`|BZ|S?%`~juSoB$XSj?{$xy3y-@Nr;4`VhRj%bMT+~MQ+;tV7L8|Q%4h$ ziDZ%tFglcbXJJ1<%?brKBWS+8t#dxBWDS8Xl_`t+U;PrUiT|R2x5U#-VX(@fZ&_%{ z2{l#A1tcLF79rBp@gL}^g_faeoFc;6%B#K?Ihqe*Io&tMGv<9~L^%L$uKrB!=@jL~ zxZ~SNK1iG6X$`DQei|1Y>tZFHGYwjYGhS&5SVX*U6?{KE9wDxDQ|fY+4a$9I{{Aod z7i7=B8?_#q8CckSyrM<{yTA|fe+*9MGlBEmAJdH3<`0_?N9J&fL_r(%d?X^WCCd2h z(boAL&<19fchP20DWOZNdd;~wPs3isgXQf0xdK9=Id=B@-r?T>ud0U}wWX7YC&2>t zEoMGfb0Fj?n{mLLu4R9tvg?7 z{n|webgImiR$|lIc)hwL(>7V1-}>!xmNY(DJ>VO9xB*SpV5>l`Yu8Q6)RMwlI-b3J zLTG&+0_;!0f4DQ1%2nGZs?%N;5pzdSQ1SuC$ccdy0GeU4h1V&uK`62u2FS9$VB=uHg7$}A?$f6Qqse+7?0B#aJy0TiUrhxmt7<%Tk50CaQ3-};X}>CS`=E3 z4aKfb1wm0WT9BJcux4KG`6d8rWtLBwmG69M12Cd+Cp}Z8CCF!4#a>_|jphmroQTh! z9}?!wsB)le^jSc(n87^*J<~^>1l@4i_|X+N3xgt9fbT!VvXE1oBS>GOVIm-6s3v=% zYX?(+v8&FXr&RX20c=Mx3O4UOsH)t5(gmHBiK>u?-1*vkKabP66?G0F3^Lg>DGzb&D?rc(7 zG;jbH`ZdtGa{T}amCwH;$_28XV^JC55msyEHFVV{L~+0Y9( zDr%KgNG)|~gIGB&w|Yq@z#8VU#mXsq^uD1iMPJ``8X)uoQnqexc!WRF`Jw@M=Qf4EEou(>dS_m+PKqehJtZhN&2FX) zQ?9Kkf)(yN?gzxsAJXH(RX6TmY{AfNxH||6NoCLOD{Mj*7td@8fRjB0+_D$A;>H1) zt@0YfCD99<7!0QZLK}JKy`SP&_t^(3R!%QsKujv|JXX`Zb82@5G8M1@WyCs$lcLEO z`a;-Unh&phF`m%id!tOgb|$tYpnOn{|8+*7k8l4xMN0K;2z}~$S9{69;XO5--|SbO znRoER*eVYuRzk5(mTK4D#N3rda`x3|d{kb1rj+0T&g`>CJSN?tE^DPTo;Y<<<-O~i zy}WXi#k#)m;5lwtk203nTnqw0u8#pgP4yS|lfa(!u=+_nUpvRzk}U%na09SC_ycQu zl@#JmHoijHl^;Zm*8&D&OD(lS?w2b2#tBO=4WoWq;+gGTk6>Su>Bw6*)W&0kGtjRa zhw{!i4x4J={NwTe=b=a(0UuYxyZ79;d=fy;qb*?9x6Ou&Z+KF9`y~G;_VuQY5yZs3 z2g_<~SobGU?#x(Hbc)C;3S4_D7dZ5NfzMHC;!Bl!-5rK8po@v#yobS@?i9Q1pn04) zIac;fLCg~(4Ok^UV%^G`)g2kUZf3A58Hh|g1W!%vmx2hSKR^)V3rh;soc0qT?ecEO zAuE*J+MgFCo{^_Tayw4hC(sow0)CUX`hS~>_;1(3M4|%5fY^v0w^yIXF`z~E2j6z@ zLhxmJNwsdVz$3GMnHpGFTJX1MK0c?f@H01sVveA%2uM7#$yRvthd1Q8q!43D2~olk{Wtz}v5O>Y`p=<8{8 zl>>&Av4V#;Gu#k%r!n4jGh(u!P{QdJm!OKOkX z`<#OJj&TVS1J{wvdaaH(Xi9c$?K<;2;J6*gc?^00T%h$o>gso%6>6j)W&urk+x-3D zJ$2(|g&Phiw!(_MLuU9;f*x$50vNkrS*-;RM%kyQ+&9`{ef?2O2gLhTeViS5MSk3l zYooC(Yhy+8V80cEwyb!etD$djAGlr>cH40Oa)s(50a5ie9an*(4A; z90)iLWxNhynA*w%3p%lCw-Q895DLw7KS+0D70u`7+WyRH=gpcLn1W)hPO&Y(&E{4X+2m} zv;C#RgD@2R@16PXJ?UDiF*p0uA81f=R9k{v`7xBB&N9h8W0UJ8hWuvhfwHXh1>d13 z3dV`WZj5@$0|4G34B#If-&G$NChs(P8eQpYD)0^7782y4f zw6jwCrTpZMn%av~^-YiZd}1Pbq_U3x*_GB8d#(U;@c?JSG0!Wwf5;a1Lgg{-@}>#b zAVyUGZKm>SYIMX-we10sO1KdSDB3W&B4-jxK~Dz^3D9s1 znCZ`n4SK;ie8$Q@Qc0EB1!%l|-YTZog1pZcsGpf5!u$Y$W%fkA{HHk0vFq-0`KzD> zlEJfmq5O?#*@BM_Ld3cHp?ny=Y12U&s(=qMqWSNaEaCE4z!v!piRj+zG20HdOJ_L4 zFhLodpha*#>g^o(NnZg;9RNn=tYhH+T$0;C7=^rA-uq?199(`NM}fxvRA*|6paFe@ zDmdyk$=9wVtG?Uw{9!j(a39n>(y#l|GaHm3n<2u~ph55P4sF~$Gm_%wAQINJAS9>C zyFFwr8|Y$DUDN#GOL7_zIevXv{TPaI+%L`317Ds|1i<5aZe`Lt|Msy3xwmb&bqf-S z+ySe&_;8@)dvy+swcBx#F*tcDg*{HNG_`q?f&Ln;vPNBCP$~@A7CTsKb`fR)eqs|1 zU(TrZ4v-&9$-F!9B7yu$pHSvNu486_u&2g8UaI;|KvgWkgAiQ`Eu*zma1sUjo|Dbt zUl#}Wno(teVFc?-=UTk~`$qo)>paK!5&QS1va+8jUcVI*ODUCo&^tUnz7k3&3gotl zoBP1sMQ8@^nK>&Vr&uz;mR>A6eX^gcH?Ly2P#ZHc;$X7?-X;AEHz6Jo;N2rP1Bo$5 z*JW|fYx`s>LhgyiRSva_Sl&(PR1dY8G+w!<1GZNZeRlReiWg7*}srhUa!=RGRF`+dt{ zhKn0F0ZQdSNJvW7T6zg8FbQgHf7u0JJ#atsP! z`fz!ps`~KZLv5Dm6!G-%z@^O}Ju@K9@3O4{OZf$n8w~qP7TDy*3n>#mMr>-wy?D7m z6h-Iu2Zc*4ePHUquBFTZ;w=>g+Y|<*{>e1<8XT*D!Hb`bTW`E`W%_R zbPqT+Po*_J7zR>eKK+SM2m__xlp{_a@xQ0R?A1qO&`Xz_I3rL0ZSMg3anG%?>eHPL z#iDT#NX3Mspj4e50FQf|eVpKIC=ZTBYcFBh=YwrM9K5tr!f|$R)}nwNmzhy&J-B3E zxlR!DxbwD`eke2co8tr`;f~w;@8{zOZ&Q7h^&q`0YQinxayHvsvK~2|2*iX3_{e=*Tieu%3Qe5ph9LMb=L2At5#WAT z^8~?otvEv=+7A{;WHe5`f=lLFbb(~1m8O?~*Z6`O8z;k&x(`3#gQ4iuo?bZ3H5dL# z)$ewFq5ln-D&Aq4#D^@wSc!7njxAOzKi=D(l}@1~1^rQ>CG@8SBAR+ydj-rT%JZkw zB;WRNJmNomrH-F0K7woN@~hDYqXZRk^xueC*((q^hXhfO04ettY@w2O1B=s^4Oa#; zZD%|V+dydJy2w2lV4zRuzE!uAA%6DaeCv~VEAVtbR*g`QKL3^k)>yV+OI_J>RgRJ= z;3)i6GV1=(j_oHoOT{fD8yf<9E2SM+hw*=%Nh*pwU2&V}0FK=RXJX(l$ediP&JfG0 zmeb0u0sz^vd;aVlZhR$WA19jiGym+grkf&2xS?OAU)^gBO@^S2rlS%GO(?orvP?&z z780>ikEoP6u)TW|;%(nZ3-Xq{dG}*#Pn)z?lDo`tHfW(VeTNhWT2|F1I2MB9fEMsO zf5nPs*9Ea=JD{f#?ztjIoZ_yiv+{^5{^l2@(jfiu(RMf5qu{)x#}EdWQ<*n>ybd?S zbI3gPwPbyaSh?dzr_bzhmS;Lziq@^V;-6#7O&1q8&~2hPheVn(u0PJaq$Cj_)@fzPQ9oL&xHklX*J92TOya4|bV_g&qaQ&TKy=>>bYNDZNif7|u^$npq{KGWAc|0P3kNgTna`$Uv>oFHI;qS& z2gFO#)`8=_t$4P)q~ym0aP(~#;!F<42k{wP_8eRWEm!wV>0+O)`y#@L%dk6;bgq)Fl(Zo>Fb@v1eT>w! z^DMC-(DcrOLxVCy0twHDS2WBqbfx}u0#=1MGcG~Pq&OTllrX|^EDJ1L`rW~m?d@a8 z=gQ05*BCJPF6y30U}|pTEIFNF(A*P_?ieOVl&BLa^6e}$%tFh^EOb1qi4f*}&0FRB zL>_>XV>V^`L9^2O?7y$=^@B#LA57vmBs@K9PQiBB=_=P}I2OkX!HtDS`}tmMvUgol z-GSEV+Nk$)6;+)_Cq3w=EdT;R2v;(1wJAMF=WO&>jR(mm9~nWnL2Ce39v`2+T3w$6 z<|YqQeYN@NSzwAQE_o7oh=FF;aG1gefET@_g}jOTW<_j^2SzX7*SSc5DiG#<0Nq3? z@LwFIsFaq*b6T7NtNR(loF!#h`iH>%D-p8_!-sT1E7s=D4Sg|B-So zkd|fqFa5P!6bx67CG`Ut`epn^-voc75IC|ZGLGDrkpr9cww{j9x%_l&ENi7d?hx(Q z@D2^1rxiQdmswPYOovGi++E?U6^2B-d;)l&mm~_{T>A8X9+W#LVtu@1qyLw{LM$LA z=TQs*S%R+rcoh3>dLfldP9)G6&x_oE#03HX-dhFayGirY@X@Zz>O*CH&PhQWkAsWP ztGjPE@)%W@4i=+6e&{I4uwofW#8kVx)e;+->V$2g7`oW%BoTdvpHnEQ=3a)md0vI| zD@4G4r<3C@!$<#J*pIlyc*&t!7516Ci_hXj-LRqe#DVww@n#@NfkKj)HZEuJDgwf- z(;E;!nZWo)v+?I`$gf|l>}#Tp!1NmU8hp$td^)NCsYD2U>wQBo@C>12c{u;57WTY8 z^bW`-&e>vzq<(DwGA)US#Cd;%Chx!g*vzy&>M=+`0f(st_yvHGFOxz&B=D()H3*D2 zK?4W&28|ouuc!cZZZkE^&*KV&Mouj@g)6JB6=6WwCqS_GX$3cu%-q$opE2?u9GPK+ zTZD3he+=l2WZzL%{=fg!&RpA3 z(<%ZPV>G4E>ZJmKQ(w9W>;NKR|6KuFJ;lpurAW+Am`ZyAhH>y%Cora{Wbf^ZnyGw72?k0KP{V{_RDMGmXOZMYb!r?;b8<=&=I6OoAh(;G9-&Yd)Y zFbLnluX;vhLj$*CU!KMlF>-Qu0baryf z7MJ3k%$#wS#`NbM<$$haAxG^}F8BpKOaIIC1?YXfPnJN?3ZUsk>l+^k`auB>58_+=0sxQSL3cH4DK|Ak0`O2b;h({($IbFP`GXriJa)UU{RTu?%3o1Kj>v&cRck z1j)6sBobE8dI9JnqAF_atR{R%(G#E3v*FXHlvb|Hn`iV;g(?3I9l0oSnd z0}$`Ch5u==Kro;E<3~$bF(V9G+S-XY66G5$tyPhcBpkcYDO29Tp``K}WQ+*}HsSIy z^&zwi4yzCXV2&+jGA{ErmQMQ&-uS ztsxlcj*sgZ!*#}+>2x|qdAxhDEe1x^aE@2sF)3+XpUz)GdR-kHx1Qa0cV>r!p>|ir z*4DQRnFufVTidSh^R}~Kpd3_pO1-htXzdQ`odlBqt}CarW~%#A`aP*Hdu6WmdWWo~ zJlNgR6&sjf8>;HhcBOgme2R(!s{^w$eJ;_^3<0S%`=ev{KgYAI!wFFO;dD=B3|JB0 zi9i&Yqxfrww0xYWHFUkctIk?IF(j**PJ4RPKKsQY3hz1;Xx{D5NZKH~Lu&WZzY^AN zmQ&?uvi6&7XXw9yy!WQpeOrpN&Mr;(xH$FK4f(*>F5#z3B^j6*NLj7OYBHlJ=#cS3 zx1T-RI{F}K^}~qj8d=2K4E0M8Cw_Z-y;@VyhR)0L1#hN(P*77)$bId$V#SIwIG~Os z?AT2`9oF5V% zhD0*g@-FE!B5>=)?nl1u=;HP_Km<$%C%)Y^Utrw~68eHgN&5==AyXA*7Xy-#Pw+1} zIvNw_P!?}(*&r)iqH{id-7J-@Lo(3b%e%|fM4EDLHZp^wGra5}W|VJeUbceH}G<2^r~2u&TBMtJge0zBWEy1lb4a}ACk-$-JD zyZ7!PC|AkkGinvmJRP=?ax&$_We%&Y=9VKIHfZ1<;iw#P)z2{n~&a5c&A%=PqU9l)N1J(J^8wBTe@3%UPC(6y$ ze#uFYRM}NrS>~>FsQnvZLL-lgta?Ypd=Bp0SE~Ccy-e6>^0n#v(DkJ0sRP(Y2;_yc zBj-{8s~nfTFa6HYA5*b1?s9eISx_j813@}XxyET?0d(NG>J%Q>3Lvop-)}3UYIco6 zj?T?Y)He8%Wa00_cj%g%n@7W&EX-C9lRrlEt|0C1(cb32 zIb^<&`%%(WM1-c>F2xPi*4Azy!iL*8GLnUl_4f8MTZ~8&jJ}%r5a|o7(#fjQ*zpGP zapGh{q^GB6N3yTh5ezbDP2NV&WNEQKEWyy0uB7kEwIRj%H#kwH4K z-kiTBy*m%LPSI?+xj93JEL_=I=+iwhxY!X4^M^a=lJtJ^L=SO=Ch3@)xFN^BV7iT` z(DqecY#x``*XSo#_AJ=k=qm5-l8{#$0}Yk5o}~{G==pn$T$~fcPc(GjILWZK4%lA6 zuF{g)Joj(6@88zjfAJui|K)zZ<@K%Wx6Y)24%s~N+5GXUXJ522_&U%^@-}nO_qbb& zeO<1Z*GQeIWq(q`^hk;7kA72Sr@CCa@*~aZ{xbC@nbjV+tk>mYS)OiX*uCgng^}S7 zUqA~8#)5f_-H#>ZkAOyEr)%tyK_n0RWnRPLgN|y3K4Av36MPVZQHPU21 zdzLIkr5qU`UufeQjHt=uR-0o@sW67sst1O44A))#h3UUlYVRw17KB0ksj~5_$0Ny& z>`$6)i`k)R2CKP!?4K*)%jj{DmvXnc%E)C+M7tv&oop9TzJ;`*+=GD8yu3Oox%m*$ zD#-n0=#SaQDxRWJudaW+aF9RHt?J~}`t)Th@irA#=BPfervnIt%H#?L*-zx>cEv|a zDgA2a%mKKAX;gXNG9T`QfV_Rf*?Vu0l8cZ*@&=w$!%VPYsHdv=ryRIwR{)>?#?-rB+rdjV^VJ5DsGxwchdCf^Wk0cOtDLHjd2pm8 zBqrq^($mvxlDT#9XXhItjM~xBfd?3?5iW{CV;%{zJ@$vq_&@`-)R63{@kn%G9U-)? zsWLthTBttq2873Fp07#lVS#}hIhfFX7P9U)3o#<(dz#?} z_0V=n@6pl18N-6fA8O9(Vg1HhT3?bH&V7uKfC@i7ua+yx4YR?)OTk)tcC;^E*!&7G zzSnd+k8GM=?PD3)EWqYSd-3~99#){~KmtvuBW-+pZ?kjcLG{rV&%!bzH0dic?GX7mNyB+m(xd-EK+qr*c|Q4lk{G+q^1 z4p5{yDB5Sfpv#Mex5AxjPkb1Ae>rwdCLC*>VejM9%EN_Sm>7Jky!_B;gKaHcU!?!} z&%nG5(C$Kq1V*4Y#F^+d<958JwYgDX@qaMe*h{?i`2_ z@eIaUQzv6d(_|*Y`i`M%3GZ#!`C_2ss(%1*6Q1QyD>|# z^(yB&Ik`Fy+2>fYmX%t3TQ2k+Pl%7V1%>QX(O;W3ZL+J&-EDVei#ZoQrXfLmFQ-2B z#AU3|)aylIG7u%TFt_IEy>X@Gz9!y4Nnk~#p$%v5sE2vom%W@&TdVVnObsXMR|Jw{ z>S$x4UwF{42)m;qdasxp6!5PIwqpYN_(XsM7ZvSpIC+J=DdVyXM#Ev~+odn*$?EWz z9Rr!vHV2FH~^NQP`ZsfN>Rhxuj}06K8rF{%3P<;Q9IV58-gK# zjd|Y$MeYy0pT2(mdSB|Hqy;lU=(}1@dfJIvXb1EV4(W;ML8)#MDm)=_hr7gC?m^re~uxoG-igCigMEg4e7V;hmUoyFUkDa`@5{j$ViN z)lvawJ}sOcC&SoJ*yInNL7J-(Wj;30s%c=*_gA5|zWzgL8JRbsG8Sjv++P38u}3rR z@?ll80;E7c;0d=!#yxfx9`5&h`Vqd8#C4>c6F#gRt?YY#e1AgS>jy2D_)sk{^tD&}Pvd^%~qS$a2WgQp8aCO*g z;}h$$6zeB0CFiz}Nt|uER$s^SjGtjJm7tN-(qU$)2KPZ@xSn_JCCfIb}9GMyO z%j52S)!)By&rf@dW&1xI4^7mCv4eHYvrI}CnOepMt_a{rOBjoK5D87Hdt*WS3XIz? z3hvVI{3I-QNv0ng}Bo)9VI5 zCb}?m2RGavAvWSrNA`X+KggZ<&vpSZ+OGK5LY@XBCp0y@a(29e?Z_=(zn%TV-QC>- z?n*zdO&g6@bXAjCRwU%Dk_zFNmAMxJiP$>nFD0KoevDDnYLlbH5RI$tGt-^0x9L30 zKV3682VvRm$B#g^9FNs;extwV$>?jfMfrt7c&FD8tD$-i0ZN?4*O-$jC;0>@^dw8iI-n#YA-xNVV?vp>S^`}Uma z@!k%kea?TI4xUPn3i|QGz5(%K2T>w~RaBYAtckaPjW-g6xh3=$>?hQ{uV1aVw>NPv z%$VZ9wRsl=&w5xN8wjBKxxONjLv!n` zBTB#aLbqg{+C9nO+*}1SOH0SuRGiNb_utWIqGWy*+^EsHclTQ-9~>N-(Ml(^L&IkR z&P{d%U(d5xOD6HIvMX8kT~A8a&?$Hl+s3JGFDZiN3{_(O%20~^S&y#%MZQaod=`Hi zEQmo|f`IL+uq35h$kO?;?U3|9mgh)z`b6K`p5Ctz+}SwySF26E%DK}IK~#VD(6~%} z#`U#fug;0k&AO4f;W!4yf-^^_e>Op#IE#G)_04EdeZAqFN`8hRg;(Cv;qvqyQbeX5 zYRdS`%pg>153Vb@P*GmJtQZ9Qy-}oY`0#0`gTw1-q>$z53 zao%nDIlaerY@q&*Kt_h^vn!E2l%e^Vc`7c-**zCe7+^-*ur&JM3|uEezVlTCSV@i- zCklz*GoJbeNqqh3id8wSPX!K@C%HOG{}^}rLFU2%){iH{E~)_>9$Zq_?^a3Jpp*)#>AJ9FPbzQFG8%5QIuwR2cb^iys*C6Y zgJm%041;B0^z*9E!m=_qcg4(xQEn4{F87l8l%Zf_hfpqUEu9x&N8>}mLL?E$fo%kH zL25X2i`2>k6-SN}ppJNk5X?x~$D9IsQc(cB}c~&=!>o=FTH{?8#@0vldeazqdjM)o4-Kcc#B?IX;iHh12o9cBrwO{s5^vUx{d9~}~e!8^1 z__hIgqm&ex?{#cf-^j)yNG1Lh00WtLi2pnlw{IEu4u{F7s@kfT&Sz*3bwN^Le}w1s z#b3oj)2j(-35}Ubpz1szP{JxZ8X|(A~aU5&9kGorep4pZ&R{2S91Dn@1;oH^b44GAo03-WWVjl%Oxz* zbad7l5$(I@3P>aR5-&>6@02Y3~FHSvV z8xm6NI%+5|G5&*@)1abwB{XnB07que9{&2ZLtf$$8EU*!Ie2Y7TfRc1I<{4oJ+mjW zv=pj^@}HLKgN)FJ9TPr3rTJ945K6T_W~N(a9O|AM{%gtFCY#cSB?Xq5q}e^2Lz&0@ z+bn)EmYn(W_Q&+&?+)C{CTw;bBv2f%%a?5#_B~dc(L0(n@%e(L!2y2$t#kf0rJS;? zWYcT$<6YaVjxxY1VA57dQngZO97M9W;EhNI2M2#QeN}lyI@wn+dY>Snlb~byEm8_G zQsE;Y>oc@Fzk#pYMB2kA!nZz@{UiX;7w&*a2mJs!21WWQOiT2`pjQmNXl5RC%4#<* zkc9X{pTEA2t|%f>e5`WZ2-}KM33?}Xmw1%=>Bf27W@r5Ws*)bkF*KBTvOmCnw%(^l zG9D$qjgJd;gaiZx5GF^KfuhszF3x|xH#ATupu)BVT9Jl1?YGs!BE2gk0|H%1blvgT zU(!CpzaIRYvxJkt3{@y)My1}LU#5Ykzf|Ajj`KBo^v3?gpWMvb;AGy$;!*6Rw+m0u zjq)28>UOlZm#y(#wU!VVoV&hoA2%!KhpB1euD3qjGEs!s|qxTZ)BT{k!5ZxOx*kU_+vBO_w9snF>>A&;YCzzn{V|1-J4X4N+G-a;~x|k-D2Kj%p!pV-!;ZoG2FbomfIDQfU z)iSk|TjRV$<%?&sww*Z$U${t>?@v&Ha;o8Pipj7X2XlhyI6k(7e5hL4vv z$hEkqahhn6fVMsUNuYg5S~H48b9U+#w)&sDo! zKGl^Dw36_pu`&0lmH1y?)2}Y@Q08$UT)!t`G+|)v@ejmL7z2L0e>FH~A`fgH2+G3f z=zEx-lNqk47sxQ3K^r@>ZTVAiyx?iLX0aeg#?rwE6H%Hn1oD z9maH+3Xo-`td4KnjoB^^4^1boZ`UAYc7%;1EMzf0GqXPL4nK)g3i1Yu*uwp+JlsLR zW3ohqSes$ND>#}-JuNloJomlu{bEcUloGAT^n@$TORg>Z5XmR4#V4y4a-CD8oLk>= zu*UEcVNHZ9vo7(ssO)aba*OErh7z3vOaSPBGxI5Lt?vHx1mW+;oj-5n-Cf0JqQ!US zAs{dy6$-t~yQl0L^R9P{KA(=l7^*F$EVyinbsUajR6yzqF0Sow`J~;*afBkLeeIo7 zef6mbnUG(+Wmz6dx1rsmBiHDgWJ`2}vIKu47}LMk0CH7C%YpNx|BV&-#D*x}S+jZb z$ljli_xU%G>=mZzGdpPtGw4^N4x(;)H(vCA7oqR|=|H=CxsCNqM@w>cr7Ag6db^iP z3Ja*MlGn?-yjGUO>Zy-1TqBq2o84;eCOFe-MdmpxJBh8E(+7)ToRQjtffjBUIs{&T zvansy&L7wEs`ou?VP1t&l(OG%9^?XqLcd7ok_A2h{RjMKYZFn=Ub)5OYTBxW&zjwT zzGupI0J-nqDO9UGJ-Fl|P?17DE!tX7aES0yIlA8a^Ai=qL|&@D>B(MP%T>_+g^RJgnE-mFesYNUh6F#C)mL9G^ zGhNvEgk^sdsOqK>YoRYgq4KCTQv6L~Vh**!vrtx+%|RAIvZZ^-`i~@Kw=E*#dS?gQ zN-LY1`rHHOeI`B$0^jQ9glim{%4p2jNGS9d>z%BYcz-^KhMl)pu{?6w@n5XLW| z4Qmgv5VEbaSxzMt(8gOhCXom5!@8|$2gDvKDUJOz2h|t-_VznRLJTi7>?6?mgB{LE zmMJgiJp&l`21?mt;8?Zk8uNdH(19Z}`lC?(7LyIF=4(T#M@nM_KD+D;bLpRvP_hFq z@fLQV9@u0iq_UA&wue#Q7U{nvg=AUJhHLc+@=snbK~H{fr)~*7Q4{7dQrW-e$52ra== zBYgs3b0j%BPA7RxmHZ(!&~B!TQ5_>_ETqzyI_7ppkKj z%f#Zm-SiD+en}}~sb#SKM2cLmv3l5aCu?VS{_d71zxCR62Xv9&i+1{dF1kqy;$AUd z-foUb`jmH_ewF2?wy09VH== z_k`!Zs$&{h!f^ick~+VLttg1|?A?v{$;}i0bAu2mDV)?i)6sYiPu6S;%c8Odx&Qw2 zE3Z(mK&vm|zx(|*RIDBf)*BY{VM4=?8ujm*;;ilY;CIU`^VjnNF#bit*h)GT+!Xwz zY~%mj7_{7LtFyAzQV*eZ8NWWW;(rzg?3M7KHGp?m7{yjrarXD;(jL!ti;m~{zxz>BK=YJM^5kx>SGK2i$$^ZO9RCKYDptR@t zz!jZcxlDVwb=H6HV;Xwg8jEDllr04z0zQgm8Cf6cwTr6ByAy5czPaSrvk?&u8u0zw77DJvLSqeMsx2*U8HZ7R# z3?KHsa2&RZy64ZIKY&Wc(anE$Onid1A^)DbSD8Zk?5V-n z%+>4v{iCGYW|n(Gx*w2xQe?(j`0S`oS0|gpi6QLW3}HI<0;`CKU#Pqv?)x;dF7r@q z2KnrNt&(}t?Sqycz1@#=rynd)e!Nb0aG2%nU%xBpm4nYw(7-XMCewDi>ouD{^gyh@pf5&1}& zI(ooT{jj3iii(?}xRr=MC-$gAb8e>6S$Ys1TRY17KX+(lCDNG2Yyhnm`_GclzwLE% zwD8cx{iKW$QXqLnbv7;3eq1#k1;{GW^H^WUj$ z9CxEoP7ZdM6P%Cv-D~T|PbX$>V6NVOz1i*m_RWnk!>@G|a~}}%H;lfi-xsm4v^tdEx~@N4EzRo=^7Fgv~D z*d4MJtaBP!(Pva=uA|ukcKTwd9s7_MQVipdWeZ~^zk6t`})UnI*(I@5w z_5X9hTv^wr$VrFG$(M59OYl;8ldvp-P{;+O%^qEeSc z69P5$rOfN;lIvCMf}rveRLNlFk5q#Md&Ks*0M{%=^(`EyjS`g;qMFLutIQ|Sc&e@Bdh2a9$%9nMc{L*_9cs&D zA=&Z9*VrsA{Vwm*C3G@*gJ!XXO1{hb+`E(3c!Jf;diQx>vQj9e>_}L23g80=5?*~; zIRpHJVxUx!w56Tz9&k$Lc0bl88#j2P$1ZdR#&2dm3l8v5PV03PjFoPVrS@_l)vlXDjUMVL_}0Ip8~^Yd`OUCcet1$@I&uS2%Uw)k9CO(Q{Dqp9CXom32;fmio)rdiy5 zWar>sy^dNv3wk>3@L;bH<{+h$ZM2qw*i@x!9ofQMu2|42(JVj;an!RR#+QDjmn+Up z{xoCZCY11dN(6>HVb};0rG%b_S2XjNr`eWANyyI85T3$1eN)P z7|wZ!x&WDp>hV+FT$(kREnxVq@$1akQ<2rgt@r^B@Vojo;)x_Znm@t}K0mh3&pExdHz|hvn30 zm3c&xVO}h?1H6DLQ8^qo=DHSSc9o@@TR&v?jU&!5i1`#|V~+B{#ES|)F1QT3b$$qc zsDrD#@Ud9TmhURH5_TS%8m%OwC&PmF}wne)GOc24zS94QryYnbDPr5X%judWP zZ{XhRS$s9?oKHc1uJ=dl9L@SuPdX}Fc289~&!VY*^!AQZyXPZy{%E9jhB`56qEcte z@1|gmPORuCCMS9qcs!i3XM_N|7k`dSGhtCHpaeGP)M?PTJqGVNugUy@dQ{QPHScGB zO4*q_Z)lw{qOe^lU^}YlDw(m>>ebVVEa$9>^-6|58higdKwc9upS}99+~nyMUYdGl zd`|8C{Vl?DQQgT1B@a>0Ib;ti+?n>sWlO|e#^J>B=g8H~f_p#byB#;VzFzas2EW7F z;8($zP_j-; zrQG__f4<7^KT+}+zbcW{w3WIBb%-4}{Ok$l&EzCu^gL|EwPnK3nB^?oa0By(ck}^g zFbgKoTQPuHE$U}Xmns59XiB?-*hc1_MTqc$`N$hj0l!&d@icWmZTEegZFxYu#UcYg5zim0JcZt+gMV(&nq>jm+1XDGb$@!KcJJc7N)&g_)LUgW z7s2@Rqw*3V0E~9D2w?7OOM3?JqM*Lxcfbggz+VVcnJY-C$dPd$c$5ySBReak=cXAY2kuOU7YIftU8;K38+ zI%MGWwer8Wwu|l0nM)bWkXB*iyaoUreFLzpvBDDmcNl^4ZP#p}G8-f8AD8txbWKU^ z-!5sVE25MV%GD!w7Qg54^8USPqjHA~y}o{OIMsT6P3Gk}4`)UbWyqHwSoR#mwpPrt zT!QWB?0+f~!@RtOgLZBup1cQ51>{x1j7Yh?fcA@!p?|H|1q<$o9N|!O8(I8TJnb;I z0sq!B2gZqO!z+q~W-|ZZE41hKG$G@#UR06a!4Lka0yLeq1@Vug(3AN69+;H>PV{A1 zH8bWf|NlSv|HO*13%PHkB5|X|^Y|^7f^S~e z7fBgDInvi~!q`85Gnwq3=6Rvy#>#C)2rO0*x~>n{Gdqa^U-Oy9hn;rZ;k^t7kMu27 z`uX7F)$h%DasA!*?Y_M7Mp=2Z^^vdOqGYg9?<;w@cEd9s2Z_5FEPFmoHXluae~L-| ze&0Nt?WiZ*8b8JWMm+T-wQ=I67Hh>Gev>3JpJNrTj-gXc3W|E(M?A-?PJwXHlhduT(+GL#ijNwE+x=!fmTXBJd79`~|@XwHd0B8Ru1Kbor`CIXg*s5aH z*_v~m*wiF4v`JJ}gf{)V9<{2+=nj|n-6F0-Wq#?>5=5i|gz+ODUlDr5y^XUK6%&mM zTB}aljl4CU-b$)b313~VeS@ks2MU`yBn(&3G;()wK}ViRTR+z4a8L0si)8ucEhFLb-yTVzhTz1j=<4`zmaisQkq6`<&#zUJX>Q1)`^CU( z`~vEOSH+UD*HVK|AR;Y7|5BLx0R3t~V*l)5|5*+4sXH}pSyp~t$^hL|AW-3J{JGIh zjmwp{`Mg7DQ+ca4AC%ixq$*1g7#b^7X7YXysO$Uoz~@8&c0xFFC+sNA`i3sq8Oyvl zP2v4F79gEd&vY^fo949HxuPZ1U%16{G_R%M+??ZmWFmNL)D@2M%xtlm&r9{)ZFz-O zhkUI|HkQp;Gg6kFuhkUW4IZ=F{cWZi<9<6Qoj&d3p{7fyh8^UPMiDfBdA^d1`r)JhI!gHx5(!*7-FDu*)MgKljz**A~0?@1ayOJE<|rQ5`J z9_N`$oR`w~V?Eu7{p0-O#^*5ujB)V)k|xA4n1H z{dLQ6YmJt$Q?lmf`dlp&4Er)LR8> zdG?sSUgdC@rsoU|c~j*l+LNO z8WrxhMBod%Hwhk2A>`0d?Yu5Lh#KHK@v@3DpiGx#PEn2iTqYcJ6+G*o?~_JlF++X;^()T;rR8o8&jWX2@gEK+W@nslx}COu zJgI;!{YYQNp!4YCLwhXk^iE8MPlCO4MD>SCf6%3&C*tY)qDDs`r2gi_KxQ>5CVP|U zl-fZ?(>G*>tGAV;$xBGg^Z25+F$V2UcdX{>jn6JeH%y4SyN!Crhq>JI-_PhHoK{I} z<9~n8!2Tf3eo*3zz1)o_V_whXD-}Oax}fZ#NptS#kE1(r>%IoOx|e-s5tEkyE;mEv8M|mxSol_oZe*F|Aj|(uh3% z2OgzsZK>IGvoM{8bxH>&un8k*KWI*d2IN}$&#lF9EkT?wi8@u2AirJ7CMP8{Ox%WR zbhTuZJ#?{ydFG^$d81l2Tj~rP)YB?-wUkAD3Ld*CPGR55yA3|o-dP*UJ3H{sPPI~s z{_~)ti&ORu78GM-bYexm+olE?L;y(Lk%8PE&I{50lABGg zlq|o@8Ll#+e8Rekqd@xPQH`)`T72*ProNJLF)g&pdDt+@qW}c9nf}t$%9dMVT*eEo zZ;lN1E5eGMNz%-?_qb8c9qzErgCvz*E)n#}XEu$o`Jn>Orc*;3Eb}PqaHsROrh~7pe}P zb5djZ8nn)Z>EvXG8=6VcW$YUFG;t(X6Ni)@Dl+o2@+LC?+aI{<0WG9dDHC=%R&gk(wP@tvl_0vK2)-0U{L+}2D|c)pw8SA_1d?mN%V_D^Y0|$ge>1-YMJ0s9lq!OiVB~_t(V7LNKaQcmiaI@ z{s?Nxo>iiCwb5mdO>RaFUDmxrjt=9H2Rb%15)IT8X@5LLDZS&1%&9Ev=4T4lvy2l! zl8mM%Ir_iXWO|3jt*45v+5(NjDj;dx;f@2VLGAF%7qzCJIG8OiI;|mSymgbuLHfbI zV1kL_z(@@sdc8@j9qwz`W{FW?3FXGz;sx(2qxrgK`?CmFi-N6pEiaYJhJ04i#(64- zxLOv>kI&#WaRV1XE7)IOf|So2WWxtfolq@#SQzs%AbYqJol9Y~OfI2{DWa9&b~>{@ z&fgktn{2x; zNy!zi3FHSsn%4B5k13M={LITakh+Um}tWp@MBK>^Wt)XxqggC)_;9zqJU%; ztZzZjsHANzP4+~HUAgGwr*uFdrVMTY*X~E(To33BVV>_<8$r1fU^x~en7&2JEagwL zOT4jR%YhN}`Nf(?m_$z3zg7wXCNk1vufLy4oX-#%Ph@uvRqSa9DJAAUuQ;=GsR0n2 zO3_iQoHX0w65lI>m-S-+T`kiwy4a!ZEq+EnOpu4lvKo#YTMW3|(80c^>Q*LKTyQXB z`b0~(YRg`f{ zFlOefz0q1imp0UCx!%O~5fNI6)S>u?xNr{f6prna^{@i9OkH(HQnp0bAu;-0o#4c1 zU+xJC<)xpQX*gY!#Cdz)-^Y2*oHKc%cDWbX|}B48Yu zhxsgA5ija4(-y~jbOb0F+8Drboes3FVJFzT+_B}LkK&%7tb!4#u0w1lKumVO{0o#gFt07{+w7qQyUe5PL0YQZN4bXBluKU!8 zIvF-H(!6oxvu3H1{(rv9+&2DlCU7ljJ-0@1P(9Zu-!(>5&Z;pzeRjMt*4%Bvv^wrc zWO})JxB__!AFnZNnJ^w8!~Kg(^HDxYD5rigp!gBwRuU8+?T)tEj|hV8X!bST$7*sV zYi%x@kHOOk)q>4EKw>|VbhSd1PQ&vK0}xjc{JY@zXn$m&bX>n|T>tDClLNhA2?6;< z`eGtK-u(pON6l9%+ZTr+!}AZBna5n7a33gxL4ep zTo@794)Y)RjG?^whSBlo97(lKc5pG>O(v0>tUGkR5?6$5UQHe&pPA6)r_Q0~&LP97 zH;Bgt!46iA5xq((SeBTal<+ls?x#e*7Of;*F6FrT7SUq?1^RDtUbHbmxTxQ-JT~i0 zvUX`d=vmf!v#OI#mV7IF-;z0QnrgIEQ9*RNiJYhvS^VSWx&_N45FA1zLer;1>*rW?!xZyf)O?rnLGNQZ|g(C(~75yl;o51 zLkpPF52v7p@;-AJSYl_3QD?eG3p%%Jh$hdKq@6=HsrO)>Cke1czRlPG2vQNz{;r;F zFL#@v>CT^|pJmNl*!(2nJFoFYCm)n5k;hz(Kr@}W3){{_%~`Tj>IT0Yg6h)wUWKSm z={5Nz)E`l(WMeRFo_O0aLtlj~Bpu$yaH_39Lf*T6*DV~c833hUs>!L&@D!4!1IED* zrB3bUz96RY9`|15e7XC^whv{0TdJEx(Rr7Ck2fEtne$cw_kaf}YPf#b&`M!IECvs#a@K5O(;)3 zbwr^jT3dn_=ecIA*|^2~7ZX3xj!I3nD|pBQ_(=_w3qTJ)trWKcq9TT9&U}u;iA^8{ zR?+NBBlP7f$r%Nh!0=yF^B{rdhC<(n-s=AelbU$>F`hs;?X^41vTZ{PpMR zB<<8Lj+I;2(e1a`>V$>Xe*TDXqRn(K0T6!X;I@j05)wEH0o5S=hwF@6-zs1WuY(WZv4&^V?$~T{_`cK{1E(4)eVVW@E1lch z&ZM^05i)d-4Nqjj4$}`|mRk)I+WM!*CEp!kVg7e1^mKrksTGnbCFD$$GT^iW2Ar<6lvoBvo75))*W1{j3^PbyiTLGF+1&)W-s} zy(=mzj%NCDD|bQG;b3C3E&us&i;f@j5f?MpLkM*Ti=q8qi$3v! z;GDl>&+|~SwjR;3U%X?5&AF^~1qVqFz9KaTD#>f_4GS$XrPf6rN-@s_t5Hk}IF#6= z+H)**$t&Me`w&JD>oS~(O7%~x8q$stLp}Q{P=L`l_bTrY-xia-G<%Xycz^gtl05Es z^ZrN(hD1l+)Q6|(ng|_BQ{!@@rp}~y!Y8poe&rHv_iO?`2~&>AM1=g6(^h% zvBWErV9wY!KbJyxD|B1YC@(=YIZ%2gz@ix3H;@(fJwA&MQp-M{ENJr+)2w+W zG}Wz2cqj?wE#i{aS;uJgai?bjJhEj{gI-@UqGc!<(g8Ld3G;C%S}1acQ5CF!XrTzj zmQXlX^H?&jBA}NbA&P*%!o8Rc=No#@IqVBZlU*WtA;B z32~y%kc)|_*+~FDZQZ^tc6r?!?D!f^n1%-fm+(41SrrWm&8e*B3u-l!1j9`)H}n{; zX+`&@8ucQ=-bJPn7taB@+t#-3qy7KDEEk&iES}z?Erq$dZ8f3IcW9#w$VIj|slMdU z3M@Q@^o9e4@gp>fg0D;Qh?w!OLo|DWl<9}xB}SbYTqKm2Ml^nr-g#1o*!HsQhKT7HnXZk)S{$dE)YVuzn;70GQE14>Z)5hIrW};Y>Zdm zhE0UTxIFi(Enz(VgYnDQx0n4&>cvFONn0Rlv9#ye-yF7FT^iSI3F3N!xdwAfjDOWF z1fInn{z70h?20uFp!VZ)rQzVc*sgiLj3u zs;mB>)0cqcqaCaZ_`h`Dm+mDoGB_Sq*W^~TvERtHQmqQOI(F^{fy=CRWECwEJ0oX~ zKEwP0^t5hgaMQ-3en1EyBY0y<{WzRTs7}t4Km}2HBe%$o5?=%LC5?nCGFO3+xt@By zl8`mA3D8;v1*Nb7Qcs%5-C!pc)V3$%F=0&+l0#k(gD~pf2x@a6$r8_MvTx847<^>Z zB)Dmw>LH=N(*B?>dB^Sw$LQyz9^~0p9P9G!xH(qogW%QD1P*~;oLQQZ^X8Ir+5npD zd(Gs~|*dttmAW}%Vj}1s!)~7sOk`F#lD^R@mMP~^xWxVoP z^7TiZ@-LstkdjCym($|-eS=1%=y`XTQSaj~ zi3aDh3mLWF4YC0@s^W1ry(|mE!L?<0Yy@9lSMIpf?5Dp^0Mx03*~cfJGM%qjvuylw zJGM9g0Lsrn?&vAoi3jy@^<(&OxW? zSp(bY;A@YX>lr3qPd64k=boVE6bQ|EL%NI8HuVLMVPh>1L@Y8hx8YFf1Y4?5h|k4` z?w#8r-xQq<21bGc%U^;hu*_*2;fLbMes0Z;elM@Jv40uMGy=EXe63wFyJZ7>Mi zvS`n-u)t%ILtJsDC30yD&T&7^T9cN5CH03&rwt@uaN8_+U0`J9B|#(Ze2vCvLah9< ztt0UyqQVy*iL-CLB3~mh5uZYaq zmbXY1uZBw`XbPG25@IbCwthtW+gqOklX_X}J53Q4bs$%AqTC@AJf)~K&-d-z`nI=X zcH?JZKqXV+w-G+$Kf>3vT-x}ZNEh);=7vptGUnPBie0X-%N|e#UscFyx&EE80kO}P z0e9BD3KEJ8l;vr85y-i%Ej`VIm##^Il(YoPL90%C8}-+bd8n+PVLZOznAin#mg3@n zNASyvS99qx2QAgxw9D!v+phX_MS3a;SXmGJ^Rg8fv%5SR^vZqKB2{Gul1B^Mob(r` zl`3iG8lFpVp>t;iO&|}gv{X1610G7b$K8XLF>SJ+?94mKbW~VT`7KsR))uI)vfImD z{q0(|x5M+orOIMHb>-J*CYC7+&udYj5tLAr8M@D1UBEv2V$PDQq}T-Em+g4~v$noH zBj@M4c;)SaMPBw~AjJUelsB3ox49jaJzo)(0@uOx-w#)%t}f}}TLKZy`$!El6*Zge zg*7z&JzRHb>?5g?BQsL>4mus=_ww^tg++i&?E-`tI+^O9pbh)GE^Ts6!g?Fuo`qZf z;+{AVW}epS!!McAy9XqmT$2}a(?)`B)V^=1)Gs0Did)j3v!3TF@3l*411*BIQs|V; zfytafPvy4uVcsJBqk!vE;{Q;}VUDBDJ^v4D=Kp8C{J&zoh)WX!z;T2KGoxK-BR$}m z=E4u=Y1&UePm(YVWnqESe~&W4|AGwv|BPaExOl$MA!cs|!bvF%8?l8>A$Xst`Vu2g z$gW2>5jOYlS3IkwhxIS>KWz#4r&p-iZ_X+Hkx~|lUC1kEZQ#-otXl*r%wmN9MIZyO zl&wE`MG9MYh${4+P~b@W+W_EgpPs5XQ)OooyYO43A0r%>aoSRZ(fk~sXMufr1L6Zq zgd%9=>Y>t`b|fQ}_CcvyYzWnc#mHt!%6|$(wZq0JejY9S&2snh?u@>pv4}+RwB7X( zY$AYO1nr`q@n~A)lsJMtj)rl#)rF+bxfr4Y_iOe+bodmh4w0Cj7gk51Q7H(*N!f^l z(>}Tq#_6Yv<0IernLHf;5DILW9@R@3VcQ*w0MPJ24r9D8tqT#ubSx8)AoPreoYIr} z7A6!M!Xqa<9);TzB=R8>#G`3WL=I_W8;R%wuU3E$(l_(b?30n%CmJ04Umd6%for0ZOY&>3huV~BbRa&xFYi~nn&wJYkdEq`3ZCc52cmEdt zxMw7^JcXYAg#;?E`V@G*Yxx|zmhsxGX9+eEbL$_=dq~bJQyRQ}i|Kj#0+2R^Y^H9{N zx>eqUNdLqDeK{Pw5iz7iT)GCg=4Oj7%bL6~V?_7dDh0w@P}JszD)2w30ZR3QJ8wNa@tF7a1oR+o(VCFMM0hX2?&RJ;2-M`ormmXB zX^6w{aBe=~w^%-Wi{~M?c$K^qG)Oive13*nB)!ReA@0WrB2uJBs28{N=}4~2LIUIs z$>2>B@47)mSq#RqP%(i)p9Uf@?PM#+$Ou0lHgo~}(GQ~@gAQ$HGF_|@lX9SFP^PqP z`uW&{(quBaf$)VwXunD+|6oV0WC4`UDE9ck`G}+Veb8#q?U2Z)QqOyY(shai-m187 zZYEZX|2g@n2g11rQIjhgd@UrzA^(pT;jIUL*aq720MU$KBOGpp+YB&G^qMbin^#^i zl93!ET9;+h0=B|rROtYNloaQ_Bz1s5={mh@WR?R-GuTL4t@^`Z2WnBpcsRNvO^>si z&o5?_9@S4E2*fGEQL34Y0RAn0mpksgOb<%Y*Wh(%y0Q)-w}aadCE+a^(#xcWir+qSEz zyt$%WS*7Ch(n3qT^ux4uM6J_u5Y)%e&VnFRwxKZNHAH7teJ7QQ4i4qX0cL7V190~d zyK^%&htwH?6?q<@UYsxBc$63inmyF?Y`Og`mS>3(DFCfteNf6e*mW}!d8^Q_pMQgkO11A0O5_jBdj~+GSL)5b-DdN_* z^u9u*{Yc`EwvZ^h+s!bfAgnZPmGSwfEi>M3tA0Xu%vT7@-c*l8Pe(jAi6+Qqx|I(1 z9ZO{}alcSgaE#1qnn;-p#dE83C=j9#fR}@TBLZSp>gm_04gfykKn8e_O7!*eK(7WC zMz`L?$IdS+enU`Efto|uvTRwUUkHg?)qw<_d9z*dX>7me*1__hFi(i-e7L$clu#LJ zc6Q7*!q#Iav(#z!1bj^_C!r!(0=&_zvadcEV3jnFT4p`5G!mSbX*sII1S$vuP^!q% z?jXg4vz~`a7dimAcOX3uv^ey{FmpVZpxI84iSkBSXA5-=nM~CR>7XMuJ4=)GVfKo_ ze+;9Qm-KIPLc(?xumkWQ!m7+4X#`6hQ|&i0Yt^*FO@5@{2{-{VLZ={)ganzQzeObz z57ifv%F(Fc{oP1lc~V7+gz}meO-~l9W$D^Pf}cR?ta8!BGmJa0=o)zTG-mS>^Ep)E zbf$mJw(lQ20#KCRxl-Qtq#o58{JBS{8YGxEkgBtJ1Q;^kJ?~UB{*2>2>ECuH=TOOv z8-A37r0$mx`!JZi(bPv z?s$Ua&^k|mbWu!8ObP{=+3PEr`9fX_0X{xH>EqpPf2CzUhwQLfhApA)(;H0-*|E@VT9NGAvrtpb!5JCCz%t?gHXeCBzkdh_1^zXG@cS=3zWE~3{fua@dUa* zCj&}*(aZxHox^Lwk7$7T?Eds=bxRY{iOx@AoaxNQjc59IxFu3cmYc~Oam%C_9wnI> z69MmV9sM4z^XpfbZP7xma85k*zgbPeXfEIrqo-@)^U0Jwp;>@!Fk{pe=Agm6C027Y$i33z!@WHFZ}7sypjdMg^=Zf6 z_v`N&Y!xq@{E<+u2xV5Y8YPSmac8ELV1ROxg1BF7Y(8>N!njW;C#S{z=fjqFe_Il$ zP}PC3ld_QxlP-s&0>5p7O58J8vKZ=jO!F{xA*?3q0|1iS>5ZA6_VdS3B`>v?8t85!7Me*ZgSl?8ChZSIVFMI+b%pNEK8a_5DzsFaQT72 zp^?p0-|p2vuyX4%VfA1};W%W-q^1OO!zS4w;EHdHY+{I~PY-Q@WcEtJyo(l<13+R6 zxHrx`f>}ny$p+~L?yVI&`4AWOK+&Jr!%;yb%yxG-3=R(Ics-uia)Q_dN{^ycdvy+n z{OadpZT_I{nhXF||G#=Wzn7-MFpk$nU@WtdlZAQHvJq_y*&Jy|^owEQxoX3Kk(m8j zn?uWKQF8!46v*vejl#q;;VzWm-5!j;&~0BrJlJoo0QX1M5%dZm^5N z+55cb`+lF#_kEgSD<$?u*OMbQ2_iexxANMgDX2^i%ldVg6@RY)9Ue0~Fj#(0r#>cM z9bedTdPqo3VD=&e!7G?}2x@(`-}=N8TXbxs3K8UTsBdLIQGgVHqm zMDUtcW_dSfA8t&Fkt`*^tf;9Mi@PLXSsw805=x(lo-W^rCqOMb@&KA!#7fL7LFHr; zfCXk(vlbX+ZiQ&Fy@i`^%p0x#Jwe8V*5AQk$2PH_$=&KUcYZ8(O$Uc6lmaeDVhX!P z-JYBzW_C7@P#6Y43DB&~q4sZ-|Yg{mJzT*Uis>Wa3zBALf=y7h+*Tgdp@_jQ| zCv4?H8yAUQ!=%VwBapar`B=uKrTW>6(@UDGT@e zeN#PVG%ajwYuOa9zWJw?JG0E4B~2NF_hL)Jo2d*1#P!7>h}Bgd3B8Nc8115xp}mE_ z5d|t#pdgE+EZM+=;vYaWA4>daMpenMf4B^K!fWMBZ|phk@C3rUpj7J8|DJ(~ggB`w zb&nBPR_e@olKm7k#7o|^2-g8RIZOlqfChW5h68w`jyCxoP&jDema*SLXv46cO+<6N+Y@pIJ!{k>o->p8(9D019q3bW?@QAJe literal 0 HcmV?d00001 diff --git a/examples/similarity_search/similarity_search.ipynb b/examples/similarity_search/similarity_search.ipynb new file mode 100644 index 0000000000..678e68a45b --- /dev/null +++ b/examples/similarity_search/similarity_search.ipynb @@ -0,0 +1,259 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5083d23c-e27f-4d14-a8d2-12e11a6aff42", + "metadata": {}, + "source": [ + "# 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", + "\n", + "\"time" + ] + }, + { + "cell_type": "markdown", + "id": "7e06b213-6038-4901-b98e-2433625115c4", + "metadata": {}, + "source": [ + "## Similarity search Notebooks\n", + "\n", + "This notebook gives an overview of similarity search module and the available estimators. The following notebooks are avaiable to go more in depth with specific subject of similarity search in aeon:\n", + "\n", + "- [Deep dive in distance profiles](distance_profiles.ipynb)" + ] + }, + { + "cell_type": "markdown", + "id": "ca967c08-9a05-411a-a09a-ad8a13c0adb9", + "metadata": {}, + "source": [ + "## Expected inputs and format\n" + ] + }, + { + "cell_type": "markdown", + "id": "d1fd75ae-84c2-40be-95f6-bd7de409317d", + "metadata": {}, + "source": [ + "## Available estimators\n", + "\n", + "All estimators of the similarity search module in aeon inherit from the `BaseSimilaritySearch` class, which requires the following arguments:\n", + "- `distance` : a string indicating which distance function to use as similarity function. By default this is `\"euclidean\"`, which means that the Euclidean distance is used.\n", + "- `normalize` : a boolean indicating whether this similarity function should be z-normalized. This means that the scale of the two series being compared will be ignored, and that, loosely speaking, we will only focus on their shape during the comparison. By default, this parameter is set `False`.\n", + "\n", + "Another parameter, which has no effect on the output of the estimators, is a boolean named `store_distance_profile`, set to `False` by default. If set to `True`, the estimators will expose an attribute named `_distance_profile` after the `predict` function is called. This attribute will contain the computed distance profile for query given as input to the `predict` function.\n", + "\n", + "To illustrate how to work with similarity search estimators in aeon, we will now present some example use cases." + ] + }, + { + "cell_type": "markdown", + "id": "01fa67c2-0126-4152-98a9-fa0df84c4629", + "metadata": {}, + "source": [ + "### Top-K similarity search" + ] + }, + { + "cell_type": "markdown", + "id": "8e99b251-d156-4989-b5a0-3a2c79cb75d4", + "metadata": {}, + "source": [ + "We will the classic GunPoint dataset for this example, which can be loaded using the `load_classification` function." + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "f8a6bb7e-b219-41f1-b508-b849c45672eb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "

" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "\n", + "from aeon.datasets import load_classification\n", + "\n", + "# Load GunPoint dataset\n", + "X, y, _ = load_classification(\"GunPoint\")\n", + "\n", + "classes = np.unique(y)\n", + "\n", + "fig, ax = plt.subplots(figsize=(20, 5), ncols=len(classes))\n", + "for i_class, _class in enumerate(classes):\n", + " for i_x in np.where(y == _class)[0][0:2]:\n", + " ax[i_class].plot(X[i_x, 0], label=f\"sample {i_x}\")\n", + " ax[i_class].legend()\n", + " ax[i_class].set_title(f\"class {_class}\")\n", + "plt.suptitle(\"Example samples for the GunPoint dataset\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "5392f7f4-1825-4b15-9248-27eeecb1af3c", + "metadata": {}, + "source": [ + "The GunPoint dataset is composed of two classes which are discriminated by the \"bumps\" located before and after the central peak. These bumps correspond to an actor drawing a fake gun from a holster before pointing it (hence the name \"GunPoint\" !). In the second class, the actor simply points his fingers.\n", + "\n", + "Suppose that we define our input query for the similarity search task as one of these bumps:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "a494a0be-4459-414d-9fc2-1400feefd171", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "q = X[3, :, 20:55]\n", + "plt.plot(q[0])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "fcf10a34-930a-4fce-86f8-4dfa207cad11", + "metadata": {}, + "source": [ + "Then, we can use the `TopKSimilaritySearch` class to search for the top `k` matches of this query in a collection of series. The training data for `TopKSimilaritySearch` can be seen as the database in which want to search for the query on." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "80eaab8f-204f-439f-84c8-ad3462f1575e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[(195, 26), (92, 23), (154, 22)]\n" + ] + } + ], + "source": [ + "from aeon.similarity_search import TopKSimilaritySearch\n", + "\n", + "# Here, the distance function (distance and normalize arguments)\n", + "top_k_search = TopKSimilaritySearch(k=3, distance=\"euclidean\")\n", + "\n", + "mask = np.ones(X.shape[0], dtype=bool)\n", + "mask[3] = False\n", + "# Use this mask to exluce the sample from which we extracted the query\n", + "X_train = X[mask]\n", + "# Call fit to store X_train as the database to search in\n", + "top_k_search.fit(X_train)\n", + "best_matches = top_k_search.predict(q)\n", + "print(best_matches)" + ] + }, + { + "cell_type": "markdown", + "id": "3dc402cf-80b7-4d0c-b07c-2f8e7822ac97", + "metadata": {}, + "source": [ + "The similarity search estimators return a list of size `k`, which contains a tuple containing the location of the best matches as `(id_sample, id_timestamp)`. We can then plot the results as:" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "23efe48e-8257-4ecc-93a2-d72f19024ab5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(20, 5), ncols=3)\n", + "for i_k, (id_sample, id_timestamp) in enumerate(best_matches):\n", + " # plot the sample of the best match\n", + " ax[i_k].plot(top_k_search._X[id_sample, 0], linewidth=2)\n", + " # plot the location of the best match on it\n", + " ax[i_k].plot(\n", + " range(id_timestamp, id_timestamp + q.shape[1]),\n", + " top_k_search._X[id_sample, 0, id_timestamp : id_timestamp + q.shape[1]],\n", + " linewidth=7,\n", + " alpha=0.5,\n", + " color=\"green\",\n", + " label=\"best match location\",\n", + " )\n", + " # plot the query on the location of the best match\n", + " ax[i_k].plot(\n", + " range(id_timestamp, id_timestamp + q.shape[1]),\n", + " q[0],\n", + " linewidth=5,\n", + " alpha=0.5,\n", + " color=\"red\",\n", + " label=\"query\",\n", + " )\n", + " ax[i_k].set_title(f\"best match {i_k}\")\n", + " ax[i_k].legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8ea887b4-3c04-44e2-a2dc-b71266bec182", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (Spyder)", + "language": "python3", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 810de65d11a5e830cd75dfd7e99df8fb80a82108 Mon Sep 17 00:00:00 2001 From: Antoine Guillaume Date: Fri, 20 Oct 2023 17:40:18 +0200 Subject: [PATCH 22/31] Adding parameters for self matches, typos in example notebook --- aeon/similarity_search/base.py | 40 +++++++++++++++++-- aeon/similarity_search/top_k_similarity.py | 34 +++++++++++----- .../similarity_search/similarity_search.ipynb | 14 ++----- 3 files changed, 63 insertions(+), 25 deletions(-) diff --git a/aeon/similarity_search/base.py b/aeon/similarity_search/base.py index d72bc69e26..8dcc9b1549 100644 --- a/aeon/similarity_search/base.py +++ b/aeon/similarity_search/base.py @@ -3,6 +3,7 @@ __author__ = ["baraline"] from abc import ABC, abstractmethod +from collections import Iterable from typing import final import numpy as np @@ -35,11 +36,16 @@ class BaseSimiliaritySearch(BaseEstimator, ABC): } def __init__( - self, distance="euclidean", normalize=False, store_distance_profile=False + self, + distance="euclidean", + normalize=False, + store_distance_profile=False, + exclusion_factor=2, ): self.distance = distance self.normalize = normalize self.store_distance_profile = store_distance_profile + self.exclusion_factor = exclusion_factor super(BaseSimiliaritySearch, self).__init__() def _get_distance_profile_function(self): @@ -103,7 +109,7 @@ def fit(self, X, y=None): return self @final - def predict(self, q): + def predict(self, q, q_index=None, exclusion_factor=2.0): """ Predict method: Check the shape of q and call _predict to perform the search. @@ -114,11 +120,23 @@ def predict(self, q): ---------- q : array, shape (n_channels, q_length) Input query used for similarity search. + q_index : Iterable, default=None + An Interable (tuple, list, array) used to specify the index of Q if it is + extracted from the input data X given during the fit method. + Given the tuple (id_sample, id_timestamp), the similarity search will define + an exclusion zone around the q_index in order to avoid matching q with + itself. If None, it is considered that the query is not extracted from X. + exclusion_factor : float, default=2. + The factor to apply to the query length to define the exclusion zone. The + exclusion zone is define from id_timestamp - q_length//exclusion_factor to + id_timestamp + q_length//exclusion_factor Raises ------ TypeError If the input q array is not 2D raise an error. + ValueError + If the length of the query is greater Returns ------- @@ -137,7 +155,7 @@ def predict(self, q): if q.shape[-1] >= self._X.shape[-1]: raise ValueError( - "The length of the query q should be shorter than the length of the" + "The length of the query should be inferior or equal to the length of" "data (X) provided during fit, but got {} for q and {} for X".format( q.shape[-1], self._X.shape[-1] ) @@ -151,12 +169,26 @@ def predict(self, q): ) ) + if q_index is not None: + if isinstance(q_index, Iterable) and len(q_index) != 2: + raise ValueError( + "The q_index should contain an interable of size 2 such as" + "(id_sample, id_timestamp), but got an iterable of size {}".format( + len(q_index) + ) + ) + else: + raise TypeError( + "If not None, the q_index parameter should be an iterable, here" + " q_index is of type {}".format(type(q_index)) + ) + if self.normalize: self._q_means = np.mean(q, axis=-1) self._q_stds = np.std(q, axis=-1) self._store_mean_std_from_inputs(q.shape[-1]) - return self._predict(q) + return self._predict(q, q_index=q_index, exclusion_factor=exclusion_factor) @abstractmethod def _fit(self, X, y): diff --git a/aeon/similarity_search/top_k_similarity.py b/aeon/similarity_search/top_k_similarity.py index 5e72e10cbc..d763affafd 100644 --- a/aeon/similarity_search/top_k_similarity.py +++ b/aeon/similarity_search/top_k_similarity.py @@ -2,6 +2,8 @@ __author__ = ["baraline"] +import numpy as np + from aeon.similarity_search.base import BaseSimiliaritySearch @@ -52,7 +54,7 @@ def _fit(self, X, y): """ return self - def _predict(self, q): + def _predict(self, q, q_index=None, exclusion_factor=2): """ Private predict method for TopKSimilaritySearch. @@ -62,11 +64,16 @@ def _predict(self, q): ---------- q : array, shape (n_channels, q_length) Input query used for similarity search. - - Raises - ------ - TypeError - If the input q array is not 2D raise an error. + q_index : tuple, default=None + Tuple used to specify the index of Q if it is extracted from the input data + X given during the fit method. Given the tuple (id_sample, id_timestamp), + the similarity search will define an exclusion zone around the q_index in + order to avoid matching q with itself. If None, it is considered that the + query is not extracted from X. + exclusion_factor : float, default=2. + The factor to apply to the query length to define the exclusion zone. The + exclusion zone is define from id_timestamp - q_length//exclusion_factor to + id_timestamp + q_length//exclusion_factor Returns ------- @@ -80,8 +87,17 @@ def _predict(self, q): ) else: distance_profile = self.distance_profile_function(self._X, q) - # Would creating base distance profile classes be relevant to force the same - # interface for normalized / non normalized distance profiles ? + + if q_index is not None: + q_length = q.shape[1] + i_sample, i_timestamp = q_index + profile_length = distance_profile[i_sample].shape[-1] + exclusion_LB = max(0, i_timestamp - q_length // exclusion_factor) + exclusion_UB = min( + profile_length, i_timestamp + q_length // exclusion_factor + ) + distance_profile[i_sample][exclusion_LB:exclusion_UB] = np.inf + if self.store_distance_profile: self._distance_profile = distance_profile @@ -89,8 +105,6 @@ def _predict(self, q): _argsort = distance_profile.argsort(axis=None)[: self.k] - # return is [(id_sample, id_timestamp)] - # -> candidate is X[id_sample, :, id_timestamps:id_timestamps+q_length] return [ (_argsort[i] // search_size, _argsort[i] % search_size) for i in range(self.k) diff --git a/examples/similarity_search/similarity_search.ipynb b/examples/similarity_search/similarity_search.ipynb index 678e68a45b..690d69e55a 100644 --- a/examples/similarity_search/similarity_search.ipynb +++ b/examples/similarity_search/similarity_search.ipynb @@ -21,7 +21,7 @@ "\n", "This notebook gives an overview of similarity search module and the available estimators. The following notebooks are avaiable to go more in depth with specific subject of similarity search in aeon:\n", "\n", - "- [Deep dive in distance profiles](distance_profiles.ipynb)" + "- TBA" ] }, { @@ -61,7 +61,7 @@ "id": "8e99b251-d156-4989-b5a0-3a2c79cb75d4", "metadata": {}, "source": [ - "We will the classic GunPoint dataset for this example, which can be loaded using the `load_classification` function." + "We will use the GunPoint dataset for this example, which can be loaded using the `load_classification` function." ] }, { @@ -107,7 +107,7 @@ "id": "5392f7f4-1825-4b15-9248-27eeecb1af3c", "metadata": {}, "source": [ - "The GunPoint dataset is composed of two classes which are discriminated by the \"bumps\" located before and after the central peak. These bumps correspond to an actor drawing a fake gun from a holster before pointing it (hence the name \"GunPoint\" !). In the second class, the actor simply points his fingers.\n", + "The GunPoint dataset is composed of two classes which are discriminated by the \"bumps\" located before and after the central peak. These bumps correspond to an actor drawing a fake gun from a holster before pointing it (hence the name \"GunPoint\" !). In the second class, the actor simply points his fingers without making the motion of taking the gun out of the holster.\n", "\n", "Suppose that we define our input query for the similarity search task as one of these bumps:" ] @@ -225,14 +225,6 @@ " ax[i_k].legend()\n", "plt.show()" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8ea887b4-3c04-44e2-a2dc-b71266bec182", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { From 23f29cf932e109a164726503bd6ab2816047d054 Mon Sep 17 00:00:00 2001 From: Antoine Guillaume Date: Fri, 20 Oct 2023 17:46:31 +0200 Subject: [PATCH 23/31] typo in import, replace Q with q --- aeon/similarity_search/base.py | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/aeon/similarity_search/base.py b/aeon/similarity_search/base.py index 8dcc9b1549..3c9b3fa2a8 100644 --- a/aeon/similarity_search/base.py +++ b/aeon/similarity_search/base.py @@ -3,7 +3,7 @@ __author__ = ["baraline"] from abc import ABC, abstractmethod -from collections import Iterable +from collections.abc import Iterable from typing import final import numpy as np @@ -56,15 +56,15 @@ def _get_distance_profile_function(self): ) return dist_profile[self.normalize] - def _store_mean_std_from_inputs(self, Q_length): + def _store_mean_std_from_inputs(self, q_length): n_samples, n_channels, X_length = self._X.shape - search_space_size = X_length - Q_length + 1 + search_space_size = X_length - q_length + 1 means = np.zeros((n_samples, n_channels, search_space_size)) stds = np.zeros((n_samples, n_channels, search_space_size)) for i in range(n_samples): - _mean, _std = sliding_mean_std_one_series(self._X[i], Q_length, 1) + _mean, _std = sliding_mean_std_one_series(self._X[i], q_length, 1) stds[i] = _std means[i] = _mean @@ -153,19 +153,20 @@ def predict(self, q, q_index=None, exclusion_factor=2.0): " do q.reshape(1,-1)." ) - if q.shape[-1] >= self._X.shape[-1]: + q_dim, q_length = q.shape + if q_length >= self._X.shape[-1]: raise ValueError( "The length of the query should be inferior or equal to the length of" "data (X) provided during fit, but got {} for q and {} for X".format( - q.shape[-1], self._X.shape[-1] + q_length, self._X.shape[-1] ) ) - if q.shape[0] != self._X.shape[1]: + if q_dim != self._X.shape[1]: raise ValueError( "The number of feature should be the same for the query q and the data" "(X) provided during fit, but got {} for q and {} for X".format( - q.shape[0], self._X.shape[1] + q_dim, self._X.shape[1] ) ) @@ -186,7 +187,7 @@ def predict(self, q, q_index=None, exclusion_factor=2.0): if self.normalize: self._q_means = np.mean(q, axis=-1) self._q_stds = np.std(q, axis=-1) - self._store_mean_std_from_inputs(q.shape[-1]) + self._store_mean_std_from_inputs(q_length) return self._predict(q, q_index=q_index, exclusion_factor=exclusion_factor) From 787fe10891d984ee9215f9a769c3f3ea1879e3b3 Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Sat, 21 Oct 2023 11:46:48 +0100 Subject: [PATCH 24/31] switch test example for pipeline --- aeon/classification/compose/_pipeline.py | 33 +++---------- aeon/regression/compose/_pipeline.py | 63 ++++++------------------ 2 files changed, 22 insertions(+), 74 deletions(-) diff --git a/aeon/classification/compose/_pipeline.py b/aeon/classification/compose/_pipeline.py index b1d0c5febf..7cfb55c667 100644 --- a/aeon/classification/compose/_pipeline.py +++ b/aeon/classification/compose/_pipeline.py @@ -287,19 +287,12 @@ def get_test_params(cls, parameter_set="default"): """ # imports from aeon.classification import DummyClassifier - from aeon.classification.distance_based import KNeighborsTimeSeriesClassifier - from aeon.transformations.series.exponent import ExponentTransformer + from aeon.transformations.collection.convolution_based import Rocket - t1 = ExponentTransformer(power=2) - t2 = ExponentTransformer(power=0.5) - c = KNeighborsTimeSeriesClassifier() + t = Rocket(num_kernels=200) + cls = DummyClassifier() - another_c = DummyClassifier() - - params1 = {"transformers": [t1, t2], "classifier": c} - params2 = {"transformers": [t1], "classifier": another_c} - - return [params1, params2] + return {"transformers": [t], "classifier": cls} class SklearnClassifierPipeline(_HeterogenousMetaEstimator, BaseClassifier): @@ -594,20 +587,8 @@ def get_test_params(cls, parameter_set="default"): """ from sklearn.neighbors import KNeighborsClassifier - from aeon.transformations.series.exponent import ExponentTransformer - from aeon.transformations.series.summarize import SummaryTransformer + from aeon.transformations.collection.convolution_based import Rocket - # example with series-to-series transformer before sklearn classifier - t1 = ExponentTransformer(power=2) - t2 = ExponentTransformer(power=0.5) + t1 = Rocket(num_kernels=200) c = KNeighborsClassifier() - params1 = {"transformers": [t1, t2], "classifier": c} - - # example with series-to-primitive transformer before sklearn classifier - t1 = ExponentTransformer(power=2) - t2 = SummaryTransformer() - c = KNeighborsClassifier() - params2 = {"transformers": [t1, t2], "classifier": c} - - # construct without names - return [params1, params2] + return {"transformers": [t1], "classifier": c} diff --git a/aeon/regression/compose/_pipeline.py b/aeon/regression/compose/_pipeline.py index f481c1601b..89c053508a 100644 --- a/aeon/regression/compose/_pipeline.py +++ b/aeon/regression/compose/_pipeline.py @@ -68,21 +68,19 @@ class RegressorPipeline(_HeterogenousMetaEstimator, BaseRegressor): Examples -------- - >>> from aeon.transformations.collection.interpolate import TSInterpolator + >>> from aeon.transformations.collection.convolution_based import Rocket >>> from aeon.datasets import load_covid_3month >>> from aeon.regression.compose import RegressorPipeline >>> from aeon.regression.distance_based import KNeighborsTimeSeriesRegressor >>> X_train, y_train = load_covid_3month(split="train") >>> X_test, y_test = load_covid_3month(split="test") >>> pipeline = RegressorPipeline( - ... KNeighborsTimeSeriesRegressor(n_neighbors=2), [TSInterpolator(length=10)] + ... KNeighborsTimeSeriesRegressor(n_neighbors=2), [Rocket(num_kernels=100)] ... ) >>> pipeline.fit(X_train, y_train) - RegressorPipeline(...) + RegressorPipeline(regressor=KNeighborsTimeSeriesRegressor(n_neighbors=2), + transformers=[Rocket(num_kernels=100)]) >>> y_pred = pipeline.predict(X_test) - - Alternative construction via dunder method: - >>> pipeline = TSInterpolator(length=10) * KNeighborsTimeSeriesRegressor(n_neighbors=2) # noqa: E501 """ _tags = { @@ -276,26 +274,12 @@ def get_test_params(cls, parameter_set="default"): `MyClass(**params)` or `MyClass(**params[i])` creates a valid test instance. `create_test_instance` uses the first (or only) dictionary in `params`. """ - from aeon.transformations.series.exponent import ExponentTransformer - from aeon.utils.validation._dependencies import _check_soft_dependencies - - t1 = ExponentTransformer(power=2) - t2 = ExponentTransformer(power=0.5) - - r = SklearnRegressorPipeline.create_test_instance() + from aeon.regression import DummyRegressor + from aeon.transformations.collection.convolution_based import Rocket - params1 = {"transformers": [t1, t2], "regressor": r} - - if _check_soft_dependencies("numba", severity="none"): - from aeon.regression.distance_based import KNeighborsTimeSeriesRegressor - - c = KNeighborsTimeSeriesRegressor() - - # construct without names - params2 = {"transformers": [t1, t2], "regressor": c} - return [params1, params2] - else: - return params1 + t1 = Rocket(num_kernels=200) + c = DummyRegressor() + return {"transformers": [t1], "classifier": c} class SklearnRegressorPipeline(_HeterogenousMetaEstimator, BaseRegressor): @@ -362,18 +346,13 @@ class SklearnRegressorPipeline(_HeterogenousMetaEstimator, BaseRegressor): >>> from sklearn.neighbors import KNeighborsRegressor >>> from aeon.datasets import load_covid_3month >>> from aeon.regression.compose import SklearnRegressorPipeline - >>> from aeon.transformations.series.exponent import ExponentTransformer - >>> from aeon.transformations.series.summarize import SummaryTransformer + >>> from aeon.transformations.collection.convolution_based import Rocket >>> X_train, y_train = load_covid_3month(split="train") >>> X_test, y_test = load_covid_3month(split="test") - >>> t1 = ExponentTransformer() - >>> t2 = SummaryTransformer() - >>> pipeline = SklearnRegressorPipeline(KNeighborsRegressor(), [t1, t2]) + >>> t1 = Rocket(num_kernels=200) + >>> pipeline = SklearnRegressorPipeline(KNeighborsRegressor(), [t1]) >>> pipeline = pipeline.fit(X_train, y_train) >>> y_pred = pipeline.predict(X_test) - - Alternative construction via dunder method: - >>> pipeline = t1 * t2 * KNeighborsRegressor() """ _tags = { @@ -581,20 +560,8 @@ def get_test_params(cls, parameter_set="default"): """ from sklearn.neighbors import KNeighborsRegressor - from aeon.transformations.series.exponent import ExponentTransformer - from aeon.transformations.series.summarize import SummaryTransformer + from aeon.transformations.collection.convolution_based import Rocket - # example with series-to-series transformer before sklearn regressor - t1 = ExponentTransformer(power=2) - t2 = ExponentTransformer(power=0.5) + t1 = Rocket(num_kernels=200) c = KNeighborsRegressor() - params1 = {"transformers": [t1, t2], "regressor": c} - - # example with series-to-primitive transformer before sklearn regressor - t1 = ExponentTransformer(power=2) - t2 = SummaryTransformer() - c = KNeighborsRegressor() - params2 = {"transformers": [t1, t2], "regressor": c} - - # construct without names - return [params1, params2] + return {"transformers": [t1], "classifier": c} From 174fff5a9cadb1e604a44e60b3488f8f0fc2cb3e Mon Sep 17 00:00:00 2001 From: Tony Bagnall Date: Sat, 21 Oct 2023 11:57:01 +0100 Subject: [PATCH 25/31] switch test example for pipeline --- aeon/regression/compose/_pipeline.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/aeon/regression/compose/_pipeline.py b/aeon/regression/compose/_pipeline.py index 89c053508a..845d687b9f 100644 --- a/aeon/regression/compose/_pipeline.py +++ b/aeon/regression/compose/_pipeline.py @@ -439,6 +439,12 @@ def __rmul__(self, other): def _convert_X_to_sklearn(self, X): """Convert a Table or Panel X to 2D numpy required by sklearn.""" + if isinstance(X, np.ndarray): + if X.ndim == 2: + return X + elif X.ndim == 3: + return np.reshape(X, (X.shape[0], X.shape[1] * X.shape[2])) + output_type = self.transformers_.get_tag("output_data_type") # if output_type is Primitives, output is Table, convert to 2D numpy array if output_type == "Primitives": From 2c66919bcd332a0e7dd4c9f5611c8347b0230170 Mon Sep 17 00:00:00 2001 From: Antoine Guillaume Date: Sat, 21 Oct 2023 23:57:14 +0200 Subject: [PATCH 26/31] Add mask to distance profile, move exclusion zoneto base class, some numpy docs --- aeon/similarity_search/base.py | 39 ++++++---- .../distance_profiles/_commons.py | 72 ++++++++++++++++--- .../distance_profiles/naive_euclidean.py | 30 ++++---- .../normalized_naive_euclidean.py | 50 ++++++++----- aeon/similarity_search/slow_search.py | 25 ------- .../tests/test_top_k_similarity.py | 11 +++ aeon/similarity_search/top_k_similarity.py | 41 ++++------- 7 files changed, 161 insertions(+), 107 deletions(-) delete mode 100644 aeon/similarity_search/slow_search.py diff --git a/aeon/similarity_search/base.py b/aeon/similarity_search/base.py index 3c9b3fa2a8..bb14e76ce0 100644 --- a/aeon/similarity_search/base.py +++ b/aeon/similarity_search/base.py @@ -57,13 +57,13 @@ def _get_distance_profile_function(self): return dist_profile[self.normalize] def _store_mean_std_from_inputs(self, q_length): - n_samples, n_channels, X_length = self._X.shape + n_instances, n_channels, X_length = self._X.shape search_space_size = X_length - q_length + 1 - means = np.zeros((n_samples, n_channels, search_space_size)) - stds = np.zeros((n_samples, n_channels, search_space_size)) + means = np.zeros((n_instances, n_channels, search_space_size)) + stds = np.zeros((n_instances, n_channels, search_space_size)) - for i in range(n_samples): + for i in range(n_instances): _mean, _std = sliding_mean_std_one_series(self._X[i], q_length, 1) stds[i] = _std means[i] = _mean @@ -78,7 +78,7 @@ def fit(self, X, y=None): Parameters ---------- - X : array, shape (n_cases, n_channels, n_timestamps) + X : array, shape (n_instances, n_channels, n_timestamps) Input array to used as database for the similarity search y : optional Not used. @@ -93,12 +93,12 @@ def fit(self, X, y=None): self """ - # For now force (n_samples, n_channels, n_timestamps), we could convert 2D + # For now force (n_instances, n_channels, n_timestamps), we could convert 2D # (n_channels, n_timestamps) to 3D with a warning if not isinstance(X, np.ndarray) or X.ndim != 3: raise TypeError( "Error, only supports 3D numpy of shape" - "(n_samples, n_channels, n_timestamps)." + "(n_instances, n_channels, n_timestamps)." ) # Get distance function @@ -170,26 +170,37 @@ def predict(self, q, q_index=None, exclusion_factor=2.0): ) ) + n_instances, _, n_timestamps = self._X.shape + mask = np.ones((n_instances, q_dim, n_timestamps), dtype=bool) + if q_index is not None: - if isinstance(q_index, Iterable) and len(q_index) != 2: - raise ValueError( - "The q_index should contain an interable of size 2 such as" - "(id_sample, id_timestamp), but got an iterable of size {}".format( - len(q_index) + if isinstance(q_index, Iterable): + if len(q_index) != 2: + raise ValueError( + "The q_index should contain an interable of size 2 such as" + "(id_sample, id_timestamp), but got an iterable of" + "size {}".format(len(q_index)) ) - ) else: raise TypeError( "If not None, the q_index parameter should be an iterable, here" " q_index is of type {}".format(type(q_index)) ) + i_instance, i_timestamp = q_index + profile_length = n_timestamps - (q_length - 1) + exclusion_LB = max(0, int(i_timestamp - q_length // exclusion_factor)) + exclusion_UB = min( + profile_length, int(i_timestamp + q_length // exclusion_factor) + ) + mask[i_instance, :, exclusion_LB:exclusion_UB] = False + if self.normalize: self._q_means = np.mean(q, axis=-1) self._q_stds = np.std(q, axis=-1) self._store_mean_std_from_inputs(q_length) - return self._predict(q, q_index=q_index, exclusion_factor=exclusion_factor) + return self._predict(q, mask) @abstractmethod def _fit(self, X, y): diff --git a/aeon/similarity_search/distance_profiles/_commons.py b/aeon/similarity_search/distance_profiles/_commons.py index bb8428f7b2..7d50f0d95d 100644 --- a/aeon/similarity_search/distance_profiles/_commons.py +++ b/aeon/similarity_search/distance_profiles/_commons.py @@ -1,7 +1,8 @@ """Helper and common function for similarity search distance profiles.""" - +import numpy as np from numba import njit +from scipy.signal import convolve AEON_SIMSEARCH_STD_THRESHOLD = 1e-7 @@ -13,14 +14,14 @@ def _get_input_sizes(X, q): Parameters ---------- - X : array, shape (n_samples, n_channels, series_length) + X : array, shape (n_instances, n_channels, series_length) The input samples. q : array, shape (n_channels, series_length) The input query Returns ------- - n_cases : int + n_instances : int Number of samples in X. n_channels : int Number of channels in X. @@ -28,14 +29,14 @@ def _get_input_sizes(X, q): Number of timestamps in X. q_length : int Number of timestamps in q - search_space_size : int + profile_size : int Size of the search space for similarity search for each sample in X """ - n_cases, n_channels, X_length = X.shape + n_instances, n_channels, X_length = X.shape q_length = q.shape[-1] - search_space_size = X_length - q_length + 1 - return (n_cases, n_channels, X_length, q_length, search_space_size) + profile_size = X_length - q_length + 1 + return (n_instances, n_channels, X_length, q_length, profile_size) @njit(fastmath=True, cache=True) @@ -48,9 +49,9 @@ def _z_normalize_2D_series_with_mean_std(X, mean, std, copy=True): X : array, shape = (n_channels, n_timestamps) Input array to normalize. mean : array, shape = (n_channels) - Mean of each channel. + Mean of each channel of X. std : array, shape = (n_channels) - Std of each channel. + Std of each channel of X. copy : bool, optional Wheter to copy the input X to avoid modifying the values of the array it refers to (if it is a reference). The default is True. @@ -65,3 +66,56 @@ def _z_normalize_2D_series_with_mean_std(X, mean, std, copy=True): for i_channel in range(X.shape[0]): X[i_channel] = (X[i_channel] - mean[i_channel]) / std[i_channel] return X + + +@njit(fastmath=True, cache=True) +def _z_normalize_1D_series_with_mean_std(X, mean, std, copy=True): + """ + Z-normalize a 2D series given the mean and std of each channel. + + Parameters + ---------- + X : array, shape = (n_timestamps) + Input array to normalize. + mean : float + Mean of X. + std : float + Std of X. + copy : bool, optional + Wheter to copy the input X to avoid modifying the values of the array it refers + to (if it is a reference). The default is True. + + Returns + ------- + X : array, shape = (n_channels, n_timestamps) + The normalized array + """ + if copy: + X = X.copy() + X = (X - mean) / std + return X + + +def fft_sliding_dot_product(X, q): + """ + Use FFT convolution to calculate the sliding window dot product. + + Parameters + ---------- + X : array, shape=(n_features, n_timestamps) + Input time series + + q : array, shape=(n_features, q_length) + Input query + + Returns + ------- + output : shape=(n_features, n_timestamps - (length - 1)) + Sliding dot product between q and X. + """ + n_features, n_timestamps = X.shape[0] + length = q.shape[1] + out = np.zeros((n_features, n_timestamps - (length - 1))) + for i in range(n_features): + out[i, :] = convolve(np.flipud(q[i, :]), X[i, :], mode="valid").real + return out diff --git a/aeon/similarity_search/distance_profiles/naive_euclidean.py b/aeon/similarity_search/distance_profiles/naive_euclidean.py index 365f73ffa4..75fb335519 100644 --- a/aeon/similarity_search/distance_profiles/naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/naive_euclidean.py @@ -9,7 +9,7 @@ from aeon.similarity_search.distance_profiles._commons import _get_input_sizes -def naive_euclidean_profile(X, q): +def naive_euclidean_profile(X, q, mask): r""" Compute a euclidean distance profile in a brute force way. @@ -37,21 +37,23 @@ def naive_euclidean_profile(X, q): The distance profile between q and the input time series X. """ - return _naive_euclidean_profile(X, q) + return _naive_euclidean_profile(X, q, mask) @njit(cache=True, fastmath=True) -def _naive_euclidean_profile(X, q): - n_samples, n_channels, X_length, q_length, search_space_size = _get_input_sizes( - X, q - ) - distance_profile = np.full((n_samples, search_space_size), np.inf) - - # Compute euclidean distance for all candidate in a "brute force" way - for i_sample in range(n_samples): - for i_candidate in range(search_space_size): - distance_profile[i_sample, i_candidate] = euclidean_distance( - q, X[i_sample, :, i_candidate : i_candidate + q_length] - ) +def _naive_euclidean_profile(X, q, mask): + n_instances, n_channels, X_length, q_length, profile_size = _get_input_sizes(X, q) + distance_profile = np.full((n_instances, n_channels, profile_size), np.inf) + + for i_instance in range(n_instances): + for i_channel in range(n_channels): + for i_candidate in range(profile_size): + if mask[i_instance, i_channel, i_candidate]: + distance_profile[ + i_instance, i_channel, i_candidate + ] = euclidean_distance( + q[i_channel], + X[i_instance, i_channel, i_candidate : i_candidate + q_length], + ) return distance_profile diff --git a/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py b/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py index 244da14182..7ec2790a33 100644 --- a/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py @@ -9,11 +9,12 @@ from aeon.similarity_search.distance_profiles._commons import ( AEON_SIMSEARCH_STD_THRESHOLD, _get_input_sizes, + _z_normalize_1D_series_with_mean_std, _z_normalize_2D_series_with_mean_std, ) -def normalized_naive_euclidean_profile(X, q, X_means, X_stds, q_means, q_stds): +def normalized_naive_euclidean_profile(X, q, mask, X_means, X_stds, q_means, q_stds): """ Compute a euclidean distance profile in a brute force way. @@ -29,11 +30,18 @@ def normalized_naive_euclidean_profile(X, q, X_means, X_stds, q_means, q_stds): Parameters ---------- - X: array shape (n_instances, n_channels, series_length) + X : array, shape (n_instances, n_channels, series_length) The input samples. - - q : np.ndarray shape (n_channels, query_length) + q : array, shape (n_channels, query_length) The query used for similarity search. + X_means : array, shape (n_instances, n_channels, series_length - (query_length-1)) + Means of each subsequences of X of size query_length + X_stds : array, shape (n_instances, n_channels, series_length - (query_length-1)) + Stds of each subsequences of X of size query_length + q_means : array, shape (n_channels) + Means of the query q + q_stds : array, shape (n_channels) + Stds of the query q Returns ------- @@ -45,25 +53,29 @@ def normalized_naive_euclidean_profile(X, q, X_means, X_stds, q_means, q_stds): q_stds[q_stds < AEON_SIMSEARCH_STD_THRESHOLD] = 1 X_stds[X_stds < AEON_SIMSEARCH_STD_THRESHOLD] = 1 - return _normalized_naive_euclidean_profile(X, q, X_means, X_stds, q_means, q_stds) + return _normalized_naive_euclidean_profile( + X, q, mask, X_means, X_stds, q_means, q_stds + ) @njit(cache=True, fastmath=True) -def _normalized_naive_euclidean_profile(X, q, X_means, X_stds, q_means, q_stds): - n_samples, n_channels, X_length, q_length, search_space_size = _get_input_sizes( - X, q - ) +def _normalized_naive_euclidean_profile(X, q, mask, X_means, X_stds, q_means, q_stds): + n_instances, n_channels, X_length, q_length, profile_size = _get_input_sizes(X, q) q = _z_normalize_2D_series_with_mean_std(q, q_means, q_stds) - distance_profile = np.full((n_samples, search_space_size), np.inf) + distance_profile = np.full((n_instances, n_channels, profile_size), np.inf) # Compute euclidean distance for all candidate in a "brute force" way - for i_sample in range(n_samples): - for i_candidate in range(search_space_size): - # Extract and normalize the candidate - _C = X[i_sample, :, i_candidate : i_candidate + q_length] - - _C = _z_normalize_2D_series_with_mean_std( - _C, X_means[i_sample, :, i_candidate], X_stds[i_sample, :, i_candidate] - ) - distance_profile[i_sample, i_candidate] = euclidean_distance(q, _C) + for i_instance in range(n_instances): + for i_channel in range(n_channels): + for i_candidate in range(profile_size): + if mask[i_instance, i_channel, i_candidate]: + # Extract and normalize the candidate + _C = _z_normalize_1D_series_with_mean_std( + X[i_instance, i_channel, i_candidate : i_candidate + q_length], + X_means[i_instance, i_channel, i_candidate], + X_stds[i_instance, i_channel, i_candidate], + ) + distance_profile[ + i_instance, i_channel, i_candidate + ] = euclidean_distance(q[i_channel], _C) return distance_profile diff --git a/aeon/similarity_search/slow_search.py b/aeon/similarity_search/slow_search.py deleted file mode 100644 index 47f314f870..0000000000 --- a/aeon/similarity_search/slow_search.py +++ /dev/null @@ -1,25 +0,0 @@ -"""Basic similarity search to demonstrate the basic use case.""" -import numpy as np - -from aeon.similarity_search.base import BaseSimiliaritySearch - - -class SlowSearch(BaseSimiliaritySearch): - """Slow similarity search.""" - - def __init__(self): - super(SlowSearch, self).__init__() - - def _fit(self, X, y): - return self - - def _predict(self, q): - index = 0 - min_d = np.Inf - l2 = len(q) - for i in range(0, len(self._X) - l2 - 1): - d = self.distance_function(q, self._X[i : i + l2 - 1]) - if d < min_d: - index = i - min_d = d - return [index] diff --git a/aeon/similarity_search/tests/test_top_k_similarity.py b/aeon/similarity_search/tests/test_top_k_similarity.py index 1dc03e6870..fdbeda4b94 100644 --- a/aeon/similarity_search/tests/test_top_k_similarity.py +++ b/aeon/similarity_search/tests/test_top_k_similarity.py @@ -30,3 +30,14 @@ def test_TopKSimilaritySearch(dtype): search.fit(X) idx = search.predict(q) assert_array_equal(idx, [(0, 2), (1, 2), (1, 1)]) + + search = TopKSimilaritySearch(k=1, normalize=True) + search.fit(X) + q = np.asarray([[8, 8, 10]], dtype=dtype) + idx = search.predict(q) + assert_array_equal(idx, [(1, 2)]) + + search = TopKSimilaritySearch(k=1, normalize=True) + search.fit(X) + idx = search.predict(q, q_index=(1, 2)) + assert_array_equal(idx, [(1, 0)]) diff --git a/aeon/similarity_search/top_k_similarity.py b/aeon/similarity_search/top_k_similarity.py index d763affafd..ac396f9c35 100644 --- a/aeon/similarity_search/top_k_similarity.py +++ b/aeon/similarity_search/top_k_similarity.py @@ -2,8 +2,6 @@ __author__ = ["baraline"] -import numpy as np - from aeon.similarity_search.base import BaseSimiliaritySearch @@ -54,7 +52,7 @@ def _fit(self, X, y): """ return self - def _predict(self, q, q_index=None, exclusion_factor=2): + def _predict(self, q, mask): """ Private predict method for TopKSimilaritySearch. @@ -64,16 +62,9 @@ def _predict(self, q, q_index=None, exclusion_factor=2): ---------- q : array, shape (n_channels, q_length) Input query used for similarity search. - q_index : tuple, default=None - Tuple used to specify the index of Q if it is extracted from the input data - X given during the fit method. Given the tuple (id_sample, id_timestamp), - the similarity search will define an exclusion zone around the q_index in - order to avoid matching q with itself. If None, it is considered that the - query is not extracted from X. - exclusion_factor : float, default=2. - The factor to apply to the query length to define the exclusion zone. The - exclusion zone is define from id_timestamp - q_length//exclusion_factor to - id_timestamp + q_length//exclusion_factor + mask : array, shape (n_samples, n_channels, n_timestamps - (q_length - 1)) + Boolean mask of the shape of the distance profile indicating for which part + of it the distance should be computed. Returns ------- @@ -83,26 +74,24 @@ def _predict(self, q, q_index=None, exclusion_factor=2): """ if self.normalize: distance_profile = self.distance_profile_function( - self._X, q, self._X_means, self._X_stds, self._q_means, self._q_stds + self._X, + q, + mask, + self._X_means, + self._X_stds, + self._q_means, + self._q_stds, ) else: - distance_profile = self.distance_profile_function(self._X, q) - - if q_index is not None: - q_length = q.shape[1] - i_sample, i_timestamp = q_index - profile_length = distance_profile[i_sample].shape[-1] - exclusion_LB = max(0, i_timestamp - q_length // exclusion_factor) - exclusion_UB = min( - profile_length, i_timestamp + q_length // exclusion_factor - ) - distance_profile[i_sample][exclusion_LB:exclusion_UB] = np.inf + distance_profile = self.distance_profile_function(self._X, q, mask) if self.store_distance_profile: self._distance_profile = distance_profile - search_size = distance_profile.shape[-1] + # For now, deal with the multidimensional case as "fully dependent" + distance_profile = distance_profile.sum(axis=1) + search_size = distance_profile.shape[-1] _argsort = distance_profile.argsort(axis=None)[: self.k] return [ From b310735be8bd711646d63fa39577eacacc2b989f Mon Sep 17 00:00:00 2001 From: Antoine Guillaume Date: Sun, 22 Oct 2023 13:04:35 +0200 Subject: [PATCH 27/31] Add distance profile and speedups notebooks, exclusion factor value check, some utils functions --- aeon/similarity_search/base.py | 13 +- .../distance_profiles/_commons.py | 24 +++ examples/similarity_search/code_speed.ipynb | 177 ++++++++++++++++++ .../similarity_search/distance_profiles.ipynb | 24 ++- .../similarity_search/similarity_search.ipynb | 3 +- 5 files changed, 231 insertions(+), 10 deletions(-) create mode 100644 examples/similarity_search/code_speed.ipynb diff --git a/aeon/similarity_search/base.py b/aeon/similarity_search/base.py index bb14e76ce0..3ba4d99828 100644 --- a/aeon/similarity_search/base.py +++ b/aeon/similarity_search/base.py @@ -36,16 +36,11 @@ class BaseSimiliaritySearch(BaseEstimator, ABC): } def __init__( - self, - distance="euclidean", - normalize=False, - store_distance_profile=False, - exclusion_factor=2, + self, distance="euclidean", normalize=False, store_distance_profile=False ): self.distance = distance self.normalize = normalize self.store_distance_profile = store_distance_profile - self.exclusion_factor = exclusion_factor super(BaseSimiliaritySearch, self).__init__() def _get_distance_profile_function(self): @@ -187,6 +182,12 @@ def predict(self, q, q_index=None, exclusion_factor=2.0): " q_index is of type {}".format(type(q_index)) ) + if exclusion_factor <= 0: + raise ValueError( + "The value of exclusion_factor should be superior to 0, but got" + "{}".format(len(exclusion_factor)) + ) + i_instance, i_timestamp = q_index profile_length = n_timestamps - (q_length - 1) exclusion_LB = max(0, int(i_timestamp - q_length // exclusion_factor)) diff --git a/aeon/similarity_search/distance_profiles/_commons.py b/aeon/similarity_search/distance_profiles/_commons.py index 7d50f0d95d..660ea8dbf5 100644 --- a/aeon/similarity_search/distance_profiles/_commons.py +++ b/aeon/similarity_search/distance_profiles/_commons.py @@ -119,3 +119,27 @@ def fft_sliding_dot_product(X, q): for i in range(n_features): out[i, :] = convolve(np.flipud(q[i, :]), X[i, :], mode="valid").real return out + + +def rolling_window_stride_trick(X, window): + """ + Use strides to generate rolling/sliding windows for a numpy array. + + Parameters + ---------- + X : numpy.ndarray + numpy array + + window : int + Size of the rolling window + + Returns + ------- + output : numpy.ndarray + This will be a new view of the original input array. + """ + a = np.asarray(X) + shape = a.shape[:-1] + (a.shape[-1] - window + 1, window) + strides = a.strides + (a.strides[-1],) + + return np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides) diff --git a/examples/similarity_search/code_speed.ipynb b/examples/similarity_search/code_speed.ipynb new file mode 100644 index 0000000000..de3df5c860 --- /dev/null +++ b/examples/similarity_search/code_speed.ipynb @@ -0,0 +1,177 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "599bd2b3-ed7b-42b4-b886-991e9a05688c", + "metadata": {}, + "source": [ + "# Analysis of the speedups provided by similarity search module" + ] + }, + { + "cell_type": "markdown", + "id": "5a57d08d-a74a-453a-a17c-4e359d5f88ee", + "metadata": {}, + "source": [ + "In this notebook, we will explore the gains in time and memory of the different methods we use in the similarity search module." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "38d4fd81-15e4-4139-a761-6ba7005d352e", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "from matplotlib import pyplot as plt\n", + "\n", + "from aeon.similarity_search.distance_profiles._commons import (\n", + " rolling_window_stride_trick,\n", + ")\n", + "from aeon.utils.numba.general import sliding_mean_std_one_series\n", + "\n", + "sns.set()\n", + "sns.set_context()" + ] + }, + { + "cell_type": "markdown", + "id": "a40f071d-0672-4242-9c8c-e8d4a62c7a4d", + "metadata": {}, + "source": [ + "## Computing means and standard deviations for all subsequences" + ] + }, + { + "cell_type": "markdown", + "id": "a55ec2d8-e8e5-4ca6-8792-16cd93a2c705", + "metadata": {}, + "source": [ + "When we want to compute a normalized distance, given a time series `X` of size `m` and a query `q` of size `l`, we have to compute the mean and standard deviation for all subsequences of size `l` in `X`. One could do this task by doing the following:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e2b76314-ccf4-4c6d-96bc-0b1cb3c97f6b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 91)\n" + ] + } + ], + "source": [ + "def get_means_stds(X, q_length):\n", + " windows = rolling_window_stride_trick(X, q_length)\n", + " return windows.mean(axis=-1), windows.std(axis=-1)\n", + "\n", + "\n", + "rng = np.random.default_rng()\n", + "size = 100\n", + "q_length = 10\n", + "\n", + "# Create a random series with 1 feature and 'size' timesteps\n", + "X = rng.random((1, size))\n", + "means, stds = get_means_stds(X, q_length)\n", + "print(means.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "98e7aa71-65e6-4975-bea0-2188368eed9a", + "metadata": {}, + "source": [ + "One issue with this code is that it actually recompute a lot of information between the computation of mean and std of each windows. Suppose that the window we compute the mean for `W_i = {x_i, ..., x_{i+(l-1)}`, to do this, we sum all the elements and divide them by `l`. You then want to compute the mean for `W_{i+1} = {x_{i+1}, ..., x_{i+1+(l-1)}`, which shares most of its values with `W_i` expect for `x_i` and `x_{i+1+(l-1)`. \n", + "\n", + "The optimization here consists in keeping a rolling sum, we only compute the full sum of the `l` values for the first window `W_0`, then to obtain the sum for `W_1`, we remove `x_0` and add `x_{1+(l-1)}` from the sum of `W_0`. We can also a rolling squared sum to compute the standard deviation.\n", + "\n", + "The `sliding_mean_std_one_series` function implement the computation of the means and standard deviations using these two rolling sums. The last argument indicates the dilation to apply to the subsequence, which is not used here, hence the value of 1 in the code bellow." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5c48986d-dca0-44f2-9d7a-a67fc32731e9", + "metadata": {}, + "outputs": [], + "source": [ + "sizes = [500, 1000, 5000, 10000, 50000]\n", + "q_lengths = [50, 100, 250, 500]\n", + "times = pd.DataFrame(\n", + " index=pd.MultiIndex(levels=[[], []], codes=[[], []], names=[\"size\", \"q_length\"])\n", + ")\n", + "# A first run for numba compilations if needed\n", + "sliding_mean_std_one_series(rng.random((1, 50)), 10, 1)\n", + "for size in sizes:\n", + " for q_length in q_lengths:\n", + " X = rng.random((1, size))\n", + " _times = %timeit -r 7 -n 10 -q -o get_means_stds(X, q_length)\n", + " times.loc[(size, q_length), \"full computation\"] = _times.average\n", + " _times = %timeit -r 7 -n 10 -q -o sliding_mean_std_one_series(X, q_length, 1)\n", + " times.loc[(size, q_length), \"sliding_computation\"] = _times.average" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "01e14732-7675-463f-a4ed-2f903d12142f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAADOAAAAOlCAYAAAB+SnlkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAB7CAAAewgFu0HU+AAEAAElEQVR4nOzdZ2BUxcLG8Wc3PUAINfQWeu9NECmKIghSBRWxIyoK3mvDLliuDRFQEOUqXOlFQJp0CL0EkBY6JEACpJFedt8PebPskmSTQMIm2f/vCydz5syZsych+2TPzBjMZrNZAAAAAAAAAAAAAAAAAAAAAAAAADJldHQHAAAAAAAAAAAAAAAAAAAAAAAAgIKMATgAAAAAAAAAAAAAAAAAAAAAAACAHQzAAQAAAAAAAAAAAAAAAAAAAAAAAOxgAA4AAAAAAAAAAAAAAAAAAAAAAABgBwNwAAAAAAAAAAAAAAAAAAAAAAAAADsYgAMAAAAAAAAAAAAAAAAAAAAAAADYwQAcAAAAAAAAAAAAAAAAAAAAAAAAwA4G4AAAAAAAAAAAAAAAAAAAAAAAAAB2MAAHAAAAAAAAAAAAAAAAAAAAAAAAsIMBOAAAAAAAAAAAAAAAAAAAAAAAAIAdDMABAAAAAAAAAAAAAAAAAAAAAAAA7GAADgAAAAAAAAAAAAAAAAAAAAAAAGAHA3AAAAAAAAAAAAAAAAAAAAAAAAAAOxiAAwAAAAAAAAAAAAAAAAAAAAAAANjBABwAAAAAAAAAAAAAAAAAAAAAAADADgbgAAAAAAAAAAAAAAAAAAAAAAAAAHYwAAcAAAAAAAAAAAAAAAAAAAAAAACwgwE4AAAAAAAAAAAAAAAAAAAAAAAAgB0MwAEAAA6XnJzs6C4AAAAAcAJkDwAAAAAFCRkFAAAAQEFCRgGA7Lk6ugMAADirXbt2afjw4ZKkRx99VF988YWDe3T3RUZG6quvvlKbNm3Ur1+/DPuffPJJ7d69W5K0fv16ValSJd/7lJKSohYtWigpKSnHx5w4ccLu/nXr1mnRokU6fPiwIiMj5ePjo2rVqunBBx/UwIEDVbx48TvtNgAAAJAlskfBzB5ZSUxMVK9evRQcHKzff/9d7dq1y9FxqampWrZsmVasWKEjR44oJiZGvr6+8vf3V+/evdW3b1+5u7vnqK3Q0FDNnj1bW7Zs0YULF2QymeTn56dWrVpp0KBBatmy5Z1cIgAAAJwcGaVgZ5Tt27frzz//VGBgoMLCwpScnCxfX181aNBAPXr00KOPPppttpgyZYomTZqU43O+8sorevXVV7PcT0YBAABAfiKjFMyMUpCf4YqKitKcOXO0fv16nTlzRklJSSpXrpyaNGmi/v37q0uXLjnuM4DChwE4AADAIXbs2KGxY8cqPDxcrVq1cnR3LE6dOpWr4GZPbGysxowZo82bN9uUX79+XdevX9eBAwf0+++/69tvv1Xz5s3z5JwAAAAAbBXU7JGV8ePHKzg4OFfHXLt2TS+99JIOHTpkU3716lVdvXpVO3fu1KxZs/T999+rZs2adttat26d3nrrLcXExNiUnz9/XufPn9fixYs1bNgwvffee3JxcclVPwEAAAAU3IwSHh6uf//739q2bVuGfenZYsuWLZo2bZomTZqkxo0bZ9nWsWPH8qxfZBQAAAAgfxXUjFJQn+Hav3+/Ro8eratXr9qUh4SEKCQkRKtXr1bPnj31+eefq1ixYnnSfwAFCwNwAACAQ+zdu1fh4eGO7kYG1h8K9ezZU82aNbutdkwmk1555RVt375dkuTp6an7779ftWrVUnh4uNasWaOwsDCFhITohRde0Lx587J9EA4AAABA7hXU7JGZyZMna/78+bk6Jj4+Xk8//bSCgoIkST4+PurZs6cqV66sS5cuac2aNYqKitKJEyf07LPPauHChSpdunSmbe3YsUOjR49WamqqJKlu3bq677775OHhocDAQG3btk1ms1l//PGHJOnDDz+8g6sFAAAAnFNBzCixsbF65plnLJ+RuLi4qHPnzmrUqJFcXV115swZrV+/XnFxcQoJCdFTTz2lOXPmqG7dupm2d/ToUUlS8eLFNWrUqGzP36JFi0zLySgAAABA/iuIGUUqmM9wnTp1Ss8++6zi4uIkSVWrVlWPHj1UokQJnThxQhs2bFBycrLWrFmjpKQkTZ06VUaj8bb6DaDgYgAOAACAlSNHjli2n3jiCbVt2/a22vnjjz8swa1y5cr69ddfVaNGDcv+sWPH6u2337Y8DPf+++9r9uzZd9R3AAAAAIVTUlKSJkyYoLlz5+b62EmTJlkG3zRq1EjTpk1TuXLlLPvHjBmjV155Rfv27VNISIi++OIL/ec//8nQTkJCgt555x3Lg20vvfSSXnvtNRkMBkud7du36+WXX1ZcXJz++OMP9ezZU+3bt891nwEAAAAULFOnTrU83Fa5cmX9+OOPqlevnk2da9eu6dVXX9X+/fsVExOjt99+W4sWLbLJDJIUFRWlkJAQSVLDhg317LPP3lafyCgAAACAcytoz3CZzWa9/fbblsE3/fv318cffyx3d3dLnaNHj+qFF17Q1atXtXHjRi1evFgDBw68rX4DKLgYVgcAAGAl/QMmg8Gghg0b3lYbycnJ+umnnyxff/311zbBTZK8vb319ddfW2aH27NnjwICAm6v0wAAAAAKrfPnz2vYsGG3NfgmPDzc8iGQm5ubJk2aZDP4RpJKly6tn376SWXKlJEkLV++XGfOnMnQ1oIFC3T58mVJ0j333KPXX389w4N0HTt21Keffmr5euLEibnuMwAAAICCJSEhwbKCjNFo1NSpUzMMvpGksmXLatq0aSpbtqyktIfhdu/enaFe+uo3ktS4cePb7hcZBQAAAHBuBe0Zro0bN+rw4cOSJH9/f40fP95m8I2UNgnBpEmTLF9PmTLFMqkAgKKDATgAAAD/z2w26/jx45Kk6tWrq3jx4rfVztatW3X16lVJUtu2bdWyZctM67m7u2vkyJGWr//888/bOh8AAACAwicqKkqff/65Hn74YcsHNmXLls3VA2p//fWXkpKSJEl9+vRRlSpVMq3n4+OjESNGSJJMJpOWL1+eoc6SJUss29Y55VYPP/yw/P39JUkHDhzQxYsXc9xfAAAAAAXPzp07LTM4d+zYUfXr18+yro+Pj/r162f5eseOHRnqpD8kJ+m2H5KTyCgAAACAMyuIz3BZZ5Tnn39eLi4umbbVsmVLderUSZJ06dKlTCcuAFC4MQAHAJBBamqq/vzzTz377LNq166dGjdurG7duumdd97RiRMnJEnTp09XvXr1VK9ePQUHB9scv3jxYsu+H374we65du3aZan79ttv2617+fJlfffddxowYIClX507d9aLL76ohQsXKjk5OUfn+euvv5SQkKDPP/9cHTt2VIsWLfTwww/r888/1+jRo3Pcd0kKCwtTw4YNVa9ePfXu3Tvb+rfrTq49ODjYck3Tp0+XJF24cEFffPGFevXqpRYtWqhly5bq06ePvv32W0voyM7OnTs1ZswYdenSRY0bN1aHDh309NNPa8WKFZKkwMDATF/Lt99+W/Xq1dPkyZMtZe+8846l7uLFi7M8Z0pKiubOnavhw4erQ4cOatKkibp166bRo0dr69atOeq3PRcuXFBMTIykO/tQaNu2bZbtrl272q177733WgLZhg0bZDKZbvu8AAAAhQ3Zg+yRE0Uxe0jS77//rv/+97+W17Rjx45atGiR6tSpk+M2rLPHfffdZ7eu9f5169bZ7AsPD7fMUu3j46NWrVpl2Y7BYFCXLl0sX//999857i8AAEBBR0Yho+REUcsoQUFBlu2cTAhQrVo1y3Zmr5n1Cji3+1kLGQUAACANGYWMkhNFLaNIBe8ZrtTUVG3fvl1SxgySGetz3fqZDIDCz9XRHQAAFCzh4eF6+eWXtX//fpvykJAQLV68WCtWrNDHH3981/v166+/auLEiUpMTLQpDwsLU1hYmDZt2qSff/5ZkyZNUr169bJtb8yYMdqwYYPl61OnTsnDw0OjR4/WmjVrJEkrVqzQq6++aredlStXWpaJfOSRR3J7WTmS19e+dOlSffTRR4qPj7cpDwoKUlBQkGbPnq0ffvhB99xzT6bHm0wmffTRR5o3b55NeXh4uLZv367t27dr6dKlevbZZ3N5pfYFBwdr5MiROnnypE15SEiIQkJCtGbNGvXv31/jx4/PcoaB7Bw5csSy3ahRI0lpMxEEBgbq+vXrKlasmPz9/dWkSRMZjVmPY7Zup3nz5nbPWaJECdWqVUsnT57UjRs3dObMGdWuXfu2+g8AAFCYkD3IHs6cPaxVqFBBY8aMsZlFOqdykz3q1q0rb29vxcXF6dSpU4qNjVWxYsUs7ZjNZklSkyZNsr2uZs2aWbYPHjyY634DAAAURGQUMoqzZpQRI0aoV69eCg0NVdmyZbOtHxYWZtn29vbOsD994Iy3t7dq1qyppKQkHTp0SKdPn1ZKSorKly+vVq1aqXTp0lmeg4wCAABARiGjOG9GkQreM1znz5+3DAiqXr263TwjkVGAoo4BOAAAi9jYWA0dOlTnzp2TJLm5ualbt26qX7++oqKi9PfffyskJETvvfeeOnTocNf69dVXX2nGjBmWr1u0aKHWrVurePHiunTpkjZu3KiwsDCdO3dOQ4cO1R9//KH69etn2d6SJUsyHWn/4IMPqlOnTipbtqyuXbumc+fO6ciRI5Y38ZlZtmyZJMloNOZLeMvra9+yZYv27dsnk8mkunXrqlOnTvLx8dHZs2e1du1axcfHKzY2VqNHj9bff/+daVh46623LNctSe3bt1fr1q2VkpKiXbt26cCBA9q6davOnDmTaR969eqlOnXqKCAgQAEBAZay9FnVmjRpkulxo0aNUmxsrNzd3dWtWzfVqVNHSUlJ2rZtmyUsLV68WDVq1NCLL76YzSubuWPHjlm2k5OT9dRTT2nnzp0Z6vn5+Wn06NEaOHBgpu2k/wxJUtWqVbM9b6VKlSyh9Ny5cwzAAQAARR7Zg+zh7NlDSssKH374oQYMGCAPD49cHx8TE2OZ/c7T01Ply5fP9phKlSrp1KlTMplMunDhgho0aCDJNsNUqVIlR+2ksz4WAACgsCKjkFGcOaO4u7urSpUqOcoCkrR27VrL9q0reMbHx+vs2bOSpJo1a2rq1KmaPXu2IiIibOoZjUY98MAD+ve//53peckoAADA2ZFRyCjOnFGkgvcMV24zSuXKlTPtA4CigQE4AACLyZMnW97wVaxYUdOnT1fdunUt+9944w1NmDBBc+fOtVmeMT+tX7/eEl58fX317bffZhjVn5iYqK+++kqzZs2yBI8VK1bI3d090za3bt0qV1dX/fvf/1a/fv2UmpqqDRs2qGPHjnJ1dVXv3r313//+V1LaDApZhbfTp09bQkPbtm1VoUKFPLrqNPlx7Xv27JGLi4vGjx+vQYMG2ex79dVXNXz4cF26dEkxMTGaP3++Ro4cmaFP6cHNy8tL33//fYYlNVesWKG3335bISEhmfbh3nvv1b333qu4uDhLeOvcubP69+9v9/WIjY1VixYt9P3338vPz89SPnbsWE2cOFE//vijJGnGjBl65pln5ObmZre9zKTPyiZJEydOzLJeaGioxo0bp507d+qLL76Qq+vNt1RJSUmKjIyUJLm6uqpcuXLZntf6Qblr167lut8AAACFDdmD7OHs2UPSba14Yy198I2U9gGTwWDI9pjy5cvr1KlTkmyzh3VbFStWzLYd69fl+vXrOeovAABAQUZGIaOQUXJm+fLlCgoKknTzIVBrJ06ckMlkkpQ207T1bNPWTCaTVq9erZ07d2rKlClq3bq1zX4yCgAAcHZkFDKKs2eUgvYMV24zSunSpeXm5qbk5GTduHFDSUlJWX4vACh8sl53CwDgVMLDw/X7779LSnvDOXXqVJvgJqXNgPXxxx9n+GN6fjGbzfruu+8sX0+aNCnTJTU9PDz03nvv6b777pOUtuTjn3/+abft0aNHa8SIEfL19VWZMmU0aNAgy8hz64egVq5caVni/lbLly+3bPft2zenl5Uj+XntL774YobgJqWN8n/ttdcsX+/YsSNDna+++sqyPX78+AzBTZJ69+6t999/324fbke5cuX0888/2wS3dKNHj7bMLhAdHZ1hidOcsp49wWAwaMCAAZo/f7727dunffv26X//+58eeughS53ly5friy++sGkjfblRKW0W6pywrnfjxo3b6jsAAEBhQfYge5A98oZ1drjT7GG97eXlddvtAAAAFEZkFDIKGSVnzp8/r08//dTy9ZAhQ1S2bFmbOtYPyUlStWrVNH78eG3evFmHDx/Wxo0b9cEHH1gefIuMjNSoUaN08eJFm+PIKAAAwJmRUcgoZJSC9wzX7Xwm4+HhkenxAAo/BuAAACRJGzduVEpKiiSpa9euatiwYZZ133777bvSpwMHDljehLdo0ULt2rWzW/+ll16ybFsvr3krg8GgoUOHZrm/QYMGqlevniTpypUr2rt3b6b10sObp6enHnjgAbt9y638unZJGjZsWJb72rRpY9m+dSWWEydO6OzZs5KkOnXqqHfv3lm2M3jwYFWvXt1uP3JryJAhKlGiRKb7jEaj2rdvb/n60qVLuW4/NDTUMiuai4uLJk+erM8++0zNmjVT8eLFVbx4cbVu3VoTJ07UO++8Yzlu1qxZ+ueffyxfJyUlWbZvJ7xZHw8AAFAUkT1uInukcbbskVfyMntYb1t/IJTbdgAAAAojMspNZJQ0ZJSMwsLC9PzzzysqKkqSVLlyZY0ePTpDPesBOO3atdOSJUs0aNAgVahQQe7u7qpUqZIef/xxLVmyRDVq1JAkRUVFacKECTbtkFEAAIAzI6PcREZJ42wZpSA+w8XzYACsMQAHACBJ2r59u2U7sxHx1qpXr57lkp55ac+ePZbtnJyvYcOGlqUaDx06ZAmjt/L395ePj4/dtqxnUFixYkWG/fv371dwcLAkqUePHipevHi2/cuN/Lr2SpUq2V1Os3Tp0pbtxMREm32bN2+2bHfv3t1ufwwGQ54H2tatW9vdbz3LmvUMBjlVvnx5bd68Wf/73//022+/qUePHlnWHTFihO69917L1+nL3Upp134n7vR4AACAgo7sYYvs4XzZI68YjXf2p13r7HEnbZFhAABAYUdGsUVGIaPc6vLlyxo+fLjOnz8vKW1Fmu+//14lS5bMUPfdd9/V8uXLNXXqVE2aNCnL749y5crZzNi9ceNGnTt3zvI1GQUAADgzMootMorzZZSC+AxXXn4mA6Dwc3V0BwAABUNoaKhl29/fP9v6jRs31pEjR/KzSzp16pRle/bs2Zo9e3aOj01ISFB4eLjKly+fYV/6Mpf29OnTR19//bVSU1O1Zs0avf/++3J1vflrMz+XLpXy79rLlClj91gvLy/Ltslkstl34cIFy3adOnWy7Uf6DBR5xTpYZsb6/tza95wwGAyqUKGCKlSokKP6w4YN05YtWyRJAQEBlvJixYpZtm8NwFlJSEiwbOdkJjcAAIDCjOxhi+zhfNkjr3h7e1u27zR75LYtMgwAAChKyCi2yChkFGunTp3Sc889p8uXL0uS3N3d9cMPP6hJkyaZ1vf29lbdunVVt27dbNtu2rSpGjVqZPl5CggIsKyKQ0YBAADOjIxii4zifBmlID7DdaefyaQPygJQNLACDgBAkizLNkrKdmYBKfs30nkhfRn7vD4+qyUwrZUrV0733HOPJCkiIsLmzXlycrJWrVqVoV5eyq9rtw5nuWW9nGlOXkNfX9/bPldmrENRQdC0aVPLdnh4uGJjYyXZBi7rIGWPdb2cvLYAAACFGdnDFtkjI7JHzlj3806zR25zjHWdvJ5NEAAA4G4jo9gio2TkrBklICBAjz32mGXwjbe3t3766Sd17tw5z85h/VlL+qzl6edKR0YBAADOhoxii4ySkbNmlKzcjWe4bqet9IE6BoOBnAIUMayAAwCQZLtMotlszrZ+Xo3Ktneu1NRUy/aDDz5o82Y5J7KaKcB6lL09/fr1s4yOX7FihWVZ123btikiIkKS9PDDD8vFxSVX/cqJ/Lr2O5GcnGzZzsn3SE7qFGa3/pEjJiZGxYoVk9FoVNmyZXXt2jUlJycrPDw82z92WM9eYm95WQAAgKKA7JER2cMW2SNnypYtK4PBILPZrLCwsBwdk1X2sJ59LydtkWEAAEBRQkbJiIxiyxkzyty5c/Xpp58qJSVFUtoDe9OnT1ezZs3y9DwlS5a0bMfExFi2ySgAAMCZkVEyIqPYcsaMYs/deIYrtxnl+vXrlvtUsmRJVsABihgG4AAAJNmOdM/JyP0bN27kqN3s3sDbW5LR+s1xixYtNGLEiBydM6/06NFDJUqU0I0bN7R+/XolJSXJ3d1df/31l6VOfixdKjn+2jNj/SFIXn6PFDTJyckym83ZBp/02RLSWd+z2rVrW2abCAkJyTa8Xbp0ybJdo0aNXPYYAACgcCF7ZET2sOUs2eNOeXl5qUqVKrp48aLi4uKy/eDIbDZbZq42Go2qXr26ZV+dOnUs2yEhIdme27pOzZo1b6f7AAAABQYZJSMyii1nyyhff/21fv75Z8vXVapU0YwZM3L13j82NjZHs2Jbf9ZiPbs0GQUAADgzMkpGZBRbzpJRCtIzXGQUANaM2VcBADiD2rVrW7ZPnDiRbf0zZ85kuc96JoakpCS77Vy9ejXLfVWrVrVsnzx5Mts+SWnLSOYVDw8PPfjgg5LS3qjv2LFDqamplhkV6tSpo4YNG+bZ+aw5+toz4+/vb9k+depUtvVz2u+CYvz48WrTpo0aN26sX3/9Ndv61j8nlStXtlkatn79+pbtQ4cO2W0nKirK8vNUokQJm4fgAAAAiiKyR0ZkD1tFPXvkpdxkjxMnTiguLk5S2s+hh4eHZV/dunVlMBgkSYcPH872g9jAwEDLdqNGjXLbbQAAgAKFjJIRGcWWs2QUs9msDz74wGbwTdOmTTV//vwcPTB28eJF3XvvvWrcuLE6duxoWT3HHuufOeufRTIKAABwZmSUjMgotop6RimIz3BVrFjRMvDpzJkzNit4ZoaMAhRtDMABAEiS2rVrZ9n++++/7daNi4vTnj17stxv/SY2u0Bx+PDhLPe1bt3asr1582ab5TOzaqtDhw5q0aKFBgwYkKM/7GenX79+lu0NGzZo//79lpkDHnnkkTtuPysF4dpvZf09smnTpmzrb9y40e7+9A9OCopSpUopOjpakiwB3R7rWTQ6duxos+++++6zbGf3Wm3ZskUmk8nSjvUfPwAAAIoiskfmyB43FfXskZdykz2s93fq1Mlmn4+Pj1q1aiVJun79ut2fF7PZrM2bN1u+7ty5c847DAAAUACRUTJHRrnJWTLKF198oXnz5lm+7tq1q37//XeVKVMmR8dXqFBBkZGRSk5OVkJCgt2fFUm6fPmy9u/fLyntwdD27dtb9pFRAACAMyOjZI6MclNRzygF9Rmu9LasB39lxfpcZBSg6OEJTwCApLSlOtP/gL5jxw5t3749y7q//vprhqUbrVWsWNGyvXPnTssb01tduXJFy5Yty7KdDh06qEKFCpLSZln45ZdfsqxrNpv1zTffSEoLl1WqVJGrq2uW9XOqVatWlpkMNm7caAkkRqMxX8NbQbj2W7Vq1coysj8oKMhuyF+3bp2OHz9utz3rkJKampo3nbwD6TNlSNK+ffu0c+fOLOv+888/Wrx4seXrYcOG2exv166dypUrJyktnFnPamAtKSlJ06ZNs3zdv3//2+k6AABAoUL2yBzZ46ainj3y0gMPPCB3d3dJ0uLFixUcHJxpvaioKP3222+WrzPLHr1797Zs//DDD1mec/ny5Tp79qwkqXHjxqpTp85t9R0AAKCgIKNkjoxykzNklL/++kv//e9/LV/37t1bkydPtnlgMztubm7q1q2b5eupU6faXbnm888/tzyM2LVrV1WqVMlmPxkFAAA4KzJK5sgoNxX1jFJQn+Gyzig//fRTloOx9u7dq4CAAElSuXLlMkyKBqDwYwAOAECS5O7urldeecXy9euvv57pm9f58+dr6tSpdttq2LChSpQoIUkKCQnRxIkTM9Q5f/68nn/+ecXFxWXZjpubm0aNGmX5+vvvv9fMmTMzhMH4+Hh9/PHH2rFjhyTJ1dVVL730kt0+5pTBYFDfvn0lSaGhoZaZv9q1a2cJV/mhIFz7rQwGg1599VXL12+//bblvNYCAgL01ltvZdte8eLFLdshISF508k74O/vr549e1q+Hjt2bKZLj+7du1fPP/+8JUQNHjw4wzK2RqNRo0ePtnz9yiuv6NixYzZ14uLi9MYbb1iWeW3atKm6dOmSZ9cDAABQUJE9Mkf2uKmoZ4+85OPjo2eeeUaSlJiYqBdffDHDIJzw8HCNHDnSMrvhgw8+mOkDaf3791e1atUkpX0INX78+Awz823fvl0ffvih5Wvr3AMAAFBYkVEyR0a5qahnlPDwcH3wwQeWrzt16qT//Oc/t/Wg4MiRI+Xi4iJJ2r17tz744AMlJSXZ1ImPj9e4ceO0Zs0aSZKnp2emrxsZBQAAOCsySubIKDcV9YxSUJ/h6ty5s1q2bClJOnHihN54440MPzdHjx7Va6+9Zvn6pZdeypdBWAAci59qAIDFsGHDtG/fPq1YsUJRUVEaMWKE7rnnHrVo0UIpKSkKCAiwvJn18PBQYmJipu24urrq8ccf108//SRJmjZtmrZu3ap77rlH7u7uOn78uDZv3qyUlBR17txZ+/fvz3I2hiFDhmjv3r1atmyZTCaTvvjiC82dO1f33nuvSpcurUuXLmnjxo26evWq5Zg33nhD9evXz7PXpV+/fpo8ebIkKSYmRpIsgS4/FYRrv1WfPn30999/a82aNYqJidGIESPUsWNHS7jYv3+/ZeYNLy8vxcfHS8p8qdIqVapYtn/99VclJSWpRIkSatOmjc3yrXfThx9+qOPHj+v8+fO6fv26hgwZonvvvVdNmzZVamqqAgMDtX37dsuMba1atdI777yTaVuDBg3SqlWrtH37dl29elWDBg1S9+7dVa9ePUVERGj16tUKCwuTJBUrVkxffPFFgVvSFQAAIL+QPTJH9ripqGePvPTSSy9p/fr1OnnypE6dOqU+ffqoZ8+eql69ui5fvqw1a9YoMjJSkuTn52fzYJ01Dw8PffLJJ5YPq2bNmqWtW7eqe/fu8vb21qFDh7RlyxZLHho8eDCTCAAAgCKDjJI5MspNRTmjzJw503J/JalevXo2q+HYU7t2bZtcUL9+fb355pv6/PPPJaU9FLp161b16NFD5cqV06VLl7R+/XrLvXN1ddVXX31lmb3bGhkFAAA4MzJK5sgoNxXljCIVzGe4DAaDPvnkEw0ZMkSxsbFas2aNAgMD1bNnT5UqVUonTpzQ+vXrLQOCOnXqpKFDh+bTKwTAkRiAAwCw8Z///EelSpXS7NmzZTabtW3bNm3bts2y32AwaOTIkdq3b592796dZTuvvPKKzp8/r1WrVklKG9199OhRmzpdu3bVN998k+0fw7/88ktVqlRJv/zyi5KTk3Xu3DmdO3cuQz1PT0/961//0pNPPpmLK85e1apV1apVK+3bt09SWih54IEH8vQcWXH0tWfm66+/ltFotNzb7du3Z1jutlevXqpcubJ+/vlnSWmzc9yqY8eOqlatmi5cuKDExETLEq1PPvmkw8JbmTJlNGvWLI0dO1Z79+6VyWTSpk2btGnTpgx1e/furY8//lje3t6ZtmUwGDRlyhSNGTNGmzZtUnJyslavXq3Vq1fb1CtfvrwmT54sf3///LgkAACAAovskRHZw1ZRzh55ydPTU7/99pteeuklHTx4UHFxcVqyZEmGejVr1tS0adNUpkyZLNvq0KGDJk6cqLfffls3btzQuXPnLK+XtSFDhtjMMg0AAFAUkFEyIqPYKqoZ5db8kFkGyEqfPn0yfB+PGDFCXl5e+uyzz5SQkKDLly9r1qxZGY4tV66cPv30U3Xt2jXL9skoAADAmZFRMiKj2CqqGUUquM9w1alTR7/88oteffVVXb16VaGhofr9998z1OvWrZu+/fZbGY3G3F04gEKBATgAABsuLi5677339Mgjj2jOnDnatWuXrl69Kh8fH7Vq1UrDhw9X69atsw0Jbm5umjhxoh599FEtWrRIBw4cUEREhHx9fdWoUSP179/fZqlIe4xGo8aMGaOBAwdq/vz52r59u4KDgxUTEyNvb2/VqFFDHTt21JAhQ1SpUqW8eBky6Nu3ryW8de/eXcWKFcuX89yqIFz7rdzd3TVx4kT1799fixcvVmBgoK5fvy5vb281btxYQ4cOVY8ePfT1119bjsns9fL09NTs2bP17bffKiAgQJGRkXZn5bhb/Pz8NHv2bG3YsEHLly/XoUOHdO3aNbm6uqp8+fJq06aN+vbtm6OA6e3trWnTpmn9+vVaunSpDh06pOvXr8vDw0M1a9ZUjx49NGzYMPn4+NyFKwMAAChYyB6ZI3vcVNSzR14qU6aM5s6dq2XLlumvv/7SsWPHFBkZKS8vL9WtW1cPPfSQBg0aJA8Pj2zb6tGjh1avXq3Zs2dr06ZNCg4OVkJCgsqWLasWLVroscceU7t27e7CVQEAANxdZJTMkVFuKooZJTw83GaW7rwyZMgQde3aVXPmzFFAQIDOnTunuLg4+fr6qmbNmurevbsGDBigEiVKZNsWGQUAADgrMkrmyCg3FcWMYq2gPsPVokULrV69Wn/88YfWrVun8+fPKzY2Vr6+vmrSpIkGDBigHj165MVLAKCAMpjT198CACAXnnzyScvsCevXr7dZirIomjx5sn744QdJ0owZM9S5c2cH96jg+/DDDzV37lxJ0vfff68HH3zQwT0CAABAYUT2IHtkh+wBAACAu4mMQkbJDhkFAAAAdxMZhYySHTIKAOQtVsABACAHli1bJiltZH3Hjh0d3BvHCAsL05IlS1SjRg01bNhQVatWtVv/5MmTlu2aNWvmd/cAAACAIoHsQfYAAAAAChIyChkFAAAAKEjIKGQUAHA0BuAAAJCNbdu26fz585Kk/v37y8XFxcE9cpxvv/1WklSjRg2tWbMmy3rHjh2zLPdaqlQp1a5d+670DwAAACjMyB43kT0AAAAAxyOj3ERGAQAAAByPjHITGQUAHMfo6A4AAFDQxMTEWLYPHTqk999/X5Lk5uamoUOHOqpbDle+fHnVqlVLknTu3DlNnz5dJpMpQ73Tp0/r5Zdftnz9+OOPO3XgBQAAALJC9sgc2QMAAABwDDJK5sgoAAAAgGOQUTJHRgEAx2IFHAAAbjF58mQtWLBALi4uioqKspQ/8cQT8vPzc2DPHO+1117Ta6+9Jkn65ptvtGjRInXo0EF+fn6Kjo7WyZMnFRAQYAl1jRo10siRIx3ZZQAAAKDAIntkjewBAAAA3H1klKyRUQAAAIC7j4ySNTIKADgOA3AAALhFxYoVbWZQkKQmTZpYQosze/DBB/XRRx/piy++UEJCgs6dO6dz585lWrdnz5767LPP5Obmdnc7CQAAABQSZI+skT0AAACAu4+MkjUyCgAAAHD3kVGyRkYBAMdhAA4AALdo0qSJatSooUuXLqls2bJ68MEH9fLLL8vLy8vRXSsQhg4dqq5du2rBggUKCAjQ2bNnFRMToxIlSsjPz0/NmjVT//791bx5c0d3FQAAACjQyB72kT0AAACAu4uMYh8ZBQAAALi7yCj2kVEAwDEMZrPZ7OhOAAAAAAAAAAAAAAAAAAAAAAAAAAWV0dEdAAAAAAAAAAAAAAAAAAAAAAAAAAoyBuAAAAAAAAAAAAAAAAAAAAAAAAAAdjAABwAAAAAAAAAAAAAAAAAAAAAAALCDATgAAAAAAAAAAAAAAAAAAAAAAACAHQzAAQAAAAAAAAAAAAAAAAAAAAAAAOxgAA4AAAAAAAAAAAAAAAAAAAAAAABgBwNwAAAAAAAAAAAAAAAAAAAAAAAAADsYgAMAAAAAAAAAAAAAAAAAAAAAAADYwQAcAAAAAAAAAAAAAAAAAAAAAAAAwA4G4AAAAAAAAAAAAAAAAAAAAAAAAAB2MAAHAAAAAAAAAAAAAAAAAAAAAAAAsMPV0R0AshIdnaDUVFOetunj4ykXF6NSU02Kjk7I07ZR8HC/nQv327lwv50L99t5OOpeu7gY5ePjedfOh8KLjII7xf12Ltxv58G9di7cb+dCRkFBlh/5ROL/OWfD/XYe3Gvnwv12Ltxv5+KI+00+QU6RUXCnuNfOhfvtXLjfzoX77Tyc+TMUBuCgwEpNNSklJTXf2s/PtlHwcL+dC/fbuXC/nQv323lwr1EQkVGQl7jfzoX77Ty4186F++1cuN8oaPI7n0h83zsb7rfz4F47F+63c+F+OxfuNwoaMgryEvfauXC/nQv327lwv52Hs91ro6M7AAAAAAAAAAAAAAAAAAAAAAAAABRkDMABAAAAAAAAAAAAAAAAAAAAAAAA7GAADgAAAAAAAAAAAAAAAAAAAAAAAGAHA3AAAAAAAAAAAAAAAAAAAAAAAAAAOxiAAwAAAAAAAAAAAAAAAAAAAAAAANjBABwAAAAAAAAAAAAAAAAAAAAAAADADgbgAAAAAAAAAAAAAAAAAAAAAAAAAHYwAAcAAAAAAAAAAAAAAAAAAAAAAACwgwE4AAAAAAAAAAAAAAAAAAAAAAAAgB0MwAEAAAAAAAAAAAAAAAAAAAAAAADscHV0B4D8YDKZlJgYr4SEOKWmJstkMkmSIiJcZTBIZrOUnJzi4F4iv3G/nQv3u+gyGIxycXGRu7unPDy85Orq5uguAQCQa2QUSNxvZ8P9LrqMRqNcXNzk6ektDw8vR3cHAIDbQkaBxP12Jtzroo2MAgAo7LLKJxLvY5wJ99q5cL+LNjIKgKKOATgochIS4hQZeU2SOcO+5GSTJIMks0ymjPtRtHC/nQv3uyhLVWpqspKSEhQTEylXV3f5+FSXi4uHozsGAECOkFGQjvvtXLjfRZfJlKqUlGQlJsZJMsjTs6pKlvRxdLcAAMgxMgrScb+dB/e6aCOjAAAKM3v5ROJ9jDPhXjsX7nfRRkYBUNQxAAdFSuahzCCj0Zi2ZTBYSo1G3rgVddxv58L9LrrMZrPM5psz3KSkJOnChfOqVq2a3NzcHdgzAACyR0aBNe63c+F+F11pM3Cm31OzLl0KkdFokLd3MUd2CwCAHCGjwBr323lwr4s2MgoAoLDKLp9IvI9xJtxr58L9LtrIKACKOgbgoMgwmUw2oczDw0ve3j5yd/ewvGFzcTFali5MTTXZaQ1FAffbuXC/i7a0WRHiFRd3Q6mpKUpJSVFwcLBq1Kjp6K4BAJAlMgpuxf12LtzvostsNispKVFxcdFKTIyXyWRWSEiI/P1rO7prAADYRUbBrbjfzoN7XbSRUQAAhVFO8onE+xhnwr12Ltzvoo2MAqCoYwAOiozExHhZhzJf33I2gQwAUHi5urrJ1dVNXl7FFB4eptTUZCUnJys+Ps7RXQMAIEtkFAAomgwGgzw8POXu7qHIyKtKSkqQ2WxWTEyMJBdHdw8AgCyRUQCgaCKjAAAKI/IJABRdZBQARZ0x+ypA4ZCQcPMhbG9vH0IZABRBRqOLihf3kdmcNltCVFSUo7sEAECWyCgAULQZDAZ5e9/MJzExNxzdJQAA7CKjAEDRRkYBABQm5BMAKPrIKACKKgbgoMhITU3+/y2D3N09HNoXAED+8fDwtixDm5iY5OjuAACQJTIKABR97u4eMhgMMpulpCTyCQCgYCOjAEDRR0YBABQW5BMAcA5kFABFkaujOwDkFZPJJEkyGo3MigAARZjBYJDBYJRklsmU6ujuAACQJTIKABR9BoNBRqNRZrNJqakmR3cHAAo8s9msFStWaNGiRTp27Jji4uJUrlw5tWnTRo8//riaNm16x+cICgrSzJkztWvXLoWFhalEiRLy9/dXv3799Oijj8rFxSXDMcHBwerevfttne/EiRN32uW7howCAEUfGQUAUFiQTwDAOZBRABRFDMABAACFTtrMCGaZzY7uCQAAAAAAAHIiISFBr732mjZt2mRTHhISopCQEC1fvlyvv/66Xnjhhds+x4IFC/Txxx8rOTnZUhYeHq7w8HDt2bNHS5Ys0ZQpU+Tr63vb57DGQ2IAAAAAAAAAADgXBuAAAAAAAAAAAAAgX40bN84y+Mbf31+DBw9W2bJldeTIEc2dO1dxcXH65ptv5Ofnp759++a6/a1bt+r999+X2WyWl5eXHnvsMTVu3FjXr1/XwoULFRQUpL1792rs2LGaMWOGjEaj5dgyZcpoypQpOTrP1KlTdeTIEUnSq6++mut+AgAAAAAAAACAwosBOAAAAAAAAAAAAMg3AQEBWrFihSSpffv2mj59ujw8PCRJvXv31sCBAzVs2DBFRkbqs88+U/fu3VW8ePEct5+UlKSPPvpIZrNZ3t7emj17tho1amTZP3ToUI0dO1Z///23AgICtHLlSvXu3duy38vLSz169Mj2PMuXL7cMvunSpYtGjRqV4z4CAAAAAAAAAIDCz5h9FQAAAAAAAAAAAOD2/Prrr5IkV1dXjR8/3jL4Jp2/v7/ef/99SVJkZKQWLFiQq/bXrl2r4OBgSdJzzz1nM/hGktzd3fXll1/K19dXkjRt2rRcX0NoaKg++eQTSVKpUqX02WefyWAw5LodAAAAAAAAAABQeDEABwAAAAAAAAAAAPkiMjJS27dvlyR17txZVatWzbRer169VKZMGUnS6tWrc3WOlStXSpIMBoOGDh2aaZ1ixYqpf//+kqSgoCCdPXs2V+eYMGGCoqOjJUlvvfWWypYtm6vjAQAAAAAAAABA4ccAHAD5KiUlRbNn/1dPPfWY7r//XnXt2kGPPtpL69evzZP2V65crk6dWqtTp9ZauXK5zb4ZM35S+/Yt1aFDS+3fvzdPzof8FRERoYUL5+b7eTZuXKdTp05mKLf3/QQAAICigYyC3CCjAABw5/bu3SuTySRJat++fZb1jEaj2rRpI0k6ePCgoqKicnyOPXv2SJLq1aun0qVLZ1nP+vxbtmzJcfs7duzQmjVrJEmtWrXSo48+muNjAXscmU9++WWaOnRoqfbtySeFBfkEAAAA+Y3PUJAbZBQAgLNiAA6AfDVhwkf66afJOn36lOLj45ScnKyrV8NUooSPo7uGAmbt2lV64omB2rRpQ76dIzz8ut555196//23FR2d8w/wAQAAUHSQUZBTZBQAAPLGyZM3H5CoW7eu3bq1a9eWJJnNZgUFBeWo/dDQUMvKNHXq1LFb19/f37J9/PjxHLUvSV9//bVl++23387xcUB2yCfIKfIJAAAA7gYyCnKKjAIAcGauju4AgKLr/Plz+vvv1ZKkEiV8NHToE6pcuapiYm6ofv2GDu4dCprp06fmalbL27Fz53Zt3bopX88BAACAgouMgtwgowAAkDdCQkIs25UrV7Zbt0KFCjbHpa+IY09wcHCO2/fz85PRaJTJZNKlS5eybVuS1q1bp3/++UeS1KNHDzVt2jRHxwHZIZ8gN8gnAAAAyG9kFOQGGQUA4MwYgAMg35w9e9qy/fTTz2vw4KEO7A2QvV69+qhXrz6O7gYAAADyCRkFhQ0ZBQBQFISHh1u2S5UqZbeur6+vZTsyMjJH7UdEROS4fTc3N3l7eysmJibH7f/3v/+1bD/33HM5OgbICfIJChvyCQAAQNFGRkFhQ0YBADgKA3AA5Jv4+HjLds2aNR3YEwAAUBhExyYqNiFF5X29HN0VAEUUGQUAAOTG5eux8nBzVWkfD0d3pVBLSEiwbHt42H8t3d3dMz3OHuv3eNm1n14nJiYmR+0fP35ce/bskSS1aNFCLVq0yFGf7gYfH89cHxMR4arkZJMMBoNcXIyZ1jEYbv6bVR3kjcTERMu2v79/vrzeRqPBZtv6HNb7JO53YWHv59f+cTf/zep46+8JFxcj3xNFgMEglS5dzNHdQD5L/9k1Gg3c7yLOZDLrQugNlfP1UjEvN+43gDzHZygAACA3YuOTFRmTqPKlnO85LwbgAMg3ZrPZsu3iwn83AAAga3uPh+m/q48rLiFFzeqU1ai+jeTm6uLobgEoYsgoAAAgJ0xms+asO6n1+4IlSU/1aqAuTSs6uFeFV0pKimXbeoBNZqz3Wx9nT2pqao7bt66Tk/Z///13y3ZBW/3m9h/AN1ht56Q+8ovZbLJsu7q63pXX2945uN+Fx53eq5wez/dE0cBAKueRNkCPH9yiKuJGgsb/uktBFyJVzMtNHz/fXvWql3Z0twAUMXyGAgAAcurIuXDNWH5UUbFJqlPVV68NaCpvT+d5/+A8VwrgrnnllRcUGLjfpmz06JGW7Xff/VC9evXRL79M08yZP0uSJk36SS1bts60vZUrl+uzzz62OfZuio+P199/r9batasUHHxRUVGR8vEpqYYNG6l37366557OWR6bnJystWtXacOGdQoKOq4bN6JVvHgJ1ahRU/fe21V9+z4qD4/MZyocOLCPrly5rL59++vf/35XR478o3nz/qfDhw8qKipKZcqUVfv2HfXkkyNUvryfJCk6Okpz5szWpk3rFRoaKk9PTzVu3ESPPz5CzZo1z3AO63uwadNORUdH6fffZyogYIuuXbuqYsWKqVGjJurff7DateuQaT/v9D6mX2e6wMD96tQprY2nn35ezz77ok07kZGRWr58qfbu3aXz588pOjpKLi4uKlmypBo2bKz7739QnTp1kcHqkyHrc6ez/p7ctm2v3T7e6tixI1q6dJEOHjygq1fD5OLiqvLl/dS6dVv17z9I1apVt/taubi4aPPmXYqLi9X8+XO0adMGXboUIrPZrKpVq6lr1x4aNOgxeXrmfhZLACiMjp4L17RlR5RqSvuj7sGT13T28g3Vrerr2I4BKDLIKDeRUW4io5BRACArizadtgy+kaRFG0+pc5MKMvIk8m2x/v2RnJxsd5BMUlKSZTsng2kk21VvkpOTs62ffg43Nze79WJjY7VixQpJUqVKldStW7cc9eduSU01ZV/pFmnPUpmttjOy/jbPqg7uzKhRz+vAgX02ZS+//IJl+733PtLDDz+iGTN+0i+/TJckTZkyPcv3tX/9tUzjx39kc2xW7N3T273f8fHxWrt2ldasWaWLFy8oKirS8l64T59+6tTp3iyPTU5O1po1K7V+/d86cSItn5QoUUI1atRSly5d1bdv/yzfgz766MO6cuWy+vUboLfeGqcjRw5rzpzZOnQoLZ+ULZuWT5566hlLPomKitKcObO0ceN6XblyxZJPhg9/Ws2aZVzhyvoebN26W9HRUfrtt1+1detmSz5p3LipBgwYrPbtO2bazzu9j+nXme7AgX1q376lJOnZZ1/Qc8+NtGknMjJCy5Yt1e7dOzPNJw888KDuvberTT6xPnc66+/JHTv22+3jrY4ePaIlSxYqMHC/rl69KhcXF/n5+alNm3YaMGBwlvkk/bVycXHRtm17FBublk82blynkJAQSWn5pFu3+zV48GPy9HS+2VVvx+38vkDhYjQaZDAYZDabZTLxy7soik9M0cc/79TpkChJabNM/xVwVrWr+N61PjCYDyja+AzlJj5DuYnPUPgMBQCycvZytCYvOqzE5LTJsU5ejNTRc+FqXb+8g3t29zAABwDsCAo6rnfe+ZdCQ6/YlF+/fk1bt27W1q2b1b37A3r//U/k6mr7X+qZM6f1wQfv6Ny5MzblkZERCgyMUGDgfs2dO1ufffa16tdvYLcff/wxS9OmTbaZzfHy5RAtWbJAW7du0tSpM5SYmKh///s1m5CTlJSo7du3adeuHfrkk8/VpUvWHxIHB1/U2LGvKCws1KqvkQoI2KqAgK0aPHioXn11rE3gudtWrVqhb7/90mbZ23Tx8fG6cuWKNmxYp44dO2vChP9k+yF6biUlJWnixK+0bNmSW/Yk6ty5Mzp37oyWLFmgZ599UcOHP2O3rQsXzuuNN0br8uUQm/KgoOMKCjquFSuWavLk6SpXznnelABwThdCb2jy4sOWwTfpSnjn7f/hAFBUkFHIKNbIKACQ9/7ee1Grdl2wKfMt4ZFFbeSEt7e3ZTsxMTHHA3CsB9bkpv3spNfJ7qGIrVu3Wuo+8MADMhoL1kOH0dEJSklJzb6ileTkFJlMZhmN5iwfyHZxMcpgSBuMwUPb+cOczUgXkynt/lg/RJ2aasryfljXSz82t/vSz5FbWeWTa9euacuWTdqyZVOu80lERIQiIvbpwIF9+uOPWdnmE7PZrFmzfsuQTy5dCtHixQu0Zcvt5xPr1+j8+fOZ5pNt27Zo27YtWeaTvLiPWbm13u3mk+we2E8/R3Z9zDqfSGfPntHZs2e0aNH8LPOJdftnz57NNJ+cOHFcJ04c17JlS8gnOWA2S+HhsY7uBvJZ6dLF5OJikMlk5n4XQSmpJk1aeMgy+CZdyeIed+1+u7q6qFQp7+wrAkABwGcofIZijc9QACDvhUbEaeKCg5bBN+l8iuVsQq2iggE4APLc88+PUlRUpPbv36OFC+dJkp57bqRq1aotSapbt74ju5djFy6c06hRzykhIUGS1LRpc3Xr1kMlS/rq3LmzWrx4gW7ciNb69WtVqlQpvf76vy3HXr58Sa+/Pkrh4dclSbVq+atnz16qUKGSrl+/pvXr1+rIkcMKCwvVq6++oB9//FW1a9fJtB979uzSn38ulqenpx59dKAaNGik69evadGi+QoNvaJr167qm2++1MWL53XlymV16dJVHTt2ltFo1IYNf2vHjgClpqbq66+/UMeOnbMMK++++y+FhYWqatVqeuSR/ipXrpxOnDiupUsXKj4+XvPnz5GHh6defPHlPH2d33xznBISEvSf/0xQZGSEataspeefHyVJql69htXrsFOfffaxzGaz3N3d1b37A2rYsLF8fHwUFhamAwf2avv2bZKk7du3avHi+Roy5HFJUsuWbfTZZ19n+T2ZE2azWRMmfKT169dKkry8vPXww4+oYcNGSk1NVWDgfq1Zs1IpKSmaPn2qEhMT9fzzL2XZ1ptvjtHlyyFq0qSZune/X76+pXT69CktWbJQMTE3FBISrG+++UJffPFtrl9TACgsrkXG67v5B5WQZBvKeneqqYplijmoVwCKIjIKGSU3yChkFADOa8/xMM1dd9KmzGg06Nk+jVj95g74+PhYtiMjI1WiRIks60ZGRlq2S5cunev2o6Ki7NRMm8k2Li4uR+1v2LDBst2zZ88c9QXICfIJ+SQ3yCfkEwDOy2w267+rjuufs+E25eVLe6tfF3+ZklIc1DMARQ0ZhYySG2QUMgoA5xUVm6Tv5h3UjTjbleg7N6+sOlVKOqhXjsEAHDg1k8msmITk7CsWMcU93WQ05t8HxulLYMbE3LCUNW3aPMslKwuqr7763BLKRo58RU88McJmf79+A/Tcc8N1/fo1LV68QIMGDVXlylUkSV9+Od4Syh59dJBef/1fcnFxsRw7ePBQ/fbbL/r55x8VHx+vjz56V7//Pi/TWRQvXQpRiRI+mjTpJ9WpU9dS3qNHTw0Z0k/JycnatWu7JOmtt95Tnz79LHUeeqi33n//bW3cuE4REeE6ePCAWrdum+n1XrhwXh063KPx47+0LJfao0dP9erVR6+++qIiIyM0d+5sPfzwI6pSpWouX82stW3bXpI0adI3kqSSJX117733Zaj344+TZTab5erqqkmTpqlx4yY2+594YrhWrFiqCRM+kSStXbvaEswqVKigChUq3NH35N9/r7aEsqpVq+m776aoQoWKlv0PPdRb/fsP1htvvKrIyAj9/vuvat++o5o0aZahLZPJpODgCxmWXu3Ro6d69uylZ599QomJiQoI2KqIiAiVKlUqx/0EgMIiJj5Z384/qKjYJJvye5pW0tO9GykqMs5BPQMch3ySf8goZJTcIKOQUQA4pxMXIvTz8iO6dQ2AVwc1U4t65ZlN/A7UqFHDsn358mVVrZr17+0rV27OUFupUqXbat+e0NBQmUymbNtPTU3V5s2bJUl+fn5q0aJFjvpS1JBR8gf5hHySG+QT8gkA57Vo8xlt/8d2BYcS3m765IUO8i3uofBwBuDA+ZBR8gcZhYySG2QUMgoA5xSfmKKJCw4qLNJ2VbNmdcpq9OBmuhGd4KCeOQYDcOC09hwP0//WnlB0nPMFMx9vNz3+QD21qc+Sh1k5ceK4DhzYJ0nq2LFzhlAmSeXKldfLL7+uTz55TyaTSevXr9Xw4c/o2LEj2rt3tySpceOmGjPm35kGrqeeelYnTwZp06b1OnfurDZv3qCuXXtk2p8nnxxhE8okqXx5P7Vv31Fbt6Z9ENyqVVubUJauV68+2rhxnSTp7NkzWQazMmXK6qOPJlhCWbqaNWtp7Ni39MEHbys5OVkLF87T66//K9M28sulSyEKCjouSere/YEMoSxdnz79NG3aVF27dk0XL17I0z78/vtMSZKLi4smTPiPTShLV69efb377od6883XZTabNWvWTP3nPxMzba9Onbo2oSxdjRo11bVrD61e/ZfMZrOOHz+qDh3uydNrAQBHS0xO1fcLDupKuO0gm0a1ymjssJZyyecH8YGCaPexUM1afZx8giyRUW4io6QhowBA3gm+GqNJiw4rJdV2+M2wnvXUo211paaaHNSzosHf39+yffLkSbVtm/nv/vT9kmQwGFSnTuYzyd6qVKlSKlOmjK5fv245PiunTp2ybNetWzfLev/8849lNZ5u3brJ4IQrIJFRyCj2kE9uIp+kIZ8AQN5avy9YK3eetylzdzXq/WfaqXK54mQUOCUyChnFHjLKTWSUNGQUAMg7KakmTV36j85fuWFTXrOSj94d0VZuri5ZHFl0ZXynADiJ/65yzlAmSdFxyfrvquOO7kaBtmPHNsv2wIFDsqzXpct9evrp5/XBB5+qW7f7JcmyPKYkDR36RKahLJ114EsPWJnp3v2BTMsrVrw5S2PnzvdmWsfPr4JlOzY2Jstz9O3bX8WKFc903333dVPZsuUk2b42d0vFipW0ZMlKTZ48Xc8880I2dStLkhIT825E7eXLl3Tu3BlJUvv2He0uadqxYyfVqpX2UMHu3Tuz7EeXLt2ybMPf/+bDBdazOQBAUZBqMmnan0d0+lK0TXnlcsX0zlNt5O7mfKEMkKSZfx0jn8AuMootMgoZBQDySnh0gr6bf1DxibazR9/XorIGdcvZABDY16JFC7m5uUmSdu3alWW91NRU7dmzR5JUv359+fj45Pgcbdq0kSQdO3ZMN25k/btq586dlm17A4EOHDhg2W7WLOPMp86AjEJGsYd8Yot8Qj4BgLy093iY/vg7yKbMaDBoZL/GqluNGfXhvMgoZBR7yCi2yChkFADIKyazWTNXHtORs+E25WVLeur9Z9rJ29PNQT1zLAbgAEAmjh07IiltpsXGjZtmWc/Dw1PPPvuiHnjgIctynUeO/GPZ36KF/aUv69Wrr+LFS0iSjh49kmkdT09Pm3BlzTpIpS+Lmtnx6VJTU7PsS5s27bLcZzQaLa9DSEiwZfbHu8VgMKhcufJq3rxlptcZHR2tffv26JdfpuvixbSZgOxda24dOXLYst2qVZts67dqlfbhfUpKioKCTmRap0aNmlkeX7z4zfuaksLS4QCKDrPZrFlrghR46ppNeakSHhozqJmKezlnKAOAnCCj2CKjkFEAIC/EJiTru/kHFXEj0aa8RZ2yeuL+uk656kl+8PHxUfv27SVJGzZs0KVLlzKt99dffyk8PO1DvIceeihX5+jZs6ektN9Tc+bMybROTEyMlixZIkmqWbOm6tevn2V7hw/f/F3bqFGjXPUFcAbkE1vkE/IJAOSVExciNH35UZlvKR/+YD01r13WIX0CgMKAjGKLjEJGAYC8smjTae04EmpTVtzLTWOHNFdpH88sjir6XB3dAcBRRjxUX/9be8IpZ0dIX5oUWUv/oNfHx0fe3t65OjYyMu3YEiV8sp2l0WAwqFKlSgoKOqGIiOuZ1ilRImczPd66pKj1OXKiatXqdvdbh8Pw8Ovy9fXNUbt5LSQkWAEBW3Tq1EldvHhBISHBCg/P/LXLKxEREZbtSpUqZ1vfuk7699KtspqFQkpb/jSd2Xzrn1cBoPBaFnBOWw7aPmjl7eGqsYObOXUoAyTp6YcbaNZq51ylk3ySM2SUjMgoacgoAHB7klNS9cOiwwq5FmtTXrtySb34SCMZjQy+yUsjRozQ1q1blZycrLFjx2rGjBk2DyecOnVKEyZMkCQVK1ZMgwYNylX7PXr0UJUqVRQcHKwpU6aoZcuWat365kMzSUlJevPNNy0PnDz99NN22zt16pQkyc3NTf7+/rnqS1FBRiGj2EM+yYh8koZ8AgC3L+RqjH5YdFgpqSab8n6daureZpWyOApwHmQUMoo9ZJSMyChpyCgAcPvW7rmoVbsu2JS5uxn12qCmqlA6d79vixoG4MBptalfXq3qllNMgvMFs+KebnyAnI0bN6IlZR127ImLi5MkeXl55ah++jkSEjJfwtL6TXp+yi6AWs+wEBcXa6dm/oiLi9M333yhtWtXZRpWSpQoobZt2+v48WMKCQnO43PfvF5Pz+zvq/VrlZAQn2mdu3VfAaCg2BwYoj+3nbUpc3UxavTApqpcLus/VgHOom0DP7WoXZZ8giyRUTIio6QhowBA7plMZv28/KiCLkbalFcs463RA5vK3Y3/E/Nap06d1LNnT61Zs0YHDhxQ3759NXToUFWsWFFHjx7VnDlzFBub9vvtzTffVOnSpW2O37Vrl4YPHy5Jatu2rWbNmmWz393dXePGjdOoUaOUkJCgESNGaNCgQWrZsqUiIyM1f/58BQUFSZJatmypgQMH2u3vhQtpHyr6+vo67e9IMgoZxR7ySUbkkzTkEwC4PeHRCfp2/kHFJdrOmt+leSX1uaeGYzoFFDBkFDKKPWSUjMgoacgoAHB7dh0N1dz1J23KjAaDRvVrLP9KJR3Uq4KDAThwakajQT7e7o7uBrKRlJR418+ZHpYSEzMPS/akv3GPj8/8Dfmt0uvdTgjMS8nJSXJ3z/rnIT4+zrJdsqRvrtu/k/toMpn05puvKzBwv6S04NOyZRvVq1dfNWrUkr9/bdWsWVMuLka9+OIzeR7MrEN2VkHLmvVrZR3SAMBZBZ68pt/X2C7VbJD04iMNVbeqr0P6BBRE5JPCg4xyd5BRskZGAYDbZzabNWf9Se09cdWmvGRxd40Z3EzFvdwc1LOi78svv1RsbKy2bdum4OBgffXVVzb7DQaDXnnlFT322GO31X63bt304YcfasKECUpOTtYff/yhP/74w6ZOkyZNNHXqVLsPTcTExFgevilRosRt9aWoIKMUDuSTu4N8kjXyCQDcmdiEZH03/6Aibtj+Lmheu6yeeKBujldCAJwBGaVwIKPcHWSUrJFRAODOHDsXrhkrjmYoH/FQfTX1L+uAHhU8DMAB4DBGo9GynZqammW9mJiYu9EdG6VKlZIkRUdHKz4+3u4sB4cPH1SxYsVUqVIVeXp6qnTpMpLSZleIjo62uzyp2WzWpUshkqRy5crl4RXkXlhYmGrWzHoFgsuXL1m2y5S5+Uv0btzHdevWWkJZw4aN9eWX31nu0a39uHEj779f0u+pJMv9sufixYuW7bJly+d5fwCgMDkdEqWf/vxHt05q8/gDddWqHv9HAihYyChklJwiowBA4bV61wWt32f7ob6nu4vGDGqmsiVzNtMpbo+Xl5dmzJih5cuXa+nSpTp27Jhu3LghX19ftWrVSsOHD1erVq3u6BxDhw5V69at9dtvv2n79u26evWq3NzcVLduXfXp00eDBw+Wm5v9QVbpK/FIsvu+Cchv5BPySU6RTwCg8EpOSdUPiw4r5JrtygT+lX30Yt9GcrH6PQIAjkZGIaPkFBkFAAqvC6E39MPiw0o12T7o1f/eWurUtKKDelXwkNQAOIz1B532lro8e/b03eiOjXr1GkhKC05Hj/6TZT2z2axx497U8OGP6ZVXXpAkNWjQ0LL/wIG9ds9z9OgRy7X7+9e5027fkX/+OZTlvpSUFP3zz2FJaa+N9TKmd+M+bt++1bL90kuvZghl6RIS4hUcfMHydWZLmN6OBg0aWbb37duTbf30++7i4qKaNWvmSR8AoDC6fD1W3y88pKQUk035wx2qq1vLKg7qFQBkjYxCRskpMgoAFE47/rmiBZts//93MRr0Sv8mqubn3Cud3C0Gg0GPPPKIfv31V+3YsUP//POPtm3bpu+//97u4Jt27drpxIkTOnHihGbNmmX3HHXq1NH48eO1YcMGHT58WPv379fcuXP1+OOPZzv4RpL8/Pws55o3b16urxHIK+QT8klOkU8AoHAymcyavvyogi5G2pRXKO2t1wY2k4db1qs2AoAjkFHIKDlFRgGAwulaZLy+m39QCUm2AzS7tayshztUd1CvCiYG4Pw/s9ms5cuXa8SIEWrXrp2aNGmibt266a233tKhQ1m/WcmNoKAgvfPOO+rWrZsaN26sDh066IknntDChQvtjia25+DBg2rQoIG6det2R32bMWOG6tWrp3r16ik4OG+X9AOyUqpUact2UNCJTOvExcVq166dd6tLFh07drJsL1u2OMt6+/fvVXj4dUlS69ZtJUmdO3ex7J87d7ZMJlOmx0rSH3/8luk5HeHPPxdn2df169cqIiJcku31SXl3Hw2GtF9JmYWp6Ogoy7aXl3eG/ekWLVqgpKQky9cpKSm3nOPm8ty5CW2VK1dRzZq1JEk7d27XmTOnsqy7bdsWnTt3VpLUvHlLeXsXy/F5AKAoiYxJ1HfzDyomPtmm/J4mFdT/3loO6hUA2EdGIaNYI6MAQNFy5Gy4fl15LEP5sw83UMMapTM5AgAci3xCPrFGPgGAosVsNmvOupPad+KqTXnJYu4aO7iZintlP3AcAO42MgoZxRoZBQCKlhtxSfpm/kFFxSbZlLeqV07DetS1+T8ZDMCRJCUkJGjkyJH617/+pR07digyMlJJSUkKCQnR0qVL9dhjj2n69Ol3dI4FCxaof//+Wrx4sUJCQpScnKzw8HDt2bNH48aN0/DhwxUZGZmrNmNjY/Xee+/ZfdOXE6dPn9akSZPuqA3gdljPILB8+VJdu2b7x6WkpCR99tknioyMuNtdU7NmLSyzI6xf/7f+/DNjOLt+/Zq+/fZLSZKrq6v69OknSapfv6FatmwtSTp8+JAmTvwq00F2v//+qzZv3ihJql69hrp1uz8/LiXHjh8/qp9+mpyh/OTJE/r++28kSSVLltSjjw602Z9X99HT00NS2pKut6pQ4ebSdcuXL8n0+DVrVmnatKm3nDvxlnN4WrYzO489w4YNl5S2/Oq4cW/qypUrGeqcPHlCX3zxqaS0EPjUU8/m6hwAUFTEJ6Zo4vyDuhaVYFPepFYZPfVgfUIZgAKLjEJGsUZGAYCi4/yVG5q85LBSTbYf1A/uWlvtG1VwUK8AwD7yCfnEGvkEAIqWlTvPa/1+28lxPd1dNGZwM5X19XJQrwDAPjIKGcUaGQUAio7EpFR9v/CQQsPjbMrrVvXVC30aymjkOa9buTq6AwXBuHHjtGnTJkmSv7+/Bg8erLJly+rIkSOaO3eu4uLi9M0338jPz099+/bNdftbt27V+++/L7PZLC8vLz322GNq3Lixrl+/roULFyooKEh79+7V2LFjNWPGDBmN2Y+LSkpK0qhRoxQUFJTr/lhLTU3Vu+++q8TExOwrA3msVq3aatCgoY4dO6rw8Ot67rnh6t9/kCpWrKTLly9pxYo/delSiKXO3TZu3Id6/vmnlJiYqK+++kxbtmzSvffeJy8vL50+fUp//rlYMTE3JEkjRjynypWrWI59550P9OyzTyo6OkqLFy9QYOB+Pfjgw/Lzq6iIiOtat26tZSlQd3cPffjheLm7u9/1a7RmMBj0xx+/659/DumBBx5SsWLFdOTIYS1btsQy28Arr4xRyZK+Nsfl1X0sV85PZ8+e0ZkzpzVt2hTVrVtPfn4V1LBhYz344MNatiwtkP3552JdvnxJnTp1kY+Pj0JDr2jLlk06cuRwhjZjYmJUrFhxm3Ok++WXaUpKSpbJlKoePXrK1dX+r8SHHuqtgIAt2rRpgy5evKAnnxys3r37qkGDRjKZUnXw4AGtXv2XkpPTVnoYOvRJS0AHAGeSkmrS5MWHdSEsxqa8RoUSeqlfI7m6MAcAgIKLjEJGsUZGAYCi4WpkvL5bcFCJSbYPTtzfuqp6tq3qoF4BQPbIJ+QTa+QTACg6Ag5f1qLNZ2zKXIwGvdq/iar5lXBQrwAge2QUMoo1MgoAFA0pqSb9+Oc/OnPJdqBj5XLFNHpAE7m5ujioZwWb0w/ACQgI0IoVKyRJ7du31/Tp0+XhkTY6t3fv3ho4cKCGDRumyMhIffbZZ+revbuKFy9ur0kbSUlJ+uijj2Q2m+Xt7a3Zs2erUaNGlv1Dhw7V2LFj9ffffysgIEArV65U79697bZ5/fp1vfbaa9qzZ89tXLGtmTNnKjAw8I7bAW7X++9/otGjX9K1a1d17dpVTZ9uO7K9efOWevPNcRo2bMBd71utWrU1ceJUjRv3psLDr2vXru3atWt7hnrDhj2pESOesymrWLGSpk6dobfffkPBwRd05sxpTZ2acaWpihUrafz4/6hu3fr5dh059dxzIzVnziwdOhSoQ4cCbfa5urrqrbfe00MPZf7/U17cxx49HtDu3TskSbNmzZQkdet2vz755HM1bdpcTz/9vGbO/FmStHv3Tu3enXGp0/vu66Y6derp559/lCSdPn1Kfn43ZzGtX7+BqlSpquDgizp79ow++eS9/y9vqBo1atp7eSRJH344Qd7en2nlyuWKj4/TggVzMtRxcXHRiy++bJlJAQCcicls1q9/HdOx87az4ZT39dLrg5rJ093p4weAQoCMQkZJR0YBgMLvRlySvp1/UNGxSTblbeqX15DutVmdE0CBRz4hn6QjnwBA0XD4zHX9d9XxDOXP9W6oBjVKO6BHAJA7ZBQySjoyCgAUfmazWb+vOaFDp6/blJf28dDYwc3l7enmoJ4VfE7/BNyvv/4qKe1Nx/jx4y2Db9L5+/vr/fff1xtvvKHIyEgtWLBATz/9dI7bX7t2rYKD05aNfe6552wG30iSu7u7vvzyS+3Zs0eRkZGaNm2a3QE4O3bs0Ntvv53pkni5dfr0aU2alPZG0cfHR9HRuVumD8gL1arV0OzZCzRv3v+0ZctGhYQEy9XVTTVq1NRDD/VW7959HbI0abomTZpp7tzFWrRogbZu3aQLF84rISFepUuXUdOmzTVw4BA1btw002Nr1KipWbPmaeXK5dq8eYNOngxSTMwNlSpVWlWrVtP99z+oHj162iyX6UhNmjRTz54P67ffftHOnQGKiAhXmTJl1bZtBw0d+riqVauR5bF5cR979eqjxMRELVo0X5cuhchgkBISEiz7n332RTVp0kyLF8/X0aNHFBUVKXd3D5UtW1YNGjRS796PqG3bdjpz5owlmG3Y8Lc6duxkacPV1VUTJ07V5MkTFRi4Tzdu3JCPT0ldu3Y1R8HMzc1N7777oR555FEtW7ZEgYH7df36Nbm5uatixYpq27aDHnnkUZtZMgDAmSzceFo7j4balJXwdtPYIc3kU8yxMwABQE6RUcgo6cgoAFC4JSanatLCQwoNj7Mpr1/NV8/1bigjg28AFALkE/JJOvIJABR+Zy9Ha+qSf5RqMtuUD+lWW+0a+mVxFAAULGQUMko6MgoAFH5Ltp7VtkOXbcqKebpqzODmKlXCI4ujIEkGs9lszr5a0RQZGakOHTrIZDKpa9eu+umnnzKtZzKZ1KlTJ12/fl3NmzfXvHnzcnyOUaNGaf369TIYDNq+fbtKl858xoovv/zSMhho9erVqlnT9g1CeHi43n//fa1bt85SNmDAAG3btk2hoaGqXLmyNmzYkON+paamatiwYQoMDFTbtm1VqVIlLV26VJK0fv16Vani+DcVERFxSklJzXH9sLBgmUypMhpdVL585v13cTHKYJDMZik11ZRXXUUBxf3O3i+/TLPMNjBp0k+FeilN7rdzuXo1RGazSW5ubipVqkL2B6BQK126mFxcjEpNNSk8PNbR3UEW1u65qLnrT9qUebi56M1hLVSzok+O2nDUvXZ1dVGpUt537XwovMgouFPc7+yRUVAYkU+cC/mkcEg1mTRl8T8KPHXNprxKuWJ6+/GWOZ61jYyCgiy3+UQioyAj7rd95BMUVmQU50JGKRzCIuL02ax9io5Ltil/oE1VPda9To7bccT9Jp8gp/LjMxSJ9zHOhHudPTIKCisyinMhoxQOG/YHa/baIJsyN1ej/vVYc9Wp4pujNpz5MxSjQ8/uYHv37pXJlPbLu3379lnWMxqNatOmjSTp4MGDioqKyvE59uzZI0mqV69eloNvbj3/li1bMuw/efKkZfBNsWLFNH78eH322Wdydb29RYxmzpypwMBAeXl5acKECTIw2x8AAABu0+5joRkG37gYDRr1aOMcD74BAAAAgLxgNps1a01QhsE3pX08NGZw8xwPvgEAAACAvBAdm6Rv5x3MMPimXUM/De5W20G9AgAAAOCs9p0I0/9uGXxjMEgjH2mU48E3zs6pB+CcPHnzIcG6devarVu7dlroNZvNCgoKsls3XWhoqKKjoyVJderYn7HC39/fsn38+PFM6xiNRj366KNatWqVBg0alKM+ZOb06dOaNGmSJOn1119XtWrVbrstAAAAOLdj5yM0Y8XRDOUjHqqvJrXKOKBHAAAAAJzZ8oBz2nLwkk2Zt4erxgxqplIlPBzUKwAAAADOKCEpRRMXHFRYZLxNeYPqpfRMrwYyMlkuAAAAgLvoxIUITVt2VOZbyp/sWU8t6pZzSJ8Ko9tbPqWICAkJsWxXrlzZbt0KFW4uexYSEmJZEcee4ODgHLfv5+cno9Eok8mkS5cuZdhfo0YNrVmz5o4Hy6Smpurdd99VYmKiWrRooeHDh99RewAAAHBeF0JvaPLiQ0pJtY1lA7rU0j1NKjqoVwAAAACc1ZaDl7R021mbMlcXo0YPbKrK5Yo7qFcAAAAAnFFKqkk/Lj2ic1du2JRXLV9cr/RvIjdXp54zGQAAAMBdFnw1RpMWHVZKqsmm/JF7aui+5vbHOcCWUw/ACQ8Pt2yXKlXKbl1fX1/LdmRkZI7aj4iIyHH7bm5u8vb2VkxMTKbt+/n55eic2Zk5c6YCAwPl7u6uCRMmyGgk0AMAACD3rkXF67sFBxWfmGpT3q1lZfVqX91BvQIAAADgrAJPXdPvq0/YlBkkvfhIQ9Wt6uuQPgEAAABwTmazWb+tPq7DZ67blJfx8dSYwc3k5eHUj2sBAAAAuMvCoxP03fyDik9MsSm/t1kl9e1U00G9KrycOtElJCRYtj08POzWdXd3z/Q4e+Ljby4hm1376XViYmJy3H5unT59WpMmTZIkvfrqq/L398+X8+QVHx/PXNWPiHBVcrJJBoNBLi6ZDyxKX73XYFCWdVB0cL+zZzTeXNLaxcVYqF8n7rdzMhik0qWLObobyGfp/1cZjQbudwERHZukSYt2Kyomyaa8Q5OKenlwC7lY/X7JDe41AAAAgNtx+lKUflr6j0xm29U5h91fV63qlXdQrwAAAAA4qyVbzyjg8BWbsmKerho7pJl8i2f//BAAAAAA5JWY+GR9My9QETcSbcqb1y6rJ3vWlcFwe895OTOnHoCTknJzFJf1AJvMWO+3Ps6e1NSbs4Fn1751nZy2nxupqal69913lZiYqEaNGunZZ5/N83Pktdw+QJ/282+w2s5JfTgL7nfmnn9+pJ5/fqSju5HnuN/OhQFXziNtkC0/4I6WmJyqz3/bo+CwGJvyRrXK6F+Pt5K7m8sdn4N7DQDO69lnX9Szz77o6G4AAAqRK+Fx+n7BISWlmGzKe7Wvru6tqjioVwCAooB8AgC4HRv3B2vF9vM2ZW6uRr02sJkqlmHyMQDA7SOjAAByKyk5VZMWHdLl63E25bUrl9SLfRvJxcizl7fDqQfgeHreXGElOTnZ7iCZpKSbs3vnZDCNZLvqTXJycrb108/h5uaWo/ZzY+bMmQoMDJSbm5s+//xzubjc+YOR+S011ZR9JStpkxuarbYzsn4oP6s6KDq4386F++28cvv7AoWP0WiQwWCQ2WyWycQPuCOlppr0n9l7dexcuE15Nb8Semd4a7kYDXf0M+nIe81gPgAAAKDwiYpJ1LfzAhUTb/v3946NK2hAl1oO6hUAAAAAZ7XvxFXNXhtkU2YwSCP7NlLtKiUd1CsAAAAAzijVZNK0ZUd0KjjKprxiGW+NHthUHnkwybKzcuoBON7e3pbtxMTEHA/AsR5Yk5v2s5Nex3pgUF44ffq0Jk2aJEl68cUXVa9evTxtP79ERycoJSU1+4r/Lzk5RSaTWUajOcsHP11cjDIY0h7O54Htoo/77Vy4387JbJbCw2Md3Q3ks9Kli8nFxSCTycz9diCz2axZa05o95FQm/JSJTw0ekATJSUkKzwh+0Hn9jjqXru6uqhUKe/sKwIAAAAoMOITUzRxwSFdi0qwKW9Us7RGPFRfBpZIBgAAAHAXBV2M1LRlR3Tr9GJP9qynFnXKOaRPAAAAAJyT2WzW/9YG6cDJazblvsXdNXZwcxX3yvvFQpyJU0/z7OPjY9mOjIy0W9d6f+nSpXPdflRUlJ2aaSvkxMXF5ar9nEhNTdW7776rxMRE1a1bVyNHjsyztgEAAOA8lm8/p02Bl2zKvD1cNWZwM5X2ydsB5AAAAABgT0qqSVOX/qPzoTdsyqv7ldCofo3lygqXAAAAAO6ikGuxmrTwkFJumSjykXtq6L7mlR3UKwAAAADOKrPnvLw8XDV2cHOVKclzXnfKqVfAqVGjhmX78uXLqlq1apZ1r1y5YtmuVKnSbbVvT2hoqEwmU67az4nLly8rMDBQkhQUFKTGjRtne0z37t0t2ydOnMizvgAAAKBw2nLwkpZuPWtT5upi1KsDmqhKueIO6hUAAAAAZ2Q2mzVz5XEdORtuU162pKdeH9RUXh5O/bEHAAAAgLssPDpB380PVFxiik35vc0qqm+nmg7qFQAAAABnlflzXgaNHtBEVcrznFdecOpp4Pz9/S3bJ0+etFs3fb/BYFCdOnVy1H6pUqVUpkyZHLV/6tQpy3bdunVz1D4AAACQ3w6euqbfV9sOyjZIeqFPQ9WrVsoxnQIAAADgtBZvOaMdR67YlBX3ctMbQ5qrZHEPB/UKAAAAgDOKS0jWdwsOKjw60aa8mX8ZPdmzngwGg4N6BgAAAMAZHTh5Vb+tPm5TlvacVyOe88pDTj0VXIsWLeTm5qbk5GTt2rVLjz/+eKb1UlNTtWfPHklS/fr15ePjk+NztGnTRqtXr9axY8d048YNlShRItN6O3futGy3bds2F1dhX5kyZTRlypRs6/3+++/atWuXJOmTTz6xDBwCAACA8zp9KUo/Lv1HJrPZpnzY/XXVun55B/UKAAAAgLNavy9Yf+04b1Pm7mrUa4Oayq+0t4N6BQAAAMAZJaek6odFhxVyNdamvFYlH43s21guRqeeExkAAADAXXYqOEo//XlEtzzmxXNe+cCpB+D4+Pioffv22rp1qzZs2KBLly6pUqVKGer99ddfCg8PlyQ99NBDuTpHz549tXr1aqWkpGjOnDl64YUXMtSJiYnRkiVLJEk1a9ZU/fr1b+NqMufl5aUePXpkW2/dunWW7XvuuUdVqlTJsz4AAACg8LkSHqfvFxxSUorJprxX++rq3or3igAAAADurn0nwvTH30E2ZUaDQSP7NZZ/pZIO6hUAAAAAZ2Qym/XzimM6cTHSptyvtLdeG9hUHu4ujukYAAAAAKd06Vqsvl94UMm3POf1cAee88oPTj/dwogRIyRJycnJGjt2rGJiYmz2nzp1ShMmTJAkFStWTIMGDcpV+z169LAMZpkyZYr27t1rsz8pKUlvvvmmIiMjJUlPP/30bVwFAAAAkHeiYhL17bxAxcQn25R3bFxBA7rUclCvAAAAADiroIuRmrbsqG6ZtE3DH6yn5rXLOqRPAAAAAJyT2WzW3HUntfd4mE15yWLuGju4mUp4uzuoZwAAAACcUcSNRH03P1CxCSk25fc0rqD+9/KcV35w6hVwJKlTp07q2bOn1qxZowMHDqhv374aOnSoKlasqKNHj2rOnDmKjU1bLvbNN99U6dKlbY7ftWuXhg8fLklq27atZs2aZbPf3d1d48aN06hRo5SQkKARI0Zo0KBBatmypSIjIzV//nwFBaXN2teyZUsNHDjwLlw1AAAAkLn4xBR9t+CgrkUl2JQ3rllaIx6qL4PB4KCeAQAAAHBGIddiNWnhIaWk2s7a1rdTTd3bLOOK9gAAAACQn1bvvqB1+4JtyjzdXfT6oGYq5+vloF4BAAAAcEZxCcn6bn6grkcn2pQ3qVVGT/GcV75x+gE4kvTll18qNjZW27ZtU3BwsL766iub/QaDQa+88ooee+yx22q/W7du+vDDDzVhwgQlJyfrjz/+0B9//GFTp0mTJpo6dapcXFiGFgAAAI6RkmrSlCWHdSHUdlXI6hVKaNSjjeXq4vQLaAIAAAC4i8KjE/Td/EDFJdrO2nZvs0p65J4ajukUAAAAAKe1458rWrDxtE2Zi9Ggl/s3UfUKJRzUKwAAAADOKDklVT8sOqzgq7E25TUrltCofjznlZ8YgCPJy8tLM2bM0PLly7V06VIdO3ZMN27ckK+vr1q1aqXhw4erVatWd3SOoUOHqnXr1vrtt9+0fft2Xb16VW5ubqpbt6769OmjwYMHy83NLY+uCAAAAMgdk9msmSuP6ei5CJvycr6een1QM3m6Ex0AAAAA3D1xCcn6bsFBhd8ya1vz2mX1ZM+6zNoGAAAA4K46cjZcv648lqH8mYcbqFGN0g7oEQAAAABnZTKZ9fPyozpxMdKm3K+Ul14b1Ewe7iwIkp94iu7/GQwGPfLII3rkkUdydVy7du104sSJHNWtU6eOxo8ffzvdy9KGDRvypJ0vvvhCX3zxRZ60BQAAgMJn0abT2nEk1KasuJebxg5urpLF3B3UKwAAAADOKDnFpMmLDyvkllnbalXy0Yt9G8nFyKxtAAAAAO6e81duaPKSw0o1mW3KB3X1V4dGFRzUKwAAAADOyGw2a866k9p74qpNecli7ho7pLl8vHnOK7/xKRUAAADg5P7ee1Grdl2wKXN3M+r1Qc3kV9rbQb0CAAAA4IxMZrNmrDiq4xcibcr9SnvrtYFN5eHGrG0AAAAA7p6wyHh9t+CgEpNSbcp7tK6iB9tWc1CvAAAAADirlTvPa/3+YJsyT3cXvT6omcr5ejmoV86FATgAAACAE9t9LFRz1520KTMaDBrVr4lqVfJxUK8AAAAAOCOz2ax5609pz/Ewm3KfYu4aO7iZSjBrGwAAAIC7KDouSd/NC1R0bJJNeZv65fVY9zoyGAwO6hkAAAAAZxRw+LIWbT5jU+ZiNOjl/k1UvUIJB/XK+TAABwAAAHBSx89HaMaKozLfUj7iofpq6l/GIX0CAAAA4LzW7L6ov/detCnzcHfRGGZtAwAAAHCXJSal6vsFhxQaEW9TXr+ar57r3VBGBt8AAAAAuIsOnb6umSuPZyh/tncDNapR2gE9cl4MwAFQIA0c2EedOrXWwIF9Muzr1Km1OnVqrVdeeeG2209vY8KEj2zKL1++lOU+4E6dPBmkTZvW5+s5UlJS9N//zsh034QJH1m+vy9fvpSv/QBQ8AWHxeiHxYeVkmo7/ObRe2upU9OKDuoVABRcZBQURWQUAAXJziNXNH/jKZsyF6NBrzzKrG0AcCvyCYoi8gmAgiTVZNKPf/6js5ejbcqrlCumV/o3lZsrj1sBgDUyCooiMgqAguTMpWhNXXpYJrPtc16Pdaut9g0rOKhXzotECABAPktJSdG0aVP03HNP6vTpU9kfcJuOHz+mZ555XDNm/JRv5wBQNFyPStC38wMVn5hiU961ZWX17lDdQb0CAAB3CxkFQEFz9Fy4fvnrWIbyZ3o1UKOazNoGAEBRRj4BUNCYzWb9tvqEDp2+blNexsdDYwY3l7enq4N6BgAA7gYyCoCCJjQ8ThMXHFRSssmm/MG21fRA22oO6pVzIxUCAJDPrl4N06xZM/P9PIsWzdOZM6fz/TwACreY+GR9Oz9QkTFJNuUt65bT4z3qymAwOKhnAADgbiGjAChILoTe0OTFh5Vqsp21bdB9/urQmFnbAAAo6sgnAAqapVvPatuhyzZlxTxdNWZwc5Uq4eGgXgEAgLuFjAKgIImKSdQ38wIVE59sU96+kZ8GdvV3UK/AABwAhc62bXvzre2KFSvla/uAI40b95HGjfvI0d0A4EBJyamatOiQLl+PsymvXaWkXujTUEYjg28A4HaQUYDbQ0YBcC0yXt/NP6iEpFSb8u6tqujBdszaBgC3g3wC3B7yCQBJ2nQgRMu3n7Mpc3M1avTApqpUtphjOgUAhRwZBbg9ZBQA8Ykp+m7BQV2LSrApb1ijlJ7p1UBGJll2GKOjOwAAAAAg/5lMZk1bdkSngqNsyiuW8dboAU3l7ubioJ4BAAAAcEZpq3MeVFSs7eqcreuV09DudVidEwAAAMBdtT/oqmatPWFTZjBILz7SSHWq+DqmUwAAAACcUkqqSVOWHNaF0Bib8up+JfTyo03k6sIQEEfi1QcAAACKOLPZrP/9HaQDJ6/ZlJcq4aGxg5uruJebg3oGAAAAwBklJafq+4UHdSXcdnXOulV99TyrcwIAAAC4y04FR2nasiMym23Ln3ignlrWLeeYTgEAAABwSiazWb/+dUxHz0XYlJfz9dTrg5vJy8PVQT1DOu4AgHwXFhaqRYvma/fuHQoODlZqaop8fUupbt166tKlmx544CG5uOR81v1OnVpLkpo3b6nJk6dnWuf48WNauHCO9u3bq4iIcPn6llKrVm30+ONPqVYt/yzbvnz5kgYNekSS9NBDvW2Wcdy/f69Gjx4pSZoyZYaaNm2mVatWaNWqFTp79rTi4uJVvnx5tW9/j4YOfUJ+fhXsXseRI/9owYI5OnjwgCIiwlWyZEk1bdpCjz32hBo1aqyxY1/V7t077F5nXrh6NUzLly9VQMBWXb58SQkJ8SpXrrxatGilgQMfU+3adbI8NioqUkuWLNSOHQG6cOG8EhLi5etbSg0aNNIDDzyo++7rnulx1q/zRx9NUI8ePbV+/Vr9+edinT59UklJSapYsZLuv/9BDR48TB4eHpKks2fPaM6cWdq7d7flvrZt215PP/28KleunOE8r7zyggID96tJk2b68cdfFBR0XL//PlOHDwcqOjpapUuXUevWbTV06JOqUaNmpn1Nb0OyvyzuhAkfadWqFZKkBQuWqWLFSjbXmW7mzJ81c+bPkqRJk35Sy5atbfafOXNaq1at0P79exUaekUxMTfk6empMmXKqmnTFurXb4Dq1auf5bnTZfZzklkfb2UymbRly0atWbNKx44dUVRUpLy8vFWlSlV17NhJAwYMUYkSJey+Vq1atdX3309VSEiw5s37n3bt2qGrV6/Ky8tTderUU69ej+j++3syky1wF63YcV4bD4TYlHl5uGrMoGYqU9LTQb0CAMcho2SOjEJGIaOQUYC7IdVk0rRlR3Q6JNqmvHLZYnp1QBO5ubI6JwDn4qh8smDBH9q/fx/5JBvkE/KJNfIJUDRdvh6r7xceVHKKyaa8d8ca6toi4/+fAFDU8RlK5sgoZBQyChkFuFsWbDylnUdDbcpKeLtp7ODmKlnM3UG9gjUG4ADIV3v27NK77/5b8fG2s1mGhYUqLCxU27Zt0dy5/9PEiVNUqlTpPDnnggVzNWnSNzJbTU9z7dpVrVmzUhs3rtcHH3xyx+dISkrQ2LGvaM+eXTblwcEXtXDhXK1YsVRffvmdWrVqk+nxf/wxSz/+OMmmj9evX9fGjeu0efMGjRo1+o77mBNr167SF1+MV1JSok15SEiwQkKCtWrVCr388msaPHhYhmM3b96ozz//RDExN2zKr14N09WrYdqyZaOaN2+p8eP/I19f3yz7kJKSovfee1ObNm2wKT9z5rSmTZuiXbt2aOLEqdq6dZPGj/9QiYk3+3r1apj++muZAgK26Oeff1PVqlWzPM/mzRv18cfjlJSUZCkLDb2iv/5apjVrVur99z9V9+73Z3l8fjOZTJo06VstXjxfJpPtH3djYmIUExOj8+fPafnyJXrhhVEaPvyZPO9DWFioPvzwXR0+fNCmPDk5SkePRuno0X80f/4cffDBp2rfvqPdtrZs2aRPP31f8fHxlrKkpETt3btbe/fu1vr1azRhwldydeWtCJDfth66pCVbztiUuboY9Gr/JqpSvriDeoWcMJvNWrFihRYtWqRjx44pLi5O5cqVU5s2bfT444+radOmd3yOoKAgzZw5U7t27VJYWJhKlCghf39/9evXT48++mi2fzw3m81av369/vzzTx06dEjh4eFyc3NT5cqVdc8992j48OGqVCnjHwKtdevWTSEhIXbrpNu2bZvKlWO2QdwZMgoZhYySM2QUAPnBbDbrf2szX51zzOBmKubJ6pwAnAv5hHxCPskZ8gmA/BJxI1HfzgtUbEKKTXmnphX1aOfMH+wFgKKMjEJGIaPkDBkFQH5Zs/uC1uy+aFPm7mbU64Oaya+0t4N6hVvxvyGAfBMREaEPPnhH8fFxcnd3V69ej6hRo8Zyd3fXpUuXtGLFUoWEBOv06ZP67LOP9dVX39/xOZctW6Lvv/9akuTm5qZHHumnJk2aKz4+Xps3b9DOndv1ySfv3/F5vvvuK124cF4VK1ZS7959VaVKVYWFhenPPxcrOPiCEhIS9Mkn72nevD/l6Wm7ssDixQs0dWratbq7u6t3775q3LiZEhLitXHjOu3Zs0uTJ09U8eL5+1D06tV/afz4DyVJRqNRXbv2UJs27eTi4qJDhw5q5cplSk1N1aRJ38rPr4K6dOlmOTYgYKs++OBtpaamSpLatu2gzp27yMfHRxcunNdffy3TlSuXFRi4X6+88rymT/9N3t6Z//L/9dfpunQpROXKlVffvv1VqVJlnT17RvPm/aGkpEQFBu7X119/rrVrV8lgMGjgwCFq1KiJbty4oSVLFujs2TOKjIzUDz9M1H/+802m5wgNvaLx4z9QUlKSWrVqox49esrNzU07d27X+vVrlZKSoo8/HqdixYplGzhyo1Sp0vrss68VERGur776TJLUvfv96t69pySpVq3alrozZvykhQvnSpJ8fUupV6/eqlatutzdPXT58iVt2PC3Tp8+JUn6+ecf1bZtB9Wv30CSNHDgY+rc+T4tXDhX+/enzd7w2WdpPwclS/rmqK/R0dEaM+ZlnT9/TpJUsWIl9erVR9WqVdeNG9HasmWTdu/eqejoKL311hj95z8T1a5dh0zbCg6+oI8/Hqfk5GR1736/2rbtIFdXV+3fv1erVq2QyWRSQMBWLVo0T0OGPJ6LVxRAbh06fU2/rTphU2aQ9HyfRqpfvZRjOoUcSUhI0GuvvaZNmzbZlIeEhCgkJETLly/X66+/rhdeeOG2z7FgwQJ9/PHHSk5OtpSFh4crPDxce/bs0ZIlSzRlypQs/8AaFRWlMWPGKCAgwKY8KSlJQUFBCgoK0v/+9z99+umn6tevX6ZtxMTE6NKlS7d9DUBukVHIKGQUMgoZBXCsFTvOa1Og7fs/Lw9XjRncTKV9WJ0TgHMpCPmkT59+atasuRISErRx43ryiRXyCfnEGvkEKJriElL03fyDuh5t+xBzU/8yGt6zHrO8A3A6BSGj8BlK1sgoZBRrZBSgaNp59IrmbThlU+ZiNOjlR5uoZkUfB/UKmWEADpya2WSSOTHG0d246wwexWUwGvP9PH//vUo3bkRLksaN+0jduz9gs3/w4Mf00kvPKSjouHbsCNClSyGqVOn2l3COjo7WTz9NliQVK1ZMP/wwTQ0bNpTZLKWmmtSnTz8tWjRP33331e1f1P+7cOG82rfvqPHj/2MTvPr2fVQvvfSsTp8+pevXr2vHjm3q2rWHZX9ERISmT58iSfLxKamJE6eobt2by0w+8sijmj9/jiZN+kYxMfn3vRkVFakffvhWkuTp6ZlhFoeHHuqtbt166F//Gq3U1FRNmfK9One+T0ajUXFxsZow4SOlpqbKxcVF7777oXr27GXT/tChT+rDD99RQMBWnTt3VpMnf6c33xyXaV8uXQpR3br19f33P9oseVm7dl19+OE7kqQVK/6Ul5e3pkyZbvN6Pfjgw3rqqaG6fDlEAQFblZiYKHd3jwznCAtLW47vuedGasSI52yO79y5iz7++L3/n5ngG7Vu3TbPRut7enrq3nvv0+XLNx8sqVathu699z6behEREZo7d7aktEA0Y8bvGQLVk08+rS+++FQrVy6X2WzWunVrLMGsXr36qlevvrZu3WSpf+s5svPjj5Msoaxz5/v00Ufj5eFx83u7X7+BWrVqhT7//BOlpqbq008/0Lx5S1SsWMY/IISGXpGrq6u+/nqS2rZtbynv2bOXmjdvqQkTPpKUdl8JZkD+OXMpWlOX/iOT1Sw8kvRYjzpqU7+8g3qFnBo3bpxl8I2/v78GDx6ssmXL6siRI5o7d67i4uL0zTffyM/PT3379s11+1u3btX7778vs9ksLy8vPfbYY2rcuLGuX7+uhQsXKigoSHv37tXYsWM1Y8YMGW9572gymfTyyy9rz549kqRKlSppwIABqlWrlmJjY7Vt2zatXbtWSUlJevvtt+Xj46Nu3bpl6MeJEycsM0WNHDlSTZo0sdvvkiVL5vpaCxPySf4jo5BRyChkFDIK4DhZrc45ekATVSnH6pxAQURGyV+Ozifff/+jGjVqLINBMpulhx/uSz75f+STm8eTT9KQT4CiJznFpMmLDyn4qu3vk5oVS+ilvo3l6nJ3/l4JIHfIKPnL0RmFz1CyRka5eTwZJQ0ZBSh6jpwL1y8rjmUoH/FQfTWpVcYBPYI9DMCB00o+s1uJAbNljo92dFfuOoOXjzzueUJutdrm63kuXDhv2e7QoVOG/R4ennriiRGaPn2KKlWqoqioyDsKZqtWLVd0dJQk6cUXX1GDBg0z1BkwYIgCAw9o48Z1t30eKW3WhXHjPsow64G3dzENHjxMn3+etvzpsWNHbYLZ4sXzLYHr9df/bRMy0g0ePFRHj/6jdevW3FEf7Vm1aoWiotJeq2efHZnpEqpt2rRTr16PaPnyJbp0KURHjhxWkybNtHTpIsvr/NhjT2QIZVJaIPnoo8/05JODdeXKZa1atULPPPOCypYtl2l//v3vd2xCmSTdd183+fiUtJzr8ceHZ3i9vL291bVrd/3xx+9KTU3RhQvnVbt23UzP0aHDPTahLF337g8oMPCAlixZoAsXzisgYKu6dOmaaRv5Zfv2rZYlU5966tlMZzMwGo164okRWrlyuSTp4sXzGercrmvXrmrVqhWSpIoVK+vDD21DWbqHHuqtM2dOa86cWYqMjNCffy7RsGFPZtpm//6DbEKZdRu//DJNV65c1tmzZ5SYmJDpuQDcmdDwOE1ccFBJybZLHT/Urprub531Ms4oGAICArRiRdr/y+3bt9f06dPl4ZH2h8fevXtr4MCBGjZsmCIjI/XZZ5+pe/fuuZpRKSkpSR999JHMZrO8vb01e/ZsNWrUyLJ/6NChGjt2rP7++28FBARo5cqV6t27t00bS5YssQy+ad++vX788UebWZAGDRqkDRs26NVXX1VKSoo++ugj3XPPPZbrSHfixM0Vmvr166eaNWvm+DqKmqTTuxW/9XfyST4jo5BRyCg5Q0YhowB57dDp61muzlmvGqtzAgURGaXof4ZSvz75JCvkk5vIJ+QToCgymc365a+jOn4h0qa8fCkvvTaomTzcXRzTMQB2kVGKfkbhM5SskVFuIqOQUYCi6PyVG5q8+LBSTbaTLA+8z1/3NKnooF7BHqZsgNNK2DLTKUOZJJnjo5WwZWa+n8fH5+YM5XPmzLLMbm6tW7cemjt3ib799gc1aNAow/7c2LEjQJLk7u6hhx7qnWW9QYMeu6PzSFLTpi1UqlTpTPf5+9exbMfE3LDZFxCwRZJUpkwZde9+f5btDx2a+ZvdvHLztXLXI4/0y7LewIFD9OKLr2jChK9UtWp1SdL27dskSS4uLnrssaxHtXt5eWnAgCGSpOTkZMs5b1WpUuVM772Li4v8/PwsX3fufF+mx/v5VbBsx8ZmPZvEsGHDs9w3aNAQy/aOHduyrJdfevbspblzl+ibb35Qt249sqxn/YeLhITELOvl1u7dO5WSkiJJGjBgUIY/OFgbOvQJubik/dF569ZNWdbr0qV7lvusl2S9ccP5ZqcB8ltUbJK+mReomPhkm/IOjfw04D5/B/UKufHrr79KklxdXTV+/PgMg1b8/f31/vtpS61HRkZqwYIFuWp/7dq1Cg4OliQ999xzNoNvpLT3B19++aV8fX0lSdOmTcvQxrx58yRJHh4e+vrrrzNdgrxbt2564oknJEmhoaHasmVLhjrpA3A8PDxUvXr1XF1HURO36VfyyV1ARiGjkFFyhowCIC+dvRytqUsPszonUMiQUfgM5U6QT8gneYl8AiCvzd9wSruPhdmU+Xi7aeyQ5vLxdndQrwBkh4xCRrkTZBQySl4iowDIS2GR8fpuwUElJqXalPdoVUUPtavmoF4hOwzAAZBvunbtLoPBIEmaOfNnPf74QE2bNkUHDx6wvAnMS0eO/CNJ8vevLS8vryzrNWzYWO7ud/aHsxo1amS5z3oGeuvrjI2NUVBQ2kOmTZo0t7y5zUzduvVyNZN9bh07dlRS2hvkzJaWTOfvX1tPPjlCXbp0tTyEe/ToEUlSzZr+WYbTdK1b35xxIf24W1WrlvXDttZ9q1y5SqZ1rENEaqop0zoeHh5q2rR5luepVq2G5fqOHDmcZb384urqqipVqqpduw7y9i6WYX9YWKi2bt2kyZMnWspMptQM9W6X9TVnNkuGtdKly6hmzbQH+I8fP5rpH1yk2/sZAXDn4hNTNHH+QV2LSrApb1SztJ7u1UDG//+9jIIrMjJS27dvlyR17txZVatmvmJRr169VKZM2hKzq1evztU5Vq5cKUkyGAwaOnRopnWKFSum/v37S5KCgoJ09uxZy76YmBgdOnRIktSxY0eVK5f5zEeS9OCDD1q2Dx48mGF/+gCc2rVry2gkniL/kVHIKGSUnCGjAMgroRGZr875IKtzAgD5ROQT8knOkE8A5KXVuy5o7Z6LNmUe7i56fXAzlffN+vcjiiaz2azly5drxIgRateunZo0aaJu3brprbfesnwOktcOHjyoBg0aqFu3bjk+ZufOnXrjjTfUvXt3NWvWTM2bN1fPnj31wQcf6OTJk/nSTzgnMgoZhYySM2QUAHklOi5J384LVHRskk156/rl9ViPOpbfyyh4XB3dAcBRPO99WokBs51ydoT0pUnzW5069fTccyP1888/SkpbqnTWrJmaNWumihcvrjZt2qtLl67q3LnLHS9NmJCQoPj4OEmyGU2fGVdXV/n5VdDFixdu+3z2wox14LJ+03r9+jXLdoUK9peFMxgMqlSpsiXI5aXExATFxcX+fz8qZFPbVmxsjJKS0kbk52QZWes6ERHXM61jPYOGPVmN1s/Jm4xKlSrbDcKSVL58BUVGRioiIjxH/ckvhw8f1N69u3Xu3BldvHhRISEXFRsbm6FeVoHodkRERFi2c3pfT50KUnJysm7cuCEfH58MdXL+M5J5mAaQeympJk1d+o/Oh9rOylPdr4RG9WssVxcGNxQGe/fulcmU9n9j+/YZl3hOZzQa1aZNG61evVoHDx5UVFSUSpbM2e/UPXv2SJLq1aun0qWz/iNr+/btLavxbNmyRTVr1pSU9nujSZMmunz5smrVqmX3XNZ9io62fd9tNpstHwzVrZv50uLOxPu+ZxS/9XfyST4jo5BRyCi5R0YBcLuiY5P03byDuhFnuzpn+0Z+GsjqnECBR0bhMxTyCfnEGvkkDfkEKNx2Hrmi+RtP2ZS5GA16+dHGqlEh488qiraEhAS99tpr2rRpk015SEiIQkJCtHz5cr3++ut64YUX8uycsbGxeu+99yyfA2UnKSlJ77zzjlasWJFh37lz53Tu3DktWLBAY8aMydN+FlRkFDIKGYWMYo2MkoaMAhReCUkp+n7BQYVFxNuU16/mq+d7M8lyQccAHDgtt1pt5VqjtcyJzrcsnsGjuAx3aYbxp556Vo0aNdEff/yuffv2KDU1bTR3TEyMNm5cp40b18nX11evv/5v9ejR87bPY70EqIeHR7b1Mxt9nhvZvcnPTFRUlGU7J32807CaFeuHX3PSD2txcXGWbS+v7PtnfQ3x8QmZ1rmd1zK3cnK/04NfZiHobrhw4bwmTPgoy5kZ/PwqqGPHzlqyZEGenzs9qEuSp2f2MztZh+SEhPhMg5mrK28xgLvJbDZr5srjOnLW9o9LZUt66vVBTeXlwc9kYWE9U1l2g1Jq105b6tlsNisoKEht2tif3UaSQkNDLe8F6tSpY7euv//NhyKPHz9u2a5ataoWLMjZ76PTp09bttNnIUoXEhKimJgYm77ExMTo+PHjio2NVfny5VW3bt278l6hIHD3bytjtZbkk7uAjHITGYWMYg8ZBcCdSEhK0cQFBxUWafvBUcMapfQMq3MChQIZhc9Q7gT5hHyS18gnAO7U0XPh+uWvYxnKn+5VX41rlnFAj+Bo48aNswy+8ff31+DBg1W2bFkdOXJEc+fOVVxcnL755hv5+fmpb9++d3y+pKQkjRo1SkFBQTk+5t1337UMvilVqpQGDRqkevXqKSUlRbt379ayZcuUnJysb775RsWKFdPjjz9+x/0syMgoZJQ7QUYho+Q1MgqAO5GSatKPS4/o7GXbSZarlCuuV/o3lZurczwnU5jxvyacmsFolMGLmUzyW+vWbdW6dVtFRkZq584A7dmzU//H3p2HR1Xe//9/zUz2jSTshNVA2BMEQRS0igugyCZEUItorVo3Fvv105baaqv+aq2iuGLBpVpEwqYsggsgCLIpJOxhX8KeMAnZJzPz+yNlyCE7JDlJ5vm4Li6P77nPfd7JncC855z7vjdv3qjU1MKZ8na7XS+88GcFBwfruuv6X9Y1QkNDPce5uSUXAEU5HPnltqlqRYug3NycMloWyssr/+u4vDwuvqnOy8ur1LlF37SXVmgVlZNz8esMCKhcEViVKjLeF1bWaNAg/LKucWHFiMtx9uxZPf74w7LbC1coiIiI1DXX9FH79h3Url202rfvoCZNmsrpdFZLYVZ0K9/c3JwyVzWQLn6vpNJXrABQs+b9cEA/7ThpiIUE+uqZe3qoQYh5f/+i8lJSUjzHUVFlr1ZTdIWjlJSUCk3AOXbsWIX7b9q0qaxWq1wul44fP15u3yWZN2+e5zguLs7w2p49F1eAslqtevLJJ7VixQrPB/lS4aSd+++/X7/97W+94t8c6pOaQ41SiBqFGqU01CgArsSF3TkPnTTeOGrdJERPjOjO7pxAHUKNUjOoTwpRn1CflIb6BMCVOnLqvN6ev01Ol3Hl+VE3Rev6bmXvaID6ae3atZ6JLX379tUHH3zgeS8yZMgQjRo1Svfee6/sdrtefvll3XLLLQoJKfvv/7KkpqZqwoQJ2rRpU4XPWb9+vRYtWiSpcMG2jz/+WA0bXpwsNnz4cI0ZM0bjx49XVlaWXn31Vd1+++1q3LjxZedZF1Cj1AxqlELUKNQopaFGAXAl3G63Pvl6t7YdMO401jDMX5Pi4xQUwNSOuoBRAlBjwsPDNWjQnRo06E653W7t2LFNH388Q+vXr5Pb7dZ//vPhZRdm/v4BCgkJUWZmpo4fTym3/dmzZ8ttU9UaN764ZeqJEyfKbX/y5Mly21yOkJAQ+fr6yuFw6NSpU2W2dbvd2rRpg6KiWqpp02YKCQmRn5+/8vPzKvR9Pnbs4vavjRs3ueLcL9fp06fLbXNhTBo1Mn4gZS2yikhBQUGpM/4zMy9/RYWZM6d7irJhw0Zq0qRnS7xO0RVAqlJk5MUP6o4fT1GHDh3LbH/06FFJhR82VHRrWQDV5/ufj2np+sOGmJ+vVRNGx6ppZJBJWeFypaVd3MUoIiKizLZFd5Sx2+0V6r/odtTl9e/r66ugoCBlZmZWuP+i1qxZo5UrV0qSGjZsqH79+hleLzoB5x//+EeJfdjtdr399ttavXq1pk+frsjIyErnAZSFGoUaxSzUKGWjRgHqLrfbrU+W7db2AyXszhkfx+6cAFAG6hPqE7NQn5SN+gSo287YczR1TqJy852G+C29Wmrwta1Nygpm+/DDDyUVrvb/4osvFttRIjo6Ws8995yeeeYZ2e12JSQk6MEHH7ysa/3000/6wx/+UOn3Ll988YXn+J///Kdh8s0FsbGxmjhxol566SXl5ORoyZIlGj9+/GXlCZSEGoUaxSzUKGWjRgHqtvmrD2jtduO/GcEBPpp8Tw9FhLLIcl3B3S4A1cLtdmvlyu91+PBBBQUF6Z57jFvdWiwWdesWq3/843WNGnWXzp49o3379l3RNWNje2jduh914MB+pafbS31A8/DhQ8rISC/xteoUERGhFi2idPx4inbs2CaXy2V401/UoUMHqy1Hq9WqDh06aufO7TpwYJ9ycnIMM+OLOnz4kCZPflKSNHbsr/XEExPUqVNnJSVt1cGD+3XuXJoiIkp/EPbnny+u4BId3aFqv5BKsNvP6dixo2rZslWJr+/fv89T9PTo0dPwmq+vn+c4Ozur1ELk4MH9l53funVrJBUWOk8/PbnU4m/v3opvR10ZnTt30ZdfzpdUOGZlFWZnz57RkSOHJElXXdW+WvIBUHGbd5/WrG+NfzdYLRb9blg3Rbfgg5O6qOgKT+VtIe7nd/HfqIqsDCUZVy2q2Fbp/srMzKxw/xecOHFC//d//+f5/9/97nfFVtMpOgHH19dXDz74oIYPH65WrVrJbrfrhx9+0JtvvqkzZ84oKSlJkyZN0kcffVTq+6eaEBZWuRWBzp3zkcPhksVika2Uld4tlov/La0Nqobb7daKFd/p0KHCGmXs2PuLtYmL66FXX52qESOG6OzZM9q/f1+J41L6eBrH+mKNckCZmRmeiXOXjnfR9/+X9lH0uKzXrNbSf85K66NRo4aKimqplJRj2rlzmywWlVGjHCg1xytls1kVE9NRO3Zs14ED+5Wfn1dqjXLo0AFPjXLvvb/WU09NUufOnZWYuFUHDx4osxaUpC1bfvYcd+gQ4/k6yvo+F2W58Eur0n8OrFaL4f+LjveF8+32czp+/JhatSr5QY99+/Z6apSrr+5luJbx7/8cNWhQ8r/5hw4dMORamZ+dn366UKMEaOLE38vf308l2b9/r+H/L+2nvO/Xpa9faNOlSzdPjbJly8/q1KlzideXpDNnLtYo0dEdio1lWdcvL4/KslikyMjgyzoXdceF33Gr1cJ4l+C/y3Zr7TbjjaPQIF+98NvrFNXk8lcLNgvjDaC61IZ7KKWtEsw9FO6hXIp7KNxDAeqq89n5en1OotKzjKvoX9Oxscbe0sHweQC8h91u17p16yRJN9xwg1q1KvnfvzvuuEMvv/yyUlNTtWzZskpPwElLS9Nzzz2n7777zhO7++679eOPP5b7AL0kT44xMTHq3Ln0z8YGDRqkl156SZKUmJhYqRyBompDjcJzXiWjRimOGoUaBairvtt8VEt+umSRZR+rJoyOU/OG3IOoS3i6B0C1sFgsev/9tzRz5nR9/PFMORyOEtv5+PgoKKhwdf6goJKLg4q68cabJElOp1Nz535Rarvq2Nqxom6++VZJUmrqWf3ww4pS25WVf1W4/vrCFSjy8vK0fPmSUtt9991yz/E11/SRJPXv/ytJhd/n2bP/W+q52dnZWrBgrqTCYvC66/qV2rYmXMilJAkJn3uOb7jhJsNrRXcHSE7eo5Js375Np0+X/iGZxXLxn1u3213s9QtFuI+Pj/z8Sn8Yes6ci3kWFBSUcJ2LHxK7XK5S+7lU3779PcXg/PkJZT5k/fnnn3n67tfvhgpfA0DV23PknD5YtFOX/q3ywKCOimvfyJSccOWK/v1e9AHrkhR9vaR/F0ridF5c5a+8/ou2qWj/UuFNpYceesizDX2/fv10//3FJzpcuMHk7++vjz/+WM8884yio6Pl5+enJk2aaPTo0Zo3b56aNWsmSVq/fr2WLl1a4Tyqw4WHsiv6p/Cf5sJ/ny2Wkv8UVVob/lTNH6vVovfee0szZryvjz+eoYICR4ntfH19FRxc+OFWYGBQhcaqtNduummAJMnpLFBCwuxS282fn1Dqa5eq6GsVbTdgQGGNcvZsYY1SWh8JCV9U6FqX++fCe8u8vFwtW7ak1HbffnuxRunT51pZLEVrwQLNnv1Zqefm5GRr/vw5kgprlOuv73dF38uKfr+Lti1qwYK5pfZR9L3/r351k+G1ojch9+7dXeL5O3Yk6dQp4wPwl/4+XOB2u4udn56eLqmwRgkI8C81zy++mOXpx+ksKPH37uJ1XBX+2ezXr5+nRpk3b47y8nJKzeHzzz/11Cj9+99Q6fGqzPhX5PzK/lvBn7r350LtfWGyHn8u/lm+4bASVhgn5vn52vSX3/RV6+ZhpudX18YbQP3GPZSScQ/FPNxDKR33UIC6Kc/h1LS5STqVlm2Id2wVrt/e1aXYAirwHps3b/b8Xd23b99S21mtVvXu3VtS4cSWC5+XVdTevXs9k2+Cg4P14osv6uWXXy71Ie2icnJy1K5dOzVr1kzR0dFltr2w6JMkZWRkVCpHoChqlJJRo5iHGqV01ChA3bRp92l9/p3xHorFIj02rJvaR7HIcl3DXRwA1eZCEXL+fIbefPO1Et+Qrl69SkeOHJYkxcX1LPZ6Zdx22yA1bx4lSfrss4+1Zs0PxdqsWvV9mW/Qq9vIkaM9q7+//vo/deBA8dn033yzTF99Nb9a8xg6dIRnNYT3339bu3btKNZm27ZEzZ79mSSpZcvW6t37WknSXXcNV2homCRp9uzP9M03Xxc7Ny8vV3/72589D3wNGnSnmjVrXi1fS0XNnTtbP/5Y/Gfi668Xa8mSryQVriwdF9fD8Hrnzl08x//5z4fFCqLTp0/pH//4W5nXLrri//nzxT/0uvC9ycrK0vfff1Ps9YKCAr311uueFRQkKT8/r9LXKU2jRo10++2DJRVuTfq3vz2nvLzixdnXXy/2FLEREZEaNuzuCl8DQNU6diZT0+ZtU4HT+CHM8Bva6Ya4FiZlhapQ9O/y0j7YviA//+KqfRWZTCMZd70pr/+i1/D19a1Q/2fOnNG4ceN04EDhrgtt2rTRv/71L5W0kuDs2bP1888/a/ny5brmmmtK7K9p06b685//7Pn/OXPmVCiP6uJ0uir1p/Dtb+F7YLe75D9FldaGP1X358Jkk4yMDE2d+i+5XO5ibVatWqnDhw9Jknr0uLpCY1Xaa7fdNkgtWhTWKP/5z0eGGuVCmxUrvi82Aae0vivzWkXb3X13vOfvnldf/Yf2799f7Pxly77WwoXzqvXnddiwkZ4a5d13p2nHjh3F2iQmJmrWrE8lSa1atVbv3n3ldkt33TXCU6PMmvWpli1bWuzcnJxc/fWvU3TyZGGNMnjwEDVr1uKKvpcV/X4XbVvUnDmztXr1D8XOX7x4kRYv/lKS1LPnNYqLu9rweqdOF2uUwhuhBYbXT506pRdffKHMr8nf/+K/NxkZGcVyaN688P1EVlamvv32m2KvOxwFeuON17R27cUaJS8vv1i78q5TWo4NGzbWwIF3SJJSUo7pr3/9s3Jycoudv2TJYs8koIiISA0fPqrS41WZ8a/I+ZX9t4I/de/Phc+33G636bnUpj9rE1M0fX6S4ffBapF+f29PdWgVbnp+dXG8AdR/Zt9D+fHH1cXacA+lEPdQLuIeCvdQgLrI6XJp+pc7tP+48Xc9qnGwnrq7u3x9bCZlhtpg796LDz3GxMSU2bZ9+8KdAtxut5KTK7+LgdVq1YgRI/T1119r9OjRFT4vMDBQs2fP1g8//KA33nijzLZFdyApOhkHuBxm1yg851U6apSLqFGoUYC6aPfhc/r3oh0lLLLcST06sMhyXVT+tHoAuExjxtyvxYsXKj09XQsXztXOnds0YMBtatasuc6fP6+kpK2eN6F+fv4aN+6hK7qev3+A/t//+6P+3/+bIIfDof/7v8m67bZB6tv3OjmdLv3001qtXPmdfHx8FBgYqMzMzKr4MiuladNmeuSRxzVt2us6dy5Nv/3tON1113B16dJd+fl5WrfuR61evVIWi0UWi0Vut1s2W9V/ABgZ2VATJvxe//jH35WZmanf/e43Gjx4iOLirlZBgUNJSYlavnypnE6nbDab/t//+6NnG9XQ0FD96U9/0ZQpz8rpdOpvf3tOy5d/rRtuuFGhoQ109OhhLVnylU6cOC5JatmylSZO/H2Vfw2V5XK59Mc//l633TZI1157nZxOp9as+UFr1qySVLi6+eTJ/1fsvAEDbtP777+tnJwc/fLLZj366IO64467FBoaqj17dmvJki+VmZmpzp27aNeunSVeu0GDBvL391deXp6+/nqJ2rWLVmhoqLp2jVWzZs00ePAQffDBu5Kkv//9L9q8eaO6dYuVj4+Pjhw5rG+/Xeb5fl5Q0s9v48ZNPcevvPKSbrttoPz8/Cu0gsFTT03W1q2/6PjxFK1evVL33x+vO+8cqlatWuv8+fNas+YHbdhQuM211WrVH/7wnGHVCAA1Jy0jV1PnJConz/hB0U09Wuiu69uakxSqzIUVo6TCFYzKmlhTdAJO0Yk1lem/PBfaFP3wrzRHjhzRww8/rMOHCz90b968uT766KNSt4uXpJCQEIWEhJTZ74ABAxQSEqLMzExt2bKlzO3dq1tGRq4KCpzlN/wfh6NALpdbVqu71IcoC1dWL3yAmwctq198/H366qsFSk9P1/z5Cdq+PanMGuXXv36oxHEpbawuPJx7ga+vn37/+4s1yrPPll+jXNpH0eOyXnO5Sv85K6uPRo2aGGqUhx66v9waxWq1VvnPa4MGEYYa5dFHHyyzRvn97//o+b0JCgo21CjPP/9nff310jJrlAkTnqnw97moojccS2vjchk/Oi36+130fJfL6albS6tRJk16tth1br75Vr333lvKycnRzz9v1sMPP1BujXLpw9whIWGeGmXp0sVq2/YqQ40yaNCdnhrlhRf+rI0b11egRjlfLNdGjZp4jl9++e/FapRLv59Fz3/yyUnasuVnHT+eoh9+WKl77x1Vbo0SFtag2FgW7b80ZeVRGW63lJaWdVnnou6IjAyWzWaRy+VmvP9n7zG7Xpu9VZf89af7B3ZU++ahdfr7ZNZ4+/jYFBERVH5DAHWa2fdQ/vjHZ3TbbYN03XXXyeWS1q5dwz2U/+EeCvdQLsU9FKDucLvd+nR5srbuO2uIR4T6a9LoOAUFVGyxKdRfKSkpnuOoqKgy2zZr1sxw3oUdcSqibdu2Wr58uVq3bl35JCth3ryLCyfFxcVV67VQ/5ldo/CcV+moUahRLkWNAtQdR09n6q35SSpwGm+iDL+hnW5kkeU6iwk4AKpNRESEXnllqv7wh8my2+1KTt5T4taOISGh+vOfX1D79h2u+Jp9+vTVSy+9qr/+9Y/Ky8vTN998bZi5b7PZ9Mwzf9AXX/zXlMJMkuLj71VaWpr++99PlJeX979tSC9uRVpYCP1J//rX/6eCgoIKrzhfWUOGDJPD4dC0aa/J4XBo0aKFWrRooaFNYGCg/vCHv6hXL+MHSTfccJP+/vd/6OWXX1BWVpY2bFjnedNeVK9effT88y8pKCi4Wr6Gynj66Wf01luvF/uZkKSGDRvq1VffVLt2VxU7LyIiUlOmPK+//e055efna8+eXdqzZ5ehzejRY9W1azc9//yUEq9tsVg0YMBt+vrrxcrOztK//vX/SZKeeeYPGjFilMaO/bW2bv1FGzeul9Pp1OLFX3pWvL7AZrPpgQd+o717k7VmzSqdOnVSWVmZCg6++NDyr351kz78cLocDodWr16p1atXKiIiUosWFV9t4VKhoaF6990Z+uMff69du3boxInjmjHj/WLtGjRooOeff0m9e5e+HTeA6pOV69DrcxJ17rxx4sTVHRrp/ts7lrjLCOqWsLAwz7HdbldoaGipbe12u+e4rEkupfWfnp5eZluHw6Hs7OwK9Z+UlKTHHntMqampkgpvWn3yySfl3ryqCJvNpjZt2mjHjh3Kz8+X3W6v8NcLXIoapWTUKOagRikbNQpQNxw/m6Vpc5PkKDBOXBvar61u6nHl7wUBoD6jPikZ9Yk5qE/KRn0C1B1frT2k1YnGB16D/H00OT5OkWHlLzSF+i8tLc1zXN6DyEV3lCl6T6YimjZtWn6jK5ScnKwvvih8n+Tn56eBAwdW+zVRv1GjlIwaxRzUKGWjRgHqhrPpOZo6Z6ty8owLvd50dRSLLNdxTMABUK26dYvVZ5/N1cKFc7V+/TodOXLY82ayRYsoXX99fw0ffrciIxtW2TX7979Rn32WoNmzP9P69et06tRJhYSEqnv3WN177zh17x6nL774b5Vd73I89tiTuu66/po/f462bUvUuXNpCg0N09VX99T99z+o6Oj2+sc//i5Jnm1Aq8OIEaN07bXXKSFhtjZtWq9Tp07K6XSpWbNm6tv3esXH31vqlqK/+tUAxcX11Pz5c/TTTz/q2LFjysvLU5MmTdS+fYyGDBmma6+9rtY8DD569Bh17NhJn332ibZvT1Jubo6iolrqpptu0ejRYw0PJF/qpptuUXR0B82e/Zk2btyg1NQzCgkJVefOXXT33feoT5+++u675WVe//e//4PCwsK0cuX3SktLVUBAgGf7UF9fX7366ptatGihvvnmax04sE85OTkKDAxSixYtFBfXU8OH3602bdpq/vwErVmzSk6nU6tWrdCddw71XKN167Z67bW3NHPmdO3dm6z8/MKdEy4t4ErTqFFjffDBx/r++2/0/fffaNeunUpPtyssLEwtWrTUgAG3adCgO8t8GBxA9XEUOPXW3CQdP2tcdbl9VAM9OrSrrNba8fctrkzbtm09xydOnFCrVq1KbXvy5EnPcYsWFVsV49L+y3Lq1Cm5XK5y+1+zZo2efvppz2Sd9u3b68MPP6zSm0vV9UE1vBM1SsmoUWoeNQo1ClDXnTufp6lztior17g75w2xzTWsfzuTsgKAusXM+uTzzz/Vhg0/6dSpkwoNDVW3btQnl6I+oT4pivoEqP1+2JqiL388aIj52Kx6elSsohqX/3sO75Cbm+s59vf3L7Otn59fiefVBufPn9eECYW7hkjSfffdVyOTfsoSVslJbufO+cjhcMlischms5ba7sLbJYtFZbZD1YiL66HPP5+nBQvmad26H/9Xo2QpODhYUVFR6tfvBo0YMarMGqW0cSptrH/1q5v0+efzNGvWf/TTT+s8NUr37nG6774HFBsbpzlzZpXYR9Hjsl6zWkv/OSurjwueeOJp9e9/g+bNm6PExK2eGqVnz14aN+4hQ40SFtag2n5WR42K1/XX99MXX8zSxo1Fa5Tmuu6663XPPfeqefOS7+sOGHCrevbspXnz5mjt2h917NhRT43SoUNH3XXXMPXte32JNUpFvkcXXivpnKIufa6h6O920fPHjLlXnTt30aeffqRt2wprlJYtW+mmmwbonnvuK7NGueWW2xQT01GzZn2qjRvX6+zZwhqlS5euGjXqHl177XX69tuLNYrNZi2W77PP/kkNGjTQypXfKzX1rAICApSZef5/bf31+utv6auvFmj58qXav7+wRgkKClLz5lHq0eNqjRgxSm3bttO8eXM8Ncrq1Ss1ZMgwzzXatbtKU6e+rRkz3ldycmGN4u/vp9zcbAUHhxT7fl6aY9OmTTVz5n/03Xff6Lvvlmvnzh3/q1EaKCqqpW655TYNHjyk1BqlIuNVUrsr+fm2WAp3HUf9duH33Gq1ePV4Z2Tla9q8jbJn5hvi13ZtpqfuuVq2evCclzePtcXtdrvLbwbUvHPnslVQ4Cy/4f+cPn1MLpdTVqtNTZq0LLGNzWaVxSK53ZLT6SqxDeqPujzeqalnNWzYIEnSffc9oN/97imTM6r9ShrvJ598RFu3/iJJ+vHHzWamhyp25kyK3G6XfH19FRHRrPwTUKdFRgbLZrPK6XQpLS2r/BPqIZfLrfcWbtfPyWcM8eYNg/TH+3spJLB+TE4wa6x9fGyKiAiqseuV5YcfftAjjzwiSfrLX/6i++67r9S2Tz/9tJYvXy6LxaKNGzeW+SFjUddff71SU1PVvXt3zZ07t9R2q1at0qOPPipJmjJlisaNG1eszYoVK/T00097bvDExcVp+vTp5a4ad/ToUa1YsUKpqanq2bOnbrrppjLb33TTTTpx4oR8fX2VmJhYLVu3VwQ1Cq5UXR5vapTKo0bxHtQn3oX6pFB2boH+8d9fdOyMceXR2OiGeuru7rJZ68cDMdQoqM0qW59I1Cgorq6ON/VJ5VGfeBdqFO9CjVJo696zemt+koo+AWWR9PiIburVsYlpeVU1M8a7vtUn48aN04YNGyRJu3fvLnMy7E8//aTx48dLkp566ik9+eSTV3z9AQMGKCUlRVFRUVqxYsVl9ZGTk6OHH35YmzcX/vsdExOjuXPnljuhqLbZu3ev8vMdslisat689AXpgLogNfWs7rzzdknSr389Xk888bTJGdVNv/vdb7Vly8+SpPXrfzE5G1SlEyeOyu12yc/PVx06XPnuWUBtl5tfoOfeX6fdh88Z4p3bRurvj10vf19znnlB1WEHHACoQW+9NVUnThxXmzZt9eijT5Tabs2aHzzHMTGdaiI1AEAt5Xa7Neu75GKTb8JD/DQpPq7eTL5Boauvvlq+vr5yOBzasGFDqRNwnE6nNm3aJEnq1KlThSffSFLv3r21bNky7dq1S+fPny91xZv169d7jvv06VPs9Y0bNxpWV+vXr5/efvttBQWVfyPu9OnTevnllyUV3mwqawLOwYMHPbv1dO/e3bTJN0B9RY0CAKgsR4FLb89PKjb5pl3zMP1uWLd6M/kGAFDzqE8AAJdjf0q63v9yuy5dfvje22Lq1eQbVI2AgIu7tDgcDsMuN5fKz7+4WnlZ7WpSVlaWHnvsMc/km4iICL311lu1YvJNZSd0F/7Ouoscl6zoHCmWGa/fauNYT5v2uo4fT1GbNm3LnPj/ww+rPMcxMZ1qTf61WXnjzfew/qpLC4Dg8litFlksFrndbrlc3vfL7HS69Oqnm4tNvmnVNER/Gt9bPlZLvfk9MHOszd4ZkQk4AFCDLBaLVq9eKUnq0KGjBgy4tVibQ4cOaubM6ZKkkJBQ9e17XY3mCACoXZauP6wVv6QYYoH+Nk2K76FGDQJNygrVJSwsTH379tWaNWu0YsUKHT9+XC1aFN8mfMmSJUpLS5MkDR48uFLXGDhwoJYtW6aCggJ9/vnnnh13isrMzNSCBQskSe3atVOnTsaHWVJTUzVhwgTPzaebb75Z06ZNq/ANqG7duikkJESZmZlas2ZNqV+nJL333nue42HDhpXYBsDlo0YBAFSGy+3Wh0t3afcRuyHeJCJQE0bHyt+PydIAgMtHfQIAqKwTqVl6c26S8guMD7DdeV0b3dKr5B3/4N2KLiKWl5dX4Qk4tWGCS1pamh599FElJSVJKrynNHPmTLVt29bcxP4nIyO3Urt0OhwFcrncslrdZT6EWld3bUTl1caxdrulH34orFHaty+9Rvn3v9+XVFij9OnTt9bkX5uVNN7uIrNu+B7WT263vHrXRm9RuGujRS6X2+vG2+1265Nle7Rx5ylDPCLUXxPujpUj16G0XIdJ2VU9s8a6NuzSyQQcAKhBd945VHPnzlZBQYFeeGGKvv9+uXr27K3w8AhlZKRr164d+u67b5SfnydJmjz5WQUHh0iSEhO3Kj3dfsU53HjjTVfcBwCgZqzddkLzfjhgiPnYLHpyZKxaNQkxKStUt/Hjx2vNmjVyOByaPHmyZsyYoZCQi+O9b98+vfTSS5Kk4OBgjR49ulL933rrrWrZsqWOHTumd955Rz179tQ111zjeT0/P1/PPvus7Ha7JOnBBx8s1sff//53zwSg2NhYvfnmm5Va/c3f31/x8fH68MMP5XA49Mwzz+jf//634euUpJkzZ+rLL7+UJLVt21YjRoyo1NcKoHzUKACAykhYuU8bLrlxFBbkq8n39FBYUO1YDRgAUHdRnwAAKsOemafXv0hUZo7xAbZ+3Zpp5I1XmZQVaruwsDDPsd1uV2hoaKltL9wnkaTIyMjqTKtcR44c0cMPP6zDhw9LksLDwzVz5kx17drV1LyA+o4aBQBQGV/+eFCrE48bYkH+PpocH6fIsIBSzkJdxAQcAKhB7dpdpSlTntc//vF35eXl6YcfVnpWSijKz89fEyf+XrfffnFF+3//+11t3frLFefw44+br7gPAED123YgVR8t3V0s/vCQLurcJsKEjFBT+vfvr4EDB2r58uXasmWLhg0bprFjx6p58+bauXOnPv/8c2VlFa4c8eyzzxa76bNhwwaNGzdOktSnTx99+umnhtf9/Pw0ZcoUPf7448rNzdX48eM1evRo9ezZU3a7XXPmzFFycrIkqWfPnho1apTh/P3792vZsmWe/x80aJDWrFlT7tcVHh5umOjz+OOPa+XKlTp48KB++eUX3XnnnbrnnnvUtm1bnTt3TkuXLtXmzYXvW4KDg/Wvf/2rVqwwB9Q31CgAgIr6ZuMRLd941BDz97VpYnycmoSzOycA4MpRnwAAKionr0BT5yQqNSPXEO92VaQeGNxJFovFpMxQ2xXdLebEiRNq1apVqW1PnjzpOW7RokV1plWmHTt26Le//a1SU1MlSU2aNNHMmTMVExNjWk6At6BGAQBU1KotKfpq7SFDzMdm1dOjYhXVmEWW6xsm4ABADbvttkGKje2hhQvnafPmjTp69IhycrLVoEG4mjRpquuu66c77xyqZs2am50qAMAkB09k6N0F2+UqssWyJI25pYP6dG5qUlaoSa+88oqysrL0448/6tixY3r11VcNr1ssFj355JMaM2bMZfU/YMAA/fWvf9VLL70kh8OhWbNmadasWYY23bt317vvviubzWaIL1y40LD99z//+c8KXfPSyUChoaH66KOP9OSTT2r79u06efKk3nzzzWLnNW/eXK+99pq6d+9emS8RQCVQowAAyrNx1ynNXrHPELNZLXpiRDe1bRZWylkAAFQe9QkAoDwFTpfenr9NR09nGuJtm4Xq8eHd5GOzmpQZ6oLo6GjP8d69e9WnT59S2+7du1dS4T2ZDh06VHtuJUlKStJDDz2k8+fPSyqcQDRjxowyJw4BqFrUKACA8vySfEaffrPHELNIenRoF8W0CjclJ1Qvi9t9yVN9QC1x7ly2CgqcFW5/+vQxuVxOWa02NWnSssQ2NptVFovkdktOp6uqUkUtxXh7F8bbu5w5kyK32yVfX19FRDQzOx1Us8jIYNlsVjmdLqWlZZmdTrU7dS5bL3/6s85nOwzxQX1aK35Ae5OyqhlmjbWPj00REUE1dr2KcrvdWrRokRYuXKhdu3bp/PnzCg8PV69evTRu3Dj16tWrxPPK2wGnqL179+qTTz7RunXrdObMGfn6+iomJkZ33XWX4uPj5evrW+ycRx99VKtWrar011NaLgUFBVq8eLGWLFmiHTt2KCMjQyEhIWrbtq1uv/123XPPPQoODq709aoDNQquFOPtXRhv70F94l28rT6RpF2Hz2nqnK0qcBpvJfzmzs7q171+P1hAjYLarLL1iUSNguIYb+/BWHsXahTv4m01isvt1oxFO7V+5ylDvEl4oP70614KC/YzKbOaYcZ417f6JCMjQ9dff70cDocGDhyoadOmldjO6XSqf//+SktLU+fOnbVw4cIquf6AAQOUkpKiqKgorVixosy2+/fv19ixY5Weni5J6ty5s2bOnKmGDRtWSS5VrTruoUi8j/EmjLV3Yby9CzWKd/G2GmXvMbv+NXurHAXGv8t+fXuMbu5Z+nuc+sCb76GwAw4AAABQS2Rk5WvqF4nFJt/07dpUo26OLuUs1FcWi0VDhw7V0KFDK3Xetddeqz179pTfUFKHDh304osvVqr/6dOnV6p9eXx8fDR8+HANHz68SvsFAADAlTt6OlNvz08qNvnm7l9dVe8n3wAAAACofeau3F9s8k1okK8m3xNX7yffoGqEhYWpb9++WrNmjVasWKHjx4+rRYsWxdotWbJEaWlpkqTBgwfXdJrKy8vTU0895Zl80717d3344YcKC2MXWgAAgNoi5WyWps1NKjb5Zsj1bev95Btvx76rAAAAQC2Qm1+gNxISddqeY4h3aRuhh+7oLKvFYlJmAAAAALxRanqups7Zqpw84+q1N/eM0h1925iUFQAAAABv9c2mo1q28Ygh5u9r08TRcWpSj3ZoQfUbP368JMnhcGjy5MnKzMw0vL5v3z699NJLkqTg4GCNHj26plPUtGnTtH//fklSy5Yt9e9//5vJNwAAALVIWkbhPZSs3AJDvH9sc424oZ1JWaGmsAMOAAAAYLICp0vvLtiuQyfPG+Ktm4ToiRHd5WNj3jwAAACAmpOZ49Drc7bKnplviPeMaaz7bo2RhQUCAAAAANSgjbtOafb3ew0xm9Wix0d0U7vmTEpA5fTv318DBw7U8uXLtWXLFg0bNkxjx45V8+bNtXPnTn3++efKysqSJD377LOKjIw0nL9hwwaNGzdOktSnTx99+umnVZqf3W7XrFmzPP8/cOBA/fzzz+WeFxAQoP79+1dpLgAAACguK9ehqQmJSsvIM8TjohvqgUEduYfiBZiAAwAAAJjI7Xbr4693a/vBNEO8UYMATYqPU6A/b9kBAAAA1Jx8h1PT5iXpRGq2Id6+ZQM9clcXWa3cOAIAAABQc3YdPqcZi3cWi48f3Endr2poQkaoD1555RVlZWXpxx9/1LFjx/Tqq68aXrdYLHryySc1ZsyYGs9t2bJlys6+WJPPnDlTM2fOLPe8qKgorVixojpTAwAA8HqOAqfemrdNKWeyDPGrWoTpsWHdZLOyyLI34Gk+AAAAwETzVx/Quu0nDbGQQF9NvqeHGoT4m5QVAAAAAG/kcrn1waKd2ncs3RBv3jBIT98dKz9fm0mZAQAAAPBGR06d19vzk1TgdBviI2+8Sv26NzcpK9QHgYGBmjFjhhYtWqSFCxdq165dOn/+vMLDw9WrVy+NGzdOvXr1MiW35ORkU64LAACAsl24h5J81G6IN40M0oRRsfL34x6Kt2ACDuoNi8UqySm3211uWwBA3eV2u+VyuWSxSDYbM8ZRt33/8zEt+emwIebnY9WEUbFqFhlkUlYAqgo1CgB4hwv1iZUVrVDHud1u/fe7ZP2SfMYQDw/x0+T4HgoJ9DUpMwBVhRoFALwDNQrqi7PpOZqakKicPKchfnPPKN15XRuTskJ9YrFYNHToUA0dOrRS51177bXas2fPZV2zIjvU/OUvf9Ff/vKXy+q/LqE+AQDvQY2C+sDtdmvWd8n6eY/xHkqDYD89Ex+n0CA/kzKDGfjbDPWGzVY4c9DtdqmgwGFyNgCA6lJQ4JDb7ZbFIvn48PAP6q6f95zWrG+NK1hZLNJjw7opOqqBSVkBqErUKABQ/xnrE9Y6Qt22dP1hrfwlxRAL9LdpUnwPNWwQYFJWAKoSNQoA1H/UKKgvMnMcmjonUemZ+YZ4r5jGuu/WGFksFpMyA1BVqE8AwDtQo6C+WPLTYa0o8R5KnBqFB5qUFczCBBzUG35+F28C5+XlmJgJAKA65eZmSSpckSgkJMTkbIDLk3zUrulf7dSl6zk9MKiTenRoZEpOAKoeNQoA1H8X/n63WCwKDmYHQ9Rda7ed0LwfDhhiPjaLnhwZq1ZNqL2B+oIaBQDqP2oU1Af5DqemzU3SidRsQ7xDywb67V1dZLUy+QaoD6hPAMA7UKOgPliTdFzzV5d8D6V101CTsoKZmICDesPf/+IMwuzs83K5nGW0BgDURfn5ucrOztSFRa2YgIO6KOVMpqbNTVKB02WID+vfTjfGtTApKwDVgRoFAOo3l8up7OzznvokODjY3ISAy7TtQKo+/np3sfjDQ7qoc5sIEzICUF2oUQCgfqNGQX3gdLk0/asd2peSboi3aBSsp0fFys/XZlJmAKoa9QkA1H/UKKgPEved1Sdf7ykW5x6Kd2MCDuoNHx9f+fj4SZKczgKlpZ1Wbm6W3O5L15YHANQlbrdbDke+zp8/p3PnzsjtdslqtSgsLIytSVHnpGXk6vU5icrOKzDEb4xroaH92pqTFIBqQ40CAPWT2+1Wbm6W0tJOy+kskNVqUUBAgPz8/M1ODai0Qycz9O6C7XK6jO9Pxgxorz6dm5qUFYDqQo0CAPUTNQrqC7fbrf9+k6wte88a4hGh/pocH6fgAF+TMgNQHahPAKD+okZBfbH/eLre+3K7XJe8Pxl7SwfuoXg5nlpFvWGxWBQR0VipqSflcjlVUJAvu/2sJIusVqunzQUUbPUf4+1dGO/6y+VySTKOaXBwsJo3by6GGnVJdq5DUxMSde58niHeo30j/XpgjOHvMQD1AzUKLsV4exfGu/66tEbx8fFRy5YteT+HOuf0uWy9MSdReQ7jCrMD+7TS7X1am5QVgOpEjYJLMd7eg7Gu36hRUF8sWndIq7YeN8QC/X00KT5OkWEBJmUFoLpUpD650O4C3sfUb4y1d2G86zdqFNQHJ9Oy9WZCkvIdLkN88LWtdVvvViZlhdqCCTioV2w2H0VENJHdfkZO54WV5d2ebUqtVosky/9ivHGr7xhv78J4e4+AgCC1aBElq9Uqp9NV/glALeAocGravG1KOZNliEdHhenRYV1ls7IxJVBfUaOgKMbbuzDe3sFm81FUVEv5+vpSn6BOycjO1+tzEpWR7TDEr+3SVKNvbm9SVgBqAjUKimK8vQdj7T2oUVBXrU48roVrDhpiPjaLnr67u1o2DjEpKwDVrbz6ROJ9jDdhrL0L4+09qFFQF9kz8/T6F1uVmWO8h3Jd12a6+6Zok7JCbcIEHNQ7vr5+atSohfLzc5WTk6WCAodnRq2vr48sFsntlhyOgnL7Qt3GeHsXxrv+slqtslp9FBAQKH//INlsNsOKN0Bt53K59e9FO5V81G6IN4sM0oRRcfL3tZmTGIAaQ42CCxhv78J411eFK3D6+PgqMDBEfn7+CghgFV7ULXn5Tr2ZkKjT53IM8c5tIvTQHZ1lZRVCoN6jRsEFjLf3YKzrM2oU1H2J+87qP8v2GGIWSY/c1VUdW0eYkxSAGlNWfVL4Ou9jvAVj7V0Y7/qMGgV1W3ZugabOSdTZ9FxDvFu7SD14RyfuoUASE3BQT1ksFvn7B8rfP9AQj4wMls1WuGNCWlpWKWejvmC8vQvjDaA2crvd+vz7vdq854wh3iDYT5Pj4xQS6GtSZgBqGjUKJMbb2zDeAGojp8ul977croMnzhviLRuH6IkR3eXrw4IXgLegRoHEeHsTxhpAbXXgeIbe+3K7XG7jyvdjb+2gazo1MSkrADWttPpE4n2MN2GsvQvjDaA2chS49M6CbTp6OtMQb9ssVI+P6CYfG/dQUIifBAAAAKCafL3hiL7/+ZghFuBn06T4ODUKL/4BMgAAAABUF7fbrf8s26Ok/amGeMMwf02Kj1NQAOt1AQAAAKg5J9Oy9UZCovIdLkN8cN/WuvWaViZlBQAAAMAbudxuzVyyU7sOnzPEm4QHauLoOAX4cQ8FFzEBBwAAAKgG67af0NxV+w0xm9Wip0Z2V+umoSZlBQAAAMBbffnjQa1JOmGIBQf4aFJ8D0WE+puUFQAAAABvlJ6Zp9e/2KrMHIchfl3XZhr1q2iTsgIAAADgjdxut774fp827jptiIcF+WryPXEKC/YzKTPUVkzAAQAAAKrY9gOp+mjp7mLxh4d0Uee2kSZkBAAAAMCbrdqaoq/WHjLEfH2senpUrFo0CjYnKQAAAABeKSevQG8kJOlseq4h3rVdpB68o5MsFotJmQEAAADwRss3HtW3m48aYv6+Nk2Mj1OTiCCTskJtxn5IAAAAQBU6dDJD7yzYLqfLbYjfM6C9ru3S1KSsAAAAAHirLXvP6NPlewwxi0V6dGhXdWgZbk5S8Fput1uLFy/WvHnztGvXLmVnZ6tx48bq3bu37rvvPsXGxl7xNZKTk/XRRx9pw4YNOn36tEJDQxUdHa3hw4drxIgRstls5faRm5ur2bNna/ny5Tp48KAyMzPVsGFD9erVS/fff7969ux5xXkCAAB4owKnS+8u2KbDp84b4m2ahurx4d3kY2MdYQAAAAA156ftJzVn5T5DzGa16ImR3dS2WZhJWaG2YwIOAAAAUEVOn8vWG3MSledwGuK3926lgX1am5QVAAAAAG+1LyVd07/cIbdxfQDdf3tH9YxpbE5S8Fq5ubmaMGGCVq1aZYinpKQoJSVFixYt0sSJE/XII49c9jUSEhL0wgsvyOFweGJpaWlKS0vTpk2btGDBAr3zzjsKDw8vtY/du3frqaee0pEjRwzxkydPasmSJVq6dKkee+wxTZw48bLzBAAA8EYut1sfLd2lHYfOGeKNGgRo4uhYBfrzCBMAAACAmrP9YKo+XLqrWPyhOzqrW7uGJmSEuoLqFQAAAKgCGVn5en1OojKyHYb4tV2aKn5Ae5OyAgAAAOCtTqRmadrcJOUXuAzxIde30c1XR5mUFbzZlClTPJNvoqOjFR8fr0aNGmnHjh2aPXu2srOz9dprr6lp06YaNmxYpftfs2aNnnvuObndbgUGBmrMmDHq1q2bUlNTNXfuXCUnJ2vz5s2aPHmyZsyYIau1+OrqR48e1YMPPqi0tDRJ0nXXXafbbrtN4eHh+uWXX5SQkKC8vDy99957atasmcaMGXNF3xMAAABvMm/Vfv2045QhFhLoq2fu6aEGIf4mZQUAAADAGx06maF35m+X02VcwWz0zdG6rlszk7JCXcEEHAAAAOAK5eYX6M25iTp9LscQ79wmQg/d0VlWi8WkzAAAAAB4I3tmnqbOSVRmjnGBgH7dm2nEDVeZlBW82dq1a7V48WJJUt++ffXBBx/I37/wIcshQ4Zo1KhRuvfee2W32/Xyyy/rlltuUUhISIX7z8/P1/PPPy+3262goCB99tln6tq1q+f1sWPHavLkyfr222+1du1aLV26VEOGDCnWzwsvvOCZfPPMM88YduO58847ddddd+n++++Xw+HQ1KlTNXLkSPn5+V3W9wQAAMCbfLv5qL7eYNxh0M/Xqomj49Q0MsikrAAAAAB4o9PnsvXGnETlOZyG+G3XtNKgPq1Nygp1SfHlvQAAAABUWIHTpfcW7tDBE+cN8VZNQvTkyO7y9eEtNwAAAICak5NXoDfmJOpseq4h3u2qSD0wqJMsLBAAE3z44YeSJB8fH7344oueyTcXREdH67nnnpMk2e12JSQkVKr/b775RseOHZMkPfzww4bJN5Lk5+enV155ReHh4ZKk6dOnF+tj48aNWrNmjSRp5MiRhsk3F/To0cOz643dbtdPP/1UqTwBAAC80cZdpzT7u72GmNVi0ePDu+mqFmEmZQUAAADAG2Vk5ev1LxKVkW1cwKxP5ya655b23ENBhfA0IAAAAHCZ3G63Plm2W9sOpBriDcMCNCk+ToH+bDgJAAAAoOYUOF16Z8E2HTmdaYi3bRaqx4d3k4+NWwKoeXa7XevWrZMk3XDDDWrVqlWJ7e644w41bNhQkrRs2bJKXWPp0qWSJIvForFjx5bYJjg4WCNHjpQkJScn6+DBg4bXL+zQ4+/vr0mTJpV6rVGjRmnMmDH63e9+58kXAAAAJdt9+JxmLN4p9yXxBwZ3VGx0I1NyAgAAAOCdcvMLNDUhUaftOYZ45zYR+s2dXWRl8g0qiLttAAAAwGVasOaA1m47aYgFB/ho8j1xCg/xL+UsAAAAAKh6LrdbHy7dpZ2HzhniTcIDNXF0nAL8WCAA5ti8ebNcLpckqW/fvqW2s1qt6t27tyQpMTFR6enpFb7Gpk2bJEkdO3ZUZGRkqe2KXn/16tWG17777jtJ0vXXX68mTZqU2kenTp30wgsvaOLEierWrVuFcwQAAPA2x05n6q3521TgNE6/GXFDO90Q28KkrAAAAAB4o8IFzLbr8MnzhnirJiF6cmR3+fowpQIVx08LAAAAcBlW/nJMi9cdNsT8fKyaMDpOzRsGm5QVAAAAAG81b9V+rd9xyhALDfLVpHviFBbsZ1JWgLR3717PcUxMTJlt27dvL6lwx9nk5OQK9X/q1CllZGRIkjp06FBm2+joaM/x7t27PcenT59Wamrh7rY9evTwxB0Oh3bt2qXVq1dr+/btKigoqFBOAAAA3i41PVevz9mqnDzj+6ebro7SkOvbmpMUAAAAAK/kdrv10dLd2nEwzRBv1CBAk+LjFOjPAmaoHH5iAAAAgEr6ec8ZffaN8UEgi0V6dFhXtY9qYFJWAAAAALzVt5uP6usNRwwxP1+rJo6OU9OIIJOyAgqlpKR4jqOiosps26xZM8N5F3bEKcuxY8cq3H/Tpk1ltVrlcrl0/PhxT3zfvn2e45YtW8rhcOj999/XrFmzlJZ28aZseHi4fvvb3+rBBx+UzWYrNzcAAABvlJnj0NSERNkz8w3xqzs00v23xchisZiUGQAAAABvNPeH/fppx0lDLCTQV5Pi4xQe4m9SVqjLmIADAAAAVELyUbumf7VD7kvivx7YUVd3aGxKTgAAAAC816bdpzX7u72GmNVi0ePDu6td8zCTsgIuKjqBJSIiosy24eHhnmO73V6h/s+dO1fh/n19fRUUFKTMzExD/ydPXrz56ufnp/vvv19bt24tdr7dbterr76qrVu3aurUqfL19a1QjgAAAN4i3+HUW/OSdPxsliHevmUDPTq0q6xWJt8AAAAAqDnfbjqqr9cXX8BswuhYNW8YbFJWqOusZicAAAAA1BUpZ7P01rwkFThdhvjQfm11U4+yV9kFAAAAgKq258g5/XtR8QUCHhjcUbHRDU3JCbhUbm6u59jfv+zVBP38/Eo8ryw5OTkV7r9om6L9Z2VdfED0n//8p7Zu3aoOHTpo+vTp+uWXX7Rp0ya9/vrrat68uSTp22+/1RtvvFGh/AAAALyFy+XWB4t2au+xdEO8ecMgPX13rPx82UEQAAAAQM3ZuOuUZn9ffAGz3w3rpugWDUzKCvUBO+AAAAAAFXDufJ6mztmqrNwCQ/zGuOYa1r+dSVkBAAAA8FbHzmRq2rxtKnAap9+MuKGdbohtYVJWQHEFBRfr6KITbEpS9PWi55XF6XRWuP+ibYr2n52d7Tk+evSoOnfurM8++0whISGe+J133qmePXtq5MiRSktL08cff6x7771XUVHmLMgRFhZQLf1eWJXearUoMpIVIOs7xtt7MNbehfH2LrVlvN1utz5YuF2/JJ8xxCPDAvS3R65T44ggkzKrX2rLeAMAAAC13a5DaZqxeGeJC5jFtW9kSk6oP5iAAwAAAJQjO9ehqXO2Ki0jzxCPi26oXw/sKIvFYlJmAAAAALxRWkaups5JVE6ecYLCTVdHacj1bc1JCihFQMDFiSIOh6PMSTL5+fme44pMppGMu944HI5y21+4hq+vryfmdhtvw/797383TL65oHnz5nr66af1/PPPq6CgQAsXLtQTTzxRoTyrms1mrdb+LRaLbDY+7/AWjLf3YKy9C+PtXcwe7znfJevrnw4ZYkEBPnr+t33VrFHx91W4MmaPNwAAAFCbHTl1Xm/NL2EBsxuvYgEzVAkm4AAAAABlcBS49Pb8bTp2JssQv6pFmB4b1k02a/U+8AIAAAAARWXlOjR1TqLOnTcuEHB1h0a6/7YYFghArRMUdHG187y8vApPwCk6saYy/ZfnQpuiE4MCAwM9x23btlX37t1LPX/gwIF6/vnnJUm//PJLhXKsDk6nq1r6tVotslgscrvdcrkuXR8S9Q3j7T0Ya+/CeHuX2jDe328+qk+/3mWI+dis+uO43mrdNLTa3rd4I7PGu7onfwMAAABV5aw9R1MTEpWb7zTEb+4ZpSHXtTEpK9Q3TMABAAAASuFyuzVj8U7tPmI3xJtGBmnCqFj5+9nMSQwAAACAV3IUOPXWvG1KOWtcIKB9VAM9OrSrrFYm36D2CQsL8xzb7XaFhoaW2tZut3uOIyMjK91/enp6mW0dDoeys7OL9V90t5t27dqV2UdkZKTCw8Nlt9t1+vTpCuVYHTIyclVQ4Cy/YSVFRgbLZrPI5XIrLS2r/BNQpzHe3oOx9i6Mt3cxe7yT9qfqnblJxeIPD+msqMhAfgarmBnj7eNjU0REUPkNAQAAAJOdz87X63MSlZ6Zb4j3imms+25lATNUHZYoAAAAAErgdrs1+/u92rTb+DBNg2A/TY6PU2hQ6Sv2AgAAAEBVc7nc+veinUo+ajfEmzcM0tOjYuXnywIBqJ3atm3rOT5x4kSZbU+ePOk5btGiRZX3f+rUKblcrmL9t2zZskLXuuDCLj4X+gIAAPBGB09k6N2F2+RyG3diGXNLB/Xp3NSkrAAAAAB4o7x8p96cm6STadmGeEyrcD0ytAsLmKFKMQEHAAAAKMGyjUf03eZjhliAn00TR8epcXigSVkBAAAA8EZut1uff79Xm/ecMcQbhPhpUnycQgJ9TcoMKF90dLTneO/evWW2vfC6xWJRhw4dKtR/RESEGjZsWKH+9+3b5zmOiYkp8TglJaXMPpxOp2ennqZNebAUAAB4p1PnsvVGQqLyHcYJyYP6tNbtvVuZlBUAAAAAb+R0ufTel9t14HiGIR7VOFhP391dvj4sYIaqxQQcAAAA4BI/bT+phJX7DTGb1aInRnZXm2ahJmUFAAAAwFst23BE3/9cfIGASaPj1KgBCwSgdrv66qvl61s4SWzDhg2ltnM6ndq0aZMkqVOnTgoLC6vwNXr37i1J2rVrl86fP19qu/Xr13uO+/Tp4zmOiIjwTPjZu3evYSeeS+3YsUP5+fmSjBN3AAAAvEV6Vr5e/2Krzmc7DPG+XZtq1M3RpZwFAAAAAFXP7Xbrk2V7lLQ/1RCPDPPXpNFxCgpgATNUPSbgAAAAAEXsOJimD5fuKhb/zZ2d1bVtpAkZAQAAAPBmP20/qYRVxRcIeHJkd7VuygIBqP3CwsLUt29fSdKKFSt0/PjxEtstWbJEaWlpkqTBgwdX6hoDBw6UJBUUFOjzzz8vsU1mZqYWLFggSWrXrp06depkeP3OO++UVHjD9t///nep1/rss888x5XNEwAAoK7LzS/QGwmJOmPPNcS7tI3QQ3d0ltViMSkzAAAAAN5owZqD+jHphCEWHOCjSfE9FBkWYFJWqO+YgAMAAAD8z+GT5/X2gm1yutyGePzN7dW3azOTsgIAAADgrUpdIGBIZ3VhgQDUIePHj5ckORwOTZ48WZmZmYbX9+3bp5deekmSFBwcrNGjR1eq/1tvvVUtW7aUJL3zzjvavHmz4fX8/Hw9++yzstvtkqQHH3ywWB9jxoxRZGTh79Xnn3+uL7/8slibhQsXeuI9e/ZUXFxcpfIEAACoywqcLr27YLsOnzTuONi6SYieGNFdPjYeQQIAAABQc1b+ckyL1x0yxHx9rHp6VKyiGgWbkxS8go/ZCQAAAAC1wWl7jqYmJCov32mI33ZNKw3s08qkrAAAAAB4qzIXCOjCAgGoW/r376+BAwdq+fLl2rJli4YNG6axY8eqefPm2rlzpz7//HNlZWVJkp599lnPRJgLNmzYoHHjxkmS+vTpo08//dTwup+fn6ZMmaLHH39cubm5Gj9+vEaPHq2ePXvKbrdrzpw5Sk5OllQ4cWbUqFHFcoyIiNDf/vY3TZgwQU6nU88++6y+/vprDRgwQH5+flq5cqWWLVsmSfL399ff//73Kv8+AQAA1FZut1sff71b2w+mGeKNGgRoUnycAv15/AgAAABAzfl5z2l99k2yIWaxSI8O7aoOLcPNSQpegwr4f9xutxYvXqx58+Zp165dys7OVuPGjdW7d2/dd999io2NveJrJCcn66OPPtKGDRt0+vRphYaGKjo6WsOHD9eIESNks9kq3WdiYqLGjBmj5s2ba8WKFRU6Z/369UpISNDWrVt19uxZWSwWNW3aVNdee61+/etfq0OHDpXOAwAAoC7LyM7X1C+2KiMr3xDv07mJ7rmlvSwWi0mZAQAAAPBGZ1ggAPXQK6+8oqysLP344486duyYXn31VcPrFotFTz75pMaMGXNZ/Q8YMEB//etf9dJLL8nhcGjWrFmaNWuWoU337t317rvvlno/5rbbbtNrr72mP//5z8rMzNTKlSu1cuVKQ5vw8HC99957at++/WXlCQAAUBfNX31A67afNMRCAn01+Z4eahDib1JWAAAAALxR8lG7pn+1U+5L4r++vaN6xjQ2JSd4FybgSMrNzdWECRO0atUqQzwlJUUpKSlatGiRJk6cqEceeeSyr5GQkKAXXnhBDofDE0tLS1NaWpo2bdqkBQsW6J133lF4eHiF+8zKytKf//xnuVyuCrXPz8/XH//4Ry1evLjYa4cOHdKhQ4eUkJCgSZMmXdHXCgAAUJfk5Tv1ZkKSTp3LMcQ7tQ7Xb+7sIiuTbwAAAADUoPPZ+Xp9TmKxBQJ6d2KBANRtgYGBmjFjhhYtWqSFCxdq165dOn/+vMLDw9WrVy+NGzdOvXr1uqJrjB07Vtdcc40++eQTrVu3TmfOnJGvr69iYmJ01113KT4+Xr6+vmX2MXjwYPXq1Uv//e9/tWLFCqWkpMhisahVq1a69dZbde+99xbboQcAAKA++/7nY1ry02FDzM/HqgmjY9UsMsikrAAAAAB4o2NnMjVtbpIKnMZn54f2a6ubro4yKSt4GybgSJoyZYpn8k10dLTi4+PVqFEj7dixQ7Nnz1Z2drZee+01NW3aVMOGDat0/2vWrNFzzz0nt9utwMBAjRkzRt26dVNqaqrmzp2r5ORkbd68WZMnT9aMGTNktVrL7TM/P1+PP/64kpOTy217wZ/+9CfP5JuIiAiNHj1aHTt2VEFBgTZu3KivvvpKDodDr732moKDg3XfffdV+msFAACoS5wul977crsOnsgwxFs2DtGTI2Pl61P++zIAAAAAqCp5DqemzU3SqbRsQ7xT63A9PIQFAlD3WSwWDR06VEOHDq3Ueddee6327NlTobYdOnTQiy++eDnpeTRp0kSTJk3SpEmTrqgfAACAum7z7tOa9a3xuRSLRXpseDdFt2hgUlYAAAAAvFFaRq6mzklUdl6BIX5jXAsN69/OpKzgjbx+As7atWs9k1L69u2rDz74QP7+hdvjDhkyRKNGjdK9994ru92ul19+WbfccotCQkIq3H9+fr6ef/55ud1uBQUF6bPPPlPXrl09r48dO1aTJ0/Wt99+q7Vr12rp0qUaMmRImX2mpqZqwoQJ2rRpU4XzWL9+vRYtWiRJiomJ0ccff6yGDRt6Xh8+fLjGjBmj8ePHKysrS6+++qpuv/12NW7MVlwAAKB+crvd+mTZHiXtTzXEG4b5a1J8nIICvP6tMgAAAIAa5HS5NP3LHdp//NIFAoL15MjuLBAAAAAAoEYlH7Xrg0U75b4k/sCgTurRvpEpOQEAAADwTlm5Dr0+J1HnzucZ4j3aN9KvB8bIwgJmqEFef8fuww8/lCT5+PjoxRdf9Ey+uSA6OlrPPfecJMlutyshIaFS/X/zzTc6duyYJOnhhx82TL6RJD8/P73yyisKDw+XJE2fPr3M/n766SeNHDmyUpNvJOmLL77wHP/zn/80TL65IDY2VhMnTpQk5eTkaMmSJZW6BgAAQF2ycM1B/Zh0whALDvDRpPgeigj1L+UsAAAAAKh6brdbny5P1tZ9Zw3xyDB/TYrvoaAAX5MyAwAAAOCNUs5katrcJBU4XYb4sP7tdGNcC5OyAgAAAOCN8h1OTZubpONnswzx6KgwPTqsq2xWr58OgRrm1T9xdrtd69atkyTdcMMNatWqVYnt7rjjDs+ElWXLllXqGkuXLpUkWSwWjR07tsQ2wcHBGjlypCQpOTlZBw8eLNYmLS1NTzzxhMaPH6+TJ09Kku6++241bdq0Qnlc+DpjYmLUuXPnUtsNGjTIc5yYmFihvgEAAOqaVVtStGjdIUPM18eqCaPi1KJRsDlJAQAAAPBai9Ye0urE44ZYkL+PJo2OY4EAAAAAADUqLSNXr89JVHZegSF+Y1wLDe3X1pykAAAAAHgll8ut6V/t0N5j6YZ484ZBmjAqTv6+NpMygzfz6gk4mzdvlstVuFpH3759S21ntVrVu3dvSYWTUtLT00tte6kLO9V07NhRkZGRpbYrev3Vq1cXe33v3r367rvvJBVO2HnxxRf18ssvy8fHp9wccnJy1K5dOzVr1kzR0dFltr2wE48kZWRklNs3AABAXfNL8hl9+s0eQ8xikR4b2lXtWzYwKSsAAAAA3mp14nEt/NG4KJOPzaqnR8UqqnGISVkBAAAA8EZZuQ5NnZOoc+fzDPEe7Rvp1wNjZLFYTMoMAAAAgLdxu9367Js92rL3rCEeHuKnSfFxCgn0NSkzeLvyZ2/UY3v37vUcx8TElNm2ffv2kgp/mZOTkz0Tcspy6tQpzySWDh06lNm26MSY3bt3l9jGarVq2LBhmjRpUoV3vpGkwMBAzZ49u0Jt9+3b5zkuOhkHAACgPth7zK7pX+2Q222M//r2jro6prE5SQEAAADwWlv3ndV/ll2yQICkR4d2UUyrcFNyAgAAAOCdHAVOvTVvm1LOZhni0VFhenRYV9msXr3GLwAAAIAatmjdIa3aetwQC/S3aXJ8DzVqEGhSVoCXT8BJSUnxHEdFRZXZtlmzZobzKjIB59ixYxXuv2nTprJarXK5XDp+/Hix19u2bavly5erdevW5V73SsybN89zHBcXV63XAgAAqEnHz2Zp2twkOQpchviQ69vqpqvLfq8GAAAAAFVt//F0vb9wu1yXrBBw720x6tWxiUlZAQAAAPBGLpdbHyzaqeSjdkO8WWSQJoyKk7+vzZzEAAAAAHil1YnHtXDNQUPMx2bRUyNj1bJJiElZAYW8egJOWlqa5zgiIqLMtkV3g7Hb7RXq/9y5cxXu39fXV0FBQcrMzCyx/8rseHO5kpOT9cUXX0iS/Pz8NHDgwGq/JgAAQE04dz5PU+dsVVZugSHeP7a5RtzQzqSsAAAAAHirk2nZejMhSfmXLBBwR982uqVXS5OyAgAAAOCN3G63Pv9ur37ec8YQbxDsp8nxcQoJ9DUpMwAAAADeaOves/pk2W5DzCLpt3d1Vac2ZT+PD9QEr56Ak5ub6zn29/cvs62fn1+J55UlJyenwv1faJOZmVnh/qvS+fPnNWHCBDkcDknSfffdVyOTfsoSFhZQ5X1arRbPfyMjg6u8f9QujLd3Yby9C+PtXa50vLNyHHrrk81KzcgzxHt1aqKJY3vKx2atkjxx5fjdBgAAgDdIz8zT619sVWaOwxC/vlsz3f2rq0zKCgAAAIC3Wrr+sL7/5ZghFuBn06T4ODUKDzQpKwAAAADeaF9Kut7/crvcbmN87K0d1LtTE3OSAi7h1RNwCgouroBedIJNSYq+XvS8sjidzgr3X7RNRfuvKjk5OXrsscd04MABSVJMTIwmTZpUozmUxFaND8NaLBbZbJZq6x+1C+PtXRhv78J4e5fLGW9HgVOvfLpZh05kGOIxrcP1h3G95e/n1W+Hay1+twEAAFBf5eQV6I2EJJ1NNy7C1LVdpMYP7iSLhffBAAAAAGrO2m0nNO+HA4aYzWrRUyO7q3XTUJOyAgAAAOCNTqRm6c2EROUXuAzxO69ro1uvaWVSVkBxXv3EYUDAxR1WHA5HmZNk8vPzPccVmUwjGXe9ubCzTFkuXMPXt+a2783KytJjjz2mzZs3S5IiIiL01ltvVWjHnurmdLrKb1RJVqtFFotFbrdbLpe7/BNQpzHe3oXx9i6Mt3e53PF2udx6/fNflLTvrCHeolGwpozvI18fa7W838DlM/N3uzonfwMAAACSVOB06d2F23X41HlDvE3TUD0+vBu7cwIAAACoUdsPpOrjr3cXiz88pIs6t400ISMAAAAA3urc+Ty9/sVWZeUaN7Ho162ZRt54lUlZASXz6gk4QUFBnuO8vLwKT8Cp6OSUS/svz4U2RScGVae0tDQ9+uijSkpKkiSFhYVp5syZatu2bY1cvzwZGbkqKHCW37ASIiODZbNZ5HK5lZaWVaV9o/ZhvL0L4+1dGG/vcrnjPfv7vfox8bghFhbsp6dHxcqZX6C0tJrddRDlM+t328fHpoiIoPIbAgAAAJfJ7Xbr4693a8fBNEO8UYMATRwdq0B/r/6oHgAAAEANO3QyQ+8s2C7nJYth3TOgva7t0tSkrAAAAAB4o+zcAk2dk6jUDOOz9t2uitQDgzvJYrGYlBlQMq9eUi8sLMxzbLfby2xb9PXIyIqt9FG0//T09DLbOhwOZWdnV6r/K3HkyBGNGTPGM/kmPDxcH330kbp27Vrt1wYAAKhuyzYc0Tebjhpi/n42TRodpybhgSZlBQAAAMBbzV99QOu2nzTEQgJ99cw9PdQgxPzdyAEAAAB4j9PnsvXGnETlOYwLot7eu5UG9mltUlYAAAAAvJGjwKW35yfp2JlMQ7xd81A9PrybfGxePdUBtZRX/1QW3enlxIkTZbY9efLizdEWLVpUef+nTp2Sy+WqVP+Xa8eOHRozZowOHz4sSWrSpIk+/fRTdevWrVqvCwAAUBPW7zipOSv3GWI2q0VPjuiuNs1CTcoKAAAAgLf6/udjWvLTYUPMz9eqCaNj1TSSnRgBAAAA1JyMrHy9PidRGdkOQ7xP5yaKH9DepKwAAAAAeCOX261/L96p3UfshniTiEBNGB2nAD8fcxIDyuHVE3Cio6M9x3v37i2z7YXXLRaLOnToUKH+IyIi1LBhwwr1v2/fxYdEY2JiKtT/5UhKStIDDzyg1NRUSYWThGbNmlWt1wQAAKgpOw+laeaSXcXiD93RWV3bVf8ugwAAAABQ1M97TmvWt8mGmNVi0e+GdVN0iwYmZQUAAADAG+XmF+jNuYk6fS7HEO/UOly/ubOLrBaLSZkBAAAA8DZut1uff7dXm3efNsTDgv00+Z4eCgvyMykzoHxePQHn6quvlq+vryRpw4YNpbZzOp3atGmTJKlTp04KCwur8DV69+4tSdq1a5fOnz9farv169d7jvv06VPh/itj//79evjhhz15dO7cWbNmzVKrVq2q5XoAAAA16cip83p7/jY5XW5DfPRN0bquWzOTsgIAAADgrZKP2jX9q51yXxIfN6ij4to3MiUnAAAAAN6pwOnSewt36OAJ43MrLRuH6MmRsfL18erHhwAAAADUsK83HNH3Px8zxPz9bJo0Ok5NwgNNygqoGK+uoMPCwtS3b19J0ooVK3T8+PES2y1ZskRpaWmSpMGDB1fqGgMHDpQkFRQU6PPPPy+xTWZmphYsWCBJateunTp16lSpa1REXl6ennrqKaWnp0uSunfvrv/85z+eHXoAAADqsjP2HE2dk6jcfKchfmuvlhp0bWuTsgIAAADgrVLOZmna3CQVOF2G+PD+7XRjXAuTsgIAAADgjdxutz5ZtlvbDqQa4g3DAjQpPk5BAT4mZQYAAADAG63ddkJzV+03xGxWi54c0V1tmoWalBVQcV49AUeSxo8fL0lyOByaPHmyMjMzDa/v27dPL730kiQpODhYo0ePrlT/t956q1q2bClJeuedd7R582bD6/n5+Xr22Wdlt9slSQ8++OBlfBXlmzZtmvbvL/zLqmXLlvr3v/9dqZ18AAAAaqvz2fl6fU6i0rPyDfFrOjXRmFs7yGKxmJQZAAAAAG+UlpGrqXO2KjuvwBC/Ma6F7urX1pykAAAAAHitBWsOaO22k4ZYcICPJt8Tp4hQf5OyAgAAAOCNth1I1cdf7y4W/82dndW1XaQJGQGV5/XLWPTv318DBw7U8uXLtWXLFg0bNkxjx45V8+bNtXPnTn3++efKysqSJD377LOKjDT+cm/YsEHjxo2TJPXp00effvqp4XU/Pz9NmTJFjz/+uHJzczV+/HiNHj1aPXv2lN1u15w5c5ScnCxJ6tmzp0aNGlXlX6PdbtesWbM8/z9w4ED9/PPP5Z4XEBCg/v37V3k+AAAAVSXP4dS0uUk6lZZtiHdsFa7fDuksK5NvAAAAANSg7FyHpiYkKi0jzxDv0b6Rfj0whgUCAAAAANSolb8c0+J1hw0xXx+rJoyKU/OGwSZlBQAAAMAbHTyRoXcXbJfT5TbE7xnQXn27NjMpK6DyvH4CjiS98sorysrK0o8//qhjx47p1VdfNbxusVj05JNPasyYMZfV/4ABA/TXv/5VL730khwOh2bNmmWYECNJ3bt317vvviubzXbZX0dpli1bpuzsiw+lzpw5UzNnziz3vKioKK1YsaLK8wEAAKgKTpdL7y/crv3HMwzxlo2D9dTd3eXrU/XvqwAAAACgNI4Cl96ev00pZ7IM8atahOnRYV1ls3r9hvQAAAAAatDPe87os2+SDTGLRXpsWFe1b9nApKwAAAAAeKNTadl6IyFReQ6nIT6wTysN7NPapKyAy8MEHEmBgYGaMWOGFi1apIULF2rXrl06f/68wsPD1atXL40bN069evW6omuMHTtW11xzjT755BOtW7dOZ86cka+vr2JiYnTXXXcpPj5evr6+VfQVGV3YYQcAAKC+cLvd+nT5HiXuTzXEI8P8NSm+h4ICqud9FQAAAACUxOV2a8bindp9xG6IN40M0oRRsfL3ZYEAAAAAADUn+ahd07/aIfcl8V8P7KirOzQ2JScAAAAA3ik9M0+vfbFV57MdhnjfLk01+ub2JmUFXD4m4PyPxWLR0KFDNXTo0Eqdd+2112rPnj0VatuhQwe9+OKLl5NeqSqyQ81f/vIX/eUvf6nS6wIAAJjpyx8PanXiCUMsOMBHk+J7KCLU36SsAAAAAHgjt9utL77fp027TxviYcF+mhwfp9AgP5MyAwAAAOCNUs5m6a15SSpwugzxof3a6qYeUSZlBQAAAMAb5eQV6I2EJJ1NzzXEu7SN0EN3dpbVYjEpM+DyWc1OAAAAAKiMVVtT9NXaQ4aYr49VT90dq6hGweYkBQAAAMBrLd94VN9uPmqI+fvZNGl0nBqHB5qUFQAAAABvdO58nqbO2aqs3AJD/Ma45hrWv51JWQEAAADwRgVOl95dsE2HT503xFs3DdETI7rLx8Y0BtRN/OQCAACgztiy94w+XW7cfdBikR65q6tiWoWbkxQAAAAAr7V+x0nNWbnPELNZLXpyRHe1aRZqUlYAAAAAvFF2rkNT52xVWkaeIR4X3VC/HthRFlaWBgAAAFBDXC63Ply6SzsOnTPEGzUI0KTRcQr09zEpM+DKMQEHAAAAdcLuw2ma/uUOud3G+P23xahXx8bmJAUAAADAa+08lKaZS3YViz90R2d1bRdpQkYAAAAAvJWjwKm352/TsTNZhvhVLcL02LBusll5PAgAAABAzfnP0l1av+OUIRYS6Ktn7umhBiH+JmUFVA0qbAAAANR6R0+d10sfbVR+gcsQH3J9G93cs6VJWQEAAADwVgeOp+vt+dvkdBlXCBh9U7Su69bMpKwAAAAAeCOXy603Zm/V7iN2Q7xpRKAmjIqVv5/NnMQAAAAAeKWFP+zTwtX7DTE/X6smxcepaWSQSVkBVYf9mwAAAFCrpaXn6vl//6Tz2Q5DvF/3Zhpxw1UmZQUAAADAW51Ky9bfZ25Qbr7TEL+lV0sNura1SVkBAAAA8EZut1sfLtqhtUnHDfGwYD9NvqeHQoP8TMoMAAAAgDdavSVFM7/aYYhZLRY9Pry72jUPMykroGoxAQcAAAC1VnZugf71xWadPpdjiHe/qqEeGNRJFovFpMwAAAAAeKOMrHz99YOfdO58niF+TcfGGntLB2oUAAAAADVq4Q/79dWaA4aYv59Nk0bHqXF4oElZAQAAAPBGOw+laVpCYrH4g3d0Umx0QxMyAqoHE3AAAABQKxU4XXpnwTYdOpFhiLdtFqrfDe8qH5vVpMwAAAAAeKN8h1P//HyLUs5kGuIxrcL127u6yGpl8g0AAACAmvPT9pP6ZOkuQ8xmtejJEd3VplmoSVkBAAAA8EaHT57X2/O3qcDpNsTv/tVV6te9uUlZAdWDpxYBAABQ67jcbs1csku7Dp8zxJtEBGri6DgF+DGPHAAAAEDNcbncmv7VDu2+pEaJahSsp+7uLl8fm0mZAQAAAPBGOw6m6cNLJt9I0kN3dlbXdpEmZAQAAADAW52x52hqQqJy852G+C29WuqOvm1MygqoPkzAAQAAQK2TsHKfNuw8ZYg1CPHT5Pg4hQX7mZQVAAAAAG/kdrv12bfJ2rL3rCEeEeqvSfFxCg7wNSkzAAAAAN7o8MnzenvBNjldxpWlR98creu6NjMpKwAAAADeKCM7X69/sVUZWfmG+PWxzTX2lg6yWCwmZQZUHybgAAAAoFb5ZuMRLd941BAL8LPpuQevVZOIIJOyAgAAAOCtFv90WKu2pBhiQQE+mhQfp8iwAJOyAgAAAOCNTv9vZem8S1aWHtK/nQb1aW1SVgAAAAC8UV6+U28mJOrUuRxDvFt0Q02852pZrUy+Qf3EBBwAAADUGht2ntLsFfsMMZvVoj8+0EftW4WbkxQAAAAAr7Um6bgWrD5giPnYrPrTA73VsnGISVkBAAAA8EYZ2fmaWsLK0v3jWuihIV1ZWRoAAABAjSlwuvTel9t18MR5Q7xNs1BNefBa+fnaTMoMqH5MwAEAAECtsOtQmmYs3lks/uToOPXs1MSEjAAAAAB4s6T9qfrk6z2GmMUiPXNfT3WLbmRSVgAAAAC8UeHK0knFV5a+qqEm39uTlaUBAAAA1Bi3261Plu1W0v5UQ7xhmL/+8ptrFRLoa1JmQM1gAg4AAABMd+TUeb01f5ucLrchfvevrtLNvVqZlBUAAAAAb3XwRIbeXbhNLrexRvnNXV3VPy7KpKwAAAAAeCOn68LK0hmGeMvGwfrjA73l68PK0gAAAABqzvzVB7R220lDLDjAR5Pie6hhg0CTsgJqDhNwAAAAYKqz9hxNTUhUbr7TEL+lZ0vd0beNSVkBAAAA8FanzmXrjYRE5Ttchvjga1trSP+rTMoKAAAAgDdyu936z7I9Ja4sPSm+h4JZWRoAAABADfr+52Na8tNhQ8zPx6oJo+PUolGwSVkBNYsJOAAAADBNZo5Dr89JVHpmviF+TcfGGntrB1ksFpMyAwAAAOCNMrLyNfWLRJ3Pdhjifbs21d03RZuUFQAAAABv9eWPB7Um6YQhdmFl6YhQf5OyAgAAAOCNNu8+rVnfJhtiFov06LCuah/VwKSsgJrHBBwAAACYIs/h1JtzE3UyLdsQj2kVrt/e1UVWK5NvAAAAANSc3PwCvZGQqNP2HEO8S9sIPXRHZ1lZIAAAAABADVq1JUVfrT1kiPn6WPX0qFhWlgYAAABQo/YcOacPFu2Q+5L4uIEddXWHxqbkBJiFCTgAAACocU6XS9O/3KH9KRmGeFSjYD11d3f5+thMygwAAACANypwuvTuwu06dPK8Id66SYieGNFdPjY+SgcAAABQc7Ykn9Gn3+wxxCwW6dGhXdWhZbg5SQEAAADwSsdOZ2ravG0qcBqn3wzv306/6hFlUlaAebhrCAAAgBrldrv12TfJ2rrvrCEeEeqvSfFxCg7wNSkzAAAAAN7I7Xbrk2W7tf1AmiHeqEGAJsbHKdDfx6TMAAAAAHijfcfS9f5XO+S+ZGnp+2+LUc8YVpYGAAAAUHNS03P1+pytyskrMMRv6tFCd/Vra05SgMmYgAMAAIAatWjtIf2w9bghFuTvo8nxcYoMCzApKwAAAADeasGaA1q77aQhFhzgo0nxcQoP8TcpKwAAAADe6ERqlt6cmyhHgcsQH3J9G93cs6VJWQEAAADwRpk5Dr0+Z6vsmfmG+NUdGun+2zvKYrGYlBlgLibgAAAAoMasTjyuhT8eNMR8bFY9PSpWUY1DTMoKAAAAgLda+csxLV532BDz87Fqwug4NW8YbFJWAAAAALzRufN5ev2LrcrKNa4s3b97c4244SqTsgIAAADgjfIdTk2bm6QTqdmGePuWDfTo0K6yWpl8A+/FBBwAAADUiK37zuo/y/YYYhZJjw7tophW4abkBAAAAMB7/ZJ8Rp99m2yIWSzSo8O6qn1UA5OyAgAAAOCNsnMLNHVOolIz8gzx7lc11LhBrCwNAAAAoOY4XS69/+UO7UtJN8SbNwzS03fHys/XZlJmQO3ABBwAAABUu/0p6Xp/4Xa53G5D/N7bYtSrYxOTsgIAAADgrfYes2v6Vzt0SYmiXw/sqKs7NDYnKQAAAABeyVHg0tvzk3TsTKYh3q55qB4f3k0+Nh7tAQAAAFAz3G63PvsmWVv3nTXEI0L9NTm+h0ICfU3KDKg9qNIBAABQrU6kZunNuUnKL3AZ4nde10a39GppUlYAAAAAvNXxs1maNjdJjktqlKH92uqmHlEmZQUAAADAG7ncbs1cslO7j9gN8SYRgZowOk7+fqwsDQAAAKDmfLX2kH7YetwQC/T30aT4ODVsEGBSVkDtwgQcAAAAVBt7Zp6mzklUZo7DEL++WzONvPEqk7ICAAAA4K3Onc/T1DlblZVbYIjfENtcw/q3MykrAAAAAN5qzop92rjrtCEWFuSryff0UFiQn0lZAQAAAPBGq7am6MsfDxpiPjarnr67u1o2DjEpK6D28TE7AQAAANRPOXkFemNOos6m5xri3dpFavzgTrJYLCZlBgAAAMAbZecWaOqcRKVm5BnisdENNW5QR2oUAAAAADVq+cYj+mbTUUPM38+mifFxahIeaFJWgPdwu91avHix5s2bp127dik7O1uNGzdW7969dd999yk2NrbKr5mYmKgxY8aoefPmWrFiRYXOSUlJ0UcffaQ1a9bo+PHjCgwMVJs2bXTnnXdqzJgxCghgJXoAAHDltiSf0afL9xhiFkmPDu2ijq0jzEkKqKWYgAMAAIAqV+B06e3523TkdKYh3qZZqB4f0U0+NjZiBAAAAFBzHAUuvbNgm46dMdYo7ZqH6XfDuslmpUYBAAAAUHPW7zypL1bsM8RsVoueGNFNbZuFmZQV4D1yc3M1YcIErVq1yhBPSUlRSkqKFi1apIkTJ+qRRx6psmtmZWXpz3/+s1wuV4XP+eGHHzRp0iRlZWV5Yvn5+UpKSlJSUpLmzZun9957Ty1btqyyPAEAgPfZe8yu97/aIbfbGL/v9hj16tjEnKSAWowJOAAAAKhSLrdbHy7ZpV2HzxniTcIDNXF0nAL8eAsKAAAAoOa43G59uLSEGiUiUBNGx8rfz2ZSZgAAAAC80c5DaZq5eFex+IN3dFK3dg1NyAjwPlOmTPFMvomOjlZ8fLwaNWqkHTt2aPbs2crOztZrr72mpk2batiwYVd8vfz8fD3++ONKTk6u8Dl79uzRU089pby8PNlsNo0aNUrXXHONsrKy9OWXX2rLli1KTk7W448/ri+++EKBgeycBQAAKu/42SxNm5skR4FxkvCQ69toQE8m+QIl4elHAAAAVKm5q/Zr/c5ThlhokK8m3ROnBsF+JmUFAAAAwFslrNynDZfUKGFBvpp8Tw+FBVGjAAAAAKg5R06d19vzt8npMi4tPeqmaF3frblJWQHeZe3atVq8eLEkqW/fvvrggw/k7+8vSRoyZIhGjRqle++9V3a7XS+//LJuueUWhYSEXPb1UlNTNWHCBG3atKlS5z3//POeyTfvvfeefvWrX3leGzNmjF588UV99tln2rNnj/7zn//o0UcfvewcAQCAdzp3Pk+vz9mqrNwCQ7x/bHONuOEqk7ICaj+r2QkAAACg/vh201Et23DEEPPztWri6Dg1jQgyKSsAAAAA3uqbjUe0fONRQ8zf16aJ8XFqEs7KsAAAAABqzll7jqbOSVRuvtMQv6VXSw2+trVJWQHe58MPP5Qk+fj46MUXX/RMvrkgOjpazz33nCTJbrcrISHhsq/1008/aeTIkZWefLNlyxb98ssvkqThw4cbJt9IksVi0ZQpUxQdHS2p8GtyOByXnScAAPA+2bkOvT5nq9Iy8gzx2OiGemBQR1ksFpMyA2o/JuAAAACgSmzcdUqzv99riFktFj0+vLvaNQ8zKSsAAAAA3mrjrlOavWKfIWazWvTEiG5q24waBQAAAEDNycxx6PU5iUrPyjfEr+nYWGNv6cDDbUANsdvtWrdunSTphhtuUKtWrUpsd8cdd6hhw4aSpGXLllX6OmlpaXriiSc0fvx4nTx5UpJ09913q2nTphU6f+nSpZ7je++9t8Q2VqvV85rdbtf69esrnScAAPBOjgKnps3bppQzWYb4VS3C9Lth3WSzMr0AKAu/IQAAALhiuw6f04zFO+W+JD5+cCfFRjc0JScAAAAA3utCjXKp8YM7qdtV1CgAAAAAak6ew6k3ExJ1Mi3bEI9pFa7f3tVFViuTb4CasnnzZrlcLklS3759S21ntVrVu3dvSVJiYqLS09MrdZ29e/fqu+++kyQFBwfrxRdf1MsvvywfH58KnX9hx5wGDRqoS5cupbYr+jWsWbOmUjkCAADv5HK59cGinUo+ajfEm0YGacKoWPn72cxJDKhDmIADAACAK3L0dKbenp+kAqdx+s3IG69S/9jmJmUFAAAAwFuVVqPc/aur1K87NQoAAACAmuN0uTT9yx3afzzDEI9qFKyn7u4uXx8ebgNq0t69ez3HMTExZbZt3769JMntdis5ObnS17JarRoxYoS+/vprjR49usLnOZ1O7d+/X5IUHR0taxkr0Ldr1042W+HfI7t37650jgAAwLu43W7N+i5ZP+85Y4g3CPbT5Pg4hQb5mZQZULdUbFo9AAAAUILU9FxNnbNVOXlOQ/zmnlG687o2JmUFAAAAwFuVVqMM6BmlO/pSowAAAACoOW63W58uT9bWfWcN8YhQf02Kj1NwgK9JmQHeKyUlxXMcFRVVZttmzZoZzruwI05FtG3bVsuXL1fr1q0rnePZs2eVn59foRxtNpsaN26skydP6vjx45W+FgAA8C5L1x/Wil9SDLEAP5smxcepcXigSVkBdQ8TcAAAAHBZMnMcen3OVtkz8w3xXjGNdd+tMbJYLCZlBgAAAMAblVWj3EuNAgAAAKCGfbX2kFYnGh+ID/L30eT4OEWGBZiUFeDd0tLSPMcRERFltg0PD/cc2+32Sl2nadOmlWpfVGVylKQGDRro5MmTlc4RAAB4lx+TTmjeDwcMMZvVoqdGdlfrpqEmZQXUTUzAAQAAQKXlO5yaNjdJJ1KzDfEOLRvot3d1kdXKg20AAAAAak6+w6lp86hRAAAAANQOP2xN0Zc/HjTEfGxWPT0qVlGNQ0zKCkBubq7n2N/fv8y2fn5+JZ5X3XJycjzH5eVYtE1N5liSsGqaWHjhMx2r1aLIyOBquQZqB8bauzDe3oXxNt/mXaf08bLdxeKTxlytfj3K3nGvshhv7+HNY80EHAAAAFSKy+XW9K92aF9KuiHeolGwnh4VKz9fm0mZAQAAAPBGLpdbHyzaqX3HjDVK84ZBeupuahQAAAAANWvr3rP6z/I9hphF0qNDuyimVbgpOQEoVFBQ4DkuOsGmJEVfL3pedXM6nSXmUJoLbWoyx5LYbNZq7d9ischmY4EVb8BYexfG27sw3uZIPnJOr/73Z7lcbkP84WHd9Kterartuoy39/DGsWYCDgAAACrM7Xbrs2+TtWXvWUM8ItRfk+PjFBzga1JmAAAAALyR2+3Wf79L1i/JZwzx8BA/TY7voZBAahQAAAAANWd/Srre/3K73MZn23TvbTHq1bGJOUkB8AgIuLhLi8PhKHOCS35+vue4IhNhqkrRXW8cDke57S/k6etr7mcgTqerWvq1Wi2yWCxyu93FHhxG/cJYexfG27sw3uZJOZOpF2asV16+0xAf/qtoDenXrlr+/Wa8vYeZY13dk7/LwwQcAAAAVNjidYe0akuKIRbo76NJ8XGKrKZtxQEAAACgNEvXH9bKXy6tUWyaFN9DDRtQowAAAACoOSdSs/Tm3CTlFxgfYrvzuja6pVdLk7ICUFRQUJDnOC8vr8ITcIpOiqluwcHBnuO8vLxy219oU3RykRkyMnJVUOAsv2ElRUYGy2azyOVyKy0tq8r7R+3BWHsXxtu7MN7mSM/M00uf/qyMrHxD/LquTTWkb+tqGwvG23uYNdY+PjZFRASV37AamTv9BwAAAHXGmsTjWrDmoCHmY7Po6bu7q2XjEJOyAgAAAOCt1m47oXk/HDDEfGwWPTkyVq2aUKMAAAAAqDn2zDxNnZOozBzjbhX9ujXTyBuvMikrAJcKCwvzHNvt9jLbFn09MjKymjIqLjQ01HOcnp5ebvsLbWoyRwAAULvl5BVo6pxEnU3PNcS7tovUg3d0ltViMSkzoH5gAg4AAADKlbjvrD5ZtscQs0h65K6u6tg6wpykAAAAAHitbQdS9fHXu4vFHx7SRZ3bUKMAAAAAqDk5eQV6o4SH27pdFakHBneShYfbgFqjbdu2nuMTJ06U2fbkyZOe4xYtWlRXSsU0adLEswvO8ePHy2zrdDp15swZSTWbIwAAqL0cBS69PX+bjpzONMTbNAvV48O7ycfG1AHgSvFbBAAAgDIdOJ6h977cLpfbbYiPvbWDrunUxKSsAAAAAHirQycz9O6C7XK6jDXKmAHt1adzU5OyAgAAAOCNCpwlP9zWlofbgFopOjrac7x3794y21543WKxqEOHDtWa16Uu5Ll///4y2x04cEBOp1OSFBMTU+15AQCA2s3ldmvmkp3adficId4kPFATR8cp0N/HpMyA+oXfJAAAAJTqZFq23khIVL7DZYgP7ttat17TyqSsAO/gdru1ePFizZs3T7t27VJ2drYaN26s3r1767777lNsbOwVXyM5OVkfffSRNmzYoNOnTys0NFTR0dEaPny4RowYIZvNVm6O33//vb788kslJSUpLS1Nvr6+ioqKUr9+/TRu3LgKrbh2pXkAAADvcdqeozfmJCrP4TTEB/Zppdv7tDYpKwAAAADeyOV268Mlu0p9uC3Aj0dygNrm6quvlq+vrxwOhzZs2KD77ruvxHZOp1ObNm2SJHXq1ElhYWE1maZ69+6tpKQkpaamau/evaVOAFq/fr3hHAAA4N3mrNinjbtOG2KhQb6afE+cGgT7mZQVUP+w1AYAAABKlJ6Zp9e/2KrMHIchfl3XZhr1q+hSzgJQFXJzc/XYY4/p97//vX766SfZ7Xbl5+crJSVFCxcu1JgxY/TBBx9c0TUSEhI0cuRIzZ8/XykpKXI4HEpLS9OmTZs0ZcoUjRs3Tna7vdTz09PT9Zvf/EZPPPGEvvnmG508eVL5+fnKysryTKgZOHCgFi5cWK15AAAA75GRna/Xv9iqjGxjjXJtl6YafXN7k7ICAAAA4K3mrtyv9TtPGWKhQb6adE+cwni4DaiVwsLC1LdvX0nSihUrdPz48RLbLVmyRGlpaZKkwYMH11h+FwwcONBz/Omnn5bYxul0atasWZKk0NBQ9e/fv0ZyAwAAtdOyDUf0zaajhpi/r00TR8epSUSQSVkB9RMTcAAAAFBMTl6B3khI0tn0XEO8a7tIPXhHJ1ksFpMyA7zDlClTtGrVKklSdHS0/vjHP+q1117TQw89pKCgIDmdTr322mv68ssvL6v/NWvW6LnnnpPD4VBgYKAefPBBvfbaa/rTn/6kmJgYSdLmzZs1efJkuVyuYue7XC498cQTWrt2rSSpRYsWeuqppzR16lS9+OKLGjRokKxWq/Lz8/WHP/xBK1asqJY8AACA98jLd+rNhCSdPpdjiHduE6GH7ugsKzUKAAAAgBr0zaajWrbxiCHm52vVxNFxasrDbUCtNn78eEmSw+HQ5MmTlZmZaXh93759eumllyRJwcHBGj16dE2nqLi4OF199dWSChcy+/rrrw2vu91uvfjiizpw4IAk6d5771VAQECN5wkAAGqHn3ac1JyV+wwxm9WiJ0Z0U7vmNbuTH+AN2O8WAAAABgVOl95dsE2HT503xNs0DdXjw7vJx8YcbqA6rV27VosXL5Yk9e3bVx988IH8/f0lSUOGDNGoUaN07733ym636+WXX9Ytt9yikJCQCvefn5+v559/Xm63W0FBQfrss8/UtWtXz+tjx47V5MmT9e2332rt2rVaunSphgwZYuhjwYIF2rRpkyfH9957T0FBF28qjx49WitWrNBTTz2lgoICPf/88+rXr5/n66iqPAAAgHdwulx678vtOngiwxBv2ThET4zoLl8fahQAAAAANWfjrlOa/f1eQ8xqsejx4d15uA2oA/r376+BAwdq+fLl2rJli4YNG6axY8eqefPm2rlzpz7//HNlZWVJkp599llFRkYazt+wYYPGjRsnSerTp0+pO9Rcqeeee0733HOPHA6HJk2apBUrVqh///7Kzc3VwoUL9csvv0iS2rZtq0cffbRacgAAALXf9oOp+nDJrmLxB+/opG5XNTQhI6D+484kAAAAPFxutz5auks7Dp0zxBs1CNDE0bEK9Gf+NlDdPvzwQ0mSj4+PXnzxRcOkFalwR5znnntOkmS325WQkFCp/r/55hsdO3ZMkvTwww8bJr1Ikp+fn1555RWFh4dLkqZPn16sjy+++EKS5O/vr3/961+GyTcXDBgwQPfff78k6dSpU1q9enWV5wEAAOo/t9ut/yzbo6T9qYZ4wzB/TYqPU1AANQoAAACAmrPr8DnNWLyzWHz84E6KjebhNqCueOWVV9S/f39J0rFjx/Tqq69q8uTJmjFjhrKysmSxWPTUU09pzJgxpuXYtWtXvfHGGwoKCpLb7dZXX32lZ599Vn/5y188k2/atGmjGTNmKDg42LQ8AQCAeQ6dzNA7C7bL6XIb4qNvjtb13ZqblBVQ/zEBBwAAAB7zVu3XTztOGWIhgb565p4eahDiX8pZAKqK3W7XunXrJEk33HCDWrVqVWK7O+64Qw0bFt7MXbZsWaWusXTpUkmSxWLR2LFjS2wTHByskSNHSpKSk5N18OBBz2uZmZlKSkqSJF1//fVq3LhxqdcaNGiQ5zgxMbFK8wAAAN7hyx8Pak3SCUMsOMBHk+J7KCKUGgUAAABAzTly6rzenp+kAqfx4baRN16l/rE83AbUJYGBgZoxY4ZeffVV9evXT5GRkfL19VXjxo01aNAg/fe//9WTTz5pdpq69dZbtWTJEo0bN05t27ZVQECAAgMD1aVLF02aNEkLFiwo9V4SAACo306fy9YbcxKVl+80xG+9pqUG9WltUlaAd2B5QAAAAEiSvt18VF9vOGKI+flaNXF0nJpGFt/dAkDV27x5s1wulySpb9++pbazWq3q3bu3li1bpsTERKWnp6tBgwYVusamTZskSR07dlRkZGSp7fr27evZjWf16tVq166dJOncuXPq3r27Tpw4oauuuqrMaxXNKSMjo0rzAAAA9d+qrSn6au0hQ8zXx6qnR8WqRSNWdgUAAABQc86m52hqQqJy8owPt93cM0p3XtfGpKwAXAmLxaKhQ4dq6NChlTrv2muv1Z49ey7rmitWrKj0OS1atNCUKVM0ZcqUy7omAACofzKy8vX6nERlZDsM8d6dmmjMLR1ksVhMygzwDkzAAQAAgDbtPq3Z3+01xKwWix4f3k1XtQgzKSvA++zde/H3MCYmpsy27du3lyS53W4lJyerd+/e5fZ/6tQpz0SYDh06lNk2Ojrac7x7927PcatWrZSQkFDutSRp//79nuPw8PAqzQMAANRvW/ae0afLjQ+zWCzSo0O7qkPLcHOSAgAAAOCVMnMcmjonUemZ+YZ4r5jGuu/WGB5uAwAAAFBjcvML9EZCok6fyzHEO7UO18NDushKfQJUO6vZCQAAAMBce46c078X7ZD7kvgDgzsqNrqRKTkB3iolJcVzHBUVVWbbZs2alXheWY4dO1bh/ps2bSqrtbBkPH78eIX6v9S8efM8x3FxcablAQAA6pZ9Kema/uUOuS8pUu6/vaN6xjQ2JykAAAAAXinf4dS0uUk6kZptiHdo2UC/vauLrFYebgMAAABQMwqcLr27YLsOnTxviLdqEqInR8bK14dpAUBN4DcNAADAix07nalp87apwGl8sm3EDe10Q2wLk7ICvFdaWprnOCIiosy2RXeUsdvtFer/3LlzFe7f19dXQUFBleq/qDVr1mjlypWSpIYNG6pfv36m5AEAAOqWE6lZmjY3SfkFLkN8yPVtdPPVZU/cBQAAAICq5HK5Nf2rHdqXkm6It2gUrKdHxcrP12ZSZgAAAAC8jdvt1kdLd2v7wTRDvGFYgCbFxykowMekzADvwwQcAAAAL5WWkaupCYnKySswxG+6OkpDrm9rTlKAl8vNzfUc+/v7l9nWz8+vxPPKkpNzcQvi8vov2qai/V9w4sQJ/d///Z/n/3/3u98pICCgxvMAAAB1iz0zT1PnJCozx2GI9+veTCNuuMqkrAAAAAB4I7fbrc++TdaWvWcN8YhQf02Oj1NwgK9JmQEAAADwRnN/2K+fdpw0xEICfTX5njiFh5T/3AWAqsN0NwAAAC+UmePQ63MSde58niF+dYdGuv+2GFksFpMyA7xbQcHFCXFFJ9iUpOjrRc8ri9PprHD/RdtUtH+pcBefhx56SKmpqZKkfv366f7776/xPKpDWFhA+Y0qyWq1eP4bGRlc5f2jdmG8vQvj7T0Y66qRnevQW//ZrLPpxgm3PTs20aR7e8nHVjvWkmK8vQvjDQAA4L0WrzukVVtSDLFAfx9Nio9TZDV8TggAAAAApfl281F9vf6IIebnY9WEUbFq3pDProGaxgQcAAAAL5PvcOqteUk6fjbLEG/fsoEeHdrV84ARgJpXdJcYh8NR5uSU/Px8z3FFJrFIxt1mHA5HGS2N1/D1rdhqjmfOnNGDDz6oAwcOSJLatGmjf/3rX8Um9VV3HtXFVo0P/losFtls/P3rLRhv78J4ew/G+vI5Clz656c/6+DxDEO8fatw/eGB3vL3q30fYzPe3oXxBgAA8C5rEo9rwZqDhpiPzaKn7+6ulo1DTMoKAAAAgDfauOuUZn+31xCzWix6bHg3RUc1MCkrwLvVvjuXAAAAqDYul1sfLNqpvcfSDfHmDYP09N2x8vO1mZQZAEkKCgryHOfl5VV4Ak7RCS2V6b88fyg4WAABAABJREFUF9oUnRhUmiNHjujhhx/W4cOHJUnNmzfXRx99pMjIyBrNozo5na4q79Nqtchiscjtdsvlcld5/6hdGG/vwnh7D8b6yrhcbr35xRZt3XvGEG/WMEh/frCP/Hys1fJv8OVivL2LmeNdnZO/zeR2u7V48WLNmzdPu3btUnZ2tho3bqzevXvrvvvuU2xs7BVfIzk5WR999JE2bNig06dPKzQ0VNHR0Ro+fLhGjBghm63szz4GDBiglJSUMttc8OOPP6px48ZXnDMAAKg9Eved1SfL9hhiFkm/vaurOraOMCcpAAAAAF5p1+FzmrF4py79dPqBQR3Vo30jU3ICwAQcAAAAr+F2u/Xf75L1S7LxwbbwED9Nju+hkEBzd5YAIIWFhXmO7Xa7QkNDS21rt9s9xyVNcimv//T09DJaFu5Mk52dXaH+k5KS9Nhjjyk1NVWSFBUVpU8++URRUVE1mkd1y8jIVUGBs0r7jIwMls1mkcvlVlpaVvknoE5jvL0L4+09GOsrk7Byn37YYnzQPTTIVxNGxcqVX6C0tAKTMisZ4+1dzBpvHx+bIiKCym9Yx+Tm5mrChAlatWqVIZ6SkqKUlBQtWrRIEydO1COPPHLZ10hISNALL7xg2GkzLS1NaWlp2rRpkxYsWKB33nlH4eHhJZ6fmZmp48ePX/b1AQBA3XbgeIbe+3K7XG7j421jbu2g3p2amJQVAAAAAG905NR5vT0/SQVOY30y4sardENcC5OyAiAxAQcAAMBrLPnpsFb+YnywLdDfpsnxPdSwgbm7SgAo1LZtW8/xiRMn1KpVq1Lbnjx50nPcokXFPly5tP+ynDp1Si6Xq9z+16xZo6efftozSaZ9+/b68MMP1bRp0xrNAwAA1D3fbj6qrzccMcT8fK2aODpOTevh5APA202ZMsUz+SY6Olrx8fFq1KiRduzYodmzZys7O1uvvfaamjZtqmHDhlW6/zVr1ui5556T2+1WYGCgxowZo27duik1NVVz585VcnKyNm/erMmTJ2vGjBmyWovvMrRnzx65//fA7WOPPabu3buXec0GDRpUOk8AAFA7nUzL1hsJicp3GHfgHHxta912Temf0wIAAABAVTtrz9HUhETl5BkXCL25Z5SGXNfGpKwAXMAEHAAAAC/wY9IJzV99wBDzsVn01MhYtWwSYlJWAC4VHR3tOd67d6/69OlTatu9e/dKkiwWizp06FCh/iMiItSwYUOlpqZ6zi/Nvn37PMcxMTEltlmxYoWefvppz+rScXFxmj59uiIiImo0DwAAUPds2n1as78zvg+wWix6fHh3tWseVspZAOqqtWvXavHixZKkvn376oMPPpC/v78kaciQIRo1apTuvfde2e12vfzyy7rlllsUElLxzyvy8/P1/PPPy+12KygoSJ999pm6du3qeX3s2LGaPHmyvv32W61du1ZLly7VkCFDivWzZ88ez/Hw4cPVrl27y/2SAQBAHZKemafXv9iqzByHIX5d16a6+6boUs4CAAAAgKqXmePQ63MSlZ6Zb4j3imms+26NkcViMSkzABcUX94LAAAA9UrS/lR9/PVuQ8wi6eEhXdSpTdkPyQOoWVdffbV8fX0lSRs2bCi1ndPp1KZNmyRJnTp1UlhYxR9S7d27tyRp165dOn/+fKnt1q9f7zkuaSLQxo0bNWHCBM/km379+unjjz8ud/JNVecBAADqnj1Hzunfi3bIfUn8gcEdFRvd0JScAFSvDz/8UJLk4+OjF1980TP55oLo6Gg999xzkiS73a6EhIRK9f/NN9/o2LFjkqSHH37YMPlGkvz8/PTKK68oPDxckjR9+vQS+7kwAcff319t2rCSJAAA3iAnr0BvJCTpbHquId61XaQevKOzrDzcBgAAAKCG5DmcejMhUSfTsg3xmJYN9MjQLrJaqU+A2oAJOAAAAPXYwRMZenfhNrncxkfbxtzSQX06NzUpKwClCQsLU9++fSUV7i5z/PjxEtstWbJEaWlpkqTBgwdX6hoDBw6UJBUUFOjzzz8vsU1mZqYWLFggSWrXrp06depkeD01NVUTJkxQfn7hiis333yz3n//fQUFBdVoHgAAoO45diZT0+ZtU4HTWKOMuKGdbohtYVJWAKqT3W7XunXrJEk33HCDWrVqVWK7O+64Qw0bFk7CW7ZsWaWusXTpUkmFO4SOHTu2xDbBwcEaOXKkJCk5OVkHDx4s1ubCBJz27dvLauUWGgAA9V2B06V3F2zT4VPGBYLaNA3V48O7ycfG+wEAAAAANcPpcun9hdu1//j/z959x0dVpv0f/85MJr1TQi8GQg2hCKJgQxQLgiCJoILouroPYoHddddFV/dZdfWxAHZcxA4aQFCKWECkCVIkdEKXhJ6Q3iYz5/cHPyKHhJBIMgeYz/v18rXnuc597nPF8wg5M/d13TmmeOO6IXp4SCc5/RwWZQbgdHxaAAAAcJE6fLxAE6anqMTlMcVvvKyZru9e8WIXANYbOXKkJMnlcmns2LHKy8sznd+5c6eee+45SScWkCUmJlZr/r59+6pJkyaSpDfffFNr1qwxnS8pKdHjjz+urKwsSdK9995bbo5///vfZQVAnTp10sSJE+Xv7+/1PAAAwIUlM6dI45NTVFhcaopf06Wx+l/RwpqkANS6NWvWyOM58dnEyYYDFbHb7WU7ZaakpCg7O7vK9zi5Q2ibNm0UHR19xnGn3n/JkiWmc4ZhaMeOHZKkuLi4Kt8bAABcmDyGoffnb9XmvcdN8boRgXossZOCAvwsygwAAACArzEMQx8t2K6UXRmmeFRYgMYkJSgk0GlRZgAqwicGAAAAF6Hs/BK9+vl65Ra4TPGeHWI05JpYi7ICUBW9e/dWv3799M033+iXX37RwIEDNWzYMDVs2FBbtmzRtGnTlJ+fL0l6/PHHyy0uW7VqlUaMGCFJ6tGjhz7++GPTeX9/f40bN06jRo1SUVGRRo4cqcTERHXt2lVZWVlKTk5WamqqJKlr164aMmSI6fpdu3aZulHfeOONWrp06Vl/rsjISF166aU1lgcAALiw5Be5ND45Rcdzi03xLq3r6u7r42Sz2SzKDEBtO1nUIp29sKVVq1aSTnzhnJqaWlaQU5nDhw8rJ+dEV8jWrVtXOjY29rfPRLZt22Y6l56eXtYA4eQ8eXl52rZtm/Lz81W/fn3FxcXJ4aDTJAAAF4OZP+7ST5sPm2KhQU79+Y7OiggNsCgrAAAAAL5o9tI9WrrhoCkWHOCnsUkJig4PtCgrAGdCAQ4AAMBFpqikVBOmp+hoVpEp3qFFlO67uZ3sLGwDznsvvvii8vPztWzZMqWlpemll14ynbfZbBo9erSGDh36u+bv06ePnn76aT333HNyuVyaOnWqpk6dahoTHx+vt956q9zistmzZ8swjLL/+//+7/+qdM+KioHOJQ8AAHDhcJW69frMjUo/lm+Kt2ocoQcHdJDdzjsKcDFLT08vO27cuHGlYxs0aGC6rioFOGlpaVWePyYmRna7XR6PRwcOHDCd2759e9mx3W7X6NGjtWjRIrnd7rJ4ZGSk7r77bv3xj39UYCBffAMAcKH6fs1+fb3yV1PM32nXY4kJiokOtigrAAAAAL7oh1/SNWfFXlPM6WfXI0M6qXG9UGuSAlApCnAAAAAuIqVuj96atUn7DuWa4s1iQjVqULz8HHaLMgNQHUFBQZo8ebLmzJmj2bNna+vWrcrNzVVkZKS6deumESNGqFu3bud0j2HDhunSSy/Vhx9+qBUrVujo0aNyOp2Ki4vTrbfeqqSkJDmd5bcxPrkrTU35vXkAAIALg8dj6L9ztih1f5Yp3rBOsB4Z0kn+TopsgYtdZmZm2XFUVFSlYyMjI8uOs7KyqjT/8ePHqzy/0+lUcHCw8vLyys1/agHOCy+8UOH1WVlZeuONN7RkyRJNmjSp3I6kAADg/Ld62xFN+36HKWa32TTqto66pFG4RVkBAAAA8EVrtx/VJ99uN8VsNunBAR0U1zTSmqQAnBUFOAAAABcJwzD0wdfbtGlPpileNyJQYxITFBTAr37AhcRms2nAgAEaMGBAta677LLLTAvHKtO6dWs9++yz1Zp/0qRJ1RpfW3kAAIDzn2EYmrZwh9ZsP2qKR4T6a0xSgkKDKLIFfEFR0W879AYEBFQ61t/fv8LrKlNYWFjl+U+OycvLKzf/qe9RTqdT9957r2677TY1bdpUWVlZ+vHHHzVx4kQdPXpUGzZs0JgxY/T+++/Lbrem2Ul4eO3swHNyVzK73abo6JBauQfOHzxv38Gz9i087zPbtOuY/jtni4zT4g8N6aRrujezJKdzxfP2LTxvAACAi0fq/ixN+mqzjNNeUO6+oY26xtWzJikAVcIqTAAAgIvEzB93a8WmQ6ZYaJBTY+/orIjQsy9AAQAAAICatGDVr1q4Ns0UC/R3aExigupGBFmUFQBvKy0tLTs+tcCmIqeeP/W6yrjd7irPf+qY0+c/fPiwpBMFOlOmTNGll15adq5+/fpKTEzUVVddpaSkJB06dEgrV67U/Pnz1b9//yrlWdMctbzLsc1mk8Nhq9V74PzB8/YdPGvfwvM223swR//5cLVK3R5T/O4b2+qGni2sSaoG8bx9C88bAADgwpZ+NE+vzdhQ7v1kQK8WurZLY4uyAlBVFOAAAABcBBauTdP8lftMMX8/ux5N7KQG0cEWZQUAAADAV/206ZCmL95lijnsNo0eHK9mMWEWZQXACoGBv+3U4nK5Ki2SKSkpKTuuSjGNZN71xuVynXX8yXs4neZduD777DPl5eUpNzdXDRs2rPDamJgYPfnkkxo9erQkKTk52bICHPdpX87XFLvdJpvNJsMw5PGcvj8ALjY8b9/Bs/YtPO/yjmYV6pn//qT8InMB7o09m+v2a1vV2t+r3sDz9i1WPe/aLv4GAADwJZk5RXo1OUUFxeb3k6sSGmpg75YWZQWgOijAAQAAuMCt2XZEU79LNcXsNpv+dFtHxTaKsCgrAAAAAL5q855MTZm/tVz8D/3bqX2LaAsyAmCl4ODfGoMUFxdXuQDn1MKa6sx/NifHnFoYdFJoaKhCQ0Mrvb5Pnz4KDQ1VXl6efvnlF3k8Htnt3l+QmJNTpNJS99kHVlN0dIgcDps8HkOZmfk1Pj/OLzxv38Gz9i08b7O8Qpde+HSdMrKLTPEuretqyFWX6PjxAosyqxk8b99ixfP283MoKopmfwAAADUhv8il8ckpOp5r/hyzc6u6Gt6vjWw2djkELgS0KAAAALiAbf/1uN6ds0Wn97gacWMbdW5V15KcAAAAAPiufYdy9casjXKf1ok36dpW6tm+gUVZAbBSeHh42XFWVlalY089Hx1dtYK9U+fPzs6udKzL5VJBQUG15j+dw+FQ8+bNJZ0oGDrbzwQAAKxT4nLr9ZkbdOCYuVChVeMIPTigg+x2FrcBAAAA8I4Sl1uvz9ig9NPeT2IbhevBgR3ksKDJD4Dfh/9aAQAALlBpR/P02syNKnV7TPHberfUVQmNLMoKAAAAgK86mlWo8dNTVFxi3pHh+kubql+PphZlBcBqLVq0KDs+ePBgpWMPHTpUdtyoUdU+26jO/IcPH5bH46nW/BVxOp2/+1oAAOAdHo+hd+ds0Y40c4FuwzrBemRIJ/k7HRZlBgAAAMDXnHw/ST3t/aRBdLAeTUxQAO8nwAXFz+oEAAAAUH2ZOUUan5yiwuJSU/zqzo10a68W1iQFAAAAwGflFpTo1eQU5eSXmOLd29bXHde1ks1GZ2nAV8XGxpYd79ixQz169Djj2B07dkiSbDabWrduXaX5o6KiVKdOHWVkZJRdfyY7d+4sO46Liys73r9/vxYtWqSMjAx17dpV11xzTaXzHD58WNKJQpyIiIgq5QkAALzHMAx9+n2q1qUeNcUjQ/01JilBoUEU0wIAAADwDsMw9Ml35d9PIkL9NfYO3k+ACxEFOP+fYRiaO3euZs6cqa1bt6qgoED16tVT9+7dddddd6lTp07nfI/U1FS9//77WrVqlY4cOaKwsDDFxsbqtttu06BBg+RwVL+CMSUlRUOHDlXDhg21aNGiKl2Tnp6u999/X0uXLtWBAwcUFBSk5s2b65ZbbtHQoUMVGBhY7TwAAID35Be5ND45Rcdzi03xzq3q6u4b4ljYBgAAAMCril1uvTZjgw5nFpjibZtF6v7+7WXnHQXwaV26dJHT6ZTL5dKqVat01113VTjO7XZr9erVkqS2bdsqPDy8yvfo3r27FixYoK1btyo3N1dhYWEVjlu5cmXZ8amFQEeOHNHzzz8vSerTp0+lBTh79uwp22knPj7+d323AwAAate8n/bph3XpplhQgENjkjqrbkSQRVkBAAAA8EVzV+zV4l/Kv5+M5f0EuGDZrU7gfFBUVKQ//elP+stf/qKffvpJWVlZKikpUXp6umbPnq2hQ4fq3XffPad7TJ8+XYMHD9YXX3yh9PR0uVwuZWZmavXq1Ro3bpxGjBihrKysas2Zn5+vJ598Uh6Pp8rX/Pjjj7r11lv18ccfa+/evSopKVF2drY2bNig//znP0pMTFRaWlo1fzoAAOAtrlK3Xp+5UenH8k3x2MbhenBgBzns/HoHAAAAwHvcHo8mfblZuw7kmOJN6oVo9OB4Of14RwF8XXh4uHr27ClJWrRokQ4cOFDhuHnz5ikzM1OSdNNNN1XrHv369ZMklZaWatq0aRWOycvL06xZsyRJLVu2VNu2bcvOdezYUaGhoZJU1rzsTN5+++2y44EDB1YrTwAAUPuWbTioL5bsNsX8HDaNHtxJTeuHWpQVAAAAAF+0JOWAZi3dY4r5OWx6mPcT4ILGt5+Sxo0bp8WLF0uSYmNj9cQTT+iVV17Rfffdp+DgYLndbr3yyiv68ssvf9f8S5cu1VNPPSWXy6WgoCDde++9euWVV/SPf/xDcXFxkqQ1a9Zo7NixVS6mKSkp0ahRo5SamlrlPLZv366HH35Y+fn5cjgcuuOOO/TSSy/pmWeeUZcuXSSd2KVn1KhRKiwsrP4PCgAAapXHY+jdOVuUuj/LFG9YJ1iPDklQgJOOqwAAAAC8xzAMffxNqtbvPGaKR4cHaExSZwUHOi3KDMD5ZuTIkZIkl8ulsWPHKi8vz3R+586deu655yRJISEhSkxMrNb8ffv2VZMmTSRJb775ptasWWM6X1JSoscff7ysEdq9995rOh8QEKCkpKSyHP/85z+Xy1GS3nvvvbLvilq0aKFBgwZVK08AAFC7NuzK0AdfbysXv79/e7VrHmVBRgAAAAB81fqdx/TRgu2mmE0n3k/a8n4CXND8rE7AasuXL9fcuXMlST179tS7776rgIAASVL//v01ZMgQ3XnnncrKytLzzz+v6667rqwLWlWUlJTomWeekWEYCg4O1ieffKIOHTqUnR82bJjGjh2r7777TsuXL9f8+fPVv3//SufMyMjQo48+qtWrV1frZ33mmWdUXFwsh8Oht99+W1dffXXZuaFDh+rZZ5/VJ598ou3bt+ujjz7Sgw8+WK35AQBA7TEMQ9O+36G124+a4hGh/hqTlKDQIBa2AQAAAPCuOcv3akmKeZeI4AA/jUnqrKiwAIuyAnA+6t27t/r166dvvvlGv/zyiwYOHKhhw4apYcOG2rJli6ZNm6b8/BO7/T7++OOKjo42Xb9q1SqNGDFCktSjRw99/PHHpvP+/v4aN26cRo0apaKiIo0cOVKJiYnq2rWrsrKylJycXNbQrGvXrhoyZEi5HEeNGqUffvhBe/bs0bp163TLLbfojjvuUIsWLXT8+HHNnz+/rLAnJCREL7/8ctn3SQAAwHp7Dubordkb5TEMU3zoda3Vo12MRVkBAAAA8EW70rP1zuxN5d5PhvXl/QS4GPj8DjhTpkyRJPn5+enZZ58t92VJbGysnnrqKUlSVlaWpk+fXq35v/32W6WlpUmS7r//flPxjXTiS6EXX3xRkZGRkqRJkyZVOt9PP/2kwYMHV7v45pdfftG6deskSbfddpup+EaSbDabxo0bp9jYWEkn/r24XK5q3QMAANSe+Sv3aeG6NFMsKMChMYkJqhsRZFFWAAAAAHzVkpQDmr1sjynm57DrkSGd1LhuiEVZATifvfjii+rdu7ckKS0tTS+99JLGjh2ryZMnKz8/XzabTQ8//LCGDh36u+bv06ePnn76aTmdTrlcLk2dOlV/+ctf9Oyzz5YV38THx+utt96Sw1F+F+GwsDC9//776tixoyTp0KFDmjhxosaMGaP//d//LSu+adiwof773/8qPj7+d+UJAABq3uHjBZowPUUlLo8pfmOPZrqhe1OLsgIAAADgiw5m5J94Pyk1v5/c3LO5+l7K+wlwMfDpApysrCytWLFCknTllVeqadOK/2C7+eabVadOHUnSggULqnWP+fPnSzpR4DJs2LAKx4SEhGjw4MGSpNTUVO3Zs6fcmMzMTD300EMaOXKkDh06JEm6/fbbFRNTtUrIk3lI0p133lnhGLvdXnYuKytLK1eurNLcAACgdi3feFAzf9xtijnsNo0eFK9mMWEWZQUAAADAV63feUwfLdhuitkkPTigveKaRlqSE4DzX1BQkCZPnqyXXnpJvXr1UnR0tJxOp+rVq6cbb7xRn376qUaPHn1O9xg2bJhmzZqlxMRENW7cWP7+/goJCVGXLl30z3/+U9OmTVNUVNQZr2/YsKE+//xzvfjii7rqqqtUp04dOZ1ORUVFqUuXLvrb3/6mefPmqVu3bueUJwAAqDk5+SUa/3mKcgvMDUZ7dojRkGtjLcoKAAAAgC86nlusVz9PUX5RqSl+RccGuv3qSyzKCkBN87M6ASutWbNGHs+JCsOePXuecZzdblf37t21YMECpaSkKDs7WxEREVW6x8mdatq0aaPo6OgzjuvZs2fZbjxLlixRy5YtTed37Nih77//XtKJgp0nnnhCiYmJ6tOnT7XyiIiIUPv27SvN46SlS5fqyiuvrNL8AACgdmzcnaEPvt5WLn5///Zq1+LMv1sAAAAAQG3YdSBb78zeJI9hmOJ3Xh+nbm3qW5QVgAuFzWbTgAEDNGDAgGpdd9lll2n79u1nHyipdevWevbZZ39PepIkPz8/3Xbbbbrtttt+9xwAAMA7ikpKNWF6io5kFZri7VtE6b6b28lus1mUGQAAAABfU1BUqvHJKcrIKTLFO14SrZE3tZWN9xPgouHTO+Ds2LGj7DguLq7Ssa1atZIkGYah1NTUKs1/+PBh5eTkSDrxhU9lYmN/67yybVv5RbbSiUKgQYMG6euvv1ZiYmKVcpAkt9utXbt2ld3Hbj/zY2/ZsqUcDkeleQAAAO/YczBHb83aJLfHvLBtaJ9Wuqx91XbBAwAAAICaciizQBOnb1BJqccUv7lnc13XrYlFWQEAAADwRaVuj96atUl7D+Wa4s3qh+qhQfHyc/j0chgAAAAAXuQq9eiNLzYo7WieKd6iQZhG3daR9xPgIuPTO+Ckp6eXHTdu3LjSsQ0aNDBd171797POn5aWVuX5Y2JiZLfb5fF4dODAgXLnW7RooW+++UbNmjU7631Pd+zYMZWUlFQpD4fDoXr16unQoUMV5gEAALzjyPECTZyeomKX2xTv16OpbuhR/d8HAAAAAOBcZOeX6NXP1yuv0GWKX9GxgW6/+hKLsgIAAADgiwzD0Adfb9OmPZmmeN2IQI1JSlBQgE8vhQEAAADgRR7D0OS5W7Tt1yxTvH5UkB5LTFCgP+8nwMXGp0vqMjN/+zAmKiqq0rGRkZFlx1lZWVWa//jx41We3+l0Kjg4+Izzx8TE/K7iG6l6P6ckRUREnDEPAABQ+3LyS/Tq5ynKKTAvbOvZPkaJ17ayKCsAAAAAvqqwuFQTklN0LLvIFO/QMlojb2orm81mUWYAAAAAfNEXS3ZrxaZDplhokFNjkhIUERpgUVYAAAAAfI1hGPrs+x1ave2IKR4e7NTYOzorPMTfoswA1CafLsApKvrtC+OAgMo/hPH3/+0PwVOvq0xhYWGV5z91TFXnr6rzJQ8AAHB2RSWlmjA9RUeyCk3xds2jdN8t7WRnYRsAAAAALyp1e/TW7E3adzjXFG8eE6ZRt3WUn8OnP2IGAAAA4GUL16Zp3k/7TDF/P7seHdJJDeuEWJQVAAAAAF+0YNWv+n5tmikW4O/QmKTOqh8ZZFFWAGqbT+9rVVpaWnZ8aoFNRU49f+p1lXG73VWe/9QxVZ2/qs6XPKorPDywxue0221l/xsdzYdvFzuet2/hefuWi/V5l7o9euODn7X3kHlhW8tG4XrqD5cpONBpUWbWulifN8rjWQMAAJxfDMPQB19v0+Y9maZ43YhAPZbYSUEBPv3xMgAAAAAvW7PtiKZ+l2qK2WzSnwZ2VGzjCIuyAgAAAOCLVmw6qOmLd5liDrtNowfFq3mDMIuyAuANPv0NaWDgbwUeLper0uKUkpKSsuOqFLFI5t1mXC7XWcefvIfTWbOLa8+XPKrLUYvdM202mxwOdhDwFTxv38Lz9i0X0/M2DENvJW/Quu1HTfH6UUF65o+XKyzk7LvYXewupueNyvGsAQAAzg9fLNmtFZsOmWKhQU79+Y7OigjlHQUAAACA96Tuz9K7c7bIOC1+z41t1bl1XUtyAgAAAOCbNu3O0Pvzt5WL33dLO3VoGW1BRgC8yacLcIKDg8uOi4uLq1yAc2pBS3XmP5uTY04tDKoJISG/dQ+3Mo/qcrs9NT6n3W6TzWaTYRjyeE7/aA4XG563b+F5+5aL8Xl/smCrFq3Zb4qFBTv19B96KiLEv1b+XrxQXIzPGxWz8lnXZvE3AADAhWjh2jTN+2mfKebvtOvRxE6KiQ4+w1UAAAAAUPPSj+bptRkbVHradyUDe7fUVQmNLMoKAAAAgC/aczBHb87aJPdp61qSrm2lyzs0sCgrAN7k0wU44eHhZcdZWVkKCzvzll9ZWVllx9HRVatOPHX+7OzsSse6XC4VFBRUa/6qOvXnOlsep46p6TyqKyenSKWl7hqdMzo6RA6HTR6PoczM/BqdG+cfnrdv4Xn7lovteS9al6YZi3aaYv5+dj18eycF+dkuip/xXFxszxtnZtWz9vNzKCqKRaQAAAAnrd1+RFO/SzXF7Dab/mdgR8U2irAoKwAAAAC+KDOnSK8mp6iguNQUvyqhkQb0amFNUgAAAAB80uHjBZowPUXFLvPa5hu6N9WNlzWzKCsA3ubTbZ5btGhRdnzw4MFKxx46dKjsuFGjqnVQqc78hw8flsfjqdb8VVW/fv2yXXAOHDhQ6Vi3262jR4/WSh4AAKC8tduP6NNvzQvbbDbpwYEd1KoxC9sAAAAAeFfq/ixN+mqLTt+PcMSNbZTQqq4lOQEAAADwTQVFLo1PTtHx3GJTvHOruhreL042m82izAAAAAD4muz8Er36+XrlFrhM8cvaxyipTyuLsgJgBZ8uwImNjS073rFjR6VjT5632Wxq3bp1leaPiopSnTp1qjT/zp2/db2Pi4ur0vzVcfJn3bVrV6Xjdu/eLbfbXWt5AACA35xxYVu/NurSup4lOQEAAADwXenH8vXajA0qdXtM8dt6t9RVCTTrAQAAAOA9rlK3Xpu5UenHzLulxzYO14MDO8hh9+nlLgAAAAC8qLC4VBOSU3Q0q8gUb98iSn+4pZ3sNAcAfIpPfyLRpUsXOZ1OSdKqVavOOM7tdmv16tWSpLZt2yo8PLzK9+jevbskaevWrcrNzT3juJUrV5Yd9+jRo8rzVzePjIyMSouBTs3j5DUAAKDmpR/Nq3Bh24BeLXR158YWZQUAAADAV2XmFGl88noVFJea4lclNNKtvVpYkxQAAAAAn+TxGPrvnC1K3Z9lijeIDtajQxIU4HRYkxgAAAAAn1Pq9uit2Zu077B5DXiz+qF6aFC8/Bw+vRQf8Ek+/V99eHi4evbsKUlatGiRDhw4UOG4efPmKTMzU5J00003Vese/fr1kySVlpZq2rRpFY7Jy8vTrFmzJEktW7ZU27Ztq3WP6uQhSR9//HGFY9xut6ZOnSpJCgsLU+/evWs8DwAAcGJh26vJKRUubBvYu6VFWQEAAADwVQVFLo2fnqLMnGJTvHOruhreL042OrcBAAAA8BLDMDRt4Q6t2X7UFI8I8dfYpASFBjktygwAAACAr/EYhqbM36rNezJN8boRgRqTlKCgAD+LMgNgJZ8uwJGkkSNHSpJcLpfGjh2rvLw80/mdO3fqueeekySFhIQoMTGxWvP37dtXTZo0kSS9+eabWrNmjel8SUmJHn/8cWVlZUmS7r333t/xU5xdQkKCunTpIkmaPn26vv76a9N5wzD07LPPavfu3ZKkO++8U4GBgbWSCwAAvuzkwrbjuSxsAwAAAGA9V6lHb3yxUelH803x2EbhenBgBznsPv8RMgAAAAAv+nrVr1q4Ns0UC/R3aExSgupGBlmUFQAAAABfNGPxLq3cfNgUCw1yauwdnRURGmBRVgCs5vOld71791a/fv30zTff6JdfftHAgQM1bNgwNWzYUFu2bNG0adOUn3/iy+fHH39c0dHRputXrVqlESNGSJJ69OhRbncZf39/jRs3TqNGjVJRUZFGjhypxMREde3aVVlZWUpOTlZqaqokqWvXrhoyZEit/axPPfWU7rjjDrlcLo0ZM0aLFi1S7969VVRUpNmzZ2vdunWSpBYtWujBBx+stTwAAPBVrlK3Xp/JwjYAAAAA5wePYWjy3C3a9muWKR4THaxHhnRSgNNhTWIAAAAAfNKKTQc1Y/EuU8xht2n04Hg1iwmzKCsAAAAAvujbn3/VglW/mmL+TrseS0xQg+hgi7ICcD7w+QIcSXrxxReVn5+vZcuWKS0tTS+99JLpvM1m0+jRozV06NDfNX+fPn309NNP67nnnpPL5dLUqVM1depU05j4+Hi99dZbcjhq70vtDh06aMKECfrrX/+qgoICffXVV/rqq69MY5o3b67JkycrJCSk1vIAAMAXeQxD/527Vdv3Z5niLGwDAAAAYAXDMPT5wp1ave2IKR4R4q+xSQkKC/a3KDMAAAAAvmjT7gy9P39bufgf+rdT+xbRFVwBAAAAALVj1ZbD+mzRTlPMbrNp1G3xuqRRuEVZAThfUIAjKSgoSJMnT9acOXM0e/Zsbd26Vbm5uYqMjFS3bt00YsQIdevW7ZzuMWzYMF166aX68MMPtWLFCh09elROp1NxcXG69dZblZSUJKfTWUM/0Zn17dtX8+bN0/vvv68lS5bo0KFDstlsatmypfr166fhw4dTfAMAQA0zDEOffb9DaypY2PZnFrYBAAAAsMA3P+/Xd2v2m2IB/g49lpigepFBFmUFAAAAwBftPZSjN2dtkttjmOJJ17ZSz/YNLMoKAAAAgC/aujdTk+duKRcfeVNbdYqtY0FGAM43FOD8fzabTQMGDNCAAQOqdd1ll12m7du3V2ls69at9eyzz/6e9M5o0aJF1b6mUaNGGjdunMaNG1ejuQAAgIotWPWrvl+bZooF+js0JilBdVnYBgAAAMDLVm45pOQfzJ3bHHabRg+KV/MGYRZlBQAAAMAXHTleoAnJKSp2uU3xG7o31Y2XNbMoKwAAAAC+6NfDuXr9i43lmgPcfvUl6t2poUVZATjf2K1OAAAA4GK2YtNBTV+8yxRz2G0aPThezWJY2AYAAADAu7bszdR7c7eWi993czt1aBltQUYAAAAAfFVOfoleTU5RToHLFO/Rrr6S+rSyKCsAAAAAvuhoVqHGJ6eoqMTcHOC6rk10c8/mFmUF4HxEAQ4AAEAt2bQnQ+/P31Yu/of+7dS+BQvbAAAAAHjXr4dz9UYFndsSr4nV5R0bWJQVAAAAAF9UVFKqiTNSdOR4oSnetlmk/nBLe9ltNosyAwAAAOBrcgpK9Orn65WdX2KKX9qmnob1bS0b7ycATkEBDgAAQC3YdyhXb87aVG5hW9K1rdSzPQvbAAAAAHjXsaxCjZ9eQee2bk1042XNLMoKAAAAgC8qdXv09uzN2nMw1xRvUi9Uowd3ktOPpSwAAAAAvKO4xK2J0zfo8GnNAdo0jdQfb20vu53iGwBmfGoBAABQw45kFWp88noVn7aw7YbuTVnYBgAAAMDr8gpdejU5Rdl5FXRuu47ObQAAAAC8xzAMfbhgmzbuzjDF64QHakxSgoID/SzKDAAAAICvKXV79PaXm7TnYI4p3qReiB6+PV5OP4dFmQE4n513n1wcOnRIhw4dUkxMjBo2bGh1OgAAANVyckvSnAKXKd6jXX0l9WllUVYAAAAAfFWJy63XZmzQocwCUzyOzm0AAAAALDBr6R4t33jIFAsJ9NPYOxIUFRZgUVYAAAAAfI1hGPpowXZt2GVuDhAdHqAxSZ0VHOi0KDMA5zuvF+CsWbNGGzdu1L333muKHzhwQH/729+0Zs2asljHjh31xBNPqGvXrt5OEwAAoNpObEmaoiOnbUnatlmk/nBLe9npKg0AAADAizweQ5O+2qyd6dmmeOO6dG4DAAAA4H0//JKuuSv2mmJOP7seHZKghnVCrEkKAAAAgE+atXS3lm08aIqFBPppbFJnmgMAqJTdWzc6fvy47r77bg0fPlwvv/yySktLy84VFhbq7rvv1po1a2QYRtk/Gzdu1MiRI/Xjjz96K00AAIDf5bctSXNN8Sb1QjV6cCc5/bz2axcAAAAAyDAMffJdqn7ZccwUjwoL0JikBIXQuQ0AAACAF61LPapPvt1uitls0p8GdlCrJhEWZQUAAADAFy1cm6a5K/aZYiebAzSqS3MAAJXz2krQ//mf/9HatWtlGIY8Ho/S09PLzn300Uc6cOBA2f8dGxurOnXqSJJKSko0btw45eXleStVAACAajEMQx99U35L0jrhgRqTlKDgQK9vOggAAADAx839aZ8W/5JuigUF+GlMUoKiwwMtygoAAACAL9qRlqVJX22WYZjjw/u1UZfW9axJCgAAAIBPWrPtiKZ+l2qK0RwAQHV4pQDnhx9+0Pr16yVJwcHBeuihhxQdHV12/osvvig7fuqppzRv3jwtW7ZM99xzjyQpIyNDs2bN8kaqAAAA1TZr6R4t21DBlqR3JLAlKQAAAACvW7rhgGYt2W2K+TlseuT2eDWpF2pRVgAAAAB8UfqxfL02Y4NcpR5TfECvFrqmc2OLsgIAAADgi7b/elzvztmi03oDaATNAQBUg1cKcL799tsTN7Pb9dFHH2n06NEKCwuTJO3YsUP79u2TzWZTw4YNddddd0mSbDabnnjiCbVq1UqStGjRIm+kCgAAUC0//JKuuSv2mmIntyRtWIctSQEAAAB414ZdGfrw6+2mmE3SH2/toDbNoqxJCgAAAIBPOp5brPHJ65VfVGqKX9mpoQb2bmlRVgAAAAB8UdqRPL02c6NK3ebmAAN7t9TVNAcAUA1eKcBZt26dbDabrrnmGnXs2NF0bvHixWXHffr0KXdt7969ZRiG9uzZU9tpAgAAVMu61KP65NvTFrbZpD8NYEtSAAAAAN6352CO3pq9UR7D3LttaN/W6t62vkVZAQAAAPBFBUUujU9er8ycYlO8U2wdjbixjWw2m0WZAQAAAPA1GdlFGj89RYXF5uYAV3dupAG9WliTFIALllcKcDIyMiRJrVu3Lndu2bJlZcdXXHFFufPR0dGSpMzMzFrKDgAAoPp2pGVp0lebddq6Ng2/oY26xLElKQAAAADvOny8QBOmp6jEZe7cdtNlzXT9pU0tygoAAACAL3KVevTGFxuVdjTfFG/ZMFz/M7CjHHavLFUBAAAAAOUVuvRq8nodzzU3B+jSuq7uviGO5gAAqs0rn2oUFRVJkoKDg03xwsJCrVu37kQidrt69OhR7trjx49LkhwORy1nCQAAUDXpx/L12owNcpWaF7bdekULXdOFLUkBAAAAeFdOfonGf56i3AKXKd6zQ4xuvybWoqwAAAAA+CKPYWjy3C3a9muWKR4TFaRHEzspwJ+1HwAAAAC8o8Tl1mszNuhgRoEp3qpxhB4c0IHmAAB+F6/8yREVFSVJOnTokCm+atUquVwu2Ww2xcfHKzQ0tNy1qampkqR69egkDwAArHc8t1jjk9crv8i8JemVnRrqtitbWpQVAAAAAF9VVFKqCdNTdCSr0BRv3yJK993cTnY6twEAAADwEsMw9NnCHVq97YgpHh7ir7F3dFZ4sL9FmQEAAADwNW6PR5O+2qyd6dmmeMM6wXpkSCf5O2kOAOD38UoBTocOHWQYhhYvXqySkpKy+Jdffll2fO2115a7buPGjVq+fLlsNpvatWvnjVQBAADOqKDIpfHJ65WZY96StFNsHY24sQ1bkgIAAADwqlK3R2/N3qS9h3JN8Wb1Q/XQoHj5OejcBgAAAMB7Fvz8q75fk2aKBfg7NCYxQfUigyzKCgAAAICvMQxDn3ybql92HDPFI0P9NTaps0KDnBZlBuBi4JVvYK+//npJ0sGDB/XHP/5RCxcu1CuvvKKvv/5akmSz2XTzzTeXjS8tLdU333yjP/7xj2Wxfv36eSNVAACACrlKPXrji41KO5pvirdsGK7/GdiRLUkBAAAAeJVhGPpwwTZt2p1piteNCNSYpAQFBfhZlBkAAAAAX/TTpkOa/sMuU8xht2n0oHg1bxBmUVYAAAAAfNGc5Xv14/oDplhQgJ/GJnVWnYhAi7ICcLHwyrewAwYM0OTJk7Vnzx79/PPP+vnnn8vO2Ww2DRw4UE2bNi2LXXPNNcrIyJBhGJKkjh076qabbvJGqgAAAOV4DEOT527Rtl+zTPGYqCA9mthJAf5sSQoAAADAu2Yt3a3lGw+ZYqFBTo1JSlBEaIBFWQEAAADwRZv3ZGrK/K3l4vfd0k4dWkZbkBEAAAAAX/Xj+nTNXrbHFPNz2PXI7fFqUj/UoqwAXEy80qrd6XTq3XffVWxsrAzDKPtHkrp3765x48aZxsfExJSdb9Omjd5++23ZbDZvpAoAAGBiGIY+X7hTq7cdMcXDQ/w19o7OCg/2tygzAAAAAL7qh3Vpmrtinynm72fXo0M6qWGdEIuyAgAAAOCL9h3K1RuzNsrtMUzxxGtjdXmHBhZlBQAAAMAX/bLjqD76ZrspZpP0wK3t1aZZlDVJAbjoeGUHHElq2rSpZs2apW+//Vbr16+Xn5+funfvrj59+pQrrmndurXcbrduv/12DR06VE6n01tpAgAAmHzz8359t2a/KRbg79CYxATViwyyKCsAAAAAvmpd6lF98l2qKWazSQ8O7KDYxhEWZQUAAADAFx3NKtT46SkqLnGb4n0vbaIbezSzKCsAAAAAvmhnWrbe+XKzDHNvAN11Q5wubVvfmqQAXJS8VoAjSf7+/urfv7/69+9f6bjnn39edrtXNucBAAA4o582H1LyDztNMYfdptGD4tW8QZhFWQEAAADwVTvSsjTpq/JfHg3v10ZdWtezJikAAAAAPim3oESvfr5eOfklpnj3tvU19LrW5RqxAgAAAEBtOXAsXxNnpMhV6jHFb7m8ufp0bWJRVgAuVudllQvFNwAAwGqb92Zqyryt5eL33dJOHVpGW5ARAAAAAF924Fi+XpuxodyXRwN6tdA1nRtblBUAAAAAX1Rc4tbEGRt0+HihKd62WaTu799edopvAAAAAHjJ8dxijU9er/yiUlO8V3wDDb7qEouyAnAxo9IFAADgNPsO5eqNLzbK7TG3lU68NlaXd2hgUVYAAAAAfNWZvjy6slNDDezd0qKsAAAAAPgit8ejd77cpN0HckzxJvVCNHpwvJx+LEMBAAAA4B0FRS6NT16vjJxiU7xTbB3dc2NbduYEUCv8anKyN954oyanK2f06NG1Oj8AAMDRrEKNn56i4hK3Kd730ia6sUczi7ICAAAA4KsKiko1Pjmlwi+PRtzYhi+PAAAAAHiNYRj6aMF2pezKMMWjwwM0JqmzggOdFmUGAAAAwNe4St16feZGpR3NN8VbNgzX/wzsKD8HzQEA1I4aL8CpzS98KcABAAC1KbegRK9+vl45+SWmePe29TX0utYsbAMAAADgVa5Sj96ctVFpR/NM8ZNfHjnsfHkEAAAAwHu+XLZHSzccNMVCAv00JqmzosICLMoKAAAAgK/xeAz9d84Wbd+fZYrHRAfrscROCvB3WJMYAJ9QowU40omOJ2djs9nOOu70MSx4BQAAtam4xK2JMzbo8PFCU7xts0jd37+97PwuAgAAAMCLPIahKfO3auu+46Z4/aggPcqXRwAAAAC8bPEv6fpq+V5TzOln18O3d1LjuiHWJAUAAADA5xiGoWnf79Ca7UdN8YgQf41NSlBYsL9FmQHwFTVagPOf//znjOeKioo0ceJEZWdnS5J69eqlPn36qE2bNoqKipLT6VRubq527dqlJUuW6JtvvlFpaalatGih//3f/1VYWFhNpgoAAFDG7fHonS83afeBHFO8Sb0QjR7cSU4/ukoDAAAA8K7pP+zUqi2HTbHwYKfG3tFZ4Xx5BAAAAMCLfkk9qo+/3W6K2WzSA7d2UFzTSGuSAgAAAOCT5q/cp4Xr0kyxQH+HHktMUL3IIIuyAuBLarQAZ9CgQWc898ADDygrK0vR0dGaOHGiunfvXuG4Dh06aMCAAXrggQf0P//zP9q7d69eeuklTZ06tSZTBQAAkHSiK8JHC7YrZVeGKV4nPEBjkjorOLDGNwwEAAAAgEp9+/Ov+ubn/aZYgNOhx5ISVJ8vjwAAAAB40c60bL3z1WYZhjl+9/Vx6tamnjVJAQAAAPBJyzYc1Mwfd5tiDrtNowfHq3kDNnoA4B1eaec+d+5cLVmyRA6HQ2+//fYZi29OFRcXp0mTJsnPz08bN27Up59+6oVMAQCAr/ly2R4t3XDQFAsJ9NOYpM6KCguwKCsAAAAAvurnrYf12aKdppjDbtNDgzqqRYNwi7ICAAAA4IsOZuRr4owUuUo9pnj/K5rr2q5NLMoKAAAAgC/asCtDH3y9rVz8/v7t1b5FtAUZAfBVXinASU5OliRdeeWVSkhIqPJ1rVq1Ut++fWUYhubMmVNb6QEAAB+1+Jd0fbV8rynm9LPrkSGd1KhuiDVJAQAAAPBZW/cd1+S5W8rFR97UVh0vqWNBRgAAAAB81fHcYr36+XrlF5Wa4r3jG2rQlZdYlBUAAAAAX7T7QI7emr1RntO25hx6XWtd1j7GoqwA+CqvFOCkpqbKZrMpPj6+2te2adNGkrR3794azgoAAPiyX1KP6uNvt5tiNpv04IAOat0k0pqkAAAAAPis/Ufy9MYXG1TqNn95dPvVl6hXfEOLsgIAAADgiwqKSjVheooycopN8fhL6mjEjW1ks9ksygwAAACArzmUWaAJ01NU4jLvzHljj2a6oXtTi7IC4Mu8UoCTn58vSSopKan2tTk5OZKk0tLSs4wEAAComp1p2Xrnq806rSmC7r4+Tl3j6lmTFAAAAACflZFdpPHJ61VY7DbF+3RtrJt7NrcoKwAAAAC+yFXq0ZuzNmr/kTxTvGXDMI26raP8HF5ZZgIAAAAAys47sTNnXqHLFO/ZIUZDro21KCsAvs4rn4w0bHiiQ+OKFSuqdZ3b7dbChQslSU2bUqUIAADO3cGMfE2ckSJXqbkrQv8rmuvark0sygoAAACAr8ordOnV5PXKyjM3L+oWV0939o2jszQAAAAAr/EYht6bt0Vb9x03xetHBenRxAQF+DssygwAAACAryksLtX46Sk6ll1kindoEaX7bm4nO9+fALCIVwpwevbsKcMwtGnTJn3++edVvm7ChAnat2+fbDabrr766lrMEAAA+ILjuSe6IuQXmXfW6x3fUIOuvMSirAAAAAD4qhKXW6/N3KCDGQWmeOsmEfrjre1lt/PlEQAAAADvSV60Uz9vPWKKhQc7NfaOzgoP9rcoKwAAAAC+ptTt0RtfbNSvh807czaPCdOoQfHszAnAUn7euMndd9+tGTNmyDAM/e///q8OHDigP/zhDwoPD69w/OHDh/Xqq6/qq6++kiQFBgZq+PDh3kgVAABcpAqKSjU+OUUZOcWmePwldTTixjZ0lQYAAADgVR6PoXfnbNHOtGxTvGGdYD18eyf5O+ksDQAAAMB7vvn5V327er8pFuDv0GNJCaofGWRRVgBQuwzD0Ny5czVz5kxt3bpVBQUFqlevnrp376677rpLnTp1Oud7pKam6v3339eqVat05MgRhYWFKTY2VrfddpsGDRokh+PsnwGtW7dOn376qdauXatjx44pICBAzZs3V58+fXT33XcrMjLynPMEAOB8cWJnzq3lduasFxmox5ISFBTglaXvAHBGXvlTKC4uTn/+85/10ksvyePx6N1339X777+vTp066ZJLLikrxMnOztb27du1efNmeTweGYYhh8Ohl156STExMd5IFQAAXIRcpR698cUGpR01d0Vo2TBMo27rSFcEAAAAAF5lGIY+/T5V61KPmuKRof4am9RZoUFOizIDAAAA4ItWbjmkzxftNMUcdpseGtRRLRpU3FgVAC50RUVFevTRR7V48WJTPD09Xenp6ZozZ44ee+wxPfDAA7/7HtOnT9e//vUvuVyuslhmZqYyMzO1evVqzZo1S2+++WalBTT/93//p/fee88Uc7lc2rx5szZv3qzPPvtMr7/+urp06fK78wQA4HySvGinVm05bIqF/f+dOSNC2JkTgPW8Vgb4hz/8QYWFhXrnnXdUWlqqkpISrV27VmvXri031jAMSVJYWJj++c9/qm/fvt5KEwAAXGROdEXYom2/Zpni9aOC9GhiggL86SoNAAAAwLvmr9ynH9alm2JBAQ6NTeqsOhGBFmUFAAAAwBdt2Zup9+ZuLRcfeVNbdWxZx4KMAMA7xo0bV1Z8Exsbq6SkJNWtW7esqKWgoECvvPKKYmJiNHDgwGrPv3TpUj311FMyDENBQUEaOnSoOnbsqIyMDM2YMUOpqalas2aNxo4dq8mTJ8tuL9808r333isrvnE6nUpKSlJ8fLxycnL03XffafXq1Tp69KgeeOABffHFF2ratOk5/TsBAMBqC1ZVsDOn06HHEhMUExVsUVYAYObVfbhGjx6tm266SRMnTtSyZctUUFBQ4bjIyEjdcMMNGj16tOrXr+/NFAEAwEUmedFO/bz1iCkW/v+7IoQH0xUBAAAAgHct33hQM3/cbYr5OWwaPbiTmtQPtSgrAAAAAL7o18O5euOLjXJ7DFP89qsvUa/4hhZlBQC1b/ny5Zo7d64kqWfPnnr33XcVEBAgSerfv7+GDBmiO++8U1lZWXr++ed13XXXKTS06p/blJSU6JlnnpFhGAoODtYnn3yiDh06lJ0fNmyYxo4dq++++07Lly/X/Pnz1b9/f9Mc2dnZeuONNyRJERER+vjjj9WmTZuy8yNGjNDEiRP19ttvKycnRxMmTNArr7zyu/+dAABgtZWbDyn5h/I7c44a1FEtG7IzJ4Dzh1cLcKQTHQNee+01uVwurV+/Xunp6crIyJDNZlPdunXVuHFjde7cWQ4H3egBAMC5+ebnCroi+Dv0WFKC6kcGWZQVAAAAAF+1aXeGPvh6W7n4/f3bq13zKAsyAgAAAOCrjmUVanxyiopK3Kb4dV2b6OaezS3KCgC8Y8qUKZIkPz8/Pfvss2XFNyfFxsbqqaee0p///GdlZWVp+vTpuvfee6s8/7fffqu0tDRJ0v33328qvpEkf39/vfjii1q9erWysrI0adKkcgU4y5cvL2tuff/995uKbyTJZrPpkUce0bx58/Trr79q4cKFKi0tlZ+f15cDAgBwzjbvydR788rvzHnvzW0Vfwk7cwI4v5Tfu9JLnE6nunfvrttuu01/+MMfdN9992nAgAHq1q0bxTcAAOCcrdxySJ8vKt8V4aFBHdWiAV0RAAAAAHjX3kM5enPWpnKdpYf2aaUe7WIsygoAAACAL8ordOnV5BRl55eY4pe2qadhfVvLZrNZlBkA1L6srCytWLFCknTllVeqadOmFY67+eabVafOiQW/CxYsqNY95s+fL+lEkcywYcMqHBMSEqLBgwdLklJTU7Vnzx7T+ZMFPJLUtm3bCuew2+3q2LGjJKmwsFDHjx+vVp4AAJwP9h3K1Ruzyu/MmXhNrK7oyM6cAM4/lhXgAAAA1JYtezP13tyKuyJ0bElXBAAAAADedSSrUBOSU1TsMneW7tejqW7o0cyirAAAAAD4omKXWxOnp+hQZoEpHtc0Un+8tb3sdopvAFzc1qxZI4/HI0nq2bPnGcfZ7XZ1795dkpSSkqLs7Owq32P16tWSpDZt2ig6OvqM4069/5IlS0znQkNDy473799/xjkOHDggSXI4HIqIiKhyjgAAnA+OZBVqfPJ6FZ+2M2ffS5voxsv4/gTA+cmSPScNw1BWVpZKSkrk8XhkGMbZL5LUqFGjWs4MAABc6H49nKs3vijfFWEIXREAAAAAWCCnoESvfr5eOQUuU/yy9jFKvLaVRVkBAAAA8EVuj0eTvtysXQdyTPHGdUP08O3xcvo5LMoMALxnx44dZcdxcXGVjm3V6sRnN4ZhKDU1tawgpzKHDx9WTs6JP2dbt25d6djY2Niy423btpnOderUqez4k08+0ZAhQxQQEGAa8/PPP2vDhg2SpB49esjf3/+s+QEAcL7Iya/4+5Pubetr6HXszAng/OXVApzly5drypQpWr16tVwu19kvOIXNZtOWLVtqKTMAAHAxOJZVqPHJKSo6rSvCdd2a6Ca6IgAAAADwsuIStyZO36AjxwtN8XbNo3Tfze1k58sjAAAAAF5iGIY+/iZV63ceM8WjwgI0JilBIYFOizIDAO9KT08vO27cuHGlYxs0aGC6rioFOGlpaVWePyYmRna7XR6Pp2wnm5M6duyoq666SkuWLNHu3bt19913689//rM6dOig/Px8LVq0SOPHj5fH41FoaKj++te/njU3AADOF0UlpZo4I6Xc9ydtm0Xq/v7t+f4EwHnNawU4kyZN0oQJEySpyjveAAAAVFVeoUuvJqcoO7/EFL+0TT0NoysCAAAAAC9zezx6+8tN2nPQ3Fm6Sb1QPTQoXk4/u0WZAQAAAPBFc5bv1ZIU8+Lu4AA/jU1KUHR4oEVZAYD3ZWZmlh1HRUVVOjYyMrLsOCsrq0rzHz9+vMrzO51OBQcHKy8vr8L5J0yYoLFjx2rx4sXasGGD7rnnnnJjunbtqieffFIdOnSoUn4AAFit1O3RW7M3ac/BXFO8Sb1QjR7cie9PAJz3vFKAs2XLFk2cONFUeNO4cWNFR0crMJAPcgAAwLkpdrk1cXqKDmUWmOJtmkbqj7e2l91O8Q0AAAAA7zEMQx8t2K4NuzJM8TrhJzpLBwd6dWNyAAAAAD5uScoBzV62xxTzc9j1yJBOalwv1KKsAMAaRUVFZccBAQGVjvX396/wusoUFv7Wyf9s858ck5eXV+H8ISEheuGFF/T4449ryZIl5c7bbDa1bNnSVChklfBaKuY8+V2/3W5TdHRIrdwD5weetW/hefuWU593VFSwXkter027M01j6kUF6X8fuFzREawpv9Dx37fv8OVn7ZVveqdNmyaPxyObzaYrrrhC//73v9WoUSNv3BoAAFzk3B6PJn25WbsOmLtKN64Xoodvj5fTz2FRZgAAAAB81ZfL9mjphoOmWEign8YkdVZU2NkXXgAAAABATVm/85g+WrDdFLNJenBAe8U1jbQkJwCwUmlpadnxqQU2FTn1/KnXVcbtdld5/lPHVDT//Pnz9cQTT6ioqEgxMTFKTExUbGys8vPztXTpUn377beaOXOmFixYoA8++ECdOnWqUo61weGo3d0KbDabHA4ab/oCnrVv4Xn7FpvNpk+/2a4f1qaZ4mHB/vrfBy5XvehgizJDbeC/b9/hi8/aKwU4K1eulCTVq1dPb731VpWq+wEAAM7GMAx9/E2q1u88ZopHhQVoTGKCggOdFmUGAAAAwFctXp+ur5bvNcWcfic6Szeq61vdnwAAAABYa1d6tt6ZvUkewzDF77w+Tt3a1LcoKwCwVmDgb531XS5XpUUyJSUlZcdVKaaRzLveuFyus44/eQ+n0/zd9sKFC/WXv/xFbrdbl112md566y2Fhv62a1liYqKWLVumhx56SPn5+br//vs1b9481atXr0p51jS321Mr89rtNtlsNhmGIY/HOPsFuGDxrH0Lz9u3nHzec5bu0oxFO0zn/J12PXlvDzWsE1Jrf5fAu/jv23dY+axru/j7bLxSgHPkyBHZbDb169eP4hsAAFBjPv8+VUtSDphiwQF+GpuUoOha2uIaAAAAAM7klx1H9fE3p3WWtkkPDuig1k0irUkKAAAAgE9KP5KniTM2qKTUvIjtlsub67puTSzKCgCsFxz8W3f94uLiKhfgVHXN2+nzn83JMacWBhmGof/85z9yu92KiIjQa6+9Ziq+Oal3797661//qn//+9/Kzs7WlClT9Le//a1Keda0nJwilZa6zz6wmqKjQ+Rw2OTxGMrMzK/x+XH+4Fn7Fp63b4mODtFPmw7ov19uMsXtNpv+NLCj6oX58/8HFxH++/YdVj1rPz+HoqKs3THLK+U/QUFBkmRZhT0AALj4fLNyrz77LtUU83Oc6CrduF75Dx8BAAAAoDZt25epSV9u1mmNpXX3DW3UNY7PRQEAAAB4T2ZOkf713krlFZp3XriiYwMNvuoSi7ICgPNDeHh42XFWVlalY089Hx0dXe35s7OzKx3rcrlUUFBQbv6tW7dq//79kqRbbrlFkZGRZ5wjKSmpbG3ejz/+WKUcAQDwpo27jumVT9eV+/5kxI1t1LlVXWuSAoBz4JUCnGbNmkmSDhw4cJaRAAAAZ/fzlkN6a0aKKWaT9OCA9oprGmlJTgAAAAB8V9qRXD33/s/lOkv3v6K5ru3S2KKsAAAAAPiigiKX/vXflTpyvNAU79gyWiNvaiubzWZRZgBwfmjRokXZ8cGDBysde+jQobLjRo0a1fj8hw8flsfjKTf/3r17y47j4uIqncPf31+xsbGSpLS0tCrlCACAt+w/kqf/fLhapW7z9yeDrmypqxKq9ncrAJxvvFKAc/3118swDC1cuNC0NScAAEB17UrP1sufrpXntK4Id14fp25t6luTFAAAAACflZlTpKf/u1K5BebO0r3iG2jQlXSWBgAAAOA9pW6PXvhojXYfMO+40LxBmEYN6ig/h1eWiADAee1ksYok7dixo9KxJ8/bbDa1bt26SvNHRUWpTp06VZp/586dZcdnKrQpLi4+6z3t9hN/vjscjirlCACANxzLLtSryetVUFRqil/bpbH6X9HCmqQAoAZ45dOVYcOGqWHDhjp27Jj+85//eOOWAADgInQwI18TZ2xQicvcFeGWy5vrum5NLMoKAAAAgK8qLC7Vv6es0pHMAlM8/pI6uudGOksDAAAA8B6PYWjKvK3asPOYKV4/MkiPJSYo0N/PoswA4PzSpUsXOZ1OSdKqVavOOM7tdmv16tWSpLZt2yo8PLzK9+jevbskaevWrcrNzT3juJUrV5Yd9+jRo+w4Jiam7HjTpk2V3qu0tFS7d++WVPVdegAAqG15hS69+nmKsvPMmzZ0jaunu66P4/sTABc0rxTghIaG6o033lB0dLQ+++wz3XPPPZo/f77S09OrVKUPAACQlVesVz9PUV7haV2lOzbQ4KvoKg0AAADAu0rdHr05a6P2HMgxxVs0CNP/3NaBztIAAAAAvGrGD7u0csthUyws2KkxdyQoIsTfoqwA4PwTHh6unj17SpIWLVqkAwcOVDhu3rx5yszMlCTddNNN1bpHv379JJ0ojpk2bVqFY/Ly8jRr1ixJUsuWLdW2bduyc/Hx8QoNDZUkLVy4UAcPHjzjvb788kvl5eVJknr16lWtPAEAqA3FLrcmzkjRodOal7VrEa0Hbm0vu53iGwAXNq+0OPnjH/8oSYqOjlZGRoZ+/vln/fzzz9Waw2azacuWLbWRHgAAOM8VFpdqfHKKMnKKTPGuberpnpvoKg0AAADAuzyGoSnzt2rL3uOmOJ2lAQAAAFjh29X7teDnX02xAKdDjyUmKCYq2KKsAOD8NXLkSC1dulQul0tjx47V5MmTywpeJGnnzp167rnnJEkhISFKTEys1vx9+/ZVkyZNlJaWpjfffFNdu3bVpZdeWna+pKREjz/+uLKysiRJ9957r+l6f39/3X333XrnnXdUUFCgxx57TG+//baio6NN49atW6fnn39ekuR0OnXPPfdUK08AAGqa2+PRpC83a1e6uXlZswZhGjeyu0qKXGe4EgAuHF75Jnjp0qVlC2NP/q9hGN64NQAAuMCVuj1644uN2n8kzxRv1TRSf737UhXms5seAAAAAO+auXiXVm42d5aOCPHXmDsSFE5naQAAAABe9PPWw/ps4Q5TzG636fHh3dSyfugZrgIA39a7d2/169dP33zzjX755RcNHDhQw4YNU8OGDbVlyxZNmzZN+fn5kqTHH3+8XOHLqlWrNGLECElSjx499PHHH5vO+/v7a9y4cRo1apSKioo0cuRIJSYmqmvXrsrKylJycrJSU1MlSV27dtWQIUPK5finP/1JS5Ys0ZYtW7R+/XrdfPPNGjRokNq2bSu3262VK1dq3rx5Ki0tlSSNGzdOjRs3rvF/VwAAVJVhGPr4m+1av/OYKV4nIlDP3H+5QoP9lUkBDoCLgFcKcBo1auSN2wAAgIuMxzD03ryt2rrP3FW6QZ1gPf2HngoK8KMABwAAAIBXfbdmv75edVpnaX+HnrzvMtUJcVqUFQAAAABftHXfcU2eu6Vc/OHEzurWNkaZmfkWZAUAF4YXX3xR+fn5WrZsmdLS0vTSSy+ZzttsNo0ePVpDhw79XfP36dNHTz/9tJ577jm5XC5NnTpVU6dONY2Jj4/XW2+9JYfDUe76oKAgvffeexozZoxWrlyp48ePa8qUKeXGOZ1O/eMf/9CwYcN+V54AANSUL5ft0ZKUg6ZYcICfnv5DT9WLCpLb7bEoMwCoWV4pwFm0aJE3bgMAAC4y03/YqVVbzF2lw4Kdevr+nooMC+DFDAAAAIBXrd52RJ99X76z9N9HdFfrppEsbgMAAADgNfuP5OmNLzao1G2Y4nfd2FZ9ezTjOxQAOIugoCBNnjxZc+bM0ezZs7V161bl5uYqMjJS3bp104gRI9StW7dzusewYcN06aWX6sMPP9SKFSt09OhROZ1OxcXF6dZbb1VSUpKczjM3dImOjtYHH3yghQsX6quvvlJKSooyMjLk7++vxo0bq1evXho+fDg73wAALLf4l3R9tXyvKebnsOuRIZ3UrEGYNUkBQC3xSgEOAABAdX3786/65uf9pliA06HHEhPUsE6IRVkBAAAA8FXbfz2u/87ZLOO0+ENDEnRpuxgWtwEAAADwmozsIo1PXq/CYrcpfm3XxhpybSuLsgKAC4/NZtOAAQM0YMCAal132WWXafv27VUa27p1az377LO/Jz1JJ3Ls27ev+vbt+7vnAACgNq1LPaqPvzX/vWizSQ8O6KC4ppHWJAUAtYgCHAAAcN5ZteWwPlu00xRz2G0aNaijWjYMtygrAAAAAL4q7WieXpu5sVxn6UFXXaLrLm1qUVYAcOExDENz587VzJkztXXrVhUUFKhevXrq3r277rrrLnXq1Omc75Gamqr3339fq1at0pEjRxQWFqbY2FjddtttGjRokBwOx++a91//+pemTp0qSVVeaAcAQG3IK3Tp1eT1ysorMcW7xdXTXX3jZLPZLMoMAAAAgK9J3Z+lSV9tlnFa97K7b2ijbm3qWZMUANQyywpw9u7dq9WrVystLU1ZWVmy2WwKDw9X06ZN1blzZ7Vu3dqq1AAAgIW27s3U5LlbysVH3tRW8ZfUsSAjAAAAAL4sM6dI45NTVFhcaopf06Wx+l/e3KKsAODCU1RUpEcffVSLFy82xdPT05Wenq45c+boscce0wMPPPC77zF9+nT961//ksvlKotlZmYqMzNTq1ev1qxZs/Tmm28qMjKyWvOuXLlS06ZN+915AQBQU0pcbr02Y4MOZhSY4q2bROiPt7aX3U7xDQAAAADvSD+ap9dmbJCr1GOK33pFC13bpbFFWQFA7fN6Ac7q1as1YcIErVu3rtJxrVu31j/+8Q/17NnTS5kBAACr/Xo4V2/M2ii3x9wW4farL1Gv+IYWZQUAAADAV+UXuTQ+OUXHc4tN8S6t6+ru6+ksDQDVMW7cuLLim9jYWCUlJalu3bravHmzPvvsMxUUFOiVV15RTEyMBg4cWO35ly5dqqeeekqGYSgoKEhDhw5Vx44dlZGRoRkzZig1NVVr1qzR2LFjNXnyZNnt9irNm5+fr3Hjxsk4vY0nAABe5vEYmvTVZu1MzzbFG9UN0SNDOsnf+ft2eQMAAACA6srMKdKrySkqOK152ZWdGuq2K1talBUAeIdXC3D++9//asKECfJ4PGf9oiI1NVX33XefRo0apdGjR3spQwAAYJVj2YUaPz1FhcVuU7xP18a6uSddpQEAAAB4l6vUrddnblT6sXxTvFXjCD04oAOdpQGgGpYvX665c+dKknr27Kl3331XAQEBkqT+/ftryJAhuvPOO5WVlaXnn39e1113nUJDQ6s8f0lJiZ555hkZhqHg4GB98skn6tChQ9n5YcOGaezYsfruu++0fPlyzZ8/X/3796/S3C+//LLS0tKq8dMCAFDzDMPQJ9+l6pcdx0zxqLAAjUlMUEig06LMAAAAAPiaMzUvS4itoxE3tqF5GYCLXtXae9WAmTNn6pVXXikrvgkKCtINN9ygRx55RP/85z/15JNP6qGHHlKfPn0UFBQkSfJ4PHrzzTfLvpQBAAAXp7zCEy9m2Xklpni3NvV0Z1+6SgMAAADwLo/H0H/nbFHq/ixTvGGdYDpLA8DvMGXKFEmSn5+fnn322bLim5NiY2P11FNPSZKysrI0ffr0as3/7bfflhXJ3H///abiG0ny9/fXiy++qMjISEnSpEmTqjTvypUrNW3aNElSWFhYtXICAKAmzV2xV4t/STfFggL8NCYxQXUiAi3KCgAAAICvcZW69fqMDeWal8U2CtefbusoRxV3nQaAC5lXdsA5fvy4nn/+eUknOrPcfffdeuyxx87YvSwvL08TJkzQJ598IsMw9PTTT6tXr16KioryRroAAMCLSlxuvTZjgw5mFJjicU0i9MCt7ekqDQAAAMCrDMPQtIU7tGb7UVM8ItRfY5ISFBpEZ2kAqI6srCytWLFCknTllVeqadOmFY67+eab9fzzzysjI0MLFizQvffeW+V7zJ8/X5Jks9k0bNiwCseEhIRo8ODBmjJlilJTU7Vnzx61bNnyjHPm5+dr3LhxMgxDAwcO1MGDB/Xzzz9XOScAAGrK0pQDmrV0jynm57Dp4cHxalK/6jvGAQAAAMC58HgMvfvVFqWmZZviDaJPNC8LoHkZAB/hlVLDzz77TPn5+bLZbHrwwQf15JNPnrH4RpJCQ0P15JNPatSoUZKkgoKCanc7AwAA5z+3x6NJX23WznTzi1njuiF6eEgnOf14MQMAAADgXQtW/aqFa9NMsUB/h8YkJqhuRJBFWQHAhWvNmjXyeDySpJ49e55xnN1uV/fu3SVJKSkpys7OPuPY061evVqS1KZNG0VHR59x3Kn3X7JkSaVzvvzyy0pLS1O9evX0j3/8o8q5AABQk1J2HtOHC7abYjZJf7y1g9o2p4EpAAAAAO8wDEOffp+qtanlm5eNTUpQWLC/RZkBgPd5pQBn6dKlkqTGjRvrkUceqfJ1Dz30kJo0aSJJWrx4cW2kBgAALGIYhj79NlW/7DhmikeFBWhMUoJCAukqDQAAAMC7ftp0SNMX7zLFHHabRg+OV7OYMIuyAoAL244dO8qO4+LiKh3bqlUrSSc+N0pNTa3S/IcPH1ZOTo4kqXXr1pWOjY2NLTvetm3bGcetXLlS06ZNkyQ9/fTTioyMrFIuAADUpN0HcvT2l5vkMQxTfGjf1uretr5FWQEAAADwRXN/2qcf1qWbYkEB/795WSTNywD4Fq8U4Ozbt082m03XXHONHI6qd7J3OBy69tprZRiGdu3adfYLAADABWPOir1avP6AKRYc4KcxSQmKDg+0KCsAAAAAvmrznkxNmb+1XPwP/dupfYsz76YAAKhcevpvX8w3bty40rENGjSo8LrKpKX9tmvZ2eaPiYmR3X7iq7EDBw5UOCY/P1/jxo2TYRi66aabdP3111cpDwAAatKhzAJNmJ6iEpfHFL/psma6/tKmFmUFAAAAwBctTTmgWUt2m2J+DptGD+5E8zIAPskrBTjZ2dmSpPr1q9+FpW7dupJOfOEBAAAuDktSDmj20j2mmJ/Drodvj1eTeqEWZQUAAADAV+07lKs3Zm2U22PuLJ10bSv1bN/gDFcBAKoiMzOz7DgqKqrSsafuNJOVlVWl+Y8fP17l+Z1Op4KDgyud/+WXX1ZaWpqioqL0z3/+s0o5AABQk7LzS/Tq5+uVV+gyxS/vEKPbr4k9w1UAAAAAUPNSdh7Thwu2m2I2Sff3b692zSv/LA4ALlZeKcAJCztR4Xj06NFqX3vymoiIiBrNCQAAWCNl5zF9VMGL2QO3tlebZryYAQAAAPCuo1mFGj89RcUlblP8+kubql8POksDwLkqKioqOw4ICKh0rL+/f4XXVaawsLDK8586pqL5V65cqWnTpkmSnnrqKUVHswMaAMC7CotLNSE5RceyzX9PdWgZrXtvbie7zWZRZgAAAAB8za4D2Xp79iZ5DHPzsqF9W6tHuxiLsgIA6/l54yaXXHKJ1q5dq8WLF+uJJ56Q3V61uh+3263FixfLZrOpWbNmtZwlAACobWd6Mbvz+jhd2rb6O+UBAAAAwLnILSjRq8kpyskvMcW7t62vO65rJRuL2wDgnJWWlpYdn1pgU5FTz596XWXc7t8KKM82/6ljTp8/Pz9f48aNk2EYuu6663TLLbdU6f5WCQ8PrJV57XZb2f9GR4fUyj1w/uB5+w6e9YXBVerRax/8rH2Hc03xSxpH6Ml7L1NQYNWWd/C8fQvP27fwvAEAgLcczMjXxOkbVFLqMcVv6tlM119K8zIAvs0rBThXXnml1q5dq7S0NL3zzjsaNWpUla575513lJaWJpvNpiuvvLKWswQAALXpUGZBhS9mN/dsruu6NbEoKwAAAAC+qtjl1mszNuhwZoEp3rZZpO7v357O0gBQQwIDfysUcblclRbJlJT8VhBZlWIaybzrjcvlOuv4k/dwOp2m+Msvv6y0tDRFRETomWeeqdK9reRwVK3Z3e9ls9nkcPB3oa/gefsOnvX5yzAMvTUzRetTj5riMdHBeub+ngoNqdrfi6fiefsWnrdv4XkDAIDadDy3WK9+nqK8QvNnbVd0bKAhV8dalBUAnD+8UoCTlJSkSZMmqaioSK+//rry8vI0evRoBQcHVzi+oKBAr7/+uj744ANJUlBQkIYOHeqNVAEAQC3IzivWq5+vL/didnmHBrr96kssygoAAACAr3J7PJr05WbtOpBjijepF6LRg+Pl9KvdRc0A4EtO/S6ouLi4ygU4pxbWVGf+szk55tTCoJUrV2ratGmSpL///e+qX//836nZ7facfdDvYLfbZLPZZBiGPB7j7Bfggsbz9h086/PfR/O36oe1aaZYeIi/nv7DZQoP8a/Wn/s8b9/C8/YtVj3v2i7+BgAA54+ColJNmJ6ijJwiU7xjy2iNvKmtbDQvAwDvFOBER0fr73//u55++mnZbDa9//77+vzzz9WrVy+1a9dOERERkqSsrCxt27ZNy5cvV0FBgQzDkM1m01//+ldFR0d7I1UAAFDDCotLNX56io5lm1/MOrSM1r0382IGAAAAwLsMw9DH36Rq/c5jpnh0eIDGJHVWcKDzDFcCAH6P8PDwsuOsrCyFhYWdcWxWVlbZcVW/Fzp1/uzs7ErHulwuFRQUmObPz8/XuHHjZBiGrrzySg0ePLhK97VaTk6RSkvdNT5vdHSIHA6bPB5DmZn5NT4/zi88b9/Bsz6/fb9mv75YvNMU83fa9cjtnRTosFX7mfG8fQvP27dY8bz9/ByKiqq4wTIAALi4uEo9enPWRu0/kmeKt2gQplGDOsqPolwAkOSlAhxJuuOOO5Sdna1XX31V0okvNL777jt999135cYaxokuDTabTQ899JCGDRtW6/kZhqG5c+dq5syZ2rp1qwoKClSvXj11795dd911lzp16nTO90hNTdX777+vVatW6ciRIwoLC1NsbKxuu+02DRo0SA6HwytzrFu3Tp9++qnWrl2rY8eOKSAgQM2bN1efPn109913KzIy8px/VgAAJKnUfeLF7NfD5hez5g3CNOo2XswAAAAAeN+c5Xu1JOWAKRYc4KcxSZ0VFVa13RYAAFXXokWLsuODBw+qadOmZxx76NChsuNGjRr9rvkrc/jwYXk8HtP8mzZtUlraiR0Hli5dqjZt2pz1nifHNG7cWIsWLapSngAAVGT1tiOa9v0OU8xus+l/BnbUJY3Cz3AVAAAAANQsj2HovXlbtHXfcVO8fmSQHktMUKC/15abA8B5z6t/Ij7wwAPq1KmTJkyYoPXr15cV2lSkS5cueuSRR3T55ZfXel5FRUV69NFHtXjxYlM8PT1d6enpmjNnjh577DE98MADv/se06dP17/+9S+5XK6yWGZmpjIzM7V69WrNmjVLb775ZqXFLzUxx//93//pvffeM8VcLpc2b96szZs367PPPtPrr7+uLl26/O6fFQAA6cSL2ZT5W7Vlr/nFrF5koB5LTFBQAC9mAFCZC6VJwOlSUlI0dOhQNWzYsEoL0YYPH66ff/65SnN//vnn6ty5c7VzAgDgpCUpBzR72R5TzM9h1yNDOqlx3RCLsgKAi1tsbGzZ8Y4dO9SjR48zjt2x48QCZJvNptatW1dp/qioKNWpU0cZGRll15/Jzp2/7S4QFxdXpfkBAKgt2389rv/O2azTV03cc2MbJbSqa0lOAAAAAHyPYRj6bOEO/bz1iCkeHuzU2DsSFB7ib1FmAHB+8vrK1549e+qzzz5Tenq6Vq5cqbS0NGVlZckwDEVERKh58+a69NJL1axZM6/lNG7cuLLim9jYWCUlJalu3bplBSkFBQV65ZVXFBMTo4EDB1Z7/qVLl+qpp56SYRgKCgrS0KFD1bFjR2VkZGjGjBlKTU3VmjVrNHbsWE2ePFl2e/ndAGpijvfee6+s+MbpdCopKUnx8fHKycnRd999p9WrV+vo0aN64IEH9MUXX1TahQ4AgLOZsXiXVm4+bIqFBjk1NqmzIngxA3Aaw12q/C3L5M46pKB2vST5dnfHC6VJwOny8/P15JNPlnWUrorU1NTqpA0AwO+WsvOYPlqw3RSzSXpwQHvFNY20JCcA8AVdunSR0+mUy+XSqlWrdNddd1U4zu12a/Xq1ZKktm3bKjy86u+F3bt314IFC7R161bl5uYqLCyswnErV64sOz5ZCNS6dWu9+eabZ73HhAkTygp8To4PDAysco4AAJwq7UieXpu5UaVuc/nNbVe21JUJVdsFDgAAAABqwoKff9X3a9JMsQB/hx5LSlD9qGCLsgKA85dlrecbN26s22+/3arbl1m+fLnmzp0r6URx0LvvvquAgABJUv/+/TVkyBDdeeedysrK0vPPP6/rrrtOoaGhVZ6/pKREzzzzjAzDUHBwsD755BN16NCh7PywYcM0duxYfffdd1q+fLnmz5+v/v371/gc2dnZeuONNyRJERER+vjjj9WmTZuy8yNGjNDEiRP19ttvKycnRxMmTNArr7xS5Z8TAIBTfbd6vxas+tUU83fa9VhigmKieTEDYFZ6cLuKl36ovKwDkqTs1fMVnPgf2QKr/nv3xeZCaBJwupKSEo0aNapaBTWHDx9WVlaWJCkpKUlXX311peNbtmxZ5bkBADjVrgPZenv2JnlO25H7zuvj1K1NfYuyAgDfEB4erp49e2rp0qVatGiRDhw4oEaNyi8snjdvnjIzMyVJN910U7Xu0a9fPy1YsEClpaWaNm1ahc0K8vLyNGvWLEkn3i3atm0rSYqOjlbfvn3Peo8PP/yw7Lgq4wEAOJPMnCKNn56iwuJSU/yazo106xUtrEkKAAAAgE9asemgpv+wyxRz2G0aPSheLRr4duNUADiTs6+iqmH5+fmaPn26vvvuuwrPz549W8OHD9eHH36ovLy8Ws9nypQpkiQ/Pz89++yzZcU3J8XGxuqpp56SJGVlZWn69OnVmv/bb79VWtqJytD777/fVDgjSf7+/nrxxRfLukpPmjSpVuZYvny5CgoKyuY4tfhGkmw2mx555JGynYcWLlyo0tLScvMAAHA2P289rM8W7jDF7DabRt0Wr0sa8WIG4DeeolwVLn5PhXP+I8//L76RJE9hrtzH9lqXmMVObxIwa9YsjRw5Uv3799ff/vY3zZgxo+x3/+eff77a702nF/h/+umn+vvf/67+/fvrnnvu0cyZM3X99deX5TJ//vyzzpmRkaH77rvP1E26KrZt21Z23K9fP/Xt27fSfyIiIqo1PwAAknQos0ATp29QSal5h7ZbLm+u67o1sSgrAPAtI0eOlCS5XC6NHTu23HvMzp079dxzz0mSQkJClJiYWK35+/btqyZNTvyZ/uabb2rNmjWm8yUlJXr88cfLGgDce++9v+OnAADg3OUVuvRqcoqO5xab4l1a19XdN7SRzWazKDMAAAAAvmbT7gy9P39bufh9t7RTh5bRFmQEABcGrxbgzJ49W9dee63++c9/6uuvv65wzM6dO7V69Wq98MIL6tevn3744YdayycrK0srVqyQJF155ZVq2rRpheNuvvlm1alTR5K0YMGCat3j5GI1m82mYcOGVTgmJCREgwcPliSlpqZqz549NT7HyQIeSWVd3U5nt9vVsWNHSVJhYaGOHz9e6c8GAMDptu47rslzt8g4LT7yprbqFFvHkpwAnH8MwyPXtiXK//zvKk1dWu68PThC9uiKfzf3BRdCk4BT/fTTTxo8eLBWr15drTwkafv27WXHrVu3rvb1AACcTXZ+iV79fL3yCl2m+BUdG2jwVZdYlBUA+J7evXurX79+kqRffvlFAwcO1OTJkzVv3jy99NJLSkpKKiuOefzxxxUdbf6Cf9WqVWrTpo3atGmj4cOHl5vf399f48aNk81mU1FRkUaOHKl//etfmjNnjj7++GPdfvvtWrhwoSSpa9euGjJkSO3+wAAAVKDE5dbrMzfowLF8U7xV4wg9OKCD7HaKbwAAAAB4x56DOXpz1ia5PeZVXknXttLlHRpYlBUAXBi8VoDz6aef6oknnlBubq4Mw9DevXsrHHdyIZhhGMrIyNDDDz+s77//vlZyWrNmjTyeE50ve/bsecZxdrtd3bt3lySlpKQoOzu7yvc4uQitTZs25b4wOtWp91+yZEmNzxEaGlp2vH///jPOceDAic7jDoeD7tIAgGrZfyRPb3yxQaVu84vZoKsuUe9ODS3KCsD5xp2ZrsI5L6hoyRSpOL/cef8Glyhm6FOyB/vm76IXSpMAScrMzNRDDz2kkSNH6tChQ5Kk22+/XTExMVXO5WQBTmRkZLWuAwCgKgqLSzUhOUXHsotM8Q4tozXyprZ0lgYAL3vxxRfVu3dvSSe+C3rppZc0duxYTZ48Wfn5+bLZbHr44Yc1dOjQ3zV/nz599PTTT8vpdMrlcmnq1Kn6y1/+omeffVapqamSpPj4eL311ltyOBw19nMBAFAVHo+h/87Zoh1p5rUGDesE65EhneTv5O8mAAAAAN5x+HiBJkxPUbHLbYrf0L2p+vXw3WapAFBVXinA+fXXX/Xiiy/KMAwZhqHLL79cDz30UIVjX3nlFU2bNk233HKLJKm0tFT/+Mc/lJmZWeN57dixo+w4Li6u0rGtWrWSdKIw6OQXNWdz+PBh5eTkSDp7N+fY2Niy423bftvSrSbmkKROnTqVHX/yyScqLjZvaS1JP//8szZs2CBJ6tGjh/z9/Su9HwAAJ2VkF2l88noVFptfzK7t2lj9L29uUVYAzidGabGKf56ugpn/lPtQBb9POwMV1fc+Nb73BfnX990/Ny6UJgHSifepk80SQkJC9Oyzz+r555+Xn59flXM5+W51tvcxAACqq9Tt0VuzN2nf4VxTvHlMmEbd1lF+Dq9uDA4AkBQUFKTJkyfrpZdeUq9evRQdHS2n06l69erpxhtv1KeffqrRo0ef0z2GDRumWbNmKTExUY0bN5a/v79CQkLUpUsX/fOf/9S0adMUFRVVQz8RAABVYxiGpn6fqrWpR03xyFB/jUlKUGiQ06LMAAAAAPia7PwSjf88RbkFLlO8R7v6SurTiuZlAFAFVV8ZdQ6mTp2qkpIS2Ww2Pfjgg3rsscfOONbhcKhLly7q0qWLOnbsqBdffFG5ubmaOnXqOX/xcrr09PSy48aNG1c6tkGD37ZUS09PL1vsVpmTu/lUZf6YmBjZ7XZ5PJ6yXWhqag5J6tixo6666iotWbJEu3fv1t13360///nP6tChg/Lz87Vo0SKNHz9eHo9HoaGh+utf/3rWnw8AAEnKK3Tp1eT1ysorMcW7xtXTXX3jeDEDoNJf16to+Scyco9VeN7vku4KuPxOhTdtIpvdLrk9Xs7w/HEuTQKq8o5SUwX+J9ntdg0cOFBjxoyp9g42LperbGedk7kUFhZq27ZtysnJUVRUlNq2bUtjAABAtRmGoQ++3qbNe8wNfepGBOqxxE4KCvDKR6IAgArYbDYNGDBAAwYMqNZ1l112WdkOmmfTunVrPfvss78nvUp9/PHHNT4nAMA3zF+5T4vWpZtiQQEOjUnqrLoRQRZlBQAAAMDXFBaXasL0FB3JKjTF2zWP0h9uaS87a7wAoEq88m3zihUrJJ340qOy4pvT3Xvvvfryyy+1bds2LV68uMYLcE7dVedsHc8iIyPLjrOysqo0//Hjx6s8v9PpVHBwsPLy8kzz18QcJ02YMEFjx47V4sWLtWHDBt1zzz3lxnTt2lVPPvmkOnToUOm9AACQpBKXW6/N3KCDGQWmeKsmEXrg1vay23kxA3yZJy9TxSs+VenetRWet4XVU2Cv4fJr1qnC877oQmgScFKLFi30zTffqFmzZme9b0V27doll+tEV52wsDA98cQTmjdvnmm3zpCQEA0ePFgPP/ywIiIiftd9AAC+54slu7Vi0yFTLDTIqT/f0VkRoQEWZQUAAADAFy3feFAzf9xtivk5bBo9uJOa1g+1KCsAAAAAvqbU7dFbszdp36FcU7xZ/VCNHhwvp5/doswA4MLjlQKc9PR02Ww29erVq9rXXnXVVdq2bZv27t1b43kVFRWVHQcEVP7l+6ldl0+9rjKFhb9ViZ5t/pNj8vLyTPPXxBwnhYSE6IUXXtDjjz+uJUuWlDtvs9nUsmVLU7GRlcLDA2t8zpMLwe12m6KjQ2p8fpxfeN6+heftfW6Pof/7eI12pmWb4k3qh+rp+3sqLLj2dizgefsWnveFx/C4lbt2gbKWfiajpILfne0OhfccqIjLB8vu/O13XJ71hdEk4KTq7nhzulO7V7/zzjsVjsnPz9fHH3+sJUuW6L333lPTpk3P6Z4AgIvfwrVpmvfTPlPM32nXo4mdFBMdbFFWAAAAAHzRxt0Zen9++Z2l7+/fXu2aV/7ZHAAAAADUFI9h6P35W7V5T6YpXjciUI8lJSgowCtLyQHgouGVPzVPdjAOCwur9rUhIScW3pWUlNRoTpJUWlpadnxqgU1FTj1/6nWVcbvdVZ7/1DGnzl8Tc5w0f/58PfHEEyoqKlJMTIwSExMVGxur/Px8LV26VN9++61mzpypBQsW6IMPPlCnTtZ2Inc4aq+i1mazyeFgVwZfwfP2LTxv7zAMQ5Nmb9Sqzeau0nUiAvWvBy5XZFjNF1FWhOftW3jeF4ai9B069vUklRzeU+H5wGYdVPemB+Rft8kZ5/DlZ30hNAmoKacW4NhsNiUlJWnYsGFq2bKlCgoKtHLlSk2cOFF79+7Vvn379Kc//UkzZsxQUFBQjedSVTQJwLniefsWnrf3/bTxoKZ+n2qK2e02PX73pbq03bkVjlaGZ+1beN6+hecNAAB+rz0Hc/TWrE3yGIYpPvS61upRi+8nAAAAAHC6mYt36afNh02x0CCnxt7RWZGhZ183AAAw80oBTnR0tI4ePapdu3ZV+9p9+/aVzVHTAgN/WzzlcrkqLXA5tQCoKoUwknlBm8vlOuv4k/dwOp01OockLVy4UH/5y1/kdrt12WWX6a233lJo6G9bWicmJmrZsmV66KGHlJ+fr/vvv1/z5s1TvXr1znrP2uJ2e2p8TrvdJpvNJsMw5PEYZ78AFzSet2/heXvX9IWp+nrFXlMsONBPT913meqEB9bKn+Gn4nn7Fp73hcFTlK/jS6Ypb923kso/J3tQmKL6jFBIx6tls9kq/HPCymddm8Xf1XEhNAmoKYcPn/iAz2azafz48brpppvKzgUGBurmm2/WlVdeqeHDh2vr1q3auXOnPvroIz344IM1nktV0SQANYXn7Vt43t6xeXeGXp22TqetbdOo2xN0WceGXsmBZ+1beN6+hecNAACq4/DxAk2YnqJil9sUv7FHM93QnR2eAQAAAHjPt6v36+tVv5pi/k67Hk3spAbRwRZlBQAXNq8U4MTHx2vhwoX64YcfdPTo0SoXdeTk5GjhwoWy2Wxq3759jecVHPzbXx7FxcVVLsCpSqfoiuY/m5NjTi0Mqok5DMPQf/7zH7ndbkVEROi1114zFd+c1Lt3b/31r3/Vv//9b2VnZ2vKlCn629/+dtZ71pacnCKVlrrPPrAaoqND5HDY5PEYyszMr9G5cf7hefsWnrf3LN1wQJ9+s90U83PYNHpQvMIDHF7598/z9i087/ObYRgq3bVKxT9Nk1GYXeEYZ9urFNAjSSWBoSo5XnDGuax61n5+DkVFnR8fLF0ITQJqyiuvvKJnn31Wx44dU9OmFS88CAsL0/PPP69BgwZJkpKTky0twKFJAM4Vz9u38Ly9Z//hXP17yiq5Ss1/Tg+7vo36dm9KgwDUKJ63b6FJAAAAqK6c/BKN/zxFuQXmz956to/RkGtjLcoKAAAAgC9ateWwPlu4wxSz22wadVtHxTaKsCgrALjweaUA58Ybb9TChQtVWFioxx57TJMmTaqwAORUJSUl+utf/6rs7GzZbDbdcMMNNZ5XeHh42XFWVpbCwsLOODYrK6vsuKq78Zw6f3Z2xYsRT3K5XCooKCg3f03MsXXrVu3fv1+SdMsttygyMvKMcyQlJenll19WYWGhfvzxR0sLcAAA558Nu47pw6/NxTc2SX+8tYPaNo+yJikAlvFkH1LRso/lTt9c4Xl7VGMFXHmP/BrEeTmzC9eF0CSgJgUFBZ2x+Oak9u3bq3Xr1tqxY4fS0tJ0+PBhxcTE1Eo+Z0OTAJwrnrdv4Xl7R2ZOkZ7/ZK3yC82L265KaKS+XRvRIAA1juftW2gSAAAAqqOopFQTpqfoSFahKd6ueZTuu6Wd7DZ21AMAAADgHVv3Zmry3C3l4iNvaqtOsXUtyAgALh5eaaF2880365JLLpEkrVu3Tv3799eHH36offv2lRublpamadOm6dZbb9WSJUtks9l0ySWXaMCAATWeV4sWLcqODx48WOnYQ4cOlR03atSoxuc/fPiwPB5PuflrYo69e/eWHcfFVb740d/fX7GxJzrvpKWlVToWAOBbdh/I0VuzN8ljmDu+Du3bWt3b1rcoKwBWMNwuFa/9Uvkznqy4+MbhL/8eSQq+/V8U31TT6U0CKmNVkwArnHyflE689wAAIEkFRS6Nn56izBxzUWnnVnU1vF+cbCxuAwAAAOAlpW6P3pq1SXsP5ZrizeqHavTgePmxux0AAAAAL/n1cK5e/2Kj3Kft6j34qkvUu1NDi7ICgIuHV3bAcTgceuWVVzR8+HDl5+fr8OHDeuGFF/TCCy/I6XSW7TyTl5dn6uJsGIYiIiL0+uuvy26v+Q+kThaaSNKOHTvUo0ePM47dsePENmw2m02tW7eu0vxRUVGqU6eOMjIyyq4/k507d5Ydn1okUxNznKoqXa5P/rt2OBxnHQsA8A2HMws0YXqKSlweU/ymy5rp+ksr37kAwMWlNH2LipZ9JCP7UIXnHc0SFNjrbtnD6nk5s4vD6QX4le0OY1WTACv4+Xnl1RUAcAFxlXr0xhcblX7UvCNFbKNwPTiwgxy18FkiAAAAAFTEMAx98PU2bdqTaYrXjQjUY0kJCgrgsy0AAAAA3nEsq1Djk1NUVOI2xft0baxbLm9uUVYAcHHx2jfR7dq106effqrWrVvLMIyyf0pKSpSZmanMzEwVFxebzrVr106fffaZqdtxTerSpYucTqckadWqVWcc53a7tXr1aklS27ZtTV2jz6Z79+6SpK1btyo3N/eM41auXFl2fHoh0LnOERMTU3a8adOmSvMtLS3V7t27JVm/yA4AcH7Izi/RK5+vV16hyxS/vEOMbr8m9gxXAbjYeAqyVbhokgrn/V+FxTe2kGgFXv+wgvo9RvHNOTi9SUBlzqVJQFXmr0qB/++VmZmpTz75RBMmTNDs2bPPOv7UXW/q12fXNQDwdR7D0OS5W7Tt1yxTPCY6WI8M6aQAJ01lAAAAAHjPF0t2a8Um82emoUFOjUlKUGRogEVZAQAAAPA1uQUleiU5Rdn5JaZ4tzb1dGffONlsNosyA4CLi1dbQbZp00ZffvmlJk2apMTERDVq1Eh+fn5lBTeSVK9ePfXr109vvPGGvvjiC7Vs2bLW8gkPD1fPnj0lSYsWLdKBAwcqHDdv3jxlZp7oVnPTTTdV6x79+vWTdKKwZdq0aRWOycvL06xZsyRJLVu2VNu2bWt0jvj4eIWGhkqSFi5cWGmn6y+//FJ5eXmSpF69ep315wMAXNwKi0s1ITlFx7KLTPEOLaJ0783tZOfFDLjoGYZHJVt+UH7yEyrd+VP5ATa7nPH9FJL4nJwtu/GBzTm6UJoEnCuXy6V///vfevvttzVlypRKx+bm5pY1EoiJiVGDBg1qNBcAwIUnedFOrd52xBSLCPHX2KQEhQX7W5QVAAAAAF+0cG2a5v20zxTz97Pr0SGd1LBOiEVZAQAAAPA1xSVuTZyxQYczC0zxuKaReuDW9rLbWcsBADXFqwU40onuzFdffbX+/e9/a9GiRdq0aZNWrlypZcuWacOGDVq6dKkmTpyovn37emXx3siRIyWdWAA2duzYsuKTk3bu3KnnnntOkhQSEqLExMRqzd+3b181adJEkvTmm29qzZo1pvMlJSV6/PHHlZWVJUm69957a3wOf39/3X333ZKkgoICPfbYY2UFRadat26dnn/+eUmS0+nUPffcU62fFQBwcSl1e/TW7E3ad9i8OLtZTKhGDYqXn8Prv0YA8DJ3xq8q+PI5FS/7UCopKHfeXu8SBQ96WoGXD5PNP8iCDC8+F0qTgHMVExOjFi1aSJK2b9+u9evXn3HslClTVFR0ohB04MCBNZoHAODCs2DVr/p29X5TLMDfoccSE1Qvkt9HAAAAAHjP2u1HNPW7VFPMZpP+NLCjYhtHWJQVAAAAAF/j9nj09pebtPtAjineuF6IHrk9Xk4/h0WZAcDF6bxYORsZGam6devK39/7HSp79+5dtgDtl19+0cCBAzV58mTNmzdPL730kpKSksoKWx5//HFFR0ebrl+1apXatGmjNm3aaPjw4eXm9/f317hx42Sz2VRUVKSRI0fqX//6l+bMmaOPP/5Yt99+uxYuXChJ6tq1q4YMGVIrc/zpT39S+/btJUnr16/XzTffrBdffFFffvmlvvjiCz3++OMaPnx4WQHSuHHj1Lhx49/5bxUAcKEzDEPvz9+mzXvMBZt1IwI1JjFBQQF+FmUGwBsMV5GKVn6mgi+ekefIrvID/IMU0HuEggc+KUfd5t5P8CJ3ITQJqAmnvj/97W9/0+HDh8uNmTdvnt59911JJ94bT/67AQD4ppVbDin5h52mmMNu0+hB8WreIMyirAAAAAD4otT9WZr01RYZp8XvubGtOreua0lOAAAAAHyPYRj6cMF2bdiVYYpHhwdobFJnBQc6LcoMAC5elq6e9Xg8yszMVHZ2tqKjoxUVFVUWt9u9Vxv04osvKj8/X8uWLVNaWppeeukl03mbzabRo0dr6NChv2v+Pn366Omnn9Zzzz0nl8ulqVOnaurUqaYx8fHxeuutt+RwVFxpeq5zBAUF6b333tOYMWO0cuVKHT9+XFOmTCk3zul06h//+IeGDRv2u35WAMDFYcaPu/TT5kOmWGiQU2Pv6KyI0ACLsgLgDa69a1W8/FMZ+eV3TJQkv1Y9FdBzqOzBkd5NzIecbBLwzTfflDUJGDZsmBo2bKgtW7Zo2rRpys/Pl3TmJgEjRoyQJPXo0UMff/yx6fzJAv9Ro0aVFfgnJiaqa9euysrKUnJyslJTT3TuPFOBf00YOnSovv76a61Zs0Z79+7VgAEDdMcdd6ht27bKy8vTokWL9MMPP0iS/Pz89MILL6hOnTq1kgsA4Py3ZW+m3pu7tVz8vpvbqUPL6AquAAAAAIDakX40T6/N2KBSt8cUH9i7pa5KaGRRVgAAAAB80ayle7Rsw0FTLCTQT2OSOisqjDVeAFAbvF6AU1paqi+//FJfffWVNmzYoKKiIkknFo6d7Kx8xx13qGnTpvrTn/6kuLi4Ws8pKChIkydP1pw5czR79mxt3bpVubm5ioyMVLdu3TRixAh169btnO4xbNgwXXrppfrwww+1YsUKHT16VE6nU3Fxcbr11luVlJQkp7PyStNznSM6OloffPCBFi5cqK+++kopKSnKyMiQv7+/GjdurF69emn48OHsfAMAPu77Nfv19cpfTTF/p12PJnZSg+hgi7ICUNs8ucdUvOJTle77pcLztogYBfYaIb8mHbycmW+6EJoEnCs/Pz+9/fbbGjNmjJYtW6asrCxNmjSp3LjIyEg999xzuvbaa2slDwDA+e/Xw7l644uNcnvMvaUTr4nV5R0bWJQVAAAAAF+UmVOkV5NTVFBcaopfldBIA3q1sCYpAAAAAD5p0bo0zV2x1xRz+tn1yJBOalw3xJqkAMAHeLUAZ/v27XrkkUf0668nFvUaxokvzW02m2nczp07tWnTJn377bf6y1/+opEjR9Z6bjabTQMGDNCAAQOqdd1ll12m7du3V2ls69at9eyzz/6e9GpsDpvNpr59+6pv377nlAcA4OK0etsRTft+hylmt9n0PwM7KrZRhEVZAahNhqdUro3fqnjtbKm0pPwAu5/8u/SXf8LNsvn5ez0/X3WhNAk4V+Hh4Zo8ebIWLlyo2bNnKyUlRcePH1dwcLCaNGmiPn36aNiwYex8AwA+7FhWocZPT1FRidsU79utiW68rJlFWQEAAADwRQVFLo2fnqLjucWmeOdWdTW8X1y5dQ8AAAAAUFvWbj+iT79NNcVsNulPAzqodZNIa5ICAB/htQKc1NRU3XXXXcrPzy8rvPH391dJiXmR3/Hjx1VYWCibzabS0lK9+OKLcjqduuuuu7yVKgAAPmn7r8f13zmbZZwWv+fGNkpoVdeSnADULvehHSpa9qE8mWkVnnc0bq/AXiNkj6SzvBUulCYBp1u0aFG1xtMkAABwJnmFLr2anKLsPPPnh5e2qaeh17VmcRsAAAAAr3GVuvXazI1KP5pvisc2CteDAzvIYbdblBkAAAAAX5O6P0uTvtpSbo3X8H5t1CWuniU5AYAv8cqnQKWlpXr44YeVl5cnwzB0zTXX6PPPP9eaNWvKjY2KitL06dN12WWXSTqxS87LL7+sQ4cOeSNVAAB8UtqRPL02c6NK3eZXs9uubKkrExpZlBWA2mIU5aloyfsq+Oq5CotvbEHhCuzzoIJu/ivFNwAAwBIlLrdem7FBhzILTPG4ppH6463tZbdTfAMAAADAOzweQ/+ds0Wp+7NM8ZjoYD0ypJMCnA5rEgMAAADgc9KO5um1GRtU6vaY4gN6tdA1nRtblBUA+BavFOB8+eWX2rdvn2w2m0aMGKF33nlHCQkJ8vf3r3B8fHy8PvjgAw0dOlSSVFRUpOTkZG+kCgCAz8nMKdL46SkqLC41xa/p3Ei3XtHCmqQA1ArDMORKXa785Cfk2vZjBSNscra7ViFJ/5Gz1eV0lQcAAJbweAxN+mqzdqZnm+KN64bo4dvj5fRjcRsAAAAA7zAMQ9MW7tCa7UdN8YgQf/05KUFhwRWveQAAAACAmpaZU6TxySkqOG2N11UJjTSwd0uLsgIA3+OVApzvvvtOklS/fn395S9/qfJ1f//731W3bl1J0vLly2slNwAAfFleoUuvJqfoeG6xKd6ldV3dfUMbFt8DFxF31gEVzn1RRYv/K6Mot9x5e52mCh44ToFX3iNbQIgFGQIAAJxY3PbJd6n6ZccxUzwqLEBjkhIUEui0KDMAAAAAvujrVb9q4VrzLuKB/g6NSUpQ3cggi7ICAAAA4GvyCl165fP15dZ4dW5VV8P7xbHGCwC8yM8bN9myZYtsNpuuueaaM+56U5HAwED16dNHycnJ2rt3b+0lCACAD3KVuvX6zA06cCzfFG/VOEIPDuggu50XM+BiYJSWqOSXOSpJmS953OUH+AUo4NLBcnbsK5udbvIAAMBac3/ap8W/pJtiQQF+GpOUoOjwQIuyAgAAAOCLVmw6qBmLd5liDrtNowfHq1lMmEVZAQAAAPA1JS63Xpu5QQczCkzxVo0j9ODADnLYvbIXAwDg//NKAc7x48clSY0bN672tY0aNZIk5efnn2UkAACoKo/H0LtfbdGOtGxTvGGdYD0ypJP8nSzCBy4Gpfs3qmjZRzJyj1Z43q9FNwVccafsoXW8nBkAAEB5Szcc0Kwlu00xP4dNj9weryb1Qi3KCgAAAIAv2rQ7Q+/P31Yu/of+7dS+RbQFGQEAAADwRW6PR5O+2qydZ1jjFcAaLwDwOq8U4ISEhCg7O1t5eXnVvjYzM1OSFBZGBxkAAGqCYRia+n2q1qaaF+RHhvprTFKCQoOcFmUGoKZ4CrJUvGKqSnf/XOF5W2gdBfYaLr/mnb2bGAAAwBls2JWhD7/eborZJP3x1g5q0yzKmqQAAAAA+KS9h3L05qxNcnsMUzzp2lbq2b6BRVkBAAAA8DWGYejTb1P1y45jpnhkqL/GJnVmjRcAWMQrBThNmjRRVlaWVq9eXa3rDMPQjz/+KJvNpiZNmtRSdgAA+Jb5K/dp0bp0UywowKExSZ1VNyLIoqwA1ATD45FryyIVr54puQrLD7A55N+pn/y7DpTNGeD9BAEAACqw52CO3pq9UR7DvLhtaN/W6t62vkVZAQAAAPBFR7IKNSE5RcUutyl+Q/emuvGyZhZlBQAAAMAXzVmxV4vXHzDFggL8NDaps+pEBFqUFQDAKwU4vXv31qZNm7R+/Xr99NNPuvzyy6t03Ycffqh9+/bJZrPpiiuuqOUsAQC4+C3feFAzf9xtivk5bBo9uJOa1g+1KCsANcF9bK+Kln4oz9E9FZ53xLRWwJUj5Ihu6uXMAAAAzuzw8QJNmJ6iEpfHFL/psma6/lJ+bwEAAADgPTkFJXr18/XKKXCZ4j3a1VdSn1YWZQUAAADAFy1JOaDZS83rP/wcNj1ye7yasMYLACxl98ZNhg4dqoCAEx22x44dqzVr1lQ63u12691339VLL70kSfLz81NiYmKt5wkAwMVs4+7/x96dx1VZ5v/jf91nZd8RUVARQVBZFFEsbTHN3DcgNVtsWqayXOYzzdL0qWaqz7fpl1qTNZWTWaYFrrmkWWruisriggLubILgYT/7/fvDkbzloKBwH+C8no/HPDrzvq9z3S+8RTjn3O/rKsPSzaca1J8Z1weR3b3tkIiIWoJorIN+37eoXfuW7eYbrSu0982C84S/sPmGiIiI2pTKGiMWfp+JqptubkvoG4CpD4TaKRURERERETkig9GCD1MzUXJVurN4RDcv/G5sHygEwU7JiIiIiIjI0aTnlmLZFuk9XgKA58b3Re9uvMeLiMjeZNkBp3PnzpgzZw7++c9/QqfT4fHHH0f//v3Rp0+f+jFZWVlYtmwZ8vLysHPnTly5cgWiKEIQBPzud79DUFCQHFGJiIg6pHNFlfhk7XFYRVFSn/ZQGAZFBtgpFRHdDVEUYT6XBsO+FRBrdTbHqMKHQjs4GQpnD3nDEREREd2G3mjGotRMlOikN7f16eGNp8dE8uY2IiIiIiKSjdlixafrj+NcUZWkHuTvhtlToqFWybKuKREREREREfLyK/Dv9Sdw0y1emDEyHAMjOtknFBERScjSgAMATz/9NMrKyvCf//wHAJCeno709HQI//0wfcuWLdiyZUv9ePG/Pz0mTJiAuXPnyhWTiIiow7l8tRaLUjNhMFkk9UcGdcPD8dwNg6g9slaWQL93OSyXsmweV3h1gXboE1B1iZA5GREREdHtmS1WfLruBM4XS29u69bJDS9NjoJKyZvbiIiIiIhIHqIo4uutp5F1pkxS9/VwwrzkGLg4yXZLBRERERERObiishp8uCoTJrNVUh87pDseiuMmBkREbYWs7xb98Y9/xIABA7Bo0SLk5ubecmznzp3x4osvIjk5WaZ0REREHU9ljRELv89EVa1JUk/oG4DEB0PtlIqI7pRoMcOY9SOMR38ALKaGA5RqaAZMgCZ6NAQlPxgmIiKitkcURSzbcgrHzkpvbvPzvHZzm7OWv8MQEREREZF81u4+hz1ZRZKaq5MK8x+Ngbe71k6piIiIiIjI0VytMmDB9xmo0Zsl9XujOmPKfT3tlIqIiGyR/RPthx56CA899BDS09ORlpaGvLw8VFRUwGw2w9PTE8HBwRg4cCCGDBkClYofuBMREd0pvdGMRamZKNHVSeqR3b3x9JhIKP67Cx0RtQ/motMw7F4Gq67Q5nFlcBSc7n0cCg9uOUxERERt19rd57D3WLGk5uasxrzkGHi68eY2IiIiIiKSz470Amzcd15SU6sUmJMYg0BfV/uEIiIiIiIih1OrN2FhSgbKKg2SelRPXzz5SAQE3uNFRNSm2K3DpX///ujfv7+9Tk9ERNShmS1WfLL2OM4XV0nq3Tq5YfaUKKiUCjslI6LmsuqrYDjwPcw5e2weF1y8oL1nBlQh8XzThYiIiNo0Wze3aVQKzEmM5s1tREREREQkq6M5pVj+02lJTRCA30/oi15BnnZKRUREREREjsZktuBfq48hv7RGUg8JdMeLk/rxHi8iojaIW8wQERF1MKIo4qsfT+H4uXJJ3c/TCXOTY+Cs5Y9/ovZAFK0wnd4Nw8EUwFDTcIAgQN3nIWjjp0LQOMsfkIiIiKgZGru57fmJfRHalTe3ERERERGRfHLzdfjshxMQRWn98Yd7o3+4v31CERERERGRw7FaRXyx4SROX9JJ6gHezpiTFAOtRmmfYEREdEt2uQPXbDZDpWp46kOHDmH9+vUoLi5GQEAARo0ahfvvv98OCYmIiNqvNbvOYt/xYknNzVmNeckx8HLT2ikVETWHpTwfhj1fw1KcY/O4wq8HnIY9CaV/iMzJiIiIiJqv0ZvbRvVG/zDe3EZERERERPIpuFKDj1ZlwWS2Surj7+mBB/p3tVMqIiIiIiJyNKIoYuUvuTh8ulRS93TVYP6jsfBw0dgpGRER3Y6sDTj79+/HZ599htzcXOzdu1dy7OOPP8bixYsltbVr1+L+++/Hhx9+CK2WNwwTERHdzi9H8rFp/wVJTaNSYE5iNAJ9Xe2UioiaSjQZYDy6HsasrYBoaThA7QRtfCLUfYZDUHCbYSIiImr7Chu5uW3CvT3wQCxvbiMiIiIiIvlcrTJgYUoGavRmSX1YdCAmDeNiR0REREREJJ8fD17EL0fyJTUnjRJzk2Lg7+Vsp1RERNQUsjXgpKam4n//938hiiIEQYBOp4OXlxcAID09HR9//LHN5/3666/485//jIULF8oVlYiIqF06fKoEK7ZJd8sQBOD3E/shtKunnVIRUVOZL2ZAv+cbiNVlNo+reg6Cdsh0KFy9ZU5GREREdGdudXPbxKG8uY2IiIiIiORTqzdhYUoGyisNknp0qC+eeKQ3BEGwUzIiIiIiInI0e48VYdXOM5KaUiHgpSlR6N7Z3U6piIioqWRpwCktLcU777xT//+dnJxQXl5e34CzdOlSAIAgCAgPD8fvf/97lJeXY/HixSgvL8eWLVswc+ZMxMXFyRGXiIio3cm5pMPnG05CvKn+5CMRiA3zs0smImoaa3U5DPu+hfn8EZvHBXd/OA19HKrgaJmTEREREd25Wr0ZC1MyUcab24iIiIiIyM5MZis+XnMM+aU1knpIoAdemNgPSu42TkREREREMsk6U4alm081qP9uXCT69vCxQyIiImouWRpwUlNTodfrIQgCJkyYgL///e9wcnICANTU1GDnzp0AAKVSiS+++AKdOnUCANxzzz2YNGkSjEYjNm7cyAYcIiIiGwpKq/HRqiyYLVZJfeLQENwX08VOqYjodkSrBabjP8NwZC1g0jccoFBCEzMGmv7jIag08gckIiIiukMmsxWL1x5Dfmm1pM6b24iIiIiISG5WUcSSjSdx6qJOUg/wdsacpGhoNUr7BCMiIiIiIodztrASn6w7BqsoXWJ52vBeSOjT2U6piIiouWRpwNm/fz8AoEuXLvi///s/KJW/vYm1b98+GI1GCIKAhISE+uYbAAgJCcEDDzyArVu34tChQ3JEJSIialfKK/VYkJKJWoNZUr8vpgsm3NvDPqGI6LYsJWeg370M1rKLNo8rA3tDO/RJKL3ZREdERETti1UU8eXmbGRfuCqpd+LNbUREREREJDNRFPH9L3lIO1UiqXu4ajD/0Vh4uHDhIyIiIiIiksfl8losSs2E0SRdYPmRQd3w8KBudkpFRER3QpYGnHPnzkEQBDz44IOS5hsA2L17d/3jYcOGNXhuWFgYtm7ditLS0lbPSURE1J7U6E1YmJKJq1UGST22lx8eHxUOQRDslIyIGiMaamBIWw3TyR0AxAbHBSd3aBOmQRV2D7+HiYiIqF1K3ZGHgycvS2oeLmre3EZERERERLLbeugSth2+JKlpNUrMS4qBv5eznVIREREREZGjqag24IPvM1BdZ5LUE/oGIPHBUDulIiKiOyVLA05FRQUASHa3uW7Pnj31j4cMGdLg+PUbD2tra1spHRERUftjMlvwr9XHUHClRlIP7eqB5yf2hVKhsFMyIrJFFEWYzxyAYf9KiHWVNseoI+6HdlASBCc3mdMRERERtYyfDl3E1kM33dymVmJucgw68eY2IiIiIiKS0f4TxUjZkSepKRUCZk+OQvfO7nZKRUREREREjqbOYMbC1ExcqdBL6n16eOPpMZFQcHFWIqJ2R5YGHI1GA7PZjLq6Okn97NmzKCwshCAI8PHxQXh4eIPnFhYWAgDc3HgjIhEREQBYrSI+33ASOZd0knpnHxfMSYyBVq20/UQisgtrRTH0e76BpeCEzeMK7yBohz0JVecwmZMRERERtZxD2Zfx3faGN7e9NLkfenT2sFMqIiIiIiJyRCfOl+PLTdkN6k+PjUTfEB87JCIiIiIiIkdktlixeO0xXLxcLal3D3DHS5OjoFJygWUiovZIlgac4OBgnD59GidPnpTUd+7cWf946NChDZ5nMBiwa9cuCIKAHj16tHJKIiKitk8URaz8ORdHTpdK6p6uGsxPjoGbs9pOyYjoZqLFBGPGJhgzNgIWc8MBKg20cZOgjnoYgkKWX8uJiIiIWkX2hatYsvFkg/pToyPQr6evHRIREREREZGjulBchY/XHIPFKkrqSQ+GYkjfznZKRUREREREjsYqivhyUzZOnr8qqft7OWFucgyctbxPhIiovZLlX/DBgwfj1KlT2LNnD3bt2oX77rsPV65cwbJly+rHjBw5UvIcq9WKd999F6WlpRAEAYMHD5YjKhERUZv248GL+OVovqTmpFFiXnIM/Lyc7ZSKiG5mLjgJ/Z6vIVYU2zyu7BYLp3tnQuHuJ3MyIiIiopZ1qaQaH6/Jgtkivblt6v09cW9UoJ1SERERERGRIyrV1WFhaiYMRoukPiIuCI8M6manVERERERE5IhSd+ThwMnLkpq7ixrzk2Ph6aqxUyoiImoJsjTgJCUl4ZtvvoHVasULL7yA8PBwFBQUoKqqCoIgoHPnznjggQfqx3/++efYvHkzTp8+DQBQq9VITEyUIyoREVGbte94EVbtPCOpKRUCXp4ShW4B7nZKRUQ3stZWwHDgO5jz9ts8Lrj6QHvvY1B1HwBBEGROR0RERNSyyir0WJiSgTqD9Oa24QO6YkxCdzulIiIiIiIiR1RVa8SC7zNQWWOU1AdGdMK0EWF8P5aIiIiIiGSz9dBFbD10SVLTqBWYmxSDAB8XO6UiIqKWIksDTq9evTB79mx89NFHsFgsOHXqFABAFEUolUq8+eabUKl+i/Ldd9+hqKgIonht5cw//elPCA4OliMqERFRm3T8bBmWbj7VoP7MuD6I7OFjh0REdCNRtMKUvROGQ6sAY23DAYIC6n4joR04GYLaSf6ARERERC2sus6EBSkZ0FVLb26LC/fHjBHhvLmNiIiIiIhkYzBa8OGqLFy+Wiep9w72wrPjIqHg6xMiIiIiIpLJgZPF+H57nqSmVAh4aXIUQgI97JSKiIhakiwNOADw4osvomvXrvjkk09w4cIFAEBkZCT+53/+B/fee69kbM+ePVFYWAg/Pz/89a9/xZgxY+SKSURE1OacL67E4rXHYbGKkvqjw3thcJ8AO6UioussZReh3/0VrCVnbR5XdOoJp6FPQunHVeCJiIioYzCaLPhodRaKyqSNx2FBnnh2fB8oFLy5jYiIiIiI5GGxWvHv9cdxtrBSUg/yd8XLU6OgVintlIyIiIiIiBzNifPl+M/G7Ab1p0ZHIKqnrx0SERFRa5CtAQcAJk6ciIkTJ6KiogJKpRJubm42x82YMQPTpk3D/fffD7VaLWdEIiKiNqXkai0WpWTCYLJI6g/HB2PUoG52SkVEACCa9DAcXgvT8W2AaG04QOMC7aAkqCPvhyAo5A9IRERE1AqsVhFfbDiJvPwKST3Q1wUvT42GRs2b24iIiIiISB6iKOLrLaeReaZMUvfx0GJecixcnHivARERERERyeNCcRU+XnOswQLLiQ+E4t6oQDulIiKi1iBrA851np6etzw+fPhwmZIQERG1XZU1RixIyURlrUlSH9wnAMnDe9kpFRGJogjzhaMw7P0WYk25zTGqXkOgTZgGhcutf+8lIiIiak9EUcSKn3NwJKdUUvdy02B+cizcnHlzGxERERERyWf9nnPYnVUkqbk6qTAvORbe7lo7pSIiIiIiIkdToqvDwtRMGIzSBZZHxAVh9GAusExE1NHYpQGHiIiIbk1vNOPDVZkouVonqUd298bTYyKhEAQ7JSNybNaqK9DvXQ7LxQybxwXPADgNfRKqrn3kDUZEREQkg80HLmD70QJJzVmrxPzkWPh6OtkpFREREREROaKdGQX4Ye95SU2tUuDlqdHo6udqn1BERERERORwKmuNWPB9BiprjJL6wIhOmDYiDALv8SIi6nDYgENERNTGmC1WfLruBM4VVUnqwZ3cMHtKFNQqhZ2SETku0WqGMesnGI+uA8zGhgOUKmhix0MTMxqCSiN7PiIiIqLWtvdYEVb/elZSUykFzJ4SjaBObnZKRUREREREjig9txTfbD0tqQkC8Nz4vggP9rJPKCIiIiIicjh6oxkfpjZcYDmimxeeHccFlomIOio24BAREbUhoihi2ZZTOHa2TFL39XDC3KQYOGv5o5tIbubiXBh2L4P1ar7N48qufeE09HEoPDvLnIyIiIhIHsfPluGrH081qD8zrg8iu3vbIRERERERETmqvIIKfLb+BERRWp85Mhxxvf3tE4qIiIiIiBxOYwssB/m7YfaUaKhVSjslIyKi1sa7eImIiNqQtbvPYu+xYknN1UmF+Y/GwNtda6dURI5J1FfDcCgFplO7bB4XnD2gHTIDqtDB3DKYiIiIOqzzxZVYvPY4LFbp3W3THgrDoMgAO6UiIiIiIiJHVFRWgw9TM2E0WyX1cfd0x4MDguyUioiIiIiIHI0oilj2o60FlrWYlxwDFyfemk1E1JHxX3kiIqI2YsfRfGzcd0FSU6sUmJMYg0BfVzulInI8oijCnLsXhgPfQ9RX2RghQN3nQWjjp0LQ8nuTiIiIOq4SXR0WpWTCYLJI6qMGBePh+GA7pSIiIiIiIkd0tcqABd9nokZvltSHRgVi8rCedkpFRERERESOaM2us9h73NYCy7FcYJmIyAGwAYeIiKgNOHK6FMt/ypHUBAH4/cS+6BXkaadURI7HcrUQhj3LYCk6bfO4wrcbnIY9CWWnUJmTEREREcmrstaIBd9noLLWJKkP7hOApAd72SkVERERERE5olq9GYtSM1FWqZfUo3r64olHenOHciIiIiIiks0vR/Kxab90gWWNSoE5SVxgmYjIUbABh4iIyM5yLunw2Q8nIN5Uf3xUb/QP87dLJiJHI5qNMKZvgDFzM2C1NBygdoJ24GSo+46AoFDKH5CIiIhIRgajBR+mZqHkap2kHtndG0+PiYSCN7cRkQMQRSuMpZegVApQ+gTZOw4REZHDMpmtWLz2GC6VVEvqIYHueHFSP6iUCjslIyIiIiIiR3P4VAlWbLO1wHI/9OrKBZaJiBwFG3CIiIjsqOBKDT5alQWzxSqpT7i3Bx6I7WqnVESOxXzpGPR7voZYVWrzuKpHHLT3PAaFm4/MyYiIiIjkZ7Fa8en64zhXVCmpB3dyw+wpUVCreHMbEXVsoijCcikLhrTVqC67CADwHJoM9Blj52RERESOxyqK+M+mk8i+cFVS7+TtjDmJMdBquFgSERERERHJ49SFq/h8Q8MFlp98JAKxYX52yURERPbBBhwiIiI7Ka/UY2FKBmoNZkn9vphATBwaYqdURI7DWnMVhv0rYT57yOZxwc0XTvc+DlX3WHmDEREREdmJKIr4estpZJ0pk9R9PbSYmxQDZy3fSiSijs1cnAvjoVRYiqWrWFYeXA/XyNEQuAMYERGRrFK25+FQdomk5uGixvzkGHi4auyUioiIiIiIHM2lkmr8a00WzBZp+82kYSG4L6aLnVIREZG98FNzIiIiO6jVm7AwNRPllQZJPSbUF4+P6s0bOohakWi1wnTyFxjSVgMmfcMBghKa6FHQDJgIQa2VPyARERGRnazfcw67s4okNVcnFeYlx8Lbnb8XEVHHZSm7CEPaalguZto8rvL053s1REREMtt66CJ+SrskqWnVSsxJikEnbxc7pSIioo5GFEVs3LgRq1evRnZ2Nmpra+Hv74/4+Hg89thjiI6Ovutz5OTkYOnSpTh48CBKSkrg7u6O0NBQTJo0CZMnT4ZSefsd3fR6Pb777jts3boV586dQ3V1NXx9fREXF4eZM2diwIABd52TiIhsu1JRh4UpGagzWCT1B/p3xfh7etgnFBER2RUbcIiIiGRmMlvwr9XHUFBaI6n37OKB30/sB6VCYadkRB2fpfQ89Lu/gvXKeZvHlZ3DoR36BJQ+QfIGIyIiIrKznRkF+GHveUlNrVLglcRodPFztU8oIqJWZq0sgeHwGpjzDgIQbY5R+wXBf/L/oEreaERERA7twMlifL89T1JTKgS8NLkfQgI97JSKiIg6Gr1ejzlz5mDnzp2SekFBAQoKCrBhwwbMnTsXzz333B2fIzU1FW+99RZMJlN9rby8HOXl5UhLS8PatWuxePFieHl5NTrHqVOn8PLLL+PixYuSenFxMTZt2oTNmzfj97//PebOnXvHOYmIyLbqOhMWpmRCV22U1PuH+WHmyHAu2kNE5KBkbcC5evUqUlNTsX//fly5cgUGgwFWqxWiaPuDrRsJgoCff/5ZhpREREStxyqK+GJjNk5f0knqAT4umJMYDa3m9qvbEFHzicZaGNLWwHTyF8DW755aVzgNfhSq3kMhCGyCIyIiIseSnluKb7aeltQEAXh+Ql+EBXnZJxQRUSuy1upgPPoDTNm/AqLF5hjBzRc+90+HR/R9sIoCUF5jcxwRERG1rJPny/GfjdkN6k+NjkC/nr52SERERB3Va6+9Vt98ExoaiuTkZPj5+eHEiRP47rvvUFtbiw8++AABAQGYOHFis+ffvXs3Xn/9dYiiCGdnZ0ybNg39+vVDWVkZVq1ahZycHBw+fBjz58/HkiVLoLCxUOelS5cwa9YslJeXAwCGDBmCkSNHwsvLC0ePHkVqaioMBgM+/fRTdO7cGdOmTburPxMiIvqNwWTBh6syUVRWK6n3CvLE8xP6QqFg8w0RkaOSrQFn3759mDNnDqqrq5v9XFEU2SlKRETtniiK+O7nXBw+VSKpe7pqMD85Bu4uGjslI+q4RFGE+VwaDPtWQKzV2RyjCh8KbcKjUDi5yxuOiIiIqA3IK6jAZ+tPNOhRnvlwbwwI97dPKCKiViIaamDM2ATj8Z8Bi9HmGMHJHZoBE6COfABu/l4QFArAYpU5KRERkWO6eLkKH685BotV+gJl6v09cW9UoJ1SERFRR7R3715s3LgRAJCQkIDPP/8cWq0WADBu3DgkJiZixowZ0Ol0ePfdd/HQQw/Bzc2tyfMbjUa8+eabEEURLi4uWL58Ofr27Vt/fPr06Zg/fz62bduGvXv3YvPmzRg3blyDed5666365ps//OEPkt14xo4di/Hjx2PmzJkwmUxYuHAhpkyZAo2G9x0QEd0ti9WKz9afwJmCSkm9i58rXpkaDY2aCywTETkyWZb3vnLlCl5++WVUVVVBFMVm/4+IiKgj2HLwIn4+ki+pOWmUmJsUA38vZzulIuq4rJUlqNuyAPqfP7HZfKPw6gLncX+G8wPPsPmGiIiIHFJRWQ0+WpUFo1l6Y/m4e7rjwf5d7ZSKiKjliSYDDOkbUb3yf2DM3Gy7+UbtDM3AKXCd/j40/UZCUKrlD0pEROTArujqsDA1E3qjdHe6hwYEYUxCdzulIiKijurLL78EAKhUKrz99tv1zTfXhYaG4vXXXwcA6HQ6pKamNmv+n376Cfn51+4NeOaZZyTNNwCg0Wjw3nvvwcvLCwDw2WefNZjj0KFD2L17NwBgypQpkuab62JjY+t3vdHpdNi/f3+zchIRUUOiKOKbrTnIyLsiqXu7azE/OQZuznzfkIjI0cmyA84333yDmpoaCIKAwMBAvPLKKxg0aBB8fHzg5OQkRwQiIiK72n+8GKk7z0hqSoWAl6ZEoXtn3vhP1JJEixnGrB9hPPoDYDE1HKBUQzNgIjTRj0BQyrYhJBEREVGboqs2YGFKJqrrpL8v3RvVGZOH9bRTKiKiliVazDCd2gnj0R8g1lXaHqRUQ913BLSxYyE4NX01YyIiImo51XUmLEjJREW1tEl2YG9/TB8RBkEQ7JSMiIg6Ip1Oh3379gEAhg0bhuDgYJvjxowZg3fffRdlZWXYsmULZs2a1eRzbN68GQAgCAKmT59uc4yrqyumTJmCL7/8Ejk5OTh37hxCQkLqj1/foUer1WLevHmNnisxMREmkwne3t7w9fVtckYiIrJt/Z5z2JVZKKm5aFWYnxwDHw/e70xERDI14OzYsQMA4OTkhK+//hpBQUFynJaIiKhNOHGuHF9uzm5Q/93YSPTt4WOHREQdl7nwFAx7voZVV2jzuDI4Ck73Pg6FRyeZkxERERG1HXUGMxalZOJKhV5Sj+rpiycfieDNbUTU7olWK8xnDsBweC3EqlLbgwQF1L3vgyZuIhSu3vIGJCIionoGkwUfrspEcXmtpB4e7IVnx/eBQsHXJ0RE1LIOHz4Mq/XajtAJCQmNjlMoFIiPj8eWLVuQmZmJiooKeHp6NukcaWlpAIDevXvDx6fxewISEhLqd+PZtWuXpAHn559/BgDcc8896NSp8c82IyIi8NZbbzUpFxER3drO9AL8sPe8pKZSKvBKYjS6+nPxHiIiukaWBpyCggIIgoBRo0ax+YaIiBzKheIqfLz2GCxWUVJPfrAXEvp2tlMqoo7HWlcJw8HvYc7Za/O44OIF7T2PQRUykDeUEhERkUMzW6xYvPYYLpZUS+o9OrvjhUl9oVIq7JSMiOjuiaIIy8UMGA6thvVqfqPjVKGDoR04GQpPvjdDRERkTxarFZ+tP4EzBdKd6rr6ueLlqVFQq5R2SkZERB1Zbm5u/ePw8PBbju3VqxeAa683c3JyEB8ff9v5L1++jMrKaz/bwsLCbjk2NDS0/vGpU6fqH5eUlKCsrAwAEBsbW183mUzIy8tDaWkpfHx8EBERAZVKltv/iIg6vPScUnzz02lJTQDw/IQ+CA/2sksmIiJqm2T5DVwUr910fGOXPhERUUdXoqvDwtRMGIwWSX3kwGCMGmR7G2siah5RtMJ0ejcMB1MAQ03DAYIAdd8R0A6cAkHjLH9AIiIiojbEKor4cnM2Tp6/Kql38nLG3KQYOGn4YT0RtV/mwlMwpK2C9XJeo2OUwdHQxk+F0q+7jMmIiIjIFlEUsfynHGTkXZHUvd21mJccA1cntZ2SERFRR1dQUFD/uGvXrrcc27nzbws3FBQUNKkBJz//twUhbjd/QEAAFAoFrFYrCgsL6+t5eb+9tg0KCoLJZMK///1vrFixAuXl5fXHvLy88Oyzz2LWrFlQKtm4SkR0p3Lzdfj3DycgStdXxsyHwxHXu/FdyIiIyDHJ8ql6YGAgzp49i4qKCjlOR0REZHeVtUYs/D4DlTVGSX1QZCc8+lAv7sBB1AIs5fkw7F4Gy+Vcm8cV/iFwGvoklP495A1GRERE1Eat3nkGB05cltTcXdSY92gMPFw1dkpFRHR3LFfOw3BoFSz5xxsdowjoBe2gJKgCe8uYjIiIiG5lw97z+DWjUFJz0aowPzkGPh5OdkpFRESO4MYGFm9v71uO9fLyqn+s0+maNP/Vq78tfnO7+dVqNVxcXFBdXS2Zv7i4uP6xRqPBzJkzkZGR0eD5Op0O77//PjIyMrBw4UKo1WxgJSJqroIrNfhoVRZMZqukPu6eHnhwQJCdUhERUVumkOMkw4YNgyiK2LNnjxynIyIisiuD0YIPU7Nw+WqdpB7RzQu/G9sHCjbfEN0V0WSA4WAKale/Ybv5Ru0M7b0z4TLxdTbfEBEREf3XtsOX8OPBi5KaRq3A3KQYBHi72CkVEdGds+qKUffzJ6hd82ajzTcKnyA4j5oLlwmvsfmGiIioDdmVWYh1e85JaiqlAq8kRqOrv5udUhERkaPQ6/X1j7Va7S3HajS/LVpz4/Nupa7ut/sEbjf/jWNunL+mpqb+8T//+U9kZGQgLCwMn332GY4ePYq0tDQsWLAAgYGBAIBt27Zh0aJFTcpHRES/Ka/UY2FKBmr0Zkl9aHQgJg8LsVMqIiJq62TZAeexxx7D999/j9zcXKxZswZTpkyR47RERESys1it+HT9cZwrqpTUg/zdMHtKNNQqWXpfiTos84UM6Pd+A7G6zOZxVc9B0A6ZDoXrrVeTIiIiInIkaadK8N3P0sZlhSDgxUlRCAn0sFMqIqI7Y60uh/HoOphO7wFEq80xgrs/tAMnQ9UrAYLA92KIiIjakoy8K/h6y2lJTQDw3Pg+CA/2sksmIiJyLGbzbzdZ39hgY8uNx2983q1YLJYmz3/jmBvnr62trX986dIlREZGYvny5XBz+61RdezYsRgwYACmTJmC8vJyfPXVV5gxYwa6du3apJwtzaOVdrBTKIT6//r4uLbKOaht4LV2LG3helfXGvHRV2korzRI6gMjAzBv+gAolXxfsaW0hetN8uH1dhyOfK1lacAJDg7GG2+8gb/+9a/43//9XxQWFmL69Onw9fWV4/RERESyEEURy7acRtYZaWOAr4cW85Jj4OIky49dog7JXHkFpVv/g7qcQzaPC+7+cBr6BFTBUTInIyIiImrbTl+8ii82nIB4U/2p0RGIDuV7c0TUfoj6ahgyNsJ04mfAYvumJ8HZE5q4iVD3vg+Cku/DEBERtTVnCirw73XHYRWlr1BmjAzHwIhOdkpFRESOxsnpt0YRk8l0yyYZo9FY/7gpzTSAdNcbk8l02/HXz6FWq+tr4k0/K//xj39Imm+uCwwMxCuvvII333wTZrMZ69atw0svvdSknC2ttW9UFwQBSqXQquegtoHX2rHY63obTRb839eHcbG4SlLv3c0bf3p8IDQavrfYGvj97Vh4vR2HI15rWX5KfPHFFwCAuLg4pKWlYfHixVi8eDECAwPh5+cneWHTGEEQsGzZstaOSkREdMfW7T6HPVlFkpqrkwrzkmPh7X77raWJqCHRakHloQ3Q7U6BaLKxrbtCCU3sWGhix0FQNe1NbyIiIiJHkV9ajY9WH4PZIv3AfvJ9PTE0OtBOqYiImkc01sF47CcYs34EbL0uBACNCzSxY6DpOxKCmu/BEBERtUVFZTX4cFUWjGbpDnZjErrjobggO6UiIiJH5OLiUv/YYDA0uQHnxsaa5sx/O9fH3Hj/nLOzc/3jHj16ICqq8UUIR40ahTfffBMAcPTo0SZlbA0Wi+1dau+WQiFAEASIogir9eZlhqgj4bV2LPa83hariP/v2yM4cVa6wHIXP1e8NiseapWi1f5Nc1T8/nYsvN6Ow57X2t67lMnSgPPBBx9AEK51Nl3/ryiKKCoqQlFR0a2eWj/2+vOIiIjaop3pBdiw77ykplYp8EpiNLr4Odb2ekQtxVJyBvrdX8FadsnmcWVgBLTDnoDSq4vMyYiIiIjavvJKPRamZKLOIN0l4oH+XTFuSHc7pSIiajrRYoLp5A4Y0zdA1FfZHqTUQBM1EpqYMRC0fP+FiIiordJVG7AwJRPVddJdAO7p1xlT7+9pp1REROSoPDw86h/rdDq4u7s3Olan09U/9vHxafb8FRUVtxxrMplQW1vbYP4bd7sJCQm55Rw+Pj7w8vKCTqdDSUlJkzK2hspKPcxmS4vP6+PjCqVSgNUqory8psXnp7aD19qx2Ot6i6KIb7flYP8x6X3Lnq4azE2MhtlgRrnB9u7bdOf4/e1YeL0dh72utUqlhLe3y+0HtmYGuU5089aYjdWIiIjam6M5pfjmp9OSmiAAz0/oi7AgL/uEImrHREMNDIdWwZS9E0DD3xcFJ3doE6ZBFXYPm7SJiIiIbKjRm7AwJRNXq6QrbPYP88PMkeH8HYqI2jTRaoU5dy8MR9ZBrC6zPUhQQh15PzQDJkDh4iVrPiIiImqeOoMZi1IycaVCupNdvxAfPDU6gq9PiIhIdj169Kh/XFRUhODg4EbHFhcX1z/u0qVpiwLePP+tXL58GVartcH8QUHN2x3u+i4+1+ciIiLbNu2/gO1HCyQ1Z60S85Jj4Ofl3MiziIiIpGRpwPnll1/kOA0REZHscvN1+OyHE7i5p3Tmw70xINzfPqGI2ilRFGE+cwCG/Ssh1lXaHKOOuB/aQUkQnNxsHiciIiJydCazBf9afQwFV6SrDPXq6onnJ/SFQsGb24iobRJFEebzR2BMWwOrrrCRUQJUvRKgHTgZCo9OsuYjIiKi5jNbrFi89hgullRL6t07u+PFyf2gUirslIyIiBxZaGho/ePc3FwMGjSo0bG5ubkAAEEQEBYW1qT5vb294evri7KysvrnNyYvL6/+cXh4uM3HBQXSG8VvZrFY6nfqCQgIaFJGIiJHtDurEGt2nZXUVEoBs6dEo1tA47uhERER3UyWBpyuXbvKcRoiIiJZFV6pwUersmAyS1eRGXdPDzzYnz/7iJrDqiuGfu/XsBSctHlc06kbvB9+DrUuzVvtiYiIiMiRWK0ivthwEjmXdJJ6oK8LXkmMhkattE8wIqLbMBechOHQKlhLzzY6RtktFtpBU6H0aXxlYiIiImo7rKKILzdn4+T5q5J6Jy9nzE2KgZNGllsViIiIGujfvz/UajVMJhMOHjyIxx57zOY4i8WCtLQ0AEBERAQ8PDyafI74+Hhs2bIF2dnZqKqqgru77Ru7Dxw4UP/4xkYgb29vhIWFITc3F7m5uSguLkbnzp1tznHixAkYjUYA0sYdIiL6TWbeFSz78bSkJgB4ZlwfRHb3tk8oIiJqt7ikDBER0R24WmXAwpQM1OjNkvrQ6EBMHhZip1RE7Y9oNsJweC1qVv3NdvONSgOvB2ei69Pvwymot/wBiYiIiNoJURSx8pdcHD5dKql7umkwLzkGbs5qOyUjImqcpeQsajf9E3Wb/tlo840ysDdcJrwGl0fmsvmGiIioHVm18wwOnLgsqbm7qDHv0Rh4umrslIqIiAjw8PBAQkICAGD79u0oLLS9C+umTZtQXl4OABg9enSzzjFq1CgAgNlsxsqVK22Oqa6uxtq1awEAISEhiIiIkBwfO3YsgGvv+33xxReNnmv58uX1j5ubk4jIEZwprMCn64/DKoqS+rSHwjAokjuHERFR83FZGSIiomaq1ZuxMCUTZZUGST061BdPjOoNQRDslIyofTHnn4B+79cQKy7bPK7q3h/aex6DZ/fuEJQKwGK1OY6IiIiIgC0HL+KXI/mSmpNGiXlJMfDzdLZTKiIi2yxXC2FMWw3z+SONjlH4dr+2401QFN9r6UBEUcTGjRuxevVqZGdno7a2Fv7+/oiPj8djjz2G6Ojouz5HTk4Oli5dioMHD6KkpATu7u4IDQ3FpEmTMHnyZCiVt94Rzmq1YuPGjVi/fj1OnDiB6upq+Pr6IjIyEpMmTcKoUaP4d5KI6Da2pV3CloMXJTWNWoG5STEI8HaxUyoiIqLfPPXUU9i9ezdMJhPmz5+PJUuWwM3Nrf54Xl4e3nnnHQCAq6srkpKSmjX/iBEjEBQUhPz8fCxevBgDBgzAwIED648bjUa8+uqr0Ol0AIBZs2Y1mGPatGn4+uuvUV5ejpUrVyI6OhoTJ06UjFm3bh3Wr18PABgwYABiYmKalZOIqKMrLq/Fh6lZMJqk95uMHtwNI+O52A8REd2ZFm3AWbduXf3jSZMm2azfjRvnJCIisgeT2YqP12Qhv7RaUg8J9MALE/tBpeTmckS3Y63VwXDgO5jzDtg8Lrj6QHvvTKh7DJA5GREREVH7tP94MVJ3npHUlAoBs6dEoVuAu51SERE1ZK0ug+HwOphz9wA3rTh5neAZAO3AKVD1jIcg8H2WjkSv12POnDnYuXOnpF5QUICCggJs2LABc+fOxXPPPXfH50hNTcVbb70Fk8lUXysvL0d5eTnS0tKwdu1aLF68GF5eXjafX1FRgZdeeglpaWmSenFxMYqLi7Fjxw4MHjwYCxcuhK+v7x3nJCLqyA5lX8Z3v+RKagpBwIuTohAS6GGnVERERFJDhw7FqFGjsHXrVqSnp2PixImYPn06AgMDcfLkSaxcuRI1NTUAgFdffRU+Pj6S5x88eBBPPPEEAGDQoEH45ptvJMc1Gg1ee+01vPjii9Dr9XjqqaeQlJSEAQMGQKfTISUlBTk5OQCuNc4kJiY2yOjt7Y2///3vmDNnDiwWC1599VX8+OOPGD58ODQaDXbs2IEtW7YAALRaLf7xj3+0+J8TEVF7pqs2YMH3GaiuM0nqQ/p2xtQHQu2UioiIOoIWbcD585//DEEQIAiCpFnmev1u3DwnERGR3KyiiCUbT+LURZ2kHuDtjDlJ0dBqbr16JpGjE0UrTNk7YTiUChjrGg4QFFBHPQxt3CQIaif5AxIRERG1QyfOlePLzdkN6r8bF4k+PXxsPIOISH7WukoY0zfAdHIHYDXbHCO4eEETNwnq3kMhKFr0owtqI1577bX65pvQ0FAkJyfDz88PJ06cwHfffYfa2lp88MEHCAgIaLCqc1Ps3r0br7/+OkRRhLOzM6ZNm4Z+/fqhrKwMq1atQk5ODg4fPly/urVCIW3wslqteOGFF3DkyLWdmbp27YrExEQEBwejqKgI69atw5kzZ3Dw4EG89NJL+Prrr6HRaO76z4WIqCPJvnAVSzaexM1ttk+NjkB0KBsXiYiobXnvvfdQU1ODPXv2ID8/H++//77kuCAImD17NqZNm3ZH8w8fPhxvvPEG3nnnHZhMJqxYsQIrVqyQjImKisInn3zS6E6dI0eOxAcffIC//e1vqK6uxo4dO7Bjxw7JGC8vL3z66afo1avXHeUkIuqIavVmLEzJxJUKvaTeL8QHs8ZEQMHdjYmI6C60+KdYYiOr1jVWJyIiag9EUcT3v+Qh7VSJpO7hqsG8R2Ph4cIP24luxXLlAvR7lsFactbmcUWnUDgNexJK324yJyMiIiJqvy4UV+HjtcdgsUrfd0t+sBcS+nS2Uyoiot+IxjoYs7bAeGwrYNLbHqR1hTZ2HNR9H4Kg4vsrHdXevXuxceNGAEBCQgI+//xzaLVaAMC4ceOQmJiIGTNmQKfT4d1338VDDz0ENze3Js9vNBrx5ptvQhRFuLi4YPny5ejbt2/98enTp2P+/PnYtm0b9u7di82bN2PcuHGSOdasWVPffDN48GB8/vnncHL6bYGQWbNmYc6cOfjll1+Qnp6OjRs3YsqUKXf8Z0JE1NFcKqnGx2uyYLZIX59Mua8nhkYH2ikVERFR45ydnbFkyRJs2LAB69atQ3Z2NqqqquDl5YW4uDg88cQTiIuLu6tzTJ8+HQMHDsSyZcuwb98+lJaWQq1WIzw8HOPHj0dycjLUavUt5xg9ejTi4uLw7bffYvv27SgoKIAgCAgODsaIESMwY8aMBjv0EBE5MpPZisVrj+FSSbWk3qOzO16c3A8qJXfdJiKiu9OiDTizZ89uVp2IiKi92HroErYdviSpaTVKzEuKQScvZzulImr7RGMdDEfWwXT8J8BWQ7bGBdrByVBH3AdB4JscRERERE1VqqvDotRMGIwWSX3kwGCMGhRsp1RERNeIZiNMJ3+BMX0TREO17UEqLTTRo6CJfgSCxkXegCS7L7/8EgCgUqnw9ttv1zffXBcaGorXX38df/jDH6DT6ZCamopZs2Y1ef6ffvoJ+fn5AIBnnnlG0nwDABqNBu+99x7S0tKg0+nw2WefNWjA+e677wAASqUS//znPyXNNwCgVqvxxhtv4JdffgEAbN68mQ04RET/VVahx8KUDNQZpK9PHhzQFWOHdLdTKiIiotsTBAETJkzAhAkTmvW8wYMH4/Tp000aGxYWhrfffvtO4tXr1KkT5s2bh3nz5t3VPEREHZ1VFPGfTSeRfeGqpN7Jyxlzk2LgpOHO20REdPfYgENERHQb+08UI2VHnqSmVAiYPTkK3Tu72ykVUdsmiiLM54/CsO9biDXlNseoeg2BNmEaFC6eMqcjIiIiat+qao1YkJKJihqjpB4f0QmPPtQLgiDYKRkROTrRaoEpZw+MR9Y3+loQChXUfR6EJnYcXw86CJ1Oh3379gEAhg0bhuBg242iY8aMwbvvvouysjJs2bKlWQ04mzdvBnDt5rnp06fbHOPq6oopU6bgyy+/RE5ODs6dO4eQkBAAgMViQZcuXVBdXQ1/f3907mx7J7mAgAD4+PigvLwchYWFTc5HRNSRVdeZsCAlA7pq6euTAeH+eGxEOF+fEBERERGRLERRxPe/5OFQdomk7uGixvxHY+Dhyt23iYioZbCdk4iI6BZOnC/Hl5uyG9SfHhOJviHcxpnIFmtVKfR7l8NyMdPmccGzM5yGPgFV1z4yJyMiIiJq/wwmCz5alYXL5bWSekQ3Lzwzrg8UvLmNiOxAFK0wnzsMQ9oaiBXFtgcJAlRh90AbNwkKd395A5JdHT58GFarFQCQkJDQ6DiFQoH4+Hhs2bIFmZmZqKiogKdn05q00tLSAAC9e/eGj0/j79klJCTU78aza9eu+gYcpVKJjz766LbnqampQVVVFQDAz8+vSdmIiDoy439fnxSVSV+f9AryxHPj+0Ch4OsTIiIiIiKSx9ZDl7Dt8CVJTatWYm5yDDp5cwduIiJqOWzAISIiasSF4ip8vOYYLFZRUk96IBRD+tleBZPIkYlWM4xZW2E8sh6wGBsOUKqg6T8empgxEJRq+QMSERERtXMWqxWfrT+BM4WVknqQvytmT4mCWqWwUzIiclSiKMKSfxyGtFWwXrnQ6DhVjzho4qdA6d1VxnTUVuTm5tY/Dg8Pv+XYXr16Abj2dysnJwfx8fG3nf/y5cuorLz2szEsLOyWY0NDQ+sfnzp16rZz3+zjjz+GyWQCADzyyCPNfj4RUUditYr47IcTyCuokNQDfV3wytRoaNRKOyUjIiIiIiJHs/94MVJ25ElqSoWAl6b0Q4/OHnZKRUREHRUbcIiIiGwo1dVhUWomDEaLpD4iLgiPDO5mp1REbZe5OAeG3ctgvVpg87iya184DX0CCs8AmZMRERERdQyiKOKbrTnIyLsiqft4aDEvORYuTmxwJiJ5WS7nwXAoFZai042OUXaJhHZQIpSdQhsdQx1fQcFv7xV07XrrJqzOnX9b9KagoKBJDTj5+flNnj8gIAAKhQJWqxWFhYW3ndtiseDKlSs4duwYvv76axw8eBAAMGjQICQmJt72+UREHZUoili+LQfpudLXJ97uWsxPjoWbM1+fEBERERGRPI6fK8OXm7Mb1J8eE4l+Ib52SERERB0dG3CIiIhuUlVrxIKUTFTUSHfwGBjRCdNGhEEQBDslI2p7RH01DAdTYDq9y+ZxwdkD2iEzoAodzO8dIiIioruwYe957MqU3ijsolVhXnIsvN21dkpFRI7IUp4PY9pqmC+kNzpG4R8CbXwiVEF9ZUxGbVV5eXn9Y29v71uO9fLyqn+s0+maNP/Vq1ebPL9arYaLiwuqq6ubNP+kSZOQk5NT//8FQcBjjz2G+fPnQ6PRNCkfEVFHtHH/BexMly7G5KxVYV5SDHw9neyUioiIiIiIHM354kosXnscFqsoqSc9GIoh/To38iwiIqK7wwYcIiKiGxhMFny0KguXy2sl9d7BXnh2XCQUbCAgAnBthUNz7l4YDnwPUV9lY4QAdZ8HoY2fCkHrKns+IiIioo5kV2Yh1u05J6mplAq8khiNrn78XYuI5GGtLIXhyFqYc/cDEG2OUXgFQjNwClQhA7kIA9XT6/X1j7XaWzeN3tjUcuPzbqWurq7J818fU11d3aT5i4qKJP9fFEUcOHAAO3fuxNixY5uUr7V4eLTODe4KhVD/Xx8f/p7R0fF6O46WvNa/pF3E2l1nJTWVUoG/PhWPqFC/u5qbWga/tx0Lr7dj4fUmIiL6TcnVWixKyYTBaJHURw4MxiODutkpFREROQI24NxAFEVs3LgRq1evRnZ2Nmpra+Hv74/4+Hg89thjiI6Ovutz5OTkYOnSpTh48CBKSkrg7u6O0NBQTJo0CZMnT4ZSqZRlDr1ej++++w5bt27FuXPnUF1dDV9fX8TFxWHmzJkYMGDAXX+tRETtjcVqxb/XHceZwkpJPcjfFS9PjYJadft/X4kcgeVqIQx7lsFSdNrmcYVvNzgNewrKTj1lTkZERETU8WTmXcHXW6S/dwkAnp/QB+HBXnbJRESOxVqrg/HoBphO7QSsFptjBFcfaAdOhirsHggKvn9CUmazuf7x7XaNufH4jc+7FYvlt7+XTdmV5vqY281vNpvx5JNPomfPntDr9di3bx82b96MvLw8zJ8/H7m5uZg7d26TMrYGpVLRqvMLggClko10joLX23Hc7bU+nH0Zi1dn3TQn8IfHBiA2vNPdxqMWxu9tx8Lr7Vh4vYmIyNFV1hix4PtMVNaaJPVBkZ3w6EO9uDgQERG1Kjbg/Jder8ecOXOwc+dOSb2goAAFBQXYsGED5s6di+eee+6Oz5Gamoq33noLJtNvP/TLy8tRXl6OtLQ0rF27FosXL4aXl1erznHq1Cm8/PLLuHjxoqReXFyMTZs2YfPmzfj9739v1w+OiIjkJooivtl6GplnyiR1Hw8t5iXHwsVJbadkRG2HaDbAeHQDjFk/2r7pSu0E7cDJUPcdwRuuiIiIiFrAmcIKfLruOKyidKeJGSPDEdebN7cRUesSDTUwZv4I4/GfALPR5hjByR2a/uOgjnwQgur2jQ/kmJycftupxWQy3bJJxmj87e9aU5ppAOmuNzd+dnK7c6jVt36/T6VS4eWXX67//1OnTkViYiKef/55GAwGfPrppxg6dCgGDhzYpJwtzWKxtsq8CoUAQRAgiiKsVtu7XVHHwevtOFriWudcvIr/tyytwfN/N74vhvQLbLV/l6j5+L3tWHi9HYu9rndrN38TERE1h95oxsLUTJTo6iT1yO7e+N3YPlCw+YaIiFoZG3D+67XXXqtvvgkNDUVycjL8/Pxw4sQJfPfdd6itrcUHH3yAgIAATJw4sdnz7969G6+//jpEUYSzszOmTZuGfv36oaysDKtWrUJOTg4OHz6M+fPnY8mSJVAoGr54bYk5Ll26hFmzZqG8vBwAMGTIEIwcORJeXl44evQoUlNT6z846ty5M6ZNm9bsr5WIqD1av+ccdmUWSWouWhXmJcfC213byLOIHIf5Uhb0e76BWFVq87gqZCC0Q2ZA4eYjczIiIiKijqm4vBYfpmbBaJbexDZ2SHc8FBdkp1RE5AhEswHG4z/DmLkZMNTYHqR2gib6EWiiRkHQOMsbkNodFxeX+scGg6HJDTg3NtY0Z/7buT7mxsagphoyZAheeeUVvP/++wCA5cuX260Bp7JSD7PZ9q5Ud8PHxxVKpQCrVUR5eSP/BlCHwevtOO72Wl8ur8U73xyBwST9d2f04G64p08A//60Mfzediy83o7FHtdbpVLC29vl9gOJiIhkYLZY8cna47hQXCWpB3dyw+wpUVCr2DRKREStjw04APbu3YuNGzcCABISEvD555/Xf7Azbtw4JCYmYsaMGdDpdHj33Xfx0EMPwc3NrcnzG41GvPnmmxBFES4uLli+fDn69u1bf3z69OmYP38+tm3bhr1792Lz5s0YN25ci88BAG+99VZ9880f/vAHyY4+Y8eOxfjx4zFz5kyYTCYsXLgQU6ZMafIqc0RE7dXOjAL8sPe8pKZSKvBKYjS6+rnaJxRRG2GtuQrD/hUwn02zeVxw94PTvTOh6hYrbzAiIiKiDqyixogF32eguk66iv89/Tpjyn097ZSKiDo60WqG6dQuGI/+ALFWZ3uQUgV1n4eg6T8OCid3WfNR++Xh4VH/WKfTwd298b87Op2u/rGPT9MW+bhx/oqKiluONZlMqK2tbdb8N0tKSsIHH3wAq9WKo0eP3tEcRETtSUWNER/YeH0ypG8Apj4QaqdURERERETkaERRxNLNp3D8XLmk7ufphHnJMXDW8nZoIiKSB9s9AXz55ZcAAJVKhbfffrvBqmqhoaF4/fXXAVz78Cc1NbVZ8//000/Iz88HADzzzDOSxhkA0Gg0eO+99+Dl5QUA+Oyzz1pljkOHDmH37t0AgClTpkiab66LjY2t3/VGp9Nh//79zfhKiYjan/TcUnyz9bSkJgB4fkIfhAd72SUTUVsgWq0wHt+GmpS/2G6+EZTQxI6Da9I7bL4hIiIiakF1BjMWpWTiSoVeUu8X4oOnRkdAEAQ7JSOijkoUrTDl7UdNyl9h2PO17eYbQYC6931wffQ9OA2ZzuYbapYePXrUPy4qKmp8IIDi4uL6x126dGnx+S9fvgyr1dqs+W/m6ekJX19fAKhf8IyIqKNq7PVJ3xAfzBoTCQVfnxARERERkUxW/XoG+08US2puzmrMS46Bl1vTdlImIiJqCQ7fgKPT6bBv3z4AwLBhwxAcHGxz3JgxY+o/UNmyZUuzzrF582YAgCAImD59us0xrq6umDJlCgAgJycH586da/E5ru/yo9VqMW/evEbzJiYmYtq0aXjhhRfqv2Yioo4or6ACn60/AVGU1h97OBxxvTvZJxRRG2ApPYfadX+HYd+3gEnf4Liyczhcpv4d2kGJEFR8E4OIiIiopZgtVnyy7jguXK6S1Lt3dscLk/pBpXT4t/KIqAWJogjzxQzUrnkD+u2fQawssTlO1TMerknvwun+p6Fw4/vF1Hyhob/tjpCbm3vLsdePC4KAsLCwJs3v7e1d/1nG7ebPy8urfxweHl7/+MyZM/jLX/6CmTNnYvXq1bc9p8FgAHDtcxkioo6qsdcn3QLc8CJfnxARERERkYy2pV3CjwcuSmoatQJzkqIR6Mv3Z4iISF5223OtqKgIR44cQWFhISoqKnD//fdj0KBBAIA9e/YgKioKnp6erZ7j8OHD9audJSQkNDpOoVAgPj4eW7ZsQWZmJioqKpqcLy3t2qrxvXv3ho+PT6PjEhIS6nfj2bVrF0JCQlp0jp9//hkAcM8996BTp8ZvLI+IiMBbb711uy+LiKhdKyqrwYepmTCarZL62CHdMXxAkJ1SEdmXaKyFIW01TCe2AxAbHBe0btAmPApV+L0QBH64SkRERNSSRFHEVz+ewolz0pX0/TydMDcpBs5au72NR0QdkLnoNIxpq2Epzml0jDKoH7TxiVD695AvGHVI/fv3h1qthslkwsGDB/HYY4/ZHGexWOo/C4mIiICHh0eTz3H985vs7GxUVVXB3d32Lk0HDhyof3z9M6nr516zZg0AwM3NDVOnTm30XOfOnUNlZSUASD6DISLqSERRxNLNtl+fzOPrEyIiIiIiktGh7Mv47hfpoisKQcALE/shtEvr32NMRER0M9nfGTtw4AA+/vhjHDlyRFL38/Or/7DjjTfeQFlZGR5//HG8/PLL0Gg0rZbnxtXQblztzJZevXoBuPaGY05ODuLj4287/+XLl+s/iLndam03rgJ36tSpFp2jpKQEZWVlAIDY2Nj6uslkQl5eHkpLS+Hj44OIiAioVHzDlIg6tqtVBiz4PhM1erOkfm9UZ0y5r6edUhHZjyiKMJ9Ng2H/Coi1OptjVOHDoE1IhsLJ9g0sRERERHR31uw6i33HiyU1N2c1/vBoLDxdW++9MSJyLJYrF2BIWw3LpaxGxyg6hUI7KBGqLpEyJqOOzMPDAwkJCdi9eze2b9+OwsJCdOnSpcG4TZs2obz82o3eo0ePbtY5Ro0ahS1btsBsNmPlypV47rnnGoyprq7G2rVrAVxrnImIiKg/FhYWhsDAQBQVFWH37t24dOkSgoODbZ7riy++qH88YsSIZuUkImovVv16BvtPNHx9Mv/RWHi6cVd0IiIiIiKSR/b5cizZeLLBErJPju6NmF5+dslEREQk69Ll//rXv/D000/jyJEjEEWx/n83slgsKC4uhsFgwJIlSzBz5kxUV1e3WqaCgoL6x127dr3l2M6dO9t83q3k5+c3ef6AgAAoFNcuSWFhYYvOkZeXV/84KCgIJpMJ//rXv3Dfffdh0qRJePbZZzF16lTce++9WLJkCSwWSxO+OiKi9qdWb8ai1EyUVeol9aievnjykQgIgmCnZET2Ya0sQd2PH0D/yyc2m28U3l3gPP4vcH7gd2y+ISIiImolvxzJx6b9FyQ1jVqBOUnRCPBxsVMqIupIrBWXUffLv1G75o1Gm28U3l3h9PArcJn4NzbfUIt76qmnAFxbFGz+/PkNPvfJy8vDO++8AwBwdXVFUlJSs+YfMWIEgoKu7Wq9ePFiHD58WHLcaDTi1VdfhU6nAwDMmjVLclwQBDz55JMAALPZjD/+8Y82P5tatmwZVq9eDQDw9/fH9OnTm5WTiKg9+PnwJfx44KKkdv31SWe+PiEiIiIiIplcvFyFf605BrNFeo/x5Pt6Ylh0w8VdiIiI5CLbVifLli3D4sWL6/9/SEgIYmNj61cbu66urg49e/as35nm2LFjePXVV/HJJ5+0Sq7rq6kBgLe39y3Henl51T++/iHN7Vy9erXJ86vVari4uKC6uloyf0vMUVz82wpFGo0GM2fOREZGRoPn63Q6vP/++8jIyMDChQuhVqtveT4iovbEZLZi8dpjuFQi/fC8R2d3vDCpL1RKWftSiexKtJhgzPwRxvQNgMXUcIBSA03cBGiiHoGg5O54RERERK3lyOkSrNiWI6kpBAEvTOyH0C6edkpFRB2FteYqjEfXw3RqNyDaXnRJcPeDNm4yVL2GQFDwvRFqHUOHDsWoUaOwdetWpKenY+LEiZg+fToCAwNx8uRJrFy5EjU1NQCAV199FT4+PpLnHzx4EE888QQAYNCgQfjmm28kxzUaDV577TW8+OKL0Ov1eOqpp5CUlIQBAwZAp9MhJSUFOTnXft4OGDAAiYmJDTLOnDkTP//8Mw4fPoz09HSMGzcOjz76KHr06IHy8nJs2bIFhw4dAnDts5iFCxfC1dW1xf+siIjsKe1UCVb+nCup8fUJERERERHJ7YquDgtTM6E3St/TfHBAV4wb0t1OqYiIiK6R5W7Ky5cvY8GCBQAAd3d3vP322xg1ahQANGjAcXNzw4YNG7Bu3Tr8/e9/R21tLXbs2IH9+/djyJAhLZ5Nr/9tBwSt9tbbZWs0GpvPu5W6uromz399THV1tWT+lpjj+gdXAPDPf/4Tly5dQlhYGP7nf/4H8fHxsFgs2L17N95//30UFRVh27ZtWLRoEf74xz/e9nxERO2BVRTxn00nkX3hqqTeydsZc5Ni4KRhgwE5DnNhNgx7voZVV2TzuDI4Gk73Pg6Fh7/MyYiIiIgcS84lHT774STEm+pPPNIbMb387JKJiDoGUV8NY+ZmGI9vs73oAgDB2QOa/hOgjnyACy+QLN577z3U1NRgz549yM/Px/vvvy85LggCZs+ejWnTpt3R/MOHD8cbb7yBd955ByaTCStWrMCKFSskY6KiovDJJ59AqVQ2eL5arcann36KefPmYc+ePSgqKsKiRYsajPP19cWiRYsQHx9/RzmJiNqq0xev4osNJxq8PnmSr0+IiIiIiEhGVbVGLEjJREW1UVKPC/fHYyPCIQiCnZIRERFdI8unaitWrIDBYIAgCFiwYAGGDRt22+dMmjQJHh4eePHFFwEA69ata5UGHLPZXP/4xgYbW248fuPzbsVi+a0D93bz3zjmxvlbYo7a2tr6x5cuXUJkZCSWL18ONze3+vrYsWMxYMAATJkyBeXl5fjqq68wY8YMdO3a9bbnbA0eHk4tPqdCIdT/18eHK9N1dLzejuV21/vLDSdwKLtEUvN00+Ct54Yg0Jd/P9obfn/fGUttBa5u/wZ1x3+1eVzp5g3vEU/DpffgNvWGBa+34+C1JiIiR1JwpQYfrcqC2WKV1CcNDcF9MV3slIqI2jvRpIfx2E8wZv0IGOtsD1I7QxMzGpqohyGoW/49WKLGODs7Y8mSJfWLsGVnZ6OqqgpeXl6Ii4vDE088gbi4uLs6x/Tp0zFw4EAsW7YM+/btQ2lpKdRqNcLDwzF+/HgkJydDrVY3+nwPDw8sWbIEP//8M1avXo1jx46hoqICrq6u6NmzJx566CFMnz6dO98QUYeTX1qNj1Yfg9kibb+ZNCwEw/j6hIiIiIiIZGIwWvDhqiwUl9dK6uHBXnhuQp/6ewqIiIjsSZYGnN27d0MQBMTGxjap+ea64cOHIzY2FhkZGcjIyGiVbE5Ov33AaDKZbtngYjT+1lHblEYYQLpjjclke6VBW+e48QOglphDFKVvlv7jH/+QNN9cFxgYiFdeeQVvvvkmzGYz1q1bh5deeum252wNSqWi1eYWBAFKJX8ZcxS83o7F1vVe92sefth9VlJz0ijxxjMJCOrkLmc8amH8/m4aUbSiKmM7yrd/A6u+uuEAQQGPgaPhc/80KLQu8gdsIl5vx8FrTUREHd3VKgMWpmSg1iBd4OW+mC4Yf28P+4QionZNtJhhyt4JY/oPEOsqbQ9SqqHpNxKamDEQnBq+N0wkB0EQMGHCBEyYMKFZzxs8eDBOnz7dpLFhYWF4++237yQegGsZR44ciZEjR97xHERE7Ul5pR4LUzJRd9Prkwdiu2D8PT3sE4qIiIiIiByOxWrFp+uP42yh9P3Nrv6ueGVqFNSqhjsaExER2YMsDTgFBQUAgPj4+GY/t3///sjIyEBJScntB98BF5ffbjI1GAxNbsC5sSmmOfPfzvUxNzYGtcQczs7O9Y979OiBqKioRp8/atQovPnmmwCAo0eP3vZ8rcVy0wqwLUGhECAIAkRRhNV68wbq1NHwejuWxq73rvQC/OeHE5KxSoWAPz0+ED27eLbKvzXU+vj93XTGkgso3/oFDAW2b1LRdA6FzyPPQdu5J0S0zs/fu8Xr7Tjsea1bs/mbiIjoRrV6ExamZKC8UvoeT2wvPzw+KrxN7URIRG2faLXCnLcfhiNrIVZdsT1IUEAdcR80AyZC4eotb0AiIiJq02r0JixIycTVKunrk/5hfpj5cG++PiEiIiIiIlmIoohlW04j60yZpO7jocW8pBi4ODW+ozEREZHcZGnAqaurAwCbO67cjoeHBwDAam2dm0Gvzw8AOp0O7u6N74Sg0+nqH/v4+DR7/oqKiluONZlMqK2tbTB/S8xx4599SEjILefw8fGBl5cXdDpdqzU+NUVlpR5ms6VF5/TxcYVSKcBqFVFeXtOic1Pbw+vtWGxd75Pny/FhSmaDsU+NjkB3f1f+vWjH+P19e6LJAOPR9TBmbQVEGz9P1c7QDkqEOvJB1CgUqGnDf4683o7DXtdapVLC27vt7v5EREQdh8lsxcdrjiG/VPpzLrSLB56f2BdKBRtCiahpRFGE+UI6jGmrYb1a0Og4VWgCtAMnQ+EZIGM6IiIiag9MZgv+tSoLhVekr096dfXE8xP6QqFg8w0REREREclj3e5z2JNVJKm5OqkwLzkWPh5OjTyLiIjIPmRpwPH29kZJSQkKCwub/dwzZ87Uz9EaevToUf+4qKgIwcHBjY4tLi6uf9ylS5c7mv9WLl++XN9odOP8LTFHUFBQk/Jed30noNZqfCIiam0XL1fh4zXHYLlpB4Wp9/fEvVGBdkpFJA/zhXTo9y6HWF1m87gqdDC0Q6ZD4eIlbzAiIiIiB2YVRSzZeBKnLuok9QAfF7ySGA2tWmmfYETU7pgLs2E4tArWkjONjlEGR0MbPxVKv+4yJiMiIqL2wmoV8fkPJ5GTL138MdD32usTDV+fEBERERGRTHYczceGfeclNbVKgVcSo9HVz9U+oYiIiG5BlgacyMhIXL58GTt27MDf/vY3qFRNO21ZWRm2b98OQRAQGRnZKtlCQ0PrH+fm5mLQoEGNjs3NzQUACIKAsLCwJs3v7e0NX19flJWV1T+/MXl5efWPw8PDW3SOGx8XFDS+IiIAWCyW+t1+AgK4MiIRtT9XdHVYmJIJvVG668dDA4IwJoE3nlDHZa0ug2HftzCfP2rzuODRCU5Dn4AqqJ/MyYiIiIgoZXse0k5Jdxr2dNVgfnIM3F00dkpFRO2JpfQ8DGmrYMk/3ugYZUAYNIMSoQrsLWMyIiIiak9EUcSKn3NwJKdUUvdy02BecgzcnNV2SkZERERERI5m/7EiLP8pR1ITBOD5CX0RFuRln1BERES3oZDjJCNGjAAAlJSU4MMPP2zSc4xGI/74xz+itrYWADB8+PBWyda/f3+o1dfeRDx48GCj4ywWC9LS0gAAERER8PDwaPI54uPjAQDZ2dmoqqpqdNyBAwfqH9/cCHS3c3h7e9c3DeXm5kp287nZiRMnYDQaAUgbd4iI2oPKGiMWpGSiosYoqQ/s7Y/pI8IgCIKdkhG1HtFqgTFrC2pS/mq7+UahhGbABLgmvs3mGyIiIiI72HLwIn5KuySpaTVKzE2Kgb+Xs51SEVF7YdUVoe7nxahd+2ajzTcKn2A4PzIXzhP+yuYbIiIiuqXNBy5g+1Hpgo3OWiXmJcfCz5OvT4iIiIiISB4nzpZhwcqjEG+qP/5wbwwI97dLJiIioqaQpQFn0qRJ6N792o4DS5YswWuvvYZLly7ZHGuxWLBz504kJydj//79EAQBnTt3xqRJk1olm4eHBxISEgAA27dvR2Fhoc1xmzZtQnl5OQBg9OjRzTrHqFGjAABmsxkrV660Oaa6uhpr164FAISEhCAiIqLF5xg7diyAa6saffHFF43mXb58ef3j5n6tRET2pDea8c5Xh1BcXiuphwd74dnxfaBQsPmGOh7L5TzUrn0ThgPfAWZDg+PKLpFwSfwHtAOnQFBxZXUiIiIiue1KL0DKjjxJTakQMHtyFLp3drdTKiJqD6zVZdD/+iVqUl+D+WyazTGCRyc4Df89XKa+BVW3WC48QkRERLe0/fAlrP71rKR2/fVJcCc3O6UiIiIiIiJHc7G4Cv/48iBMZqukPuHeHnigf1c7pSIiImoaWRpwVCoVFi1aBBcXFwDAmjVr8PDDDyMuLq5+zLfffotJkyZh4MCBeOGFF3D69GmIogiVSoX333+/fpea1vDUU08BAEwmE+bPn4/q6mrJ8by8PLzzzjsAAFdXVyQlJTVr/hEjRiAoKAgAsHjxYhw+fFhy3Gg04tVXX4VOpwMAzJo1q1XmmDZtGnx8fAAAK1euxPr16xuMWbduXX19wIABiImJacZXSkRkPxaLFf/f8iM4feGqpN7VzxUvT42CWqW0UzKi1iEaaqDf/RVq178Da1nDxmbByR1ODz4H57GvQunVxQ4JiYiIiCgzpxQfpaQ3qD89JhJ9Q3zskIiI2gOrvgr6/StR8/2fYDq9CxCtDcYILl7QDn0CrsnvQt0rAYIgy1v9RERE1I4dOXUZH6/KbFB/ZlwfRPbg6xMiIiIiIpJHeaUeb/3nAGrqTJL6fTFdMHFoiJ1SERERNZ1KrhNFRkZi6dKlmDt3bv0uMzU1NfUr8hUUXNvmWhR/21DO09MT77//PgYOHNiq2YYOHYpRo0Zh69atSE9Px8SJEzF9+nQEBgbi5MmTWLlyJWpqagAAr776an0Ty3UHDx7EE088AQAYNGgQvvnmG8lxjUaD1157DS+++CL0ej2eeuopJCUlYcCAAdDpdEhJSUFOTg6Aa00viYmJDTK2xBze3t74+9//jjlz5sBiseDVV1/Fjz/+iOHDh0Oj0WDHjh3YsmULAECr1eIf//jHXf7JEhHJQxRFfLbuGA6eKJbUvd21mJccA1en1mviJJKbKIow5+2H4cB3EOsqbY5RRzwA7aBECE5csZCIiIjIXs4VVuCdrw7BbBEl9aQHQjGkX2c7pSKitkw01sF4bCuMWVsAk972IK0rNDFjoOk3AoJKK29AIiIiardyL+nw/5alwWqVvj6ZNrwXBvcJsFMqIiIiIiJyNDV6ExakZKKsQvr+Z2wvPzw+Kpw7fBMRUbsgWwMOAERHR+OHH37AypUrsWrVKly4cEHScHOdn58fJk2ahKeeegp+fn6yZHvvvfdQU1ODPXv2ID8/H++//77kuCAImD17NqZNm3ZH8w8fPhxvvPEG3nnnHZhMJqxYsQIrVqyQjImKisInn3wCpdL2Lg0tMcfIkSPxwQcf4G9/+xuqq6uxY8cO7NixQzLGy8sLn376KXr16nVHXysRkdw27D2Pnw5elNRctCrMT46Bj4eTnVIRtTyrrgj6PV/DUpht87jCJwhOQ5+EsnOYzMmIiIiI6EZXdHX4v2+Pos5gltRHxAXhkcHd7JSKiNoq0WyEKXsHjOkbIeqrbA9SaaDp9zA0MaMhaF3lDUhERETt2uWrtfh/y49Cb7RI6qMGBePhQXx9QkRERERE8jCaLPhoVRYKr9RI6qFdPfD8xL5QKrjLNxERtQ+yNuAAgJubG5599lk8++yzKC0tRV5eHioqKmCxWODh4YHg4GD06NFD7lhwdnbGkiVLsGHDBqxbtw7Z2dmoqqqCl5cX4uLi8MQTTyAuLu6uzjF9+nQMHDgQy5Ytw759+1BaWgq1Wo3w8HCMHz8eycnJUKtvvUtDS8wxevRoxMXF4dtvv8X27dtRUFAAQRAQHByMESNGYMaMGQ12+SEiaqt2ZRZi3Z5zkppKqcAridHo6s/dP6hjEM1GGDM2wZixCbCaGw5QaaAdOBnqfiMhKGT/9Y6IiIiIblBdd231tqtVBkl9YG9/THsojKu3EVE90WqBOWcvDEfWQawptz1IoYQ64gFoBoyHwsVL1nxERETU/lXWGLHw+0xU1Bgl9YQ+AUh6kIsxEhERERGRPKxWEZ/9cAK5+RWSelAnN8xJjIFWbXvBeSIiorbIrndo+vv7w9/f354RJARBwIQJEzBhwoRmPW/w4ME4ffp0k8aGhYXh7bffvpN4LTpHp06dMG/ePMybN++u5iEisqeMvCv4eov0319BAJ4b3wfhwV72CUXUwsz5x6Hf8w3Eyss2j6u694f23plQuPnKnIyIiIiIbnZ99bbi8lpJPTzYC8+O7wOFgs03RASIogjzucMwHl4Dq66okVECVGFDoI2bDIVH23kPnYiIiNoPvdGMRamZKNHVSeqR3b3x9NhIKLg4ABERERERyUAURSzfloP03CuSuo+HE/73d4OhEkU7JSMiIrozXCKdiIjapTMFFfj3uuOw3vQi7JkJ/TAwopOdUhG1HGutDob938F85oDN44KrD7T3zoS6xwCZkxERERGRLddXb8srkK7e1i3AHS9PjYJaxdXbiAgw55+AIW0VrKXnGh2j6t4fmvgpUPoEy5iMiIiIOhKzxYpP1h3H+eIqST2kiwdmT4mCSqmwUzIiIiIiInI0G/edx870AknNxUmFt54bgk7eLigvr7FTMiIiojtjlwacS5cuoby8HEaj8faDbxAfH99KiYiIqD0pKqvBh6uyYDRbJfXE4WEYe28IX5hRuyZarTCd2gnDoVTAWNdwgKCAOuphaOMmQVA7yR+QiIiIiBpobPU2P89rq7cprNZGnklEjsJSchaGQ6mwFGY3OkYZ2BvaQUlQBvSSMRkRERF1NKIoYtmPp3D8bLmk3snHBa8/PRgwW+yUjIiIiIiIHM2uzEKs3S1djEilFPCXJ+PRI9ADFgs/PyEiovZHtgac2tpa/Otf/8KaNWtQWVnZ7OcLgoCTJ0+2QjIiImpPdNUGLEzJRHWdSVJ/MC4IT4yJhNXKbUmp/bJcuQD97mWwlp61eVwR0AtOQ5+E0perIBMRERG1JRv3X7C5etubzw6Bn5czFwkgcmCWqwUwpq2B+fyRRsco/LpDG58IZVA/CIIgYzoiIiLqiNbsOou9x4slNXcXNd56NgE+Hk58fUJERERERLLIyL2CZVtOSWoCgGfH90VUqJ99QhEREbUAWRpw6urqMHPmTGRnZ0MUeWM0ERHdmTqDGYtSMnGlQi+p9wvxwUuJMf+9SYU/Z6j9EY11MBxeC9OJbYCt35W0rtAOSoI64j4IgkL+gERERETUqN1ZhVi7S9pArVIK+OuT8ejO1duIHJa1qhSGI+tgzt1n+3UeAMGzM7TxU6AKGcjXekRERNQith/Nx6b9FyQ1jUqBv80ajKBO7nx9QkREREREssgrqMC/1x9v8Nbo9BFhiI/oZJ9QRERELUSWBpyvvvoKJ0+erF+9LyQkBL169YKLiwsUCn6wSEREt2e2WPHxmmO4WFItqXfv7I4XJ/eDSsmfJ9T+iKII8/kjMOz7FmLNVZtjVGH3QJswDQpnD5nTEREREdHtZJ0pw7IfT0tq11dv68fV24gckrWuEsb0DTCd3A5YLTbHCK4+0MRNhDp8KASFUuaERERE1FEdOV2Cb3/KkdQEAfj9xH7o3d3bTqmIiIiIiMjRFJXV4MPUTBjN0gUAxg7pjhEDg+2UioiIqOXI0oCzZcsWAIAgCHj33XcxefJkOU5LREQdhFUU8eWmbGRfkDYodPJyxtykGDhpZPlxRtSirFWl0O9dDsvFTJvHFZ6doR32JFRdImVORkRERERNca6oEp+sOwbrTcu3TePqbUQOSTTWwpj5I4zHfgLMBptjBK0bNP3HQt3nIQgqjcwJiYiIqCPLuaTDZz+cxM377j35SARiw7g4ABERERERyeNqlQELvs9Ajd4sqd/brzOm3NfTTqmIiIhalix3LF+8eBGCIODBBx9k8w0RETXbqh1ncODkZUnN3UWNeY/GwNOVN6xQ+yJazTBmbYXxyHrAYmw4QKmCpv94aGLGQFCq5Q9IRERERLd1+WotFqVmwmiSrt42enA3jOTqbUQORTQbYTrxCwwZGwFDje1BaidookZBE/0IBI2zvAGJiIiowysorcZHq7Jgtkhfn0wcGoL7YrrYKRURERERETmaWr0ZC1MyUVYpXaCoX08fPDk6AoIg2CkZERFRy5KlAUepVAIA+vXrJ8fpiIioA/kp7RK2HLooqWnUCsxNikGAt4udUhHdGXNxDgy7l8F6tcDmcWXXvnAa+gQUngEyJyMiIiKipqqsMWLh95moqjVJ6gl9AzD1gVA7pSIiuYlWC4zZO2E8uh5izVXbgxQqqPs8CE3/8VA4e8gbkIiIiBxCeaUeC1IyUWuQri59X0wXTLi3h31CERERERGRwzGZrfh4TRbyS6sl9ZBAd7w4qR9USoWdkhEREbU8WRpwunfvjpMnT6KqqkqO0xERUQdxKPsyvvslV1JTCAJenBSFkEDeuELth6ivhuFgCkynd9k8Ljh7QnvPDKh6DuKKH0RERERtmN5oxqLUTJTo6iT1Pj288fSYSCj4uxxRhyeKVlSf3I/ynSthvlpke5AgQBU2FNq4iVC4+8kbkIiIiBxGrd6EhamZuFolXV06tpcfHh8VzveaiYiIiIhIFlZRxBcbT+LURZ2k3snbGXOSYuCkkeU2ZSIiItnI8pNt7NixOHHiBLZv344//vGPfLOPiIhuK/vCVSzZeLJB/anREYgO9bVDIqLmE0UR5pw9MBz4HqKh2sYIAeo+w6GNnwJB6yp7PiJq20RRxMaNG7F69WpkZ2ejtrYW/v7+iI+Px2OPPYbo6Oi7PkdOTg6WLl2KgwcPoqSkBO7u7ggNDcWkSZMwefLk+t1MmyMzMxPTpk1DYGAgtm/f3qTnFBQUYOnSpdi9ezcKCwvh7OyM7t27Y+zYsZg2bRqcnJyanYOIqKWZLVZ8uu4EzhdLF5jp1skNL02O4uptRB2cKIqw5B9D8fq1MF4+1+g4VY84aOKnQundRcZ0RERE5GhMZgs+Wn0MBaU1knpoFw88P7EvlAq+PiEiIiIiotYniiJW/pyLw6dKJHUPVw3mPxoLDxeNnZIRERG1HlkacKZPn45Vq1bh3Llz+Oc//4k//elPcpyWiIjaqYuXq/DxmiyYLaKkPuW+nhgaHWinVETNY7laAMOer2EpOm3zuMK3O5yGPQllp54yJyOi9kCv12POnDnYuXOnpF5QUICCggJs2LABc+fOxXPPPXfH50hNTcVbb70Fk8lUXysvL0d5eTnS0tKwdu1aLF68GF5eXk2es6amBn/7299gtVqb/Jxff/0V8+bNQ03NbzeMGI1GZGVlISsrC6tXr8ann36KoKCgJs9JRNTSRFHEsi2ncOxsmaTu5+mEeckxcNZy9TaijsxSnAtD2qpGX98BgLJrH2jjE/kaj4iIiFqd1Sriiw0nkXNJJ6kH+LjglcRoaNXNX1CFiIiIiIjoTvx48CJ+OZIvqTlplJiXFINOXs52SkVERNS6ZLk7wNnZGYsXL8Zzzz2Hr776Cunp6UhMTERkZCQ8PDyavKpyly5cNZCIqKO7UlGHhamZqDNYJPUHB3TF2CHd7ZSKqOlEswHGoxtgzPwREC0NB6idoI2fCnWf4RAU/CCUiGx77bXX6ptvQkNDkZycDD8/P5w4cQLfffcdamtr8cEHHyAgIAATJ05s9vy7d+/G66+/DlEU4ezsjGnTpqFfv34oKyvDqlWrkJOTg8OHD2P+/PlYsmQJFE1YNdVoNOLFF19ETk5Ok3OcPn0aL7/8MgwGA5RKJRITEzFw4EDU1NRg/fr1SE9PR05ODl588UV8//33cHbmm7REZB9rd5/D3mPFkpqbsxrzkmPg6aa1Uyoiam2W8kswHFoNy8WMRsco/EOgHZQEVdc+8gUjIiIihyWKIlb+kovDp0sldU9XDf6QHAN3ri5NREREREQy2XusCKt2npHUlAoBL02JQvfO7nZKRURE1PpkW56ze/fumDhxIj7++GNkZmYiMzOzWc8XBAEnT55spXRERNQWVNeZsDAlExXVRkk9Ltwfj40IhyAIdkpG1DTmi1nQ7/0GYlWpzeOqkIHQ3vMYFK7eMicjovZk79692LhxIwAgISEBn3/+ObTaazd3jxs3DomJiZgxYwZ0Oh3effddPPTQQ3Bzc2vy/EajEW+++SZEUYSLiwuWL1+Ovn371h+fPn065s+fj23btmHv3r3YvHkzxo0bd8s5y8rKMGfOHKSlpTXra33zzTfrm28+/fRT3H///fXHpk2bhrfffhvLly/H6dOn8fXXX+P5559v1vxERC1hR3oBNu47L6lpVArMSYxGoK+rfUIRUauyVpbAcHgtzHkHAIg2x6h9u0I5YApUPQbw/QoiIiKSzZbGVpdOjoEfV5cmIiIiIiKZHDtbhq9+PNWg/ruxkejbw8cOiYiIiORz+2WMW4DVasXs2bOxePHi+g8jRVFs9v+IiKjjMpos+GhVForKaiX1sCBPPDu+DxQK3sxCbZe15irqtn2Mui0LbDbfCO5+cH5kHpxHzmbzDRHd1pdffgkAUKlUePvtt+ubb64LDQ3F66+/DgDQ6XRITU1t1vw//fQT8vOv3ajxzDPPSJpvAECj0eC9996Dl5cXAOCzzz675Xz79+/HlClTmt18k56ejqNHjwIAJk2aJGm+Aa4twvDaa68hNDQUwLU/F5PJ1KxzEBHdraM5pVj+02lJTRCA5yf2RWhXTzulIqLWYq3VQb/na9R8/xeY8/bDVvON0sMP/uNeQuDvPoA6JI7NN0RERCSbfceLkGpjdenZU6LQLYCrSxMRERERkTzOFVXik7XHYbFK3z99dHgvJPTtbKdURERE8pFlB5zVq1dj+/btEAQBoihCo9EgMDAQ/v7+/ICSiIhgtYr47IcTyCuokNS7+LnilcRoaNRKOyUjujXRaoXp5C8wpK0GTPqGAwQlNDGjoRkwHoJK2/A4EdFNdDod9u3bBwAYNmwYgoODbY4bM2YM3n33XZSVlWHLli2YNWtWk8+xefNmANcaXKZPn25zjKurK6ZMmYIvv/wSOTk5OHfuHEJCQiRjysvL8frrr+Pnn3+ur02dOhV79uzB5cuXm5wDAGbMmGFzjEKhwIwZM/CPf/wDOp0OBw4cwLBhw247NxFRS8jN1+GzH07g5jVhHh/VG/3D/O0TiohahWiogTFzM4zHtgEWo80xgpM7NAMmIOCesVBptbBYrDKnJCIiIkd2/FwZlm62sbr0uEj04erSREREREQkk8vltViUmgmDySKpjxoUjFGDutkpFRERkbxkacBZu3Zt/eNZs2bhhRdegIeHhxynJiKiNk4URSzfloP03CuSure7FvOTY+DqpLZTMqJbs5SchX7PMlivXLB5XNk5HNqhT0Lp01XmZETUnh0+fBhW67WbORMSEhodp1AoEB8fjy1btiAzMxMVFRXw9GzaTgzXd6rp3bs3fHwav0EjISGhfjeeXbt2NWjAyc3NrW++cXV1xV/+8hckJSVh+PDhzcrh6emJPn363DLHdbt372YDDhHJovBKDT5alQWTWXqD/YR7e+CBWP5+R9RRiGYDjMe3wZixGTDW2h6kdrq2sEK/hyFonCGo+D4FERERyetCcRUW21hdOvnBXkjow9WliYiIiIhIHhU1RnzwfQaqak2SekKfACQ92MtOqYiIiOQnSwPO+fPnIQgCBg4ciD/96U9ynJKIiNqJjfvOY2d6gaTmrFVhXnIMfDyc7JSKqHGisRaGQ6thOrkdgNjguKB1gzbhUajCh3KnPyJqttzc3PrH4eHhtxzbq9e1NzFFUUROTg7i4+NvO//ly5dRWVkJAAgLC7vl2NDQ0PrHp041XGEVuNYINHHiRMybNw8BAQG3Pf91FosFZ86cqT+PQqFodGxISAiUSiUsFkujOYiIWtLVKgMWpmSgRm+W1IdFB2Li0JBGnkVE7YloMcN0eheMR9ZDrKuwPUipgrrvCGhix0Lh5C5vQCIiIqL/KtHVYWFKBgxG6erSD8cH45HBXF2aiIiIiIjkUWcwY1FKJq5U6CX1Pj288fTYSCh4fwwRETkQWRpwamuvrR4YFxcnx+mIiKid2J1ZiLW7z0lqKqWAV6ZGIcjfzU6piGwTRRHms4dg2Lei0Ru01L2HQTv4UQhO/PtLRHemoOC3ptSuXW+9w0Lnzr+tcFpQUNCkBpz8/Pwmzx8QEACFQgGr1YrCwsIGx3v06IGtW7eiW7fm3+xx5coVGI3GJuVQKpXw9/dHcXGxzRxERC2pVm/GwpRMlFUaJPXoUF888UhvNlgTtXOiaIU57wAMh9dCrCq1PUhQQN17GDQDJkLh1vhugUREREStrbLWiAXfZ6DyptWlB0V2QvJwri5NRERERETyMFus+GTtMVy4XCWpdwtww0uTo6BSNr7YIhERUUckSwNOQEAALl68CLPZfPvBRETkEDLzrmDZltOSmgDg2fF90bubt31CETXCWnEZ+r3fwJJ/3OZxhXcXaIc+CVVgb5mTEVFHU15eXv/Y2/vWPw+9vLzqH+t0uibNf/Xq1SbPr1ar4eLigurqapvzN2fHm5s15+sEAE9PTxQXFzf56yQiuhMmsxWL1x5Dfmm1pB4S6IEXJvaD8ha7dRFR2yaKIiwXM2FIWwVreX6j41Q9B0E7cAoUXp0bHUNEREQkB4PRgg9TM1FytU5Sj+jmhd+N7cPVpYmIiIiISBZWUcSXm7Nx4vxVSd3P0wnzkmLgrJXlFmQiIqI2RZaffvfccw8uXLiA/fv3y3E6IiJq484WVuLT9cdhFUVJfdqIMMRHdLJTKqKGRIsJxswfYUz/AbDYaCRWaqCJmwBN1CMQlHxTgYjunl7/25bdWq32lmM1Go3N591KXd1vN23cbv7rY6qrq5s8f1PdSQ6g6V9na/HwcGrxORUKof6/Pj6uLT4/tS283m2X1Spi4XfpyL4g/QCpi58r3nw2AZ5ut/+36ma83o6D17pt0188Cd2vK2AoON3oGKeesfC6bzq0nXvedj5eb8fC601ERPZgtljx6frjOFckXV06yN8Ns6dEQ63i4gBERERERCSPVTvO4MCJy5Kam7Maf3g09o4+OyEiIuoIZLlTdObMmVi1ahVOnjyJtWvXYvLkyXKcloiI2qDi8losSs2E0WSV1EcP7oaRA4PtlIqoIXNhNgy7l8FaUWzzuDI4Gk73Pg6Fh7/MyYioI7tx19AbG2xsufF4U3cbtVgsTZ7/xjEtvZtpW8nRXMpW3D5dEAQolVy91lHwerc9X206jt0ZBZKal5sWbz03BD6eznc1N6+34+C1blsMxedQvvNb1J1Jb3SMtmtv+Dz4GJy79232/LzejoXXm4iI5CKKIr7eehpZZ8okdV8PLeYlx8DFiQtBERERERGRPH46dBFbDl2U1DRqBeYlxyDAx8VOqYiIiOxPlnfoQkND8ec//xn/+Mc/8PrrryM3NxdPPvkkAgIC5Dg9ERG1ERXVBiz4PgPVdSZJfUjfAEx9INROqYikrHWVMBz4DubcfTaPCy5e0N7zGFQhAyEIvPmGiFqWk9NvO6yYTKZbNqcYjcb6x01pYgGku82YTKZbjJSeQ61WN2n+pmorOZrLYrHeflAzKRQCBEGAKIqwWsXbP4HaNV7vtumHXWew7tczkpqTRom/PT0I/l7Od/y9z+vtOHit2xZTeRF0u79Dbbbt13QAoPYPhtd90+Hc69rruuZ8n/N6OxZ7Xu/WbP4mIqK2a+3uc9iTVSSpuTqpMC85Ft7uXF2aiIiIiIjkcfDkZXy3PU9SUwgCXpwUhZBADzulIiIiahtkacBZunQpACA2NhYZGRlYunQpli5dCn9/fwQEBMDJyem2N7AKgoBly5bJEZeIiFpBncGMRalZuFKhl9T7hvhg1phIKNjIQHYmilaYTu2C4VAqYKhpOEAQoO47EtqBkyFo7m4VdCKixri4/LZSkMFgaHIDzo0NLc2Z/3auj7mxMagluLq6tokczVVZqYfZbLn9wGbw8XGFUinAahVRXm7j5w91KLzebc+h7Mv4cuNJSU2pEPDi5H7wcVHf1XXi9XYcvNZtg7XmKoxH1sN0ehcg2m6oEdz9oR04GarQBOgVCuiv1jb7PLzejsVe11ulUsLbm6uIEhE5mh3pBdi477ykplYpMCcxBl38XG0/iYiIiIiIqIWdPF+OJTd9dgIAs8ZEIDrU1w6JiIiI2hZZGnDee++9+gab6/8VRRGlpaUoLS297fNFUeQK80RE7ZjZYsUna4/hwuUqSb17gDtenNQPKq7oSXZmKbsE/Z5lsF7Os3lc4R8Cp2FPQenXXeZkRORoPDx+Wy1Ip9PB3d290bE6na7+sY+PT7Pnr6iouOVYk8mE2traZs3fVDd+XbfLceOYls5BRI4t+8JVmx8gPTU6Av1C+AESUXsh6qthyNgI04lfAIvtnfUEZw9oBkyAOuIBCEpZ3hInIiIiapajOaVY/tNpSU0QgN9P6IteQZ52SkVERERERI7mQnEVPl5zDJabdoOeen9P3BsVaKdUREREbYtsnzaKotikGhERdSxWUcTSzdk4cf6qpO7n6YS5SdFw1vLGF7If0WSA4chamI79ZHuFZI0ztIOSrt2kpWCjGBG1vh49etQ/LioqQnBwcKNji4uL6x936dLljua/lcuXL8NqtTZr/qbq1KkTXF1dUVNTg8LCwluOtVgs9Qs3tHQOInJc+SXV+HhNFswWfoBE1F6JJj2Mx36CMfNHwFRne5DGGZqYsdD0GwlB3bQdA4mIiIjklpuvw2c/nMDNH50//nBv9A/3t08oIiJqU0STAeazh1BeVQBtp2C4RD9k70hERNQBlerqsDA1E3qjRVJ/KC4IYxK4YC0REdF1stz1/Msvv8hxGiIiaoNW7zyD/ScuS2puzmr84dFYeLrx5heyH/P5dOj3LYdYXWbzuCo0Adoh06Bw8ZI3GBE5tNDQ0PrHubm5GDRoUKNjc3NzAVzbZTQsLKxJ83t7e8PX1xdlZWX1z29MXt5vu4KFh4c3af7mCA0NRVZWFs6cOXPLcWfPnoXFYmm1HETkeMoq9FiQkoE6g/QDpOEDuvIDJKJ2QLSYYMreCWP6Boh1lbYHKTXQ9BsBTcwYCE5u8gYkIiIiaobCKzX4aFUWTGbpAlHj7+mBB/p3tVMqIiJqKyxXLsB06leYcvcDpjroAVQB8DYagV4P2jseERF1IJW1Riz4PgOVNUZJfWBEJ0x/KAyCINgpGRERUdsjSwNO1658c5CIyBFtO3wJPx68KKlp1ArMTYpBgI+LnVKRo7NWl8GwdznMF9JtHhc8AuA09HGogvrJnIyICOjfvz/UajVMJhMOHjyIxx57zOY4i8WCtLQ0AEBERAQ8PDyafI74+Hhs2bIF2dnZqKqqgru7u81xBw4cqH98q0agOxUfH4+srKz6ZqDGmohuzBEfH9/iOYjIsVTXmbAgJQO6aukHSHHh/pgxIpwfIBG1YaLVCnPePhgOr210IQUISqgj74em/3goXL3lDUhERETUTFerDFiYkoEavVlSHxYdiEnDQuyUioiI7E001sF05iBMp36FtfSczTGGgtNQsgGHiIhaiMFowYepWbh8VbrTeO9gLzw7LhIKBT87ISIiupHC3gGIiKhjOpR9Gd/9LF1ZXyEIeHFSP/Ts0vSbhIlaimg1w5j1I2pS/mq7+UahgmbARLgm/oPNN0RkNx4eHkhISAAAbN++HYWFhTbHbdq0CeXl5QCA0aNHN+sco0aNAgCYzWasXLnS5pjq6mqsXbsWABASEoKIiIhmnaM5OQDgm2++sTnGYrFgxYoVAAB3d3cMHTq0xXMQkeMwmiz41+osFJXVSuphQZ54dnwffoBE1EaJogjT+SOoXf036HcuaaT5RoCqVwJcH/0/OA19gs03RERE1ObV6s1YmJKJskqDpB4d6osnHunNxQGIiByMKIqwlJyFftdSVH87D4bdXzXafAMIcIkYIms+IiLquMwWKz5dfxzniqS7jQf5u+LlqVFQq5R2SkZERNR2ybIDDhEROZZTF65iycaTEG+qPzm6N6JD/eySiRyb5XIe9LuXwVp+yeZxZZfIazdpeQXKnIyIqKGnnnoKu3fvhslkwvz587FkyRK4ubnVH8/Ly8M777wDAHB1dUVSUlKz5h8xYgSCgoKQn5+PxYsXY8CAARg4cGD9caPRiFdffRU6nQ4AMGvWrLv/omyIiYlB//79kZ6ejtTUVAwZMkTSTCSKIt5++22cPXsWADBjxgw4OTm1ShYi6visVhFfbDiJ3PwKST3Q1wUvT42GRs0PkIjaInNhNgyHUmEtOdvoGGW3GGjjp0Lp203GZERERER3zmS24uM1WcgvrZbUQwI98MLEflAquIYmEZGjEI21MOUdgCl7J6xlF28zWoBTz1h4D5kITXBfGMprZMlIREQdlyiKWLblFLLOSBc98vXQYl5yLFyc1HZKRkRE1La1aAPOunXr6h9PmjTJZv1u3DgnERG1Tfkl1fjXmmMwW6TtN5OHhWBYdBc7pSJHJRpqYDiYCtOpnTaPC84e0CZMg6rXEK4oSERtxtChQzFq1Chs3boV6enpmDhxIqZPn47AwECcPHkSK1euRE3NtQ/WXn31Vfj4+Eief/DgQTzxxBMAgEGDBjXYXUaj0eC1117Diy++CL1ej6eeegpJSUkYMGAAdDodUlJSkJOTAwAYMGAAEhMTW+1rff311/Hoo4/CZDJh3rx52L59O4YOHQq9Xo9169bh6NGjAIAePXrg+eefb7UcRNSxiaKIFT/n4EhOqaTu5abB/ORYuDnzAySitsZSeg6GQ6tgKTjR6Bhl53BoBiVC1TlcxmREREREd8cqiliy8SROXdRJ6gHezpiTFA2thosDEBF1dKIowlpyBsbsX2E+exAwG285XnD1hrr3fVD3Hga/7t2hVCpgsVhlSktERB3Zml1nsfdYsaTm6qTCvORYeLtr7ZSKiIio7WvRBpw///nPEAQBgiBImmWu1+/GzXMSEVHbU1ahx4KUDNQZzJL6A/27Ytw9PewTihySKIow5+2HYf9KiPoqm2PUkQ9AOygJgtZV5nRERLf33nvvoaamBnv27EF+fj7ef/99yXFBEDB79mxMmzbtjuYfPnw43njjDbzzzjswmUxYsWIFVqxYIRkTFRWFTz75BEpl69340bdvXyxatAh//OMfUVtbix9++AE//PCDZEz37t2xZMkSuLry32siujObD1zA9qMFkpqzVon5ybHw9eTOWkRtiUVXCGPaGpjPHW50jMI3GNr4JCiDo7iQAhEREbUroiji+1/ykHaqRFL3cNVg/qOx8HDR2CkZERHJQTTUwJS7D6bsX2G9mn/rwYIAZXAMNJEPXHv9q2CDJhERtaxfjuRj0/4LkppGpcceHqEAAQAASURBVMCcpBh08ePnskRERLfSog04wLU3DptTJyKijqG6zoQFKRnQVUtX6Okf5oeZI8N5UwzJxqorgn7P17AUZts8rvAJhtOwJ6EM6CVzMiKipnN2dsaSJUuwYcMGrFu3DtnZ2aiqqoKXlxfi4uLwxBNPIC4u7q7OMX36dAwcOBDLli3Dvn37UFpaCrVajfDwcIwfPx7JyclQq1t/V4gRI0Zg06ZNWLp0KXbt2oXi4mIIgoCQkBCMGjUKjz/+OJtviOiO7T1WhNW/npXUVEoBs6dEI6iTm51SEdHNrNVlMB5ZB1POHqCR95EFjwBoB06GKnQQBEEhc0IiIiKiu7f10CVsO3xJUtNqlJiXFAN/L2c7pSIiotYkiiIsxTkwnfoV5rNpgMV0y/GCmy/UEfdBHT4MCjcfmVISEZGjOXyqBCu25UhqggD8fmI/9OrqaadURERE7UeLNuDMnj27WXUiIuoYjCYLPlqdhaKyWkm9V5Annp/QFwoFm2+o9YlmI4wZm2DM2ARYzQ0HqLTQDpwEdb+HuUoUEbULgiBgwoQJmDBhQrOeN3jwYJw+fbpJY8PCwvD222/fSbxGbd++vdnP6dKlC1577TW89tprLZqFiBzb8bNl+OrHUw3qz4zrg8ju3nZIREQ3s9ZVwpi+EaaT222/jgMguHhBEzcJ6t5DIShafD0pIiIiIlnsP1GMlB15kppSIWD25Ch07+xup1RERNRarPoqmHP2wnTqV1h1RbceLCig6t4f6sj7oezaD4KCi04QEVHrOX3xKj7fcAI3L4P05CMRiA3zs0smIiKi9oYNOEREdFesVhGf/XACefkVknqgrwtemRoNjZqNDtT6zPnHod/zDcTKyzaPq3oMgPaex6Bw85U5GRERERHZw/niSixeexwWq/QjpGkPhWFQZICdUhHRdaKxDsasLTAe2wqY9LYHaV2hjR0Ldd8REFQaeQMSERERtaAT58vx5aaGO7Y/PSYSfUO4uwERUUchiiIsRadgyt4J87kjjS40cZ3g7g91xP1Q9x4KhYuXPCGJiMih5ZdU46PVx2C2SD87mTQ0BPfFdLFTKiIiovaHSwYSEdEdE0UR327LQXruFUndy02D+cmxcHNW2ykZOQpL9VXU/fIlzGcO2DwuuPnC6Z6ZUPXoL3MyIiIiIrKXEl0dFqVkwmCySOqjBgXj4fhgO6UiIuDazqWmkztgzNgIUV9le5BKA03UKGiiH4GgdZU3IBEREVELu1BchY/XHGuwOEDSA6EY0q+znVIREVFLstZVwnR6D0ynf4VYYXuxwHoKJVQ9BkAd8QCUXSMhCNzthoiI5FFWoceClAzUGaQNog/EdsH4e3vYJxQREVE7JUsDzl/+8hcAwNixYzF06NBmPXf9+vVYunQpRFHE+vXrWyMeERHdoU37L2BHeoGk5qxVYn5yLHw9neyUihyBaLWgIv0nlO9cDtFQ13CAoIA6ahS0cZMgqLXyByQiIiIiu6isNWLB9xmorDVJ6oP7BCDpwV52SkVEotUCU84eGI+sh1hTbnuQQgl15IPQ9B8PhYunvAGJiIiIWkGprg4LUzNhMEoXBxgRF4RHBnezUyoiImoJomiFpeDktd1uLqQDVsstxwueAdBE3A9V+FAonD1kSklERHRNdZ0JC1IyoKs2Sur9w/ww8+HeEATBTsmIiIjaJ1kacNauXQtBEBAeHt7sBpzLly/j1KlTcHZ2bqV0RER0J/ZkFWHNrrOSmkop4OUp0Qjq5Pb/s/ff8VGdZ/74/Tln5syoV4QA0YQ6RaIJBBIG94ZpBmxsxyWbOBuvHRvye/Lb1/J44zybeL/+xnHbOIkdrx3HjrEpBhuMMW4UiSaahEDSiI5EV68zp9zPHwoyB400AsSMpPm8/8nkOtc5c5EJSHPOfV+Xj6oif6BfPI6zaz+A68wRt8fl2EQETHsMlih2NyciIiLyJ06XjtdXFOJ8tXmDdtqwSPz4njTIfIBE5HVCCGjHdsOVvwpG7dkOsiRYk6bCPmEO5LAYr9ZHREREdKPUN7nwyvIC1DWaF7hNTO2PB29L4gI3IqJeymiqgVq6FWrJFoj6C50ny1ZY4ydCSZsOy8BU/ttPREQ+4VJ1vLGyEGcqm0zxxMHh+NmsUZBl/nwiIiK6Wl7ZgHM9Dh8+DKD1YS0REfUMhUcq8bcvS0wxCcBPZo5E6rBI3xRFfZ5wNcO5ezXUg18D7n4vsAfDPnkhlJRpHNdORERE5Gd0w8CfPyvCsTN1pviQ/iF4et4YKFb+fkjkTUII6BUH4dy1EsbF4x3mWYePh23i/bBExXmvOCIiIqIbzPnPBW7nqswL3FKGROCnM9kcgIiotxGGAb28CGrJJmgn9gPC6DRfjhgEJXU6rMlTIQeEeqdIIiIiN3TDwF8+O4jDFbWm+MDoIPzi/nTYFIuPKiMiIurdum0DjqZp+O///m80NTV1mLN+/Xo4HI4uXc8wDFRUVGDPnj2QJAmxsbHdVSoREV2HY2fq8Kc1B2BcsQHiwVuTMCmN/1ZT97vUMdm5/SOIxmq3OdakbNizHuDIdiIiIiI/JITA3zeUovBIpSkeHRaA5xZkINDe4/vPEPUp+vkjcO5aCf10cYc5loGpsE+aD0tsohcrIyIiIrrxdMPAX9YU4chpc3OAwTHBeOb+MVCsXOBGRNRbGA1VrdNuSrdANFR2nmxRYB0xqXXaTSwnnRERke8JIfDhRgf2H75oikeG2rFk4ViEBCo+qoyIiKj367YVCFarFYMGDcLvf/97t18khRAoKipCUVHRVV1XCAFJknDPPfd0V6lERHSNzlU34bUVBXCp5q4+d00eitszh/ioKurLjLoLaMn7APqpQrfHrVGDoEz9EayD0rxcGRERERH1FJ/lHsPWwjOmWHCAFUseyEBkqN1HVRH5H72qAq78ldBO7OswR+43vHXjTdwoLkYiIiKiPkcIgQ++KkXBFc0BosLsWLxwLIICuMCNiKinE4YO/VQhXMWbWp9PXtGU8kpy1GAoqTOgJE2BZA/2UpVERESefZ53HJv3nzbFAu1WLF6YgejwAB9VRUREfYXQNTQf2QujsRr2+HEA/Ou5fLe2AH388cfx+eefo7S01O1x4eGLqTuXNt889dRT11seERFdh9pGF175ZD/qm1RTPGtULObPSPBRVdRXCV2D68AGuPZ8Duiudsclq4KI7PkIzbwP1XXtjxMRERGRf9i0vwKf5x03xRSrjGfnZ2BgNBc9EHmDUX8Bzt1roJVtA+D+/q8cPgC2zPthjZ/IjTdERETUZ32WewxbCto3B1i8cCybAxAR9XBG/UWopVuglmyBaKrpPNlqg5IwGUrqdMj9E/g9l4iIepxN+yvwWe4xU8xqkfGL+8dgcEyIj6oiIqLeTggBo/IEVEcetMM70NBSDwCQ7cEIXPA7yEERvi3Qi7p1A47FYsHbb7+NEydOtMWEEHjssccgSRIefPBB3H333R6vI0kSZFlGSEgI4uLiEBLCH/pERL7U4tLw2ooCXKhpMcVHDo/Ej+9Jg8ybitSNtDOlcOa+D6P6tNvjlsGjEXvvzxDQbxB03QDADThERERE/mh/2UV88JW5CYwkAT+bNQqJg8N9VBWR/zCaauHa9znU4k2AobvNkYKjYJswG0pyDiTZ4t0CiYiIiLyoo+YAz9yfjrh+bA5ARNQTCUODdmI/1JLN0E8VoaOmEpfI0cOgpE2HkpgFyRbknSKJiIiu0j7HhfbPTgD8bNZIpAyN9E1RRETUqxlNNdDKtkN15MGoLm9/3NkIvfwg5ORsH1TnG926AQcAYmNjERsb6/bY0KFDMWnSpO5+SyIiuoE03cCfVhfhxNl6U3xo/xD829wxsFpkH1VGfY3RUg/njuXQHFvdHpcCw2Gf+jCsIzKhRHJzLhEREZE/O1JRi798VoQrhy0/ckcKxifH+KYoIj8hXE1wFXwJ14GNgOZ0myMFhMI2diaUkTdDstq8XCERERGRd+0rc7PATQKevG8UkodE+KYoIiLqkFF3HmrJFqilWyCa6zpPVgKgJGRBSZsBS8xwr9RHRER0rQ6X1+Ivnx9s9+zk4TuSMSGlv2+KIiKiXklortaGBY5c6OUH0O6Hy+UkGXJMvPeK6wG6fQOOO//93/8NABgzZow33o6IiLqJEAJ/+7IERceqTPF+4QFYvDADgXav/BihPk4IAc2RC+eOTyCcDW4yJCijboE98352kyIiIiIinKlsxOsrC+HSDFN85tRhuHlcnI+qIur7hOaCevAbOPd/ATgb3ScpAbCNuRO29Lsg2QK9WyARERGRDxyuqMVbn7Vf4PbI7cmYkMLmAEREPYXQNWjH97ZOu6k46DFfjomHkjYDSsJkSEqAFyokIiK6PqcvNuL1lQVQ3Tw7uWX8YB9VRUREvYkQAsb5I1AduVCP7AJcTR7PsQ9ORcRNi9AUMsgLFfYcXlk5PXfuXG+8DRERdbNVm49iW9FZUywkUMGSB8YiPMTuo6qoL9GrKuDMfR/6WYfb43K/YQiY9jgsfrZDmoiIiIjcq2lw4tXlBWhoVk3x7DEDMHfaCB9VRdS3CUODWrIVrr2fQTTVuE+SrVBG3Qrb2HshB4Z5tT4iIiIiXzlT2YjXVxS0aw5w75RhuJkL3IiIegSj5ixcJZuhOXIhWuo7T1YCoSRNgZI6HZZ+w7xTIBERUTeornfileX70diimeI56QP57ISIiDwyGiqhOvKglm2DqD3rMV8KiYaSnI1+mbchoF8cdN1AU1UHzfv6KI4uICIit77dU471O06YYjarjGcXpGNAFKeQ0PURmhOuvWvhKvgSEHr7BCUA9sz7oYy8FZIse79AIiIiIupxmp0aXltegIu1Lab4mBHReOyuVEiS5KPKiPomIQxoR3bBuXs1RN0590mSBCU5B7YJcyCHRHu3QCIiIiIfqq534pVPCtotcMseMwDzbuICNyIiXxKaC9rxPVCLN0M/U+IxX45NhC11OqwjJkFS2ISSiIh6l6YWFa8s34+qOqcpnp4QjcfuSuGzEyIickuoTmjHdkMty4NeUQxAdH6C1Q7riIlQknNgGZgCSZKhRAZ7pdaeiBtwiIiond0l5/HR1+aJJLIk4V/njEbCoHAfVUV9hXayAC15H0DUX3R73DoiE/YpD0EOjvRyZURERETUU2m6gTdXH8DJ8w2m+PABofj5nFGwWrhpm6i7CCGgnyqEM38VjMqTHeZZ4yfCljkPlgj/GilPRERE1NSi4bUVBaisY3MAIqKeRK+ugFq8GWpZHuD00H3ZHgwlaWrrtJsoTi0jIqLeSdV0vLHqACoumH/ujRgUhp/PHg0LG94SEdFlhDCgnymF6siDdmw3oLZ4PMcyKA1Kcg6s8RMgKQFeqLJ34AYcIiIyKT1ZjbfXHmq3n/XRu1IwNrGfT2qivsFoqIJz+0etv7y5IYXGICD7R7AOTfdyZURERETUkxlC4N31xTh0vNoU7x8RiOcWZCDAxttbRN1FO1sG164V0M86OsyxxI2CfdJ8WGLivVgZERERUc+gaq3NAU6xOQARUY8gNBe0o/lQizdBP1fmMd8yMAVK6nRY4ydCstq8UCEREdGNYRgCf117CI5TNaZ4bFQQnp2fDrvN4pvCiIioxzHqzkN15EEty+uwafrlpLBYKMnZUJKmQg7lmmF3uEKBiIjalF9owBurDkDTDVN8Tk48bspgR1u6NsLQoR78Fs7dn7rfNS1bYEu/G7bx90Gycqw7EREREZmt2nQEOw6eM8VCgxQsfiADYcFcKEHUHfTKU3Dmr4R+sqDDHDlmBOyT5sMaN9KLlRERERH1HJeaAxSfuKI5QCSbAxAReZtedQpq8SaoZdsBV1OnuZI9BNbkbChp0znFlYiI+gQhBD76xoHdpRdM8fBgG5YszEBoEJ+dEBH5O+Fqgno0H5ojr9PGe22UQCgJk6EkZ0OOTeSEZw94F5CIiAAAVXUteHV5AZqdmik+fewg3Jc93DdFUa+nnz+Klq3vw6g84fa4ZWAK7DmPwhIZ5+XKiIiIiKg3+Hr3KXy586QpZlNkPLcgA7GRQT6qiqjvMOrOw7n7U2iHdwLtZuG2kiMHwZZ5P6zDxvNmOxEREfm1Fd8fxs5D5uYAYUEKlixkcwAiIm8QqhPakZ1wlWyCcf6ox3zLoLR/TruZAMmieKFCIiIi71i/4wS+21thigXYLFi8MAMxEYE+qoqIiHxNGAb004egOnKhHdsD6GrnJ0gSLINHQ0nKhnX4eE4JvQrcgENERGhsUfHK8gJU1ztN8bGJ/fDIHclcYENXTbia4Ny1Cuqh7+BuEZdkD4F9yoOwJmXz/19ERERE5FZ+yXl8/E2ZKSZLEp6aMwbxA8N8VBVR32A01cC193OoxZsBobvNkUKiYZ84D9bEKZBk2csVEhEREfUsG3edxFe7TplidsWCZxdkoD+bAxAR3VD6xeNQizdDPbwdUFs6zZUCw6Ak50BJnQ45PNZLFRIREXlPbuEZrNps3ohqkSU8M28MhsaG+qgqIiLyJb36NDRHLtTD2yEaqz3my5FxUJKzYU2cAjk40gsV9j3cgENE5OdUTcf/rCzE6YuNpnhCXBh+NnsULFxkQ1dBCAHtyE44ty+DaK51m6Ok3AT75IWQAkK8XB0RERER9RalJ6vx17UH223lfvzuVKQnRPukJqK+QDgb4dr/BVxF3wC6y22OFBgG27j7oKTNYIdgIiIiIgA7D53Dx98dNsUssoR/mzuazQGIiG4Q4WqGemQn1OJNMC4e95hvGTy6ddrNsHGQLFwKRV0nhMC6deuwatUqFBcXo6mpCTExMcjMzMTDDz+M9PT0634Ph8OB9957Dzt37sT58+cRGhqKhIQEzJkzB3PnzoXFYrmm6/7mN7/BRx99BAAoLS297jqJqOcrPHIRf/uypF38p/eNRNrwKB9UREREviJaGlq/MzlyYVw45jFfsofAmjgZSnIO5H7D2TT9OvFbJxGRHzMMgbc/PwRHuXmjxMDoIDw7PwN25dpu9JB/MmrPoSXvA+jlRW6Py5FxsE97DNYByV6ujIiIiIh6k/ILDXhj1QFounn7zdybRiAnfaCPqiLq3YTqhKvoa7gK1gOuJvdJSiBsGXfDNuYOSEqAdwskIiIi6qGKj1fhnXWH2sUfvzsVo0ewOQARUXcSQsC4cAxqySaoh3cCmrPTfCkoAkrKNCgpN0EOi/FSldSXtLS04Nlnn8WmTZtM8YqKClRUVGDt2rV47rnn8OSTT17ze6xYsQK/+c1voKpqW6yqqgpVVVXIz8/H6tWr8eabbyIiIuKqrrtjxw4sW7bsmusiot7n6Ok6/GlNEQxhfnby4K1JmJTGqW9ERP5AGBr0UwegOvKgndgPGFrnJ0gWWIemw5qcA+vQDDYr6Eb8X5KIyE8JIfDRNw7scVwwxcNDbFi8MAMhgexyS10jdBWugvVw7VsL6G5+qbPYYJswG7Yxd/KXOCIiIiLqVFVdC15dXoBmp/n3yhnj4jBzyjAfVUXUewldg1qyCa69n0M017lPsihQRt0G+9h7OamUiIiI6DInz9Xjfz49AN0wL3C7f/oIZI9hcwAiou4inI1QD2+HWrIZRuUpD9kSLEPGQEmb0bqATGZDSbp2S5cubdt8k5CQgIULF6Jfv344ePAgPv74YzQ1NeEPf/gDYmNjMXv27Ku+/tatW/H8889DCIHAwEA8+OCDGD16NCorK7Fy5Uo4HA7s3r0bS5YswTvvvANZlrt03cbGRixduhRCXDk/nIj6qrNVTXhtRQFcqmGK3zV5KO7IHOKjqoiIyFv0ypNQS3OhHdnR8fO+y8jRw6AkZ8OamAU5kNObbwSugiUi8lPrd5zAd3srTLFAuwWLF2SgX3igj6qi3karOISW3L9D1J51e9wyNAMB2Y9ADmXXKSIiIiLqXGOLileXF6C63tzddFxSPzxyezLHYBNdBWEY0I7sgHP3aoj6C+6TJBlKyk2wTZgNOTjSuwUSERER9XAXa5rx6ooCtLh0U/zW8YNxTxabAxARXS8hBIxzh+Eq2QztyC5Ad3WaLwVHtU67Sb0JcggnkNH1y8vLw7p16wAAWVlZePvtt2G32wEAM2fOxPz58/HQQw+hpqYGL774Im699VaEhHS9cYnL5cILL7wAIQSCgoLw4YcfYtSoUW3HFy1ahCVLluDrr79GXl4e1q9fj5kzZ3bp2i+//DLKy8uv4k9LRL1ZbYMTr3yyHw3Nqik+ZVQs5s9I8FFVRER0oxlNtdAO74BaltuFRgWAFBgGa9JUKMnZsERxc+aNxg04RER+KO/AGazafNQUs8gSnp47BkNjQ31UFfUmRnMdnNuXQTu83e1xKTgS9qmPwDp8PBdKEhEREZFHqqbjf1YdQMXFRlM8MS4cP5s1CrLM3ymJukIIAf3kfjh3rYJR3fFCDGvCZNgnzoUcPsCL1RERERH1Dg3NKl5ZXoDaBvNi8IkpMVh0WxLveRMRXQfR0gC1bFvrtJvqis6TJRnWoRlQ0qbDMjgdUhengxB1xbvvvgsAsFqt+O1vf9u2+eaShIQEPP/88/jlL3+JmpoarFixAk888USXr79x48a2TTI/+clPTJtvAMBms+Gll15Cfn4+ampq8NZbb3VpA86OHTuwbNkyAEBoaCjq6+u7XBMR9T7NTg2vLi/AxdoWU3xUfBSeuCcNMr+bEBH1KUJXoZ3YD9WRC/3UAUAYnZ8gW2EdPg5Kcg4sg0dzQqgXcQMOEZGfOXC0Eu+tL2kX/8nMkUgbHuWDiqg3EcKAWrIFzp3LAVdT+wRJgjL6DtgnzIFk4yQlIiIiIvLMMAT+uvYQHKdqTPGB0UH4xfx02BTeKCTqCu10CZz5K2GcO9xhjmVIOuyZ98PSj13biYiIiNxxqjpeX1mAs1Xm+9/Jg8Px0/tGsjkAEdE1EEJAP+uAWrwJ2rF8QNc6zZdCoqGkToeSMo0TW+mGqKmpwbZt2wAA06ZNw5Ah7juE33PPPXjxxRdRWVmJDRs2XNUGnPXr1wMAJEnCokWL3OYEBwdj3rx5ePfdd+FwOHDs2DHEx8d3eM3GxkYsXboUQgjMnj0bZ86cwa5du7pcExH1Lqpm4I+fHsDJ8w2m+LABoXhqzmhYLdyYSkTUFwghYFw4BtWRC/XITsDZ6PEcuX8ClORsKAmTIdmDvVAlXYkbcIiI/MixM3X40+oiGEKY4g/ekojJI2N9VBX1FnrlKbTkvt/hYi45ZgQCpj3GhVxERERE1GVCCCz7tgy7Sy+Y4uEhNixemIGQQMVHlRH1HvrF43DuWgm9vKjDHDk2EfZJC2AdmOLFyoiIiIh6F90w8NZnB3Gkos4Uj+sXjGfmp0OxsjkAEdHVMFrqoTlyoRZvhlF7tvNkyQLrsLFQ0mbAEjeK027ohtq9ezcMo7WbeFZWVod5siwjMzMTGzZsQEFBAWpraxEeHt6l98jPzwcApKSkICqq40aoWVlZbdN4tmzZ0ukGnJdffhnl5eWIiYnBf/zHf+CZZ57pUi1E1PsYQuB/vziE4hPVpnj/iEA8tyADgXYu+yUi6u2MxmqoZXnQHHkwas54zJeCo6AkTYWSnA05YqAXKqTO8CcxEZGfOF/dhNdXFMCp6qb4nZOG4I5JQ31UFfUGQm2Bc88aqAc2uh9raAuEfdICKKkzeDOciIiIiK7Khp0n8e2eclMswGbB4gUZ6BfOiYpEnTFqzsK5+1NoRzvudCpHDYY9cz4sQzMgSezWTkRERNQRIQQ+3OjA/sMXTfHIUDsWL8xAcACbAxARdYUQBvTTJa3Tbo7vBQwP027C+kNJvQlKcg7koAjvFEl+r6ysrO11cnJyp7mJiYkAWn9XcDgcyMzM9Hj9c+fOoa6udUNvUlJSp7kJCQltr0tKSjrM27FjB5YtWwYA+PWvf42IiAiPdRBR77X8u8PYVXzeFAsNUrDkgQyEB9t8VBUREV0voTmhHd8L1ZEHvfwgANH5CRYbrPEToCTnwDIojWszexBuwCEi8gN1jS688kkB6ppUU3zyyFgsuDnRR1VRb6Ae3wtn3ocQjVVuj1sTs2DPepA3xImIiIjoqm0vOosVm46YYhZZwjPzxmBobKiPqiLq+YyGKrj2roFamuu+SQIAKTQG9olzYU3MgiTxZjwRERGRJ2vzjmPz/tOmWJDdisULMxAVFuCjqoiIeg+jqRaqIxdqyWaIuvOdJ8sWWIdPaJ12MyiV31vJ6yoqKtpex8XFdZo7YMAA03ld2YBTXv5DwyFP14+NjYUsyzAMA6dPn3ab09jYiKVLl0IIgbvvvhu33367xxqIqPfasPMkNuafMsXsigXPLchA/8ggH1VFRETXSggB/awDmiMP6tFdgNri8RzLwBQoyTmwxk+EZGPTyp6IG3CIiPq4FpeG11YU4HxNsymeNiwSP74nDTI74JIbRv1FOLf9A9qJfW6PS+GxCMh+FNbBo7xcGRERERH1BQePVeHd9cXt4v8yMw1pw6N8UBFRzydaGuDcvw7qwW8A3X0HYSkwHLYJs6Gk3ATJwlu/RERERF2xpeA01uQeM8WsFhnP3D8Gg2NCfFQVEVHPJ4QBveLQP6fd7AOE3mm+FD4AttTpsCZnQw4M81KVRO1VVf3QfDIyMrLT3MsnzdTU1HTp+tXV1V2+vqIoCAoKQkNDQ4fXf/nll1FeXo7IyEj853/+Z5dqIKLeafvBs1j+/WFTzCJL+Le5oxE/kD87iYh6E6PuAtSyPKiOPIj6Cx7zpdAYKMnZUJKyIYfFeKFCuh58CktE1IdpuoE/rSnC8bP1pviQ/iF4et4YKFZ2EyIzYWhQD3wN557VgOZqnyBbYRt7L2xj74Vk5VhbIiIiIrp6J87W44+rD0A3zCO1F96ciKyRAzo4i8h/CbUFrgNfwVWwAVCb3SfZgmAbew9so26HpNi9WyARERFRL7b/8EX8fUOpKSYBePK+kUgZ2vmCWSIif2U0VkMt3Qq1dAtE/cXOky1WWOMzoaROh2VgCiQ2h6QeoKXlh67jdnvn91Fsth+eiV9+Xmeam3+4f+Pp+pdyGhoa3F5/x44dWLZsGQDg+eefR1RUz21eFHaDpgbKstT2n1FRwTfkPahn8PfPep/jPN79on3jsqcXZOCmCUN8UNGN5e+ft7/h5+1f/PnzNpzNaCrdgYYDm+A8dchjvmQLRHDqFASPmQH74NRe933Jnz9rbsAhIuqjhBB4/8sSFB2tMsWjwwKweGEGAu38EUBm+tkytOS+D6Oq3O1xS9xIBGQ/CjmCiyKJiIiI6NpcqGnGaysK4HSZO6LePnEI7pzU9x4gEV0PoatQD30P1761EC317pMsNtjG3A5bxj2Q7P51Y5uIiIjoeh05XYu/rCmCIczNAR66PRkTU/v7qCoiop5JGAb08gOt025OFgDC6DRfjhwEJXUGlKSpkAI4TYx6Fk37YbLw5Rts3Ln8+OXndUbXf7j36en6l+dcef3GxkYsXboUQgjceuutuPfee7v0/r5isdzYBrCSJMFi6V2LUuna+ONnfbi8Bv/3g93tGpc9MXMkbps0zEdVeYc/ft7+jJ+3f/GXz1sIAy3Hi1Bf+D0aS3dCqE4PZ0gIjE9HSPoMBKdMhtwHGuv5y2d9Oa6+JiLqoz7dchR5RWdNseAAK5Y8kIGIkN7/Q5u6j2hpgHPXSqglm9welwLDYM96ENbEKb1ulzURERER9Rz1TS68srwAtY3mSYuZqf3xwK2J/F2T6J+EYUAry4NzzxqIhkr3SZIFStp02MbPghwU4dX6iIiuhxAC69atw6pVq1BcXIympibExMQgMzMTDz/8MNLT06/7PRwOB9577z3s3LkT58+fR2hoKBISEjBnzhzMnTsXFovFY43ffvstPvvsMxQWFqKqqgqKoiAuLg7Z2dl49NFHMWjQoOuuk4h862xVE15fUQiXZl5Afk/WMNw6YbCPqiIi6nmMhsrWaTclWyAaqzpPtiiwJkyCLXUG5Fje66GeKyDgh0ktqqp2uknG5frhXmZXNtMA5qk3qqp6zL/0HoqimOIvv/wyysvLER4ejhdeeKFL7+1Lut75xrxrJcsSJEmCEALGFZsTqG/x18/6TGUjXvjrdjQ7zY3LZubEY9a0ETfs75av+evn7a/4efsXf/m81arTaDiwCY0Ht0Cv6+B53mWs0XEIGT0dwaNugjUsGgAgcON+h/IGX37WN3rztyfcgENE1Ad9t7ccX2w/YYrZrDKeXZCBgdHsiEuthBDQyrbBuePjDropS1DSZsA+aT47KRMRERHRdXGqOt5YWYhzVU2meOrQCPxk5kjIXJBB1Pod7fgeuPI/hVFzuoMsCdbELNgnzoUcxq7sRNS7tLS04Nlnn8WmTZtM8YqKClRUVGDt2rV47rnn8OSTT17ze6xYsQK/+c1vTIvcqqqqUFVVhfz8fKxevRpvvvkmIiIi3J5fW1uLxYsXIy8vzxR3uVxwOBxwOBz4xz/+gf/6r//CnDlzrrlOIvKt2gYnXvlkPxqazQtip44egPunj/BRVUREPYcwdOgnC+Eq2QT9VCEgOl9IJUcNgZI2HUriFD5TpF4hKCio7bXT6ezyBpzLN9ZczfU9uZRz+cagHTt2YNmyZQCAf//3f0f//j3/PlBdXQs0TfeceJWiooJhsUgwDIGqqsZuvz71HP74Wdc1uvDih3tQ29C+cdmc7OGorm7q4Mzezx8/b3/Gz9u/9OXPWzgboR7ZCdWRB+P8Ec8n2IOhJEyGkpwDOSYeuiShTgPQR/538dVnbbVaEBkZ5DnxRtbg03cnIqJut6f0PP6x0WGKSRLws9mjkBgX7qOqqKfRa07DmfsB9NPFbo/L0UMQkPMYLLGJXq6MiIiIiPoa3TDw1mcHceR0nSk+OCYYT88bA8Xq2+40RD2BVnEIzl0rYVw42mGOZehY2CfdD0vUEC9WRkTUfZYuXdq2+SYhIQELFy5Ev379cPDgQXz88cdoamrCH/7wB8TGxmL27NlXff2tW7fi+eefhxACgYGBePDBBzF69GhUVlZi5cqVcDgc2L17N5YsWYJ33nkHsmz+HcQwDPzbv/0b8vPzAQCDBg3C/fffjxEjRqCxsRG5ubnYuHEjXC4X/v3f/x1hYWG45ZZbrvt/FyLyrmanhldXFOBibYspPjo+Co/fncppDUTk14z6C1BLtkAt3QrRVNN5stXeupAsbQbkmHj++0m9SlhYWNvrmpoahIaGdphbU1PT9joqKuqqr19bW9tprqqqaGpqMl2/sbERS5cuhRAC06ZNw7x587r0vkTUu7S4NLy2ogDnq5tNcTYuIyLqWYShQy8vgurIg3ZiL6BrnZ8gybAMGQMlOQfWYWMhWZTO86lX4gYcIqI+xHGqBm99fghX9iB69M4UjEuK8UlN1LMIzQXXvrVwFawHDDfdZ6x22CfOgzL6NkiyxfsFEhEREVGfIoTAB185sP/wRVM8KsyOxQvHIiiANxzJv+nnj8KZvxJ6xaEOcywDU2DPnA/LgCQvVkZE1L3y8vKwbt06AEBWVhbefvvttu7RM2fOxPz58/HQQw+hpqYGL774Im699VaEhIR0+foulwsvvPAChBAICgrChx9+iFGjRrUdX7RoEZYsWYKvv/4aeXl5WL9+PWbOnGm6xurVq9s232RlZeHPf/6zqXP1ggUL8N133+GZZ56Bpml44YUXkJ2d3eUu2ETke5pu4M3VB3DyXIMpPmxAKJ6aOxpWC5sDEJH/EYYG7fg+qCWboZcfBNo9aTaT+w2HkjodSmIWJFugd4ok6mbDhw9ve33mzBkMGdJxs5OzZ8+2vR40aNA1Xb8z586dg2EYpusXFRWhvLwcQGujgZSUFI/veSknLi4O3333XZfqJCLf0XQDf1pdhONn603xIf1D8PS8dDYuIyLqAfSqU62bbsq2QzR3vqkaaG14riTlwJqYBTmIjfL7Om7AISLqIyouNOCNlYXQdMMUn5U9HNPHxvmoKupJtPIitOT+HaLuvNvj1uETYJ/6EOSQaC9XRkRERER91dq849hScNoUC7JbsXjhWESGcrEq+S+9+jRc+augHd/TYY4cPax14s3gMewkTES93rvvvgsAsFqt+O1vf9tu00pCQgKef/55/PKXv0RNTQ1WrFiBJ554osvX37hxY9sCtZ/85CemzTcAYLPZ8NJLLyE/Px81NTV466232m3A+eSTTwAAdrsdL7/8smnzzSW33HILHnnkEfztb3/DuXPnsGXLFtx+++1drpOIfMcQAu+uL8ah49WmeP+IQDy3IAMBNj42JyL/YtSeg1qyGaojF6K5rvNkJQBKYhaU1BmwxAz3Sn1EN1JCQkLb67KyMkyaNKnD3LKyMgCAJElISupac5TIyEhER0ejsrKy7fyOHD58uO11cnJyl65PRL2bEAJ/+7IERceqTPHosAAsXpiBoAB+NyEi8hWjuQ7akZ1QS3NhVJ7wmC8FhMKaOAVKcjYs/YZ5oULqKfjTmoioD6iqa8ErywvQ5DSPt7spYxBm58T7qCrqKYymGji3fQTt6C63x6WQaARkPwLrsHFeroyIiIiI+rItBaexJveYKWa1yPjF/HTE9Qv2UVVEvmU0VMK5ew20slxAuO8qLIXHwj5xHqwjMiFJ7HRIRL1fTU0Ntm3bBgCYNm1ah92l77nnHrz44ouorKzEhg0brmoDzvr16wG0LopbtGiR25zg4GDMmzcP7777LhwOB44dO4b4+NZ7pw0NDSgsLAQATJ06FTExHU8Tv+uuu/C3v/0NAFBQUMANOES9xMpNR7Dj4DlTLDRIweIHMhAebPNRVURE3iV0Fdrxva3TbjqZxHqJHDMCStp0KAmTISkBXqiQyDvGjRsHRVGgqip27tyJhx9+2G2eruttUzJTU1MRFhbW5ffIzMzEhg0bUFxcjPr6eoSGhrrN27FjR9vrSxuBkpKS8Oabb3p8j9dee61tg8+l/IAA/l0l6ulWbT6KbUVnTbGQQAVLHshARAgblxEReZvQNWgnC6A5cqGdLASE3vkJshXWYWNbN90MGQNJ5lYMf8RPnYiol2tqUfHqigJU1ztN8bGJ/fCjO5PZJdePCcOAWvwdnLtWAWpz+wTJAlv6nbCNnw1J4Zd4IiIiIuo+BYcv4u8bSk0xCcDPZo1E8pAIn9RE5EtGcx1c+9ZCPfQ9YGhuc6TgSNjGz4aSksOb9UTUp+zevRuG0Tq1Oysrq8M8WZbbFqkVFBSgtrYW4eHhXXqPS4viUlJSEBUV1WFeVlZW2zSeLVu2tG3Aqa6uxpgxY3DmzBmMGDGi0/e6vKa6Og/d4omoR/g6/xQ27DxpitkUGc/Oz0BsZPtpV0REfY1Rcwauks3QHHkQLfWdJ9sCoSROhZI2HZbood4pkMjLwsLCkJWVha1bt+K7777D6dOnMWjQoHZ5X3zxBaqqWidU3H333Vf1HnfeeSc2bNgATdOwbNkyPPnkk+1yGhoasHr1agBAfHw8UlNTAQBRUVG47bbbPL7H+++/3/a6K/lE5Htf7z6F9TvMExVsVhnPzk/HwGg2LiMi8hYhBIyLJ6A6cqEd3gHhbPB4jhwTDyU5G0pCFqSAEC9UST0Zn+QSEfViqqbjjVUHUHGh0RRPGBSGn80eBYvMTrn+Sr94HC1b34dx4Zjb43JsIgKmPQZLlPuOo0RERERE1+rI6Vr8eU0RjCumezx0ezImpPT3UVVEviFczXAVboDrwFeA2uI+yR4M+9iZUEbdCsnK7utE1Pdc6sgMAMnJyZ3mJiYmAmh9AOpwOJCZmenx+ufOnWvbCJOUlNRpbkJCQtvrkpKSttdDhgzBihUrPL4XABw5cqTtdURERJfOISLf2VV8Dh9/W2aKyZKEp+aMwYhBXe9iT0TU2wjNBe3Y7tZpN2dKPeZbYpOgpE1vncZqZeM+6vsef/xxbN26FaqqYsmSJXjnnXcQEvLDQsrDhw/jd7/7HYDWaZoLFiy4quvfdtttGDx4MMrLy/Hmm29i/PjxmDhxYttxl8uFX/3qV6ipqQGAq5oASkS9067ic/j4m/bfTf51zmgkxHWtAQkREV0fo6kGWtk2qI48GNUVHvOloAgoSVNhTc6BJbL9hm3yX9yAQ0TUSxmGwF/XHoLjVI0pHhsVhF/MT4ddsfimMPIp4WqGc/enUA9+A1yx4BFA68KuyQuhpEyDJHGDFhERERF1r7NVTXh9RSFcmmGK3ztlGG6dMNhHVRF5n9BcUA99C9e+LzrummW1t04lTb8Lko2d14mo76qo+OFBZlxcXKe5AwYMMJ3XlQ045eXlXb5+bGwsZFmGYRg4ffq0x2u7s2rVqrbXGRkZ13QNIvKO4hPVeGfdIVx5p/zxu1ORnhDtk5qIiG40vaoCaskmqGXbAGdj58n2YChJ2VBSp8MS1fnvUUR9TU5ODu6880589dVX2LdvH2bPno1FixZh4MCBOHToEJYtW4bGxta/Q7/61a/aTdrcuXMnHn30UQDApEmT8MEHH5iO22w2LF26FE899RRaWlrw+OOPY8GCBRg/fjxqamqwfPlyOBwOAMD48eMxf/58L/ypichXOvpu8thdKRib2M8nNRER+QuhuaAd3wu1LA96eZH7NZWXsyiwDp8AJTkblrhRkNgEn9zgBpx/EkJg3bp1WLVqFYqLi9HU1ISYmBhkZmbi4YcfRnp6+nW/h8PhwHvvvYedO3fi/PnzCA0NRUJCAubMmYO5c+fCYvG8WL47ruHOb37zG3z00UcAgNJSz91PiMi3hBBY9m0ZdpdeMMXDg2345cIMhAaxY66/EUJAO7Ybzm3/gGiqcZtjTc6GffIDkAPZ1Y+IiIiIul9towuvfLIfDc2qKT519ADMu2mEj6oi8i5h6FAduXDt+Qyiscp9kmyFMvJm2MbOhBzEzoZE1PdVVf3w72FkZGSnuZdPlLnUCdqT6urqLl9fURQEBQWhoaGhy9e/3NatW/H9998DAKKjo5GdnX3V1yAi7zh1vgF//LQQmm5eVDH3phHISR/oo6qIiG4MQ3Wi4WAeGnd/BePcYY/5loEpUFKnwxo/kZNYya+99NJLaGxsRG5uLsrLy/H73//edFySJDz99NN48MEHr+n6t9xyC37961/jd7/7HVRVxUcffdS2NuuSMWPG4E9/+tM1r/ciop7v5Ln6Dr+bTMvgNAUiohtBCAHj3GGojjyoR3cCrmaP51gGJMOanA1lRCYb55FH3IADoKWlBc8++yw2bdpkildUVKCiogJr167Fc889hyeffPKa32PFihX4zW9+A1X9YRFKVVUVqqqqkJ+fj9WrV+PNN980PVy6EddwZ8eOHVi2bNnV/pGIyIe+3HkS3+4pN8UCbBYsXpiBfhGBPqqKfMWoO4+WvA+hnyp0e1yOGAh7zqOwDkrzcmVERERE5C+anRpeW16Ai7Utpvjo+Cg8fncqJEnyUWVE3iGEgcaS7Wj8/iOI2rPukyQJ1qSpsE+YAzk0xrsFEhH5UEvLD78f2O32TnNtth8WgF5+Xmeam394eOrp+pdyGhoaunz9S86cOYP/9//9f9v++89//nMEBARc1TW6U1jYjXlvWZba/jMqKviGvAf1HH31875Q3YTXVxai2amb4ndPGY5H7x3pl99P+upnTe7x8/YfrnPHUfX1x2gs2gLD2dRprhwYipAxMxCScSuUaE676a3497t7BQYG4p133sHatWuxZs0aFBcXo76+HhEREZgwYQIeffRRTJgw4breY9GiRZg4cSLef/99bNu2DRcuXICiKEhOTsZ9992HhQsXQlGUbvoTEVFPc7G2Ga+uKGj33eTm8XGYOWWYj6oiIuq7jIbK1k03ZXkQtec85ksh0VCSc6AkZ0MO6++FCqmv4AYcAEuXLm3bfJOQkICFCxeiX79+OHjwID7++GM0NTXhD3/4A2JjYzF79uyrvv7WrVvx/PPPQwiBwMBAPPjggxg9ejQqKyuxcuVKOBwO7N69G0uWLME777wD2c24qu64hjuNjY1YunQphKeRWkTUY2wrOoOVm46YYhZZwtPzxmBobKiPqiJfELoGV+EGuPZ+Buhq+wSLAtu4+2DLuAeShT/yiYiIiOjG0HQDf1pThBPn6k3xYQNC8fM5o2G1cCw39V1CCDQf3Y+aLcvgOnu0wzzr8AmwZc6DJZKLnIjI/2ia1vb68g027lx+/PLzOqPrPyxi8XT9y3O6en2gtRnaj3/8Y1RWVgIAsrOz8cgjj3T5/BvBcoN/x5IkCRaL/21S8Fd96fOub3Lh//fuTlTVmTfZTRkzED+blw6L3Df+nNeqL33W5Bk/777JcDWj4VAe6vd9A+fpMo/5gcPHIHTc7QhOngTJykX+fQX/fncfSZIwa9YszJo166rOmzx5MkpLS7uUm5SUhN/+9rfXUl6nPvjgg26/JhF1n4ZmFa98UoDaBpcpPiE5Bg/fluyXjQGIiG4EobZAO7YHqiMX+ukSAB7Ww1vtsI7IhJKcDcvAFEgSn2XT1fP71bh5eXlYt24dACArKwtvv/12W4e0mTNnYv78+XjooYdQU1ODF198EbfeeitCQkK6fH2Xy4UXXngBQggEBQXhww8/xKhRo9qOL1q0CEuWLMHXX3+NvLw8rF+/HjNnzuz2a3Tk5ZdfRnl5uedEIuoRio5W4r31Je3i/zIzDSOHR/mgIvIV7UwpnFvfh1Fz2u1xy+DRCMh5lDuziYiIiOiGEkLgb1+W4OCxKlO8X3gAnluQgUC73996oj5MP3cYzl0r0XCm/ff0SyyD0mCfNB+W/glerIyIqGe5fEqMqqqdbpJxuX5YlNKVzTSAeeqNqrppUtPBe3S1y/SFCxfwxBNP4OjR1o2Ww4YNw8svv+zzhTK6btyQ68qyBEmSIISAYbB5W1/X1z5vp6rjv/53B06dazDF04ZH4rkHxwFCQNd7/5/zWvS1z5o6x8+7b3KePYKG/d+i8VAuhKu501w5OBwhY25unXYTOQAAYADADfr9gbzHV3+/b/TmbyKivsap6nh9RQHOVpkn1CUPDseTs0a2TTQjIqJrI4QB/UwpVEcutKO7Ac3p4QwJlkGpUJJzYI2fCEnxPEmdqDN+vwri3XffBQBYrVb89re/NT2oAVon4jz//PP45S9/iZqaGqxYsQJPPPFEl6+/cePGtg0uP/nJT0wbZ4DWB0gvvfQS8vPzUVNTg7feeqvd5pnuuIY7O3bswLJlywAAoaGhqK+v93AGEfnS8bN1eHN1EfQrbqQtvDkRWSMH+Kgq8jajpR7OHcuhOba6PS4FRcA+5SFYR2T6fBEAEREREfV9n245im1FZ02xkEAFv3xgLMKDu7Zolqi30avK4cpfBe3Evg5z5Jh42DPnwzp4VIc5RET+IigoqO210+ns8gacK5/XdPX6nlzKuXxjUEdOnjyJn/zkJzhx4gQAYODAgXjvvfcQFeX7Zkh1dS3QNN1z4lWKigqGxSLBMASqqhq7/frUs/Slz9swBN5cfQDFx6tN8YHRQfj57NForG9B7/4TXp++9FmTZ/y8+w7haoZ6eAfUkk0wLp7wkC3BMngUlLQZsA4bCyFbUS8A8P8DfYov/n5brRZERgZ5TiQiIgCAbhj4y5oiHDldZ4rH9QvGM/PToVgtPqqMiKj3M2rPQS3Lg+rIg2io9JgvhcdCScqGkpwNOSTaCxWSv/DrDTg1NTXYtm0bAGDatGkYMmSI27x77rkHL774IiorK7Fhw4ar2oCzfv16AK0jSxctWuQ2Jzg4GPPmzcO7774Lh8OBY8eOIT4+vluvcaXGxkYsXboUQgjMnj0bZ86cwa5du7r85yIi7zpf04zXlhfAqZofqN6ROQR3TR7qo6rIm4QwoJXmomXnJ4DT3c1UCcqoW2HPnAfJxhugRERERHTjfbunHF9sNy/+sCkynluQgdgo/k5KfY9RdwHOPauhlW1HR+Pr5YiBsE2c19o9i00RiIgAAGFhYW2va2pqEBoa2mFuTU1N2+uubnK5/Pq1tbWd5qqqiqampi5dv7CwEP/6r/+KysrWB7lxcXF4//33ERcX16W6iMh7hBD4x9cO7Cu7aIpHhtqxZOFYhAR2beIVEVFPIISAceEo1OLNUI/sADRXp/mWkEiEZtyK4DE3o84I9lKVRERE5I4QAn/fUIqCI+ZF4ZGhdixemIHgAH43ISK6WsLVBPXILmiOPOjnyjyfYAuEkjAZSnIO5P4JfF5HN4Rfb8DZvXs3DKN1xG5WVlaHebIsIzMzExs2bEBBQQFqa2sRHh7epffIz88HAKSkpHT6MCcrK6ttGs+WLVtMm2e64xpXevnll1FeXo6YmBj8x3/8B5555pku/XmIyPvqmlx45ZP9qGtSTfFJaf2x8JZEH1VF3qRXVcCZ+z70sw63x+V+wxEw7TFYYjr+d5+IiIiIqDvtKT2Pj742/34qSxJ+Pns0RgwK6+Asot7JaKqBa+9aqCWbAMP9pAFLWD9E5CyEc9AESDI7GBIRXW748OFtr8+cOdNhMzQAOHv2h8l6gwYNuqbrd+bcuXNtz4U6u/7WrVvxi1/8om2zTmJiIt59913ExsZ2qSYi8q5120/g+30Vplig3YrFCzIQHe552hURUU8gnI1QD2+HWrwZRtWpzpMlCZYh6bClzkDM2CmwKgp03eC0GyIiIh9bs/UYthaa700EB1ix5IGxiArjdxMioq4ShgG94iBURx6043sAXe38BEmCZfAYKMnZsA4bB8na8RR2ou7g1xtwysp+2AmXnJzcaW5iYusidyEEHA4HMjMzPV7/3LlzqKtrHSWYlJTUaW5CQkLb65KSkm69xpV27NiBZcuWAQB+/etfIyIiotPrEpHvOF06Xl9RgPPVzaZ46tAI/Mu9IyFzd26fJjQnXHs/h6tgAyDcLPJSAmDPnA9l5C2QZNn7BRIRERGRX3KcqsFbnx9qN//j0btSkJHYzyc1Ed0IwtkIV8GXcBVt7LDjsBQQiojs+xE+8U4IyQoXFzsREbVz+bOLsrIyTJo0qcPcS89tJEny+EzkksjISERHR6OystL03Medw4cPt73u6LnQd999h1/84hdQ1daHuhkZGXjrrbcQGRnZpXqIyLu2Fp7G6i1HTTGrRcIz88ZgcP8QH1VFRNQ1Qgjo5w5DLdkE7Ug+oHc+7UYKjoKSehOUlGmQQ6JbY2wCQURE1CN8v68Ca7cdN8UUq4xn7k9HXD9OqSMi6gq9ugKaIw9q2TaIphqP+XLk4NZNN0lTIAdF3PD6iC7x6w04FRU/dEKKi4vrNHfAgAGm87qyAae8vLzL14+NjYUsyzAMA6dPn+7Wa1yusbERS5cuhRACd999N26//XaPfw4i8g1NN/Dnz4pw7Ey9KT44JgRPz0uHYuWGi75MO7kfLXkfQtRfdHvcOmIS7FMWQQ7mg38iIiIi8p6Ki414Y2UhNN0wxefkxOOmjK51qSfq6YTmhKvoG7gK1gPODjbUKAGwpd8N25g7EDagH2SL3NptmIiI2hk3bhwURYGqqti5cycefvhht3m6riM/Px8AkJqairCwrk/Vy8zMxIYNG1BcXIz6+nqEhoa6zduxY0fba3cbgXbt2oVnn322bfNNdnY2/vjHPyIoKKjLtRCR9xQeuYj3vyw1xSQAP71vFFKH8d45EfVcoqUBalke1JLNMKrdr+1oI8mwDs2AkjYDlsFj2JSPiIioB9pTegEfbrziu4kE/GzWKCQPifBNUUREvYRoaYB6eAfUsjwYF455zJfsIbAmZkFJyYEcPQwSm9iTD/j1Bpyqqqq21546l10+JaampqZL16+uru7y9RVFQVBQEBoaGkzX745rXO7ll19GeXk5IiMj8Z//+Z+e/xBE5BNCCPz9q1IUHqk0xaPD7Fi8MANBAX79z3efZjRUwbntH62jE92QQmMQkPMjWIeke7kyIiIiIvJ31fVOvLp8P5qcmil+U8Yg3Jc93DdFEXUjYWhQS7bAtffzjrtqWaxQRt4K27iZkAPcL+4mIiKzsLAwZGVlYevWrfjuu+9w+vRpDBrUfuPuF1980fbc5u67776q97jzzjuxYcMGaJqGZcuW4cknn2yX09DQgNWrVwMA4uPjkZqaajpeWVmJZ599Fi5Xa+f5m2++GW+88QZsNttV1UJE3nH0dB3+tKYIhjDP5nzwtiRkpvb3UVVERB0TQkA/U9o67ebYbkDXOs2XQvtBSfnntBs25CMiIuqxHKdq8NbnB3HFVxM8ckcKxifH+KYoIqIeThga9JMHoDpyoZ3cDxh65ydIFliHZcCanA3rkAxIFq6fJd/y6/8HtrS0tL222+2d5l7+gOXy8zrT3Nzc5etfymloaDBdvzuuccmOHTuwbNkyAMDzzz+PqKgoj9fzpbCwgG6/pixLbf8ZFcXRjn1db/68//FVCXILz5hiIYEKXvjpFAyJ5QIfd3rz5w0AwtBRv2cDarZ+DOFy83NGtiAsazbCp8yDrHj+edDX9fbPm64OP2//wc+aiKjnampR8ery/aiqc5riYxP74Ud3JrOzEPVqQhjQjuyEc/dqiLrz7pMkCUryNNgmzIYcEu3dAomI+oDHH38cW7duhaqqWLJkCd555x2EhIS0HT98+DB+97vfAQCCg4OxYMGCq7r+bbfdhsGDB6O8vBxvvvkmxo8fj4kTJ7Ydd7lc+NWvftXWvOyJJ55od43/+q//atsAlJ6ejtdff52bb4h6qHNVTXhtRQFcqnkC4V2Th+L2iUN8VBURkXtGcx00Rx5cJZshas92nixZYB0+rnXaTdxISBKn3RAREfVkFRca8MbKQmhXTEeflT0cN4+L81FVREQ9l37xROumm8M7IFrqPebL/YZBSc6BNWEy5MCuT0wnutH8egOOpv3QUcTTQ5TLj19+Xmd0/YcdeV15SHMp5/Lrd8c1AKCxsRFLly6FEAK33nor7r33Xo/X8jWL5cbdTJIkCRYLFwf5i972eX+57RhWfFtmitmsMv7zX7IwfFC4j6rqPXrb5w0ALRVluPjlW3Cdcz9CMWDoKPS7+0nY+g32cmU9X2/8vOna8fP2H/ysiYh6FlUz8MdPD6D8QqMpnjAoDD+bPQoWmYtBqHcSQkA/VQBn/ioYlac6zLOOyIR94jzIEQO9WB0RUd+Sk5ODO++8E1999RX27duH2bNnY9GiRRg4cCAOHTqEZcuWobGx9XeNX/3qV+0aiO3cuROPPvooAGDSpEn44IMPTMdtNhuWLl2Kp556Ci0tLXj88cexYMECjB8/HjU1NVi+fDkcDgcAYPz48Zg/f77p/CNHjmDDhg1t//2uu+7C1q1bPf65IiIiTBt9iOjGq2104Q+f7EdDs2qKZ42KxfwZCT6qiojITAgD+ukSqMWboB3f47GbsxQWCyV1OpTkbMhBfB5MRETUG1TVteCV5QVocprXad6UMRCzc+J9VBURUc9jNNVCO7wdqiMPRlXHz+MukQLDYU2aAiU5B5YorpeknsmvN+AEBPwwYUVV1U43uLhcrrbXXe14dvnEGlVVO8k0v4eiKN16DQB4+eWXUV5ejvDwcLzwwgser9MT6FfsDO8OsixBkiQIIWAYwvMJ1Kv1xs97R9EZ/OXTQlNMloBfPjwByUMjbsjfi76iN37eRksjqrcsQ8PejQDa1ywHhiLylkcRPHo6JEni53+Z3vh507Xj5+0/fPlZ38jN30REvZkhBN5ZdwglJ2tM8dioIPxifjrsisU3hRFdJ+2sA65dK6GfdXSYYxk8GvbM+bDEDPdeYUREfdhLL72ExsZG5Obmory8HL///e9NxyVJwtNPP40HH3zwmq5/yy234Ne//jV+97vfQVVVfPTRR/joo49MOWPGjMGf/vQnWCzm32HWrFkDIX74Hvp//+//7dJ7utsMREQ3TrNTw2vLC3Cx1jxFftTwSPz4njTInMxJRD5mNNVAdeRCLd4MUX+h82TZCmv8BCip02EZlMppN0RERL1IY4uKV5cXoLreaYqPTeyHH92ZAonfTYjIzxmaC42l+Wja+y30UwcA4WHdo8UK67DxrZtuBo+CJPMZNPVsfr0BJygoqO210+ns8gacyzfFXM31PbmUc/nGoO64xo4dO7Bs2TIAwL//+7+jf//+Hq/TE9TVtUDTOu8Ec7WiooJhsUgwDIGqqkbPJ1Cv1ts+77LyGvzh4/24cr3xI3ekIGlgaK/4M/hSb/q8hRDQjuyEc/tHEM11bnOU1Jtgn7QQroAQuKqbvFxhz9ebPm+6fvy8/YevPmur1YLIyCDPiUREfmj5d4eRX3LeFAsPtmHJwgyEBnWtQQlRT6JfPAFn/iropwo7zJH7J8A+aT6sg9K8WBkRUd8XGBiId955B2vXrsWaNWtQXFyM+vp6REREYMKECXj00UcxYcKE63qPRYsWYeLEiXj//fexbds2XLhwAYqiIDk5Gffddx8WLlzYroEZgLbpOETUc2m6gT+tKcKJc/Wm+NDYEDw1dwysbK5CRD4ihAG9/GDrtJsT+wHR+RoHOXwAlLQZsCZnQw4I9U6RRERE1G1cqo7/WVmIiovm59kJg8Lws9mjYJH53YSI/JMQAsaFo6jM34mm4m0wWho8niPHJkJJyoaSMAmSPdgLVRJ1D7/egBMWFtb2uqamBqGhHd/cqKmpaXsdFRV11devra3tNFdVVTQ1NbW7/vVeo7GxEUuXLoUQAtOmTcO8efO6VDsReVfFxUa8sbIQqmbe6Xvf1OGYMS7OR1XRjWDUnkVL7gfQKw66PS5HDoZ92mOwDkjycmVERERERGYbdp7ExnzzGHC7zYLnFmQgJiLQR1URXRuj9hycu1dDO7Kjwxw5Mg62zPthHTaOHQqJiG4QSZIwa9YszJo166rOmzx5MkpLS7uUm5SUhN/+9rdXdf233nrrqvKJyLuEEPjblyU4eKzKFO8XHoDFCzIQaPfrR95E5CNGYzXU0q1QSzZDNFR2nmyxwhqfCSVtBiwDkvmdk4iIqJcyDIG31x6Co9y8jnNAVBCeXZABu8KJDUTkf4yGKqhl26A5cmHUnvWYLwVHQUnOhpKUDTligBcqJOp+fn03cvjw4W2vz5w5gyFDhnSYe/bsD/8oDBo06Jqu35lz587BMIx217/eaxQVFaG8vBwAsHXrVqSkpHis+1JOXFwcvvvuO4/5RHR9quudeHX5fjS2aKb4tPSBmDMt3kdVUXcTugrX/vVw7V8L6Fr7BIsNtglzYEu/A5Ls1z+eiYiIiKgH2HHoLJZ/f9gUs8gSnp47BsMGsDsr9R5GYzVcez+DWrK1wy7EUmg/2CfMhTVxCiR2JyQiIiLqcVZtPoptReYFHCGBCpY8MBbhIXYfVUVE/kgYBvRThVBLNkM7uR8QotN8OTIOStoMKIlTIAWEeKdIIiIiuiGEEPjwawf2Oi6Y4uEhNix5IAMhge0n7hIR9VVCc0I7tgeqIw96xSEAnX83gtUGa/xEKMk5sAxKhSTxeRz1bn69wjchIaHtdVlZGSZNmtRhbllZGYDW7mxJSV2bShAZGYno6GhUVla2nd+Rw4d/WNSSnJzcrdcgop6rqUXFq8v3o6rOaYqnJ0Tj0btS2P2oj9AqDqEl9+8QHezwtgzNQED2I5BDY7xcGRERERFRe4eOV+F/1xW3i//4njSMiu/aVGAiXxMtDXAVrIer6GtAV93mSIFhsI2bBSVtBiSLX98mJSIiIuqxvt1TjvU7TphiNkXGswvSMSAqyEdVEZG/MRoqoZZsgVq6FaKxqvNkiw3WhEmwpc2A3D+Bz3uJiIj6iHXbjmPTvgpTLNBuwZKFY9EvPNBHVREReY8QAvpZBzRHLtSj+YDa4vEcy8BUKMnZsMZPhGTjv5XUd/j1k+Vx48ZBURSoqoqdO3fi4Ycfdpun6zry8/MBAKmpqQgLC+vye2RmZmLDhg0oLi5GfX09QkPdd4ndsWNH2+srNwJdzzWSkpLw5ptveqzztddea9vgcyk/ICDA43lEdO1UzcAfPz2A8guNpnj8wDD8fPZoWNh1t9czmmrh3PExtMPb3R6XgqNgn/owrMPH8+Y7EREREfUIJ8/V44+fHoBumLsULZiRgCmjOQKcej6hOuEq2ghXwXrA1ew+SQmELeNu2MbcAUnh/S8iIiKinmp3yXl89LXDFJMlCT+fPRoJg8J9VBUR+QthaNBOFkAt3gz91AF46ugsRw+BkjoDSmIWJHuwd4okIiIir9hacBqrtx4zxawWCc/MS8eQ/pxyR0R9m1F3AWpZHlRHHkT9BY/51ohYhKbPQNDIm1Bn8LsR9U1+vQEnLCwMWVlZ2Lp1K7777jucPn0agwYNapf3xRdfoKqqtYvJ3XfffVXvceedd2LDhg3QNA3Lli3Dk08+2S6noaEBq1evBgDEx8cjNTW1264RFRWF2267zWOd77//ftvrruQT0fUxhMA76w6h5GSNKR4bGYhnF6TDbrP4pjDqFkIYUIs3w7lrBeBqap8gyVBG3w77hDnc2U1EREREPcbFmma8uqIALS7dFL9twmDcNXmoj6oi6hqha1CLN8G173OI5jr3SRYFttG3w5ZxD6QAPhQlIiIi6slKT1bj7bWH2i13f+yuFGQk9vNJTUTkH4y6C1BL/zntpqmm82SrHUpiFpTU6ZBj4tlwj4iIqA/af/gi3t9QaopJAH4ycyRSh0X6pigiohtMuJqhHc2HWpYH/Uyp5xOUQCgJmbAm5yAmbSysVgt03QCqGj2fS9QL+fUGHAB4/PHHsXXrVqiqiiVLluCdd95BSMgPD+APHz6M3/3udwCA4OBgLFiw4Kquf9ttt2Hw4MEoLy/Hm2++ifHjx2PixIltx10uF371q1+hpqYGAPDEE0/ckGsQUc8hhMDH35Yhv+S8KR4WbMOSB8YiLMjmo8qoO+iVJ9Gy9X0Y54+4PS73H4GAnMdg6TfMy5UREREREXWsoVnFK8sLUNvgMsUnpsTgwVuTuICEeixhGNAOb4dzz2qI+ovukyQZSupNsI2fDTmYD0SJiIiIerryCw14Y9UBaLphis+ZFo9pGe2bKRIRXS+ha9BO7INashl6+UF4nHYTEw8ldTqUhMlstkdERNSHHamoxV/WFMEQ5t8NFt2WhElpsT6qiojoxhCGAf30IaiOPGjH9gC6q/MTJAmWuFFQknNgHT4OktX+zzCfK1Pf5/cbcHJycnDnnXfiq6++wr59+zB79mwsWrQIAwcOxKFDh7Bs2TI0NrbuwPvVr36FqKgo0/k7d+7Eo48+CgCYNGkSPvjgA9Nxm82GpUuX4qmnnkJLSwsef/xxLFiwAOPHj0dNTQ2WL18Oh6N1dPr48eMxf/78djV2xzWIqOfYsOskvtldborZbRYsXpCBmAjeoO2thNoC5541UA9sBITRPsEWCPukBVDSZkCSZO8XSERERETUAZeq442VhThbZZ7emDwkAj+9byRkmTdJqecRQkA7sQ+u/FUwqis6zLMmZME+cS7kcD4MJSIiIuoNqupa8OryAjQ7NVN8xthBuG/qcN8URUR9llF7FmrJFqiO3I6nqV6iBEBJnAIlbTos/YZ7pT4iIiLynTOVjXhtRQFcmnkN0D1Zw3DbxCE+qoqIqPsZNWegOvKglm2DaKzymC9HDII1ORtK0lQ2viO/5fcbcADgpZdeQmNjI3Jzc1FeXo7f//73puOSJOHpp5/Ggw8+eE3Xv+WWW/DrX/8av/vd76CqKj766CN89NFHppwxY8bgT3/6EywWyw27BhH53vais1jxvXkyikWW8PTcMRg2INRHVdH1Uo/vgTPvHx3+AmpNnAJ71oOQg8K9XBkRERERUecMQ+Ctzw/icEWtKR7XLxjP3D8GipX3GKjn0U4Xw7lrZYeTRwHAMiQd9sz7OX2UiIiIqBdpbGmdzFld7zTFxyX1wyN3pLCDKhF1C6Gr0I7taZ12c7rYY77cPwG21OmwJkyGpNi9UCERERH5WnW9E698UoDGFnNjgKmjB+D+6SN8VBURUfcRzkaoR3ZCdeTCOH/U8wn2YCgJWVCSsyHHxPMeDfk9bsABEBgYiHfeeQdr167FmjVrUFxcjPr6ekRERGDChAl49NFHMWHChOt6j0WLFmHixIl4//33sW3bNly4cAGKoiA5ORn33XcfFi5cCEVRbvg1iMh3Dh6rwrvr29/E/fG9aRgVH+XmDOrpjPqLcG77B7QT+9wel8JjEZDzGKxxI71cGRERERGRZ0IIfPi1A/vKLprikaF2LF6YgeAA3mOgnkW/cBzO/JXQy4s6zLHEJsE2aT6sA1O8WBkRERERXS9V0/E/Kwtx+mKjKZ4QF4YnZ43iZE4ium56zWmoxZuhOfIgnA2dJ9uCoCRNbZ12E8UO90RERP6kqUXDaysKUFnXYoqPHhGFx+9O5aJzIuq1hKFDLz8A1ZEH7fg+wNA6P0GSYRmSDiU5G9ZhYyFZ+OyY6BJuwPknSZIwa9YszJo166rOmzx5MkpLS7uUm5SUhN/+9rfXUl63XsOdDz74oNuvSUQ/OHG2Hn9cfQC6IUzxBTcnYMqoAT6qiq6VMDSoBzbCuWcNoLnaJ8hW2MbNhC3jHkhWm9frIyIiIiLqinXbT2DTvgpTLMhuxeKFGYgKC/BRVUTtGTVn4Nz9KbSj+R3myFFDYJ90PyxDMvgAlIiIiKiXMQyBtz8/BEe5eTLnwOggPDs/A3aFkzmJ6NoIzQXt2G6oxZugn3V4zLcMSIaSOh3WEZl8xkdEROSHVM3AHz8txKnz5s26wweE4qk5o2G1yD6qjIjo2umVp6A6cqEd3g7RXOcxX44e2rrpJnEK5MAwL1RI1PtwAw4R0Q12vqYZr64ogNOlm+K3TRyMuyYN9VFVdK30s2VoyX0fRlW52+OWuJEIyH4UcgQ3VhERERFRz5VbeAart5jHiVstEp65fwwGx4T4qCoiM6OhEq49n0F15ALCcJsjhfWHfeI8WBMmQZL48JOIiIiotxFC4KNvHNjjuGCKh4fYsHhhBkIC2V2ViK6eXlUOtWQz1LJtgLOx82R7MJTkHCipN8ESGeedAomIiKjHMYTAO+sOoeRkjSnePzIQzy3IQICNS22JqPcwmuugHd4B1ZEHo/KEx3wpMAzWxClQkrNhieaaViJP+FsBEdENVNfkwquf7Eddo3lKSmZqfzx4axK78vYioqUBzl0roJZsdntcCgyDfcoiWBOy+LkSERERUY9WeKQSf/uyxBSTADx53yikDI30TVFElzFa6uHatw7qoW8BXXObIwVFwDZ+FpTUmyDJvMVJRERE1Fut33EC3+01T+YMtFuweEEG+oUH+qgqIuqNhOaEdmQXXCWbYZw77DHfMjAVStoMWIeP57QbIiIiPyeEwMfflCG/5LwpHhakYMkDYxEWzN8ViKjnE7oG7eR+aI48aCcLAaF3foJshXXYWCjJObAMGc3nbURXgX9biIhuEKdLx+srCnGuutkUTx0agZ/MHAmZmzR6BSEEtLJtcO74GKKl3k2GBGXkzbBn3g/JHuz1+oiIiIiIrsaxM3X405oDMIQwxRfdloSJqf19VBVRK+FqhuvAV3AVbgDUFvdJ9mDYMu6FbfStkKx27xZIRERERN0q78AZrNpsnsxpkSU8PXcMhsaG+qgqIupt9Isn/jntZjugNneaKwWEwpqcA1vqdMgRA7xUIREREfV0G3aexDd7yk0xu82CxQvHon8EGwMQUc8lhIBx8ThURy7Uwzs8TwAFIMeMgJKSA2XEJEgBIV6okqjv4QYcIqIbQDcM/OWzIhw7U2eKD44JxtPzxkCxyj6qjK6GXnMazq1/h36mxO1xOXooAqY9Bkv/BC9XRkRERER09c5VN+G1FQVwqYYpfvfkobht4hAfVUUECM0Ftfh7uPat66DxAQCrDbbRd8CWcTebHxARERH1AQeOtp/MCQA/mTkSacOjfFAREfUmQm2BemQn1OJNMC4c85hviRsFJW06rMPGQ7JwmQwRERH9YFvRGazYdMQUu9QYYNgANgYgop7JaKyGWrYdWlkujOrTHvOl4EgoSVNhTc6GJWKQFyok6tt4Z4GIqJsJIfD3DaUoOFJpikeF2bF44VgEBSg+qoy6SmguuPathatgPWC4GcVotcM+cR6U0bdBki3eL5CIiIiI6CrVNbrw6icFqG9STfEpo2Jx/wxuKCffEIYOzZEH5541EI1V7pNkC5TUGbCNvw9yUIRX6yMiIiKiG+PYmTr8aXURdMM8mfPBWxIxeWSsj6oiop6urbNz8WaoR3Z0PDn1n6TAcCgp06Ck3gQ5jFN/iYiIqL2io5V4b337xgA/vjcNo+LZGICIehahuaAd3wvVkQu94iAgROcnWGywxo+HkpwDy6CRkGQ2jSfqLtyAQ0TUzT7LPYathWdMseAAKxYvHIvIULuPqqKu0k4dQEvu3yHqL7g9bh0+AfapD0EOifZyZURERERE16bFpeG1FQU4X9Nsio8cHokn7kmDLEk+qoz8lRAC2rHdcO3+FEbNmQ6yJFiTpsA+YS7ksBiv1kdEREREN8756ia8vqIATtXc/OrOSUNwx6ShPqqKiHoy4WqCengH1OLNMCpPeMiWYBkyGkrqDFiHZUCSuSSGiIiI3Dt2pg5vumkMsPDmREwZNcBHVRERmQkhoJ87DM2RC/XILkBt9niOZUAyrMnZUEZMgmQL9EKVRP6HdxuIiLrRpn0V+DzvuCmmWGU8c3864voF+6Yo6hKjqQbObR9BO7rL7XEpJBoB2T+CddhY7xZGRERERHQdNN3An9ccxPGz9ab40P4h+Le5Y2C1sNMReZdWfhDO/JUwLhzrMMc6bBxsmfNgiRrixcqIiIiI6Eara3ThlU8KUHfFZM6skbFYcHOij6oiop5ICAHj/BGoJZuhHtkJaK5O86XgyNZpNyk3QQ7t56UqiYiIqLc6V92E19w0BrgjcwjumszGAETke0b9RahleVAd2yDqznnMl0L7QUnKhpKczQmgRF7ADThERN1kn+MCPthYaopJEvDkfaOQPCTCN0WRR8IwoB76Ds78Ve53iEsW2NLvhG38bEgKJxgRERERUe8hhMD7G0pw4GilKd4vPACLF2Yg0M7bQuQ9+vmjcO5aAf10cYc5loEpsE9aAEssF18SERER9TUdTeZMGxaJH9/LyZxE1Eo4G6GWbYNashlGVXnnyZIEy5AM2NKmwzIkHZJs8U6RRERE1KvVNrrwyif7UX9FY4DJI2Ox8BbemyYi3xFqC7Rju6E68jp9ntZGCYA1PhNKcjYsA5MhSWy8SOQtXGlBRNQNDpfX4i+fH4QwTyXFI7cnY0JKjG+KIo/0C8fRsvVvMC4ed3vcEpsE+7THYIka7N3CiIiIiIi6weqtx5B34KwpFhKoYPHCDISHcHM5eYdeXQFX/qfQju/pMEfuNwz2zPmwDB4NiQsviYiIiPocTTfwpzVFbidzPj2PkzmJ/J0QAvq5MqjFm6Ed3QXoaqf5Ukg0lJSboKRMgxwS5aUqiYiIqC9odmp4bXkBLtS0mOIjh0fiX9gYgIh8QAgD+ukSqI48aMd2A5rTwxkSLHEjoSRnwzp8AhuKE/kIN+AQEV2nM5WNeH1lAVTNMMVnTh2Gm8dz40ZPJFzNcO7+FOrBb9Bu1xQA2INhn7wQSso07gwnIiIiol7p+30VWLftuClms8p4dn46BkYH+6Yo8itG/QU496yBVrbN/fcuAFL4ANgz58EaP5HfvYiIiIj6KCEE3v+yBEVHq0zxfuEBeI6TOYn8mmhpgOrIa512U3O682RJhnXYOCip01ubN8j8DklERERX51JjgBPn2jcG+Le5bAxARN5l1J5t/T5Utg2iodJjvhQ+AEpyNpSkqZBDor1QIRF1hnc0iYiuQ3W9E698sh+NLZopnjNmIOZOG+GjqqgjQghox/Lh3PYRRFON2xxrcg7skxdCDgzzbnFERERERN1kr+MCPtxYaopJEvCz2aOQEBfuo6rIXxjNdXDtWwv10HeAobvNkYKjYJswG0pyDiTZ4uUKiYiIiMibPt1yFHlF5smcwQFWLF6YgQhO5iTyO0II6GdKWqfdHNsNGFqn+VJoDJTU6VBSciAHRXinSCIiIupzDCHw7vpiHDzWvjHAYjYGICIvEc5GqEfzoTpyYZw77PkEWxCUhMlQkrMh90+AxCldRD0Gf3MgIrpGTS0aXl1egMo689i/MSOi8ehdKfyFp4cx6s6jJe9D6KcK3R6XIwbBnvMorINSvVwZEREREVH3KSuvwVufH2w3cORHd6ZgXFKMb4oivyBcTXAVboCr8CtAc7rNkewhsI2bCWXkLZCsNi9XSERERETe9t3ecnyx/YQpZrPKeHZBBidzEvkZo7kOmiMXrpLNELXnOk+WLbAOHw8ldQYscWmcmEpERETXbeWmI9hx0Pw7SEiggiUPjEU4GwMQ0Q0kDAN6RRFURx6043sBXe38BEmGZfBoKCk5sA4dy+dpRD0UN+AQEV0DVTPwx08LUX6hwRSPHxiKp+aM5ljSHkToGlyFX8K193P3v8BaFNjGz4It/W5IFv5YJCIiIqLe6/TFRryxshCqZpjis7KHY8bYOB9VRX2d0FxQD34L5/51gLPRfZISANuYO2FLvwuSLdC7BRIRERGRT+wpPY9/bHSYYpcmcyZyMieRXxDCgF5RDLVkU+tCsw6mpF4ihcXCljYd1uQcyIFhXqqSiIiI+rqNu05iw86TpphNkfHcggwMiAryUVVE1NfpVRVQHbnQDm+HaKrxmC9HDYaSnA1r4hRO/yTqBbjSmIjoKhlC4H+/OISSkzWmeP/IQDy7IAN2m8U3hVE72plSOLe+D6PmtNvjliFjEJD9I8hh/b1cGRERERFR96qud+LV5fvR2KKZ4tPSB2J2TryPqqK+TBg61NKtcO39DKKx2n2SbIUy8mbYxt3HxVNEREREfsRxqgZvfX4IVwzmxKOczEnkF4ymGqiluVBLNkPUX+g8WbbCGj8RStp0WAamQpIk7xRJREREfmHnoXP4+LvDppgsSXhqzhiMGMR71kTUvURLA9TDO6A6cmFcPO4xXwoIhTUxC0pyDuToofw+RNSLcAMOEdFVWv7dYewqPm+KhQW1jiUNC+LIv57AaK6Dc+dyaI5ct8eloAjYpz4Ma/xE/uJKRERERL1eU4uGV5cXoLLOaYqnJ0Tj0btS+DsvdSshDGhHd8O5exVE7Tn3SZIEa1IO7BNmQw7t590CiYiIiMinKv45mVPT20/mnM7JnER9ljAM6OVFUEs2QzuxDxBGp/lyxEAoqTNgTZ4KOSDUS1USERGRPyk+XoV31h1qF3/87lSkJ0T7oCIi6ouEoUE7WQjNkQft5H6Pkz8hW2AdOhbW5GxYh6RDsnAZP1FvxL+5RERXYcPOk9iYf8oUs9sseG5hBvpHBPqoKrpECAP1Bd+i8bsPAGdj+wRJgjLqNtgnzoNk4+dFRERERL2fqhl4c/UBlF9oMMXjB4bh57NHwyLLPqqM+hohBPTyA3DuWgWj8kSHedbhE2DLvB+WyEFerI6IiIiIeoKquha8unw/mpzmyZw3ZQziZE6iPsporIZaugVqyRaIhsrOky0KrCMyoaTNgCU2iQ1DiIiI6IY5ea4e//PpAeiGeS7n/dNHICd9oI+qIqK+QggBo/IEVEcetMM7IFrqPZ4j9xsOJTkH1sTJbEJA1AdwAw4RURftOHgWy783jyW1yBL+be5oDB/AsaS+5rpwEtUb30HLqWK3x+WYeATkPAZLzHDvFkZEREREdIMYQuDd9cUoPlFtisdGBuLZBemw2yw+qoz6Gv1sGZz5K6GfKe0wxxI3CvbM+2HpP8KLlRERERFRT9HUouLVFQWoumIy59jEfvjRnclcaE/UhwhDh36qEK7izdBPFQBCdJovRw6GkjYdStJUSPZgL1VJRERE/upCTTNeXV6AFpd5CsWt4wfjnqxhPqqKiPoCo6kG2uHtUB15MKrKPeZLQRGwJk6BkpwDSxSnAhP1JdyAQ0TUBYeOV+F/v2i/seOJe1IxOp5jSX1JqE649n6G+gNfuR/hqATAnjkfyshbILH7NxERERH1ISu/P4Kdh86ZYmFBChY/MBZhQTYfVUV9iV51Cs5dq6Cf3N9hjhwTD/ukBbDGjfReYURERETUo6iajv9ZdQAVF8yT6RMGheFns0dxMidRH2HUX2yddlO6FaKxuvNkqw3WEZNhS5sOuX8CN+ERERGRV9Q1ufDKJ/tR2+gyxSemxGDRbZzAR0RXT2guaCf2Q3XkQi8vAoTR+QkWK6zDJ0BJzoYlbhQkmQ0TifoibsAhIvLg5Ll6/NHNWNL5MxIwdTTHkvqSdnI/WnI/6HCkvXXEJNinLIIcHOnlyoiIiIiIbqyN+aewYddJU8xus+C5hRnoHxHoo6qorzDqzsO5ezW0wzsAuO9kLEcMgi3zfliHj+dDSyIiIiI/ZgiBv64rRumpGlM8NioIv5ifDrvChSZEvZkwNGgnCqCWbIZ+6gA6+o54iRw9FEraDCiJWZBsQd4pkoiIiAiA06Xj9RWFOFfdbIqnDInAT+8bCVnmfWwi6hohBIzzR6A68qAe2Qm4mjyeI8cmQknOgTIik5M/ifwAN+AQEXWiw7GkEwbj7slDfVQVGQ1VcG77B7Tje9wel0JjEJDzI1iHpHu5MiIiIiKiG29X8Tl8/G2ZKWaRJfzb3NEYPiDMR1VRX2A01cC193OoxZsB4WbCKAApJBr2CXNgTcrmlFEiIiIiPyeEwMfflGF3yXlTPDzYhl8uzEAoJ3MS9VpG3XmoJf+cdtNc23myEgAlIQtK2nTI/YazSQMRERF5naYb+PNnRTh2ps4UHxwTjGfuHwPFysYAROSZ0VAJtWwbVEceRO1Zj/lSSDSUpKlQkrMhhw/wQoVE1FNwAw4RUQfqm1x4ZXmB+7Gkt3IsqS8IQ4da9A2ce1YDakv7BNmK8KzZ0FPvhGTlgz0iIiIi6nuKT1TjnXWH2sUfvzsVo+OjfVAR9QXC2QhXwZdwHdgI6C63OVJAKGzjZ0FJmwHJoni5QiIiIiLqiTbsPIlv9pSbYgE2CxYvzEA/TuYk6nWErkE7sRdq8WboFQc95ssx8VBSp0NJmAzJxr/zRERE5BtCCPx9QykKj1Sa4lFhdixeOBZBAbyfTUQdE6oT2vE9UB150CsOwdPUT1jtsMZPhJKSA8vAFEgSm9UR+SNuwCEicsOp6nhjZSHOVZnHB3Isqe/o54+gZevfYFSecnvcPnQUYu5+EpbIQaiqavRydUREREREN175+Qb88dNCaLr5xu/900cge8xAH1VFvZnQnHAVfQ3X/vWAq8l9khIAW8bdsI2+gwuqiIiIiKjNtqIzWLHpiClmkSU8PW8MhsaG+qgqIroWRs1ZuEo2Q3PkQrTUd56sBEJJmgIldTos/YZ5p0AiIiKiTqzeehS5B86YYsEBVixZOBaRoXYfVUVEPZkQBvQzDqiOPGjH8t03Ar+CZVAalORsWOMnQlICvFAlEfVk3IBDRHQF3TDwlzVFOHLaPJY0jmNJfUI4G+HMXwX10Pdwt8NcCgiFPetB9J98O6xWC3Td8H6RREREREQ3WGVtC15Zvh/NTt0Uv2V8HO7J4oIXujpC16CWboFrz2cQzbXukyxWKKNug23svZADuICSiIiIiH5QdKwS760vaRf/l3vTMHJ4lA8qIqKrJTQXtON7oRZvgn6m/d/nK8mxibClTod1xCRICheyEhERUc/w7Z5yrNt2whRTrDKenZ+BQf2CfVQVEfVURt15qI48qGV5EPUXPeZLYbFQkrOhJE2FHNrPCxUSUW/BDThERJcRQuCDrxwouGIsaWSoHYsXZHAsqRcJIaAd2QHn9mUQzXVuc5TU6bBPWgApIASSxKlERERERNQ3NTSreGX5ftQ0uEzxCckxeOi2ZP4uTF0mhAHt8A44d6+GqL/gPkmSoaRMg238bMghXDxJRERERGYnztbjzdVF0A1zw6yFNycia9QAH1VFRF2lV5+GWrIZqiMXcDZ2nmwLal1sljodlqjB3imQiIiIqIt2l5zHR187TDFJAv519igkDg73UVVE1NMIVzPUo7ugOfKgn3V4PkEJhJIwCdbkHFhiE/kclojc4gYcIqLLfJ53HFsKTptiQXYrlizMQFQYRwd6i1F7Fi25H0CvOOj2uBw5GPZpj8E6IMnLlREREREReZdL1fE/qwpxprLJFE8aHI6f3jcSssybvuSZEAL6yQI481fBqDrVYZ51xCTYJ86DHMGFk0RERETU3vmaZry6fD+cLvNkztsnDsGdk4b4qCoi8kRoLmhH86GWbO7SgjPLgGQoaTNgjZ8IyWrzQoVEREREV6f0ZDXeXnsI4or4o3emYFxSjE9qIqKeQxgG9NOHoDpyoR3bC+iuzk+QJFgGj4aSlA3r8PH8HkREHnEDDhHRP23eX4HPco+ZYlaLjF/MT0dcTIiPqvIvQlfh2v8FXPvXAbrWPsFqg33CHChj7oAk80cYEREREfVthiHw17WHUFZea4oPjA7CM/enw6ZYfFQZ9SbamVK4dq2Efq6swxzLkDGwZ94PS7/h3iuMiIiIiHqVuiYXXvlkP+qaVFN8Ulp/PHArO8IS9USu8yfQsnMD1LJtgKup01zJHgLrpWk3kYO8VCERERHR1Ss/34A3Vh2Aphum+OyceEwfG+ejqoioJ9BrTkNz5EEt2wbRWO0xX44cBGtSDpSkKZCDI71QIRH1FVy9TEQEYH/ZRfz9q1JTTALws1kjkTwkwic1+Rut4hBacv8OUXvW7XHL0LEIyH4Ecmg/L1dGREREROR9Qgh89I0DexwXTPGIEBuWLByLkEDFR5VRb6FfPAFn/iropwo7zJFjE2HPnA/roFQvVkZEREREvY3TpeP1FQU4X91siqcOjcC/3DsSMjffEPUYQnWioXAXGgq+gbOiC9NuBqVBSZ0Oa/wESBbeayAiIqKerbK2Ba+uKECz09zUd/rYQZiVPdw3RRGRT4mWBqhHdkJ15MG4cNTzCfZgKIlZUJJzIPcbzoYiRHRNuAGHiPzekYpa/OWzIogr5pI+dHsyJqT0901RfsRoqoVzxzJoh3e4PS4FR8Ge/QiU4eO9XBkRERERke+s33EC3+2tMMUC7RYsWTgW0eEBPqqKegOj9iyc+Z9CO7qrwxw5cnDrxJthY/lggYiIiIg6pRsG/vxZEY6dqTfFB8eE4Ol56VCsso8qI6LL6RdPQC3ZDLVsOxrU5k5zpcAwKMk5UFJvghw+wEsVEhEREV2fhmYVryzfj+p6pyk+LqkfHrkjmfe6ifyIMDTop4qgOnKhndgPGFrnJ0gWWIemw5qcDevQDDYfIKLrxg04ROTXzlQ24vWVhXBp5rGk904ZhlsnDPZRVf5BCANq8SY4d60AXG4eBEgylDF3wD5hDiSFCwyJiIiIyH/kHTiDVZvNHZqsFglPz0vH4P4hPqqKejqjsRquPZ9BLd0CCMNtjhQaA/vEubAmZEGSuVCSiIiIiDonhMD7G0pReKTSFI8Os2PxwgwEBfBRM5EvCVdza6fnks0wLhzzmG8ZPLp12s2wcZAs/PtLREREvYdL1fHGykKcqWwyxRPjwvGzWaNg4f1uIr+gV56E6siDdng7RHOdx3w5ehiU5GxYE7MgB4Z5oUIi8he8q0JEfqumwYlXPilAQ7NqimePHoB5N43wUVX+Qa88iZatf4Nx3v3YR7l/AgKmPQZL9FAvV0ZERERE5FtFRyvxty9L2sV/MnMk0oZF+qAi6ulESwOc+7+AevAbQFfd5kiBYbCNnwUldQYXWRERERFRl63Zegy5hWdMseAAKxYvHIvIULuPqiLyb0IIGBeOtU67ObwD0Jyd5kuB4VBSprVOuwnr76UqiYiIiLqPbhh46/ODOFxRa4oPjA7CL+anw6ZYfFQZEXmD0VwH7fB2qI5cGJWnPOZLgWGwJk6BkpwDS/QQL1RIRP6IT9yJyC81OzW8urwAlXUtpvjoEVF47O5UjiW9QYTaAufu1VCLvnbfkdkWBPukBVDSpkOS2J2CiIiIiPzL8bN1eHN1EXRDmOIP3pqESWmxPqqKeiqhtsB1YCNcBV8CqpupogBgC4Qt417YRt8OSeECSSIiIiLquk37KrB223FTTLHKeHZ+Bgb1C/ZNUUR+TLiaoJZtb512U3nSQ7aEwIRxCMm4Fc1RKZBkLgshIiKi3kkIgQ83OrCv7KIpHhlqx5KFYxESqPioMiK6kYSuQjuxH6ojD/qpA4DQOz9BtsI6fByU5GxYBo+BJHNjHhHdWLzTQkR+R9MN/PHTAzh1vsEUHz4gFE/NGQ2rhRs/upsQAtqJvXDm/QOiscptjjVxCuxZD0IOCvdydUREREREvne+phmvLS+AUzXfQL5z0hDckcnuTPQDoatQizfBtW8tRHOd+ySLDbbRt8GWcQ+kgBDvFkhEREREvd5exwV8sLHUFJMk4F9njULiYN7DJ/IWIQSM80fgKt4E7cguQHd1mi8FR0FJmYaYyXfCHhULXTfQUtXopWqJiIiIut/avOPYvP+0KRZot2LxggxEhwf4qCoiuhHapn068qAe2QE4PX+XkfsnQEnOhpIwGZKdzUKIyHu4AYeI/IohBP73i2IUn6g2xftHBOK5BRkIsPGfxe5m1F9ES96H0E/ud3tcCh+AgJxHYY0b6d3CiIiIiIh6iLomF175ZD/qmlRTfPLIWCy4OdFHVVFPIwwD2uHtcO7+FKKh0n2SZIGSNh22cfdBDo70boFERERE1CeUldfgrc8PQpgHc+JHd6RgXHKMb4oi8jPC2Qi1bBvU4s0wqss7T5YkWIeOhZI6HZYhrZ2ereFceEZERES93+b9FViTe8wUs1pk/OL+MRjcn42niPoKo7Eaatk2aI48GDWnPeZLwVFQkqZCSc6GHDHQCxUSEbXHleZE5FdWfH8YOw+dM8VCgxQseSADYcE2H1XVNwlDg6twI1x71wCam45cFitsY++Dbew9kCwcCUtERERE/snp0vH6ikKcr242xdOGReLH96RBliQfVUY9xaWJoq78T2FUV3SQJcGaOBn2ifMgh/X3an1ERERE1HecvtiIN1YWQtUMU/y+qcMxY1ycj6oi8g9CCOhnHVCLN0E7thvQ1U7zpZBoKKnToaRMYwMGIiIi6nP2lV3A37+6YiongCfvG4mUofzdh6i3E5oL2vG9UB250CsOol0XkCtZbLDGT4CSnAPLoDRIsuydQomIOsANOETkNzbuOomvdp0yxeyKBc8tyED/yCAfVdU3aWfL4Nz6fodduSxxoxCQ8yPI4QO8XBkRERERUc+hGwb+/FkRjp2pM8WH9A/B0/PGQLHy5rG/004Xw7lrBYzzRzvMsQzNgD1zPizRQ7xYGRERERH1NdX1Try6fD8aWzRTfFr6QMyZFu+jqoj6PqOlHpojD2rJZhg1ZzpPliywDhsLJW06LHGjueiMiIiI+qSS41X4y2ftp3I+fEcyJqayARVRbyWEQMupYrTs+QbqkXxAbfZ4jmVgCpSkbFhHZEKyBXqhSiKiruEGHCLyCzsPncPH3x02xSyyhKfmjkb8wDAfVdX3iJYGOHcth1qyxe1xKTAM9ikPwZowGRI7eRMRERGRHxNC4O8bSlF4pNIUjw4LwHMLMhBo5y0bf6ZfOAbnrpWtXb86YBmQDNukBbAOSPJiZURERETUFzU2q3h1eQEq65ymeHpCNB69K4X384m6mRAC+pmSf0672QMYWqf5UmgMlLTpUJJzIAdFeKdIIiIiIh84da4ev/vbrnZTOe+dMgy3jB/so6qI6HoY9RdQc2g9Gg9ugVZ91mO+FBoDJTkbStJUyGHcdEdEPRNXcxBRn1d4+CLeWXeoXfzxu1MxZkS0Dyrqe4QQ0Mry4NzxCURLvZsMCcrIm2HPvB+SPdjr9RERERER9TSf5R7D1kJzZ9vgACuWPJCByFC7j6oiX9NrTsOV/ym0Y7s7zJGjh8CeuQCWIWO4EJKIiIiIrpuq6fjv9/NRfqHBFI8fGIafzx4NCydsEHUbo7kOamku1JLNEHXnOk+WLbAOnwAlbQYsg1IhSfy7SERERH1bZW0zfv3X7ahvUk3x7DEDMO+mET6qioiuhVBboB3Nh+rIg36mxPMJSgCUEZmwJufAMiCJ33+IqMfjBhwi6tOOna7Ff7+fD90wzyW9f/oIZI8Z6KOq+ha9+jScue9DP1Pq9rgcPRQB0x6DpX+ClysjIiIiIuqZvtpxAp/nHTfFFKuMZ+dnYGA0N6z7I6OhEq49a6A6cgEh3OZIYbGwT5wLa8IkPnggIiIiom5hGAKvLNuLoqPmyZyxkYF4dkE67DaLjyoj6juEMKBXHGqddnN8HyD0TvOl8FjYUmfAmpwNOTDMS1USERER+VZTi4rff7wfF6qbTfH0hGg8dlcqm1ER9QJCGNBPl0B15LY2mtNcHs6QYIkbCSU5G9b4CZCsbFBIRL0HN+AQUZ91rqoJL/x1O5qd5rHtt4yPwz1Zw3xUVd8hNBdc+9bCVbAeMNw8LFACYJ84F8qo2yDJfEhHRERERAQAuw6exVurC00xSQJ+NmsUEgeH+6gq8hWjuQ6u/V9APfgtYGhuc6SgCNgmzIGSkgNJ5q08IiIiIuoeQgi8t+4gcgtOm+JhwTYsfmAswoJsPqqMqG8wmmqglm6FWrIFov5C58kWK6zxE6GkzoBlYAoXmBIREZFf0XQDb64uwomz9ab4pamcVgsbUhH1ZEbNWahleVAdeRCNVR7z5fABsCbnQEmaAjkk2gsVEhF1Pz61J6I+qaFZxUsf7UVVndMUn5ASg4duS+aN6+uknSpES+4HHT4wsMZPhH3KQ5BDorxcGRERUd8hhMC6deuwatUqFBcXo6mpCTExMcjMzMTDDz+M9PT0634Ph8OB9957Dzt37sT58+cRGhqKhIQEzJkzB3PnzoXF4nkT7fVe45ZbbkFFRUWX6s3NzUVMTEyXcol6otIT1Xjpg924YkAnHrkjBeOT+f9tfyJczXAVboDrwFeA2uI+yR4M+9h7W5saWLn4kYiIiIi611e7TmFt7jFTzG6zYPGCDPSPCPRRVUS9mzAM6OUHoJZshnZiPyCMTvPlyEFQUqdDScqGFBDinSKJiIiIehAhBN7/sgTFJ6pN8dioIDzHqZxEPZZwNkI9sgtqWR6Mc4c95ssBwQgZmYOg0dPRYB/ItZtE1OtxAw4R9TmqZuCPqwpRcaHRFE8eHI4n7xsJWeYvcNfKaKyGc/syaEd3uT0uhfZDQPYjsA4d693CiIiI+piWlhY8++yz2LRpkyleUVGBiooKrF27Fs899xyefPLJa36PFStW4De/+Q1UVW2LVVVVoaqqCvn5+Vi9ejXefPNNRERE3LBrNDQ04PTp026PEfU1Zyob8X/+sRcu1Tw9cubU4bh5XJyPqiJvE5oL6qHv4dq/DqKl3n2S1QbbmDthS78Lkj3YuwUSERERkV/YWnAay783L5CxyBKenjsGwwaE+qgqot7LaKj8YdqNp47PFgXWhEmt025iE7nwjIiIiPza2rzjyCs6a4pFhNixZGEGQjmVk6hHEYYOvfwgVEcutBN7AV3r/ARJhmXIGCjJOeg/NhtWux26bqCxqrHz84iIegFuwCGiPkUIgb9vKIGjvNYUj+sXjGfmp0OxsjPCtRCGAfXQt3Dmr3LfnVmywJZxF2zjZ0Gy2r1fIBERUR+zdOnSts03CQkJWLhwIfr164eDBw/i448/RlNTE/7whz8gNjYWs2fPvurrb926Fc8//zyEEAgMDMSDDz6I0aNHo7KyEitXroTD4cDu3buxZMkSvPPOO5Dl9qPdu+MapaWlEKJ1FMi//uu/YsyYMZ3WHR4eftV/VqKeoL7JhVeXF6C+STXFc8YMxNxp8T6qirxJGDpURy5cez7reDGWbIGSdjNs4+6DHMR/74iIiIjoxthx6Cz+9mVJu/iP70nDqHhOtSfqKmHo0E8WwlWyCfqpQkCITvPlqMFQUmdASZrCZgtEREREALYVncEaN1M5/79PTEJUsOKjqojoSnpVeeumm7LtEM21HvPlqCFQkrNhTcyCHBQBAJCs/DtNRH0LN+AQUZ+yfseJdp0RosMDsHhhBoID+IvctdAvHEfL1r/BuHjc7XHLgGTYcx6DJYpdu4mIiLpDXl4e1q1bBwDIysrC22+/Dbu9dYPrzJkzMX/+fDz00EOoqanBiy++iFtvvRUhISFdvr7L5cILL7wAIQSCgoLw4YcfYtSoUW3HFy1ahCVLluDrr79GXl4e1q9fj5kzZ3b7NYDWDTiXzJkzB/Hx3IhAfY+mG3hzdREu1po3so8ZEY1H70php9s+TgiBxpLtaPr+Ixi1ZzvIkmBNmgr7hDmQw2K8Wh8RERER+Zc9pRfwztpiXLlN4NF70jBl9ACf1ETU2xj1F6GWbmmddtNU03my1QYlIQtK2nTIMSN4D4CIiIjon0pOVOO99ebGAJIE/H8enoDEIRGo4oQMIp8yWuqhHd4B1ZEL4+IJj/lSQCisiVOgJGfD0m+YFyokIvItbsAhoj5jT+l5rNp81BSz2yxY+vgkRATyn7urJVxNcOZ/CvXQt+67dtmDETD5AVhTciBJ7TvaExER0bV59913AQBWqxW//e1v2zbfXJKQkIDnn38ev/zlL1FTU4MVK1bgiSee6PL1N27ciPLycgDAT37yE9PGGQCw2Wx46aWXkJ+fj5qaGrz11lvtNs90xzWAHzbg2O12DBvGG3HU9wgh8OHGUjhO1ZjiiYPD8fM5o2C18PfovkoIgeZjBajZvAyus0c6zLMOHw/bxPvZ0ICIiIiIbrgDRyvxl8+KYFxxv3/BrUmYOz0B1dVNPqqMqOcThgbtxH6oJZuhnyoC2m1jM5P7DWuddpOYBckW6J0iiYiIiHqJ0xcb8cdPD0A3zL9T/cus0Zg8eiB03fBRZUT+TegatFMF0Bx50E4WAIbe+QmyBdahY6Ek58AydAwkmeszich/8F88IuoTjp+tw1/XHjLFJAn4fx6egBFx4eyMcBWEENCO5cO57aMOO3dZk3Ngz3oAckCod4sjIiLq42pqarBt2zYAwLRp0zBkyBC3effccw9efPFFVFZWYsOGDVe1AWf9+vUAAEmSsGjRIrc5wcHBmDdvHt599104HA4cO3bMNJ2mO64B/LABJzExEbLMjQjU93yzpxxbCs6YYv3CA7D0iUkQqoeb1tRr6eePwLlrJRpOF3eYYxmUBnvm/bDEJnqxMiIiIiLyVyUnqt0ucJuZHY8f3Z0Gw+h8MwGRvzLqzkMt2Qy1dCtEc13nyUoAlMQsKKkzYIkZ7pX6iIiIiHqb2kYXXltRgCanZorfPnEIZmbHd3AWEd0oQggYF09AdeRCO7IToqXe4zlyTDyU5GwoCVmQAkK8UCURUc/DDThE1OtV1bXg9ZWFcGnmDgiP3TMSWeyMcFWMuvNoyfsA+qkDbo/LEYNgz3kU1kGpXq6MiIjIP+zevRuG0fq7S1ZWVod5siwjMzMTGzZsQEFBAWpraxEeHt6l98jPzwcApKSkICoqqsO8rKystmk8W7ZsMW2e6Y5rCCFQVlYGAEhOTu5S7US9SdGxSnz8bZkpZlNkLP3xZESGBrBJQB+kV1XAlb8S2ol9HebI/YbDPmk+LHGjIEmSF6sjIiIiIn91uKIWr68shHrFM5SbMgbhX2Zd+r2UG3CILhG6Bu34Xqglm6BXHPKYL8eMgJI2HUrCZEhKgBcqJCIiIuqdnKqON1YW4GJtiyk+LqkfHriFzaqIvMloqoFWth2qIw9GdbnHfCkoAkrSVFiTs2GJjPNChUREPRs34BBRr9bi0vDGykLUNrhM8WnpAzH7phE+qqr3EboKV8GXcO1bC+hq+wSLAtv42bCl3wXJwh8dREREN8qlDSmA500piYmtN6KFEHA4HMjMzPR4/XPnzqGurrVbZ1JSUqe5CQkJba9LSkq69RoAUFFRgYaGBtN1GhoaUFJSgsbGRvTv3x/JycmwWCye/lhEPc6Zykb8ec1BiCvWsD37wDgkDo5gk4A+xqi/AOfuNdDKtqGjhYty+ADYMu+HNX4iN94QERERkdecOFuPV5cXwHnFBM6sUbF49M4U/m5KdBmj5ixcJZugOfI8d322BUJJnAolbTos0UO9UyARERFRL2YYAn9dewjHzph/z4ofGIonZ42CLPO7CdGNJjQXtBP7oDryoJcfQLsHmVeyKLAOnwAlObu1sZwse6dQIqJegKuoiajXMkTrl7OT5xtM8dShEfgRHxx1mXa6BM7c92HUnHF73DIkHQHZj0AO6+/lyoiIiPxPRUVF2+u4uM47xwwYMMB0Xlc24JSX/9C9xtP1Y2NjIcsyDMPA6dOnu/UaAFBaWtr2WpZlPP300/juu++g6z8sCoqIiMAjjzyCn/70pwgIYAdR6h0amlW8vrIQzU7NFJ+dE4/s9EE+qopuBKOpFq59a6EWfw8YutscS2g0wnMWwBWXCUnmhkIiIiIi8p7yCw34wyf72303mZASg3+5N40L3IjwzwVox/dALd4E/Uypx3w5NhG2tBmwjsiEZLV7oUIiIiKivmH594ex13HBFOsXHoBfzM+AXeG9c6IbRQgB4/wRqI5cqEd2Aq5mj+dYYpNgTc6GkjAJki3IC1USEfU+3IBDRL3Wqk1HsK/soikWGxmIp+aOgdXCHdeeGM11cO78BJojz+1xKSgC9qkPs0MzERGRF1VVVbW9joyM7DQ3IiKi7XVNTU2Xrl9dXd3l6yuKgqCgIDQ0NJiu3x3XAMwbcP7P//k/bs+vqanBH//4R2zZsgVvvfUWoqKiOn0/Il/TdAN/XlOE89Xmm9eZqf0xK3u4b4qibidcTa0TRA9sBDSn2xwpIBQRU+chPPMuCMmKqqpGL1dJRERERP7sbFUTXv54PxqazRPv0xOi8bNZo2Bh11ryc3p1BdTizVDL8gCnh+9r9mAoSVOhpM6AJarzZjRERERE1N43u09hY/4pUyzIbsVzCzIQHmzzUVVEfZvRUAnVkQe1bBtE7VmP+VJINJTkbChJ2ZDDY71QIRFR78YNOETUK20tOI0vd540xYIDrHh2QQZCAhUfVdU7CGFALd0K587l7h8qSBKUUbfBPnEeJFug9wskIiLyYy0tLW2v7fbOu2jabD/ckL78vM40N/+wKcDT9S/lNDQ0mK7fHdcAzBtwFEXBE088gTlz5mDIkCGoqanB5s2b8frrr+PChQsoLCzE4sWL8d5770H24SKhsLDun8JzqeOwLEuIigru9uuTd7295gCKT1SbYiPiwvH/PDIBdpuVn3cvZ6hO1O/dgLrtq2G0uF+gJdkCEJZ5H8ImzcT/n70/j6+qPPfG/89aa6+9M5OBEAIBEjKTiSlMYRJQHJAZhGqtWmurVbH2PJ7zPD2+evpt7evX03pa59pyHKp1YBBURBxAIIQpTAmEhJ0wJ5AQMo97r+n3R2pkmRFI9k6yP+9/unuta93rikswa6/7um+Lty8EQYBhGLzfAxz/bHsW3m/PwvtNRP3R1eom/PH9o6htcJriiaOC8PMlyVzAjDyWoTqgnjnUsttNWWGX+VJ4POSEWS0L1Vk4MZSIiIjoRhwrvIr3t5t/95JEAT9fmoJhg/ldC1FPMhQH1LOHoNj3QLtUAMDo/ASLDZbREyHHTYcUHg9B4PcFRETdxQYcIup3Cs5X4R9fmLeBl0QBjy1OxtBgbnvYGa2yGI7Mtzt8sSCGRsFr+o8ghUa6tjAiIiICAKiq2vr52gab9lx7/NrzOqNpWrfHvzbn2vF7YgwAKCsrA9DSoPPGG29g4sSJrceGDBmCFStWYObMmVi5ciVKS0uxf/9+bN26FQsWLOjymr1F6sVJSoIgQJK462B/9vnes9i695wpFuRvw7MPTYaPt/nPCu93/2JoKupydqAqcz20+sr2kyQLBk24HYHTlkLyHWQ6xPvtOXivPQvvt2fh/Sai/qKqzoH/fv8oqurMOzXGRAzCE8tSIFskN1VG5D5axUUoBTuhFO4FnE2d5gpe/rDEZUBOmAkpcJiLKiQiIiIamM6V1uKvn5yA8b0egAfvTEDiqCD3FEU0wBiGDu3yKSj2LKhnDwFKVwt3CpCGJUCOmw5L1AQIcs8vQElE5AnYgENE/UpZZSNe2XQcmm5+Ovvh/HgkRga7qaq+z1AccB75GM7cLwBDa5sge8M2aRnkxDkQ3LiqPBERkafz8vruCy5FUTptcHE6v1vJtjuNMIB5xxpFUbrM//YasvzdDoM9MQYAfPDBB6ivr0ddXR3Cw8PbPTcsLAz/+Z//iccffxwAsG7dOrc24Gia3uNjiqLQukOGrnexChH1WceLruL1TcdNMdki4v/+KB1B/rbWf3d4v/sXw9DRmL8P1ZkfQK0qbT9JEOCbMhuBGStgGRQKALzfHoj32rPwfnsWd97v3mz+JqKBqabBiT++fxRXa8yTbSKH+uOp5WnwsvK1MHkOQ2mGcvoAlIJd0K+c6TJfGj6mZbebyPEQJLnLfCIiIiLq3NWaJrywPhdOxfxubdH0KExLbv+9IBF1n157BYo9C0phFoy6q13mC4PCIMdmQI7LgOgX4oIKiYgGNn7TSkT9Rn2Tgr9syEVDs3n19PmTRmBmGleh6oh6/hias96BUV/R7nFL9GTYpq6G6BPo2sKIiIioDR+f73bzczgc3W7AubYp5nrG78q3Odc2BvXEGN/y8/ODn59fp+fPmTMHfn5+qK+vx9GjR6HrOkQ3NQzX1jZDVdtpZr4JwcG+kCQBum6gsrKhR8cm1yirasT/7x+H2iwS8OAdCRjsZzXdV97v/sEwDGgXj8ORvQF6xYUO8yxRE2FNXwoxcBhqNQDfu6e8356D99qz8H57Fnfdb4tFQlAQd/omou6rb1Lw/AdHUVrZaIpHhPri6XvGwseLr4TJM2hXz0HJ3wmlaH+XKz8L3gGQ42dAjp8JcVCYiyokIiIiGvgamxW8sD4XNQ1OU3xa8lAszIh0T1FEA4DhbIRyJhuqPQtaqb3rE6zekEdPbmm6CYuBIHCHbyKinsJvW4moX1A1Ha9uOo6y7708GhszGCtmx7ipqr5Nr6+AY+97UM8dbve4EDAEXhk/hGVEiosrIyIioo4EBAS0fq6uroa/v3+HudXV1a2fg4O7txPgtePX1NR0mqsoChobG9uM3xNjXA9JkjBq1Cjk5eXB6XSiurr6hsci6mmNzSpebGeRgLumjsKUpKFuqopuhlpaCOfB9Z2+uJCGJ8E2aTmk0CgXVkZERERE1L7GZhX/8+ExFJebGwWHBvvgl6vGwc+bu3nQwGY4m6AU7W/Z7ebquS6yBUgRSS273YwaB0HidAkiIiKinqRqOl7ZdAIlV83PJwkjA/HAHQlsACC6ToauQ7t0EsqpPS1zADWl8xMEAVJECuS4jJZnHkvHC34SEdGN4zdKRNTnGYaBd788hYIL1ab4iCF+eGThGIgiH86uZegalBNfwXFoE6C2syq9KME69i5Yxy7gL9lERER9TGRkZOvny5cvY8SIER3mlpaWtn4eNqx7uwF+f/zOlJWVQdf1NuP3xBjXS5Y5WYj6Hl038PonebhcYV4kYFzsYCyZOdpNVdGN0iouwpG9AdqFnA5zxNDRsE1aDsvwMS6sjIiIiIioYw6nhr9syMG50jpTfPAgL/zbqrEY5Mt3ADQwGYYBvfwslIKdUIoOtP8+7BqCT2DLbjcJMyH6h7qoSiIiIiLPYhgG/rHtFPLPV5niwwb74vGlKbBIopsqI+p/tKpLUO17oBTtg9FQ1WW+GDS8pekmZipE3yAXVEhE5NnYgENEfd6X2RexO8c8uXOQrxVrlqfCy8q/xq6lXTmN5sy3oFdcbPe4FJ4A24z7IQXe+ARYIiIi6j3R0dGtnwsLCzFp0qQOcwsLCwEAgiAgNja2W+MHBQUhJCQEFRUVred3pKioqPVzXFxcj45x8eJF7NixAxUVFRg/fjxmz57d6ThlZWUAWhpxBg0a1Gkukaus+6YIx89UmGIRoX74yd1jIHIFt35Dr70Cx6GPoBYdAGC0myMGDYM1fRkso8ZzdT4iIiIi6jMUVcOLG3NRVGzenTbI34b/s3ocggO83FQZUe8xHA1Qiva17HbTwbuwVoIAaUQqrAmzIY1MhSBKrimSiIiIyENt2XsOe46b53cF+Frx1PJU+HhxsT2irhjN9VBO74diz4JefrbLfMHmB0vMFMhx0yEOHsV3WERELsSZ60TUpx0rvIp1O4pMMdki4snlqXx5dA3D0QDHwQ1Q8neivUljgpc/bFNWwRI7jb9sExER9WHjxo2DLMtQFAUHDhzAvffe226epmnIzs4GACQkJCAgIKDb10hPT8e2bduQn5+Puro6+Pv7t5u3f//+1s/fbwS62TGuXLmC3//+9wCAOXPmdNqAc/bs2daddlJSUiBJnCxB7peZcwlfZpsn+vj7yHhyeQoXCegn9MZqOI98AiV/F2Bo7eYIfiGwTVwKS8xUCCJX5iMiIiKivkPVdLyy6USblaUDfK34P6vHITTQ202VEfU8wzCglxXBWbAT6ulsQHN2mi/4BkNOmAk5fgZEvxAXVUlERETk2fadKMWmTHPDgNUiYs3yVAzm8wlRhwxdhXbxOBR7FtTzRwG9/XdWrQQJlpGpsMRNh2VkGgSJ7yWJiNyBf/sSUZ91oawOr3+S16ad5OEFYxAV3v1JpgOZYRhQT++HY9/7MJpq282RE2bDNmk5BC8/F1dHRERE1ysgIABTpkxBZmYmduzYgUuXLmHYsLY713322WeorKwEANxxxx3XdY358+dj27ZtUFUV77//Ph555JE2OfX19di0aRMAICoqCgkJCT06RnJyMvz8/FBfX4/MzMwOf04AeO2111o/L1q06Lp+VqLeYL9YjX98ccoUk0QBjy9NweBBfInU1xmOBjiPfQbnia87nLQleAfAOu5uyImzIUhclY+IiIiI+hZN1/H6J3nIPW3ekdPPW8a/rRqLocE+bqqMqGcZzfVQCvdCKdgJvepS58mCCMvINMiJsyFFpHARBSIiIiIXOnWhCm9szTfFBAA/XZjE+V1EHdCunm9pujm9v8M5f9cSB4+CHDcdlujJEL3554qIyN3YgENEfVJ1vQMvbsyFQzF3dS+ZORrpCUPcVFXfoleXojnrH9BKTrZ7XAyOgNf0H0EaGuviyoiIiOhmPPDAA8jMzISiKHj66aexdu1a+Pl910hbVFSE5557DgDg6+uLFStWXNf48+bNQ0REBIqLi/HKK69g/PjxmDhxYutxp9OJZ555BtXV1QCABx98sMfHsNlsWLlyJd544w0oioJf/vKX+Pvf/276OQHgf//3f/Hxxx8DACIjI7FkyZLr+lmJetrV6ia8suk4NN28TMCPbk9AbESge4qibjEUB5wnvoIzZyvgbGw/SfaGNe0OWFNugyBzx1UiIiIi6nt0w8Abn+Xj8KlyU9zbJuHpe9IQEcqFuKh/MwwDWqkdSv5OqGezAU3tNF/wHww5/l+73fgGuahKIiIiIvrW5YoGvLSx7XuTVfNiMS4u1E1VEfVNemMN1KJ9UOxZ0CsvdpkveAfAEjsNctx0SMERLqiQiIi6iw04RNTnOBUNL23MRWWtwxSfmjQUC6aOclNVfYehOltWbD72GaC38+LBYoVtwhLIKbdCEPnXPBERUX8zffp0zJ8/H1988QWOHj2KRYsWYfXq1QgPD8fJkyfx/vvvo6GhAQDwzDPPIDg42HT+gQMHcP/99wMAJk2ahHfeecd03Gq14le/+hUee+wxNDc344EHHsCKFSswfvx4VFdXY926dbDb7QCA8ePHY/ny5W1q7IkxHnvsMXzzzTc4e/Ysjhw5grvuugv33HMPIiMjUVVVha1bt+LQoUMAWhqN/vSnP8Fms93kP12iG9fsVPHixlzUNSqm+PxJIzA9NdxNVVFXDE2FUrATziOfdLyCmCRDTpoH29i7uHMoEREREfVZhmHgnS9OYV9emSlukyX8YsVYRA7lCrjUf+nNdVDte6Dk74JeU9p5siDBEjmuZbeb4WMgCNzthoiIbpxhGNiyZQs2btyI/Px8NDY2IjQ0FOnp6bj33nuRmpp609ew2+148803ceDAAVy5cgX+/v6Ijo7G4sWLsWTJEkiS1GWN27dvx8cff4zc3FxUVlZClmUMHz4cGRkZuP/++zFs2LCbrpPoetU2OPHndTlodJjnLs2bGIFbJ45wU1VEfYuhKVDPH4Ni3wPt4nHA0Ds/QbLAMmo85LgMSBHJEMTO/xtBRETuwZnZRNSn6IaBtZ/l4+zlOlM8JmIQHrgjAYIguKmyvkEtzkNz1j9g1JS1e9wyahxsGfdB9AtxcWVERETUk/7whz+goaEBe/bsQXFxMf74xz+ajguCgMcffxyrVq26ofHnzJmDX//613juueegKAree+89vPfee6aclJQUvPrqqx2++LnZMfz9/fHmm2/i8ccfx4kTJ1BaWooXXnihTV54eDief/55pKSk3NDPStQTdMPA3z89ieLyBlM8ZXQIVsyOcVNV1BlD16Ge3g/HoU0w6srbTxJEyPEzYZ2wiCslExEREVGfZhgG3t9eiF3HLpniskXEk8tTERMxyE2VEd04w9ChXSpo2e3m3JH2F527hhAwBHLCLMhx0yH68N95IiK6ec3NzVizZg127txpipeUlKCkpASffvopnnrqKTzyyCM3fI3169fjN7/5DRTlu4WdKisrUVlZiezsbGzatAmvvPIKAgMD2z2/pqYGv/jFL5CVlWWKO51O2O122O12/POf/8Rvf/tbLF68+IbrJLpeDkXDixtzcbWm2RQfFzsYq+bEuqkqor7BMAzo5Weh2PdAOX0AcDR0eY4YFgM5NgNy9CQINl8XVElERDeDDThE1KdszjyLQwVXTLHBg7zw+NIUyBbPXcFKb6yGY/8HUIv2t3tc8A2GLeM+yJHjXVwZERER9QZvb2+sXbsWn376KTZv3oz8/HzU1dUhMDAQEyZMwP33348JEybc1DVWr16NiRMn4u2338bevXtRXl4OWZYRFxeHu+++GytXroQsy706Rnh4OD788ENs2bIFn332GfLy8lBbWws/Pz9ERkbitttuwz333ANfX37JSO61afcZHC28aoqFh/jgpwuTIIqevUhAX2MYBrQLx+A4uBF6VXGHeZboybBNXAJx0FAXVkdEREREdGM+2n0GXx8y/34riQIeX5qCxFFsJqf+RW+saZmIVrALRu2VzpNFCZbICS273QxL4G43RETUo371q1+1Nt9ER0dj5cqVGDx4MPLy8vDBBx+gsbERzz//PMLCwrBo0aLrHj8zMxPPPvssDMOAt7c3Vq1aheTkZFRUVGDDhg2w2+04dOgQnn76aaxduxaiaP7vnK7r+PnPf47s7GwAwLBhw7Bs2TKMHj26dRG3L7/8Ek6nE//xH/+BgIAAzJkz56b/uRB1RddbFi07c8m863zkUH88cjffm5Dn0usroRTthWrPgl59uct8wTcYcuw0yHEZEAPDXVAhERH1FMEwDMPdRRC1p6qqEaqq9eiYwcG+kCQRmqajsrLrzmJyrX0nSvH3LSdNMW+bhP/3w4kYPvj6J10OhPttGDqU/J1wHFwPOJvaJggi5JTbYJuwGILs5foC+5CBcL+p+3i/PQvvt+dw1722WCQEBfm47HrUf/EZxTPtyyvF3z81P6f4elnw7I8mYsh1/t3B+9271EsFcGRvgF5W1GGONCIVtvRlkAaP6vV6eL89B++1Z+H99ix8RqG+rDeeTwD+PdcXfbr3HDbtPmOKiYKARxcnY0J86E2NzfvtOdx9rw1Dh1acB6VgF9RzRwGj87+/xEFDISfOgiU2A6J3gIuqHDjcfb/JtXi/PYs77vdAfT7JysrCQw89BACYMmUK/va3v8Fms7UeP336NH7wgx+guroagYGB2L59O/z8/Lo9vtPpxB133IHi4mL4+Pjg3XffRVJSkun4008/ja+++goA8Pzzz2PBggWmMTZu3Ij/9//+X2uNr732Gnx8zPdix44deOKJJ6CqKsLCwvDVV1+Zfg5X4jOK5/hgeyG+zL5oioUEeOE/75+AQX43/u8f77VnGSj321AdUM8ehmLPglZyEkAX07EtVliiJkKOm+5RiwwMlPtN3cP77Tk8+R0Kd8Ahoj6hsLgab36eb4qJgoBHFyXfUPPNQKBdPY/mPW9Dv3Km3eNiWAy8pv8IUsgIF1dGREREROQZTl+qwZtbC0wxSRTw2JKU626+od6jXT0Hx8EN0IpPdJgjhsXANmkFLOHxLqyMiIiIiOjmfHnwQpvmGwHAw3cn3nTzDZEr6A1VUE5lQjm1G0bd1c6TJQssUektu90MjYMgcOV0IiLqPW+88QYAwGKx4He/+12bppXo6Gg8++yz+OUvf4nq6mqsX78eDz74YLfH//LLL1Fc3LKD4cMPP2xqvgEAq9WKP/zhD8jOzkZ1dTVef/31Ng04H374IQDAZrPhT3/6U5vmGwCYM2cO7rvvPrz11lsoKyvD7t27ceutt3a7TqLrtf1wcZvmG2+bBU+tTLup5hui/sQwDGildqj2LChnDgJKc5fnSOHxkOOmwxI1EYLV2wVVEhFRb2IDDhG53ZXqJry08ThUzdwB/oNbY5E8OsRNVbmP4WyC4/BmKCe+BNrbpMzqA9vklZATZnpMFzwRERERkatV1jbj5Y3HoWq6KX7vrXFIHBXkpqroWnp1KRyHPoJ65mCHOWJwBGzpyyGNTOPkLSIiIiLqV3YeLcEHO9ru7vjAHQmYMmaoGyoi6h5D16EV50LJ3wX1Qg5g6J3mi0HDISfOhhwzFYJX93cWICIiulHV1dXYu3cvAGDGjBkYMaL9RU/vvPNO/P73v0dFRQW2bdt2XQ04W7duBQAIgoDVq1e3m+Pr64ulS5fijTfegN1ux9mzZxEVFQUAqK+vR25uLgBg2rRpCA3tuPn69ttvx1tvvQUAyMnJYQMO9ZpjRVfx3td2U0wSBTy+xHMXVybPoteWQynMgmLPglFX3mW+4B8KOW465NhpEAO4iAYR0UDCBhwicqvGZhUvbshFfZNiis+dEIE54yPcVJV7GIYB9dxhOPb+E0ZDVbs5lthpsE1ZBdE7wMXVERERERF5DodTw4sbc1HT4DTF546PwOxxw91UFX1Lr6+E88jHUE5ldjiRS/APhW3iElhipnDhAiIiIiLqd7KOX8Y7X5xqE7/31jjMSBvmhoqIuqbXV0Ap2A3lVCaMhsrOkyUrLNGTYE2YBTEshgsmEBGRSx06dAi63vK94pQpUzrME0UR6enp2LZtG3JyclBTU4NBgwZ16xrZ2dkAgPj4eAQHB3eYN2XKlNbdeHbv3t3agFNVVYWUlBRcvnwZo0eP7vRa19ZUW1vbrfqIrte50lr89eMTbdYRfuCOBCRGdvzvOFF/ZziboJ49BMW+B9rlts/pbchekEdPgiUugzt7EhENYGzAISK30XQdf/34BC5dbTDFU0aHYNXcGDdV5R56XTmas96FdiGn3ePCoKHwmn4/LMPHuLgyIiIiIiLPohsG/vezk7hQVm+Kj4kMwqp5nvWc0tcYzfVwHNsCJe9rQFPbzRG8B8E6YRHk+JkQJH7tRURE1NcYhoEtW7Zg48aNyM/PR2NjI0JDQ5Geno57770XqampN30Nu92ON998EwcOHMCVK1fg7++P6OhoLF68GEuWLIEkSdc9Zk5ODlatWoXw8HDs2LHjpmsk6kx2wRW8sTUf35vXhhWzozF3gmctXEZ9n6FrUC/kQCnYBe1iLtrMyPweMWQE5ITZkGOmQLBxlXQiInKPwsLC1s9xcXGd5sbEtHwnbBgG7HY70tPTuxy/rKystREmNja209zo6OjWzwUFBa2fR4wYgfXr13d5LQA4ffp06+fAwMBunUN0PSpqmvHC+lw4FfOCWAszIpGREu6mqoh6j6Hr0C7lQ7HvgXruMKA6uzhDgBSRBDkuA5bI8RAsNpfUSURE7sOZCETkNu9/XYgTZ80rYA0f7IufLUqCJHrGCsWGrsKZ+wWchz8GtHZ+WZcssI67G9a0OyFIsusLJCIiIiLyMJ9mncOhU+Zt48OCvPHo4mSPeU7pawylGc7jX8CZsw1QmtpPsvrAOvZOWJNuhSDzxQYREVFf1NzcjDVr1mDnzp2meElJCUpKSvDpp5/iqaeewiOPPHLD11i/fj1+85vfQFG+23G9srISlZWVyM7OxqZNm/DKK69c16S0hoYG/Od//mfrCtlEvelY0VX87ZO8Nj0MCzMicceUUe4piqgdel35d7vdNFZ3nmyxQY6ZDDlhNsTQKK4ATUREbldSUtL6efjwznc8Hzp0qOm87jTgFBcXd3v8sLAwiKIIXddx6dKlLsduz8aNG1s/p6Wl3dAYRB1pbFbxlw05qGkwz2mamjQUi6ZHuakqot6hV5dCse+BUri36109AYiB4bDEZUCOmQbRjztBERF5EjbgEJFbbD9cjB1HSkwxfx8Za5anwtvmGX81qaV2ODLfhl5V0u5xaXgSvKbfD3FQmIsrIyIiIiLyTNkFV/DxnrOmmLfNgieXp8LXiw3xrmZoCpST38B59FMYzXXtJ0lWWFNugzXtDq6eTERE1Mf96le/am2+iY6OxsqVKzF48GDk5eXhgw8+QGNjI55//nmEhYVh0aJF1z1+ZmYmnn32WRiGAW9vb6xatQrJycmoqKjAhg0bYLfbcejQITz99NNYu3YtxG40VzudTjz22GOw2+3XXQ/R9co7V4lXNx2Hppu7b26fNJIT26hPMHQV6rmjLbvdFOcBbfZpMhMHR0JOnA05ejIEq7driiQiIuqGysrvJlUHBQV1mntt8351dXW3xq+qqur2+LIsw8fHB/X19d0e/1qZmZn45ptvAAAhISHIyMi47jGIOqJqOl7dfBwl5Q2meMLIQDx4ZwIbq2lAMBwNUE4fgGLPgn7ldNcn2HwhR0+GHDedCwwQEXkwz5jlTkR9yvEzFXjva/MLS4sk4omlqRgcOPC/gDea6+E4sA7Kqd3tHhe8A2Cb+gNYoifzl3QiIiIiIhc5V1qL/91y0hQTBODRxUkID2FjhysZug61MAuOw5th1Fe0nyRIkBNnwTp+IUSfQJfWR0RERNcvKysLW7ZsAQBMmTIFf/vb32Cztexat2DBAixfvhw/+MEPUF1djd///veYO3cu/Pz8uj2+0+nEf/3Xf8EwDPj4+ODdd99FUlJS6/HVq1fj6aefxldffYWsrCxs3boVCxYs6HTMiooKrFmzBtnZ2TfwExNdH/vFary0MReqZm5ouGX8cKy4JZrvCsit9JoyKAW7oNj3wGiq7TxZ9oIcMxVy4ixIgyNdUh8REdH1am5ubv387XNJR6xWa7vndaap6btdvLsa/9uc+vr6bo//rcuXL+Pf//3fW///o48+Ci8vr+saoycFBPTOtUVRaP3f4GB+V+8qhmHg5Q05OHmuyhSPGOKH/3xoMvx8rB2ceeN4rz2LO++3oWtoOnMMDSd2obHwEKApnZ8giPCOHgff5NnwiZkAwcJF+64X/3x7Ft5vz+HJ95oNOETkUsXl9Xht8wkY31sU66E7ExATMcg9RbmIYRgtk8j2f9jB6s0C5DFzYEtfypWbiYiIiIhcqLregZc2HodT1U3xVXNjkRwV4qaqPI9hGFDPHYEzeyP06ksdZAmwxEyBbeISiAFDXFofERER3bg33ngDAGCxWPC73/2uzSS06OhoPPvss/jlL3+J6upqrF+/Hg8++GC3x//yyy9RXFwMAHj44YdNzTdAy6S5P/zhD8jOzkZ1dTVef/31Thtw9u3bh//4j/9AaWlpt2sgulFnLtXiL+tz4FTMzyMZKUNx761xbL4htzA0Beq5I1Dyd0K7lN9lvjhkNKwJs2GJngRBdt/EXyIiou5QVbX187UNNu259vi153VG07Ruj39tTnfHB1p28XnooYdQUdGygFFGRgbuu+++bp/fGySp611Gb4YgCJAk/m7sKh9+fQrbsy+aYoF+Nvz64SkY5N+7v+/xXnsWV95v55XzqMvdifoTu6E1VHeZbx0SCb/U2fBLmgGLX2Cv1+cJ+Ofbs/B+ew5PvNdswPkXwzCwZcsWbNy4Efn5+WhsbERoaCjS09Nx7733IjU19aavYbfb8eabb+LAgQO4cuUK/P39ER0djcWLF2PJkiWQJKnXxzAMA9u3b8fHH3+M3NxcVFZWQpZlDB8+HBkZGbj//vsxbNiwm/5ZidpT2+DEixty0ezUTPGFGZGYkjTUTVW5hlZ1CY49b0O7fKrd42LIKHjN+BGkIaNdXBkRERERkWdzKhpe2ngcVXUOU3zW2GGYNyHCTVV5HrXkJBwHN0AvP9NhjjRyLGyTlkEKHuHCyoiIiOhmVVdXY+/evQCAGTNmYMSI9v9bfuedd+L3v/89KioqsG3btutqwNm6dSuAlhd9q1evbjfH19cXS5cuxRtvvAG73Y6zZ88iKirKlFNZWYlnn30WX3/9dWts2bJl2LNnD8rKyrpdD1F3XSirw/98eKzNe5NJiUPw4B2JENl8Qy6mV1+Gs2AXVHtWB4vJXcPqDTl2GuSE2ZBC+JxGRET9x7W7xCiK0mmTjNPpbP3cnWYawLzrjaJ0savCNdeQ5e7tqFBeXo4HH3wQZ860fJc6atQo/OlPf3J747am6V0n3QBRFCAIAgzDgK4bXZ9AN23X0WK8+3mBKWaVRfy/B9IRGujNe009wlX3W2usQUPeHjSc2AVn2dmu6/IZBN+k6fBLng1rWOR34/TSv/eegn++PQvvt+dw573u7ebvrrABBy1bhK5ZswY7d+40xUtKSlBSUoJPP/0UTz31FB555JEbvsb69evxm9/8xvRgVVlZicrKSmRnZ2PTpk145ZVXEBgY2Gtj1NTU4Be/+AWysrJMcafTCbvdDrvdjn/+85/47W9/i8WLF9/wz0rUHkXV8PJHx3G1xrxl7qTEIVg0PaqDs/o/Q3XAeeRTOHM/B3StbYLsBdvEpZCT5kIQu27CIyIiIiKinmMYBt7aVoCzl2tN8fgRgVxp2kW0K2fgyN4AreRkhzlSeDxs6cshDY11YWVERETUUw4dOgRdb5mkMGXKlA7zRFFEeno6tm3bhpycHNTU1GDQoO7tmp6dnQ0AiI+PR3BwcId5U6ZMad2NZ/fu3W0acAoLC1ubb3x9ffF//+//xYoVKzBnzpxu1UF0PS5dbcDzHx5Do8O80vm42MF4eMEYiCKfR8g1DNUJ9ewhKAW7OlxI7lrS0DjICbNgGT0RgsXWZT4REVFf4+Pj0/rZ4XB0uwHn+zt5dnf8rnybc21jUEcuXLiAhx9+GOfPnwcAhIeH48033+z0OchVamuboartzIu5ScHBvpAkAbpuoLKyocfHJ7NTF6rw0rpjppgA4JG7kzDYz9qr94D32rP05v02NBXqhRyo9j1QL+QCRhd/N4kWWEaNhRyXAWlECiBaUA8A/Pewx/DPt2fh/fYc7rrXFouEoCCfrhN7swa3Xr2P+NWvftXafBMdHY2VK1di8ODByMvLwwcffIDGxkY8//zzCAsLw6JFi657/MzMTDz77LMwDAPe3t5YtWoVkpOTUVFRgQ0bNsBut+PQoUN4+umnsXbtWohi266smx1D13X8/Oc/b30JNWzYMCxbtgyjR49GQ0MD9uzZgy+//BJOpxP/8R//gYCAAL5Qoh5jGAbe/LwARSU1pvjoYQF46M7EATupTb2Yi+Y978CoK2/3uCVqImzT7oXoG+TiyoiIiIiICAC27j+P/XnmlcwHD/LCY0uSYXHziikDnVZ1Cc7sjVDPHe4wRwwZ1bLjTUTKgH1uJCIi8gSFhYWtn+Pi4jrNjYmJAdDynbLdbkd6enqX45eVlaG2tqWhOja284bd6Ojo1s8FBQXt5oiiiEWLFuEXv/gFwsLCurw+0Y24UtWIP35wFHWN5hXRk6KC8bNFfB4h19AqS6AU7IRSuBdwdDFJwuYLOTYDcuIsSEHDXVMgERFRLwkICGj9XF1dDX9//w5zq6urWz93t8nl2vFramo6yWzZIaexsbFb4+fm5uJnP/sZKioqAADDhw/H22+/jeHD+d9m6hmXKxrw8kfHoWrmFezvmRuL8XGhbqqKqHsMw4B+9TwUeybUogMwHPVdniOGjoYclwE5ejIELz8XVElERAOFxzfgZGVlYcuWLQBaVj7729/+1rpiwYIFC7B8+XL84Ac/QHV1NX7/+99j7ty58PPr/n9snU4n/uu//guGYcDHxwfvvvsukpKSWo+vXr0aTz/9NL766itkZWVh69atWLBgQY+PsWnTptbmmylTpuC1114zrbiwYsUK7NixA0888QRUVcV//dd/ISMjo9urNxB1Zsvec20mtYUE2PDE0hRY5YG364veUAXHvvegnslu97jgPxheGffBMnKsawsjIiIiIqJWR+3l2LjrjCnmZZWwZnkq/H06XvGQbo5eXwHHoc1QC/cARvvbUAuDwmCbuBSW0ekQBE48JCIi6u9KSkpaP3c1MWzo0KGm87rTgFNcXNzt8cPCwiCKInRdx6VLl9ocj4yMxBdffIGRI0d2eV2iG1VR04w/vn8MNfVOUzx+RCAeX5oC2cLfgan36IoDyqlMOAt2QS8r6jJfCk+AnDgLlsgJECx8ViYiooEhMjKy9fPly5cxYsSIDnNLS0tbPw8bNuyGxu9MWVlZ646hnY2fmZmJJ598srVZJyYmBm+88QYXDaAeU9vgxF/W56Ch2bxD59wJEbh1YoSbqiLqmt5YDbVwLxR7FvSqki7zBZ9AyLHTYImbDimoe3+vExERfZ/HN+C88cYbAACLxYLf/e53bRpOoqOj8eyzz+KXv/wlqqursX79ejz44IPdHv/LL79sffnz8MMPmxpnAMBqteIPf/gDsrOzUV1djddff71N80xPjPHhhx8CaNkO9U9/+pOp+eZbc+bMwX333Ye33noLZWVl2L17N2699dZu/6xE7TmYX4ZNmWdNMZtVwpPL0zDIb2A1eBm6DuXkdjiyNwJKc9sEQYI17Q5Yx98NwTKwfnYiIiIiov7k4pV6/O3Tk6aYAOCnC5MwPJQrXPUGvakWzqOfQjn5DaCr7eYIvkGwjl8EOX46BNHjv7IiIiIaMCorK1s/BwV1vht4YGBg6+drV5ruTFVVVbfHl2UZPj4+qK+vb3d8Tl6j3lZd78AfPziKilrzO4ToYQF4cnkqbANw0TLqG5xl59CQux11J3bDcDR2mit4+cMSNx3WhFkQA4d2mktERNQfXbszZmFhISZNmtRh7rc7egqC0OWOm98KCgpCSEgIKioqTDuCtqeo6LuG2I52DN2xYweefPJJKErL7olpaWl4/fXXu3z+Ieoup6LhpY25KK82P6eMjRmM1XNjuUM99TmG6oR67giUwixoxSc6XPCtlSTDEjUBctx0SMPGQBC58AUREd0cj57NUF1djb179wIAZsyY0eGKBnfeeSd+//vfo6KiAtu2bbuuBpytW7cCaHkQW716dbs5vr6+WLp0Kd544w3Y7XacPXsWUVFRPTZGfX09cnNzAQDTpk1DaGjHW0LefvvteOuttwAAOTk5bMChm3L6Ug3+97N8U0wQgJ8tTMKIIQNrUptWfhbNmW9Dv3qu3ePS0DjYpv8IUjC3/iUiIiIicqfaBide3JALh6KZ4ituiUFazGA3VTVwGc4mOHO3wXn8i/YXKgAAmy9sYxdATprLFZWJiIgGoObm734H+P4iaN9ntX73u8C153Wmqamp2+N/m1NfX9/t8fuqgACvXhlXFIXW/w0O9u2Va3iqmnoH/rz+IK5UNZnio4cF4Dc/nQY/b9nlNfF+D2y6swkN+XtRf+xr1F3uercbr8gU+I29FT6xEyFIrv/3kXoO/2x7Ft5vz8L73TPGjRsHWZahKAoOHDiAe++9t908TdOQnZ0NAEhISEBAQEC3r5Geno5t27YhPz8fdXV18Pf3bzdv//79rZ/bawQ6ePAg1qxZ09p8k5GRgZdffrndhZeJboRuGPj7lpM4fanWFB811B8/XZjU+vcOkbsZhgG9rAiKPQvKmQOAs6nLc6ShcbDEZUAenQ7Byr83iYio53h0A86hQ4dat/GcMmVKh3miKLY+GOXk5KCmpgaDBg3q1jW+fRCLj49HcHBwh3lTpkxp3Y1n9+7dpgacmx2jqqoKKSkpuHz5MkaPHt1pvdf+XLW1tZ1kEnWuoqYZL208DkXVTfF75sQOqElthrMRjuyNUPJ2AGjbTS/Y/GCbcg8scdO5IgQRERERkZspqo6XNx1vs9p0RvJQzJ/U/qIcdGMM1Qnl5HY4j34Gw1HffpLFBmvqfFhTb+eLDyIiogFMVb/b/e7aBpv2XHv82vM6o2nfNVZ3Nf61Od0dv6+SpN5drVUQBEgSv9PuKfWNTvxm7QFcLDP/bjwizB//30+nYZBf181jvYn3e2BxXD6N2qNfoT4vE4az82ZDyTcQ/mlz4D92LuQg7nYz0PDPtmfh/fYsvN83JyAgAFOmTEFmZiZ27NiBS5cuYdiwYW3yPvvss9YdPe+4447rusb8+fOxbds2qKqK999/H4888kibnPr6emzatAkAEBUVhYSEBNPxiooKrFmzBk6nEwBwyy234MUXX+zWcw9Rd2345jQOnyo3xUICbHhqeSpsVu7QSe6n112FUrgXSmEWjJqyLvMF/8GQYzMgx2VADBjiggqJiMgTeXQDzrXbfHa0jee3YmJiALR00trtdqSnp3c5fllZWWsTS1fbkF67vWlBQUGPjjFixAisX7++y3oB4PTp062fAwMDu3UO0fc1OVS8sCEXtQ1OU3z22GG4dWKEm6rqWYZhQD1zEI6978Foqmk3R46fAevklRC92l/JhIiIiIiIXMcwDLzzxSkUFZt/f48eHoD7b09gw3wPMXQNin0PnIc/htFQ2X6SaIE85hZYx90N0bv7q0YSERFR/+Tl9d1OLYqidDpZ7NuJZUD3mmkA8643364K3ZlvryHL/Xt3B03Tu066AaIoQBCElpVl9baLTtH1a2pW8eu1+3DmkvlZJDzEF7/5yRT4ecu9dj+7wvs9cOiORjSc3IP6Y1/DWXa2i2wBXqPT4J82D94xEyBILVMG3PXvIfU8/tn2LLzfnsVd97u3m7/d4YEHHkBmZiYURcHTTz+NtWvXws/Pr/V4UVERnnvuOQCAr68vVqxYcV3jz5s3DxERESguLsYrr7yC8ePHY+LEia3HnU4nnnnmGVRXVwMAHnzwwTZj/Pa3v21tAEpNTcULL7zA5hvqUTuOFGPbwQummLdNwlMr0ty+SAB5NkNphnr2EBR7FrRL+V2fIHvBEpUOOS4DUngcBGHg/XeLiIj6Fo9uwCkpKWn9PHz48E5zhw79bsWfkpKSbjXgFBcXd3v8sLAwiKIIXddx6dKlHh3jemzcuLH1c1pa2g2NQZ5N1w387ZM8FJebV3FLHBWEH9waNyAmtem1V9C85x/Qik+0e1wMGgbb9B/BEh7v4sqIiIiIiKgjX2ZfxJ7jl02xkAAbHl+aCtnCL+JvlmHoUM8egiP7Ixg1pe0nCQIssdNgm7AYon+oawskIiIit/Hx+W6nO4fD0e0GnGsba65n/K58m3NtY1B/VFvbDFXVuk68TsHBvpAkAbpuoLKyocfH9zQORcNf1uXAfrHaFA8J8MLTK9MAVXPrP2fe7/7NMAzo5Weg5O+EcvoAoDo7zZf8guGXegvUUVMg+oeiGUBzjQNA1393Uv/CP9uehffbs7jjflssEoKCBt7u1dOnT8f8+fPxxRdf4OjRo1i0aBFWr16N8PBwnDx5Eu+//z4aGlr+GT/zzDMIDg42nX/gwAHcf//9AIBJkybhnXfeMR23Wq341a9+hcceewzNzc144IEHsGLFCowfPx7V1dVYt24d7HY7AGD8+PFYvny56fzTp09j27Ztrf//9ttvR2ZmZpc/V2BgoKnRh6gjOUVX8c+v7KaYJAr4+ZIUDA/16+Asot5jGDq0y6eg2PdAPXMIULt6ThEgDU+EHJsBS9RECDKbxoiIyHU8ugHn21UCACAoKKjT3Gt3g/l29YGuVFVVdXt8WZbh4+OD+vp60/g9MUZ3ZWZm4ptvvgEAhISEICMj47rHIFr3TRFyTleYYkODffDYkmRY+vmqKIamwJnzOZxHPwW0dlZSlKywTlgIa8rtrauFERERERGR++Wevop13xSZYlZZxBPLUjHIlysG3gzDMKAVn4AjewP0q+c7zLNEToA1fSmkoM4XFyEiIqKBJyDgux3vqqur4e/f8Y7h177b+P4Et+6MX1PT/m7l31IUBY2Njdc1PtGNUlQdL390HKe+13wT6GfF/1k9FiGD+ncTGLmP4WiAUrgPSsEu6JUXO08WBEgjUhGcfjv84iZANwRO0CciIvqXP/zhD2hoaMCePXtQXFyMP/7xj6bjgiDg8ccfx6pVq25o/Dlz5uDXv/41nnvuOSiKgvfeew/vvfeeKSclJQWvvvoqJEkyxTdv3gzD+G6Xo//+7//u1jXbawYi+r7zpXX468d5ML63kdaPbk/AmEg+K5NrKVWX4cj+CkrhXhj1FV3mC4OGQo7LgBw7DaJfiAsqJCIiasujZ4g3Nze3fu5qJbVrV2S79rzONDU1dXv8b3Pq6+tN4/fEGN1x+fJl/Pu//3vr/3/00UfdvvpbQEDPX18Uhdb/DQ727fHxPd0X+8/jy2zzF/3+PjJ+/ZMpCA9x/T/vnrzfzefzUPHl36FWlLR73Gv0OATf9mPIgWE3dR26cfzz7Vl4vz0L77fn4L0mot5QcrUBr3/S9kXSTxYkYWRYx5M/qWtaWREcBzdAu1zQYY40LBG2ScshDYl2YWVERETUl0RGRrZ+vnz5MkaMGNFhbmnpdzvpDRs27IbG70xZWRl0Xb+u8YluhKrp+OvHJ5B3ttIU9/eR8W+rxmHIAFxFnnqXYRjQyoqg5O+EeiYb0Drf7UbwDYacMAty/AyIfsHwCfaFIIqApruoYiIior7P29sba9euxaefforNmzcjPz8fdXV1CAwMxIQJE3D//fdjwoQJN3WN1atXY+LEiXj77bexd+9elJeXQ5ZlxMXF4e6778bKlSshy3Kb877dHYeop1XWNuMvG3LgUMw7qt49LRLTU8PdVBV5GsPZiLpj+9BwYhccxR2/Y2pl9YYcPRly3HSIQ6IhCELvF0lERNQJj27AUVW19fO1DTbtufb4ted1RtO++0W1q/Gvzbl2/J4YoyuVlZV46KGHUFHR0kGckZGB++67r9vn9xapF3dLEQQBksRfxHpSjr0cf9t83BSzSAL+3wOTEDHEvZPabuZ+aw01qNj+D9Qf39nucckvGCHzH4Jv/BT+ct9H8M+3Z+H99iy8356D95qIekp9k4KXNuSiyWF+kbRk5mhMiA91U1X9n1ZZDGf2Rqjnj3aYI4ZGwZa+HJaIJBdWRkRERH1RdPR3jbiFhYWYNGlSh7mFhYUAWp4LY2NjuzV+UFAQQkJCUFFR0Xp+R4qKvtsVMS4urlvjE10vXTewdstJHC28aor7elnwy3vGYthgLjpC3Wc010MpzIKSvwt69aXOkwURllFjISfMhhSR3NJwQ0RERJ0SBAELFy7EwoULr+u8yZMn49SpU93KjY2Nxe9+97vrGv/111+/rnyi7mhsVvHn9TmoqTc3c09NCsPiGVFuqoo8haHr0EpOQLFnQT13BNCUzk8QBEgRKZDjpsMyaiwES9dzZ4mIiFzFoxtwrt3hRVGUThtcnM7vfvHsTiMMYN6xRlG6+IXhmmtcu7JBT4zRmfLycjz44IM4c+YMAGDUqFH405/+1CcaCbReWIFJFAUIggDDMKDrRtcnULcUX6nD798+CO17/0wfXZaGxMjgXrmX3XEz99swdNTnfoPqb96B3tzQNkEQ4D/hTgTOuAeizftf4/PfKXfin2/PwvvtWXi/PYc773VvNn8TkXuomo5XNx3HleomU3xS4hAsmDrKTVX1b3ptORyHN0Et3IeOnn/EwHBYJy6FJWpin/hugYiIiNxv3LhxkGUZiqLgwIEDuPfee9vN0zQN2dnZAICEhAQEBAR0+xrp6enYtm1b64rV/v7tLwq1f//+1s+dNQIR3SjdMPDm5/k4mH/FFPeySvjFyrHchZO6xTAMaJdPQSnYCfXsIUDrfOFFwT8UcsLMlt1ufAJdUyQRERER9SuqpuO1zcdRUm6eAxU/IhAP3JHI7/Op12hVJVDtWVAK98JorO4yXwyKgByfAUvMVD7fEBFRn+XRDTg+Pt9t7+5wOLrdgHNtU8z1jN+Vb3OubQzqiTE6cuHCBTz88MM4f/48ACA8PBxvvvkmgoODuzzXFWprm6GqWteJ1yE42BeSJEDXDVRWttNUQdetvknB794+hMZm85f/d04ZhXGjg936z/lG77dWeRHNmW9DLytq97gYGgWvGQ8Ag0ehukEHGvjvUl/AP9+ehffbs/B+ew533WuLRUJQkE/XiUTUbxiGgfe+sqPgQrUpHhXuj4fu5Iuk66U3VsN55FMoBTsBvf3ndME3GLaJS2CJnQZBlFxbIBEREfVpAQEBmDJlCjIzM7Fjxw5cunQJw4YNa5P32WefobKyEgBwxx13XNc15s+fj23btkFVVbz//vt45JFH2uTU19dj06ZNAICoqCgkJCTcwE9D1DHDMPDPr+zIOl5qilstIp5akYbRw7rfVEaeSW+qhWrPgrNgF4ya0s6TBQmWqPGQE2ZBGj4GgsDFZYiIiIiofYZh4N0vTyHvXJUpHh7ig8eXpUC28HdJ6llGcz2Uov1QCrOgl5/tMl/w8oclZgrkuAyIIaP4Ho+IiPo8j27AuXb1tOrq6g5XRPv2+Le626By7fg1NTWd5iqKgsbGxjbj98QY7cnNzcXPfvYzVFRUAACGDx+Ot99+G8OHD+/0PKJrqZqOlz9qu6L0+LhQLJ012k1V3ThDccBxeDOU418ARju79sjesE1aDjnxFggiHz6JiIiIiPqqHUdKsPPYJVMs0M+Kx5emwiqzOaS7DEcDnDmfw3niS0B1tpsjePnDOm5By3OSpXs7BhMREZHneeCBB5CZmQlFUfD0009j7dq18PPzaz1eVFSE5557DgDg6+uLFStWXNf48+bNQ0REBIqLi/HKK69g/PjxmDhxYutxp9OJZ555pvVdz4MPPnjzPxTRNQzDwPpvTuObIyWmuEUS8cTyVMSNCHRPYdTnGYYO7VIBlPydUM8d7nDRg28JAWGQE2a1TEzzGeSiKomIiIioP9u6/zx251w2xfx9ZKxZkQZfL9lNVdFAY+gqtAvHodj3QL1wrMtnG4gSfGImwDd5NpqC4iBIHj2VmYiI+hmP/q9WZGRk6+fLly9jxIgRHeaWln63ylB7K7N1Z/zOlJWVQdf1NuP3xBjfl5mZiSeffLK1WScmJgZvvPEGwsLCOh2f6FqGYeAf207BfrHaFB8V5o+fLBgDsZ91oqvnj6I5610Y9RXtHrdET4Zt6mpubUlERERE1Mflna3E+18XmmKyRcQTy1IR5N+9HW09naE64DzxNZw5WwFHBzuSyV6wpt4Ba8ptEKzeri2QiIiI+p3p06dj/vz5+OKLL3D06FEsWrQIq1evRnh4OE6ePIn3338fDf/aafyZZ55ps8jYgQMHcP/99wMAJk2ahHfeecd03Gq14le/+hUee+wxNDc344EHHsCKFSswfvx4VFdXY926dbDb7QCA8ePHY/ny5S74qcmTfLznLLYdvGCKSaKAx5YkIymyewv7kWfRG6uh2PdAyd8Fo66882TRAkvURMiJsyCFJ3A1aCIiIiLqtv0nS7Fx1xlTTLaIeHJ5KoYE8rt9ujmGYUCvuNDSdFO0H0ZzXZfniIMjIcdlIHTiHFj9A6FpOporO3gXRURE1Ed5dANOdHR06+fCwkJMmjSpw9zCwpbJO4IgIDY2tlvjBwUFISQkBBUVFa3nd6SoqKj1c1xcXI+Oca0dO3bgySefhKIoAIC0tDS8/vrrCAoK6vLnIbrWtgMXsOe4uSks0M+KJ5enwmbtPytK6/UVcOz9J9RzR9o9LgQMgdf0+2GJSHZxZUREREREdL1KKxvx2uYT0A3DFP/xXYmICg/o4Cz6lqGrUAp2w3nkExiN1e0nSRbIY+bCOm4BRK+OdxImIiIi+r4//OEPaGhowJ49e1BcXIw//vGPpuOCIODxxx/HqlWrbmj8OXPm4Ne//jWee+45KIqC9957D++9954pJyUlBa+++iokqf98h0193+f7z+OTrHOmmCAAjyxMwtiYwe4pivokQ9ehlZyAkr8L6vljgNH5itBiYDjkhFmwxGXw+YuIiIiIrpv9YjXe+CzfFBMAPHL3GEQP426KdOP0xhqoRfug2PdAryzuMl/wHgRL7DTIcdMhBQ8HAEg+vr1dJhERUa/x6AaccePGQZZlKIqCAwcO4N577203T9M0ZGdnAwASEhIQEND9STvp6enYtm0b8vPzUVdXB3//9r8c3b9/f+vn7zcC9cQYAHDw4EGsWbOmtfkmIyMDL7/8Mnx8fLr98xABwOFT5diw87QpZpVFrFme1m9WlDZ0DcqJr+A4tAlQHW0TRAusY++CdexdECxW1xdIRERERETXpaFZwQsbctHoUE3xu6dFYlIid3ztjGHoUE8fhOPQRzBqr7SfJAiQ42bAOmERRL8Q1xZIREREA4K3tzfWrl2LTz/9FJs3b2595xEYGIgJEybg/vvvx4QJE27qGqtXr8bEiRPx9ttvY+/evSgvL4csy4iLi8Pdd9+NlStXQpblHvqJiIDth4ux/nvvSwS0LAKQnjDEPUVRn6M3VEE5tRtKwW4Y9RWdJ0syLKPTISfOhhQWy91uiIiIiOiGlFY24qWNuVA184Jl98yJwYR4PqvQ9TNUJ9QLx6DYs6BdPA4YeucnSBZYRo1vabqJSIIgcjEUIiIaODy6AScgIABTpkxBZmYmduzYgUuXLmHYsGFt8j777DNUVlYCAO64447rusb8+fOxbds2qKqK999/H4888kibnPr6emzatAkAEBUVhYSEhB4fo6KiAmvWrIHT6QQA3HLLLXjxxRdhtbKxgK7P+dI6/H1LHq59PGtZHSEJo4b2j9W3tLIiNO95G3rFxXaPS8MS4TX9foiB4S6ujIiIiIiIboSm6/jrx3koq2w0xSfEh2LRjCg3VdX3GYYB7WIOHNkbO3w+AgDL6HTYJi7lMxIRERHdNEEQsHDhQixcuPC6zps8eTJOnTrVrdzY2Fj87ne/u5HyOrRjx44eHY8Ght05l/DPr+xt4j+cH49pyfzd2dMZug7tYi6Ugl1QLxwDvrdT6/eJQRGQE2dBjp0GwcaVoImIiIjoxtU2OvGXdTloaDYvWDZ3fARuTR/hpqqoPzIMA/qV01DsWVBOHwCcjV2eI4bFQI6bDnl0Op9tiIhowPLoBhwAeOCBB5CZmQlFUfD0009j7dq18PPzaz1eVFSE5557DgDg6+uLFStWXNf48+bNQ0REBIqLi/HKK69g/PjxmDhxYutxp9OJZ555BtXV1QCABx98sFfG+O1vf9vaRJSamooXXniBzTd03arqHHhhQw6cirmDffnsaIyPC3VTVd1nOBrgOLgeSv4uAG1fdAhe/rBNXQ1LzFSuKEZERERE1I98uKMIeWcrTbGRQ/zw8F1jIPJ3+3appXY4D26AVtp2wuC3pIhk2NKXQwqNdF1hRERERET9wP68Urz9eUGb+Kq5sZg9brgbKqK+Qq+vgFKwG8qpTBgNlZ0nS1ZYoifDmjgL4pBovpsiIiIiopvmVDS8tDEXV6qbTPG06BCsnscdFql79PpKKIV7odr3QK8p7TJf8A2GHJcBOTYDYuBQF1RIRETkXh7fgDN9+nTMnz8fX3zxBY4ePYpFixZh9erVCA8Px8mTJ/H++++joaEBAPDMM88gODjYdP6BAwdw//33AwAmTZqEd955x3TcarXiV7/6FR577DE0NzfjgQcewIoVKzB+/HhUV1dj3bp1sNtbJruMHz8ey5cvb1PjzY5x+vRpbNu2rfX/33777cjMzOzyn01gYKCp0Yc8m8Op4cUNuaiud5ri01PCcfvkkW6qqnsMw4BSuBeO/R/AaKptN0dOnA3bpBXsvCciIiIi6md2HSvB14eKTbEAXyueWJYKm5Xb2X+fdvU8HNkboV3M7TBHHBIN26TlsAxLdGFlRERERET9w+FT5Vi7Jb/NMl9LZo7GbVxN2iMZugr1Qg6U/F3QLh5He4vAXUsMGQk5cTbkmCkQrD6uKZKIiIiIBjzdMLB2y0mcLjHPjRoV5o+fLkqCKLL5hjpmqA6oZw9DsWdBKzmJrp5rYLHCEpUOOS4D0rAECILokjqJiIj6Ao9vwAGAP/zhD2hoaMCePXtQXFyMP/7xj6bjgiDg8ccfx6pVq25o/Dlz5uDXv/41nnvuOSiKgvfeew/vvfeeKSclJQWvvvoqJKn9yUE3M8bmzZthXLOt+X//9393q+72GorIM+mGgb9vOYnzZXWmeNyIQNx/e3yfXh3BWVGCq5//Dc3nT7R7XAyOgNeMByCFxbi4MiIiIiIiulmnLlTh3S/NO7hYJAGPL01ByCAvN1XVN+k1ZXAc2gT19P4Oc8Sg4bCmL4Nl1Lg+/ZxHREREROQuuacr8NePT0A3zBOR7po6CndPi3RPUeQ2em05lIJdUOx7YDRWd54se0GOngw5cTbEwZF85iIiIiKiHrdh52kcOlVuigUH2LBmRSq8rJwmSm0Zhg6ttBCqfQ+UM9mA0tzlOVJ4AuS4DFiiJkKwerugSiIior6Hv1kB8Pb2xtq1a/Hpp59i8+bNyM/PR11dHQIDAzFhwgTcf//9mDBhwk1dY/Xq1Zg4cSLefvtt7N27F+Xl5ZBlGXFxcbj77ruxcuVKyLLcK2N8uzsO0Y36aNcZHLGbH9CGBHrj8aUpsEh9s3vd0BRUZ36Imv2bAU1tm2CxwjZxCeTkWyGI/KuQiIiIiKi/uVLdhFc2nYCmmye+PXBHAmKGD3JTVX2P3lAF55GPoRRkAobWbo7gPxi2CUtgiZkKQeybz3hERERERO6Wf74Kr2w63uYZ5NaJI7B05mg3VUWuZmgq1PNHoeTvhFaS12W+GBoFOWEW5OjJnJxGRERERL3mm6Ml2HbgginmbZPw1Io0BPrZ3FQV9VV67RUo9iwohXth1JV3mS8EDIEclwE5dhpE/1AXVEhERNS3cdb5vwiCgIULF2LhwoXXdd7kyZNx6tSpbuXGxsbid7/73Y2Ud1NjvP766zd1TfJse3IvY+v+86aYj82CNStS4efdedOYu+g1pWja/hr0q+fbPW4ZNQ62jPsg+oW4uDIiIiIiIuoJTQ4VL23IRX2TYorfMWUkpiWHu6mqvsVoroczZyucJ74GNGe7OYJ3AKzjFkJOnA1B4ldEREREREQdKSquwYsbcqGouik+a+wwrJobw91MPIBeUwqlYHfLbjdNtZ0ny96QY6dCTpgFafAo1xRIRERERB4r9/RVvPulef6iJAp4bEkKIkL93FQV9TWGswnqmWwohVnQLndjvqvsDTk6HZa4GZDC+NxLRER0Lc6uIKIOnbpQhbe3FZhiLQ9oyQgP8XVTVZ1TCveiec8/2t0SU/ANhi3jPsiR491QGRERERER9QRdN/D6J3koudpgio+NGYxlM6PdVFXfYSgOOE98CWfOVsDZ1H6S1RvWtDthTb4NgsyV74iIiIiIOnOutBZ/Xn8MDsW8o+TUpKH44fx4TkIawAxNgXr2MJSCXdAu5XeZL4bFwJowC5bRk/isRUREREQucb60Dq9tzoNh3qgT98+PR1JksHuKoj7D0HVol05CsWdBPXu4wwXbWgkCpOFJkOOmwxI5HoLF6ppCiYiI+hk24BBRu8qqGvHyR8eh6eYntPtui8OYPviAZijNaN7zDtTCrLYHBRFyynzYJiyCIHu5vjgiIiIiIuoxG3adRu7pClNseKgvfnL3GIii5058MzQVSv5OOI9+0vFqzJIMa/KtsKbdCcGLq94REREREXWluLwez39wDE0Oc/PNxPhQPHRXAkQ23wxIWvUlKPm7oNqzYDjqO0+2+kCOy2jZ7SY4wjUFEhEREREBqKxtxgsbctosFrBgWiRmpA1zU1XUF+jVl6HYs6AU7oXRUNllvhg4DJa46ZBjp0L0DXJBhURERP0bG3CIqI2GZgUvrM9FQ7Nqit+WPgKzxg53U1Ud066eQ9P212DUlLU5JocMx+CFa1AvD3FDZURERERE1JOyjl/GtgMXTDE/bxlPLkuFt80zv+IwdB1q0T44Dm+GUVfefpIgQk6YCev4RXxxQkRERETUTaWVjfjTB8favCtJjQ7BIwuTIImimyqj3mCoTqhnD0HJ3wmt1N5lvjQ0DnLCLFhGp3NVaCIiIiJyuSaHir+sz0V1vXlHkyljwrBkRpSbqiJ3MhwNUE4fgGLfA/3Kma5PsPlCjp4COS4DYmgUd3clIiK6Dp45O4WIOqRqOl7ddAKllY2meFp0CFbeEuOmqtpnGAaUE1/BcWAdoKttjvulzsHg+T+GIVmBygY3VEhERERERD2lqLgGb28rMMUkUcDPlyQjNNDbTVW5j2EYUM8fhTN7I/Sqkg7zLNFTYJu4BOKgMBdWR0RERETUv5VXN+GP7x9FbYN5MlviqCD8fEkyLBKbbwYKrbIYSsEuKPYswNnYaa5g84Pl291ugriiOBERERG5h6rpeG3zCRSXm3drjBsRiAfvTGQjhQcxdA3axeNQ7Hugnj/W7vw5E0GCZWQqLHEZsIxMgyDJLqmTiIhooGEDDhG1MgwD//zKjvzzVaZ4RKgfHlmYBFHsOw9oenMdmneuhXYhp+1B2RteMx9ASPociJIITdNdXyAREREREfWYqzVNePmjXKiaYYr/cH484kd63o4u6qV8OA5ugH7ldIc50ohU2NKXQRo8yoWVERERERH1f5W1zfjj+0dRVecwxWMjBuHJZamQLZKbKqOeYigOqGcOwlmwC3pZUZf50rDElt1uIsdztxsiIiIicivDMPDul6dw4mylKT402AePL02BbOFiAZ5Aq7jY0nRTtA9GU22X+WLISMhxGbDETIXoHeCCComIiAY2NuAQUauvDhVj17FLpliArxVrlqfC29Z3/rpQL+WjecfrMBqr2xwTQ0fDe+7PIAYMcX1hRERERETU45qdKl7aeBy1jYopfuvEEZiZ5lkrDmvl5+DI3gCt+ESHOdLQOFjTl8ESHu/CyoiIiIiIBoaaBif+9MExXK1pNsWjwv3x1Io02KxsvunPtKvnW3a7KdwHKE2d5gpe/pDjZ0BOmAlx0FAXVUhERERE1Lmt+89jd85lU8zfR8ZTK9Pg583dTAYyvakWatE+KPYs6BUXuswXvANgiZkKOW46pJARLqiQiIjIc/SdGfVE5FbHiq7iw+2FpphsEfHEshSEDPJyU1Vmhq7BeeRjOI98CsBoc9yadies6UshiPyrjYiIiIhoINANA2u35OPilXpTPDkqGCvnRLupKtfTqy/DcegjqGeyO8wRg0fANmk5pBGpEIS+s3spEREREVF/Ud+k4PkPjqK0stEUjwj1wy9Wju1TC5VR9xnOJiinD0Ap2AW9/GyX+dLwJMiJs2EZNQ6CxHtORERERH3HwfwybNx1xhSTLSKeXJaKIYHebqqKepOhKVAv5EC1Z0G9kAsYWucniBZYRo2FHD8dUkQKBJGLSBAREfUGfmtIRLh4pR6vf5LXpqXlx3clInrYILfU9H16fQWad7wOrdTe5pjgHQCvWx6BJSLZDZUREREREVFv2Zx5Fkfs5abY0GAf/GxREiRRdFNVrqPXV8B5+GMo9j2AobebIwQMgW3iUliiJ0EQBv4/EyIiIiKi3tDYrOJ/PjyG4vIGUzw8xAf/tmosV5LuZwzDgH71HJT8nVBOHwCU5k7zBe9B3+12EzDERVUSEREREXWf/WI11m7JN8UEAD9ZMAbRw/vG3C7qGYZhQC8/C8WeBeX0fsDR0OU54pDRkOOmQx49CYKXnwuqJCIi8mxswCHycDX1Dry4IQcOp7lDfsmMKExKDHNTVWbK2cNo3v1Guw8U0vAkeN3yE4g+ga4vjIiIiIiIes3+k6XYsvecKebrZcGa5anw8RrYk9/05jo4j26BcnI7oKnt5gg+gbCOXwg5YSZ3ASUiIiIiugnNThV/WZ+Dc6V1pnhooBf+bdU4BPha3VQZXS/D2QilaD+U/F3QK853kS1AGpECOXEWLCPT+FxFRERERH1WWWUjXtqYC1UzL9S14pYYTExgA/lAoTdUQSncB7VwD/SqS13mC75BkGMzYImbBilwmAsqJCIiom/xm0QiD+ZUNLz00XFU1DpM8SlJYVgwLdI9RV3DUJ1w7P8AyskdbQ8KEqzpy2BNu52rPBMRERERDTBnLtXiza0FppgoCHh0cTLCgn3cVFXvM5xNcB7/As7cbR2v0GzzhTXtLliT50Kw2FxbIBERERHRAKNqOl7aeBxFJTWmeJC/Df9n1TgE+fN37r7OMAzoV07Dmb8L6pkDgOrsNF/wDYIcPxNy/AyI/oNdVCURERER0Y2pbXTiz+ty0NBsXqzrlvHDMX/SCDdVRT3FUJ1Qzx2BYt8DrSQPMIzOT5CssERNgByXAWnYGAgi58wRERG5AxtwiDyUbhh4Y2s+zlyqNcVjhg/Cg3ckQBAEN1XWQqu6hObtr0GvvNjmmOA/GN5zH4U0JNoNlRERERERUW+qqnPgpY9yoajmldx+cGssxkQGu6mq3mWoTij538B5dAuM5rr2kyxWWJNvgzXtDgg2X9cWSEREREQ0ABmGgXe/tCP/fJUpPsjXimdWj8PgQG83VUbdYTgaoBTubdntpqq482RBgDQiDdbE2ZBGpEAQJdcUSURERER0ExRVw8sbj+NKdZMpnhodgh/Mi3X73C66MYZhQCsrgmrfA+X0QUBp6vIcaWgc5LjpsIxOh2DlsyoREZG7sQGHyEN9sucsDuZfMcUGD/LC40tTIFvc9+LBMAwop3bDsfef7a5SZhk9CV4zH4BgHbirXhMREREReSqHouGljbmoqTc/C9wybjjmjI9wU1W9x9A1qIV74Ti8GUZ9RftJogQ5cTas4+6G6BPo0vqIiIiIiAayHUdKsDvnkinm5y3j31aNHdA7b/ZnLRPVCqHk74R6JhvQlE7zBb8QyAkzIcfNgOg3MBd0ICIiIqKBSTcMrN2S32a3zpFhfvjZoiRI3Pmk39HrrkIpzIJi3wujtqzLfME/FHLsNMhxGRADhrigQiIiIuouNuAQeaB9eaX4JOucKeZllbBmeSoCfK3uKQqA4WxE8+63oJ452PagZIUt417I8TO5ggMRERER0QBkGAbe3JqPc6XmHWASRwVh9bxYN1XVOwzDgHImG85DH0GvvtxBlgBL7FTYJiyBGBDq0vqIiIiIiAa6k+cq8f7XhaaY1SLiFyvTMDzUz01VUUeM5noo9iwoBbugV1/qPFmQYBk1FnLiLEjDkyFwYiIRERER9UMbd51GdoF5YeXgABvWLE+Dl5VTPvsLQ2mGevYQlFN7oF0u6PoE2Qvy6HRY4qZDGhoLQeDzDBERUV/E38aIPExRcQ3e3JpvigkC8OjiZLe+VNKunEHT9tdg1JW3OSYGR8Br7qOQgoa7oTIiIiIiInKFT/eea7NL55BAbzy6OBkWaeC8YGg8m4PKb/4J5+XTHeZYRo2DNX0ppOARLqyMiIiIiMgzlFU14rXNJ6Abhin+4wVjEBUe4Kaq6PsMw4B2uQBK/i6oZw8ButppvuAfCjlxFuS46dw9lIiIiIj6tZ1HS/D5/gummJdVwlPL0xDkb3NTVdRdhqFDu1QAxZ7V8iyjOro4Q4A0fAzkuAxYIidAkHmPiYiI+jo24BB5kKvVTXjpo1yomvml0g/mxSFldIhbajIMHc6cbXBmbwQMrc1xecwc2KasgmBx3848RERERETUuw4VXMHmzLOmmLdNwpPLU+HnLbupqp6lXTmDsi82ofn88Q5zpPB42CatgBQW48LKiIiIiIg8R2Ozihc35KKh2dzMcfe0SKQnDHFTVXQtvakWqn0PnAW7YNSUdZ4sSrBEToCcMAvS8ESuDk1ERERE/d7xMxV490u7KSaJAn6+JAURQ7hbZ1+m15S27NxZuBdGfUWX+eKgobDETYccOxWin3vm7REREdGNYQMOkYdocqh4YUMu6hoVU3zu+AjMnRDhlpr0xho07/w7tOITbQ9afeA168eQoya4vjAiIiIiInKZ86V1WPvZSVNMEICfLkzGsMG+bqqq52hVl+DM3gj13OEOc8TBo2BLXw4pIhmCILiwOiIiIiIiz6HrBv72aR4uVzSa4uPjQrFoRpSbqiLgXytEl5yEUrAL6rkjgN52wbZrCYPCYE2YDUtcBkRv7lpERERERAPDhbI6vNrObp0/nB+PpKhgN1VFnTEcDVDOZEOx74FeVtT1CVYfyNGTIcdPhxg6mu+EiIiI+ik24BB5AE3X8deP81BytcEUT44Kxqp57llZWS0+geZv/gajqbbNMSksFl5zf8bufiIiIiKiAa6m3oGXPsqFU9FN8XtuiUFqdP9+HtDrK+A4tBlq4R7gey/LviUMGgpb+lJYoiZypWYiIiIiol62cddp5J42r0IcEeqHhxckQuSkJ7fQG6uhnMqEUrAbRl1558mSBZaoiS273YQncKIaEREREQ0olbXN+Mv6HDic5mb0u6aOwsy0YW6qitpj6Bq04jwo9j1Qzx8BNLXzEwQR0ogUyHEZsIwcC8FidU2hRERE1GvYgEPkAT7cXoTjZ8wvlYYN9sXPFiVDEl07ycvQVTizP4IzZ2s7RwVYx98N6/hFEETJpXUREREREZFrKaqGlz86jspahyk+IzUct6aPcFNVN09vqoXz6BYoJ3cAevsvXST/EFjGLYQcN53PPkRERERELrDvRCk+P3DBFPPzlvHkshR4Wfm61JUMXYdWfAJKwU6o548Bht5pvhg4DHLiLMixGRC8/FxTJBERERGRCzU2q/jL+hxU1ztN8cljwrBk5mg3VUXfp1WWtDTdFO2D0VjdZb4YHAE5bjosMVMg+gT2en1ERETkOvxGmWiA++rQRXx9uNgU8/OWsWZ5Kny8XPtXgF57BU3b/wq9/EybY4JPILzm/BSWYYkurYmIiIiIiFzPMAy89fkpnL5k3hEzLmIQfjg/vl+uZGw4m+A8/gWcudsApbndHNHbH4HTlsJ37K2orutiRTQiIiIiIuoRZy7V4s3PC0wxSRTw8yXJGBzo7aaqPI9eX9my282p3TDqKzpPlmRYRk+CnDgbUlhMv3xGJCIiIiLqDlXT8drm4ygubzDF40YE4qE7uVunu+nNdVCL9kOxZ0G/eq7LfMHLH5aYKZDjpkMMGclnGSIiogGKDThEA9iBk2X44OtCU8wiCXhiWQpCXfxSSTl9AM273wKUpjbHpJFp8Jr9MEQvf5fWRERERERE7rHtwAXsyys1xUICvPDY0hRYJNfu0nmzDNUJJf8bOI9ugdFc136SxQZr6nyEzVwK2dcfmqYDYAMOEREREVFvq6pz4KWPcqFq5l1W7rstDvEjg9xUlecwdA3axVw483dCu5gLGEan+WJwBOSE2ZBjp0Kw+bqoSiIiIiIi9zAMA//44hTyzlWZ4kODffD40hTIlv71vmSgMDQV6sVcqPYsqBeOAbrW+QmiBMvIsZDjpkMamQJB5JRcIiKigY7/tScaoPLOVWLtlpP4/quMB+9IRGxEoMvqMBQHHHv/CeXU7rYHRQm2ySshJ9/Gjn8iIiIiIg9xrPAqNuw8bYrZrBLWLE9FgI/VTVVdP0PXoBbuhePw5o5XbxYlyGPmwDrubojeARC9OIGMiIiIiMhVnIqGlz/KRU290xSfOz4Cs8YOd1NVnkGvuwrl1G4opzJhNFR1nmyxQo6eDDlxNsTQ0XxfREREREQeY8vec9iTe9kU8/eR8dTKNPh5y26qyjMZhgG94jwUexbUov0dL7h2DTE0CnJsBuSYKRC8/FxQJREREfUVbMAhGoDOldbi5Y+OQ9PN7TdLZkRhavJQl9WhVVxE8/ZXoVdfbnNMGBQG77mPQhoc6bJ6iIiIiIjIvQqLq/HXj0+YFgoQADxy9xhEDOkfLycMw4B67gic2RuhV1/qIEuAJW4abBMWQ/QPdWl9RERERETU8nv7W58X4Oxl86SpxFFBuGdujJuqGtgMXYV6PgdKwU5oF08AbZaIMxNDRkFOnAU5ZioEq7driiQiIiIi6iP2nSjFpsyzppjVImLN8jQMCeTvx66iN1ZDLdoH5VQW9KriLvMFn0DIsdNgicuAFMSFHYiIiDwVG3CIBpiyykb8eV0OHE7z9pdzx0dgwbRIl9RgGAaUkzvg2P8+oKltjltip8Er44d8oUJERERE5EEulNXhL+tz4VR1U3zZ7GiMi+0fTSpqyUk4Dm6AXn6mwxzLqHGwpi+DFBzhwsqIiIiIiOhanx+4gP0ny0yxIYHeeHRxMiyS6KaqBia99gqUgn/tdtNU03my7AU5egrkxNmQQiNdUh8RERERUV9TcL4Kb2zNN8UEAI8sTMLoYQHuKcqDGKoT6vljUOx7oBWfAAy98xMkGZbI8ZDjMiANT4IgSq4plIiIiPosNuAQDSDV9Q48/+Ex1DUqpnh6whCsnhcLQRB6vQajuR7Nu9+Eeu5w24MWG7ym3w85LqPX6yAiIiIior6jrKoR/7MuB00Oc4P+tOShuGPySDdV1X1a+Vk4Dm6AVpLXYY4UHg/bpBWQwriaNhERERGROx0rvIqNO0+bYl5WCU8sT4Wft+ymqgYWQ1Ohnj8CJX9Xp89J3xJDR7fsdhM9GYLs5YIKiYiIiIj6pktXG/DyR8eh6eYdI1fNjcX4uP6xWFl/ZBgG9Cunodj3QDl9EHA2dnmOFBYLS1wG5OhJEKw+LqiSiIiI+gs24BANEI3NKv68LgdXa5pN8cRRQXh4wRiIYu8336ildjRv/yuMhso2x8TBo+A991GIg4b2eh1ERERERNR3VNU58PwHx1Db4DTF06JD8MAdCS5ZKOBG6dWX4cjeCPXsoQ5zxJBRsE1aDikiuU//LEREREREnqCkvB6vf5qHa6eyfbuS9PDBvu4qa8DQq0vhLNgF1b4HRnNd58myN+TYaZATZ0EK6fsLLxARERER9baaegf+vC4Hjd9brGzexAjcmj7CTVUNbHp9BZTCvVDsWTBqSrvMF/xCIMdlQI7NgDgozAUVEhERUX/EBhyiAUBRNbz8US4uXqk3xUeF+ePxpSmQLWKvXt/QdTiPfQrn4c2AYbQ5LiffBtvkFRAkrixHRERERORJ6psUPP/hsTYLBcSNCMSji5NhkXr3WeVG6fWVcB7ZDOXUHsDQ280RBoXBNnEpLKPTIQh98+cgIiIiIvIk9U0KXtyYC4dTM8WXzY7G2JjBbqqq/zNUJ9Rzh1t2u7lc0GW+GBYDa+Lslmcli80FFRIRERER9X0Op4YXNuSiotb8vmRc7GCsmhPrpqoGJkNxQD17CEphFrSSfABt57KZWGywjJ4IOW46pPB4vvMhIiKiLrEBh6if03UDf/v0JAouVJviQwK98dTKNHjbevePud5QheYdr7f70kXw8ofX7B/DMnJsr9ZARERERER9T5OjZZfOS1cbTPFRYf54clkqrLLkpso6ZjTXw3FsC5S8rwFNbTdH8AmEdcJiyPHTIYj8WoWIiIiIqC9QNR2vbjqO8mrzZLYpSWG4YzJ3X7kRWtUlKAW7oNj3AI6GzpNtvi273STMhhQ83DUFEhERERH1E7pu4PVP8nCu1LyLZFR4AB5ZmARRFNxU2cBhGDq0y3Yo9iyoZ7MBpbnLc6RhiZDjpsMSNQGC7OWCKomIiGig4EwRon7MMAy8+5Udh0+Vm+IBvlY8fU8aBvlae/X66vljaN65Foajvs0xaVgivG55BKJvUK/WQEREREREfY+i6nj5o+M4e7nWFB8a7INf3JMGH6++9XWEoTTDefwLOHO2AUpT+0k2X9jG3gU5aR4ES+8+axERERER0fX5YHthm4XKosL98cDtCRAETmbrLkN1Qj2TDaVgF7RSe5f5Ung85IRZsERN5HMSEREREVE7DMPA+18X4ljRVVN88CAvPLk8FbY+uFhZf6LXXoFiz4JSmAWj7mqX+UJAGOS4DMix0yD6c6dUIiIiujF9a8YLEV2XT7LOYefRElPMyyrhFyvSMCTIp9eua2gKHAfWQTnxVduDggjrhMWwjl0AQeSWnEREREREnkbTdfztkzzkn68yxYP8bfjlPWMR4NN3JmUZmgIlfyecRz+F0VTbfpLFCmvybbCm3QHB5uvaAomIiIiIqEs7j5ZgxxHzu5JBflY8vrRv7rzZFzmvnEfzgW1QCvcCzsZOcwWbHyzx0yEnzIQUOMxFFRIRERER9U9fZV/E9iPFppivlwW/WNn7CysPVIazCcqZg1DtWd1aOACyN+ToyZDjMiCGxXCRBiIiIrppbMAh6qe+OVqCj/ecNcUskoAnlqZg1FD/XruuXl2Kpu2vQa843+aY4BsMr7mPwjI0tteuT0REREREfZdhGHj781M4bDfv0unnLePfVo1FyCAvN1VmZug61KJ9cBz6CEZ9RftJggQ5cTas4++G6BPo0vqIiIiIiKh7Tl2owj+/Mk+4skginliaiiB/m5uq6h8MxYH6nAOoz90OR0k3drsZlgg5cTYskeMhSLILKiQiIiIi6t8OFVzBhzuKTDGLJODxpSkID+GCX9fD0HVol05Cse+BevYIoDk7P0EQIEUkQ47NaHmG4Y6dRERE1IPYgEPUDx0quIJ3vzhligkAfnJ3EhIjg3vtuoo9C817/gGojjbHLJET4DXzQQhefr12fSIiIiIi6rsMw8CHO4qw5/hlU9zLKuHpe9L6xMskwzCgnj8KZ/ZG6FUlHWQJsMRMgW3iEogBQ1xaHxERERERdd/V6ia8sukENN0wxR+8MwGjhwW4qaq+T68pg/PkDiindqPe2dRpruAdADluOuSEWRAHhbmoQiIiIiKi/u90SQ3+vuUkjO/FH7ozEfEjg9xSU3+kVV+Cas+CUrgXRkNVl/li0HDIcRmwxEyF6Mt/zkRERNQ72IBD1M8UnK/C3z7Na/OAdu9tcUhP6J3JYYazCc17/gG1aF/bg5IFtqk/gJx4C7foJCIiIiLyYJ/tO48vsy+aYhZJxJrlqYgc6v7Jb+qlAjgOrod+5XSHOdLINNjSl0MKGeHCyoiIiIiI6Ho1O1W8uDEX9U2KKX7HlJGYmjTUTVX1XYauQyvOhTNvO7SLx7vIFiBFJEFOmAXLqHEQJL5OJiIiIiK6HleqGvHChlwoqm6KL505GlP4vNIlrakOzrxvoNizoJef6TJfsPnBEjMZctx0iIMjOX+NiIiIeh2/MSXqRy6U1eGlj3Khaub2m4UZkZgzPqJXrqmVn0PT9tdg1Ja1OSYGDoPX3Ec5OY2IiIiIyMN9c6QYH+02vwQRBQGPLU52+0pu2tVzcBzcAK34RIc50tA4WCetgGVorAsrIyIiIiKiG6EbBv7+6UkUlzeY4qnRIVg2M9pNVfVNRnM9lFOZcJ7cAaOuvNNcwScQcvwMyPEzIQaEuqhCIiIiIqKBpb5JwZ/X5bRZLGBmWjjumjrKTVX1fYauobHoMBpP7ERD4SFAUzs/QZBgGZkKS9x0WEamceEAIiIicin+5kHUT5RXN+HP63LQ5NBM8Vljh2HR9Kgev55hGFCOfwnHwXWArrU5LifMhG3qvRBkW49fm4iIiIiI+o8DJ8vw7pf2NvGH7krA2NjBbqiohV5TCkf2R1DPHOwwRwweAduk5ZBGpHJFNCIiIiKifuLjzLM4WnjVFAsP8cFPFyZBFPl7PQBoV89DydsOpWgfoCmdZArwjh4Hv7R5aAqOhyBKLquRiIiIiGigUVQNL23MRVlVkymeHBWM+26L53uIdui1V6AU7IZi34P6xuou88WQUZDjMmCJmQLRO6D3CyQiIiJqBxtwiPqB2gYnnv/wGGoanKb4+LhQ/LAXHtD0plo071wL7WJu24OyN7xmPgA5enKPXpOIiIiIiPqf3NNXsXbLSRjfi6+eF4tpyeFuqUlvqILz8MdQTu0GDL3dHME/FLb0ZbBET4IgiC6ukIiIiIiIbtTB/DJ8uvecKebrZcGTy1PhbfPs156GpkI9ewhK3nZoZYWdJ9t8IcfPQOi0BfAKCYem6WiubOj8HCIiIiIi6pBuGPjfz/JRWFxjikeE+uHRxcmwSHwX8S1DdUI9dxhKwW5ol/K7zBe8A2CJnQY5LgNS8AgXVEhERETUOc/+JpqoH2hyqPjz+hxc+d7qCHEjAvHThWN6fDU39VI+mne8DqOdVQXEIaPhPedRiAGhPXpNIiIiIiLqf+wXq/HqphPQdHP7zaLpUbh1outfgBjN9XDmbIXzxFcdrvAseA+CdcIiyPEzIUj8SoSIiIiIqD85X1qHNz4zT84SBQGPLk5GWJCPm6pyP72hCkr+Tij538Boqu00VwwZCTlpLuSYKRAsNsiBvi6qkoiIiIhoYPto1xkczL9iigX52/DUCi4W8C2t4kLLbjdF+wBHFwsAiBZYIsdBjpsOKSKZu3USERFRn8Lf7oj6MFXT8cqm4zhfWmeKR4T64sllKZAtPfdwYeganIc3w3l0C9Bm/WrAmnYnrOlLIYj8a4OIiIiIyNNdKKvDCxty4VTNO8zMmxCBhRmRLq3FUBxwnvgSzpytgLOp/SSrD6xj74Q16VYIss2l9RERERER0c2rqXfgxY1tn0FWz4vFmMhgN1XlPoZhQCu1Q8nbDvXsYcDQOk4WJFhGp8OaNBdiWAwEoWcXdiMiIiIi8nQ7j5Vg6/7zppiXVcJTK9IQHODlpqr6BsPZCKXoAJRTu6GXn+0y3zYsFr4ps+EcOhaCjQsGEBERUd/EmfREfZRuGFi75SROnqsyxQcP8sIvVo6Fj5fcc9equ4qmHX+FXlbU5pjgHQCvWx6BJSK5x65HRERERET9V1llI/5nXQ6aHKopPjUpDKvmxbpsMpehqVAKdsJ55JOOV3mWrLCm3Apr2p18UUNERERE1E8pqo6XNx1HVZ3DFJ81dhjmjB/upqrcw1AcUIr2Qcn7Gnplcae5gk8g5MRbICfOgugT6JoCiYiIiIg8TO7pCrz7hd0UEwUBjy1Oxoghfm6qyr0Mw4BWVgilYBfU09mA5uz8BJsv5NhpGDxpPrzDo6BpOioru9ghh4iIiMiN2IBD1AcZhoEPvi5sszWpn7eMp+8ZiyD/nluxWTl7CM273gCcjW2OSRHJ8Jr9E4g+g3rsekRERERE1H9V1Tnwpw+OobbB/LJkbMxgPHhnIkQXNN8Yhg61aD8chzbBqCtvP0mQICfMhHX8Qoi+Qb1eExERERER9Q7DMPCPLwpwusTcdB83IhD33hrnMbu56DVlcJ7cAeXU7o53/vwXKTwectJcWCLHQxD5KpiIiIiIqLecL63Da5tPQDcMU/z+2+ORPDrETVW5j95YA7UwC0rBbug1pV3mS8PHQI6f2fLsYrHCGsyF1IiIiKh/4LeuRH3Q1v3n8fVh88plNlnCL1amYWiwT49cw1CdcOx7H0r+N20PChJsk5ZBTr0dgiD2yPWIiIiIiKh/q2t04k8fHEVFbbMpHj8iED9blASL1LvPDoZhQLuQA0f2hk5XerZET4Ft4hKIg8J6tR4iIiIiIup9X2VfRNZx88StkAAvPLYkudefQdzN0HVoF3PhPLkd2sXjnSdbrJBjp0FOmgspeIRrCiQiIiIi8mCVtc14YUMOHIpmii+YNgoz04a5qSrXM3QdWvFxKAW7oZ4/Bhhap/mCbxDkuOmQ42dADBjimiKJiIiIehgbcIj6mMycS9i464wpJokCfr40GVHhAT1yDa2yBM3bX4Ne1XbSmuAfCu+5j0IaMrpHrkVERERERP1fk0PFX9bn4HKFeefMUWH+eHJ5Kqyy1KvXVy+fgvPgBmhlhR3mSCNSYUtfBmnwqF6thYiIiIiIXOPEmQp8+E2RKWaTJTy5PBUBPlY3VdX7jOZ6KKcy4Ty5o+NdP/9FCAiDNWkO5LjpEGxcLZqIiIiIyBUam1X8eX0OquudpviUMWFYMsMz5lvpteVQTu2GYs+C0VDZebIgwTJqLOSEmZAiUiCIA3sxBSIiIhr42IBD1IccLSzHW9sK2sR/fFcikqNufmtSwzCgFOyCY+97gOZsc9wyehK8Zj4Awdozu+wQEREREVH/p6gaXv7oOM5erjPFhwb74Bf3pMHb1ntfLWgVF+A4uAHaxdwOc8SwGNgmrYAlPL7X6iAiIiIiIte6XNGA1z7Og2GY4w8vGIMRQ/zcU1Qv066eh5K3HUrRPkBTOskUII1MhTVpHqSIJAgCJ68REREREbmKqul4dfNxlJQ3mOLxIwLx4J2JEATBTZX1PkN1Qj13BMqpTGgleV3mC4OGwpowE5bYDIg+g1xQIREREZFrsAGHqI8oLK7GX9t5mbRqbiymJA296fENRwOaM9+Ceia77UHJClvGvZDjZw7oB0EiIiIiIro+mq7jrx/nIf98lSkeHGDDL+8Z22urTuu1V+A49BHUov0d5ohBEbBNWgZp5Fg+xxARERERDSCNzQpe3HgcTQ7VFF88IwoT4kPdVFXvMDQV6tlDcOZ9Db2sqPNkmy/k+BmwjpkDMWCIawokIiIiIqJWhmHgH9tO4eQ58zuT8BAfPL4sBbJlYDbHa5UXoRTshlK4F3A0dJ4sWWGJToecMAtSWCzf3xAREdGAxAYcoj6gpLweL6zPhaLqpvidU0bhtvQRNz2+VlaEph1/hVF3tc0xMXgEvOY+Cilo2E1fh4iIiIiIBg7dMPDW5wU4Wmh+jvDzlvHLe8YiZJBXz1+zsRrOI59Ayd8FGFq7OYL/YNgmLoUlegoEcWC+zCIiIiIi8lTfLgJQVtloik9MGIK7p0W6p6heoDdUQcnfCSX/GxhNtZ3miiEjYU2aB0vMZAgWm4sqJCIiIiKi7/t07znsOX7ZFAvwkfHUijT4esluqqp3GM4mKKcPQCnYDb38TJf5YmgU5PgZkGOmQLD6uKBCIiIiIvdhAw6Rm1XUNON/1uWg8XsruU1PCceyWaNvamzD2QjHoc1Q8r4GDL3NcXnMXNim3APB0jurVhMRERERUf9kGAbW7ShC1vFSU9zLKuGX94xFeIhvz17P0QBnzlY4j38FaM52cwTvAFjHL4ScMBuCxK8ziIiIiIgGovXfnMaJs5Wm2MgwP/z4zsR+v3KyYRjQSu1Q8r6GevZwu+9tWokSLFHpsCbNhRgW0+9/diIiIiKi/m7fiVJszjxrilktIp5cnobQQG83VdWzDMOAXlYEZ8FuqGcOAqqj8xOsPpBjp0KOnwlp8CjXFElERETUB3DGCpEb1Tcp+J91x1BVZ35gSYsOwY/uiL/hFyqGoUMt3AfHgQ/bXznN5guvmQ9BjppwQ+MTEREREdHAtmXfeXyZfdEUky0i1ixPxaih/j12HUN1wHniaziPfQY4G9tPkr1hTbsD1pTbIMg9v+sOERERERH1DXtyL7d5DgnwkfHE0lTYrJKbqrp5huKAUrQPSt7X0CuLO80VfAIhj7kFcsIsiD6BrimQiIiIiIg6lX++Cm9szTfFBAA/XZiE0cMC3FNUD9KbaqEWZrXsdlN9uct8aVgi5ISZsERO4KLPRERE5JHYgEPkJg6nhr+sz8HlCvMks+jhAfjZ4mRIonhD42pXz6M56x3oZUXtHpeGxsFrzk8h+oXc0PhERERERDSwfXOkGJt2nzHFREHAo4uSET8yqEeuYegqlILdcB75BEZjdftJkgw5aR5sY++C4OXXI9clIiIiIqK+qai4Bv/4osAUk0QBjy9NRcig/tmIr9eUwpm3A4o9E3A2dZorhcdDTpoLS+R4CCJf3xIRERER9RUlVxvw8kfHoemGKb5qXizGxYW6qaqbZ+g6tJITUAp2Qz1/FNC1TvMFn0DIcdMhJ8yEGDDERVUSERER9U38BpfIDVRNx6ubT+DMJfPuNOEhPlizPA02+fpXcjOa6+E49BGU/G8Aw2ibIFlgHXs3rOMWQBD770pxRERERETUe/afLMW7X9rbxH98VyLGxg6+6fENQ4d6JhuO7I9g1Ja1nySIkONnwjphEUTfnmn4ISIiIiKivquythkvbzoOVTO/27j/9njERAxyU1U3xtB1aBdz4Ty5HdrF450nW6yQY6dBTpoLKXiEawokIiIiIqJuq6l34C/rctDkUE3xWyeOwK0T++fv8HrdVSinMqGcyoTRUNl5siDCMjINcsIsSCNSON+MiIiI6F/YgEPkYrph4M2tBTh+psIUD/K34Zf3jIWft3xd4xmG3rJy9MENMBz17eZII9PgNe1erkBAREREREQdyj19Ff+7JR/fb+f/wbxYTE0eetPjqyUn4TiwDvrVcx3mWEZPgm3iUoiBN389IiIiIiLq+xyKhhc35qK2wWmK35Y+AjNSh7mpqutnNNdDOZUJ58kdMOrKO80VBoXBOmYu5LgMCDZfF1VIRERERETXw+HU8JcNuaiobTbFx8eF4p45MW6q6sYYmgL13FEop3ZDK84D2rwJMhMCwiAnzIQclwHRJ9AlNRIRERH1J2zAIXKxDTtPY19eqSnm62XBL+8Zi+AAr+saS7tyBs1Z70AvP9vuccE/FF7T7oVl1NgbLZeIiIiIiDyA/WI1Xtl0AppufumyeHoU5t3kKm5axQU4DqyDVnyiwxwpIhm2ScshDY68qWsREREREVH/YRgG3vgsHxfKzIuLJUcFY8Ut0W6q6vpoV89DyfsaStF+QFM6yRQgjUyFNWkepIgkCILoshqJiIiIiOj66LqB1z/Jw/nSOlN89LAA/OTuMRBFwU2VXR+tsgTKqd1Q7VkdLurcSpJhGZ3estvN0DgIQv/4GYmIiIjcgQ04RC607cAFbDtwwRSzWkSsWZGGYYO7v8qZ3lQLZ/YGKAWZaHdVAskK67gFsKbeDsFivcmqiYiIiIhoILtQVocXNuRAUXVTfN6ECNydEXnD4+p15XBkfwS1aD86Wk1NHBIN26TlsAxLvOHrEBERERFR/7Rl7zlkF1wxxcKCffCzRUmQxL7boGJoKtSzh+DM+xp6WVHnyTZfyPEzYR0zB2JAqGsKJCIiIiKiG2YYBt772o5jRVdN8cGDvPDkslTYZMlNlXWPoTRDOX0ASsFu6FdOd5kvDh4FOX4m5Jgp3KGTiIiIqJvYgEPkIvtOlGLdN+YXMaIg4NHFyYgZPqhbYxi6DiV/BxzZHwHOxnZzLJETYJu6GqL/4JuumYiIiIiIBrayykb8z4fH0OTQTPGpSUOxal7sDa1wZjTXw3H0Uyh52wFdbTdHHDQU1kkrYIkcz1XUiIiIiIg80OFT5diUedYU87ZZ8OSyFPh4yW6qqnN6QxWU/G+g5O+E0VTbaa4YMgrWpLmwxEyGYLG5qEIiIiIiIrpZX2ZfxI4jJaaYr5cFv1iZhgDfvrkIsmEY0K+chlKwG8qZg4DS3PkJVm/IMdMgJ8yENHiUa4okIiIiGkDYgEPkArmnK/DG1vw28QfvTEBaTPcaZdTSQjiy3oFecaHd4+KgobBl3AdLRPJN1UpERERERJ6hsrYZf/rgGGobFVN8bMxgPHhnAsTrbIwxVAecx7+C89hngNLUbo7gEwjrhMWQ42dAEPv2KnFERERERNQ7Ll6px9otJ00xQQAeXZSE8JC+teKyYRjQSu1Q8r6GevYwYOgdJ4sSLKPTYU2aB3FINBcbICIiIiLqZw4VXMG6HebFlS2SgCeWpfa5ZxUA0JvroNr3Qjm1G3pVSZf5Ung85IRZsERNhGDpm81ERERERP0BG3CIetnpSzV4dfNxaLphiq+YHY2MlPAuz9cbq+E4sA5q4d72Eyw2WMcvgjXlNggS/0gTEREREVHX6hqdeP7DY6ioNa+CljAyEI8uToJFErs9lqFrUOx74Dy0CUZjdftJshesaXfCmjIfgszVn4mIiIiIPFVtoxMvbsiFQzHvwrnylhgkjw5xU1VtGUozlMJ9UPK2Q68q7jRX8AmEPOYWyAmzIPoEuqZAIiIiIiLqUUUlNfj7lpMwvhd/6K5ExI0IdEdJ7TIMHVrJSSgFu6GeOwzoWqf5gvcgyPHTIcfPgDhoqIuqJCIiIhrYOFufqBddrmjAC+tz4VTMK6Ldlj4Ct08e2em5hq5CObEdjsObOtwa1BI9BbYp90D0DeqxmomIiIiIaGBrcqj487ocXK5oNMVHDfXHE8tSIVu6tzONYRhQzx+F8+AG6NWX2k8SJchj5sA6fiFEL/+bLZ2IiIiIiPoxVdPx6qYTbRYCyEgZitvSR7ipKjO9phTOvB1Q7JmAs/2dPb8lhcdDTpoHS+Q4CCJfuRIRERER9VdlVY14cUMuFNU8v2vZrNGYMqZvNK3o9RVQTu2Bcmo3jPqKzpMFEdKIVFgTZkEamcLnFSIiIqIext+uiHpJVZ0D//PhMdQ3Kab4lKQwrJwTA0EQOjxXvZQPR9a7HW4PKgYNhy3jPliGJfZozURERERENLApqoaXPzqOc6V1pvjQYB/8YmUavG3d+5pALS2E88A6aGWFHeZYYqbCNnEpxIDQm6qZiIiIiIj6P8Mw8M+v7LBfrDbFo4cH4P75CZ2+M+lthq5Du5gLZ97X0IpPdJ5ssUKOzYCcNBdScIRrCiQiIiIiol5T36TgL+ty2szvmpk2DHdOGeWmqloYmgr1/FEop3ZDu3gCaLM/j5kQMARy/EzIcRlczJmIiIioF7EBh6gXNDQr+J91x1BR6zDFk6OC8dCdiRA7eJGk11fCsf8DqGcOtj+w7A3bxMWQk+ZydQIiIiIiIroumq7jrx/nIf98lSkeHGDDv60aiwAfa9djVF2C8+B6qOePdpgjRSTDNmkFpMHufTFFRERERER9x44jJdh1zLxzZpC/DY8vSYFsEd1Sk15bDsWeCeXUHhgNlZ3mCoPCYB0zF3JcBgSbr4sqJCIiIiKi3qSoGl7cmIuyKvPul8mjg/HD+XFuWyhAqyqBcioTqj0LRnNd58mSBZaodMgJMyGFx0MQ3PN8RURERORJOIOfqIc5FQ0vbshFSXmDKR4V7o/HliTDIrV90DE0Fc7jX8B55BNAdbQ5DgCWuAzYJq2A6BPYG2UTEREREdEAphsG3vq8AEcLr5ri/j4yfnnPWAQHeHV+fkMVnIc3QTmVCRjtr7AmhoyCbfJKWCKSeqxuIiIiIiLq//LPVeL9r827Z1otIp5clopBfjaX1mKoTqhnD0E5lQntUn4X2QKkkWmwJs+DNHwMJ7IREREREQ0gumFg7ZZ8FBXXmOIjhvjh0UXJkETX/v6vN9dBLdoPpXAv9PKzXeaLISMgJ8yCHDOViwQQERERuRgbcIh60LcrShd+7+EsLNgHa1akwcva9o+cevH0PGQNAABKSElEQVQ4mvf+E0ZNabtjiiGj4JVxH6Shsb1SMxERERERDWyGYeDD7UXIOm5+5vC2SXh65ViEh3T8YsZwNsJ5bCucx78ENGe7OYJ/KGzpy2CJnsQJaUREREREZHKlqhGvbj4B/XuN/A/dlYhRQ/1dUoNhGNCvnodyajeUon2As6nzE2y+kONnwjpmDsSAUJfUSERERERErrVx12lkF1wxxYL8bXhqRRq8ba6ZUmloCtQLOVDtWVAv5AKG1vkJsjfk2KmQ42dCHDzKbTv0EBEREXk6NuAQ9RDDMPCPbadwrMi8onSgnxW/XJmGAB+rKa7XlcOx732o5460P6DNF7b0ZZATZkNw8aoKREREREQ0cGzZew5fHbpoisn/Wm26owlvhqZAydsBx9FPAEdDuzmClz+s4xdCTpwNQZJ7vG4iIiIiIurfmhwqXtx4HA3Nqim+YFokJiWG9fr1jeZ6KEX7oBTshl55sct8cfAoWJPmwRI9GYLF2mU+ERERERH1TzuPluDz/RdMMS+rhKdWpCHIv3d36TQMA3r5GSj2LCinD3T4DuZaUng85PiZsIyeCMHi2l1EiYiIiKgtNuAQ9ZBNmWeQmXvZFPO2WfD0yrEYHOjdGjNUJ5w5n8N5bAugKe2MJEBOmAnrpOUQvVyz+hsREREREQ1MO44UY1PmWVNMFAQ8ujgZ8SOD2uQbhg61aD8c2Rth1Fe0P6jFCmvKfFjT7oRg9W4/h4iIiIiIPJquG/jbJ3m4dNU8mWxc7GAsnhHVa9c1dB1aSR6UU5ktC6Dpaucn2Hwhx0yFHD8D0uBRvVYXERERERH1Dbmnr+KdL0+ZYqIg4LElyRgxxK/XrqvXV0Ap3AvVngW9prTLfMF7ECyx02BNmAkxMLzX6iIiIiKi68cGHKIe8PWhi9iy97wpZpFErFmeiohrHs7U80fRvPc9GHXl7Y4jho6GV8Z9kIaM7tV6iYiIiIho4NufV4p/fmlvE//xgkSMjRlsihmGAa34BBwH10Gv6GBlaEFsWSxgwmKIPoG9UDEREREREQ0UH+0+g5zT5qb+iFBf/OTuMRAFocevp9degWLfA+XUHhgNlV1kC5AikiDHz4Bl1DjudkNERERE5CHOl9bhtc15MAxz/Ee3xyM5KqTHr2cozVDPHoJiz4J2qQCA0fkJkgxL5ATIcRmQho+BIEo9XhMRERER3Tw24BDdpIP5ZXj/60JTTBCAny1KQtyIQACAXlOG5n3vQbuQ0+4Ygpc/rJOWQ46fAUEQe7tkIiIiIiIa4HKKruJ/P8tv8yrn3lvjMDVpqCmmlZ+D48CH0C7ldzieJWoibOnLuMoaERERERF1aV9eKbbuNy9a5uct44llqfCy9tyrSUN1tkxmO5XZ6fPMtwT/wZDjZkCOy4DoP7jLfCIiIiIiGjgqaprxlw05cCiaKb5gWiRmpA3rsesYug7tUj6UwiyoZw8BqrPLc6TweMixGfj/t3fnYXKVZd74v9VLQhZCFkJYZBOSIJtA2ASCsiiCioAsBpABdXyVicIb5+cyDAoOiozD+KqDM6PgMiigKKgsAuPIDiIohEUgAUEISFhCEkK2Tnf9/mBSpk2n0k2qu09VfT7XxXVVqp5z18m5T1XnS5/nOW1v3COlIcNqti8AAPQPE3BgHTz05Lx8+6o/rHZR20mHTM5uk8anvGJZlt97dZbP/GXStWL1AqVS2rc/MEN3PyqloSMGZJ8BAIDGNuvp+fnmzx5MZ1f3pHLE1K1z0JQ3VP7ctfD5LLv7p1nx+F1rrNW68aQM3evYtE7Ytt/2FwAAaBxP/HlhvnvtI92ea20p5e+O3DHjR6/7hWTlcjldLz6ZjkdvTcdjdybLl1TfoLUtbVvtnvbt9k/rpttZBA0AAJrQ4qUr8v9+MjMLFnWfDLP3DhNy5NSta/IenS8/mxWzb0/H7Dt7cVfOpDRqQton7ZP2bfdJy6jxNdkHAAAGhgk48Do9+dzC/NsVD6x2UduRU7fO/m/eNB1/vDvLfnNZyote6nH71gkTM3TfE9O64ZYDsbsAAEAT+NNzr+RrP5mZjhVd3Z4/ePc35D37bJUk6VqyMMt//4t0PHxj0tXZQ5WkZcxmGbrnMWnd4s0plUr9vdsAAEADePmVZfn6T+/Pis7ueeSEt0/K5C3GrFPt8tJF6Zh9RzoevTVd855e6/iWDbdM++Spad/2LRZAAwCAJraisysXXPlAnnnh1W7Pb7fF6Jxy6JvW6XcgXUtfyYrHfpOO2Xek64Un1r7BkGFp32avtE/cNy0TtvX7FwCAOmUCDrwOc+ctzld/PDPLlne/WO3A3TbLYW8akiXX/ks6n3mox21Lw0Zl6F7HpW3iPoIUAABQM8/NW5x//fF9WbKse07ZZ8eN8/6DJiYrlmXZ/ddn+f2/TDqW9lijNGJshu5+ZNom7ptSi5WhAQCA3lne0Zl/u+L+1VaUPnC3zfK2XTd7XTXLXV3pfOahdDx6S1Y8eW/StaL6BkNHpH3bt6R98lSLnwEAACmXy/n+dY/k4T+93O35TcYNz98dtVPa2/r+e5ByZ0dWPDUzK2bdnhVP3Z+Ue17orKLUktbNd0r7pH3TtsUuKbUN6fN7AgBQLCbgQB8tWLQs5//ovryyuKPb82+ZNDpHr39fFv/0hp7DVakl7Tu+PUOnHJHSkGEDtLcAAEAzmLdwac6/7N7Vcsou226Yk9+5bVY8fGOW/+5nKS9Z2HOBIcMzZJd3Z8iOB/vlDwAA0Cflcjnfu+6RPPHnV7o9v90Wo19bDKCPuhY+n45Hb03HrNtTfnXeWkaX0vqGHdI+eWrattxVngEAACquuv3J3P7Ac92eGzW8Pacf8+aMWK+913XK5XK6XvhjOmbdno7H70qWvbrWbVrGbZn2SfukbZu90zJ8gz7vOwAAxWUCDvTB4qUr8q8/npkXF6y6WnQ579n0hRy8+BfpeGB+j9u1bvqmDN3nxLSOfX2rvAEAAKzJK4uX5/wf3ZeXFi7r9vx2m2+Qj7x5SZb+9MyUF8zteePWtrTvcHCG7vLulNYbOQB7CwAANJrr7noqv3moe+YYP3q9nHrkTmlr7d2K0uUVy7PiiXvS8eit6Xz24bWOL62/YdonTU375P3SMnLc69pvAACgcd3+wJ/zs9ue6PbckLaWnHbMmzN+dO8WTu5a9FI6Zt+RFbNuT9eC59Y6vjRsg7RNfEvaJ+2b1rGbv679BgCg+EzAgV7qWNGZf7vi/jz9/KLKc5u0vpwTRv8umy99tsdtSiPGZOje09L2xj1SKpUGalcBAIAmsWTZinz1xzPz55cWd3t+340W5thht6bjxifWsGUpbZP2ydDdj3KxGgAA8LrNfOzF/OSmx7s9N3RIaz7xvp0zclj1FaXL5XK6XnzytbvdPHZnsnxJ9TdrbUvb1runffL+ad10u5RKvZvcAwAAa1Iul3P11Vfnpz/9aR5++OEsXrw448ePzx577JETTjghO++88zq/x6xZs/Ld7343d911V55//vmsv/762WabbXLEEUfkyCOPTGtr64DUaCYPPzkv3/vlI92eKyX5P4fvkK03GVV123LH0tcWB5h1ezqffSRJufqbtbanbaspaZ+0T1o32yGlFr0AAGh0JuBAL3R1lfPtq/6QR56anyQZVlqedw6bmf2HPpKWcg9Bq6U1Q3Z+Z4bs+p6U2tcb2J0FAACaQseKznzjp/fnyedeqTy3SevLOXqDmdl2xVPJiz1v17r5zhm61zFWXwMAYMC5uK2xPPPiq/nPXzzU7XK0UpL/854dstn4Nd9hs2vpK1kx+850PHpruuY9vdb3adlwy7RP3j/t2+6d0tAR677jAACQZOnSpTnttNNy0003dXv+mWeeyTPPPJOrrroqp59+ej7ykY+87ve4/PLLc/bZZ6ejo6Py3Lx58zJv3rzcfffdufLKK3PBBRdk9OjR/VqjmTzz4qv5tysfTGdX9+u5ph08MbtOGt/jNuWurnQ++3A6Zt+eFU/ck6xYvtb3ad1kctom7pP2N+6R0pDhNdl3AADqgwk4sBblcjk//O9ZuefRF1JKOXsMeTyHD/991m9Z2uP41jfsmPX2OTEtozce4D0FAACaRWdXV/7j5w9VFgkY07Iohw6bmT2HPJ413XuzZfwbM3SvY9K26ZsGbD8BAGAlF7c1lkVLOvL1n8zM0uWd3Z4/6q1vzC4TN1xtfLmrK53PPJiOR2/NiifvTbpWVH+DoSPSvu1b0j55alo33LKWuw4AAEmSM844o5JPttlmmxx77LHZcMMN89BDD+Wyyy7L4sWLc/7552fChAl573vf2+f6t956a84888yUy+UMGzYs73//+7PjjjvmpZdeyk9+8pPMmjUr99xzT2bMmJELL7wwLS2r3+GxFjWayYJFy/L/fjwzS5Z1zxvv2GPzHLz76ouSdb78bFbMvj0ds+9M+dV5a61fGrVR2ifum/aJ+6RlVM+TeQAAaHwm4MBaXHX7k7nx3mfyhtaXcvTw32br9hd6HFcaOS5D9zk+bVvullJpTZe8AQBA7zTTytBWl+6brnI537v2kdw7+8UMLy3Lwes9mP3Xezjtpa4ex5c2mJChexydtq13l1UAABg0Lm5rHCs6u3LBFQ/khfndFyrbe/sJOWzv7pNluhY+n45Hb03HrNt7cUFbKa1v2CHtk6embctdU2obUuM9BwCA19x+++25+uqrkyR77713vvWtb2Xo0KFJkne/+905+uijc/zxx2f+/Pn50pe+lIMOOigjR675Lo9/bfny5TnrrLNSLpczfPjw/OAHP8gOO+xQeX3atGmZMWNG/vu//zu33357rr322rz73e+ueY1m8urSjnz18pl5aWH3nLLbpPE59oBtK3/uWvpKVjz2m3TMviNdLzyx9sJDhqX9jXulbdK+aZ2wrd+zAABgAs5KLm5zcdtfW7SkIzfc/XR+feejOWb4vdln6Ky09JShWtsy5M3vypBdDkupbeiA7ycAAI2nmVaGtrp035TL5fzofx7Lbx+ckwPXeyRvX+/BDG9Z3uPY0rBRGTLliLRvt39KLeI/AACDx8VtjaNcLucHN8zKo0/P7/b8Vhuvn5MP3S6lUinlFcuz4ol70vHorel89uG11iytv2HaJ01N++T90jJyXD/tOQAA/MV3vvOdJElbW1vOOeecSj5ZaZtttsmZZ56ZT37yk5k/f34uv/zynHLKKb2uf8MNN2TOnDlJkg9/+MPdskWSDBkyJOedd17uvvvuzJ8/P//5n/+5Wr6oRY1msXjpivzrj+7LU3MXdXv+jZuOyt++Z/uUyivS8cT9WTHrtqx46v6k3LmGSv+r1JLWzXdK+6R907bFLhYHAACgG1fgxMVtLm77i3K5nMefWZgb752Tux95Pru3zsoZG/w+I1uW9Ti+bctdM/Qt09IyaqMB3lMAABpZs6wMbXXpvuns6sovbv1jFt5/Y87Y4L6MaV3c88D29TJk50MzZOdDUmpfb2B3EgAAeuDitsbxq3vm5JaZz3Z7bsz6Q/Pxo3ZK6/ynsvSRW9Lx+G+S5UuqF2ptS9vWu6d98v5p3XS7lErNnfcAABg48+fPzx133JEkmTp1ajbffPMexx122GH50pe+lJdeeinXXXddnzLKtddemyQplUqZNm1aj2NGjBiRo446Kt/5zncya9asPPHEE9l6661rWqMZLFm2Il+9/L488edXuj0/fvTQfOKt66d81w+z6PG7kmWvrrVWy7gtXpt0s83eaRm+QX/tMgAAdc4EnLi4zcVtybKOztzx4HO58ffPZM4LizK+ZWE+OuLOTGyf2+P40qiNst4+J6RtizcP8J4CANDommVlaKtL996yjs7cNvPZ/OnuW7Jf+e4cPHJ+zwNLrWnf/m0Zstt70zJs1IDuIwAArImL2xrHA398KZf9ena350a3L8//t+uiDLnhnCyeN2etNVo23DLtk/dP+7Z7pzR0RH/tKgAArNE999yTrq6uJK/9HmZNWlpasscee+S6667LzJkzs2DBgmywQe8mZdx9991JksmTJ2fs2LFrHLf33ntXFiy45ZZbuuWLWtRodEuXr8j/u3xmHn9mYeW5MS2Lst/Ip3LgBk+ndP3cdFTZPklKwzZI28S3pH3ivmkd13NeBQCAVTX9BBwXt/W+RqNavLQj/3zpvXlq7qK0pjNvX++hHDLs/rSXulYf3DokQ3Z7T4bsdIjbiwIA0C+aZWVoq0uv3aIlHfn1757OU/f+Jge23pM92+atcWzbG/fM0D3el5YNJgzgHgIAwNq5uK0xPPviq/mPnz+YcjlpTWd2aH8mewx9PDsNfTalBzvTw29U/mLoiLRP3Cftk/ZL64ZbDtQuAwBAj2bP/suk8kmTJlUdu+222yZJyuVyZs2alT322GOt9efOnZuFC1+bEDJx4sSqY7fZZpvK40ceeaSmNRrdso7OfP0n92f2nAUZVlqeN7f/KbsP/WO2aZubllKSV6ps3Nqetq12S/ukfdO62Q4ptbQO1G4DANAAmucWJ2vQ24vbklQubuuL3l5UNnr06CTJf/7nfxa2RqN68Il5eWruomzZ+kL+ftQ1effw+3qcfNO29e4Zcdy5Gbrre0y+AQCgX/RlZehx48YlSa677ro+vUdfVnVOUlnVuYg1GlVXuZwrbnk8//GfP82WM/89fzP0hmy+hsk3rZu+KcOP/HyGHXyqyTcAABTSulzc1hsubut/i5Z05Os/mZmNVjyXo4fflX8afXk+tP5N2XnI0ymVO9ewVSmtb9gx6x10akae8NWst88JJt8AAFAIzzzzTOXxZpttVnXsxhtv3ON21ay8Pqs39SdMmJCWltcu33v22WdrWqORLe/ozAU/+X2G/Pn+nDLypvzT6B9n2sg7M7H9fyffrEHrJpMzdP9TMvIDX8uwgz6Wts13NvkGAIA+a+oJOC5u61uNRjV2/fVyyHozc/qoX2bTtvmrvV4aOS7D3jkjw94+PS0jxw38DgIA0DT6ujJ0ksrK0L3Vl1WdV7rlllsKWaNRXXfbrGx6/3fyf4Zflze2v9DjmOUjN82wQz+ZYe/6VFrHN8eK2wAA1CcXt9W/q6+5NR/s+nFmbPDLTF3v0YxoWb7GsaX1N8yQKUdmxPH/kuGH/X3at9nTomYAABTKvHl/WfBqzJgxVceuXMg4ee06s954+eWXe12/vb09w4cPX61+LWo0qnK5nP/58Y9ywoJv50Pr35RdhjzV40LLK5VGbfRaRnn/P2f4ez6bIdu9NaUhwwdwjwEAaDRtg70Dg6mvF7ddd911lYvbNthgg169R18uKlt5N55bbrklW2/9lwuoilKjUW3V8mwmDJ+5+gulUtp3fEeG7n5kSu3rDfyOAQDQdNZlZeiVE3KqKcrK0FaXrm7skzdkhyE9X2zYMWKjjNzrfRm5zR4plZp6TQ0AAOpEES9uW7Ro0Tpf3PbXNRpVV1c5e7zws2zUtnDNg1rb07b1lLRP3j+tm24nqwAAUGhLly6tPB46dGjVsUOG/GUy+arbVbNkyZJe1185ZtGiRd3q16LGQBs1qn+urWr531vatLSUMnbsiMx64JHs9+oNVZcdLw0dnhFv2icjdnxrhm42OaVSldviUBh/3Wsam343F/1uLvrdPJq51009AcfFbb2v0cjKi1dfLbxl3BZZb/9TrCQNAMCAWpeVoXuTUV7Pqs5dXV3rvDJ0f9RoZFus35ks6f5c5/BxGbHnkRm57VtSamkdnB0DAIDXwcVt/WOgLm4rd3VmXmvPf8+hm78pI3Z8a0ZM3jst6zXXL1gbRTP/krzZ6HVz0e/mot/NRb9rY8WKFZXHq2aQnqz6+qrbVdPZ2dnr+quOWbV+LWoMtNbW/p2IXyqV0tpaStvy1a/zSpK0tGX4trtl5E77Z/i2U9LiTpx1a2WvaQ763Vz0u7nod/Noxl439QQcF7f1vkYja9tqt7SM2yJdLz2VtA3JkN2OyJCd35FSS1N/PAAAGATNsjK01aWrm7DP4Vl0zay0dCxOedjorDflvWmfPDWlVhkFAID64+K2/jFQF7eltSVjpx6dRbdemlLKadlgQjZ48wEZudP+aR89oV/3gYHTjL8kb1Z63Vz0u7nod3PR73Wz3np/mcze0dFRNQMsX7688rg3WSHpPqm/o6NjreNXvkd7e3tNawy0zs6ufqnb0lJKqVRKuVxOV1c5W+0yJTPv2CpjX30ySdI1fmI2nHJAhk/eO63D1k+SlPtxf+g/f91rGpt+Nxf9bi763TwGs9f9/f/H16apr95xcVvvazSyUtuQDD/qrHTNeyYtG0xIyQoIAAAMkmZZGboeV5dO+meF6R5XLBy7U8Zt9c2sWDQv7WM2MfGmgVihsrnod/PQ6+ai381Fv2vDxW39Y6AubkuSDfc9MqN32DflclfaRk9IqVTq131g4LggonnodXPR7+ai381lsPo92Be31drw4cMrj5ctW9brjNKb32f0VH9tVo5ZNTvVosZAW7hwaVas6Fz7wD4aO3ZEWltL6eoqZ968V5MkWxz/uXS9/GzKQ0embcTodCRZsCTJkldr/v4MnJ56TePS7+ai381Fv5vHYPW6ra01Y8YMX/vA/tyHQX33Qebitt7XGAwDdnHbSuO2q/n7Mbj8gry56Hdz0e/mot/NQ6+bZ2XoelxdOunfXzL+9YqFrSPWT/uI9fvt/RhcVqhsLvrdPPS6ueh3c9HvdePitv4xkBe3veZ/c/rLi2v+ngweF0Q0D71uLvrdXPS7uQxGv4twcVutjRo1qvJ4/vz5WX/9Nf+/+FUXLx47dmyf6y9YsKDq2I6OjixevHi1+rWo0chKpZa0jn3DYO8GAABNqqkn4Li4rfc1BsNAXtxGY9Pv5qLfzUW/m4t+N49m7nWzrAxdj6tLJ/2zurMVKpuLfjcX/W4eet1c9Lu5DGa/G2mFaRe3AQAARbLVVltVHv/5z3/O5ptvvsaxzz33XOXxpptu+rrqVzN37tx0dXWtVr8WNQAAgP7R1BNwXNzW+xqDwcVtrCv9bi763Vz0u7nod/NwcVvzrAxdj6tLJ/2zwrQVKpuLfjcX/W4eet1c9Lu5DFa/G22FaRe3AQAARbLNNttUHs+ePTt77rnnGsfOnj07yWuLx02cOLFX9ceMGZNx48blpZdeqmy/Jo899ljl8aRJk2paAwAA6B9NPQHHxW29rzEYXNzGutLv5qLfzUW/m4t+Nw8XtzXPytBWlwYAgObh4jYAAKBIdt1117S3t6ejoyN33XVXTjjhhB7HdXZ25u67706SbLfddt1+t7E2e+yxR6677ro8/PDDeeWVV9b4+57f/OY3lcd/nZVqUQMAAKi9YizzPEj++uK2alzcBgAA9Le+rLpczytDW10aAACax8qL25LkrrvuWuO4db24LUnlwrQ1WdvFbetaAwAAKL5Ro0Zl7733TpL8+te/zrPPPtvjuGuuuSbz5s1Lkhx66KF9eo9DDjkkSbJixYpceumlPY5ZtGhRrrzyyiTJ1ltvne22267mNQAAgNpr6gk4Lm7rfQ0AAKD//fXK0NWsy8rQvam/tpWhB7sGAABQH1zcBgAAFM3JJ5+c5LWFimfMmJFFixZ1e/2xxx7LF7/4xSTJiBEjcswxx/Sp/sEHH5w3vOENSZILLrgg99xzT7fXly9fnk996lOVBaFPOeWUfqkBAADUXlNPwHFxW+9rAAAA/a+ZVoa2ujQAADQPF7cBAABFst9++1Um4d97771573vfmwsvvDDXXHNNvvKVr+TYY4+t/Nv/U5/6VMaOHdtt+7vuuiuTJ0/O5MmT84EPfGC1+kOGDMkZZ5yRUqmUpUuX5uSTT87ZZ5+dq666KhdffHHe97735X/+53+SJLvttluOPvrofqkBAADUXlNPwHFxW99qAAAA/auZVoa2ujQAADQPF7cBAABFc95552W//fZLksyZMydf+cpXMmPGjFx44YV59dVXUyqV8vGPfzzvf//7X1f9Aw88MJ///OfT3t6ejo6OXHLJJfn7v//7nHPOOZk1a1aSZKeddso3v/nNtLa29lsNAACgtpp6Ao6L2/pWAwAA6H/NsjK01aUBAKC5uLgNAAAokmHDhuXCCy/MV77yley7774ZO3Zs2tvbM378+Lzzne/MD3/4w0yfPn2d3mPatGm58sorc8wxx2SzzTbLkCFDMmLEiOy666753Oc+l0svvTRjxozp9xoAAEDttA32Dgy2k08+Obfeemvl4rYLL7wwI0eOrLxeq4vb5syZkwsuuCC77bZbdt9998rrfbkwbbBrAAAA/W/lytDXX399ZWXoadOmZZNNNskf/vCHXHrppXn11VeTrHll6JNOOinJa3e1vPjii7u9vnJV51NPPbWyqvMxxxyT3XbbLfPnz8+Pf/zjyoVla1sZerBrAAAA9WPlxW1XXXVVfvazn+Xhhx/OK6+8ktGjR2fKlCk56aSTMmXKlHV6j2nTpmX33XfP97///dxxxx154YUX0t7enkmTJuU973lPjj322LS3t/d7DQAAoD6USqUcfvjhOfzww/u03V577ZVHH320V2MnTpyYc8455/XsXk1rAAAAtVEql8vlwd6JwfaJT3wi119/fZLkDW94wxovbjv77LNXW3ltbRe3Ja/dXefUU09NuVxOe3t71YvKfvCDH/S4alpRagykl19enBUrOmtac+zYEWltbUlnZ1fmzXu1prUpHv1uLvrdXPS7ueh38xisXre1tWbMmOED9n69sWTJkkyfPj233XZbj6+XSqVMnz69x5XXepNRkuTSSy/NF7/4xXR0dPT4+k477ZRvf/vbVVdNK0qNgSKjsK70u7nod/PQ6+ai381FRqHI+iOfJL7nmo1+Nw+9bi763Vz0u7kMRr/lE3pLRmFd6XVz0e/mot/NRb+bRzP/DqXp74CTJOedd15effXV3HbbbZkzZ06+8pWvdHt95cVtfz35prcOPPDAfP7zn69cVHbJJZfkkksu6TZmp512yje/+c01TnopSg0AAKD/NdPK0FaXBgAAAAAAAAAA6oEJOHFxm4vbAACgeEqlUg4//PAcfvjhfdpur732yqOPPtqrsRMnTsw555zzenavcDUAAAAAAAAAAAD6kwk4/8vFbQAAAAAAAAAAAAAAAPSkZbB3AAAAAAAAAAAAAAAAAIrMBBwAAAAAAAAAAAAAAACowgQcAAAAAAAAAAAAAAAAqMIEHAAAAAAAAAAAAAAAAKjCBBwAAAAAAAAAAAAAAACowgQcAAAAAAAAAAAAAAAAqMIEHAAAAAAAAAAAAAAAAKjCBBwAAAAAAAAAAAAAAACowgQcAAAAAAAAAAAAAAAAqMIEHAAAAAAAAAAAAAAAAKjCBBwAAAAAAAAAAAAAAACowgQcAAAAAAAAAAAAAAAAqMIEHAAAAAAAAAAAAAAAAKjCBBwAAAAAAAAAAAAAAACowgQcAAAAAAAAAAAAAAAAqMIEHAAAAAAAAAAAAAAAAKiibbB3ANaktbV/54e1tbX2a32KRb+bi343F/1uLvrdPAay1/39704ah4xCLel3c9Hv5qHXzUW/m4uMQtEMxHnie6656Hfz0Ovmot/NRb+by0D1Wz6ht2QUakmvm4t+Nxf9bi763Tya7XcopXK5XB7snQAAAAAAAAAAAAAAAICiGvwpQAAAAAAAAAAAAAAAAFBgJuAAAAAAAAAAAAAAAABAFSbgAAAAAAAAAAAAAAAAQBUm4AAAAAAAAAAAAAAAAEAVJuAAAAAAAAAAAAAAAABAFSbgAAAAAAAAAAAAAAAAQBUm4AAAAAAAAAAAAAAAAEAVJuAAAAAAAAAAAAAAAABAFSbgAAAAAAAAAAAAAAAAQBUm4AAAAAAAAAAAAAAAAEAVJuAAAAAAAAAAAAAAAABAFSbgAAAAAAAAAAAAAAAAQBUm4AAAAAAAAAAAAAAAAEAVJuAAAAAAAAAAAAAAAABAFSbgAAAAAAAAAAAAAAAAQBUm4AAAAAAAAAAAAAAAAEAVJuAAAAAAAAAAAAAAAABAFSbgAAAAAAAAAAAAAAAAQBUm4AAAAAAAAAAAAAAAAEAVJuAAAAAAAAAAAAAAAABAFSbgAAAAAAAAAAAAAAAAQBUm4AAAAAAAAAAAAAAAAEAVJuAAAAAAAAAAAAAAAABAFSbgAAAAAAAAAAAAAAAAQBUm4AAAAAAAAAAAAAAAAEAVJuAAAAAAAAAAAAAAAABAFW2DvQPQ38rlcq6++ur89Kc/zcMPP5zFixdn/Pjx2WOPPXLCCSdk5513HuxdbFhnn312LrnkkkyfPj0f//jH1zr+5ptvzqWXXpr7778/CxcuzLhx47Lzzjtn2rRp2WeffXr1no1Uo8gWLFiQyy67LDfeeGOeeOKJvPrqq1l//fUzefLkvPOd78xRRx2VIUOGrHH7WnwuG6lG0b344ou5+OKLc/PNN+dPf/pTkmTjjTfOfvvtl+OOOy7bbrtt1e2LcpyLUqPeLFy4MO9617vy/PPP58gjj8yXv/zlNY4tyjEuSo0i++1vf5sPfOADvRq733775aKLLlrt+aIc56LUgL5wzg0eGUVGWZOi/DwpSo0ik09qW6MeySiN2W8ZpfY1oC+cc4NDPmncfJLIKLWuUWQySm1r1CMZpfH6LZ/Uvgb0hXNu8MgojZtR5JPa1ig6GaW2NeqNfNKYvZZRal9jXZXK5XK5398FBsnSpUtz2mmn5aabburx9dbW1px++un5yEc+MrA71gTuvPPOfPCDH0xXV9dag1lXV1c+97nP5fLLL1/jmBNPPDH/+I//mFKp1PA1iu7OO+/MjBkzMm/evDWOmThxYv793/89m2+++Wqv1eJz2Ug1iu7222/PjBkzMn/+/B5fb29vz/Tp0/PRj360x9eLcpyLUqMefeYzn8mVV16ZJFWDWVGOcVFqFN3FF1+cc845p1djewpmRTnORakBfeGcGzwyiowio9T/d4x8Utsa9UpGeX01ik5GqW0N6Avn3OCQTxo3nyQySq1rFJmMUtsa9UpGeX01ikw+qW0N6Avn3OCRURo3o8gnta1RdDJKbWvUI/nk9dUoOhmltjVqwR1waGhnnHFG5UO2zTbb5Nhjj82GG26Yhx56KJdddlkWL16c888/PxMmTMh73/vewd3ZBvLggw9m+vTp6erq6tX4r33ta5Ugs8kmm+T444/PZpttlj/+8Y+55JJLMm/evPzgBz/IuHHjcuqppzZ8jSJ75JFH8rGPfSxLlixJ8toP64MOOiijR4/Os88+m5/97GeZPXt2Zs+enQ996EP5yU9+klGjRnWrUYvPZSPVKLKV/V62bFmS5G1ve1v222+/jBw5Mg8//HB+9KMfZenSpfnqV7+akSNH5sQTT1ytRlGOc1Fq1JubbrqpEsrWpijHuCg1iu7RRx9NkowYMSL//M//XHXsuHHjVnuuKMe5KDWgL5xzg0NGkVFklPr/jpFPal+jHskojdtvGaW2NaAvnHMDTz5p3HySyCj9UaOoZJTa16hHMkpj9ls+qW0N6Avn3OCQURo3o8gnta9RZDJK7WvUG/mkcXsto9S2Rk2UoUHddttt5UmTJpUnTZpUPumkk8pLly7t9vpjjz1W3nPPPcuTJk0q77nnnuVXXnllkPa0sdx0003l3XffvXLsJ02aVP7617++xvGPPfZY+U1velN50qRJ5Xe9613l+fPnd3t97ty55be//e3lSZMmlXfYYYfynDlzGrpG0Z1wwgmVvl5yySWrvd7R0VH+5Cc/WRlz7rnndnu9Fp/LRqpRdMcff3zVfj/xxBOVz/tuu+222t+xKMe5KDXqzYIFC8r77bdft+/zT3/60z2OLcoxLkqNenD00UeXJ02aVD7uuOP6vG1RjnNRakBfOOcGh4wio8gova9RZPJJbWvUIxmlsfsto9SuBvSFc27gySeNnU/KZRml1jWKTEapbY16JKM0br/lk9rVgL5wzg0OGaWxM4p8UtsaRSej1LZGvZFPGrvXMkrtatRKS/9N7YHB9Z3vfCdJ0tbWlnPOOSdDhw7t9vo222yTM888M0kyf/78qreSZO2WL1+er3/96/noRz+ahQsX9nq773//++ns7EySnHXWWdlggw26vb7RRhvlvPPOS5J0dHTku9/9bkPXKLLHH388d999d5Lk4IMPzrRp01Yb09bWli9+8YvZaKONkiRXXHFF5ZgktflcNlKNInvsscdyzz33JHltBYye+r3VVlvlwx/+cJJk0aJFueWWW7q9XpTjXJQa9eZLX/pSnn/++dVWN+lJUY5xUWoUXVdXVx577LEkr91Kuq+KcpyLUgP6wjk3sGQUGSWRUfpao6jkk9rXqEcySuP2W0apbQ3oC+fcwJFPGj+fJDJKf9QoKhml9jXqkYzSmP2WT2pbA/rCOTewZJTGzyjySe1rFJmMUvsa9UY+adxeyyi1rVErJuDQkObPn5877rgjSTJ16tRsvvnmPY477LDDKrfbuu666wZs/xrNHXfckUMPPTQXXHBBurq6Mnz48Jxyyilr3a6rqyvXX399kmTSpEnZfffdexy36667ZocddkiSXH/99SmXyw1Zo+juvPPOyuNqt2YbOnRoDjjggCTJggUL8uSTTyapzeeykWoU3fz587P33ntnww03zDvf+c41jttuu+0qj5955plu2xfhOBelRr1Z9Zakn/rUp6qOLcoxLkqNevDUU09l8eLFSV77mdUXRTnORakBfeGcG1gyioyyKhmldzWKTD6pbY16JKM0dr9llNrVgL5wzg0c+aQ58kkio9S6RpHJKLWtUY9klMbtt3xSuxrQF865gSWjNEdGkU9qW6PoZJTa1qg38klj91pGqV2NWjIBh4Z0zz33pKurK0my9957r3FcS0tL9thjjyTJzJkzs2DBggHZv0bzi1/8InPmzEmS7Ljjjrn88ssr/zCvZtasWZk/f36S6n1a9fXnn38+jz76aEPWKLqWlpZMnDgxI0eOzFZbbVV17KqrQqxcKaMWn8tGqlF0u+++e77//e/n9ttvzzHHHLPGcc8991zl8fjx4yuPi3Kci1KjnixcuLAyE/y4447LW97ylqrji3KMi1KjHqz6s6evwawox7koNaAvnHMDS0aRUf6ajLL2GkUmnzRPr3siozR+v2WU2tWAvnDODRz5pDnySSKjNNPPNRmleXrdExmlsfstn9SuBvSFc25gySjNkVHkk+b6uSajNFe/VyWfNH6vZZTa1aglE3BoSLNnz648XtsXzrbbbpskKZfLmTVrVr/uVyMbO3ZsPve5z+XHP/5x5ZiuzarHu7d9SpJHHnmkIWsU3fHHH5+rr746v/vd79b6d1x5y7skGT16dJLafC4bqUYjmD9/fuW2fsOGDcv+++9fea0ox7koNerJyluSbrLJJmtdFSEpzjEuSo16sOr+rrw16dNPP53bbrstd955Z5599tk1bluU41yUGtAXzrmBJ6PIKKuSUdZeo97JJ72vUW9klHWrUQ9klNrVgL5wzg0s+aTx80kio/i51p2M0vsa9UZGWbcaRSef1K4G9IVzbuDJKI2fUeQTP9f+mozS+xr1RD5Ztxr1QEapXY1aMgGHhrTq7fE222yzqmM33njjHrej90444YTceOONOeGEE9La2trr7frSp0022aTH7RqpRqOYO3dubr311iTJmDFjsuWWWyapzeeykWrUq2XLluWPf/xjvv3tb+c973lP5dazn/nMZzJ27NjKuKIc56LUqBer3pL07LPPzsiRI9e6TVGOcVFq1IOVKyNsuOGGueWWW3LYYYfl4IMPzoc+9KGcfPLJOeCAA3LUUUfllltuWW3bohznotSAvnDODSwZRUZZlYzSuxr1SD5p/F7LKM3RbxmldjWgL5xzA0c+kU/+mozSuxr1SEZp/F7LKI3fb/mkdjWgL5xzA0tGkVFWJZ/0rka9klEau9/ySXP0WkapXY1aauuXqjDI5s2bV3k8ZsyYqmNXztpOUrm1JH2z0047va7t+tKnVW91uWqfGqlGozjvvPPS0dGRJHnXu96VlpbX5nrW4nPZSDXq0YMPPpj3ve993Z4bP358/uEf/iGHHXZYt+eLcpyLUqMerHpL0iOOOCJvfetbe7VdUY5xUWrUg5XB7MUXX8ynP/3pHsc89NBD+du//dt8/OMfz/Tp0yvPF+U4F6UG9IVzbmDJKDLKqmSU3tWoN/JJ4/daRmmefssotasBfeGcGzjyiXzy12SU3tWoNzJK4/daRmmOfssntasBfeGcG1gyioyyKvmkdzXqkYzS2P2WT5qn1zJK7WrUkjvg0JCWLl1aeTx06NCqY4cMGdLjdvS/VY/3qn3oyap9XHW7RqrRCC677LJcc801SZLhw4fnIx/5SOW1WnwuG6lGPXruuedWe27+/Pn55S9/WVkhYaWiHOei1KgHK29JujJs91ZRjnFRahTd4sWL8/TTT1f+vOWWW+af//mfc9ttt+X+++/PL37xi5x44okplUpJkm984xu54oorKuOLcpyLUgP6wjlXH4qSDYpSoxHIKL2vUW/kk8bvtYzSHP2WUZqr3xSLc674ipILilKjUcgova9Rb2SUxu+1jNL4/ZZPmqfXFI9zrj4UJRsUpUYjkE96X6MeySiN3W/5pDl6LaMUt9/ugENDWrFiReXx2v6RvOrrq25H/6tFnxqpRr371a9+lS984QuVP5911lmZMGFC5c9FOc5FqVGPxowZkzPPPDNjx47Nc889l5///Od55JFHcsMNN+TOO+/M97///eywww5JinOci1Kj6Fa9JelZZ53VbQWXtSnKMS5KjaJ76qmnMnTo0CxdujS77rprLrzwwm63oJ08eXLOPPPM7LjjjvnMZz6T5LUVbw455JCMGDGiMMe5KDWgL5xz9aEo3y9FqVHvZJS+1ag38klj91pGqV2NopNRmqvfFItzrviK8t1SlBqNQEbpW416I6M0dq9llNrVKDL5pHl6TfE45+pDUb5filKj3sknfatRj2SUxu23fFK7GkUnoxS33+6AQ0Nab731Ko9X3iJxTZYvX155vLYPJbX1evvU3t7ekDXq2Q033JDTTz89nZ2dSZKTTjop733ve7uNqcXnspFq1KMpU6bkxBNPzGGHHZYPfvCDufLKK3PcccclSV555ZX8/d//feUcKMpxLkqNIlv1lqSHHXZYDj744D5tX5RjXJQaRbfddtvlvvvuyy233JJvf/vb3ULZqo488sgceOCBSV5bAeW///u/kxTnOBelBvSFc64+FCUbFKVGPZNR+l6j3sgnjdtrGaW5+i2jNFe/KRbnXPEVJRcUpUa9k1H6XqPeyCiN22sZpXn6LZ80T68pHudcfShKNihKjXomn/S9Rj2SURqz3/JJ8/Q6kVGK3G8TcGhIw4cPrzxetmxZ1bGrftDWdlsqamvVPq3ah56s2sdVv0gbqUa9uvzyy/N//+//rfxQO/LII3u8rWEtPpeNVKMRtLS05POf/3wmT56cJPnjH/+Y2267LUlxjnNRahTZyluSrlz5oq+KcoyLUqMelEqlTJgwIeuvv37Vcav+D7Z77rknSXGOc1FqQF845+pDUbJBUWrUKxmlOb9j5JPe1yg6GaW5+p3IKLWsAX3hnCu+ouSCotSoZzJKc37HyCi9r1F0Mkpz9Vs+qV0N6AvnXH0oSjYoSo16JZ8073eMjNL7GkUmnzRPr1eSUWpXo5ZMwKEhjRo1qvJ4/vz5Vceu+vrYsWP7aY/oSV/6tGDBgsrjVfvUSDXq0b/927/lH//xHyu3aXvf+96XL33pSymVSquNrcXnspFqNIrW1tYcffTRlT///ve/T1Kc41yUGkW16i1JV952tq+KcoyLUqORvPGNb6w8fv7555MU5zgXpQb0hXOuPhQlGxSlRj2SUZr7O0Y+6V2NIpNRmqvffSWjrL0G9IVzrviKkguKUqNeySjN/R0jo/SuRpHJKM3V776QT9ZeA/rCOVcfipINilKjHsknvmNklN7VKCr5pHl6/XrIKGuvUUsm4NCQttpqq8rjP//5z1XHPvfcc5XHm266aX/tEj3oS59WfX3VPjVSjXrS1dWVz33uc/nGN75Ree6kk07KF7/4xbS09PyjpRafy0aq0Ui23nrryuN58+YlKc5xLkqNorruuusqj2fMmJHJkyev9t9BBx1UGXPllVdWnl/5+S/KMS5KjUbS1ta22nNFOc5FqQF94ZyrD0XJBkWpUU9klHWv0Sjkk7XXKDIZpbn63VcyytprQF8454qvKLmgKDXqjYyy7jUahYyy9hpFJqM0V7/7Qj5Zew3oC+dcfShKNihKjXoin6x7jUYio6y9RlHJJ83T69dDRll7jVoyAYeGtM0221Qez549u+rYla+XSqVMnDixX/eL7rbddtvK4972KUkmTZrUkDXqRVdXVz71qU/lRz/6UeW50047LWeccUaPKyKsVIvPZSPVKLorr7wyn/jEJ3LkkUdm4cKFVceueku/ESNGJCnOcS5KjUZWlGNclBpFd8stt+Rb3/pWzj333Lz88stVx86dO7fyePz48UmKc5yLUgP6wjlXH4qSDYpSo17IKI3/HSOfNE+va6Eox7koNYpORmmuflMszrniK0ouKEqNeiKjNP53jIzSPL2uhaIc56LUKDL5pHl6TfE45+pDUbJBUWrUC/mkOb5jZJTm6ve6KMoxLkqNopNRittvE3BoSLvuumva29uTJHfdddcax3V2dubuu+9Okmy33XbdblFF/9t6662z4YYbJqnep1VfHz16dLcw00g16sVZZ52Vq666KknS0tKSs846K6eeeupat6vF57KRahTdrFmzcv311+cPf/hD7rzzzqpj77///srjlbcyLMpxLkqNovrABz6QCy64oOp/X/jCFyrj99prr8rzhx12WJLiHOOi1Ci6G264Ieeff36+973v5Z577qk6dtXP/i677JKkOMe5KDWgL5xz9aEo2aAoNeqFjNL43zHySfP0WkZprn4nMkqz9Zticc4VX1FyQVFq1BMZpfG/Y2SU5um1jNJc/ZZPmqfXFI9zrj4UJRsUpUa9kE+a4ztGRmmOfssnzdPrlWSU4vbbBBwa0qhRo7L33nsnSX7961/n2Wef7XHcNddcU7mN3qGHHjpg+8drWlpacvDBBydJHnzwwdx33309jvvd736Xhx56KElyyCGHdLv1ZSPVqAdXXHFFZUWElpaWnHvuuZk2bVqvtq3F57KRahTd1KlTK48vueSSNY6bP39+Lr/88iRJe3t73vrWtyYpznEuSo2i2mGHHXLwwQdX/W/fffetjN90000rz6+cVV6UY1yUGkW38u+XJJdddtkax82bN6/yfT9s2LC84x3vSFKc41yUGtAXzrn6UJRsUJQa9UBGqV2NIpNPalujyGSU5up3IqPUugb0hXOu+IqSC4pSo17IKLWrUWQySm1rFJmM0lz9lk9qWwP6wjlXH4qSDYpSox7IJ7WrUXQySm1rFJV80jy9XklGqW2NWqqvfxFAH5x88slJko6OjsyYMSOLFi3q9vpjjz2WL37xi0leu5XeMcccM9C7SF6bldvW1pYk+fSnP50XXnih2+tz587NZz7zmSRJa2tr/uZv/qahaxTZiy++WPnMJK/9HY844og+1ajF57KRahTZ3nvvne222y5J8pvf/CYXXXTRamMWLVqUj3/845V/sBx77LGZMGFC5fWiHOei1GhkRTnGRalRZAcffHA23njjJMltt92W73znO6uNWbhwYaZPn5758+cnSU455ZRssMEGldeLcpyLUgP6wjlXH4qSDYpSo8hklNrXKCr5pPY1Gl1RjnNRahSZjFL7GtAXzrniK0ouKEqNopNRal+jqGSU2tdodEU5zkWpUVTySe1rQF845+pDUbJBUWoUmXxS+xpFJqPUvkYjK8oxLkqNIpNRal+jVkrlcrncb9VhkH3iE5/I9ddfnyR5wxvekGnTpmWTTTbJH/7wh1x66aV59dVXkyRnn3123v/+9w/mrjacu+66KyeddFKSZPr06fn4xz++xrHnnXde5QfDuHHjcvzxx2frrbfOE088kUsuuSQvvfRSkuQjH/lIPvnJTzZ8jaI6//zz861vfSvJa7OjzzjjjF5tt/3222fTTTet/LkWn8tGqlFkDz30UE444YQsWbIkSbLffvvlHe94R9Zff/3Mnj07l19+eeV/QGy//fa55JJLMmzYsG41inKci1KjHs2ZMycHHXRQkuTII4/Ml7/85R7HFeUYF6VGkd1888352Mc+ls7OziTJvvvum0MOOaTHz/aee+6Ziy66KEOGDOlWoyjHuSg1oC+cc4NHRpFRVpJR6vM7Rj6pfY16JaM0Xr9llNrXgL5wzg0O+aTx8kkio/RXjaKSUWpfo17JKI3Vb/mk9jWgL5xzg0dGabyMIp/0T40ik1FqX6MeySeN12sZpfY1asEEHBrakiVLMn369Nx22209vl4qlTJ9+vRMnz59gPes8fUlmHV2duaMM87IlVdeucYxxxxzTL7whS+s8VaejVSjqPbbb7/VVnvojXPPPTdHHXVU5c+1+Fw2Uo2i++1vf5vTTz+98j8VejJ16tT867/+a0aNGrXaa0U5zkWpUY96G8yKcoyLUqPofvnLX+Yf/uEfsnjx4jWOOfDAA/Mv//IvGTFixGqvFeU4F6UG9IVzbvDIKDLKSjJK/X7HyCe1rVGvZJTXV6PoZJTa1oC+cM4NDvmk8fJJIqP0V40ik1FqW6NeySivr0aRySe1rQF94ZwbPDJK42UU+aR/ahSdjFLbGvVIPnl9NYpORqltjVowAYeGVy6Xc9VVV+VnP/tZHn744bzyyisZPXp0pkyZkpNOOilTpkwZ7F1sSH0JZivdfPPNueyyy/LAAw9k/vz5GTlyZN785jdn2rRpedvb3tar922kGkUyb968vOUtb3ld2/51MEtq87lspBpFt2DBgvzwhz/Mr3/96zzxxBNZtmxZxo0bl1133TVHHnlk3vrWt1bdvijHuSg16k1vg1lSnGNclBpF9/zzz+eHP/xhbrnllvzpT39KR0dHNtxww7z5zW/22W7AflMszrnBIaPIKCvJKPX9HSOf1LZGPZJRGrffMkpta0BfOOcGnnzSWPkkkVH6u0aRySi1rVGPZJTG7Ld8Utsa0BfOucEhozRWRpFP+rdG0ckota1Rb+STxu21jFLbGuvKBBwAAAAAAAAAAAAAAACoor7uiwcAAAAAAAAAAAAAAAADzAQcAAAAAAAAAAAAAAAAqMIEHAAAAAAAAAAAAAAAAKjCBBwAAAAAAAAAAAAAAACowgQcAAAAAAAAAAAAAAAAqMIEHAAAAAAAAAAAAAAAAKjCBBwAAAAAAAAAAAAAAACowgQcAAAAAAAAAAAAAAAAqMIEHAAAAAAAAAAAAAAAAKjCBBwAAAAAAAAAAAAAAACowgQcAAAAAAAAAAAAAAAAqMIEHAAAAAAAAAAAAAAAAKjCBBwAAAAAAAAAAAAAAACowgQcAAAAAAAAAAAAAAAAqMIEHAAAAAAAAAAAAAAAAKjCBBwAAAAAAAAAAAAAAACowgQcACioOXPmZPLkyZk8eXI+8IEPDPbuAAAATU5GAQAAikRGAQAAikI+AWgeJuAAAAAAAAAAAAAAAABAFSbgAAAAAAAAAAAAAAAAQBWlcrlcHuydAAAAAAAAAAAAAAAAgKJyBxwAAAAAAAAAAAAAAACowgQcAAAAAAAAAAAAAAAAqKJtsHcAABpdV1dXbrjhhlx77bV54IEH8uKLL6atrS1jx47NzjvvnAMOOCDvete70tra2m27OXPm5KCDDkqS7Lnnnrn44osrr33gAx/Ib3/72z7vy7nnnpujjjqqx9dmzpyZK664InfddVeef/75dHZ2ZsMNN8yUKVNy+OGHZ7/99uvz+wEAAMUjowAAAEUiowAAAEUhnwCwNibgAEA/mjdvXk499dTce++93Z5fvnx5Fi9enDlz5uTaa6/NN7/5zXzrW9/KFltsMeD7uGzZspx55pn5+c9/vtprc+bMyZw5c/Lzn/88U6dOzfnnn58NNthgwPcRAACoDRkFAAAoEhkFAAAoCvkEgN4wAQcA+tGMGTMqoWzMmDE58MADs/nmm6ejoyNPPvlkbrjhhnR0dOSJJ57IBz/4wVx77bUZMmTIWutOmzYtb3vb29Y67pprrslDDz2UJBk/fnz23Xffbq8vX748p5xySn73u98lSdrb2zN16tRsv/32KZVKefzxx3PTTTdl8eLFufXWW3PCCSfksssuy8iRI/t4JAAAgCKQUQAAgCKRUQAAgKKQTwDoDRNwAKCf/P73v8+dd96ZJNlmm21yySWXZPTo0d3GPPXUUzn++OPzwgsv5Omnn861116bI444Yq21DzvssLWOufnmm/Pwww8neS1wfeMb38iECRO6jTn//PMroWz77bfP1772tdVWZ3j++efzyU9+Mr/97W8ze/bs/NM//VPOO++8tb4/AABQLDIKAABQJDIKAABQFPIJAL3VMtg7AACNaubMmZXHxx577GqhLEm22GKLzJgxI0lSKpXywAMP1OS9H3/88cyYMSNdXV1JkrPOOiu77rprtzFz587ND3/4wyTJ2LFjc9FFF/V4a9SNNtoo//7v/57x48cnSX7xi1/kySefrMl+AgAAA0dGAQAAikRGAQAAikI+AaC3TMABgH7S2tpaeXzfffetcdyhhx6aa665JjNnzsyZZ565zu87f/78fPSjH82iRYuSJCeeeGKOPvro1cZdeeWV6ejoSPJacBw7duwaa44cOTInnXRSkqSrqytXX331Ou8nAAAwsGQUAACgSGQUAACgKOQTAHqrbbB3AAAa1Z577ll5/Mtf/jILFy7MMccck3333TejRo2qvDZs2LBsu+22NXnPFStW5BOf+ESeeuqpyj589rOf7XHs3XffXXm8/fbbr7X2LrvsUnm88namAABA/ZBRAACAIpFRAACAopBPAOgtE3AAoJ9st912ee9735uf//znSZLbb789t99+e1pbW7PTTjtl6tSp2X///bPTTjulVCrV5D3POeec3HXXXUmSzTbbLF/72tfS1tbzj/vHHnus8vgTn/hEn97n2Wefff07CQAADAoZBQAAKBIZBQAAKAr5BIDeMgEHAPrROeeck3HjxuW//uu/smLFiiRJZ2dn7rvvvtx33335xje+kQkTJuTwww/PBz/4waq3B12bH/7wh7n00kuTvLbawje/+c2q9RYsWPC632tdtgUAAAaPjAIAABSJjAIAABSFfAJAb5TK5XJ5sHcCABrd3Llz88tf/jL/8z//k3vvvTcdHR2rjRk9enQuuuii7LjjjkmSOXPm5KCDDkry2i1GL7744jXWv+OOO/K3f/u3lfD31a9+NYcddljVfdpxxx0r+/GRj3wko0eP7vXfZ+jQoTnxxBN7PR4AACgWGQUAACgSGQUAACgK+QSAatwBBwAGwIQJE3LyySfn5JNPzuLFi/O73/0ud9xxR2688cY88cQTSZL58+fntNNOyw033JDW1tZe137yySdz+umnV0LZRz/60bWGsiTZYIMN8uKLLyZJDj300Gy//fav428GAADUIxkFAAAoEhkFAAAoCvkEgGpaBnsHAKDZDB8+PFOnTs2nP/3pXHfddfn617+e9vb2JK+thvD73/++17VeeeWVfPSjH63cKvSAAw7Iaaed1qttN99888rj2bNnr3X88uXLs2jRol7vGwAAUB9kFAAAoEhkFAAAoCjkEwD+mgk4ANBPzj333Bx33HHZY489Mnfu3DWOO+SQQ/KWt7yl8ufnnnuuV/U7Oztz+umnV1ZWeOMb35h/+Zd/SUtL736877777pXHv/rVr9Y6/uKLL86UKVOy11575XOf+1yv3gMAACgOGQUAACgSGQUAACgK+QSA3jIBBwD6ydNPP5377rsvCxcuzFVXXVV17Lx58yqPJ0yY0Kv6X/7yl3PbbbclSUaNGpVvfvObGTlyZK/374gjjkipVEryWjC755571jj25ZdfzkUXXZTktVuoTp48udfvAwAAFIOMAgAAFImMAgAAFIV8AkBvmYADAP3kfe97X+Xx1772tdx88809jvve976XBx98MEmy0UYbZZdddllr7csvvzz/9V//lSRpb2/P17/+9Wy99dZ92r9tt90273rXu5IkXV1d+bu/+7vcfvvtq42bO3duPvaxj+Wll15Kkmy66aY5+uij+/ReAADA4JNRAACAIpFRAACAopBPAOitUrlcLg/2TgBAo/rwhz+cW2+9tfLnXXfdNTvuuGPGjx+fBQsW5O67787999+fJCmVSjn//PMrYWnOnDk56KCDkiR77rlnLr744iTJgw8+mPe///3p6OhIkrz97W/PAQcckCVLlmTFihXp7Oysuk8f+tCHKo8XLVqU4447Lo899ljluSlTpmSPPfZIe3t7/vjHP+ZXv/pVli1bliQZOnRovvvd72bKlCnremgAAIBBIKMAAABFIqMAAABFIZ8A0Bsm4ABAP1q0aFFOO+20yi1E12TEiBH57Gc/m2OOOaby3JqC2RVXXJHPfvazr3ufHn300W5/XrhwYT71qU/lxhtvrLrdxhtvnK985SvZc889X/d7AwAAg0tGAQAAikRGAQAAikI+AaA32gZ7BwCgkY0cOTIXXXRRbr755lx99dV54IEHMnfu3CxfvjxjxozJ5ptvnre+9a056qijstFGGw3KPo4aNSr/8R//kXvuuSe/+MUvcvfdd+f555/PsmXLMmrUqEyePDkHHXRQjjzyyIwYMWJQ9hEAAKgNGQUAACgSGQUAACgK+QSA3nAHHAAAAAAAAAAAAAAAAKiiZbB3AAAAAAAAAAAAAAAAAIrMBBwAAAAAAAAAAAAAAACowgQcAAAAAAAAAAAAAAAAqMIEHAAAAAAAAAAAAAAAAKjCBBwAAAAAAAAAAAAAAACowgQcAAAAAAAAAAAAAAAAqMIEHAAAAAAAAAAAAAAAAKjCBBwAAAAAAAAAAAAAAACowgQcAAAAAAAAAAAAAAAAqMIEHAAAAAAAAAAAAAAAAKjCBBwAAAAAAAAAAAAAAACowgQcAAAAAAAAAAAAAAAAqMIEHAAAAAAAAAAAAAAAAKjCBBwAAAAAAAAAAAAAAACowgQcAAAAAAAAAAAAAAAAqMIEHAAAAAAAAAAAAAAAAKjCBBwAAAAAAAAAAAAAAACowgQcAAAAAAAAAAAAAAAAqMIEHAAAAAAAAAAAAAAAAKjCBBwAAAAAAAAAAAAAAACowgQcAAAAAAAAAAAAAAAAqMIEHAAAAAAAAAAAAAAAAKjCBBwAAAAAAAAAAAAAAACowgQcAAAAAAAAAAAAAAAAqMIEHAAAAAAAAAAAAAAAAKjCBBwAAAAAAAAAAAAAAACo4v8HrmqokDUEnXsAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(ncols=len(q_lengths), figsize=(20, 5), dpi=200)\n", + "for j, (i, grp) in enumerate(times.groupby(\"q_length\")):\n", + " grp.droplevel(1).plot(label=i, ax=ax[j])\n", + " ax[j].set_title(f\"query length {i}\")\n", + "ax[0].set_ylabel(\"time in seconds\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "75f15e37-5735-4d33-b2cf-70235420b724", + "metadata": {}, + "source": [ + "As you can see, the larger the size of `q`, the greater the speedups. This is because the larger the size of `q`, the more recomputation we avoid by using a sliding sum." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (Spyder)", + "language": "python3", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/similarity_search/distance_profiles.ipynb b/examples/similarity_search/distance_profiles.ipynb index a4db064509..25ca2fe6f7 100644 --- a/examples/similarity_search/distance_profiles.ipynb +++ b/examples/similarity_search/distance_profiles.ipynb @@ -5,7 +5,15 @@ "id": "2be06527-dbbe-4c32-af27-0b0ff904311d", "metadata": {}, "source": [ - "# Deep dive in distance profile" + "# Deep dive in the distance profiles" + ] + }, + { + "cell_type": "markdown", + "id": "d778bc25-a0c4-46b5-a14b-b0c92a1e5f3a", + "metadata": {}, + "source": [ + "In this notebook, we will talk more about the theory behind distance profile, how they are computed, and how they can be optimized. For practical experiments on the speedups implemented in aeon, refer to the notebook on the [Analysis of the speedups provided by similarity search module](code_speed.ipynb) notebook." ] }, { @@ -18,10 +26,20 @@ }, { "cell_type": "markdown", - "id": "e5ab1135-04bc-4367-8af6-426f07b53203", + "id": "fad95e02-3d0e-46d7-98bc-7ba6aac66bd3", "metadata": {}, "source": [ - "## Mueen's algorithm for normalized euclidean distance" + "In the context of similarity search, where we have as input a time series $X = \\{x_1, \\ldots, x_m\\}$ and a query $Q = \\{q_1, \\ldots, q_l\\}$, a distance profile is defined as a vector containing the similarity of $Q$ to every subsequence of size $l$ in $X$, with the $i^{th}$ subsequence denoted by $W_i = \\{x_i, \\ldots, x_{i+(l-1)}\\}$.\n", + "\n", + "Given a distance or dissimilarity function $dist$, such as the Euclidean distance, the distance profile $P(X,Q)$ is expressed as :\n", + "$$P(X, Q) = \\{dist(W_1, Q), \\ldots, dist(W_{m-(l-1)}, Q)\\}$$\n", + "\n", + "We can then find the \"best match\" between $Q$ and $X$ by looking at the distance profile minimum value and extract the subsequence $W_{\\text{argmin} P(X,Q)}$ as the best match.\n", + "\n", + "### Trivial matches\n", + "One should be careful of what is called \"trivial matches\" in this situation. If $Q$ is extracted from $X$, it is extremely likely that it will match with itself, as $dist(Q,Q)=0$. To avoid this, it is common to set the parts of the distance profile that are neighbors to $Q$ to $\\infty$. This is the role of the `q_index` parameter in the similarity search `predict` methods. The `exclusion_factor` parameter is used to define the neighbors of $Q$ that will also get $\\infty$ value.\n", + "\n", + "For example, if $Q$ was extracted at index $i$ in $X$ (i.e. $Q = \\{x_i, \\ldots, x_{i+(l-1)}\\}$), then all points in the interval `[i - l//exclusion_factor, i + l//exclusion_factor]` will the set to $\\infty$ in the distance profile to avoid a trivial match.\n" ] } ], diff --git a/examples/similarity_search/similarity_search.ipynb b/examples/similarity_search/similarity_search.ipynb index 690d69e55a..79fc4e21ca 100644 --- a/examples/similarity_search/similarity_search.ipynb +++ b/examples/similarity_search/similarity_search.ipynb @@ -21,7 +21,8 @@ "\n", "This notebook gives an overview of similarity search module and the available estimators. The following notebooks are avaiable to go more in depth with specific subject of similarity search in aeon:\n", "\n", - "- TBA" + "- [Deep dive in the distance profiles](distance_profiles.ipynb)\n", + "- [Analysis of the speedups provided by similarity search module](code_speed.ipynb)" ] }, { From e0c82fd65c685f49fe3eb367b738ea62a9484585 Mon Sep 17 00:00:00 2001 From: Antoine Guillaume Date: Mon, 23 Oct 2023 15:02:52 +0200 Subject: [PATCH 28/31] Fixing tests and docs that where not updated after previous changes --- .../distance_profiles/naive_euclidean.py | 10 +++++++--- .../normalized_naive_euclidean.py | 9 +++++++-- .../tests/test_naive_euclidean.py | 10 +++++++--- .../tests/test_normalized_naive_euclidean.py | 14 +++++++++----- aeon/similarity_search/top_k_similarity.py | 6 +++--- 5 files changed, 33 insertions(+), 16 deletions(-) diff --git a/aeon/similarity_search/distance_profiles/naive_euclidean.py b/aeon/similarity_search/distance_profiles/naive_euclidean.py index 75fb335519..d61d2c15c8 100644 --- a/aeon/similarity_search/distance_profiles/naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/naive_euclidean.py @@ -27,14 +27,18 @@ def naive_euclidean_profile(X, q, mask): ---------- X: array shape (n_cases, n_channels, series_length) The input samples. - q : np.ndarray shape (n_channels, query_length) The query used for similarity search. + mask : array, shape (n_instances, n_channels, n_timestamps - (q_length - 1)) + Boolean mask of the shape of the distance profile indicating for which part + of it the distance should be computed. Returns ------- - distance_profile : np.ndarray shape (n_cases, series_length - query_length + 1) - The distance profile between q and the input time series X. + distance_profile : np.ndarray + shape (n_cases, n_channels, series_length - query_length + 1) + The distance profile between q and the input time series X independently + for each channel. """ return _naive_euclidean_profile(X, q, mask) diff --git a/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py b/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py index 7ec2790a33..27649ac4a5 100644 --- a/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/normalized_naive_euclidean.py @@ -34,6 +34,9 @@ def normalized_naive_euclidean_profile(X, q, mask, X_means, X_stds, q_means, q_s The input samples. q : array, shape (n_channels, query_length) The query used for similarity search. + mask : array, shape (n_instances, n_channels, n_timestamps - (q_length - 1)) + Boolean mask of the shape of the distance profile indicating for which part + of it the distance should be computed. X_means : array, shape (n_instances, n_channels, series_length - (query_length-1)) Means of each subsequences of X of size query_length X_stds : array, shape (n_instances, n_channels, series_length - (query_length-1)) @@ -45,8 +48,10 @@ def normalized_naive_euclidean_profile(X, q, mask, X_means, X_stds, q_means, q_s Returns ------- - distance_profile : np.ndarray shape (n_instances, series_length - query_length + 1) - The distance profile between q and the input time series X. + distance_profile : np.ndarray + shape (n_instances, n_channels, series_length - query_length + 1). + The distance profile between q and the input time series X independently + for each channel. """ # Make STDS inferior to the threshold to 1 to avoid division per 0 error. diff --git a/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py b/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py index 31f9a463bd..00375d6ddf 100644 --- a/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py @@ -23,7 +23,8 @@ def test_naive_euclidean(dtype): ) q = np.asarray([[3, 4, 5]], dtype=dtype) - dist_profile = naive_euclidean_profile(X, q) + mask = np.ones(X.shape, dtype=bool) + dist_profile = naive_euclidean_profile(X, q, mask).sum(axis=1) expected = np.array( [ @@ -42,7 +43,9 @@ def test_naive_euclidean_constant_case(dtype): # Test constant case X = np.ones((2, 1, 10), dtype=dtype) q = np.zeros((1, 3), dtype=dtype) - dist_profile = naive_euclidean_profile(X, q) + + mask = np.ones(X.shape, dtype=bool) + dist_profile = naive_euclidean_profile(X, q, mask).sum(axis=1) # Should be full array for sqrt(3) as q is zeros of length 3 and X is full ones search_space_size = X.shape[-1] - q.shape[-1] + 1 expected = np.array([[3**0.5] * search_space_size] * X.shape[0]) @@ -55,6 +58,7 @@ def test_non_alteration_of_inputs_naive_euclidean(): q = np.asarray([[3, 4, 5]]) q_copy = np.copy(q) - _ = naive_euclidean_profile(X, q) + mask = np.ones(X.shape, dtype=bool) + _ = naive_euclidean_profile(X, q, mask) assert_array_equal(q, q_copy) assert_array_equal(X, X_copy) diff --git a/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py b/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py index ce90852b54..f450c26df8 100644 --- a/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py @@ -36,9 +36,11 @@ def test_normalized_naive_euclidean(dtype): q_means = q.mean(axis=-1) q_stds = q.std(axis=-1) + + mask = np.ones(X.shape, dtype=bool) dist_profile = normalized_naive_euclidean_profile( - X, q, X_means, X_stds, q_means, q_stds - ) + X, q, mask, X_means, X_stds, q_means, q_stds + ).sum(axis=1) _q = q.copy() for k in range(q.shape[0]): @@ -73,9 +75,10 @@ def test_normalized_naive_euclidean_constant_case(dtype): X_stds[i] = _std X_means[i] = _mean + mask = np.ones(X.shape, dtype=bool) dist_profile = normalized_naive_euclidean_profile( - X, q, X_means, X_stds, q_means, q_stds - ) + X, q, mask, X_means, X_stds, q_means, q_stds + ).sum(axis=1) # Should be full array for 0 expected = np.array([[0] * search_space_size] * X.shape[0]) @@ -101,7 +104,8 @@ def test_non_alteration_of_inputs_normalized_naive_euclidean(): q_means = q.mean(axis=-1, keepdims=True) q_stds = q.std(axis=-1, keepdims=True) - _ = normalized_naive_euclidean_profile(X, q, X_means, X_stds, q_means, q_stds) + mask = np.ones(X.shape, dtype=bool) + _ = normalized_naive_euclidean_profile(X, q, mask, X_means, X_stds, q_means, q_stds) assert_array_equal(q, q_copy) assert_array_equal(X, X_copy) diff --git a/aeon/similarity_search/top_k_similarity.py b/aeon/similarity_search/top_k_similarity.py index ac396f9c35..45bf1d3738 100644 --- a/aeon/similarity_search/top_k_similarity.py +++ b/aeon/similarity_search/top_k_similarity.py @@ -40,7 +40,7 @@ def _fit(self, X, y): Parameters ---------- - X : array, shape (n_cases, n_channels, n_timestamps) + X : array, shape (n_instances, n_channels, n_timestamps) Input array to used as database for the similarity search y : optional Not used. @@ -62,7 +62,7 @@ def _predict(self, q, mask): ---------- q : array, shape (n_channels, q_length) Input query used for similarity search. - mask : array, shape (n_samples, n_channels, n_timestamps - (q_length - 1)) + mask : array, shape (n_instances, n_channels, n_timestamps - (q_length - 1)) Boolean mask of the shape of the distance profile indicating for which part of it the distance should be computed. @@ -88,7 +88,7 @@ def _predict(self, q, mask): if self.store_distance_profile: self._distance_profile = distance_profile - # For now, deal with the multidimensional case as "fully dependent" + # For now, deal with the multidimensional case as "dependent", so we sum. distance_profile = distance_profile.sum(axis=1) search_size = distance_profile.shape[-1] From a625f9f2146740abfa42c1c4ce6527b840bad2cb Mon Sep 17 00:00:00 2001 From: Antoine Guillaume Date: Mon, 23 Oct 2023 15:56:10 +0200 Subject: [PATCH 29/31] Force float convertion of input to avoid issues with normalization of int types --- aeon/similarity_search/base.py | 4 ++-- .../distance_profiles/tests/test_naive_euclidean.py | 2 +- .../tests/test_normalized_naive_euclidean.py | 7 ++++--- 3 files changed, 7 insertions(+), 6 deletions(-) diff --git a/aeon/similarity_search/base.py b/aeon/similarity_search/base.py index 3ba4d99828..1e69889f44 100644 --- a/aeon/similarity_search/base.py +++ b/aeon/similarity_search/base.py @@ -99,7 +99,7 @@ def fit(self, X, y=None): # Get distance function self.distance_profile_function = self._get_distance_profile_function() - self._X = X + self._X = X.astype(float) self._fit(X, y) return self @@ -201,7 +201,7 @@ def predict(self, q, q_index=None, exclusion_factor=2.0): self._q_stds = np.std(q, axis=-1) self._store_mean_std_from_inputs(q_length) - return self._predict(q, mask) + return self._predict(q.astype(float), mask) @abstractmethod def _fit(self, X, y): diff --git a/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py b/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py index 00375d6ddf..eec58bd37e 100644 --- a/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py @@ -13,7 +13,7 @@ naive_euclidean_profile, ) -DATATYPES = ["int64", "float64"] +DATATYPES = ["float64"] @pytest.mark.parametrize("dtype", DATATYPES) diff --git a/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py b/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py index f450c26df8..1cac748ef1 100644 --- a/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py @@ -14,7 +14,7 @@ ) from aeon.utils.numba.general import sliding_mean_std_one_series -DATATYPES = ["int64", "float64"] +DATATYPES = ["float64"] @pytest.mark.parametrize("dtype", DATATYPES) @@ -36,11 +36,12 @@ def test_normalized_naive_euclidean(dtype): q_means = q.mean(axis=-1) q_stds = q.std(axis=-1) - mask = np.ones(X.shape, dtype=bool) + dist_profile = normalized_naive_euclidean_profile( X, q, mask, X_means, X_stds, q_means, q_stds - ).sum(axis=1) + ) + dist_profile = dist_profile.sum(axis=1) _q = q.copy() for k in range(q.shape[0]): From b6d322f2d7230722f2f3bfafa68815f59df64f7f Mon Sep 17 00:00:00 2001 From: Antoine Guillaume Date: Fri, 27 Oct 2023 17:49:37 +0200 Subject: [PATCH 30/31] Adding dummy class and test, correcting some docstrings --- aeon/similarity_search/_dummy.py | 93 +++++++++++++++++++ aeon/similarity_search/base.py | 11 ++- aeon/similarity_search/tests/test_dummy.py | 36 +++++++ .../tests/test_top_k_similarity.py | 7 +- aeon/similarity_search/top_k_similarity.py | 23 ++++- 5 files changed, 163 insertions(+), 7 deletions(-) create mode 100644 aeon/similarity_search/_dummy.py create mode 100644 aeon/similarity_search/tests/test_dummy.py diff --git a/aeon/similarity_search/_dummy.py b/aeon/similarity_search/_dummy.py new file mode 100644 index 0000000000..e52d914534 --- /dev/null +++ b/aeon/similarity_search/_dummy.py @@ -0,0 +1,93 @@ +"""Dummy similarity seach estimator.""" + +__author__ = ["baraline"] +__all__ = ["DummySimilaritySearch"] + + +from aeon.similarity_search.base import BaseSimiliaritySearch + + +class DummySimilaritySearch(BaseSimiliaritySearch): + """ + DummySimilaritySearch for testing of the BaseSimiliaritySearch class. + + Parameters + ---------- + distance : str, default ="euclidean" + Name of the distance function to use. + normalize : bool, default = False + Whether the distance function should be z-normalized. + store_distance_profile : bool, default = =False. + Whether to store the computed distance profile in the attribute + "_distance_profile" after calling the predict method. + """ + + def __init__( + self, distance="euclidean", normalize=False, store_distance_profile=False + ): + super(DummySimilaritySearch, self).__init__( + distance=distance, + normalize=normalize, + store_distance_profile=store_distance_profile, + ) + + def _fit(self, X, y): + """ + Private fit method, does nothing more than the base class. + + Parameters + ---------- + X : array, shape (n_instances, n_channels, n_timestamps) + Input array to used as database for the similarity search + y : optional + Not used. + + Returns + ------- + self + + """ + return self + + def _predict(self, q, mask): + """ + Private predict method for DummySimilaritySearch. + + It compute the distance profiles and then returns the best match + + Parameters + ---------- + q : array, shape (n_channels, q_length) + Input query used for similarity search. + mask : array, shape (n_instances, n_channels, n_timestamps - (q_length - 1)) + Boolean mask of the shape of the distance profile indicating for which part + of it the distance should be computed. + + Returns + ------- + array + An array containing the index of the best match between q and _X. + + """ + if self.normalize: + distance_profile = self.distance_profile_function( + self._X, + q, + mask, + self._X_means, + self._X_stds, + self._q_means, + self._q_stds, + ) + else: + distance_profile = self.distance_profile_function(self._X, q, mask) + + if self.store_distance_profile: + self._distance_profile = distance_profile + + # For now, deal with the multidimensional case as "dependent", so we sum. + search_size = distance_profile.shape[-1] + distance_profile = distance_profile.sum(axis=1) + _id_best = distance_profile.argmin(axis=None) + + return [(_id_best // search_size, _id_best % search_size)] diff --git a/aeon/similarity_search/base.py b/aeon/similarity_search/base.py index 1e69889f44..e98491eccd 100644 --- a/aeon/similarity_search/base.py +++ b/aeon/similarity_search/base.py @@ -19,7 +19,7 @@ class BaseSimiliaritySearch(BaseEstimator, ABC): """BaseSimilaritySearch. - Attributes + Parameters ---------- distance : str, default ="euclidean" Name of the distance function to use. @@ -28,6 +28,15 @@ class BaseSimiliaritySearch(BaseEstimator, ABC): store_distance_profile : bool, default = False. Whether to store the computed distance profile in the attribute "_distance_profile" after calling the predict method. + + Attributes + ---------- + _X : array, shape (n_instances, n_channels, n_timestamps) + The input time series stored during the fit method. + distance_profile_function : function + The function used to compute the distance profile affected + during the fit method based on the distance and normalize + parameters. """ _tags = { diff --git a/aeon/similarity_search/tests/test_dummy.py b/aeon/similarity_search/tests/test_dummy.py new file mode 100644 index 0000000000..c05db2e7c4 --- /dev/null +++ b/aeon/similarity_search/tests/test_dummy.py @@ -0,0 +1,36 @@ +"""Tests for DummySimilaritySearch.""" + +__author__ = ["baraline"] + + +import numpy as np +import pytest +from numpy.testing import assert_array_equal + +from aeon.similarity_search._dummy import DummySimilaritySearch + +DATATYPES = ["int64", "float64"] + + +@pytest.mark.parametrize("dtype", DATATYPES) +def test_DummySimilaritySearch(dtype): + X = np.asarray( + [[[1, 2, 3, 4, 5, 6, 7, 8]], [[1, 2, 4, 4, 5, 6, 5, 4]]], dtype=dtype + ) + q = np.asarray([[3, 4, 5]], dtype=dtype) + + search = DummySimilaritySearch() + search.fit(X) + idx = search.predict(q) + assert_array_equal(idx, [(0, 2)]) + + search = DummySimilaritySearch(normalize=True) + search.fit(X) + q = np.asarray([[8, 8, 10]], dtype=dtype) + idx = search.predict(q) + assert_array_equal(idx, [(1, 2)]) + + search = DummySimilaritySearch(normalize=True) + search.fit(X) + idx = search.predict(q, q_index=(1, 2)) + assert_array_equal(idx, [(1, 0)]) diff --git a/aeon/similarity_search/tests/test_top_k_similarity.py b/aeon/similarity_search/tests/test_top_k_similarity.py index fdbeda4b94..b8945c90a4 100644 --- a/aeon/similarity_search/tests/test_top_k_similarity.py +++ b/aeon/similarity_search/tests/test_top_k_similarity.py @@ -1,9 +1,6 @@ -""" -Created on Sat Sep 9 14:12:58 2023 - -@author: antoi -""" +"""Tests for TopKSimilaritySearch.""" +__author__ = ["baraline"] import numpy as np import pytest diff --git a/aeon/similarity_search/top_k_similarity.py b/aeon/similarity_search/top_k_similarity.py index 45bf1d3738..963a490e7a 100644 --- a/aeon/similarity_search/top_k_similarity.py +++ b/aeon/similarity_search/top_k_similarity.py @@ -11,7 +11,7 @@ class TopKSimilaritySearch(BaseSimiliaritySearch): Finds the closest k series to the query series based on a distance function. - Attributes + Parameters ---------- k : int, default=1 The number of nearest matches from Q to return. @@ -22,6 +22,27 @@ class TopKSimilaritySearch(BaseSimiliaritySearch): store_distance_profile : bool, default = =False. Whether to store the computed distance profile in the attribute "_distance_profile" after calling the predict method. + + Attributes + ---------- + _X : array, shape (n_instances, n_channels, n_timestamps) + The input time series stored during the fit method. + distance_profile_function : function + The function used to compute the distance profile affected + during the fit method based on the distance and normalize + parameters. + + Examples + -------- + >>> from aeon.similarity_search import TopKSimilaritySearch + >>> from aeon.datasets import load_unit_test + >>> X_train, y_train = load_unit_test(split="train") + >>> X_test, y_test = load_unit_test(split="test") + >>> clf = TopKSimilaritySearch(k=1) + >>> clf.fit(X_train, y_train) + TopKSimilaritySearch(...) + >>> q = X_test[0, :, 5:15] + >>> y_pred = clf.predict(q) """ def __init__( From 6771eadf4d32c453f5ded95da290963c7f182331 Mon Sep 17 00:00:00 2001 From: Antoine Guillaume Date: Fri, 27 Oct 2023 18:56:23 +0200 Subject: [PATCH 31/31] Fixes from Matthew review --- aeon/registry/_tags.py | 1 + aeon/registry/tests/test_lookup.py | 1 - aeon/similarity_search/_dummy.py | 21 +++++++++++++++++++ aeon/similarity_search/base.py | 5 +++-- .../tests/test_naive_euclidean.py | 6 ++---- .../tests/test_normalized_naive_euclidean.py | 6 ++---- docs/api_reference.md | 1 + docs/glossary.md | 6 ++++++ docs/index.md | 2 ++ 9 files changed, 38 insertions(+), 11 deletions(-) diff --git a/aeon/registry/_tags.py b/aeon/registry/_tags.py index df05eaf985..fce62f2bb8 100644 --- a/aeon/registry/_tags.py +++ b/aeon/registry/_tags.py @@ -220,6 +220,7 @@ "early_classifier", "regressor", "transformer", + "similarity-search", ], "bool", "can the estimator classify time series with 2 or more variables?", diff --git a/aeon/registry/tests/test_lookup.py b/aeon/registry/tests/test_lookup.py index fd59f72c07..a0bd8bb167 100644 --- a/aeon/registry/tests/test_lookup.py +++ b/aeon/registry/tests/test_lookup.py @@ -1,4 +1,3 @@ -# copyright: aeon developers, BSD-3-Clause License (see LICENSE file) """Testing of registry lookup functionality.""" __author__ = ["fkiraly", "MatthewMiddlehurst"] diff --git a/aeon/similarity_search/_dummy.py b/aeon/similarity_search/_dummy.py index e52d914534..a4462631c9 100644 --- a/aeon/similarity_search/_dummy.py +++ b/aeon/similarity_search/_dummy.py @@ -20,6 +20,27 @@ class DummySimilaritySearch(BaseSimiliaritySearch): store_distance_profile : bool, default = =False. Whether to store the computed distance profile in the attribute "_distance_profile" after calling the predict method. + + Attributes + ---------- + _X : array, shape (n_instances, n_channels, n_timestamps) + The input time series stored during the fit method. + distance_profile_function : function + The function used to compute the distance profile affected + during the fit method based on the distance and normalize + parameters. + + Examples + -------- + >>> from aeon.similarity_search._dummy import DummySimilaritySearch + >>> from aeon.datasets import load_unit_test + >>> X_train, y_train = load_unit_test(split="train") + >>> X_test, y_test = load_unit_test(split="test") + >>> clf = DummySimilaritySearch() + >>> clf.fit(X_train, y_train) + DummySimilaritySearch(...) + >>> q = X_test[0, :, 5:15] + >>> y_pred = clf.predict(q) """ def __init__( diff --git a/aeon/similarity_search/base.py b/aeon/similarity_search/base.py index e98491eccd..3ecff52861 100644 --- a/aeon/similarity_search/base.py +++ b/aeon/similarity_search/base.py @@ -17,7 +17,8 @@ class BaseSimiliaritySearch(BaseEstimator, ABC): - """BaseSimilaritySearch. + """ + BaseSimilaritySearch. Parameters ---------- @@ -223,7 +224,7 @@ def _predict(self, q): # Dictionary structure : # 1st lvl key : distance function used -# 2nd lvl key : boolean indicating wheter distance is normalized +# 2nd lvl key : boolean indicating whether distance is normalized DISTANCE_PROFILE_DICT = { "euclidean": { True: normalized_naive_euclidean_profile, diff --git a/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py b/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py index eec58bd37e..dd568b5124 100644 --- a/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/tests/test_naive_euclidean.py @@ -1,8 +1,6 @@ -""" -Created on Sun Sep 10 12:21:00 2023 +"""Tests for naive Euclidean distance profile.""" -@author: antoi -""" +__author__ = ["baraline"] import numpy as np import pytest diff --git a/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py b/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py index 1cac748ef1..28da06cc58 100644 --- a/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py +++ b/aeon/similarity_search/distance_profiles/tests/test_normalized_naive_euclidean.py @@ -1,8 +1,6 @@ -""" -Created on Sun Sep 10 12:21:00 2023 +"""Tests for naive normalized Euclidean distance profile.""" -@author: antoi -""" +__author__ = ["baraline"] import numpy as np import pytest diff --git a/docs/api_reference.md b/docs/api_reference.md index e71b3f0736..f2ac63ac2c 100644 --- a/docs/api_reference.md +++ b/docs/api_reference.md @@ -24,6 +24,7 @@ api_reference/forecasting api_reference/networks api_reference/performance_metrics api_reference/regression +api_reference/similarity_search api_reference/transformations api_reference/utils api_reference/file_specifications/ts diff --git a/docs/glossary.md b/docs/glossary.md index fdf314862d..b687fd27a7 100644 --- a/docs/glossary.md +++ b/docs/glossary.md @@ -93,6 +93,12 @@ Time series transformers See {term}`series-to-series transformation` and {term}`series-to-features transformation` for types of transformer. +Time series similarity search + A task focused on finding the most similar candidates to a given + {term}`time series` of length `l`, called the query. The candidates are + extracted from a collection of {term}`time series` of length equal or + superior to `l`. + Collection transformers {term}`Time series transformers` that take a {term}`time series collection` as input. While these transformers only accept collections, a wrapper is provided to diff --git a/docs/index.md b/docs/index.md index 8d88d96f20..bc108668a0 100644 --- a/docs/index.md +++ b/docs/index.md @@ -165,6 +165,8 @@ Annotation Annotation ``` +::: + :::{grid-item-card} :img-top: examples/similarity_search/img/sim_search.png :class-img-top: aeon-card-image