From 94d3ee7731b082b0c777b10ab926df590747240b Mon Sep 17 00:00:00 2001 From: Giovanni Canali Date: Wed, 22 Oct 2025 10:13:51 +0200 Subject: [PATCH 1/2] Improve domain and operation logic --- docs/source/_rst/_code.rst | 18 +- docs/source/_rst/domain/base_domain.rst | 9 + docs/source/_rst/domain/base_operation.rst | 9 + .../{cartesian.rst => cartesian_domain.rst} | 4 +- .../{difference_domain.rst => difference.rst} | 4 +- .../{domain.rst => domain_interface.rst} | 4 +- .../{ellipsoid.rst => ellipsoid_domain.rst} | 4 +- .../{exclusion_domain.rst => exclusion.rst} | 4 +- ...tersection_domain.rst => intersection.rst} | 4 +- .../{simplex.rst => simplex_domain.rst} | 4 +- .../domain/{union_domain.rst => union.rst} | 4 +- pina/domain/__init__.py | 22 +- pina/domain/base_domain.py | 204 ++++++++++++ pina/domain/base_operation.py | 172 ++++++++++ pina/domain/cartesian.py | 295 ----------------- pina/domain/cartesian_domain.py | 236 ++++++++++++++ pina/domain/difference.py | 120 +++++++ pina/domain/difference_domain.py | 109 ------- pina/domain/domain_interface.py | 98 ++++-- pina/domain/ellipsoid.py | 295 ----------------- pina/domain/ellipsoid_domain.py | 264 +++++++++++++++ pina/domain/exclusion.py | 144 +++++++++ pina/domain/exclusion_domain.py | 115 ------- pina/domain/intersection.py | 134 ++++++++ pina/domain/intersection_domain.py | 113 ------- pina/domain/operation_interface.py | 80 +---- pina/domain/simplex.py | 258 --------------- pina/domain/simplex_domain.py | 303 ++++++++++++++++++ pina/domain/union.py | 105 ++++++ pina/domain/union_domain.py | 116 ------- pina/problem/abstract_problem.py | 9 +- pina/problem/inverse_problem.py | 2 +- pina/solver/solver.py | 4 +- tests/test_domain/test_cartesian.py | 35 -- tests/test_domain/test_cartesian_domain.py | 163 ++++++++++ tests/test_domain/test_difference.py | 250 ++++++++++----- tests/test_domain/test_ellipsoid.py | 30 -- tests/test_domain/test_ellipsoid_domain.py | 161 ++++++++++ tests/test_domain/test_exclusion.py | 242 +++++++++----- tests/test_domain/test_intersection.py | 255 ++++++++++----- tests/test_domain/test_simplex.py | 184 ----------- tests/test_domain/test_simplex_domain.py | 176 ++++++++++ tests/test_domain/test_union.py | 254 +++++++++------ tests/test_problem.py | 24 +- tutorials/tutorial2/tutorial.ipynb | 70 ++-- 45 files changed, 3058 insertions(+), 2052 deletions(-) create mode 100644 docs/source/_rst/domain/base_domain.rst create mode 100644 docs/source/_rst/domain/base_operation.rst rename docs/source/_rst/domain/{cartesian.rst => cartesian_domain.rst} (56%) rename docs/source/_rst/domain/{difference_domain.rst => difference.rst} (51%) rename docs/source/_rst/domain/{domain.rst => domain_interface.rst} (83%) rename docs/source/_rst/domain/{ellipsoid.rst => ellipsoid_domain.rst} (56%) rename docs/source/_rst/domain/{exclusion_domain.rst => exclusion.rst} (51%) rename docs/source/_rst/domain/{intersection_domain.rst => intersection.rst} (50%) rename docs/source/_rst/domain/{simplex.rst => simplex_domain.rst} (57%) rename docs/source/_rst/domain/{union_domain.rst => union.rst} (51%) create mode 100644 pina/domain/base_domain.py create mode 100644 pina/domain/base_operation.py delete mode 100644 pina/domain/cartesian.py create mode 100644 pina/domain/cartesian_domain.py create mode 100644 pina/domain/difference.py delete mode 100644 pina/domain/difference_domain.py delete mode 100644 pina/domain/ellipsoid.py create mode 100644 pina/domain/ellipsoid_domain.py create mode 100644 pina/domain/exclusion.py delete mode 100644 pina/domain/exclusion_domain.py create mode 100644 pina/domain/intersection.py delete mode 100644 pina/domain/intersection_domain.py delete mode 100644 pina/domain/simplex.py create mode 100644 pina/domain/simplex_domain.py create mode 100644 pina/domain/union.py delete mode 100644 pina/domain/union_domain.py delete mode 100644 tests/test_domain/test_cartesian.py create mode 100644 tests/test_domain/test_cartesian_domain.py delete mode 100644 tests/test_domain/test_ellipsoid.py create mode 100644 tests/test_domain/test_ellipsoid_domain.py delete mode 100644 tests/test_domain/test_simplex.py create mode 100644 tests/test_domain/test_simplex_domain.py diff --git a/docs/source/_rst/_code.rst b/docs/source/_rst/_code.rst index f23817376..6ce70a8cd 100644 --- a/docs/source/_rst/_code.rst +++ b/docs/source/_rst/_code.rst @@ -231,10 +231,11 @@ Geometrical Domains .. toctree:: :titlesonly: - Domain - CartesianDomain - EllipsoidDomain - SimplexDomain + DomainInterface + BaseDomain + CartesianDomain + EllipsoidDomain + SimplexDomain Domain Operations ------------------ @@ -243,10 +244,11 @@ Domain Operations :titlesonly: OperationInterface - Union - Intersection - Difference - Exclusion + BaseOperation + Union + Intersection + Difference + Exclusion Callbacks ----------- diff --git a/docs/source/_rst/domain/base_domain.rst b/docs/source/_rst/domain/base_domain.rst new file mode 100644 index 000000000..e6b9ce88c --- /dev/null +++ b/docs/source/_rst/domain/base_domain.rst @@ -0,0 +1,9 @@ +BaseDomain +=========== +.. currentmodule:: pina.domain.base_domain + +.. automodule:: pina.domain.base_domain + +.. autoclass:: BaseDomain + :members: + :show-inheritance: \ No newline at end of file diff --git a/docs/source/_rst/domain/base_operation.rst b/docs/source/_rst/domain/base_operation.rst new file mode 100644 index 000000000..cfa145f03 --- /dev/null +++ b/docs/source/_rst/domain/base_operation.rst @@ -0,0 +1,9 @@ +BaseOperation +============== +.. currentmodule:: pina.domain.base_operation + +.. automodule:: pina.domain.base_operation + +.. autoclass:: BaseOperation + :members: + :show-inheritance: \ No newline at end of file diff --git a/docs/source/_rst/domain/cartesian.rst b/docs/source/_rst/domain/cartesian_domain.rst similarity index 56% rename from docs/source/_rst/domain/cartesian.rst rename to docs/source/_rst/domain/cartesian_domain.rst index 97f5e8974..15491be8c 100644 --- a/docs/source/_rst/domain/cartesian.rst +++ b/docs/source/_rst/domain/cartesian_domain.rst @@ -1,8 +1,8 @@ CartesianDomain ====================== -.. currentmodule:: pina.domain.cartesian +.. currentmodule:: pina.domain.cartesian_domain -.. automodule:: pina.domain.cartesian +.. automodule:: pina.domain.cartesian_domain .. autoclass:: CartesianDomain :members: diff --git a/docs/source/_rst/domain/difference_domain.rst b/docs/source/_rst/domain/difference.rst similarity index 51% rename from docs/source/_rst/domain/difference_domain.rst rename to docs/source/_rst/domain/difference.rst index f25daa522..0167c3062 100644 --- a/docs/source/_rst/domain/difference_domain.rst +++ b/docs/source/_rst/domain/difference.rst @@ -1,8 +1,8 @@ Difference ====================== -.. currentmodule:: pina.domain.difference_domain +.. currentmodule:: pina.domain.difference -.. automodule:: pina.domain.difference_domain +.. automodule:: pina.domain.difference .. autoclass:: Difference :members: diff --git a/docs/source/_rst/domain/domain.rst b/docs/source/_rst/domain/domain_interface.rst similarity index 83% rename from docs/source/_rst/domain/domain.rst rename to docs/source/_rst/domain/domain_interface.rst index 27adcf0bc..898896ba3 100644 --- a/docs/source/_rst/domain/domain.rst +++ b/docs/source/_rst/domain/domain_interface.rst @@ -1,5 +1,5 @@ -Domain -=========== +DomainInterface +================ .. currentmodule:: pina.domain.domain_interface .. automodule:: pina.domain.domain_interface diff --git a/docs/source/_rst/domain/ellipsoid.rst b/docs/source/_rst/domain/ellipsoid_domain.rst similarity index 56% rename from docs/source/_rst/domain/ellipsoid.rst rename to docs/source/_rst/domain/ellipsoid_domain.rst index ee0d2b7a4..4a9799e29 100644 --- a/docs/source/_rst/domain/ellipsoid.rst +++ b/docs/source/_rst/domain/ellipsoid_domain.rst @@ -1,8 +1,8 @@ EllipsoidDomain ====================== -.. currentmodule:: pina.domain.ellipsoid +.. currentmodule:: pina.domain.ellipsoid_domain -.. automodule:: pina.domain.ellipsoid +.. automodule:: pina.domain.ellipsoid_domain .. autoclass:: EllipsoidDomain :members: diff --git a/docs/source/_rst/domain/exclusion_domain.rst b/docs/source/_rst/domain/exclusion.rst similarity index 51% rename from docs/source/_rst/domain/exclusion_domain.rst rename to docs/source/_rst/domain/exclusion.rst index 8d18be199..f624122ae 100644 --- a/docs/source/_rst/domain/exclusion_domain.rst +++ b/docs/source/_rst/domain/exclusion.rst @@ -1,8 +1,8 @@ Exclusion ====================== -.. currentmodule:: pina.domain.exclusion_domain +.. currentmodule:: pina.domain.exclusion -.. automodule:: pina.domain.exclusion_domain +.. automodule:: pina.domain.exclusion .. autoclass:: Exclusion :members: diff --git a/docs/source/_rst/domain/intersection_domain.rst b/docs/source/_rst/domain/intersection.rst similarity index 50% rename from docs/source/_rst/domain/intersection_domain.rst rename to docs/source/_rst/domain/intersection.rst index 8b2498661..fade1d042 100644 --- a/docs/source/_rst/domain/intersection_domain.rst +++ b/docs/source/_rst/domain/intersection.rst @@ -1,8 +1,8 @@ Intersection ====================== -.. currentmodule:: pina.domain.intersection_domain +.. currentmodule:: pina.domain.intersection -.. automodule:: pina.domain.intersection_domain +.. automodule:: pina.domain.intersection .. autoclass:: Intersection :members: diff --git a/docs/source/_rst/domain/simplex.rst b/docs/source/_rst/domain/simplex_domain.rst similarity index 57% rename from docs/source/_rst/domain/simplex.rst rename to docs/source/_rst/domain/simplex_domain.rst index 7accd7f84..5f1d31c9b 100644 --- a/docs/source/_rst/domain/simplex.rst +++ b/docs/source/_rst/domain/simplex_domain.rst @@ -1,8 +1,8 @@ SimplexDomain ====================== -.. currentmodule:: pina.domain.simplex +.. currentmodule:: pina.domain.simplex_domain -.. automodule:: pina.domain.simplex +.. automodule:: pina.domain.simplex_domain .. autoclass:: SimplexDomain :members: diff --git a/docs/source/_rst/domain/union_domain.rst b/docs/source/_rst/domain/union.rst similarity index 51% rename from docs/source/_rst/domain/union_domain.rst rename to docs/source/_rst/domain/union.rst index 921e430cf..614bb351c 100644 --- a/docs/source/_rst/domain/union_domain.rst +++ b/docs/source/_rst/domain/union.rst @@ -1,8 +1,8 @@ Union ====================== -.. currentmodule:: pina.domain.union_domain +.. currentmodule:: pina.domain.union -.. automodule:: pina.domain.union_domain +.. automodule:: pina.domain.union .. autoclass:: Union :members: diff --git a/pina/domain/__init__.py b/pina/domain/__init__.py index cf0f03b90..57999f4d8 100644 --- a/pina/domain/__init__.py +++ b/pina/domain/__init__.py @@ -2,22 +2,24 @@ __all__ = [ "DomainInterface", + "BaseDomain", "CartesianDomain", "EllipsoidDomain", + "SimplexDomain", + "OperationInterface", "Union", "Intersection", - "Exclusion", "Difference", - "OperationInterface", - "SimplexDomain", + "Exclusion", ] from .domain_interface import DomainInterface -from .cartesian import CartesianDomain -from .ellipsoid import EllipsoidDomain -from .exclusion_domain import Exclusion -from .intersection_domain import Intersection -from .union_domain import Union -from .difference_domain import Difference +from .base_domain import BaseDomain +from .cartesian_domain import CartesianDomain +from .ellipsoid_domain import EllipsoidDomain +from .simplex_domain import SimplexDomain from .operation_interface import OperationInterface -from .simplex import SimplexDomain +from .union import Union +from .intersection import Intersection +from .difference import Difference +from .exclusion import Exclusion diff --git a/pina/domain/base_domain.py b/pina/domain/base_domain.py new file mode 100644 index 000000000..c7bef9700 --- /dev/null +++ b/pina/domain/base_domain.py @@ -0,0 +1,204 @@ +"""Module for the Base class for domains.""" + +from copy import deepcopy +from abc import ABCMeta +from .domain_interface import DomainInterface +from ..utils import check_consistency, check_positive_integer + + +class BaseDomain(DomainInterface, metaclass=ABCMeta): + """ + Base class for all geometric domains, implementing common functionality. + + All specific domain types should inherit from this class and implement the + abstract methods of :class:`~pina.domain.domain_interface.DomainInterface`. + + This class is not meant to be instantiated directly. + """ + + def __init__(self, variables_dict=None): + """ + Initialization of the :class:`BaseDomain` class. + + :param variables_dict: A dictionary where the keys are the variable + names and the values are the domain extrema. The domain extrema can + be either a list or tuple with two elements or a single number. If + the domain extrema is a single number, the variable is fixed to that + value. + :type variables_dict: dict | None + :raises TypeError: If the domain dictionary is not a dictionary. + :raises ValueError: If the domain dictionary is empty. + :raises ValueError: If the domain dictionary contains variables with + invalid ranges. + :raises ValueError: If the domain dictionary contains values that are + neither numbers nor lists/tuples of numbers of length 2. + """ + # Initialize fixed and ranged variables + self._fixed = {} + self._range = {} + invalid = [] + + # Skip checks if variables_dict is None -- SimplexDomain case + if variables_dict is None: + return + + # Check variables_dict is a dictionary + if not isinstance(variables_dict, dict): + raise TypeError( + "variables_dict must be dict: {name: number | (low, high)}" + ) + + # Check variables_dict is not empty + if not variables_dict: + raise ValueError( + "The dictionary defining the domain cannot be empty." + ) + + # Check consistency + for v in variables_dict.values(): + check_consistency(v, (int, float)) + + # Iterate over variables_dict items + for k, v in variables_dict.items(): + + # Fixed variables + if isinstance(v, (int, float)): + self._fixed[k] = v + + # Ranged variables + elif isinstance(v, (list, tuple)) and len(v) == 2: + low, high = v + if low >= high: + raise ValueError( + f"Invalid range for variable '{k}': " + f"low ({low}) >= high ({high})" + ) + self._range[k] = (low, high) + + # Save invalid keys + else: + invalid.append(k) + + # Raise an error if there are invalid keys + if invalid: + raise ValueError(f"Invalid value(s) for key(s): {invalid}") + + def update(self, domain): + """ + Update the current domain by adding the labels contained in ``domain``. + Each new label introduces a new dimension. Only domains of the same type + can be used for update. + + :param BaseDomain domain: The domain whose labels are to be merged + into the current one. + :raises TypeError: If the provided domain is not of the same type as + the current one. + :return: A new domain instance with the merged labels. + :rtype: BaseDomain + """ + # Raise an error if the domain types do not match + if not isinstance(domain, type(self)): + raise TypeError( + f"Cannot update domain of type {type(self)} " + f"with domain of type {type(domain)}." + ) + + # Update fixed and ranged variables + updated = deepcopy(self) + updated.fixed.update(domain.fixed) + updated.range.update(domain.range) + + return updated + + def _validate_sampling(self, n, mode, variables): + """ + Validate the sampling settings. + + :param int n: The number of samples to generate. + :param str mode: The sampling method. + :param variables: The list of variables to sample. If ``all``, all + variables are sampled. + :raises AssertionError: If ``n`` is not a positive integer. + :raises ValueError: If the sampling mode is invalid. + :raises ValueError: If ``variables`` is neither ``all``, a string, nor a + list/tuple of strings. + :raises ValueError: If any of the specified variables is unknown. + :return: The validated list of variables to sample. + :rtype: list[str] + """ + # Validate n + check_positive_integer(value=n, strict=True) + + # Validate mode + if mode not in self.sample_modes: + raise ValueError( + f"Invalid sampling mode: {mode}. Available: {self.sample_modes}" + ) + + # Validate variables + check_consistency(variables, str) + if variables == "all": + variables = self.variables + elif isinstance(variables, str): + variables = [variables] + else: + variables = list(dict.fromkeys(variables)) + + # Check for unknown variables + unknown = [v for v in variables if v not in self.variables] + if unknown: + raise ValueError( + f"Unknown variable(s): {unknown}. Available: {self.variables}" + ) + + return sorted(variables) + + @property + def sample_modes(self): + """ + The list of available sampling modes. + + :return: The list of available sampling modes. + :rtype: list[str] + """ + return list(self._sample_modes) + + @property + def variables(self): + """ + The list of variables of the domain. + + :return: The list of variables of the domain. + :rtype: list[str] + """ + return sorted(list(self._fixed.keys()) + list(self._range.keys())) + + @property + def domain_dict(self): + """ + The dictionary representing the domain. + + :return: The dictionary representing the domain. + :rtype: dict + """ + return {**self._fixed, **self._range} + + @property + def range(self): + """ + The range variables of the domain. + + :return: The range variables of the domain. + :rtype: dict + """ + return self._range + + @property + def fixed(self): + """ + The fixed variables of the domain. + + :return: The fixed variables of the domain. + :rtype: dict + """ + return self._fixed diff --git a/pina/domain/base_operation.py b/pina/domain/base_operation.py new file mode 100644 index 000000000..8261ae431 --- /dev/null +++ b/pina/domain/base_operation.py @@ -0,0 +1,172 @@ +"""Module for all set-based operations Base class.""" + +from copy import deepcopy +from abc import ABCMeta +from .operation_interface import OperationInterface +from .base_domain import BaseDomain +from ..utils import check_consistency + + +class BaseOperation(OperationInterface, BaseDomain, metaclass=ABCMeta): + """ + Base class for all set operation defined on geometric domains, implementing + common functionality. + + All specific operation types should inherit from this class and implement + the abstract methods defined in both the following interfaces: + :class:`~pina.domain.operation_interface.OperationInterface`, and + :class:`~pina.domain.domain_interface.DomainInterface`. + + This class is not meant to be instantiated directly. + """ + + def __init__(self, geometries): + """ + Initialization of the :class:`OperationInterface` class. + + :param geometries: The list of domains on which to perform the set + operation. + :type geometries: list[BaseDomain] | tuple[BaseDomain] + :raises TypeError: If geometries is neither a list nor a tuple. + :raises ValueError: If geometries elements are not instances of + :class:`~pina.domain.base_domain.BaseDomain`. + :raises NotImplementedError: If the dimensions of the geometries are not + consistent. + """ + super().__init__() + self.geometries = geometries + + def update(self, domain): + """ + Update the domain resulting from the operation. + + :param DomainInterface domain: The domain whose labels are to be merged + into the current one. + :raises NotImplementedError: If the geometries involved in the operation + are of different types. + :raises TypeError: If the passed domain is not of the same type of all + the geometries involved in the operation. + :return: A new domain instance with the merged labels. + :rtype: BaseOperation + """ + # Check all geometries are of the same type + domain_type = type(self.geometries[0]) + if not all(isinstance(g, domain_type) for g in self.geometries): + raise NotImplementedError( + f"The {self.__class__.__name__} of geometries of different" + " types does not support the update operation. All geometries" + " must be of the same type." + ) + + # Check domain type consistency + if not isinstance(domain, domain_type): + raise TypeError( + f"Cannot update the {self.__class__.__name__} of domains of" + f" type {domain_type} with domain of type {type(domain)}." + ) + + # Update each geometry + updated = deepcopy(self) + updated.geometries = [geom.update(domain) for geom in self.geometries] + + return updated + + @property + def sample_modes(self): + """ + The list of available sampling modes. + + :return: The list of available sampling modes. + :rtype: list[str] + """ + return list( + set.intersection( + *map(set, [g.sample_modes for g in self.geometries]) + ) + ) + + @property + def variables(self): + """ + The list of variables of the domain. + + :return: The list of variables of the domain. + :rtype: list[str] + """ + return sorted({v for g in self.geometries for v in g.variables}) + + @property + def domain_dict(self): + """ + Returns a dictionary representation of the operation domain. + + :return: The dictionary representation of the operation domain. + :rtype: dict + """ + return { + "type": self.__class__.__name__, + "geometries": [geom.domain_dict for geom in self.geometries], + } + + @property + def geometries(self): + """ + The domains on which to perform the set operation. + + :return: The domains on which to perform the set operation. + :rtype: list[BaseDomain] + """ + return self._geometries + + @property + def range(self): + """ + The range variables of each geometry. + + :return: The range variables of each geometry. + :rtype: dict + """ + return {f"geometry_{i}": g.range for i, g in enumerate(self.geometries)} + + @property + def fixed(self): + """ + The fixed variables of each geometry. + + :return: The fixed variables of each geometry. + :rtype: dict + """ + return {f"geometry_{i}": g.fixed for i, g in enumerate(self.geometries)} + + @geometries.setter + def geometries(self, values): + """ + Setter for the ``geometries`` property. + + :param values: The geometries to be set. + :type values: list[BaseDomain] | tuple[BaseDomain] + :raises TypeError: If values is neither a list nor a tuple. + :raises ValueError: If values elements are not instances of + :class:`~pina.domain.base_domain.BaseDomain`. + :raises NotImplementedError: If the dimensions of the geometries are not + consistent. + """ + # Check geometries are list or tuple + if not isinstance(values, (list, tuple)): + raise TypeError( + "geometries must be either a list or a tuple of BaseDomain." + ) + + # Check consistency + check_consistency(values, (BaseDomain, BaseOperation)) + + # Check geometries + for v in values: + if v.variables != values[0].variables: + raise NotImplementedError( + f"The {self.__class__.__name__} of geometries living in " + "different ambient spaces is not well-defined. " + "All geometries must share the same dimensions and labels." + ) + + self._geometries = values diff --git a/pina/domain/cartesian.py b/pina/domain/cartesian.py deleted file mode 100644 index 4e6f3b9b0..000000000 --- a/pina/domain/cartesian.py +++ /dev/null @@ -1,295 +0,0 @@ -"""Module for the Cartesian Domain.""" - -import torch - -from .domain_interface import DomainInterface -from ..label_tensor import LabelTensor -from ..utils import torch_lhs, chebyshev_roots - - -class CartesianDomain(DomainInterface): - """ - Implementation of the hypercube domain. - """ - - def __init__(self, cartesian_dict): - """ - Initialization of the :class:`CartesianDomain` class. - - :param dict cartesian_dict: A dictionary where the keys are the - variable names and the values are the domain extrema. The domain - extrema can be either a list with two elements or a single number. - If the domain extrema is a single number, the variable is fixed to - that value. - - :Example: - >>> spatial_domain = CartesianDomain({'x': [0, 1], 'y': [0, 1]}) - """ - self.fixed_ = {} - self.range_ = {} - - for k, v in cartesian_dict.items(): - if isinstance(v, (int, float)): - self.fixed_[k] = v - elif isinstance(v, (list, tuple)) and len(v) == 2: - self.range_[k] = v - else: - raise TypeError - - @property - def sample_modes(self): - """ - List of available sampling modes. - - :return: List of available sampling modes. - :rtype: list[str] - """ - return ["random", "grid", "lh", "chebyshev", "latin"] - - @property - def variables(self): - """ - List of variables of the domain. - - :return: List of variables of the domain. - :rtype: list[str] - """ - return sorted(list(self.fixed_.keys()) + list(self.range_.keys())) - - def update(self, new_domain): - """ - Add new dimensions to an existing :class:`CartesianDomain` object. - - :param CartesianDomain new_domain: New domain to be added to an existing - :class:`CartesianDomain` object. - - :Example: - >>> spatial_domain = CartesianDomain({'x': [0, 1], 'y': [0, 1]}) - >>> spatial_domain.variables - ['x', 'y'] - >>> spatial_domain_2 = CartesianDomain({'z': [3, 4], 'w': [0, 1]}) - >>> spatial_domain.update(spatial_domain_2) - >>> spatial_domain.variables - ['x', 'y', 'z', 'w'] - """ - self.fixed_.update(new_domain.fixed_) - self.range_.update(new_domain.range_) - - def _sample_range(self, n, mode, bounds): - """ - Rescale the samples to fit within the specified bounds. - - :param int n: Number of points to sample. - :param str mode: Sampling method. Default is ``random``. - :param torch.Tensor bounds: Bounds of the domain. - :raises RuntimeError: Wrong bounds initialization. - :raises ValueError: Invalid sampling mode. - :return: Rescaled sample points. - :rtype: torch.Tensor - """ - dim = bounds.shape[0] - if mode in ["chebyshev", "grid"] and dim != 1: - raise RuntimeError("Wrong bounds initialization") - - if mode == "random": - pts = torch.rand(size=(n, dim)) - elif mode == "chebyshev": - pts = chebyshev_roots(n).mul(0.5).add(0.5).reshape(-1, 1) - elif mode == "grid": - pts = torch.linspace(0, 1, n).reshape(-1, 1) - elif mode in ["lh", "latin"]: - pts = torch_lhs(n, dim) - else: - raise ValueError("Invalid mode") - - return pts * (bounds[:, 1] - bounds[:, 0]) + bounds[:, 0] - - def sample(self, n, mode="random", variables="all"): - """ - Sampling routine. - - :param int n: Number of points to sample, see Note below for reference. - :param str mode: Sampling method. Default is ``random``. - Available modes: random sampling, ``random``; - latin hypercube sampling, ``latin`` or ``lh``; - chebyshev sampling, ``chebyshev``; grid sampling ``grid``. - :param list[str] variables: variables to be sampled. Default is ``all``. - :return: Sampled points. - :rtype: LabelTensor - - .. note:: - When multiple variables are involved, the total number of sampled - points may differ from ``n``, depending on the chosen ``mode``. - If ``mode`` is ``grid`` or ``chebyshev``, points are sampled - independently for each variable and then combined, resulting in a - total number of points equal to ``n`` raised to the power of the - number of variables. If 'mode' is 'random', ``lh`` or ``latin``, - all variables are sampled together, and the total number of points - remains ``n``. - - .. warning:: - The extrema of CartesianDomain are only sampled when using the - ``grid`` mode. - - :Example: - >>> spatial_domain = CartesianDomain({'x': [0, 1], 'y': [0, 1]}) - >>> spatial_domain.sample(n=4, mode='random') - tensor([[0.0108, 0.7643], - [0.4477, 0.8015], - [0.2063, 0.8087], - [0.8735, 0.6349]]) - >>> spatial_domain.sample(n=4, mode='grid') - tensor([[0.0000, 0.0000], - [0.3333, 0.0000], - [0.6667, 0.0000], - [1.0000, 0.0000], - [0.0000, 0.3333], - [0.3333, 0.3333], - [0.6667, 0.3333], - [1.0000, 0.3333], - [0.0000, 0.6667], - [0.3333, 0.6667], - [0.6667, 0.6667], - [1.0000, 0.6667], - [0.0000, 1.0000], - [0.3333, 1.0000], - [0.6667, 1.0000], - [1.0000, 1.0000]]) - """ - - def _1d_sampler(n, mode, variables): - """ - Sample each variable independently. - - :param int n: Number of points to sample. - :param str mode: Sampling method. - :param list[str] variables: variables to be sampled. - :return: Sampled points. - :rtype: list[LabelTensor] - """ - tmp = [] - for variable in variables: - if variable in self.range_: - bound = torch.tensor([self.range_[variable]]) - pts_variable = self._sample_range(n, mode, bound) - pts_variable = pts_variable.as_subclass(LabelTensor) - pts_variable.labels = [variable] - - tmp.append(pts_variable) - if tmp: - result = tmp[0] - for i in tmp[1:]: - result = result.append(i, mode="cross") - - for variable in variables: - if variable in self.fixed_: - value = self.fixed_[variable] - pts_variable = torch.tensor([[value]]).repeat( - result.shape[0], 1 - ) - pts_variable = pts_variable.as_subclass(LabelTensor) - pts_variable.labels = [variable] - - result = result.append(pts_variable, mode="std") - - return result - - def _Nd_sampler(n, mode, variables): - """ - Sample all variables together. - - :param int n: Number of points to sample. - :param str mode: Sampling method. - :param list[str] variables: variables to be sampled. - :return: Sampled points. - :rtype: list[LabelTensor] - """ - pairs = [(k, v) for k, v in self.range_.items() if k in variables] - keys, values = map(list, zip(*pairs)) - bounds = torch.tensor(values) - result = self._sample_range(n, mode, bounds) - result = result.as_subclass(LabelTensor) - result.labels = keys - - for variable in variables: - if variable in self.fixed_: - value = self.fixed_[variable] - pts_variable = torch.tensor([[value]]).repeat( - result.shape[0], 1 - ) - pts_variable = pts_variable.as_subclass(LabelTensor) - pts_variable.labels = [variable] - - result = result.append(pts_variable, mode="std") - return result - - def _single_points_sample(n, variables): - """ - Sample a single point in one dimension. - - :param int n: Number of points to sample. - :param list[str] variables: variables to be sampled. - :return: Sampled points. - :rtype: list[torch.Tensor] - """ - tmp = [] - for variable in variables: - if variable in self.fixed_: - value = self.fixed_[variable] - pts_variable = torch.tensor([[value]]).repeat(n, 1) - pts_variable = pts_variable.as_subclass(LabelTensor) - pts_variable.labels = [variable] - tmp.append(pts_variable) - - result = tmp[0] - for i in tmp[1:]: - result = result.append(i, mode="std") - - return result - - if variables == "all": - variables = self.variables - elif isinstance(variables, (list, tuple)): - variables = sorted(variables) - - if self.fixed_ and (not self.range_): - return _single_points_sample(n, variables) - if isinstance(variables, str) and variables in self.fixed_: - return _single_points_sample(n, variables) - - if mode in ["grid", "chebyshev"]: - return _1d_sampler(n, mode, variables).extract(variables) - if mode in ["random", "lh", "latin"]: - return _Nd_sampler(n, mode, variables).extract(variables) - raise ValueError(f"mode={mode} is not valid.") - - def is_inside(self, point, check_border=False): - """ - Check if a point is inside the hypercube. - - :param LabelTensor point: Point to be checked. - :param bool check_border: If ``True``, the border is considered inside - the hypercube. Default is ``False``. - :return: ``True`` if the point is inside the domain, - ``False`` otherwise. - :rtype: bool - """ - is_inside = [] - - # check fixed variables - for variable, value in self.fixed_.items(): - if variable in point.labels: - is_inside.append(point.extract([variable]) == value) - - # check not fixed variables - for variable, bound in self.range_.items(): - if variable in point.labels: - - if check_border: - check = bound[0] <= point.extract([variable]) <= bound[1] - else: - check = bound[0] < point.extract([variable]) < bound[1] - - is_inside.append(check) - - return all(is_inside) diff --git a/pina/domain/cartesian_domain.py b/pina/domain/cartesian_domain.py new file mode 100644 index 000000000..3333a8fc3 --- /dev/null +++ b/pina/domain/cartesian_domain.py @@ -0,0 +1,236 @@ +"""Module for the Cartesian Domain.""" + +import torch +from .base_domain import BaseDomain +from .union import Union +from ..utils import torch_lhs, chebyshev_roots, check_consistency +from ..label_tensor import LabelTensor + + +class CartesianDomain(BaseDomain): + """ + Implementation of the hypercube domain, obtained as the cartesian product of + one-dimensional intervals. + + :Example: + + >>> cartesian_domain = CartesianDomain({'x': [0, 1], 'y': [0, 1]}) + >>> cartesian_domain = CartesianDomain({'x': [0, 1], 'y': 1.0}) + """ + + def __init__(self, cartesian_dict): + """ + Initialization of the :class:`CartesianDomain` class. + + :param dict cartesian_dict: A dictionary where the keys are the variable + names and the values are the domain extrema. The domain extrema can + be either a list or tuple with two elements or a single number. If + the domain extrema is a single number, the variable is fixed to that + value. + :raises TypeError: If the cartesian dictionary is not a dictionary. + :raises ValueError: If the cartesian dictionary contains variables with + invalid ranges. + :raises ValueError: If the cartesian dictionary contains values that are + neither numbers nor lists/tuples of numbers of length 2. + """ + # Initialization + super().__init__(variables_dict=cartesian_dict) + self._sample_modes = ("random", "grid", "chebyshev", "lh", "latin") + + def is_inside(self, point, check_border=False): + """ + Check if a point is inside the domain. + + :param LabelTensor point: The point to check. + :param bool check_border: If ``True``, the boundary is considered inside + the domain. Default is ``False``. + :raises ValueError: If ``point`` is not a :class:`LabelTensor`. + :raises ValueError: If the labels of ``point`` differ from the variables + of the domain. + :return: Whether the point is inside the domain or not. + :rtype: bool + """ + # Checks on point + check_consistency(point, LabelTensor) + if set(self.variables) != set(point.labels): + raise ValueError( + "Point labels differ from domain's dictionary labels. " + f"Got {sorted(point.labels)}, expected {self.variables}." + ) + + # Fixed variable checks + fixed_check = all( + (point.extract([k]) == v).all() for k, v in self._fixed.items() + ) + + # If there are no range variables, return fixed variable check + if not self._range: + return fixed_check + + # Ranged variable checks -- check_border True + if check_border: + range_check = all( + ( + (point.extract([k]) >= low) & (point.extract([k]) <= high) + ).all() + for k, (low, high) in self._range.items() + ) + + # Ranged variable checks -- check_border False + else: + range_check = all( + ((point.extract([k]) > low) & (point.extract([k]) < high)).all() + for k, (low, high) in self._range.items() + ) + + return fixed_check and range_check + + def sample(self, n, mode="random", variables="all"): + """ + The sampling routine. + + :param int n: The number of samples to generate. See Note for reference. + :param str mode: The sampling method. Available modes: ``random`` for + random sampling; ``latin`` or ``lh`` for latin hypercube sampling; + ``chebyshev`` for chebyshev sampling; ``grid`` for grid sampling. + Default is ``random``. + :param variables: The list of variables to sample. If ``all``, all + variables are sampled. Default is ``all``. + :type variables: list[str] | str + :raises AssertionError: If ``n`` is not a positive integer. + :raises ValueError: If the sampling mode is invalid. + :raises ValueError: If ``variables`` is neither ``all``, a string, nor a + list/tuple of strings. + :raises ValueError: If any of the specified variables is unknown. + :return: The sampled points. + :rtype: LabelTensor + + .. note:: + When multiple variables are involved, the total number of sampled + points may differ depending on the chosen ``mode``. + If ``mode`` is ``grid`` or ``chebyshev``, points are sampled + independently for each variable and then combined, resulting in a + total number of points equal to ``n`` raised to the power of the + number of variables. If ``mode`` is ``random``, ``lh`` or ``latin``, + all variables are sampled together, and the total number of points + remains ``n``. + + .. warning:: + The extrema of CartesianDomain are only sampled when using the + ``grid`` mode. + + :Example: + + >>> cartesian_domain = CartesianDomain({'x': [0, 1], 'y': [0, 1]}) + >>> cartesian_domain.sample(n=3, mode='random') + LabelTensor([[0.0108, 0.7643], + [0.4477, 0.8015], + [0.8735, 0.6349]]) + >>> cartesian_domain.sample(n=3, mode='grid') + LabelTensor([[0.0000, 0.0000], + [0.5000, 0.0000], + [1.0000, 0.0000], + [0.0000, 0.5000], + [0.5000, 0.5000], + [1.0000, 0.5000], + [0.0000, 1.0000], + [0.5000, 1.0000], + [1.0000, 1.0000]]) + """ + # Validate sampling settings + variables = self._validate_sampling(n, mode, variables) + + # Separate range and fixed variables + range_vars = [v for v in variables if v in self._range] + fixed_vars = [v for v in variables if v in self._fixed] + + # If there are no range variables, return fixed variables only + if not range_vars: + vals = [torch.full((n, 1), self._fixed[v]) for v in fixed_vars] + result = torch.cat(vals, dim=1) + result = result.as_subclass(LabelTensor) + result.labels = fixed_vars + return result + + # Create a tensor of bounds for the range variables + bounds = torch.as_tensor([self._range[v] for v in range_vars]) + + # Sample for mode random or latin hypercube + if mode in {"random", "lh", "latin"}: + pts = self._sample_range(n, mode, bounds) + + # Sample for mode grid or chebyshev + else: + grids = [ + self._sample_range( + n, mode, torch.as_tensor([self._range[v]]) + ).reshape(-1) + for v in range_vars + ] + pts = torch.cartesian_prod(*grids).reshape(-1, len(grids)) + + # Add fixed vars + if fixed_vars: + fixed_vals = [ + torch.full((pts.shape[0], 1), self._fixed[v]) + for v in fixed_vars + ] + pts = torch.cat([pts] + fixed_vals, dim=1) + labels = range_vars + fixed_vars + else: + labels = range_vars + + # Create the result as a LabelTensor + pts = pts.as_subclass(LabelTensor) + pts.labels = labels + + return pts[sorted(pts.labels)] + + def _sample_range(self, n, mode, bounds): + """ + Sample points and rescale to fit within the specified bounds. + + :param int n: The number of points to sample. + :param str mode: The sampling method. Default is ``random``. + :param torch.Tensor bounds: The bounds of the domain. + :return: The rescaled sample points. + :rtype: torch.Tensor + """ + # Define a dictionary of sampling methods + samplers = { + "random": lambda: torch.rand(size=(n, bounds.shape[0])), + "chebyshev": lambda: chebyshev_roots(n) + .mul(0.5) + .add(0.5) + .reshape(-1, 1), + "grid": lambda: torch.linspace(0, 1, n).reshape(-1, 1), + "lh": lambda: torch_lhs(n, bounds.shape[0]), + "latin": lambda: torch_lhs(n, bounds.shape[0]), + } + + # Sample points in [0, 1]^d and rescale to the desired bounds + pts = samplers[mode]() + + return pts * (bounds[:, 1] - bounds[:, 0]) + bounds[:, 0] + + def partial(self): + """ + Return the boundary of the domain as a :class:`Union` object. + + :return: The boundary of the domain. + :rtype: Union + """ + faces = [] + + # Iterate over ranged variables + for var, (low, high) in self._range.items(): + + # Fix the variable to its low value to get the lower face + lower = CartesianDomain({**self._fixed, **self._range, var: low}) + + # Fix the variable to its high value to get the upper face + higher = CartesianDomain({**self._fixed, **self._range, var: high}) + + faces.extend([lower, higher]) + + return Union(faces) diff --git a/pina/domain/difference.py b/pina/domain/difference.py new file mode 100644 index 000000000..76807b035 --- /dev/null +++ b/pina/domain/difference.py @@ -0,0 +1,120 @@ +"""Module for the Difference operation.""" + +from .base_operation import BaseOperation +from ..label_tensor import LabelTensor +from ..utils import check_consistency + + +class Difference(BaseOperation): + r""" + Implementation of the difference operation defined on a list of domains. + + Given two sets :math:`A` and :math:`B`, define their difference as: + + .. math:: + + A \setminus B = \{x \mid x \in A \land x \not\in B\} + + For multiple sets :math:`A_1, A_2, \ldots, A_n`, define their difference as + the set of points that belong to the first set but not to any of the + remaining sets. + + No check is performed to ensure that the resulting domain is non-empty. + + :Example: + + >>> cartesian1 = CartesianDomain({'x': [0, 1], 'y': [0, 1]}) + >>> cartesian2 = CartesianDomain({'x': [0, 1], 'y': [0.5, 1.5]}) + >>> difference = Difference([cartesian1, cartesian2]) + """ + + def is_inside(self, point, check_border=False): + """ + Check if a point is inside the difference of the domains. + + :param LabelTensor point: The point to check. + :param bool check_border: If ``True``, the boundary is considered inside + the domain. Default is ``False``. + :raises ValueError: If ``point`` is not a :class:`LabelTensor`. + :raises ValueError: If the labels of ``point`` differ from the variables + of the domain. + :return: Whether the point is inside the domain or not. + :rtype: bool + """ + # Checks on point + check_consistency(point, LabelTensor) + if set(self.variables) != set(point.labels): + raise ValueError( + "Point labels differ from domain's dictionary labels. " + f"Got {sorted(point.labels)}, expected {self.variables}." + ) + + # Check if the point is inside the first geometry and not in any other + inside_first = self.geometries[0].is_inside(point, check_border) + inside_others = any( + g.is_inside(point, check_border) for g in self.geometries[1:] + ) + + return inside_first and not inside_others + + def sample(self, n, mode="random", variables="all"): + """ + The sampling routine. + + .. note:: + + This sampling method relies on rejection sampling. Points are drawn + from the individual geometries, and only those that lie exclusively + within one geometry are kept. When the exclusion domain is small + relative to the combined area of the input domains, the method may + become highly inefficient. + + :param int n: The number of samples to generate. + :param str mode: The sampling method. Default is ``random``. + :param variables: The list of variables to sample. If ``all``, all + variables are sampled. Default is ``all``. + :type variables: list[str] | str + :raises AssertionError: If ``n`` is not a positive integer. + :raises ValueError: If the sampling mode is invalid. + :raises ValueError: If ``variables`` is neither ``all``, a string, nor a + list/tuple of strings. + :raises ValueError: If any of the specified variables is unknown. + :return: The sampled points. + :rtype: LabelTensor + """ + # Validate sampling settings + variables = self._validate_sampling(n, mode, variables) + + # Allocate list for samples + samples = [] + + # Sample until we have enough points + while len(samples) < n: + + # Sample a sufficiently large number of points + batch_size = 2 * (n - len(samples)) + pts = self.geometries[0].sample(batch_size, mode) + + # Filter points inside the intersection + for p in pts: + p = p.reshape(1, -1) + p.labels = pts.labels + if self.is_inside(p): + samples.append(p[variables]) + if len(samples) >= n: + break + + return LabelTensor.cat(samples, dim=0) + + def partial(self): + """ + Return the boundary of the domain resulting from the operation. + + :raises NotImplementedError: The :meth:`partial` method is not + implemented for difference domains. Please operate on the individual + domains instead. + """ + raise NotImplementedError( + "The partial method is not implemented for difference domains. " + "Please operate on the individual domains instead." + ) diff --git a/pina/domain/difference_domain.py b/pina/domain/difference_domain.py deleted file mode 100644 index 4ea7b5278..000000000 --- a/pina/domain/difference_domain.py +++ /dev/null @@ -1,109 +0,0 @@ -"""Module for the Difference Operation.""" - -import torch -from .operation_interface import OperationInterface -from ..label_tensor import LabelTensor - - -class Difference(OperationInterface): - r""" - Implementation of the difference operation between of a list of domains. - - Given two sets :math:`A` and :math:`B`, define the difference of the two - sets as: - - .. math:: - A - B = \{x \mid x \in A \land x \not\in B\}, - - where :math:`x` is a point in :math:`\mathbb{R}^N`. - """ - - def __init__(self, geometries): - """ - Initialization of the :class:`Difference` class. - - :param list[DomainInterface] geometries: A list of instances of the - :class:`~pina.domain.domain_interface.DomainInterface` class on - which the difference operation is performed. The first domain in the - list serves as the base from which points are sampled, while the - remaining domains define the regions to be excluded from the base - domain to compute the difference. - - :Example: - >>> # Create two ellipsoid domains - >>> ellipsoid1 = EllipsoidDomain({'x': [-1, 1], 'y': [-1, 1]}) - >>> ellipsoid2 = EllipsoidDomain({'x': [0, 2], 'y': [0, 2]}) - >>> # Define the difference between the domains - >>> difference = Difference([ellipsoid1, ellipsoid2]) - """ - super().__init__(geometries) - - def is_inside(self, point, check_border=False): - """ - Check if a point is inside the resulting domain. - - :param LabelTensor point: Point to be checked. - :param bool check_border: If ``True``, the border is considered inside - the domain. Default is ``False``. - :return: ``True`` if the point is inside the domain, - ``False`` otherwise. - :rtype: bool - """ - for geometry in self.geometries[1:]: - if geometry.is_inside(point): - return False - return self.geometries[0].is_inside(point, check_border) - - def sample(self, n, mode="random", variables="all"): - """ - Sampling routine. - - :param int n: Number of points to sample. - :param str mode: Sampling method. Default is ``random``. - Available modes: random sampling, ``random``; - :param list[str] variables: variables to be sampled. Default is ``all``. - :raises NotImplementedError: If the sampling method is not implemented. - :return: Sampled points. - :rtype: LabelTensor - - :Example: - >>> # Create two Cartesian domains - >>> cartesian1 = CartesianDomain({'x': [0, 2], 'y': [0, 2]}) - >>> cartesian2 = CartesianDomain({'x': [1, 3], 'y': [1, 3]}) - >>> # Define the difference between the domains - >>> difference = Difference([cartesian1, cartesian2]) - >>> # Sampling - >>> difference.sample(n=5) - LabelTensor([[0.8400, 0.9179], - [0.9154, 0.5769], - [1.7403, 0.4835], - [0.9545, 1.2851], - [1.3726, 0.9831]]) - >>> len(difference.sample(n=5) - 5 - - """ - if mode not in self.sample_modes: - raise NotImplementedError( - f"{mode} is not a valid mode for sampling." - ) - - sampled = [] - - # sample the points - while len(sampled) < n: - # get sample point from first geometry - point = self.geometries[0].sample(1, mode, variables) - is_inside = False - - # check if point is inside any other geometry - for geometry in self.geometries[1:]: - # if point is inside any other geometry, break - if geometry.is_inside(point): - is_inside = True - break - # if point is not inside any other geometry, add to sampled - if not is_inside: - sampled.append(point) - - return LabelTensor(torch.cat(sampled), labels=self.variables) diff --git a/pina/domain/domain_interface.py b/pina/domain/domain_interface.py index 7f693e3da..f9b980bd8 100644 --- a/pina/domain/domain_interface.py +++ b/pina/domain/domain_interface.py @@ -5,57 +5,101 @@ class DomainInterface(metaclass=ABCMeta): """ - Abstract base class for geometric domains. All specific domain types should - inherit from this class. + Abstract interface for all geometric domains. """ - available_sampling_modes = ["random", "grid", "lh", "chebyshev", "latin"] + @abstractmethod + def is_inside(self, point, check_border): + """ + Check if a point is inside the domain. + + :param LabelTensor point: The point to check. + :param bool check_border: If ``True``, the boundary is considered inside + the domain. + :return: Whether the point is inside the domain or not. + :rtype: bool + """ + + @abstractmethod + def update(self, domain): + """ + Update the current domain by adding the labels contained in ``domain``. + Each new label introduces a new dimension. Only domains of the same type + can be used for update. + + :param BaseDomain domain: The domain whose labels are to be merged into + the current one. + :return: A new domain instance with the merged labels. + :rtype: DomainInterface + """ + + @abstractmethod + def sample(self, n, mode, variables): + """ + The sampling routine. + + :param int n: The number of samples to generate. + :param str mode: The sampling method. + :param list[str] variables: The list of variables to sample. + :return: The sampled points. + :rtype: LabelTensor + """ + + @abstractmethod + def partial(self): + """ + Return the boundary of the domain as a new domain object. + + :return: The boundary of the domain. + :rtype: DomainInterface + """ @property @abstractmethod def sample_modes(self): """ - Abstract method defining sampling methods. + The list of available sampling modes. + + :return: The list of available sampling modes. + :rtype: list[str] """ @property @abstractmethod def variables(self): """ - Abstract method returning the domain variables. + The list of variables of the domain. + + :return: The list of variables of the domain. + :rtype: list[str] """ - @sample_modes.setter - def sample_modes(self, values): + @property + @abstractmethod + def domain_dict(self): """ - Setter for the sample_modes property. + The dictionary representing the domain. - :param values: Sampling modes to be set. - :type values: str | list[str] - :raises TypeError: Invalid sampling mode. + :return: The dictionary representing the domain. + :rtype: dict """ - if not isinstance(values, (list, tuple)): - values = [values] - for value in values: - if value not in DomainInterface.available_sampling_modes: - raise TypeError( - f"mode {value} not valid. Expected at least " - "one in " - f"{DomainInterface.available_sampling_modes}." - ) + @property @abstractmethod - def sample(self): + def range(self): """ - Abstract method for the sampling routine. + The range variables of the domain. + + :return: The range variables of the domain. + :rtype: dict """ + @property @abstractmethod - def is_inside(self, point, check_border=False): + def fixed(self): """ - Abstract method for checking if a point is inside the domain. + The fixed variables of the domain. - :param LabelTensor point: Point to be checked. - :param bool check_border: If ``True``, the border is considered inside - the domain. Default is ``False``. + :return: The fixed variables of the domain. + :rtype: dict """ diff --git a/pina/domain/ellipsoid.py b/pina/domain/ellipsoid.py deleted file mode 100644 index 4b75be8e2..000000000 --- a/pina/domain/ellipsoid.py +++ /dev/null @@ -1,295 +0,0 @@ -"""Module for the Ellipsoid Domain.""" - -import torch -from .domain_interface import DomainInterface -from ..label_tensor import LabelTensor -from ..utils import check_consistency - - -class EllipsoidDomain(DomainInterface): - """ - Implementation of the ellipsoid domain. - """ - - def __init__(self, ellipsoid_dict, sample_surface=False): - """ - Initialization of the :class:`EllipsoidDomain` class. - - :param dict ellipsoid_dict: A dictionary where the keys are the variable - names and the values are the domain extrema. - :param bool sample_surface: A flag to choose the sampling strategy. - If ``True``, samples are taken from the surface of the ellipsoid. - If ``False``, samples are taken from the interior of the ellipsoid. - Default is ``False``. - :raises TypeError: If the input dictionary is not correctly formatted. - - .. warning:: - Sampling for dimensions greater or equal to 10 could result in a - shrinkage of the ellipsoid, which degrades the quality of the - samples. For dimensions higher than 10, see the following reference. - - .. seealso:: - **Original reference**: Dezert, Jean, and Musso, Christian. - *An efficient method for generating points uniformly distributed - in hyperellipsoids.* - Proceedings of the Workshop on Estimation, Tracking and Fusion: - A Tribute to Yaakov Bar-Shalom. 2001. - - :Example: - >>> spatial_domain = Ellipsoid({'x':[-1, 1], 'y':[-1,1]}) - """ - self.fixed_ = {} - self.range_ = {} - self._centers = None - self._axis = None - - # checking consistency - check_consistency(sample_surface, bool) - self._sample_surface = sample_surface - - for k, v in ellipsoid_dict.items(): - if isinstance(v, (int, float)): - self.fixed_[k] = v - elif isinstance(v, (list, tuple)) and len(v) == 2: - self.range_[k] = v - else: - raise TypeError - - # perform operation only for not fixed variables (if any) - - if self.range_: - # convert dict vals to torch [dim, 2] matrix - list_dict_vals = list(self.range_.values()) - tmp = torch.tensor(list_dict_vals, dtype=torch.float) - - # get the ellipsoid center - normal_basis = torch.eye(len(list_dict_vals)) - centers = torch.diag(normal_basis * tmp.mean(axis=1)) - - # get the ellipsoid axis - ellipsoid_axis = (tmp - centers.reshape(-1, 1))[:, -1] - - # save elipsoid axis and centers as dict - self._centers = dict(zip(self.range_.keys(), centers.tolist())) - self._axis = dict(zip(self.range_.keys(), ellipsoid_axis.tolist())) - - @property - def sample_modes(self): - """ - List of available sampling modes. - - :return: List of available sampling modes. - :rtype: list[str] - """ - return ["random"] - - @property - def variables(self): - """ - List of variables of the domain. - - :return: List of variables of the domain. - :rtype: list[str] - """ - return sorted(list(self.fixed_.keys()) + list(self.range_.keys())) - - def is_inside(self, point, check_border=False): - """ - Check if a point is inside the ellipsoid. - - :param LabelTensor point: Point to be checked. - :param bool check_border: If ``True``, the border is considered inside - the ellipsoid. Default is ``False``. - :raises ValueError: If the labels of the point are different from those - passed in the ``__init__`` method. - :return: ``True`` if the point is inside the domain, - ``False`` otherwise. - :rtype: bool - - .. note:: - When ``sample_surface=True`` in the ``__init__`` method, this method - checks only those points lying on the surface of the ellipsoid. - """ - # small check that point is labeltensor - check_consistency(point, LabelTensor) - - # get axis ellipse as tensors - list_dict_vals = list(self._axis.values()) - tmp = torch.tensor(list_dict_vals, dtype=torch.float) - ax_sq = LabelTensor(tmp.reshape(1, -1) ** 2, self.variables) - - # get centers ellipse as tensors - list_dict_vals = list(self._centers.values()) - tmp = torch.tensor(list_dict_vals, dtype=torch.float) - centers = LabelTensor(tmp.reshape(1, -1), self.variables) - - if not all(i in ax_sq.labels for i in point.labels): - raise ValueError( - "point labels different from constructor" - f" dictionary labels. Got {point.labels}," - f" expected {ax_sq.labels}." - ) - - # point square + shift center - point_sq = (point - centers).pow(2) - point_sq.labels = point.labels - - # calculate ellispoid equation - eqn = torch.sum(point_sq.extract(ax_sq.labels) / ax_sq) - 1.0 - - # if we have sampled only the surface, we check that the - # point is inside the surface border only - if self._sample_surface: - return torch.allclose(eqn, torch.zeros_like(eqn)) - - # otherwise we check the ellipse - if check_border: - return bool(eqn <= 0) - - return bool(eqn < 0) - - def _sample_range(self, n, mode, variables): - """ - Rescale the samples to fit within the specified bounds. - - :param int n: Number of points to sample. - :param str mode: Sampling method. Default is ``random``. - :param list[str] variables: variables whose samples must be rescaled. - :return: Rescaled sample points. - :rtype: torch.Tensor - """ - - # =============== For Developers ================ # - # - # The sampling startegy used is fairly simple. - # For all `mode`s first we sample from the unit - # sphere and then we scale and shift according - # to self._axis.values() and self._centers.values(). - # - # =============================================== # - - # get dimension - dim = len(variables) - - # get values center - pairs_center = [ - (k, v) for k, v in self._centers.items() if k in variables - ] - _, values_center = map(list, zip(*pairs_center)) - values_center = torch.tensor(values_center) - - # get values axis - pairs_axis = [(k, v) for k, v in self._axis.items() if k in variables] - _, values_axis = map(list, zip(*pairs_axis)) - values_axis = torch.tensor(values_axis) - - # Sample in the unit sphere - if mode == "random": - # 1. Sample n points from the surface of a unit sphere - # 2. Scale each dimension using torch.rand() - # (a random number between 0-1) so that it lies within - # the sphere, only if self._sample_surface=False - # 3. Multiply with self._axis.values() to make it ellipsoid - # 4. Shift the mean of the ellipse by adding self._centers.values() - - # step 1. - pts = torch.randn(size=(n, dim)) - pts = pts / torch.linalg.norm(pts, axis=-1).view((n, 1)) - if not self._sample_surface: # step 2. - scale = torch.rand((n, 1)) - pts = pts * scale - - # step 3. and 4. - pts *= values_axis - pts += values_center - - return pts - - def sample(self, n, mode="random", variables="all"): - """ - Sampling routine. - - :param int n: Number of points to sample. - :param str mode: Sampling method. Default is ``random``. - Available modes: random sampling, ``random``. - :param list[str] variables: variables to be sampled. Default is ``all``. - :raises NotImplementedError: If the sampling mode is not implemented. - :return: Sampled points. - :rtype: LabelTensor - - :Example: - >>> ellipsoid = Ellipsoid({'x':[1, 0], 'y':1}) - >>> ellipsoid.sample(n=6) - tensor([[0.4872, 1.0000], - [0.2977, 1.0000], - [0.0422, 1.0000], - [0.6431, 1.0000], - [0.7272, 1.0000], - [0.8326, 1.0000]]) - """ - - def _Nd_sampler(n, mode, variables): - """ - Sample all variables together. - - :param int n: Number of points to sample. - :param str mode: Sampling method. - :param list[str] variables: variables to be sampled. - :return: Sampled points. - :rtype: list[LabelTensor] - """ - pairs = [(k, v) for k, v in self.range_.items() if k in variables] - keys, _ = map(list, zip(*pairs)) - - result = self._sample_range(n, mode, keys) - result = result.as_subclass(LabelTensor) - result.labels = keys - - for variable in variables: - if variable in self.fixed_: - value = self.fixed_[variable] - pts_variable = torch.tensor([[value]]).repeat( - result.shape[0], 1 - ) - pts_variable = pts_variable.as_subclass(LabelTensor) - pts_variable.labels = [variable] - - result = result.append(pts_variable, mode="std") - return result - - def _single_points_sample(n, variables): - """ - Sample a single point in one dimension. - - :param int n: Number of points to sample. - :param list[str] variables: variables to be sampled. - :return: Sampled points. - :rtype: list[torch.Tensor] - """ - tmp = [] - for variable in variables: - if variable in self.fixed_: - value = self.fixed_[variable] - pts_variable = torch.tensor([[value]]).repeat(n, 1) - pts_variable = pts_variable.as_subclass(LabelTensor) - pts_variable.labels = [variable] - tmp.append(pts_variable) - - result = tmp[0] - for i in tmp[1:]: - result = result.append(i, mode="std") - - return result - - if variables == "all": - variables = self.variables - elif isinstance(variables, (list, tuple)): - variables = sorted(variables) - - if self.fixed_ and (not self.range_): - return _single_points_sample(n, variables).extract(variables) - - if mode in self.sample_modes: - return _Nd_sampler(n, mode, variables).extract(variables) - - raise NotImplementedError(f"mode={mode} is not implemented.") diff --git a/pina/domain/ellipsoid_domain.py b/pina/domain/ellipsoid_domain.py new file mode 100644 index 000000000..ecb08e37c --- /dev/null +++ b/pina/domain/ellipsoid_domain.py @@ -0,0 +1,264 @@ +"""Module for the Ellipsoid Domain.""" + +from copy import deepcopy +import torch +from .base_domain import BaseDomain +from ..label_tensor import LabelTensor +from ..utils import check_consistency + + +class EllipsoidDomain(BaseDomain): + """ + Implementation of the ellipsoid domain. + + .. seealso:: + + **Original reference**: Dezert, Jean, and Musso, Christian. + *An efficient method for generating points uniformly distributed + in hyperellipsoids.* + Proceedings of the Workshop on Estimation, Tracking and Fusion: + A Tribute to Yaakov Bar-Shalom. 2001. + + :Example: + + >>> ellipsoid_domain = EllipsoidDomain({'x':[-1, 1], 'y':[-1, 1]}) + >>> ellipsoid_domain = EllipsoidDomain({'x':[-1, 1], 'y':1.0}) + """ + + def __init__(self, ellipsoid_dict, sample_surface=False): + """ + Initialization of the :class:`EllipsoidDomain` class. + + :param dict ellipsoid_dict: A dictionary where the keys are the variable + names and the values are the domain extrema. The domain extrema can + be either a list or tuple with two elements or a single number. If + the domain extrema is a single number, the variable is fixed to that + value. + :param bool sample_surface: If ``True``, only the surface of the + ellipsoid is considered part of the domain. Default is ``False``. + :raises ValueError: If ``sample_surface`` is not a boolean. + :raises TypeError: If the ellipsoid dictionary is not a dictionary. + :raises ValueError: If the ellipsoid dictionary contains variables with + invalid ranges. + :raises ValueError: If the ellipsoid dictionary contains values that are + neither numbers nor lists/tuples of numbers of length 2. + """ + # Initialization + super().__init__(variables_dict=ellipsoid_dict) + self.sample_surface = sample_surface + self._sample_modes = ("random",) + self.compute_center_axes() + + def compute_center_axes(self): + """ + Compute centers and axes for the ellipsoid. + """ + if self._range: + rng_vars = sorted(self._range.keys()) + vals = torch.tensor( + [self._range[k] for k in rng_vars], dtype=torch.float + ) + self._centers = LabelTensor(vals.mean(dim=1), rng_vars) + self._axes = LabelTensor( + (vals - self._centers.unsqueeze(1))[:, -1], + rng_vars, + ) + else: + self._centers = None + self._axes = None + + def is_inside(self, point, check_border=False): + """ + Check if a point is inside the ellipsoid. + + :param LabelTensor point: The point to check. + :param bool check_border: If ``True``, the boundary is considered inside + the domain. Default is ``False``. + :raises ValueError: If ``point`` is not a :class:`LabelTensor`. + :raises ValueError: If the labels of ``point`` differ from the variables + of the domain. + :return: Whether the point is inside the domain or not. + :rtype: bool + """ + # Checks on point + check_consistency(point, LabelTensor) + if set(self.variables) != set(point.labels): + raise ValueError( + "Point labels differ from constructor dictionary labels. " + f"Got {sorted(point.labels)}, expected {self.variables}." + ) + + # Fixed variable checks + fixed_check = all( + (point.extract([k]) == v).all() for k, v in self._fixed.items() + ) + + # If there are no range variables, return fixed variable check + if not self._range: + return fixed_check + + # Compute the equation defining the ellipsoid + rng = sorted(self._range.keys()) + squared_axis = self._axes[rng].pow(2) + delta = (point[rng] - self._centers[rng]).pow(2) + eqn = torch.sum(delta / squared_axis) - 1.0 + + # Range variable check on the surface + if self._sample_surface: + range_check = torch.allclose(eqn, torch.zeros_like(eqn)) + return fixed_check and range_check + + # Range variable check in the volume + range_check = (eqn <= 0) if check_border else (eqn < 0) + + return fixed_check and range_check.item() + + def update(self, domain): + """ + Update the current domain by adding the labels contained in ``domain``. + Each new label introduces a new dimension. Only domains of the same type + can be used for update. + + :param EllipsoidDomain domain: The domain whose labels are to be merged + into the current one. + :raises TypeError: If the provided domain is not of an instance of + :class:`EllipsoidDomain`. + :return: A new domain instance with the merged labels. + :rtype: EllipsoidDomain + """ + updated = super().update(domain) + updated.compute_center_axes() + + return updated + + def sample(self, n, mode="random", variables="all"): + """ + Sampling routine. + + :param int n: The number of samples to generate. + :param str mode: The sampling method. Available modes: ``random`` for + random sampling. Default is ``random``. + :param variables: The list of variables to sample. If ``all``, all + variables are sampled. Default is ``all``. + :type variables: list[str] | str + :raises AssertionError: If ``n`` is not a positive integer. + :raises ValueError: If the sampling mode is invalid. + :raises ValueError: If ``variables`` is neither ``all``, a string, nor a + list/tuple of strings. + :raises ValueError: If any of the specified variables is unknown. + :return: The sampled points. + :rtype: LabelTensor + + :Example: + + >>> ellipsoid_domain = EllipsoidDomain({'x':[0, 1], 'y':[0, 1]}) + >>> ellipsoid_domain.sample(n=5) + LabelTensor([[0.7174, 0.5319], + [0.2713, 0.6518], + [0.1020, 0.4093], + [0.2102, 0.1353], + [0.4830, 0.1873]]) + """ + # Validate sampling settings + variables = self._validate_sampling(n, mode, variables) + + # Separate range and fixed variables + range_vars = [v for v in variables if v in self._range] + fixed_vars = [v for v in variables if v in self._fixed] + + # If there are no range variables, return fixed variables only + if not range_vars: + vals = [torch.full((n, 1), self._fixed[v]) for v in fixed_vars] + result = torch.cat(vals, dim=1) + result = result.as_subclass(LabelTensor) + result.labels = fixed_vars + return result + + # Sample points + pts = self._sample_range(n, range_vars) + labels = range_vars + + # Add fixed vars + if fixed_vars: + fixed_vals = [ + torch.full((pts.shape[0], 1), self._fixed[v]) + for v in fixed_vars + ] + pts = torch.cat([pts] + fixed_vals, dim=1) + labels = range_vars + fixed_vars + + # Prepare output + pts = pts.as_subclass(LabelTensor) + pts.labels = labels + + return pts[sorted(pts.labels)] + + def _sample_range(self, n, variables): + """ + Sample points and rescale to fit within the specified bounds. + + :param int n: The number of points to sample. + :param list[str] variables: variables whose samples must be rescaled. + :return: The rescaled sample points. + :rtype: torch.Tensor + """ + # Extract the dimension + dim = len(variables) + + # Extract centers and axes of the variables to sample + centers = self._centers[variables] + axes = self._axes[variables] + + # Find random directions on the unit sphere + pts = torch.randn(size=(n, dim)) + norm = torch.linalg.vector_norm(pts, dim=1, keepdim=True) + direction = pts / norm.clamp_min(1e-12) + + # Radius is set to one if sampling on the surface + if self._sample_surface: + radius = torch.ones((n, 1)) + + # Otherwise, scale radius to lie within the sphere. Important: exponent + # 1/dim is used to avoid shrinkage of the ellipsoid in higher dims. + else: + radius = torch.rand((n, 1)).pow(1.0 / dim) + + # Rescale the points to lie within the ellipsoid + pts = direction * radius * axes + centers + + return pts + + def partial(self): + """ + Return the boundary of the domain as a new domain object. + + :return: The boundary of the domain. + :rtype: EllipsoidDomain + """ + boundary = deepcopy(self) + boundary.sample_surface = True + + return boundary + + @property + def sample_surface(self): + """ + Whether only the surface of the ellipsoid is considered part of the + domain. + + :return: ``True`` if only the surface is considered part of the domain, + ``False`` otherwise. + :rtype: bool + """ + return self._sample_surface + + @sample_surface.setter + def sample_surface(self, value): + """ + Setter for the sample_surface property. + + :param bool value: The new value for the sample_surface property. + :raises ValueError: If ``value`` is not a boolean. + """ + check_consistency(value, bool) + self._sample_surface = value diff --git a/pina/domain/exclusion.py b/pina/domain/exclusion.py new file mode 100644 index 000000000..59205f3a8 --- /dev/null +++ b/pina/domain/exclusion.py @@ -0,0 +1,144 @@ +"""Module for the Exclusion set-operation.""" + +import random +from .base_operation import BaseOperation +from ..label_tensor import LabelTensor +from ..utils import check_consistency + + +class Exclusion(BaseOperation): + r""" + Implementation of the exclusion operation defined on a list of domains. + + Given multiple sets :math:`A_1, A_2, \ldots, A_n`, define their exclusion + as: + + .. math:: + + \bigcup_{i=1}^{n} \big(A_i \setminus \bigcup_{j \neq i} A_j \big) + + In other words, the exclusion operation returns the set of points that + belong to exactly one of the input sets. + + In case of two sets, the exclusion corresponds to the symmetric difference. + + No check is performed to ensure that the resulting domain is non-empty. + + :Example: + + >>> cartesian1 = CartesianDomain({'x': [0, 1], 'y': [0, 1]}) + >>> cartesian2 = CartesianDomain({'x': [0, 1], 'y': [0.5, 1.5]}) + >>> exclusion = Exclusion([cartesian1, cartesian2]) + """ + + def is_inside(self, point, check_border=False): + """ + Check if a point is inside the exclusion of the domains. + + :param LabelTensor point: The point to check. + :param bool check_border: If ``True``, the boundary is considered inside + the domain. Default is ``False``. + :raises ValueError: If ``point`` is not a :class:`LabelTensor`. + :raises ValueError: If the labels of ``point`` differ from the variables + of the domain. + :return: Whether the point is inside the domain or not. + :rtype: bool + """ + # Checks on point + check_consistency(point, LabelTensor) + if set(self.variables) != set(point.labels): + raise ValueError( + "Point labels differ from domain's dictionary labels. " + f"Got {sorted(point.labels)}, expected {self.variables}." + ) + + # Check if the point belongs to any of the geometries + inside_flags = [ + g.is_inside(point, check_border) for g in self.geometries + ] + + return sum(inside_flags) == 1 + + def sample(self, n, mode="random", variables="all"): + """ + The sampling routine. + + .. note:: + + This sampling method relies on rejection sampling. Points are drawn + from the individual geometries, and only those that lie exclusively + within one geometry are kept. When the exclusion domain is small + relative to the combined area of the input domains, the method may + become highly inefficient. + + :param int n: The number of samples to generate. + :param str mode: The sampling method. Default is ``random``. + :param variables: The list of variables to sample. If ``all``, all + variables are sampled. Default is ``all``. + :type variables: list[str] | str + :raises AssertionError: If ``n`` is not a positive integer. + :raises ValueError: If the sampling mode is invalid. + :raises ValueError: If ``variables`` is neither ``all``, a string, nor a + list/tuple of strings. + :raises ValueError: If any of the specified variables is unknown. + :return: The sampled points. + :rtype: LabelTensor + """ + # Validate sampling settings + variables = self._validate_sampling(n, mode, variables) + + # Compute number of points per geometry and remainder + num_pts, remainder = divmod(n, len(self.geometries)) + + # Shuffle indices + shuffled_geometries = random.sample( + range(len(self.geometries)), len(self.geometries) + ) + + # Precompute per-geometry allocations following the shuffled order + alloc = [num_pts + (i < remainder) for i in range(len(self.geometries))] + samples = [] + + # Iterate over geometries in shuffled order + for idx, gi in enumerate(shuffled_geometries): + + # If no points to allocate (possible if len(self.geometries) > n) + if alloc[idx] == 0: + continue + + # Sampled points for the current geometry + sampled_points = [] + + # Sample until we have enough points + while len(sampled_points) < alloc[idx]: + + # Sample a sufficiently large number of points + batch_size = 2 * (alloc[idx] - len(sampled_points)) + pts = self.geometries[gi].sample(batch_size, mode) + + # Filter points inside the intersection + for p in pts: + p = p.reshape(1, -1) + p.labels = pts.labels + if self.is_inside(p): + sampled_points.append(p[variables]) + if len(sampled_points) >= alloc[idx]: + break + + # Sample points + samples.append(LabelTensor.cat(sampled_points, dim=0)) + + return LabelTensor.cat(samples, dim=0) + + def partial(self): + """ + Return the boundary of the domain resulting from the operation. + + :raises NotImplementedError: The :meth:`partial` method is not + implemented for exclusion domains. Please operate on the individual + domains instead. + """ + raise NotImplementedError( + "The partial method is not implemented for exclusion domains. " + "Please operate on the individual domains instead." + ) diff --git a/pina/domain/exclusion_domain.py b/pina/domain/exclusion_domain.py deleted file mode 100644 index 4a61e415d..000000000 --- a/pina/domain/exclusion_domain.py +++ /dev/null @@ -1,115 +0,0 @@ -"""Module for the Exclusion Operation.""" - -import random -import torch -from ..label_tensor import LabelTensor -from .operation_interface import OperationInterface - - -class Exclusion(OperationInterface): - r""" - Implementation of the exclusion operation between of a list of domains. - - Given two sets :math:`A` and :math:`B`, define the exclusion of the two - sets as: - - .. math:: - A \setminus B = \{x \mid x \in A \land x \in B \land - x \not\in(A \lor B)\}, - - where :math:`x` is a point in :math:`\mathbb{R}^N`. - """ - - def __init__(self, geometries): - """ - Initialization of the :class:`Exclusion` class. - - :param list[DomainInterface] geometries: A list of instances of the - :class:`~pina.domain.domain_interface.DomainInterface` class on - which the exclusion operation is performed. - - :Example: - >>> # Create two ellipsoid domains - >>> ellipsoid1 = EllipsoidDomain({'x': [-1, 1], 'y': [-1, 1]}) - >>> ellipsoid2 = EllipsoidDomain({'x': [0, 2], 'y': [0, 2]}) - >>> # Define the exclusion between the domains - >>> exclusion = Exclusion([ellipsoid1, ellipsoid2]) - """ - super().__init__(geometries) - - def is_inside(self, point, check_border=False): - """ - Check if a point is inside the resulting domain. - - :param LabelTensor point: Point to be checked. - :param bool check_border: If ``True``, the border is considered inside - the domain. Default is ``False``. - :return: ``True`` if the point is inside the domain, - ``False`` otherwise. - :rtype: bool - """ - flag = 0 - for geometry in self.geometries: - if geometry.is_inside(point, check_border): - flag += 1 - return flag == 1 - - def sample(self, n, mode="random", variables="all"): - """ - Sampling routine. - - :param int n: Number of points to sample. - :param str mode: Sampling method. Default is ``random``. - Available modes: random sampling, ``random``; - :param list[str] variables: variables to be sampled. Default is ``all``. - :raises NotImplementedError: If the sampling method is not implemented. - :return: Sampled points. - :rtype: LabelTensor - - :Example: - >>> # Create two Cartesian domains - >>> cartesian1 = CartesianDomain({'x': [0, 2], 'y': [0, 2]}) - >>> cartesian2 = CartesianDomain({'x': [1, 3], 'y': [1, 3]}) - >>> # Define the exclusion between the domains - >>> Exclusion = Exclusion([cartesian1, cartesian2]) - >>> # Sample - >>> Exclusion.sample(n=5) - LabelTensor([[2.4187, 1.5792], - [2.7456, 2.3868], - [2.3830, 1.7037], - [0.8636, 1.8453], - [0.1978, 0.3526]]) - >>> len(Exclusion.sample(n=5) - 5 - """ - if mode not in self.sample_modes: - raise NotImplementedError( - f"{mode} is not a valid mode for sampling." - ) - - sampled = [] - - # calculate the number of points to sample for each geometry and the - # remainder. - remainder = n % len(self.geometries) - num_points = n // len(self.geometries) - - # sample the points - # NB. geometries as shuffled since if we sample - # multiple times just one point, we would end - # up sampling only from the first geometry. - iter_ = random.sample(self.geometries, len(self.geometries)) - for i, geometry in enumerate(iter_): - sampled_points = [] - # int(i < remainder) is one only if we have a remainder - # different than zero. Notice that len(geometries) is - # always smaller than remaider. - # makes sure point is uniquely inside 1 shape. - while len(sampled_points) < (num_points + int(i < remainder)): - sample = geometry.sample(1, mode, variables) - # if not self.is_inside(sample) --> will be the intersection - if self.is_inside(sample): - sampled_points.append(sample) - sampled += sampled_points - - return LabelTensor(torch.cat(sampled), labels=self.variables) diff --git a/pina/domain/intersection.py b/pina/domain/intersection.py new file mode 100644 index 000000000..105575df1 --- /dev/null +++ b/pina/domain/intersection.py @@ -0,0 +1,134 @@ +"""Module for the Intersection operation.""" + +import random +from .base_operation import BaseOperation +from ..label_tensor import LabelTensor +from ..utils import check_consistency + + +class Intersection(BaseOperation): + r""" + Implementation of the intersection operation defined on a list of domains. + + Given multiple sets :math:`A_1, A_2, \ldots, A_n`, define their intersection + as: + + .. math:: + + \bigcap_{i=1}^{n} A_i = \{x \mid x \in A_i \forall i\} + + No check is performed to ensure that the resulting domain is non-empty. + + :Example: + + >>> cartesian1 = CartesianDomain({'x': [0, 1], 'y': [0, 1]}) + >>> cartesian2 = CartesianDomain({'x': [0, 1], 'y': [0.5, 1.5]}) + >>> intersection = Intersection([cartesian1, cartesian2]) + """ + + def is_inside(self, point, check_border=False): + """ + Check if a point is inside the intersection of the domains. + + :param LabelTensor point: The point to check. + :param bool check_border: If ``True``, the boundary is considered inside + the domain. Default is ``False``. + :raises ValueError: If ``point`` is not a :class:`LabelTensor`. + :raises ValueError: If the labels of ``point`` differ from the variables + of the domain. + :return: Whether the point is inside the domain or not. + :rtype: bool + """ + # Checks on point + check_consistency(point, LabelTensor) + if set(self.variables) != set(point.labels): + raise ValueError( + "Point labels differ from domain's dictionary labels. " + f"Got {sorted(point.labels)}, expected {self.variables}." + ) + + return all(g.is_inside(point, check_border) for g in self.geometries) + + def sample(self, n, mode="random", variables="all"): + """ + The sampling routine. + + .. note:: + + This sampling method relies on rejection sampling. Points are drawn + from the individual geometries, and only those that lie exclusively + within one geometry are kept. When the exclusion domain is small + relative to the combined area of the input domains, the method may + become highly inefficient. + + :param int n: The number of samples to generate. + :param str mode: The sampling method. Default is ``random``. + :param variables: The list of variables to sample. If ``all``, all + variables are sampled. Default is ``all``. + :type variables: list[str] | str + :raises AssertionError: If ``n`` is not a positive integer. + :raises ValueError: If the sampling mode is invalid. + :raises ValueError: If ``variables`` is neither ``all``, a string, nor a + list/tuple of strings. + :raises ValueError: If any of the specified variables is unknown. + :return: The sampled points. + :rtype: LabelTensor + """ + # Validate sampling settings + variables = self._validate_sampling(n, mode, variables) + + # Compute number of points per geometry and remainder + num_pts, remainder = divmod(n, len(self.geometries)) + + # Shuffle indices + shuffled_geometries = random.sample( + range(len(self.geometries)), len(self.geometries) + ) + + # Precompute per-geometry allocations following the shuffled order + alloc = [num_pts + (i < remainder) for i in range(len(self.geometries))] + samples = [] + + # Iterate over geometries in shuffled order + for idx, gi in enumerate(shuffled_geometries): + + # If no points to allocate (possible if len(self.geometries) > n) + if alloc[idx] == 0: + continue + + # Sampled points for the current geometry + sampled_points = [] + + # Sample until we have enough points + while len(sampled_points) < alloc[idx]: + + # Sample a sufficiently large number of points + batch_size = 2 * (alloc[idx] - len(sampled_points)) + pts = self.geometries[gi].sample(batch_size, mode) + + # Filter points inside the intersection + for p in pts: + p = p.reshape(1, -1) + p.labels = pts.labels + if self.is_inside(p): + sampled_points.append(p[variables]) + if len(sampled_points) >= alloc[idx]: + break + + # Sample points + samples.append(LabelTensor.cat(sampled_points, dim=0)) + + return LabelTensor.cat(samples, dim=0) + + def partial(self): + """ + Return the boundary of the domain resulting from the operation. + + :raises NotImplementedError: The :meth:`partial` method is not + implemented for intersection domains. Please operate on the + individual domains instead. + """ + raise NotImplementedError( + "The partial method is not implemented for intersection domains. " + "Please operate on the individual domains instead." + ) diff --git a/pina/domain/intersection_domain.py b/pina/domain/intersection_domain.py deleted file mode 100644 index 0921ff381..000000000 --- a/pina/domain/intersection_domain.py +++ /dev/null @@ -1,113 +0,0 @@ -"""Module for the Intersection Operation.""" - -import random -import torch -from ..label_tensor import LabelTensor -from .operation_interface import OperationInterface - - -class Intersection(OperationInterface): - r""" - Implementation of the intersection operation between of a list of domains. - - Given two sets :math:`A` and :math:`B`, define the intersection of the two - sets as: - - .. math:: - A \cap B = \{x \mid x \in A \land x \in B\}, - - where :math:`x` is a point in :math:`\mathbb{R}^N`. - """ - - def __init__(self, geometries): - """ - Initialization of the :class:`Intersection` class. - - :param list[DomainInterface] geometries: A list of instances of the - :class:`~pina.domain.domain_interface.DomainInterface` class on - which the intersection operation is performed. - - :Example: - >>> # Create two ellipsoid domains - >>> ellipsoid1 = EllipsoidDomain({'x': [-1, 1], 'y': [-1, 1]}) - >>> ellipsoid2 = EllipsoidDomain({'x': [0, 2], 'y': [0, 2]}) - >>> # Define the intersection of the domains - >>> intersection = Intersection([ellipsoid1, ellipsoid2]) - """ - super().__init__(geometries) - - def is_inside(self, point, check_border=False): - """ - Check if a point is inside the resulting domain. - - :param LabelTensor point: Point to be checked. - :param bool check_border: If ``True``, the border is considered inside - the domain. Default is ``False``. - :return: ``True`` if the point is inside the domain, - ``False`` otherwise. - :rtype: bool - """ - flag = 0 - for geometry in self.geometries: - if geometry.is_inside(point, check_border): - flag += 1 - return flag == len(self.geometries) - - def sample(self, n, mode="random", variables="all"): - """ - Sampling routine. - - :param int n: Number of points to sample. - :param str mode: Sampling method. Default is ``random``. - Available modes: random sampling, ``random``; - :param list[str] variables: variables to be sampled. Default is ``all``. - :raises NotImplementedError: If the sampling method is not implemented. - :return: Sampled points. - :rtype: LabelTensor - - :Example: - >>> # Create two Cartesian domains - >>> cartesian1 = CartesianDomain({'x': [0, 2], 'y': [0, 2]}) - >>> cartesian2 = CartesianDomain({'x': [1, 3], 'y': [1, 3]}) - >>> # Define the intersection of the domains - >>> intersection = Intersection([cartesian1, cartesian2]) - >>> # Sample - >>> intersection.sample(n=5) - LabelTensor([[1.7697, 1.8654], - [1.2841, 1.1208], - [1.7289, 1.9843], - [1.3332, 1.2448], - [1.9902, 1.4458]]) - >>> len(intersection.sample(n=5) - 5 - """ - if mode not in self.sample_modes: - raise NotImplementedError( - f"{mode} is not a valid mode for sampling." - ) - - sampled = [] - - # calculate the number of points to sample for each geometry and the - # remainder. - remainder = n % len(self.geometries) - num_points = n // len(self.geometries) - - # sample the points - # NB. geometries as shuffled since if we sample - # multiple times just one point, we would end - # up sampling only from the first geometry. - iter_ = random.sample(self.geometries, len(self.geometries)) - for i, geometry in enumerate(iter_): - sampled_points = [] - # int(i < remainder) is one only if we have a remainder - # different than zero. Notice that len(geometries) is - # always smaller than remaider. - # makes sure point is uniquely inside 1 shape. - while len(sampled_points) < (num_points + int(i < remainder)): - sample = geometry.sample(1, mode, variables) - if self.is_inside(sample): - sampled_points.append(sample) - sampled += sampled_points - - return LabelTensor(torch.cat(sampled), labels=self.variables) diff --git a/pina/domain/operation_interface.py b/pina/domain/operation_interface.py index 8cce9698a..9be458972 100644 --- a/pina/domain/operation_interface.py +++ b/pina/domain/operation_interface.py @@ -2,89 +2,29 @@ from abc import ABCMeta, abstractmethod from .domain_interface import DomainInterface -from ..utils import check_consistency class OperationInterface(DomainInterface, metaclass=ABCMeta): """ - Abstract class for set operations defined on geometric domains. + Abstract interface for all set operations defined on geometric domains. """ - def __init__(self, geometries): - """ - Initialization of the :class:`OperationInterface` class. - - :param list[DomainInterface] geometries: A list of instances of the - :class:`~pina.domain.domain_interface.DomainInterface` class on - which the set operation is performed. - """ - # check consistency geometries - check_consistency(geometries, DomainInterface) - - # check we are passing always different - # geometries with the same labels. - self._check_dimensions(geometries) - - # assign geometries - self._geometries = geometries - - @property - def sample_modes(self): - """ - List of available sampling modes. - - :return: List of available sampling modes. - :rtype: list[str] - """ - return ["random"] - @property + @abstractmethod def geometries(self): """ - The domains on which to perform the set operation. - - :return: The domains on which to perform the set operation. - :rtype: list[DomainInterface] - """ - return self._geometries - - @property - def variables(self): - """ - List of variables of the domain. + The list of domains on which to perform the set operation. - :return: List of variables of the domain. - :rtype: list[str] + :return: The list of domains on which to perform the set operation. + :rtype: list[BaseDomain] """ - variables = [] - for geom in self.geometries: - variables += geom.variables - return sorted(list(set(variables))) + @geometries.setter @abstractmethod - def is_inside(self, point, check_border=False): - """ - Abstract method to check if a point lies inside the resulting domain - after performing the set operation. - - :param LabelTensor point: Point to be checked. - :param bool check_border: If ``True``, the border is considered inside - the resulting domain. Default is ``False``. - :return: ``True`` if the point is inside the domain, - ``False`` otherwise. - :rtype: bool - """ - - def _check_dimensions(self, geometries): + def geometries(self, values): """ - Check if the dimensions of the geometries are consistent. + Setter for the ``geometries`` property. - :param list[DomainInterface] geometries: Domains to be checked. - :raises NotImplementedError: If the dimensions of the geometries are not - consistent. + :param values: The geometries to be set. + :type values: list[BaseDomain] | tuple[BaseDomain] """ - for geometry in geometries: - if geometry.variables != geometries[0].variables: - raise NotImplementedError( - "The geometries need to have same dimensions and labels." - ) diff --git a/pina/domain/simplex.py b/pina/domain/simplex.py deleted file mode 100644 index cc496daee..000000000 --- a/pina/domain/simplex.py +++ /dev/null @@ -1,258 +0,0 @@ -"""Module for the Simplex Domain.""" - -import torch -from .domain_interface import DomainInterface -from .cartesian import CartesianDomain -from ..label_tensor import LabelTensor -from ..utils import check_consistency - - -class SimplexDomain(DomainInterface): - """ - Implementation of the simplex domain. - """ - - def __init__(self, simplex_matrix, sample_surface=False): - """ - Initialization of the :class:`SimplexDomain` class. - - :param list[LabelTensor] simplex_matrix: A matrix representing the - vertices of the simplex. - :param bool sample_surface: A flag to choose the sampling strategy. - If ``True``, samples are taken only from the surface of the simplex. - If ``False``, samples are taken from the interior of the simplex. - Default is ``False``. - :raises ValueError: If the labels of the vertices don't match. - :raises ValueError: If the number of vertices is not equal to the - dimension of the simplex plus one. - - .. warning:: - Sampling for dimensions greater or equal to 10 could result in a - shrinkage of the simplex, which degrades the quality of the samples. - For dimensions higher than 10, use other sampling algorithms. - - :Example: - >>> spatial_domain = SimplexDomain( - [ - LabelTensor(torch.tensor([[0, 0]]), labels=["x", "y"]), - LabelTensor(torch.tensor([[1, 1]]), labels=["x", "y"]), - LabelTensor(torch.tensor([[0, 2]]), labels=["x", "y"]), - ], sample_surface = True - ) - """ - - # check consistency of sample_surface as bool - check_consistency(sample_surface, bool) - self._sample_surface = sample_surface - - # check consistency of simplex_matrix as list or tuple - check_consistency([simplex_matrix], (list, tuple)) - - # check everything within simplex_matrix is a LabelTensor - check_consistency(simplex_matrix, LabelTensor) - - # check consistency of labels - matrix_labels = simplex_matrix[0].labels - if not all(vertex.labels == matrix_labels for vertex in simplex_matrix): - raise ValueError("Labels don't match.") - - # check consistency dimensions - dim_simplex = len(matrix_labels) - if len(simplex_matrix) != dim_simplex + 1: - raise ValueError( - "An n-dimensional simplex is composed by n + 1 tensors of " - "dimension n." - ) - - # creating vertices matrix - self._vertices_matrix = LabelTensor.vstack(simplex_matrix) - - # creating basis vectors for simplex - vert = self._vertices_matrix - self._vectors_shifted = (vert[:-1] - vert[-1]).T - - # build cartesian_bound - self._cartesian_bound = self._build_cartesian(self._vertices_matrix) - - @property - def sample_modes(self): - """ - List of available sampling modes. - - :return: List of available sampling modes. - :rtype: list[str] - """ - return ["random"] - - @property - def variables(self): - """ - List of variables of the domain. - - :return: List of variables of the domain. - :rtype: list[str] - """ - return sorted(self._vertices_matrix.labels) - - def _build_cartesian(self, vertices): - """ - Build the cartesian border for a simplex domain to be used in sampling. - - :param list[LabelTensor] vertices: list of vertices defining the domain. - :return: The cartesian border for the simplex domain. - :rtype: CartesianDomain - """ - - span_dict = {} - for coord in self.variables: - sorted_vertices = torch.sort(vertices[coord].tensor.squeeze()) - # respective coord bounded by the lowest and highest values - span_dict[coord] = [ - float(sorted_vertices.values[0]), - float(sorted_vertices.values[-1]), - ] - - return CartesianDomain(span_dict) - - def is_inside(self, point, check_border=False): - """ - Check if a point is inside the simplex. It uses an algorithm involving - barycentric coordinates. - - :param LabelTensor point: Point to be checked. - :param check_border: If ``True``, the border is considered inside - the simplex. Default is ``False``. - :raises ValueError: If the labels of the point are different from those - passed in the ``__init__`` method. - :return: ``True`` if the point is inside the domain, - ``False`` otherwise. - :rtype: bool - """ - - if not all(label in self.variables for label in point.labels): - raise ValueError( - "Point labels different from constructor" - f" dictionary labels. Got {point.labels}," - f" expected {self.variables}." - ) - - point_shift = point - self._vertices_matrix[-1] - point_shift = point_shift.tensor.reshape(-1, 1) - - # compute barycentric coordinates - lambda_ = torch.linalg.solve( - self._vectors_shifted * 1.0, point_shift * 1.0 - ) - lambda_1 = 1.0 - torch.sum(lambda_) - lambdas = torch.vstack([lambda_, lambda_1]) - - # perform checks - if not check_border: - return all(torch.gt(lambdas, 0.0)) and all(torch.lt(lambdas, 1.0)) - - return all(torch.ge(lambdas, 0)) and ( - any(torch.eq(lambdas, 0)) or any(torch.eq(lambdas, 1)) - ) - - def _sample_interior_randomly(self, n, variables): - """ - Sample at random points from the interior of the simplex. Boundaries are - excluded from this sampling routine. - - :param int n: Number of points to sample. - :param list[str] variables: variables to be sampled. - :return: Sampled points. - :rtype: list[torch.Tensor] - """ - - # =============== For Developers ================ # - # - # The sampling startegy used is fairly simple. - # First we sample a random vector from the hypercube - # which contains the simplex. Then, if the point - # sampled is inside the simplex, we add it as a valid - # one. - # - # =============================================== # - - sampled_points = [] - while len(sampled_points) < n: - sampled_point = self._cartesian_bound.sample( - n=1, mode="random", variables=variables - ) - - if self.is_inside(sampled_point, self._sample_surface): - sampled_points.append(sampled_point) - return torch.cat(sampled_points, dim=0) - - def _sample_boundary_randomly(self, n): - """ - Sample at random points from the boundary of the simplex. - - :param int n: Number of points to sample. - :return: Sampled points. - :rtype: torch.Tensor - """ - - # =============== For Developers ================ # - # - # The sampling startegy used is fairly simple. - # We first sample the lambdas in [0, 1] domain, - # we then set to zero only one lambda, and normalize. - # Finally, we compute the matrix product between the - # lamdas and the vertices matrix. - # - # =============================================== # - - sampled_points = [] - - while len(sampled_points) < n: - # extract number of vertices - number_of_vertices = self._vertices_matrix.shape[0] - # extract idx lambda to set to zero randomly - idx_lambda = torch.randint( - low=0, high=number_of_vertices, size=(1,) - ) - # build lambda vector - # 1. sampling [1, 2) - lambdas = torch.rand((number_of_vertices, 1)) - # 2. setting lambdas[idx_lambda] to 0 - lambdas[idx_lambda] = 0 - # 3. normalize - lambdas /= lambdas.sum() - # 4. compute dot product - sampled_points.append(self._vertices_matrix.T @ lambdas) - return torch.cat(sampled_points, dim=1).T - - def sample(self, n, mode="random", variables="all"): - """ - Sampling routine. - - :param int n: Number of points to sample. - :param str mode: Sampling method. Default is ``random``. - Available modes: random sampling, ``random``. - :param list[str] variables: variables to be sampled. Default is ``all``. - :raises NotImplementedError: If the sampling method is not implemented. - :return: Sampled points. - :rtype: LabelTensor - - .. warning:: - When ``sample_surface=True``, all variables are sampled, - ignoring the ``variables`` parameter. - """ - - if variables == "all": - variables = self.variables - elif isinstance(variables, (list, tuple)): - variables = sorted(variables) - - if mode in self.sample_modes: - if self._sample_surface: - sample_pts = self._sample_boundary_randomly(n) - else: - sample_pts = self._sample_interior_randomly(n, variables) - - else: - raise NotImplementedError(f"mode={mode} is not implemented.") - - return LabelTensor(sample_pts, labels=self.variables) diff --git a/pina/domain/simplex_domain.py b/pina/domain/simplex_domain.py new file mode 100644 index 000000000..9e3a3e58f --- /dev/null +++ b/pina/domain/simplex_domain.py @@ -0,0 +1,303 @@ +"""Module for the Simplex Domain.""" + +from copy import deepcopy +import torch +from .base_domain import BaseDomain +from ..label_tensor import LabelTensor +from ..utils import check_consistency + + +class SimplexDomain(BaseDomain): + """ + Implementation of the simplex domain. + + :Example: + + >>> simplex_domain = SimplexDomain( + [ + LabelTensor(torch.tensor([[0, 0]]), labels=["x", "y"]), + LabelTensor(torch.tensor([[1, 1]]), labels=["x", "y"]), + LabelTensor(torch.tensor([[0, 1]]), labels=["x", "y"]), + ] + ) + """ + + def __init__(self, simplex_matrix, sample_surface=False): + """ + Initialization of the :class:`SimplexDomain` class. + + :param simplex_matrix: The matrix of the simplex vertices. + :type simplex_matrix: list[LabelTensor] | tuple[LabelTensor] + :param bool sample_surface: If ``True``, only the surface of the simplex + is considered part of the domain. Default is ``False``. + :raises ValueError: If any element of ``simplex_matrix`` is not a + :class:`LabelTensor`. + :raises TypeError: If ``simplex_matrix`` is not a list or tuple. + :raises ValueError: If ``sample_surface`` is not a boolean. + :raises ValueError: If the labels of the vertices do not match. + :raises ValueError: If the number of vertices is not equal to the + dimension of the simplex plus one. + """ + super().__init__() + + # Initialization + self._sample_modes = ("random",) + self.sample_surface = sample_surface + self.vert_matrix = simplex_matrix + + def is_inside(self, point, check_border=False): + """ + Check if a point is inside the simplex. + + :param LabelTensor point: The point to check. + :param bool check_border: If ``True``, the boundary is considered inside + the domain. Default is ``False``. + :raises ValueError: If ``point`` is not a :class:`LabelTensor`. + :raises ValueError: If the labels of ``point`` differ from the variables + of the domain. + :return: Whether the point is inside the domain or not. + :rtype: bool + """ + # Checks on point + check_consistency(point, LabelTensor) + if set(self.variables) != set(point.labels): + raise ValueError( + "Point labels differ from constructor vertices labels. " + f"Got {sorted(point.labels)}, expected {self.variables}." + ) + + # Shift the point by the last vertex + shift_point = point[self.variables] - self._vert_matrix[-1] + shift_point = shift_point.tensor.reshape(-1, 1) + + # Shift the vertices by the last vertex + shift_vert = (self._vert_matrix[:-1] - self._vert_matrix[-1]).T + + # Compute barycentric coordinates + coords = torch.linalg.solve(shift_vert, shift_point) + last_coord = 1.0 - torch.sum(coords) + coords = torch.vstack([coords, last_coord]) + + # If check_border is False -- use tolerance for numerical errors + if not check_border: + return torch.all(coords > 1e-6) & torch.all(coords < 1 - 1e-6) + + return torch.all(coords >= -1e-6) & torch.all(coords <= 1 + 1e-6) + + def update(self, domain): + """ + Update the current domain by substituting the simplex vertices with + those contained in ``domain``. Only domains of the same type can be used + for update. + + :param SimplexDomain domain: The domain whose vertices are to be set + into the current one. + :raises TypeError: If the domain is not a :class:`SimplexDomain` object. + :return: A new domain instance with the merged labels. + :rtype: SimplexDomain + """ + # Raise an error if the domain types do not match + if not isinstance(domain, type(self)): + raise TypeError( + f"Cannot update domain of type {type(self)} " + f"with domain of type {type(domain)}." + ) + + # Compute new vertex matrix + vert_matrix = [] + for v in domain.vert_matrix: + vert = v.reshape(1, -1) + vert.labels = domain.variables + vert_matrix.append(vert) + + # Replace geometry + updated = deepcopy(self) + updated.vert_matrix = vert_matrix + + return updated + + def sample(self, n, mode="random", variables="all"): + """ + Sampling routine. + + :param int n: The number of samples to generate. + :param str mode: The sampling method. Available modes: ``random`` for + random sampling. Default is ``random``. + :param variables: The list of variables to sample. If ``all``, all + variables are sampled. Default is ``all``. + :type variables: list[str] | str + :raises AssertionError: If ``n`` is not a positive integer. + :raises ValueError: If the sampling mode is invalid. + :raises ValueError: If ``variables`` is neither ``all``, a string, nor a + list/tuple of strings. + :raises ValueError: If any of the specified variables is unknown. + :return: The sampled points. + :rtype: LabelTensor + + :Example: + >>> simplex_domain = SimplexDomain( + [ + LabelTensor(torch.tensor([[0, 0]]), labels=["x", "y"]), + LabelTensor(torch.tensor([[1, 1]]), labels=["x", "y"]), + LabelTensor(torch.tensor([[0, 1]]), labels=["x", "y"]), + ] + ) + >>> simplex_domain.sample(n=5) + LabelTensor([[0.0125, 0.0439], + [0.1346, 0.1950], + [0.8811, 0.9939], + [0.2722, 0.5535], + [0.4750, 0.7433]]) + """ + # Validate sampling settings + variables = self._validate_sampling(n, mode, variables) + + # Extract vertex matrix for the requested variables + vert_matrix = self._vert_matrix[variables].tensor + + # Sample barycentric coordinates using the Dirichlet distribution over + # the simplex. This can be efficiently done by using samples obtained + # via: -log(U(0,1)) ~ Exp(1) ~ Gamma(1, 1) ~ Dirichlet(1, ..., 1). + coords = -torch.rand((n, vert_matrix.shape[0])).clamp_min(1e-12).log() + + # If only the surface is to be sampled + if self._sample_surface: + + # Pick one face of the simplex at random for each point and set the + # corresponding barycentric coordinate to zero. + face_idx = torch.randint(0, vert_matrix.shape[0], (n,)) + coords.scatter_(1, face_idx.view(-1, 1), 0.0) + + # Normalize the coords + coords = coords / coords.sum(dim=1, keepdim=True).clamp_min(1e-12) + + # Prepare output + pts = (coords @ vert_matrix).as_subclass(LabelTensor) + pts.labels = variables + + return pts[sorted(pts.labels)] + + def partial(self): + """ + Return the boundary of the domain as a new domain object. + + :return: The boundary of the domain. + :rtype: SimplexDomain + """ + boundary = deepcopy(self) + boundary.sample_surface = True + + return boundary + + @property + def variables(self): + """ + The list of variables of the domain. + + :return: The list of variables of the domain. + :rtype: list[str] + """ + return sorted(self._vert_matrix.labels) + + @property + def domain_dict(self): + """ + The dictionary representing the domain. For the simplex domain, the keys + are of the form 'v0', 'v1', ..., 'vn', where each key corresponds to a + vertex of the simplex. + + :return: The dictionary representing the domain. + :rtype: dict + """ + return { + f"v{i}": self._vert_matrix[i] + for i in range(self._vert_matrix.shape[0]) + } + + @property + def range(self): + """ + Return an empty dictionary since the simplex domain does not have range + variables. Implemented to comply with the :class:`BaseDomain` interface. + + :return: The range variables of the domain. + :rtype: dict + """ + return {} + + @property + def fixed(self): + """ + Return an empty dictionary since the simplex domain does not have fixed + variables. Implemented to comply with the :class:`BaseDomain` interface. + + :return: The fixed variables of the domain. + :rtype: dict + """ + return {} + + @property + def sample_surface(self): + """ + Whether only the surface of the simplex is considered part of the + domain. + + :return: ``True`` if only the surface is considered part of the domain, + ``False`` otherwise. + :rtype: bool + """ + return self._sample_surface + + @sample_surface.setter + def sample_surface(self, value): + """ + Setter for the sample_surface property. + + :param bool value: The new value for the sample_surface property. + :raises ValueError: If ``value`` is not a boolean. + """ + check_consistency(value, bool) + self._sample_surface = value + + @property + def vert_matrix(self): + """ + The vertex matrix of the simplex. + + :return: The vertex matrix. + :rtype: LabelTensor + """ + return self._vert_matrix + + @vert_matrix.setter + def vert_matrix(self, value): + """ + Setter for the vertex matrix. + + :param LabelTensor value: The new vertex matrix. + :raises ValueError: If any element of ``value`` is not a + :class:`LabelTensor`. + :raises TypeError: If ``value`` is not a list or tuple. + :raises ValueError: If the labels of the vertices do not match. + :raises ValueError: If the number of vertices is not equal to the + dimension of the simplex plus one. + """ + # Check consistency + check_consistency(value, LabelTensor) + if not isinstance(value, (list, tuple)): + raise TypeError( + "The simplex matrix must be a list or tuple of LabelTensor." + ) + + # Check that all labels match + matrix_labels = value[0].labels + if not all(vert.labels == matrix_labels for vert in value): + raise ValueError("Labels of all vertices must match.") + + # Check dimensionality + if len(value) != len(matrix_labels) + 1: + raise ValueError( + "An n-dimensional simplex needs n+1 vertices in R^n." + ) + + self._vert_matrix = LabelTensor.vstack(value).to(torch.float32) diff --git a/pina/domain/union.py b/pina/domain/union.py new file mode 100644 index 000000000..df094bb82 --- /dev/null +++ b/pina/domain/union.py @@ -0,0 +1,105 @@ +"""Module for the Union operation.""" + +import random +from .base_operation import BaseOperation +from ..label_tensor import LabelTensor +from ..utils import check_consistency + + +class Union(BaseOperation): + r""" + Implementation of the union operation defined on a list of domains. + + Given multiple sets :math:`A_1, A_2, \ldots, A_n`, define their union as: + + .. math:: + + \bigcup_{i=1}^{n} A_i = \{x \mid \exists i: x \in A_i \} + + :Example: + + >>> cartesian1 = CartesianDomain({'x': [0, 1], 'y': [0, 1]}) + >>> cartesian2 = CartesianDomain({'x': [0, 1], 'y': [1, 2]}) + >>> union = Union([cartesian1, cartesian2]) + """ + + def is_inside(self, point, check_border=False): + """ + Check if a point is inside the union of the domains. + + :param LabelTensor point: The point to check. + :param bool check_border: If ``True``, the boundary is considered inside + the domain. Default is ``False``. + :raises ValueError: If ``point`` is not a :class:`LabelTensor`. + :raises ValueError: If the labels of ``point`` differ from the variables + of the domain. + :return: Whether the point is inside the domain or not. + :rtype: bool + """ + # Checks on point + check_consistency(point, LabelTensor) + if set(self.variables) != set(point.labels): + raise ValueError( + "Point labels differ from domain's dictionary labels. " + f"Got {sorted(point.labels)}, expected {self.variables}." + ) + + return any(g.is_inside(point, check_border) for g in self.geometries) + + def sample(self, n, mode="random", variables="all"): + """ + The sampling routine. + + :param int n: The number of samples to generate. + :param str mode: The sampling method. Default is ``random``. + :param variables: The list of variables to sample. If ``all``, all + variables are sampled. Default is ``all``. + :type variables: list[str] | str + :raises AssertionError: If ``n`` is not a positive integer. + :raises ValueError: If the sampling mode is invalid. + :raises ValueError: If ``variables`` is neither ``all``, a string, nor a + list/tuple of strings. + :raises ValueError: If any of the specified variables is unknown. + :return: The sampled points. + :rtype: LabelTensor + """ + # Validate sampling settings + variables = self._validate_sampling(n, mode, variables) + + # Compute number of points per geometry and remainder + num_pts, remainder = divmod(n, len(self.geometries)) + + # Shuffle indices + shuffled_geometries = random.sample( + range(len(self.geometries)), len(self.geometries) + ) + + # Precompute per-geometry allocations following the shuffled order + alloc = [num_pts + (i < remainder) for i in range(len(self.geometries))] + samples = [] + + # Iterate over geometries in shuffled order + for idx, gi in enumerate(shuffled_geometries): + + # If no points to allocate (possible if len(self.geometries) > n) + if alloc[idx] == 0: + continue + + # Sample points + pts = self.geometries[gi].sample(alloc[idx], mode, variables) + samples.append(pts) + + return LabelTensor.cat(samples, dim=0) + + def partial(self): + """ + Return the boundary of the domain resulting from the operation. + + :raises NotImplementedError: The :meth:`partial` method is not + implemented for union domains. Please operate on the individual + domains instead. + """ + raise NotImplementedError( + "The partial method is not implemented for union domains. " + "Please operate on the individual domains instead." + ) diff --git a/pina/domain/union_domain.py b/pina/domain/union_domain.py deleted file mode 100644 index 5c3e96f3f..000000000 --- a/pina/domain/union_domain.py +++ /dev/null @@ -1,116 +0,0 @@ -"""Module for the Union Operation.""" - -import random -import torch -from .operation_interface import OperationInterface -from ..label_tensor import LabelTensor - - -class Union(OperationInterface): - r""" - Implementation of the union operation between of a list of domains. - - Given two sets :math:`A` and :math:`B`, define the union of the two sets as: - - .. math:: - A \cup B = \{x \mid x \in A \lor x \in B\}, - - where :math:`x` is a point in :math:`\mathbb{R}^N`. - """ - - def __init__(self, geometries): - """ - Initialization of the :class:`Union` class. - - :param list[DomainInterface] geometries: A list of instances of the - :class:`~pina.domain.domain_interface.DomainInterface` class on - which the union operation is performed. - - :Example: - >>> # Create two ellipsoid domains - >>> ellipsoid1 = EllipsoidDomain({'x': [-1, 1], 'y': [-1, 1]}) - >>> ellipsoid2 = EllipsoidDomain({'x': [0, 2], 'y': [0, 2]}) - >>> # Define the union of the domains - >>> union = Union([ellipsoid1, ellipsoid2]) - """ - super().__init__(geometries) - - @property - def sample_modes(self): - """ - List of available sampling modes. - """ - self.sample_modes = list( - set(geom.sample_modes for geom in self.geometries) - ) - - def is_inside(self, point, check_border=False): - """ - Check if a point is inside the resulting domain. - - :param LabelTensor point: Point to be checked. - :param bool check_border: If ``True``, the border is considered inside - the domain. Default is ``False``. - :return: ``True`` if the point is inside the domain, - ``False`` otherwise. - :rtype: bool - """ - for geometry in self.geometries: - if geometry.is_inside(point, check_border): - return True - return False - - def sample(self, n, mode="random", variables="all"): - """ - Sampling routine. - - :param int n: Number of points to sample. - :param str mode: Sampling method. Default is ``random``. - Available modes: random sampling, ``random``; - :param list[str] variables: variables to be sampled. Default is ``all``. - :return: Sampled points. - :rtype: LabelTensor - - :Example: - >>> # Create two cartesian domains - >>> cartesian1 = CartesianDomain({'x': [0, 2], 'y': [0, 2]}) - >>> cartesian2 = CartesianDomain({'x': [1, 3], 'y': [1, 3]}) - >>> # Define the union of the domains - >>> union = Union([cartesian1, cartesian2]) - >>> # Sample - >>> union.sample(n=5) - LabelTensor([[1.2128, 2.1991], - [1.3530, 2.4317], - [2.2562, 1.6605], - [0.8451, 1.9878], - [1.8623, 0.7102]]) - >>> len(union.sample(n=5) - 5 - """ - sampled_points = [] - - # calculate the number of points to sample for each geometry and the - # remainder - remainder = n % len(self.geometries) - num_points = n // len(self.geometries) - - # sample the points - # NB. geometries as shuffled since if we sample - # multiple times just one point, we would end - # up sampling only from the first geometry. - iter_ = random.sample(self.geometries, len(self.geometries)) - for i, geometry in enumerate(iter_): - # int(i < remainder) is one only if we have a remainder - # different than zero. Notice that len(geometries) is - # always smaller than remaider. - sampled_points.append( - geometry.sample( - num_points + int(i < remainder), mode, variables - ) - ) - # in case number of sampled points is smaller than the number of - # geometries - if len(sampled_points) >= n: - break - - return LabelTensor(torch.cat(sampled_points), labels=self.variables) diff --git a/pina/problem/abstract_problem.py b/pina/problem/abstract_problem.py index 057a62683..4923b63c1 100644 --- a/pina/problem/abstract_problem.py +++ b/pina/problem/abstract_problem.py @@ -4,7 +4,7 @@ import warnings from copy import deepcopy from ..utils import check_consistency -from ..domain import DomainInterface, CartesianDomain +from ..domain import DomainInterface, CartesianDomain, OperationInterface from ..condition.domain_equation_condition import DomainEquationCondition from ..label_tensor import LabelTensor from ..utils import merge_tensors, custom_warning_format @@ -288,10 +288,13 @@ def _apply_custom_discretization(self, sample_rules, domains): "the input variables." ) for domain in domains: - if not isinstance(self.domains[domain], CartesianDomain): + if not isinstance( + self.domains[domain], (CartesianDomain, OperationInterface) + ): raise RuntimeError( "Custom discretisation can be applied only on Cartesian " - "domains" + "domains and domains resulting from operations between " + "Cartesian domains." ) discretised_tensor = [] for var, rules in sample_rules.items(): diff --git a/pina/problem/inverse_problem.py b/pina/problem/inverse_problem.py index 231d01441..8a2902448 100644 --- a/pina/problem/inverse_problem.py +++ b/pina/problem/inverse_problem.py @@ -19,7 +19,7 @@ def __init__(self): # storing unknown_parameters for optimization self.unknown_parameters = {} for var in self.unknown_variables: - range_var = self.unknown_parameter_domain.range_[var] + range_var = self.unknown_parameter_domain._range[var] tensor_var = ( torch.rand(1, requires_grad=True) * range_var[1] + range_var[0] ) diff --git a/pina/solver/solver.py b/pina/solver/solver.py index 442574224..148152d47 100644 --- a/pina/solver/solver.py +++ b/pina/solver/solver.py @@ -257,8 +257,8 @@ def _clamp_inverse_problem_params(self): """ for v in self._params: self._params[v].data.clamp_( - self.problem.unknown_parameter_domain.range_[v][0], - self.problem.unknown_parameter_domain.range_[v][1], + self.problem.unknown_parameter_domain.range[v][0], + self.problem.unknown_parameter_domain.range[v][1], ) @staticmethod diff --git a/tests/test_domain/test_cartesian.py b/tests/test_domain/test_cartesian.py deleted file mode 100644 index 1de06431c..000000000 --- a/tests/test_domain/test_cartesian.py +++ /dev/null @@ -1,35 +0,0 @@ -import torch - -from pina import LabelTensor -from pina.domain import CartesianDomain - - -def test_constructor(): - CartesianDomain({"x": [0, 1], "y": [0, 1]}) - - -def test_is_inside_check_border(): - pt_1 = LabelTensor(torch.tensor([[0.5, 0.5]]), ["x", "y"]) - pt_2 = LabelTensor(torch.tensor([[1.0, 0.5]]), ["x", "y"]) - pt_3 = LabelTensor(torch.tensor([[1.5, 0.5]]), ["x", "y"]) - domain = CartesianDomain({"x": [0, 1], "y": [0, 1]}) - for pt, exp_result in zip([pt_1, pt_2, pt_3], [True, True, False]): - assert domain.is_inside(pt, check_border=True) == exp_result - - -def test_is_inside_not_check_border(): - pt_1 = LabelTensor(torch.tensor([[0.5, 0.5]]), ["x", "y"]) - pt_2 = LabelTensor(torch.tensor([[1.0, 0.5]]), ["x", "y"]) - pt_3 = LabelTensor(torch.tensor([[1.5, 0.5]]), ["x", "y"]) - domain = CartesianDomain({"x": [0, 1], "y": [0, 1]}) - for pt, exp_result in zip([pt_1, pt_2, pt_3], [True, False, False]): - assert domain.is_inside(pt, check_border=False) == exp_result - - -def test_is_inside_fixed_variables(): - pt_1 = LabelTensor(torch.tensor([[0.5, 0.5]]), ["x", "y"]) - pt_2 = LabelTensor(torch.tensor([[1.0, 0.5]]), ["x", "y"]) - pt_3 = LabelTensor(torch.tensor([[1.0, 1.5]]), ["x", "y"]) - domain = CartesianDomain({"x": 1, "y": [0, 1]}) - for pt, exp_result in zip([pt_1, pt_2, pt_3], [False, True, False]): - assert domain.is_inside(pt, check_border=False) == exp_result diff --git a/tests/test_domain/test_cartesian_domain.py b/tests/test_domain/test_cartesian_domain.py new file mode 100644 index 000000000..db9297ced --- /dev/null +++ b/tests/test_domain/test_cartesian_domain.py @@ -0,0 +1,163 @@ +import torch +import pytest +from pina import LabelTensor +from pina.domain import CartesianDomain, Union + +__dicts = [ + {"x": [0, 1], "y": [2.0, 3.5], "z": [0, 1.5]}, + {"x": [0, 1], "y": [2.0, 3.5], "z": 1.5}, + {"x": [0, 1], "y": 2.75, "z": 0.25}, + {"x": 0.0, "y": 2.5, "z": 1.0}, + {"x": (0, 1), "y": (0.0, 1.0)}, + {"x": (0, 1), "y": 0.5}, + {"x": 0.0, "y": 2.5}, + {"x": 0.0}, +] + + +@pytest.mark.parametrize("dict", __dicts) +def test_constructor(dict): + CartesianDomain(dict) + + # Should fail if the cartesian dictionary is not a dictionary + with pytest.raises(TypeError): + CartesianDomain([("x", [0, 1]), ("y", [0, 1])]) + + # Should fail if the cartesian dictionary is empty + with pytest.raises(ValueError): + CartesianDomain({}) + + # Should fail if the value for a key is not numeric + with pytest.raises(ValueError): + CartesianDomain({"x": ["a", "b"]}) + + # Should fail if the value for a key is a list of lenght != 2 + with pytest.raises(ValueError): + CartesianDomain({"x": [0, 1, 2]}) + + # Should fail if the range is invalid + with pytest.raises(ValueError): + CartesianDomain({"x": [1, 0]}) + + +@pytest.mark.parametrize("check_border", [True, False]) +def test_is_inside(check_border): + + # Define points + pt_in = LabelTensor(torch.tensor([[0.5, 0.5]]), ["x", "y"]) + pt_out = LabelTensor(torch.tensor([[1.5, 0.5]]), ["x", "y"]) + pt_border = LabelTensor(torch.tensor([[1.0, 0.5]]), ["x", "y"]) + + # Define test domains + domain_1 = CartesianDomain(__dicts[4]) + domain_2 = CartesianDomain(__dicts[5]) + + # Expected results + truth_1 = [True, False, True] if check_border else [True, False, False] + truth_2 = [True, False, True] if check_border else [True, False, False] + + # Checks + for pt, exp_1, exp_2 in zip([pt_in, pt_out, pt_border], truth_1, truth_2): + assert domain_1.is_inside(pt, check_border=check_border) == exp_1 + assert domain_2.is_inside(pt, check_border=check_border) == exp_2 + + # Should fail if point is not a LabelTensor + with pytest.raises(ValueError): + domain_1.is_inside(torch.Tensor([0.5, 0.5]), check_border=check_border) + + # Should fail if the labels of the point differ from the domain + with pytest.raises(ValueError): + pt = LabelTensor(torch.Tensor([0.5, 0.5]), ["a", "b"]) + domain_1.is_inside(pt, check_border=check_border) + + +@pytest.mark.parametrize("dict", __dicts) +def test_update(dict): + + # Define the domains + domain_1 = CartesianDomain(dict) + domain_2 = CartesianDomain({"new_var": [0, 1]}) + domain_3 = CartesianDomain(dict | {"new_var": [0, 1]}) + + # Update domain_1 with domain_2 + updated_domain = domain_1.update(domain_2) + + # Check that domain_1 is now equal to domain_3 + assert updated_domain._fixed == domain_3._fixed + assert updated_domain._range == domain_3._range + + # Should fail if trying to update with a different domain type (Union) + with pytest.raises(TypeError): + cartesian_domain = CartesianDomain({"x": [0, 1], "y": [0, 1]}) + other_domain = Union([cartesian_domain]) + updated_domain = cartesian_domain.update(other_domain) + + +@pytest.mark.parametrize("mode", ["grid", "random", "lh", "chebyshev"]) +@pytest.mark.parametrize("variables", ["all", "x", ["x"]]) +@pytest.mark.parametrize("dicts", __dicts) +def test_sample(mode, variables, dicts): + + # Sample from the domain + num_samples = 5 + domain = CartesianDomain(dicts) + pts = domain.sample(num_samples, mode=mode, variables=variables) + + # Labels and number of samples + labels = sorted(variables if variables != "all" else domain.variables) + if mode in ["grid", "chebyshev"]: + num_range_vars = len([k for k in labels if k in domain._range]) + num_samples = num_samples ** (num_range_vars or 1) + + # Checks + assert pts.shape == (num_samples, len(labels)) + assert pts.labels == labels + + # Should fail if n is not a positive integer + with pytest.raises(AssertionError): + domain.sample(0, mode=mode, variables=variables) + + # Should fail if the mode is not recognized + with pytest.raises(ValueError): + domain.sample(1, mode="invalid_mode", variables=variables) + + # Should fail if the variables are invalid + with pytest.raises(ValueError): + domain.sample(1, mode=mode, variables=123) + + # Should fail if the variables are unknown + with pytest.raises(ValueError): + domain.sample(1, mode=mode, variables=["invalid_var"]) + + +@pytest.mark.parametrize("dicts", __dicts) +def test_partial(dicts): + + # Define the domain and get the boundary + cartesian_domain = CartesianDomain(dicts) + boundary = cartesian_domain.partial() + faces = boundary.geometries + + # Checks + assert isinstance(boundary, Union) + assert len(faces) == 2 * len(cartesian_domain._range) + assert all(isinstance(f, CartesianDomain) for f in faces) + + # Iterate over the faces + for face in faces: + + # Each face should differ from the original domain by exactly 1 variable + diff_keys = [ + k + for k in face.variables + if cartesian_domain.domain_dict[k] != face.domain_dict[k] + ] + + # Check that only one variable differs + assert len(diff_keys) == 1 + + # Check that the differing variable is fixed to one of the bounds + assert ( + face.domain_dict[diff_keys[0]] + in cartesian_domain._range[diff_keys[0]] + ) diff --git a/tests/test_domain/test_difference.py b/tests/test_domain/test_difference.py index 5e45836db..aba26dd78 100644 --- a/tests/test_domain/test_difference.py +++ b/tests/test_domain/test_difference.py @@ -1,76 +1,178 @@ import torch - +import pytest from pina import LabelTensor -from pina.domain import Difference, EllipsoidDomain, CartesianDomain - - -def test_constructor_two_CartesianDomains(): - Difference( - [ - CartesianDomain({"x": [0, 2], "y": [0, 2]}), - CartesianDomain({"x": [1, 3], "y": [1, 3]}), - ] - ) - - -def test_constructor_two_3DCartesianDomain(): - Difference( - [ - CartesianDomain({"x": [0, 2], "y": [0, 2], "z": [0, 2]}), - CartesianDomain({"x": [1, 3], "y": [1, 3], "z": [1, 3]}), - ] - ) - - -def test_constructor_three_CartesianDomains(): - Difference( - [ - CartesianDomain({"x": [0, 2], "y": [0, 2]}), - CartesianDomain({"x": [1, 3], "y": [1, 3]}), - CartesianDomain({"x": [2, 4], "y": [2, 4]}), - ] - ) - - -def test_is_inside_two_CartesianDomains(): - pt_1 = LabelTensor(torch.tensor([[0.5, 0.5]]), ["x", "y"]) - pt_2 = LabelTensor(torch.tensor([[-1, -0.5]]), ["x", "y"]) - domain = Difference( - [ - CartesianDomain({"x": [0, 2], "y": [0, 2]}), - CartesianDomain({"x": [1, 3], "y": [1, 3]}), - ] - ) - assert domain.is_inside(pt_1) == True - assert domain.is_inside(pt_2) == False - - -def test_is_inside_two_3DCartesianDomain(): - pt_1 = LabelTensor(torch.tensor([[0.5, 0.5, 0.5]]), ["x", "y", "z"]) - pt_2 = LabelTensor(torch.tensor([[-1, -0.5, -0.5]]), ["x", "y", "z"]) - domain = Difference( - [ - CartesianDomain({"x": [0, 2], "y": [0, 2], "z": [0, 2]}), - CartesianDomain({"x": [1, 3], "y": [1, 3], "z": [1, 3]}), - ] - ) - assert domain.is_inside(pt_1) == True - assert domain.is_inside(pt_2) == False - - -def test_sample(): - n = 100 - domain = Difference( - [ - EllipsoidDomain({"x": [-1, 1], "y": [-1, 1]}), - CartesianDomain({"x": [-0.5, 0.5], "y": [-0.5, 0.5]}), - ] - ) - pts = domain.sample(n) - assert isinstance(pts, LabelTensor) - assert pts.shape[0] == n - - n = 105 - pts = domain.sample(n) - assert isinstance(pts, LabelTensor) - assert pts.shape[0] == n +from pina.domain import ( + Difference, + EllipsoidDomain, + CartesianDomain, + SimplexDomain, +) + +# Define the domains for testing +cartesian_1 = CartesianDomain({"x": [0, 2], "y": [0, 2]}) +cartesian_2 = CartesianDomain({"x": [0, 2], "y": [0, 2], "z": [0, 2]}) + +ellipsoid_1 = EllipsoidDomain({"x": [-1, 1], "y": [-1, 1]}) +ellipsoid_2 = EllipsoidDomain({"x": [0, 1], "y": [-1, 1], "z": [1, 3]}) + +simplex_1 = SimplexDomain( + [ + LabelTensor(torch.tensor([[0, 0]]), labels=["x", "y"]), + LabelTensor(torch.tensor([[1, 0]]), labels=["x", "y"]), + LabelTensor(torch.tensor([[0, 1]]), labels=["x", "y"]), + ] +) +simplex_2 = SimplexDomain( + [ + LabelTensor(torch.tensor([[0, 0, 0]]), labels=["x", "y", "z"]), + LabelTensor(torch.tensor([[2, 0, 0]]), labels=["x", "y", "z"]), + LabelTensor(torch.tensor([[0, 2, 0]]), labels=["x", "y", "z"]), + LabelTensor(torch.tensor([[0, 0, 2]]), labels=["x", "y", "z"]), + ] +) + +# Define the geometries +__geometries = [ + [cartesian_1, ellipsoid_1], + [cartesian_2, ellipsoid_2], + [cartesian_1, simplex_1], + [cartesian_2, simplex_2], + [ellipsoid_1, simplex_1], + [ellipsoid_2, simplex_2], + [cartesian_1, ellipsoid_1, simplex_1], + [cartesian_2, ellipsoid_2, simplex_2], +] + + +@pytest.mark.parametrize("geometries", __geometries) +def test_constructor(geometries): + Difference(geometries) + + # Should fail if geometries is not a list or a tuple + with pytest.raises(TypeError): + Difference({cartesian_1, ellipsoid_1}) + + # Should fail if the elements of geometries are not BaseDomain instances + with pytest.raises(ValueError): + Difference([{"x": [0, 1], "y": [0, 1]}, {"x": [1, 2], "y": [0, 1]}]) + + # Should fail if the dimensions of the geometries are not consistent + with pytest.raises(NotImplementedError): + Difference([cartesian_1, cartesian_2]) + + +@pytest.mark.parametrize("check_border", [True, False]) +def test_is_inside(check_border): + + # Define points + pt_in = LabelTensor(torch.tensor([[1, 1]]), ["x", "y"]) + pt_out = LabelTensor(torch.tensor([[0, 0]]), ["x", "y"]) + pt_border = LabelTensor(torch.tensor([[0.6, 0.8]]), ["x", "y"]) + + # Difference + difference = Difference(__geometries[0]) + + # Expected results + truth = [True, False, False] if check_border else [True, False, True] + + # Checks + for pt, exp in zip([pt_in, pt_out, pt_border], truth): + assert difference.is_inside(pt, check_border=check_border) == exp + + # Should fail if point is not a LabelTensor + with pytest.raises(ValueError): + difference.is_inside( + torch.Tensor([0.5, 0.5]), check_border=check_border + ) + + # Should fail if the labels of the point differ from the domain + with pytest.raises(ValueError): + pt = LabelTensor(torch.Tensor([0.5, 0.5]), ["a", "b"]) + difference.is_inside(pt, check_border=check_border) + + +@pytest.mark.parametrize("domain_class", [CartesianDomain, EllipsoidDomain]) +def test_update(domain_class): + + # Define the difference + domain_1 = domain_class({"x": [0, 1], "y": [0, 1]}) + domain_2 = domain_class({"x": [0.5, 1.5], "y": [0, 2]}) + difference = Difference([domain_1, domain_2]) + + # Update the difference with another valid domain + domain_3 = domain_class({"t": [0, 1], "w": 0}) + updated_difference = difference.update(domain_3) + + # Check that the difference has been updated correctly + assert len(updated_difference.geometries) == 2 + assert updated_difference.variables == sorted(["x", "y", "t", "w"]) + for i, g in enumerate(updated_difference.geometries): + assert g._range == { + **difference.geometries[i]._range, + **domain_3._range, + } + assert g._fixed == { + **difference.geometries[i]._fixed, + **domain_3._fixed, + } + + # Should fail if trying to update the difference of different geometry types + with pytest.raises(NotImplementedError): + difference = Difference(__geometries[0]) + difference.update(simplex_1) + + # Should fail if trying to update with a different domain type + with pytest.raises(TypeError): + difference = Difference( + CartesianDomain({"x": [0, 1], "y": [0, 1]}), + CartesianDomain({"x": [1, 2], "y": [0, 1]}), + ) + other_domain = EllipsoidDomain({"x": [-1, 1], "y": [-1, 1]}) + difference.update(other_domain) + + +def test_partial(): + with pytest.raises(NotImplementedError): + difference = Difference(__geometries[0]) + difference.partial() + + +@pytest.mark.parametrize("variables", ["all", "x", ["x"]]) +@pytest.mark.parametrize("geometries", __geometries) +def test_sample(variables, geometries): + + # Define the domain + num_samples = 5 + domain = Difference(geometries) + + # Iterate over modes (dependent on the domain types) + for mode in domain.sample_modes: + + # Sample from the domain + pts = domain.sample(num_samples, mode=mode, variables=variables) + + # Labels and number of samples + labels = sorted(variables if variables != "all" else domain.variables) + if mode in ["grid", "chebyshev"]: + num_range_vars = len([k for k in labels if k in domain._range]) + num_samples = num_samples ** (num_range_vars or 1) + + # Checks + assert pts.shape == (num_samples, len(labels)) + assert pts.labels == labels + + # Should fail if n is not a positive integer + with pytest.raises(AssertionError): + domain.sample(0, mode=mode, variables=variables) + + # Should fail if the mode is not recognized + with pytest.raises(ValueError): + domain.sample(1, mode="invalid_mode", variables=variables) + + # Should fail if the variables are invalid + with pytest.raises(ValueError): + domain.sample(1, mode=mode, variables=123) + + # Should fail if the variables are unknown + with pytest.raises(ValueError): + domain.sample(1, mode=mode, variables=["invalid_var"]) diff --git a/tests/test_domain/test_ellipsoid.py b/tests/test_domain/test_ellipsoid.py deleted file mode 100644 index 203010799..000000000 --- a/tests/test_domain/test_ellipsoid.py +++ /dev/null @@ -1,30 +0,0 @@ -import torch -import pytest - -from pina import LabelTensor -from pina.domain import EllipsoidDomain - - -def test_constructor(): - EllipsoidDomain({"x": [0, 1], "y": [0, 1]}) - EllipsoidDomain({"x": [0, 1], "y": [0, 1]}, sample_surface=True) - - -def test_is_inside_sample_surface_false(): - domain = EllipsoidDomain({"x": [0, 1], "y": [0, 1]}, sample_surface=False) - pt_1 = LabelTensor(torch.tensor([[0.5, 0.5]]), ["x", "y"]) - pt_2 = LabelTensor(torch.tensor([[1.0, 0.5]]), ["x", "y"]) - pt_3 = LabelTensor(torch.tensor([[1.5, 0.5]]), ["x", "y"]) - for pt, exp_result in zip([pt_1, pt_2, pt_3], [True, False, False]): - assert domain.is_inside(pt) == exp_result - for pt, exp_result in zip([pt_1, pt_2, pt_3], [True, True, False]): - assert domain.is_inside(pt, check_border=True) == exp_result - - -def test_is_inside_sample_surface_true(): - domain = EllipsoidDomain({"x": [0, 1], "y": [0, 1]}, sample_surface=True) - pt_1 = LabelTensor(torch.tensor([[0.5, 0.5]]), ["x", "y"]) - pt_2 = LabelTensor(torch.tensor([[1.0, 0.5]]), ["x", "y"]) - pt_3 = LabelTensor(torch.tensor([[1.5, 0.5]]), ["x", "y"]) - for pt, exp_result in zip([pt_1, pt_2, pt_3], [False, True, False]): - assert domain.is_inside(pt) == exp_result diff --git a/tests/test_domain/test_ellipsoid_domain.py b/tests/test_domain/test_ellipsoid_domain.py new file mode 100644 index 000000000..ced0f9dd0 --- /dev/null +++ b/tests/test_domain/test_ellipsoid_domain.py @@ -0,0 +1,161 @@ +import torch +import pytest +from pina import LabelTensor +from pina.domain import EllipsoidDomain, Union + +__dicts = [ + {"x": [0, 1], "y": [2.0, 3.5], "z": [0, 1.5]}, + {"x": [0, 1], "y": [2.0, 3.5], "z": 1.5}, + {"x": [0, 1], "y": 2.75, "z": 0.25}, + {"x": 0.0, "y": 2.5, "z": 1.0}, + {"x": (0, 1), "y": (0.0, 1.0)}, + {"x": (0, 1), "y": 0.0}, + {"x": 0.0, "y": 2.5}, + {"x": 0.0}, +] + + +@pytest.mark.parametrize("dict", __dicts) +@pytest.mark.parametrize("sample_surface", [True, False]) +def test_constructor(dict, sample_surface): + EllipsoidDomain(ellipsoid_dict=dict, sample_surface=sample_surface) + + # Should fail if sample_surface is not a boolean + with pytest.raises(ValueError): + EllipsoidDomain(ellipsoid_dict=dict, sample_surface="invalid_value") + + # Should fail if the ellipsoid dictionary is not a dictionary + with pytest.raises(TypeError): + EllipsoidDomain( + ellipsoid_dict=[("x", [0, 1]), ("y", [0, 1])], + sample_surface=sample_surface, + ) + + # Should fail if the ellipsoid dictionary is empty + with pytest.raises(ValueError): + EllipsoidDomain(ellipsoid_dict={}, sample_surface=sample_surface) + + # Should fail if the value for a key is not numeric + with pytest.raises(ValueError): + EllipsoidDomain( + ellipsoid_dict={"x": ["a", "b"]}, sample_surface=sample_surface + ) + + # Should fail if the value for a key is a list of lenght != 2 + with pytest.raises(ValueError): + EllipsoidDomain( + ellipsoid_dict={"x": [0, 1, 2]}, sample_surface=sample_surface + ) + + # Should fail if the range is invalid + with pytest.raises(ValueError): + EllipsoidDomain( + ellipsoid_dict={"x": [1, 0]}, sample_surface=sample_surface + ) + + +@pytest.mark.parametrize("check_border", [True, False]) +def test_is_inside(check_border): + + # Define points + pt_in = LabelTensor(torch.tensor([[0.5, 0.5]]), ["x", "y"]) + pt_out = LabelTensor(torch.tensor([[1.5, 0.5]]), ["x", "y"]) + pt_border = LabelTensor(torch.tensor([[1.0, 0.5]]), ["x", "y"]) + + # Define test domains + domain = EllipsoidDomain(ellipsoid_dict=__dicts[4]) + + # Expected results + truth = [True, False, True] if check_border else [True, False, False] + + # Checks + for pt, exp in zip([pt_in, pt_out, pt_border], truth): + assert domain.is_inside(pt, check_border=check_border) == exp + + # Should fail if point is not a LabelTensor + with pytest.raises(ValueError): + domain.is_inside(torch.Tensor([0.5, 0.5]), check_border=check_border) + + # Should fail if the labels of the point differ from the domain + with pytest.raises(ValueError): + pt = LabelTensor(torch.Tensor([0.5, 0.5]), ["a", "b"]) + domain.is_inside(pt, check_border=check_border) + + +@pytest.mark.parametrize("dict", __dicts) +@pytest.mark.parametrize("sample_surface", [True, False]) +def test_update(dict, sample_surface): + + # Define the domains + domain_1 = EllipsoidDomain( + ellipsoid_dict=dict, sample_surface=sample_surface + ) + domain_2 = EllipsoidDomain( + ellipsoid_dict={"new_var": [0, 1]}, sample_surface=sample_surface + ) + domain_3 = EllipsoidDomain( + ellipsoid_dict=dict | {"new_var": [0, 1]}, sample_surface=sample_surface + ) + + # Update domain_1 with domain_2 + updated_domain = domain_1.update(domain_2) + + # Check that domain_1 is now equal to domain_3 + assert updated_domain._fixed == domain_3._fixed + assert updated_domain._range == domain_3._range + + # Should fail if trying to update with a different domain type (Union) + with pytest.raises(TypeError): + ellipsoid_domain = EllipsoidDomain({"x": [0, 1], "y": [0, 1]}) + other_domain = Union([ellipsoid_domain]) + updated_domain = ellipsoid_domain.update(other_domain) + + +@pytest.mark.parametrize("mode", ["random"]) +@pytest.mark.parametrize("variables", ["all", "x", ["x"]]) +@pytest.mark.parametrize("dicts", __dicts) +@pytest.mark.parametrize("sample_surface", [True, False]) +def test_sample(mode, variables, dicts, sample_surface): + + # Sample from the domain and check that the points are inside + num_samples = 5 + domain = EllipsoidDomain(dicts, sample_surface=sample_surface) + pts = domain.sample(num_samples, mode=mode, variables=variables) + + # Labels + labels = sorted(variables if variables != "all" else domain.variables) + + # Checks + assert pts.shape == (num_samples, len(labels)) + assert pts.labels == labels + + # Should fail if n is not a positive integer + with pytest.raises(AssertionError): + domain.sample(0, mode=mode, variables=variables) + + # Should fail if the mode is not recognized + with pytest.raises(ValueError): + domain.sample(1, mode="invalid_mode", variables=variables) + + # Should fail if the variables are invalid + with pytest.raises(ValueError): + domain.sample(1, mode=mode, variables=123) + + # Should fail if the variables are unknown + with pytest.raises(ValueError): + domain.sample(1, mode=mode, variables=["invalid_var"]) + + +@pytest.mark.parametrize("dicts", __dicts) +@pytest.mark.parametrize("sample_surface", [True, False]) +def test_partial(dicts, sample_surface): + + # Define the domain and get the boundary + ellipsoid_domain = EllipsoidDomain(dicts, sample_surface=sample_surface) + boundary = ellipsoid_domain.partial() + + # Checks + assert isinstance(boundary, EllipsoidDomain) + assert boundary._fixed == ellipsoid_domain._fixed + assert boundary._range == ellipsoid_domain._range + assert boundary._sample_surface == True diff --git a/tests/test_domain/test_exclusion.py b/tests/test_domain/test_exclusion.py index 95ada2c9d..13b3b8d0e 100644 --- a/tests/test_domain/test_exclusion.py +++ b/tests/test_domain/test_exclusion.py @@ -1,76 +1,170 @@ import torch - +import pytest from pina import LabelTensor -from pina.domain import Exclusion, EllipsoidDomain, CartesianDomain - - -def test_constructor_two_CartesianDomains(): - Exclusion( - [ - CartesianDomain({"x": [0, 2], "y": [0, 2]}), - CartesianDomain({"x": [1, 3], "y": [1, 3]}), - ] - ) - - -def test_constructor_two_3DCartesianDomain(): - Exclusion( - [ - CartesianDomain({"x": [0, 2], "y": [0, 2], "z": [0, 2]}), - CartesianDomain({"x": [1, 3], "y": [1, 3], "z": [1, 3]}), - ] - ) - - -def test_constructor_three_CartesianDomains(): - Exclusion( - [ - CartesianDomain({"x": [0, 2], "y": [0, 2]}), - CartesianDomain({"x": [1, 3], "y": [1, 3]}), - CartesianDomain({"x": [2, 4], "y": [2, 4]}), - ] - ) - - -def test_is_inside_two_CartesianDomains(): - pt_1 = LabelTensor(torch.tensor([[0.5, 0.5]]), ["x", "y"]) - pt_2 = LabelTensor(torch.tensor([[-1, -0.5]]), ["x", "y"]) - domain = Exclusion( - [ - CartesianDomain({"x": [0, 2], "y": [0, 2]}), - CartesianDomain({"x": [1, 3], "y": [1, 3]}), - ] - ) - assert domain.is_inside(pt_1) == True - assert domain.is_inside(pt_2) == False - - -def test_is_inside_two_3DCartesianDomain(): - pt_1 = LabelTensor(torch.tensor([[0.5, 0.5, 0.5]]), ["x", "y", "z"]) - pt_2 = LabelTensor(torch.tensor([[-1, -0.5, -0.5]]), ["x", "y", "z"]) - domain = Exclusion( - [ - CartesianDomain({"x": [0, 2], "y": [0, 2], "z": [0, 2]}), - CartesianDomain({"x": [1, 3], "y": [1, 3], "z": [1, 3]}), - ] - ) - assert domain.is_inside(pt_1) == True - assert domain.is_inside(pt_2) == False - - -def test_sample(): - n = 100 - domain = Exclusion( - [ - EllipsoidDomain({"x": [-1, 1], "y": [-1, 1]}), - CartesianDomain({"x": [0.3, 1.5], "y": [0.3, 1.5]}), - ] - ) - pts = domain.sample(n) - assert isinstance(pts, LabelTensor) - assert pts.shape[0] == n - - n = 105 - pts = domain.sample(n) - assert isinstance(pts, LabelTensor) - assert pts.shape[0] == n +from pina.domain import ( + Exclusion, + EllipsoidDomain, + CartesianDomain, + SimplexDomain, +) + +# Define the domains for testing +cartesian_1 = CartesianDomain({"x": [0, 2], "y": [0, 2]}) +cartesian_2 = CartesianDomain({"x": [0, 2], "y": [0, 2], "z": [0, 2]}) + +ellipsoid_1 = EllipsoidDomain({"x": [-1, 1], "y": [-1, 1]}) +ellipsoid_2 = EllipsoidDomain({"x": [0, 1], "y": [-1, 1], "z": [1, 3]}) + +simplex_1 = SimplexDomain( + [ + LabelTensor(torch.tensor([[-1, 0]]), labels=["x", "y"]), + LabelTensor(torch.tensor([[1, 0]]), labels=["x", "y"]), + LabelTensor(torch.tensor([[-1, 2]]), labels=["x", "y"]), + ] +) +simplex_2 = SimplexDomain( + [ + LabelTensor(torch.tensor([[-1, 0, 0]]), labels=["x", "y", "z"]), + LabelTensor(torch.tensor([[2, 0, 0]]), labels=["x", "y", "z"]), + LabelTensor(torch.tensor([[-1, 2, 0]]), labels=["x", "y", "z"]), + LabelTensor(torch.tensor([[-1, 0, 2]]), labels=["x", "y", "z"]), + ] +) + +# Define the geometries +__geometries = [ + [cartesian_1, ellipsoid_1], + [cartesian_2, ellipsoid_2], + [cartesian_1, simplex_1], + [cartesian_2, simplex_2], + [ellipsoid_1, simplex_1], + [ellipsoid_2, simplex_2], + [cartesian_1, ellipsoid_1, simplex_1], + [cartesian_2, ellipsoid_2, simplex_2], +] + + +@pytest.mark.parametrize("geometries", __geometries) +def test_constructor(geometries): + Exclusion(geometries) + + # Should fail if geometries is not a list or a tuple + with pytest.raises(TypeError): + Exclusion({cartesian_1, ellipsoid_1}) + + # Should fail if the elements of geometries are not BaseDomain instances + with pytest.raises(ValueError): + Exclusion([{"x": [0, 1], "y": [0, 1]}, {"x": [1, 2], "y": [0, 1]}]) + + # Should fail if the dimensions of the geometries are not consistent + with pytest.raises(NotImplementedError): + Exclusion([cartesian_1, cartesian_2]) + + +@pytest.mark.parametrize("check_border", [True, False]) +def test_is_inside(check_border): + + # Define points + pt_in = LabelTensor(torch.tensor([[-0.6, -0.6]]), ["x", "y"]) + pt_out = LabelTensor(torch.tensor([[0.5, 0.5]]), ["x", "y"]) + pt_border = LabelTensor(torch.tensor([[0, 0]]), ["x", "y"]) + + # Exclusion + exclusion = Exclusion(__geometries[0]) + + # Expected results + truth = [True, False, False] if check_border else [True, False, True] + + # Checks + for pt, exp in zip([pt_in, pt_out, pt_border], truth): + assert exclusion.is_inside(pt, check_border=check_border) == exp + + # Should fail if point is not a LabelTensor + with pytest.raises(ValueError): + exclusion.is_inside(torch.Tensor([0.5, 0.5]), check_border=check_border) + + # Should fail if the labels of the point differ from the domain + with pytest.raises(ValueError): + pt = LabelTensor(torch.Tensor([0.5, 0.5]), ["a", "b"]) + exclusion.is_inside(pt, check_border=check_border) + + +@pytest.mark.parametrize("domain_class", [CartesianDomain, EllipsoidDomain]) +def test_update(domain_class): + + # Define the exclusion + domain_1 = domain_class({"x": [0, 1], "y": [0, 1]}) + domain_2 = domain_class({"x": [0.5, 1.5], "y": [0, 2]}) + exclusion = Exclusion([domain_1, domain_2]) + + # Update the exclusion with another valid domain + domain_3 = domain_class({"t": [0, 1], "w": 0}) + updated_exclusion = exclusion.update(domain_3) + + # Check that the exclusion has been updated correctly + assert len(updated_exclusion.geometries) == 2 + assert updated_exclusion.variables == sorted(["x", "y", "t", "w"]) + for i, g in enumerate(updated_exclusion.geometries): + assert g._range == {**exclusion.geometries[i]._range, **domain_3._range} + assert g._fixed == {**exclusion.geometries[i]._fixed, **domain_3._fixed} + + # Should fail if trying to update the exclusion of different geometry types + with pytest.raises(NotImplementedError): + exclusion = Exclusion(__geometries[0]) + exclusion.update(simplex_1) + + # Should fail if trying to update with a different domain type + with pytest.raises(TypeError): + exclusion = Exclusion( + CartesianDomain({"x": [0, 1], "y": [0, 1]}), + CartesianDomain({"x": [1, 2], "y": [0, 1]}), + ) + other_domain = EllipsoidDomain({"x": [-1, 1], "y": [-1, 1]}) + exclusion.update(other_domain) + + +def test_partial(): + with pytest.raises(NotImplementedError): + exclusion = Exclusion(__geometries[0]) + exclusion.partial() + + +@pytest.mark.parametrize("variables", ["all", "x", ["x"]]) +@pytest.mark.parametrize("geometries", __geometries) +def test_sample(variables, geometries): + + # Define the domain + num_samples = 5 + domain = Exclusion(geometries) + + # Iterate over modes (dependent on the domain types) + for mode in domain.sample_modes: + + # Sample from the domain + pts = domain.sample(num_samples, mode=mode, variables=variables) + + # Labels and number of samples + labels = sorted(variables if variables != "all" else domain.variables) + if mode in ["grid", "chebyshev"]: + num_range_vars = len([k for k in labels if k in domain._range]) + num_samples = num_samples ** (num_range_vars or 1) + + # Checks + assert pts.shape == (num_samples, len(labels)) + assert pts.labels == labels + + # Should fail if n is not a positive integer + with pytest.raises(AssertionError): + domain.sample(0, mode=mode, variables=variables) + + # Should fail if the mode is not recognized + with pytest.raises(ValueError): + domain.sample(1, mode="invalid_mode", variables=variables) + + # Should fail if the variables are invalid + with pytest.raises(ValueError): + domain.sample(1, mode=mode, variables=123) + + # Should fail if the variables are unknown + with pytest.raises(ValueError): + domain.sample(1, mode=mode, variables=["invalid_var"]) diff --git a/tests/test_domain/test_intersection.py b/tests/test_domain/test_intersection.py index fe6921f16..98dcb344e 100644 --- a/tests/test_domain/test_intersection.py +++ b/tests/test_domain/test_intersection.py @@ -1,81 +1,178 @@ import torch - +import pytest from pina import LabelTensor -from pina.domain import Intersection, EllipsoidDomain, CartesianDomain - - -def test_constructor_two_CartesianDomains(): - Intersection( - [ - CartesianDomain({"x": [0, 2], "y": [0, 2]}), - CartesianDomain({"x": [1, 3], "y": [1, 3]}), - ] - ) - - -def test_constructor_two_3DCartesianDomain(): - Intersection( - [ - CartesianDomain({"x": [0, 2], "y": [0, 2], "z": [0, 2]}), - CartesianDomain({"x": [1, 3], "y": [1, 3], "z": [1, 3]}), - ] - ) - - -def test_constructor_three_CartesianDomains(): - Intersection( - [ - CartesianDomain({"x": [0, 2], "y": [0, 2]}), - CartesianDomain({"x": [1, 3], "y": [1, 3]}), - CartesianDomain({"x": [2, 4], "y": [2, 4]}), - ] - ) - - -def test_is_inside_two_CartesianDomains(): - pt_1 = LabelTensor(torch.tensor([[0.5, 0.5]]), ["x", "y"]) - pt_2 = LabelTensor(torch.tensor([[-1, -0.5]]), ["x", "y"]) - pt_3 = LabelTensor(torch.tensor([[1.5, 1.5]]), ["x", "y"]) - - domain = Intersection( - [ - CartesianDomain({"x": [0, 2], "y": [0, 2]}), - CartesianDomain({"x": [1, 3], "y": [1, 3]}), - ] - ) - assert domain.is_inside(pt_1) == False - assert domain.is_inside(pt_2) == False - assert domain.is_inside(pt_3) == True - - -def test_is_inside_two_3DCartesianDomain(): - pt_1 = LabelTensor(torch.tensor([[0.5, 0.5, 0.5]]), ["x", "y", "z"]) - pt_2 = LabelTensor(torch.tensor([[-1, -0.5, -0.5]]), ["x", "y", "z"]) - pt_3 = LabelTensor(torch.tensor([[1.5, 1.5, 1.5]]), ["x", "y", "z"]) - domain = Intersection( - [ - CartesianDomain({"x": [0, 2], "y": [0, 2], "z": [0, 2]}), - CartesianDomain({"x": [1, 3], "y": [1, 3], "z": [1, 3]}), - ] - ) - assert domain.is_inside(pt_1) == False - assert domain.is_inside(pt_2) == False - assert domain.is_inside(pt_3) == True - - -def test_sample(): - n = 100 - domain = Intersection( - [ - EllipsoidDomain({"x": [-1, 1], "y": [-1, 1]}), - CartesianDomain({"x": [-0.5, 0.5], "y": [-0.5, 0.5]}), - ] - ) - pts = domain.sample(n) - assert isinstance(pts, LabelTensor) - assert pts.shape[0] == n - - n = 105 - pts = domain.sample(n) - assert isinstance(pts, LabelTensor) - assert pts.shape[0] == n +from pina.domain import ( + Intersection, + EllipsoidDomain, + CartesianDomain, + SimplexDomain, +) + +# Define the domains for testing +cartesian_1 = CartesianDomain({"x": [0, 2], "y": [0, 2]}) +cartesian_2 = CartesianDomain({"x": [0, 2], "y": [0, 2], "z": [0, 2]}) + +ellipsoid_1 = EllipsoidDomain({"x": [-1, 1], "y": [-1, 1]}) +ellipsoid_2 = EllipsoidDomain({"x": [0, 1], "y": [-1, 1], "z": [1, 3]}) + +simplex_1 = SimplexDomain( + [ + LabelTensor(torch.tensor([[0, 0]]), labels=["x", "y"]), + LabelTensor(torch.tensor([[1, 0]]), labels=["x", "y"]), + LabelTensor(torch.tensor([[0, 1]]), labels=["x", "y"]), + ] +) +simplex_2 = SimplexDomain( + [ + LabelTensor(torch.tensor([[0, 0, 0]]), labels=["x", "y", "z"]), + LabelTensor(torch.tensor([[2, 0, 0]]), labels=["x", "y", "z"]), + LabelTensor(torch.tensor([[0, 2, 0]]), labels=["x", "y", "z"]), + LabelTensor(torch.tensor([[0, 0, 2]]), labels=["x", "y", "z"]), + ] +) + +# Define the geometries +__geometries = [ + [cartesian_1, ellipsoid_1], + [cartesian_2, ellipsoid_2], + [cartesian_1, simplex_1], + [cartesian_2, simplex_2], + [ellipsoid_1, simplex_1], + [ellipsoid_2, simplex_2], + [cartesian_1, ellipsoid_1, simplex_1], + [cartesian_2, ellipsoid_2, simplex_2], +] + + +@pytest.mark.parametrize("geometries", __geometries) +def test_constructor(geometries): + Intersection(geometries) + + # Should fail if geometries is not a list or a tuple + with pytest.raises(TypeError): + Intersection({cartesian_1, ellipsoid_1}) + + # Should fail if the elements of geometries are not BaseDomain instances + with pytest.raises(ValueError): + Intersection([{"x": [0, 1], "y": [0, 1]}, {"x": [1, 2], "y": [0, 1]}]) + + # Should fail if the dimensions of the geometries are not consistent + with pytest.raises(NotImplementedError): + Intersection([cartesian_1, cartesian_2]) + + +@pytest.mark.parametrize("check_border", [True, False]) +def test_is_inside(check_border): + + # Define points + pt_in = LabelTensor(torch.tensor([[0.2, 0.2]]), ["x", "y"]) + pt_out = LabelTensor(torch.tensor([[-0.2, -0.2]]), ["x", "y"]) + pt_border = LabelTensor(torch.tensor([[0, 0]]), ["x", "y"]) + + # Intersection + intersection = Intersection(__geometries[0]) + + # Expected results + truth = [True, False, True] if check_border else [True, False, False] + + # Checks + for pt, exp in zip([pt_in, pt_out, pt_border], truth): + assert intersection.is_inside(pt, check_border=check_border) == exp + + # Should fail if point is not a LabelTensor + with pytest.raises(ValueError): + intersection.is_inside( + torch.Tensor([0.5, 0.5]), check_border=check_border + ) + + # Should fail if the labels of the point differ from the domain + with pytest.raises(ValueError): + pt = LabelTensor(torch.Tensor([0.5, 0.5]), ["a", "b"]) + intersection.is_inside(pt, check_border=check_border) + + +@pytest.mark.parametrize("domain_class", [CartesianDomain, EllipsoidDomain]) +def test_update(domain_class): + + # Define the intersection + domain_1 = domain_class({"x": [0, 1], "y": [0, 1]}) + domain_2 = domain_class({"x": [0.5, 1.5], "y": [0, 2]}) + intersection = Intersection([domain_1, domain_2]) + + # Update the intersection with another valid domain + domain_3 = domain_class({"t": [0, 1], "w": 0}) + updated_intersection = intersection.update(domain_3) + + # Check that the intersection has been updated correctly + assert len(updated_intersection.geometries) == 2 + assert updated_intersection.variables == sorted(["x", "y", "t", "w"]) + for i, g in enumerate(updated_intersection.geometries): + assert g._range == { + **intersection.geometries[i]._range, + **domain_3._range, + } + assert g._fixed == { + **intersection.geometries[i]._fixed, + **domain_3._fixed, + } + + # Should fail if trying to update the intersection of different geometry types + with pytest.raises(NotImplementedError): + intersection = Intersection(__geometries[0]) + intersection.update(simplex_1) + + # Should fail if trying to update with a different domain type + with pytest.raises(TypeError): + intersection = Intersection( + CartesianDomain({"x": [0, 1], "y": [0, 1]}), + CartesianDomain({"x": [1, 2], "y": [0, 1]}), + ) + other_domain = EllipsoidDomain({"x": [-1, 1], "y": [-1, 1]}) + intersection.update(other_domain) + + +def test_partial(): + with pytest.raises(NotImplementedError): + intersection = Intersection(__geometries[0]) + intersection.partial() + + +@pytest.mark.parametrize("variables", ["all", "x", ["x"]]) +@pytest.mark.parametrize("geometries", __geometries) +def test_sample(variables, geometries): + + # Define the domain + num_samples = 5 + domain = Intersection(geometries) + + # Iterate over modes (dependent on the domain types) + for mode in domain.sample_modes: + + # Sample from the domain + pts = domain.sample(num_samples, mode=mode, variables=variables) + + # Labels and number of samples + labels = sorted(variables if variables != "all" else domain.variables) + if mode in ["grid", "chebyshev"]: + num_range_vars = len([k for k in labels if k in domain._range]) + num_samples = num_samples ** (num_range_vars or 1) + + # Checks + assert pts.shape == (num_samples, len(labels)) + assert pts.labels == labels + + # Should fail if n is not a positive integer + with pytest.raises(AssertionError): + domain.sample(0, mode=mode, variables=variables) + + # Should fail if the mode is not recognized + with pytest.raises(ValueError): + domain.sample(1, mode="invalid_mode", variables=variables) + + # Should fail if the variables are invalid + with pytest.raises(ValueError): + domain.sample(1, mode=mode, variables=123) + + # Should fail if the variables are unknown + with pytest.raises(ValueError): + domain.sample(1, mode=mode, variables=["invalid_var"]) diff --git a/tests/test_domain/test_simplex.py b/tests/test_domain/test_simplex.py deleted file mode 100644 index c03e1504e..000000000 --- a/tests/test_domain/test_simplex.py +++ /dev/null @@ -1,184 +0,0 @@ -import torch -import pytest - -from pina import LabelTensor -from pina.domain import SimplexDomain - - -def test_constructor(): - SimplexDomain( - [ - LabelTensor(torch.tensor([[0, 0]]), labels=["x", "y"]), - LabelTensor(torch.tensor([[1, 1]]), labels=["x", "y"]), - LabelTensor(torch.tensor([[0, 2]]), labels=["x", "y"]), - ] - ) - SimplexDomain( - [ - LabelTensor(torch.tensor([[0, 0]]), labels=["x", "y"]), - LabelTensor(torch.tensor([[1, 1]]), labels=["x", "y"]), - LabelTensor(torch.tensor([[0, 2]]), labels=["x", "y"]), - ], - sample_surface=True, - ) - with pytest.raises(ValueError): - # different labels - SimplexDomain( - [ - LabelTensor(torch.tensor([[0, 0]]), labels=["x", "y"]), - LabelTensor(torch.tensor([[1, 1]]), labels=["x", "z"]), - LabelTensor(torch.tensor([[0, 2]]), labels=["x", "a"]), - ] - ) - # not LabelTensor - SimplexDomain( - [ - LabelTensor(torch.tensor([[0, 0]]), labels=["x", "y"]), - [1, 1], - LabelTensor(torch.tensor([[0, 2]]), labels=["x", "y"]), - ] - ) - # different number of vertices - SimplexDomain( - [ - LabelTensor(torch.tensor([[0.0, -2.0]]), labels=["x", "y"]), - LabelTensor(torch.tensor([[-0.5, -0.5]]), labels=["x", "y"]), - LabelTensor(torch.tensor([[-2.0, 0.0]]), labels=["x", "y"]), - LabelTensor(torch.tensor([[-0.5, 0.5]]), labels=["x", "y"]), - ] - ) - - -def test_sample(): - # sampling inside - simplex = SimplexDomain( - [ - LabelTensor(torch.tensor([[0, 0]]), labels=["x", "y"]), - LabelTensor(torch.tensor([[1, 1]]), labels=["x", "y"]), - LabelTensor(torch.tensor([[0, 2]]), labels=["x", "y"]), - ] - ) - pts = simplex.sample(10) - assert isinstance(pts, LabelTensor) - assert pts.size() == torch.Size([10, 2]) - - # sampling border - SimplexDomain( - [ - LabelTensor(torch.tensor([[0, 0]]), labels=["x", "y"]), - LabelTensor(torch.tensor([[1, 1]]), labels=["x", "y"]), - LabelTensor(torch.tensor([[0, 2]]), labels=["x", "y"]), - ], - sample_surface=True, - ) - - pts = simplex.sample(10) - assert isinstance(pts, LabelTensor) - assert pts.size() == torch.Size([10, 2]) - - -def test_is_inside_faulty_point(): - domain = SimplexDomain( - [ - LabelTensor(torch.tensor([[0, 0]]), labels=["x", "y"]), - LabelTensor(torch.tensor([[2, 2]]), labels=["x", "y"]), - LabelTensor(torch.tensor([[4, 0]]), labels=["x", "y"]), - ], - sample_surface=True, - ) - pt = LabelTensor(torch.tensor([[2, 1]]), ["x", "z"]) - with pytest.raises(ValueError): - assert domain.is_inside(point=pt, check_border=False) == True - - -def test_is_inside_2D_check_border_true(): - domain = SimplexDomain( - [ - LabelTensor(torch.tensor([[0, 0]]), labels=["x", "y"]), - LabelTensor(torch.tensor([[2, 2]]), labels=["x", "y"]), - LabelTensor(torch.tensor([[4, 0]]), labels=["x", "y"]), - ], - sample_surface=True, - ) - pt1 = LabelTensor(torch.tensor([[0, 0]]), ["x", "y"]) - pt2 = LabelTensor(torch.tensor([[2, 2]]), ["x", "y"]) - pt3 = LabelTensor(torch.tensor([[4, 0]]), ["x", "y"]) - pt4 = LabelTensor(torch.tensor([[3, 1]]), ["x", "y"]) - pt5 = LabelTensor(torch.tensor([[2, 1]]), ["x", "y"]) - pt6 = LabelTensor(torch.tensor([[100, 100]]), ["x", "y"]) - pts = [pt1, pt2, pt3, pt4, pt5, pt6] - for pt, exp_result in zip(pts, [True, True, True, True, False, False]): - assert domain.is_inside(point=pt, check_border=True) == exp_result - - -def test_is_inside_2D_check_border_false(): - domain = SimplexDomain( - [ - LabelTensor(torch.tensor([[0, 0]]), labels=["x", "y"]), - LabelTensor(torch.tensor([[2, 2]]), labels=["x", "y"]), - LabelTensor(torch.tensor([[4, 0]]), labels=["x", "y"]), - ], - sample_surface=False, - ) - pt1 = LabelTensor(torch.tensor([[0, 0]]), ["x", "y"]) - pt2 = LabelTensor(torch.tensor([[2, 2]]), ["x", "y"]) - pt3 = LabelTensor(torch.tensor([[4, 0]]), ["x", "y"]) - pt4 = LabelTensor(torch.tensor([[3, 1]]), ["x", "y"]) - pt5 = LabelTensor(torch.tensor([[2, 1]]), ["x", "y"]) - pt6 = LabelTensor(torch.tensor([[2.5, 1]]), ["x", "y"]) - pt7 = LabelTensor(torch.tensor([[100, 100]]), ["x", "y"]) - pts = [pt1, pt2, pt3, pt4, pt5, pt6, pt7] - for pt, exp_result in zip( - pts, [False, False, False, False, True, True, False] - ): - assert domain.is_inside(point=pt, check_border=False) == exp_result - - -def test_is_inside_3D_check_border_true(): - domain = SimplexDomain( - [ - LabelTensor(torch.tensor([[0, 0, 0]]), labels=["x", "y", "z"]), - LabelTensor(torch.tensor([[2, 2, 0]]), labels=["x", "y", "z"]), - LabelTensor(torch.tensor([[4, 0, 0]]), labels=["x", "y", "z"]), - LabelTensor(torch.tensor([[0, 0, 20]]), labels=["x", "y", "z"]), - ], - sample_surface=True, - ) - pt1 = LabelTensor(torch.tensor([[0, 0, 0]]), ["x", "y", "z"]) - pt2 = LabelTensor(torch.tensor([[2, 2, 0]]), ["x", "y", "z"]) - pt3 = LabelTensor(torch.tensor([[4, 0, 0]]), ["x", "y", "z"]) - pt4 = LabelTensor(torch.tensor([[3, 1, 0]]), ["x", "y", "z"]) - pt5 = LabelTensor(torch.tensor([[2, 1, 0]]), ["x", "y", "z"]) - pt6 = LabelTensor(torch.tensor([[100, 100, 0]]), ["x", "y", "z"]) - pt7 = LabelTensor(torch.tensor([[0, 0, 19]]), ["x", "y", "z"]) - pt8 = LabelTensor(torch.tensor([[0, 0, 20]]), ["x", "y", "z"]) - pt9 = LabelTensor(torch.tensor([[2, 1, 1]]), ["x", "y", "z"]) - pts = [pt1, pt2, pt3, pt4, pt5, pt6, pt7, pt8, pt9] - for pt, exp_result in zip( - pts, [True, True, True, True, True, False, True, True, False] - ): - assert domain.is_inside(point=pt, check_border=True) == exp_result - - -def test_is_inside_3D_check_border_false(): - domain = SimplexDomain( - [ - LabelTensor(torch.tensor([[0, 0, 0]]), labels=["x", "y", "z"]), - LabelTensor(torch.tensor([[2, 2, 0]]), labels=["x", "y", "z"]), - LabelTensor(torch.tensor([[4, 0, 0]]), labels=["x", "y", "z"]), - LabelTensor(torch.tensor([[0, 0, 20]]), labels=["x", "y", "z"]), - ], - sample_surface=False, - ) - pt1 = LabelTensor(torch.tensor([[0, 0, 0]]), ["x", "y", "z"]) - pt2 = LabelTensor(torch.tensor([[3, 1, 0]]), ["x", "y", "z"]) - pt3 = LabelTensor(torch.tensor([[2, 1, 0]]), ["x", "y", "z"]) - pt4 = LabelTensor(torch.tensor([[100, 100, 0]]), ["x", "y", "z"]) - pt5 = LabelTensor(torch.tensor([[0, 0, 19]]), ["x", "y", "z"]) - pt6 = LabelTensor(torch.tensor([[0, 0, 20]]), ["x", "y", "z"]) - pt7 = LabelTensor(torch.tensor([[2, 1, 1]]), ["x", "y", "z"]) - pts = [pt1, pt2, pt3, pt4, pt5, pt6, pt7] - for pt, exp_result in zip( - pts, [False, False, False, False, False, False, True] - ): - assert domain.is_inside(point=pt, check_border=False) == exp_result diff --git a/tests/test_domain/test_simplex_domain.py b/tests/test_domain/test_simplex_domain.py new file mode 100644 index 000000000..10cf9cb41 --- /dev/null +++ b/tests/test_domain/test_simplex_domain.py @@ -0,0 +1,176 @@ +import torch +import pytest +from pina import LabelTensor +from pina.domain import SimplexDomain, Union + +__matrices = [ + [ + LabelTensor(torch.tensor([[0, 0]]), labels=["x", "y"]), + LabelTensor(torch.tensor([[0, 1]]), labels=["x", "y"]), + LabelTensor(torch.tensor([[1, 0]]), labels=["x", "y"]), + ], + [ + LabelTensor(torch.tensor([[0, 0, 0]]), labels=["x", "y", "z"]), + LabelTensor(torch.tensor([[0, 1, 0]]), labels=["x", "y", "z"]), + LabelTensor(torch.tensor([[1, 0, 0]]), labels=["x", "y", "z"]), + LabelTensor(torch.tensor([[0, 0, 1]]), labels=["x", "y", "z"]), + ], + [ + LabelTensor(torch.tensor([[0, 0, 0, 0]]), labels=["w", "x", "y", "z"]), + LabelTensor(torch.tensor([[1, 0, 0, 0]]), labels=["w", "x", "y", "z"]), + LabelTensor(torch.tensor([[0, 1, 0, 0]]), labels=["w", "x", "y", "z"]), + LabelTensor(torch.tensor([[0, 0, 1, 0]]), labels=["w", "x", "y", "z"]), + LabelTensor(torch.tensor([[0, 0, 0, 1]]), labels=["w", "x", "y", "z"]), + ], +] + + +@pytest.mark.parametrize("matrices", __matrices) +@pytest.mark.parametrize("sample_surface", [True, False]) +def test_constructor(matrices, sample_surface): + SimplexDomain(simplex_matrix=matrices, sample_surface=sample_surface) + + # Should fail if simplex_matrix is not a list or tuple + with pytest.raises(ValueError): + SimplexDomain(simplex_matrix="invalid", sample_surface=sample_surface) + + # Should fail if any element of simplex_matrix is not a LabelTensor + with pytest.raises(ValueError): + invalid_mat = [ + LabelTensor(torch.tensor([[0, 0]]), labels=["x", "y"]), + LabelTensor(torch.tensor([[0, 1]]), labels=["x", "y"]), + torch.tensor([[1, 0]]), + ] + SimplexDomain(simplex_matrix=invalid_mat, sample_surface=sample_surface) + + # Should fail if sample_surface is not a boolean + with pytest.raises(ValueError): + SimplexDomain(simplex_matrix=matrices, sample_surface="invalid_value") + + # Should fail if the labels of the vertices do not match + with pytest.raises(ValueError): + invalid_mat = [ + LabelTensor(torch.tensor([[0, 0]]), labels=["x", "y"]), + LabelTensor(torch.tensor([[0, 1]]), labels=["x", "y"]), + LabelTensor(torch.tensor([[1, 0]]), labels=["a", "b"]), + ] + SimplexDomain(simplex_matrix=invalid_mat, sample_surface=sample_surface) + + # Should fail if the number of vertices is not equal to dimension + 1 + with pytest.raises(ValueError): + invalid_mat = [ + LabelTensor(torch.tensor([[0, 0]]), labels=["x", "y"]), + LabelTensor(torch.tensor([[0, 1]]), labels=["x", "y"]), + LabelTensor(torch.tensor([[1, 0]]), labels=["x", "y"]), + LabelTensor(torch.tensor([[1, 1]]), labels=["x", "y"]), + ] + SimplexDomain(simplex_matrix=invalid_mat, sample_surface=sample_surface) + + +@pytest.mark.parametrize("check_border", [True, False]) +def test_is_inside(check_border): + + # Define points + pt_in = LabelTensor(torch.tensor([[0.2, 0.2]]), ["x", "y"]) + pt_out = LabelTensor(torch.tensor([[1.5, 0.2]]), ["x", "y"]) + pt_border = LabelTensor(torch.tensor([[0.8, 0.2]]), ["x", "y"]) + + # Define test domains + domain = SimplexDomain(simplex_matrix=__matrices[0]) + + # Expected results + truth = [True, False, True] if check_border else [True, False, False] + + # Checks + for pt, exp in zip([pt_in, pt_out, pt_border], truth): + assert domain.is_inside(pt, check_border=check_border) == exp + + # Should fail if point is not a LabelTensor + with pytest.raises(ValueError): + domain.is_inside(torch.Tensor([0.5, 0.5]), check_border=check_border) + + # Should fail if the labels of the point differ from the domain + with pytest.raises(ValueError): + pt = LabelTensor(torch.Tensor([0.5, 0.5]), ["a", "b"]) + domain.is_inside(pt, check_border=check_border) + + +@pytest.mark.parametrize("matrices", __matrices) +@pytest.mark.parametrize("sample_surface", [True, False]) +def test_update(matrices, sample_surface): + + # Define the domains + domain_1 = SimplexDomain( + simplex_matrix=matrices, sample_surface=sample_surface + ) + domain_2 = SimplexDomain( + simplex_matrix=[ + LabelTensor(torch.tensor([[0, 0]]), labels=["x", "y"]), + LabelTensor(torch.tensor([[1, 0]]), labels=["x", "y"]), + LabelTensor(torch.tensor([[0, 1]]), labels=["x", "y"]), + ], + sample_surface=sample_surface, + ) + + # Update domain_1 with domain_2 + updated_domain = domain_1.update(domain_2) + + # Check that domain_1 is now equal to domain_2 + assert updated_domain.variables == domain_2.variables + for v1, v2 in zip(updated_domain._vert_matrix, domain_2._vert_matrix): + assert torch.allclose(v1.tensor, v2.tensor, atol=1e-12, rtol=0) + + # Should fail if trying to update with a different domain type (Union) + with pytest.raises(TypeError): + other_domain = Union([domain_2]) + updated_domain = domain_1.update(other_domain) + + +@pytest.mark.parametrize("mode", ["random"]) +@pytest.mark.parametrize("variables", ["all", "x", ["x"]]) +@pytest.mark.parametrize("matrices", __matrices) +@pytest.mark.parametrize("sample_surface", [True, False]) +def test_sample(mode, variables, matrices, sample_surface): + + # Sample from the domain and check that the points are inside + num_samples = 5 + domain = SimplexDomain(matrices, sample_surface=sample_surface) + pts = domain.sample(num_samples, mode=mode, variables=variables) + + # Labels + labels = sorted(variables if variables != "all" else domain.variables) + + # Checks + assert pts.shape == (num_samples, len(labels)) + assert pts.labels == labels + + # Should fail if n is not a positive integer + with pytest.raises(AssertionError): + domain.sample(0, mode=mode, variables=variables) + + # Should fail if the mode is not recognized + with pytest.raises(ValueError): + domain.sample(1, mode="invalid_mode", variables=variables) + + # Should fail if the variables are invalid + with pytest.raises(ValueError): + domain.sample(1, mode=mode, variables=123) + + # Should fail if the variables are unknown + with pytest.raises(ValueError): + domain.sample(1, mode=mode, variables=["invalid_var"]) + + +@pytest.mark.parametrize("matrices", __matrices) +@pytest.mark.parametrize("sample_surface", [True, False]) +def test_partial(matrices, sample_surface): + + # Define the domain and get the boundary + simplex_domain = SimplexDomain(matrices, sample_surface=sample_surface) + boundary = simplex_domain.partial() + + # Checks + assert isinstance(boundary, SimplexDomain) + assert boundary._sample_surface == True + for v1, v2 in zip(simplex_domain._vert_matrix, boundary._vert_matrix): + assert torch.allclose(v1.tensor, v2.tensor, atol=1e-12, rtol=0) diff --git a/tests/test_domain/test_union.py b/tests/test_domain/test_union.py index a2fd05f86..7dffa3694 100644 --- a/tests/test_domain/test_union.py +++ b/tests/test_domain/test_union.py @@ -1,97 +1,165 @@ import torch - +import pytest from pina import LabelTensor -from pina.domain import Union, EllipsoidDomain, CartesianDomain +from pina.domain import Union, EllipsoidDomain, CartesianDomain, SimplexDomain + +# Define the domains for testing +cartesian_1 = CartesianDomain({"x": [0, 2], "y": [0, 2]}) +cartesian_2 = CartesianDomain({"x": [0, 2], "y": [0, 2], "z": [0, 2]}) + +ellipsoid_1 = EllipsoidDomain({"x": [-1, 1], "y": [-1, 1]}) +ellipsoid_2 = EllipsoidDomain({"x": [0, 1], "y": [-1, 1], "z": [1, 3]}) + +simplex_1 = SimplexDomain( + [ + LabelTensor(torch.tensor([[0, 0]]), labels=["x", "y"]), + LabelTensor(torch.tensor([[2, 0]]), labels=["x", "y"]), + LabelTensor(torch.tensor([[0, 1]]), labels=["x", "y"]), + ] +) +simplex_2 = SimplexDomain( + [ + LabelTensor(torch.tensor([[0, 0, 0]]), labels=["x", "y", "z"]), + LabelTensor(torch.tensor([[1, 0, 0]]), labels=["x", "y", "z"]), + LabelTensor(torch.tensor([[0, 1, 0]]), labels=["x", "y", "z"]), + LabelTensor(torch.tensor([[0, 0, 1]]), labels=["x", "y", "z"]), + ] +) + +# Define the geometries +__geometries = [ + [cartesian_1, ellipsoid_1], + [cartesian_2, ellipsoid_2], + [cartesian_1, simplex_1], + [cartesian_2, simplex_2], + [ellipsoid_1, simplex_1], + [ellipsoid_2, simplex_2], + [cartesian_1, ellipsoid_1, simplex_1], + [cartesian_2, ellipsoid_2, simplex_2], +] + + +@pytest.mark.parametrize("geometries", __geometries) +def test_constructor(geometries): + Union(geometries) + + # Should fail if geometries is not a list or a tuple + with pytest.raises(TypeError): + Union({cartesian_1, ellipsoid_1}) + + # Should fail if the elements of geometries are not BaseDomain instances + with pytest.raises(ValueError): + Union([{"x": [0, 1], "y": [0, 1]}, {"x": [1, 2], "y": [0, 1]}]) + + # Should fail if the dimensions of the geometries are not consistent + with pytest.raises(NotImplementedError): + Union([cartesian_1, cartesian_2]) + + +@pytest.mark.parametrize("check_border", [True, False]) +def test_is_inside(check_border): + + # Define points + pt_in = LabelTensor(torch.tensor([[0.5, 0.5]]), ["x", "y"]) + pt_out = LabelTensor(torch.tensor([[-5, 0]]), ["x", "y"]) + pt_border = LabelTensor(torch.tensor([[-1, 0]]), ["x", "y"]) + + # Union + union = Union(__geometries[0]) + + # Expected results + truth = [True, False, True] if check_border else [True, False, False] + + # Checks + for pt, exp in zip([pt_in, pt_out, pt_border], truth): + assert union.is_inside(pt, check_border=check_border) == exp + + # Should fail if point is not a LabelTensor + with pytest.raises(ValueError): + union.is_inside(torch.Tensor([0.5, 0.5]), check_border=check_border) + + # Should fail if the labels of the point differ from the domain + with pytest.raises(ValueError): + pt = LabelTensor(torch.Tensor([0.5, 0.5]), ["a", "b"]) + union.is_inside(pt, check_border=check_border) + + +@pytest.mark.parametrize("domain_class", [CartesianDomain, EllipsoidDomain]) +def test_update(domain_class): + + # Define the union + domain_1 = domain_class({"x": [0, 1], "y": [0, 1]}) + domain_2 = domain_class({"x": [1, 2], "y": [0, 2]}) + union = Union([domain_1, domain_2]) + + # Update the union with another valid domain + domain_3 = domain_class({"t": [0, 1], "w": 0}) + updated_union = union.update(domain_3) + + # Check that the union has been updated correctly + assert len(updated_union.geometries) == 2 + assert updated_union.variables == sorted(["x", "y", "t", "w"]) + for i, g in enumerate(updated_union.geometries): + assert g._range == {**union.geometries[i]._range, **domain_3._range} + assert g._fixed == {**union.geometries[i]._fixed, **domain_3._fixed} + + # Should fail if trying to update the union of different geometry types + with pytest.raises(NotImplementedError): + union = Union(__geometries[0]) + union.update(simplex_1) + + # Should fail if trying to update with a different domain type + with pytest.raises(TypeError): + union = Union( + CartesianDomain({"x": [0, 1], "y": [0, 1]}), + CartesianDomain({"x": [1, 2], "y": [0, 1]}), + ) + other_domain = EllipsoidDomain({"x": [-1, 1], "y": [-1, 1]}) + union.update(other_domain) -def test_constructor_two_CartesianDomains(): - Union( - [ - CartesianDomain({"x": [0, 1], "y": [0, 1]}), - CartesianDomain({"x": [0.5, 2], "y": [-1, 0.1]}), - ] - ) - - -def test_constructor_two_EllipsoidDomains(): - Union( - [ - EllipsoidDomain({"x": [-1, 1], "y": [-1, 1], "z": [-1, 1]}), - EllipsoidDomain( - {"x": [-0.5, 0.5], "y": [-0.5, 0.5], "z": [-0.5, 0.5]} - ), - ] - ) - - -def test_constructor_EllipsoidDomain_CartesianDomain(): - Union( - [ - EllipsoidDomain({"x": [-1, 1], "y": [-1, 1]}), - CartesianDomain({"x": [-0.5, 0.5], "y": [-0.5, 0.5]}), - ] - ) - - -def test_is_inside_two_CartesianDomains(): - pt_1 = LabelTensor(torch.tensor([[0.5, 0.5]]), ["x", "y"]) - pt_2 = LabelTensor(torch.tensor([[-1, -1]]), ["x", "y"]) - domain = Union( - [ - CartesianDomain({"x": [0, 1], "y": [0, 1]}), - CartesianDomain({"x": [0.5, 2], "y": [-1, 0.1]}), - ] - ) - assert domain.is_inside(pt_1) == True - assert domain.is_inside(pt_2) == False - - -def test_is_inside_two_EllipsoidDomains(): - pt_1 = LabelTensor(torch.tensor([[0.5, 0.5, 0.5]]), ["x", "y", "z"]) - pt_2 = LabelTensor(torch.tensor([[-1, -1, -1]]), ["x", "y", "z"]) - domain = Union( - [ - EllipsoidDomain({"x": [-1, 1], "y": [-1, 1], "z": [-1, 1]}), - EllipsoidDomain( - {"x": [-0.5, 0.5], "y": [-0.5, 0.5], "z": [-0.5, 0.5]} - ), - ] - ) - assert domain.is_inside(pt_1) == True - assert domain.is_inside(pt_2) == False - - -def test_is_inside_EllipsoidDomain_CartesianDomain(): - pt_1 = LabelTensor(torch.tensor([[0.5, 0.5]]), ["x", "y"]) - pt_2 = LabelTensor(torch.tensor([[-1, -1]]), ["x", "y"]) - domain = Union( - [ - EllipsoidDomain( - { - "x": [-1, 1], - "y": [-1, 1], - } - ), - CartesianDomain({"x": [0.6, 1.5], "y": [-2, 0]}), - ] - ) - assert domain.is_inside(pt_1) == True - assert domain.is_inside(pt_2) == False - - -def test_sample(): - n = 100 - domain = Union( - [ - EllipsoidDomain({"x": [-1, 1], "y": [-1, 1]}), - CartesianDomain({"x": [-0.5, 0.5], "y": [-0.5, 0.5]}), - ] - ) - pts = domain.sample(n) - assert isinstance(pts, LabelTensor) - assert pts.shape[0] == n - - n = 105 - pts = domain.sample(n) - assert isinstance(pts, LabelTensor) - assert pts.shape[0] == n +def test_partial(): + with pytest.raises(NotImplementedError): + union = Union(__geometries[0]) + union.partial() + + +@pytest.mark.parametrize("variables", ["all", "x", ["x"]]) +@pytest.mark.parametrize("geometries", __geometries) +def test_sample(variables, geometries): + + # Define the domain + num_samples = 5 + domain = Union(geometries) + + # Iterate over modes (dependent on the domain types) + for mode in domain.sample_modes: + + # Sample from the domain + pts = domain.sample(num_samples, mode=mode, variables=variables) + + # Labels and number of samples + labels = sorted(variables if variables != "all" else domain.variables) + if mode in ["grid", "chebyshev"]: + num_range_vars = len([k for k in labels if k in domain._range]) + num_samples = num_samples ** (num_range_vars or 1) + + # Checks + assert pts.shape == (num_samples, len(labels)) + assert pts.labels == labels + + # Should fail if n is not a positive integer + with pytest.raises(AssertionError): + domain.sample(0, mode=mode, variables=variables) + + # Should fail if the mode is not recognized + with pytest.raises(ValueError): + domain.sample(1, mode="invalid_mode", variables=variables) + + # Should fail if the variables are invalid + with pytest.raises(ValueError): + domain.sample(1, mode=mode, variables=123) + + # Should fail if the variables are unknown + with pytest.raises(ValueError): + domain.sample(1, mode=mode, variables=["invalid_var"]) diff --git a/tests/test_problem.py b/tests/test_problem.py index 1c1184f54..1407572c1 100644 --- a/tests/test_problem.py +++ b/tests/test_problem.py @@ -2,8 +2,7 @@ import pytest from pina.problem.zoo import Poisson2DSquareProblem as Poisson from pina import LabelTensor -from pina.domain import Union -from pina.domain import CartesianDomain +from pina.domain import Union, CartesianDomain, EllipsoidDomain from pina.condition import ( Condition, InputTargetCondition, @@ -70,16 +69,16 @@ def test_collected_data(): def test_add_points(): poisson_problem = Poisson() - poisson_problem.discretise_domain(0, "random", domains=["D"]) + poisson_problem.discretise_domain(1, "random", domains=["D"]) new_pts = LabelTensor(torch.tensor([[0.5, -0.5]]), labels=["x", "y"]) poisson_problem.add_points({"D": new_pts}) - assert torch.isclose( - poisson_problem.discretised_domains["D"].extract("x"), - new_pts.extract("x"), + assert torch.allclose( + poisson_problem.discretised_domains["D"]["x"][-1], + new_pts["x"], ) - assert torch.isclose( - poisson_problem.discretised_domains["D"].extract("y"), - new_pts.extract("y"), + assert torch.allclose( + poisson_problem.discretised_domains["D"]["y"][-1], + new_pts["y"], ) @@ -106,8 +105,13 @@ def test_wrong_custom_sampling_logic(mode): "y": {"n": 50, "mode": mode}, } with pytest.raises(RuntimeError): + poisson_problem.domains["new"] = EllipsoidDomain({"x": [0, 1]}) poisson_problem.discretise_domain(sample_rules=sampling_rules) + # Necessary cleanup + if "new" in poisson_problem.domains: + del poisson_problem.domains["new"] + def test_aggregate_data(): poisson_problem = Poisson() @@ -115,7 +119,7 @@ def test_aggregate_data(): input=LabelTensor(torch.tensor([[0.0, 1.0]]), labels=["x", "y"]), target=LabelTensor(torch.tensor([[0.0]]), labels=["u"]), ) - poisson_problem.discretise_domain(0, "random", domains="all") + poisson_problem.discretise_domain(1, "random", domains="all") poisson_problem.collect_data() assert isinstance(poisson_problem.collected_data, dict) for name, conditions in poisson_problem.conditions.items(): diff --git a/tutorials/tutorial2/tutorial.ipynb b/tutorials/tutorial2/tutorial.ipynb index e93850aaf..de53e5da5 100644 --- a/tutorials/tutorial2/tutorial.ipynb +++ b/tutorials/tutorial2/tutorial.ipynb @@ -16,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "ad0b8dd7", "metadata": {}, "outputs": [], @@ -73,7 +73,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "id": "82c24040", "metadata": {}, "outputs": [ @@ -81,8 +81,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "The problem is made of 5 conditions: \n", - "They are: ['g1', 'g2', 'g3', 'g4', 'D']\n" + "The problem is made of 2 conditions: \n", + "They are: ['boundary', 'D']\n" ] } ], @@ -100,11 +100,7 @@ "\n", "# let's discretise the domain\n", "problem.discretise_domain(30, \"grid\", domains=[\"D\"])\n", - "problem.discretise_domain(\n", - " 100,\n", - " \"grid\",\n", - " domains=[\"g1\", \"g2\", \"g3\", \"g4\"],\n", - ")" + "problem.discretise_domain(100, \"grid\", domains=[\"boundary\"])" ] }, { @@ -127,7 +123,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "id": "e7d20d6d", "metadata": { "scrolled": true @@ -137,7 +133,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "GPU available: True (mps), used: False\n", + "💡 Tip: For seamless cloud uploads and versioning, try installing [litmodels](https://pypi.org/project/litmodels/) to enable LitModelCheckpoint, which syncs automatically with the Lightning model registry.\n", + "GPU available: True (cuda), used: False\n", "TPU available: False, using: 0 TPU cores\n", "HPU available: False, using: 0 HPUs\n" ] @@ -145,7 +142,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "38a34ce3c1214e90be1f5e0194d80674", + "model_id": "0fb488df9f64451c9e0e98155306e720", "version_major": 2, "version_minor": 0 }, @@ -205,7 +202,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "id": "1ab83c03", "metadata": {}, "outputs": [], @@ -246,13 +243,13 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "id": "7db10610", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -304,7 +301,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "id": "ef3ad372", "metadata": {}, "outputs": [ @@ -312,7 +309,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "GPU available: True (mps), used: False\n", + "💡 Tip: For seamless cloud uploads and versioning, try installing [litmodels](https://pypi.org/project/litmodels/) to enable LitModelCheckpoint, which syncs automatically with the Lightning model registry.\n", + "GPU available: True (cuda), used: False\n", "TPU available: False, using: 0 TPU cores\n", "HPU available: False, using: 0 HPUs\n" ] @@ -320,7 +318,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "62180078584f4dfea97d9dc6f8d20856", + "model_id": "02dbc375d37541c0945fd21b32359f55", "version_major": 2, "version_minor": 0 }, @@ -401,13 +399,13 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "id": "2be6b145", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -449,7 +447,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "id": "ae8716e7", "metadata": {}, "outputs": [ @@ -457,7 +455,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "GPU available: True (mps), used: False\n", + "💡 Tip: For seamless cloud uploads and versioning, try installing [litmodels](https://pypi.org/project/litmodels/) to enable LitModelCheckpoint, which syncs automatically with the Lightning model registry.\n", + "GPU available: True (cuda), used: False\n", "TPU available: False, using: 0 TPU cores\n", "HPU available: False, using: 0 HPUs\n" ] @@ -465,7 +464,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3eed1678b6c14cf2a190c248766815c7", + "model_id": "8c336148882a48f28907335d05b6a8c3", "version_major": 2, "version_minor": 0 }, @@ -541,7 +540,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "id": "daa9cf17", "metadata": {}, "outputs": [ @@ -549,7 +548,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "GPU available: True (mps), used: False\n", + "💡 Tip: For seamless cloud uploads and versioning, try installing [litmodels](https://pypi.org/project/litmodels/) to enable LitModelCheckpoint, which syncs automatically with the Lightning model registry.\n", + "GPU available: True (cuda), used: False\n", "TPU available: False, using: 0 TPU cores\n", "HPU available: False, using: 0 HPUs\n" ] @@ -557,7 +557,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "dd1dfdff74d44fe39c9a26577360887c", + "model_id": "6de1e10850af4035b2994637863f5d55", "version_major": 2, "version_minor": 0 }, @@ -623,7 +623,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, "id": "a04e8a5d", "metadata": {}, "outputs": [ @@ -637,7 +637,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1079e27187e3401b8fe32a2eedc2048d", + "model_id": "9fd1d9fe4f5843edbec0481bdcbbfaf7", "version_major": 2, "version_minor": 0 }, @@ -655,7 +655,7 @@ "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", " Test metric DataLoader 0\n", "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", - " test_loss 0.06821467727422714\n", + " test_loss 0.07931102812290192\n", "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", "PINN with extra features\n" ] @@ -663,7 +663,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "162d7ddcaaa04224a497fac59416dba3", + "model_id": "a1d9261b0a7b46ce8738193a5a725e8c", "version_major": 2, "version_minor": 0 }, @@ -681,7 +681,7 @@ "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", " Test metric DataLoader 0\n", "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", - " test_loss 0.0006851177895441651\n", + " test_loss 0.0008294920553453267\n", "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", "PINN with learnable extra features\n" ] @@ -689,7 +689,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3223351c32cd439da929c499f80b847f", + "model_id": "ba405e3fec6441deaaba7a92d1b423c4", "version_major": 2, "version_minor": 0 }, @@ -707,7 +707,7 @@ "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", " Test metric DataLoader 0\n", "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n", - " test_loss 5.667239566520266e-09\n", + " test_loss 5.015203530245316e-11\n", "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n" ] } @@ -747,7 +747,7 @@ ], "metadata": { "kernelspec": { - "display_name": "pina", + "display_name": "deep", "language": "python", "name": "python3" }, @@ -761,7 +761,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.21" + "version": "3.12.11" } }, "nbformat": 4, From 8b0b4aa48fa8d71997c51b737e38d98f8bb8fca6 Mon Sep 17 00:00:00 2001 From: GiovanniCanali Date: Thu, 4 Dec 2025 10:44:11 +0100 Subject: [PATCH 2/2] update tutorial 6 --- tutorials/tutorial6/tutorial.ipynb | 455 ++++++++++++++++------------- 1 file changed, 251 insertions(+), 204 deletions(-) diff --git a/tutorials/tutorial6/tutorial.ipynb b/tutorials/tutorial6/tutorial.ipynb index 7c9973c52..916cc179e 100644 --- a/tutorials/tutorial6/tutorial.ipynb +++ b/tutorials/tutorial6/tutorial.ipynb @@ -1,26 +1,25 @@ { "cells": [ { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "# Tutorial: Building geometries with PINA `DomainInterface` class\n", + "# Tutorial: Building domains with PINA's `BaseDomain` class\n", "\n", "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/mathLab/PINA/blob/master/tutorials/tutorial6/tutorial.ipynb)\n", "\n", - "In this tutorial we will show how to use geometries in PINA. Specifically, the tutorial will include how to create geometries and how to visualize them. The topics covered are:\n", - "\n", - "* Creating CartesianDomains and EllipsoidDomains\n", - "* Getting the Union and Difference of Geometries\n", - "* Sampling points in the domain (and visualize them)\n", + "In this tutorial, we explore how to use and visualize PINA’s built-in geometric domains and how to construct custom ones. We will cover:\n", + "- Creating domains using `CartesianDomain`, `EllipsoidDomain`, and `SimplexDomain`\n", + "- Combining domains through set operations\n", + "- Defining custom domains\n", + "- Sampling from domains\n", "\n", - "We import the relevant modules first." + "We begin by importing the necessary modules." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -34,24 +33,18 @@ "if IN_COLAB:\n", " !pip install \"pina-mathlab[tutorial]\"\n", "\n", + "from copy import deepcopy\n", "import torch\n", "import matplotlib.pyplot as plt\n", "\n", "from pina import LabelTensor\n", "from pina.domain import (\n", - " EllipsoidDomain,\n", - " Difference,\n", " CartesianDomain,\n", - " Union,\n", + " EllipsoidDomain,\n", " SimplexDomain,\n", - " DomainInterface,\n", - ")\n", - "\n", - "\n", - "# a simple plotting function\n", - "def plot_scatter(ax, pts, title):\n", - " ax.title.set_text(title)\n", - " ax.scatter(pts.extract(\"x\"), pts.extract(\"y\"), color=\"blue\", alpha=0.5)" + " Union,\n", + " BaseDomain,\n", + ")" ] }, { @@ -63,11 +56,11 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "We will create one cartesian and two ellipsoids. For the sake of simplicity, we show here the 2-dimensional case, but the extension to 3D (and higher) cases is trivial. The geometries allow also the generation of samples belonging to the boundary. So, we will create one ellipsoid with the border and one without." + "We start with PINA’s built-in geometries. In particular, we define a Cartesian domain, an ellipsoid domain, and a simplex domain, all in two dimensions. Extending these constructions to higher dimensions follows the same principles.\n", + "The Cartesian domain represents rectangular regions, the ellipsoid domain models circular or elliptical shapes, and the simplex domain corresponds to triangular regions, which can be combined to form general polygonal domains." ] }, { @@ -76,21 +69,34 @@ "metadata": {}, "outputs": [], "source": [ - "cartesian = CartesianDomain({\"x\": [0, 2], \"y\": [0, 2]})\n", - "ellipsoid_no_border = EllipsoidDomain({\"x\": [1, 3], \"y\": [1, 3]})\n", - "ellipsoid_border = EllipsoidDomain(\n", - " {\"x\": [2, 4], \"y\": [2, 4]}, sample_surface=True\n", - ")" + "# Carteisan, Ellipsoid, and Simplex domains\n", + "cartesian = CartesianDomain({\"x\": [0, 1], \"y\": [0, 1]})\n", + "ellipsoid = EllipsoidDomain({\"x\": [-0.5, 0.5], \"y\": [-0.5, 0.5]})\n", + "simplex = SimplexDomain(\n", + " [\n", + " LabelTensor(torch.tensor([[-0.5, 0]]), labels=[\"x\", \"y\"]),\n", + " LabelTensor(torch.tensor([[0.5, 0]]), labels=[\"x\", \"y\"]),\n", + " LabelTensor(torch.tensor([[-0.5, 1]]), labels=[\"x\", \"y\"]),\n", + " ]\n", + ")\n", + "\n", + "# Example of a domain with fixed and variable dimensions\n", + "cartesian_fixed_variable = CartesianDomain({\"x\": [0, 2], \"y\": 1})" ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "The `{'x': [0, 2], 'y': [0, 2]}` are the bounds of the `CartesianDomain` being created. \n", - "\n", - "To visualize these shapes, we need to sample points on them. We will use the `sample` method of the `CartesianDomain` and `EllipsoidDomain` classes. This method takes a `n` argument which is the number of points to sample. It also takes different modes to sample, such as `'random'`." + "Both Cartesian and ellipsoid domains are created by passing dictionaries that specify the bounds for each variable. If a lower and upper bound coincide, the variable can be fixed by providing a single numerical value.\n", + "Since the concept of bounds does not apply to simplices, their initialization requires explicitly providing the vertices. The number of vertices must always be one more than the domain dimension." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To visualize the shapes, we draw sample points from each domain using the `sample` method, available for all PINA domains. The argument `n` specifies how many points to generate. The optional `mode` argument selects the sampling strategy (e.g. \"random\"). The optional `variables` argument allows sampling over only a subset of variables; here, we sample all of them." ] }, { @@ -100,8 +106,9 @@ "outputs": [], "source": [ "cartesian_samples = cartesian.sample(n=1000, mode=\"random\")\n", - "ellipsoid_no_border_samples = ellipsoid_no_border.sample(n=1000, mode=\"random\")\n", - "ellipsoid_border_samples = ellipsoid_border.sample(n=1000, mode=\"random\")" + "ellipsoid_samples = ellipsoid.sample(n=1000, mode=\"random\")\n", + "simplex_samples = simplex.sample(n=1000, mode=\"random\")\n", + "fixed_variable_samples = cartesian_fixed_variable.sample(n=1000, mode=\"random\")" ] }, { @@ -109,7 +116,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We can see the samples of each geometry to see what we are working with." + "We can inspect a few sampled points from each domain to get a better understanding of their structure." ] }, { @@ -121,40 +128,42 @@ "name": "stdout", "output_type": "stream", "text": [ - "Cartesian Samples: 1: {'dof': ['x', 'y'], 'name': 1}\n", + "Cartesian samples: 1: {'dof': ['x', 'y'], 'name': 1}\n", + "\n", + "tensor([[0.5425, 0.6101],\n", + " [0.7445, 0.9891],\n", + " [0.5512, 0.3992],\n", + " [0.0850, 0.7751]])\n", + "\n", + "Ellipsoid samples: 1: {'dof': ['x', 'y'], 'name': 1}\n", "\n", - "tensor([[1.6544, 1.2960],\n", - " [1.7501, 0.2478],\n", - " [1.0246, 1.3413],\n", - " ...,\n", - " [0.4893, 0.9506],\n", - " [0.8948, 0.0721],\n", - " [0.9561, 1.5479]])\n", - "Ellipsoid No Border Samples: 1: {'dof': ['x', 'y'], 'name': 1}\n", + "tensor([[-0.2000, 0.0602],\n", + " [-0.0484, -0.2838],\n", + " [-0.2880, -0.0161],\n", + " [-0.2058, -0.3772]])\n", "\n", - "tensor([[2.6485, 2.2025],\n", - " [2.1400, 1.9427],\n", - " [1.7750, 1.8902],\n", - " ...,\n", - " [2.0498, 1.9918],\n", - " [1.9361, 1.9551],\n", - " [1.4225, 1.4052]])\n", - "Ellipsoid Border Samples: 1: {'dof': ['x', 'y'], 'name': 1}\n", + "Simplex samples: 1: {'dof': ['x', 'y'], 'name': 1}\n", "\n", - "tensor([[3.9522, 3.3056],\n", - " [3.3107, 2.0495],\n", - " [3.8294, 3.5586],\n", - " ...,\n", - " [2.0069, 3.1172],\n", - " [2.2859, 3.7001],\n", - " [2.4795, 2.1462]])\n" + "tensor([[-0.2432, 0.6661],\n", + " [ 0.1784, 0.1737],\n", + " [-0.1602, 0.6325],\n", + " [-0.0232, 0.1157]])\n", + "\n", + "Fixed variable samples: 1: {'dof': ['x', 'y'], 'name': 1}\n", + "\n", + "tensor([[0.2608, 1.0000],\n", + " [0.2790, 1.0000],\n", + " [0.1738, 1.0000],\n", + " [1.9722, 1.0000]])\n", + "\n" ] } ], "source": [ - "print(f\"Cartesian Samples: {cartesian_samples}\")\n", - "print(f\"Ellipsoid No Border Samples: {ellipsoid_no_border_samples}\")\n", - "print(f\"Ellipsoid Border Samples: {ellipsoid_border_samples}\")" + "print(f\"Cartesian samples: {cartesian_samples[:4]}\\n\")\n", + "print(f\"Ellipsoid samples: {ellipsoid_samples[:4]}\\n\")\n", + "print(f\"Simplex samples: {simplex_samples[:4]}\\n\")\n", + "print(f\"Fixed variable samples: {fixed_variable_samples[:4]}\\n\")" ] }, { @@ -162,7 +171,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We are now ready to visualize the samples using matplotlib." + "Now we are ready to visualize the sampled points!" ] }, { @@ -172,7 +181,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -182,32 +191,25 @@ } ], "source": [ + "# Basic plotting function\n", + "def plot_scatter(ax, pts, title):\n", + " ax.title.set_text(title)\n", + " ax.scatter(pts.extract(\"x\"), pts.extract(\"y\"), color=\"blue\", alpha=0.5)\n", + " ax.set_aspect(\"equal\", adjustable=\"box\")\n", + "\n", "fig, axs = plt.subplots(1, 3, figsize=(16, 4))\n", - "pts_list = [\n", - " cartesian_samples,\n", - " ellipsoid_no_border_samples,\n", - " ellipsoid_border_samples,\n", - "]\n", - "title_list = [\"Cartesian Domain\", \"Ellipsoid Domain\", \"Ellipsoid Border Domain\"]\n", + "pts_list = [cartesian_samples, ellipsoid_samples, simplex_samples]\n", + "title_list = [\"Cartesian Domain\", \"Ellipsoid Domain\", \"Simplex Domain\"]\n", + "\n", "for ax, pts, title in zip(axs, pts_list, title_list):\n", " plot_scatter(ax, pts, title)" ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "We have now created, sampled, and visualized our first geometries! We can see that the `EllipsoidDomain` with the border has a border around it. We can also see that the `EllipsoidDomain` without the border is just the ellipse. We can also see that the `CartesianDomain` is just a square." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Simplex Domain\n", - "\n", - "Among the built-in shapes, we quickly show here the usage of `SimplexDomain`, which can be used for polygonal domains!" + "Similarly, we can sample and visualize boundary points by using the `partial` method. This method returns a new domain representing only the boundary of the original one, from which we can draw samples in exactly the same way." ] }, { @@ -217,9 +219,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -227,37 +229,30 @@ } ], "source": [ - "import torch\n", + "# Boundary definitions\n", + "cartesian_boundary = cartesian.partial()\n", + "ellipsoid_boundary = ellipsoid.partial()\n", + "simplex_boundary = simplex.partial()\n", "\n", - "spatial_domain = SimplexDomain(\n", - " [\n", - " LabelTensor(torch.tensor([[0, 0]]), labels=[\"x\", \"y\"]),\n", - " LabelTensor(torch.tensor([[1, 1]]), labels=[\"x\", \"y\"]),\n", - " LabelTensor(torch.tensor([[0, 2]]), labels=[\"x\", \"y\"]),\n", - " ]\n", - ")\n", + "# Boundary sampling\n", + "cartesian_bnd_samples = cartesian_boundary.sample(n=500, mode=\"random\")\n", + "ellipsoid_bnd_samples = ellipsoid_boundary.sample(n=500, mode=\"random\")\n", + "simplex_bnd_samples = simplex_boundary.sample(n=500, mode=\"random\")\n", "\n", - "spatial_domain2 = SimplexDomain(\n", - " [\n", - " LabelTensor(torch.tensor([[0.0, -2.0]]), labels=[\"x\", \"y\"]),\n", - " LabelTensor(torch.tensor([[-0.5, -0.5]]), labels=[\"x\", \"y\"]),\n", - " LabelTensor(torch.tensor([[-2.0, 0.0]]), labels=[\"x\", \"y\"]),\n", - " ]\n", - ")\n", + "# Plot\n", + "fig, axs = plt.subplots(1, 3, figsize=(16, 4))\n", + "pts_list = [cartesian_bnd_samples, ellipsoid_bnd_samples, simplex_bnd_samples]\n", + "title_list = [\"Cartesian Domain\", \"Ellipsoid Domain\", \"Simplex Domain\"]\n", "\n", - "pts = spatial_domain2.sample(100)\n", - "fig, axs = plt.subplots(1, 2, figsize=(16, 6))\n", - "for domain, ax in zip([spatial_domain, spatial_domain2], axs):\n", - " pts = domain.sample(1000)\n", - " plot_scatter(ax, pts, \"Simplex Domain\")" + "for ax, pts, title in zip(axs, pts_list, title_list):\n", + " plot_scatter(ax, pts, title)" ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "## Boolean Operations" + "Great! We have created our first domains, sampled points from them, and visualized the results." ] }, { @@ -265,9 +260,32 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "To create complex shapes we can use the boolean operations, for example to merge two default geometries. We need to simply use the `Union` class: it takes a list of geometries and returns the union of them.\n", - "\n", - "Let's create three unions. Firstly, it will be a union of `cartesian` and `ellipsoid_no_border`. Next, it will be a union of `ellipse_no_border` and `ellipse_border`. Lastly, it will be a union of all three geometries." + "## Set Operations" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "PINA’s built-in domains are powerful, but by themselves they cannot represent more complex shapes. To build richer geometries, we use set operations. PINA supports `Union`, `Intersection`, `Difference`, and `Exclusion` (symmetric difference) for all domain types.\n", + "Here, we focus on `Union` for demonstration purposes; the remaining operations behave analogously." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "All set operations in PINA take a list of domains as input. For `Intersection`, `Difference`, and `Exclusion`, the operation is applied between the first two domains in the list. The resulting domain is then combined with the next one, and this process continues iteratively until all domains have been processed." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let’s build the union of:\n", + "1. `cartesian` and `simplex`\n", + "2. `cartesian` and `ellipsoid_boundary`\n", + "3. `ellipsoid` and `simplex_boundary`" ] }, { @@ -276,17 +294,16 @@ "metadata": {}, "outputs": [], "source": [ - "cart_ellipse_nb_union = Union([cartesian, ellipsoid_no_border])\n", - "cart_ellipse_b_union = Union([cartesian, ellipsoid_border])\n", - "three_domain_union = Union([cartesian, ellipsoid_no_border, ellipsoid_border])" + "union_cart_sim = Union([cartesian, simplex])\n", + "union_cart_ell_bnd = Union([cartesian, ellipsoid_boundary])\n", + "union_ell_sim_bnd = Union([ellipsoid, simplex_boundary])" ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "We can of course sample points over the new geometries, by using the `sample` method as before. We highlight that the available sample strategy here is only *random*." + "And of course, we can sample points from these composite domains as well!" ] }, { @@ -295,9 +312,9 @@ "metadata": {}, "outputs": [], "source": [ - "c_e_nb_u_points = cart_ellipse_nb_union.sample(n=2000, mode=\"random\")\n", - "c_e_b_u_points = cart_ellipse_b_union.sample(n=2000, mode=\"random\")\n", - "three_domain_union_points = three_domain_union.sample(n=3000, mode=\"random\")" + "cart_sim_samples = union_cart_sim.sample(n=1000, mode=\"random\")\n", + "cart_ell_bnd_samples = union_cart_ell_bnd.sample(n=1000, mode=\"random\")\n", + "ell_sim_bnd_samples = union_ell_sim_bnd.sample(n=1000, mode=\"random\")" ] }, { @@ -305,7 +322,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We can plot the samples of each of the unions to see what we are working with." + "We can now plot the samples to visualize each union." ] }, { @@ -315,7 +332,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABOYAAAF2CAYAAADKopfOAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnXd4FNX+xt/dJLtJNo30QCD0EAKCgnQEFEUBERVRbIAgWFAUC6IoIiqWK6J4QVARC94rYEEEURHRS1e6IXRCIEB6Nr1sdn5/vL+Tmd3sJrsphMD5PE+eJLtTzpyZOeU936JTFEWBRCKRSCQSiUQikUgkEolEIrmg6Bu6ABKJRCKRSCQSiUQikUgkEsnliBTmJBKJRCKRSCQSiUQikUgkkgZACnMSiUQikUgkEolEIpFIJBJJAyCFOYlEIpFIJBKJRCKRSCQSiaQBkMKcRCKRSCQSiUQikUgkEolE0gBIYU4ikUgkEolEIpFIJBKJRCJpAKQwJ5FIJBKJRCKRSCQSiUQikTQAUpiTSCQSiUQikUgkEolEIpFIGgApzEkkEolEIpFIJBKJRCKRSCQNgBTmJBKJRCKRXBIsW7YMOp0OSUlJDV2UeqOurzEpKQk6nQ7Lli2r+Ozll1+GTqez2a5ly5YYN25cnZyzNrhajsb2LDiq88bIwIEDMXDgwIYuhkRSI3Q6HV5++eWK/x21IxfLM+5qOTZt2gSdTodNmzbVe5lcpa77k4ZsPx31oZcTja2vdca4cePQsmXLBi2DFOYkEolEIrlMOX78OCZPnozWrVvD29sbAQEB6Nu3L9577z0UFRXV6blef/11fP/993V6TIlzxETF2c/58+cbuogXBfb1pNfrERUVheHDh2P79u0NXbx6Ydy4cfDz83P6vZ+f30UhwkokdYEQDpz9XKrv+aVAfn4+Zs2ahU6dOsFkMiEkJARdu3bF1KlTcfbs2YYuXoPi6LkODw/HoEGD8NNPPzV08eoF0V9nZGQ4/L5Tp04XhWheUzwbugASiUQikUguPGvXrsUdd9wBo9GI+++/H506dUJpaSk2b96MZ555BgkJCViyZEmdne/111/HqFGjMHLkyDo7pj333Xcf7rrrLhiNxno7R2Nj0aJFDkWYoKAgt45z+PBh6PUNv55bX+UQ9WS1WnH69Gl89NFHuOaaa7Bz50507dq1zs93qfLLL780dBEkEoe88soraNWqVaXP27Zt69ZxLpZn/GIpR31RVlaGa665BocOHcLYsWPx2GOPIT8/HwkJCfjqq69w6623omnTpgCAmTNn4rnnnmvgEjcM4rlWFAWpqalYtmwZhg4dijVr1mD48OENXbxGw0cffQSr1dqgZZDCnEQikUgklxknT57EXXfdhZiYGGzcuBFRUVEV3z366KM4duwY1q5dW+vzKIqC4uJi+Pj41PpYruDh4QEPD48Lcq7GwqhRoxAaGlrr41wsYmd9lcO+nkaOHIlOnTph5cqVdSLMWSwWWK1WGAyGWh/LFQoLC+Hr63tBzqXlQl2fROIuN910E7p3717r41wsz/jFUo764vvvv8eePXuwfPly3H333TbfFRcXo7S0tOJ/T09PeHpenrKG/XM9YcIERERE4D//+U+dCHNWqxWlpaXw9vau9bFcoaCgACaT6YKcS4uXl9cFP6c9Db/0KZFIJBKJ5ILy1ltvIT8/H5988omNKCdo27Ytpk6dWvH/p59+imuvvRbh4eEwGo3o2LEjFi1aVGm/li1bYvjw4fj555/RvXt3+Pj4YPHixdDpdCgoKMBnn31W4XKhdZVLSUnBAw88gIiICBiNRsTHx2Pp0qWVjr9gwQLEx8fD19cXTZo0Qffu3fHVV19VfO8o1snq1asxbNgwNG3aFEajEW3atMGcOXNQXl5uc+yBAweiU6dOOHjwIAYNGgRfX180a9YMb731lkt16m4dbd68GT169IC3tzdat26Nzz//vNK2CQkJuPbaa+Hj44Po6Gi8+uqrDbaiax8TSNT1n3/+icmTJyMkJAQBAQG4//77kZ2dbbPv33//jSFDhiA0NBQ+Pj5o1aoVHnjgAZttCgoK8NRTT6F58+YwGo2IjY3Fv/71LyiKUmU5gPqpp8jISACoNNlLS0urmPh4e3ujS5cu+Oyzz2y2ETGH/vWvf2H+/Plo06YNjEYjDh48CADYvHkzrr76anh7e6NNmzZYvHix03J8+eWX6NatG3x8fBAcHIy77roLp0+fttlGPLu7du3CNddcA19fXzz//PO1un4t4l5v2bIF06ZNQ1hYGEwmE2699Vakp6dXKou9K5G7dbZkyZKKOrv66qvx119/1dm1SCS1xf4ZFzHcvv76azz//POIjIyEyWTCiBEjKr2rR48exe23347IyEh4e3sjOjoad911F8xmc8U2FosFc+bMqXgHWrZsieeffx4lJSVVlgMAzpw5g5EjR8JkMiE8PBxPPvlkpf2ccerUKTzyyCOIjY2Fj48PQkJCcMcdd1SKHeZOe6AoCl599VVER0fD19cXgwYNQkJCgkvlOX78OACgb9++lb4ToTcEjmLM6XQ6TJkyBStXrkTHjh3h4+OD3r1748CBAwCAxYsXo23btvD29sbAgQMrXae2Xe3Tp09F3/Xhhx+6VP5Dhw5h1KhRCA4Ohre3N7p3744ffvih4vu0tDSEhYVh4MCBNv3csWPHYDKZcOedd7p0HnuCgoLg4+NTqe9ytY8V9bZ8+XLEx8fDaDRi/fr1ANzra3/66Sf0798fJpMJ/v7+GDZsWKV7L8IqHD9+HEOHDoW/vz/uueeeGl23I8S7uWLFCrz22muIjo6Gt7c3rrvuOhw7dqxSWexjzLlbZ99//z06depUMY4V9eYql6e0LJFIJBLJZcyaNWvQunVr9OnTx6XtFy1ahPj4eIwYMQKenp5Ys2YNHnnkEVitVjz66KM22x4+fBhjxozB5MmT8eCDDyI2NhZffPEFJk6ciB49emDSpEkAgDZt2gAAUlNT0atXr4qBTVhYGH766SdMmDABubm5eOKJJwDQzeDxxx/HqFGjMHXqVBQXF2P//v3YsWNHpdV0LcuWLYOfnx+mTZsGPz8/bNy4ES+99BJyc3Px9ttv22ybnZ2NG2+8EbfddhtGjx6NVatWYfr06ejcuTNuuummOqujY8eOYdSoUZgwYQLGjh2LpUuXYty4cejWrRvi4+MBAOfPn8egQYNgsVjw3HPPwWQyYcmSJW5bH2ZlZVX6zNPT021XVmdMmTIFQUFBePnll3H48GEsWrQIp06dqhgQp6Wl4YYbbkBYWBiee+45BAUFISkpCd9++23FMRRFwYgRI/D7779jwoQJ6Nq1K37++Wc888wzSElJwbvvvuv0/HVdT1arFSkpKZgzZw68vb0xevToim2KioowcOBAHDt2DFOmTEGrVq2wcuVKjBs3Djk5OTZiNkCxtri4GJMmTYLRaERwcDAOHDhQUR8vv/wyLBYLZs2ahYiIiEpleu211/Diiy9i9OjRmDhxItLT07FgwQJcc8012LNnj809zMzMxE033YS77roL9957r8Pj1ZbHHnsMTZo0waxZs5CUlIT58+djypQp+Prrr53u426dffXVV8jLy8PkyZOh0+nw1ltv4bbbbsOJEycuCosGSePFbDZXik2l0+kQEhJSJ8d/7bXXoNPpMH36dKSlpWH+/PkYPHgw9u7dCx8fH5SWlmLIkCEoKSnBY489hsjISKSkpODHH39ETk4OAgMDAQATJ07EZ599hlGjRuGpp57Cjh07MHfuXCQmJuK7775zev6ioiJcd911SE5OxuOPP46mTZviiy++wMaNG10q/19//YWtW7firrvuQnR0NJKSkrBo0SIMHDgQBw8erGSB60p78NJLL+HVV1/F0KFDMXToUOzevRs33HCDjbWbM2JiYgAAn3/+OWbOnFmj5A7/+9//8MMPP1T0wXPnzsXw4cPx7LPPYuHChXjkkUeQnZ2Nt956Cw888EClusrOzsbQoUMxevRojBkzBitWrMDDDz8Mg8FQaXFJS0JCAvr27YtmzZpV9EsrVqzAyJEj8c033+DWW29FeHg4Fi1ahDvuuAMLFizA448/DqvVinHjxsHf3x8LFy506RrFc60oCtLS0rBgwQLk5+fj3nvvrdjG3T5248aNWLFiBaZMmYLQ0FC0bNnSrb72iy++wNixYzFkyBC8+eabKCwsxKJFi9CvXz/s2bPHRgCzWCwYMmQI+vXrh3/961/1Yun9xhtvQK/X4+mnn4bZbMZbb72Fe+65Bzt27HC6j7t1tnnzZnz77bd45JFH4O/vj/fffx+33347kpOTXW9jFIlEIpFIJJcNZrNZAaDccsstLu9TWFhY6bMhQ4YorVu3tvksJiZGAaCsX7++0vYmk0kZO3Zspc8nTJigREVFKRkZGTaf33XXXUpgYGDFuW+55RYlPj6+ynJ++umnCgDl5MmTVZZ98uTJiq+vr1JcXFzx2YABAxQAyueff17xWUlJiRIZGancfvvtVZ7X2XmqqqM///yz4rO0tDTFaDQqTz31VMVnTzzxhAJA2bFjh812gYGBla7REbNmzVIAOPyJjY2t2O7kyZMKAOXTTz+ttK99ubX3T9R1t27dlNLS0orP33rrLQWAsnr1akVRFOW7775TACh//fWX07J+//33CgDl1Vdftfl81KhRik6nU44dO+a0HPVVT0FBQZWe4/nz5ysAlC+//LLis9LSUqV3796Kn5+fkpubqyiKWqcBAQFKWlqazTFGjhypeHt7K6dOnar47ODBg4qHh4dNnSclJSkeHh7Ka6+9ZrP/gQMHFE9PT5vPxbP74YcfVnmtgrFjxyomk8np9/bvqrjXgwcPVqxWa8XnTz75pOLh4aHk5OTYlGXAgAEV/7tbZyEhIUpWVlbFtqtXr1YAKGvWrHHp2iQSe8Tz6+jHaDTabAtAmTVrVqV9te2I/TP++++/KwCUZs2aVTzPiqIoK1asUAAo7733nqIoirJnzx4FgLJy5UqnZd27d68CQJk4caLN508//bQCQNm4caPTcoh3bcWKFRWfFRQUKG3btlUAKL///ntV1eSwD9u2bVulftHV9iAtLU0xGAzKsGHDbLZ7/vnnFQAOxwP25YmNjVUAKDExMcq4ceOUTz75RElNTa20raM+S9xf7b1bvHixAkCJjIy0uVczZsxweJ8BKO+8807FZyUlJUrXrl2V8PDwin7PUR963XXXKZ07d7YZY1itVqVPnz5Ku3btbMo5ZswYxdfXVzly5Ijy9ttvKwCU77//vsq6URTnz7XRaFSWLVtms607fSwARa/XKwkJCTbbutrX5uXlKUFBQcqDDz5os//58+eVwMBAm8/Hjh2rAFCee+65aq9XUdT7nJ6e7vD7+Ph4h+9mXFycUlJSUvH5e++9pwBQDhw4YFOWmJiYiv/drTODwWDz2b59+xQAyoIFC1y6NkVRFOnKKpFIJBLJZURubi4AwN/f3+V9tCuiYnV2wIABOHHihI0LDgC0atUKQ4YMcem4iqLgm2++wc033wxFUZCRkVHxM2TIEJjNZuzevRsA3TPOnDnjtlubtux5eXnIyMhA//79UVhYiEOHDtls6+fnZ7PKbDAY0KNHD5w4ccKt81RXRx07dkT//v0r/g8LC0NsbKzNedatW4devXqhR48eNtu56+bxzTff4Ndff7X5+fTTT906RlVMmjTJxpLp4YcfhqenJ9atWwdATTLx448/oqyszOEx1q1bBw8PDzz++OM2nz/11FNQFKXKDHN1XU+//PILPv30U7Rv3x633347tm7danOuyMhIjBkzpuIzLy8vPP7448jPz8cff/xhc8zbb78dYWFhFf+Xl5fj559/xsiRI9GiRYuKz+Pi4iq9M99++y2sVitGjx5t815ERkaiXbt2+P333222NxqNGD9+vFvX7C6TJk2ysVrp378/ysvLcerUKaf7uFtnd955J5o0aWJzDgAuvYMSSVX8+9//rtQW1mX2yvvvv9+mXx01ahSioqIq2kJhEffzzz+jsLDQ4THEttOmTbP5/KmnngKAKmO/rlu3DlFRURg1alTFZ76+vhVW6tWh7cPKysqQmZmJtm3bIigoqKIf1lJde7BhwwaUlpbiscces9lOWMG7Up4dO3bgmWeeAUDr9wkTJiAqKgqPPfaYSy661113nY11Vs+ePQGwbdbeK/G5fTvj6emJyZMnV/xvMBgwefJkpKWlYdeuXQ7PmZWVhY0bN2L06NEVY46MjAxkZmZiyJAhOHr0KFJSUiq2/+CDDxAYGIhRo0bhxRdfxH333Ydbbrml2msTaJ/rL7/8EoMGDcLEiRNtrNLd7WMHDBiAjh072nzmal/766+/IicnB2PGjLHpuzw8PNCzZ89KfRfAcUN9Mn78eJuYjK70K+7W2eDBgys8QQDgiiuuQEBAgFt9l3RllUgkEonkMkLEZcnLy3N5ny1btmDWrFnYtm1bpQmF2WyumHAAcJj1zhnp6enIycnBkiVLnGaATUtLAwBMnz4dGzZsQI8ePdC2bVvccMMNuPvuux3Gn9GSkJCAmTNnYuPGjRWipLbsWqKjoyu5yzRp0gT79++v9lrcqSOtKKM9jzY226lTpyomC1piY2OrLYuWa665pk6SPzijXbt2Nv/7+fkhKiqqIl7PgAEDcPvtt2P27Nl49913MXDgQIwcORJ33313RSKHU6dOoWnTppXE4ri4uIrvnVFf9TRq1Ci0a9cOjz32WMUE7NSpU2jXrl2lrLDOymn/LqSnp6OoqKhSnYnyikk5wFhUiqI43BaoHKi6WbNmdRoM3pHbmP1zKwQ0+5iCWtyts5qcQyJxhR49etRJ8gdn2L+rOp0Obdu2rWgLW7VqhWnTpmHevHlYvnw5+vfvjxEjRuDee++t6B9OnToFvV5fKVNsZGQkgoKCqm0L27ZtW+nddbUtLCoqwty5c/Hpp58iJSXFJo6WfV8JVP+uirLa10tYWJiN+F4VgYGBeOutt/DWW2/h1KlT+O233/Cvf/2rQsx69dVXq9zfvoyinps3b+7wc/t2pmnTppUSEbRv3x4A42L26tWr0jmPHTsGRVHw4osv4sUXX3RYrrS0NDRr1gwAEBwcjPfffx933HEHIiIi8P7771d5TfbYP9djxozBlVdeiSlTpmD48OEwGAxu97GOxnGu9rVHjx4FAFx77bUOy6uNDQhQ/IyOjnZ2eW5Tl32XO3XmyriuOqQwJ5FIJBLJZURAQACaNm2Kf/75x6Xtjx8/juuuuw4dOnTAvHnz0Lx5cxgMBqxbtw7vvvtupcC/7sT2Evvee++9GDt2rMNtrrjiCgAcDB0+fBg//vgj1q9fj2+++QYLFy7ESy+9hNmzZzvcNycnBwMGDEBAQABeeeUVtGnTBt7e3ti9ezemT59eqezOMrpqJyiOcLeOanqexohOp8OqVauwfft2rFmzBj///DMeeOABvPPOO9i+fTv8/PwauogO8fPzQ8+ePbF69eoaZ4mrTTZiq9UKnU6Hn376yeHzYl9v7pzL29sbJSUlUBSl0iRG+f9Myo4y8F2I5/Zyejcklx/vvPMOxo0bh9WrV+OXX37B448/jrlz52L79u024kRN4qnVlsceewyffvopnnjiCfTu3RuBgYHQ6XS46667HAb4v9DvakxMDB544AHceuutaN26NZYvX16tMOesjPVZdlFXTz/9tFPvAXvh9eeffwZAoejMmTO1igGr1+sxaNAgvPfeezh69GhF3Fp3qG3fBTDOnEiipMU+KYXRaKy0cOMM0S8VFRU5/L6wsLBR911SmJNIJBKJ5DJj+PDhWLJkCbZt24bevXtXue2aNWtQUlKCH374wWZF0JE7QlU4mmiEhYXB398f5eXlGDx4cLXHEJnK7rzzTpSWluK2227Da6+9hhkzZjgcjG3atAmZmZn49ttvcc0111R8fvLkSbfKXh11VUdaYmJiKlaetRw+fLjGx6wPjh49ikGDBlX8n5+fj3PnzmHo0KE22/Xq1Qu9evXCa6+9hq+++gr33HMP/vvf/2LixImIiYnBhg0bkJeXZ7M6LVyNRRBwR9RnPVksloprMplMiImJwf79+2G1Wm0mEq6UE+Dz7uPj41J527RpA0VR0KpVqwoLjboiJiYGFosFx48frzRBPHbsGMrLy6u9FnfOVZs6k0gaC/bvtaIoOHbsWMXikqBz587o3LkzZs6cia1bt6Jv37748MMP8eqrryImJgZWqxVHjx6tsMwBmCQpJyen2rbwn3/+qSS4u9oWrlq1CmPHjsU777xT8VlxcTFycnJc2t9ReQDWS+vWrSs+T09Pr5UFbJMmTdCmTRuXFxdrw9mzZystzBw5cgQAKmXwFIhr9fLycmlcs379enz88cd49tlnsXz5cowdOxY7duyoJGC5g7bvAlCrPlbgal8r3DnDw8Ndun53EOU8fPhwJavHwsJCnD59GjfccEOdnau2deYuMsacRCKRSCSXGc8++yxMJhMmTpyI1NTUSt8fP34c7733HgB1FdDercXdOGUmk6nSAN/DwwO33347vvnmG4eD7PT09Iq/MzMzbb4zGAzo2LEjFEVxGrvMUdlLS0tdznbmKnVVR1qGDh2K7du3Y+fOnRWfpaenY/ny5TUvaD2wZMkSm/pftGgRLBZLRRbb7OzsSivGXbt2BYCKGEFDhw5FeXk5PvjgA5vt3n33Xeh0uioz4tZXPWVlZWHr1q2IjIxEeHh4xbnOnz9vk3XQYrFgwYIF8PPzw4ABA6o8poeHB4YMGYLvv/8eycnJFZ8nJiZWWEwIbrvtNnh4eGD27NmV6k9RlErvgzuI+rSvb4DxirTb1Jba1plE0lj4/PPPbUJErFq1CufOnat4l3JzcysEE0Hnzp2h1+tt2kIAmD9/vs128+bNAwAMGzbM6fmHDh2Ks2fPYtWqVRWfFRYWOg0TYY+Hh0eltmbBggUoLy93aX97Bg8eDC8vLyxYsMDmuPbX5ox9+/ZVyqIL0IXw4MGDbocrqAkWiwWLFy+u+L+0tBSLFy9GWFgYunXr5nCf8PBwDBw4EIsXL8a5c+cqfa8d1+Tk5FRkrH/99dfx8ccfY/fu3Xj99ddrXOaysjL88ssvMBgMFeJubfpYgat97ZAhQxAQEIDXX3/d4dhMe/3uct1118FgMGDRokWVrDiXLFliM/aoLXVRZ+4iLeYkEolEIrnMaNOmDb766ivceeediIuLw/33349OnTqhtLQUW7duxcqVKzFu3DgAwA033ACDwYCbb74ZkydPRn5+Pj766COEh4c7HHQ6o1u3btiwYQPmzZuHpk2bolWrVujZsyfeeOMN/P777+jZsycefPBBdOzYEVlZWdi9ezc2bNiArKysinJERkaib9++iIiIQGJiIj744AMMGzbMaSKLPn36oEmTJhg7diwef/xx6HQ6fPHFF3XualNXdaTl2WefxRdffIEbb7wRU6dOhclkwpIlSyoskFxl1apVDt1Fr7/+ekRERNSobFpKS0tx3XXXYfTo0Th8+DAWLlyIfv36YcSIEQCAzz77DAsXLsStt96KNm3aIC8vDx999BECAgIqJqE333wzBg0ahBdeeAFJSUno0qULfvnlF6xevRpPPPGETUBle+q6nhRFwdmzZ/HJJ58gOzsbH374YYX1yaRJk7B48WKMGzcOu3btQsuWLbFq1Sps2bIF8+fPdymhyuzZs7F+/Xr0798fjzzySIVIFR8fb1PeNm3a4NVXX8WMGTOQlJSEkSNHwt/fHydPnsR3332HSZMm4emnn3b5+rR07doVEydOrHB1uv766wEwaPe6deswceJEdOnSpUbHtqcu6kwiqQt++umnSgl/APYTWouumhIcHIx+/fph/PjxSE1Nxfz589G2bVs8+OCDAICNGzdiypQpuOOOO9C+fXtYLBZ88cUXFQtUANClSxeMHTsWS5YsqQjFsHPnTnz22WcYOXKkjXWyPQ8++CA++OAD3H///di1axeioqLwxRdfwNfX16XyDx8+HF988QUCAwPRsWNHbNu2DRs2bEBISEiN6iMsLAxPP/005s6di+HDh2Po0KHYs2cPfvrpJ5finv7666+YNWsWRowYgV69esHPzw8nTpzA0qVLUVJSgpdffrlG5XKHpk2b4s0330RSUhLat2+Pr7/+Gnv37sWSJUsqxfnU8u9//xv9+vVD586d8eCDD6J169ZITU3Ftm3bcObMGezbtw8AMHXqVGRmZmLDhg3w8PDAjTfeiIkTJ+LVV1/FLbfc4lI7rH2u09LS8NVXX+Ho0aN47rnnKuK51aaPFbja1wYEBGDRokW47777cNVVV+Guu+5CWFgYkpOTsXbtWvTt29fhopArhIeH46WXXsLMmTNxzTXXYMSIEfD19cXWrVvxn//8BzfccANuvvnmGh3bnrqoM7dxOX+rRCKRSCSSS4ojR44oDz74oNKyZUvFYDAo/v7+St++fZUFCxYoxcXFFdv98MMPyhVXXKF4e3srLVu2VN58801l6dKlCgDl5MmTFdvFxMQow4YNc3iuQ4cOKddcc43i4+OjAFDGjh1b8V1qaqry6KOPKs2bN1e8vLyUyMhI5brrrlOWLFlSsc3ixYuVa665RgkJCVGMRqPSpk0b5ZlnnlHMZnPFNp9++mmlMm3ZskXp1auX4uPjozRt2lR59tlnlZ9//lkBoPz+++8V2w0YMECJj4+vVO6xY8cqMTEx1dZlbetowIAByoABA2w+279/vzJgwADF29tbadasmTJnzhzlk08+qXRMR8yaNUsB4PRHXPvJkycVAMqnn35aaV8tMTExNvdM1PUff/yhTJo0SWnSpIni5+en3HPPPUpmZmbFdrt371bGjBmjtGjRQjEajUp4eLgyfPhw5e+//7Y5fl5envLkk08qTZs2Vby8vJR27dopb7/9tmK1WqssR33Uk8lkUnr37q2sWLGi0vapqanK+PHjldDQUMVgMCidO3e2qTttnb799tsOz/nHH38o3bp1UwwGg9K6dWvlww8/dFjniqIo33zzjdKvXz/FZDIpJpNJ6dChg/Loo48qhw8frtjG2bNbFeXl5cp7772ndOnSRfH29la8vb2VLl26KO+//75SXl5us62413/99ZfN57///rvD98j+Oa5tnQFQZs2a5db1SSQC8fw6+9E+i/bPmqM+xf4ZF+/Bf/7zH2XGjBlKeHi44uPjowwbNkw5depUxXYnTpxQHnjgAaVNmzaKt7e3EhwcrAwaNEjZsGGDTXnLysqU2bNnK61atVK8vLyU5s2bKzNmzLDpkx2VQ1EU5dSpU8qIESMUX19fJTQ0VJk6daqyfv36Su+pI7KzsyveUz8/P2XIkCHKoUOHnLb9rrQH5eXlyuzZs5WoqCjFx8dHGThwoPLPP/84bMftOXHihPLSSy8pvXr1UsLDwxVPT08lLCxMGTZsmLJx40abbR21nwCURx991OYzZ+2MKPvKlSsrPhPt6t9//6307t1b8fb2VmJiYpQPPvjA4THt27Tjx48r999/vxIZGal4eXkpzZo1U4YPH66sWrVKURRFWb16tQJAeeedd2z2y83NVWJiYpQuXboopaWlTuvH0XPt7e2tdO3aVVm0aFGlvtPVPtZRvQnc6Wt///13ZciQIUpgYKDi7e2ttGnTRhk3bpxN3z927FjFZDI5vUZnfPnll0qvXr0Uk8mkGI1GpUOHDsrs2bMrvSOO7quiOL5njsZ6ta0zV55zLbr/P5hEIpFIJBKJROISy5Ytw/jx4/HXX3/Va6ZDiUQiuZjZtGkTBg0ahJUrV2LUqFENXRxJHTFw4EBkZGRckFh2EgkgY8xJJBKJRCKRSCQSiUQikUgkDYIU5iQSiUQikUgkEolEIpFIJJIGQApzEolEIpFIJBKJRCKRSCQSSQMgY8xJJBKJRCKRSCQSiUQikUgkDYC0mJNIJBKJRCKRSCQSiUQikUgaACnMSSQSiUQikUgkEolEIpFIJA2AZ0MXQCKRSCQSSf1itVpx9uxZ+Pv7Q6fTNXRxJBKJpMYoioK8vDw0bdoUer20MZA0bmT/LJG4z6XYD0hhTiKRSCSSS5yzZ8+iefPmDV0MiUQiqTNOnz6N6Ojohi6GRFIrZP8skdScS6kfkMKcRCKRSCSXOP7+/gA4gAkICGjg0kgkEknNyc3NRfPmzSvaNYmkMSP7Z4nEfS7FfkAKcxKJRCKRXOII95iAgAA58JdIJJcE0u1Pcikg+2eJpOZcSv3ApeGQK5FIJBKJRCKRSCQSiUQikTQypDAnkUgkEolEIpFIJBKJRCKRNABSmJNIJBKJRCKRSCQSiUQikUgaACnMSSQSiUQikUgkEolEIpFIJA2AFOYkEolEIpFIJBKJRCKRSCSSBkAKcxKJRCKRSCQSiUQikUgkEkkD4NnQBZBIJBKJRCKRVI3VCiQnA3l5gL8/0KIFoJfLqxKJRHLJI9t/ieTSR77SkgZj2bJl0Ol0SEpKauii1Bv1cY06nQ4vv/xynR3PHcaNG4eWLVs2yLnrg6SkJOh0OixbtqyhiyK5jPjzzz9x8803o2nTptDpdPj++++r3WfTpk246qqrYDQa0bZtW/nMXmYkJgJvvAG89BIwZw5/v/EGP5dcWlitQFIScOAAf1utDV0iieTy4WLsnxMTgVdeAUaPBkaMAIYPB556CkhIqNPTSCSSBkYKc42I48ePY/LkyWjdujW8vb0REBCAvn374r333kNRUVGdnuv11193qTOS1B2bN2/GTTfdhGbNmsHb2xstWrTAzTffjK+++qqhi9bg6HQ6TJkyxeF3q1atgk6nw6ZNmy5soSSSGlJQUIAuXbrg3//+t0vbnzx5EsOGDcOgQYOwd+9ePPHEE5g4cSJ+/vnnei6ppCGwF2YSEoD33wf27AFCQ4HYWP7evRt47TVg9Wop4NQnF1IocyTAvv46sGHDhTm/1QqcOAGsX8+fEyfkcyW5vLjY+ufERODee4FXXwX++kvtE957D7jhBuDHH+vkNBKJ5CJAurI2EtauXYs77rgDRqMR999/Pzp16oTS0lJs3rwZzzzzDBISErBkyZI6O9/rr7+OUaNGYeTIkXV2THvuu+8+3HXXXTAajfV2jsbCypUrceedd6Jr166YOnUqmjRpgpMnT+LPP//ERx99hLvvvrti26KiInh6yle3LoiJiUFRURG8vLwauiiSy4ibbroJN910k8vbf/jhh2jVqhXeeecdAEBcXBw2b96Md999F0OGDKmvYkoagMRE4LvvgEOHgOJiwGgEUlMBnQ7o1Yu/AaCkBMjKAo4fB/btA7p2BeLigFtv5e/Lifp08bK/H97eQIcOtatnZ+VNTKQAm5EBNG8OmEzc7r//BT7/HGjdGggPr935q6qrxERg8WLgjz/4bAFAcDAwYAAwebJ755Nud5LGysXUP1utwKOPclFGUWy/UxTg7Fm+m7/8AsTH1+pUEonkIkDO7hsBJ0+exF133YWYmBhs3LgRUVFRFd89+uijOHbsGNauXVvr8yiKguLiYvj4+NT6WK7g4eEBDw+PC3Kui52XX34ZHTt2xPbt22EwGGy+S0tLs/nf29v7Qhbtkkan08n6lFz0bNu2DYMHD7b5bMiQIXjiiSec7lNSUoKSkpKK/3Nzc+ureJI6wpEwc/YscPgwEBjIz8PCgPR0YMcOoLAQCAkBLBbAYODk7fRp4PHHG6c456qYo90uNZV1cfhw3QlnAkf3o6CgdvXsTOi75RZaPmZkAB07UoBNT6dljNXKSXhJCe93Tc+fmAh8+y2waxeQnw/4+QHdugG33cbvZ88Gdu4EPDyAyEh+lp0NrFkDnD8PzJrl2vmqukaTSYp1kkuL+uyfjxwBtmypLMppOXuWgvr8+fJ9kkgaO/IVbgS89dZbyM/PxyeffGIjygnatm2LqVOnVvz/6aef4tprr0V4eDiMRiM6duyIRYsWVdqvZcuWGD58OH7++Wd0794dPj4+WLx4MXQ6HQoKCvDZZ59Bp9NBp9Nh3LhxFfulpKTggQceQEREBIxGI+Lj47F06dJKx1+wYAHi4+Ph6+uLJk2aoHv37jZumY7ir61evRrDhg1D06ZNYTQa0aZNG8yZMwfl5eU2xx44cCA6deqEgwcPYtCgQfD19UWzZs3w1ltvuVSn7tbR5s2b0aNHD3h7e6N169b4/PPPK22bkJCAa6+9Fj4+PoiOjsarr74Kq4s+IMePH8fVV19dSZQDgPDwcJv/7WPMvfzyy9DpdDhy5AjuvfdeBAYGIiwsDC+++CIURcHp06dxyy23ICAgAJGRkRWreoJNmzZBp9Ph66+/xvPPP4/IyEiYTCaMGDECp0+frrbsVqsV8+fPR3x8PLy9vREREYHJkycjOzu7YptZs2ZBr9fjt99+s9l30qRJMBgM2LdvnyvV5DKuPh/OYsxt3LgR/fv3h8lkQlBQEG655RYk2gVzEvV+7NgxjBs3DkFBQQgMDMT48eNRWFhYp9cjubw5f/48IiIibD6LiIhAbm6u0zAGc+fORWBgYMVP8+bNL0RRJTXEaqWYIYSZgAAKJAYDxYyyMgodVit/FxZSpPPzA8rLuV3Hjtz/++8bzv2wpm6frsbQ0273zDPAI48A//kPhSzh4rtnDwW12sTfc3Y/AgL4f3o68OmntFZ09TqF0GfvkrxnDzB3LgXG5s15LYpie59DQmjFpig1u8+JiRTe/vMf/n3mDH//5z/Ayy8DH34I/PMPLTSbNgV8fPgTFcXPEhIo6lV3PmfX+McfwAMPAFOnyhiJkkuL+uyfP/8cKC2tvgwLF7I9lG7nEknjRlrMNQLWrFmD1q1bo0+fPi5tv2jRIsTHx2PEiBHw9PTEmjVr8Mgjj8BqteLRRx+12fbw4cMYM2YMJk+ejAcffBCxsbH44osvMHHiRPTo0QOTJk0CALRp0wYAkJqail69elXE/AoLC8NPP/2ECRMmIDc3t2KF6KOPPsLjjz+OUaNGYerUqSguLsb+/fuxY8cOG7dMe5YtWwY/Pz9MmzYNfn5+2LhxI1566SXk5ubi7bffttk2OzsbN954I2677TaMHj0aq1atwvTp09G5c+dqzdDdqaNjx45h1KhRmDBhAsaOHYulS5di3Lhx6NatG+L/33b8/PnzGDRoECwWC5577jmYTCYsWbLEZevDmJgY/Pbbbzhz5gyio6Nd2seeO++8E3FxcXjjjTewdu1avPrqqwgODsbixYtx7bXX4s0338Ty5cvx9NNP4+qrr8Y111xjs/9rr70GnU6H6dOnIy0tDfPnz8fgwYOxd+/eKq9j8uTJWLZsGcaPH4/HH38cJ0+exAcffIA9e/Zgy5Yt8PLywsyZM7FmzRpMmDABBw4cgL+/P37++Wd89NFHmDNnDrp06VKja66Kmj4fGzZswE033YTWrVvj5ZdfRlFRERYsWIC+ffti9+7dlZJfjB49Gq1atcLcuXOxe/dufPzxxwgPD8ebb75Z59ckkbjKjBkzMG3atIr/c3NzpTh3EZOcTCFGCDMCoxHw8qIolJFBQSUjgxZ0Oh2tqDw9uZ1OB0RHU+xITgbqO0+PvYVbQQGtvtx1+3TVMk27XXQ0vwMoTCYkUKQMC6NwdfAghavY2JpZkdjfD0UBzGbWd0EBrVR27+Z5Q0Kqv057oU/cYyH0bdsGnDsHdO7Mz81m2/tsMLCeS0rcv89WKy1qdu7kcxIUxGeqrAzIyeG5DQY+R02a2D5/Oh3LaDbT0q6q8zm7xpISIDOTVneensCgQRQcG7uFp0RSU1ztn1NTXTteeTkt5vbuZRsp3VolksaJFOYucnJzc5GSkoJbbrnF5X3++OMPGyFlypQpuPHGGzFv3jyHotP69esrxUF46KGH0Lp1a9x77702n7/wwgsoLy/HgQMHEBISUrHtmDFj8PLLL2Py5Mnw8fHB2rVrER8fj5UrV7p1vV999ZVN2R966CE89NBDWLhwIV599VWbeHRnz57F559/jvvuuw8AMGHCBMTExOCTTz6pVphzp44OHz6MP//8E/379wdAIaZ58+b49NNP8a9//QsA8OabbyI9PR07duxAjx49AABjx45Fu3btXLru6dOnY8KECWjTpg369u2Lfv364YYbbkCfPn2gd3FW0aNHDyxevBgALdFatmyJp556CnPnzsX06dMBAGPGjEHTpk2xdOnSSsJcVlYWEhMT4e/vDwC46qqrMHr06AqR1RGbN2/Gxx9/jOXLl9sIroMGDcKNN96IlStX4u6774aXlxc+//xzdOvWDdOmTcPbb7+NCRMmoHv37njuuedcuj53qenz8cwzzyA4OBjbtm1DcHAwAGDkyJG48sorMWvWLHz22Wc221955ZX45JNPKv7PzMzEJ598IoU5SZ0RGRmJVLsRempqKgICApyK5kajUcbvbETk5VHMMplsPw8MpMVRSgrFufx8uq56eVEsys2lVVNgILc3mbhtXl7dlU0rwInyHTgAbN5MsaWkhD/nzlHYiY933e2zOsFKCGzt2tluZzbTgiwkhKJSejqFtNDQuhEotfdDHDsjg9eUnU2xz2QCmjWjIFjddToTXgH+37w5cOwYBb+AAP4uLOTfAK1mhAALOL/PjtyBk5JosebhwRh14vxGI/9PSqIAEB7O58oeg4H7FBRU/Vw5ukat5V+zZnx+8/MpDtaFgCqRNDT12T/bOQtVidUKbNwIjBwJvPsuM7dKJJLGhewGL3JE3AEhlriCtiMwm83IyMjAgAEDcOLECZjNZpttW7Vq5XJwUkVR8M033+Dmm2+GoijIyMio+BkyZAjMZjN2794NAAgKCsKZM2fw119/uVxu+7Ln5eUhIyMD/fv3R2FhIQ4dOmSzrZ+fn41waDAY0KNHD5w4ccKt81RXRx07dqwQ5QAgLCwMsbGxNudZt24devXqVSHKie3uueceF64aeOCBB7B+/XoMHDgQmzdvxpw5c9C/f3+0a9cOW7dudekYEydOrPjbw8MD3bt3h6IomDBhQsXnQUFBlcouuP/++22es1GjRiEqKgrr1q1zes6VK1ciMDAQ119/vc3z0K1bN/j5+eH333+v2LZTp06YPXs2Pv74YwwZMgQZGRn47LPP6i2RRU2ej3PnzmHv3r0YN25chSgHAFdccQWuv/56h3Xx0EMP2fzfv39/ZGZmyphekjqjd+/eldzAf/31V/Tu3buBSiSpa/z9aWFWUGD7uU5HayyDgYIGQAEjP5+Cka8vvxdCSEEBj+PGkKFK7F1Hb78dGDYMmDIFWLGCWTuDgylanT3L3yUltm6fVbldVidYCYFt+3bb7UpKVIFSWHVlZFCwAyhcFRfXXKAU9yM5mS6m587RtdNi4fcWiyreuXKd9sKrotBaLTWVvyMiWGd//snJ9Z49PF5SEu9pbi5FRyHAOrrPztyBf/uNImZwsOM6DgqiAFBaSis6e0pLWV6TqernypG4rLX8MxpZbyK0lr2AKpE0Ruqzfw4Lc3+f48eBJ56gNa9EImlcSGHuIifg/5dL89wYXW7ZsgWDBw+uiI8VFhaG559/HgAcCnOukp6ejpycHCxZsgRhYWE2P+PHjwegJiqYPn06/Pz80KNHD7Rr1w6PPvootmzZUu05EhIScOuttyIwMBABAQEICwurEFfsyx4dHQ2d3SizSZMmNrHNnOFOHbVo0aLS/vbnOXXqlEPruNjY2GrLIhgyZAh+/vln5OTk4M8//8Sjjz6KU6dOYfjw4ZUSQDjCvpyBgYHw9vZGaGhopc8d1ZF9+XU6Hdq2bWsTA9Ceo0ePwmw2Izw8vNIzkZ+fX6nczzzzDLp06YKdO3di1qxZ6NixY7XX5Sr2z0JNno9Tp04BcHzf4uLikJGRgQK7mbN9vTdp0gQAXHoOJZcn+fn52Lt3L/bu3QuACX727t2L5P+fnc6YMQP3339/xfYPPfQQTpw4gWeffRaHDh3CwoULsWLFCjz55JMNUXxJPdCiBQW206crB/oODaVVnBDoALoGRkUBPXuqkzdFoatrXByPV1sSEoDXXgM2baIQlJZGQTAtjSJMUBCtx7ZsUd1Li4oooIlr0OloKfXXX8wcaB+PzZmloEAIbKmpttsZjbQgE0KSwWAr+hQUcBuz2f14dwDrr317um+KOG8Ar8/bmyKahwfrOzubdRIQQAswRyKTVnhNT6e14e+/U4j7/Xfgp594ntJSniMoiJZ42dnA0aMUY4UA6+g+VxW/7vvvHQtuAqOR9afXUyTUPn/CKtPTk4kiqnquHInLWgHV3uoPqL2AKpHUNRdT/+wg7HS1KArFuRdekDHnJJLGhnRlvcgJCAhA06ZN8c8//7i0/fHjx3HdddehQ4cOmDdvHpo3bw6DwYB169bh3XffrZSMwJ0MrGLfe++9F2PHjnW4zRVXXAGAIsbhw4fx448/Yv369fjmm2+wcOFCvPTSS5g9e7bDfXNycjBgwAAEBATglVdeQZs2beDt7Y3du3dj+vTplcruLKOrUlX6IrhfRzU9T03x9fVF//790b9/f4SGhmL27Nn46aefnNa5wFE567vsVqsV4eHhWL58ucPvw+yW+06cOIGjR48CAA4cOODyeYxGo9MguiLRgn121Qt13y708yFp/Pz9998YNGhQxf8i1szYsWOxbNkynDt3rmISAHABZe3atXjyySfx3nvvITo6usLyVHJpoNczRtnp0xR3oqNVd9AzZ4DWrWmlZjIx4cCKFRQ9hCAltgsNpStTbd0CExKAJ59ktlNfXwpEViuzdQoj59xcWrCdOUPBLjzc1nItKIgi1MGDtKx7911ahmnjsWnFHOG2qUVYhkVE2G4nXHzPnaNophV9FIXnBBhbraTE/Wytej3QqxeDr4uMqGVl/BHJNvz9eZ5z57i9qPN9+yq7zwrh9Y8/KKoWFvIavLx47EOHKPTdcAPrLCOD12I08pxeXqxPs7nyfbZYgKVLORkXdSqsCDt2ZGw5RaHVXNOmtlZzisJ7GxXFZywxkZaPItZcVhbve/fuFIETEhxnVLVa+dOkCa+le3d+LwTU0tLKbtfa+1tXFp4SSW25mPrnnj1rvu+PP3Jh5cUXa10MiURygZDCXCNg+PDhWLJkCbZt21atafSaNWtQUlKCH374wcaSR+tS6Ar2lkYARRZ/f3+Ul5dXSg3uCJPJhDvvvBN33nknSktLcdttt+G1117DjBkzKokoALODZmZm4ttvv7WJf3by5Em3yl4ddVVHWmJiYioEJy2HDx+u8TEBoHv37gDoYlnf2JdfURQcO3asQmx1RJs2bbBhwwb07du3WpHXarVi3LhxCAgIwBNPPIHXX38do0aNwm233VZt2WJiYpzWpfg8Jiam2uO4ch7tMbUcOnQIoaGhMDkz7ZBIXGTgwIFVCrf2WYLFPnv27KnHUkkamrg4xij77juKGykpFC2uuooijBCUWrakNVd129WUxETg9dcpyoWEUFjJyKAgde4cf/v4qBZegYEUd/LzKbCIJAXp6XQDNZspKLZvT4FJG48tNpaC1Z49tjHmANUy7KqrKJL9+aftdh068Njp6RSvRN6k7du5X3Q0RTtX493ZExFBsaqkhAJVYSHL5ONDkSwjg59FRLAO8vMpuq1YwWvVnkOvB265hckxzp+nFaGwIsvMpCjn789r6duX15WZyd9nz7J+9+7l/dDe58REinLffMP7lJpK0a5DB167yFZ78iSFsdOnWVY/P9ZZbi4FtRtvBCZOBD76iOKhCJkVHAxccQUFt88/d5zUIzGRz6JwSU1KYry8nj0p4Pn5AadOqaKsNv6cuL91YeEpkdQFF1P/HBDA91q40LtDeTnw5ptMKDNyZJ0XTSKR1APSlbUR8Oyzz8JkMmHixImVAowCtAB77733AKjWO9pOxWw249NPP3XrnCaTCTk5OTafeXh44Pbbb8c333zj0IIvPT294u/MzEyb7wwGAzp27AhFUVDmxKfCUdlLS0uxcOFCt8peHXVVR1qGDh2K7du3Y+fOnRWfpaenO7Uks8c+PoVAxDRzxyW2pnz++ec2LtOrVq3CuXPnqkyUMHr0aJSXl2POnDmVvrNYLDbP0Lx587B161YsWbIEc+bMQZ8+ffDwww8jIyOj2rKJ+t21a5fN5zk5OVi+fDm6du2KyMhIF66yaqKiotC1a1d89tlnNmX/559/8Msvv2Do0KG1PodEIpE4Iy4OeO454JVXaOnwyivA9OmVhSRH2z3zDEWjmrhuCkQyhvR0Clp+fupx/PzUWGRiW4uFn3t5qVlLPT1pUXboEAUxLy9aSgUHV47HBlDgCQ2l9ZnZzGOazfxfWIZ5elbeTiSa0Osp9hiNFLMAinK9evF8rsS7s1pZZ9q68/enFWDXrswket11qkWaEB99fPij01G0atuWnzs6h8lEi8MWLSiIpaTQddRk4o+wMExKAv75h2U5cYLH8/KiNZ32eRDuq/v2sX7Cw2ndeO4cBVExJCsuVoPIZ2bymIcP0/3WwwO4+mpg0iTW5bx5FPkWLwYWLaLVZGEhcOQIRUGti+z779Mq5/33KeadOEEBUafjsX/6iZ+HhlKIDA1VLTzt769M/CCRVKawsGburIKCAmDqVLYREonk4kdazDUC2rRpg6+++gp33nkn4uLicP/996NTp04oLS3F1q1bsXLlSowbNw4AcMMNN8BgMODmm2/G5MmTkZ+fj48++gjh4eFuWV1169YNGzZswLx589C0aVO0atUKPXv2xBtvvIHff/8dPXv2xIMPPoiOHTsiKysLu3fvxoYNG5CVlVVRjsjISPTt2xcRERFITEzEBx98gGHDhjlNZNGnTx80adIEY8eOxeOPPw6dTocvvviizl0C66qOtDz77LP44osvcOONN2Lq1KkwmUxYsmQJYmJisH///mr3v+WWW9CqVSvcfPPNaNOmDQoKCrBhwwasWbMGV199NW6++eYalcsdgoOD0a9fP4wfPx6pqamYP38+2rZtiwcffNDpPgMGDMDkyZMxd+5c7N27FzfccAO8vLxw9OhRrFy5Eu+99x5GjRqFxMREvPjiixg3blzFtSxbtgxdu3bFI488ghUrVlRZtueeew4rV67ENddcg8mTJ6NDhw44e/ZshVtBbURVe95++23cdNNN6N27NyZMmICioiIsWLAAgYGBePnll+vsPBKJROIIvb76TKL22TcLCoC33qIY5siqyVW0yRhSU2lV5enJMlmtFH5KS9UYbiLOW5MmnECmpAAxMRRfzp6lIBQQYGspBfCzrVv506ePa5aCziwKx4yhdVZEBAWfxYtVazEtzrK1Cosv+7q75RZba76gIApZ//ufKkD5+NDyS5uIw2BwnBFWiHlioi3cOwFOwMW6mKhb4eqan8/vdu6kOCfuhchSGxfHe1Vezv3CwtRMsorCOi4tBXr3pjB35gyPpygUGydPVutYr1etBL/9Fli1iscKDuZnwhKvY0e6tS5YoLrJiiyywjX1/Hnej5deojC3enX9WHhKJJcyej3bgfJyvmvuTolOn2Zb9v77wIgR9VNGiURSN0hhrpEwYsQI7N+/H2+//TZWr16NRYsWwWg04oorrsA777xTIZ7ExsZi1apVmDlzJp5++mlERkbi4YcfRlhYGB544AGXzzdv3jxMmjQJM2fORFFREcaOHYuePXsiIiICO3fuxCuvvIJvv/0WCxcuREhICOLj4/Hmm29W7D958mQsX74c8+bNQ35+PqKjo/H4449j5syZTs8ZEhKCH3/8EU899RRmzpyJJk2a4N5778V1111Xp7GU6qqOtERFReH333/HY489hjfeeAMhISF46KGH0LRpU5usqM74+OOPsXr1aqxYsQJnz56Foiho3bo1XnjhBUyfPr3eMpdqef7557F//37MnTsXeXl5uO6667Bw4UL4+vpWud+HH36Ibt26YfHixXj++efh6emJli1b4t5770Xfvn1RXl6OsWPHIjQ0FPPnz6/Yr127dpg7dy6mTp2KFStWYPTo0U7PERERgR07duDll1/GihUrKlLR9+nTB19//TV61iYQhx2DBw/G+vXrMWvWLLz00kvw8vLCgAED8Oabb7qVLEUikUjqA3shqaSEVlLCgqymrpuAmoyhRQs1hltoKEWn/HwKUcK1Sq/ntsXF3MZk4nahoXRlLCwE2rThuUW4USEYpaXRWuzNNykY3XorLQC1YqN9HDOAx4qNdb7dgQOsj6qSSaSkqCKYsDrLyKAYaV93w4bZxv1r0oRi26lTPKenJ69fJOcIC2PdaM8hSE2lVZnIcJqTQ8FMJEgoKaHgJizvRLw8e0s8cf1CQPX3t423J+LLpafzHmRlcZ9OnVgOs5nHTE7m9vYG+aJOTp3ids2a8VrPnuV9i4+n5Z+/P5NjhITwPL6+vMbCQjXm3OnTwNdf00U2Lq76+yuRSFSENTLAd0W0EYriunurhwfbhsceY5swfrx87ySSixWdIiOUSySXNZs2bcKgQYOwcuVKjBo1qqGLI5FI6oHc3FwEBgbCbDZXZPuWND7shSRfX2b1FDG8evWyzdJ68CAtk555RrWUqkoUSUqihVNoKCeBO3ZQaPHyUrOylpbS6svDg9ZyRiPdPa+/nhYZJhNFoyVLaD0ngv2LmHOFhbSYsljoRpmby/O5IyA6Q1t+R4+5iN32yiusgzfecB7fTtTdiBGqtVdxMct94gRFx/Bw1bpN7K89R8uWqpvs/PnAzz+rgmZODuvPaqU1jLCIEUkT2rTh976+tAg0GNTj5uUBc+ZQVPPwsK1bEZcqJYXnCQ8H+vVjnQh3Y5EZNStLLSfAsog6CQmhdWBICDPFZmRwe6ORwpzRyOsKCmIZRaw/o5FlEi6rISHAJ58ALoQmdhnZnkkuJZw9z/v2AaNG0frUYlHbCJ1ObTecIdojnY4/ej3bqSlTgNGjpaWqpPFzKfYD0mJOIpFIJBKJ5CJH674ohKScHIpl0dEUuA4dogAjJmPR0UyGMGMGrZmqc3MV2UOFWNWzJ4+ZkaEmK9DpKLb4+fFYBgOzfY4YQWsqcZzdu3kcMV4+dIjCUWgojxcVpSZsOHhQtQarjTWHffmdJZNo0cLW6qwqt9cxY1RrPrOZPytWUJwLDaVIlpZGQSogwPYcwrrx779pXebhQYs8kUjCauVnwkVNxMsrKaGF2hVXOLbEs89mGxZme6+KiiiSBQTQVRgANm/mdxYLhbvgYJZZa9mnrROrldvl5vL6hEhYXq6KgSIGlshY6+trKwgI1+c1a4Brr5WWOhKJOwQG8l08e5ZtgtaURqezdXHV61WhTptgRUt2NhdM/v6bArxoryUSycWBFOYkEolEIpFILnIcCUnCDdJgoAiTkUHhKCiI3xcVMZFAURFdGatzc9XrKdhp3Td79eLE8H//o1XeNddQGBKWYgC3/eEHHkuvr3ycgACKO97eLKOIxyauw1Hst5rgqPzims+csU02INx2XXF71etZh2vXqq64hw5RbDOZVAs0Dw/W88iRTLAgrBv9/Lidvz8FLLNZFeWsVtVt1cODk+3iYu7TqRPdZwFeg4jf5kiADAvj9eXksC5btVJFwIQE/hZx68rKWB86HQXbzp15Dm2d6PUUYP/5h2UTUS0KC1lOkfgiL4/HFEkwAG5fUsLy+vnxftT23koklxvR0bRSLSlx/L3VygWO3Fwu0Ah0OtWyDuD7ClC4y8oCNm1iwpclS6Q4J5FcTMi1K4lEIpFIJJKLHEdCkjYBg8h4KSZxisKYaxYLBTNXM5SKJAtXXknXyaNHKST5+zM7adu2FOiCgmwt84Sw5ug4IqacxcKJZI8eFHNSU/m5ry+vzT4uW02wL/+RI/x91VW2QqTW6swRWiFMuBDv2UPxq2VL1n1REa1QRKZagb11Y3Awr1ev5/ULyzE/P9ajycRzmUy27qCZmayj7GzWbWQk70VyMgO622ezzc2liNqmDa+1QweKh4WFFO6MRp7bYFCz5+7cqT4D2jrR6RhfTrjZlpfzHIrC85lMtMbT67m9NvZVYaF6/MhIXktd3FuJ5HIiKYmLA+Ld0iIsbktKaP0WHc131tOTPwK9Xt1WJJKwWNiWzZnDtk0ikVwcSIs5ieQyZ+DAgXWe+VYikUgkdYu9+yJACygR+N/fnxMyYb2Vk0OrqObNVQs6gbMMpQL7JAspKYwT1qJF5XIpCsWk1FRakWnj14njbN3KRA8iJtvhw7ZulX5+vA4nSdvdprokEYDrbq/R0cx4K0Q2gLGfPDwYW+/cOQpvvXrxfiQmAp99xs+FdaO4T0lJquuZxcKyeXtzm6AgWqgdP06hLycH+Osvbpufz/NlZ/MYwh152DBg/37n2U7PnQM+/1y1YDMY1GywJhOv59Ah9RmwrxM/P1rsWSwUIYuKKKI2b87jN2nCcxw9yjIKUUC4ODdpwmMqSt3dW4nkcmHLFr7zzoboisLvTSa6i99yC+PRicUakThCCOuArUD+3Xd8p7/7TrqZSyQXA1KYk0gkEolEIrnIcSQk6XT8zGymMBMTw0ma2UyByNOTbor2MdSAyhlK7dHrVcHO35+uilpREFCzrJ49S7Hn7beB334Dxo1TXaT0elpW9e4N/PEHrcC0bpWlpUxeYbE4t16rCdryO/veFbfXM2dsXYhzcijSBQaq7p5FRWqAdSF4Wq3q+XU6ipL791MgE7HX7K3LCgt5vLQ01ToNUAO9Z2QA7dtzf+GOPGUKcPfdjgXIiAigdWueMyuL23h6qllkmzShRaF4BuzrxN9fda8FWLbu3ekmq9PxOevQgfd62zY1Vp6Pj5rxNT1djbknkUhcJzu76gQPAL/Pzga6dKFV71NP8Z3z8OBPaantMYSbK0Dx7qefgNdeA158sf6uQyKRuIbUxyUSiUQikUgucoRoYu++aDBQMGnWjN8dPUrxq2tXxijz8XF8PK2rZnUIUfD0aXVSJzKBJiWpQlJyMhMjjB8P/PijbdlvuYWi1vnzPKcQ5XJzVdfYH36o7FpbFSLj6YED/O3OvoBrbq/2LsQirp8Qq+xdiE0m1W1MCI2KwjoKCKB1nU6nuiGL68jMVLO7hoYCw4czYUJoKAW02Fie5+hR1p9wR/7hB4qB/v4sa3KyrWtqeDifhUGDGB9w0CBmaQ0Lc/wMiDpp1owJPFJTKZwWFbH8/v7q5P7MGZbjmWdUN+devXiezp35jGjj+kkkEtfZv9+97UaMAN59l+2+Tsd2S9smiuQy4m8fH4p2H31U2R1fIpFceKTFnEQikUgkEkkjQIgm331n6744cCAnZSaTajklXDBdyVBaHfaWVM2a8Xd6OgVCnY6xxAIDOcE7c4bxi1q1Ui3nTCZu4+lJt0fh+iistwwG9xJAiIynhw5Vn222ujqtyu3V3oVYG9fPaOT1al2ICwoovkVGUizs2JF1lJFBkcxgoIVh06Y8R0qKmqQhPZ2CX58+rLucHH4XFMRt7RN8VJd1NzbW9Sy19hQXs4wxMXSvLSmheLhtGyf+RUWq6BYXB0ydqt4PkehD61YrkUjcw2Jxf7vhw4EbbgDuvRfYuJELH2Vl6rtvtaqx6PR6/k5NZRty660U1j2lOiCRNAiN4tWzWq04e/Ys/P39oXPkjyGRSCSSiwJFUZCXl4emTZtCL00kJJI6pyohyWpVPz9zhlZqrmQodfW8QhT8+2/gxAmKSQaD6kILUJBp1oyWcZ99xsDkIguq0UjLqrw8ijwArf2Cgmi5UZVrrRaRjCEjgy6m1WWbrY6q3F7tXYi1cf1CQznxjYri51qxa8QI4IMPWPfe3hTwjEaKb0Yj75XFwkQNFgs/9/fn8UQGVEfWeXl5qnWeK1l3Xc1SKxCJKzIzgauvVuMRHjrEMqal0ULxjjtsRVBX4vpJJBLXadu2ZtsZDMDs2Xx3166lMCfczHU61T1duNNbrcDHH/O9b9uW7cbw4XV/PRKJpGoahTB39uxZNG/evKGLIZFIJBIXOX36NKKjoxu6GBLJJYkjIcmZBVl1CQLcQYgvv/zCuETp6RTVvL1ttzMa+ZOYSKsxYRkm3F1TUmyTP4SGUsxzxbXWPuOpWK8V2WYPHmS22djYuhGFHMWia9eO137iBK3j2rWjoKYVu4SQ+c03wP/+Ryu3sjIKiUVF3D4sTHU5Cwqiy+nGjRS+RKIMZ9Z5jrLuOqqH6dMdW1k6ewaSk21j6gEsZ2goryEzk8LeXXfxGTxxgi7AAOPftWwpxTiJpC54+mlg7ly2D87w8eF29sTFAS+/zHZm/Xp+5uHB9sPDg22KEOyExbPJxHZj+nRuL8U5ieTC0iiEOf//H6WdPn0aAdqowxKJRCK5qMjNzUXz5s0r2m2JRFL/VGdBVlWCAHfR6yn4BQXRBcpgqLyNsA7LzQXee4/ByYuKWM7z5xkzLSKCVhtlZXTtPHmSFn7VudY6Eo4E1WWbrSn2LsTFxXQ1jYqiyJWV5Vzs0uloAefryzooLmZ9iFhziqJa3TVvzvKfPk031qAg59Z5IutudLSadVdRKJ6VlPA+HzzIenDHms0+pp72OoKCmKn1yBGKgu+/z4QeWVncJjgYGDAAmDzZseirteiUFnUSSdX4+jKRzpIlqguqaDMUhe/O2LGqha09cXFss1q3pqWrp6faZors0Dod2/DwcLbFEREU799/H7jxRunWKpFcSBrF6ybcVwMCAqQwJ5FIJI0AGXZAIql/RPKDRYsYoL97d1Xo0FpO/fADrSDsRRCtUCKEmIKC6kUT4d65fz9FOK3FnBCavL0puJlM3NbXFzh2jJO/7GyeQ7h/igmnKzgTjgTVZZutKY7ErehoimOOhCatWNqqFS1StmyhhZkov6grX1/WkV7PpAnnz3P/+Hjn1nn2WXdFhlxhiSjKsW+fasXmilBpH1PPnoICCn8ff8xny8OD1wZQoPvhB5Z/1ixVnLNaaQn4ww+sLw8PWvrUJCagRHI5sWgRfy9bxnZDJN/x8aEoJ753hrc3M64+/zwXBry92V5oM0lHRPC9LCxUXez//hv4738Zq04ikVwYGoUwJ5FIJBKJRHK5UZWFkXBd/ftvYNcuCj0lJRQ7wsK4TVUWZFrX19RUWmlZrZyktWhBscSZaKLX05Ljjz84oWvWTHW1zM3lpDE3l58JsTAnh8dv3ZrCTWoqRTovL1qBRUfTTVJbTkfX74pw5Gq2WXdxJG45ErscudsGBAD9+9OKcd8+XlfTpmryC3HPfHwYL659ezWhgyPrvK5d+busjPfw4EFOqAMDWad5edx25UoeSyuSVWW1Zh9Tzz5hxOnTnNSnpKjXJbLMNm1Ky5x//uH1x8YChw8DixcD69Zx4h8QoD5jNY0JKJFcTixaBLz9NgW2EyfYhs6ZQ+tVV3j4Yf5+5x22vaWlfJeNRr6Lwq3VaFTdXLOzgS++ALp1k++mRHKhkMKcRCKRSCQSyUVGVVlHAdUay2Tij78/XR7NZqBnT1XocWRBprXmKi2lW2J+PkWbtDSKamlpVYsm8fHASy9xgnj+vBpXrkkTTu7y8jipE6KPSGQQEqIKd1deyXIGBtK16sgRtZzOrv+WW2qeafRC4czdNiwMGDyYdXH2LOunRQt1G1H+Xr2AZ56xtcazt87LywOeegr49VfWT0kJ695komtaSQkTSxQXqzH3Dh+uPpOto5h62oQRRiOflfR01XVWr6fVX2go76XZTMF440Zg1Spg82Zu26oVn4HUVJa/Rw8epy5jAkoklxqiLczM5PuXmcn22x1r04cfBiZMAFav5oLKihUU0kXsS19f28ytRiO/+/BDZlyWsSMlkvpHCnMSiUQikUgkFxFVxYxLTqagIqyxzGZaSOn1FH6ES2NoKCda9hZkWmuu0FC6F+bn83sPD/6dkqJOwqoSTYYPp9iybBnPabXS3TI4mCKQVhyzT2Sg19N6SsRH05azuph5w4bVXbbZ+sCRu602/ltsLC0IU1J4/Y7K7+np3DovMRFYuFCNX2c2q4JZUREtaZo04aTdYOD2GzcyEUV6OsUzb2+KZP/7H7B3LzBpEnDttaw3+5h62oQR/v7An3/y+vz9Wc7ycp67pISTfYD/r1nD51Wv53V5ePBHPKeHD9MVt65jAkoklwqiLRTvrY8P39vdu923NjUY1GzKR44wFIEQ4bSiXH4+t83OprD+zz9898eN44KMRCKpH9wW5v7880+8/fbb2LVrF86dO4fvvvsOI0eOrHKfTZs2Ydq0aUhISEDz5s0xc+ZMjBs3roZFllyO1DZgsAw4LLmQyOdNIpHUFEdukIrCz0NCKJSYzcDAgfwuMFBNEBAWRrErI4PbBAZWtiAT1lzR0cCOHaoo5+XF7319VZdUb281gYAz0SQ+HnjzTds2z2plRkCtu6m2nELQMRr5ndbSLToaeOstx1lX4+JoifXrr5xc/vUXxZ2qMo06a4/rs522d7e1j/9mtXLiK9x33cmWq30+evWiACeSL4gMr35+tEYLC+P5zpyhAHviBIXRo0dZtvx8tf6PHgVGjQJuu02Npzd6NIW7lBS6K/ftqwaiNxjU2IAi02NhIa3hTCZ+fvo0n9lTp9TnS5RTPKcWC8tc1zEBJZLGjnjXT5xgm5yQwN8GA+M65uXVzNrU05OC3tSptNwNDOT+paVsE8rLeQ7RRhw7xp8//qCVtMzWKpHUD24LcwUFBejSpQseeOAB3HbbbdVuf/LkSQwbNgwPPfQQli9fjt9++w0TJ05EVFQUhgwZUqNCSy4vqnLncWWVqLb7V4cUDSVa6vt5E8jnRiK5NLF3g7QXdQoLacnQsSMnVDod2xizmdv6+VF8EYKPvQWZsOayWHhMDw/bzHseHhRqhLtpVlb1ool97DWrtbK7qSinsBSLiaGAYzbbWoqdOePYDVTUw9mznKCePk0h6/77GSfJUTvorD2+4gpai9RXO62N0xYWBuzcyfsWGMi6Fq6/Xl7Mluus/I6wfz4iI/kjrNHKy9WJNcDJdXk56yI1lfddTLrLynivPT15H7ZsYf0PGwZs2AD8/DOFVBELMCREzeCYkkILOQ8P9f4aDGqMwdhY7hsUZGspKTAY+FyZzfUXE1AiacwkJ3Px5ORJtptC1Nfr2b4HBfHdqYm16fDhbA9mzmTbVFjId9lgUEX3wkK+90FBbCeSk4FXXqGVtLSck0jqHreFuZtuugk33XSTy9t/+OGHaNWqFd555x0AQFxcHDZv3ox3331XCnOSaqnOnaU6E+7a7u9K+S5m0dARrgo6Uvhxn/p+3rTnudDPjUQiuTBo3SDT0zkxE6KOlxdFjtRUWosFBVH4CQtjXDkhXBUWsu25+urKFljCmisnh2IJoAoswjJPr1e30evdF02cxSkzGCjAeXry99GjlS3FDhyo7AaqrQeRbMDPj0kUUlLYttpPTJ21x3/8ASxfzjLFx9dPOy2uPzmZbp8lJRTPhGAaGKjGV/vrL8cZc51h7yYbGMj7LywmFYXnKClRLRGjo+nKWl7ObU6f5iRfBI8XljHNm9M65/nnKf7m5qr3v7SUcQctFlrPBQaybvPyKMQBvD8WCyfuPXoAX3/NY4eEUIwMC1PF1tJSPnOZmUyK0ZAxASWSixGzme2nSJRjtarf6fVqllazuWbHHz+e/cVvv6kxSQ8dYrtfVMRjl5fz3bVa+f+RI8C8ecBHH8k5gURS19R7jLlt27Zh8ODBNp8NGTIETzzxhNN9SkpKUFJSUvF/bm5ufRVPchHjyJ0H4KC8Y0d2VlWZcNd2/+qob9FwyhR+VpfCmKuCjhR+3Ke+nzfBhRL/JBJJwyCEs/x8tsGFhbaChrc325XcXLYHIpZcWBgFkL//Btq1cx6wu0ULxoBbt47iS3Exj6XTqeKcr6+aUCAurmaiibM4ZQMHAiNGOO/f7N1AFcW2HkpKKFAGB1McctS2OmuPhcCUmUlRymLhtZeWMjZaSkrdJSKIi6Nr6I4dnNxmZVGQ1GZhNRrdj69mXz/2FpMifl9pKesmNJSZcb/7jtecl8d9tXGlPD1Zr6Wl/F7EhfPyUt1SjUZ+V1bGa2nXjvfg1CnVJdZg4GfNmtHaLimJlomRkTxeejrL7OXFe+DtzXvf0DEBJZKLEbOZYrgQybQWxOXlbL/S0mouzOn1bKPOnmVb6e3NcxUW8vhlZXynvbxUN/niYuDHH4FffgFuvLFurlMikZB6F+bOnz+PiIgIm88iIiKQm5uLoqIi+IhlNg1z587F7Nmz67tokoscZ1nNAP4fHV31gLa2+1dFfYuG27cD06bRXaSkpG6EMVcFHSn8EHctBl153g4eBLZu5WSyJrGOLpT4J5FIGg7hBrl5sxrwW5u1My+PfVZBAXD8OK2ToqLU5AExMcBDDwGtW3Mf+/aloIAWEMJazmpVLTFE7LDych67TRtg7NiatyciVpk7banWDVQkt8jIYD0AFNKiotR6cdSXO2uPT57ktiUlbC+PHmVZTCa1Xd6+ve4SEUREAG3bUpiyWChuae+no4y51WFfP0KU7dmT13b8OPuE0lJaInbuTJEsL4+WMAYDJ9fCfVlRWDYvL1W0FK6r2kyNOh0t44qLuZ3ZDAwZwjh3mZmqq5uIT9iiBdCvH91jU1LUOjabKeT5+DBD7aRJl8eYQiJxl7w8CmXl5Vw00babVis/LyqqXXxG7QLK339TlBPWrAYD25LCQlWUVxS2x5MmAR98wEUWiURSN1yUWVlnzJiBadOmVfyfm5uL5s2bN2CJJA2Bo6xmWqob0Fa1v6Kwg0lN5eDdXWu0+hQNMzLokmI28zhiAlYbYcxVQaddOyn8ADWzGKzueS0qYua7N9/khKQmsY7qU2yWSCQXB8INcu9eWrT5+LANF4KHry/QrRsnZVu20GIiL89x8gD7tsxopChXUkI31//9T40tBKjuSsJC6sor68at0532yN4N1tub1+7tTaHS15dtZFXilqP2OD0d2LWL1+vpyTa5uFjNXFtSQsHo/Hm6yNZFG+rvz/sn4rPZY58x1xWqchMODqZoOXo00KULj//BB7RqCw7m9ZWWcvxjNtOCzmrl/Q8KUq1ixHnEcyEQCTvKy/lsZmVRCNbrWZ7SUh4nPl5N8NC/vyoYGgy8dy1aADffrGaBlUgklUlL4/spEgApivqdaKetVm5XG8QCSlISY8j99BPfcW9vtpc5OerijRD0U1M5HwGkOCeR1BX1LsxFRkYiNTXV5rPU1FQEBAQ4tJYDAKPRCKM2QqzkssTeXcOe6ga0zvbXBpAuLGSGsd273bNGqy/RULjslJZywGwwcGDsSBgDXLdCcFXQ2b5dCj+uWgzaW6GYTM6f1/R0Wsrl5tIKsmnTmsU6qu1zJ5FIGgdxcbRIOHqU73N+fmU3SLMZ6NoVmDy5shUu4LgtO3iQMc10Ooo1xcWqBZfVqgYXb9uWbZKwgrrQ7b0jKw6dzvb6BY7GAs7cYUtLKZKZzbxOX1/2scKF02plPW/ZQuGotqKRI+s2gTYTrbuuws7chLt1U4VZqxV44w3e/+7dKTwmJakuaiJiTFgY6yA6muKdsOzT67mtNjGIsNzx82O9FhQw5pS3Ny00y8poZam9zrAwutO2bMm+8KmngD59pCAnkbiCXq/G/hRWzuJzvb7yWL0252ndGnjmGba5x4+zrRTtokjwIv62WtnujB8PzJjB9kgknJFIJDWj3oW53r17Y926dTaf/frrr+jdu3d9n1rSyKntgNbR/toA0hYLO6GYGPet0epLNBQuO76+HABr9WmtMLZxI7O8uWrR5aqgk5p6eQs/rloWWq3A6tW29R8by0nN6dO2+yoK71lWFreJjuZ3/v6q1YLIyCcsDJxZJ9b2uZNIJI2Ha68Fbr+don6LFny3hYim7QMdiRyO2jKxKCUspMrK1GN5etLd0suLCwhXX00x5ciRhmvvtVYc8+cDx45RYNJeq7OxgDN32JAQ9nNWK69VZBT18lIz3oaEcOGupmEu7BfMHFm3Cbdj+4y5NakfZwt02gU5vV6NQ1dYyM+E5aTFAjRpwrhwZ8/yd1YWtxXjAfGclJTwWIGBwJ13Avfcw2vx9+f2r73mePyg03FBKj+f+0pRTiKpHtEmFxZW/k6EIPD15XZ1RXw88OSTTEiTk8NFCyEClperAp3Fwu2zsrjt++9ToHv44bori0RyueF215ifn4+9e/di7969AICTJ09i7969SE5OBkA31Pvvv79i+4ceeggnTpzAs88+i0OHDmHhwoVYsWIFnnzyybq5Askli3DXCA3lgNZsZkcgshRVN6C13z8nRz2OonBw2LGj+jsjQxVdqkMM+k+frmxanp0NJCSwo4yOdm//khJOloqKWG4RU0dgMtFkfckSTjhCQzkwDw3l/++/TxHIHq2g4wgh6EREuLbdpSr8uGJZuG0b8MILwKZNHDC1b8/637uXEx0PD9vn9cwZrjyGhNi6X5nNjMsTFsbf2uC99taJAmfPDaBOUGsaqN1q5QT4wAH+duU9kNScf//732jZsiW8vb3Rs2dP7Ny5s8rt58+fj9jYWPj4+KB58+Z48sknUSx8ziSXJHo9hbmYGLYROh0nRq70gfZtmdZizNtbdQ/V67kAZLFQ3PH05ERP9AMN3d4LK46HH2Y9JCa6Nhaw7/8zM3m9RUXcV0wuhXuYyD5oNNLqIztbtRRxtV1MTKSF2ksvAXPm8Pcbb/C7xx+nW3BmJsXOzEyKibWN2SrchDt3rpzow35BTsShCwjgeMhiUe97QQHrs1s3lrt7d977sjIKtcXF3K60lHXUqRODxrdurZ47MPDyHj9ILi0uhj66XbvqrdCMRm5Xl4wfT9G9SRPbpEBCoNNa7gFsF8+coUC3aFHdlkUiuZxw22Lu77//xqBBgyr+F7Hgxo4di2XLluHcuXMVIh0AtGrVCmvXrsWTTz6J9957D9HR0fj4448xZMiQOii+5FLHmbuGfRwdV/b/+2/gxAlOOpo2tXWHcddN01GMl6IiDt7PnOHkxscHeOstx1ZszmLElJZy8BoUZCviCPLzudqv19OiwdUYcK5aH/bqBfz5Z9273TQWqrMsLCykpaJOxwFLaionfh06qPUfHU0R7sgRPq9FRbw/ffrYul9pLRWys1W3IoEj60Rnz01trS9kFt4Ly9dff41p06bhww8/RM+ePTF//nwMGTIEhw8fRnh4eKXtv/rqKzz33HNYunQp+vTpgyNHjmDcuHHQ6XSYN29eA1yB5EJR0z7Qvi3TWoxZLBRmAE7qSkr4u7CQglFMDNusxMS6ae8tFoZJSE3l4k+vXrbukY6wtzyLjXW/Hhy5w5aUqDHfRNnEIoeXF8cGwiosNRVYs8a1djExEXjvPZY5NJTX6elpa43/3HOuJ/lxJ1mGM5xZWFss/C4oiNd+xRV8Pvz9GSsqPp7uqIsXM2nEuXMsi6ifG290nLChvtx2JZILTWPqo+0XaesCvZ4JhJKSgF9/pTgo2kVH1nseHmy3Cgq4GDFhgnRrlUhqgtvC3MCBA6FU0QosW7bM4T579uxx91QSCYCaZXVztP8vvwDz5qkuh/ail7tumtpB/44dwD//cMAbHc0VZF/fql1kHU24jEYObAEO7rUoCsUegNfgTgw4VwUdT8/6c7tpDFTlKpqezphwIiNiSAhXDUWijp49WV+ZmcBjj7GO8vL43eLFnAxqMRpZ3wUFakBtLc6sC2orVgvE5G/PHmDZMg62WrTgT2Hh5ZeF90Iyb948PPjggxg/fjwA4MMPP8TatWuxdOlSPPfcc5W237p1K/r27Yu7774bANCyZUuMGTMGO3bsuKDlljQMNekD/f3Zppw9ywmSyKjn6alaZZeXq+5QpaX8HRxMV8bExLpp73/8kZbcx46pmT7btmW7Mny4430cJayIjGSGz7vu4jbCfTI6mn3TgQOO68XeHXb/fgqUZjPrQCQ/KClhm+/jQwuxsDDg00/Z7jdvXnW7aLWyjd+8mec+dYr1LCza09O5YDZ9evWLfnW5SGIvlAE8bmEhY/VlZPC3+O7gQeCHH3ieuDiOl5KSgMOHaakfFsbj2VvmCepr4UgiudBcLH30kSNqMhZnFBdzu7Zta3WqSsTFAa++Sg+gM2dss3drERZ1gpQU4PXXgZkzq1+AkUgktshXRtIocDerm6P9O3RQ4zU4CpZaEzeLuDiakM+YwUF+XJya2QyoPpOpowmXyKLmaGDr78+O0c/PcXmqEhddFXTqSvhpjDhb8Rdx4rKzKbiGhKguYGFhauymXr1YXwUFFGcB3i9HVoiBgaplXfv2tm7LVVkXWK2cPA4bBlxzDZ+JwED3xGox+du+naJyfj6fneRkPnNaC8DLIQvvhaS0tBS7du3CjBkzKj7T6/UYPHgwtm3b5nCfPn364Msvv8TOnTvRo0cPnDhxAuvWrcN99913oYotuYA4s5hypw8sKKDF1+HDfLcVhe2UcEcSwf09PFSRzmhkchqgbtr7H3+kGGU287i+vizX/v3A1Kks3/jxtm2LfcKKwkKKbn/+CXz7LV0oe/akAFRURKv06kQsrTvse++pAprIzArw2gMCKGQ2aaL2fSaTY8tobbu4cSMgQimHhHCMoV20iY93zRrf1cRDrmIvlAUEUGDz9lZj2Wot8+0X9kS9tW7t+jkv5/GD5NLgYuqjRRxIQHW9F2jjPp4/X6vTOKVzZwr0jz/u/BweHuw/ysvVz+bPZ2zUqhZgJBJJZaQwJ7lksZ/cCMGhrt0szpzhwL1Tp8pWVq64yOr1PKe2rFOmcOC/axcH5iYTY7706AF8/rmtRZeicPBfUqK6JDkTF7VCoNmsns/Hh/UlJki1tVJsrDhb8T97lnHimjRhfZeVqRZuImFDRgYnYvbiblVWBF5eFNVEwPXqrAuqsqZwR5R7/326dScnc2JqMvH+i7hDWgvASz0L74UmIyMD5eXliIiIsPk8IiIChw4dcrjP3XffjYyMDPTr1w+KosBiseChhx7C888/7/Q8JSUlKNH4R+fm5tbNBUjqlbqwmEpM5OKOTsf2payMVnNFRbSMM5n406yZmgQiJYULBPPns52rbXtvsbCdMZsp7Oj1bNtyctjWnDtHi4qUFOCOO9QsotqEFRkZqgtqVJQal3P3bop7ACeDropYcXEUBL29KaQJSxSRYTA9nfUVHExLsZAQLoI5sowW7WKLFnR3LSpiGyksR7SLNsK9tSprfFcTD7m7SKIVyrZtY/03aeI4u21dJXe6XMcPkkuDC9FHu9o/Z2aqfzuKK+xou7pmxAj+njbNNuax1lJOK8oBbM/++ovtrdWqHkMikVSNFOYklyTOJjdXXFH3bhZVxSUTIk5qKsviaHDqqKzBwZVNxq1WdTAtxMWMDO6XkcHzFBTwe2fBlwGev6gIWLu26slfbawU6ypGTkOc09GKvzZO3LFjnKSFhamTJ+EqduYMMGhQZXHXmRXBwIFckdy/v3rrgrqwphCTv/R0Pi8ikLdwsy0sVOOEaC0AL9UsvI2FTZs24fXXX8fChQvRs2dPHDt2DFOnTsWcOXPw4osvOtxn7ty5mD179gUuqaQ21OU7npHB91f0EWfPqu2VxcL2y8dHTYgQHk7BpkmTuhHht29nWxkeropyKSnqokZAANubjRvZnj7+OMsjElYAqtultq3Ny2P7uHEjP9MuSlQlYon+wWLhueLjgaVLgZMnaTFcVKTWR0oKren8/Kq2jM7L4zFPn+a2FoutS5dYtDl/nvValTW+o8RD2kU3f39eV00WSYRQtnUr8OabvCciO7gWe6+B2vSptfVykEgaE+720a72z76+rp3f1e1qyogRQKtWwBNPAL//zrZJZLS2TwQBsM3Q6dh+TZzIOHVdutRvGSWSSwEpzEkuOaqb3Awb5poQ4irO4pKJQfzZs5xcLFnClX6t+OWorMnJjPOi0zGmTnw8j71vH8s7bBivY/t2TmjKynh+kWkWoLWEs0lcXbvLODr+hU4kUNfntF/xF3HiTCYe12zm/Q0IUEW5/HxO3pyJu1VZEQwdWvUEqK6sKcTkLzAQOHqU++fnc7VTxLkrLKQ7tjMLQEntCA0NhYeHB1JTU20+T01NRWRkpMN9XnzxRdx3332YOHEiAKBz584oKCjApEmT8MILL0Dv4KbPmDGjIjkTwBX55kLxkFx01PU7LgSesDAuOh0/TtHJ05PtV2kprSw8Pbng064dkJWlivC1XehITWXf5OvLvkksHvn6slwiiHhYmJoRfehQdZFLJKsIDKy8AJKVxTZLp6OlcVCQel5HVur2/YNw/fLw4L4+PixXcTGPLf7286OgJo7ryDI6L4/HiYzkNWtFRIDW0Hl5apw6Z9gv8InxQ0YGBT9R9/v21Uzw0uu5sNS7N/t6e+y9BmRCIMnlyoXoo13tn+PiKruw2qPTXZh3snNnzh1GjWKIBJHd2hmizOnpdGddtEi6tUok1XFZC3OOXB3PnJGm940BZ5MGVyY3Bw4ATz/N7JruZIlzhqO4ZOnpjN1VWMjOq3VrZrrTil+xsZXLarVSMAH4/5kzHITbl/+RR4CnnuLkRbghikyzoaHOJ3GO6kdR+HlICINWf/stY+bV5Nmvb9HvQp5Tu+JvHyeuZ0910pSbS3GrZUsOWOzdgqs6pqsTX0fWFILq3KXFecxmYO9eTkhF4orQUE5C8/M5ufTwUDNvlZY6twCU1ByDwYBu3brht99+w8iRIwEAVqsVv/32G6ZMmeJwn8LCwkoDe4//N81xlozJaDTCaJ9RRHLRUpt3XIsjC26dju+6nx8FFg8P4Mor2a8YjRS/cnNVsakuRJmICIpShYUU1AoLeS5xbaWlqrVFcDD7rP791UUukbXay0uNoyQserWPvH02a8DWJdO+f/D1pcVHSgqP4+3N9k2nYzuYns6xgIcHBThtzFhHltHJyWzzW7Tgd2LBxmpl3eXm8pw331x9sg7ttYvxgwh1IATJlSvpclzTPu2WW1jX27axPiIjeR6t18Dhwxe+H5dILhYuRB/tav8sYmGWljrfxtPzws1V4+OBVauAceOY8K601LFoqNOp8wtF4bjzlVdodRcff2HKKpE0Ri5bYc7RCqpwZTAa5ergxUxVkwatK4yzyc327cALL1CUE/v/+WfN77V9DLFmzfjbbGaHGRhIMScwkAN2IZrdeadtWdPTOfBNTOQxxUQhKooDZq07S//+nPg0b87JgphcOQviLLCf/NmvyovYPz17AoMHu1cP9RUj52I4p6M4cb16cbCRmMh7EBQE/Oc/LE91bYe7E9+q3KUB57GBxHl27GBMuZwcbhMQwAGVl5f6bBUWqq4JRUWciFVlASipOdOmTcPYsWPRvXt39OjRA/Pnz0dBQUFFBrj7778fzZo1w9y5cwEAN998M+bNm4crr7yywk3mxRdfxM0331wx+Jc0bmr6jtvjzII7MJDvuhCSwsJUSzOttZRIPlRbUaZXL2YJPHiQfZXVqrp5lpQwkY6XF0UgsSiWnq4ucjVtqlr35eayDMXFFLlOnOAxvL0rZ7MGVJdMkwn4739t+4ecHParoaF0Y9W+Pp6ebMtF25eWRov3kBDnltHahbkePWgVn5TENlQk2oiPZz9eFdHRrKe9e3l+rQuvECbbtGEd1LRPS0wEVq/mdZw7R1djk4kLh7168ZpiY4E33riw/bhEcrFxsfTRmZmqi70zfH3rN8acPfHxjHW9ciUX8v/5R40xJ9oLIcwBqnB36hTw2WdsX2TbIZE45rIU5uxXUIuKgC1buBoZHExzf19fuTp4MVKdddSNN1Y9uSkqYidSVMRkDXW1EqyNIfb335w4+PqqVmwiwLLW8kGkQTeZVAu77Gx2WCYTO7qcHOCXX+hOo10V27WLA3VtsGktziZx2smf1qpPrMqXlHAisngxt4+IcN16tK4sPhzhzLqsPs9pj6M4cSUlvE8REZyEuvI81cTCz9lkW+Aoo7A2ycO5cxReQ0N5/81mtf7atqWYnJ7O589o5OQzLg54/nnZ9tUHd955J9LT0/HSSy/h/Pnz6Nq1K9avX18RbDo5Odlm9X3mzJnQ6XSYOXMmUlJSEBYWhptvvhmvvfZaQ12CpI6pyTvuCGeZpXU6iilJSWr8UovFNsbqiBEUbjIy+N7n5vJvo5H/Jya6Lsp4erItmz6dbaXFosa1zM1leZo1Y98orMG++QYYPZriz8GD3CclRXV9NZnY1ubksK0KDa1cV1qREajcPwhLPGE5WFzMH51O/dxs5mS4SROOCYuKVHGwQwfbdlG7aHP8OPtT4QIrXHf9/KoPL/HddxwTHD7MSXZAAPf19FSt7uLiKBDWpE/T9jtt2tAt7dw5NT7eiBE8flLShetTJZKLlYuljw4LY7tUFWVltklcLgRxcUzec/fdDEFw9KjqtSQMC4Q3jvhfr5dth0RSHZedMGdvYQMwZodwN8zIYAPTr5+6Ovjtt8CYMRyUSRfXhkMbuL5ZMw6WrVbVIu3gQQqsRqPjyY2i0A3UYmGnIr6vq5VgEUPsl1+YXjw2loN6+8GtEM0ATgLy89Ug16Gh/N9qVS3YhAtQy5b8LitLDb5qf50iWHRmJve3FyjF5C8/nx2k2cz9FUVd4fLx4TvxzDMUbXx8XLMeddfiw1VXzqqsyyyWurEycRX7rLZffklBMz7eNcsCZxZ+/v4UcRMTgU8/BV5/3da12tlkG3CcUdg+yYPFwoDfOh2Pe+yYOhFNSuJky9ubVh3BwWwLZ8yQLgf1yZQpU5y6xWzatMnmf09PT8yaNQuzZs26ACWTNATuvuPOqCoLdHo6cPXVdF/MyuIijNFI96K+fSl2JSZSBNqyRbWk9vRk3+SuKCPiCb3/PhessrJ4LZ6ePGdYmK01WFoa8O9/s0znzvGai4r4f1AQRTnh1uXnx77p4EHbBQ6tS6awstP2D0Yjj2G1qsc6c0btby0W/qSmsi3v3p3HOH2abaijdjEujpnUn3yS/YKfH4/tSngJe8HMYGBii4ICCn0iUYM4TkYG2+yffgKGDOF9qG684qzfad6cxz54kHFt4+LqznJTImnsXAx9dHi44+QKWsrKuN2FRq/nHGHCBHohaTOzClFOp1PDEYgwL7LtkEicc9kJc/YWNjk5aoBhvV4N7ms2cyDo60t/+l27ONCSLq4NR3IyLbyEeKqdMHTowAHmuXOcdCQlVZ7c5ORwAB4dbRssGlBX7//6i8Jahw41E2D1eu4bGcnOyFFgVGH50L49t928mROmwEAOyn19uUJeXKw+k6Wl/BETGA8PimvJyaooJNxSheVTaCjw1VfA7berz6qY/K1fz9V5i4X1otfzvGJy4uvLc4nrcGbNpRXXzGbnoqj2ut2JYVSdddntt9eNlYk7iDhxSUmcvIn4RFqcWRY4svDTuhMXFVE0UxTggQccW2W4klHYPsmD1s3ZZGKZU1M5gczNpZAbGGjr0iTbN4nkwuHuO14VzrJAiyRHYnFh3z72P+fOAcuXs/05dIhtflkZJ1ImE8957hz7lfBw9yZWw4ezvZsxg2Ek8vN5/IIC9t/CqiwyktbsZjPDKLRowX6qoID9jI8PyyeSVVx9NfuuVq3YljlK5JSUVLl/EC69586pCShE/6fX89oMBpbT25vH9vVlBu0ePViWpKTK4wNhzedqeAlxnA8/pItX9+48XrNm/PHwYNscGkrRNDMT+Pln1Srv+HEmlBowAJg8uer22h3L8rqy3JRIJLVnxw7VwtkZViu369DhwpTJnqeeYhiXAwdYFiHIeXiwLbRY+Dsigu396tV0+e/bl2NOaegikahcdsKc/WqgNsAwoMYRKSnhhPnAAU6YO3XiYEoGwG049u3jwF3E8xKTh3PnOJjv3p33rV8/DqrtJzeJiRzUd+5ceXCans7tT5wA3n2XHUhNBVh7yweA5SspYdlTUoBu3fg83XorY8pkZ6urSUYjty0t5cDe05P/Z2TQPUa4s5w4wQHywYPc959/1BTl4eF8ZkUmV/Gs6vXAFVcAn3zCMgkxsKyMA//yclpMCYsKi4XxdRxZgNmLa0YjJzFpaRR3nFl8uBrDyJX4cTt3UuDct692ViY1oSYWgocOsY4CA9VMhVp3Yn9/1t++fRQktW1MdZNt7XMqyubtbdu+CQIDec+7dOF9HzOGz7xez/qUbgYSyYXHnXfclWM5ywINUORav962HU5JATZtUsUyDw9VtPLz47YlJexvXOXHH4E5cxiPUwg+ZWXsc/PymA32qqvowiks4QwG9kVGI0U40fddcQWPIdqv5GT2VT160HKjSRPba3RkhajT8bPsbI4ThJuVsL4WbmPCijwqCujaleOMzz93vpAkxo2uhJcQfefff3PRVyyECau4sDCeT1jQJyVxu7Nn1WQZUVG8hh9+YN3OmuX8+XCnr4qPrxvLTYlEUnvy8mwt0RxRXt6wVmiensCrrwJTp7JNtlrZhuv1bK90OnVBvqQE+N//uJ+/P61+ZcgUiUTlshPm7FcDhVtDWRn/Li1VAwALoaNJE4oTHh7Vu5xJ6gerlSv7FgsHrSLgs9HI/4WI2ro1xYb27StPbrp25YTC19f22CLWmshw2r591VZi1aG1fBAWArm57JCEFdq4cdwuLg6YNIlWTRkZfN7KymyD8IuU5JGRvAYRc8JoBO64g8/pqlW8juBgfi/i2imKraAGAPv3c0W+oIDHKS9nWQIDaYGg06nvgahn+1X1oiLHlmxpaRy4b9/OQb29xYc2hlF1gaVdWeU/dAi4/37e46qsTABObmqScdmZy607lgXaidihQ3w2RDY8bZDv4mI+o3FxnITZuz5VN9kWiLKVl9u2bwKR+MHHR3UH+/33mmdglEgkdYOr77graLNAa3G26FFaqsaCs1gokpWWsl0/f57b5OfTymvCBMftg7a9PHeOmfjOnmXbbLWq5/DyYl/s68u/MzL4txDkALZdFgv7JtGeBgVRxNu6lYsKhw6xDWvbln219nqdWSEaDGqGWh8fNflNWRnPGRTEH4uFiyQbN3Lf+HjnC0mu9gepqYyll5HBMphM3FcsMPbsyfZXJL2wWFj28+dZN/7+7Dt8fVn2tDSOAb77znkYDnf6KlctN4Ga96kSicQ1ROIEEYZEZDkViwzahYSGRIQtmDmT493SUrYHIgxBVhY/E3Mbq5Vt4H//yyQ8H30kx5sSCXAZCnP2K6hat4bQUA6ERPas9HT+Dgvjdq64nEnqh+RkDkyjo9UA9dqg1v7+HDT27asOEO0nN9HRwFtv2a4EKwrvaUEBJwcixpZOV7u4c3FxwLBhnJSkprK8QkT08wPWrqVLalwccO21wDXXcGDt56dayZ08qbqWtmkDXHedWgYxkO7ShRaAu3bxd3AwB965uep5mzVTBTWA19utG89x+jS3t1o5OcnL47OdlcV6DAxUr0msqpvNLL8jca1XL4pyAL+3t/hwJWuuKKurq/wREVVbmQDMAuVqBlQtVbncxsa6ZlmgtRCMieHze+YMrzE7W60LMVAJCeExtPetRQv3Juqindu9m8c7f942w59o586c4f308uI+dZUMRSKR1BxnglpNsV9cENa72nZYUdQA3sJqu7CQ7Z7VSlHIYOD++/dXtugFbNvLoiL2nykpbFu8vXkOf39bK+KMDApsIjFE06ZqvyPGZiEhqkXa4cPAhg0UCJs04WJcYSHPNX069xOTRMC5FeKVV7I/at+e5/37b7bHYWFqWTMy1GQ5kZEsuxhv2C/QuhIjsGtXNRxHx45q26vXqwuMhw7R6r9nT1rTnz7NHyFQRkaqfaJOx8/MZpbfWew/d+MXVme5Cdj2qUYjy9WvH8ckUqSTSOoGEVdTLJjYIwS7/89J0aAMH84EfF99RWOBjAy2lSKOu2gTyspsExBt2cKFnk2b2MdIJJczl7ww58jaRawGJiRQTAgO5sDj+HEOANu1ozCRlUWlPyyMIsnBg665nEnqHjEo79yZA9D0dN47g4GDarOZnVPfvmrj72hyY78SXFbG1fzych6vQwdbwU8rFLkjjlitnLy0aAH07s0yipgzQGUrNtG5CgFPWDOJ7JlaIdJ+IJ2QwH1jYvjM2gftDg7m/mIyVFxMATAujs/w6dPqxKuoSH3GtXUBqGJgXl7V4lrHjjz/5MnquyLq6sAB111qTCY1OUFIiG28Hm15/P15nx1ZmRw+7H4GVIEr2VOrsyxwZCHYsaOahbCkhFaKVqtqEQFwgCLu2759HOi4IyxqrR7y8vgcpKbymSou5vPl4aHG0nQ1eYVEImlcOFpcCApi2x8To24nLLR8fdkW5OezLxBWt0JAEtlB7S167dvLsjIuGFks7K+NRraPoaFs94qL2d8YDGwzCwpYLm2/06ED28fTp/lZXh77t/x8btusGcsWEMA+7cQJYMECTg61ngyOrBCtVuDll9W20GLh5FZY65WUsK/Ny2NoCBF7uKyM13ruHOsnMZHHmjCh+v6gZ0+6w4q+U7swHBZmG+M4NJSLJ+3bq7Fjo6Iqu8mKiWxBgXN3tprEL3RmuWnfpxYVcazz559MlNapE69TWlxLJLWnaVO2C1lZzrcJCOB2FwOenvRiufdeth1//MFxv4cH+5KyMtXiT2vlt20bRf2337ZdWJFILjcuaWGuKmuXYcM4uNi9W12F8PXlACUriyunIiPm/v38zGrlQNZorN7lTFK3CFcMX18O+oTlohAdQkJ477p0qfo49ivBqam8x8J6zT7luBCK3BVHhBtmixaOXUe0gh/A56t/fw6SxXX5+qqZ40SmVS+vygNpUTfJyRTphLAmYvCdOcNOMDWV7j7CpQWobCav16uus1q0YqDJxLJ4e6tZcbXbizoLDKSQ6ug+uuLus307BXERX8jeRdd+ld9eiHUlRp2z99bVfadPr9qywJGFYFgYn+E9e1iP6emq5UR0tBo/6cwZ/v74Yx7TXWFR+6zv2MFJq3DXbtWK1334MJ99regr4iEGBPA6ZWp7ieTC4mrG6upwtrhw6BDbg4gItgUA33mdjtvk5rLtUhS2SyKRkcjiHRSkinFi0cq+vUxN5WRMxE8TrqomEwW19HS2f4WFPL8IXB4aansNXl4U5wBaymVlsY0U4pJAWJ0dPcq+o18/2+M46h+EFVlIiG0sTmFVHBCg9sXZ2Vw8OXCAZRcuZaWl7AvOnGGct6r6A/ss4iLendnMY/r783iZmdw3LIwJjhYu5DYWS2VhrrSUv4VLrDNqEr+wuj41I4MJswoLKRqazfxs925pcS2R1AU9eqhZTR2hKBTne/S4sOWqDtF27NrFNqq8nD+ORDnB0aPAE0+wnRkx4kKXWCK5OLhkhbmqrF327+c2AQHAoEGqkp+Tw8For16MXxIczAbFZOKgqbycg5mmTdWBiP0AVU5g6wd7V4x+/RwnVHAlILF2JfjQIWY2i4mxddsUFBTwHCtW8FlwVRxxNzFAcTHL1LKlel0i5mFiIidRR49yImU/kG7Rgqvq//0vOzThsgiwbjw9+Yzv3MnMcsLFMSuLnWOHDmrcn7Q0/i4spBvNwIH8W4iBnTtToExMZHl8fNSsuELUrCprmysuNdHRNIPPzGSwbxHrUbgzR0WxvmJi2Hk7m7C6k4nO/r0V+0ZH2z5nAOtKK1qJ5ykpiZluATWBQkKC+hxoRS+jka7J5eXcRlj9iWsR9y03l+Lkbbep37lj0aZ91rOz6X4PsA5NJmDuXPUZ1brqa90O9u2T7ZpEcqFwNWN1dVS1uNC9O9uEXbvYjgqrbC8v1TVSYDTyWCLcQ2ysKuCJPsxRW2s0qha6ok8pKeH1iEyvZWXADTcAL75Iy6sPPlAtuoqKOA4TYRU6d2b/sGOH4+QKAI+bkUFRsDq0VmSnTqnhHHQ61XIwNpbtX2Ehz3noEBdihXW7dnL5118cS7zzDvDcc46FVUdZYsVCjTh2YSG/v/pqNYPu9u3sW8xm2/5d9CkeHrynVY1/RGbbYcMYOsPfn/faHdFXe58B/q2NkQrQmrFZM+cL1nUlOksklwPJyWxDq6K4mNu1bXthyuQOwhVXZGvV651nmS0vZxv5yCNsY6688oIWVSK5KLgkhbmqBqRxcTS3B2wnuwAHgwkJwJo1HDBccw3FDJGtUggyYoVYuFzYiyySuseRK4afH+v/zBkODO1dMao7XsuWvI+7d1MoCgioLBSdPq26/rnj7udOsGXAdtugINttDQZajE2axGfOfiCr11NM/vxzllmISKWlnGCYTCzroUOsq1tvZbmF67agsJAuO+3a8Rk/d47iXEgIxcDOnRlbTrjUZGVxoK8NWh0aWnXWtupcakJCeA2Zmeq76+fHCeSxYzzP0aOcNGVmMmDs5MmOJ6zuiqP2+wo336wsli8/n9/5+alZCYVodfiw48l0jx6qNaOwhhQuxqGhvN96PSdWpaW2983Tk2W0Wvm/9rmoTli0r/OiIuCnn2zLFxHBZ0WIz9rssF5evN7MTIrS7dtLyweJpL5xxX3e1fewqoUJvZ4LWdu2MTREbCzP5edHkappU7YBp07x/J6e/GndWrWw0/ZhjtrawED2yyILq0h0YzCwvUlJYRv29NM8LqBadCUmsu/JzVXbHpH0ad8+nktY4NmHN/Dycj3ekrAi++Yb9mNnz7KvjYpSM6SeOUNRrHlzLpIId16A1yPizZ07xxAESUm8HndivYWFse/7+2/2v1On2i7U3H47F6j++otlDA5mP5mdzbFpjx7sV52Nf6oSe90RxbT3WVjHaS3mDQZuU1rquH+qK9FZIrlc2LJFtSp2RkEBt7sYhblevdimiZjt1SWpEAYwQ4YAs2cDDz9c/2WUSC4mLklhrqoBaW6uGsfJ0WQ3MJBCzaBBFCmEy1l2NhtHvZ4/HTu6ZiEkqTtq4opRHdUJRd7enFS0aOGe1ZW7wZar2jYlhavnN9zgfBAdEcHJQEkJhSTh4ismGE2acHKRl0eB7Y471ICsmZm224aF8Vh79zKxSbduauKMjAwKlBERFHJyc/ncm83cPiqqepG0qvt49dW2MXgEubkc7Ht7s6wits0PP9CKbtasyvffXhy1t1gDnL+3qam0UlQUTsLE5FJR1MlfYSFFKw8PNRmG/WRauCr/739qdirhYnz2LO9HcLCaFEJ738LCeI8AltkeVxcEnE32T55k3YnMv1rLB0XhxKltW55buupLJPVLbVzvHVHdwkTz5mzn2rVTXSdDQ9UkA82aqckZPD0p2rVvz33t+7Dk5MoLUVo3TZH9u6SEbU5JCY//4ovsTwTCwnfrVuDNNzkGi45W6yI6mgJWaqq6oODtrdZfejqP16uX6/UeFwc8/zz3WbKECxLt2/N6c3NVK0KRDMPPT70WLy/WmV7Pdvz8efazQmi0p7rxRkwM8NBDlfePi2Mft3gxYzaJDLnBwbRqnzSpdrFSXR07afvUkhJb91/ANpu7ff9Ul+WQSC4XxNi3KsRi7sWIpyfwzDOMOZeXV70w5+HBtjwnh21es2bSrVVyeXFJCnNVDUjFBFenczzZ9fDgpFkEDg4LAwYP5t/nz3NQWFCgHlsMUK+8ko3JgQPSPL8+cRaQuDZ1XZVQ1LEjsHy5+1ZXYgCenMxVbpG8wNNTnQBpxSt3AzPb4+/PSYywOBPik8jQeuoUB9HiOrp0YYY4g4E/IjGFmAAVFvJY3bpRcExKshW7te43GRl89s+dY/KN8eOrH2A7u49a10+A15KYyHMI1ygRMLxJE1q1/fMP7539hFUrjoaF0apNWKyJzv/66ytb9lmtdB0yGPi3mFj6+fH7ggJOZDt1YlkXLGD5HVlUJiSwXgDbuBoizoZez2vq2pWfi/sm3MmEMCeERC2uLAhUNdmPj2fdp6ZSzA0NVZ8d4crVoQPrQbrqSyT1S21c7x3hitV2eDits/R6tR3ev58upX/8wXYgL4/nt1jYlh4/zrawdWtOmJKTVRfLgwcpLnl7qxZzPXowMUBwMC3L9Hq2/2PH2opyAr2e+/r4cHttXej17Hd++YXlyslhu1VQQFEuMBB47DHbxA+uoNdznNesmToOOHuW1zFwIBezVq1iHyIs6P38eG5tXyWoyl0zNpYWcGvWsF/28OC1VrfAGBcHzJvnOGRCVUmovvmG52nRQnUlq6nYq+1TmzZlPZeVqW69Itt3YCD/Fv2TxQIsXcpnJy5OzW4rEw1JJFUjDEnqaruGYMQIZq6eNs1xZlmBNvGery/bz3/9Cxg61P02XSJprFySj3pVA1IxwVUUx5Pd8nIOuiwW9TO9nsLbjh0cCHp4ULg4fpwTdJGh9eWXpXn+hcBRttXa4kwoSk7mwNZVl1RAHZQfOcKVrLNnKdAAzle4a2sN6MhCLz0d2LyZ58/O5iRi+XJg1Chea1yc6xZ9jsTusDAe02zm+5CSAtxzj1rWmsSSsX93zWYKW+J9FRMLT0/VwtVspguQ/YRViKP79wPr1/O9DQ7md8IF6Nw5Tra09SvuXbduqrWscF0tL2cZFIUTZS8vbjNokOPJdEAALXCvvJJthzZhSVQUJ4IHDvB8V19te4yAAJZZHEeLo3vkiOom+x07UogTVnOOrCctFumqL5HUNzVxva+qjXXValsr7CQm0uU9IIBtVmKimuyquJjnyc0FIiMZ/3P1arYvaWkUf9LT2d4FB3ObFi3YN/Trx34nIsK1vqCqMVz79vx85041m6sINfHYY7XL6FfVwl+HDlxky8/ntXl728Z6y87mdev1wBtvOHbXBNQ+vqiI/0dFceJ67bXV9496PQVRZxZ59mzcyPFLSQnvjwihINp2d8VegELrnj20kAd470NCWC9iMQdQn6+CAmDGDJZDUSgshoZyMSo8vGais0RyuZCdXbfbNRRTpvD9nznTuXWfNv6ciE26Zw/jWt9//4Urq0TSkFySwlxVA1J/f7742gm2fSDddu34W+tCIVZ+f/2VjcqmTfzc11fNGhYfL83zGzOOBD93XVJFDJUdO2jJZbFQfImPp8iSkaEOyO2pjTWgvYuMjw/FqtRUrlB5ePC8X39NkXDWLPes9JxNlHQ6umfqdKpVoLYenMWScfb9LbfY1ndJCcVNRVFjpfn5qaK6SMhQUOBYOIqN5STK15f75+errrCxsZxI2q/UiwlybKzqeiUyNAtrAxH/TaR/d7aaJywKQkJoYad1pQ0M5P5pabwmR/ehUye1PmtiSenKZN9kYpsXEeHYelK66ksk9Y+7cUlFG5qYSItXIR6NG8f+pjq3ydBQ1eItL4/fffONal27ZQvP07Yt29+zZ9mOCUvpZctUl0SRNMhkYntXUsKYoCkpTDZQlaulI6rrdw0GTvT692cbHhFBV9S6sKpwtvDXujUtrH/4gWNAnU6NCWo2sy3v3Jn1Itw1hTCpTTpWXq7WW34+F4aWLOF3rohzrpKYyONmZNC6zWjkvdHGhG3SxPVFF+3YRlixl5XxejIzGXuwe3fWycGDarKoDz6g5bfZrE68U1MpFA4YQKFVxmmWSBxz+nTdbteQPPYYLaqfe47tnjYJhF6vWv2JcbPVyjby6ac59n/wQWlRK7n0uSSFOWcD0uRkruaWlLABWL2a33XuTCFDJBEYN44xo+wHs8ePU4Rr25YDN2ENk5ysBjQOCJDm+XVFXWfvqsnxXJncCHFExFBJT+eg1WDg85STw06oZ08OXqt6LmpjDSis7r79FvjyS16rpyeFs/BwVUDeuVPNHueqlZ47AmV1sWSGDXMek018L+pbiGCig/b2Zp2L84vYGyaTY+EoOZmT1uuvt3XxFcKT0Vh5pV47QY6M5I+HB388PdX4a0YjnyV7C1stIgZPebkqYmoR7mT338/74ug+ADW3pHRlsi+sW5KSXBOfJRJJ3VOTNvbECbaLubls2/bvpwvqSy/RcqwqS+zOnVWLN2GdcPIkLeFyc20D++t0bHeLivh3QQEXLHr2VMMPNG3KsqanU/Dp1InteFgY+zp3cKXfve22C7foKcYOgwZRcDx50jZzrYcHr1GIkSYTxSdhneYo6ZjIgp2eTmuXo0fp4nr77bW/LhHCID+f90LERjYaeT/EuTt3dm3RJSGBrmgnT7I/9fDgBDsvT+37CgrYh4SH8/kaMYLP14kTfJ4sFi6QGQzsD3Nz+awGBbFccvFHIqlMdTHZ3N2uoRkxgq6p//oX41YLSz9teBeRwVWQng48+iiwciXw3nuOQyBIJJcKl6QwB1QekCYmcoBgNHKVzteXg9gzZzjA7NSJK64jRqiWMJs387uUFNVCp3lzbqfTUeQoKOCgMTeX5xGigTDPP3iQgYwDA2XsOXeo6+xdtTmeK26m2lhezZpxkC0GnEajOhDu169+3Tbi4oA776TLakgI3WS0Ljfh4bR8ENnjXLXSc1WgBKoOYJ6QUHVMtoMH6do5ZQoH9YmJFLasVg7omza1jeljNnOS0L27Y+FIWIz5+XE7exyt1GsnyCIb4LlzarIXkZU2IIDX7sjCVpQvN7fq78Vk+9pr+VNVXKKaiNSuTvZHjKBlQ01jHEokktrhbht74oRqgR0YSAGmtJTbzpnDRaD4eMdtfEEB33ft4khSEv//5x+2WfaB/UXGzYwM/gA8pojtpm3L8/O52Bkby36vJn1dfSR7qgn2YwcPD/bxworbZGI7e/w4yxgSwv5Ga53WsaNt0rGyMtss2D4+rNutW3mM2npaiBAGwupb9F9ibBoQwPt25AitDqtadElIAJ58Ur3+khI+a35+rAdhsejtTes3kVE2OZl1l5/Paw8O5t8GAxe4/P35/9697Ne7dZOLPxKJPfaLubXd7mLA05NWc0OG8EeIczqd6s1mT3k5XfNHjgTefbd2IQskkouZS1aYA9QBaVISMH8+B1Hdu6sTzMGDKa4lJnK74cNtV5CNRlqS9OvHwdbixergBlCzUhkMHOhkZHAQJhrIoiIOOt58kwMvGXvONbQWV9HRrOOcHAqlyckc+LlTfwkJwNy5dLexdy9x1d24OgFLG8tLxOsSkxoxEBbPh59f7dw2qrP8O3aME6+oKDU2mkCn46A6NVXNHies9MRxExIcH9eViZJ9kgj7cwcEALt2MZ5aWpqt9Zo21syYMey4k5PpBvPRR5ysCiFOxPQpL6eL+a23OhaO3HUPA2wnyMKFNDubgqY4ZrNm/K4qC9vqLHAdiV7OJq81taR0dbJ/sUyCJZLLGVfbWCF4FBXZjkm8vdk2nT/PPvSRR9i+tmihth9WK2Og2S+ehISwb8jLY3shEmGJRcnSUvZrCQlsC/V6ts0FBTy+NrxAXh7HRyEhtevr6iPZkzs4s/5OTub1jh5Nq7OvvmL7ajKxf7e3Tjt8WBXyiou5cKfNgi0swlu04Llq62lhNtO9VCTQyMlhOQIC1KRGWVkcj1a16JKYyLHT4cOs++JiNUt5aSmftYAAHqt7d/aTwjovL4+f5+ZyTGyxqJltjUY1furJkxyHyMUfiaQyro69GuMY7corgdmzgRdeYBvlyOpPzA1E6KmkJG4fE8O2VyK51LikhTlAHSTk5HAQou34hUgRH8+Bx5tvcuCgjf+RkMBYGIMHV47VZDSqvvDawSjAQdDWrRyUhIdzcCRjz1WP1vIsLIxWjdpMmsnJHGy+/TaFheoG62K19/Dhyu4l7robVyWOaGN5Wa222coA2+dDp6u520ZdWBLaC2buHLe6iVJ1Mc3EYH3PHnXlXBuMWmvBJuq7ZUuuxC9eTNeX8+d5LGeJNLS4GyNQe53aCXJ4uDpoCA/nb+1kuU2bqifT1X1fn7gqujX0JFgikbjWxgrBQ2upJrBYONZYu5btW0iIbVvuLCGMyKIqzuvnx3GT1lJYuLyKRZbAQJbl9GmW0WSiYOPpyb6vLuJT1keyJ1fQjkXi4lT3XqORfUliIscPnTtzkat5czWmq+j3RT2Zzeo4sbTU1k0YUOvM27v2FvWJiQxlkZhIAdDHhz9eXhRy8/J4bWFhlftO7aKfjw/wySdqCBeReVVkci8sVBdP8/I4PsvLU0VYf3/eO2FhZzRSyMvI4L7CBTYwELjjDjkelkgcITIYV+WqqtM1Xjfwhx9m+/LMM2wntdcpRDntZxYL53OPPgosWiTdWiWXHpe8MAdwoFBUxIFRamrl4Oa+vnQLiYoCevfmZydOcLBlNqsCnZcXt23VitsEBlJUOHeOjaIYjCqKGpC5fXvVhU3GnqseMWnw9WXMLeHq4eXF+5eRwcFyTg7vTUEBJwNXXVU5NktiIuOiHD7s2L2kZ8+aD4LtrdZMJtUyS/tciBVxMfA2GGoes6u62G1C7G3fnqJVdratGyvAZzMri9+3b+/ecQVVTZSqslBLT6ebqrAyDQmpfD8MBscTubg4YN48rpYdOcLP2re3zSjoCHdiBNpjP0EWYmNBQeXJcnWT6aqOlZRU/wKYOy7LMiueRNKwVNfGagUPLaJdKy3ldqK907blFovjxROdjgJedjatmVu25HbCUrioSBVo/P35t8HAftVsZvvu40MBS7j6JyY23viU2rHIli3qAqFYTBJjhyNHWE8tWlTu9wHWkZhgenioMUmFRb0IeRAVpSYEqqmVoTbObVQU+3pxT3x9gS5d+Ds5mZ4g115ru69YvElL4/Ny9iy3Lyzkj0icJsa6hYVqQqXyctu+WyyK7d+vLkgqirrIlZHB5zcujuWSSCSVEYJ9cbFzizJv77pJfNNQPPAAx+effML2RFynNjGjQMShO3qU87uZM6WoL7m0aMSvsuukptK9LyGBL7W9lc65cxzQNm/OwcKuXXzpxcqnt7cq7G3ezAGtSPPeoQNFopQUmtaaTBzQHD9O8SMuzlYYkanhq0aIqGJVVTvANRo52D94kJnRxD0AODj+5x9mG9XGfEtPd+5ecugQ4wW6OwhOSGDmtUOHeJ7gYIoewcG89x078rkQkxV/f7qV+PuznDEx7rttaFfvHcVu04q9LVsyjuKaNbbuK6WlHKBbrbQ0E+6rrh63NjHNhFidn894NCLQq/39aNLEeawZvZ4uL61bu15vQO3cNN0RqqrbVnyfmAj89791Fz/RVaToJpE0frSCR2kp2w+AbWp6uhpzzt+foox9W37nnc4XT8LCGG/3wAGOk4SIUlqqLoJFRbEd2bePi14AhaZz5zhGioxUxziNOT5lXh4FKm2digXCc+coYArraW9vjle0/b7od/PyWHfC7SohgUJVcTH7wMxM9oMieUZNrQy1fXl8PPvZHTvY5/v78/fx47x/MTG24R+0i3O+vrzu/Hxea2kpBUVtVtWAAH5WUsLjxsTwe23frdczjMP69ezrtPEK9Xo+a6GhLGtjFG4lkgtBVJS60F5YWPl7Hx+Om6OiLnzZ6gq9HpgwgW2F6FMA9j32Ip3Ihu3nx3ZWGrlILjUueWEuMRFYtYoDDDFoFINIs5nxqc6c4YDTy4sDmeRkNgZBQRyEFBVxsNSzJxuN//0PuO46NgwGAwcXQuw7epTbBwQAffqobiBaZGp45/j7c+X1/HnWv721V0oK75+YkPj7876azcBff6nZRrXuOs7cSzIyeJ6qBsH2lnH79wOvvcb9hGibk8OBbJMmHKwKy6zu3fk8HT7MaxKdqrsZ6gDn7kfieuzF3smTWcZ//mHdiNVqT0/Gd5s0iR1ZdTHh3BWRnVmonT2ritWdOlGg1E5ejEaK5/361c9E7mJx03TXOlEikUi0CMHjjz84dmnWTM0QnZ3NiZrICB4YyH20bTlQtXt/URFdC++6SxXjDh1iNrz27dmX7dzJvk9Y7gHs3woKeH5FaVzxKR3FbRWhL0S8Vu0CYVgY+zRFAdq2ta3Pnj1ZXxkZFK1EgrA2bdjf5uTQkk2MPYSly/79HN94eXHhzF2xyn6MEBbGsiQmcrwr7k/v3pwEi/ti77K7ZQtFw8BANS6uiPEEsLwiPlxJCf/38uL57PtuvZ7XnpLCbb281ADvubkcMzVW4VYiuRD06sW2QIRwsaekhMJ4r14Xtlx1TXw8LeDGjmXb4AwPD869fXykkYvk0uSSFubEgCMzE7jmGg4mMzMpBoSEsKH73/+AK67gAOnAAQ5CAK4aalPM5+ezsejbl2JHcrJqYjxwoJrNNS+Px1i8mMdwRF3EXblUadGCA8u//qLQqaWoiINa4RLq4WFrBafNNlpQUL17SW4uxZBBgxwPgu3jrhUXc/BdWkp3ZoOBgl92tjo56diR5zt8mGJdQQFXrmNj2Xl6enIy9f777okw1cVusxd74+JoPfjNN8Du3eoEq1s34Lbb1PO6e1xXcGShphWrIyM5IBeTFxFPLiCAwbTrayLX0BZjdW2dKJFILg/shaO4OOCll5h9VSwSKQqFD5OJ7WuHDraim7Yt79GDian++otim5+f6gYbEsLv7V32IyLYfx08SJEnOprHFQH9S0ooYHXpombmbAztmLP4qt278/uqYjsBjhejevXifTl9mvfG15fjkzZtaDm3YwewbRvrLSaGdV5QwAWrwEBu427dVdeXCws3MVYRaAU9EUfPy4sLZ1arGnRdr6egVl6uJmDy92d/1bt3ZRFW9Hd+frTS3LePx1YU1rGi8HmpyUKlRHK5oNfzvRFZne0pL+e72hja2uoYOZLi3AsvsC1yZC1nMqlzPmEV/O237LN69WrcLr0SCXCJC3NiwBEdra5sJier6ds9Pfkzdizw66/AihUcFOXkcOABqG4cAQEc+AQG8jgTJnClWsRx0SYiiIsD/vzT/YDzEnYuN98M/PQTV6uDg1U3zPPnbd0otA2wTsdtz5/n4LZDB9fcS8LDHa/Y2ls2+frSzDozkwPN8vLKrrFGI7d/7DEew1EmYEB1x3VHhKlJdtG4OOD556u2EqvJcV3B3kLNXqwWbixmMycKpaX8cSfWTHXZaS823LV6lEgkkqoS8yxdqoZVyM+nNXnTpmxH7a31CwrY1n75JfvW3Fz+PneOE5zwcHWs9Pnntue65Rb+3ryZfZ02Rq/RyGNFR1NQyspSFzUvdqqyYN67l//rdI5DQvj7s86Em6r9YpTRyPtw7pyatVSvZ/1arazz3Fwu7Ol0FMPat+fvAweAoUPdq0P7vjw9nZPWwkLV+yMvj5br2oVBraCXkcHFxsJCLqZpywuolnOlpcyo+Nxz/O2o79X2dwEBwPXXq/298F7IzJT9nURSFYcO8Z2tiuPHuV3HjhemTPXJo4+yzZgxg3M5i0VddBIJh5o0YVv31VdsQxITaUHXti3bteHDG/oqJJKac0kLcyJGyOnTHBiJzJ5+fqolVWoqV+369aPqXljIRkBkHhPm9+HhHLyYzWwAOnRQ40W99VblQfMVV9Qs4LyEAYmHDgU2bOD9yMujCBcczPtYXs5BqBjcCbQr2/axzrTuJXl5nMR06MDG395Cy2LhhOf4cX7n78/7npvL+2u1qrFYRFDngAB+n5WlWho4ygQM1EyEqWl20eqsxGp6XFfQnttqrSxW63ScMCgK4+60bs16diUZQl1kp73Q1Id1okQiuXRxxfX9zTfZj5jNFN1Onqxsba4oHIvk5HA806IFLbXy82nd7efHuKQ7d/K4oaGqhZw417BhFKuystR+UIhUvr5sf/38aBnWGNqw6iyY//pLFd1SUtSxg6cnx4zNmnF7sWilXYzat48i5rFjtFg3mTiW7NCB9Z+RwTFlWBjv21VXsc4DA1mfNVmg0fblcXHsGwsLWT5xn1q0oECYmKguDGoFPWF5KTK3CisdrcWKEOfMZjUBkyPs+zvR3wsslsbzrEgkDcWCBaow7gyrldstWnRhylTfjBjBOeDy5cAbb6ihgnx92WZ6e3PRoaCAbUrTpmzr9u8Hnn2Wx5DinKSxckkLc6mpzK4K0FVABO7NyeFAxWikyObvz5XNTp24ypifr6aL9/PjgMnDg/tmZtKd1WoFVq+mlV1JiRqTRDtoHjaMDYW7Aecvd/R6xkgrLubgNCSEA1aRwdJq5T2xF5Gys9Vso87cS86do9gUFkZrMvtU24mJFOW++YYD8NRUnissTI3R5uGhuu6IwNsGg2op4O9fNyKMvUXYLbfUvdhbm6yldXUeMWEsK2P8vupEtsYap62+rBMlEsmlhzPhyN+fE5HERODTT+n6I8QRg4Fto30be/o029igIPZ54liBgYw5mpDAfk94C5w6pcbNjY1VM2pPnMg4usLiXIhUIpGW2dxwbZi7FtTVWTC3b8/xQkYGx3y5uaq1l7OMs3o9Lc3Wr+d+fn68B/7+alzjtm1ts7KKMYMQrWq6QKPtY//+mwJtaSkntaWlPF9ICMew2oXBFi14j7dsYV0YjbxOraWcwaCOn0UYEbMZ+OwzTpwd1bPs7ySS2pOUVLfbNRaEN1v37uzj0tPZbkVE0FKuoEBN6nf6NNtUgH+//jpw443SrVXSOLlkH1urlYq6wcBVP5GyXut6uHs3AxyLgVXPnvysTRv+Li1VBT1tkoC0NOCppxhrrrCQA7iICA4+tPGiDhygeq91c73Y3e0uFuLiGKdGWEWlpfHexcer7sgWi5olrLiY91lkGxXHcJSNc9Agx+KoEHyOH1cz0pWXc0Cdlqa6rhYV8VkSHQGgxm6Ji+M9Tk6u3aDUmUVYfYi9tclaWtvzlJSoE8Y2baoX2RpznLa6tE6sahLa2Fx8JRJJZRwJRyJ7dUYG+6Fjx9h2PPAA20lnbXnr1hRV2rRxLEIpCscrISGMAarNPmo2qxZkXbsy8VVCAi3uvL1Vt9aGDNNREwvq6hbP/Pw4rvPz4/Gjo9VYcM4yztr3T2Yz61JkIU1PZ78mFnrFYp/W+r82gpW4/2IiC/BYwcHsY3NzabneoQPHrmYzLSbT0/ksHTjAe1lWprqQeXjwp7yc1yKSe3h7V23ZV5/W+BLJ5UJMTN1u19iIjwdmzlTb9x071JBCOh3bMauV7ZWw8t21i0kAp09v6NJLJO5zyQpzyckccHTrxkGkfYwQMfDo2VMdWInVxowM7nf6NAW5/HwORq66isdJSOCALj2dA5aEBAo3AweqCQbEiuSZMzJ+Rk1xlEmzoAB4+mkKp8XFbIj1eg4Su3VTs41WdQxHQoV9ZrLUVDbwQshNS+PzYjCoIlx5OfcrKeEEqFkzrvCITGQREXRpiYuzzTBb3aC0OouwKVOAu++uW+HlQmUt1Z5HuF55edlacVQlsjXmOG11ZZ2onYQWFfE5bN6csRmjomjJ6+oEVYp4EsnFib1wpI0ZFhioLhLu22cbM8xRW2420xrZkQilKNy2rEwNLVBYqFrMpaTQLbO8XB0LZWWx7ejYkZ83ZJiOmlpQu2LRFR4O3H8/XXxdWbSy758CA22TT4lYxX5+XJBSFFo/iuy5dSFYxcaqC8UhIXT/MhpVIS4riy6kJhPw8ssc1xiNTOCQnMwxr4cHx8k6nRpv2WDgscrKWAd+fmrcOkdcKGt8ieRSpmdPxmd2ZbtLFW2f9u23bE9EbFOLxTZmfHk5x8Uff0x3VnuvKInkYqdGwty///1vvP322zh//jy6dOmCBQsWoEePHk63nz9/PhYtWoTk5GSEhoZi1KhRmDt3LryFH2A9IAa1sbEcQGjji3l6UkRRFNuYVvarzaGh9Gtv3pyWSmvXcoAqsmx5efHv0lIOdHbtAoYMUTPHyHhRtcc+RlpiIgexYWGVhTlHg2tHx3CEdkDt7185k2tgIF1lDQZOToKCOEA9f57CXLNmzCRkMlEY2byZwvDx4/wtAmP7+FQ9KHXFIuyHH7gSVNcD2guVtVScJymJAmiLFq6LbI09Tpu71on2wllBAfDBB2qMw4wMPoN//cXnLiCA4lx8fPUT1MYYp08iuVzQCkf+/mrMMNEnFRezP4mL4/hDu4hh35YnJTkXocxm9m0eHmqCJdGvenryPGVlFKliYznuKS7mPidOcAxUFxbWNVkkqI0FtasWXddeyx9XyuYorppIPnX2LOuquJjWLampPE9QEMca5eXcLiysdoJVcjKP3bIl75EQ5VJSeB89PfkcKArw22/83bEjXcauuUYt67p16rV4e6sxlz09OQ4KCKAlXlWWfRfKGl8iuVQ5fbput2usiD6tRw/2Qbm5qoWcl5dt+63XcwHi/feBf/9burRKGhduP65ff/01pk2bhg8//BA9e/bE/PnzMWTIEBw+fBjh4eGVtv/qq6/w3HPPYenSpejTpw+OHDmCcePGQafTYd68eXVyEY7QDmrtM0AWFNBs//x5xlVZvdp2QurIcigpiS4AHh48XkkJ/9bpOEHOy+M2OTkU82T8jLpHDMLLy4HbbnMc86WmbozaAbV2MC0sLT09OYD19+f9johQM7PGxTF5yD//AJ98wt8WC4Wl7t05wD9zhs9bp06MdedsUNqYLcLcxZnIJgTzwkKarJvN6ncXa9wadyaVrlon2gtnRiMnXDodXdJ27lQz7oWEcLvsbA5SSkoqu9Zr343GGqfvUsLdBa6cnBy88MIL+Pbbb5GVlYWYmBjMnz8fQ4cOvYClllwotMJR06Z8V7Vuo7m5FOGDgtR3uiZuhcXFbIf0elUE9PRkH5aToybC8vPj2EavZx8mEvbccw/LVRtr25ouEtSmv3TXosuV/tZZ/+TpyToWwqfBoMY03rOHgpmXF9CuHTBuXO3a3rw8tv9XXMEFm/R0flZayjGrSOwg4vaWljIencXC+xoWxmequFhNwCVcbr29WfYmTfg8dOxY2bLPvi+MjWX2VmmZLZG4j6vvyeXyPvXqxbZ6927VSk60/cJazsODbeDatWyHRagHiaQx4LYwN2/ePDz44IMYP348AODDDz/E2rVrsXTpUjz33HOVtt+6dSv69u2Lu+++GwDQsmVLjBkzBjt27Khl0avG0UA0KIiDlIMHOUCKiWHMlPPngU2bONAUCQHsB2FHjlCBj4xUY9X5+tJ6yteXK9f5+Rw8BwVV7Y4g3cdqhnYQrtfbZvgCaida2Q+ow8JsM7kWFXHg2q8f3VVNpspWTOnpalyXwECKKMXFPI7IhBYbCzzzjPMVnMZuEeYOjiYx9jGULBa6uxoMavy+iy1uTU0mldVZJzoSzs6epfVlYKAqXGqtZwB1JVFY/IosevbBvhtrnL5LBXcXuEpLS3H99dcjPDwcq1atQrNmzXDq1CkE2TeCkksGrXCUmMj20N+f77o2E6orFvpViVCnTnFC4+fHNlS4MJaVqSEb9Hqec8sWNdFD8+YcOwUG2rZl7o5varNIUNv+sq4tuuz7p4wM1f04JoYLTf7+rOujR3kfBg1ShVCzmZPJNm1qPpEU/aqPD61Ltm9nvygSU+h03MbfXx2/iiQRe/YAgwdz2yuuYHkzMtSM9H5+7Cf8/CjK2lv2SStsyaXExbB41qtX3W7X2PH0ZBKiqVPVBWvRXxUXq/2hEOw2b+bY2VGyP4nkYsQtYa60tBS7du3CjBkzKj7T6/UYPHgwtm3b5nCfPn364Msvv8TOnTvRo0cPnDhxAuvWrcN9991Xu5JXg6OBqK8vsHcvB5MRERxE/f47Bx6KwknvtGnAvHnVv8A6HSe+JSUcdInBicgy6cxVUQ5cao67g3B3JgiOBB9haZmTw/vWtSuDKmtFNauVWckyMjgQPnGCE5ncXHUy4+VFF+f4eD57VcUdvFgtwhzhqH4BNX6c+NyZNUVVk5iAAF5rYCAtEN97jx1xXFzdxK2pq+QJ9WF55sw9y2Dg8QsLOYlq2VL9TpuIxMeH+5rNjjP9XU5WmRcr7i5wLV26FFlZWdi6dSu8/j+dY0t5cy55hHC0dCmt/NPS+H5rM6ECrvULzkSoTp1o7W+xsL0QQoywrBJJjwID1WQQPXvSaspe9HJ3fGOx8NqOH+f3/v5sg5wtEti3zcLNsjb9ZV3GV9WOOxMSWF/5+ay7vDzWb48erJ/cXI4VoqPVdjg6uvYLI6Jf/eMPTlbz89X7qCgcj/j78//SUop1Iu5yYiKPceWV7G/atAFmzQJ+/ZVltlrpvtqxY2XhUlphSy4lLpbFM0Wp2+0uBcaP5wLGunXsQ0ScOQ8PtrEWC9s0i4Vt8PHjbJ9efx244Qa54Cy5uHFLmMvIyEB5eTkiIiJsPo+IiMChQ4cc7nP33XcjIyMD/fr1g6IosFgseOihh/D88887PU9JSQlKSkoq/s/NzXWnmBXYD0SPHOFLGhlJke7331WzV09P/j5wAJg7l/HCtIOI9u05IMnKoluJUOWbNeNAJCNDdW11ttqamEiBITmZAkJEBM8rBy6u4Y5o5e4EoSqLgrNnOUAdP76ypZsQOXx9gb//pmgiXIHKy/n/0aN8flq0qN7a7WK0CHOEo/oNDuZ3J09SoCwoYB22bs2JnH3dO5rEFBRw4iAEToC/T5/mhPSdd2pv5VDVs2G1AsuW2U5ChBjoKP5bfVieORPOjEbWjdXKdstqVb/TPpfiHdE0oTbvxuVklXkxUpMFrh9++AG9e/fGo48+itWrVyMsLAx33303pk+fDg8RnV1ySRIXxzEJUDmZkKLYLhxFR1d/LEeJIQ4coOgnEh6UlXFiA6gujCKMh7Bq7txZbVOsVmDjRmDJEgpBIrZvdTEuly4FvvmG50hN5bhICI72iwRFRZXbbTEuO3265v1lXXswaMVU4W5VXKyKqV5etEQLD6+8gFLVwoir5RTWbsuX89g+Pmq/UVqq9h95ebw/QrQzGNjXnj/PBbKQECY0GzyYP1WduzFnS5dIHHGxLJ799JPr211/fa1P1yjQ64E5c9i+nzzJMavZzDFySYlqOefhwX6trIxz9zFjmCRtxgw515ZcvNR7SMRNmzbh9ddfx8KFC9GzZ08cO3YMU6dOxZw5c/Diiy863Gfu3LmYPXt2nZxfOxBdvZqrzmYzrXDKyzm4M5n4ohcXU2E/caLyIKJlS2DAAAbeT0vjCqjBwBff25urxwMGALNnc1tHQf0XLaIYqCgUa3x8OACNjeVgVw5cqsZV0UobIN+dlduaCD55eRzkZmRw0CuCJOt0HJCL7GuHD3MCUd3qfWPIZOZoZTw5me9GWRmfa7FyVVTEjrO42HHd209irFa+Xx4evPbAQB4zI4MrZMOGcZLgrpWDmNTs2wesXMnytGhh+2xs3sw6Fh280ch7l5bmuOz1ZXnmTDgTGf5OneL/JSUUhAG2ReLaxbNnNPJ/+wlqcnLjscq8FKnJAteJEyewceNG3HPPPVi3bh2OHTuGRx55BGVlZZg1a5bDfepqgUvS8Hh6Mk7O++9zoUi4JR44wHfb05Pt7ltvVV5EcCTo2CeGCA/nQuGZMzx+Xh7bD09P7q+N5RMQwPHKkSNA//5sL+bOZbt6/jy/z8mhUBgeXnWMy+PHedzwcI7HtBZ5YWHqIsG+fcD69ZX79H372Fd4eNSsv6ypB0N1IllcHHDvvWqZfHzU+ICpqRxn+vszJqh2AQVwvDDiTjmtVmD/frX/TU+3XcgR2XVFvYnPRbsfEKBmZh0xwrUYe9IKW3IpcSEWz1ztn9PSXCuzq9tdKsTHAy+9BLzyCsfnIrGN1aouWolY8CJJY0EB+6GiIu4nxTnJxYhbwlxoaCg8PDyQmppq83lqaioiIyMd7vPiiy/ivvvuw8SJEwEAnTt3RkFBASZNmoQXXngBegcjphkzZmDatGkV/+fm5qJ58+buFNUGMYjduZODGhHM1mjkIEUMroxGdaX44EHbQYReD0yezAHLP//YBqT38AD69KEPe+vWjsvw6afAV1/x2GKQW1zMhsJsZiMjBy5V44poNWIEBdiarty6K/j4+/MZSk3lCrPFog56dTo10HNurjqRqc7a7WLOZObI9Qhg/RuNauDpDh1YZ/7+nBiUlTkXn8UkJiGB23h5qVapAI8bGUmBb80aZshzlHnQGWJSk5hIV/bcXFpARkSoCRJCQxno2mpl2UVbkJ2txm+zL3t9WZ45swwVSUnS0/m32czvy8p4TcKtLSWF8YzEKqL9BLWxWGVKVKxWK8LDw7FkyRJ4eHigW7duSElJwdtvv+1UmKvLBS5Jw6PtF3bsUJMMNW+uZvy2X3xyRdDRtgd9+3JhsrSU/ZnVyrYeYNtgtfJ3djb379yZi2AJCWx3FIV9b2oqFxCuuYZtprMYl3FxHFMVFLDP9Pe3jZFZUMC2ePPmqvv06Ghuf/iw6/1lTV0vXRXJAgNZhyaTbTsuBM/CQtsFFIH9woir5RRi4aFDXADOy+NxWrVin5yaSsHUalVdv/R6Pjci46pOx89jYlifzvo2e0Rf6OPDMuTnc1EyOprnkFbYksbEhVg8c7V/dnWB9P/Y+/Iwucoq/VN7V1f1vqc7nU5C0mlCICEhCQQcwICKLCMoiAugjjKOICOOgyii6Ii4MaioyCgqP2TcQAFRUEDWLISQhNDpJUt3uju9VfVSVV1VXfvvj3eO31e37q26Vd0dkvQ9z9NPb7fu/e53v3u+c95zznvmYyD14ouh377/fQTuTSboNptN+NomkwhMmEzQQU8+Cd34y18aiTCGHHuSFzBnt9tp7dq19Oyzz9I///M/ExEchmeffZZuuOEG1c+EQqEM8I2jBymNoniHw0EOpbUyA+E0+0gEpadvvIGXkSOGsRiMJJsNBtT0NNJelUZEWxv4Nh59lGjnTlGqt25d9ghrezvRf/83jJWSEgA1TNjO3FBc3moYLtmlrY3ohhsyyw3ZCHc6Zx651Qv4EMHJaGoC6FtVlc47aLfj56IiPFe3W3+222zy3syWaJUecTl3UZHguZCzB0tLUbqzeLH23JeV4fipKdG0QJZYDHPQ368fvFaWV3HjlqoqOIN+PzIzqquReRGPCyJZ5lXi0q2pqUywfq74ALMBZ9XVKIkqKUGEtKcHP9fX43PDw1hn1dXIylVzUI+HrMwTWQoJcDU0NJDNZkuLvLe1tdHw8DBFo1Gy2+0Zn5ntAJchb720taFz5623wtmQy1qJ0oNPyWRm5vjUFECu3buJPvEJEeSQm0yUliITNx6HjbJgAXRMOCz4yqqriT72MdA3HDyILLtwGLqHSyIDAXSyr6jAHq3GccnBSa9XZP3a7dBDk5M47+LFyKTLtqePjRHdeCM+z/tlUxPOs3evOo9oIaWX+YB5WnqcAbvubpy/rEycXxkY0TvOZBIByc5O7AE7dsCebWkR4JrVimcUDmM/tVjwnIuK8HmHA/N0xhnYY/bv12+PlpQIjljmzrNY8NzXr8f+ZGRhG3IiS77BM73784oV+q6v97gTTVauJPrhD6ETX34Ze4XfL3RlOAy9ysF87tz6u99hb/v617Wb8RliyFsheS/Hm2++ma699lpat24drV+/nu655x4KBoP/qMO/5pprqLGxkb7xf6Qol1xyCd199920Zs2af5SyfulLX6JLLrnkqHHjsCHY3IwXsL0dhgkbD5xR53Agi4aJ+9WMiLY2oltuQaerkREcv3Gj9oudTIIXq68PymFqCue22WAUcYbe8DAMWMNwyS4dHTBAh4cFN0p9PTLl2tpghB9N/iyzGdd+6imMqaoKyn5kRKwjux3G9yc+kV+2Wz4A4VxLttKj4WEAkLKDITcjsNsx3xYLvqvNfXMzHJ0dO+D0yZJKYS7r68U59Iz30UeJfv97AGuVlXDeQiHhaDJX0imnwKn4P1qQtLEzsOj3Z4L1c5V5lgs4W7IE4PTQEMqHBwYwL6kUOIEuvTS9a7AaoHssZ2We6FJIgGvTpk308MMPUzKZ/Eegq7u7mxoaGlRBOaLZD3AZ8taIsmwymcT+csopmQEBBqr27YO+kgEd1nceD/63fz/Re99LdPnl6fqAGwCMjRGddBJ0XHU1sm+npzGWTZvwv3vvRZba+LjI3LXbYdtw18/t23H+eFzopelp2Fw7duBaRUUigysUwjE7dhCddhqu9atf5d7Tg0Fk8BHhHr71Le2stkJKL2WQrK0N9+r1wm7k7EQZzNNqQDY8LLLLLBacRysw0tubOc5UCs8iEsHz37oV2ZPRqDgulcJ8HzmCwJnLJZoHORyCy5VNcLcbeyR3OQyF8gPS3ngDY+AGFzabyJJ/5hlwAV58sZGFbcjxIUcjeKZ3f+aAcrbmDiYTjpuvwlQPg4PQmbGY6DDOoByX7fM8RiJE99wDCp2bboJ+MsSQY0HyBuauuuoq8ng8dPvtt9Pw8DCtXr2annrqqX+k/Pb19aVlyN12221kMpnotttuoyNHjlBNTQ1dcskl9PWvf3327iKHyCVn9fUA00ZH8bdEQmTIlJXh5Y1EYGipGRFqZQwvvqidMffcc0TPPitKGtn4jEbxc3ExrsclKXzN2SYkPhFEGa1uaYGB2dsLB+HTn35rupqefz7RRRfBAA2F8FwrKkQ2XSBAdPbZOG4m8latCaVDMjKCe+SMssFBUbrCIgPVnFLOnI5qc282g5T1L3/B+Ssr8b5Eo3Bciotxv6lU7mfH6+TwYbyjjY04v9eLEiy3G85DaSn+NjYmNm/l2IkwjvHxTLC+kMwzvc9QD3C2ciXWVKFr4ljMypwvkm+A65Of/CTde++9dNNNN9GNN95I+/fvpzvvvJM+/elPv5W3Ycgci5q9UVEB+2XRIvXPuFzIxpqcRHYdg3Lc8ZqzkwMBoldega7iTC/WB3v2EP32t7BN2G4xmaArFy0CmLd3L46bmMA12XZi26aoCD/v3w/91dBA9L//iyxlhwNgTigEvRkKQRczzQjzBd1wA879yCP69/T2dnDejY4KmyoUSs9q42zAfAJ4cqOnV17BeONxjJMzx5VgnrL8WG6KxMkxhw5hPtQCI0q6BAZX+dr8bJcuBfG7yYR7dThEswevF2O2WoVuLy/H8+AM9aIiYYdyxqLeoFI8DvvLZMLaisexFrgyZGICc3LxxcbeYsjxIUcreKZHli7F+yQHjJViseC4+SxtbaCT6utDRVssJpI3GJTjhnJEgmpo924k2xAZ4Jwhx4YUlMB5ww03aCqn559/Pv0CVit9+ctf1uTBORoigzVlZTAEOb01EhEouseDaGZLC9G112YaEflykiST4MSKRmEYsdHEmXqcUptIwDi65BJBjFwIIfGJLHpLOj73uaPPn8X8g5xNUFWFdWa1Cr6v97xnZkbpW7km5OyCkhKs1aEh0TmvslJkwnHjC7ZD5Gw3n49o7VrtuVcCnIEA5rChQTRI0dNhj9dJczPAOYcDc9/QgDEMDmLdcCYfEeaTSGQ4yhKJaIP1+WSe5fsM9QBn2bIq9YCAx1JW5nySfANcCxcupKeffpo+85nP0KmnnkqNjY1000030S1sURpywomWvdHZCTCnrg5lnkoJBvFeJ5P4TCqFz4RCQmcnkziuuRnnlzO9WlrwtXy5tl5rbQWtAQddWMcmEviKRkVnPJMJYOKpp8IJ6u9HRtXAAHQyd7gvLsZnvF4czzyZ+WQmt7cTfeYzyOJzudI7vcp2wlVX5R/ACwQA9nFQt6xMZIYNDQGAqq1Vp0BJJjG2hgY8y4YGPA9uxPO+9yE7UKmjZds1EkkHV7m769SUyI6sqRHg7eQkxsYNqjjrJpkEMHfaaZgPHq/fL0qOa2r00xls24amao2NsGsZYI1E8HnuOCvzMhtiyLEux0rwrKcn93toNuO4detmdKnjXlauJPrRj8BZ3dUlEmFSqUxQjitkOBv8Bz8geuc7jbJWQ956mRdLUDbsamqE0x8MirRWq1VEP5mwVpZcwFB7O9HPfkb09rfjf8uX4//9/TCiQiHBwcIcH6mUcNA3bwYwUSgh8YkuektPBgaOPn9WMomylHe9CxwHw8Mw3mdaGqink+jRWBNy1J4bEPh8AMpKS7HBcZvyoiLMhceDn8NhAF02W25jPxfAqefZyeuEuwnGYungHHceLCkRQFwqhXFzFh0Dd5GIKAdSA+uJ9AFo7e1Ed96JedHK4lB7hoUCZwa4f+xLPgEuIqIzzzyTtm3bNsejMuRYEDV7g0GVhQsBhOzcCfBK1jMMVLW1ASwKBvEZr1d0BSUSgFpRkTbvamsr0fvfj+w7Itg03HG+txf7XGMjMuI406qkBHqNuej4b+vWAURMpbAvFxXh+gzWcHZ0IABQad06QR2gNzO5qws6tqsLe4fbLUAz7vTK90qUfwCPgb6pqczmRJw5nkplZuEx/1s0SnTmmem248qVuKd9+0RgVha2XV9/HfMhg6upFPZXvh43zODgMzd4mJgAgOd2gwbhyBHMd2Ul5lnu7FtdjeBZPjbLyAjmmbPy5CoQqxVgXV8fjjPEkONFjpXgGTct0Cpn5f9xd+X5LqtWgTfuppsQwOJsbxaTKb0jNfNKt7djz73iCiOz15C3VuYFMMeG3RtvED39NH4vKhKlrEQwVE46CYbS6Ci6qN55p0DPswFDXi+4t557DqUaViuMnpUrYTw2NODz8TgMGDakmJNl0SJEcPfuJXroITjvK1fm31H0RJZ8OmCuWjU7/Fl6Mo6UAAh3ED37bPUIuF7J1kmUeYaqqpAR9oc/zO2aUJYH19SA0Hn3bqz9aBSb3Nvfjv/39GBD9PnwXBYvBg+jnrlva8OGynOaL8AprxOzOTO7r6wM91FZCUeBu5pecIHIepiaEpxy3DDmS1/CO6kl2QA0vVkcs/UMDXDfEEOOb1HaG8oSxngc+un55wGkKIGqa68FGLRrl+gWzhkCnMXc0AB9mEhklm3mAva5+/a6ddCbvEdarbgOOz/l5dCb3K2eg2iHD+NvwSB0bjQKG2zBAlzHbsde6vOJ5g033CAaHKhl8N11F+bJ5QIIpWzg09mJfYj56AoN4CntP1kY1AsGhc1QCJ8dC9uu+/bBxuROuVNTmBu7HXNcXIy14fPhdw6eTU7iXtavR+DJ78c16uuxfqan8Rw2bcJXITZLXR2eeSiE/dRkEhnoRBiHzYbjDDHkeJJjIXjGmchaHHOcDTbffMJscvHF0Lfvehd8CHnubDYRCOI9hm3+r3wFFTs33CD4Sg0x5GjLvADmiGC41dfDOInHRfYaZ8mwofPGGzBWDhzAy/zRjwpDVA0YGh3Fizw8jPMuWIBjJibAPWc2E61ejSgwkeBh4XKPoiLwwDz0EKKaHR0wmOvqYFCy6O0oeqJKvtxxerKYZOCNnysb1MGgcAK0Mo60AJDeXqyn5csLB+X4vGzocifR0VGRdRmP4x6GhmB4b96c/7X0iLKUyOsFyMRZEZEI1vBnPgMnrK8P7xLPe1nZ0eM+U64TZXZfKoWNuaoKY77ySuGMdHUJMJQ55dra4OQyKJcvz19HB/iO9GRxzMZ7XWi3QUMMMeTYEdneUPLD2Wyi8/f4OAAbdsxkfWU2A3g6fFjoaZNJcHauWIHflXunHmCf9WxxMdHb3gZbx+8XWVpyCVFtbTogxXx0tbVo8BCNYnw2G777fAjsWK1E990n7KQVK4guu4zoAx/I1L9ykwTO4GJedW7g4/ViD+V7bWnJL4AXDMIu83jEfiLzoDI49e1vw67kMa9cObOGVG1tKHXdswd77sAA7s9mg13JWXGcqUYkgmcvvojjGMzlbLjZ5BbduBFB7X37BCDKkkyKQPPGjYWd3xBD5rM0N2fnlyPC/43GKuly2mnYPz77WewJoZBoeBONYl+wWuF3sz916BD2kj//GXx1n/zkW30XhsxHmTfAXF8fjNgLLoChsHUrHGWnUxAPM29IbS0AkD17YKBqNRUYHUU3zsFBwRvn8+GcDQ34/8QESj3e9jaUhIyOwhji8seKCpHZ43Ti2LExGFQrVwJM5BKU2e4oejxJUxOM4j17YKiWl6d3KVMrPcmWxSRnBIyOijKLujoY9MPDItqv5pi0ts4NAKIEVkZHsbbKy7G+DhzA5rJkSXqp5f33I7NrLjKh5FKibdsAKjFvos2G98XpBLeDWjbW0WxaoQQRa2oAfnE3wokJvGtnny26EbLkAgTzLQ/lZzk6qi+Lo5D3Wq1jY6HZGYYYYsixIWxvTE1l8sMR4XttLWyDyUl85yDNY48JkO7Tn0bjhKEh2CkVFbBNVqzA+ZR7Z6FcrkSoGAgG4ewkk9gfXC7YNJWVItAYDMLGOXIE40qlBBXC8DBASLMZ10wkwE3ndKbvv8psBgYym5szs6SJsFf6/fj8eecJOyGfIFBJCea8rg5z5vUKHtTSUuwtkQiOWbBA2Azt7fj7TBpSnXYaMs+7u7GPlJXhezyO/cXvF1yo8TjO6fFgn3vve0WmvXxvs6X/rVY8k1tugWNbUyNsJo8HY73xRoO7yRBDCpGnn9Z/3IYNczuW400uvRT67p57QDPEFA4cOAmFBN2DzYa9IxiEP/iFL8D/fs973uq7MGS+ybzZKtlwc7sFDwh3bRkZERwp3P3G6YTRNjioboh6vUQvvQTDg0h0fuFSiKYmGCQc2T58GMBJMAhjOxoVncFqa2GwMZdAMAhDa2QEiqGmRpR3zHZH0eNBGBDp7kZ2QFcX5nfVKjynfLnj5IyA4mIYtlNTmHtOe/Z44BREIng2SsfkqqvmBgBRlr04HNhIuLsa80kQ4V65+cLU1NxmQrW1Ib37M58B+Ox2Y3649Ki6Wh2MLITrbCb8aGp8RBUVWCvd3fj8xz8OPke1edICcwspD5WfZbYsjqGhzLItPeCl2jyVl+fu2CiDgNmyRo0OrYYY8tYIBxheflmAG3Igyu+H/picxM+bN6eDQbJO+sIXAP7ff7/I5Ha7oW8GBhCgPOMMAEg+H/RKPlyu7e3QYQz6+f2weVwu2Dxer+A/I8Lx+/dD9yxZgmv6fAC2iETworkZf9uxAw5ntoAXA5mhUGaWNDf5CQZhayntBL08nnLQZ9MmAYbZ7YKnbdky3HdPD55TQwP0LfOmyhQl/CyVQUW1QFZTE84xNYU54/FbLJjjqSnYMuPjuJ7Lhew4Dj7xOdvb89ftuQJrySTRKacgu+Q3v8H1vV44uitXApQzuh0aYkhh4vfjOzf0UQr/nY8zJF0uvhhNHb77XXSPnp4WgfFwWHBRMzc2Z31PTiL7PJWCHjXEkKMl8waYkzPeolF893ph2HCKKwNzzL9SXi66pKoZolNTeGljMQGYcNSyvx+GstkMY7CqCtlGzMNRXw9n3WQievVVGJ6pFM4ZCMDISiYxHi57q6oiOvfc+ZWyLAMiS5diTt94A89jeBgGoV7+MiKREeDx4Fzbt2O+FyzA/wcH8fuiRfje2Yl5ZyO8pATOQXf3zMpTtERZMl1WBoemrw9r1ukUoK7MFbRsGRyYv/4VzsNcgCouFyLvCxcKDiDZYVSCkYWAWbPBj6bVKfWccwprxFFoeSh3wystxfW93nTScHYYOzuxrn7yE9FAQw94WWjHRgb3s2WN1tYazSIMMeStEg4w7N4NcMrphB7issniYhwXj+PdZ9tFSydt3gwAh0v19+8XtonDQfTgg9h3wmGU8mzapJ7dpcbl+sADaE5gtWJPWrwY592/H/rJ4YB+6e/H2DkLvLkZuqisDEAWEf4ej+NeiNIzi88+WzvgpcyU5ixpzmqbmsL/b721cH0mB306OjCWqirYDAcPCmDst7/FPBKJ6omKCtxrLj47raAUc8RVVqY3J+L1UFaGz09PZ3JRzSTQpfXZyy7DPezZIxpeRSKwm9raAMitXQvbzMiUM8SQwmXxYhGEZ72YSqUHasxmdXvPEIjViozelSthN+/bJ6gXbDZROadsFBEIEF13HXzwT33qLRu+IfNM5s2WyYbbCy/AsCGCkRGNQrFFIiJTqrJS8K9kM0SjUXwRCWAvHse5pqdheHHXR6sVPBxsjE5PI+OuslJwy/GYEgnRmCIQQHR7aAhKmVNz54OoASKlpXAyJicxZ62tyGbUa/z19QGM83oBsA4OiufG5cScNVdaCsP5mWfwLONxMffnnJMf551eUZZMcxfU4WGsCd6gEwms1eJiOEFvvAFA5r//G8CKluGdb1mpfDxH/ltahIEgi/yuFAJmaX2mpASAVkdHZlMWLZkJT51SCiXvHhlB6fGbbwK8n5gAwM6k64GAID4vKUkvAXr9daxPmQMv1zyVloKMva8ve8fG00/HNe69V2SNejyiS7XJhDVkNIswxJC3TtraiD7xCQBcDC5ZrdAfjY0ARYqKRGc5Fi2dxJlTExMi066zE59duxb6cnAQe8mWLdjjqquhsyIRcQ0ll+uHPiQAJ6dTBGsqKwXoPzkJHdPWBp3DwVC2k8Jh6KF4HMcmk/i5qEhkFnOmtlrASy1TeuNG2E0DA9CtX/hC9gY+ep+JMujDnccTCcy3yYRxEuH+enow/ssvF3OuxmeXLSi1ezeewVlnCcBTLqP1+/F7TQ2edzCIz+zdi3EkEvkHurTG88ILKJd2uVAJEo9jvrnkuL8f93jhhQYoZ4ghM5WPfQzNxyYmMrPm+PfKShxnSHbh7Lk//AGNHg4dwh7HFVJqnW8DAaL/+A/4We9731sybEPmmcybbdNsRpTvj3+Ew9zYiIy4wUEYGzJ3y/r16XwoaoZoezte5ulpGJncrjoWw3GcSedywXB55RWiM89EphwRjE+rFf8rLYUBSQSDbmpKAEHhMI6rqMC5tDK0TkTRAkRMJszHypUArAYG9JeL7tkDoMRuF2Cq3Y45j0QQAefMR5sNzzgWE53HAgFExV94AWukvz8dHCHS5rzTI8rIv8mE66xdCwCXs+YSCThonJnAHVCXL8c41QzvfCPnyuPjcTgZxcW5s7EKAbPUPiN3IwyHM5uyZBO9JUq5JJ+OwCwdHUS//z3WDj8rl0s4ilNTQj9w11q+50hEkLq/8Qaax7S1ieeUbW7NZqyVrVuJXnsNzrYyO+PSS+FYeb043yuvYG4bGnAOjwfHbtqE+zCaRRhiyFsj559PdMUVAMrkDLOREbzTrFuUwSEtncRg/EknAbjhIE97O2yPpiZkpnd3Q3+4XNh3OIstmQRPb1MTMusCAXxVVuJYeRw1NdA3AwMA5265BXtDezv+f/gwdF00ChtKLvXn8iIikVnMzSu0Al5amdLnnVdYprSWKIM+ExO4bn8/5sjlEnrZahVzdPgwGgENDGQGi3IFsnbswDNva0PmIIOlXEY7NgabqKpKZE62tRE9+ijO9Z73CP2thwdXazyRCK41PIzrFBfjOestOTbEEEPyk6IiUOfcf78A5VhnJJP4+cor0zshG6ItViv21GeewR7GvjaDcmrdb6enia6+Gnvm179+tEdsyHyTeQPMEcFgamgAcDE1hZexpgaKLR6HUWO1wtgh0gZYyspEVlNTE5xtv19kz7ERk0jAYF2zBs4vgxAmkyhRHBrCdTn7jnlEOFuvuBh/D4cBwOzZM39I2wsBRLJJMomyCwZDuQW5yYR5DoUAmDLpdjSKY2pq4DBwZuXSpcJJqKoSEfri4vQIfSHZjWqRf5cL66iqCmv3rLOEM/bKK1iHNhv+VlmJcbW1wbG67z6im27C+mGnTE/kXC1aPjUFh+3ll/F7ba04PpXCeZgzaGgI18zn2Smft7IbYUkJPvPyyzj/rbfOPANCj+TbEZidmrExNH159VX8XFoKR6W/H89ozRrM20knpQORfM+VlYL7Un5OzE2pNbfMabdsmSBZl7MznE4B7Pn9eMZySTJnqPj9RrMIQwx5K8VshhPBvF1NTXi3d+yADmR75ZVXREMHIm2dxECLzwfwv6oKn5fLRdvasIe1t8NGqavDOSYmsB92dSGDYHwcesjhwJhGR9MDDCx+P/ass86CHmG6kFAI47NaBUAXi0EnWiwCpGPCbrs9d8BrNjOlcz0X1oeHDmHc0Wi6HpXFZkNQSSuImCuQtXw5gsi7duE5FxVh//X5RAVITQ2uz+L3iywQvx+B6FRKgHpMy6HU7WwnPfus4DEsL8f/uBFJdTWAxspKjMXh0FdybIghhuQnyST0QksL3rlEQgB0FgsqI7hxjwGC6xOzGZzZf/4z9q5EIvdnEglU65hMRP/1X3M/RkPmr8wrYC4QgAFx3nkAGYaHYThMT4ssEbsdRrDJpN1UgMl4X30V2S52O5xmrxeGD3PDlZQge4U7ffb24viFC3GexkaMgSOtcocYu13wiDidolTh5ZeJLrlkfijgfAGRXNLXB6eCCMY0l9KEwzBouXPbkiUwsoeGxN+npwW3z4oVMGwPHEAk6/BhrIVDhzAmlwvPTO6Ol49oRf4vvBBjYmN7fFx0BC4tFeXXbCAPDsK5Yn46kyndcdKKnGtFy8vKADQ99RTKsN/+dmRZBIM4x+QkHJSvfz2/7DoW+XmXlKR3IwwGRXQrmcSceDxEd9899+CcWhYjixp4LztZpaWZfEfcEerii4n+9jcBsKVS6fecSgFYs9szG4/kei9qawHIms2ZDurevQLY83oFzwaLnKFSVTV/O0EbYshsCNMB+Hzi/T9wQJBPV1YiqLJ8OY4/cADfly+HM9baimz/++8nevxxUdIkv/udnbjGxo3Qt3KQpLc3s1szd++02dIb0fh8sHnKy+GwcDa51YrP1tZir+vrQ+Yc6/+REex/gQB0ZUMD9JjShuImBtyAKxoVWevT0/jd6URlgccDveX3Y46OHIFezNXkabYypfVKMIj5YqqHoiLYc9w8yuEQgT8tPZorCMmVGRMTWB8lJZijkhLYAcwJKu9NkUj6z3L2uUzLIQd7OzrAdfrUU3jGzL/U0oL1yEEcDlryOZRrSKvk2BBDDMlPmH6HO4fKIBL/vm2bAYLnK6tWgd7gC1+A76JX7roLQfUrrpizoRkyz2VeAXNy565YDAZOKATns7QUhoTfDyUYjWo3FTCbkQ311FMA1qqqwIE1PS1KMGprhcG5dy+MW58PUcjKSmGITk+LslbmlXM6Ydhw5h4RDB+rFWOWFXC+nGHHk+gBRNaswRzo6Wa5Zw+AKotFcPkVFWHuxsbws9kMB8TrFcDR+Ljg9qmrA7jHvDlEcIS4pGjhQuGUzISjSyvy39UlALuREVxn6VIcz0TZnHHFHHUmEz5XVob74qwKIvWy0mzR+9paRMT37sVxnO3AUfWlS/Vl16llPsjPe8EC4QSMjQH8nJ6GIcLl3Xv3IoJ1221zy4HGZfDt7SgRbWrSdjyJMp0sLuniTAWLBc9u4cJ0gI2zHzjrIhLBfToc6c+JKPt7wU55IIBzrVyZ2cHQ4QBwyzorGhWlEJyh4nAUzpVoiCHzUZJJAGHd3eJvf/sbOB+HhgS3G3eEZ+Ju7rhutULH2WywE1atgl548cVM54Hf++Fh8Xt/v+CqHBggev55vLucacfdmrnbN5ePymA8A4gLFoB+w+HAF2dom8344sw2BvmCQXxuaAj2y5IlmTbUwADsm7o60YiLASR2PCsqUL7f24vjrVboz7VrZ7ckVU0KsadKSnA/Q0Micy4SwefcbsxbNIpnoqVHswUhPR6UMkci4BAdH8czP3AAc1NSgnUi7+tE6byDU1PYOzj7XKbl+N3vBCh8xx3IxmQ71GbD2Lu6RGZeWRn2DS5tZuE1xEHMcBhrycjkMcSQwsXnQwnl4CD0rCzT0/Bb+ThD8pNPfhIBjmuv1R9ESCSIPvxhUd1kiCGzLfMKmGPH//XXYZBwZorJBKOiogIgi8uVu6nA+ecTXXQR6tRDIRghJhPAidpa/K24GFkuExOCD2B0FAqWgR6HA+Oy2WCI8ljY8M0WdZ1Jt63jQbTKOpkvy2LBfH7lK7nvXy5jbWjAvDIJdXExnh+XuFqtAJ+qq7E+uANpNIpsgVAI16qowP+few5/e+c7BQClh8dFz/0rI2AyYNfZiSyKRYtgLKdSWBM+n3AGrFbcn8sFp6GzE/clgznKstJc0fvmZszXxz6GuXzoIazflSv1ZddpZaIqu96Fw3jGvb2iZKq0FH9jQKmnZ+65bDo6kP04NQXn68ABzI2a40mk7mRx+brPB6AxkUAJqwywyVkscsddLk/i5xQMar8XysxFtXeCM1y6urA2JiYwpuZmnIevW1qKey+EK9EQQ05kiccBlnD26YoVeG+ffBIg2vg49BfTUpjNeOc500iWZFIE6ZgfrKoK5/j976EXZACERcmFw1QLAwOZ4BmDfcEg9AnvCz4f9jAZjGc6jWXL0oMzk5PYMysrBSerHAiqr4feaWvDsSUlCGDKupGrFriJAWcNEmF8ZjP0kccD/bppE76UDXDmQgq1p5qbARp2d4vs9URClN96vfh57VqhR5UAYFOTerCF9/TxcYBnp5yCv/t8GCOXtsmNe7hcNRzG/2w2rAnZ3pVpOaancd/xOPh3HQ7sz/39eM4lJTj/xATOFYngq7JSNE0zmUS3+D17YOOWliL77sUXTxyb1BBDjrZMTMDuZB40pcTjeN8mJo7+2E4Eec97oMOuuQZ6To+Ew+D1u/tuohtvnNvxGTL/ZF4Bc+z479sHYvWqKmGgcJnimjUwpnI1FTCbia6/HkZNXx+MlAMH4OCGQog2EkFZhkLphkwwCAN2eBiRznXrYLgND2M8TmfuqGu2Dl4nUidFrbJO5vY7ckTf/ff1YX6bmvBMampgJDMYEo8D5HvHO9ABqbmZ6FvfEoYyEYA95lfxegFelJTgGVksADrY8CXK3rFzJsKAXXMzQOZdu7A+Dh3C2ubOdtEoxsrkpjYbNvADBwQfjcmUmRWlp4TY6YQjQQSQp7lZX3adshOdUvh5P/AAHLeeHtxHcXF6FqnDIZxDNZ6c2RL5PVu6FO/r0BDWmJrjSaSe6cllRB4PnKyaGqLf/AYOJwNsvJY4c4XLpnle5efU0pL5XqhlLirfCSJwDTJQGIsBYB4exnyXl0MvNjbi3tUAVEMMmY8SjQKgf+opor//HXqPs704681iwTvEZX3MO8vvjxKUU+sCF4lAB3DWLINyaseycJdsPn8yieMdDvwcDkMXvPIK/m6x4Mtqxb5XVIRAARF0qdOZmTHNe2UqJUCnN99UL71fsgTneewxBE244YHPJ4KM3MSAKUWmpjBOsxnZeh/6EAKgR0P36LWntDLqLr8c+9yrr0K/V1RgPoaG8JkzzsAxZrM2AHjqqZnBlsFB2KqVlbg+Pw/mfHM6se87HPgcd0UdHsZ8Wiy4ZlcXsvqU9u6KFRjDs89iL4jHcQ7m/+MSWs6ujEYBBjY2Iquxu1uUHHs8OHZqCnvIWWfhGieaTWqIIUdTDhxIbyqoJlwBdu65R21YJ5Rcfjn2sjvuUA+CqUk8TnTzzdCvn/rU3I7PkPkl8wqYI4Jh8L73IaoXj8OQ5Ow1Jk+Ox/XxY7S1gceJjazychhlFgsc5+5uwRvncuHcIyOikUAohJe6uhrnW7QIxpXDAcOUo64OB4xniwUgXlMTQCOtDl4nWkcsZVmny0X08MMw9vXeP4Mdq1ahKYLHIzj8iGBMOp0wJjmr67LLhKFcWiocGK9XGLWcAVFRIfhVZJLlUAhrbC7SzOUMs23bAGIFgxgbr52JCUSsEwmRmTA1BUO/uhpz5PGkZ0Xlw6nW3q4/u66xUV95UFsbutf5fHi3iosx//yZVArzzmD1+PjccNloce0tXIh3cN8+cD61taln/vX1oSzIaoXzxE58bS3W4e7dmMt3vxvdV7lMdXw8vTyZ71lZ/iu/Fz6feuai/E48+ij+5vUi08/rFZxDlZVYp7GYyPrMBqAaYsh8kh//mOi734WuZbCNhZtHxWICoGMQy24Xe4Qeg585arkEUP6MllNGhPddWebEABxR+nm4E2s8LgKFRLjmxAQAl7o66FTOhiKCHWKx4BjWQXLp/eQkdMjOnYKrtKcHDiM3rFE2ipApRUpL8XtzM/aoRx7BnjHX+idXR1S2J5JJAI1aGXVf+hLWyJYtsB8tFgBU555L9IlP4JhcACDvBRxs4ez81laRSa3Mdnc4kL3x97+DzJznkjMe9+/HfHPpMNu7tbWClmN0VDQg4+dsNuOaFov4X1GRoGaoq8N19u4V2XU8VnnvOhFtUkMMOVrCduFsHWeIutx2G+bw17/W/5l4nOiLX0R10KpVczc2Q+aXzDtgjghZKqtXCw44hyO9m1Y+vEpK0GhkBCDJ9u0wvrixQH29MLqLi/FZBgYZzOGIaSQC57yyEsczwf/69TACBwayd/A6ETtiyWWdzOGTz/1zFlhxcSYZv9UKUM5kIvrLX8AJxEY3G8pbt8LxqKhIB3GZH5AdIyXJMpfIPvQQ1tpsOxltbegu9JnPYN1yyVRREQzpZFJEwnn9hUJYb319cJzWr0/PispVQixnUeWTXZfPWrRaMfdPPw1HMBbD/HFpt80GxyIQEOOYbcnVKS/Xe1ZUhHe3txfPoqQEpfJr14oMk337sL6uvBIO6jnnEL3wAu7RbhfcTdnKf1tacA2tzEUe686d+J07Qyu57yIRzPX11+N5nUh8lYYYoleSSbyLf/gDAg8DA8iE4owhpaRSAjRLpQBQEIly0nyEz5VI6OsUJ49Z7VzJZHoTAK1jiTBuzm4uL8fYBwexx9TXi88mErB5uHSRu9xzswBumDQxIRpCvP3t+EwwCBBoYAB7ajAo9g6/H/vM6tXQS0cLzNGj57dtQ0ZFNJodUIvFkC0YieC4D3yAaPPm7E2VZABw716i//xPzM+ePSiN3rcPP3d3Y17Uuu+uWoXPnnQS9HZRkbBpuTFFaSkCu2wbMC0HZzAGg6I0lZ8/77VVVQAjW1uRJfLaawKgXLIEJbZdXQgoNTWlz6PJBIB1xw6iv/7V2FsMMSQfUbOrZ3KcIepiNhPdfjv0+L59+j/n8xF99rMIinBm+InG927I0ZV5Ccw1N8PYfP11GAxMeMxcTmrE9NlEBo1WrUL5xZYtQNL7+mCgmc0wYhg4IUIkkksLiABgnH46jKBduwSpc2Ul0T/9E7o4xuMwiMJh7SwlJWfYiSa5ONDU7l+ZBcZlNJEInIpXXsHnFi0SXGhsdN9wAyIi3/wmwCDZ8Cwrg7HM5T/M88VR62gUn+npQaR8Lso5XC5Er5ua4EiOjQmQ0OUSwJbTifUXiwHEYbC4oQEGtyxaJcSrVwPYjMcBBmlx4xBpN3nQK6edhq89ewCAcic5txsbXyyG+W5tnRsOtELWGVF6VsTpp+McDNzKWS0mE57J734HR4dLfdnpGhsT854re03PWJmHSD6GHTcijG1qCjrxRAH0DTEkH2lvJ/r3fwc4zuVDuUTOZGNQjcs98xVu1mOxqINEyuuxaIFtDKTpFc705my5w4fhqJSXQ89u3gy7hDPOufSeCcgXLYK+SqVE0MrhELQgpaXIlNu2DTbM0JBofCUHvIiOXoAxl+4sLgbA2NCAZhhKQG3bNqKvfQ12XnMzxhoMwnb4wx/w99ZW2IRbt6Y3QmKRAz0DA5ibp55CgLahAd+dTsyXz4frFhdjbs4+G+fo7sb8KR308nKce2BA8LQ+8wzOWV0tgltOpwCEuUkEA3YjI6IZyfnnYx3IJb0+HzhNFyzIXLceD2yiQ4fAyVRff2JxIRtiyFzKsmWze9yJLDNthtjWRvTb34LSiPc0PfLCCwiuu90nJt+7IUdX5iUwZzYjO+2xxxDFk7uOcTexmfAqmc0oiVy/XmTLFBWJyCTzxxQVwRji0taBARitn/sclAt3djObEd188EG89PE4gJ7iYmTgEAmDmjNfHI4Tt5OiniwtZcajWhaY243/vfQSnsc55whwVo5iP/44nsmZZwKAksVkgtHd2ysyLaamcB7OADjttLnNAOAy3ZYWrKeXXoJD5XSKEisiZDG0tIgsrHXrcJ9jY+rOj1o26PbtYh1m48bJluWlV5qb8T5MTyNzIxzGPYTDosyHm1p0dc3+BljIOlNmRXAJelVVOtcc8xS++Sb+tmoVnFp26KqqQEZbV6fPwNAzVnY887kfQww5kYWbOLz5JsDxJ54Q3ScLFS435K6VFktmmamWcKMI3oempvRxzGmNQy9fjvJzMpjHWW3MW/bxj2Mv6OzE/0dH8ZmaGhFs5M6cHLiSaR5MJujG/fuh85Ytgy0jVy0QaQc+ZrsTfTbdmUphnBMT2vvL1BTmZuNG8XnZfrj/fujz7dtBX1BRAXtBBiHl+/X5kCnn9YKWoK4On/X7kb12+DC+uLt8fT2CV1rgosmE/WV4GPZuJALeOpMJe7/Tia8FC7DP+v0ik44zQONxXKu7GzQqSoezt1d9Drk5iM+HZ8wluQbvnCGG6BMOgGTT5WazkTE3W80QV64k+uEP0XlVb3JLNAqezmuvxT52IvK9G3L0ZF4Ccx0dMHzKyxGt9ftFN7P6epQlzPRFMpuJrrsOSPrAALJQGPybnBTHVFXh5337BIhhtQIcXLJEnZNkagoG0ssv43eTSZROchbRihX6O8wcb5IPB5osallgXIqzdm1mJFsZxdYq7/R4QO5cXEz0/PPqGQCpFByALVvwddZZswfOyY5FTQ3mZHhYlDFxZ7YFCzDmZFJwybjdMMa1NiDOBu3oAOePXm4cPVleuUQGU00mOICHD2PsJhPGsHgxnJJ77kGmy2xugIWsM2VZlMMhiLP5/fd6oQM6OzHvlZX44o6M7NDt2EF0yy361omesa5di99375797EZDDDne5PHHQfbc1QWwvxAQi0UGzbgZEINUfF6bLZNrTg1o46Ca34+fuQFErvGpOW/5ZMvlkkQCAcI33sD+de212Pd++EPovUQCes3hwPEWC/ZUuVEPi8uFe3e7RXMrpagFCuaiE72W7vR4cL2ODgBVHR0AsmRAzecTz0lZ5swZ0U8+iRLThgZhc3Lm24YNmWWpgUD6HlJTg+N27gRIyN1Wec6efRbVH5WVsEvU5tLpBAg6Pg5QNR6HvSJnN1ZVYa8fHMR9BgKiE6Tbje64CxeqO5xqc5hK4T64ecSCBQAl/X5c6/BhPEuDd84QQ7QlmcwdkCk0CHOsit7gCx+3Zw8qT6ancazsn/T1obkDz8/y5dBzWjqnowPZyqecgmxovcEwvx9d1M89F9cwuDUNKVROeGBOrS09Z7Rs3IhjONPMbgeosHcv0UUXzfxFWrkSNetf+xqAEs7MW7xYZM05HDCW1EAMLU6SsjKUVj71lOBD44hmKiWi7ffee2Ki9flwoClFmQV25AjRz36mDUbIUftVq9TLO/nZRaMwepuaYAhzBgBnSY2OwgD+5jeRfTdbac5Ko7i+Hl+cqdHbC4eASxaZANrh0JclpbUOS0pgbHd0oMHEf/2XAPlmi2OBwdRHH8Wm53CIkuFoFE61xYIxTE8T/fzns7sBrl8PIGvHDmy2XOastc6UZVGcMTI0BAfLbscxY2NYF+x48TtLVBhPpJ534vLLcezAwOxnNxpiyPEiySTK7r77XbyLs+HQyMAcB2FSKQDyFosA6BlUYS65VEo0jCgqwjE2G4z8ykoY+ZOT0K8+n7aTwJl2VqsA8ZSZb7Ml09NEzz0H+ofyctwr0yQkEhi70wmAyGZL329YgkHcX3099ic9gYK56kSvpjvDYQTQxsehm91u3IsSUJMrFOT743vo7wcw1dyMzLfeXpyDswg5e5pI3C93Q5Wz36qrAaRxIHZ6GnNXUYH5HRgQjczkclt5HDYbOODWrBHUHaWlOFdnJ2yXJUtw/9whnBtFJZMILms12FKbw1gM9kA8jjmsq8N1vV78LZnEXKxfj9JYQwwxJFMOH9YHzB0+fHTGM9eiN/jCx3V0wEb3+6HfuClNaSl09N/+huo4mw16kamhrr8+c7+QfZ0zzoD+0juvJhMyq//2N/y+fPnc0THMdta4IceWnNDAnNoLXleHbLOlS3EMg3LcAILb2c/Wi3TxxQDifvELjCOZhGJYsQLGXbZStd5elNe4XIIDjw2u2lpwi/ztb4IPJJkEULJixdElT34rRIsDTQY4tZSXzAnIToXe8j4lsCeft7cXkWA2eIlEKQeXhpSX49nNZpqz0ihubMQ4BgawGcndZ1MpbGANDfj7vn0wxn0+jF9tHaqRYysbXBw4gHN/9KOz352orY3o6quRMVBejuhYMol5ttngAAQC2Hx//nN0gJ2pyLrD74fTMjSE97W2Fs7N+vUC+OR5U5ZFmUx4H30+zJnDgeOCQWzitbX4v5KXpxCeSD3vBJG+Ywwx5ESSZBLv6TPPIIPp6adFBle+JaJa52d6Cu5qSYR9mXV+SQl08+bNON7jge6srIQ+Xr4cnzlwAN85ss9/+/znETSsrIRusVqhv10ugHe1tYjy79+P4znjyW4XQN1sZlZEItCLIyMCWGSKCJ8PepnBxAULRPBBBt0uvRQBxFyBgmQSGduHD0PXJpOifGs2MhNk3Sk7eq2t+OrqUgfUuAOvMrhChHsfHsYYi4rS9wKvF+tkdBT7diAg7tfpzCwL5c8QiQZiLhfutagI66q/H+drb08HLgcGcEwshqy5khLs6UNDYt07nVhD4TDAuKoqjGnBAmEv8P1pBY6U+8/ICOyeJUvw+e5uYavabJi3I0dQ6ns0uu8aYsjxKOHw7B53LIve4It8HNvZVVXQt34/fGsiBLSYamHJEpEI89hjKOf/l38B1RDb77KvwzzuS5eCHzObjcD7fWkpPrd9O7Kk54LvfS6yxg05tuSEBea0XvA9e/BCOp0wjDl6Z7XCMFq2DIt9Nl+klSuRJZUPwt3RQfTjHwOMsNmE088lEWVlAnA5/XRET5XdZU/E7qyyZAPJ9CqvQsoVZWBPFuW5iEQpBxv0DQ14LkSzC5wqjWKHQ/AcrVuHTW1wEMeWlmIM27fDGI/FkEGiNUfKLDAZbCwrw7yPjuLdmqsGF9xx9vBhvK/cNY5IZKN4vch+vPbawojXWZS6Y9EiOCtdXXA6/+mf4NQoufbe8x48S+V64lKkjg7oHna2qqvhSMs8Q/L9FsL3lu2dyOcYQww5ESQaJfrBD4h+8xvwsnLnyVzlpPmK2QwQ44orkG3P5z/pJAHE633PTjop82/ckbq2FrqIueciEWRNNTfDIaiuhiMxOQld6fGAEy4WQ8lpR4d6Z9mZSiwmMrMWLxYl+1NT0MWNjRi/EnTTG0x47jkAc5GI4Fdzu3Hf9fU4/0xtHdaLW7ZkNnoymdQBNb8f12e+Wlmmp3H/y5YJUIv3AjmD3uNBabAcUFTuIZEInu/0NM7jcqVn6DEtRUUF5n9kJH0uTz6Z6Fe/Ehl3K1YInsBkEnvq9LQI7C1YgP08FsNnlMEjLYdT3ls6OwG6NTcDUA6FcP98Hs5emZo6cQPIhhgyUwmFZve4Y1X0dK3+4x+hT5U8zomEyN7mpIFkEv/jTDmrFX5/eTmCdC+9hO+rV0Nvvec9Qg+6XIJ2gsG5gwfVbQWzGX+32YTf5fWC8qGqanb53ucqa9yQY0tOSGAu2wve1gai5+efhxHDEe5UCs62xwPDRutFKjSFVAvMUTvvyAjK9ri7JyuLeBx/q68H+s9ASWMjlI7cXZY5uPJF64+3FFm1ec1Hec2kLFZtLPK5GLByODCW4uJ0A3e2gVO1Zg3btiFSHYmITaWmBg7B5CQ2qaVLs8+RnAVWUiLARjayp6ex4bW1AfybCyO7pESUgHKmgCypFMY4MIB75k51uSRbqbuyfPyMM3Du++8XHfjU5k1tPdntIjPmyiuRVfjww3B+mCxevpeZ8L3l0jXyMXz/7e3Hx/tuiCF6JJkk+upXif77vwGeZJNCMubMZhjinKV2ySXo5JaNu2YmsmcP7Ba7HTqbS0THxgBULVkiOnFzp+XBQWTsX3MNggqvvYa/j4/DyQiHZweUJBLgVTQqAp9mM7IDa2pwze5uddAtV6CgowM61+sFYBSPC77Rzk6cf8EC7LMzDahy4w1uhsB6ORugdt11yMJU2g/cqV3ONOdzVVdDx4+OgkdU5pxVs0mYliIUwvxUV6efkzlji4uJPvQh3IM8l319ADblLDx+9lwG7XDg+UxP4/hQCBni69dnBo+yBY54b2luBvfdyy9jruSgsZy5v3z5iR1ANsSQmQjzkM/WcW+1aPmYapU5LHKW7rZtuXmcBwehE7k7On8PBuETJxL4bCyGPZXt9yuugF7r68PvExPQg06n2Me4kRPrTdajJSX4XziMz2zbhmOWLZudRB81XIMz4Jmz89FHiW691bDhj3c5IYG5bC84p9GPjOBFHR8XZSg2G15cNnq5XIJlrlJI5fNyWeDUlCCLDoeFAorFBDcVZ/q9/jrGLWf+rVgBheNwAKzbuze3430ipMjqjbrIwJHeqL0ekc+1dasAv+RGECxzkeYsgzKrVhGdf77YBBnIDQSIHnoI62vlytxzJGcCLliAuWUjWzawOYttLozs5mas62hUvXNeJIK/JxJ4t/VIrlJ3pe4gyt2B749/hKOltp7Wrk1fT1dcgf+9VXxvHR3YyHfuxH253Rjj5ZcfP++7IYYopb2d6AMfQMRaj+QDTpWV4b09/XTogKqquQezk0mAG/G44KmMRPB7fT0ciN5e0RXV50vXIUTQRePjyPblRjrsjPj9ws4oBKjjfYAz8SIR0XjqlVcAjq5Zkz3YpxVM4P18agqB1Olp2D+xGPQVZ5L19+McIyP6qBSyBSC1urRmA9SWLs3U92efDdDpyJHM4AsR5v2ss7COlGNR2iThMJxDqxVgsMw/x3twRQWCP2VlAowLBPC9qUns4W1tOGcqhb9FIpjT+np0WP/737GGXC5RtsuZ33w9PYEjBhh374aD63SKxlN+vwhU5mpAZYgh81nc7tzBI27QcqxLNh9TzlZTE/aXRkbEcUzPUFQEHbZgAfbHaFQAc/E49Krdjn2C945QSABzbL+/+ir8mCefhO9cVwddz030GIxjaohkUiT3cOAkGsWxgYDgv/7whxEovPTSwuYtmUQm99atokmhTCckc3Zu2GBwdh7vckICc8rSO1n8frxcySSMBW5F7feLGv32diiKCy4QBJFzlUKqPG8sBhBtYkJ005SjjBYLXnyfDwolFMLXokWiM9jhw3hBnU44Dj/5CRRLNqDtREmR1Rt1UQJHs1nel60kRpZc5Yqzkb2o5vD09mJza27WN0dyBL+jA+8JE1TLBnahWZp67+Nd7yJ64gk4aS4X3oVEAmvbZsM4IhFsprkkV6k7c/DJkqsDnzxvektK9QDC8TiibyMjuLeNG2dWqsv3f8cdyMJhgyOVAii5dy/Rl798fLzvhhgiy+OPgzfG48nvc3ocnxUriL71LWShHU3p60MwoKlJdNsOhUTgkJv4MDDldKbrkN7ezD2xtpbowguh08bGAIz4/fjq7c2v3DXbvB0+TPT+9xP953+iCVYh997ZCV06PQ19xeVFnKXHjbscDlAsnH9+bpqQbAHIbPQWRAJQk7PctPR9Vxf2Ga3gy6pVWFNaY5HPOTREdNtteFbsDDLI5XTC2Tz5ZJz/rrsyz3nqqdjDX3sN5ygtxee5M/iiRfhfMon9Ze1a7AXd3dgnzzoL18kncNTWRvSJT4D3MBAQpc1yoNLnK4y2wRBD5oMsWpR7fzKbcdyxLLl8TM5Wy8X3XVcnstoGBnA+5mzmjs9WK+zmaBQ6i4P6zPXNVBO8b8j2u80mAD+nExVpfB3+2/Q07GbuvG6z4W+xmLCnrVaRRd7VRfSpT+Ga+YJzvF9t3YogR0UFMIpAQDR7ZM7OwUGDs/NEkBMSmNOKeBIJ/jguCWGy23gcyo1JHAMBGPnDw0Rf+hLIIvVkYRHpB1PUsrtGRvBim814yf1+8bPMi8MZcgy49fTghY1EcD/c9bWpCUZQa6s20FZIltmxKtlAWaLswJGeEsBsogTSNm5Eh7RduzKPzRV1nsvsxULmiEGkBx5ARufoKDYoZSZgodxoeuT97yf60Y/gnHE0zGyGQ8LErytXim7LWpKr1L2rCw5JXZ0wiHw+bHoMCio78BFlzpue9ZQLwPvTn2DMHDgAHWCzgYPq05/OHyDg9enzEX3ve4gOckMSbqIxOYm/338/ulYe6++7IYYQYW3/7GdE//EfuUtX1UTp9NhseJ8bGlDCfu216IQ+U0C8EAkEsK83NQlaAtZBsRh0kslEdNVVyHZV6hAtfc8lr243sumKi5HlNTaGQEBvL86fTfSUAUejRN/4Bmyr229X1ylaQSgeu9uN+9+zB8fLThFz651+OnR3tmxtvQHIQugt1PR9tuDLqlXIzMg1FjkDPhpF5sXwsOgEW1GB+VmyBMfce6/2Od/9bqK//hWOHVeJsH3Y1QXHtb4e66G0lOiccwQ36iuvgI8p30qC88+H071lC55rUVF6xv1MaBsMMeREl1BIvXpD7bhjTWSb86GHEDDTqtJ59VVkGO/Zk53ve+NGUD098YTgVS8rg64bHMRx3LGa947iYuhBDmaFQoIXlvk/XS7sr2Yz9B6DcczparGIxBinU3DVcidy7obOXdh57+S/Dw0hQLV0KeZAbZ7UuNJ5v6qtxX5tsaAZRSwGX4B9EZMJ92xwdh7/ckICc9kinpEIXtayMnDJMSG03Q4jhYlwKytx7JtvoqPq8HDuLKxnnkGXVLn7Kht5am2ZlampRAK951Rc5owxm0WtfCwmUnCLiwGKeDyITlutIpqaSOCc7e1QTjU16kCbVpYZAxJFRUQ7dsBQX7JkFh/UHEg2UJZo7oAjLSCNo9T5GPhznb1Y6By1tcHBIsLm2daGjULO6JwtI1tto7Jaib7wBWxu4+PCqUwk8H6WlRHdeGNu55nXe1NTZlfm8nL8fWAAIFU8LtLFg0EAkhx90ztvuUQLwPvTn1Au5fNBRxQXw6DYtw9/J9IPzsnr0+sV/BfcqYoI32trYdw8//zx8b4bMr8lHgdX489/jjXN5PiFiskEQH7zZoBxubKv5lqSSbz/oRAM+5ISUYbDpacuF+ahpwc/K4OBevR9ZSWcmd5e2AiLFyMDob0dNpDXm9nNVebXySWJBNGdd8Lx+ehH0+c1WxBKHrvLBceDeXyYN7W4GHvOwoU4v1a2dj4ByNmmt1AGX5qakCmXbzD04ovxbH7xi0w7c9067BmHD+Nn/px8zr17cV8DA5jPykocw1mTZWWwLa1WEbSprsY1R0dRQSJnCuoRs1nQNni9uHe1RiCGE2mIIZnCyRrZJB8Kl6Mlsl4fG8PvDQ3YX2VKH/ahOzvBh6qX3oWz2uTO0pWV2LcaGoguuww2weuvQ7dx6StXzdXXp3N+c9Z5Mok9tKUFe+rWrQL0CoehH+Nx8TnmnOPMOQbt+G9c9ppIIMBx++1Ev/td7v3vssvSE4KIMJ5Dh3DNVAp+f3Ex/qfG2SlTGhgc0sePnJDAXC5Cfya5jUbxIjDoxSWujIwXFcE5f+450c1FjSvE5QJw9dnPilI3/ix375LBFGVqKneJWbECysflguHNythiwRi5Swxn9nG2XHk5fmb+LXauEwkYWqEQXnomDFaWKqpF1OX6dU4B/t73iP71X4/tFNnmZiimoxmdzQWkvfvd4DvSY+AfjezFQjrRslitcKy+/32sMbMZ9zs1BaeopAQZJjORbI4aA1GcRTYyIrjybrxRH1AVCIj3kslcZW7GVasA9O3YgfuKxTAGq1WU8G7fjsidHt6dQkqS43Hco88HcEx2stxubM4/+AHRO9+ZG4hUK5ePx6FDjhxB2ju/+2yAjIzgeRrAnCHHqjz+OIiO9+/PndmlJVYr9IfbDZ36gQ/MbROHfIT1YEcH7nFgQABokQicnWBQZMf/4Q94n887Lz0YqFffX3opsq3YZiotRWCJMw+8XoB0oZBwiJh0W4/EYmhA8NRT0Ne33oryq2wZXjfckM5v6nLBFuPz+f24vyVL8HO2wEi+NBezSW+hDL6olRdnG4ssK1eCIkPZ5Om++8AX6nJhfciZ7PI5zWYAdy+8gPUyNoZ9zuuF42mx4JqcSWIyweELBPC3Quk9ZgvoNMSQ+SRe7+wedzREaXMWFWEPGx+H7bxhgzrfdl1dbj3R2wudtWYN9i6fDzoqFILPHY2KRJKmJjRn6uvDZxhEW74cOlBpv7e1IQDGje6OHBE8cuxzM9hmNmMvslgEpyon1cigoRzASiaJnn0WSTwXXpjdd9y3DzqX+a49HtzjxASOsVrxN6cT/1dydu7Zg6Dl8cwZP1/lhATmiLQNgTVrAFh5vYJEmEiQRHJ6/+goFv/UFBa5xYJI5LJlOLesVNjgs1ph0NjtOO/EhEDOGUxhzhFOTa2owOeGhqBg1q8XvHIcoebmFPKLbrfjZWOnnHm/EgnxZbHgXDYbrufzAcRTltwpI+oeD5RnKARDjDNq9u/H2N9KvrlcIEdXF+71wAGAYSUlcGSam3F/DgecE44mzNT50gOk7d2LLK+BgdwGvh7nYd8+AI9lZYU5CzPtRKt8tzo6RLQumSR68EGkpReyAejJFrz4YgBSenjX5FR6nvu9ewFsEaEElss4+R1cuRJfExOCBDuZBIC1Zg3eg+FhgOrnnov3REm23tsrnKbt27EulZtjNqdv2zas4dpa9ZKpmhqMI1cHWq1yeZMJG3osJjoG83rTUzZhiCFvpdx7L4CdqanCz2GxQHecd96xkR0ni1IPnnoqdA5nz5nN6Rn13Ajh8GEALnIwUK++17KZuGlNayscih//GAAQO0H5CFcCvPwyAlZ1dbCpzjtPPcPr8ceROdDfj/G43XCwOOBYVCS6jB85grFqBd0KoXCYKb2FluQaS3ExAiM7d+J35R7P4+roANjp9eJcLhf2Et7LZAeY7y8YxHr61a9wTE0N7NDxcZzH6cS+I+8Ds1FpMJtApyGGzBfRmwU+02zx2RI1mzOZhF5xOhFAkRNFiNL1S0tLdj2xZw9sb26ASCQyypnfjf928CD2hptvxr7X14f9kXlJ4/H0pILNmwHq7d4tGt2VlooAPWME7BNz0L60VNBIyd1a5ew+TrCZnib63/+FvZHNd9y6Ffe0alW6T75gAe6D+bWHhuBTrF0rODsjEWTlRSLHN2f8fJUTFpgjyl5C8MILUBDc0SSVEqSQiQResHBYZJakUjCMucvVWWchvT+VwgsTi+HcrCgcDlFi6nDAyOztTX8RifC3oSEoKa8XgMvwMEAGNno5FdZsFi+v2QxAgQnwk0lchxtYxOMw7hwOfJZ5aogyjSw5os4du0IhYdBxt5t162AIvlX167l412Rn5swzBWn2gQNIAW5sxDz/6lcwZmcjeqA3Cj8woM/Az2Wwh8PYNL75TWxyhUZBZhrB5nfruefAR2Y243e3u/ANIJ9sQas1OyBFJNbL9u0A4oJBvBPxuADc7Hax0fL7+vrryJoZGUFkjQliOfOyshLPYGgI36uqxLwRCeLt0VFc127HpinzPL7xhuDyUVvLIyPQKZymrhTumJetfEGrXL66WqTbFxXhXeefUymMqbIS927I3MkPf/hD+va3v03Dw8N02mmn0Q9+8ANav359zs/9+te/pquvvpouu+wy+uMf/zj3Az2GJJlE05I77xR7bSHicCBi/elPH1uAHJG6HmxshL4IBgUJtdWK/Z+zmNhOicWge37+c6IPfhD/b23Vp+9lm0kOZnCW2oUXwnnp7UWwYWgIey43kclXRkagc30+8PqoZXhdfbUY+/bt2NP7+2H/OBzQ15EI5ue667Sf5VzQXBTaoCnbWDwesb888ADKmdT2eOU68fkwJxy44aoHdoD5/lwu7D9NTQBGx8YEnYPVivGMjkL/z3alwVwBnYYYcqKKlg1Y6HFzLWo+UVkZ9BDTMciJImr6RUtPdHQAcOImD+XlAN66u0UWGxHOyfQHY2P4zJNPQr+dc452UsFDD8H25W6q4TBsZ7sd50ml8DMDb6kUdGd5OT538KDAE5ivnhNsOOknmcTe+atfAQSsqIC+lX0Mkwnzd+AAEoMOH073yaenkThgNkNfu1yY31QKe+P0tKgkOp454+ernNDAHJH6C87RY26D3NMjSlgTifSOLpyuarNBAfj9ogMMAwSMkg8OCgCtuBgvSmkpPjM+DuWhVFgrVkBBsbHd04Nrc6Ybl7DKKbF8fqcTSm5yEn/nFNpwGACJ3Y5rMEml34+/KSPLckRd7tgViaR33TSbs5dYzKXkyqS64YbMBh0tLZjboSGAE5yRmAs8ysfYnkmzCTXJZbBv2YJnUlsLsHQmUZDZiGC/+irW3Bln5N4Acs1roR111YTXy6FDeP7xODZPvx8brNOJcQwMYLPjFuscFeN5aWkRGyxLTQ0y5XbvRlkvv0tyNmxTE54JEd5fmeexpgblXC4XnFy19VhXh/c/FNJ2Im027Q60ap2c5HL5lhYBwCeTosNTIIDfzz3XcKDmUn7zm9/QzTffTPfddx9t2LCB7rnnHnrHO95BXV1dVCujqArp7e2l//iP/6BzzjnnKI722JD2drwbf/+7fm4zNVm2DBl3mzcfm4aplmPT1AQD3ekUGfHFxbBBQiHRBOfIEei5XbswZ1VVAtj5/Odz63uzGTbEk09qB8GWLBFl7rW1RJ/8JHRpIZJMIovZ6wVIyMtf3jtXrRI6+U9/IvrpT2FTsQNUWQnH5k9/QumP2j44EwoHNZlJgyatsXBmxPAwynzXrMGzVdvjleuEHbSREeh42QEuKxP3R4TPrVyJYzjDIhjEns2NjsbGsMfMBQ/cbHScN8SQuZZjIXjGPGh6uoYfCxIICC62kREBOLGv6/OJzuImk379woGI6Wno+OFhkR0s859y0Mpkgm/udGIf/MMfwHWZK6mgvx97SlOTaHRXXAwdGY+nc8YlEtCR1dW479ra9Eo8kwnnkkE5Itji3/wmrsXz43YLOp2aGgSaXC5UxrAO532iuhp+v9UqgL3+foyBG080N6tXv5SWwo985BEEX8rKDP17rMkJD8ypiZwtFI/jRZqcTOeX485u3PmKuTcYJJuawsvlcglAzGKBg88Zd5EIwJNIRCx6JYhTU4Nyg44OGEWRCF5gJnmensY5w2GR/RYO4xwtLXixdu8GUDg5iZeuuRkvdXc3XlaOpL76KsaqFlnmOfnxjzM7dslcJfkCTbMhejKpfvlLKGjZmTGZoHT27sXcMbBpsWiDR/ka27Mdhdcy2FMpjG18HGNtahLGeKFRkJkax/kAaeFw7nmdLZCT1wtvkPG4KM0xmbCJ2e0YAxEMhEAAm1xTE9YK82JoPddQCA7v2rV4D9WyF8bHcYzdLrIXqqoA4PFmrbUeP/tZdFzatw96QH4uyaTobqXWgVatk5NcLr9hA7J9Dx0SRlJfn+CrPOMMok98wtio51Luvvtu+vjHP04f+chHiIjovvvuoyeffJIeeOAB+vznP6/6mUQiQR/84AfpjjvuoJdeeokmJyeP4ojfOuGOq1//OoCpQsVqJfr4xwHKHctrW00PsuM1PCw6yLOjFgoJ54DtGSbwb2yE/sgneJNv8yHm9bzxRthEhcrQEEp8rr4aeku5d5rN2KP8fuhGpxM2jt8PuymRQIms06ndUXr9ethLO3bAdmJnLF/waaYNmtTKi4uL8XnmEly6NLutIq8T3l/GxkRJakkJ9rKxMeybfH/BoPgcd+ZlKSnBdQ4dgkNYVzf7PHAyd+L4OO5lxQrYpMpuhYYY8lbJsRI8KynJzeXJ/MfHgoyMANB6803B386A04YNIhv4yJH0apNc+oX9jeZm6CW/XwShWJJJXM9uF9njfj/2yHvvhU5jGplcSQWLF0MP79kD/ezxoDM1N14igs7mTHaujJmeRvM0tu0tFtG4MRoV/nwgIM4VDuMaso1utyP4xY2diopwf9Eorsd7ezAI39/jQSXfyScjG0/pR/Ee0dcHH2jXLoB6S5bgegb33LEj8xKYI0rPFtqzB9lWW7bgdy4hdToB7DDIxsJGcWsrFAO3T5YbSXAHReZzamuDIajm7NfU4OU9eBCKqqICRqbbjfPHYqLM1mYTL7nbjRdtclIAacXFeMGZUw6/ZxwAAQAASURBVI3bKnM5Sl0dXtgnn8yMLLe1Ef37v4uOXVVV6Sg90dx1Nc0megGgZDIzy4ezESsrM5+jGniUr7E921F4LT6goSGxPuROQmr3oSfTKVsnIJdrdrMF9+xBhliuec0Fck5NYZM6ckQfT19ZGTZieQ3bbNjwgkHRHW7dOgHAE8FZOOkkvCt6u88q1yhH15gvsrQU988t2HOtx8FBzMstt+AdrqkR8+bxaHegjcdR/nTwIMZdVgYnVy6X37kTx5WUCCefOztWVBB96EPGBj2XEo1GaefOnXTrrbf+429ms5k2b95MW7du1fzcV7/6VaqtraWPfexj9NJLL+W8TiQSoYi0wPyyBXucSHs70W23Ef3lL+nvSj5iNsP4/M53oN+OddHSgzU1MPxHRwWfUCSC46ursfcfOgSdVloqOpbmE7wptPkQ835+5CNEv/1t/txzLJOTsE3e/W7oOeXeyXrW5cLaCIWgm5kn1OsVn9+8WXxOBoNGRvDV2wt9nS/4NFsNmpR0Eq+/ju8WC+Zvzx7sdRwYVe7xvE76+sRcVFbi7yMjmEsigLnnn59Onq61z9bUEJ12GvaBT3wC157NbAo5kz0QwF4bDuPeX3gBHQv1dho3xJC5lGMleMaBl2zAHFdXvNXS0UH0+99jrImECBbJHOoNDUSbNgmaBb36RfY3SksBJr3ySjqFAvvBROlNGKxWAGjsc1xxRW6fcv9+on/6J6KXXkJ2nd0uEm+IRKY2d3i12UChdPHFCC4dPix45UwmwQmfSuFnBu4SCTy7Q4cABoZCmMfKSgTe166FHxAIiKYPnDBTXQ2fYnQUx5x1FvaDRx5J1++cic282USYewb9pqcN7rljSeYFMKeVGcRlri0tRJdcgmjrHXfgxdi7F4uaXxoi8RmLBQu6txffYzEogWRSAFduN44bGwMgd+21uI5W+cKOHfjucuF8U1M4J5M5MrpeW4uxplIgfuey1VWrBBDx0kt4cT0eGFinngrjkzuUEmkbjy0tACp27coE5eaqq2ku0QMAMb+A0thkgISVM4Mv8mePHMEcP/lk/sb2TBspqIka/1s4jLGcdVZ64xHlfejJZNSK9r/wAu6xoUF0Fp5ptqDDgfdKz7xmAzlHR4lefBGb389+BpBZa2y8XoqKBDjG4nDgfRkfx/kTCfytrg5rhJ/hr3+NbIyDB5Hh1tSEd8zpVH+uyjXKfD0MqtvtOIbBRaLs6zEQyOxA6/Vm70Db0QFQ7pFHcG4uaaqtFQC1zYZ74rbuixfjfMy3d+QIdN9FFx3bWUXHs3i9XkokElSnqEOuq6ujzs5O1c+8/PLL9LOf/Yx2796t+zrf+MY36I477pjJUN9Sefxxos99Duu1EP6y4mIY79ddh26ruboXHyuSTQ+2tOB9jsWwP09OQl9z+anfD90ajeLvcmdNPcGbQugE2L7aswc69G1vg1MyOCg6uOYjAwMAYi+8MHPv5DIpr1dw7vA4HQ44SD09RE88IbgDZTBoakqU6wcCsNGuvBKAol59N5uUC3JZ1be/DR3M3eTlhkQbNsCWGxjAtQMB6Ozly7FXJRIiK9zhwNofHMTvq1fjPbJacd/JJM7V2QlbT77vVAp7wBlnYP5ncw9gQPPQIdyHxyPWRiqF8XzhC2JPMsSQt0qORvBMb+BMbgSoJdwg8GiL7Fu7XLA9x8awB7z6Kn4uLUVCwfAwbPizz4a+bWtTb86mBdYp/Y2aGuiJgwdhezO9g8UC3ZlKiaqU0lLoWZMJNv4TT4jKMzVxuaDDn35aVJz4/TivnB23eDGuy010OPhx111EX/0qdClzwXKzCnlsjCUQ4fuBA5iryUkRTGltJXrvewFC8t7AvnkqhXGddRa+OKtcth+IBG1NIgHboKoKvgGRyLD3eAzuuWNFjhNTtXDRW5poNkNhvP3tALa4jJRfIjZqmGCZu6KOjwtQiGvPQyFRglpURPQv/yIMDSWIEw4jU4/JHxsaRPYKI+zMI1NbS/TFLxK9//2oT/d6019U5hPZt0+UxToceEEXLICBxspby3icC6BppqIHAKqshFHe25vuzDgceGYTE5grdlTkzxYVYVPQa2w3N6cDvXqJtfORtjZwIXHn0WQSWZ1Mwq02B3oyGbWi/ZGIaCZgt4tuozPNFly8OLPEmEXNiVFbe/39APdSKRC3cjao1th4vTBfJINjfM2yMhGt53bnPh/Ga7FgvAMDyChdsABE2QMDMCxOOQVRLOVzVa5Rmey2pgabodUqAPuJCcyJ1nrk56i3Ay07nwcPCl2RSAjHbtkyOKwHDuDanBZfU4NrMdjLjuzR5pA0RFsCgQB9+MMfpv/5n/+haramdMitt95KN9988z9+9/v9tHDhwrkY4qzL448T/du/4Z3LF5Rj4uTbb88PcDlWJNcefMop0M1jY9Alo6PQY5ycwZnzysxqPcGbfOkE5Ey03buha7h79SmnILjR3p7f/bOz9tprIvOXhTvPDw+LLGYm4I7H8b+SEswd79UMBo2NiU7z5eXQyQMD4BnauFE/GDTbvLJEcGItFuhtzrKQGxJ1dmJeDxzAeK1W6HDmOLbbRafBaBTOWnk57mlkBPcp00lwY6K+PjyrsjI8u7ExzNlMbTy1YHhfn2iE1d8vbFu5gVlPD8qQf/rT4++9NeTEkaMRPNMbOGPOsGwi27hHS5S+NWdfnXoq9NiGDfif1yuoYmw2gEzcrE/ZnM3l0i6tVPM3qqvxGaZ44uaNbDNw80Y5AMFcrUTZq3NGRvAZpothLs6pKVSdHDkiOqJz53KnE4HtU05BAsGDD4qqNqa0slpFcEj5XFMp6OCSElyX7//yy0W1DVf6aPnkSvuBm/mYTLD97XbBmedw4P9jY/DVDNv/2JCCgLl8CTEnJyfpi1/8Ij366KM0Pj5OixYtonvuuYcuuuiiggeuR/LlAeEF3dcHA2h4WJSMJBKihJV5OSIRvFgWiygLi0ZFhpbLhdTdiy4CYMRGCjcqYGPW78c4OOJtt4ua9ooKvOT9/QAOP/ABjK+rC0pKLVWVUfFkEuecnsYcHD6MSEZra3bjcaYdO2db9JaLXnopeARkZ4ZIKGuOmKh9tqREf1nmww+rA70ysTafJxjEs8+3HES56TkcUK4eDxR2oZmMvb1weNxuQShKhOuEwzD+ObOrvHzm2YKbNqnzHSjnldehcu0NDOBddDqxdpnaI1smI6+X118XkTrOrGDeiWXLcE27HRuw0wkHZXQU4+F1VlqKkqjJSTyT1laRfSCL2hplsluOSDU1YZ3pWY/8HJNJ/I3J33kdqUUqvV7R0ZUzAdmx6+kRuspuhz7kZhjbt8MQ4nLZo80hOd+kurqaLBYLjSha6o6MjFB9fX3G8QcPHqTe3l665JJL/vG35P+F0K1WK3V1ddHSpUszPudwOMhxtK31WZD2dqIvfQnrmQNh/JVLTCai887Dvn88Z91o7cFNTaJJlJyByx2nS0sR3Fu9OjOzWk/wJh/OVNm+4mZRsRh0cmcndHVjI/TV3r35z8HBg0Q33QR9xgBrczN0144d2F+4Sy1nA8Ri0PnBIOaHwaCpqfQMO15LFRXYv/7rv1DeVF+vHvgodI70CGfgtbZir+/rE1ka7Dj196MaorQUTSGYW4i74VZUCN4iudSpogLgqJJOYtEiBHm2bEF2ot0Op3k2unFrBcNLSwFA9vZi/pkMvbgY1+dM9i1bcAw3FzHEkGNdCgme6Q2c9fTkDk4lEjjuaImab93bi9/ffFM0OquuFoCWxSKCy1rN2cJh7dJKNX/D7Yau6+6GnjGbRZCGCNdculQ0vSHCWC0WfK6/X92n7O7Gz7KNzlycZjN+5mCH2w2/4X/+B/pL1nnXXYfrdXYiI/rgQfgS3ERCTTi55/XXRdJPvj65fPzWrbim2SyAytFRPKviYuyX/PdAwLD9jwXJG5jLlxAzGo3SBRdcQLW1tfT73/+eGhsb6fDhw1QuM87OgRTKA9LWBmOwqAhcKQzMMamkxSL41w4cwP+4OxqXxnH5ayQC5fTww3jRlVxeb3sbMt9qa6FkvF44yR4PxsmGSn8/DKn3vCeT9JdIlAHIqaoMDjIJptkMJ/zFF2GscamilvE4Gx07Z0v0ZvFpKa8LLoDy93hw32qfdTpzG9uRCNpuRyLZgd6ODpSXFNKtjUgbUB4dxZi3bcMalu+jqgrlJ+3t2s+qo4PovvsQ7XG5BGF4YyOuVVaGv8ncZ7lKc3JtGE5nJt+Bcl6V61Bee52dyBBYtCgzu0xrbPJ6YUeFwTduI15WBuf1ve+FocCA2Ve+kpndZzLhnVm5EiDfwEDmPMjXbG/HvVqtGHdnpygxmpjQtx6zNSI59VRk8alFKsvL0zP1TCbc24EDIrMklcLzjkSwbkIhnIsd3aPNITnfxG6309q1a+nZZ5+lf/7nfyYiAG3PPvss3XDDDRnHr1ixgvYqkI3bbruNAoEAfe973ztusuD0SDJJ9ItfiAxyjjJzNno2sdmIbr2V6MtfPjGybZR78MgI+HvGxuBsrFqF97yvD/bHNddgb+jpEWUqLMkkgnnLlolyRrU50hsEa2oi+ta3hH3V1QV9ZrHAbgmF4JAlEtC1mzYBlMmV+SFfKxrFfvKlL+E+uaPeJZcATOrrEyVMDKRxpnRPD+aLCDZUICDKf2QwLxzG77//PdEzz0DvnXQS9jQtrrPZ5pVle256GmOamBANitxuwRlXWgqbkffB0lLMR1cX7v/cczFn3OXPZMIz0KKTcLtxjkAAe+CmTaIL6/e/XxjfUDaaDM5aTKUwJpMJ4+UsR7NZVC90dxvAnCFvnRyN4JnewNngoL4x6z1upqLlWzM/OlcfVVenN5fx+WCDu1zwj9Sas5WU4O/cxEjpo6v5G83N0CHhMD7n9YpEGpcLY/J6RaAqGMQ4Lr0UvomaT+l2Qye63en3zgkwbCe3tcFGeeIJjP/sszFepV944YVEzz4Lu50z+7JJPE705z9jT7rwQnHv+fjkfPyWLdhD+/qwPzO1DjepZJ7WRELb9je6aB9dyRuYy5cQ84EHHqDx8XHasmUL2f6P7KnlKORJzoQHpK2N6O67kf76X/8FQGtqCgZFeTleWOaAs1rxQnPXVIsF57BY8MIePIjFrAbkvPOdUBALFmBM3KGV039jMbw0y5YR/eu/CiNJGbFl/ih2uKenheHNXWC4mcTUFLL0FixA+m0245E5+I4F0Rsx0FJeXV3ZP5tMZje2+/sFqLNypTbQm0wia6/Qbm3ZAOWNG+F4EeH/yiyKX/5Su8sZG8yHD8OJY0N4aAhgUyQCY57XtGwv5MqiyrZh5JpXLSeG1x4Da8oNMtfY5PXCqfI+H96FykoQXF97bXpWzd69ubMmZY4f5QbV1gbS8e9/H9GuWAzr5aSTiK66CtmzetdjNgfnV7/CM2duOGWkUs7UKy3FO+/zYR4ZMJyexj1w8MDrRVRtcPDoc0jOR7n55pvp2muvpXXr1tH69evpnnvuoWAw+I999ZprrqHGxkb6xje+QUVFRXTKKaekfZ4DW8q/H8+STMKI5LI+mw36SM5UVwPnTCa803fcQfSpTx39cc+lsB5MJmH8j42l61HOGujogJ675hqiH/0o3dno64M+4iz6r3xFO1CkNwjGepAx4b4+0ZwqGMS1QiE4GH4/gj8XXCAaGui5byLcWyCACoPOTgCv558P2+k3vxGUIamUaIIxNYX18+qroP0wm3FceTnGxg21uKKAszGTSex7+/aBSJtIHZybbbqPkhLo4VdewXw1NUFfT01hP2c+1PXrRcY4S3k5jh8YgL0qV95lo5PgYG44jOAR06aUlWGPKLTLu5rtUlKC+WYb2e8XxOdMas+8TZz1Yoghb6UcS8Ezu312j5upaPnWZWWwJfv6YHv6fAKUk219Iu3mbHKjtEWL1H10NX8jGEQA//HHRQau2Qw/V64K4WYJp5+OfaSxUd0OP+MMlKHKCQVyAkxpKXSm0wkfnwMNHLRX+oW33IK9+f/9P/3BqdFRNL5qbBR+Sr4+OZfi2mzYYyorha61WvH/yUnsX5OT2EOUtr9eOjBDZk/yAuYKIcR8/PHH6cwzz6RPfepT9Nhjj1FNTQ194AMfoFtuuYUsjGIpZDa6yc2UB8RsRtloby8MJrMZx3NUMxIRmTTNzSICyxH+4mJh/Gll7L3yCl5o+eWX03/HxvC/m25Kjx4qI7aRCI7jlGEuE+DuXmx0mUz46umBsZYvj4gSNWeD8Gih6HojBmrKK9dncxnbzPPQ3KwN9O7bByNazTBdsAAK7uc/J7rzTu1SmVyA8skn4/zXX48NjbMoenpgyPv9WANvvCG6nF10kTCY163D/zmjqqYGYAxnyQUCKOdJpXBuhwM/K7uh8ljludTaMNavBxi8YwfKZLgMR48TM5OyIfmZ79qFLIvBQdzP0BCcPU4T13Ot/v5Mjh95g+roQAOR0lKU03GW6vg40d//jg2S5ygXmJnNwfH5RJafyZQZqTz7bAHwezyY52QSxzU04FzsnE5PY0O22zH+pUuPPofkfJSrrrqKPB4P3X777TQ8PEyrV6+mp5566h+cNn19fWSeRw+hvR2Zcq++Cj2q7OrJU6HMnLPZ8K595zvIIDtRRW1fYO4xrxegB2fFvvvdIqO2owNBCYcDHeNy8XMS6QuCyUEMBpGKi0WHeC5BZiLuAwcQYDzvPGRDvfaadtaAySQa90xPY18aHBRUDnffjWyHv/wFjlFpKY43mURp/8knY+xE0LOvv45MtMlJjMfpxPk4285mE93ylizBnP3gBwAA1fbq2aT7YK7h8XFcm0uluDSYu/utWKE+V6tWIbjW0SGCNbnoJDiYW0iWvJZo2S5sy9bWYv6tVrzfJpNoqBaJYP640+FMy2kNMWSmcqwEz6qqZve4mYqWb830LZzxOzambusHg9rN2YhEozTmz1Tz0ZU+Hp+H6V5MJuivcBh2ss8HH6ShQTRpYNtfzQ4ngi0iJxSwziwthV3PtrTXC33NiTEMSCr1aEkJrsd8c7kklcK+9aEPET30UOHUHAMD2O8qKjC2ZFJQZiUSgi+/qCjT9s+XDsyQ2ZG8gLlCCDEPHTpEzz33HH3wgx+kP//5z3TgwAH6t3/7N4rFYvTlL39Z9TOz0U1uNnhAzGaUuz3xBAwfRuHtdizQQADnKC7Gy8y17RYLjrfZYIxqATlDQ+oNC5ignrtjZSub27cP98DZLwy+2WwCEedyj3BYRCSuvFL9hdJKWVWi5pEIzud06uvgOVsykyy+XJ/VMrZXr8am8tBDeNaJhFC8LC4XHI7JyfRnruU8ffSj6vOkF1AuK4OifuIJgHJ8/tJSUbLZ14fOQHa7MJg5m07OqKqowLgPHxaljc8/LzoI+XwwlrkbamUlxqLkU1A+e3nN+P0A+oaGACrV1upzYmZaNsTdCv/6VxgMy5drby4yN11jY3pZkMeDciCnM53jh8/BvJFeL56L15ue+drdLZzKXNGvXA5OTQ2+swGgFqlkgL+vD3POmRVFRTgXly9zE4yKCqxz7pZlyNzLDTfcoBp9JyJ6/vnns372F7/4xewP6C2SP/1JdDAjEsEl5okhEk48ZzdZLFjPX/wi0cc+duIDycp9gUtquJlBSQmcoT174MzccAOyxe65B3Mjk1/novMgSndY5I55TidsBNm+YruHnw+RoM9ge4RpNVaswH3U1KBMR+mgMCjHz5/Pwzbcm28isHXllQgiRCLQX8GgOrfa3r3Qv5EIsjOSSeEQcjam2Sy6VIdC+HtNDY7ftg2BDjXJ5tTJnMK5ApbsOFVWCsePs1/CYbEnDw+LDEVZnE7wEC9fjj1WD50EPzPOStWbJZ+tpEnLduFrcWYgN4KQ55+fgcWCktxjpVLDkPkrx0rwjJvBZCt/NJtFtdZcSzbfuqYGumjvXvy/qwv+0sKFoCBgfanVnI1I6KN4XF9p5cgI+DMffVR0T62uhj5kLrVkEnbwpk2ZNq6WHa5M1GDqg2gUOm7FCkEbxeAi++EsSj1aU4Puqc8/r48zN5XCnnfjjUTf+57w9fNJhOExOZ2wG6JRkcHMHHNFRZmYQKF0YIbMXPIuZc1Xkskk1dbW0v33308Wi4XWrl1LR44coW9/+9uawNxsdJObDR4QzoApL4fS83ph9E5MAFA76yy8NKOjMI6TSVHCkUhgwRcXi8wjOWWXX9izz8Y58y2JkEGkHTuEM+N04oXjz3C5AANydXX47Gmnqd+vFqfVk08K1DwUQsnR+DiMyU2bcN0TAUVX4/V54glEnHt6ANoUFyOyvW5dOm8Bb556nCctDpd8AGWZ2Jpbf4+M4HqcWdLdTfTjH4uSa6LMkuloFGvE7camFo3iuYZCOB8Ts1ZV4TqPP56dT0GtFHPRIoyzqwvXueYapJLnUugzLRvKd3M59VT8zuV0VivmmstvlBw/fI5f/lKUCzFXJD93mw3PrLMTTuVtt2V/P3I5OBUV0EFyhoNWpJKzHGtqcA+ccu9yYR2HQlhHb3979kxOQwyZC2lvR3nioUMCfIvH8cW/czYTl4A4HMgC/trXju8GD/lISQnue3AQ8/HGG3i/mZuHy2ra2nDM44+jfH5yErpBqR/1ZEVxUOPJJ9ObELHtU1eHPbGxUXDClZWJoJ3Vir8XF+PvoRD2nYEB7I2nn46fR0dFECSVwuc4iJhI4H7HxkQXu+3bRWOb6mrBnankVotEwBMcjcJG2boVNks4LO6R7aPiYpHJFY9DP3q9AMOygWxKp66Qsp9AAGM/6yyAgXIXw4YGUCFs2YI9sKlJ3ZbduBFNidQqGNToJBwOcb+c/SFzuKoFrnPdm5btwtcKhfD99NMx59xxmcF2lwsNmD7xCcPRM+TYkGMheFZXh/cqFNI+pqgovYx9LoTBMK7Y6OlJp/UhEt1R3/c++Ed/+hN00uAgSkNffRX86tmas7E+8vtBt9TUlK6Dg0FBbcDdpZk3tbYWOmVoCOM84wz4Hn4/9pCrr9bvmyoTNcbGsDfU1IjmSpwBHIuJvUsGGZV6tKgIPkZ3t6je0RKe13gc1XWXXILsaAY1m5qQOZ7LjxoZwRwRCVqM6WnMSXEx7rO4OBMTUCYIpFJiX3U4sO8bXVznRvJyw/IlxCQiamhoIJvNlla22tbWRsPDwxSNRsmuUhg/G93kZtOhX7oUhPkTE6IZBBMptrYiC+rgQQGOcTp+IkH03HNY1FYrrrliBV5ofmFPOw3IfiElEQwi/fWvUFA+nwBTmA+NI85EUA5VVTDO1OrIlSmrU1NEL72E5hWVlYhkmkwAluJxgFNeL5TM2WfPPYquh4ByNkgq2dju6CD66U+hFHlT5GjDG29AUb/jHYK3oK0NG0IwiGszHwFvOkrnSW2e8gGU29vhaHBaMpcnMtchlwK9+irOla1kmruw7tghGoyMj+Ncy5bhPrhTUS4+hWXL1MGwsjJslPv24Trnn6/vec2kbCgfrkl2QhnI5rInzuQ588xMjh/5HMkkjIA9e9KfOxGAskhEndBWKbkcHM4OsdtFWrzDkR6p5C5Vq1djzZWXY71wlqTdjrU8OYnn8sEPGqCcIUdX4nE44fv2CU5UBuOIsH9aLKLreTQKUPo//mN+ZMnJEgxiX+/qwrvr9WJOQiEY1ezMlJeLDHduOFUonYfSJgiHse+9+CKyExYtwrgY8J+expiYq6y2VlQW1NXhOdbVCV0ei+GeSkqw/7AwFx7rTpsN9xyPQ9eNjUFPv/Od2IP0csKWliKzIh4XBNw2G67P5zebhY4lgm31+OPaIJsyc4Obc+RT9sP6vrgYdpTs/JSVYX6XLMEeks2WtVqF49XXl94ISs0WdruRJV9Xh/uS+eeUgWs9JU2treq2S1kZ7M7ubhyzeDH+3tWFuQoEsFd+4ANEl19+/AZ1DTFkLmT58ty2mdU6t+XfahVTQ0N4d5WN6KqrAT6xD9DSAt02NIRMsfZ2BI2yNWezWqETVq1CkyHldSsqcN3+fgFucZfy8nJ8dmAADRSYhshkgi/LTRv0iDJz/KGHRHMlDigUFYlmPQsWiACHmh5l/XjOOdiLfD5tcE7m1I3FcK8+H/R3IgG/7qmnEKS8/nrtCrjt20XZKvtuxcWYQ48Hevn978/EBOQEAbnyKx7H86msxPmMLq6zL3m5YvkSYhIRbdq0iR5++GFKJpP/SPvt7u6mhoYGVVBuNqUQh56Nms5O8KCUlICra3AwvaQiGER0k7mm7HYsdqdTpIyGQsIwiscFir9+vYgYMxChhztNC8RYsQLgIYMlqRSiEJwJxV9VVVBYJ5+M82TjtOIXcXAQxhtnTlVV4W9lZWI+5Lp6GejgkoXZ4KDTE4meTZLKZBLOx86dGL/NhnsNBjEPiQTm+pVXENGuqUEzgcceg+JdsEBwuMiRoIoKbC5MsKyMNuQDKHMDh+lpKO5YTHQHJsJ3pxNjDQZxLTnCJZdML1uG9XnBBRirx4OIVlkZ5tFqxf+JcvMpbNumDwx77jlsLnqeV6FdgvWWBvt8cPYOHcLzcbmw8ZhMeI97ewF6LVgAJ0lZxpxI4HPt7eL9kI/h9Hw93D1a4Kzs4DQ2YjwcxbNYsGY3b4bOY3CYuyfu2gW909UlMjIsFsz55s0ASQ0x5GhJRwcy5bZsSf87Z0kxQMeE/EuXIttK2bBlPkhHBxoKsb5mEIt1utuNfYXBFdZpRIXTeShtAq8XwZRQCAAgg0dlZQD3ucSVgf4FC7BnclSeCx5KSqD3WJfv2QOKgNdew343MSFKtjj4UFGB8/j96eVcv/89MqyIMvfJoqJMTtglS+Do9fVhTfX2iutw1p3bjWv29OD72BgASDUgikjYG0xTEYshq5rnW0/Zj1LfM2E6UXpG3KWXikyRgYHMEjFeK1o2kNIWrq4W2fAMTKrZGXqzzm+5Rdt24U7o09PoTuj3i060dXVE//7vKDGbT2C7IYbokWQyndZBTeLx3J0+CxUtUJ75iZnDlH1r1lPy3rFnj6B1YRv0U59CxZncnM3lAnC/cSN0tVypVVwMrubBQei+sTEkD1RXi71mcBB6aXwcPms0is8lk9hHslUraYmcFW234/PbtglOb87Gs9sBjrK/pZYAxPrR68U+sX276B6uvCZROjUEEa61f78IcAwPgxJiehpc9Mp76uvDfK9dqx6Y5664GzZk6l4OGB0+jL0pGIQOr6zEZwYGsBeMjJzY/L5vheSdI5EPISYR0Sc/+Um699576aabbqIbb7yR9u/fT3feeSd9mi2bOZZ8HHrZqBkZwe8Wi+hoKIMepaUwIg8dQmnHFVdgkdvtcJgjEfzMEd7SUpG2+9JLKK2QX9hc/GfZDC45UrlpE16SoSG8wH4/XqjychjPgQDKMh95RHze6UwHUuQSTAb1gkEoUSLRzaymRpyTy+rYKdizB9GJ2QDJ9ERriWaXpLKvD87C5CTWAD97i0U0+YjF8PwvuEBwxpnNuJ5MPDo9jTllrr+XXhJ8PH/7GzYheV3qBZRlTjQmT5aj3vw3LlssKtIG+5gg2u0WHYWZT5FIKHKi3HwKnLGZDQzr6EAThVRK//PK9Y6oAdd6S4MDAVEWLGe7BYP4Siax2T/1FN6vtjZRxtzfD4MgFsM7Mj0t3g+XKz09v6EB72W2KFM2cJbLYgcH8Z35/iYmsLa4w668UfK5PB78PR4XmZLNzUbpkCFHV9rbUXb3zDPpf+fye6sVa5kIumjxYqKvfx2lfvNtncqgyMaN+L5rF953blbgdgN0l2kViorgJBRK5yFnGhNlZn8TQVeuWyf2uro6ZA6Ew9A3FRXQXa2t6YFIWU+fdhqaVQwM4J6efx62SWcn1kBxMXSVz5c5xlAIgR2m0pD3yZNPzmx4YDJBb/v9IrMiFIJe5wBrUZEo+2luRhayGhB1//24T86Oi8WwrmMxjGnDBvE8cpUNZ9P3/f0YE2el/Od/Yo4efzyzRExJOaK2p37+85ndDB97TGRYsv1x7bVi/80n61zLdjn3XMz3z3+OPYppIurrYRe/9hrebyNbzhBD0mXrVpHdy7ybLFyNlUziuNnOmssGym/cCJ23ZAkqLsrKRDIG6ws1WheHA///7W8RnPvAB9J5TMvKREBZvu7kJPR2UxN0+Btv4HeHA/5JQwN0Yk8P9hJuMEOE/cFqhb42mQqv6mprw3711a8KPWa3I3gTiUAPRiLaHNqtrcAKWH9v2gSQb3hYBCH5GSuBVs7Qi0Rwj21tgn+0r0/9njgxobUVdgJnvXGmYlMTrqlWBt3cDJ0tdz8PBrEnV1fj89z9XA8tkSH6JW9gLl9CzIULF9LTTz9Nn/nMZ+jUU0+lxsZGuummm+gW7kd/FERPwwAl+FNWhvLUoSEYiJyeypGJZFJwdDCIUVcH5TE2JtrOT0xgcQeD4mWwWone+179RogeYIoNu44OvGzLlkFRdXeLsRYV4WVTfv6d7xRAitwSmmvoo1HMgdsNwzORgCJlkmS5rp7JoH/3O3yfKUimJ1r76KP422ySVAYCOF8kIrpfEkE58QbJm8J554n7YcP0gQcQQR8dFWWsDKTYbHBUhobA69XaCkUuA5d6AGWzmei669Cd7uBBjC2VEtlbXALU0AAn6X3vw0aqBvYpCaK5bJJLY6NRAdLl4lNgTgwtMGxqCuCd2YzS1lzPS0+5qxZwzXwWuZzTkhI4aIGAyHZjjrZoFOfjzMS+PhgGGzbgHNwUYu1agKSHD4sS09pakcm4YgXeq1xNZ+R1pHRw3vY2zO/rr2MOpqbwHBYuFA6wcq0rz8Xzc845+XcQNMSQmUh7O9G//AvWL3PGycL6i0vxzWa8t/MRlCPKBEVqapDhSiTKQJNJoZtlndbSUjidh5xpLHfwlPdBLt8cHsYx69YJp4i54RoboZP4Wl1d2gHGNWvwdeGFWCN79ohOqyxyeQ8R1tArr4AY++yzxf7Q15fZ8IBI8Kvu3g29vmAB5oIDTJEIHE2rFTQAakBUYyPAsYYGsX+NjOB7fT3sv85O3LOSU1grIKOm7yMRsedwMLWyUnCztbSI5/n66wDYysvhMGfLalOzhbljLZOkyx3L9WSdDwxg3LxH/+d/pvPdsaNdXo659XoFb2Q8DjDUIBI3xJBMCYUyM6dY5L9n46ArRJJJZLRv3ZpJ4UIEHbNwIfRRWZnQK6wviovVaV24CczoKACqW27JfOd7ezODAcyxHIvhGpxB7ffDN62sFL52JCKaYZSUQC8XF2MvYk73QrjR4nFU0DE11dSUoK9auBB6ubUV2WstLZkdTuUMayLoxTvuQJOmAwfweQ5KZpNAAAlAtbUYS1WVeuBHTkyQ6YuYKoEIfo+aP9LVBb0sU+cQ4fOTk9g7Tz8d92PwzM2uFMQqlC8h5plnnknbtm0r5FJHRdTAn1QKi31oCP+Xs6TYeXA4BEgnG3ZylxarFZHMoiKhLEZG9BN1JpMwyA4fFtFmLiFVGlxKw87hwIt/5AgUyJo1QlnJn3/lFRzLmUFshBNB6RGJTq82m6jX53r/VatwvBa3i/J6+RhgeqK1r70mMpR8vnQHQg/JtZow74xa/b/c+Zb5yGRy0tZWov9LGKXduzH3FovYnKamRJdfzk6rqoJx3d6O7jinnYbnnWu8K1cSfeYzeP6BgDgnl1dXVIish9NOQ9mLGsilJIguK4MSHxrCd7k9+NAQ7kMmjJYdwo0bwUOkBYYxV11rqz7eNz0lzNmA63e/O7dz6nSKsmC5VDcWw/EWiyAGdzrxDHftSm8KUVsLA+Hpp2EAMC/UySdjrNXVGEOupjMsauBsMkn0la+IkmMl6bnDob7WCy0FNsSQ2ZKODuipXbuyG5/ML8adPK++ev6uUzVQxGzGXr59O/QQ2ydMZSEDboXyc6p1XWWbhgi60GKBPmEdWVsLB6izE/pvYgLOw3vfC+4wIn1Z7StXwlm5/nrcv7wHq+3HsRgywR58EIEYouxcrdXV2Ls2bUKmh8uFzDOPB3aZy4X9WwuIisfhzMjZdBzIiscz6T2IspcNs8g6es8eZJTYbCKYOjWFDPtQCMFUuVy2sRGlxmpcVNlsIC6T9noRzFV7Jrmyzvv64FTef78IAPMezZnbvb1Yr8PDghKFbcnhYXxu2zbDwTPEEKW0taU3P1IKV2rNZoCVQaStW+HDVFTgHWaOdBa1gAPri6GhzIAOkaBYWrhQ2y+TwT0OcrP/7fWK4B0HzJlf3eWCfc66u6QknXqmtBQ2Owfh852TBx4g+vWvhV/MDRVtNtj6VivmiTtNy59V2/v6+zEfn/oU0Y9+JMA5otxdW8Nh0ViSGyMp70ltH+Q9KZXS9kcYE4lGcX+JBK7Ha5CplBYuzF0BZEj+UhAwd6KJGvhjMiEtuKsLCiEUEqAHI+SJhHDWGX2WM404q6ioSLwMPh9+9/lgtOZykJ97DsBcJAJwTtlEQllGwIbdn/6EFNSeHighmw1KYMMGke7MBtvQEAzq3l4YTGyEy/fN4KPDIcAozsqqq4OiGhgQRJsytwtLISBZrmhtOIzywakpbB42W/r8EOWOVqtJczOcn507MQelpZlloqkUnt+zzxL97/9mAkcf/ShKsLq7Ma9cetTXh/MsWoR1ND4u+BIOHkSK9urVeJ56Sn8/8hF85i9/Ecrc6cT9K8uItLJH1cppli3DZw8dQjRq+XLBt0aENc0ZpT4frsck1NkyNdxurBm3W/1+5HLop57KTTidK6Ny716iG24Q/DzsnK5ejfeBs2CXL8c8csluKCTe62RSvMN8fH8/rnPOOSKiWFuLhiAvvYR3wmbD87PbMZZcTWfUnov8vPbuFeVrUj+djLlTW+t6MocNMWQuJJkk+slPEERhTsRs4BzzzJ11lsgQm4+iBYrImV9DQ3jnq6rUAbdCQHnZoF+wID17mkvzy8ux7xYViTKc8vL0pkLBIIi+zWZktR0+jMw6vrZWwG7zZoBsv/51bgeFCOO57jp0x7700txcrTU12Dd5nk46SZyrtzc7EMVltTIXnBzIqqpKp3nQKhvWygRvbgYNSDSaHtzkRl4WC+xSOQuFu9r6/emAIIvavqCXO+5znxOUGY2N4lplZbAPXn4Z51+0SHQDV4KtPh/siHhcdBImEt11ubuiWsmyIYbMZ1mwILcOTKVw3GyIDCLV1oosV+ZIl8v01QIOvHc8/zz2DDmgI9O61NdrgzqcVff3v2OPYZuBq5hcLtjB7Itx2ScHp7kpQ319uh9qt8PPYmAp3zk5cEB0l+ZmFYOD0Is1NaIDqqzH9OjZyUno/O9+FzpXrx5koGzfPgSKlPdUaBNMGRNhDrxEQpTZcjJKZyfOl89cGpJbDGCOtMGfxYthbLS3i8w4IrEwuQnA2Jjo1iobaKws5ayiffvw809+IjjAtLjXmIfL68V5GPSSFWRFRbrBZTYDqPrxj3EMc5xZrTCi/vY3HMfgHBtsZ58NBXj4sADhwmF8uVwwNrkcl4k0iXDusTGcX4vbRZZ8QbJs0VqPB6nWHCnhZgjKDURPtFopZjMM97/+FWAZk1gTYU5SKcFt0NurXiL86U+jfJS72I6NiYxHJpTmDMWdO3FOJta02/WX/prNRP/6r3hmfX14VmVleCZM8qwHDFIreVy8GJtoURE2NC6B3L8f4+ONd9kyOEbKkl61TI0zzkB2QzbeN4cDBn8up+Gqq/Tx31x9dTq/zsgIIvgPPigA1YoKzNvAAH5OJDCHvBEXFwPYOuUUrIGODmzOymhTbS0y6PbtwyZ94ACASD1dZHOJXs48Y6M05FiS3l5kkoZCeK9yORpctvntb8/PbDkGbXw+6I6ennSQhigz84s5fmajU7ls0B85AsBlfBw6JxCALmxuRiAjFBKBJ7aNysvxmddeg0MzMIA9rrgY+5QcOFML2JnNyJhjwmo5i1JLJiex5yxdirkqNFswV2f0sTHs03J2msmEz/h8gnsoGITtwDx0Z5whOqUyt5taJriS85clEsG7U1GRmZHncOCLM0uUorYv6OWOGxhA1ccf/4isPL5WSQmejckEm4DtXDWwNRAQXMdq1+JgtZF5YYgh6cIVJnqOmynHnBJEIsLezZUzXq8o0ydSDzjw3tHejgAC64poVPhRarQu8j41NATAa2gIeoipE5hKaWJCdP+W/+fzQf8wmMg+Gwvrx7Y2fVUryjnhCi1uiMec414vzud0ZuqxXHqWs53XrAHfXiqFgBQnCGQTiwX+V08Pgllq91TIPsiYCN9TV5cAI5lmJBBAtd0FFwh8ZD7aanMhBjBH6s4udyXlF4yNQpmQ0WyG8ZlIgHT3vPOwkJua8KIwtxQDV2zkNDUJYngt7jVWBpwJxqmxHGHk8a1ala7c4nEYwj4fUnijUUFuXFEBhbZ9OyLEzFHFGX9XXIHUZVaK3DSgthafrazE/yorUa5IhHF/4hNQtNm4XVjyBQ60jORUCvM5Pi46kg0PY27k+amqyk5ynU1WrgQH3Be+IHjFuCFCWRnmpqEhe8nuVVchM8tux5ffj3vhuYlE8AxMJhEZ4w4/+ZT+trWB14CV7+ioPidE7TzK7IqmJsEXMzKCbngLFuBYLt/hrqZLl6aDc2qZGkQgDM3G+7Z4MdZaLqehu1tf19VAQGSMdXRgjaqllTc14XNjYyIrsrhYlAWvWCHeRzlqqFzrNTUoHa6oSH8/Zrpx5XIaC13rhhgyl/LMM1ibZrPogpkta66iAiXb87Hbl5IvMxLB3hYIiCYAWplfROkODgcgurryb8IkG/Rchjg8DB25ahX2mMFBoYOefz49W72vD4EJs1mULlqtAnCUMy/UAnZtbUTf+Q7RP/0TjteTOXf4MNGNN2K9cSlvvtmCubIMmpvhAA8MpGfS19SgCcff/obxvvAC/s7lWMPDAjwbGsIaX7kyO+evLFyNwUFhGYBjTuOBAcEFxKK1LygD0qlUOv+QMnOdKxL4c+PjOHbTpnQOKj5PUREczt5ezLvLJRpiKfctDgAbASVDDEkXboSTTRIJHHfxxfmdWxm0SSbTQaRUCsDR8DB0ltsNvd/fj89oBf3b2uA3feYzourMZoO/tGJFJq2Lkn/twAH4RVx6WloqbAe2y51O+LfM7+5ywe9raoKPOjGR3oU0EoE+a2xEcxu9trgMrHFDRC4f5gy9UEh0mVbqsWxVXx6PCOB/7Wv43W5HokN7e+6xcTVbLJaZJa18HvnsgzImwiLvvwxwxuOwDb78Zf0VXobkFgOYo0xnV+4k43bjxTOZoDC4O47Nhhehvh4KwGRCmVk4DGXR0ADD5Y038FVRgRezqSk7OS8DMKwMWluFIcelCyYTPufxAJg45xxhcG3bBqVWWyuAvOJiKLniYnyNj8NQKyoCF5jNRvSzn0HRLV+Osr+nn8YL7PPh+HBYEOOvW4d737cPUeALLxQv+GwDB1pG8tAQotFVVUIR+P1CEbvdcBp27MAxJ5+MOc0XHLn4YoBEP/+5yBCrqgKw2d0NICobcESE8fF8cCkwK/axMRxTVSXKg7mpQr6lv7PFI6ZW8tjSgrX/xBMYszJ7o6lJHUTUKp/MlV7NXWJzAW5E+WWQ6UkrP/98gAZ//jMcqooKvHvscPI6XrsWn929W32tHzmS+X7MVApNTTfEkLdKmEQ6kRDGfzgsulzLTgdzV/7oR4IvbD6JFhfN9LToAu9waAddZAeHywPtduiq1tb8mzApec9efhlOWm8v9t+iIoynoQFGOmern3EGSh8dDmSH79kjOuLZbKLT/TveIRrtcAdxma911Sqi//ovos9+Vl8GARHKn/793zGPRIWV8OfKMiDC+ZU6+OBBkUG+aBHW+t69mL+pKZRm790L24SbNJWWanP+ynsaV2P09cFWkxsvEcHmqa/HWM3m3PuCkkeQO/bF43g2bjfsEs5c37BBNAIxmXBvL7wgeFZNJhEQ9XrxvEIhlDBfcgkCxT096c4yZ9HY7bCzOOvOEEMMgRQV6StlLSrK77xqDdPKy7FvLFqU/i5zAoHfL97zs87KHvRfuZLov/8bfJ2jo9jP6uuhE2Ral64u6Ii+PvytuFjYB5z8Eg7jc5yVxaXz3N2ZAx6JBEA52f9lTrlIBKDcl76EsekVGVjjarHJSUF1YzbDn/N4MFalHtOqcvF4gDP4fLhnriRIJnE8+4nZhKu3Uinw33k8yDRXeyb57IPsx7/8Mu6zuRnzGArhPoJBwRPISSeFNHc0RF0MYI7Snd32dhiX/BJx+R7zYHAW3KJFMI4iEbyMp58OY6utDUBcfT2ip/E4XuL+fvz/pJP0ca+xMnC7RYmEbNAkkxjbihXpBtfIiBgjn7u6WvDFcUfRgwdhsKVSAtgLBmFAHzlCdM01uI/t20XnNY6UZ+PLmgvgQM1IDocxF2edJaLuGzaIjYTTmn0+jJe7mqllC+Qq9Vm5Eh3F5GN8PvDH5QKOgsH0+WhsxMYxMJDe1ZQbTTD/Aiv2fEt/55JHTG/pixaIqJxnNd43rS6xSmFHbvnyTCCYI/bM57dpkwCC9dzD2Biydd71LpSST03hOm43zsvrmAnNBwaOLkhWaImWIYYcbWFQrq8Pa5QzZhIJ0USIm89YLAB07r9/fmbKZQsabNwI22TJEu2yVRnUa2rCnkOEuW5vh/6qqcm/CRPvKS0tAFh6e9FFjikZduyAziwtBZAzPAxu3FQKumjHDujEkhJBCxAOgw5h+XI4MlxJ8PDDIgtazu77z/+Eg6enYx0R1tDHPoas5UIlV6BLrdkWEfYWrih4+WXYW0uW4Lns3YtzNTVhr5e7t6px/srrwGTCeHp7ReUGd4fv7saauPJKfL67O/e+wM7XCy/g+YVCOIfNBsDs8GGRMVFRAcBQBu5cLtwzd+WNxURAu6xMzMf+/ciyX7xYdJkdG8M8WK24V5sNc2ZkehtiSLpUVuoD5ior9Z9TKwDU2YlgTlERdDK/y2Vl0AnDw7jWVVeh7DLX3rFyJdEXvyj05P796TqptZXo5puhJ81m6JxYDD7zwoUik3bDBviw27bBd7VY8MU81ew71dcDXLzySux5XFXF2dPXXovvcvAnV/KCDKyVlUFHM890KCR41+rrcaxSj6klq6RSmA8GuCoqRAai3Q6soKhInFtLzGYR4IzH0eV2eFhksBUq7Mfv3o2A4IIFgsaCA0PLl+N7IRVehmQXA5j7P2Fn94EHEOm1WmFELFwIY9PjweJ3OvEC8KLjNNueHii0gwehWJYuxYtaU4PPu1z4X38/DFwlKKAEYJRtjmXQiXneampQJie/gNwhhhsW8LkbGwUvSSIB483pFN0kiTIJ87nlvRwpZ6AyGwgwF8CB0kj2+Yjuuw+bBXemqa4GV57Ph7l+800o0qVLtcuG1aJGauCdEvDKRRAtZ2q1tKTPB2fDWSxQbkyAGokI/gVeH7lKfwvhDypUcjXiyAYias3zZZdhg8/VJVYt83L1avy+ciU24fZ2jKGvT5R+FReLJi5tbfrvIRgEZ0Njoxg3b5bKdfxWgGRGl1VDjnXhkvG//x3vZiqFfYmb5nCZJpPan3IK0U9/ml80+0SSXEGDhQuh18rKMgMfSlCPM92rqmA0c/YDg0CFdConEpQak5PQz6WlmbYJlypzU6hQCDZGKAT9GI1CRwYCCP55PDh+/37szVp8rXY7HA49Ja2RCPaVvXvVdaLefTNboEvNJvnJT0Rlw+Sk6EpoNosqh1QKzqNa91Yl568y4OPxALyur8fz7ewU5Nx1dQDZWlsRWOXyLiJ8lrlw5Wz2yy5DcGx4GHsdg3J+Pz7vcOAabjfeVwbu2HmensZz5fKzUEgESj0eOHTr1mGtNTUBnPN68Z2zZeXGUcb+ZYgh6SKXE87Gcckk9uXDh6EPOAuttBTval8fKI0480xu1FJcjPf28GH9489mqz7zDCpTiATdAVMwDAxAz3GGbl0dAhwHD0LfMDgmc9c1N0O/nnYagkjKa3Z1Ed11V25/TxYlsMaJMgzU+XyYq4YGzJeeZJVYTGRNl5Zib9+7VzRWdDrFnj8yos4bykFNkwnAXl0d5mrXLqJHHyW69Vb9+lRtP2xrA77A/ilnSdvteC7cgENZ4bVvH4KxZWWGX1KoGMCcJG1tRB/6kMhsKi7G4vJ60WXR64VSYqSc03qnpoAaM4dKaSkMHb9f8KgUFcG44eiish5cCcAolUFNjeh2xplAZ5+NsjtZNm5EVt6+fbgevxAul8hYaGlBpLulJbN0QEn6K0fK8wEB5gI4kI3k9nZkMHZ14d7kbqxVVQBK3W4YsVod4JJJonvvzd71s1CCaGXJrnI+mPunsxP/Hx8X/Gxs2PJ51qwRJTHyPOoFFWdLCm08oBWdk+dZmSGTK/PSYoHh/5WvCAff4xGbnduNcqLmZjg63/8+rpPvPehZx21tuNa2bXiudXV4D60a2nW2wFSjy6ohx6p0dODd3L1blKHwGg+H8d1mEyB8SQmykucrKEc0s8CHEtRj/hc29JUgUCGdyrXGKdsmkQh086FDgoKjrAxjkAOEHFzs6YFjFYvh+9Kl0J/K8s4//pHollvgUO7Zo2+c+/YRffWrWIey6Nk3CwHu9u4VHQOJ0p8BkciKN5kElYXcvZVI7D+nnYaAklbAp7UVWYn3348xtLaKjqi7d2OPfPe7AXxmu0+XC06W1Qo7dmoKPzMXVDiMuY/FMAfKbqpc1sSl06WluB+Z5N1sFpno11wDflnmby4qQpm1keltiCHqwsD7bB333HPQo5EIADarNZ0blO3dcFj4uNz9tLgYe3RXV35BHTVblalx2Ce1WPD30lIATePjosxzeBj6dXQUY+Hkkqkp6LCGBozb4xF+l/KaevwQrRJQpS+ybh3Gw5VP/De9ySojI7CJ2Oez2TA+7nxeVCSaKC1ahOc0MoKxxOP44ixrpxPXOHxY/O/hh+H7Ll+efQ9LJrEeHn9c+FVOp9gnzj8f3PNbtuDzgYDgSFer8AqHsf9885s4z1z7pCeqGMCcQsrKAOy43cJxr6kBCBYMQjFwTXlDgwDoGJALBPBZ7ljFUeqyMtEemju4sqgBOVrAhMkEA2fRIvxf+aJZrVAAt9wC41huMuHx4N4++lFwy3EasFLUjPZCQIC5Ag46OgComUyY11gM1xocxD2Wl8PIP/PMzPmRUf3x8dxdP7VScgsp2ZXnY9UqKD3m7vnd77Au7HYoVhmAGh0VABQrulNPRbOFbJvMbAOjhfAH6uF005pnrcxLLvc5ckTc+9QUImnJJMqb5c1ichJr5uc/B19RvveQax2rOXovvqjdaflogql65GhmXRpy4ksyiaY5Tz8NPcxlFkSisziDRQ4H/n/BBchQnc8yk47LSrCMGwWwoa8EgWbSvVltnOxEEMGZqqrCc+3qws8sLhcM9t5ekTXe2opsq5KSzICmHCgcHIT+vvZa7N165O674Vhw4EePc0akX0fLutPnS+eGUz6DaBT37nZjTyopSaezUO4/DLip6eZkEgBXKgUHTLmvbtsGMvGFC7UzEDmD3OFA47KpKdH4gcFU7oirVUJst4tu5fxMZZJ3ZXOPurr07ujGfmOIIdllwQLxzmuJ2YzjcklHB8B8rxfH837M3KAbNogs63gc73QiAT1dWYmAwcKFKJWfaQflvj7oIrcb12Jgjjuyh8PwdRMJgGDRKP63aBF+5oZup5yC448c0aaPmYkfQpTpi0xPI3tv0yZ8nXZafskqnZ14DosWQdemUhi7zCUvl8+6XKgQYlqKREI0pOOgFu/zfj/m4sYbcb2iIvU9rKMDGd5//rOosKurw33I+8QVV+B8Xi+OsViwV0xPp1d4eTwA8Px+ZA4uWJA/p60hEAOYU4gW+FBbCxL3J5/EC7BxIxblc89BqZSVAZ1+4w1hiCmj1AsXYoFzbXlZGQwzLYVSaEkod+b5/vdh8Hq9MJZWrsTLesopMOpmq3Pq0RRZwW7cKNp3c7qzzycIOLX4SlwubCyTk8h0KoQvjWjmJbsyd49adFwNgAoGUWr92GNYU1qNRO6/H2uqkG582cabLxg5U146Zcaay0X0v/+L6ym79DLZq9eLe5XXBpfapFLo8jdbHIj5ROEKjdjNpRyLQKEhx7fcfz/Rb38ryPq53IIj3QzGnXoqjmluRsnEfHfOZ9I4SQmWcaMANvSjUQECzbR7M4/z9deRAcdOAQdC+Nxr18JQHx4Wzl40Kug0uCKBSbXVApqcaceBwosvRrnz+96nj28uECD6139FxQNRbufs/vuFQ6hHn8u60+FAVsPoKPZl+RlUV4vsgtZW2F9HjsAxc7nSuUvl/UcrKKS2r8rcql6vsJHYxlNzQnndhEKZVRypFMBQmw33pta0oaQEtvH73y/256qq9KAYd/BzOHC8keltiCH6ZckSfcDckiXZz8O+09QUAB2mJeDsV9a7zCfncuE95WtPTyOxxG6fHf8wEIAdUF8PvcmAFJFolLh/v2i6WFUlmrARQf8ePAife/Xq7H7XTP0QotmpAmPd19yM/ZOzz0wmUSI7OgpMYdEi6OVDhwQoOj4uOp03NQnOzuJifCYQEA0h+vrw/3e+E/OpDD5973ugqEql4C/H43gOgQD48T0ekanOfi43NBwbQ2We3BCP+fxaWzE2Dr4a3HP5iwHMKSQb+OD1IhuH+T2YU2PJEiy+6moYMmwMy1HqVEoon8lJlHAQ4YU799xMrjiWQpXBxRfjhVQrr9PD31Wo0T7XolSwyjKaaBTPhju9aQGPvNkUUjYky2yV7KoBUA8/nAlAlZbCGdqxQ71U0mSCkn7ySaE4ZxMAyheMnEl5FotsyPf2AmxUbrDckamiAu9pTw/eXyavLSnBhrdnDwwTucynUF64fKJwRDOL2M2FHItAoSHHt/zwh5kdNJnDhkg0fUgk8M5v3myUsbHMpHGSGqgnN42KxXA+Iu3GTVqillF76qkIDu3YAceOA5FuN+whLre86CLwCIVCgn+uogLnZJ7cqqr0zDJlQFMZKHzPe4g+9SnRdTWXbNuGRk0f/nB256yxkej55wGeqWWhyTq6q0tdd46O4llt24bPLFuG+Wfnatky3CNnFFZXZxKi63kXlPuq3EExFMLvVitsv4qK9PuUnVAtMNjjwTFdXXguzOc0MYHzcrlrYyOOb21FKdeuXYL+RW7EFQziOnp5sAwxxBBISUl61rmaWCy5gTL2nVpbBc0Ag2EMong82H+cTvgRDBoRif+//jqA+Jn6hyUluA6XSDLwzyCg3w89uWABSj4rK0UmLxF05+LF0LnXXw/fXGs/mw0/hEg7qMB7pM8n9km1Bk3yeZR7fUWFyHaOxbAn1NXh/mMxBLmCQejeaBT3TSRAOb8f95hKAXsoKYEv/NxzqB5jTvVHH8Xn+vowjupq0UyDAdquLmSZ8z4h+6e7dhH94heCWzQWQ/Dt4EE8L5kjnWhmnLbzVQxgTkVygQ+8QPftg3FWXS14RGRjmFspR6N42bjzGHdr5dbzzLmjJYVGGK1WlOCqnW+2O6ceLVFTsHIZDSuohgbcnxbw2NaW3n1XKflkDeb7fLRKB5UAVHe3uhPBGQp+fyZfIUdKwmF8NpnEGnM4hGKeKQCUDxg5k/IsNdHaYLlsiPl7uroEEbXJhM84nRj74GB6c5NCAdV8onBEM4/YzabMNLXfEEOU8vjjRLffrk5UzOAcrzO3G3xTH/6wsb5kYdvjkUfgAAWD0HVr16ILtBZoo2Xor1xJtHMn5t3hgKGeDwCkllFbWQlDvLwcOtfnQ7DD64Uj8alPiXNff73gxOVMqslJ/F5bC3upvDw9u08Z0FQLFH73u6B/GBrKfQ/JJI4/+eTszlk8jvk55ZTsOrq3N3v33G3b8LvXi3tYvBj2SFGRaJ517rlEl16KsRSy/8j7aiSS3g3VahVgbHu7yDRhkZ1QtXUTDsMJ5OYhjY14ZhYLzs3cxJWV2EvXrsXf+DzbtuG5sHOZSokMunvvNQI+hhiSjxw6pP+4tWu1/8+2s9ud7qdyFmwyid/tdgA5AwOZWbIM0m/YUNi+Lfs+Lhfsy9274RO//jp0K2d8sT/kdiN7jEtdWUwm6NVAQDTY0ZLZ9kNk4T1y+3Y8A96zlyzBPGlVnyhxho4OBFKYM6+0FPOzaRO6Wlut8B+sVgSQ+vvxPCwWkZXM9BBOp0hUGRwk+utfsVc1NcEeIIJuP3xYYBc8pxwYi8exXhisNJtxb1yuOjiI5CS3G+cqLQU4Ku81LDPhtJ2PMi+AuUI4lLTAByLBC/bSSzBQ29thBHOa7YYNIs22tFRkDzQ1pZceVlXBaHsrnOBCyzBzzaXy/01N+sCPZFKAUUQo7eQ0aln0KFinE0bvI49oA4/XXouI/9HOGtRbOujzIV3Y6RQlOzKPgMMhlLEsPh/WpM0G8CkYhIJlgtfGxtkBgPSCkTMpz1ITrefPZUN9fdiY/H44fFxCx2BteblonMHNTQqVfKNwsxGxmy2ZjdR+QwxhiceJvv3t7OuXu2nGYniPzznHAOW0RC5P1Ctae/rVV8MmqavLDwBSy6idmiL6298AAr3znThu927BJTg+jqzJpUsBCra1Ed10kxgTl+nU1CAiz0b8ihUAf44cEV1dp6e1s/usVqIf/xglrbFY7nvx+cB7ePLJ2raDz4fvypJOluJi2CdPP0302mtwFtV0Z1sbHJ7NmzHny5djzmcSBFKKXE48Pp4ehEomMX+lpZhruSyYSL3BkVyqtHs39svWVlE2tn07suVGR0WTh2gU1SPXXYd7aWsjuuEGos98Bs/SboftUlODMqyaGiPgY4gh+QpTQGSTRCL3XiHbzjU1opu2xwNfIx6HjquqEnvFkSP4H2c7NzXB96ir0zd22R/khncyvU5lJfaNgwehw9xuwZvGGXs9PdAzixdnnl8voDbbfgjf1549oO3weOB3xWLw2aamcJ/hcPbqE8YZtBr59PSg03ZFBcBSHvfmzUSvvAJ96vPhHmw2zEM4LCqILBacKxoFiDY6KugjGhvTM9VZODDm86XPLQdeR0bwd5cL/7PbRZdxbkRR6HMyBHLCA3Mz4VBS6+rCyPibb0KRVVZisXFUeGICEVdun3zllVB0P/lJeg09y1vpBOdbhplrLjs60iP9zIlQXCw6zajNPZNQvvCCIHWurAQX2PXXpx+rV8Gefz4UTzbg0Ww+ulmDeksHOzqIHnoI39vbRbMQt1twuFitMJ7t9vRrTE9jDi0WGMdlZVDYTPA6MYFMhdkCgHIBtbOdnan1/E0mrOXeXtH5zmIRKfHFxfi/zwcDYGxMOGKFSr5RuLmK2GUTreczW6n9hhhChCyZ/fuz8+CkUvhifjkD8M0UeY9oaYHeGhrC3rhvH9EXvpC9c+1sUStoZdRyJoPFgn0+Hoc+rarCPjM1hf32zjuJbrsN49HiCd29W+hqIvF53td27UJTAi2aj8suw/9++EN997RrF+Zielrddhgbg92hRhHh8WC8Q0MYH9t6J5+cniHg8eA5ceZEff3ccHbyvrpvnygh4s6J3IDMbs8sC9ZyQvkZbdmCjnq1tYIniAgluC++KLJmKiqEDfPkk6K7oMuFfaymBuNIpfC9q8sI+BhiSCGSrfkKSyKRfe8lyrSdmRssHMbX1JRoLnjkiPA1Tj0V+oTBm/FxfXaq7C+OjkIn2u3I6mtthX7s7xf2KPODW60o31yxAtd/9FFkeS1alL6P5QOozaYfwvclBzEsFuhFqxX7YTKJeeKknFzBCK1GPkxbpPTzamqQfGKxALwrKsKxZrNoDmEyYTyRiChxnZgAeHbqqSJZQy5pJhJBtv5+BFSSSSSxfOpTIuM7kcBXOIy9IBTC5/v6YJ8cT/RYx6Kc0MDcbHIo8bk8HpzPbsdi5nbSlZVYnKOjyFR63/uEMbZ3L16OY9EJ1pv5lGsu3/1ugElvvokXORLBS5xMIrpy/vlwMtRAqDvugPJhIlAifPbxxxGF+PKXxXPKR8HmclKUGQYDA1A2CxcSXXKJ4AabDdFbOphMotzD4wGo1tODYzmN2O2GIg0EsOaOHMH/eA4OH8Y9sHHM12GC18FBKEqttZiP6AW9Z9okQ5Zsz9/jwcZWXIxU79FRbEINDXA0urpE6Xg8jvVqtxfuMOUbhTvavI7Zns9cpvYbMv9keBhrhvlqskXvXS6iT37SyJhRinKP8HoRkWeerq4uoptvJvrOd/BeZguGzBT00Mqolbk8e3tx/QUL0kuUIxFBHM3OiHJMl18OnbdvH/T13r24n6IinKOlBUBdLpqP738fAOHWrbnvKZVCZsL7369uOzQ3I7ttYCCdW8njEVy9LS1wVrxeYbNxB1mPB0Fbn08Egmy2uePsbGuDnblnD/azsTHB/XbaaQDKfT6sK3acZBuJCM9QXkdlZdgz5WeaSoksuQULYJutXQsOW6L0LLg9e+AY2u0CrJW7Pq5bl14eZYghhmQXvbyMuY5T2s5OJ/y1QABgDGddTU1BX0xNYV8/dAi26fLl0Hlr1+a2U2V/sakJ1yQSXUXdbujMk0+G7xcKEb397aJk1m7HWEwmXG/rVmQpt7YWDqjNhh8i3xfbzW439st4XGSScdn/2BjuZds27WBEtuqVbLRFZjP8HaYt4MooBnKtVsHpazZjbIEAvnp6RHaeXNJss0FXT09j7y0qQsb7tm04jveHZFL4UUSCN9XhOP7osY5FOWGBuZlwKCmJHJmI3+MBKr1/P14QJj32eGCIbdgAoyUYhPHHXXKOByc4W+ZTPE70wAOIzLa14f9yx5X2dqJvfAMvdFER/j48jGNsNhFtfsc70ud+2TJk2L35pgCO+DktWABj8M038RwZJGMFeMUVUBbd3dkVbC4nRU4lfuIJbCCDg0QPPogoRrZIdz4l0npKB/ftw/rhNTswIKIedjscnrExEb1aswabZVeXmIOVKzEnzA9QVJR5vdmQfEDvZBLK/N3vJnrb23ITo+YSZelNd7cAYq+9Fs/z1lvhJLS1YWN69VXREjwaxVrr6cE9FOow5RuFO5q8jrmezw03HL8NYAw59oSz4Ww2fOdyOqXYbIj0bt589Md4rIu8R3i96bxh3Blz717w8i1alD0LfaaSi8szGoVhXleXrju4+2tTExyuv/4V41PqeplL75FHsOcS4VxuN2yGqiro6GzZBmYzsu03bdIH9vj9sE24jEtpOxBBb7KOLi6G7cINtJYswd5aUYHsg1AI56mqwvdQSGR8VFbifuaSs/O009CR0G4XFBdMkF5ZKbL8jhzBGOX7vOuuzKDN+vWZtio7bkVFsEHs9vTSWJl77+WXRakyZ9jIXR/37sUcGgEfQwzRJ5ztlE249D+XsN599FHwlnk80BNsoycSgm8uEoEuGx8n+vvfoUuam0XpupYofW+fT/BV2u2ZXberquBDRiKiYUwqJXzixkYEG046SWTzFRrYn0lGufK+RkfxNzmDjCsCTCYBMgaD0P/79qlfK1v1CmMM09Pq3L1OJ/T/xISg8eFOu9ywhwOlXq/Iquzvx/inpnAv/f3YF8fHcZ2aGvDFOZ3wi8fHRfZzJIJ7Zp/UYhGg4ZVX4lnONAFjvssJC8wVyqGkRuRos+H7okVQVPG4IExkgGpsDD8vWgSgQI5e5Mqs6e+HseLzwbiZKf9IvpIts4YIoNwjj4guX9XVok0y3/+zz8IgrKnByxoOw6i1WPAy9/aitLKiQsz9tm2IdieT6d12iPBzWRnm5LXXAJy9+mr6GFtbQSCeL3eOUrq6cH9cPqQnszLfEmk9pYPd3ZijZcvgQITDuCe/X6RHT01hTS9bhrVz9dUiFXxkBCnHnJo+OYlnU1cnSl9LS/GMZtIdLR/Qu6tLe55mssbb2kSXuMlJ/Dw4iG5BZ58NEDgQwOYgN/nw+zHXq1djHc/UYcoFEs5V5mA20fN8Hn8cpWAMFDY2ioY0Y2NYd0aEyxC9Imc4ccdrtcy5detQjmmsq0zhPaK4GEEFmTeMCHtpKAR95najgUAoNDcZWS4X9MHhw+nd8JjLc/9+PFuZm4a5PEtLYTv19BDdfbd2OWdbG9EHPoAy3WAQn2fnjTu9Wa3Zsw2IwFX34Q8T/ehH+u7tL39BKe3oqLpzJuvo7m7Md20t1jdnp8Xj2IutVuw7vb34Ho9jjuTOdHNZwtncjHlUsy2rq+HQbtpE9MEPimCYVkfZXbswvsrK9MZZw8P4IhLrc+9eXLemRlR8dHfjuKYm7MsOR/oclJQg4LNpkxHwMcQQvaK1l8rC3JJ6pK0NfsPOndCdViuCKFymXlYmeJqTSdER1mzG/+TSdTVR+t6RiPCZ5eYCDOaUlcFueOopHMdNHrg8t70dnznjjNnx9wrNKFfeFweppqcxVrNZ8H7LYBo3Ffr+9wFuKvfBbIk7ZWX428BAZjkrB9DPPJPo4otBQdDbK6gm+vtF93MuheZ1wr4k01EsWoRnMTKCezr3XPgBL72E58TBuFgMX6GQyGpMJvF/sxmBoksuUefmV2ZnGzagtpywwFwhHEqc+XXoEF4k7vY5OYlFzPwi8Xg6YaLcRcxkysx+y5ZZs28fzh+LEX3963MXAdeSbJk1b7yBY8bH8eLV1uIF57IELuFgsknOpGOkniMHTIbp9QKY47kfGREAkdwZhoUV0cgIiDFTqfQx7t4NxfTpTxdu7ObKBlQDbgopkdaTNckOrcsluuJUVWENcoedQAD8ANXVAgDmttaPPAJHqqwMn5ucxHplstemJnylUjOLWOsFvZ97TgCeMy0lV0pHB0p+vV6AlOEw1utLLyEaeMopIIstLcXmwxtoQ4MAlYlmx2FSAwmHhgCSMkgnHztTDqhcmZp6n89VVyHz9Je/BKH71BSOqaxEJqYhhuiRxx8n+trX8G7LRPxyWavZDIDmq181IqdawnvE0BD0mhysSqWwDyaT0O2jowCCFi6c/Yysjg7o0J4ekVHBja1qanCN/ftxnVgMY4pGsddwkGhsTF85ZyAAMMdigX2hpF4YGYE9losP9LOfRVXD5GTu+4vF0KDgJz9R/7+so3fuxF7v9+NL5myNx7Hv+Hwg1g6FEGBV8s4RzR1dSa6s7Zoaoo98JD17PVfQpqkJa0wudwuH8YxcLjjGw8OYjw0bYKcVFeE8kQjskx07Mjs6+v3YhzdtMpwyQwzRK3V1AhzTEotFf0MGIugHqxWAjNcL25jLJokE0MQgXTiMd7+tDftOtr1G6XszgMU+s+wvE4mu3okE/JpUCn/jjqOcgd/TA39iJv7eTER5Xxyk6urCGPn5yEAWA1bFxThWbR/MlrhDhCBcfX0mbZFcadPWRvTFLyIL8n//F/um2QzfkZtDyJUMDNRFIgg2vf3tqGiSufA7O/FcbDaxHhiEk88xPY3n1NYmfJGWFuGnPPEEMqmZ49xsxv1ed112vtz5LCcsMJdv+Wh7O4y1zk4ooWgUBinXwo+NCbSYM0t4AfMLaLdrl4CpZctEIjAky8sRgZhN4IJIXwdVLSOtrQ3GuckEAuaREbyIcllCZ6fIoiMS52ZlxHXuRMJJk+e+rk4oOWVnGCLBe8BNDJTEmDN1SDo6cmcDKoGbQkqkOUJRUYE5W7dOncS0rU1kdyk3MzZ8i4vFuub1K49p3Tqsq6EhOAnT03hW1dVITe7snHmJoh7Qe2AADnu+86QHsFLjYmKeioYGvJter4jQLVyI6xQXZ2ZmzobD1N4OsnOPB9dqaMieyTITDig9mZp6nk9HB9E99wDIZQ7MmhpslLW1eH4zKfM1ZH7Ij3+MsvFAIDNizxlVFRUo7bv8cnCNGqIubKA//zz0vhysmp6GUWu1Ckfq5Zehb1asmL2MLDnodOqpgvuNmx2sWgXdduaZ0G1Hjgj7p6EB+xIDMHrKOQMBfIY7aMvCQT2mFMkmLS3IAP7lL/Xd55NPCk4eNZGdC78fDorMu+ZwYM4HB2H3ffzjcEAWLcIeo5S5bO7jdKJD7ssvAzBTZmJzUyQmWO/oyB60GRtDZsr27XD0JiexZySTAvhLpYQNWFEBHqjly3HdoiLBrTw6CqfN6cRaqK5GVoUhhhiiT+rrRWmiljgcgp9bj8j+sd0uqG+4IiwahQ7k5Ai7He98NKq+18i2u8+H8bDvzQAWNxng/cLhwOe2b8fvLhfs0FgsHTjiYM/gIPRwPv5ePnRD+cwZc5DW1sLOZ9uHAbBQSMwbdy2trsZcKPfBXMGVJUsAmr3xRu5KG7MZ1S8TE8AxpqdFsFSLXiQaJfrBD7B+mAuffaiyMsE5yJ/lQGsyie+8j374w+nJK3KjzHBY0HEQ4V5efJHoS19Ctp8h6XLCAnP5ELN3dMCx7uoSHVaLi4XRWFOD3/1+0f3KYsEL4nRi0dbV4feaGu0SMDkS6/OBfN5mS+9iMhuAE5E+Bz5bZg1nBjKpsMsFA40BK5sNgMSRI/g7l+Ta7Zir4mK80BxtKSoSc8dzv3Ejvnd3pwOd/IwY6bfbMQ+z2dGWHZCDB7NnAyqBm3xLpNU6E/X1ibUnRz6uvRZZVrt24RnJmxk/k4YGrJGODnEOeUwcjZAJPWtqkPX42mswjk8+GZ8pdJPSA3onErivlpb85ylXabB8v0SC20deP1NTgg+Sy1fVHKapKazxI0cK27gZ0O/qwjVkcHcuMln0ZGrmej59fViHJhPmxuHA+vf7cR/l5XPLi2TIiSF79xJ9/vNYN2rC0d2NG2H0XX65sY6yCRvo7e14Dx0OvMvRKJwSBussFkEyPZuk+hzwYC7daBSZxwMD0DkeDwzq974XzzKZFAGJpibYQs89l185Z0kJ7iMcFtnqLMyb5HLlBrTMZqLPfQ7j11qPsni9RL/+NdGHPqRvbrLxtNrtROecg2exa1d64wi+j4EB0Cckk3hvlHtNIQ6kcs9k5/zsswF+cdmqzCUXDgOkO/ts9b2B7Z26OpS7vfYaMs+jUXyObTrmsztwAOf653/GM62sJPrTnwQVB9tvvF9t3GiUsRpiSD6yYIF6RZEsNhuO0yvsH7/wAt5tBl+4UUAsJqiIQiHsN04n3nmlT6Smh0ZG4O9s3AhdKPsksRj2AiLoF06CqarC5wIB7CHMr83g1egobNqtW9E9uqwsu67Ml25I75wxpkCEMVVUiNJQs1kAWGYzxu924345KUBtH9RDc3PRRdp7hOwbrFoFMO+pp7AnxeO5OQqDQezl69fjZy7BrawUoCzfG39PJvEsnU7MC+/RykaZnF03NYVjm5pw3oEBVFosXmxkzinlhAXm9BKzEwlj1OWCUkmlRElmOCwymKJRLDSrFYrQ54PBzIbKhg1En/hE9peeI7G9vVBCzc2zCzgR6Xfgs2XWDA8DkItGwfFiteLFikSgaEZG8LvDgQ2hogLn3r8fUeOqKij08XHcc3MzrtfRARDg0ktxziuuAKK+YwfmsrJStHVOJERJndutfq+cndXZqd+olTOu2tq0swGrqzMj3fmUSCufw6JFMHh37sScjo5i82tqgkKMx/G9rw+f5cgHE2OXlop1ITcLUI6ppkaQW3u9eIY+H77sdqJf/QpZgno2KTWHQQ/ovXAhxl3IPGmtVx7Lzp2CB02O7PA4OFU+GsX6GRqCgyJnXBJh/l98Ee/yz34mNhi9G3dHB0rfu7qw3t3u9A50GzaIdudaJOh6JZ9MzWzPJ5lEaa/DgRLgF17IbGTT2Qlna654kQw5/iWZRIQ0GwiSTOI9rKkxMi/1SlsbOPgY7GcCbs5eKC6GXnO7BbAyW6T6fX2IcHu92Mc5El5VBVAplYJevvpq0djqttuEM1FIOWdZGY7nslll6aPNBsNdLaiilJUrAUL927/lPjYWAyfd2rXZ12UwiD3b41EfHwe+wuHs9qbFgs9/5SvqPL75OpDKrofxOAKk7e2YX24KpdxXBwcBrr7yCsBE5TOS7Z09e/BMTSbYRxyo5cxNsxn3f+WVGCdzrHLJtduNY0IhrKepKegBA5w3xBD9EggIn1QGRpgvjP+eT1DGbEZG9K9+BVu1ulpQEhGJbChuZmO3Q1eUlUHvsY7Qst1HR6H3tm3DXlBRAf28c6fgZ+vrw99ra3Ftux26lrtL2+0YQzQK/VldDR366qvQ81w9pKYrC6Eb0jNnso4vKRHdqokwxuJijJvvgQFOOUilVaWTi+ZGq9JG6c8ypcTb3oYs6sOHc3MUEmHMBw5gvlesENmTZWWicYTVKv6eSuH5nXcePs9VEzyWxkbRiDCZhJ8RDgMTaG7G/4eHkeV+113GviDLCQvMEelDoXt7RfbNyIhAgjlbi7vMcfvjYBALNxKBojjpJCgsBvH0SiEceHokHwdeK7PG48Fx09N4WZxOwasyPY25mZ7G35qaYLQToQSHu5pWVYl7s1phzD3/PP7mdKbzb335y6htf+EFQTJcWQkCyne/Gx1Ss2X/HDgADjqrVZ9RK2dclZSkZ6bJ5KSTk7gXufRTb4m0y4WIvPI5LF4MgO7556FAYzEAk48+is+0tsJRaWyEAqutFQq1pgY/K1OY1cZUU4P78vmQHfXmm1Cw+ZRMZ4s45QK9L7kk+3PLNU/K9ZpMYs10dmID6ejA81m4ML0ZC1F6qrzbjc3e7U4fa18fNi1ux87Zi3o3bn7PRkdxPnZCZHB3507cY08P+CPLy/VxK6iBoflmamo9n64uzM+ZZ4qyfGUjGybmdbvnhhfJEMgPf/hD+va3v03Dw8N02mmn0Q9+8ANav3696rH/8z//Qw8++CC9+eabRES0du1auvPOOzWPn2v56U8FB2kuWb3aAOXykZUrif77vwH6j45Cb3R0CI5Rtzu9K+Zskerv2YN9gktveM9nPjGmSZAbB8nORGcn9uF8yjmbmxHA4JKbsTHcI5fGWq35ZVldfz0css7O7Mclk1i/d91F9POfazsFJSXYg+vqROagPD6Zs7WlRd3ebGoSnVG1eHwTCf0OpGzj1dTgHMxJa7HgWRQVYY0o99WmJtgA3d3pnRGJ0qsZgkGi3/1OVImUl+P5MH/SySdjrNEosvOSSQT7+vowpmRSZOA4HIJW4o03kPlhOGGGGKJPDhzAu80NBeSySSJRinrgANGaNfrOGY/D3yorE+WKlZXQF1xGGg5DPzAdxYoV+DvriKYmom99S91237gRoBwR/s+68OqrkdW7Zw/OMzEBW5n1RUmJ8LuZDok7xSYSIhOX+Uu1Avj50g3pFRlT2LpVUFG1tGCPGBmBz8glrQ4H9nP23bi5Wjyu7vsXQnPDe29xMQIuvBdwJdjoqCit1RIuTfX7MZfs04yPC/3NmfoMCtfXQ5cXFeGeSkrS/RRuQshZlBxcDATw3LmzqxH8z5QTGpgj0kahiQDKcfYNd2kcGhLRQeb1ikYFEf/4OIClSy5J56xKpfLjzcqXA0+v5OPAq2XWpFKC9JFTVZmcmVObTSYo8aYmkEbyvZ57Ls41MACFUF2NcRw8iDnMxr919914Ht3dONfy5eJFffVV9eyf0VGAKy4XnAG3Wx+4IoOiyjTr0lIotHAY87R0aXppst4SaSLt5zA2BoU+NITfmc/B7xeKe9Uq0YGIFXgwqJ4RqDUmBloOHcI5zjhDfC7XJqUn4pQN9G5tTX9uRLi3SATK+MgRAGLZ5onX67ZtcBh5DTU3Y/4OH85sxsKdARsaRHSvthZzyV19BwZgxLhcyBqordU3J7LI79nISDpHIpd679+POeFStL4+ZKu98ALR7bercytogaErV+YH5GsFJZYtw3vNGawyjyFR7kY2hsyO/OY3v6Gbb76Z7rvvPtqwYQPdc8899I53vIO6urqolhekJM8//zxdffXVdNZZZ1FRURF985vfpAsvvJDa29upsbHxqI49HodBnisCy6K1Zg3RlpUrQeYsOwAlJdBHRUXYh7npAoMlMyHVTyaxl8bjcCJYH8iBBq2sPHYmmpuh37jTOpOJM0inxr8rZyF4PDgPR+T9/uzUIGpiNhP99rfgU+VmNloSDCIg9sEPEl14YfpcsM3GwbLduzG/fr/ouqeklCDKtDddLpBxDwxo8/gSpZd559qHZEfs1VdhT8lNKbxe8LsuXQo7Qtntvq0Nxxw4ALtpwYL0oNqllyIINj2NcwwP45nLa8HjwTPioBbvbckk9lO7XZRDsT0dCmG8esrQDDHkWJBjIXjG1VuczcZ/4/2XbbVs5fayKLm1i4rgO518Mn4/eBD6eGIC16ivhx6x26GTuFqHK5W0bHfmf77+evG+B4OiaVtLC3QYN89JJsW9MM8dd4ONRnFMLIaxVlZiD1TTlfkGsfMV1vEvv0x0xx24t4ULAdCddBLm7rXXBGhXXy8qUTwezGt1NZoVXXHFzIOWgQB84dFR6Gx5L/D5cP3eXu2uvXJHX68X42N6rmgUz0yeb97Xzj4b+8G+fWIPbG8Xfgpnc3Lwn0tkIxHMkcUiuv8awf90OeGBOaJMFFp2fuXsm+ZmQWbMTR140bIhzIuzuBgvHUu+vFmtrdkBnv5+GME+H14qvQZMPpl4auW+sRgyfMbGBELOc8i1/9PTeGnXrEkfU00N0lp37yb66Efx/4cfBiixdm3uyMWSJZg3NmoZPFTL/pmaQhmiyQRwhY1/PeCKEhRVln6GQrjHxkYoztbW9LWkNZ7ubmwaZ5yh/Rxk4DMQwByXl2ND5IhQTw8+t2MH0S235H7u2cq25Qwp5Xm0Nim9EadbbgHHlAw8NzVhw25vF2W527bhftmpiUSwWVx3HcaYbb0WFwNYbGjAPfBYVq/G54aHRUZmWRnGwanjRMIZPP98fOXK7NC7cfPzbW7OzLjkyFgkgmP4ubMu6exEuZqSW6Gjg+h738N1q6vxjlmt0BHt7SJbRS+QrxaUSCZRThUMZpLy6m1kY8jM5e6776aPf/zj9JGPfISIiO677z568skn6YEHHqDPf/7zGcf/6le/Svv9pz/9KT3yyCP07LPP0jXXXHNUxszy619jTekRpxOAhiH5C7+/W7YQffObADwcDuh0OXOrqmrmpPp9fdClTU3QpQzMMbhit2N/yZaVx+VRf/wj9i4ujy8txb64ZIk6yKYMIkxNQZetXZtJbq0UtcDnqlUAjm+9NXc316kpBEmWLMG49u4VTRQiEYyDnZKODtGxNBjMpJSQ54H3jd5ePC8tHl/OTvH7c9uTLEzf4PHgZ2VTivp62CK9vbBrlFJTA+DylVdwDp7v1atxPDuWTL3h96eX8Sq55dg25ExKzo5LJGBHhkL4eXoadvbkJNbyTDmfDDFkLuVYCZ5VVorGDzIAx7ZmKgW/rbIy97m0uLUnJ2H7bdiAIMXYGOzOZcvw//HxzGqzvXv1+ZplZdDJySQylJV+BdvyAwOiVHd6WlSqcfKL3y8aybBfyvMg68qZVqPp4fvs6oL/OT4OXXvgAPwOIiR1hEJiTg8dwr0FAqJhxCmnwE/u6AAVAHOCFhKkYG5rtQZFNTXwv7nDuVKUJa4OB/a90VE89w9/GGurqws+yMQE5nrVKhwrA7XKhKOyMozt8GH8zuWvZjP2CP59aAhjW7Uq/3s/UWVeAHOycAdFdn5bWrDYDhyAIUOEBckKj9NRKyuRzsudReToBUu+vFlaYMq+fXipYzGUwOVjwChBJxkkYGNbduCVRvHwMJSN3S6MQQareG6IACrI6bny+auqRDZUd3dhjRKUQKYy+4dR+LVrRbmnPI7GRm1wRS3DjEs/Dx1ChgJHBh58EFFeee6Vc9bRIZReXR0+U1enDqRwZh63B+foBhE2ypIS/G98HOtAb1RHT4aUmhQX4xnt3CnmJt+IE4+vowMOkfz8iLAxcJMB3izcbnTGu+KK7Jmjw8P4n3IsNTVIl9+9G4qf06Z501BG93jDa2kRDm023sJcJZz8noVCmRmXXArP0T+XS2S5JBL4/6FDRN/9LkoCOY38Jz+BU2g2456sVoy/tVVEw/r60pvFEGU2s5FFGZRIJtPXvjz2khL8XFWVu5GNIYVLNBqlnTt30q233vqPv5nNZtq8eTNt3bpV1zlCoRDFYjGq1GONz6IkkwDmuNNXLtm4UfCRGZK/mM0AUc48U7yzNTXq2ccz7bQdiQBY27ED+oQpO5hbzGwWpZJqTkRHB3Q620nsIA0MACx697u17Zdc/Dpqks1e+OQnsSffeWfutfrqq8gSS6UEgXdTE+bC6RTR/cZGOKzZuuKpzauWk8g2pMmU256U7/mhh5BBzgBqPI59Qu5wz03MhoZEkyRZnE44xNdfj2P37gW/4I9+hDno6sL5Tz45PWjJAV2ZW45INPHg63NDJTmTnbstDg/jc07nzDifDDFkLuVYCZ4xxRKR8EmVkkqpAy+y6OXWPvts6O+lSxG0YOBdqZPzrfrS8itkW/7IEexpsRg+yyB/Mil+5uQYWWRdOZNqND0NI5Sdy998Ez8zl1tDA+5hwQLM75YtAgStqRFJA/39AEjfeEPQfSh9/HyaAmllTHKCEZe1yscr15K81wwMEN13H9Gzz2JP37NHBK3UgFqidN+6pgbn43Jk+Z4mJ+H7lpZi/W3fjsQJw9eAzCtgrr0dbe337RNcchzRjUQAHpSUiDp35lE780wYjakUSNwZrFNKvrxZt9ySCaZEIiIFNh8+MBbli8HRdeYfSSaJLrgg3YiXjeIXXhCRYDa0iouFgR4OA2jh9NmuLij0cFjc50UXZaa1qomsTNvbBacOlysqS17l7KwjR0DY39wsNhS5tr6yEs9IDVzRyjDr74cSTaUwh5WVUCivv5459zxnzz2H7CuzGb9zOW1PDxTY9LToTESEeQyF8CW3j2bhUmEmFc0V8ZclV4aUcpPyeLAZDg0htf2xxwormyRSB6Knpoj+9jfc69vehrmRS5v27YNC5lIhrcxRlwubnVJqalA+vXs3onwDA9k3DRa1jVsGdhnczVbCqQR3lc4L8006neld+hh8HR/HWuvtBXDx3HNEf/4zjqmqEqno3Ehi5UphrGRrZqO1sckbPGcy8nnWrYNjNjAgwEA92SqGFCZer5cSiQTV1dWl/b2uro46c5Fj/Z/ccssttGDBAtq8ebPmMZFIhCKSx+/X064yh/T2Yt3qEZeL6DvfMYytmYrafuV2Q6cMDMwOgM460elEMOfFF0UHTiLox0gEZOE7dkDnXXqpMKZlp2/jRnxGCR7u3ZudX0wvv04yKfbdqan0fVe2F665huh//kc0T9IS2alNJJApNjGB+9ywAffa3g6d/P73Y5xMtZFrzrM5ibz3q9mTqRTGHQ5jHpNJ0czB48EeMTmJueWmXI2NsNX8fsEvx93CGSBTlhVXVGCO/vxn7NOlpYLOg7M8NmyAs87PMxoV3HIszc04X3c3xsWcgZxFwmXFdXWYs+5unNPo/m3IsSjHUvBsaEjoWC0xmwU1jpYUwq2dTcflajLW1SUSA7gRlJZfwbb81q04jrPLiopw/XAY+shuh25SZhjLYJteuiFlIEtPMk1ra2bn8pNPRvYx3/fEBOz1FSuwfz7yCECxt70NY/Z64feEQiIb0m7P9PH1dpXN1qDI48H/LRbo8fZ2AIicfJRLJiaAF/ziF0SXXQYKr2xAIdsqfX3w/Twe7DvcoZslkcD4uClIV5fBMyfLvAHmOjoAhO3dK15UrtufmBAoPHeAYa4ViwV/KysTqbVEmUaWXn4xZcaRDKb4fIiG2mzpWTFa5ZlaaPp73gMU/qmnMF7eF7jTKXeplF9uNop9PsHNxQ0vHA5B+jg1JThonn5adFxhkkciATKccoq+yMXQEBw4NiJHRmB4Njbi++HD4GK59Vbx4paUwIno64OyUfKsDAxg/rRSZJUZZsw7ZjZjvg4cwN+5VCgQUDceX30V8yJ3/CwtxfMLBESnNFb0XLPPRJjc/YhItC1nwzeZxHqw2/UDJLkypHiMHg82h+FhOCJr1gggNN+ySWXpK5Eot2FAeHAQhrj8PjQ14Zlfcw3mXw1wqq3Fc2anQSmhEJ7PZZeJbL9c0SXlxu31ClAtFsO1V6xIJzlXm2els7xxI+azuxvjYqJ2pQ5IJjF/gQCObWkheuIJvEMtLULHyJFMzvB93/vwfLSa2Siv09eXHumSy7M4A2R6GuDgpk34mklavSFzL3fddRf9+te/pueff56K5JoOhXzjG9+gO+64Y1av/Ze/YB/JJWYzAi1GecLsiJ5GVjMR1omvv46gQVkZdBp32IvF8LdwGLZFRwfsi4suQtaV05lp88iOk9msn9cnW5ZAezuaNfzpT9hba2qg01aswM+ynfS5z8FhyQXMEaXvdX4/7oP3hdZW2Civv45zV1Xpr2DQ4vH1+TCX3OlO2XyrowPZFKWlojGWx4MxrVwJwKuvT+jzSAT63W6HPp+exvyNjSGjo7wccymXFa9aRfSDH2BvSKVQBcHdXdkRDAZFFk15ueBSVuMKvOIKXGvLFugIlwvn4zKmkhJhU3ODofJyo/u3IceeHI3gmd7AWWNjbhAllcJx2WQm3Npqki3BYedO4cN85Su41vr12f3BUEg0B1y3Drax1yvoVbipjNWanmGsBNuyUftoBbH10vdcdVVm5/JkEudesED4n6ecAtBpZATXTiTEOTs7ca9ccTY2Br2tbHbHXHy5mgJpNShiP8LlEt3PFy5EwKmjA89azmTTkrExJMUw9U4uHd3WBs7Uxx4TjTxiMVGGzTQHiQSOXbgQz9rgmRMyL4A57hjV2Sky5XjBcKdV5sCorMQLMjgoOuFw62e/Hy8ckeAbUXvhc/FmKTOOzGYolC1bMEYV+oIMQC8czs5fV18P481sBthjteIFaG2FItaKUHo8glPA44HCcLvxYsdiosSVyz6npsTfq6tx3NgY0de+hjK9XJGLpia0S+7qgsHrdmOe33wTgAKXxQwNAfHnPa65GVHrX/8az5OjPkQiqmKxADjTSpFVdpT77ndx74FAOsjHPGbbtqUbj7lKPk8+GXO0eDEU9JEjWE/LlkGpW614dhYLrhMIiE3IYsEz7OlBFKfQUg+1Taq4GFlmw8NQ5qtXC+eAswPyKZuU50EGuaam8J27BrIhzsLvQV2dttPJRNR6ol96My7kOdm2DWuLs9FSKZFVcO+92eddy1l+5zuxljm7VhbOPHE6xb309WEsbrcAMlk4kjk8jHfhtNNyR62IRLRt+3a8S/G4KPMtLsb1qqpEgxGDiPvoSXV1NVksFhpR1J6MjIxQfX191s9+5zvfobvuuoueeeYZOvXUU7Mee+utt9LNN9/8j9/9fj8tVKtr0ynJJIj19ciGDUQ33ljwpQyRhIGqeBwZW0TajYDUPqenDIZ1Yns7AKHKSuyjg4PCvkgmsT9aLHBCJieJnnkG/3/HO7DvO504jnmBWPTy+qgFEdiuOXgQdgXbYg4HxuD34/i1a7HXsp00MABAadeu3HPMmdJuN5ymaBR6d2AAdlAshj2ysRHH6K1gUO6/DKgNDwtKBS7lOflk2HVbtsD+qqxEGTN32ztwQPCsLl4MO+LQIcHV4/PhWAbEbDb8zvyuRPheX0/0rndhrjs7xX1zV/HaWtz/9DT+duSIIA8fG8M60uIK/PKXQb/ypz9hHrkRUkkJxsyk4Fw6rWdtGGLI8SZ6gmd6A2erVukD5nIFwXJxa4fD0BurVxN95CP6/A01Wp9Dh7B3nHkmdAUDSn190Gn9/dq2fFsb7HGnMz1L1+GATnr5ZfG3eDyT21trXEqfwulEkg7vi319GHtpKfx9zi5mIKmpCfr7N79BgMZux/zZ7SLIMjkpylejUYyD6XumpzFmTljgc0ciYg+QrzM+nhskXLZM+FV1dfAV5QZFkQhAuEgEY+Vrvutd2FO3bsWeqidz7tAhZM1985v6fIRkEnNTVyeSgfge2Y7gwFShjS5PZJkXwBx3jCISoJzdLpBbOWMpHAZYs3QpXujRUbxwo6NQNOvXYyGx8agWue7tza/GnZ3orVsBmJSX4xwcBWZhA2bPHkSrtdD0K67Ai33BBQIIkBWNw6EeoezoIPr970X2oMkk+M4CAXScKS/HuAYH07tZclkmpx8PDxP9v/9HdO212pGLqiqMz+MR7ZnDYcw1cylwW+nBQXRuTSZR1lhSgmfx4IPiHjl9l7vUtbSAxJjLBbPJ1BTmw2zGfSkJNEdGoJy4rKSvT3T01eL2cbnw+Q99SDQmKCnB9499THASMJDLoJzJJO6Pu97MpNRDuUl1d0NRLlqETVheYyYT1tShQ/rLJjkSFwphvjl70eHAfIVC+OzwsHb6eUuLNseQ2Zxf9EvvnNxwA9FnPoMxclSrogLXravDu5Zr3rW4kZ55BjrC78dccHOPSES0gq+sBLjM0a36eqwzGWQmEnxNXOKdC4DklHzOsGAjYmICz4fLs/bt099gxJDZE7vdTmvXrqVnn32W/vmf/5mIiJLJJD377LN0ww03aH7uW9/6Fn3961+np59+mtatW5fzOg6HgxxqnAsFSl8fAgp65LzzZu2y81qylbPk0gF6ymBkaWsDb9gbb2DfHR7GvsjVAgzgcFlKVRV0+759+BoYwPpwOqGXZftFD6+PMojAHG+7dsHm6eiALVJVhbFYLPg9mYSeGxuDXlu+XGSMXX45eNP0ZAZMT+P+kkmMwemEznS7cR/T0wC68unezfP66U8j8+3Pf8b8ud1wrJqbMc+Tk3CSenqwZyxfjs/x/DU3w5Hs78dzN5kARHLnvaIi2Eg2G76mpzH+piZ8fnAQ+82GDfj5scdgv3AXeJ8PY2AKE94vnE7YT3/7G87Le1a2e/3qV/G8TSbMl82GazGXLts5rJoMx8yQY02ORvBMb+Bs+3Z94AmD+1qSjVt7chL6dfVq8HJarfoDO2wD9/aieZnZjIw3tS7T3DxHy5a/9tr0QLzsL6RS8P0aGqD3Xnstk9tb5gNXs82DQZxfuS+WlsL3ZkyAKV14DwuHMaYtW6Avi4sxP9XV0JFOp2iaUFEhdBvzqHEZLgOKNhvux+/H/XAygMsl6ACWLdOuuNu2DRVkIyMC9ONgz8kni0ozbrSzYkV605AlSxBk+v73BX98NonFoMPz7ajN1XZTU/gqLsbcxmLis0aTuUyZF8Cc3DFKJjyUiTS5tS/X8bPC6u+Hg3vVVVA8Dz6IF4G7X519dmbpVz417nJde20tXmqrVXBLbdggUl4HB/ESPfkkDFKtclcui3O707NvWNQilJzKOzaGWvhXX8W1KipwjfFxzOGaNUDl778fn6+uzuRH4ShBRweupRW5OOMMzOfChVAw0agoJywuxjx7vVBeHC3ZtQsGe10dxlZbCyU3Po7jmNvEZkOEORTCZvGv/5rpkMjOS38/xlZSgnmTsx1NJihenw/G8ZNPZnb0VQJcRMLgLCvLdKJuvx3R//5+PKtoVJBrl5biGTDwORulHvImtXMnOOXWrMFaUwoDinrLJktKcPzevSJFm9+zkhLMD2/yra3if0qFrAU4zVUZl8uFdbRwIZ5VXx82j717Md9ud2aWpJqojfv88/EMn30W65Kzc4uKsEETgVODuxA7nZiHQCCTJ4INgUsuyb0RxuN4tgcPYuPt7oZxw++kTPBrlBC9dXLzzTfTtddeS+vWraP169fTPffcQ8Fg8B9E09dccw01NjbSN77xDSIi+uY3v0m33347Pfzww9TS0kLDw8NEROR2u8mt1cVkluXxx3MTTBOJ7pyGzEz0cN6o6b5CP0cEW2b1auieQACfqaiAke9wCOoF7tzs8YjATHW1MLh7euCknHMO9oNcvD5qQQTmeGtrQ6bCyEj6/jE1Jew1ph/p68N5Fi/G3tPWhgDUoUO555vLLh0O3B9XA3BQTXag9HbvZmltxX2ddBLmgO0CkwmfbW8XgcraWpxbthuLirAfDQ+LzHMmTe/shG0aiQA4q6zEeSorxTmqqmBnmM3YS556Csdzd1SLJZ2rzumEgxoMYv2sX48xMfdctiz+lhbYdrt2IcBNhDkaGsIakZ3RbJxPhhjyVsnRCJ7pDZwdOaJO1K92nCxqwJpWiefgIN7Vj3wE73i+gR0OoE9M4Dilncr6cmwMVRqvvppuy69ZAx2TTAoO5PZ26AhumubzAVC64QboEjVub+UeJ9vmHR3q5aEvvID9IRiET19ens7vvGyZ6EjKNDChUCa3J2dvNzeLfYIIY6uvx72WlopmGpEIPieDZkxzlExqV9yFwwhghcOo4OP7mJ7GGA8dSm8KdMopmb4pEY5fvBj3lksSCayZL34R91NZqd6sgmX5chwzPo4swupqwa9utwuO9fFxPB+jyVy6zAtgjjtGcWcX5pbjslaOpjIJL6ehEolMsZdfhlKRX+jeXrycy5erEyDmyvIhyuTm6u0VBozXCxS/qUkAR5zF1NAAUEGZ7dTUBCOaKL+uNHI5YmlpeoozR49tNqL3vhfzwS2t5YgGSzQqjPhAACnWallFXDLZ3Iz7PXwYL6zDIbi+uKOayYRrBoOYh/p6ROc5k3HhQswV8+jZ7QIE2b8/05BUOi9FRQBkpqbwDOrqRLMCIozTakW0hUhkL01OYtyRiABReS1lMzgvvhhK8Re/QKSrowPKvLYWjpFczjxbpR7yJvXYY9q8bbw+9JZNNjfjebz4ItalHJlhkmqrFUp4bAzrKN9sN63MNCI8L72d/GThzdHtRkaGkqdwfByO0J49+QFXbNQkEhiT34/1UFQkMghWriT6xCdEGTsD+evXi4YtnEnncCD79fzzc1/3gQdQtm+1Yl4mJ7FWOZuVCX59Pty3UUL01shVV11Fnv/P3puHR1pWaeMnVZWqpLLvSWfp9N7pphfopmmgUUQWB1lcQEUd0FFw5hvUkc9RmJ+DOs6I6IwDop8MzqjjKOooyKqggOx0Q3dDL+l0ek1nT6qyVCWVVFVq+f1xe3veelNblm6a7vdcV64kVe/yvM/7POc5537uc47HI7fffrv09/fL+vXr5YknnvhzTpvOzk6xGQby97//fQmHw3LNNdckXOfLX/6yfOUrXznu7Y1EYAinS0BNqazE+mfJ7CXbnDdmttZsz6M0NUHXvv46DOr2duhIAnLc8HO5sNYODOg96HAwTcjQEDaxGIGQLq9PfT3W6WSbCGecoRU9qUfJamP6AVa7Li6Gk8m0ADYbmAWf+lTmsUuGvtOJv0dH1c4pKEh0oERmti53dqIvyc4wClnqhw6hjQsWTGdKlJSozcNcviKwNyoqdGPvssvwDC+8oAw1EQVa+/oAeA4PY20ZHETfTU2hXRMTuknMgg2rVwNoN46ldOMomf27bBne55EjcNiWLcO6OBfWuyWWHE85WTbPFizIrLuoNyjpgLVMm9yz3dhJV9xBJDF1jbGQ38AANsBJemHkb28vIt1ItFi2TORjH8O9mb/MnNs71RqXal0sKsL1Jydx32BQiQbM77xtmwJw4+PYqOrt1XB/bqTT96yo0E2N7m6Aie9+t+ZmFcHa2NCA9ZbsOZHEcN5k/nssBv09MYH2FBWpXb95M3zqxYtFPvIRfHf//fBf4vHkBKEPfQjEFa83/fhiLrzOTqytjCJMNR6am0Xe/nZs5g4OYv1asADvmlFnJDa97304fyapN051OS2AOVaMam3VMNZwWBMyGoGEiQkYDHl5ieGWDJPI1tDNhuXT0TE9RxkTcvb0oC1dXZjQ0Sju2dIC42Z4GMbXqlUY4Nx9LSiAwVVXlxjLzxwkzB12/vmJgBErSU5NYfK4XDiGMfGxGP6uqlIgYfdu9KMxhQLpuWVlMMAI/iVjFTHnwcQErtffj0lst+OzSESPZTXLyUntl9WrwQh67jncr78f9ykqQn+NjgIIKStLzKsnMl1Jx2JQOMEgzhsfVwXtdOpiEwgkLgbr1+Oc/n4AgxdeiPZlY3CuXo2Y/Zdfxu9kO+W853yGesyE0ZlN3jabDQr2wQe1iiznGBcQtxvj6uBBLMyZChYkU87mtswmXMsofL+7dycy/US0WnN/P/L7ZMNWY5to1CxZgnm4ezfA23gcc/3CC3Ux4nPRkfF44IiOjkLnsOogQbxM9z18WEuzBwLo864u6AinE9eYmoKhwbBzK4TozZGbb7455e77s88+m/B/R0fH8W9QGvnFL7ILY83JQZg+WaGWzE4y5S9Nxdaa7XkUoy7q6cGaODAA3UU2WWUl9GVHhyb1j8UUwKOTYbNBD5aVJTfejW1lfiOCScZNBK8X18rJ0bxnZO1NTWm1+UgEejYWQ9u+8AWEVF19NTYHd+1K3+fxONap+nroff5fXp6eEZ+N/szGaSX4mcwhI3jX06MMa+Nmb1OT5gV0OLRvuLEYDqN/3ngDa0x+Pp6NYcnhsObtGx/Hsdw0NQOS2Ywjs/1LdkZdHfosU+V0Syx5s+Vk2TxrasrMmMvJUX8uG2DNCIwZ7ey5bOykq0Atkqgvacu3tWEj2djWzk4QYWIx6Acysfv6AN4x7HYma1yqdZGh/FVVWNMcjsSIFRYQbGyEHty1C2tUfb1unjPkf/FiXIO53QoKkG6Atv7ll6Mdjz2G/Oss1EBfo7AQOvLiizUqyxgS7PEAqNy/H/fbsUOjkBgmW1yMfmKU1vvfjzUjFUHo/e/H+vy5zykJJtX4Yh7yeBx+ejCIv3/0IwCBJSWJ6Yc+9Smso3v3ql9YUIB1Z9Eikc9/XvO/z9WXO9XktADmWDFqzx7kyhgf17BB5pijwRSPY/Kdeeb0cMuZGrqpWD7m3FxGY62qCjsDzz+PCcTcaRUVmox5akqrPvb3wyArKQFzr6ICk/aqq6DwzAmH/X5cp7wc1VM5MQYGsGPb2qqTMD8fbZqcVMP5pz8V+au/ws7F889jgtfXK9PQ78d5hYVQ5OnCE8wA0VlnQUnyfvE4rsW20HB1ufBcnZ3oI69XK5IVFqLPGOYSCCCccPFi9FtnJ+5tVtLhML4nazISwWdkVJWVYbwwlMb4vjZvhsHb14ffFRXZG5w2GxI8n3tu8iTVxyPUYzZVizLJunUAlFj0gYmt6+rwjnNz0fc33YT/0xUsyEY5zyVci5KK6SeCfh8bQ9/09WVfTdBs1BQXA4g05vBgTjcj02/FCs1D9NxzcFxEME85D7O5b0sL5jKB/MJCfB4IQA/E4xqm5fVaIUSWZJZYTOTnP09kkqeSxkbMcUvmJtmyD8xsrdmeZxQjqMLK3SxKU1eH3wwN5brMannl5co+qKqCPVBVBdvr8ssTdb6xrTzfCCaR5cUCAi4Xrs0NhpISdYSMa3d9veam5XrwnvfAtjFu9iWTcBgbZgsWYE1++WWE5VZWJh4303U5G6e1vBzrUUdH8g2zyUkwLyoqsCGZqkhSSwva29enYKLfrxUEuS5VVirzIxrVIhLMg1pVhc3ZZGFQ2Y4js/3b0IB+s1gRlrwV5GTYPOvqyv64bIG1L34xuT07l42dmWz4iySmXWlp0Q2Ori4lzPT3Y5P52DEAU8PD2Oh2OEAGMOvSeFzJJfv3q35JtS4y51tZGfTgqlWaVoERNQ4HNnYWLYLOo15taoJOHhrCc3k8uKbbramzjELGeWsrfIKCAm1XdzfWs5oa+NiDg1hjOztxbbcba9HAAHRzUxPWOpJ7CgvRTupSRvlkQxBqaUGf/ud/TmdmEhDmhll3twJvQ0NYP4gbmKuVsxjQgw8CRGRahI0bE306YzqLkhLYFJEIQMhsfblTTU4LYE4EL/YrX8GkfewxdTJo9OXkKIgQDgPtPe88DbecraGbjnGUzFgjGl1cjEHa3Q0lScOwuxsTgkYoS9H39oLRUFGBMMmLLoKBakw4bCzQ8OyziPO//HIg9I89hr6ZmoJxODaG0AsRKAG7HcrIWCX0H/8RiX77+zX8pKwMSmLx4tTgjpEVxXwC+/ahvStX4jlCIfRtdTX6g0rNmNeG1dMiEa2EwzwqRPftdnxGBsDrryMU1/hO43E8a14ezmFy4gUL9H6hEP5PxkivqgIL6o03AFpu2DAzg/N4AGWZZK5528zMtoYGhPLu3In3yHBm5lrYtw8g96WXJn+OmQBtcw3XoqRj+vn9WAybmzH+jIt8Kkll1OTkYF6sXo25wrlnBiDXrsX/dXUwBFg0IlNOH+N9i4rU4crN1cSuzP0UDmO8v/QS5p4VQmRJJunowA5wJsnJmc7EtmR2MhP2wXycZxYjqLJrF0CfF17QinVMHO71Yo3lhhl/U88UFGguXbMzZ2xrSUkimJSTo+tweTnuUVqKZ/L5NDTH7VbQsLwc16cdUFGB6+7bp3l+urvTPzedsRtugL5euRK6d67rcrZO61VXIQ+SsYJ6fz/WwOpqkU9+Eu8mXZGktjacOzKCdUAE74Q5lXNz0ZfMFdTTgz5jJb3CQuSB6ulJvSmU7ThKZv9a+UwtsSR7CQSyq8rKPMlzYUyn29hJBXpRZuLHmNOuDAxo4Zl9+3STwOsFcEdfMC8P/u/YGIAq5jAV0dQHzMV+333wR9773tTrIvOJBgL4XVuLdY+VX4eGUGQiJwdrX309viOrLicHOrOrS8NTWX06EIBP2N0N233FCvgtHg/WglAIetfpxEb5Sy9hfbj4YuRFrakBoLV1q7KalyzBfUgemZxUolFzsxZr/NWvtIBQJoKQCNI99PZiA43pq+z2xFRSTAWWm4s+4LisqkpdrbylBddOdW/6ckeO4F4HD+LeDgfW77GxuRU+fKvKrIC5733ve/Ktb31L+vv7Zd26dXLPPffIpk2bMp73i1/8Qq677jq5+uqr5aGHHprNreckLS0if/mXmNAs5U6jki+9qgoDu6REwyLnw9BNJsmMNWM55cFBTTZJ5JoGLys10vjNywOYQBS7vR2DuaICgJLLpVVAS0sx8Pv7RX7/e5E//hHXWL8eCpOsJzIK+/rQ1vXroTyNuy7Mk7Z/PyZZeTmeJRW4k4wVVV6Oic3wBoZjFBXhNxcdp1NLZDN0xRg7zxwxIhq3PzEB5RWN4ufb3xa58UZ81tsLRco+r65OrEbH3AbNzTCQqWyTjYOJCfT1hg2zMzyPV4GDTPfMpLCNQjBu1y6tShwKJQJLXV3ar243FiU6FVddheuYc8KJzAxom6vxYRQy/TweODJcKAko7tw5fZFP9S6yYau0teFaDGvlmNqxAwnOHQ70ZVkZ5inZDenARuN9c3LQ16xgSJYp8z0yFM3pBADI0G5LLEklf/gD1pVMkpsLZvrpZEAdL5kp+4C62eeDQX/0aGJxKB7T3g5GPllumTYumpvxc+WVYNg/+ihCU9rbod8rKzXXDgtN2e1YF/x+nMvcaObNS/MzMo2Hx6O5OcvLsZ6ccQbOGRmBDvP7cazdDocgLw86c2IC7GQm4OZ60N+P6/f0pHdyYzHYh/fcI/LZz87fupyt02pmKzIpeUEBQLKHH8a1kt3X3Nbqan1Wtxv9v3gxbB+/H9cdHsaaU1amVWfLytDPFRWJ6VAoVsEGSyw5cZJNRVYeN1fGdCp/Nx3oZdRFRh3U1gZmL/XVDTck5rAzpl2JRuEXjIxg7Sgt1VQI4+PQP8x17nJBN/X24lrMx75tG9odjQLAWrhQgaKbb06+npaUKAN5+XJdM0pL0Z+HD2ON2boV60xuLtrAfJwjI7h/Xp4SSyYnsY6UlCT6Lx/8INro9U4HoBhGSz/fbodvvXAhInr6+0Xe+U6sGy+9hGdnocOiIqzBjPBasgTfGf2FTCmJmprAEHe5gBcMD+PZ9u5NLMgYDmMsGJl1g4Miv/sdbIRk/lq6e3d2ok/6+tAfxhzf/f3ok2wK8J1qMmNg7pe//KXccsstcu+998o555wjd911l1x22WXS3t4u1caM9Sbp6OiQz3/+83LBBRfMqcFzERpdLhcGPCc7K4x5vUCMFy/WCpwFBRhgb7wx/wZKMmONQFI4jHuzWAWNXYYZ5ObifIJRZOXk5yvKvGED2EDBIBwrVu2KRNAHbjcmeCCA81jOOC8Pk8IIXK5apTsTRuCDedKyAXdSsaK6uqCcrr8e/z/0EKqG9fej3UTqq6qgKGOx6dVmzTkYWEKaIcsOh+YT+/KX8f/u3VBiBORyczEO+Axr1qAvWMJ6wYLja6jOFCibD8kmh5yIAqrbtkFZRyIYB2vXYuxwAWSS02ROxQ9+gGsNDycyxTZtUqBNBI5VKKSMOzPQNh/hWpSmJiyAhw7p+AmFcK+8PIwT8yKfirmWCcQfH8fOoM2WmKcwFMK4bmvDZwcPKltvwwaM+3Rgo/G+oRDOJ62d84IA/tlnwwAR0WSuzc1W4lVLkkssJvLrX2dX9GHBAoxXS+YuM2UfGDe7QiGsnWNjWKsKCnCdHTuUGfWVr8wsh4vNhp38iy5KzInqcoFJ19mpdhSZACyYMDGRfPPS/Iz19Vj/WlvxjHl5eM4NGxKLZbW1Ya3u6MAxdXU4Z3wc983NVWetqkrXg1WrkNYik4yNYROTzoV5XTbmm+3oyLyZ1dEB+0EEz/vaawA2k4F8sRjWypYWrKG1tZpygWzr1laRf/gH2F5mSdXWAwfgTC9ciD7auhXPGInA4eSGb2UlWOQeD8ZcRcXM2YLWWmKJJfMnMwHm5kokSbYhxAIIzPu9eDH0yM6d0A3XXosNbs5z6rGREdjysRiAFxbOe/jh6WlXnE78ZmEbY2g9C/l4vdh0ys1FG4NB2M3NzdiI8vnwXV6ebkoQCHzkEeQaTbae5uYqIOT36+f79kFHV1dDlzGf6ego2ltaiutfeaXI//4v7Olnn1VMobIS7aTt/tRT8J14LlPKHDqkaXOiUayfFJsNftHRo2iXzYZrDg7Cj3K70aZgUPO5trTgHtmSE3gfrsV9fWhLaSlsChZRYp75ZNLdLfI//4NovZkQI3w++ImRCPrZmOO7qkpDelPd91SVGQNz3/72t+XGG2/8c2Wae++9Vx5//HH54Q9/KLfeemvSc6LRqHzkIx+Rr371q/LCCy/I6OjonBo9W2GeNdL8q6oSCxcUFWEC2O0IASUbiKEUxyPM0LzLOTSEQVpVBWXX3q7hHQzZtNl094AUX4J1w8MwprZuBavJ68X/IpjELPFcXq753Ai+2e1QTGTpVFSo8jCCIGbgIxm4kyzUMRMr6vHHlZp7ySVQ/GNjmoiYDC2y4fiTLDEqC3swpxaBPDIFysow2VtblUloLGFtTPbs86Gvr7xS8/Ydr3DTbIGyEynGHABeL5R+VRXm0GuvIYSV73DPHvRTayscpsZGLUTy6KN4HxdcAOeBoapvvKEL4q5dSqXm4rZsGd4/x9t8sljb2zGuyPiorMTY9vsxFuvrMUdLSjIz1zKxXOicGfMUejzIKdfZqTtl+fkwAtrb8cwXXojxmgps5H137sT8n5iATmD4OispMv9iSQnmR28vrmclXrUklXR0wJjMRiwGzfxKNmytVJtdwSD085EjmPNHjkBvn3su3tFM83FSzDlRV62CPn/ySd1Zn5pSp8XhwD2Y3iHVM5pza5aWYg3+i7/ABll+Ps43V/N79FE4XSxMwZycg4MADLdswed5ebiey5VY1TSZTE3heKNzYUxW/otfZJ8HNVnO0Le9DZuQNTWJwBX1cFubrolLlkCfb92q/dveLnLLLWD/JwPnUoWP7typ72zVKownpggJhxWUI+A6NIR2Mu1CNmxB4zMMD6sj+bGPJW+rJZZYkl6yye3K42bKtDZLss2SffvgAzkcygILhzG/Dx+Gzb5+PfQBq7F/97vQV8uWJaal4QbKkiWadqWvD9dmkcFIRHUHQ0VjMejBoSHdTHe7wR47dgzrm8OBtS4ahR9CNl19Pf6+7rrk6+mFF2KN2b1bP2ee04YG5BD3evEdUzf4fPBrbr9dc6wRcCPjq68Px23cCB378svq2zMyizlSGYZcU6P3pjB6x+eDT15VBV1KUJObbbW16rdGItmTEyhme4Opowh2ZoqaGB+Hb7RlC+6/fTs+T7cxMzaGZ2d0kFFYnM7nm9lznAoyI2AuHA7Ljh075LbbbvvzZzabTS6++GJ55ZVXUp73T//0T1JdXS2f+MQn5IUXXsh4n1AoJCEDbOz3+2fSzJRC4GXtWgAKxuorpGiyIhV3WsnoYlgrS9qXl89fmKFxl9PnQ/LHo0c11wrDO5xOTY7MHenaWvxmNdSpKZxz+DAGe1mZAlhOJ34CAUzanBxVAmShFRUpTbauDt8xNx0lE/CRzNGvqQEwQTaikRGVkwPl+eyzuCfZREVFuIbHA0M7HFYAcWoKzxKPJ1aCMwq/Y0jsxITmwTl6FJ/H48oODATwLlisYGAA9+jpgWPBvH0nMtx0JnI8dqqN+dwWLNAFSERZCfv3Qxk3NGARHx7Guzr3XAVHu7s1z013NxwFgrKvvYbFtacHC42RztzXh/e/aJGOt7kaH+Zni0ZFLrsMDk9vL3RAXh76rrBQ8ztmCpPNxHIpLMQ8YJ7CeBzXGhzE+CTgbLdrtWKPB8esXZt6zvG+ra2Y9+XlyqYNBuGo1tbiul4v5h8XvYGB6VWxZuu0W3Lqyf792CHOJDZb6vyRlsxe0rGo0+Xa3LwZ+mDRImWOGyu8ZZuPM9WaYtZzF18MAIp2itMJHRIKQfd87GPpx4Y5t6bPByDptddgM1RXTwfAWlrArK+vx/OMjKAPhoeh01nVeulSkXe8AwBiZWXmPHOxmAJ4RocgUx7Um2/WhN4DA2CIb98OvVtbi2sMDwNMHBgAc59riPHa3GyqqMC6uGcPPuMGrMuFeXnHHSL/3/+XPePR+M4Y+sv8Rm43+odBL9x8ralJXcHRLHyGI0dwTb8f73/3boyN228Ho8ISSyzJXpYvz64q6/Ll85Ov2gjQbN+O+ex2w/5fuRLHkEFXUQF/mfqekSapCBivvAKbfs0afLdyJXRhR4emkaG/SnJFMKgbzGSh5eTArl2/HmvPffcpO88Mjo2MKOttzZrU6ymrpo6NYf35j/9QH7yqCvem78qCQ/n5IMAQM6CfTMaXxwP9XV2Nc5lWgexD5rgLBvGOfL7pQCzzrHq9WM9zcrCe0Kb3+/H3O9+p73W2KbZob5Dl/frr6IeRkezODwbBDHS54EutXAniRqpN/qIijM/JSfydrOBRQcHsUoW9lWVGwJzX65VoNPrnctGUmpoa2b9/f9JzXnzxRfmv//oveeONN7K+zx133CFf/epXZ9K0rIRMm/x8DBYi4GNjmk+tsBDAEI2j4mJMsOef14IANLSuumr+nFbjLqfTKXL33TBKKyqgcDs6YCgxDt3t1sourEw6PIwJ8dJLmEjLl+P/zk5cPxrF+WTB0TiLRKDU+vuhbJg8+eBBGMmLFilqnwn4SGW87tqF7/r6tBKOke5Lg3rRIk0wzR1clrTu7wegNjmpDKfJSZzL5zOLw4H319OjO+Xj4zjWbkcbg0HN5xcMoq00Ks2OxZsRbpqNHC/WE/O5ud1YjHt7tSqe24354fHAEGChgtFR7JRRyRrzJjKhq8+nuyTLlmEBiMfVuBDRMXDkCJy2hgZ8Pl/FMoy56jjPDx0CO6GiAm2bnNS2imQOk03HcmGFZzL9fD7Mh1hMk5gHg0odZ1hYby+uccEFqcHGlhaRD3wATlAkotWkYjHoLFY+ZBjw0BAqT5OJMZciGpacujIwoAmA00l5OVjOlsy/pGJRZ8q12dgIoF4Ea4F5DmfaaMi0phj1XDAIPcMcPwT+q6uhex5/HCwJ81pEcHFoSDfkPB7oHm64hULQx8bNAhEkD3/wQa3myh39oiLo08lJ2Ax2O85ZvBh2XyZgju0yOjaZCg5t3QoWW3U1+uLgQej2wsLEit8LFsDW2LsX12OOT+O1Bwdxv8JC2EShkBZm4IZlKITjZqKfzQ43CwM1N+MaTifmO53LmTh2xiTeXi/6vqREqx12d4t87Wuw7yzmnCWWZC8TE9kVf+B8XrECuV4feQTAPqMwZkIgoJ/z+9+DmbtiBdZ4EQBRExOwl+Nx6F2nUzfZ+/rAQkuV//nQIdi0xcVYK3JzNfUK0zKVlqLdw8OwkwsLodOZ2sXoh55/vshdd0HPLFgwPRyyt1dTuYhkF5U0Pj49XQ7bJYJ2HjiAH2MUHgsj8fiiIrRz+XJc84wz4MsHAvjObld7n4Uo29sVEIzH4UNceCF0qtHfKSrC+62pAUDJNWCuqZXa2xNZc/n5WkQoWyEL8OhR9Msbb4jcdBPILca1qqgI/jWJGRUVSjzy+zGujPjD6SIzDmWdiYyNjclf/uVfyg9+8AOpNNebTyO33Xab3HLLLX/+3+/3SyMTUM1BzEwbgj6hECbh009jEHDyicBIfPVVpcguWaL5Tb773fSMknQMplTfxWIYoIEABmtrK44vKwMiftZZ2HV44w0cY7djEnICNTTAMGIyTSZU9vmgTAsLlS5MYKy/H58xnLCwEOdPTMDgXbMG/2cCPtIZrzU1WnRj2TJl/5HuW1SE3/v2QTEYQbuqKrQpGAQT4OWXNeE0Q3uZA4lMIYa4RqN4Pr9fwQ6Gt4bDuP+CBbrbwVLdeXmpHYuTLdx0JhVNZypjY3AABgfxN/Pw5eRgoWEBEoKeExO4P1kMIgrEsuQ2masUOnJFRcoYMFZHLS/HuyDTTmR+knKbc9VxZ6ywEPMqN1dDvynZ7ESlAm9FoEuof5iLieN0agrjeHRUGXQiWNgKCzODjevWYYE2MmP37dPEsgzj7uxEjpBNmwAUzkcRDUtOTTGPi1Ry5pnWGDlekspWyCbXZiCgf6c6JtlGQ7ZripnpX1YGvZGsKncyEMkMLsbj+J+OXygE5ywe182C++6DvcPwpepq2EoiuPbUlK4phYW4zp49YER85CNg2bFfzGJkeF95pertdCCo16t2DHPzvP462iiiayKvT0bg9u24rkjitcmiGBvDNdxuDXnKy9M8eo2NM9fPRkbE3XfDsayoQP5BpjHhWnHJJeinb3wj84ZfZyfaMj6ONtOxFNHE6P39Iv/937ietdFjiSXZyeBg9scZN1OofxYsgC4zgyKZhGHotbXQNzk5sE25yZ6ToxvABKQqKuCzsgifWerqYFs//7xunni9WlhhfBz2Pplhg4PQrTYbNlYaG6E7k/mh6WyVcBh9YrMlJ1KYN6EiEYBKbjfaYhb6ASLpo/D8fvTPuecqs66wEPdnwQabDedMTuLY3l6Anbm5+pw33YR7Gf2dykpcr7RUCyPONbVSsnU/FkNfzFS8XqxbAwNYqw8eBGD8/vdrGo4HH0yM4hkfR/8wGjA3Fz7/6ZYiZUbAXGVlpdjtdhkYGEj4fGBgQGrJ1TfI4cOHpaOjQ6688so/fxb7E4LicDikvb1dlixZMu08l8slLnOg9TxIMqZNYaGGfubmAoQSgQIKBsFACQQwSIaHMfgrKjIzStLtNosk/27tWtBAf/tbzQtVV6fFCZxOgHPvfCfopb/9rYbWVlRAWU5OYpLn5WlIxaZNmPAHD2pYksOBCR0IaGguwz0J+C1erLHvTmfmXZdUxitRf5Z4jsfRX9zR6OpC20hPLipKBO3OOUfv/9GP4hl279adJDLlbDYtisHY+3hcq1OygIbNpveh4igr0woyF12E/svGsXizJdNO/lzbXVCA/hkfxwLPqrhuN/p6aAj3bGrCWK6pQVuMpczpaExNKShqnN5M2nr22TDeyWJ1ODD+ly3DOzQ7j5nYi8ZKhfy+pESPSZarrqRE814wBJptnclOVCrw1qh/iosVIB4bU6eNY5eGFRfmTGBjUxOOMYb4GsPBh4fxPrZsQTvI0JuPIhqWnJoSDOrGR6pde7td5H3vO7n04qki6eyIbHJtGgsVZJuPc6ZrSnMzgJ6BAQD+ye6TCuQ3g4tGdjXzC3Ejx5zygsnDAwHoy7IyBa9qarQS+8qVeu8zz8Q6s22b6lejMP3F8DAiIjimU4GgBBLDYdhrdJCYOiQaxfO43dqPTAURCKhuNV6ba1BHhxaDmJzU6/r9eP5U1W4zCZ3cSy4R+eMfkYtPRDcjWSyrvR0st2g084bf2Bj6zO/Xd2cUlws/1kaPJZbMTPr7sztu717Mr2TF9R54QPMlz0TMZBbjJrtRF9FPMudDM0t3t25AM9KJpBBjuiWGtRYVQa9UV8N2PXhw+gb8nj3Q9x5P8vRUDBO9+24cZ95YSAZGjY9j0+LFFzWPO8XoByxfnjoKjyGoFRW459696EebDWBfOKyFHcfG1G8/ehTPWVMz3d82+zuBAIppzEdqpVTrfnU1fL+OjuwLkYhouC9ZcaEQ/MKeHhQJfPxx3GvtWs3xPjWFsVVXh3WnqipxHT5dZEbAnNPplA0bNsjTTz8t7/lTmaxYLCZPP/203HzzzdOOX7lypezZsyfhsy996UsyNjYmd99997yw4GYqqZg269erAcSiCRMT+F1UhIludNJTMUpiMZFnnsGu7vg4JlJhoRo0u3fjOLOx89xz2HFmjrjmZkxanw+/N22CknnoIZEvfhH04o0bRf75nzVWXQQDesUKPNuRI8qOufRSKJH9+6FUYjEoBpaqLi/HMwaDuE9dHQBAvx/X+MQnoFwyJXJMZrwyFHXBAtzb48F9GarHZ1y2DP8XFyfG6Le1oX2NjdiVsNt1h4HKTUSTVLpcasjGYgoCsngGFwAa/n4/2sO8dzTsjWJ8101NJ08oa6ZwpvliPfHalZVKUw6FNCfa2BiAXlZYPXBAk68awa54HOPAGBo9NIT3W12NfEDmHIR+f/r8asmey1hF1lgdluFM730v5ok5Vx3zXvh80A0LF+K8VLt0MxVzOfncXO1HzkFWWiZjdckSUNkzSbKNh7IybDYcOIDnMtLJWdVwPopoWHLqSSyGjR9WBk8mrBp26aUntm2ng2ST0yxTrs2NG/Eed+3KPh/nbNaU2VbKNoOLZnZ1OJxodzEx+Jo1WG8qK+HIRKO69ofDWJMmJmDH1NUpgLV6Nfpk/360aWQkeQqMsTGsVwy7TAWCMv8v896GQmovsqq9ke3GZ2KfULcar801aHAQ7579Ho3iXm53+mq32Uhbm8hjj8FOcrk0lcvYGOzVc8/Voi9G0D0VOFtUhN+hENYcs5BByXQKllhiSXbCXN+ZpK8P+mA+N+jNNmVxMT5jqCd1Ee+XLB8aJRYDM7ewECGdr70GHTcxob5YXR38g/5+1ZN1dSLf/Cb812Q+V0EB2lFfj/sykocbzw4Hjlm+HOuKcWNhxYrkYFRJCYr0PPEENi7e+U71441+QHNz6ig8VkYNhZBv1OPBGjg8jPswiNDv1zDd3Fz03003Jfe3k/k7LS3z44+mWvddLlx3wQINC85WCLoydVZTE/rhnntwzdWrldm+fz/eS28v3n99Pfrl4Yc1jdTpIjMOZb3lllvkhhtukI0bN8qmTZvkrrvukkAg8Ocqrddff73U19fLHXfcIXl5eXLGGWcknF/6pzhR8+cnUpIxbRoaRD7/eSTmJSBgtwM0mJjAcStWJMY6m43NtjbsTDCZOndwGY7Z0gLqZk4OlB0nDxlirNzV3Ix72+0KTrW3wxg1GsTr1uGz2loF50pKFFT0+6GY/vhHHN/YiImxfDnooVu3YseZlWaCQbQhPx9gACeMw4FJkgnYSWW80tguLAT4UlGhu8WxGJRRURH66dChxF0PlwtsxoICLDzd3WjbmjWYwE89hWcoLtbwVRE8D8FUKmeGt5BGTGDQZkM/Hzmixr1Z+K537RK5//6Tp4LlbB2ibCUQmL4bVVeHvmfoi82Gd7pxo4aweL14b4sWaX447rjU1yeGRnNMdndjcTOGks8mX4IxCXVfn9K9JyfhxAWDujAny1XndOJ5WKU12S7dXMSof/7wB5GvflXnKsevMQwhPz8xjDfTtZNtPFxwwfS2z1cRDUtOTenshFFK5rFZbDbo1Xe8w2LAzLdkw1p75BGRq69On2uTDP2enuzzcc5mTTGv/fF44gaLSHIQyayDjOxqbpoZGRk+H36TlbVyJdaloSF1hqam8Fl5+XQAy2aD8/Tgg+ogGYWbM8PDCLvkJoa5nWwLdSwruW7fjj4tLkabmDOJwDb7xW6HbiVQVVODtYmOSlUVdPYTT8BJYXqRujq0o7IS73M2+pljq7MTa8uyZfic7A1uxhKw9PsT1+Rk4Cz7Z/du6AuCkHxmvx/2cHm5tdFjiSUzkepqBc5Tic0GvWLM7UyZ6wa9eTNZBLpt6VL1bUXS50MLBODDhsPQn4cOQdcvXgz/jeDcwAB0EiUYhL+Xyv+kz330KNbK0lLol8ZGTUtks0FvlpfjfyNQ+cEPpt6Eqq7GWrFnD/rN4UjuB6SKwtu3D/3R0IA+am7GNZ98EsezgKNZp5999swKac1XaqVU6z6JFaEQ1qmhoezyDlPicfRffT36r7gYhZ3e8Q7tc+YNHBzU4h0XXqhFRU63QnQzBuY++MEPisfjkdtvv136+/tl/fr18sQTT/y5IERnZ6fY3gK8Q/NgZo4y5idjyF2qogIiiYwSggHHjmEAL1iAc43hmLm5Cg4ZjR0yykpLNRk8JScHA9nr1R0AGsRFRVBiRNl9Pig/xvgz/NZuB7hACinD4t75TiRQPnwYRjrzhBUUYDejvR1Kxe3OzphK5ehzR3ZkBArw/PO1uMLYGFhNeXlob0VFIh2Yu7GlpWif8bpNTSJvfzsWjFgM1ybA2N2Nfisr0zxyDgcm+MSE5t3Kz8fz1dXpjlAwiHBZY0gGGWK/+hV+nywVLLMJZ5oL64m7UQ0NWrU4GsX1wmENgd68WXfKq6pEzjsPRUiYmy4vD5RkhhYfOJC4yIlg/sylmIOIOh0eDxaPSASLIcM6PR58ZmSfpiqhftVVWmVvvpmR1D+bN2P3cHgYi1cggD7Kz8f369cnD+NN9/z5+Zjnb3vb9PBdcxvmo4iGJaemPPIIcpkyDUCydTAvD/lrrDEyv5Ita+2667LLtTmTfJyzWVOMa39VFWwH2ix2u+YsM4NIZh1UX481pbtbmQ5kZBjZ1Y4/Wa6VlQiFGRnBms18oHV10J3JAKx167Bh1Ns7nQlKtnIshvXr+efVLtq4Ee/llVegkz0ePGMwqIWKCgoApNls0Lss5EAGNIs5NDdj4+jLX9YiU3190POrVuE6LhecX+bbbWmBjTQxgWearX7m2GLVVxZzonBjjQUnjDlWCSxOTOBdECi12VAg67nn8O7q6xOTeLvdcFhXrbI2eiyxZCayfDnmDudaMnG7Md/mukGfKp+pcTN51y6R//1f3QhhbrOuLrThwgtxv61bYedzvVm2DDYE9Qc38R0OHMM0SseOIVKF7c7JSZ7P3cgoX7sWDF+CS36/+niFhYmsPuP6eeCAglHmzSTazZOTiBirr09MDdHRoeljzOsrN6MaGmDj896LF4OB/Pjj+Oyss+CbUqdXVACYa21N73Oky18/W0m3ucaiRU4nNo9ITMlWIhGcz5yEU1OwCyjxOGyGaBTPwsrqp2shuhkDcyIiN998c9LQVRGRZ599Nu25P/7xj2dzy+MunZ0YDBdcAMPC68XgIThXV5dYodHIKGloANXW68WgOnYME5NMLI8HA5k7kyKJxo6RUSaiFGEK86z4fIkGMY3h555DW71eGIUsPZybi0G9Zg3u0dkJY46VwFpaRO64AwbW738PpVNQAKXm9eL5WlthyKZKlmyUVI4+iwNMTqIfWRLa5UIbGVJLIMxclnpkBPdvbp7upCxejH4lE4ohJS4X7s8S2yJaRODYMS31zYSlPT1oZ28vjPHcXC0+UVmJZ2LZbu5qi7z5iuN4sp6YnPPoUYzhsjJdBNxugLesxmfcURfRUuaf+hTeq7EAQqoFZa7FHHjt/ftxT1YVNi7IBLkXLtQdxDez0m5REcZ+SwvCh4aG8N4qK9Gn6cJ4zZIuH1WqZ5mPIhqWnHoSiYj8z//gd15eYlJ95ptzODAuuWNuyfzJTFhra9Zk1l8z0XGzWVO49u/eDZaX3a5V/Bgu2tcH49usU8w6iInE7Xbcv6xMUwkY2dWhkAKATqeu/dywI2vDDGA1NcHJSrfrT8fnE59Q8K68HG3Zt0/z4cRiChKOjuK90OarqEB/BQKanzgex9rZ0YHrNzTAqczP1w3BI0c0pcY73oH3u3s3+mY+2NscWzU16iQZowSYToHznN/RjmXV1UgE6VecTrRj9WqR229HXrr+fs0rV1YG23bxYmujxxJLZiolJdA9jDAyi80GW5GhlrPdoM9UhZubyc3N0MFGm5EFFKemRH72M5y7YoXI9ddDzxQVoe2f/zz0XmmprissFnfggG6MEAwyMsmM/lUyRjnDIT0eMO9CIeQUXbVquo3C9VMEbe3sVL/fWBixvh66eeVK6Lxf/CJ1/xjXV58PeeCNRXAoNTUAL/fswXF8Nw0NeP6f/CR9NFam9yQyO+Au0+ZaMIjPh4ag00lyyFYmJ5EflkAlc6+yGJLHg/XC59NNIZHTsxDdrIC5U1ForKxYgRdPYIiVDcfHMVhIuTUySrq7dXebhhqNHTMYQDEaQgzfiEQ0z50xLJM5U4aGABzSILbZYNT97GcK2rGdg4Na4IHsufx8TDbj4GZFGLZnYABGNPO6TE3hWvfcI/LZz2Y2BM1Gdlsbrkmj+bHHNHSVTLqSEijK0dHk1dyamgCYJXNScnLARvT7lS5ss4GFx4Sa69bBoGUoZk0NDEfGvVMZNDWpwW23Q3Ez315lpRr92VDFj8eORjI5Xqwn827Unj06R4JBsLxYeGPFitTO23nnTb93KsU6HwAZ25iXl5iriEKQ2+HQXBQib16lXbMTbMzPkw2wynFm3MVsapoZm/PNBCYtOTll61boXCZ5Zp5OsskjES1IZIWmzb/MlLWWjf7KVsfNdk1ZsQJ2htuteYgcDthFK1YoSznZ5pVZBw0MYA1vb0/Orv7qVxESZLPBaWUO2bEx2Gg7d2LDIxmAZbOBiZYuNEwE34+Pa5/19aE/7HbYBKOjuBYjGfx+fNfcjPb09SEU6oYbAMQ9/DCu6fcDrCwpwe/XXoMNs3kzNkIXL0b1WCPT+fLL508/c2zR+ezrS3QgGYpKu7O4GO9u2zb0LZOOl5SApXL33WobXnEF2Ig//jHsPxYWW7XK2uixxJLjJQ4HQj6PHZvdBn22VbgpZgbdr34FW8Foe77xBu77mc+oT8Q84SRLUKjLKis13xrTKYlM96+SMcqrqpTUceyYphWIxZJHQOXlAWAsL0d0gMulYZRTU7B/jh5FuohAAKy9dPlejdE1sRhs8VQba2Ym3sCAyK9/DR8/Xf9n855ENOx4eFir637sY5ozNZkYN9eMa2s8rptrFRVaTZc+1MhI6muapb0dz2i3i7z6KkKa+Y66u/F+iJ288gravWjR6VeIzgLm/iRmQ9jIACoqgpLp68PgqKiYXhWGu9s223Rjh2BAbi4GJME6SkkJrnngAMA7JvktLtbKly4XJrPRII7FMIkY187qYE6nKoS+PjhZDDXs6YHi6uhQZH9oCAbkiy/iObhjWlSklNbOzuwZYVTaLILBPtm+XXcyIhG0h4g5d9O5y1pcrLusV16JXYRUTkp+PoCiZcuw2zw+rpXFzj5bHUqyIkdG8G7OPx+KqrUVSq25Gffo6VHl4fPBCL/mGpGf/zw7BkM2OxrZSLbg3nyznmIx5G04dgz3zMvD+Glv11xze/aIXHwxAE7udMwHIDhXgIzzmOCymQ3AZOJkAr3ZoMJcgFWOs7Y26Ce/H8ZMTQ3myUzYnG8WMGnJySkDA9ADbreC8axazTxcIloN3JL5lTc7/+Ns1hSur5dcgjYaQ4JycpJX5Uy1xq1Zg/xuyb6LxXSj0QgALl0KR+vYMdgCn/2sbtSZxbxhk0rcbtyHDLJoFNdjNfu8PI1uiMXQlv5+zaXzgQ9gnfzGN3DcggVgDZSWqq1DJtqWLXC2+vvRZ0Z9PJ/62Ti2VqxQtoLR3mRBNOZK6uvDs7lcWmxDBL+7utBH//ZvaOfq1SJ33mlt9FhiyXwI52cytpwIPvd6EXFBIkkmO9KodwsKEBmTbRVuCnNv3n8/dH02kURXXinyu9/BvmCxM1ZPtds17UxlZeKaZwZmUjHKc3I0n3Q4DJ+2rGx6BJR5/aRNw1y6JMbws4ceSuwfrgcVFfAf/+7vtPIoiweS2JNqY41MvKYm5LYfGkrf/8uWZc47e999mkt7fFxTRu3ejci622/H5kkq4eYa19axMS1Mt3w57j00hGevr8f7o1+YanwaJR7HNZqb0U8+H8bhxISurRxj+/cjzdayZWjXyeCvnSixgLk/STpDuLIS4Mz550/fyRSZDuqxqiONnVgMP11dAJBEYKAalWduLq5bWoqJ0dkJA21sDAbdJZdobjgKdw1WrcKuRVkZDNTcXBhQ0SiACSYpZkjrT38Kxcjw0o4OsKIKCtBegloEtIaGoIBmSiV99VWcv3Ej8rWI4PmNlV/XrEEYrd2Oic5qP93d6Id3vxsG+quvpndSFi9WBZiTo5V9nnoKzxIOawgt86a89hoAjUOHcMyhQ+iDigoAHA6HhnJUVWXHYBgY0OIfc8lDN1Nwbz5ZT888g2cIheDkcGd9xQq8r6EhPNNnPoNj5gIIzjezkPN45068x/5+BciN5d39fuzKnQz5bmbjBBt3zjge+bx+PxgYfO7TjQZuydylpkbD68JhDWsTwfzMzYVesIqDHB9JlnuNVdqHhqZv0h0PmemaQmepsDAxfwwlWbGsbEKnzJIJAMzLQx8ZjXyzDAxk1wcTE/gdCsFWYkg3C3UxzxJtpYIChE8xB+u6dYnsDoaAEhg0RlT4fOi7480MMI4tjwc2VVeXRhHk5wNMvOkmHP/DH2I9jcXUgW5sRLuZQuXxx7Gerlun48RaayyxZO6yf3/mVEKBAPRNNnakWe9GIgBy1q6deeGImVbwvugisH+fekqLKjocsMlZqK+xcfpmn5khno5R7vGAbUW2Lxn/vb3qdy5aBNLGU0+hbVu2aCirsU0NDfj+2DGAU4ODCnbSD2Ll7He+E7o0EEB/9vfjeYw55kSmb6xl24dbt+J3cTHaYVzzcnJgIzz7rDKaJyfxPYtQHjsmctttWK8uvjj52mhcW4eGALr5/eiT3buxvk1O4t0RPG1sBNbANDyZJB5H31RW6qZvLIZr8Tfzy4XDINsMDoK5eLrYmhYw9yfJxFypqhL5+MeTO8lmUK+qCo4x492Hh/HZli1aJS1ZsnljLpHKSkyohgaRTZvwXX4+Bi4nFA3hSASTorYWg3p8HN/b7ZiQbjfasXMn/jdSjnt7cc/XXsO1WbSCwmSNTGScrcFoVDbMWUclkp+PnRFOdrsdn519Nr6nsdvTA2bW5Zenfzd2u1ZsbW7Gd52dUGITE/h/fFxj5aNR/D0yojsKIrie3Y7wjGgUIKnDgX654ALsGOzalRocXL8e4R5eL8YJn9vlwv/79on86EfJwV2jzJRWbhzDczWG29qw6+L1YiwwnNlYxGThQrA7A4Hs8hulu9d8MAuNYpzHXGBZ6Yk5Ah0OzMeTKd/NTJxgc34NJhgvLNQCF9QhOTmnHw3ckrnL5s0wjDo71Vgy7raHQgCCb7755JlDp5oQsP+P/8BuN8Eg7l6fCJnJmjKT8NvZrnEiMwcAk4nZAUolwWBi6DY3WVn1PRKB88C8RKWlWrWcjldrq7I7zKlORDSiIhRSYPF4MwPMm0G0NxsbwWphNVoRkY9+FM/g8aDtRhuR0Q2HDon88z+rnZppHT9RqT4sseStLgcPZgY84nGQFz74QZFbb009t5Lp3WPHNAqmsDB1PrZk+nSmFbxtNuSdDgbRRjLu7XaRp58G6JMuNQ6BmVREmnhcQzhpUzNXWk4OfBimUfrJTwAQtbcDqGtogO6OxzX/+OQkdB9TRU1Owm9kOgNW3Y5GoUdra9F/q1fjmUdHcb5xjTMzGLPtwx07QCQR0XWELMCqKrTFuGHEjXmCh5EIGGif+5zIhz+MIhRm/cy2MD/rxERieO/wsEZP9PdrpduyMi2qmEm4uTUwoJFWxC24tsZiaAP73Bj1dDrIaQ3Mmem8LpfIu94F+mt/f/YMoGSgXlkZjJQDBzBxbrop0dhJ5YQbc4kMDAAl//3vEQNvBi5oCI+Oar4fljWemNCwWSZajMdhVBkpxw0NYIft24f/jaXujQwjMuh8PijwbHfPCwpUKRjDR5xOgInBICb3+Dju/afivn/uV2OC/mS7QWeeCWCipyeRZtzdjTZy96C0FIpqcFCVFxVETg7Ay4kJtIMG99CQAoV33glg1W5PTRU/5xwoe7cbDEFjItH8fFxn504o6oqK5MZrsqSmIiemyATvPT6O8UvGARmDBHzWrJl5fiOzzMUxyyTGsbJtG3ZcfD7cY9EigA4nY76bbPvRvMPGHJV09owMjNLSuVfmteT0FOoe6gFjxfKcHOiEk20OnYoSDCq7vKQEc727G/pzPiuBzxUsyTb81lgsazZr3HxUIqcNlMnhjUaxbtvtmuiaIDVtBkYmME1CezvW91Wr0J8FBdrekpLpqU54ntN5/EOUjZLtZlBJiba/qirxe9o/rDxbWws7L906btyQm5xE/zU0oAq60Ua2xBJL4N9lI08+ifmZChBP5VuUl+NnZATphjZvTizOkE6fzkYXt7QgzQB1wOAgjrnkEujFbFLjpGKU9/So/iVgVVWlOeMHB+G/HjyI70tKsKmwdy8+LytTXe9w4ByvF/fjPdiXfX3QXWRLh0KJG+KrVsH3WLQIvrwRT7jqKviELADhcqXvw1AIkUx+P56tsHA6YcLvR/smJ/EcBOV6etQ3YJ78l17S/H/GsULQcs+exMq5IsrQm5hAO30+PB83lIqK0Gd+P45Ptr5y7bTZ0HeTk/icRSKLivB5MKggn8sF0svQ0OkT9XPaAnNG42BwUEMbqqs179kll4CemipPCSUWwyRLBupdcEFyECCVE87P29oQTujxqGEUjQLYocGzYgWUy4svanEFVrjxeKBo8/IwcUpKYDQZQTkR/N3SguMZztDYiGsxmXFlJe7rcmH3nnH06XZFjQrbDByIwBg1TlwCf0Yx77YYDUmfD5/7/SL/+Z9gcfG5fD4o09JSTPD+fn2Hk5N4v34/7p2fDwVAAzEc1rxKzENWXY1+2LkT/VdfDyVhBm5ZEnpwEOeXlMBI9fmwWMTjaBNBvWTG60yp4fMpvPeKFXjHRueBITceD8BmYxGSmcqJAB+TjZWiovRMxRMlc3WAzTtsZmfPyMA4EfmoLDn1ZOtWLYjDDZR4HHqQ4f6hEI7bsuXNbu2pKdSTQ0PKJqcUF89cT6bTO7NhLye7Xjb5Mo3Fsmazxs1H/r23vx3OTSYWMdlwRmYeHQuHA9fw+3WDr78fdldpKd5bdbUmGO/qQnuNqU6KinB+eTnsiRPN5M5mM6ipCe/k1Vcx7ynMFzQ5ic9ZgIOgZLLxadyQc7vxe2AA137iCWxMf+pTFuBviSWU6ursjnO7E/1D8xxK5VuEw9DRQ0P48fsTK6Km06ez1cXJNgUaGhCK+cgjYPExkioVMSYZo3xqCv5cfb0ex7xz8Tief2IC7WFIaCikmyNMNTA5iXsz9ZHDARa03Y5+tts12oqgVEVF4oY4yT4f/ShsdD5nIIBCQFxrXS7owMHB5GGvXV2aRqGmButLYWEiYaKtTTflSYKhfp6aQpuZd9vhwPN7vdP1c1MTcILnn8dmoLktZB56PHiOSATPVF2Nfurt1eq8BN+MYiwwRGHBJlZi5znc7GG+1mDw9In6OS2BObNxMDgIlhDplWQ3vfwy2E033phYcSWdQetyYWBv2YJ8G7MBAWiQHzmCAdzaqgqithbteOghkS9+EYZwZyd+vF58T+VRXAzlNTaGxMh9fcnpsiyE8PTTuE9Hh7LbIhHE4U9NYfItWICJnIndZFTYLS2JwIGIVlFlhbJs8gqIKLj2+OPoc1KReQ2+p6kpPEMopEklGXYSj0MRxOPoUyZ1ppLlLji/r6pCnzInwrp1eOZAIHE8HDmC8TM+jn4y5jUjPZdOTyoQaqbU8PkUY4jQypXYqevpwVjKy8OzDA/ju7k4DycKfDwZCxrMR/iueZcyJyfR2XO58OyhEMbXbAtxWHL6ysAA9B0T1FOXud0wevPyYDxnm6vLkpnLfOrJdHpHZObs5XTXy5TnyFgsK5lkWuNmWjAnGYC4eDGSpf/+9+n7LRLRFBdMI8Kq8hMT6tTl5mJuFBVhnkxOYm5UV8OOZOgRw5o2bkQ/dHdrSNKGDceXyT3bDSGbDQyPJ56AvVVRoZs/w8Owl2m7cXM1VaV6bshVVQGM8/lwPqvcPvUUxgarvFpiyeku5gqmqaSrC/Yg/UPzhk0y38LjwTwUgZ4OBvF3T4/mY1u8OLn9SH2yejX0cKaQTbMY7fO2NrCoCZwFAjj30ktFPvQh6MhUYmSU5+TgeUZGEC3DXMsi0DX9/egj+jPt7fib6TlIZuGGSywG39nlwrH0SZmHnbn/KitxzPh4YmqkvLzEQj5tbdOru46Pw5bq6cG6cdZZuD/7MBTCuxWBXzsyokUJS0pw38OHgTnU1akfL6I2nIgSavLz8TuZ/WCz4ToPPoh7iCQW6PD70bZIRFmVfr/69qtXo31HjijjzWbT9ZNpIcxCMI4VXllcIxzGuH3tNY0SPB3ktAPmjMZBSwsoncEgBllPj1b0XLQIk/jxx2FY1dVhgLPE8ubNmDj/+78Y8MYy0R0duM7y5bMD5V5+WeQPf0ACSSoHVsMbGgJNdetWDfH87GfRrt/+FucUFQGga2rC5Fi4EIZVpsqmmzeLXHYZKNF//KMaxpxIfj+ozsxDkKliD43ntjY4cyMjQNRF0IYlSxA3HwxqmWvmoUu122IOgSQVefdu/LACz8gIfhuVAoExMj9EEkOz+H8ohPOcTrx35oYZG4NRun+/Vo5LJkYnimHFLpfSdo3HmZWjGXSJx5WGTQWbbVjiTA1x471F0H/j41DIIhoqbS5CMlN5M8HH+ZLZODnzFb6bbJeSeS3b2rBIMzH3bCvzWnJ6CxP8EnRhZcpIBDqcbGBj6gFL5leMetK8DpSUZK8n0+mdzk6835mwl7PRY+nyHM1HKGq2BXPSAYjvex+AoEzV5IaGMNbz8zHeYzF1mKJR9FlurrIt8vLwrMwxW1oK0KmwEOs9IwcWL8aG6Pnnz34TN1uZ64ZQsqTtfI76eg2xMtpT5vFJoLmhAcnZOzvx+eio2ls5Ofj8eKXrsMSSt5rY7VqNOp1MTgLgKShQ/9C4YWPUu0VFmHfbt2NdaWiAz9TXB/3gcCj4c/PNmTdmWBznyBH1k7O1Pc1EmaEhbGq0tgKQ2b49OYs2GaOcfmNfH57TGFoaDMKfWbYM6ycjq6qrobf7+qCrcnOh1wmOsfJ2fT38azLCqPfz8/E987EztNXsvyaLFGJ6oNFRtO3QIejS2lq0i/7h2Bju73KhXb29uD6ru7IC+NKlCMvt7oYvTJbcxATaSqJJSQm+S2Y/rFuHIo1eL9o0Nqb+cnGxjp2qKmWyeTzo5y1bcHxpKWyBY8fQFw6Hkl7SCXP2kT2Xm4sfsskbGtKff6rIaQfMJStKUFwMRTA1pdW0SP/s7MQgnJqCAeX3i/ziFwC54nEcu2QJDLbiYmWpbd8ucu+9Ip/+NJSqmV2VTKjsXn4ZaH8wiAFK+qnDgck0MKCGugju9+1vowzyI49oQYR4XJXjihWZK5uedRZ2J157DW2sqIBSYtJfOmU7dgDAy7Rrbzaeq6s1dJVx/8yB9dJLUDilpaoozZXnkik2MjsmJzU3XEUFlDUr6ZSX43smrZyagjJjck8a0jk5uhtA+nNZGe5NqnO6IhiBAMaBx6MVeTmWmIugoCCRxms2Xo2gS1WVJi5lOE0shhDrTGGJ2Rri5jyLy5eLvPAC+m9iQne6g0E8d1ERFuu5yHw4Zm+WxGLI9fDoo1h4SLfPJuxrvsJ3UzFGnE6M9QULRK699vg7e5acmhKLwcAmME99RUN0agqfn3suNnMsOT5CPdnZqRXjmPumslKZi+n0ZCa989prcEguvDA7Vl62euyLX0zN4puPUFSR9DnSqKfvuw9jdcUKdbQIIK5fD51Jloj52UXw/d/+LTY3n3kGTk9np4YvsaIc0wbQSWOOnPFx3HfBAi1GVFgIJyqZfj4eRRHmY0MoWdJ2mw0hT52datc9+6wmJHc6E8cngebBQU1oz7Aw5hsaH8e5VhVxSyyBMJVOJmCOVS1DIc2rbBTq3eee0/xkvb1Y0+lD5eZqbnKywMwb6Kn0SWcnjk+l25JJMhbtxAT8rIoKkGNSsWiTMcqN0SM+H56PGyudndDPPD4U0rBPlwu2s8+H7wsLoZMOHsRx+fn4jGyzujq0nb7K4CCuReAoWaSKub0eD/x8Pu/ChQpqFRcjBPbVV3F+ebmmUOD3vb3oo9Wr8T7XrYO+vP12ka99DesoI8TcbujjsjLYDYOD+M7lmm4/NDVhk3/nThwbDqMPtm/XQpJkjRuLOY6PK6OuqgqA7r/8ixJZsl3HWEU3P18LXjJaq7MTG1qnupx2wFyyogRMiOhyQSkxr4jXi8/dblV0pIPynAULoDz8fgxmEQzE3l5UUPnDH3DdmhoM3lQOvFHZhcPK7GLFF+ZoI3LNWHaKzYYSyBddlNqwyxT+cdVVAAWffBLnNDQowu10avhCRwfAyrKyzLv2ZuOZSn7PHpFf/QoTfOlSPP/RozjOZoPyMleeMyu2wUGEogQCqiSN4cSHD6OdW7bg76EhzQ0jksicY+VB5upzuXSnxVwEI10i1OpqvGs6UgyZdbsV5DPm0jODUARddu/W91BejmuMjGAs9PUBsEtlTGdriCcD78rKcP3hYShl0pgjEfxfVgbwt6Vl9g7DfDlmJ1ra2pDP4re/hRFTWKjM1ExOzlzD0swO24oVyRkjxzscypJTXzo7sflSVITxxk0JbmTEYhhrH/hA+hATS+YmTU3Q/Y88gjXDWB2ttxfr5dVXp9eTmfRORQWYCcnCS0RSs57mEl4701DUdJIsXUFbG0Jxfv1rOBHl5bDbmAycAOL27WoDEMyjzUWwiDl+Dh+Gnbd/P+ZDWZnmJKLtwBDW4mJNiyGCtbSwEP8vXAg7ZN8+VD81PuPxqFI+nxtC5qTt/f3KnGtuhnNpTEheUQHAl+PTmFh8agrjmfck04QMfZfr5GbMW2LJiZJUkSVmsdngb+TnQ5ea54/NJrJ2rcjPfqbVSZmLzOOBbmhuhv/CkMnWVpFdu1THptMnDGlNptsoZjs2FlMW7e7d0wsOVFTgs2Qs2lSRN4we2bcPfvvBg3imLVvgU/b04JmNuc+dTujuggLoalYDzctDP/j9qutE0B63GyBRYyNALJIvhoeTswXNDHiG7fJ56cOuXIk14qmnoEvNOb9FNBe6z4fP3/Y21bNXXIGIvx/9SOSxxxJz3ongfU5N6b3oPxvfy9VXY93r7cW7YUEGEpayqSy+YYPI//wP2PNtbZrr2zwmOS6MQiBRBO+DocUHDljA3CkpyYoShEJappf5yJgMkxM4EtFywPE4BkowCMXGpPg7dmCwTk6q0UZDOicHyiGZA29UdpWVKObAHUiGBlB5RCKKKBMkMwJeZOatXj1dMaYL/1izBgkpn35adxaYs4BJHFlddHwcbS0rSwSWstntJeD3i1+g31evxrViMSiPujr0cXn59MpzRsXm8aCfvF5VDpGI7hYxyb8I2s1QZeZMIgukpER3FQi6ieA3cy74/VAUK1bgGtkkQiW7MhjEgsPEpHV16NPRUd19Pv/8xOutWAHAJz8f/TU+rgk7V6zAs6cypiMRkR/+EI4EY/JZuMFoiMdi03MdkPrN/H+kfjscaDd3wee6m53KMRsfh+ItKgI1/WSStjaRu+/GmBPBs0ciYGyOjYls2pT+vcwkfNc8j8zJYo0OW7qQMUssmY2w2hZ3k5lzk0Jm5saNb14bTydhaIfRJuBnmSST3mFuMAIpZjFvHM02DUGyjYWbbxb58Y+h12IxjKm5ht5zU+rYMbRzwQKsu0ePQj9v2aIhQrt3Y21jmgsR7VOGqNKB2rRJK8o5HFq9ne/E6cR9mHycYa7RKBw7shMCgeTg5fGqUj4bIDWdHceN1o4OrIeTk2jn5KTmQS4qwhiw27HZa04s/swzmtuX3zH6pLgY/VVXd3Iy5i2x5ETL+Hh2un5yUjfPCgunz59YDDqvoQG+aF+f6iwC4yzKx3QJ/f2IZiLQNpeNmWQbD6WlIFiUlED3MZURhYBPRcX066aLvKmqAoOsrAypd1auhP5pb4eeZSVX+pmMhqqogP/D+9bUQJexMndlJe7Z16fRUCIiH/4w1oiamtR2uLG9sdj05+UGqDH/WyyG5yULkCw4sv2IQaxZk3i/1auRs+9d7wJrvL8fPicBvXAYfS8Cdl1tLXxUo3/x7ndjvOzfDywkEtF+bW/PrrK4zYZ2PPAANsu83sTxQnzDLCSklJUl+uGni5x2wFyyogTHjiUWBygogHEQiQAcYflkViAJhxWgY3ikw6G5nRoa4NjEYhjwDAft7gYI09aW6MBT2bndUILGAchBy3BIEQxopxOMs1/+MrGqbCZmXrLwj0BAQZriYo3rZiJLux3H0hClY2BkNwUCIt/4xnTwYO1andz8vKYGAMySJWgTdw5YMMHtxr3r64HYs6+o2MbHcU4ggP5jOAkr1zocCqjW1kIxi4DtVFaGz4nG05gcG8M7+uAHEd7zu9/B+CQrqrFR4+jTJTM15tVraMDxS5cC0GGo7Asv6G6z241dHCMDrrMTSvKSSzTnHRdKLprJFr+2NoByDzyAPhgY0LASKtCGBixKw8PJd72amvC+Skvx7uhQ8N4sST7X3WwzSNzWpmM4FkOo+Kuvzo0tMF9C4JxszooKzAm7XasitbdjcUxllGQbvjswgDBZY+6Ovj6M29Wr589hs8SSVDI2hjVleDh1ot7TqULWmyVcB7ZsUQY2wyHr6qDLh4bSb5Jk0jsOBwxgrxe77JnYy7NJQ5DMISsvx3dDQwrQ1NYCyJkPdlhTE2yMwUGtuD40hPZddhnuz83OqanEPLO8FplzxcU43+vFcWVlGt5ERkVuLs6ZmsJ3vCaThBP827cPm07G+XM8q5RnAlLdbvTTjh34P90mEN8Lw5JGRgDOh0I43jg+Fy6E7WG8LxOLP/CA2tCFhRp+l5sL23VwEPbWycaYt8SSN0MY6UOSRyqJRpWBtXjx9GJ6HR1gCdfUQIedcQbCWo8cUWKF348fsuUbGmB/co2Z7cZMqo2H/ftxf5JOWHSQki6FUKbIm54e6NpLL03cWDD6HSxsZbfjGm43osaOHMEawVBeMtoIYJ51Fvr7zDPBIm5uVtZ1ZyeYhmaAztjeiorE5zVGZTH/G9fFQADvdNkypA5gHnzm8SwrQy78JUsS105G0dXViXzucwD2GKLLqrvxOCKz8vNxbDQKAO/FF/Ecn/40QEefT+SnP8UGF33JbCuLt7SI/MM/QPdfcQWex7zZaJbxcazbfj/GoM+H65uj6E5VOe2AuWRFCYaHYWTQqAwE8D8NLSbu5cRkIkm7HQPR4YAC4YQZHsY5RuVVXAylxIFmdODHxjAImWyR4YPGnVwRnajM+XX4MBQwq8oybj0VM8/YB8bd0W98Q43C0VEtE11UhH4gOs9J5HAAWAqFYHytWZOcffXcc6BNNzQkggq7dqHtjNM37xw4neinoSG8j9dew6LCnYMXX9QcbgMDUCa5uWgjFWkkgmfJycFkbm4G3fj116fv9sTjAADPOw859s47D4vWyy/jGgzXMubrI1Mx2Y5yMlbi1VfjebZu1R2tZctwbk9PcmZgYaGG2hol2eLHhe/wYbS3ulrDXn0+rU5UUABDfHQU9zfvetGp6u/HzogxuXs8jutNTuKaxh3v2QhBYuYCstmS5wJ6s8EnAucE8Y3GA9mIDItPBVhkE77b0IDwq6EhjFG3G0VYenu1ajDzWM7VYbPEklSSnw/9kCq8kcZbfv6JbNXpJ1wHVqzA+mUu/hCNQpenA0izcV4uvBA6nexltxv6v6sL64iZ9TSTNATJHLLOToTn5uTAWOfGXkcH7IjZ6ns6ngUFsIlGRjSNRF4e+s7rxcbYmWfqBovNphuuzC/LSAoR5JXbuVOZCiMjmpuOleUZFUHbkBEYjMIoLARYFQgglHPxYgUvj2eV8nRAqseDdCt9fdjQ+8lPst8EMjroxcVavIvjs6AAIWTJEouvWYNnYf5mpxP9U1KCvszPTx0KZ4klp5tUV2vUltEPMwujfqqrkfvVXDTv3nsBwBcUwIZlnlKmJorHoauOHoXeKiuDzjLatLPZmEm38bBxo+q/vLzE8MhMKYRmmxLBTE4ZGECut/Z2+O6LFuGezDFXUAByRX09/ub6Sx+VGxWZUhEY23vsGK7P4o7MM7dyJfonEAAQVVuL99PSosxChpYyH96WLdPJPkYpKIAf19gIXcv2i8CXttmwtr36Ku7LfOaMnPu3f9PiPHffDX+8ogL3OnpUMZB0lcW5KdPUhLYa2f+pxnI4jGceHQVR5IorTp+co6cdMCcyHTypqcFE6u/XnGqs6MkdChpeDHVl/Hk0mujAjI8rqOdwYFK53RjIU1OJlWeYI66oSIs6lJRomG2yCiYE6jhwu7o0ZEMkkZm3bx/izD/yEQ3tNE9as1FYWorBTyXFHCrGneVYDJPzPe9BOMrDD09XukVFON7ng3KhQo3FYMy2toKZtXbt9J0Snw/35i7uxITIXXeJ/M3fQLG98Qb6mLnXWC3QbocSIlBqBDWzUeJr1mjJbuaqW7oUCoXJTNvbkzMD3/teVfaRCAA+EQ0tbmgQufNO3c1nGW3uGhhBlpkufuZKwwQrXS5ldBFYIsswFku+61VSgvd16FBiUmyPB208cADj99/+DcDr+943d9Ds1VfRB6ysJHJygU8Ezt1ujOmxMbTPCCSPjWHcpso/mGn8saLd0JDOI1ZqamjAAm6sMDVXh82SN1++973vybe+9S3p7++XdevWyT333CObNm1KefyvfvUr+cd//Efp6OiQZcuWyZ133imXX375vLervT2xQE0yCYdx3IYN8357S/4k5nWAoSeUbIrkZLPukVH+m9/AQTlyBN8XFMAwf/hhXMfsXGRyhpI5ZATvyFTo7obumqu+b2sT+f73YTO43bAPgkHoZrILXC4FlV9+WeQd74ANEQ6rHUemAoWhYYxWYFqPcBg/NTW4xsgI1gbmbGLxLQKDTU3oJ5tN7TM6zsezSnkqIJWJx/v74XyvX4/CDdluApnHJm1HSqq1kInFc3Ox+XngANY2mw19lZenuZItscQSzLm6OoAgqYAMRuO4XDjWCEgZw/vdbsxJmw0gPHOsG6/LQjaRCIgEJSXwKdaswfxdvhz6M5kfkyw/dLqNB5sNNsTLL2tl19pa6NJsUghlW53bLEZyypo103OzNzQgx9u//zuet7x8etuNejnbVARs7/e/r1XRWdm1shLXNfbjVVdhs2r7duhm6loCeVyT0/kCzP3W3KzrEtluvb3or+5u6P3qamVmer1g4r373dDJIhrG29qK/8vK8N1VV2Uu+NHdDVZfZyf6JtVYFknEOUIhHH/hhafPZs1pCcyJTEfN8/NRQeSFFzAomAxTREEjIts0uJxODJTRUc1TNzmpoa1uN67BaiU5OTAcaQT+9Ke4xooVmFivvgq0nlW9klE96ZS7XDBqyspgHBoBDa8XgGBfH3Z6W1vh+CcLbzUnpPT5MIFZ1dRopDLvWk0NgLO+PrQjmdJlKeqSEiimPXvQT0NDmPThMIy9mprERJKs7pObi3MZYnLokLLKbroJOxk+n/YHQ2Dtdq0wVFYGRRMI6DtPl2Pv8cfR5oYGZdy1tqKPGG6aSvnu2qVVfMNhKNmNGwFcNTfjfbS34x2YwTYzyGIOt/b7dSe6uHj64mdc+IqKcG9j/H9RERTwoUNwIFavhkGeDPjLyVEWH3dMJifB3OrrQ//m5eF+Bw/ivX75y7MH5+aLLXA8qtlRBgYUqBwdxf9lZcpADIfRL0NDIhdckDoEJ934O/tsMBaM/UCmqtOp85qJXEXm5rBZ8ubKL3/5S7nlllvk3nvvlXPOOUfuuusuueyyy6S9vV2qq6unHf/yyy/LddddJ3fccYdcccUVcv/998t73vMe2blzp5xxxhnz2rZXXsn+uA9/eF5vbYlB5rN6aTbOSyyG9a6uDnqI+V5TOReZrpdMt9MuKC3FMxh12mw3G4yOJ6tTc7MvFML6ST3NfGg5OVi7CJx5PIl5FCmsFsr8e5GIblbyeZgzNi8Pzz4ygvWgrw/3IfuZeXIcDgBzXJ+OZ5XyZECq243Nzf5+2F/r1+MeM9kEmu3YNLbH60Vl50gE/Tg0hONvuun0ccAssSSTNDfD/zh4MPUxDgd0HJlF4TDCHkdHRf7f/8N8W7RIq3zTr2K+M+pK5i+32fA/gfp779UIrtdeg1/5yisAA+vrsVawWmd/v8gnP6k+bF4efNXCQqwnDE8dGoIfGYtBJ9XXaxHAoiIAdGVlIHAUF+P7Xbtg7/r9mpucaQcIntXVQSfZ7eiDwUE8g9uN+zHUd9curF319fCJHn8c619lJfpw8WL0KX3dQEBzmhcUaHqD3/4W9xgcRLtZIIghsgcP4j38zd+AydjVhc/y8zXaq6oK93joIe2LoiJEExUWQjcPDOCHFVHjcZAj6uuxPrW3i/z3f+vmCTc6XnkFa92hQ/CpJyfxrnw+jbQjI459yoqoAwMo4HDsGFJBjY+jfxwOjQw8dAh9kqzC+KFD2Ng7dgzvbM8eHJMujDWZBAIi//RPIMqsXj2bWfTWktMWmBNJRM1ZdXXVKhgVTNzPCqyxmLLlyIbjzqLLhckUCGjOMlboKipSJcQJxXjsN94Q+ed/Rvz1FVcgtxSrvZCxZ8zpJqL50YqLMTF8PkxMCifXjh3azgUL8Pezz8I4u+02Hdw0Cjs7NY8NQ/IYjkHQq6RE84a4XJh0L72UfLe3vx8/7IeBAd3N4cQ+cgRKvqoKE7y4GAAWY+DjcSjhujqAXKTr/v3fi7z//djRcDjQxslJHDs2pmDG1JTm31uzBu1KlmOvoQFMOZbs3r1b+4GU3rw8fGfe/Y/FoKxefFGTqNpseNa9exW4Yp9msyturMz64IOJDoPdjp1m446YEVzNydFEoVwoR0c1XLu4GCGsFRVYIJIZ1RMT2CWprMQis3UrFo38fIy14mIN8X71VYShku48U5kPtsDxqGZnvPavf43njUTgZHV3K5uUjgwXpkzVBJONv6YmGATmfjBXjeLOFyWTw3Y8wUpL5ibf/va35cYbb5SPf/zjIiJy7733yuOPPy4//OEP5dZbb512/N133y3vete75O///u9FRORrX/ua/OEPf5Dvfve7cu+9985r29rb5/c4S2Yn81m9NJXeMVZFe/hh2C/nnpuZuZzpeiLJdTs3G7jZadZpM91sMLLymO/s6FFtO68zMYF1mkmlaYv09uqmqd2eyB7hGs/2MW1BTg50ciyGdcBuB7i1ZAnuMTgIfb1qFc6bnIT9x3x+lZVgF1COd5VyM5B64ADWczLlqqpgI81kE2guY9PcHq7ZF1xgVRS35OSSk4HVTqII2brJhEVnYjGRr39ddQ6JJCKYp9mIOYVFZyf0xe9/r+H+bMfoKPQCdRb9zGTy2mvwI+kTmitxHjkCHZqfr2zqXbs0fPell1T3GtnNycgrRqZ0NKrRXkxFZazAbWZJiyBkk5W3Wbgvlezdq+kPeC+z7N4t8sQTANlGRvS9sN/6+hKf49AhgG6pZHBQ/yZ7TQRriDF/m/m50sn+/Yn/E7D76U9BGkglx46BfX3ttcAyWlrgN916K3z0ycmZgXDJhEWYvv51kS996dRfI05rYI7C+Hvm/yKCz0nLSUdkOxLBRKJBwTwb3d243tSUosIMg6Oy6O/HNQmAHDiAHcING3Ct3l6N9xdRgzEnBwqrqQmTkgyzqSkYg4wZD4UUBS8vV9ZXIIBj29uh5L/9bYBzTU047pFHcL3S0sQkozk5UFDNzWgfFUlBAYy3iYnpu70eD+4ZCilISWXo8eAzt1vDb4NBKPyjR3EdhwN9GY/D4F+3LpGu290NYI5AYiiEZxgbU+O5qQn9EIkAWKmvT0xebNyN7+jQ4huvvqo0YSOl94EHdGeFz7h/P9rQ0YH222zoF5ba9niwmNx3H5JoznZX3Giom1llIok77iyBvnQp3nVnpxbwWLQIO2+9vZr/Jl1404oV2HF6+WX0R329LpouF9iIvb1YiDs6ZlfGeq5sgeNVzU5Enb6hIZQj59iorcX9Rkcxf+vqUKjjppuyu5d5/Ikk7wcC4X19CvAb82+kc9iOJ1hpydwkHA7Ljh075LbbbvvzZzabTS6++GJ5JQVd7ZVXXpFbbrkl4bPLLrtMHnrooXlvn9s9v8dZMnuZbahOMkmmdyizYS6nu55Icp1m3Gygo0SdJjJzdpix3TYbdJzHA53NCnTBIGyuvDy0Nz8fnzU1wamgY8lCDca0JSKaVJ1OZTyO6yxbhnt96lNIF2KzYR286y44Vhs3apJs2kI9PbD1jDp7PgHYVGIEUnfsQE65M8/U/Lmz2QSay9jMBti1xJI3U04WVvvWrVpMMJ2waKDPp+H58yWs3koxkkZSVdY0C0kMqWR8HDmylyzR3ObMdx4Ow6cygobp8pMZdZdRMqXoMLZ1aCi7Y9nPqXLysk2jo/ihmCuCz4dk+y6yvVa2YygUQjHKoSGR//N/kLZp69b0fTJTYZGhNzu10YmQ0waYS8UeoWPf0aEGWWEhlICIFmJgPrjyct1hrKjQxJzM3VVSgnuEwzBSqAjy8jQMgtW8XC4tYd3VBUMpJweOOBUL85UUFAD4cLtx/eFhtCUQ0HAKEVUmFRUwGlmkgkBTXh6e+R/+QeSv/gpMMgJnRnopdxZycvQ8o8EeCODz1auhRLnbK4LJE40C0PN6tXqMwwED1+tFHzQ2gv3V1QXw7Uc/0t0JgqGTk2CdsXQyd23XrEE1nLw8UJAPHsQ9y8vxEwyiTzZtQj+km8zG4husasRnjUTQHo8Hzzk+DtBxfFyrGEUiel3mHmS124kJAFd/+7fZ74oTEIpGEQprDmU1J/rkjvtzz6GtDBceHtYqck1NIu98py6odAAqKwHgJTOq29pEfvxjgMkul+aoIGuSoO3AAACq2QBzc2ELHM9qdiKJTl9xMXLj7NgBXcH8jzYbxu4nPzk3wCtZPxjZjz09YDgUFGjZ9FQO2/EEKy2Zu3i9XolGo1JjrKwiIjU1NbLfvG35J+nv7096fH9/f8r7hEIhCRksVH+W9eazrXx1ulTIerPlRIAYxyPPWTKdxs2G3l4NO+Km4mzYYeZ2V1UhJyzDjnJztbJ4QwPu5fHgvqWlOJ7MAjPLgP8zny/b6HYDdKuowPXe/nYFuBYvRsjSd76jldkLC5UBYq5YR5lPADaVGIHUhx/GGjbXTaC5jM1MwK4llryZcrKw2nt7YdNnAkkIfM032JNKZhqOmOlaItBJx47Bp2LqJIaFktByqojNNr/A1Zst4TBYkf/+7wh1ZsTZfAHETCW2b9+pn1f7tADmUrFHrr5aCxcsWwYDknlISJdlzjibDQbZxRdrrPTwMIwzgkg2m+bgystDdU+nE0wbJlhkaXgapuGw7hwPDCgQxlxpRiXLnQC7XdlyLhf+7+3FMU4n7uXz6bMagSabDZ+/+ip2YZYuBdBwxhlQ6ix5b7fDyCKbLRTCtUSU+bZ6NZ6xqkp3e4uLwehjFTSnM3H3glVrFy7EOygqwmfbtyuQxH5kaElPDwCRzZsTd21bWkRuvBHP/sQTOI+hrHV1eDanU3MXpJrMLL7R36+5bkQwDnp6tBAEjfQjR9D3jY0K4BpDggIBGLpkzg0OYgc9211xMvjIAjAn/a6vhwL8/e/Rh01NKKLxs5/hvTOBZ18f2mm3JxrLZEB4vWgTE7izeq0RsD58WMe0zYYxwmp0DBeei8yFLXA8q9mJJHdWIxGMl+pqrR7s882tmqBI6n5wOrV6YGUlAOh0DtvxBisteevIHXfcIV/96ldnfN6WLSLf+lZ2x1lyYuR4gxjHI89ZKp1WXw92PHV0NDp7dliydldXi1x2GfIF+3zYBMzNxRru8cCOY/U7hqYa2QFmhno8jvWutBSMh6YmvIu2tvlNSH6iWGTzuQkkYgFslpx6ciJY7dlunHk82QM4rCp9PGU+ATleT0RBnLEx6OhoFP6GwwH9fryf60TLqQTKiWBMjI8DlAsGlQQyX5KTAyxhePjUz6t9ygNz6dgj+/bhBS9ZAgDF6YThxYSMubkYYCz0UFgIx7eiAsBPfz/Q/cWLcazTqdWoyso091t+PnY8CG4ReAuFAL4x8WJHB4yxlSsBhk1MwKgVwSTu6kKyXiad7+zEdzQouQPc1YXvY7HEajKBAO4RDKL9ZMp5vWjDOeeAiUZ21sCAyB/+gD4aHdWqnh4PgKdPfxpK02iIvvIKjmX46+rVAAFDId35cLlgEFZVob9GRrQoRkHBdKSdYFVZGUIKaQi3tQEQGR1Fv5Ct6PWib/x+fW9ut7IejULgMy9Pn1FEE1MTeCss1IqcIniOoaFEKjfDnaem0HZzzppsDXYzIMSiHKxO09kJx+bf/x3PvXy5Fq2oqdGKv7EYnsduBzi4fLmOhclJ5Dj81reUwWmsLktw58wzAQaFQuiD3Fxce2xMd7NYbW62MltHZiYsj9nkWzOHCO/fjzm5YAH6MRhE37W0AByeK+CVqh8uvBBVjwoKMrf/eIOVlsxdKisrxW63y8DAQMLnAwMDUltbm/Sc2traGR0vInLbbbclOAp+v18aGxszto+gRTqjio68JaeGHK88Z6l02tVX47rDw2Bbz5Ydlqrd1dXIWfb885qrlvlqV66E7SGSaB8l05e0QRg1UVIC3drWljmP2mxAthMBcs3XJpAllpyqciJY7dlunFVVzS/zaK5yPFhrRj+KPhM3S3JzTwwD8ETLqfpMLIQ530AqGYasCn4qyykNzGVij7zyClhFa9YAuBgZSTTEeI38fIAuLOxQUgJjJhjEj8+njLpoFD8M9wsEFPlnmKyRuSSiTKTJSRiUNhsMIqcTQAB/22zIE3bkCNra1IS22+0Ay8rLRa65BjnB3ngD5zDJMuP3x8cVXIlGYYgVFADEam8HC4LtKi3FNZhb69gxDV/99KdRsIJCQ/TllxFfXl2NPuK9u7rQ7yyiUVsLxdvVpfkEysrUiCawxcScfj+en4aw8d22tABEJHCWk4MJzITLXV045+67UTiCBqaRSdnTg3dFQzUW04TILDHN8N5gUHPX8P2JKGuSY2BqCs9VWor/OzrQR7feOt1gF8H3Y2N4NwyPZly914v/R0b03Sxfjvfx8stg5J17Lox6Vr7bsUPDhIzJnD0enOP34z0tWJAY6vj+9ydWeW1uxtjw+xNzVzD/YmEhilQ0Ns7eeJ+NI5Mty2NgAIVVZppvzej0LVigVYYJWvj9GhJFluFcAa+5siaSVVkm0F5SYlVyPRnE6XTKhg0b5Omnn5b3vOc9IiISi8Xk6aeflptvvjnpOeeee648/fTT8nd/93d//uwPf/iDnHvuuSnv43K5xGVM4JWldHRkNr7jcRxnhbOeGnI885yl0mkic2eHpWu3xwN75n3vE3nsMc37ZrzH4KA6SOYQVv7tcGguYYa+ZgNWncxMsvnYBLLEEktmL9lunC1YoD5aJjGnJHorCNtqZCzzM/pelv45+cVY3ZUFH+YTnMvLwxhpaZl9IaS3ipzSwFwm9khjI4y1tjYADwz7czphpIXDWgjCuFtBtsDICAw77sBGozAQfb7EHcfNmxFqSWDD5dKEwmSQMTcAw0VFlI20bh2e5eBBgATRKAzdlhY1FMvK8ByvvCJy/fUAHLkTTcYZacEFBbh3KAQALzdXlZ+xEheZgn/7t2CqeTxgZG3erDlVjGKzIbT13HPRTvZVSwuefWICfUzAbt8+PHturl7P6YQxyGO5a+JyYZedhrDx3RYVAWDcu1fbPDmJ80pLNVfKq68CnPvsZ/G/kUnZ1IQ2HjmilWGnpgDKFhRocQenEz+RCPrP4ZiexJPgItl2w8MiX/wimJnnnDMdEDKHWpOteOQI/p+cBPBEFlw0qgmtKyrQ9t27FRQqLQUI09eHn4oKTeYcj+N+w8NwqhsaNKSHoY6PPop7Mo/chg3oG+ZhNFKUGxqQYydTHr9sZKaOTDYsj4YGFP8YGpp5vjWj09fWplWWg0H0hzEkaj4Br2T9kC3jL1WVZYcDOqmhYeYhaZbMv9xyyy1yww03yMaNG2XTpk1y1113SSAQ+HM+m+uvv17q6+vljjvuEBGRz372s/L2t79d/u3f/k3e/e53yy9+8QvZvn273HffffPetl/+MvvjLr103m9vyZskxzPPWSrdPh/AVTbtbmxMzPtWUAB7aMeO6euG0anNy0Pkw7//O65D9vSpAFZZBRgssSS5nAhWe7YbZ5s3Y0Phj3/MDLjl5p48zLrZCskP8Th8GRJiUhV0sOTkEJI0li2Drz2f45AFMOvrRW644dRfo05pYC5TqFttLb7btUuZcZGIsqRYWZU5wwjQiAAQW7MGgEhODsIg8/JE3vGO6TuOzNNx8KCGtBJ0stk0l5yRTWdk5BQWai66yUllQYlodVCGXR46hOM+8AGAhgR7gkEobbdbc+gRFMvNxbnd3WDVrVuXuFP+/vdnb5Qn28EuKwPLjkawywVg6KyzAKj8x38oA83hgBLmAhOJoB8XLEB+v2TvliF6fI/sKxH0rcuF58jJgRH6m9/gODOT8rzz8PeBA/jNCqeRCK5RXw9jPi9PGZBkJhEoYxlv7hbk56Pt0SjCT4PBREAoVaj1wADGS04OnBcmdrXZNPS0vR3jkEBLf78Cq8acMf396Fe7Hfc+fBjsypaW6fl0GhrAjBRRJlpVFfL1dXZqdV0R3HPtWi2AcqJDJDOxPCoq8B6Ghmafb41O3w9/iLk1OIj+N4dEzSYHU7YykwqrrLL86KPKkmN4dV8fwNWrrjr1d5xOdvngBz8oHo9Hbr/9dunv75f169fLE0888edQmM7OTrEZBuV5550n999/v3zpS1+Sf/iHf5Bly5bJQw89NKdqb6kkTT2JWR1nyVtH3qpgTaZ2JwPvyGh3OKbnmDMyTxYuhP1ysrLf5iInM6vPEkveLDlRrPZsxOEQ+dznYK+mW3OZSscYDjoTOVmYdsYK0X5/InHkVAz/PFXE5RI5+2yRd70LPsvo6PyNp9xcrFO33461+FSXUxqYSxXqxhCvoSE4ruPjWv00NxfGWjCohRhiMRznciVWqpqYQOjoddel30nt6ADTrKYGJYQJlBQUQPmQCSUCx7+qShNg1tSIbNsGoKamRquN9vdrsQi2r6gI5+/ahWe6+WaR//ovoNd1dXheYxXRaFRBrJoaOO6trcrEMu+UZ8vaSbWDfd11YIzV1Oj5nZ2as4/VLlnQQkSZauefn2hAmt9tQQEAwGAQIBcNbZsNfc1qtYsWodCECK5nBKaqqrRKLPPhBYMAOhiaHA6jb8NhADQNDZoLcGJCFxCnE8+xeDGA1XgcICorvD70EHYWUoVat7SAAUjQlGBqWZnmnGB4akkJQOZDhzS8Nh7HuUuWgB3GkE6OHxbtMEtBAa5dV4dnWrUK9zl8GM9VVqZlzAsLAR6aK+aeSEnHljj7bJGf/GTu+dZaWkT+RFySXbvwv7FIyFxyMKUSzrVdu8BMGhnB+6qpwXjOxPgzl7GfSVl7S06M3HzzzSmN/GeffXbaZ9dee61ce+21x7lV04vNzPU4S95a8lYFazK12wze7dwJe8xmUza5iG6qMZUGGfWWWGLJ6SMnE6v9iitEfvADkc9/Hja3EaDKyYHNW1GhRQunpuCPZFNgwOnEb6bgSSa5uZoiyGhHmjf20wFnLhd8D78f7TMfa7PB/3C7RTZtgr/S3q4FLegXJjt3viUnB/ZNJKL4QKbjHQ7tn2RiLGhofC82mxYXpP82GzH64nwXc7H3WfQym2q4paXY8L/2WpHnnlMyEUNaZyus3P6ud4nccsvpAcqJnOLAXLJQNzLMPB44uwQiyssxKQgMMYTR4QBgNTIC1pC5UtX73gfwJZt27NwJAGN0VCuyknXFogesilpbi/txl6S+HoNy1y5MlspKPIcIrs1qq8Zk9K2tIh/7GEIiJydVUbOqK5MpBoPKCguF8FNbi4mWLB9bNnm6st15b2rCsYODuK/Xq6AowbVFizApjeea363LpUqdYaS5uehvhwPXnpxEX5SUQHEkY1IWFGCBi0TQ/z09icUohofx3urqAJRMTkIBNjVpRdiWFoAmrMwqouGiQ0N4nrY2OAWpQq3DYbTR6QSNPRzWnHF5ebgnw1NzcnD/nh70N4HC/n4sKvn5KOJw9dV4NjIUk0kggOOvukrkgQcwhvr6cB8yr9xujEe3W+fTmjVzY4zNpjgDJdVYa23NvjhEJnE4RP7qr8Bu7O3VnJL9/ejr6mr02UyYJamemXONY8TjQd9yzFZW4nmThQ93dmKMXnCBhrKOjaH9CxbgvQ0NWcUfLEktmzaJ3H9/dsdZYslbSYzgXVcX1kdGLxglHtcUAOecc/IzBi2xxJL5lZON1X7FFQAonn8eERFDQyASrF6N9drjwWZzfr76qG43/KPiYth+zc3wgbZtg8+0ZQt8uM5OkUcegW+6fDmu3dYGf2HxYmxwDw7iepGIRo6JQEf6fLAvr7kG+vTwYfXjmpoQhXXWWYgw+973cM3RUdjfLHpYXAw/a3wcbT3zTDzbsWMiF10EgkkgAJ9u/37Y4YxgKirSHOChEPwkRlsVFSkBJRxGu/h/WRmeifnJi4rgb/3FX8AH/sY3QHgYHtY1gql8pqbwv9MJf/DKK9Hn+/YBLwgG8TxGckdeHvo2Jwf+o8uF87/zHQCRv/61yM9/jnsQGGTaJPq4ublo3+Ag/M9NmzAODh3CtViMb2AAub8J1IrAh+jqQrsmJzXnfH09+pbRUvTvbDb0S0uL5jmnn9PdrVFTb3sb2vjd72IcNjWp/9rdrXnZ7Xb0pc2GccbqrYwGq6xUoJjRfF/5Csbp6bQGn9LAnDnULT8fLCQWCKiuhqLavh2D9OyzNf8WWXVEncvKZl+piu0wgmys+MrQ1KoqKK1wGJOovX16SGVhIdrQ14fPuGvAvHXJktFfcAGU4v79GPwjI4lhujRAQyFMpmgUCvboUbCErr0WE302ebqMRnAqEML4jkTQ9qEhBQsXL05OXzW/2/p6KD+Gi+bk4J2RBk2gi7sf1dWJTEq+77Ex9L/TCeBvyRINFSbjsKAADL5FixKT63u9Ii+8gMWsp0cVDMXpxPXtdvwmgy0ZcER2Jq/d2Kg541wuPI/DoTstExMi7343+vl3v8P/xcVg5TU24n5PPAEWZUtL5up7F12EPv3hDwEok00ai+Fztrm4GIr4wAGMtdkwC2YK+iaTZGyJbItDZAsmGtl527bBwAkE0Bf5+SIPP4x2ZNPmVM+8dq3I449jLMViyvQMh/VefX0Yd6tXT2f8McR7xQotBGIs/hCN4l1ZxR8sSSVnngldZTS+zZKbi+MsseStKm43dGOmXDhW9WFLLDk95WRjtTscsM0vuijx88WL1Z7kRu5llyX3Ud/5TpEbb0z8bPlysPGSSUcHQLuBAdjKNhtsUa9Xc4HHYrA1V6wAASCVOJ3wR1jduroatmhFhZJLcnNhr+bkwBcdGwMI5XSKrF+vvvsLLwBIIlutpkavtWkTSCzhMEAsXnv3bvjAtG0KCqD/3W5cv7oaf//+9/A/h4cVYDNG0Bnz3fH5o1H42mvXwm4/eBDEnQceUOZfMIjUCCtXwpfftw/+1rJl6LuyMtjnoRDubcwPvXKlfv+Rj4AMYZRLLkn8n+QNo683MAD/obwcbWT/OhzAICYmcN/iYvjLBNQWLcI7Oess5Es3g2SxGEBMrxd+CSP9jHgDCTIuF54jEsF5tbU43uPB5yxAGYngWcvKTi9QTuQUB+ZE1Jl+8EGAS6xeWlWlk2NkBAOgoEDj2wl6kSG0dq3ITTclhmHOZLC0tADk2rVLQ0gdDlzH5RJ57TVMAuZXm5rSCpilpQCEXn0VCtTnw3PEYpqjLlUy+qIigHUvvIDfpDpzUoTDmDhut1YVzcnB5Dx8GO2123H8296mAMdM8nQlK25QW4sJuG4dziXg0damE7GlBYkeU9FXzWGMLpdShHNzE3cFCLBGo1op1RiqSfBtagoKKy8Px9XUYIz4fOjPF15AHy9apHRnCu/NvDXM40fhO2f/j4/rb2PeQBH8X1wMoMzpTMwZNziI84xFNCorRT75SfTF0qUYV3l5iVVE9+3DAnv11dlV32tpEfnoRxX4DAbxdyCQWCRleBhtm03VvlQ59rIpzpBJsikOMdPw05YWPHNrK+ZTYyN+T0xk3+ZUz7xzJ8C90lKwNJ58Eu+ZYbOc542NOLezE+/LCLKZwUhzuOHxzIVnyakhmzdD73V3pw5DcDim6yxLLHkrCau/pxM6N5ZYYoklJ6scz9ygtKNJHIlGNUen04n/8/Lga/3v/8JHpZ1sbk+ySCf6Sk6nkktoWwQCWlTRmHqoqgr+YyAAf2hkRPN5068vLISf2dsLm9nhwHHRKHzMTZvgJw4Ngb136BDus3Il7jU+DiIPo6/IxotGE0Np2cevvgq7vaoKx9fUABzdskXk619XRiP9BfptRr+pqAjgIPNjGzfVc3Lg/6Wy35P1tzkHN0Np+/txzXXrABr29aHdJSU4f3QUx/p8SjSpqkrt45kLbVZVoX+ffBLPQKYcQ5JDIby7nBxlEhYXa3qm0tLT21c55YE5ESiJ665DKOCaNQDmOND5PUPySkuhWAIBBbu2bMGAee215GhxtrJuHRB/VvYksPHQQ1rxcWxMGXrMRzY4iHO9XiDemzahmurQEI6ZmlKFZE5GX1KC9j/4oKLfExOqSONxTAgWm6iqwiSemMCEnJjAcTk5iYpHJLs8XWYQYmJCZM8exKH/8pfa7g9/WOQLX4AzOJOFhQvSM88oFXtkBH3CHHx2uzK8nE48a18f3vXWrfh7agp9wnx7ExPYNdmyRZUNwY6FC5OXgXY4MLYmJ9F3/f3oKwJjfj+ea9s2tOPRR8HwO3AAoGd1deL1uLD09Gh+t1WrMI5JJ+/sRNXU970PC9OBA+hPM0PM+K6uuy776nslJXiWwkK8q6IiBTHHxjB+q6oAWs8UQIvFUufYyxb0TSeZikOYF8Vs2/zww+j7c8+deZsjEbAQDx9GfxUVaZhzfT10DEMD/H7VEWRHTkzg3swzWVaWuHAdDzDSktNLenvBFB4YSM2ai0ah13/wg9NvN9OSU0Pa2zPnv4nHcdyVV56YNlliiSWWzEYYNUKAprUVtmFDw8z9KvN1P/Yx+Gzd3ZqGiZE7Tid8j+ZmAC4PPaR2crIomGSRTt3dmned5BLaq42NCgQODChQVV0N4Ou55+BDrFwJm5eg1+LFiCLavRvtGBjAd0uWqK+ydy987P5+tN3pVOJBSQmiArq7YbfTdzTmbmMxvupqXHv/fvhLRjvbZhP50pfU30oXdTdb+z1d1JHR15ucxHdTU8ARqqsV8CPhY+lSPH9Pj7L1NmxIHyGYrNAmw2qdTvSxzQbAsqQEfTg1hfb09WHsMKKM+V5PZ1/ltADmYjEAFoEAwIV4HIOQE7yqCoy4ri4M0pERDMjmZgW78vLmVnUyFsNPeTkm5sKFUArHjmkxCOaec7uVNutyYfD6/Yoor1kDOvLQEBykSy6Bg85JHIvBmFy2DH+vWYMYdIbHjY8nxnxzJ4B5xyYm8MwM7xTR4hH796OtVMzp8nSZgRevF2HDIyO4n88HZblrl8hjj4lcfrnIbbdNp+hmkvZ20IVJox0fR5/19ChNmaxAgpA2G0CvoSG0o6AA7SVQGI8jl8Pu3eiP/HyEry5fjusyQTQlHsfnF16Iex89in4aHEwEQXt7NW9cUxPu+8IL2FkgCBgIYCxWVsIh4Bjp6UG/1ddPv79I5irExne1Zk32OQCNC0VVlTIIg0Gcv2XLdGp9NmLeZTHKTIozpJN0xSHSLTSpQq87O9Gm4uJEHcIqfuna3NYGUO6BBzA2BgaUol5VlRiSzjwUhYVqKNjteP+RCMbj2Nj0xOTHA4y05PSSsTGMr3ThrJGIyB//iDCXTDlWLbHkZBSmuUgnLKJkiSWWWHKyirFY2IsvKtDE3Nr5+bAtZ5MmRgR+1e23A2A6eBC2AckMTif8z5Ur8ffWrQAFQ6HUUTDmSCcSKFatwrWMedzXroUv1tqqIZG0m6urARrt2YNrJAO9Lr9cfY377oPvHQ6DIMGc8iIaYfXGG/DTq6vh99bWwjcXwfEEmNxuDWGNRmGr9/bCx124MNHOzpbRaLTfW1vhZzDKisSZq65KvE4ggNxu6aKObr1Vz2EuO49Hw0pXrULEDtmEZCSefz5IQZnA3GRpg+irMA87/VISDQoLdXyyLSzElIxNeDrJKQ/MEUnevh2Tl/myjInUWTyhpATMJbc70eEWUVBjZAQKY2AAg3fBAmW7pRq8RjR7cBC/t27FOcxDZqx0Q5os88sNDWk8eDiMv3t6wL4LBBTcqK3FRNy5E8fFYkicuHw5Qi9zcwEIDQxokvi+Piib6mpcb/dufW7uIIhgguXmQlkw+T0nV2VlcrqpEXgRwd8jI1AwBPL4LiYmAM4Fg9mFDHMh8vlEfvpTTGyGvHZ0AMxi0k+3GwAF88DV1aFPOjtx74sv1iqqxnd+8cU45hOfwBhpagII+J3vpAY9broJ5xrzkBH4Y1jiBRcoO27RInxnBAGZoHRqCp8z9HfhQoyb3FwF9QIBLCTd3SLvf//McqplU30vFdCTk4NxuHAhvp+N8pwJkDgXmSnNP93u04ED6G8RXWCM4FqqNpM5evgwzqmuxiLIfHHnnJOYV5AOYUkJxsPEhILo0SgML7cbwK35OWYLRlpiiQjmB/OfphKGQ+zfbwFzllhiiSWWWPJmCO3VbdtA9mCam4YGEASGhwE0nXcebMbZpom54gr4JLfeqv5qfr6mhaqqwvdHjsDHShdR8sUvTgeLtm3T3Oq0V9esgV84NQW7t7ISz0e7edMm2CnXXivyoQ/BxzHb9/RzmprgG+/ciT4hAcXr1bRCubm49pNPgo1XVaVA3tq16N/iYk171dODezBF0sQECDF//dfT+zbbauctLWD6fec7aOvUFNq1bBkIOUYmosulkWGbN6fvb957zRqQO8z+wYc/jP6cTbquZEw/5j8fH1eSQU4O/mdIbX4+Pi8pAa5QXIznPd19lVMamDOGURYW4rPJSY1lJwNmdBQTrbxcw1zNwmSXn/kMBjIBFJcL1NjFi5PvRJhDOZuaMJGGh5WZQHZcfj7aFQhoTHs8jklTXY3vJibw/cKF+O7oUSiSQ4e0lHRREZRiUxOOZZ44hwODv6EBbe7rA/ATDotceinaS+XE0EsmaeztVcVTU6OAwbFj+D4QmN5nRuCFefEIMhDYY3LLkhIc88wz2PVYuhT9kapPqVRYPaiuDu3iIsEdo/x8zdc3NqZ5+MhEisfBJrTbp7e/sBBtYzUjkexBDwJBLCgxNoawr4ULp4+v6moo3P37odR27cK9Fy5U8O3oUVC2y8pSK2DmINy1a37DGI8X0DPfxRnSSbaLYrqcd7t3Y1Hx+zW8d2oqEVxzOqe32cgcbWnB/I9GoTuqqjSM/vzzNa9gRYUWelmwAON8eFjDWeNxbCJceGHy58gERs6lCq4lp7Y0NWEDIVP+rWAQetYSS96KwmiA+TrOEkssseRECu1Vjwf2pdMJm3J4GASFvDz4pl4v/KotW+aWJubMMwHeMBWTmczQ1wd72RwFw+irvDykayHT3ggWXXRRok3a0CDyzW/C9r3gApGXXoLvQWBsYEDkqadE3vEO+IiZNgiNRRgPH4aNPT6O60xNqR8aj2shv7e9TUNpJyZwXxITvF7NVed0op2BgMhnPzu3zcq2NhSAKy7Gs9ntmmfvu99Fv6xejXb09gLMLCnBGHA6E/PSJYvgISD27nfj+YqKcOxc/INUBA6XC31SWqopsJgrOx7HfUnOueACAKzZMPROdTllgTmzM/zSSwrSBAKadD8/HxNz4UIohu5uTAizUnn1VYBfDge+Z/XOUEjjys07EcnySbHS66pVmMhlZRiYo6NoSzCoFUntdkX1/+IvgJ4vW4YJ9eCDOH/JEii13l6AbNEolO+fKnonADcNDXD229sVXLnySihTrxfHsnQxQxWjUbTF48FvsgnDYUyu2lpMukcewTMaJ5MReCFllSGdjj+NvJwcnBOLKe11bAzXzc3VPr35Zkz0XbtEfvUrtI0FDg4exEK0bZvmwDvrrMQcfFwsuLNDFpvIzIGhbBhYZiBozx5lGJrF48H7OXIE7yYUApOupgbtMuYfM1d6ZR82NGAcXn893u18hzEej+SyJ1s+tHQ571paMOdEsOiyQpURXGtrA7C/YUNim43M0aIiBdyYf9CY9NSYsLahAQxTn0+rJjkc6P+8PJzzzW+mDktIBUbORxVcS05dsdmgfzJJPI5xb4klb0XxejMfQ/vEEkssseRkEqO9Wl8PP6i0VJlKjGwy25ilpbNPE9PUBBsxnc1eUACiBIUbz16vEjPuvns6q8xsr3Z04Dy3WyuVjo7iuUTgH7tc8O+yFWMRRuasC4fVL2PagkgE7aRN/+53w1f/zW9w/7IyPCP9SaYyOvvs2afdEUl8p6tXa/+ShOPzwT9gburcXPiEw8MA80pK4LMzkmfZMtj4jOBJZ/tznZuNf0Cw713vSgylrqrSAobhMNpPLIBSVATA9+Mft/wPyikLzBmdYb9fWXN+vxpb0aiGjI2NgaoaDk8HNTo78SOCSXHkiIaWieDcnTuRIHP/fk1++eMfT88nVVWliSQrKjBA168XeeUVOOG5uQp6kS13xhkAbBYuRKjkww+rMmb8dlGR5qY7cECTOooocDM0JPLpT+OzAwfwe/lyXOPhhzEhqVxFcO+yMlx/aEgLDgwNoS+pmJzO5EreCLwsWIB2GJUo+8Fm06IXTLAZiaB/Vq1C+OYtt6D/tm9H3zQ3a2nr/HxlG+7fj+MWL8a5R46gT41FHPiMGzagHW+8MXNgKFsGFiUVO8zjAaDo8SjY63AgZPjYMexorFiRmH+Mi6tRGEJZU3P8whhn+szZXG+2+dCOB+MrXc47vx/6gnNpbAzvrLhYdw4PH8Y4N7fZyBw1Vtfl+Q4H5mBbG4B2Y8La6mqMxWAQgPnUFECTNWsw5mcalnA8q+BacupIthVXQ6Hj2w5LLDkeEospc9+YRsQoOTnQ7Vu2nPj2WWKJJZakE6O9Ojmp0U4isFWZk5gpiZhYX2T2aWJsNpA5tm1DcbyGBoA/k5Ow2auqYJdOTMC2pX8zMQGbgvncDh6EHZrO3hwbQ+qnwUHYv8yTx+ILubl4ju7uzNcyCoswsm8KCmCDkxXHlDF5eWrT33QT/LDzzkOeuvFx+M6FhYn58Iy2/2x8lFQ+iM8Hm72kBHZ6Vxfat3s3sIVgEH3CQpDK/A0dAAC920lEQVQMyfV44C8UFcH2v/tu3KOiAr6iw5Fo+4vM3D8wA3lMvXTeebjPffcBrOvs1EihkhLNq19UJPKRj1h+h1FmBcx973vfk29961vS398v69atk3vuuUc2bdqU9Ngf/OAH8pOf/ET27t0rIiIbNmyQr3/96ymPny8xOsNeLwbsxAQGRnExJk04DMVSXAx0fvduMLMeegiVLwMBzUMXjwM57+rCdXJzMYFZpWVwEGAK84Cx2gvzSUUiAFo4OFnNZmwMANsll0CBcRfXZgPotGQJBnFLCyZ9fr4ed/CghoLm5aFd5eWJOyMUKuI9e9BOMxp+9dWg5MZiIr/9rQJ+/f1aEpu006IiAEYsOBGJJFfyRuClpwfn9fZqRRZW4YlG0Rb2KYEOETwLGX3l5ehnEQA5nZ1oBxlIRUWJz75yJfrc5cI7jkYTQZ/3vQ/X6u4+/onyk7HD4nHNu+fzaVLRwkK0dWwMLMiyMs0/Fgwmd4aN7L7m5uNXOn2+paUFc+7HP0ZfsEBKOiBxtoyvTAtlupx3xj4vLAQz01id1mbDGLv22ultMIOyVVWJ59OoWr9ed42YsJbh7t//PuZuSwvGNhftmYQlHO8quJacOtLYCP3MzatUkiwFgCWWnOzS2QldzygGs1A3LlliAXOWWGLJySdGe5X5jqem4Cc4HJoqKBLB8Q6H+lWzTRPz2GMAbtrasFm9Zw9CPletgg971VUgebz+OmzV/fs16ksEPvGCBch13taWaG+a7XNGs42PgwTS1YVn4aYhgcaVK+H/ZWu7kvX37LPok6IinFNfD9uYKWOS2fQXX5yYn623NznxYbY+SiofpL9f04YEg0j5xHfNtYrFK3p70cbKSs33t2CByBe+AIDMZoNfTFbdihV4L7/5Dd7BTPyDVBv9u3cj9VJdnZIKIhH873IBkPN6cZ3RUbTt29/WPPGnu8wYmPvlL38pt9xyi9x7771yzjnnyF133SWXXXaZtLe3SzUz2hvk2Wefleuuu07OO+88ycvLkzvvvFMuvfRSaW1tlfr6+nl5iGRidIYJaBDUIbpMpyISwfFdXZjgZkeETKaJCfxmhURWYnQ68d3Bg5h8nAzMJ8XQ0IkJ/Ijgs9paVZbLl8MIfOEFTKobbwRQZC4s8fDDAP2cTjjoublok8cDgMft1kSURmE46a9+hd8NDXju0VFM1l278CzMK1dQgH4aHsb5DGmNRjGpt28H/bSqKr2SN+YnC4dBxw2FNK48Jwfn5+SgL2w29B1j/ffv1yqro6P4nguR3w/g6m1vQ/8yTHhiAtfzeEAtrq3FcxiV6FVXaWXL979fE48er0T5ydhhU1NoE6vxNjRgvMRieK9FRXj2N97AgsD8Y+Zw1mTsvrmy205UDrK2Nozp/n7ck9Vyr7oqNSg3G8ZXNgtlupx3NGj4d2mpVqflztvUFJhsHR2J/ZYMlGV129FRtG39epGvf11DvI3vr6MDY/mMM6a3aybVa09EFVxLTg254AKMcWO4nzGsQgR6aGRE560llrxVZGwMejXVuI3Hoef/5m9UJ1tiiSWWnCxitFdLShJTpBgLidls8JWMftVs0sQ89hiKCPh8IJssXIj13+uF7b16NX5sNvy/fbsm9A+F0Abm+LbZEu3Nycnp9nl1Nf5mIUJWUCWpgTJT29WYa669HfcqLIRPmpeHPlm9Gm2dmgLDziiZ0vq0torccQfwBuaVn5jILiolmQ/CVEfMHZeXh78DAbSPvnMspmmm+vvxN/GAe+5B/9psYMqxqi7zY69ahfclgv7Lxj9ItdEfDMKP9nhwzDnnABvx+RL9vJISvONYDJjGF74g8rnPIaXY6W5Pztjk+Pa3vy033nijfPzjHxcRkXvvvVcef/xx+eEPfyi33nrrtON/9rOfJfz/n//5n/LAAw/I008/Lddff/0sm51ZjM5wZaWGgeXlaUglc+S43Voo4b778Hlzszr9O3fiN+m0dMKN+dGYD+7QIc1nVlqK49vbFYArLsZxoRBossuXa3GE7m4FspJN3FgMIFokospXBL8XLIDi6+nB30YgIR6HQiArrboaiLbXi2vZbFAixcWYFMeOYRIypLanJ7E6bSCACbZtG1h2Hk96JW9UZI89hgSWXV2aKysvD/eKx9G2lhbcb3QU1yZ7jwsPd4cIXHV2oh27duH7nh5QaAmumZVoIDC9sk1NDXbGm5pQeMJmw3EdHfMHSpmLKAwMoH8dDs3VNzamVWu462XOP9bTowDl8WD3zVcOskzgnhlka27WPv/ud6fPg9kyvrIF89LlvCsuVjC+qAhjkwtlVRXu0dAg8vOfY76b+y1VyG5vLwD5j388tQM4X9VrT1QVXEve+rJ4McC5Rx+dXgQiJwdzYdEirfBtAbmWvJWkrw8OFAttmfMU5ebCjrr88jenfZZYYokl6cRsrxpTpBQVwZ7Mz4eNWV4Ov6a7G+t1QQGO7+zMzr+JRGBD+3ywDXh8VRV8rSNHRL73PehL+jnf/z50LHOhGXOyiai9uWuXyBNPJGddjY/jWTweZYhFImp7FxTAdywvR3qmHTu0b8zPZPZHvvhF+L3M6+1wQOevXAl/at++macyam0FuNTergUqKitxzWyiUszvVAR+WCQCwszwsBZeLCpSspDTqYAlc8IT5Nu+Hf3CcGK2qaBA82N3dWnByWz9g2Qb/QMDyHU3MgIb8fBhZW263ejveFzHZyiEdzw2hnb+/d+DKPP+95/eoa0zAubC4bDs2LFDbrvttj9/ZrPZ5OKLL5ZXXnklq2tMTEzI1NSUlJeXz6ylMxSi4p2dYKExTNKIMOfnQwEQvd+7F8ecfXai03/BBVASfr8qhVgs8V4FBbhHV9f05JciivDb7Xr8xAQc5QMH0JZMLK3OTgBi9fUY4KWleA4mViwtxcQJBrWCazQKZcokmQUFKGTBScr8eqwyOziIZ2MFnclJZQg6HNpfFRUAJ154AdUkM4FCVGQ334xKM//2byIvv5wYBlhYCPYbFTd3SdjW4mK0ywxcDQ6inW436NR//ddQYkblTCXa1gbQh4vAxATo2M8/j2stXKhjg7sT2SS+TAdAmb//whewQO7fL/Ktb+G7khLNdxAIKIswHkcb9+3DwmrMP3Y82H3ZgFjZhMlmAvdmA7LNhvE10/uky3l3xhmYV7/5TSJYYbejD/r6cFyqfjPn/nO5AG6cfz7GWyrm0XxVrz2RVXAteWuLzSZyww2qo8NhHfPMv8IcMhaQa8lbSWIxbKCwCJjNpmlJGEnhdifXkZZYYoklJ4Mks1c3boQ/090NP2bVKt14ePll+GxMI3T4MEC2c87JvOm+dStIJ9XV021Umw0+28GDOG7LFlzr7/4O7XC7tYprbq5GO7E43wsvTLfPi4rg5+7Zg8+qqwH2jI9ruh/qZ4J4fX0otvjww9N9tlT+yM03i/zyl7BjGhrgt9PfminZoa0NUS/t7fCPCwsTWWnnnJOZ2Wd+p0VF8G/JfiThJhLRkGUWsWxuhp3W24vPy8r0fcfj6k+Oj+Na9fXwU4qLgSssXIh3lck/KCgAeWLHDrxDApft7SJ//CPAQ2MOf4J5BP6Ysml0FEAeC1jU1qJdL7+Mc07nfNczAua8Xq9Eo1GpYcnPP0lNTY3s378/q2t88YtflAULFsjFF1+c8phQKCQhQyym3++fSTP/LC0tItdcA2ZXcTEmZCCgoE5ODgARtxsTQQQOutnpt9vxOZNYmr+PxTAI/X5M9upqHBeLATBqalKgLBLB5wsXgikzPi7yiU/gvEw7F0w4H4lASQ0O6vHM9cbcZL/9LT7PzUU/XHUVYr47OzXm3xib7nKhrdu3a9iu04k+c7sxwYiuk01GYOyaa2Y2gVavFvnP/8TkZhEKmw1VLz2exJ0QAlRcECorFbCz29GXHg92XNxu/Pzud1BuIolhhQ0NUM4eD5RSby92OBj7PjgIZWi3Y7yccQb6b+dO9Ns114BZZwSjMgFQ6b6/9FKRp5/GMUeOoN+Zf4+VeUW03PQHPoAdKWP+sfkMM80GxLrvPiw6Bw6kZtNlA+7l588cZJsN4ysVmJeqfLuZ1WgEP9esEfnpTxPbSWeuuxtjaPNmfMcQ1wULcI2HHsIO3a23ok27doH92tcn8rOfoUhMKgB4vqrXGq/T0gKdxMWeYdInsgquJSe3rFsHY7KjAykIwmFN3VBSAqOMxtWaNW92ay2xJDvp6IAtxGI+8TjWT0Y/MOdtcTHWLUssscSSk1HM9mowCDv2/PPxs24d7OFvfAPfkRnsdsPfO3oUn2cKsRwYwLlud/Lvmct9YEA/a26GLfnUUwrUkD3FfGjFxWjDunVq17KKq8cDm6OjA/ZFczPs6qoq2OQsntbaivs2NyO9kjlsVCS9P3LddUp2OHgQ116/HrZPJJJd1BR9J48H1y8sxPGMqOEzbd6c6KMkI3UY3+krr8DGKi3F89XUoD1tbYplOJ3wp9xu2GSxGP4m8ae0FL8nJzUPfTCI/nC74eOymEV1NXyTVH6GMSpoaAjtGB1Fvz77rBbXdDrVlw0E9G9ek0WXuNlbXo53OTyMPvB6T+981yc0e8Y3vvEN+cUvfiHPPvus5OXlpTzujjvukK9+9avzcs+aGjCNamsxOfbuxSRwuTCYnU44xwxnZNlko7BaqN2OgUQDjmKzQYEUFIh89augcr7+OgAMVhfl5PB60ZZ3vhPXOHAAIFE2oUADAwBwRDBBvF6tlspCCrGYMsqKivBcvb0iTz6J+/f3JyaPF0lMEjo6imvn5CiLzhi73tSESVtQgHsMDKDfZio2GxaQxYv1s8bG6YyiZcuwU8Mwv4ICgB39/ZjErD7U2AjQobgYQNru3WhXV5cW8Vi8GN+FQuh3lnQuL8f3VCLFxeizoSFcw24Hy/D55/HszJOwdi3etVHhj48DcHnjDZHLLsN5XV2pq+BccIHIf/83xiQr1TBRpnGX48gRkdtuw+7Sbbcdn52ETIy0/Hw879KleH5jqPe+fUiSumYNQKZMDLXLL585yMbx3NOD95aTo3OLuQrNjK9kYF6y8u133YV8Qi0tyXNINDSIfPObGG/ve18iqBWLYZeOlPv2dg0TdzigU7ZuVZBxcjI5dT9VDoq5VK81Cq+zezdAcDPr74wz5i8c2pK3vjQ1gT1++LDmaY1E8JtM5+pq6DgrL4glbxVpb9eQGiMYJ4L/c3IS02VYYokllpyski7nWSwGUC4Ugm1MdhtTsjBE1ONJD4TU1ADAYbVVszAlAH3BWAwFCvbvh61Mf9vjUVJFQwN8iR07wIyj700CTHExfOVjx+ADlpfjGZj3vKgIz+Xx4Lh166Czjb7Ggw/iWK9XN6O9XrSHxIk9exDF1NkJv5C/f/xjEGBsNvg7H/tY6uIERt9pYAB+hYj6AMXFuG9/v/oo6UgbK1aIfOhDwAYmJkDkoV+2dCmuPTCA60xOAp/o7cX7j8dxTxaOq6jAsfRPAwEcHwigP8i4u+oq3K+nJ7mfYbcnRgU1NQEvOHQIYF4wqAXD6J+R6ccceOwPFsCkf1tcrEzOvDwr3/WMgLnKykqx2+0yYITFRWRgYEBqa2vTnvuv//qv8o1vfEOeeuopWbt2bdpjb7vtNrnlllv+/L/f75fGxsaZNPXPwuouublKL/V6MaBEMEArK0X+8i9R/jkZjdPnU6CIFUodDi0eEQphcDU14djKSkwmhoVykI6NgV66fj0mO3OsZWP8xWJQWMYKqUymyVBWFpYoKNDJWVmJ41pb8VxjY/jMKE6nsrOcTkX8+/rQ9nBYw31XrdJQU58PfTtfxmuyBWZsTOSTn4QyqK/HszM3G6myublo5759OrGPHcM1WTlWBGxAgm2s7ON2q7Lis05M4HMm0fT5NBm0ywWl9PzzoEAXFMB5ZUVY7vQMDYHWyySX6argLFuGXaNAQEPGcnIUdGSRD58POfpCIZHbb8e955M1l46RxjyFExO4F6vZ9fdjbjBXxNKl2NFZuzY9E+6CCxLDKslgM9K1zXMjEABIsG+fhoaTwn3WWclzHZrDN83l25lz8tChxJLr5hwSHR268NpsiRWPBwbQZo9Hc0AyTHxqCmOhvx/909Q0uzx56Zh8cwlj5sI4NQWd2NNz+u5SWZIoNht2eL/zHYxhY8Jl7nZ6PAClP/zh09OAsuStJ6+/rknFRaCn43GsxUxzMjUFR9BiD1tiiSUnu9BeJQOrtRW2bywGe7GkBGywkhLVezk5sDuHhpBSJR0QsnkzbPt9+5QNRmHU0urVyPX91FOwCZ5+GjZ9QQFs4t5e+Ddk3RUV4V5Hj8L3aGvD5/S/BgYUaIpEYEOXlalPx4KNzc0A5eiX8tkaGjTnXFGRRqiEw/Bz6+pgz7e1ge316qvwDfbuBdhFHz8WA/nguefgd11xxfT+oe/U1ASfhAQabv7k5+NaXV1I5RQIJKZUMm7O796tBQsnJ/F7YEALYthsYAZu3YrPFy7Epvq2behjp1PTM1RXo7/GxhSoy8/XqCySGS6+WDdXk/kZ69fjHff0JPotTU3oL0YSEoBjkUyupSJK7onH4edFo7g2jzMWKIlGT+981zMC5pxOp2zYsEGefvppec973iMiIrFYTJ5++mm5+eabU573zW9+U/7lX/5FnnzySdm4cWPG+7hcLnEZqxfMQRi+9dxzUEATE6rAWKm1qAgTu7MzebgYGQL5+ZgEvA5zQpWVYSAdOiRy002YTAxLjEYxsWpqEpNfzrQyTmcndno3bIDS7e2F0iOTjAi0241JHo2iHSK4X2+vxucPDMDoJKA3NJRYXjsaRZ8sWIBrhEK4xtq1eFaR2Vf2ySTJkmr+4z+K/NM/KTBEkIxhwZEI+qKxEc9w4ACe1eVCnxcV4TkHBrSaTXm5MiGdTg01zsnR0F0CnWRKBoNY3A4fxmeBgAJ7brcuIswXd/Sovp/GRvR9sio455yD8bd1K64fjWpBEeYQdDhw3bExKODPfQ5jijthsynOYJZ0OcgIwjG858UX8f4JPrvdWgnY64WyLixMXCxFlAlXVKRhlVVViSwzLoaXXKJjq61N5GtfwxggcOl04p5tbbhmslyH5vDNZOXb6+qml28XSQSIfb7UoCUB295eAHZknPK7khL03UsvgVE428qomapBpRIaaz4fQnEjEWX99ffr9VpbreSrliRKWRnGiblSOcduJIId56EhC5iz5OSXWAxrDQuYRKMaBWG3q/3jcMBZsTYoLLHEkreCtLaC5bV/P/RceTl+Bgfht0Yi8EGM4nTC9rPbFbxJJg4HAJsvfAH+VWkp7HtuzpWUwPb+wheQRsnv11BV+khMGVRWBnvC6J92dsJ+pl3f24vvg0FNMzA1BRv2r/9a5IMfhE3/wx8CpEpWOI1g19iYRsgYI924YV5ejhQ9sRiOIXA0NKSRQnY7rvEP/wAQ08yco+/EooZTU2gzAwNHR/H8q1aBmfbww8k356uqEN2Wnw//p7AQ/ffii4iyYYFCEopI9hgZQbvo409NoR39/fiMOe2nphR/8Pu12MVNN+la19ICsgiBv5oaAIX/9E+JfsvgIMBM5rDjO83N1fdBVhzXWPpG3Bgj0cjvxxhauTJ19NPpJDMOZb3lllvkhhtukI0bN8qmTZvkrrvukkAg8Ocqrddff73U19fLHXfcISIid955p9x+++1y//33S3Nzs/T394uISGFhoRQmixudZ7HZRK6+GhOBhRMISEUi+L+sDEykq69OHi7W2YnJweoyTU2YuKRlMlY/GsWgJ3lweBiTwuGAIluzBhONFVhnklySiPyKFZowc2xMkykyZtvpxPF2u7YxLw/Kp78fQNrBg5ikY2NoW3k5lBJDJ6NRBeuWLcOkGRvD87Cq6XxXAk0nV1yBheX//B+AnwUFGmqbl4cJPTGBNldVKY2YjDO2j0CXz4d3xLwHRlDS7cZxPl/i+QQBSecWUQU+NaU54pYu1cUuFoOyZX82NaWuglNcjN2m4WEo2XBYKb8Ms+E7GhrCImysZJpNKe5Mki6XWTCIsbxgAeYH8xXY7Wh/MKj5D7lDs38/xojxOlS4JSUaVvnkk+hjgqUjI3jmvj44UStWIDx2xw6tLMxqPqyUGg7jnRJUoxjDQLMt3/7MM1hwzKXbR0bAfCwvT9x5LCnRfIxFRdNzM4yN4dp9fZqbb7aVUVNVg0olRro8c0LU1WnIwaFDyh4kuGwlX7WE8vLLalwRMDeDdJOTOG7DhjenjZZYkq10dkLvs/AXHQpjYZOcHOjHSy99c9tqiSWWWJKNPPYYgBNGb7hcAIOOHYPfV1Cg7CUj58XoZ2QCQpYswQb2H/4AezoexzktLSIf/ajmTY7H4Sd0dMA2YKFCRo/RVh4fh026YgVs695etG1iQiOYROAz5+VBZw8Pi9x/P8CtDRvg16cLr3W7QaTweOA3kKFFokVPj1YwXb4c9jnvT7+RzxmNws/79rdFfvCD6QSAFSuQfy0Wgx/o9SqBJx7HcyxenDq/djwOf8foz9vtANwKChCltWcP+jQ/X+TCC9EPjJzq6xP50pfQj/X18MUYqhoMot8Jpo6MwBe99NLphI5kIbalpQrwiqDPWLSDEXqMrGMxx2BQGXLRKNbUSy7BM7e1wY/0+eB70PecDWnpVJQZA3Mf/OAHxePxyO233y79/f2yfv16eeKJJ/5cEKKzs1NshhH7/e9/X8LhsFxzzTUJ1/nyl78sX/nKV+bW+iyloABOO/N3ESwjg83pxEC57rrkNM7zzwdA9fTTUHbV1YqEx2Jwblm+mAyWeBwOPNlPeXlQQr29swtBIyLP+HeXS5VoOIxJwIor0Si+t9kUuaYzdfnlADg6OxHaW1ICJfTMM/h7yxZlIpHt09EBACUQwL3nuxJots/f3Azl6XRCIXi9GopIhe73a6y6MXcMc7YVF+MdDg/jOpOTSrE17poTAOI1yI5kFTeCmCzEQcqy14vxwWq2xraR3VZcjIWNOQ3HxzWsksAqFXY8jn4nQMcEmgUFuB6VYDaluDNJulxmnZ1YDMJh3LeoCOM5Lw997XLhObxegHFdXVDePp+GfSZTuLW1uK7NpvOSixzzXnzwg2C8er3KaCws1LYQHOzsTM00+8xnRO69N3P59rY27J7F40ox7+zEblV/v+YurKpKPJfGUCiki2A4rODfmjWaGyPbyqiZqv1mEnMRjrw8gPLDw2BdOhyJhWCYn9JKvmoJpa9PdZ1x88YMzu3d++a0zxJLZiJjY3AwuKZTjOFdDgecHosBaokllpzs0tqKaJLeXtjsTif8hJER2NYEfKqqANzR3iNrqrYWdvqGDamBENqSk5Owx0dGYEeOjcEna2+HrcoCfUwx5HDADmZVTp8P4BYLUezYARCvsRGfjY7iWJIiuOkton7P8DDycn/965mLoi1aBOZXNJqYW5052Vlgoq5O0xiR8OJ0apoXEdjgw8PYhGSxOIrNhsin//5v/M8ceuPjGs575pnot1Sb86Ojig+QLUiprgaDu7MTxSKXL8fnLE7U0iLy6KMgRcRimrOc/sjkJP4/7zz4bS0tYMmZcwOnKty3fz/eW00N1kVGHrHwBENTc3PVf2aEF8fCihVa2HHtWhzX0wMQcS6kpVNRZgzMiYjcfPPNKUNXn3322YT/Ozo6ZnOLeRWfT2mk0SgGE1k7BFfIUlmzJnm4WHs7lNqrr2LyMM59YECTLy5YoBVLiZazqEJ3t8j11yNkcTZOthGRj0Y1zJR0WyO7ipOxshITgSyk8nIUndiyRcFHlmJeuRL3MVZrjcdVWZx9tsiVV0IxEZQ4kYYrGYOlpehPlt6emtLCHKGQGtsMBWUeQIdD+9vl0so0BGrz8pQB6fPhODKICIZxx8kI+MVi6COXC4plYkLfe36+0scZchsIaGGJSATP09Mj8ra3oV8rK+EMi+huA9kqBBdjMZz/8ss4lgDRfCTMNOcy6+7Gsy5dCoW6bRvGHhmEdrvuljDMddky9MngINpZWJicZdnRgfF0ySXKPiQYTECzrQ3t6OhQNh7fY14ejiFdfXw8NdOspUXks58FYFhYOJ31JoLzBwZw/bPPxnceDwyfWEwLhExOoo9HRqAvJiZgAOTlKZOPbFQj+J+XhwU1mwqrgQCS9qaq9ptJklXYjcU0x8TQENrY3Kxt4O6plXzVEkp5uSaRJhhnBuVEwEbl5oUllpysQhY2C1oxDEdE2XJuN3IOW2PZEkssOZklFkP4an8/bDYSRozVQGl/MzpocFDBH/pRVVWpgZBktmRpKWzeeFzktdegV1evBkOPkUAMYeUmtcMBe58khrIy2OC9vbCbr7wSfsPjj+OY/PxEYkkohGfJzYVt2t2duShaS4u2hUCSCHyJqSn0w8SEht2S/OByJfrB9CtdLoCZBw4kAnMiAK0WL0Y7CVo6HOinlSvxvAcO4Fjz5rzHoxE99Kl278bf3PwvLMT1QiGRX/wCvsHkJNpcXIxnXrMGfc3QXWO+eZI8LrggOakm2XsWwbU3boQvsGMH3pnXi89JBLLb8V5IBgqHNeps2TKRT30K/pKR8PQXf4H2siLubElLp6LMCph7K0lbG/IqtbWBLZKfjwnLWOZ4HEplchIDic5FMtbNl78s8h//AfYO61+w6klurrLPenp0cpNJNDQk8sgj2JWYjaNrRuRJ86XSoENN5JrPFgxqoQTuAtts08FHJqOkgpucBG2W5bT37AFt2OmEUl68GO2Za16zbGVgAMzEvXvVUaSzyAqBVEAEIUjfFsF7YEJRtxu7FyUl+P/YMbwzGuaFhVggGBcvoiAf+52UXQJuNPSjUYwj5gAgYGSz4XMuQrxXTg4+f+IJJNgsLcWxDJdlAtKpKS12QSUYDmvOunPOgeKfj4SZzGX2zDMYs93duI/Xi2cZHFRQy7hTUlODcVNQgGSke/akZ1kSbC0sVADVKAzr9HgSGYxG44GA6eQkPk9HxW9uxgLz+uvTQbl4XBfNFSt0/hhz0hUXY3GpqEA/eDxYVK65Bs/18MNIEltfj3dDkFEE8+qss9CGTMbEmjWpE8NmG66crMJuSYkCv/n5mh+Qz28lX7XELFddhXWP+iiVtLWJ/OhH2M21xJKTUWIxFPjiGi6iazh1pNMJBgkr31liiSWWnKxCO4+FCY3C4g6BAOy6devg6xw5oiyuRYtQ2CEdEJLMljTeo6ICm9fGZP8uF2zNUEiLI1IiEdy7okKvwZRMH/kICjEwGodhkKGQ+tj0/UikMUe5uVx4rvPPhx+Xm4u2DA9rrjeyuBhxRYZXSQnscAqJEfR1mG8umRQUwLesqsL9zQQgny/55rzXC8KDz4c2RaPqg27bBt+uqkrDe3/1K/x2u7XS6/CwRoydfTbINyymx+KOzIF/6aXJAdh079lmA3bxyivwcSYnweJzOuETMQppaiqRtLF+vcj3vof3lCoC6PLL5xYZdCrKKQ3MkZbJBO/Dw5hYBDOWL8egPnwYCuw//gNx3KnAppYWxJd3dCQi31//Ogb92Bgm09SU5qRj6GN5OZz5uYSHGRF5JnXMz1elRpCIwA1DC/Pzkb/sk59MbDtZUJwQN98McMFYmYaJ/YPBRBCGgF1nJ4CJmhpco6EBim0+J1lbm8ivf63gVGUl/h4Y0FwAfO6hIYBbPp/eNxbD/3w3wSDozazKU1+P/AmbN0PxTE5iAaPC6erCdZiPxljNzeXC9SIRXN/txvVYZbSiQllnLFyQm4vxUFOjpcS9XpHf/U5BRbabOzj8jAqwqAifs3Lt/v1QfuY8EWZlmO37aW9HXjevF2BSQQFAxfZ2LAAEPCcn8SyVlYnFKrxekWuvRcnvQCD5vdIVmxDRsM7qaixuHIMMEeY7IdV8+fL0OQnShep2d2MxZHixCN6f16sLK4twrF2roemBAELgFy/G9bu6NKSgoADv18wUTFdhNV1i2JmEKyersJuTA4OAcyEWU0DTmG/PSr5qCWXpUhh6zz+fnClHCYVE7rlH5IYbkiditsSSN1u4429cx/Py1G5ijt7qag0RssQSSyw5WYW5rPPypuePE4E+Gx6G/fh3f6cEAdr/zO81U1vSKNx8pm/W1wcgqaAAvlB/P+4ZDsO2LiuDD0O/qa4O9vLQEOyNd75T5MEHYVMwxVBhIa4dCOD88nK1TY1F0Zjnrq9P5Gc/Q5+Ew1r4welMJGz4fFgHvF78v2YNfBwCWiS9kPFnt+PeDCWltLWhzUePAm8oL9fIMm7yMxrGuDnf2oq2siAhWWa1tbDHPR74CBUVOJ4EhepqRO9NTGghjvZ2YBnRKHxZY+E9nw++DfNpz+Y9NzbC566thY8zOKjsvngc55Hkw3Z9/vPoU5HU+bFnmjf7dJBT1oQ20jJXr8ag3LYNDmhREQb8M89gslVUIPY6Pz8zK8VmgxO+eLFORobseb1a0dTIWLPZEP63fPncwsOKijAhKyo0Nr6iAkqZ8fHj43jW4WFMxuZmKLq1a5Gw8rnn8B1DOEpLkdCxuhqT9sorAUjxWqOjcN5zcqA4mMySlVBfeAEgF0NrGW6Yl6e7A5s3K3A3U6CO73FoCOGer76Kv0mb5e5JcTHaNzWllWdcLl0QhobwvPX1eNbxcTAoe3pE3v1u7CS0tKCvfvMbvEcCeRUVSncWUZp1YSGelzsHXV149k2bsBg99xzGm7Fybl4ezluwQBOKdnejjcxLYLPh/Y6OKjOPIdh8bpcrkcbs8QBwveCCxEqmxiSeoZAmDnW5UodHpqI0NzTg+AMHsEieeSaAIoLPo6Poq54e9P973zud7m2UdMUmjAvZihUATsNhPCcrJItoH5SVAdTKNLbSgWJnny3yk58okEiGIMPBjaGeXAwPHEjM85Dq2uYdyVQVVjPtTmYbYsoS9R0dmksyJwfv5Zxz0OfDw+jPnJy5VYy25NQVmw0Jha+5RkP8zcK17vBhhNe/7W0nto2WWJKNMH+Nkd0eiSjrmsBzUZG1IWGJJZac/FJUBL9ndFQT+hvtRjLWWlo0Wmo290i3gc4CgsPDsGl9PtiVxcXqBzIVz9vfDlve709MXRONqi39f/8vom26uvA8JJ+MjWl+6VWrptumhw4BjBsfRzuYv5vXIuOOaZ/IwmMxuL178X1DA+xr5vDmM5CRyMgzijEv29q1uN/Y2PR0N8k253/4QzDQHA74aIsX49yREQUHe3oQ5lpWBn+0sRGROsb80E4n2u73Yyyw8J4I/m9rA3utoWH27zkQgK/7pS+BxPTGGxoNFo+jPcGgptpauhTA4xVXWAy4mcopC8yZHVw6pPv3a1L6yUkAR2vXYsDl5GTPSjFOxnXr4LR3dSlt17gLW1sLp7ewEEjzbMPDjEDGggUaAkigxu9XCm9PDwDDL34RE/prXwOoZbdj0g0MKNjEKmSvv45nHxvDvbZvx0QdHtaYewJC+fkAtrhT4/Mp4FdcDOWVk4NY+J/8BAqH4N9Mwl+N77G4GO+QFV3CYQUgmCSUyU7POgux7Tt2QOEWFOB9trRAYfl8yvirrNRqnsl2X9rb0Tcs8EEDngtLcbGCpOefDzCEIbdVVfg9MKDnVVRo7L/XmxgKy7LiDEfm2CWIyvLkVIgEJ4eH0bdXXaVt/9//RRubmvDOXnoJx5WXA4h2u5MD0anAoZwcHOP1YnytXInn3bMHDg9Ld2/YkF2OgEwMNi5kzc1478EgxvKxY3h+Mh6KiqD8L7oouzGVChQTwRx57jmMY4bv+nw4hjs73CFMxipLde1keiTZTlGmXatMVVtFMD8eeAC7d14v+sxYrKKyEvqjpQU6IxCAHrSSr1qSTC66CPr0j39M/j31WiAg8tRTFjBnyckpTzyBtYZ5QpkPx+3W/KHj49i8szYkLLHEkpNdmppgxw0OwtYnIMYCfkyuf8MNs7flMm2g9/TA35ucxP1XrYKeNUZ1vfOdsEVratAOFoSjGG3p5makz/ja13AN+lllZVrZ1GibkiDz618rWy0UUnv33HPhdxOMY+5uEmY2bIDNOziIZzRGBBUVaV47hwMkn5tuSozGMpMYCgsVZ/B44ItdfDFIE/n5mo6H1Wz37cM7crvRtp07QSTxeHCPnByQBq65Bmm5hofRv+ZoGBJOpqbwvIcOwRelb5afL/LNb6b2v5O9Z0Z+0VfesgX9/1d/JfLP/wwwlQzIsTG8x5oa2IDMEd7Rgee1QlWzl1MWmEvm4NIp3bNHc4oND4PxdegQEOXq6syslFST8aWXMCFZjbG0FOdv2IB7M8Y8025sqlhsI5DR04N7kqbM3QRSZ/1+KKTaWpG778Zkd7nwfJ2dWjV2chLP0dWFSbd1KwCJmhoARC6XxouLaJ41TtacHKUb5+aiTWNjcOJYnYeJOysqkgNBkQjuOzCA+27erIrR/B6rqvAd2+hy4ZizzkI/kMo9PCzy4Q9jwbjzTn2vXFS4MOTna0UhvmsCJs3NYNNt3YrcND//ueZQGB/HsWwX6c1f+Qqqfw4P471VVEDJvvgizmECzooK9Amr1jCHgd2O98jE1MEg3o/TiQWD4dEsCDA8jAWnpAS5Ax5+GGP3jTcwBpYswbMfOIDzFi/G9Q4exPtOBkSnA4eqqgDqvfQSFo78fFzz/PMx3qqqMGaNC1A6yZZlxnHv8WBxZNWiYBCMz09+cmZ5ClLRp9euxa6bz4fxy7BoVgCuqZlOTTc6cXOtpJpteG8qHWLevdu7N3H37owz0HdVVeh3Ee17K/mqJcnEZkOBluefTywCYZZ4HKx0qwiEJSebPPYY8nbSKRPBOA2HNcccQ8He9S5r/FpiiSUnvxh9QhElaAwPw5+orxf5x3+EzTwf90i1gX7TTTiWtmRlJQCbxkZEYV14IUChTNExtKWvuAIkkx//GNeLxeBjrVqVaJvS3j12DL5AfT3aa8y9XVgIH2hyUtPUOJ2IEmlpgf907Bj8mHe8Q1MitbXhnJoa/GzYIPK+9yXaxclIDMQZWIH28GH8dHZiw9xITikpgS9YWIj3xfDU5mbNo+f342+vFzjF6Cja53RqLr/SUg1xLSvDvZ5/Hn3R2Khpjl58Eb5hsoqs5vecnz8dYGUF3pYWkQ98AO3t79doMkaSsYJuWxvwh5GR2RWxO13llAXmUjm4Xi8G1uSkgiSsxnjsGJDeJUvSs1JSTcarrsLA7OzEpLnwQigaoyN/5pmYZHv2JHfczeGH5oFsBDK2bcOk6O+HQlq0CJP46FFce3BQ5AtfwHHj47qTMjGBCU2mXTAIReb345k4+RnewVBKUoBJWxXRqqORCNrqcChgGIlgQQiHtRqPGQj67W+hWA8dgmGcmwsK7Gc+A+Wc7D0SCCwpwd9OJ/qfYFskApAhEMAx+fnYGTGHBoqkZiDFYonFD2w2HDsxAQVdW6ttId14wwYo4qeeQn/39uK7sjIFOBl/HwopM47sSqdTw6A5hsNhDddk+W5Wn+UPk4zedx/uRbpyRQXGhteLc1hhsbhYmWClpdOB6EzgUH4+QOxPfQr9y7wCDz+McTlTBZwNy8wM4DFkfNMmLDoPPzz7CqbGd757N/qjpkZDppmz0e3GPKmuxvs2s8oyzd1sJNvw3mSMjky7d4OD0DvXXpvYpmwZfpacvnLttTCsR0fTH7dtG3ZI04WwW2LJiZRIBHmAyUBI9j3zwZ5xBmw0SyyxxJK3ghht47Y2+FpkZN1ww9xAuWT3SLeBns6WNII+9fWqd4eGcJw5QmP1apAqUl3PaO82NcF/p1/LirT790OnEyxauRI+T2UlfBefDySDYBDPUF6Oay9YgPtv347Iq89+NnkocCoSAzd6urvhVxcW4nxzEbcVK9CmnTu1gAPDU+NxDcv1eODfhcP4iUbx3diYRkHl5eEeq1fjnhUVeD+lpeij3btxnZEREDPe/378mFPsfOYzCFX97W81bVBDA0C5nh7465/5DJ6ZUUvV1fjNfNXbtuEdHzmCz1aunF0Ru9NVTllgLhUtc/9+DLapKaV3Mv59bAwoM/NIpWKlpJqMNhsmQigEJ5jAC3cW7HZ8/pWvJHfcjWyXZNUYb75ZQzc/9CH8sFrq668DDRcBgJCbCyeKrLLJSfyQ0suy2kykHw6j3bW1uAerT/b3o48CAWXLOZ1ov4hOTOZI42cEjQhcjY1pNVICQT/6EYpp+HyY2CxpvW8fQnBFULFl+XLkLmpq0lh/JuQ0VpKkmFlFM2UgtbWpYpqYwHk1NWBm7d2L8uBbtqA9fLdVVQCIvv1tAKO5uXo9rxdjgzscBOcI1k1NaQUlIxBDlqTDgd/BoFYTiscxDiYnlV3Id1tWhusWFuK5urq0ChPfC6uKlpRMByezBYfOOw/tamvLvopoOjZopryLyQA8VhOeSwVTCgH31atxbVY14jvu68NCU1YGanmynbu5tiPb8N5sqyoZd+9YrOJDH0oETqzkq5ZkksWLAcY/+2z643w+kX/9V5H/9/9ORKsssSSzvPwyct0Yq6+KTGd+NjWBGWqFsVpiiSVvJZlJChWjzCTCI5t7pLMljaAPc52LJC+mkM31jPYuizSQ9Ux/yuuF3Ts2hr/tdtjTzFHt8wHQKyiAb0d7m7nvVqzA+byf+blTkRiMWENZGXxpppEyklO++EXY+62tYNWVlyv5gvnJq6pAXGEUzNatmhvV6cQze71o9/LlAOCcTpGNG/EMHg+AsokJJaqMjWFd7OmZ7pusWJGYb5UEpu5uBQkffFCLJdnteEaurS4Xjtm6Fb7Hxo06RmZaxO50lVMWmEvm4DL2enxcwTcCU6x0OT6OQfyxj6U20IqKMPjIiOIkZj6wM84AYBYIIIQwLw/37+vDREgFuv3mN1ASTU0aDsSBvHWryC23AMAKhRTUW7tWablr1uD4nTuVtVddrbsIeXmYnETcjQw4PsfEBJywwkJMdoJC8bjmmjMWM8jNhdIZGNBrRiL4nmGXIvicYaYFBXjm//ovKEZWtBRB+wsLAYDccw/AMFJ4d+9G3zNPQXe35u8zVuk0s4pmwkAi9fbFF/H9okV4hoEBKLNNm/Bu9+zRXHuspvmDH2CsETxzOtEnwaBSfV0upZuPjSUWlGAoK5lx/K6qCtdwOBRwJbuQwOjICPpqeFgZZXzPk5O416FDCszZbBgn/f0Ym0ZwcibgUKpCEckUcHv73BllxoU6FhP5xjfmXsGUYgTcc3IS82AsWoQF+uDB6SXHZ9IH2bRjJkUkUrXfKHwWc7EKS94cGR4elk9/+tPy6KOPis1mk/e///1y9913SyHjLJIc/+Uvf1l+//vfS2dnp1RVVcl73vMe+drXviYlxh2J4yg2G8DoTMCciMh//7fIXXdpsmRLLHkzZe9e2HWsbG4U2jaxGNZyK6+mJZZY8lYU2sYE21pb04Nts4nwmI9N3GAQ/uoZZ8AudTjgV9x9N/KoZVso0Gjv2myJFWEJWnm98HOCQVyThI7OTvST261RTXv3Ih9cWRmuWVkJttzgIOyZ0dHp/UTGm9m/ZAEMEbTHaKaZi7gxLHT3bviaQ0P4TWLPzp24lsMBfICRb8PDeBYR9RdfekkjtIJBHLt/fyITj8SMpib0j9k3eeYZkd/9Dn9XVMDPZM5tnw/EhR078P2GDRhnxtyGLEQ5OQmsw+NJxEhmUsTudJVTFpgTme7gDgwAEMnNxSAdG1PmEtleTBC5aVNqpRAI4Frt7ZjAubmYxCtX4vfkJEJ/PvQhHFtQIHL//VA+qRz3b38bgz0cxuRjIv2VK3EsJ0VDg1Jid+7EpCorQ162nBwoj0AAx/n9cOrr6jDZg0EYn5w4jGu32XBMcTEmy+bNAJoefhgg5ZEjyjAUwfk5OeirqSn0Y26uAks81mbD/2ZWWyCAzzo6NByVuxwiSkXetw8VYJxO5C/r7ASQdOgQjnO7lR0YiaRmFc0UZOrsVEVvt+OH1OjBQSQy7eoS+cQn8H6amvAszz2H56iogOIjs49MtWgU3/P+TicU/9gY3u/4uCpTKmanE+9pYgL0arIVWfI7FMLfBH2DQbTR6UwsZ22zKbuO7XA6cV5HB963EYjOFhzKtoroM88gv8J8MNso81XBlJIuhJfgfU0NdqWMu2ex2Py2Q2R2O6BzzU9nyYmRj3zkI9LX1yd/+MMfZGpqSj7+8Y/LTTfdJPfff3/S43t7e6W3t1f+9V//VVatWiXHjh2Tv/7rv5be3l759a9/fcLazVCOZACHUSYmoLe/+c0T0ixLLEkr//M/qccsWXQ5ObB7rNAaSyyx5K0q2YJt8xXhMROhfzU0hE0+c/XY55+Hv7l0KfzUlStFrr4abUtmA5vt3ZUrEyvCxmL4327HMy5bBr993z74QCJKSPH5dI2IRHD/vj70BVMnpQrHTOZfDg0BOGPBQ7NfYI5SWrcOEQlOJ67f2op20z/2eNBH9CEaGkDG6O9H26NRtDkvTzGFl17CNb1eBcVEcD0Sk8y+SSwm8uij8BWbmxUXcbnUB+7s1Iiw1as1XY7Xi+dhOiuvFyzArq5EPKOqKrsidqeznNLAnEiig7t/v8i3voW/a2qU6sqcX/G4xoLX1CS/HsP2cnIw2KemMGl7ezFo6+rAAHvvezVcrKMDTJVUjnt+PvKShcNQPEz839cHoI2IdUGBUkeLixHD/dpricwE5i5zOnHM0BAm/cAAgKipKRxHBpzdjus0NuLZCFQxn11nJyb+2Biu8ZOfoL+KikReeQWfMx9dLAZlQVYYK7oUFqpyisehNAYGcB7zz7nduDfZPm43wLvBQYCk4TDYgQ0NAER7enAtvx+AWE0NlGAyVtFMQaaKCoCjxnBUIzWazMD6egVaDhzAc9TU4B0w/t/t1hxlZNzV1uJdtLTgfezciesGgzh3eBg7SUuWQEkHgwrQsYpuXh7aQcXJQhLMpcAEoLEY2k2Hmm13OHAfVofNNHdSgUNmlhbfOSspFRTgWR99dP4YZanubZaZKv9sQngbGgCyHzighk9pKcbpwoXTnz9ZqHC2MtPdybnkp7PkxEhbW5s88cQT8tprr8nGjRtFROSee+6Ryy+/XP71X/9VFixYMO2cM844Qx544IE//79kyRL5l3/5F/noRz8qkUhEHI4Ts4yfcYbuOGeS++5DXq8T1DRLLEkq99wDZy+dxOPQ1RdeeEKaZIkllpzk8lZktWcLts13hEe2kmoj3eNBEQHmzq6thb/03HMgh9TWQj+bQUazvVtVhWIPxoqokQg20tevx/fV1Zon2m6HPzQ6Cr+qrEwjjETgj77xBny4DRvU10oWjmr2LyMRTW9UVTW9L8yb5Kyuy1xz0agy3JiHnKSM0VH4FWVl8CkIHDY2wp9cuBDHtbWhbyYndaOePjOJMtFoom/S2YmxUliIZ+Azi6gP3N+P9nJ8GdPlMPXPtm0aiVdRkci4O+cczYtukQSSy2lhNtPBbWoSefppMK7CYQwstxuDaWoKA7a6GsclGzBGhbZ5M34TKc7JwaCrq0NYqhEYSgcgxOOKyhcVab4tItQ9PQB56upwf4aDiijTzO/XRP4MNZ2a0txuvDbBIe4W5OdjQjU1oR1moCpZ2KDTCSWXk4N7Pf882jc5qSWtp6Y0TNjhgBIrK0Mb9+0DQEDAihVJx8e1ilBBgYZrjo0hfIoMsvFxTTYZiaDN/f1QJNdfP73SDGXFCjAYDxzA/8uXT0/myfdUU5OYr4DC/kxVXXdqSt8lacjMsUdq9QUXQGGecUZiFZ5lywDuTkxoBaIzzoBiDQahRCMRZSKS2Uk2HdmJfG8FBao4x8Zwf7cbvxm+Mz4OZb50KQDcZIyuTOCQcdcqFNL5wLYWFuK+0SiuM1+MMvO954MhlimE127H4tLdnWj47N8PVmlenuay4PNXVmJMn4hFaC756Sw5MfLKK69IaWnpn0E5EZGLL75YbDabbNu2Td773vdmdR2fzyfFxcVpQblQKCShUOjP//v9/tk3XJBTsq4OmxaZ2we9ffHFc7qlJZbMWsJhka99LfXGk1HKyy22nCWWWAJ5q7HaZwK2pYs04Tkvv4wf5pGeD2Ge47w8tJd4JUMta2u1aGAshmP7+2FHv+MdOMYMMprt3bIygGEHDsBWCQbhcxmjvWw2TVPT14f/8/NxfacT956YwP3pS42NJaa2SRaOaiQxFBSI/PznAPbo41KSbZLTdt+3DyyzigocNzoKv9AY2kpGIHOysxAi8+YxjDQYROodRrOVl8NHZTHEwUElENA3GRuDn1NbC/IMwUEKMYQVK+Anv/GGjrfSUrT5hRfgc9TUKAsxHkd7iQFUVADstEgCyeW0AOYoNhtyxz33HCZGfb0CL5OTGNyFhRhoyQaMWaFVVgI8GRrSXVcy24ySDkDw+aB8SkuhVEZHdTIQTPF4MBkWLkyMVSczjUyreBw/eXlQ0OXlmMytrZjQS5bg87w83KupCf1RV5c5VC6ZMl+xAtd54w08QygEZbNsmcj556Mftm0Dw+3AAe1rlnYmu8jpxE8kgvbl5+N68Tj6k7kBjh1DP8RiuC+BybPPxmR/7TUAc2ZJR+82KlOfT4FNc74CES1wMTQEZW8cI11dygB0ODQElkCYywUwsbYWDmthIfIGejxQUiUl6AOPB4uTz4ecBxdfjHa0tqJvampwHJmIRUXol7IytGNsTGnL8Tj6MhrFu2hsxP+hENo5NgYWYmUl3s9saMXctXruObSP8yg3V8Oyy8p0gUsms2WUHQ+GWCp25ZlnYiHr6Zlu+GzciAXw+efxfji+mdPy6FFQ8udjEcqUrHe2+eksOTHS398v1dXVCZ85HA4pLy+X/v7+rK7h9Xrla1/7mtx0001pj7vjjjvkq1/96qzbahaHQ+S220T++q+zO/7OOy1gzpI3Txg2lY2cdZaV68YSSyx5a7LaZ5LWJRVRhFVMBwfhy9x5J1IIzSQHtFlor+7aJfL44/Bj9u3T9E/0SRl95nDAv9m7FwBTfT0IBOPjsKvNIGMye9flgl++dKnIE0/A76bfbCSuEDBjW1gkYmoKP+XlSoYx7G/+Wdxu+E3Mt9bUlLiGvO998EGy3SRvaUEKrF274Av39iICjaG4fj/+D4XwXXk5/C3mw/P74Y+0tuLvqir4krGYRgY2NOB5d+/GMwYC8KGYd5pYRXm5+jsVFeiDcBh95HYj9VF9/fTn6+tTYHHVKuRi379fAToCixdcYJEE0slpBcyJICb69tuxk9rfr+BWWRmAjsWLUw8YJuufmsJg6+yEwmB4YHk5rmUGGNIBCMEgrrFsGY559dXERIosu8wYd+O5JSU4rrsb9zxwABMwEMCEHBjAZCkuhlJjhZhVqzC5OjtRDvrWWzNPkFTKvLoalcyYGP9Tn0pMjH/RRYnA1ze/ickbiWBid3XpDonNhnYzXLOwMDGRZSgExREO49n4XTrWVWuryB13QMk0NuJdcOdl927dpQkGca3+foBJdXU4Z3BQgSbu9phLe7e2ovADWWv8nFVoWeJ64UKRRx7BvZ9/XkPCBgfxPurr0R7mV8jJwaITCmmVWIbYFhZqIQjm5AsE8LfbrQAmd1FYypphsCI4joDxbBldNhtAp4cewjupr1dQzu/X52HlWpYpN47j2d7/eDHEkoXwxmKoppzK8CksxNjhgi+iC3+yXcnZSLb5Q2ZbocuS2cutt94qd955Z9pj2tra5nwfv98v7373u2XVqlXyla98Je2xt912m9xyyy0J5zY2Ns7p/jfeiNANny/zsVu3QjeuXj2nW1piyazkgQcy50MUge32oQ9Z+tESSyw5caz2+WS0zyStSzKiiLFyJ4kb1dXZ55yLRLDeDwxgc3rzZviDv/kNrrt3L/y6iQlNtTQwgOi1vDxNu1RXh+sRrMvN1WgqkeS+ntHe3bULhfv6+rAhfvQo/OK3vQ3PU1KipIt4XHPN5+bCtu/rgx+/eTPu9/vf47cxcor99cYbOP6HP0TIrdkWn80mOXPN5ebCdhIBu42FIJmCyujflZbiXbrd6OO+PsUN4nH0aSgEm21gAMfn5+M7Apbf/S7aGotp/nyHA9cdH9fIJ5cL/j4j08zPx7BZMi3pC9EHYg56ptSyJLmcdsCciMgVV6DK4o9/rGhueTkAq3SsEiqSHTsAiESjGKxkBHV3YwAODIBOS0kHIHR2YpI0NkJxbNqECe/1atL+khIAHJWV09tUWIjvX3pJwcG8PAz8kRG0027HhKISJiIfi2ESb9qUmdmQbWL8lSs1n5kRGFi9Guj50aO4d3W1nscJzRDQJUs06SVz1rG9XOP8foANVCzJWFetrSKf+5wW6RgYSExA+eST6PtLLkE/dnYiH6DHo+eIADgjBfjii1GVk2MkFsM4GhhAu1n1d2oK3xGcicXwPLEY2m7cgYlE8FkwiPYtX46xePAg+nvNGhQHueIK5Grr6sICNzCgfRaJYJFasUKLOrzyCvrPZtPiGAsXav4+Y8GPueQeKyjAtbiIsupxXR3e87Fj6JfhYfR7VZW+g3TMtmxKuR8vhpg5hHfPnumGDxmf3I0qL8dOEavgsg8aGlKHCmcrM03WmykEOZu+tSR7+b//9//Kxz72sbTHLF68WGpra2VwcDDh80gkIsPDw1JbW5v2/LGxMXnXu94lRUVF8pvf/EZyjUkwk4jL5RKX2aKco9hsqJz2X/+V+dhwWORHP8JmjDW2LDmR0toKFnc2Ul8PYM4SSyyx5ESx2ueT0T6TtC5mooiIhpNWVsLGpN0qkjrnHG3Ixx4T+eUvYXtPTcEPqK0FAOR2qy8bjWo4JkEl5uLOyVG/gD4NN/gdjkRgLJmvx+J2TzyRaCO73QitfPJJkS1b8HlDg/qhS5eiPV4v7ldSggiYsjK0kVFPxj4liNnfD3/qzDOTh9mKzHyTnLnmXnwRz1NVpce63fAxmNaKudknJuB7FhYCBzBGSrndGkU3MQG/r7AQ5y9YoAUr9+1DXmCSYshgLC5Guxn+u2oV/F+2yfx8Ph9IJHl5IL7E44nvlGPAZjs+eQxPFTktgTkRAEV33pn9hGlrE/n1r5UJFI/r5BgZ0ZLNpaVgvZlznaUCELZsARDT0wMAqL0dysoYl37JJZhgyVhBixYBENu5E/cbH9f8VuXlUB7BIL7jhgx3IkIh3Pe++2CcpgMxZhI2mIrZ09SEdpeW6vmVlWgni0iEQiJ/+7dQpBUVCE9luWWyz8ggNLKXzKyrtjYkH29vx3UKC6cX1GA+P+5CtLai30pKoJCdTvRnTg52Mj70ITil27djN54FJ3buxD1dLnwWDCqLUkRz+k1MIG9DJKKhpkYJhTCWli/XnSs+j80GUNDIQGS11+98B4Dxxo04zuMBnZjP6HTqLtGBA+j/ykrdeaqoQDhwpvLqqWRsDM/+jnfo7hapz6++is9KSjCGg0G0f2QEdPPJyeTMtpmUcj8RDDGz4UPav9eL5/N48HzLl6M/jcUfotHZhwqLzH+y3pn0rSXZSVVVlVQly/JrknPPPVdGR0dlx44dsmHDBhEReeaZZyQWi8k555yT8jy/3y+XXXaZuFwueeSRRySPtNc3QT7/eewSZ8rdNTUl8oc/zA2QtsSSmUosJvKP/wh9mY3ceqtVpMQSS051OdlY7fPJaJ+Jf2YmihQXw/dkCiS3OzE6K1k0Em3Ip56CPxSJwNatq8P99u7FcRdeCLuXxAr6emwXwbdAQOTyywFEsZggfW0WKqAki7BJZSMvWgQ/6fnnARRNTOC6dXXw+RjSGQ4DjFu9WvOhd3fDR+HzNjSgb15/Hd+VlwMQYzHGVLb4TIq48d288QZ8pPx8JXX4/bj/OefAh3vjDUSnvfYa/KjDhzWfPHOb19TgHBZLZIHEBQsSI5fq65Fiqa5uev58VorNzxf59Ken+wjmXPTPPw9gkZF/BOXsdlxnwQL4SbPJK366yGltjmTLKvH5RH76UwzSM8/EDsHkpIIeU1MKpNhsQNM7O6EEjWDBihUwAs0AQnu7yFe/CjDKZlPW28gIBnQ4LPKBD0CJmFlBZ5+NSqmXXIKJ198PgMVm02T00SiUcCyGHQLuPuTk4F7j45kd+2zDBtvbUzN7Xn8dk3NyEs9OpUCabjAIAK2uDm3Pz0+ssiOiFWELCrArIzJ94aGS9nhwXGFh8oIaBAonJ8GIGhnBcxQX47OlS3Hdnh6wvv7rvxDOaGS7sXBFNIrfZPWRdhyN4rpOp4Yc85nZduPOzNQU7u31JmeRJRuzf/M36PO2NijYffs0d19jo1ZzragAcyscxnPG43iP8TjG0GxBGoJWExOaIDUeh3KemMAC4HIB3OzpwXsZHESfX3vt/JRyn2kF05mK0fCpqtKiHcwNSFZlWxvGrLGq81xChUVmlj8kUx/Mpm8tmT9paWmRd73rXXLjjTfKvff+/+2deXxU1d3/v7NkZrLvGyQBwhIChNUSoNQNHkBxt62gtWqt1LZordYKtuJCH0XlabVqi49VaX/qQ9W6UBfqilaFqMgaEtZAEkhCFjLZl5k5vz8+/ebcmUz2PXzfr9e8kpm5c+8559577jmf8102UHNzM61cuZKWLVvWErvmxIkTtGDBAvrb3/5Gs2fPpqqqKlq0aBHV1dXRCy+8QFVVVS1uL7GxsWQxps7qByZMgBXvnj3tb6cUrtu33kJCJEHoDz74gOjddzvnxjplCiwABEEY3gw2q/betGjvalgXo6HItm0QwyIjMfdibxbG10KNwwMVF+P5TqRjfhcX41g8H9i5U2cTtdt1rOnmZu2iyQkejh/H73jOdvy49sLicW9bHjbtjZHj4mDUkJ+Pv++8A7EqLU17Dx07pjOe1td7e90Q6YXsb77BX4sF9d29G23DbdbdRHZG0tPxTDp0CG1u9EDi4zidmM9deinEueeeg0DHc8iQEJwH9vAJCtJurCNGeCeyIILOUFGB5yFbLxozrXI4prZcpRmjsFhSooVXtpYLCYGrbkgIvKi6a6ww3Dmjhbn2MFqVlJfjPZv3ciwxTmXMllfJyeiM9u+HyFZaCkuZjgSPtDQdi4ut3qxWdDxpadjP3r1Ev/61FndY1MvO1oKW2Yzt3G50RkTYjlVvs1mviBDp1YjOqtcduQ2mpSFza1uWPV99hXpZrd5x9Hg1ICAAKxwTJ3qv/syfr5NkZGdrAS04WK9sGB88x47pTrqkRGdXVQqdjNmss4i6XFjxOXpUt31goF7FMZvRlqdP46HX2IjjxsVBjGExLiwM+6qvR/0CA1E3zrLK7qYMJ+og0i69ZjP2v2cPxJ3OxkcznheuS1CQt6kyd7BslfeTn6Ccr76K67snIo2/1Tp28QwL09fZmDF4cXam2lpYIaam6n0NVCr3juAHTn4+VoQaG3HPcgDVsDBcY3V1uPZiYrRVZHeSUBjpSvyQ9hisbXum8eKLL9LKlStpwYIFZDab6corr6Q//vGPLd83NzfTgQMHqK6ujoiIvvnmG8rKyiIionHjxnntKy8vj0b385Kj2Uz06KNEF1+s42S2RVMT0Z//jIQRYpUk9DUeDyaNDQ0dbxsSQvSHP0hfJwhnAsPdqr2rYV3Y0+SLL+A9FheH+a2vsGVcWDaGByLSc0vOusnZTF0ujIcrK7XXCK8fWiwYP1ss2rMrKgqGEOXlKHdMDPYREaETA9bWYl7icGC8ysYvZnPHY+SQEJRt40YIQsHBmL9xaKPzzkPdUlOJrrkGZTZ63aSlEX30EcY9Nhu+45BRRUWY02RmQqDsTiI7X84/n+jKK3Fu+FjGpH6+FpA/+AHKX1qK+d2IEdi2oUHPO10uzEuN1ocMxwz2zTzL712uznv9pKcTLV6M9uL5sNWKNrfZIDjabD0zVhjuyFDZD75WJQ4HLsqSEtzUTU2YzFqtGAiaTLpDqqvDzbB2LS7qWbNwU7cneOTnQ61mqzejG5zJhP9zcnAz+s7BjC52nH3FaKIaHo4btakJnVNtrY5xxibLXVGv09ORqMI30KfV6i2I+bPsmTABnRhnWeUsOLwaYLViX6NHt179YUu606dR7pgY3OD+HjzcSaekaBfOoCB9fpqa8D0LWOwaGxyMduHYbTabNsU9dQrbxMToVSirFSsLp07hM34ouN04Dl8X/JlvexB5i3O8zdixXbdc4ofse+8hHh1nzHU6YeJMhBUWtpBMTESWpPLynos0/lbrOGU3r7IYV70iInA+Dx7U2YCY3rQO623S0+HKnJWFc1VRoa/d6dNRH6cT91J5OcTWniShYLoSP6Q9BnPbnklERUXRSy+91Ob3o0ePJmXwEz333HO93g8GFi6EFfff/95xIN/cXKL162EtLgh9yQcfwFK7M0yf7j+LuyAIZy5D2ardX1iXpCSMQ/fubR3mxWxGoP65czE/9cUoAtXWeocH4sUPt1sfy2zGHI3nMpzV1Bg3jo1ZLBbMRSMjUabbbtMiW2gojvfmm1pkbGzEMZubiV58EeGE2NilozFyfj7G542NmLMaQxuxqJacDOOP8HD/498vv0SZ4+J0kj+bTRu/7NqFcEK9ITiZzRDmTpzAvpOS0G5tWUByUovYWAh0J06gzdn4pLkZY3x/l6FSmK9ERbW9eNoVrx+PB+0YH4/jR0R4xwksLYXl4bJl3TdWGO6IMOeDP6uSsjLtJ19fj4vN7cYFZ7fjM+MKLVvQeTy4SUJCcMO0JXhwtle2qjKKckTaIsbphPhltJgzWitFR+vOjwg3XHMzVgE4EypbgiUne5vFdvam8xef6tNP0Tm6XB2vWsTHo+P0eND5Wa06+UFsrO5s2lr9OfdcpGoODm47npjRtXLiRAhtR46gPTlLqdmsz1l8vLagq63VDxWrFW1ZUYHvQkJwTLY8s9t1EFN2bbZY0O51ddhPcLA24/W9zoywtVpkJNF//zdEzK7CmXsTEtCeX32F66W+Ht8HBkJESklBPXpTpPE9X7xqFhcHF1bfhcq2Ovresg7rK+LjsbKXkND6Xo2MxP199ChE4/j4niehIOpa/JD2GOxtKwwdzGaiu+9GIqSOwvJ4PERPPAELO8nQKvQVHg/RnXd6W6a3x3nnibWcIAitGcpW7cawLjk5SL7UXjzhzrjBXnIJxvb5+drSjb2wLBbvUD6cdZUNHmw2zEGcTm3oEBiIcWZgIOZVkyahzP6Su3G21ZdfxnwsJaW1d8/Pfobx9u7d+I0xjrnHAyGIY8H5hjbieNFz5rQ9/uVF7QkTYAVYXKzng5xptrwc+1q6tHcEp65YQBrnCOPHY05eU6PPlcmkrQa3b0d7G89xSgrqVliIORkb73DSSJ5jJCW11iB8z1l+PsTbs86C/lFXp0M7cYx4lwtiqDx//SPCnA++ViWlpeisPB68WGn3eLAyEB6ub2SjqW50tHeQeHZt8yd4cLbXfftwoVqt3tlDWTR64QVs69vBcqd6/DjK1diIY3GwyNmzUYajR9FJcnaarrradRSf6sorUS5OXuFr+VdbC6Hmhz/E6kNuLrZ1OGBZ6NvZdDeov7GTSk/HOQsI0MkjmppwfliE4yCbJSU6aQNnUuUkHCy28cPIZMLfpia9EhEXp91hzWZYviUlwaSXU1f7S/qgFMpitSIAqs9zvdPwNep2I+h6XZ2ONchusgcP4vvS0t4XaYzni+My5uW1zibc3jXXW9ZhfUVoKK6VgABcQ0ZiYyFCRkYiRgQnPPGXpbgrySnaGzgVFOAeM5r2E/k/1mBvW2FokZ4OF4p77vEfz8vY15WWwmru2WdlMCb0DX/5iw463hF2e8eZ6AVBODMZDlbtXYkn3JEIdOIEwt6cPg0BqrIS40SbDfOKgACdZDAgAP1rQwO+5/BPTqdOvBcZiVdICAxH2vIoMZsxfn3pJcy1Jk3CvLasDMdIT4cHy69+hfdHjkAUSkpCHNzAQLxvaiKaOhXzbA5tRKQzrpaVwXilrfFvdTU8owoKUP/ycsxhLBZsb7ejXPX12M+BAz2P1cxGH0uXEp19No7j62JrbCcOtfPZZzqUUWMjyhQeDh2AvafKylqfYyLEun/tNW9DEosFsecyMjoWebmtGhowFwwJ0Ukk2DsuKUknShT8c0YLc/4my0arEg5eXVeHtMhsHsoqtMuFjkYpbB8aqlMBc3IDvumdTqj4voIHZ3ttbsbNwL71bGLLNxN3aP5WC269Fa9//AO/O3nSfyDPY8e0At6eWWxbbdVRfKqsLBz3/fexLxa5YmKgxh8/DjU/NRWWb77x8trqmLu62GQUMr7+Gu04ejTa2OlE+02aBGuPhgadVZQzx7AFHLuk2mxaqGOLOJMJL6tVJ4M46yxss3072nbmTG05Z8wA68/1y2qFYLpqlf926EjYYUvG7duRMvv0aV3Oujrs32LRyTe++AJ17m2Rxni+bDaixx+H5V50NB4OVquOIeHvmust67C+oqPynTiBhCyLFum69UYWVH8DJ3+m/VFR2L6iovWx0tIGd9sKQ4/vfx+u8xUV3m75xhiaRLhG33iDaPly3BuC0Ju4XES/+13nEj4QYaIxb17flkkQBGEg6E484bYMIQ4cwKJaXp6e97Lgw7GxjZk3OYsoW8vl5+sYaSNGYP4VFISx6qRJHXuUsLFMUBDmNmVlOBbH8j59GmPdhQsxttizB2PZ4mL08+PHo0zp6ZhHFxVhTsxtYrOhvoWFsKLm8a9xzrV7NwxblMJcpqYGdfR4IMix5d+556IsPY3V3N6coa19+oba4Xkfz1liYzHnKytDjPHwcO+5pNHzwTg3YCOfF17AfjsSeY0GAL5JJFgQragQA4D2OGOFubYu/Nmz/cdss9uR8bK4WAe8tljQMQUFQf1tasL7xkatyvNNz+KNUfDgzrO8HIr4l1/i/7Aw3PzFxUSffIKbgFM5GzvY9HQITxs2EP3iFxB15swh+t//RccxYQI6C6cTFguzZ8MFr6IC4l17gUF96Ux8qi+/1B2CxYIym0xYpdi5U7uw3nef7mQyMnrzrGpYyNiwAea0nGCBk0sEBKBdWYTjc2kyaVdljwdtxG3IKb+V0vEF2RqK49FFRsLyjgjXQEkJtueVFY45xxlbefI6YgTMsf2dh+xsBC3NzdUpx9PTtbDDK2NHj0L8rK/X++Wsr+ze43DguIcPwzLv2LG+FWkcDjwIs7PxPioKD68VK/zXtavZpfqbrpbP36plTQ1WtXbtQjucf37nk3zwwGn3bqJXXvEW6/Pzif75T5y/73zHf2zLwdy2wtAjNRXPrs2b9SprW4YDlZVEq1fjPpDMv0Jv8tJLGNN0BoeDaM0aSUYiCMLwpKP52siRWDB/7z1vzw5fQwiPh+jppzFe5DkRGylwtk72ImPjEo7XPXKkNkwJCIBH0WOPYY7UnkGGy+UdwzwwEPOaU6dwjJgYnTTw6FHtAWWzYfuFCzHWyMnBGHjFCqIHHtChjXg+zMkHOfOpMZSSUR+or0doGqcTdVUKZYyKwv/swsvJ7aqrexaruSuWjr60F2qHSBsGhYd7z71Zi3C5MB8pL8dv2PPv9dfx3igMtiXy+jNe4CQSSmF7MQBonzNyaNLehZ+fjxuuoKB1zLagIN2ZJCWhsygo0CsEI0bg4jxwQKvyTU068KGv4GHsPMPC4HPta/ZJhO+MohyRdpE9eRKiR0EBLLYuvxzmqNyp+Apw3XENJeo4PlVQEDrJxESiJUvQBmVlaNfqanTYUVEoI6fR7krmT6KuuwOmp0OwLChAhxoV5Z3ZJjBQrxJwR8YZg1h0q67Gi1fi2TybE2nU1WnT7NOncd5TU4lWrkRbff01xK+KCmzPx2V/e48HbZeUhOCsF17oXae33kIikeJiXEMOBx46bFa9ciUCpJaW4qHF+zRa6LHrLVv+VVejLPPn46HSFyKN8R4791y0LWdq5Zh37Z23rmSX6m86Wz5/q5Z835aW4po4dAirXFdc0bl6GU37Gxt1v8B9i7GfGT269cPzrrsGd9sKQwuzGf1TVlbnhJE9exBD829/EwFY6B08HlgLd9Za7uabETNJEARhONLefI3DMx09Cmv3hIS2PTiOHYNxCHsIcVI8i0VbydXUYA5js+FvYiLmD/x8HzkSY4OqqrYTKzBvvYV5A7ucEuFYZWX4PzhYe5ZZLHpOXFuL4xPpeM+TJ2PexLG3WSgyzrOrqvDbiRMRM9do6MD6QHMz5tgOB7bnOGlms072SAQh8fPPYaHHnlhdpTuWjkbaC7XD7eTPEyo/H2O4sjLMSdgiMSYG58/t1pZzvplbfcNzDXbjiqHAGSfMdebCT0rCRZ2f7z9m2/TpEN0SE/GKiMBNedZZWgRxOiGeuFzYHxH2bbwofTtPX7NPiwUxwYi8O9jSUqwoOJ36JgwO1sLid7/bvl96d1T8juJTFRXppBJxcahLZSXKaTJBFGtoQCceEdFxJ+Mrwhkz9HTFHXD0aJyXnTu9Vw4Yt1ubIXPGWrYwY3dc40oRZ+Nh68jAQFwTZjN+/61vtRY4pk6F6MYTV6PFZXAwzvmoUa1XWbKzsdJz8iSuIQ6oevo0ylldjQdIXR3qduiQFv04Bh4R3nM2JH64mkyIhzZhQu+INMbzFRyMiZLvPRYdjRWlzmR87W58wf6iM+XzF68yK0ufL4cDv/38czywOitS+1sNZdEzPBzn2+g+7/vwHOxtKwwtJk/GYtDKldoyvC1cLojK48cT3Xtv/5RPGN4cO4ZJgL/4rb6MHEn06KP9UixBEIQBoa35Go9BnU7MW9LSMDdoy1Di4EFYT7GXEHv6GOcXHg/mZCYT/paXY/E9JqZtQw5/vPUWFo6dTswhiTBGranBuMHhQBlqajDOiIzUFnr+YOuw2trWQtGcORDtCgpwrNWrUe+jR4n+/GcY3fB8vqQEdUtJwVyMkxfU1uJzhwNzuZAQzINLSzHP6Y6rZmc809qzxutuKKDduxGf1WbDnCEgQGetZS9Bu93/+M5fPPLBblwx2DnjhLn8fFzYYWEQzoymnnzhl5cjQUFWFi7MEycgLBljtnE8qdmziS66iGjdOohQSUnYbtIkZIJxu3GMiorWF6W/zpPNPvkmcrtxk9TU6En3jh16IMqxfY4cgbjz2Wco97hxEGk68ktvD1+xJS0N7ndt3fDBwag714M76pgYXQe+sdvrZHJyEIByxw6dSMLp1Ksgvqa9bJ3mmx6c3196aWv1/uRJnNuRI7Hf+nptodjYqGMkcdxAfvDY7fr88rk6dAji2223tc4slJKCFZrSUm3y7HZr11azGWVKSMB+uHPzeOC+WlKC7x0OfO5yQdg5fRptevw4HghTp3o/vDgRhHGyYoxvl5amxZj2RJrOWCn6uoW7XIhHMXVqzzK+die+YH/SUfnailfJ8S08HlzHKSkQ0jobl8LfaiinRWfrXqP7PFHrh+dgb1thaPGjH+H6fffdji2XlCJ66CGiGTPEcknoGTk5CFdRXNz6WeOL2SwurIIgDH/8CTTGMajVCg+vqCh8156hhNuNsWRwMJ7tNTXYhzGZnVGo47jHDQ0QvZqbMXeIi8N41x8uF4wMnE54HJlMmB/wHKusTO/T4UB5Kip03LKAAGxjzMZqtA4bPdq/UHTeeTrxwbp18HDasQN1bWxEG9rtOrZebKwWCt1uzMnNZpSNrQbZc4wNcrpCR55pHSXl6461mscD3YDrx3HgOGstWzvGxOjvjLRlhScGAN3njBiiGMWF7dvRWfHE2DcDKl/48fFQ0TMz/cds44s8IwNxnWpqIPQcPox9pKYSXX01hLv4eP8XZVvqdmkpBpxHjuB3ViuOd/bZqMOBAzpjC4tFBQXocEJCcPyEhPZXQjrCXwy+qCgISv5u+NhYlIdTIxN5iwVGl14mKAgrMjt26PY4cADWF/v26ZhFZWXYV3IyBMewMG3huH070e23o9NvaICVXk0N2iEiQouTS5fCjYo75fp67OPb38b5YSvF4mIkr+D4bx4P9hMSol2Mi4p0SumaGhxj+nT8vq1sOdnZaKeQEGzPq0zBwShfXZ1353bsGIRdvn7r69HWp07pc8/CW1UV2ovFOIcDfzl7sMmkLf84Y/All+iytiXSdCZpgT+38GPH8H7fPtSXk48w3cn4OhQxCu/GeJV8n/M94XB0Xqz03S/fazx44Oy/vveaZFwV+hKzGQsTX36J51dHNDYS/fKXcN0XoUToDvzsOX4c/WpjI57/bQnDmZlEP/5xvxZREASh3/En0DQ3Q2RxudBfTpyox6JtLZhPmIAxI1vYscdQQAD+50ys/B17GlmtGHOWlGCexiJVW+PP7dsxd46Lw+8bGjAn4jEsGxvYbDrWd20ttq2vR92++Qbzt4kTMTf3tQ5rL7kFz2GCg3UiR2MCxpgYvI+OxnOGwxlxXD0eh5eVYZ7scOhwMl2hI8+0zozju2qtlp+PdktKgsGH3e59XURFYUzn8bQuU0fxyMUAoHsM+yExiwvc4Rw+jJty5EgIBmyu6XRi4Gaz6QvfbEYgyZEj/cdsy8ggevtt3Ixjx+J9URE6Q7bUSk/HcZ1OZML0dS317Tw5Y2ZFBTqBefPQQf3737AiY3dQiwWfsymty6WFmIAAvI+O7pxfur828xeDr6AAxx05ElaFxhv+kkvgamoUGVksaGqCeJSYiLoT4UbftQvt9dxz+O2ECRDqvvwSv42IQKdXWor9nDwJEW/xYuyfU1xzUM6CAlidsYg0YYIWPtmybtkyHKOkBG3C4ib7zVdXo47h4WjLlBR0RtzOBQU47pEjeIiMH482OnECbeZPAE1PR/yCX/4SDwEinKMRI/RDxBgQMycH5tS5udpFkcU1FuXYNTUwENdxfj6u3YYGnWSDM7ByPDuHA4LtRRchwCdR2xZxnQlAmpbm3y08OloHeM3NRf2M1gw9FYm6GmtwoEhJwTX4xRdoP6NorZT3PeF2d16s9Cfoh4frwYNSuLb4XpOMq0J/cP75ENpeesl/5mlf8vKQ6ev66/u8aMIww+NB8pucHL0oyM89tmhgKw6zGd4EzzwzOJ8TgiAIvY2vQFNSgjFoairGjZ1ZMB89GnPQl1/G53Y7nu0swimlkxzabNoaj+OSNTcjM2pRUfvjz5ISbXVGpMU3iwXv7XbMGyIj0c9XVaGsoaEoF8/bT57EfDExEfX0tQ7zl9zCOIdxOnWm2dhY7OvAAcx1nE4IWBx/LS5Ou7larZhrJSZiTlhR0T3Dg+66ovrSFWs19q6ZOhUJQYyJMXjuHhoK99ycHJxbjhleXo79Ssy43mVYC3PGbJXV1RBTamrQYRw7pm8+vgFzcqAOz5rlfeH7u8iTkogeeaS1KJGcjO/27yf6y18wWf7yS5ShtlZb02Vmassj7jxzciBWVVXheGzFV1qqhSfOrsnZQU0m7etuteqsn2wy3BXXQY8H7eLrY0/kHYMvNhZl5sQIoaGolz+X0ZAQ7IsDjBpjbRUXY8A8YwbK/fnn6BiCg9HpmUw4XyYT9lNTg/JVVkJIy83VVkccUN9k0ubGeXk417Nn47u//AWi0cGD6ESPHYOQd/bZOqYBkY6jEB6uRTkiPDSsVnTcGRkQP2JitKjXngA6eTLRH/4AF65Tp3CdJCSg3sbYg7x6c/y4TvTAgUabm72z/vL1O3066svZj9i8nB+gfG3ExqJTX7GideYho0XcpZdCKO0oAOlVV/mPhxAersXC0lId64zbticiUWes+AYLnADl8GHc0/X1KHNUlB6E8D3RFbGyLXP1pCRc00rpgZEEXBX6C7OZ6M47ibZuRf/VEUohS9sPfyjXpdA1nn8e4xR2qWKCgtAXVlWhj+Xx1po1eAYLgiCcKRjnrrm58P4aNUov2hppawy6bBlcHU+e1J44VquOuW23o5+NjtYx3diK7NQpHHfs2PbHn/HxmLvw4rXVqmN885yLjVFYmPN4tAFHSAjG1xzfPTERhhgdzQl8Y7oZF7hjY3VW2YwMzCM//RRlqa3F3ylT9Pibw2JVVXXf8KA3Eyd01lqNrfQCA/0noIyKgoHBLbcgDuAnn0B4JNLfCb3LsBXmWAk/elRnX3G7cRE2NeGiO3oUF154OG6qI0cgtvi78Dkb4rFjuHA/+QQi0ujR/uNoBQXBmi4hAeKKy4UOpL4eglFDg7eLaVoaLGsefhgiUVJSaxGLMy6ymyWXi10u2fXTbMZNHBmJurLlVHsKPgse/nzsjSsroaEwOx41Cm1x8KC3QOLrMhoTo02nGxrw2c6dqE98PEQlqxUdYFSUdulkuINmS7GaGkz6ysvxoAgMRPty3TkRQ1AQ6u50QiAZMQLnY9w4lDM4GNt89hnRli3IUJqSglUCfiD4Wno1NMDU12xGx33qlLcrdEcCaHo6rEP++U+c+6oqlN+YMXfdOlyvs2ah3PzwY2tITtygFMo/bRrOT0YGBODISB2PwWTCw4OzCQcF6fq0ZxGXnY12Hju2/RhxfO6DgnAOON4Dm8mfPo02Ki/XyTV6IhL1JI14f2Ms69y5uGazs3E/V1Vhsjh7to5X2VWxsi1z9Usuwf4qKnB+JOCq0J9Mnkz0298i8yX3ye2RnU307LNEN93U92UThgebNyPcRXk5ngE8XuCFwthYjKHq6mBd/6tfiSgnCMKZCQs0KSlw99y509vggMj/GNS4CB4XhzFlQ4MW4xwOzBNsNp3oga3Impt18sPp04luuKH98eecOZib7d+PuYLdjnlFTY1OthcXB6utoiKUJTgY89D0dO+kiU1NeHUm8YRvTDeTCXMXp1MbxDQ341nT0IB54hVXYC556JC38YpSmAfl5KDObcWY68jjp6uuqJ3xIGpvG18rvfnzdVvabDj+rFkQOxsa8DcjA/M8DrPVlreY0D2GrTDHSR5qaiBK2Wz4S4QbiC2Q2ArNbEZn9b3v+b+4cnKInn5aq8VNTdhfWhpuTqN4pRSOX1eHC7y2Fh0Hq+ilpThmaam2sCLChL2yEttUVuLCZ3dGk0mbChvhuGGcSdRigQC4fz86MBa1HA50mBkZreuWnU304IMoDwtWvj721dWY6FdW4rVnD7aZNQvl903GcPXVuhPYs4foySeJPv5YC4TR0fidrzk1mwQ3NqLMbCbNHXRjIzLImM0oL1uIceZWFrGam3XMt9JSfFdXp11TidDJBwdjFWTvXhzX4cAg/vhx7TLMJr0nTmCfoaFoY86Syu101lltp8k2PuT4OkxMhJBy/vkoJ4u+ycl6tcJu1wkw+NpiFx2TCWU6eBAiZVOTjmEWGQlLRJdLm3mHhelycMwzfxZx27ahTv6uFSJt8k6E9vj4Y+0+ZBQqp0xBu9bW9lwk6mka8a7SE3dZf2UNDsY1cuQI2qywEGXm/qk7YmVb5upEPUvmIQg94Uc/Ivr734k++KDjbV0uWBHPmdN2fyMIzN69GF+cPImxT1WVt6VHbS2ekZmZ6FfvuQeLIIIgCGcyXbHG8l0EHzUKC/XbtmmDhNhY7XoaFKS9dCZNwtg/NxcC1YMPdhxH1mqFsHPXXTCYiY3V4XBKS7H/efMwZ2puRpnPPhtiHs8F2CvH5cJ8ozOupP5iusXGasuxkycxb6ytJfrWt/TcJTkZ7ZOTo0NQ7d2LdrRaYXDxyCOtPXk66/HTWVfU9ryeOCFiSQmMew4c8H9M3+uCXVVrarSrKoeqKi9HOxhF3bCw3p9/nekMW2GuuhoCWlUVxBv2DQ8IwI3DgSubmzFw43hz06a13ldODtF996FTIoJll1LoQHJzcdOec44WmZxOLcyxwFJTg84lJkabx44ahX1/9BFMRN9/H+LM7t3YNiEBN3xQELZvaPDOhMNwsGN2WayqgkgTH49jlZSg7q++io7NmMG0uprojjtw03L2SA4AGRuLjuaf/0Rd2ISZ3Uc9Hoh6HOCfBZLNm9HBcgf/7rsox3nnoWxff43O4eBBdL7cbtHRWnxkc+iyMrxn4YcDjwYGol719d5Wg+XlKB9bFXKa55AQlMFojUeEVZiFC3G+brwRHVZtLdHatUhe4HRiO6XQ/nY7OiqHQ2duDQrCdnv34lryNWHmh1xpKYSzwEDU5eRJon/8Ax1herr36k1ZGa5RhwOfWa0QdFhkZXPu7du1VWJqKvaVm4vjcBw7zmrLsQO++grXSlvWnklJcL8sKsIDyBeeCLHl4MmT+I2vUBkdDaF72TL8pidCUE/TiHeFnrrL+pa1tBTWjI2NEIPLy3X8vZMnYWW6YkX3VsLaMlfvbjIPQegpZjPR738Psc13IckfJ04Q/fzncE0UyyahLXJykLyhoEB/xiE9amvxDAwK0vGHFi+WwNOCIAhMZ6yx2loEHzMGc9atWzFHHDkSc4/sbIxjiTC/SE7GHGDsWFjKdTa500UX4e8f/4j5R3Mz5kqRkRjf19RgYXvyZMzB4+P9Z+LuSlgYthb75hvUh+eLMTFIDPj114gZ94tf4FnC429jO2ZlYa7ocqHuGRkot68nj9EAJjkZx66ra9vjpyNX1LY8iD75BCJZYiLmHEePYm7mz4iGj8n1MRofEWlX1aKi/pt/CcNYmOPkDSy+sSsku3ayBZpSWAGw21vHliPC7zZsQGfU0KBjfAUFaXGE/ejZ9bGoCEKgzYZjGdNMNzbihmHropMnidavh0hlsaATqq1FOY8exf6Sk/GehSl2tSTydmkNCMBxGhtRV7MZIkBYGKzejhzRGUwbG/E6fhzlT0iAeNXUhN8cP46Oqrpa+8xHROB/lwsv7giMdTfeoCkpuoOfPBnfV1airoGB2Bf/tqwMv3O7dd25Xiy68fk4dkyLiLz9sWM6AYbJpEVKbveGBtTHGFuBBau6On1euFO5914k29ixQ8fwczjwt7FRrybU1elsqKWl6Pg8Hoh0fN43bECnbLXC/JnPfXQ02pdXGoyrN+y23NioU4DX12vTcZ6QsIgZEoLrxGbDcZub0bZK6VhnfP3U1+s4cB6Pd6ZQIi3eFhRol2pjmxUWwhqPXWfZcoEDhoaG4oFvsWDlpjcsFnqaRryz9Ia7rLGsxhT1oaFoq8REncmXrWnZatZYjt4U0YaSG7Aw9MnIwOLMffd5LyIZ4X5aKQyMf/ELxOEUyznBF48HkxrOVE6krx1+8djO5cLzU2JqCoIgeNORNVZ7i+BmM+bJR49CsCkpwXySn/EcmqW7njEXXUS0ZAkMDkpKIL6FhiJJVG6uzsZ6+jS2+da39PyIqOthYcxmJD144w0YLNjteIWFYU6VmoqwHP7mMOnpEO1Wr8acKj3duyxGTx6Xy9sApqREexZ1x+OnLfG0sRGflZRAD7DZ8Lnb7d+IxveY7Ko6ZQrqwq6q//u/mOONGuW/PL01/xLAsBXmjEo4u0VyJsumJmzD2VcKC2ES6zuQ83iQYe7VV7XFj82GfXBSAnaRPX4cN6bVismuyQSxq6IC+2Ervbo6CGGRkRBPiot1WmiOi1JYqK3jGhu1tR8fj106jTF8LBadKIKt6lgEmDgR27AlU1ISbrCPP8Zn7PJpNqOdUlIg4uXlYb9uN/ZXXa23YWu2uDj85QD/xhvUXwdvDK4ZGorf5uWhk6it1X7rNTX6PPFv2bWVxUKOmcadNZEW8iwWfb5Z2OP9EaGdOMhlfT3a94UX0L68grB6tX54nTiBWEgxMciQe+QIjh0YiP3V12P///43sq82NqJzbGrSsRYCAnA+oqP1ubda8YBhIZN9/dPT8XA4cULXk5M9WK0QBTkRCAci3b0b7e92429hIY7NiSwCAlDfU6dwbHYFDgrCA2bKFByDMzeFhmqT96AgnLPCQpThrLPQXpMno66+AUNHjdJxJ3qD3kgj3hG95S5rLKvHgzarq8M5Y0HVasU2SUl4WBtXmnpbROtvN2BBIEKsuU8+wXPGnzjHggoHlP7wQ7j1P/MMnsWCwHzwAbwKeMzDoi6Rvrbcbh3z9NprZaFBEATBH+1ZY3VmEdxuJ/rBDzCvqK7W2/bUM4YIY+P58/G/cSw8fjzG0Xv3Ys7IyQDHjNFWal2NYZ2Tg3hxkZGYC3HdCwsxf7/gAux3717/9SosxDxvypTW8xI2VNm+XbuSRkfruHU8H8/MbG3Q0pGnjL+5NRsB1NfDCIWt3tgTjee87RnRtOWq+tVXqGdNTdcShwjdY9gKc2YzAu1v2QKzWJtNixA1NTpZQmAgzDW///3WvuD/+AfEh7IyfFZXp8UxFtnYpa+uDtZQHKNt/Hhtucaxz/i3VVW4oYqLdeZMo9LOcdLYSq6yEvux23HTcTYaFu84ECevFCcno6NISMBN5XSic+CssByzraYGro5Hj+KmCw7WGVDj43WGR7dbp8G22bTFF2dEc7lQVyLvG9RfB28MrsnWdzk5Ok11TAzcibdvx2fsPms2o0OoqcF+eFIXGYn2aWjQn3PcOc5cGhWF8p06pRNxZGXpDD9NTRCb8vK8g1gaH16hoTgHDgfah4/R1ITt2IqNBUnOKNvYqNOMs1UdW7XFxqJMR4+irkZff45dcOgQ2slsxj5Y1FMK+zKbcb5DQ/F5ZSWO29yMv2xJx5k/i4r0tVNcrAXcgwfR+c6fj/aZM0fHFcjK8s4qHBiIh9mpUxDgwsK8g69ylqZDh3pvBaW30oi3R2+5yxrLajajndgt2WzWgt3+/XgIGuMS9oWI1p9uwILAmM3oT6+4As9gf5bevpSVES1fDlfYn/60/8oqDF6ammBJyYuhHDeXFyAZfj95MsInCIIgCF2jO4vgnByxq2Jce+FafMfCZWVwLeVY4Wx0UFCAucyUKZi3dNZSz7j/OXPwmTHpQU4O0VNPaQ8zf/HbTpzAnLwtETMoCHOnkBBsExKi53JsSJObi+OfOAHjipde6thTxt/c2ulEXdgIw2iAZDLhXJaWor3sdu+kkB3NEdid9cCB1sJdb82/BE23hLmnnnqKHn30USouLqZp06bRE088QbNnz25z+1deeYXuueceOnbsGI0fP54efvhhuvDCC7td6M4yeTLRbbfBpaa6WgtqUVG4OUJCcNFzdkuGVfrjx3XckoYGXOgej7acY4EjPBxC3G234fdsWfXVV9oarbYWAhO7WhLpJAKnT+sUzCdOYJuICByrqgrvOf203Q5Vu7FRT/bZvTIkBELbrFlYRSgtJfr8c7jLnjypExmwdZnLhbZgl9yGBm0BFhSE7dm6JywM37ndWvwJDNTxz9j10niD5uf77+A5uOauXegkTp5EG7J1H7cxW4R5PNoSrrFRr5Zz4gsWpdiyLzhYd34c04/bdf9+7f7J9Q4OhlthTEzbwgeLLZ99pi3KuA3NZoh6Npuud2gozoXTiQ7N48Fx6urQebIVnMOBbViYMcYuyMmBEGcU84jQTuXl+DwyUmdY4s6+sRH1qqvTpuUNDbieifQqF1vxsahbUgLBbf5874fb/v04ZnIy/tbVoRM/ehQC7pgxOD4HXyVCnXpzBaU304i3RW+5y3JZ8/MRP5L7ECI8CO12rGjV1raOS9gXIlp/uQELgi+TJxM9+ijRz36mrbk7ytba0ICg/fPni1vrmc7mzYj3umePHg8QtbaW478BAYgV29m4RoIgCIKmM4vgSUkQkA4e7H6olY7CtRjHwkQ6JExsLMrEHmazZmH8mpZGdOedne/7/Y21eQ5TWgqxjz3MRo/W8dvefBNGL3Y7nkl5eRjfjxnT+hhFRfjdpEk4VnMzfkekxbKyMu259vLL0Bk68pTxJ542NGgDGg67xQYqXNbiYsxhOewVJ4Xk37c1R2BjnZCQvpt/CZouN+Pf//53uv322+nee++lb775hqZNm0aLFy+mU6dO+d3+iy++oOXLl9ONN95IO3fupMsuu4wuu+wy2rdvX48L3xluuIHommu0C2F4OMSMceOQsMFsxk3DSq9RRU9JgSASFqazYLpc2lKMXUpNJmSIWbQIHUtgIF6ZmbihIyK8tw0JwaRjxQpc7BwfpawMN1FQkLYSczhQ9qAgmKaGhUHwSUzEzTFyJPY3fTpcgK65RrvLZmXhhg8IwIvdhjgbpNWK+sTH41icYMLj0bH52EWWCGUPCNAdQX09Oq6oKLzfv9/7BuUOvqCgtYVETAzqsGABJm8LFqBNYmPRifANHhysBUh2OTW6sbjdOvNoQAC2jY7G+R03TrsM2+3ouDndNru9JCbiPHFnbxQ+jLDYEhICIVUpHNNqxXuPB+eF24WFN6tVJ25gi0aOaaeUXm0xCljp6USrVmFCsn490YUXIqbb3LlE3/kO2pWvBY4hwJhMaFsi7ziDbHWXnKxdKjkGAVsasFuw0wmh2ePBQ6ixEcdOTtYi7Vln4bfffKPj/zH88E5P790VFBYtZ8xAHQ4exN+ZM3snRprxYeePrphrp6cTffe7uA4cDohezc24fkaO1Oe8sBDXILdTZ0S0tjL/9ke9BKGrXHIJ0Z/+BAHaYuncb8rLiR57rHXfIpw5PPUUxm+7d6PvNGK0ljPG2V28GL8RBEEQug7PddhQwenE3MXpxHuLBXOo3bt1fOSYGAhInKm0I9j4ZefOtvdhHAsbrcG432fvLU50ePhw63lbe7Q11maX0OZm7WFmsWAeVF4OEbCsDFZko0Zhu88+w5zbdz+FhdjHuHHaq8g4F+Y6FBSgLI2N0CPCwnBM9pQpK4PBCI+HfOfWpaVYvOLQUEePol3Cw3HM2lps29iI8kRF6Zjsr74Kca6jOUJcHDSLvpp/CZouryv+/ve/p5tuuolu+M/oZ8OGDfT222/Tc889R6tWrWq1/eOPP05LliyhO++8k4iI1q5dS++//z49+eSTtGHDhh4Wv2PMZgRvbGzETcvinNWKG8xX6TWq6CxeREbqzKBstcU3kVK4IC+/3FuM4tWG+fNxY/D2HDj/wQexfVYWLnDOPmq366DGbG3H2TY/+wzlT0tDR1RSgpstLg7x0CZPRkdRWEj06af4fUKCdm10OFCvujrUPToaCnpoKPYRHY0bsKoKVnF2O27guDhsz+VjoY+t/+x2CEW+AT87snKKjSW68kqiv/1Nq/tEOg4dx2izWPCe3VU9Hj3BYxPjwEB0Em433nP2VU7wYLEgftEFF6AuI0dCNPFNfNCe9VB6OjomdtFkcZOz9IaFod2I9KoIp86urUX7BQVp1+CqKnTMY8a09ttnN9rRo/EA4JWlU6d08oZJkxDrjrOt2mxoL46/N3o0Hgg2G8r7zTc6iYTVqlds2PqwsRHnuqgIrsRJSe0HgZ05E9t9/TWuyf5YQelsGvHu0NvusvHxEDgnT4Z1aGMj7jG2tHU6cR6+/W1d/r6IpdcfbsCC0B6XXIJ+7vvfR5/SGf7f/8Nv7r5bVmLPNN58E+edn7FG91WGV/xdLjy/xo7FYpZcK4IgCN2nreytM2ZgDnLiRPdDrXQ2XMtVV+mxMBs2BATo/TidmHdyQqC6OqLHH8d8vzMiUVtjbRYBHQ4dNsqYxG3kSB0KKiICRjlbtiC++IIFWHw3znEDAzHn4hBOxvkazyM5UVxysndIIJ6f+nrKGOfW27djztbUhDLX1GjDkOpq/D1+HGXn+Ud5OfY9ezbK8+WXmGfu3t3+HOH88/Hqi/mXoOmSMNfU1EQ7duyg1atXt3xmNptp4cKFtG3bNr+/2bZtG91+++1eny1evJjeeOONNo/T2NhIjRy0jIiqqqq6UsxWpKcj45tR3PBNEc0YVXSzWScqGD0aLpeVlbgB2DV12jSidevaF6NCQnChl5dDKDGmkL7iCrizff657iCam3EjKwUrrPR0iIOc9fP0aawOOBxE553nXQe21MnKwmC1okILW0SoFycPmDYNIs6JExD0zjlHi31jxqCu9fUoV2wsOgxOyhAQANHv17+Gf3xbN2hH6bnT0tApGEUDkwkWgMeOoa7sjspl4AG6xaJFPCL9HQtTSuH3bjc6oMsvRyfJATi7I3ycfz7ExC++QH0dDhxn61a0S329tlQj0vHWePWFLRGbm2EpFRCA9mtPFPEVo5xOpLWOjUXdfRMvREVBEEpLQxtOmqQFVb6ujBZ/3AkHBKBdSkrwCg9v33qL4zyMG6dXktq6r3qTjtKI92S/vekuy3EJY2KIzj1XnyeebEZH65iKTF+IaP3hBiwIHZGRgQWkG2/0dktsi+ZmuLT+859EGzfKiuyZwu7dGK9VV2urbg4j4gsvDsbFwbp88uT+L68gCMJww98iuMeDTOs9CbXSVuICFqTCwjBOJdJj4REjdCgoux1j1/x8PB/Cw/Wz4dAh7zjh7dHWWLuxUcfxHjFCW50Z47dx/HAiPHvmz8c8nq0Fg4PhVXTppRAZP/8cx5s0CWNu9mKqrUUZrrsOc7pduzBn5zju0dFoU4cDv3E6vc/PypVINuh04pjs3edwYFxfVaVjobNBTX29DhvFHmq5uUQ//CHmcJ2ZI0gs6r6lS8JcWVkZud1uio+P9/o8Pj6ecttYBi8uLva7fXFxcZvHeeihh+j+++/vStE6pLOWNr4qOqvctbW4WKOjceMkJGB/d9/dejDYkRhl7DDS04nuvRdxeN54Q2c+DQzExT9rlhak4uIwYDWb269DfDzEkoQE7T7Z1AQBrLRUZ4VRCvVh4c4o9n3rW7BkM5lwY3JctMBAtAtn6vyv/+r4Ju2o7f2JBnY7xEG3G6+SEgzQY2IgGAYEYNuYGNTF6YR4GRODevHlFRUFUWTFCpTD4+mZ8GE2Q5hjc2Yub0gIViXi49GmVVXaao7doUND0dnGxmKSWlWF/zsjihjFKI8HFpG+VpkctPTECVw3l1xC9OSTaNeRI9EWhw7pmH28qsLWmSEhaOuAAJ2mvCPrrbg4xFbs6JocKnTl3u2Itqxnfc+T8VrrKxGtN+slCN3l6quxkNUZdxfmq6+IbroJoRrkOh3evPkm4hEWFekQH263zmrvmzyEY/usXYvnnSAIgtA7+C6C793b83jFvi6knAChrEzH7OZjcazmgwcxVyktxTyG42WnpGCeVVoKEe2sszC2aM9qz5hwYvZs/G8cazc2YrwdHo7xO8dwZ4u9piYdV50JCsI8lAU1Pk5eHsp2+DDqExKCOVNiIuYCEybg2VVSAvdTIswfAwLw/b59WKgKDUVdXngBcwceBwUHY66WnKzj3jc1IUlDWZn2zoqPR9twnHqjpxifs/h4mSMMFgZliNzVq1d7WdlVVVVRMkeA7AGdsbTxnUxzooLcXNxgFRX47Ior2g902RWXu/R0ov/9X3Q4WVnYLiZGZ2o1CkZsxtoebKkTEICbnOF6nDypEyCcey4GtJxlhstJpC3Zvv1tiEhsXhsWhs7PGJuvI9pr+7ZEg4suguj573/jc48Hbr3HjkH1J9IZcy0WlPOee1D3gwfx+YQJ3m3WG8KHv/LGxKBTjohAB7dvH9qZCJ8lJcHt1GbDOXG5IMp0p8NrzyqTzad5v8Zy2u06uy+7A3NGXb5WiovR5nPm4DidETE7c00OJXrLXbaz56mrVqbdfUD2pRuwIHQGqxVhHK66SmcNawt+9ikFd/lXXiH67W/leh2uPPUU0W9+g7GG0WXV7dbZ1jmzL7+/6CL8RizlBEEQ+paOFutrajCnOHHCey5pHHMGB+t9NDRgfldXh/1FR2Mf5eVIhLB8ObYtLoZ3TlUV/lqtOuZ1aSmEsYkT8Xxoz2rPX8KJqCgYLrDXj92OfRFpbyy7HcfiUEGJiTr8UGkpPKiqqzHHHjECdfv3v4n+7/9QnrlzUZ78fFjFKQXDmbg4LEZxgj+3G38rKzF/5JjqtbXwgsrL87YIrK7G/G30aO/4vWzMwwnm7HbUNS6utaWj0Uts9GiZIwwGuiTMxcTEkMVioRJO4/EfSkpKKCEhwe9vEhISurQ9EZHdbie7UY7uR/xNpiMjYeF08CBu2BUr4NLYFSunjrBa4eJTWwuxiQeg3bGUactENzYWHd/XX+Mm/8Uv2hdVuB1ycrS1YG0t3ve2+1t7osFFF3l/XluLFZEdO/A/mw0bhVLOmtrWsXoqfPgrb20tOtncXHSAPLmIjUUnvnw5Om62RutJh9fZOviWs6SE6K9/hXsYx1EIC8ODrbgY5bzlFr3qc6a6QPaWu2x3r7W+EtH6yg1YEDrLZZchU/q6da2D+hsxJqRpbkaff/75RPPmDc8+50zmH/9AWIy6Ov/fezyYpAQGYnKkFNHUqXBx9k2AJAiCIPQ+7YVaOXUKnjwBAUTPPou+mhMDVlRoISwtDZ/v2wdLsvJy9OE1NfiNxQKPr9JSWJMlJ8OAxOWCpdzu3fhNbS2Ob3TLJGrbao8TTpSVeWc9LShAeRYtwvHj4zEP+tOfvOc9Rq8otqRTCvutqEC9kpLweWio9uSKj8eYOzgYx+Y2GTkS89QvvkA7jBoF4Y2tEt1uPc6x2SDkxcSgDK+/juO1JZRyNtb9+7W32bFjiMOanq7bSinUPzUVZT12DOd49GhtWZidLQJdf2NSyjdfZvtkZmbS7Nmz6YknniAiIo/HQykpKbRy5Uq/yR+uuuoqqquro3/+858tn82bN4+mTp3a6eQPVVVVFB4eTk6nk8L8yfR9gD9lPT297006e+u4xk7In6DS2SwqA9UOHWE0R+5up9Eb+2hvn2yqXVvbdx1bd+rg8RA9/zzRX/6CB5jHg457/HiIchdd5L39YL0GhhJ9ca0NVgaivxY6ZrCdlzffxOIQu6UY4SzoxoD/QUHob2bNQmyVjIz+La/Q+3g8RA88AJHWEFa4TTiLXWQk0XPPifvqmcxg688EoScMlevZ39wyPx/JCU0mhGxJSdGfKUX0ne/gMxbCamogGnFoJYcDCy6cYHDBAmxXWIh5RmSkPn5FBRZy4uKQeIE9yxinE8LdAw94h/9Zt65jQXHcOIhzEydi4Wf3bm0A4nbDWi4yEvsIDkbIhQ8+QBnmz9eCV2Ul0ccf66RF554LIbKoCNs0NsLr67zz8Nm77+qEio2NOJbFghePgRITcUxOevToo1io9Fev0lJ43xUXQ/DLyIAAWFEBYXDePNRz/36UNSFBW9Vx3ffs8Z7zTZzYvpfgQDFU7puu0GVh7u9//ztdd9119PTTT9Ps2bPpscceo5dffplyc3MpPj6efvjDH9LIkSPpoYceIiKiL774gs455xxat24dLV26lDZt2kQPPvggffPNNzRlypROHXOgGn6gJtO9ddzeElTOJFHhTMLlQkafkhKs6syZoy3lfJFrQOgsw/FBORwYjOeloQFuiBxfhfsUXo02Bvw3mXT/FBqKINS33NKvxRV6kexsLBB+/LG362p7sDXCgw8S/fznfVs+YXAzGPszQeguQ+l6Ns4t6+th8eVyQYBjb6HPPtOxQkeMgHDFi22vvQaRq75eP+s57rXZjPkIu2kuWID3jFIQw/yJdkpBbJo5E1b5PJ44doxozRqdSJBhAcvphDC2YAH+FhRAFIuLw3HYMyspCftkC8D6eux7/nzvMpaUQOyLjEQCwhkzYAkXFKRDCZWXQzDLzsY+XC7M0W02/MZq1Rldm5tR9vHj0SYnTkBc41D8RqE0KAjJCNm6b84ciIGlpThvR46gDcaMQTkjIjAGY+Od7GzUOSnJ+/OCgq4Z9fQXQ+m+6SxdjjF31VVXUWlpKa1Zs4aKi4tp+vTptGXLlpYED/n5+WQ2zNjnzZtHL730Ev32t7+lu+++m8aPH09vvPFGp0W5gWSg3L56042ut2Jlifvb8MNqxQOlM8g1IAhCb8Mrv8uWYfDJiWmMlnKMUtr1taIC1nbbtiEgsiwSDC3efBPC2okTnf+NyYTxy+OPI9udIAiC0P+kp0Mk2r4dglNVFT6LiMD3TieEILsd1l8nT8IyKzIS23IsNU4oaLHohAqNjRCZmpthTecb1cpkgqBVXAyhySgetRVixzfhBBHGE7m5sNJLSNDZUKOjIWRt2YLtFy5EOVicio5GBtP4eNTz6adRByMck662Vi8mcvIIIlgHWiyYm7tcEMpKSvC9x6P/1tSgnIGBaLOmJtQ/KgrfvfEGBEhjuJyDByGIjhpFNH26tuKLjUXbjB4NK8GEBJyDyZO1pZ3RBTchAe9NJpRv0iSInu0l1hB6h24lf1i5ciWtXLnS73dbt25t9dn3vvc9+t73vtedQwk9RAQVQRCEwUNFRQXdcsst9M9//pPMZjNdeeWV9Pjjj1NISEiHv1VK0YUXXkhbtmyh119/nS677LK+L3Afc8UViK/6zDMYfBqt5NpDKQRXPnGCaMOGwbWKK7TNk08inhwncOoMJhOsLt58k2jatL4rmyAIgtA+Rou54mJkAW1qwjPYZtPxlNkVs7mZ6JNP4A5pteLZbbNB+KmuhmjE4pDNhu8bGtDnc5IFI4GBRFOmILlfSUnHsZv9xWJzOiEAhoejfCwMKoX6WCzams9i0eLUvn1IRPVf/wWLuvHjIU4aXUnDwyHgHTyIMkZHY//Nzagfu8RWV6N9Tp/G2KemBi9jfF2HA8JgczNe9fVwa50wQSe5MAqlX34JsXHePC0EMvwcLSmBeDd+vH834Lg4tI3TqcVWk6n9xBpC7zEos7IKgiAIwnDkmmuuoaKiInr//fepubmZbrjhBlqxYgW99NJLHf72scceI5NvWq1hwJ//jJXbtWsxMHS7O//bTz8l+t73iNavRwBnWckdvDzxBNGdd3YunpyR8HBkbRVRThAEYeDwTaIQHg5LsqNHIUQFBEBoqq+HCGWzQVA6ehSCTkQEBKmwMMSLzcmBdV1YGLZlF9b4eAhSvigFy7g5c/AsKSzs2CPMX9KKxkaUy+XCmCMhAWVgwY6t0ozPqoMHkTyxvJxo82YIhAkJqJNvgryAALRNQIC2cissxPugILTdF1+g7s3NKDcLmfwigjDHAmFVFfY5cSLa5uRJ1N0olJaVwV21shKWhWPGeItvtbXaK8FoQUiEurpcaMvTp1s/p9tKrCH0LjKEFQRBEIR+ICcnh7Zs2UJ/+ctfKDMzk+bPn09PPPEEbdq0iU6ePNnub3ft2kX/8z//Q88991w/lbZ/WbkSA/wXX4Sb45gxbce89CU7m+jiixGcODu7b8spdI833iC6++6ui3JBQUS/+524rwqC0D9UVFTQNddcQ2FhYRQREUE33ngj1dTUdOq3Sim64IILyGQy0RtvvNG3Be1nPB4IQGVlELjCwiA4hYdD0KqqgiBktUJQamzE50pB7DGbIUI1NED4CQkhysyEBVh9PfZbUQELsAceQLbQ/fuxD5cLf/fv1+6qVisstzIy8LetRTmzGWODmBi9P3a3PXAAZSkvJ/r8c1gAulz4HVvREWG7Dz7AtgEBWpDLz4dgFxiIfRw8iHpMm0b0058ikUJ5OfZjMkF8mzwZVnTssutw4DlnsWA/gYG6LkpBCLNaITBmZsLCsLYWvyspgVC6cyf2X1eH9s3NJXrrLaJ//Qv15H0VFqJ9o6KwDyPsgltX5113ho8ZGtrjS0loB7GYEwRBEIR+YNu2bRQREUFnnXVWy2cLFy4ks9lMWVlZdPnll/v9XV1dHV199dX01FNPUUJCQn8Vt9+x2YiuugoWcM3NyB7dWVwurGJ/9RXR//5v6+zSwsDg8WBCc/vtGNjz6n9nCAwk+tvfiK68sm/LKAiCwIhVu3/y8yH4JCd7W2ER4b3ZDIEtMlILPOwKynHkqqogatXXI0HEggWwfisuxsJcXBzR6tUQr8aP15ZgHbmrdkR6uo7FlpUFl9TmZohso0dj7FFUpC3YTp/WFoEeD1xEGxshJrrdOotpSAisAUtKYNWdna0TXxw7hu0SEoi++11YnG3fDvFu/36MWaxW7V5bXa0zslqtWiBMSoJ1YWqqfn4WFiKGXFYWBL7YWO3Gyu6q1dVEhw7BzXjKFLR5TAzRddehHb74AmKfw4F6Gl1w09K83Yj5mDNn4jdC3zEkhDlOHFtVVTXAJREEQRDag/vpLib8PiMoLi6muLg4r8+sVitFRUVRcXFxm7/75S9/SfPmzaNLu2A21NjYSI0G86Sh9Pw0m2FB9+qrWEHvCkVFsLiz2RC4WVxbBwaXi+ill3AOv/4aAaeVaj2hawu7nejhh0WUEwSh/2Cr9q+++qplAe2JJ56gCy+8kNavX08jRoxo87ds1f71119TYmJifxW53/CXRMHphOCTkgJRiy22rFY8g4nwLKip0VZYM2dC/Nq/Hy+rFWLU9OkQjSZPxu96K4Ehw7HYVq9GmefNgxtoXR0EuuhoCIRVVahjWhqeVwUFGIcEB7dOSmE2QxQ7dAii2+efazdfdms9dgz1v/VWWI3n5yMz7b592orQbtdJJnjYZrVCSEtOxl+32zvJRWYmFq5GjoRAd/Ikjmmz4bOSEhz35Emd4faSS7DvsjJk092zB+2akIC2ZRdcFlE7Sqwh9D5DQpir/o9Dc3Jy8gCXRBAEQegM1dXVFO4vcu8wZNWqVfTwww+3u01OTk639r1582b66KOPaOfOnV363UMPPUT3339/t445GMjIILrvPmRf7arGW1BAtGIFBt4XXoisr511ixV6hscDS8dHH4Ulgcvlff46cy4DAyHK3XJL35VTEATBF7Fqbxt/SRQ4Lll0NESs2lqd8bOoSG+fmIjPOLtpeTnEofp69Pfx8dj+zTch/LBFXG8nMCwshGA1ZQrqEBamY7Oxy2hUFNG4cTqzbFWVjgNnt0OgMi4wBQdj23fewXbGRBC+GU3vugv1mT0b7Wm3Q8isq8OzMzBQx6ZzuYjuuQdl9mc16HJhwSsrC3HlOC6d2YwyjRyJ/x0O1OHwYcR5LSqCVePcuRAJi4vx3YkTREuX4rm7Z0/vWCoKXWdIDFVHjBhBBQUFFBoa2i0T4aqqKkpOTqaCggIK495kmDCc60Y0vOsndRu6DOf69bRuSimqrq5ud2V5uHHHHXfQ9ddf3+42qamplJCQQKdOnfL63OVyUUVFRZuD+Y8++oiOHDlCEZwe6z9ceeWV9J3vfMdvJnQiotWrV9Ptt9/e8p7P61DillvgGvL00137nVIY/P/jH4iz8qc/YaVa3Fv7Do+H6KOPEO/mww8x4WI3Jo+n8+LqyJFwCZKYcoIg9Df9ZdU+FC3a/SVR4LhkTU0Q6WJiIAZxnDR2Fw0JgfhVUwM30aYmbV3ncOA5MXo09l1QAOuyvhCB2OovKAjx8DweiHREKJPFAuHuBz/A2CM3FyIikbZE802awAkVysth7efPzdc3o+mcORD/9u+H62l9PbZzOPCb48dhsceLiv6sBj/4ABlhT51CPSwW/NbjwbZHjqDM8fE4H0lJqNPJk7C+GzeO6OyzYfXY0IBjxMZiMfPCC3vPUlHoGkNCmDObzZSUlNTj/YSFhQ27STQznOtGNLzrJ3Ubugzn+vWkbmeKpRwTGxtLsbGxHW43d+5cqqyspB07dtCsWbOICMKbx+OhzMxMv79ZtWoV/fjHP/b6LCMjg/7whz/QxRdf3Oax7HY72X2j9w5BNmzACvYjj3QtW6vJhJXnujqiXbvg3upyYdVX6D1YkNu4UcfWaW7WolxnMZmIzj+f6PHHtSuTIAhCbzDYrNqHokU7J1EoKPDOQhoSAiEpIQHuqIcOQdCx2SB+RUTAYotFMZsNIlhAACy3GhogFh04gMzqOTmwLktL6z0xyOOB0HTiBITBjz6CoMZx3mJiIDoGBEDEmjYNCaXy8yG4/fSnqCPHeGPxzeOBtVxKCgQsX9GO8c1oarWiLXftgkurzYZ9ulx4ftps2Gb9emznK1J6PHCb5eQaZjNeHOvP5UIbK4XxE1s21tTgvFVVQXScPx/nhwj1zs3V4mFvWioKnWdICHOCIAiCMNRJT0+nJUuW0E033UQbNmyg5uZmWrlyJS1btqzFwvDEiRO0YMEC+tvf/kazZ8+mhIQEv9Z0KSkpNGbMmP6uwoDw4INE3/oW3FoLCztnfWU262xubEF37bVEv/wl0fXXt5/FTegc2dlE//M/WLmvqMBkwei6yhMGIv9JH8xmfOZwEP3610Rr1sg5EQSh9xlsVu1D1aLdmESBXR1jYtDvR0RAnAsPhyVXZSX6fbcbog8vrDU341nBscyCgyFYHTuGZ7avdVlPycnR5S0pgVVeUxP2HR2N8hQVobwxMUTnnqstxOrrkdk0JAT/79uHckdFoT7l5XBXvfRSfGd08zXim9E0JwfuouPHY0xz+rS2Mnc4iL79bbR1WxaE+flI3mAyabdXThxBpIVDpWBRN3YsxD6XC3/DwmDB6HRqYc5XPBQGBhHmBEEQBKGfePHFF2nlypW0YMECMpvNdOWVV9If//jHlu+bm5vpwIEDVFdXN4ClHHxcfjnRhAlwSd28uf1teeWZCINrjr1SUwORb+NGuHBcfz2stEQM6jxsefDWW0TPPIPJFE+0+HsiLcSx5Zzb7W1tEBCAiUBCAs6JWDIKgtBXDDar9qFs0e4vKUNtLeLD5ebCAi41FeJSSgoszT79FFZabNmllLaaCwiAGFVdjVhnY8ZApOoNgSgnB+EVysog+BUU4LnjduN/tqwPDYUoZbUiQYLZ7P3b6dORMfaTTyDGnTqF31qtcIv9/HPU+9QpuKka3Vl9M5p6PBAKy8qQoMrjQXy6U6cg+DU14RUa6h2fjkW86mqUtapKl7+2Fm3mcmmrObdbu7iyNaDVqi3yqqt1ogmi1uKhMDCcEcKc3W6ne++9d8h2gu0xnOtGNLzrJ3Ubugzn+g3nug0GoqKi6KWXXmrz+9GjR3eY0fZMzXg7eTIGtLfdBhfX5mb/27EAxIKQEY8Hg9pXXyX6+GNY4l14IQbIYkXXPmx5sH073Fbr6nRw6fp6LcoRaQHO48FkgN1s3G68T0oiuuIKiKPiuioIwmBArNo7h7+kDOnp/uOSZWcjM7fFgs8DAmAh1tiI54HDgf8bG2Fpd/QoPispQRKo7mIUwCZNgnVYRQViusXFQTAsKdHurKNGwbKvoAB/X3tN/9ZkQvkSE/F/ZSXqMXo0RLRjx1C3yko8HydNajuj6bFjEDCTk7Gv6mqUISlJJ4MwWrMlJWGfq1ejvA0N2L60VD9no6J0Egm2niNCvaZNQ+w4pVCOoiKUlbPkErUWD4WB44wR5u67776BLkafMJzrRjS86yd1G7oM5/oN57oJQx+zGavYCxYQ/eY3CHDMsVSUwmCZXTr4MyJvV0qlMGgvLiZ6+224YkZHIwj08uWSxdWIywWXmQ8+gBhns2Fl3+WCe49x1T0gQMeXY7it+f+AAASd/sMfIIaKECoIwmBCrNq7hz+xzuOBJZ3DAcsulwvPALsdz43mZvxVCs+WuDgIUs3NWDwbObL7SSDy870FMI6zZrXiePHxELKmT0fZCwoQH+/3v8ezLS+PaOpUPXZga0CbDfXheHQRERDJHA6UlwjCWlsZTTnWHsej43IFBOC9rzUbu9DW12OMEhwM6//cXPyuuhrCnMWiFyM9Hm3Rx7lMTCZYzjmdKNuoUdiX09laPBQGDhl6CoIgCIIwpLj0UqKlS7Vo9OmnWG2vqcH3SulVY6Moxy4e7OqqFAa8BQV4/etfRKtWQfT7yU/OzEFqUxMsDf7xD7joVFbqyRNn4TOb8X9dnc666nZjUsETCm5zdmO1WDAZePhhBPkWBEEYbIhVe+/B4tjEibCSO3AAzwy7Hc9gjqsWEKBdYsPDiWbPhtjVkyQQvgIYH/P4cW2t19yMcYPbjedeUBCO53Ti+Hv3QqQLCIDYZrfDlTUwENu7XBDfOGbbrFnY509+ol1kfTOahobiNxyPjp+pzc34v6lJZ1a12RCLzuWCsMfx68LDEQuvvBzP57Iy70UwzowbHEz03ntI8pCSgv1FR+NZHBMDIdKfeCgMHCLMCYIgCIIw5LBaESvu7LPhZvnQQ3A/aWpqHeOFyDveHJF2rTTidmM1+Wc/I/rtb4muvproyisxsB3OVnQeD1xs/ud/iDZtgsuPL2YzJjQNDdrqwWbDe45rY7RaNMaYCw1FPL8HHhDXVUEQhDMBFsdCQiBa1dTA4tpo1U6EZ0Z4ONxMJ06E66Xd3r0kEMYMrJyJNDwc44KaGu1qy8/zEyfwm8hIiFdsfRYVhW1zcxHfzeVCmYziF++DrdysVn28ttxwU1IQL/eLL/C/3Q6xrLgYwmB+Pvb9zTfasj81VSdpYOLiiBYvhiV7SQmezWYzyh4XhzFLZKRetKyvh1h37rmIo8dJN/yJh8LAMYyHmYIgCIIgnAmkpyOpw7e/TXTXXQiMzPCA02z2TgrhK8r5UlFB9OSTiGc3eTLR735HdNFFfVL8AcHlQuyar78mev99/O9PkGM4kLTHg9X96mrtntTcjElFUxP+dzgwKZgwAS6r3/8+Jhcy+BcEQTgzMFqHxcYSnXMOxLaiIghYLhfEorlzkTk0PFwvqnUnS2h2NsYBubl4vp88ic+mTYO7psOB51djI/4GBUGwYpfatDSdUCE2FiJZaSksvdkFlrO1hofrGG1NTfieLeg4gQKLhEYB7MABWLgdPgxruNBQvOrqsK3Fgu2CgiDKuVw67pxv/pKUFIx9Ro2COMiuq8nJ+lm7cCH2e+ONED1FhBvciDAnCIIgCMKQx2yGC0lCAtEvfqFjoXGWVn+urZ3B5cKK809/ipXp2bOH5iozTxJOn4ZV3ObNmPjU1XUsUhr3we3ndmMy43BoN5rmZlhHLF0qWW8FQRDOZFJSIAbt3ImECLGxcKFkV9GtW2ENN3Omt5U7UdezhL71FtHatRCzWDCrrsaxCgrwHIqIgDvo6dM6cQLHSw0IgADGn7P7bWkphLeoKIh7HLohJkY/C6uqkBiiqgqWgSkpOlkSx6ZzOLCP4mI8O+fOxfO4uBgCYk0Nyh0Tg2M0NOiEEM3N2A8f09hGZjNEvJkzIer5EhICwW7kyK5ZHgoDw7AYLlVUVNA111xDYWFhFBERQTfeeCPVcKCZNjj33HPJZDJ5vW6++WavbfLz82np0qUUFBREcXFxdOedd5KLl9v7ia7WraKigm655RZKS0ujwMBASklJoVtvvZWcTqfXdr51N5lMtGnTpr6uDj311FM0evRocjgclJmZSV9++WW727/yyis0ceJEcjgclJGRQe+8847X90opWrNmDSUmJlJgYCAtXLiQDh061JdVaJeu1O+ZZ56h73znOxQZGUmRkZG0cOHCVttff/31rc7TkiVL+roafulK3TZu3Niq3A6Hw2ubwXTuulI3f32HyWSipUuXtmwzWM7bp59+ShdffDGNGDGCTCYTvfHGGx3+ZuvWrTRz5kyy2+00btw42rhxY6ttunofC0J/cumlsHSbPh2DbZdLD7bZ9aSrIYCUwuD5t78luv9+ojVriB58kOiFF4heeQWvnTvhDmp0lx1IXC5MfNauJbrhBqLvfheJLc4+m+iRRzDQr67uvChHpNuR4YQPDgcsH8aPJ1q/nuhvf5PkDoIgCGcyZjPR5ZdDUNq/HyIZxxxtbITwFBLS+necJTQ9vXNZQrOzESbhxAkIZKGhOFZtLZ5LHMON47GlpmLxaPp0WJo1N8Na/LPP8CothYiYkYGyc1w8kwniXlycFv1OncL+rVb85rLLYBX3xz9iTBATA0u86GjEw/3qK2w3ZgyexYsXw5IwOBjbLVmCz887D0mukpNRx9JSHM9fG0VFoa7+6KrAKQwsw8Ji7pprrqGioiJ6//33qbm5mW644QZasWJFu8E7iYhuuukmeuCBB1reBwUFtfzvdrtp6dKllJCQQF988QUVFRXRD3/4QwoICKAHH3ywz+riS1frdvLkSTp58iStX7+eJk2aRMePH6ebb76ZTp48Sa+++qrXts8//7yXWBDh68Dey/z973+n22+/nTZs2ECZmZn02GOP0eLFi+nAgQMUx2ljDHzxxRe0fPlyeuihh+iiiy6il156iS677DL65ptvaMqUKURE9Mgjj9Af//hH+utf/0pjxoyhe+65hxYvXkz79+9vJQT1NV2t39atW2n58uU0b948cjgc9PDDD9OiRYsoOzubRnJqHyJasmQJPf/88y3v7bwU1I90tW5ERGFhYXTgwIGW9yaf5bDBcu66WrfXXnuNmpqaWt6Xl5fTtGnT6Hvf+57XdoPhvNXW1tK0adPoRz/6EV1xxRUdbp+Xl0dLly6lm2++mV588UX68MMP6cc//jElJibS4sWLiah714Ig9DcXXYQB7qZNRP/3f7B4Ky3FANxs1ivlnYXjpTmdOpPZE09glZu7tqAgDPgnTiT61rew/1OnMGi++GJkI+0LoYrjwx08iP9DQoh27CB6/HEdZ6c34bhxgYH4GxGBScbs2UTXXScx5ARBEASQnk50663aeoyzlc6aBavqt9+GaJeUhGdrbW3XsoR6PHBfLSnRFmYlJfg8IgJup5wAYsQICINBQXhO7t+vY806HNiuqAjP99mzIch997vI1l5bi/1mZRF9+SXR0aN6PDBmDNGcOShvWhrRunUQACdN0uMDdoO1WCDcxcZqoa+xUcd8M5mQMZYxWu6Vl6Pcxja67jpkvmWrRN/4uoWFsKbrjMApDDwmNcRTx+Tk5NCkSZPoq6++orPOOouIiLZs2UIXXnghFRYW0ogRI/z+7txzz6Xp06fTY4895vf7d999ly666CI6efIkxf/nDtmwYQPdddddVFpaSjabrU/qY6S7dfPllVdeoR/84AdUW1tL1v+YC5hMJnr99dfpsssu66vityIzM5O+9a1v0ZNPPklERB6Ph5KTk+mWW26hVatWtdr+qquuotraWnrrrbdaPpszZw5Nnz6dNmzYQEopGjFiBN1xxx30q1/9ioiInE4nxcfH08aNG2nZsmX9U7H/0NX6+eJ2uykyMpKefPJJ+uEPf0hEsLyqrKzslKVTX9LVum3cuJFuu+02qqys9Lu/wXTuenreHnvsMVqzZg0VFRVR8H+e/oPlvBnpzD1/11130dtvv0379u1r+WzZsmVUWVlJW7ZsIaKet5cwMFRVVVF4eDg5nU4K49ReZwgsXH34IdE772DF+vRpDLq7isNBdNZZmGDU1kL0sloxGaip0a6eRis0zmA6dSrivJx3Hj4/fBjbsbhnMmGAn5eH7xMTMTkoLIToRgRXlJ07iXbtQhnYAqC+Xr8aGnRm1L7CZsOE67/+C0Gmp00beq69wtDlTO7PhOHHmXA9+4u3Zjb7d/lMT+98ltBjx4huuQViV0IC3E7z8mDNzXHfOKYcx46rr4fAVVkJke7IEWw/ZgyebcXFKMe3v42wGMZycD2cTl2X8HBdn2PHYFEfE6OzqBJB1PvkE+y/rg7PzeRkPPcrKzE+aWyElZxRmCNCffbsQfms1tZtlJMDC72yMv8C5623Ds+Mq8PxvhnyFnPbtm2jiIiIFuGKiGjhwoVkNpspKyuLLr/88jZ/++KLL9ILL7xACQkJdPHFF9M999zTYjW3bds2ysjIaBHliIgWL15MP/3pTyk7O5tmzJjRd5X6Dz2pmxG+YK0+KeV+/vOf049//GNKTU2lm2++mW644YZWVk29RVNTE+3YsYNWr17d8pnZbKaFCxfStm3b/P5m27ZtdPvtt3t9tnjx4haxIy8vj4qLi2nhwoUt34eHh1NmZiZt27atX8Wd7tTPl7q6OmpubqaoqCivz7du3UpxcXEUGRlJ559/Pv3ud7+j6OjoXi1/e3S3bjU1NTRq1CjyeDw0c+ZMevDBB2nyf0wpBsu5643z9uyzz9KyZctaRDlmoM9bd9i2bZvXOSHCPXfbbbcRUe+0lyD0N2YzLNlSUyGMffQR0V//SvTxx1i97ywmE1a7jxzBBMJm0/FmODaNPzdWjwcTgawsZFoLCcF+3G4d342FOV5Vt9thkcYBnd1uTAJqamD111b5AgIwMelLAgJgEXjffRJDThAEQegYs9l/jLP0dFiZ+RPtOkN1NZ6xHIvN5dKJioh0wqLQUDx7q6rwPK6rg3BWV4f4ayEh+LymRrumfve7rQWttuphLE9Dg7bSY2pr4S7rcuEZ/dlnEOYmTtQiXmEhnvlGlGptuefbRm1ZJc6c2XmBUxgcDHlhrri4uJX7lNVqpaioKCouLm7zd1dffTWNGjWKRowYQXv27KG77rqLDhw4QK+99lrLfuN9JGt+395+e5Pu1s1IWVkZrV27llasWOH1+QMPPEDnn38+BQUF0XvvvUc/+9nPqKamhm699dZeK79vOdxut982zc3N9fubts4B153/trdNf9Gd+vly11130YgRI7yEkSVLltAVV1xBY8aMoSNHjtDdd99NF1xwAW3bto0s/qJ89gHdqVtaWho999xzNHXqVHI6nbR+/XqaN28eZWdnU1JS0qA5dz09b19++SXt27ePnn32Wa/PB8N56w5t3XNVVVVUX19Pp0+f7vF1LggDidmM2Gfnn4+V7RtuIPr008791mTSA3mHA3+tVqxys6trR3CcG14DYzHO+HuzGfs9fRqDeHYXdTrbj1+nVN+LcnY7XIQfekgG+4IgCELP6Ujsao/QUISLqKzEMzM0VGddZ4s5lwturNOnE+3eTXT8OJ7bQUGwTGdxzOnE5xYLLNx8Ldc6Wx7ORMtGXKWlcJv1eHTmVl+32ZAQWPydOIHy+1q9XXEFFhfboqcCpzA4GLTC3KpVq+jhhx9ud5ucnJxu798oVGVkZFBiYiItWLCAjhw5QmPHju32fjtDX9eNqaqqoqVLl9KkSZPovvvu8/runnvuafl/xowZVFtbS48++mifCXNC+6xbt442bdpEW7du9YqvZrQcy8jIoKlTp9LYsWNp69attGDBgoEoaqeYO3cuzZ07t+X9vHnzKD09nZ5++mlau3btAJasd3n22WcpIyODZs+e7fX5UD1vgnCmwFZ0n3xC9JvfEP3+91jl9sWYwTUkBL/ZswcDd/6cxbLOGpwbRTiLBb/jffAgur7e+/ilpV2vY28SGooscr/8JdGiRTLYFwRBEAaelBSIUqdO4RleXQ2rs/p6/K2pwfNr+nS4sSYmEk2ZAgEsPh6un/zs5lDrTics1ruTMME3Ey0RrNjq6vDdkSP4zG7HmKK4mOjf/4bb7EUXYXzRXau3ngicwuBg0Apzd9xxB11//fXtbpOamkoJCQl06tQpr89dLhdVVFRQQkJCp4+XmZlJRESHDx+msWPHUkJCQqtMgyUlJUREXdqvP/qjbtXV1bRkyRIKDQ2l119/nQICAtrdPjMzk9auXUuNjY19EqQ+JiaGLBZLSxsyJSUlbdYlISGh3e35b0lJCSUmJnptM3369F4sfcd0p37M+vXrad26dfTBBx/Q1KlT2902NTWVYmJi6PDhw/0m8PSkbkxAQADNmDGDDh8+TESD59z1pG61tbW0adMmrwQybTEQ5607tHXPhYWFUWBgIFkslh5fC4Iw2Pjv/ya65x6i3/2O6O9/x4ozW56xa2loKNEFF2Cwnp2tY8i5XN7iXVdxu7XLjfF47N5qNve/CMZutaGhyLJ6/fWo++jRIsgJgiAIgwfO/FpQgPcc7qGqSrurzp8PIWz/fohzK1fqhAm+9DRhgrE8+/fjOXrqFI7v6zZbXe3tNrtwIdGFF4rV25nMoD3VsbGxNHHixHZfNpuN5s6dS5WVlbRjx46W33700Ufk8XhaxLbOsGvXLiKiFpFg7ty5tHfvXi9h7P3336ewsDCaxBL4IK1bVVUVLVq0iGw2G23evLlTGS537dpFkZGRfZY50maz0axZs+jDDz9s+czj8dCHH37oZVllZO7cuV7bE+Ec8PZjxoyhhIQEr22qqqooKyurzX32Fd2pHxEyk65du5a2bNniFUuwLQoLC6m8vNxLzOpruls3I263m/bu3dtS7sFy7npSt1deeYUaGxvpBz/4QYfHGYjz1h06uud641oQhMGIwwFh7sABCG/PPkt0++1E999P9NxzRFddBREuNJQoMtI7cYTV2nlrOaLW2/qKer7ft+e+2ptYrRDirriC6E9/Qjy8rCyin/8cloIyORAEQRAGGxxj7Zxz8KyaMAHC2llnwU1UKWQ0nTkT202eDPEsJgbimdOJ57vTifedzQjbUXlmzIC1e2Ul9p+YiDIuXowkUGefjWQP48Zpt1m2esvIkMWwMxI1DFiyZImaMWOGysrKUp999pkaP368Wr58ecv3hYWFKi0tTWVlZSmllDp8+LB64IEH1Ndff63y8vLUm2++qVJTU9XZZ5/d8huXy6WmTJmiFi1apHbt2qW2bNmiYmNj1erVqwd13ZxOp8rMzFQZGRnq8OHDqqioqOXlcrmUUkpt3rxZPfPMM2rv3r3q0KFD6k9/+pMKCgpSa9as6dO6bNq0SdntdrVx40a1f/9+tWLFChUREaGKi4uVUkpde+21atWqVS3bf/7558pqtar169ernJwcde+996qAgAC1d+/elm3WrVunIiIi1Jtvvqn27NmjLr30UjVmzBhVX1/fp3XpjfqtW7dO2Ww29eqrr3qdp+rqaqWUUtXV1epXv/qV2rZtm8rLy1MffPCBmjlzpho/frxqaGgY1HW7//771b/+9S915MgRtWPHDrVs2TLlcDhUdna2V/0Hw7nrat2Y+fPnq6uuuqrV54PpvFVXV6udO3eqnTt3KiJSv//979XOnTvV8ePHlVJKrVq1Sl177bUt2x89elQFBQWpO++8U+Xk5KinnnpKWSwWtWXLlpZtOmovYXDidDoVESmn0znQRRmS7N+v1H//t1LXXqvUt7+tVFiYUsHB+OtwKGU2GyPFtf+yWr3fWyz6f5NJvzeZsK3N1vl9d+VlsWDf4eFKnX22Uq++qlRenlJu90C3tiC0j/RnwnBCrufewe3GM2zPHvxtbvZ+7/tsMz7Xv/c9/H3wQXzeW+X597+VuugipX70I6XWrFHq3nu9X7fdhuPm5fXOMc8khuN9MyyEufLycrV8+XIVEhKiwsLC1A033NAibiilVF5eniIi9fHHHyullMrPz1dnn322ioqKUna7XY0bN07deeedrU7ssWPH1AUXXKACAwNVTEyMuuOOO1Rzc3N/Vq3Ldfv4448VEfl95f3nrn/33XfV9OnTVUhIiAoODlbTpk1TGzZsUO5+GI0/8cQTKiUlRdlsNjV79my1ffv2lu/OOeccdd1113lt//LLL6sJEyYom82mJk+erN5++22v7z0ej7rnnntUfHy8stvtasGCBerAgQN9Xo+26Er9Ro0a5fc83XvvvUopperq6tSiRYtUbGysCggIUKNGjVI33XTTgAkgXanbbbfd1rJtfHy8uvDCC9U333zjtb/BdO66el3m5uYqIlLvvfdeq30NpvPWVn/A9bnuuuvUOeec0+o306dPVzabTaWmpqrnn3++1X7bay9hcDIcBzD9jXHQ/5e/KLVwoVIjR0Kgs1ggzvmKbr4vk8lbaLNYvIU5s9n7ZbF0vM+uvAIDlVq6VKn165V66imlNm5U6tAhEeOEoYX0Z8JwQq7ngcNXzOvtZ6HbDfHvu99tLcytWYPPH3xQnsHdYTjeNyaluhsZRRAEQRCEoUBVVRWFh4eT0+mkME4VJvQIl4to+3ZkVissJPrqK2R840xrRhdUkwlxZUwmZFrzHXn5ZmUNDEScHGNW1rKyzsWys9u1+4vJhN9HRRFdcgnca8QtVRjqSH8mDCfkeh7e5OQQ/fGPeIYnJbXOuHrrrZLlvDsMx/tm0CZ/EARBEARBGKxYrQgqzXg8RMeOER08CFHt6FHEq8nJQZyZujp8brNhe7cbn3GiB04iYTZDTAsJgchmsWCbiAgd2NofCQlEP/kJ0fnnY+B/9Cj2mZBANGcOyisIgiAIQv/BMedef737GVeFMwMZpgmCIAiCIPQQsxnWaKmp3p8bBTsiBHomIjp8GIJbTY0W5saMIcrLw/eJiQhcXViofzt6NDLJ7dqFAb7LBeHt6qsRVNoovs2a1YeVFQRBEAShU6SnE6WlScZVoX3ElVUQBEEQhjnD0eRfEIQzE+nPhOGEXM+C0HWG430jOq0gCIIgCIIgCIIgCIIgDAAizAmCIAiCIAiCIAiCIAjCACDCnCAIgiAIgiAIgiAIgiAMACLMCYIgCIIgCIIgCIIgCMIAIMKcIAiCIAiCIAiCIAiCIAwAIswJgiAIgiAIgiAIgiAIwgBgHegCCIIgCILQtyiliAjp5QVBEIYy3I9xvyYIQxl5PgtC1xmOzwER5gRBEARhmFNdXU1ERMnJyQNcEkEQhN6hurqawsPDB7oYgtAj5PksCN1nOD0HTGo4yYyCIAiCILTC4/HQyZMnKTQ0lEwmU6d/V1VVRcnJyVRQUEBhYWF9WMLeZ6iWfaiWm0jKPhAM1XITdb/sSimqrq6mESNGkNksUXmEoU1nn89D+V4fyki7DwwdtftwfA6IxZwgCIIgDHPMZjMlJSV1+/dhYWFDdkA6VMs+VMtNJGUfCIZquYm6V/bhYiEhCF19Pg/le30oI+0+MLTX7sPtOTA85EVBEARBEARBEARBEARBGGKIMCcIgiAIgiAIgiAIgiAIA4AIc4IgCIIg+MVut9O9995Ldrt9oIvSZYZq2YdquYmk7APBUC030dAuuyD0N3K/DAzS7gPDmdjukvxBEARBEARBEARBEARBEAYAsZgTBEEQBEEQBEEQBEEQhAFAhDlBEARBEARBEARBEARBGABEmBMEQRAEQRAEQRAEQRCEAUCEOUEQBEEQBEEQBEEQBEEYAESYEwRBEIQzlIqKCrrmmmsoLCyMIiIi6MYbb6Sampp2f3PuueeSyWTyet18881e2+Tn59PSpUspKCiI4uLi6M477ySXyzWgZa+oqKBbbrmF0tLSKDAwkFJSUujWW28lp9PptZ1v3UwmE23atKlHZX3qqado9OjR5HA4KDMzk7788st2t3/llVdo4sSJ5HA4KCMjg9555x2v75VStGbNGkpMTKTAwEBauHAhHTp0qEdl7Gm5n3nmGfrOd75DkZGRFBkZSQsXLmy1/fXXX9+qbZcsWdLr5e5q2Tdu3NiqXA6Hw2ub/mrzrpbd3/1oMplo6dKlLdv0R7t/+umndPHFF9OIESPIZDLRG2+80eFvtm7dSjNnziS73U7jxo2jjRs3ttqmq/eOIAwX+ur5LLSmt5/RQufo7ef0kEcJgiAIgnBGsmTJEjVt2jS1fft29e9//1uNGzdOLV++vN3fnHPOOeqmm25SRUVFLS+n09nyvcvlUlOmTFELFy5UO3fuVO+8846KiYlRq1evHtCy7927V11xxRVq8+bN6vDhw+rDDz9U48ePV1deeaXXdkSknn/+ea/61dfXd7ucmzZtUjabTT333HMqOztb3XTTTSoiIkKVlJT43f7zzz9XFotFPfLII2r//v3qt7/9rQoICFB79+5t2WbdunUqPDxcvfHGG2r37t3qkksuUWPGjOlROXta7quvvlo99dRTaufOnSonJ0ddf/31Kjw8XBUWFrZsc91116klS5Z4tW1FRUWvlbm7ZX/++edVWFiYV7mKi4u9tumPNu9O2cvLy73KvW/fPmWxWNTzzz/fsk1/tPs777yjfvOb36jXXntNEZF6/fXX293+6NGjKigoSN1+++1q//796oknnlAWi0Vt2bKlZZuutoUgDCf64vkstKYvntFCx/TFc3qoI8KcIAiCIJyB7N+/XxGR+uqrr1o+e/fdd5XJZFInTpxo83fnnHOO+sUvftHm9++8844ym81eA6Y///nPKiwsTDU2Ng5o2X15+eWXlc1mU83NzS2fdUZU6AqzZ89WP//5z1veu91uNWLECPXQQw/53f773/++Wrp0qddnmZmZ6ic/+YlSSimPx6MSEhLUo48+2vJ9ZWWlstvt6v/+7/8GrNy+uFwuFRoaqv7617+2fHbdddepSy+9tNfK2BZdLfvzzz+vwsPD29xff7W5Uj1v9z/84Q8qNDRU1dTUtHzWX+3OdOYe+vWvf60mT57s9dlVV12lFi9e3PK+p20hCEOVvno+C63p7We00Dl6+zk9HBBXVkEQBEE4A9m2bRtFRETQWWed1fLZwoULyWw2U1ZWVru/ffHFFykmJoamTJlCq1evprq6Oq/9ZmRkUHx8fMtnixcvpqqqKsrOzh7wshtxOp0UFhZGVqvV6/Of//znFBMTQ7Nnz6bnnnuOlFLdKmdTUxPt2LGDFi5c2PKZ2WymhQsX0rZt2/z+Ztu2bV7bE6H9ePu8vDwqLi722iY8PJwyMzPb3Gd/lNuXuro6am5upqioKK/Pt27dSnFxcZSWlkY//elPqby8vFfK3NOy19TU0KhRoyg5OZkuvfRSr2u1P9q8J2U38uyzz9KyZcsoODjY6/O+bveu0tF13httIQhDlb56Pgve9MUzWuiYvnhODwesHW8iCIIgCMJwo7i4mOLi4rw+s1qtFBUVRcXFxW3+7uqrr6ZRo0bRiBEjaM+ePXTXXXfRgQMH6LXXXmvZr1GUI6KW9+3ttz/KbqSsrIzWrl1LK1as8Pr8gQceoPPPP5+CgoLovffeo5/97GdUU1NDt956a5fLWVZWRm6322975Obm+v1NW+3H9eK/7W3TU7pTbl/uuusuGjFihNfAe8mSJXTFFVfQmDFj6MiRI3T33XfTBRdcQNu2bSOLxTJgZU9LS6PnnnuOpk6dSk6nk9avX0/z5s2j7OxsSkpK6pc2727ZjXz55Ze0b98+evbZZ70+74927yptXedVVVVUX19Pp0+f7vE1KAhDlb56Pgve9MUzWuiYvnhODwdEmBMEQRCEYcSqVavo4YcfbnebnJycbu/fKGRlZGRQYmIiLViwgI4cOUJjx47t9n6J+r7sTFVVFS1dupQmTZpE9913n9d399xzT8v/M2bMoNraWnr00Ue7Jcydqaxbt442bdpEW7du9QrOvGzZspb/MzIyaOrUqTR27FjaunUrLViwYCCKSkREc+fOpblz57a8nzdvHqWnp9PTTz9Na9euHbBydZVnn32WMjIyaPbs2V6fD9Z2F4QzjaH8fBaEgWS4PKfbQ4Q5QRAEQRhG3HHHHXT99de3u01qaiolJCTQqVOnvD53uVxUUVFBCQkJnT5eZmYmEREdPnyYxo4dSwkJCa0ya5WUlBARdbjf/ih7dXU1LVmyhEJDQ+n111+ngICAdrfPzMyktWvXUmNjI9nt9na39SUmJoYsFktL/ZmSkpI2y5mQkNDu9vy3pKSEEhMTvbaZPn16l8rXm+Vm1q9fT+vWraMPPviApk6d2u62qampFBMTQ4cPH+41gagnZWcCAgJoxowZdPjwYSLqnzYn6lnZa2tradOmTfTAAw90eJy+aPeu0tZ1HhYWRoGBgWSxWHp8HgVhsDHQz2fBm754Rgsd0xfP6eGAxJgTBEEQhGFEbGwsTZw4sd2XzWajuXPnUmVlJe3YsaPltx999BF5PJ6WwXxn2LVrFxFRi2Axd+5c2rt3r9ek4v3336ewsDCaNGnSgJa9qqqKFi1aRDabjTZv3uxlzdVe/SIjI7ssyhER2Ww2mjVrFn344Yctn3k8Hvrwww+9Vn6NzJ0712t7IrQfbz9mzBhKSEjw2qaqqoqysrLa3Gd/lJuI6JFHHqG1a9fSli1bvGIjtUVhYSGVl5d7iV09pbtlN+J2u2nv3r0t5eqPNu9p2V955RVqbGykH/zgBx0epy/avat0dJ33xnkUhMHGQD+fBW/64hktdExfPKeHBQOdfUIQBEEQhIFhyZIlasaMGSorK0t99tlnavz48Wr58uUt3xcWFqq0tDSVlZWllFLq8OHD6oEHHlBff/21ysvLU2+++aZKTU1VZ599dstvXC6XmjJlilq0aJHatWuX2rJli4qNjVWrV68e0LI7nU6VmZmpMjIy1OHDh1VRUVHLy+VyKaWU2rx5s3rmmWfU3r171aFDh9Sf/vQnFRQUpNasWdPtcm7atEnZ7Xa1ceNGtX//frVixQoVERHRkrX22muvVatWrWrZ/vPPP1dWq1WtX79e5eTkqHvvvVcFBASovXv3tmyzbt06FRERod588021Z88edemll6oxY8ao+vr6bpezp+Vet26dstls6tVXX/Vq2+rqaqWUUtXV1epXv/qV2rZtm8rLy1MffPCBmjlzpho/frxqaGjotXJ3p+z333+/+te//qWOHDmiduzYoZYtW6YcDofKzs72ql9ft3l3ys7Mnz9fXXXVVa0+7692r66uVjt37lQ7d+5URKR+//vfq507d6rjx48rpZRatWqVuvbaa1u2P3r0qAoKClJ33nmnysnJUU899ZSyWCxqy5YtnW4LQRjO9MXzWWhNXzyjhY7pi+f0UEeEOUEQBEE4QykvL1fLly9XISEhKiwsTN1www0tQopSSuXl5SkiUh9//LFSSqn8/Hx19tlnq6ioKGW329W4cePUnXfeqZxOp9d+jx07pi644AIVGBioYmJi1B133KGam5sHtOwff/yxIiK/r7y8PKWUUu+++66aPn26CgkJUcHBwWratGlqw4YNyu1296isTzzxhEpJSVE2m03Nnj1bbd++veW7c845R1133XVe27/88stqwoQJymazqcmTJ6u3337b63uPx6PuueceFR8fr+x2u1qwYIE6cOBAj8rY03KPGjXKb9vee++9Siml6urq1KJFi1RsbKwKCAhQo0aNUjfddFOfiSxdKfttt93Wsm18fLy68MIL1TfffOO1v/5q866WXSmlcnNzFRGp9957r9W++qvd27q/uKzXXXedOuecc1r9Zvr06cpms6nU1FT1/PPPt9pve20hCMOZvno+C63p7We00Dl6+zk91DEppVS/mugJgiAIgiAIgiAIgiAIgiAx5gRBEARBEARBEARBEARhIBBhThAEQRAEQRAEQRAEQRAGABHmBEEQBEEQBEEQBEEQBGEAEGFOEARBEARBEARBEARBEAYAEeYEQRAEQRAEQRAEQRAEYQAQYU4QBEEQBEEQBEEQBEEQBgAR5gRBEARBEARBEARBEARhABBhThAEQRAEQRAEQRAEQRAGABHmBEEQBEEQBEEQBEEQBGEAEGFOEARBEARBEARBEARBEAYAEeYEQRAEQRAEQRAEQRAEYQAQYU4QBEEQBEEQBEEQBEEQBoD/D5j37ylyQRbWAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -326,61 +343,72 @@ ], "source": [ "fig, axs = plt.subplots(1, 3, figsize=(16, 4))\n", - "pts_list = [c_e_nb_u_points, c_e_b_u_points, three_domain_union_points]\n", + "pts_list = [cart_sim_samples, cart_ell_bnd_samples, ell_sim_bnd_samples]\n", "title_list = [\n", - " \"Cartesian with Ellipsoid No Border Union\",\n", - " \"Cartesian with Ellipsoid Border Union\",\n", - " \"Three Domain Union\",\n", + " \"Cartesian and Simplex Union\",\n", + " \"Cartesian and Ellipsoid Border Union\",\n", + " \"Ellipsoid and Simplex Border Union\",\n", "]\n", "for ax, pts, title in zip(axs, pts_list, title_list):\n", " plot_scatter(ax, pts, title)" ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "Now, we will find the differences of the geometries. We will find the difference of `cartesian` and `ellipsoid_no_border`." + "## Creating a Custom Domain" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we explore how to create a custom domain. As an example, we consider a heart-shaped region defined by the inequality:\n", + "$$(x^2+y^2-1)^3-x^2y^3 \\le 0$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Custom domains in PINA can be created by inheriting from the `BaseDomain` class, which provides the general structure shared by all domains.\n", + "We begin by defining the constructor: we specify the available sampling modes (\"random\", \"grid\", \"chebyshev\", \"latin\" or \"lh\"). Here, we default to random sampling. We also introduce the parameter `sample_surface`, which determines whether we sample the full heart or only its boundary." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "cart_ellipse_nb_difference = Difference([cartesian, ellipsoid_no_border])\n", - "c_e_nb_d_points = cart_ellipse_nb_difference.sample(n=2000, mode=\"random\")\n", + "class Heart(BaseDomain):\n", + " \"\"\"\n", + " Implementation of the Heart Domain.\n", + " \"\"\"\n", + "\n", + " def __init__(self, sample_surface=False):\n", + " \"\"\"\n", + " Initialization of the Heart Domain.\n", + " \"\"\"\n", + " super().__init__()\n", "\n", - "fig, ax = plt.subplots(1, 1, figsize=(8, 6))\n", - "plot_scatter(ax, c_e_nb_d_points, \"Difference\")" + " self.sample_modes = \"random\"\n", + " self.sample_surface = sample_surface" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Create Custom DomainInterface" + "Since the `Heart` domain inherits from BaseDomain, we must implement its abstract methods: `is_inside`, `sample`, and `partial`." ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "We will take a look on how to create our own geometry. The one we will try to make is a heart defined by the function $$(x^2+y^2-1)^3-x^2y^3 \\le 0$$" + "The `is_inside` method checks whether a given point lies inside the domain. It receives the point to test and the boolean `check_border`, which indicates whether points on the boundary should be considered inside." ] }, { @@ -389,19 +417,30 @@ "metadata": {}, "outputs": [], "source": [ - "class Heart(DomainInterface):\n", - " \"\"\"Implementation of the Heart Domain.\"\"\"\n", + "def is_inside(self, point, check_border=False):\n", + " \"\"\"\n", + " Check if a point is inside the Heart domain.\n", + " \"\"\"\n", + " # Extract coordinates\n", + " x = point[\"x\"]\n", + " y = point[\"y\"]\n", "\n", - " def __init__(self, sample_border=False):\n", - " super().__init__()" + " # Define the quantity defining the heart shape\n", + " eqn = (x ** 2 + y ** 2 - 1) ** 3 - (x ** 2) * (y ** 3)\n", + "\n", + " # If sampling on the surface, check for equality\n", + " if self.sample_surface:\n", + " return torch.allclose(eqn, torch.zeros_like(eqn))\n", + " \n", + " # Check if point is inside the heart shape\n", + " return (eqn <= 0) if check_border else (eqn < 0)" ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "Because the `DomainInterface` class we are inheriting from requires both a `sample` method and `is_inside` method, we will create them and just add in \"pass\" for the moment. We also observe that the methods `sample_modes` and `variables` of the `DomainInterface` class are initialized as `abstractmethod`, so we need to redefine them both in the subclass `Heart` ." + "The `sample` method closely resembles those of PINA’s built-in domains. We specify the number of points `n` and the sampling strategy mode. Note that for illustration we implement a very naive sampling approach, which is inefficient and not suitable for sampling boundary points for the heart domain!" ] }, { @@ -410,33 +449,35 @@ "metadata": {}, "outputs": [], "source": [ - "class Heart(DomainInterface):\n", - " \"\"\"Implementation of the Heart Domain.\"\"\"\n", + "def sample(self, n, mode=\"random\"):\n", + " \"\"\"\n", + " Sampling routine for the Heart domain.\n", + " \"\"\"\n", + " # Create a list to store the sampled points\n", + " samples = []\n", "\n", - " def __init__(self, sample_border=False):\n", - " super().__init__()\n", + " # Random sampling\n", + " if mode == \"random\":\n", "\n", - " def is_inside(self):\n", - " pass\n", + " # Loop until we have n samples\n", + " while len(samples) < n:\n", "\n", - " def sample(self):\n", - " pass\n", + " # Generate random point in bounding box\n", + " pts = torch.rand(1, 2) * 3.0 - 1.5\n", + " pts = LabelTensor(pts, labels=[\"x\", \"y\"])\n", "\n", - " @property\n", - " def sample_modes(self):\n", - " pass\n", + " # Check if the point is inside the heart, borders included\n", + " if self.is_inside(pts, True):\n", + " samples.append(pts)\n", "\n", - " @property\n", - " def variables(self):\n", - " pass" + " return LabelTensor.cat(samples, dim=0)" ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "Now we have the skeleton for our `Heart` class. Also the `sample` method is where most of the work is done so let's fill it out. " + "The `partial` method returns a new instance of the domain class that represents only its boundary. Implementing it is straightforward." ] }, { @@ -445,33 +486,37 @@ "metadata": {}, "outputs": [], "source": [ - "class Heart(DomainInterface):\n", - " \"\"\"Implementation of the Heart Domain.\"\"\"\n", + "def partial(self):\n", + " \"\"\"\n", + " Return the boundary of the Heart domain.\n", + " \"\"\"\n", + " # Copy the current instance and set sampling only on the surface\n", + " boundary = deepcopy(self)\n", + " boundary.sample_surface = True\n", "\n", - " def __init__(self, sample_border=False):\n", - " super().__init__()\n", - "\n", - " def is_inside(self):\n", - " pass\n", - "\n", - " def sample(self, n):\n", - " sampled_points = []\n", - "\n", - " while len(sampled_points) < n:\n", - " x = torch.rand(1) * 3.0 - 1.5\n", - " y = torch.rand(1) * 3.0 - 1.5\n", - " if ((x**2 + y**2 - 1) ** 3 - (x**2) * (y**3)) <= 0:\n", - " sampled_points.append([x.item(), y.item()])\n", - "\n", - " return LabelTensor(torch.tensor(sampled_points), labels=[\"x\", \"y\"])\n", - "\n", - " @property\n", - " def sample_modes(self):\n", - " pass\n", + " return boundary" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now have all the components needed to complete the `Heart` class." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# Linking the methods to the Heart class\n", + "Heart.is_inside = is_inside\n", + "Heart.sample = sample\n", + "Heart.partial = partial\n", "\n", - " @property\n", - " def variables(self):\n", - " pass" + "# Avoid complaints about abstract methods not being implemented\n", + "Heart.__abstractmethods__ = frozenset()" ] }, { @@ -479,16 +524,20 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "To create the Heart geometry we simply run:" + "Let’s generate the heart domain and draw sample points." ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "heart = Heart()" + "# Generate the heart domain\n", + "heart = Heart()\n", + "\n", + "# Draw samples from the heart domain\n", + "heart_samples = heart.sample(n=1000, mode=\"random\")" ] }, { @@ -496,17 +545,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "To sample from the Heart geometry we simply run:" + "Finally, we visualize the samples." ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -516,10 +565,8 @@ } ], "source": [ - "pts_heart = heart.sample(1500)\n", - "\n", "fig, ax = plt.subplots()\n", - "plot_scatter(ax, pts_heart, \"Heart Domain\")" + "plot_scatter(ax, heart_samples, \"Heart Domain\")" ] }, { @@ -528,13 +575,13 @@ "source": [ "## What's Next?\n", "\n", - "We have walked through a simple tutorial on how to build custom geometries and use domain operations to compose base geometries. Now you can experiment with different geometries and create your own!\n", + "In this tutorial, we introduced the construction of custom geometries and the use of domain operations to combine basic shapes. From here, you can experiment with a wide range of possibilities:\n", "\n", - "1. **Experiment with Complex Geometries**: Combine multiple basic shapes to create more intricate structures using domain operations.\n", + "1. **Build More Complex Geometries**: Combine multiple simple shapes using set operations to design sophisticated domains.\n", "\n", - "2. **Optimize Geometry for Specific Tasks**: Customize your geometry models for specialized applications such as fluid dynamics, heat transfer, or structural analysis.\n", + "2. **Optimize for Specific Applications**: Tailor domain definitions for tasks such as fluid flow, heat transfer, or structural mechanics.\n", "\n", - "3. **...and many more!**: Explore new geometries and build them with `DomainInterface`!\n", + "3. **...and many more!**: Implement new geometries using DomainInterface and push PINA’s capabilities further.\n", "\n", "For more resources and tutorials, check out the [PINA Documentation](https://mathlab.github.io/PINA/)." ] @@ -542,7 +589,7 @@ ], "metadata": { "kernelspec": { - "display_name": "pina", + "display_name": "deep", "language": "python", "name": "python3" }, @@ -556,7 +603,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.21" + "version": "3.12.11" } }, "nbformat": 4,