From b4968eef751fcd11446b0b3d6446366fd9278f39 Mon Sep 17 00:00:00 2001 From: ColinDoumont Date: Fri, 14 Nov 2025 19:05:42 +0100 Subject: [PATCH 1/9] HammingGraph space: initial commit --- docs/examples/HammingGraph.nblink | 1 + docs/examples/examples.rst | 1 + docs/references.bib | 7 + docs/theory/hamming_graph.rst | 113 +++ geometric_kernels/kernels/karhunen_loeve.py | 53 ++ geometric_kernels/kernels/matern_kernel.py | 25 +- geometric_kernels/spaces/__init__.py | 1 + geometric_kernels/spaces/hamming_graph.py | 319 ++++++++ geometric_kernels/spaces/hypercube_graph.py | 8 +- .../utils/kernel_formulas/__init__.py | 3 + .../utils/kernel_formulas/hamming_graph.py | 62 ++ geometric_kernels/utils/special_functions.py | 77 +- geometric_kernels/utils/utils.py | 6 +- notebooks/FastMaternForHammingGraph.ipynb | 268 +++++++ notebooks/HammingGraph.ipynb | 758 ++++++++++++++++++ tests/helper.py | 5 + tests/spaces/test_eigenfunctions.py | 28 +- tests/spaces/test_hamming_graph.py | 108 +++ tests/utils/test_kernel_formulas.py | 119 ++- tests/utils/test_special_functions.py | 14 +- 20 files changed, 1921 insertions(+), 55 deletions(-) create mode 100644 docs/examples/HammingGraph.nblink create mode 100644 docs/theory/hamming_graph.rst create mode 100644 geometric_kernels/spaces/hamming_graph.py create mode 100644 geometric_kernels/utils/kernel_formulas/hamming_graph.py create mode 100644 notebooks/FastMaternForHammingGraph.ipynb create mode 100644 notebooks/HammingGraph.ipynb create mode 100644 tests/spaces/test_hamming_graph.py diff --git a/docs/examples/HammingGraph.nblink b/docs/examples/HammingGraph.nblink new file mode 100644 index 00000000..8c821b13 --- /dev/null +++ b/docs/examples/HammingGraph.nblink @@ -0,0 +1 @@ +{"path": "../../notebooks/HammingGraph.ipynb"} \ No newline at end of file diff --git a/docs/examples/examples.rst b/docs/examples/examples.rst index e65f501a..6e600208 100644 --- a/docs/examples/examples.rst +++ b/docs/examples/examples.rst @@ -9,6 +9,7 @@ Spaces Custom Spaces and Kernels Graph GraphEdges + HammingGraph Hyperbolic HypercubeGraph Hypersphere diff --git a/docs/references.bib b/docs/references.bib index 0328bfa3..3fe5dc02 100644 --- a/docs/references.bib +++ b/docs/references.bib @@ -152,4 +152,11 @@ @article{sawyer1992 title = {The heat equation on the spaces of positive definite matrices}, volume = {44}, year = {1992}, +} + +@inproceedings{doumont2025, + title = {Omnipresent Yet Overlooked: Heat Kernels in Combinatorial Bayesian Optimization}, + author = {Colin Doumont and Victor Picheny and Viacheslav Borovitskiy and Henry Moss}, + booktitle = {Advances in Neural Information Processing Systems}, + year = {2025}, } \ No newline at end of file diff --git a/docs/theory/hamming_graph.rst b/docs/theory/hamming_graph.rst new file mode 100644 index 00000000..81f632d0 --- /dev/null +++ b/docs/theory/hamming_graph.rst @@ -0,0 +1,113 @@ +################################ + Kernels on the Hamming Graph +################################ + +.. warning:: + You can get by fine without reading this page for almost all use cases, just use the standard :class:`~.kernels.MaternGeometricKernel`, following the respective :doc:`example notebook `. + + This is optional material meant to explain the basic theory and based mainly on :cite:t:`borovitskiy2023`. + +========================== +Motivation +========================== + +The :class:`~.spaces.HammingGraph` space $H(d,q)$ can be used to model $d$-dimensional *categorical vector* inputs, where each component takes values in $\{0, 1, ..., q-1\}$. + +There are many settings where inputs are categorical vectors or can be represented as such. For instance, DNA sequences (with $q=4$ for A, C, G, T), protein sequences (with $q=20$ for the standard amino acids), or error-correcting codes over finite alphabets. When $q=2$, the Hamming graph reduces to the hypercube graph $C^d$ (see :doc:`HypercubeGraph `), which represents binary vectors. + +========================== +Structure of the Space +========================== + +The elements of this space—given its `dim` is $d \in \mathbb{Z}_{>0}$ and `n_cat` is $q \in \mathbb{Z}_{>1}$—are exactly the categorical vectors of length $d$ where each component is in $\{0, 1, ..., q-1\}$. + +The geometry of this space is simple: it is a graph such that $x, x' \in H(d,q)$ are connected by an edge if and only if they differ in exactly one coordinate (i.e. there is exactly *Hamming distance* $1$ between them). + +Being a graph, $H(d,q)$ could also be represented using the general :class:`~.spaces.Graph` space. +However, the number of nodes in $H(d,q)$ is $q^d$, which is exponential in $d$ (and grows rapidly with $q$), rendering the general techniques infeasible. + +========================== +Eigenfunctions +========================== + +On graphs, kernels are computed using the eigenfunctions and eigenvalues of the Laplacian. + +The eigenfunctions of the Laplacian on the Hamming graph are the *Vilenkin functions* (also known as *generalized Walsh functions*) [#]_. These are characters of the Abelian group $\mathbb{Z}_q^d$ and can be expressed using $q$-th roots of unity. + +The Vilenkin functions $\psi_{\mathbf{s}}$ are indexed by frequency vectors $\mathbf{s} = (s_0, \ldots, s_{d-1})$ where each $s_i \in \{0, 1, \ldots, q-1\}$, and take the form +$$ +\psi_{\mathbf{s}}(x_0, \ldots, x_{d-1}) = \prod_{i=0}^{d-1} \omega_q^{s_i x_i} +$$ +where $\omega_q = e^{2\pi i/q}$ is a primitive $q$-th root of unity and $x = (x_0, \ldots, x_{d-1}) \in H(d,q)$. + +The eigenfunctions with the same number of non-zero frequency components $j = |\{i : s_i \neq 0\}|$ share the same eigenvalue $\lambda_j = (q-1)j / d$ and form a *level* $j$. The dimension of level $j$ is $\binom{d}{j}(q-1)^j$. + +However, the problem is that the number of eigenfunctions is $q^d$. +Hence naive truncation of the sum in the kernel formula to a few hundred terms leads to a poor approximation of the kernel for larger $d$ or $q$. + +**Note:** Direct evaluation of Vilenkin functions is not currently implemented for $q > 2$, but this is not required for kernel computation thanks to the addition theorem below. + +========================== +Addition Theorem +========================== + +Much like for hyperspheres and hypercube graphs, there is an :doc:`addition theorem ` for the Hamming graph: + +$$ +\sum_{\substack{T \subseteq \{0, .., d-1\} \\ \lvert T \rvert = j}} \sum_{\alpha \in \{1,..,q-1\}^T} \psi_{T,\alpha}(x) \overline{\psi_{T,\alpha}(x')} += +\binom{d}{j} (q-1)^j +\widetilde{K}_{d, q, j}(m) +$$ + +where $\psi_{T,\alpha}$ denotes the Vilenkin function indexed by the subset $T$ with frequency values $\alpha = (\alpha_i)_{i \in T}$, $m$ is the Hamming distance between $x$ and $x'$, and $\widetilde{K}_{d, q, j}(m)$ is the generalized Kravchuk polynomial of degree $d$, alphabet size $q$, and order $j$, normalized such that $\widetilde{K}_{d, q, j}(0) = 1$. + +Normalized generalized Kravchuk polynomials $\widetilde{K}_{d, q, j}(m)$ satisfy the following three-term recurrence relation: +$$ +\widetilde{K}_{d, q, j}(m) += +\frac{d(q-1) - qm + q - j(q-1)}{(d - j + 1)(q-1)} \widetilde{K}_{d, q, j-1}(m) +- \frac{j-1}{d - j + 1} \widetilde{K}_{d, q, j-2}(m) +$$ +with initial conditions: +$$ +\widetilde{K}_{d, q, 0}(m) = 1, +\quad +\widetilde{K}_{d, q, 1}(m) = 1 - \frac{q}{(q-1)d} m, +$$ +which allows for their efficient computation without the need to compute large sums of the individual Vilenkin functions. + +With that, the kernels on the Hamming graph can be computed efficiently using the formula: +$$ +k_{\nu, \kappa}(x, x') += +\frac{1}{C_{\nu, \kappa}} +\sum_{j=0}^{L-1} +\Phi_{\nu, \kappa}(\lambda_j) +\binom{d}{j} (q-1)^j \widetilde{K}_{d, q, j}(m) +\qquad +\Phi_{\nu, \kappa}(\lambda) += +\begin{cases} +\left(\frac{2\nu}{\kappa^2} + \lambda\right)^{-\nu-\frac{d}{2}} +& +\nu < \infty \text{ — Matérn} +\\ +e^{-\frac{\kappa^2}{2} \lambda} +& +\nu = \infty \text{ — Heat (RBF)} +\end{cases} +$$ +where $m$ is the Hamming distance between $x$ and $x'$, and $L \leq d + 1$ is the user-controlled number of levels parameter. + +**Notes:** + +#. We define the dimension of the :class:`~.spaces.HammingGraph` space $H(d,q)$ to be $d$, in contrast to the graphs represented by the :class:`~.spaces.Graph` space, whose dimension is defined to be $0$. + + Because of this, much like in the Euclidean or the manifold case, the $1/2, 3/2, 5/2$ *are* in fact reasonable values for the smoothness parameter $\nu$. + +#. When $q=2$, the Hamming graph $H(d,2)$ is isomorphic to the hypercube graph $C^d$, and the generalized Kravchuk polynomials reduce to the standard Kravchuk polynomials ($q=2$). + +.. rubric:: Footnotes + +.. [#] Since the Hamming graph $H(d,q)$ is $(q-1)d$-regular, the unnormalized Laplacian and the symmetric normalized Laplacian coincide up to a multiplication by $(q-1)d$. Thus their eigenfunctions are the same and eigenvalues coincide up to this multiplication. For better numerical stability, we use symmetric normalized Laplacian in the implementation and assume its use throughout this page. diff --git a/geometric_kernels/kernels/karhunen_loeve.py b/geometric_kernels/kernels/karhunen_loeve.py index 0aa3625d..21f3c798 100644 --- a/geometric_kernels/kernels/karhunen_loeve.py +++ b/geometric_kernels/kernels/karhunen_loeve.py @@ -11,6 +11,9 @@ from geometric_kernels.lab_extras import from_numpy, is_complex from geometric_kernels.spaces import DiscreteSpectrumSpace from geometric_kernels.spaces.eigenfunctions import Eigenfunctions +from geometric_kernels.utils.kernel_formulas.hamming_graph import ( + hamming_graph_heat_kernel, +) from geometric_kernels.utils.utils import _check_1_vector, _check_field_in_params @@ -253,3 +256,53 @@ def K_diag(self, params: Dict[str, B.Numeric], X: B.Numeric, **kwargs) -> B.Nume return B.real(K_diag) else: return K_diag + + +class FastMaternForHammingGraph(MaternKarhunenLoeveKernel): + r""" + For $\nu = \infty$, there exists a closed-form formula for the heat kernel + on Hamming graphs (including the binary hypercube case). + + .. note:: + We only use the fast path if we have ALL levels (exact computation). + When truncated to fewer levels, we must use the parent class implementation + to ensure consistency with feature map approximations. + """ + + def K( + self, + params: Dict[str, B.Numeric], + X: B.Numeric, + X2: Optional[B.Numeric] = None, + **kwargs, + ) -> B.Numeric: + assert "nu" in params + assert params["nu"].shape == (1,) + + if B.all(params["nu"] == np.inf): + d = X.shape[-1] + + # Only use fast path when we have all levels (exact computation) + if self.num_levels == d + 1: + assert "lengthscale" in params + assert params["lengthscale"].shape == (1,) + + # Get q from space (HammingGraph has n_cat, HypercubeGraph is binary q=2) + q = getattr(self.space, "n_cat", 2) + + return hamming_graph_heat_kernel(params["lengthscale"], X, X2, q=q) + + return super().K(params, X, X2, **kwargs) + + def K_diag(self, params: Dict[str, B.Numeric], X: B.Numeric, **kwargs) -> B.Numeric: + assert "nu" in params + assert params["nu"].shape == (1,) + + if B.all(params["nu"] == np.inf): + d = X.shape[-1] + + # Only use fast path when we have all levels (exact computation) + if self.num_levels == d + 1: + return B.ones(B.dtype(params["nu"]), X.shape[0]) + + return super().K_diag(params, X, **kwargs) diff --git a/geometric_kernels/kernels/matern_kernel.py b/geometric_kernels/kernels/matern_kernel.py index 8a63aafb..24fbf789 100644 --- a/geometric_kernels/kernels/matern_kernel.py +++ b/geometric_kernels/kernels/matern_kernel.py @@ -20,12 +20,16 @@ from geometric_kernels.kernels.base import BaseGeometricKernel from geometric_kernels.kernels.feature_map import MaternFeatureMapKernel from geometric_kernels.kernels.hodge_compositional import MaternHodgeCompositionalKernel -from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel +from geometric_kernels.kernels.karhunen_loeve import ( + FastMaternForHammingGraph, + MaternKarhunenLoeveKernel, +) from geometric_kernels.spaces import ( CompactMatrixLieGroup, DiscreteSpectrumSpace, Graph, GraphEdges, + HammingGraph, HodgeDiscreteSpectrumSpace, Hyperbolic, HypercubeGraph, @@ -76,7 +80,7 @@ def default_feature_map( @overload def feature_map_from_kernel(kernel: MaternKarhunenLoeveKernel): - if isinstance(kernel.space, CompactMatrixLieGroup): + if isinstance(kernel.space, (CompactMatrixLieGroup, HammingGraph)): # Because `CompactMatrixLieGroup` does not currently support explicit # eigenfunction computation (they only support addition theorem). return RandomPhaseFeatureMapCompact( @@ -136,7 +140,7 @@ def feature_map_from_kernel(kernel: BaseGeometricKernel): @overload def feature_map_from_space(space: DiscreteSpectrumSpace, num: int): - if isinstance(space, CompactMatrixLieGroup): + if isinstance(space, (CompactMatrixLieGroup, HammingGraph)): return RandomPhaseFeatureMapCompact( space, num, MaternGeometricKernel._DEFAULT_NUM_RANDOM_PHASES ) @@ -212,7 +216,7 @@ def default_num(space: DiscreteSpectrumSpace) -> int: ) elif isinstance(space, GraphEdges): return min(MaternGeometricKernel._DEFAULT_NUM_EIGENFUNCTIONS, space.num_edges) - elif isinstance(space, HypercubeGraph): + elif isinstance(space, (HypercubeGraph, HammingGraph)): return min(MaternGeometricKernel._DEFAULT_NUM_LEVELS, space.dim + 1) else: return MaternGeometricKernel._DEFAULT_NUM_LEVELS @@ -277,6 +281,7 @@ def __new__( num: int = None, normalize: bool = True, return_feature_map: bool = False, + fast_matern: bool = False, **kwargs, ): r""" @@ -289,6 +294,7 @@ def __new__( :param space: Space to construct the kernel on. + :param num: If provided, controls the "order of approximation" of the kernel. For the discrete spectrum spaces, this means the number of "levels" @@ -302,6 +308,7 @@ def __new__( If num=None, we use a (hopefully) reasonable default, which is space-dependent. + :param normalize: Normalize the kernel (and the feature map). If normalize=True, then either $k(x, x) = 1$ for all $x \in X$, where $X$ is the @@ -324,6 +331,14 @@ def __new__( Default is False. + :param fast_matern: + If `True`, use optimized kernel implementations when available. + Currently applies to :class:`~.spaces.HypercubeGraph`, where an + analytic closed-form formula is used for the heat kernel (infinite + smoothness, $\nu = \infty$) when all eigenvalue levels are included. + + Defaults to True. + :param ``**kwargs``: Any additional keyword arguments to be passed to the kernel (like `key`). @@ -339,6 +354,8 @@ def __new__( num = num or default_num(space) if isinstance(space, HodgeDiscreteSpectrumSpace): kernel = MaternHodgeCompositionalKernel(space, num, normalize=normalize) + elif isinstance(space, (HypercubeGraph, HammingGraph)) and fast_matern: + kernel = FastMaternForHammingGraph(space, num, normalize=normalize) else: kernel = MaternKarhunenLoeveKernel(space, num, normalize=normalize) if return_feature_map: diff --git a/geometric_kernels/spaces/__init__.py b/geometric_kernels/spaces/__init__.py index 700b75a5..36db926e 100644 --- a/geometric_kernels/spaces/__init__.py +++ b/geometric_kernels/spaces/__init__.py @@ -12,6 +12,7 @@ from geometric_kernels.spaces.circle import Circle from geometric_kernels.spaces.graph import Graph from geometric_kernels.spaces.graph_edges import GraphEdges +from geometric_kernels.spaces.hamming_graph import HammingGraph from geometric_kernels.spaces.hyperbolic import Hyperbolic from geometric_kernels.spaces.hypercube_graph import HypercubeGraph from geometric_kernels.spaces.hypersphere import Hypersphere diff --git a/geometric_kernels/spaces/hamming_graph.py b/geometric_kernels/spaces/hamming_graph.py new file mode 100644 index 00000000..df264505 --- /dev/null +++ b/geometric_kernels/spaces/hamming_graph.py @@ -0,0 +1,319 @@ +""" +This module provides the :class:`HammingGraph` space and the respective +:class:`~.eigenfunctions.Eigenfunctions` subclass :class:`VilenkinFunctions`. +""" + +from math import comb + +import lab as B +import numpy as np +from beartype.typing import List, Optional + +from geometric_kernels.lab_extras import dtype_double, dtype_integer, float_like +from geometric_kernels.spaces.base import DiscreteSpectrumSpace +from geometric_kernels.spaces.eigenfunctions import ( + Eigenfunctions, + EigenfunctionsWithAdditionTheorem, +) +from geometric_kernels.utils.special_functions import generalized_kravchuk_normalized +from geometric_kernels.utils.utils import chain, hamming_distance, log_binomial + + +class VilenkinFunctions(EigenfunctionsWithAdditionTheorem): + r""" + Eigenfunctions of the graph Laplacian on the q-ary Hamming graph $H(d,q)$, whose + nodes are indexed by categorical vectors in $\{0, 1, ..., q-1\}^d$. + + These eigenfunctions are the Vilenkin functions (also called Vilenkin-Chrestenson + functions), which generalize the binary Walsh functions to q-ary alphabets. They + map vertices to complex values via products of characters on cyclic groups. + + For the special case $q = 2$, the Vilenkin functions reduce to the Walsh functions + on the binary hypercube $\{0, 1\}^d$. + + .. note:: + The Vilenkin functions can be indexed by "character patterns" - choices of + coordinates and non-identity characters at those coordinates. Each eigenspace + (level) $j$ has dimension $\binom{d}{j}(q-1)^j$, corresponding to choosing + $j$ coordinates and assigning $(q-1)$ possible non-identity characters to each. + + Levels are the whole eigenspaces, comprising all Vilenkin functions with the + same number of coordinates having non-identity characters. The addition theorem + for these is based on generalized Kravchuk polynomials, i.e. discrete orthogonal + polynomials on the q-ary Hamming scheme. + + :param dim: + Dimension $d$ of the q-ary Hamming graph $H(d,q)$. + + :param n_cat: + Number of categories $q \geq 2$ in the q-ary alphabet $\{0, 1, ..., q-1\}$. + + :param num_levels: + Specifies the number of levels (eigenspaces) of the Vilenkin functions to use. + """ + + def __init__(self, dim: int, n_cat: int, num_levels: int) -> None: + assert num_levels <= dim + 1, "The number of levels should be at most dim+1." + self.dim = dim + self.n_cat = n_cat + self._num_levels = num_levels + self._num_eigenfunctions: Optional[int] = None # To be computed when needed. + + if n_cat < 2: + raise ValueError("n_cat must be at least 2.") + + def __call__(self, X: B.Int, **kwargs) -> B.Float: + raise NotImplementedError + + def _addition_theorem( + self, X: B.Numeric, X2: Optional[B.Numeric] = None, **kwargs + ) -> B.Numeric: + + if X2 is None: + X2 = X + + hamming_distances = hamming_distance(X, X2) + + values = [] + + kravchuk_normalized_j_minus_1, kravchuk_normalized_j_minus_2 = None, None + for level in range(self.num_levels): + cur_kravchuk_normalized = generalized_kravchuk_normalized( + self.dim, + level, + hamming_distances, + self.n_cat, + kravchuk_normalized_j_minus_1, + kravchuk_normalized_j_minus_2, + ) # [N, N2] + kravchuk_normalized_j_minus_2 = kravchuk_normalized_j_minus_1 + kravchuk_normalized_j_minus_1 = cur_kravchuk_normalized + + values.append( + comb(self.dim, level) + * (self.n_cat - 1) ** level + * cur_kravchuk_normalized[..., None] + ) # [N, N2, 1] + + return B.concat(*values, axis=-1) # [N, N2, L] + + def _addition_theorem_diag(self, X: B.Numeric, **kwargs) -> B.Numeric: + """ + These are certain easy to compute constants. + """ + values = [ + comb(self.dim, level) + * (self.n_cat - 1) ** level + * B.ones(float_like(X), *X.shape[:-1], 1) # [N, 1] + for level in range(self.num_levels) + ] + return B.concat(*values, axis=1) # [N, L] + + def weighted_outerproduct( + self, + weights: B.Numeric, + X: B.Numeric, + X2: Optional[B.Numeric] = None, # type: ignore + **kwargs, + ) -> B.Numeric: + if X2 is None: + X2 = X + + hamming_distances = hamming_distance(X, X2) + + result = B.zeros(B.dtype(weights), X.shape[0], X2.shape[0]) # [N, N2] + kravchuk_normalized_j_minus_1, kravchuk_normalized_j_minus_2 = None, None + for level in range(self.num_levels): + cur_kravchuk_normalized = generalized_kravchuk_normalized( + self.dim, + level, + hamming_distances, + self.n_cat, + kravchuk_normalized_j_minus_1, + kravchuk_normalized_j_minus_2, + ) + kravchuk_normalized_j_minus_2 = kravchuk_normalized_j_minus_1 + kravchuk_normalized_j_minus_1 = cur_kravchuk_normalized + + # Instead of multiplying weights by binomial coefficients, we sum their + # logs and then exponentiate the result for numerical stability. + # Furthermore, we save the computed Kravchuk polynomials for next iterations. + result += ( + B.exp( + B.log(weights[level]) + + log_binomial(self.dim, level) + + level * B.log(self.n_cat - 1) + ) + * cur_kravchuk_normalized + ) + + return result # [N, N2] + + def weighted_outerproduct_diag( + self, weights: B.Numeric, X: B.Numeric, **kwargs + ) -> B.Numeric: + + # Instead of multiplying weights by binomial coefficients, we sum their + # logs and then exponentiate the result for numerical stability. + result = sum( + B.exp( + B.log(weights[level]) + + log_binomial(self.dim, level) + + level * B.log(self.n_cat - 1) + ) + * B.ones(float_like(X), *X.shape[:-1], 1) + for level in range(self.num_levels) + ) # [N, 1] + + return B.reshape(result, *result.shape[:-1]) # [N,] + + @property + def num_eigenfunctions(self) -> int: + if self._num_eigenfunctions is None: + self._num_eigenfunctions = sum(self.num_eigenfunctions_per_level) + return self._num_eigenfunctions + + @property + def num_levels(self) -> int: + return self._num_levels + + @property + def num_eigenfunctions_per_level(self) -> List[int]: + return [ + comb(self.dim, level) * (self.n_cat - 1) ** level + for level in range(self.num_levels) + ] + + +class HammingGraph(DiscreteSpectrumSpace): + r""" + The GeometricKernels space representing the q-ary Hamming graph + $H(d,q) = \{0, 1, ..., q-1\}^d$, the combinatorial space of categorical + vectors (with $q$ categories) of length $d$. + + The elements of this space are represented by d-dimensional categorical vectors + (with $q$ categories) taking integer values in $\{0, 1, ..., q-1\}$. + + Levels are the whole eigenspaces. + + .. note:: + For the special case $q = 2$, this reduces to the binary hypercube graph, + also available as :class:`HypercubeGraph`. + + .. note:: + A tutorial on how to use this space is available in the + :doc:`HammingGraph.ipynb ` notebook. + + .. note:: + Since the degree matrix is a constant multiple of the identity, all + types of the graph Laplacian coincide on the Hamming graph up to a + constant, we choose the normalized Laplacian for numerical stability. + + :param dim: + Dimension $d$ of the Hamming graph $H(d,q)$, a positive integer. + + :param n_cat: + Number of categories $q$ of the Hamming graph $H(d,q)$, a positive + integer $q \geq 2$. + + .. admonition:: Citation + + If you use this GeometricKernels space in your research, please consider + citing :cite:t:`borovitskiy2023` and :cite:t:`doumont2025`. + """ + + def __init__(self, dim: int, n_cat: int): + if dim < 1: + raise ValueError("dim must be a positive integer.") + if n_cat < 1: + raise ValueError("n_cat must be a positive integer.") + self.dim = dim + self.n_cat = n_cat + + def __str__(self): + return f"HammingGraph({self.dim},{self.n_cat})" + + @property + def dimension(self) -> int: + """ + Returns d, the `dim` parameter that was passed down to `__init__`. + + .. note: + Although this is a graph, and graphs are generally treated as + 0-dimensional throughout GeometricKernels, we make an exception for + HammingGraph. This is because it helps maintain good behavior of + Matérn kernels with the usual values of the smoothness parameter + nu, i.e. nu = 1/2, nu = 3/2, nu = 5/2. + """ + return self.dim + + def get_eigenfunctions(self, num: int) -> Eigenfunctions: + """ + Returns the :class:`~.VilenkinFunctions` object with `num` levels. + + :param num: + Number of levels. + """ + return VilenkinFunctions(self.dim, self.n_cat, num) + + def get_eigenvalues(self, num: int) -> B.Numeric: + eigenvalues = np.array( + [ + (self.n_cat * level) + / ( + self.dim * (self.n_cat - 1) + ) # we assume normalized Laplacian (for numerical stability) + for level in range(num) + ] + ) + return B.reshape(eigenvalues, -1, 1) # [num, 1] + + def get_repeated_eigenvalues(self, num: int) -> B.Numeric: + eigenvalues_per_level = self.get_eigenvalues(num) + + eigenfunctions = VilenkinFunctions(self.dim, self.n_cat, num) + eigenvalues = chain( + B.squeeze(eigenvalues_per_level), + eigenfunctions.num_eigenfunctions_per_level, + ) # [J,] + return B.reshape(eigenvalues, -1, 1) # [J, 1] + + def random(self, key: B.RandomState, number: int) -> B.Numeric: + r""" + Sample uniformly random points on the Hamming graph $H(d,q)$. + + Always returns [N, D] integer array of the `key`'s backend with values + in $\{0, 1, ..., q-1\}$. + + :param key: + Either `np.random.RandomState`, `tf.random.Generator`, + `torch.Generator` or `jax.tensor` (representing random state). + :param number: + Number N of samples to draw. + + :return: + An array of `number` uniformly random samples on the space. + """ + key, random_points = B.random.rand( + key, dtype_double(key), number, self.dimension + ) + + random_points = B.cast(dtype_integer(key), B.floor(random_points * self.n_cat)) + + return key, random_points + + @property + def element_shape(self): + """ + :return: + [d]. + """ + return [self.dimension] + + @property + def element_dtype(self): + """ + :return: + B.Int. + """ + return B.Int diff --git a/geometric_kernels/spaces/hypercube_graph.py b/geometric_kernels/spaces/hypercube_graph.py index f81f41ab..f0cb8030 100644 --- a/geometric_kernels/spaces/hypercube_graph.py +++ b/geometric_kernels/spaces/hypercube_graph.py @@ -17,7 +17,7 @@ EigenfunctionsWithAdditionTheorem, ) from geometric_kernels.utils.special_functions import ( - kravchuk_normalized, + generalized_kravchuk_normalized, walsh_function, ) from geometric_kernels.utils.utils import chain, hamming_distance, log_binomial @@ -74,10 +74,11 @@ def _addition_theorem( kravchuk_normalized_j_minus_1, kravchuk_normalized_j_minus_2 = None, None for level in range(self.num_levels): - cur_kravchuk_normalized = kravchuk_normalized( + cur_kravchuk_normalized = generalized_kravchuk_normalized( self.dim, level, hamming_distances, + 2, kravchuk_normalized_j_minus_1, kravchuk_normalized_j_minus_2, ) # [N, N2] @@ -115,10 +116,11 @@ def weighted_outerproduct( result = B.zeros(B.dtype(weights), X.shape[0], X2.shape[0]) # [N, N2] kravchuk_normalized_j_minus_1, kravchuk_normalized_j_minus_2 = None, None for level in range(self.num_levels): - cur_kravchuk_normalized = kravchuk_normalized( + cur_kravchuk_normalized = generalized_kravchuk_normalized( self.dim, level, hamming_distances, + 2, kravchuk_normalized_j_minus_1, kravchuk_normalized_j_minus_2, ) diff --git a/geometric_kernels/utils/kernel_formulas/__init__.py b/geometric_kernels/utils/kernel_formulas/__init__.py index 82bca600..43d338f1 100644 --- a/geometric_kernels/utils/kernel_formulas/__init__.py +++ b/geometric_kernels/utils/kernel_formulas/__init__.py @@ -4,6 +4,9 @@ euclidean_matern_52_kernel, euclidean_rbf_kernel, ) +from geometric_kernels.utils.kernel_formulas.hamming_graph import ( + hamming_graph_heat_kernel, +) from geometric_kernels.utils.kernel_formulas.hyperbolic import ( hyperbolic_heat_kernel_even, hyperbolic_heat_kernel_odd, diff --git a/geometric_kernels/utils/kernel_formulas/hamming_graph.py b/geometric_kernels/utils/kernel_formulas/hamming_graph.py new file mode 100644 index 00000000..2243b401 --- /dev/null +++ b/geometric_kernels/utils/kernel_formulas/hamming_graph.py @@ -0,0 +1,62 @@ +""" +Implements the closed form expression for the heat kernel on the Hamming graph. + +The implementation is provided mainly for testing purposes. +""" + +from math import sqrt + +import lab as B +from beartype.typing import Optional + +from geometric_kernels.lab_extras import float_like + + +def hamming_graph_heat_kernel( + lengthscale: B.Numeric, + X: B.Numeric, + X2: Optional[B.Numeric] = None, + q: int = 2, + normalized_laplacian: bool = True, +): + """ + Analytic formula for the heat kernel on the Hamming graph, see + Equation (3) in :cite:t:`doumont2025`. + + :param lengthscale: + The length scale of the kernel, an array of shape [1]. + :param X: + A batch of inputs, an array of shape [N, d]. + :param X2: + A batch of inputs, an array of shape [N2, d]. If None, defaults to X. + :param q: + The alphabet size (number of categories). Defaults to 2 (hypercube). + :param normalized_laplacian: + Whether to use normalized Laplacian scaling. + + :return: + The kernel matrix, an array of shape [N, N2]. + """ + if X2 is None: + X2 = X + + assert lengthscale.shape == (1,) + assert X.ndim == 2 and X2.ndim == 2 + assert X.shape[-1] == X2.shape[-1] + + d = X.shape[-1] + + if normalized_laplacian: + lengthscale = lengthscale / sqrt(d * (q - 1)) + + beta = lengthscale**2 / 2 + + # Compute disagreement indicator: 1 when coordinates differ, 0 when they match + # Shape: [N, N2, d] + disagreement = B.cast(float_like(X), X[:, None, :] != X2[None, :, :]) + + exp_neg_beta_q = B.exp(-beta * q) + factor_disagree = (1 - exp_neg_beta_q) / (1 + (q - 1) * exp_neg_beta_q) + log_kernel = B.sum(B.log(factor_disagree) * disagreement, axis=-1) + + return B.exp(log_kernel) # Shape: [N, N2] diff --git a/geometric_kernels/utils/special_functions.py b/geometric_kernels/utils/special_functions.py index 41189737..c691f349 100644 --- a/geometric_kernels/utils/special_functions.py +++ b/geometric_kernels/utils/special_functions.py @@ -45,53 +45,68 @@ def walsh_function(d: int, combination: List[int], x: B.Bool) -> B.Float: return (-1) ** count_nonzero(take_along_axis(x, indices, axis=-1), axis=-1) -def kravchuk_normalized( +def generalized_kravchuk_normalized( d: int, j: int, m: B.Int, + q: int, kravchuk_normalized_j_minus_1: Optional[B.Float] = None, kravchuk_normalized_j_minus_2: Optional[B.Float] = None, ) -> B.Float: r""" - This function returns $G_{d, j, m}/G_{d, j, 0}$ where $G_{d, j, m}$ is the - Kravchuk polynomial defined below. + This function returns $\widetilde{G}_{d, q, j}(m)$ where $\widetilde{G}_{d, q, j}(m)$ is the + normalized generalized Kravchuk polynomial defined below. - Define the Kravchuk polynomial of degree d > 0 and order 0 <= j <= d as the - function $G_{d, j, m}$ of the independent variable 0 <= m <= d given by + Define the generalized Kravchuk polynomial of degree $d > 0$ and order $0 \leq j \leq d$ + as the function $G_{d, q, j}(m)$ of the independent variable $0 \leq m \leq d$ given by - .. math:: G_{d, j, m} = \sum_{T \subseteq \{0, .., d-1\}, |T| = j} w_T(x). + .. math:: G_{d, q, j}(m) = \sum_{\substack{T \subseteq \{0, .., d-1\} \\ |T| = j}} + \sum_{\alpha \in \{1,..,q-1\}^T} \psi_{T,\alpha}(x) \overline{\psi_{T,\alpha}(y)}. - Here $w_T$ are the Walsh functions on the hypercube graph $C^d$ and - $x \in C^d$ is an arbitrary binary vector with $m$ ones (the right-hand side - does not depend on the choice of a particular vector of the kind). + Here $\psi_{T,\alpha}$ are the Vilenkin functions on the q-ary Hamming graph $H(d,q)$ and + $x, y \in \{0, 1, ..., q-1\}^d$ are arbitrary categorical vectors at Hamming distance $m$ + (the right-hand side does not depend on the choice of particular vectors of the kind). + + The normalized polynomial is $\widetilde{G}_{d, q, j}(m) = G_{d, q, j}(m) / G_{d, q, j}(0)$. .. note:: We are using the three term recurrence relation to compute the Kravchuk polynomials. Cf. Equation (60) of Chapter 5 in MacWilliams and Sloane "The - Theory of Error-Correcting Codes", 1977. The parameters q and $\gamma$ - from :cite:t:`macwilliams1977` are set to be q = 2; $\gamma = q - 1 = 1$. + Theory of Error-Correcting Codes", 1977. The parameter $\gamma$ from + :cite:t:`macwilliams1977` is set to $\gamma = q - 1$. + + .. note:: + We use the fact that $G_{d, q, j}(0) = \binom{d}{j}(q-1)^j$. .. note:: - We use the fact that $G_{d, j, 0} = \binom{d}{j}$. + For $q = 2$, this reduces to the classical Kravchuk polynomials. :param d: - The degree of Kravhuk polynomial, an integer d > 0. - Maps to n in :cite:t:`macwilliams1977`. - :param j: d - The order of Kravhuk polynomial, an integer 0 <= j <= d. - Maps to k in :cite:t:`macwilliams1977`. + The degree of Kravchuk polynomial, an integer $d > 0$. + Maps to $n$ in :cite:t:`macwilliams1977`. + + :param j: + The order of Kravchuk polynomial, an integer $0 \leq j \leq d$. + Maps to $k$ in :cite:t:`macwilliams1977`. + :param m: - The independent variable, an integer 0 <= m <= d. - Maps to x in :cite:t:`macwilliams1977`. + The independent variable (Hamming distance), an integer or array with + $0 \leq m \leq d$. Maps to $x$ in :cite:t:`macwilliams1977`. + + :param q: + The alphabet size of the q-ary Hamming graph, an integer $q \geq 2$. + :param kravchuk_normalized_j_minus_1: - The optional precomputed value of $G_{d, j-1, m}/G_{d, j-1, 0}$, helps + The optional precomputed value of $\widetilde{G}_{d, q, j-1}(m)$, helps to avoid exponential complexity growth due to the recursion. + :param kravchuk_normalized_j_minus_2: - The optional precomputed value of $G_{d, j-2, m}/G_{d, j-2, 0}$, helps + The optional precomputed value of $\widetilde{G}_{d, q, j-2}(m)$, helps to avoid exponential complexity growth due to the recursion. :return: - $G_{d, j, m}/G_{d, j, 0}$ where $G_{d, j, m}$ is the Kravchuk polynomial. + $\widetilde{G}_{d, q, j}(m) = G_{d, q, j}(m) / G_{d, q, j}(0)$ where + $G_{d, q, j}(m)$ is the generalized Kravchuk polynomial. """ if d <= 0: raise ValueError("`d` must be positive.") @@ -105,12 +120,20 @@ def kravchuk_normalized( if j == 0: return B.ones(m) elif j == 1: - return 1 - 2 * m / d + return 1 - q * m / (d * (q - 1)) else: if kravchuk_normalized_j_minus_1 is None: - kravchuk_normalized_j_minus_1 = kravchuk_normalized(d, j - 1, m) + kravchuk_normalized_j_minus_1 = generalized_kravchuk_normalized( + d, j - 1, m, q + ) if kravchuk_normalized_j_minus_2 is None: - kravchuk_normalized_j_minus_2 = kravchuk_normalized(d, j - 2, m) - rhs_1 = (d - 2 * m) * kravchuk_normalized_j_minus_1 + kravchuk_normalized_j_minus_2 = generalized_kravchuk_normalized( + d, j - 2, m, q + ) + + rhs_1 = ( + (d - j + 1) * (q - 1) + (j - 1) - q * m + ) * kravchuk_normalized_j_minus_1 rhs_2 = -(j - 1) * kravchuk_normalized_j_minus_2 - return (rhs_1 + rhs_2) / (d - j + 1) + + return (rhs_1 + rhs_2) / ((d - j + 1) * (q - 1)) diff --git a/geometric_kernels/utils/utils.py b/geometric_kernels/utils/utils.py index 452ca8ef..4f5e9f42 100644 --- a/geometric_kernels/utils/utils.py +++ b/geometric_kernels/utils/utils.py @@ -17,9 +17,9 @@ from geometric_kernels.lab_extras import ( count_nonzero, get_random_state, - logical_xor, restore_random_state, ) +from geometric_kernels.lab_extras.extras import int_like def chain(elements: B.Numeric, repetitions: List[int]) -> B.Numeric: @@ -311,7 +311,9 @@ def hamming_distance(x1: B.Bool, x2: B.Bool): An array of shape [N, M] whose entry n, m contains the Hamming distance between x1[n, :] and x2[m, :]. It is of the same backend as x1 and x2. """ - return count_nonzero(logical_xor(x1[:, None, :], x2[None, :, :]), axis=-1) + x1_int = B.cast(int_like(x1), x1) + x2_int = B.cast(int_like(x2), x2) + return count_nonzero(x1_int[:, None, :] != x2_int[None, :, :], axis=-1) def log_binomial(n: B.Int, k: B.Int) -> B.Float: diff --git a/notebooks/FastMaternForHammingGraph.ipynb b/notebooks/FastMaternForHammingGraph.ipynb new file mode 100644 index 00000000..497d3571 --- /dev/null +++ b/notebooks/FastMaternForHammingGraph.ipynb @@ -0,0 +1,268 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/miniconda3/envs/geometrik/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n", + "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", + "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", + "/opt/miniconda3/envs/geometrik/lib/python3.11/site-packages/spherical_harmonics/fundamental_set.py:21: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n", + " from pkg_resources import resource_filename\n", + "INFO (geometric_kernels): Torch backend enabled.\n" + ] + } + ], + "source": [ + "import warnings\n", + "import time\n", + "import numpy as np\n", + "import torch\n", + "import gpytorch\n", + "import botorch\n", + "import geometric_kernels\n", + "import geometric_kernels.torch\n", + "from geometric_kernels.spaces import HypercubeGraph, HammingGraph\n", + "from geometric_kernels.kernels import MaternGeometricKernel\n", + "from geometric_kernels.frontends.gpytorch import GPyTorchGeometricKernel\n", + "from botorch.fit import fit_gpytorch_mll" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def Ackley(x):\n", + " \"\"\"\n", + " The Ackley Function. See https://www.sfu.ca/~ssurjano/ackley.html for details.\n", + " \"\"\"\n", + "\n", + " num_dims = x.shape[1]\n", + " a = 20\n", + " b = 0.2\n", + " c = 2 * np.pi\n", + "\n", + " sum1 = (x**2).sum(axis=1)\n", + " sum2 = (np.cos(c * x)).sum(axis=1)\n", + "\n", + " term1 = -a * np.exp(-b * np.sqrt(sum1 / num_dims))\n", + " term2 = -np.exp(sum2 / num_dims)\n", + "\n", + " return (term1 + term2 + a + np.exp(1)).reshape(-1, 1)\n", + "\n", + "\n", + "def generate_data(space, obj_fun, num_train, num_test):\n", + " key = np.random.RandomState(1234)\n", + " key, x_train = space.random(key, num_train)\n", + " key, x_test = space.random(key, num_test)\n", + "\n", + " y_train = obj_fun(x_train)\n", + " y_test = obj_fun(x_test)\n", + "\n", + " data = [\n", + " torch.tensor(x, dtype=torch.float64) for x in [x_train, y_train, x_test, y_test]\n", + " ]\n", + "\n", + " return data\n", + "\n", + "\n", + "def get_kernel_and_likelihood(kernel):\n", + " scaled_kernel = gpytorch.kernels.ScaleKernel(GPyTorchGeometricKernel(kernel))\n", + "\n", + " noise_prior = gpytorch.priors.torch_priors.GammaPrior(1.1, 0.05)\n", + " noise_prior_mode = (noise_prior.concentration - 1) / noise_prior.rate\n", + " lik_fct = gpytorch.likelihoods.gaussian_likelihood.GaussianLikelihood(\n", + " noise_prior=noise_prior,\n", + " noise_constraint=gpytorch.constraints.GreaterThan(1e-8),\n", + " initial_value=noise_prior_mode,\n", + " )\n", + "\n", + " return scaled_kernel, lik_fct\n", + "\n", + "\n", + "def fit_predict(data, scaled_kernel, lik_fct):\n", + " x_train, y_train, x_test, y_test = data\n", + "\n", + " with warnings.catch_warnings():\n", + " warnings.simplefilter(\"ignore\")\n", + " model = botorch.models.SingleTaskGP(\n", + " x_train, y_train, covar_module=scaled_kernel, likelihood=lik_fct\n", + " )\n", + " mll_fct = gpytorch.mlls.ExactMarginalLogLikelihood(model.likelihood, model)\n", + "\n", + " # Fit\n", + " start = time.time()\n", + " fit_gpytorch_mll(mll=mll_fct)\n", + " end = time.time()\n", + " print(f\"training: {end - start:.4f} s\")\n", + "\n", + " # Predict\n", + " model.eval()\n", + " start = time.time()\n", + " y_pred = model(x_test)\n", + " end = time.time()\n", + " print(f\"prediction: {end - start:.4f} s\")\n", + "\n", + " # RMSE\n", + " rmse = torch.sqrt(((y_pred.mean - y_test) ** 2).mean())\n", + " print(f\"RMSE: {rmse.item():.4f}\")\n", + "\n", + " return model" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "SPACE_DIM = 10\n", + "NUM_TRAIN = 3000\n", + "NUM_TEST = 3000" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fast_matern: False\n", + "\n", + "training: 10.7532 s\n", + "prediction: 2.2959 s\n", + "RMSE: 0.5953\n", + "\n", + "lengthscale: 5.3399\n", + "outputscale: 1.3710\n", + "\n", + "----------------------------------------------------------------------------------------------------\n", + "\n", + "fast_matern: True\n", + "\n", + "training: 37.6229 s\n", + "prediction: 1.2217 s\n", + "RMSE: 0.5972\n", + "\n", + "lengthscale: 3.8122\n", + "outputscale: 0.0225\n", + "\n", + "----------------------------------------------------------------------------------------------------\n", + "\n" + ] + } + ], + "source": [ + "# HypercubeGraph\n", + "for fast_matern in [False, True]:\n", + " print(f\"fast_matern: {fast_matern}\")\n", + " print(\"\")\n", + "\n", + " hypercube_graph = HypercubeGraph(SPACE_DIM)\n", + " kernel = MaternGeometricKernel(hypercube_graph, fast_matern=fast_matern)\n", + "\n", + " data = generate_data(hypercube_graph, Ackley, NUM_TRAIN, NUM_TEST)\n", + "\n", + " scaled_kernel, lik_fct = get_kernel_and_likelihood(kernel)\n", + "\n", + " model = fit_predict(data, scaled_kernel, lik_fct)\n", + "\n", + " print(\"\")\n", + " print(f\"lengthscale: {model.covar_module.base_kernel.lengthscale.item():.4f}\")\n", + " print(f\"outputscale: {model.covar_module.outputscale.item():.4f}\")\n", + " print(\"\")\n", + " print(\"-\" * 100)\n", + " print(\"\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fast_matern: False\n", + "\n", + "training: 65.4289 s\n", + "prediction: 2.7725 s\n", + "RMSE: 0.5869\n", + "\n", + "lengthscale: 3.7185\n", + "outputscale: 0.0219\n", + "\n", + "----------------------------------------------------------------------------------------------------\n", + "\n", + "fast_matern: True\n", + "\n", + "training: 50.6489 s\n", + "prediction: 1.3516 s\n", + "RMSE: 0.5869\n", + "\n", + "lengthscale: 3.7185\n", + "outputscale: 0.0219\n", + "\n", + "----------------------------------------------------------------------------------------------------\n", + "\n" + ] + } + ], + "source": [ + "# HammingGraph\n", + "for fast_matern in [False, True]:\n", + " print(f\"fast_matern: {fast_matern}\")\n", + " print(\"\")\n", + "\n", + " hypercube_graph = HammingGraph(SPACE_DIM, 2)\n", + " kernel = MaternGeometricKernel(hypercube_graph, fast_matern=fast_matern)\n", + "\n", + " data = generate_data(hypercube_graph, Ackley, NUM_TRAIN, NUM_TEST)\n", + "\n", + " scaled_kernel, lik_fct = get_kernel_and_likelihood(kernel)\n", + "\n", + " model = fit_predict(data, scaled_kernel, lik_fct)\n", + "\n", + " print(\"\")\n", + " print(f\"lengthscale: {model.covar_module.base_kernel.lengthscale.item():.4f}\")\n", + " print(f\"outputscale: {model.covar_module.outputscale.item():.4f}\")\n", + " print(\"\")\n", + " print(\"-\" * 100)\n", + " print(\"\")\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "geometrik", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.11" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/HammingGraph.ipynb b/notebooks/HammingGraph.ipynb new file mode 100644 index 00000000..6f7d84d6 --- /dev/null +++ b/notebooks/HammingGraph.ipynb @@ -0,0 +1,758 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "N2YCQeyY50Xg" + }, + "outputs": [], + "source": [ + "# To run this in Google Colab, uncomment the following line\n", + "# !pip install geometric_kernels\n", + "\n", + "# If you want to use a version of the library from a specific branch on GitHub,\n", + "# say, from the \"devel\" branch, uncomment the line below instead\n", + "# !pip install \"git+https://github.com/geometric-kernels/GeometricKernels@devel\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Matérn and Heat Kernels on Hamming Graphs\n", + "\n", + "This notebook shows how to define and evaluate kernels on q-ary Hamming graphs $H(d,q)$ for modeling data encoded as categorical vectors with kernels that respect the geometry of the Hamming distance.\n", + "\n", + "**Note:** When $q=2$, the Hamming graph $H(d,2)$ reduces to the hypercube graph $C^d = \\{0, 1\\}^d$ (see `HypercubeGraph.ipynb`).\n", + "\n", + "At the very end of the notebook we also show how to construct *approximate finite-dimensional feature maps* for the kernels on the Hamming graph and how to use these to efficiently sample the Gaussian processes $\\mathrm{GP}(0, k)$.\n", + "\n", + "**Note:** the points on the Hamming graph $H(d,q)$ are integer vectors of size $d$ where each component takes values in $\\{0, 1, ..., q-1\\}$ (`array`s of the suitable backend).\n", + "\n", + "We use the **numpy** backend here.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Contents\n", + "- [**Basics**](#Basics)\n", + " - [Defining a Space](#Defining-a-Space)\n", + " - [Defining a Kernel](#Defining-a-Kernel)\n", + " - [Evaluating Kernels on Random Inputs](#Evaluating-Kernels-on-Random-Inputs)\n", + " - [Visualizing Kernels](#Visualizing-Kernels)\n", + "- [**Feature Maps and Sampling**](#Feature-Maps-and-Sampling)\n", + " - [Defining a Feature Map](#Defining-a-Feature-Map)\n", + " - [Efficient Sampling using Feature Maps](#Efficient-Sampling-using-Feature-Maps)\n", + "- [**Citation**](#Citation)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Basics" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NaG9OvVp-Ryf", + "outputId": "1fbd9363-48ee-4bd0-e214-056a84c64766" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", + "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", + "/opt/miniconda3/envs/geometrik/lib/python3.11/site-packages/spherical_harmonics/fundamental_set.py:21: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n", + " from pkg_resources import resource_filename\n" + ] + } + ], + "source": [ + "# Import a backend, we use numpy in this example.\n", + "import numpy as np\n", + "\n", + "# Import the geometric_kernels backend.\n", + "import geometric_kernels\n", + "\n", + "# Note: if you are using a backend other than numpy,\n", + "# you _must_ uncomment one of the following lines\n", + "# import geometric_kernels.tensorflow\n", + "# import geometric_kernels.torch\n", + "# import geometric_kernels.jax\n", + "\n", + "# Import a space and an appropriate kernel.\n", + "from geometric_kernels.spaces import HammingGraph\n", + "from geometric_kernels.kernels import MaternGeometricKernel\n", + "\n", + "# We use networkx to visualize graphs\n", + "import networkx as nx\n", + "\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining a Space" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we create a GeometricKernels `space` that corresponds to the 4-dimensional ternary Hamming graph $H(4,3)$, where each coordinate takes values in $\\{0, 1, 2\\}$." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "YJXKhf4y-tgV" + }, + "outputs": [], + "source": [ + "hamming_graph = HammingGraph(4,3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining a Kernel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we create a generic Matérn kernel.\n", + "\n", + "To initialize `MaternGeometricKernel` you just need to provide a `Space` object, in our case this is the `hamming_graph` we have just created above.\n", + "\n", + "There is also an optional second parameter `num` which determines the order of approximation of the kernel (*number of levels*).\n", + "There is a sensible default value for each of the spaces in the library, so change it only if you know what you are doing.\n", + "\n", + "A brief account on theory behind the kernels on the Hamming graph space can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/TODO.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "kernel = MaternGeometricKernel(hamming_graph)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To support JAX, our classes do not keep variables you might want to differentiate over in their state.\n", + "Instead, some methods take a `params` dictionary as input, returning its modified version.\n", + "\n", + "The next line initializes the dictionary of kernel parameters `params` with some default values.\n", + "\n", + "**Note:** our kernels do not provide the outputscale/variance parameter frequently used in Gaussian processes.\n", + "However, it is usually trivial to add it by multiplying the kernel by an (optimizable) constant." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "params: {'nu': array([inf]), 'lengthscale': array([1.])}\n" + ] + } + ], + "source": [ + "params = kernel.init_params()\n", + "print('params:', params)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To define two different kernels, Matern-3/2 and Matern-∞ (aka heat, RBF, squared exponential, diffusion), we need two different versions of `params` we define below.\n", + "\n", + "**Note:** like in the Euclidean or the manifold case, and unlike the general graph case, the $1/2, 3/2, 5/2$ are reasonable values of $\\nu$." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "params[\"lengthscale\"] = np.array([2.0])\n", + "params_32 = params.copy()\n", + "params_inf = params.copy()\n", + "del params\n", + "params_32[\"nu\"] = np.array([3/2])\n", + "\n", + "params_inf[\"nu\"] = np.array([np.inf])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now two kernels are *defined* and we proceed to evaluating both on a set of random inputs." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Evaluating Kernels on Random Inputs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We start by sampling `3` (uniformly) random points on our graph.\n", + "An explicit `key` parameter is needed to support JAX as one of the backends." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0 1 1 2]\n", + " [2 0 0 2]\n", + " [2 2 1 1]] int32\n" + ] + } + ], + "source": [ + "key = np.random.RandomState(1234)\n", + "\n", + "key, xs = hamming_graph.random(key, 3)\n", + "\n", + "print(xs, xs.dtype)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we evaluate the two kernel matrices." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", + "kernel_mat_inf = kernel.K(params_inf, xs, xs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we visualize these matrices using `imshow`." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# find common range of values\n", + "minmin = np.min([np.min(kernel_mat_32), np.min(kernel_mat_inf)])\n", + "maxmax = np.max([np.max(kernel_mat_32), np.max(kernel_mat_inf)])\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)\n", + "cmap = plt.get_cmap('viridis')\n", + "\n", + "ax1.imshow(kernel_mat_32, vmin=minmin, vmax=maxmax, cmap=cmap)\n", + "ax1.set_title('k_32')\n", + "ax1.set_axis_off()\n", + "\n", + "ax2.imshow(kernel_mat_inf, vmin=minmin, vmax=maxmax, cmap=cmap)\n", + "ax2.set_title('k_inf')\n", + "ax2.set_axis_off()\n", + "\n", + "# add space for color bar\n", + "fig.subplots_adjust(right=0.85)\n", + "cbar_ax = fig.add_axes([0.88, 0.25, 0.02, 0.5])\n", + "\n", + "# add colorbar\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=minmin, vmax=maxmax))\n", + "fig.colorbar(sm, cax=cbar_ax)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualizing Kernels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we visualize $k_{\\nu, \\kappa}($ `base_point` $, x)$ for $x \\in $ `other_points`.\n", + "We define `base_point` and `other_points` in the next cell." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "import itertools\n", + "base_point = np.array([0]*4)[None, :] # choosing a fixed node for kernel visualization\n", + "other_points = np.array([list(i) for i in itertools.product([0, 1, 2], repeat=4)])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The next cell evaluates $k_{\\nu, \\kappa}($ `base_point` $, x)$ for $x \\in $ `other_points` for $\\nu$ either $3/2$ or $\\infty$." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "values_32 = kernel.K(params_32, base_point,\n", + " other_points).flatten()\n", + "values_inf = kernel.K(params_inf, base_point,\n", + " other_points).flatten()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We prepare the networkx graph for visualizing the space" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def hamming_graph_nx(d, q):\n", + " \"\"\"Create q-ary Hamming graph of dimension d.\"\"\"\n", + " G = nx.Graph()\n", + " vertices = list(itertools.product(range(q), repeat=d))\n", + " G.add_nodes_from(range(len(vertices)))\n", + " \n", + " for i, v1 in enumerate(vertices):\n", + " for j, v2 in enumerate(vertices):\n", + " if i < j and sum(a != b for a, b in zip(v1, v2)) == 1:\n", + " G.add_edge(i, j)\n", + " return G\n", + "\n", + "nx_graph = hamming_graph_nx(4, 3) # 81 vertices\n", + "pos = nx.spring_layout(nx_graph, seed=42) # Auto-generate layout" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we visualize the kernels" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7kAAAFoCAYAAACSWjxjAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQd8FGUTxic9AULvvRfpgnSUKiJFsCAoAooidrFh7/WzF7ChqNhA6dKRIr330HvvEEgv9/3+b3zD3uXucnsJAsn7+DtJLrd7u3t778wz88xMgMPhcIiBgYGBgYGBgYGBgYGBQQ5A4KU+AAMDAwMDAwMDAwMDAwOD7IIhuQYGBgYGBgYGBgYGBgY5BobkGhgYGBgYGBgYGBgYGOQYGJJrYGBgYGBgYGBgYGBgkGNgSK6BgYGBgYGBgYGBgYFBjoEhuQYGBgYGBgYGBgYGBgY5BobkGhgYGBgYGBgYGBgYGOQYGJJrYGBgYGBgYGBgYGBgkGNgSK6BgYGBgYGBgYGBgYFBjoEhuQYGBgYGBgYGBgYGBgY5BobkGhgYGBgYGBgYGBgYGOQY5DqS+8MPP0hAQIDs2bPH732cP39eAgMD5eOPP5bLGf/73/+kZs2akpqaqn4fMGCAOncederUcXqtt7/lFnzyySfp14DHiRMnvD5/MfDVV19J+fLlJSEhwedtVqxYIS1atJC8efOq41u7dq3khO/ZpcKrr76qjt3AwMAgu5FTfBBX/8KbH2H8C+NfZDeMj2FwUUiuvrFWrlzp9PzZs2elSZMmEh4eLtOnT5ecjI0bN4rD4bisF+vo6Gh57733ZOjQocoYahQtWlRGjRol7777boZtPP2NBZH9lC5dWiIiIqRp06Yya9Ysn4/lStn+hhtuUOffs2dPn56/GMAZSExMlK+//tqn1yclJcltt90mp06dUg4Px1mhQoWLfpwGBgYGlwLGB7n0Pogn/8KbH+HN97hSfISsbGv8CwODSwCHTYwcOdLBZitWrEh/7uzZs44mTZo4wsLCHFOnTnVcztDHv3v3br/38c0336h9HD582HG54uOPP3bkz5/fERcXl/5c//79HRUqVHD7em9/6927tyM4ONjx1FNPOb7++mtH8+bN1e8LFizw6ViutO1feeUV9fkeP37cp+ezG88884z6LFJTUzN97ebNm9Uxffvtt47LCcnJyere8+UcLjfoz9nAwODyg/FBLr0P4s6/8OZHePMvrkQfISvbGv8ie2B8DANfkGWSGx0d7WjWrJkjNDTU8ddffzmyC+fPn3dcrgbmkUcecRQtWtRxOaNevXqOvn37Oj3nD8ldtmyZul7vv/9++nMsLFWqVFGLeWa4Ere/1EZo5cqV6n3+/vvvTF87f/589do//vjjsv/uXSkwBsjA4PKF8UEuvQ/izr/wl+ReiT5CVrY1/kXu9i+A8TH+O2SpJpe6EKQWq1evlrFjx0qXLl2c/n7w4EG55557pESJEhIWFia1a9eW77//3qM+PSoqSu644w4pVKiQtGrVKv35HTt2KJlFwYIFpUCBAnL33XdLbGxshv34+n7usGXLFtm3b59Pr92wYYPatxXffvuthIaGyuOPPy4pKSlyKbF7925Zv369dOjQIcv7+vPPPyUoKEgGDRqU/hxysIEDB8qSJUtk//79OXr7S4FGjRpJ4cKFZeLEiV5fx3fiuuuuUz8jKeK70qZNG/X7mjVrpHPnzpI/f37Jly+ftG/fXpYuXerzd+9i1MvY/T57OlZftvf1/BcuXCjXXHONuieqVKniVcbly/py7tw5tQZUrFhRvaZ48eLSsWNHtUYaGBhkL4wP8t/7INnpX1wONj4r2+dW/8JXG3ux/At3PsZ/6V/4ev52fAxf1w7jY9hDsPiJmJgY9QFTlM4XvWvXrk5/P3r0qDRr1kzdNA8//LAUK1ZMpk2bpr781HPwIbmCL1K1atXk7bffVvUmx44dU8/36tVLKlWqJO+88476IEeMGKE+WGpCsvJ+VtSqVUt9oefNm+eTgenTp4/6OTk5We37m2++kWHDhsl9990nlxqLFy9W/1599dVZ3hdf5OrVq6svshXUPgGaEJQrVy7Hbn+pwGe3aNEir6+5//77pUyZMur78uijj6qFlAVy06ZN0rp1a3XOzzzzjISEhKiFFQM1f/58VTOU2XfvYsKX73NWtvf1/PkeX3/99WqtwMDxXX7llVfUNXSFr+vL4MGD1XrIa6666io5efKkMnKbN2/Olu+jgYFBGowPcml8kOz0Ly4HG5+V7XOjfwHs+hg5yb+4GD6GnbXD+Bg24a/UBulJSEiIY8KECW5fN3DgQEepUqUcJ06cyFC/UKBAAUdsbGyG1H2fPn2cXqufv+eee5ye79mzp6NIkSJ+vZ8nqRDPXXfddZme/6FDh9Rrv/rqK8fJkycd7dq1cxQuXNgxd+5cx+WCF198UR3juXPnsixXrl27tjpHV2zatCn9OnjDlbj9pZYTgUGDBjkiIiIyfR33naucqEePHkq6t3PnTqf7NjIy0nHttdc6be/pu5dVuPue2fk+u4Ov2/t6/rwuPDzcsXfv3vTnoqKiHEFBQRmkRL6uL/z80EMPZXouBgYG/sH4IJfWB/HkX/grV74SfYTc7F/YsbEXy79w9z36r/yLi+Fj2FmrjI/xH8mViTyQfncXpWK9RjrUrVs39TMt0fWjU6dOqguiu9Q6EQp3cH2eCArRCyIcWXk/12P2JYKKTAcQcSGydejQIVm2bJmTjONSg2sTHBysJBRZRVxcnJJEuILPXv89J2+fnUDKwn1DRC8zIOvh2HyR2ViBTG3mzJnSo0cPqVy5cvrzpUqVUnIhIn76e+PLdy8r5+AJmX2fs7K9r+fP62bMmKFex0gFazaFNcMKO+sLEifWA9YFAwODiwfjg1waHyQ7/YvLwcZnZfvLyb+wY5/99S/89TFyin8BstvHsLt2GB/DHvwmuaTmqf+gHmbr1q1Ofzt+/LicOXNGyWdIu1sf6NuBlgFZgUTAHaw3iP6CgtOnT2fp/fwB8gOAVADJAXUXVatWdXoN9Rnc8EgZ6tatK5MnT86wH2QsDRs2VBp8zo/XIldgf5cTaInvbqZafHx8+t9z8vaXClrSY3eWGt8FDFeNGjUy/I3FlZmG7uqEPH33LgYy+z5nZXtfz5/XYeSRULnCdVs76wuzIxnvgeONZA1jvWvXLp/Oy8DAwHcYH8SzD3Il4VLb+Kxsn9v8C399jJziX4Ds9jHsrh3Gx/iPanLRgk+dOlUVW1P0jL5fR1T1cPC+fftK//793W5fr169DM95WhAo7Pf2RfX3/fw1MMwJo4CcG43GF0RWrHjiiSfk888/VxE+6oVo0MBNWKRIkfTXMMeP5yMjI1Xkp2zZsjJmzBgVzaGQPitRUt4H7T8F6uw/K4CsUxDvisOHD6t/mQ2Xk7fPTlAvweLnWr/jDiyoefLk+c+MpK/vY+ccPCGz7/PF3t4u7Kwv1PMQ+R0/fryK9r7//vuqlmfcuHGqftDAwCB7YHwQzz7IxUR2+heXg43PyvaXk39hxz4b/+LibW8XdtcO42P8RyQXEEWYMGGC6miIkVmwYEF6BILFj3R9dnXg84b/8v0wMA0aNFCdDBs3bqwGeHPeWp4Catasmf4zkTKGb7MQupJchqKTvdXo3bu3IshEpemA5w3fffedTJo0SXXIoysjhf3c7ES19fvTBTGrhpVznTt3rpJfWBce5BL67zl5++wEWQeCGb6Az46ooD/fBYyXa2YDcJ8EBgZmqRGGnXO4FPD1/PPmzasM7/bt2zO8znVbu+sLjs+DDz6oHkRgMdxvvfWWMUAGBtkM44O490Gyiv/Kv7gcbHxWtr+c/As79tlf/+Ji+xiXu39xMXwMf9YO42P4jiyNEAJEUX/77TfVdpsFkC87kZBbbrlF6cyJNLqC9Hx2Ijvez5f2/dyEdDBDgsyNSeSE93vggQcyvJabjxucmpl27dqpbTSIgHKT6w58GnwZTp065ZP0CEOHgaHTIedOO3WuP2jevLn6d+XKlZJV3Hrrreq8kVJoIM8ZOXKk6iCX2WJ2pW9/qUANRosWLfz6LtDND+fEOr6H+rVff/1Vte/PSpT0coev58/rqHfBQbZ+7/l+U0fjz/rCfUb9jBV0ZSSa707SZmBgkHUYHySjD8J61717d+U0sw6iEsPePffccz6dz3/lX1wONj4r2+c2/wIYHyN7fQw7a4fxMf7jTK4GkUSiitSXsrDqLCURLr7otLRHWgSB48s1e/Zs9XN2Iqvv50v7fkgotRaasJJt/fLLL5Vunp+pkdEYPny4kiyzP25ca+3D33//rd6LiI8G2n3kChghZnP5YoRKliwpN910k4oaWgvg+blOnTrqvPlMsgKuJ1FcjouIEQT8xx9/VF9uor05fXtfwGfr6+gHX7Bq1Sp1v/LZ+oM333xTZs2apRZbgi00CaF+jUWQeo6cDl/P/7XXXlNrFdIfXocEj+8s8+l0cxc76wvBK6LQOD7169dXJQf8jZKFDz/88BJcCQOD3AHjgzj7IKw3HA9+xZ133qkyRfgdjEPhXwIDl4N/cTnY+Kxsnxv9C2B8jOz1MXxdO4yP4Qf8bdu9YsWKDH/74IMP1N+6du3qSEpKchw9elS1ui5Xrpxq9V+yZElH+/btHd98802WWqp7asHvy/tlpX3/mDFj1OtoD2/Fgw8+qN5v/vz5brfjekyZMiX99/vvv18dh0ZiYqKjS5cujjvuuMORmprq8AXFihVztG7dWrUTd/e+H330kSNfvnxOrcf9GSEE4uLiHE899ZS6nmFhYY5rrrnGMX36dJ+O80rc3s79yBgFnqPVe3Zh6NChjvLly/t0L3hq8b969WpHp06d1D2QJ08eR9u2bR2LFy/OsP3FGlvgbYSQr99nX4/V3fa+nj/fnUaNGqlxAJUrV1YjH/T7uCKz9SUhIcHx9NNPO+rXr69GCeTNm1f9PHz4cBtXzsDAwBuMD5K5D/Lwww872Xa2A5s3b3YMGzbMcTH8C39HCF2JPkJu9y98tbEXcyySpxFC/4V/cTF8DF/WDuNj2IdtkmtgHzfccIPj008/Tf+9UqVKaqYWSElJcdx+++3pRtkXHDlyRM3eio+Pdzz//POODh06ZHjNmTNn1Oy8ESNGOBkavkB8iU+fPu30em9/yy3AWHH+LCLWxc7T84DgRUBAgGP9+vXZcgx8pixun3zySbbsz8DAwMAgd+HZZ59VQYB169Yp/6B58+aOY8eOOd59912Pwfis+hfe/AjjXxj/wsDgUsCQ3GwGi/8vv/yiInCQViKoRPfWrFmTHkkl8qJx7733quHRLHTugHHgYcWsWbMcDRs2VD9juIgiLVmyJMO2GLQaNWooIq33xSLKgyHmru/j6W+5BR9//HH6NbAaG0/PAyK42Tno/Msvv1TOAMbIwMDAwMDALk6dOuXo27evo1u3bo5du3Y5ZsyYobLEZJAuln/hzY8w/oXxLwwMLgUC+J8/MmcD96DpBbUOa9asUS3HqdF44YUX5Oabb1Z//+STT+TIkSNKg793716pWLGi6opobVs+bdo0peEHNI64/fbblU5f4+OPP1b7/+mnn9Tvjz32mGq6MWXKFK/HFhUVlT5AGi2/tbOzt7/lFtC63tr1jjqYkJAQj88bGBgYGBhcqchO/8KbH2H8C+NfGBhcChiS+x+DDoXPPvustGnTJtPXUqROh8N169aZRc/AwMDAwMAgW2D8CwMDg5yOLI8QMrAHxgm1bNnSp9fSsY0IqDFABgYG2Yl//vlHunXrpkYP0L2TMQeZge6ezOMLCwtTChXGihgYGFyZMP6FgYFBTvc5DMn9j/HMM88Yo2JgYHBJERMTo0YQDBs2zKfX7969W7p06SJt27aVtWvXyuOPPy733ntvhpnCBgYGBgYGBgaXg89h5MoGBgYGuRhEVcePHy89evTw+JqhQ4eqmjzrsPrevXvLmTNn1BxAAwMDAwMDA4PLyecI9vmVBgYGBgYXFfHx8ZKYmOjXtsQrMR5WIPPhkVUsWbJENamxolOnTiq6amBgYGBgYHDlIT6H+xyG5BoYGBhcJsamUoV8cuRYil/b07X0/PnzTs+98sor8uqrr2b52OgIX6JECafn+J1u8nFxcRIREZHl9zAwMDAwMDD4bxCfC3wOQ3INDAwMLgMQTcXY7F5VQfJH2muXEH0uVSo12qvGUeTPnz/9+eyIqBoYGBgYGBjkLCTmAp/DkFwDAwODywh586U97CDl384KGBurwckulCxZUo4ePer0HL/zXiaLa2BgYGBgcGUibw72OQzJNTAwMLiMkCoO9bC7zcVE8+bNZerUqU7PzZo1Sz1vYGBgYGBgcGUiNQf7HGaEkIGBgcFlhFQ//7MD6mhoy89Dt+vn53379qnfn3vuOenXr1/66wcPHiy7du1SI9C2bNkiw4cPlzFjxsiQIUOy+ewNDAwMDAwM/iuk5mCfw5BcAwMDg1yGlStXSsOGDdUDPPHEE+rnl19+Wf1++PDhdOMDKlWqpNr5E0ll1t2HH34oI0aMUN0ODQwMDAwMDAwuN5/DzMk1MDAwuAxA18ACBQrI/i1l/GoCUa7mQTl79uxFqY8xMDAwMDAwyDmIzgU+h6nJNTAwMLiMcDnWxxgYGBgYGBjkPKTmYJ/DkFwDAwODywgYj5QcanAMDAwMDAwMLh+k5mCfw5BcAwMDg8sIOTmqamBgYGBgYHD5IDUH+xyG5BoYGBhcRkhxONTD7jYGBgYGBgYGBnaQkoN9DtNd2cDAwMDAwMDAwMDAwCDHwGRyDQwMDC4jMH3O3gQ6+683MDAwMDAwMEjNwT6HIbkGBgYGlxFS/GgCYff1BgYGBgYGBgYpOdjnMCTXwMDA4DJCiiPtYXcbAwMDAwMDAwM7SMnBPochuQYGBgaXEXKydMjAwMDAwMDg8kFqDvY5DMk1MDAwuIyQKgGSIgG2tzEwMDAwMDAwsIPUHOxzmO7KBgYGBgYGBgYGBgYGBjkGJpNrkCXEJybLyh375UxsvIQGB0mlEoWlWqmil/qwDAyuWKQ60h52tzEwMDDI6UhOTpHVmw/I6ehYCQoMkLIlCknNyiUu9WEZGFyxSM3BPochuQZ+4eDJs/LbgrUyaXmUnI2Nd/pb/YqlpFer+tL56hoSFGjEAgYGdpDih3TI7usNDAwMriScOH1exs5cK5PmbpBTZ2Od/latQjG5uWMDufHaqyQ0xLi1BgZ2kJKDfQ6zGhjYxtKte+XJkX/J+fhEt39ft+ewekxfvVXeH9BFIkJD/vNjNDC4UpGTDY6BgYGBXUTtPCJP/W+8yt66w/a9x+W9EbNk2oJN8r+nekiBfBH/+TEaGFypSMnBPodJsxnYwvo9h+WxEZM8ElwrFkTtlqd/mCIpqVdKHzYDg0uPVEeAXw8DAwODnIY9B0/K4++M9UhwrVi/9ZAiw/GJSf/JsRkY5ASk5mCfw5BcA1t4Y8xsiU9K9vn1EF0yugYGBvaiqnYfBgYGBjkNH/0wR87FOJdEecPG7Ydl/Kx1F/WYDAxyElJysM9hSK6Bz1i966BsO3TC9nZjFhmDY2BgYGBgYOA79h0+JSs37bO93fjZ68XhuEI64xgYGFw0GJJr4DPGLt7g13Zrdx+WHYftk2MDg9yIFAn062FgYGCQkzBxzgbxh6vuP3JaVm3afzEOycAgxyElB/scV8ZRGlwW2H30lN/b7jl2OluPxcAgp8LhR20M2xgYGBjkJOw9lAWf49DJbD0WA4OcCkcO9jlMd2UDn5GUkuL3tonJ/m9rYJCbkJM7HRoYGBj4iqSklEuyrYFBbkJKDvY5DMk18Bl5QoL83jZfuBkjZGDgC1Icgephb5uLdjgGBgYGlwQRYf77HHkjjM9hYJDbfQ5Dcg084vjx47JmzRpJTk7rply7eD5Zu/eo7f3kjwiTc/u2y7R929TvJUqUkPr160tQkP8GzMAgpyJVAiTVZiVJqlwhFsfAwMDAA06fPi2rVq2SxMS0EYUVi4fIfD/2E0pAPvawTJ16UAICAqRw4cJy9dVXS0iIIb4GBrnJ5zAk1yAdJ0+eVAZGk9qiRYtKu3btJDg47Ta5Nj5Bxq//VmIT7M2gq1s0XEoUKyqNGzdWvx85ckRmz54tKf/Kn0uXLi316tWTwEBTIm5gYGBgYJAbcPbsWVm5cqUkJCSo3wsWLCitW7eWsLAw9XtySqpMWXxATpyJsbXfamXySJFCkdKiRQtFcvFt5s2bJ0lJab5LsWLFpGHDhum+jYGBQc6E+YbnYuioKQs/7faLFCkibdu29RjtzBceJn1aN5DvZq/w+T0iw8PkxbtvldTYaJk4caJ6j5YtW0qnTp3SX3Pw4EGZOXNmesv/cuXKyVVXXWVIr0GuRE6ujzEwMMi9OHfunKxYsULi49Pm3hYoUED5A+Hh4W5fHxwUKH27N5FPfprr83uEhgTL0ME9pGCeAJk8ebJERkbKddddJx07dkx/zbFjx2TOnDnpgfaSJUuqQLtRlxnkRqTkYJ/DkNxchDNnzqioqZYCIeG59tprJTQ01Od9PHxjS1mxaausPxyd6WtDgwNlcKvqUrpwfpHC+aVs2bJKAj1p0iTJnz+/MjwQ2TJlyqiHxr59+2TGjBnppLdSpUpSs2ZNFZE1MMjp8K8+5sqQDhkYGOQenD9/XpHauLg49TuEs3nz5hIREeHzPm7vfLUsXxMlizdkXioVFBggt7erKNUqFFe/d+/eXWWLp0yZorLDWplWvHhxuf7669O3O3z4sMyaNUtSU1PV7/gjdevWNYF2g1yBlBzscwQ4zMTsHIvo6GhFanXUFClQo0aN0qVA/uCff/6REiVLyrg1u2XCii0Sn5xmFFxRo0wxealXB0k8kVYTQz2MFRge9mU1PJ6we/du2bJliyK9PKpVq6YehvQa5LTvK5mNseuqS95IexmFmHMpckv9bep7RQDJwMDA4L9GTEyMIrWxsbHq93z58qkypTx58vi9T3wY1GUrt5+TX/5aKXEJ7rsmly9dSJ4c0F7yBcUolRoZYis4prlz5yriimLNU/YYHDhwQDZu3JhOesuXLy+1a9c2PodBjkJ0LvA5DMnNwVIgbjwMjLfF3A6WLVsmefPmlTp16sjYsWOl041dZcqqLfL3+u2y7/AxKVKokFQuUVhKOaLlwb63ORkpZEDUwLhCGx6MB2Q3s2Pldt2xY4d6aNSoUUNle/8LA5Sa6pBDB05JTEyChIeHSKnShSQ0zAgiDLLP4PyxrqbksWlwYs+lyG31t1z2BsfAwCDngAwtPgcZWwCZveaaa5SfkB1Yv369qtdln+PHj5cbOneRv5duk9lLtsreA0ekUKGCUrZ4ASmeJ1YevrdX+nabNm1SyjVXogtQsuFzUKbVpk0bRcQzw969eyUqKipdXVa5cmXld/xXpPfQnuNy/myc8jVKli8i4Xn8T1QYGOQmn8OQ3GzC9sMnZMzCdTJ/0y45Gxsv4SHBUrVUUbm1RT3pUL+qhFyEWg/XqClSIEitHSmQr6DLMrcKGVkMD2S0evXq6X9HXqzrbKdPny4dOnRwys56I7ra8FAjg+EhyuqL4QEc09atW2XXrl3pzxFxrVChgmQnos/GyrS/1sqUCavl8KEz6c9H5o+Q62+sJ916NpIyZQtn63sa5E6D8/vaq/wyOL0bRF32BsfAwCB7sP/IaRk/a53MXb5dzp6Lk+DgIKlQupB0b1tXOrasKeGh2d9JmAA6PgcBdYCvgc+B75HdwK6fOHFCEVXUXKdOnVJKNHc+B6qwBg0aOK19EF3WQ5pPuQP1uDSjgqBTtlWoUCGffQ6tLtNAWVa1atVsJb0x5+Jk9h/LZcqohbJ/+wWpdkTeMGl7c2Pp1r+1VKxZOtvezyD3IToX+ByG5GYR0bHx8vzP02VB1G6PrykSmUfeuKOTtKxVMUvvBZnFwEBuAdFSDEx2RU09gQgmNzK1NNwu48aNk1tuucXpNVaDgwGkoRVRUis4dmRHGCNPwPAQZeUc7RgeDY6P46WuV4PaGuqB/cWaVbvltef/lJjzaR0g3SEwMEAefLyT3HRLWgdpAwO7yA0Gx8DAIGuIT0ySt7+eKbOXUMLj/jWRecPl6XvaS8cWNbP0XmRRCVCzrgCC2/gcF3uNgUTyQN0FUI558zmYCMHEhhtuuMHpNUiO8UfwXbz5DAsWLFAS52bNmqkRh3bgqi7jd3qIZEVdtn39PnllwDdy+pj33id3DrlB+j55o1/vYWAQnQt8DqOzzALOxSXIPZ//obK43nDyXKw8+u1E+eDurtK2bpUsSYEwML5mObMDLNw0i6JJFCDb2r59e6/bENXVx2wFkqPly5fLunXr1JxcdyDbSxYYQ0F0FsODgfLV8GBUyOTyANTUbNiwQWWf+RsP3rtUqVI+7W/jun3ywlO/S1Ki+zogq4z5i4+mq+Puces1Pu3bwMAdmFeXU2fWGRgY+I+ExGQZ8s5YWbvloNfXnYuJl1e+mCJxCUkqs+srUFRBapH6YitpSkn2lH4e/xUOHTqksqSdO3dOL5Nq0qSJ121QjelOyVZQWoX9X7p0qSKw7sB5ElDHdvNevBbFGXW4voDtdZ8QwH44/mnTpqX/HX/E1/3t2XJInus9TGKi05p1ecMvH09Xvke/p7v4tG8Dg9zmcxiSmwW88tvMTAmuRnJqqjz701QZ+2w/KVukgEcpEAZGS4F01PRiSIF8wf79+5UMWHchJLuKEfTF4HHMRHiIElmBsYLoQjpp2e8JGAaItb+GR4MmE5BaTaoxhLw38mugJdR0W3RFSnKqvPXK+EwJrhVffjpTmjSrIqWNdNnAT6Q4AtTD7jYGBgY5G5+NmpcpwdUgy/u/72ZLjYrFpUYl90FiyoNQXSEFBprU2lVQZReQJxPYv+mmm9IztHQ+btq0aabbMnoQBZerj4CSC6KLH+FtP/gcmgjjH/BglKEmr76C/dSqVUs9dKAdddnUqVPT/47vY50oYcX/HvnJJ4Kr8dunM6RJ+9pS8+qsKQUNci9ScrDPYUiunzhw4ozM2XCh+ZEviE9Klj8WrZMh3a9NlwJhYIiaalKLgXElhpcCR48eVRnXrl27pj/HLFta8vsC6mhoya+jsa5EF4OTGdH1ZHgwHtZ6YDvQpFbXBmNE165dqz4HHRGm7ph5vosWbJUTx9MCDr6CqOpfE1bLoIc7+HV8BgYpEqge9ra5MqKqBgYG/uHs+Tj5a/4mW9ukpKTK6Gmr5eUHO6fbu9WrVysyCSgf0vbucpBOUqp06623upUkZwbILETSXSCcv+FvZEZ0NbSPADll5CHSY/bhDwi0k1HmoUkvx4J/pdVllHAxq3fjsp2ye/Mh2+/x148LDMk18BspOdjnMCTXT4xZtN5jPYw3/LFwnVQOiJbQ4KBLIgXyBUiEFy5c6FQDQ3dB6lp9HZbuST6kgaEhO0uE1VfjYTU8EydOVB0O/TU81uMkW26NbOMEYAz//GW7X/ucMXWdDBjURkJDzdfLwD5SHYHqYW+bK8PgGBgY+Ie/5m2UxKRk29tRu3tVqSTJExas7B02NDP5738NSrOYZdu7d+/0OlayyzS28rWRJtvpMYPuamEJqEMsUZL5ev5kcnns3LlT+RxkX63+gr+kF1Kre5PgJ3Fc+B0zRqzza5///LVGBr16s+QvdHH7sxjkTKTmYJ/DTLr2E4u27PFru5jEZClXu6HKcFLberkRXCTJZGxvvvlmp+eRUVNTawdEVCHHnkCGltpdmkPYAUYHORM1yhgeji27QGQbAn7jjTfKyeOJfu0j+mycHD2c1qjDwMDfqKrdh4GBQc7FsnX++RxJyalSpHRNZdMoPSpWrJhcTqAEimaWvXr1ciKnZHWZtGAHEHiUWZ5A2RLJBSTRdlClShXlc5BtxedYtGhR+jihrILEAdl0Pp+Y4/aDGCApIVnV8hoY+IOUHOxzmFSTnzgfl5iFbT136b2UQD7NAm6NpgIin64E98C+k7Jj2xFJSEiWvPnCJD4u4+JMlpXorLdxPjSVWrx4sSK6Ws5jx/DwYHA7x120aFE1LiC72vgnxCf5vW18vP/3h4GBgYGBQXb5HOdiL0+fgyzmH3/8oQiuVSW2efNm1aHYasuPHjgl29bulfjYRDVGJyYmPsP+yLRCcj2NKgRkUHkNRNdu4B41Gw+acSJjpqssvUPIzmYH4rPwGSfE+e+vGBjkVBiS6yfCsyBF3bB2jcTu36YykRUrVlQLs68y4IsFanX+/PNPuf32250WbIzQwYMH0+U9C+dvkYljV8raVc5R5eDgQNkelSo9b2siVaqlNbnQBsqTfEgDYgrRZa6d7or8Xxkezo/GFnv27EnvCK2PNTQ0UOLiUsUf5MsX7td2BgapfjR18O8uNTAwuFIQFuK/z7FtS5RMTzio+n4QdKZJk3WO/aUAfsGYMWOUagwFlfV5fAFdm7tq/maZNPIfWTknSvW80AgMCpCt805Lj4HXSa1GldKf57woO7Lu0x3Rpb8HKjB/5Mdkw8ns0lyTQD7XlayzL9eUmlx6njAiiTpkq2/kCPS9yaUr8uY3PoeBf0jNwT6HIbl+4qpyJWTPsdO2twsJCpQ+N3WWwvnyKGkw5Orvv/9WC58VLPSFCxdWDQ9YULNzyLgreG+MDUbFdZFGuozEiU7DH733l8ycut7tPpKTU2XGlHXy94wNMmRoF7n+xvpOUVNvkVVNdJEAUW+LHNkfuBqesLAwNasX8mslsVpmxDWFCJcuXVodp+toptVLYmXOLHuNPkCZcoWlZOnLS4ZukNPb+V8Z0iEDAwP/ULNyCVm75YDt7XAdevXoKOVLFVa1r5QQIQV21zODADG9LhjZdzF9DmwwQfUuXbpkqLlldKAeWTjijQky9us5bveRmuKQfyatlgWT18jAF2+SW+5vl970El8C2+8N+CTUwdJ0kt4o/oAmod26dZPY2FjVJItrBtnFB8Hn0POFrT4HD2TPBPRdm4zuXRoj47+dZ/s48hfOK1XrlvPrHAwMUnOwz2FIrp+4rWU9mbpqi+3tGpYtLIvnzVF1Ia1atXKa6WoFiyINoIj2EXF0rf9goWTWKyQ4KyOG2C9yIbomQwqt4P05zrx588pH73omuK5k94O3J0tERKi0bltLZVh9IbnaONHwyg7R1VFRq0HR8/0w6O+9957qHHnbbbfZrkXqdnNjv0hu1x5XX1QHwSBnI8URqB52tzEwMMi56Nmhnoyetsp2w8vq5QvJ+lWLZVNQkLKxyIB5uAM2FJ+DRkgaVt8D8ovPkdVeIiiuIIOQatcxioxQxFb/9P4UjwTXCo4PMhwWESJd+7VWwWoSCL6AWlhIrh2iy/vpwDnNsbSt1xnkjz76SPlkZKg9zeb1hC53tZIJI+bbrve9/vZmEhrmOXNtYJBbfQ5Dcv3E1ZXLSI3SxWTroeO2tnuoR3tpUKm0qn+F0EHEmEnHYmiVLLNwksnl4YncIbPFGOkMpd5OL7g0fkKaBOHzhAkTJqhMrWsWE8yZM0ct1BvX7ZNpkz03c3AF6/NnH0yTpi2rqQ7DvsiHNCD+XBdqchgVxGLvSmKt0FFRSLG70UtkdmlswblwDBhWd+fqDnXqlZOaV5WRLVG+zSUEEXlCJCXgkHpPb9fdwMATUiVAPexuY2BgkHNBJrZJ3QqybL3nZo7uMOCW1tLmmmqqJIkMJyQSGwjhdbXJ2FDd9dcV2hZjm11tMXYY/4WgNiVYyHc9Yfr06UoiTA8NV5ANpQHTgV3H5PfPZto6z29fmyDXdbtaIgvlVSSTY/RlHCPkFpJLVhfSy3kyYgmf4+TJk24D1sWLF1fzcyH7rn9n7CJZ8nnz5ql9tm7d2ue5w2UqF5emHWvL0pm+N+MMoWt28fOK2JOQMDCwi9Qc7HMEOLKrRVwuxPbDJ+TuT8fIuXjfmjr0a9NQnuyRUUJDNJBxOhBXDITdBkzuAMnav3+/kibxsytYDHft2qUILhlhV2zbtk0RcZpHvf3qeJnrR0Zz6Ms3SYdOdRUJp8mDu06JnqKiNKLCQFE7RPSY65LV6DGGB5kWxuDaa6/1yfAcPxYtjw3+QY4fjc70tSEhgfLuJ3dKzatKKUOOwcdoGhj4AuqzuOc/XtlCIvLZiz/GnU+WIY0XK8fONTtiYGCQM3D4eLTc9/KvcvKMb5nKTi2ry6sPd8vwPEQXwgvxpVwHpVVW1UfsiyaQ2HIysq5Alnzo0CHV7Klq1aoZ/k7QniwypUtfvzpOJoywL9tFtnzr4PbqWGbNmqWmWLjzOfA1OE58D8C54/NQvsSxQcDJWOMjZOW68F4LFixQqjgSGfgymeHcmVh56uZPZN+2I5m+lrrkF74eqIgxAQLsB8ELAwNfEJ0LfA5DcrOIqP1H5eFvJsjJc7FeX3dP+8ZSNHqfmj3rLcrJIk/TBQBBwgBdDCAXwujouXIa+neGlQ8cOFBCQvJIn5s+laQk+w0R6tYvJx8O66eioqNGjVLZVmszKsDvREU1ibUaFGpzMAo1atSQ7ATvzb4xPHR3zszwvPP2R7J9Y4js3+t5LFDxEvnlljuukhq1SqXLzwkiIDWH3HvKyBsY5CaDY2BgkDXsPXRKnnxvnBw85n1M3U3t6kqFyFPS5cYbva4JEE9dEoXtgtxdDNB7hMA5CidrPbD2OShruueee6RQwcJy59Uvyvmzcbbfo0ylYvLtPy8q247PYZVlW30OSpjwOfjX6nMQjCe77Smb7S9472XLlsmxY8fUvlHZecPXw0fI6omHZN+mEx5fU7BopNw2pLWUrVU4vTEonyVNPCG67pIXBga5zecwJDcbsGrtepm/7aD8s+OY7D52Kv35sOBA6XrNVdKrZX2pWba4ii6OHj1aNXhyrX91BR8LhodFC7kvi1ZWam+tmD9/vuro7C6aCiCARDLJeEZt3C8/j4jy630i8gTLQ081VPviPJDt2M3Gcqws1tWrV5fshjY8SLCIZLszPERHOfa7775bvh/xpxw5EChrVuyRmJgECQxC0lxBuvVsJM1aVpOgoECVKWaskd4X78Fz/NuuXTtTq2uQqcH5YGUrvwzOU40XXvYGx8DAIOvYtXuvTJ6zTlbvOCvb9hxLfz44KEA6NK8pN3dsIHWrl07vYIwE2Bf/gQA7gXYymgSAfZXZZgbIIz5PvXr13P4dgqubb+7auk++ezrzWly3CBB57JsbpXCRtCZblGtBZu2AkYkQ8ewmuhr4dajsKMdC8uwKOj6T/R0yZIj8OWqy7F51Stb8s13On41VPkfVOhWky10tpVWXBhISGqxUgPhVVkJPlh570qlTp2wbb2SQ8xCdC3wOQ3KzAdS19ujRQ/3889hJUq/RNbJ6xXIpEBYkPbt3dXqtHaKrQS0pixayXwwVhNff9v8siOzD06gepM0QOzoGgk0b9svjg3/0673y5A2TiTOfVj97kw9dSqJrNTz79u1T2WZteBidNHz4cHnrrbfU75MnT06/LmD27NlK9uxae8vMXlc5NJFlItlk5+leaWDgyeD8b0VrvwzOM9csuOwNjoGBQfb6HL/9MUnqNbxGNm3cIElxZ+TOPr2cXmuX6AIyrfgK2C0UX/TK8NVfcQV9Q/BhPI3qgdxyPvT/AIf2HJeBrd4QfzFxx4cSGp5Wa8yUBTo42wVEl/OtXz9tSsTFAA02t2/froLiukQNG/Daa6/JBx98oALirj4HwQB6kPBwnYKBT0fyQoMkBb4c5NffiRUGORvRucDnMI2nsgiibtaufEXzhkq9iqVEoivJhg0bMrwecsosWjtEF/mMbofPTQm5wgjp0Te+ZgdpggAh8zaLlkWR6J9GgQJ5xF8ULJjH6bzdjSzwBYwToIkD5+ku8pkdIJPLA8MDSSUCPHLkSGVsgG6EZQWZ8J07d0rFClVk9owNsuifrRJ9Nk5CQoNk5l+j5MFHb5LadSuo10J4+bz5DNg/ZN80pjLw1Jo/JYe28zcwMMgatm7d6hTwLRQZKrWrlpKikYFqUoIrsJu9evWyRXRpIqVrOxmPg7oLqTFdj5HG+upzbNmyRQXnvdWJEvzt0KFD+u/5C+VV+/cn/xKeJzSd4Fql0HYVVJwjKi/Ktjxln7MKiCcPfAh8Agjqr7/+Kq+//ro63iNHjmQgs3zuZMULFywi8yenjU86c/K8UpFNDlohdz7SVZq1q5/ed4XAAdn5cePGKb/ONKYyyG0+x5VxlJcpWDxptEBzJFcQnUPm6g6a6DInzl1TKG8gYnLDDTeo6CS1rFOnTpW//vpLNVHwBhY63stbIyQWVciYlXyVLV9EKlUpLv6gVRvnMQUQx8yO0xMg+VxrIp8XExgdOjJ///336mc9SmHHjh0Z5N1ly5aTX35YLL1v+kR1k161fJds33pYojYckG1R0fL44FHy8L3fyQ5LAwmuPwR32rRpqqOjgYErUh2Bfj0MDAxyPgi4usvM4Q+QeXVHDjXRJbNpncbgC/LkySMdO3ZUXYNRIWmfg0ZN3kBPCppJeSO4NMAik2vNBOUrkEfqt/QvmN3yRmeJMYFrVFr+oGnTporgQ3QvJvAV8TkgujSrxOfgM4TMuma/+SwWjt8kd13zsnw05BdZMSdKtq/bJ1tW75EdK47Ka/2+k8Ht35b1Sy74SSQ12D+KOBSBBga5yee4Mo7yMgXRTWSpGkQ6dWaWiBkLlad5bRBdjA6RV7tEV4PIH2QX44OxwPBAns6cOeP0OggarfAzm9nGAogsyRXUnNoFgdOIyNNOBoZOzXRN9hc0cILocj4XEz///LPqOn3//ferSCqfEdFWq/OQkpIqb786QZYtPCyxsZ4/v62bD8sTD/6kxjBpEETA6NCMikAHnR4NDDRSJMCvh4GBQc4GSiBPM+chsmRaqff09Hd8DvwEu0RXg/1rnwOwL4gzDZWsoNSHgLS7iQpWUMIEgXYF8279QYFKDlmyZEm6rcZH8pRs8AX4TBBdd6q87ATXkCztE088of6F8OIruQYsPn9utCz8c4tEn/bcXXvv1iPywp3DZenMDU6ZebL4NBXD58jKNTHIeUjJwT6HIbl+ghpTpMPWrrlELq31liwo3qKAyJA10aVmJSuAQGJ4IGcsjiyazIaFEJI9tZJxd/Amy2EMUImSmc+bs6Ld9XWk7123qqZTdHImiqgbS2SlDByjSe0spPNiAFJO9FkbcSKr1CwgNaY+hiZSnMfIb+bJgrmbfdpnXFyivDx0jJw47jyGiPuDbtvU2SBBN+XxBgYGBgbugH3A9qGI0iBAavVBUJUhEfYEmhBpouspAO8rIGPYScgTPgY+B6SVsYWQcWvZkzvQ4IqmUO4aIzXrVFcq1rQ3WaJh6xpy32N3qcwothqbip+Gn5UV/wqiS1AgKwF6b+DaUQN81113pQcSePTp0yf9mnIe47+dK1NH+ZaJTU5MkXcf/EH2bjvs9Dwlbvgy+Krs298SMgODKwWG5PoJFlBrHQnAAFmly0hwXIemeyK61MtklejqiB3ZWKKtGJDffvtNZZhZRD2RKJ6HDHuqd43IEypvfdBb8hfwPPrIiirVikjjFmnyI65H9+7dVQMHFlWyzNS6ZAV0KcYwsFBnJwhaMHbgqaeecnqe6wfZ5TyQG48dO1HGjV5qa9/nzsXLpHGr3EbXOR/quseOHXvRyLvBlYOcLB0yMDDwD3TcZUKBFWRLrXbbl94XmugSfM4q0dU2jBpWfA7sPKU+vAfKMG/HAhH2VD5FjenrP90vxUr7No2hTNWi0vS2CumybWw13aHpMYLKDX8tK2Bf+Ad6vGN2ARXfp59+Ki+++KLT8wQv8N9oOoXce+rUafLzx1Nt7TshPknGfzPX7d/wESkBI2Oc3edkcOUhNQf7HFfGUV5mQL7Cwk7XQVey6BqV9CU7B9G97bbbso3oAmpzyBC+9NJLyvgQ/aWWBqLpWtdK4weIljeUKBUpXW4uLQ0aeW7HHxYWrKTNn31zn1SqVEGmT5+e/jda3LNgc550AiTS6iqrtoP27dsrkks0ODvA5/Tmm2+q62VtUkHdkbXJB1ndYCkjSUlpWWk7+GvCSo/zhnVjKoIiGB6ItUHuBHeIfemQgYFBTgWZPOwlc11d7bw/Y37wU+gLAtHFn8kOsB98iVdffVX5HNQNY+vxOVyzoHRupubVGwqXyC9t7q0izTrWUeVP7hAcEiTtbm4sn05+Wpo0b6S6NGufi5IxjoMu1Lrho6us2g5atGihPgOaU2YX8Dkef/xx5QNqHD9+XGVyrXW4BaSMxEbb9wnmjF+hRg+5g25Mhb9DY6rsCHgYXJlIycE+h+mu7AdYyJHoZAbd2c8XUKepiS5RVuuiZxdIazAu7EejRIkS6a306c6I4QG0rseAeptfyzlgIPoN6KWkvJs2lJed2+Jk9cptEhIcJiGhgZLiiJYuXdtISEiQrF6xWxo2rqiCABgd6k81caRmmagvsmMyuhgNaozcNe/KDGTSkfKArA6wJ5oKyXR1GLhW1hb+YME8z3IwbzgXnSBzZq2UTjd6Nu5EtpGeEyBgbJKnsQsGORf+REmvlKiqgYFB9ijH3AFCdOLECZ86Cmuiy6QHbDTbZiUjOX78eCWx1e+LLdUjAwlGa58D+0aTy8x6hOA79LmrlyT0SpD5s8rIye0psnphlCTGJ0tkwbwSnXhcbup1o4SFh8j6xdulXotqahID5V/Ycp1wILtNuRa+DvYcgg0Bd20k6QvIqpKhhuhmdSzPDz/8oIizVX4O8Itcxx4tmrrWr/dISkiRiT/Pljsf6u7xNZxHjRo1lM9I5213fVkMcjZSc7DPYUiuTdDAiWwesuDMALFEVkuEzJfW7Vaii/HxZxZufHy8is727t3bo5FjQeNBbSkjcpijBllkcXPNTgMWPwwsx0PNKlIguVFk6tRUCUgpKX9NWC3bt8TKJ1EX5DSRkeHSsXM9aduxgTofzksbHd5n8eLF6U0p2CdZZ+qZvY03cgeaVnB8nKvdoe8aSJr4TCHfVpBNdTfmJ/qM/5HvjRu2SpPm1b1G3wlwQKxxDDDYZNldI/gGORcpDoJG9gyI3dcbGBhcGYiLi1P/+kJCqUclE0jzqfLly2f6ek10f//9d+nZs6db+58ZkCRrn8Vdfa0OQvOAfH/++eeqIRSBXEiju5FGNPW85ppr1PFA8Lvd0kXtu87yknJsW5zMG7dGDqw9L8PWjknfJiJvmLTt2Viuv6OJOh98Dp0sgExi53VyApKKn8RxWEdA+gKOGem4u7GCvoLOyQT4BwwY4PS8Toq4+m7Rp/33OQ7uO6IagVln6LoCf5aABEkMGlNxvajfNcgdSMnBPseVcZSXeV2MN4PDIm2nBT2kiigk0VUyrHbA66nrJIPrydhYgSGEQEFaOSeIJ9FW/tVNoiCf1KNCsqxDn2NjEmTcr9vlo3enyLYtzs0NdA3quDHLZejjf0i5MvVUbbCWYufLl89JGkMmF1IXHh6uDA/vb6cJE822iND6M56IbYjM3n333Rn+BvHn3BcuXKgMsn7Exvkv62nWvIkytr7IkXEKuBcYKcCxmMZUuQMOCZBUmw+28QfDhg1TwSG+e8gHqd33hk8++UQFyFjXUF8MGTJEBdYMDAz++yyuKxlC/YNaylvzKU9El0ysJtS+ApuEr0IDRV/UZ9Saksnl9ZQcISOmCRaNKbW/Q4kQ6xEknQwxwXWOMTEhSX55Z44Me3asbFqesR9HXEyCTP15kTzT8wspnbe6It5aig2J0z6Nzl7i95CIwOeYN2+e098zA/4SGXOIrj+JEvy0Rx991C255zPEB7L6HGfOnhZ/UadubZUdpqY4M/De+Bz4RZS3mcZUuQOOHOxzmEyuDdA1kIXXXYaUxdQ1CqoJod3aU4yUJrq+ZnRZoFnU2c7XDPDKlSuVsQHccBgdbYhYWPkXI3PPPfekL8DIaJKTU+S15/+UvbszXzQhw++8Mkne/qi3Oj6ixarGpEABdV2sMmmCAjoSTc0u15Nsry/nQydHyCPGMLMINgSbiCUL+VdffSX9+vVT27qSSMYG8OVq0KCBIuYaq5bEyryj/tXllC1fVJq2uFVdC7LtmQUjdGMqrhWGkWPxR2ZlYOAK1hdGVvAdwNhgTPgeETCieYsrfv31V3n22WdVYxki/TijZCK4Rz/66KNLcg4GBjkZ2GD8CHc20NM8XAidXXLCNlq67GtGl/cn60eA2tcMMGSSOlAAKUZeDCBgkHn+ZbzNY489lv56fADe68Mhv8i2FZmPvoEMf/DYz/Ly9/cpP4IgOMopHGtsvlXxRRCbBwF8AvxcZ94Pf8gXootPxDVHDecNBA/wORiBSCZb9yZxxapVq5RPRjMxMtza19yzJEb2bpwv/qBsleJSt1kLlWiwZre9gfUdn5YyNXwguwo7A4PLxecIcJj0kM+gRoQmBu5AtpZsp6skBPIEAdW1KXZAtg8jkhnR5SOENNHO3xdZNCB6wgxYT4QQcssCh5SHaCVZWGp9+/btK9P/WisfvvOXrXOpVqOkfDHiHiW/xehguFnkvV0XFllG9nB+dAK0Ek134Pi4DrzOOlzeFVwjIpYjR45UXxh3XaXpcsz1d1d388foWfLNZ/Y7RJcum1ceerKlkmFBtLk3dJDBVxD5pos3103PZDbIGcDBI/jz9OIuEpbPXk1+wvkkeb/FFKXOsN773COe7hOMDPfiF198oX5nnSJS+sgjjyjD4oqHH35YrQX0JNB48sknVZYAtYOBgUH2wrWnhRU0UYI0uXYozorPATnGEYWIZkb0ODaInq+lNKwdHJcnwsTfeG/2iXoJuw/hHTRokCz/e5O80v9rW+dSvEwh+X7xyypTS/0vNh8i61rv6ur34HNg+zmOzJp6aSLIsVpHObmCIADvjz+H/+Ou1wYZXjLwyKFdMWfaQnn/vgvSbF9RsGReefjTrqo7NJly3t9aN+0LkHbz2UFGMvPBDK4sROcCn8Nkcm180b3VX7AYI8NxBzsLihXcKJAgFn6yfp7qgJEZsQD5SnBZ7Dhe1xpUVwNGRJeoH7WyZHbp+IeR+O2HrbbPZfvWI7J182ElpcYocLNnFm0m44tB0llMDDqZXneGByPDAkxkmAwshtRbM6uffvpJGT5PY5P4vK0Np7hmRJWJyDZr0UCmT9op+/acsHUNBtx3vZQvX0TJs8jgcr/gkGQ2T9BdY6pp06apmhnTmCrnIdURoB52twGu9/wrr7yiup26c+bIGjz33HPpz3FPIotcsmSJ2/cgkvrzzz+rABlrB93NkbTp+Y4GBgbZB5xHsoye/AeyGozs8QRfmk95yuhS04rv4Yno8r3HhvtKcDkWbKq3oC5kFAkxfowuE8IBx+f464vVYhfHDp6WFX9HKT8G/wWJo24G6um6UC6GPSZgThaYzC/H4i7LpMkrNpigOH6SdRKDK7D77MuTzWbdtTY0hQBQHgcRwfes26yqbFi6w9Y1uH1wJ7UtnxfA59G+na8g0E+mGl/FNKbKmUjNwT6HIbk+AoPiKYur4W7hZEFlIfS1+ZQrMDKa6GJ8XIkuCyeLjrfuyK4gg0o00ROQDUEWtayFcyCyecMNN8j2rYfl6OE14g+mTlottWqXUdeRGxWjQ4SGc/JWowp5pTsi9TMQ2KNHj6pF15NBgQhDAvk8MCruZNrU0yBTdgddB6TlYtTs6g6N+jN8/OkbZeiQXyQp0TdZWLOW1eTatrXU/D/IMwSf/WJE6bLo2oDCG/hccAZoTEVkFnmVaUyVc5AigephdxvgLqrqDtz/3IN8p6zgd0/1fHfccYfajvWGNYHAz+DBg+X555+3dawGBgaZA4fQm88BEXPXtInvJgotFD+unXt9AfaYoLqutXVdQ7DZEB8yk76CmlstTXYHalDr1avn5COR2SSLffzQaRm+KaO01xdM+2WxNLu+rvJdOAbODZKHvfRWf0yAnYwTdpaRi1xLemR4SmQQLCcIjs/hLnCO/0iDTdd5uBqafOP0M9cXGTRgrYXogwfeuFWeuvkTiT3nWz3iVY0ryY19W0poeIhS+bF/OkuTNEAyTZbM1yAIx2VtTEVm2FsjK4MrCyk52OcwJNcHEEVgwfMXLN7Ib4hK+AOILvIhV6ILWSWS6ynK6A7M1eMm9NSpERLJ/qw3IlEWfez7950Uf7F+7U4VDQScAwsmUoSnn37apxoYoGfrsR2RX0/ZTBZkHb20El3qfZkJ9/rrr3t8D6KnSLnZPxIkDISrMajboLw8/kxH+eS9mZnOzC1fKa8MGdpJEVwNzh/SzININfINIsH87qskCKNLfRHGlS8/ETF/VQMGOSOqirHxJtXPCrjP3n77bRk+fLj6Hu7YsUPVzr3xxhtqvrSBgUH2APtGLaQ/wJZCbgmi+kNytX1CdUX5j5XoYhvJ3NiZZEAwG0JetGhRt38nC4rdwv5pbNq0KV3WfHD3cUlN9a+qbuuG3ek+B4Csoggjm+TryCT6YPAgi6R9AiTFrraWkiqkzsBKdDl3SqNYIz3ZZ7ot6yZYBC4g5a4JjUq1SsvzX/eXN+/7XuJj0pp4ekKpKgXl0Y9uUwRXg/eGnPIgS/7xxx+rRAHn4uusZd2YiqAETUndHafBlYfUHOxzmO7KmUDXhfgbtWJhJ3pBY4OsAMOFxASiy/748DEKdufLsgjTyMgdqPGBeELKrSCSooeTJyf5320vb95IJQXSD3T4ZLldB8X7AiQ4RFlZdDEMnJdrd0SkPwQXaJ+vjj05Wc3DpauhuxpnLQ/i2hJRZv9EkNwZJvZ16uwO+fbnwXJd+6oSEpLxNSVL55FnXuouX418RKZNn+JRno0kmxl+ODUYO2RSvl4Tjo1MLkEYyDuLgMGVjVQJ9Othd13COUEVYQW/E+BxB4wKMqF7771XZTRYjzBA77zzjq3OpAYGBt5BI5bMxtN4IkwomWiSmdXvJDYSokvmDqUVwX4UY94kue5AMN5TSQ4EkMA6xMuV+OoGi8mJ9qZMWBESlCY/1o/7779fBcaxs3aBv4VPgIoMG8156YkRGthiMlvaDuM/0iBn4MCBbkk1f6e+UDfaZP/swx1x5LVbD6yTr+e8IF3vbiEhERnX/CJl8skj794uX814SZauWORRIYdfA7klUE5AAUUgygFfW/SQ9OA4yYr7478ZXF5IzcE+h8nkZgIIDxE6f8FCTSo+OzJsLIJ8yG+++abK7NrtsovhxEB5Im0QRTLF3mqR8xfwf2B8XjeF7cgRuMYsxu4aLmQGgg88qFshc8uXyNodEQJJppRzpukVxJeI6cplO2XWtPVy/Fi0pKSkSkpqrNSoXUhaXXeVMuyZGXLqoPksiHDXvyav1G/cQIoWribnouMkJDRYKlQsKlFbVkiHTnXVe/N5QULpbugO3GOQdd3sAikyhk93oMyseyXOBxF3JFEYHtOYysAbqD2jqRzSQy2JxGjwOzI2T01WXLuBa2fM9C80MMgeUE7jy+xWT9857KE/o208EV18gv/973/KrnqS63oCAWYC5O46+nL82Dyk0a7bWGe05i/sf7OjvAUyKsQoU4K44/PoiRJ2nXXIKOsho/1YN7HRWjpOEoF1FLuP7BilGb7axmU7ZebopXJ47wk1oSJZ4qXK1cXl+ttaqvKxzK4t/gCqMrJm5Zvklfuu6SAl81WWs6fOS3BwkJSqUFT2Ht8q113XWELDQpQ/QCbeU6MpMmOUpuHfcc+QzMFXYo2HBGeWnYO08x7ca/RMMY2pDC5Hn8OQXC8gSkctbWb1rhAsT19utiWLm11OIAsKCyLRM+Q8vszDBbw/23hq/OCpczQRSRZ0jYaNK0q+yHA572NdiBUVKudRtbIA0kb2EWPGYorh4Gb3x+gA9oEBoJ4W0oxEioUaaRFEl0J4XpOaVFgG9B4uhw5knDu3Neq0zJ91QB55oqvX9yIYACGHRPI+/EuWtnkrZ2IcWaCpitLS7IHzxRDSAAOJjztQq6tHOBBh5cH5YCipH0ICldmoAmYOkxXmOpPlzorM3uDSIMURoB52t7ELWvn3799fOWE0daCdP+udnhmNM4jzQ9RU359kJbjHtHSISCvPG8magUHWgZ0mE5hZQ0Fv/gQ+gf67P82nXEFNKsFX5Lo4qTirvoIaUE8+hyZtrj4MGUWrz1G1blkpWb6IHPGjVKrq1SWVzeU6cNzYQ/wAanKxp2QwOQZ/AMkjaI7tp96XWlrWUewufgyqMVRwDau3lAc6vCt7tmQcf7Rj1RFZ+MdWuXvoTSKtPb8XfgRkVPkwqanqMw0OCZZr2jlPfygfV1yp0ShdIkDB2uyt0RSvI/jO8eKL8eB8kDPj11Lb7a25GeC4UKEhC8cP5l4xuLKQkoN9DkNy/RzCbgUX3lOXXsACy4Lob/MpDUgqxBtpDwuPrtH1heiyaFHv6Ym0IT9xzfwR2XNtLhEWFiKNmpaV+bPtyWIhxvcOvknC/60RIUKDZIh/qe0gCsqCmlmL/8yAISMIwDWnJonGUVxzvhDx5wvL6y/8Kd7iDWfPJMpbr4yTU6fOS8/bMnafJrNNIwgdaca4kYWdM2dOhtcSwcY4aVDrjOSJGmdXeRbAcFHvYp2hy/noexBnA8eAzwnC7ClTqxtT0dSK7DUReE/1UAY5qz7GDlg7qFF/+eWX5ciRI6ruDIdQ1+NTv2ZdW2iawj3KvzpDg7F56623bL+3gYGB/QZNVttszXZmd/Mpq2wYOSE2Dt8D24QayReii6oI5zQz0mYFRNHVR2INatq5pkz8epGtYw8ODZKBT98qhYqlvQdqMbLkkDeSBaxlZE/JQqK08jcYgG9B9pZrjk/Dg+QGvkfJiKry4p3DJSXZs7Qy5kyCfPHcGDl+6IwMGJqRcGPHufbax6QeFn8N+bgrCKYTeNfAr4LYe0sgQICZoYvvwefK+eh7kPuHQIDuIeLJf9WNqbAjpjHVlYfUHOxzmJpcD6BWhC+2Lw2RqGXNrPkTpJT6UH9Bdz6aRunGS5BmOg9CdDPTprO401FP19VawWJvJW1WsFhbI8rclBiENu2rSp689qSwN/dqkk5w9fGzkLIwDhkyRGW7ucH594UXXlDvbXegvRV8McjkYpy5RqFBJWTuzANeCa4Gr/ny05mybLEzkcdoUetknUtIphWyyfu5i65jZDCqGsigibBClt2Bv/G5El11BUaOLzjGBmcIwuutBpfmIBguZjhTP2QkpVcGHI5ASbX5YBt/gEyIe5o1AsdTry8ARQSdv633JuMBuOdQFvB9HTZsmK3O7gYGBu6BfBZb4W3eqruaVU9A9eOpa6kvoEET76PLtQieUspD4NS1FtUV+CSU3FibSWmw3lhJmxU6aKyBz4MtrHtdBSlU3F5zmxv6NE8nuAA7jQILn4OMEmSQ7DRgRieJgMzOyxvwAchOIdvF58gfUkymfr3aK8G1YvTnM2XWmAtBcUASYPXq1U5je7gm3CM6ceIKyCVqAA0ab6oSrZUrPR43gQvIqauPQKCETDeBduwDhJcaXk+gthKfg8+YhEVWfDiD/w6OHOxzGJLrAWTm7EhnM4sC8qFYyY4dcEPw4brKQFjkyNhlRnQ9zWKFtBEldB0mr0k+0hPOi5uL2hkMHtKjVtc2lude6SYhIb7dPlfVKyJ97/YsYSE6SPSG602N7jPPPKMkSxAzZLc8yGLbJWm8/r333lONtLZuihOxsTlv9etPF4ZNs1hzPFapsZaMAzLeNO1yBUaVjLIVRFaJxPPwdD34rK1dIa0g8EK2GsILyYbsEql1Z6D5/IgyY3wJUJANNri8kSIBfj0MDAyuXFDf2bFjR59ei03OrDswQXp/m08RuCcT6zpqUBNdMrreCCEqOHfnAmnDtrubtQrJx15x3OwbkoTKi0xjy2ubyWs/DJKwPBlre92h3FVF5P5XPc/k5T0gvaic8Glee+01FXjmM9A+B+TSH5L24YcfqgDzvtXnJDXFns/y+2cXgtH8O3HiRBX0dlevjESY5IcryI65JlQoYYJUeAqK87lCZpE2e/o7fgSvIVsM2cU/8TSGSTemwm80jakuf6TkYJ/DkFw3IJ1OpCy76sw0AfYnkwZxInLmSTatuwB7IrpkX6k/cZUXuSNtVhBRIdOKsULOTO2JtTFUhcoF5IEhLaVqdfdd0bREud/Aa+XhJzqkz33zBLLJZJv1z8yNZU4eCyuRV2RNLKraAEG4vV1POjYSrWVf3breLvv3nBO7iNpwQHZuT+sEx+KPsbEGM6yRaqLS7gwOkSh3hlIPwCaY4A5EXtk30iRvYF4hZBd5EERXD7B3F2Qhwsr7cS7e5hIbXFowLUPLh3x/XOqjNjAw8BeQP2xLZg0GNTLzJSBw/q7x2GHsNXbFE+Eh8+eJ6CI55vhcZ/i6I23ufA5qSrHxBL0hStrmVrqqtPR5sZXUbpIxO6wRnidUbh7UVl4aMVBm/z3L63lCRLWtJHB8zz33KCUZBByfAzKJ/6N9DlRv3q479h8VGtnVgf0Hya61x8QuDu05Lqv/Scu+00jTdUQPxFsnJVAPunaqBVwvHq7+IP4bx0idsDvgYxEM55y9Ab8EskvGnQA+PgdNTV1BEIYABcdPgN2Tr2Nw6ZGag30OU5PrBnxxPS3E/oBuuWRN7YJtaNzgqWmAlehikDA6RFmtmnZIEvUmrtDGxlOnZUgkixckUw8jdzWE9RpUlMgCDskb3kp+HTVPHKnhkpSYItHnTkr5ShHy0muD0yXKGENPtag68geJhUxro0NdKufEuSGb4QEwNGQk0fJrkK1FKoNxZjHFwPN6pNC//HghI2sX/8yNkoOHt6rsq9UBwZBbm42xoFtrYVxlYxhI15EQfK6///670+xjKyDOvA+EPbPOi7y/DlggTybSqjPC1nFJ1sZUXC+MmoGBgYHBpQPEQtu+7ABEhCCs3eZTkG3squuUBVcQNNdEF5/D2j2Zc3HnP7kjbRocI9Jq1G6QTHflX/ytUs0yUu3FChJ/prVM/H6upMQGS2JCspyPPSv5ywbJW8OHSt7INDudkpqsFHmeRiZiB7GTeuYvdhKfA0IG2cY+WkebQIitPgd2nW117w9N7IcOHSozflsiyYn+SXUX/rVWHHlj1Cgo6/xa/DKunf4svX2mNLtECurqb3GPkRDh83FXiqcnVbjKSD0FUnTyBZKLv8g+uXbWpIpuTEVSRfskBgb/FUwm1wUYBho1ZMfIHw1qZ5CJ8AV3V0PhDpAbpDPuOh67A4SL6BpGR0cbkay4zrwFREqptXUXNUYazaBlFi9ImDuCq0mu7hx9TbOackP3SvLJlwNk2HcDpc+AOhKW97RTDS4ZR94PqZKv0iqMDu3vMSzW6COfDbWtRFt5sKBTt8NxY2w4Jt7ngQceSDvW075dc3fYu+ewOm5NsK3X0NfFms+foIErCEZwjTGqnkDUlow2n4uv4DPnXuAz5h7C+OhZwdbGVDgS1Fd5iuwaXBrYrY3RDwMDgysPrO/YWXez2/0FdZi66RT/+gJKXxiNB2n1xf+xEl0IGKDGFeLn2gyTelBX0mZVm1FWhMyWgLyn/iba56DetEW7RtLurrrywbjH5bMpT8ltz7SQwtUCJcLSK4Tj4DpQa+sN1uysbv5IcsFa16r3p30O+mJA2pA5U3ZEgBuyO3jwYLWPMyf9z1oePnhc+YmukxQI4HtqHuoK1HvcV+6APBufw5OUXQfjPfUNcQdILMkIAhRk5Ake6HpnwP1AgIPAPbW/1HsbXD5IzcE+h8nkugBi6CuxBJAqdwu3FUifeR1RNfZP1tIbWDBZJIgq2iHbEF06E+sOiBAr1ywuchWiba6kjegdEdhy5copYqVrTb2RcKJ37ub5kVUkoomRYH8aGDE6AnrKTGJECDIwOse1KQJEje2t+yNwoLsdP/TQQ2oh5drRfpxI9hdffKFqRvZs9//LeP58dIYxPBhFJMjunBIMx6E9JyTmXLyEhodI6QpFJSw8RL2WbLbrvEAINJIsMqsYT28zdLmmvjQl0eD17JPjpb6KB9cK2RLXiuuNE0SzDxwcaqi83W+bV++ReX+tlVPHzklgUICUKldEOt7aWMpUzNjQzMB/pEqAetjdxsDA4MoD5MWOz4GNyWyigg4aQz6w65l1WMaeEfB0VYL5QnQhhXrSAzbGdWQQhAZ1letYJGwzRJHO/xArd3W6VhC8xk65a7gFmUXdxftbfRKC4WyD3+FOtcRrCYi7HhuEjQAxx8g+NPBpeA98HOTN2HOuHT4HJP77779X53pkg//lQNHRZ9x22Ib4uo6q1AT94I4jcu50jPI5SlYsJnkiI5T8mGvmmqjQzS0pW3Kn8rPO0GUfXFtfgT+j67gps8Nv09lbrpVuTIWqj3pr/BNvZYE71++V2b8skhMH05SQxcoWlo59W0ulOhf8QIOsIzUH+xyG5FpgbSTkK1hYvY0PsoLFhkXHGyBCRNl8IbgxMQkya9p6Wbd6r8TGJkhERKjUrltWWl/XVrXofuqpp5xez3tDcq1z4XRtLgsfhpauxr5IWFlcqRf2ZDjYD2TWSkoBryeyCkHGALuTD1lJrtXocJws9EQIOQ8WVIy3Npa65kd3kYboYoyC5Yjs2+lf5LBsucIZ5F4YRVdyf/ZUjKyctUdGv/eeHNl/QZqeL3+EtL+5kbTv2UBlf91JpzheDLceDeBthi6fkS8dv63g2Alc8CAaDqHGAeKzoPYXEs29wX1HF3DX+3np31Hy86czZWfUhWywxpiv50qDFlXlnme6SNXaZmTAlTSzzsDA4NIChY5d5Zhr8Dirzaf4O7YFcuoahHVFQlyizJuwSlbO2ywx5+IkPCJUqtYtJ+1uuV6N9aCXhhUEnSE0BKo1sKfIiCkpIihPsJrMY2bAdpEscDd3F6UYgWAUS662Gb+CWlZIFYFyK2gY6UldRtAXXwUJN1lRSBvXEzJL5poeGADfg+expXyW+Bw7gg7L7iVrxR+UrFAkg89BwsK1U3XM2VhZO3WbjH1+nuy3zOANzxsmbW9vLl3ua6d8CnfBc8iyJrKe+r3wPJl9guWeFH3egC/NA5+N9+Ga4V+QYCHhw3XFX8PfcE16rF+wWUa+/IdELc3YKHPsp9OkdvPqcvfrvaRuK2cf0sA/pORgn8OQXAtYbO1EVK3t3L3C4ZAwanKjoiQPslG6LLvMh9PGRmdhvUW3EhKS5Nthf8uMqeskPs658cOif7bKD9/Ok0rVSsjkSVOl71190psQQG6stTYYH7oospjrTo1IhzKrxdDRWU/1tSyKRO88yWCJ2GLkiAK7ElqMIvWrGCstgUo75wRVa8o8N+TJyJgxjCz+uvaIOhKILwECCLTOtF7bOkGW/vOpxMYmih0EBwdIngIxMnz4cCUdggzyuUDurZHfdUt2yBsP/qiyt644Hx0nE39YKJN/WiTNu1XyWB/EQg/RJDONwfZlhq4/QO6FY2Gd6cf9y2fJ/nEEMGwYRsj05FGL5MvXJ3psuKGyxIu2y9N9hssrX98tDZp7H2thkDn8kQJdKdIhAwODCyAraNfnIMibmRpM+RwE1DdvljxIQ2nq6GbsBus3GVyCqN6CpynJKTLqg6kyZdRCOX/WuaPukhkb5NdPpkv5OoVldsm50n9gX2V72TfZQuyKBmQTYm/t9UHA25ceKDRZ8pSRxi7jS7hruggI8CJBdmdf8Y0gsPhC1mZdJBwI1LNP7D8+B1JqfsdX5PzwSfBZBg0apPara1FTOqbIsvG75eQR70kNV8BrS9SKkM8++0xlkGm+xT45bmsjsO1r9sjLN38gp9zsPz4mQaZ9P089GvWspWTC7oIo1N/icyAld81ka3BvWmfo+gN8QU208S+4ZviI+IFkkvH3kDAzAYTn5/2xVN4f+JUkJ3muad60ZJs81+Vdeeb7wXLtLZn7qwa51+cwJPdfsAD6Qu5sgZoIZj59+aW0/bcmU4lQBg0S4Uv/4IMiNAsKClILJgSGGk1vi0lcbKI8O+RXidroOTOZmJgiWzedlbgYDM3vcle/3ko2wiLJYkcWlKw1ZNFKVHneKs3xBup8Bg4c6PHvROtYmInWaQKN0aB+hUg0EqJffvlFSWaRK1mNFdlxFmauA2SXSCsRZhZBIrkcJw2bkDiRAeV5jBGLKUOjXWXEzPRt36muTB7vPmLrCdVqFZT+/e9Q54ozQv0N52Ul5htX7paXBn4nSYkXCLk7pKY6ZNHEXfJj+SnS/7Eubl+DoSHiifF3N0jdOkPX6jhkZaYfIEpNUxDuQe4Hoq8ERE4fSJHRHy/xqSt4fGyivPHAj/LpuEekbGXvM6MNfJAOOXKmdMjAwCAN2EfXZoS+ACJG0x+3IID+888iw4dL23/nmab7HMyfxeeAVP+bsYWEEuR27YRsBbbtjXtHyIo5nms0mQW7e+0JiTmRIinJo2Tg4H7pWULsFsQWO07jQ+vIQogrGVBfABny1hCLsjFsGT6GHrODUo2gND4HmWDUVPh6+u8A3wL7TnKB68p0DV5DIJlrQ7AeH2DUqFEqE4n953mCDRA2Rga59jcJCg6Szne0kJ8/miZ2ULZWYblzQC/l50A+3377beVzWOeC7tm0X4Z2fkdlcjPDqvGb5f0Hv5RnvnzQ7d8h5mR7PSkSdbkYgRBIflZ71ZBJ50F5HI1G+XzweyC7ZMRP7T4nvz471SvBtd6X/7vnKylWtojUamqC61lBag72OQIc/sy1yWEgkofUxW5EFdAUKcMYHi7pBx+IvPwyqUnvO2BhGT1axu7apQxCZrKQl4eOkSULM46q8YQatUpJ8fKHpG/fO1V9BfU/ENmqVWvI0oXb5BQNEgICpHiJ/HL81Bbp2TPza0C2l+genYut1wGZEMYEI0GGEGMM8dQSIYwdxgWplTaqkG/ItpYYAxZU6lowjGRrWXwhvCzIutshJB1DQCMGIrAjR45UUilPBvP0qfPy6KCRcuSwb5HVyPwhcttd1WTL1nUqK8wCz1fl3XffVRlmDOA9d98jz/YeKccPp40+8gXYiG9mPiNlK3muY0U2DHF3rb+xOgYYZU/jn/wF54dxx1EgYv3tS3PkwE73zSs8oeOt18gT7/bK1uPKLcDw8/3v9fddEprXXtQ8MSZRxrQfpSLzfM8NDAwub0Aws83nAN99J4JNPpfJuDxqLH/+WaacP68IJ5Jdb/j0md9l+q/eR9k57b5KcanQPkC63dRVEULILkStfr0GsvzvTXL84GlxiEOKlCggxxP2ys239MiUPOEPfP755/Lcc885XQcCtRBQbCL9TlhD8RV0ABc7zfnx/tq34njwgax9SbC5BOHp8Mz6SfAB8ksGl4Azx4dqjAwutpnjGTZsmCKArjJiDeTcT9/8qezefEFK7A1heUPklqebyO5DW5WfdPfdd6vj//TTT9PL3Pr16yfv9/lOdq7zvREl+Ojvl6R2C88JDILakE2rH+auZ4unGt6s+Bxk9wlEQOTHvz5XNi7w3b8FTW6oL2+Mdy7NM/AN0bnA5zAkV0RJZyFo/tQdZDA4XM7HHhP5/HOn1zmahotUDBFJdIgsj5eAgxcyf8kREXLut9+kUCaSne1bD8uD93xn+xh79q4qew+sUe3ja1avL3+OXqZqeWPOOzdHyJsvRLr1uEZu7t1UChXK6/Q3FnUILJlVoqEYAKvEhagjkhQILAslkh4aN9C0wNtoBKKkGAvqZoiikpElU/vYY49lqJ9xBUYHqRMRXpo3WSPE7nDwwCl5/IHv5Mwp700hSpQsIG9/1EfKV0jLMEP8IOOQbc4LMk3U+K3nPpcNM+3JkUCPu1vL/S909xp08TZaCBB5hdxbZxdnJxbOWi1vPfCb7e1osjVq0YsSWSAte29g3+Dc9nc/CbFpcJJiEuWP9j9d9gbHwMBAVCMkyJM7xY5fJPett0RefNHpKUfDMJGqoaRcRNbES8CuC6VNqSEhcmLYMCl+331e3+vYwVNyd4vXJTXFe12vK9oPqCPHEncoWXKTq5vLxO/my4zfl8pZl67DYXlC5IY+LeSW+9tJsdLODTzptYHPQWkUPodVfaR9Dpoc4XMQ3MZH+eabbxQxtfYdcQUZXV6HbwKxImAOecXeIg/2BvwfPjuOC/8ks27Hp46elSdu/lCO7vUeCC9QJJ+89sP9UqNhmhwbPwgfAKUb53/nnXeqe+WDlz+VxcM3i11ce2tTeWHUw15fg5KQqQueZOucO+oDstgXA5tXb5PHW70hYpORBAYGyMhNH0jJikZBZhfRucDnyPVyZWSzSGr9Ibhu4wNkcC0E1zGggDgGFkwzNhopDnH8HSMBH52SgHUJEhwXJ4Vo2LB8eVpm1wMmjbMnt9VYt+q4vPG/J+WP0dPl8/+tkrNn3MtcYs4nye8/L5apk1fKLXdUl8JFLyx2ZGR152WMDdnMMiVryaTxq2T5kh0Sc15kyd+zpGqNktK1x9VybdtaykjxBdDXicWaSCkSFQ3qQelSSJQWqSzkltdTX5sZaAAB+YTsIYPKDLFxJ+XhJ1vIgT2pMmXSGjl+NNrp7yGhqdK773Vy0y3XSIGCF0gamWYe3333nYpMYyRZ7M/s9a8mYcaYpTLgyc6KELoD0VsiptSpeJJn2Zmh6w/WLXRf25QZEuKTZPHMjdLpNjN/11/oYet2tzEwMLj8gX2DMPg7ozxD1vOnn5wIruOWSHEMLiRSxyJpdjjEsTBOAj45JQGL4yQwKUmKP/oo+lERl+kBVkz9ebFtggs2zNsnH00cKmNGTZDfXv1Ijh047fZ1CbFJigDPHLNEbnqssZSoeEGWiwQYn4PrhC+BEqxK6atk8g8LZMmM9XLubKwsH/m7lK9WUm7s21La3dxYlT6R1aVOFrJGhhBbTZZWA1+vb9++qtcGwfX7779fqaaQz2YGiKaeLPHww95JI4hLPi93vnydnNsbIFNHLZKDu487/T0oTKR7/zZy833tpGipC+eOTedBfwwUcZw/UxBObXSuh/YViyaskDPHo6VgMc9khIZeNCDz1PNDz9Al6I8/lN1YPSPKNsHVpWDU8fZ+2nPiwCD3+hy5nuQiwfA3MoUs10neQQ0uEuV/kfpJCZHb3SwqQQEi1+cTR+s8IgMPS8Dc2LTGEC+9JPL77x7fb/7fvs8ts2LPzmhZumSjTJtwQBLiMzdY0WcTZcq4ffLZN3dLkaLOtTqQyqZNWstTj4yUwwdXOP0tMTFZojYcUI/hn8yQCtViVX0MsmIIKZFTMq66ZpYMLBFUDBAt+Flg+RtyIwIPmYF5bLz+6aefTm/Y5akhE0aCiC01z6Btxyoyb846KVyolCKK4RGB0uq62hISEuxEcK1AwksEnUg6mdzTRzKRontAXEyS6sBcoZrnWiQMNFFwamU9ZcIJOHANyC7TkAPniSyw9UFAwfU5X/62d5dvEit3OHU8E7mcQa5tAmFgkNsxd+5cZQf9AcFlJ3UPjZKefDL919QXi4g85KYRJsS4dR5xNI8QeeyoBIw7l1ZK9fTTGFKP7/fPpNV+HeexPdGyePYqmfPdFjl/OvNxOnHnEmXqsHXy0cQhUsalpwO1mtdc3VReGjBc9m2a4vS3pIRk2bnxgHz+7GgZ8eZ4Kd88QiLLipL4Mi8eqTLja3SfE+poaTIFcXz11VcVicRn8KULNaAMi2aj1MpSssXIJU8dqbGvzM7lNeD6O5rInz9OkdJFK8j6dRskslCEtOzUUE6fPeVEcK3Av3nwwQeVKg6lW8xR/0YTUTNNLW+DNp6nh3ANyORyTdx1sAbIuMlk6wZenvwHb/6Fp+d3Rl2Yq2sXp2yUjBnkLp8jV5NcInIsfh6bOGQCJKNOWTSaTP1bg0sG1y3BtSIiUBzflhJpukcCTqaIjBtHwavIv3WnVsTHJ0lcnL3uwNZI1z+z9/tEcDWOHY2W335aJA8/cYNT1jsuNlWefGiUHDkc43X78+cSZPPaIOl+WwOpVKlAuryKxYyIJBleFkxrx0CMAWSVf5ERnTxxUo4fi5fos3ESGhos5SoUSSfdRFKp5aD5FZFZOgZ7MzqQc+vCvWr1KunTt6uKim/ePldu7NZdEXFGGBHddQURYeqB2TfHzO9xMf6RXDBj2kypsCtzeQ1R6Y8//thtx2WNH3/8Uf2da4bBdvfAgPnyPOfHv6Gh3kdJeENQ4JUR4btckZOjqgYGuRkEdBmpYm0k5M/IoXT88Qc1P+pHR5d87gmuFcEB4vi4hMi6eAnYmSQyf76a+iAe7MuZk/4HLJdP2eETwdWIPh0jP/7vL3n+q3vSnyNwe+bUOXnlrhGyb4v7aQ0acecTZevsRGnfr45cVbdsekdf9sEkCZIS1M9afQ4aOCILJviNSgsSnBoTomTVQSFBUrpiUSleJu2aatk0/TmUxPO229KbhermmlbQ5wXSqME4ojsH3axs7M5Ta6R5y3pSp15t5Zu4A/Jr9os91k03h58YLf5ixrRZcjQh81GKBABIOngr/2J8Ev4XgX9PvoWvfof2OcLC/fPDQWDQlUG4Llek5mCfIzi31+JaFzx/SHK6Fh1J7ldfpf9NSZR9Qd5AkTvyi3x+GguY1jzihRcyvCwoi1/ijesyzjjNDLOmb5CBD7RT83cBWcUZk/bJkcPOMl9PIDD617hdcvfg2mrBhtxicGgd787IE7VEpvvjD79JsJSTD98cIefPJTldg2Ytq0n7TjVl5ZrZyohpmTlyI09Gh2wn76kj4BBtyC0Pxg/xOwQXEPDQUicrqP+x1vkQIY4skFfOuNQY+YrIgnmV4fIFvDfSLU8znKlL4ryJWNudoesJlaqXkVXzd/i1bYlymThaBgYGBrkQZOSyUtOIvbruOtUvOQ1ffpn+o+M+H32O0ABx9C8gAS//SxrxWz77zO1Ls+J3bFxiPzPHOCLqWAuXKJCe9V40ervsscyB9QqHyJxRm6R4hfzpEl8CC0zOcDfyEB+AwPhPI3+RvAklZeyIvyX6eJzzjPlra0inO5rJqu3/qGuvG3WRIIHwYnsJ4lt9GjK+BMut9pjjgNBRXgVhJdMMaK6ZQRUoogi19V6htKtYqaJy/uR+8QcFixbw2edAZYfPdo0HKTv7IeOLlNzfgI0rqtapLHNkqV/blqzouZGnQe5Grg1/kCFjUfF33mgGkIHdkUYKHM0inGtwM4HjTks98IIFbl8TEhIkRYq677abGdg2xY+6mtiYBPnik9FKngvBXb40Svbt8Y3gaiQnOWTmtI2q3oWFEaLobVHcvuWY/PXnUfl55EInggs4B+YAv/7CRDmwK49Ur+Y8CByjQz0JEVTqZrVTAHG1jgwgqovBI6LO3DZr5pZGEnSgdn7fFHWfuNZCNWrt27glV+QvGi67D2xxmgPsDTT4oqM1kWR30DN0GS3ki+TKF1x/q3/1YvkL5ZHmHTxLogx8bOfvx8PAwODyBaSBQGtWApHYjHSlEvZjyRL1o6NKiEgTG/vtlV8cOsXhYu+sKF7Wv4BlQGCAxPuhPGN0zLC3RqluvzzmzlwoO1YftrUPR6pD5v65Ro38oeSHRAYZR0/Yu/WI/P3Vdhn5zl9OBFfty+GQVfO3yNv3/yBbZ52TOlc597/AL6BvBmQcdReAxKJUs47kQSKN2gqiy2utTTvxRahzdX1fXus6DrFRB//6b4TnC5WjMftVAN8XoLLjXqMJqCfQGZzPCIVfdqB9nxYSEmo/7xYaHiLtemcyN9og1/ocuZbkaqKTbThtaaxQweYXtVywpGf+T53KIE9CQjtlyhSp38i/7nGMw/EXRYuUVVFKRv7kC3cmlb7ixJEQCQ+PyLBgu2Lr5kPy/FO/yflzmS/E61cfl08/mJrheZwIbXQYLcBsPtfPmSgqUdGJEydmGEIPIXZdtImokiV1NUIV6vvXUe62e9srws/YI6RKGMDMQNdHamFQD7gD561n6GYHSlcsImWr2Y/QdrzlGgkN8/9+M7ggHbL7MDAwuHyBxJMxgVmBU6CVsTK6+WWFkLS6W19RIEikYFBG3+Xf0hz8DR7Vm/k2w9YVBYv7310/f1gRpdIiMF00oLKkptjvRnRyZ6IUL1IyvRbXEw7uOibP9f5CTh7JfErCnnXH5d2HfsgQSOYzQT1GwJyJDygEXT9nZNCoxRgbpfuCWLd3bWTKiEB3cuFKLUva+pg1ut7bQfrf3V91lcafRGqc2WAV/CbOB9LuLbhOg8zsGNJSoFh+qdqsnO3tWt/cRPIX8Tzn2SB3+xy5kuSy4FB/kdXB1k6w1oHaDWwlM8sp7UdHaKgiPdrI0M2OelMegx7s5pd8qNy/o3D8Qcq/BgZiGLXBv2ZEdG0+fjTzRlIfvD1Z4uOcs7feMG3yWlmxbGeG57XR+fLLL9MlQRpaFsS1paETkVjXBRpjREMsd7J0XsvwdAhy646N5KpGFcUO8uWPkE63NlEjq6jxJcqMFBnDw4MZtZ7AOUGKPWWA6YANGSe6mhVgYMmGP/J6LwmL8J2wFi9TSG651yKlM/ALOdngGBjkRmB3CKx6GgmXZZ8jyQ+SobcJDVX2TvscNIvENiqf45k+kifSfua5Yk3vs3e9ITk5bfoCDRV3bzjq1z6SElLk0E73HZ2t+OL5MRJ9ynt/ESuWztwof491bripATGnL4gufdJANo2Nh/wy8g/izcOaVUUWjMRZg+7bNOrUIFgPQa5Wt7K06H4hC+wLwiJCpeug9qqWm5pk1HRktvE38Cd0BtrTOVHuxTm4A6oC9od0OStAHk2AfvC7d0lkYd8ViwWKRkrfF5yDBgb2kZqDfY5cSXLXr18v9evXz9I+MkSuSpS4EEldEafGBPmMZRcWkCMiqp5UE1saW2kyHhiULI2aFbF1nM1bl5dz5/0zFOp4ju6TL774Qh3D+fP+N1pKTQnwKmtZv3av7Nnl3F7fF0wau9Lt8zR5eOCBB5TElwVUA1kQxBYpkZZN87s1OotUR29j7VzMPiG3VatWVVIdSOoLn98lJco6z/fzhJDQIHnpy/4S+W/3ZhweCKs2PDgWNNTC+JCJto49AHwGerSQp8gp8wI5N7o6+uOIsW+y9hDqetdUk5eG9/eJ6EJw3xp5rxRy6cZtYB852eAYGORGYDvoC5FVOK37kZFENtN+XpcgEmujVGVzggScTXv9ybAwZYe0z0EAVvscqZIsjbvZC+TWu7aSJATZnx+vcTr6uHz//fcqwH/urO8E1BWhQeFeg8b7dxyVtQs9y3E9YcqPCz0Gh2luybUkU6pB+ROjjZjIoMum8D2QNGvgS1CSBOjerH0TiC/klsA8Pge+yJNf3yeV6viW8QwMDpShIx+QUpWKp/cuIWgPgSbAjt+BjwTZpV7cnZyZc/JWCkUCgJFCbG8XXIOxY8eqffM+NRtWkzfHPyn5i2ROdAsUi5Q3xj8lpSv7pzYwyB0+R2BuJLjZMVeU6JduQKBApu/fDsIBB5JF5vi+OAf8cKH9+aHWrRXBskbXIDsQH+Qwb743SHr39a3+oEHjEvLIkzfKU8/2E38QGBQggx7oqWbVIV0JDPRfklKjZjWvs2+nTPBvVAEzeo8ddTaoDGpn0SxfvryqyaE+V8tzTpw4oRbyGjVqOC3SrjJgIpRcd+4XFmLILdtgaKz1PYWL55deTzSWKnW8R64LFc8nne6pLtXrl0l/jqwrzo8GZLtFixbK8FCzw3grjA+jjzSo50IKRY20J0DCiRxz7L6AmmP2x1gADA3bazRqXUPKtUiStjc1lJCwjHJzCHuH2xpIvxdaSlmX0Q8G/iEnGxwDg9wG+kJATrKqHCNI7DQ5gP39O54mIDpVZILvnZADfrxgMw+3aqVkqZRGaWA/6aOBfXrmnfvlvpd7iC8leNUalZKH371Nhr79kAT62WV/wJBbVTMm7GCqw7e+Fe5QvGRRp+yoK6b9Yj8QDLau3Ss7Njo3f0LpRp8XAuRpvlKgUnwBfA78uYYNG6a/3pXkAppo8hwBakq7ILf4mPgc+DIaeQvkkb7vd5FaLZ0zxq7IVziPdHm6pdRpc6E2mECL1efgniSLDOHlb5RmucqZCcZzDN5KoSDv+ImutcWewL7xbyjBInBvbapZs0lVqdizgHTs10oi8mVUEaAs6HBXS+n9Xiep0biyT+9nkHt9juDcKFXmC5tVMD7I2jxA4cEHRf6VigZ8dCptDm54JnGE1fEiM9IIcUKRItLw1VclIDRURQVZaJAuQ2zuu+8+RVxArfrhMiBvI5k3a7vs2ZWxEVTFyoWk74C2cl37tLEANO2reVVp2RJlT25ctnyETJw0Rr0/xqJEqTxyLtp+k4GQkACJjTshScmeM8G7drqv+/BlPNLePSek+L/dGImiUm+tZ9MBjA7Xc9iwYSpLTnMpKzA4EGHdqRkgK2LWHtHkRx99VEVi3QHnAKL7xYQnZNS3f8qhzQmyYv5mSYxPkYg8oVKwZLgMeLSbhBZKkN17dis504ABA5RxIWNKMxJ34G96BAL3LGSXbYiYciw1a9b0mh2gnofOkjhYSPNxWpbP3SIzxiyTg3tOqAYfBQrnlUr1ikixKsFyU8+ubscg/Pzzz9Kj1w2qJviqa6dJ6rlIOX8mThnxkuUKS4vr66gaXI5Py7IMDAwMDNJAcNq1DtMfYAdQ/WTwOUaOVD8GDDudNkaIeltv2J4o8kea35AcHi4133pLahcurHwNgp2oiQh8Dho0KL1Mp0rTItLvlfayaOIm2bXuiDhcknolKhaUPg93lo69mqY387ymfW1ZNutCgNYXFC2fT5asSZPHYseLVoiUI3vsz0ANCBRJCjonQSmeVUi7N/s/C37PlsNS9d9sKoSNWb70AtFo0KCBuo4jRoxQAfQ77rgjg8+BD2kFPscnn3yiMrnMxvXUMwbCnJiaIJ/MflUm/TZVNv+9R1bP2igx0XESFhEmBUrllbueuVWK1MwnW7dtkT/++EPuvvtuRVYhz3y27oDt1t2ckUtDdgGZfUgsx8d5Ms3BHfBJ8BO5jzRpXTN3k0wZMUf2Rh2QxPgkyV84n1RpWk6K1M4j3W7p4rYJKY1OG7dqqK5n0z615VjUWUmITlJBnWJlCkvLmxpLnsgIRZJ1fxUDA0/IVSSXyBokITsQGxuraiCdACkhC7ZjhwSsTRAZeFgc35RKGxPkDqvjJaDvQQn4d81xDB4sk6dPV19apC3MK4MQ8UX+/PPPVQZSt6En8ta9ZysZM/ovKVW8hqxevUEaNKgjteuWk02bl6cTXI2+d18rLw8drUihr1ncUuWTlQQFw8pC13dAO3n1OfuNjSIio+XPsaOVlBaCiWTGFYkJ/kdsrdtSS+raTEobHa4hLf9dAbmluYKWJUMOIb1InV5++WWPxI3uzGRLtQNTsGSY3HXfrWpfZJO5ZtTHNu+Y1r25QcMGSprz7rvvyrPPPqtIKzIkXu+t+yPXnwdElWw40VLuPUgpWV53c30B4w4wVLs3HpcfP5gtxw66NBjZd1K2rN0nYeEhErM/j9z99I1ONd9EoOmu2LdvX/V7YIhDuvZ1T6oh5Fx7orIGWQPfULudC7Pe9sPAwCC7sWHDBo+j3+wCm4IyyQkE2iFDS5ZIwK4kkb6HxPFDaZEiHoju1gQJuOOQBMT+u2L07y/TFi9WNg77h49BMyGIEASNICw2kSwydvWmOzrKrz/+IWULVpPVy9dK/avrKbK3/eAG6dTVmZT1fuR6WTV/syQnuidVriAxXb5xPmWzyFziJ/R9tJs8O3+47WuVp6RDpv89RWVCGXPjOp4HQLr8hXVbbDz2zzVTj/IL0gopdP0bwQOdydVzfHVX5scff9zt8QL8P7KtOogfGJkqQ0c8qJ7Hb0HlxfG07Zz2WdStV0cFLl555RV5/fXXVQCC44KAW9VsrihTpox6cGwkW3jQlBM/BR+EkUzuQFaYBmvHd56RUS9NlAPbnOt9j+w5LttW75bgkCA5sSpeHvq4n1OjSvxqSrXee+899fu52Gi55cEubt+LwDsE3prQMPAPjhzsc+QakgtBYBFBDpodcCs9oqnE779L6rXXSmBsrATMiRVptkfNwVVjgsoGi7DeL41LkyjPiEknuNK2rYS//LI0OnZM1aMQratevboyPhAa6ktZ9H/88UdVT0FziNGjR8uQIUMUeQwKOy6dOjVSu9q1J0ItFtbMXNMWVeWhIZ3ki4+mpzdk9ASIznOv9pCatYvIzp2t1MJFXcmc+eMkIq9D4mJ8/zIgWbq5VzORwFhlKFlsWeA5JzLhkE+ieeF5/L8V8/3bGIPFl1prFmNXMMuOObrUq9Jcg9ojDd5/c9RmGfHZaNmz5aiULF5aChctIGGpBRXRtTaA0GDxh9Tp6C1SLy0pwkDpmhyMCg4DUVQeLMhIdCC6OBMYYI7HOoPX87UMTI/u4nyQySUIwb3iafZiPikj/3vy1wyRdysS4pNk7Ij5cmT/KXn+877pkfgPPvhAXnrpJfEFRIi5X5E8MyrBwH/k5MHsBga5CWTrsivwhw/jtnHVTz9JatOmEnjqlASsjBdpuSdtRNBdBUQYLcTavyZeAn44K/LXeQlITHMAHA0aSPD770vzhAT57rvvlI2kVAXlFn4H2T+C7b/88ouqGaVnw1tvvSX33nuvUgdJoWi54Ya0oOfZpKMZgrU1r64oT396l7z/6CilHPIG3KkH37xN2t3WSMl1IfMkJabNnSCRJYPl3BF7QfAu/VpKaKEU5TO9+uqr6rg4LxROyIZRQ4Xn9X8KQL4CaYFvgszIdK0qMA2yniit8DkJbnMfaL9R9+P4edgY2bJ0pxQtVEyKligsEfH5lT33RHKtEyEgxDrTrsurtAoMBRp/4/3wdfhcX3vtNeVzUK6Hz+GN5GqwPcF6QAAEgr1u3TpVx2s9HysKBZSQF/u+LylJnp0O7ofpI+fJoZ1H5a1JT6cT3ffff1+eeOKJTI9LHxv+kzfSbeAbcrLPEeDIjt7fVwCQNvCF0ItCVoGkgtE6GtTRIicCNY8elcpPPCEBLjUX3BO6i7IVR2rVku+7dZO40FCVxYUIEUWDyEKIKlasqMggNTKcA4aHn1mseU+IGKSK7Vi4IJN0xHMnK5k7e4MM+2SqnD3tPopZrUYpGfRQe2nQqKJaULt37+60kG1cv0eeeOgncaT6Vs49+JGOUqNOXmUMkInTYZAGS1u2bFHGk3PE+AQkV5StGxPELgoWzCO/jH9UTp06oQhWhkg3CfPVq1X2c/DgwYrAUTvDYq2aRCQly4cv/ShLZ2yThPMZP5yiZfJJ/8e7SIeeztJ0oqOoArRUBrku2XXX+wODRUMJaz0OIHKL04Ch4wEB97dm66uvvlLHQVBDy5nB7q2H5bGen0lSou8OQp+HO0i/xzupBlR8Lpp8k0VARuXardoVGHM+52ztIppLgGOCs9TmrwckOG/GQI03JMckyLyuXzo5PgYGBpcOrPHYbqfeHdnoc2D7sXnYjYpnzshVTz0lAf82L8rM5zhdqZJ81a2bJBYurAgtvgOZXFRj2EZILbaEQCrnQKCXQDeBXPwNbBodf1ExaSWRp2DtmgVb5IOnfpBTB91PWKhQo5T0f6aLNO9UT+2D8XrWcYN7tx+SBzu9I6mJvtnH2x7sIF3vbaZIJsHflStXKqJH6c5PP/2kCBr2KU98Kdk823NjKk9A+TRqxeviCEpR18TdOePf4HMSEMCOsi7jM3Cd+bw+e+5bmffLMok7mdEPK1g6Uu54qqd0H9zByScgU0vnZh10Z39cK21rdUYZqTf+Ttu2bZ32CzmlkSb+BgET7LRTjbcN4LuxDxIEBA7wV8Gx/Sfl/sbPSWy0+27M7tD5njby+LCB6vw4vv79+6cH8rnHUKR5A74XGWxTKmUf0bnA58gVmVxkvzyy84MgO0f9gZ4hRj2CNTso1Eq++KKkjhsngf/WQLgam/ORkXL2jjskqmtXKXX8uFq8rBk56iBYiFicITKQWx7U+PBaopM6copRYLHTDYmoi4Dw8Tykjm1YlDjm51/vKgGOQjJn5ibZumW3ihqGhKbIybNRcsONJaVO/bJqgSHb6kq8rqpTXqrXiZVj+0vI6dMxXjO4rduXkdbtKinShbGkSzMZZvaJ4SfCyjGzsC1buka2R0X5LKfWaNqyggQFBShS37t37wx/h0QjPSbaqjOUZL65Ns8NfV5ObsonB7Z6rvk5cfC8fPj0aNm8Zq88/Fpa5JJribHXBJd7Qe/bFZwn9cCuJJeMLIszCzjOy9dffy3333+/X0SX7aj1JaihCT2Ed830Y7YILpj80yK5/vaGaU3O3nzTSXana4S9gddwPk7fBQNbyMlRVQOD3ABsLXbXU12lPyAfobNogGwq62y6zaDXxMsvS+qvv0rgv5MMXH2O+Lx55WDnznLw7rulzIkT6Z30NWj4hM9BcPaHH35QfhPZSMpWIGsQXh4A242DrEfWEcjGf0FJBVmGoECoKOm5770bpHhkeZkzdqVs37RbwsMjpGCxfLLnzHrpfNtVcnWbGumj8awEF5SvWkqqdYqQM2vyyNEDp7xeo+Y31ZB2d9RTfhGfARlqMpzYZ/yQ559/XhE7zm/ZkuWyc+F8SYy3ZyPrXVtZ8hXMI7///rtbnwN/g5FMBA24ZoDrRAb25ZdeltNLUmTn0oMe93/m0DkZ/sRPsmHhFnnuxwclKDhIKQLYl1VV5prZ1/cBZM9dl2RUbpQg4ati3z/66CN5+umnPfou3nDnnXcqqTB+FNJnfBzGIu2dd8IWwQWzf14ovYd2U74rCjcNEjy+fH/wOUjIkLQw8A+pOdjnyFEk9+CBU7J6xW6JOR+v5A/Va5aSOvXKqYiaJzmnHbBYQiBYxPhS05gBKa87xJcvL+uefFIWli8v3Y4elUJRUZLCjNYyZeRMeLiE9esnaypUkAVLl8pDrVtLxwIFlCEhMujaGAmCBhElYsqizWJy1113ZXhPJCk8yLix8DzzzDNqcWVxp/EBP3MOesh4w0aVVEaYaCAG9MMPP1RkDPK1b98+eeihhzK8Bx32OnRqJtd37Cwfvf+L7NuVLLstTaNCQwOkToOictMt18iZ6CPy8ccfp0tJ6DxI5I8aJWvDAW049+8KlhlT1vn8eWALS5ZLlRdffFHJuV2BgUb6hLHRdVEQUmo+INshpyrJga3OzR88YeqvSyWyQB7p0q+xcl64ZlkdD0EEWBtKpOdcW6REyH7tAOOm2/wjn+b3o4dOyMcPvW/7mM5Hx8mrT3wsbw972u37ZAbINY4SmV/uWwP7yMkGx8AgJ+H4odOyYk6UnD8TKyHhwVKxZmlp0LK6sjGumTR/gL3C2dekEQmxp/GHSSVLyoZHHpFZxYpJ95Mnpcj69ZJy9KgUL1VK4pkg0KGDnGjXTkYzA71xY7m2eHFFmLUPYAWZXMhSmzZtVPNBsjXu/AHWeAK+NFdCmYTUFIJJQoH+F+wHZRn7AVc1qqzkpSjO8AEI3kO6yLoSzB84cGCG94D8tGjbWHp83FM+ee07ObQhRnU41ggJC5IKDQpJn4dulLMJaeOH8JXIUqE8wieCOFunBqiuxTffJGe2BcroL3wffUOvkrIN8qVLf11tIsQT0o/EV4/cwbfCr8NvzH+8jKxcusSn91owbrnkzR8h973fW2Xsrb1GCHa4qqp8EWXqOlZUZ/QUoYMz1yUzhZY74HNo/wWf8lz0efmy3xDb+yEQ/8r978pzXz7qdD0h6r5kZ02pVNaRmoN9jhxBclcs2yljf18mq1fsylBvWqFSUalVN7907uyfLAMyRG0IhIkvExIeFitkIyzggMUMgop8SH9JiWbyxWvQubNUb99ePaeNyYmtW1XmrX+bNnJ1YmJ6PQevh4Qic7JGsCCdECL2TVQUA8HixEKKkSHryqKnu+ZhPDBIGA62w8hgWCB8RH/JnOporAb7Zr/sh22I4vIeGCctf+X46bDHMaxes0IeeOQmRWgY4bN+XZSsXrNSzkYfk4MHl8jGqACVicbQkQXUmVTk1jgA7qTUjzx5g2zasEsO7Mt8FALZ22df6SZjJ4xQ5wJJZNFm/xB1PhuOn4UYo8MirOfA4XzsjjomX85bYOte+PPbeZKa/4Tcc99dbiUfVlhrcbUBcjWI/E4UnUHqZJf5zIkAI/nl+hBl9xXcbwRytGRsxoRFkuylJsYbUs/lc+pYyP1tJ8PMdwRDStQ5q2MzDAwMDC43bFqxS8Z+NUeWzd4oqSnO62zpikWlUuMicm1r7zJLT8DXwOfA99A2k+AhyiodOMSe4G/gd2iQocTJr9umjdS68UYnnyP68GE1XaBvZKSqEdUKMNZofA6aBUGANNgOaTQ2iGNADoqdIggLKUISC6nAt8AvovYVKa4e/aPJOXW+7IPj1MFbMrY6WwtBxuaxzciRI5UKCPuh5a9IpyHBvGbLts1y633XqyaMJ4+ckY3rtyif41T0Mdl3YKes27pCnQ9kkCA/+8b+4tdAlK0kV+Oup7vI2mWbZeuKtOy4NwQEBqjxSAs3TlP2luQJ54cfhs/BZ4PPwftzPTknFGYECBgXeP54vAzv/aete2H6D/MlrHKqDH7yXqfnSUK4BjtQ+ZHg4F+OD19HZ5KtoJaW4+Y6kgDAf8HnwNfj8/MV3Bdk/dmWcqv5kxZJ7FnPEzS84eyuuAw+qR1wX3IcfNamVMogR5HcX35cKD98M8/j3/fuPqEe0af/kBdev1lCQzM/ZaKmkEKce4wLWTrrYsHixu96rhyOPAu4a4c9SKaOYAJIGIaCxZfsJoSTxdgKMo4QTepIaMyErIRFnkWLhQlShAFh4SRzh/yERZbXUOtqBcfCOZD5ZZHlvKix1aMC9AgcyBELFq/DwLIwI0chisbPLJZEZlkQiYAiiUX2zOII2JYsbYfrH1G/I72FZGJwMHBcq19//TU9Q61lSa7YtWuHVKx5TmpdVVfmzNokKS7Og0bpMoWk1131JT7psJJrEUXGCOMEcF5IV7guNJli4ePzImLNOWnJ+l+/TBC7SElOlaBzzkaA2iQIqiv4jDFEfMYsvBh5d40euDY4HQQOMOg4JEShIeQ4AsiBfCWKEFMeSLJKhNcSfxGZ17mtP/egp+yBJxBI4N7JjmxGboPDEaAedrcxMDC4+Jj68yIZ9sIfGcitxqE9J9TjhQPD5ZWR90neyMyzUdgwgtsQTuwwNsE6vQHbgK3R0mAAScFeWOWmBLKtAXLsOfYQJRgBavwEMqZWYKN4X60ig1AS2CZwq0kbx4T/gE9D80v8FGw+5TbWBpfYM02uOA7Kudgeua32OQiy68wh9piSIkg92UWOk+uAj0GQHPJMQkGr3Dhn6l0B9v3ajg8p+whBhtxB3vE9sPf4WgS3IX6ecOjQQSlYL1a6XNVSZv6+TJI8THkoUrKA3P5EO3EUiFZBB64HxJb3w1ZzbvhD+AL4G1w3rjNBft1EavRbo8QfxO50OH3Grk1FNXTXZIIE+IRk/vnMXQEJxFflniL7DhnnWmpfjwC7r0SR4+BeQPZcpaD/WdSIEOdJJXx+fP52QFCG74cvTTwNco/PcUWT3Al/rvBKcK1YvGCbvP/mJEV03YEvFeQSQBT0F50sKYQTI6RBPQd1kJkV7RPlZDGE1LEQsgANHTpULVhWY+UKCAULFAs/hgVD9tlnn6koG/uB8CKThrgS0eV1RF75nYVeAyODvBqDybmxXwwCJEo3i0BuwraQYY4Xcgi50osoJIV9IFkiSszCTWaZub26654reD+dheR9IbvU3zJ39tPPPlfXkoUR0qwBaYcIP/XUU8q43tjjKvlrwirZvSNaTp8+rzK3NWqWlSYtykmKHJdUOS2zZs1X8iYMN5lcjCQGleuBocQp4PpRe0KzDAIXBAgS4pJl4fT14g/mTV4n/Z+4EEyA7LtbVDHMGGUcCAwzEWoMCRFwjBQBD+u/XFeIrgafK8dOd2Ouk47geyK8nBeyaZwatt28J0r8RWiY87LA/a4l7r4CJ4n7XkeWDXwHrfzttvO3+3oDAwP7+GfyavniuTE+SUM3LN0hbw36Xt4YNVjVVboCAoidZ1+QOQLi+AvYCAKLKMb0+0A8sbmZyTf1est2ZBOxv88995yy6Vafw1VZRJCe9Rriw3GRoaM0itfQEAhfB3uvCTTHDeHFzlnLa/BBsHsEziGz2sZj+3gACCD71O+PP4CPpQkZ70GWePjw4Wob7I9WpRHM9kRwmO1KBpgMMj4c5VeUMg0b/qU6f/wQa7AWQvfNN9+ombQE73vef5389MkEObQ5Ws6cPC/JyUlStXYFaX5jLUnJd04CAmLkn38WKpkyCQjOg6AA/hn1yFxfbDbnTRdqbDLXXwf1p/3om6/qikXjVsqQL+5Nv4e4vu4abOpMLsCHgnTzOXvyOfD18JW4NvqzwH/AV+N6ZJjJ/C/0a9m3Lt8jqLF23RrxF6Hhzr406j9XCX1mIChkSqX8Q2oO9jmuWJIbE5Mg3301x9Y28/6Okq49rpb6V6fJIogIkskELI4QWxZXIossqvqLExZSXFYvPSbrVu+VuNhECQh0yLH946Vbz0bSuGllt8SDLxqLKosI0TKdLdUROfYLgca4schbpakQTl5HRpSoIVFKuiu71uoC3hvjwD5YUCGLyI7YLws9iy4g60wW193CqBcTFsPHHntMbYuBICLKsWA8mBfLvljMWUA9EVwAgdayWSQoKzZtlQ8m/iOrgivKgv1cq/wy+4sJck3ZgtK0XEFp17KZMmjUG2nZ7569W2Xoi2n1pSzcRHKtbeIh2mS1kcViaNu36yjvv/SdBCfnk+1bd0qJ0kWlRYc6cuTIbHX8EGEthzmw65ikpswXf3D04GllzPRnTsQZx8QdMNzawOEUEDTRI6EIIvCZE/nldz5bPmees465QgbENSdAwvlD1jH6VnAPQ+j5HImuEzn+/ceJ8tPyRX6dY4XqaTJ8DX8lxzgkZNJxCgx8R06ujzEwuFLB2JOvXx3nE8HVWLNgqyycuk6u654WJCSYqTsis06zRpLlxD5DSgGEIX9IMdk8e5esmrdZYqLjJSDIIUeWfi9d+raSZp3qOs0z14DUYD+wSewPIuQqDeZ5Aq8ch5XEcE7Y+lGjRqmMIF2IsU2esmLYf0gc5JvzwX7hbxCAhygBgrbufA5sH+eNj0NgncA/x0n/DvwR/s4+IedkmLXt9ERwAaSM10E+CXRv2b5P3vxigmyKrihrTqeRw5lRf0v9qqukUfVC0q51E3WO2Cbd/XpD1Fp56r2B6ckL11plPRmCz4meLF1v7CZfvf6DyNkQidqwWUqULi7Nbmgkq2MXq0ABhFo3ijp/JkY+jvlF/EHsuXiZNG6yRORPUxNCLD3ZZq6B9jH1z1afg3+57/iXgAQ/Q3qtTZsIcHBP4k9yPfFT8aF0jTFApcaDfZCV516Z9dcc+XgKkzfsD2ypUCtNnm69H/1piEWABMWjKZWyh9Qc7HNcsSR31tT1Eh9nf5j3j9/NlvaHS6VHT1k8+RniwMJEhlFH+w4fOi1vvDhOtm/9J8N+lizcph5lyxWWl968RSpXdZasQvJYQCAs7mbzYiQgQUheWEwwEEQAAV9uooxvv/22WqiIuLkjuFbwhUY6xELEYoyhwSggByIqpme4ugPklmNhMYMsE30dMGCAkjWz0HP8kCjqHjguIqVklNm/u4WE53gkJafI62Nmy+QVUf/WSl+IZp9PSpW5u0/JP3tPy+8L1krzEnkUkSUSpyXFet8syCzEGhhPDDVkukG9RvLSg5/LmHc+ksT4C7P4ju08JBsWHJKiJfPLvAIbJKp6lDoPiHtWhmYF/Bs15tjIFhMF9jTTjvtKG0k+F3d1yFbQNOrRRx9VRNZVJYDjA6HHIEN8uW8JnhAR5z1c6436DOgh035YJ8cPnLd9jl36XJC7EfH1tzW/nrFHtttTgzaD3CUdMjC4UrF4+jo5dTStRMcORg+fLueD0gKTrKWQTuwBdh1bTQBW25QzJ87JOw+MlPVLdmTYz5p/tqpHsdKF5Jkv+kmdJlWc/k75ErYS++1OeUMAlOA9dkirt3RNry5tevLJJ1VjRd3kyhu0ZBebih0iwA6xJouGz+Fudqy2i5BXyDhZQHwL/C4aGOGHoS7D37GO3kOGjU/FdfIkpeUcKHH64td/ZMy01ZKqDP2F18YnOWTZ5tOyfMtpmTx/q1QvGpee/dXKI0/qPALJ+IskHZo1bS6vDPifDH7hRYk/d2Hs4fFN52TjrJ2Sv2g+WeBYJTu275BGjRup4HpWB3W2bdNWChYvoILdBCc8NafkM9Q+B9dDT9jwBBIifOaaDFvBvTRp0iT1OSK75vMmkILvR2KFxqtWdOreQcY3nCW7Vx2yfX5d7mvvdw8QV5hSKftw5GCf44oludP+WuvXdpvWH5FW7UpIRJ5gFX0iaukuYnT44Gl5/IEf5dRJ7yThwP5TMuTBn+SDz/uqGbMYLhZ8opyuLc11BJh/WcCnT5sv0yZtU8cUGBAm4eGhUrFyMWl1XWWJjAxVxwcBhdDRZMKTfMQ6DJyFiKwxP1MbwnFg0JDPaEBkMWLsm3/Zhogd78ExsyhzfEi4GSPDgkPUjgwmxA5SR2YZo4qEGePpivLlK8jgL0bLyj1HvV6/lFSH7JH80rhyXenQoY2KUmL8ILu69oTj04POMaQcFxFVJEXP3fW17Nl2obuzK04ciZaJI5ZLm+4N5Pz5mcpYXVWjrmoi4U/EsVCxtAHrat8nTvg8IoLIItFRFnCy/BhUfT/o/XGuGA8Mf9++fTMs9NQf8zeuO0SY687n5ckg3PlQZ/nkuT9snV/9ZlWkXJW0piQgq4PWuXdxeDw1wTDIXVFVA4MrFTN+v5BBs4PdG49I9PHqUrBEmpwSQueOeEBwn+zxiRzaczzTjs7P9xkmr/14vzRsVUMRD7KL2AaC01ZYbQOEbsGcJbJ4/FbZuGiPBKbOldDwUClTqZi06dlQUiOjFXnCJ2DNR0Gky5q8+Ry8B1JrPbmAtR5SavU5rIF09s/5Q8Q5doK7EE2C/GSYCe7zd+UjTZ+ufA58IY4JBRf+Cf6HKwioPvH2r7I8yrvPgdndfyZEqlRvLNdf30lWrlyh9stxczyuoyZ5nkQEDZvizsfLCze9L5sWX2j45YroE+dl8udz5ZpO9SQlOUXJvuvWqau6byfZHFcEwiJCJV+htJpVghKUZfkCkjVccwg8GXztQ6VdgzTfA2JL8B9f5p577skQQKB2Fz/sr7/+UsEPVHMo6DxlWe95sY+81PNDW+dXvlYZqX9tLackhj/dnjXwT02plD2k5mCf44oluUcOeW4m4A0oLurXayJVqmVsFmRdAF4eOiZTgqsRG5MgLz79u/QeUFmKFC2kCI3rSBkMDBmttNrXFFky76SsXsFCwYLMzZIosTGJ6j0Zg1S0WKRsWLdfHni4t5IA6UZEnjKyVpKrf2eBIjJKPe3//vc/ZVwxSDoiCalisdIRL4wM8iKiYBBkTXAB74uhgmgjJaJmiAWS+hAyuxgAq+R68aHzmRJcK/5cvEEaVi4jXVu1UosT0WbdYZLj5Nz4XGjwQMQ35nyMPH77x3J0j2+R9XmT1kqnPI3kpVdfUg5BpdpFZNeGE2IXLW9IG0XEMVrHIAGkV1rGQyYdA6PB547TQBaWjLuniDGGidpajIo7Y8ZnxH1AUALD5a6zs0aHmxur2uOV852bm3lCRL5QaX7ThTppwGfursmFHRCQ4HyQQRkYGBhciTiy96Tf21avVFsaXee9GeC7D/6QKcHVoEHSm/d9J3e82kIKFMmX3gjKCpRp2CDIJ00TV07aJ2tmnhFHqvadUpQU+vSxaNm4bKfkL5xXtq8+LPc+ebsietghMofuGiZafQ4NLSlGdYXs+b333lMkGXtFgBObpbs1607O1AAjLyaADjF+9tln0wMAZIjJ5BIYgPBCfvBvOCcekC1rN+Blm45lSnCtmLd8u4yevlru7NpMkTyyxBBqbKpuwgnIZuLfQJyGdH5Vdq/0POPWihUz1ktQWIC89ttrKvFRvWV52fT3LrGLRp3rSHBIcHqPFys4JoLm+ALYahIEWqKO74asGp8DfxQ/0h34DAkmEDznta5g3/heNLQiScC10t25XdHkhgbS4c5WMvuXhT6dW0h4iFx7r3NTS8oF3QUx7ID78M8//3R7Pga5C1csyfXUeTc7tl2xdKfs2e2bsdE4dTJGQgLLyLXXNlayGsgg0iAMDAsEkUoW+TZt2sszj/4sW6K8SzpOHD8n0ycyEmePtGhdQ2VnIXgYFl1D4sngsAixuOm5vpALJEzIWyFE1FG4Zv/I4pJ1YxHFuBEVdSVi1DCTTWRR1XOHOT+yfdTTsLBiDKpUqyZjFvk+71Zj2MS50qJyCfW+LMiafGM0aVrFAk6ED6Ozd9MZnwmuxqw/VkvZOuHS4YY2ki+wlLz5gL1uh1yylHzHVBAAo4UEF+OgwXETDCAby/FzrXE+rCSUa+wNvBZCjMNiHSWlpcks/hh3wGdEMIL7i8/D9TOlbuuFL/rJGw+OlNULMsrfrChcPL+89s3dEpQ3Kb2jZnbVtHBfEAHm/kGaZ5B7pUMGBlcqrDWJdgHJ9IYdG/fLusW+zWy31mrGHgiRW27voHwO7A72ADIEICKQxOs7dpLX7v5GVs5L60rsCdGnYmT29xukds060qlPc0WMyMzq9dsV2DtNBMkik6HlvQnmM06IYDo+CNsjP3bNEqJGItOmyRiqMFciRgCdwDtqNN1sic8BX4CmUewfW4VfMHraarGLn8Yvlk7N0hRyHCe+EeC8PvnkE9m8ebOSX0PCD2054TPB1Vg6aZ38/PVvcsMtHaX0a+Xl0b9ftX2MeaqkBQPwy7hGVp9DN9Qiy03SgUw8PpmWM+MbuBud5Po56t4u3D+69llLk7HZWpWI/8Gx8Bl7ko4/8dW9aVn9373PA85XMI+8PPpxKV6toKqjxXf0Jq22A84Hf9uUSvmGnOxzXLEkt1CRfHLk0Bm/tl2zdpkkp1ZXX153sovJ41f5td/RvyyQJMd+5cxjYFzrIYhGfvr+1EwJrpWMv/3KePl21P1SqkwhlRFjHADyEmsdKNlavsxIfcguIk9BPqQlKTqThrGgeRQkkeMjMqeBpBRjgVGDiLHgka3VNTG6UyJyYWsGk0VO1x1jtJj/+93kOXIi+kKtiq84dC5B3vvye7m6ajknqQm1IUSWeW+OiQUsalac7f2npjgk4XgelVE9k3BGytcsIvu2+B6dr3x1IVkXtVJuu6OHMgCuI5s8tfQna24HRKe5xgQruJcIQHANXKXJ/Ay55bowLoH3g1RbER4RKj0faiwxQQcl/mhe2bvZOXtdqFheuanftXLD7U2lQOE0SRT3D58jhlPPgs4q9Bw7jK8/DSVyEzAeqTnU4BgYXKkoWDRSjuzzL5sbtW29hBVN9ihVnvKjb5kvV/z10z9SoGqKrF23VvX1gExas30Qoh/enSwr5232aX+4DJ8/N1oq1iotNRpUUIFmgvU6gKtB0BWlFbYH+4SthhTz3hBdfAl8DhpXIVGGhGPDUTFpkLlFrUSQHDky9pR96rGL+Cru5KbYDwiMbor0yy+/yJ9/zZfdB+33aImOTZaPv/5dqpbOo+S4ehwgZBsfCwUeZUb4Utsn+Z4ldnqPrcnKN+Oa1WhVQbYuTBs96QvKX11cth7aJLeV66my4plJlZFyo1Sz1uy6dtJ2B4gwyQT8QnwsjpXtXKXJ7Id7DIUdEm/uCdf6b7pA3/J8Rznm2CcxOxyyb81hSbWUhuUrHCHd7+8kXQa2laJlCqvnuF/IvBJk8LcHiCtMqZTvyMk+xxVLctu0v0p+H7XY9nZ16pWTXrffpCQYRKl0dJYvMlEyomKrltuXlIAjh2iOFKIK+d113D0XnSjzZtsb7ZKQkCwTx62UwY90TF8MvvrqK0WEiJSyEJHZxcCwQFtni1mjnxhWZCwYQvYB4YYwU99KRhBio2thuQZIX5CNaJJLTQrbYdBcZboabPvwww/L48NHQ1nFH6TmL64kJkhnaHwFsaYOhYw0NT5EEmPOJspdo970a/+zx6+UQY3bKnLe7o4q8udnZ+T8iQsNqzyhZae68tynd8q+/ftU1toaIPAErgfBB+vvEFeutTewb7L2fA7IvmhuhRLAW/aXKChRZ4gkUjD9GRHpXrdurdx5fzd1D5w5Hiv5w4vKn3+OlciCeeTZVx/NQDqRlCEJp6P2vfc6D6HPCoj84nRlFhzI7cAdsNuoJIt9TQwMDDIBHZK3rE5rDmkHZasUl/6Deyt7SqMpre6CMBCYxBn3lYS6IvpknCTHBskjjzzilhAmxifL1F8W2c46TxgxT4Z+0V/9TukQJU/YCf0e2DAIK5JoK8kh26hLtbAjenIEAXYC1/gcED7IDMSDIDDXggAuAV1rg0n2BamDUOHruAPPM87x3a8miYi9TLjGuaQIVcuMzcUHwtZSckTA/7XXXlNkOiQoVG75+H6/9v/3bwulyR21lM/R5v5GcuzQCTm968J5ekKDNlfJ6+OelNj4GDUGEV8oM8LKe1gVByjCuK7u+qZYQcKHoAQZe8YxkonHH/YESphQCOIPanKqAwQcIyq0rv2uT6u13rpPiuYpKdOmTJPzCefkzU9fUfJrKwgqUJtNWV1mDTrtAF9Dy80NcqfPccWmVLr1aCSBgfYjCWUqiJJ9EoGiCx11qzyQaBCVnDx5qiQlZU56PCHmXILHkTLrVx/3S2Y9ffIamTRpipLM8MCIYCj5ly8xRBSD4dpYAMmNjmCRmcVoaJChY5Eiusq4IM4dY4Lsh6ge0UuMGu9Dplhn9JAleSK5GuH5LtTm2sXh4ydV5BiJEJFL3o9IXP/+/ZV0lyjfqeP2O1xqnD5+Ti34fOa333Gb/Pj3q1K8RoCE53VfI1usVEEZ+GwXef7zvipCqSXdGD66HUNaPSExIUkO7TojK+ZvkQ3Ld0m1yjWVLCszkBHnsyJ7S10096seReQNnBeLObIx3T0Tw42TgWRHBSxCEiWiaIocPLNFHnxigMesKs+TncfYY/izA5wP9w6BFYPMZ9bZfRgYGFw8dOzVVDUBsosKDQsqGSgkAAce24Pdxv/Q9ZBnT5/z+7hOHnWf8QRblhyUuPP2VVULp6yVsWMmpPsc2GJsL3aP48ee6F4ZVpB91XWyrj4Hx4jPQVCe5lJkfEk2ENTVM17ZJ0QXcszPquO0Lz5HHv99jiNHjyt7yXHj/+gpE3fccYfKKkOkz544J0mJ9ptGgdjoeClXprwK8t58a0/5ee0XUrp5AYkskqacckXB4vnlzud7yFuTnlb3m5Z0c+0IYpNd9oTkpGQ5tOW4rJixTtb9s1kKRBRKn9rhDSjTIKZ8JszJpe8KiY7MQFkeY5hIRECS8VNIHilC36aNCuIUKllAQoo75HDiXrnzgV4ZCK4G54jii3uKLH92gMA+/ixE3yB3+hxXbCa3eMkC0rlbA5ky0fcB1JWrFpfHnuwrsbFp8hld94kUhy8lCzlyomHvr3WSV9hBhYppc9HcYdcO/+TVMTGJUq7MVdKw0YV6To6TVvssfBgf1yYQyH6so4sgOize7rKAkB+IB/IcFistdcH4kEGFyOl5dxgcbx0XQUSoe8LoC5pd00gSE8+oRZdzI5qKsaFmgygwEcdjR/13CIKCgp0M5py5s6Xb3U2kUcPGMurLSRKcnF/27Non8Ykxkhx2Vt778gkpVfpCDTTXkMAAGXEWd+pzIZNkzHWE9dDeEzLllyUya9xKOXcmVv6QNPl7WHiIVK5fRCqUrCnV62YcVq47YUMGH3roIXXd2SfEFTmyL00UeD2ZXK4fGX8CBLp+GnC/0/qfAAlBDa7FzqiDMmvsSjl28LQKjhQpUUDa3pSWwUeahMHDEcNIZxXckwQHuHZmjl3uq48xMLhSkTd/hNw8qK389ukMn7cpWb6IDHl9oEhQqlrb9VgXgs8EEiEBPEZFLpTT8f7ZtQKFnbsBW7Fng73eItaZwIVCyki7zhfqGVFRQbI4foiXq89BGZC1XAaCgU1zBfYTMklvDwgvklLIjSbG2FQC9Frxg8/hqbmiRkSY/z5Hwwb11HFCsiHwBInJIBNsx+dQUy0S3I8t8hVFihROt3eLFi+SDgObS88ePeXdpz6WoPMRcnDfIUlMSZBzAafkzRGPS7Ua1dK35diw0/yL3YSM0oSLIIkOUp84eEqmjJgj03+YJ6eOnJXRMlM9HxwSJJWuKSNlIytJ3VYZ+2Fg73Vfj6efflop9gAyZXwuFF2+2GkyuZDiX3/9Vcm+sfP62CjXYt98xjpYv3/bYZk+cp4c3nUs7fyKF5Drbm2qjoPXkyHm2uN3ZtVP4F4j22xKpXKnz3HFklzw8BM3yMkT52XposxlKmXKFZa3PugtISFBasFkEeNLSdRJO/+QRb5QVaqVlO1b0+ba2UFYuMiZs8dV9kzXR1jrfhMsc1zt4rxlHhvgOJGUjBwxSvJLedm765AyONVq7pc23RoqgoTBsAKJEbUW1npeuhRyjHrmGYYKQgUBgmxhiJBA64XGXYc/V9SrWErGLd3o13me3b9D2ve/XUV4GdYOWWNhJNNMRI6s5o6te1QTKH9mz0UWutDYgogomUpmwCElK1o5WB58cED6EHiuw0+jflIklsg1CzlNFx544AH1L6/hviHzivGnhnX3+lPywdO/u436JsQnyeZlR+Sxnp9JvyGdpM9DF4bbUweDjIt96m7GuiYahwhSam0Kkel5RkaqzxmDgyQM2RDEnEYeLPrcK4v/XieLJo6VLWv3Zdh+yq9LpFzVolI0TyVp0uYqtS9kTBBuT52hfQUyNz5HXXtlYGBgcCXgrqduVCN8Zv+xPNPXEix8Y9RgRY4BTRuxnwRu+Zf1T08kqFq3nKyYY6+UCQSFBkhwRKrKtgJstbXuNyHWfp2qtbGVK1j/R438WcKjC8rx/afk4IFDsm/RSbnu1rTOu5Q0WVGtWjWnwLm2a9R+IjPGN9qxY4eytVwTMqhkcvHFdFMjSK6nqRIadapdKNOyizNHd8p1dw5QPgBlUvgE2Eh8KCTC+Ei7d+6RoJBASUmyr8TLUyBcjWoC+DFkFbHzsXGxElZW5IUXnkj3OZDWTp0+VaLHRKusObaSkqeBAweqSRb4rSjaCLZzzTjO6H3x8uYdn0tsdJzbYMX2xfvkqY5vSY8Hr5f7378z3R+lvIkAtrW8iesPuPYEGai71QmOzMBnhu9CEAP1Hw+CGLwPSkD87rULN8rvz0+XtfMy3uuQ3qLlC0me84Wl7e3N03uDkOzI6oQHUyqVe3FFk9zg4CB59Z3b5OeRC2TSuJUSfTbjlzwkNEiua3eVqmktUDBPhi8lNz0OP4aH6CGZq649rpaP35ti+3hKlElRx8Qiohd1SDTRqbQB6PZlQxrh4c7EYt+Oo/LL57Nk8cwtkpy0Kf35BZOi5IcPpkmdZhWkTrWDUuWqC7WckDAy2DSDABgVFiDkKRpkaXlAQj744AMV3cxs9AsLLpFFCCkITkmViJAgibMp+44MTJGkY/tU4wSi2yyWeiA9JBsjwPEQyUw9vFM2Lc9IzjJDg+sqqmglo3rYD7Jo7gMWe9c5xDw/dOhQRWL5HL///nu1cCNr0h0sAb8TYf1x2DgZ/ckSn8j3Tx/PUPdJu1vrZuiarAG5JRDDcWAsMLo4CL601+d+ZhteS3CAWjAMGNsPGTJEVs7bJh8+PUYcXmz2/h0n5LVBI+Xh12+Rzr2bquPTNb/WQIld6OYWvsjQciNoABGQQ2fWGRhcycAOPflxX6lYs7SM/2aunDx6NsNrgoIDpVnHunL/azdLsdLOMmICxNgxsleQFtZkSEuXfq38IrlFqoRKRL60kiTWeWyFrvvlWKnn9Beu0uxj+07IqLfGy/w/lkpC3AX7t2pSlPz02lipek15qVK0ptRpeWHkEHYcGav2h3RnZF3jq4+bB3aZKQocO709rP6Fa00udhGfA38A4F8VzBcqZ85fOC5fEBKYIpGB0covIqDMez/zzDNOPgfvpSZb3FRIFv5pvylp05vqK0UcyjgC1dhl/A4UTa5NmwggP/bYY+q+gJQxY5fEBKTTWsvN9aCOefyPf8m3j/zhE/meMHymGhFx58vdlT/DZ6O7JrtLhOjpEK6qQE+AjHNu+FGcF1J1zpvECTN4j28/I8/d/56kJnl2kE7sOy3vDhguR/Yelz7PdFeZZKY9kGTgmvkLrhe+BokNb/1NcitSc7DPcUWTXD0mpf+910mfu1rK/DlRsnLZTtm9+4CUK19aos8dlNv6tJYmTdOkl57AwkKtDAswhic28bTkzRcmMTZqWYKCAmToC/2leo2KajEie0Y20mrcSpbOJzu3+jZ714rAoACpVOUCqdi4Ype8OmikxLiJtAKk1usX75Enbx8mL37RTxpflyZT0dlYvVBS74kE1l0beCKILHacA80AkM9C5jA4yIlY+PX+yPgSUbRKirYmzZdR8+zVcvZqWU/KBcaoyC6LPAucOzkvDQqK5d0qLy//ztb+Q8NDZOCQm2XDprWqoRONFTgHFlFIKgZIXx/9r5LvFimijkXXubINUd+vv/5aSbeIVpOlnTJyna3s8g8fTZPQwnFySy/nrskaBFy41hhagNwHByazhRryyLWCFOsmIBDTzz//XDkWi/5eLV+9ONMrwbXeS1+8Mk6KlykojVrXUNcB40tk3VtjisyAhBrCzHU3cAb3kO0mEFdKFwgDgxyAW+5vJz0GXieLp6+XZbM2yq7te6V02VLiCI2X6s1Kyu19ncmDK7C5qIB0k57j549L0dIF5MShjKTZEzAZA57sKW1vaKH2g91E+mt9j1KVC8uZA0f8OscqtS+UXu3asE9e6P4/JYV1B9V9ePleGdr5HXnym0HSrvcFUqQJGv/SQAlfy123WwLP+BtIVYcPH64aLkKayOxCmHS5FbaS7bGH1jm5p5JXyBe//mPrHLteV1uqF09SKiqO0bVBEeeFf4Bqrn6V/bZJbkBggAx4rpccPn1QZSVRzZHNRYpL1psAt7uxTGT48c0IBuvu1qjr6J9CVpJEBL7IxPfm2souTxg2Q8LLifR/5A630l3XRAiNqPAD6dGCn+MJHDPNTLmGOimC74Eaj5KpDcuj5JsH/vRKcK344ZU/pES5ItKuT0v1mXCdOA7XoIAdQNSRYHNdTalU7vE5rniSqxEaFiwdO9dTDy394Iv3/vvvZ0pyNfjS69E7MdF/yS/f+05a2nUupwguYDGHAFhJAMeyYP462bnV/rlVrBwpAYFpsqP9O495JbhWJMQlyZsP/yQf/PagVK1TNt2QEDElI8kC5i2TRgSP64gRJouJkUE2QvabfzknjAOSZl5jRc1Qh1QpVkB2HvfNaNcsmkce7tlRNRMbMWKEInfIrZF8ayDl0fNbG19bQz1W/uP7BS1dO1gOHNqrCDnBDBZf5Eh61JPrwsffMLr6GMjeQvZpHkWkk/NnUSdSjQyZ+ltbcIgc254WcXcHasatGWPAsVJfgvTNU6t9yDok1DqTFskVoGPyM3d9YauJRmpKqvz6+SxFcgFGlrolriFE3B9wzhgs9kN3b4PcUR9jYJBTQCPC1l0bqof2OfAd6Mgr4p3kWtfB9CxZXLiMeH6aJPtIWpr1qKYIrt4PJMRKRFCorVm2UTYvsN8KtUSl/BJeMG1NOXnotLzQ/X2PBNdVHvvBfd+o5klXt6uToQEV6izsqifgR2BTKKuh5wiZWhIEZDchfrpZFQ/r5AJQKFikduUismmXb2OeShcJlcfv7iShIcEq4Io0F//IWleMDJzPFZ+uaoOK0v6OlvL3r743RSrVqIAiuJBSsqecDz+TNdblcVagvILYQjYBvVKoZ0Vxx+vxO0gq4HPsXnVIDu8+JnZxZHW0x9pUjkcH9/WxkYHm/cjyempwRuAbf9K6X2TZENM33nhD3rnnC4k5a88/QjXQtncLdRwkXZi2ob9n/gL/3pRK5S6fI0dXYUMSfOlK6wq+VP3v6SavvtNLyZ0zyyT37F1b8hXwnqFloW7esrZUrW5/7mjjZqXV4g/J+/qd8T4RXCvRHfVpWhMCgOQDEkQ0kSYLekGDrLKAsFixsBNphPjxeup8CucrJSXyVZW1i3bJK0PfVX+HBBNRJSIN8bE+ut7YWW6qGCGVCjoPd3eHYinRUuzYJklJSZsnh5EhYgmZo+4EQo7kBTKkiR2f0fOf3yX1mmYcUu8Ot953nQx+/hYV6aaz4+OPP67kTpw78lkr9OIOSdRd+SC0uhYZA4V0F3KPzJms5IFNNgnuv5g9bqXqwuwJEGzX7oi8N9FlnXG2AgKOoSbbq+U9RICRgBPBPH74jGxavt/2cUat3iu7Nl8YC8VnwbFRw2QdWWAHyJow4lxbg4wGx+7DwMDg0iIrGaKb+nSSd35/RCIiwzJ9j26DWkhYWe82h+xf/WuuksZt7CtuGrSvpGwJdv6rl36SU0d8b5qZkpwi3780Jv13iC2BdZRFOnvNA/sJ8dMdnJEEc268Htsb5sgjJcMqyOYFO+WVIW+qsXf0wtCkx9XnuLHzDdKzZUmpVDzznhHF8iZL6KnlkpyUqMYgoUJDmcUxYNOwuWQvmaZALwuNIV/eKy27N/bpOnS8q7U8N+JRpeqjJIzMNPtFBcZ+3QEiSXkU0Pad8yVhgt0nq61nCZ/YYF8VCBZNWKG6RXsCwWfXKRAE1fEN3fnTXCd8Af7ViR1eBzEmKUF37xVTLigMfMWhnUdl1ewL2+EX4nvRG8S1q7evwNcjUILazSB3+Bw5muQCIk+QJH/QonV1GfXHw9KuU2WJLOBseIJDHNLrzuYy8vcHpEr1PGph0J3p3IEvPaTxmRe7S2iY75e9dv2C0rpNHTV+ICneIWsW7LB9Hivnb5GjB06pnyF2EFz+pTaGiCn1MbRs1wsYiyrn0rxZCxn52QRZ99c5+fPDdTL56/VyJiq/bJwWJ7+/u0oWT9kqBSILux1uz4D3U8eOyIiHe0n/+iWleECcBFlGPoWHBEuj0gXklyf6yKMdG0rD+vVVrSjSHGqUMHRIY/mXKDBkkgimFRF5w6RMkyTp2KeeFC/jPsJYsmJ+eebjPjJwaFdF/iB8RCbJaPI7Cx5GzkmmjNx76U6ZN2mNbFl+WP08f958p0H2XCPqhshoEzTYtdlzW39vOB8dJycOe46QI8mC4FthbQphBQs/EW5kQ1qmDAgWkL2m+cPCaetVZtYfzJu81ul3PYaLiLtuWGEXnIdummJwodbFn4eBgcGlB7WOrllGX1GnaRX5cfGrctPgllKgmHMPkaCQAOk24Fr5as5zUrdtGUV0XBVU7vDwO70kb8GM8mBPKF+3sHS4takKbgc6AmXpBOd13xdsX71btqzYqX6mIRWjhfAJkFTjcyDdRa2FzSL7x4MA9NVXN5IJ306TJV9vlokvLJSJb86TE/8ky6ZfDsnoJ2bJ/FErJW9opNvmh5CslSuWyVdvDJC7OpaVEnkTJDjowroYHBQotSvml89fuFUG9agtN3a+Xp599lnl/9DQkaQIDZ4IZkNMOU5XpVtIaLBU7V5M2tzbWMpWc5+wKFqhoDz0aT956ptBUr16NeW3QP4+/vhjRZghsrqUzRqo3rRkm8z5fbFsmb9HVv29QRYtWqx8FSto1kVGG6IbtWKb+ANUXAe2efaJKYVy9ZnxdyDZJB2s4Ph1sgB/SoPgCBl7aq2XTV0jced9T8xYMW/MkgwkleMgEOFtfKM3kJTQDWcNcr7PkWPkyp7Qt29fGTlypDz11FN+bV+kaKTUaRgpzzz/pBzYf1J27twre/bslGXL50rvu5qoBWfV6iS1GGFwyPxZZaIauitxUsoZGfRIM/n5u3Vy5rT3phA33dpYipeJVlEnZC7bVx+VVD8aNFNX+b8Xv5Gg4qfUwgA50UPXIUxIZMiqaRKJ4YmJjpdFYw7JppVpjR1cceZ4nCycsFPWL3hfej58tdx2R/f02l4WSGpeqQPlejx85y1Su/RciYlPlCatrpWFC/6RHjd2lm1boiTw/CllSCDKGBmMCxlryE/ZsmVVpg/CTRYSuQrXAcku1x3im5ScKE++cZfKJq6Yt0V2bDwgm6O2SZ16tZScuWzVoqqOlToTSCqkmddy/ki7OGaiwxwrnSjHfD1Xxn6/WKJP/p1+rjN+ipLIwmFy5p5gufGO5pIvf4Ra1PlMiUZDIJOT/SOOIMFLJlcbGF3TpOGuKQRRaEgnGXndGAo5MEGNu+66S/1+yksENzOcOZlxW+4ZulNj1DByniLUnoCzwjZ87jiHBgYGBlcy6DPw7rvvqmY5/iCyUF4p2yCv/PbCO3Jw1zHZt/ugbN2+RTZsXSUd+9eX8tVKyvqtK1XdJNJWgtWeahWxU8kBcXLni9fJxE9XyNH9acFuT2hzUyOp2bGQshk0kty54qAkxvo3H/azF76RIk1DVfaSYC1+AbZMl3Phc2CP9XGeO3te1v+2R9ZPvdDLxIro4zGybPRG2TDjRen27LXS94Hb09VVlFLpelUCDPf3v1UqlJguScmp0rTFtTJ//j/SvWsniT5zShFM/A0IJ4ECrh+kCZ+D5yBm1G7eeeed6rWQcyYrUP/LtIItW7fI65+/ro6ZLsFRS7dL1PrNUrt+LanXupbUaFJZNX4kCI30GqUSSQr8jH79+infg8C18gcTklWd7OhPJsupAxeC3TM+WyJ5C4VLjwdukG6DOkihEgXSyuhiYlQQG5+Nbf1FQrz3Bl0o9EgIWLsau5vyoH/Gx9KNM7HldKjWzcNOu2nO5itOH0trZmoF140aafwcPcHEDkypVO5Cjie5ulmSvyBDRWc2OiZWqFRMPUQaS4OrqynizCJZq1Yt9VoykOj9+RK6duploSNaCVFjMWjbvrnMnLpORv+yQM6cSnBqYNWmQ23p1rOR1K5bLr3xAYvLofUw3MzHJblDvvBCUrdJVWWAIZEcCwZBD+C2YtaM2fLP73tl2/oDme43+mS8TP5yg6Q6kqVUuaLKQBBtJEKKYWD/XBM9/65skQJSKCJUwkODVW3K62+8KYMfeUy++/576d75BtUiH0KK1AWSi3yZ+hRqUu69915FUDEgLMDIZ7744gt1HJxP03ZXqceMGQ7p1Kl9+jHqDtrvvPOOMq4YLqLUBCYg/Uh7v/tqlCwZe1hiTrsnnOdOJcjID6bJuB/nSc+HGkrBYnkU0SQ7iiGA+J53093bp8/m3xETngCJhcxyPa2gBobjZ0QDZJFz4nUEAQDXiMw4c+f4DKhB3r7dv+gv8FbHQ7MJjDjHY9e5gxyTbSboYObY5ewmEAYGOR2sxe7mw/oKFFUQQdbVslVKqEeLDlfLkSPtVH0mjXh0k0fIDiQM0uRufj32EpVWr9695IZuHeTvscvl92HT5OTB806NLZtfX0+69G8lDVulBRpR1xBEjdnKwuJ7DaoV4QF5pGbNqvL6668rwoft1T6H64SABf8skOU/bJV1czdnut/YM/Ey5d2FEhIRLMUrFFZEpX///opU6dmxegoBAfISRSKlUGSo5AkPlTwlS8oPP/wod/a7RyZP/ktq1qgiL774oup0THYPfxGChs9AJpdxgQA1Gdlo7Oknn3yinuM8GratrR4zZkQ41YrSXIt7gNeSfcSPZN98RvgivNefv46Tf75cL9EH3cvOY07Hyy9vT5AJX82Qni+2leKVC6vgPsFgbHvRUkVk/9kLJUR2EFnQWRXnCnwN/CzX+lfrlAf8M4IFJDJ0DTH3Lv4l9w5JHxqUboryb5wkwO92B6499xK9RvzpDYLvRGCez4PkSm6HIwf7HDme5OoIFFFJHTW0AxY35A2uIBLEF54FlWweET7IBdlCFkK+ONYOuGT9MEaPPPKI+j1//ghp1aaiVKgSJEWLVJDRv42Vxo2vlnOxx6Vnz7TOdlaZCEQ3NtZee3wrkAk1u6m82g9kCENMltSdUVw+c5dPBFfj1LFzsnXRWUltnSCvvPKKMsSa4FpHADBGAEIG9hw7LWMWrpO/zuST8a9/r577c8R0ua5OFelUp7YkHd2rIm1kCtmOSCHXmIgoWVcIK/UZGGMiiTqiS1CA90MiRW0LmV+eY2HGQGDAIGMsbhwndcnBAeGycPQBiT+XeTb27PE4mTZis3z85yNSqGjajEMMeNO2teTvCfa6SYMqV5WWYqUKZiq5d60h4XNCZo2RQfpF5J37j2vGvYZB5ri4D7lmRKj5uWyl4rJurn+GsVT5C50s3YHPHINHRpnraqc+DYNFZJbtcjvSDI7dJhAX7XAMDAxsgjWXLsGuwW5fACl1nXEPCKgSRNYZPdZZalwhGNg01w642AjsAWVAuryn3a2NJE/ZJKlWvrZMGveXFC9RXALDU+SW253HBLIOsx7rET3+AL+ofcHGKhiN7SHjhrTVHRZPWOMTwdU4fyZWVv++TZoOqqGyepBcTXABgWtILu8LWQVHTkTL+NnrZNrGQJn45E9pO5p3SpouOSadWzWQ04eilJ+oM6/YUbKSHDe2jZpdCKb2OXSWU38eBOTxObC9XHv8EPbBv1xLkgnPP/+8urYRoXlk/hdz5NyRzAPjMafiZPI7C+STea9I6col1HMQyWadG8j+LfZtebGyhaVyfc/Nv4DKMrvUvWo/CvKOj4v/yLmQvCDBwz3IteH64bNA6umhUrZqKQrlxB+UqujcL8UVzBImaYGMmvpfO0FyAhkkU1xHN+ZGOHKwz5ErSC43MfITMoF2oWtp3YEvPSQM2RARK6JzLG6QDRr9sFBo2SgRJzK+1loSDBBfNBXZbFRJklJPSUSE+/ciU/bmwi/FX3Tq0k4tSNSfsCCT1WOh5NwwxBhPjmPe3Hmyc7V9w8bc1eBShdWIAOTQRMkg+SzsOlIGWWVRmbnzpAyd/sO/X5ILX6xUh8jcDTvVo3z+MLmxfLjK7GLMWVCJipJ9xZjQvIFAA0YEaRiRb0gv/+ph7hh8It4sfERqyWJjtCC4BC4wPCzQhZPr+ERwNY4eOC0/fzpTHnkjrYMm++/cp5lfJLdkzTB1bkRFNYjSYqR58DkBggOcA0RdvyfElfuT64vh4X7SEXKV2W7aVAVVrPdvbOt4mTN6s8TFJNiOqHa4OXNpDw4B9zzNIcg46OBDZiAIQhCKz5UgTG5GTu50aGCQG0AJxzfffJM+c9UOyPp5CsizrqvGU926KRJC8BdSQXAdmS62APsLyO4SiLfOmIVAk/XidVXrl/13JJ77Rk2Qxs8WfiP+onmbpqphEUFYjgM1FoF+bDRNEbEVnA++0a6F9vumRC3ZIaWvyy/PPfecUg8R1IVYQbh0gJX6V95z6ebT8vqPIyRVOR3ORGjZ+r3qUbJwhFxTPkEeefBeJcNFZs2cWuwonwn7gVBzzaivxebic2Dj8Dnwbyi90X4IHZsHDRqktsP35Fpw/Uk0VJCrfCK4GmePn5Nvn/1NXhnzuPodv7PtnfVk7KfTVDmaHVRoVkJ2796lfD4N/AxsLz4H/gfg9x9++EF9doBrCnnF7+X+0UEUrSDgOpCt171KNFI6pMjsr5arLt120WnAdZmfT4UK6nOnN0j37t0zzFT2BHxxfF9TKiU52ufIFSSXG5iF1i4yu/n5IuvGAUSsIKyQDgwPzxPVIroEqKPQMlIr9GKsW7ez6LvWX2o89GxfWTL5DUlNsR9CyV/WoaKMGEAt7dDvw3tD+Hj/6WMXyYkj9rvdckyJx/OoyJom5ZC39957T2XpVM3NuXPy++o9suFU5p3x9kUnyB87kiT+x1HS5Ybr068TzSmIJjLzVQODD3EnsMDngPG0RrSR6mKoMDY4DzgEWu5SpVI1GdLja9vnO3fSGrnnmS6SNzKtTgVZVJ1rKqsZxr4iPF+Q1G9VQZFXrg3Xjs+fcyBAgMyYe4wACpInlTH+VxaEgSFizOIOsR08eLCaZ6y6GcbFqTFMOClWgss2i5culCoNisjGRfYiwOVqFpRDx/ZJkRLO0nZ34JjUoPrx49W1JiruC8hecC2ov87N4Ntt9xt+hQRVDQxyBegzocmCHTByBWLmCRAo3YgQJ501nnUdG6fnyeJnQEawla6zzAkKu8ozsYkogaxz7jUGPddfZn+5TBJi7KvI8lcLVeRJ174C7BukHJJGUgC/YNb4ebJ3o3+NG/cuPSpPv5KWqcb2cf2ozSXIrTOs05fslZU7MyeUR07Fyby4IEn54mvpdXM39RmigIOcs19sqs4U4utxHpBhgGQa30oHJ6jz5Rg4R2w58l18DnyFGtVryMC6Q22f69Kpa+T4gVMqE4sPx3u36tlE/hm7zOd9BEcESaOulHTNUAkPggO6HwrBZe4vSCLnhjIAoq7tN8ePzwHp5VyRclOWRvKAe/Dbb79Vn7OV4PIZLFy0UCq3KCUn/7RHcktWLyynEo5JZUkL2ngDx0yjUpIrnIN19KQ3mFKpnO9z5AqSax2ybUd/T/YMAuUJZGaJZFlfw4JBPQZfemoFmBHGFw5n35rVggBa5czWfSL5tM5q00Ae2+qGevLPFM9dnN2hTPUCsvfQdpnw5BgVgdSAMP36668qw0tUDwPZsHZz2TZvnviD6BOJSpqkCTvgZxpEkY2V4hV9IrgaJ+NTZU9IWg0IEVIipWRe2TeLrbW1P0aTKB6yXjK+iTHMoE2Wzav3yMkTpyUwZL507N5cTidGO90D21cfkxQfB5RbQSZ03uQ10uWO5so5QDp8x5Ot5N2HD0n0icw7CeYrECHdBteRbt270KBfSZpYbJHWc34YVx6A5zh3Fm+IuRVsA6EkQ86IAj2LD0OkHRz2hxOEFAt5W4M618jjt3wuJ31sCMGxvvDRQIlJOq2MHoZRZwu8fd+IeiNrwni6qxdzB4x3Vubv5gTk5KiqgUFuAaobyJFWc/kCArFk/LzBdeQazrkezbN06VL59NNP1Xvi9Fu75Or+IlYQ5MbXoMbSOj1AIzxPmHQe0FY1R7KDIhXyS1J4rMpkMrJPA9kv9hmfiQwc8uWrazSRjeLctddXxJ9MUT4H0H4HxJrrztie8IJlfSK4GufiUuRQQikltcYnwo7SRBObSqLCqjLCj+CzgkhD8HZu3iNyKFw2LNoqRw8eleCwYGnVpYnsjzvk1E9j+9K9khBtfwQOUxFm/DhP+r5ws7KvBFFufraDbF27XY7u9N5QTB1vnlDp9ty1cvO/0nTuI+w51wxfihIvHlxHfFWIH+Qdf9aadIFIol6kZpe+NATf2Yb7ncA80PciJWace6PPG8vjG16X/Vt9C66HRYTKc98+IhHFQlRTMBSB1sSFO/A9QLWpe4PohEtm0M06c3OplCMH+xy5huTiNNPQCAmlL0AK5C6bqsHC5k0WwReOqBbZUjK6LEjUkmpZKpk/ooFW8Dc9P84dyQV3PNxRVs7fKrE+tmQPCw+RJ966U7btXacic8i2WbhZNCCORHA1yPSGBDuPLbCDokWKOZEwiBsETUdxe7/3g+19Lt55RG5rWEn279mlSB+RUOphqI9Brozs2BqBS4oTObE+r3z9C9l0532N+mSmBIcEysF1yfLgKz0lPE+oHNh13O/zXTh3hQQVTrt+GFUymMUaRkvV+NqyeoHnBmEFS4RJkdoxsnzdP1J8en6nAIeup2XBdZX6EnXkvtGt+pllRxYX8kr0lPsHw8JrXnrpJXUv0fwBAs79r4MCKJ7fGnmvPNvvKzlzwnuH7/yF8sir39wjZStTG1M8fTwGEjMyBq4jFlyBgeQ4CU74MoCdqDEOl6fMgoGBgcGVABxugpC6eVFm0PNjPfUywJfwlm1iO6S6BNpRxCCLxSboDrLWpoQa2A/8Am9Z51sfv1Hm/7nU5y65gUGBMuTTQXI64KjKOlMWhTwZkoLKylrrSelRwfzebYg3ROaNdPI5uEZcQ01YHn/7d8Lvtva5btsR6dOplsqEY4ewSUOHDlVNLsnO8n5WhVRKgkOOzI2TGX/PyqCy+2PLVNXYa+fMo/LYF3dL/iKRsn/bEb/Pd/n81VKscVrTKD6z7bu2ScHrRCrXaShLJ69V4w/doUCpfFKoWZCs3rlUpk0rnn6PkYDhnkKazHlZs7CAzLSWuAN8MIITeroEpB8/GN+aBl6AxA8+LKVl3I8ab096Wp7t+q4c3H7U6zlG5AuXF355RGo2SZNT62AIhBz/LzNlGKSa7Dt+t2505g2Qcx6mVCpnItfk55FCsmj5CrKart1s3f2dRcHTYGnqG4j20SSJBYkHCz5fQOD65YPYkvX0hgrVSsjLX/ZXTSR8IbjPfdZXrmpYSREmmkKxaCNnJarLsRDx4meIC5GvyAL+k1zXba3jbXYeOSmbD9uvyUhMTpHtMWkOAIscI6FowEH2ksUZQ07HanB430l54rYvZOf6Yx6L4pOTUmXW2JXyzJ1fSsy5eElO8r8LZplSZdMH0ROxhng/+czj8tq398jtzzSUa7vXlsIl80regmFSqEQeqXlNSen1ZGN54eve0rR1A5Xd5J7QhpPMOvcUBpoF2rVJB4s9tT/WmbhEm4moEskngq0l6Ui3uTZ0EUQ6bs16q31VLynXD6wiTTpVVkTWFWERwdKtbwv5bPxjUquhc5MKMrk4cEiyiOJi7LyBDDTHicPnS9dRiHGunmPn8PPhB4YNG6YcHYJR3H+6SYsnsNY99NBDKlDG2obCQKk0DAwMnEC9H5ksX0Ew0NMoIKs9xQ5om+fu+0mQlD4Vel3GzhM4pJTKdb4sZTAEaL0RAeSxb054SgoWz7xxZ1BwkDzx1b1yTaf66r0ItrLmcx2w1xwLx4hvhFIO4pu/sG81lO4QWdi5SzBBXU2sTp6JkVVR9mt98R3W7IhWsnFqUulrAdlj/A/ngGoK2wfOHDsrQ9q+LmtmRnksI+P5hRNWqNcRKEhO8n/0T9FCxVTmkQe+EMGMgYPukVd+GyJ9Prperr+3lZrTm69IHilYKlKqNS8nt7zWXp4fd79c26W5ujYExVm38Tm4nyCjSL0JRLuu/wSaeX3adXGoADqBEaTSJBj4bAlU4GdAhilR4rrhc+CnWVG8fFHp8ep1cnWPGlK4ZMbARnBokFzf71r5bMGrcs319Zz+ho9EgoqADJlkPQLTE0gY4KfQGyQz/wRAnjn+XAtHzvU5ck0mVzds8FTv6gqykLrJjztAMljEmT/6448/ymOPPea+dX+vXup3Fhe6LbJQQkqQhbjOt+MYvUVyNeo3ryo9H6knO1eclxVzt2RoPMDm17SpJXc+2lGq1y2nzpkHEiYaYUA2OAYWDW4galh4bzr/NW0XIV+/OdF2MwPQrEPtDNdIZyPX7favo2/atofFsWGJklPpOmludBZfIm9cr9G/j5GZI3bJiSO+RZu3bzggT9/1qRQr5/kzzgz5C+dViy3ycup1qKXlZxogkCm/rmNtKV/+Lrf3GxF2ZDgENiCuyNTIUHPPcc0wOjgBEHuMkZ5hHBIcInMmrZTJv8+TQgWKyobZIyVPwQCJaRMvM2ZPVdcExwE5PPema2RWg4hsvauvktLlT8gLH90ri2ZukCX/rFTXtXDx/7N3FmBSlu3bP7ebpbs7JZRGEAQFA7sQxcTubsUW29cAVKTELhBFuru7e2lYWLbrO373vvfy7DCzOzP693vZnfM45mDZnXnmyeu6zvOKu5SO5+zWpZf19XjsnHOyApQ8UZLMsfN/T/cux0vlAk6HUqfCJp2bpRlaty50/cdiDT9Kh/iMr+BaPPzww/rss8+Ms6GMkOCJZ4zg1xUECwQ2/A0bQrsFQktR2fwAAiipIJBDRC4slrCwwxQ9AYGaZ61fv35m/oK7ai/KLok5sKH4E8ROAkTEc0RTxE5IjS+T70H9VrV17Rvna9W4rZo/frmy3YjDLbs10fVPX6aWXZuYOAZfBNGBJOIjICeQH0R2bI6NOWpWzTKltOl+rB7R8aIz3Z4jsHbLPmVl+7d+/aqNCUrasdWIzpbY4cNskoDvgGBOf3+Fdm/0jkjv3rRPD573gpp0820teSdKlY81309sMHLkSBPXYYOZAwMJ6Ht/Dz3w3q1uh6WSRSee4Di4NhBSMrRUoBGj4J/ZFradqkP6ukGZ0mU0+btZmvj1NEWFxmjdzx8qJzJTHdp00tzFeUsrEXNw/9Kf6yqoW1DuXaZCaZ1zU1udO/JcLfxjuaZMmKGG9RupTKVSOhFxRJdfXXDKtxO2p5ljtv3crqXUTkC27WwQqsjc+TQnuNYltlUqt/jGHCWG5ALKPLmJyXoVBlTHwh4ITrLtScSwuBuzj9LgLEfmAYW4YGRwfBh+Sjow/DyMtocV8HcMGcTBHZj61+iM2rrhtnaG1A195zulHMvQwUOHFBUbqitv7qku3fMGFAHXUlEMEX0LECvIDoQDIoUjgpy36lRfS2f7th5vxWpl1K77yUW5OSfOctOUdN97UCy27dqtfp06GUILeUPNQQki84wTh/SWj6ynhO2LfNvu6kO6bmBvLfxjm1/7tXrbHEVNOG6uFb0okDfOJ72w/FwYeEgJUhBCbrnlFnPeORbUdh5qnBSEkwwogQsOZ/eqNP08fKFZsikPJ7ME0398SZEV0vXgK9eqc9cOZnsYFPqyXAMa/objxgGw7fCIMEWUS9NdT1+V79gmTPCupIprwbEiltjyOE/r5EK4mTpK9pdjR/0tah073lfS1rH7t9asYxL67bffrptvvtn8H8dD2dmXX35pBoq4gt8T0JBRshkhbwd8BBBASQSxBs8UdrgwUNHjyd8D7Kv1p4ig7ipiIDp8n7X3vIeYgxYl/A1L5tml5SDd+AHA+4ljXKf8O0G2t3TlOD3/9YNKPHhcX7w2WkkHU7Vj+w7FV4hTtys76LLrT84moZ3F6QcgI5AfMsqUMCO44zMR2wlkO/ZtrenfeD9ACcSWjlb3a06Ww7IdZ6Y6Nc3/JRcPHT6qTmdVNUE1/h2RAL9u13/l3NYt21ifL/3Np+3u23hYA56+WjOHL1N2lu9VZNtPbDDBPvcKGf1XXnnFVBVSNWCHnHoCcSVknfkczO+w8TAiDIIIf2ebxLbcS8QgJzZl67t3x2vftlPbuuZ9+4CiawTrxhcv1yWXXmxiWGIO4ktXks3fiDkZKknMERoWqvKNS+m6ppfkT3nm94WtZmIBqSVeJcFAVh2STqWmO+HGORvEDgDzBAQZ4iJ/lxs9nZFbjGOOElOubA0tJ6soULprG+jdgbJnyieccJJUsnn0oDh7dvk7jgaySXqeBxJjgmGCzNBLiWHBEfAw4gzcAceEA7H7V75yvJ4efLuadCutIyGr9e5XTykp7eQQArturKuSjGrFd9GXS7kJx4zhoFS2cadyJhvsC668rVuBfiGOx9mPwULs/iLtRJIxjravmfPHg8HACbLFlAmP+uh3v7Y9Z/IKVaufR+x8QdV6pfXm+y8ZZ4ejRqiw0y2dx10YULIov7G9VpBb7g8EEpyPnbaN0vXHl6v0xZu/OwjuqWXYJxLCNHzQDCN88DmGYlAe5grOm+sAK4IoS3AB9yTqmrfg3qaEmX4ZMtR2PWRXcN8zIAwhCZGlMNiy7ZI6BMLXF8BBO1+uQ2qcASG9UwQ3Ftwz/J8gzh24l7i3yQxxnSm3Z6iMNyXoAQRQEoGfJh74u+1RztYfABGwy8sBBHPEQKc4z7NPsE6MgT+BHPB37C8ZY/wowT9ZODsg0hMgRlYoL12hlB55726dc9uZ2l9qs9785nlFli1ITBh45drfiCgNiSY2IuvHMeHPGULVpFdthYQVXWHnRN+7zjODsTydo+go/2OOlOTjRnzGB2PzSCwguuKPyOYiHHz2/Ai/tv3nqGlq2LHwdWrdgfLjd4e/YUgd+2Lbl/C1rlO0PQGSx7WBuHPNqY4jviD2pAQ5b0mpIHNdFn+7QR/eN9wtwQU5WTk6sS1L3z45STs3JJjPEQPg/wu7fyxICDiFbp6VokpXnaC6zcbPZGs9rcFsY3+eBxI+hYH38UyUNOQW45ijRJFc1C9IkZOQusI5FbiwvzvBw0kWDnCBcWp2OJDr5yATXFRUKwtUTS4kToCSDgwovbLuwAOIUXIFN1eFMlU17ptp2rLioFbM26yM9ExjNOyyM66gvNRm9CDk3FCUiN4w8Ard89LlXhPdjn0a6eIbCi5ej7F0lpG0qet/Q3+50ExTAgwR57whDtB7ilIMWXvwvse0f4d78lcUZv2xQqEVjjqX6y0S3BvX3NnDDKIgMOBfspmICajUOAyEA2/AMaBGOu9RghB6SqzhhtwunOqeNLpiz/ZDev62L5SRnmUCHMqmnb0mVCFAyG35syegrtrpzr6Aa0MZvJ3cyP3sDgQjiCwcu6fnkYwFqh1CQIkCzsOfF0s91ahhMj72xTwAd8C+4Chch3jwf0/XjHYL21eNEEO/Ha0OZBMCCCAA977CruxQGAgAC1tT3NWfIvqOGTMm/2+IymSz3G0TMkyGl0obC2wDZcsQa8RMfA3Exx0gyJSJusZE+OCKZSrr16/+0Ob5u7R06mqlJKWa+MfT0ovEOfTjQrKx7QiuEPxLrrtQT311txla5Q2anVNfNzx7WaHDQJvXryIvN3cK4iMyTTkwCQX2ERGXawhJJOZ44vEntGv5Ab+2vWLqeqWUOWQGUvmC6x7va9qiyIiySgYEj2tCjMDvvBFTrO+FJFtwf1J1SBxLDEic9f27v+uv4bO82t7hvUf17CWDlXQ02QgtlPs6Z2rga7hH3U0Zd95TiOzuqiKLAsINMQexE/cxMY47cM9BqolLbBWDu/0h201/fIlCbvGNOYodyS2MwAJucjs0wB1QGuw0Qncg++RKGsk4YagBQXthSwDgUDACqE9kAJ2wqitqBQ8Z23I22KPaYWxds7JD3hujjTPStX1auD57/k/9/vkqPXnDEPXv/Ip+HjpPyvTsPNkezg2HiKJqM3FNOlRSzxsaq2xFz71E0bERuumRPup6RX3TY2zBNF+nQcMZfvmf91W3tO9lp+Ehwfr0hUdMPwmGiZud88TQBcgkpTZJib6vR5iP7BB9MuJN9brWuyVuwO1PXaR23ZuYa4Oj5pra5QuYMMj1IevM9ePFg1oYmaRMyFVF5/xhuLPSpV++8s7ZWGxbv1ezJuQtM0UZE06MfWT/3FUp4Fj+6b5KyDX7z31BcOVuUAQZBAIzBAxnVsIJHA5CjCenFEBBkNEh02BfTz311D+2ba4BAcXQoUONjbzmmmv0zDPPmJKjAAIIQB6Da3yVJ+AfqKjyBGw38YIT/J/yYkBVk+tKDcAumYjQjbAOueG9TkAM+Cz7aCchOwdp4ruJDVyHCI3+5FstHr1R+37N0hcP/qjxb83SUxe+qevr3a9hj3+jyBzPw6TwlWQjiTsQ2m0mrnyTOF32XHdVqOm+pxOER4bpqocu0FXPnVdg+Bbbwo86Rf+PP3pP9Sr7HnMQun/wyv3mnGDzeNFqg7CALyK+OZGY4nGScZHIld766DVd9mRPBQV7R3SvfuQinT+gm7k2+E0r/HLMd9xxh4kXEEG4vrzscFN34Li47sQCThBXmSGVpctp5Ks/+nRI+3cc0p/D87Kk3CuUv1uiSPbUtUXQzrTxJ4b3BM4LmWRK64lh3RFmCBnxOjGHHajlLiYj1vZmYFUA+p+POYodyS2qph8VjtIJT6CUgwfUE1AjXBUpq0ZhNAjK3T28riooTo1yHnfl06ivEBH2lb/jeKhLh2CjvlpkZ+fomds/1i8fL9f6xXtOqZGH/K2YsUd3XvC25k85tRQJxYtjsaScUhybiUMICIo7ro/G3afeNzdVm7MbKiQyS9HxIapaL15nXVBVd77ZXdfc1cOUoZD1Q6EFqJ9kpSm5xnmhPlKm1LWu9+sFWlzSvrnio6OMYWYYEUoqBhwlh3/pLZk+o6BY4AuYBknJxMMvD9Bj716niBjPj0RsmQg9/m4/XXRDRzNsDLGCkibUY47TTovkwbR9ubwgcNb5OMUAgKCBUSeQcaf2b1h00OPUxsIwfszJ+4p7ieuDIkZJtBOW+Lrro8W4+DId1N09D4lFPEEE4v7i+XQC9ZbggT4x55qOTlC5UJJKiGx/jK8vG6g4X576mcnmExS5Xl/+7xrQWmAXCUidGSUqDlBhAwFBAAG4B0SuMGEdgbOwXkEIjSvJdX6WslV3lTk2FrJZYARsxEfKUl3B+wgiIQD4bTJ92ALIOaWrTrx593806pHxWvrnWuW6+KaUpDStnrRFd7d/RpNGnyrOQjzYVzvYCL/JfhFzQNoPZSfo7RlPqe/TXdXxojYKjQ9SZJkwVW5YTmdd3Vg3D+mr2167Th07dTTbsmSPaiV8DTEBoiq9fIjN3dpU83kM7Nln1VfViqWNbybu4JwRyBNzQNzM2rDjfevFdUVYRJgGPnujXvrhYUWX90zEo0tH6t73B+iWl6/W8OHDTXxJzEFLG/6cDD77yPUlpiSW40UMamMOVwGd802MCRl0R/Q2zt6pjBTfZ6j8/jnLNuada84dhJysKeKKM/7lPcSI7pJJPAeeJod7C2JPyC73MXGFa1xlZ4NAvj0lIEpaq1RuMY45ih3JLUwhApA6TwoO2SZP02gB5aie/o6T4IEpbJgOBpiMpAUlPRAkHngnuFFQ6DDikBJIAgaOY3MSgVcf/FJLp21XUUhPzdSr947UsrkFyz4xArbpn4mNOAo7PZBz+OCDD2rJ0sU6mrlDyfFrNHLmc7r15a4aOuEp1WkVr9/G/2KMP9lVjgXHMnr0aI0dO1aDBg0yZTQQSG5uDHO35vV0ZTv3ZUzuUCUmTC1jM0yJMi/OH/uGKk3ZwvPPP29KF1avW6qwCN/6eSyqO4h3j75t1OOWaup6TS3Vb1VBlWrFqUHzaqpQJ0Jdr62ta59so24XtTTHiEBh+394CCG1lChzD9jsowV/s86HB9M6H4gn54cgBDLsLFu2mPrLEr+Oa/3yndq362RvNuXzOA9PwZC7ZwYnRGXD3wUGCqJK/w/HbfuNnc8ORNdOAHUFwQrPiScSXOzwL4zzJ8jh+to2C2CHn3nqKSeI5J51ZtURdnBEhZVaBhBASQZBHzbWXR9ZUWvfFvZ3W+7rOh/ECYiMU5RHxIYUY4OdIG7BN/A8I1rTMgNZJOZxln9+9OiXmjq86AFRLM33zsBhmvFDwffyvZBGQAYZkkrAynFCisgC8bv9mbuUXv+APp4/SHd8fqW+Wv6e2l7WTBP+Gp9vgyB17CPL/FC6zbJJJAWwRfgc1ic+t0sbXdXzZMxVFEpFBalD/dD8mAOfRLUYto8qLWKODz/8UGs3rjEE1B+UrRyv6FJ5Q8ba92mli1/qpM53NVOTrnVUqX5Z1WtVS1VblFf7AU107Xu9dO4NncwkZ64PPaP2OnKdOFfERZST22pCQFxnYw5iSRtzEANY3wuR4/5xxZSx/i2ls3fbAa1bcLLFiaQEMaa7KjFiW3dTmLmnPZUb+wJINdlj4g5EHdtv7Pw79zgxhbvZINxDPCclplUqt/jGHCWO5AJUMHeDcehr8GZtXHdAibDlQ57gjgTjoDA6zh5ObgTUJxvwkyElg4v6ZCcyj/3yV837w/vBQDid9574zmR/AY7FWRvPQ49BRB3kBenidxBUHB0PPMfP0C36LSB5GH+M76uvvmp+hwqHwWByGpPS7Ph93suNDIlrWzZY5zWooKAinhBKm88tn6Vzz8kbjMALooZIQN2/VQYpu+l6ztlKD/cv49iya96UbIujiUfV+uz6+uiHxzX0jyfVe2BDXXFvW6UG79eBA/s1bNgwQ1TpY3aCfhgUXjL9/Mx1cgdUKOt8CHxwPJSTMdgC528Vf64/5+vgPt97VCyOHDy5vh2N/QQQ7oZCeIJd0uqfAgIR5fhcQxR8pxAAUPf5PqcRLInr2P2dIRC+gFH+3M9UJRAoERQi9NnJhyx35iw94u9UlLBcGvaTe5chEAyFCCCAADwDu+9uuIrrsCRX2AylO0BeEKU9wWbMyGw5QbUR5cLOwYL8Dn9u/RbbhURiCyCfxBzjvp2g8Z94XzXF979/zxdKS85rRSGOgKg5s3qUH7JtSKqNOSA6+FiETURWyqghnBwvgig+7OWXXzb2h/fib4kPWI4IEgixIs4iC41ta1Y9TBd2qKLgoMJ9WZWy4epSL0vdzu5YIOZApIaQ2f1GtECwTS/r3XKFrmjZu3GBc0Dc2P781np/4iANX/6uLn2pqy5/rodUMU3Hk44ZG01cQSLC9d7BPnOuEA883Qu0LNmYAx9MbyMxB+eVe4+4FxCPQHp3b/V/uUfWAbaAWL744otGiHCNI3xdwspfQIQ4birVuM9cB1vxbFFRwL3kuo8lqVUqtxjHHMWS5BbF8CkzdVeyXNRnPWW8MKaoQjgJTyiMLPAA0sNpnQ7GnAfLDsnCOdoR6ZSeYmD/+t73DNvBvYlaMHWtx95i1BScHI4FgoXBw5ngbDD0GEhb4sJ5oL+BG499RBGDlHMOKPPA6GLkuGkpu0ZV4/v4efA9/fV094bqUaesSkWcLC2PDAtVg7ggXVApVz+9cJca169nyBDnwd0axOwj5UOommed6/vac1ExEerSp5kpB8fQ4yScyzhwL6A22xJfBoJh9BAbnOo6fUtWleT62MmVRYkekD0MMIoq2+Bc4sAZZGXLxMLC/F/ly+4j26JkzjpnZ+kvUy5xgp7ANS9q4XV/B0UQ8HC8EHwLggoCQjtswAmeAadaXazxLyzKToD59ttvm+wEDp3gkGfeil/0JTmz5zzvBJuUtyPO3X///cb5uBv9H0AAAZwEttxdxsi5rqs74GudS/FZsC18TWFZYGAn9LsCQZrf21UciC3sXAmAaG39HrYB8vjb0Mk+25qU46maMnaux95M4gqyeoi7kC/szxNPPGFiLcg5ZBz/Q1yCPyaDYwci0hsLUaPckZgFv8acEyrf8KnsM74YsvrsA/30yDVN1KN1BZWJPRnDhYWGqG7lcLWrmaqfPr5PrVs2NcdOPOZ6HrF7xByQSzKlLXs3VJCPw6Noj7rw1u4m5sAvI2Y7CR8ZaPabfeZnkggcI/7SGXvSAoU/5xriM8nqkqX1tCqHhS1pHjBggDlvxDNcFyriOP+IyVHR/mWogR0cZu9PjgHxwrnKA9e2sGUBucbEJf8keIYoYWbbxBxOgYdKPGJf+nRdS5tL1LTl3OIZcxS7dXJd10pzB0prKal1gl5JW7rrDgTiZDNd4Tq6H2PoTqXi8xheT8DpkLG1a8BaQBSdI7c5vp9/GKdD2/3rgftj7HxVrhdtMrncPDgHHmwcDceC8osBxJDjfDGmZJE5LsglhgLjjCqLwaCU9PHHH8/fPkYZZ8T5RZ2xx+KaJY8LD9G59crp/r5dlXg8SQ0bNVZ4SJB5CF7+7jtzDjHgrLnGNiGW3Pw4GX7PPkEsCQLeeustPf/qc/o8brzGj5rv9bm46/lL1KxFE/NCLWJiId/rSqohemT/IVk4UR5MjsVeZwg3jtUCx0w59eDBg42R9LRurNPxfP3116YUG6cAcWd/uDbhMUGSH4IxuxZbOtw4MtRv9glgTMisE1QQAPD3wtYdw/hzfK59Wf8EeN54cZzsD46aa8r+4RgRFRBF7NJG3G8lYR07f1RSf1RVcO+995qXO7hbboH7gT6wAAIIIA922ZXCgP1FAHbGB05xtKi1cZ3AN0COEY2JFyCB7tpQeJ+zPcoVZG/x72RUEBYtENV5zu1+cnzff/u9jqz1T+yc8MVUte3b3FSrQSCx98QxxBz4H+zMTTfdZGIPKuL4HTEI54rYBKEZokGMhqDNZ1944YX87UNaOA9kDPEbthwaodnpe2MiQ9WxaVk9NrCvlq9YqbZt2ysqMsysYfzikCHmPRwzrTPEL6yvSgbVthFButke+0R/7hPPPaoJlWZoxAs/eH0uBrxwpVqc1Uwt1MzcD5BLroHrZGtbLkvCAz9IAoEY0woWxCFOn0wiggwYJdvEZpDVwsB9B3nmXBLvcA/wOWKboEj/M5dRZcLNdri3bRIFXw1BQaBmv4g9XcUOJyhzJlHiugTVPwFIEy8EAe4b7nPiCs4H152kCvto5/Kw7zxb7LOnvtHigNxiHHOElsRyZet0IJWQF8BDjoH0BAyC69/t6H4eDgDxQQ1zN10Z1dEdSXaCbBsPNwabjCLlzZAAG+Rj9GnkP/OMjvou0/OaYIVh5ZKNevXVefm9HfZBxuGROaPfBBWTkmkcD8beniPUL7KNkCZKlDFajNm3BoD9hazjiDDcKDQ4WhwDRtzZz0yvA+cNY0IJQuuWZxiyikoDkeH7Mdx8Pjw8Qk88/pTqN6hb4BpwPujHIYvOda96RrBadKmqVbMLVwGZaNj1igbKjDpoHioeIowc34mT4/vZNqU8lGtzfAgAGD++hwwtpS/sO8YbR+Qa5OCk+Bvb5ZohcHC/IXY4M5S2VJ2/oW4hGqBm8R3s16PbX9eRBPdLOxSGM7s20oo1S8yxUMblBEMhOG6OiWvPOfbkUDi2opa/+LvgvEO42SccP/cm30vwwb2BKMX9CfgbjsiWiycnpWr35v1KT81QdFyU6jSpatTyAAIIIID/pZgDMRN7TAYDEDsUJnwjNLsuF4i/gChCwACi8KhRo3TnnXee8nkynojDhQGxmKo2/BV+HoEV4uPskcN/dT6rq8YknlwWxhdsWbXT+CCqiGymGN9OSTHngBkXtuSY6b6IzfgDgL+E4OFfmfMBQeb/tE1BZiHKCLdkDfEdZHzIFEKUiLmcKwngx/E1iPfJJ5IUEx2hIUOGmHPHcRN/QYA4b/Gl4vXEo0+qboM6pkzY6d853xwLPiq2cZA6XNNC879dVeR56HBtC8U2CcrvQcTXcwwI2xwTMQWxEr4YIdcOQUXoZd8ZokQsSFzCMbpWHbKP+HbiLysQQzYRB1wHPtL3iv+HGBPj8D6EZrL3z+19RXtWuV/CsjA0aF1bB1P26rd3fzL9y673PlWAxJDEgZ7m4tjj+L8GcSovnjHuQY6be5KYlMQS4oYVS4jrSbTYOD8tJV071u5W2ok0RcVFqXbzGgqPKPr5D+D/D0osycXYUVKLEyhq+IOnmnzX0f0YyZdeeukUkutLXyNOD2NHCQpKE8bUgt/zfdvWul+c2xuEBoeZY7bZYQwKGTSUUjM+vmxZQyIwxAyeQjHE0EJ8KesgY5kbFKyFm/foRGwl1W53jl7/z1Bdcd45xnBBQin7wAmzrxBdVDNEBIyvHZKBSm3VMs4PhBnCxfFizI8fPaGZv6/Wh7P+UEpiHilcHbxJh1eP1oXXd9QZ7esZhRVHAUnDWNHvmZ39k7r2aa2vP5moY3uzleMY8x8aFqLWXevq+nv6qNEZNczvUB3JMmN8MXKodtwbOFy2yfHjEDB43Fc4VIQHAgEcIv0BkGwL9oVtobTjZHFUOK0333zTlMmjYCIS2DJ03gOZw9DapaE4Tzh9rvc5F7fU5vmzlJHm/eLXgHWL04IPmuPAQKP6OrMGXHN+b0vQC1NNeTZ4RpwT7v5p2EERPL/cizhw9pn7iXPDPuLc2RfuoT9+mqJN8/Zr2k+LlJZysqqhXOV4nd+vk/r076LyVf7ZZZH+NfhTDvTPtU4HEEAA/wcxB/YLf2JJrqdSYgt3Nte2sVgiAHkobAK+N4QBnwtxRkyEbDnnTeC/CfLTjhQkSb6ApXYu6XuJLu6bV+3EMWPrqRCCXECy8JuIvJQjMuwJ/2lngeBfQ0PDtHx9go5nl1b9lt01bORP6nv+fuOH8XHELJT0UmlGqwskBdKGvyYDy3nAh+BbAecVosz3ELeZMuRZ8zTj+wVa9NtqpRzIMNdnbfABHZyeoYsG9tRZvVqY62fjOa4F8Rrb7nJRe33x8tc6vjVd2VknfXVIaLAadaqjm565Ri275mXLSQDg+xGz+X72EVKOgEs2m1Jf4iUqrCDkJD0gt+wzxIyYw9mnzTaIOTiHxGkcPxl8xAK2C9m1hJhzQjzDOSVry7m3SR9iAc5D+wtaac1vO5V8xDdx/eI7eqps2VjzfQgjzowoQHAgCcT5g1QXBmIxRAvX5TL/afBM8pwR7yIEcA2IjRGjbJsX4Fh+HTtOexYe1qSRM3Ui8WRVQ6lycTr/pnN08Z29VKVuwTVgTxvkFt+Yo1iS3MImJFtQSmFH6UOwPA13AK5L9wAMMUbIWSbkyaHYQQjeAgNEOQ4Giownn+UhxFhTvlSqtP89kkEhOQUWTAdkYDGmlgSRnaUXFxIE2cYYk9U9cOyEPhg3Wz/M2abjk52Du+K0Z+42RR3ZoYS9+3TpJX2NI8NA4czIDjOAAONKbwbnDKNLdpeMNcdHaS/qn+kF/m6+di/LVUZawbLh3Bxp5oQV5lWzYXmVbnpczVs2NuSRa055EueM7R1O26FSUeVVPra6jh45rk1b1uu2+/pp5pyp+QQXcC4wauwLDot9xbli8HAoKMmIHDgaAgB6jL/44guTWeT/EFbuBYg5SjgBDKVfts+K47FLCaFCcx1xKKioqLl26Aj7wffaa4NTQ2Vmf25/sow+fvFnr68xa/jWbV5RK1Yk5GdJMdg4SQIae59C0tknnL85v7m5WjpjvZbOWGd6qSKiwtWwVS216tzaKOSuz8D/BQgWEYkQTCD5kG++FzWaeweRZcmELRrx5ji3RvbwvmP6+t0/9NNnU/TU0FvV7lzv1z/+3wHXx1c1+98Z5BFAAAH4R3LxGQxYAgTRhU1FRuR0LTXGf+LnLDGxwG67tknhX1zfVxggm5TOQirtACOIGCSaKq0jOrl2rq8IiwxVRGTBHkyIORVC+CAAMWO9VwROfDgVY7feequSUjL0xY/z9PPk7Tqc6FwKJ1b7J+xQRMYe7UnYr57nnpNP5BC7KdtlPU0yvfhmsq7EGhBBxHRiqfvuu0+vv/668dGTv52p7ROPKjUp7ZSYY/7vy8yrSoOKqtozWrUaVTefx8cj4HPOuJaHMhMUnBmqqrG1lJR4QivXrNCtD92oBcvn5RNcwL4QF/G9/fv318cff2yOl5iDe4R4jH0l5qCCkGE9ZLERG7h/eB/nD1GAEmb8OwKFzVpzvCQYePF5qgOJVdku77VZcs4N95StMGQKN3EYPZMPflhBr97wH6+JTJP29dXxktaaOXumiXXYF+JqYiSIo7037dBJZxn+6tnrNW/8EiUdOWFijjotaqrLFW3zM6z/17B90MSAkHD2jZiSvmDuS4STZePX6uO7x7hdG/n44SR9/844/fLRH3rk8zt17vWeh9f+7yKo2MYcxZLkejNamhsbsoWi5Gm4gwXvcZbvoMRBPjGmroAoOsugAQ+LLw6H7J4tXYYQ2V4V1poFtRtVVuUaZQssEeMtSlULMtu3g6dQsVD36H0FTC1DtYLI4STYbxS1974co1+3Jinxv5MSXbFpH/sSp8Rd6YqdPlPndjvbKJR8HtKJoIAhwWmSAbdDFSCWOBpTQpScrOCkcto6r+h+450bDynxcISefvpy4/i5RmSHraHnfGG8+X3fC87Wnj11tWjpPLdZSbuQPISVQRgAdRjFFIUUosU1JSsL6STDS9absiZKWOxneC8KLMdsSS7BD84ch2XXpuNzlJk57wmcJiSdbeEcINeffPKJcaLnX3O2Jk+arg1zip60DLl98v3rNX7Cb/nXFAeD+s93o7ByL3N/4vBvuOGGvL6g3eH6Zdg07dl64NR7pmysGnSopNYt2xgn9G+AQATnQtk2FQ0IBxD0Z24frGW/F73EANndl28eqpe/vketuni/bNX/BIqxqhpAACU15gD4EmIHSCgCsifgI5ytOfgs/IMtmXSCKiMIgTNGgVzga70FPt76HrJv+B38IeQJlK1cWo3OqqsNi92vK1oY4utGmIwrWVDIHYSc1hR8IEDcpkoM8nPbbbcZIoTP/PTzMZq8Kk0Hjpxwu92deyHeMUpcnKSI6EXGp5OpRSimbJeZI/hpkgacH8Rq+napZEN0x8cQH8RnVtSGn/cr578rT3jC3k0HdHR/uB5Y+IDx72RNuU42DiT2w09BWC+4vKc6Hm1tzidxpmvftO3jZp/tGshkQN9//32TFIFwEquwfyQcqDbDn0NKEeUhYYA4gVJr4lc7dwOBHN/O/nBfEq9yvsnQ2xgSsK+cI44FERwSzFKVZNgvvPxCtRnXQMu+25S/HqonVK5fTi9+/5AmT51cICYmjiS2JuawyQdiJGJMSHvUsXh99/Zv2rpy5ynbHPLYKDXsWksdzuqouDIFkzL/V0BY4F4hTuJetFOpX7lnsGYPW1bk5zMzsvTmgI8VGh6qble5XxLnfxa5xTfmCC6Jg6csMIQoN4URUDv23gkUOHd9twDSwBAhC1+XYOH99MhQTgrRxShDwpyLxWP8zr7I8+LxnoCY9tJ79xujSmYOxY7jRy3D2FGeDNl65JFHjAOw52VvUpp+2JjokeA6sfN4hibvz9Ha9RtM5g0CjQKJgbMTrTHwOE8MMVPSMLL0osSEltPHL/7i9fEcP5yu9578Lr9PyVX1w1mSTUYkgNQRYECInRN6uV/oCcKpIipwXng//cEYPcqnUIUx3jh/HAPBAMeC4o1Dsso3x4RTxaFx3QhkcEaorxhNtodye/fddxsl3zltk2s67rdp+vn72Tp6MEx1a52lMqXLmXuZz5euk6H7Xu+rlh3dD0erVru8bnvqIjXqHqmPP/3I3DOouM77D8dpHSVlaFwHAoIDS6SPn/rWLcE15/nICZM9feLKD3TiWMGpk//XwClThsa+/jjmNy2fsMOnZbPeuucr8+9phX9hzboAAgjg3485qPSBRBQ2XdZdmTLCsKeYA5+D/3NFUZOXncD/I+zi5/CDzIlwHZjYo79/gfvDg+8y8QuEkFkexBzENlQ1MaARUgbRJc6y2esjx9P0x7JkjwTXiYPHMjVpRZp27EowftcOEUXw5ljMew4eNBVBkHnEa64ZVVTVytfQW7d8ViTBtUg7nqFX+3+Uf01c57Q41yHmuGxfp12mB5CJ/fbbbw35ZP/w0wjnlBdz7amaI6NKGxMxBXEH1wIiynUhi2sn0JKhRQxGkCDG4BxzXJwHuzIFYgKzTiDEzlVF2I8Zf83TmE9/U9reMFWNa6CIsCgTJ9F3HF4rW/cOu8GULzPHxBUVqpfTgBeu0Jm31tOob0aYc0w85Iw5iCOJOUhAkGHm+EgopK0O0hs3/sctwQVUki0fv14PdHlOhxJ8T+b8HRAnEXMQO/449mfN/8r7+Tcc+9u3fqrkfzlO+tvILb4xR7HM5HrrcChRRlWCeHgChMg5xQ5iQgkoRsUdMGzOJVfsOnWobd7AOWYfA8b3YNjYV5wW5IWSnhrNSym+bIyOHfG+dLl+qwqqUZcJcZWNM/nss8+M6kh2koeTfWciMsYPVdAOPnj9h2lKTi9YOlwYlmzZo/NbN9LlfTqaKYQQdl4cBw4GcM45HgwjSiUG8I0nh3rtbCwWTlun78b8ovMuOFkS4wRlRBBXVGTOJdeB/eA8cswonXyO0h72h/+jYnN+CETsGoOQLcqb2A4ZRdurRKYRB41AYEvS+U5ekHxKvlBZb7nllvx9splVnM63336nXdvTtXLJIe3dE6aVC06WZI38fJHOPa+pxk/8VY88eo969jxbfa7sojFf/aAYVVayKSkOU72m1dS6cwOz3c2bq5nMJ2XVkFkCCkBZGA6X9+AEyUx/+eWXWj/1gLYv8W7IxIal2/XyLUP1+vf3+xRA/RMgSJo5loXsffvc0QPHNWfCcnW75EydNmBqoa+TC/2cdBhAAAH8ezEHsQNLxLFWpCdAgp1r5+KPyCp5asOCEDuJBRk5srie1mp3BTEK+4VNx4fxL/4BIog/tHMSYmqHq3LtCtq33fuZINWaVdCZ3fMy1rfffrsp/4SQU6ILASJWwv+z/xBEjhVb/9GYmTp63Pue0M07D2pdQj3ddkVfE3NAcMkeks1k+5Arvh+/DKF89913jW9+7rbXTmmLKgpks78Z+oM69+ngdk4FJcecO4QDiBLZSzvM0mZvIdvEBMQkdpkUxHP2k1gJUAnHe/DhXE+IK9l//DpxKX+z1QCQYV4QYarwuB+J5ZwxEZlVYjqGiR7emq7lU7drz4ajWq5F+e/5/t1Z6n7pWZq8fJyuHXC5LrruPF10/XkaO/xbRaeWMYI3Q5ZqNa2mtr1bKSQk2PQ/k4HmvLN9iDvHyv7bYZ78S0zFbJLtM/dp1e95y0AVhV3rE/TMRW/owzmv/GtVZBZmMNq3K3wWydOS0/XXyBm67D7PQ+X+55BbfGOOEk1ybYaWshN3I/hd18Z1ju4vDDzUVo2lNLioJWQsbG8kShLGn5IjDB7KINPyIJ7sD4quMY6V6unpAUOVmlz09NsqdeL14qcD8wceQc4wxKhsOALI3/XXX2+y1KZE9vzzTb9mozM7aOnWPfIV381ZoSs6NDNGmJIbiCBOB8KHA8KwM9kPZ4NT7dnjPH3+VN56er6A49m46JCu6V/WZGNRMnHuEFvn0g44bVR0+ltQTHGoOBVKx1AuLWmD/NpBTLbc14JzzvnHYOOoOV9cZ1Raym+4TjgSKgQoLeP/9JCSiaW/lmFcdlI2SNizTxN/26Nd290LFUnHU/XLD0sUEtpGWzYeFrPC6P89u0c7j5O67fJGEHkco30ffdVW1SarzX1520136vZOg3w63yvnbtLiqWvVrue/2+vK9OQp3xdcyN1bTBg56/QiuQEEEECxjDmICchkQQycLU1OONun8EdkJp3DDd2BKiFiEz5HywwxgjcklziDzCBiLscB2cJn2aVrEHfZHzvxvtEvzfTYea8q8YDn6bgW5WuW0bNf3298NLEEPgh/S6YS8gdRYykRMqIQN0gafqtS1Vqaudg7EuTEuKmrdMtlHYyYi5+mZxXCSbKA3lXON3EIk565Dh3ad9A7q0fIHyz8ZbWuHXilOWdcH/Yfn2/7owFxBNflrrvuMplR24vLtaeCyiZKiCEQJog5yN66A0kOrgeVgojvlF9/8MEHJgnBtcPnE4eYpMTrrxtfTxsS77drkIL9+w5ozjebtWWJe6Ei9US6Joyeo6CQKkpYl3eNuT8atKiXL/i7gutI5pOMNLGPHTbFRGhLeO0Sm7fdcrvubfWMT+d664odmvr1bPW5NW8I1L8F9nvCsCl+fXb8kEmnF8ktxgguyQ4HQkA5KcqpO2Bw7Rqinkpi3YEsHVk8J8nyZsohWVxILUYP1Y4eCkgRBBSjjdGgh9Uax8atauqdb+9W3SaFTMYNCVLjtpV07o11NW/BHONQbA8IDobeVcpaOC5IH+U3GCrOIUb77TEnF/H2BZv3HtYTr71j9hUHTZkShJf+ZF4YaByQNcAbVuxSVoZ/67NtWLbbGFOuI87Trk3LuaLPhRdDLAgCuKaU7uB0EDcY8GHXCDx6NFHrV2/R7i0H1andOR6nalPCzjni++wUYI6HEinKgSjBYrv2OpG1tmu8cl8gXvzww4/64et1HgmuE9lZQfr1+62aMmmhCRQ8EVyuF46I3izKxJ3r/ULq7TAKRA32/bNXxyg7y/dzPv6rmfq3sW/nIZO59gdb1+zW6QRiJH9eAQQQwP92zAEZwkYjwroDw4DsPIeiypSdQHBlYKQT3rRKUZGEn+S9ZFkRdvFpVBnhv/BjlvSCmo2q6v3pL6hZx7wYwh0oba3Xvrp6P9lOG7asM8I5BI7voBUKn89QQUqWyZZxfPg0Xvittz79Xtk+VnSBQ4nJevqV/xjijk8m5uBfSD+CPpVrxFN2Obqd6xOUklh0C5Y7bFu225w7u/wSfbLEHMQanE9eVFPZyjDIJlVgCP4QVDvEkZLlWZPnKjHhhDq26eK2kg0BngQLGW6ILNcFMZ2ZHcQcbJ/zCsm0WX2+n+OEgBPf8TcqvH78YLZHgutEbrY0dcQ6fT98grkmdliVKxDd2Qf+TmxFhtqC2JJ4g+tL/EGM9vU7Pyg1yfclCcd99pf+bTAI68BO35dSAjvX7VGGD9WP/7+RW4xjjmKXyYUMeioldgXZPYwBA5Cc68ZaYDxszwX9I87R/YUB1Y2lhCA2znXaCgPj7CFDbJ9GfZQxlFhKayDa/I3sm53Wa1GncVV9PO4hTfptjn78cpqCMqOUkZalmFKRKlMtVKVr5WjZqkWKL9PYGGCMIIbSlj9TsjpixIj8Rdn5PQ4bg0rv6INf5WX//EFcpeoFFGicN/+HrEP2nKqlN9loT8hIzyvxQTUtDDhVHBOOByfDdafvOPHwCf3xzXz9OHyakhMZehWnW3u8aYZ7XXBdB51/VTuVKhOTb7gJUDDsdq03yDPnju/H2aHW8ju2z7VEWSa4YeAF5JJrmnQ0WquWe58hz8zI1rCPZ+j6WwtO3LTAsaMc2/uNwIQScO4jV5BF530/vuJfZnTJtLVKPJSk0uXj/A4KERjIUjj/5YXTd4d9W4seuuUJaamnj7Mp7kMgAgigJA+esn4eUZReWldQZWXXxuVniJM3S7eRpYRA0X5kSVxRIKtK/EMcgD/mZ8gUojqVbUw7hrRY8mtjnyp1Kurdqc9p1bx1eu/xIYrIiFHqiTTFlIpSfO1oVWwZqzVbVikkItjETJwbiBJ+kJ9Z254sI2QM4kNcAvCpkLVH3/hW/iIkqnSB9jOq4vD7xDR8pzMecZ2k7Asy07NNDOEUJNyB99CfS4UZP5MpJ06g5/SvUTP19Tu/6Pi+PKH7jj+fVrkqZdTnlnN0wS3dVa5qXtUXJdb08CLG2/Vu8ZXEpJR8c4xkqIkBiDeIERHhiW9JLBBvsQ85xyK1ePIGr48Rwv3du9N0zQsd3LYnsS+UYtMTDCCzZJvdZaMRNriXJ74+T/5g09Jt2r5ml2o3O7kyhi9gXwuLOWxCwxnfJx3yfxUTkJ6Sfvqsn5tbfGOOYkdygTdElJucsg8URgy57T+xcGbxICgYfW8nJNvvx+l4s+wK78NRQqDov0DphYyhftEzjJMBlHxQckt/jCspr9usstpfUi2/pxajRv9wTHw5c4w4MJwlPRMcG06RHgqUNkqceGHI6BeidwWwP8kp/jfQh4ZHnJJpxIGzPBLGkNJhjDRlvGkZ/mXpQIWKZY1KyYAFK3B4ugdwqKjICAeco4SNSRr25ByluyFCTK/+8q0JGvvxFDOxmKV5yILiTHDQlByhnlPShfPk/JGlJUigNJtJkbafCZXz8ccfN/uIM//p620+H+fhg+lasnCTLs5bbrAAuF+sswHcy+yDnaLtBNlgiO6hvf6po6w9PP7nP1ShpvuJ5DaD4OkacI3oL+OFw+fe417j/2QM3H0uYdsBfTPo5PAOXxBbqnDx438Oxbg/JoAASurgKVvZhZ3j/XYCrhO2zYmSVrtOrC+A5FoRvLA4iOCeuINMKhlGSoXxh7RE4ZfpscSOUxkFSYQEu64mUadFDTW/rKZ5P8eGgAuZDQ0NMceF0IofQgyGaBFrfPTRR0ZgtVN+bcxhxVjirJRU/wXvXBc7SCktWU8GSdqlEelZHTBggLJy/Rc/4+JjDUFHqLDiuqfzTbUgq0sQcyCGb16yQ6PvmagTR08lUYf3HtXoV3/Wt4PH6aHPbtO513U254RWLMA2yEjTimSr+iDQnHsSFGSPuYe4pojxjz76qCkPJ+aYOXKTz8d54mi6Zv3O6hsn1062IFZlHyzs+sc2IeRugOuh3f4PkZr42yTV3u2+xL+o+IPzxHWyMQf3NcSbn4k53JF4hJsh8k9wCQ4OUkx80UuZ/s8gt/jGHMWS5HoDDLpt8G/UuLG+/GWiKtbIK02uGB+r3CMJhqAWNrq/MKCu2R7booBRgJBQ+oIzwAHiUOyDh9KEo4AQ4hwweLyXAUhO8B6ydzhJDCtGjwEPOEpKsykp4bghWoyKR+Uj40hm0WYlKVPCEbE/ICir6OV8POHMM5qdYnwoE8ZpIhhQYoXaiCGuV7uhwsJDzRh2X9G0TW1deWWeiki2tCiRg3OLcLBmwU7tWhSknOzCJSmyzIPu+kovDrlZCcc25g/IwOFwTeyC4VZ1JVNuh3/ws5m49/bbZsAXwUBGerg2bdgvf5CeUi5/OIcFpJrvdTXUfD/kmgoA2xMDKF0yi9jLf3Bv1WlatMP5u6DCgOPjOSxTOUZH/6t6+4K2PX2fRP7/E0G5eS9fPxNAAAH875Yrk5m1y/xAKr/5ZYqq12lsRMNy8dGKj0gzw3nwF8QEiL++AHGcTLHrxF93gKCRWWPoFCSJGAMSakViyC4+DBLMz3ZSsZPU2GQBMQeATPL69NNPjYgKybJLIXIsiMtkPvkOxFdIPr6aJAKDuGxCICjX/5ijWZOCWWxiJQRgsqD4bVrAIPiPPfaYalSrqbiyMUryYXinRdMODcwxMcSJzKU9b67rFVtQ4UXp+cpZ67Tnz+Qih10RBzH1me2lxh01+09sSHUf5Mxm+4GtKrM9sZRDI8SzTNLQoUNNzBGSG6GlMzfKH4QcK2NiYGdVIlUAnE9bxm7BvhFzcO8wLM2CzzNMbVjQd/IX3N9n9vK8tvQ/Be5LnguSRdWaVdSeNe5XnSgMZ53f6l8fzvl3EFSMY47Qkqy+pmblaPi0+fp22QEdMeWyJ4cdxIWHqF9SkMok79clXvTEuIK+V+dSNZ5glUaUU8qbKRFynaKIo7H9w/b/GG/rNFFPeSghMyx5Y40s6pkdrEQJC0YWI8hgAjK6lJfwHggT2TQcHcaa7eP46NNNL11Nz38z2efjD1GuYtIT840+vSGAfSTbzO8hL5QwkVGHVK+d8au2rvBd6bvo+k5mGzh3Mro4sqLQomlLffnMfNN74g3oXX39gdE66+o4ZWalm2nKDNPg/Lk6NoZAUI5my7PtsClUTjLo0yevkb9ITsoxaj2OjWPmmjFEDNXcHQgyKHVCpCE7AEHmXsEAR5UOV/o+39Vseq7KVvK8rvTfAfc1DtH29kDOuQ8RbjITojXk+byqBl9w8U0FxaD/eRTj0qEAAiipJJd+28joWI0Zv0g//JWgfYdYHufkEipREcG6rFcbVVmz0ZAibyrSnEB0JWNYFIgl8LssdUimlbYk17Jbu56vXTGA2ATbzPRefAp+BFLFfA0GSNqAHgLJ7yFAZC3xNQjz9I8Sp0AMIUDER/Y7ETAZ5gjxRYAuW7WxHnj9R/mKIOWqTERqfjYcsgJRYRYGQ6jw0+wbAgNxE3HPnjmJWv2n72v/XnzHueY7KOOmLQmiS1YQf+ypbapjh076+IZvlO1DlfR7d32htvfUUXCkzCwREhKca9fKQxIYJC74OzEHIrTZz4svNvuUsOmocnP8cxJH9p4wWX872IzzS8WapzgLsYKyaa478RHCC5lm9jkkxn/iV6FG3jrA/zS4R7hPuV8A8RqxGs901PF4vXb9hz5vs+9dp7Y//k8jt/jGHCWS5JKtjCxTUf3e/Vp7DrufEpiUka0hExeoXGyk2nVJVT0P4/s9gQe6KCeF08ORYHgxWA899JDb96GWOZclsg4NYgyBsUsaoarS82GB6ocyjGNhijFZThwL5JKsoi1rsZMcMZCobZBsDCnb6tG5i14NylF6rm/GqWZElnZs2aztmzflq8IokThEyCH7hqODaGNk6Clp2a2ZzyS3ZYd6qtWwcv6abBh3ymjsAAZP1+CH4VOUm+1bEJFyIl2NqvRU4/YVjUHE6VMKjHO2KjT3Fs4cwo3hdAoWXCeEhvIVaspfZGZmm21TPoaT4VhdJ29yXREVUFTtMkmUaeHw2F+cHmXbiRukEW/kqfC+oE7LSoov988s0G6mYxH2thgAAQAASURBVG/caEQVrhX7imLMtXRFr2s6aPQ745V8zPsooUXHBmrQ0v/zHUAAAQTwd0ku64QGhUXrjhe+McvduENqeo6+Hr9YMVGhatystcr5GNOTEXVO73cHbD/+CVsLaWGlAXegtJT4xJX4MhATIRlSRSxh23EsbAk01WLEJ3agJUsHUiYMiCvsftolFskAQjzZPhnlmPAcJWf4FnOUjkxT0tH9ZsYI4ij+j5gDcggpJ9Yiw4wfJLvJ3JTG3Wtp7aTtPi1dyPI5rc5plh+bsb+cEyrmIPmeSO7Id79Rto9dWVkZWaqsOrrirt6m/9WK6FTkIYQAjpHYjRiE9zhjDq4FmfaqZerLX5BVJl6gUo7raoeVufpxzjfn2DXm4PpyXthG7p5wvTtwiM/7ULlhedVs/M9VjrGvDM2ySzqxj8Sprjj7ivYq/2QZHdrl/UyQ2s2qq22fVv/Yvgbw91AiSe68Jcs1cvVhJRwtegz+4RNpuvPTnzT6oWtVqbR3g3Yw/JBOk33y4ADJqr3xxhumpwPCRGmpExgFiCBZOrKfEEMeSMo3eUAxIjgQnGd2SrhWz92plK1ltWZqoqrULKeel59lSBglzSi3bAcjTAkLWUZ3Q7ogyRhIjBT7h0r74Qfvq2/rZvp+qfc9pMHK0e29Oykj8aAxHDhTyoMpqSWLDEnjuDGWlNZgpCkf4v/9H+il0R+curC9O0THhemhNwuWdNHbCbGnNAo1zt1AEKNEzvJv4u6kH5bospseNvsKcKaQXK4DggHn2PYX2aWfbAm1Jdyl/kaPaERksLmf7DAKhoxwbzgDEgQKfk/ftv1O/s91ZVomfd3g/H6dNPrt332esNy8m3/DHyzYV0rZ7BANlHVvJojOmT9LNw/qoy+enuDVoLJqdSvq6aG36rRDMe6PCSCA4gZTDlrEcKhp02fpx7lHtGVX0dNak1Oz9PCbP2noS9epdjXvmK7tQ0QcpE2KdilXUB3DHA4ICnGEHfjkJMDEHLzwZwioEDbiE4RIjpEsLmLtsb3J2r3wkDJXR2lVzg5VqF5WvfqfrcXpC0w1GeXWfAclq8zgQGR3B7t8ESDOIe6BHPW78BwN+3m5V8f+3zOggdeco5yUA4bIsv9Ur5FNhGwTCzCzAoKNyE8MxbwTMt93vdtfHz9QcDK1J4RHh+qJr+4s8DuSBIjrEHTIujuyBJZN8H7okxOzvl2k2wf1y5/ITYxmByex4gfX2sYcxD7ffPONyTDbuJOKr8gY/wcgRcaEmzgCck3MQTUaE6ttO56NMYhhId72WaBqkOuLv7fLZfXo10WfPPyV0k741nd9xgWN9HdARpk4zdnbjDhRVCJq7ry56v/WJRp+3486dujk5GhPKFuljAb9+sRpVapc3GOO0JLokKZuO+IVwbU4cOyEPp4wT4P6eVeCQBkxqtq+9GDd+MYXCosrrSNHj2rCrl/V64z6ykzYrA3r15msKYYYIoqi6Rz5j3Oh5AfDgrGitxPCDEFhaAJYPGO9fv9snll+x2LH6iXm3zEfTlKzdrXUqmm6MYQ4nn79+hmyaR9ASIY1SHbSHKofDz7lwzgzyDGlKVurltKShKLPWVhIsKolbtG5He8xBJPyJpRejD/Hy7AmjhUlEvL9zDPP5E+ZxFDjKC4f2Fk/fz630PKa6nUr6MkPr9PUmRONuug0KjhWvo9z5joAAfw5YZKOH/JvuMX2Dfvy+4b5TgIDFEGuHcfhOuwAJZMR/tYJoVavXr1WcXGRZh1cU/LBR7wtTQs5ZPp7IYZsl9JveqtcB5i4AofDvcb+osIzfAqjf+EtXfTbUO+XBGrTrYlqn1HJpynmvBcijsoPyADYciBvgGPivuAziAqNmjTSy7cN0YGdntXV1l0b6/GPb/J7AvT/VxTj0qEAAiiJmLf2sLbsyrN/3iApOV0fjp6hd584dTq+O1ASivAZXaaG7h80SnFlq+jwkaP6a/lP6ta2voJSdmnjhvXG9kNe3cUckCEIIoQN3w0BhEzRGmOF2tVzNmjEyz9o5az1+Z9LWJbXlvXNW+NU78waalS1uYmB8O0MPWKasjuxmVgM4o1fYj/wUcQo+AlKnTs1Lau5a4uu7AoOClLlsD3qfGYjlS/f2fh925IDKcffUCkEuSWLTcWc9cdUuUHc7njnOg174lvlFCL4lq9WVs9/e7/mr5yjGo2qFjgmxHUy1uw3ywW5gljnwGb/hi4dSjiqQ3uO5osYkEbiMmI55po4BRauERVelAsTF/F/2txmTJ+hyjXLae+OQ/kxh7fl8LFVc81yTMSEdsUGWuyIDwuDnQlCrMf9g4jBLJkrHr9AY57/2evjb9S2ns664Iz8uTTegHuLc04CxRxDbKy5r117iD3BLuNJbFWza021bN1KL175tnas9pwcadKhgZ75+gFVqnWqwPQ/j9ziG3OUOJI7dcYsrTrg+6CBics26NFLu6pUdNEPyfyNu/T61PVKSPzv9xzOq1HZdWyrpq/eqpiwYLUuHaUyBw8a1ZJgH4PsHCYAeKhtKRClvTgoq4hN+Ga+Pn7+JzO0wh34/ar52/XgFR+o/eWVzXZwVkyVcz7IGAOcGeUuqHCQMKfxQwll3+bPX6COF/TRiGlLleRh+mG9yuV0SZNKyj0ab3owIOgoqvTEoJpSOkNvD6XcZqBCaqrJiGKMIC8YIdQ19ueGZ9tp1ew9Wr9wv1JPnOwbja8SqnueulYdezVXaFiIqtS8xCiXGHSnsafnCEUa58/PfB8kHlV67NdMzPNuUrY7pCbn7T/Xh4EZrDeM8XbnNDjflAhzTJzfsOBIzfhllXL3JSr0v2qmsS8RocqNjlBuuOdHMiIyVC++cpeSk48bdZqhYijmRRFcC7KlTzzxhAlmUH/p0829MldZaTmaMLLo/vHm7evpmc9vU1pGilGV7RAVd4BEU4YPuC44RNcpz96AwWRk+3HcllTXb1FDbfpVUN0K52j55K3atGKn0lIzFBMXqTbnNNFFN3VVnSb/90Ox/s9QjB1OAAGUNKxYuVJrdvgecyxYsV179ieqWqXCl6kBMxeu1aw1Sdq5779C9KEE80/CoW2au3ybIsODVb8CJOm4yaxSjow9dY058JEI0wjq9KxSjWTXSJ318yK9edMnHodD4hM3L96pR3u9ojP71zetOcQPNmaxsG1SEFGILfvgFKnJhEJOV6x4T/dff5FGjVuio8fdr/LAubmye30l7o02sxzITuOX8Yt33nmnydghCCPuMuyS74aIIkxDTBHe8S2UG9/0yUVaN227Vk7cqOQjJ1tiYqtG6s6XblS3K9srPDJcdc+oaSq0+JyTNJFFhcg5hzQR4xBzfPD+B8rJ8t9IpyanGVLN9vD7zAThONxVEPA+ziniASJ7dkauFo9boxO79yv3yMlsZG5YqILYf/71QHiDQ4L0+Bt3KjIuVIMHDzZkF3/srlLAHbiOxByUp5OBtktRBWeFaNSgoudr1G1ZSy//+rhiy8aY46V60ROYM0MsadvUSAh5Wt+3MCCykBiiP9yWnldvUEUd7mui3kFna9O0nVozd6NSklLNslktujY1PbiN2/lfEv7/HbnFN+YocSR31sbdSvVjgm9aZpbGL16n685uZUp5CeIp13D2ffLzol1H9NPa/cotZHZtcmaOZh+U6jRp4DabRSkIvQ2UwdilfwB9JTiMhdPWFUpwC+x3SqbmfL9b3fpXV/Xq4UY5RdXCGPA9PNAsdUO2DIPvDvTiXHfdtaYPdNJLD+uPpRv09aQ55jjKli6tmhVKq6pO6L4brjKGtU7btka9xbGgoEJAOQ7IKAYfVQ/nicKKyggJRpmkjBolGWI4a/5fuqDvBbr23h46tO+oVq1crQ6d2urdD95WhboR2rhpg1E0OR7eT68v28Jxcz0gR2DhzGUap8mGCJavUkbrd6zUWe1aa+Kik9lvX7Fl20bTewtx41wSMDiXnHIF14yS7U/f+EZ/jlqhjPSC959J5PK79CzlhoUom9HzIaeWu1x2VTuVLh2nffv2GAUXYQLnYZcPcMXWNbv159dztXf7QVOSnB2UoePB2QpS0MlJlkFBuu/N67Tj4EYd2yzt3nTqJMFyVUqrT//OuuqeXmbdt2hFntKvRc84zh0nDKhCMBOcfRye4gTZX66v64ALgiPO+8X9eurifip+KMYOJ4AAShqmzF2rI8d9X5M1JzdX46av1h1Xdzb2lpiD8k+bfbX/btqTpG+n7lZOIeWDaRk5Wr1HqlKjovFXrmBmBqIkRMSIsWFhRpjFL0MU1s7fVCjBdSIzPUuLRm5U035VDNFgG5BdiCWzIvD39MlCqF17Oy3wawjjzA755T8vafrCTRr18wwlp2WbuKFK+VKqEJWsBwZeYzLT3S+7zPT9UjWEuE1LFBlHhkJB2snYQnY5Rj5PHEKWkeV4ENgh1hCb8y8/X91vbKfo8FhNnjhF51/YS2+8/bqqtCqjrdu3ms/hk9gGYgExE6KxOcdpaaYveuOKLfpjzGRVrFBRpSvG60Bqgho2aqh9oev8Jrr7D+01JA6/x/XgX4QBO2TL3fkjsz/01RH644PZSnG3JnBmlnIzT+TFGnGxCnKznXOvbKdqtSuZc8rsD9qd7LlyXcYS7N6YoN+HTdHOdXuUmZGpoDDpcHCSjrY4WuBa3/jCVdq0d732LUzU9hWnZkfjy8fp/Ju76/pnLld0XB7RRHhxgvNNzEEpMkC0cBVMfAUxNsdqs+AW9DrzfVfee6l0GnZAleSYo0SRXEOKsv1/AGYuXq6yKfuNikUQj7FxPggrt+/VM399WyjBdWLUzBVqVL2yLm7X1BgrjDFkAUXQdZgQPZWQGjDi3T+8IrgWWem52r8+W12vbK5BgwaZUiWcD+QLB4RjcGZ43YER9pCOiRN+V5/zz1d88n7zOasEUyJEDy/kEmOEs+TcoGxStoIxgkznZYXnGyXXlkTZdVPZJ0gx5JtyJ144JzvEKzHpiHkfih6OhfJgnA1/Yz9QV8lOBilYvwyfrElfL9DuTQWHfETEB6n2WRmq16yqtqzJU7t9QeU6cYorFau77rorvy8XkC2mrBvH4g6bFh3Rb5/nlZIXhqDMbIUcTVZ22RjqofN/36lrA1WslmyEBpwsJJfzhVGmNIksPSXaYMPyHRr6/A9au8j91Mgxa2YqcWu2+j+Qt+4h1zG2Zq7e/vJFrV6wWUunr1NyUqr27N2tPpf3UIfzWygkNMRtORDXHBA4QZw9Dd3wBQRvLDvBfeNaEmWEpEWLTLlUsUUx7o8JIICSBHzXsWQvR/i7waJl61Q7/oQRaYk5XJeK27n3iN4YO7JQguvEpPmb1bDOQvXv287YcEpJqbbC1rrGHMQ3DHECrN3qy/J+2Zk5SlkXpM63dTbkkwotYgi7di5+oqg+ZvwZyxz+/NOPJgOYdWyb+YyNOajSgpxDSjjPkFXIOeSVzxEnUP5MfAGx5liI3fDTZHWJIXgf28Cn8CIuQYSHgPP3A0f2mxiDVTD4brJ7bIOYA9JGqTMtUVGRUZrx/TytHjVNu1fllchahMeHqHaXKmpxdmOtmLZOvqJ01VjFlI3SDV1vMITeAoJNTEjFnDtsW5Cgn16dLEdFuntk5yj3WJIUH1eA6J7Rqb4adIs3800g97RGAWI0jpt7hrgU7Fi3Wx8/MFzLp64pUAJv8ePCKTq8Iln3Db7d/N8khypmatjSd7Rp6VbNG7dESUeTtWfvLp3b9xydfWUHI6g7wfnn2hGzAq4PGfOiYldvQfyNOODaqw6IWe0sk2KJ3OIbc5QokotBqFipsrSxoBHyFlWr1VDv3nkT7dxh+NTFyi7SohTEZ3/OVc7eTebhpVcEhc4dKFeGxK1Zsk1b1+31ed/XLkjQBTe2MQYBh4OjRBnEAXBenGu9egJOlqzum2++aQZFYXBxEFYVfe655wz5gohC1p9++mnj2HBoECnUP4wb30kpFCW+ZJIhjM7+Tt7H2rmUG+F4IJA4ZBw96iEiANulBBtV0fYQkcl9+vHndGhhiA5sd98/nH4sVxumHFa5vLXofUaLLtWMg8TJObP4ZKbpVyEIgeSj/OF8+TvXa9wna73+jqDsHAUfT1VO6RhFRYerTPlkvfDq1WaBcRwO5wGyy8AOziMlWfQ/PfLIIzq49YQG3TxU6ame1xpMPJCsMW/8pYwTubrlmUvNMA5LJpu3r29eABLfuXerU9as5VpQzcB15l76J0FwwbERyLibFErgQoUD90QAAQQQwP8yEH9r1KwlLfYv5ihfoYLboNvimwlLlZHpG4kePW6RYnL2atXKFbrvvvs8TmTGzyCo7tm8T0un5LWe+IIti3Zr/86DJsNGmSmkBN+BT3SuGVwY8PWQGwZW3nrrraZqiViDhAVZ4SFDhpg2HHwR1Wj4QQRfYgJiHLukEvEFMQOiMFVYVAfZDCxgfwYOHGgqwqgUsv4FH4+Pw+cgrBJzEM8wH4Ltk/V+bdDr2jspSbtX7nd7DBnHsrXx990qUzkv4+grmvWsV6A8mPPHeYR8UyEGSJJQ/cexgf07DmnsIxOLJrgWubnKPZGsoPhSiogMU2ytXL0y+m6FhYeaY0ZAwC9zXji/xH9PPvmkidFyjwXrqT6vGZLqCccPndBv705WyuF0PfFlXnuXTQg0aFPXvGzMcW7vs09Zs5bjIzYgk+zr+tFFgXiN/luuL+10rrBDMt1VywXwv48SRXIxWOXifFsKyImysZ6zVPsTT2jG6ry1YH3B7iNJqtiol9pFRnokuMBO553661L5g5ws6dCODOM0ILU80DzcOAaycRh/HAf/twTOfq/9GcPK2nqUbbz11lvGyDLkic+yXUjm7bffbjK+OKBzzjnHlA3ZUfeuoHyIDC+9OxBoBhtAnnBqkHGygzfeeKNxYOwrC6+TGWZ4BOUk/B6jTtYPktmiWUulro7Xge1FZ2gP7z6s4DjKjL0XJSpWLa37nhqgefPnGvUbB4NRZP9xeAgVnCP2m/PBCwexbdlxn0s7gtOzdMPNZ6tWozBFRIRqyZLFJhihnNv2mWD8eXENcO5DPxquhaP3KCPVO8X9+/9MUulKMSpTL9oo4a7gnBOkuVuzFnDc/yS4lpBonJi7kiP2kZI9BnwUZxTnhdkDCKAkgfaNiuX8H0RTupB4JTk1Q3/O9l48tTh2Ik2RZeurffvIIpccwsf+OXKa2+xckciVNs3dpVZdWxlxEuESsoBfIeaAONql+NzFG/ZnBiTyOUqXIXuQLLK4ZBIhHvSnUgqN4E62jayvp2n9ZP4Qo/HLbIvqIzurg5+JwYg5EM2JQcaMGWPEXbLK+HXOB21qCPr4/jatz1TaojCPBNeJo8zhiIpQTrb35zK2TIwefvMurdmw2pwH+o0h62RSuXZkVWkDQ5CwKyrQj7xp1m7l+lpAkJWtvjd0Vuerm+vYiSOaM3e2iWEg9bY0mfMO2aUKkKrAj97+j+Z/tE4pid6V408eMUtV61RS2TbRbjOwXHOy5hwn4LicQyr/6ZiDwVRUM1AV6G44ml3ikETC32m9+l9HUDGOOUoMybUDiJpHxuk/E/LKfn1Fr1YNPf5txO9Tle3nYttTVm5W27ylagsFfS2rJ/leYmsx+c/pqnFGlHEI9DFgvHE4DE9AbcV4OtVNd+BzGHzey8RmzilOgTJlSBCLvrM9HA0EyZazuANGDoWOEiDUWaYFQ2JRVPkZQgWRxqnQ64JT5P8QHbLaGCUymTg5jNWYt//QtrXen5+c5BSFxMV4tYQOQ40GvtRb06ZPNftsy6JQ+XAEd999t8mG48wh9RBx/tapw9ka+njRQ53cIf1wkpKSgnX22ReYDC7Z4f79++f/3S69gKCAEr1z8TGvCa7FyMHj9OPa94zibQ062wP8TGaee+P/GpQDcV5Z5sETyPATaDDxsFijGPfHBBBASQFllZCBWnXrK2z4VGVm+V623KOD55jj+3EzlJpWsE/RW0xftFk9mhc9RBNCOW+k71lcixULVym5zEFDZBGAiTcgoxAnKqKID4pqcUHcRFilzYpsLuI4fgkBAZ/IQCRiI4R7YgPihMJgBzNBtIkziB2IOSCRCMj8nRf/tzEH8Q1tQYivxD74e8jx6Dd+0KqZ3pcgZ6WmKzw2SlkZRd8L4ZFhuufj/lqwZL45b+wTSYBPP/3UVPZRVs1xQPwgoSQbOJ6uXbpq2Ezvpxc7ceJgonYlbDfZa8p3mbFCm5kF8R4v7m3+vnfxUa8JrsXXb/yk7xKGae78Oeb/xFG0qAGuCXFNYe1Izgq6vwNK2IktC8sMU77ONSdhU6yRW3xjjhJDciFJZBVBuwY1tHCTb4OH6pSN0frFcxWTe6YxqBYYbB6W3FD/exGPJqdI8aeqSK5ApZz7w3i/v6d6jeq67LKuxmBXr1pTZeMqaeGihep//VWKjCqc3DpJ7sG9iZo1bp1qRJ2lyd+uUuJOadG6Kbru+mtMJo7tU6oMSSK7SZbVHZyGClUWA06ZM4u0MyACh4ZqiMHFyUEsUfYgkxhaSDLkjiFXx48laf2cvNIdr4EogdJeq5IOJCR6fFt0fKguvbulylSKUvuGPfJLq+nJIYuMwYeEEtDgMHGGOEtei2asV7qfgcjKBVtVpUVe6TDH70lNZ2p15QpV9cUDU3z+jvTj2XrvpSFKDTtsSCYBhC1BJmNKdt8TyUXJxilRwu4vOCauMWIFAZUnoOwSKNm+4wACCCCA/2Uws4CMIn7unHYNNGnuyWV3vEG5+Ajt3bpcW2NzTLWOBTbXrPmZ5bnyqygcS2JAYNEkl4n4Ez6Y5ff3VKpcyRBIKrbi4xgYVU0bVm7Sjf2vVtnyhWeRLfB961au1/IJG1Qzp4mmDV+k5M05WrZ7ni6+7CIT20F2KTWG8Nr1W4sCfguBmpiGvmEq0NhXSmkhjfTrQsCIOxDtIeNk9HgfA63I/q7+0/OSMp6QmZKm6o2ra89mz9nfiFJhuuSJc1SubpyaNGmXn2WkdJ02MRIU+E3atagoY3+YVE0Z9ubl23XsYNFrurrDypnr1OzyGnkTkAsZ4EQMXLlSZY24/Vefv4PVHAY/8oHCauUY4YNzaodUIhzY9YDdgRJnYkquzd+JOcjkE695qjK04goVe2TMi+ofD+B/F8WO5LojAgTHzlKE23q105Itu73OvLIOW/vKkUZhoo+VLB1ZS37mASX79OkE/7J1INzL9UZREBOTh/MJv76nQuXSOrwrXb8MWabtayYp978JzKnDX1b3S1rrous7qU6jU3sSLP74ZbomjVyvYwm5+Z8FK6YlKDwyRHOit2rO+ul69Y0XjXGgNIgeCk+AQCEQWIUX52H7hfkd14xeUc47BhBVkZ4cSDAlJhgoypV4Tft5kRZ9/pXP5yQ7I1stO1dSRkhpLZy0RemJIcrJlsLCQ1SzUTk17VRZrTrVU9lyZY1D9GTw2RdKmzDA7LMl9iknfJ+qaZF45LghnThx7jeuP+XJNoPrvL8/eeMrZaT5PjUcbF1yQBfd0+6U/lqcAA6f73UHyssh+f6SXLtGIuJTUcMjUI25B4r1wCnntG1fS4f+r3YmgAAC8DnmcJbcgv4Xt9WMRZuVkem9jW7bINYE9Qi/iKiU10LgEPqIOX6dutLvfQ4L8y5o57uOZ3hej7wo1GpYXStmrtWfn83T5vm78tehnfnOI+p6RXtdPPDcQpdemTlxrkY/95sSN6UVWMN21e9bFBoeovLH12jVsfm677G7ze8hP/hg1zXrnWIpVX3EF7xo3UKIoELItmpB7PHhxB+8BwJJts8OQ8T/8lo+bbXmvvKyz+ckNydXdc6qrBaX1dHcH5YpaVe6crNkjqdyg/Jq1quOul3RQUHBQR7JHNeFLC5r5XK8xCC2CoqlbfzFiWMphjiTcOAeZlAYMQBZdCcQxIe+Ndz02vqDHYv26cpLzjtlujbl4HaFBnegXevvkFxa7XiWGBZGJUFhoHIMcuvNvJrTHUHFOOYodiTXHSibdU6ga9+wpp6+sode+X5KkY352MnHLuumfl1bG4KFkeTGRzmklMX2k6QeLronwxNqVUDRPDULactH6btIy8rRsr1J2lunkmJ3+e50wiODtWnxYf06ZOwpf0tNTteEr+eb14X9OuquFy5ViGMJGzKV3w//U1O/3qysTPcnLCMtW+PHzFNUXFWtXrpJIVFZxoBB0Mh2k4GF0KLUWVAGBInjfTT+P/vssyaDi8GGUKJekxWl/+Taa681ZIi+XMixaw/pjvW+D+PK/+zGvbr20Z568pV7TL9OaGiYMjMzzLRJSFinzp1MGTJOj95hhmURbPCCmHOM3Bs4RspacApktNnPyBz/+7EyMtOMwWcwFKXbkEL6VfgdJeE4YEqUKPEOyfJurVx3KBVdxijtriQXBZteKE9w9k/5Cu5pyua5rkWVHlEZwCLwdmhJAAEEEMD/Msi02mXaQMPaFfXSvRfouQ/HKyu76PaYmy5trzuu6WJETTK3tBExWAg7aNeZT0703+fVrEzM4b5k1paPZmTmaPX24zpUtY6Cl230PQgOkXat2K9f3jm1wigjLVOTx8w2L9afffTzOwpM08W3fjv0Z016f6HS/ruevCso+f1r5EyFx4RqzdkbTUYT8oLATjaQSiSy6XamBEBMJa6wVVhkf0lWcD4hM1wzYoDPP//clCQTN3755ZfGx7v6uu1r/F+GcMfa3eo/4FI9+NLdpty4VFwp7T+w3yx7RKa2dZvW5hiIhxCZyRrbmMMOz6L3luFdCL/EuBwL74vOKeX3fuUG55iMNZOoEe45N9wLJCGId/HB3IeUhcem+B9zRAZHmmQR3/FPrMjgDYhjeS7JdjsHnboD9xLxD9fcXa9uAKcPih3JdRcEo964PkhXdjpDZWOj9f642dpx0D1prFE+Xvdf1EXntWqYb+AwoDzoGERUJcpTMYrJO9arfKkKOnTct0Xfg4OkasHJyvmv47ODley6q5DApFLV9N64WUpjhH+pKIWVSVbE0QzfvickWGuX7Cjyfb9/PU9pqRl6dPC1xjlgSDOPh2va2C3K8mKKY2pSlka8NkNnXBhjrgVGd/jw4capoH66rtEHgcNokhGHvOHQEREw3GR0KVkeNmyYWawdg47jgnDyN2dvRma6fyXB1uFCVtku4gX7wQAKFF8UTfpVUdE5Dkp0ue4YfO4rJihD3BE/OA72BwOJ0sgxrFu1UVtnH/Br3HqFmjFGGIB8IghwzJBCnCLDGMhmQ6xx2hNHzyOn7tfxR0TmkXd3WeKiwHmyaxV7C4g6DsR1yQpPgIDzfk9rKhY7FONx/gEEUBJiDoRQJ8kFlCy//9QVen/kdG3e6b6ktkLZWN16eUddcu7JpejwR/gXloyhhxXxFPF18+plqlOthrbtOeLzPleJS1P2f5dTtBNsraCJLw6Nr6P3vpyiEynpUmi0oirHK2yvb+1AUXGRWjK56H7eGT8sUOqJNL34w8NGXCaDlnE0R1M+XOyR4DqRkZylH16crLNuq2uSDhAziCA/kwl37dFlgi/vwWdBYPDziPBkcMkkMtSSFij6W2kRowwYH0T2EoHBkh7iBn/BZ9lH2q0QFYgh2D5JDTL3XF98MuSa/SSDzHEQ80DWuL/wvczP4P7DB9O2RFXb5o1btCnskHL92L0K9eKNAI1YT/UYMQcZYmJcMsf0qBKTMkdl3q9LNE7T/Dr+0PBQcz8T/5F19wXEX5Bszo+34P7mvEJwvQHHSSKhJGRxi3vMUexIrisgIc4eWid6nFFf3VvU04KNO/XborXaf/SEDh85oiZ1ayp122o9d9clpnQDJYuyWx5KO0Yc44SR4sG3098ObzygaT6S3LOb1FZuWrLGfPedGb6DcuicYDt8yiJDxJ043qSUys8/pKCiBWGDyOhwpSV7T4qn/LxEwbEpatGphiEij17j3SLwFsnHMpR1qJohJRC9//znP2rXtp327zmqvdsTFR0Toco1y+YTVYgcPS9kbCkLwgk5+0Eom2VbnB/6Z3BIZAH5nF27LLb0qQvce4uYUpHGsbFdnNgdd9xhiLXdB8pbIK0YfwgaajqElnuD96KqHjuao/r1mpv3n9v9Mh1L2mXui9Klpyt9z2YtmLzB5/3q2KeRatXJGwhmwflC1UeFRmm2AVbtRtX8Pv4qtSvorLMamvPJQAuOz1sQyEG2uWeLAk6cc+ks5y4KPHuQeIKSEtMXU4yHQAQQQHEHhNST6Hdms5oa9eaNWrFhj8ZPX62EA8d06PBh1a9dXUrZpX6XnK1mzZoa4kMW0rbrAKqDIBuInvmC3+bj2rbHt/1rVr+yKsSHafTo0canMsiPXs/8CbYzVuvVIQWXn0lvUkWhB5MU5MWQRhAeFebTQKKFf67QW/d/pJYXNjD78tr1HyvluPdlt+knMrR3wXH1eb2P8UUsOQRpPbT7qA5tT1RkTIQq1Sqv0LC8kJfKK2IOKsWIcexQQwtiRmIxYjy7jjCkGdHfnvu/E3NExOT1+RJDEGcQR7zyyiv5Myfot2WmB3EG1wjyTUUcxJahW5C85MNZql+ziUmQ9Okaq52HNurCiy40gn32lkhNHTnf5/068+Jm5jtc16dnLgcra7C0o/XDdZt558PdoWrdSkaA4Djx7e6W7vEE5rGQ7faG5BIvkRRAHPJWwEdE4DqQNee8lwjkFt+Yo9iTXAJ3T+PkASShQ6Na5gVQliCuu3e30GeffWYIBi/Xqa9kFXFmGElUOCbdnd09RwPe/1ab9x32at9iwkLUtVq0enTrbIgLxhnyzAOMkc2KLa8Pxp/a65tZNlxH2pRVmaVHFVxEX3HZiqVMn4WvYNmbh1/opdlTFmvdsqIzwK5YNWe3MtIzlZ6co0MbgtWv0yAlHT3ptCpWK6M+17TX+r2L9dCj9xnljL4PMtiWXEKKUCxxPkOHDjUKsy2lYVARToEFyik9yYn1b9ACiKyUa8gUhI1MLkaOwQQWlAzx3SyRhIoLCWdN2uioOE38fYW+Hb1VRw7h0E/2H5cpF6F9u0MUE5+sawb29JnkxlcJ0fotK3TtDSfvO1RdSpgIAnB83HfWMbfu1lilK8aYNXB9Re/rOykiPsg4D8gzQoO3ZcHct5QyFQWyBZxTAgpfHAfiEooqZWglBsXY4QQQQHEHBMouueIJLRtVMy9nzEGmiTXomXVgZ304we9p40EopIqIuOb83jFKePUHQ5q9QXhosLo1L5W/Ri37iU/Bp5G5K1elrl4fxnr2BT+XUypSKR3qKnr+1iKJblzZPJ+UkepbKnHt5G164qP7zGCqeb/7vlTijsX7dPxwklkWMG1TsPo3fEDH9p/sGS1bOV69bzpHu7M36eY7B5jsLCK5JffmOHNyjK9C8GaKMbEfPp9zjgAMKUMIxyelRqcoOCTIpyWBLMo3js/35WRvIa2IxYgj+F5+R88oiRV8POIGVW1Vq1TTtJ8W67ePluvgTpbZOblSSFy5SB3bEqKQCifU//ErNW3MAuX6slxR5UhtP7pRt587IP93DLhiv7hf8NtUEdhe1vqt66h6k8ravc73NaD73NrDEHzEA7Z/1VVXFTroyt1ymkWB54nrhShBJZy34LowbIp4r8Qgt/jGHMWa5NoePl/7+HAglAyTuWNKsKfPk/FCjXv33XeNEojB+uyuy3XXZz9p097CiW5ceIjevfkCtWtS35A5HnBeNlNMBvqxEX947BlOrxypQ53LK25zkiL3pZ3SL8MgqPOv6qDS5WI16v2J8hWbV+/R0w+/rCM7vEwXuyAtOVPD3hinP79Z6LbM+cCeoxrx7p8KCs7Vpxqt8DLpxnlg3HG2OH4UQ5wNmbz9ew8oMquSwpIrq2nVympVv5kSE4+ZUqPHH3/clHT9/NEsJR/wbZmGslVj1fn8NiaLjEEE9IlQomQrADB2DHjgfkDdNX06X4zR3GlJ2rnd/XU+ejhdX342UzVrl9eNt5dT/fZx2rzAOyJeoUpp1emWq/79rzFl2jhaypI4L9xvAMNNORU9PPQAU67U46q2+unj6T4df7N29VS7cVVz7smOQyZRq+3UQW96brlOlLp56nNBQCAzQbbcl2fRLunANS5JfTHFec26AAIo7sCf+1p1gv3EjlMVxGBFT3YSkRebT3UU7TUQ3cGPXarH3/5Fy9cXTnSjIkL01C3d1Ktr6/zf8T0MiLSE5sX//KpsDz3D2eVjldytocI37lfYnkQFuQjsDE4697rOqtOipj57dLR8xYGdh/XUHS/qxP40M5zJV2Rn5ujz577VrB8WKCXp1CzykX3H9PUbv0rBUtDxb6SKaSZjSXUWWVpiDmIwCA7tSRDK2LRyCt0Xp2al26px5QZKqnMiP+bgvd++PE5HN/omLMeUiVLny9ppxozpRviFMHNNyZba2TH431GjRpksJ9fn5Zdf1tjR32ne2O3atML9ROekw2kaNXiCKlQtrTrv1FftnuW0beIhr/Yprmyszrimuq644VJD6Cl95ru53yCgtqKOIVz8n4FdJCB63NBZI5/+0afjr9Goqlqf28Lce9z3zFqhPNu2L/F7Z7LDU+xNW5in5aJsJQQxh7fk2cYqlGOTQfeFGJ/uCCrGMUdoSRr+UBQI6HkwcFKQCLJIdoS4J9gpwpSzQkgwmueXz1aj+Iqat+OIDrusWxoZnKMbe3bUNV3O0KTfx+nMhnXcOsWw2NLaeKTwDGxWfJiOnllWwWnZitqbquD0HDPy7PyuzdWza3XVrF1dI9/0r2cCtGjQTptS9mqH1vj1+fGjUBkLJzW5OUGa+e0ODRp2i87q1tgYN2fv5YGEo/rpi5n687ulSk9dmP/7WT9tUnRcuFp3K6erLrtWFauW070v36w37xjh0z7e9MRl6tWng/lODC090fThUq5MZhmll2ACBZP1gMHxYymaPfm4du8quhdq5/ZDemvQnxrz42Ma/OwwLZ+8N7//2h1qNaikW5/rqflL8tYYRnDBEVI+41yrDedAJcH7779vFF6MfUqPNC2btknb1u7xuox94Et5PSqQSDKyqLRsC0LPkj783tmH5A6UhfGsWYHGCTL0bM91qFVR4D7AyXKMlH2XKBRjVTWAAIozCJI9TeH3BNs/SlbVDvph9oQnYKfJKuKfyPDxfV0bBalKqUpasjFRBxIL9rGGBefoyj5tddX5bTR7+kSlpjZ2O+wnNq60NuwqPObIiYtU2pm1lN6imkL3JCr4v9naDp0aqv8dnaXQXM0avkz+okapOsqOlDbLv6FaE4fPKPpNOdKMocv0+Bd36tzzO5vKObuEDUg8cEw/ffSnxg2brJRjJ8nyFC1QZGyEWp5XRtddfr3KVyur+98eqJcv+6BQn+6K6564TBddfKF54R+pHiObzPBN/D1ltWQ3iUNuuukm8xnmpMwfu9MjwXXiYEKiBt38pYZNeU7D3xmlOSNWKauQdjPKuB8bMVA/T/zeVMjZajVXv02cCigFZ6klYoXM3lla9udar9cKDg0L0b0f3lxAxCFTTaxB1SVxNKXLPAeQ6sJiDs6du4oJqiGJ5V0rIbwBMT9igy+8oVggt/jGHMWa5KI0URLhDSC3qKg8bPbBvv322w3ZQbXzBMpG6Tsl80s5xyeffGKUo0GDBhlltkztxtp/PDlvZH1asn4bOVRV0uqoXFxH8xBCjFGyXEnuok27vF7iKCcyRMl1Tq6Zd6hCqDp0amdIG8bRXwQrb7qc//Aua4dq++bDX2vU7GcL/H7Dyl164bYvdOyIe6U0JSlDc8ZvVERsHSWG7tNPk0er3tlltGWWd9On213YUDXOOKnW0YvCPcM9gNOh3IWSdcp4Mfh22MGo4bO8IrgWGemheuWF0Xr65RuV9UyQJoydr4nfLVTi4bxSKgx+07NqqnqzaDVtV0M/j/9Ojz32mCmFJ9h58MEHzf3DACwy1rwfR0RvDgTYZlCjYyP1ytf36LHL31HC1sIrCaLjIvXsF7erYatT+2ro0SJLzIAHXlQVoOx6AoonqqprIIbThvj6s8QQwgJBHM7edVhZAAEEEMD/Iqi4wZ97G1BDaLGPNosFqSFr9+KLL3r8HEE8RIiYg3aR7777zoizlDqzvEpIVHklpmQrKytbuVnp+uPnEYpKLa2KZc82GUPezwBDV6zatFepXg5wzA0PVWadk0uwHCwXo+atmhnSncawKj8RolBl+zMxyVfkSu/d9YXa9Mibo2FJ184NCXq272Dt3+k+A8ogrAU/rVI4sUKb4/ph0jeqd0FlbRqf4FXQ36p3UzU4t0aBjCTXED9L/AGRJIaEbPI7+mtJnPzy+XRtXLHT68PLTpPefPBLPfrR9brrmVv1x1fTNeHzaTq4+2Rc0KhdXdXsUEFNutTRT39+Z+Jd/D4lxPfdd5+J/YhhKd8mxiBGpXIAQdsiLDxUg35+TE/0eUUbF24tdJ/CIsL05Mh71abnyaFqFsQ5iA2U6TOvA+GnMJLrbuUHYiSq8YjXCotXPIHjImFFubIt5w/g9EexILksgTNt3DLt3LRfWzZv095VOWrRsZZXA3QI4Jm8hoLElDdKVizI4EJ0XMHDhDNhErCd/AoxwFiR9aK3FoKJcXBVmsKSDhpCgDPg/XyO8lDX0oikNP8dxc6EfYb8QNyPHit6wXdPmDp9snIz/p0y0RPHUvX72Nmq1jQva75720E9d8vnSkosup84/USOohLqKLJWhip3KKvjKYk6sTFcqUnuz2FMqShd91BvXXFnT1OqhEHFqXBdyNbedtttxthhcClXB6iqlIi1atlGf45f6/PxbVh7VFGRsYoqG66bHumjnle30JZNO3Rg/0Fd1LePomIizPvoiWXAxIcffmiGPFiCh7IJwcXRoPZCxLl/EGQQSmxJUalyMYo784QGXH2x/hwzV/t3FSS7fE/3K9rq8jvOVbW6FT3uL+vjQVIJ2AiqvHEadto1ARcqK88T++gryGpwrDxjJaovpgSoqgEEUByQkZahGT8u1Jbl2800210zj6r1uc0K9Hd6AvYRv0MGFqHbGXNg3z2tuwshRognCMdGQn6IG5jNwPIxkAT8xF133VXgsxE5ecvP4Fuwz1QEMYzHdV/NJGU/ceDQUXMctLwc2u//2vALly1UZKTvPsMfsCLD+M+nqHK7vCFhh/cm6umL3ipABD0h40SWwleWUma1HJ3Ru6lSM1N0dGGGkj1U30VGR+jyBy/QTYOuMeKEXcmA+R/MFeH6USJNi9QzzzxjPkMVE61wCQl79csXc3w+vk1LExQVGqcyleLV74lLdPHdPTRzymwlJ6XowksuMHEQwL+TTf7444/18MMP5yeGEPzZB+4T7jfaxohHqKyyaweDmPhoRXbI1G1XXKeJX87Qrg0JBfYjPDJM3a7upCsfulB1z/A8rIpsOm1jlBjzvUWB/bJVZryfe5q4BbHAV9jKMbZF73uJQ27xjTlOa5J7/GiyRn/wlyb/vMQQXYvVc/bo28+kBs2rKziltLr0PlU5YkovmTHUosLKGiC63PxkphhABHAUqEUobfzdqj6oYJACHj4CfBQ5Ow3RZmrp9eR3DKrCcEAGIFlsh4ywRVR40c7SE6pVzlsonP368r1ftGnpAb+2c/b5rRUTWUpDV03Wv4HfRs3Wh788YJzAl69N9orgWiQeTFaZnaVUsU1FnXtVOUVHxWjehJVK3hWszJRc09scHh2sc69qr74DuhunAzjnGPlvvvnGXBsIIwTXdVFySnNwSsE5VZWWutLnY0tLzdK0yat1Qd825v8rVuYtDYQYYQkuQQzr3TGen95b7g0yA2SRKV3m9xa8l31lxD1G2TrN9957TwPvvM0oo1ffd56WzViv3Vv3a+WKVQqLDtb9z95mMr5FAeWW88C14D4tCogE3Mc4C3q7cFT+gueSniRKpgprFSiuKM79MQEEcDqDpW7GvPaz/hwxU0lHTg41WvXXZn3/7u+q0aiKtC9S5w/odspnESeZ3YFNI+bw1HcL+cWeQ3gQqu1ygsxmYGYCgbidmQCxZRYIvyPmYFgScQi+xQqMlHYOGTLEkBLIMlUykCuEW+IEiyjHOrW+onzZ0mZb+KMhr32llX9s9ms7Hc5vrXpN62jwtC/1b+C3IZP0wc3PGUF19Iu/ekVwLU4kpihtfYyC2gfpnKs7Ke6WOM35dZGOrU1T1olcZWdlK6pUhMne3vj4NfnTmBEnuK7M+SBraZcq4no4hQeSNFRCRWaU07FDvg+UZCDWxG/mqd+DvfOrDnv26WGuvyW4JGoQs7mvqCKgcop+VO4dhHRIo71PEd/ZZ/qGEZ/J8lJtxZrCl15+ifn9NY9eqhXT12jn+j1avGiJwqJDdd8Ldyi+fNEJJ76HBBH+3xtQUswxUV7MLBeqE3ydv2NBrAV559yURJIbVIxjjtOW5NKr+fSNQ7Vnu+fG+k2rd+vVe0ep/wPn6fr78pY4oRyEh4iSYkqEPDWlk9UjS0spEdk8FC5n34bTwQAIMA3r1kjhpHjoUJVo5IdA0UeDUcN4YeRwZhgSnB8TgylfwgCipB33Yn04T2hUJW+Rbr6nZrNSiomLVLKbQQyFoXnbuup30xVm30tVCNfxg/6XPXuLA7uStGzZclUuX13bV3vvbCz2b87QkcOJOqNl87wM+dTJOv+e84xBhqRS3jJ16tR8gmtBEPDFF1+Y/mpG+fMeCOM777xjDJ8dbsCkw/ffGuf38e3YVvBetfcSQQxkF4WeQIFhS/SncF+guqPC44wITOwwLAIe7h/2lXvaBlBcc9vPxb19Zvem2p+6XY9dP9A40aXLFxcQUwoDpdkMcEDRLQrc15TZEWh5s5yQJ3ANEBhYLoPrUiJRjNesCyCA0xXHDiXp6Yvf1Oblnlcb2LVhr96983NtWrZd976fN6XWEktstHOpHldQNUbJJDEDYiUT/KkEc8YoBOP4IUBWl+yfzVxBQvAXxBRktci8sUwLPoGqJLLHCN9U5UCKyRLef//9xt/QB3k8JVPBQZIfM59Ur0aeGMmx1WhVURVrlNMBlyoibwYSDXz8ZkO0ytaL1ZEtJ0WE/yscP3hCi+cuU7MzmmjTnF0+f37f6iNSRohKVy6dJ1pP+ksXPH2e8V223JY40XW5ISoHIYeUBtOOROxHlnTMmDH507UBscvbT37h9/Ht3HRy8jFZT8grCReSNgjqEFXED4ZakoUnI4q4zb2KWI3Izv0EuJ948TniY7bFPcXPdmCWObZzmumoDuqBq+8wMc78hfMKiCmFgdgXEYj4pygwiZoEBTGaty0C7oCIz/ESY/naT19skFt8Y47TkuSStX3uli8KJbhOkO0tUz5W5eoGa9++fUYFde3zwwBAMuyi3zgGDAwPMhkqMreuwHnhgPgs6pczI0z2F8NBxo2gHQLCOmOQL5wTLwwKpAVCBaHAoECqIRXtmjVU64Q0LdtasPSjKOCkKucmmSwf+7dv/z7VaBar9fN9I7mX3tzFHBvO8OFXr9egO78yo/n/r9HurPb6beQcZXu5Hp8TKSfSFJ1dxZBSBjKR+SSowCgzfZiAwbWPA7GBJR/uvPNOY5DpgeG4mXhIX8rbb79tyBtg0nNysvdr97ki47/DHyCrtk+Vn7lW7POAAQOMk4PocU/Ydd3sOrnsG5lVsrr8jv1FgeXYUIM5ZlcVlIFZHAsv7jWcKWTXLgNQFFBqKaUqbGIoTgI1GAfo7jnxBQSDXDd6a0rc8IcSUDoUQACnI8jKvXjVe4USXCfGDZms0hVLqfkFdYxQCPl0rUrBF2HPbcxBTILNI17A1pPdcxXhqS7i7wijCOl22r4V2iG1bI/BUhBmykohLcQhkBhiAsgXcQjrrGO7IRb4hAZ1aqlb2xxNW7jJ5/NTp3yu8UEcB2S9/BkxPpPcS+7uZXwa5dfPDH1QT/Z5Q5mFDEz6p3BmqzO1es4Gn9bltWDliMQNqep+fhMzkAmyxYtzTzxJzOGaXcQHE3OQJaUakEnF+GOuNYSX6dr0V/M54s/0vzFXJTM9K79y0ca8/EwsCpGmopDWOhIwJGKc1WL2nsIXE59yPwIILaSQ3xMbucYc/I1rSLwEiKWJdy1xLwrEPSRXuDc9tTtxn/EeYmzu5b8DYnOuE2IEIn2JRG7xjTlOS5I76cfF2rl5v0+fGfbGb3rvlzvzs0MYe4w+a49aBZKHCwPgqjphiHgvGTI+xwNGeQuEmZJKDBaOhJ8Bxon3Q0TIzFrjwsPPg4SSihNCVYVEsh0IBEMhcEpkgCm/qB+ZJV/nFDYuF601SxcZlYt9YvsHDyxV1YPxSthScDiQJ1x289nqfN5JstK+R1PdM+hy/ee5Hz0uaeRcuigjzbdlfCyCgoNM6e7Orb6vu2YRphhzTVG7ER64FogVGEyuD70nKK70RUF+UVS5vpZQoiDaNXNRyVExMaZWfDiR7N1QK3coFR+VT6whpwQF3E9811dffWUcA9/n6mgsuJd4cQx2nzDwKPkcM709gwcPNtOWLYmFNDoNN99r+168Le3hmcERutuvPXv2GDX1iiuuMEsr8P/CBkYU1R8PEbdTFksqinPpUAABnI6Y8+tirZ3vG/kb++aver33I/niN7aeqfX4JYDPJ4uKn3aNObB/ZNnIUvE5SC1kmRd+DBJMPGJjDoD9xX9AdPH/lkgTc0BgEOMhKpBt2/cL0Ro7dqzxB9jfyjHeTcl1okaFKG1as9gQEggQwmqpZqGqd6i6tiwoehow6HFtJ110e95a6Bxr806N9MTwu/T6TR+bpYEKA0sXIYr7s+wQoHR350bfkglOhOdEmyw6cQbXwPpMzj0ECn9GYgX/DiGk4g//bAkw/hxSzOeJFbknGA7G+0iWpGV537blirjSeWvSQ6Sp4DKDwdLSTMxBHMD94Bx85gruG16QVGIOBBFTQh0Zae4X+r/feOMNE3NYv09VmnOFDOJcjoc4y9ultdg/SLSdNeIEcRjnlXiEuTfEU/6WGNvKMeIWsuolFUHFOOY4LUnu+DEnF8D2FmnJWVoyY7PWrc9TMwFOwnVpE9uAzgPMA4RSt29jup76ZJiyU8ONMY2IClX5WpEa+NgVii0fbB5uZwbLOIvKlY2RcsKuh4Z6y+RcyAmGzmbJ6IPE2eGUmGL3bKNGSvz8F01avc2rY4wLlQYPvFLVK5YzJSSUsmKc0tJT1WtAa/01ap32bvLc28HC5udf10YXDGhjjCIqHiSZgRK7jm1Xw+4R2r9WStznrpQ6V7Wbl1eni+tq9o/btXPjQfmKlh3rmWPfv8+/HmKwbet23XLlBUZ5JBCwS+HggHHoGLR77rnHGF6mEyMwcK3stcfJkFEnK4oDwFHhhFBZ+Xzd2mfonlv96xfq3DWvFIYgh+8iIGAtPMrGXnvttSInClpwX/HCMON4EFw4RlRZHAPHzfYx2vzeSWZt9te5Fm5R4L6lHBlnYtVcwPdQjWCzCfyN6+cvySUzQUDIMTm/J4AAAgjg/yfIzPqKrIxsLftjvfYeTMhffgV77Nr2hK3GD9k+Wcja9kV7NXXMT3r72AhlpWcrPCpM5RuU0vWPXq4GTWqZgVPOShfEeYRz16WHiCkgMPiw4cOHGz+IjbUxB/uBCEolDkLl/QNrKyNkon6cnDd/pCiEh+bqpfsuUpMGNQ2Jw69A+IixOt3STEHh0ubZuz1mfRC2O1zeUtcPuthkoPks7TnEHPuS9qnx1ZWVMPe4jm5zX7pcvUVFde7fSqvGbdXa2b73Adc9o6YWLJuvbVu9i7HcYf/e/epTu7MpdcUXQ3SJBzn3XGuSGpBBxAwmGJPp5npz7jlPXBNKZRlsiW/m98QI/A3x4cwz2uumv17yi8R3/O88GrbH90KkEawph4ecEidSCVYUyMLy4v4kxmB7xErEHFxzjttWH0CEXUvyiWcpoXcl08RV7tbE5d7kfJFAci5NaBNTVqQn1vg7JNcOyOSYPCUXAji9cdqR3I2rdmnXFv9I0PTfluvZT/sbcoAhpWyElxP0AqJs4Yw2r9ind577zgy4yjtVeYpiekqW9qw7oRduGaFKteL07jcPFtgGRs6pZLkCpQ4iTJaNzBVk1ypclHjw3Rh81NwL65fW+rXJ2pVT+DIqNcvG6sXLu2jOtMmmJ9JmqDEqbGvf/r269K42SjqUqem/rtTejanKzswzmqGRUt3WpdWobQUdPrZJiYnNzSAhFFmME4YQ9a9C7wq6fOjl2rx6t4Z/9LPKxJXX3n171axVA5WpFaTw6DzHfda5df0iuZv2z1ft3R0UFev/bVm2YilDcAGOBqdpS3UpH8KgQ+5QUim1IThALWfyJIaWklvOGQYcp41CiVOwpJlMaqWq0dqf4Ju6WqlKlMpXjDCDQfhuDDv3CfvFNtlHemD42Vtg4FHnub7sL4EB1x5ngnhD2ZO7AVBkqK0Si7pqYZ2ua4aX80I5E9vH0VFazfmCRDv319+hD8BWShCMuYpDJQ7FuHQogABONxzYeUgrZxWME7zFlLFzNPi2p4xwjn3HH5GNdU5QRky2wwWjMkvptf7/0aEEWzGUR44zUjOVsPKwBt84TGVrlNK7E18o8D0M4HH2RboCm0p1Ez4QwRL/bmMOhF8IBfEIhKLbGWW1cOEJ7Tpe+JTaSuViddvFjbVx7TLFx4SaOAFRGN/DMWHTe9/XSRk3ZGvSyNnaveSQMlPzjic4MkiNu9ZS5TbxStMJHTl6xPgY4jIq2ai8wo91OO9MXf351WaQ0bBXRik+qoz2JCSoxZlNFV4jRxVqljU+sP1lLfwiufuCt2nDhkqKjvd/FYqo+Ij8Xk7OK0QQEsj1xMfzM21T+EvEbJInDOgiC4/PJLaAaHF/cNz4bGIOrhk9r1zX2i0qaNsK3+LeuHKRatKuphHS+R6uNwkWSDc/I5RAIn1Zw57YhQQB9xvXi2tEKT7iNiTxhRdecJsVJj7hOIm3nX2vVBUQZ7ou9cn3cF9yPyEAEJOTtOH9hcXW/lSOcd4rVaqkEo3c4htznHYk99A+70pu3eHIgSSjlhLYu+t3ARgDyn3mTlqt1+4bXeQi3/t3JOmRqz/Wu9/fqzLl80qE3BEFV5AhxbhQesGgBZwMJAojz+fJ6mEcIWH929XXGZ2769vZK/T7orXKdCh6Z9Wvrmu6tFTlkHSFhwYZZ0mmku1RLs02MAyQd0piUApfGXq3IVnz5y7Q0uVLzd06aNDTppSlYXTecAG7WDz7ggGDFEF4Qf3m1dX18oYm64yhZlv8jOHE4fyVPUnRpcKVctz7XpK4chH6evzn2rBhveZnr9CSyd6vCedUha+7raDBRrm0iiXXHGMGKcRQslQQU5Xt/tv1ZrkGGHDUVpQ+fs+5JNNIKfPV/drro7en+bRvuaE7zXdhsHEClBlDoilZtoOtfAXDI0aOHGmuN04AIYL95Z6i/Jn+Hnq4qBqgVMlpyPk/5UqUA21YtkO/j5ilJTNW6/MHJysmLkrNO9TXRTedrcZt6phts9+cM74PlZaf3U0+pkyO7K43y3c5Abm1WdwSr6j6UTp0ujicAAI43XCScPqOY/uTjOBMzEFc4S7mIKBHPExYd1DP9B2sjLTC14k9suu4Huo+SO9OfU5V61YqMFSoMGCbsbGQLKbkYr/JwCH6E6/YUmp+vqRrfXXser5+mrxC46etVLqjZLhpvcq6vFcrtW5YXlu3bFJOVBk9/vjj+e1ZVEIRPxC7UAqNr3nuq4fyBhXNnJM39yI0SE888YQp36Wvkmoq9ofv5kUswjbsEnI1G1dTlxta58ccxCO0GNm1ZadOmaoy1eJ0dE/RWUmL8NgwfT1pmPbs260FsYs1e9Ryv7Kl1z94Rf7PEDPILYNEue5cc4gUMQeiNLM/yKhD3ojFOA6A+IGf5f/EW/hPzgsxAufrpscu0Ys3fu7T/kXWSMsfqImQz3wNzhUxhzMW8EWcJh5km7fccos5TmIQYg6yxEOHDjUtUxBaYg6uD4KKBfEX80eIL3ev36vfPv1LC/9cptSkVMWUilGjtvV08Z291Kp7c/M5zh/7TP8wsSX3AgPSXGHf6/wuXyrHqGIIxBwqtjHHaUdy/w4wiEVlyjDEu7fv1+CHxxZJcC327Tqitx7+Wq+PvMOQCksQPQGHhLNDVcMAYXAgD6h5dlozJALVD4ULMozxu6lDA4XvWK6aDRopMytbs6ZMUo1Dx5SwPFmrDh82ihSqGtvC8GBM7GQ8CBBZYlQ01Du+k7HvUTGRJkP32WefGQONkksvEMYEo0TGDgUOB+R0olaJxkBCEq0qDHm/qO+FKleqml696+v8bHFhCI0I0utf3anQ0BCjhPJa8sdebVvnW2/uGR1qa9nqhcpekacWo1pD7DG2OAvOKY6e/eV3qJAPPPCAMdQ4FjKcqJS2hAaiy3GhSNO/i/qKmtiyTT116lZZc2d4t3/1GgereesGRmjA2SBAAJw1xpVyG4ILe628BUOq6P2xQ6y4RzhG1GCcEMETToIyNBRhzgf3lyXzZ7XooFu6PKv9246dsjQC6+tO+X6BGrWprfvevto4EVtyx73gaWkfSui4f3yZsIwqzHHwHTYLX6JRjFXVAAIoSQiPCM+3954AKTi477BeuuaDIgmuxdH9xzTomg/06cJXvRLVIVX4d/oliQXwsQT3xBzO8mmWPWR7DE8qVy5eV/Wor+yDy1S9dgNlZeVo5vTJqh5yXAkbU3Roe7jxr9j6L7/80vyMX6CHExBjINazLbLEZA4vuayvKlQqbzKVrAUPuYf88VniDcQA3mv7N92JpewrpMpOleZ9vc7rpSpja+ipPm8qI7noYVUh4cF65uu7FRUbafwur9W/7NDSSd6VaVvUbVVD2w9t1uY/8zL9+HGEWuJMSCD+ELJKXMTxEUcgSuODuRZce3w0MQdxiD1uSDEtY1wbZl6UrhStbv2aaObX67waAFqjVZxa9qlqiBwxIS9AnEPbFT4ascMOh/IWEGQywRwbQPCm5Y54iaQBgr2NOYg3iHmIOSyZ79z2bA1s96j2rCo4U+fE0RTt33FQM3+Yr9rNquup0febZAMxLfcu588dwQXcy8SpvpBc7ksqx8gic1/+nSq0YoHc4htznHYkt0KV0n5/tnzlojNmGJ1xo+cq3UtnY7F87mZt27BX2xPWF+iVgdBSusOgIwsMAwYP0oBxwGjwf8qYnnvuOeMUIWWUvZDhwvBhJCDPZ3fqkK9uVo2PNgYFBW3nzp2GDNsBFhgeDCqkm7JdvpNsJgYX9YryKZwcDzjOqGqV6ipfvqoGv/WBomPC1bJlC/Pg8zfKOpx9EU6QGYf8OgdgmHNdvrzeHHOH3n7kOyMCeEIkPqzqTqVkHVVubrV8Y3PTIxfopYHDvZ7oHBQstelZ0xBRHAhEnv0aOHBg/qANMqkcO8aNYRA4E/siu0q2EiNuCS6wpT0IB2ybFw66WatSyslN14bVGTp6xH2fc1i41LBZqB59sr9Rc4cNG2auK06L64nKi6PmdzhHX8qGcF4IJExkdgU9MtwTODQUYgIIHIEl9pDiquVq6blrP9XRg4Ur3xuWbtdz136mZpeUUbfzOpnvQ1lmMJo9R07gjHDW3sL2o/HMBLK4xd/hBBDA6Yby1cr+n36WmOP3odN0wrRFeY9tq3dp2bQ1Uum8gVIWkAIqjvDN1p/aaiQIKL/D3vK9xCfPPvts/uBFsrAQC8RG4g2E3yaNG+aXoFYqG2UykJBaxF9iFYgy26SsFr8EQeP3+FNIKjEG74FUYeP5P2Jzg3oNVbdWA/3nvc8UEx9pxFmOA39IzOFu6BDA79F2BLGx4PvZ7jtTntU7t32h7as9LwcUXipEanpMYWXzBHqbXR/w7BVaNWO99xOdg6TG59Uw8Rh+j2PH395www3G3wIymrRHUbnFeXEmQaiMo+qKmIPzZGdZ4J8R2xEBIIj8jLjeqENlpaQnadvcEzq4x311QWhEsGq0idEjb9xiYhdiHr6DpAcxCNfVEk72xxcxmliU+4OlrVwBaWboJbEH3we5hQgjcJBE4Xo3a9BCj/V4WXu3Fj40dvua3Xr4nBfVdmAjc9/eeOONpszZdSZI/mXwg6ASvxAL0ov7d5YfKjbILb4xx2lHchs0r67aDStr+0bfJ/BWqBdqSmisAugOEeGRpnfXH/w2crZUMcEYawseUkgqhgtiCdmCBGAEULqigspp0s8L1KhRQ3Xu3s4MpoKcYEwglhg5jAQEiIlyVpGDIEM2AMogRgDDjxNBnaNEyDodSA6A6OLUrCqG4/nrj0WaP+OEpozjmFmbLFyRUWFaMm+mGjVbpgaNqpkSFBwnRIxsG8dAFhpAJhl3jzN0h5tf7Kyk/UGa+vNyrVu6Xbk5wYqMDlNU2Rw9+vItatWpviGi7CdDsiCUXJ8OnTrolif66PPXJ3hFcPvc3ELxlcKMc2Tf6D/CmdglgzCEOE07WZg+lccee6zAdrhGGD7KYyiXgnDhOFGb6aMePXq0+vfvb4wiayc3btJYQWFbVaViC61adkAnkvLI3fGkg6pcLUjPvnCHqtc4OYTJDOPo1MlcB0p+6F+xfbC+ACfPvcAQC1cDjzLJcRPAMIwBYYMAhd6g/J7aUvF65NLBOnbQu77ioweOa8UvGXryhbz1GVGpccxOh+kE9zz3uKf1IJ3AKRI0EVghwARQvCcdBhDA6QbWfG11TlMtn77W589Wa1PO2GRPlS8AWz3n+zxf7it++2ySKp4TYaq27Nqi+FBiDkgNAiKxAn4QH4BvLBtWSZPGvmXsba+Le+jiQRcb30BMAhkjCwc5w89BhKzAjZ+ivJltIXYSb7A9fCU+G8EdskyWDNID8J/4K/4lLiHmmDNpqVaOP6BZu/dKOdPN+8Ij07S0zCTNOXOxmp5ZzwyFZL8hjXaQlR2oSAb0xRdfNMfnjuDcMeRK7V59QPN/Wq6lU9coN4vthyqqcpgeeutOtevTSvfcc3f+agD4K3wmxP+hIbdp8G1DlJtdhEENktpd10QN2tcyyQiEa/wiMQPX24J4DqLJcROHMePDCSr1eA/Za64B/+e6mEq7Sy81RJe1jBHXibPK1IpQfPV4RWXV19o5u5RxIlepKalKzkhS2TqheuTlgWrc9ORMC84PSQ4I51tvvWViDnstC1sW0BVk/4ktiZ1cS+7tkkHsO4QfAsl54F9EdUrRybI+0OMZ7d/q3bJSycdSNH/IGj38bN68GyoQETWIX7iXXEEG2d5nRYFrxbWmGoDr7q6FoKQhqBjHHKcdyQUX9uuoj1/82afPsE7uwIev1fwF8wzR5cHDoLsaycT9qUo66t9aqNMnLFaDXrkFBufgEHj4cDp22AODrP78doHW/5mjxIN5A6I2zlipcUNXqlHLGqrTKl45yjWf5QHEeNK3y/8hDpSxUMpBRtKWNwNIB6ofShoKFQQE48jPOAeUQ7aDsnj8WIpeePJ7rV6J4lmQqKSlZkqpZbRsnrR3d4L27HlVZcqUNmTJLk7PeeO7cYKeCC5K7qHDh8xd1v/xLtqzp45ReMmE4gQjymSaPiCIH46U8luIJllgVEEcauerOmv74hTt2ebeONZsUEF3PX+Zxk3+Rr/+Ot84EZw0gOBhfC1wZkwCZpw9JMwdQbMGFVUVp4oowDFz7uizwaFz3jHirIvHOSlXLlTX33i9Wdwdot6+WyMjPLiCbeKwuY6DBg0yzhrjj1O05T9FAecECed8uVvrFsXWLllBCRb7i4KPo+NFtcDPI/7SsQO+Dc5KOpimhZNWqWPvvKV9KHmC6LpT2yk9xqEjtBQGnCPXAZUXpdrTMgYBBBBAAP8/cdHAnj6T3IjocN33ym1auXqFiQEguvi6U9a+TUzXwZ3+9f0unLhcTWqUN0ONbCwDeSFrSsyB7cfvpSSl6q+RM7Xl26OaszVvCaN1StCMT5erTvMaatqzroJjQow9JttIjADpwt9AXiCzVItBpm3mC5KL70cAtplVjo2WHI4XX0gPKlVe+M+0lHS9fvdXWjh5zX/3/mTsZcq090Zo/fgU7V+7Trt2vqn40qWMn2Ff7CRoKtVIDjgHJjqBzyemCC8Vrr5PnqNz7m5jxH5EZZMICD+kxMSjpgqJ2AifDjGCMH/wwQcmW9jlztbaNTNR21e5X/6oct3yuuON/pq3cXp+NZyNOfDlEGcL9vnqq682RJd9cx2wZIH/RwSwywlxnMSnJDtYVpJjwK9SDcb5Ll83Um/d/5D5GwS5U7NmbjOsiA98L9fvlVdeMW1L3IckYgpL9riC5ABVAO5KghHcbRxKXI3IAfHnHPMyVYMjxmv/Bt/WTU47nqEpY2bpojvyss18h6flDzk3COauS3G5gjgYQZ04mTjUGT8HUDxxWpLcnpefpd/HztP2Dd5ncwc83EfRMVHGsAEUTm5yjDjEyy4jk5vtv6oTEhSme+8dWGhfIRno52/9Qgf3Jrr9+4YVu8yrfosquvfuvOwtBph+Gh5iiAEPKM7StUTYAkMKCcNZ2XXaMMIQXJxYcnK6Hrt/tLZuLnpa375dIWrTurX69WtnjC8lSnaKIz97OlaMPUvjoFKyvxgljgMngkOEOD7//POmpJisMtfgmWeeMQ6KUiuMI0QRQ8xyPhFrgxSZUUnKDjNEPzk9Uc07VVOVOqU1e8lE49ghyE4nwjlDrXOC78OZ8HtP2UZrQMkwQpK5T9hHts3E648//lgPP/yw+T9/I7trl2d49NFHjZFnqank5DSFhaMShxtnRYDANUBFtEsacQ4hogyK8gZcTzLxtmTdCdvX63QAVABARu0yPwRDB9amyR+MGz4zn+QSOHEcOE1XMouqyvApb44FJ0NAxGdKfF9MAAEE8D+JThe3UfPOjbR6zgavP9PvyUsUX65Uvr+EeFKlRcxBq4olDJl+risPsjNydM0116pdu7Ye37N/xyE9c8lg7dqQ4LHsmVeVBhV0+x8DjYiOPWb/EJ6JOSBWvCC+7oBQCfm1g4holYKMILCbgZRpmXruhs+0esGWIo/p6NYshTaorlsevtLsCxlB2wJG3Ibfdee78dUQOXweFW/4E2Ig4ibIDaW5H330kSkNZhtcD6q5IKVksUlOUBpLLEi7T9CsE4pNLq/sZJb5idSx1CNq3K226rSqrmU75xu/hYjgnMFCzOEU1gHHTzxD/OSpD9YKH9wrZnjnX3/ll3pz3l999VUzowWBmxiCpXsg7sRHd9xxR95yl1nZSk1KU0hYiKJjI/P7TTk+BHEqBiCBCO0QepYs8gZcA+Ilzo0ruB4cj/NaEGNDviH3gNjp6Cr/1vodN2RSPsnlehI3cm5cySzxiJ0Z4k3lmJ2LY+eTBFB8cVpe4cjocA36/FY9c9Mwr5YTuumRPjr/6oLDHzBkkAwcDqWyqIMYgVJxeWTXHzAxsDCCS2/q0zcO0dFD7td8c2Lzqr16+e6Ren3kQJN9tr2iGEF3GTx3wPgyuABDj4GFPJLlHffjRm3b7H22esJvy9T6zNrGiWFIIDYMC4K4QaqcfS18FxMTIbMYOYyv0zFCuPkMpBtSBrklu8i2IH5kSelfxhBDACF09JbgMFFvUToZjlGhXDmVrhxhHDCGD6LI9WN6H6VOlPvgcMh4uwIDR4k05NmWLLMe8pwJy82wpV1b9hrjV7lmeZ17ZXtdeNFF2rsvwfRWQ3CZWsz+oB4SDODQ2Q7q5dpV+/THb7v0/muv5/cTV6ocr3qNonXPA5cbp+Psz+Z4OT6CAZwZRNgT7Dm56aab3P6d/bNZXKeDpY/FLn+UkZ6pFbM3yh8sn7XB9CtB3AHXg2uHE3W3Nm5hA1G4L3DQOEecdqAvpmT0xwQQwOmIkNAQvfDdg2b68cYlW4t8/2X3nq9rHytYmQIZsHYOP0ilEj6vUe2Ca9v6gtDwEJ11ludhmokHj+uJC17X3q1Fx0l7Nx3UUxe/pfemPqdN2zaayiQIG37JEnJny5M72EFEfI7sIT6JzNmfIxZp2wLvV8aYN3GVWnZqqEtuvdD4EUpMeRHDUMUEwbQVZBBeBFOIKuI+hMxmoQH7gF/lb7zH9gvju/DzZCghhPyNbC8/49s6PNbB+E4y0hDC0mFhqtqkgolxIHK0atnvwq8jIHNenO1qFnwfJdYI/yxdaAd2Lvh9mSYOn6ZdmxKUkZ6hKrUrqce1XdTruvN0/MQxE0tBcJ966ilT6UTMQVzHdxOHIC7M+nOxlk/Zpo/vesSI66BMxVKq37aC7nqmn/HP7LMF54LMMdV0EHuIuidw7YiNEcnd+XIIMIkMJ3gfIjx+3YrxC//wrwVw64odOrj7sCpUL5f/DBH/upsJYs+9pynjxIrcu5wzqg5swisAFeuY47QkuXYA1Tvf3aOvP5qsyT8t1onjp5K2qvVK67ZHL1HHXnnT/tyBB5KyEEAZ8+SJUxUcKuV4OXvACdbMLQxDX/3NK4JrsXbJdr32+BBd2L+96c9ANUNhhFDhTCB1tscYg47RhCzy4md+hzGAgEDomX434fe/9MEbC6HkPh3b2FEzdU7PvHJrem8w7pShQGYxoogGtk8XQ0RfCS/XknBTOvVfpTM1WZo5ebcO7M/S+ujDmvz7NIWE/6K2HWua6cAYV3o6MMq2PAlnQV8GThdjx7bI/lKKC4GHQEJeKZPCCbqqquwjjgsxAiKMgwo+Fq+vXvtNR/YXdMK7Nx/Q4qlrNfSFHzTgyb7GGeJcGCyBo8TRQlDpT5o8aZYmj9+r3btOdeT79x0zr/mzP9Fd9/dUWtrJgIPrh9HFiVD6DfEnSHB1KDhyMvco2u76TmyfiTsgKpBx5lykJ2f53ANsweeSj6eq9H+XygI4Mcq/ES2c/T1cD3qeyFi4Aw6QoIN9omw80BdTMvpjAgjgdEWpsrEa/NfTGvvmb/rzq+lKPHBqtUq5WvG69YXrdO517gc1WlARxIvAe/q06QqPDVHGCd8zupUalCvUdo4Y9KNXBNdi57o9GnTbO+r7YA/T+oMPZhYFhIp4Az/MQCt8Mv6AF3M6iDPs/AvbB0y2DV85d848vdJ/DFKBT8f2/ZBJ6ntLV+MLqVyjOohtE3MgtNNWxM8QG2IcRG3iEPbNeU6IRyCqIDqslKaMWa7UI0RAhzUzYrOCS/2iemdV0N3332FiCTKk+Ew7CBJBllgDUsW2IEoQZM4FwjY/U/YM2XPn7xCnIcB8lr/T21oxqJo+eWiEmSjsxL4tB7VsymoNfXyUrnvqMrU4v4Vp5eFa0O5GfMN+UD02eeI0Lft1n9Yvzmt5c52jsej341r8xyu66p4eimqaFw9yLrk2xGHElAgtJAgoJ3e9j3g/+0rc407ERjywA7ZcYcuWiclM5dwx/zK54ERicj7JLWwmCPEPyRfi08Iqx2yPuqd2tZKIoGIcc5y2JBfExUfrjmf7asAjvTVrwgrt2LRfGelZiouPUqsudfXbxO8KJbiugCxeekVfzfltq1bPOdlX4S2ad8pbysUdDiYkasG0dT5vc+eqE2aYAwSH7CFKJmvS3XfffYbwYUggfRhasoq8l3IMSzhsL65F6gkIku+EYuvmw/rPR1+pcpVY4+zoRUEJg3zh9Ph+nDZGnH30NCWXTPSrr7yjudNOaOlCbj/rgE9O+d20dpsWz/2PKtdMMZMfUT85fo5tyJAhhlTiQJ1GGUf33nvv5Q93guhi9HBItlwMsK8o0wDHtX3hUf3yyW+FHjsTiN9/ZIxqtItR7bNqG6UQZ0P5E0HKgvlLNf7H3Tp0oHABIyc7Vx+/N0mXXNXcOF2uG0bZKqkQZ1RkSCN9Tc5BTHYqpTsii8EmY01ZOOCaoMAiQuCEIePcKwQrjRv6nzUAEVGnlncjoECindecAAAH6s7p09vF33G4OPBAX4wbnCYOJIAAShIioyN080tXqf8zl2n2z4u0ZeUOpadkKLZ0tFqf20w/TvpGPa7t5P32IiPVu09vzbtwpeZ/u8rn/anTyXPlGYLk1LFzfN7m1rkJaje6naZMm2JKVPGZZBKJOSC0VAXh6/FVkBjiAMqDbckqwrQz5kg/ECZl+UZwweGE43r/laGq2rC0Kd1FkIZw8TNCPr4NMRXRGkGVQYzuYOaA/PKHNk76XPP+2uF2rdmNsw9rw8zXVKZplikLJpbAp3Fcb7/9thGhyaQ6y1vxs8QZ+F9iE0q78XnEBE6wb9Y3mnXkN6TrxcfeKXTN26SjyRr6+GhV+jZeHQe0Mt/F+aY/GZI2d/Z8zRm9XTs3FD6pmO/47qMp6nNjey2vvtwMo0S4sFlQ/DNCPYPGiC2cvc6U1hPruMt42gSKzeJyDoiJiDmIRYg5bFKGaxQUIjMAzB9ERJ1aNeBuJgjxO0mDoirHyI7bAa4BFP+Y47QmuRaRUeHqdcWpPSlzFpcz5a3OQVDeoGW36lozN8GnjFe5KjFq0b5u/hpp9J868ed3C7xed9eJvTsPa+wX47Rl74r87B7ZUQYzQXoZIkDmD0NKn4ldM9USXNeM4FoPwxS8QWZapFHoMGKUzJBNxaBjMGxZChP8ON9kPCGbrt+/b2+SFs/OVmaG55IvhIrVyxOVmV5Rr7/2hjp36WRUWhwnPTfuxt5jjCGzqL2QvejQeH3zxS9m4MaqWdvU54ruqlGvijHoFrvXHtEvn8zz+vh3LUzWrgNbVKNFOdNDi0HFEQ75aIYyUr0f4jDuxzWKiknXrbfXNuTcWfrF9eS6Qv44JkqzCCow0iivOHccCZl0q6TTA8W1pwSO843AYadZInxQEk3ZOo6W87Pjr1+1b8ch+YqylePMusqu4F5AVafcCydaFMimcyyBvpiSVzoUQADFAbRsdL+mo3k5sWJbfdMa5KmqxhNanNdAi39aa9pmvEVsuWh1u6K9aXUho+b0bQCCm5Z8aulsUYBgjXz3OyVk5flofArZMXw7FTuQSkRmSA1VXPiXwrBuyTb5i+QD2arVq5bxeRApBGoEdfwMfhLQZ0vcgx8kDnGdGHxob6JW/ZKo9CTPSxlmZWRr4/x9qnGkot59+33VqlPTiND4zbvvvvuUklwAYaL8HNGW8t9ysRU0/L3RSko8obVTN6v7JWerffe2BdrL0g9ka/gT3xZKcJ3Yv+SYxqdNUrkzYs2KEPhMYo4Rr/6hzAMne4GLwh8jFygkPtOcN4QJ4gILkhaQRdv/DKklbkYYR4BGkOf82zkbtnwcv088BvDjxC68ECEg0cSlXCOq0w6claZ18/MGnvmCqFIRqlDj1PY8YgbiPFrFnEkMu3+ucSel2cQc/M1WzwVQMmKOYh1dYhDJlPlKcitUi9Mtj1+gL9783av3x8RF6rwbmxhSByAlVu3EUAKyzP4iOzXUqJHOZnu2TRkMx8fD7o6Q2/XqnEhNzfB7P6pVraUuXTqaHmYMl+2PsdMEIbYMREANxJCi6GJseA+kKzUlQ88+OlaZGd4NGNqw7oBycuO0qdImU95K6RMlxih4GF/nwAdAv8qQwSP12/sfaufqA//tiQ3WkZX7tfr3bxRSJl2tetXV06/VNZ9dM9X3bH3pjDq68MI8o4oy2KVTL33x0WaftsF+rVx62AgEOGQGcdFri/KJEwOcN5wMCisKLiQWYs2/kFd77JBdHCxOqqjx+fyd0qRe17TTqLeKXprJFQ0LyRrwjJFtdy6XgdDDkk5OddhZ4kRQEuiLCSCAAIoL8MVkHH0luXHlovXgJ7fq7duHevX+sIgw9X6wo7p265pvVxHYqQqyWbod6/wXtFMPZ6ptz7aG5DnjKYRUMoEI+e5iDkiS60oBqcn+xxyVKlY155JYgx5hYhpEdTLKgHJlRG9EVvwo555MJ7EAlVDZ2Tl6YcAQpSd5l2DYtfGAckPKqGy/0qaCjG1zrD/88IMhbRA4JzjfM3+bq19emaxtC/coOytPpDikbVr13TaFVhipZufXNT4P/7vs13X5fbPeInxvKV32fF4mGOH73HPO0/BHZxFJ+LSdNTP26MQ9J/LajpKTDZGFvDp7iMnAUilIIgMijD8n3sCnk2ggLiGrTBxCyTR/K2pgJLHNOf06+kVyG3SrlT8DxBXEFwgeVBrYpBIkHrHdVusB7hVKm9lPd6Q4gOKNYk1yyXgSSEO4PI1u94Qrbz9HwcFBhujaAULuEBMfoReH3qQ9h04SHYwiLwyw7WnweoFxNzhy6Kh6XF6wvAKjiSHCoUEuKd2hTNkJjtvV2UZHux8Y4Q2STiQagomBZHATyhgGBZUM4w9Bs4SG843KSTaZ/cN47tmeo317vR8+ATatT9JV/doaBwaRg9RjfCk5wYnhzCxGvD5O4z9xv95gbo6UdThCi7/Zowe2vKjStcK0cZnvyzYkJqQqKre0Ifk483E/+7e+4ca1R/XA/Y/ovPN7GAeOMokaarO6dukGfo9xJgvrzjhzPei19nYyMX1G34z+XuGRYXnLNniJiMgw5ZQ5bp4nO7nSFYgwzhH/lEJR8uQkufQ8cd8QiHC/BPpiSlZ/TAABFGfQywnRQoAubIigO/Tqn2ff37/7i0IzuhGx4Xr26/t0MOOkSEuMwQtfQmaX/fDFvrsiIzUjf8UJC/pKiTkQ7inLxae7HiN+0VmqDKJj3A8C8gaZ2WnGx5HFhVQhonOMxBT4f4Rg+31k5/Bv+E6y6Waa8bYMbVvnfqq0J+xed1R1q/TRrjq7TIk2xIiYgz5gsp7Ons/v3v5NPzzzl/usVq6UdUBaMWqrHtz4jCq2jdPycXm9wb4g5Ui6YtLLGHGBpMVfY+crO9P3qsDtq/brsQeeVvuz25jss233cvpgjtPGHJxXSL6rr+f+IrvtbmUKd0DI/mbft4ovH6djh062pRUF4u/o+iHmeWI/3PWeExM5Z4KQ0Scmda0cswM5/eECJQFBxTjmKNbTXng4KaXBIPqDy2/tpmGTHtcVt3VTqTLRBf5WpXYZndmniob8+YgmTv/FlJNifJ2grMcu5ZOY5NsaYU6kZ6W6bfyHbOBUKNFhyBJZOtZEA5AId0bhjNanrnPmLerUK22MBYbQGkaUM9RrxrobIutYIw6wDxgieijmz2FNXt8xfNhEM/iCLC7nk/OKI0PFg1TheEe//bt++GSyV9vbteiEgve5X9vXG6ybv9MYeozvnFmr/dpGVlauDh/KNNlgjC7Xkp4fMtT2hdGmn4Vp0pQ8WWdvwbWnRM2XpXfYZvvOZ6nv3QXL7IrC/W/3U4fObQ1xZYI1KrAr7DqG3Av2/+ZYM7N15MAxTfx9itqelVdZgDAS6IsponTI11cAAQTw/x0QTNdA2xeiO2Ldu7r+6UtVtnLBypxKdcqr6UU19OXqwVq9a6nJYCGkOzOqZBbxIxCQ/Ue8X2LRFSfSk4zvcQUki4ojfDACO7beuVqAO7ToWN/v/ahYJ87EHFQu2aV3OEaqw1gOhiwkLTxO4HcQ94k5Vkw7dSiTNxj6+rcmo0kGk/PJ9oipOHZiDiqUfvt0ooY9McYr27tnwSHlron2ukzZFQvHLzNxLDHHtN/n+7UNbpMD25OMeMG5JC4jnnLGHCQrEEvIYiPik8F2Tma2Szh5S3Dt9TinRzdd8Gg3BYd4Tzlue/N6dTq3vamQZAYMwoo7cJ2JfZ0go370wDHNnjJXjRrkVXJSBWCHzAZQcmKOYk1yrVFGVaXEwls4nUbVWuV125MXadTs5/TFlCf0ye8P69ZXuuiLSU8prnqmmcRMqQwKIwoYDxvZK+c6oRiNq2/2b7hOSGiwajf3rDxZA4DhInNKphNjaMuYXdGrzxlm3VZfUb1mjHr07GiOi5IZ55h2jMe9995rnBEkFzKGMXRi147D2rPL/drARSEro0yBPhsMNI6HUirI9mcffK6v3/Wt/HblHP+W0QHHDieZ7CQKZWiI/5nIOrXrm2ABoupaaozjRjjh7xwjjh2VmsoA69QLm15cVBBWsXG0bni6t4KKsAChYSF6+P3+6nFFHjnFwaGakoWF7JJhd4KgAIUdErxl9S7NHrteVzZ+VNe3fFrv3/aT7j77LQ2+b4Q2r9gV6IspQlX19RVAAAH8/wfkgT5GKzj7GnOUr1ZWNz53hUZvel8j1r2jzxa9pluHXqoRa95VvW5VdTw50Qi+rI+KL6RHkxdZKgsIyo0P5vWs+oO6bat5nJUAUYDc2nkglKMyQ4IhmO76czv1PkPlKp3sAfUWZarE6MoBFxph17XPlrJpMrv0ytJjSQxkJyhbJCWmuJ087A2S9wYXyHDiqyBTvMjmfj1irD59eIRP21w+bY1f+wKOHszLmhPvxUT67zcb1G1oMvGmh7hcuQICOcMqyfASj3BtydwT03GtubaAvl0EBl/BWrm12lTVXR/3N0ttFgb26fY3r9dVD1+cf+65zlwP2reoWnQCAYT4iIwta0Ev/XaDLq9wi66uMlAvnfeBHj7zFQ26+l0tnLjUbbIoABXrmKPYk1ycAYRk+vTpf2s74RGhhvDWaVRFcWUizYPIg8VDb4HhwAhi+HngILyQTRxYh57N/DL0HXs2U2y853IfMqWUlXB8NpPGQCi+213PTExMhM6/sKXP+xFb5pgpl4FAQ7ww9IDsNVlG26uCqEA5Kg4HsmtV3mOJyfIXaSnuS73JKKNEVgiuZ1RKX+DnKjoGKanJhoBSsnPsuOdhFkXh3HPPMefUFQgyCAeULjvVdIQFCCbfzfRHX/u+nEC1/WvJj3r082t12cAeZjqoE/z/8jt66LPpz6rXf4erOB0i+8V1ZgAFpePOe61F8zP0yRPf695eb2j5lK1m+qgFJXRTf1ion99aqEE3DVGa428B/PuqKus+E/QQQFD6z33nDb755htzP3APBBBAACdB7yKxAGWuf3dt3sq1K6pO8xoqVSHGPG9kT51ZYnoNiTkQQFnjFb/P/Aqyjs06NVTdM2r6/L18rnwtz/Md8EvEHIj5gIocxFYGI7lrP+E4LrrJ9z7Ico1CDMEi5nASK4iYWcf+v+XUzCfBDuEXiTnIstoBWv4ul5eekum2xYxrSzKhVkRDM6zq30JmVoaplLv//vuVsM//XuuGTRqYliFEA2dVGG1lCBX83hlXcJ6Jsfg7A75I6PgLkgLj5v+k+8feZJZHKuMSD0fFRuqiO3rps6Vv6upH+54Sc3DvQ3Yh3Nx73OMWPG/fvTpetzR9SDPHLFDK8bQCWd1ZPy7Qry9O0yM9XlLSUe+X8SwxyC2+MUex7sm1QLEis+hu6trfAaraO++8Y8bsO4FhsKWYkDxUVtDr6lb65qMZPmVxO13YUJVreybHkE0ME+obA6FweBB7vp//o3J16dKlwGcuuLSxFi9cr907veuP6H5efV12dUtD6DGQ9D3wvQxOImPn2pdjy4U43zgoXlUqFVy42xfgJD2BwRLTflisfxPlqpVSt25djZNN2B6tn7/37iF1IiQ0SJ26NNeMmVPypyTbe5NSaK4pztQdKBGnVJkgiuvM9fYVDAUjMCldKUYDX7pCA568WNs37FXqiTTjbGo3qnLK6H7X/URgQdDB+RJc4AB5vX7HF9q4YG+R+zBv4kq9eOOnevnrezwOlyiR+JcmHVJ29/DDD+uzzz4zzoblMBDJeKady1e5AgHr0UcfDQzwCCAADyBjRDBOIO6ahfw7oDVp0KBBBQZCWVtsiSDDghgCCDHpMaC9tj6y0+vtY9svvvtchcZ6JnAkDWgRQtBGxEf0JsbCHuCXGILFUjfOWOu8fmdpxoQF2r6q4LqwntDxgubqc3trU6JKzAGZp0SW88l3uluflWFDvBCOiX3q1fSfkJlVCkI954D++sr7OO6fQNmapc2xmdknZ8boqzfyYkqfECT1vqybVm1cauJCqrDskMg//vjDnF/ncFMnqEbkunJPE/uRSPEViOFk+uPKR+vCV3rrxheu1NaVO80ausQcNZtUU3RcwWGi7GdKSooRF5yTvvkdcRL7wXn58O7PteSXojPlK2es1WM9X9a701885btKNHKLb8xR7DO5AJKHccTw/ZMgg0lJUmH9CVw4iCeEpXmXKmra0fOEWieCgoPU/uIaOpqaUKh6hiLC9DgcD44OJ2NLSmjWh4ByY9lSJtS7xYsX6oHHe6hJ88L7UmnpHXBbNz39wrX56h9KGqVCOBpKZz0RMXMMQUHm3KO8JB7bZwYJ+IPqNfJ6cSwwzvQi4ch//XGcjh/1P0vsK6JiInTPcwNMFt+M4Q/zbaiFRdnyWVq2fJFZX49yejvhkHsUpRwC6lxayAnUbcqIGPBEqRgDMXwB14+y8rvuusv8i8OA0DZqVUutujQy/7pbm47SOAitKyi15r7ger/8wIea+8cK7/dlzkaNff9Pn/Y/AM+gncD5ck7OdAV9V6wtefPNN5vgA8dDMPHll196/Ax29Prrr9dLL73k82CdAAIoKSDwJkBn9sA/CbIfVPoURpwhLmRaiTsan11Hba/wfm30ttc00fHQg2ZwpidAOIk5EFft0nV2TXRIOJ/9/vvv8+dzIIz+NekvPfrR9Wp+duHkCF58ya3d9Oxnt5nEBL6FgZrEH/hGxFSOq9BjaNvW+Mek1KMKi/RPYKhau3yBmSYM26Q9iJ5Y4o7dG4sWcf8pIPLf//odpnqKjOXBrK1Flvy6Q6mqoVqzeblJQEAqbEsd1XgIIpQne2oh4j5G0Gb4J8O+XKu3igLXj8nbt9xyi2l1Ih4NDQtVwzPrqnWP5mrcrr5b0gmJJXPvCvwU15j7481H3tfvw6Z4vS9blm/XkEdHef3+AE7vmKNEkFwyqxASxqX/04BcUppcFCAAGP+r7umsPv3bKLwQ41uqbJQuuq2Fnn3rHrMUkbPXxhWxUfH6Y/Qc/TVysRmo9MuXk7Vr++58Y0XW9eqrrzakEEOF+gXx3JOwUx98NlC33dtG5StnKTLyJFEPj8jV9Td11kef91dEbF4GHAWRm5efUfUgPNzQbNebY+/d51x17ubbUk4WNeqGGsdiXzhVHCwKUJvWnp3x/wXa9W6qxONHDMFHMKhWvYzatK3j0zZw5Dfe2tOUWeG4uX9wHJRbERhwjj0JG6j0BDp2CaHu3bsboYMJg54WQncCksp30q/NNihzQ8X1Bjgc174nJ9jnnUt977v+c/TsvzV9vLjh7/THYI+wdfb1+uuvu/0OAg1sCxkXC4I6/k8JuieQRUK4u/XWW//5Aw8ggGICfJ7Nlv3TYLkUd4P/3AFidO2TF+vSR881a456QkyZKJ17d1u9PPwpUw5dWMyRlZ6tJeNX68e3J2jr5L2aPHKWFs5ZlD9Fn9iAmANfgSBL1RAVRytWLtfgsY/o3g8vVvlGYYqOO7k/YVHBumBAR3048RGVapRuSBfbw9/hZwmI8T9UxmG3vEHnLp3U+9q8ZR19RZ2zyhWIOfhOxAMSB506dfZ7gJQ/aNG9kRSRY2I3ho1Vq1VJ3S85y+ft9Onf0VQfUllHDAV5ZKgUQjn+wJOwQcUeJN9OJSZ2IHtPzFHYfeL8PCX03IucQ0QLSqO9rYjgmD0B0rN3ke8tY1O/nq0Tf6OFrrghqBjHHCWmRpB6fhQrDK9du/bvAlJByQ6ZNG9KoSEYpq/ixes08PErNOmnRfr+y7+UmZarkJBg1WlYTTWax6n7hWdq5KiR+b0o3AAYFedSLLs27dO3H07UrPHLTlkqIDhMOro2WNfe31sVqpUx+4VhoV8HEoWxxKBB1Hr07KzyFSOMuhccHKYpUyarUqUKZnJxhYrt1OqMDvryi1Hqf8M1xjBBmjlWstcoMii6bAcDVlRTf4XKvi9pEBsboeYtKyknJ6vAecdI84oMj1JwSJBysn13OnyubJVSOrTbuwEh5aqWUlCVRI0dO9Y4O5Rrzuljz1ysB+74Sgf2nxw2Vhi6dK+q8/t0yisNu/hi48hRRlE6Ucnvuecej5+l99q1J4Gg58orrzRklWvAveIOXDd6WRAs7DpyZAQ4Doi2c205d8DQcM49YdnM9UrY6l05mhNHDyZpzu/Ldc5lvjvuYom/UTpEP5pzLUfngDgnGN6BQupa6s7/6e1zB+zcF1984ZWwFUAAJR2U4/HM8Lx4ssm+APsN+SObh1AJeShqCTbeQxbtrpdv0q3PXq+ZPy7QqLe/V0ZSlilfrV63qpr2qKs25zXVDz/+YHw8mVBINATIrrkL9u84qLFv/GIIAm0tTgSFBunQ/FT1f+YK1WhU1fyO2IWWGspciRMQ18nEtm3XVhWqxxtfVzq+rCZPnqR27dvq66+/VoXK5dTprG4aPmyU+t14tRluiE2iPJqqOeZgkOGlr48BirRpFYZyDX0PccPCQ3RmT9b6PVmyTbUTx8GLzFNM6WglJ6bIH1RtWFEJGwufSG1RqnysyneINnaXnlauDX7+9hd6asvq3abFyBu0Oa+O+t91mUn4IGzjI0h60EpHTMeSkJ6AUOFaHk8VI0IGE65ZIaKw+SDESJwzsvzOCj9v1qwlznT2Drti68odWjPHO8HHibSUdP01Yrouf6DgclclFrnFN+YoUSQXEkFZTVEktyiyyt9xNpTs8rCSIaZ52rlmqydjQbkHiIwOV/Vm0XpzzJ1m8hwXnwsK4flt3G+m2R8HhVFluxB0/o+DWz57g16+ZahSkgo6GoucTGnCyNma98cK0+9Yr3kNcyNS2oHBwGFwU1577bXmWDA+kCwMWXZ2rnZvz9Xozzdo2AcnJxD/9t3bqtMwTrExpfXTz9/pgw8+ML9HXeUcsH1UGrKr9iZHxWYSME6J48AwVqqaq/0JXpbaBEnX3XSWunbt6NaZ4/Q4L7VbVNTW5fvlK7r2PVPNelbRj4PnaN/2wtXA0pVj9MCHV6tt59bm/5QYIxZwPnfs3KT3Phmgh+8drv17PWdTqX7qN6CDyldJL3CPoWS98sorpuSX7aF8o3gSJDhLpghWPC0ZZAeQEZwQSFBG7lpGT6kVv8PJOWHW+x03zmRibe+L+/0PLrREac3Cgks5+IK1i7YESO4/4HB4rp0O558Cz/INN9ygYcOGmec4gAACKBws64e9JWNWFMktKuYgi0alD/4UogMBJTtGCWlhwJcQS4DwiDA16VZHDze7xVQR2RiG4HPCHxM0YMAAU1GEHyfjR1xDzIEIumnpVj194RtKPOBeEM7NytXUMbO1YPxSvfTzY2rZranJ8kEOye5AcomR7JruiLEQLERe1rBfOnmzZn+1QxPffjp/m398tFqVm0apfK9KGjFihB577DHze2ZhEHNQSQYJJuawgzDJOOKbOQ7iPc5/jTax2rXU+2FDl9zVRV27d3brCxHYiTnqdaiulX/6vkJDqx7NddET3TTq0V+0Y1XB5RZdEVs+Wvd+MUDdL8ojhzZBwflbvGyh3vj+Pj3T/z/astJzyxS3Ve8b26tep9IFpmVzfb/66iv169fP3EuTJk0yZJV+V2cpfGFLBrEfxC4kjihPJ+awFWYW3KOAJIsTxLxkkP/uurX+EFyL1XM2BEhuCYg5SgzJBTzkBOqcvL+zfAkZLRwD6XfIF04HVawwksvDjmrldGYYEIYIAQyLXWScKYUYacpBSNVDeFC9yMI1qtlCQx8br9Rkz3XvzgzZc/0+1lu/PKhxf44zBJpSExRBiC6Gie9ESYFcLVuyTcM+XKn0NBTMgk43JTlXa5alad3K6arbuFQ+4bEElkEQHBulCjgcjBgOB8Nplx3COZWpvFTBIZW1d1dOkVnWiy5rqKuv627ONcMk2J4TOE96Y295vJSe7fexfMWFA85W8/b1tWjZfKUvyFF0SmXt2VJQYS1dKVoX33yOLr31XEXHRhYok+FF4EHzPE7j1rtbKierjFnX98DezPwJznGlwnVB39a67KoO+mvSeOXkxBb4Dgw99xIvS0DZLtfbDlrgPCLQQIQLQ6NGjYyIA2m1PTwAx8z1QpSwAYETfC/LMDC92V+keXFPekLKCf8/W9zwbyzMjtPA5rBshBP8304tdYLgmmDG2Q9HkGztKuJKUVmVAAIoaSDOwO5CUP7O8iVU67ANO/CJWGLkyJGFklzIKmTWSW7sUCiAD8dvAcgsQ4UgUXfeeacpD542bZrpQ921KUFf3fOjEg8WXanEEKHnL31L7814SRPnTDCxFgkGSg2JA1h3lf3HD/H9G5Zt11dPT1fKsVPtf+rxTG2bn6mXF45WzU6R+eeScwCBpTeZuIKVBtgWfo/vg5ziS2mv4rs3NdikKplR2rvq5Hqv7kBo1uXKJrr1sStMrET2yLkUJMAPIwbf/dqtuvPPJ+Qr+t55ns7u2V6L+i3SifGHVSqpgratzJsGbRFXIUZ9buuhax66RKXKnYxTuX94cYyDBw825HTgGxdo59pDmjBqjnasPpRf0RYTH6nOF7XQdfdcoOVrF52ypCNl35w/4gyqwADbtQPLEBGIO5nvUlTMwXmnyhBBhZiIdjaAsIEoAIlF8HEFcSj3g038+IPU5DT/P+shSVQSEVSMY44SRXJ5cFEuIZxkvfwFhoYH2Eks7KLZrkqWvYhkaiF+3gAnRB8CFxBji/PBcNN8/dAlb3pFcJ1E9/EBr+uy+7sYMm4Xw8boUG4COcfxhQVX0FMPj1V2VuHkMyc7SJvXROipxwcrNj7DGEIyqtx8qH2UrbDPkHTUO25sShGs4ofj/fDDp/The2O1cskh7dzu6jhzVLEKE50bKjV9n4YMGWJKqxEDcDDu0OaceDVqU1sblnruF3VF1YZllBmel2muVqOqYkvFmNKbfi/crMP7jpmhT+ExIbr1vusLZFNdQf+RHbYxfPhwc2+cd3EVVShfSe3adVJ4eKjCI4LNPVeufJw5X5wr7h8cPc6YhxVnTdmQc7soo4gPfJbyNFvuUxTYFo6Jcw1RJiAiKOC7XMuOLHwpW3YFwQTHsOdvLG0QHef/esPFDv/CpEPub+5Z7nlb/s59yf9Z89oVBHYEvE48++yzJjCiqsPZShFAAAGcjDlsT2dRJLewlieEdefzZyeRQlbcTSXluYTYuPZZ8oy7G1pFPERshE/CNlC2jD+/7rrr9MQlg7wiuBYpx1P1xNUv6ooXzzdk2Yr3ZHsgNAsWLDAxTZUytfX41R8qI7XweQxkenfMTtNz9w1WhQYRZjvEWhAoqtMY3sjPxBeQdmwVVXEQawRkfn7nj5f12eBRWjcrQZuWMffCsf2gXJWrHa7OfZspND5LH374oSHiCPdmuKQbENd0uLCN5v9e9DyW/M/UKq3gStkmHoyLj9U5/ToaYfny1y9XWmKmgoOCFVcuRlcPvNxjrAMg+8QGCB9kYDkX7a+uqfNuPUNdu3Q3a9vHlIo0lVuVa5ZT5NZIQyKIwzg33APEFCQ37HRlu13uA/5Oqxwk31vhknuqb9++JpakfY3sOokJ7mlPMYcvZcuugKAzZHXbzq3yF9GlAtOVS0LMUaJILoYDxRL8ndH+GDgmFjsVLtQrCCPrjzrBQ04fJZNwXX/vCZBhSA09J+wjSgZlP+N/mqjD23zvAzmxK1chCs0nuE7ggDZu3KwH7/hG2V7P/gnW8gXp+n78I4qNizI9wzgzV4eAoaTP5oUXXjDqK0IA5UqUNqek71CNBumq17SMko9TirNPderWUGrGXg0a9Jy58XNy8lRMjHlhRh9j+eKIO/X4Ze9p1+aiy5brNK2mN394QPsOJejNN98015FrRHlW9YYVdMMdV5ttQoAxpIgYhQHyyedxjBBFJsZBKhs2OtkzBMG09x2OhPJwfmbIB0FK27PaatrPC/XtazPNMWSmZym+bIw6XdBK5/XrYJw4GViUdu4/MvJFlbhhUBAgMAyID65lyq6wZctkx92JNRgkxAvK7q2ixn1J/zYOs0qDkw7TV7ToWN/vzwbgHxjlT4kiQSL3LhUJVEsw+RCwNBqBOdUZVKxYhd6CABO4/j6AAALIA/4bW+m6FIq7ABAf4amfzWZA8C8WCL/EHO4yYfRt2gydN8C3sH8QO+aGEHOwP39NmKQ9S3yfs3BsS6rSj2Wq27V5BNcJKt727EnQfee9XSTBdWLj1EQ9+fILqlyjnPE57J+rb2ZmBNVvzz//vPGZzM9AzMdvHc/dq7JnpqlX54baty1Rhw8eVaUqFZQRmqg33nnVZK7tNcIneyK4Fk+NuV+P93pZGxYV3aZTuU5Fs2xNWm6K2T9iBvaJUvYqDSuaknL8OZljjsG5LrA7EMshYEPq+Rx+m5ijQaP6+csr2RgTm07MQTxm+6Pphz565KjWzNioae8vNr2tGWkZiikdY8j7xXf20sFqB00MSsyBsAARLSpmxhcQ8xBzIJYzcKywOIVYF8GDjDLCvis4Bu57yLztzSWG5/qTIa7azPOyM0XhjG7eTx0P4PSNOUoUyQUoWjywKFlMpvUHPLRkK52ZN7b16aefnkJyITMMKXIFqiMj2z0BUsdDTUaXfh4Mb+b+8AIKpLfITM9W8p4gQ04wcJT/WoPBsRzeH6bMPA7mNfj4iC8n6p4HLjVqIOfD6RRQ2ujBgURzw2KUKB1CHUSBQTHGoZNRxng+/fTT6tajqQ4erGAcPuofGULOH8rqk08+WWjdf+nycWp0cSnFL47Sunk73WakQ8ND1a1vG9312tWKiYvSrHmbjKHEQZDBfO211wwZRxnlfFN6Q7BQFMm1AQqBDMpT//79jYIMQcaA89BSXoEDs0EOmW3uF+7HtfO3a/LwlUpOLJihP37khBku9t1//tI5l52p3m/3MSXI7CP7bNdjLqyPFrGEsf2opTjPorLBEGF6elFYKXF2joPnXsEg8a91oAQDXCtLipf8usMMRfMF5SrHq1Pvlj59pjjj3ygdAghv3EsEhGR9sDNknexgCAKwwqoYAggggKKBAAzhQgj1JDRCMrGtnkguwIfiWyyw5fgsV1Biigjq+uzifwpr04Kc8Fm7D/i13H3hysrwvGauJzB9OHF9iiGOiMXEHMQElvCcSMhV6jHfJuqT0f1y8A96+sM7TMzhOqwG0dgudfPJJ58Yf8e5J4bCX0HYeA+x1UNP9NFzzz2nCy88x1QhQd7wycRFCOwsacIAyMKq71jy5qyBjRReNkQbZmw7ZQAoCA4JVseLz9QDn96uMhXjNWvWWnOt2TdIKmXHnBfiJ0geMY5ribQ7WB+MgIINZ9/5PNlTZncghLMttmvPOcSZpAOf27VqryZ/uFDH9hfsVT52KEk/fTBBP304QW17t9T5X/c2cRtiObEQn+W+K0wAIMajl5L73WTsq1QplOhS8UcChBiaPl2EBif4vxXVgZ1ybRMfK77bpBXT18oXsC5vz/6Bdd5LQsxR4kgu2S16B5wPjSso04G0eFqn1B0wKLwf1cl5wSAg7hQqDLQrIXbdBxQryIPdl/27fB+VbvHbDxN0yzOXGWMI6XIe2923fCHJ9+WVpv61Xm3azTOOA8OGE7FANURhxnFiIB966CGzRhbkljKEMWPGmGuBwUSlo7SIMhfUHd6PEcXZokBC5F588UXTw4Fxc/YYWVACFRkTpsHfPajD+xL155g5WrNwq3bv3GNKg7r0Pku9r++kMhXySp1Gjx5tynkIEsguQ+w++ugjQwgpIUIF9+X6I1igkrJvOBMEEIQMSnjopcKRPvXUU3rrrbfM+yHBkOjxo6Zp67QTyilkSQIChmk/LtbhvcfMIDGEAbaLc8Sp4wTovXJdoB1nR1DDd1MOYvu8IaU22KH0A0eEMwQ4I84/5WpkuLn3cJyQXf6GAcIwueuxAY27VPGZ5F44oKtZCzCAf3dhdsB94a5UCBCkFAYGlwQQQACFAx/IkCViDk8lyZbkuosVnHB+lhgBPwMxgMwBMmJsx10pH0Iu/tUT2B6+HN+LP4BMMFHZX0ydMEO1z6ls/DfVWM7hkc/f+Jkk37e9cOIGTZk8VTVqVjcE2rluO6I68QEZbvYfkvr2228bkmVXQiCDSVxCfELWiIo81ltFQMCH478ptYVwEYgjFvB/d4Mv8a8J+/bo3Qkv6/jhJP05fJqWTVmtPTsTFBYRqi4XdtCFA3uqYo3yxlcT3zAHBXL9yCOPmHsCMk3pMWI+AkhhFWuuIH6iio5jJW7h3uAak4WHSCBskzwgqwqIE7jP5v6+SCtHbS1cvMiVFv2xQo90f0nvTHvB3BPspx2QSoxAHOecvg2ohiNWQFi4//77zb4Rc9jWNcD9yT2L8AHYb84PQ8RoyeP/zhksnBN7Dd2h6fn1fCa55w3opphSnpMDJQ65xTfmKHEk1zoJSjrIupEZ+3/tnQV4leX7x+8RY8Co0d3djYA0opSKPwMRUBSwQGyxAAsDFBUUQbEAQUSku7sb6Q5p2MaCje1/fZ79n/Hu7NR7YDDOns917QK2nXrP4bnv753iwuC4EjkIWZ02t4IBQRzQx6InF1Iq4+m5OENHXRFMHCoIPHdCyBMtWrRMXPhtJSbmmuzzcgx9sud4KVY2bdwmOXMFq2ynzlgjWhn1T5ZvwoQJKnrDoah7TDnoufZMFOZQxICQ0URQUVaL8bIO1OD9wDAQ8SGaiPjl0NSlM4hWHocBFJC7QE7p8mpCz/W+fYdkxLC/5MD5CBn80T9y5UqolCyTU6JijyoD8M477yihy+PzH49sNwEL7o8D11v4PFHWY91vy/PDKBBUYIohr5nXBhzw2TKGyOHlEV6/r9tW7ZNRAybLi58+luiU6CEiBBmIDnPNKQfD0PB4GCeuFdeWx8RgcJ1wpghK8BnDQdK9OXzuyP5S6cC1xjBREqUztQRu6ANzFLnct1oxVS1YmtxfU5ZN3ezVa6rbsrI80sf9hNA0xy00OAaDIeXhrCYQibiiSsaVz+EKbJyzCbe6p1GLXGyvK59DVyi5AtGGf4BI5PxHdMW7SQZ4ouFdDZX9swa/Nf9u9H5+hpXoK7GyY9MeOXrsiLqeOlGAj4S9JnCM7SZAq4d5YvPwOfDH3njjDWXjCO7ia+gdvNg6q2+E7zdo0CCZPHmysmsEJ/BvtE+IL0VQXPscDIh65LWO6uvcmQsy6OUv5fSFKBn25gQJu3JZCpUNkXQh4Ur4UcHVu3dvJfyZGE3AHXvMY+mNF9y/p4wWwg9fFP9J+5L6c4R91nM58Av4k8B6sfwlZNfEo15n5w9sOSxDenwvA/56NdmAVCq98Hnwhfkcco34LBJsxxfmvSdbhz/FhFyeJ61QfAa55rp9jueLz8H/DRJQJIkoZ9UDMkn2ONujqgdlZS8VJPf2bCZzRrsXSJqKDcpKz8+uV0QYxK99jjRZi8Z/QP7DE71zhieDQ7TM2cFN1E8vaefQdNVwD576KQGBi3jR5Rsh+X0f0124RH71nIl2WomKtFmn7EDTpi2UqNL3SwQOUYdoJILHQUt0lEOMQ41aejKKTORDUOqp0xxwGFeMjrO9aByUGCX+5LpwGBL9xBiQ5SXqauXKlWj56rOZ8nLvibJzS7QsXbRLNm84Knv/vSRzpx+W1QtFvhk6QypUqJg4nAOjgXHgfcOYEQVG/Hmz8Bx4XdZoow5QAK8JoUhmWk+mnv7zctulYPMnrpGwi8k/m2RXye4Sqf7xxx9VjwOBBa477wnPg9JsXhvXiiACnyuCE/QF83nliwnOiFqCClxb3htrfy6ZA16nFd5Dbsdr43q9MaKHVGpSxONnvMVDdeXdn3qqHdGG6wT4+GUwGFInnKO699AXnwOBhkBwhO9xHiMoCKCSgXR17nrjc5B1xVboSreQgr7PWSCDic13lp2JivR9mn6FchWV/cLnwI5yXRFQZMypyNLtM/wcXw+/hyAv9p3qLcqEyc5Sms37QtbTGQTTEbbYa4LJBBC4LVlHAuNUp1mFKOXKowb9Lb2bfir7l4bK0qmbZPOyvbJ/42lZNuFfWT76uPwxdKEExCfMWQGeJ/4StpuANDNCeB3013oDQs+6XoXXg9DUcF14DQhRBOrvn/0pUTY3Gaz8Z72cPPCf088ez5sAPxk2MuP4FFxjBDDvO59rAhFUsbG5gefL7XjPtM+Bj4Ko5Xf0NgnrBgheg7VtSlfu4TOShSf48+rI56T+Y9VUebg76retJZ/OeUcyZfa+Si8tEODHPkeay+QC2S4OQCJGRJocx1d7Mjh6krAjHHiUCXEQcp+u+l8QTe7Kkrh//rMjGCjHQZxwm+ad6sqk4fNtvVb1vNIHSPWmZaR46SLKgOnSHMiSxXUPkDfs3r1T/vfwA0q0EqEkM45hIypJJFgLJEQeYhdDzGHOz3idRJeJNGI4OIwRTFxH/ftWEHA4CezB43AlItuvXz8VEbX2iFy+FCGv9x0rhxzWAVm5ejVO9v8bLcFZSsjV6FgJzJQhyaFKRJXoJ1FWHAcezxO8X1xbPWyK56T7aziUGS5B5BGjdOHcJQk9bL/XCUM6d8Jq+d9zrVQUl7Ifx75ZIqUffvihMjwYed4TPdlTC19uw/VlejWvzVlFA4IdAazXXAG3waGyZm8pOefzTjkYDsaGDevlhcGPSlBAsMz8dbnM/3NtojCnFwZx2/7JJlKiwvWedkPaiKoaDGkRzmQEAJU+esqtHZ+D2zobBghkxWixwa44m7QM2FdnbT6OENzldxlCyEyJpo/cJaPfHCfXYu3bqpr3Vlb+ECISUaMHIkGWrEESetX163XH6bOnpE3hZipgjv3C90BI6UFMusoOW8ffCRBwbWlBwrYTFMD/4+cEZgmY615Yx7kfBL3JDuOj8Lv4K9hW/BP8Dk1URLS82+V72bne9bTfazHxsnvlKSlTtYiEX46Q4BzXs+r4k0ycRQCSIdZToj3BZ0K3Gun74f0DPmdUz/H6uA5BmYIk8oD9zLwKyI+cL72/6Kr8UN5Lx75ZfF2y5JQc4y9Qxsx1A649gXZuw/Unq0t1mc4IW/E0bRmRjIjGxyS5wt/xG2kVe/StjtL3094yc9QCmTNmsVz4L6GUHUHL57jjc/dI+bpmwGVa8znSpMgFSlg4UIg2OQoYDI714LCi+2Nd9dcQCSXK99NP9Lk6h+ysu5HpHCJ6ehjiBJHLQc0hW7leadm5zvM0PyuN29WUg0f3yZYdG9Xj0seJQeRgQgAXL5lTjhy63tviLXnyZZLgbAlRNqKeiDz6TxE7HFZaeOohRRgKDlsMBQYFof/kk0+qiCqvGUHGfZER51DkT2cZS4QVj8N9cH169eqlHpPHq1u3nvTt/YOcPO6dAd2y8bB88ck0eWdQwqRs3lv9esjwYsiYCMdrc/ee6QmaHMKORhIjT7CCg5nsNqI5f9biEnllpfjC3D+XSXDJWOXQkN22Oj+UEzO9GkNO+TU/Y9gEwRyuNxMPyTDrHiM++1QmYAgJPFg/z3raMsbW2ZJ3DD39TdyG18h7SxCCISt6Z3TPgQ+pL/bZ8TGw7ho2GAyGtAK2CrHLeesoYDhfsYvO0PZT75x3FGJkNWkP4px353NgO11hbUEh4IkAxI4gkhp2rCPL/15r67VWb1pJrkioEt/YKCp9uH9sFq+nWMW8smOVfZEbnCuTFCqZT/lnCDquCTYHsYPYd0xYINR5PCqQuPYM3sRfIFNKFpGSZ+A54hc5GxKKYMP/4r649twffa66dYog72uPDpUDmz1vdoD924/LRz1/kk//7KP+jS+G/eT6UFlFGxe7ivH7yCC7y8BzDRwr33i+VBQy8Iugs+47zpe5kFw4Zd/Pg0WTlkvxlnmVD4FfZM20EuzmM83zIJurq/h+/fVXdb34fXwffRuy2ATn+Wzw+bIGX9xNWyZRgMimOpBECKJZD99i/gn3BU99+Jj6IvBAcIYBYd5UMRj8kzRbJ4gIo9wBZ1+vFfImqsphx4Gos6yOEFHiP6rOdjmDSJu7oUYYFz04gqgY4lCXD3V9o72kz+D92xaUJVAee+nexGwkz4//8Ez1o5+C6Ge7B65n6uxQqVoule1E0PMnvbcYHbKZ1v1r2sBxcCECEVkYDF0mzPfpTSHyiPHB2LsKMgD9ybx3w4cPV7dDXBH5RPi+9cbnXgtczZIFu+TIoYSSJcpmyHRqyPZT2sR9MwGQP52BKMdA8brPnT0n21fvk+UzNsm1C0Ey86/5iWP+yfJiGNPF+R5fCsyQWUWuEaxW8cnniqANDgvXhyws7zely/QXIUj5zCJQrdlf7gcBT9+SYykywpfPiGb1oq0yafRi+Xflebl8OIMc2p3Qz83j8R6QqSdK60jmrEFG4NqcdGj3y2AwpF6w5YhNXZllxZ0TzhlO0JuAqzP7g/OPXSG46Aoez1rW6gg+hhbBZEYRg4Df8fg7nSTIRsUXe1q7DXxY2XmqlxAg2HQqvSgnxp7c09n1ACx3VG1aXFasWK520mNzmHWBr4SPYX192DFsIz4F/hxVSfyOrkri9TGTg99jSBLXWGdAnYHPh29CaxQCF8GMuMWevv3yB14LXM3WVftk68q9ifYXW61BGJLVxY5TEUflmjMQsQRO6IGln3rX6r2yfPJaObPzkqyYtVp9prjWJHPwp4KDXE/W9khsOuVzkIiwClxEJgO0VLb3/9cY4T/RF47PwboYfD4CCFafmoAE98cwLse2QfwHJlxfv1a7ZNKwmbLur50SsVdkz/9ny2lXIwjAa3Q2tZzPLMOljMBN2z5Hms3k6rJL/kORGbROOnYXVeU/LBlQDA6Ho1XMcVBSooFh4D81YuxG4T8o0ToMD30O1RtVlJe/fEK+emWs0zU5VgKDMso7o59Re2G1eCYSTG8GfSoYCfpK8uTJK5PGbZCzZ5JmId2RM2cWeb1/d5k3b7Y63BD2Q4cOVWKayDKRPAwcopcDGOjJ4EDkOmEgELf6+hGZ43uITDLhOALu9roS7UNUYsS4f0Q0Bm/X5onESsUu0/7eKH1evVcJZqLYVnhtGFLKg8mU4hAgfK0744hmZgwIkqPrw2TE84Ml/GLSwEm+EjnUvtsTF08mlKzt/Vd8JVPQ9VJ5XX5MhQHvJ4e+EvtvvZXscCeazRdBHcQot8Fo6bVaGCZKhVSZ2v+XEvEaieyP+mKSrJy5W84cTyi//mfrqsT7LVWpgDS4r6yKbHvaxWtI26VDBkNaRZ/HCCYcc92X6QlsDlVcnNecz9beXAQkNgs/hvPX2c5cb3BsD8Ie4HMQ1Cd4+e7El+XDR76UaA8zPAjAv/7zC1KtScIgLGwmAhs7QoaRqi0qjBBmU75bIYf+TRpU9RSw7zOgmyxfvSRxQCSBbgQs04oJQuNzIXaxifhq+ARUKSHCqC7SiQldkcf3EJmUIOPX4bu4KusmO0qbF9ecv/P4lECfWBsr/8oascuM31ZI9UblkrQAabj2CGl8TJ4zYlDPCtHg+xTIU1C2zt4t34/5Qy6fSuq/5SqaXVp0bSRRuS4r/2jH7u3iK9YeVoIpXF8yqZR9cw15j5nj4bhHl/eCz7mzTRAkmPAJuQ/EMdee/yN8ESAZ+cHPsn7qTjm+KyGAcHxpwtBOKF6lsFRtU0aWZl2qqifNqrsbJN5/fY40/clAbBAl4z+gLgkCPRjIEev3dD+vhswYYgtBgGB2Ng0OEM/uduGBozjRi8OJ3EHLh+tL2xdrSoXaJVzcgUjNJhXksXebyNWgy+qQR1xyWGIsOXQoK3nuuedUZHXmzBnywivsW/WuGT9DhnQy6LNHJCgooxLOlMIgnDhsOADpO0VEY8gpw8FQ8js8Pgc6xof+HA5GjIV1Dy0HO04AB+GIESPUIe8IfR8If8QZET8y1JQ2XwmPlg1r7ZVyaxYv2OnyZ0S4ec4YCt4bXidGB6ENBDXOHw+TX99eKH98OSeZwIUzhy/L2E/myqEFkbJl4zbp8EjCge4LgTlEXVu+CBhgEAgWsIYJI4hAdXffGBc+o3wOcKDI6OtIMhldnBFKnBDQsTHXZPyXy2XKD+sSBa4jB3f9J+OHLpdtC8+43cNo8MHoePtlMBhSPdg2nHrsIELLDrpfVoPdoYIIkYGPgC1whjNfxhFHe+E4KKt+25ry0Mf3SLWmFV3alsqNykv3YQ9J+kKxSnDjc2C/CXxSSsrWiTfffFMFxbGf3d5rrfbbewNtVf2/fypxBSA2jmtBNRjXBR+HrCYzR/BJENMIUMQ7r59sIWIWO45PYs364kvwviAiqXDTQXkrVD/hr+DXUGaL7dTiaum0TeILq+duSwwaOL5H+Bz4l/io2GGeG9eUsmANonZo5x9l4sfTkwlcuHgsVCZ/MlvWDN8pe7bvk3aP3CcZA33La2UvlCVxUJReRUXgn2vMdefaOgpcK3oTBL4aWWV8DvxCXjf3xReJEbLXfG/CRzNlyuBFiQLXkSM7TsiMoUtlzrBVkju36woFgw381OdIs5lc4MDiIEYgIUqJWLqDaJMWZPyHtu7a5X7IXOpMMIefzvpa4YDQZbrOQHQ47rijPIQImF5JgzBs0q6ePP9mFdm5YZ+MGTpJwi9GSu48uaVc5VKSPm+E5CqQsG8Nw8cBRIbUEaKF9ErooRgdHi4m82eekgvnXJf7huQOljYdi0ilKkVUVFkfvhhD62OwGghjQv8LhxvXA8OjB0BwkCF6OdR0L4WGQAE/I2qKkaQUWmfaKanlWhPBxVDxcz1V8vJl79fxOBIWGimxsdckQ4b06j2zvneIW5wJrhVikOtPXwgZ3W+++UbOnwyVbX+dk6grrsudEq/LvkuyYVKAPNMrr9S4u7xsXpZ0ob03PPXaQ1K+Rskk15ogA9lvnpt1IIY7cFb03kQ+dzgfCGCMN1ldghVTR22QI9s9L6eH5dP/lbEl5skTL5mVQHfCYnaDwXBrwWbha2ATaS2xrsqzO6TSWqaJfeX8t7Y6Wf0Wx32mVrDJjquFtH/D9/k5lUqVGpSTp17qKod2HpHh74yW8PORkjkoSCrVrCg5K2SW9DkSAqgE4/GtEN7OXj9ZZ+4zU6ZAue+FKrLol91y+ojr9qRsObNIyycrS72WlZUvQIAcgYTvQIDXeq3wG5jSq9uC8A3wbbDXWpwTZHDcfMH9YM8JrhOoJ5DOe8PrQUDTX8pAKAQdvo5q82rXTiLCozxmt11BJV7YpQiVJSWzSYYYn8wa0ODf2HYyp/iX2HeeR3RojCwftlUiLiQPqDty/shlWffDLun1bGZp8r8GsnB8wsYHO3R+rZM0uu96ibnu2dblwpRXewsCni+y/PgcCGB8DtrdqKqcOmyB7J5/zKv72rZgr4x4+Vfp+81Ttl+TIW34HGk6kwv8B2NgkV5M7Q59eDuCcKVkxlrmQtkM0SpHnA2OsGJd7G6FIUAMbSCiyEFHjw5Cceve9VKzXTEZNuVtyVntquStll7yFc2lDnTEIyKT5+Uqs4wwpT+Fw/SZXo/J6+81kXJVY6V8xXwS8P+fDmxDlWpFpU2HojJ2ch8pVCRYiWfEt17kjVGxZrYp8eV1YlyIvDIFETGM4OY2GGVrkMAKBz4HKBBhJVLNMAYEJf1Hv/32W2IkFkGHcafXKV0633sveI265AUxi6gFrjHGlKg2oo+DGeeE18NnBkO3Z5F3Aldzat9FmThituStYH+MfaW6pZIIXIIeBBswEpRwUUbtC0yuJjqNsafXhSEmOzYc8FrgaiZ8v1AunLF3G8MNRlTvsMiqwZCWwd8gi4td9JRl1cFVR/ABEFzW/kjsvTOfg2o16w5YRxCO2GVHCIAiFLEvuiwVNu3eIDUeKi/fLPhEit4bIoWa5FSlsdh17GGPHj1UpZu1r9IK5dYIT/yDbj07y2s/PCJlW2eVivWKqYyttsdlqxWVZk9Ukl/XDZQSVfOp18HtsP1cO8QuLVwa/AAel+tACTdikOuBwHfchuFY3sp7otuUEGD4b6wQ/PTTT5VQpgdYbygg6ECyg6C9p5U1ntC3x+fD97MKdv6Nz4H4RYDzevCLCPhv+XuPVwJXc+7IJfnh7V8lpNr1z4u3FC5bUBq2v/4Z5DOrV2Rqse8LvFdkdgl68Bmjemzr2u2yZ2Hy6j13zBy9SA7v9E4UG9Kez5GmM7nWkeWISE8RT2cGiagfpcSO2UgMhHVgj7fwGM76CyhbIeqFyNM7YRE19GWQ+UT88hr0gUO2U8OhjVEkSuasT5hDkwOG/og6dWrL+fPnVO8mvZmnTp2RkiWLqd/hgN25c7sSdwhnjAyZTRacf/DBB7J88UoJuJRDdq7dL2dPX5DAoAwSUiyzvDToefl76iR1G54vhzfZbK43q3qcwe+SCf7jjz+UAOP+BwwYoMQ4z0Ov6QECDAjP4ODsqoQ6Ksp7wanJmz+77Nq1M7E8GqOuy8kILtBrjYDEkHMt6C9BYLMm5/Jx+483ZfQCmbhtqESe/lWWT70+dMId2XJlVf3YVnif+ezhDHFNb3TIApF7+qi5/tsXON/p6Ck6PXvCGunS12RzDQaDwRECiUwDxkfg3NbVNM4giOnYI0pQmSAz9toKNoogrLOtD+7sAllVznxnIgQ7SBCf2R1AOTABX4L9+BMEpLXvowcQ8ViIQJ0FdSaCyPKSLUWwVqlSWdo91kwJcUTroQOHpUbN6lK3Xl31WtetX6sqq/QsD8Rznz591GCjXdv/lb2Lj8rmBdvl/JkLEhcQJ3lK5ZB+nz8nG7atV/4JwXeeG/4KvpqzrQ2A6KaUlhU3vD56TBGWBOPxC6xrCvk5Gd3DRw5KrnzZ5aIPgd0s2YLk1JljsmHLCXXdCDZo3w8hzWPgr+k+XD4rVAnmz11Qzu3yfn6KZv5vy2XSydFy9YTI1G/nenUbhje99duLST4/+J1kuXmveI7O1mnagddHuxWl5REH/5N4H6rxpo9aKH2+fvKGnofBP0nzmVxdCkx0EQHmCqJ81kNO42rYDocCBzhROKvBupEGeQwYpUgchkwqJMpH9o1hEwgw66RdjI91ah1GB2HoTHjzXMm4YnSAAxfhzPdErilRiZHgPhG+XCcywGSHee1REVfl0NJw+fXNJfLTB1NkzdztcmDLCfl3zRFZ+edu6VrzbZk/ZrP8r9PD6vDGKFJii2DHYFpH4PPY3C/XGwNHdBangGgqj8+ACbLhPFfrtD4ymVu2bJLS5X3rCa1QOad6fzm8EbG8Pv7UU4z5fOiJk0BPEJn94YN+8ymiFXnpmvz87QRp0qWCtHzE86TJ3AVyyOA/+0iRMvkTv6dXUehss7tovTdgtCkH53PS5O5msnt9wuRku8z7KyELbvANf550aDCkdXTbEdVO1uonR5ztigeEo2NQ3WrnEaY3C54nNhixOGbMGGUfsMcMdCKTZ23HYnKxdUow9posNBOCnSUIKHGlN5ef8UWCgZLc7DmzyfETx1WAm4wsWU3KdSmNxd/CL7kaHSPHFp2Xn3pMluF9xsjKqetl9+oDsnfVIVk1dos8Xvx5+enVifJklx4qG831wl+gSgl/xrpdQNtSBC4/I2NL+xPTmHn9JBXwkXgdukcZCE7gY5Wslduna1u+fkHJGpxVvS78N4LU/KmnGHOdqVDTcC0px/6m/0i5dtX+3uLYiGsy+uNfpOqDpeXBl5KWa7sKqn888y2pUO969SK+H0F/AgL8Xa+69BWSRAwMw1fGl9w+f59P97Poj5USG5N0lZLBe/zZ50jzIhcwNkT49J5PZyDIdLmOhowk33MlXOlrZLCTxnEhuiMcYM6ENCAuGYiAOOTgw1By/85KmQCR6jiIAqPDQerM6BBNQygSYbaCgNb9E7wWMqaIKQQ2w6TCLl6R1x/4Us7sjpRrMc7Lj6OjYuT83hiZ+NFyyZQhsxKsPD9KdBCT8+fPV/dN3wtiGpFFfwaHKUIXI8fvUAaljSnGkAw8UV1+TlkSxqxQMfuZTAZpvdivkwog6PeSPlyEowYxaS2NAgTx4d3OVwp5Q/4cRaTx3Y3lta+7y9OD20qdVhWTrYcqXDqf9Br0kIxc8q6UrnK914rXTEYdp4b3zLHHyC5E6DH09EuTxb90Lky9b75w9tRluXbN/tJ5g/+XDhkMBlHiAPvsGIy2glh1tO/8LmLQ1fBKbDJCToOIJiPrTki7GhjElH4CztjB7du3K8Gny0udgTh0XEGHDWf3LJVijhOEsbUE6bHdiEjdvkR1F0MlEfgMecLOUzWFj4DPQw9s//s+kSMrTktMpHNhw8DE8zvDZMwLf0lI1jwqMIDvxbWjeo9KLAQ2Zcg8PvYe0U2lGL4R5dDjxo1LzGDjqyCuEfEIbYLw3CfXr0DFIJ/Klnu//Zh6PO1z8Pz0MEtA+DmumuK5793s23BNyCrZVYD++S+flPen9ZM67auqLRxW8hXLI0999Jj8tOurxCnZQDKIikD8L1dre+xA4IL3geuKT8n7evF00s0W3hIRFiWXz7leoWVIuz6HEbn/v6cMB1/vznUGh5m1LIOoH//pKaV1BcYF4aoFJUbD3VAgnoO1Nwbjgujji4OV8hwOGCJoHMquym40HJ6OhoXnRORwwoQJTn+GoUJM6+eMkeJ58H1+n6nMRHQpjcYwffj0aDm40zuht2/bUflryHJVVkW/C4YeEcu1JQuN8OU+6T8h0org5xrTF8NURmvJDH/HCFIy9corryjxz/tTvmIhyVfQXpTziR5NJFdI0nItx911XEvKlxH7iF0+Jxg5iff9v9DB/dedmxqNy0v3AffK2M2fyNBpr8qnf70kXT5oKqOXvy8P9mohwTmuDwbhvUH04zzwHLluvlYI8DkmOs97Yl08fyMiVUXmfRwAZvDvqKrBYBDl1CNYGXSEgHR1NluHTiG8ED3uKnZoN8FO61YbspG087jC8ef4K3oyMqKSXbI6Y8l9uxK41se3VlhZ974idB0zqGSCeXyqpHRPLPfBa8Ufwcaz5x3BqYPQQ3p8L9uWXu9fdceJfafkhxfGSc0aNeXzzz9X5bX4G1wfxD3+FPeJuOR5IzrJLuJr9evXL5ldpQSboVcvvPCC8pPwOUpXLC75Ktvr/OvwZBMpXq5gku8R8GAApBXeS9q2EJcEHAhou0omeMORQ9er0Wo0qSLt32gufxwbKV+v/FC+WPCedPv2fvlt/7fyeP8HJVe+pAkXPhMEJUi48F5wLXyB60z2ls82pez6GsfdYGD8Rm+flgnwY58jzffkgt7NxRcHn+NScGdlxvQlEBFzNkHZCkIOQYSA9gRT9PQ+Mf5EyBIt44DjACR6S6aZ38M4eoJyF4YjsA7ACuIRo4PQJXNnjQrzfMm0IqT1Pj7KlegHZr8dBx29QPTwfPf5z7J9tb3yEqYJR5xtpzLHGC5dvqzFFeKS18c1wND9/vvv6jlxwPM7vBcYZowlWXT6ZjhsyaojPulh2b//gCyafVKuRub0+HzKVQqS0IjtMndu8onSjmVfPAbvA8+ZQx6BWbFqeVl9bJv4wrWAmCSOAH0/GGG9VuFU2EGnvVQ6iso1oLyK6Lqv2VuuMZ8B6+Nwv/sO/CsB6QJ8EqtMw8yQ0fU6AUPa3VlnMBgSwAZy1mJLacHxBEFVtZf1xAmnAzA1VGSRneR3nfX0WiFoi50naIrw0y07ZGSx+/wb24Cf4+wxEXl65yzgaxB4dhyAiI0mC8uaGISS1WdCtPNY9JzqadNUc40dO1a6du2qggDYOOzuL9/9LksnOR+i6Yr9mw/LgbXH1GPS5kTgnsonncGmUg1/i4wxQXXEPT2iZNoRv2SYsf1cAwLKBNwR4rQr4QPg25199KxMPLVI4s86r8SzQnlzVMjRZFVzQCuaNbOOr0OlIdeHTC8iuFrtKrJgm/0JyZAxa8YkrXoI+uwhwWpyNpy+ekLSO8lK4xPSD62GnW7dqj5bvmZv+cyRvbX61Fz/nbt3SMagDBITZb/sGH8je+7kfeUGL/Fjn8OI3P+HaCWiBgOBwHI8eKxrfyjZ5fcQYxgcSlldgZgcPHiwW5GLkUBw8Pgcngg1nTXmPz+CkzIkDl2MIT/n0CX7ZgVjaRXdlF/r6KgjZE4pCSaLh9GxDp7Q6w0QdDwfDt3QS+nlg3fHS0hIfgkIyCR//bFaYo76Vs46fOBvUv+RkqosCWHH68eo6p3FGg50on78nAgzhyLPk6ET+oDmwET488X3iDxzkNIzdOpYnJw8GiCnT0Ukew5lyuWRdg9Ul5b31FCHNq/TMeKNg2A11vwOxldfX96Lph3ryOpZ9kVuhsAMUqJa3sR/67VFnsDg874gijHGvHd2IUNASRtBEEqTiRRTAq97o3FYiHDXa7Zf1i7yLmJupVmHmrZvY0gbBsdgMCSAaEBY0f9J9tRaKaZ6PS0ZW2waZzLnNa1T7kQuQpMhje6ECGc9gWPui/Oe2+jMHEKGbCWtSjwPMnf8HDvhCJVs1kGQvAbHJIEGsc2uXLJ4vGbrrlr+/csvv6j2JcQsz+HqpXQy7M1xUihfUQm7kkH+Or5IgmOcl2l74qcPxkmdZ8pJ9+7dVWUaPgXtPmRj+buuXMOfwBdBWGLfEbj4FWSTEb6IYLLpXBN8Duw2u3XxGR/v+rj8tzdcLuyJkxP7kre9FS2fV+7pXE/aPn63GrqpA/VWCCjg3+nABNeX90WvFiLjfW/XlrLgZ/sil/su16hEYq83/pQ3O5Txy/B9KCEn0OJLaxR+nN6uwXuMP0flos7s83xI3LR6vLHMHrPE9v3f1aG2WsVk8JF4//U5jMj9f8iacuDrnbHW7CaHoZ6AqAdFUEqjxak7kcuhz+HCYWotbebwxJAgOPgd/uPzPcSzs8FWiFXdB4sw5Hk4TlHkIGTQFdFGDQaD5281KBoOFoSmo9EhasjzoR8mNiqPzJq2Q86fxQBGy0GxlNPExUtA3hyS7kKYBNgoFTm85ay0e66ubNm6RUUniYxSBsXjcg344j3AAWB3MSKU6833ORQxvBh5hB6vj1Jq7odrSUT6ww8/VBnKHDkuyt3N80quHMXl7OkoiYy4KlmyZpKadUpK8RLXrwdrish4E0SwDlLgelqdDQ5oos28RxhAhGHlSlUkR55g2/0gjdvVkOq1q6osvZ5EyXN2B4+J8KfEh+fK585dlN4ZfF55TIw415Uv3neqEnQ0XtOuy10+idz2XdyX0RsMBkNah0AzZ77O3Fnbhwhi655Hzn2Emd5DT3DdHfgEBIMRRNYVQ3qCL74DdgO7R6DYsQRZT8/lcfS+WJ4bNgf7a/WNqGiiUs267QDbjAikpcnZc0M8UxlGBlXv9CUgjw0nu5k5Jq/8PXKJnD2akN0+Ktf7VIXtEzlzSBwBYRs+x4kdp6V18F0qM8rjEgwn8YAd5LXxhTjHx6KyjGw0PiG+Ge8RWVvsLdcVnwN/hH/jAyJwX3/9dWXDQ0IuSuGHCkt8ZKBEnQ9Qe3QzZ80kleqUlLLVrvt/PAeywI4ronTrnPY38Q14P/BBeCx8jrhqcVKobH45ue+0169fPWaLynJfp3tUMgW/yht4v3lMMq/4QmTBrZ8pb+A14mdwrfE9+OL95jk4ljx36N3KJ5HL7QwGZxiRa4GoHAaFrO1ff/0tLVq0koyWskuMBAcaGVDrwm5PEPkaNWqUyujyn53IJ4c9RgZhB0RVHXfVkcFFaPE4I0eOVD24GBO+R6mxdXcdEOWlvMYqcnkMyltdTWO0Gh0ixfQMc4hjDI4dDJQFs91MaqScNVsWuRYUKOlPXZCAWO96YePjRGKjEwwUQQWuJ4Kf543Rw+A8/fTTasog4hvDg6HVhpTsOYaASCqlVkRYeW8obcb4cDsgsPDWW28lZNKbuO5LAg5cjLV1TzH3TZBBi1wOd4IIXCsisb1791YC8fiWMJk5yvsSKoZLNXqwinICiIxiyHS5vMtrFh+v3keuFcYOJ4KAhycw0FwrrhlGFUeCSDGfIXePx7U7cnaHVKhVTHZvSton5I7mHWtKMcsEaIN9/Hkxu8FguA72Dn+AIOOI4d9Jq5atJTBTQkZXn8/YP7vloV26dFGzLPjCj+A8B3wbLZbJ0DlWg/FcCB5TpozPQtBX+xPcB4FnKr00CF7d/6tB/NHW5EzkaqhAopoIIc3v6azi1eNZ5bevk+/6TSQgQNJlDpKAwIxy7cIlUtLeXRDO1Jh0KrCAf0HpNNlxniuCksd/9tlnVQAb+4gvxfPS/hVZbPwtMpB8Xw/zYnAVQQrtE5KAQPAyJ6RuR+dDQTX4W9hma6Ug/gSiUMPzInOMz8F7w+cAf+Hy3ij59Y2/vHvtXLZ0AVL3oarKVyIZcP1yJl81RTJBlxLzuFQj8t5wvfAVPcHnAV+DjDi3wW+jEoChX+58Dq7dln0bpG7barLeRnVczRaVpXqThNY6g28E+LHPYUSuheLFKspHAybIgT1hEno5Umb8OViy5wiS2vWLSK2al2Tb9nWJPSN24GDhgMRYURLrrJ/WccgEJSUILiJoTEPWq3SAQxVDZJ3+C87KT/T3nO3OczQ6ZEERRRziK5cckRWLvVwhkzGDXCsQIulPnJMAL8pfoHWb1qoXBHGJoUSMU67Ec0SoMz1ZG3YcAQy1FrlkbvniMCYDi+FBlHM9GGil4fcpT6K3hwACkXF3O924vhhxHgvjp4Un147HQVQT+X7yyScThk6JqCx4s4dryL7th2Xvas/XiymMr37dTS5GuV4d4dizxfXRg6Z4PghvVwvYKbcikKKzAkRKuQ8+g5988onHPbr8LvdPSTTXv03rCOnfdZQc2OV5uFjNRmWl3+BHPP6eIe2WDhkMhusUyF1Uvh34qxzeckEunA6VpSNeleAcmaV8/UJSrfxpOXp6v7KRdgcLYrOwibQdIYqcBbnJqOmAsGOZMvbGsV1Ht0N5Az6KqxVIGsQylUUIXYT0rpXHZP7PzodwORKQPr2kD8kp185doCzOq9s0bd5ULl9NaGvCvpE0oEeYBAMCEh8BoQv8m2GWGrK62FyuESKUL64fgQLKlTUkCZ544gkl4Mn+4sdYVzs6wmMichGFiF7Q/hoCkaw7lXi0XxHkRnyTXa/SsqxUv7+8bJ26x6vX/tyX3SVDoaSrGp35Atw/4pTXwXuDyOc9xHd17LPWIMLJ9pLw4X519SL+ywcffOByereGzxn3j4/LvJf2ba/Kuw8MkW3Lkm6zcEa52qXkvfF9vboGhrTpcxiRqwTlNRn2+SyZO3Nrsp+FXo6SxfP2y5L5I+Suu4tKq1aehxkBhxOHFBAtRTgSMeSw9AYONA5VBAuH5WuvvZbk5xw+TCtElLo7RK2Tgh0zxY4gojjYLl0Kk9XLWAVgYx1PYAaJz5ZZAkKT9786wmClLMFB6lDjgEScUoaLsOSw5IC0Rq5r1KglQz8bKysXhargQ4aM6aRY8TzS7v5aquSIYIBe9o5Ao/yH/hFdmkRggt5jrinfd+yDsULEcdmyZeo5UF5DcILDGwHM8+Uwpr+E64mx5FAmCNHg4dKSM1+w7Fx8XK6EOi87LlA8jzz38cNSr2UV9XwR6XweiBI7+1xgiCk5w3AQ4eXxEeBkljEgeiCGdSIjEWbd04P4x1nBSSIo4AkMN59bPnc6GJAtRxZp0b2kpJ8cLcd2hknklaTTMSF7rizStvNd0qVPazNw6iZAoMjbYJH1NgaD4c6As/unj6fJP6MXS5zDcL/wy5Gycd4B6TXvY6ncqKgM/t21vbJCEBaRir3gvMfeEyB2179rFTo6kErGFrtHRtKxh/inn35S9pqyVXdgl/ElHNuvnP0eftKa1Wtk6Z9JVx56I3TTZcksceHJh0Y6kilLJgkpmFMyhAeoqib8JqqxdBsUr2ngwIGJv9+g/l3yXt/PZMvUM3LpbJiqvipYPI/c81gDqXdXPWWXKa3GRlPaTPKCdjTuG6FI8GD8+PFK7JIVx69wFWAmi4vtxfch24nfwvPDbuPLcB1pV+Pn2GUyqwTZ6z1WRfIVyS1rJ2yT0PPO26XyFA6Rnp89IS06N0pMYlCpxpBOXbFmhQov625ePj9kWEmq8MVniyoyfFINyRleHz4JbWb4WQh2awm7uxkj3BcCWvux9Na2f6uRRGYIlVObL0n4xeTvb5bsmeWeJ+6Wpz58RIKy+NanbUgbPkeaF7msSvngncmyesVet7+nsnnLjsrQwdPl9XecT7Ol1JmMH5EpjABigYONLC0ZWTKVjoYDOGStByBChsMTMcVwIUpfHCO53D+GjMyjp+wyv+eNyNVGp9+Ln8m1a/b3zcZlzyLpvBC5bR5vqEpa6PEhSkm0EzHKAUwfMBFexBvlwmN/Xi5//7lOwsMoibp+sO7cdlxmT98iZcrll0zZjigRyiRGHQHli/vnehNJ5BpRGoQBQpQScND9QI4gOMnQ8h6QCeZ9zZkzl8RcjVX3Tw8xC+J5D3AqONgxaiEhm6X/l8/JosnrZdnUjXLm5AWJvXZVylUppV5znRaVEt9nDBifFf50tecWo6lWBly7pq4Rhg6xjlHEmHJfGCpn++q4b7LOjpOTncF7QMSfMjbHvYwY8x07t8qwce8pgbvon03y7+YjEhkRrQIVNRqWkSZtqyeW2BluAn4cVTUYDCJfvz5B5k1c4/H3dq48Jh/1/EneH9PT6dRbbA8iCHuK2EAs6CwqdhR76m6FkAYhQ6aWqiHafp5//vlkMxpoLcImIshcVRJZW7+wP96A3Rn06lC5esX+IRaQJbOIFyK3+WMN1T7Ybau2qcwts0iY2IxtZUMDwWr8A2zrPz8ukYnD56td8SLXhfeuDYdk4eT1UqxcAclSOlyq1q0qvXr1Uj9DmPJFUoKEBO8BYnThwoUqeE/2lffBVQk3QWz8EoILtEFxX2ruS3SMqsaih5jtFth7hCE+JUGHokVPSY93u8jmubtk4bjlcubYOYmIjJCyVUrJPd2bScP760j6DAmBZ36fdjt8IUSyM5GrJ31zjcjo45Pht3JdSCDgS/Aa8Hcc/Qoy0mS/aaPylL2lIgDRTWKC62SFxMfCxQtl2NSP1LqkJZPWqKxuRGikZM4WJJUalJWWnRtJ5mDfVhgZ0pbPkeZF7p/jVnsUuFbmzdomlasWlbYdE0pLyPJxkHEYEOnCsDiW6CAwya4hiJxhXdejy5Q5KD766CPVW8P9OgPBpnttPEGUDIOIoXIHojn0AoeHD5OTAzNKfGAGCbga67Y3JGPBSHXNEHYYBQwnDBs2TJUCcy24Vq+/NEa2bnRfArx/72lJnyFIHu+cEO3m4EWoIUZ5vVokYmCIUnIIY9AYMsahzGGNEeG6k8HFMGOU3nnnHZn+z2yZ+fs6WTZju4Rd+J2ZF5I5a6BkK5hNrlyIlbMBZ5WY5j3XkW2iim27NlZf6vnt36/Kf+o2qZzkeeOQYKgIXhDkcAbRZUqtKX/CwBBhxQC6i6Lr7C2lWO52MgPXiEgz0WGuiaPR4pqMHj1aXn75ZfUzRG37JxqqL0PK4c/9MQZDWgdx643A1axbuFP+HDFfOvdNKBfFniFWsFXYdfp5rcOgALuKeEQ0WXssrYFNPQ8EO6BFDaW3iA7dc+oIpc+sk/EG7BTtM67uS4MdvnDQt00NZHMDMgVKfHTSvmBHclYOUlVYZBy5fmRMgVkniF3apbhm7/f8VtbPdr8W8eje/yRgv0ib1tdFIv4FX7T7EDDGL+QxSCzgz2Ffsd8IWUQmQQDeF+aAYLPxTRDHi+YvkfGfT5HlkzbK4JM/qfcmMHNGyVEqSALCAlXig/ee4Di3wbcIDAqU1l2bqC8gAE6A/+42SSsA+Iw47il25nOw2pEeY3wO7odSacfebSs6e0uiwrqFxBX4WfjLfM4cP5e83uHDh6uZLPjRuNJtujVRX4aUI8CPfY40LXKvxcbJtL8TSortMOXPdZI95Io6nIiqsTTcXcmw7qtEPCGK9OAHDcOMdCZP70ClLIiyWnfDG/g5xomDDsHrDg53jJOrvgrQK4rCw3wzOBCfIb1bkdvk4aryePdHEgWVPnTZ60fmUov9vTujPQpczbVYkcGDpskPv/SUfAUS9tTR10u2Vo/eJzJKVpIeGqKVXDsMEZlRyn3pCSLSqdcDTRq1WH77aqnExiQdphV55apE7hd5vv1Xkr9UkHR/q5Xb6dqUivEaEdWOZdL0yRK15LODw8Jzw7BoMFb0UvFFSQ/OgjuBayd7S8kR1wSBTjmVM3744Qf1WdTOkMFgMBhujKk/JV1R6A0zflkuJermkPPnzyk73bNnT7fnMmIFwaGzuVSSWUFwYe+sZcrYQmyw7g11JXIJhFs3EVhnR1gh2EzG0NXQS8DmEXgOveA5G+sSD/3KtTpUlqf6dksmqMiA6wGgcGxrqEeBax2e+X3/KVK+SkkpWSmhFYhWHwL22r+jZxcbi3+Bjcf+I4SpzkP4IgqpnMMPgLm/LpURr/wu0RFJBfvVyBg5uzNG+jUbJHnL5pBHBt6bWJXnrLeWyj0y+3rVpRVKiPElaNvCb8QnwufU98HnhmGfCH9eDy1Z7gQu2W/ux5vsLX3OBF3wRV35MQhsrp9OfBgMN0qaFrmrlu+Rc2e9G6Rg5fChsxIQn0vat2+sBJMnQaFhoh/rbRxFLnAfHIr85+bgIDrmrAyZQw2Dws+JhpGZZXgCBzXfQ9zxp+PqAOCAcQWRXTLK6qAKuIGl2m6iOzXvKSlvDeud7PuMpifbTQkwREZelckT3Ux1dkJ4WJRMnbxBer6QsA6Bw9taUqUjrVwzotVECTEuGBqy7ERUiTojcn8bNlf+GL7A42OePhglM0ftlEaNGrot16Ukh/cUx4LH0+U6iOxvv/1WPa8RI0aozKsOdmD8dbaXiC/Xx9WETTvZW4Z86InRRJddQfAEvF01YLiJ+HHpkMGQltm5/qAc9GKInyMXzoTKuQNR0uGJ9kqoEMz0JviIoMCuOopcbA/ilEAqvgLlyvSoUsHkiJp6fPWq8iv4ovKHCimyivwbW8sXgXbta2ifCLuHrbX6SPp3eA38HNKlS5l2l4rNS8knk99NJnCZg8Fr0H24tK396YXNt0Ip8eRRi+W1YU+of/NarG1HBAT44tp98803qmoK/wIf4IUXXlBJB64/fsjU7+fLd6/85vExz+67LDM+XiEtWjSX4JxZXQ6Qwr5j67Hj+AXAe0XfNs9DByDwN3nO3Af+D/6j3hhCMMPVNGVr9tZTGxwVYWTRaQNz53PQJ8znkMo1wy0m3n99jjQtcrduPuLzbQ/uOy+N7k6Ypsd/TCKgWnha/9QDA/SkXspXf/huopw8fkWio69JYGA6CY88mTjZEEFEpI+yXQ5hcDQclNcSGUTg6gFUZBP5NyUyCCPrGiENBxoGynEQBcZK94wgpN56ebxcPH/Ip+vibI1QzSYVpFzD/NLhiaT7+IAD9ccff1SlOvr1LZy7XSKcDDjyxJyZW6T7M00lMFNSo6ohOECpDAcz0VUi2YhJ3iMOeoz814N/kjk/7fb6MXduOCRjPp8lz753v9vfo+eGPl/eYz4rGDsyzYhdJltjMHSZO88TUYtBwDjwZZ2CaQUjRvbdm+wtQQ4MGZF1d1OmEc2sDmAyouHW48+lQwZDWmbbKu8yhc44sithmwI+BxlCRKUznwN7TgmwFnYI0JFf/iqnD4TK1chYyZgpvYTGnlVO6oqVK5QdolWI+RPYGnC0JWRprT4HNhuxjR1DRFFFRLDYEWwtj6/3vlrtPoOZ8Hc6d+4sQ/uNlZP77FfVqecaH5fM367UsJzUe7Ca1O9YM1kvM0Fjgsq0/ujs49r5O+Tsyeurdbxl+fTN0mvAg5I9V0JSwVnLD2IRsct1YCcxPiB+AFl2sqDff/GjTB24zOvHPLLrhHzT52d5+/cX3W7NYBctQprqQXw+3j8EKT4HmXvQAQiuCZlfypTxO/k7ZfDO0CsJvcne8jnFx9JtYa5AkP/222+JiQ7DrSXAj32ONC1yIxzKQuywc+cemTs3Uv3nRByRndVGgD+JzmGE+E/OYcq/p0/ZKHERteWvcY6GLkCOH9glD3e+V9Zu+EeViXJAeQuCiJJnDIqzXbkaSoGZ6msVuRxulClx2CGUKGXJU8DL3XMOBAZFS81HQuTKmThp0rip6uFc/+9yeeaFh9VB6yzyzPNB0OuSHVi+xHuRaYXJywQusueKTey50WUyBBow1JTv6N1+CHsOdQyu6kUODZX18+2L+3l/rZeu/dokMWz09yAoASPCkCvK2hHZiFxdAkRpGO/fqX0XJfR8pKS/vFZ27dsqvV7trn7Ofegl9FYQ5iyJJ4PvaoCWNWpNHw/RW0dnwxGMJg4PqxTcrX8wpCB+HFU1GNIyEeFRPt92/56DSoRiT7CnBEOtPgdtJ5ShUmZKBg5htfCvdRJ0vJxMXbgx2f2dWLdE7nuioaxds1ad+d5M4NdgS/AztBBy3JWrocXGuvdV2xiqz3R1G4IpuKh3a4AcyZA5Xqo9UkJCj0RIs7tbSOasQbL/7G65+76GSkA6myzNPBCq5KxVTytnXZ8obDebu3bBDqnRrJQKZGso+6VFCRtKMJ1sOb7WhAkT1NAr61rCdf9sl3iHCdueWD5lvZw9fiFR5HLfvB8kXIDv81lgMBailMcnoAAM6aRU++LhMDl54D8J+C9Idh/cJd36Pa5+TqCE2zuWFBNEIRhPMoTAvDvwpcgYU9LuOFjKGVS0kcH1tCnEkELE+6/Pkaa92KDMvpfIVKxYTtq0STjgiXzRx+AMDoYc2XPKJwOmyJKFu1ze38UL0TJqxGKpVrOCZAt2PmjK0641RK6zXblW+Ll1fx0Cl0EMCGCyd0Rn+736hKxY9IVEXLEndkuWzSSPdr9fCaqMhSKkdIVi0qDds+oAc7a2hygjJVO6J8YqVn3l8uUIOXvhmMrMkuWkDBtj5ngo87hEMyndpe+UKOOpI+flwjH7GWSmDo/8/A+JzHRCGRuimxgCZ0MYENl8XhDaObOHyNoZe2TS93Ml9GzCVOr5kmBs1//9gdzbpZEcOHc4WamZt9lbPgeUMfNYzgZLOQMjzPNGiBtuD/4cVTUY0jJBWZJOLLZD6bIlEyt6ONudZU51xQ6/9907k2T6r8td3h9B1YlfL5TilfNK7hDvVhtqaGMhSOwq22dF79fV8y4IbCOk8Fewv9jn515/Ulb8uVcunPJuIrMmX8VM0rPv08qPyVQmXoqXLCD3lG+qhnY6bgoABB+203E2yY30BF8+H66CDghn/DDENQKRiimrzcX3YkuC7pEmOHHyyCk5uzPU9mPGXYuT7wf8IpnKxSTO9UDEOktuENgmuE4GuViRYrJk3GoZ//nfcv7oJfXz+ZLQmrT8h01yb4/mcj7zSXnwsaSVaQTiEdAIVnfZWz6XPBYBGDK93vgc+ENcLy3CDbeeAD/2OdK0yK1UpYhM/3ujz7f1lm+/nONW4FrZtvmUfD1klrzyluthDY5Ur15dHZxEUx3H/rvbX0dUjmgi38PQWIVo01ZFZfZU77OaFSoVlpD8R1V/Lf0mHG70WHDgEdHDqOjR97o3hMcn48ohZxXmV67Y75PWXIuNkXXr1ynhjnjW/SjOILOMuB08eLDKJocdzyDx8Umjzt4SdiZe7upU1+1gLw2/M/6XibLox3/lxIGzTn/n3MlLMvaLmZIrfzZZ03CTtG7f1Fb2luoCrjdC3tV0bmfDqKgI6N+/v1e/b0gh/DiqajCkZSrVcT3ExxMVaicMUfSGsUNnuxW4Vo7sPCufPv+LDPw5YR2ON2B/CODT2uKp6gz/gmArgWd8D4LbVL5hf61CtH3PBjL244USd827w6xomfxStlFm5cOwAYDAPaWxZLspB8b2k93E56D/ly+EOT6HLsvWXLh0QXwmIF5lq6kII0DsbsIwGVWGYQ4aNEiVh8eEpJOY6Ok+Pey5fZelU9fmyh9wVwoMZJOn/jVdvnj0Bzm45ajT37l0NlQmfDZVsoVklYIhhdXQU95jenfxMT1lb2kBI8BC4IP+W2+g6oB5KFwPw20k3n99jjQtcps0rygjv5kvly953u1qJWdIJqlZx/P0N7J6ZGhnTrW35Jz9r50eqS8lSnkfXeUQ8jQ9GRA8RP6+/vprNSGRHghngqlxs7KSJ09BGTtmlVqd4478BbNI83vzyMpVOxKzlIBwpfeTEmr6hoky8lhEoD/99FMlLpky6Pict62PllMntosv7N6bMKBJT350BUIbwUjGkudDdJeMrK9ER3o/kTrs4hVZ/OMelwLXysXTYfLD69MkTmJFMsZ6zN7qwVKUQ7sb8uAIARL6rPQgDoPBYDDcXGo0LieFS+WTEwcT+mu9JSg4o9x1r3ubpokIvSp/frfE1v3Tk7pl5V6p0eh6m48nCIpjQyk5dgfiE7s0atQoJQYRpM52tDZsU11iouLkzy+XqM0X7siZP6u06llJjp46oDLDCGYdKMfnoExaD0YqWLCg6oUdMmSI2olLb6zjjIsTG6Ll4JaE9iK7nDh3SIlIx0nGzmws/hHPlUyuCviH+l61xhRmdz25VqIiomXB0DUuBa6VsAtXZOLbsyRvgTwSExjlsfeWykB8Dq65q+GYrvxjBnK9/vrrXg9vNRjskqZFbmBgBrXv9o/fVtq63YMP11f/qYmeuSoZAqYVHz3gW3/rtCkbpO+r1yf1eYJSmS+//NKtyCVqRj8K5a4MpyCyisjkyzrcir9TcsPfO3UuJ2tXnpTjR5KXEWUKEilSIoN8NfxFyZw5UOLio5UBsT4HMrY8FvdH5BKBzaHGQU+21Rm8J/Pn2Be5ZcvnlzLlCrgVuLqcBpFLZFIf3ryfV2N9/++QOUvS9QnumPDNXDl+wHuDeuVSlKyevEcG/vy829+jB4j+W16X3X5agh6mJyb1cKeUAhkMBu/BpnZ48m4Z+f5kW7dr26WxLF+RMJwIweYKzv9DG89L7FXnttUdM35dbkvkkrHzlIFDyJE1paqIKiFag5iRQdbP6m8ANvlszCF56LX6snbmPjmy41yybFFglgySo4TI8InvqmFPzNpgBZHV50BMkoFkW0W3bt2U/0HwFjHmOGVZ0+bxu2TyD4vctno5I1+RXFK2RmE1xdodZJbp0+V56iQAbV1hEb6LXPqPvRW5076bK7vX7ff6vqPDr8rMYYvl2+WfuP09Zo/wvvK6PGWTHRk9erT6PFjnsRhuHwF+6nOkaZELTzx1t+zYelS2bz3m1e/Xu6u0PNqlsZrYR/kL0UIyokzKc4x2IfjWrPRtSvHCOdvlhX5tkk0G5FDjcRGPGBC+6H/goKNUeNy4ibJ+zT7ZvvmsZMiQTkLyBEls3CVlWDhM6L1FABHhJJroSgxxv4jBgNwB0vnJSlK6VFXZsPaQhIdGqenFxUvmlbsal5Vnnnla/v13h+oL1oMwMFb0m+jDnT4O9p/RD0NJD+PtGcKE4UOYAUZC36ZK9WJSqkw+ObjfXrS7bKVgdX/0R+v7cizH5TGJulqHRACC/7thY8RXKtSgh9VzNvdqVIzMn7jG9v1vWrxH9f7kyJ18vRPGE4NJZN1Z77MnKCfnejjr5zHcBnC0bDpbtn/fYDDcFhC5W1fuldVzvQvklq1RVLq/3l4CgzIqG0ugmt5PAuyO7UmIjl2rEoYP2WXNvO0SdilCsuXMksznQChqfwPfQ++35++jRo6WvZtPyLalRyRjxvQqy5ohe6waYkk/Lr4BZaz4HAx6dDXZn8eh4gsf4v6+daVi6aqyacle1S+bPkN6KVwqrzRuW0NeermvbNi8Vr1+/BqqsRjQSCYRKH8l6K8HStLvST/wm2++qXwAXVqMH6B3xBcplU9l2Tcv32PrmlVqXFhWr1ktjRo3crpvHjHP42GXHWePECQYe2C8pM+QzmPm2hkV6pX2SuTyOzN+sLceCfasPijH952SImULJvsZrVP4Dcweoc/YLviCfIYoZTekAuL91+dI8yKXbO7HQzrLR+//LetWu490NW1RUWrUz5woPDnAyZpRdkEmkAgdAitxFUzUNbkSHu3z5Ofp02ZLUOYE4Ww9yHhcdqgyPQ/RyuMeO3JeihU4L2NH75fYGJGdm66vRypaPKc82uVBadKivHz22adq2jNDCJyVoOhVRhgNph7SX6spXSb5YUd5CiU4HFhkZ+nFYPw8ETp9fzwOIoqMMYaPTC4gqojCYmzoq0EcY5Do03np9bbyep+xcvWqd5nw2vVKSccH60tYWEXV90M0l4g3BpOhF/QEMWnRcYiTlRb3NpQF43dJ5AV7pTPpMwRInZZlZN/Bfz3+7ooZm1W5sl1iomNlwaQ18tCzrRK/x+eO10UE1ZsVQs5gMBdl7gzqMKQO/HkIhMGQ1iGb2P/7p2TYa+Nl0d/u1+bUblZRat5fQAlcwNYTkKUKilJhbCt2TotdspW+rMIBhNa0yTMld+FsSTKs/J1eUoLk2HF6NbGrZ05ckD1Lzsv0IeskNipOdsr1vtZ8xXLK/3q1ktaP1JehXw1RVUJkmd2JHgYbUW320ksvJdqyEuWSzz5hcjQ+CteCa8kUaYLbHTt2VD/XQXa+dAD4xRdfVPdJPy6+id58gVijp5hBWr0HdZLXHhwm4V4OvixXvZg89dqD8u+eXYkDrfD/aAmjPBu/iFJpd21DTVvfLVOLLZLQgzb9xACR2h0qy+Wr5z3a/U0Ltsupg/ZLsXn/Z/+4UHp+9kSS73E9CRLgS/nic/D+EMz45BP3WWLDrSPAj32ONC9yIXOWQPl4yGOybcsRNYhqxdLdEvv/kTVEcLNWlaRAkTjp+EBz9R/cMXqG6ESoIawozdFi90Y/A/R45Pz//WvuWL1ir5reHBXlPJN47MglGfLJdBkzerr0fa2NEsYYLCYC6sEPRGp5bRhJPbDJcTiDq+eIYCZ6yn1RJoQBRoDpKCsgXtkTi7GzZlmJfnIbXfaNuCY7zjXu81pz+W7YUon0sOqpVt2S8v5HD8niJQuUAeO94XUQaSTiTbSRbLKrUiV+B0FPH+vTrz4gw9+Z6vF1J7kGHWrJ5m3rvSp1Orbft74fOG7JbFOKxVANBkvpqZV24fkOHTpU3njjDdMTk5rw4yEQBoNBJGNgBnn9m25y/9PNZMZvy2XZ1E0S/f/2O0PG9NLw3mpSsk6ING5TW4kxRIU1A4pdJaBMsHvRooQy28TWqRs4C1gvU6JCIY+/t2PdARn01GgJv+x8nsmZo5fku3f/kvHfzZAu7zRXw5jwMcis6udJYJyAOH+ySo+Mr16R5A58LSqysNvM+MCfwOdCWHJfetAidv/DDz9UPop1fSF/Z2CWLjEmO40gxWd59tOOMuqdGR6nLZevUVwG/tpL1qxfqar4SGzoXbNkrQmok+F0lbWm+o8hWQz8fH3Yi/Jex6Fih9qtqsrZ8FNKpHu6Xsf2nLB130lveypJZSI+Ixlox0o4O3zxxRfSp08fjzt2DbeQeP/1OYzItVCtRnH1hVi8fOmKBEiA5MjFAZpRGREmGGME9OQ+DdE6IpAcuIyNJ1JFeS5/ZqLEyIX4dEemTBkkWzbP/ZFbNx2WD9+dLDExnntwLpwVmfXPEWlwV32VBebAosQZI0qkFsHk6lB2BQKLtUNEUhGyf//1j/Ts9YwSvRzA7dq1U7+HEOYxKbW2gsGhT1f3ZVByxG2I6rIWoFKtSAk9n02OHb4qUZFJs7rlKhSUDp1qS+s21VTJD+gDn+nCXH/2xGEMMZ5EvHU/DEKccmyeDwZWT0SknXfjsj2yeq53u3rzF80pvd/tKMHZM6uhFjyGqx4T1XN0xvOwKVfEXI1VAQFeC9fcXVbaG0xPTOokIC7hy+5tDAbDnQXZwFeGdpEXP35ELp0PUxWAOUKyStD/z3iYPHmyytwinrDPGnbaIpLwPRiiRICdKbgEP3Plyy5nT9jP5qZLF6Bu64mDu07I+91GSqQXVWqXTkbJwp/+ldb3tFQ+hp7PQQmv3ltvt5cTQUlAGj8MIfnz6J/llddeVdcIEJ1aSPKYjjvm8Tko69Zg/7jGZJrZ31u6TUaJPJ5Pjmy5JJFhSQPsxcsXlPbdGqsMdabMgcqP0JV79KYimOkDZrMEdhpBz3MAvRsXf4d1OTrzDO2fbyEzvlvk1evPnjervPL9M5KncIgS8VTDWXf+WkH4nz5lr+3LSkx0jAqw8Frw3+wMs3QGiQ6GpLp6vobbQ4Af+xxG5DohKCijBBVIOhYf8aTH5juW3fAflqyanlJMZJEDgRKYPdt/l51b7Y+nb9aqcqJwc8fQT6d7JXA1lGQvXbRLMmW5rIY2EJHzpafCyoVjEXJyday8MfZ7NfBixXcDJVvuIKnYuKg0bhAuR04cVFldrgcGDUOnD34MDoaZyCdGALFMiRHlRPTt6t2tOXOEyL495yRTpmCJuBIuHe5vqYZMabh/3gcitES2K1SokCgCtRNAL5PuXyaKSETY2XqdBh2Lyv4De+Xsfvf/i8tVKypNHisuWbMFqQw07zlRStYj8PqsmV3ENNniMxfs7QG0EnE1TL0GXwZLOYKR533wNDDDYDAYDCkL5cj5Cock+z5DFGnxwe+wVpCRwUUoJt4+MFDZcmza14fG+iRyKY3OEZJ85oMj3749wSuBq9m96bDMGrtSitQIVj2x2F4E3o1UD2WODZYjc87J81+/I1cjY2Tl4GckS84gqdyqjNSqVEdCr15S/g0ik4y3tWcX0WsNtusdsFy/559/Xj0vfI72T+eT3RuOSPr4QImKjpI2HVpIxdolE29HGxT3hR2ldLx48eKJIhD/BQGML8Jj8Zq5X3wga1ZZc1fnqrJ+wzo5sz7cbatjsQqFpGW/OpK7UC7lh3JfP/30kyoh5zOh4bEIqqsS8FO+r0e6lj5WVdbhQ+kEga+QCaZljY0eBsOtwohcGyBe2LOGgCIziTADhBL9GFYoXSHL+WK/TvLcUz/afqwyFdxncTEWc2evk1MnLtu+719/nC9DR3RVwxAo6XWFJyNEb+lHz4yWbav2Jf/Z+ShZN3WfdJ31jhStn1U++P5VVWJExpSyaN2zS7myLlHGKLC43DqgAePB7/J797UVFQVm1c3uvTkkOHsdJSwBg4ahp8fU2RJyssq65EtHX51NEiYDvGbtGvltzmcydsxfcmRrmKxftC9xRRB3W7xibqnWpIiUqJRbNmzcINkWZFaGlK/nnntOfv75Z/VcrOU4RN6JFl8+c0WemfeB7SmO0KRDbWnWLunwCl8gujt27Fi1xsmQCvHj0iGDweA99JuSzcVWU5GED+LKNiOmED19BnSTJ+cMkrhr9lItlEe7G2TEEKWFs1Yo4WeXid/PlSHTXlTrg8g4u3oMTz5H5JUo+azrcFk5Nfk++4hLUbL+rx3SdUofKdo4j7w75lWVWaXCjBJiveeVx9DZSYLfDMSimkvDTA+CBQjVlq0S5lZ8//33cuDUTslyJJ0Ss0BWlhYoKsIQ7Y7lt7wfBNXxBbS9dzYQk6A+Paq/Lf1epk6YITsXHJT107dLRGhU4u8UqZJfqt9bVso0KCqbNm9Sszh4r8lCM2OF2+vHAh4P0Y7ID3g8nXSe+JwaemmXeu2q33ASBPC5hg8fbmZ/pFbi/dfnMCLXJpRacHhZRa47yDY2a1lJlizc5fVj3N28otSqU04JaoYzEaXTBxclxpSn8NiXz/m27uXk8StyJVwkT54MqnfVFe6E2JXQSHnjoWFy+N+Tbh8rNuaaHFoRKvPHbpAHn22mypgJAPBFuZVeYcQwKsfsJCXgCFHr1EIMDwaf6YkYfX09uK+33347WX8qwQBWOXHgY+S0ESX6SrSWzC+lvxgoIp+//fabMhr06OQpFCz7j+6QQb8/Jrmy55UM6TOqUrKsljLyi5cuqtvyXHksRDnvGdlpxLbj88lSIosULJdDTu65JHbIWyz7TRG48Nlnn5memFSMPw+BMBgM9qDahuArk4y9IW+hXNKh+90ydcxSrx+jaoMycu/DTWTKlClqOJN1DR/tTJTiUqkWfdK3bN7lMxFy4WikFCmSYH9diWl3PsfVqKvyTrvBsn25+1YixP2RpWdk5leL5flhT6qhoIg/RCCCkswtAfdXX301Wak02Vn8O/wMDb4DwXfW5HAt2MuLvcfGv/XWW8kyswQDCLoz0IoAvZ4FwuNzfXkOlFvj7+B/sT+YtipEd1CujBJfMkzemtpTCoQUlAzpAyVbrqyS3ZJhD78Srm7L/ZDlx+coUaKEypSSKSbY7kixugVl/3LPO3KtBOfJIg/2SggM3CjDhg2Trl273nA22JAyBPixz2FErk0QRBxUlIYgkDjIHCFraC2Dff2djnLo4DE5cijM4/3XqlNS3nyvo+oDZrgEZaX0iXCo8UUkVw+L+uaovf2+Vk4cOy/FS+RRBo3DmoixHUb0n+hR4Fr57bPpUqV+6cSyK4QW0U++MEDOym+JqLpaLo6B5GDH+GIwiMiSIcYQ829EKq8LA8XvkWnHGFhvjxjlfeQaY4goBSbDqUupgT4ooqSPPfaYyiKvXL0pyX5fIsL015BR5j70vj6MIiKa12e9PwzZ028/JB/3+NlWpL1u+4RAx42iAyd6IJghFeLH4/wNBoM9yESy255qIISMziRawSZZByv2HPCg7Nm1X3avOeFVX/D7Pz0jwTmyqBYf7CbZY6DyCXuh+0cnD1nt8+s4fvCMVGtYVlVq0ZbkuFLHE2PeneBR4Fr5Z/gcqXp3RYnPHK/E1eDBg5P4HM56gfERCE67Al+CYDbDO/EpeF8og8YHoDQZEUxQniQEQXOrz8H7g7/FXBdENoF+bkNlGu+xhgD+H3/8IbXr1FL9u+s3r1X+jYb3BGFNwsXqcyBwse8MhrIKb/yi7u89Kh92HGYrm1vv4WrJVlj6Ao/PNWEQmCGVEu+/PocRuT5GVhlqwKRAXQJjhXHy1gP86LHD0qtvQ9mzI1Jm/LNJLpxP3peZKySrdHiwtnTu1kgyZEjIsOmeCrKZiEAElbXvgiypr+g+Xg5dIpPORK6r0qELZy7L8umbbD/myI/+kLx146Rv377q3xXKV5BNS/+VXSuOSYbQtZK/aIhUaVBGPS4CF2PgaMgpbWaoA0YSI8XBSdkQwh+jgbBEjGKYGQCh+6TdgeBjhx5lSxgthmFw3TH23CcGcsCAAfLII4+oqdnW4VxEZ3muumzaeu3YCcjzYbIzZUpkrHFUeM6d+u6XycOY1O35unV7s4PkqiA3DD3BGOGBAwfe+J0ZUgx/jqoaDAb7EGxFLGDbnIlcRJN1z/nZs2fkgT4N5EKbOJXRPX0seRY4OGcWafNoA3nitbYSlDkw0Z4xjBIRyBc+iHWS7o34HPq23B921hmufA7KlOeMWWz7MX8aNE7KPVZAunTpolqlEIZbl+yUnQv3S7rTSyVP4VxSvXkVJebIvmKbrcEC7D+9r2TS8esI0FPaTIky2W6qoSi//vbbb1UbGz6CNxV++CWIbt5LKtIYWMnj4COQ3aXX991331X3xy5ZawaU50CwnNfiCAIdoYufgq9IEoD3sUHTOvLUFw/L6JcnSJwXO3kfePFeKX1f8pWRdiEQQCuaaY1K3QT4sc9hRK4PcEhT1sJhw4HkmIWk51H3eyLMyBQykKBePVEiduXSPbJty1GJjIiWsCuXpUbNEpIxc6gEBkZIfHycnD59Tk0OJANIlE7fPyKXyCCHFocik5/lsG+vIUeO670hWkA7TlZ2VTo0Z+wqn4zdkW1npe9n/WTrxh1ycPVF6fJ2f7l8LmFU/3zZov5kkXz5hgUlIG+4KilGlGkwPkQ2EWsINZ0h5fe4zjxfXbLM3+nD4drzexgKZ5OjMWJMKCTyiQDlUKZvBOFLeY2+DQaSKLrjfWB8rFFWKzxfMsAIXZwUSosIimAwyzcsJO9U6Sk/fjBF/jtyzunts+fOIs+810laP+rdOid38Dq/+uor+fjjj2/ofgwGg8FwayFIiqDC36Cc1nFiMC07BGkB24cIQyBJU5H7n24q6xbulM3L9siVsCiJjbsqeYoGS8EKwSLp4iVerqmqNIL22DfrxGPsBnM7eFwyjDlyex5M5YrsIdcrmqh0o+LN2oqkn7szFo1bIVdcrCtyx8ldZ6R/m76yc+suObs5TDo//5xcPJkwx2SOLFd/ZsubVSq3LiNxBSOkScu7VeuTfi7YcHwCxCKiU28i0P2v+E0E7RGU/D5CmaQBfgHJEGfZYn7vm2++UQEE3jP8BwQv2dzu3bsn9u2ywQMBzGolb/uW+RnZeKYYk9Hl9vieDObMXiazfDr7Hfmu389yeOdxp7dneFe39x6Rh/q1u2GfA3hd+GRmRaHhdmFEro8gWohQEV2tV/suObjlP1l8Zb0EZQmUsAvXl4nTD8LAIQ1Z2qYtK6kvLYiJajZv3l5FYz/44AN1YL7wwguJQwQ0GCDW62Acpk6dKsVKZJFtm+0/95DcwVKl+vUMJ4exdX+dJ7at3uvzsvlfv/5Ldi45LlfDnUcTL52+Imun7Fej+mv1qid5CycYFXpgyNjSj0uJOMKVrC4HMQGHZ599NkmwgUOV3wWcAsqCuNZ83ypUyQhzX/Tn6AguRgLDxnuHM4HRp0yJnijHiLknuE8yukyKpkQbY0mWWF/rhvdVl/mTV8o/YxZKQGwGyZgho4Tkzykt/1dPLlw7Jq07Xl9VdSN8/fXXakex6Ym5A/DjIRAGg8E3WI1Dlg6fo0XTlnJow3FZdHGFZMqcSS5dvN4KtXjx4iS2HBvUoHVV9aVFFu08TMxltsjnn3+uxNiLL76YpLVG3xZxS5sR/k7uUvbW/Wjwi+o2T/B5gKAzz0EPoEz8vaAg9ViOQyG3LvV+pokjP3z0sxxYfUwizzkPRoedvSJrxm+VfMXySO8eVaRYhcLq+wytwm+gFBk/AIHL9xD9XLdXXnkliT3FtyDLyxe+BhVeCFmut9WXYxMH94Ovp+diMNyJ183j4Z/oqdD4HQTraX/yFp4HbV6vvfaa6hnGTyLYz3pLGL1tqKycsVbGDflLroWL8jly5s0hzR5tKFeCL8r9DySsfQR3g8g8MWbMmITAiEMgw5AKifdfn8OIXB/hMI66GCeLfl0h326brnbhTpN16mcB6QJk94JzUufeslKwTEGnE/U0HJIcQIgqSofJKnJAcpBiYDjsHMUuhwZlKXt275c5M/ZIbIy9T9t97WsklkQDho3D2BEOW2cZXjvrAxzZueikXI3wXC5zZM8peeexb+Wzv1+SFWuWKeGvVwLROzt9+nQV+SSrTsbVWmIERJ4pa0ZQWt8zjCdBAn6faDLXn6FXjvAzenf4XR6La05klMcm62sdTKGvkytwOt555x116FOepEvciZJj6IPzB8t3swYku93Mmdf7qXi+ZKt9GRbFsC/eYx3pN6Ru/Ll0yGAw+AY2INO1LDJr2GIZ9cQkiQglmD4/4YcBIlsn7pMmj9eXrMUzJikxdgTRQlXRtGnTVMUSrTjYSwQWdgyfw1Fk8m/s4ckTp2TuzxslItS5YHRFswfqSNbs1+8TO4b9cwTbSjCZqiorkWHXEwd2ObD0hER68XzPHD0nb97zkQxb8YFs3rVR+V34HFwvhCbXiwA7XwStHQPG2Gf6dSn31nAf2F5ELe8fbU28vk8++STZ43ONSWLgixG85/55L3hsx0Gn+ENUtbmCSkCCFjxn7ocAtxat+CNxQXEyYvHnyQQsgQzeF54rj8FzdbbyyBOUXfP8evToYfu2hltPgB/7HEbk+sis31fIuAFLnQ4Pio+Ll9Vztqqvh55rqcpNHA8TDkSWl1NqS8TOOqYdMUaEk5IYRBVQnuwodstXKCP/e/QumTB2ldfPOzhbkLR/sHay73P4UvLEcnkOWXp/OKyZ4KdLdDQRUb7ver0a4XqasyPH9p+Wz14dJYNG91WvnawrUUnQQpF+GAw00VGyvRqyugyHoG/GWSSStQBMGH788cdVZJzIsjMBibjlvaGcC4PBtUA0YowIXlw6Hy5Ht0bKC0OHSvjlSJn67U4pUa6AtO3cQKrULaWMHkaR58MeX4IZlCfhZGAIKEd3LD3TIIj1oBFENe+JNz3GVvh8/fPPPypab7hD8OMhEAaDwTeWT14rI3uMdz48KF5k4/xt6qvNk82kcaPGkt4SyFa/Eh+vsosILoSXHiYF2CeybthSRBA2ir5OxwB9ocIFpesr7eWHgX/b2gH8YM9myb5PhpTZJthoAvv4H9hFnmPJktf30cLFMPt7fzWRllU8njh34oJ8+OQQ+XTae8ouk4DABuMTUUqsfQ4C21R1UQas/Qs9WIoMuTOfg0wt90F/MH4dFXSOPh1wzcm6YrsRnYhf7YchOCnbPrbmnIx6/k+5cjlKpuRaKkXKFpD7ejSXWi2rqOvI+4dfyfvM+041Gz2/9BXrfl1n0JbF7zDglPcAH9CuyOUzxDCtIUOG2Lqd4TYS778+hxG5PrBw0lr59o0/vPrdyd8vlAwZM8iT/RMMCgcXRgQog+UgpSzWGUTgKHVG7JLZ5eB0FLtP9W4up05ekqWLPJfzZMkaKA2bZ5PlKxYki9RyEHJ4U+LLz4ik6sFPiEUrZ7bGyB+7b7xfwxsObjgrixcukaux0apkh2ELjNznmiEY6c/lOmEorbvu3EGAYdCgQfLLL7+o2+rJy3yfdU3OhnAhVBG7RDaJUH7y8WDJF0Cp8YYk/ckXz0TIod2nZPG0zVK8XH6pdW9+ebR7R/X+0RtDZviNN95Qxk4vjncFTgBGDpFL2RKrD+yKXPqLySKbnpg7B3+OqhoMBvusm71ZPn78a7kW63kWxtxflqhqsldHP6v+jf+Az0GWFpuOwCFT6KwUFbFLK5YWu9yWbKJV7D7wTDM5eeisTP81oafVHRkzZZC7Hy8ta7csl10Hkq7T0xlHqq2wwwRyeX4ErPGNrEQdENmz7HqGNCU5tPaELF+0UmIkWvkb+D+jR49WPgfXEHGLD+YuiO6InheC74IvgWgmyYEYJZvubPIwApVgPu1YZNm//PJLKR5XWWaOXiRRV65X0108ESqHdhyT5VPWS6Ey+aX6Q6Xk2bd6qNJ2ZoLwnPEBGIDpyedgUjRrGYFqAHp67UKW+qWXXkpWXWdIvQT4sc9hRK5NIsKjZMTbf9q6zcRv5kr1ZqXk6JkD6uAi0mftH2VQEgeZ405VDQbAmtnlwETs8v106QLkrQH3S0ieIJk9fZtERTrPlBYsklXu7VBKqtUoraJzGBTHgxWRR2ZRH9pE/xik4Mh9TzSWCd/MVRnrlCbs4hXZvuKgVLk7QeSR5SbrjPjH6NB7YreElwES/fv3Tyw3ojRZ900zFIrBERzQGFzHfhIchHZtO8jS8Udl4+a1bh/nyN7T8t+xC2rAWN83n1Y9xWSEmTTIigYMpLNhWBqr8SQYQoDEDuz85XPibM2VIRXjx/0xBoPBHgjbr3qP8krgaphEXL9jDbkQf0YJMrJ31vJanaVj3Z4znIld7kP37D730f8kW57MMvXHZSqb6Iw8RbNJyyeqSq27K6nsInZIz8mw2jgErfW5kdV1pHXXJjLqjd8lJsr7SjBfIVO+6u8N0vDRWqrailJhsqj4CFwLSpUde5e9EX5PP/10oi0maEDmHMgUk2AAro9jqTl+IWJ349j9MnmG84SI5uT+03L6y3MSERYpb37eT/lvBBEIdiN6Edfu2ues+BIYp7WLKdPOJoAbUjHx/utzGJFrk0V/rZPIcO/LXzRTflwkg37s4/TgQGwyRdhxZQ6QZaRMFSOBoeH2GB7KT/U4e4xY/cb5pW3Hx2XZ4j2yYe1hiY0haxwmRYrllqd6tpEy5a6vuEFcEaFDdLFbTcMBa91fx0GO0HXk1PljUrNpWdm02LcBVHYpkKtokuFd9LECvSN2BS5LycnIWntqrVBuxBeCn+tD5hXDxHXSkcmRH/4jezY7n07oSHRkjCybeFhy5vtDWrVpmni9H374YbX/mKFUznYEaxDZrvYxu4P1R3xmWKNkMBgMhjuTVVM3qDJau/z51TQZtuAjpxk1KpaoLnImcgmmUiGF36EFJ34HwwvJPDLbgWqvCo3zS5MHX5QdKw/LnIkrJV1cRgkLD5W8hXNKt34PSOW6pZL4OAhGgvQEXjVNmjRRk6AR1O64GHpB6nSoJqsn2V9d6Au5M+dz6nMgEu0KXCrGaFnD73IGgpAv/Dn8L71Zg3Jm7RuM/XiKrJ2RPOHgjGsx12T1mJ3yc/HfpUX7JonTmfWmB+a5OFbyWeEzwYRpVwEQV1BSzfNHUBsMqQUjcm0ye+wKn263c/kRFSHM9P/76HQPCoYEIUuJCNlcR8gyIsgQR9ZoJ5E9DA5GA0HGAcrPd+/ZJcO+fzrRsNEzsn79KokPqKoMG3CYUoZDP8ykSZPUYYqA5v4Qv2QX+Tvf49+OwpyDrG6nGnJg53G5fMa7sf4hhbLJhZPJX583xFxNHr2lr8iu8GOsPtfSmyX0iGeui34syrsQ1YULFFclynaICIuWdKEJK4o0BCbIQk+cOFEZH1dincADpUp64bs38HkYOXKkDB061NbzNKQO/Ll0yGAw2GPm6AU+3W7fqsNy+VyY5MqXUI2ETWduBQKWwCk+h7PhTwgsbJVuXdIwhwLbQjYT/6VSpUrqd48cPSyDx/dJnC2B2KGvNi7oSpJNBASPEW1jx45VQpcyWnwMqqfo+9Q+CD2hznyOOo/WlIObj8jp/a4HLlnJXSynnD96yadrFxOdtO+Z58NrdheQdgb+Ga/TKphdwWNo34Tkgr5tkYJFZep382w9Lr5m+J44KdW3VLJND/gcDNRytt4IyMTSJmVH5OJTsj3C2UAtQ+onwI99DiNybXJ07/XhRnaICIuSMT/8JkE50quDiwOHLB0iVvfYOsvyInzJyvFl3SNnHXbA/dHkj8HCCDneD4aIqC3lq4hhPQhJT/77/ffflQHj0GNiMaU5lMzoZfBWgaWnCFNqc/78RVk7/rAc23vG5eumnLrx/6pIUMYsMm+c+/JeVzjbzYfRY6WCtzChEMH/8ssv2358rodedfD1gPE+7Qie8+c6efzFVkmGgRCUoEcGo4PxcSZ0CTjwntrdTcfuPtMTc4dCG4DdVoBb0DpgMBhuPUd3X5+ybwfs1M8jfpVcJbKp6i98B3wOvnSbjDOfA5vPwES+nKF7eb/99lslTLlvhipZwa/A5lKtxIwLhiBh37B59H2S3cTn4Pf01GBEMz8nk2z1OXg8/A6GMYWHhcuqH7bJnjUJu2xd0fixupKrQA6ZPsy3AEHOvNmTvR7EPQMqvYUyZ1YzDhw40PbjEzDQ1+C3z/6U8Ev2dwQvnrhKeg7unGyqNb4GGV2C7M5WCvLe2i1V5rPAEE+zovAOJc5/fQ4jcm2gRGSs5/U3rihbppwUK1dAHQR8ISL13zEWdrJ1jmAAiIISTcPoECl1jNRZpytSJqSjtGQs6aXg0KNsxrq/zlEocXsOeiYNd+zUVrLnWiLFQx6SGb8sk42Ld0nc/3/ws+fKKvd0vkvadrtbChbPI999Mcan14VIbnhf0tU3PCeMqrdRVaLX9MBybW6UA9vO+nS7C2dCZffWo1K5dtKpkbxHlA/pjK4zYcrrdLeiyAq9PTgNjtMpDXcQftwfYzAY7BET7XsfaoliJaRKowpJ/A39J/7CjfgcOrNL65SexuxsUwBil+wxQWk9dwT/g8oqWofIGDIHQ5fVOtpAqsmY+stwyKYtm0j6TOnkmY+6yLTv5smqaRsSe5WzZM8srZ5oIh2fu0eKVyoiY4b/qsSaTgzYoXGnpL3DPG8mP7uam+IImViEH+1RN8q+tcd8uh3DqTYv2iGNH6ib5Pta6OJz0DblbMIziRCGbHL99EohV1BejY/Ce2S4Q4n3X5/DiFwb8B89a47MPkXVoHb9GpLLIUKo0UL3RiJhREAxJBw2lLhigKxilwMLQYsIxmAQzeXnHNwcdhgdxK21hMkxosdjkEXFINFLc/8D96tDsl6rKhIVES1hFyMkQ2B6JXKtWcvGberI+r8PyX+H7fUW1WpWUYlkKzwnbwUuxvfjjz+Wr776Sm4GYT6+9+q2F53flmADkw+JrjoTupQwYUi4zu4+I0x9Zr2RKRm6s+F/nO3SoZR6MgaD4baSPXewXDpz2afb1qhbXUqVcz4EiHWBBIAZ5OgrCEj8DfwIpgWTBXYUu2xFwKfQ5bdUgWHDOnfurIYhETS3iilHn4O2Lm5HAJ5BSvgo+Cw1mleR6MirEno+TNKlTyc58mRTmyw0zds1kbW/75CDG47aek1la5eSivUTWrs0+FD4Et5eE6YZU1F1M7YahJ33fWUj18YZ+E+PPPKIyrTzp+MATN4zqv9o7+L6O+4t1lDCzX0w+dlw5+LPPoepZ7RJw/uq+3S7inVKuhS4QBkxo/NvBHpZEJ+IISY4Y0zYAUt2zzqxkAMOQ0HPzdSpU1WklUMOgYU4pjyXIREc1lERMUrYYYDYLcueWsqN6CVmAIU1ChiUJZPkLZxLvU6rwCWKyyTHbGXtld1iuB55MWECoRUiqo5rjVzB2H7Khez20gCvn91yRJLJbvMVfdX+0DHN+o3r1N49ZzDxkKg20VXHyDMl7fRts2rg6FHXBhsx70tplCGV7qyz+2UwGPyORg/U8+l2hcoUkJJVi7ldUXejPgf2jPkeZAcRuvgV+BNUhllnjCBeGS6FAKbfkzJeBCDVYwhXhPbq1avV70ZHJAjXa9filN+CEMd+E5xnhZ41m8qMk7xFckvugrmSCFx8FWaOBJVHONtzxx/v/2Cy79EupsuqPYENZoWOt1OMrWD7yaByTbTPERbh2ywT2LFrh3o/nIHPpwdgOlaKcb1Jkugp3K5gFeN7773n8/MzpBLi/dfnMJlcm3R4sonM+yPhMLZD++5N3P4c4YhIvRGINFqzfBxilCNxgCFeMRLsvNNlyognSmXpVSWiypAI/j15wjT549vFcvZArIRevCIjZakEZsog+Utnllb/q6X6donuOa4DcAQDiiAlGoiAw6hOL7RC5v263uNrwTD1/aKzVL0raUQVENbO1gw4QnnyE0884XKZOffBeH1ev6soLb3JRJAJHmCU1087LSvnbvf42M5ez6NdH5DwqIvyzz//SOnSpZMM5dB9P5Sd6x5dxyhwrhx5ZP7sJRJwNYvkzB0seQpcX280fPhwFRl3VnpkMLhixIgR8sUXXyhHEmeVEjui+M5gVyR9/TiPQAaHqgFXv28wGG6c9r1aycTP/klsBfL6dr1buc0kYiu8zU66giFT1jJVxC4+BkFxMrtUfrEiSAtTfI+OHTuq4DF2EOFIQH72P3Nlxo8LZcSuiXL+1EUZIX+qQHmR6nmkTscqql8XH4aBm+7A38DvwOZjS/FRxhf4W2Z9ucSrsuWnBz8ujR9Mfp7hO3kDAx+bNm3qcmgT15ugP8Fq/A/H58T7xZpCvTuX4MC+2f/J8R2nxRce7NJBshbIpJIZZGPr1KmT7DPgatMDP7t2NU4O7zou+bMeluwhwZLfUlU3btw49VpJihgMqdXnMCLXJmWqFZPazSrKxiX/en2bQiXzSuMONeV24Sh2+ZOoqxa7REf5Yo3Rm898JduXnUq2A/dqdKwc2xUmP3+wVOZN2CxfT3zN6WNxaLN6h0gqhgmDpsGglai/XfpV7yKjP/hLrly6vtDc8Xr1HNBJGrSp5rTXBSPgbBK1FYZpIa6JRhINdWZMCAjwuh0nV7ujbecGPoncOk0rSL5CuSSf5FIGkKEUGHkmXiP+NTgDRMN1GRHPc9emw7Ju2in5/tXBqif8V1mpfrdS7RLSvktDyZzvqvq9unWT9t4Y7kxu1aRDgimvvPKKcsxwBukf45wga0EgyxGcVgIp/H+hfI8gEtUiOJWuytkMBsONka9YHmnZ5W6Z//syr28TUiCn3PtUc7ldIM6sYhe7jdglsA4MoiKgznCrAT0+k/WTdiWbd0Kv7ZGNp9XXirGb5OsFH7p8PKqtEI/YVqvPwTlWomEBebd+P/m6z2gJPe289Ddv0dzy1AePSutuTZP9DB9Ct5O5g+w1v4voYxuDxhpowBcrUqSIctLdrfGx0u6ZFjL9B/sDtMrVKillayXM5iDJQEAfnwMBrfufXW16OLD1iGz584B8/fB41RP+uyTs8S1Ts4S079lSStUvKIcPH5YuXbrYfl6G1EeAH/scAfG+dOWnccIvR8ibDw2Tgzs9Tz0MyZ9DvpjSTwqVTP4GOjJ79myvRs07g6gg4hLD4glXYnfEgL9lxjjvstQVaxaXwb/3lkxBGZPcJ8+DDyRGzBlEbyh/ibsWJ5eOxsjG+Xvl4N4jEhKSS/IWDpEcJdPJc290dxmBnj9/vtx1112q3AnRbM3C6tts375dHcA9evRQBzpR3ZvRGwP8d+l5zxdy4pC9AVSDfuwh9ZolL7FmfQKl4UygtJZgs5939qzZcmJzgCz42/3KokzZ4mX0zHclbyF7K5UMqQtK0pl82rg55fXO1zu4IjY2SlYsHqg+N9qR9ARGhsAIVQCAQ0rQp0+fPvLWW295vL126Li92cdsMKQc9J72b/uJbF/mObgenDOrfD7/XSlbq1SK+hzYQm6vh1S6w5XYHfvx3/L7R1O8erxiFQvLV4veU69Pnz+0Y3GfiDbEozMIiDPTgqD33tWHZOeC/bJ3+341XIky55wVs8iLA3tL+vTOu/coo8Y+418RuCcL6yh42StLWfDzzz+vfA78n5u53eDVVh/JjpUJGza85ZWRz0ib7slFO89/8+bNqkKNljMNvhtzWSJ2BMjkr6+LdGdkDE4nw5d+LCUqOb/mhjuD0DTgc5hMrg8E58gin095WYa/OUGWT9/kcuJywXI55dNxr0q+IiFe3S+HIm+iq52p3vTj2snsUoKDMEUkBsXk91rgwr+bj8jPQ2bJ432bK0PDc6bfxlN0kt4bDA5lRzMvzJT3f+6leoaZ1Aj8XZdBcRiTEbYKVIZecY0Qsuzda9SoUZIsLOIWAaz/E91seC79Bj8sb3f7QWKuetdj3PKBWk4FLvAa+CKSRZQVoYtB5dDYuzxSVs/b5fH+o8MC5I0u38tXf/VRZcyGO5sAVnTYjD3q38doWdHT2x3RO7H79++f5PxhcJ3ujfMEQ2YIblFZYTAYUg56Tz+d/bZ89/KvMu/Xpcn2uGpYF/TF9IFqurA34ODipPKnXahGohLJbmYXfwHhmTdjIa8FLhz994R82/cXeWnkU2qdDyKbKc2eHGyqozjvCIrznN+d0E/1BSPusecI9fj4OLUSEZ8D38Oa+0G8co3IHmGrHfcHs62CarGff/5ZUoo+X3eXl1t8KBGhSVc1uaLOPdWkVRfn644Q4XzhK1HGTN8tpdFkyi6uj5EZoxZ5vP+Y8Dh5877BMmzJACnoRQLHkLoJ8GOfw4hcH8maLbO8+d1T8vR7D8rssStky/I9ciU0UoKyZpLyNYtLu25NZMRPX0keG9k1DlDKd1jGbRcOYSKTdqD/gtQ/YrdX209tP+bsCaulVJ2sSqDaiVqSiWUhPH293I7M7vjx49UHl0zvTz/9pAR7iRIlVA2+Frl8wBHoGEu+R1+rFdYKDR06VL7++mtJSUpVyi8VW2SVPUsjJDrSfa9Oi/trSb/Bj3i8T4QtX2R1EbsRpwO9Eria/45dkO8H/SP9v3nC69sYUinEzOxuKvv/3ycqamXAgAFOh5ERPCJYxCwAK/x79+7dXj3km2++qbIjdvZVGwwG3wgMCpR+3/eUpz58VGaPWSxrZ26S8EtXlAAuXb2E6sEdM2m05C+VdBuBOxA3ZPXYumAXBCP9tHbA3hMMR+y+1Pp924+57O+1UqFtEWn/UNtkE4HdgRimtw8fYtKkSSprSckkAk+v++EaIP7Ibmqfg+fJF6+T7+GjWeEMZfBSSk8XLlK+oFR5rLDsmHhcIi67n0dS797q8s7YF5MM/3QG/hVfZKHxOa6dT++VwNVcOhMqQ3uNkiHz3/X6NoZUSpz/+hxG5N4geQrmlK6vt1dfjjz99NMqo9i3b1+v7osDh4igLyL3Rjiy97ScOmh/RcHVqGty9XyWJAKXCKjOwrLSxhlEQYnGPPPMMyoD/cILL6geFm0wyeY6y0pTLuRqGTuPS4SIpvSbWSbkCM+bxvmOnVtImf6VZMa4VTJv0no1oEuDMazVuKzql23Q6nq/rTdQDsVX77b2d/qumr9D7eMNyedd6YjB/6KqlO9bMxs3spLMHZ9++qlaeUUJouM+boPBkHLkyJNdHnvjfvXlyKvFXlV7a99/3zsByaofRJ6v+NoGdOHUJdnvw/7XuGvxEr7/WhKBi+3H19BZWGfPj75TbsOciw0bNqhhS/gZVp/DcSgTrF+/3u2si3fffVeVWabkwEdENj5Hw3vrycv9X5KZPy6S2WOWqAFdVqo2Lq+GlN3dqZ7L0mtn0MfM12v3fWT7uW1fsUcO7zwmJSonFTqGO4sAP/Y5jMhNQYj66eihN+PkfV1c7mlZtyd2bHA9It4T86etkgy5Q5MYFBrIOTQxGq6MICU/euKzt4aSPhj94Xa8Th9++KE8++yzXi9r9wWuMxHfmjVrqjJpePqNdtL1pTZqOBS92oGZMkqxMvmlQFHfSzj37zwhR/ees3272JhrMufPtfL4i619fmzDnQ3Gxpv+GKaG02LASjAr/NvT3swhQ4Yog8MeRTJBBoMhdcD/a8QcK/7IeKRWdq3Zp+Zy+MLSqaskb50syV43WVhssyt/Avs9bdo0dX0cpyXjPznzo8g+6S0Sjj4HFWO0XbnqBb4Z8JijRo1S2TLdO9313U7y+Fv3q2t4+VyYZMiYXq2LKlbe9/f7zLHzsnP5Pp9uO2P0Qnlx2JM+P7bhziZ7Kvc5jMhNYV577TU1LpsUfkpBr4h1Qq9dIsPdTw10R7asOWyXLAFilXJpSnTpeSG7q4MB9M5Qtm3t96G8yFWEiPJmDFFKZsAxNt9//716To6lEqxXqnGXdzv0vGHv9mO+33bb8Zv2PAy3CXwpu7Eum79P5oFWgIULF8oDDzygvoeTx79ffPFFl7cjS8Q+ZipOnGU+DAbD7fc5KKHFKUwpcEydTUP1logw73pLnRGYIZNPPgcCloFQBQsWVD29/KmDAWRrydpa1yK6SzhMnjxZOeYM2UxJ2BLBasFOnTol+T6lyFUb3zx/Z/+Wwz4HHfZu9D1JYkglxPuvz5FydZ0GBX2yCDhS+t5iN5vLaPgbiSZmzup7eUFY+CU18ZgPq12Y7IxAx2DSp6ubzxG+TB12LFW2GhQdreWDDwzSSkl++eUXFYnytKfvZhAd6XyoiDdERd7Y3kND2lnMzih/9tD9+uuv8u+//8pzzz2n9lo+9dRT6udML7QOiWB8P87zmDFjVGsF/fN83Ui5o8FguLmQqSRQzJAXbwPOzLOww9atW9WOS1/JHOzd+hxnxMRdVYOjaB2yCz7Eli1bVECdrC9/B2w7WVsrXD/rDmDtcyCGjxw5ovbKpiR///23el+6du0qKU10hO9+Q1SE70kSQyoh3n99DiNybwGvvvqq6qnwBkpu7Ajim0HlOgm71HyhRKX80qBBA1UGREbWDpQuMA6cQABDqNztoeOwdyz5plmdacv0Pqck7Kwl8JDSRu3ChQtqMvTBw76VDUHWbKY/0l921tn9sgufZ8qA6N9j2AoOH73xejAEPW78v9RQycCERHYqkgXRX9yHwWBIPTDvArvlDVWrVpUdO3bYun8GyFCJ5SsV65eRdDb6Rq0UqpBXDZ/krFq2bJmtpABClVYq1goycMvxZ9ZgvbMySr7Hmh2c9ZSE18b526tXrxR9HAaWkkDYvd/7IZeOZM3uuRXPkLoJ8GOfw5Qr3wIQc6yGYXUOgtAdZDHpVUXs3irKVC4sZasWln3bPe/9dcwAt/lfPSXMKD8go0z0sUqVKsmmELo2WNMCAAAhh0lEQVSCQVJM9uOwxWjqvhimHjL1D4PEh9xxkiLRH6YjfvXVV5KSMJDi7Nmzav/dzQLBThTL2puAgUXwE10uX7qKLJqwx6fyodp3e3fdDakYX6KkPq47p0zIVakQAx6ssHLCYDDcGbCPluBzx44d3f4eWUyyk7eSfEVzS9021WTtrIRMqrdQpvvISx1UJvfBBx9U2dcpU6aozLW3vXo419wGv4xeQnwJSoIphWQoVb169ZwKZ/p4mf2R0tsb8Ke2bdumys59HezlCAkE1hSeOHHdx+O+ef20ulWvXEPmfLVaoq7Yz8rWblXlpjxHw20k3n99DiNybxHdu3dX4689iVyEHlFSbyHycaOCmLKf/OUzyL7t9m7XqlMdqVSlguTJF6KixkRb6B0hKkzPCiP5PfXtcNDy/ClPph9GGxkmDCMwEbmUMVPOrEEIUz48ceLEm2YEXP2HQ4ySifflcXgfDxw4oFYk6Qgx90N5GEEPV3uN//tvvxSrkFMO77xg6/GyBAdJi/uvl1cZ7kwC4hK+7N7GYDAYNAwqeuONN1SLzc20k5QKIgpvBERk9ooZRWbZu13DjrWlcq2KUrRMYfnjjz8SfQ5meBBgR6h64w8RiGezA34GyQdap/BVtNh3Vo7NHlwC64jjlAL/B7+Dkk1fhoniZyAMWO9kzUrTD0kChay9s88C1YOl6heSXYsO2Q463Nejhe3naUhdBPixz2FE7i2kdevWSvw99NBDN+0+2avKrtsbMTaU37z+QS9JFz1Blk33TumWq1ZUerzRVv0d49C+fXtldHhtGBCigytXrlQClednXZ7uCH0vHMy8FmcHMEbVOjWZUgeMm7v7vFEovaaMh8CEJweBa0iJBeXTZJ01GCl2+fK+e2OwCA4girnNc/0fkbe6/mCrFOu+x+pLUJaUW2VgMBgMhjsH+jkRZvS+3SzoVb3RoXMI0t5vPiXBsSEy5euEuRqeKFKuoPT9NqF3jwwka4DYeduuXTs1EJIvRCrilXJmdxNf+d3t27ermSDWKjG94YKMJxlf6/Ab9vuS9U4p8H+mT58ub7/9tlel4KxL4jYM5bQ+f3oXEe3eiHGCA9wHM136ftZTXmz4ntrS4C3NHm4guQvm9Pr3DYZbjRG5txCm8iKaKLO5WbtcOZBv5L4oZyLie/HiRancLKfkznO3/PPLCrfiqmajsvLO8K4SlPm6oKJf9rHHHlNGB1EbEhKiSpEp8WEwFQcur9/Vc0UUz5o+Ty4dDpBp3w6RS+fDJV7iZNao3VK6Zi5p3SpGref57rvvlGi0Huw3G8Tm7NmzlbFxNBSUVWMY+dO68okJjawV8mVHGNFbjCrX4P77r+8+JIjw02czvboP3pMnX01YMWC4w7mFpUMGg8F/IXM3fvx4Va7qzjZh57DV3ogrXd7rKwyLpDIL25m7diZ5cuD/5LcP/3bbnlO+TikZ9Ncrkj0kOPF7iNPOnTurdieqvwoXLqymJBM0Z3oyrxlfwbHVSUNV3fjfJkjYvhiZPnCFnP/vksTHxctf+RZJmUaFpXmTFpIlW2YZN26cyoKm5D5wgvwkCdi56/g+EeRHiDKzA7TPQXKB6jdfgv0IfNrBKPO2+hz9vntahvYa7VVwvWytktLnG7M6yC+I91+fw4jcW8yTTz6phJq7kdl60l9KRg0BQ0DJLOXKlOyow+5+kbaP3yWzxq+W+X9vkPDLCVMX2cXW+N6q0q5LQ6niYlAVhpLG8hkzZqj+mOLFiyujiYgOCwtTgpqmceuYfrgWe00WTdwtC8cfV8verYRdjJSDO/+TNTM+krr3FZGC5bNL06ZNVbN6SsDBTxk0JcqUKrNiAPShnyNHDiVG+fNG4P7IdLPEHqPsLDL+v57NVN8zQjfSRa8MQrvFA7Wk70f/U++RwQ+4BeP8DQZD2oAhSawxfPfdd13+Duv36Nn0ZhXhjZQ+42fgF5BlpR3pkUceUffXsnMjmTVmscz5ZalcPH1Z/S6DqRq0rSnte7WUWi2rOH1cvkfSgEA6YhAxSiCdTCaBcPwEbDWtU9bbY3/n/7haFg3ZKtdikorr0PPhcuLf07J+Yl9p/ERNCSodL126dEkxn4NpsUyc7devn5raTAuaFQIKlFUj5G8UMt34NFTbWcWtpvUTd0umzIHydZ+fJfziFZf306B9LXnjp2clc7AZdOkXxPuvzxEQb3dfjeGGwdi88847LiNwHM6U+VIe4w4ie/SyeurzdZU95PERnfSAOO5hA3o6ELlxcfESnD2zLRGFgGYnHYepFYZTUQqMMcUgXbsWJx+/+Jusnr/Tq/t97v0HpGO3Rsrg+LIrz10PCwOmEOIIdSY+Y/i5Pjezn4k+Xa43BpnMrzeBjCthUbJwykaZO2mtnDp6QZUT5cwdLE3aVZe2nRtIoeIpGwwx3BpCQ0OVQ9a8DuVq9pyH2NgoWbzhE1Vh4M1idoPBkHb45JNPpEePHsmmBWtwA7GpBKTdQUAc2+5LixQVUKzuQbBRlouddbSt2OMrlyMlJjpGgnNlVdVbdgQ0gXayuVZIGDDMiTYgPZxq2As/yewxSYfcuOLx/g9I9/cfknnz5nldBuwOrjU9sPhuly5dUtVvCHV8AQZ2Fi1a9Kb6HDzeihUrlL/ItaHqzBPRkVdlyZ+rZeaPi+TYnpMSEx0r2UKCpdH9taV9r1ZSopLvKysNqYfQNOBzGJF7G6A0+Ntvv1W9pa6gXNaTwWGJMiXBdktkidjyHBBxCxYsUH20KTHACSFNCZQzEU5JMIf82d0B8s+YVV7fZ7p0AfLZ+Ofk+Lk9tkWu7mHROwF5zXwxyZny6qFDh8rrr7+u/n6zoVeXqdk4CUy9tPYYGwxJDE7t/r4ZnI2DU73BMRgMtx7sDv7G4MGDb8jnIBNIJtbTQElHtKhjTy3lxQjcm9Wy5SiksfPOEgQEsinTDdsTK+MGTbN1v+9PeEkC8l5VQXs75yvCkuek93pqnwMhS3n1p59+qjY38O+bjQ6oU15OQJ21SQZDWvM5TLnybYBVMQhTspo0/N+IcLIrcBmQREkMwpPILcMbUmpCMSW4CGoioI6RX4xF2TLlpPMHg2zdJ1nlKWOWyV2dCrvsIcKgYFgQ8lbILDvrYcEIfPTRR9K3b9+bLnCJXCNuMegMw0jJvh6Dn0DY0e7kQhOqNBgMLqAvlU0F7IZlTZ2vkBV1zJR6gmwlw6oISjNwKqUELlAhFhwcLFOnTlWrk6y+Df2nZHMfL9vH9v3+NWyW9PjmQdV25cyhJ3BOAJ1qMCt6LSDPyTHoMGDAAHn66advusDFLyQBgn9kAuqGtO5zGJF7m6Dn87333nMbWb3ZcEDracfWfpiUhJJkDlmMGyU51sdbNmubRIZfn0bsLWsW7pL67YupKClGhSixsx4WbyKXGAQEbu/evVVp8s0Cw86iegQ1xt2bgR4Gg8FgMKQEPXv2VIMv3YlcCvvc+QR2C/+wr2SIaYdiiwMCNyVX8ACZZnwOZmuwhcFqezfM3y4XTiT0/Nph15p9culEuBLnBNFpcbJeC4LX+BzM1/AEJdns22VQJ8L7ZkGwnlJyri+ZbBNQNxiMyL1tcPAiACn/cRYZJfLHYeoYAbRGDu1kcYnqMRCK6KbuO01pgauhB4TJykwPJHOspx2uX/yvT/fHFMbFMzfIuUunVLl2mzZtfN5j+8EHH0i3bt3U2P2bwenTp1UggZ5e1iqlVMTa4L8E4GjadCbt/r7BYEh7NGnSRPkB2CZHaNtBvPHnzRC4ej3hAw88oPpO8TluVbCXiiweF6HLn3oa9Po5W3y+z9ljF0qhBjmlbdu2Xq8FdHZNSGyw9kj3B98oVKzRc8yGCxNQN/hCgB/7HMYDv82TljECzuAA3LZtm8vbsgvOm6ih1dhwsFLGk5LlQq7Qe+14HvQBQHhoQm+sL5QpVU4ta2fxuy8Cl2vy8ccfq+xyxYoV5UahBJxry3RmphZSJmQErsH3SYfxNr9u95M2GAypHXwABJGr3bHsTXUFPyMw7y1TpkxRPb78SdWYq1U+KQWZTFYMkUmmTxfCL0f4fH/FC5dU2VrKvn217cOGDVPrkxw3TPgaUMfnwE8kaEEiwQhcg0/E+6/PYbzw2wx9mhgBR2gGp6HbU8O4N5C5pXyFCO7tELgajBwlOvSLMMY+U5DvRi97jmBVfu0rQ4YMUdfE20CBK+g5xtBQOo24xYDdqgy5wU+xbWx82HFnMBjSJAi/H374Idn3KXOluskVDG5C4HkDczioUENgUjIcGBgotwN8HR6fIZgHDhxQ63F8hZ259NL6Ctec8mR8vhuBbDs+HX9SmcdKRRNQN9wQ8f7rc5j/GbcZSm0pb6VPIyWgR4MhT0xRJpqa0v0wntB77chEh8ee8/l+KlYvkTix0C4jRoyQqlWrqt15vrJ161YlbnnfELc3MszDYEhCnI9fBoPB4IEaNWoogUS/rF28CeCyyoeBmqytwdbbHY6ZElBizP7ZM1cS9t77QulqxXy+7dixY1VSokOHDj7fx+7du5XPwbwPxC3ZYBNQN9wU4vzX5zAiNxXQvXt3GTlypNe/T7TVm8gd0Uum+2F0ELi3u5SFIVFEdmfNmqVKiRrdV0nSpbd/SJeqWFCq1C2t+ozt8ssvv6hdgb7s2KXEee3atSqKisFC3N6MUmeDwVl/jN0vg8Fg8IZ+/fqpaqabDVsN8E0oocU+Om4yuNXQrzp37lzlc5CFbf7YXRKY2X4FWZ5CuaR+u1q2+5KBSr3o6GhVxeYLW7ZsUT4HgpZrSpDCYLiZBPixz2EK+FMBjL0fP368REVFJZmIR4kP0VbHUh92zJKd9VRGy/3RK2od9nQrwSBg9Iig6hU+ZK6tAn3V1EOyffURW/fbrktDn57Pn3/+qQwFe4Htvg4mJRNBJXp6M/ppDAaDwWC4HeTPn1/ZNQLP2GXr9+n15E8r//33nwoOu4MtB6woPH/+vOoRZRDS7YDeYd1bzADIli1bJgnwr71/pyybsN7WfbZ9poWkT28/JzR//nx1XVhP6EtAnV5iZo8YYWsw+IYRuamEV155Rb744gu1VsgqfhGJjqWw9LNy8LkCQ8MAJKKYCLpb2Q9DxJLMMePsgUENlAq54s0hXaXPg8Pk4hnvSo9rNC4tbR6up/5up1SHDDLG97nnnvP6NmSKKfdmkjWlzWTFDYYUx5d+lzskqmowGFIHr7/+ugwcOFA++eSTJD7HypUrk4lc2nMQi64gAEzlGNlShk252gqREmCn161bp54D0Pfqzud46aun5cDGo3Ji32mv7r9k9SLy8MttbfsctKGxH/itt97y+ja0PxFQZx5LgwYN1JfBkOLE+6/PYURuKoGdrkQbEah6XyuRU5a324FhTBgpMsD0w9yKXWlEgzFwHNAIag5mbxeQ586fQ4ZOeFHe7v6D/HfsotvfbXhPFal+T4jtiCpGg0Xt7Cb2VqgvWrRIlYUznEqvHzAYbgl+bHAMBkPqAFvNdgIErA6a0z+L/XMEW+iq3Qlfg3JgqsXuuecetUkhpUEEkulE4DJnhCFXrA3yhuCcWWXIvHflnfu/kIPbEqrMXFG9aUVp0KOiBAbZSxRs375d5syZo4IIdgPqrHkiA20w3DLi/dfnMCI3lUVW33///SSRVWdlLK76Qjgop0+frv6ekv0wPD6ikeEVkCdPHmXcfB1qVbBYbvl+1msyb/I6mTBynlz87/pqoXTpAqRus4oSUjJe+rzVTRlTOxAkWLp0aZIMuSsYZIWhwVgzATE1DMwwpEH82OAYDIbUQ+/evVWm0V1lmDfrCRHA2MyUFGdMd967d6/6O0KaALSvbVghBXLK18sGypJJq+W3TyfJ2QMJWWCdra3erJLkqx4sL334nMydO8fWfVNFN27cOLUP11Pml5YyfA4SBLye21XibUjjxPuvz2FEbioCQ0GpDSUurlbb0GPrbFk7xoaF63ra783OPhKtpQxZr+2hDJmdezeLoMyB0vGJxtL+8YYyZuRYKV+miuTJEyL5i4RISL7scujQITWAAUF97tw59acn6MvhmrAP1x2s/2F3ICVWlDnd7gnUhjQOUwvtzmO7QyYdGgyG1AMirFGjRjJz5kyX9hyb76r8mKFK3AcCjWq0mwlB+/Xr16u2KyhdurTbMmS7BGbKKPc80URad7lbxv74hxTKXURVz+UtmlvyFc2t/IxVq1ZKuXLl1IwTb3YE08/8zTffyNChQ90KXK7pkiVLlEinDPx2rVgyGPzd5zAiN5XRo0cPefPNNxNFLkOaKBXSwosx8gxvcoTR8kQFO3Xq5HWpsCfoYcXIIJw5jBm4lNKlSLzeZ57vpoxu4Zw5lcAFhP3ff/+tBDzTEtu0uVeirsTIlbBIyRIclMyg0LfMxGr6nF0ZG36H10eZEyP5zTh+Q2rAl8mFd8qkQ4PBkLrA9uFzaJGLjaccmA0CQNC9Xr2EORiOu3BDQ0PVpgLr8KrbVYbsK9j9rj0fVy1KkiNGCVwgkI7AJghA6XHZsmUlKjxawi9dkaw5siTzF7gWH330kRK4rgLl+FS0k5mAuiE1EeDHPkdAvC8z0Q0pCkOSGOCA8aH0hb/rKCI/Y7CDFQ5nyngeffTRGxqOxEcBEU3WFIjM1qlT57YdxGRXMbi6lIpJg4tmrZE1c/bKwW3nJeZqwgqh7LmyyD3/qyvtHm8oBYqGKMM0YMAAZWyclTNxTemZoffZmfE2GG4HOEk4lq3KvSIZ0tsrlY+9Fi0L9n6pnMRb0RNnMBj8B/bW8/XMM8+oLCN9uo0bN3bpc1DVxe+w97VQoUI39NjY43///VeJRs4ugum3YxsE6KC+3qDAAM0pv0+XzbN2y/5VxyXqSkK/cpbsmaVl50bSoXcrKV6xsOpjZubHZ5995rSK7sSJEypYgGBHNJuAuiE1EJoGfA4jclMpRFbfePUdmTNxrSyasU4yZcwsmYIySqYccfLC252laOl8iYfyqlWr5IknnvCpXAgBbS1DrlChgpQqVUpSC5Qo0ytbq0YdGfzSONmwdLfL36V/t2P3RrL1xDwZOnRIsp5k+ogpYSYrXK1atVvw7A0GHwxO2Zd9Mzj7vkr1BsdgMKRO+vfvL6/3e0MWjl8ls8ctksB0mSRTUKBkyCHy3IdPSpkaJdTvsfFhwYIFanNDkSJFbD8OlWn4LbQJAfYYvyO1CD8C/cePH5cmdzeVL3uPlsUTV7v9/Xu63S2HM26XQR8MSpZ1PnDggFr5SCCArLTBkJoITQM+hylXToVEXomWjOdLSNfGH0p8Yt379cEIvZZ+ITUalpGOPWvL8tWL5cknn7QlcDEujNzH2OgyZF2alNpgP9yunbvlhQe+kP8Oh7r93bi4ePnn5xXS+uG7kwhcIqgYLfqIKXc2GFI1cfGEH+3fxmAwGHyAqqiQC8WlS5mXJC42+VnywoL3pGK9MtJ5YDtZsm6hPPbYY7YELs40ZcgE1WlJokLMm7katwMEd5bMWeSFZv3l6BbPa4bm/bZc6txbNcnQLQIBCFwSBsbnMKR64vzX5zAiN5VxJSxK+nf7QfZtP+7297as2i87Nx+QD356UvLlS8jquoJkPYMTOHSBaGOrVq1crgRIbSz7e49HgWtl/qSNUrtxBcmYK0KtN6pVq5bLQV4GQ6rDjycdGgyG1MXV6Bh5v9NQ2bxop9vf+3fdfhn04Lfyxu89pXjx4h7vl7YnypCBOSFNmza9YwYsrZy4xSuBq9kwZ7tM+36+FG2QR5UmE1Cn3cxguCOI91+f485QOWmIIa/94VHgamIi4+Wbt6bJyNll1aTAJD+LiVGRUyKowITAmzkN+VYRER4l8/5ab/t2v3w1XT7/41lp2LBhijwvgyHl8MHgcBuDwWCwyXev/OZR4GquRcfJyD4TpFbD6pI9d9IBl1SGbdiwQQ1XghIlSqhe3tRShuwt12KvyYwfFti+3fgh/8jQZW+bgLrhDiTeb30OI3JTEYf2nJI1C3fZus2po+dl6cyt0rpTHTVwSZchk6VlqNKdvlR80T+bVPm2Xcj8hp+PkZs09NFguHX4cVTVYDCkHs6fvKjKbe1w8fRlmf3zUnn0tfZqlgczPaxlyHpo053Kqumb5NzJhLVFdrj8X7ic2XNJihYtmiLPy2BIMeL91+cwIjcVMWPcKp9uN27ELIkJOqMELTvX7pQyZG/YsSFh0rMvbF93SEpWuLHJjwaDwWAw+COzxixWmUu7/PXtDAmuECDZst9ZZcjesGPlnhu6be1WVW/q8zEYDL7jP2rID1g9b4dPtzt9JEzq1WokeQrcmuFRjNhnjx3RW748/d3xe3Y4cuiYz8/TlwywwXDbUQMd/HMIhMFgSD2snLbBp9uFnrki5QpVkrK1SsqtgLki3vgarv5uh3279/v8PCPCony+rcFw24jzX5/DiNxUxOWLET7fds7M+ZK3SNIemZSCHhumMpMx5k/HvxPVZVecs5/zp50enU2zzsrhnQk9PnbJnNXeSHSDIVXASPXrY9W9v43BYDDYIPRcuM+3XTRviRw8u9f27fTWSvwAV393hjNfw/p3Nio4+3769OlVKbW3HJx3RnYuTBjSaZfMwcbnMNyBxPuvz2FEbioiY8b0En3Ntw9O02ZNEnfn+hNV6pSUZTO3+nTbynUS9voZDHcUftwfYzAYUg8ZAtP7fNu7GjWQandXFH+jSqPy8s9383y6beWG5W/68zEYUpx4//U5vA9vGVIcX0VqUJZAyVvwzh4w5YoWD9T2KSNbsWZxKV2pcIo8J4MhRaEMyJcvg8FgsEExH2dWpEufTgqXLiD+SMOOtSWkgH1/qmCpfFKntenHNdyBxPmvz2FEbirivsd8m0rYvGNNJXT9kazZgqRVpzq2b9exe+MUeT4Gwy2Lqtr9MhgMBhu07dHcp9vVu6+G5C6US/yR9BnSS4feLW3fruOzre+4dUkGg7/7HEbkpiJa3F9bsgQH2b5d+y7+vQu2xxttpVy1oraCBc3a10jR52QwGAwGw51M/Xa1JG+R3LZv16GXfRF4J/Hoax2kto2sbKOOdeSBF+5J0edkMBjsY0RuKoJs7IsfdLIVDezUo4mUqujfa3KCMgfKJ7/2klqNy7n9Pa5bp6ebSJ8PH7plz81guOmoQYd2o6q3+0kbDIY7jfTp00m/73qo7KW3tOzcSOq0rib+DNdj4J/9pOn/PFfXte56t7w99gVbw60MhlRFvP/6HGbwVCqD0uPoyKsyfMDfci3W/RCqjt0ayTP920tagLLlj3/pqfbmzhy3SlbM2S6xMQn7/YJzZJZ7Hqor7R6/SwqVyHO7n6rBcGP48RAIg8GQukCwvv37C/LZU9/L1Sj363aaP3qXvPLDM5IWCAwKlLd/f1EefqW9zBi1QBZPXK18M8gcHCQtOjeUDr1aSckq3leZGQypknj/9TkC4vXcdkOq4sCuEzL1t5WybMYWibYYnnTpAqRO0wrS4YmG6s+0CgI3PDRSXQ9EromiGu50QkNDJUeOHNIq3zOSIZ29HvvYuKuy4MyPcvnyZcmePXuKPUeDweCfHNt7SqZ+N08Wjl+RbN9rjWaVpEPvVtLo/jpptu/0Wuw1Cbt4Rb3+4FxZVRbcYLiTCU0DPocRuamcsMsRsnP9IYkIj5JMWQKlTOUikr+wfw58MBjSMokGJ+/Tvhmcsz+leoNjMBhSN5HhUbJt+W65cumKZAwKlJJVikiRsgVv99MyGAw3mdA04HOYcuVUTrYcWaRBq8q3+2kYDIZbhR+XDhkMhtQNpbj17zODGw2GNEO8//ocpt7CYDAYDAaDwWAwGAx+g8nkGgwGQ2pCLVm3GSW9QxazGwwGg8FgSEXE+a/PYUSuwWAwpCLi4+PUl93bGAwGg8FgMNgh3o99DiNyDQaDITVBr0ucf/bHGAwGg8FgSEXE+6/PYUSuwWAwpCaU8fBPg2MwGAwGgyEVEe+/PocRuQaDwZCaiIsTCbBZCnSHlA4ZDAaDwWBIRcT5r89hpisbDAaDwWAwGAwGg8FvMJlcg8FgSE34cemQwWAwGAyGVES8//ocRuQaDAZDKiI+Lk7iA/xz0qHBYDAYDIbUQ7wf+xxG5BoMBkNqwo+jqgaDwWAwGFIR8f7rcxiRazAYDKkJRvkH+KfBMRgMBoPBkIqI81+fw4hcg8FgSE0o4xHnlwbHYDAYDAZDKiLef30OM13ZYDAYDAaDwWAwGAx+g8nkGgwGQyoiPi5e4m2WDsXfIVFVg8FgMBgMqYd4P/Y5TCbXYDAYUhNMLfTlywdGjBghJUqUkKCgIKlfv76sW7fO7e9PmjRJKlSooH6/atWqMmvWLB9fpMFgMBgMhttOvP/6HEbkGgwGQ2qLqvrwZZeJEyfKK6+8IgMGDJBNmzZJ9erVpU2bNnLmzBmnv79q1Srp3LmzPP3007J582Z54IEH1NeOHTtuwqs2GAwGg8Fwq4n3Y58jIP5OyTkbDAaDHxMaGio5cuSQZnK/ZAjIaOu2sfExskSmyuXLlyV79uxe3YYoat26dWX48OHq33FxcVK0aFHp06ePvPXWW8l+/9FHH5UrV67IjBkzEr/XoEEDqVGjhowcOdLW8zUYDAaDwXD7CE0DPofJ5BoMBkMqIlZilAGx9SUxiUbL+hUdHe30Ma5evSobN26UVq1aJX4vXbp06t+rV692ehu+b/19IArr6vcNBoPBYDCkbmL92Ocwg6cMBoMhFRAYGCgFChSQFf/51ucaHBysoqJWKAsaOHBgst89d+6cXLt2TfLnz5/k+/x79+7dTu//v//+c/r7fN9gMBgMBsOdQ2Aa8DmMyDUYDIZUAIMVDh06pCKevkDnSUBAQJLvZcqU6SY9O4PBYDAYDP5CUBrwOYzINRgMhlRkdPhKafLkySPp06eX06dPJ/k+/yay6wy+b+f3DQaDwWAwpF6C/NznMD25BoPBkAbLlGrXri0LFy5M/B5DIPj3XXfd5fQ2fN/6+zB//nyXv28wGAwGg8EQeJt8DpPJNRgMhjQIo/y7d+8uderUkXr16smwYcPUJMOnnnpK/bxbt25SuHBhGTx4sPr3Sy+9JE2bNpWhQ4dKu3btZMKECbJhwwYZNWrUbX4lBoPBYDAYUjOv3Aafw4hcg8FgSIMwnv/s2bPy/vvvq0EOjOWfM2dO4qCHo0ePqumHmoYNG8r48ePl3XfflbffflvKli0r//zzj1SpUuU2vgqDwWAwGAypnUdvg89h9uQaDAaDwWAwGAwGg8FvMD25BoPBYDAYDAaDwWDwG4zINRgMBoPBYDAYDAaD32BErsFgMBgMBoPBYDAY/AYjcg0Gg8FgMBgMBoPB4DcYkWswGAwGg8FgMBgMBr/BiFyDwWAwGAwGg8FgMPgNRuQaDAaDwWAwGAwGg8FvMCLXYDAYDAaDwWAwGAx+gxG5BoPBYDAYDAaDwWDwG4zINRgMBoPBYDAYDAaD32BErsFgMBgMBoPBYDAYxF/4Pxt9VNDpILpbAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cmap = plt.get_cmap('viridis')\n", + "\n", + "# Set the colorbar limits:\n", + "vmin = min(0.0, values_32.min(), values_inf.min())\n", + "vmax = max(1.0, values_32.max(), values_inf.max())\n", + "\n", + "\n", + "# Red outline for the base_point:\n", + "edgecolors = [(0, 0, 0, 0)]*nx_graph.number_of_nodes()\n", + "edgecolors[0] = (1, 0, 0, 1)\n", + "\n", + "# Save graph layout so that graph appears the same in every plot\n", + "kwargs = {'pos': pos, 'node_size': 120, 'width': 0.2}\n", + "\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.))\n", + "\n", + "# Plot kernel values 32\n", + "nx.draw(nx_graph, ax=ax1, cmap=cmap, node_color=values_32,\n", + " vmin=vmin, vmax=vmax, edgecolors=edgecolors,\n", + " linewidths=2.0, **kwargs)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax1)\n", + "ax1.set_aspect(1)\n", + "ax1.set_title('Kernel: $k_{3/2, \\kappa}($%s$, \\cdot)$ for $\\cdot$ in nodes' % str(base_point))\n", + "\n", + "# Plot kernel values inf\n", + "nx.draw(nx_graph, ax=ax2, cmap=cmap, node_color=values_inf,\n", + " vmin=vmin, vmax=vmax, edgecolors=edgecolors,\n", + " linewidths=2.0, **kwargs)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax2)\n", + "ax2.set_aspect(1)\n", + "ax2.set_title('Kernel: $k_{\\infty, \\kappa}($%s$, \\cdot)$ for $\\cdot$ in nodes' % str(base_point))\n", + "\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Feature Maps and Sampling\n", + "\n", + "Here we show how to get an approximate finite-dimensional feature map for heat and Matérn kernels on the Hamming graph $H(d,q)$, i.e. such $\\phi$ that\n", + "$$\n", + "k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}.\n", + "$$\n", + "This might be useful for speeding up computations.\n", + "We showcase this below by showing how to efficiently sample the Gaussian process $\\mathrm{GP}(0, k)$.\n", + "\n", + "For a brief theoretical introduction into feature maps, see this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "### Defining a Feature Map" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The simplest way to get an approximate finite-dimensional feature map is to use the `default_feature_map` function from `geometric_kernels.kernels`.\n", + "It has an optional keyword argument `num` which determines the number of features, the $M$ above.\n", + "Below we rely on the default value of `num`." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "from geometric_kernels.kernels import default_feature_map\n", + "from geometric_kernels.utils.utils import make_deterministic\n", + "\n", + "feature_map = default_feature_map(kernel=kernel)\n", + "feature_map = make_deterministic(feature_map, key=key)\n", + "\n", + "key, features = feature_map(xs, params_32, key=key)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The resulting `feature_map` is a function that takes the array of inputs and parameters of the kernel.\n", + "There is also an optional parameter `normalize` that determines if $\\langle \\phi(x), \\phi(x) \\rangle_{\\mathbb{R}^M} \\approx 1$ or not.\n", + "For Hamming graphs, `normalize` follows the standard behavior of `MaternKarhunenLoeveKernel`, being `True` by default.\n", + "\n", + "`feature_map` outputs a tuple.\n", + "Its **second** element is $\\phi(x)$ evaluated at all inputs $x$.\n", + "Its first element contains the updated `key` for randomized feature maps.\n", + "For `default_feature_map` on a `HammingGraph` space, the feature map is *randomized* (using `RandomPhaseFeatureMapCompact`), so the first element is the updated random state.\n", + "\n", + "In the next cell, we evaluate the feature map at random points, using `params_32` as kernel parameters.\n", + "We check the basic property of the feature map: $k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}$." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xs (shape = (3, 4)):\n", + "[[0 1 1 2]\n", + " [2 0 0 2]\n", + " [2 2 1 1]]\n", + "\n", + "emedding (shape = (3, 15000)):\n", + "[[ 0.00701236 -0.00344909 -0.00625436 ... -0.00625436 0.00705406\n", + " -0.00205084]\n", + " [ 0.00715692 -0.00352019 -0.00638329 ... -0.00638329 -0.00575958\n", + " 0.00418624]\n", + " [ 0.00690437 0.0271678 0.04926436 ... 0.01231609 -0.00555634\n", + " -0.00807703]]\n", + "\n", + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 0.016708524516172243\n" + ] + } + ], + "source": [ + "# xs are random points from above\n", + "_, embedding = feature_map(xs, params_32)\n", + "\n", + "print('xs (shape = %s):\\n%s' % (xs.shape, xs))\n", + "print('')\n", + "print('emedding (shape = %s):\\n%s' % (embedding.shape, embedding))\n", + "\n", + "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", + "kernel_mat_32_alt = np.matmul(embedding, embedding.T)\n", + "\n", + "print('')\n", + "print('||k(xs, xs) - phi(xs) * phi(xs)^T|| =', np.linalg.norm(kernel_mat_32 - kernel_mat_32_alt))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Efficient Sampling using Feature Maps\n", + "\n", + "GeometricKernels provides a simple tool to efficiently sample (without incurring cubic costs) the Gaussian process $f \\sim \\mathrm{GP}(0, k)$, based on an approximate finite-dimensional feature map $\\phi$.\n", + "The underlying machinery is briefly discussed in this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html).\n", + "\n", + "The function `sampler` from `geometric_kernels.sampling` takes in a feature map and, optionally, the keyword argument `s` that specifies the number of samples to generate.\n", + "It returns a function we name `sample_paths`.\n", + "\n", + "`sample_paths` operates much like `feature_map` above: it takes in the points where to evaluate the samples and kernel parameters.\n", + "Additionally, it takes in the keyword argument `key` that specifies randomness in the JAX style.\n", + "`sample_paths` returns a tuple.\n", + "Its first element is the updated `key`.\n", + "Its second element is an array containing the value of samples evaluated at the input points." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Two samples evaluated at the xs are:\n", + "[[-172.18988516 -134.87645627]\n", + " [-221.5365812 -297.66287804]\n", + " [ 121.27478634 -446.6551314 ]]\n" + ] + } + ], + "source": [ + "from geometric_kernels.sampling import sampler\n", + "\n", + "sample_paths = sampler(feature_map, s=2)\n", + "\n", + "# introduce random state for reproducibility (optional)\n", + "# `key` is jax's terminology\n", + "key = np.random.RandomState(seed=1234)\n", + "\n", + "# new random state is returned along with the samples\n", + "key, samples = sample_paths(xs, params_32, key=key)\n", + "\n", + "print('Two samples evaluated at the xs are:')\n", + "print(samples)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Visualizing Samples\n", + "Here we visualize samples as functions on a graph." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "key = np.random.RandomState(seed=1234)\n", + "key, samples = sample_paths(other_points, params_32, key=key)\n", + "\n", + "sample1 = samples[:, 0]\n", + "sample2 = samples[:, 1]\n", + "\n", + "cmap = plt.get_cmap('viridis')\n", + "\n", + "# Set the colorbar limits:\n", + "vmin = min(sample1.min(), sample2.min())\n", + "vmax = max(sample1.max(), sample2.max())\n", + "\n", + "# Save graph layout so that graph appears the same in every plot\n", + "kwargs = {'pos': pos, 'node_size': 120, 'width': 0.2}\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.8))\n", + "\n", + "# Plot sample #1\n", + "nx.draw(nx_graph, ax=ax1, cmap=cmap, node_color=sample1,\n", + " vmin=vmin, vmax=vmax, **kwargs)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax1)\n", + "ax1.set_title('Sample #1: $f(\\cdot)$ for $\\cdot$ in nodes, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", + "\n", + "\n", + "# Plot sample #2\n", + "nx.draw(nx_graph, ax=ax2, cmap=cmap, node_color=sample2,\n", + " vmin=vmin, vmax=vmax, **kwargs)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax2)\n", + "ax2.set_title('Sample #2: $f(\\cdot)$ for $\\cdot$ in nodes, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Citation\n", + "\n", + "If you are using the HammingGraph space and GeometricKernels, please consider citing\n", + "\n", + "```\n", + "@article{mostowsky2024,\n", + " title = {The GeometricKernels Package: Heat and Matérn Kernels for Geometric Learning on Manifolds, Meshes, and Graphs},\n", + " author = {Peter Mostowsky and Vincent Dutordoir and Iskander Azangulov and Noémie Jaquier and Michael John Hutchinson and Aditya Ravuri and Leonel Rozo and Alexander Terenin and Viacheslav Borovitskiy},\n", + " year = {2024},\n", + " journal = {arXiv:2407.08086},\n", + "}\n", + "```\n", + "\n", + "```\n", + "@inproceedings{doumont2025,\n", + " title = {Omnipresent Yet Overlooked: Heat Kernels in Combinatorial Bayesian Optimization},\n", + " author = {Colin Doumont and Victor Picheny and Viacheslav Borovitskiy and Henry Moss},\n", + " booktitle = {Advances in Neural Information Processing Systems},\n", + " year = {2025},\n", + "}\n", + "```\n", + "\n", + "```\n", + "@inproceedings{borovitskiy2023,\n", + " title={Isotropic Gaussian Processes on Finite Spaces of Graphs},\n", + " author={Borovitskiy, Viacheslav and Karimi, Mohammad Reza and Somnath, Vignesh Ram and Krause, Andreas},\n", + " booktitle={International Conference on Artificial Intelligence and Statistics},\n", + " year={2023},\n", + "}\n", + "```\n", + "\n", + "```\n", + "@inproceedings{kondor2002,\n", + " title={Diffusion Kernels on Graphs and Other Discrete Structures},\n", + " author={Kondor, Risi Imre and Lafferty, John},\n", + " booktitle={International Conference on Machine Learning},\n", + " year={2002}\n", + "}\n", + "```" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "geometrik", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.11" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tests/helper.py b/tests/helper.py index 96681d5a..e0d6ab70 100644 --- a/tests/helper.py +++ b/tests/helper.py @@ -11,6 +11,7 @@ DiscreteSpectrumSpace, Graph, GraphEdges, + HammingGraph, HodgeDiscreteSpectrumSpace, Hyperbolic, HypercubeGraph, @@ -71,6 +72,10 @@ def discrete_spectrum_spaces() -> List[DiscreteSpectrumSpace]: HypercubeGraph(1), HypercubeGraph(3), HypercubeGraph(6), + HammingGraph(1, 2), + HammingGraph(3, 3), + HammingGraph(2, 6), + HammingGraph(6, 4), Hypersphere(2), Hypersphere(3), Hypersphere(10), diff --git a/tests/spaces/test_eigenfunctions.py b/tests/spaces/test_eigenfunctions.py index c6a98b93..ffe7b6de 100644 --- a/tests/spaces/test_eigenfunctions.py +++ b/tests/spaces/test_eigenfunctions.py @@ -5,7 +5,12 @@ from opt_einsum import contract as einsum from geometric_kernels.kernels.matern_kernel import default_num -from geometric_kernels.spaces import CompactMatrixLieGroup, Hypersphere, Mesh +from geometric_kernels.spaces import ( + CompactMatrixLieGroup, + HammingGraph, + Hypersphere, + Mesh, +) from geometric_kernels.utils.utils import chain from ..helper import check_function_with_backend, discrete_spectrum_spaces @@ -57,10 +62,9 @@ def inputs(request): def test_call_eigenfunctions(inputs, backend): space, eigenfunctions, X, _, _ = inputs - if isinstance(space, CompactMatrixLieGroup): - pytest.skip( - "CompactMatrixLieGroup subclasses do not currently support eigenfunction evaluation" - ) + if isinstance(space, (CompactMatrixLieGroup, HammingGraph)): + space_name = type(space).__name__ + pytest.skip(f"{space_name} does not currently support eigenfunction evaluation") # Check that the eigenfunctions can be called, returning the right type and shape. check_function_with_backend( @@ -94,10 +98,9 @@ def test_numbers_of_eigenfunctions(inputs): def test_orthonormality(inputs, backend): space, eigenfunctions, _, _, _ = inputs - if isinstance(space, CompactMatrixLieGroup): - pytest.skip( - "CompactMatrixLieGroup subclasses do not currently support eigenfunction evaluation" - ) + if isinstance(space, (CompactMatrixLieGroup, HammingGraph)): + space_name = type(space).__name__ + pytest.skip(f"{space_name} does not currently support eigenfunction evaluation") key = np.random.RandomState(0) key, xs = space.random(key, 10000) @@ -117,10 +120,9 @@ def test_orthonormality(inputs, backend): def test_weighted_outerproduct_with_addition_theorem(inputs, backend): space, eigenfunctions, X, X2, weights = inputs - if isinstance(space, CompactMatrixLieGroup): - pytest.skip( - "CompactMatrixLieGroup subclasses do not currently support eigenfunction evaluation" - ) + if isinstance(space, (CompactMatrixLieGroup, HammingGraph)): + space_name = type(space).__name__ + pytest.skip(f"{space_name} does not currently support eigenfunction evaluation") chained_weights = chain( weights.squeeze(), eigenfunctions.num_eigenfunctions_per_level diff --git a/tests/spaces/test_hamming_graph.py b/tests/spaces/test_hamming_graph.py new file mode 100644 index 00000000..55cefa34 --- /dev/null +++ b/tests/spaces/test_hamming_graph.py @@ -0,0 +1,108 @@ +import lab as B +import numpy as np +import pytest +from plum import Tuple + +from geometric_kernels.kernels import MaternGeometricKernel +from geometric_kernels.spaces import HammingGraph, HypercubeGraph +from geometric_kernels.utils.kernel_formulas import hamming_graph_heat_kernel + +from ..helper import check_function_with_backend + + +@pytest.fixture(params=[(1, 2), (2, 2), (5, 2), (10, 2), (10, 4)]) +def inputs(request) -> Tuple[B.Numeric]: + """ + Returns a tuple (space, eigenfunctions, X, X2, weights) where: + - space is a HammingGraph object with (dim, n_cat) equal to request.param, + - eigenfunctions is the respective Eigenfunctions object with at most 5 levels, + - X is a random sample of random size from the space, + - X2 is another random sample of random size from the space, + - weights is an array of positive numbers of shape (eigenfunctions.num_levels, 1). + """ + d, q = request.param + space = HammingGraph(dim=d, n_cat=q) + eigenfunctions = space.get_eigenfunctions(min(space.dim + 1, 5)) + + key = np.random.RandomState(0) + N, N2 = key.randint(low=1, high=min(q**d, 10) + 1, size=2) + key, X = space.random(key, N) + key, X2 = space.random(key, N2) + + # These weights are used for testing the weighted outerproduct, they + # should be positive. + weights = np.random.rand(eigenfunctions.num_levels, 1) ** 2 + 1e-5 + + return space, eigenfunctions, X, X2, weights + + +def test_numbers_of_eigenfunctions(inputs): + space, eigenfunctions, _, _, _ = inputs + num_levels = eigenfunctions.num_levels + + # If the number of levels is maximal, check that the number of + # eigenfunctions is equal to the number of categorical vectors. + if num_levels == space.dim + 1: + assert eigenfunctions.num_eigenfunctions == space.n_cat**space.dim + + +@pytest.mark.parametrize("nu", [1.5, np.inf]) +@pytest.mark.parametrize("lengthscale", [1.0, 5.0, 10.0]) +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_reduces_to_hypercube_when_q_equals_2(inputs, nu, lengthscale, backend): + space, eigenfunctions, X, X2, _ = inputs + + if space.n_cat != 2: + pytest.skip("Only applicable when n_cat=2") + + hypercube = HypercubeGraph(space.dim) + X_bool = X.astype(bool) + X2_bool = X2.astype(bool) + + # Compare eigenvalues (backend-agnostic, only once per backend) + if lengthscale == 1.0 and nu == 1.5: + hamming_eigenvalues = space.get_eigenvalues(eigenfunctions.num_levels) + hypercube_eigenvalues = hypercube.get_eigenvalues(eigenfunctions.num_levels) + np.testing.assert_allclose( + hamming_eigenvalues, hypercube_eigenvalues, rtol=1e-10 + ) + + # Compare kernel values with backend testing + kernel_hamming = MaternGeometricKernel(space) + kernel_hypercube = MaternGeometricKernel(hypercube) + + params = {"nu": np.array([nu]), "lengthscale": np.array([lengthscale])} + K_hypercube = kernel_hypercube.K(params, X_bool, X2_bool) + + check_function_with_backend( + backend, + K_hypercube, + kernel_hamming.K, + params, + X, + X2, + atol=1e-2, + ) + + +@pytest.mark.parametrize("lengthscale", [1.0, 5.0, 10.0]) +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_against_analytic_heat_kernel(inputs, lengthscale, backend): + space, _, X, X2, _ = inputs + lengthscale = np.array([lengthscale]) + result = hamming_graph_heat_kernel(lengthscale, X, X2, q=space.n_cat) + + kernel = MaternGeometricKernel(space) + + # Check that MaternGeometricKernel on HammingGraph with nu=infinity + # coincides with the closed form expression for the heat kernel on the + # Hamming graph. + check_function_with_backend( + backend, + result, + kernel.K, + {"nu": np.array([np.inf]), "lengthscale": lengthscale}, + X, + X2, + atol=1e-2, + ) diff --git a/tests/utils/test_kernel_formulas.py b/tests/utils/test_kernel_formulas.py index 427acfc9..73137691 100644 --- a/tests/utils/test_kernel_formulas.py +++ b/tests/utils/test_kernel_formulas.py @@ -4,8 +4,11 @@ import pytest from sklearn.metrics.pairwise import rbf_kernel -from geometric_kernels.spaces import HypercubeGraph -from geometric_kernels.utils.kernel_formulas import hypercube_graph_heat_kernel +from geometric_kernels.spaces import HammingGraph, HypercubeGraph +from geometric_kernels.utils.kernel_formulas import ( + hamming_graph_heat_kernel, + hypercube_graph_heat_kernel, +) from ..helper import check_function_with_backend @@ -66,3 +69,115 @@ def heat_kernel(lengthscale, X, X2): X[0:1, :], X2[0:1, :], ) + + +@pytest.mark.parametrize("d", [1, 5, 10]) +@pytest.mark.parametrize("lengthscale", [1.0, 5.0, 10.0]) +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_hamming_graph_reduces_to_hypercube_when_q_equals_2(d, lengthscale, backend): + space = HypercubeGraph(d) + + key = np.random.RandomState(0) + N, N2 = key.randint(low=1, high=min(2**d, 10) + 1, size=2) + key, X = space.random(key, N) + key, X2 = space.random(key, N2) + + def heat_kernel_hamming(lengthscale, X, X2): + return hamming_graph_heat_kernel( + lengthscale, X, X2, q=2, normalized_laplacian=False + ) + + # Compute reference using hypercube formula + result = hypercube_graph_heat_kernel( + np.array([lengthscale]), X, X2, normalized_laplacian=False + ) + + # Check that general Hamming formula with q=2 matches hypercube + check_function_with_backend( + backend, + result, + heat_kernel_hamming, + np.array([lengthscale]), + X, + X2, + atol=1e-10, + ) + + +@pytest.mark.parametrize("d", [1, 5, 10]) +@pytest.mark.parametrize("q", [2, 5, 7]) +@pytest.mark.parametrize("lengthscale", [1.0, 5.0, 10.0]) +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_hamming_graph_heat_kernel_matches_rbf(d, q, lengthscale, backend): + space = HammingGraph(d, q) + + key = np.random.RandomState(0) + N, N2 = key.randint(low=1, high=min(q**d, 10) + 1, size=2) + key, X = space.random(key, N) + key, X2 = space.random(key, N2) + + def to_one_hot(X_cat, q): + """Convert categorical matrix [N, d] to one-hot [N, d*q].""" + N, d = X_cat.shape + X_onehot = np.zeros((N, d * q), dtype=float) + for i in range(N): + for j in range(d): + X_onehot[i, j * q + X_cat[i, j]] = 1.0 + return X_onehot + + X_onehot = to_one_hot(X, q) + X2_onehot = to_one_hot(X2, q) + + beta = lengthscale**2 / 2 + exp_neg_beta_q = np.exp(-beta * q) + factor_disagree = (1 - exp_neg_beta_q) / (1 + (q - 1) * exp_neg_beta_q) + gamma = -np.log(factor_disagree) / 2 # one-hot counts differences twice + + result = rbf_kernel(X_onehot, X2_onehot, gamma=gamma) + + def heat_kernel(lengthscale, X, X2): + return hamming_graph_heat_kernel( + lengthscale, X, X2, q=q, normalized_laplacian=False + ) + + # Checks that the heat kernel on the Hamming graph coincides with the RBF + # restricted onto categorical vectors, with appropriately redefined length scale. + check_function_with_backend( + backend, + result, + heat_kernel, + np.array([lengthscale]), + X, + X2, + atol=1e-10, + ) + + if d > 5: + X_first = X[0:1, :3] + X2_first = X2[0:1, :3] + X_second = X[0:1, 3:] + X2_second = X2[0:1, 3:] + + K_first = hamming_graph_heat_kernel( + np.array([lengthscale]), X_first, X2_first, q=q, normalized_laplacian=False + ) + K_second = hamming_graph_heat_kernel( + np.array([lengthscale]), + X_second, + X2_second, + q=q, + normalized_laplacian=False, + ) + + result = K_first * K_second + + # Checks that the heat kernel of the product is equal to the product + # of heat kernels. + check_function_with_backend( + backend, + result, + heat_kernel, + np.array([lengthscale]), + X[0:1, :], + X2[0:1, :], + ) diff --git a/tests/utils/test_special_functions.py b/tests/utils/test_special_functions.py index 21ce5414..61923234 100644 --- a/tests/utils/test_special_functions.py +++ b/tests/utils/test_special_functions.py @@ -5,7 +5,7 @@ import pytest from geometric_kernels.utils.special_functions import ( - kravchuk_normalized, + generalized_kravchuk_normalized, walsh_function, ) from geometric_kernels.utils.utils import binary_vectors_and_subsets, hamming_distance @@ -70,7 +70,9 @@ def test_kravchuk_polynomials(all_xs_and_combs, backend): ) def krav(x0, X): - return comb(d, j) * kravchuk_normalized(d, j, hamming_distance(x0, X)) + return comb(d, j) * generalized_kravchuk_normalized( + d, j, hamming_distance(x0, X), 2 + ) # Checks that Kravchuk polynomials coincide with certain sums of # the Walsh functions. @@ -94,10 +96,14 @@ def test_kravchuk_precomputed(all_xs_and_combs, backend): kravchuk_normalized_j_minus_1, kravchuk_normalized_j_minus_2 = None, None for j in range(d + 1): - cur_kravchuk_normalized = kravchuk_normalized(d, j, hamming_distance(x0, X)) + cur_kravchuk_normalized = generalized_kravchuk_normalized( + d, j, hamming_distance(x0, X), 2 + ) def krav(x0, X, kn1, kn2): - return kravchuk_normalized(d, j, hamming_distance(x0, X), kn1, kn2) + return generalized_kravchuk_normalized( + d, j, hamming_distance(x0, X), 2, kn1, kn2 + ) # Checks that Kravchuk polynomials coincide with certain sums of # the Walsh functions. From 19ebc609fa377b7ef1819d225a4f3a83918c32e7 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Sun, 16 Nov 2025 17:16:09 +0000 Subject: [PATCH 2/9] Fix docs building problems, add new theory page to the respective index, fix some phrasing/references. --- docs/index.rst | 2 ++ docs/theory/hamming_graph.rst | 8 ++++---- docs/theory/index.rst | 1 + 3 files changed, 7 insertions(+), 4 deletions(-) diff --git a/docs/index.rst b/docs/index.rst index 2970d9bd..d5698e32 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -32,11 +32,13 @@ Before doing anything, you might want to create and activate a new virtual envir .. code-block:: bash uv venv --python python[version] [venv_dir] + where [env_dir] is the directory (default is `.venv`) of the environment and [version] is the version of Python you want to use, we currently support 3.9, 3.10, 3.11, 3.12. [Optional] activate the environment. However, this is not strictly necessary for `uv`. Instead, use tools like `uv run python` to run Python inside the environment. See `uv documentation ` for more details. .. code-block:: bash + source [venv_dir]/bin/activate .. raw:: html diff --git a/docs/theory/hamming_graph.rst b/docs/theory/hamming_graph.rst index 81f632d0..b665d5d1 100644 --- a/docs/theory/hamming_graph.rst +++ b/docs/theory/hamming_graph.rst @@ -5,7 +5,7 @@ .. warning:: You can get by fine without reading this page for almost all use cases, just use the standard :class:`~.kernels.MaternGeometricKernel`, following the respective :doc:`example notebook `. - This is optional material meant to explain the basic theory and based mainly on :cite:t:`borovitskiy2023`. + This is optional material meant to explain the basic theory and based mainly on :cite:t:`doumont2025` and :cite:t:`borovitskiy2023`. ========================== Motivation @@ -21,10 +21,10 @@ Structure of the Space The elements of this space—given its `dim` is $d \in \mathbb{Z}_{>0}$ and `n_cat` is $q \in \mathbb{Z}_{>1}$—are exactly the categorical vectors of length $d$ where each component is in $\{0, 1, ..., q-1\}$. -The geometry of this space is simple: it is a graph such that $x, x' \in H(d,q)$ are connected by an edge if and only if they differ in exactly one coordinate (i.e. there is exactly *Hamming distance* $1$ between them). +The geometry of this space is simple: it is a graph such that $x, x' \in H(d,q)$ are connected by an edge if and only if they differ in exactly one coordinate (i.e. *Hamming distance* $1$ between them is exactly $1$). Being a graph, $H(d,q)$ could also be represented using the general :class:`~.spaces.Graph` space. -However, the number of nodes in $H(d,q)$ is $q^d$, which is exponential in $d$ (and grows rapidly with $q$), rendering the general techniques infeasible. +However, the number of nodes in $H(d,q)$ is $q^d$, which is exponential in $d$ (and grows rapidly with $q$), rendering the general graph representation intractable in most cases. ========================== Eigenfunctions @@ -40,7 +40,7 @@ $$ $$ where $\omega_q = e^{2\pi i/q}$ is a primitive $q$-th root of unity and $x = (x_0, \ldots, x_{d-1}) \in H(d,q)$. -The eigenfunctions with the same number of non-zero frequency components $j = |\{i : s_i \neq 0\}|$ share the same eigenvalue $\lambda_j = (q-1)j / d$ and form a *level* $j$. The dimension of level $j$ is $\binom{d}{j}(q-1)^j$. +The eigenfunctions with the same number of non-zero frequency components $j = \lvert\{i : s_i \neq 0\}\rvert$ share the same eigenvalue $\lambda_j = (q-1)j / d$ and form a *level* $j$. The dimension of level $j$ is $\binom{d}{j}(q-1)^j$. However, the problem is that the number of eigenfunctions is $q^d$. Hence naive truncation of the sum in the kernel formula to a few hundred terms leads to a poor approximation of the kernel for larger $d$ or $q$. diff --git a/docs/theory/index.rst b/docs/theory/index.rst index 71916b75..c6d37f68 100644 --- a/docs/theory/index.rst +++ b/docs/theory/index.rst @@ -14,3 +14,4 @@ Product kernels Feature maps and sampling Hypercube graph space + Hamming graph space From 20816aa5e2bde7cf7b6d8cd0c5b913805467eb37 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Sun, 16 Nov 2025 17:20:27 +0000 Subject: [PATCH 3/9] Rename to and move it into a separate module. Replace asserts with proper exceptions. Remove parameter in --- geometric_kernels/kernels/__init__.py | 3 + geometric_kernels/kernels/karhunen_loeve.py | 53 ---------- geometric_kernels/kernels/matern_kernel.py | 19 +--- .../kernels/matern_kernel_hamming_graph.py | 96 +++++++++++++++++++ geometric_kernels/spaces/hamming_graph.py | 16 ++-- .../utils/kernel_formulas/hamming_graph.py | 7 +- 6 files changed, 118 insertions(+), 76 deletions(-) create mode 100644 geometric_kernels/kernels/matern_kernel_hamming_graph.py diff --git a/geometric_kernels/kernels/__init__.py b/geometric_kernels/kernels/__init__.py index c404c291..890a4dec 100644 --- a/geometric_kernels/kernels/__init__.py +++ b/geometric_kernels/kernels/__init__.py @@ -15,4 +15,7 @@ MaternGeometricKernel, default_feature_map, ) +from geometric_kernels.kernels.matern_kernel_hamming_graph import ( + MaternKernelHammingGraph, +) from geometric_kernels.kernels.product import ProductGeometricKernel diff --git a/geometric_kernels/kernels/karhunen_loeve.py b/geometric_kernels/kernels/karhunen_loeve.py index 21f3c798..0aa3625d 100644 --- a/geometric_kernels/kernels/karhunen_loeve.py +++ b/geometric_kernels/kernels/karhunen_loeve.py @@ -11,9 +11,6 @@ from geometric_kernels.lab_extras import from_numpy, is_complex from geometric_kernels.spaces import DiscreteSpectrumSpace from geometric_kernels.spaces.eigenfunctions import Eigenfunctions -from geometric_kernels.utils.kernel_formulas.hamming_graph import ( - hamming_graph_heat_kernel, -) from geometric_kernels.utils.utils import _check_1_vector, _check_field_in_params @@ -256,53 +253,3 @@ def K_diag(self, params: Dict[str, B.Numeric], X: B.Numeric, **kwargs) -> B.Nume return B.real(K_diag) else: return K_diag - - -class FastMaternForHammingGraph(MaternKarhunenLoeveKernel): - r""" - For $\nu = \infty$, there exists a closed-form formula for the heat kernel - on Hamming graphs (including the binary hypercube case). - - .. note:: - We only use the fast path if we have ALL levels (exact computation). - When truncated to fewer levels, we must use the parent class implementation - to ensure consistency with feature map approximations. - """ - - def K( - self, - params: Dict[str, B.Numeric], - X: B.Numeric, - X2: Optional[B.Numeric] = None, - **kwargs, - ) -> B.Numeric: - assert "nu" in params - assert params["nu"].shape == (1,) - - if B.all(params["nu"] == np.inf): - d = X.shape[-1] - - # Only use fast path when we have all levels (exact computation) - if self.num_levels == d + 1: - assert "lengthscale" in params - assert params["lengthscale"].shape == (1,) - - # Get q from space (HammingGraph has n_cat, HypercubeGraph is binary q=2) - q = getattr(self.space, "n_cat", 2) - - return hamming_graph_heat_kernel(params["lengthscale"], X, X2, q=q) - - return super().K(params, X, X2, **kwargs) - - def K_diag(self, params: Dict[str, B.Numeric], X: B.Numeric, **kwargs) -> B.Numeric: - assert "nu" in params - assert params["nu"].shape == (1,) - - if B.all(params["nu"] == np.inf): - d = X.shape[-1] - - # Only use fast path when we have all levels (exact computation) - if self.num_levels == d + 1: - return B.ones(B.dtype(params["nu"]), X.shape[0]) - - return super().K_diag(params, X, **kwargs) diff --git a/geometric_kernels/kernels/matern_kernel.py b/geometric_kernels/kernels/matern_kernel.py index 24fbf789..0fe8795a 100644 --- a/geometric_kernels/kernels/matern_kernel.py +++ b/geometric_kernels/kernels/matern_kernel.py @@ -20,9 +20,9 @@ from geometric_kernels.kernels.base import BaseGeometricKernel from geometric_kernels.kernels.feature_map import MaternFeatureMapKernel from geometric_kernels.kernels.hodge_compositional import MaternHodgeCompositionalKernel -from geometric_kernels.kernels.karhunen_loeve import ( - FastMaternForHammingGraph, - MaternKarhunenLoeveKernel, +from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel +from geometric_kernels.kernels.matern_kernel_hamming_graph import ( + MaternKernelHammingGraph, ) from geometric_kernels.spaces import ( CompactMatrixLieGroup, @@ -281,7 +281,6 @@ def __new__( num: int = None, normalize: bool = True, return_feature_map: bool = False, - fast_matern: bool = False, **kwargs, ): r""" @@ -331,14 +330,6 @@ def __new__( Default is False. - :param fast_matern: - If `True`, use optimized kernel implementations when available. - Currently applies to :class:`~.spaces.HypercubeGraph`, where an - analytic closed-form formula is used for the heat kernel (infinite - smoothness, $\nu = \infty$) when all eigenvalue levels are included. - - Defaults to True. - :param ``**kwargs``: Any additional keyword arguments to be passed to the kernel (like `key`). @@ -354,8 +345,8 @@ def __new__( num = num or default_num(space) if isinstance(space, HodgeDiscreteSpectrumSpace): kernel = MaternHodgeCompositionalKernel(space, num, normalize=normalize) - elif isinstance(space, (HypercubeGraph, HammingGraph)) and fast_matern: - kernel = FastMaternForHammingGraph(space, num, normalize=normalize) + elif isinstance(space, (HypercubeGraph, HammingGraph)): + kernel = MaternKernelHammingGraph(space, num, normalize=normalize) else: kernel = MaternKarhunenLoeveKernel(space, num, normalize=normalize) if return_feature_map: diff --git a/geometric_kernels/kernels/matern_kernel_hamming_graph.py b/geometric_kernels/kernels/matern_kernel_hamming_graph.py new file mode 100644 index 00000000..a262429c --- /dev/null +++ b/geometric_kernels/kernels/matern_kernel_hamming_graph.py @@ -0,0 +1,96 @@ +r""" +This module provides the :class:`MaternKernelHammingGraph` kernel, a subclass of +:class:`MaternKarhunenLoeveKernel` for :class:`HammingGraph` and +:class:`HypercubeGraph` spaces implementing the closed-form formula for the +heat kernel when $\nu = \infty$. +""" + +import lab as B +import numpy as np +from beartype.typing import Dict, Optional, Union + +from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel +from geometric_kernels.spaces.eigenfunctions import Eigenfunctions +from geometric_kernels.spaces.hamming_graph import HammingGraph +from geometric_kernels.spaces.hypercube_graph import HypercubeGraph +from geometric_kernels.utils.kernel_formulas.hamming_graph import ( + hamming_graph_heat_kernel, +) +from geometric_kernels.utils.utils import _check_1_vector, _check_field_in_params + + +class MaternKernelHammingGraph(MaternKarhunenLoeveKernel): + r""" + For $\nu = \infty$, there exists a closed-form formula for the heat kernel + on hamming graphs :class:`HammingGraph` (including the binary hypercube case + :class:`HypercubeGraph`). This class extends :class:`MaternKarhunenLoeveKernel` + to implement this formula in the case of $\nu = \infty$ for efficiency. + + .. note:: + We only use the closed form expression if `num_levels` is `d + 1` which + corresponds to exact computation. When truncated to fewer levels, we + must use the parent class implementation to ensure consistency with + feature map approximations. + """ + + def __init__( + self, + space: Union[HammingGraph, HypercubeGraph], + num_levels: int, + normalize: bool = True, + eigenvalues_laplacian: Optional[B.Numeric] = None, + eigenfunctions: Optional[Eigenfunctions] = None, + ): + if not isinstance(space, (HammingGraph, HypercubeGraph)): + raise ValueError( + f"`space` must be an instance of HammingGraph or HypercubeGraph, but got {type(space)}" + ) + + super().__init__( + space, + num_levels, + normalize, + eigenvalues_laplacian, + eigenfunctions, + ) + + def K( + self, + params: Dict[str, B.Numeric], + X: B.Numeric, + X2: Optional[B.Numeric] = None, + **kwargs, + ) -> B.Numeric: + _check_field_in_params(params, "lengthscale") + _check_1_vector(params["lengthscale"], 'params["lengthscale"]') + + _check_field_in_params(params, "nu") + _check_1_vector(params["nu"], 'params["nu"]') + + if B.all(params["nu"] == np.inf): + d = X.shape[-1] + + # Only use fast path when we have all levels (exact computation) + if self.num_levels == d + 1: + # Get q from space (HammingGraph has n_cat, HypercubeGraph is binary q=2) + q = getattr(self.space, "n_cat", 2) + + return hamming_graph_heat_kernel(params["lengthscale"], X, X2, q=q) + + return super().K(params, X, X2, **kwargs) + + def K_diag(self, params: Dict[str, B.Numeric], X: B.Numeric, **kwargs) -> B.Numeric: + _check_field_in_params(params, "lengthscale") + _check_1_vector(params["lengthscale"], 'params["lengthscale"]') + + _check_field_in_params(params, "nu") + _check_1_vector(params["nu"], 'params["nu"]') + + if B.all(params["nu"] == np.inf): + d = X.shape[-1] + + # Only use fast path when we have all levels (exact computation) + if self.num_levels == d + 1: + return B.ones(B.dtype(params["nu"]), X.shape[0]) + + return super().K_diag(params, X, **kwargs) diff --git a/geometric_kernels/spaces/hamming_graph.py b/geometric_kernels/spaces/hamming_graph.py index df264505..1cc46037 100644 --- a/geometric_kernels/spaces/hamming_graph.py +++ b/geometric_kernels/spaces/hamming_graph.py @@ -9,7 +9,7 @@ import numpy as np from beartype.typing import List, Optional -from geometric_kernels.lab_extras import dtype_double, dtype_integer, float_like +from geometric_kernels.lab_extras import dtype_integer, float_like from geometric_kernels.spaces.base import DiscreteSpectrumSpace from geometric_kernels.spaces.eigenfunctions import ( Eigenfunctions, @@ -53,7 +53,8 @@ class VilenkinFunctions(EigenfunctionsWithAdditionTheorem): """ def __init__(self, dim: int, n_cat: int, num_levels: int) -> None: - assert num_levels <= dim + 1, "The number of levels should be at most dim+1." + if num_levels > dim + 1: + raise ValueError("The number of levels should be at most `dim`+1.") self.dim = dim self.n_cat = n_cat self._num_levels = num_levels @@ -196,6 +197,11 @@ class HammingGraph(DiscreteSpectrumSpace): Levels are the whole eigenspaces. + .. note:: + If you need a kernel operating on categorical vectors where $q$ varies + between dimensions, you can use `HammingGraph` in conjunction with + :class:`ProductGeometricKernel` or :class:`ProductDiscreteSpectrumSpace`. + .. note:: For the special case $q = 2$, this reduces to the binary hypercube graph, also available as :class:`HypercubeGraph`. @@ -294,12 +300,10 @@ def random(self, key: B.RandomState, number: int) -> B.Numeric: :return: An array of `number` uniformly random samples on the space. """ - key, random_points = B.random.rand( - key, dtype_double(key), number, self.dimension + key, random_points = B.random.randint( + key, dtype_integer(key), number, self.dimension, lower=0, upper=self.n_cat ) - random_points = B.cast(dtype_integer(key), B.floor(random_points * self.n_cat)) - return key, random_points @property diff --git a/geometric_kernels/utils/kernel_formulas/hamming_graph.py b/geometric_kernels/utils/kernel_formulas/hamming_graph.py index 2243b401..487752c3 100644 --- a/geometric_kernels/utils/kernel_formulas/hamming_graph.py +++ b/geometric_kernels/utils/kernel_formulas/hamming_graph.py @@ -10,6 +10,7 @@ from beartype.typing import Optional from geometric_kernels.lab_extras import float_like +from geometric_kernels.utils.utils import _check_1_vector, _check_matrix def hamming_graph_heat_kernel( @@ -40,9 +41,9 @@ def hamming_graph_heat_kernel( if X2 is None: X2 = X - assert lengthscale.shape == (1,) - assert X.ndim == 2 and X2.ndim == 2 - assert X.shape[-1] == X2.shape[-1] + _check_1_vector(lengthscale, "lengthscale") + _check_matrix(X, "X") + _check_matrix(X2, "X2") d = X.shape[-1] From 21166a7a50cd5251b3f101adc627ecb6d9165dc3 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Sun, 16 Nov 2025 17:21:31 +0000 Subject: [PATCH 4/9] Update and rerun Hamming-graph-related notebooks. --- notebooks/FastMaternForHammingGraph.ipynb | 66 ++++++++++++----------- notebooks/HammingGraph.ipynb | 52 +++++++++--------- 2 files changed, 60 insertions(+), 58 deletions(-) diff --git a/notebooks/FastMaternForHammingGraph.ipynb b/notebooks/FastMaternForHammingGraph.ipynb index 497d3571..1e5a2da5 100644 --- a/notebooks/FastMaternForHammingGraph.ipynb +++ b/notebooks/FastMaternForHammingGraph.ipynb @@ -9,12 +9,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "/opt/miniconda3/envs/geometrik/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n", "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", - "/opt/miniconda3/envs/geometrik/lib/python3.11/site-packages/spherical_harmonics/fundamental_set.py:21: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n", - " from pkg_resources import resource_filename\n", "INFO (geometric_kernels): Torch backend enabled.\n" ] } @@ -29,7 +25,7 @@ "import geometric_kernels\n", "import geometric_kernels.torch\n", "from geometric_kernels.spaces import HypercubeGraph, HammingGraph\n", - "from geometric_kernels.kernels import MaternGeometricKernel\n", + "from geometric_kernels.kernels import MaternGeometricKernel, MaternKernelHammingGraph\n", "from geometric_kernels.frontends.gpytorch import GPyTorchGeometricKernel\n", "from botorch.fit import fit_gpytorch_mll" ] @@ -140,19 +136,19 @@ "text": [ "fast_matern: False\n", "\n", - "training: 10.7532 s\n", - "prediction: 2.2959 s\n", - "RMSE: 0.5953\n", + "training: 68.8307 s\n", + "prediction: 1.0435 s\n", + "RMSE: 0.5972\n", "\n", - "lengthscale: 5.3399\n", - "outputscale: 1.3710\n", + "lengthscale: 3.8122\n", + "outputscale: 0.0225\n", "\n", "----------------------------------------------------------------------------------------------------\n", "\n", "fast_matern: True\n", "\n", - "training: 37.6229 s\n", - "prediction: 1.2217 s\n", + "training: 68.1158 s\n", + "prediction: 0.9751 s\n", "RMSE: 0.5972\n", "\n", "lengthscale: 3.8122\n", @@ -169,10 +165,13 @@ " print(f\"fast_matern: {fast_matern}\")\n", " print(\"\")\n", "\n", - " hypercube_graph = HypercubeGraph(SPACE_DIM)\n", - " kernel = MaternGeometricKernel(hypercube_graph, fast_matern=fast_matern)\n", + " graph = HypercubeGraph(SPACE_DIM)\n", + " if fast_matern:\n", + " kernel = MaternKernelHammingGraph(graph, num_levels=SPACE_DIM+1)\n", + " else:\n", + " kernel = MaternGeometricKernel(graph)\n", "\n", - " data = generate_data(hypercube_graph, Ackley, NUM_TRAIN, NUM_TEST)\n", + " data = generate_data(graph, Ackley, NUM_TRAIN, NUM_TEST)\n", "\n", " scaled_kernel, lik_fct = get_kernel_and_likelihood(kernel)\n", "\n", @@ -197,23 +196,23 @@ "text": [ "fast_matern: False\n", "\n", - "training: 65.4289 s\n", - "prediction: 2.7725 s\n", - "RMSE: 0.5869\n", + "training: 55.4799 s\n", + "prediction: 0.9727 s\n", + "RMSE: 0.5901\n", "\n", - "lengthscale: 3.7185\n", - "outputscale: 0.0219\n", + "lengthscale: 3.6613\n", + "outputscale: 0.0222\n", "\n", "----------------------------------------------------------------------------------------------------\n", "\n", "fast_matern: True\n", "\n", - "training: 50.6489 s\n", - "prediction: 1.3516 s\n", - "RMSE: 0.5869\n", + "training: 55.5970 s\n", + "prediction: 0.9783 s\n", + "RMSE: 0.5901\n", "\n", - "lengthscale: 3.7185\n", - "outputscale: 0.0219\n", + "lengthscale: 3.6613\n", + "outputscale: 0.0222\n", "\n", "----------------------------------------------------------------------------------------------------\n", "\n" @@ -226,10 +225,13 @@ " print(f\"fast_matern: {fast_matern}\")\n", " print(\"\")\n", "\n", - " hypercube_graph = HammingGraph(SPACE_DIM, 2)\n", - " kernel = MaternGeometricKernel(hypercube_graph, fast_matern=fast_matern)\n", + " graph = HammingGraph(SPACE_DIM, 2)\n", + " if fast_matern:\n", + " kernel = MaternKernelHammingGraph(graph, num_levels=SPACE_DIM+1)\n", + " else:\n", + " kernel = MaternGeometricKernel(graph)\n", "\n", - " data = generate_data(hypercube_graph, Ackley, NUM_TRAIN, NUM_TEST)\n", + " data = generate_data(graph, Ackley, NUM_TRAIN, NUM_TEST)\n", "\n", " scaled_kernel, lik_fct = get_kernel_and_likelihood(kernel)\n", "\n", @@ -246,9 +248,9 @@ ], "metadata": { "kernelspec": { - "display_name": "geometrik", + "display_name": "gkconda_updated_sh", "language": "python", - "name": "python3" + "name": "gkconda_updated_sh" }, "language_info": { "codemirror_mode": { @@ -260,9 +262,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.11" + "version": "3.10.13" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/notebooks/HammingGraph.ipynb b/notebooks/HammingGraph.ipynb index 6f7d84d6..4c3bcd32 100644 --- a/notebooks/HammingGraph.ipynb +++ b/notebooks/HammingGraph.ipynb @@ -24,6 +24,8 @@ "\n", "This notebook shows how to define and evaluate kernels on q-ary Hamming graphs $H(d,q)$ for modeling data encoded as categorical vectors with kernels that respect the geometry of the Hamming distance.\n", "\n", + "**Note:** If you need a kernel operating on categorical vectors where $q$ varies between dimensions, you can use`HammingGraph` in conjunction with [product kernels](https://geometric-kernels.github.io/GeometricKernels/theory/product_kernels.html) or [product spaces](https://geometric-kernels.github.io/GeometricKernels/theory/product_spaces.html).\n", + "\n", "**Note:** When $q=2$, the Hamming graph $H(d,2)$ reduces to the hypercube graph $C^d = \\{0, 1\\}^d$ (see `HypercubeGraph.ipynb`).\n", "\n", "At the very end of the notebook we also show how to construct *approximate finite-dimensional feature maps* for the kernels on the Hamming graph and how to use these to efficiently sample the Gaussian processes $\\mathrm{GP}(0, k)$.\n", @@ -73,9 +75,7 @@ "output_type": "stream", "text": [ "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", - "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", - "/opt/miniconda3/envs/geometrik/lib/python3.11/site-packages/spherical_harmonics/fundamental_set.py:21: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n", - " from pkg_resources import resource_filename\n" + "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n" ] } ], @@ -146,7 +146,7 @@ "There is also an optional second parameter `num` which determines the order of approximation of the kernel (*number of levels*).\n", "There is a sensible default value for each of the spaces in the library, so change it only if you know what you are doing.\n", "\n", - "A brief account on theory behind the kernels on the Hamming graph space can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/TODO.html)." + "A brief account on theory behind the kernels on the Hamming graph space can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/hamming_graph.html)." ] }, { @@ -244,9 +244,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "[[0 1 1 2]\n", - " [2 0 0 2]\n", - " [2 2 1 1]] int32\n" + "[[2 1 0 0]\n", + " [0 1 1 1]\n", + " [2 2 2 0]] int32\n" ] } ], @@ -289,7 +289,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -414,7 +414,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -541,19 +541,19 @@ "output_type": "stream", "text": [ "xs (shape = (3, 4)):\n", - "[[0 1 1 2]\n", - " [2 0 0 2]\n", - " [2 2 1 1]]\n", + "[[2 1 0 0]\n", + " [0 1 1 1]\n", + " [2 2 2 0]]\n", "\n", "emedding (shape = (3, 15000)):\n", - "[[ 0.00701236 -0.00344909 -0.00625436 ... -0.00625436 0.00705406\n", - " -0.00205084]\n", - " [ 0.00715692 -0.00352019 -0.00638329 ... -0.00638329 -0.00575958\n", - " 0.00418624]\n", - " [ 0.00690437 0.0271678 0.04926436 ... 0.01231609 -0.00555634\n", - " -0.00807703]]\n", + "[[ 0.00699769 -0.0137675 0.01248256 ... 0.01248256 -0.00563144\n", + " -0.0081862 ]\n", + " [ 0.00711193 -0.00349806 -0.00634317 ... -0.00634317 -0.00572338\n", + " 0.00415992]\n", + " [ 0.00692829 0.00681548 -0.00617938 ... -0.00617938 0.00696949\n", + " -0.00202625]]\n", "\n", - "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 0.016708524516172243\n" + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 0.02531349719744118\n" ] } ], @@ -601,9 +601,9 @@ "output_type": "stream", "text": [ "Two samples evaluated at the xs are:\n", - "[[-172.18988516 -134.87645627]\n", - " [-221.5365812 -297.66287804]\n", - " [ 121.27478634 -446.6551314 ]]\n" + "[[-130.9953739 -177.25877559]\n", + " [ 41.14356715 136.7170067 ]\n", + " [ 79.75263457 -217.72826631]]\n" ] } ], @@ -638,7 +638,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -736,9 +736,9 @@ "provenance": [] }, "kernelspec": { - "display_name": "geometrik", + "display_name": "gkconda_updated_sh", "language": "python", - "name": "python3" + "name": "gkconda_updated_sh" }, "language_info": { "codemirror_mode": { @@ -750,7 +750,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.11" + "version": "3.10.13" } }, "nbformat": 4, From ac9822618d03e40fefff8ecaa41fa83c53e6aca5 Mon Sep 17 00:00:00 2001 From: ColinDoumont Date: Tue, 18 Nov 2025 17:12:04 +0100 Subject: [PATCH 5/9] Fix mistake in eigenvalue formula --- docs/theory/hamming_graph.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/theory/hamming_graph.rst b/docs/theory/hamming_graph.rst index b665d5d1..bba9cf61 100644 --- a/docs/theory/hamming_graph.rst +++ b/docs/theory/hamming_graph.rst @@ -40,7 +40,7 @@ $$ $$ where $\omega_q = e^{2\pi i/q}$ is a primitive $q$-th root of unity and $x = (x_0, \ldots, x_{d-1}) \in H(d,q)$. -The eigenfunctions with the same number of non-zero frequency components $j = \lvert\{i : s_i \neq 0\}\rvert$ share the same eigenvalue $\lambda_j = (q-1)j / d$ and form a *level* $j$. The dimension of level $j$ is $\binom{d}{j}(q-1)^j$. +The eigenfunctions with the same number of non-zero frequency components $j = \lvert\{i : s_i \neq 0\}\rvert$ share the same eigenvalue $\lambda_j = \frac{q j}{(q-1)d}$ and form a *level* $j$. The dimension of level $j$ is $\binom{d}{j}(q-1)^j$. However, the problem is that the number of eigenfunctions is $q^d$. Hence naive truncation of the sum in the kernel formula to a few hundred terms leads to a poor approximation of the kernel for larger $d$ or $q$. From fb355e780d2b23b74d1341589245a012dbb81916 Mon Sep 17 00:00:00 2001 From: ColinDoumont Date: Tue, 18 Nov 2025 17:13:28 +0100 Subject: [PATCH 6/9] Move dtype casting to a more relevant location --- geometric_kernels/feature_maps/random_phase.py | 2 +- geometric_kernels/utils/utils.py | 6 ++---- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/geometric_kernels/feature_maps/random_phase.py b/geometric_kernels/feature_maps/random_phase.py index 2956a6a4..3b839d90 100644 --- a/geometric_kernels/feature_maps/random_phase.py +++ b/geometric_kernels/feature_maps/random_phase.py @@ -109,7 +109,7 @@ def __call__( weights = B.power(spectrum, 0.5) # [L, 1] - random_phases_b = B.cast(dtype, from_numpy(X, random_phases)) + random_phases_b = B.cast(B.dtype(X), from_numpy(X, random_phases)) phi_product = self.eigenfunctions.phi_product( X, random_phases_b, **params diff --git a/geometric_kernels/utils/utils.py b/geometric_kernels/utils/utils.py index 4f5e9f42..3d84769d 100644 --- a/geometric_kernels/utils/utils.py +++ b/geometric_kernels/utils/utils.py @@ -298,7 +298,7 @@ def get_resource_file_path(filename: str): yield path -def hamming_distance(x1: B.Bool, x2: B.Bool): +def hamming_distance(x1: B.Int, x2: B.Int): """ Hamming distance between two batches of boolean vectors. @@ -311,9 +311,7 @@ def hamming_distance(x1: B.Bool, x2: B.Bool): An array of shape [N, M] whose entry n, m contains the Hamming distance between x1[n, :] and x2[m, :]. It is of the same backend as x1 and x2. """ - x1_int = B.cast(int_like(x1), x1) - x2_int = B.cast(int_like(x2), x2) - return count_nonzero(x1_int[:, None, :] != x2_int[None, :, :], axis=-1) + return count_nonzero(x1[:, None, :] != x2[None, :, :], axis=-1) def log_binomial(n: B.Int, k: B.Int) -> B.Float: From a30d13e35d757a8081dc23f5c324288c3f3b18ba Mon Sep 17 00:00:00 2001 From: ColinDoumont Date: Tue, 18 Nov 2025 17:14:32 +0100 Subject: [PATCH 7/9] Improve consistency with existing hypercube tests --- tests/utils/test_kernel_formulas.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/tests/utils/test_kernel_formulas.py b/tests/utils/test_kernel_formulas.py index 73137691..10cce9e2 100644 --- a/tests/utils/test_kernel_formulas.py +++ b/tests/utils/test_kernel_formulas.py @@ -100,7 +100,6 @@ def heat_kernel_hamming(lengthscale, X, X2): np.array([lengthscale]), X, X2, - atol=1e-10, ) @@ -108,7 +107,7 @@ def heat_kernel_hamming(lengthscale, X, X2): @pytest.mark.parametrize("q", [2, 5, 7]) @pytest.mark.parametrize("lengthscale", [1.0, 5.0, 10.0]) @pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) -def test_hamming_graph_heat_kernel_matches_rbf(d, q, lengthscale, backend): +def test_hamming_graph_heat_kernel(d, q, lengthscale, backend): space = HammingGraph(d, q) key = np.random.RandomState(0) @@ -149,7 +148,7 @@ def heat_kernel(lengthscale, X, X2): np.array([lengthscale]), X, X2, - atol=1e-10, + atol=1e-2, ) if d > 5: From 476347228b397ac587291c790aef7068ffeee0de Mon Sep 17 00:00:00 2001 From: ColinDoumont Date: Tue, 18 Nov 2025 18:37:44 +0100 Subject: [PATCH 8/9] Remove unused import --- geometric_kernels/utils/utils.py | 1 - 1 file changed, 1 deletion(-) diff --git a/geometric_kernels/utils/utils.py b/geometric_kernels/utils/utils.py index 3d84769d..481f6f89 100644 --- a/geometric_kernels/utils/utils.py +++ b/geometric_kernels/utils/utils.py @@ -19,7 +19,6 @@ get_random_state, restore_random_state, ) -from geometric_kernels.lab_extras.extras import int_like def chain(elements: B.Numeric, repetitions: List[int]) -> B.Numeric: From 72de82e6e7067e86962d9bbf5107eeb44d889ac9 Mon Sep 17 00:00:00 2001 From: ColinDoumont Date: Tue, 18 Nov 2025 19:35:56 +0100 Subject: [PATCH 9/9] Update benchmarking notebook --- notebooks/FastMaternForHammingGraph.ipynb | 270 ---------------------- notebooks/other/HammingGraphTiming.ipynb | 233 +++++++++++++++++++ 2 files changed, 233 insertions(+), 270 deletions(-) delete mode 100644 notebooks/FastMaternForHammingGraph.ipynb create mode 100644 notebooks/other/HammingGraphTiming.ipynb diff --git a/notebooks/FastMaternForHammingGraph.ipynb b/notebooks/FastMaternForHammingGraph.ipynb deleted file mode 100644 index 1e5a2da5..00000000 --- a/notebooks/FastMaternForHammingGraph.ipynb +++ /dev/null @@ -1,270 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", - "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", - "INFO (geometric_kernels): Torch backend enabled.\n" - ] - } - ], - "source": [ - "import warnings\n", - "import time\n", - "import numpy as np\n", - "import torch\n", - "import gpytorch\n", - "import botorch\n", - "import geometric_kernels\n", - "import geometric_kernels.torch\n", - "from geometric_kernels.spaces import HypercubeGraph, HammingGraph\n", - "from geometric_kernels.kernels import MaternGeometricKernel, MaternKernelHammingGraph\n", - "from geometric_kernels.frontends.gpytorch import GPyTorchGeometricKernel\n", - "from botorch.fit import fit_gpytorch_mll" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "def Ackley(x):\n", - " \"\"\"\n", - " The Ackley Function. See https://www.sfu.ca/~ssurjano/ackley.html for details.\n", - " \"\"\"\n", - "\n", - " num_dims = x.shape[1]\n", - " a = 20\n", - " b = 0.2\n", - " c = 2 * np.pi\n", - "\n", - " sum1 = (x**2).sum(axis=1)\n", - " sum2 = (np.cos(c * x)).sum(axis=1)\n", - "\n", - " term1 = -a * np.exp(-b * np.sqrt(sum1 / num_dims))\n", - " term2 = -np.exp(sum2 / num_dims)\n", - "\n", - " return (term1 + term2 + a + np.exp(1)).reshape(-1, 1)\n", - "\n", - "\n", - "def generate_data(space, obj_fun, num_train, num_test):\n", - " key = np.random.RandomState(1234)\n", - " key, x_train = space.random(key, num_train)\n", - " key, x_test = space.random(key, num_test)\n", - "\n", - " y_train = obj_fun(x_train)\n", - " y_test = obj_fun(x_test)\n", - "\n", - " data = [\n", - " torch.tensor(x, dtype=torch.float64) for x in [x_train, y_train, x_test, y_test]\n", - " ]\n", - "\n", - " return data\n", - "\n", - "\n", - "def get_kernel_and_likelihood(kernel):\n", - " scaled_kernel = gpytorch.kernels.ScaleKernel(GPyTorchGeometricKernel(kernel))\n", - "\n", - " noise_prior = gpytorch.priors.torch_priors.GammaPrior(1.1, 0.05)\n", - " noise_prior_mode = (noise_prior.concentration - 1) / noise_prior.rate\n", - " lik_fct = gpytorch.likelihoods.gaussian_likelihood.GaussianLikelihood(\n", - " noise_prior=noise_prior,\n", - " noise_constraint=gpytorch.constraints.GreaterThan(1e-8),\n", - " initial_value=noise_prior_mode,\n", - " )\n", - "\n", - " return scaled_kernel, lik_fct\n", - "\n", - "\n", - "def fit_predict(data, scaled_kernel, lik_fct):\n", - " x_train, y_train, x_test, y_test = data\n", - "\n", - " with warnings.catch_warnings():\n", - " warnings.simplefilter(\"ignore\")\n", - " model = botorch.models.SingleTaskGP(\n", - " x_train, y_train, covar_module=scaled_kernel, likelihood=lik_fct\n", - " )\n", - " mll_fct = gpytorch.mlls.ExactMarginalLogLikelihood(model.likelihood, model)\n", - "\n", - " # Fit\n", - " start = time.time()\n", - " fit_gpytorch_mll(mll=mll_fct)\n", - " end = time.time()\n", - " print(f\"training: {end - start:.4f} s\")\n", - "\n", - " # Predict\n", - " model.eval()\n", - " start = time.time()\n", - " y_pred = model(x_test)\n", - " end = time.time()\n", - " print(f\"prediction: {end - start:.4f} s\")\n", - "\n", - " # RMSE\n", - " rmse = torch.sqrt(((y_pred.mean - y_test) ** 2).mean())\n", - " print(f\"RMSE: {rmse.item():.4f}\")\n", - "\n", - " return model" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "SPACE_DIM = 10\n", - "NUM_TRAIN = 3000\n", - "NUM_TEST = 3000" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fast_matern: False\n", - "\n", - "training: 68.8307 s\n", - "prediction: 1.0435 s\n", - "RMSE: 0.5972\n", - "\n", - "lengthscale: 3.8122\n", - "outputscale: 0.0225\n", - "\n", - "----------------------------------------------------------------------------------------------------\n", - "\n", - "fast_matern: True\n", - "\n", - "training: 68.1158 s\n", - "prediction: 0.9751 s\n", - "RMSE: 0.5972\n", - "\n", - "lengthscale: 3.8122\n", - "outputscale: 0.0225\n", - "\n", - "----------------------------------------------------------------------------------------------------\n", - "\n" - ] - } - ], - "source": [ - "# HypercubeGraph\n", - "for fast_matern in [False, True]:\n", - " print(f\"fast_matern: {fast_matern}\")\n", - " print(\"\")\n", - "\n", - " graph = HypercubeGraph(SPACE_DIM)\n", - " if fast_matern:\n", - " kernel = MaternKernelHammingGraph(graph, num_levels=SPACE_DIM+1)\n", - " else:\n", - " kernel = MaternGeometricKernel(graph)\n", - "\n", - " data = generate_data(graph, Ackley, NUM_TRAIN, NUM_TEST)\n", - "\n", - " scaled_kernel, lik_fct = get_kernel_and_likelihood(kernel)\n", - "\n", - " model = fit_predict(data, scaled_kernel, lik_fct)\n", - "\n", - " print(\"\")\n", - " print(f\"lengthscale: {model.covar_module.base_kernel.lengthscale.item():.4f}\")\n", - " print(f\"outputscale: {model.covar_module.outputscale.item():.4f}\")\n", - " print(\"\")\n", - " print(\"-\" * 100)\n", - " print(\"\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fast_matern: False\n", - "\n", - "training: 55.4799 s\n", - "prediction: 0.9727 s\n", - "RMSE: 0.5901\n", - "\n", - "lengthscale: 3.6613\n", - "outputscale: 0.0222\n", - "\n", - "----------------------------------------------------------------------------------------------------\n", - "\n", - "fast_matern: True\n", - "\n", - "training: 55.5970 s\n", - "prediction: 0.9783 s\n", - "RMSE: 0.5901\n", - "\n", - "lengthscale: 3.6613\n", - "outputscale: 0.0222\n", - "\n", - "----------------------------------------------------------------------------------------------------\n", - "\n" - ] - } - ], - "source": [ - "# HammingGraph\n", - "for fast_matern in [False, True]:\n", - " print(f\"fast_matern: {fast_matern}\")\n", - " print(\"\")\n", - "\n", - " graph = HammingGraph(SPACE_DIM, 2)\n", - " if fast_matern:\n", - " kernel = MaternKernelHammingGraph(graph, num_levels=SPACE_DIM+1)\n", - " else:\n", - " kernel = MaternGeometricKernel(graph)\n", - "\n", - " data = generate_data(graph, Ackley, NUM_TRAIN, NUM_TEST)\n", - "\n", - " scaled_kernel, lik_fct = get_kernel_and_likelihood(kernel)\n", - "\n", - " model = fit_predict(data, scaled_kernel, lik_fct)\n", - "\n", - " print(\"\")\n", - " print(f\"lengthscale: {model.covar_module.base_kernel.lengthscale.item():.4f}\")\n", - " print(f\"outputscale: {model.covar_module.outputscale.item():.4f}\")\n", - " print(\"\")\n", - " print(\"-\" * 100)\n", - " print(\"\")\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "gkconda_updated_sh", - "language": "python", - "name": "gkconda_updated_sh" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.13" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/notebooks/other/HammingGraphTiming.ipynb b/notebooks/other/HammingGraphTiming.ipynb new file mode 100644 index 00000000..dde532a9 --- /dev/null +++ b/notebooks/other/HammingGraphTiming.ipynb @@ -0,0 +1,233 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# To run this in Google Colab, uncomment the following line\n", + "# !pip install geometric_kernels\n", + "\n", + "# If you want to use a version of the library from a specific branch on GitHub,\n", + "# say, from the \"devel\" branch, uncomment the line below instead\n", + "# !pip install \"git+https://github.com/geometric-kernels/GeometricKernels@devel\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Benchmarking Speed Improvements on Hypercube/Hamming Graphs\n", + "\n", + "This notebook benchmarks two methods for the `HypercubeGraph` and `HammingGraph` spaces with $\\nu = \\infty$:\n", + "\n", + "1. \"slow\" method — based on the addition theorem presented on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/hamming_graph.html),\n", + "2. \"fast\" method — based on the closed-form equations discusssed in [Kondor and Lafferty (2002)](https://people.cs.uchicago.edu/~risi/papers/diffusion-kernels.pdf) or [Doumont et al. (2025)](https://arxiv.org/pdf/2510.26633).\n", + "\n", + "Moreover, we also double-check whether the different methods lead to equal kernels.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", + "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", + "/opt/miniconda3/envs/geometrik/lib/python3.11/site-packages/spherical_harmonics/fundamental_set.py:21: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n", + " from pkg_resources import resource_filename\n" + ] + } + ], + "source": [ + "import time\n", + "from collections import defaultdict\n", + "\n", + "import numpy as np\n", + "\n", + "from geometric_kernels.kernels import MaternKernelHammingGraph\n", + "from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel\n", + "from geometric_kernels.spaces import HammingGraph, HypercubeGraph" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "SEED = 1234\n", + "np.random.seed(SEED)\n", + "\n", + "# Configuration\n", + "SPACE_DIM = 20 # dimensionality of the space\n", + "N_CAT = 5 # number of categories (alphabet size) for Hamming graph\n", + "N_SAMPLES = 3000 # number of points to evalute the kernels on\n", + "N_RUNS = 10 # number of seeds to average over\n", + "LENGTHSCALES = [1.0, 5.0, 10.0, 20.0]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def generate_data(space, n, seed_offset=0):\n", + " key1 = np.random.RandomState(1234 + seed_offset)\n", + " key2 = np.random.RandomState(5678 + seed_offset)\n", + " _, X1 = space.random(key1, n)\n", + " _, X2 = space.random(key2, n)\n", + " return X1, X2\n", + "\n", + "\n", + "def run_benchmark(space, kernel_type, lengthscales, n_samples, n_runs, space_dim):\n", + " results = {\"times\": defaultdict(list), \"kernels\": {}}\n", + "\n", + " for lengthscale in lengthscales:\n", + " for run_idx in range(n_runs):\n", + " if kernel_type == \"fast\":\n", + " kernel = MaternKernelHammingGraph(space, num_levels=space_dim + 1)\n", + " else:\n", + " kernel = MaternKarhunenLoeveKernel(space, num_levels=space_dim + 1)\n", + "\n", + " X1, X2 = generate_data(space, n_samples, seed_offset=run_idx * 1)\n", + " params = dict(nu=np.array([np.inf]), lengthscale=np.array([lengthscale]))\n", + "\n", + " start = time.perf_counter()\n", + " K = kernel.K(params, X1, X2)\n", + " elapsed = time.perf_counter() - start\n", + "\n", + " results[\"times\"][lengthscale].append(elapsed)\n", + " if run_idx == 0:\n", + " results[\"kernels\"][lengthscale] = K\n", + "\n", + " return results\n", + "\n", + "\n", + "def print_results(fast_results, slow_results, lengthscales, space_name):\n", + " print(f\"\\n{'='*80}\\n{space_name}\\n{'='*80}\")\n", + "\n", + " for ls in lengthscales:\n", + " fast_mean = np.mean(fast_results[\"times\"][ls])\n", + " slow_mean = np.mean(slow_results[\"times\"][ls])\n", + " speedup = slow_mean / fast_mean\n", + " is_equal = np.allclose(fast_results[\"kernels\"][ls], slow_results[\"kernels\"][ls])\n", + "\n", + " print(\n", + " f\"Lengthscale {ls:5.1f}: Fast={fast_mean:.4f}s | Slow={slow_mean:.4f}s | \"\n", + " f\"Speedup={speedup:.2f}x | Equal={is_equal}\"\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running...\n", + "\n", + "\n", + "================================================================================\n", + "HYPERCUBE GRAPH\n", + "================================================================================\n", + "Lengthscale 1.0: Fast=0.6992s | Slow=1.3529s | Speedup=1.94x | Equal=True\n", + "Lengthscale 5.0: Fast=0.6834s | Slow=1.3563s | Speedup=1.98x | Equal=True\n", + "Lengthscale 10.0: Fast=0.7838s | Slow=1.3482s | Speedup=1.72x | Equal=True\n", + "Lengthscale 20.0: Fast=0.7434s | Slow=1.3582s | Speedup=1.83x | Equal=True\n", + "\n", + "================================================================================\n", + "HAMMING GRAPH\n", + "================================================================================\n", + "Lengthscale 1.0: Fast=0.6942s | Slow=1.3436s | Speedup=1.94x | Equal=True\n", + "Lengthscale 5.0: Fast=0.8381s | Slow=1.3142s | Speedup=1.57x | Equal=True\n", + "Lengthscale 10.0: Fast=0.7756s | Slow=1.3819s | Speedup=1.78x | Equal=True\n", + "Lengthscale 20.0: Fast=0.6543s | Slow=1.3453s | Speedup=2.06x | Equal=True\n", + "\n", + "Done!\n" + ] + } + ], + "source": [ + "print(\"Running...\")\n", + "print(\"\")\n", + "\n", + "# HypercubeGraph\n", + "graph = HypercubeGraph(SPACE_DIM)\n", + "fast_results = run_benchmark(graph, \"fast\", LENGTHSCALES, N_SAMPLES, N_RUNS, SPACE_DIM)\n", + "slow_results = run_benchmark(graph, \"slow\", LENGTHSCALES, N_SAMPLES, N_RUNS, SPACE_DIM)\n", + "print_results(fast_results, slow_results, LENGTHSCALES, \"HYPERCUBE GRAPH\")\n", + "\n", + "# HammingGraph\n", + "hamming_graph = HammingGraph(SPACE_DIM, N_CAT)\n", + "fast_results = run_benchmark(\n", + " hamming_graph, \"fast\", LENGTHSCALES, N_SAMPLES, N_RUNS, SPACE_DIM\n", + ")\n", + "slow_results = run_benchmark(\n", + " hamming_graph, \"slow\", LENGTHSCALES, N_SAMPLES, N_RUNS, SPACE_DIM\n", + ")\n", + "print_results(fast_results, slow_results, LENGTHSCALES, \"HAMMING GRAPH\")\n", + "\n", + "print(\"\")\n", + "print(\"Done!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Citation\n", + "\n", + "If you are using hypercube or Hamming graphs from GeometricKernels, please consider citing\n", + "\n", + "```\n", + "@article{mostowsky2024,\n", + " title = {The GeometricKernels Package: Heat and Matérn Kernels for Geometric Learning on Manifolds, Meshes, and Graphs},\n", + " author = {Peter Mostowsky and Vincent Dutordoir and Iskander Azangulov and Noémie Jaquier and Michael John Hutchinson and Aditya Ravuri and Leonel Rozo and Alexander Terenin and Viacheslav Borovitskiy},\n", + " year = {2024},\n", + " journal = {arXiv:2407.08086},\n", + "}\n", + "```\n", + "\n", + "```\n", + "@inproceedings{doumont2025,\n", + " title = {Omnipresent Yet Overlooked: Heat Kernels in Combinatorial Bayesian Optimization},\n", + " author = {Colin Doumont and Victor Picheny and Viacheslav Borovitskiy and Henry Moss},\n", + " booktitle = {Advances in Neural Information Processing Systems},\n", + " year = {2025},\n", + "}\n", + "```\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "geometrik", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.11" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}