From faf114a73f666eff7d96ba562e5a39f984f2125e Mon Sep 17 00:00:00 2001 From: Benoit Bovy Date: Mon, 26 Oct 2020 17:45:33 +0100 Subject: [PATCH 01/12] add IndexWrapper base class + register_index func Also add sklearn BallTree wrappers. --- src/xoak/__init__.py | 2 ++ src/xoak/indexes/__init__.py | 7 ++++ src/xoak/indexes/balltree.py | 20 +++++++++++ src/xoak/indexes/base.py | 70 ++++++++++++++++++++++++++++++++++++ 4 files changed, 99 insertions(+) create mode 100644 src/xoak/indexes/__init__.py create mode 100644 src/xoak/indexes/balltree.py create mode 100644 src/xoak/indexes/base.py diff --git a/src/xoak/__init__.py b/src/xoak/__init__.py index 6b876e6..1dd3de0 100644 --- a/src/xoak/__init__.py +++ b/src/xoak/__init__.py @@ -1,3 +1,5 @@ __version__ = "0.1.0" + +from .indexes import IndexWrapper, register_index from .core import XoakAccessor diff --git a/src/xoak/indexes/__init__.py b/src/xoak/indexes/__init__.py new file mode 100644 index 0000000..80d4487 --- /dev/null +++ b/src/xoak/indexes/__init__.py @@ -0,0 +1,7 @@ +from .base import IndexWrapper, register_index + + +try: + from .balltree import BallTreeWrapper, GeoBallTreeWrapper +except ImportError: + pass diff --git a/src/xoak/indexes/balltree.py b/src/xoak/indexes/balltree.py new file mode 100644 index 0000000..1d744ac --- /dev/null +++ b/src/xoak/indexes/balltree.py @@ -0,0 +1,20 @@ +import numpy as np +from sklearn.neighbors import BallTree + +from .base import IndexWrapper, register_index + + +@register_index('balltree') +class BallTreeWrapper(IndexWrapper): + index_cls = BallTree + + +@register_index('geo_balltree') +class GeoBallTreeWrapper(BallTreeWrapper): + + def build_index(self, points, **kwargs): + kwargs.update({'metric': 'haversine'}) + return super().build_index(np.deg2rad(points), **kwargs) + + def query_index(self, points): + return super().query_index(np.deg2rad(points)) diff --git a/src/xoak/indexes/base.py b/src/xoak/indexes/base.py new file mode 100644 index 0000000..9422d66 --- /dev/null +++ b/src/xoak/indexes/base.py @@ -0,0 +1,70 @@ +from typing import Any, Dict, Tuple, Type, TypeVar, Union +import warnings + +import numpy as np + + +Index = TypeVar('Index') + + +class IndexRegistrationWarning(Warning): + """Warning for conflicts in accessor registration.""" + + +class IndexWrapper: + index_cls: Index = None + + _query_result_dtype = [("distances", np.double), ("positions", np.intp)] + + def __init__(self, points: np.ndarray, offset: int, **kwargs): + self._index = self.build_index(points, **kwargs) + self._offset = offset + + def build_index(self, points: np.ndarray, **kwargs) -> Index: + return self.index_cls(points, **kwargs) + + def query_index(self, points: np.ndarray, **kwargs) -> Tuple[np.ndarray, np.ndarray]: + return self._index.query(points, **kwargs) + + def query(self, points: np.ndarray, **kwargs) -> np.ndarray: + distances, positions = self.query_index(points, **kwargs) + + result = np.empty(shape=points.shape[0], dtype=self._query_result_dtype) + result["distances"] = distances.ravel().astype(np.double) + result["positions"] = positions.ravel().astype(np.intp) + self._offset + + return result[:, None] + + +registered_indexes: Dict[str, Type[IndexWrapper]] = {} + + +def register_index(name): + + def decorator(cls): + if not issubclass(cls, IndexWrapper): + raise TypeError("can only register IndexWrapper subclasses.") + + if name in registered_indexes: + warnings.warn( + f"overriding an already registered index with the name {name}.", + IndexRegistrationWarning, + stacklevel=2, + ) + + registered_indexes[name] = cls + + return cls + + return decorator + + +def normalize_index(name_or_cls: Union[str, Any]) -> Type[IndexWrapper]: + + if isinstance(name_or_cls, str): + return registered_indexes[name_or_cls] + + if not issubclass(name_or_cls, IndexWrapper): + raise TypeError(f"{name_or_cls} is not a subclass of IndexWrapper") + + return name_or_cls From d59f076861a211ac247637e2406e2bf92e5b5b01 Mon Sep 17 00:00:00 2001 From: Benoit Bovy Date: Mon, 26 Oct 2020 17:47:00 +0100 Subject: [PATCH 02/12] refactor accessor (wip) - Removed "tolerance" - Removed "transform" - Plugin IndexWrapper - Enable dask-based index builds --- src/xoak/core.py | 127 +++++++++++++++++++++++++++++++---------------- 1 file changed, 83 insertions(+), 44 deletions(-) diff --git a/src/xoak/core.py b/src/xoak/core.py index 496d7cf..cdd165b 100644 --- a/src/xoak/core.py +++ b/src/xoak/core.py @@ -1,10 +1,33 @@ import numbers -from typing import Any, Callable, Iterable, Hashable, List, Mapping, Union +from typing import Any, Iterable, Hashable, List, Mapping, Type, Union import numpy as np import xarray as xr from xarray.core.utils import either_dict_or_kwargs -from sklearn.neighbors import BallTree + +from .indexes.base import Index, IndexWrapper, normalize_index + + +def coords_to_point_array(coords: List[Any]): + """Re-arrange data from a list of xarray coordinates into a 2-d array of shape + (npoints, ncoords). + + """ + c_chunks = [c.chunks for c in coords] + + if any([chunks is None for chunks in c_chunks]): + # plain numpy arrays (maybe triggers compute) + X = np.stack([np.ravel(c) for c in coords]).T + + else: + import dask.array as da + + # TODO: check chunks are equal for all coords? + + X = da.stack([da.ravel(c.data) for c in coords]).T + X = X.rechunk((X.chunks[0], len(coords))) + + return X @xr.register_dataarray_accessor("xoak") @@ -20,45 +43,52 @@ def __init__(self, xarray_obj: Union[xr.Dataset, xr.DataArray]): self._xarray_obj = xarray_obj self._index = None + self._index_cls = None self._index_coords = None self._index_coords_dims = None self._index_coords_shape = None - self._transform = None + def _build_index_forest_delayed(self, X, **kwargs) -> List[Any]: + import dask - def _stack(self, coords: List[Any]): - """Stack and maybe transform coordinate labels into a format - compliant with sklearn's BallTree, i.e., a 2-d array (npoints, nfeatures). - - """ - X = np.stack([np.ravel(arr) for arr in coords]).T + indexes = [] + offset = 0 - if self._transform is not None: - return self._transform(X) - else: - return X + for i, chunk in enumerate(X.to_delayed().ravel()): + idx = dask.delayed(self._index_cls)(chunk, offset, **kwargs) + indexes.append(idx) + + offset += X.chunks[0][i] + + return indexes - def set_index(self, coords: Iterable[str], transform: Callable = None, **kwargs): - """Create a ball tree index from a subset of coordinates of - the DataArray / Dataset. + def set_index( + self, + coords: Iterable[str], + index_type: Union[str, Type[IndexWrapper]], + persist: bool = True, + **kwargs + ): + """Create an index tree from a subset of coordinates of the DataArray / Dataset. + + If the given coordinates are chunked (Dask arrays), this method will (lazily) create + a forest of index trees (one tree per chunk of the flattened coordinate arrays). Parameters ---------- coords : iterable Coordinate names. Each given coordinate must have the same dimension(s), in the same order. - transform : callable, optional - Any function used to convert coordinate labels. This is useful, - e.g., for converting degrees to radians when using the haversine metric. - This transform will also be applied each time before indexing (query). + index_type : str or :class:`xoak.IndexWrapper` subclass + Either one of the registered index types or a custom index wrapper class. + persist: bool + If True, this method will precompute and persist in memory the forest of index + trees, if any (default: True). **kwargs - Arguments passed to :class:`sklearn.neighbors.BallTree` - constructor. + Keyword arguments that will be passed to the underlying index constructor. """ - if transform is not None: - self._transform = transform - + self._index_cls = normalize_index(index_type) self._index_coords = tuple(coords) coord_objs = [self._xarray_obj.coords[cn] for cn in coords] @@ -71,28 +101,39 @@ def set_index(self, coords: Iterable[str], transform: Callable = None, **kwargs) self._index_coords_dims = coord_objs[0].dims self._index_coords_shape = coord_objs[0].shape - X = self._stack([self._xarray_obj[c] for c in coords]) + X = coords_to_point_array([self._xarray_obj[c] for c in coords]) + + if isinstance(X, np.ndarray): + self._index = self._index_cls(X, 0, **kwargs) - self._index = BallTree(X, **kwargs) + else: + import dask + + self._index = self._build_index_forest_delayed(X, **kwargs) + + if persist: + dask.persist(*self._index) @property - def index(self) -> BallTree: - """Returns the underlying ball tree index.""" + def index(self) -> Index: + """Returns the underlying index object.""" - return self._index + if isinstance(self._index, list): + import dask + return dask.compute(*self._index) + else: + return self._index._index - def _query(self, indexers, tolerance): - """Query the ball tree and maybe reject selected points - based on tolerance (distance threshold). - - """ - X = self._stack([indexers[c] for c in self._index_coords]) + def _query(self, indexers): + """Query the index. """ + X = coords_to_point_array([indexers[c] for c in self._index_coords]) - if tolerance is None: - return self._index.query(X, return_distance=False) + if isinstance(X, np.ndarray) and not isinstance(self._index, list): + result = self._index.query(X) + return result["positions"][:, 0] else: - dist, indices = self._index.query(X, return_distance=True) - return indices[dist <= tolerance] + # TODO: implement two-stage query with dask + raise NotImplementedError def _get_pos_indexers(self, indices, indexers): """Returns positional indexers based on the query results and the @@ -123,7 +164,6 @@ def _get_pos_indexers(self, indices, indexers): def sel( self, indexers: Mapping[Hashable, Any] = None, - tolerance: numbers.Number = None, **indexers_kwargs: Any ) -> Union[xr.Dataset, xr.DataArray]: """Selection based on a ball tree index. @@ -143,12 +183,11 @@ def sel( """ if self._index is None: raise ValueError( - "The ball tree index has not been built yet. " - "Call `.xoak.set_index()` first" + "The index(es) has/have not been built yet. Call `.xoak.set_index()` first" ) indexers = either_dict_or_kwargs(indexers, indexers_kwargs, "xoak.sel") - indices = self._query(indexers, tolerance) + indices = self._query(indexers) pos_indexers = self._get_pos_indexers(indices, indexers) result = self._xarray_obj.isel(indexers=pos_indexers) From 64709858618be2f3ee80536c75774b55c2596675 Mon Sep 17 00:00:00 2001 From: Benoit Bovy Date: Tue, 27 Oct 2020 16:36:40 +0100 Subject: [PATCH 03/12] better flexible index API + fix some types --- src/xoak/__init__.py | 2 +- src/xoak/core.py | 97 ++++++++++++++++------------- src/xoak/index/__init__.py | 7 +++ src/xoak/index/balltree.py | 31 ++++++++++ src/xoak/index/base.py | 114 +++++++++++++++++++++++++++++++++++ src/xoak/indexes/__init__.py | 7 --- src/xoak/indexes/balltree.py | 20 ------ src/xoak/indexes/base.py | 70 --------------------- 8 files changed, 209 insertions(+), 139 deletions(-) create mode 100644 src/xoak/index/__init__.py create mode 100644 src/xoak/index/balltree.py create mode 100644 src/xoak/index/base.py delete mode 100644 src/xoak/indexes/__init__.py delete mode 100644 src/xoak/indexes/balltree.py delete mode 100644 src/xoak/indexes/base.py diff --git a/src/xoak/__init__.py b/src/xoak/__init__.py index 1dd3de0..3ae9f7a 100644 --- a/src/xoak/__init__.py +++ b/src/xoak/__init__.py @@ -1,5 +1,5 @@ __version__ = "0.1.0" -from .indexes import IndexWrapper, register_index +from .index import IndexAdapter, indexes, register_index from .core import XoakAccessor diff --git a/src/xoak/core.py b/src/xoak/core.py index cdd165b..a970127 100644 --- a/src/xoak/core.py +++ b/src/xoak/core.py @@ -1,14 +1,27 @@ -import numbers -from typing import Any, Iterable, Hashable, List, Mapping, Type, Union +from typing import ( + Any, + Iterable, + Hashable, + List, + Mapping, + Tuple, + Type, + Union, +) import numpy as np import xarray as xr from xarray.core.utils import either_dict_or_kwargs -from .indexes.base import Index, IndexWrapper, normalize_index +from .index.base import Index, IndexAdapter, XoakIndexWrapper +try: + from dask.delayed import Delayed +except ImportError: + Delayed = Type[None] -def coords_to_point_array(coords: List[Any]): + +def coords_to_point_array(coords: List[Any]) -> np.ndarray: """Re-arrange data from a list of xarray coordinates into a 2-d array of shape (npoints, ncoords). @@ -30,6 +43,10 @@ def coords_to_point_array(coords: List[Any]): return X +IndexAttr = Union[XoakIndexWrapper, Iterable[XoakIndexWrapper], Iterable[Delayed]] +IndexType = Union[str, Type[IndexAdapter]] + + @xr.register_dataarray_accessor("xoak") @xr.register_dataset_accessor("xoak") class XoakAccessor: @@ -37,35 +54,36 @@ class XoakAccessor: n-dimensional data using a ball tree. """ + _index: IndexAttr + _index_type: IndexType + _index_coords: Tuple[str] + _index_coords_dims: Tuple[Hashable, ...] + _index_coords_shape: Tuple[int, ...] def __init__(self, xarray_obj: Union[xr.Dataset, xr.DataArray]): - self._xarray_obj = xarray_obj - self._index = None - self._index_cls = None - self._index_coords = None - self._index_coords_dims = None - self._index_coords_shape = None - - def _build_index_forest_delayed(self, X, **kwargs) -> List[Any]: + def _build_index_forest_delayed(self, X, persist=False, **kwargs) -> IndexAttr: import dask indexes = [] offset = 0 for i, chunk in enumerate(X.to_delayed().ravel()): - idx = dask.delayed(self._index_cls)(chunk, offset, **kwargs) - indexes.append(idx) - + indexes.append( + dask.delayed(XoakIndexWrapper)(self._index_type, chunk, offset, **kwargs) + ) offset += X.chunks[0][i] - return indexes + if persist: + return dask.persist(*indexes) + else: + return tuple(indexes) def set_index( self, coords: Iterable[str], - index_type: Union[str, Type[IndexWrapper]], + index_type: IndexType, persist: bool = True, **kwargs ): @@ -77,18 +95,18 @@ def set_index( Parameters ---------- coords : iterable - Coordinate names. Each given coordinate must have - the same dimension(s), in the same order. + Coordinate names. Each given coordinate must have the same dimension(s), + in the same order. index_type : str or :class:`xoak.IndexWrapper` subclass Either one of the registered index types or a custom index wrapper class. persist: bool - If True, this method will precompute and persist in memory the forest of index - trees, if any (default: True). + If True (default), this method will precompute and persist in memory the forest + of index trees, if any. **kwargs Keyword arguments that will be passed to the underlying index constructor. """ - self._index_cls = normalize_index(index_type) + self._index_type = index_type self._index_coords = tuple(coords) coord_objs = [self._xarray_obj.coords[cn] for cn in coords] @@ -104,31 +122,29 @@ def set_index( X = coords_to_point_array([self._xarray_obj[c] for c in coords]) if isinstance(X, np.ndarray): - self._index = self._index_cls(X, 0, **kwargs) - + self._index = XoakIndexWrapper(self._index_type, X, 0, **kwargs) else: - import dask - - self._index = self._build_index_forest_delayed(X, **kwargs) - - if persist: - dask.persist(*self._index) + self._index = self._build_index_forest_delayed(X, persist=persist, **kwargs) @property - def index(self) -> Index: - """Returns the underlying index object.""" + def index(self) -> Union[Index, Iterable[Index]]: + """Returns the underlying index object(s). - if isinstance(self._index, list): - import dask - return dask.compute(*self._index) + May trigger computation of lazy indexes. + + """ + if isinstance(self._index, XoakIndexWrapper): + return self._index.index else: - return self._index._index + import dask + index_wrappers = dask.compute(*self._index) + return [wrp.index for wrp in index_wrappers] def _query(self, indexers): """Query the index. """ X = coords_to_point_array([indexers[c] for c in self._index_coords]) - if isinstance(X, np.ndarray) and not isinstance(self._index, list): + if isinstance(X, np.ndarray) and isinstance(self._index, XoakIndexWrapper): result = self._index.query(X) return result["positions"][:, 0] else: @@ -152,9 +168,9 @@ def _get_pos_indexers(self, indices, indexers): if len(set(indexer_dims)) > 1: raise ValueError("All indexers must have the same dimensions.") - u_indices = np.unravel_index(indices.ravel(), self._index_coords_shape) + u_indices = list(np.unravel_index(indices.ravel(), self._index_coords_shape)) - for dim, ind in zip(*[self._index_coords_dims, u_indices]): + for dim, ind in zip(self._index_coords_dims, u_indices): pos_indexers[dim] = xr.Variable( indexer_dims[0], ind.reshape(indexer_shapes[0]) ) @@ -168,8 +184,7 @@ def sel( ) -> Union[xr.Dataset, xr.DataArray]: """Selection based on a ball tree index. - The index must have been already built using - `xoak.set_index()`. + The index must have been already built using `xoak.set_index()`. It behaves mostly like :meth:`xarray.Dataset.sel` and :meth:`xarray.DataArray.sel` methods, with some limitations: diff --git a/src/xoak/index/__init__.py b/src/xoak/index/__init__.py new file mode 100644 index 0000000..c9020b0 --- /dev/null +++ b/src/xoak/index/__init__.py @@ -0,0 +1,7 @@ +from .base import IndexAdapter, indexes, register_index + + +try: + from .balltree import BallTreeAdapter, GeoBallTreeAdapter +except ImportError: + pass diff --git a/src/xoak/index/balltree.py b/src/xoak/index/balltree.py new file mode 100644 index 0000000..2a7a1e9 --- /dev/null +++ b/src/xoak/index/balltree.py @@ -0,0 +1,31 @@ +import numpy as np +from sklearn.neighbors import BallTree + +from .base import IndexAdapter, register_index + + +@register_index('balltree') +class BallTreeAdapter(IndexAdapter): + + def __init__(self, **kwargs): + self.index_options = kwargs + + def build(self, points): + return BallTree(points, **self.index_options) + + def query(self, btree, points): + return btree.query(points) + + +@register_index('geo_balltree') +class GeoBallTreeAdapter(IndexAdapter): + + def __init__(self, **kwargs): + kwargs.update({'metric': 'haversine'}) + self._index_options = kwargs + + def build(self, points): + return BallTree(np.deg2rad(points), **self._index_options) + + def query(self, btree, points): + return btree.query(np.deg2rad(points)) diff --git a/src/xoak/index/base.py b/src/xoak/index/base.py new file mode 100644 index 0000000..ab78145 --- /dev/null +++ b/src/xoak/index/base.py @@ -0,0 +1,114 @@ +import abc +from typing import Any, List, Mapping, Tuple, Type, TypeVar, Union +import warnings + +import numpy as np + + +Index = TypeVar('Index') + + +class IndexAdapter(abc.ABC): + + def __init__(self, **kwargs): + pass + + @abc.abstractmethod + def build(self, points: np.ndarray) -> Index: + raise NotImplementedError() + + @abc.abstractmethod + def query(self, index: Index, points: np.ndarray) -> Tuple[np.ndarray, np.ndarray]: + raise NotImplementedError() + + +class IndexRegistrationWarning(Warning): + """Warning for conflicts in index registration.""" + + +class IndexRegistry(Mapping[str, IndexAdapter]): + + def __init__(self): + self._indexes = {} + + def register(self, name: str, cls: Type[IndexAdapter]): + if not issubclass(cls, IndexAdapter): + raise TypeError("can only register IndexAdapter subclasses.") + + if name in self._indexes: + warnings.warn( + f"overriding an already registered index with the name '{name}'.", + IndexRegistrationWarning, + stacklevel=2, + ) + + self._indexes[name] = cls + + def __getitem__(self, key): + return self._indexes[key] + + def __iter__(self): + return len(self._indexes) + + def __len__(self): + return len(self._indexes) + + def __repr__(self): + header = f"\n" + return header + "\n".join([name for name in self._indexes]) + + +indexes = IndexRegistry() + + +def register_index(name): + + def decorator(cls): + indexes.register(name, cls) + return cls + + return decorator + + +def normalize_index(name_or_cls: Union[str, Any]) -> Type[IndexAdapter]: + + if isinstance(name_or_cls, str): + cls = indexes[name_or_cls] + else: + cls = name_or_cls + + if not issubclass(cls, IndexAdapter): + raise TypeError(f"'{name_or_cls}' is not a subclass of IndexAdapter") + + return cls + + +class XoakIndexWrapper: + + _query_result_dtype: List[Tuple[str, Any]] = [("distances", np.double), ("positions", np.intp)] + + def __init__( + self, + index_adapter: Union[str, Type[IndexAdapter]], + points: np.ndarray, + offset: int, + **kwargs + ): + index_adapter_cls = normalize_index(index_adapter) + + self._index_adapter = index_adapter_cls(**kwargs) + self._index = self._index_adapter.build(points) + self._offset = offset + + @property + def index(self): + return self._index + + def query(self, points: np.ndarray) -> np.ndarray: + distances, positions = self._index_adapter.query(self._index, points) + + result = np.empty(shape=points.shape[0], dtype=self._query_result_dtype) + result["distances"] = distances.ravel().astype(np.double) + result["positions"] = positions.ravel().astype(np.intp) + self._offset + + return result[:, None] diff --git a/src/xoak/indexes/__init__.py b/src/xoak/indexes/__init__.py deleted file mode 100644 index 80d4487..0000000 --- a/src/xoak/indexes/__init__.py +++ /dev/null @@ -1,7 +0,0 @@ -from .base import IndexWrapper, register_index - - -try: - from .balltree import BallTreeWrapper, GeoBallTreeWrapper -except ImportError: - pass diff --git a/src/xoak/indexes/balltree.py b/src/xoak/indexes/balltree.py deleted file mode 100644 index 1d744ac..0000000 --- a/src/xoak/indexes/balltree.py +++ /dev/null @@ -1,20 +0,0 @@ -import numpy as np -from sklearn.neighbors import BallTree - -from .base import IndexWrapper, register_index - - -@register_index('balltree') -class BallTreeWrapper(IndexWrapper): - index_cls = BallTree - - -@register_index('geo_balltree') -class GeoBallTreeWrapper(BallTreeWrapper): - - def build_index(self, points, **kwargs): - kwargs.update({'metric': 'haversine'}) - return super().build_index(np.deg2rad(points), **kwargs) - - def query_index(self, points): - return super().query_index(np.deg2rad(points)) diff --git a/src/xoak/indexes/base.py b/src/xoak/indexes/base.py deleted file mode 100644 index 9422d66..0000000 --- a/src/xoak/indexes/base.py +++ /dev/null @@ -1,70 +0,0 @@ -from typing import Any, Dict, Tuple, Type, TypeVar, Union -import warnings - -import numpy as np - - -Index = TypeVar('Index') - - -class IndexRegistrationWarning(Warning): - """Warning for conflicts in accessor registration.""" - - -class IndexWrapper: - index_cls: Index = None - - _query_result_dtype = [("distances", np.double), ("positions", np.intp)] - - def __init__(self, points: np.ndarray, offset: int, **kwargs): - self._index = self.build_index(points, **kwargs) - self._offset = offset - - def build_index(self, points: np.ndarray, **kwargs) -> Index: - return self.index_cls(points, **kwargs) - - def query_index(self, points: np.ndarray, **kwargs) -> Tuple[np.ndarray, np.ndarray]: - return self._index.query(points, **kwargs) - - def query(self, points: np.ndarray, **kwargs) -> np.ndarray: - distances, positions = self.query_index(points, **kwargs) - - result = np.empty(shape=points.shape[0], dtype=self._query_result_dtype) - result["distances"] = distances.ravel().astype(np.double) - result["positions"] = positions.ravel().astype(np.intp) + self._offset - - return result[:, None] - - -registered_indexes: Dict[str, Type[IndexWrapper]] = {} - - -def register_index(name): - - def decorator(cls): - if not issubclass(cls, IndexWrapper): - raise TypeError("can only register IndexWrapper subclasses.") - - if name in registered_indexes: - warnings.warn( - f"overriding an already registered index with the name {name}.", - IndexRegistrationWarning, - stacklevel=2, - ) - - registered_indexes[name] = cls - - return cls - - return decorator - - -def normalize_index(name_or_cls: Union[str, Any]) -> Type[IndexWrapper]: - - if isinstance(name_or_cls, str): - return registered_indexes[name_or_cls] - - if not issubclass(name_or_cls, IndexWrapper): - raise TypeError(f"{name_or_cls} is not a subclass of IndexWrapper") - - return name_or_cls From 3676ac2ea2cff7681c0faf14d2824a8200a3478b Mon Sep 17 00:00:00 2001 From: Benoit Bovy Date: Tue, 27 Oct 2020 17:19:56 +0100 Subject: [PATCH 04/12] implement query on chunked arrays / lazy indexes --- src/xoak/core.py | 73 +++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 66 insertions(+), 7 deletions(-) diff --git a/src/xoak/core.py b/src/xoak/core.py index a970127..25945cb 100644 --- a/src/xoak/core.py +++ b/src/xoak/core.py @@ -141,17 +141,70 @@ def index(self) -> Union[Index, Iterable[Index]]: return [wrp.index for wrp in index_wrappers] def _query(self, indexers): - """Query the index. """ X = coords_to_point_array([indexers[c] for c in self._index_coords]) if isinstance(X, np.ndarray) and isinstance(self._index, XoakIndexWrapper): - result = self._index.query(X) - return result["positions"][:, 0] + # directly call index wrapper's query method + res = self._index.query(X) + results = res["positions"][:, 0] + else: - # TODO: implement two-stage query with dask - raise NotImplementedError + # Two-stage lazy query with dask + import dask + import dask.array as da + + # coerce query array as a dask array and index(es) as an iterable + if isinstance(X, np.ndarray): + X = da.from_array(X, chunks=X.shape) + + if isinstance(self._index, XoakIndexWrapper): + indexes = [self._index] + else: + indexes = self._index + + # 1st "map" stage: + # - execute `IndexWrapperCls.query` for each query array chunk and each index instance + # - concatenate all distances/positions results in two dask arrays of shape (n_points, n_indexes) + + res_chunk = [] + + for i, chunk in enumerate(X.to_delayed().ravel()): + res_chunk_idx = [] + + chunk_npoints = X.chunks[0][i] + shape = (chunk_npoints, 1) + + for idx in indexes: + dlyd = dask.delayed(idx.query)(chunk) + res_chunk_idx.append( + da.from_delayed(dlyd, shape, dtype=XoakIndexWrapper._query_result_dtype) + ) - def _get_pos_indexers(self, indices, indexers): + res_chunk.append(da.concatenate(res_chunk_idx, axis=1)) + + map_results = da.concatenate(res_chunk, axis=0) + distances = map_results["distances"] + positions = map_results["positions"] + + # 2nd "reduce" stage: + # - brute force lookup over the indexes dimension (columns) + + col_positions = da.argmin(distances, axis=1) + + results = da.blockwise( + lambda arr, col_pos: np.take_along_axis(arr, col_pos[:, None], 1), + 'i', + positions, + 'ik', + col_positions, + 'i', + dtype=np.intp, + concatenate=True + ) + + return results + + def _get_pos_indexers(self, indices, indexers, compute=False): """Returns positional indexers based on the query results and the original (label-based) indexers. @@ -168,6 +221,9 @@ def _get_pos_indexers(self, indices, indexers): if len(set(indexer_dims)) > 1: raise ValueError("All indexers must have the same dimensions.") + if compute and not isinstance(indices, np.ndarray): + indices = indices.compute() + u_indices = list(np.unravel_index(indices.ravel(), self._index_coords_shape)) for dim, ind in zip(self._index_coords_dims, u_indices): @@ -194,6 +250,9 @@ def sel( objects - Use it for nearest neighbor lookup only (it implicitly assumes method="nearest") + + This triggers :func:`dask.compute` if the given indexers and/or the index + coordinates are chunked. """ if self._index is None: @@ -203,7 +262,7 @@ def sel( indexers = either_dict_or_kwargs(indexers, indexers_kwargs, "xoak.sel") indices = self._query(indexers) - pos_indexers = self._get_pos_indexers(indices, indexers) + pos_indexers = self._get_pos_indexers(indices, indexers, compute=True) result = self._xarray_obj.isel(indexers=pos_indexers) From f2ec9a34fb6d0110f0220efd66529f3e7c5950fc Mon Sep 17 00:00:00 2001 From: Benoit Bovy Date: Wed, 28 Oct 2020 18:26:25 +0100 Subject: [PATCH 05/12] black --- doc/conf.py | 3 +-- src/xoak/core.py | 48 +++++++++++++++++++++----------------- src/xoak/index/balltree.py | 8 +++---- src/xoak/index/base.py | 20 ++++++++-------- tests/test_geo_coords.py | 5 +++- 5 files changed, 44 insertions(+), 40 deletions(-) diff --git a/doc/conf.py b/doc/conf.py index 51e5aef..b99da47 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -25,7 +25,7 @@ # -- General configuration --------------------------------------------------- -master_doc = 'index' +master_doc = "index" # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom @@ -52,4 +52,3 @@ # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ["_static"] - diff --git a/src/xoak/core.py b/src/xoak/core.py index 25945cb..da2ecff 100644 --- a/src/xoak/core.py +++ b/src/xoak/core.py @@ -52,8 +52,9 @@ def coords_to_point_array(coords: List[Any]) -> np.ndarray: class XoakAccessor: """A xarray Dataset or DataArray extension for indexing irregular, n-dimensional data using a ball tree. - + """ + _index: IndexAttr _index_type: IndexType _index_coords: Tuple[str] @@ -71,7 +72,9 @@ def _build_index_forest_delayed(self, X, persist=False, **kwargs) -> IndexAttr: for i, chunk in enumerate(X.to_delayed().ravel()): indexes.append( - dask.delayed(XoakIndexWrapper)(self._index_type, chunk, offset, **kwargs) + dask.delayed(XoakIndexWrapper)( + self._index_type, chunk, offset, **kwargs + ) ) offset += X.chunks[0][i] @@ -81,17 +84,17 @@ def _build_index_forest_delayed(self, X, persist=False, **kwargs) -> IndexAttr: return tuple(indexes) def set_index( - self, - coords: Iterable[str], - index_type: IndexType, - persist: bool = True, - **kwargs + self, + coords: Iterable[str], + index_type: IndexType, + persist: bool = True, + **kwargs ): """Create an index tree from a subset of coordinates of the DataArray / Dataset. If the given coordinates are chunked (Dask arrays), this method will (lazily) create a forest of index trees (one tree per chunk of the flattened coordinate arrays). - + Parameters ---------- coords : iterable @@ -137,6 +140,7 @@ def index(self) -> Union[Index, Iterable[Index]]: return self._index.index else: import dask + index_wrappers = dask.compute(*self._index) return [wrp.index for wrp in index_wrappers] @@ -177,7 +181,9 @@ def _query(self, indexers): for idx in indexes: dlyd = dask.delayed(idx.query)(chunk) res_chunk_idx.append( - da.from_delayed(dlyd, shape, dtype=XoakIndexWrapper._query_result_dtype) + da.from_delayed( + dlyd, shape, dtype=XoakIndexWrapper._query_result_dtype + ) ) res_chunk.append(da.concatenate(res_chunk_idx, axis=1)) @@ -193,13 +199,13 @@ def _query(self, indexers): results = da.blockwise( lambda arr, col_pos: np.take_along_axis(arr, col_pos[:, None], 1), - 'i', + "i", positions, - 'ik', + "ik", col_positions, - 'i', + "i", dtype=np.intp, - concatenate=True + concatenate=True, ) return results @@ -207,11 +213,11 @@ def _query(self, indexers): def _get_pos_indexers(self, indices, indexers, compute=False): """Returns positional indexers based on the query results and the original (label-based) indexers. - + 1. Unravel the (flattened) indices returned from the query 2. Reshape the unraveled indices according to indexers shapes 3. Wrap the indices in xarray.Variable objects. - + """ pos_indexers = {} @@ -234,17 +240,15 @@ def _get_pos_indexers(self, indices, indexers, compute=False): return pos_indexers def sel( - self, - indexers: Mapping[Hashable, Any] = None, - **indexers_kwargs: Any + self, indexers: Mapping[Hashable, Any] = None, **indexers_kwargs: Any ) -> Union[xr.Dataset, xr.DataArray]: """Selection based on a ball tree index. - + The index must have been already built using `xoak.set_index()`. - + It behaves mostly like :meth:`xarray.Dataset.sel` and :meth:`xarray.DataArray.sel` methods, with some limitations: - + - Orthogonal indexing is not supported - For vectorized (point-wise) indexing, you need to supply xarray objects @@ -253,7 +257,7 @@ def sel( This triggers :func:`dask.compute` if the given indexers and/or the index coordinates are chunked. - + """ if self._index is None: raise ValueError( diff --git a/src/xoak/index/balltree.py b/src/xoak/index/balltree.py index 2a7a1e9..d910208 100644 --- a/src/xoak/index/balltree.py +++ b/src/xoak/index/balltree.py @@ -4,9 +4,8 @@ from .base import IndexAdapter, register_index -@register_index('balltree') +@register_index("balltree") class BallTreeAdapter(IndexAdapter): - def __init__(self, **kwargs): self.index_options = kwargs @@ -17,11 +16,10 @@ def query(self, btree, points): return btree.query(points) -@register_index('geo_balltree') +@register_index("geo_balltree") class GeoBallTreeAdapter(IndexAdapter): - def __init__(self, **kwargs): - kwargs.update({'metric': 'haversine'}) + kwargs.update({"metric": "haversine"}) self._index_options = kwargs def build(self, points): diff --git a/src/xoak/index/base.py b/src/xoak/index/base.py index ab78145..1bd0afe 100644 --- a/src/xoak/index/base.py +++ b/src/xoak/index/base.py @@ -5,11 +5,10 @@ import numpy as np -Index = TypeVar('Index') +Index = TypeVar("Index") class IndexAdapter(abc.ABC): - def __init__(self, **kwargs): pass @@ -27,7 +26,6 @@ class IndexRegistrationWarning(Warning): class IndexRegistry(Mapping[str, IndexAdapter]): - def __init__(self): self._indexes = {} @@ -62,7 +60,6 @@ def __repr__(self): def register_index(name): - def decorator(cls): indexes.register(name, cls) return cls @@ -85,14 +82,17 @@ def normalize_index(name_or_cls: Union[str, Any]) -> Type[IndexAdapter]: class XoakIndexWrapper: - _query_result_dtype: List[Tuple[str, Any]] = [("distances", np.double), ("positions", np.intp)] + _query_result_dtype: List[Tuple[str, Any]] = [ + ("distances", np.double), + ("positions", np.intp), + ] def __init__( - self, - index_adapter: Union[str, Type[IndexAdapter]], - points: np.ndarray, - offset: int, - **kwargs + self, + index_adapter: Union[str, Type[IndexAdapter]], + points: np.ndarray, + offset: int, + **kwargs, ): index_adapter_cls = normalize_index(index_adapter) diff --git a/tests/test_geo_coords.py b/tests/test_geo_coords.py index da1acd0..cb8a5e3 100644 --- a/tests/test_geo_coords.py +++ b/tests/test_geo_coords.py @@ -22,7 +22,10 @@ def dataset(request, array_lib): lon = xr.DataArray(array_lib.random.uniform(-180, 180, size=shape)) field = lat + lon # artificial data of the same shape as lon and lat - ds = xr.Dataset(coords={"lat": lat, "lon": lon}, data_vars={"field": field},) + ds = xr.Dataset( + coords={"lat": lat, "lon": lon}, + data_vars={"field": field}, + ) return ds From 6668f1fe70a425c65a624ada92afc11771b0c60a Mon Sep 17 00:00:00 2001 From: Benoit Bovy Date: Wed, 28 Oct 2020 23:02:26 +0100 Subject: [PATCH 06/12] add docstrings --- src/xoak/core.py | 12 +++---- src/xoak/index/base.py | 72 ++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 76 insertions(+), 8 deletions(-) diff --git a/src/xoak/core.py b/src/xoak/core.py index da2ecff..10df3e2 100644 --- a/src/xoak/core.py +++ b/src/xoak/core.py @@ -150,7 +150,7 @@ def _query(self, indexers): if isinstance(X, np.ndarray) and isinstance(self._index, XoakIndexWrapper): # directly call index wrapper's query method res = self._index.query(X) - results = res["positions"][:, 0] + results = res["indices"][:, 0] else: # Two-stage lazy query with dask @@ -190,19 +190,19 @@ def _query(self, indexers): map_results = da.concatenate(res_chunk, axis=0) distances = map_results["distances"] - positions = map_results["positions"] + indices = map_results["indices"] # 2nd "reduce" stage: # - brute force lookup over the indexes dimension (columns) - col_positions = da.argmin(distances, axis=1) + indices_col = da.argmin(distances, axis=1) results = da.blockwise( - lambda arr, col_pos: np.take_along_axis(arr, col_pos[:, None], 1), + lambda arr, icol: np.take_along_axis(arr, icol[:, None], 1), "i", - positions, + indices, "ik", - col_positions, + indices_col, "i", dtype=np.intp, concatenate=True, diff --git a/src/xoak/index/base.py b/src/xoak/index/base.py index 1bd0afe..ea28ee3 100644 --- a/src/xoak/index/base.py +++ b/src/xoak/index/base.py @@ -9,15 +9,59 @@ class IndexAdapter(abc.ABC): + """Base class for reusing a custom index to select data in + :class:`xarray.DataArray` or :class:`xarray.Dataset` objects with xoak. + + Subclasses must implement the ``build()`` and ``query()`` methods, + which are called to build a new index and query this index, respectively. + + If any options are necessary, they should be implemented as arguments to the + ``__init__()`` method. + + """ + def __init__(self, **kwargs): pass @abc.abstractmethod def build(self, points: np.ndarray) -> Index: + """Build the index from a set of points/samples and their coordinate labels. + + Parameters + ---------- + points : ndarray of shape (n_points, n_coordinates) + Two-dimensional array of points/samples (rows) and their + corresponding coordinate labels (columns) to index. + + Returns + ------- + index: object + A new index object. + + """ raise NotImplementedError() @abc.abstractmethod def query(self, index: Index, points: np.ndarray) -> Tuple[np.ndarray, np.ndarray]: + """Query points/samples, + + Parameters + ---------- + index: object + The index object returned by ``build()``. + points: ndarray of shape (n_points, n_coordinates) + Two-dimensional array of points/samples (rows) and their + corresponding coordinate labels (columns) to query. + + Returns + ------- + distances : ndarray of shape (n_points) + Distances to the nearest neighbors. + indices : ndarray of shape (n_points) + Indices of the nearest neighbors in the array of the indexed + points. + + """ raise NotImplementedError() @@ -26,10 +70,25 @@ class IndexRegistrationWarning(Warning): class IndexRegistry(Mapping[str, IndexAdapter]): + """Mapping of all indexes that can be used to select data + with xoak. + + """ + def __init__(self): self._indexes = {} def register(self, name: str, cls: Type[IndexAdapter]): + """Register custom index in xoak. + + Parameters + ---------- + name : str + Name to give to this index type. + cls: :class:`IndexAdapter` subclass + The index adapter class to register. + + """ if not issubclass(cls, IndexAdapter): raise TypeError("can only register IndexAdapter subclasses.") @@ -60,6 +119,11 @@ def __repr__(self): def register_index(name): + """A convenient decorator that can be applied to any + :class:`~xoak.IndexAdapter` class to register a custom index in xoak. + + """ + def decorator(cls): indexes.register(name, cls) return cls @@ -81,10 +145,14 @@ def normalize_index(name_or_cls: Union[str, Any]) -> Type[IndexAdapter]: class XoakIndexWrapper: + """Thin wrapper used internally to build and query (registered) + indexes, with dask support. + + """ _query_result_dtype: List[Tuple[str, Any]] = [ ("distances", np.double), - ("positions", np.intp), + ("indices", np.intp), ] def __init__( @@ -109,6 +177,6 @@ def query(self, points: np.ndarray) -> np.ndarray: result = np.empty(shape=points.shape[0], dtype=self._query_result_dtype) result["distances"] = distances.ravel().astype(np.double) - result["positions"] = positions.ravel().astype(np.intp) + self._offset + result["indices"] = positions.ravel().astype(np.intp) + self._offset return result[:, None] From 39aefff35a5bc030f7d4379380b75a3f5e6e7a57 Mon Sep 17 00:00:00 2001 From: Benoit Bovy Date: Wed, 28 Oct 2020 23:04:32 +0100 Subject: [PATCH 07/12] rename core.py -> accessor.py --- src/xoak/__init__.py | 2 +- src/xoak/{core.py => accessor.py} | 0 2 files changed, 1 insertion(+), 1 deletion(-) rename src/xoak/{core.py => accessor.py} (100%) diff --git a/src/xoak/__init__.py b/src/xoak/__init__.py index 3ae9f7a..e056fe7 100644 --- a/src/xoak/__init__.py +++ b/src/xoak/__init__.py @@ -2,4 +2,4 @@ from .index import IndexAdapter, indexes, register_index -from .core import XoakAccessor +from .accessor import XoakAccessor diff --git a/src/xoak/core.py b/src/xoak/accessor.py similarity index 100% rename from src/xoak/core.py rename to src/xoak/accessor.py From 1f6459d67cf301882e251fa572322b79113843a5 Mon Sep 17 00:00:00 2001 From: Benoit Bovy Date: Thu, 29 Oct 2020 12:28:35 +0100 Subject: [PATCH 08/12] add tests for index base --- src/xoak/index/base.py | 2 +- tests/test_geo_coords.py | 6 +-- tests/test_index_base.py | 100 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 103 insertions(+), 5 deletions(-) create mode 100644 tests/test_index_base.py diff --git a/src/xoak/index/base.py b/src/xoak/index/base.py index ea28ee3..3363d3f 100644 --- a/src/xoak/index/base.py +++ b/src/xoak/index/base.py @@ -105,7 +105,7 @@ def __getitem__(self, key): return self._indexes[key] def __iter__(self): - return len(self._indexes) + return iter(self._indexes) def __len__(self): return len(self._indexes) diff --git a/tests/test_geo_coords.py b/tests/test_geo_coords.py index cb8a5e3..2a81ded 100644 --- a/tests/test_geo_coords.py +++ b/tests/test_geo_coords.py @@ -43,12 +43,10 @@ def indexer(request, array_lib): return ds -def test_indexer(dataset, indexer, array_lib): +def test_indexer(dataset, indexer): """Select the dataset with positions from the indexer.""" # create index - dataset.xoak.set_index( - ["lat", "lon"], transform=array_lib.deg2rad, metric="haversine" - ) + dataset.xoak.set_index(["lat", "lon"], "geo_balltree") # select with indexer ds_sel = dataset.xoak.sel(lat=indexer.latitude, lon=indexer.longitude) diff --git a/tests/test_index_base.py b/tests/test_index_base.py new file mode 100644 index 0000000..ed05f13 --- /dev/null +++ b/tests/test_index_base.py @@ -0,0 +1,100 @@ +import numpy as np +import pytest + +from xoak import IndexAdapter, indexes, register_index +from xoak.index.base import IndexRegistrationWarning, IndexRegistry, XoakIndexWrapper + + +class DummyIndex: + def __init__(self, points, option=1): + self.points = points + self.option = option + + def query(self, points): + distances = np.zeros((points.shape[0])) + indices = np.ones((points.shape[0])) + + return distances, indices + + +class DummyIndexAdapter(IndexAdapter): + def __init__(self, **kwargs): + self.index_kwargs = kwargs + + def build(self, points): + return DummyIndex(points, **self.index_kwargs) + + def query(self, index, points): + return index.query(points) + + +def test_index_adapter_base(): + class IndexAdapterSubclass(IndexAdapter): + def build(self, points): + return super().build(points) + + def query(self, index, points): + return super().query(index, points) + + adapter = IndexAdapterSubclass() + + with pytest.raises(NotImplementedError): + adapter.build(np.zeros((10, 2))) + + with pytest.raises(NotImplementedError): + adapter.query(None, np.zeros((10, 2))) + + +def test_index_registery(): + registery = IndexRegistry() + registery.register("dummy", DummyIndexAdapter) + + assert registery["dummy"] is DummyIndexAdapter + assert list(registery) == ["dummy"] + assert len(registery) == 1 + assert repr(registery) == "\ndummy" + + with pytest.warns( + IndexRegistrationWarning, match="overriding an already registered index.*" + ): + registery.register("dummy", DummyIndexAdapter) + + with pytest.raises(TypeError, match="can only register IndexAdapter subclasses."): + registery.register("invalid", DummyIndex) + + +def test_register_index(): + @register_index("test") + class TestIndexAdapter(DummyIndexAdapter): + pass + + assert indexes["test"] is TestIndexAdapter + + indexes._indexes.clear() + + +def test_xoak_index_wrapper(): + indexes.register("dummy", DummyIndexAdapter) + + idx_points = np.zeros((10, 2)) + offset = 1 + + wrapper = XoakIndexWrapper(DummyIndexAdapter, idx_points, offset, option=2) + wrapper2 = XoakIndexWrapper("dummy", idx_points, 0) + + with pytest.raises(TypeError, match=".*is not a subclass of IndexAdapter"): + XoakIndexWrapper(DummyIndex, idx_points, offset) + + assert isinstance(wrapper.index, DummyIndex) + assert wrapper.index.option == 2 + assert isinstance(wrapper2.index, DummyIndex) + assert wrapper2.index.option == 1 + + results = wrapper.query(np.zeros((5, 2))).ravel() + + assert results["distances"].dtype == np.double + assert results["indices"].dtype == np.intp + np.testing.assert_equal(results["distances"], np.zeros(5)) + np.testing.assert_equal(results["indices"], np.ones(5) + offset) + + indexes._indexes.clear() From 1b354997a26c6f7215911c6e18a5b60b2ebd30ce Mon Sep 17 00:00:00 2001 From: Benoit Bovy Date: Thu, 29 Oct 2020 12:44:16 +0100 Subject: [PATCH 09/12] move fixtures and rename test balltree --- tests/{test_geo_coords.py => conftest.py} | 25 +++++------------------ tests/test_index_balltree.py | 12 +++++++++++ 2 files changed, 17 insertions(+), 20 deletions(-) rename tests/{test_geo_coords.py => conftest.py} (68%) create mode 100644 tests/test_index_balltree.py diff --git a/tests/test_geo_coords.py b/tests/conftest.py similarity index 68% rename from tests/test_geo_coords.py rename to tests/conftest.py index 2a81ded..89df5bb 100644 --- a/tests/test_geo_coords.py +++ b/tests/conftest.py @@ -1,10 +1,7 @@ -import numpy as np import dask -import xarray as xr - -import xoak - +import numpy as np import pytest +import xarray as xr @pytest.fixture(params=[np, dask.array]) @@ -13,8 +10,8 @@ def array_lib(request): return request.param -@pytest.fixture(params=[(100, 100), (10, 1), (10_000,), (36, 18, 12)]) -def dataset(request, array_lib): +@pytest.fixture(params=[(10, 10), (10, 1), (1000,), (3, 10, 5)]) +def geo_dataset(request, array_lib): """Dataset with coords lon and lat on a grid of different shapes.""" shape = request.param @@ -31,7 +28,7 @@ def dataset(request, array_lib): @pytest.fixture(params=[(10,), (33, 69), (1_000,), (1, 2, 3, 4)]) -def indexer(request, array_lib): +def geo_indexer(request, array_lib): """Indexer dataset with coords longitude and latitude of parametrized shapes.""" shape = request.param @@ -41,15 +38,3 @@ def indexer(request, array_lib): ds = xr.Dataset(coords={"longitude": longitude, "latitude": latitude}) return ds - - -def test_indexer(dataset, indexer): - """Select the dataset with positions from the indexer.""" - # create index - dataset.xoak.set_index(["lat", "lon"], "geo_balltree") - - # select with indexer - ds_sel = dataset.xoak.sel(lat=indexer.latitude, lon=indexer.longitude) - - # ensure same shape - assert ds_sel.field.shape == indexer.longitude.shape diff --git a/tests/test_index_balltree.py b/tests/test_index_balltree.py new file mode 100644 index 0000000..d41e2d8 --- /dev/null +++ b/tests/test_index_balltree.py @@ -0,0 +1,12 @@ +import xoak + + +def test_geo_balltree(geo_dataset, geo_indexer): + # create index + geo_dataset.xoak.set_index(["lat", "lon"], "geo_balltree") + + # select with indexer + ds_sel = geo_dataset.xoak.sel(lat=geo_indexer.latitude, lon=geo_indexer.longitude) + + # ensure same shape + assert ds_sel.field.shape == geo_indexer.longitude.shape From b888cb9c8b5c9eebfe4a14eab7327a32e7478ca5 Mon Sep 17 00:00:00 2001 From: Benoit Bovy Date: Thu, 29 Oct 2020 13:48:31 +0100 Subject: [PATCH 10/12] xarray indexing issue (workaround needed) --- src/xoak/accessor.py | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/src/xoak/accessor.py b/src/xoak/accessor.py index 10df3e2..81302c7 100644 --- a/src/xoak/accessor.py +++ b/src/xoak/accessor.py @@ -210,7 +210,7 @@ def _query(self, indexers): return results - def _get_pos_indexers(self, indices, indexers, compute=False): + def _get_pos_indexers(self, indices, indexers): """Returns positional indexers based on the query results and the original (label-based) indexers. @@ -227,14 +227,11 @@ def _get_pos_indexers(self, indices, indexers, compute=False): if len(set(indexer_dims)) > 1: raise ValueError("All indexers must have the same dimensions.") - if compute and not isinstance(indices, np.ndarray): - indices = indices.compute() - u_indices = list(np.unravel_index(indices.ravel(), self._index_coords_shape)) for dim, ind in zip(self._index_coords_dims, u_indices): pos_indexers[dim] = xr.Variable( - indexer_dims[0], ind.reshape(indexer_shapes[0]) + indexer_dims[0], ind.reshape(indexer_shapes[0]), ) return pos_indexers @@ -266,8 +263,16 @@ def sel( indexers = either_dict_or_kwargs(indexers, indexers_kwargs, "xoak.sel") indices = self._query(indexers) - pos_indexers = self._get_pos_indexers(indices, indexers, compute=True) + if not isinstance(indices, np.ndarray): + # TODO: remove (see todo below) + indices = indices.compute() + + pos_indexers = self._get_pos_indexers(indices, indexers) + + # TODO: issue in xarray. 1-dimensional xarray.Variables are always considered + # as OuterIndexer, while we want here VectorizedIndexer + # This would also allow lazy selection result = self._xarray_obj.isel(indexers=pos_indexers) return result From 1e58157e6bf497b0f6d88b62910eb28072695483 Mon Sep 17 00:00:00 2001 From: Benoit Bovy Date: Thu, 29 Oct 2020 13:52:00 +0100 Subject: [PATCH 11/12] update example notebook --- examples/basic_examples.ipynb | 2452 +++++++++++++++++++++++++++------ 1 file changed, 2050 insertions(+), 402 deletions(-) diff --git a/examples/basic_examples.ipynb b/examples/basic_examples.ipynb index 9bc160a..8ea246b 100644 --- a/examples/basic_examples.ipynb +++ b/examples/basic_examples.ipynb @@ -28,6 +28,35 @@ "import xoak" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This shows the indexes that are supported by xoak. Below we'll use the `geo_balltree` index." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "balltree\n", + "geo_balltree" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "xoak.indexes" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -39,7 +68,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -398,60 +427,60 @@ "
<xarray.Dataset>\n",
        "Dimensions:  (x: 100, y: 100)\n",
        "Coordinates:\n",
-       "    lat      (x, y) float64 -80.79 -10.39 -74.74 -77.76 ... -33.23 15.97 9.155\n",
-       "    lon      (x, y) float64 159.4 11.46 -153.8 38.71 ... -134.9 -29.72 152.2\n",
+       "    lat      (x, y) float64 50.45 52.98 6.907 -89.19 ... 44.31 -11.33 15.67 -9.3\n",
+       "    lon      (x, y) float64 154.4 -99.74 49.09 -79.22 ... 103.5 7.588 140.9\n",
        "Dimensions without coordinates: x, y\n",
        "Data variables:\n",
-       "    field    (x, y) float64 78.65 1.067 -228.6 -39.05 ... -168.2 -13.75 161.4
  • " ], "text/plain": [ "\n", "Dimensions: (x: 100, y: 100)\n", "Coordinates:\n", - " lat (x, y) float64 -80.79 -10.39 -74.74 -77.76 ... -33.23 15.97 9.155\n", - " lon (x, y) float64 159.4 11.46 -153.8 38.71 ... -134.9 -29.72 152.2\n", + " lat (x, y) float64 50.45 52.98 6.907 -89.19 ... 44.31 -11.33 15.67 -9.3\n", + " lon (x, y) float64 154.4 -99.74 49.09 -79.22 ... 103.5 7.588 140.9\n", "Dimensions without coordinates: x, y\n", "Data variables:\n", - " field (x, y) float64 78.65 1.067 -228.6 -39.05 ... -168.2 -13.75 161.4" + " field (x, y) float64 204.9 -46.76 56.0 -168.4 ... 69.79 92.15 23.26 131.6" ] }, - "execution_count": 2, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -474,16 +503,16 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ - "ds_2d.xoak.set_index(['lat', 'lon'], transform=np.deg2rad, metric='haversine')" + "ds_2d.xoak.set_index(['lat', 'lon'], 'geo_balltree')" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -842,60 +871,60 @@ "
    <xarray.Dataset>\n",
            "Dimensions:  (points: 50)\n",
            "Coordinates:\n",
    -       "    lat      (points) float64 -56.8 56.22 -78.25 68.43 ... 30.5 21.96 -76.0\n",
    -       "    lon      (points) float64 -84.84 -155.7 103.5 45.06 ... 52.72 6.8 36.47\n",
    +       "    lat      (points) float64 48.52 -10.86 -69.43 ... -36.65 -16.72 -84.88\n",
    +       "    lon      (points) float64 2.692 152.1 -132.2 147.6 ... -31.5 -148.2 -123.5\n",
            "Dimensions without coordinates: points\n",
            "Data variables:\n",
    -       "    field    (points) float64 -141.6 -99.52 25.24 113.5 ... 83.22 28.76 -39.54
    " + " field (points) float64 51.21 141.2 -201.7 147.6 ... -68.15 -164.9 -208.4" ], "text/plain": [ "\n", "Dimensions: (points: 50)\n", "Coordinates:\n", - " lat (points) float64 -56.8 56.22 -78.25 68.43 ... 30.5 21.96 -76.0\n", - " lon (points) float64 -84.84 -155.7 103.5 45.06 ... 52.72 6.8 36.47\n", + " lat (points) float64 48.52 -10.86 -69.43 ... -36.65 -16.72 -84.88\n", + " lon (points) float64 2.692 152.1 -132.2 147.6 ... -31.5 -148.2 -123.5\n", "Dimensions without coordinates: points\n", "Data variables:\n", - " field (points) float64 -141.6 -99.52 25.24 113.5 ... 83.22 28.76 -39.54" + " field (points) float64 51.21 141.2 -201.7 147.6 ... -68.15 -164.9 -208.4" ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -916,12 +945,12 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
    " ] @@ -955,7 +984,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -1314,144 +1343,144 @@ "
    <xarray.Dataset>\n",
            "Dimensions:  (x1: 20, y1: 50)\n",
            "Coordinates:\n",
    -       "    lat      (x1, y1) float64 -77.0 62.24 -14.26 -35.65 ... -37.03 62.19 46.17\n",
    -       "    lon      (x1, y1) float64 164.1 140.4 -67.11 131.5 ... 162.9 -36.25 -66.78\n",
    +       "    lat      (x1, y1) float64 40.01 -11.4 -20.83 7.373 ... -77.95 -11.85 -25.02\n",
    +       "    lon      (x1, y1) float64 -64.04 -154.7 96.29 ... -21.38 -44.47 -100.5\n",
            "Dimensions without coordinates: x1, y1\n",
            "Data variables:\n",
    -       "    field    (x1, y1) float64 87.14 202.6 -81.37 95.86 ... 125.9 25.94 -20.61
  • " ], "text/plain": [ "\n", "Dimensions: (x1: 20, y1: 50)\n", "Coordinates:\n", - " lat (x1, y1) float64 -77.0 62.24 -14.26 -35.65 ... -37.03 62.19 46.17\n", - " lon (x1, y1) float64 164.1 140.4 -67.11 131.5 ... 162.9 -36.25 -66.78\n", + " lat (x1, y1) float64 40.01 -11.4 -20.83 7.373 ... -77.95 -11.85 -25.02\n", + " lon (x1, y1) float64 -64.04 -154.7 96.29 ... -21.38 -44.47 -100.5\n", "Dimensions without coordinates: x1, y1\n", "Data variables:\n", - " field (x1, y1) float64 87.14 202.6 -81.37 95.86 ... 125.9 25.94 -20.61" + " field (x1, y1) float64 -24.03 -166.1 75.46 ... -99.33 -56.32 -125.5" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -1472,12 +1501,12 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAEGCAYAAABLgMOSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOydd5xdVfX2v3ufctuUTHollQRC6KGlMAkgIKKIP7FSFFBUAiixISogYKMKARUUxEIvgvSaSYckkIT0NunJzGQyM7ffU/Z+/zjn3plJJg2i+Mo8n9zM3Dun7LPPuXvtvdazniW01nSiE53oRCc6sb+QH3UDOtGJTnSiE/9/otOAdKITnehEJz4QOg1IJzrRiU504gOh04B0ohOd6EQnPhA6DUgnOtGJTnTiA8H8qBtwINC9e3c9aNCgj7oZnehEJ/4/wPz587drrXt8mGMMiVbqrPL2ads6N/uK1vrMD3O+/1b8TxiQQYMGMW/evI+6GZ3oRCf+P4AQYv2HPUa6kOf/ZL992vYP1Hb/sOf7b8X/hAHpRCc60Yn/NKRWH3UTPnJ0GpBOdKITndhPCAER09i3jd1/b1s+SnQakE50ohOd2E8IBIYQH3UzPnJ0GpBOdKITndhPCMDotB+dBqQTAbTy0UohDAMhOtndnejE3tC5Auk0IB97zJg+Hdw8Bw8djNZQXlZGpKwCIxJDHMAviNYaPAekgTA+msdOZVrQqUZEvAJZ8d9JjNHKJ7dmFaqQIzZkOEY8sU/7+dksLQsXIgRUHHEkRjz+b27pB8OW9xYz/0+P0rJpK0NOGcPRF51HrEvFR92s/UbnCiRApwH5GKOmpobm+q2MPekEPM9DK01LMkklEDMMhBU5IOdRmWZo3IhTyJHP5Zn13mIefX0ml1z6Taqrqz/0NUyZMoXa2loGDx7MpEmTdjmmVgpnwev4m1eBkKAVsqoXkRM+/aGv0dtRj1u/CaOsC1a/QR9q9Tbj2afxnvgLtu8hDYNEPE7/r1xC1YTT97jfjtmzWXPLb6GorC0EubPO4u5XXt1jvxxoaK3ZMnMuq55+Ea0Uwz77SfpXn4gQgpqaGh76yY30WrgeQ0iisQib5y9iwV+f5GuvPky8W9W/tW3/DshOJXPE/4Kc++jRo/W/Ow/EV5pNLTnqUnmEEPStiNKnIor8ALN0rTVKgxQc0Fn+/uLCCy/g1ptuQCm/tW1KY0dsKiq7YJV1+VDH11qjU9uhcSOe59PU0oIQAtu2WLRiLVf/egq33Xbbbgc27eZRdbWo1HaamlvYtmkjloRNTWkqDz6GHCaTJ08mkUhQVlZGOp0mk8nsckx39bu4y2aBkAghgtWQUhj9DiZy7Bn7fV01NTXcO2UKZ3bRjBvQg2g8hm3ZGJVdqTrvWxiJ/Z9R17z1Ft7vf0OVbeALgetr0JqK8jKG/uSXxAYN63A/Z8cOFl789cD9aAbzQSeXI5XOcJcUiLLy3fbLgUB60xY2vjYNrRT1769gzb9exXdd0BrDthl+3tmoT47j+1dfzcSVSfB8FBoQlJeXEzVNTrzyYqp/fHn74zY0AlDWo9sBbS+AEGK+1nr0hzlGPyOqL48N3Kdtr82s/NDn+29Fp7N7D6ipqeG8887jkEMOZcrjL7J403Zaci4tOZdl9WkWbG7Z72POeXcRMxavZv6azcxaWsvbC5fw7zDiezqm1hrf8+jbpy87my8hBa7r7Vebiv00evRozjvvPGpqatCei9qyAt24Ca0VUkBleRlSSjzP5/CDBzPkoP5MmTKl4zY6ebxlM1D16yg01VOh8wzv252eleUcPagP/XObePDe35FIJKioqEBKSUVFBYlEYpdjerULg2sLjbUQAqTE37Ia7e9bNnHba508eTKHWi5jB3TH8X1akikcx8FraqDlpUf263hFLLrrV/SOW9iGICYFFZZESkEhm6N5+pu73a9p5ky075eMB0Amn0dKwVHR2B775cOgpqaG7445lQePOpWpP7qROdfdwuq/PQ6FAmYsihmPgZSsfOJ5HvzlLUQyDtrzUSJgMEk0mVQKx3VZ/UpN6bgNq2q559Qvc/MhE7nx4JO5/fjPUL9y7QFr94FC0YW1L6//ZXQakN2gOFCsXLmSPkOGM3TkKCzbRqNROpgd7si51KXy+3zM2fMXQKILlh3B930Mw0BHy3ln4ZID1m7X80jl8iSzwavguu2Mgee6FHJZXKfAFVdMIp6IY0iJ67oopYIViG0hTWufzlfsp/r6enr16kV9fX3wfsV7QcyD4NwajWkYRCN20A7fp3+fXtTW1nZ4XL9uDXgujuMilB+sZhDEYxGy+QK2afCZ0YdQVlbWbr8jhvSnu+GinTb3xXMD4v7O0BrarL72BVOmTCGRSHD6oO6ARkqBEIJMNguGibNpDSqX3a9jznziEU6IG6EHqrWdZabEVwqVSe92X7+QR6v2CW2+52EAFq33vaysbLd9vTs4TS2svOMPTP/0V3n7oknUvzkDCO75z6/6HsNWbUFKgYcmn8sF/ZnLof2gT4UU+I6LWr2BrU2NSMDQmrgWxLUkrgV+Ooth29TU1PCFcz/Hz444lZXT5pBPpnGyOTa+t5hbj/0UyW0N+9X2fzcCAyL26fW/jI91DGRqTQ3/fHMm8V4HYUsYe9hQPjH+JKB1oFi1ahXV53yZSCQaLLzDB0IDaM2MJWvpXmjYJ9dA2pdUCBG4G4ofanDNGFrrD+3O8nyfXMHFdV3S6TQaMA2DluYdHHbooSil8FwHAMdx8D2frCMpKytHA8r3kdLAME2MSGyfzlnsp4qKwG1TUVFBxLaI4AWDthCgg1knQMSyKDguUgqWr1nH4MGDOzyuTm4HAZlclgrbRKMpGiPTkBQcl6OGDyL9/EwqKiroWhbjB586gW5lQfDfmf0M6/0Y1/7+H3xuRDdOPWwQdjRGxA4MGMpHVnRvFwPRWqPzGYQ0ELu5/traWnr16oUtRWl4lkLg+UVDJND+/mWOrX72MQ4VovRMtF37GYak/Jjjd7tv5THHsulvfwueKSnDfQx8rVnfhqyQTqd329cdwU2mmPm5r5HfVo/rexRyOda+PpVlB/VkWkQxzDeQQqCK7Q5dg0JrKDgQD/pPmAaVPbtTX19LPQYDtb3TmTQb313EM1/7DoPrCwi3OOFQoIMecXN57jn3Yt7tH/2PxnT2hv/11cW+4GO7AplaM42Zm9KMPOUchh5xHP1HjWatX86LM+cDwUBRVlZGNhvM1tsaj7Yor+rKlPsfpGbGTFZvTzN/YxMLNjezJZlrN/PXWtOla3eisRjxsjLsSCT40qGJRPdtsG4Lz1dkCi7Zgovr+yitKTgeruvS3NKCrxRojef72JEYNdOm4XvhwCYEmUwGw5AUXI+mTI535r/HoiVLeeb5F6jo3gch9y3LtthPbdGnV09UcVYsTSA0JOHQKITgiZdrqN/eyKRJkzo8rrCjQfs9PzQe4eeIIH4kBemCSyaTIZlMcuXpo+lVkUApRSKRwHEdKpKbGVBm8uKKOpoz+cBlUsijlY8wTOwjJ5aO6+/YSu6VB8i+8Hsy/5pCbuojqGxql3YNHjyYdDrNeztyyHDIVzpYXeF7mJVVyD3EQLTW+JkUKjTkAG46jRSSjBfO3Ivdhcbs2ZvyY07c7fESQ4bQ86yzQGtUPo8qFEjE48x0HGozGZRSJJNJMpnMbvu6I2x49BnydQ14AlKZDK7WCCk5dGMDS+bOx/far9y0EQwlbRdRyg3IAOf86HuYpkmtn21nHBFBknY+neHQugKmq9r8qfW7ptFsnruIl196mc2bN7Ny5UomT55MTU0NHxUEQRB9X17/y/jYrkCeq5nDIRPOBqXaDayb/Riurxg8eDD19fXE43FeffpRPnfxtzs8jtZw+JiJbNdxzJYMlmXi+7CpOUfO8RnaPRhc31m8gkhld4xwVmhHDEzLJp/Nkk42I0Tf3Rxf4ymNUhrLDIasVN4h53h4nhcE8YUgm05jWSZuIQcaZDgbRWsi0Sh/efBBxpx4Qum4vu8jZRBUFkIwf+Fi3pk7l7q6Oi67/Mo99p32HPxcGnyXH0z6Fo8+8xye0hw6dBCXfPGzdKuqJBqNUvA8Muk0iXiMiCHRChqbW7jlzw+zYXtyj0Fd2XMwfroJ2zLJuz5Ry0AgKLguIuwX2WcYt912G4899Gf6VSXwtaaiogLbtmlqasI0DD5z/Ehue/Edfv7SQo7rV8GRA/tw8ic/gzloFDIeDPQ6nyFf8xjac3Bcn0w2i9G8hKYli9h+2BlUT5hQatekSZOYPHkyz6zYzOFVQ+liSSwpiMdjYJjYg0eSevMZzJ79iI44Cmm3rnByq5ey4eE/4jY14vk+S/Iw4IuXsilaweE4KClIeh4RKZGALyRH3nB7u/jGzlCuS/8LLqDrSWPYPnUqQgi6TZiA19jI0nvu+cAz9u0z3gatyWQzwTMiZWgcBMPi5Uxv2MzxsjtCa7QQKK3xDImtNFh28AxaFqfeczMDTzuZ69dfz79+cCMuCp9gEqEBwzSx3CA2IoG2ZqntikwDiXgcx3FYv349AwcOZMqUKR/ZKkQIse9SJv/D+NgakPK+g5FSts6UARHO2Hfk3NJA0aNHD9Zt2IjjONj2zsvvAINHHEqsLEGypSUYwCI2Wmsasw79PZ+358zB7N6fXC5LWVl5aT8pJYZpEFWFDo/rKcWaTXW4vsZ1g/ObAioqK/E9F8MwStTNeCKYfZumSbqlGSEEUkqklDiFAkuWLkUaBr7nBQwZw0ApVdpm+fLl++TmeG/u2/TvmgjaLiRnnTaBE489ktvuvZ8fXHYhQkAul0drRWVZGYmycpxcBhGNYscq6DXoKG77/al7vT+ysie636FEnUWkUkkMKUBrUtkcnq9YnYZTzwzoreOPGYX73mvt9vd9H0OaJMKYS8bxeHPNdh6ZtYR5k3/dblt3/RK05+J4imQqFQxuQlBuS26/41cgRGmgqq6u5rbbbmPKlClMfn0REwb3ZkRVgpZsPacM7oU7dyqWIcEwyMx5ja5fvgKjrBJn2yY2P3AHTiaDIQW2FBwRU9TcfRNN/Q9j9daVDIvbmKaJ0hpHaZh4Fmab56Xd9eWyzPvlDbjvLwDfZ4dhUfXlCxn/xS8H7YR2hm9/Ee3TC60VvhesIgDQGglUHdSfRcuXMG/IQRxbl0EohdCaaFkZo390BZUjAsZYnxOPwQpdWVdddRVT//IIanl9sKIUYBgmQmsEBKvKDtpRNB6byKMFmKExra+vx7L2LU7370BnHkiAj50Ly/UVqxszVPTsixay3ZJaaY1pmlhSlAaK4cOH43semVRqF5eUDt1Ebj6LIY0gmJrJAMEMRQA51+elV19H+QqlFOl0Cs8LmD++7yO0z0mjj96lnVpr1myqw/M1juNgWTbxRIJIohxf6eDL17oxAPlcDmmYRKJRlNaUlZdTXlFBRWUlP7/+Bi666Gu8+uprtLS0EI/HsSwLIQT/ePgRtmzdulc3R01NDVHtEI1EKIvHiUYjWKZJj+7duOrSCzCkpFBwMM0gINySzuBpeGXmXO7621PIPsP2mESotUZrVepno+dAEsedxSa7D1c/8DyfuuZ33PzUNDZUDGXiKaeSnPVPWmoeZdnLj5FMp3GdVkNsGAZaa+bVbi19tjsDqdPNoBWZTCY0vAIhwJCSft0qd2EvVVdX88QTT/DL397CK6u38OelWxjWoxJbaFpSKVylEdLATzWTqvkXhfWraH71afxCnkTEJGpKopZB3Lb4xJC+vPLPp2gc/0med23mNGV51zfxPn8xJ+5m1Qsw/9of4CyYj68UvpR0VR7e3//MtH89t9t99geDLvgC0rIwpYH0FZbvYynNjphFpizG6NGjSR0yiCf6RlkzrA8DLv0yn5/2Tw7/9kUMmDiGHqNGlILpRVx1269oKbexTQvbMDHC+6xtCxXGAK1dBmWNg2KWSJY+MU0TL5nhEJ3g9Tv+xKZFyw7INe8vOllYH7MVSKrg8eLyOvKeorxnX3wN2jbwM8HDadsRymMRqmLBzKa6uprq6mrOO+881r7/LqNOHB/ELqAU9G6s38bCOTMY8IWvorTGD780wSAosA3JyhXL+bQhg/wPpchmAyMjDYNBvYOMaMdTNOcchICquI1W4IbGQ2tNoqyMYgxBaY0Zup6C72Dwue/7NDc3Ub91K6NGHVbKeTBNkzFjxzF8xCH86qZfsGzFSvr17c3QoUN54sknmTZt+j65OR76y4PcccM12JbVxphqDCkZ0KcXUggKjotR9IdrTa5QYN7S1bw1YzY/uv7mDo+rtUYn66BpKygPDAvddQCyvBtCGhx38ikcd/Ippe39bWvJr3mPXCaN1ppeXSsxhCCfyyAIBpiyRJyVG7bw7Jz3MexoKReiIwMpu/dD1C4qufXaYltOUVu7rsN2FwkEVZUVHFwZDQxHOImwIxE0kFs0h5ZFc9HZDBFTopRuN2mxDMmEg3oyfeYsnnji6aA/lCK3ainN01/D7tGb2PCR7WJS+c0bcdauxg+fAQBfCCw07z54Pyd/+jO7vYe5zZvJrV9PtG8/4oN2n8ewoLGO17tGOWl7IwZh7ElCueNhJdP87M7bO3xWXv79n1n2q7uxsnkMw6Db2OP47F/uxq4oZ8IpE9GP3MPD196MvWYL0bIEYy67gD7lXXjl+ttxkhmkFNha42vwg0UnL8gmsqYk6nnBMdOK43NdsBZt5NEf3Iw0DUZ+9hNc9ci9/7G8KiE6pUzgY2ZAZq/fQdb1MaXEQJHPF7BjMWQkhnbypJq2M0QYCDG03X6TJk3immt/Sry8goGHjMIwDKQhWfLuPP7wix8yfMQhqP/7EoZpIny/ZDzKIiZx20Qqj8b6Onr27YfnBvEWKYJvR9e4zdaWLC35YFWilaI+meOJvz7AWZ/+DEIIotEYoMN/rT5nQwiEFARlCTSe7yEQvDd/LqNGHYZSqmREhBD06NGDG3/5K5xCAeX73PW733HX7+7c5/5bsXIltm3vkiMShsYBME0DX6lSgqVlGDRub8AUmtGjR3doqHSyDmdbLa6TJ2IaSFlAbVrCM1Pn0nvk6Pbbao2/ZQXZbC68LonnK4Qh2ZZ1WbV8A2effirRrn3JmJsp7/LuXuMAZv8RuMtmE00l8bzWti/c2sKKLQ27desVGVkhqzsIrBYZWUpBIYfWkEwliQuBQRD891Xb/hMc1rs7D4UUWz+bYfOUX+LUbcEtFMjk82zN5nnci3Pp5VdQXV2N01CP43sYOxEdhJDE0kk6Qs0bb7Dil79iQCYLhkEiFqX7saMZcf3PMWLtSRxFavbpBQm2Qd7X+EohDEEMwff7D++wH1979AlW/fxWbA1aSjylqJ82h6c+93W+/PqTAEw89VQmntreham1xorHefPmu2nZtBUMgS8Ardg4uCtR12ZYLEZ9fT35VJrj81VIIdBSIEVAdX7/qZd5asqf+PwV3+jw+g80Ol1YAT42BsRXms3JQmnWkMlk8JWikA0otfOfeoB1yxYxp0cPTjt5bLt9lTA4/hOfZtXq1cyeMZUoPscefiiP/el++vftg9Q+D93xSz75pYsYMvwQQNA1bjOoa6BHNGnSJG686Wd8c/I1DBg8FN/3yWazxPwcnurbajy0Ki3lz7vwYgqp5iDnpC0LKTQ8ChHODAEpyKQD98tTjz3KSSedVIqBQEDPLc7MTMMk52UwTJNJV17J9OnTGT9+/D71Yd++/XCcwIXV1ogIoOAr4rZFWVkZyWQKKSWWZaJ8xS8mX45tW2ze1sBNd/+JyZMnlwLoWmvyW2vxCjnikSBzQWuNFILPVh/H5FvvA2gdsJQf5Id4brsB1FOKbpVlfO2Rlzh38o0AjO83nPETWplWu4MwTGKnnM+mlx8jX/s+voZp6xp5dkHtHt16RaJFRUUF7+3IcnTXOI5SmIaBcgPmXt71EELgAcXWipDaDOAohWtYJSO1/dlHKGzZiKsUyXQaISX94hHGJ7OlfjvpsJFEDBM3nCAUoZSmkCjDz2QwEq0aWjU1Nbx0zU+YYJiokEaeTGdg7lwi993P0KvakyaKK6vDmlMoIZGWQOggXlbRpQq9bhNeOoNZliBf38Cm51/D2dHMvD8/RIVuZWSJ8FxN7y+jedVauhw8pOP+F4Ljvv4Fjvv6F3AyWdZMnY3yfAaffALxqsqSXI1lWQyPVmG9swYtRMnQSynB8/nXXff/xwwIdEqZwMcsBtJ2wuB5PlIIhNb4rsOOTbWUJRK7JFu9MWM263QFo0//DCedcTZnffVSjv/UFzhs5GHcdttt9OzZk7q6OtxsioPicMLgHoweUMWw7mUYQuD6ipNPPpmfXfsTnvjTPVx31WX8497bMVP1jDnuGHZkWv32KpyZFlcMS5YsCemMrRnUAbszSGZ0fEWh4OD7PhvWr+O2X/+She/OY9Cgge2X8m1+L+YreJ6HlJInn3p6n+mQkyZN4q3ps/C8VoOEEDiuy7qNWzC6D8AuryKeSJDKZAMNqkIhdGkJBg3oyy8mf6d9VrRWeE6emG21c+1ogtn6Nz9/VvsYhDTAsolYFrpNRThTSjbU7divXIe2EHaU4Z+5iKajPs0vZ67nbzPep1uPHntkik2aNKlEI36ytomNqTwCTSIeD+NSgkzeCVZJCBStUwFfK7KuR95XzG5Il4xUav6sIACfzSJClpyv4ZjySKnf7O49MI84GhnmXQggojQRrRnlFJh+3me4/7OfouaNNwC47bqfc6ppEDMEERn0rhCCbD5Pwyuv7pKIWKRmt1sntct1Cf5SP+NtXj/18yy8+U4W3P57BjYmqRC0J6aEK5Hslrp9ug92Is6hnzqVw845nXhVJdAac5o3bx7X/OQnqHCC0f4GClqSHa++/h0QBAWl9uX1v4yPzQrEkIIBXaJsaM5jilZXi2lItix9F+g4yLqqxaesWxTte0FuBVDRtRuzFs7l2svO73BwqampYdr89zli7CnEYkGwedhRx/P444/v4qNVxUBiB5OZbdu28oc7b+HcL3yZkYcdzvBDDgkD38Hfc7kchXwe0zQ5fvSxTBwb5AsopUhmWzOx254z1yarWQpBeXnZPtMhq6ureeiB1TQ0NpKIx4IBDoHjOrhGFGFYGF16U96lN/GqOnSmmVw+8IUDuK5Hz25VHDFyBLPnvhs2TrKjJUX/nl13WdW4nk+/Xt3bGXUhBEa/Q4nl5uNn0iilsE0TTyn+9MI0Jk26aq/Xsbdr3FdqaFtG1traWn5vR/n+hV9i0OAB6EKe5BvPYhgFlPIRQlIwDCK+T9LxwmfP4I0Wn0k33Nx6Tq0A0Y79pAncJW2zyY+/7mZm330HqamvE/FcQJD1FUpKhJQMdwu8fdP1vPXwP/g+CjMSfNUtIKYh5Xi4SqNcN3C3tYn9FFdWa7okGLU9ha91SUlAOw5Vxx+NjNjM++7PKORyJLMZREg9jgiB7fs4BCsDrRSWlHQ5pGMtr/3F8OoTME0T3/ORRitVXQuIjRx0QM6xLxAfgwD5vuBjY0AAThrYlaZcHamCRzRRTiaVpGnrRlZOe6nDZCvHVyS6dt9FL0lrTY8hIzo8R01NDY/96xU+c8GlaMB1XTzPY42QGELQuyLabvttG9ZR1mtA+K74JQ4M1cvPPs3ihQtYuWwpEyZMoGvPPnzvh9cEs1LfQ4VBW8/zMNsMAFJK4hGbbKE1WU1rTUtzUyhjF7CULMti9erV+yVxcdHFlzB75gw2LlhM357d2N7UQp+BQzlhTHu3H2GfmUb7mIjWCts0SoZaCME/a+Zy+edPp5hqWPxZcB02bds1BmH0HEhUGhRWzEMXsqzdUs8L767m/G9ftc+Dv8o04615D9W0DREtwxxyFEaPAXvfcSfszuBorSjUriCx8n1ymTRSaHwheXlLC/O3bOeySy7hqLPP5chEe5pu4vBjSS94B8M0SzEsC1iWV+0mOMIwGPPd78N3v8/Ka39I3aL30FJiS0Ek7NdTEhFytas7FPwsMw2yBY81ros7c2a7ayhS2KfH4vSOWlTlHAyticUCNQYvlWbRD29A5XJkC4XAeAiBNg3wFGVC0Oj7pdVyz7NOId6rx373bUeIJOKccuNVvHbNbSVFBw3Ud4tw9XU/PiDn2DeIDySk2uGRhBgA/BXoTfDlv09r/TshRFfgMWAQsA74gta6KdznGuASgtSZK7XWrxyQxuwnPjIDIoQYQdA5RQwBfg50Ab4BFMVvfqK1fvFAnHN7pkBzzkXpwGfu+j5P3P1LNi1/nyOPPHIXd4UkoHK6vt/uYdEa2hOAWzFlyhS+dNVPMQwTaVqIqMBzHXK5HJta7HYGpKamhhWbt3Ni936Bm6d0Conjulxz0y1cc+VlnP+lL3DVVVdx/gUXkE4lKa+oLBkPKQ3qtm7BHnpQu3bYloltmUEmt4D169djWhbx0L2i0Tz6yCNs3bKFwYMHB8HpcIVlhK6T3eGkseM48aSTUJ4DCKTVQX5MJA75NOXlFSE9V1MoFCgU8jzxzHMMGXYwNTU1VFdXc/T403js5Wl84YzxoXFU+FphGSb/fHPWLjEI7XugFZV9BoIdZfRJ/Tnu/I7zJTqCyjRTmP1P3HyObC4fyG9sWE0h3pWecRO0wug3HHPo0Qiz49yfvUEXCpRP+BTREUewYcYbLF6xgheWbyBZ3p1J1/6C43dj6Hqcez752tUkfEUhk8bTkNTw6JaW3cZj3B3bEUpRJmXrIxSu5kwEiJ3ENQUIQ2BLyXS3QG7y9+Fzn+OIU0+ly+hj262s/pRdy4kH9ePsISNgxlwAUstXk1y8HDJZdJuVkpASV2p2aE1G+UQqEhx84Xl84orLaJi/iLIBfYn1/PB1WL70/Ul0PXgQf73pNhrr6qkYOZjJ1/zgP5pUWCRMHCB4wGSt9btCiHJgvhDiNeBrwBta618LIX4M/Bj4kRBiJPAl4DCgL/C6EGK41nr/hN0OAP4r5NyFEAawGTgB+DqQ1lrfuq/774uce8bxeHjB5iBj1nVJJlswTAvte7x6x09o2dHYob/7X/NW0OKC7wdZ30prpJT0kAXOPPGoXc4zfPhw7v3nmxiWTXE+LQjcShHbYuzgVnnqr19yKZf98Dq0UtiRCNGQDaO1ppDPk8/nMQ3BccMPQoqgpsJvfnsLl3zrckYdeTS+7zNz2lQOGXLQXgPhWmvmzZ/PnLffpn//AQw4aCDRWJS5b79NPpflnHPOQUpJLBbDtm0sywrkOTqAl89QSLWQzeUwBETCxMlIPEFwKzUYNrp5CwIdspSC52zB4qVcdf1vsW27ncR4TU0N86a+woWfHE9VRTkKTcFTOK7HvY88x6LaLUyaNImTx42h5b03UflsEGw3DCKRCNGhRyO79NpjHxThLHqLwoblNKfSpUz8MlNgCFCh9Eo+n2N13Q7umrmWb19++T4PTtr3SU9/lsLyd4PaI0D8mGpio0/ZZ4qpch3SC+eycvYMXpj9Di+v2kD/QYNKLDI/l6XxhadomTMdtMb3FOm1GyhFWNos49xsqy7Xzt91J+8hdevfClIS6T+AsQ/cj1ne3iDP+eIltCxegRGN4DgFMpkMEcfD8zV5QjYcGoTg9V4JskMH8Ngjj/DPS79Lw8tTcZWPJQ26TxzDuX+9B/khkwC11myc/z471m+iz8jh9Dp0311kB0LO/WA7ru/stW/nPHvT+/t1PiHEs8CU8DVBa71VCNEHmKq1HhGuPtBa/yrc/hXgeq317P29jg+L/xYX1qnAGq31+n8Xj3tNY6ZEfW0JE8YIS7gOPvIEVr1T02Es4PSjhvHyonWkCkGOh2maVBqKU485gqV1STa15FFa0z0RIVW7hFzBQZQyd4P/tBBIQ2LuRFlIpTOBfxwRKOGGM3UhBJZlUcjnAEnG8SiPWKW2TZkyhXXr1jEoHFT2hUU1bdo0pkyZwohDDuXsT5+DDBPtTj/zk8TjcfKZIMExmUxSWVmJ4zhMuvxyli1b1o4CqzyXQqqFlmSSWMQiFo2UrlVl04Amny+gfJeoZSKEwDQkrueRzxcYOngQh488hK3120vXUnQDnXzCseitK4HA9ZfNtWAYksu/8lku/tltTJ48mduvuYqRPeN4fuAWc30f13NRa94jcczp+1TQSTVtI5PLl4yHISjdm3TIzhNCMLhHF/rHaMcaa3ecbIrCsrn4DRuRlT2IjDyB3OI5FJa9C+EqrlAokHzrWX7/m1tZJ8raUYm175NftZjcykXIaIzEkSdh9eqHtGwqRo9l9OixjL4CrmtzTq0U71/3fbytG3E9H2kaJKQkUm5TSLZRNAgNgzAE2g+J1m0ZW75qx6ARQhDVmtz69cy87gaqb2+dvynPo+X9ZchoFMcpBMFqDUJpbCCuCWI3QrAqarBEuNw2aRLP/+h66l54Ay0EhgxcmfWvT+ef3/o+J158PrEe3aga3jEza0947fkXefrSHyOb0xiGQSwa47AzJ/CVB2/F3I1axIGGkAIjus9GsLsQou0M9z6t9X0dHleIQcDRwNtAL631VoDQiPQMN+sHzGmz26bws/84/lsMyJeAtoUUJgkhLgTmESztmnbeQQjxTeCbAAcddNDOf94FBU+VDIjve8iQAiqEgRmJ7lbuOmIafOboITTlXHKuT0XUojxi8vaGJnZknWCgy2RoSUrShQijx1aTTacpq6hsLyCIwN5pRt+jRw/iibIgq1zQWuyIMEtdBhz3thPHtj53HTKx8q5PxNy926nI66+qquLSyy4DgriJECJwVwGmFUGpHIJAqTdiWVz7k5/w3HPP8dLLL5cG0bHHH0PBKSAExKKRkiqxEWSoFG8OhpQYUpLJZolEo7Qk0xiGREjB0IED2Fq/fZc+15nm0D8og6xw2cpAG3vM4Tw/NYWVbwYSyNBQSBEY31w2SyKfgdjeXVkiWoagVf3YbNNtjutimiZCSCzDYNRBvZi7rm6XyYWfaiL9rz+h3YCs4G1aQ8Pct/CyObSQxEMabTKZxDIk5x0+iB+8ubTUjyhF6p8PMtAusnlMUtNfQVRWUXnypygbPb6krtsWsx/7B2LTOjQCYUh8X+EphSkFWBI81U7O17AN/IKPbpN7orVGSIEZMfFdv2RgACwBmTltx6Yg3mLEomg/yNZHg/Y8TC3wgVzIhtMa+mcVFzuSuouuJp0OVqi+bBValL6i6ZlXePy514nHYvQ++nA+8cDtxPaxImFNTQ0PXHw13VscMCS+0qTSKRa/9BY1d/6ZU3+4++z9Aw2x71H07fuyAhFClAFPAd/VWif3MJnu6A8fiSvpI6fxCiFs4DPAE+FHvweGAkcBW4HbOtpPa32f1nq01np0jx57D9D1r4xhhAO0YZglCqhAU9ajD0Oqz+bYiWeWWFE7tZGucZt+lTHKIyYteZemnIPruWSzWZRWKM8nEo9zzMQzsKNR8rksnueidVCfQUpBeaTVXiutuXTyT3A9r7TygJC5ojX5fFBfwTJN4taurqSC57Nqy3aWr9/C0tqNvLuiljlz53d47UVe/5ChQwkd4kHw3XWDQVQEonYAFeXlxCIRDMOgV69efO1rX+O73/1uO+qtDrW02iTBFzsqSGaLRohGIggpiMViZLM5TNMIaMoaWpKByu0urDcpSl8N3/NKqwkdapSVlZVR39gU6GLRdrcwZXkfa62bQ44CxE6UBUHB84OEwPC8nlI0ZgodTi7y899AOzmEYeJ6iuZUGqk1CdvE932SLS2kirpaCCpso1TY6brrruOxW25kUCQQKbQE4PtBHlBzI+sf/zN/uvCcUnGutpj57NOYYY6PIPgZZhGhrYAujWjtRyEE0pYUaE/VLcKwjXbDkYRdlHaFEPT/4rlo5eN5Pkr5mKHUuoPGFeDoYNUWE5JKX5PK5xBaY6ugBohSCjwfq41LN5lOs3X+QqZe8dN9um8AU+66i+5JFwwJRdkZaZDP53nnoaf2+TgfGgKkIfbptU+HE8IiMB7/0Fo/HX5cF7quCH/Wh59vAtoyPvoDWw7Ide0nPnIDAnwSeFdrXQegta7TWvs6GOHvB3ZfDGE/0Ls8wuCucTQQS5QFAW7LRto2PQ89moOOGsPBn/g8f5+5tJQpXFNTw+U//jk//eOj3PTgk7xWMxOApqxLwfNRWhCJJ4iXVWBFIpRVdGHk6DFIwyQaiyMQtOxoJJdJozyPPm0C6Mm8SyQaI5vNkkol8byAVaV1IF8iwvKrKtuCabS/TUprNtQ3kSsUAvkNITAtG7uyG9NnzNzl2ou8/mQyWaLUFgOAjuME7ielsC2rVTgPKBQKeJ7HiSecwMHDhlFbW4u0IiilQ9dbe4h2I1FwHMOQlJfFKSsrw7IMmpMp3l+xukPWm0h0pWjgDDMw8kY4e12wYi3pdJon3piN76u2qS2YhsH6+h0Ie++y+DqbYu3id1nV0ILrefieh6c06YKD6/lYYX6JbUgcz+ftdfUd0ru9LWtL15jJZpAiGMiFEFhGcO9c10VIiSkFa1qClUpZWRkLFy5kTN9umFIGxkAEyrRBvwbZIif26oJI7thFtnzltnp27nkvzBVRGgpGe2UAz1fsyDkUlEIV14htd9cg2/hWlYZ15Ql2xvDvfoten5iIbRhhHgb4aAqlyY8g2mq1EFKGpWvB8hXC94mET4gHoWQJOJksm6fNIb15217vHcD6tet2ee6kFHi+h5vf9+JuBwIipEzv7bXX4wRLjT8Dy7TWt7f503PAReHvFwHPtvn8S0KIiBBiMHAw8M4Bu7D9wH+DAfkybdxXRYsb4lxg8YE4iRCCU4f1YPygrlimgbRjYNh4SqB8jVbBDLAu6/LCjLm8VVPDzK15jvu/Sxh27Bj6jzqOTfH+/HPWQhat3xoEhsNja8CKRAMGkeuyvbGRguNgmCbReALHKfCnW3/BvDmtg7sTutS0VvhKkUqnadzRSCaTYfniRfzryUfxm+s44cjDdrmWnOORy+WDlY0IZp06VOLdVN/Iqg1beW/ZGv72+NN8Z9IVpXrh6VSK+fPmYlpB0p5lWfhKBcWlQrVfEfZVNpstJYRprenbrx+DBw9GGFZIDxaBhEjx21xcuUkZDKyGgZatPmIpYNmqNVx/y11EDEGfPn12iSsIOwbd+gNQlkgEg43vc8ffn2FbfQOZTIbjTjmTf7w6o9TzQsCazXU4PQ8GoKZmKt/79jf4v0+ducsM3m/YQHrOs1Rm6jh0UD+s8gpW1Lcw+opfccXDU9Hl3akoT2BIwfrGJDe/soC6xqYO2U/FeiUQJGWKsDKhIw0MIUhYJlHTwBLg+JrnancAwaoLwJdG4DosjrmlJ0kgCAzKod277FKKNtWjD2lftfM9G1qzQ2mebUyz0dcskQb3ZF2+ta2Z7X36Y1smlizmlIQ6UzuxsorY4hQ4YvLVOz9ySNviyNt+Qdfbr+fufCN35BrIFb8DWmPJVmUESwdZ9yqcfQsNcQSmCJ6DgvKxXB9DawylcdIZHhn/WbJhXGxPGDhsCJmEhWjjklNKY0qDQ8+csNf9DxSE2LfVxz6uQMYCFwCnCCEWhK+zgF8DnxBCrAI+Eb5Ha70EeBxYCrwMXP5RMLDgI2ZhCSHiwEZgiNa6JfzsbwTuK03Afb6sGEjaHfaFhVXEYws3s7k5TSGXb626J0C4+UCuwTBoWr+K+lWLOfFzF9FqJlrn16ZfIBqNYppm4E8GpCHRGvLJZrywvkjEjpDPpnnizhtpbm6iZ8+ePPFE4KlL5l02NGVpamoq8f2D65f8dcqtNDdsK227M1J5h7Wb69HKp+23PxaPgw7qm2ilMC2LQj7PlZddwtbNm+jduzdVVV35wpe+xJhx4ykrK8P3ff70xz+wbOkSrrjySkaNHIlSipaWllKQGeC666/n/PPPL8mPvDv3HVauWErvblWMOHgoVZWVJbdWyaYQBIobt2/HNAyam5uoLA8ynMvLy4n16I8R3XW2qz0Xci0sXbaM39z1B5YuX9EukF9TU8Nf/nw/tnJIVHThnC9+herqCbw7/U0qkxspj8eQUlDflOTnf36SK77/Y04eNw5nzjO0NDUFmmGhm8qQgntfms2S+jRPPPEEupBj1qyZ3HnvH/eooVVY+jb5ea+hhaS5uRnlK2xTon0VFPHSgfT5lmSG695ajC7vWhJ0TCQSDCmL8INRfTGlICLbi2K25D0E8MDmNKvSDnV1dRSf75qaGm760Q+4qF9XRsRM0JrlGYfBF34TVdGFu/94X7t2jx87lll330n9i8/T01OBdIqUKF8RF2AKiXJ90o7HczsaOWTS5Vz1ve/t6SvE7373O66//no+KxKcFqnAUmCHKgnFFY5GkFEK5enQedbKEMupNowwUfoPu1d3vv7+mxh7CITX1NTws+9cxeG16YBBphRKQLe+ffj+rH9S0Xvv7uwDwcIaEU/oP4wYtU/bnrLgnQ99vv9W/FfQeD8s9tWANGYc/jqvllRLQOG1Ym0GL99DKgfDtFjxdg19Bw5mwMEjafvglwZ530H6LpFoFMuOUJQA155HPpNCq0ABVxoGqeZGnvzdTSil2g0EWmtWNaRJ5wukU0mEkBiGyZYN6/jNtVdz6y237JY66ng+KzZuw3XdUjAZAeUVleTSqaDiXvi5ZVnMmTmNB/5wDz179iwNLldeeSVjx44rBe+LbSqEbgDHccKqhQbNzc1s3bZtl/Zorfm/z51LNpPhgXvuoGtVl10C+VprGurq6N61imw6FWamBzkqFZWVmF37Ifax/vqeoN0C22c+hxQCP4xvWYZBKpvnxw/+i7//4S7cxTVs395QIlAE20iWbGpg8v1Ps6+TEAjYULm3X8Jd9V5QhCqdwpACSwrSuQKeH6wIDQF3vDaXV9Y2cMQRR5RWMpMnT+azw/rwf4O6ES8FmTXJgouBYIeruKU2SUsy2W7iAZS0oTatq2VYlwo+3y1KX0siDYkcdDCHf++nmJW7BqWn/+bXOK++DL6PkAambbFVae7Y0cyA/Sw6VWxD3buLuCQduK+UaHVjCYJVTtYvFiPWQQVHDQWlcbUuqr0U/0MJwVl/vYshn/7EXs997213kFuwil52gnH/dzZf/OnVRMvL9rhfEQfCgBxSVqbvO/yofdq2es7M/1kD8t/CwvqPIOv6ZNMZhJCluhNCBg+1Dh9k33dZ8MbzDLj0u60zKkTICAphRoI8hXyeXDaL7/t0reoK2qeyooJMJouvfKQwWDEvoGbv7EcXQjC0exl1KZOtKgi61rzyAsvmz9mj8QCwTQPl5JCGHSgAEwzUvufiuS5mG/0d3/cZfshIMpnMblc0bdtk2zaO42LaNpXhTLC8spJhBx/cblutFG4uzR/uvpNcNkvXqkqglYbcFhVlgaH2QqViKQUFxwk0vfJpjLJ9Y+DsCappK6CD+FV4etf3iUUsesWNMF4REChUGwMrhCCVzZXuzd5q0/uNm/E3rgCtiQw7gsgRJ+NtWIaY8xKG5wAa2zYpuD65QpA7dMG4o9haVteu/4uJem/WLONzo4ZyRv9uSLcAymF1psBjdXladlOKtsjEm/bKy4i/3kXMCLS2PF9hrlnO0ht/yOG//eMu/vfxP/oxybPOov6ll/DSSbqOHc+4iRP5YpuqifuKYhu+cu7niL6zCg8dMgYV0bDYryGCks0CMErxkUACxNXBtyswIrqUtd6wcMleDcj+yM38+7DTmPAxxcfKgPRI2IHarSFBa9xcBjueAATaD2iti9/8Fzs2rGbt/Bn0HRrIlewyq/ZdhBmEBE1TY/iKbVs2Mqh/fyzbJi4E6VSKDSuW8P6sN3dbk9qQgr6VMfpWxoBeTDxyOHD5Pl3LEcOH8s67C9hS30i+UGD9mpV88YKvYdlWO/VdwzDYtnXLLkFgX6mgMJUUpUB1eLE4odAitA6oqXSa8rKyEkvMzaXQviIWi5HL5UqBVcdxsSwz2D/cNxKNIbSisktVwL5paQ4ry+nQDXcA4AXU42zBaZchLIRg2OCDEOVdEVaUskQ8FN1TQeDb9/nX2+9z7be/SWHWM+hsMyKSwBh8JEa/4e3uvbN4Ot7qdwNFYMBbvxhj4GE4qxaFUQtKs+qoZeD5CuUrLMPYhcW18yCotcZv2cHsd+by9/v/TO3mrXut0TLnL39kginxi5KbQuBp0A115FYtJd7GxVLzwvPs+OMU+qrgOdd9+zPk2GPbldz9IFi9YT1KSgx0iYBRAFShgC2D4WXnQGuxR4vkueD6wRGarfnMh2rPfwyCVi2ujzE+VgYkahk0vD+LnkeMRRpmOBDmyGWSzHzsfvqW2Xzz6xeSXr2Q1e/UcPBxJ9N7SPuZt1vI4+RzJMrK2VG/hXRTI6mtGzj9pGOoHjWAxoxD3lOsXrKRx5/5O+U9+vKZS7/LwCFD6d2zKwXP/0AKnVprknmPpqyDrzVltsmxRx3JCaWH+FM0ZQpIgtwDrQMXiud7PP3YIyXjpbUmlXNw2lSLsw2D8piNEII1a9bQp2+/dlnLRerz8uXLGTlyJFr5FPL5QBLf8zEMg0yuQHkiqISYyWaDIHhIm9ZSBqRZPzBMZWXlQZxIiIDMsIdrppAJRpdIYo+MFlFWhWnb6HwepWRJNUBIOK769CChcdTJ6EVvUQFks1m00ry+ZD3f+sY3GepsJdmSo+C62FaGWGYGMa0wBxyKzmfxm+sC44HACfMhlO9jN88AzyedzVEZtTFEqxGxTYOC0kxbV79XlWAhBGaXbow//UzGn37mXp4GmPPY3xhruVTGInhKkXc8vNDNqpSPu6M1IF3zxhuIe++gf9EYao3YvJH3Lr2Q4x5/Fvkhku8GDhnConwtR7U4YalaAb4PUjKvMsKhjVmMnb3kopgoL4IIO+AJjWtIHl08n89+4Nb8Z7EfeSD/s/hYGRCAz405gtv+9HtGjDuTaHkFW5e9x7KpL/Crm37RbqY3efJkXrrnRg4++VOceNbnUErhuw4CXSoaJA0bx/Uo5POlz3uUBTO6AWNPRFk/I2Um0FqTLXis256iPu1w/EFVRHZOS98LGtIFmrJuySXQlHNIFTwGd0uU8iIqYxauF0F0qUJrTSad5l9PPs6lF3+tdG3LV60hmiinUChgmAaJRAIsm2zBJRG1aWpqpk/fjpNat22rY+TIkSx47z16du2CDDPstdLkXY+IqzBNg2hYh1yFYncAOgi2INBYto1TyCPMKCIS7/BcupAls2FZmE8TGKltBcnhx4/tcHtR3p1IVU+6APl8PqgPLwyydhnHnzgx2CZWjnXc2VjJBuKeg6zsyVc/E6fu1b+TzWaC7HZpBPTedAp/ySxi22pRjZuCQVFQytYXIVVVEtCdY7aFNANHTbHUMVqzsTnLEwvXctOvf7tf93tPmPPo37Bef5qobaIJVpGJqEWm4OL4ASMp0n9Qaft37r6TCSFVuC3BQXouc+64hTE/uvYDt2XSpEn84OqrMbTNqJSDVgofcE8dwxvL3mNzrIIzNiZL7mAHTUFopIS8CpSHNdASt1k+og9rNm34wG35T0KITgMCH0MDMqG6GkGQXFcMKO9sPNqKyb3y8J84euKZCNGaO2HZNtFIBLNrdxJdqlDDRzFr/WqoqWFCeJyp06bRFOmJ8HyKsYFk0gFRycbmHMO678o+2h08pWjKujiuE876PQzTpCxRRnPOolsiMFqLV61D2BGUUhjSIBqLc8Gll9GnSzBI19TU0PugIbiehzQCJk6yJUlll8pAZdX3MSMduzS01ixbvpxTTpnInb+7i9/edANFkT4hBQYGBV9RWdkFnAyZTJZYLFrcGQhiEtrzMU2DPz38BD/42S86jDdopchuXE4hl8P3VZg0B71tnzkzpnHiuJN32UcIgRxyLPaOTdg7tgbGqlt/qqr6oJ0c/vr30S0NQVusCJR3Q0QSYMfwkjsQqNIKRwgZGKBCBrV1NRqCdogg58A0zVLtFk9rErFIQKIgGKANaVJwHO6b+i5L6MJNv/7tHn32zqa1pN9+A6+pAbvvIMpOPA2za8/dbp95/Vm6hnEEWwcxBQ3EbQs/V8AcMpzogEGl7SvTSYha7fInir+vnzWDMbs9095RXV3NLbffHsRz1qxlRL/+jD7qaOrems7RTTneddJ08wWjzBimkEQRxLTGl5rnnGZSI4fSvVtXPNPAbWziZFHG7OtuJdK9Kxtr5tC0qpauhwzluMnfos/xR32Ilh54dIZAPoYGBPYtCNe2HvryGa8yqvqTSMMM/NvRGK5TwHdatYd6DRzKM689UzIgjz71T077yjdLnBQhBApFLpdjRzYG7LsBKbgKxymUZr7SMFC+TyabYUMuTbeDD2LGrNmU9eyPDutGu55LoaUAlZWk8xYVMZt77rmH39w5Bc8NZN6FFFhWBCkNtFY0NrbQrVv3dqwsoJQUN2vmDC7/zrdZumwZTzzzT774f5/DsIxSvsimTZvp0qVLkKwZj4UEGxHUmyAo4uUWCjRs2cHc95fvPlidT5HPZoNVnixmSGgM02D5e7M7NCDB9UiM7gdB91ZpG60ULfNfQxeCEriJqI3wXShkyNWto2bRKqz0dkYfMjRMItTkCw42PlLoMFcnCPwXWxuNRkinsxhCIPHJuR5x22rDqNZgGCylikcff3yP9za3chEtz/8N7fsgDXJNjeRXvU+3r16F1b13h/t0wcdHIiRklMJGY4dG9q36Ft7P1/KNUOkYwCkrA6/Q4bHWhaoAHxR+Nsdxg4bw6EN/xYjHeO3nN9P0l8foBRwpLD5hVPFmpUMqp+mjKU0mtIBzolXctnwF7sgRDHAFE9Y1UxaL897vH8LJOyjAtwxS9Q1sm7eIsx66k/7jDkhe8YeGkAIj8rEcPtuhswf2gmJthK2rljL8uPHEq7rRc8AQCEt8FiENk0TP/qX3K5ct4QzTRPttqrOJYKoYs/bPfWUaglw+H9KFw1mylEghmffOLI4++CBef/MtvnDhJUSikVJgspDPUyg4FEJpirVr17J65QoOHj4C1w2SAWOhArDruAGN1/XY0ZIkHrGJhKuRxsZGJl/9Pa644gogKDj05DPPsnHzFj5xygTKy8qYOXsOm7Zs4TfX/zQwPFqjAlmrEuvNdRwc1+WXd96z2zKxAFr5KK12MTCmlLiF/cs2fn/mG/TMJRFS0CURXKsKc3dyuRzHDO5DriVKNBotGcyyRBw8BxUaHQiNaZGYIA0sGVCAm1oy2IZge9olZlkYRhD3cX1F1M2UJOs7vE6tSL3xTECZzuXwwtVZWTRKesaLVH324g73S2JQiY8iyHR2lMIIxSUn9u/BBO3z+M0/B4KV9eHfvhLvrt9i7tSfCljadd8UjHdpu1K8+aOfkn7pNXxfYRgGiZPH0vLSVBCgilRprZmoLLLSJ+v7gWJaOAmKasnZooqHlq/gC7H+lMXj5D0XP18IcqsIXIZpFQg1zrz+Nvp/opqljz2L8hUjzjmDEydfRrRy36X8DyQ6XVj/HZno/9UourNEPsWrf72HTe/OCCSbOsh3sNs8UN0qK9iwcmlJYwqKGkuag7p07PffHSKmwdqVK7DaBDsNw0Apn389ESTxV3TtTiQabSe8GI3FSmq4EAz8f/nTfeQLeQzTxLZtCAPdTiEXUCwNA8f1WLRkGWNOOpHjjxvNRRdewBVXXFEaCIulXN9+Zy53Tvk9P/rpdTzy+JNcdukluJ5HczJDcbwtJsht2LCRe/70ED+/5S6++e09y6OLSCKUkm8ffXVcj40NTfvVd3OmTQ1qo5Tugw687lqRiNokLEGX8gRN6WxJhVdrDaYdRptC95hozRB3PBekgYOga3mCyniQVGqZBlHLJGZbVMai/HDiSH57/U93WzJY57IUWnbQkgoqKxpG4DpLZjK0rF6622uKTfxUoDmpA+HEWBgHyRf11ITgS/2reP4PdwNQfcYZLD1hPE1OkOAqgKSvuL0xxaVXttZDn/7gAzz6ydN59pSTeeCsM5n21JMdt1tr3vzBNWReeCWIcxkSpXwyr05Fel676oYIgaHBVMGqzLBtTMsK2HxSMjxezugBg+haXomHJpvJYgCmEJgicNHZvsJLZ9k2dyFz77yflq311K3fSM0df+SmkeN4Kyzd+x/Fgc1E//8WnQZkN1BalzSx2tZkvvf231CRiIeCjMVs2kDhd9zhw0v7T5o0icfvvYU1SxYE0ukEg3S5m6Qytv+Jcy8+/jeWLVqAYRhIKUmnUjxw961ErECW/cRxJwcKvu2e1yBgXR6xSm1asXwZP/relbzywgu8v2ghhXyOdLK5XR1ry7JIpVpYtGgRS5cuZerUqR3GiIr14Hv27Mltt93GwQcPDyRWlB/QSYUEKdFCUlHVjbPP/T8eePAve3UfCitCk2cEulKmiWUGsvBzFizm1LM+s1/9Nm/xcjxVVIFqTQolTBexpMA0DFzPpzGZoa6pheZ0sPJwQ9ejCAkAhHGweDSKFYng+oqMpxBCUh6xSuw6AXha0SUe4UenH92+pnvb67QjZHJ5DCnCyUXw05SSTY3Nu72mE7/6dbzqT5HFwAoT9HJK47URRDGl4DC31T11yc+vJ/Lj65gVibFDQiRuM3nCGE4cEbAMp99zN4W/P0Qv16HMMBjs5Mnde/cuRiSzZi3zvnIRvDGVhG1QbhtBadfQaFi0KkoXoYUO3IshBbwIqaHZEPTp3x+0Jp1KExOhPhjFexRKpBQ1tzJZcplMoLNlSKx0ntu/c/VujfS/DQKEIffp9b+MThfWTnizZhovL95AlyEjMU2brhE4d/RwusWD2b8UgjNHDeDlxRtI5zReGHPoZ+Y5bexJpeOcMGYcP731Ht5fvY5Xnn2ShTPfIqpdrrvu5x+oXZdc/HUmT55Mj5696Nq9O5s3rCedTgfS4ARZ6M1NTZRXVAQrC4Ikwnw+h2kEiXptyQF/vu/3DB48mC+ffyHHjD4OPyxBK6XE9zyWLV7CJ08/HcOQHVZe6yiOFKi1ekSjUaxQ5iWgtAaZ+glb7jVRr4jBR57AgrdnUr9uOU4hz5K1mzjplDP2O4Gs2ZNsqGtkSN82Qekg8zKU3ZDtKjAKIUEGSXm+r8GUJeabDo2OkK2Kwy2pNDnfI27IkpKzpzRZ10cDQ7uV07yt4wx3YVq8tq6O0wf1JBQqLsWNHluyjnF7uK4TLrgULriU/PrVLL7xh/hat5s8+ErTZydRxCEr36c8apDDwPN8/JVLWfLjqxh1271kn/0nphD4YYKlLwQ2ijV/vp8huTwNr72O8jyym7bhuW5r/wFxQ5D2NMqSGEXpeBm6IJUK1IhPGUN+znukM+mgPggChWZ2XPC9H02m/qd3YtbXY4a1PgVBrdbgdgm0CMoFaA0xAdminL9S9FBGh7V8/p0I8m7+Y6f7r8X/tnncT0ytqeHFFQ10HXY4Qgs8p0BD1ueRebVknda66BVRi/OOHcJnjx3GZ48bwUXjDuWTY1uVCjKOx1trtpOLVtFn8HDGnvVZvv2L2+nef+Au6qr7iuLgX5aIs2LpEnr06FESIxRC0FC3jUgkQiqZpHH7dpp27CCXy7F544ZdjlNcTT3xxBP06NqFd+bMLsmDO47L1q1b+fql32BHS4qNW+q4+57fdygtvjOENHj4yWeItM0rEIJUKkWhUKBbVRfQHcuK73IsITj6xHGc8aWL+fRF3+HHN/zyAw0Ql0+axNX3PsJzsxfg+36gOlB09UiJMEykFEQsMwyWS0xpsMOFeas3QuiNd321y8waNJXlCRwhcJUmlSuwI5MjExoPCM41aNDA3bZvZs5ixtbmkgK7RvPUmnq2Rbrs0/XZfQ8inkgglGofr0HT7dgTS9s5jdtpmP4WyXQGzw+SaR1fk2luZv4fpmD4XrBibAMlBEMKeTY//AiZrVtpWluLm0zh5XL4JQcfAWeAIJE0VR6hvKwMU0gIadFVF3+Zsx+6h5GXXUh5ZSWmkKSF5t0R/bj8sssY3JhmzHXfQ7UZkdVOXR0QwsMYVJu/KSnQFYkOa/n8WyEEhm3u0+t/Gf/bV7efePDRpxjxma8F2dFhnEP7Hpl8nmX1aY7t36W0bbFGSEdYVpfC9RXZTODbllogTZOJX/g6dbf89APPlvbEHotJH1/5xOJxlO8jDYnruHTZC1Nk/Pjx1NTUcMPPrqWluYWvX/oNThwzFq0UyWQSKSWf/uy5NNTX7bYyX1sce/yJLFm+gqGDB+H7AXss8O+bGHup16GcPCqXBOUj7DgyXs6+VBjcE6qrq7nx5l8xZcoUesQsjj/sYMri0TDhLgjOCiuCbbu4no9tmfjxKgaOO5uGRA2pxmXk8nmqEtGSSGC7iacQxCJRVmzZzkHlFr7rI2VYsEkItjRnOP+Sy3bbvm9fHpA0nqgsp2+XCjbsaKE51bqy1ErhJ3cg7ChGvGOtp96f/iLbnn0EJ5fD8z2kYRLpUsWIi75V2qawZROZkIhRlOAQUiAVbHx3Lt2NkE3Xpr9NrTEQuGFcxlSBQKREkNOKqGjtC0NrXA29fziJk846i4a3ZqDR9KgeQ6xPwCYb9cNJjPzeZXi5PE5TC9PP/w4td/+FqWFSphs3ERkXEPhCY+ni8QXKkEg/MCMKgmRIrfFNg/UxGNxnz4maBxpC8D8f39gXdBqQNmjJu+z8SAghUBoas84+H6ch4yDDpLNi/Q3leVT26E1Vt+7/ltnSSceNZtbb77C2sZmqbt1prK+jf4+ujDnxhD3up7XmhJPGcuwJYzClIFsoAILm5iaKxaaEgLPPOZeaqW/t1fhVV1fz+ssv4DhBtUYhRCCeaFvB4Cs7zsL3sy2o1A6Kjhzt5NH5FEbXvgfEiFRXV3Pd1Zcz5shDEYh2hcNyno9nRfnDGzPZ3JLnwb8/DMDoiWfgzMoiNq+D4gxYt/4gNCZrtye5e9Zqrjx+IP0q40Qsg4Lr4QL66NOonjABv2U7qnErIlGB7NEPnWwGKdu5FReFeUk/u/4Gqqurya9ZSvNLj6JzWdAKe/AIqs4+HxlLoH2PppefIjV3GgCxLuUk+g9AGBbxkUdSdfIZGGWt7CS7V+9QRDHoS1Nr7PDe+skWUoNGkFi7BgiMiAgD9EKapLPZYDJlSHRYjUQKQVr7RIXEAJYVchxzw0+Z+NWvADDgS+d2eC+kZWFbFjMunERq05ag8FSYlNlHadKGJK8USoOHxgqdJEoKtJBIT5FXPihIVcR4v18ZyXyO6/bA6vt3oZOF1WlA2qHCKi6T28t4SKBn2b5rBplSUPA08YpKIKiu5zlOSQdq1HFj+dV9f2PLxg0kt6zj4gvPPyD+2zEn7B9H3leKxnRA9XUcB8d1qCivwEDhe36JMqyUoqwssduyvzvj1DPOYuu61cRCuXEN2HaEih59O9xeK4VKB+wqx/XIZDJ4nkfEtqnfsJVDjz5uv65rdzjlnC8wd9lMTm5Ddsg7LnnXxzJNqiorefntRaW/CSGwR5/JqoW3cEjPCiwjMDy5gofvK2KWgeP7NDS3EM3u4JK/LOXh23/Job26IBIVWAMPY/2ct3n+his4okccIQziERtch0zewfMVjQUfe/QZuwhdug1bqXvsj+RzWRzPwzBMylYuRj/1J7p95QrqHrqL7LIFQT0XX6GQxHyfvl/9NvHDjgEgs/x9drz8DO72OqIDh1Jn2vT2XSwRlK4NLhIOKouTqt9AesgwKtbX4vs+yjCJHDsaa8ky/OyOkDUFvgRTFc2pwDcNaqVgzsEjmRwaj70hu2UbyeWryTqFdiUDhACVsMEX9C4L1BKSyRRKSKTWeALe7xHh+MsuYPas2azZtIHBB/Xlx/uhInzAIMT/fIB8X9BpQNrgkq9+kacWvE+fEUcES2WlEKZJeSzCoT33TSoaIJVKocxIibZrWoFq7tJZUzn9gu8wcMRILDvCsGNOQnk+9/zhFoAD8iVwfEWmEJTJTUTMXXS3lNYsXLKMVM6hR48eRKNR0qlUIAUefpFdv5XOGtCATZYsXtxhZb6OIISgz6BhaN8LRCqlRJj2boPnOkxyc1w3rEMiSyu3jWtXUZ/MHpC+qa6uZrF0SBe2UygUUBpM0ygJRK7ZtG2X6xOROP5hE/jiz37CV8cdwVlHDsHzFeXRoPiW73ocPaQ/Rw3ux5tLammJdydyTNDWmpoa3nzgd1x60iEoHUwktA5m8BEpcDxNr5hJ07yXqLFiVE+YWDrvimcfwcykUYCUAWW7JZ1Gb1iD/48pZJe+V5rcRA2JH0rXrH/2EQ497BiS82ex8YG7KeRyuL6PtWUzw7rFmbehgWNigevV05qsrxCWSZkULGzezvefexEvlcKqqgKtWfC1r2M3NeOGuTNETNIFl9pcDikN1iQizHYK/DbMEeoINTU1TLn7bmrXrWPw4MF867wvghRBNU2j/fMpTZPHekpe+sufAVi8fSv3TrmHzWvW0nfoECZdGdDJv/vhHoUDgn2pNvi/js4eaIPq6mrOPWogdQtnUshmkELQNwYXnjBsnwUQX58+m+ZsnkKYpV7Mg/B9n3jXHhx67InEyyqCQUsFBazOueQq7rn33r0eO+/6rG5Is2BTC4u2tLC5OdfOFdOcc1jfmGFrU5p1dTtYuGYTd933QCn4rbVm1catWIlKuvboQUVFBZZlkSgrKy26crkc0jSxbDuoZ2GYpDNpHvnH30qKwsUa5X6HgeUAQojW6oR7cUEVDW0mE0jtF7PPpZSks9nd0mA/CA4bM5HK7j2p6lIV1GyRMlDL3badd5au6jDBsbq6mp/f+EteWrWdr0z5J6+t3Ere9UjmHRTBNQrD5BNHHszTf3ugtN+UKVM4e9SgUBpFE5OB60cIgW0alNsmrtKURyzefOTB0n5aa3K1yyiP21TEbSrjFpGwYFkumyWz4v2A4UaJkRxkxQvI1G1BK8WGv99PJp3GUQrCZEOvUOCQwQNo8nyaPJ+00ohQOdkQgi7pJEY0SqRHD6RpIi2LkbfdSmTYMIzQWDVYFnf7LtfXbWaKn2dz/7785oYbONT12D5tOv5OZWXf+N09rPnGd/nqgjV8LyPoVruJH/3mV/ixKFZbWm9IcVuZMBk0ZAjdDz+E7ocfwoSJE3ngd3fz15/fxB2Xf5fxY8aU+qhpVS3b3n0fL99xlv2/EyKUtdmX1/8yOlcgO2FidTUTP8Rs98U3axh16mco5PM4hQLSMPBcl0i8jEGHHl6ahZt2BMO0yGfTmLZNXu15kHV9xaqGNHnHJZNOo7WiJWmxcYvHiSMH4/mKhlQBx3FIJltKkicnTTiNm68JSpQef9JYPKXx21TkA7Btm1wuC4DvezQ3NfP2jBpOPfVU3nj9NR7++9+o6tKF2267jTFjx5LJ51u9fEIQi9jtJOG11niFHMrzKAYNhBBYsXjHMRDTBmkhhUTLIkMqmKFOnT2vndtMaxUIGxrGB4qNCMPEPHQsYuMyKsQGUuk0z818jzeWbtgjQaAtgcFdPofmRTN2WVEJAZW0Dma1tbXExg4ErZEoIobRLtHTNCQJoOArCi2tCZK5xe/QPRJQi4tnSMRsEA7a12QLBSId0KEtIdiYzrH8+iuxvQwibpPOOSgVsMt8rTEyLcQiNp5S7WbQSiucsl0zuqO9ezP+wQeoefll7r//fpavX8/gg4fxz9/dSXV1NZufeoZVt9zB3FwuqIFjmJR96xtM+PpFNEydQfLeB+iiwJeCuO9zRlIhK2xe7RbhtHQ56ZaWgNIrBY2WwVxb8es2ytHzf303S//8CK7nkc3lyCuflUcM5Li0gV/fGAhYSkn1r65hxOfO2uv9P2AQAhn58IXQ/n/Hx9qAKK15dep0Hrjvj6xdtWKv9Rf2BbUrVzDq1OD3oMiTh9I6LPcaaCuJMEVbSIFpWniuS+9egaREsdLbunXrGDRoUKk92zMOBccl2dKMEMHg4jouvpRMmzmbI485FtBksplSUFLrIJHw+HHVTJkyhfuPOxEpDYQIGPaO62FZQZzCDAstScNk+muv8sYrL3LxRRdw8UUXcvFFFwIwe/Zs6hq2l1R244lEYHwKDoloUJmxpqaG+XPf4Stf+gJoSCQS2BE7kDLJ57BiiQ4GXoFZ1Yv6VavoVhXEjbSCh55+joVLljF48GBqamrYtGIRp550DJZpEo3FiHbrhyzr2qrdFdbp2F2gvnQ+K4o55GjMIUeTAL522lf52v7c5Eg8yGffaRD3lSZaXll6P3jwYGbW1nP2of2JWQYaCVqVomyaQA6l4CsykdbBO/P26yX1gLZIRG1eXFzLsT2r8LWizDTb5eprNP0iJoXtdcSlwDINqspj7EgG9e1tKdmUd+h30CD0urVh5r3E0ApXa4688NLdXnL1mWdSfWZ7mfn06tWsuvsekpl0mOsjEb5P8z2/Z+qAfkT+8FeUp9CmLLGnpNaMz7jcprfxu+mv8OatdzHv9bdYmk+hDh3Gr69sVTzYPHUWSx94FMfzSaXTCCGIasGR765ju6/ACAguppS8cuXP6HrwYHocfuh+3MgPA9HpwuJjbECWbkvy6Ny17EiZ9PrMJMrWL6H2tcf2iaq6J5huhkxLExXdeuC7LkopYmUVIARKafKAKTSmCFw30rJINzbwlfPOZWrNNF59eyFf+eFNWHaEjWtW8Ns77gJgwGGjQz2s1liFEALP87jztjsYdfjhfP78i3FdNyzWFEBrjW2a1NbWYkjRWolRCDLZDBXl5UgRKMy6rmbThvX8468PctONN7a7rpqaGua/9x4HDR6C1oEhTCaTVISJi75SzJwxg8mTJ3PX7bdiGgb5QoFUKkncj2OYJob0MSMxhGGU9LIIXTrCsGhwJNf95Bf07N6drQ2NNO7YQSaTYdy4ccyreY2LPn82WoPreXjpNJIt2NJA2lEaVy3CxkMK2FTXSLNZyYnjTmbW9Bqmvfoia2rXkXQ13/nOnmVU9uke9x1GJDYDlUkHM3khMKUglXMZd86XSttNmjSJn1/zI0b378bAyliQeNYmIV6GcaYFm3fw+YsDqq/KpfF21GPsJl40Z2Mdh/fqTlwIkq5H3DAwZFCjZEc6R9y2UARS6dHQCJXHIyTTOZQQzBNxzv7FLcz/9Q3I5YtRStEsTSo+fz7jPr1/Wf71r75OPpMNjEe4GtRSYGjF83fcyVkNuSARU+kSdVgBMddn6KChRHt256zf/oLdrRtWPvwMynXJ5XIUy0YrL6g3r5SPpzSWZaHQZFIpXv7V77jg4T/s1zV8YAgQxv7X9flfw0dqQIQQ64AUQdKpp7UeLYToCjwGDALWAV/QWu+fANJesKk5x6PvbaYlWwhnhJKywYcz9KwIq57704fKap10+eX8/MYb+OTXr6DXoGHYkWhpxRFmsZUkJyyt8R2HwXHFhHHV3Pv485x42qcCF5DrMmDoCC75yc08+Mfb+NUdJ7SrNAhBkN80TS769pUMGDgIKxZH2jaFXKbka1e+4p1ZMxg8eDBx2yqJBnqeh1KCdCZDPpfj9RefZ+XyZSSbd3DTjTfucv1Tpkzh7M+cg2EY+J4XqgtDNpPBtm201lx33XUcdeSRHHzwwcRiUWzbxrLaL/ObGxsoLyujkE2Ty+VIppI89ewLnDBmbOmcU6ZMYcPGjaUV4ZQpU7jz2kCzSWuNFBKlFbl8Diu1nUyymYSpMY0gODx0QB88z+evt9/IWeNHM+zTE5BCksxk+f6tv2HBggUsXfge9XVbseIVXL6Pq07VXMf2+W9i5JIkcw62NBHaA63ZkXVJDhzNyW0C4dXV1fziV7/htnvv4byBMcYO6YNlSFAaEWbKCUMy8vgTObi6GpXP0Pz4lFLFwyI0rcmP/bqUw8lns+nlJ+gbj+BojVCwKZ1laJcKWjJZpJQ4SoOniJpBjCfv+Txfl+Yz196IkSjj+Btvwc/n0a6DUVa+T+oAu/RHwUHvJCoKATtre10d8UEjcVbmSWazBCkmAqE0KQHfvmLvtFs3mwMR1N4xhcBy/EDSBIgIgRc+x6ZpIYVg2Tvz9/saPihEJwsL+O9YgUzUWm9v8/7HwBta618LIX4cvv/RgTzh9LWN+ErjuQ5G0d3h+8T7HUxljz7U1q7+wMeurq7mFwSD4Nvz3uPnD/0TrbPEE+WBJpZWoAWeCHSDPnXEQGL2UHKuH5bQ1djRWCDCqAMNoW4Dh9M9YbPM87DsCL7nBisRQxCLRujTfwCe55HPZYnE4sQSFbiFLEJrnn/yEdauWsFtt92GIQX9u1Wyvs4DgkS6uq1bsbXDD6++ao/XVVtby8rlyzn1tNNKnwkh8EMNrbnvvMMpEydy8SWXBAFYKcNrIKxBHpzPkuDls4E0PVBRXs7XvvJFrrn+F6X+23kw/9GPfkgiHsMJxQABpJA4rgO+g/YczIgdTOwD7RQMKfjyWRPYvqM5YHQJTbcu5fz2exezadNmzv/G59BAMpPjl3+8u3Tu3UElt5OZ9woim6HgKxKh6vG/3lnM4ad8muPGngxS4m+rRTs5ZFVvZHnX0vWofIYdj94GXgEtg8EUIdCGRS+3CZVJklsyl0LLDjK+It5mPC8m0zm+z1ePGUHFuvn0GTKAFdt20MdQmIZkRN9eSNeha3mC5nTRiCg812N9S4bvzljKX//+93bXaESjEI2W3hfdp8U6OXtz53YbP5aVjzwWJMsWkxNDzSr/oAEMvfIyFl19LRVAppAHTyENSd+vf5kJEybs9rhFDDnnDOrefhdLCGxPUVy6acBAEgdy6FJ9nNX8Z4PpOxvOjyP+G3vgHOCh8PeH4MBXuNyRdUr0VNVWWkMpHGG2o3K25Fy2tORxvH2T4IBWuZAB/fthmRaGlOSzmUBDqDQcwIThvYiFUgc510cKQTReVjIeAJYd4biJpzNrxnTMTAMrlyxEmia+8nj/3XfI53KosDyt67pkUklyuSyL58/lp1d9iyXvvtPOJWebBsP69mDEgN4cOqgvE088lrEnnbTLNeyMwYMHM2vWTFauWIE0DCzLCl5moHR7//33c/Ell+B7HulMDq8oYy+KLKugjKwVZjwHmlJBoNw0Db76xS/slm01YMBBbK1rwGzDhFNaEbWjIIwgjgPh+BIyuLQfJjEaeKX+8RjQuwdHjBhaqvNRVR7nl5efzyN/fZA9wa9dhJPPlSjORaHNs48bib1qNo0v3Efu1T+Tm/cS7uLpFGY+hbPwzVbZlGiCbKwLjq/wNbgKUo5HcybI81DN9bgbV5LP5/GFKK1Si5flKh9LSuKmxEsn0bkMw6OSmG3jamhJZ8j7qp0siyUlwjB4viG3i/HYGdNeeZm5v/w531FJbh3UgxOzTVz7/e/vUb6my7HHED/uWAQaQymM0C35Ah6XXnUVPU4ew+G3/IKKwQOpjCfoNeJgTrz9Zk695vt77Osihp77SXqOPhLbb+P3E6BUQCk2hUTqwGilbQNx+LB9Ou6BgpBin17/y/ioVyAaeFUIoYE/aq3vA3pprbcCaK23CiE6LM0mhPgm8E2Agw46qKNNdovB3eJsTRaIJxIkky0oVFhUSdO0eR3X/Opmcq7PPxdvZUNTDkMG43n10O4cf1BV6Tg1NTX8/v4/sWnzFvp077rLjK1v754kdzRQ3rUHyvdwCzmcfBYrEmVE325URlvdO3HLIJ4oCzSAdqLGlnep4i933cuD9/8RXVPD3T+/mtraWiacdQ7HnTQ2NEwBlArKv37m7E/x9S92nA0cGM/9e7CLdVFu+sUNnH7GmZx62mlooCwep0+vnsFwV1RMBZqSabp364pA4WtNOpUMIuNCIC2LLt26B0WxMmlcz6Nfn967TVKcNGkSd//lAW64+tvYlonjedimhR2JIBNVkGlpMzctXlfwe5fyIH/H9X08zy+VIy5u5fkKyzQZ2a/bLufVTo7Fc6bz1D+f46vHDSFmmUFOSzForzUV8Sh0rSRmmyUt3EIhT7bgUOYuQ3bvj9kvSFycsWg5J/evxC/dX4kQinw2G2Sol3VBh+yogtZ4Gqyi5lRIB2/dM/hIar+keJD3FUILolEbpRQ78i5T8wYX/ixwSWqlSM6bSXL6a/j5PGVHH0/VhE8i7QiZP93NmPJYSY9qTNxiUL8qpky5e7eGRwhB9ZTfUfPAg7z3j0doSLawvV9fvnr190r79Jw4np4Tx3f8UBX72ffZPuNtkstWEevbi16nVWPEY0jL4vS/T+GBnqMoTt8EYBsCqTSOhqzyma1S5PsN4jff3fMq+kBCSIG0O1lYH7UBGau13hIaideEEMv3dcfQ2NwHMHr06I6TEXZ30kHdeHdTCzltUlZeGcz6fI/sijn89lc3U11dzaPvbWJ1fZJcJo3v+ximyavLHLrFbYZ2T/B6zXReXrqVYy78PscKQbqxnpvvCGbQbetm3P6H+zjnOz/CMK1Aa0hrYpbJYb3aUyajlkHENsk5fvECKUZdPadANvy8rYtn5tx3cV0X5fsopQL3GIJYLL7fRav2hqLkxuNPPMHZ55xLWXkZiXgC0zJJ5x0SZWWl4L0ftsf1fCzLwvOCVZJt20FeSGhohJSUl1eQy2WY/97C3SYpFq/3zoce55QTjmLYoIOw4+VU9R0GVgSvbgMRCOquU9QSkEjhl2aAEWlhhSsY5fulRMXi9gcPHlh6r7XG37ycwoZldM+l+NYZxxPFwy0UyOYLpfyRqBnMLDylwoB4sL9lmVAokM1kyCycSZ/QgDw8633GnjcOUwq8cAVjGwbL65ro36UnsSPHohfMRigfhMQXAiFgTXOWQ+MWbdfAOrSAMnQNGkYgf+9rWJDy+fydf0VYNtVtYhsNTz5Eck4NWilc32PH06t55x8PMtuxOc1z8NtolXlAL9MgsnXzHp8LIQQTLrmYCZd0XPxqb/AyWeZeNInUyrWoQh4ZibD8N3dzwsN/IDFwANI0USLQ32o7sTKlwAT+ld/O+ojg+Ttu/w9no3fGQOAjNiBa6y3hz3ohxDPA8UCdEKJPuProA9Qf6PNWxiwuHzuYN1Y1sHp7hrKuZYwf2o2mvi73/vkv3HzvXzjmi98JYiSGCULieS6ZbI4X31vFpNOOZM52Rc9hI8EPlFfLu/XilG/+iD8+cE/pQS7+fOgf99Jt2OH0GzyMYf16curhw4lZuzI4+lbEWLmtCcMI6l/4voeTz4MQ5FLNnHfeee380yeffDLTFq5AWhGElMQTZRiGQTqd4sKvfY0rLvvGAf1SVVdXc/RxJ5AvOKTTKZqbmzFMg7KyMr71nUksXLiQo48+Gs8LMuFzuRxSSvK5LJ7nU1ERxXEcLMtsLTYlBHYkxm9vv5Pf3X33Hs+9u2uJDzmSzJoFRMIuLbguEcvCc9ygIiLB3F0KQT6XBa0DN4gUaKVxtcdBhxxeOp5ONqC2rqaQzxO1rUBqXUviIijL6/g+UcPAMCT5fB7DkO1LX2mNEZYJ3rxxA33Cj2Pde/Ortxbz7ZNG0C1uAYJ5mxp5ak0zpwJW74NoGX4CkSUzsIyA2bV0e5onF6/j+pOGB4NoaA+ElOiw/SU3GeAjeHr5er5gR9CeR37jmuBviUqSc6aipYHr+yRTaYSU9IzaDMvnsAQ4qr1hlcrn1F7dWPOLa/HzebqcNI5unzgTIxrbp+elUF/Pxocfo3n+u0R69mTAV75El2OPxk2laHhzGl4qTcuSVSSXrkTYFr5hkGxJQuMO/v7J8zjk97+hurqaFQmDQ9P+zipDeGiMQ4dy5vDhH4GUCZ0GhI/QgAghEoDUWqfC308HfgE8B1wE/Dr8+ey/4/xVcZvPH9mv9P7NqTX8aeoSen7ym/QCrFgCK5agFLhTGq+QZ2tzhjfXbMdIVKDbuEKU72FYNrL7gHbn2Zf660X0r4xSWy/I5rL4noc0Aon1hbOns3zxIk6sPpWvfOdzeJ7HvQ8EYaI/3ncfx447lVM/fW4QlNWasvIKrv3t3Tx0z52lNuwMpTUFzyfveBS8wHdeEbWJWrtKn+QcDz+cZecKBZLNYaKilChfkcvm6N23L7379sV1HKxIUNXBMC02bd5C045GunfvjiAozZvNKhKJBFLKUFJEU3DdDzwISNOibPhoKGRYs/R91ixfwrGHDMF1XaK2RcQ20TqgkG5uaKJ7eRzTCGpimLaBtmKMPLL13P62teA5xCNWqU+V0uRzPs25At3LY6RyBeav2MQxg/sGOSEqqJteNIq+UhhC8Py8ZYwOxXiLbsAr65P069aFHS0ptrckS8q7AMec+1Vqqvry5AP3sXztOrr06c+V3/8J7syniIYPW8lRF7FobEwGsQ4CKuPDaxvwu/Umt3opDY/eh5PLkslkUb6HcDzsaCzI+A9dcYaArjEbL5sPpEVEUNRKa4VUcKQtSK9YhhCCbRvX0zx7BsNu+DXS2rP7Jl9Xx3sXX4aXzoCUZNdvpOW9BfT53LlsfPQZtOehPI98fQvCNNEEtPBiDlPXZJaffO9qfnnH7Ww4YSS9ZiyhayEMpAvw0fyBJJZVscfyyP8+CGSnAflIVyC9gGdCf7IJPKy1flkIMRd4XAhxCbABOO8/0ZiHZy6j2yHHIJQKXQVtYwQaaUgSFeX4js38jc0oM45SLqZqo+ArBP2GHPyB2xAxDU4a2os5y9eTFSa5TIZV773NW08/zAWTvs/ok08raQeNOn4sDclmzr/65/Tq0aMNA6kV53/rCn7z/W/vMjC35BwaM0WplYDFUijk2aY1hZYdHHdUMBv3lGJHOh9U53M9crks8XgCpXWprK9pmlRUlKPDZMlSDoryyWWzDOjfn4EHDQjYWr5DeXk5uVyOpuZmLMvCMAx2NDUxatSoD9RnWmtwcmjlIawow445iaGHjkLXraKhYTueBr8Q1HIxDEnNgpXUrlvHzT+YFMjGV/REdO3XLilMZ5pa0zXCPjUMSSweY1VDit9PXcJd9z/A1qlvkNk0j4pYhHS+QHksihBBsF4AK7buYEWy1fHUVnl3ZbiSvObn1+1yf6onTGyniwWwePMK/DULsUXAMPO1JlVw+eJjrzFk0GCG9u/Lqu0tNKfT3PHLm2j4x70U8nly2UxQ4c8QWPEIdY0BI75Ir9Ya1nlwiDSIA1pKfN8nIiW2BG2atGQygRvXkCRq19Dyzmyqxp68x/uy8R+Pkm9qJuM4eL6HaZjEIzZr7v0zRqIMI2JhmEYQFHccCp5bMh7oQDQ/Hk8wZcqUwPDWTqa3tBjUmGV503ZmF5o57rjjuOGGG/7zqw8C7/IHoT7/r+EjMyBa67XAkR183gic+p9si9Ka6KBRiOJgYUcoeD4RywidzRrLMIIVtOeSy3iY0ThamPjawxA6iD+4LocfcSSPzljI9FdfZP7rzzOgX9/9ym5P2CanHjG09YOxhzPztRcYffJpKOWjlA9CEE+UB3GHPejtGIZB3m2fU5B1PLani9L0OqBgGgaWHSGXzSDj5UybPp2Tx48nFcpguK5DS0sSIQVRrYmXVZBONmGaJmWJoOpdNpulUAjiA5WVlQRUWhm6qnTARCsECraxWIxsJltiwb3wwktc+5Mf4xdyaK0Q0kRauxdfLEJ7Ln7jRlCtxb5ErBJR0QPMCLFohLzjIITEMk0KrstL09/GisYxBh/T4TFV01bwgklBoFfWWunPkJITDh3MKccfgWqpZ+yEU5n9lmb5e28xrFuCjQ1NbGxMkVHw3tqtzFxWy29vvbXd8fdnRdoWh13wHRY+9iAt788iiua9zQ28Ul/gimt+xowZM5hblIK/4QaOimp2KB9dyJNoq+GmNZWxCE2ZHL7vYxsGPjA3r3m9JceXupdxeFngnor0G0ByzVqSqVTralNp8pk0K195iRP2YEC0Umx6cyrpXDaoPhiKQaZSGaIqoPIWCk6ofaaDOiNKI8K2GkpTXxbBriyntra2neGdo2oZfMwYXvwoFHjbolPKBPjog+j/FfCVxrQjeE4BKSRCSDxfoZTGMiUmwdJZq2DAVUojw8I92rBQXgE7EiESi5NCkc3lGTz+LPofezJv3febD53dfsLJp0CbwdSybBACMxyg94Tu3duzi5qzbsDlKdUJDwZ4M6w7DvDc8y8yftw4Cl5gfAKXh0AKQSrZQkVll0CE0LQwTBPP88hls1iWVVLxRet2SYQaMCyb5lSS8kSMWDxGXV0dlmVx/pe/SHkihptNBdtJAz8PRjSOtKK7NSR+0xbwXRzXDSTgfR/bSrJtTS0jjzyWfFMSUwZ03k312/nXW7P57MSTqJ4wEe3kEHZ7X75q2kph7cIgfqH8IMlUtgZvtQ7k38sAr3YB1pGf4KSJp8HEIDempqaGR9rkUfz21lsP2CAnhOSoL10CX7oEgCMI/LsAV13Vnn3UMvVFtONgtI87By4r0whEDJUiqeHppGJ9U4pMJkPLWWfx+ruzkKkkXbIFDs7niMiAUqwp1sbRzFy8mI6qzGitmX7HHaSefY5IOkccQUGDH1K5BYEKguN5JcMkoibad9G+Qvo+2pDkLIPpB3Vrp/78QQ3vvxOdUiYfcwPSnHP58+vzWbotiYiWYRom0ncxfRdpGPhK4+cLGH4B2w7ou4JABsTL5zAi0cAN4ubp2bsHGdenUHAxLAvtC4zyLhx91nnMeXzfstuV1rTkXQwhKI+0DugTTj6ZlO+HWdjBMj+YIYuSrEhHdcsL+Rxfu+D80vuamhoo60GioiKIDcSibQZHDTpYtaxauaL0ma8gXlZRytsgDI5f99Nr6dWrF6d94hMcccSRgTsi2Kv1epSPEEFOgiBgPzmeTzJbYNPmLQzs2wuJJmJbwWyfcJAKM7FzO7aTTLawdUeK409sn6uiPRe8QiABH/rOA0FHTcu2DUxLF6iurmbGtBoeeODPfPKEI/jG5z+JZZoo5dC8bA51jsUhx7VWHk+tWYSTzRCzLWzTRisf4btBHCS8990qy0ml03S1LHByEImX9m87yBWT8iZPnnxANNb2B9Ghh5R0wXZGDvjlorU0KUGfEYeydmMgsX7W0Ycz/N2pWFIQrYojUWjDxsm6RIBceFuVkLy8uY6rOzj29LvuJvfU05hCUJAQUxAlkFXxhcAwJA4+KhPotcmQSeEnLGq0y9bGHVQMHEBdzyqS2UxJ/fm/EUWx0o87PrYGJJl3+cWLi2hO+2DFgoHLsAP6pOdhmAFLxxAaI3SnuIVcKFNuIowgMLvpnTdZ8OJjXHz3Y/i+QhhhPoBhopVPj4MP36dCTHWpPLPW1JHJZlFKU8imGBLzOXX8GMYccziz1tSRy+VxHKdN7etgkM+7PvEOai+//uJzLJz+BgB2opKyASOIRIuaTBqtRbsCrVYkwqZ1tURtm3TBxVfBdjJw+AYbCUEikeDSb1/BuWd9grlvv83Djz9OxI7gum6Qee77gbEoFIhGIm0KU2lisRhaa44bfSzbt27CdTzKE/FSYFiE51BKYds20YhNRURSU1PTfgAOE0AzpcEoOIdAEI/FuTk02ONOrmbscUdT2LiMlpaWkoCgQNPdUMyaXsOY8eFx3Ty+UuQcF8OQAQNPecWORmmNaUgipoHruliGiWrahr9peZB93rUvst9wFsyYSsOs17j4xIOZ37cLby5a9aFXofsKL90Clo1R0QXd1Ng6QQDynh/koCTK6d33IB4Pi1hprXnrgnOwpAhk4cNjBbkOEu0oogKaNTySdqg8aGCH52565hmiQqBFUII2rxURH2ygIGClIVk3uDdja7dhSoGhNb4Q1JZFWd2jF6t0niOH9GfrPmbCf6ToZGEBH2MDMn1NI8lsAVSg66Q9F18plGlBajsTjxhMz7II29IFyiMmvcojPPnOSrQVQ5pGaaDsceQ4jo/G8H0V1OZo4zMQ0kCaJl2HjqJ7/0G7bUvG8Zi5tp50JlNaZcQrqliTbMaoqWFCdTWH9+/Givo0xWQy1wvqjdu2FQgM+mH8RgQB70wmw7hTz+T9t2fxq9/8lt/e9/eSe0kgdlF7VVojpMn8d97mxtun0JRxQsfFrsFCpRSHHnYY533py6Sam/j1zTdz8SWXMmDgQDLpNAsXLmDUYaPo1q0rvgYjNFixeGCoI5EIyvcxDZNYZazV7dXBKiqfL9ClspI///3R9oOJGeSUlGaypU6HuYuWtpeAzzTjOoXQDSdbNwRmv/VqyYBsqm+kT7cueL4mlSvQJREDGbhYVJuBOBaxmbNiHeMGrsNf+x6e65DN5dFbNsCiWfTzXQ46bDBaCI4Z3Idxw/txwxNTP5TGWlto5ZN7dxq5hTNRhRxWvyFEjxpP83N/w9tRH6wcfYUHASPM88j7PgJJRmm2FnxubTOzdxsbiCsPX8pWplf4GEtL0ux5SAS3b9pBvRLc8c3L2PzXP4PyqTxxLIkRIxFCEHdd/PBeGIYRaFVJTVRIplgmDfkct13zI+6/83dUbdpGF9tmSzxCfcQinUpx5JFH7lKZ8b8XnXkg8DE0IL7S1Kxu4KXldehi1UDPJbQIKMdn6fN/595vfpraxiw516c8ajKsW4KyhlU0dR8OrkD5Lr4buDd6HzWeguNgW1aQzKZ1KOEhkKbNUWd/mfLyct5c3cCEod13cTdtbM6Ry+dLxgMCWnA0nuDJ555lQnU1XeM2xx9URUs+yDq3DcmCNRvxPIFl2aVVSc5xKIQ1rKVhcsyY8XTv1p22pUPb5mu7oYaW4ziYpsl5X70QgQqFGzvW+ykWgDrlE2dw+KhRFByH9xcu4PZbf8v1N97M2HHjSywVDTS1JMPYkaKiogLTsihkUsTiYQxCq5I7AwjVgoPiVsXraqhv2KkNAqNLH/SORkzDQEoDz/fYUtfAUy+93j4pUQTMol3qhwjYtHlL6e2/3l7CpZ8cg2nIkhSLFpK84xIxjVJup+srfv23Z3n24P44rksymSqtgipsg0zOJd+mJPChfbpx0iGDeHXe4j0+m/uK9NRnyS+bB4DjuOSXLSC7ZD4oHU5iAolzMxGlpSWLaUeQnkve8Xg6Kbl1p5WQDNlwrq/QOykUaAAp0Wh2NDVz9zcvoeyFp9nueSBgx5uv0fXUM+h30aUkbYty1wurKMogrqZ8tjgOZQf1b1d6dvLkySRMizLbJJ1K/Ve7q3aHA8XCEkI8AJwN1GutR4Wf7VZUVghxDXAJAXP7Sq31KwekIR8AHzsDcv/sWt6u3R4Eji0LTBstTXCCgkoIQZ/ulfz2hXfZlHTQYfCvLB4jm1ZU9BC4+VxJEl1Kiee65IWPacigFkU4WAequg7a98lm0qwGepVHOKxXRbs2FTwFml0Mi5CSlnSm9N6Qgq5xu/R+3MjBaK1pSBfY1JJDIEg2ZxCA53kgJVu3buWQQ0e1e9jbnqUYAAeIRmMgBC3NLVRWVGAXqZ5t21T8KQSnfeL00ucHDRzEJz/16ZIOU0lyHigrK6O5qQmEIJ/P4+ZzlMejKO2HkhwiWO2ERiSYQXukUyksKwjS512PnSEicVbvKDBv+pv0692LFbUbeGPG2zS3tPCTn1xbukeivGvrOSjOkCWO49GQahXgO+mMz3DzX+7nG+ecRp9uXUhn8wgVaHsFkvcGtmny2rvLmXDkCNxcFkNAeSxK3vGQIuipiG2STWWRdnCvTEMysk8XVu1DOeC9QWVSgfEQkkwmg+k5mCKcDRuB1plbcELVGEGD5/LGxiauuf4XxA45ghMse5djmpVVmP0GYG3dGDzDGlQoXuj4ELMsmhV06dqNsvffw/E8MtlsidrrvPw8VSdPpMdXv0r2wb9gEJTLNcI4zMpEgknf+U67BNsiq2pfhRv/2yDkAWVh/QWYAvy1zWcdisoKIUYCXwIOA/oCrwshhmutOw56/ZvxsTIgm5pzvFO7nUyyBcM0Ma3K0iCjRBAQS21YzuFjT2dDSwGUQojANZXM5LC6D0DALhLlrutgIXBkEFEQhoFhR4JFjetgmYGAYDqT4Z013i4GpEdZBOgoGC6QRcO2GwghqIrbbG7JAwGbyvd9NIEk/CvPPs3BB49g6CEjS/u0NQjFGb5hmBimgVMoIIQgl8uXDEhra1p/CSaqIgwPBLN10wr4apL27J9igFwKgeM4VCaK7CeJQtNm8cH69eupqizHNAxs20Ipza/vuJtvf/vbHV7/SWPH43iqNBgNGzyQa6+4hFG9EzSvnE/Wl/QdcQT1jkl3wy9du+N6XPu7P/GNy75TOlZxALsuPNbRo0Zy40VnY1kWUcvC8X02N7Ywdd5CrrvwMxjFol2mgWUa5MLSqiqMTWmlStLzTckDM8P2W7YjpEGhUMDwHWzbDO+DQoerJtO2cMOVard4jHvefI2bnhq922N6yWYqDXAiFjqUWDFNiVPw8BF4wIONWcb37xNUvCzGnYrU3nSahU8/ycmTf8Q0KVn/wIP01oqIaVIQUC1g289+Rs33v0/1Zz9b6uv/nwxGRzhQLCyt9TQhxKCdPj4HmBD+/hAwlUCV/BzgUa11AagVQqwmUPCYfUAas5/4WBmQdTsy5HLZ0uogl8kQjcVKtbv9rSu5bNwwnlyZwkBAUaJaCLTv40oz9NXLUhAXKZHK59hyhzl1KeKVXRFKYVgR3FwmLAzU6j5q2N64i2z25ZMmUV7WlxYlEVIihcT3PRbUvMLFF3x1r9dlGZLe5TabWvIkyluN0zsza1i9fAlvz6jh5NPOaLcKcZXGCg1ePFGG73tI5eN6HkaYTFY0aGI38YmgbwKXllKBDlcxUtC2VnupnaZJS0sLMQMiVlELTARygaHL6/WaaZx37mcRpoltRVj4/mK+8OWvMn7cWLxcCnwPTAvDjpe+wMXBaMa0afSL+VRWlJfkVKKmSVPtEoaPHsvsGdOY/dZrbNq8mYZUgW9c9p1dBrGdBzatfBbPfJP5s6bz3rKV1OUU15x7auDjVzrMAQo0qywzCLr7fkBhTkRtbCNIlrvoEycSH9Jrr/dyb5AVXdHKxy/kiLYR8xMh/Vy5Xrv7vKS+aa/HbHrjefxMGhVLkM9kUH5AHNBS8K8czGtOsyOd4Yr/+z9yr/yrnTu06KasmTmTkybDyRdfzOR//pMzWprJQ8ml282QNNx9N/qcc/43EvCE2GvlyzboLoSY1+b9faGW356wO1HZfsCcNtttCj/7SPCxMiBdYnYgERIOPL7nkkm5CGnQ8M5LvH7/rwH4+6InSZSLdlP1Yu2Lpa8+zqGn/V+QVKg1Xj7HuJ4Gn5wwjlhNDX957C/UN+7gmLO/TLe+A2irgCel5P3pr1GzbgXHnPFFTuzZh4YNa7npltv56Q8mY9iVbEl7FAoFti57j7PHHLXLALe7mg0bmnMEqtfFOILiqBPGctb/fYlBww8NmUXG/2PvvOPrrur//zyfdWd2905bSlkdbChtyp6yERX3QBRU/FbFLeDPCahoVcAtwwHK3qtpS6GLTqA73StJk9z9Wef8/jif3CRNCymg+JXv+2Esubn3M+/nvM95v18D29QQYN/zyBSLzHryUUaMGMHYUSM4ZPIR/OLXdzD9zHNwHC3j0WnBa0RJZH/PfmdS7r6C8oMQyzQBzVJftnw5lekUa1ft5rRTTu71edd1ueyiCwEoFkuYlsnRRx6Jk0jgdzSDUvhBUGay//jnt/PBD3+4fI2WzJ/DweeeRhCEdCZtPwiwIrb6iVMbuhBXfQxhmBwx9XSOmHo6H43ueduzd+IFkhBImGCLTi6NyR+eWcyph45gWP8aysOLFcMRgmDNAkQ8hdl/+H7390ZhpqtwRoxDrlm6j4PVpZXOHlIoFT94bhETJ/bi6/aI/CvL8MOgrI8lDFOvYqXkhaZNDBh3CN+44RqOnTyZuY89gGkY5a+1gU4Sz27bwVej1+pbWzQ/qBtyL1SKCs+ltHUrieFv/vz/o6LvCaRFKbX/JeCBxb6ewN6ztX9TvKtgBIcMrEB5RUJh4gchvu+jhIEMPGoKXc1UtWNNuSxTfs0wEW6Bs95zCblMlo72dvasXc6ZAyTvOflEAKY3NPCzW27mqz/4GWEo8aUegEzLRhiCTMsudmxYzVlXfZXBBx1GvKKKEUccxfnX3sij85aQdaqwEimSNf046MTTaI/3L5eYAJ6fO48Fm/Zw+XU/5Mu/vJtDTjqDr3796zTOX0TYidOPmtWdmkzX/b+bmX7mufpcFXihwnU9XNfl5fkv8PILz3PFxedx3JETMIRg0mHj+cG3vsbcWc/he1o0MZfN9ryQat/f2M6eT3mGKgReEHDNNVdz5Sc/SSLmcOKJJ1JZXUPTxo09ZrJBELCxaUMkrRJimFpnK5PJEHquJqD5Pu0d7fi+T11NDWeeMpUZM2aUPSuSjtWr7KbVahUq8Hod75sJIQSZoqfVd4FCCB1eSNYPWb+7jefX7Wb3sGMwLUcjxZwEmKZe5SpF0LQUme9Ahb17On2N+CFHUvCDHmVC7W8CGIIwCFnb0s6H73seN1HBDTfc8LrbM9MVuMVSD6l609T9nlEHj+fee++loaEBq7KSx+w0YcTr6RzJ/p73qR4xqry9ukQSudc+FCBMi7Cw/5Ks9H22PfAwiz95NS9f+Tl2PvokKnxHSvtvHBph0refNxe7IjFZ9hKV3Qp0z8DDgO28Q/GuWoH8/KG5lEScuGFipypRUpLbtZntT/yen9349fL7PnrWFH47bzVVI8ZhWDYy8Am9AkMGDmAbcWoGVuqa/pARtNV1lYy2tBf5+5JNFEsu8X5DyBVKGEpS2LKK7WtWsmbhHC768g/14BjoGrWSEsu2OWjaOWRzOWLxBKbtAIqiEPzwroc4YUQ1J06Zyk6jivpDBxKGukxxxJRTqB04mDnz5nPKRVGDtltDwTIMDNPA8zx838d1XeJxzey+67afM3/O8z2E/KCrDzBz5ky2b9nERZdfgRCQy+dIp9MIJZBKIgOwLaNHU72jo4Nfz7yVYUOGMvnII9m8aROPP/own/1sz1JRQ0MDjY2N/PHP3+Xggw5i2/btzHlhHr++9ZYoOSkCP6DTvrYz8vl8pBSgPT2OO/pIUqlUGR6bKbg9XAtBD6y2aSLs2Fv56uh7pRSvzXuWlB2jsqoC13UpFApaVE+BGHow9957LaqYw31xK57nk89nCUPtmFeZjGHu2YH34v1aSWD0ZMxRRxxwScesrCNUsKdQJOXYOBGJU6HYlSvys9UdrFi7gfrDJvPdPjSna04+m53LFpd7VQCWgHWu4pUNG3u899wvfJGvf2kGE6sqSMbjrMgWaM3nueVb15ffM+yMMyg+/BDCMPTqT2nJe9+yWLx1Kw0HH7zPa/vcR6+ksGwlMpSYhkHrkmW0zJnHYT+4/j+y7PUvZqLvT1T2IeAeIcRP0E30g4AF/8oDeb141ySQFds7aNymNY5K+bx2xbMsCrkslZQ45MjjuXvRZpr2FBhWNYrLjhH8/Z/3kVUxqlMxzjjrbFa7JoWOdj0gmBbJZJKVOzI0jKmjLunwzyVN5HIlVOSGh5JIw2TTpk3InRv50Y9+zGv015Ip3cX7pJ6d2aaBsJ0uMUcFww4+gr899Fe8RDWGmSCM4JNKKVQYMGTMwTzw9MOcctH79KeE0EyRCNUV+H63+rzUxk6AUOF+iW2dfQClFC8vX0khUFTX1JJp7yBdkcYwdF3fDxWdqE8FpCoqmfHVb6CUZEB1Jac0TOWjH/5gr+0rpZgy5SSmTDkJ0+ya9f79njs5edo0XM+NroCW3lBSrxaDMChbEHeWvLqTNI+e0sCe9g7696uNgARgmxbCiukV5Fv8Dm2f/xSjLBern1YlSFoWsXic5pYW8hVDOHTqWfqNsSQlP6SYyyIVGIZJzDQQUhIKQ/fFlCRYtxhiCawhfRfgVEqxevaT1MZsjJilCYJegEKLX+ZOvIg/XH9O37YlJaUNq1EyYGloMUlonTUT2OQp/rCto5dHS0NDA9+/uSeC6ut7JakTP/c5XnrpRVRrq37BEDiGRRNw/XXXcXM0aem+jdPHHET/l5ejIoKerxReLg/PPs+IV99H5WGH9Pka/VtCGGC99UkJgBDiL+iGeT8hxFbgO+jE0UtUVin1ihDi78CraNuWq98pBBa8ixLIU6t2I6NesIhm5gCVg+tp61fPtx5eRr7kEgYBqyyLZDzOjd/9LmP7aUe7Xz6xiHyhiJIhRlkcLkNFZSXbO0o4pkGm4KJUWO4DWKaJEoKDj5vOjTd/G6kUGxdsIOu5OoFFfg6mqSGmptMbYqkMk8mnnM3KtU2MGD+RwCv14DPIMGTQkGFUxS06Sp0NVG2CIaUk8Dxsyy4nLNvQrPqf3HwzjvX6MyghBEdNPILGxkZu/OF32bx5M6eccRYXXPJeBgwcSCwWw/N9jUpTqixF4rkBW3e1sG7NanzPZUBtDcceo0vAQRjiurqc1DnbdWwbx7aY/cKLNDQ00H/gYL3K8H1y2Q7mzXuRyRMO0+KLUkalL3h61pweeklTpzUwb+5sNix9hYmHjCWdShGLxbSZV8tmVCyNUT2w12xWKcXqRS8Q9zqwDINlazdSOfJQpnYbFGUhS3/TB2F0KytqAMCTyzfxya99ouu6GQa/fW4xHzx2nL7GCuKOtiluz2RRKoNpWaSTSUTTsgNKICsevIuKzSspCXCUwEKRcCxaSz65Sacz5Yy+JY+grYWdv/8JYS4DSnHysFpmbdzBvNYifizO5o4c+Xyer17fVf6SbonskgUcmtnN7746gxXLltP0+MOs+MF3eHRmDede/QUapk9HhQG2CskLPQlAgC9gsDCYlErx7W9/m3Q+z8lOjAtiSbZs287S+S9zVqqKsNsEAQNKhQIdy1b8xyUQwduKwnr/fv60T1FZpdT3gO+9LTt/i/GuSSAZ18cwBDJQPQYQJUMGHHcWmUIRwgBDCELfIxuG3PbcK9z8Xi0b9/JLc6k85ITy4K3/lRQKBSrjNrZplAe37iEMg0K2A9ArgglD61imBIVCHhA4qTjCMPdrMSuEQbqmP+mqGpRtaw0oqUlxWrnW4LwzT+OQARVs6SiyK+silVb1/dvvbuO0Cy/HsqwIJQWGabKtaR3O4aP6fO32Bbl0/YANW3cSi8XAtrtxOCAZEQTHHTweJSVhGLJk+QomHXE4ruvh+T65nHZ6tG2bZDKJVZHmK1/+MkpRVvVFCAIJd/zpLj73qY8yeeIEMpkMpmkyf/FS7n3gkV4EtBNPmgZMI8y2onJ7ug5YKVQpi2wHo7IOYXb1SnatfJGx1RaghScH9quhrSPLL2f+nKuv+TwAsmVTeWVX3iTaA2TswKpe1+yvz77E7rYMn5o+kSHVaYTSis3VqQRFz8f1QzLZLGkhOJB5rL1uCcIUSASuABeFARgxh2PPuajX+/2dW8i99Ax+y07sgcNIn3Aadr/BrLn9JuSubbhBgGNZJGIO00cMpNnJ8Y+V63txM7zmXay64UuU2tsxZIgIFXGpGKMUIp1gkizS+L1vg/guExwbwzT1sUUoNABTKSY6Fq+sfI3PjhiFJUER0B/BhP51+IWe5UchBH4osaurD+AK/ZtCiANpov/XxrsmgRw7opbVOzrIZz2QnaUeLdzn1AxChV3oLN14DdmZ9wmlwjQEr816hOPGH6s1sKLGnmHZFFp3MaImgSEEhV2bSQ0eBd2F7KQiu3458B4AJg+pIpSK15ot/EBzTDy3hJ3Y2+VNlP8JFViRZ7sZT4FXRIYBlu2QNhWnHKeFBkfWpBhZkypvYc/U4/nLb3/JpR+5Esu2EMJg1fKXGb8P/+8DjU6pdiE0FLgTtmtG0GBNBgxx3RKO7ZCqrCEIQlzPKxsHGYahiYzFIi3NuxkxeBCtrS1kslndUxCCeDzGqaecws9/8yf+9pd7WL9tN7f/5rcsWLiI+vp6vvOd3n4aAMU9O3FLJTzPx4pcE23TQBXbCYvtCCeBUTMUFfr0ixs9Er8AaqsqoG17lwZX4EVUxN7wgUy+d2O4vr6eXW0dVKWTZL2QlNmFUEvGbLwgxDZNlm7YxoHgwlKWIOhxCAIJpMxO9FXXebib19L2j9/ohr0wCdtacNetZPOIicS2b0YCacvEMkB5HkLAZYPTXHfbHIy9XAdf+dn38dv2ECgwEThKaj6Q0okMIWioTHDnL25l4te+HglzWr0mVXk/4GP9B2AKrdLb+T03hCARs3B9RefTYyhFaFv0aziJ/8j4vwTy7kFhnXJQf4bXpUlVVOrGuDAxDMH5Y1MExZyu63cLwzAI3FInFYSh/WtYff/tBLkOjVYxTbLbN9A+75/lgeH0sf3o2LG5y4xIGDQtauT9p5/UbbuCY4ZXk7BMSsUC+WwHoe/jedp7o5uTUbejUUglkAoNQ44l6FdXx+EjBnD6xG7eIXtFQ0MD77/oPH7zo29x8zdn8Pubb2D84Boapk59y9fTMg02NTVpxFe31zt5ARoCrOW7FQqpJKGSFIvFsn6VQA8chmGwYf16EFBRoUmEtm1F1reC+lGjuOaaazAsm4lHHs2vfn0bixYtKqOD9o7GxkaKhQJBEGBGpUqDLin+trZ2vHxGe4lkmvfZoBVCcNbU45k5U/vck64jkLJXH0UA/2zs3cO85pprOKZ+sF7RSkk2MrXSyVWbh4VS8uDsBcye9Xyfr/vOYoC110FYQr9e1hSLYuv9fyLb0U5LWwftmQ58JVGBT/6lZ0AIYoaB1emiGB0XrsvK3/y0x/alWyLcvIFA6efClKrHvlEKR0qSwCfCHM0P/g3DMkjFYprgKBVmhNxaUywxIpHcKwlCaAg8U5CLJiUoRQaoue4LWKkk/4khDNGnn//meNesQBKOyXfPOZTZ61tYsrWDmqTNaQcPYHRdiue+8gPUQSfs5UEoYMsKhNBeD512pPk//j+qBw4ll+mgo2VXDxTTadOnYtHI7//6Z/bkClRaik9/7MM9Brmd2RLLd3TQXoo0g6KSmOu6OI6DiCSiRVl1Qz9pEjAB3ytRyBS59ORJfTrvvctP7UWPVbsyhFJRl3IYkI6xL72rvkTSgpfmzWXKtOnYtt1lbBUNAJWVVZSKRdxSCceJIdD9AyOCtHZGGIY89vhjTD/pRBzHobKykny+EKHNDMaMHcuYg8b1+bhmzpzJ1R+8hEmHHozn+8RjXeZUYRgSypD2jg6qFMRjvftOnSGVKjfozboh7FnxErXpBFZ0nlLBy+s2kRfxXp9taGhgaNiGUdhdJjV2lHyStmat27aNG0quvehU/O2LWfC8z7Enn9FrO3uHmDidYNVsbNMkVApTCPwwJDXmMNrvuRmZa8eorGNDYhAVe3bhSYUZlVc7OjJUVVYwKCZoLSoGOXuVWwFXSsSGV1FSdtX4hUCGsjwY7r0GiytV5ryEhqC4cQN2wkCRotI0UMUiBgpfCD45sA6/LY/vekhJuQ8oENh1tdxfmSa/oYmhQ4dxxYwvMn369De8Ju9IvI1N9P/N8a5JIABx2+SM8QM5Y7xmBOfcgM1tBT5+1on89KG51Bw2JYJEGWTWLOaL53Rxf3ro92xYQ319Pd/+Wm8U0/TpDUyfvu+ixP2zF7LOjaGAinQFdiyBciR+Uavw5vJ5Kisq9CxVdGo3dYbOKIZpsn3jOmBSj22X/JC5S15hweLFvDxvNsLNc83VV/c4vqbWHC15P5qlKnJuwLK1m4jndr0pWYmpU6fS2NjIt770BY6f2sDF731f2fujM+KJhOYUODZt2RzKsLAiGLOWwpA89+yzbN+2HcO0kGGA4zg4nYACIagbcGAM7qamJv7y0JOMH1OP49iRT4guqxUKBS0vgiSXzxGP9dvvdp57cVG5QS9Mmy32QBYueIEpR4wjkIpHX1zC7x9+jh/+6Mf7/Pzoo6fiL3mKkudFCsoBrlQ4wqAtl0VKie04VMRMwh0rUOr0N4SrHnPORSwwDLLzn6afI2j1FIMOmURdaxPtxQJeEOLk8lTLTQSWhemHSIhKhpJioUARg99vaOHr4zW5WaD7OaECTwlMJUHKMofBcGJsFhYjVUAoBKFpYEn9HfKkxOncgtKS8UE+TyoWY9A559K2eBnFpg2EhoFfLFHM54kJScq2KcqQMJTaKjeeZNxVV3HvxRcewJ1+B0OI8mTv3RzvWAIRQgxHi4cNQk+w71BK3SqEuB74FNApv/p1pdRjb+e+/VDym3kbmbO+JfK6SHLKtGnMv+929pjVDDj6dPpNmMp9LTYtL2/lkolDsEzjLen3PN/YyKpcCsMKQUGxWCCRSCKEgWHZqDBASsnuLRupGTAIJxbX6q+dcioIlJR4rsvml1+Aj11a3nZz3mXRxhbyIsEhxzVw8NFT2LhqJV/+8pe56aabaGhooBSENOe0l0h5kBeC6rr+PPjEwwBv6tw6r8nKtRu6+ZT0ZKTbjoMKAzKZDAiwLJumdWtZ8NKLrFy5gtWrVnHLLbdgxeIEnosMAkAhTBPLiR0w2qW+vp5V6zbw1R//gjOnncDhB9Uzathgcrk8ZvTQaziwglQ12eZtVCR71vxLrs/t99zPT3/56/JrJ0ybTqMSXN0NfvrDH/14v9fNqKzDHH4IduYlraFmmcQEFFxdrhSGoUuloSLtmKhcG6Ki9g3P75jTzyUYP5Zg+3pEIs2ehY3kcrmyCq4fSpAhoWViBCEiqozq3p5EHHYCy59YwrNxybQRA5BKPxPSMHAMwVYfjrB6Dg0Dr7iSPX/8BZUW2IZAmiC0XnwZgVeQCtOykKEGl2xf8jLGth2EpklHNoshIntbG9wgIJVIEEskUWHAoAsvZNCF57/hue9PieEdif9zJHxHeyABMEMpdQhwPHB1pDQJ8FOl1KTo521NHgB3LtzM7HUtGCKqtkjF4kyMK677EQe/5xMk6gbhFvO0trTywMvr+f6DL+1zO5mSz6s7s2xtL/aoPe8r/vS3f+qaqNIzvsDzKBULgMKyHdxCgfVzHmNSPxsZePheBHWN5LkFkjXLFzPzq5/lg5deWN5uKBUrd2QoFnVjPfR9lFTUH3IEk6ZML9fwX35lDZ1Ws+WhPTrm4xpO66r1v4kIpSSRTJeZ5Z19EBkNLIYQ5AtdAnxhGDBs5EhuufkmGmfNKvNRhBDYsThOMoWTTOPEk716U32Ja665hnw+T9OmLdx1/2Oc/5HPsL5pk16NmNofHeDpFxZBqpa8G+AjCDBwg5C2TJ6HnptDRV3/fWpl3Xvvva/bg+ke1uhJbKgYw++eWcCfZy1h0dpNeIHuV1jRcSgl9XnKvfnbvUMFPoWn7iTT+E/aV7xEy4tP4rh53VPqpk8VSoVlCOY258vyM0rB3D0ek973MW655RaezMKuXAk3CPUqMZIoqZ16Rq/v89RzziX+ma/wvHTwwpBAQOgYWHELJQR5BSoaUDsnPYu2bAUhyOcL0fFFw41h4CZsflddyWE3/5ij//5X6q+68g0nCrNmzeKWa/+H5JbtjKrrx+7du3soEfxboxOF1Zef/+J4x1YgkVBYp1hYVgjxGv8GUTA/lDyzupkg8MkW8gRBiGWZxJMp/rFsO5aQFLJdKCHp+6xsDnn8uUbOPqWBghewK+uyeEs7C7e0Y0baQwPSMT5x/Egq4/uWeG5at4bDTAvVbZDwPA8/DDls2ADOPmE0xnkaMnzymecw9LCjGDn+CLIde5j/xEO8PPtpQM+uuw9amZKWKPF9r0yyAxDC5PBjp/LnOc8B8MILLzBtHzBP0FySN3JMfL1oy7uE+xj8yn2HwNfyJJ0DjNCmUqeddjrr1q3tNQi/Vdbx3nLhI0fV86nrbuRTH3wvU46aSEc2y72PPs2Fl38Q1bGT2ro6wsDHtkxMx6S9pYP7nprLnbf+ALl9NTgJROUAhNO719GXOG766ZSEo9n9u3YzftgATMvEENqb3DQE8VS6T6sPb91SSru30pHt9CCJUFgxi46iXx68Hdti/e49/PmVrTxWVYHju2zZ08H3fnwTSMWUIw5h6oMPMveFecy55/ecWAHVMRszHqd23cs0/76Ffldc3QON1XDyKRj3/xmztYQbyvIz4hgQV+ChSwk24AqDf2zdzUlHToK2th7Cgwaw1rJ5dfNmKg4Z36drWNrVzOZrv8ZHSgpRchEdLktrUsxKJt82o64Djf/zRP8P6YFEUsaTgfnAFOAaIcSHgUXoVUrbPj5zJXAlwIgRI/q8r1IgKbke+VwGYVoYtl32nghUJUnh61l0eTZlgJT84Z77KdYdxOwNrQS+jxSG5mSEHslkih0ZuHvxVj4zpX6f+x1QlaZt20Zqho9GBZ06SHo1MHFIVY+ST7/KFE/eeRtSyvIstbKyEsMwegnjdc72LdMilGGX9IcA1y2Va/gP3vMnpp19YQ+pk85ofOKhXozjvoZUinzRJZvNatnzeM/GopQSw7RIpNN4bomYE9MN5FIJOxZ70/t9o9i73NhZ+rjj7vvKpY9pJx6P3LkWx7ZxFXTk8oRhSL/aau7+6Q1aIsQrgFdA5ffAwIMQ8VSP/cybPYuV854jcEvsypY45T0X09AwHQDlFgg3rUC27+SEpMmUm76FMXQ8O5+/DyffigkoYRGLJ0gfc+Y+BySlFLJtJyq7B1FRS7DxFdxSJ5JNv7+oFEkhsA2FFAaG0IuZxzZnGDBgQLnc872vfpNjBqTZ/avvlPlER4w5lCMuv4zcgue1HXOE5HK3NdH+xN+pvfAj+j4GAYv/fAcVmVakZZKOx1AoCl6AZ0IgFYEUxASsl4IHMyVqRoyk/vPXsusL12BIbRoWAh3C4NmSd0D3fsWXv0lFwUV2NvKVYlJbnuaBVSx4C5OftxT/l0De+QQihEgD/wCuVUplhBC/Br6LLtt+F7gF+Pjen4vkkO8AOProo1+/ftQt0o5JKdeBEe/SsBIWEPqoXCthqqIXKkmYFu1mmsb1LQS+T6gUhmkgLJtQhrTtacW2HdYGPpmSv89VyDXXXMM3vnMD0z72RaoHj9CS2cDomMewqkSv9y5fvpzt27eXsf2e5zF48OBenhKVcQvLECRTKTKZDiSyLAe/aNZT5fcPHjyIf/zxNi7+6FVRy1Mnnxeef4q5Tz/WSxPrQKJUKmGaJp7vY1kajdXJEenE+Vu2g207umwYlba+ef2NrFyy+E3v90BiX/0rGRENXc8nn89HBkkmqUQCVMie9nbCIMS0TCpSKew9WxBDumbMS+Y+z2jVysFTj8SyTDwv4OU1i5kNTJ0yBX9lI0ExRy5fIJQSp6ONYMsGBp12OWrHBoItr6L8Ekb1QC26uFco38Wd9yCyYzedIAoRSmSng2PneRgWyoB0KqkHaaW4f8UmLvzM//Q4Z2/rBvb8/dd6xRpq22Px8jxsLRoDUpavg2WaBC+/SM35HyK7aC677vwVVTJEpPQqLPRCpJJUxBxc02Cbl+fHezzS6TS5nGax3/KdG0gfcij2577Ikz/8PoNiMXY4DguLLu35PF/roz9Kcet2smvWoUyjR//OUIrxrRmax/9rJiGvG8JAWPtH8L1b4h1NoUIIG5087lZK/RNAKbVLKRUqLYf7G7RZytsWeS/EU5qUJ6Ui7LQBNS22PfcXTEKkMAgRKCsOdoLsjiYGHXkyAIVCvquWqxSmHdOM6cAnl8syZ96++yUNDQ1874bvsPaRP/P4T7/Bmsfv4dhknkum9VZ5bmho4I477mDMmDHkcjna29uJxWJcvReqCnR/YdLQKgQKJxbHcmJgGCx/4Xk+87EPcsKUqTz38quc/+kvMWDsYdz0na/y8F//zMN/u4tPXnQGD/7xtv1qYvUlDCFYu/o1EomkLqFF9fcuToLmX3SW7oJQ0t7eTqGQx7JMDj7siDfsH/2rQpgW+UKBQqSNFoah1hpDUSgWkaEsqwK3d2QICtluQAHJgKAVK+JzuJ6PQnHUwaNZ9NzjhM2bCUp5PD/AcWxsy8QyBGlZYNZvf0ThtRehlEOEAap1G/7LTyDbdvY4Pv+VF/Cat9DW3k5Lyx7a2tsJAo9EMtnjmqVtzWnaky/SnCvQUSxx5vhhpPOtPbaXWzRL64qFAR2dNsMIYpYRfc869IrRMAilpFjIM/fJx9h15y9Rsqfckul0CTjGbIt1ymbAgAHs2rWLAQMG9PhONbznPZz5/R8yp64/T7fsoWavv79RBPk8wjRIpdP6uY0mIFIpnCB8Z6xwBf9qNd7/FfFOorAE8DvgNaXUT7q9PrjTSAW4CHh7jKSjmL9xDwoDL5BlnR4AGfjszpZo/9VXOfRD3yRZN1BLiHsuRs1QXKcS0OzqIPCxnVjnAUclLxPllvjjr+/g3FM0US8IJetbC3ihZFRt8oBRXJZlcdLUadQNHEzLrh3ceeedTJrU0yNEKcWihYvYHiRIpSuwLAsv9EnVDUIKk1lrtlMyElTVxqgdOJjxE4/khaceY+2SF/naj25lwJDhZAs5Zi9axtSjJrxu/0EpRSnQ5MCEbZbf+9gD/+CTV19LuqKi1/v1JRJRwo5kIg2BbWj3u2Qq1cOj/d8ZG9euZlhNikQqBQiUDMlGA6vrel09G0Ov2TqyOcqg32K27Mpomga+7wEC27GZVD8YtWs9pmGQiMdQMkQ4FkpqUuVxowdjqBDfDQiVxA8k8XgMsWYBznFdSKTC+mVkszk92+7kcuTyVCTiGCKPVFKj+JSio+hp9VvD1HarAnbNfYzGVF35+xJ2tKGtcDPRKlGfn680ssoPQkSk7OsYBmuzRfb8/U8M3A+PzzQNwlASSMlxF1/GFz70yf1e67eCYEyNHoXhONhBGHGE8oSBtpAee/F73pn+B/8H44V3toQ1BfgQsEIIsTR67evA+4UQk9Br9o3Ap9/OnS5csQplOVo2XGgCE2hZktHnXcnWp+/ErOyH22mwYdiAbnbnPalLNW4J07QwTFMjaCIY7p4FD7Mpqsdu6yhy9+KtFEol8vkCUik6Vs7lQ6ce06cv/MyZv+T489/P+JNOpxMq+ersJ8oNQ6UUT7y0lB2eSaJiKElDEJRKBL6W1ag/5HDyjoMpTCzHRBgGJnowPO38iznr/AvxPZcw8HHiCUrA3CWvMPXIw/d5PEU/ZHtHgU4SsgAGVyZIxSwuf+9lfOGqj3Py6Wdy0aXvI5lKYaZT5QTjlkpYto1pmoTdfTCixLKv5KGUIoxkMLojjPoSfYF6ymKWoTXJzsKQPhzDpKKqitv/eBeXn3saQphlJo5pmvz10ef4zGS9El21/GXG1NZ026LWNwuDgIF1NQSlgnZyVKrM5xGGQIVSq/EKgWmAqQwcC4qui6ANO/ARli6BehFrvxNG1XkNvCBk68GnMOv+v9HWvJtrTjoUhIEp6EH2G1iZ5IfdGsyxkeMImrcTBGGZoa/Jg4qWQpEK28YWWvGgJBUP7C4x1fYhmd7ndQ6BrBfgxONMmr5P3b+3JQzb5pBvfYVXvvFdrDCkKpVEGCaJoUM45msz/mX7fd0Q/NcjrPoS79j6Sik1VykllFITukN2lVIfUkodEb1+frfVyNsSc+fO7eFh0T2EYXHoJVdrlmlnGAZmooIwlIRSEk/q2Wo+n6OYz7Nr1RLWznqI9ff+jJY1y6ivryeUirsXbyVXLJHpyCBliACqDj+JG26Z+YawQz+UjD3jvRx62kUY8ZQeUITgsOnnEB+ipUueeGkJu8I4pu2UZ8pmPAGGXhmkkklMyyprSoF+4KVUWKaBaVlloTsVSY4UjPg+rWilVGxrL+jSFOC5Hu2ZDCs2bOGjH9cqtP/vu9/lteVLufoTH+KR++9l29athEFAsVDAdUt4rpZo94qlslyLIQRuBO/tDL3q88kXS7iuR7HkUiy5WualfDyyvJrZO+bMmcNjDz/IcUdN4rhjj94v1FNmmsv765Q4kUqhhGDekpU8/NxckqkUVVVVVFVVkcmXWLZ+q/6MlNTKXJT8Oo9dkUwmUQr69x+A63rlPlP30KWgTm5PF54hGY8ReC4/+eb/0DhrFgAvrttW9vqwDAPbNHAsk3nrtnHiqWfy9Zm/58d/eZDqujqtC9xNNsMQgjVtxR7outTRDRiJJHHbwkBhCe3a/OjWDB9+4AV+/fIalmRcHm8u8KP17axv7aDJ2nfyACh4AaZpstOXxIaN2u/7+hoqCJj929/yvXPP5SPHHcvll15avm8DTmngmDvvYOilF9LvpBMY96XPc8xdv8FK7//4/rXxfzBe+A9oov87QyrFjtYOKoYHCEPLa3c+4EpFAoGG6F1SEaAMi4mDqxhcHWfphh2sXTqfF/7yK4KOZsaOHYvjOGVl2E1tBfxQ15BFt1KBaVoMP6qBmTNncuTxU5i3cQ8b2wrELIMjh1RxxGDd2H9izW6GH3ZkeefCchCGRegWOeqsiwHYXjKwHLGXroTCcGIYQReHpGsG2/VGU2hRQNOy8SPvDc1aFGxqLdCaK6GEwPc8Vi1bxKFjRlI3dJQe8F2PTKZDczZsh+GjD2LGjBn85Kc/46vfvoGtO3axfu0avvCZT/He93+Ac86/AMMwKZVKvDR3NhMnTyYei2OaJqVCnkPGje1xj0Ip8YIAz/PKDd14PE57RzuDBgxg+9at1NRUa8Kc77OruZmDIpkTGfiMGdKf/7n6qrIC8YKXl3LTrTOZOXMmFYkY8198gZWvvMY3rv4Y/Wqre1y7zks0dvQojpk0gZLnE+SLBDIgnUpw4+c/rns5hXZAkS95pBNdqDMhBDvbMow/fDQdTa+S8X2Sjk3ULkAphe8FOKboNonpSjJCCD54wiHMX/gEjcBjTe1MGN6ffulEDy7HDrfbV9MwiR99OuZTfy2DEwwhKAaSf6zY1APpZKYr6ffhL9F83x9pe2UxGV/S2FJk/tYWEpVVZITFK+15dgYGO9o6yOfznHrlNQRP/gWro2c/pXNCtaYY8rtNrZz9FqHXfibD/Ks+TWHLFo43DI6Jx8k07+b6GTO4PuqXpMeOZvxXv/iW9vO2hRDlleK7Od41CSRb8vnMH18gftCJSCUQUoIURH1fPSM2Xr8Wv3bbbq49+UQunzwMLjmG+6ZN4qGV21HJGgw3x1nj+9PQcBKrd+dAULZm7QwlBLFkirW7W7j75S0UA4kptAzJ8xtaaC14jOufZkd7Hjrl2gE929FucZW1/XTzMJEijFwNOxufCoVlahFChPbTMG1b+5mXj0EP0p38lc7PIgTJVJrmXKksZmc7DocffQLFfIaSH2CZBvlioQxzNkyT2n79GDx0KGZlHUYyTf1BVYwedzANp5/JFz71Mf7y5z8y7uDxbN+2lUwmwy23/ISTpp6037KU7wf4vt9Dsdd1tQHX2rVrGD5UU4W0B7nF0MGDWb3qNcYdPJ6gkIkSR4gfQaWPPWoSZ59+KsdPOpwh1QkuO+8sLjn3DIRf2uc9FkJw0klTGTV8GNlsJsqruj9gGIpXFr/IYYeMxzRN/CCgIy+xLbOsSrytLcuh/Yajml5DociVPJK2QTwWwzAEdkIgAk+vRHpMYBS5YglhmBx70Ah+ft89XPGxTxFumI0nFUpKfCkJpOLyo8cis3swIt5IbNyRNK/byK65jzGwMsmatiL3Ld/IpuY2brnlGz3Oz6yo4vCPfUE7Qs6cSVPTJo4aN4Y/nHccpu9SLBQIZciq4dX0u+CjNDQ0EBx1FGu/eSV2GESlX0HWD/ngI3PZVvQ49ti3jnPZ8vvf427fDoZR9lKvUYqLU+8cz+MNQ/x3N8j7Eu+aK/DbuU1sbS9qjLxbLM82ZahnnjJwQckuisReMlQy8GnatqO8pL736bk8ug1E9RCseApnwEhmtad5eOUORlTHtZy1bfVAy6gwYPdrizjyjItwA4kMfNrb29nT2kpHezuLt7Qyb/kqCsUSKgy7BpfoYOKpFAMrNVSzmGkv8wb8UgGFwjYMnRiiYzYtW0vWAzL6N/R9spmM7jH4muAnhIFlWT2k2PWOFY5tUF1djUSX1mKJFIZl4TgxTMvEDyXnX/o+kuk0MgwJg5DAD3Bsh+t/dDPbt29n1WuvUldXFyFvpkVS8PtO1QoNC95bsVcpxbAhQzoPqyzJAlBXW4ufz6BkSEVFGtu28X2vnBwvPf9cDhk3FqUglKH+rBXXciLd2PNCCF5YuITTTz0VJUMsyyYWc0jEY8RjMRKxGEsWvATJKlLJVFkaxPND3MhK99gJh6MyuygmazAQOJZJPB7X/R60H4sRT+JKRa7kls8jlBI/0EgnxzIZEFNMObSe6soKMiWPrOfjhgolDHzPZcMLT/a4bkedczGpMz/EDxfv4JZnl2Ckq/eLdAqatzF89QvcdNQg/vSeo/ncuBpMr6hFE9Er9cMrHCp26fLX7jt/gY1CGSbK1Kv02mSMR684k2+ccBiJAxxFpOcRZDM9no3W2Y343b7zoKUqDgU2vlM8j9cNgRJGn37+m+NdswJpXNtM6PuYpnYTDIoZzFgKYZqo0McyDcIgQIUBwrJ6KapL36X51YV85/GXuOGGG7h38RaSg0ZhWDbCtAilIpQh9y/fzvqmjZwz+RAeWOaTLxQQhoGSIe0bV7F1xQLO+uCnyQY+uY6MRsxECJtsRwfPLnuBcSeeSuAp7HhSL5V1dQnbsjh6mG7cjkwLdkht2COlRPoexOL4nVpSsRi245QTQmcRSxPNBKtXLMU0TYaOHI3vFkklYlpe1hS6+QuYpogGbzTyzNJEs0SqAkPoZDTt1DOorqwgn8v14CYEQcCAgYM4ePwhPPvM073uh+sH5F2/3JNJxSKoq2kQ7jWQmKaJ7/u95MqJzi2VShH6rjZWMgzt/WHbtLe3Y9sW/epqKGY7evir+75HBpv5819i6nFH43keDzw5i6dfXMz0sy/QKCwhSCeTWJ38AyE4aNgg5s59gSmTDoNNr+C6JUARdxztAOnmye3cTL90jO1iCPnNqxjev5p80Y2StIEBJBIpvJKLQpeDOrK58jkHocROVkDg4/teJGvfdeyGELy2bAljz+ppZNcXpFPYsYdd9/wclc9RkoqYZZK2DYquTyaTxTQNDMNESUnLvGdoHDyG4ete7bzaPe6xaRi89/AxHNWR1xOeN0AlhaUi2/5wB+0vzgUlcfoNYNgnP0P6sAnl+xzu5WmigFGjRr3udt+x+C9PDn2Jd00CkYqyv7YRPcQqKIG0SO5ZzcUXXcDc9a20ZAr4fogwDW1biUK6RcJiji2N/yDbvJ3v3X4XQ8/+pCYT7eOheXm3x0Grl3N1w3E8NG85i5YuY8Oi2Yw8fDLn3fgHtrkmIMF0sAj0foRAWRbP3ncXY44+CTOZwi8WMB0HYVr4pRJN8xpZs6iGRDzG0WOGMtjIsa61RLyimkBJTGHglQqRQJ+lPRiEKDezQZd95j1wN+uWLSKT0Uzle++9l0zJZ2nTTl3+iqIsz46iVCwQmBbxpMZ05rNZPFeXgYRhkEwmKRTyPQYYpRSDBg3qdX2Knk9bJk/JLeG5HrF4jIITo39NBbZlsae1ldq6Oiwz4pUEAb/61S/51te/1mvlYhgGQkl6upJALBYj5sQIgoCkY2NZli5DRZ/XGluCz371RiZMnNhFfrvlFoinaWnPUD90UJQ8In2pUDJm5DD+8VQjUsG0E48nlmmmedN6lFvA87X8vO+6uK7LkMpK2qsr8QKpbX/Rs3s/DAmk5KYHZ/PFc07EQK9ALMsqy7NPOvU8jNrBKKmJod3PLpCKp5asiizKDiwKy17ALeTxZZQMossZj9lk8sWuRCUEMcti5syZ/Gi4JswZoveqUQDD0wnm/+MvHP/eD77uvjfP/AnZpS/jS6m10do7aP7Gl+HDVzJk6lSKjz5KR6GggR+G9itZGUqu+dzn3sSZ/otD8H8JhHdRCev4+lpiiRRSamtRAISBv2UFXzl3ElVxi+ZMgaLnESg9C/RDhRdCIEy2zP4nfnYPEy+7hoopl6H2kzwAlDC47W8PMyAd45NnHMNtX/kEF3/ycww46nQ8KSITJoGyYgRCD9jCtMht30TL1iae/+2P6dixWfdRfI9tq5az+ZUljJh8EsMOmUDdqHGsd+Nkcbj6vKl8ouEIphwyiphj9ehrdP53MZ8n8LVAY6lYJNO2h0wm08MOtiJmkWlr1SW88kARobfCUJenIgiuUgrXdcvGUcUIpqvJXRJQmJbJkoXzufJTPbkBSila2zPkcjk810MYArfkUiwW2bx1B0IIOtrbuP22X7N48WKef+45rrvuKzz7zDOsX7+hXGrSu45KfDLUJSLR835UV1excfMWnFQFyWSqTB5FgeM4LF35KmPGju1FfhNCsMes1KisaMVTcj32dGRACM6bPoWZM2ci7DhG3XBWr10LRMlMEPWjIJfLkckXsMyej5llWYRSsjXr85U/PULeC8oJxg0lu2rGMmX6KRBL8kpzlsqEQ3UyRlXCIWYZvLK9ld3yzXlRNL+2DIHCEArf9wlCSaTMjtWN9CaAJR0uTU1NWLX9X7fkGDNNXnzsIVQY9tB66x5e826yy5fiS0kmm9WoN8NASMlLv7yVx/2A7aUSCceiImZhALtdF/uCC/4j+x8KgRJ9+/lvjnfNCuTTU0ezeleWZgGFkkvoe9iqyJcv1LyML92/nJIfYtixvR4WhRIWg6e/j8KuLQw97gwC36OYz5KqrN7nvqxYgrWrXin//vSs2WwqVaHHt6ijIbVBjzIcZBjSvm4FKx65iwkTJrB7y0aevf2H1PQbQD6fp60U8OFv3qRls4POQVyyy7fL0inDqhKsbXZQVdUU8jl8z9My6pEGkR2V5QTw6pJFDBs6pAc/QghBZZhnyYtzmHjsiViWReAHgKSQy2FGZRzQrohCgG3rmanvBWSDLFWVleRyOQC2btrI6CEDmTa1px2pUlo6RCe5Tv6FICizwLXPiJSyB5fjlltuYeLkyfzlnrs568wzicViZLNZSoU8A/rVlctT5WKdUpQ8l5q6fpjJKgg8qlAEnk/JdSkUi1QOHMasCDK7d0yZOg1vwxKa9+xBRZBjM2qWx2JOD3jslu07mTBmWI/Pa896xbw1WznvqIN1v0QpOif9ja9s5K9/+3v5XqrsHt1Ur6hjeDSQh1tXcfToYeSKeWxD6AHesPjHwtV89urX5z8oGbLkyQdZOutJVm3ewXYV570nTuKosBUnFS/3+tqyefJBSNo2EQpsUxAoxfZSwGMbdlFfX8+AD36W7T+/EaV6stHLrTIU41WJDV/+OMI0SR91InUXfAAz0cVA9FqbMUyTfASOKD9jQjA0bnPbHbfzjdEjsA2BoSAdt1ni2yxduJCrX/dM38Ew3zXD537jXXMF6tIx7rjiKF5Y38qmPXmG1SRIORaZYkBTS17Pwva5oogGJCvGuNMvL9fCw1D7me9zWW8YbHp5Tvn3O//xMMPO/AjdmyoKhZK6sX7vtz7NoOpUVwkFegyewydPwnIcpO9324dAhiE7syUqYhYxy+D4kbUs3d6BY0c9nDCk5JV049awicdiTBpey/vmvdDrmDtKPtVjDueQQSV27NzBU//8K61bN/Dxz82gom5gudRRzOcQSpW5J0oqlKnwcx3Ujx6KV1uJZQgmj923wKUQWuTRtu0es1XLstjUtIFDx44CdD3/pKlTcf2AMNTJJghDhgwdxulnnkUqlSKdTjNoQH9+eetPe+4gUhiQUjFk0GDN0K4eiOkVUYFPhWkhYgmGv04JQgiBla4m7bqUXK+c7CzLYs7CpT3gsS+v38aZJ0zGMESZr2KbBi2ZHKOPO5lf3XcXnzh3GjHbRirJ/XMXM/7k93Tbl4Go7GlspZQit/IFSqUigRK4vkTJEMe2+PJlZzK6oQGZa8Nf9RKyZRsilsQceyTWsIMh8Nh+3y+p3bOLs0fXcfqoWtwgRJR2UoqOLQLaUVORor0jx1Mbd/HKjj3UD6hji6t4aVsLmVyeb1x/A/FR4xj2jVtY9PWrGZiwo+Pr0lOToWSgJWjt6MAyLbwXn8dv3smQa75RThTxIcNR0Up2b9HI7cLii0MHEjOELugKXTqeapvkdm5Deh6G8x+mOyXE/5WweBclENBNYcc02N5W5P6Xt2mntuhvjm2UuRD7CmEYCMNAhmE3Hwdd0zaMnp8p5TKY3ZLF5vVrGSplVPLqWauXYcj2jWuZcMYZPVYE3ZftX/rBz5FhNPsrl20UTjzOgi3tLNjazoBUjGOGV9Mwug430AxuyxDszJbYnfOIWQbDquL7FHrMlHyWbdmjexIll2RFFe+/6lrGDqhkSFWCOfNe4rk5c1m/Zg3Sd/nU52eQqq7F9zycWAzcAkdOPFzv03n9h0oIwdzGWZxy2hn6ekpZBjbMmfUcZ5w8DYCXXprPoKHDNBkSSCaThKHkhBOncMstt/Cd73yHefPmYRgGt/z4h8Rj3Us6ChlqeZCOTIaKaL8iloQDqPwYtUOwsm2Yvl/mlbR1ZPj13f/kum98s/y+8y97P7fceSfXXnG+XgkJ2LKrhUL1CBqmTgcEX/rVL+loaaZmwEA+fdVn3rgsEwYEpQJSaamUTiMspCKBj8x34M7+O34pT75YAqkQ2zfRUVvPyEEDEZkWFOBFigpVcRvhmDTvyZA3TOKm/n5IBXM37mTMh65llGHw7W9/m/WrXuXIof0ZP2oUy5YsKU9mOlqa+d6UwziitgI7Kte1F0tILwDDxDBNQhmSyeVh/WrcrU3Eh48GwKqspO6Mc+i4768oKVFCYAElYF2hxOGWhR9NyGwUTrS8OTvu8ORZp/NYVQ2XXvvF/6xy1v8lkHdPAglCyVf/sZylm1ophV2JQnlFLSkRS6EMhbMPj2xhCAzDwTJNLFMgDAuBRIUhmGbE0FblJf0rj/yJo4/uEknsn7LJt+ygYuCwbulDwzp3rniRs844g3vvvXe/x372iUfyaiCx40nNHo/CEAI/8Cnm82QyJmu37WS8meHUaV1lo6FVCYZW9VZ67R5L122lKDVvxDANAt8nFwSsU5JBlXGmnng8U088vsdnvEBrIDmm0avG/0Zx8Jh67v3rPVxwyaXE43Fy2SxPPvE4Z5ym5TAaGxvZ3bqH4fX1+J6PVIr29naqq6rKM9pcLseECROoqqqiGPmuV1ako3sQ3V8F993/IJ+79n8O6Pg6Q9hxkvUT2bp0IRteeZWFy1aybtturvvGN7WcTOijOnYzdewAxl/1SW6/5x9saNpATW0/Lrz8/VHy6EJHyUwLancTyncJN6/EGDhaJ7V9hWnRkS+SjscIuyHPbNtk3Y5W6ta9jF8q0J7JR7wcAWFIcvdaOlo3lgEDliGwIzSdGbHaQ6XIB5G8CtCaqOHjJ5/MrbfeyjCvg5mffA9KREZg219mbbGVEyaMYfeeGr7y9ALqhwyixlC8urOZz088iJNHDCyvxD2gGEKhUMRv3l1OIACDP/ARNmay7HrkAdKmwSpMHs+ViBdLpAfWUigUEYak+xMohCBuCs7JtnPdjBn86C0If769If7rIbp9CfFOKaG+nXH00UerRYsWve57nlixg5sff5VcLouVqoByR0ChSjmEZWM4cWwbTNvpIUUOChEGxGyL8VWwfnc7Ziyh2djxJEZUC1VS0jTnIXbPvpc77rij/EVvbGzka9+5kYnvv5aqwSM1rLcbZdESikNjOe6//ZZ96jdJpbit8RWseCoqoVFukmt4asRjME1WPP8Y7zv5WBoaGnh+9hwaV6yn/6hxCBT1tUnOPH5Sr7Lbwwte0+fcLb1JqbBsm5MPHYFjvf0PSmNjI3fedTcf+OgnGDp8OIl4gljMIR13+OgHP8CN3/sBqVSqLFkilcI0DGpqarj2c1dTLBa59NLLGDlyJBXJGNVVlQgF6ZROlkIIlq1YyU9n/pq//e1vb/vxq9BHbV8FndpeneCD2qEYlf17vT9s3Yrathrf9ykUCwg0r6ZJ1HH8tJP3uY+ZX/88lx5ZT5fDoIFUktvnvMZ1F06nffsmLYDYbQWspKKUzZGwBI5h4Jhd7FgBtO7pIFSiTBYVwM7J54CSPPfrm7hi0kH4YahFM6WkMh7DMTXMV1vfhny/cRlrPIPJY+u5uioksdf3KZCKQiiZ8N1fEBsyvNd59dIq+/SnqfzD7XiFAn6xiNVtTCpJQdT146++pKP/gNedbPUlhBCLlVK9ZbAPII6aeIR66ckH+vReZ/DYt7y//9R416xAnl+9m0JEUOsZAoX2FlDFLErECQIfw0loscTAQwU+BpKCC2tEBVcdUcHv/nIf23buYnBCcPyUk5i/7DU2rFxE/ciR/L9uyQP0DPQHN3ybmTNnsql2DIedcwWm2Y0zoQTLi2n8dH+GjbHZvXMbM2bMKKOCdmZdvFBRyrRjWjaGaZKIxxFCYNoOSP2ICSEYMHIMv/r1bXjCZnXGoP7IE6Jup2BXKHl04Wu859hDe1yBHVs2MWrcIWVmO2jCm+eWsKLjLPkheS/AMgwq4tY+ez8HEg0NDRx+5LHavzs6dqUU2ZJHMl1BJtNBRUVFOYEYQpRdD4Mg4Kabb8GJuBemYRC3BNlMB63tug7/yquv8u0bv8sPfvDDt3Sc+wvVsVsnD2Hgei75fB4lFbS18VrGYFoPxWSJ2rEOz/fp6GTYC4FtmmxeOAdXGfucVR9xxsX84s+/5sPTJ9OvIsm2PRnueGYRl131RUQiB0r2SB4AtmXw4KubeN/RB2Eprf6LEgi0dUFlPEbRD/W1NEyyI4/gmLEj2fK3X/Ghow7GNgxilknMkuRdT08elEYWBlJiGiZfb5jEodf/krZnH2bTQ3/rJf1jGYJ1e3Ics4/kAfvmq7SlEjTdeguGH6ACveoMVGfy0IKXFYk4S/+TSIX/twJ59ySQuKUJd4bQCJXuFptKaR0Tf91CGk4/nZfW78ILNdTRNjRhqnO1UiwWmHxMA38/5cCW0Q0NDYyZeCy/mL1231aYQnDIJZ9B+C5+IcPqx+4qSzjkvYAwDDRhEYEMwvJDaxhGDyvtRCLF9Cu/xhY7QeXgGMr3UGGXNlZbaJP3AlJO161/5aVGho8Zh2laej+G5j6seLGR844+mE17CuwpeOX3m4ZgXP80cbvvQnGds85+g4bw3is+woiRI3FiMVToU8h3WQun0xVccvn7+cd99/K5L1wbnZ9meTiOg22ZXH31Ndi2jRf5xgeAVDa7Wtt5/vlnWbhwEaFU/OLWnzN58uQuTbC3M4oZAFzPJdOR6SojKcWvbv0Jim59LK8ESps1dXcSlEoxadwovrEfqY6G6dOJEXLPA/eyaOUqkjX9ueYa3QeQbTtRa5dhKkWnPKNpCF5Yt4N5rSHnuT7VMQuhNGBDAlnfxzQtqsdOwKzqhzN2AmbNQPb84Xu6uQ1laJVtGqQcW3/ru126UEkM08RtWo2/ewdCQCYISRgGTsS2L0nJozvaef/eJ/Q6UXPCFJL1Y9j2l7toee4ZSiUPP5KrF9F6/bVC6V/mYHnAIQTqv1wosS/xrkkg504czDPLNiJDRVDMY6cq0POyaLlcaCN20HEsa7eI1w7FLxRRpoWu6kb1YsMg8Fxqk29ORG3x1nZ8P8SOmb00t0T0pIahj52q5LBLrmLur74NQMwyEPEu1VEFFLyQpGOWm+umpUtQtUOGE/h+uR+jXdMUKtBM7sD3aC/2TCAXn3cWd/z8h7znik/Qb9AQ8tkMzz10LxefeTJtRT9KHl2DcBBKNrTmOWRgRZ8G5sbGRmbMmMF5F13KpR/4MADFkotp2ygMJJG3hJTk8nmGDx/Bc888Q21tHZe//wNlomWpkCc+sD+HHHoo7e3tZThoJy9lzEHjmHzkkUgZ0tHajOd6bN+6Cdu2aW5t4/AJEw/8pu0vLAe8Evl8PuJ/iOg+GHih7KnfFDnX9bAcRk9MWjP5ffrRKxkSvDaPyWYLky89FS45GaPfMKyDdS/KqBnEzv6H4WxYRG06jkLw7Gtb+eXTi/jBj2/ihUf+wGnjhunkoSBQCkyLQEoSk6dhDRwJgL9tA8iolxd069AJoYmc6OQUSFlWbU4ltUJCfNRBGIvmIRQUpCQfye/bpkl82IEP9LFBg6j/wv+gPB85by4qlwN0w/3RQNJyAC6G/5b4vxXIu4dIeMyoWk6uT6IiaRA304GX6yC7YQmEPjLZn8BM0Z7J097WSugWQSl8bDqlm5USpLYuPuCmcWe4gdQz/P38XYUBYRDqFZIwmHj2ZbyyM8Oza5vp5I9EFhMEUtGRyeIV8wjDpLlpFW4uS+Dr7Ssp6dRj6bTe7BQgTNg9j7+hoYErP3IF/7jtZr720Uu465brufjMk2loaKAl56LQEutte9pobm6ho72dbKFE1vVpzrm05Fy8YN8EMtCQ5KqqKi649HI8z6NYLOCWSrrkg8CJaZtU3cuBubNnccstt7B44QI+cPll3PSjH7Bl4wbGjq6PVICtskd8J2mysrISO9Iey7S24Hs+YRhgRrIcdTVVLJg//03dt31Guo5AKaqqqqmuqSGVTpOIx3Bdnw+cexoi6JLMFaaFqB6EYztlLo1paELpX599cZ+z6rBpOXLPNjzfp62tjZbWVjo2vMr6xkfK75l8xgW0jD+Vbzyxkkt/8QAPrG7mBz++iYaGBl7JKDwp8aXSyQPQ+gcGZv9unBVTQ75TqRQhENJNgyyyJpah1O6MhkllugIn5hAbdTAVx0wjVlmley2WRdxxiNk281vzfOizb26gF4bB6C9fx+irPkti6BB8x2K+59Fc1+8tOWe+/SH+z5GQd1ETvTMefGoWd9z7BBvXvEoxl2Hgeddq0UE7Xl6+C0JEUCJUCiuRJiY8ZODhNi3n25c3cMYBlq8645WdGe5ofBXLiZeZx50hBHi5dpBa9sJJJInHHAyhkMIsy6oYERFNhj5t27cwuG0Nc+fOpampiU/e/EdU5OutgES6gk5ORFjIYpgWlXGLCyeP7nNJZ9WuLB2FEpmOjnLtXiqFE4tFawddRovHYozqV0ltqjdO9thjj+WKT1zJ2edfrImEpQJeycWJxaio1E6PQamIUoqW5t1c98XPMWf27P0ek+/7ZeHBTo0vACuyjW3esU3raXV7eG3LYvbcF7j4ssv7dN77C+W7hNlmwmyb7kEoCUpiolnruVyeUOpkXzt2AkZFnf6clGxZ8CxxV19HLwj57cPP8/Cchb0GRqUU3gv34XluWZW4s5RT8gI29T/iDQfSxsZGXv7Lr7ls8miU0MnKDyVtB53EMWd0cVCUlLT9+UfIQhZPKijmtcyPlHiBREmFrSSYNoaj7Zurz/8wiXFavypo38Mrf/wl3tqVZF2Ppb7NUR/9DA0n7xsY0JfoWLyQplt+qEmzEZjF9QN2Z/Mk/YCcbVN76WVM+/RVb2r7b0sTffJE9eJzT77xG4FY7eD/yCa6ECLL3ryCbqGUqnyjbbxrSlidccEZ07ngjOkAfOuBlSxoaiVmm7Rmu+S9FZbG3YcSgSIIwbBT1E6Yzu+aHIbvzHDIoK5r2xcHPIBDBlYwvMJmfWuGRKoS27YjQpfSftuRiKBpWtiOg+uWiCeS3bFgSEAFHkKGOI7D3Llzy6iU79/zGANGjEEGPgIoFfI4iRQiQlRVWoozJ4w6oH5AbdJmV2tbOXkA2LZNLBYn39GGZVuEQYDve2xEUBG3sbut0KSU3Pr7u6jrP7DMl0lalcQTQXklpxTsbm7m2ccf4YU5jQwaOPB1j8myLL0KC8Ou5GGa2JaFDAOCsGepCDRZb38mVH0N5bsUtq0m9H1ijjb5wrDwinlinecsBCW3hGPbuDvXE09VIwztCDni+NOZ2ziLu/70R5asfJURI0buf1YtA/L5Qjl5gL7/ybjTJ3nzzr9/93e3UxPmqaipY+olH2Tayaf0vC6GQeU5H6bj4d/hBD7SN1FS4UpFCYES4CFIOjaVp11MfNwEzFSXdbFVXcvEa79V/r3n1g88lJRsvm0mnuuSL5W0da1UOKGiCnANQToIKP3lbmajmPbpz7zFPb7Z+N8P41VKVQAIIW4EdgJ3oudkVwAVr/PRcrzrEkj3eG3zbvK5AtkgQBoWppNAJ2SFQmDG4himQV1NrcbOuyH5vM/n713GBROG8IkTR7Fg3lxmzJhBqrKagSNGs7t5dw8EVfcwhOB/zj6Sa2+4ieW7srj5LKvnPM7RZ1/KYdPPw4nFicViZcKhtR/DGhHV35vXLOtRP9+44Dnqho7UvYUwxDBMvEKOlU//k5uv/8abguP2S8fYuG41I0YfVCbTIQS+W4p0r7oQVMVSkUzJp67bKiRT8uk3YJBuhMsu/SrDsumUHMlmMqQqKsnkCzRt2MBvfvOb1z0mIQSOY2Mrq9wgF0LQ2NjIn//8Z777nW+WwQCdjPkg8FnftLHP593Y2MiD/7yPikQMOxZn2imnM7Z/mrihVz4xOhnZiphtQ5T8LdPULHsgny8Q9woQ73oWT2qYzkkN09/w/ETVAMxMtscg5VgmK7fs3m/PRO7ZAYGPUTMIEUv02YfcGjCU2o98DXfDqzQ/8DuKfgCR16KIGNcZ12PY5ClvuK23Gl5LM6W2PWRyEeDANLB8HwWYCBACKcCQBm333QfvWAIBjP+a4fNMpdRx3X7/tRBiPvDjN/pgn66AEOJHSqnr3ui1/03R2NjIlpXzsYZNwDAMQt9FGgaGFaOzYSxCF0SMPW3tKDtyhRMCqQRPvbaL5pzLK3/6Nf0a3kds9GQAqv0S9sJH9ztLnDN7NvMe+Tu+77Nl61YyHR089ZsfY5QynPy+T7G7ZQ+okGR1HXZ8/wTAUq6D1XOe6FE/v+Ki9/DDn13PcedeRr9ho9izYwvzH7mXr3z+M31KHlk3YHumSBAqBqRj9Es5GELw2N2/o3bwMEaOPZiNG9YjhOD9H+9pVa/lXcLe2yx1QYOlUhhQLi0ppchls/i+hxCC933wo7z80gt9rnN311RqbGxkyZKlXH/DjcTiDnHbxC25hFLLZ7y6ahWnn3Yaoe+CMDBMa78rscbGRtq3beBrV3+yfF6ZXJ6glCOIOVGPoBsAAxHxFpVe/UTmXlrksTdSR5XyqGIHGBYiXYvYh6aSNeYo/E3rsIxIUh8oeQG/efKlXj0TmWnFW/QYqsxJkVhjj8EePaFP1xFAWDbxcRNZsLWVyYNrCLpZCFuGwVNrd3Do63x+75j97DPc/ZvbWbFhI0NHjtrvqnzvMJMpigXtBd+Z/HURS2hCZXTPpIB0N9j5vz3+u6RMQiHEFcBf0TPo96MdsN8w+ppCTwf2ThZn7+O1ty2EEGcBt6J7f79VSr2tgP6ZM2cSy4fIYYehDAvTUoS+5nwk2tcj1zRSGncKsaHjosEmapHo/yOfL/LyxoBS/UkkRxwKnUJzdpzUCZew7fHb9rvfAYccxeApF3B8ZR1hMcfuRU8Ra9nAjDMmcPTRRzP+hFMYe8blZZmP7tHZssp1dJDtaOc73+xynOt8QLuX077y+b49uFvbC6xuztE5buzMlqhNOkwaUsVnP/sZPvWpTzFuwlFc9rFPUzdwEMKJYciwh6OhaRi9pFI6VyedvQqpFKZSIMDzPGQY4kSijKZtlZ0EDzSaNm7ivZfr/kbR1SqzjmWz4uXlLFuxkve/9zJqqqsJ3BJECcBOpPYJqV6xaD6Xn39mpNyrB63a6iqUX8AUBn4Q4PoeMccBBMo0EZHDoD5psA2T1o4s/ZyuSYBSCrlzHWR2l7erhIEx/DBEome52UhX89gWl9L6ZRw5biRrtjVzV+Ni2gteWS8Nol7F4idQXgkv1FBhKUPsxc+yZeM2jj7l7AO6jo+3BIys9qiK2diGwJeKzZki8wsmfWmLKylZesdPSK9YwFX9DOg/hqd3ZfnSjBnc3IcmuJVOs6LockTCoROs3pnKSmFYbkobCvLWO7wCeJug4f/qsa4P8YFo/7eiH9MXotfeMF73DgghPgN8FhgthFje7U8V0U7+JSGEMIFfohPXVmChEOIhpdSrr//JvkdTUxMDBw5EvvJPisNPIKgYBG6WbXP+Tn9vB/X19bS0rEUMOxhhmPTEGmhYbC7nUzHyMA2R7SR0KYkSJgNPOG+f+20JHQ4648N68Ag8DCfOoCnns6XxAQDq6+vZsmIB/cYfSdXIgzGTqV7bUFKSrO3PN378cxoaekqM9KVsceutt/K3hx6n/oijyO3ZzWnHTebQMy7D8zwK+QJBGGhRPC9Fc1WCqdOm8bFrv8qRJ00vy7r7QUgsVUlYKmiXRykR+TZss6eIYk0yRsELokG7syQCILCdGJZlU8xlMU2TjrY9DN6Hf8gbhVKKk6OmbWefww9CFIJ4upLPXXM1oed281kPiMfjBO3tDBzam+x27KTDIoRX1yQsCENM00GFHoahHRy7vDNMiJJIKqkTxo7drbQYlYzpPsjkWiGzG9fzy8cRcxzs0sukjmjosSJqbJxFMrOd95xxEn4QMnzoYA4fO4Kl+XiP+yvbd6ECDy+UPRvuAlbNeoS8qaVSuk8qvvTpjzIxLZGZFsy6odgHH4uRrgbgQ5/+LNd8+UtMGTWI4TUVrG/pYP7mXdx0c1fSer3omP0E5quLI1FEfc/PGlhBPpB9tqadVzeAdGYPoyyDEEVoGkg/QAKGUhhK2wZUX/zePh3Tvybenh7Iv2Ose6NQSm0ELngzn32jFH4P8DjwA+Cr3V7PKqX2vJkd9jGOBdYppTYACCH+ij7Bt+WirtzaTvKkj7PbSBEvtZDeOBfLbSeTyXDs0AHce69GdB19zLHUDD8MOeAgXe+MskhQzGNb2rmNUFukIrtm20qE9B950D73PfqUS1EIPWMFUBIpBcNPOg+pFNdccw0zZsxgyd9vI2+nOOOqb1BR26XUqpSkmO3AjsWpHTH0gM/91ltvxRtyGJ+/5RI65VwCzyWTzeC5rm7iG1oUr1gqsnT9VlJV1Zx05nn6/KSkVCzglgqEYcDWpvVsX/MKU487ihNP6l0jT8UsFsydxbEnTS8PkHoBolchwjCIJZMgJclUmhtu/gWPN87juccf5ryzz+pzOSsej+N5Xo9BOAgChg4dhgz8yGc9QpIZJq7rYloWc+fO5aSTekrOp5OpXg13GYlh/uHvD3Hl+y/CMi2I9M8MFUYwb2jLZHAch7oBAxg+ZnLPbXTswvd9SsUCtmViCIHn+3i+z+p5jRw1ZXr5vUueeZgPTJ2gJWWimfaoIQNRu9t6nnhUtuokKZa9UoCqVJKHfjeTK44dy68uOpK24uHMXb2FwRteoJROaWmUPTsINq4gcdpHMKr60dDQwI9uupmZM2fSuHgN9fX13HRz3+GzmTlPEnRDwKno58xBlTy6YH2ftnHl5z7PjBkzGJ5OMSiZpMkrUNuW4dK6GqqVImdZVF/8XqZ95h0Wen97Slj/0rHu9UII8QteH4X1+TfaxusmEKVUB9CBrokhhBgAxIG0ECKtlNp8QEfc9xgKbOn2+1age5MHIcSVwJUAI0bsWzp8X/HCmmauf2AFftVI/EKeID2SXHIo8qXfY5e6DJYA6keNZPeLfyVZP5HC+LMQloP0ilFR1kI0r0MOHk1FRRXFQp4wgtDGkimOHrPvmXT1kJG0Z3KRoZnQcuhKkqisZE/eo71uHCd/9de07WllVeMjPHjr9Vz8P9/FtO3Ic1zb8gokaefAl/BNRYPjDxpP1/dGYTsxAgFCeGX0kiF0gvQju95OX3JhGMSTKQo5jRqr6z+Aj73n1Nfd5/B+1fz2Fz/lk5/7ot5jVNIShnZ9xDCQgQ9KS72PGFXPhz71WW742pcA+jR42bZNEAR6oI+O1emUAFdQLBYjtnhUVxea/Pe73/2uVwKxIpKpjNwrpZTYloXpxDh2+hnaTAi6kkcUwjSRQMnzceIJcAvQjQBKGGAYgop016rS8zXa6r777uuRQE4YO0RDprs930EoGdmvCuWVEE7EnakeGMlCS2KWBUJrbIVK0Zpz+cLJh2PbNm4oqYhZXDJhBGEYYoQB5QWW7/PqXTfTevjZ5RXsm+FbKCkJCzmtyht2+b1IIGXSZxZ5Q0MDt9xyCzNnzmRhtGr69I03agHLf4WqwJsIBQeyAuknhOjOM7hDKXVH9N9vONb9C6Nv3IfXib420d8D/AQYAuwGRgKvAYe91QPY3y738VrPIpK+AXeA5oH0ZaNKKX7+9Bpc18cvFTCFQMoAZdq4w0/k48fX9HhwOlcDNC2j6aVZ1Jx4KVVjJmIqibVpKaUVz1Ex+VTso87CtKswhCCQioRtcsERg/d5DCP7VeErzaoOgxDTMkkkU6TjDn9atIXdHQUKrkc8XcmR7/kQrRtfo5jrIFVViwwDTNPEtGySiQTjB6T3uY/9hRuEHHPaeWWhSBX1c5RSKMPEtGOoqDHZOVOXvk9He4nqqqryNexqcApqK/d9DNrNDwyhB4THnn62h5+5Qg84nbPmIAg0N0sYhH6A5dhcdNn7+1T2EEJQUZHGNE1KpRK+7xOLxXAch/796pC+Fx13d16IzabNm1mxYkXXMSkJUjL28Im0blyDhWaLS6WIx+OkBo6gYeTBBNtW9ShvdQ8jkoEpFPIk9uZYRfBqze/Uf3Nsi6Jp8Ny8BT3eWplOlb1Fuo5PaYRet30L28EYehBV7rKuJ8SGVTtaOLguiWGIsppvGAlx2pGsT/cYURnn29/7DnDDAScPFbFbhWFgDxhCxa6tFEsufiBBgKkUG3Ilrrmm76rI+0ti/wnJozMOABTe8jo8kDcc6/5VoZT6U48DESKllMofyDb6OoX9f8DxwDNKqclCiJPhgKRuDjS2At2L08OA7W91o3k3pDnrUirmy4OgJt0J7BGHMnfuvXzhC18ov7/7TGjHjh1svv+njBgxgmHDhpU9tG+8cCqJUaN5cMUO2oo+hwys4NKJQxlYEe+x7yCU/PKxF1m400XE0xjCIZk0ScQdTCGYMKSKV3Zqhz2BwkCADKkbNZ4VD/2W8Q3nUDNkBKZhUpmMcdlRo0gewArEDyVPrW3GsrvEsrUiKxFiSOK7JaxI8htDsG39KoaOGo2SEtd1icfjOtkozStxbJsjhtb22I+UikWvrSO0tOtdtqONNB7PP/MUH/3sFzBNq0ciAQh9nyAIyqgb0OznEfX1NDU1EUhJruRpUyQECcciHbN7DCa2ZZFOJYnFHJTUg5ljW1pmxImxbcdOBg0cQDwWw4sUcX/6819QX1+PUorQzSPdYnl71YOG6+MJXDAsjHiqSz8tloRiVvexlBGxcwCly2YxJ4Yf+BDrWmkovwTSxwsC7G4IMKUUW3Y2E98LcWf1H44oNetziVZUpmFgJ1J6/53bLeXxtqwh7wZYuu1AIKF/VQXK0UcWerpvE7NMzUlRvZOfVDD94OF97lOAVk7IznmMwtJ5KN9DpKsJ2puxDKhIaih3seThBpKBF1zBCfvZbl95VP9p8TZxsP8lY92BhBDiBOB3QBoYIYSYCHxaKfXZN/psX0cgXynVKoQwhBCGUup5IcSP3sIxv1EsBA4SQtQD24D30UdUwOtF3DawTRHJMnRL/IbACAOamnO9lsjdZ0Kv90U/dmTPgbR7lPyQL/z5edqlDdLAViAR5HxFwS9xaEVIOtaPQCqCSH6je9QOHMoLv/k+z8x5EakUNQn7gGdiTXsKZPIlFPRkwXfCImXIz774ccZPPpqKqmrWrVxKaMW45ls/QAiDQrGEUhCPa8vf6nSKkbXJXqirxWs2EpgxZKi5BBXVNYRBQP3osdz205v47IyvRrvV+92yaSMjR4wgsCzNHu/kiRgGTevXcehhh9GWKyGjp1WhKLg+nh9QlYz3kJUxTbMXaq1zX5l8kd/+4EccdughZLM5nm+cTUtLC7fccguvrVjGgJoKPM/HNA1SqRQOoJwEVrr3fTWqBxMUshgRrFtFarcl1yUeixFKyb1PzuZSO0lcBHiex/I1Gzjp8LHkCiUECse2kUohw5BCye11P8eeeAZ7XnwYq5Qrgw9i8QTJCT2b7eHuTZRKRUIFgdL+9UoqbMukwwupSTok4hZxx4rgsAA2uFrgsTO8ICQei9HU9Np+v0N7R/vjf6G0ehkIA2WYBNs3ISQUQoVjCAzAdmyyx07nhIv23fBufO45nr7pRq7ql8Y5fChLshm+85Uvc0MkyfKfGooDWoG8XvxLxroDjJ8BZwIPASillgkhpvXlg31NIO1CiDQwG7hbCLEbeHN4yz6EUioQQlwDPImGtv1eKfXKG3zsDcMyDS44chh/fK4DGQa6xmyYYDqECowpn+YTv5vP9y+dyKDq3hyMN1Mb3tCS57uPryAv0mDp2nsgwRQKIRS+57KiFFLtbMQ0qrBMq6fonlJkm7dTX19PdeLNiTgCrNiwhbxHmejWPYQQVLpt/PjHP2LmzJm8skhzDVasXEnz9i0MGqE1qPwwxM1kmffkI3zvus/3GvT8UBIYNqHvlctF2sHRZurp5/DHX/6E5YsXcvZFl5GuqGT2s09xwtGTOerwq9gjtEmUlBLHcfB9j/v/dg833PhdpFL4vkehUCCVTGGaJoEStOWKOJbJ0sULuPvuuxHCwDJN3vvey/aZ9FOpFK+8+hq5XI76+nq+9rWv6Uvsl5AyFVnSSjo6MlRVVeIgUPFUr/M0LBtn2MFsfW0ZXraddU0beezZRg4ZN5aS5zNn/mLu+P43MfHx/QDDMDnqsHEEvotlGgSBjBKywnFsXlq5tuwlX74nlk3tlAuQrdtQmWaIJTH7j+xtQCVDLXKITg4x2yaQIZZp8syKdbzvxCNIOHrV18VaASsWJygVACh6AW4QMnvt9j73KcJsB9mVi8kXCwRBSMw0iEU0Dds0KEQy/TawdNbTHPO+j+5zOzv/+AsuHFRZ9seZUhXnkOQAbp/5i//oBAJvzwrkXzXWvYnj2LLX9/xt5YFcgHaf/CKa5l4F3HggB3igoZR6DHjs7d7uldPHsK5pE7PXdSARYDoQ+hD6pCoqaWrO8+W/LeXPVx7/luutoVTc2riOQskH0+4mSUL5gccQCEwaX3iRQxvOIZZMkc92IJEYlo3b3sLO1Uu5+aabWduco2lPgYqYRXbjK/zmlz/v87J/yYKXGDnpBJxYHD8IMY1IyRbwigWe+sc/+PB7Tuth1nPZZZdx98++zzENpzJ2wtH4bomFs54i37oLIb7Qax9+KPFcd5+rgLoBA8vlwL//6bc9jllFVqZhGOL7PmtWvcaspx7ji1/4PKNGjyZXdOnoyFBZUaFLjlEZLV8oYNsWhh3ja9+6HhmR+FYsX8bsOXNQUjJjxgzGjRvHVZ/5DALBnLlz+NhHP1q+Vpdddhk//9F3o8FARKVNzadwbKfXeXSGYViMOOwoALa5jezoeIJ5f3+I+vp6vvedbyKQeH4YrXQVYajAsAlDXSZMxB38IGTTzmaefHHpPgduYZiY/UdA//2DRIx+w5ASKlOJMjIMIfD9gD89O58TD6nn4P5VGrChVGQNEJZ9QXw/IFSKvyxay6ptu3twTF4vFs16hmQ2i2Foy10ltVIvQtDDokQIMu3t+9yGu20z9SIg7KbpKhTUWiYD23f36TjeyZBvUw3rXzXWHUBsEUKcCCghhAN8Ht3jfsPoUwLZq7Hyp/2+8X9BWKbBTz55Gk8+O4vvP7iCfGqYrgkLQTabwTBNtoQBq3dkGT/kDbXEXjfWt+QpBSFh4EXSHV0howYzUiIsk/aODJ8+YRT3r9jBegGlUonWtcvxV83lpptuZkt6NC8u307J8ykVi5hWmjHvm8GYMGDXyvl85atf58c//H6vJJIp+Szc2k7d+MlIO4YXKkxD6AFNaPSOlJL6wyf3qn93ggjmP/ckryx4odz32d8g41gGjuMQRuWrzlAoWnfv4P3nfnC/jdHKhENlQsOVDx05mAvP1KpKeVer9xpCaImQbg+t53mYpsHB4w8hm82A0PyACZMmsXD+S/z9L/dw/gUX8KlPXamRa0Jw9tlns3jx4nKpsqmpibXrmzj80PF4XheAQAgDEX2me8yZPZvli+czcshAiq7PiLHje61Mw9ZtZHduIhQ9ixxKGMz8+6PEbYshA/qzYftu5ry8kmw2y83f/SbhxiXguxBPY/QfhYinaWxs5Il//JWTxg9j9NBBJPoPZeRR08orESNdQ0u+xJiKzn6LKBM2L5p6DO35EoWadNm4q1MBOesH3LtoLVub97B4cwu1I8YckNrt7ff8ja8cVKUnYYAUhn6OlCLsNq4GUrLd3jfQwt22SSPXpMQSgkSXeSIfHFLJde+7hHM+8/n/yJWIvsbv9FG8bXEVmkQ4FN2TeQroE0b6jYiE+1NrFIDqi1rjf1r0KGmc9HEcx8ErFcpNdSUluWyGOfMXMf6ityYNJyMnQEPohji9DGgUhgxRoaLCa6N/OsaVJ4zCC2RUCjgW+CSLtrSxZXUzvu+Rz2RIVVZp0yfHoZTtYOhR06kYPLJXAij4Ifcu2UTR9QmDgFKxgFNRUXZfVUoL9GE5uLlML42l7iCCvqx0LMPA8AqEVrwM+zVMk2I+z4SD+lYa2TsStk0ul6OioktPSggRKfL61Mare1/3UHLU0cdy+69+yac+daVWt/W6DLGOPOoopFSYpqC+vp7f3XkPP7rhW9i23Q0GLDHjPQe+uXPmUGuHvPe8MyPwhcL3fZYunM+kY7qQl8KJEwR6NUWUqDr9yH1hc+o5F/e4pjN/8B3G19hQyusbk29DFjpY0uxz/5/u4OsfPB/L0qUv02snv/RZUhNPQcRTKCnpX5UmW3SxIgkVN1r5XD79WH7z+BwOHaz7OBoyrqiqTOMk0nxu5t09jNU6oy9N7eVrN7CwdjzH9ktqFLEQBIbAkopQSmwhCKTkmS2tnP/pL+3z3lo1/Ugmk2SyWZKR82Xnytw0DC6O+3ztui/znR/17ocopcguX0rbC7O1UsBJDaQPn/DvQ2mp/54EopRqQVeWDjjeiAfSJ0XG/y3RaWyUSqUYOHAgbTtepegMAMPWvAfCiOOhePyvv+NT+0kgUkraCj4Vcft1NabG9Evhe66u4ecy2IkUph2LGLoSAi341756MTPef1H5c3tv85WdWRSKYiGP7cTKzncCzWvw3RJVQ0bxqt/z4Xl8/gpyromUmp8iujVNNURUbwPDZMPKxfsso0ydNo3hRxzNlnatkVWT1qWPxH7cCI89fBwvLVlJxldYjsO2pvXUD6xl6j5Ihn0JwxDc/vOfctZ7LuDoY4/HNAxKxWI34pxBqVTs8RkpJfF4nDPPOquXPpdSSje6wxDTNMqrrBnf+A6XX3wh9SOHs2HjJoaOHE3/EWN7fHbTmlc4ZPoUglBqTS8EpmlSExM9wBcb1q9jRG11+XfP8yhks6zesImzzr+4x4pFKYVcNx9kgOsHZYZ6Ih4ju3E9n7/kDAxDlOXrvUBheCXCHWux6icBCtuyKHk+Yae4ZZRIaipSfOrDH6SlaSV1CZO4Y2HHtDikc/RZ+0weC55+lOClR/n5GeNww4N4ctU2rvvyl/jRTTf3GMTr6+v5y+ptJO0RHFoVwwJWtJV4eksr4wfUkWvfwy6nkouu+nKPz7nbNpFbPBdZyJMYP5Hk4KEQNIEfRBKmOnwElgFTBlTtExm29fe3s+f5Z8uw8/YXZlN32lkM++gnX/8L9TbG/3YrDCHEV5RSP94fofAtEwn/22LmzJmkUikqK/XCyUr1QxkxhKGdLSQWhC7ZV56lIz6Mk77yJ44fP5QvXTKFQVW6qf7L59dy76JtBFJ7cxxfX8v3LzkCax+aSvPmzmHt/b9j0JmfwEnGtHNeroNgzzasXAuBVKQKu5hx+flMn77/ZbppCC1fHoTEkzHoZBNE/3T2BOoPndjjc69u2kbl4JG6IS/Ath1QqjNtRGQ4RamQww9kDxJlZ6zY0cHOnIfveRQLRfZ0GKxcv4khsp3p06b2er8QghOOPALQvJO2MaMIpSJb8knH9i9g+HrxvssvZ8aMGdhOjF//9vfE4gli8RgylGSzmYgh3wV3tSPS5emnn15+yMsqAZGXSedI1X2VdeMPbyrPuI8+tjeX6/CDx2IYJlWpdI/z0IoEAVg2Mt/OiNqejW7HcehQ8P3b7+KxJ/bykAh9kCGuF5SZ8rZlYRkGJ0w4GAKfXC6HH/WWDMPA9XzSuVZ9XoaJH6/EDtvwwy4SZVXCQUnJUL8ZNWwgCoE1eAxmZT+soQch4r0lcmSujUEb5jFsYA2+VFgGXHD4cI4fUcfm5+/FH9kfa4SW9rnug5eSXj6LLpl/xUs723jvF7+23xXqwjt/Q/zlRoj002LLF5IaMRqkxN20HqmInkOIG4CCAYk4j6/vuTIubFjHnueeAdPAiGm4sFKK1qefoO6U00mMGLmfb9LbF28jCuudjOvQirvrgbY3s4F3VQLp1L8C8GPV5PtPICzlEaaFEbnFKalIH9KAYVm4hmDW+hzLfj2HP1x5ErNWN/PXBVsjIpgkVDBvfStX3tHI7686udf+fvGr20hPPg/XDzAjF8AQg9imRfzj97/s8d4glCzc3MbS7RmStsmU0bWM7adLKJOHVrG5rYhlmYRhqG9aJCtidQoCSskpp57WY5vbN6yhesio8he90/5WKYlbzBMGAWEQYFgWn/zIB2mYegKgV2p3/v0fHNpwLiPGH44AAs9FhQFCGlhOjHsfeB6h5H4Hi7aCx7pdHbiuWyYNOgQcd0j9ASeRzkH+29/+NueecSoXXXIZRxwxgY1NG3j1lZX8/Fe/xnCccjM+FotRV13J8CED6chkKZVKUb/EJJVKYVlW2a61c/v7Og/NDykgPe0V069fHclkspx4OyOdSqGU7gbIjl09Pt8Z/epq900+NC1AUChoRJSSknRFSpNSA00cra6uRlVWosKQUqmE67p05Et0Ctz0P/4sci8+DMU8Qiks08LodLCM3mMA7vb1VE46db/X31u9CEMo/GhuYhkGCctgVG2aGqfIzsf+jKoZxNALPsmQpsXkDYEb9Y0c2+bzUw6jdsQAMrMeRuY7iNUfQvzgiQjTYvYzT1Ox8DkN7REGfhhSymZh8wbqTruQltbdFDJZ4kJ1tdQFTI7BotGjehxndsVyVBhEytnRW4VWDsiuWPpvSSDwtvFA3snYJYQYCXwM6D2A9SH+a/SI+xL19fVluGQpPSJaMEtk4BKWcoSlHIblIEwbFfgYKAwV0lFw+f3sDdw1f1OZdBeRuFEoVrdJnn72+V772105GlE9hFBKfLdI4Ptg2RQPOwsv6C7UJ7n+wcXc0fgaL63ZxqxV2/jJc6t5do1GovRLOQyujOHEU3obqnNwEJoYFklLL2uDD3/2izQ2NgKQ27SKwPcxIi0lP/B1yUSGehYoBE48Qb+KBKefpEUZGxsbueF7P2Dq5Z9iyOiDQCmtoGvHMGMJzRY3LUaOO5QHn3qOV3dlWLU7S3uxS1o7lIp1uzrI5XJ4nkcQEQWLoeCFRUvf1L1raGigsbGRe+6+m13bt/Kb237JujWr+J8vXsvwQQMZUFdLXW0N/epq6FdTiWVqqZKKdJrKykr69etHTU0NjuNgW1YP0uK+QilFkO9AugWQmqFeW9cvIl92jRydcu/rVkXSRTIsf15FbPzOd0897hj9N98lbNlCuG0Vu15ZyCOzXyL0PSxDUFWRwoyOLRcZSiEEIkKfxWIx0ukKvv+be8r32UhVUzHtMmomTqXqoAm4vq/7Hd2qEgqFLRTLn390v+cs23ZhGoZezSFIWEZZskUqhR+GyNZtzPvNzWSzWUIFtuNg2bZmu/s+bffeTn7RLIqvvkz7E3+l9S+/QPkeT/zpt/poDL0a7vSRd4tF/B2bqDx+OgmzZ2LzQomtJO8d21PzzYzHYR9IPwwTIxbv/fq/IJTS3/O+/PwHx6+BJ4DxaFmTzp/F9FHm5F2VQK655hpy+Ty7rWG0105EmjHMZDVWshojnkaYEUFPSTofeyEE0vdYvKmNvBtGKJZuEXWkf/X7u7peUoob/z6b+IQzCYVFYMYRsTSGE0eYNlZFHZ+6ez4tee2bfffTL7K5rYAMA4QKkb5LLpvlH0u38NuXNvLz2RtY31LAVwbpeIytcx8m8NwIMimQvo9fzGFYFpWHnchtDzzNTU8uZfzFV7Fh3Rp2bdkUmVQJVsx9jrZtm8AwMG2bfjG48Mgx5VnpzJkzOea087BiMZ2sBF3XwrIi4pxkyIiRTLvog+zKeuzMuizb0UHTHj2Lznu6lt+5IhBoMy3Ltlm7+a2RbBsaGrj33ntZtGgR9957Lw0NDRiGIBGzqUjESMacsvxIwfXIlVx8qVBRaSgRj2Hbr7/wfunFF3nsoQfJ5/Nkc3nyhTxt7W0UCqXodncj8oUhnu+zaNFCAAre3h4VqvN/TD/jLM052bEGv30XbS27cMISZ0w5ltq6WqqrKrE7JcqVIhF3yolI3wC9Xz+UhBjMnDmzvBfhxLFGHIZ9yBRKrsv+1DAKa5fivng/7uInCFu29vibWTuIWKQ2YIhOyRU68eYYwsAyDNwdmzAM0ePeCgHKdSkVS7S0tdOey2mgw65tFFYuoGnbtl4ukUbkEmkkUlSfci5mPIEyTLxQkvUCckEIhsDcuLacLAGqjj1BK2R3k/5XQYAwDaqPPWG/9/XtDtnHn//UUEr9Qil1CJp7MrrbT71SanRftvGuSiANDQ0cfdFnyQ6dhkdPNrYQJmYshcaCyh5SE6ZlUZtywMvvW7lGhmxZ3aWpdMcjc5izpUBnn8IyDQxD0OmKIYA9uRI/fFgn+WeWruthcCQM7YEe+AHLNjWzp7WF9vZ2XN8nI22OPOsy0skkFTELv5AlcItooFdA5dDRjD/lwgjvHzCofhxmupqffPZ9PPC9L3DhUWP48iWn8LEph/CxEw/m0uMPJW51zeaampoYNHK0HvQiMybRedIKTMvGACqra1FKkuloKx/f+t0dlPywPCvfu1QiBLTt+VeKOEeHqRS5YolCsUh7Wxutra20tXewY/fu8t/31wBdtnQJI4cMYsoJx2nmd6oCw3IIgrCsKVUolsgVCuQKBbL5PL4f8OSzswD4xR/+Gp1rxPuOBteXV7zGlKkNyPad+J5Le0cGpKQyGcdxbAw7hrDj5QmMUoqY45R7GlIqOnJ5Wjqy+GHIyCED9+lMCLB6Z0ev1zrvxNh+aTq2baR9w6u0PH8vrz39z/J77HFH48QTVFekyjI3CPD8sJy8hBCs292qAQzdtx/14twInCClpCOTJfA9Sq8tIawbTC4IetTMlZJgGFQcMxUzkQDDpBTq/kjKsamMOdiGSRHRI1naNTWM+uKXEZZNJMOFsG3q/+erWJX/PmBo577f6Oc/PZRSb9rW8V2VQJ57fhYv7HAwDBPDtAiDbvODTsRMZree9UQlA6kgkUjwvuNG4C59uNuMLPpXQOuyZ6mv76q7Prhsm1aalXqGZBq6FIDQyB2URIQB69p8/FDS3rxD5y3DQjkplB2HWBonHieUIabtYMSSBBL8MGTVrix516PkeeWBWkmFROAkEsRSFcSSFcTSlQjTJJZIcfZHPkv/fv3Ktf6YZfTwLgdoK/pc8vlvkh5cjzQdMEzcYoHA98rXqH33DjYsXwRCEIaybCglw5BsLsuLS5aTdkyUkhjdywxCEPgBW9b2XSrjzYYfhLiuS3t7h74+gOe6KAS7mlvIF0vkiyUKJbeHqKBSigG11RiGQRCGEBWBbCeG7ThIBYWSr618lSo3tefOX0TB1SuP+x9/mlt+e09kyapXKM+/tJjPfSdyBy3lyRd0aaoqlaBHjhUaUq3/s2fydV1XS60Y+nu5ZtO2/bLGkxMaKLp+N+mSrvMrlErELJN03CEdtxlW2Mr6J/6CbNuJSFWROO1DxIaOoSKCe3t+SMHV32OBLrc+sHITf1u1Qzf8Df2DlLhBGPFCNDrOMARuyaVt904+NshGCVCGQChdBhaAO+kkYsNHY1VUERsynIQA2xCYAmwBcVOw2jd6JcuqI4/h8Nv/SP0Xv0L9F7/C4bf/icpJRx7At+StRSfXpi8//83xrmqi/+K23yIGnY8wRFktNvDCyAxKEZQK+G27qPB3E9SN1dLbyRQfnjqWMw4fxG+NPWxY8DfsI87BTKRRvkfzwkdomfMXbn/ggfJ+XCn0hQ19zf0QVg9aHb5bnqUDJNs3IxWIclOwa7YnhKlJiCJqyir9erHkoWwzMruSSKU0RNMyy0QuJcGwtMJu7dB6Ft637xkrwJ6Cx7PrWhhy8BHk83liIolwEoSlArJUxBCCTa8u5W+3fo8LP3wlAKZplCVLRITEefSRRzj52MnESm0UZRW2bWuUEvDsI//kwnPPLO9TSsXunEtH0UcpSMVMBlbE35R3e/cIpcT3fF1aiWjRhjCoSKcJAp+2tjbCMCQej1MwTepqa3QSDkNkKMEA6UuUjJfZ+rFYgtAv0Z7N8vkvfpkzT53OyJEjeG7Oi8x9aQE333wzoPtsTzTOY96SleXjyWQyXYO9aYHSirj7XM0aJthx8Evl0lfgB2SzOWzbxrYsVm3ezqJX1+6X0HnSyafw+1+tZIy3icNHDUFKRdF1sQXUplMRaqqLbzHIa8F96SHMQaOxJ51C8hQtxTT/qUdJrXiGlGOX7+8fF67l7Cs+zp133smrrTmmjRyAV8jh5XNceuTBJEwj0irTPTYVBMjd2xlVEdccG6XwUfx9YzvnfOZapp1+BhB9t30Xtdc1kUIw0lbl61favJH2ec8jCwUqjjyWiolH7hOO/O+I/+7U0Ld4VyWQzRvWYAySSKVR/J2hm4YS2zQZkJI03v419uRdWrIeQ2sSpGIWOTfgso99lh/f8A2KG+aze/ducrkclmVx/fXX09DQgFSKOetawE7gYWMQYPolfPTgjlIIP0LbGCbWni3YpsFnP3w5M5e1k6wd2HVMSsuCOI5Thuvq0ANdyXeRHjiGwrBtiu17SFdV0f3NCi3hbVoW7Ts2v67O0fKdGVzPp5DXSJ58poN4Ko0ZS+BIjyOG13HpkRfy5Q9dRMEPeWrZBgzTjOCzYJgmgefxwjNPwI3fYurxx9I4ezZPPjebjmyWUradD1/xgR78h6XrtxIKUyOkDAM/naboh4zpl8Y09jW69o6XFixk685mkqkU27duYfzYeo455ljcvcylbNsGodFOMcchnkgQhiHFYpHlK7YyccIEXW60tJeFEIJsPk8iHse2bYQhWNe0id/+6S4279jFD2/9FYMGDaK+vp6bb+7iSJQtAIB0Ol1m73dCpI2qARitu1E95NQF3ZciwnLwI46QXT8Js2ULVWIz7R0ZHnjuJeas2vyGrPExh03kJzfex7UXTOew+iFUxhOI0CtzgXqsTNBJjuxSdrYWmHja+QAcd8a5NDpJ7rnnD2Ram8nFKvnYp6+loaGBSZMmMXPmTH7x/CJ+du7RjDhoMK6UOJZJOhnD8wIKRU+rPMtoh8JACUjEDcYPrisnDwDluQRtLZjpSjKZDo1yjD43KmZyzaev4cU7foGY9QRIiWkYxF54nuqJRzP8mi+/I0nkP7s//u+Jd1UCGT1qJJu2z6c09ESU9MHo1geRISr0uPZijUaqTcWoTcUIpOTnT6/hkaXb9Irkguuxti6k9OyfMU2TZDLJ3LlzmTRpEkvCITy/phk7Wa0lTISNEtpTw7Qs/QAbFioMCPLtfPrEUYDuzdz26lN4+Q4Q2mRJhgGhaVJTW4sQBrpAFdXDfd1AL2T2MOc33+FHN93CN++4jXP/5wfdCG3dETiCV2c9wvXXzdjvtdlT8CkWumTuAfxigcA0efz27/O+u+4svzdpm8x79F6mnPdeYokkpqXF+jauW8uAIV2ImYZp02iY1iXq6QYhm/bkyXsh2Y42ECaB52IYBmEY0tHeTlVVFR1Fj9pUF0Rzf7Hw5aVU9BvEEYOGo1CMHnsQuWyOxYsX02/gQBKJJEFENLNsfYyVFRWY3by0E4kECxYuZOKECQjDJBaL43kuQRAilSSby4GC7//4JjZu3kIup1cCd9999z4H8Ddk7yerafZMKvGR0b3aF6w2Fk/CwLEYiQoYfiip4YeSAq486T0ctWA+P/vVbcyYMWO/TPG//ul3/Opz7ydmW1rkUilStoMKvF5AEIEmbCop2bzgedrtqvL2GqafTMP03gjPTujzD6/6MKP6VRJKhR8E7Cm62KZutv9+5WauGDsQ09x7mBEMNXpqsQrLRlg2hK5uPkeHaAlBmx+wbtFCJi14JuopGQRSUsrlYNliqpcupvLIY3sd478yFP/95am+xLuqB3LNNdcQNs0hvnUOZlAAGaBCH/wCFaVtfOvMwVx0Vs+H5c8vbOShJdsIfJ/2tjay2SztNYdijzmB+hPPZeAF17Gt/j185c+zeHLlNkwBqYRD2jEh9JChxG7fwvHeqzgrH6djwSPYrz3Ll46r49xTux56M7sby4lhGwLLEFimiUSwY9MG3D07UWGIXyoQlHK6hwLsXjaH+lGjOHX6NL7wla/Taeyjyoxz3Qht27WdC8889XVnrEnbREG5vKE/rlc769eu6fX+c6ZPobWlhZLr0tHeTmtLMwNHjOKSz17HrMbZvd5f8kNe25WlNe/jBiHKjJFIprAj18AyrNPzKPlvjF1RSmElK3S/ItBSLWEYUlFVyYYt22jdtYuVK5Zj2zaWZfPqK6/iuaWu5KFUGUF02mmn8eL8+VxxxRXc+IMf6vp91B9yHIemzZvZ3dLKrl27GDBgwBvO/veFFOu6pIJxR53I2rzJj/90Px25fI+GvpSSXKGIJyPzqM7zDX3CTcsorZrHMLWHn1z9Pj56wens3r2bGTNm9EApARw1tLqcPAD8UFEM9uUDoqJeh49CS+LPnDlTT1RybciO5r1WSz2jVpa0hI1haASZEHihxA0CrvjA+4jtpV8GOmHlzb0UoU2TyhNO0TpvhtZUi8UcbNumMePz7J9+V04eoEuSGgZcIPvyS/s9vn9ZKJ3k+vLz3xzvqhVIQ0MDP+mcHc77GQfV1/O519F2Ukrxj4VbCANfCy0KgWkIvDAkNvH/s3fecXZVVd//7tNunZ7MpPcCJIQQQk8yoaOAoAIW7CgiIKjBgqIP+CgqiDWAAiKoKEXpLaFlSEhCEkhCep30MsmU2++p+/1jn7kzk5kUmj6vsPgMSe7cU++5e+291q+ci2dZoUWqxKioJe9K8k5B9SRcB11IovEyPn7WqXz55P2XjwAumjCYhzbYaGZEJQjDQHgOudefZfvWdYz5xDWY5b3Cur5G69o32LrgBW4Na+8njh/D5je24AQdiJj2VcjOxbNpbHyzi1nWvnFEXRnb9rQo17pQVVVoGitmz2RwD5bBRxxzAntWNFLI50p9GfyAeDLJs889z9T6rnYCO1JFVSLLZvF8H01APBYlEo2Rz2YAlURcxyVqHnxe4wfKsrabd7kfMHT4SE48ZhwNDQ1c+41raGxsZPDgwfz+9jtK79t35j9o0GB+9vNfcO20aXzkwov5w+23MXbsWDTdoHe/gUyqf1s8q/3G5Cn1TJ5Sz4y/38XJRx2BHwR4vh8irgI8PyDSiXgYbF8FuTayuRxCaOia4NNnnMSuljSz31jeTe7j6JGDMXUdyzTwfdXgLvo+hqaSRdQwSlUzBUVWx56/eS/FliaKL9+PzLYCGsIwsSaehV7bnaDnRRP4gao1aZqGFVoA67rO8BOmsKFpB/rW9fhSYrT3GgNJn1M/0m1fNedexIN/uZeTepXhoxLN7KzPUt8kk0oj9gcDjsa77evfEf/tyeFQ4n2VQOCteXr4gSTv+OTzuRDrHn7jggCzvAqvkMYKOQVC18M6tmos6xGDwHPJ5zI079gCdE8ggZQs25Fm3Z4s1YMO42NyFf+avxIvVoXp5vn4xGF8/LK7AJUQHn/pVf755LM0LltEv+pybu1Uex9UGaNfZYINO5vRDEPpIUmJnW6hdfVCdu04MP9iUGWMPiLPZkeoVYGAVa++wKuP3c8vb7ml2/sLro+m61j7dIINM4K7bycU2JPKkMnlFXpJ03BcB8dxiFhWyXfcMAzsYpGK2P5l1NtD0wSGYeC6bpdEIDSBYyt+zb6f9c6mJmzbxjAMzLDs1i5B7jg2pmFywUcv4M4//pGf3PSzLtL271U8O2suxx4xsks5RNM1hf8MxRyla0OuTSHfPB9NVzwXU9f40AnjWLx2UxeUUpBp4bCBfdB8ZRNsahqWoZPKeWjxcp6YO5fTxg2jOhbBdl1cz8PQNZ54bTlzVm7ntk9OIbNjC0XHRTd0kvEYcv6TRE/7LFqiosv5j/vIJ5ELn6TM0lUZTCqkYFBWjdlvKKMvncaG235MMrWnAxZcVccRZ53b7V4Iw2SWXsHT6/cwsFLBcWstjb7SZkUgcIKAmKaVjCraYcCVnbzk/13RTrB8v8f7LoG8lTB0jcG94izPpNA7DVK6FUUGXkepSNOhfXZUIiIq4yHfs1nw6J/goq5Jy/ECbnp+Dev3ZBXjVteIGAluuvIShlR31ykSQnDBaZMYPeYo/vnmdppzLi8XTap2pBjXrwIhBBcf1Y/vNDxP+dAj0HSD1g0r2DrvOTKp1CEZBZ178gRmNTTwp3v/ytrVKxk0oD+/vKVnZ7iyiBHy+MGMRBUaLPDxHAdC6Y/OsXP7NipqeiND5JmhGzS3tlFRVlbi2ixf8joj+vVG14Yf9Fw1IWhu2k1NXR8CP8DzPVWWCgIqkrEu4obtUVNVRTZfIJNOU1lZWbqvrusSBKqm3X/AAJLJ5H45Fu927EzlWLp2I+NHD0cPy2au5/Poy/P48tHhqsf3Sk123dAJ/EAhCQMlmNhukNUe/sY3QNORvouQAolE0wTJWJRmkeDZ9Xu5b+5KTCEZFIPKZJwFazczZmAdt11Sz8BelbiuhxtK/afSWSrLwduyEqPfSIJ8Gq2yFi2W5IQjD2fP6pfBKZZKVaZpkhx7DELTsLeuJ+oXyAsNXwZoQiPh5kjPfJDK8z7f5V54rXu57sP1zHz6aQZHA0YmLLW6KS/jSyOmcuebjXyhrhwrVM0WSOTkM4gN7Sp6+e+K4AMc1gcJ5GBx9Rmj+NpduwjQQqcFLWSLBx14p7Dx7bs+mt6xUpFS0rz4JYqbVnbb74zVu1mxvZViIYfv+eiG4mv8btYGbv3okT02VhdtbeWe17aUHtvdGZs75m6iV9yiImZy3KBKLpgwnG9fexWJRKJHFNDB4oSTJtHviGPwpaRfeZSKaM8uiFUxk7hl4OrRDmqMriN0nXM+fFa39z/zz7/z6a9eEzLZpfKjNwweeeCvvPT4Q6Vm8OSTD41J/Oq8+eiJSgzTwoqbpdWEY9tolTVs2tVMn5pKYp184xUTPYpdLJbur+/75HI5olEF2V21cmW3AflA0Vms8e3EFVdcyXe+/W1OO+lYph43nlQmyxMvzeHLV3QSQo3EVAIJAhKJBOlUmiAAUxcs37AZnQ4hTOm5yHyKbL4AMiBu6hjhysAJJN/5wwMlpFgikWBVm8P6Ra9z6anHcOV5U4iEPSLLMjFNg1QmSwDYdhF9zQJyS2YpiRUZ8Oq2FKN711DturihbYGUEukHiJULiR9/FtuefxQ/l8OTqkTpS0kqk4XVSyg//SK0mCo/pV6dSduMR6iRko8PrUUnoOC4pHOqJxL3bC474Uh+u2EvkZ07GNSnjjMvvYwpZ33obd33dyM+WIF8kEAOGhMGV3PNCRX86rHXEBV9MB3F/PZ7jUSYCXzfoROoBzebpqPSFWDvWs/YoUPZnS5y19xNvL6lVTHTpacIZUGgShJ+QD6TZpuAPVmH2rLuKKQHF2/v0FhChiq7gua8Q2sqxcYdTXh7d/GZz36WV+fM6YICOnnyZLa2FdAE9C2LdvWER2lg/eOpmRxx5kWIkN8hg4BtS+fx4WMO67YKEUJQXVnJrnS+JNrn2jamaZAYMKrbubfu3MqLT/yTU879mJJg0TSWLniVLSsWs2jRIcnudAlXi1BZXkEumyMLJBNxTMvC9308zyUIAprasvStViucvK1QT5aus23rVjKZDEeMOQLTtKioqCgxvk848SQeeOCBgyZcGfh4hZwCYYCSqIkl3jKctL6+nptvuYXp06cz81d/DD+vq/dpvGuIupHInWuIGAYVFeV4ro2p6Zw+8UjOm3QsVlWlSh4hXNYwDQI/IBc2znVN0JZ32LBxYzek2JmnncrXP3IMCEnR9YiHEipCCKIRi0LRQfN9vHyGVCZf6h+dPLCSbFsKL+yXqcmUmlbl83mCQpbWHVsp0yk9b5oQBAHkCwWCYh4RidL8r3vILJodDsiS9jsYtUxsx8PxPFwhSGZb+fuf70FP/udtiNq1sN7v8R9JIEKIW4DzAAclJfxFKWWbEGIIykpxTfjW+VLKy9+Lc3juhVnceu8T7N7TTCxqUqwZi2uWU0aWq88ZyyUf6fAC+fS5p9C/TOPWu//Bjn6nQZmalctA4mtR4qaBrwl8p6hKWwiEYRK4RczWTXz5x9P59qPL2JspYBdyyq8iWYZmRBFeIYTIqy9WoVBgf5PZrO0pFjQho10AqJ6CHo0hEJgDRvH4v17ihk7ggI3NOe6Yu4mCbZPP5bALebY3PMKln/hoSaTwh/97E5/44W/QNA3HLuK5BQzDZOD4k/jF728C6JZEmjJ5cmmVMIXQkDLAtYvs1VV/4ZVXXikNUslkkqV//iPzX55Bv4GD2b1zB3ubdh/UQrXo+rQVHCV9b+mUh4Nbda9eeJ6LQOD7npKqByLRKH7OI/B9HMcmnbcUnzz8rhcDj6GjDmfN8iXMnzefqaeqz9m2bbLZLL169eKGG39M/T4ggM4hpcTNpfEcm0w2i+f5xGJRtEyairr+b3s1MrBvHb2rKnr8nVZZh7SiBC3bsIo5zKKyrfV9n7Z0mmixiL9nFxUxC2GYJMvKQILjOuSyWQSCJ19bztChQ5Gey8n9k5zwjYsVAKKqD01L5yJQBNui4xKz1DMeMS1cWwFCckXF12lve+maUPYCRaeL5pOlCQwhyc15km2ZPEdWJ3E7TdcNTZB3XPTyKnJL5pFZ8loXpJbKQSoRRS0Tx/MVsCDwu+hfHYrx1XsVEvA+SCD/MRjv88BYKeU4YC1wXaffbZBSjg9/3pPkcfuDM7n6wS1siU+gMPRsWvp/mHykL9KIkrHq+MmMXfzl8Ze6bFNfX0+/0y4lliwH30UEHppXBNcms3k1lx0hqCuPYZoR0DTc1F5iyx7hztun4/YeRWu2QCGbRoYquE6hAJrWyUJHiRU6LTvpneyZAxH4njKRor1MJjA1LUS3KGy60HSOOO+L/PTXSi4+Y3s8sXIXedsmnU7jBwGRRJJBp3+C73zv+zQ0NHDvQ4/ysetuwYxE0U2LWLKMeHml8hjXDUYfN6WLFlF7pFtb0XRNIdEECE1D03Vy2QwvLlrOmpTklE9+mZNO/3BpRuvYNiuWLqYsET8oHDZVcNjQ1MbOvW3s3NPMxh17WbllN34g0UJJD+hgwXcuSQuh5NCDkL3vuA6tba3s3buXTCZDVa9aBg8ZQj6fx3FddMMkWV6BBEaMHLFfrSwA6Tk4dpHWthSBH6DrGnbRplDIs2zJ4v1u11M0NDRw9x3Tuembl3L3z6/nx9d8iXKnhdfmzu72XhGvQB8wBqJluK5HW/h56pqG7brE/QJuPgO6WVoJWJZFLBrlleUbeHDWAq668krcJc/jb1uNU8iTamkmtWE5lZWVofGYEZqNteeJAE0DwzAoj0WoSsYpjynHyXapDmFoWGH/Jq4LorpazbWtWcqRfasQpo4OoTyJKqc9vdtG6Dq5RbOx3Q63yFJzWrT/W52LIQRZqaNXVJXu27Rp02hqaqKurm6/cOb3LiS+PLSf/+b4j6xApJQzO/1zPnDhv+O4u9sKXPiz59iZkWAmQxU2VG9DGPi+i6UJAs1g+rOr+Nz5HasQP5Cs3pHGLnQ44QEI6SMr+vH4vbfzz4ceYktLHgFYusaMFafyWqZI07o95ItOF5KeYxcxLAsthD9KqaRU1v/rd0x84jc9zqi2vDGbIbxjGQAAmOJJREFUwROndmEttzO221cA7X/XBo4FYFVTBj+QFEIHPy3kduiGyaBxxzF9+nTGXXQ5Rrtne/jA67pBorIKITSGHHUcq1+b1e1+zp/5BJPPu7iLz4Wm6QSuQ85M0LtfDE3T6DdkOHWDhjLzwXupra09JHRTICXbmtNksznltaFp+IGHHxgsXbWGyupegFRJohOU1w0HI2UspVYljuuQTinjKU1XOldNe/ZS17uGWDxRer+u65SVlVMoFnh17lwmndzhoqhq+z6+56pSURCgaR39LtMyMU2T5bNfZdzRh67JdN+f/8Qt111N1DJLroNDBvQlVyiq6xY9zPGcAsWwj9PO29FDiHmuYCOlIJcvKA6SqbG1qZV/zF/Nzbf8kslHjsJdNgvH80inM6VylCsV50X6PomoVSpLtuWKVJpK3LO9fKprgrKoReB56JaB7UI8GsFyPbBdco5H0VWiijKUk3lyxUbGD+pLi+3z2JrtXPaDG9V99Vw8P8DSO+RVpCjlD+V/oykElnH2hV1Uozubw7X/2ZN74XsREj4gEvJ/g0j4JeDZTv8eKoRYLIRoEEJ0t7wLQwhxmRBikRBi0Z49ew7pQGf9z7PsSHUiU7UrpobRXn0V+GS1rqWEna15fD/A87tuAwI9cGlsbEQTgiE1CVrzLl+8Zz5/enkljy/cwMJ1uwg0PeSMqNANk0K+wKaXH8HPZ3ADgSMNBp73NWqHH9HjjGrZA78mtWtLeK50K3W1CzUGnkNVf4XZt12lk6W4F51WO0IjWVHJnrYM5b3qcOxOyKlwUFFJSaJbMT58xfdpzjtdjrdrzVJWLpiNrhtomo6uG+zdvplIJILj2ASBj+95BH7AmOOnUNd/QBd0k+sHePshqTleQC6fLyUPCFc4Ava0phncp4ZYLIZpmsRicXL5PEHgl5wJDdPEMNTA125/q2lKQdbQdUWCLCq4b5fVhhCYpsX03/++y/l4jk0+myadSpHLZTFMk2QiqRwKy8tJJhJELIuzTzsVr9iVHCilRLoOgVPsRPJUMbx/LZZplJIHKBSWaehQzPZ4b0hW43f7PNWfRccmlU4rORZN4Ptq9dA+GZG5NpABuVxHLyPcAyt3tKBrymNG0w2EplNZllSIrk7HkVIifB+kJGe7+BJacwWkpuFrAjeQoU6amhzpus7a1iwX/ulJHtrlcNkPbiwN8vGxx6LrGnm/434JlATPs2u38OSardy7bCNLDzuZkz56Uek97WXRLrfl34ieQ4IfHNrPf3O8ZwlECPGCEGJ5Dz/nd3rPDwAPuD98aScwSEp5NPAt4O9CiB47ZlLKO6WUE6WUE3v37n3Q85mxeDuZYs+fZqmMVEJPCaJ0DJb3v9rIZ26fi237+MLCIYonO5qG2rZFJdROICU3PrqYTDarXNNkgG/bgCDQLALA1yJgJdDMCHWTL6ZgVeKE5LpIr4H4x36CsureJBKJLqWjb0+bxtal83AKWexchmIm1eU6giCgmEkhgZbNykNhcFUMQ9MUs32fGdOudcvp378/sVhM1b7zuVLyaA/XLoarLp3nl6zrsv0VV1xBJpOh6HrKYc71SFbWEIvHSmrGHefmU95LaUflHZ83d6RYtLWNhVvaWLEzjb0PS1pTI1WXpAtKc6tp9y4ihs6Q2ioG1fWiX+8q0nt2cP89d7J500aKxSLSc6mrKsMydMVaDldquq7jBz6zXnwewzTwfU/1oIQoDY62bdOW6ri3MgiwC3nS6TS2XVT+436AaRqUJRNdEF35QoG9u3Zy4//8iIaGBqTv4rXuJL9nK3s3r2XX6iX86uc/LU0MRgwZjL6POZKUEss0kX5XuY/SPajuT852MHQdXdMwdTU5aUnnSkZaWul6NWYvW9fxHEWTEErHdP6cHc9n7qa9pAqOml0HSmxUaBpaNI4UGtmiQ9ELcD0fKSFnu+i6jmEY6IaJrmvEEvFuEGopNGoHDGb48OHdmPnJE06hEC3D9Tzynk/R88l7Pt95YRG/W72LJZUDuehnv+Xyad/ucg86m8O1x1tBz73TkCjRzkP5+W+O96yEJaU8/UC/F0J8HjgXOE2GI42U0gbs8O+vCyE2AKM4RHesA8Xyza3sWyffN3RNEgSq7vqZSQMB2LQny10vbcB1XbxiHikMhGbgY6AJF2PXMty1DVz1S0W229FWoDmdR3T6EgnAyebQNIkRjYGmlfSsNDMsHWlRpAm+Z6PrJkHdKJJOocuM6pprruGZS68l8DwCz0MIsAsFrGgUpMQp5LDiSTTdYOgJZzD9udf5si8YVjeSNa6joJ0hHHTb4jns2drI975xK63lyqa1kMuSzaZJhigXp1jAKeYxTRMpA3a25Lrcr8FHTuSkymHkc1kc18MwDCp71SI0Q8FN02kCQm8VCc1Nu/jG169m+a40nh/geS65XI6UprF2YyPVXltpcLEMjT27d1LXbyB+OJC29zVWLX0dLr5AlVJC0uHxx0zg+GMm8Oq8+eTyOUwrwobtTcSiETZtamTwkCEIBIVCgYf+cT9vLl1CW2sbNTU1BH6AYZqqUesqtFZNdXXpOn3PwwsCkhWVBH6AUyySzhUpS0Qx9ZCwaTtkMhk0XcMyDY6bMJ5rr72W5/91vyLxpZTfuWEYfObj5/L161QJ57CjjsF2HDVYt8NgZUA0GkNYXRnWDQ0NPPrg3zHx8SWMqK3glOOOIl90eGTWAjZt38nPv3oRUctCE2A7Lhu27eShlxcoEieg1fRHWDGFcHI9hBCYuk66YLNuy06SJ47s8SuimSYRy1MkUMdHohwKtVDnSmgCx/MxLR3L0Ev+7IYmKHoB8zft6ja4v/rsk2RmPsSQhIVWnmB7W4bnVjbyr1Vb+Pp3r+ORAygnHEy08r0OCXgfVLD+Yyiss1GG7vVSynyn13sDLVJKXwgxDBgJbHw3jjlxRC/alWplEHSd2coATVMzBUOTXDyxF9/69BkAvLKqiaLtUMipGroupLLARcNd/Rxjkmmu+mUH2S7SSc21yzUjsHdvRu8zEDc0zTHi+yyuJEg9gh+4aLEKcj3MqL71mY/wYKOHGU9A4OHYRaRQ/tVWNIZE4BTz6KZJ7ZEn8Vhjit/W13JYbRmzlm1g7erVrJr9HAkvW2pip4suT6/eTcQyCQKJ5wcEvge+hxX2ETTDYPvWRqCDp7GhOadgu4kEuVwOz/PIZLMYlRVYpkV5ebkqH2k6ubYWrvnaZYwefyyNLXk8zy31JYSUROIJ7px+O9CB9irXfLZtbqTfgIHhakbw6D/+yjln9jw3aWhowKzoRU1VtYLy+h6FomTQ8JFce+VXQ6Z7gUwmQy6XIx61sKyIst51XXRNAQKee/opLrtMSdbLsPxnRWKqP2QIrEiEfDaD4/nYxQK27RAEiiGu66rck0wmmTBuLK5dxCnKUjknkJJELMptP7+BfL7A6vWNVA7pR3ksovahGURjUayyaoTVYc/6SkMDxS0r+eFXPlF6WFZv2My0399P095mEgm1Epr0pe9y7qSJDBvQl6XrNzNz/mJy+QITJqi+jNA0zKPPxJ7zFEbQjCYEK7Y1Mf3ZeVRHdGzXJ2KoElqXJ1joKlmCek46KQBoQnmC6JqGOexIIvZSnFQbQkDa9rl13jpaM1muv+HG0u4WPvYg/Za+hNmJNDu8VyUXHzeGpSSYM2fOAaV3Dipa+V7HBzBe4D/HA5kORIDnw4ewHa47BfixEMIDfOByKeW7YmFXP7YP1QmNlpwyA5K+H7LHJVdMKuOqT5xGKu9RlbS6GC1JFMRTNSzV67qmiIO1fWt5+J4/dTlO77IIEbsVJ1aj6vfhPpABtcWt5K0RmK6DMPejNivCUtSujT3OqM46ZQrFYDZPrNmDVlaDbmoMTAhevv8ORp13KZ0KciB9sBKs3p1lXL8KRp96FJx6FFzxiS77LI+aXDyuP9tSBfKuzz8ee5raEWNKjXllvuWxZ8VC4NOl7Vxf4rou6VQKEda6Xc8lnclQGY9iRZQRU1nE4MhxQ4iaOptb8kgpu/QlQPms1/Ub0KUJOnnSyQolNv1WUuksIvD4ypcv3e8gMfPFl/jE5y/F8zwIkWq+7+P7ATf85CZuuvFH7Nq1qzTYHDNhAk4IhXUdB9d1mTv7FQ4/bHRJRdgLYaOqLNPRL4klkqTbWtB8n969erFn794SkzwIAuYtWESvXjW4XoepGEAiHivJqNhFm4lHjaWltY29NgzrW6dKiPFKRKKqy7VtXb6QD598TJeSyBEjh/KNz32cSP/RJWKg4wc0taUZ0LeOsmSCaMQily90lXuJxOl32sW8MmsWr898lDOOGMRvLv0Isqwaq2U7ecdD93x0Ta2IEhEL23HQAkWnFZqGZhhUxmN4QVBCAQZS0rzmDZY0ZWkrH8Abi5cyZ/kahgwdyq23Xtch5e/7JJa8jKmLLogrTROUmzqnDqrloWUbevyMO8dbkSV6t+MDNV4V/ykUVo/aA1LKfwH/eq+O+9JPzuWTP3+W1btVf8PyMkw7uz9fvlCtNmorut+O44bX4KMhjJiaIcqQ5yGgefW8Ho/zjamD+PlLW9HileErAm/TIqZ97ix++NRKzDol1SFLg307kiok5GVbqfPbuGE/MNfzT5vM+adB3vHRNWjKOjTu+LgSlQsCpOsgpRLHM6wIO1JFxvXrmV/QHromGFylSianju7LX555lHGnnkMklqBt93bmPfpXpn31i1226Z2wWJvOhM1tdQ2GYdLctIt/3fc77vnr39E1QczsqPEnIwZaJ02n9pAyILV3d7cmaPsgIaUS4dP2Wdl1jly+EOpqdeYUqBQ+ZOiwEvprzquvsmT5Clat30jL3j1MOvEEJk2ejACGfuqTXfYZ+D6u65LJZCgvL+uEipL85re/59Of/iRVVVVEoxEEAs/3WLt+I/MWLMRzHYVsCoUSzbBfIKWkaNthryGgX59afNdlx64mctJg9FFDu61gTx43ultpyfcDjjl8BFf+/HbKkklOP+Fo/vajr5GIKV9z23H55iUX8IUf/pIJA2vYNu9Z+g4dhdZrIMKwGBi0cOxpE0oaVYIisrKK1ubm8OZpmLogCAIyhSKWJkhGTEAq6XU0LOnjuB4Fx8UPk/bRfZP88MkX+MK3fsCve3h+vT3bMWQAdHBK2iOi6/SPin9bL+OdhP9B/nh/MdHL4hZP//j8g78xjBeW7eSaPy9UsFhDQ+o6ASa6bxPZ9BID+/fcvP/ImVMps2bxm3v/xc6WDP3LBN+47AvU19fT+56/01o9oLQCkVIikCFsX4PAo2bzXP7+938c1JkvbulsbM5x+5xGIjV9AQGajojEkHYeKV2iEWu/vJL9xdT6egQwffrP2bR5M0MGD2ZaD+WBw+vKWLpuE9EQCqtm/B6Lnn6YjRs3kox0f7yq4iZRUycSieB5HrphYJgm2XSKtkyOLVu3ctFFF3UpR2Rslw07Wyi6Lr7vs275UobWVlE/pStIr5jLUipTSolhGGi6ThAErF+zmmMnHMX8BQuprOvHmYOGYug6ruuxc8d2Xp0zh8mTewb9Oa4LQtCWSpfkOoQQrFu/nqOOPgYZ+LRs38W8ua+ybOUqVq9dTzqdJpfL0ZyzGdCrkmKhoIyphIZEYhgmMpAkE/FQj8shGrGIAuvffJ2RR03scg6JeCyES3eMuIEMiJoRdu/czi3fvJTDBvUhomso6osimFZXlPHiXb8gn8sR2GnsLSswd29kSatgTJAG2lfIlK5L6gaJqIkmhCq36kpePamLEGfSzhBRem+60PBsp7QCM3Wd+tED9w+pNSxE+F4FD+64rABJY0uGq676To+fxf+V+ADGq+J9lUDeanzjzwvVl1FKAscvlVuc5u3om17jqgOwqE+ZOpVTpk7tvs9LL+Ha628kfvgkqBsN5b0JPAfD1Ak0k8D3SI06g3N+O5Opg+Jcd+HkA866H1u2Ey8I0JH4QRCijQSaFSUWj1MRjzK27/6lH2zPZ2tbEV2DQZXxEq/kUMoDCctg1l9+T5/DxjNgxGGk9u5izWuvsG3juv3OIDUhGNu3jFebtlNwBbFkGZ7nYpgWX/jG97jgM1/iL7/6CdOmTePWW2/luJMmsbEpRa5YRPo+QtcZPe5olr2+ABoamDR5CnnHQwKXXHIJs16YwdQzziaR6IB4+r7PLtvlldmziZZXEYlGQzKmkvwYOGgQO7ZtI12wMTWNiKVWSY7rkndcjEgEIxLFcx2KuRyWZbFq1Sq2bN0KgNB0Rh4+hh1Ne3nyuefZuXNnqUw2etwxBE6RzJaNRDsZK8ViMRLxODJQK0Xf80p9ngqrYzBvD8eIk8DG8bxSadE0DBxh8rnzz2ZY/1rMUPNKydwIErGOHko8FsN2HFpa26iuhLKWHVAe7d4wl5Lq8jJaMx0IpwRQXlGBzKU7vU2qprmuoWs6nueX+jwSQNP3C6k1auowKmoI0s1odKy8AYq+ZOqXr2bSf6g0dcghlT/8+z0+SCD7iXlr93TT+28vjWiVgw7Kot64J8ufGjbQnHU4cUQvPnXCYCxDo76+nl/+5H9U8++NZ0jW1CFqR5BL1hEbOh6BwtAHgeTFTXkij8zm2o/3LKtRcH3WN6WxbRvXsZXYXlk5hmkiNJ1ehstXTh5KZD8rmRW70jy3pqnUpzE0wceP7MeAytgh36cvfulL/OzmX7JwxmMk4rFDQsMYmsbk8YczZ90uCoU8hUIegcAwdGr7DeSk0z/MrKcfYfr06fz6qGMp2o5KHpqSOQ98n7FHH8vMR/5B/zETcByHQj5PtHYgTbNm09rcTDSqFHld18FzXfr07c/r81/l+EHDiESiGKH8vggJhCNHjSZXKFLIF9jT1MTMZ5/kq5d/jUK4ckjE4ximRSwhWPbmUm655ZZuSXJ/SVezovTq3ZtMmyoNGYZekpEXmo703E6y9OFDF/jKPz2MfmMmklv/BpICuibQ9QiGYWIOPIyPnm7jFbIlUcv9SalErAialqctnaGushwRON0SiBDdVWaztkvcMjA1XTl3Skm6YBNIQRzwQyKp5/lELA0/kLy0elu3+9NZeuSKk4/krLpYyVRDAHlhMOyqH3JYbX/+r8cHKCwVHySQ/URqH9Jc1xAHTB7/WriVW55dHYoewuLNLfxl9nqenHYKccvocaA58+Yn8LV2xd8OYtjMjWmu7eEYm1vy/GzGclx0hBnBMhUzOJtuwzAtpO+yc8Yf+N65PbO+W/MOz65uwnUd8rmcYvyaFvcvtPnWqYd1ARL0FI4X8PiiNbSKGi745g24jsvL/7iL2nhrj2gY1w9oWPQmc+a/xrKF8+hdVcmnr/4elRXluI6jJFHC9446aiKLGmbS2NiIE8J99+WDSOlzzkWfwrEd0ulUOPvVOf+Tl2AIyKRT6J2EDYMgYNiow4hEI6U+BGHyUPdb0Naq9lNbV8dHLvgYtm0rTa0goJDPY5iqrHPllVcSjUYPquPV5Xxdm2LRxtVcYtGI8rpXB6alpQXDaD9XVSJjX1FG3SQx6ljknkbItuEHAYWiTWb169i5DBXJBI7nEtXFvm0FCNWPAWoqK8gXihTtPL5tk4hGuiURu2iXElH7M5x3feas3sWUQRX4nk8gBJahUXR9HNtWemioFeZfFm5g5bamLvenoaGBn1x/HaePHsDnzpzA2MooqaKNqevoQqAh2ZbOsvvNFUw6/f+PBPJBCeuDBLLfOHFkzX5/57Tt35zJ8QJ++dxqJXoYPl8SyDgB194zi9sv7xmC6ukRtH1YygKJr0e6E7Ok5I9zG8kWigihEYnFQYb1aCtKEPgUVs87ICt35e4MjuuQTadLpQffc0mlXZ54ZQEfP+WE/W4L8Njra2mxAyWLounoMYOzv/h1hhs56id33TZVcJmzYTdZGWPs5DM54sRTaNq6iVw2B8muHhdCCOxivkQKi5sGhm7gOnYHIz1ki2vSL6G5lBqsRNMVoc11sl0SSPt98z0PrI6eUOfBViUTxcPoVVuHTkAsFgMJhWIB2y4CgrLycn7+s58dcBKhvFFspK+Mt6RQlq+u55EvFskXbXRdIxmPl5KHCFGBbY6kLvy8g3wKmW7Cs/O0tLaRNHVs21HKApqGrmuUl1fgFHNEo3E0EZRWCeo8gn3guJCIRVmyrpGf/vHvPHTDFUQtU4kqCli8fguj6qqoiHfcI9v1EFaMi79/M/6Odax95u9URw12Z4o8vHQzq5vS1Gk2TiHPpqxPZV2/biv0GX+7mz989ARMTSNmKEWBiGXQmslTEbEwBBxeU0Z+4RNkrSKJyeeWlBDwPdCNty1S+Z6ElF3AGu/X+CCB7BN700V++fgKHn1tsxLt07WSLAMAMiC6+iHgaz1uP3f9XqXN1MOz9fq2XPcXw7AKrTixakBDarpiYUsfo9DS7YuzK22TKrp4jlJHtaVUSQTQTYtVz/4Nc+ubB0SyFL0A23a6yFkIIUAIHvrnwzxw+637xddnbY82W4ZlpfZzU6ZQCzbs4MxOvWgpJUt2pinYDlIG+KFWVd2gYeTzOQzT7PC4kAIR+Mx/8blSGawmYbErovw+At9DMwyCIODNRa9x4qQppNMptH0SRVtrC2WJJIEMSrNoHUHc1NixfQfDRgynq4RNpwaylIjQbzsW7TCmMkwDy7LIZjIMGTz4gMkj8D1yrc3Yjk0QNqFj0SjxRJJUqpUgAGSArglefW0hlck4Qwb0I5svkMfksPHHqvMqZpCt23Ecl1Q6RTIaIWbqeL6vYLWaaph7wK6WNH2qBVZZmXp2nAJeoD4jozPTXSoCYL9e1Rx+/CSGX/IdzjvhKIb0r2XB+p18/vTjGD+kH+2maEiliJuxi6x7+QlGTj2XPaNP5XMhbLidxLcpl9tvWVcGPpeMqMLQNLxwRSMByzSojFoYnSHGQcCuV55l89OPM6y2FxHPgSBAr6yh/NTziY0+ar/3/d8Zkg9QWPB/Qwvr/0wUHI/P/nY2TyzYjO8rvojv+biOp9jIjkNm5k+57Rc37HcfRcfbr9GM57r73e6io/oiNQupmShMpY7UTI4c1Kfbe0sKpYaSJ/Fch1TLHrKZNDtWv8m6Gf8gl8sesA8xvCaB6zr7JCdVh2h48uFQ5bRPj5pcthf0sC0h0a4r4ivn+Niej2sXuwoDCkFbJsOeXTuwLEU6NA2DOTOeonXnltJgZOoaR/Trhe7b2HaR7Vs2MeNf/2BU/1osy1Jopk4rt8D3eOi+e2hraS6Vp0zTRAt8Jhx5BEsWLSCXzVHI5ygWCriuqz5n38cP3RI1XcdzndK/25NIJBrljttv5/LLDywSvWfndorFIo7t4Ac+ju2QLxRwhUFFeQUCKC9LYpkWYw4bzaDBQ3h95To2Z3wOP/q40n0NUk0gZckHvf3BSsRiRKNRDNNA0zQEghdeX8XVt9yJ1mc4+sAj0EYejxEvxwglZTzPI53J0JrO0prKUlddybx587jhhhsoJHvzzJKNnDflWD564lEIw0TqSnFBGCYBgkTEpCK9jV0vP8yUKVO49Ze/5JxjDufqyaP5349P5p6fXc+UKT2j2PyW3SQiVkn3rF0GXQYSc59nKGpoxIDRSRMj10ZgF/DdIqkdW2n615+wG9fsu/v/WLSrER/s552EEOIiIcQKIUQghJi4z++uE0KsF0KsEUKc1en1Y4QQy8Lf/U68h0u3D1YgnWLG4h00Z2w1qIh2YcWQjZzPoiH5zg9v6nGWVXR9bnp8Ba+s3h0KHYrSF779EUqvm8f+hIeT/YZhbFiH4wUllE3E0NiYj5EpupRFTWzPJ+/4lEcMkpaBHUuQzaRDiQyTwPfZNPcZxowZw4033njAWfLgqhiF7RtIDBhRkqOQgc/Cx/7KiKNPoP6zVxApryZwHfY2rubu+x/qYIhHDdVH2EfnR2g6ZRUVzG5spjYRoXfSAiSuH6BbEVzHJgjROlZUo5DP89wDd/Gnv9yP60vKIgZnjrsauLrLfi1D49jDO2xuP37aJADaCg6OG6dQKKJpijQ4f/Ys5r7yMh8//1xGDjwSPwgwdb0EiR439ghWLl/GYUeMwbJ0srmcQkNJNS/WNIO9u3fRq1cNzc3NJBJJLMvE9wMKxSL5fP7ApSspsQydQqFYWp0JTeC5Hkgo7zeI1998mjGjRuJ6rvKBkQETxo2lYf4CNi4vI7BzpNMZhvWvwzJ1fN9D03QcPyAWlirLysrUvoXAdRxeWbQUYVhoVf3U64AYfSL+qtl4uQwtqTRBoCxlo9EITakMiYRifD/88MPIIMCZ/yiykFUS7UIDTYT9E9UvikVMnHwbQVsTJ5YVOe708R0rFXcX7uIXMI8+o7sKg6YTj8dJpzOgge0HGKEwZufhVUqJ9PxS/8WXssSV0jUltbP5yb8z6uob+U+HlKqv92+I5cDHgD92flEIcQTwSWAM0A94QQgxSkrpA3cAl6GUzp8BzqarYO27Fh8kkE6xensK1w8IfB9hdCz7BYBmIKVH/UkTe9z29zPX8OLy7RQLeVwvIFpWoR59ESYRPyA54niuv+9Ffvy5U7tBc19cuhGnaCOkggsHgcR2JBFD55/Pz+XRuW9i147CiMbRdJ2IoZqP8WQZruPiuw5aaju3//AaTpl64AEO1Bf0/LH9uPnOPzDwqBPQBGxb8iqtrRnOueL76JEomm6g6QZ9jphAr2GHs3RHiqP6VWDqGv0Mm22uhR76chimhWGaxPoOZHNrgU0teQh8IqEUuGZGiJgRPNfBLeTwXJe5M57gqiuvpHw/trkHi8qYRdys5M3V63jt9deZNfM5fKfIrbfeygknTaIYsqkNveNe10+ZQkNDA3/+4+0kysowDYOTTzyBE086mTe3b+GO22/nsMMP58KLL1ae3o6N7bSr9kJVVdX+TqcU+XyhtDpsD03XyGQy9BIao4cNLTHcO38uZ085iUKhQGAmqCovw4pG0KRPRWWVIh8WCkhN74a08iT0qankos9+qcs+hRBo/Q/H3LSEiGUiA9ANVfZ6YNairuq1bhF8X0HCS+VaCYFfQunpmkbc0nj1gTsZ368S07Jw3IBcLqdMvVIptrb6HHtaV5tZraqWSGU1FTIgWyjiui4tTkBNIoQRh2WtIJBd+oale4OyRyi6Pvau7Qe9//+O+HeVsKSUq6BHZN35wAOhfmCjEGI9cJwQYhNQLqWcF273F+ACPkgg730Mq0sqvR/fQRhWp98IMC1kPsfIPmXdtnM8nycWbiafySCEMs4ptO7BTFagGQa+nUf6DoZu8NyaFLG/v8QPLjmtyz62rlmGqBmBJtVMWSWRgEwuz30vrSE6eAxmNAYIZCCxPZ+ooROg84njB3JYbTkjeiV6etAANVt6bnUTC7a04voBQ6vjnD/heL77VbroCZ3xha8jdCXNrmZ/YQ/BivDSul2M7J0kbuqcd/IEnpuzgKXbmtHMKL36DwbfJTAsQvKMas6GBTcpFTfBCD0nls9/hZ3rVlBf//sez/dAIaXE9tTsL2JoTBx7GBPHHsbln78EKSVvrtvMyi27OmRHohGG96nGCicF+6LgXM9n/aYtpHJFho0cxbYtW7CsCCDUZCIUQWxtbeVTn/oUedtBFwLL7N7YFUIwZ958TpkyWUnJtL+O4JW58xh62Bgsy6RQtLvYChu6hqFruJ6PYeiYpoGhgRBqpSelJFlWDoFPJp0qXZttO0SjUX7wjSvpO/a4bvdKq+gNQ8ez66Unqa1IsmNviodfeZ031m/tql5rRkBA3nZIRiNq0hSuMNs/v/a/H96vmmJBCWg6djEkEBpoAp5/+K/kjfg+lryC5OmfIvvMvVRFoqRSbbiOS9HxsET73QFNyJKzYbDP6jaQElPXWbM3zVF0QIK3b97EgMFDuPLfqYPV6ZwOMXoJIToLwt4ppbzzHR6+P2qF0R7bwtfc8O/7vv6exAcJpFN8aMIA7pixhhbdwncKaGa0k8e1QLcSfOa3s7nv6kkkO82aC45Pvlik3ZVPoBA9Iqw/S8/BMHTF70Dw1IoWfrDPsZtfn0HijOFIoSGkQuIL3SSzdQ01w49A6AbtPQrFGlaeCYGEmniEkb2THCjuf30ba5qy+K5LPp9jaTrDmxu3c15/UZL4kFLyy1lrKRSL4RV39FuEppHP5dnWVmBUeKyzJx3H2cDWtgKvrN+NJ/WOhrwmCLrsRbkRGpqgZdc2lsx8hEw6zVuNguuzuSVHvmiTzxdoa21mxsN/48ILPkJ9fT0Lly5Hj1eWxP6klBSLgnXb93DEoLpuA37BcdmbyqFbEfoPGsSFgy8h1drGz2/6Kdd+5zsIoRMEkubmZvr3748VieB6Pi6KhJmMWiWIbHv0HTiYV+fN46QTT8D3fXRd58WGBoaNGKVQZj5YponjuorZDkQjSuo/GosSi1gor8qO1SKoQVXTNIqOgxYi5zRd3fPaA1gaaOW9aa4azhf2aXx35usITUfvNxqRWkA6VyBmmUTClZsMZIljEkgwDYNiIIkISSzRzhkSOJ6HI0UXBrr0HNxNy/F3biAy6kiIV3LzT3/G4ZVRJg3rg6Xr6umQ6hmTQmA7Lo7vk7BM2kHJrufjBZJXc4Kahgb+/JMfcdVh/akbegS2HzDztl9AEFB/yilv+Zl6OyF5S26De6WUPZcuUNYXQPdmJ/xASvn4/jbr8bT2//p7Eh800TtFMmowvMzBC0Bi4nsBnuPi5dP4xTyB0Fi9rZW/z+4Kjy2PmQS5tnCQV1/0IPxCgCrf+EFAEKhBwRVWt2MProoSvP4IwlPeIQgNuWcDuxr+ga9ZBLqJFCL8napNO45LWzrD/CUrD3hde7M2a/eo5JHJpAiCABH4oOn84bGXSg1yIQTViSha2P9RT6P6TwYS3/dKwnmdw9RFSRq8PbQe3qeZFq7nkUm1vS3vBj+QbGzOkg+5H77vUV3Ti4998Wtc/0Plv9GSUXpYymZXwXs9z8UJB6DO4Xo+LTkb1/cJpNK98j2PyqoqRow+nG9/8xsM6NOHQf37MnLkCDRNo61V2eK2tbbiug4FpzswYsqUKVTX9eNH/3sTP7zxJ1x/40/oN3AIU8JBtXbQcKxIBMs0sSyLqopydMNE05WysaYb4SqO0mTB9Tz2NLcgA0k0Gi0lLSGE6qUkKg9479rVa2tra9m9eze1tbXdUFP60CNpi9fieD4Fx6Xoeni+T7tAp+sH5B2XnO0SsUyMUJ23fW1iGQaVZR1lMena5Gf+mfyC58isX07Lm3Npfu1ZsCKcNKwfRdcn7XiKS6gJpICsELy0fhtuIMnYSlq/4LqsbM7w0wXr+cilX+PRu25n2rhB9I4aOKE+2ocG9WLLg3e/pefpHYVUz+Oh/Bx0V1KeLqUc28PP/pIHqJXFwE7/HgDsCF8f0MPr70m871cgu9vy/OWF1by2ejepVIp1uwuqaYgg0KOAACOGbupICUU34OZ/vkHfYDvnnaVmO0II+qUWszM6BanpBAi0aKLkjiesGFJG8O0sum4RtVu7nUe7v0Fi9zrivfuTT7WQa91D/8OOR6KpfekdUwkhBAQBgefyz3vv5pjqYL9L+L15VXJJ5xWap6O5q1Heb2iXGeOkIdU83JzqOEZ7TdpTs96BPbDUV7/xGiI6sMv0pycyG4DQDV5+/KG35d2QLrrKyCibLUFtPc/DtEyOn3IK06dP57OXX9Pt4EKIUCqk47W849KSswkCiWaYRA0Dz3Wx88pCd8LEY/nLn+4s6TsVi8rpD1QvwA8C2tpSVFZWEo9Y3VY2B5KCEYZJsu8Q/EIWWUjjex6ZXI5kPK6a10KoXkegBm8pJWZoOZzO5hC+r0ycNA3HcVnduIWTx+3XvPOQzkndJ42Rp5xPw6xZ/OKmn1IhC/zyqxdBuBYydB1NEzz+2go+Nn5IybwKKA30k0f04dXNamJQfO0pZGoPmgyIWQaB1MkVXb50/HC0fFGh3YKAtjAJl5clqa2pZeTJFzP9j7fTvLWRtbv2UhQGRx11FFdd/2Pq6+vZfM+vMbQo7j4glfEJjaCQR4vFea9D8h+XMnkCZbj3K1QTfSSwILTCyAghTgBeAz4HvPU68SHG+zqB7GjOceFPnyWTd0BAW7YIaAip1GmD9pIRqsHXPvBKNL5718uUR7XSF/I7l36cb/3PzWjDJuH3Ogzpu7hOHivZjpbRwIwhfYevTB7c7Vy6+husUfyL67/Hjc9vIPAchGkRyA41WgkIKdFyLZip7Qf0gu6diOBLWULzlEJKglRTF8Lh6NoyjojmWdyaJV5Zo/gXbhHfsTmmMuiRoX7b9Okc++mrqB0wGIkWCg6qGVop4aGWu+nWFhbOmsmjjzzylmvWXuiSt+916LpJda/ezHqukTXLlzJg8JAu2+mGQSaVwmwvyUhJa87BcVw0XS8lN8O0cPQiCEFra0uXFVImk1Gz/vC9mhBIIchms9RUdO+LHSyEpqNH4uTTzaRCX5RcvkBZMk67KKYMQn0sEQonRiNs2baT7/3s13z8Q6cTMQ3mL17Gp7902btKsqufOpUpk05Gpprw924jt3k1hVwGz/d5bkkjdzz6HOcdeRmtuaIqYQg1mOqaRtTQuOqqq/BbduJtXd2pjyLRBCSiJm4QsNvx6ROzKLoeuq6TSCSwdIE5aPRBE92w6nJ8GdBVWFKJR/qZtn9PApHKzuC9DiHER1EJoDfwtBBiiZTyLCnlCiHEQ8BKFBXoyhCBBYqkdi8QQzXP35MGOrzPE8gfnl5GcyqPa+fxPR+MGAiJF6iGnpQ+QoS3qNP3U3pFvOrR/L7ToF1fX8+vboRf/+FeNrpDFVHMMPALOYRhIXSdwHX49uRqPn1uz3Xanr443lMrMKSPX8xj+xEM01ClAylh6zLE6pdJJhIHZJ3XJCwOryvjtXSGoN3CVTcIXJudixs47Ph67ni1kV2ZIknLYPKwUVSLZfzxnp9RMBL0rqnmU+eewan1PWtyNTY2Uj7vJRJnfxwA04oQi4cDYQjFlAiCwGfJC09w2qmnvq2GZ8LSFUhBV2TCkpWs57Ju5TKGDh3KcUcfyfo1qxg2cjSWZalVRbGI4WZL73c81WPK5bLE44ku0iaRSIxiPscTj/yzywppxnPPcs6553VBT5mmybPPPM1XvvTFt3wt7VEIJegT8TiWaYSwBSUAmc3kKIvH0DVB0XZY17iVlVv3UFnTm7sffOw9M1F685UZ9Cnuwvd8dEMnHovTHOnNT267l/UbN7JtTxttBYfa8gSO5+P7KtHpmiA6YBT19fU0PnY3Vb7XgehCTXo0IYgYOvctWs//nncykWIBu1gkn83QGgha/SQnHeT8Kkccjti4Uj1VYZ8LKYnH4+gV1QfZ+t0JyaGVp97xcaR8FHh0P7/7KfDTHl5fBIx9j08NeJ8nkJkLN1DIZdGEgln6vtsVfeUWILLP7DJkxgqju9pofX09R048gY/c8hK5TFoN1EikUyAQGsPryvabPPYXVZlNZOuGoQkJXpFiwUXoBm5qD1UrZgKH5gX9qQn9ye3ZweJdDkYkSn7HBrY1PErG9jly8oWs3daEQOLF4zy3pompw8fwj7/ce0jnOHToUDYsnE3t4OEMOGy8ShpBVwMmUA3/xhVLuP47097SPWiPmKmTjBg4iQT5UIARYN3K5Sx7Y5Gq6Ycw3X/+5U+UVVahaxonHTuBKZMnlfbTPqb5vk8+nyeeSJRIhxLJH6b/ls986pNdBuZXZr3MsGHDGX344ciQ4b5m9SoaXnrx7ScQ3WD3nr0MHTQg9JBHscg1ga6beIEknSuweOUayuoGcPKHP85JwJe/emAi4zuJuQ0vMaywo9Q/8v2AbC7HkKTgH/f/BWFGueiii7jj5aVc/5ETiZg6mAZ+EJB1PAYPG05x5j3UFHaD0NqJVKX9SyS7MwUS1b1JJWvYvGUZe9uyzN+wlQfmLyfn3scNN9xwQDfC0Rd/ka23/Rgnn8P2lM9KLBajeuo5aJHofrd7V0PygZQJ7/MEkmneidCSiJCroeMraJ5Q5SuhG6r2b+jgOkjpIQNl0hRJbWBYD4N2dSLCxOG1LFwPxWJeeZebFroRJe2Z/Ohfb/KlKcMYchDUFEDe8TjvQx/mvpeXYA04HCEkmq7jZFMUZv+NyjKLzCF6QRuaxuUfOj6EP/6KxsZGkskkI0+/RGk1+T6BDMhm0pSVlTNnYzOThlZjHERUETr6N3Mf+hN9Bw/nqHM+SXXfgcjAxwx1p1zHARkw7brrqZ/UHW56KCGEMr0qixhs3FFk69atzHziEXZu385Jp32IZ16cBXRdyQWBxAsCHC/A1JVsi6mHWkyRKI5jk8tmla6UoXPX737Nrm1bus3qL7vsMqZNm8aYMWMZNnw4jY0bWb5s2VsSVOzpeh544hl+cM3XCB87JFAoKtn2dZu38+cH/sW99/3lbR+jc0gpFd9DaPt1xHyzYQYjTziiNLtun+EXCnliLTvR64aWPu9v3F/g3AmjqImbvLFhB5/46HkUlr2KRhDCwEOAgexA8wWBJJMvcv2U4cjcbqoG90YO6s0zS1cjheDwPtU8c98fmXDkWCafelqP52j27sOAy68j9fxj2Fs3oifKKDv5DBLHTOrx/e9FSD6wtIX3eQIRO15D9D+tQwZbE4jAwcs0EY1qVEckU4+o4Yl1gqKMIAwLQw8w3DTGphe46hf/2+N+f/TRsVz798Vs3msp9rjto+saXhAwa+Vu5q/by52XHnfAJDJrbRO/eWEdYJIcchSFXAZn7RxqIz71YwYxt67ybXlBdx5cL7roIqoHDEWWBgsNCMjn80r3yfGpjB08gXTu36xf+SZ6dR+mfPQSkAHFXLYkXW5FIpx87IT97scPJKmii6FplEX0Huv6QghqEhFqRg4kv2szp593ITW1dZiWpWxpPY8X31iD0FTSrOndWzXcAVOHvuVxYpYiYsbicQXLdV18z+P5Z57ilZdf7DEpdL7GJ594nKFDhx5U0h8IBRxdAs9FCV4a6GZH0/0j519AS1saQ9fQNA3X9RCahmWZJBNxHn/iSRoaGt5xmUrm25C7NyiZeCmR0QSibmS3RKJUjLWSRHv7PSdQIo373ovfPf0qQ4cO5etXXkFtyxKU+aSG1EyE9CEI8KXE9jwcz6dh5WbOG68MSduTiiYEv/7sh3DyCj6eLTqIN5/F7ltB5PCe0a9Wn4H0/uzX39E9eUchP0ggAELK//9vwsSJE+WiRYsO/sZ94sKLLmJdoRfpiqMI23xYxV0M1rfz6H3TScZUOcv1A/7w0Iv889lZtG1fz8hqydevuvKgkhYrt6e4+i+vKw2gQCnH+p6HZlpMHJjgj1ee2eO2j8yYxW9fVxLruqaRSCRAN4hbOvdfejwRQ8la3PHEHGas2EYhm6EivYlvXHw2Uw/AQt83Jk6cyMTPXku833Ck31HbD2RAr5peXHfayENagewbU049nU9+/xaseBLDMGn3Jl+5YA7nHdWzEOH2VIGVTVkc26ZoO/ieS2bvbgb3rmDqMUeWzqOhoYEHH3mcTY2NnHDKmdSfdY7ytwfiyTL0kCwYMTrk4TuX0YQMKI9FKTp2SQJFAIsXLeTxB/76rvcU3GIBu1igUCgqtraptM6qa+vC2X1AbtcWUqkUEklVZSVaKHBZLBZ5Ze5r/Oy3t/Hzn//ibZ/X/DkNjIrZJWn2RCJBxDTBjCIGjeuSqL91+aV876OTu3rhSIlh6NRM+igi1jNgwM9nsGfc1VEfJLzvnkfge8xYsYUnl2zg5k+fQdzNE0iFLhMhTygoul3Ig+mCjWYY7B49hePO/kiXY0kpsRtXU1i5SEmsHDGRyLDDDxlIIIR4/UC8jEOJviPHyM//+qFDeu8vzhv7jo/3fzX+IysQIcQNwFeAPeFL35dSPhP+7jrgUsAHrpZSznivzuPr4VJ8QHYtomIAO4yRFIwadpYPZtK3HuaaC8bzxbPGYOoaX/roVM4//UTqKmOq7rtPvLR8J7c9t5atzTn6VMa47PSRHDuiRs2xAp90KvSs0HUC32PB2p09ziwbGhq4+W/PYB5WjyYUGz2dTinJbk/w+uZWjh9awzX3v8r6PQVEohdWsjf52iH86F/z+HxOUDd4JIOr44zpW35AN8OhQ4eyZe4zHPaxKxTp0fcValk3D7l81VPU1VSx7LXZTDztHEUOkxI/8Ok38jDuvu+ubtecKrqs2J3BcRyKxSKxeAKIEU8kac6meXLRas6beBivLlxMa6QX537+CjRNo7K8rNRrMiORUvLQQvBcZ0WO9hqR5wdkiza5TPh5CEEgJWPGjWdY/z6cdMLbK6/1FEHgYxcLpMLPXgiBbStZ+uXL3uTIcUchhEa0okada4gkAoUqyubynHjcMXzyYxccEGV3oJg35xWaVr7O4ceNQ0owDR3PUX4flhBQzEKnpHD+pz7HEy8/znknjsMMibCu79MWqaHXfpJHeLFdkgeEKxfTRDNMHlzdzFXXXk+i5U2km1cfB8oiV/qyQzcuLOXFLIXWWvn0gxRiFV2ufeWff4OxebUCqmga1so3KB93ApUf6upn/17GvwuF9X89/pNEwl9LKceHP+3Jo7NA2NnA7UKI7qP1uxTtS/E+vavZLgfgRmooL0sQCev2v3l0CS8t2coVv36So674O/XXPsjYr/6VH/zxGTqv3BpW7ub6B5ayvTVPxNTYkyly06PLmbNKuf1lO3lWAAjNQHdzTJ8+vds5TZ8+HTNRrhqQ6p4ghEYup6Tg847PG1vbaGwpIAgQUq1uhBDERp/Moxtd/rZoK794cR0/enolRdfvdoz2uOqqq2jasJK1T9yN07YHYZi4hTzjKiT1I3qxM11k5uomnlm5i00teQ51tfq1q67msOOmkMtmsR0HX0rFfaispnLkUd3ev7WtQCAhn8sTiyfUTDlsJiPBlYJZi1dSiFURicbC5nyApuskysrxfT+c2VO6Z52jK8FRD8UCBZrQAPWn0DRmz513SNd3qCGDgHy+UPoMCW10LdNkw/r1pffpsSTRyt6qbyAltuPQ2tYWkgUFZ5065YAoux6PLQOCpkYOL4czTjqGZCxGWTxGxDKJRSIYAiWE6Hc1Tquvr2fkKR/ht0/P54l5S2lYuYntsYGMmHLOAY8norH90p0d3+fhhx9W6spDFTiop3lN5+2N8NqrEzGmT5+uEtnurbz54F0YW1bhBT4+YPs+qXSG9JvzcXdtPdTb846jvQfybhAJ/3+O/2s9kPPpQSAMeHe/2Z2ivr6ew8YdyxnXPYKhaTiuQ0trC77vI3STb97xIumiRIgQZx5I/j53N+WRGXz3C2cDcPuMNQRSlhRfTV3g+gH3vLyBc8b3468vt5aSR6guRUXzm6VBwfMDiq5PImLQ2NhITaQ3BTm+ozcTloACCUcNqOTJFTvx0ZR5UHsYERACx/VJt7agGzprbIdH39zBp47pTFjteu3ttez5f/yfTv2U45nb2MxzK3dStG2CIODllZJh5RqXn3HMQUsFY485jpUL1hBNlClSXMhl0HSDw06c2u39didCVknsUd2s0gqm2ZZUmEJBq9u3KxaJRqPo7TDcLvvoaYRShlK+9LqtzKQMWLf23ZUKV0RHt9v98oOANWtWd3ktCNpFNDUiloVlmmRyOdqfmP2h7BbNf5Xdm9ZB4LN283aOOameKfX1yNadkG/DdhzMqNVxO4J2YRmU8ZQV63an6uunUl8/9S1dq2ZYrNnZwui+1V32JxE8s2gVjz14EVdddRWTT56Mu/FNRLa11ANBC0VbOn1s7TI9y1sK7N66hdSjf8Rr2k5lJkWkLIbrBaRztpoIaAFOoYC9eS1mn56f9Xc72nlO7/f4TyaQq4QQnwMWAdOklK3sXyCsWwghLkNJFjNo0KB3dCLpvDJmclyHdCeHviAIaHMMhLRLpQVNQIDgL7Ma+e4X1PZbm/NI36U1o/gkmmGCESWVd1m5tY1EYRf5WB8QAk16lO98DW/XKoYMHcZds9bzr0XbcLyAmPBojQ5g7VMPMCzSn+SQcaEvtrIk/eSxA+ldFqE6bqG860RJPoVQFVfIAM3QCPyAXDbLc8u27DeBQM/ck3TR5bmVO0OpeDUQBlKyrlXw+MtzueDUkw94P5MRQ60MJOGg0DGkGFaE51+ZyxlTOtD+tQmL5pwTeluEIdT/fM/FNCMU81n0ykr8olcidOYKBQzTVHybfZJQexIpQYnDcuD2rZupqa4kHo8r7g9gmCapthYyrS0HvK63GkLTyWSy1NRU47qqx2SaJkW7yNr1GzvO13NwcllE4Je0sYTQSMYT5PJ5np/1So8ou9VvvMagMoPhR48FAceNP5K1GzfxSkMDk4ZUquvXBDJc/YBa1UlfIoVS8TU9B6x3RrwLggB/83KGDB+BZ+cwkGpVrGn4vs+pRx9Bbe1err/uu/zkZ79g8gVX4a5eSMubr9LWtJtyQ6AjMDtlHscP2Ja1eWnddq6afCSFbRuVA6fvYVkmhqERj5rkiypBu76PFumukvBexlvQwvqvjfeshCWEeEEIsbyHn/NRevXDgfHATqAd9nLIQmBSyjullBOllBN7H0BI7mDh+wEaEl2omnNXhz4NZIAMupaBhJAUgo7cW2H5pDN5ZctqGPiahR8qqM5bsY29QRU7nv0dXsNvqF35V/wtr5Mt2Aw7+zL+NmcDLS2ttLW2sCvjUnXq5Yz82p8opDNsefoPOFvexNu8hEvHJfjM8YrBPmVEL3TTBCuO1C31E94qTVNfaM/38H2fHTt2djGDOpTY0JynUMiHyaOj9KIbJs/MW3LQ7eOmTsLqNDdpTySo8t1TL77S5f39ymMkLYNoPFaCUYOgmM+FasABW1YsJmJZihkfMtx9X9KWTqMX2hjZtxo3vRdkUNJt8oOATDqNbRdpad7DM48+zM4d25G6hYeubFI1wZbGjfz0B9/liit6dpl8uyGEoDmV5s1ly9F1BRPesXMH373uB3zuc58rvW/Xti0UCgWyhWKnh12iaYLm1jaOOu7EbkleBj6942oa4Xo+rqtsbEcNG8KiV2fR4SgYJlSht687cH2fdK5AJlcolUrfbgRBgDPvUfx1C4njYUUiSuBR1xVxUNOIR0yOGlTLtHNPZsHjf2fnk39i0cwn+PXTc7hhTiN7Bk0g2X8wQTTGnrzNst0p/rZiJ//z4jLaMllO7FdBOpNFBn6HB4eEaPiMaahkHRl55Du6lrcSEuVzcyg//83xnq1ApJQ9m3/vE0KIu4Cnwn/uTyDsPYnf3Ps4tzy+Clfq4RdJYJmWgvMCBkW8ggNWost2ARoVdCjJynUzofwEPCkRdNTipZ1HExLdMKk+9iK2PPYjbH8s1Sd/Fi3Zlxc3u0jPRbouWrRMEbeRCN2ibOTxGOW92P7Ub7j//vu7DCAvzZ5HsVBEj8QUkgeULEkAOuB5XujBYeJmbH72ciMLWnS++qHjD8l7w9CUdlRPgojNTU2HdG/rkhFSRa99IaG0AQM1hKXtrl4YuiY4flAV21JRXlu+Fl8zMUwT13HQdZ3nH76PS847i8qEIokVi0UlLaNLon6RSceMU8ccM5KGhgbmLVnOjh07+dff7iUWi5LL5ajrN4Df3fsPIpEIge/jui4yCPjr3XewfOE8fvzjH78ncuAnnXQSDQ0NfPf717Njxw7KKyq6Ib22bd3KsKGDCaQglStiGcrzw/E8fv6b6eSKDkEgu2wjnTygVjSe1+GBbhgao4cMgEgCWcyRSCQwDQM0DaRG0bZpy+SwTJN8oUB19OB8pANFsHM95NpKqCothPx25g8amoaDzylHDGZiWyt6226G18T55hnHsGhLE1++4RYFiT7/a6xsaOC2TvYCP/zRj9AWP0FVmVpdSCnJF12iuhYeI8D2A+zjTkdPvHVJmbcbUoL3QRP9P4bC6iul3Bn+86Mo1y3Yj0DYe3EOf3vkOW56dDWIcEAN6+1eIEMPKImbT2FvX0xizDl40kAPy1cEHtM+1tEMblzwHK3GYsonfByjZghIn8ApKl+RSETV7cv6MHbCcRQmfAkZK8PNZdDj5QjdVGWozmO1EBgalPUbSWzU0d0GtntmLiLoexSyWAwRRxLXdTBiZfhSRzdV2cuMRNFr6tCE4NWdLpufXMFPzx1DRezASWRkrwS6rgTFS6OAUN4YkcyuQ7q/vZIR1uzJAKJjF4Af+Liu0+39uqZIgoMnj2dWQwN/+9vDNLeliGoBl192GfX19fiBpCljsTcfQxdQVxalOt71WjqX5D7+4TO4/fY7qKjtw2e+chUVFZUUi6qpLYMAoWl8+ouX8fttm95TL4mDaTs9PfN5rrrs0tK/i45LMhGjIhHnjl/fzO6mPfzkll+jaYJJJ52E9FwKe7aTTHSUnvKFoiqTSdRkqKIWWWzEspQrpHrZwPXyCCCXL3D7v2Zy86Tz3tG1+Ts3dCoZtkdXEiKgDNA0ofTRNEl7+27ioFomDOtfQpnte69WPfjHEtRahvtMxCzyBZtFm3byeiHChz7/Zaaccuo7uo63GqqJ/t+9ujiU+E/1QG4WQoxHfQ6bgK8CHEQg7N09gb++DKKW9i+Xphkl7492e1NiNUSGTkHb/DJu5UiCqsEITacyEaNVq8X1AgqOR758FNJxyb5yG+WnX4sw44pXUUoKGrqfR+s/Hk9qyGI+ZB2HRYX2MkLYbJaBh5rI+dQNGd3lvO94bBbpXkegoxMI5S+iSQ9NaDj5DG0rZiMKKQZM+SheMYuuCQQavuvRVnR5ZuWuA/ZEAKKmzonVAbObVO+lfSBYO+MfXPv5T3d7f7ro8sr8BTw540UqRx1NeXUvBlQncTwNzTAwTGUyZdtFXLvIrg2rezhqR0ytr2dqDwOurgn6VsToW3Fote4pU6YweOxEcm5InpOSRLIMu1jAdRxkECijqNRb9yV5N2Pdhk1s2LiJ4UOHoBs6UcsKpU2UYGCfulqm//Jn5LIZ3NbdSLeI63nompLNl0A8FiXjZXE9j7qho5D5NPmiclLUNYHreTiuB1Jy+Q9vZsOOPdx+xx3v/OR1s3uNub302+k3mqBkjNUZVGDogvGD67jn5Te67Vp6LpHta8i6LuXRiCqpogYN3dCZmTa58/6/v/NreDsh//sRVocS/5EEIqX87AF+16NA2LsdTTmJjHcgfoTWE1pYgm5i9B2PMJP4gYcIHDJZjz88vYyF6/awZmceY8zHiAeqaWs3rSE64MiwZBCoFCE0EplN5LUkQjfwXRtN1/GLBYxonA5sFuHUxiEIVwBfvOjc0tk89+Is/r48o1oKZnvXQxIIHU3TMDWN9MKnsAPBgMkXoIfsZhlIZXAFLNmeOmgCAfjYaSdRMauBvzzxPHv27KVM5rn2K5d2mR0WXZ8nV+5i4940jp1g5NmfIvAcfNthRz4gZunoroPnOmowDCR7Nq9n9Phj+d/7HmXTqmUUd2zksku/+J6sANJFr5Q8usyGozFc1w0NkiTVVZXv+rHfSnz18su55jvf4fRT6pl0wvGcOuWkEJWldYG7xhNJPNdBkwHRSIRcNkc8YpRKjaZlsjPtMvGEk/G3r8Z2HFU6lAGe5ynpek3QuH0Xt//hznflnpvDjsLfvQ/EWDeUZlxpfFX9Ah2JaZpdhDA9X7I31bOWm7QLSN9HCo3WfJGoaYSrmIDmbIFLLnt3e1ZvJdphvO/3+L8G433PY0Xjbn774BxsX0PYBbRQKfdAYZuVJcy8bkWQgUcum+GV5QGV5cpXu/0LKqtGYW+YQ3TYCUgjSqBFCbwizTE1uywzDHzpEwQ+Qga4hSxGJK6maEhwi8ptTjfpVxXj7lWC3yx+kZqkRX7j62i9RyGkJHCKaFa0g8mLzoUjI4y76w6+/cMbMUwTEYoa+kEAmk5bOkt2y2oaKpoPafA4bWo9px2A2f70qt1s3Jsh1dpKVa9eICWaYRF4PoHnUgT2bliJpalBe8e6FRw2+Uz6jTgcXdfpNWQUTrHIjT/7Ef8D73oSSRVdpJR4rkuxWCSZTHbqFRj4vs/LzzzB5V/96rt63M4RBAG26+L7atA0DR3T6GqFW19fz80338z06dPJZzNMnXRCN5dDUA1p2w+wNEXCi8ai7G1tIxqxiFoWT730KpdcFsp7GAoKXLQVus2yrHC1Kzj6mIkHVlHwbChkQDMgXh4CKXoOraI3f3h6Dl89Z1JJ3BIhCISGH7ggoCmVp63fOMYUN5OMB6TSWdDA1DUcz+fF5Y38+Gc/77ZvEUvgocq5YFBwlepv1DTYmve54N9sYds5pKSbQdn7Md5XjoRL1u7g3G/dzaMvvYH0PaTv4dsFAt+jO9gr1NINSbLt0Eq1oNAQmhFWnKSSGkE1MA0zQmUyQezN+4iYOr6dRbp2OGDoFD2JbkYUSEYo74zcxkWs/+NlRHa/Sa+qcoYN7MsxI/uyIwdteRcvkOxO22RqxhEIQ1mZBh5+IYNv5wlcl+P6WHz9o6p+fMv//g96aieB0EA3MOLlCCuGZkVwopV858afvWVk1r6RtT3W70mRSac6cVxUaGaHfMmIsUex7sVHeHL6Txgy9mii8QTIgCDwCAKfSDzOyR//fI+kyncauqYMp9KpFK7rkMvlSiUU13WZP+t5Tp5w5NtKXFLKUuN4fxEEAa2pNKl0hr3NzbSlUmTzBWy3u4thfX09Dz/8MC1t6QPybIyIkteRIbQbwHZcCo7L2k0dVthaRS1WJIKuaaFqrCKyzpj9Gpd+5bLwGgIF4iixwCXBns3Yq+fRsvI1mpa+wpZXHmPBnFkHvBf6iAncM2MuRc8jW3RpSuXIuQGuZvDQ4s1sH3QCE0//MJGTP4qVrKC8vBxd02jNFbltvkoePX0GQtMpjFQKIJYuiJgmiWgET0Kf0z56wHN6r0PCBygs3mcrkGm/ephUJosuQqlxJ48wY/iOjWaYaLrSKeocUgYqUWga7S7fQAg1lei6hqHrVFRUkMvl8AJJLFHGWV/5Hv9c3Iapa4hO0idePo8m0lT1Gkg23Ya3aSFjxXbufLgDaRUEAVN/8XJY0go61LAFeNJA05Q3tgahZ4ngy2cdUzpGfX09x5zgcdPza1ixM1UiaEnHRoskqDnrsi5eJm8nip5PIWTYy3bUjbphqMQrMS2LgbXVPPzww0gpuX/JNlqbm7vMrn3Ppd+osTz7x5sPeDzHC9jQksPzAwZVxqiIdbcF3jeqYhZbdu1VplGgkFcSspkUd93yYx584IG3fN1SSjJFZevq+T5trW3cdftv2bl1Szd01YaNjcQSCYWKC5OWGyYPyzR7lJnJ2w579jZT27tXDwcHEOSKLsmohef7xKJRHMfhlXkLOPWsD5feKqJJIn2G4e/YgGurnsmcN1YxcOyxTJ4yhU2L51KuOchA4ngeLTLGEUeMwd7dSDp0XhRCozweJb93Ow0Ns/ZLLrz6qitpnnEf2XyeQCpJEzuAqKFz3pTjqZuqttOq+hA961IiqT2UA30revGLg8CIx1/wGV5/0sJe8gplumRnUTJi+FBGbllIy10LMYeNJTH5AjTr4M/DuxlSyg9QWLzPEsjyxt1oQkENDd3A9Vykm0PoJr03z2B7IU50zEdox53KEEvvu0XMWLLEPyDkJmgliQqwLAvDNJESrvzIZ/j7nEY8YaLpGkJ2rHAEgsKGBcz/3WXhWX2q23m25h0cXyL3RXlIJYcdhDIe7SukUwbFGV3XFcKYjBgMr0mwpHEXmpCITvvSYmVsz72zh78qZinklxkJG+Q2VkSx4X3XAU0QjUQ4ul9laRtdCHTDIPD9Llwb1y4e0M9kc2uepTs7Gt2NrQXqkhbHD+owDyq4Pm0FF0MTVMctdE0Qt3QeuvdOLvr8V0p191w2zf1/+E0XKZG3EumCQ872FF8FQWVVFd/+wQ386hc3ccEFF3TxsmhuaWFAIlFKFO2EzGw2S0UyCXr3BHLVVVfxsUu+yHOPPkAykaCjbYwiomo6wjBpzRV46tkZZNIZ5ix8nau/9e1uEwItUUlixAQIPBA6549Xv9+0eC5lwsb3FWjDMg36SJeW9UsxPKWI257kPT+gV2UFd9//wP7Z6a5SKzBMo0u5yw8khdY9Xd4qhEBU1r6FOw7HnHcxnHcxQRDQ/96fIjNNSKn6V/7KBWya9zIvlY3immu++Zb2+07jgx7I+yyB4BaU62BI0jINE8/3kZ7N4cP6M3H4JGasD7qXJaTEzTSDm0HrPSLcV54TRyVY1wq2q3xETENn7KBKfvf0KmxPzcQCDKTQ0QMbiSp5DC4/8LK2LGp1EMH2Cek6bHnwOvqOr6emdx1fPHcKF549lUBKHl+6g0eW7CBddDmsroxYRPlmB65TYm+DQsP0HdQxYAeBpCXvELd04tahPRK6Jmha9AJ9T/wwhhVRIoFCw7QMAt+jMhnnrCP60a9ccTeEEIyoSbDCccmkUxCEGlWaYNW8l7owrQuuz5a2Ao4fsGPDGnJl/VSjOCQZakKwO+uwpa3AwIooG1ty7EgVw+MoefCxfcopj5psW7+aH3/rcsaMOxq7WGRr43ra2toOasDVUwRSknO8UqmuPQlKKfn6t77NIw89wA033MD48eOpr69n1aqVDB4yhMDvKo2udNF6LlPV19eTSCaZfMY5LHzlhZLRFRA+P9DcmuLm397Gtp076V1dxbXfvY4TT+pZHUAIAXonblIQUK45+L7sdP4o2LZTxA/87j0PAc17uyaCLmHFyBdtYhErTKwqTMNg1dbdDG7ZgajojdAPzkE6UNjL5yPzaYIQGKBOHvqUJ3jjn3/lt2gHNKJ6N+MDKRMV76sEMiKZYU0hSiAEEoEvNKRuQHor9Iazjj+MmRtWq9XHPtv6uT2YFX3x8ikIPAzTYummFJ86bQy11RU4ns9Jh9Xy9bsXIATo0kd6njKlQuALExG46LuWMO3rn6cpVeS1dXuxDI2TD+tNshPBzzI0gt1rEXWjurZmBLQunUnvsijzH7yty/n9ed4mnnhzJ67rUizkmJ9KY1kGyZiF7SiSodAEMgApBJddrNBdi7e18rdF22jNFigUCqQ3LCG+aQFXfe2yg5a4PnN2PT/97a2MnPIhEpW92LJ+ORvmv8j//PB6Tp00nraix65Mkd6JCLomOLpfBWnbY6uAfDaLBFo2r+fiqcdRH9rl7kgXeG1Lq6oxux5FvZKYBDN0OERKAiQaGhubcyQtnc17M+Ry2ZIFayKRZMXuNMcPqi6ZHy2aN4dkMkn2EA24egrfDzqUfTt/LEKg6zr1p57Gow8/WOI0vL5wEaeeehqWZSnUlxDomsbSJUsY2K/vfo+TzWaJxmKk0lkMU0cPEYKKdyDQTZOxh43iJ9+/liBQ5czZM5+CWDmTJ/dsO1yKwFc9kX3yVxAE+AGYItQbC5OIpglc18MR+x/8habxxJINfOL4wzB1pRdnGQJLF4wdVIe7XCkPGKOPR6/rSNzSCZO+1d1FMEjtwd20Alwbvf8I9D7DcLco+LfsYXJ1+uFDue6WW/5tCQQo+ei8n+N9lUB++q3PcOkPbqM1PhqJpmZ0gYdeMYg3mpvZdNMPGHbsZWxoKnRdAUgJXhFdN9E1EIaS1Mhmszz40koW3fYZYhGD5VtaAfBcl0xGNUOlboJuEjg5eu96iZ9N+yLbtIH84JcNJVy7pgl+/umjOWFUhyTLwN2zWev4xAccTjutN7N6Lm1z/8H4sKbcHjnb46llu/BdV8mbC4GuSVwXCoFDPJHE9UMYpw4n97PYUzaYL/1lLm22RPgu0i2i6zplw8dTjCaYNm3aQQ2T2n9394OPUhw0hl7Dj6R+6qkcMX4M9y/eTmvBVclUCM4c1ZsRvZKcNqI3qWIl6aJHedSg4hQlP1FwfRZta2Nza0FBkz2PYjZNJBolAAIUy159HiCFamIvWbeZgtTVQKor/bJ0KgWUk7G9LoKRb8eAqz08P6ApU9xv01xKSeAHJJPJkkjmRRddyPXf/z5Xfv3rDBk6FNu2eebJJzn8sNE97qM9hg4dyvZt21TPywtIVpaVBnQhBPF4nC9/7lOk0pnw0ZAcNmI4c+YvoKFBHvjadAPX97FCqZH2MDSdFdt2ccSwwcR1G8s0S8rAP73vUb56+YEhs0edcQH/e+fv+MTk8fQqi1NbniDnOBjtyUEGFJa9wve+fwPbtm7lu+dPYmhtJUjJlrY8/sgTOPGUMwBwNy7FfuN5JRGPxN20DKPvcES8fD9Hl+zNFWltbT3gOb7bEeznWXg/xfsqgUydOpWvfn4PNz/8Op7jABJDNxCaRppe9E70ok/T84yb9CWeeHUtfhDg51sxNz9P9PDzkZoo4fKFEGhI8vk8u9vyDKkrpzoZwQuCkny7pmmKle5JYrntDIjm6TdqAtffMQ/PdSgU8niej24YfOvPr/H8DWeTiKiP5OqrruCyyy5jy9424r0H4LTuwMln6du3b7fZc1PWRhOCQqHTcVF5p5jNQjGLqOqH7xUorJ3PPP8YzJbNuD6KBa9b6svqOwjhEu03grLe/Q7Jg6LX6KMZe2E/bNfFLhRYmw7Y/loj0nPxHBvd0IknEjyzuonPTLCojltURE0qOq24Ail5acNeWrNFAoQioGk60bIKipk2ookkvuzaMpASBlTEeHnJQgaMPKzLAIsWkMt1yM8fjAm+vwjChnnR9XE8xaXQNdEjxFZKyYvPP0dtbW2pPNZ+zFtvuZlt27YxcOBArrzySqZMOfAqoX3V9Mqr8/jIOR9WXJ5Og5WmaThFv6TUDMrf/eTjj+XaG2464LUKIWiVUepwVXlTBui6ju24JPoMpaqyHCfbhucryKwbwMfO+xCT6uuRrs3aRa8y79U5zJy7EFePlpJxfX09S5Ys4SPX3cDksSO47erPIDQN1y+UpPbtQoErpx7JwIpjEUjytovtBwypStC6eSGvzDKYfNKJ2G+8AChBxVxOGauZqRR768YwQIiQM9XBdg8Cye9fWkRVVdUhfrLvPNonDO/3eF/BeAGylBGPJ1Rz24ziaxYeBj46drSOzZsbueObH2L7P69h1yPfZM9zP2bHqnkYbhvsa00SQlVrQ2Z0v+o4E4bWKBXa9vpy+Lj3Kq6nsbGRGUt3ULQdMpkMgR+o2rPvk0qnuefRWaVd19fXc+edd3L0kYdT3L2RwCkyYcIE7rqruyFT72SEQEo8L+iqX6VpGBW9sCMVFLNpXKlhHT4F20ySz+a6qORiRkOBQh+kT1lN3UE9KPxAMnNNE47rkEun8D214tB0nSC8BUEQkEmlsV2HZZ0a4Z1jV8amLVsgn8t2ERNECDTDxHXs0v1u/8m2NjOiJs68l2Z0KyXouoHrOoek+7W/eGX2HOYsXsn6bbtoak2r8lGnnkfnkFLy0vMzaGttxTTNLgm+HZ47b948HnrooUNKZO2rpkVLl+F5nQAYQlAoFtUKs5MtbnsIIWg6BK2yI46dxHbHZOvuvRQdl7Wbt7PZNjn6iFG4hSzpXJ6c7VJwfeVT3reSFfNeorC8gZogxQUnj2f6tV/mk/VHM23atBIkfM6cOYwbN47jJ07ADNn0pmFQLBbJ53MkIiYDa8radYGJRy0SUQs3kCRjFnOffAi/aQtCKMRc4NokIiYRQ4fAZ+5TDzPHqyQQIgTZg+P5XP3Ai+xOZfn2t7990Gt/NyMI5CH9/DfH+2oFAtCvVzmGpiE1Cyk7EC4S2Or0on7IsB63GxXbw0o5gEC0w3kVAqov24h3Gqhu/vwxnLpoIRm9WqFnZUDv1CKC5g0MHToU1wuwbUchuMLBXmgCIQVPPfMsX/9khwZlfX09s2bNOug1JSMGZx5ey8Pz0wShDAqajqbpyECR+oy48uYQQuBJQTRWpnS9JKUvo6aF8hlCI71r80EbzW0FFzeQJTivaG90S4lumhSLeSzTJNDALtpkHa/H/WRtj2JRIXmQAUJo7epNCN0gn8nw+IO/45gTpxBJJFj52mwuOe8MNE0j37yLjSvfZOgRR2IYJoHv4/s+rz7xIB87/saD3rueoqGhgflLlnPWeR/F91w81yEIoiGbHUCWeg9SSvY07ean//MDampqDsknHVTScT11rqAazrqulZJCfX09kyedzK7NG9CLRugVogAepmGg6VoXWRBD12lLZyivqDykaxx75JHIlmqQkj59+9GWK7Jg1kxG9q/F930MvcOT3g8C+osshUKAJjRiEeUvct7JEyiPmvz8pp9SX19PY2MjdXV1rN7RgmUYRKMdfusCIPDwfL8kNyolWLqOrfnoQkMWsqAbyCDARGKaimtlxpVVgef5fOGGW3jskUfY/eZrPPzwP3lm8Sqqqqq46aab/q39D+R+cS7vq3jfrUA+dsq4UPU27IEAhDIinh9QMWRCj9t978rPUbF9BqabQgoDEbgkml/n55ef3eV9FXGLX33uKJLL7qam8VGGbn8IbdeSUuO2fkwdge+EzHMVEjWw71379nUjL5s0jFMHRxVBUjPQsnuR2b3IwEezYoTiW52O2fE3GV6/0DQ0TSfz5iyybS0HbTTHTF2hUTrBch3XBSGQQQfJTgiB57oMrU70uJ+KqInrqqSaz2bo8MoGZMBrzz/BE3++nZu/eSlP3PYzPnveGZwSDtJXXnEFf/3NTTx8x69Y/MoLvPLUv/jt97/OR848uLhe0fXZ3JJn1e406/dkacs7SCmZPn06x500OUymokQYlFISoNSAQSWBDevW8rUvfpbqqqpuqsn7Cykl27bvYG9zMy2traTSaTK5HLbTlWAoNF2pDqPucfv9LBZtctkshqGj6zqWaeIHPr++406uvPLKgx/fLSKbt6kRUCgiovAdhg4eVOq3uZ5HEAQEQYAp1HfD83ySsUgXZPGJ4w7n82ccT0NDA0OHDiWbzapz1w0In+vSj25id0KxEe5G1zRcPyArImi9BiACH9q/m+FjoAmBZpp4nsf022/n4mu+x8NzFpHL5di2bdu/N3mE5y07PRcH+vlvjvddAqmtSvLFc4+jvbgklHohwrfRDIvFqzb3uF19fT2//8m1TBBv0Hvt3RwbvMofrv88p5wytcf3/vrnN9K/QmPP7p3U1taWZqYThlZTaW9DSkEgDCSKzxHf2sCwgX0Oev4zX5zFOV+6lokf+SIf++TnSuUDXRNc/4l6bjy5kl4L7ib17O/QTRMtkkAzLfaF3Yj2/4UrBiklqa3rWffYHcR3rzykmXTc0hlek8CwIh3JAkGhUMB3bQwrgtB1xfXItDCqV88JpDZpUWjbi9ANNCHIpttw7AJte3bxm2u+wJvPP87zzz9Pa2srs2bN6nJe9fX1/PKXv6TQuodH/nwHG5cu4Effv476+npsL2B3pkhT1sbrVK9uaGjg8iu/zoI1m9jV0oZtO9iez/ZUgeacQ2NjY+gk2PH1aLcUBjUjb0ulWbz4DR7950P88Cc/494HHuaEkycRSKX7dKDSxeLFi0OUmYsfSsvbto3tOCHZsSPx7k1l8QMfQzeUHIkQrF67jg079pIquGzZtoMXXpnDzdPv4uJPf3a/n5mUEmnnCbIt+G27S8mx/dpc18OyLCSKGKuSlkd5Ik4ikaCiqpqa2lqEYZaIqe33YuqxR/G3e//EVVddRS6X46iBvSi6Lm25PEXHxfV87HbJeU3r1HzuQNat3bGXMy/6DORTCCvSDQVZcD3GDqztAlL4T8cHJaz3YQkL4IzjRvGbv80M2eXh90gzCIBCy7b9bvdWmrE9vXdJYws/+eebZJIjcQsFTK+NMnsrXj5NvvoI9vYbwo8eXMpXTh/BwJrug+09j7/M7fP2IvqciNZPY6uEab99kFvpaNhOnVrP1Kn1XPvXBl7fZaOF3Alov1ChJOBLPRoIPIfAKdIy6++YTo6rfnArU6ZMYdXuDPM3tSCl5NjBVYztU96t7n7umDp2NTWxLaMhA9XTmXXf70g3baf+ws9jxRJsWTqPyz/+YQy95/mKEILx1TqPzZ7J6OMmownBghlP8Njdv+XwkcMP6tXR073ekSqwqSXf6SAwuneS5YvmM23aNL78ze9iRaI4dhHHtikrK8M0TZqyNiNGjGTWjGe46LNfCs9PQwqdguOSaWvl9dfmsuLNJXz681/iq1+/BgkYusGutiym3q5zJWnd08T8uXPo278/2UyGAf36cOLxx7Ni5UrOHDgIx1aimslkUs3QgUKxiGVZRMJkMf6YicyfN5d1q1eiIdi6YycnTZrMpJM7eB/HTIGLP0e3eHX2bBYvmIvn2Jw++QSGDRqAZZpq5aGbtNsD+74SbvQ8n0denMeZx48lYllUJBMIAa3pDNUVqnchLEup6gY+EijaSpo/l2ot9W62zJuJrgmKjkfeESVRSFOPYBoG6UKBmKkT0TUKjsfTy7cybOp5TJk6lSCfVr1F3SKXyah+iB9g6hrNmUIXkMJ/NKQk8D6oYb0vE8jxYwZRbnmkXatU2QkQGNJhTP/3xhZzy94cV9w5H8cLMIWkGHgUiFGgjli/I4nH43jCZOabO5i7pom/XHUy/ao7/B4KjsedC9vULB1Zkgzh8DP41V1dSyfPvdjAgm1ZhFQAWGHFSnpVAomhhcq0vq/guyE/oX+vStIpmD59Ok3lI5i5ajuFooMfBLy0YjOHV5tccOJYBIIRvRJYhkbU0LnqjPHMnDWbvz7wMGuXvk6yooIaC+be96tOsNkDI49OqZ+ChmT69JtKcNuH/3FoJaF9I+94bGrJl/SvPM/HtEyWOw533v0nEokEQ0eMBimJl1XQbsrlBRJDgyu/fjXf+uY1DB4+ghMmn0IkqsinIKjuVcupHzqPEyZNIR6L4TihzpmuowkNz/dJtbWiGwZlVTWcetaH8T0HUGW8ha+/QePGxtDjPqAsUV5SCpZAPpdXxD5NxzTV1/OEE0/ihBNP2v8F9xBvLJjH0Jo4o847m1jEwtIFtuPQnMlgmSaJeAykQBcylI5Xf76yZCV/e+p5ygzBfb+4Ds/30TWdXNEmGYsiJGiWhV8sUCiG1y4EWmhMVV9fTzD+CPa++kQJ4Qjqcc3ZDpv3pBg7qA40Db3vCBIjJ/KFj3fIkGjxcrSqPljNO3FjMTKZLJpQgI0Zq7dTkYhx9RWXv+Vn4t0OyQcwXnifJhAhBLd/61wu//E95CL9QGiU+81UZFdyzY9uek+O+cCcRmwvQAQemUwGIQSGrqHXDEJ6BWTgkU4pWG/OsPj5P2bzuyvPKm2/sLEFzw/QO/VOBBI0g+1BV/jiH+/7G+Lw8xXc1PeRhSy+Zij+igYR00IXAreYR2v3VN/4GkjFY9jelmfmqh1k2v3hhSDQdFZnDW5rWIehC/LZLBueupteosBVV13FmVPrOWL8RB5fvpPmvJJKH9ErwUfG9ulqb3uAONAKr6GhgX/OmIWIleFnWrj4nDP2+949OVUKSqXSCE2g6xqe55HJZJGRBMlkklRrC7X9BoQimaLEp3B8yTPPv8BnLrmEF596jCOPPpYgCLCsCLphhN4xOpVVVeq+BD6+HxCLxkqlJ9M0MQwThCL9OUW1EtJ1HTOaYNOmRlzXxTDMLjLzSInneRSLRSIRC/Ntfj2llPSOGyXpdF1TycmyTGzbxvX8EgjAsR3Kkgky2SwPP/sSbeksmqajRyIITUdHff6ep2xwy+JRkJDNF9FCSPM9T77EV77aMaiL8l7Y8WrM7F4MTYErPD/gydeWM/zUC4iEMOb9iUZGjj8Pe+5jJNJ7MU2TQj7Pk0s38KX68RzWpwp2L2T2rc/x0yfnUda779vi9bzjkB8QCeF92ANpjw+deRp/+ellnFK9iSFtLzKxVxu//eWBMfTvJBp3Z5UTXDtHRGhonWDBXWC9gc9Lizfw1ydeYuGGZnJFT/kp6Dq+lATCxNej+FqEQEJFdVfhva2rlymhxU59Dy3wCBybSSNq+c5poxlVV4ZuRgnsAqx5BTa8BigW9KDxJ1EoFDo4JUJDj8RRQn5F0uk0gRAMO+8rNGcKTJs2jRkvz+buuevZ3NRCW/Ne0qlWVu1s5W+vb3vHjcQXG2azVtZw/Me/yHEfvpCTPnEZK50yXt6PorCUkqKj5FvadajaUW+e55PNZmnaub1r8ujYmHM/+QVeeLmBq785jbo+fXBdF93YdzBXjWHD6OpvEe6i5ATYuffkBz6JZJIvXXop//PDH5JqayttFwQB2Ww25DUEXbZ7qyE9B0PXw/10OeMQGSXJ5PLYjsOm7Tswk5XsLGq8sGApu3fvpra2lmuv+wGxeAJdC0EEgOf75IsOezN52nIFVjZu465n5nD8hy/s8r0RQjCg/nyakgNZtm0Pr67YyB9efIPhp5xPfX19qam+vxDRBNFTLyF66iWU1V9M3YXX8JmpxzJ2QG8CBG2ZDCOrY/zq4sk0793TBUr87wwZyEP6+W+O9+UKpD3eLsHs7cRRQ6pYtKG5VG8GQhgmBL4XKv62Q04MRFktt85qIbFwPrlcATa+hDHmDKShBnIAKUBoBs3R/hx5wRWMjKS45orLGDp4IE1rGhCHn4okNLYSGob0+NrkYfStiDFlRC9mzWrg2mtvJJFIdJH5OP2Uel7c5nSIAOodj0ng+5hCIKQi+/U+8iTie7Zz/5yV9Bo9HiH9EiM8m06zA9iRLtL/EF0Ee4o1eZOK2nKFy5Hqusure7F0Uyun9PD+mkQE13G6qN0qmLHGxlVvgu+Ry2ZxHRsr0iGjocpIEk3XOe3cj/LXv9zHd278RYkI1/l9jusTjZhouo7nKZXddsmSIFDlKR0D3/c6bQeaoXHSSSfhex5nn3Um//rXIwwcNAjHUYN+JBpVvu2BQj3pupoKeK6HDCHOhtG5NCSRnkvgFkFKNCsKUmLoOl74rNmuT6y0CmyH/Rps2raTL37rRyxatIhxtUN5+OGuelpBphl92yocu4jr+RimgWFF6TN2MsKMMBzYV4FLOkVwC8xdtITtSxYw+bDBRCIWk06IUTl2zAE/ZykDgubtBKm9iGgCvW4IWnkv3MY3kZ6DMAxy6YwCZQQKvfe540ezbGsTd95x2793FSL/+5PDocT7cgXS0NDARRddxMSJE7nooov+LbOXi04aQjKqykiBDGHEQmAUW5Wyk9AUNBANYZrKn911SKcViU0OOwU/3Uo75FglD6WFYiRrMA47jc39z2Ta937ApEmTyC1/GfnGY2i5vUi3gLd1GVcdXdbFDnbqVNX0rK2tLc08b731Vj51+gmKpdyOQiqNwxJC/wjXdRG6QeX40+h3yidJjJiAq0eQQqHKhNAQmiCfz5MqdgyigZQ0tuSYu6mFN3emKXr7dyz2goAdqTzltf1KyaN9uSCBmkHDe9yuLGKw5o35IDQM00I3TBAaMx/+G0MHDeTWW2+ldc8u7JB7EgRByW4VlBRN3wEDWbTgNUxdEIt2Sn5h0s/lcuRyeXxPXVsun8d1XTzXVSvF8LqKuZyqlwcSw9CVdYAQ1NfX89e//pWf/OR/SaVSGIZBsqyMaFQROm3HoWnvXu75871sWL+e5r17SLW1USzkse1iaXXhF3N4+RSBYxO4Dl4+je/aRKKx0irEdn1czy+JeWqaRq5Q4OY7/nzAhrRWVkNk6FEk6wZRVdePsgEjiY86DmFGur1X+h7+xsUUl77I7tdmMM5o5awJh4FQvRcvn6G4bBbuytl4W1ci7UK37Z3XnsJ543m8dQtxV8zBbniAINOCzLYpRWEUMkwIgaVrlEdMPjSqlmumHM7/ThmKt+vfh876AMar4j+yAhFCPAi0CwJVAm1SyvFCiCHAKmBN+Lv5Usp3tWPW0NDAtGnTSCQS1NXV0dTUdEi6T+80asoi/O2ayfzw3peZs6oJEeSpya1B272ELdEjSI44CdDQ8JDSVXwOKdGErpqIUhDEqrFKrOSuuV8IgYyUYY2YxJw5czr0n575zQH1n3pahfmBZEpfg5e2FgmEhub7CAOEZ6PpGq7nhbDSCE4+Q+C6qilqWrhaBCsolmQ2AinpU6YGnJdmNfD85hyRqt4YVpRoxGROY4QLx/WjNtl1UGpszjFvSyu2Y2OFMGTZDh4QAHK/irYAE0cO5Nc3/YBxx5+sBAznz2bLxvWlz3nKlCk80bCAZHl5STxTCIFjq6SydsWbDB06lLryGDslFB23xIK37aJCE6XTXPPlzxFPJNi7Zw996ur47Je+wrARI9myqZFsOsVpZ5yJ5/lYEQvpe4wYOrjLvQf4nx/9kA+fcw4fPuccdN1ASkk6nUYAH/voBTh2kUI+ryRHbJvKyko0oWGaBoFTCBNryMNxbAqpFLf98R6+8umLMEOuSN7xWb50Oa7jImXAA48+xYwXZ/GDH1x/wOdWRMsQfcsO+B6AYNsqnOYdtKXTyCDAMg0wDRzHxXEdyiMGWuDh7N4Ke3dg7liHccRktDIlye9tWkaQasJxPXL5PL7vE7VMgtmPUzPuZNCMsNFvgAyIm+0CkwoqGzVNirP/ReL8q3oUZ3zXQ4Lv/Xcnh0OJ/5Qn+ifa/y6EuBVIdfr1Binl+Pfq2NOnTyeRSFBeroTZ2v88FN2ndxr9a+LcM+0cGhoauoj7XThpBH+5/7fEy6owawaxt98paqbbqYYfBAFaB3y+x5BBgOg9ksbZLyH6HsHJX/0p5ycjnH54HX0qDu1LtWhLK79/aTWpnOJOeG27aH1jBqOOmUTF/2vvvOOsqs79/azdTp0Zht5hQECKgIKgUUDFbizRGI3GxBaNV9I1P1M0lpuricGUizHR3OgNiZoQjSUqBtsgWCiC9N6GOjDtzJy22/r9sfc502EYZ4Cr+/l8NnPY55y91i5nv3u9632/7/Enk8pkkI6DoXs3RNf2kt8cy4Swi1S8kFcvKd0lXbaertFTKC0t5fEX3mDUOZcjXQfbzFCbSSOLCnl13T6+NmFA3i9enbZYuL0S07JIpdJoBZofCupPOPs3zOryPcCgFvcjdy4bHueGDwlCCLooWVYvX8rIsSd6woGZDK7rkM2keOvVl7j3nrsxNIWBXaOkTJtk1mbtxs1ous7m9Wt545UX6d2zB4lEglHHj2DGjBnNRBuHDuiL43oSM2oLGlo5A57JesdbCKisrPKSL20bQ1PJpv2ERtdF0zRqa2spLta8MNJGxsOktraOUMhg0KBB3Pz9H3Hi6JF87avXMWz4cE7UdbKZDKqmMm7MGP7jpuu5474H8/Lz7UW6DrJ6L8lkyh951r8Xi0VR62wv01wCQlKdqKVLIYhNSxDjz0EIgbN7A5Zlk/ADTPKRYalqFq/fwvh4MW5tBbFoFDvrBSVYjoNpefkloWjUC0LYvRl98MFdZR1F4MI6ynMgwrtjfAk4dNpwB7Fmyx5qQ4Oo3WeguSnYvwqzeieKolBaWnpE/KgtPfWPHz+eWbNmsWX7KpQB5xCJRMikUjj+BK10bazdGzGGtJwpL23Lq0eeSVBwzu38Yu46TMdFFYK/LS7j3ktGM2HQwcXmyqrSPPLmOmrr6hBSogqB0q0vXSecx42nD6Dv6GHc9av/QVEVkuECigcO837smgpCwcqmUTUdx81ipesoW/IW377qIsC7kQ+95Oa8N0wIgatAOpkkoevUZu28dtXGA3WYjostBUYkStZxiOTCkP2QW+m6rHj9H3DB5MM6zo3enzqV0tJS/vXMU4w6aTLRWJyVyxazcfkS7r3n7kbGJhbSiYV01tZV8G1/BNtUHr619hRFbbauKQ0nlXPzZJ4LxJ8rIzdnJuonx/0Sy/gjM01VKO5ShOMnMmq6wcIly9i4YxdP//5XSOnm3WmKqjK0ZCBXXfr5T/7w5Nhe9rpjoypqo0p9QlEI6ZqndyAEju0VdKtLpijWddzqfWCbICXpjBe4EdI1onr9ramkYg36lEtwy8sQZesQSKxshppkBs0X6wz5+Sk4zcsFdwa549jZCCEeBi4GTGAzcIOUstp/74fATYADfEtK+bq/fgLwFBABXgW+LTvJl3a050CmAPuklBsbrCsRQiwTQpQKIaZ0ZGPL1m6nTB3BgWwI05Ek7BCJ4pOQ8X5omnbUojmgXnRv6YcL+fGVJ6PrBno4ivTnRpzq3ex59RGy5VvrM8h93Eydp3OFi5uqQus6wBM1dB3qEjVUVFbx3Sff4e1D6GrNW7+PVDqL8Ec/CBDSQe/Si0dn/40RPQvQNi3kwLvPoe5dj6YoGKEIerQQPRJHC0VB0Zj723tYOfshvnv1RZx5hndj2rp1a7MSrt4Nxcm7j2xXsqsmzdbKFJbt4kiJIwWWK0iaNpbjUFN5gGXz5/HU3bdz7Rc+3yHH/d677qB3UZTKygP0GTiE404YD6Lln0YuWa7pvNHUqVM/kb9b17T8ac09fYfDYcp27crniORGYIZhoGqarzDgGdOcTpbn5lGYOGE8APF4nHSyDhyHTCbbSElYSjhryimcNflE7PJt2Ad24KYTh78fmgFGmLDhFZRSVIWUnyNimaavi+npiGUsbw7DcRxkNo29qhR7/YcI1yESi6EIXyLHnxG0XRdXulir3kUf9Tmin7+NgunXooejdO/ejeLiYs94+EZW7TW43efgsGjj/EcH3LfnAWOklGOBDcAPAYQQo4CrgdHA+cDvhMiHdT4G3AIM85fzm260o+g0AyKEeEMIsaqF5dIGH/sy8EyD/+8BBkopTwS+BzwthGixCIAQ4hYhxBIhxJL9+w9SLa0B9//hJU9eAxfHtr1EOykwi8dw3HHDiMVizJo1q5173HFcecogZt0wkYsmDGR03wKimXKUdDWxoaegLPoTxeufx9m2CKtqj2c8XAdFEXQ/8BHHTzoDTdOwTMsLt3VdFCQOCj+4/5cHNZAVSdOvSNdc9mRPpaekm5Or2Lv6QzIVu7yoH+q9aq5jMeXWe0g1EU4sKSmhbNnC+hWqhmJE0GMFhFSFA8ksTy7eznMfl7GzOoUlG4chOxLSjuS+m67gbzN/yj0//EGHjRYXLFtNNlJM/yEjGDh0GJOnX8ierELp/Pktfj5n7JcsWcKMGTNYvm4jH6zexKqyctZs39ts39uCoiiEQl72eTweR9d1Nm/axKWXXsarr72GpqooiuJFVZkmmm4ghEJ5ZXV+pJIjUVvHgD59OXXSROrqvBIAAJqmNQrtFQL69+jKVRefR6KqguoD5VTt2Mj21R8dVt+FECj9RxEKR9A1BV31VB2qEnVs3bmHpGlhOy516Syu9AxdQVgHKTEti6qqKipqEghVIxaN5s+6KyU1yTSuN2ONU77DO1bd++fdVNK2kLaFQKKPPg0l3uWwj317ORJhvFLKf0spcxfUB0B///WlwLNSyqyUciuwCZgkhOgDFEop3/dHHX8GLvtEnTgInWZApJRnSynHtLC8CCCE0IDLgb81+E5WSlnhv16KN2Qb3sr2H5dSTpRSTuzRo0dLH2nG8nU7iEXC+XkPCSAkSihOl67djymdnZH9iuhZYLB+v0MqOhC1/3i6TL6W7LjrKVu1iONSK/nt5SW8/P8u4C/fOY+FD1zO3Cd+Ru8e3ZDU55sIRfgRWwqRkH5QA3lC3yJURTR5ahJIIegT9S6V/BN49+7sXb0YxzZxbMuLAMokca0siqbRa+TERm3NmDGDde/OZc/6FUjVQNHDCMVTfK0zHeas2E0qY5JI1KA2qLvinSP/tQTNCB9UtFBKyYGkyfJd1byyZC3f+uE9TDz55Faj7SzHxTTi3g3KsXAcG9dx6DtgEBvK6/jJAw+2anRzqr1Tzz6fcDhMNp0mY9uUVSTIWK1Hl7WGpqqEDB1NNzDCEQYNGcqf//o0j/3+caafcy6/fOQRtu8oo/+AgXkjv2XLFuqSaZKpFKbtIIVKYVEXItEIt95wHTP/6z5uuPFGhGYQj8eQUuaNiKZ4I4FMNovpiyfatk1MdXlvwbuH1XelsDuRMVNIGYVs31/JP95exE9mv8Y75ZKL736Uecv8uBgJIV1DVwS2lNQmaonoKsWxCKqioEeiWAhq01kOJJJ+FUb/i34klhCC0KQLiUy9En3oePRhE4hM/wqhMS2X9e0sDsOAdM897PrLLe1s8kbgNf91P6CswXs7/XX9/NdN13cKR9OFdTawTkqZ31khRI/cMEwIMQRv+LWloxrs06MLjuMSMgyMUAhd1zE0HU0BVXgVBo8FnR3TdvmPJz7k0bnryVgOluNio+FKgRLthhj0ubzPvV9xlFF9iwjrKq+98TYfLP6IRMrEVsNeNUQAoaJkE8QV86AGctrQ7vSIh72JcBQQXtW62hVv881bb2J3TYZlO6sZceJk5syZw7e++30ikQi2beLKerVYhEKksKhRW9OmTeMr117Da0/MxHWdvA6yK72a8rYjSaXTXoKlImg4BsrNmwOMmHDqQUce68rr+HBHFVsr6qhxVCZfcg1fvO3OfLRdU2OQNB1M08z/X1VUioq6EIlEOeGkiZz9hS9TVue0OBr5w+OPc/aFF3s3ZSkRioJr22SzJtVps9nnD4XruqQypieRISWO49Cvf3/+/tzzlJSUsHDhe2TNxttd+N4HSCASi2OEwiiq6rkzVQ0UlYH9+6HYWZas3YxuhCkqKsq7y2oTnvKxoqr1OT9C4Dgub73+WvMOHgIRKWDAKedx0hdv4dafPswTT/2Zb3/721xz7Vf45iN/4qYHH8MFtFDIKx8gJV3iEQytvjqiAIxIDMfFT9TUyJ19pXv/+raEQO3eF33waPQhJ6B0bb1EcGcgpa9Q3IYFOJB72PWXxxtuqy3eGiHEjwEb+GtuVUvdOsj6TuFoTqJfTWP3FcBU4H4hhI03MfQNKWVlRzX4va+ey7cfehrbcTAMg9raWkAQSW2lzKxtVgzoaDF3+S5WllX7Q3c3L3uFEUFmkzjdjueee+5pdDN8/c23ufvtGkS0D6rr+aFRQjiOgkhXE9/wGslDGMiIofKrqybx2KsfsHDTPtKJKuIVm/jR1Rew2OnLE/9cTjqVxJEStXIHZ5x4PBk75mepAzpIKwOuS9WWNc3aWrBgARPPvQQt5OVV5Gp+5K5uB4HmS8G39GgjpcQxM3z9O3fSddhYuvfuy3F9unHBpBMIaypJ02ZLZRIBpJJ1uP5k9MBR4zjuhBPZtHJZswljXRHouoZje667WCyef8+2vMnhAYOHMn/ui0xrUkmwuibhlQtrMGITQmBaJqYvtOe4ktqMSdryhAvjYZ2YoTVzE2ZMi9pU2qt/LuonzB3bRjd0pk47g9fnvtas/2s3bMI0TeIFBU2y4SWRSJSaTJohgwdx7U3f4Cd3382UUycRcRyEbuCmaqjesyNvPHRNy4s49iwuzCcufhJKS0uZPXs2Q4cO5cFvfplQyKA2nUEP6+DYKKK+xkruOChCEC+IY/v5LhKBNnQCSqQ+nNjasQbr47dzO4sIRQidehlKYbdP1N+2I72nn47YkpRnH+x9IcTXgM8D0xtMhu8EBjT4WH9gt7++fwvrO4WjNgKRUl4vpfx9k3XPSSlHSynHSSlPklK+3JFtXnH2RH5626UgXVLpNKqqEk7twN67gh07dnDdda3LYR9J3ly514vwEI1dOACoOlqsC3tKLud7s5fy0VbPvv78hY8QujcfYVsOZtbCthxsV7DhmQfYtWFlPlroYMRDGnd+4XReuPMKXn/gZp773UPsjg9m2Y4KamtrvJBUVUP2Gsa7e12k4zTO+NbDbF30FjvWrWjW1ooVKwh16+v/T+aysfKTjYrwIo/MbKZxp/z3bdMkHosx/tKvUTJ2IrFuvdltasz5aCsZy+FA0ns6z914c9naiqrR97iRLbooo4ZKxNC9SWlRX9BJSolt+dtTFAYNH9XsWBUVFrQgYyLRNI0P3lvAlKlTWbJ6PVV1aRz/abQ6laU61XgUYdkOiboUZtb05c1B1XXi8TiudNE0nYLCwhb7f9PNN7N63Xqy2Ww+sELK+qRI4UeAdS0uZtasWShGBCUSR2gGSrQon1gYCYeIRSNomgpILjvvTCo2rWJ+aSkz//MePp73PHuWlbJn9SLvIaGN5MLmh/TvQ88ucSzHj8KyfLkWX9ZE8VVN69IZkpks63ft55Vlm3hu0Vq2dxuJPnR8fpvOvq1Yy+aBY3sBH0Ig00myC5/3IrGOAFIeGTl3IcT5wP8DLpFSNpCX5iXgaiFESAhRguetWSSl3APUCiFO8aNcvwq8+Ik6cRCOdhTWEUUIwS1fPIPJxbsZFy3jjL6VnD6ikJKJF8Kwy7j3mVV87+G/sb+q9pDbWrN1H8+XrmbZht0dnm0aD+sgQG8qfy5BC0dQwnHUeA/mfbSFG2e9xSPPvEEi3BvIPc15n3UdF+lI4sNOoaKiol3JklJK3li7h0RNNY4j0aMFaKEImm6AqlOVzGKaFrZtY5kmqbo6Kss2t3hMksmk7xPOubrqd0wIgWHoCCOMjULGtPLhuhKJY1v8+7EHOf/62xECHNtCSgfpOCSzFmv313rCff4WVU3L30yk62Jl0i26KIUQTBjSl4imoKr14baZdKpRpJvWQg7HN269lVf/OQeBrxkm8ZV7BaXz5vL5y64gFi+gpqYa0zI9QyMhaVoNfPteZFLWzGJZVv1x8Q2RlGDbNps3bWyx/9OmTWPY8BFks1nqUinfeNS/rwhBbV0dyXS6mfERmsHOhEVtXZKQ4UV0mZZFVY2nfuCYafasX871l57LgD690RSFMDbpHWuRVrbZ8WiJrVu3Eo/Hm4zSFFwkit9m/YNSfb35f723jB8/9QJm/zGk1UheOWLWXbeTfv9FkK5XGdS1wLURqoq0TNyK1ssxdDTSddq0fEJmAQXAPCHEciHE7wGklKuBvwNrgLnA7VLKXGO3AX/Em1jfTP28SYfzmdTC2r7NK72pCFhZXcyBTAgHgbQFv/v7Wzz27L8pOrCAojCMHTu2URZ3Omtx+Z2P89HGvbi2g6KqHD+oBy8/cguFsU+WAWvZLpoquHzyAN5ZvRctpGCaFtJ/wvWEFm0cM+X5gJE4Ljz53l7Cuklrrs6SPt2prejdrtHVS2/Mpy6rIHSDUDjaXARPUUnZ0lcJFqBoIDSqqqr4r/9+nOJh4+lXFKFbzCAajVK25iMGjZtEOBqrzySXXkEsgYuLQLqQSdRhJWsY17cLJxx/HCO6x3hlZp1fyjWXByHQDAOE4N2PN1C1ewdjTj4VIQTRWAF1iRo/Xt9h1QfzWx2BhTSFzx0/kLRps7JsP5msZxBzoafSsRnYo0uz7031XVr/+OtTXHDZlfTo1RvHsXGyJjd/8w4S1ZWerIljk0wmCRmhfB6L6bj53BZvtONNYluWha7r+TOpaRqrVq5g2Ucftdr/QUOO48DuMlw//0PxM+Zdx5vfefyp2dTW1rbovhw/6VRWLf2QqpoEtu1VAlT9iC9VVbjgjNOxsmkc1wEBpmWjKFlCif2o3fo3215TSkpKKC8vR1EU9lTV0q9bIaZlUxAOeSNERa3XghNQFIuyc38lS3ZVMXToUB599FGEEPTu3ZtRQwZyxdgBWKZJSNfyCZRIt3701UbD9omRsiOMQxuakccd5L2fAT9rYf0SYExn9ivHZ9KA5C/qaFcOZEPYKPX3XglSaFQXTya17WXCGzY0kjr53sNPs3jdHoTw5hlc6bJ66z5ueWA2zz709Xb154k5b/Cb1zaRIo6muHx+fHduOms4f3xrE4URjZraOlwrC8JB6BGE8PzVACoSVzXQdy3CLOzbeMMChOtgb13U5uCAhlny/SefS2bYGYSiMVQj0iyPI4crvQlRIQSoGka8kCnf+SUFvQbw67nL0A2DEV00xo0fz5Ztq0lWHfBdVp7AoSIgqkVJpjO4vtYRUmLEi8g4kpE9Pd93j65dEMIzIEJRMSL1wpJG917Ei7uTSCQoKChAURRihUWkk7X8639+S0RXDzkCixga4wb15OPt+0n7k9i6rqNaSU49+cQG+yvZX5ulOm3RdegJjK7JEo5EqK6swLZtEALDMOjeqw/g5PMecqq2AIm0iaYo6Kq3eIbGobaujpBhEAqHka7Lwz9/kEUffsiggQNblaNRVJU9ByopjHgijKGQQU1NDf984UXmv/chldXVB3VfjhozhvKNq/L1R3JIKXFcp1HdCyEElmWDmWq6mRaZMWMG3//+9wF4Yu773H/dhRQXRVEcb4SJpiEVFdfMgitxENzxv6+iReIURmDNmjUADB8+nJMG9kBRBJYrMXyLk7sipXRAKKjdOi3gqBHeqPjww7U/bXymXFg5crkM+xNW6/EJqoEoHMD+/fsb5Ye8uHCDl6TXUCZcwNvLy3Ccw/e//uWFN3nw1V2kRQxFuDiu5IWlB/hw+Xr+ddeZPPSVk7njrJ6MrXoVw65FKCq6ptcr+uL56LPbP2Jaf81/KPPmT4RjY6z4G+lkbZuCA3I6YeXl5fTsN5DMcdOwLQszVXfI79oueTfF8LO+QFG/EqT0ksAc22ZNpcmYc65AuDbrXvwjdbs245gZEvt2MjLukM5mcf1JVUHu+Eo2V9WL7n39+q+yZ/M6hFAxwlH/3NVnaUtFwZFQVVXlBUgIwZmjBvPMH3/HnDlzDjkCKy0t5StfvpoZX76Et17+B5GQTryggC49+1Kdrs9w3lWdpsqvn55I1DBizAnEC3LpSp7xsywL13E8cUxFJRSO4DQQbjRtl/JEGttxCRk6qqqiaiqqquFKqK2t4+GfP8SVV1zBog8/PGT/x514EmX7DvDgzF9x7Q1f5/pbb+eFV1+nbNeuRiWVpZQ4mSRW4gBW4gBOJgl6hKxpYuhGvkaJqqrYlo1tmk0i4qRnaLTmgoot0TDx8sIJIzAd7xrP/+yE8OqKhKPUOVCRthCh+kJqpmmiCSiKhPIyNpYj8yWK/Wk0APTjT2303U5FSi/rvS3Lp5jP5Agkd1Hf/8vfs3kP9b54fwIz9x9hFJBK7Gg0eWnZLkJtLE0hhPBuDtKrcH44/PqfS0Hti4Kb35aLy1trqtAUwZljenPmmN7cfMV0Fq7fz+2Pl+YNlec3VtAqNzJkQB9m3nw2iYzJ755/l/lvvEb5infoW1LCjDbOfeQmPOO9B2MNm4arhJCKwDRN7KpKirs3rjvS1J3luqAqknAsTrq6AsXPKVEUgYtkTQ0UDT+JERd59VdNNLr0LeHksUPY8MGG5gmMQpBN1T/pTps2DYd3eXfndvoNG0nuIDiOhap7tbqFpoPrkM1micbj7E9m6RE3ms8nNaGhyOaIUWP43HmXkLJdyGaxpc7miiQDHJfiiEHSdPL9sy0bR7UhIjwjkUr68f+e8XzvrTcZPnIkJUOGIgRYliclX1AQRzcMEhmLrrEQfXp2Y83a9VRVV7OjbAfLly7l8xddeFhux6nTpjH1IJ8vLS1Fs1MMGzLYCyAJR9AdC2GmKejag5Cu5s9BoqaG7/z0IS6YdioXT5/iixZ69WqMUAil8OC5V1K6kKpBWlmmTp7A1MlPUvnhq16QgaogHcWvmOmh4KIpCs8tWJZfF9ZVZn7jKi44eTS6rlObyqIqNo5rk7RciqMhsC1QBPpJ56H1H9FSVzqJI+PCOtb5TBoQ8G5Gb0ydyklX3c+6bXuQjYYiEqSFzFQTi0YbTV72DKXZZxagKvWfd6WgWE+ja4drPqDGCqFojYdBilBwbIu91WkKo/XlPk8b0YMvjSvimSUHcBXvyVar2gxrXmLGww8BUBg2uOua6dx1zfTD7svWrVvpcfxEMuMuBVUHFNDCoBq42TpSqRTRaOtPeC4SDYH0xQO9ffG0m2xXokfijLv0Ri8b2XWJxaIIzeBvy3aRKi8j1msgNPxRSkhsXQWck1911rQp/PYrN9Kj3/cRAsxsFlU3iGh6/jsAkXghliPZVJFk/b5qlrz2PG89/9dmysTJrM2a8lpqi0v40WNPs3bRu3QtLkY3DNLpNJlUilAoRCwWY1eNJ7MhoN7/DmTNLEKApusN3vNcPYs/fJ/JnzvdOz6uN7+QE0Ts1rUbpi/7rgjBmFHH+1s8hWuv+lKjYyul99Rt2Q5CgKFpfq2QtlFaWsrsp/7Ez+6+C9f1kiYz2SxFhUUYwiRi6FRWVfkjam+eJhyJkBBR3lm8gtNPHE3I0FH0EKHeQ1t80s+5P1OJKh790Qx6de+KYehIBFLRyZoW8Yg/T+jnGAnpeqHQSJZuLuPv7ywiGvV0xm6eOo5xA3th2g52JktYV3DRUBybaDTiHWc9hDbyc0fYeODdIgID8tl0YeUQQjD3se/SvUuc+lAQL+NVmHXI2l306NEj7z+WUvKTm85FdbO4UuKieP5/1+K+mw7/hg3QRUvT1PHlSomq6fQpbv4j/dFXz+FXl/VhcPk8tPd/y5C6JTzy8ENMnTqVj7dX8fTCbcz9eHe75DQGl5SQHX4WCNUTyBN4P1JFhUgR2axFMplsEC7a2PAJBI5jk64qR2jeRHDOt68oKk6yBlQV4VfzSyZTaIrAlTBuYE+SFeVeaL3waqXs3bCCK6c0F48M2Wlsy0QCiqpgm1kv4kp4UipGJIaqeYrAtm1RW1vHyKnnMfaUKY0SCt9e8B6lm/ZRkfSNULyQCWddxOCxEzGzWXLWyHVdEokE2ayZ16vK7bumaTiOS12dJ0Gu+/MXoXCIkr49+ca3vovia1vliMZiuK7Esu1DjoxyxzmVNUlnTU+B1nZIZrJkLavNtW1mzZrFuDGjMQzP0HqhswrpVAqki2manlSKqnoCiKEQX/3SFcx/910uv+E2eow7naIRJ1Nw3Iko0ebqQg3dn/fedh1F8Qg1iQRZ03fh2F453PpkUy/gQqo6KculJuPwrw9W8Mtfeu4umanjxJJ+6KFw3kNg2Q6uojF/0152RvuhjzqN0BnXoJeMPeQx7HjkkYrCOqb5TBsQgF7dCln9/AN869rp9CyOEdElBdYeimuW0Kd3L4YPH87MmTPZm41z4jUPcscfFhAL63QTNUTTZQwN7+dP3z+bay6/oF3t33HlyeDYOPiiiVLBFTqDe8TYuLumxXDYs886g5ee/iNL35/PnDlz+NzpU/j+Xz7iO39eyu/mbeDnL63hi796l2f/9fZhFc664dYZyHAB0rGQWoimTYtQhLL357J/3VLMZC1mXU0+50D6UiCpDYtZ+49HkbaFboQ8wT+hkK4+gFJXQW7aUwglX61PSsmYUaO4YGCY7W/+neUv/ZlNLz/JVRNK8mKMDfmP277BvP95BNe2UFUNzTBIJ+so37YJVYCma6hCENIUUskkIFFUjeGTp1FYWEgsFuOee+5h3f6UlyeRT2TzUxtVA9UXKszJwQhFIZ1OEzU04mE1X1CooLCQcCRKdU01X//y5Tz+20d4+sknyBzYRVhX0XWdTCZNNmuSD2AWglgsRiqZ9DShDoHtuDiOm1du96OBqU2mue+++ygvL29U26al87x161YyWdOb5M+dT+HVdAcvVLiR0KIr6dKlMO+6FUJBqM0TIHPk3J/9+/TiuAG9sW3Xf0hIepPdiooajmE7Tj63KbcfjnSxHZsKU+R1xv713BwKi4owTRNV8Y6jYRgoqkr/Xt356RPPog0e26IxOyLIIxbGe0zzmTcgAIXxCL/4zpXsmPcIVe8/wf6Vr7G7bBvr169nzpw5VLpF3Pmbf7KvooZ0qo4DVdXsTSpce8kZfPDiH/j8+QdNJD3oU+JVF0/nvssGUuhU4KAhVQNN09hT6/L1WQt4+PmVh+z/i0t2snRrJYrw/MaqIqiqTfPgKxvZ14abS46zpp5OPBbLy2AAjVRFbcvFVgyW/OkBEru3oEdi+Sxi17HRFJVhp0zn/X+/xJeG6Jibl1K1fhmrXnqSfz94G8ve+CdmLrtYuv6EsXfTLukW44wzpvHkb37B84//mtl/aF1ifNq0adxx280s/NMvmf/ME2xeMJeRei0/vPJsvnDSUKKGlvfnO47jh+O6hGNeNFc8HmfFihX0GzKswQ0xH8/jhcAiUFUNVVPzkvUfvDMPVRH09cOSPckVwca1K/nuTdeycd0a1q9cxiXnTee0U08BJLFojGgshmbo/rHy3EOW7fDgvT/BaIPb03KcvPHIIYSXVzNh4skUFhaiKEreOLakd1ZSUsJb7y7AtKx8tJWUnuR7rk9Na6gvXLS0zdF7uXwPVVGoH2R4xz+HUdyDA3oxVbXeKDaTNUnUpciYNj964jlu/cZt9fsXKwIpcVsQ99ywr/qoa9ZJKbFtu03Lp5nAgLSBh2e/gWlapJK1uK7j/0hcfvfce4d8qm84tG/tRn7dZdN58Rc3UVwQpVvcoDgeIhryIqqeXbCFdTurD9rGK8t3+XH09T+0TCaFiBQT69bvkDeXHBFDZcrw3oQinpxH45+tF9lV0G8Y2UQlW1+fjWOZ2NkUTjpJl1iEaEinIpnlo7JqLjxrKn++79vMmD6axNoPMFNJ9q7/mLIVH3hJdIpGOBoD4OzhPSgIHd503LRp03jmr3/h2T/8hl/dfSdnT/WE9ArD3jxELvQ0J40uEOzZ5IWE1tV5UWW2WZ+9LRr8K6Xklb/PxjKzaJoOCJbOf4uPF7wJePMVPQvC7Fn7ETd84Vz++KuHGNCvD2PHjvWeuH3Cuoqm64QjUS9z2RcydF2v9nrYOPToo/l5qKfhzTlHa4KgM2bMYP/+A9z9nw9zoKLSG1n5IwMlXkwkEvFCllUVVVXYu/8A/3h5bpulfUpKSqirq6OqNsneimp0zS8Ipap5MTOlsAcjTjuXPmdfy9JsF3736nvc99SL3PnUK9z4ze81emAQegh14Eh0TUf1C6sZmkratHnhg1XHgGad9JMY27B8ivnMTqIfDjv3VZP1i93ktIEEAkcJ8dv/PngxnrZWQFywdi+uH6GSQxGCrOXw7uq9HN+/S6tttJQI7zo2itr49LZFbfj2qUPYtL+OzfvrGoQVyPzktFVXTTQaZcjYkwEQrovt1kclZW2HbZUpJg/umt/P3r17061bN7Zt28Y7j/+MQWMnM376xZzzxSsY36+Ifg3qtH9SVEUwrk8hy3YncKQkGouTTNZRW13B+g9LSSQSJJNJxo0bx6I3X2XapVfn5UO8fVAQ0uGDf7/MinffpGefPlTs309NdRUzZ85s1Nahzq2qKIR1laRZb6QkYJkmlmVx64xvtmmfDF3zaprLBrlzEhzbZumSxcRisfxnWxMEzUUezpo1i2u/PoNTJk/iuq98hUmneImXqhGmYtN6du7YztsL32fdlh3c/8ADbY4Ca5jv8eicufz4xssxNJV43O9bKIoors9TOm3amZw27cyDblMbciL7tu0is2UFXeIR1uyqYHbpMnaWVzBz5o/a1K9OQ0pkCwb8s0ZgQNrAsIE9WbSiqpGchQQiis32bQe/IW/d6mW9N6SlG3nIn/RtiqoIwsbB3RwXju/Lo//ekBfgA1C0ECJdiWrVy7K0RW04FtL46YUjuWn2YkxvRjv/nnRdqla8zahRo4gJG6TrG736y8hQFXoX1mfk5/ZfURS6dfOE7lzXZfVLT3LRPbcftC/tZXDXGAUhnU2VSdKmQzJTyV+efoyd27flo7AA7vzBD+jVfxAjTprsGQ4Bimtz2tBePPyLX3gVIjduoKSkhHvu/kmzm2lbzm1YV0nbDo7tYlpWXrMqHovTZ0DbFGRVRSFkeFFMNHAPVR3YTyKRwHGcZtURW+JgFRqFHmLgyLEMHDmWz513cZv61XTbOQP14fKV/Oj3FnfN+DpdewxEhAsgXnzYwoxCCE6YfjGlWiG/aKU08dFCwhHT3TqWCQxIG/jJTedz+fc2eUKCCCQCISS95c5D3pBzWe+5p1No+UZ+1ti+PPTcx9iOmx+F2I6LqgjOGX/w7NovTBzAwg37WbGjGtN0MDSFoliY2kXPUUuyTTeXhvTrEuG80X2Yt2YPWcv3v+NSrFrUZvagR8I45VsQyRpErAvRaBQpJZYrKQhpTGpQOret+9/RdIsZdIv5IdBDu3PRqbObfSZnJF7+8+856ZQpXHTe2Zx52inAocvhQtv2LRbSqU5baJqKrmtEo5G8Sy2it/3nF9I1DE3N101XFYVJk07O37Qb1mE/WjfXthyzY2m7n4wgDwQCA9Imzpw4nPtumMr9j7+CpcaIqha95C601B5mzJh50O82HNof7EbetSDEw9dP4gf/u9h3GXsJePdfM4HeLYTzNkTXFH593QSWba9iVVk13QtCTBvZiyVnRtt9c/nWGccxuk8hr63ZS9Z2mTK0O5eO7cPi8ZH8Ngcvf5HjLrmFPbaG5UqO71XAjZMHEdHrR0xt3f+jwSe9MbVl33RVoVvMoCJp5g2HQNA9HvL1w9qOEKJZrtGxeXP9DBDkgQAgOqnW+hFl4sSJcsmSJZ3eTkOdqMO5IR/O92rTFu+vK8eVklOP70lRg0TCYxXL8RRgDa1lF0V7j9v/Bdq6b47rkvarFEZ1LZ9oGXDkEUIslVJO/CTbUAv6yPjE69v02cQ7D33i9o5VAgMSEBDwmaJjDEhvGT/pujZ9NjH/l59aAxK4sAICAgIOG5lPwvwsExiQgICAgMNFEoTxEhiQgICAgHYQRGFBYEACAgICDhspvTLLn3UCAxIQEBBwmOiqQq9DhNfn2NHJfTmafCqisIQQ+4HtR7kb3YEDR7kPcGz041joAwT9aErQD49BUsqDV8Q6BEKIuXj70RYOSCnP/yTtHat8KgzIsYAQYsmxEKp3LPTjWOhD0I+gHwGdT6DGGxAQEBDQLgIDEhAQEBDQLgID0nE8frQ74HMs9ONY6AME/WhK0I+ADiWYAwkICAgIaBfBCCQgICAgoF0EBiQgICAgoF0EBuQwEUJcKYRYLYRwhRATG6wfLIRICyGW+8vvG7w3QQixUgixSQjxW9GweHkH98N/74d+W+uFEOd1Zj+atHuvEGJXg2Nw4aH61FkIIc7329okhLirs9tr0vY2/zgvF0Is8dd1FULME0Js9P8WH2o7h9nmn4QQ5UKIVQ3WtdpmZ52PVvpxzFwXAR2MlDJYDmMBRgIjgHeAiQ3WDwZWtfKdRcCpePVhXwMu6MR+jAI+BkJACbAZUDurH036dC9wRwvrW+1TJ50j1W9jCGD4bY86gtfINqB7k3W/AO7yX98F/LyD25wKnNTwGmytzc48H63045i4LoKl45dgBHKYSCnXSinXt/XzQog+QKGU8n3p/Wr+DFzWif24FHhWSpmVUm4FNgGTOqsfbaTFPnVie5OATVLKLVJKE3jW78PR5FLgf/3X/0sHH3sp5Xygso1tdtr5aKUfrXGkr4uADiYwIB1LiRBimRCiVAgxxV/XD9jZ4DM7/XWdRT+grIX2jlQ/ZgghVviujJzLpLU+dRZHur2mSODfQoilQohb/HW9pJR7APy/PY9AP1pr82gcn2PhugjoYAIxxRYQQrwB9G7hrR9LKV9s5Wt7gIFSygohxATgBSHEaDx3UVPaFDvdzn601l67+9HWPgGPAQ/4230AmAnc2FFtHwZHur2mnCal3C2E6AnME0KsO4Jtt4UjfXyOlesioIMJDEgLSCnPbsd3skDWf71UCLEZGI73VNW/wUf7A7s7qx9+ewNaaK/d/WhPn4QQTwD/OkSfOosj3V4jpJS7/b/lQoh/4rll9gkh+kgp9/juxPIj0JXW2jyix0dKuS/3+ihfFwEdTODC6iCEED2EEKr/eggwDNjiuw5qhRCn+FFPXwVaGz10BC8BVwshQkKIEr8fi45EP/ybVI4vALlInBb71JFtN2ExMEwIUSKEMICr/T50OkKImBCiIPcaOBfvOLwEfM3/2Nfo3GsgR2ttHtHzcQxdFwEdzdGexf+/tuD9AHbijTb2Aa/7668AVuNFlXwEXNzgOxPxfjSbgVn4CgCd0Q//vR/7ba2nQaRVZ/SjSZ9mAyuBFXg3hz6H6lMnnqcLgQ1+mz8+gtfHEP8a+Ni/Hn7sr+8GvAls9P927eB2n8Fzo1r+dXHTwdrsrPPRSj+OmesiWDp2CaRMAgICAgLaReDCCggICAhoF4EBCQgICAhoF4EBCQgICAhoF4EBCQgICAhoF4EBCQgICAhoF4EBCfg/jxCi7mj3ISDgs0hgQAICAgIC2kVgQAI+NQiPh4UQq/x6HFf5688QQrwjhPiHEGKdEOKvHV0LJSDgs0ighRXwaeJyYDwwDugOLBZCzPffOxEYjae1tBA4DVhwFPoYEPCpIRiBBHyaOB14RkrpSE/ArxQ42X9vkZRyp5TSBZbjFQALCAj4BAQGJODTxMHcUtkGrx2C0XdAwCcmMCABnybmA1cJIVQhRA+88qqBumtAQCcRPIUFfJr4J17N94/xChP9QEq5Vwhx/NHtVkDAp5NAjTcgICAgoF0ELqyAgICAgHYRGJCAgICAgHYRGJCAgICAgHYRGJCAgICAgHYRGJCAgICAgHYRGJCAgICAgHYRGJCAgICAgHbx/wGJPiD20tjl4gAAAABJRU5ErkJggg==\n", "text/plain": [ "
    " ] @@ -1511,7 +1540,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -1870,27 +1899,27 @@ "
    <xarray.Dataset>\n",
            "Dimensions:  (nodes: 10000)\n",
            "Coordinates:\n",
    -       "    lat      (nodes) float64 30.9 49.12 4.963 64.06 ... -38.57 31.24 37.95 64.31\n",
    -       "    lon      (nodes) float64 -80.67 -67.81 -24.35 89.45 ... 69.17 115.4 65.6\n",
    +       "    lat      (nodes) float64 -6.609 52.34 -39.36 -44.66 ... -55.66 -34.23 -70.85\n",
    +       "    lon      (nodes) float64 -177.1 -47.01 94.4 -38.02 ... 9.832 -93.45 -171.4\n",
            "Dimensions without coordinates: nodes\n",
            "Data variables:\n",
    -       "    field    (nodes) float64 -49.78 -18.69 -19.39 153.5 ... 100.4 153.3 129.9
    " + " field (nodes) float64 -183.7 5.334 55.04 -82.68 ... -45.82 -127.7 -242.2" ], "text/plain": [ "\n", "Dimensions: (nodes: 10000)\n", "Coordinates:\n", - " lat (nodes) float64 30.9 49.12 4.963 64.06 ... -38.57 31.24 37.95 64.31\n", - " lon (nodes) float64 -80.67 -67.81 -24.35 89.45 ... 69.17 115.4 65.6\n", + " lat (nodes) float64 -6.609 52.34 -39.36 -44.66 ... -55.66 -34.23 -70.85\n", + " lon (nodes) float64 -177.1 -47.01 94.4 -38.02 ... 9.832 -93.45 -171.4\n", "Dimensions without coordinates: nodes\n", "Data variables:\n", - " field (nodes) float64 -49.78 -18.69 -19.39 153.5 ... 100.4 153.3 129.9" + " field (nodes) float64 -183.7 5.334 55.04 -82.68 ... -45.82 -127.7 -242.2" ] }, - "execution_count": 8, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -1912,16 +1941,16 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ - "ds_1d.xoak.set_index(['lat', 'lon'], transform=np.deg2rad, metric='haversine')" + "ds_1d.xoak.set_index(['lat', 'lon'], 'geo_balltree')" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -2280,60 +2309,60 @@ "
    <xarray.Dataset>\n",
            "Dimensions:  (points: 50)\n",
            "Coordinates:\n",
    -       "    lat      (points) float64 -57.48 55.55 -78.33 67.68 ... 29.89 21.38 -75.14\n",
    -       "    lon      (points) float64 -86.35 -153.1 108.8 48.39 ... 50.82 4.812 39.42\n",
    +       "    lat      (points) float64 48.23 -12.16 -69.45 1.477 ... -37.02 -17.54 -84.37\n",
    +       "    lon      (points) float64 2.689 151.5 -132.7 147.6 ... -31.23 -145.9 -123.5\n",
            "Dimensions without coordinates: points\n",
            "Data variables:\n",
    -       "    field    (points) float64 -143.8 -97.54 30.46 116.1 ... 80.71 26.19 -35.72
    " + " field (points) float64 50.92 139.3 -202.2 149.1 ... -68.25 -163.4 -207.9" ], "text/plain": [ "\n", "Dimensions: (points: 50)\n", "Coordinates:\n", - " lat (points) float64 -57.48 55.55 -78.33 67.68 ... 29.89 21.38 -75.14\n", - " lon (points) float64 -86.35 -153.1 108.8 48.39 ... 50.82 4.812 39.42\n", + " lat (points) float64 48.23 -12.16 -69.45 1.477 ... -37.02 -17.54 -84.37\n", + " lon (points) float64 2.689 151.5 -132.7 147.6 ... -31.23 -145.9 -123.5\n", "Dimensions without coordinates: points\n", "Data variables:\n", - " field (points) float64 -143.8 -97.54 30.46 116.1 ... 80.71 26.19 -35.72" + " field (points) float64 50.92 139.3 -202.2 149.1 ... -68.25 -163.4 -207.9" ] }, - "execution_count": 10, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -2349,12 +2378,12 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAEGCAYAAABLgMOSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAABDVklEQVR4nO3deZwcdZ34/9e7qrvnzOSeEBJihiPcECTcxyByuq6g7iroorvrdxFl9nCjgqKrP3bxIAavUZRdXdEVwYtDRBAQhoQ7CVfIAUkmkHuSSebq7unuqnr//uieMAmTpOforp6e9/PxqMf0VHVVvWemp9/9uUVVMcYYYwbLCTsAY4wxo5MlEGOMMUNiCcQYY8yQWAIxxhgzJJZAjDHGDEkk7ABGwpQpU3T27Nlhh2GMGQWWLl26Q1WnDucah1aO10Tg5fXcbZnEQ6p6yXDuV6rKIoHMnj2bJUuWhB2GMWYUEJE3hnuNnlQvH3Rm5PXcH9E6Zbj3K1VlkUCMMabYHA3CDiF0lkCMMWaQRKAi4ub35ExhYwmTJRBjjBkkQXBFwg4jdJZAjDFmkARwLX9YAjHGmKGwEoglkJLT0tLC7+6+h5NOPYPD58xh4vg6jjx0NlHXhuwYUyqsBJJlCaSEtLS08D//+zM+/x83EolE8H0fRxw27Ohg5uTxxPJttDPGFJxjM5lbAiklzc3NfGr+dbhuhEwmO0jJ1wxO2qUzmWbquKqQIzTGQLYXVsy1D3SWQErIhg0bOHjGIaTT6d37RIRUqpeUVxtiZMaY/qwKK8sSSAmZNWsWvb29uJEIGmQHKakqkWgUx16sxpSMbAKxf8ox1zIbqJLyAoISrL+89tpreej+e3HIFpE1N9K1uqqKcZXRcIMzZgh2rF7Lcz/4GUt+9H90vLEx7HBGlCv5beVszJRAVJWVbT28sLmTTKBEHeGkg8dzdH0tUiKfJBobGwFY9twzzD3lVBzHpbamhonjqqmtsARiSltLSwvNzc20trbS0NDAZVMPZfv9jxN4Hoiw6Gvf5/ybPs+JV30w7FCHTbBGdBhDCeS1HXGe39gBZIueXqA8v7ED1xGOnFo67Qt9SSQIFC8IiLgOTokkOGP2paWlhfnz51NTU8O0adOIv7GJ1x58idpxtVRUZjt/BL7PX264mcMuPJfag4Y1Ge7ue/ZPWE1NTbv/fwpNRPKfyqSMjZkqrBc3dwHsfjPu+9q3v9Q4jhB1nd2JxJhS1tzcTE1NDXV1dTiOw8xk9s0lkUzufo7juqgq6x5dPOz79SWstrY2pk2bRltbG/Pnz6elpWXY185HXyO6VWGNEYmM97ZGL8ntL0VPPfscXqSSceMnEom4OChzDpluAwpNSWptbWXatGl77hTB8/29dsmIVBn3T1jA7q/Nzc1FK4WUe3LIx5h5NxpfGSXYq8oyUJhQgo3TixYvJlo3mQmTJoMGpNNp/ADWbtmBWr2rKUENDQ309PTs/n7X1FoCIOK89RbT1xZy6AXnDPt+ra2t1NbuWfVcW1tLa2vrsK+dD5FsVXg+WzkbMwnklJkTEAEvUFQVL1BE4JRDJoQd2ts898LLxCoq8D0fEBxxyHgZelNpkhn/gOcbU2xNTU3E43G6uroIgoA2P8WqyTGqqqrx02n8TAYELlr4ZWrqJw/7fnsnLICenh4aGhqGfe18WBVW1pipwjpkQhUXHjGVZZs66ejNMKkyyjtnjOfgusqwQ3sbcVwiboS0/9aAQkcE1QB/72KUMSHb9swyUj+8g39OVLG5K8HiWBf1Rx/OtTfeyImzD2PdI4txoxEOu6hxRBrPIZuw5s+fD2RLHj09PcTjcZqamkbk+vkYqV5YInII8HPgICAAblPV74rIJOAuYDawHviQqu7KnfMF4BOAD/yLqj40IsEM0phJIAAH11WWZMLYW+eudtKZ9B77AlWikQgVkTFTaDQlrqWlhTtu/AbHvdRKxHGorK5hpiN8hCrO/7fPMf2sUwF45yeuGPF7NzY2snDhwvB6YTGIBaUOzAPmq+oyERkHLBWRh4G/Bx5V1W+IyPXA9cB1InIMcAVwLHAw8IiIzFHVoldPjKkEMlqcf85ZbN64kZnveAeoooCrgvgZm1DRlIS+XlB/s6UXVxw8oDveQ11dHeJ7LL3pO7z3gTsKGkNjY2PREsbeZASrp1R1C7Al97hbRFYCM4DLgPNyT7sdeBy4Lrf/TlVNAa0isgY4FXh6ZCLKn32cLUGNjY2Mc30WPfIQ29u2sWvHdryeTo477B1hh2YMkOsFVV3NhHRAIG/1rorH4zixGLtWrQk7xAITHMlvA6aIyJJ+29X7vKrIbOAk4FlgWi659CWZ+tzTZgAb+p22Mbev6EIrgYjIkWTr9/ocCvwHMAH4J2B7bv8XVfWB4kYXvnPPOYdzzxl+bxVjCqGv224quouI56Nkk4jv+6jnUV0/Mm0dpUpgMAN8d6jqvANeU6QW+B3wb6ratZ/uzgMdCKVxNLQSiKquVtW5qjoXOBlIAHfnDn+779hYTB7GlLq+XlCvHzwRAUSzvRsjjoMiHNf0j2GHWHAimteW37UkSjZ5/FJVf5/bvU1EpueOTwfacvs3Aof0O30msHlEfqhBKpUqrHcDa1X1jbADMcYcWF+33VeqYdWMifiABAE14+s46XOfZs5HPxB2iAUljuBWRvPaDnitbFHjJ8BKVb2l36H7gI/nHn8cuLff/itEpEJEGoAjgOdG7IcbhFJJIFcAv+r3fZOIvCwiPxWRiQOdICJX99Upbt++faCnGGMKpK8XVP20aTzlplh8zjEc/ZMFXPXqExx79VUlM0FpIYkreW15OAu4CjhfRF7Mbe8BvgFcKCKvAxfmvkdVXwV+DawAHgSuDaMHFoCEPbJZRGJki1/Hquo2EZkG7CBbp/efwHRV3W95eN68ebpkyZLCB2uMGfVEZGk+bRL7M6eqRn9w6DF5PfeiFUuGfb9SVQrdeC8FlqnqNoC+rwAi8t/A/WEFZsKjquDlxsJEYmPiEy2An4zjtW8nMmESbm1d2OGY/RCnVCpwwlMKCeRK+lVficj0vq5rwPuB5aFEZULz3JNPMC7VztQJdbiuixOrpO7QE5CK6rBDKxgNAnY98Bu6nn0McRzU96k96XQmX34V4pbCv6npT0Rwyn2ekjyE+soUkWqydXuf7Lf7ZhGZS7YKa/1ex0yZW9TSwqxIN+MnTyTj+2S8DFFVkutfpurweWX7Zrr09luJvbCYjOfjRlxqqqvpeeFpnJo6Jl0y+hdgKj/597AqZ6H+N6pqApi8176rQgrHlIBnHnuIo953Pp7vZ7uHikPG96A3SVV8F9SV/viClpYWfnnbrczQOAdNncKJl7yf0y99336fL8/8hUg0guM6+H5AZ1c34+tq6X76L0y8+ANjpgpvtOjrhTXWlefHOTNqeeleYpEIGe+tTiUiDq7joH5mwBFUpaSlpYV7v/d1Pj/vcFynHkHJvPgQK3Zt5OgrPzVgImhubuaL0yJo32JnjhAEEE8kiYpA4EOZlrxGL0GcUn81Fp61ApmS0pnMvG0RItUAzw+QitJZenhffvqjH/CpeYcjIniqZDS77kzFhlV4W98c8JzW1lbW9wZE+70fOY4gQUB0+iElXW2nqnQuX8Wme/9Ex0uvjp31agQc18lrK2el+8o0Y9Kll/8NS5av4JTjj0TEQTXAUZcgUglV48IO74Am9HYiMo3+ixCL4+CgpNa8QnT62+cza2ho4DcbdvLZOVOJCmTfg5XAcZj8vo8UK/RB8xIJlnzyc2x/bhmJZALf9+mqq+aoW27kvEsvCTu8gstzjEdZK+/0aEadxsZGqmYdw11/fpLWjZvZ1t7JDj/G5GNOGxXtAFPr6wn2+hSuQZAtUeyj22dTUxOvtXfytVVtPNeVYVMyw9Pbu4lf9GEqZ88pRthD8tq3f0zbM8/T1d2NHwSI4zCxK8nD/3xd0dYmD4vIiA4kHLWsBGJKzrmNjZwb0jTdw9X44Y+jz9yNAwQiaBCAKrHKKmJHnDDwOf3Wtrh1ed/aFtdxVon/Djb+/o8kUymkX3IMHDi+N6D5+98Pbar1YrEmEEsgxoyoc86/gCU97UxY+SQS+EQjLpWVVYw/4yKi9TP3eV6Ya1sMVZBO43k+zl5r1LhQtLXJwyKO4FbY26f9BowZYfPe92GCC99Lev1K1POIzZqDO35S2GGNuPrGM+m+5wEyueorADdQ3qiK0HDooSFHV3jlXj2VD0sgxhSAU1VD5dFlOf3Rbkd/4V/Z/OSzeG3bcT2fwHHodYQHa4UvF3Ft8lDYSHTAGtGNMUNUNWM6Fz/xByZ/4iOsnzaRx2odHpx3OF/+7rdHXXXcoAmI6+S1lTMrgRhjhiw6rpaLbvwiF934xbBDKarsLAlhRxE+SyDGGDNYIrgxe/u034AxxgySCNYGgiUQY4wZEuuFZQlkSFSVnnR2vqZx1hfcmLFHpOwbyPNh736D0NLSwv/+6jcc+q7LGD91OlVVVUwZV827DpvMxKpY2OEZY4rIViS0brx5a2lp4fobvsRxl/094+sPxvcydHV1sr07wQOr2sj4wYEvYowpCyLZGZPz2cqZlUDy1NzczBHzziYSixF4HiIODgHJeA8V0ShvdiQ5bHJN2GEaY4pBBKfCFpSyEkieWltbGT95Kk7krReNiOD5Pr5CMuPv52xjTHnJTiCZz1bOyvunG0ENDQ1sXbeaIJPZvU9VibgursCUGmsDMWbMEBDXzWsrZ5ZA8tTU1ETr8mW0b1iXfWE4Ao5LdU0tB42rYFptRdghGmOKRHK9sMb6VCbl/dONoMbGRhZ+61usfuhOlt5/J8mOnUyqjnHmoVO58Ij6UbHYkTGjTSae4N4bF/DvJ5/L5UfP5UMf/JuSWazKcZy8tnIWaiO6iKwHugEf8FR1nohMAu4CZgPrgQ+p6q6wYuxvNK7ZYMxo1dm6gbsuuZLO7duZqcIM16H7qVVcv+7f+cZ3bgn9f1HKvIdVPkohPb5LVeeqat/c19cDj6rqEcCjue+NMWNMy/yvEt+xE8QhiDgoSl3K56Qepbm5OdTYxBGcWDSvrZyVQgLZ22XA7bnHtwOXhxeKMSYM6e4eti19hUzgv/VJXwR14B1d6RJY8dDaQCD8BKLAn0VkqYhcnds3TVW3AOS+1g90oohcLSJLRGTJ9u3bixSuMaYoREDAjbhooHsc8jWgoaEhpMBybD0QIPwEcpaqvhO4FLhWRM7N90RVvU1V56nqvKlTpxYuQmNM0cVqazj4jHlURStQ1WwSUYVAWVPj0hT6ioeC4zp5beUs1J9OVTfnvrYBdwOnAttEZDpA7mtbeBEaY8LS+K3/YMKsGYwbNw5XBA2U+IQarvrxwvAb0CXXlTePrZyF1gtLRGoAR1W7c48vAm4E7gM+Dnwj9/XesGI0xoSndsZBfHjR3Wz4y5N0b9jM5GPnMP30k0vjTdmmMgHC7cY7Dbg792KIAHeo6oMi8jzwaxH5BPAm8LchxmiMCZEbjTL74vPCDmNA5T5NST5CSyCqug44cYD97cC7ix+RMcbkR0RwynyaknxYCjXGmMEawV5YIvJTEWkTkeX99k0SkYdF5PXc14n9jn1BRNaIyGoRubhAP2FeLIEYY8ygjeg4kJ8Bl+y1b8AB1SJyDHAFcGzunB+KSGhFIUsgxhgzBCPVC0tVnwB27rV7XwOqLwPuVNWUqrYCa8j2Xg2FLShljDGDJE7Be2HtMaBaRPoGVM8Anun3vI25faGwBGJGnKqSznh4fnaRrYjrEotGSqP7pTEjZBC9sKaIyJJ+39+mqrcN9bYD7NMB9hWFJRAzolSVZCqNH7y1Rnza8/CDgKqKmCURUx5EECfvpocd/SaLzdc2EZmeK330H1C9ETik3/NmApsHee0RYwnEjCg/COhNpYj39OD5PhHXpbqmhopYDD8IiFjXx7ypKum1r9D7QgtBootI/SyqTr2QyOSDwg7NAOSfQIZiXwOq7wPuEJFbgIOBI4DnChnI/lgCMYMWqKIK7gDrIbz++utMmDQJPwhwHAc/COjq6mLChAnEolGw/JG33leeouvJB+hNJkn7HpU724m/sZopH/pnIpOmhR3e2CYCIzSQUER+BZxHtqprI/AVsonjbQOqVfVVEfk1sALwgGtV1R+RQIbAemGZvPmB0t7Ty7bOBNu6ErR1JUl7e75277vvPjKZDI4IAtmvIsR7eqz6ahDU9+h86kG6e7pJ+z4iDr2eT2+8h/UP3Bl2eIZsG0g+24Go6pWqOl1Vo6o6U1V/oqrtqvpuVT0i93Vnv+ffpKqHqeqRqvqngv6QB2AJxORFNZs8Up6PKqDg+QHtPak92jvuveceentTRKNv9VCpiMXo6uoiUuYzk46kIN5FItGD8lZXUBHBVyW+cV3I0RnEgUhFflsZs/9ok5eMH2QThe7Z/11VSaS83c+bMWMGX/riF1i7bi2RaJRINMrq1atp/t53rQQyCE5lDYEf4Oz1O4s4Dm+0d4YUlekjjFwJZDSzNhCTFz9Q0ukM8XgPvu/jui41NTVEozG8fiWQpqYm5s+fzw3XX8+0adPo6emhra2NhQsXhhj96COxCp7fkeS0qdVAtp+mK4IfKE/t9HhfuOEZkUI3oo8K5Z0ezYh5YekS4vEeglzjeJBrHM9kMsQib/0jNTY2snDhQurr61m3bh01NTUsXBj++g2j0cGXXsn9qzcRqBJxhI7eNAsXr+TSj/1T2KEZyCaQfLYyZiUQk5dv37KQyz/0Eeaddnp2hThVHMdh29YtHDL1qD2e29jYaAljBDSe9y4Qhy/9oJmtGzdQP+MQmj7zRfvdlggZoBfiWGMJxOSltbWVu37xv2zZtIGzGs8nFovx4rIl/N///oTH/vJo2OGVJE0l8d5cQdC+CYlV4s46BnfKzEFdw5JxieprRB/jLIGYvDQ0NNDW1kbLow/T8ujDAHR1dVFfX3+AM8cmTfeSXvJHNNULAproJOjcjh42l8isY8MOzwyXCGKDYq0NxOSnqamJeDxOV1fX7vaPeDxOU1NT2KGVJG/jqmwS8Tx2dXSyY+cuOjo7SKx6HvXSYYdnRoLj5LeVsfL+6cyI6d84vm3bNurr661xfD905xYymczuhOs4Dr4f0NnVxdJFj4Udnhmuvl5Y1ohuTH6sPn4QKmtI9ab2WBNCRIg6wk9+/kvmvSvUheTMCCj3MR75sN+AMQUQOeRoMl5mj9H3UddlzbYOnn9lRYiRmRFjVVjhJRAROUREHhORlSLyqoj8a27/V0Vkk4i8mNveE1aMxgyVM34qv3h6Nb1pDxEh4jq8umkHX7+7hYaGhrDDM8MlDhKJ5bWVszCrsDxgvqouE5FxwFIReTh37Nuq+q0QYzNm2E5779/yoc99jiNmTiNwo2xqaycej7Pwi18KOzQzXELZly7yEdpvQFW3qOqy3ONuYCUhLs1ozEhrbGzk5gULSLmVvNb6pnU8KCNCthtvPls5K4lGdBGZDZwEPAucBTSJyMeAJWRLKbsGOOdq4GqAWbNmFS9YYwbBOh6UKaHse1jlI/QymIjUAr8D/k1Vu4BbgcOAucAWYMBZ+FT1NlWdp6rzpk6dWqxwTZ5UFT8IUA1tueZsHF4Gr7sdb9dW/O6dqO8d+CRjDsi68ULIJRARiZJNHr9U1d8DqOq2fsf/G7g/pPDMEMVTGbqS6VzyEGoqItRVFX899CDTi9/RRiaTpjfZix/4eJ7Pm7uSnHbmWUWNxZQZESQSPfDzylyYvbAE+AmwUlVv6bd/er+nvR9YXuzYzNAl0x6diRRBkE0eqro7oRSb372TTDpNR0cnqXSaIFAqYjG2v7mWlpaWosdjyow4+W1lLMwSyFnAVcArIvJibt8XgStFZC7ZJRDWA58MIzgzND29aTKZDD09e64bAlLUUohqAF6GnngcEcHJ9ZjxfJ+TTzyOf/mPr1vbhBkGQcs8OeQjtASiqovJNkXt7YFix2JGTk88QTyR2D3de9+8WePHjyfQKtyiVWNl7+P7/u7kAeA4QndPL62trUWKw5QtSyDhN6Kb8vLKyy8RiUYRcQBBxCESibBr5863Lc9aSCKCVNVSEYsR9FsxEYR7HnzYBvOZ4cmuaTvmq7DK+6czRXf7f/8I3/OIxaI4TjZ5iAi3/89tRW9Ed2snkvQV182WhFzX5eHHF3PXPX8syizCmknhb12Lt/5l/O1vWg+wMqIIKvlt5awkxoGY8uEIfP0rN/DBK/+OWbMb2Nm+g3t/cxfbtmwqeiwiDjPmHM/TTy7m/vvu4bkly5gwaTILFiwoePuHJrvxVj0FgQ8aoO0bCbasIXL0WUjUFiIqC669fdpvwIyopqYm5s+fz3e+eRO1tbX09PRkp+9YOOBwnqI446yzOeOss4t6zx0vtBBJx0mm0kQi2Y4EMVX8TauJzD4h28ivipT5OIGyJVL21VP5sARiRlTfuiF33HkXUw86mMlTpnDKSSdy9plnhB1a0SxqeZyj/W56fR/XdfCDgM7OLsaPH0ds11Y8INi6DgIfqRqHe+hcnPG2suOoYwnEEogZeSedegazjzt59yh0EaErmaauqrxnJu1z66238r2rL9/dacARIXAgmUwScyOk3lxJPJEg4/lUxnqo6O6g+uSLcGomhBu4GQTrxgvWiG5GWMYP2JVIk06n6OzooL19B50dHbR19pDxgwNfoAy8tmYtL6zdSLTfRHqOCCh46V46u7rx/QDXcUhnPHoTcTYttYGNo471wrIEYkZWMu3tXsrVD3xcx8HzPRKJBC+/ujLs8IqioaGB7/3+ETa1d+5ekdAR4Y22XXR1dWf3OQIC4ggKdGzZEHbYZrAsgVgCMSOvtzeZe9PMjgVxxEFExsz0IU1NTWzZ3k7T9+/gG79+mB/c+xhN3/0FyelHoxrgOHt27XQchxdffyOkaM2QiKCOm9dWziyBmBFVHYvgeR5uv38ckeycWH/+0x9DjKx4+joS1NfX88TSV1ixpYNPz7+esxvfxeMr3kBEcB1BgJjrkkpneLp1e9hhm8GyEog1opuRFXEdHrrvbi657AO4rkvfhIq/+cX/Mq6mOuzwimZf64BMP+V8fvSb2/lw4zzG11bxwtqN/OiPT9D0uS+GEKUZOrEVCbEEYgrg9JPn8rlr/4nTzzqXiooKljzzFBvefCPUsSClorHxPED4UnMzra2tNDQ00PS5L9rEjqNN31Qmo5iIdJOdtHZAqlp3oGtYAjEjru/NsLnfm6Qt5foWW6WwHIz+bryqOg5ARG4EtgK/IJsaPwqMy+calkDMoAWqxFMeCtTEIrjO2+f7sTdJU/acsnn7vFhVT+v3/a0i8ixw84FOzOs3ICLfVNXrDrTPjH5+oKT9gIqIM+DsufGUx4pNO0kkE3ieTyTi4iZ2cfYpJ4UQrTEhKa+pTHwR+ShwJ9kqrSsBP58T8/0NXDjAvkvzPNeMAoEqa3b08OT6dp7fsIsn1+9kQ0dyjzXNg0BZsWkn8WQC3w9wHAdVyFRO4IknnwoxemNCIJLfdsDLyCUislpE1ojI9UWIfG8fAT4EbMttf5vbd0D7LYGIyKeATwOHisjL/Q6NA54cUqimJK3fmWBTZy+ZTJp4PE6gSkdHJ6+nOzn/tGzpoivlkUgmCPzgrdKJKq7r8txLKzj3rDND/AmMKaaRaQMRERf4AdkP6RuB50XkPlVdMeyL50lV1wOXDeXcA1Vh3QH8Cfg60D8zdqvqzqHc0JSeQJWNueTR1dW1e/S0qvLGzjgtLS00NjbiB0oQ6NvW9XBcl2Sq+GueGxOqkanCOhVYo6rrAETkTrJv5gVPICLyffbfC+tfDnSN/SYQVe0EOsnWiSEi9UAlUCsitar65qAiNiUpCDTbMJ5bP1xy/xiqyvhJk2n+1n/Q2NjIuIoIkUh2oGB/XibDrq0bwwjdmFAoDKYEMkVElvT7/jZVvS33eAbQfx6bjUD/Bu1CWnLgp+xfvo3ofw3cAhwMtAHvAFYCxw43ABM+1xEqIn1L0L5VunAjEbasX7N7/fBYxMFN9eC5lbjRKILgeRleWfosl73n4pCif8tLL7+MiFA3bhwbN22iIhbjlFNOCTssU6YGMTXoDlWdt49jAzWS7LNUMJJU9fY9AhGpUdX4YK6Rbwr9L+B04DVVbQDejbWBlA0R4fDJNTiOgxuJII5DJBrB9zI8dvede6wffubco4nEd7DyhedY8tTj/OnXt3PC7INC77L76quvMnXqVOrr64lVVDBnzhymH3wwzz//fKhxmfKlmt92ABuBQ/p9PxPYXKiYByIiZ4jICrKFAkTkRBH5YT7n5tuROaOq7SLiiIijqo+JyDeHGnA+ROQS4LuAC/yPqn6jkPcb66bWVlDbu4OX129l6vSZtG/ZQMt9v2H966veNoL8nNNP4ZzTS+eTvaoyrq4OEcH3s70PM5kMsViMeCIRcnSmHCmDKoHsz/PAESLSAGwCriDPHlAj6DvAxcB9AKr6koicm8+J+SaQDhGpBZ4AfikibYB3gHOGrBR6JoxF7zrjVJx0C83NXx91I8gjkQhBsOe/tO/7HHzwwSFFZMpdHqWLPK6hnog0AQ+R/bD8U1V9dfhXHnQcG/bqHJPXOJB8E8hlQC/wGbLD3McDNw4mwEEKrWfCWBfmCHIvCEikPAJVKqMuFRH3bT2+9qXvef3HrTiOQ0dHRyFCNYZgJDIIoKoPAA+MyMWGZoOInAmoiMSAfyFXnXUgeSWQvRpWbt/nE0fOAXsmiMjVwNUAs2bNKkJIppB6Mx47elK7E0BPyqMi4jCltvKASURE6Onupqa2dnf3Y8dx8H2faKRsppswJUSBoChN3UVxDdnmghlk32v/DFybz4kHGki4r9kaBdB8ZmscogP2TMh1g7sNYN68eeXzpxyDVJX2eApUdw9QVFVSnk8i7VFTET3gNQ4//HBeX7OGmpoaXNcl3tNDTzzOSSfZFCumALR8Eoiq7iBbszRoBxoHkteMjAUQes8EUzh+oPiBEnWz3YbTfoAqe5Q0+koS+SYQEWHOEUe8VYVVX5939ZfZvyDVi7dlPRKrIHLQOxBbBwPYs7p0NBKRz6vqzfsaUDjsgYQhKoWeCWaEBaps6+qlJ+Vl1wMHptRWUB3Nrl6YSqeIx+P4vo/rutTWjqMyOrglQS1pjKzky8/Qs/gPpDMZEvEEnckUP1vfw9/+v2tGReeKQhnBXlhhuo7sjLtrgV1DuUBJJpBS6ZlgRtaLq1vRaAXpdBrXdamprmG7wvTxlfQmE6TSaYIgO0ljEAT09HSzfWMrU95p1VBhyGzbQM+ibPLo6u5GRJhUXcE/HupwzWfns+Bbo6OHXqGM8gIIwDYReQfwD8C7hnKBki2LquoDqjpHVQ9T1ZvCjscMzxOLFuFJhEw6k00Qvk9XVyfpTIZdiTTfX/B1epO9uI6L67pEIlGefPwvLPj618IOfczqffV5CHziiQQigiOCFyi1sQhzZ9TT3NwcdoihUX2rKvZAWwm7FXgQOIrstCZ921LynOakJEsgpvz83y/v4BOfuR7JLT4ljgNBQDKZoLoyxpOLnuCN1nUce8JcqmtrWfvaarZt2cy2bdtCjnzsCnqzgzB938fZq91j4rgalq1sDSOskjHaq7BU9fvA90XkVlX91FCuYQnEFMVLLyzD9zyisdjuAX99jbHVUZeGhgba2tp4+YWlu8/p6enZYxoVU1wVhx1LunUlrusSBEF2ok2yS1y8vLl9zP9tyqAKC4ChJg8o4SosU15mzZrF3XfcjgCRaBTHcbMz+2YyTKypoKmpiXg8TldXF0EQ0NXVRTwep6mpKezQx6yKw08getAsaquriDpCJLc+0h0rN7O9s2tM/22y40A0r62cWQIxRdHU1MRjDz3Abd++mdbXVrGrfTuLH/0zmV1bibkOjY2NLFy4kPr6erZt20Z9fT0/+PF/c9RJp7K1M0F3b3rUd5scbcR1GX/5/2PSpR8hOKiBJTt7+fJjr/JKb2TUTHFTSJrnVs6kHP4p582bp0uWDHtqe1NgLS0tNDc3755nq6mpaZ9vQjt7eulOebz1L5idcn5aXZV11TXDIiJL9zO9el6On/tOvfvhlryee0R93bDvV6qsDcQUTb7zbGX8gO6URzqdIhFP4PkeETdCTW0NdVUxqmP2sjXhUsq/eiofVoVlSk7K80nnltf1Ax/XcfADn97eFK+vG9s9f0yJyE1lks9WziyBmJLjiJDILa/rSHalREeygwsXPfFE2OEZA1gCAUsgpgRVRbOTIcZisd37HNdFNeD+u38XYmTGZCkjtiLhqGYJxJQcEeGX/3Mr7Tu2ZwceCqTTKX78nW8xrrYm7PCMASBA89rKmbVGmpL0ob/5IPOv+QRHHn0MdXXjWb3yVbq6ut62vK4pvqA3QXLZ46TXvgJuhMpjTqXy+DMRd3ATX4525V66yIclEFOS+saFNDc38/zKFTQ0NPCVr3zlbb24Fi1ezLNLluF5AV2dO7n4gneP+fEJhaRehs57fkyqfRuJZJIgCHC3bMB/5XkOv+rfww6vaPrmwhrrLIGUAFVl2cYOHn1tO72ZgNNmT+S8w6dSERnbNYwH6vb7zHPPU1c/g7+6vIFoNEY6neL11atoeeIJGs89t4iRjh3pdctJtbfR2d2TndpEhIzn42xp5ZmH7uf0i98bdohFoYBnCcTaQErBr5ZtpHnROl7csJOX1m/l1keX85FbfstfHs9voNJYpKo4lbVUVFYSBAGpVC+qypyjjmHZS8vDDq9sZba+Qbo3mU0ejgN9XxFa7v3N/s/dvoXe1tUEyURxgi0oxdf8tnJmJZCQtcdTPLy6DS+dId7diYiDI0JQM5mv/PDnuIJVyQzAD5Sa2lp8z9tjvzjCMSfMDSeoMcCtm0zG9982G4CIsGL9xgHP8ePdtN/1IzLbNkFuFuZxZ19C3TmXFCPkguibC2ussxJIyF7bHscBEon47uQB2XmIxs0+fkyvuXAgrht5+/xYqsRiB14C1wxNxZy5BOIQ6Zc/oo6wPZ4iWTNpwHN2/u6npDe/ifatdw90L3qQ5OqXixBxgSj4QX5bObMEErK6igiI4Pne7uQBgCoRv5fWVht5PRDXEaKuQyQS3Z1EVJUgCBhfUxVydOXLqR5H+/Hv5s3OBC4QEVje1sWXH3mJaweYndfr2kW8dTUdPT2072hn165dZDIeGvj0PPd40eMfKQr4QZDXVs6sCitkR00bR21FhI5oBb6XySYRcUADulc9M+bXXNgXEWHW9Kls3L5rdwIREdTPcNLxxxYtDtUAzaRRDXAiMcQt/3+p0y95Hy1V4/nPH/+Qta3rmTZzFl+66RsDVrU+t+gJart7QATHdQj87FT9dbW1RBM9IUQ/MhTwrAbLEkjYXEf4wgVz+P/+8AJbdmUIVJEgQ/dTv6V720a+auMe9inqOsyeNonejE+gStR1iLpO0WbrDbw0Xk8H6XSa3t4kvu/z+OKnOWjWoWXfbpXvxJjf/dn/cd07qqhwhIBsGxUBpHqTTJpzQuEDLRTrxgtYFVZJOKiukh9+5HQ+fmQFkRfuYcMvvsxEr8PWXMiDiFAVi1BTESUWcYuWPFQVL95JJpOms6uTTCYDCOedfSa/uP1/aWmxHnQAa1tb+e2mbEkjKtlFqSKOsD2Zova088INbhj6ZuMd6wtKWQmkRIgI77/wXN5/oY1fGA3Uy4AqPT1xHBFEHFSVWDTKey66gObmZkv+QENDA09ubmOnF3D2pComxBxe2tHNyqCCc6prww5vWPzyzg15CaUEIiILRGSViLwsIneLyITc/tkikhSRF3Pbj8KIz5gDy757eL6HSL9/I4Hqqirr/JDTt1TxyrZd/GpjFwte3sjdr2/mnz49upfDtSVts8KqwnoYOE5VTwBeA77Q79haVZ2b264JJzxj9k8i2ZmCY9EYqm/1tPE9n788sdg6P+QMtFRxWVTNKnh+kNdWzkKpwlLVP/f79hngb8KIw5ihEhHc6jqq0mmSCcWNuHiezzNLlvH4oidZsGBB2CGWjHwb3EcT64WVVQptIP8I3NXv+wYReQHoAr6kqosGOklErgauBpg1a1bBgzRmb26skpop09m0YjnLli7l4b88TnciyYIFC8ruDdPsyUaiZxUsgYjII8BBAxy6QVXvzT3nBsADfpk7tgWYpartInIycI+IHKuqXXtfRFVvA24DmDdvnv0lTSjEcTnyuBM58rgTufLj/xh2OKZYVAmsG2/hEoiqXrC/4yLyceC9wLs1NxJMVVNAKvd4qYisBeYASwoVpyltqkp7PM2uZBoF6iqiTK2twHWK0113rFPfI2jfBJk0zuSDkUpb0AtyI9Etf4RThSUilwDXAY2qmui3fyqwU1V9ETkUOAJYF0aMpjRs6EjSk/Lo6/W0M5GiJ5Xh0Cm1e079YkZc0NFG+rk/kEomSCQSaBDwwMotHHHhB62KDqvCgvB6YTUD44CH9+quey7wsoi8BPwWuEZVd4YUowlZb8anJ+2RyaTp6Ohgx44ddHR0EO9N0d3rHfgCZsg08Ek/fz/pRJyuri583weEvzrmYH5yy9fG/EBJVcj4QV7bcIjI34rIqyISiMi8vY59QUTWiMhqEbm43/6TReSV3LHvSQFH14aSQFT1cFU9ZO/uuqr6O1U9VlVPVNV3quofwojPlIZkxieTTtPZ2Ung+7iuS+D7JHt7Wb3OxlkUUrBrK+pl6Enk1v4QBwUirsNfnTRnzM8S3VeFlc82TMuBDwBP9N8pIscAVwDHApcAPxSRvjWFbyXbweiI3FawefNtKhNTsqKuQzyRyI70drIvVXGyE/I99sjDIUdX5vxsCc/fe6CkwrjqShsoSXEGEqrqSlVdPcChy4A7VTWlqq3AGuBUEZkO1Knq07m25Z8Dlw8riP2wBGJKVk3Mpb1tG9FYxe59kWgU38vwp3t/V5B7Bqp4fjDm67edidkOlNFIZM+Bkqq0rHxzzA+U1PBXJJwBbOj3/cbcvhm5x3vvLwhLIKZkiQi//9mPeX3lctxIBDcSoW3LJn74zRuZOnnyiN5LVYn3pumIJ+lK9tLRkyTem377glVjhEQriB7fSHV1NVHXIeYKjgMvvbmdx5evo2mAtT/GlNxsvPlswBQRWdJvu7r/pUTkERFZPsB22X4iGKhdQ/ezvyBKYSChMfv09x+7ivnz5zN5ylTGjx/Ptq1biMfjLBzhae5fXbmK2gkTyaQzOK5DTXW2u6oIVFfERvReo0Vk5lHUjq+n7cmHWP7iMv68bBU7qOTmb31rzPfCUhjMNCU7VHXevg4eaMjDPmwEDun3/Uxgc27/zAH2F4QlEFPS+uZSam5uZt3aNTQ0NNDU1DSib2AtLS1MrJ+O7weIyFuLHtXVISJUVxz4GuXKGTeJwy+5ksMvubJwFemjULYXVqil0/uAO0TkFuBgso3lz+WGQHSLyOnAs8DHgO8XKghLIKbkFXoupebmZhZ85/t4vgeSrTojgHgiTiwWQ1WLts6IGR0ULcqCUiLyfrIJYCrwRxF5UVUvVtVXReTXwAqys3lcq6p+7rRPAT8DqoA/5baCsARixrzW1lbWrVvLYYcfQSaTBnKTJToubhFXODSjiFKUqUxU9W7g7n0cuwm4aYD9S4DjChwaYI3oxtDQ0MDPf/oTvEyGaDSG67pEohECDaipiIYdnilByqAa0cuWJRAz5jU1NbH8lZe54brP8syTi9m0cSMtj/2Ftk0biLjugS9gxp7B9cIqW5ZAzJjX11Dvex4LvvE1vvutm5k9cwann3Za2KGZEqVoUaYyKXXWBmIM5bnokSmcEuiFVRIsgRhjzCD1tYGMdZZAjDFmkFQtgYAlEDPK9GZ8tnb3ksz41MYi1I+rpCKSbcpTVXrSHkEA1TGXqGtNfKZwCjjP1ahhCcSMGj0pj9Vt3aQzGXqTvfgasNLLUBnfwamnnsqqze0kkkmCICASjSK9PZx63JE2jsOMuL5G9LHOPqKZUeONXQnSmQxdnZ1kMmnU94nEYryyfgsvrN1AsjdF4PuICH4mgxep5Knnl4UdtilDquD5mtdWzqwEYori4UVP8fiyFXT39JDavpkr3/9XnDeIXk+BKom0T7ynJ7vAUW5N9MD3OerEd5LOeLhOsHvdEESIRCK8vrmNswrxA5kxLduIbiUQSyCm4O5/ahmb/DoaTj4nWzrwMtz3bHaBtXyTiACOQBAEe1RJiThk0mkcFyKRvV7OImQ8W/rWFICW/yDBfFgVlimoZMZnq18NQOBl8DNpUOWo087ljt/nv2KxiDClNkY0N7lh//2LHrxv9+P+fM/jjddXjcBPYcyebCqTLEsgpqC2dqfwfO9tq9y4kSixydMHda1DJlQT0+x6HUEQ4DguSxc/xp/v+TWbX1tOEAS4kQjRWAwQ1qxawbvOPHXEfhZj+qiCF2heWzkLpQpLRL4K/BOwPbfri6r6QO7YF4BPAD7wL6r6UBgxmpHhCLiOg+/7OP1KCKoB42prB3kt4axjD6Nl8ZP84d4/8PKyJUyZNJFvLVhAY2Mji556mudWrCbjK+2bN3Dx+Ta63BSGgvXCItw2kG+r6rf67xCRY4ArgGPJLpLyiIjM6TfPvRllptdVUl1dTU88ni01iGSL/57Hu+cdP6RrNp59Fo1nv71p/Jwzz+CcM88YZsTGHJhq+fewykepVWFdBtypqilVbQXWAFYHMYrFXIfzjzyI2poaXNclUMV1XWZG01xw7plhh2fMkFkbSLglkCYR+RiwBJivqruAGcAz/Z6zMbfvbXIL018NMGvWrAKHaoZj+rhKPnTSLLZ0pwgCZdq4CqqiNk26Gb1sKpOsgpVAROQREVk+wHYZcCtwGDAX2AIs7DttgEsN+FdS1dtUdZ6qzps6dWohfgQzgqKuw6wJVcyeVG3Jw5QFDTSvrZwVrASiqhfk8zwR+W/g/ty3G4FD+h2eCWwe4dCMMWbYApsLK5w2EBHp33/z/cDy3OP7gCtEpEJEGoAjgOeKHZ8xIy0IAjzfJwiCPcaxmNFJVQn8IK+tnIXVBnKziMwlWz21HvgkgKq+KiK/BlYAHnCt9cAyo5mqsnHTJqLRGJlMJjtaXpWDDppmkzyOckGZV0/lI5QEoqpX7efYTcBNRQxnTAhUWb2thx3xFO+YVM2sidVhhzQmvP7664yrG08mk0FE8DyPSCTCG2+8yezZ7wg7PDNUClrehYu82FxYY0BHMsN/PbSKbd29pNMZEskkiTdeZeIbT/LP137aBtsVUCQa22P+LhHB932qqqpQ1VFVCmlpaaG5uZmNG97kuKPmcNU/fIJzG88LO6xQKFhVJKU3DsQUwI+fbGVTR5J0KkN3VxeB51E16xg6JhzG/PnzaWlpCTvEsuU4+/gXG0WJA7LJ47Ofnc+7j53F3Tc28V8fvYiGnlZWLXpwzL6RBoHmtZUzSyBlLpnxeWlTJ1FXSCTjiAiOIwhQNedUampqaG5uDjvMsrVyxYq3zRIcjUZZ39o6qkofzc3NfOzis/ngOSchIqhCLOoyJd1OsGNj2OEVnyqBF+S1lTNLIGWu/2An3/N3r6MBCk6E2tpaWltbwwluDBg/vo5du3bhOA6xWAzHcYjH4+xjeFPJWr++lQ+cfRIavFV1owh+EBBsXh1ydMWnZNsV89nKmbWBlLnaigiHTKzizZ0J3IhL4AfZJCIubH2Nnp4eGhoawg6zbJ155pksXryYRx99hMmTp9DT3cXRRx/NWWeNrmWujjj8cCpjETL9PlGrBjjiopneECMLiVL2gwTzYQlkDLjmrAZufHAVflUN8WSSQAMk2UXPiw8Tj8dpamoKO8SydvbZZ3P22WeHHcawfPKaa9i6fQX1E8bhB9nkEahSV1ONVE8IO7xQWAKxKqwxoWFyDd/5wAn83emzOXlaBbHXF7H1t99k6vhaFi5caL2wzAE1Np6HV384Ig6uI0TcCBPr6ojGYrizjgk7vOLT/KYxKfckYyWQMWJ8VZT3HXcw7zvuYPjQ2cCNYYdkRpkTz72IoGsH/qbVaG8PUj0ed8aROLUTww6t6Kwbb5YlEGMOQFVJpH1Sno/rCLUVUVxn9PSgGklO3RScuilhhxE+Bd+zBGIJxJj9CFTZ2pkgnkyRzmRIp9OoBvTu3MaZp5XXUjVB9w7YtRn8NESrkckzkaq6sMMqWeVePZUPawMxZj+6kmnivSk6uzrp7U2CBkQiEeK+U1YDMIOuNjKbX6dr1w52bG+ne+c2Um++iia7ww6tJCk2kBAsgRizXz0pj2SyNzsAUxxA8D2fqdOm8Ytf/jLs8EaEqpLcvJbunh7SGQ9xHVLpDMlEgva1L4cdXmlSRfPcyplVYRmzHyIQBD7OXqPGHccpnwGYgY+X6iVQ3f1zigheEBAke0IOrnRZFZaVQIzZr3EVURzH3WNEcSQa4c3WdUyaMCG8wEaS4xJPJnHdPd8OohGXNzZtDSmo0leMbrwiskBEVonIyyJyt4hM6HfsCyKyRkRWi8jF/fafLCKv5I59Two4Z44lEGP2Y1xlFPHTOI6TnRhRoGPnTn6w8BtlMwBTRHjw6RcR3pr8MeK6BEHAg88MrQor6NzOhifu5amfLeQrn/57PnLFh8uqzUgVPD/Iaxumh4HjVPUE4DXgCwAicgxwBXAscAnwQxHpWyv6VuBqsgvyHZE7XhBWhWXMfogIxx8+m6eeeY5FTz3Na6tX0dOxi+s///nQB2AGfoagN0Hge4jj4lbW4ESiQ7rWYe88ix/fdTdXXXYhdbU1bN2xkx/+6j7e/9F/GPS1/M2vk1zzAlXJOHOmT+aIy85j/bZ2/vW6z/P1b94c+u9tZCgUoQpLVf/c79tngL/JPb4MuFNVU0CriKwBThWR9UCdqj4NICI/By4H/lSI+CyBGJOHM08/lTNPL51uu4GXwYt3kMlkSCQSCIKyg03bO5h78rxBX6/vTf0ztzTz5ptvMGvWO2hqahr0m716afw3l5NIxPH75l0DZk+bzKWnnUBzc3NZJBDVQa1IOEVElvT7/jZVvW0It/1H4K7c4xlkE0qfjbl9mdzjvfcXhCUQY0YhvzeOl8nQ0dGZnZ5fBNd1cfwULS0tQ3qTbmxsHPabu3bvBBEyno/bby0UR4QzjzmUe5/83bCuX0o0yHu17R2qus+sLiKPAAcNcOgGVb0395wbyC7z3df1b6B2Dd3P/oIYk20gP7/rXk5890c55J3v4aL3lVfdrBkb1M/QE4/nkkeue7EfMPPgg7n11lvDCywSA1UirrtHF1YBdnSW0czPqmjg57Ud+FJ6gaoeN8DWlzw+DrwX+Ki+9UvdCBzS7zIzgc25/TMH2F8QYy6B/OuNt/LJb/yO13ZGaKeexRsq+bvPfNOSiBlVRFxU2WNRKsdxSPb2smbNmvDiqp0IsSpqa6oJchMOOggZ3+feJ18om44HiuJ7Xl7bcIjIJcB1wPtUNdHv0H3AFSJSISINZBvLn1PVLUC3iJye6331MeDeYQWxH2OqCmv95h385N5nESDbY1FRoJ0pfO2WH3LGmWfxyLMradvZzdwjD+HEOTNH1apxpvgyfkAinX2TqI5FiLrF+UzmVFThug6+r7sTiYhw9x8eCPVTvogQPeZsZOWTjEeIx+N4gc+vn17BJ//9urJo/wCyjSB+phh3agYqgIdz70XPqOo1qvqqiPwaWEG2autaVe0r7nwK+BlQRbbxvCAN6BBSAhGRu4Ajc99OADpUda6IzAZWAn1LnD2jqteM1H3/8swK/CDYYyI8EUAdlm+Ic8z7v8SO9g4yfkDEdTnzhNnc94PPEo24+76oGbM6k2m2dvTQ25si8LOrPWa6dnLK3OMLfm8nVkl7Vzw7saPrAsq9f/wTP//VXSxYsKDg998fqawlMvci3EQn1V4GqZ3Iv/1VuX1W1cG0gQz9LqqH7+fYTcBNA+xfAhxXyLj6hFKFpaofVtW5qjoX+B3w+36H1/YdG8nkARCJOLiu87bpBVSVbncKW9p2EgQBEVcIAp9FL6zly7f8fCRDMGUi4wds7eihq7ubTDpFEPj4vo9TM57FTz5V8PuLCEccdQyRqhpi1bUk0j5uJMaCBQtK4lO+iODUTMAZPxVxyy15kFuRcGTaQEazUNtAcnV0HwJ+VYz7XXzW8VRXVe9eq1jpWzNcCSSGI+zudug4AiL8/A+FfzMwo08i7dHbm0JUEcfJFWXBcV2eXrKs4PcPAp9MMk5tdTXpdJqqykr++q8uZdaM6QW/t4G+EoglkHCdA2xT1df77WsQkRdEpEVEztnXiSJytYgsEZEl27dvz+tm0yaP57avfoJxteMQcfCDAMd1+MRlp/ddc697QG8qNegfyowNQeC/7TXjiNDe3l7we/vpVK4bbweBH6AKmYxHVSzG4sWL87qGppP4Hdvwd27Gj3eiOuxR02OHlUCAAraB5NO3GbiSPUsfW4BZqtouIicD94jIsaratfdFcgNxbgOYN29e3v2cL3/3yZxz8pE8/PRy/EC54PRjqJ9Ux28f+SQ9GXCl7/rZrWHsLbZm8lAdiwzwgUPwfZ/2bVsKfn/1fRLJJCLO7lIzgB/43Hv33ftdg72lpYUVy57lg5ecTywWpaKigmg6iZ/swp08I9ct2OyPquINs4dVOShYAlHVC/Z3XEQiwAeAk/udkwJSucdLRWQtMAdYMuBFhmjyhFquuPT0Pfbd9On38G/fuZ8gcFERRAMqNcHXPjv4qRxM+Yu6DpnuDpzqcbiuuzt53Pmz/+HvPnJlwe8vrguqb0ti0UiUpS+8sM/zWlpa+PKXvsRvb/s2jgi9vWmSyRTjx9cRA4JEN27N+AJHXw4UgqL0wippYbZuXQCsUtXdw+5FZCqwU1V9ETmUbN/mdcUI5hMfuZxpE2u48bs/Z2t7Fw3TavnKv/8/zj//XcW4vRmFTjnxWBY/9TTPLn2BHTva2bF1E3/3kSuL0ojtxirwg4BoNELG87KTPYrDw395jMmTJ+/zvObmZuYedzSQXW3RcYQggHg8TmzCBEjHwRLIgamifnlXT+UjzARyBW9vPD8XuFFEPMAHrlHVncUK6L2XXsh7L72wWLczZeDsM8/g7DPPKPp9Hcdl45Y2euPdHH3UkSSSSf7wxwe4/Re/5Ob9dONtbW1l2uSJOI5DEAS5awmel3szFOuyng8FNLA2o9ASiKr+/QD7fke2W68x5gDmnXoqLS0tXPMvn6G1tZWGhgZuPkA33oaGBl5ZuZrtO3dx0NTJZDIeQaDEohFAcKqt9JGf4owDKXVl2EHbmLFjsBMgNjU1MX/+fL6y8Ad89TOfZsqkCagGVFWPQ+omI7HKAkZbRnRQkymWLetuYcwY0tjYyMKFC1Fx+di/Xs83bv0ZW+IBVTPm4FrpI2+qxZkLq9RZCcSYMWYkpm03CkF5J4d8WAIxxphBUwKrwrIEYowxg6ZYN14sgRhjzBBYLyywBGKMMYOWbUS3keiWQIwxZpCirsO0idV5PffNAscSJtl7bYzRSES2A2+EGMIUYEeI9+9jcezJ4tiTxZH1DlWdOpwLiMiDZH+OfOxQ1UuGc79SVRYJJGwiskRV51kcFofFMXriMMNnAwmNMcYMiSUQY4wxQ2IJZGTcFnYAORbHniyOPVkcZkRZG4gxxpghsRKIMcaYIbEEYowxZkgsgQyCiPytiLwqIoGIzOu3f7aIJEXkxdz2o37HThaRV0RkjYh8T/ZexHoE48gd+0LuXqtF5OJCxjFAXF8VkU39fg/vOVBchSIil+TutUZEri/0/fa69/rc7/pFEVmS2zdJRB4WkddzXycW4L4/FZE2EVneb98+71uov8k+4iiZ14YZQapqW54bcDRwJPA4MK/f/tnA8n2c8xxwBiDAn4BLCxjHMcBLQAXQAKwF3ELFMUBcXwU+O8D+fcZVoL+Tm7vHoUAsd+9jivg6WQ9M2WvfzcD1ucfXA98swH3PBd7Z/7W4r/sW8m+yjzhK4rVh28huVgIZBFVdqaqr832+iEwH6lT1ac3+t/wcuLyAcVwG3KmqKVVtBdYApxYqjkEYMK4C3u9UYI2qrlPVNHBnLoYwXQbcnnt8OwX4/avqE8DOPO9bsL/JPuLYl2K/NswIsgQychpE5AURaRGRc3L7ZgAb+z1nY25focwANgxwv2LG0SQiL+eqMfqqS/YVV6EU+357U+DPIrJURK7O7ZumqlsAcl/rixTLvu4bxu+oFF4bZgTZZIp7EZFHgIMGOHSDqt67j9O2ALNUtV1ETgbuEZFjyVYX7S2vftNDjGNf9xtyHIOJC7gV+M/ctf8TWAj840jeP0/Fvt/ezlLVzSJSDzwsIquKeO98Fft3VCqvDTOCLIHsRVUvGMI5KSCVe7xURNYCc8h+mprZ76kzgc2FiiN3v0MGuN+Q4xhqXCLy38D9B4irUIp9vz2o6ubc1zYRuZtslcw2EZmuqltyVYptRQpnX/ct6u9IVbf1PQ75tWFGkFVhjQARmSoibu7xocARwLpclUG3iJye6/X0MWBfpYeRcB9whYhUiEhDLo7nihVH7g2qz/uBvl44A8Y10vfv53ngCBFpEJEYcEUuhoITkRoRGdf3GLiI7O/hPuDjuad9nMK+Dvrb132L+jcpodeGGUlht+KPpo3sC38j2dLGNuCh3P4PAq+S7U2yDPjrfufMI/vPshZoJjf6vxBx5I7dkLvXavr1tCpEHAPE9QvgFeBlsm8M0w8UVwH/Vu8BXsvd84YivkYOzb0OXsq9Jm7I7Z8MPAq8nvs6qQD3/hXZ6tRM7vXxif3dt1B/k33EUTKvDdtGbrOpTIwxxgyJVWEZY4wZEksgxhhjhsQSiDHGmCGxBGKMMWZILIEYY4wZEksgZtQTkZ6wYzBmLLIEYowxZkgsgZiyIVkLRGR5bj2OD+f2nycij4vIb0VklYj8shDroRgz1thcWKacfACYC5wITAGeF5EncsdOAo4lO8/Sk8BZwOIQYjSmbFgJxJSTs4Ffqaqv2cn7WoBTcseeU9WNqhoAL5JdBMwYMwyWQEw52V+1VKrfYx8rfRszbJZATDl5AviwiLgiMpXs0qo2s6sxBWKfwkw5uZvsuu8vkV2U6POqulVEjgo3LGPKk83Ga4wxZkisCssYY8yQWAIxxhgzJJZAjDHGDIklEGOMMUNiCcQYY8yQWAIxxhgzJJZAjDHGDMn/D97I7RBIu4RxAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
    " ] @@ -2388,7 +2417,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -2747,144 +2776,144 @@ "
    <xarray.Dataset>\n",
            "Dimensions:  (x1: 20, y1: 50)\n",
            "Coordinates:\n",
    -       "    lat      (x1, y1) float64 -77.47 61.5 -13.89 -34.18 ... -35.42 61.33 43.9\n",
    -       "    lon      (x1, y1) float64 165.1 141.3 -65.72 130.8 ... 163.9 -36.31 -66.68\n",
    +       "    lat      (x1, y1) float64 40.15 -11.63 -18.99 11.76 ... -76.58 -12.73 -23.44\n",
    +       "    lon      (x1, y1) float64 -64.65 -154.1 95.49 ... -19.21 -44.74 -100.7\n",
            "Dimensions without coordinates: x1, y1\n",
            "Data variables:\n",
    -       "    field    (x1, y1) float64 87.59 202.8 -79.62 96.62 ... 128.5 25.02 -22.78
  • " ], "text/plain": [ "\n", "Dimensions: (x1: 20, y1: 50)\n", "Coordinates:\n", - " lat (x1, y1) float64 -77.47 61.5 -13.89 -34.18 ... -35.42 61.33 43.9\n", - " lon (x1, y1) float64 165.1 141.3 -65.72 130.8 ... 163.9 -36.31 -66.68\n", + " lat (x1, y1) float64 40.15 -11.63 -18.99 11.76 ... -76.58 -12.73 -23.44\n", + " lon (x1, y1) float64 -64.65 -154.1 95.49 ... -19.21 -44.74 -100.7\n", "Dimensions without coordinates: x1, y1\n", "Data variables:\n", - " field (x1, y1) float64 87.59 202.8 -79.62 96.62 ... 128.5 25.02 -22.78" + " field (x1, y1) float64 -24.5 -165.7 76.5 -0.6217 ... -95.79 -57.47 -124.2" ] }, - "execution_count": 12, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -2900,12 +2929,12 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
    " ] @@ -2921,6 +2950,1625 @@ "ds_sel.plot.scatter(x='lon', y='lat', hue='field', alpha=0.9);" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Working with chunked coordinates (dask arrays)\n", + "\n", + "Xoak supports chunked coordinates for either or both index points and query points.\n", + "\n", + "Let's first create chunks for the index points and set a `geo_balltree` index." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
    \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
    <xarray.Dataset>\n",
    +       "Dimensions:  (nodes: 10000)\n",
    +       "Coordinates:\n",
    +       "    lat      (nodes) float64 dask.array<chunksize=(5000,), meta=np.ndarray>\n",
    +       "    lon      (nodes) float64 dask.array<chunksize=(5000,), meta=np.ndarray>\n",
    +       "Dimensions without coordinates: nodes\n",
    +       "Data variables:\n",
    +       "    field    (nodes) float64 dask.array<chunksize=(5000,), meta=np.ndarray>
    " + ], + "text/plain": [ + "\n", + "Dimensions: (nodes: 10000)\n", + "Coordinates:\n", + " lat (nodes) float64 dask.array\n", + " lon (nodes) float64 dask.array\n", + "Dimensions without coordinates: nodes\n", + "Data variables:\n", + " field (nodes) float64 dask.array" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds_1d_chunked = ds_1d.chunk(5000)\n", + "\n", + "ds_1d_chunked" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "ds_1d_chunked.xoak.set_index(['lat', 'lon'], 'geo_balltree')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A balltree structure is here constructed for each chunk:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[,\n", + " ]" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds_1d_chunked.xoak.index" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's also chunk the query point data" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
    \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
    <xarray.Dataset>\n",
    +       "Dimensions:    (points: 50)\n",
    +       "Dimensions without coordinates: points\n",
    +       "Data variables:\n",
    +       "    latitude   (points) float64 dask.array<chunksize=(25,), meta=np.ndarray>\n",
    +       "    longitude  (points) float64 dask.array<chunksize=(25,), meta=np.ndarray>
    " + ], + "text/plain": [ + "\n", + "Dimensions: (points: 50)\n", + "Dimensions without coordinates: points\n", + "Data variables:\n", + " latitude (points) float64 dask.array\n", + " longitude (points) float64 dask.array" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds_indexer_1d_chunked = ds_indexer_1d.chunk(25)\n", + "\n", + "ds_indexer_1d_chunked" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Queries are performed in parallel using Dask." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/bbovy/miniconda3/envs/xoak_dev/lib/python3.8/site-packages/xarray/core/indexing.py:1361: PerformanceWarning: Slicing with an out-of-order index is generating 13 times more chunks\n", + " return self.array[key]\n" + ] + }, + { + "data": { + "text/html": [ + "
    \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
    <xarray.Dataset>\n",
    +       "Dimensions:  (points: 50)\n",
    +       "Coordinates:\n",
    +       "    lat      (points) float64 dask.array<chunksize=(2,), meta=np.ndarray>\n",
    +       "    lon      (points) float64 dask.array<chunksize=(2,), meta=np.ndarray>\n",
    +       "Dimensions without coordinates: points\n",
    +       "Data variables:\n",
    +       "    field    (points) float64 dask.array<chunksize=(2,), meta=np.ndarray>
    " + ], + "text/plain": [ + "\n", + "Dimensions: (points: 50)\n", + "Coordinates:\n", + " lat (points) float64 dask.array\n", + " lon (points) float64 dask.array\n", + "Dimensions without coordinates: points\n", + "Data variables:\n", + " field (points) float64 dask.array" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ds_sel = ds_1d_chunked.xoak.sel(\n", + " lat=ds_indexer_1d_chunked.latitude,\n", + " lon=ds_indexer_1d_chunked.longitude\n", + ")\n", + "\n", + "ds_sel" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
    " + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ds_indexer_1d.plot.scatter(x='longitude', y='latitude', c='k', alpha=0.7);\n", + "ds_sel.plot.scatter(x='lon', y='lat', hue='field', alpha=0.9);" + ] + }, { "cell_type": "code", "execution_count": null, From 1c5d0e11f41c39146632a85476bba9be2fea383b Mon Sep 17 00:00:00 2001 From: Benoit Bovy Date: Thu, 29 Oct 2020 13:56:52 +0100 Subject: [PATCH 12/12] black --- src/xoak/accessor.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/xoak/accessor.py b/src/xoak/accessor.py index 81302c7..678a25e 100644 --- a/src/xoak/accessor.py +++ b/src/xoak/accessor.py @@ -231,7 +231,8 @@ def _get_pos_indexers(self, indices, indexers): for dim, ind in zip(self._index_coords_dims, u_indices): pos_indexers[dim] = xr.Variable( - indexer_dims[0], ind.reshape(indexer_shapes[0]), + indexer_dims[0], + ind.reshape(indexer_shapes[0]), ) return pos_indexers