diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index d0f48b0d..c27d1bcb 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -10,12 +10,14 @@ jobs: fail-fast: false matrix: resolution: ["lowest-direct", "highest"] - python-version: ["3.10", "3.11", "3.12", "3.13"] + python-version: ["3.11", "3.12", "3.13", "3.14"] exclude: - python-version: "3.12" resolution: "lowest-direct" - python-version: "3.13" resolution: "lowest-direct" #numba 0.60 requires python < 3.13 + - python-version: "3.14" + resolution: "lowest-direct" #numba 0.60 requires python < 3.13 steps: - name: Checkout code uses: actions/checkout@v4 diff --git a/.vscode/extensions.json b/.vscode/extensions.json index 4e265ea5..db1ae57f 100644 --- a/.vscode/extensions.json +++ b/.vscode/extensions.json @@ -1,6 +1,7 @@ { "recommendations": [ "ms-python.python", - "charliermarsh.ruff" + "charliermarsh.ruff", + "astral-sh.ty" ] } \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json index e95988f1..0d3f95a2 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -7,10 +7,14 @@ ], "python.testing.unittestEnabled": false, "python.testing.pytestEnabled": true, + "python.languageServer": "Pylance", + "python.analysis.diagnosticMode": "openFilesOnly", + "ty.disableLanguageServices": true, "[python]": { "editor.rulers": [ 90 ], + "editor.inlayHints.enabled": "off", "editor.formatOnSave": true, "editor.defaultFormatter": "charliermarsh.ruff", "editor.codeActionsOnSave": { diff --git a/README.md b/README.md index 2c7dfad0..fee71d3f 100644 --- a/README.md +++ b/README.md @@ -5,7 +5,7 @@ ![PyPI - Downloads](https://img.shields.io/pypi/dm/polykin?label=PyPI%20downloads) [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/HugoMVale/polykin) -PolyKin is an open-source polymerization kinetics library for Python. It is still at an early +PolyKin is an open-source Python library for polymerization kinetics and related chemical engineering calculations. It is still at an early development stage, but the following modules can already be used: - Activity coefficient models @@ -53,8 +53,8 @@ development stage, but the following modules can already be used: - [x] Termination composite model - Math - [x] Joint confidence regions - - [x] Root and fixed-point solvers -- [ ] Models + - [x] Fixed-point solvers (scalar and vector) + - [x] Root solvers (scalar end vector) - Physical property correlations - [x] Antoine - [x] DIPPR diff --git a/docs/installation.md b/docs/installation.md index 6d210940..98f67015 100644 --- a/docs/installation.md +++ b/docs/installation.md @@ -1,6 +1,6 @@ # Installation -`PolyKin` requires Python >= 3.10, because it makes use of recent type hint syntax. It further relies on a number of mature and well-maintained mathematical/scientific libraries: +`PolyKin` requires Python >= 3.11. It further relies on a number of mature and well-maintained mathematical/scientific libraries: `matplotlib`, `mpmath`, `numba`, `numpy`, `pydantic`, `scipy`, etc. ## Install from PyPI diff --git a/docs/reference/math/derivatives/_SUMMARY.md b/docs/reference/math/derivatives/_SUMMARY.md index f7627c31..f975de6a 100644 --- a/docs/reference/math/derivatives/_SUMMARY.md +++ b/docs/reference/math/derivatives/_SUMMARY.md @@ -1,6 +1,7 @@ * [](index.md) * [derivative_centered](derivative_centered.md) * [derivative_complex](derivative_complex.md) +* [gradient_forward](gradient_forward.md) * [hessian_forward](hessian_forward.md) * [hessian2_centered](hessian2_centered.md) * [jacobian_forward](jacobian_forward.md) diff --git a/docs/reference/math/derivatives/gradient_forward.md b/docs/reference/math/derivatives/gradient_forward.md new file mode 100644 index 00000000..975202c0 --- /dev/null +++ b/docs/reference/math/derivatives/gradient_forward.md @@ -0,0 +1,6 @@ +# polykin.math.derivatives + +::: polykin.math.derivatives + options: + members: + - gradient_forward diff --git a/docs/reference/math/fixpoint/_SUMMARY.md b/docs/reference/math/fixpoint/_SUMMARY.md index 67f981b8..b22b6ca4 100644 --- a/docs/reference/math/fixpoint/_SUMMARY.md +++ b/docs/reference/math/fixpoint/_SUMMARY.md @@ -1,3 +1,6 @@ * [](index.md) * [fixpoint_anderson](fixpoint_anderson.md) +* [fixpoint_damped](fixpoint_damped.md) +* [fixpoint_dem](fixpoint_dem.md) +* [fixpoint_steffensen](fixpoint_steffensen.md) * [fixpoint_wegstein](fixpoint_wegstein.md) diff --git a/docs/reference/math/fixpoint/fixpoint_damped.md b/docs/reference/math/fixpoint/fixpoint_damped.md new file mode 100644 index 00000000..de1882e6 --- /dev/null +++ b/docs/reference/math/fixpoint/fixpoint_damped.md @@ -0,0 +1,6 @@ +# polykin.math.fixpoint + +::: polykin.math.fixpoint + options: + members: + - fixpoint_damped diff --git a/docs/reference/math/fixpoint/fixpoint_dem.md b/docs/reference/math/fixpoint/fixpoint_dem.md new file mode 100644 index 00000000..cc8870de --- /dev/null +++ b/docs/reference/math/fixpoint/fixpoint_dem.md @@ -0,0 +1,6 @@ +# polykin.math.fixpoint + +::: polykin.math.fixpoint + options: + members: + - fixpoint_dem diff --git a/docs/reference/math/fixpoint/fixpoint_steffensen.md b/docs/reference/math/fixpoint/fixpoint_steffensen.md new file mode 100644 index 00000000..88e41549 --- /dev/null +++ b/docs/reference/math/fixpoint/fixpoint_steffensen.md @@ -0,0 +1,6 @@ +# polykin.math.fixpoint + +::: polykin.math.fixpoint + options: + members: + - fixpoint_steffensen diff --git a/docs/reference/math/fixpoint/index.md b/docs/reference/math/fixpoint/index.md index ce3ee400..565d8261 100644 --- a/docs/reference/math/fixpoint/index.md +++ b/docs/reference/math/fixpoint/index.md @@ -1 +1,21 @@ # Fixed-Point Solvers (polykin.math.fixpoint) + +## Scalar Problems + +[fixpoint_steffensen] is the only solver in this group specialized for scalar fixed-point problems $g(x)=x$. It accelerates direct substitution through Aitken's delta-squared process, often converging significantly faster than plain fixed-point iteration when the fixed-point sequence is smooth and locally contractive. + +## Multivariable Problems + +[fixpoint_damped] is the most basic option for systems $\mathbf{g}(\mathbf{x})$. It applies direct substitution with optional damping, making each iteration inexpensive and easy to interpret. This is a reasonable first choice when the mapping is already contractive or only mildly unstable, especially if function evaluations are cheap. + +[fixpoint_wegstein] improves on direct substitution by estimating a componentwise secant slope and converting it into a bounded acceleration factor. In practice, it often offers a favorable balance between robustness and speed for weakly to moderately coupled systems. It is usually more effective than simple damping, but because the acceleration is applied componentwise, performance can degrade when the variables are strongly coupled. + +[fixpoint_dem] targets problems whose slow convergence is dominated by a single eigenvalue of the fixed-point iteration. By estimating that dominant mode and periodically applying a promotion step, it can reduce iteration counts for recycle-type problems and other slowly convergent systems. It is more specialized than Wegstein's method and is most useful when there is a clear dominant convergence mode. + +[fixpoint_anderson] is generally the most powerful solver in this family for difficult coupled systems. It combines several previous iterates through a least-squares acceleration step, often delivering substantially better convergence than direct substitution-based methods. The additional linear algebra introduces some overhead, but this cost is usually justified when evaluating $\mathbf{g}(\mathbf{x})$ is expensive or when simpler accelerators stall. + +[fixpoint_steffensen]: fixpoint_steffensen.md +[fixpoint_damped]: fixpoint_damped.md +[fixpoint_wegstein]: fixpoint_wegstein.md +[fixpoint_dem]: fixpoint_dem.md +[fixpoint_anderson]: fixpoint_anderson.md diff --git a/docs/reference/math/optimization/OptimumResult.md b/docs/reference/math/optimization/OptimumResult.md new file mode 100644 index 00000000..1a5266f4 --- /dev/null +++ b/docs/reference/math/optimization/OptimumResult.md @@ -0,0 +1,6 @@ +# polykin.math.optimization + +::: polykin.math.optimization + options: + members: + - OptimumResult diff --git a/docs/reference/math/optimization/VectorOptimumResult.md b/docs/reference/math/optimization/VectorOptimumResult.md new file mode 100644 index 00000000..f9fda605 --- /dev/null +++ b/docs/reference/math/optimization/VectorOptimumResult.md @@ -0,0 +1,6 @@ +# polykin.math.optimization + +::: polykin.math.optimization + options: + members: + - VectorOptimumResult diff --git a/docs/reference/math/optimization/_SUMMARY.md b/docs/reference/math/optimization/_SUMMARY.md new file mode 100644 index 00000000..eb29d076 --- /dev/null +++ b/docs/reference/math/optimization/_SUMMARY.md @@ -0,0 +1,7 @@ +* [](index.md) +* [fmin_brent](fmin_brent.md) +* [fmin_nelder_mead](fmin_nelder_mead.md) +* [fmin_qnewton](fmin_qnewton.md) +* [fmin_secant](fmin_secant.md) +* [OptimumResult](OptimumResult.md) +* [VectorOptimumResult](VectorOptimumResult.md) diff --git a/docs/reference/math/optimization/fmin_brent.md b/docs/reference/math/optimization/fmin_brent.md new file mode 100644 index 00000000..aef4def1 --- /dev/null +++ b/docs/reference/math/optimization/fmin_brent.md @@ -0,0 +1,6 @@ +# polykin.math.optimization + +::: polykin.math.optimization + options: + members: + - fmin_brent diff --git a/docs/reference/math/optimization/fmin_nelder_mead.md b/docs/reference/math/optimization/fmin_nelder_mead.md new file mode 100644 index 00000000..67f53a69 --- /dev/null +++ b/docs/reference/math/optimization/fmin_nelder_mead.md @@ -0,0 +1,6 @@ +# polykin.math.optimization + +::: polykin.math.optimization + options: + members: + - fmin_nelder_mead diff --git a/docs/reference/math/optimization/fmin_qnewton.md b/docs/reference/math/optimization/fmin_qnewton.md new file mode 100644 index 00000000..0144ad70 --- /dev/null +++ b/docs/reference/math/optimization/fmin_qnewton.md @@ -0,0 +1,6 @@ +# polykin.math.optimization + +::: polykin.math.optimization + options: + members: + - fmin_qnewton diff --git a/docs/reference/math/optimization/fmin_secant.md b/docs/reference/math/optimization/fmin_secant.md new file mode 100644 index 00000000..eb3d174f --- /dev/null +++ b/docs/reference/math/optimization/fmin_secant.md @@ -0,0 +1,6 @@ +# polykin.math.optimization + +::: polykin.math.optimization + options: + members: + - fmin_secant diff --git a/docs/reference/math/optimization/index.md b/docs/reference/math/optimization/index.md new file mode 100644 index 00000000..4aa96bbb --- /dev/null +++ b/docs/reference/math/optimization/index.md @@ -0,0 +1,22 @@ +# Optimization Solvers (polykin.math.optimization) + +## Univariate Optimization + +These solvers cover the typical trade-off between local speed and global robustness for minimization of scalar objective functions $f(x)$. They differ in the use of derivatives and whether a bounded interval is required. + +[fmin_secant] is a fast local method for smooth problems when two reasonable initial guesses are available. It uses a secant approximation of the first derivative, evaluated via centered finite differences or complex-step differentiation. It typically converges quickly near a well-behaved minimum but is not robust to poor initial guesses, weak curvature, or nonsmooth objectives. + +[fmin_brent] is a robust bounded method for cases where an interval containing a minimum is known. It combines golden-section search with inverse parabolic interpolation, achieving reliable convergence while exploiting smoothness when present. It does not require derivatives and is the preferred choice for safe one-dimensional minimization within a bracketed interval. + +## Multivariate Optimization + +These solvers provide different trade-offs between robustness, efficiency, and derivative requirements for unconstrained minimization of multivariate objective functions, $f(\mathbf{x})$. + +[fmin_nelder_mead] is a derivative-free method for unconstrained minimization of multivariate functions. It evolves a simplex of trial points through reflection, expansion, contraction, and shrink operations, making it useful when derivatives are unavailable, unreliable, or too expensive to compute. In exchange for this flexibility, convergence is usually slower than with gradient-based methods, and performance may degrade for poorly scaled or high-dimensional problems. + +[fmin_qnewton] is a fast local method for smooth unconstrained problems when gradient information is available analytically or can be estimated accurately. It combines Newton-type curvature information with optional BFGS Hessian updates and supports either a line-search or dogleg globalization strategy to improve robustness from remote initial guesses. This is generally the preferred solver when the objective is differentiable and a reasonably good starting point is available. As with other quasi-Newton methods, however, convergence remains fundamentally local. + +[fmin_secant]: fmin_secant.md +[fmin_brent]: fmin_brent.md +[fmin_nelder_mead]: fmin_nelder_mead.md +[fmin_qnewton]: fmin_qnewton.md diff --git a/docs/reference/math/roots/index.md b/docs/reference/math/roots/index.md index fee6d0f1..dea184c5 100644 --- a/docs/reference/math/roots/index.md +++ b/docs/reference/math/roots/index.md @@ -1 +1,24 @@ # Root Solvers (polykin.math.roots) + +## Single Equation + +These three solvers span the usual tradeoff between local speed and global robustness for real-valued equations $f(x)=0$. They differ mainly in how much information they require and how sensitive they are to the initial guess. + +[root_newton] is the fastest option for smooth problems with a good initial guess. It uses a Newton–Raphson update and estimates derivatives via complex-step differentiation, so no user-supplied derivative is needed. Convergence is typically very rapid, but the function must accept complex inputs, and—as with any Newton method—it may fail or converge to the wrong root if initialized poorly. + +[root_secant] removes the need for derivatives by approximating the slope from two initial guesses. It retains fast local convergence on well-behaved problems and works when complex-step differentiation is not applicable. It is generally less robust than Brent’s method and less decisive than Newton near difficult roots, but provides a useful middle ground between simplicity and speed. + +[root_brent] is the safest choice when a bracketing interval is available. By combining bisection, secant steps, and inverse quadratic interpolation, it maintains the reliability of bracketed methods while recovering much of the speed of open methods. The only requirement is an interval where the function changes sign; when this is available, Brent’s method is typically the best choice for robust production use. + +## System of Equations + +[rootvec_qnewton] targets systems of nonlinear equations $\boldsymbol{F}(\boldsymbol{x})=\boldsymbol{0}$, which are inherently more challenging than scalar problems. There is no multidimensional analogue of bracketing, and thus no method combining global guarantees with high efficiency comparable to Brent’s method. + +Instead, such solvers rely on local linearization. Classical Newton methods use the full Jacobian, but forming and factorizing it can be expensive for large systems. `rootvec_qnewton` supports two approaches: recomputing the full Jacobian at each iteration (either user-supplied or via finite differences), or updating an approximate Jacobian using Broyden’s rank-1 formula. In this sense, Broyden’s method plays a role analogous to the secant method in the scalar case. + +Full Jacobian updates improve robustness at higher cost, while Broyden updates reduce per-iteration cost at the expense of reliability, especially with poor initial guesses or strong nonlinearity. As with other quasi-Newton methods, convergence is local, so good initial guesses remain important. + +[root_newton]: root_newton.md +[root_secant]: root_secant.md +[root_brent]: root_brent.md +[rootvec_qnewton]: rootvec_qnewton.md diff --git a/docs/tutorials/_SUMMARY.md b/docs/tutorials/_SUMMARY.md index 08fc1017..d53bc973 100644 --- a/docs/tutorials/_SUMMARY.md +++ b/docs/tutorials/_SUMMARY.md @@ -6,6 +6,7 @@ * [Distributions](distributions.ipynb) * [Equations of State](equations_of_state.ipynb) * [Kinetic Coefficients](kinetic_coefficients.ipynb) +* [Optimization](optimization.ipynb) * [Physical Property Equations](physprop_equations.ipynb) * [Thermal Conductivity](thermal_conductivity.ipynb) * [Viscosity](viscosity.ipynb) \ No newline at end of file diff --git a/docs/tutorials/optimization.ipynb b/docs/tutorials/optimization.ipynb new file mode 100644 index 00000000..2c0dfd98 --- /dev/null +++ b/docs/tutorials/optimization.ipynb @@ -0,0 +1,857 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3ca58710", + "metadata": {}, + "source": [ + "# Optimization\n", + "\n", + "## Overview\n", + "\n", + "The `polykin.math.optimization` module provides both univariate and multivariate solvers for smooth objective functions.\n", + "\n", + "| | Derivative-free | Derivative-based |\n", + "|---------------------|:------------------:|:----------------:|\n", + "| Univariate (scalar) | `fmin_brent` | `fmin_secant` |\n", + "| Multivariate | `fmin_nelder_mead` | `fmin_qnewton` |\n", + "\n", + "The scalar solvers return an `OptimumResult`, while the multivariate solvers return a `VectorOptimumResult` with the estimated minimizer, objective value, convergence message, and iteration counters." + ] + }, + { + "cell_type": "markdown", + "id": "bf952e8c", + "metadata": {}, + "source": [ + "## Univariate Function" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "de8d1948", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "from polykin.math.optimization import fmin_brent, fmin_secant" + ] + }, + { + "cell_type": "markdown", + "id": "24493219", + "metadata": {}, + "source": [ + "### Lennard-Jones Potential" + ] + }, + { + "cell_type": "markdown", + "id": "c4366c81", + "metadata": {}, + "source": [ + "The Lennard-Jones potential is a standard one-dimensional test problem with a single attractive well. For $\\sigma = \\epsilon = 1$, the exact minimum is at $r^\\star = 2^{1/6}$, which gives a useful reference when checking the numerical result." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d8bd5da4", + "metadata": {}, + "outputs": [], + "source": [ + "def lennard_jones(r):\n", + " sigma = 1.0\n", + " epsilon = 1.0\n", + " return 4 * epsilon * ((sigma/r)**12 - (sigma/r)**6)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ed9b9512", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "fig.suptitle(\"Lennard-Jones potential\")\n", + "\n", + "r = np.linspace(0.95, 3.0, 400)\n", + "r_star = 2 ** (1 / 6)\n", + "ax.plot(r, lennard_jones(r), label=\"Lennard-Jones\")\n", + "ax.axvline(r_star, color=\"tab:red\", linestyle=\"--\", label=r\"$r^\\star = 2^{1/6}$\")\n", + "ax.set_xlabel(\"r\")\n", + "ax.set_ylabel(\"f(r)\")\n", + "ax.legend();" + ] + }, + { + "cell_type": "markdown", + "id": "cc0ce706", + "metadata": {}, + "source": [ + "When a bracket containing the minimum is available, Brent's method is the safest choice. It does not require derivatives, preserves the bracket, and usually converges rapidly on smooth functions." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "96cdefb8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + " method: Brent\n", + "success: \u001b[92mTrue\u001b[0m\n", + "message: |Δx| ≤ tolx\n", + " nfeval: 13\n", + " niter: 13\n", + " x: 1.12246221e+00\n", + " f: -1.00000000e+00" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fmin_brent(lennard_jones, 1.0, 3.0)" + ] + }, + { + "cell_type": "markdown", + "id": "7c224388", + "metadata": {}, + "source": [ + "The secant method targets the stationary point through numerical derivatives, so it can be very efficient when the starting guesses are already close to the minimizer. Here we use complex-step differentiation, which is accurate for functions that accept complex inputs." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "95b5471b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + " method: Secant\n", + "success: \u001b[92mTrue\u001b[0m\n", + "message: |f'(x)| ≤ tolg\n", + " nfeval: 10\n", + " niter: 8\n", + " x: 1.12246205e+00\n", + " f: -1.00000000e+00\n", + " df: -3.87659504e-09" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fmin_secant(lennard_jones, 1.0, 1.01, diff_scheme=\"complex\")" + ] + }, + { + "cell_type": "markdown", + "id": "817fb418", + "metadata": {}, + "source": [ + "The trade-off is robustness. If the initial guesses are too far from the well, the derivative-based iteration can leave the attractive basin and *fail* to locate the minimum." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "69fd7215", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + " method: Secant\n", + "success: \u001b[91mFalse\u001b[0m\n", + "message: Function value increased from -0.2242077243863605 at x[k-1]=1.6 to -0.10963081822561647 at x[k]=1.8125241675252626.\n", + " nfeval: 3\n", + " niter: 1\n", + " x: 1.81252417e+00\n", + " f: -1.09630818e-01\n", + " df: 3.52378708e-01" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fmin_secant(lennard_jones, 1.5, 1.6, diff_scheme=\"complex\")" + ] + }, + { + "cell_type": "markdown", + "id": "cad45a34", + "metadata": {}, + "source": [ + "The near-minimum secant run converges to the same optimum as Brent's method, but the second run shows why `fmin_secant` should be treated as a local solver.\n", + "\n", + "**Recommendation**\n", + "\n", + "* use `fmin_brent` when you can bracket the minimum and want robust convergence;\n", + "* use `fmin_secant` when the function is smooth and you already have two good initial guesses." + ] + }, + { + "cell_type": "markdown", + "id": "4254eaf6", + "metadata": {}, + "source": [ + "## Multivariate Function\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "5b74fed8", + "metadata": {}, + "outputs": [], + "source": [ + "from polykin.math.optimization import fmin_nelder_mead, fmin_qnewton" + ] + }, + { + "cell_type": "markdown", + "id": "eea2e598", + "metadata": {}, + "source": [ + "### Himmelblau's function\n", + "\n", + "Himmelblau's function is a standard two-dimensional test problem with four equivalent local minima. That makes it useful for visualizing how a solver moves through the objective landscape and how strongly the result depends on the starting point.\n", + "\n", + "We start both methods from the same initial guess, $x_0 = (0, 0)$, and record their iterates through a callback so the optimization paths can be plotted on top of the contour map." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "4bb50ee4", + "metadata": {}, + "outputs": [], + "source": [ + "def himmelblau(z):\n", + " \"\"\"Himmelblau's function for 2D optimization.\"\"\"\n", + " x, y = z\n", + " return (x**2 + y - 11)**2 + (x + y**2 - 7)**2\n", + "\n", + "def himmelblau_grad(z):\n", + " \"\"\"Analytical gradient of Himmelblau's function (for BFGS).\"\"\"\n", + " x, y = z\n", + " dx = 4*x*(x**2 + y - 11) + 2*(x + y**2 - 7)\n", + " dy = 2*(x**2 + y - 11) + 4*y*(x + y**2 - 7)\n", + " return np.array([dx, dy])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f58bb8f6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqMAAAJJCAYAAACeQD6MAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsXQWYHAXWrHWddXf33SS7sY0bQUIgIUGCOwcHB8dxd8jh7nYHh7tD8CgR4i7r7u7u8n/1enoyu9ndJPxwuSNd+frrmdnJSM9Md3W9evVMBgcHB6FBgwYNGjRo0KBBw0mA6cl4Ug0aNGjQoEGDBg0aCI2MatCgQYMGDRo0aDhp0MioBg0aNGjQoEGDhpMGjYxq0KBBgwYNGjRoOGnQyKgGDRo0aNCgQYOGkwaNjGrQoEGDBg0aNGg4adDIqAYNGjRo0KBBg4aTBo2MatCgQYMGDRo0aDhp0MioBg0aNGjQoEGDhpMGjYxq0KDhN0NQUBCuvPLK/8kt/MADD8DExGTIbbx+8803H/P/vvvuu3LfoqIi/K9gzZo1GD9+PKytreW1NzU14b8RfG38bDRo0PD7gUZGNWjQcFxQCda+fftG/PucOXMQFxenbc3/EEh0+Xls3rz5//1Y9fX1uOCCC2BjY4N//etf+OCDD2BnZ4eThVWrVmmEU4OGUwjmJ/sFaNCg4feL7OxsmJpq57z/7di7dy9aW1vx8MMPY8GCBSf75QgZJSkeSQHt7OyEubl26NKg4fcE7RetQYOG3wxWVlba1v0fQE1NjaydnJzw3w7aCDRo0PD7giZZaNCg4T/mGVVL/du2bcOf/vQnuLu7CwG64YYb0NPTIz7Fyy+/HM7OzrL87W9/w+Dg4FGl6WeeeUaUs5CQENja2mLhwoUoLS2V+1Ld8/Pzk5Lzueeei4aGhqNe1+rVqzFz5kwpRet0OixatAjp6enH/b4++ugjREZGCjFKSkrCli1bjvl/vv32W3keHx8fIemhoaHyWvv7+8fcZsY2CC5joaqqCldddZW8fz6Ht7e3bIOxvKt8zCuuuEIuT5o0Sbav+vzH+1poFeD/+/zzz/Hoo4/K83PbzJ8/H3l5eUf9/927d+Oss86Sz5ifQUJCAl588UX5G5+Pny3Bx1SXsTyjBw8exJlnngkHBwfY29vL8+7atWvIfdTv3vbt23H77bfLd4/PvXTpUtTW1o65XTVo0PDbQlNGNWjQcEJobm5GXV3dUbf39vYe92Pccsst8PLywoMPPiik4fXXXxdSumPHDgQEBOCxxx6TUu3TTz8tPlQS1OFkkOSVj0Oy+dRTT4nncd68eUKM/v73vwsJevnll3HHHXfg7bffNvxf+iFJvk4//XQ8+eST6OjowKuvvooZM2YIqSEBGws///wzPvvsMyHTJHyvvPIKzjjjDOzZs2dMzyzJEIkSiRDXGzduxH333YeWlhZ5n78Gli1bJqSa24Xvg4rn+vXrUVJSMur7uueee4RY8zN46KGHEBwcLET5l+CJJ54QWwa3Ob8n/FwuueQSIZ8q+HrOPvtsIcq33nqrfA8yMzPxww8/yHWemFRUVMj9+FkdC3y/PLEgEeXJi4WFBV577TUhy/yspkyZMuT+3DYkwffff7+Q9BdeeEGa0viZatCg4SRhUIMGDRqOA++88w4lyjGX2NjYIf8nMDBw8IorrjjqMU4//fTBgYEBw+3JycmDJiYmg3/4wx8Mt/X19Q36+fkNzp4923BbYWGh/H93d/fBpqYmw+133XWX3D5u3LjB3t5ew+0rVqwYtLS0HOzq6pLrra2tg05OToPXXXfdkNdZVVU16OjoOOT2+++/Xx7TGOr73Ldvn+G24uLiQWtr68GlS5ce9T75elV0dHQctU1vuOGGQVtbW8PrG2mbqeB2MN4Ww9HY2CjP+fTTTw+eKNTXu3fv3iG3H+9r2bRpk/z/6Ojowe7ubsPtL774otyemppq+EyDg4Plcfl6jWH8ffjjH/941LZXwdv52ahYsmSJfMb5+fmG2yoqKgZ1Ot3grFmzjnqPCxYsGPJcf/7znwfNzMyGfJ80aNDwn4VWptegQcMJgSVUqlbDF5ZajxfXXHPNkNIr1SvyDN6uwszMDBMnTkRBQcFR///888+Ho6PjkP9PXHrppUOaW3g7FdTy8nK5ztdJK8CKFStE3VUXPhfvu2nTpmO+9uTkZCnNq6CSy1L42rVrjyq5G4O2ARVsFuLzUtGjMpuVlYX/L/j4lpaWogw3NjbiZIAWAb4GFXx/hPoZUnkuLCzEbbfddpQ/dXiM1vGA23vdunVYsmSJWDZUUHW9+OKLxQ5C5dkY119//ZDn4mvk4xQXF5/w82vQoOHXgVam16BBwwlh8uTJQhKHg6XPkcr3I4EEzhgqsfT39z/q9pGI1Yn8f0J9jNzcXFmznD8SWOo9FsLDw4+6LSIiQkglvYcsO49WTv7HP/4h5fnhBIkl7f8vaBmg7eAvf/kLPD09MXXqVCmH0+Iw2mv6tTH8c+F3wnj75+fny/rXigDj9uZ2p81gOKKjozEwMCBe4tjY2ON+jRo0aPjPQyOjGjRo+I+DSuTx3m7cwPRL/r/xY5CcEPQijkTQfqvIIKqxs2fPFrJLXyY9mWzwOXDggPhb1dc1lkJI9W6096eCiuPixYvxzTffiFJ777334vHHHxcCPGHChBN+3Sf6Wo61/f8b8L/wGjVoONWgkVENGjScMlAbczw8PH5xnqaqrhojJydHuvrZoT0SWDpnsPzKlSsxa9Ysw+0sWQ8HlbqRph+xjGxcih7rPVId5cLXyqlKzz77LD788MPjeHe/7msZ6bURaWlpY27/4y3Zc3tzuzPPdjhofWAz1XC1XIMGDf990DyjGjRoOGXADnqqk+zWH6n7/3gifnbu3CmKpgqWgRnbxHipYym2xuobvazsxB+JsDFhgH9XwU5zPs9YYLm6q6vrqMdidFV3dzd+CX7paxkNiYmJ0q3PDvbhJNd426jTn441kpTbldud2984vqq6uhoff/yxJCQcj/VCgwYNJxeaMqpBg4ZTBiQmjHG67LLLhBhddNFFoq4x+ujHH3/E9OnT8c9//nPMx6DfkaTWONqJYEzVaJg2bZqojIyU4v+j8kerwEil4WuvvRZffvmlxEUxroo+S6qax4pbojrLfE3+n5iYGLEcfP3110LM+D5/CX7paxkNVCq5/WkloGLLhic2G1HFpKeW1gJCbRDjtuK2Jukc7T088sgj0phG4nnTTTfJ+2a0Ewk4o6U0aNDw3w9NGdWgQcMpBXZZb9iwAb6+vpLvyWzLTz/91ECOjgV6P6nskUwyJ9TFxUVC9MdKE3B1dRVFkcSLTUwM7T/ttNNGJEskXyyrk1zSA0ollv+XQfJjgeVopgTQEnDXXXfJwkYpBtEzf/SX4Je+lmM9JlML2PTFx2buKj8PElQV5513nuSBrlmzRk4c+L5GA5uTtm7dKicJ9MfypCAwMFCeY3jGqAYNGv47YcJ8p5P9IjRo0KBBgwYNGjScmtCUUQ0aNGjQoEGDBg0nDRoZ1aBBgwYNGjRo0HDSoJFRDRo0aNCgQYMGDScNGhnVoEGDBg0aNGjQcNKgkVENGjRo0KBBgwYNJw0aGdWgQYMGDRo0aNBw0qCRUQ0aNGjQoEGDBg0nDRoZ1aBBgwYNGjRo0HDSoJFRDRo0aNCgQYMGDScNGhnVoEGDBg0aNGjQcNKgkVENGjRo0KBBgwYNJw0aGdWgQYMGDRo0aNBw0qCRUQ0aNGjQoEGDBg0nDRoZ1aBBgwYNGjRo0HDSoJFRDRo0aNCgQYMGDScNGhnVoEGDBg0aNGjQcNKgkVENGjRo0KBBgwYNJw0aGdWgQYMGDRo0aNBw0qCRUQ0aNGjQoEGDBg0nDRoZ1aBBgwYNGjRo0HDSoJFRDRo0aNCgQYMGDScNGhnVoEGDBg0aNGjQcNKgkVENGjRo0KBBgwYNJw0aGdWgQYMGDRo0aNBw0qCRUQ0aNGjQoEGDBg0nDRoZ1aBBgwYNGjRo0HDSoJFRDRo0aNCgQYMGDScNGhnVoEGDBg0aNGjQcNKgkVENGjRo0KBBgwYNJw0aGdWgQYMGDRo0aNBw0qCRUQ0aNGjQoEGDBg0nDRoZ1aBBgwYNGjRo0HDSoJFRDRo0aNCgQYMGDScNGhnVoEGDBg0aNGjQcNKgkVENGjRo0KBBgwYNJw0aGdWgQYMGDRo0aNBw0qCRUQ0aNGjQoEGDBg0nDRoZ1aBBgwYNGjRo0HDSoJFRDRo0aNCgQYMGDScNGhnVoEGDBg0aNGjQcNKgkVENGjRo0KBBgwYNJw0aGdWgQYMGDRo0aPgfQGtrK2677TYEBgbCxsYG06ZNw969ew1/HxwcxH333Qdvb2/5+4IFC5CbmzvkMRoaGnDJJZfAwcEBTk5OuOaaa9DW1oaTCY2MatCgQYMGDRo0/A/g2muvxfr16/HBBx8gNTUVCxcuFMJZXl4uf3/qqafw0ksv4d///jd2794NOzs7nH766ejq6jI8Boloenq6PM4PP/yALVu24Prrrz+J7wowGSSN1qBBgwYNGjRo0DAiBgc6fjsiZmp7XPfr7OyETqfDt99+i0WLFhluT0pKwplnnomHH34YPj4++Mtf/oI77rhD/tbc3AxPT0+8++67uOiii5CZmYmYmBhRUydOnCj3WbNmDc466yyUlZXJ/z8ZMMcphIGBAVRUVMiHaWJicrJfjgYNGjRo0KDhOEDdjCVqkiVT0/98UbezJAE9vb+NdmficeAoTmJlZSWLMfr6+tDf3w9ra+sht7Mcv23bNhQWFqKqqkqUUhWOjo6YMmUKdu7cKWSUa5bmVSJK8P7cplRSly5dipOBU4qMkoj6+/uf7JehQYMGDRo0aPgFKC0thZ+f339027HEHTqlCFU1/b/J49vb+x3l2bz//vvxwAMPDLmNQlpycrIooNHR0aJ4fvLJJ0Iww8LChIgSvN0YvK7+jWsPD48hfzc3N4eLi4vhPicDpxQZ5QdJRL/4INrMgQRXbxTWN6K1pwcJ7p6obelAVWsb/BwcEKBzws6SUpiZmODShHH46nA6Onr6EOrqgik+vvh0f6o8VnKQP0JcXPDx3sNyPcbLHUsTYvDqhl1o7uyGpbkZrps9ER2dffhwywH0DwzC1soC182fBGtzc7yxdg+a2hUvR2KoL65aMBEZBVX4ZNNBtHb2yO1eLjpcOHscJoT6YtXOTKzamYGOrl75m7m5GWbEB+P0KZEI8nLBlv152LA3F/kldUPee4ifKybFBiAp2h+RQR4oKK1HSlY5UrPLkZlfjc4e5fGMYW1pjgAfFwT6uMDPy0kWb3dHeLk7wNrKHHX1baipb0VdQzvqm9rQ2NSBppZOtLRy6UJ7Rzfa2rvR0dWDvr6BX+UztLQwg7WVBWxtuFjBztYS9nbWsLezgs7eCo46WzjYW8PR0QZODupii77+AdQ3daChqQ31Te2oa+TSJktNQxvqGlrR3NZ9zOd3c7aDr4cjfDwc4evlBF9PZ/h6OsHBzgrVja0or2lGaVUTyqqbUFbThNLqJvT09I36eB4u9rJ9g7xdEOjtjABvZzjqrFHX0oHiykYUVzWguLoRxZUNqGsevUzkorNBIB/Dy1m+BwFeznC0s0Zje6fy/7nUNKGkugH1rZ2jPo6VhRkCPZwR4OEMfw8nBLg7w83JjroEalvaUVLXjLL6JpTVN6O8rtnw3R0N/K77ujrCx8VBFm8XHTwc7OVz7B8cRH1bByobW1Hd1IKqpjZUN7ehprkdvf3Ht9N3sLWCm84O7jo7uOps4eagrB1srGFmagITUxP0DwygvacHje1daOzoRFN7JxraO9HEyx2daO7oRt/AL/9+UtCws7SEvTUXK9hZWsjaVm6zgK2VJWzMzWFhYQZzM1OYmpjI/wFMMKj/1zegLgPo7etDR28fOnt60Nnbh65eXu9Fd28vOnv60NXXh0653ofOvj78J41WFqZmsLU0h62lBWwsLJS1pQVsLSxkX2dlbg5zMxOYmZmJ0sP3Ke9wcFD2fT39/ejuG0BXbw9au7vR0tmD5u4utHT+ss/A2dYabnZ2cLS1gr2VJSzMzUXh6Rvol23Gx65saUV9x+jfecLK3Ax+jo5wsbOR99RvMoi27m6Ut7agur19xP9jZ2GBQGcnOFhbY2BwAFUdbShpasLwj4PfhyBnZ9hYmqOhqxOFLY0YMPrQ+D0NdnKGnZUFKjtaUNNp/HyDCHJ0lm1d3NqIjv4ew+0etnZwsbFBSXsDuvuVfQy/UUEOzuga7EFtV6vhvn52Dugb7EVDr/LY5iaAr50Darub5LXL49nYoG+wG5393A8OwtXKBgPoQvdArzyum5UNOvrb5PO0MB2Ek4WFXOffnC0t0TtAMjUIOzMzmKEHA+iDjakJrEx75bK1CWBl2o1B9MPO1BQm6IIpBuBgxh9DB8zRBztTvhb+P1OYoRsWGICtqSlM0Y/OTl8kJh40HMf/k+jp6REiWlKcAweHX/f5W1paERAYISSbDUUqhquiKugVvfrqq+Hr6yu/s8TERKxYsQL79+/H/zJOKc9oS0uLSNb+/3oQMT7+qGvpRF1nB+LdPIWIlLY0I5B/t3PC9pISWJqZ4apxE/DunoPoHRjA1AB/uFpYY02m0pl22aTxKK5txNa8Yrl+8eRxMO83wUc7D8n1KG933DhvCl5Zswu5lQo5XBAfhguTE/DPH3cgtVg5CwnxdMGti2egtrENr/+4C/UtCukgqbj6jEkI9nDBB2v2YeP+XMNOLMDTGcvmJOC0iRE4mFWG735Ow/7MUsOBiTs4Es/ZE8Mwc0Io+vr6sf1AAXYfKsKBjFJ0DyNIdjaWiAr1QnSoJ6KCPREe5CGEi2StsLgORWX1KClvRGlFAyqqmlHb0PqLDoKmpiZCRCwszOU1mvHgTNKgHLXk/dFO0d8/iN6+fnndPb3//7NRG2sLuDrbw83FDu6uOri72sPDTQdPNwd4ujvA000HM3NTVNe1oqquBZU1LaisbUZFTTPKq5tQUd2Mdv3JwUjgy/dyczCQ90BfZU1yyQNwSWUjCisahFQWldejqLIRjfrPeSS4O9sh2NcNIb6uciLBxcNFh+qGVhRU1stjFVbUo7CyAZX1LaM+jpO9DUJ8XBDs4ypLiLcrPJzt5OBfVN2IoqoGw7qstnlMQuDhZC8kNciTZNVJvoOuDrby2yChLK1tQmmdQlS5rm0e+SBuDBJHbz1R9XHWyWVPJ52QWKKlqxs1zW2oamoVoqqQVWXp6Tv+7wWJkou9LVzsbfRr5bKznQ2c7GyEKJC48oPkwZmP3drVjaaOLjR3KGSppVO/7lKvdx83aT4RkLCS3JHkWVuYy1oWC3NYq7dZKGuePFiYKSSXvyH+lkxNWMIcJDMRYiS/qUGFEPLzJSns7R+Q7yVJbRdJrpBeZc0T085hl/l/fm2QPDraWMviYG0JnbW1vCd+VtwvmMAEA0LUSV570drdg4aODtS1daC+veO4yaurnS18HHXyWfMEwdTMRL6zLUJU21DaPPr33sLUFIEuTvDU2ctn0D3Qh9qOduQ1NMj2Gw4POzsEODvK59PS043chjq09w490XewskKoiwssLExR1taC8jbj3+8gvOx18HXQobm3C3nN9UP+FuLoImQ5r6UOXXoCyttDnZxhagYUtKr3H4SzlTU8be1Q1F6Pfj3hdLGygaOVBco7Gw33C7J3RGNvq5BOXve0tkMfOg2k1MPaFj0D7egd7BPiyb+39DXL3+zNzWBh2ofewR6YYQCulhboGmiXT87Zwgo9A21COElc+wf1l81N0T9I8tkPO3P+3rphazoIS5NO+buOxwN0wBKDsDLtgxmfx9QcvT0TERayUjyQxqTtP8kdfovn/qWP3d7eLv+XXfMXXnihKKsvv/wyQkNDcfDgQYwfP95w39mzZ8v1F198EW+//bZ4ShsbG4eU/1n6/+KLL05amf6UJKNT3n0OVlY6FDc3IdzZFeiF7FyoiIboXLC1uBhWZma4ctwEvLX7gOzIF0aEob2tG7uKSmFuaopb50zDtwczkF/bIDvQv502E6sOZuNgcYU81+XTJ8DDzh4vr94hBywe+O5cMgd55fV4d8M+2fnZWVnixjOTEerhghdWbkFehbIj8XNzxA1nJyPYwxlvfL8LWw8XGN5DclwgLj4tCf5uTvhq42H8sDUdLW1H1KnEKD8sTI7C3IlhqG1ow6bdufh5Ty4Ky4x3aoCzoy0SY/wwIcYf46J8hTzV1LUiI6cKmbmVyCmoRl5RrSibo8HK0lwIHcmdm4s9XJxs5XG5OOhsoLO3hs7OCra2lrC1thRFk+rQiYJfUaqLXd196OzqQWdXLzo6e9DW0S3qa2tbt2wDKrLNrZ1oau5EU0sHmpo70NjcIf/veGBrYwkvDwd4ezjKQuXT29MRft5Ocjsfp4yqZ1UTSqsaUVbZKCSztLJxTKJKpVbUT18XBPu7IYgE098VlpbmKKpoQFFFPQrK6+UzIsGsbRydxHm56hDs64pQPzeE+rvpSao9Kutb5f8W6BeS1Yr65lFPGHS2Vgj21pNUbxJVF1FC+b0srWlCYXUDiqqoqCrK7FgKKE8qvF0dREVV1FQn+Lk7wtNZJ4SIRLK0rlleT3lDC8q5rm9Be3fPsT8TKwt4OenksTwd7eHpxEUHD0c7URyZB0LCRCW5rrVd1Fsu9a3tqGvtQH1rx3E9z0gnF1RXHW2t4WBjpV9bixLLtc7GShaSWJI/ksBBE5Xwkez1o62rB23dPfL86tLR06us9Zc7uql29opy+1sQvrHA/ZhCaM0NRJfKJt+TtZ7skvioBNHczEzepxmVKiG9CtnlexY9a2BAFpI0qrl8n236hcSeSijX/NsvhZMoobZCMPmZ8PXxtfED43OTODd3daGqpQ2Vza2ijo4Fvm9/J0d4OtjD3sZKTkg6+3pR3daOgoYGtI9QMSK87O0R6OoEnbUlegcHUNHWirx6kr6hn6GtuTki3N2EcLf2dCOrnuR06PcxwNFRyHJ7fy8y62vRO3CE5DrpiWt7fw+ym2oNqiu3fYSzG2A6iJzmOoNIYWthjhBHZ1R2NaOpR1GDKTyGObqgrqcVLb1dhtflY2ePso56Ifz8JAPtHdHc14qufoWUetvYoWugA90DPUJCfWzt0dxL5XcQFiaAs5UV2voUNdTNygpdAyTVg3AwN4eZSRf6B/tgbWoKK9N+9A/2iEpqbaoopvZUz9Ehj6szI91UlFGdGR+9G/amLNt2CsG1FXLag652D0yKPqSR0WEgqQwODpYu+uuuu048tWxeIuFUeQ/L8sMbmPbt2yeNT8S6detwxhlnnNQGplOSjJ7x4WvIbGuBt509PCx0SKmpkpJHnJsnNhUUGhTRN3ftl5/puTFRKKlpREpFtSgWt8+bjn9v3iNn59yJ/WX+dDy/ehtqWtrlbP+ec+Zh/aEcbE5XSOScmBBcOnMCnlq5GXmVCilcMC4M1542Ge+v24+1+7LlNpZVrz9rKiZH+uPN73dh/d4cuZ1lvdMmR+DKMyejq7sXH/64D1v25xt2QJ6uOiyeFYtFM2NhMgis2ZqBtdsyUVLROIQwjIvyQ/KEYEwdH4RgP1dROg+kluBQeikOZ5ajYQQSRIUiwMcZgX6uCPRzgT9L9t5O8PF0hJOjragxJIi1da1StudjNLFc39yJlrZOtLZ1ob29R8hjZ2cPurp60dPbh97eflE++/sHMDDAg/gREqAe8GhBsDA3FdLGhWTWxoaLpRBHO5bm7Fmet4ZOZw1HnQ0cWZZ3tIWTk62U7vn6+Nx1DW2oZ2leSvJtQrxlqW9BdW2rkNaxwNdFFdXPx1nev5+3sxD4AF8XIeQt7d0oofLJpVy/rmhAZc3ohNDe1gpBfi4I9nNDiD/JJUmqG8zNTaVET4JaUMalTi7XNbWP+tp8PZwQSgWVaqqfQlY9Xe1F7VTJqawr61FW0zykTDjcmhHo5SJEldYBqvNcO9pbo6KhBSVqub+mESX6ddcYNgRRjJ0dhJzyJMtXv/i4OsDBzhrtXT2iqvKxKxu5tKJSf/lYFgAVJCMsz7s72MnazdFOrABUbaVkb6t8D/ieqXI2tnWKPaChTSnZ08pwZN31i8jrcPD3RrLM0j1POkmaeN3OWr2sL3Hr/0YCSIVTSJ4QPZJbEr0jyiYXktzuPpK9XtnuJHZqyb5ryELFs2/I7d19yvo/Ab5+7gvVbcBFZ2Wlty8oxJdqriig/JKYKGSW74+vkQS2oYN2ig6xVnA5XrLO56Ztw8vBHu46e+isLWBhZi6ki2pvY2cHShubUd7UchR5NH4MfycHBLg4GUhqS3c3ihqbUNzUNOL/CXZxhr+zo6jVjd1dyKqrlf8zvLQf5eEu26ausx2ZdbVDXoO9pSWi3N1gYmaCrIZaUVdVkPyFurqiqbdziGJqZ2GJMGdn1HS1obLjSGk+2NEZ5uZD1dIgnRP6TfpQ1dliUH6DHByFlKrqKUlpk5FS6m9HlbYZfYP9MBVSaofGXm6DQTha8LfVg56BXpiZDMDVylJfuh+AuyUJaqtSxrewNKikzhbm6BtsF2XUwdwE/YOdsDYxgYVpN0zQD0cp27fDEv2wNaVFYEAp6/cmIyH0o1OejK5du1ZOACMjI5GXl4e//vWvompu3boVFhYWePLJJ/HEE0/gvffeE5J67733IiUlBRkZGYbGJ3beV1dXS/xTb28vrrrqKmlo+vjjj3GycEqSUf/nHxY5PNHVB1tLiqGztMIc/yD8kJ0jasE14xMNiuiyuBhkl9cis7oWTjbW+NOsZDy7fpuoGtFe7rhk4jg8/v1m2YFS4fzz6TPw1Dc/S6mSB5c7Fs9Cb28fXvphu/gWne1t8I/z54vi+NxXW9DW2S07vuWzEnDZgkR8+tMhfL7xkJA07qNPnxyFaxdPFQL11re7cCCzzPB+psQH4oLTJmBirD+27cvHdxtSsS+txPB3lsOnjg/GnCnhmDYhRHb+ew8VYef+Auw5VITa+qGGaR4YIoI9EB3uhcgwL4QHeyDIz1XUTJLK4pJ6FJfVo6y8EeUVjaioakJ1TYv4Q/8bYWFuBmdnWynPu7qyRG8PNzd7uLvplBK9h4NctrQwR3d3L6pqW1DF8nxNs5TlK1ier2oWBZRq7GjgdiY5JTElYQ/yd0WQvxv8fZxlh82TgqJypTwv6mdpPcqqGkc9uDrpbISUhgS4ITRAIapc+vr7UVjeIOQ0nwS1rF7WzUbKuDH4edM7qpT53RSy6ucmvld6W1niJzlViSqJJr+jI4HfUV93R/Gkkqwqa2cp1fN3IiV6ktNaEtQmlNU2oayuGZ3dYytTJGUkpj70lbo6iMJKXynL9fytkEDRQ0p1VUr1TW2oadKX6ulTbh/bCzgcVDNJUPnYzvbKmlULluqVxVoIIwkh0ds3IGqeoUSvL9m36sv2rVQ/eb2rG21U67u7f3MPJ/2NVkYle7msXxsumyslfEvzI387UgJXSvmmehJo3MSrlPUHwK8mvbYsZ9Oy0EH/qpDfI2ouSXB7d+8RlVeWnl/l/fO1OtkqNgr6OOkNtbOxktfP3zWfQi3fN3V1oaa1HdUtbahpbRMLwrFOFHwcHeDn7AhXe1s5EeCGaO/pRkVLKwrqGtDcNXJFiIQ63MMVHg52crJMsphX34DSJpath8LZxhpRnu7yneP90muq0TyMnPrqdAhxdcEABkQVre888n22MDNFnIcnrCzNhJiS4KrwsrNHgJMDStqbxKuqgH5RqrVWyGysQZ+QS8DZ2hp+Oh1yW1XVdRBeNvawszRDSYciWJibmCDEwQllnfX6/zeIYJ2TeEoVEgoE2OtQ001iOwg7c3PYW5iirY8nyErpvlVfuneytMTAYDsGWIY3M4OlaQ/6B3vFB2phovhHdeZmMAXL+YNw5Oc52AYz9MPejHS1C/amgzA36RTCystAN3raXTE3dv8pT0Y///xz3HXXXaJisulo2bJlePTRR4XbyLdgcFCan15//XU0NTVhxowZeOWVVxARETEk9P7mm2/G999/Lx5rPgazSe3t7XGycEqS0cAXHsHi6HH4ITtbzgyXR8bi09Q07pdxQ9IkvL37gOzolsRGI6+iTogoy0I3Tp+Mp9ZulbP35BB/zAwOxHNrtsnOd2ZEEM4eF4WHvvhJdtq+Lg546IKF+GDTfmxJL5Tnnxsfij+emYwXV27DjowiuS06wAP3XLxACMaLX2xBo765ZFp8EP60fCY6O3vxyhfbDCSUBOOM6dG45MwkONrb4Ot1h/DNTylo0Ct7PLAkxQbgjFkxmD0pTIjCll25+HlnLvYdLhY10phExUX5IjHeH+Ni/BAd5gUrKwvUN7QhM7sS2blVyM2vRn5RLWpq1TPukUGl0s3VHi7OdnB2shV10sHBRtRJNhixVE/fprW1haJ0WrChQ1FGlIYOZTniGR1Aby/X/ejp6RdFmISxo7NXKdXzwN+uNEi1trJE34VWlulbOqWRimro8YDby9XFHl4szXs5Slnem41J3k7w9XGSvxFUTssqm8Qzq65Ly5VS/WieVhIaH08nBAe4Snle1gFu4itlMYrlfTaSkaAWlNZJ01lFTdOoB3N6eElOwwLdlRJ9gJs0lZGMqgoqyWm+XK6XxrGRQJIiVgFfVyn5c00l1c2Z5f4WIahF9LYKWWW5vmFMGwL9xoGeCjn1Z/OTpxP8PXnZET19A9LoJF7SWqXpSV2Ox1PK18oSvRfL9C46pUTvbC/X6WHlb4ANPyzJ1zUrJfq6liNrlulZsufv6pc0yPC7aSjNc60v25NgUDHjZap99jb65iUrC8N3mkocP0sSahI4pSzfI2owyZxxmX7o0ocu9TJVzZ6+38SberzgSTUVc7WUr3hYj3hZFZWXKqjia2UTkRBe1Quuh/hVBwfQ3dsvyqcQ/K5uvSe3C82dXeLRHe2EaDSQoFIJpRru6cBmJht5vaZmpkKsqHTXtrWjrLEZZU0tY6rDVKmDXZ3h7+IonzF3ELQXFDc0Ire2YcTPgSJFtJeHnNRQza5obUVadbUo2MZgs1Gst4dsp+qOdqRWVwnZV8Emt3gvT/l7fmMDSlqahxDTBE8vmJmbILW+2sh+MIhoNz6mmdzeoy/x25lbIMLVDSVtjajvVo4NrPhFubiipKMBrb0KKXaztoGLjRUK2xT1lMfDYAdHlLTXyfeXDbxBOgeUdyp/tzEzg5u1Jep7mg1+0q6BNvQP9sPK1BQOFmZo7+8QBdTd2hrt/S1y2U2vkir+Uaqk7TA3GYCjOdA32AVbU8DCpEtUUBLVwcF2WJkMwMa0W5qXHExNYNE3GZPD3j3lyejvFackGf3DN59jTYmiIF4aNx4fHVI64a9NTMIn+1PkAHBGZLg0sqRWVhuI6JNrtsgOdUFUKEKdXfDmz8oIrgunJMDHXocXV2+X61PDA3D9gsm476N1Un7kzvKvS2fL4zz84Xq0dChd9jedMw2z4oLx+AcbsD9bIZssid5x0RxRof756VZs3pcnt1MNOHdOHC4/e7L4Jz/8bi/WbMkwkEuqXYvnxePsufHS/Uz1c+3mDFkbE1CWmJMnhiI5MRgJ0b5CDMsrm3AwpQSHU0uRmlGOquqjz/IJNv0EBrjB308p1XuLl9JRFEaSTmOQTJIYtrZ0KqSxrUsIJMk1SSXfA0v1PPAMcDH6FlKU4gHdnM0Z5mb6Mr0ZrK0tlTI9S512lrDTd9Hb2VnJ/Y3B52ho6kBjYzvqG5TyfH19G2rrW8VSUFOrlOfH6nQnrKzMldK8rwv8fZ3hz7WfCwL8XMQewPdZXduilObLqBw3SLNXUWn9qH5bvlaW+EMC3RAS6C6kMizIXdRaNpaJekrVs6RWCCoXJgCMBJJ6+k+FpAa4yzo00F3U1ar6VqXET3LKkr8os3VCBkYCD+AqOeU6iI1Pvq7wctOhqbVTaXZSO/zFT9qIirrRbQhqAxV9pH6yOCqX3Z3k+00SW9XQKv5RPo6U5xtaUVHPdYuQy+MmI452cHeyl7WburCz3lHprufr4HZXy/QNrSzTd8hlqqvN7V1oMr7c0Tmm/eCEG5KMCZuVvsOeXemytlDInn5Nvyb/pqifynWSEVFr9eRO3W2TMAyw2W9AafQj0eqRcny/lOhJhNVSvVzn7fpyfY9xCd943dN7FJH6tcHtoHpvh3hybaxgyxNWElrx4VKhpQ9XIbD8fMQbrF9IXo8HDtZW8HNxhK+zA1x0VEMtFL9xb5+oqUxVKa5vGvWEhfvuCE83eDnq5ASpo7dH/k9mdd1RBJUELsrLHUGuztIUWdnWhsOVlfJcxghzdUGIuzP6MIDUmhpUG0X7iK3Ky0s8siSmRc1HrAE6S0vEeXlKZ/3h2iqDj9TB0grRHm4oa29GebvaFDWIWDcPdPT3orC1QW7h1yjG1R3V3S1o0BNVVz0pLWo7Qjqppha31xk8pu421qjuUsrz7la2GDDpkian4aV7dys7tPcfrZI6mrMpsZ3fWDiaW0pDE5VRFynbt4kKqjOnHaUbdvy+Q1FGdWb8TLrR3+GJxXGbNDL6O8UpSUbDn30cvRYWWBIRjTXZueju78fymFhszikUn9KMoAAM9gxKsxLPem+ZmYwn1vwsO6pFcZHyw/1oh9Ixf/OCZCEKn+1Ikesrpo9HYpA37v94vezc/Vwd8eQVZ2HVrkx8uvmQQQ196IozsDejGC9/tU0ICJuBrj8nGUtmxokn9OPV+4WoUWE5e1Ysrl2aLATr7a924aftWQbPX1yENy48K0lUUJKrb9cdxuqNaRKxpIJkZ860CMxJjpASMlXGA4eKsWtvAfbsL5TStDF4vAsKcENUhDciwjwRFuKB4EA3IV8EvzJUH8vLG1BZ2YTKqmbU1LSgtrZVCB+V1Raj5/+twddrzzgnBxs40i/qbAsXJzs4u9iJsuniopTmWaJ3crIzlGD5PtjkVFXN8nyzvA9aD2RdSQtC85g+NarAgSzJB7gq60A32U5UhfnY9KiSlBaW1ElpXlnXob2jZ1QPaWiQuywkpySVJKz0yrIhS4gpFdTiWllTTR2tOcvF0VYUVFVF5WOxgYqErII+0lKVoCpklR5V45OWo+Ke2IAlC4mq4iP191JK9IywEi9pVaNSqtevj0UmSbRISn1JTt0c4EMvqfuRcj2Ve5blGZlVxfinBuVydVMrapva5TYSyBP5njja2ShlellYqlcWJ3Wxsxa1lf5tlorZjMOTx1aqeLJWSvVcy6Iv07exTM/LXT2iSCtNSmNbFH5NcD/B7aWU54+U6Edbc9sPv9243M8StLle2dSnUB1pVqKPVd+sRPKqqruq0mto1urule2irrlt/j+eVVqoqD660hes46KkIthYkbiaCnGVz6uzG1XNrahs4tIiMV5jQdRQdxcEuTmJdYPbsau/H7VtbciprkdR/dAoJhUkinE+nvB20klzV117O1IrqiVKavhnQ0tXiLsLBk2BgoZGpFVVD4mAcrCyxAQ/bzlRyW1oQG5D/RBiOsHbW8rvGXU1qGo/QlqDnJykez+7qc7o9kHEe3jCxAxIqVdzIwcR6ugin3t6Y7XhtlhXD9T2tBjUU3bf21mYoVRfvmdHvoOVOSo7FaLpYW0HmPSipa9T34nvYCjdO1sq/lE2PFmamMDR0lxUUjMTxkSZo6OfPtEBOFuaoXugE5YmJL1Uy3vgYG5Go4RRtz2VUUiJn8qooxlg1ZeA+RFvn1Qy2tRY+Zt00zs5e5+U9/XfhFOSjAY8+QimhoaijEpMWxtmBATIgS6/oRExHu4IdnDCmoxcaVa6Y/5MPLnmZ/FNnRUXARdLG3yyS1FS71o8Byn5lVh9KFsOdOIP7ekXfygxLSoQdyyZjYc+WI/Uwkq57bIFSbhw1jg88t567MlU1NnJ0QG454rTRA176r0NqK5XdmZT4wNx68WzobO1xptf7MCqzWkGcjQtMQSXnzsZ8ZE+OJhWis++2ycqqPppujrbYeHsGJw+J0aICLvOt+/Kw8/bsrHnQNEQRZANMzGRPhif4I+EWH/ERHlLcxBBNTM3rxp5+dUoKKhFYWEtSkrq5fGOlyRyYR6ora2VNB9RbaTaachdVOOdVM9av1KqV6KdBuS1dndz6ZXXwxJ8R3uPvAY2RJ0I+F7FM+rhAC9PR3iyNM+ueb3SS/KqklXGSlElZjm+tFwpy5eWcd0gzVqjgWSUpDQkyB3BQW5CLklUaWXgz42NUySUBcV1KCDBLK4VRZUq60jbkH5U+nfDgj0QTqIa7CGfLz9rxk6RpOYV1yjrMUr9PKjRIkD/qZBU8aS6i/LJ71V5TZMQ00JVRS2vF2I5qg2BPlJPR31GqpqTqqypzDILl95REtMydaltljVJ5bH2PCyDe7vq4KUnp1Kmd9FJ7i4Xqp8kCSz31za3Cfmlj5RrWVimb+kQFZRl+tGatsYCv58kpvwNSrneVlHz+NpYtlcuKyV6rpkaYadfeIJJvZ4EydA1r/dY0ksrZXhZ6yOUetiUpFw3NB7xNoOqqZTsVfVzNIX7Pwmq0mqpXsr2etWX16Vxy4qZq9weioVBbVwyMfzeB9HXz/zRPiGrbCATdZpNS1So2VjGRshRPJyj2QqYukCSyMgw+jtZTSGx5mfBZqiS+iYU1zWigk1Mo5xw0nIQ5umGUE8X8RMzMauxswvZ1XWyDFdE+VsN93AT4snvAi0IbHotamg86nET/X3g7mgvDU57y8rF96qC+dMT/X3ku0ZSml1/JDOaCmWSn68kN+ytLJfMWXnPpqZI8vVBD/pxoLrCQHQDHBzg7aDDofoKEV0IP3sHuNra4HCDckwy0aunRzrwBxGoc0IvmFXaZsgp7RrsQkuv8vcQnTOqupROfHsLC+gsTNDcqyidfrb2aOhtPMpL6m5ljc4B/WVLK3QPtOgjoJSyvZXpIGxNqRP3CiFlqZ7KqK0Z300vLLoCcX78lyeVjJZm+cJB9+tOf2ppHYB/VLlGRk9FMpr0z+cR5u6DPeVlCHZ2RqCdI7YUFMPT3g5nhUfg/d0H5Sz8noWz8ez67XKWPz8yBIEOTnhvO8d2AfeeOw/b0oukY54710cuWojD+ZX4bJtCVC+ZPQGnJYTj72/8ILEzPJA9dOUZMIcJ7ntzjSg6PEu97YLZWJAUjmc/3IR1O5Wuem83B9x+2VxMjvXHJz/sxwff7jEoYNMTQ3Dt+dMkB3Tr7lx88NVuZOerZ7rAlAlBOPf08UieGCLXd+8rwNqf0rBzT/4QUkEiljwpBFMnhWBcvL/srPlVoCp4+HAJ0tPLkJFVgeLiuhFJA7cBCZ2Pt7OQOGkGctfB1ZULfaN24hkdXj7/tcFSP5urqMQ2N3fI0qgvzzc0cFHK83V1DOVvl879sUCSzPfj5+sMP9oRWJb3d0GAv6sE6aseOBLhktIGFJfWo6ikDkUlyprkdbRfFH2oIcEKmeQ6PMRDPgc+Jt8Hy/x5VD2LlIXRWqN1+TPMX8ipfgkLdpekA34XqcxRic3lYxmV+ltH6U5nuTyYpX5/d6OGKVcZFsAmFiqpbJwiOVWjqIoqGkf1pBIkamye8vd2hr+nk3KZi6eTKMAsETOOqry2CeXMcxUfaQuq6lvETzpaU5Yx+FG4ONiJd9Td2V7WtKi469dquZ7EmOBvjuRUSvOtR0gqCY+U6Ns65Xmb9V31J+pdHA3clwhJs1a658VvqSdvR8rz+hI945WoTkp53sxwXVRPoyYltZFH4pXYec8cUSF27EhXFEtWXFiS5++eJ9PGJFZdG0r5Pfyb/vqQsj7/3q+QYn0D029BguXE1Zpk30oal3gCQAKoKtck/bSk8P3yU+GJKkv0tWxa4kmIrNukhH+sIxrVX1asAhlF5qp4Q9m9zoas8sYW5FXXo6C2YcQcW56AhXi4INrbQ75bjC+pbG1DankVShqOtjcFuzkjwddLTl7qOzqwr6QMtW1Df9Ph7q6I8fFAn8kgDpRXoKy5ZQhxneTvK+T2UHUVylpahkRCRXq4obilaQhhjXB1lZSX/TUVhhgpVxsbRLi5Iq2xWiKmCEY7udvb4XC9QkrZxM5EmYL2OnT08f8NIsrZHZVdjYbrkU6uKO6olRM7NjG5WluhplshmAF2DqjvqZfvoYulNQZNuqTLngTaynQA3QPdsDUzhZVZr+SSOphbiBo6qM8k7R1olSgnJwt6fTukmclMr5bqzE1g1ROE82I+0Mjo7xSnJBn909df4fvCIjGML4+Kw0cHDou5++apU/Diph1y37/On4n3dhwQX9LkID9M9veTqUrEfSoRzSiQztanL1uE1fuysPZgjuxU/7p0Djzs7XDvu2tkhxbm44pnbjgHq3dk4M0fdsnOMjLAA4/ecJZ0bj/8+jrUN7fLju7iM5Nw3XnJ2J9eiuff2Sih62o5/uZLZosSunV3Ht76dLsoawQPXGfNi8PysxOlo5uE6Ps1h7FqXeqQuKYAfxfMnRmF2dMjRLUjCWLzz779hdi7rwAHDhSLl3I4SDLDQj0RGqqQKPpGfX2dhbgNB9XL+jqFADY1tqO5qUOIIp+nvb0LnR1KvBOVzl69b1SJdzpy4JfwbnpG9b5RPg/VVDZXSayTrSXs7OkVtYbOgbFOLM/bwIGNU062cp/hc34JPk9dfatYCrhUVTXLtqpSy/LVzWOSVQedNfz9XRHIsnyQG4ICFeWTnfrq8/G9kZRyUEBBUS0KipT1SLFZBBXjUJLJUA+xQ4SHekqTk5rHylJ/XlEN8gprhJxyKSlvGPF1cjuFBLgiLEhPUkM8RBVXFVnmzirqaa2h1E+v62iky9XJTiLASE5JVtmVz0Yskkk+HqOmGF/FbvySSsVHytxVEsoxfaQ6G/h5Kh5SRlLxMsvznGxFjyeVaRJd+knZUEXvKx+zqqFFQv/Vcv3xkkX+rliSd3GwhTPjnrhmidfBVl6LlOxZouf3SK+C8uMk+SJRbe3oFh+poTzPcj2ni7E8LyV6fam+U2lOUpuUfi3P6YmAr1shqvpAfHqu1cWIxKrXuf+y0Jf3VcIrk5T0BFi9D/cxahmf91e68RXPKj9r6W5niH4Py/ZKiV5K9WJZ6EU7c0Z52Sh9QLU6/NLtRMVVIr0c7SXWS05KqIJaWcjvkT5TElb69ssaODmsWRIZxrLeUEUN9XJFiKer2DmohlLhzK2uR0ZFtTTKDQe3SbyfFyK93aRJk534h8oqkVVdO+R3wO8hy/rR3u4SvJ9dU4eDZZVDFHsfBx0SA32lUWlfeQVKjLr0naytMSXITzymO0pLDGH6VEWn+PvJY+4sLzWE8bvZ2iLOywMZDbWo1nfc028a7+mJjKZqNOm78/3tHeFoa4m0BkXU4HEx0sUVGc2VEjvFx490dkF2i/J3nYUl3Gys9MH5JKEMzW9G7yBD7M3hYGkqKillCB9bG/mbEpZvi5Y+RQ11t1YioJhX6mgxiJ6BLtibKZ5SYx+ptQmD79nY1A+X/vE4P/afWpn+d4pTkowGP/4YO1NwQ9JEvLlTyRK9bXoy3ti6V8oel0+egD35pVKKYYzHRRPi8dj3m+Ux/nrWLKQUVGB9Sp7spJ+/8mx8uS0Vm9MUhfSxy84QAvHMFz/L/WfGB+MfKxbg8Q83YMuhfLlt+ZxxuGX5DLyxcic+WXNAbqMf7/4bzpCS5PPvbMCGnUrGqIerPf54yWwsmBaJ1MxyvPLez0jPqTQQmeWLEoWEUsVKTS/DZ1/vlXK8SlZYMl44LwYL58UK2eFOmkRsy7ZsbN+eg9S0siHEhmXsyAhvxMf7IzbGF9FR3uK5NEZbaxeKi+pQUlyHsrIGVJQ3okpP5lqa/3Ne0dHAjn36Rfm6Xd0Y56SDm7sD3D0c4OnpIKV5Z6NyvAqW5RlVVc4u+fIGeW+8XFJaL9ts1AB5nTWCgtwQzLJ8sLuQS67ZWKWC3tSCQr3iWVAjC0nrSGNS+RnQs0tiGh7qITFboSHuol6rhJ/l/dzCWiGpuUU18rgjxU9JBqkXy/yKIisqapC7xFzJAbuvH8UV7OpX/KgFJbXiJ1VPgkaCu4u9kFR25DP6K1iyUl3hYK8okFTROA6VJf4SJg9UNyo+0qqmMadOESRQnGRFcsoKgbe7g1Kmd3OQ21Wyyu8s1c1axjxxpCvL8/rLJMlqqZ73OdE9HEkDhzWQmDILVUrzdkqJnkTcUJ5nzq2+TM/YIbVMzzI1XyPJcqeemEmZXl30XfWd3foyvL5ML41DbELi2qhUf0Tl7NcrmHp1U5ROpQnwvwH8rlHJNW7SUi+TOBpbGAxWBxsr8USr2arstud7YqOZWqKXhjN9LmyDPh3heNVZiQ5zcZCRtFRDmcLA5yc4aIDjbYtqG2TIA3OiR1O2gz1dEO3rgQA3RyHjJJwZFTVILa06ykIgHlEfdyQEeMt3pr6zA3uLyiUyyhhu9rZIDgkQH2xpUwt2FBYPaXJiED6FEI4m3VZcgrr2I7+dKA83aajKa6xHWk3NEFWUaQAs1dfox5gy23Siny+KWhtR1NJkyDNN8PREWmOVIcs03MkVMBtEbrMicnjY2MHVzho5LTWG63aWpijrUPyjIQ7OqOtplpB8a1MzeNrZGBqcjL2k3jb2aOlrPKq5ycPaGh39JKoDcLeyRFd/m3hNrc36MDDYK3mkA/rGJnuzfph2OeK68V9rDUy/U5ySZDTwsUdxdnwC9hWVyw98aVw0DhZWSBDyjJBA2Jia46esfNlZ/G3BLPzjy7VyNn3dnEnSof31nnTxJT1/xdlYuUMholQTnrv6bKQVVOGNVbvl+S6cMx6Xzk/EX17+FnlldXKfu684DZOi/HH3yz8gLU8hlRecNh5/vGgmdh4sxNNv/CSdy/T3XbgoCVcvT0ZbWzf+9d5mbNymlPE5F/78s5OwYskk6SZnKf7Dz3ZJJ7yKxHEBOHfRBEyfEiY7T6qTm37OxIYNGUhLP5JVSpBITZ4UgolJwYiL9RMyp4LKZmZmObIzK5GbU4n8vBrUDmt4Gg6qmK5uOlEpHbk42iq+UXtOY7KCtY2FwTfKRgmJwpHsQ5YbjUaC9jHeidFOil+0u6tP8Yx20DPKyUtdSrd+a5dSom/qEMX1eGBhaQZPxjj5OMHHxxk+vi7w9XOGr58LvLydjpoURcWT5JTElNYFZq4WFdUJaR1NTWW5PzREUT2pKoeFecLD3cGgovK9lbA0X1ArEVokqLkF1fJ5Dwf/S4CfqzSUkaSqazXFgK+hvKpJIad6gppbUCMnRiOBzV4kpSSnVE9JVBnAz8+DUEv97L6XZidpmKqX8bCjgZO3gtQxqPqxqByY4OXuIA0mBCOiSFTFP1rdJHmn9KpyXdMwtmolnxs7553t4eliL8MeOCKVE6ikTE8fqZMdXBzt5MSQIFFrktinDjS0tKOBZfpWhdQ06i83tnVIeZ6/Oyp3vwaUsvwRMma8SEneyqg8T9VfX5qXBiRL9bJezVQVS3X8p9yuKpxKdYKldvmtcHxu3xGiql5mWfvI9f4h9+ffSHjVvw8p76sd+MYB+noCzfvx+miNb78U3PdRnVYbylTVWka46hvP6EGlakllluqqmjtbpW944/AEEtixQJLJAQycdBfk6QJfFx3Mzc3lvdNPmltZj+yKWiHGI/3fCB83xAd4SSYum6cKaxuwv6gcpcPK9bzv+EBvxPl7SSpIXm0DdhSUDBmuwHL8tNAA+Lk4oaq1FVvyioZMj4r2dEecn6eMr/65sNjgV2VfA49Zg6aD+Lm4yOAhZVme5f3cxnrkNSokmIkM0/wDJJu0oFnxsTpZWSPO0wP7a8vQKeNFBzHO3RtVXS2o7lT8opz01NLfYfCPxrh4SPQTR6NamZnC316Hkg6FeAbZO6G2p1FOKlytrAHpuO+BPZvmzAfQ2d8lsVMWpr3oGeiBo4UlBsB59wMGHynL8swe7R3shKN8v5UM0giL03FOxB0aGf2d4pQko9Nefkk8o9uLShDp7oZAOwdsyCmAr5MDzomOxL+37hWy+cSShXho5QaJFDlnQjR8dDq8/tMeIU3PXHYW1h3IwbpDuXKAePHac7ErvRgf/LRfnouxTbPjgvGnF76Wzl8qOs/efI4cAO568Xs5CFJhuff60zEpNkBK8j9uTpf/y4iee248XUjCVz8ewFufbBfVi4Tk7AUJuPqiaaJs7TtYhLfe34qMbIXU8uC0cH4szl8yURpo+NEeTinB9z8cwrbtOfLcBB8nLs4Ps2ZEYlpyuJAmFY0NbTiwvwiHDxUj9XApSkuGjhE1Lt0HBLrBL8BVSvYkcF7ejqI+kniOVCb/T4A2AMUv2oYGdvbXtaGuthW1tUppvrqqGfV1rWOW40mMvdmME+Aq7zEgyBWBsnYTMm0MEuVSkjaW4wuVBq/8ghrU1Y2cy0ofbTiJJFMKuA73gq+P85AOf6YbkJzKkleNnPxqiacaCYydigj3RIQQVC9ZU6lVQZ9sLtVYfZmfRJUNWCORPn5/GNovnfz6bn6umUyggr5TRlex2Y5B/sq6HtWjvF+CxMnX00nIqXhI6cn1cpaMVFoB1O+KKNOMdqptEZ9qZW0LKhn5VKeU6WkzOJ4mJP4+mSbAxxbvKAkqY544rtZBKc+ra52d9RCFnOSrRWKeutDKufT0IzMHkyc/HV1SYuZlrtv1pXnlstJJP1IT2m8NnsyppXieTCileFP5PNWSvEwzMxt6u/o34/VQonuEDB8p3Rv5V/Wlez6mOkeeZFZVgEURVm0LLNWLjaFbX6rvERIpJfsOfUIBGxJ/Qbc9CT9L9cyfZame6icb3PiZs8rAcj2b3FimL9Nn3nI4w2jPxa+jv6sTwn3cZOHj8VvHZqfMshqklVaPSHQ5rjYxxFdIKiOdCmsbsSu/RHyoxmDQ/syIQHi7OooYsiW3EBXNrUPK/jPDAuHn6oTC+gZsyy825JGyZD4jLEjsCLvLyqQzX0Wir7d4YHeUlRpioujXZB52WVsr0mqrDaR0ekAgClobxG+qhugHuzhhd02p/MZ4nwke3jjcoDQ+Ma5qnIcn0poqpHRvb2EJX3s7FLTV6QPyqZI2CUHl31iqb+hpEx+qr50t6rqbpPzua2srZXueKrpbW6G1rw1WnFZmrsy3d7GwRN+gOrXJXBqb7M3MYGbSjr52U9wzeZVGRn+nOCXJ6D++/wGfpOeI8nDdxCS8umWP/MjvWTgHD/24UdS5e86cg0+2HZLsuaQgX5yTEI0Hv/xJHue+5fORWVKDr3akigLz0rXnYE9mqYGI/u3CuYj19xAiyh1siI8rXrptqQTXP/rmOlFrwgPc8eSti0XJu+e578V7x53gZedOxjXnT0NZRSMee3k1svKUHUh8lC9uu24eIkI8kV9Yi1ff2oS9B5TgfJa5zl00HheeN0m6wakirv8pHV99vU9UPBUhIe5YuCAOc+fGSEc5QVKWnVWBndtzsXtXHvJzjzRDqSApi4z2QUSkN8LCPREc4gF7I8IzHD3dfairbUEDm4Ya9L7Rpg7JGm1v60YnDzr6vFGmD/TLWFBl3CFhoieEEi/DA6L4Rc0lZ9SaflE7S9jqu/R1jjbiG6UC6+RsB0dnu6NUzeEg6amtaUVlZSMqK5pkqahoRDnL8qUNY3boe3g6ICjYXbZBCCOvQj0QEOhqUBRVMGM1nwMD8muEnDKNoLi4fkSywuSC8HCFmEZGcPGGj4/TEELPuKycPIWgZnOdVy35piPBx8tJlNPIcC+DgkolVIVa5lc9qEqzVM2okVNUPElKGRHGqCmSVJJW1TZAkHQok6bqDeNQeb1sjG58gkohiSqJKTvzeZmjZhnwz/GrJEWGz61/ALWNbZI2QdJaQ/8v141tQlS5ZszaiXTNU4WjvYBqG9U3B3t9tJO9tXKZHlJZWJ5Xgu8l29bG0qD2quCuVKKOuvRTibjWRz2pXfOMVeNl6ZqXtVEZXr9WM0CV24xUTqPL/63g56U2aFkbyvV6ldioTE+Lg6z1qQSq/YFEjJ+eEqnVpVeulYYzdc1BBrRgsBnteJVsNwdbUUH93Z2UrFs3NtIx63JQVNTCmgYUVDUgv7J+VEWVCm2svydi/D2k7N+PQWl2OlxUKSR1eEYp/adTwgMQ4euOfgzgUEklduWVSASWCh6DksMCEO3nKUH0m7MLUdzQNCQfdV5UCJztbLG7pBTplUdK8n5ODpgWGojaznZsyi80jBUNcHJEUoAPUmurkVOviAmWZqaYHRws05o4/lpVY5P9/cUryhB+tcxvbWlmiIRi1JOXzt7Q5MQR2nZWZihso9o6iCgnN1R0NaKzv1cUT3dba1TovaRhDs4o61TIKgWf2h5FPfW1tUeTvtvey9oOLX0kpwNwtTZHZ38HdOZs82036rRvk/n0U2yX4LTQyzUy+jvFKUlGYx59Ct1m5rhxyiS8v/OglDZumZWMT/ccRl1bB84bH4uW1k5syiyQeJB/nD0Xf37vBzkYXrdgMqxMzfDKqp1CHp+58mwpwb/+o9LcdPeKeWJ+v/XFr+VgkxDmg+dvORdf/nQYr3+lNEfNmxSO+64/AzsPFuCRV9dIpzx9eA/ccpbMj//8+/14/cOtUv7ige+PV86RBqX29m68+f5WfLf6kJBInvUvWTQBl1wwVTIv+fdvvzuAL1fulfnwBEvup82PxaKzxiMiwktu40eemVGBTT+lY8vPmaIeGoOEc0JiEBLGByA23l/UvJEIZ0lRLYoL61BG72hJA6r03tHmxrHLY781HBxt4OKmU/yiHg7w8HKEu6ey9vR2kvVohFUac2pbRe0sLa6XGKuSojoUswlpFHWSj0XVlEpnWLiXbL+QMM8hnlFVRaVyKopnLglllcRljRS8b29vhQiS00hvIadRkd6iRhsTVPpQSVCVpUoUVKYhjAR27UfqFVl6UElS6Sc2ft8ch5pHZbdYIaf5RXUor2ocNU2B06VITtXpUuoIVCpmKtiNz8clMS2lb7RSaXLi5CqqqWMRR5kx7mIPbw+FnDKCiiV/T8Y8cZyrmw5WDC83Ap+P08joGyUxpY+0vrlDLrNEz79Jeb6lQ04U/z9gdzy9oiSmspBwqb5R6ZxXBjQcIWb6EZ76taosqmV543L8cD+zMfhZqWV3iT5jSZ3ldqOyu7Iof+N9WNYlmeWa92PH/ZH7qY91pIwvj8n7Gd9m1GEvpX591BRJ82+h9kpHveS/WsNJpy/ROyg5o65Uvh3sZLtTkaWSzTK95NA2tqGqURmgwAa4YxFWqqkh3i4I9nKVZlM3J3sZz1lS24zs8hpkldWioLp+xGpCoIczxgf7IDbAUz7n0vom7C8ox+HiyqNOGug5TY4MkLSH0oYmbM4sQJmRakphg6X6+EAvNHZ1YV1mnow4VRHi5oJZEUFo7enB2sxcmQylEtr5UaHy/Gtz8wyjTDnxaU54sJTqD1dXGUjpvNAQUUQz6mqV+1nbINHPBzsqi/VNUYOY6uuP4vZGw6z7ce5eqOhsRm2XMv6TqmlmCydI9cPBwkr8okXt9YaO+8L2Gj3xdJCmJTY3uVvZoBft6Bnog5uVDboHWiUM38PKDm3iHaWP1BLt/a2wNjWBtWmPjA51sbBCD+/bboInpq3UyOjvFKckGQ1+4DFMCQ9FX2ef5MBNCw6AxaCp+HTYsLQ4JhIvrtshpakXL1mM+z5dJ2fjjGqaHxuKuz9YI493z/nzMNA3iKc+2yTX/3r+HET6uuNPL6yUnfTkmAA8fdM5eOXzrUJGicvPnoQ/LJ+Od77aKQH2xMS4ADx46yKaJfHwi6tlfjyRnBSCv920UDIlN/yciZdf2ygEhJgzIxI3XDUbPt5O4qP8+pv9+OyL3dK1TrBR57wlE3HmmQkyjpOgWrlmVQrWrUmRpiMV7E6fOCUU06aHI2lSCJydj5RlCR688nOqkJlWhuz0CuRlV6KsuH7MUrf4Rt11BrXSQa9gUtGU0aA2lrCgb5QB2xbKvGxmDxKDA4pKqnpG2XVPtZJqahdLfW3dimdUP+GptaULzezcb+6QjNJjgQd6klRvX2f4+LvAL4CLK/wCXeW24Srnke9PJ4oKalHELvn8GhRyKagRD+tIoP80PMIL4ZEKqQyL8BI11xhUSouK65CTU4mcnGpk51aKmqpaKozBMat8HBLTqCgfuWyseBL8/LNJTFWCmlctE7ZGAtVxklKW9sP1a450NSa8VPLUPNQCduDzcnHtkKEKw7ctSSqHK3ChgsomJ6Y8kKgZg0SHjVJlVU2yMDOV6RJcV9S0CPk5Fhx11vBQvaOuOhlpyqY/rpXFThTOkWwjEg9E5Y2xYFTdWhTvKC9zTUuCupYOen15/rcgX8NBYmIol8taIau8XS2n82RULpsplxm8zpK5eh9Jo9Cvj1xX7jf0b0Pvbyjn659frhu9FuPyPberqgjzpFo8pYYyvV4Rlm76I0qx2BtYqu9QLsu2Vcv17V2/yINKJZuk0kM/NtbLVSfZtCzXO9hZobOnH+Us09c2o7S2CSU1jSipaRLv8Gjwc3cUVTMqwANh3q7iM2fDU3pJFVKLq1BUMzQ/lGD5fGKYHyaE+oivNbeqDjtzS0Q5NQb9r7OjgxHl7y6l+o0Z+dKxr4IK8ZyoEDme5NbVY31mnsFWwM+D5NPf1QFb84tlXLUKHssYWbWxoAAV+vB9RysrzI8MRV5TPQ5VVRmamuaGBuNwTZVh7CinCvo66/BzWZGhySnR2xs7qoplrCqVz1h3D+ypLZW/e9nawd7a3KCSxrl4ILe1Wk4OvG3t0YMutPZ2SQ6pg6WZlO052cnJit327dJ5b2PeL1OcnC2tRQGld9RTxog2S6e9zrwffVK+t0KU+URcFP0njYz+TnFKktHIR57ENcnJeHP7PuisrHBd8kQ8/9N22ck+ds5C3PP5Wim5/OOcuVi1LwuHiioR4e2Gu5bMxY2vrpQz3ivnJUm35N/e+EGUo5sWT8PUqADc9MyX4pVKjgvEEzcuxrPvbcSP2zKUUPzL5+Gc2XF47NW1WLc9S17TirOTcOPFs5CRU4n7n/lexlZSJbnl6rk4Z2GCRAI98/Ja7NitdOJz0s9tNy1A4rhAITKr16bg3fe2GlQ75mFevCIZ8+ZGy4FFfKMHi/HNV/uwY0eOgayxiWj6jEjMnR+DxInBQ2Ka+Lg5GRU4sKcAh/YVISutbMTGIJ2DDQJD3OEfRO+oC3zY/OPjBHdPRyGe/2nfKMkxyWlDXSvqOQ2KflHGOFW3oLaqWfyi1ZVNouqOpciQoFLpDAh2Q1Cohyz+I5TiDYpiZTMK2ICUW4W8XK6rR23y8vN3EbtDVLSPLKHhnhJZZQwqVGyOysqpRHa2stCPOhL5p99XIafeiI7yEVI5/PHY6EU1lsSURJUlfgb4jwSqpUrElBIzRYJq7Gk19qKywUklqpwsNdYIVHWcLLNQA3ydpcGJBJVKqicbnIbl0XK7UsUkWa2kf5RRXLUtMqK3WpZWITnHA5IsFydbaWyi/5V+UnpGnfVrZrZKrBMneNnbiHI51neXJFmIFKcK6QkV/ZBSku884pOkz5sE7EhpXiFqare8qirKWM5udhD/7+2KDfFPenJKBVjJSzVXLhs1bolazDK9OhyAwwIklUAp26ulen7PGaUlY1lbjUr06gCDlg5Ru6VU39x+XLYF7tuZ0ECCyTJ9gKezZN/Sy8/PsbC6EfkV9bLkVdSNOj2MzUpxQZ6ID/YW+xWbnUhM2QCbWlR1VBB+gJsTkqMCkRDkja7+PuzKKcH27CIh4yqYNDA7JgTjg71R09aOtam5KKprHFLuPyM+Uk6qNmTnI63iiJWKAftUS/PqG7Axp8DwHYr39sT4QB9sKSoy+EpJSk+LCkNKbRWy6vQd87a2mBroj80lhWjWK63T/P1R19uB7AblPlGubjA1BzIaFULNqU31ve2o6lC8nYmePjjcWCb2Ch87HQZMelHf3Q4rjhS1t0NpR4NYr4IdHFDRqRDXQHt71HY3wtyE3lFLtPS1wd7cAqYm3egb7DN02ptxpKgF0DvYBfd+P9w76dmTSkYbf6MJTM7aBKZTk4ze/90qrEzLlaiUO+bNwKubd4uP5/YF0/HN7nTxiZ4eHw5fnQPe3bxfxrC9et1S3PH2D9K1OTsuRMr1Nzz/pZytnj8rARfNHo9rn/xMlBR2yz9zy7l4+t0NWL09U3xpjG2amRiKu575FntTS+Tg+7drF8g8+e/WpeD5N36SchqVpIf/eo5kTW7bmYunXlwj/kMqGpdfNA0Xnz9FVIq0tDK89M91yMtXdhDeXo646spZmDsnWh6bquLmTRn4/NNdQ3yg8Qn+OPPs8Zg5O0rUSRVUGvfuyMOOLdnYtzNfSN1w4hkT74fIOF9ERHkjNNILLsNUtLHQy8aQpk60tXTKc3W2D/ONqlmj+m8jH1dUHB7sqKDygGarekatYKezFt+q2Sgq5miQUab17aisaERFaQMqyhrEYlBeUo+yknp5TSOBryWAvkl6ZsM9EBrhJUons01HQlNTO/JyqhXFM4tJBFVChoeDn1UI45uifRAdQ4LqC/8A16PIH7cTP2sS0ywuWRUoG4FQ8v/RyyoENVIhqPT8Did7HR3d0m2fm19jUFCZFDBSKZLZicyXlTxURkSFeiIkiJmKQ5VO4xGosnDMaFm95KIyhWI0cNtSTfX10i/eypreUW9PRyE7w8HnolJJ3yg9pLVcGPHEdUMb6hpZpm9Ds75ScCLg8/HAL3FOXNM/aqfEOglxsrNWyvL661KWtxlaoh9NXR8LPAkx9ogauuP1HetSkteXztVFQu6HXeZvSS3Nc83bmQHaq17W33f4bcMfj39TnvdI+X8s/++vBRJZB/02V/27PFngSQObkth4xpMLEkmW62k5oB2D5Xl6iGV8bL1SoudSfYyUBnpaGa0X6uOGUF9XhPm6wd1FJxO8cspqkVVSg8ySahRVN45IcmODvDA+1AcJId7SuEQP6Z6cUqQWVw55Xt53crg/ZsQEie3gQGE5NqbmDYmUYtTVafFhiAn0Qn5NPX48nCVZqSqmhvojOSIQ+fUNWJWWLccwwt3eFosSotHa04Xv07IMtzMUf2poADYXFhpIqYedHeZGBGNrabEhRD/KzR1Bro5YW5AnhNbWwhwzAoOwTUr3PTIadoZ/IHbVlAipJnGMdvfAXr1KGurojLbBTtR1tUtmd5ijE3Jbawy+0oJ2HoMGEergjHK9j9Q4/slP39hECxzVUnbaqxOb6Cd1sTSBTY8OD08+uTmj6Zke0P3KE5haWwcQG12jTWA6FcnoJa9/gL1VtZga5A+zAROJ2ZgY6CtBv5/uToGXoz3uWjQHf373B/l/z16+CF9uS8HunFIEeTjjxWvPESLKDs0ZccG4Z8V8XPvEZ7Ljiwn2xKt/WY4XP/4Z325OEyL6yM2LMCkmALc/vhLpuZWiEjz2l3OkPM/cUHpECc6Ov+uWM6Qc9spbm7DyOyWDlErVPXcskqB6lmFff3MTflx12OAtvPyyGTh3caKQVB6INv6Ujg/f2yYNOQbf6BnxWHLeRAQGuRu2BxXCXdtysHldGvbsyBuiGJLojZ8UjAkTgzEuKVDUz9GIp8x4b2hHeXEdyvXe0ZrKJtRVt4hC2VjXhvbjmKjzS2DHg5az0rzk7GoPZzd7WbtyIpSnA9y9HOHh7QibYV3wo70PKpolhXUoKaxFcYGysBzPLv2RQP9pWKQXwqO8ZYmI8ZHXMhpBzcmuQk5WBbIyuVTKYICj35OVkFKS02hmvcb6jujblZJ8DokpCWoFMrMqJUlgOPj5039K9TQq0kfWnJg1/POUxqbiOn0nv9J0xeamkVRxyS/1dkZosLt8L0P0azZPjeR3pDrLkaclbGxihis9pGxwqhy7wYnP46b3jZKY0jPqRf+ouwM86Bt1dxjiUR0OEijxi+o9pOIZZcyTfk3ljSd7XDe1dPx6U5fMTIXEq8qglbFPVPyh+rWlqiyyFG5uKIVL456FUelcLa/ry/BqiZ2LmX5RLxtuM1Wvmxguq7eP5UkdCwa/qpBmfSSUNFvxsl7xVfNT9WtRiI2UYrWpS1WV22SAgHL5lxyNSP4Z7aUujPyir9jbTQdvN0e5jfFdnPRVVtMsubfFXKoaZQLYaESVwxE4nCQy0APRgZ4y8pYENb2oSsY7Hy6olMldQz53U1PEBXthclSAkFPGM+3OLsG2zCIJ3zcGvaHzEkLh5+4kyurawzmoNSKmvi4OODsxSjymG7MKsD23yLB9OGHpnKRomJiZYuWhdIO31NbSAueOi5ahIStT0g3NUjGe7pgc6o/VObmG8n2YqwsSA3zwQ2422nqU/dv80BCJdEqtUQSMKDc3mYq1u0qJAwx3doWFlQkyGhQRJNHDG3ltdZJVyi76ICcHZDYrxDPe1RNZLUrjEzNJK7vqJfLJXyY1NYovV7msEFJ/O3s09DTCwsREuvE7+zvhZmWNLj0hPdNxEc6PvFAjo79TnJJkNPTux2BtZ4fb50zDU2u3yhnrI4sX4K7P1sr96BN9/KuNcsZ6QXICPHX2+NeqHXLG/v5tF+LJTzbhUH4Fgr1c8Pqfl+P2l75FemGVlH/evvsifLxqP97/Ya80YDz8x7MwOTYQtz36JbIKquWM/7m7liEs0A0PP78Km/Xh9tesmI4rzp8qM8/ve/QbQ1zTRcsm4drLZwnR3LU7H88+v1qmGxFnnZGAa6+ZI3me/Bh378zDm69tQlGh4iGiT/O85ZNwztKJQ8gMydWqrw9g45oU8VuqYHl6xpwoTJ0Zgeg4PznLHw6qlyUFdchJL0deVgUKc6pQlFeD1uMIu+cBkIomCaStnRWsrC0U1ZMzvM2VA6V40FTPaK9elWE5s6tXmd7EA1gbVdUTy4N0dLaFp48zvP1d5H1y8aVPNMhtVHVTBbdtdWUzCvOqUZBbLUpzfnYVKkcpdXt6OyIi2geRsb6IivVBeJSPqLojPS4tBEwzYENZVkY5crIrRyR/VDej43wRE+snBJUd/cMJhTxebYuingpBrUR2TpV4ikfznxo3SPF7NBwkZ8xSVYP6meTA9WgTpUi+ggJdEczpVGxuCnRDUICr+FNHOplhSbamrkXxjFY2CTmtqNL7RquaRgzyHw4qZh5uCjllwxOfi15Rd46mdbaThermsVR8bj+SJTYvileUsU70i0rMU7dYEIQ46ZcOEihm3up9kCzR/9qZm78VuCmMCaoxgTUQXjMjAmzsSTWKiyKhFl+pNF/pp6WpTVkk4VKuN+qut1Y66230zV/Glgg2n9HuQI9ui3h39aX6lg4hffQpS05sS6eU53lycbxWDXdnO/i4K9O+Aryc4O+pjKf1dtdJ9F5hRT0KWKIvq0NuWR1Ka0Zu3KMaGx/ihbgQbySEesv3Kr2oGgfzyrE3p1SmhhmDNoQpUf6YFhskx4eU4ipsTs1HSnHlkMdnA9TpEyLF48oy/rrDuYYcUm6eaZFBmBcXivLmFny9Px31+o5/Ni+dPT4KAR4u+C41EznV+ql85mZYMj5GTna+PHSElE4M8EWMrwdWpmcYGp1mBgeIyr8qVzkWOVhaYn5YKNYX5cvoUAoqC0JDsbOqREr5jH2iSrq1slC8pJ529nC2sUJWE487g0gyKtuThNb3tKCjvweeNnboRTfa+rrgbmWLXnSia6AX3jbsqG+UMaL++rn2rCs4W5mjo78DrpbW6B5sRm9bLz6a95FWpv+d4pQlo9fNmY7vD2VK9/zNc6Zi1f4sKc+fPzke3Z29+GF/FoLcnXHfsvm44ZWv5Oz5kUtOR15pnUQ40efzwZ0r8OZ3u7F6V6Z0fr5zzwrsTinGM+9vlOe759qFmD85Arc98iXS8yql1PTSvedLhM3dT3yLfYeLZSd/z5/OxIKZ0cjMrsTdD62UAz13clRDkyeHimL179c24dvvFaWUM9PvuP1MJMT7y3VOQ3rlpXXYv69QrjNn8sKLk3Hu0okGEsSD/q6tOfj60104vL/YsE3YyDPv9DjMPT1OStDDD9hUWvMyKnBobwFS9xch43ApOkYMZTeBJwPkA1zg5essl908HeHmoZPOdjYx2Tsw0/HXKXEwDopEulUfdk9ltpmz6OkV5VLTIipnbWXzMVVZElX/YHcEhLgjkB7RMC6e8prHAh+XjV05mZXIo+KZWSGNXcNB0kjfKQl+dLwvouP9pGFqJHJE8s2ThYyMcmRlVCAjvdygcA9XT0lKY+P8EEPSG+N7VPe+bKf+AUkEoHKalV0la3bwjxQxxaY3lZgyeYFq6vCGKxX8jpKYFhTVyMjT/MIaGQQwmsrJEjZJKUfJBtKTq29u8vJyMgTUj6i4i2+0BZXV9I02y4Ssqtpm8Y8y2orq2/GAhMnFmeVdxTdKvyj9seIXpW/U0QaOjHbSWcuar/eXeJ5JRjsZ5cSTp269Oqhfd6uTlYYtSkneKIReLcUbdb3ze8HPTCmrK+V3Kcfry+2MRlOv84SRa14/1hCBkw2esHNbc5oco7OYHsKFJXruA1mi5+chpXqDz5cRXDbyuyJ5ZYmeFg2xaXBUrN66wWxaZtbyZGE0SCqEuyOCfZRxt6F+bggLcJMmKKqnWcU1yCquRkZRNfLL647anvxexQZ7ITHCD0lRfjKv/nBhJXZnlWBPVomQaWPEBXlh7vhQjA/zRW5lHdYfysW+vDKD15PbY0pkAM5MjJQg/R/2Z2J3nlIKV7NMl02Nh5POWkhpenmN4X3MjwlFUogffkzPweGySgMpXZYYi0ETE3x5KM0wKnRhdLjYTr5Oz5D+CJbWz4mLQmptFTL1flI2L1F1ZjlfjX3icW6PXiUd7+mF2p42lLe3SA7pFB8/7KhW7hvp7Iqanma09HbDzdoG1hYmqO5qlcYpksya7lZRUm0tgJbeDqW7frAV/YP98LPVobG3QbJIXaws0NHfLgH6Cx1mY1nEeVoD0+8UpyQZTX78RZwRH4eP9xxGkKszzowMw+ub94pR/M4zZ+OOD1bJTuH1G5bhkU9/Qkldk+wcFiVG4dZXvpXHeuaGxeJPe+bjTXLm+K+/LJMJQXc8963sWG48f7rMmf/LE19jf1qJKKL/vO8Ciaj52yMrcTijTNSBx+5agokJgdiyIwcPP/WDqIBUkx677zzplC8ta8CDD30tDSzEeUsn4rprZovqwLL6h+9vxWcf75IDD9WJ85ZPxopLpxlyQOkd3bAmFZ++t81AlJjhOW1WJM5ckojEySFH+Qnp69y7LRe7tmRj/448uW4MKpoRsT4Ii/JBSKQXgiO8pIzP2/8bwddfzTxRRk+VNaCyrFE8ouXF9dLYNBpc3HUIifBESKTikeX79fZ3HpNQU7UlKWUDWDZL8Wnl0kQ1HKoHN2acP2IT/BEZ4zPq9pMpWBnlyEgvQ2Z6hUzEGu5t5cGI2acxcX5CUGPj/aS5aSRCxe9YXl61UYNUlfhFRwKbl4SYMhWAHfdjEFQSoHKOFi2qlYSAQk6pYuxXReOoYfA8GWO539/PBf6+zvDnJCwf+kadj+rsHw7uulpau5S80Told7S2TvGMMpe1Tu8dpbJ5ouBvQjyjOhshR7xMsk/CxJxbqnpMhVC9ovwt00PLgzdtEWrzDpW/X+If/bXAbUQCNYSg6kmq3Kb3jCq3Hbms3i4e1AGVEB8hxhIbRbKs97OK11XfjKWSbLVBiyfTKjEnUaf6zPX/58jDfa6zfrCBq1qipyruwjQFJfaL42OpzFJh5RCFUk7+0i8cT8ss3NHivUgyQ3xdERnkgaggT8SEeEoWbn55PVLzK5GSX4GUvArJOh3+/6iYTo0NwpSYACF6OzKLsS2tEBnFQzOcQ71dcVpShJT0sypqsHp/Fg4VKiRS9Y+elRSF6TFB4i/l5L/GdmVfTGWaJfykMD+sScvBz1mKEEHMjAjCjKgg/JCejUOlyuPZW1niwokJqGpvxY9p2aJaWpubY9mEWOQ0NmBXSakho5TxUl9nZqCzr0/I7KKICGwoLpBZ9lRFqZJuLC0Q7yhjoSLcXbCrWvn/bGbKbq5Be18P3G1sYWdthtL2JmlmCnRwQGFbnZThAxx00thkZWoqc+7re1rhbGmFQZNO9Az0wtdWhyYDIaVC2gmfQXe8NONhjYz+TnFKktEX1mzEG7tSZEfx2LkL8fDXG0SRePz8M/DPVdslBPmK2UkY6BvARz8fhKeTPd68aTmufvZz6ea8aM54nDUpSnyi3GHfftEcKcNc/cDHcqbOjvk7r1qAB15ehQ07s+UA9dK9F8gM778+rBBRnpU+c98yxEb64LtVh/D8K+tFvZw6KQT3/32xTPrZviMXjz/5vUQHsax6598XY9LEYHkvVMyeeuw7lJUqqtnUaWG46ZaF8PF1lut8LHpB3399MyrKlHIyCeqipYlYfP4keHg6Dtk2LHvv2JiJzWtScWBnvhxwVLCsnjAxCOMmBSM2MVAU1BNpHJLyZ3s3muvbJIOUamZHWxc62nvQ3dkjpLqvt0+Is7FCQJuAOX10lmawYmlPbWBi85KDDXSOtuIXtR4WGXQi4PsuLapDaUEtShjblF+D4rxqIawjwdbeCmH0h8b4Shk+Is5XVOCxSBPJaGZauURjZaWWSUPT8I5+kp/waG/EkZyOC0Dc+AAJ8h8J3E4FBTXISCtDelqZfBeY7zoczi52oprGxvkjLt5PGq6MUxOM0dbehZycKiGmOblV0ng1WmYpSa5KTNVJUsPjwIxBhY+EtLC4Thmnyqam0gaZBDXW+Fb6LH30DU3ebGjimk1NXo7iGzUeWzsWSIjoGaWay0aqxmZ13SElYHpGZWF5vrVrxNzX/w9InKR8LR5R/RQjyyORTcYxSsqgB33ZfEgck1JG54kQH8/Y+3lkUa7z7/w+qvdlZBp/T7xNItTkb4qPVL2sLupjKs+lek31a/MjZXyzESKmVJvN8e4TSE5VzyjtDqr9wdgewXK9+Hrp6WVnfXOnlPGPFySs3u4OIgJwoIJMAGOZ3ttZFFeW/QvL61FY3oCCsjop0+eX1sl+fDj4HklO48O8ER/ug3HhPlL+PpBThgPZZdiXVSqDF4b7TqfFB2PmuBCE+blJY9OmQ3nYm106xJ8c5e+Bs6ZEi890W2Yhvt+bOcRjym78ZcnxMvbzsx0pSC89QmznxIRg4YRwbMstxqrD2YZ96KzIIEyPCsZXB9OQWaWIGV4O9rhgYrxMH9xXUm4Izz8zPlJK9+zmJ86MikBtdxv2lJcbVFJ+Z3eWK6Rzso8v6vs6kNekDGuZGxQsZXtOigpycEK/6QBK25pgbWaOcFdnZDRVSed9nKsHslqq9HmkLihsr4W5iQl87G1R09UMBwsLmJn2oHugxxCOT0LqbGUG224rvDb7SY2M/k5xSpLR6978BFtKKjE7PBhWg6bYkJEvUzBiPNzxzub98HF2wMMXLsT1//pSzt7/dcMSfL01TXYi7LR89ZbzcPVjn6K8rhnzk8Jx75ULcc2Dn6CoogHjI33xzzuX460vd+L9r3fLQeTZO8/D+Gg//P2xryVDlET0uQeWIzrcG5+t3INX3twsr2/xmeNw202nyQHkk0934c23f5bb4+P9cN89S+Dqai9E5IP3tuLjD7YL4eRtN992unTHq0g5UIR/v7AeeVnKWTFJzfJLkrF4+UTxahojO7UMq1buw5a1aUOadFiyTp4ThSmzIqWD/ljkk2XzytIGlOTXoKywDhXFddLIVFvRhPraFrE+/FawsrGAk4u9KJkuHg5wY+MSw+19nODJUaW+ztA52Z5Q2ZVTogpzq1GYUy3bMT+rUq4z83Q4nFzsZBtFxfsjZrw/ImJ9x2yYUnNbM1JKkX64FOkppTKtajgYLUVSGj8hEPETAo46gTAGR5ymp5UrBDW9DLnZlaJkGYOEh7mn9J1SOSVRddVP4hoJJGgkqJIIQIKaW4Xq6pEjqzj5KzTUQ1lClIV2kuGq+1F+0doWIaUlZSSnjaKsMiWgqqZ5zBxbglFMXhxq4OEgjUwe7jq4u+nX9Iu62P0iVZJldSqu4l3Ur8Uv2k7SpCxsvqEXl5fVOCdm4aolehLgY73+3xv482ITlowWFf8oPaX6pi02cKmxT3oVWfyjemWZZXpbNeZJSvQs1ytTsIYPqOCJssQ7NXWgXsrz7ajTT+GqZTd9nVKmp6d3LPCxOaI2yNcFIf5usnC6GG0AVFJzimuRVVSNzEJlITEeDnpQE6P8kBTtj8RoPyGnezJKZDT0vswSifkzJrOTowMwLykciZF+OJhfjnX7crA7q9hQ/ue+PzkmCOdMi4W1tTm+3ZWOjSn5hulOzCc9f3q8dNt/szcdG9PyDArz5DB/LJ0Shx35xfj+YKaBlJ6VEIm4QC+8t+uAYexogq8X5kWH4KP9h1HTqhDQ+REhov5/nZ5p6Lo/LToMX2akiUrK3NEzIsLxbW6mlPs9bO0Q4+2OTaWKKjvR2wfFHY0yEYpB+EHOjkhpUEhokpcPDjawvD+IBFdPZEpjEzvtXVHQXiPRT4E6Haq6GqGzsIC5npD62dqjsVeJgLrWewnOCZ+vkdHfKU5JMhr298dgYW2DRxefhn98uU52AC9feg5ue+d7OVt9/sqz8dqqXcipqMPiSdGYGRmMu95eJcTywzsvxkdr9+PHHRnwcXPAR/ddiqfe24B1O7PFJP/ew5dif2qJqKLEvTedgdNnxuDhF37ET1uzpGz33APny3jPj7/YjdfeUQjnJedPwXVXzpID2AsvrTV0y597TiL+eON8OagytP6RB79BWopydrpgYRz+eOtC6HQ2BkLy+gvrsWldmlwn8bzw8mlYcuGUIQ00fb392LIuDd98vEsakVSwuWfemQmYfUa8kNHRwK8MlcTMg8VCZvMyylGUMzJRMwZVTfowOcKT6qaNnZWomoxtkuB78yNdvtwOJN79agNTJxuYlEgolsLbWzplxCjfy/GAz+cT4AqfQFf4BrnBP8QDgWEecpnPfzzgc7HLPjejQrZbdlqZEFS+TmOwk5Xl/ZhxAYidEIDY8YFCkMfanlUVTUJK0w6VyMKO/uHg9Kh4ktPEQCRMCJAmrNEINpVXksj0VL16mlZmmMplDC8vR+nWZ3mf5DQ0zHNMAsfgf+aU5uYqeaXsuC8raxix5EoVMIhNTOy0D3ZHkL7r3sXlyDz6sQh7NQPwK5tQUak0N9E3WkXvaFXTqKNLh4MVBRJlTigzXugXVdfiF3Ww+VXL6fxMpeNcny1Kcsr3JB5RKWfrI5vUKUfSrDc0YonfK9UPyjV/E7wPy+viER3gZaXcrpTdB/VlefX2I7eRmMh1ekoHeRsM/1d+a+pl/n/xnSr3Vy8P9aXqo6GGfe9/K5C00tsrObCMeKJv1PGI/5cnHVKid9UZBiuo0V9qRm1FjTJYgQsngZGwjgbm0IYHeSAiyAORIZ6IDvWCp6u9dOOn5VUiNbcSh3PKkV9Wd9T3PtjXFZPjAjA1Pgjx4d7ILKrB1pQCbD2cL538KniSNjnaHwsnRWFChK+U8n/cnSld+saq6jnJsZg7IRQ7s0vw+bYUiRYkSPgXT47BgnFhWHs4F9/tU7yfKildPjUeG7LysTol2xCUf1FygjQqvbNjv5Bm/gQ5bZAnCp/uT5Fxohw/etHEBKzKyUVxk1Jt4RCYwtZGpFQrauxpoaHIa65HQVOjeEVJUNeV5AlBDXB0ktJ8ZmOt/I0K6s7qEiGeEz19cLBRIaTxLp7Iaq08KvopWOeASiGkHLfbJSV7f1sdGnobgI5+rDrzFY2M/k5xypLR86cmoYD+n7IqXDglAbX1bdicUYCZ0cGYFhaAp7/+GY621vjgzxfh6qc/k9DlP5ydLOH3d/zrOyl7vXHnhRJV88gbCqF99Z4LYGdliev+8bEcdC49dxJuuniWjPb84KvdsgN68p6lmDIhGF99tx8v/XuDvK6rLp2OKy+eLgephx/9VsrzJGV/vHEBli5JkvukHCrBQ/evlCggetX+/NezMHd+rPyNH+Ga7w7h9RfXCVHjTmbR0iRcfsOcITFDPd29WPvNQXzx7jaJXiKoOsxcGIczz0tCXGLgqCShurwR+7bm4ODOPKTuLUTLCN3UVCgDqIiFuAvx8/JzEXWSRMzF3UHI6K8Jvm+quU31bbI01rairroZdVUt8v5qK5vkdbOpaTTIxKBANwQyPzTCCyHMUI32gbu343EpqdymVE5JyjNTuJSO6EOlOhs3IVBsDuMmBgnxH+vx6ROlapp2qBgpB0qQl1N51HQpTriiYpowIRAJSUESzD9W/FYlCa++tE+SWlRYc9TBlAcmCeVnpFQMu/d94OY+dqYfFUJ6mklMOZmKeaiFRbWiFI4ENtiRpAYGuklKgDQ1seN+2LjTscASLokpldXq2lZpbGJXfm2t4hulX/REyZI0zuhs5PWxkYkNNPTHqn5RWfSz6cUnKhmjFpLXKzFO1pa/ODLpfxH8Tg33kdJDqsY+9RiH+uvVYhkAoB8EQOVSWXol95alcUWBphqtKNAnenTi5yKRXzI61lEizGScrKejZNeqE8v4/BxLW1zegMKyehnawPI8UxxGek6S39gwL8SG+yA+wgcxYV7yvg/nVuBAZin2Z5Yhu6h6yP9lukBSTABmTgjB9PHBEnS/6UAeNuzLkY594/vNGh+KRckx8HZ3xI+7M/D9rgyDH5XHmpnxwVg+M0FGgH7w80GkFVcZ/rZwQgTOnRKLjen5WLk7zRC8z/L9oolR+GJvKnblKwKGq70trpqVhPTqWvyQqgxecbWzxeXJE7AmKxcZVUpD1IyQQHg42+OL1HS5HuzshIlBvvg8PU38pmEuLvB3ccTGogL5+8yAAOS01qOqvU0U1HgvD+m+J6b7BmB7tTLVaby7FzJaKoT4xri4I6+1SrroRyKkjhaWgEknegf7JPZpglUI/pJ4pUZGf6c4Jclo9F1P4IElZ+LBrzfAxtICTyw/XTJFmRH39k3Lcctr38p4unsvnI/Mgmp8vT1NZhe/dutyXPzAB7KTuOLMSThvVjwuufsDMeffdMEMLJ8/Dlff/ZHM354yLgjP3LkUG7Zm4eEXFJX07lvOwJnz4rB+UzoeefpHue2Ki6fh6ktniMn/3vtXYt/+QiGI995zLmZMj5D7rP7hEF54drWoEqFhHrjvoWUyapJgefe5R7/Dnu15cp1Zl7fdfbasVVBdXPfdIXz02ibJ/lRLy+esmIKzlk2Sy8PBr0VhdhW2rU3Fzg0ZKDIKzifYbBPO7vDxAQiP9RUS5x3g8qt1y/+aoC+0mk1LxbQP1KOssFbxiOZXo80o2soYjHsKi/WV98YlIsFfMkuPBySjGYdLkHGoFGkHiyX+anjJlikG8UlBsiRMCpKYqbGIGD23GallSD1YjNQDxcjOqDhqZCg9ogmJgXrlNFCmY431mO3t3ZJ3mplO5bRcmqTUcbLGIEkkOY2SUH4fRER4jxhVZQy+3wo2MxXWCjEtZOd9Ya3cNlr5muVbf38X+Pu5ws9PaWry9XWBn6/zqE1TYz1/M0u5De0Sl8ZyrnhGG9tFIaaHlOum5k6Jcvq1SupUg1n9EH+orJUyNUvWkiOqjti0GOYNHe4L1fs0jb2gXPh58iMVD6h6nU+sv52Xh3zmJkOvq5fktiF3Ux5f7i+XlVvlOXnJyE+qvibFt6p4u9V4KOV9HXmPSrle8cqOlpowGviZkJjSx8vPiNFOEvPEiKfGdvH8csiCNKs1th2XWs4TDE794sIJYIG+LjK2lg1zfH20W3CiWG5xLbILq5FdUI28krqjGvD4fqNCPDEhxg+JMQFIiPIRcrovoxS7U4uxK7VIrALGiA31wtyJ4Zg3OVzI2Lo92VizOwtFlUfSMtiNf/b0GJw9LRb5VfX4ckuKdOaroE3s0nkTpDnr/U0HsDXjSOPSaePDsWxavOSVsoRPtZvfkyWTYjAx3B+vbd6NwlrFC5/g74XzJsfhnZ0HUFCnPP+s8CBE+bjj7V0HhNA62Vjj4snj8HlqGqrb2hV1dUI8VuVlo7ajA7bm5lgUHYmV2YoqG+HiCktrM6TWVcNU7yPdUK5MDpzs5YuDDeXiKY11dUdBey16BvoR5eyGwrYayRxVCSm/bwE6e1R3NUkXvTLDfgCLnSfhjqQVGhn9neKUJKN//fhr5Na0IqeqDtfPmSwRHCklVbhw2jiYDgCfbTuMKD8P/GPZXFz5zGdytvvWXy7Aj9vS8c3WNAR5u+CDey/BbU+vxKHsckyI9MW/7j4fj7yyBmu3Zkro8rtPXibRMzfe9YkoBJcum4IbLp2JA4eKcce9X8jObfm5Sbj5+nlCKu6590vsP1AkB+RHH16OCeMDhRC+8+bP4g8l5syLwR13nm1o3Ni3Kx9P3v+1NAWxyefKP8zFeRdNHZIPemBXPl57ejWK9ZOaSIIuuHomTl+SOGL3NpXFjd8dxE/fHkSp/v+opWcSz6Tp4Rg3NVQImsUYYeP/C5CRk7WtKMqtEptBIcduZlWK73V46Z1gkH7UOH9EjQ8wkPDjKfEzAoqKadr+YiGnVFGHE0l+LuMmB2PcpBCMnxwMD2+nMR+TuatZ6eVIOUDltBgZqaUyyWp4ZJWopiSoEwIlXmos5Y4H/7LSeiGlmens3i+XzNrhRI2PweEJkVHeiIz2FiWVnfyjNUcZg7+FEn2XPaOgitnUxGSDMTruCebk+vjoG5mYF8smJlmcJFd0uK/wRMDnpSJH8trSohAf+gPb6BeVvNEjXlESeMkW1eeMcqHqd+rsRX85SFyZAsL9l+ohtVGVZdU3akv1WT/dyt5KmX6lV6uVEr3NUeNuVfCzqNUnK7AMT98x98EV1c2yUC0fDWwmC2S0U5A7woM9DAtVcCq6OUU1MrAkLacCKdkVQn6NQSIbF+GDyQmBIkSwxM8egm2HCrDlQD7S84fmikYHe+L05CgsmBqBuuYOrNqZgdW7soaE6E+NDcTyuePg7+mEL7akiFqq5qp6Otvj0vlJiA/xxvub90tEFMFzDHbgnzMlFp/vTMH6lFzDlKlr5k2CmYUpXtu0RzJMSVRXTB0HWztLvLV9n8SIsUx/7cyJWJ15RCU9Oy4SzX092FygEF/OtG/u78K+igq5viQ6SubZN3R2wtXGBrHeHob59vODg7G5okDI9zh3L+S21qKjrxcRzq4o72qQjvxIJzcUtQ8lpDyCsamprrsFnta2aO1vQn97D7ad+7KWM/o7xSlJRt/asB3Prt8tcRf3nzMPf/9oDWwszfH6defh6pe/kDPKN/64DK98uwMpBZVYNCUay2ck4JrHP5XHefPOC5FbVINn3t8kYc4fP3a57Kjuf+lH2eG+8sCFCPZzwzV/eV92glOTgvHk3efJAfcPt3+AtrZuzJsVhXv/tlgI0f0PrsSOnXmyk37isQskP5QHyBefW41V3x+S57zsyhm4/KpZomiQHHz01hZ8+ObPsoMLCfPEnQ8vFbKhgjmb/356NbauV8os9GmuuHY2zr5g0lEEiq/h0K58fP/RTuzelGkgHySbk2ZFYvppsZg0O0oe40TAEnZVaQOqyxqkkamuqklK6c0NbWht6hDfJzNLpaO+pw99PX3yvvmeJJSbagtDtfUB2tZ2lrBl6dTBBvZOtuI/dXSxh7O+ccnVyxFuXo5wcD62J/FYr5tqZl56BfLSy5GTVibKMP12xqDPNSLeD3FJQYibGIyYCYHiTT0WhEimliJlbxFS9hciK+Vocko/6PgpIZgwJVRSDI4VzM/txxipFL1yyuao4Z3qjJMiMVWX4DDPY5aVaYOQEH3mnmYqcVUshQ8HyWBwiDvCI7wRHuklBJXB/MdDUAmWeSsqmlDKTnuOZy1Xuu0ryptE+RoL/KhdXXXSyCTNS/pmJjeG37vppMmP/tDjfS0nCv5+uK3VEjQv9+gnEMlllq71nlHJEtUPc+Bl+jvFG2qcH0rvZv8RD+dR/k/9Wln0E3QNl5XfruzV9bt24x28urs37PX5//TXj/xNeQ5Cngv0mupfw6CRz9QoBkpiofTZp+r7VEeT/iYeUidbODsd8QBzSpebm70y+MBNJ2sSW2Pw8ymrbEJphdIsxxI9kx24jJZX6+ftjOhwL8REeCOW3+1gD9kvVda24FBmGQ6kl+JARqnk3g4v6yePD8aMpFBMHhcoiuvP+/KxaV8u9meUDkkNmRgbgLNnxmDa+GBpfvpma6o0QKmfEXsTLpg3AfOTwrD2QA4+3ngQdc2KTcrZ3gaXnzYRiRG+eGfDPmxIyTOQ4xUzxyM5OhD/WrsTqSVKWZ/Z2TeePhUbxU+qhNz7OjvghnlT8OmBFKSWKxWwBdGh8HVxxHu7D8j3I9jFGfNiQvH2vgOigrJsPyHQB19mKMeXaQH+qO1qR05DvcRBcZLTj4XK488MCJSxoSSeLM2XdTZJ/miYowuqeprQ2d9rIKFSsnd2RUFbDSwk9skCjT3t8LfT4VLPaTgvcs5JJaM70r1h/yuPA21rHcC02EptHOipSEaXPPU6chraRBXdnlGEzLIaXD13oswzXnMgGzNjgnHuxBj8/c0fpftz5f1X4I5/ficByOfMiMUfzp2GC//+nuxg/nrFPMxJCsMlf3lPum6vXjYV15w/DQ88+wM2bs+Gt4cD3nr2cjno/+G2D6RrOC7aF889fqGcjT9LwrkmRQ6Ujz96viii3IE//fj3+Gldmvy/W/9yJhYtnmDw5z11/zfYvlnx+9AbeuPtp0tJkODHuf7bg3jtmTWiyFHRXHzBZFx641whI8Zg+f7n1Sn44s0tKMpRdlZEbFIQTluahBkL446LXMmEorIG5KaUIj+jHIVZlSjOqUJNOaeY/Oe/XlY2lvD0c4aXvyt8gtzgG+QO32B3+IV6CFn9JUSVk59y08uRdbgEmYdKkHGwWEL2jcHPin7T+MkhGDclRAjq8PSCER+7s0eGCRzeU4DD+wqRk14xhPjy9YZFe2PC1FAkTg1FzPiAYxIrkoGcDEU5Pawnp8OzSRn1xW59IacTAhEa4TXi1K3hqKtrFVLKyVHZmZXScd86LIuW4EE7KNgNYeFe0hjFkybaTNSGu+MFv/Ms75dXKM1MlfQC6xuZ2N1/vFFMVNdIXGhnIJFhc5OTk50QGwcHazg6cK2ocFxGU+A0HD8Usqo0bpGYq7mjMgyA6QOdTB9gMoHiIaXyLBFPbXrvaFs3WqlU60v1J+IDpqrq5ekAb0/GgjlKTJifr5Jn6+aqG9IsSRU1r7gWeYU1yCuqRW5BzVEEk6DlguR0XIwfJsQFIC6SkUfmKK9uxt7UYuw+XIR9aSVDOvm5n588LghzJ4dj5qQwGaG6cU8u1u3MQkquoi4STFk5Y1oUls5LEGFi5eYUfLs1zRCcb2dtiaWz4rF8bgJ2Z5fivXX7UFbXbCClV58xGbHBnnhl9U4ZXU2w7+HGM6eKn/mlVdtQ16r4UM+cEInZcSF4Ye12VDQp75MDX5wdbPHGtr1CODly9KppiXhr937puGcu6VXTkvBFWjqq29pgZ2mJCybE4YOUQ9K8FO7qAledLXaWlUqpfXF0FL4vyBLiPcXHF+nN1Wjr7UG4EwPxW9Hc0zWEkMY4uyG3rXpIl72tuQVszAfQ3t+NZLtgvDTreo2M/k5xSpLRyD8/Bjt7ezy89DT8/cPV4ht99ZoluOafX8jZ6Md/WYF73lqNkpomXL9oKnycdHjonXUy2m3lY1fhmfc2YsOeHMmbe/3ei3DPc9/h5715iAz2wBuPXIz1WzLx2Mtr5GD8ymMrZOd136PfSrA9z9pff/FyOSh++NEOvP3uFtkpPnj/UkyfFiE7RhLR9WtT5f/fde+5Up4nGuvb8I8/f4LcrEpRom69axEWnj3e8P6aG9vx/IPfYpeeqDJi6Lb7zpVgemNQ2dj842F89M8NqChRws7ZXHTakkScfXEyAowU1pHAr0xJXjUObc9Fyq48ZOwrlAaikWBjb6U0Mvm6iHLJ+CVHV3s4ONnBzsEGtjor2VFaWisd9STP3B7SFax20/PAxSgdlkbbutDOyUtNHWhpPNK4VF/dgobq5lFfh/HrCQjzRDBLy9E+CInxRUi0jyiuJwK+PvpP0w8UIW1/EdL3FRm2pQq+F+aQTkgOw/jkMCntH4+1ob21Cyn7i3BodwEO7s6X/FNj0F7BZrPE5FAkJYcjMHRsbyhBQpCbWYlD+4tEOWXnvnGUl2wbW0sJ4Fe79cOjfY5LTZQ0gMpmGWXKDFXptB+FoBLuHg4ICfWQ0j7VVK79/F1+kXLJ525s6hByWstmphp9ExOb2epaRVXl+NzhyvPxgL8xlmmZs6s0LyllZDYQHmlaUhdLieKxtLRQIo2sLI54JvU+Si5mRrPlh+R56jM6VYKk+kPHet/qnnuISmqknBqrmkffDsPYXXXNG+VxVAV1tCOD3odqov+OK+sjuabqiFHJIrU4sfzRscDXRIsEp3KJ75d+UfqADUMO2qWhjaV6ktmxQIuAv58zAv1dpZkuhEuwh0SFqa+V/tTsvGpk5FYig8kUOZVHDVCQCUyR3pg0LgiTxgciMtRLVOLDWeXYfqAAW/flSXXM+P5Txgdh4fQozJwYKrFUq7ZlyFJZZ5QrGuGD8xeMx7RxwVi/Nxsfrz+AQr23lI9BX+nlp0/EoYIKvLFqt4GUers44A+Lp8JJZ4vnv9sqvlMiwscNty6egW05Rfhk22H5vElUb1s0HVnVdfhkl5LewqakG+ZPwWvb9qKovlGUWxLSrNo6bCtQpistHReDotYm7CurkM/+kqQErMrPRV1HBzxsbZHo74PV+Yo94KyIcKwvyRd/6ARPbxS01wsJ5Yz72u5WNPV0Scm+rLMB3QN9iHPxQLa+yz7cyRnF7XVwtrRBHzow0NGDXec9pZXpf6c4ZcnopbOnSMDx/oJyCbivbmjFuoM5YgKfHh6Ihz/6Sc42P//HZbj0oQ9lfvFtF8yScOI/Pv6l/EgZ48Qz6juf+VZ2uG8/dolk111x67uy07zukhm4fPlUrPz+AF589SdpUnj5qYsRE+WDLVuz8cBDX8vruvVPC3Hu4kTZ2f7zhbX49uv9snO/94HzDPmhnB50580fypq5oQ88c6EQBxXpB4vx+N+/kIB1HgAuv2kezrt8+lE5j4d35+P1J39EQaYSIcLy75IrZuDsFVPHLMMz1ojEc8e6VOzdmImaiqGh8CSSJHehMb6yBEZ4wS/EA05uY0/R+bVB4lpX2YjKkgZUldajoqgOFUW14n+tLKk/qtRO8PVRQQ1P8JdGpajxgQg9Tj/ocL8tkwZSdhfg0O58sSgYg4Q/fmIwEqeHY+LMCImVOp5tw/GmJKUHd+WLB7hxWCYpu+qpmiZNCxPl9FhjTAkSfWaRsiEqhV7WwyWSxGAMqu2cDBXHEP4JAYiJ95cxpMcDfpdralqQR7tDbjXy85SlepQgfX7fqVoFsMM+yFVZB7rB39/1mM1Sx/NaqKyRtDQ2tKNRH4BPQiOjZDlSVt/IxOgqNnH9N2WEGn9F/lf31kOamdTQf71vlMTdxuaId9RW7xnlCQB9o/bGvlFHW1mPlV9L0NNbxdGx9ItWKSq6ZNhWNMr10ewDPPkIC/FAeKgnIsO9EB3hJVPIVHtUSXkDUjLLcSi9VBamsBiD3fqTxwdh2sRQTE0MlhOY/JI6bN6Ti027cqRz37jzf/7UCJw1JxZx4T7YyxL9plRs2Z9nyB3lZKnzTxuPc+fEI62gEu+u3otDuUocH7fB4mkxuPKsyRKm/9oPO1GrL9/zOPXnZTNRUNOIf63ageYOhUSz637RpCg8890WZFUoJ7mzY4IlwvCpVVtR1dwqJxTXzZmMirZWfH0oQ+6THOKPaB8PvL1rv5yjkHD6uzthZZry97OiImQ2fV5Dg4z8PD0yHF9lKSX8hWGh2FJRJFmlCR6eKO1sQmN3JyKcXFHV04KWnm5EubhJAD5n3Se4ekgOqZkJ4KezR2VnE3xsdfhbyALMD0nUGph+pzglyWjU7Y/hpSuX43Z20JuZ4s0bluGal4+oon9//UdU1Lfg9mWz0N87gJe/3ApvVwd8/vDluO6hz5BbUotl88fhTytmYcXt74hZ/vIlk3HDRTNk1OeuA4WIi/TBPx+9CEUl9fjDbe+LT+yW6+dh+ZKJ0rRx0y3vS4nqvCVJuPmPp8nr+/jD7Xj79c1y8LnzH+di/mlxcjtHV/71pvdRV9MKLx8nPP7SJdJ9reL7z/bg30+vEoLhF+SGu5+84Cg1lB7S1x//AVvWpBomCZ1/7Wyce+k0yfscCfxq5BwuwU9f7cOWVYfQYlSWpsIXNykE46aFIW5yKMLj/U6YvP2nwRxUktOinEoUZVWiILNCbAX1IxAkkmsS0pikYMRODEbspBA4udqf0PMxVope3EM782Q9XLVlIH/SDBLTSIyfGjrq5zD8M2Ez2v6deTIpK3V/0ZBpTmpJPyk5TMhpdIK/vJdjgQdnTp8Sz+nBEiGpbIwzBtU6+pJj9SNMufY4QdsDm4IKC2okAood9rzMJqnhRNgYrm728GPHs5+zpEiwgYmXvb2d/99EddSJYZwIxLD7ViXwnuVj3iYLS8vMvGVEkX5hqZnjgDl/vqenX75rhnGZ9IiKh1IpWavZnScLquo6XIWV2/Rd9rLSf67qp3vEZjqyCvufel98WbR60GbByV9c6AvmwsqTu943zMsjkVZ+BpwuVlxaL/vnwuJamQ7G6yPZABjzFR3pg9goHyQwjzfSWwi05C1XNEqu9L5DxdiXUjykPE/xgaX82VPDMXNKmGSikpiu35GFddsyh9gAAnyccc68BCyaEyvTAL/ZlIKVG1PQ0Kz8BtmbsGRuvIyY5rCVN77fJf5SVSldPicBFy9MxOq92Xhn7V60dymvY2FSBK45cwo+3noQK3cq+dMUWf66dDbKm1rw73W7lc55W2v89dzZ2JpXJFOciCmh/pgXH4Zn129FZ28ffBx1uGJaIl7ashNt3T3wdXLAWfGReH3PPlFakwP90GXSj/0VFTLrfmlsND7NUI4384JDsKumBO29vYgXQtoo40WjXdxQ0tEk40Pj3RQSSm0+gZebq2BtZgYHazM09XRgsp0f3pp/g0ZGf6c4JcnoNa98BBedE1YfzMY5E6NhY2aBL7aniFf0tPhwPPjBOgkc/vTuS3HBve+JZ+eBa86A2SDwwL/XiLfnq2euxpdrDuLtL3dKpt0nz12FbXvy8eBzP8jO4Z3nL4ePpxP+8OcPkFdQg+RJIXj8gWXim7rx5veEkI4fF4Cnn7xIdpibNmTg0QcVpZRB9kuXTZLLFWUNuOMP7wkR5USeJ/95mShhBEvYbFIiGSUYVn/bfecMmf7Dj3ftl/vwxlM/SrMQDzyLLpqCS25eMKqC1tXRjY3f7McPH2wX/6cKBxc7TFsYj6kLYjFuWvj/awznfxNIEvPTypCTUorswyXIOlQso0uHwz/MEwlTQ5EwJUzWTmNMLxoOWiPYsX9ge64sqfsKhwT2kzBSNWXD2OQ5UaKaHm+zVdrBEhzYmScElROjjEHPKhugSEy5eOsjwY4Ffm/KSurlsdMk77REVPnhcPPQIZoRX/HKEk4Pnd6/fLzgc3FgQ1FhHYqL6lDCDvviOpSW1I8Y1G8M+j29vJ3g6eUoC5uYaAOQtaeDKGn/SWX+eCE2FD15U9fqHHmWzdX7GHbOalefHmqEk9ykJ5EqgRxOMtUoJmOC+VtCbWwyzLjXN2tJ85Yh9J+eUcU/KrPr9f5RA+HXJxdQpW6TRIMuUa2PVX43Bt83iSkTGDjCluNkGRXG8jzXw8fJ8vWRkObmV0t5Pju3SrJzeVJhDJJMktMJ8f6YwKpBjK+ovXyfqVkV2HWgANv35EuDlPFrmRDnj/kzojAnOUKUX5byf9ycho27sg0NVLR0LJgWhfPPmIBgf1es35WNj1fvR16pkkvKY8viWbG4YvFkVDW24t/f7JAxpISdjSWuOmsyTp8ahbdW78HX21Pla8NOemZkRwd54pEvNqCgSnld8xLCcPHsCXjq280GlXTppFjEBXvhqR9/FgLqrrPDbWdMx6vb9qC4vkmak26dPx2fHDiMksZmaQKmj/S1PXvl/jGe7hJPtbmoUELvL4iPw6eZqUJW5wUHY3dNmfhGx3t4Ib+9Hq293Yh380R2S42U8pM8vXFIH4wf4+KG3NYauFhZoxdd6OvowqELHtfI6O8UpyQZ/eznPXj8hx0yReSNG5bhT69/g+7efrzxx+V44pONKKpqwJ+WzgD6BvHPr7YhwNMZHz9wKVbc+b6Mibvx/BlYNCMaF9z6thjyH7ntbInzuOTmt8XDdPVF03DVhdPw7sfb8c6H26V0884rV8kkmOdeWIMffjwkU2je+PfVclZPf92tN70nO+nlF0zBH25eYCjP3nbtO6iubEJgsDueevVyab5QO7Ifv/ML8YfyAHP1nxZg+ZUzhhxsSLKev+dL7PlZOdONTPDDLQ8slSabEbdPYzu+fXcrvn9/m3gyCRKL6WckYP7SiRg/PfyEZtKPBBKwxtoWNNW1yvPxeTpau9Dd0a3MqO/rNxyMmW0omYXspmcJj749fSc9Z9I7uerk8q99gJWA+JJ6ZB0oQjr9oHsLpCFrOOg1HT89AokzIhA7OeSEyDk9sCl7CrBvWw72bsk+qqRPMjqF41jnRkuX/vGom+p35oBeNT2wK+8odZNd+ioxTTjOBqshI0c5vvRwqTRE5WVXHVXu5IE6NNJLckk5IpVlfl9/118cBk8CUl7WgLLSBlmXlzcKKWZDU0vzyJ5UYzDyjJ32VFepnDkzfUHfxOSkb2BydLKR5j6qbadSaP3/Ivh943eCJym0WzSKZ1SxXdAjbBh6UNc6pk+YuwxPT0fxi3IyWHCQm4yyDfB3HTKJi4/Bpqb0zAqkZ5YjJb1McmuNQavB+AR/TE4KxtRJIZJZSrCkv2VXLn7elYOsvCMniSSU0yeF4oy5sZiSGCxkfP2ObHyz/rBESKkYF+WLFWdPxPTEEOxOK8a73+2RyU8EK3pUSq88ZzLyKxrwz6+2SoMtwSoeLWU+Ho548rNNkgijlu7vvngetmYW4c11e6RJydnOBnefPw8ZFTV4e9NeJZ3F0wV/PnsGnl+3HXnV9ZK//aeFydhdWo4tuUpk09XTEnG4qlrm2/PvN8ychA8OpaCxs1M67elRXZ2bKydNFyXE47PMVIl3IiHdWV0q8U4cH5reXCXl+yROZ2ooF9I6ycsbBxrKYGFqAl+dPco7mhBo74S7w+dhTki8RkZ/pzglyehzX/+Et7emYFygN+ZGh+ClH7Yj2s9DIi/+/Op3sLe2xNcPXomL7nsfja2dePCaM9DT1Ycn3vlJRsV9/ew1eP7dTfh+YyoSIn3w6oMX4dX3t+CTb/bCz9sJ7714pXiVrr7pXYk3ufdvZ2PBnBjs3JUneaLcET79xEVITAySTtEbr3kLVVXNmDwlFA8/cYEopSxb/uX6d1GQVw0fP2c89/pVcHFTysQsEd7/p4+Qsq9IiNrfH1+OGfOVJicVJDpP/OVTNNa1yn2uuG0hlozgISUYsfTVG5vxzTtbZNwm4R3oisWXzcCC5ZOgcxw7VmgkNNS0oCC9DEXZlSjLq0Z5YS2qiuukyejXLOUx+omxTu4+TvDwc5EOeq9AN/GA+oV6SrPUr0FWGUeVtrcAqbvzkUIF0kgxJriN46eEYuKcKEyaEy3d+8f7vPwJlhfVYc/PWdj7c7Y0RBmrpvYO1pg4KxJT58aI1/R4Eg5UNTY/qwr7d+SKasqOfeP8VB50o8f5K+Q0OQyhUV4nNLSASlZuZoWE8WdySStH07CEAYI+0wiG5Ud7IzzKB+HR3mI3+f9+LiyhS2d9VZP8fmq4VLcoTSw1LeIPPRHw5djrbKQsy6QBehX52uldtFEbl/TNS2rjkiHY3kqJIFO9kTx5UBuVJBSegfH6Jh/j8Prh28AQq6SPaZJIJX2ckiio+pGc6khQtexviFjSjxLl98dYmTyyPnK7Eimlj5OScZ96RbPvSGyT4bn0iq0a78TLox06hiqyQxuaeDJrYcHGJiUInwtPGJTsUQtYD/GOWkkGJmfUH0/KgzH4OukRlvGx+gQGekZ5MlNa1jDicAeCnx1H1nKwQ2SEF6KivGVCmLrflMbFqiYcSinFgcPFOHC4RIiwMdgUNSM5HDOnhSMq3Eu2Bf8P01XY3MpQfRWuznY4a14cFi9MgJe7g0QEsuK2YVeO4UQv0MdFpvmdPiNauu/f/HoX9meWGrr7V5yRiEvOmoithwvwysptqNZnoE6OCcAdF88VMvrCyi1o6egWP+iVCydh9vgQPPjpTzLymliWHIe548Jw/+frUdvSDmsLc9y1dA52FZbhx8NKQ+zSpBj5Tby784BcPysuAgOmwOoMJcLp2mkT8V12NipbW+Gj0yEp2AffZin/VyWk/O4sCA3BlopidPf3YbpfAPbUlUgYfrKPP3bWsElqEBM8vZDSWAFHCyuYWwygpbcLC5xC8K/5l2lk9HeKU5KMzv/Hy6ju6MXDFy7Ea6t3oaKhBQ9dvBCrd2ZiT3YpLj8tCX4ujnjigw2S8fb5Q1fgojvfk27H2y6ZgxnjgnHx7e/IDvq1hy6Cm7M9Lvnj20I8n7h7KaZNDMHtd38mOyqeKT/xwDLZ+V193ZtyFn/+8sm48YZ5smN74B9fYvvWHHj7OOGVN64WdYY7oXtv/wT7duaLgvPCW1fD29fZQETvvflDpB0oFlXrwZcukSk+KviY37y/HW8+vVqaddgZf+dzK2TU5XDweVZ/shMfPL/G4AelT/LCmxZg2unxx2wSUMGDVXFWJQ7vyEXa7nxkHSgc0YepggcWlrh1nFPvZCud7FQ9LTijnl3GdK7ru315sKRi2q3OpWcQeVMHWhvbhUQfC1RO2UwVFOWD4GhfhMb5SaMVldb/D6js0gt6cFs2Dm7LkRxVY5DMT54Xg6kL4sRbe7zKJsFILpby92zOElXbePQqHydhcgiS58dg6rxouHk6ntDjHt5TqJT0d+Wjcpgay2Y2NT6Ky/FOnBrSVV/RJHmnDOTPTi+XBiZjT6sKkrywSC+Jk+ISEu6JgGD3/1d4/XBQ1Wqob5Mue67r69rQ2KhvYmIDU6PSld3S3CGlYQ3/vSBJ5b6REVwOjrZiv2Ajp7OzrajdrDS56jNlOQJ5rH0Xv6f83GX4Qkmd4l3mhLCCWhlsMBw8CYmO8kFcnB/i4/wQG+NriP3iYxUU1WL3vkLs3leA1PQyQ/MRwbzbOTMiMW9WNKL0+2BGR63elI71P2fINCmC5yTJSSFYtigRk8YFSqj+l2sO4ev1hyXqivB2d8AVS6fgrNmxOJRTjn9/sR2pecpJsbPOBtcvm4aF06Lw4dp9eH/1PvGeUoW98qxJOGdGHF74eivW788xTHK6/9LTsO5wDt7btF9RRL1ccM/58/D6hj3YmaP4UVdMHwcvNx2eX7NdiGRSkC/mJ4Th6XVbRVmdHOSHcC9XfLhP6ca/ZNI4bCkpRlFjEzzs7JAc6o+vszIVhXRcPD5JTxHryVnh4VhTkquopUHB2FiRP2R0KDNGg5wdUNBaD387R9T2NqGnvQN5l2ll+t8rTkkyGv3Hx+Dk6IhHLlyIP7/1PRxsrfD6jctwyeMfi/fq2wevwi3Pr0RJdSPuWDEHjjbW4hXlD/6b56/FU2/8hDVbMzAtMQTP/H2pjPtc93MGJo4LxHP3L8eW7Tm477Fv5az/vVevFq/S08+uwuo1KVIGev3fV8nffvj2gIz55AH4pVeuEL8d8cZL6/HFhztFbXn2tSsREeNj8Afed8uHOLSnUOJmHvv3FVIKVUFV5JVHvsMqvYd03uLxuOXBpSOWj3NTS/HiXZ8jP10p+/iHeuCKO84SEno8ihWD6vf/nImda1Kwf3OmxCsZg4qIb4iHkED/cE9RKb0CXOHp7yod9r/G2FBuD4l14hz6ikbJNa0qqUdlUa0osbWj5JwyjiYgwguR4wMRlRiE6InB4gf9pa9JjbratzkL+37ORNqegiHKJpXMSXOjxW+bNDvqhGKkeMLAXNPdGzOxc2OGKKjGYOg+iSkHE/iHjB3JNRwVpQ3Yv0PxmqbsLZSRo8ZgMxxJKQlqwsQg+c6dKHgywcaoHOaRZlZIvBSvj1RCJYHwD3JDUKg7gkM9EBjCxV1U1OM9Mfql4OthFJXaTd/WqvgTSeCleamdjUvdktXKSCwl3L5XvoOSn9nNRiX6IZVmJQbYD5+I9WtCVRppiziiOipK7JARo/y7fjyn8ndGS6mXlfscGeepXDeM+jQ/MvZT1E4qnfoxpIpHdWj8lCFw3zgyShZVoVWUW5llL/5R/fx6wzbslcxdbmOZbtXefdTghuPdNm7uyhAET2/6RR2l2c1H3wBHe8ZI+zhRPSubJJqM2blZ2ZXIzqmSCoAxuL+mYpo0IQgTk4IRGelt+H7S20pSunVHrqz5PVHh6+OE0+bE4PT5cXJM4Hdu2948fLcuBfsOK7FJRKCfCy5YPBGnz4mR3w8J6Sc/7pfxp4SPpyOuWT4Np02PxPaDhfjX51tRXKn4ucP83XDHFfOkC/+pjzdiR6pSVg/xccV9Vy1EdVMbHvtkAxrbOuU7ccu50xHq54Z7P1qrKKKW5rhn+XwUNzTh9Z92y/+dHOaPC6Yn4L6V66VxKdDVCdfOm4xH12yWSU7RXu6YHRUsvlLi/MQ47K2sQH59gxDSqaH++CYrU74z9JB+kpEi91scFYXvCjLl8oLgEPxUzsD+QSR5+WB/XTmcLK1gaQXUd3cg3sUD1wQk4pyoiSdVGW1orPzVn5uP7eLsrYXen6pkdMWcyZIj99PhPFwyewJM+oBPNh3E7IQQmbZ06wtfS67oj09fiz88+jlyimtx4/nTcdqUSFx469uys33rsUvE0H3ln9+TM8s3n7kUwQFuuPyGt6Rb8/IVybjmsplISS3Fbbd/JK/hpecvlTPsivJGXH/VG9KJ+4c/LsDyC6fI37dtysRDf/9CLt/z6DLMPi1WLnOH/tjfvsC2n9KlVPj4a1cgKv5ItJN4SG//RCYo8cBxzV/PxNIrhnpICapUH724Bl++tkkOFJxmdNntZ2DRJdOO6Qflazi8LQfrv9gtJJS+RxVUGuOnhiJuShhiJoVITJL1sAko/2mQMJezWzu7EoWZFSjMKJdGJaqaIymo7JyPTw5DwrQIUVB/KQFiFirV0t0b0rFnU+aQZiiWcifMiMCMMxMw9bS4E7ZAlBXWYsdPGdi1MQNZh0uHkG2/YHdMWxCDaafFIiLO74TK4CQHWWllQk4ZIZWTXj7ETkECHxnrq58KFYKoBP9fPNGIB+GSwlrxnHLJz6lCYV71qB31LOP6BbjKQrLKtW+AixALxpH9NzYoqThS6tZPLmKZfWBAyvDqFB5jKM3sSke7YS49S96cVa+fW38q+VpJxiQInxURnixw3dyJZskapcLdgcaGNqk40dNM1ftYNiCq8v4BrggMdJOxtkEh7uIXdRnB0iMpE0W1SOMAiZRS2Zczt9YYjJpKSgzC1ClhmDIlVHoECJLrPfuLsHFrJnbsypcJUCroMV20MAGzZ0RKqZ3+0pWrD2L1xnRDR76Lky0uWJyEJWeMl8/+m59S8MG3ewykNDTADX+8ZDYmxvlL5/0bK3egRX9CuWhGDG6+aCb2ZZfhmU82oaGlQ75Hl50xEefPG4cnPt2ELakFct9pMUG4ffksPPn1ZuzKVhTRi2aOR1K4L+79bB06unvh7+qIvy2ZjUe/3ywh+S52Nvjr2bPw5LqtqG/vQJCrM86dEI0XNu+Q/3/e+BgcrK5CXn0DvHX2Mq3ph5xsUTzPjY3GF5lKZ//ZURH4voA9DYOYFRSELRWFMvPex0GHvJZ6BDs4obKnCb0D/bglZAr+PPm0k0pG16Vyyt6ve2Lc3jqAhfHFGhk9Vcno63+8CLe+8Z34qz66fQVufmmleGpe/uMSfLnxsPhvVpyWKOSUuaI8Y/zuxevw+qfb5UyVDUvP370M9z/zvXiBZieH45G/nYsvv92Pl1/bIKH2H715nexo/nDTu8gvqMGis8bhL38+UwjEHbd9hMMHizFuQiCefv4SOcCwxHnjpa/JQXn5pcm4/k9K5BPx5vNr8eV72+Ws/OF/XYbxk0MMf2P5+oGb3hefKD1sdz67QtSy4SjLr8ETt35gUEPnnDMBN9y75Jhd4SyLr/1kB358f5sojyo8fJ0x7cxxmLowXgjo/8KseuncrmpGzuFiZB8sRtb+ImQfKhbiagx7RxskTAvHhBmRSJobA+/A4+tuHw4ezPj4O9elSUYro6VUUJGaMD0CM84ah2kL46BzOnY+qDEaaluxa1Mmdv6ULtFRxmqsu7cjpi2IlYUTtU6UWLe1dMo0qIPSCJUvKurw4P2Ycf7SqT9ucogE5J+IFWGkz6W2ukVIaUFeDYoLakVBZUf/SGV+FfR2evk6i83F08dJ6az3dpTIKXdPRyEe/81kVcOvC/pg6RUV73BNswxjqGTucHmTjJill3i0Ix4V09BwL4SzahLljegYH7i5Oxzt7y5vxMFDxdh/oEjWxv5T7sdZyp85IxIzZ0ZKvBRBgrltZy7WbkjH/kNFhtdAf/KZp8VjyaIJopbSJvD9+lR88cN+1OhPmjlJiqT0/LMT5WTki9UH8OF3ew3l+6njg/Cny+bAydEWr36xDd9uVrroHe2txVaWPC4Iz326Gat3Kf7NcD83PHTtmThcWIFnv/xZmnfdHe3w2NVnYldeKV5fqyiiE8P8cNNZ03DPp2tQ3tACBxsrPHjhQvx7825kVtTIsJh7zp2Ll3/eJQTVx8kBKyYn4NmN20QjXzYhFvsqK1DQ0IgAJ0eEerpgQ2EBbMzNMT88BN/nKuR0ZkgQNpTkw9rcDJEebjhcVwlvOx260CN5pBM8vJDSVA50dqPgqoc1Mvo7xf8sGX3iiSdw11134dZbb8ULL7xwwp7R6xbOwGNfbkKkrzuunT8Jd765Cl7OOrxx+/lYeqeifH756JV49bNt2LwvT3JFrz8vGUtuekNiSV6+93wphVx6y9vyw3/n+Svg6+WIFVe/LhNh/nLLQpxz5nj8uOownn1+tYQ3f/DuDeJ1Wrv6MJ5+/Acpw7/x3vWSm0jS8tc/vCcxOtFxvnj29SsNXZ0//XAIz/xjpVz+26PLMG/ROMN7Ylnr/j+8J0SUvsuH/n2FjKEcju1rUvDsXz9BZ1u3zG7/0+PnY/rpCWNuL3a9f/XvjVj1wTZDYxO72ecsScL8ZZMRlRT0uzjQk8Tlp5chXZqTcpG6K086/I1By8GkeTGYPD8WcVPDfhHxlozQnCr5LLatPoyi7CMd+iRyiTMjMfvs8aKYnuhEKHpp927JEtWU3fnGqrWjix2S5ymKKfNMf8lrrypvxOG9hTIV6tCeApkGZgyq9RxTSv8yJzhx8hSbVP6/4O+CjUlUUkuL64WclhXXo7y0QZIDjgW+LkahiZ/QXQcXVzs4saPexQ6Ozvpuemdb8SHSl/h7+D6P9L0T37VYC/rEWsCKjEw2k7WSjUolr5d/V+OX9JclI1XNSuVabXoyND9R8T2i/nJ/OFyd5GZVG5tUS4FiM1CavZRGJnPZJ/JEhws/D6WJSd/IJI1lSvIBL/8ShZjvsbysUWLDiotqJeO2qKAWZWUNIyqqjIaKifNDXLw/4sf5IyTUc8jzio0mqwK79xRg565c8Z0ag8R07pxoWbjvJzglbPVPqfhxbQpq9N9hbp/pU8NxwZKJkmXKx2Wz04cr94hqSnCgyiXnTcaysybISNF3V+6WZicKKtyWF5w5AVcvn4bC8npptmUeNpGcEIS7rjkNGUVVePS9n9DU1gkrCzP8+cI5GBfhg7+/uUoSZNgV/+dls+DlrsM9H6yVEryfqyMevmQhnv1xG1KKK2FhZoYHLliA7w5nYmdeiVz/x5J5eGP7XintezvqcPGUcXhm4zZ57ouSEvBzSRHKmlsQ6e4GR50VdpWVwcXaGnE+nvI3RysrhHq4YH91Bbzs7GBmaYLy9hbESdZoNfoHB5Do6Y1IKx2emLNcK9P/TvE/SUb37t2LCy64QKT6uXPnnjAZffzzNciqaMLBggrcfu4s6UzcllaIa86YDCtTM8luS4z0w6PXnYVzb3tDDOmfPH45tu3Nx78/3SZjP99+/FI8+co6/PhTKmZMCsXjdy/Fp1/twatvbZYZyB+8fo3sqC+74jUZVXfjH+bh/GWTpdx05SWvioH+uhvn4cIVyfLavvxoJ15/cb0cPP/90Q2GhqWC7CrcdvnrcmBYcd1sXPHH+Yb3w4PDQzd/IOSDRPSxt65G1LiAIe+ZH+/HL63Dhy+sletxk0Nw50uXwXWMxhc2Bn3xyk/45s3NBsUwKMobS66di9lLkn43+aKjgQfZ3JRSHNyajYNbs5Cxt2BIF7qtzlpIafLpCZg4L+aEiaOxUr111WFs+fGQWAlU8EA8ZUEs5p6TKB7TEyWPJB0Hd+QKMaXPtM0oAon+VUZGTTstTgL3f8lnqQTv1yJlX6EQUwbvs3RqDL4H+pk5tpQkleH7v8RzOhZIpBjzRKLMqgIXxqCRvFZXNo86jnTM8Z86a9lGXCsk6Mj4T5Ij2lGEMHHcp74TnN476Z7X+zPZsSxjMo065lWOaxwWbyjd6xv1pIvdqBv+CAHsE/+peFKFICpeSxJHxbd6ZK2STPFhknzqCejvDRJ872ADJ0Z06aO6XNz0EV6SNasTZZxZs8ZRTaOB262ooEbxi2ZXISerAoUFtUcRVJbkx40PxPjEQEycHCJWEeMTmKqqJmzbkYstW7KRls68TAUki1OnhOJ05jRPCZXXRMK5a18BvvnhIPbsLzTcNzrCGxdfMAUzpobLd2XTjhy8+9kOQ26pu6s9rr14Bk6fHYPK2ma89P5mbNuvlNzdXezx5yvnYUZSCD5avR9vfr1TclJ1tlb46xXzMDE2AA++s9bgJV0wMQK3r5iD57/agrX7lAjAxVNjcNG8CbjjnR9QVt8MnY0VnrjiLHy5OxUbUvNk29+1ZC52FZXip/Q8IbFUSN/ZfQCFdY0Sjn/h5AQ8t2m7PN5VUxPxTXYW6to7MNHPB60D3cisq0OQkxPsbCyQVluDQEdHDFoAxS1NiHP3QH57nUQ+Tfs/9q4Cqqq0i+5/bEVAaQxQUAELBSVsURG7u7u7u7u7uztRRFRAuru7QRCwa+Zf59z7ng9FR2dUHGWvdRf3BfDy3v2dc/bempXgnB7HFdTjjbrCrEr1QjX9L4r/HBl9+vQp6tevj127dmHFihUwNDT8ajJ6y90Ps0/Y8XXnZg3AwFWnWBl4YdEgTN92FQnp2WxyT151u887cU7wnvm90GPiAU5bmj/WEuaGVdBj1D7+ou9c1Rc1dNTQZ+hetvmYNaUtzwOdOeuKfQceQF1dAUcOjuTV/+4dtrh4zp2jDvcdHsEHJTqhjuqzm08aU+Z1QLsu9aVVzwl99yAx9hEaNKqGpdupnf/eYmTLgku4c8mTT/wrDgxDLRlVPYFOZNvmnYPtBQ++3HV4Mwyf0+GTs6H0N++ec8OhVdekc5U16mmj3xRLNLCo+c2qRvR/aI7yUfJjZKfnsm3Ss5znXH19/eK1IG4RTb7pIE659UQCiATKUSWLFLPKZVFeXQFl5L/edupr8ezJC/g4hMHjXhDc7wblmTktVqIojJvro3GHejyu8E+JaVxEKhxu+ML+mg+SYt9XV8htoGkHQ/Z51aun9dXvAce4ukfDyTYILnbBbPUlQYlSxdhkn8RPDZrqfbFlVL6G/hHp8Kfce69YdnrI+cDuhtObdNXYSoqIqV6dipwi9j0rkSQ8oVEGas2Skj6LZgozRTV91jO2oaI40Nzs5/8ou/6/CCLMlJQmrUCWEO2pShQVvmdkUSXaLhHR5p8livLv0fVEujlvXkYIJRFQfShykry3bN7/gahJsJciAv6naIgvEm2xgsupViQUE4VMNLpEC3kSlNH1X2V8ryYPdc1y7LFboVJ5VNJSQiUtZV7wf84yiv5PWFgKAv0TEBiQgKCAxI/ETDQWYmKqAxPzajCsp5VnjppcHB7Yh+LuvSBERLz3GSWf27aWtdGxvSHU1RX5OjLbv3DFE7ftgnihQaiipYxBfczQvIkev4Ykkj14xglpYjW1WhVVTB7REnUNKsLZJxqbD99HUprg6tGsgS5mjGiF3GcvsXyfDYKihS5MG7MamDnIAtecgrD9oiO/D5XVFLF2bEe4hSdg6yUHLr7UrqKBJQNbY8nZu/CNSWZR3PJ+lvCMTcR5FyFVaWq7xgh/9AjXfUN5ATa/ExFSH860r1xeAR0M9bDTQWj5j21qgsPePnj2+jVaVauKgKx0toAy0tRE4rMcpD57igaaFRCck86m+M20tGGfEi3aPGnAJzMZFYuUhFP/qYVk9BfFf46MDh48GOXLl8fmzZvRvHnzz5LRV69IjfkqDxmtVKkS9t90wHYbT9TV1kBnYwOsPGUnGAL3aYkhK0/zfKjNptEYtPAkEtOysXCkJcqXLYUZay5zq+Tq7lE4c9UTB045Qb+aOvau7Y8bNv7YsM2GrTxOHRjFB9q+A3azOnf2zPa8Iiaj7mED9nDFdM2Gvryyppd//pRTbONU10gb63YNlB7Ety6/hlsXPaGsKo9d58ax9Y4E5w/Y49DG23ywXbhjIExb6Od57nRQXzPxGFxsA7lKM2F5d1iJVdj8kBL3CJunn0SACykagYo6qhg2vzMTrH9DGLIzchHmE4so/3jEBichPjwFKTEZH81o/lMQ+VOtrAQNbRVoVlFFxWrq0KqhAS19ze9CVIl4hXnHwdnGHy63/Fi1LwGdzKli2ryrMbf0/0k8Kn0eIgIS8eCaN+yv+7Bfq6xdVKtuDWDRzRhqX5ik9OFjD/aJh7NtIJPTdBk7KiIZ9cx0mZiaWhh8Ub79555DQswjBFBogE88gn3juXr5IUg8x8b4tSqges0KPHdKVa0fDXq8RH6oukvVVCI8T5+Qgl7cyFbsuaDyllQcJS1s2phQUTtb0rIWPTlJqMR+nOL/kXyL2IOziNiyFv1HZdXw75XuRAaFqisTRCKMVIkV/TmLy1Ro35PLD0im6Icque5r/Tp/RhB5JTsuCj2gBUX242fCIoMWuBlPOK2OFiAZaTmfdTQgUk2kVFtXla3FdKqrsaOJ7HFWFvQ+h4enwMc7Ft4eMUxQZeNDqXpuYqaLJs300JDifWW6DjGxGbhjG8gb2YoR6LBKoqfuXY1RT1xokpH/xaveuHzDm2NoJaSUhLCNzXS5+HHJ2gfHzrtKZ0ZbNdHD+CHNUVauBA5fcsPJax78OSxbpiSmDW2JlmbVcfSaOw5ddWWiqamigFUT2uMd/sLs3TeQlvWE40aXDLOEXJkSmLX/Jp68eAVNJXlsGN0RB+66w9Y3gh/v7G7Nkf70GQ7YCQWOcZZmSMzNwRWvYCakC7tYYK+TOxIf56KaqhLMq2nhiJs3L1AmNDfFdhc3Lvz0NqyFqxGheP7mDayqV4NdXDT7jlpVqwbrOMF+qqm2FguaFIqXRMkSf+D5k6cIHDa3kIz+ovhPkdEzZ85g5cqV3KYvWbLk35LRJUuWYOnSpR9dP2jdUfgmZnKL3i0wFq4h8ZjYpREyM5/hjJ0P2prooXcLQ4xYdoa/pNY7RmPFztt44B6B3u3qY8KAZug1ej/SM59gweR2aNNMH4PHHOLV7fiRLdCrawOcv+CO3XvvQVNTEUcPjeKTzZoVV3H3TiCMGlTF2o19+bG4OIRh8YyzfGDce2oMKmoJmfOezhFYMO4476/dPwR1G7wXLHk5hWPhyCN8Eh27oCM69TfP8/zoxLhi7BG43wvmE9W8nYM5wjM/cFzoaRfsXXyR5wypAjlguhU6D2/+j2YLn+Y8h8+DEHjfD4LfwzAkR79PFPkQ5VTleZOnJCUFwW+UCB2dfKmyQmdxMuN+9eINR5S+oFjAx8+Rm/UEj9Of4PmTz7dh1SorQbeOFqrX14aeURVUr6eNUt+wVUyvHWXcO173hsN1H1buywqgmnasj1Y9Tf7xbC2dUMi79d5lLzjZ5HUvIIP9Nj0bsir/n7gW0GOPDE6G0x2BmJJKXwJa4JDoSSKAUtUUqjf/BjTfSaQ0xD8BoZTeFJqSrzCpnJIcdPU0oKOvAZ0aGqhaXR3qFct9d2unQvx6oEUBKe1pfIMEeBStTLPGifFZSIh9xIuK/EB2UHo1NaFHOfR1KkK3hka+/re0QCFi6uoSATfnyDwqe1oAmDWqBovWtbjoIBkVoCKFs0skrt/wYQGUBFWrqqBXDxO0bKHP9yWLqIvXvHD+sqeUlBroaWLs8OaoU7MiK+oPnnLCNVs/biKVKV0cowc0QWdLQ0QnPMLK3bcRFiMcj1qaVseska3Y/mnhLmv2y6bRkin9m6Flw2pYsO8W3EMEFf3ozmZo3bAGJu26gsSMHLY93Di6I2z8I3DWUfASndi+Ef784y9svyUo5yksJiE7B9d8QriCurhrK2y+74SMJ89gWFEdWqrlccU/GKWKFeVs+50uggXUMJP6OODjxfu9atXE2VBBYW9ZXRe3YyNQplgxVChXFuHZj3h+dL2RBQwqVC4ko78o/jNkNCEhAcbGxrC1tUWdOoLw5p9WRuuOXYO/ihXHmen9MHjtGV6pXVo8GGPXn0dG9jNsmtgZHv5xOGfri7aN9DGtf3N0HL2HZ7mOrRvECS+zV16GQtlSuHhgNBsdT59/DqVKFcPF4+NYQd9/0B6Opps2tS06tDPkrO3hg/bygYPM7avX0OAD08jeu/kA2XtwIwwX50GpPT+q2w6kp2SjU18TjJvdXvocMtNzMa7LNjZCt+xujMnLu+UhOkRg1k0+wXOIVBlZcmAEWwnlByJ4W2edwYPLnny5jlk1TN3UD+qVv045/iz3ORyvesHhsicTUJp7k4AeW6Vq6tA11EIVg4qorKfBnqMqFcv/o8phnsf/7BUykrKQFp+JZPIWjUxDQngK4sOS8Sglrwm9hGRVJSGCeXXUbaLHP0mQ9S1AXyMSQd2/5An7q97ITM3OI35q08eUiSmlRf0T0HvldDsAdy95wM85UmrpVEquBJq2M4Rlb5N/1MaXIC4yDc62QUxMo0KS89yma6DJ7gxETLWqqX2T1jq1Zam1HxqQyDZStCXEfDyjR6CqXuWqKtzmp5+STVXj+/uPFiL/0Q86RskKoiSVYq4Qi7Oukkoxbdyep58yf4c+RdzWl/VM5WqwpApMMcAkZKJ53eIoLVfiH9uJfQj6nNF8Mc2JxkSkIzoiDZFhKUhO/LiCT9Vm/doVUcdIG/WMtdni7MM5VPp7YaHJcLQPhcODUKTKHH9Ipd+ydS2062AI7Soq0uvjEzJx+YoXbO4EcGWeoKYmjz69TWFlWYefK5FS0iJcuOIltYYiOygipRpqCgiLSsXGPXcREim04WvrVcCcCZbsRUo2UIcuuvLrr6okh8UT2kNXSxnL99vA3itKagE1bVAL7L3qgtO2QrISFWMm9miCWQduIiAmhcVOa0a0R1BiGvaKSvtRliZMuLfcFIRKE9uaIyzjEW4HhHN606KuFuxDmvvyFSz0dPDizzdwio6HilwZtDTQwSlff7ZF7FrXAKcC/FG8SBG0qqaDm5FhkC9eAloqCvDPSEP1ckpIepWNZ2/fYEINI8xs1Oq3JqPv3r3jItuJEyeQmpoKTU1NDBkyBAsWLMgzFrN48WLs378f2dnZaNSoEXbv3o1q1apJ/05WVhYmTpyI69ev8+hf9+7dsXXrVsjJCSmPBYH/DBm9cuUKunbtiiJFiuR5Y4TYuT+YdMre9rk3veboVdCtrIkxrU0w79At6GgocRoFtejLlCyOW5tGocf0w8jMeYaN07sgPT0XGw7aoZq2Co6uHYQFa6/C3jWC7TYmDmuBhSuuwME5HF071MOUca1hdy8IK1df51SQU8fH8kFl7cprsLUJ4NXy8tW9+PFcv+CJ7euseQj/yMUJ0pzwQ1vv4Nzhh3yy3XdpglRkQm3W+cMPsY1PVX0NbD499iNCt3f5FVw55MDVxSX7h7MAJj+kJ2Vh6ZB9iA5O4pPB4Nkd0GOsxVcZv4d5xeD6wftMRGXb7kQ+jVvVgmEzfdQ00eWq54/Gk+xniA5MRIRPLMK8YxDqGcPEVRb0vPWMq8LYoiYatqkDndqVvgnRooO/v3ME7C644+FNX+lrQ//PpHUtWPU3h1Fz/X9ssk/m/ncvesD2okceqy0y7rfsZcJtfEWlf35QSUt6DOe7AjEN9o7L42WqUbk8j4SYtjRAzfpaf+tN+zUgghMdnorIkBREhaWweC8uKv2T1k5Uuec5QBrTqFQOGhXL80ZWT2Rt9a2Iy68Aeg+pkkeuC5LZS9rnTTT3J3/c509pLEGY06TLwnjCa7x49lrYf/k6j5jvR4MqlCwwkxdU9fKKtJFDQhmuqiupCq4JlExG+1/r6ECvDUXcUoIYxdwG+yd+JIQjZT+NVDUwr4aGjXSh+oEYlF7rsJBk3LMLxj2aMZeZnzaoWQEdOtdH8xY0xiM8NrKGokrpxUse7MQiUfH372sOq7Z1+DmTCPbQiYewvhPAxJc+2/17mqBvTxOuRl6x8cXe445ssk+3jerfGD07GCEsJg1LtlsjIeUxt8qH9zTHoC4NccbGGzvPOnLbXr+KGtZP7QyngBisPmHHxy8W8I6ywvKTdizupRb88iFtkZL7BFuuCQR0ZJuGTNS3iRXSWZ2bwSkqDo7hsWwDNbtjcyy8fhdv3r1Dv4Z14Z6QiIiMTBioqaCcYmk4xMRBXU4O1TSVYB8byxGiNA4XkJ4GAxVVJL3MQfarl2iupY0HKdH44+VrxIxb+FuT0VWrVmHTpk04evQoatasCU9PTwwdOpQ7xpMmTeL7rF27FqtXr+b7VKlSBQsXLkRAQACCg4O5o0ywsrJCSkoK9u7dizdv3vDfaNCgAU6dOoWCwn+GjD558gRxce9TKgj0Aurp6WH27NmoVavW3/4NWTI6uI0ZsrNf4JZHKIa0MUaRP/+Hw9buaN2gOnq3qIfRK86yAvHWzjGYsvICfIITMWFAU3RoXgudh+3mVf+RLYNRTr40egzazV/gw7uGoqq2CiZMPo7g4CQMHdwEAwc0QlpaDgb12cX32bF3KPT0NbmqMKT7Dm5fjp/RFp17NeTHmByfyVVRqpou2doPpjJk8tpJZ+xecZ0rRTsuTWSTc1lYn3LG9vkXeH/21gFo3kkQQn0IMn9fMGAXstJyWQg0f98wNqv/EtDHxfNuIM5uuYVAlwjp9ZWra6BlLxM06WyMCjpq+BlBZDTINZKrt36OoR+NEKhUKA+zdnXRqEN91DKv/k2qbnRCd7zhA5tTLgiRUcxSGpXVgEaw7GsGhfL/jDjS4oTSnkig5kikV6yu0ELErHUttO1jCsNG1f5V2lV25lMOUnC2C4aPcyRXviQgw3kSQJm00IdR4+r/WAD1OdB3hlqsVLklYkoq/vjodCTFZX5WdESLinLKcixekRATUluTsTldT2SdVNhk6/RvK/TfG/Sdo/dWMsP67Ml78shEUpZcylxm0imST7rv35nBfy2o00DHIiJVkjlW+skzrjTrSvOvYtWTK6CiqEmy3uPZ2r/IQeB9BVVIZhKETPRZo+dNJPhzXrOfAv2v8spygv8sL1TK8cKFksVokyz+Pwd6jGQrFuATDz+vWPh6xvCsqiwozta8WQ00bqEHbR3VvJ2qt3/Cwz0Kt2/6wdk5nEMPJNXS9p3qoVMXI7YdI9A8svUtf5w+68riWYKGhiKGDWnK1lD0+kXFpGPbXjv4+idIU51mTLBEfUMtpGXkssOLh6/Q/q9fqxLmT27HtoKbDt2DtX0QX29WrwoWT7DiIJe5O24g9+lLtincMK0zcp6/xKyd1/Hs5WvoVlTG5oldsPO6E6zdQ/l9WzywDXJfvcL6y/b8t8ZameEt/sReW6FiurRXa1zwCoRfQgo0FMtieIsGWHrzHt82xcIcRzx88Pj5C1jqV0NI1iPEPH4Mk0oVkfQyF/E5OWhUuTL8M1P5f1jq6nJkKM1rNaxYAaXf/YWjnQcUKBnN/E4JTEpfmMDUoUMHqKmp4eDBg9LrqKpZqlQprpbS94mqpdOnT8eMGTP4dvq79DtHjhxBnz59EBISAgMDAx53pG4z4fbt22jXrh0SExP59wsC/xkymh/+rk3/OTK6Z1IfLDpsw55r5C267rgdopIysWKkFcKi03Hqlhe36Cf1aYpOY/Zwe/3SzpFw947F+t13oKutwt6i5y57YOf++zCooYHdmwciKioNI8cc5pbTmZPjUL68HPbttsO5066oV18b67f058dy9Zw7dm64zebchy6Ml1Zxlk8/Aye7YBg30sWKnYPyVKtGd9zM85P5zYmGeMdiVp+dfDCnWM8+41vl+xqEesdi4YBdbPdDdk1Lj42BaoUvE8MEu0XiwJKL/JNAJ51m3Rqg/dDm0G9Q9T/n0Zga/whe94LgYRvAc66y1V1FlbJo3MkILbqbwMBE55s8t7iwFNw66Qy7C25SuyVSKjfvbIROw5tBt9b7RK2vBdlx2d/wwe2zbmxLJUt62/Y2QeseDf/xiIAE5Hbg5RTB6U/uD0Lz2DmRMIb8bRs2q8EElRZK3/PzQMQljWYB4zORRBGwCVlISaTtMV//qXnA/ECEir0r5Uvy3DIZ5RNRKVm6OEqWLM6tYlabS+ycyMaJFOUyCvKP7JtEAdOfItGSRmES0SL1uMTHU2x1CzZMgkhKWo0kNTkLqF5zi/tbgAgiLRroOfJP3hcvy9HzF557qdIlUKpMcXFfaJPzT35NBHcLeh1+1HeeXkN6LSRVXInYjAI5yLnhcSa5IzzlxT1v6bl/S2BVNRSgpaOKKtXVoVNDHTp6Glxp/9zijcgptfO9XKPg5hSB0MC8SWU089+8dU20sKzF4ihZUELUbWs/joGmES4CvYat2tRCr75mnApFIDJO/tQnTztzshShRnV1jBtrgdq1Kgl2Tw6h2LH/HjLF29u3qY2xI1qwAIniRXccvo+Xr96y4HbOhLZoYqKLG/cDucNHPtkV1BSxZkZnlCxZFNM3XWVvUtJHrJzQHipKZTkOmzqDFVQUsGNqdxyz88RFxwD+jC8a0AY5r15i4xUH/t/TOzdFUk4uTj30ZZuntQOssPWuM2IfPUbNCqpobFAFu+zd+LZZbZti7V0HHo0bYW6MY36+ePHmLXoZ1sKlsGC8fvcOPWoa4HxYEI9xNNetgnvx0dAsI4ezbbqhsppagZLR8356KF3223WDCM+fvEPPuqE8iij7vEqUKMHbh5XRffv24c6dO6hevTr8/PzQpk0brpb2798f0dHR0NHRgY+PD3MjCZo1a8aXqRV/6NAhJquPH78fSXn79i1XTc+fP88d6ILAb0lGDcetxaGp/TF84zluy5+eNwBd5hzkNsadLWMwcukZxKc+xqqJHfigt+7AXRjoquPAyv6YsvgcvPzjeVh8QHcTjJh4BBFR6Zg6vjWnaGzbcQdXrnqjWVM9LF7YhWeB+nbfxq2Y5at7wqxRdV4tD+m+nb0QJ8yyQqceDfjxhQUkYvLAfXyC23VuPKs8JVg6/hhc74WwfdPaYyPzHDCf5DzH+HYbkJGcjSbt6mLujkH5niTC/eIxt/d2NnQ3MK7CRPRLWuiP03Oxf9F53DvnypdJZNRhWHN0H98GShr/XtzyM4CIqK9DCJxu+MDF2hdPZFprpNS36G2KVn3Nv3qeNj8Q0XC45o0bRxzyEEcy0+82qgUatqr1r6qyUcFJsDnjintXvLgyJiGLpq1qoV0/s39dLSUQsSJlvtuDELjdD80jgCKQ6Mi4SQ0YNanOCU3kg/ujwNZhj58jIzWHt0dk7URbhmDtRNVetnV6/Jw7EP8V0HeaCKKEPDJxLiNLKoV9MoYnUinxTKX7U1ubbifi/V9bNP7zz8AzpCXn8EI+JSlLEDHFZ7LTA73/+YFeq+o1NVGjdkW2ICOPXFqofArUgnd7GAFn+1B4ukblUe/XMNBEmw6GTEzpvZCAjv9OD8PY4i8oUPAipbekeUsD9B/UWDpXSjZSFy954sw5V16QEFq2MMCYUS2grFyWhU37jzjgyk0fqf/o7KlWaFC/ChKSH2PZ5hsIjRQspWikbOygpohKeIR5G68hJSMXpUsWw9JJ7VFXvyLmbrsO96B4bseTQX59/UoYt/ECkjJyoFpODrum98BZBz+cfeDLj3XpYEskZz/BTmuhRb+kb2s2wb/lE4bSJYph3cB2mHfBBtnPX6JVTR0UKVEE1oHhHCPa39QQ2+xdUOR//8Oopg2xw8WNieeABnVx1M+X50eb6WjjTnQkt/GLlPgfEp/kokulqtjavvsvS0Y/BM190nzoh92wefPmYd26dTyWSKOK1KKnACCCs7Mzz4gmJydDQ0ND+nvky07f+7NnzzKhpRZ+WJjgKyuBqqoqC77Hjh2LgsB/moz+0w9U/7WH0apuTWy78hBNa1dFi9o6WH7kDmpVVceKEe3QfcYhnsOx2T0Wi7fehItPDMb0aYzOFnXQeegunrM5u3sEtwkph56Iw+WT41G6VHH07L2d85PXrOqFhg2qStOWyGv06OlxfN/7dwKxesElbhGeuDqZTxCEBeOPwdMpEq06GmLG8m7Sx+31MBwLRh5mQrHz8iRo6eZtg6+ecIwFS5rayth2bVq+7dKEyFRM77yZKwlEepYdG/NFBOHBRXfsmHkST7Of84e5Tf9GGDS38y9DQvPD2zdvuVJqf9kDTje8ObVKgvrNDdBuaDOYtq2Dov8yYYi+ehRHeu2wPbfyJbN4FaqooNsYC7Tq0ZCJ/78hvdS+v3XalSvnshZR7fqa8d//N7OlskiKfQR3+1AOYAjwiMkTTUpVRJovrUfxqua60NHX/CmER/T604wk2QQ9zRWyz4m8UyucqnCSCqVEqEMm82xALwp0JMlD7KMpmtkThDl2oWLK1k2iVRNXVOmnxJ5JtGYqXpIsmIrzcYCqj0IlkvaFqiT9JHJJ1/3bRUQhBJC3bLwoXoqJSEVUaApiItI+qqbSe6ldTRV1javA0KQqJ4x9KryBqrYujmG4bxMIL7coaUue3uemFgbo0M2IhVCyiwGyhzp70gUuzsLIE93UwqImBg9ryob6BPKuPnLUETetfflzRpZRw4Y0QZfORvw98g9KxJrN1kgSrdq6daqPMcOac3Fl7wkHnL0mKNbr6FfAspmdUKTI/7Bgyw14ByXw/5s8uAW6ta6LlQdtYf0wmO87qW9TWJrrYdzGi4hOzoSSQhnsmdkDZx744byDH//tNSPawS8+FcfuezGJ3TC0A046+cI9MgGqCnKY160Fpp+x5pnRUS0awj46FsEp6ailqYpKyoqwDg6HWlk5NNCpiKvBoVApUxrVNZXhGBcH3fLl8RJvkZCbg+ba2niQHIN3L14iYerCX7ZNn/AFlVFyFJo5cybWr1/PM6O+vr6YMmUKV0bJ9rKQjP5HIPlArT9/B7EpT+EcHIvpPZohJCoVt91CMbyDCZTlymDDsXuor18RW2Z0heWwXdzWOL5+MMIjU7Fq+21pi/7oKWceKjclq6alPeDkHI6Fiy9BqbwczpwSiOfk8UfZLHnYqOboN6ARP44pww/xcPzAkc14I0QEJ2Nivz0scjlwZRK3iwh0wpvQdRtiI9LQdXAjjJrTIc9zogSfVeOP8u9tujgJNT5IYCKQSfuUDhuQlpCFGvW0sOrMhL81Zyel+vYZJ2B3VqiG6tSpjEmbBqBG/Y+jRn9lkIrd+aYP7pxyhq99iPR6IuPthjRD+yFNofhBfvU/QUbyY1w/4oBbJ5ykLXya5+06sjnaD2ryr1X/MSHJuHXaJU+1tGjxImhsVRft+5ujpnGVb1YxIyLn5xYFD4dweDuFI/UDhTK1w+s01EFd06qo06AqKuuqFpKsXwREyGkEgYm8DJnnGVBxDpTIPFXW35N5mgoUiBuRHIm6nhX2FBUqQ9glZJ2OXzQ+8S2rvLTAoLnk0MBEhPonshUZjYDIggoCVDFt0LgaTJrqQUsn/3EUqsDfswmEzXVfxEa9n00n27KuvRuieZtaeeyioqPScPzIQ1bj8/8p8gfad6yHgUObsEk+ITwiFdu230Gw6HZRo4YGZk63QtUqqtyB23PYHpevC4p40i4sntMJ2pWV4OAWgVXbbuHZ89dQLi+HVXM6s2H+hkN2uGYnGNj3aW+E8f2bYte5hzhhLbirjOhqim4WdTF+00VEJj6CskIZ7J3ZE0fueuKqcxDbQ20Z1xk3vEJwwyOE/bl3jOqCFZfvITotC7UqqaGLWS0suyIEzCzt1grr7RyR8+IVetavBc+kZERnZqGJjhYSnj9BVGYWmlbVRkBWGjKfP0eHGtVxIyqMPxmtq+lAuUhRrG7T8bcWMFWqVAlz5szB+PHjpddR+A/Ni4aGhha26f8rkLzpt938sPyUA56/eoNTc/thypYreJTzDHtm9sS5295sezG2ZyPoVVbDtNUX2Rbj8s5RWLzhOkezDe5pynFskha9JHFp+cqruP8gBD27N8DYMRZISszC4H67uUpy6sJEbq1Ehadi7IB9fLA5eX0KD9gTVs8+B3ubQM6dp/x5Ce5e8cbGuefZt/KQzUwWjUjwNPcFRlms4VSdvhNaY9B0q3wPsNSaD3SLgqa2CjZemwpFJWFg/lNIjcvAkv472aSeHnvfGR3Qd3q7f10J/K+DXpdbxxxhc+IhsiUzXyWKomVPU/SY0AaVqr9vi/wbIke+r5f33WPVPIGIaMchTdF1ZAvIl//nZvQSck1m+jdPOrO5vgTaNdTRrp85WnY1/uZCJKqaejtFwNs5gtOgqBopCzIZJ1/T2sZVYGCkBR09TSYhhSg4EFGk8Z+cTBpneMaVRLKTo9EG8hLmmU2xokwJZZKKMr2332q+9e9AxJBV9Qql+TOkQIp6EqmpkKpeAcrq8lDRUISaZjmedf0nIFIZ4BkLP88Y+LhGcatfFhqVysO8hT6atDZAjVp5q57S7kdQEm5e8sID2yBp5ZWO+117m6BDd2Men5AgMiIVh/Y9gLubYL1EM7sDBzdGl+4NmLzSfKr1LT/s3X8fz569Ym3CoAGN0bePKZ9T3DyjsXqTNavyS5YohhmT2qB1i5qcbz9vzRXEJWaxPmH+pLZoYV4DJ655YPcpR/5fbRrrY8FYS5yw9sLu84JifnDHhujTth7GbrjAmgr18mWxd3YvbLnkADufSB5z2z25O7ZbO8E1LB7K8qWxYVgHTDp0jVv07evrsRn/KVc/lC1ZAtPbN2GFPWGmZRNseeDMc6LDGxlzQhNVUQcY18Uxf19u3bfTq44bkWGcWX+hU3dUVFH9rcmokpISk0/ZVjop5w8fPozw8HCpgInESzQXKvn71IL/UMBESnwjIyO+D82gtm3btlDA9KMgedMdvEMwed8tyJUsjqOz+qDngqO8yru3bRw6Td6H3GevcHBxX9x3CcPpG17o0KIWZo1sjY6DdnLqxZ61/aGsWAa9huxhsiZp0XftsY3nfHZuGwR9fU0cO+yAY4cd2fSYEpcIO9bfwrXzHty2WbC6B19Hc22D22/mgzglLZHRN4GqB6Pab+Y5p6HT2qKXWEWVYM/Sy7h6xBEVq6pip/UMqVWILA4sv4KLe+w4SnPLjemopCv87U+BbJAW9dmOnEdP2JB+3qHR7Mf5vdrhqbEZnMiUmZzFaU1PHz9jQvbm1RuumFCVhCojpcqWRFmKAlUpCyXNclCrrAzVysoFooSm6s7Da164vOcuwmXa3+btDdFnWns21/+3oEXEgyueOLfzLhIiBA9BGqvoMKQJuo+x+McKfFlEBCTgxgknjiCVCH7opN2yixFXS6saVMC3Bn2mI4KS2J7M3y0awT5xH4mNqF1drWYF6NWtjBp1K/H8nrK6wm8x6/g9QScqqrrT/OxjikfNyOW4VFrM0mWep31E87RPeZzn36rv6XhEwidpzCgJwETxF2303f5DRmVPoP9Jx0GJup4rqSTwouQribjr+es8dmNfAhpHoTnmClrKqKCtjMo6quyZS2Tya+zJSCRHo1TuDmHw9YjJ4y5Bqv3mbWvDooMh++B+CCL0N6948/Gf5pcJNEvapXdDdOtrmmeu1Nc7Fnt32SEiXPjuk7hp0tS2qCdGPpPafuv2O3AS2/v6epqYN6cjKlQoxzZQKzfchJev4D7TtWN9TBjZAq9ev8XSTTfhIubYk+6hf7eGsHkYgpW7bfj1pkz75VM64pKdH7acEhTzQzuZoGcbQ4xcew7xaY+hpV4Ou2f0xIIjt+EZnsAV012TumH2MWtEpmRCr6IqJnQwZ0JKQqXpHZvANjQSvnEp0NdUhUn1Sjjo7AW5EsXZBH+HoyvPifYzqYuDnt4oU7w4GulWxu3ICGgpKuLdH++QkJuLXlWrYV2Hzr81GR0yZAju3r3LlkzUpieh0qhRozBs2DC2dCLQzzVr1uSxdvL39//I2iktLQ179uyRWjuRsr7Q2ukHQfKmH7n5EFuvu8NUvzKs6uth6WEb1NXVxOx+Fhi44DirCu/uHY/h804gIjaDh7zVypfF+HmnWZ147cg43Ljth007bVFLvwJ2buwPV7dIzFtwgaufpKKnA+ywgXvZ7H7WvI5o07YOt6f6WG3Ek9yXWLW1H4zNBDulIzvu4swBB9Qx1sa6A8Okj/fBTT+snXGGV/1H7s7KM+OZGJWO0Zbr+MC98tho1G9S46Pn62UfggX9dvH+ggMj0Miq7mdfH3+nMCzuu51nJMlzc+npiVDWLPdNXns6eSRHpcH3QTBC3CIQ6RuH+NDkPAb5Xwt6jdW0VFBZXxNVa1dGtXpVoNdQ94fNs9JzCnGPwvntNix6kqBB69oYMKsjahj9+5EGGlh3ue2PU1tsEB0kVDLpc9BpWDMmpZRd/29BFXa7ix5cLU2QaSkaGGlztbRJe8N8FzrfAnQyjwxKQiBl2nvFMjmVjCl8SCbIfL+qngaq6tFPdWhWVvqmPqf/VdDnkCqTmWkSoVYustIFRTnFyRLhlBBQWfL0JaBODC185MsJ1Ufy9CzL3p6lWfzIIil5UZFftiR/NmkjEvq95oI5vvX5a7aseiqjqM8RI0Elz50W+enJjz+qxMuCPtdESqkar2OgiRp1KrG6/ksq8y+ev4KXcyQc7wbDzT6MRxIkoIjbNl3qo4VVnY8spOg8cN8mAGePOXMSFIGqoz0HmKNrHxMeQ5AQc9IcHNz3QOpV2sqyNsaObwUFxdL8Oty1C8K2HbZcJaVZ0ilUCW1Vi4nlkVNOOHbahX/PkI7n8zqjrFxJ7Dxqj/PXhTnSblaGmDS8JVz9YjF/03UeSWtYRwtrZ3bG5fsB2HziAd+POoVtGxtgxOozSM16AoMqatg4oTPGb7+EyORM6FZQxqphVhix4wIeP3uBtvVroHYVday9ai/Mkw5qjyVX7fi2XiZ1EPIoA74JKahXSYPToxyj4qCvpoLipYvCOykFDStVQPTTx0h/9gwd9WrgWmQo/nrxEnGzF/zWZPTJkydMLi9fvoz09HSugvbt2xeLFi1C8eLF85jek+qeTO8bN26MXbt2sfpe1vR+woQJeUzvt23bVmh6/6MgedNn7boAW/94jGxnwsPhl+0DMLCtMTQV5XletGEtLawc3x5WI3Zyde763jG4fscfB087oYV5dR4Cn7/8Mh66RGD4wMYY1Nccm7fcxvWbvujUsR6mTLJEXKyQuERtlAvXpkJOrqQ0+pNaNNSip4M1kbGBVpv4hDFvXS80bVNL+oGa1GMHRzYOnNgK/cYJ6UwSUNyn021/mFjUxJIDw/O1+hndYhUnAXUY3ATjVwlG+58C+W/O67EZr56/ZrP6RcfGcTX134DNnz2iYH/BDS43vJEixtPJomSZElDXVuFEpnJqiihbrgxfR1UUKpbQAfk12dw8oSjQZ3icnoNHyY+RHv+I51rzg0YVVdRtpg/D5jVR36IWFEQfv++J+LAUnN1ijfsX3KVtSrN2hhg8rwu0v0GFkV5LN9tAnNhojShRgUvteyKkXUY0/yZqdfofAW5RuHnCmeNHJYIqGg2g6FGrvmbQ/MCu5luDyHdizCOE+sUjTIwOjQ1Py7f1SyKgSpTGpKOKilWo4qXCVS8iqd/D87RAWuXZz6XVS9mfEoLJ12U8+SorKyKY5VXkUV6lLHuu0n45FcF7tZxSWSgqlWECSgLLX4Hs00hBGtl+JWQhKe4REqMzEB+Vzlt+rxtX5mtVZNFdLWNt1Kyv/bffLyKi7g7hsLP2g8fDCOnnlYgljV517G2Sxx1F8v463Q/F8QP2iIsW3CjKlS+DQaObo23HejyGQCDSffjAA1y74sXnI/IonTi1LZq10Ofb09JzsHrNDfgHCM4c7drWwcQJrVkc5+QagRXrb+L5i9fQVFfE6iXdeY6UyOj2w/f571k01sP8SVbwD0vCrHVX8OLVGzSoXRnrZnXBeVs/bD8jWDjNGNSSrx+++gxynr5Ek7pVMaNfCwxdfwaPcp+jSe0q6N/aCGN3XeKK6NROTViwRAp7EjTN6NwUM85Y899a3NUCa+864tmr1xjRuAHO+wUg+8VLVtSfCQrEq7fv0M+oDk4E+LElVNOqWnjz4gWO9e7/W5PRXxm/pZq+09zdSHj8goev91x0QnhCBtaN64gHbhGwcQnFyG5m0NdSw8y1l1FZoxzObBmGyYvOwTsgHtNGt0Kn1nXQqc92ttbYs2Ug9Kqpo++A3ZzUtGpFT5ia6OD0CWcc3HcfDUyqYvV6oUW/euElVlrS6nfsNEu+zt0xHIsmnhCU9XdmSBNDgrxjMaP/Xl65H7s/BwriELvEumdC+43c2tp9eya0xLa+LHbMPYubxx5CQ1sZu+7OlaY45YfYkCRMt1rLBNaoZU0sPjH+X6m4KTPe9sRD3Nhvh/iQJOn1VG0wMK2GWo31uGpI1UyVSkr/qP1KH9vHaTkc/xkblIho/ziEeUUjNjAxTwuPqqf6ptXQqJMxmnRtwK397wky0j+98Sbszrowkab/T5ZQREq/RcWWnpuLjT+Ob7BGrChkKKdSFv2mWqFtP/NvNmtJFTWbs26wPu0ijVal98moaQ1u4Tdoof/DiAoRhpiwFF6YRYemIDo0mQV91Lb9HOFSq1AOqppCGpOSqjxvNFMoIVtU3ftRs6lEsinFiCt5OS/En8/Fqt5z5GQ9Fap7Wc8E66nMp7z/Na1ymitXIpKpKiQQMdmksRZ67ipl2WeWLhcmU71/T1LisxAdlsIRuBGBSQgPTPyoMk+kkEZG6pvrslUZjZB8ztWAxhzsbvjh1iUvJIqVT0I9k6roPqgRjMx1P4pwtrcNwtG9D5AizomTeT6dI+o1eN9dCQlOwsa1NxEr2qi1sDDApGltUbZsKf4bJ04549jxh0wwdXXVsGxxV6irKyI2/hHmLrmE5NRsNsBfubArDGtXht3DUKzYas0euObGVbnIEhqdimmrLjEhNamrzRXSo9fdceCyKxcHVoxvD1Wlshi74TxeUafPoh6szPUxYtM5vjysbUMoly+D1Rfuc0V0+6guWHvNHjHpWWispw2dCko47OgFxdIlMaaVCVbetkexIn9gYkszbLzvxMSTrJ8OeXpDvkQJ1NVS53SmehoaOGjVDuUUFQvJ6C+K35KMGg5fjf8VK4Fry4ai+7zDbNV0c/1IjFt1Holp2dg6qxt8gxJx7LIb2jWriTmjWqNt/+08c3Ns6xA+OY6eclwwGD4zEckp2Rg8dB/PQ129NIVNoSUqejpYUMoGGRn3styA589eY8uBoTCoIxicr5lzHg9uB6BzX1OMnd1O+ljXzTqL+9d90aabMabKCJoIpJ4nFX2zjvUwZ9vAj55nZEACJlmtZ+Ky5txE1G306ZlPUtpPsliJ9IRMGJjoYtXFKShZ+p9V2V48fYnLO27j4rbbPPtJIHNs805GaNylAYxa1Uapv1Hx/1s8y3mOIJdw+NmHwMsuADFitUCCmubV0XpAEzTtbvLNcunzA5Hkoyuv4KGobi1Rujj6TG3H3qz/hujLnkjtr3rj+IabSBFPeGQJNWxBZ5hZ1vlm85VUuXe7Fwzrk87wcnjvS6esoQirPqaw7G0CpQ/iEH8E6PmTSj8+Mg3xURlIjM1Aclwmi6WIyH0pqOJFPpLUBZAa3fOcIyUKFRPM7SkzXZxv5DPyX38xSeS5Rlkze9rYvP6NTISmIOqh7Z8caul9pBa5IMx5X8mkfekmEm2JRVwh/t3nij5DFIMb5B3HrhDpomWSBPQemDTXh1krAxia6X6S3NP77e8Zi+tn3eB8L0S6sCBNQJ/hTdGolUGeUQZq39+45IkT+x2kEaTN29TE6CltpClNdJ+Txx7i1Aknto6i2NA5CzujrqEW3+7tHYsVq68hO/s55OVLYcmiLjCsq4XsnOeYv+wyAkOSWB+xcFYHzrh3847BvLVX+bPbsJ42Vs3pwu4yJNwl0/zmDath6eT22HLyAS7c9ePf3TarG7fbZ+++wf9zzkALlC5dHAsO3+bL60d1gF1gJG56hkJFvgxWD7bC2P2XudpJ86M3AsIQkpyOxtW0ULRUUdiFRqGGmjIqKCnALjwKtTRU8bYoEJSWjlbVquJhcjyev3mDxebmGGJqVsDWTqnfydpJvbAy+juS0TrDVkFVuTw2j+7EefTl5Uvj/PLBaDN2N9/vzu6xWLj5BjwD41m4VENLBaNmneR5mxtHx+P8FU/sOnAfZg2qYs3SHrh23QdbttnAsG5lbNrQj9sq3Tpu4oPPyXMToKauAE+XSMybfIpb9KduTOUTG52werdYyyevrcdHsVCDQFWTfk1W8Qluy7lxqFH7fTJPakImhjdfxX97l/UMVNHPG91Fb+esHtsQ6BqJ5l2MMHvnkE++HnQynd99M3wdQqFZVRVb7syF/D8QxvDs0iknHJx/hquVhAq66ugyvg0s+jZCmQLIppeA2vk0IvDwigcCHoZJCQGRQ4t+jdF5bGtoGwiv+/dAsHsU9i88jxCPKKmB/ri1fXmu9FuAPiO3Tznj1ObbvLAgkI/s6CXdoCvzufkWSI7NYM/SOxfckSuahpMIxcTCgM30aW75Z/DBJFU3tWUpiYmCINJTsvO0tMnwnCqSBXHoo9ECUoBTFZPnMcuVYTU4KcF5K0eKcDmu3PLPcmV+CWeB16/e8HGNui8UukHv0ctnZPskWD9JbJ8k/q2UYCX1bSW/VtGrlV4LIt20yKVFM4cAiIp6mmElP9ZvLXSj9r6PSyS8HMP5JwksJaD/Z2ZhgBYdDWFoovPJbkFq0mNcPeXK1VLJbCmJnAaMaYHGrQzyfG8obvTYvge4cdGTj/O0SBoxsRXadakvLIgoSS8kGauXX2XHFrpu4JAm6DewEZNb6tAtWnKJraDo8tTJlmhnVZdFYNSyd3AO59+ZMdES7S3rcMdv9spLTD5NiJDO7QK/kCTMWHsZb96+Q8cWtTBzZCss2GmN+x4RkC9TAgcX98Nd73DsuuTE/2P39B64HxCFk3berLA/OL0nZh+7xRZPjfS10bRWFay8fB/FixZhQ/wZZ63x+u07zGzfBHucPFh5P6KRMc74BuDJq1cYalYfh7x98Odff6F3/Vo4HRgAxf/9Dz5TpxUoGd3vbfRdTO9H1vcqJKO/KxltVLc6LOpUw+rjd2FWSwuD2zTA+DUXoKmigEsbh8FymKCcP7J2IJsKbz1wD6ZGVbB+QXcsXHGFv9CjhzZDv54mUkunIYMaY9DAxnByDMPi+RdYAXn4xBj+37s23saVs+6w6lwPU+d35Ouc7gVj+bQzUNVQxFHrqdKD6O3zHti66BK0q6lh19XJeQ6u+1dew6UDD/jET8KlD+H1IAQL+u9iy6EDjgs/G/V5asMNHFt1lWc0t9rOg5be12fSUkV105j98Lkn5B5r6qhh0MLuaNrD5KcwNpfFo6Qs2J12hu0JRySECS1uAs2V9p7ZEXWb6n8XxTZ9xSg84MDiC8gUW94UNUqktPw3qiqSvc6FXXZsCUUnd3oerXubYOjcTuxX+i1B9jQPb/nh1ikXBHoIylyCaoVyaNvbFG16NSyQaunXgAgPESNSOHOWu4Qgid6YRJ4oTYccHyTZ6bItc0EF/odAkjiLnXLZi/CcHvlfElHiCE0xMYl8MclftSDcH74X6HXKTM1BZloOHqXm8GgHkf3HGbnCmEHmU359adb7a2Za/w3ovVBQkhMrxgpQ1lDgUQ21SuWhXkmJg0GIuP5TEGGmUAcXu2DeaJEjAVWvLTrVg2UPY47DzQ80mnH1tBuunHThogVBV18Dwya3QX1TnTz3jQhNwba1NxEWJByr6hppYdqCTtCoIIhKyVlgx1Yb2Nzy58vk2jJ3YWcoKJRm4rl+4y3cuy+Y2Pfva4ZhQ5vyZ3jTzju4cVv4nUljLNC9kxF8AhMwa4VQDW3cUBfLZ3aEk3c0i5qIEA7tboqBXRpi/OoLCIxMQUU1RRxc3AfrTt3HHfcwLugcmd8XC4/awCcyCTUqqmDhwNYYsu0st+9ndGkK16gEOITEoIamCqyMa2DT7YcoU6I4JliaY9XtByhWpAhGN2uA7Q6urKhvVUsXlwKDUbV8Obwr9hfi0tIQNWduIRn9RfHbktHBVuZ48/Itzt/3w6C2xmx2v/WUPZob62Ji76boNfkgihcrgrtHJmLNThvYPAjG0N5mGNrbHN0H7uJM4G3r+qJOzYro1XcnMjOfYtOGvtwS2bn1Di5f9EDHLvUxeZrg/Tms504kxmVi4ZqeaNJSGDzfuOgybK/5oGt/M4ye+d4jdM7QA/BzjfrIzolIwADTJVzVIdESiZdkQW/ltE6bOH+ePClHLXmf4vQhogLiMcliFbcYZ+wailZ98mbdfwlcrX2wfsRebslTpaL/vK7oNqktn5h/ZrBQ52Eoru6yhfM1ofogaeEPXtyDSen3AFWETqy9hit77VjgIKdYGmNW94FFL9NvRoIzkh7j0OpreHBZMK6mqtGA6e3QcUiT7zLjGReeCutTzrh32YsrX5JqqXEzPSamDVv+uNnSQnxbUNUyNSELqfGZvKUkZLL3LW1UcSbf0a8BEXgi5byVLSGtblKlk8l8iaJc/aRFLFVDJV8JqpKyzRMlX71+xwsFiu+lhcPzp8JCgrxP/y6LXgIiq5WqqqJyNTVUIWcGA03++bUiQGrpUzvf3tofDrf8mXhLULtBFXTsZ8ZV0/wq2/SYL51wxuUTLrwIIpCR/qgZVqik/X6unZ43WUEd2iUsMkkQRbOklh0NpceMO7f9sXXjLU4Jo6S/Zat7oqqOGh/nKLnp+EkhstOyTW3MmGbF78OeQw9w5qIHXz9hVEv07GIMT/84zF5xCa/fvINlcwPMm2iFa/cCsG6/Ld9v3hhLmNWvguFLTiPlUS4LfVdP7ICRa88iIvER6uhqYsVIKwxYexrZT1+gV7O6qFJBCasu3OOK6K4xXTHt2A2ugo5s1RBusQnwjU9B0xraeFsEcIyMRUPtinj511v4JaWiVQ0deKQlI+v5CwxuUA+ddaqgrrZ2YZv+F8VvS0aXDusIa6dgeIclYsnwttyquPkwGCO7mvGQNa0I9aqq4dDqARg06TBiEjKxZl5XVK+iih6DBCN76wuTkZv7An377+YD6PUrU3ledPTwA4iKSMP8xV15yDwjLRf9O27h3zl/ZwbPqNGBrH/rDWxFsnrvYNQz0ZEOv/dvIrThyc6JRBgfpi0pUbTow4UfVR79XSIwu8c2nkk87LKEZ8nyAx3gprRZhQifODTqUB8Ljo75KjJEH5kLm61xcMFZ3q9uVBVzjozl1vx/Damx6biwxRq3jziwtynBuE0djFzVB9o1v22bW3YhsGniUUT5x0v9SSdtHvRNK5ghnjHYteA8zw8TyDN0wure0Deu8t2Iy0Nrf055CvKMkV5PghmLrsZo3bMhKn8QY1uIggctRlPiM9kqLjEmA0kxGTyOQfO3EuHa50CEkjxgldTkucpfXrks+xOTMl9RmSyhBFsoqkaWkivxXcc4qFJL4yNUlWVLq/QcYUwj6bGgpo/P5OvzAx3/KumqooahFvTraaFWw6rs3/ylx0WqmFIUrs1FT3g6hEkXuPTaEClt38ckX4cHEq2d2mePG+fduQJPlfZuA8zRf3TzPKJTEjatX3oVgb7CMYN8qqfM6yD1JqUEJ+rGpSRnc2zsvIVdYN5Y0AqQSf6mLbf5MZmb6WLRgi6sbzh47CGOnxWsnyaPbYVuHevDySMK89dcYR1Fn87GGD+kOfaeeYijl934fLNtQQ+UKVMSI5edxsvXbzGwvTG6tKyDActO4umLVxhoaQTjmlqYuOMy/93NYzvhvEsAHINjUKOCCgZbGGHOqdssVFo3SGjXv333J+Z1ao71dg/x8s1bTLYwxzYHF6Ei28gIBzy8ULZECVzu0x1VNApmtrJQTf/98duS0WPzBmPmjmvIyn2OYwv7Yd0hO4TEpGH1pA6Ijn2EQxdc0L55TcwY3gqWfbfyl/Pi/tGIiEzFvGWXUUVLGUd2D4O9QyiWLr+CatXUsHfXUG6ddG63gb/4Zy5OhLKKPOxuB2Dtosuorq+JHUdH8GOhLOTxfXbzAee8wxypiv7OJU9snn+RPRW3X5yY5/EvHXkQrneD0HucBYbMbP/R81s2fD97UrYb0AgT1/b55OtAKUJbpxxD6bKlsN9tGZTUv1zlTR+XA/POMIEjdBhlgTHrB/z01dC/Q2byY5xedxXWBx/wCZqqe53GtMaghd2+y8wr/Y/z227jxNrrPCdXXl0BM3YNQ/3mBt/uf7z7EzannHF4zXU8zX7OJ1arAY0wdG5Hnq/7XkiISmMl/t1LntyqlYCiai26GbPwTl7GHaIQ3x9UNUyKTkdcRCriI9JY+EXvU3LsI/78fQok7NKorAR1sc2tVrE8j2NQ61tZU5HnX/9LYQQ075kUm8GvQVx4CmLInSE4iT1aPwQR6jpmuqjXqDq7SKh8oecy+ZveOufOm0RMR7Ol7fuYotuQxvx3P0Ri3CPsXX+LbaEIqhoKGD+3A0ya1sjzfb5wwgVH9tznfXVNRQ5OofMKgQojyxdfgo9XLFeVx01sg649GvBtzi4RfJ6i6rKxURUsW9KNgwgOHHPECTHyec5UK1i1ro3b94Owctstvm7yiJboZlUPi7fdhJ1LGBTKlsTBVQMQHJOK+Ttu8n3WTe6EP//4CzN3XufL26Z0hUtYPM+PlpMrhT1TumP4jgvIef4SY9uaIiztEe4GRMKgoioa16yCPffdoFy2NLqb1sYuezeoyJVGU70quOAbhOoqSvir+P8QmvEIPWtUw5quv3cc6K+M/zaD+BcoV7YUE1GCllo5xKUIMW9VNJVg5yiohqtWUkZsQiYTUTK7V1GSg/UdwSuzuljloSFxQg0xCjIsNJmJqIqqPBNRQpC4mq1l+L7S5ivO2tU20pISUQKtrgkmooecBDTf5ukg5BY371Q/32xztztCznCn4XmTmmRB3pzHVl/l/YFzOn0VESUcWnhOSkRHremH7pM/jiD9L4JSnSZsGYKuE61YiOV01RNXdtrA8ZI7Jm0fAtP2H7/m/wbUuqa0JhIyrR15APHhKZjffQv6zWiPfrM6fpN5W/ob7QY2RqP2hji4/Apsz7nB+vhDuN7xZ99Z87afD0H4p6iko4YR8zph8Ix28HgQAtvz7nC/H4Iw8g71i8e+FVfRoLk+f44bWhh81nasEF8HIikpcY94fCI2LAWxYalMukgh/qmYTqpukhNDxaq0qbJXK1nCaVRWZlHVf4ls/h2oFa9bsyJvsqA0qnC/BIT6xCHYKwZhvnFMJB1u+PJG0K6hwaNRZm1qoXqdSp98XVTUFTBoUmv0GdMCD2744tLhh4iLTMP5A/a4dtIZHfuaoeeIpnkWZBW1lLF8x0C42odi1xprFt0tnnSSPUrHzrLiyjJ9n3sPbgTDBtpYOe8iUpOzMXXEYUyY1Y61CKSeX72+D3ZsscGNaz7Yue0OMjJyMXJMS5ibVcOaVb0wf+EFeHrFYMGiC1i5vAdGDGrC7X0S5a7behtyZUqibYuaeJT1FHtPOGL7ofvQUFXAgnGWSErLRmh0GuZuuIq9y/uin5URTt3ywrL9Nji2vD96tTTEuXu+WHLIBkcX9INbSBwb4u+54Yq5PVpgzrFb2H/HHbvGdoVbRAKCE9PR1rAGtJQUEZeZjdwnL6X7Jf8oCvmSJRCekcliJiKjFwIEXUIhfk38lmSUYkBznwrD4yqKZfDsxWs8f/mGfdFoMDs2KZNvq1JRicko71dW5oNPtOjxplNFMDCOjEzjn9VEchoWlsI/9WRU7iGBgtdmzbqVpdcFeglRbXVk2qZ0IvF1ieR9o0bV8jxmD/tQnpeqpKPKB8UPcfe8O5NgUlJrfSYj/frBB6x4V9dSRofhzb/qdbu66w7ObRTsPCZtH4r2I1riV0MFHTUsOjOZbaF2TD7KqVGLe2xGm0FNMXbDAK4mf0vo1K6MbffmY++8s1yxPrn+BkK9YjDnwEiOP/0WIGX2tM0D0KqnCbbNPsMVsuXDD6Bpx3oYu7InFJW+TygAVcvN29TmjYQtD655w+6yJ6KCkuBiG8gbkQPTVjXRtL0h6jet8UsJfL43nmQ/48oebyHJiAlNZhL6KbEQVTErV1fncQnaqC1NCwcVTcWfwgWhIEF2WfQ5pE1SSQ73i4evczi8HcOZnArkPgVnd93lynCT9nXRvHN96BhUyJeYkuUTWfO16lIf7g9CcXrPfYQHJOLCIQdYn3NDzxHN0GVQozyLMdNmejBsWBXHd9/jedJ7N/3g6x6N6Uu7sj8poYZBBew8NpLb9q6O4di88jqiI9IwZkobnrmdPN0K6hqKOLD3Ps6ddkVO9nNMm9ke9Qy1sG51b8yedw7ePnFYsOgiE9LxI1uwZ/Yt2wAsW3cdm1b24pjQ5LQcXLf1x9JNN7BnTT+smdEZQ+eeQERcBtbtv4u5o1sjICIZAZEpWLDzJnbM6QHv8EREJj7CupP3sGywJQatO4P7vpFoVU8XLWrrsOJ++w0nTG7fCCsu3sMeW1cs7NUKs8/ewjl3f8zt1AJLre/hnFcAhjY2xl4nd9wICEWTKloIT0yGcHYsxK+I3/IIVEFZHonpwjxURRVF9hYlaCjL81wnrQAJlTTKIS5RIKPalZT4Z0y84OlYVRwyjxaTM6pWFclphEhORSN6NuyOEq6rUVNT2uoO9hNm+WrWe09QyXj5ae5LbulUF22eJHC3E1aFJuLBUhb09+6LgpXWvUw++bxp8P/yHmEYvd+MDl/VWve1D8aeWSd5f9iyXr8kEZWFkUVt7PFYhR5T2vGJ5s4xB0wwX4ToAKHK/S1BIo7JWwZh5p7hXKXyuheEya1WSTPpvxXqmFfDzjuz0XtCax5DcLjugzEtVsH5th++N2h2tOvwZthxYzoHNdCoCbV8qW16/6o3lo46hD5Gi7Bm0nE43vRlYUoh3i9SqaVOFboj662xePgBDDRfhl71FmJ2313Ys/QybM65Idw/gY83nCBUuyJadW+A4XM7YsWRUTjusgjnfFdg4/mJmLy6F78Xxs30+T343YlofqCwEZobHTClLTZdnITTnsswc3N/XjSRFy3FjF7c/wATO2zC2Lbr2eHkU/629PqatjTAlrPjsGTXIFTV12Df2aNb7mBku00c+yw7LUfkdOS0tth4ZAQqaiuzJdn8ccewd8MtvHkjiLRId7BkfW8MGiV0wa6ec8eCqafw7OlLPl716W+OmXM74I8i/2O1/crlV/D27TvUqlURa1b1ZG2Dl3csO8FQEWPGJEuYm+iw3+i8ZZeQlPwY00ZZoH6tSnjx8g3mrr6CksWLYsWUDly0ue0YjFsOwWyCT1ZPwdFpOHrdgwVM5EXq6BeNsLgMjLASzkfrzz3AOCszVs8HxKXiz7d/oo6WBp6/egP7gCi0qqnLHci7ARForKOFN+/+RFRaJiqVU0DG0+fQL6+MK0P6/ZD3vhAFg99yZnTiljOoq6ON3Zed0LFRTdTTqYCVB+7ApLYW5g5phe4TD/AX6t7xSVi84TrsXSIwcVgLzvFt03UznxzOHx2DUiWLo3O3Lfy3b1yditKlS2DE4H2ckLFibS+YmlVDSGAiJg87xAlL525P5wMFec4Nab+Zh8gvOs2XmiZfOuKI/Wut0bC5HpbuHix93CR26ttgMQ/nrz09DnVMhRWyBHFhKRjTchWKFi+KM36rPmnmfveMMzaMO8yG5Yd9Vn8xGc3NfILRxvOQlZoNi36NMPPA6F+qdfd38HcMwbphe5GRmMlkcdqeEWjey+y7iZuWDtjFllmktl9ycjxqmX06tOCfIsI/HpumnkBsaIp0ETNmeQ9WOv8o0KGH2qL2N3zgdDsgj2CmaPEiqN1QByYtDWDcXJ8teX6Hzxwp1Kn6RpVOSpqiqid9vz+lFCcyWUVPg7slVfU12XdYQ0v5p7NV+9I56me5lDf/nMeJaP6eooBJHESzjjxmIJ6tSG0vsdQiwSYRxFJlSKVfEmUVS3/XGXYS63k+CMWDaz5wswvix0egx9PYqg46DmoM/fran/y80vGcCOjRzXe4HU+o07Aqxi/qzNG2H4qyDm65g+tn3fly9ZoVODZaXUbY+vB+KNYuvswLkSq6qli5pR+URfHqQ4dQrFwqzIo2blIDC5Z25eqpt08s5s4/z9e3tayNmdPbcbt+ypwzCAlPQaUK5bB700AWEY2cdQIpaTnsQbpuQXecuOaOPacfonixoji4qj/i0rIwd9sNnlPdPb8X/KNTsP2CI8qUKo6TiwZg+r7riEh6hHYN9VBTRwNrLt5H2VIlsGFoe4zef5n/x9qB7TD/og17j87t2Byr7tjz9RNammG7gwtbPV0a3KNQwPQL47ds06uXK4uUR4I5u4aSPJIzRKN2FQVpVVRDRR5F/vgDSeLBoqKGIlJSc5iIlixRDCrKZREULLTfKQWDiCitPBMlbX2xUkrtE4JudXXpwSk8SPg98hGVTe8IEWdLKRNZFnFhqUxE6YBLB7kP4XxLqGyR9+jnUoVuHhYyhqk9/zUH690zTjARrVRDk9vzvwMpkEWdJvrY5boca4buhpdtAFYP3oXk6DT0nd35m78W3La/Ow9L+u9EqGc05nXfgnmHRsP0G893VqtTGVutZ3LWPfmT0jwp5dLP2TkYNep9/Bn7HqDXjj7PtI1a0JnnSZ1vB8DlTiCLTHwehvOGZVeYdNVrVI3TxOqY6nBb9b8MqgiTiIja6kQ2Ke6U9j+l9qZFkHZ1dSabEtJJdkT5KbR/NhD5Ij9SUrSnJ2ax/RgtPMifNJtCCDKf8PGN5uK/FSjpjdT8nE6lrsiiK/oM0XhShaqqUK1Y/h8T9hIli6NR2zq8kZ2Z/XUfrkxH+CcwQaWNZkp7jGoB87Z1Pvo/VClt2bEeGrWuhYuHHHBuvz383aMxvus29B7VnDfJ8ZmqpCRkqm+my1aAdO6Y2G8P5qzuKW3bN26hB1W1wVg0/QxiItMxZcRhrNk+ABW1lNC4qR6WruyBxQsu4KFjGFYtu4L5i7qifj1tVtUvXnoJt20CoKxcFsOGNMXKRV0xduoJJCQ9xpI117B2WQ+smt0ZY+acgptPLI5dcMWgHqbwDUmEq28sC5sOruqH9k1q4qZjEJbttcGxFf1x3zsCgdGp2HjmARb0b4Uh68/A2j0U7Rvqw6CSKoIT0jmhqYdpbZxz8cdhOw8MMDfEIQcvnHH1QxdDfVzyCYZzRCwM1FUQnJqBo25Cml0hfk38lmRURVEOfpFCe11dqSy8AoWWubqyPFIyhJMBDW1T5YbmZgiaaopSYqqpocgn0sREQfRUqaJgLJ+c9JhzfslaQ1VcmcZGCoKnKtXe29qQkp6g+0F6Es0TEWqIUaESBLgL6T100s6PRHrcE4yNTS0/neqTFJXGKUDUnm3Tv/FXtefvnXHm8QWqiP7TqND/OuSVymL55RnsJHBp2y0cXXoRj9NyMXbjgG/e5lRUkcfaq9OxesQ+uN7yw/JBuzF773A07SooY78VaD5z2LzOaGhRE+snHUdq3CNM77IZQ+Z2QvfRLX/oooNeQ/162rxRa5mshlztguBxPxjBXrFMZG6fdeONQJVSuq9ePS1Ur1uZK4PUWv2ZQMcPmpVNjE7nLYHsk6LSmYSS3dCnQMp1ej6yHpgaWko/fTv95fNXTKzjw0mxn8rPlayiUuMfccLSl4KIN40qURgH7dMxj/1Hiwr+o9TLoyqpEMP6jj1HaaPRDvLylUQT0yaJyv0Q5GlK87La9BrXrMBpZbp1KqHMV86E0xxu+/7mvEUGJuLasYd4cNWbRyZWTTiGCtoq6DXOAhZdjT7y26Vxin50W+f62LX8Ktztw3Bypx2c7gRi+ppe7KgigVlzPew8MxYrZ55lQrpwwnEMn9qGbaDoe1rdQBNbDg7DvEknkRifiamjBEKqU10dDU11sXRFD7Z+cngQihIlbmDm3I5oZF4NUye3xcbNt3DipDM01BVg1bYuVi3uhvHTT8LTJxb7j9hj7PAWmD66FVZtv43DZ51RR78CFoyzwqCZRxGd8IirpNMGNodXcDwXdvZecMbCIW3Qf+kJbte3M9NHr2aGOPvAF+vPP8CCAa0wdPt5XHMPZu/RWz5hCE3OQHfTWihXphRiMh6ji5EBSlAFNyEFE1uaMhk97y0IdAsSb/58gTd/Fvvmf7MQvysZVZBD+mPBC1G1XFmkZz2REtN4kWASMX1CBzcxuk1dVR4+fkLlUlNdSJdJEjOLK4iWH4kJwu9WrFheeiKPjxMOhloyiRyxouhJlqBSe06SgaxrUCHP4w3xEcRONRtUyTd5h4brCUbNP23WTglAfJ8WBl+c+iOxcSK0G9ESNYyr4ncGVThGr+0HdW0V7Jp2DNf22OLdu3eYuHXINydudBJeeHQsNow/jPvn3bBm1AH8UbQIGnf8tqp+Qi0TXeyynYOtM0/D8YYPK++D3KJY9EQtz4JARR1V9KBtVAuuItKCzNcpAn4ukdzCJksi2kgQJWmRkrhPq4YGKuuosTJcs4oK2xF9r+ohVfyookfpQzRDSBW/NImnZdwj9rUkY/ZPgSx+6PFSxZPIp1Z1dd5+5KjEP0VO1lNE+MVzNTA6KBHRQUnsT/op0CJYUp1UqVAOyhrl2JuUPEkVlMuyap+iiIkM/pv4U+pcPc99gRzyG32Ui8fpT/Aohd6Tx0hLyOT3hR4nkWOydKLt3iXB/J2+w1p6GqjZoCpqm+pyFf5rvH91a1XEtHV9MGxWe9w44YRrRx9yhX/zrDMsehowxZJtzT5cVJCX9JLdg+F4OwA7l19DbEQapvbZhYETW6P7sCbSyqqapiI2HB6OHatu4M4Vb+zfaIPEmEdcOaXXjKyeNu0fwoQ0MiwVs8Ydw+rtA9j6iQjpgiVdsXTRRdjaBEBeoRTGTmiN9u3qIi09h8nopi020NQoh7p1K2PONCssWX2NjfFr6lWAVcta8A1KhPW9QCzfYo0jmwdj/ti2mL7mEs5ae6ORkQ7mj2iDiWsv4rytLyxMqmNou4bYf90VG04/4HQmig+NTXsM/6gUdGpowGR0z21XNsDfdMMR+++6Y3gLY2y45YgTTr7obVwHx1x9cDc4CnUrqMM/5tvP638tjkd1Qym5b0ubXjz98oXar4zfkowqK5RGRvZTqZo+PUvYVy1fFp5+ArFTVSqLdDHrW0G+FLfmU8UqqbpI5tLEyxoaitLKKKGCWCklJMWLBLXy++viRdGTlsx8UEy4IFZRr1juo5MnHfAlPo35mZtTlYDaT5+L/nS6IbQ4mnQx/sJXCXC96YMI7xhueQ1c8Ok0p98NlGdfWr4UNo7ch5v776GMfGkMX9H7m/8fqqSQ9yidjO6eccGaEfuw/Nxk1Gv27ROiaLxj7p6hMDxRHbsXXYTrnQBMbr8eiw6O5OpRQYIU9w1bGPBGoNZoqE8sV0xJ8UxVKEolkyjLPwR9nygoglq25Cwgr1iaXRGo+sbpPyWK8mstyf2m7xN1OISknzd48Ywqbq94lpH+Dy0cHz96iuxHTz7r0Umgv0ktYSLKlPpDJJsqcqRkp8fyXwARvJjgJAR7RiPEK5YT3qiKnh+IvBGhJtV+RV01bolraqswEf0RSVz0XSlbrgxv9Fp/6vkQMaUKLj2vqKBEJtZUrY4NSebt5rGHfN+qNSuiQQt9NGxVCzXqa39Ra59eAxI+dR/ZAjdPOuPCvvu8cFo35SQuHbDHyPmdPpr7JyLc1KoOz45uX3IFzneDcHjTbfg4R2Dmut4cb0qgsa6pizvzbOi+jTacdZ+RloP563ujVOkSUCxXBut2DcL8ySfZxWXuxBNYu3MgdGtooFGTGpgxuwPWrbqOi+fcoaIijx4UGTy4CZKSHnOk9eJll7Fn1xC0aKKHEHIOuOSB1ZusoVNVBVNGtkRgWDLik7KwfvcdLJ/VCV1a1cGVu/5YvccGxzcMRufmtXD1QSDWHLrLcaE27qGIT8vGqTtemNy1CRYdtcGBW27YP70nbH0j4B+bgl6N60CznDySH+fy3KqmojySs3MhX6w4ShcvhpDUDMy1aoalrRrDYMWcb/I5KcTPh9+SjMqVKoknz4UINiX5Mnj0WCCjyuVoX4i4UylfBumZT6TElJD+SGjhq4oHBgkZVRPJaYrYxidbDQIpE+lAQdAU1fikhkwTK6CklJSAfOgIVCWRBVWF6EBG0K31cSJQsJh2Q8rPT+FR8mNEBybyAc/Ess4Xv04Xtwp+oh1Ht+LWcSHeo3X/xnj35i02jz3IdlcaVVXRbliLb/4S0clv6vYh3IZ0vOqF5QN3YdPtOdD+oHr+LUCfD/IlrVa3MlaOOsgtzqkdN2LWjsEw+4rPzfcGtUZJCU6bpIJPRIKIKLWHqQ3OSUJxj4RZRDF7nozOv8drRrOJKhqKbIpOVS7OQa+sBM3Kyrz/XwuEILJGyV3+zhGc6hbkHs0t7w9BRJM+Kzq1KrK9URWDCt80Rex7gb5TRJBpM23zfrQpKy2Hj6eBblHwdw4XRGRc9U3E2R227Ahh1rYuW6KRhd7fEVNaRFFln1r4Vw474Pzee9zKJweExlZ1mZQSSf+wWr5gW3/cueSF3Suvwdc1ChO6bce8zX1RS7QBpM9c1wHm0KhUHqtnn4enUyTmjDrCPqW00KJUplXbBjAhDQ5IxJwJJ7Bx7xBoVVVBm7Z1kP34OfbttsOenXehpq6AJs30MGtGOyQmZSEiIg2LllzC9i0DMGpoMwSHJiMgOAlLV1/Dzo0DsGhqe4yZcxL2rhEckT1+QDO4+sXyeNueU46Y0KcpHH2iEZuchbN3fDGrvwUmbLrI/qPHFw1ALW11BMam4twDPwyxMMbuWy68jWlrgkVnbXHM3hvj25lj1fX7OOPqj94NauOwszeu+YWgi76QUliQGKhz6buY3k/Ffy+98Fvjv3WU/EaQHEJIMV+0yB8ca0ZQUiiDrGyBjCqXk0N6ukBGlcUKRsYjsZoqktMMsXIqmQ9Nl1RONRSkSRw030TVF8VyQrszNSmbrTRoML288vvKSKJYLaXqiSxiw1P4ZEsHwvySOyLESu7nRCe+joJZvq5hZSh8oadkXEgSAh6GcXuNKoGF+BhthzRHZkSpITwAAQAASURBVEo2ji27yJ6k2gYVYWCa1x/2W4BOemT7RGlG/g/DsLjfdmy/t4Dbmt8DEnHTmrGH4fswHMuG7cew+Z3RY6zFTyleo8dE7V/aJD6Rsos5aqGTgIbmN6mqSdVNGm+h20iBTC1bImDUdidQG5XanjSDSkptIhXUOicSTBU3BdqU5LhaVU5F/l+1lX8W0IiB54NgeNuHwvdhGJ7mvPiocq5vpA09oyrQq6/NsZnfM8WrIEDjS43bG/JGeJyRCx+HMLjbBcLzfgh/fig0gjYSRbXq0QCte5syKf8c6PPTd0JrWPU1w8ktNrA+5YyHt/zgaR+CgVPbovOQJnmqxvR5tuxuDH3Dylg15RQXKuYMPYAxczugQz+zPJ6ka/cPwcIJJxAWmIRZIw5h9d4hKKckhzJyJbByaz/MHn8C4SHJmDPxBLYcGAo1DUX07GOCtNRsXL3shTUrrnKefbUaGpzKNGbcEfbO3r7DFjOmt8Oi2R0xfMIRhEWm4dCJhxg9tBmG9jbH/pMPsfXAPRjVqYw5o1pjysqLuHjHF60b62Nq/+ZYuMsaR6+54cyaIWhRXxf3vSOx5aw9pvdoiqEbzuGaSxAOzeiN805+SMrMxfMXb6CrroTI1Ew8yn6GykqKiM/MRuk/iqFUsaIISk6Hc7RwritIFPujFG/f9m/m7wv8u+G3JKMvxQxyRbmSyH4iHHTJQ610yeLIyhFSmcoplEaY6PNYXkzKyBIrqErl5ZggZoq+ckoiScwUySm1PwjpqQI5VVVXkJ7E05KFVr56BUEEJUGKOG+qWVmooEpAIgACtb7yQ1SgIHqiAfxPIchFiJir0+h9tNzf4e5JoU3V0MoQyp9p///u6DenM2ICEzipac3gXdjt8WlrrX8rNqIZ0kmtViIlJgPrRh/EsrMTv5uohVrIy0+Mw74lF3H9iCMOrbzKSmiyf/ov2QYREdCqps5bId6DiHeYTxyntrndDZRafElAn2GamyRv2tpmuqiiX+E/9b5/C9BCo2X3BryRfRNVimmm2snaF5mp2Vwtpa2ueTV0HNoUppYfK+dlQcWE8cu7o10/M+xcdBFBnjHYv/Iaq/Gnbej70WeUbJ7Im3TroktsBSWZJx07v6OUvOrVroQNh4Zj3pijLJadOfwQ1u4fCiWVsigjVxKrtvbD9NFHEReTgbmTTmLL/qFcPaWo0OTkx/Bwi8ai+Rewa/8wqFHS0rzOmDXnDKxv+/PsaOtWtTBzUlssXHkFpy+4wcS4Cvp1bYiH7pEIiUjFhj22WDOvK9o1qwlr+yCs22+LQ6v6w9igEjyDE7D55ANMGdAcTv4xcA+JR59W9dC6fjXYekfggLUbRluaYuX5ezho647pXZthzqlbOP3QFxM7UHX0Ac65+aN7/Vo44eaLI86FavpfGb/X0UVE7nOh5aQoV0pKRhXLlmKCKblcTr40HssQU8Ljx+LlcqXx5MlL9miTJauZj/KS0wxJZVX1fTUyIzVXGhkni9REkaRWykv8kmKEFj3F9eUnIqDVOoGEEJ8CJfoQDBp+eZvD+ZogDGnxnfw0fxXQgmLqruEsakqLf4SDCwTB1/cAVeUWHhvH1TpPu0Bc23cP3xNU8Ru3shdGLenGz/PGUUesHXdE6qtYiP8WSH3u4xiG7XPOYoDRQkzrtInJFBFRmm3VN6qCAdOtsOnaNJwNXIPFh0eh68gWPB70uxHRD0GjFiQQnbKhH076rMS8vcNg3NKAXzc/5wisGHkQw8yX4sqBB+wq8DmQLde6s+M5fIDmmWnmmczzLx+0l1bnJSA7v1nre2PY9Lb8Hbx5xg1Lxh3jqr4EpD1Yf2g459knxj7CnFGHkS3qIIh4rtrWHypq8kiMy8SSmWfZs5acCcjiqVJlJWSk53Km/bu3f8KovjYGDRTcVrZsu8OOMU0bVUe7NrW5y7dm8y0eP5s7sS13Fp09o2H3MAwTBjTlyOyo+Ee4dMcP0we1ZHN8B+8oJKfnoF8bQXi57YIjxnQ0R9E//oBTUCy0lMqhgpI8Mp88R/rjJ6ihqYJnr14jI/sZKpaTR9azFyhfohSKFfmDlfWF+HXxWx5hcsSDhYJcKeQ+eyndp1hQatfx5bKlkC22qhTlS+HV67dSZX05hTLIzhaIaZkyJXionFrvj8UWf7nyYiVVnDlVkpmjyhR9BJVlFO1EgjNShTlSOqDIIi1JVPfLiKIkSBKrpjSrRhWg/EAijHgxorSaYV7/0k8hJSYdiRGpvPpuYPl98st/JZRRKI1pe0fyvvWB+yz6+l4gQcXI5T15//Dyy0iOET4D3xNESObuHsqhClQZWj58P15/InKyED8XiNwEukUyAe1ffwHm9dnBbebH6blsEN+0U33M3D4Ip/1WMwntP60dk9LfnXz+XZeiSYd6WH58LA67LuFEM8qZp87B3sUXMdhkCc5uv5OHMH4I6mi07WOKvbazWSBFC7x9K65i0dD9LIyTBZFQig6lWVIa+fJ0DOe2fY6obyBoVirPFVFlNXkkxDzC3DFH8UT0bSUiSkb41LoP9EvAllU3+JxDs6XkQVqqVHH4+8bj0P4HfP8B/cxRt04lvHjxGqvWXmf/7AmjWrKjDHlt7z1kjyqVlDGwh5CutP3QPf68jO3XhC8fOO8MhTIl0b2VMO6w5eQDDLQ0hoJcScSmZMEnLBFdGtXi2/bedMGoNsLfOXrfC0ObCwLbc07+6Gcm/P5Fj0B0qK0HHeXCDt2vjN/yiPNMJKNlS5fAE5GMli1Tgq2cCJQsUaJ4UWl+Pa34csUvNq325ORKICdXIKMKCkJL9unTl/jznRAPoiBmimdnCQcLRZGcEh6Lrf3yMvOfFA1Hql2+Xpw/lZ3lIpAdyodIjRcM9ilx5XP+olQRobabyhe22/3sBd9SvYY636Xl/CuiblN9tOxjzgf5gwvPftf/1WFYcxg21WNR0+45368SK4smHethyZFRXJUlX1sSONFCpxA/J5Ki03F07Q0MNVuKmd22MgGlmWMiTW37mWHFyXE447+aFxktuzWAvMwx6mcHfceIvD3Nec6kmgSatNH8dk7mExZbfVhh/F4gBxPy5T3msQwT1/RmV5PcrKc4suY6hpot4Urp5zoJSmoKWHpwBCas6MFE08shDOPbb0SgR/RH9zVvVRNrjozgaid5Us8cuE9a3CBoVCyPtfuG8sxoTHgaFk86yQlOBG0dVSxc05PjQe/e8sf5Ey58fWUtZcyY04H3z552gZtLJBPLubM78nkuNDQFp067oEzpEpg1xYrvd+WmDwKCEjm/vnKF8sjKfo4Dp5zQoUUt6FVV46LOvrNOGNHVlKNCIxMecYV0eAdT/v0D110xsFV9lChWBL5RyVCWK4NKygp4/PQFHuU8hY5aeTx5+QovXryBklxppOY8gXFFTZwd2ecbv3uF+JnwW5LRpy8EMipXqoRUVS9XuoS0SkrElO8nktGyciWlRFVOriSvVHNzxdtEk+RcsYpKq0yK+eTrssXKqoxXo4Sgkq+eBI/FlTBVN0nYJAvJwYYOWh8iXayaqlb8mKhKkCSq9Cvqvk+A+juEeggm+7XMv30M5a+MwUt6cDXZ516Q9DX8HqD3ccKG/txG97ANgI99CH4EjJrpY9mxMUxI3e2CsHHycWknoRAFD1qc2F1wx8zuWzGiyXKc2WbD1TqyZqO41xWnxnGLefL6ftxy/hlV/lRxjw1OgvNNH1zaZYu9885i5dA9mNF+HUaYLETv6tPQUX0sbz2qTEZfvekYUGsWb/1rzkTvatPQtfJEtFMejW6VJ2Jg7dkY33w5Fvbaii2Tj+HUhhu4d96V082+ZeIT+QKTE8UBhwWYuW0QK/WJ/FOldEyLVWyV9qnkbfo+k+J+69WpqKSrxilcc/rtwo3jTh/9jl7dythwcjSU1RU4RGHmwL0slJWggpYSVu4exPOiwb7xWDf/ovQ7Wr9hVYyb1pb3D+20g4+7QHibtdBH525CRZJsn7Iyn7Iod/LENnzd8ZPOLGoyMtRCe9F9YP02G/wP/8O0Ua348pXbvoiJe4SpQ1vy5Rv3A5D26AkGdxSqnmSE38HcAGrlyyL98VM4+EajexPBoePgLTcMayUEehy774VBzYx4/4yzH/qYCPc57er/jd6pQvys+PmORj8Az8UWY5mSxXkVJ9mXtOHLlBYIofS20iXwTGy5yIlE9cPLEuJKrQ8Jnojzp2Vlqou5YnufVrcSSNotsgRVeptYSS2Xj2VK1meIqgTkp0egFfuXIko099c1/DGxkL8K1LVU0LKPGWxPPMS13bbQa/D9rEhocdF+aHNc3WeH42uufRfv0fxARuA0S7h40B44XPdhVTHNlBai4EBG7uSLeeeMCzsFEGiWsX4zPVj0NGH7og8XuT8DqB0d7hOLCN84RAckIDYkkcV5NPL0NaAFIK2zyR9W9nc5kenpS2QkZeFTS0PygK1auxKq1dVCjfpVoNeg6r9yCaDHQoInGn+g94Pidslkf+nQfTxjOm5Fz092skikuvXKFGyde45FTSRyIjeVsYu75lHbk+PKhhOjMWfIfqTEZ2H24H1Yf3w0lMSuWtXq6liytR+LmpzvhXC2/ajpAgnt2MMYEaEpsLnui1ULLmHX8VHcxh891gKB/vGIikzHhjU3sHJdb7RsYQAHxzA4PgzHug03sWvHYE5jcnaPQlxCJnuQDuhtihbm1XHfORxbDtzD9hW90cq8Bu46h2HnSQesm9kF52x9kJb5BNftAzGigwlWHruLo7c8cGhuH1xw8IdfdApGtTeDumJZpGY/YftDyX7Z4iVQslhRhCSnwytWiNEuSLz+8yVe/1n8m//NQvymZPTFK4FklipZDC9EYkr7EpJKqnqChJyWLlUc2SJhpMon3yZWVGlmNL/LhGdPxetkCCr5HRLk5N9fJ7FRKSu2/CWg9o5k7ii/NlqOWFH9nAdolrhqVhZTor4EyVGCi0DlAjY7/y+iw0gLJqMPr3pg0rMhKFnm+6Xp9JrSFtZH7BHsFslRr/rfkfzKon5TPUzfOpDFTJf332fxnGXfQqHbjwRVzILco3Bp33242ryvupFvpWVfc7TubcKz5D8TqJVONnNkTxboEoHk6PznnWk0SFNHFRpaKlCpWJ7Tmsh2SVGlLMqWl0NZhdIoKfc+KlS240Pteaquvnz2iiufT7OfIzvzCR6n5fD/T0+gdKwMHl+iYyNVjmmj2F0C/S0ipzQGY9SyJmqZVeMZ0a8FdS2oUtq8qzHPj9L75HkvGGNbrsLAme3RZWSLfOdyqTs2e+sAjoE9ss4aN084c6LXvB2D8+gCyM927dFRTESJkM4ddhDrjo2Eomj3VttIG9OXd8OaOedx6bgzKldVQduuRvz8Js5qh6jwVE5pWr3gItbvHsw2ZnMXdsHYkQfh7haFm9d80KFzfUyeZAlfv3hERqXjwiVP9OllwoR01cabOH7GBW1aGmD8kOZw8oyGX3AiHFwjMKZvEzxwi4CHfxz8Q5MwoqsZVh64g2M3PHB+/RAcsfZA0qMc2PtGobN5LZx38MPROx4Y2KI+1l+2x0l7X/RrbMipTBddA9Cpnj7OuQfwVtDYFd4fJb9xAtPLwgSm35iMvhZJZ4niyBErCURAJZZPREwJL2WIaopkv1Reoiq5/EKM/SstVlU/fZ1ALkvLHFiei4STWiuykG0j5RcRKKmCfC6ykSLxCHQg/xI8fyIcwAlqWh8r+AvxedRooMPK+tTYDPjcD4ZZh28f3ykBVSWbdW+Au6ddcOuo4w8jo4TmnY2QHJ2B4xtuYuf8c9CpXTHfUIZCfFsQ6XSzDcSZbXcQ5hMrvZ6qoB2HNEUDi5o/jfiIiGGIezRcb/vC/U4A4kKTP7pPpWrqqFZPGzq1K6FKzYrQ1q/AEaH/1M+WhEElS5fg7e+COp5kP+ORgCj/eIT7xvGCjiqzdJm2izvuoJRcCRi1rIUmnYw4MKTkJ4SinwIdt4fO7YTWPU2wY+5ZVt4fWH4Fzrf8eEFH7fwPQc+91xgLVKyqinWTT8DzQSi37ZcdHpkntUtVUxFrjozEjAF7uWW/aPQRrD0yUkpam7etzer6E3vuY8fKG6y6169TiYnn/FU9MH7QPhY0nTzkgEGjmkO7igpGjGqJ3TtssXeXHYwbVuUAlzGjWmL9RmscPeaI5k1rMAG9cdsP/kGJ2H3wARbP6YQ+nYxx7IIr9hx3xPFtQ9C1TV2cv+WD3acdsXd5Xxy97o7EtGxcvheAoe0bYsVRWxy/7Yk9s3vi0kN/uIclYFR7U5QtVQJx6Y+hJi+H0iWKISotCwOa0TE0AA6h308YWoiCx29JRl+LlkzFixWRGt6XKFZUSkZJvER4KZLWEiXe31ayhHAbmWULl0XiKgqQaAhdAsnweN7rxN8Tq698nUhaycZDFi9krs/vBEMtKMLnREaSqitFVn4JsjME8koHXZo1K8TXgU4kxm3q4MY+OxaCfU8ySrDs35jJKMW9TtjY/x9Vcf4p+kxug3C/OCZH68Yfxfbbs7haVYjvQ0KJwJzcdIuTgQgUY2rRoyG7HVT+SXxU6XGGeETj/gU3PLzmxQIjCWh0QNdQC4ZN9HgenazmCtI4v6xiGdQ2r86bBOQfSpVb7/vB8LwXxBVVeh60lShdHI061Idl/0ao07jGVxFmikZdfW4ibE67YN/Sy5z0NKHNWoxf1Yvfw/xg3qY21pwah8XDD7D906w+O7H6xNg8IleqkK46OAwz+u9FRGASVk09hSW7Bknb+v1GNUNsZBoe3g3GyhlnsePMGK6eVqhUHpPndMDqhZdw6pAjjEx1ULNOJXTt0QCODqEI9E/A5g23sGZDH7S1rA3bu4FcId252w7Ll3bHxDEWGDXpKO45hKJbx/osZrpu64/ElMe4fjcAg7ua4sa9QIRGp8HFJwbDu5hi6d7bOHXLC+fXDcX+ay5Ie/wU3qGJaGNcA7fcQ3HewR89zGvjsJ0nLjoHoEuDmjj10Bf2gdEw0akE52DBL7sgMa76ye+SwLQYavjd8XMsoQuIjBIBJc80QvHiRWRIqmDVRPnUkssST1GycZL9G/R7fFn6d97ze8l1JWQIwiuR1BYv+f5+EmL7IZEgQYJw3/wJxqt8yO5H9xErsbTC/xI8E8nrr5au8iOh11DInY70fV+5+l6oaarLlSSqooe4fz/R1KeqUFM39Ud5spOJTONqXSG+PXwcQjG53Xr2siQiSovEnuNb4ajbUkxe1/enIKIUpXlm000Mb7AA09quwfUD95mI0kK5efeGmLN/JM5GbMa2u/MxbHF3NGxd+6c8xlC3oUUPE0zfORSngtdj69156DXFChraKnj1/DXunXPF7M4bMaLhAlzefferRFBEXtv2M8duu7kcJ0ojWBsmH8emaSelx/IPoVdPC+vPTYCSugLH2RIhzRST/mRnSJfuGYwSpQTbp10rrkvHNug7Om1pV1SqooxH6blYN++9oKmFZS1YWNXmc936pVfZyokWDDNmt0ex4kXg5RGNe7ZB/LgnTWzDBREn5wi4e0Sjuo4a2rURxEW7Dj7g7uHgXoJa/sg5F5QqURQ9rerx5YMXnNHatAYqqiqwj/dNxyD0txQEUydsPNG/pbBgv+sdjpZ1dNmxxjMyEaa6QqfFPiQaA8wMcWyUYGlXkCj+R8nvshXidyWjbwUiSaa9b95J9ovijez14r6kgvpWJJ9FxRWnhJwWKyaQSunvykQDSn8nn+skv5fnOpHYfnx9/gVsijHk28Vqbb7PVXKfL1TOvn4pHBSLfYbgFuLz0BJnbSVOBt8TdLKh+TYCzeH9aFDbkEQZhAt77JAaL4Q0FOLfIyEyFQsH7sa8vjsR4Z/A7dc+kyyZhA6b15kTggoaYV4xWD1iH6vWj6y4wnOg1FWx6G2K5Wcn4Uz4JiaiREgptOG/BCJhJGoatqgbDnmtxGabOWg3pCm33snjee/8s/y8Dy65kKcC/Heg2No15yZiwIx2/D9sz7piRtctUneUD1FZVw3rz06AqmY5JMVkYE6/3dKwE1mV/ez1ffjvWZ91w/VTgnWTZCRs/vo+XLTwdo3C+SNCuh5h/AwrKKvKIzkhC4d2CiEaFSspYcAgwfh+9867ePrkJbS1lNGti6By373Hjr1Hhw9szJ1Byq93cApHp9Z1oaEqj6zHz3Dlth/6djBG6ZLFEBGbATe/WAzsICjmT97yQnszfciXLoH4tGykZz5BgxqV8O7Pv/DAJxIWdYTFvGNQDMyqV2az/YC4VOhpfj52tRD/bfyWZFSyMixW9A9p9ZMy6qX7Rf/IY1nDt4mXaV/2bxQp8r8PLr9/ST93Hfm9SSDNxP6gFS+97x/5t4P+FFe///tcJKT0Pl/YUhLFqD9jBvl/BUoagnAkOz3nh/gd0gmTEBWYgIKAuVVd1GtSA29fv8XprTYF8hh+JVCCz8GVVzHWYjWLXigtp/PwZjjkshiDZ3f47Iz4jwBV3aiNPbPjekxuvQr2lzzYy5hmlqmieCZ0I2buHo4GrWv/lPZR/wR0PKTnN2nTQJwMXo+JG/vzvCvN2J/fZoMh9eZi/8Lz7HP6JaBzQv+pVlh5ejzky8shMiABU9pvQKh3/t0UjcpKnNqkoqmIxOh0LBi8F08/qMqaWRhwUhNh7+qb8BetmwjauqoYP6c97x/ffY+z7CXuL9MWdOT9a+fdEeQvHEN69TVD5cpKLNw9fNCerxs4sBH7asfFZ+LGTV+Oxe4lWkIdOObI55jBYmLfqcvuXMTpZikY1x+55AqrRvpQViyDjMdP8dAnGt2bC4Eqp2y90K+FUEW99DAAXc0EQ/ybXqHoYCS4hFx2D5IWjgrxa+L3JKMiQSjyxx/v95lwvnt/vQwZpeqTlDCKpI5sRGQJpMTwXpZQ/pUPEZTYxv3xv89fJwvyc/ua62Xx4eP7O0iqrJKqayG+HhKRA496/IDozAo6wrwRiS8K6kQ9cIZwort30eOjBJlCfDl8H4YxCb2w6y7HMzZsVQt778/HmGU9oKj0ZSLE7wlybpjZYT3mdd+MAKdw7vq06muGHQ8WcuWwdV/zrxb5/NdAYxJkq7bXZSmWnJoAPeOq3Ga/uPMOhtafj7Nbbn1xQhkt4rbdmskRoVTtnNNzG1xs/D9dUT05lm3+okOSsXTEx8ET3Yc1QfMOdfn8tHraaan9H6F153po0romf67WL7goHQ8zNtVBmw51+Ty0ZeUNrnpSh2/iVIHYXr/iheiodMiVKYkhg4SUpaPHH7KDTJ/uDSFftiTiE7Nw934wLJvXhKaaArJzX+CqjR/6tDPiMbfgyFQEhqegt6VAOml2tEeLunze9Q5Pgop8GY4FzX3+im2gqqqXZz0HhdIolS3NcaEPQ77/2FMhCg6/JRmVEEsinRJfOuKLUlL4x//y+NURmZTe74MK44cEMj96mB/HlPUyltwuqXRKIKmoSgjzhygitv/fie38/CCpTLwRxVh/h5KiaIlW/IX4Z5CMV/B7JOMP+L1QTvSZLUgSqG9cBdUNK/Nzv3/Zs8Aex38VRCrIIH1u7x2crEa2TOTnuvToaFSoWvDtyfTETKwathfTrNbyOAgtWjuPssBh71WYsXMYdOtUxu8GKlKYtq3LJJxGEnTqVObj5uFllzDafDEHUnwJiGRuvDoNDVoaMEFcMeIAbM68b7PLgtT3K4+N5ihXSmnaOON0nu4LLQwnL+sG7erqyM58ijUzzkgLKzz7uaAjlFTKssr+yI670t8bNbkNFMqVRlxMBi6dcuXr6hlpo0kzPT737dl5l4sr7dvVRcWK5ZGT8wLnL3qwB3dfMRb06Cln/jmohzA7evqqJ9/eoUVNvnzquie6tqiDUiWKcSpTfMpjWBhV49vO3/dD96bCDOolxwD0MBf2r7gGobOxAe/f8Pox4R6FKBj8nmRU2orOvyr5YYv6axrWf+Xzm3/JEFsazubrZIintHopjglI71v0j8+STbLoILwS5zzzg6RKQRF5XwIFsfryLOf5Z2PsCvFpUBwggU4YP4KMSgRsbwo4nrN5F6Fl5343sEAfx38NNGc7teMmjo4kkD/lnvvz2Ky+oEFEhip+I00XweGKJy/G2w5sgkOeKzF2TZ8vjhj+lUHnCxpJ2H5vPmbsHgYlDUWkxGZgYe9tWD183xctEmkemBYfbfqYMvnbMv0Urh0W2uMfgqqoC/cM5aq0ww1fnNiSdzSGAg7mb+mHUqWLI8AjBmf23JfeRh6tkxd15v0rJ10RIrbl5RVKYeTE1rx//IADMtKEiurIsS25SurtGQMPtyjWTAwb0pRvO3/BHTm5L9C1Yz0oyJdCcmo27j4IRptmBlBVKsuzozYPgtGnPfmbAi6+MXj0+BnaNxHI5dk7PuhtIVRK77iHomVdXdZrBMWloYamMseFhic/Qq2KQufHJVwIYynEr4nfkoz+Lf76K0818y8ZgirhkJLWu6RqKZkBlbTvZa+TbflLyAm1Qj6uXr7Nl2RIFPgfQmIFJbGGyg9lRCP9L1V9li1fRvp4MlMef9HvFCIvyGOUoFxR6Ye8NJLP0o8gvn/XciSE+cT9sGzw/zr8XSIwyWo9ooMSeXaQKqGUcZ6fr/CPRnJMOma0W8ezkKQkJwP4HfaLMGXroEIS+olKaaveZtjvuhzdx7fhIoP9ZQ+ukrpY+/7t603f3ykb+qHbaCFSc/eCC7h6UFigfAhD82qYtEoQDp7ebgtHa8G0X4KKVVQwYXEX3j+1+x5CxVQ9QsMm1WHBbfm/sHXZVWknp3X7OqhZtxJXZw+IVVNNzXLoIpkL3XufiXLTJjWgq6uG589f49x5N5QqWZzb9YSTZ125o9e7s/A7Z656QFNVEU2NBVHSOWtv9GojENCHPlFQli+NahWV8erNOzj5x6CloXA/W89wWNQRqqbu4Qmoq6XxUeew4BKYvv1WiN/UZ/R/eUimsE8fdMn1vC875/nnX+9nRWVmTAnvxFlMEj3xZZnqpkRZ/1b2uuJF8PIFEU8Ztb5I/l59MKdJxs18/fPXfOD4sGJbpqxANJ+LqU6fq3Rmf6C+/NwBVU1LGYkRqUiOSuOIy0J8HaL8hNkmLf0KP+SlyxUjYwtarUy52nQCJsuarLRcKGsoFujj+dnheMMH6yYe47liGnFYsG8EVCr8HKlJDpc9OMudvIxLly2Fkct6oO2gJoXCxi8AdURGLu/JDgIbxx9GbEgSlg7YifZDm2H0yt6ftOoj0DF+xMIuXBCg5KY9iy6iWIliaDeg0Uf3bd2jIWLDUnHpwANsmnmaVfcUKSpBy0714OEQhgc3/bBh9jnsuDxJGgtL8aCeThGIjUzH5ZMu6DmkMf/vsdMsMXHIAdy3CUSX3g2hX6si+g5sBOubvjw3et8uCBata2HwwMZYuPgiLl/xQq8eDdG5vSFOnnfl2dGHrhHo0Ko2Dp9xRkLyY7h4RaNXOyPYe0TitmMwxvZrgoY1K8M9KB5XHwSykGnNCTtcdgjAtH7NYeMZhlseYVg+rC2svUJxyzsMi/u2RiuDyhi6EwWKNcHDUULu2zrNvHpasB2tnwW/ZWVUQjSJ4ElJ5l8y4qQ//+J5Ugmo+vmefH5ARt/mtXx6/eY9oZTYN0n8RmU9R2WrnaXKiBXOD7zmSoveoPR48qt+SlS1lCTyKZRXVZCaOX8pKtUQrIniggs+C/i/iICHYfzTwERY5X9vJIvCJcrZLkhQZUf6mRTjcwuRPxyueWPNuCNMRBu1q4t1Fyb/FESUFtuHll7EquH7mIiSj+0ep8WwGty0kIh+JaoZamHbvfnoPqENX7552B5T2675W/szIoXkmtBjrAVf3jHnLByv++R732Gz26OueTU+P6wcf5SdGGQxbmFnKKnJIykuE8e32UqvVyhXBsOnWPL+yb0PkCF6l1bX10Tr9oLKff82YU5UXr4Ueotxv8cOO3LBxdxMl6ujlFJIhJRmQ7u0FyqeZy66c4R2R9GH9Nx1LxjqV4BOZWW8ev0WNx8EopuF8D+u2QfCwrgaB81EJ2eiVLGiUC9fFk9fvMLzZ6+hpiiHJy9e4X9/Ad0aCir7Qvya+C0ro5L5UPI1o0og77/LSzhl7ZioskmzLHn9RSXkM68ZvmzFU9pml1FWkjExQZZclhIroJJEpff3Lc5zo/Tlf5rzPE82MUFBSYiGy34kVMbyg+QEl5H05S13nbpacLnh/UNM2381kIDB30EYtK9v8WMOnlEBQguOohQLGtJOWqE12GcV8+snHeORnta9TDB5Q7+fIsKTRFQbxx3m1jKh5yRLDFnQtcDHP/4ONA9PnRwaj3mUlIWcR7kcaUwKd4mbBYk9aaypjEIZPm6W1ygHdS1lVKim8V07ChRkMnJZT9Rrpo/1Yw5yzOikliux4OgY1GkkjLV8ipAOm9+Zu17WJ5ywbtIxlFMti1ofLHDpvZmzdQDGt9/IwRO7l17G1LV9pLeXVSiFSUu6YvHYo7hyzAlNreqgRh3BTL5Vx7q4fckTwX4JOLTVFrNX9eDrB49ugQe2QQj0jYfbwwiYNqmOLt2NceGcG5ISs2B3NxBt2tZB/75mWLr8Ci5d8USvng05iencJQ8EhSQjMDgJ3dvVw7lrnvAOiEdM/CN0t6yHdfttceWuP06sHwQlhTLIzHkG75BEtDKujpvOwbjhFIyOpgbYb+2GG+7BsDLSwxE7T9zwDEHDqgWfUjTH4OB3SWDaWJjA9HtWRmW9QqX7f8oQThnyKVwWrC4kt+Uln5KUJUmr/T3xLCkhnmIEKIGGymXz6AllygrzYc9yX350QJJXFA6UuWJevCwoeYeQlZ43kUMW1HInpMZ9ue1PDeOq/DPELfKLf6cQApyuebGtSwVddWgZVPwhL0ugs2B2TxYzBU1mJBVRReX3GdqFeI+0xCysHH2I5/SadqqPKRt/HiK6YvBuJqIkjJm5ZziGL+nx0xFROmaHeUbjwhZrrOi3DYP1p6GLykhMMF/Il/fMPIHTa6/h+t67uHPMAffOOPNme9wR1/fa4cy6a9g7+xRWD9qJyc2WoofmGPStMhELuqzHseUX4XU3AC+fffsZPmOLWthxfyFXS0ngOK/bZtw9m79iXvb4P25VL5hb1WFSvWzYfmkXRBaKymUxe+sAvv+dc+4fzY82bK6HFh0NucO2bcllaTePCjFj57Tn37tv7Y/QAEHMpKImj669hRnQI7uFOdHSpUugVx9RJX/Cmd+Hxo2qs7L+6dNXuHnLj31HW7UQxEkXrnpCTUUejcU0usu3fdGmsR5XTBNSHsM/LBkdmgoq++v2gejYSNi/4x6G1vWEWVG3kHiY19Di/YfBsch9XvCzlYUJTN8PBX8ULABIqqFvZchoHsL57h237CVzoFQNlc51SvPqRaIpks9S4iwOtS0+Ip4yrRMyGebrnr7Ko3AkPMn5mHB+rvopmcl7lJL9tx6UWak5XyxiMjCtxgeopMhUZCYXipi+Bjf32fHPVgOEGazvDVpk0EwafV4lSUwFhZjgJKGtV64MnyAL8XELnOIfqWpHM6LTNw+QHosKEkQs1o48APc7AdyNWXp6IizEaMefAbTgd7vliw0j96Kv9gRMarIY++eehuNlD6lYUFFVHvomumjSrSE6jm6FfnM6Y9jy3hi1ph9vtN9vbhd0GtMazXuaoqZ5dShrCl2jrNRseNj44+SqK5jXcR26a4zBbKvVuLzDBunfMFFMpWJ5bLg5C006G/FiZMPYQ2yY/znQQmXW9sGoUU8LT7KfY8nQfXiWj+1eHVNd9BorCJ+2zz+PrIy8iVCjZreHnEIpRIek4Lpo3USopq/JYibC/k02UpeXngMbcXJTNOXa3xc6PZ26GqFs2ZJIiM/EQ4cwfmxUESVcuuzJn6MenYWUJkpkynj0BF2sBNN7UtWTSKNNI+EYde1egJSMugXEoZKKIjSU5PHs5WtEJ2ehlrY6azciEzOgo67E52SHoJh//NoX4ufHb9mmLy6pgL57xykRUsIp90HOfLGiePv2Nc+5lJTaKAm3URavLPmUkNE8FU+5j4mnnLwgOnoiQwzlywlk9Gnuy49GBMqplEVsWMpHBxeCxFYlPTH/GDn+fwql2WokMyUbcaHJMGio87evj5xiGVSrp41w7xh42QWgzUDByqMQfz8rGuIeyeKDtoOb/ZCX6/4Fd/5Zu1F1VmMXJDzuBfPPmg2rFs4X5oO7590R6BrJ7eK5u4d+VsjyI3Fg0Xk43fDmzy2ZuFNL+WdAamw6buyzw53jjsiRsUcqLV8KdZrowcC0OmoYV0HV2pUh/w8DAWisJjYoEVF+cfzdDXwYhrT4R/B9EMwbVVqJuFoOboZm3RuiZJl/53JAZH/uwVFQrXQRF3fc4ShRegyD5nX+5HeGfmfRwZGY1G4DEiJSsWnqCSzYP+Kj+/efbAlP+1BEBSVhx4ILbP8kuY+ikhyGTrXE9iVXcGLHXTbGVxSPF0MmtILDnUAE+cTD3TEcJk1rsNVTt74mOHHAgbfGLfS5Otq5mzFOHH2Is6ec0bS5Hlpb1MTBQ/ZIS8vFQ6dwNGuqh7q1KsIvMBHXbvli2IDGqKRZjoVMdx1D0bFlbW7T27tHYPowC9Sppgn/iGTccQ1FW1M9HL7pjluuIbBqoIfA2FTc8YpA2/o1sNPaGff8Czt1vzIKflleAJCd/yTCKZn9pCFqyT5BSkCJjJYsnm8l9IXYgqdVJOG5jAhJTiSjlO37uSqovGJpPmjQqjT3A+GHsrpEgPRxK169kpJ0HvRznqCSWcKYoC+PizS2FFbLrjfyH5wvRF7Qe3d06Xnebz2wCcqrf38lOS1cbh935P1WfcwL9C2hx2InEmOKBy1EXlAl7ORGa97vP70d1CsL4zMFjfsX3XB5t2DjM3P3sJ+CiMaHJXMbfWjNGTi/2ZqJaHl1BXQZ1wbr78zDhaTdWHphGnrP6ADD5jX/MRElkFMAdYKomjrr4BgcDd2Eg/7rMHpdf9RuXIOPy0HO4dg0ej/66UzGvjmnkJ6Q+a+eH1XDaY502OJufPn0xps4uvJKHu/pD1FeTQELDwxH0eJF4XzLH5f3vfcOlYAWE9PX9+UxC5c7gXh4K2+Sk2WPBtDR18SzJy/ziJmU1eTRua9QCT+6w07qGNOtrylKlymO2Kh0uDqG83VduzfgkbTwsFT4+cZzh7BjBzHK84oQdtGlQ33+edPGn48LpKzny3YB0KuqxkImOsfauYShXWOhrX/bKQRWpsJnzzkwFqZ6lXnsPCAmBYbaGny9Z0TiP37NC/Hz47cko5Jq6Ks3b1FCJKO8/0HrvaR4+cXL1zzrwvsi2SwjKuCfiZVQOVH5/vTpS+lBpax8yY+qoAqi2jg76z3ppLkshfLCbGjWBxZMklZ8Rj7t8vJq8rxqppmetPhPHyB16wrpKBG+X24a3Fj0ifO44/fF7f3fGQ8ve3BllKpdfWd3/jH/86oXv+8kwGgqGs4XFJxu+nJykJxiaTQWT06FeA+KeExPesydjo6DhUjFnyFVafu0k7zfZ1o7NO3aoEAfT27mE2ydcAij68/Bg/OufFwjEeCS81NxImIrxm4ciDpN9L/rHCuRz4rVNNBtYltssF2A4+FbMGxZL2hUVeUgkItbb2GIwXRsHnfwX5PSXpOtMGZVb94/s8mat8+hRj1tjF4iENjDq68hXMY7VNYQv5eowt+z9HKeYzd13MbM68D7t897IC4y7f1jGdqY3Vuiw1PhfC9EOlLWsYfwmThz9CGf1+j81dpSIJcXz7nxTyKjNCYUEJCI6Jh0NDGrBkWF0sjMegYX92i0bVGT/3dweApiEzJhJbbnbzkEwcKkOo/KUSLTX+/+Ys9RIrB+kcmoryvM3IclZEBXQwlvC72LGdra2vw5/XAbP3483/7y5UveV1JSgpycHLp37460tPfvNSE+Ph7t27dH6dKloaqqipkzZ+Lt24INufktyaiUgMq034mAUkwZ4cUHrXe6LNl/Jqrgy4iV0KfisLuc6PlJGfASwiohnjky4iNqlxAeZ+atgJZXFVb3mWLyhQRqohqehA/5Hjh1hKjA+MjUTz7f6vW0+WeoZzS+FFXrVGaLJxLjPLwiqGsLkT/oJLV7xgne7zG1PVTFivX3BB2wT667zvudRrbkRUlBil+OrBUeS5fhzaRehoV4D/ur3vyzdW/TAn2vZLFr9mluEZPwbeCcTgX6WB6cc8EIw9mwPigIZkw71Mcu1xVYfWM2zDrULzAhFc159p7ZEYcC1mP55emo01SfBUC3Dz/AsNozcWD+mX+1WO8yphV7khKoOnrzcP4m9xK0H9QYjdsbcqV93fgjH1k5EXqPs0AFbRXOpT++5Xae22oZV4GZhQG/xkc22+Tp2HXpJ1RHT+578L462seEvbFDA5MQ4COQ327inKircwSSkx9DRbksi5kI16/7svaibSvBSeSmjR/KK5aBmZEgrrx1P4iFTORoQ1n1uU9ewqxuFb7N1jUMbRoKM6W2HuFoVV8QMtn5RMCyXg0Y6xa8W8jPAA8PD6SkpEg3W1uhyt2zp/A5mjp1Kq5fv47z58/D3t4eycnJ6NZNWMQQ3r17x0T09evXcHZ2xtGjR3HkyBEsWrQIBYnfkoyWFMnoy9dv3lc/iYyKM1zPxXjNMlIC+gpykkro81e8QiwracGL86DUupCInHKyX0jb74RsmdZ7eSkZ/aACKuaLPxL93iRQrywQm5RPVD61qgstjLjQlE8+X/0GwpwozYySRdSXgIhuq/6C0fKtQx+3hArxHrtnHOe0KlLQ95nZ8Ye8NDbHHyI+PIUrkV3HtirQt+PU5ttIiX0EJXUFdBstVGUK8R50vPBzFtqcP0PEJ8H7QTBcb/kxyZu6bXCBkT0iUyRMWj14F7fjtWtW5Irk0vNT2WLuZwG11hu2NcR6m3nYZLeQZ1Ypfvf8ppsYUXcWHC66fbbN/jlQWlO/GULFcufMU3CzyauGlwXny6/rCyV1RSTFZODgiqv52kmNWyaQj+vHnBAXnrdQMXSaJVcyXe+FIESmW9a1vxmPm8WEp/HsKKGckhxatRPGbi6KwqfKWsowbliVbdyuXxEWWZJWva1dIBdj2ovVUzevGGRmPYWVmE9v6xCCcvKlYVRb6NbZOoWijalgcWXrGirNqvcMjYdRNaEy6h+dgi4mNbFtlJAoVZB49e7ld9m+BioqKlBXV5duN27cgI6ODpo1a4acnBwcPHgQmzZtQsuWLWFkZITDhw8z6XR1Fd6/O3fuIDg4GCdOnIChoSGsrKywfPly7Ny5kwlqQeG3FDCVFEnni1dvUar8ezIqacVL5j7JyFdSDZUTB9dpRUlfNokq/smTF9J0JBr6fpTxBDk5z6GhqYhyYutdtiUvqYB+2I5X0xTa8enJeZXxmtpCAlJqQhavhmkeSBZValYALnkg+jMG9TRvVEFHFUlR6QhwDoeZqHD8O5Bw6fjyS2zxFO4Vjeri6rYQ73H31EPYnnjIB/fpe0f+kKpXTuYTHFlxmfcHzOrIIrWCQoBrJM7vFFbmY5b1+MgLtxCC2wUp6MkzWKfWj7H7+jucECvZHYY1h5aeEHLxo0FOHYt7bkaEdwx/f/rO6cwjLpI44p8VJGhaZzOPFf57Z53kpLqVA3agUWdjTNo2BIpi0MjXYODcTniU8hh3Tjphzcj92HR7Dqp8whqOgiWmb+6PeX134sZRRzTpWA91zAQSJ0H9JjVg1qYWz47uW3EVK4+Nlt5WqaoqLLrUh+0lLxzfbotVB4cLf1ehNNr3bIDzRx7i3CFHmDYTqpTd+5rg1hVvuDqGISXpMTQqlEOnLkbwdI/GbWs/DB3eDPUMtaCpqYjk5GzYO4SirWUd1NKvgMCQJNjeD0a3TvW5gPMo6yl8gxLR2lwPHv5xuOscigMr+7NeIzE9h7uQ1SupIDwhA8ExqahdRYPnRu39omBZT6igFiQWBo77bglMubl5u6IlSpTg7XMg8kikctq0acxBvLy88ObNG7Rq9b5Aoaenh8qVK8PFxQWmpqb8s3bt2lBTe+/bamlpibFjxyIoKAj16hXMmNVvWRktXVysgL56La1+Pn/5RmZfiN+Uk2nFU+VTInyi1oK82JYnQ3zK6CUoipXQXLH6SKtKQpYY10hQFr1BH6Xl5snvVhXb8akftOMpPYPUt2SQnZKPzYiOgdC6iAz8/HC3YVNhONyHLDa+ECTCadZDaN2QkKAQeUGhANsmHOZ9so2hk9SPwO45Z9irsErNiugwvHmBkqw14w7zAs2iewNuHxbiY1C7lFBORZ6rVgWNMK8YBLsJrg+9prQtkMdAlmTTLJYzEVVQLos1t+Zi0MLuPz0RlYBO/Kbt6mGv5yr0n9eFK8tOVz0xpuF8+NwP+kd/b9KmAWzP9uLpKyztv/OzyXr1murBSuxcbZt5msepPsSIeZ24eOHtGAYvByEVToJ+Y1vy4sjHORIhPnHS67v0N+M2OxnhB4tV08pVVGBsqiNUQi8II1smZrpQUZVnPYSjfSgvJtqKiUu3bQL4p6WFUA29fTeQhcItxOOjrWMImjXU5VnRmMRMpD7KhVkdYZTsnkc4WtQXvEnve0eieV2hAGLv/+UjZv9VVKpUCQoKCtJt9erVf/s7V65cQXZ2NoYMGcKXU1NTUbx4cSgq5hXQEvGk2yT3kSWiktsltxUU/vi9K6NEQMXq54tXKCuST/rSUXVUTqyMPn32ig8W5LFGyH36kv+GtC0vzgwpikkej8W2vJKKmAuf9UwaI0pklP4WKflzHr9vmWuIc4YpCVkftYcqSeZCI/IOIRN06wjtjtS4R5+NYDRqKRwYPO2+7kDZfYoV/3S85I740MJ40DxVnR6bOeXFqHVtJqM/AvaXPPDgojtnwE/ZMghFxZGTHw1KC1s6dB9n0GvV0MD41YIQoxAfQxqM8ZNYOd055cQ/G3c24nbvjwb5es5uu5o9QkkYtMV+MeqKi+X/GoqXLM4kevvDpdAyqIDHaTmY234tTq29+tVte/ouzzs0mpOh6HhOPqSyBYsPMXxBZx6NoXb9ObE7IQtNLWW0HyC4bBxedyPP31KvWB4WnQTV+5m978ew6JzVQowDvXTivSl/p56CkMnmui8nCpIgyUq8362bvvzTsk0tVsD7ByQgOSUbLZrocQEnJu4RomIy0KqJUGl1cI1AyeLFYFJXJKAuYWhhLFR2H3hGonk9gYy6B8fBRE8Y1fAIT5COzxUkltfahXV1Dn/Tjf4mISEhgdvskm3u3Ln4O1BLntrsmpoF0934lvgtyWgZ0abp2Yv3lVHap9WbpPr59PkryEta8WJMp4LoEZqb+4IJpeIHAqXyom9blihOInL6R5H/ceXosVgdpZWqhKSmySjkNbUEMpoc9+ijg5hkLjQ2PCXflk2FKkIrP8z3/Qo3v8oo/e/k6HT2qvtS6NTRQqNOxvyYjiy+8MW/9yuDSP/8zus5erBidQ3MOzb+h6To0Hu3dcox3u8ztR1qGBVM24qqMCtGHkRkQAJ7my4+PKqwPf8ZSEjoSxnbt4ICERLyFCW06i3kjf9I0OJtUfdNUiK64c58aP4EMY//FjTfuv3hMrQd0kyweVtyge2pXn8lgaLv04KjY1GsRFG42fjj8i7Bdis/lJEvhdFLuvM+kdGUuI87Z30ntEYpuRLsPep0W6hYStBrZDM+j7nbhyFGZq6UZkcJzvdDkCFaCjYw14WahgKe5L6Eg53QXbNsV5fJp69PnCBkUpFHfVEsa2cXxMUbE2PhGGVnH4I6+hVRvlwZPp9SRGhzE4GA2rtHonG9qlwpjU3OQvEiRaCpLI9Xb94hPesJKiorcCiNZ/iXWxN+L5QoUvK7bASKGZXd/q5FHxcXh7t372LEiBHS62iGlFr3VC2VBanp6TbJfT5U10suS+5TEPgtyWhpsVX29MUryImV0SeS6qdYHaXqp6QVnyP6hCooCJezJW14kYxmiRVJiTgpUxQnEUFREpNoMsRWHUGtglCNSJOZD9WsrMT/n4zvcz6ocGrXEMhoTEj+IiU9kZQEe346oaJ02ZKo01gYFHe++XXeoYMWd+c2jNM1T/g7CrYfv7NyfkHn9YgJTGDvw5VXZ3BIwI/I314+eDdXJGua6qL/LEHwUBDKeYqz9HEI5fnYZcdGQ0OMnC1E/lASxYmP03P59StIRAcmIjvjCUrLlUTdJp/ORv9e2DPrpLQ1v+r6LCiLwR2/Auj7MHX3CEzeOYwX/vYX3DCn/Vo8/Uy7PT9Qt0ti+XR4+SVE+n/akq9xB0PUa1IDb169xcEVVz66XaG8HLoOEwI4Tm2zyVMdraCtjMaWgur94iEH6fVVqqmhboMqPBp287zQludKaGehknrrqnD+UFNTQH3x3GMrEt1WYmv+7r0gJuUtRd/aB45CK7+pidiCdwlHYyMdFPnjf4iMz0DOkxeor1+Jb3P0iUbjOkJ7/qFfNBrXEv6Ha8iXWxP+Djh8+DDbMpEyXgISLBUrVgx2dkISICEsLIytnMzMhEUG/QwICEB6err0PqTIJwJsYCD4vhYEfksyKm2/U2tesi/m3sqLKnkiowpSMiq04cuJQpFssRIqEShJ2/JiHjeJmCSgnF9Cesp7lbyGeABOSXycp3qiKoqYEqLy5g9X1RdK8NEh+bfJKfFGIib5HBp3FKPaRHPiL4W2QUVYDW/B+9snH/2swf6vXhGluMBQjyiULS+HVddnQ11bGKH4nqATyPpxhxATlIhyqvKYd3B0gaifqaq1fMQBuNMMWMliWHp0NHsfFuLzoPeMXA+oQxIX9mnXix+BEI8o/qnfUOeHj3h43PGH9YF7vOiefWTsL1ERzQ/thrXAyuuzUEahNBvmz2q7Gtn5JOh99m8MaQazdoKFE7XrP7WIoddy9FKxWGDth0C3j88BXYc3Q5myJREblsqCJll0Hyp43tpb+0tnmwkdxWx6myve/BgIbTrU5f8T6BuPxDjB3aVNW2FO1M42kMknWTzRzGlCQhaiotJhbqLDeouklGxERKWhmZkwN/rQLZIFwnX1BJGWo2cUmtQTzmNOvtFoIs6KOgXEwLym0Kp3Cysko7LnBCKjgwcPRtGi77/HNGs6fPhwFjTdv3+fBU1Dhw5lAkriJUKbNm2YdA4cOBB+fn6wsbHBggUL2Jv076qx3xO/JxmVVEOpFS+ST2oJkNWT5HLO05dQlM9bCVUUK2BZIhlVEtvyj8RKqKpEnCRDRtXEmaw0mQQljUqCWCn5A7umSlWFdnt81PsVC0GHFPNEXuMy882vr20qtDtCvWOZMHwKjTrWYxIT5R+PhHxa/p/DkCU9uZoRH5KEs+uv4XecEZ3ZZqWUiK61noMqtYSV/PfGgUUX4HzDh8UdC4+N43jXHw2yBFvQfxc87wXzwmnJkdGoK3oLFuLzIMKgV18g7f7OEQX6csWFJPNPHXHW/EeByNTOqUd5v/O4NjCy+Dksrr4XDJsZYIPtfCiqynPU6Jx2a/JEmn7JZ2bylkF8zI0NScIZMb0rP9DMdtt+wmwoWT19OOZFEdQdBzXm/XO77fLcXqNOJRjU02LCefOsYGJPICV9OWU5Hi9zeRAq1TvUNxFIou1NwX7KvEl1lCxVDMlJjxEaksz+26YmgpXgffsQlCpZHCaiC4u9UzgMa1bicywVeAJCktDEWLjvQ88oNDYU7ucXnoTqFZVZYZ+R/QyKpUtxhHf64/dC4N8dd+/e5WrnsGHDPrpt8+bN6NChA5vdN23alFvvly5dkt5epEgRtoOin0RSBwwYgEGDBmHZsmUoSPyWZLS0ODNKZLR0yWLcKsivGqootuUfiwRQSSJQEtsuStK2vPAlIXXhhy15dbElnyrTkq8gtjUlq0sJtKsJ8xqyyRgE+XJloF5JqKZG+H88N1OhqgoLEd6+fotgj0+rDhWUysKopVCGtzsneI59zSzT2A0Def/UmmtMyn4XUEt+crOl0tY8eQ3+KA/EC9ttcGmXIE6YtmMIDBoKB+8fCYqbndltCwLdonhObcWpcdwaLMSXw7i50K50vZN3bu9Hg3LXCZrinPmPgs0Re6REp/P3Z/BiYc7xV0fV2pXZM5WeMx07aLyHQga+FIrKZTF+XT/eP7f1FvtEfwr9p1nxIpEKEm62eaufhM5Dm/Lt4f4J8HPJWz3tJIqcbp3zkFZBacygTSfB4uf2ZS/pfS07CI4ZdrcDuNJPYTDm4qL0nq0gjm0hftYdHMKY+DZtJBRLHJ0jeC7UzFggnc6eUWhkJBzP/MKSmKRqa5bHuz//gk9YEoxrCIt97/BE1Cs0vM8Dqm7Sa1u9+scFgZIlS7JnaFZWFp49e8ZE9MNZUC0tLVhbW+P58+fIyMjAhg0b8lRYCwK/JRmVkM+37/5kr1H5MjLVUJGMZucSGRXb8rkv+ItHw9cEijkjKIuZyBIyqiq25LOynuK12MomTzZCioxlU0VtgYwmfTBwrlVNaFvF5GNgr1dPID+hMjYcsqvo+k0FcuDtIKxiPwWJaMH2tDMniXwNmvcyRdPuJvx7NJz/OfX+rwLn616Y2mIZMhIzWay0+f6iH1YRvXnEHgdE0djwJd3RoocJfjQi/OMxpeMGxIamcPzsuguTUEuc+yrEl8PcisQe/2NCn/YvYyT/DbLF6lw5cY71R4CcRM5vvsn7fWZ15jz43wWVqmtg7a25XOEM947Bin7b8fbNl485NelsBJO2dZkk7ph58pMKffKS7ijOhp7YaP3R/Sj5r3UPofV++aB9ntsata6Jcspl8fjRE7jce2/9Z9lVGOvydoliK0KCaZPqnFefnpqDIDGOtGUrYU7UwT6Ez5MmDXW4VZ+U/BjRMRkwbaDDM6dxCZlISMxCIzGExckjChXVFVFZsxx/Rtz946QWT67+sTAV2/OuQXGwqF8NLQ0Ljzu/Mn5LMvr63bv3nqHP8lZDJYr57CfPUV5BIJ/0Rcl9+kLalqdECYKyRJwktuUVFErzfAwdByTVUc2KYkteZj60oqicJ2snWUN8HX1BqBQdlvLRwUTPUPhihvjE5vuc6osGxR4yB5P8YNrOEApKcshMyYb7V1Zp2Atv+1CokfVIbAbWDt311YT2vwJ6XocWncPSXltYPFS3mT4T0R8xI0q4fdwR26cJEaM9J1mi56Qf7wdpf9ULM7tukdo3bb4+HVVr/hym7f81qGiWg2FjoYpx64RgrVQQeCV6IpcUZ+V/BLztApEW9why5cqw2vx3Q2W9Clh+eQZKlC4Or7sB0ujgLz3mjlvbl8VRAU7hcLj86Xn/nmNbsatFVGAi3O9+bOHXZVhTQT1/L5jtoCTgKmh3gXjeOucuvV6zUnnUqq/F56J71kJbnqqrjVsIlc/7d4T/Ud+4Cic3ZT56iuCgRK6WNhBV9I4Pw9js3rC2sIB3cotEQ0NtJqcJyY95MzMUBUq+MTAVyahbYBxMDIRREr+IJHQw0cfSwZZf/LoV4r+H35KMsm2TpBr67H019PGTFxxVxvs5z3l1J5khJcW8stiWfyRWQtXEtny6OJxOX3TJjGhqitCWryD6h6alZLO3KIGyuyWJS/HR6XmSMejA8Pzpq4/8Rg3EL3eIV2y+3nNGzfTZe5IEEqn5mONLQKbbbUSz5OsHvj7ms2y5Mlh0ZjIfHD1s/DkK85/G4P2soBMniQ7Orhfz1se1YeUvjSr8CFA+9ZbJgoVT51EWGPaD25q0+Dq8+hrWjDvCnoLGLQ2w8epUqP5CyueCAOWKE6xPOOHFs48zxX9VUO48oUUvsx+SUPYzooZxVcw9Op7PETf22cH6KyKW1SopoddkYTF6cOnFfA3uCfLly0g/Y+d23PnodrIAbCASyRsfLIja9hB8RH1dopCW9L5wYiF6idrd8JMe55u3FiqhjveC8e7tn+y3bS5pxdsLnTlJVr2zOCNtLnZTXNyjBOGSvqCDcPOOgYmYTe/mF4u61SugeLEiSM96iv/hf1AtJ8d6Dv/IghX+SfDq3avvshXiNyWjT168gqJEqPTsxfvW/JPnUJKIlMQ5UUlrnkRLEjJKgiYilhLB0pMnLzkilEAxoIQUcUa0vLIcD3hT+yJVxldUS2JkH513hVpVT6iORgQmfaSop1XvsycvuWWaH0mUqOpdxASMT6H9sOasiqR86pjgzyc35QddQ23MOjSGD6zX99rh+Ir3w9H/ZdDB1vbkQ4w1mY9ApzC2w5p7bDzGbhz4w5TH57fZYPv0k7zfZbQFxqzuza/zj0JO1lMsHLAb53YIc6o9xlqwWKnMb9Ra/V4wtazDhOBJ9nNcP/LeSudHongpwdbuc0LHbwlaOHvcEapqTboJbeLfFWYd6mPI0h68v2vacU5w+1J0n9AGyprlkJ6Q+dkiQteRLVC0eFG2+Qt0/3iuv8NAoRBx94JHHt9bMsGva0J583/h3rX31n9NWtfkokxcVDpixNAVwwZVOPqaOnv+4thYI3GG3EmcEzU10WUP0siodKSn58JM4vgSnMQhMib1RQLqG4N6BkRAiyIj6ylSM3KZkBI8g+NhJM6NeoYWvMcoYYrvFIzxHvNNN/qbhfhNyWjOUyKj76uh5cVqaFYutebFfVGkpCxRzGc95RY+rdr4cuYTVg7KyQntrlRRLS8ho2QCTCAiUbGyUB1NiH0/K6atK5BRyRdcAl0x3jMiKC9JJBW8gZGoyHXLXzxkZinYbDjf9v/s81evrIxGHQXPuIv5rKC/BI27NGCSRji56goT0v9yhTQ9/hGbcW8YsZe9RPUb6mKn6wo07ynYYfyIk/b+RedxcIkwI9prihVGr/qxRDTEKwYT2qyVeojO3jUEwxd0+SGG/r8D6HXsPUloNV7YdZcdCn40JNX9r1F2/xskhqcgJ+MJt6gNRNeP3xm9pneAaft6ePPqDc/dv3wmWAr+HWisYtDczrx/dsstPBNT//KbHaVoXsKV/R+TVqOmNaBWsTye5r7AQ7H1LkGrLkKr3u6qt/RYTkp8Y7Hq6SDaQhUtWgRmokbBSVTaGzesyhVSOg/GRGdwIIy+WP1094hGBY1yqCjOhnr7xaGhmDPvG5jAx7i6eoJ9oWdAHIzF9vz/2bsKsCjT73v+uwYGIh2SBhgY2N3d3d2u3atr6+oaa9fa3d3d3YEiSHd3iLr7+z/3fu83DAMoMWDAeZ55mBmGYRjm+97znnvvOY/feKJySYmMPnX8PshoDjIP2XKVCY+NU5BRqTdUlOYj46CrLfpChX2TnlBGiYzSQaMvpyeJ0ryRXJYPkMhoEVHKJKsLGWZiYMnLPaF8biUm55WTLwg25aSePMdXSRXL8jWkk8KLu+9THJIgvHnoglDxelJC59HSonjt8EPOiU4P2o1ogsF/dufre/48jnXjd/1wPaRkOXPo7zMYbDcVj86/YPuk/nO74O+rM7LMB5Few9LhWxUbg0FzOmPgrI5ZRkRp4Tn2zzWemKe8+SJFDbg/tH47aXHKgfrQsGNlmJUwYnX0wOr0bQQzAj1jqYedFLaswHvR407VlB8ldz4zQfHOEzcNZZXT+70/Nk8/kOqfbdStOkxLGCEyNBonNyWYmqui/eD6/PX+hVcIUBqclX9/s67SIOTFQwlWTvIgU958ueHjEQIn+4T1p25TyRj/9mXJyJ4fW1+aUbh38x3fR32iFSuL4SNRmq8m1NCHQqGtJqboHz11QzELPegUzo8P8Z9h/84XlWwlAvrE3hOVS0sE9Pk7b1QUKukbN398+MaBEYSVFVZiY8WNar3Qc+Ygm5JR6hOV1VBJGZVL8zGKMn1UzAfEf/wMfTExHyS8RA31pdJ8QKB020hMpfqJHlETMT3v452UjHooNY0XtRFk9H1Aoh5Q8n2TlVFVYle+pkRGXz10Tpb00Y6X/Azp5HD7zJdTlmwqWqFi/dKcsrFvmTTpmh50mdAKvy3vy9dP/3OF1cUfYcqe3qM7Jx5jaMXfsXXGQR7ssK1lg/UPF6DHlLZZZiofERKF6R1X4PqRR/w7J64bwANLWVmWn913IzbPO879X3Xb2GHVuUmwEkELOVAv6H88eIakcJ3cegPeKp7CmQ0T0R7k7ZK4IpOZyijBQqhkOZDU6Ymbh/JbQf2jqU21o8+OnLx2fMMVHqxMDpYlTdgDmFrDzu2+k+T7jTtXkczrH7nCT8nrmtrAqoue0lvnEqpr1erZ8EaCSKq7s/R5rVi1KLefBQdG4b1IBqxWQ+oLfSiso6qJqflnzz24ra2qqOw9fubOG+1K5aSh3KevPFFZkNEXDt4oYa7HlouRMfGIjfsEQ+2C7Hzzxj31MdaZhby/5s2USw6yKxmNjoO2ZtLSfEhELMeBUv8KITgsGvpiYj5QlLUMDSTyGRAoyvLCgNzPXyKjpsIP1NcnlE8GBAvh6eeh1B9KE/V58uZCXOxH+HiGJjK+L1hIA/Fxn+Dq6J/E/J6y6OOi4/HuRfJpFPVFqeX6F6YuZfT+vS1/vXLgPnwysDiRQjpj3xgu7T659Aojq8/g5JHvlYQ+vfoaY+vOwfweqxXeh5M2D2WTapp8zSqQmfW4Jotgf/89293MPzgGTXpInn9Zgee3HfFb40XswEBZ2CMXdsXvGwbk9IdmMqo0KsNDYWTXs/6PQ1na3mIpSKGbkvKVmQjykc5tBuY5kbHKqNjQFi0HN+TrK39LOWFJFXXbV0GRYga84T+3M+W+4zb9pWSlSwceKLxDZegbF1ZU2a6ppPHVaylV126xj6gkktCkfMUaErG8J9xaaO2qLMjngzvSub5qdem2w1sfREbGoXhxQ47MpnmKt299UM7WjFtVqIro6xeOSmUlAko59dZWhsifLw/Hcrt7h6JsCROFAX4FoY6+dE7ZZzUHPz6yJRkNJ2VU7g2NjIWusHAKCY/hHZueiPkkMmoglNFAMUFvJLxE5bK8iaJHNFxRts+V6xfEx39GoHiMZTGRrOQWxD0z8i63qLWkjjqLVBS5jFKyvHSQvnmauMGdDmQ7YQ/z5Ebyu+m6bSvyVL3jc4+vqi5koF61aVlWR7fNzdgQUp0OVdj6yLioARtrT2qyAP9M3Zfi7j2rQe/7vVNPMK7eXExvvQSOT1y5j63n7+2w9dVSNOldJ0v7M++dfY4Jzf6Cn3sQjCz0sPzCVFRskDW5wBTnSjnWf/RYx7ZNZsUNserMJLTul7XvQXYFvccj5nfmSFXaEFw7KuV/ZwVKCIs4T0ffFPsO1Qm5SpJVThQ/EgYv6AYdo8LwcfbHkZUpJyyprgGdRzdXqKMpeZZWa1KWY2jJV/bh5aQDrQ2Fh+j1Ewn9oYRKtUuwQhrsHwHHlwl9mjVEWf7BTceE3yF6SR/ddVZk1Vta6bMI8/SxG6uvFUXy2JNn7kw2S4ve0KcvPWAn7J4cnP3Zl7u8EAJIHbWzMVWU6u1KSNftXb+PifocZA6yJxmNjoWuKNOHRMZAT5TmQyJi+MDUF32jNN1nKJTRgODIRGV5f+EjWsREO9HA0q+5fkERU0kd9RQlEBNTHd5JEkFVzqMvUVo6MN+/TbzjsxU2TvYqZJRQRaRbPLqePBnV1i+ESsJz9NJByVLlSxg4S+Qan3mG1xlUMymVaN39BWjcqzafkI6tPo9B5abg4q5b36yXNDIkCkdX0euYjLndVnFyFJGA9iObYefb5eg3u3OWmnATKd6x4Djm9VmP2OgPKFfbBquuTFcoVpkNDyc/jG/zN46IWMAWvWph9YUpsBKDcznIGphY6qPHWKkd45/ZRxGWxuzy9IKS2owtJcLwNpkcc3Xjo5jYpo1fDhKDsuuHLJR67g8sOYVgoSKnpne0sL4mgn3DcPd08u1Y5MzSuEtVhTqqiprNyvKaRH6jLm99Eln/VZP7Qa8keFZXq2vDmyhaq2QD/MpCLXVy8EWY8MuuXEXqC332REoCrGgnkdHnone4ohBanr/0hLGBFgz1Nfmc+MbRV0FGX77zQQUbcd3JF+WKSQ4zDu5Z01qSg2+D7ElGoz5AV+4TJWVUkNGPn/7liFBlNVTuEY2IjOMGamO5R1RMzyvIqF+4oixvLuI+vUTcJ+1mLYtKvVquSlGfJeTJeaWTAaGM6K2xf+KWpIRHsYJ0UnB964Mg0aeqimY9pJSlK4cfJSnRqMKydBE07yuVdDb8vj/DpJHiIidvGYYFJybByFIfIX5hWD5sM/dmkrfeh9jM91T7+OEjJyct6LUGPYuOwabf93E5vmDh/Og+pS12vVuBEct6Z2kKDSEsMBJ/dF6JA8vPKaybFh4dxzGtmQ0quVGP4pgWS9kUmyJmZ24djDFLurPvbQ6yHp1HNOYQARpmWvP7wSwr19MGiPDs+pcDMtSBHKX9y2jQvSa7DFDP+u4/j6fqPSXC2EqEB5zcfC3FxzXtWl1RRZOTt2TkL6iBKqISozpVX6ORdL9yGpO2bkHY2Err1WNRltfV00QxUd17KhxeKlaRhJSnYu2qWFEkBzr6ISYmHnblRG/oa6nNjLLqCS/feqNCSVNFNGhJK0OODiWBKF+e3CigkQexKfir5uDnQLYko6FRMYrSfHB4DNs1yeb2pIYaiJJSYEgUChbIy+UFeYLeWEzPU88oNVWT1yj5sFGDtmx+by4SljyUptSthJWTq5KVk3UZmYz6JSKB1mVNedcaERoDT5VSO8W6lRIH+MOrSVM2CFUb23KuMZGfh1eS5hSrot8f7Zmoudp741QydiDpQZVm5bH5+V88ba+pU5AnR1eN3IZexcZg9ZjteHnLQa1qaYhvGHuELuyzFt3MR3Jy0u1jj7gkXbyCBcauHYC9zqswYG6XLCehhBe3HPBbvXl4cdOBVaKpmwdj+KLuWeJfGugTiund12HjLMkwu3KDUthwdRpqNpf6w3LwbUDq1cQVvfgrTT5fUZluzixUaSxNRz+89CrTCTBVIZSTn3KQlKwPFuropV234P0+daXolgPqcasXqdvuKmKGDNPihihR3pzbsG6dfpbk+7VFf+id84k/B5XqWPNn0sc9GN5KQ7dV6kgtYo+V3FwqVxdK6ANJCS1bzozb1AIDItlrm2YsqJWNhJrX9t5cpqf0Q4rUprjQcqUEAX3rjZLFDPl7FDgTEhYNGwtpzXzr6o8yVomz1XPw8yFbktHIuHhoCX/Qj58lNVRfqKNByn2ioVF8sjAS5vZUmiffUSKv//73PwQFRbLqaSKGmLxEapKFpRhYckuwcpJ3kC5KVk5mVnrIXzAvmw97uCQc9OTXVlpk0b9MxlO0msgCvpeCuT1NPjbtLu2Kz+68/dX3g5Q5KtcTdi48kW6rJ1Xk0cjD0/a73i3H0L96slIaHR6Ls5uvYUqzhehq9hvmdVvF1kovbr5FqH/4VxdHKumQLc3z629wfO1FLBm0EQNsJ6FnsTHsEXrzyEPERn1g65SOo5tj3f353DrQclBDaIjUrawE9XRRWX5ahxUIC4iARUkTrLk6Aw06VcsaE/+DDzCi0SK8vOvEA2Y0pDRv9wj2I8zBtwcpo30mteTrG2YegZ9Hyulp6kLFBmV4YM3XNZCH6DITFAFKiAqTeu5zkBRlalijWssKkrPJopOpbreoLjaTFB2cEhp0qMxfbxx/muR7VRuUQq48v3Kp3lOpYlegoAbKilaxRyJRiSAPLL145KoQEmiqnvBcKKFk8VRSVPyeP5NK8+WFGvrqlSfy5smFkjZS2f3VGx+UE+1JDu/98cv//R9KCju9V46+sC0hPe61sx9sixqzv+m3xod/4zPlkgMgWxq/Ed+Ji/8Mzfx5mYgGR8TAQEcTLt4hTEAN5Al6YedEvS2uHsHwC4zg/kojIy14eoXC2zeclVKaoPfwDIGXdwhn8lpaCSsn92A+QInQFrdJSkaJyJa0NcWzBy54+9JTYfdEqFCjOF48cOF4tra9Ek9Y12pWDtsXn8WrB86ICo+BpiDSymjZpzYba9OABPUJWlhLB3ZKaN63Nq4fech9oyvG7MSi4xN4mEodoJ7MTmNboMPoZkwirx+8j4fnniMyJBp3Tz3hiwwiTKRckppK1+n9plaDuJgPiAqNYUKXnKJKjytWwRKVGpdF9ZZ2sKlSVG2vP70gh4Ilw7bC8Zkb327epw4nKmVFLniIfwRWT9mPR0I9L1XJChNX9mYP0Rx8X+g0ojE7Gtg/dMHikTux7Pg4VqYyC5QsVrmRLe6fe4Gbxx7DqrSkTmUGaECHEKzku5yDpOjzR0c8PPcC1w/dR99ZHWFk+fXjtHmf2tzrf/XQAwyc04nL96qo26YiNs89zoEWQT5h0BfWg3Kp3q6WNR5fd8CDy/awEN7XhCr1bPD8vjMe33RERzGZX7y0CTS18iEqIg6O9j4oXcEcpcuZIXeeXxESFMVtaeaWeqhgZwH7V154+dwDrdrYoVxZM5y/8AqvhIND2dJF8PqNN16/9UbzxracXR8V/QHv3QJR1sYEr518Ye/ki/K2VMJ/jjcuflgztTO61isF/R2/f9OPz9AnvyN3AfW2NX2KyakaZFtllBAcGQP9wmJQKVypNB8WDUNd4SUq+myUlVECpUkQfPykE6yZqUhYEhZNpma6+OXX/0N09AcEB0nPUbSEIcejkS+b3OxNKCV8Rd8qTS4SKojmcFJGVckXRQpalTRmX8h7IhUjOc/R6s3K8vWTW25+9f0g4jZ+dT8uIb+87ciTmuoG/Y5Kjcpi0qahOOC+FqtuzsbAeV15Et/YyoBJO8UU+rsH4f0zN47kfHX7Hd4+eA+3117c4E/vBZWnihQ34ni9PjM6cH/qYZ8NWHt3HpfhS1Ur/k2JKG1Azmy7wWV5IqIFtfJj+rZhGLeqb6YTUfrdV488wvCGfzIRpWjAAdPbYunxcTlE9DsFbUonre7L/daOz92xJwO+v6lFfRHNee3QA4XDR2aAqiEEP7es9VP90VCiohVvpEkdPbrqQqp+pmLDMtA1LsyOBY+TmZgn6BppobTo47x3IXFvKKFaI6nK9kipP5RQWZTkaYj2g2ixoM9peTGg9FxU7PJq5EbpsqLU/kRSQstVkJTQ1y89+XxUVkzNOzn5IT7+E2yFcmr/1odFhDJCKX3j6IfSxcV1UkOLSeTYySOIq5Gy5WIOfk5k2/8uqaE0Re/qG4Kg8BgYaCeU5o2EMkpWT2R8T8oowTdAeIkKOyfqeSFYiLhPD69gRZndzEyXlVFXl0DoGxRir7Yi5rrw9gjBewdfVBW2GKUqCDKq4htKsaAFtfIhOiIOTq+9UUqU7WXUaVkBbu/8cPvsC0WihiraD26Ae+df4cqRh+g7pRX3kX4JJkUNMHRBV6yZsAc75h9HuVo2CisYdYMIZcmqxfkig7z2qPcz1C+coxJpEpd6jcihQKNAXmhqF2TVlE7AWWVKn1YEeIVg5ZideH5TcjuoULckG9nri2SuzASlJ9EgzCPRJ0z9YhNX9IaFONnn4PsFbR7HLumBhcO34dC6KyhXyxoV60pTzZmB6i3K8yYp0DuU+5grNZRIibphJioyXu9yPCK/BmppenrlNS7uuol+szuhYDIVL2UQOazfqSont1FoRq3WUsSzKmq1KI83j1x5LWg3SEpnUnVneffcI1GVzdRKH/rGWgjyi8DrJ26oIuI/7aoVxZ0rb7hU32tYA76vfCVLvHzqwTn1bTpXRqnSRfi1BQVFIcA/AsZGWtDRKYDQ0Bg4OvmjjLB38vQO5cHgMtYmePDUDW+cfDGsel3+nqtnMAfTFNbMh/CoOLz3DIKZ/pffj6zApsp/oVAhSZxSFyIjI3ES25Ddka3JqKyMBocr94lGQ0szH/LlzY24+E9s6WRiKLxE5chPE4lYeInSk7lZYmWUULSYgYKMyskU1qVMmIw6KZPRcma8O/T3CUNIYCR0hQrLnqI1iuP2hdd4fNspCRmt27oCdi0/j+d33yM8JJoHm1RhW60YbOwsWW05ufUm+k2V0ju+hJb96uLpVXvcO/sCC/pvwNrrM6Ep+r4yG1RmIoWULj8aaFr97Pab2Db3KIcSUIvBgJkd0HZow0xXaUl9IPsWSlEi70hSQ3uNb44uvzX+bkl7cn9DREg0vFwC4eseBH+vUHaLCA2M5EE+2pyQQkMbls9UKfiftKEhZYZ8ESkMgo4BXUMtJnZUPTAvYchff5QYyjpt7NDyTi2c23MXS0fvwtqLU1nZygzQ57NBl2o4veU6zu24lWlk1FJMS5P3MCl4WXUu+RFRoX5pWJYxhfsbb1zecwcdRn09iU0mo48uveJeeWrBUEX1ZuWwae5x2D9ySfI/MCiiDQtrI3g4+ePZHSfUa23H91OVyq5GCVw69gQv7jsryGj5qpLK+u6VNx+LdM4uJwZqXz/3UPSNFi9hCMd3fnjz2htGxoVhW8YUt247wv6NN5ftKafe2zcMDqSGig3LWyc/GOpqsgd4aEQsnD2CUMrKEPdfueOdWyDM9KXf/S2h8WtevqgTH3MSmBjZvExfIEmZPiBEDC0JSye/oEiYiAVBJqNmou/GW/jCmQtlNCQ0GlFRksl70WJSI7arUrKRjfAVdVTyFaVmcasS0mPtn3skWyp5cjvBaFgGLbIlyplxWedmCl5z9Hd0GdmYr5/ecYsX9K+BfmbC2gFsxB7gGYK/hmz+4fLmsxoe73wxqdVSrJtMJv/xKFO9ONbfmoX2wxtnOhElJfaPnuuxctI+JqLWFcyx9sIUdB/T7LsmokQ0SdXfuug0pvXegO6VZ6FHldmY0n0dVv5+CAfWXcHVY0/w/I4T25gF+oQhMiyGCennj/9yHzG1dNB9lL/tbO+NJzffcd42bdIWjd6FEc2XomPZaRjTbgXWzz6GW2de8Mbte8bQOR05ipWseBaP2pGpx55sD3T//AsEqWSYqwtEfOTNpeOTpMOYOUh87m09tBFfP7f1WqqcDoqXM+eKFrlkECFNDsYWelwdobXiqajYKKOy8KV+eivxOmNXU2oVe6E0REvVPR19TXaPefda6gG1KV2EJ+hDg6PhL8JfbEX72RvRJ1paxAs7iICXUqJa4+Doi1LFjRTra2TUB5QS5fm3LgEoaSmtje9yPEZ/evwYkkEmKaPFDHUVfaJGcp9oqOgT1S8EN+8Q+AdHopyNdCBRkzVdzETJ1ddfsncqUCAv9PU1uSzh4REMW1tTFBNWTi4iy1eVjMqDTYSylSzh4uiP10/cUU/0eRIq15F2o+/tfRAaFMUnAWU0bF8J71954fqJp2gnmsxVUaNZWZhbG8HTyR+ntt1Cz/FSeseXQOW7mbtGYELzxXh67Q3+mXEIIxZ1z/EMVAF5ppJn6JE1F5kc5SuYFwNmdkTrQfUznYRSn9/p7bew46/TTMrIQqfv5FZoP6QBq+rfI/l8cdcJL+874/VDFyaXqqDjwdBUmzdaRua6HFtIU/9aOgVY+aSBC1JiaOEjfP78Hy/CsTTcFhaLsOAoblUgVZUmhD3e+7NaRMcIXU7vknK6S5Q1Zb9eMv4uVrrId/W5JsVy+saBGNNyKV7fd8bupWfRf5oU26tukMdw+To23CN+ass1DJrTOVN+D/loUs8oRQRXblIuU37Hz4KG3Wth87T98HznC4eHzvzefQn02a3TrhIOrjjPw0yklKYUQevh6Icn196ifntpwl6GXW0bHN18Ay/vvk+0LpWrKpFRt3f+PLREw0v0PVs7C9y6ZM/iSbnKVlydKF7SGO/sffDmlReMi2ijjK0pjh56hDdvZDIq9Ym+e+fHv4PI6OXrb+H43p8HmEyNC8PbLxyOrgE8UX/3mStfrysiRh3dc3qOf3ZkWzIaFBGDGjZSeSEgLAqGOhLRi4n7iKiYDzCWldHACOTTyAMd7QIIDYuBt18YbIoZIa+cqOQXDjNTHVha6DEZdfeUyai0o/P2CsGHD5+goZGb7Z2IKISHxiDALwJGoveUDugT+x7glUriEpHPEmWK4P0bH1ZHm3ZMfBKhksrmP0/B8aUnvFwCYCbUWGUQKeoxrjkW/7YDxzdfQ9uBdZlsfg3Fyppj8oaBWNB/I05tugZDU110GtU03e/3zwQ6mT44/xIbph1gmym5B2/k4p7QF+lbmQn3d75YOWk/t18QbKsXx7ilPb6rASVS9N4+defBiMc3HLgMqAyKrC1aygTW5c1RwtYURUsX4bK6Og346f/k5xkCp1dePE1MJJj6rN+/9ubL/jWXYWKph/ptK6JRx8owEWEV3xrkDzluWU8sGrEdB9deRslKVqjeNGGTqk50GNGEySiV6rtPaMVDVOpGubolcXX/Xby48Rb9Zqv96X8q0Ptfu30VXN13l9+zr5FRQo0WFZiMPr36hn2Vk2tLoc0Xuas8u/UuEeEklKlixe4Ngb5hfLzIxwGtP0Us9dhv9M0zd1RvIPWX2laUyOib5wlzDjTERGT07StvNG5RjvtGCW6ugbz+UU49taNR9TA4OAolRWn+3Xt/fj3WxQwlMkpqqLB3cnQLwOBukpOMi3cwPuVU6H5qfH8SShaBSvMyAaU+0XwauaEljO/9Q6JgIg8tBUqleVNhUeLjH84HlayOeopSvaWYGnUXJsE6ugVRWLsAD+DQAUmgHSRN1RPevUnw9ytbyYJPDp6uQQhTKSNWFdFsD68n+L3J0NbXVJRYLh1+lOLfWqe1HZdpaBjq6MaUEztUUbttJQyeK6klm2cdxsU9krKUneHp6McpSnN7r2MiSoNJs3b/hjl7R2U6ESUVcNeSMxjVbDETUeoPG7WoGxYfHv1dEFFSh5/cdMDKqQfRs9ocLrkf2XSdiSgdMzYVzNHtt8ZYsHMYjrz8E2tOT8DoBZ3RvHt1WJczU3sSFB1TtLDWb2OHEXM6Yv35ydj7aA4mLO3Oqigdj77uwdi3+hIG1V+I33uu59aBr6WWZQXqtq2ItgOlMvrf43Znmv9o1aZlYVbCiFs8iJBmBio2lEz23z1yRmTo990m8T2gUc9a/JU8k1PKnleGdUVLzqGneGH7+wmG9MooRQpmvjwII8FElMpl0HFnI2I6X91PHBEr+42+EZPyBLJ0Iji88uJeeb5PlOUdROmehnZ19Qriv3//h/dO/izGWIk1ktKYilvp49df/g9h4bEICo6CjSCgTi4BsBZtHR4+odAplI8tGKkC6eGbOa0kOfg+kH3JKHmLigx6yqenoQhFqT4kSjFB76ewc0ogowRzQTy8RK+VlaW0m3RzlxYN9hYVxJMORhmlhA2GfNASNLXyK/pGXz6WPCllVG8oRbM9veuE+GTi0Jp2lcoyV48+SXERJTWWpukJxzdfR6jofU0NSA3t+FsTvr5y7C5c3n8P2RHUw7d28l4Mrz2HYxRJfeg+oSU2P5iHmq2kpv/MxKv77/Fbk7+wf9VFtvSq0bwc/rn+B1r1rf1NbaxoMSLFcdW0Q+hZdTZm9t/MfZuRoTHsBkGtJFNX98GBp/Ow8vg49J/cEpXq2vDQ0beAjn4hNOlcFTM3DsD+J/MweUUvfj10vFILwcJRu9C/7gIc3niNCdq3xOCZ7VGyoiVvIhcM2crtGOoGfXa6jJVad46tv5Qpv8PAXI8Hc2hj/uRiUnuhHCRGhXqlUdigEKJCo/H8WvIpe6r/wyqNJeU8JYsnam8pKwZpyXtaFWWrSSV5OpaVUbqSVD18qzTPQGmCRGBjo+NZQCGUspXWNTeXAFZCCTZiat5ROCnYiOAXJyd/5M2bm6uJ/P33AbCWyahrAPS0C/IU/X//+x9cvUJRwlwisc7CrSYHPyeyLRklAlqogAbHj1GfONk70SQfwT8kEib6QhkNkpVRMbQk7JxkMuohyrTyrs/NPSG9qIQ4+JTJqOzJ9vZVYl9ReUrxxUMpVk1GsVLGMDAujPi4T3h+L+mut1rDMjxFTP1yD79w4qrRrBwvbLTY7E6DjyEt0kPmd0GrAfW4nLJ81A6c3X4D2QUfYqgv9CwGVvoDZ7be4CGAGi0r4J/7c9F/Rge2nMpM0PTriol7MbXzavi4BrIC8semQZi1dQj0xAbpW4DKebv+Po8Bdf9kBfTCgQecsU6fxVa9a2LhnuE4IMgeKZPJBTN8axAhJrJMSu2O2zPQY1QTfv0UGLBt8Rn0qz0fO5edY8ubbwHa8Ez/ZyAK6RSE6xtvrJt+KFPiOxt2qQYDUx2ODz6/M3PU0eqtJNuhOycTAi5ykDxo8JBK9QTlQJAvobKIeKUe/5RQvmYJxcY2JTJq/zjx+lNGuLg42Xvj48fPitdnXUYimvIQk75hIegIJdTFUYo0tRZDSk7v/BKth07vpfXQWgwuObn4o4RQQ2mIKSb2I0qI9dTZIxDFBRl19f72ZDQngSnzkC17Ril2jOI8w2PiWB31CYqAf2hkQp9oUCSa1ZDK35STG/vho8JblPpaCBbCzomSmPi2hR6XIsPDYxEaGg0dnYIoIfpi3ouDU7mc4ezoz0onlQoJdtWK4fie+2wmrNzTQ19rNC6Nk7vv4d6VtwqlVAb1+jTpUpWVnHN773M6U4oZyLM6YFL7FWwD1KZ/XY4iTA3oZ0cu7cl9fmQFs2biXoT6R6D3722/q+EPdYJsSy7suo39y89x6hOheHlzbluoUFfqncpM0Gfg+rEn2DT3GFseEVr2rsUG9qnp+c0MfIz/jHsXX+H8/vt49SBBQaF2gVrNy6FBu4ooV734dzlA9TWQxU3fiS3QfVQT3Dj1jNsLvJwDeKr/1K476DioHjoMqsdDVFkJfRNtTNvQH3/0WIfLhx6yVRup4epErty50G1CS/YXPrjqApr3raP2cAYiVweWnMLjiy8RGxXHqWw5SBk121TCmU1XOZWJqg9fq36QnzGdi8nZI8Q/nONCVVFWDAO9eeSS5DlL2lnw+kWDhSEBEWyRRjA210Uh7QLsWuHy1helRInextYUr564cxJT8w6VFNaFD247wcnBD2XKm8PaJrEYI5PP984BfH4rLlqLnF0DoVUoHycfBgZHwcUjCMUt9PH4tSfbO5UQj3PzkYSfb4neD2bmJDBlEn68VUMN0BEnQk5bEn2jNEVvrCdK88GR0CygwRd5t2YqUpe8VIzuaWCJDizqiTExkR7jIkoXNiUlMurmGsQLOcHQWIt3kDQNrWzxRH2jlL0b4BsOP0FwZdQUWfQPrr1NthTfokcNPhE9u+3IHo0poUyVoqjbxo7LZRtmHU2TykInrt8W90DPSZJX6d6lZ7B46BaeKP/ZSCgpv4Mqz8D6qfuZiJLN1dRNg7H66h9ZQkS9XQIxrdtaLB2zi4ko9fsuOzEeoxd3/yZElFTQrX+dRp+ac7F47B4movR5q1jHhkvw+6gPc0l3jhb8EYmoMvLkzYWmXapi48XJmLGhPyed0UT+npUXua/07N57WW51VqG2jWKifuOsI3gnMr/ViaY9a8HATJc/71QBUDeKV7CAaQkj7nu+eyppTnoOEqNsnZLIV1ADof7hcHmR2PIvOZB6XlQkHb2665j8/6CsGTTy5+G2Dw/HxAOFtMmylO2WlD5fdJyXLCeJFo5K1TwbW2lAyUlp9qGEWO/eOwglVDwfDfHGxsbDykpfIdiEhESjeFH9ROtlMQtx2z1IoYY6ewajmJlUzqeAmhz8vPhhlNFFixbh2LFjePfuHfLly4eaNWti8eLFsLGR7I/SAjK7D/OPRCANMYnkJf/QKFgZSKV3snMiFDHUwjvXD/AJDEcVW6lcEREVh8ioOJgW0eEDKzomnqfsdelkYKUPb+9QuLoFcka9gWEhaGnlR0RELPuNlhQ2MmXKmeH2NQe8eempMAzOlz8vSpU3w+un7pxVbyLILqFMRQsuH5JHIsWDVqot+Y/KoN1rpXo2eHLjHc7suYehM9ql+LcPmtkeDy/bw/6BM64ff4KGHaVyUGpAr73v9HY8qLN20l7cOPqId+IUdUlDED8y4qI/4Pyu2zi27hLbAxEo6Yn6QilTPiuM02mhPrTuMk9Qf/74me2aeoxthk7DG2W5cTttVMjj8+SO25xdLW9cqDWgebdq3HdJauLPCtp8kdpbo6kt7p5/hZ3LzsPHPQhrZxzBmd13eCCKVOCsQucRjXho7e65l9w/uubCZGiLSo46QJ+v3lPaYPnoHTi48jxa9KuDAoXUt/Ghc0eD7jWxe/4xXNlzG016qVfd/dlAPZ52Dcrg3umneHzpJceFfg3la9vA5ZUnXt1xQoNOSVP5qLxOyvrLu054+9iV/WyVQW1crg6+cHjmgdotyivuty5rhkc3HblUL6OEmJZ3dw5QmN8ryKioBGprF+AhppDgaLi5BKFMWVN2nvHwDIGLa6DC7ikgKJItE4tZ6uP+U1e4egSjTXOpwufqFQxLETITFvFte7gJe6rPz5QEJkP8g+yOH0bGuHnzJkaOHIkHDx7g8uXL+PTpE5o2bYqYmLT3c+lrCYP7cPIXVVJGxcld7hMtIpKXfPwjkD9fHuiLlCNSR/PmyQUTUQpx95R2bMVEOcHFJVBxArYuKZE0R6VSva0oddir5NFXEnn0z+67JDmJyOooJTIlhzaidHfp0EPExaSsVhoU0UH3sVKyx+a5x7knMa1o0bcOFh0fj8L6mnB7443RDRfwJG5m9LNlNkL8wrFjwXH0KTcVm2YcYiJKhGvEX92x/elCtBnUIEuI4NMbDhjeaCH2Lj/PRLRyg1LYeG06m9dnJRGN//CRy/DDmy3BH33/YWsm+r+SCjrrn4HYcesP9Brb7KcmoqqktE6rCth4aQqGz+7AQ1nujv6Y2mM9Fo/bg9AgaeOa2aBzyfjlvWBW3JDLsGT7pG6FtlG36ryppHPC4TUXoW407lWb/w6yePLP8Y38KiqKPtDn1xPnxqeEsrUkkeJNChP1hNIiW97hSeLeUEJJsS45vUwcTW0t5hyclVRQA2MtFCqcn4cp3YWXdnFRlvdyD1YM2xYTdoPOzpISW1ReI10DoampAQPhne3qHoRiYqDJxTMIlkV0uZ0uMvoD4j58grGeeglgRhOY1H3JwQ9ERi9cuID+/fujTJkyKF++PHbs2AFPT088fZr2ko++ljRMEajkL0rKqPyBD4uK4wOgiGznJDLpzUSpXmHnJNRLN2G7UqyYdKC5CiunRBOFonShTEbfvPTicr2MSqLBnHJ/P6lYetRtIU1L3r3yJtlSPVk8kVl4TNQHXDn6+It/f8dhDXnRoQnxLQtOID2g3Pp1N2axaTYN+ayesBvTOq6Aj1Li1PcKIldvHjhzulTf8r+zcX10eCwnmYxZ3gfbni1Eu6GNWJnMbAT5hOHPoVsxo9d6+LkHc/zjtA0DMG/3CE5OySpEhEZj7+qL6Fd7AVZPPwzP9wE84NO2X21svvI7/tw1jFXC7znVKTNBvdkULLHtxnQe0CJSdePkMwxrvBgXDz7Iko1YAc18mLl1MP9fyBB/64KTan1++t/2n9mBrx9ff4U3auqEkYU+7ETs6PntN9X63D8jKtSX3iuHB+/x8cPXXQ7KVJOUek8nvxQttEpVslRk0avCupy0Lr239060LpHXNcHbLRixQuhgtxihhDqLtU1XXxNa2vklO0MhyBQVftuugrBS9ZDgJiwQSQ3l77sHw8pcTyHu5Mn9q2L9dfMKQVHThEphDn5O/DBkVBUREZJ6qaOTsrdjfHw8S+DKF4IcA8rKqFLPKPWIFhSN+37BETAVyqi3TEaFt6jcNypbU3h4SmS0uNgFUhlCnjwsKUoh75S83chrNH+BvHxgu75PIG/FShpBS7sA3//2RWLV1LayFbT1CnK/z7O775NVcOQUphPbbyU6maiCSipjl/bg6zTMRKpcekBl7IXHJvC0PRG3FzcdMKzmbPYkTY/imtkg8n18wxWMqD0XE1su5jYDUpcovnPGzhHY/HA+Wvavy+9PZoPMqQ+vv4Kh9RfgztkXPBzWYUgD/HPjD/aYzKrBMIrS3DDnGPrVmo89Ky5yj6qBiTaG/NEWu+/N4nK0qdhk5QDsCjBqfmesPDEOxW1NER0Zx/Glf/T5J9lUKXXDrLgRJq7qo7Bpu3lSvf2XZFNWumoxdt3YtUi9ZJfQanBD/nphxw0u7+YgZVCPrY6RFp8rHJNRMpPrGy0iyF9yyifBuoLUFkbOHKrx0HScU08p/e+pb10GtYjpGWnxhovK+DKKCiXUVQwo0TmLgl0IbmJdKyrOHbLXNvWN8s+IPlHZhcbdIxhmJtrsPRodG4+gkGhYCQJKg0tWJjlk9GfHD0lGaRJw3LhxqFWrFmxtpVJGSn2mWlpaiouZmdTgbaClmRADqlNIYedEMFGU6iOVyvSCjJqkoIyKMj1FghbS1GAiSAcXwUaQUS/PYERHS7n1NORRprz0Wl4r7VCJUFauJe1uH99xSvS30M/UbSH10Vw/+yLZv7dJ5ypcRiQj7/uXki/nKw8zyabaKybuS1VufXKg19VpZFNsvDsHlRvZsmp7dO0l9Lebhl0LTzIB/Na9oNePPMTsHmvQq/Rk/PPHQbg7+LABdNNetbD2xkz8fW4qarepmGXDN89vvcPIJn9h258nOWudSmeUJ0+55KR+ZQU8nQOwbOI+DKy/EKd23uGyGpErGkjadnM6Og6unylpPD8LyKR/5fGxGDStDQ89Pb/rhOHNl+DykUeZrpLWalEeXUc1URy7biom5hkBu27M68LXL+29C1f7xJvijKJ6KzvomWgjPDASt4+lHNSRA+l/UaaGVHq3v5d4PUgJlNZFcEphyE1LpyAMzSRRxfl14v8tnf8oCY3gImI8ZRQT65iLsGkiFLVOTEYJVnJ1UCihVmJIiYZ46biQlVEv7xD29rYUaqibRxDy5M6lGBR29w6BpRB/yPy+SQ0bTB8sfeZz8HPihySj1Dtqb2+PAwcOfPFx06ZNYwVVvnh5SQefvrasjEbBWBjdR8bGcxSosr+oqZF03T8okqPILFRTl+Sygoc0Uc87Q0WPTICiiduId5WAk1LfaFk7qSTyWilSjVC5llSqf3wnqfpZv5XUVH7/6ttk+0LJjqVNH6l39Mg/17+6KA6Y1gYmlvrcg7Z22sEMLaImVgaYf2gM5h0cw5nXZBi+b9kZ9Ck7BctGboP9Ayn3OCsQ7BvGw0ize65F1xLjeer/4cVXrIKWqGDBNlV73y7FhDX9UVyUprJKhVwwZAum91jHtkGF9TQxYUVvLDs+DlZiEchsuL71wZ+/7cTwpktw9dgT9k2lKfiFu4dj9anx7AmaXUvxaQW9T52HNsC6c5NQqqIl4qLjsXzyAX5/M9ubtO+U1rCrW5JVrAWDt6R7M5kcSBmt274yH6/UR63O45ZspFoNbcTXj6+9+EP2mWcl5DhQh4cp94Eqw0YMOjk9SxyeooziZc2TJaOEYgoymtAfqqyCUpyuDCtBRmmISf4/kiE+3yeUVTNzXeTK9Qvi4j4iMCASBgZa7Dzz+fN/8PEJUwg6HsJBxlJYJpJ/t0UR4VjjE4KSloZoXC3tw8o5+HHww5HRUaNG4cyZM7h+/TpMTb/sk5k3b16efFO+EAwKF1REgubXyM1xYwQ/FbN73cIFeVCJkiCIkJoLMkpKKamf5ma6PFFPk4DBwguSMngJzkq9kzRFT3inZOVUTpgJv3rmwT02MirXLM7P6eESyDZPyrApZwZjcx02wCdCmhyox4+UGsqrp0SZL4HI66TVfbhEfPPkM1z5QqRoakBkvGqTslh/axZm7BiOEnYW+BT/GVf238eklkvQr8I0/DP9ICcYqcsSik6Cgd4huHX8MdZN2YehNWaht+0UrBq3Cw8vvOTfT72g3Se2xKb787Dm2gweSspKi6QPcR+xd/k5DK23gKeh6f1uN6geNt+agSZdq2VJSd75jTfmDduGka3+xp3zL/l9ox5QKjeTQb1dbeuf1jM2s2Fa1ABLD41Cv0kt8WuuX3D3wit+n1UNxNUJUrGmruvHg2Rk57Zs7G5FNKM6MHBOJ+TOmwsvbr3Dg/PqTU1qNaght/W8f+aG13eSxhznIAE2VaShVnqvUgPabPPjX3qkSPSLibQkVcJJKCoUUGXSSbCUiacwrCeYWury552SmIL8pbY5SzGg5C7K8mRXaCoIJkVl09om2yJSO5u5UGnDI2IRERkHC1Ga9/AOTaSM5uDnxw9j7UQH1ujRo3H8+HHcuHEDVlZft7pICQXzSeQz/tO/CI/5wOpoVGwQG9/LZXryGqUDhzLpXTyD4e0fjqrlLLix+uOnf9mOgqbpTU204ekdykNM+nqaKC7KFM6iTCH3jd649hYOSge/dWkT5MufB1GRcXBzDlD02lA0KGX/2j/zwMNbjmjbPcGig8hCwzZ22LvuKq6cfIaGbZPGUJLa1qxrNZzefRcH1l5GBTEUlRJKVbJC7wktsGvpWU54sa5gDgth1p9eULsB5drXalMRDo9d2Tz+9qknnOV+fOMVvpCqRAqqTUVLmNuYwNhKn3Pe6fVTeZgWK/p7aYGNj/3ISiuV/EP8whDgGQJvlwB4OfpxMk2ESisA/Rw9b5Wm5VCzVQVYlpIstb7FZ/bOmRfYMv+4op+wXI0SGLGgMyzFYFtmw+WtD/auvIj7l+35Nr0PdVqV57Qh2VcwB+ohh91HNmbXgcVjd3OrDE3c95vUgtXTzIhspZLrH5sHY1KHFWzXdnD1JfQYJ0V7ZhRG5nocA3xwxXlsmnkIlRqVUVsvtZaeJpr0qYOzm6/h8PKzKFcn8717f1QUKy+Z0VPISIhvGHRFq1hKsCpjKnl5BkXxz1Bff0pklM6dSX5e9sYWEZ6qZNTDOVBhmJ+byuoWeiyc0EQ9JQWaWUnVwoiwWESEx0KrcH6YW+oxEfX0CEa1GsVhbq4LRyd/eHqGoG4dGxjqF+L1lNRQM+HS4eETAnNh6RQaEYuoGKnF7Vsj7t945P43Xu3PmYMfiIxSaX7fvn04efIkNDU14e8v7dCoF5R8R9OCyLgP0NHMj9CoWASERXEmvZNXEPxDohTKqE+giAE1lMiol38YathZMfkkHzTarREZpQZsmYxWrWSVSBklxZNODKXFNKKDg6+inE87RuobfXLfBS+fuivIKKFaHetkySihUbuKTEZfPnBBcEAE9ERShjI6D2uI8wcesDL65okbylT+MnHvOropXj9w5sziP4dsxYozE9XSu0h/J5X86EKl8SdX7fHwwis8u/6GIxfJE48uX/r51JTxiNgWtTVFqarFUK6mNcrVtuFm/m8JKoH9M+cY+7nKSTqUNV6njV2WEGMPJ3/sXnGBVToC/c56be3Qc3QTmIlWkhxkTi/pmtMT2I/0+sln2L74LByeumPi3z1RMBN6cK3Lm2Pkwq5YOXEfdi87xwMqleqrh9x1G9cSl/ffg59bEE5svIKuY1tAXeg8riXOb72ORxdewuWVB4qVkxS9HCStXplaG8PznS9cX3t+lYzy40sYwZM26vZeyZJRuS+UhpTI21jZNYQCNuhcQZ7WtPkncYBQxEKXHSWoxz3QNxxGIg7bopgBk1G6VK1jjXz58sDQuDAC/MLh6RaEsnYWsLAQaYVijsJCtLd5iihtUkeJjHp5hyoGnGhIuEC+PNDTLoDgsBh4+obBzPDbRwp3uj0PudQcAf35C1aM2Qk/TJl+w4YN3PdZv359GBsbKy4HDx5M83MFR8TAUFt4jYZR36hmkjI9kVEiQqSMEkgZJch9ox7e0oFUVEzUk08agUr3efPmwocPn9gAn1Dc2gi5c/+K8LAY+CnZpZSvKNlsEBlVRtW6Um/Mq8duiFMpZxub6cC2kiUT3Wunnif791HprnEnycx+z8oLqVJ1pqztx/6a1Mu4bIx6S34EGhiq1boiJqztj932S7DjxSJM3zoU3ca3QM3WdkwmtXQLJiJqykSUCKe2oRaKlTPnx3ca1RTjVvXFqsvTcdxzDZfff/urByuy35KIEslePn4PxrRYykSU4l57T2yBTbdmZMmUPJVsl4zbgxHNlzIRZRLaxo59Mqeu7J1DRLMAlGYzeUUvjFnYhT1iH1x5g7HtVvAGITPQrHsNNO9Vk4+XxSN3IEAs8hkFxbwOnNWRr+9bdpZ7sdUFk6KGqNOxKl8/sOS02p73Z0RR0ePpmkyPZ3KwKi0pnzSomRzIPo4GXalfnCpMytDIlwdG5tIa5670eaXzr6kgih5KDjAWxaT7PMV0PMFcqKMebhL5NBdrpKeH9Lk0E6V5L/E5JSN8/r53qKIVLiQsBrFxHxV2iiQG5eDnxg+jjKqz0T0oMpaTlxw8AxGgNFFPZFQ2vqc8ejLclaf7vMXBIB8s1NNCsBIHmpsgo0TsyPz+rYMvnN77c0kiT55cTEipTO9g76OIDS1f2VIxxEQ9qPI0t3lRfSadFAv69J4zagvDexmN21eE/VN3XDr2FF0G10uW4FDJkPxGX9x9j9cPXVC2mtR7lBJoBzxjy2BM7rgSDy69xo6/TmPg9JSTnDICer2GZrp8qdshcQIUkWAaBPkU/4kJN+3GqTyYN3+e77qnkXpgj268isPrr/JQCaF+h8oYOK0t9LPAID7YPxz7Vl/CxUOPeJEh1GpeFr3HNc8px38D0GeVYnrJoWDBiB1cth/fcRUmLe+Jmk0lz2B1YsT8znCx98b7l57sW7vs+Hi1+OQ27FodZ7ffgsNjF2ydcwRTNw2ButB9SlvcPPKQp+o93/nAvGTWDPH9aLAQSqbH26Rl9eRgLlqAKB0vpc+mubUxpzDRBqlomcSzFxYljODnEQLP9/6J2rwsihswQfV0CUS1BpL6biYrmUox1FSWf3zPmc3vCXLPqIJ8yre9Q3ldl9dUL59QFCyQF9pa+REWEQsv31CYGmnj+VtvePuFAeW/PCOSFThaZ1amJDAZYS2yO34YZVSdCI5MiAFlZVQvwd5JI09uxbS9T1AEzIzEzkwomoppP0FGi8o+aV4hCm/PEiIa871Ss7dcqn+r1KdD2b0FCuZFdNQHOCtN2tPJokb9knz93vWkDf51WpRjPzgf92C8UVFVZRia6qBpV6nEv2PZuVSReZsKFhi3rCdfP7zuCs7tuYusBvUiUc9oYf1C0DHUYpVTo0De75aI0oT+hX33MLDWPOz5+zwTUerDXX5qAqau7ZfpRJSmtrcuOs256ef3P2AiWrl+SS4Vz9gwIIeIfmOUKGvGLgXlaxRnB4z5w7bjwLorap8ipw3bjM2DUEi7AN6/8sLGWUfVdjz+trgHH3/XjzxKMfc8vYpfjdYV+b3Y95f6PU1/FliUkkiYp2PqLLwsZDL6hcebi7YwL6U1SgalfPH3lOYe+H4xnOSlpIKaWuopDPHlz7SZuM9LlOVNhRIaGRHH0dgmxoW5fS029iPCwmI4WpufQ/TVywKQl284zERl0ktUJr818v2aN1MuOcimZDQoSZlekNFQaRDGWKlUbyZ6bvyDItgXzVzF3okOLFI+4+M/w08cMNYlpIP5vbB3IpQWu8+3SkNMNIkoZ9M/f5x4WrJmA4mMPrrlmCRxiQzz6zSX1JWLR5+k+Hf2GNWYJ+vfPnHjWMfUgLLqe02QesPWTTuIu2qepP1ZQCdeUpB/a/IXVk3ej7DASBiZ62L6xoH4++R4JqSZHdt5aONVDKy3EEc2XcfH+M/cG7z04CjM3z6UFbkfFbSpI+IWFR6LiLAYvlCyGAVJ/IhWQDRotGDnMEVk785l5/D3pP38P1MnKOp3yrp+TBzP772Ly4cequV5aUKbsuoJ66fsx2eVdLiMoNd0KfHpxqEHrI7mICmoZ5Tg7eSXqs+/ufz49/4pPt5cEE5KWlOFmRjC9XZLTEblMj2JIDKKmOvy540EFRpa4seJMr+vsGuiPlI9Efvp4x3G66WhQSGFOmoqNuy+fpJLjamJaI3zC2NllH9OBM/k4OfFD1OmVyeCo2JR2VpWRqMVZJSsnshPlPpGXzn5sr1To6rWbO8U//Ez/JTsnSKi4hAeGYvChfLDiqYDnQPg4hbEuzxrWRkV/ms8yCOUUReXAMTFfuRJekKFKla4f8uJyWj3ftJiRShV3pyj1egAf/3MHXYqZfbmnavg8rGnnFU/bFrrZIcj9IwKo22/OkxWdiw9i8r1S6XK2J3IKGW0X9x/H3/9tgNzdgxFpXo5E68yaNhrx6JTTPIJmoXzo8fYZmjVr06mpzfRyZraL2g4ifpTCTQVP2BKK1RpUOq7VZAJdCwEB0TyYubnGcKDEEF+4QgJjER4aAyTz+ioOLYuSwlki0XVBHKdoGQYHQNN6BtpcSWAhixIvTEwKfzdvQ/UbvLb3I4wL2GIDXOOs8drkG8YZmwcwH+LukDHaa+JLbBn2Tn2DqZNiTo8bPvP6IA7p55xH+Kpzdd50l4dKGFniZptKuHe6afY8+dxTN89Si3P+zPBuKgBf54pwCMsIAI6Qi1M8fFW+nycULsTRbpSyIAqioghRh/XgGStygjeSgoo3y96Qb1FlCeBeuL1jQoh0C8C3h7BKKxTAEVE9dDfLxyfPv3L8xJFTHUQHBQFH+9QXguLFNGBn38Ee43aljFF7ly/8tobGByVQED9wlBbRJzKMxs5+HmRPcloZLTCa5SUUW3NfMib+1e2eqLbRZSUUWV7J2qipoZqI/1C7DtKpfrCpfPzRD2RURpiqlfbBhYWenwAxsTE826viIk29A0K8SUoMJKjQe1ERnDFKkUVOfWklJCSSSDSWK1eSVw68Qz3rjkkIaOlyIKpuCE8nANw/fQLtOlVI9m/teuIhrhw8AHcHf1x5cgjNOtW/avvD534Rv/Vje2UKKpy3sDNmLVtSLYnpE4vPbFryRlFfCqdiNsNro8uvzXOdN9SInKPrztg2+IzikEYiu3sO7EF6rfLuvSo1ILUfOovc7L3houDL1zf+bEtTHJhDWkBtSFERcTxxVckn6kif8G8KFrSBNa2RVCygjnKVLSEjlBmvjVa964FYzNd/DlqJ149cMGkLmuwYMdQdltQF2hj9O6pG55cd+D+0VXnJ2fYHYPaZQbM7IBV43djz1+nUK9jFeh+hRSlFn1mdmQySv2j3Sa3yZmsVwFtcPWK6CDIOwT+7kFfJaM0NGdkoQdf10D4uAQkS0bliF8ftyCFVZOMIkIBJUGCeuFpQp/vF/MRkeGxfPxpauVTqKNERn09QmBrZwEdvYLQyJcbH+I+wZ+m4C30YGqqg5fPPZiM8s+YaOPJUzf4+obzucvYSIsHmHi9FNVIH/8IRQoizW98L/ZOOcgcZE8yGhGryKQPDJfM6g11CsEzIIz7RosYSGTUL0hSnqhvlMko9Y3aAeamOgoyWr60KYrJebuifEG2TUWLGsDR0Y/7RunAI5SxNWW/0Tf23goySpOHdPCGBkfjzSsv2FVJKO/WalhKQUZHTG2Z6ITBAxJdq2DjwjM4d+gRWvesnqwaRFnaPUc3xaYFJ7Hz7/Oo29oO+VJhTUHTkzRhT7nI5GE4d8AmTNswADWaSZGk2Qnkx7dn+XncFzZJ1F7RrEdN9BzXnCdTMxvO9t7YsvCUIsSAJmHJJ7R1n1qZrsSmFmT58va5B14/duPhuvf23hwxqgpSbIxNtWFsrsv2MPrGhaFroInCegWhVbgA9wvnK5AHGhp5WE385VfpM02JLRRgQO4SVLInFTUsJBqhgZGssNKwHy2GPh7BbMJt/8SNLzLMiuqjQvViqFzHBuWrF+ONxLdCpXolsezgKMwatIXLpOM7rcafO4fBQsneLSOg88Tk1f0wuvliJhurJu3HtI0DMqwWN+tTGxd234HjMzdsmXVYbcNM1Dtav0t13Dj8ADvmHMH8YxPV8rw/E4ws9ZiMBnoGK1KZvoQiRQ2YjNKlfB2p5UsZVEmg44uOqSDfcL4tg/qOqdpDxxgNMlkJI3yaU9A1KMSVDF+PYA5h4d9lrovnD10VZXn6nJmY6sD1fQD8vCUyaiKX4kVfqIkoxfvSYJJodyMySmpoCdFC4BsQjnwauaGjlZ+9Rv0DpcjuHPycyJ5kNDIaeoUKgM7NHz//i7CoOC7VExn1ozKBrIwKMmoqdmryRL2lqS4ePXdPsHcSQ0wu7gk9NlSqJzJK5r71RYm7TFmZjCZYdNCBS+rolfOv8PyxayIyale9GPeHhgRFwdHeB6XEwa/sObp9+UVWoIgIkAKUHFr1roXTu+/wieXg+ivoP7lVqt4n2mH/sWkQ/vptO+6df4UFQ7ZizOLuaNYjeRX2ZwNNJ+9beZ7/dgKp5A06VEbPCS04RjWzQWXcncvO4+rxJ4r/ByVsdRvZWK2l3fQqtW6O/nhy2xFP77znz59qb3PBQhooYWuK4qWLoGhJY44PNLHQ5b8jrciT5xfuNSugqZGst64M2jxRGdHZwReOL73g8MKTXycNXdDl9L4HTEQr1bZGnea2qFa/VKo2Z+oGeT2uODoGM/pvYkI6qesazNs+BKXskj+G04pCOgUwbeNAdse4feY5ymwvhnYD62WY5I5a1gtjGv3Jw0zN+9RJluikVx29dewRHp1/Afu7jrCtlRP9qAwDM1IlHTk4JDWgUj3BT2nKXVVsIDcTHyKsbkGJyCjBxEIPjuGeTDplMsrPa6YjkVHPEAUZpVRAgkxG+edNtZmMykqosUkKZFSkDBoLtZdK9/XE/57sneLjP8HEUIvJqG9wDhkl+Pj4YOrUqTh//jxiY2NRvHhxbN++HZUrV1acm2fPno3NmzcjPDwctWrVYmvMEiUSNjGhoaEcInT69Gk+rjt16oRVq1ahYMFvZ4v4fdX2sggfPv2LD58+Q1czv1JGvZLXqFBGyQT/MzVUG6p4jYoD112FjFKJgfxFCXLfqJOSVxspo/IQk3IEqF1ViYA+e5h4iIkWXzISJty5knQAifpE67WU8urP7HuQ4t9Lpf8hwqbp6JYb7EWZWhBxoKEciq2kEunKSfu4X1LdPqTfExyeuGF2340Y1WwxE1H26mxXERuuTcek1X0znYjGRn/AjqXnMLjhIgURpVL85qu/Y/D0tt+MiBLZfHb3PdbNO4m+DRdjZIfVvBl69ciVv6dvrIVG7ewwdl5HbDo7Hgfvz8TCrYMwcGJz1G9VHhYlDNNFRNMCen4rG2M0aV8Jo2a3x7rjY/h1zFjdGy27VeOUGFJs7115g8WTDqJHnT+xZMpBPL/vnOWfaSrNLzs0CiXtLBAdEYfpvTfi+R0ntT1/yYqWHLRA2DLvOBxfeKhlmKnVAInUrpu8j8m/OmBawhjN+0vPu23moR9yUC0zoSeUxeBURmMaWUjnKH8x0Z4cjMXUu79n0scYC6N6P5Wfp4oG36/UIkMqKMFXiSgbi9dLyig/poggmzL5FAKPPPRrIipMtIYW0tRAATFT4ReY4P3tH5jTNxoWFsbkMnfu3ExG3759i7///hva2gmtGEuWLMHq1auxceNGPHz4EAUKFECzZs3w4UNCm0OvXr3w5s0bXL58mePVb926haFDh+JbIlsqo4TAiGgYaGsiOJJSmKI5hUkmo/qFCyY0VIdEJTHelfNzqaxA0NEugMJa+Tlf190zGCWtjWFtLZUayGtUHmIqVsyQe2liouPh4R4EK9EoXrGq1Df6/p0v9+MUKpxANmo1Ko0bF17j7tW3GDy+aZJSW5ue1XHp2BPcuWSPocFR0BaJGaqo3qQMRxU+u+2IDXOPY962Iaku29EuevzyXmyKv3/VRRxcexluDr5MzKic8zOAiAj12B1ef0WRmkRKaN12ldB9TNMMR6Smdjjp0qGH2L38AsJExKltlaIYMqMdJ/t8K+uqlw9dcfPcK9y7+oZJkwxSGKnkXbm2NSrWKsGq5/c2OESg3rZaTcrwhY5FFwc/3L1kj1vnX7HCQz3XdDEy00GrbtXQrFPlLPtcUxvNoj3DMX/4Dj42Zw3ajD/W9Ud1FW/h9KLtwHo8cHf33EssGr4Nay9OzXB/c78Z7XHn9FN4Ovnh2PrL6DZOPclMvad3wNV9d/HmvhPun3nGg005kKArojFpICk1MBBDRBSdnBJkYpncY4xFShIpo4nuFzZN1BYjQ05j8vcJT5GMGgnySdZOsbHxCiU0KuoDoimSWwg+fgERfA4xNtCCs3sQ/AIj+Do/v0rs87dA3OePyP35o9qfM7VYvHgxzMzMWAmVoRyNTue3lStXYsaMGWjXThKgdu3aBUNDQ5w4cQLdu3eHg4MDLly4gMePHyvU1DVr1qBly5ZYtmwZTEyyJqpaFdmWjLK9U+GCeOsRwH2jCnunECmTnrxHPf3DeKLewlgcbIGRTFBlZZT6RuM+fEQ+jTzcN/r0hQdP1BMZtbTQTzLERL2GpUoVwfNn7njz2ltBRnX1NWFRVB8erkF48cQddRuXVrzOKrVL8KLv7xOG9299YS2m8mUUL1OEyyWOr7xw/tAj9PytUbJ/Lx3gI+Z0wIgWS/Hkxjvcu/gatZqnvv+Tfr7vlNYwLW7I6uijq29YOSQvzdJiCOtHBPmCXj/+BMc3X4enULGpl6phpyroOrIJ915lBUgRo75ed+E3W8RSHwN+b8UG6VlN8JiwvfXFlZPPmLCFBUt91QQtnQKo0bA0ajQq/c17L9MDei+LlzbhS9+xTfi4uXz8GW6cfQF/r1BsXXYee9ZeQZMOldChf22YiAU7M0EDIrM3D+JMezouF4zYjt9X90HtFlLVI6N/L3kHU8uJv2cIVk7ajz82DczQZ4oI9OC5nbHst+3Yt/QM6neqyiXfjIKiLtuPaoaDS0+zOlqtRQXeCOcA7LlMCE3lVLn8/wj8gpKqIKxCVFEG2dQR6JhIdL8go/6CZPJ9QvWMjozjfm5qpTESZNRfKKEFC2pAU1ODyae/XwSKFjOAllY+RETE8W0aYOLHB0itccaGgowGRCiCaAK+AzLa8voi/Krmtp5/xVBnZGTiNoS8efPyRRmnTp1ilbNLly64efMmihQpgt9++w1Dhkj9225ubhyV3rhxY8XPUGR6tWrVcP/+fSaj9LVw4cIKIkqgx1O5npTUDh0ku7WsRrYs0xOCaKJeyfjeSC7Th0ofCBNxABAZpXzcfHlz47///Q++gRFs56QlplMpQ1e5VC/HghIRpSEmVfN76hsl2NsnTtOQ1dGnD12SxLNVqS2V6m9ffpPs39K2t9TDefbAwy+Wzciyo/OQBnyd1FE6caQV5ENKhu40rRnoHco9adsXneKM4x8JFJlIr7tvlVnsE0pENF9BDXQc1hDb78/B+L97ZQkRpXzo2YO2YHqfjUxEaThp6Mx22HBxMmo1K5elRDQyLAYndt3Fb+1XY3TntTi5+x4TUVLqqcT9147B2HtrOsbO74iq9Uv+cERUFfTelixvjtFz2mPvzekYN78j97ZSGf/M/gcY0uJvLJ58gBNnMhvUSjN9bV/Ub2uHfz//h0Wjd+PWmRdqeW5SQn/fMIA3WXfPvcCZnbcz/JyNutVA2ZrWvJn7Z/oBqAvdJraGlp4mvBx9cWHHTbU974+OwkIdDAuUyNrXoC8EE7KCSmlNMBQ2hQEqhJO/ZyqRyUDR4ylDJpkBSiQ3X/68bENIINGEYCx6QsneSW65kNVRuo9vK/pEw2EkyHZEZBwrp+RYw98LjFBcD/jJe0bNzMyYOMqXRYsWJXmMq6urov/z4sWLGDFiBMaMGYOdO3fy94mIEkgJVQbdlr9HXw0MEq9tuXLlgo6OjuIx3wLZXhklkDIqR4IGhEZzP2cRAzpQPHiIiRYtsnd67xHERrwWJjqsjr5y8GHze+uihknIKMHGOvkhJsIblZzhStWL4viBh3j60FVR1pdRt0kZ3Lnyhi8DxzZJQlDqNCuLLUvOIzQoCncv26N+qwop/sO7j2qMW2dfcDzhjiVnMXJ+pzR/aIrbmmHtxSlYP/0wrh17jENrL+Pu2RcY8WeX79r+ifoaH197gwt77+HxtbeKk6SBqQ7aDqiL5j1r8jR3VoCSk/auuoQze+4y+SDVnKbje41pyspTVoHeA0rxOnvwIe5ctFcMIVHvZY2GpXhIjkrwRGR+ZtCkcLPOVdC0U2XugT2y9Rae3HbCjTMvcfPsK9RvXR59RjdRlCkzA6QCTlrei7+SD+nicXt4yLLOF47n1ILS1Qb+0Q6b5hzD5nnHUaZK0SQxkGkBnYNGLu2JkfXm497ZF3h48SWqNcu4kltAKz96TWuP9RN3Y9f8o2jQrQbyZ9CW6meAlrAmiwyJTt3jdQsid95cPC0f4hem6CFVhoGCcIYmG6AgD1Eqr0eGgoyGBETyuUI+LxiaaLMndoBvOIqVNGbvXwJt7CLCY1FYuwCT0fdO/ggQ/sikhtL6SGooxYBqFtRAVPQHrkAaCfIdEBQJI5GQGBDy7ZXRcw2mZVIc6HJ4eXklem5VVVRuJyNFc+HChXzbzs4O9vb23B/ar18//MjIxspoDPeGymSUEpnoeKMyfFhUrKI0QEb3hCJiF+ctyghmKhn1RUUzOJXpZZIjDzE5OvklSmKi30ON3CFKZYdyFS1ZTQ30j4CXR+Ienqp1rVmFov4bZ4eE55JBxKFVdyn6k5StLzX/59XIg1ELOvN1IkKvRH9kWkG+hZPX9MXMrYOhY1iILWRm9FyPWX02sBXS9wIuOdt7Y/PcY+hbZSZ7plKLAd1fobY1v/5td2eh0/BGWUJE6QR+csdtDGqwiL8SEa3asDQ2XpiC4bM6ZBkR/RD3kS3BSAWd3GcTky56bcVKmeC3GW1ZAZ22oicroD87EVUGLbrlqxXD/E0DsOboaG5HoM8K9ZQObbUcGxeeZgU5s0Cei+OXdEeTzlV4YPCvsXtw96Lk5pBRtB9cH1Ub2zJBWTRiO3tIZgSWpYqgwwipHLh+6v4MP5+MVkMaokhxI4QHRuLQ32fU8pw/OrRE5S4mIpb7uFPzOZZ9YMkvNDnoizUsVBDLRN8zloIjyPs6XKlNhyzYaL0hwYam6mUYCiU0UPwuGr4ly0LpPmnNNBTqp0xGFbcDpOeRU5kCmIyKtrmgSBgKMvpBTcNyGUG+XHky5UIgIqp8SY6MGhsbo3TphDY+QqlSpeDp6cnXjYwkzhEQkDjMgG7L36OvgYGJqz2fP3/mCXv5Md8C2ZeMRkTDSKlMT96gMjnliXoxwUdlegIpo4ntnRLHglpZ6DHJpDJDqFisFElM76UkJkKBAnkVvaJv7BPi7zQ0csO2gjlff/bQNUmpXp6qv3nxdbJ/D5FROkk4vvJmm50vwa6WNZp3k8jryt8PZmgRqdm8PDbdmIEOQxqwukeK48imizFv4CbYP3L5JlOxbDv01ge7l53FsPp/cm/rsU3XERYUhcJ6mug8ohE235qJRQdH8+vPqr60Jzcd8FvLZdg49zh7+FnaGGHh7uGYu3WwwoQ6sxHkH4Ftf19AnwZ/Yc3s42wLRhsdGtpZdXgk1h4bzQEKsqF1dgb1lc5a2wdrjoxidZg3ErvvYVCLv3Fq771UkYL0EtKxf3VDow6VJUI6ejceXU9dnO+XQORiwope7I1L7SHqyK/vNbk1m6rTEMyBFeegDuTKnQuD/+zG14+uOs/emtkdBbUTNqlRqdwM6YqyeIjo21QFEctceXLx+TJEpReVNqAkMqgqp9RXaGAsSKRSCZ9cKvg+JeJraKRCPsXP+YvfJZfmA0TrgYKAEhnVT7hOCYi6WVgt+p5Rq1YtODo6JrrPyckJFhYWimEmIpRXr15NpLxSL2iNGlI7H30ly6enT58qHnPt2jVWXam39Fsh25LRYBVllA5IQ5mchkbBROzG/ESfimzvJGfkyhP1sr1T3ry5UURM3cvm95aWSklMSicERd+oaqm+WvJ9o4R6zWz5661LkqqnCopGbNhGKucd33Hnq38/WQTRdDx5j25eeBoZASmKQ+d0xD/X/2ALJFr07l98jckdVnJ2+4ktN9icPLPtkMicf/2MwxhQYw7/3n0rLsDLOYDLVbVaVsDs7UOx+8l8DJrRPsvIH8HTOQAzB2zCzP6b+fWQB+ToPztj7ZmJsBP9wJkNN0c/LJt6CAOaLMHhLTd5Kp6GEYZMbYndN6Zh3IJOsP6B8+wzEzQk+OeWgXyxtDbi927DgtMY02Ud+5hmmkK6tDvqtq7AJPjPETvSXcVQhpZOQUxe3ZePUYr7vX36eYaej/qshy/qztePrrkEb2f19JzVaFMJ5eqU5F707bMPI7uDPg/5NTUU6mhqICujoaKapwoilrQGECiWVxX6KXwvuZ+RCaqsgiZHUGUlNFC8HgNZCRXKqHw7UEkNDYuI5ShuwxRcYrIbxo8fjwcPHnCZ3tnZGfv27cOmTZswcuTIhIHFceOwYMECHnZ6/fo1+vbtyxPy7du3VyipzZs356GnR48e4e7duxg1ahQPN32rSXpk9zK9HAlK8n90XLxiiInz6oUyGhwewweDnJer8BoVJQ5v3zC25CHIfaNuHkGJkphkiycZtrZmyZLRioKMvnzqjo8qJYnKtUqwQkplkHevky+DdxDZ9veuvE1iyZEcgZywVFpEzu29h0fXMq680MDP7+sH4J8b09G8V03k0cgNdwdf/DP7KHpXnIGJ7ZYzQbR/6Mxl4vSCdnBk1Hzr1DMuv49r/Te6lJ6KOf3/wentt7ghn353tSa2mLiyN/a/XIgZmwehetOyWVpypr7QDXOOYURzycGAfnfHQfWw9fp0tOxZM0sUWUpDmjl0O5fjr556zm0BZatYseK35fxEdOxfJ0cFTSVIHV17dBRGzmrHg2YUcTqx50asn38SsRmMOU2JgExe3gvVGpXhcumcwVvh+DLj5Ld8LWt0HSVly6+asv+LE9epQa3WdqhC5f+Pn7F+yn61VENoUR36V0++fu3APbx7nHSDnt2Qv5A0JBQdHpu2CXwhoCQHmVgGp4GMyv2gVGWRYSDuk8v0fJ9QVoME2aQ4bH5MoNSeZiD6YINEK5yhfgIZJa9RDRGNHRQSBQOxNmd3VKlSBcePH8f+/ftha2uL+fPns5UT+YbKmDJlChvak28oPT46OpqtnDQ0pM0MYe/evShZsiQaNWrElk61a9dmUvstkW0HmEIiYzmPvlD+vIiMjRdDTJoKeyetghrIr5EbsR8+8W25TE89pGSETwdOnty/4iPl2QdFwsSoMKws9XDrnpNCGVVOYqKJ+gb1peEeW+EZ6fzeH3FxH5Evn9QzUrSEEbR1CiAsNAZvX3mhQuUE/zAiotXr2bDn6M0Lr5OkMRHIVLxKXRs8vuWIYzvusOn318r17QbUwcntt/H35P3YcH4ydMQJIyMwK26EsUt6YOD0drh+/DGuHX0Cx+fuePvEjS/yYmNubQTTYoZssEwnTvJ2pDQcKtPRgkaLG2WZU48eTYXSZCeZMFOJkaZ4k7MjqVi3JCo3LA27OjaKTOWsBilZZ/few56VFxS+nOQbSWq0nPucmaD37tm99ziw4TqTUQLZldVqaotOA+vApuy38Sz9GUAbiNY9qqN2M1tsXXoeV04841Snh9ffYdyfnWBXo7hafx9tYKav64tZA7fg5b33mDVgM5YdHgWzYomnZdOK3hNb4sUdJz4ul47Zjb8OjWbymx6wbdziHnhRczae3XiL2yeeoG6HKsgoSlS0QpPetXF5zx1snLwHK67P+i59bLMK+amn3QeIi07w+v0StAUZDRNkLznoCRIZqkQsVclosJLaqXx/kNL9ivuSI6jiPpmchofF8ObKQAwpkb0ThcUYyFPzQVH8fzYge0WfUL4tK6U5AFq3bs2XlEDv3bx58/iSEmhynlTV7wnZloxSAlP0h4/Q1yooyGgMDHUSyvRsvKtXCC7eIUxAq9paIE/uXPj46TM3VRM5NTXWhqtnMB8wREZVldHEQ0wJyigdlHr6mgimmE8HX1QQMZ5EGEgdvXr+NZ4+cElERgn1W5RlMnrr8hsMmdg82cWj86C6TEZpkew9ujEK63w53mvg1NZ4/cAFrg6+WDJ+L/7cNSzdi5IqiFy2HVCPLzSV+fjqGzy/7Yh3z9x5J+7h6MeX9ICUTwsbY1iXN0fpykVRplqxJJF2WQ0igY9vOGDLn6fgJeyALG2M2aqJiH9W/H5KSCKfzHcvvRRkhjwzOw+swxF/OVAP6LiauKgLGra1w+pZx9h3cfrArWyzNnBiC7XaXuXJmxuz/hmAab02wOmVF2b03YS/j46Gntggpwf0uZiypi9GNv2LQx6ObriCrqOapvv5TKwM0HVMc+xdegabZhxClSZluYSfUQyY25VjQh0eOuPm4Qeo3zV7RBEnBzm2Ni46dSq8tiB34UKJTA6y+BCSTCmfeouT+55MYIOV+kz1ZaIZGsNVPRpg0hdkOFi0aBUqlA958+ZCfPxnBAdHsf0TzUoQEQ0KjkqilBroafLaSsooWS0afGUty8GPjWxJRvPnzQ06nENE36iLX4g0US+T0TDp4DXW02IySpm4RBSLGGrBzTuE+0aJjJoVEWTUNwzVK0lDTAR3jxCeNqSfkZOY3jsnJDHRhaJBb153wBt7bwUZJVSqXkwiow9dMWhU4tddsUZxFNTUYAunN889UE6FrBKoBFvCtgje2/vg1O576Du26VcXut/X9MGYtitYedm3+hL6jG+OzIg+bNmnNl/ofSAy6v7Ol1VO8iul3TupiKSEfv4ktSjQQFb+ghooWDg/J0vRoISxhZ5CTf2eDLE9nPyx+c+TeHrLUWGt0ndCczTrVl1t5D4l0Pv54r4Ldq+5rOhhJN/KFl2r8ubkS1nuOcgYSAldf2IsD4WRN+mpPff5f/H73905llRdoONg7rYhmNRlDTtXUP8xRYlmxAHCxEofIxZ0wYoJe7F72TlUrFcKxTOgmncd1wLXDj/kPHQipWSMrw4j/K4TW2P3/GPY8sdBVG9d8ZtVPL418oq/Oz6VA6daYpo94guWSLJ6mlxPv0xGVUv4eoJ4BovyO4G8iOmcQ4onTdkbm+pAz0CQS/E4Wvf09AtxXn0gxXwW0WY11NMrBEGBkTAVtmlBIZK9or6umOkIjkLfLtXRrFZxaG0dh2+J2M8fkUvNCUz0nDnIpmRURzM//KLiERIVC30xpRccEYMSJiKRIlQ6eI1E07S/GGKizHoio2R8TzA3STxRTylLVLr/EP8JfgHhPNAkJzFFR8fDzz8CJqKcYVvWTCKjKv2flYT5vbOjP5frqWwvg3abNRuWwqWTz1khTY6M0gHfbUh9LBi7F6f33UfnwfWQ/yuJEVTyG/1nFywdv5fJKEVPUp9aZoFeI5FTulRpmHm/JysQHhLN5fjz++7zCZQUp3b966DHqCZZYhXl8NwDO1ZeYm9MAi0IVEbuNLAudITSkIPMV6yoj7Rag5JYPv0om+SP7boew6e35g2BukrLNKRIlYvxHVdxQML8ETswf/sQ3rSlF026VsOjK/YcF7p0zC6sOT+Fqw7pQd58eTB8UTfM7rEWxzdcQdOetWCuBkLeeVxLXNxxE4FeITxdTz6k2RF580n/l4/xn9JkBxXxBW9SHVk9TaaUr2uYvDIq94wqk1G2ktLXZPtBmYzKymhYaDQ+ffqX10EaUiIyGix+n76+pkRGg6NQrrw5Czg0gxEWHqPoE6VI7u8FjS4vxa9q3gz9qyZLtB8d2XKASVc0grPXqFZBhdWTnMgUEhHLfaGy2a5fsHQwFlGZqDcz0U6UwpTr119gLiLW3MUAER2AVqJ876w0aVraVor1fPvGh0mMDG3dgihmLZX2nwmCoYz6LaQIzztX3ibxhpNRvVFpFLHUQ3TkB5w78DBV70nD9pXQpk8tvk6k1MslsU9ZDhKDFoQj/1zDoAYLcXbPPf4f1mxWFv9cnsq9oZlNRMmSae7IXZjQcyMTUSbBfWpi+6XJGDK1VQ4R/QaoXMcG60+O4b5t6ndeM+cElk49hA+x6lM+qBVl3vYhTICpkrF6+uEMDQwRiRi9uDu0iRQ4+WPn4ow5a5DxfbXm5dn2av3v6hlmIiV00ALJ6ungstMISia+Mjsgdx5BRlOZdldIlLUjQ1Mmo/R/T1EZVVJNlf+PuqK0T738yoO2CsVUtAVoFc7P6x/9aKjw1Kb2NEKQeIyeEHyCgqJ4/dQVFlakhuoLMkpl+hz8/MiWyqhuQSKjYayM6mkVUGTVk2JKJVXamZFSSj2jBH9xIJmIg9NH9MqYCWXUyzfh5EilemfXQLh6BKNW9RJ8X/HihjxN7+QUgLp1SvJ9xYobcr9MdPQHeLgHKbxHCZWrF4WLkz+e3HdGo+ZlE7328lWsmLCGhUTj2QMXhf+oMuhv6Da0PpZPP4JjO26zb2RqetiGzGjHvaNvnrjx5O7K42OzNA3oRwCdlG+eecHpVXKmc7EyRTB0RjuUq67e4ZXkQAMCVI6/cvwZvxZSEqgntOdvjWAgjKd/ZJBTwv9oc/Z//8d/2482sEK9pHM29MWx7XewfcVFNsunjcOM1b3VlnNfvIwppq3ty8folaOPeSiu+8iELOr02D2NXdqT3SiOb76B6s3KoWwGPsvDF3bDs+tv8OKmA+6ceoY67Soho6jXpTpObbyCN/edsH3WIUzZNhzZDWRRR/icSvN3TVFV+xATzwQ2OcW7sEIZTUr4dESZnUrvFB1dUGywaRaA1HjacJF3s5zKpCueK0SonnT86uhpsrVTCD3OuLCCjFLPqKyMEoLk23qaXKan23KZnm5/L7jaZHKmJDAZYwmyO7IlGdVmMgqERsWidBGJBBL5pINHX6sA/EOjEMR59YKMhogUJoPERvjm4iCkgyXuw0fk08gDS3Opb9TDMyFFqURxqW/UWUltJNunkqVM8OK5B/eNKpPRitWK4eCue2x+rxoNSkSzTtMyOLX/Ia6ff5UsGSU0aF2BB1kCfcNx8ehjtO1V86vvC51gZmzoj7HtV3Jc6Lyh2/Hn7mHcV5oDwP6xK7YsPAVH0Zepa1gI/Sa1RKOOldmzLzNB1kGHN9/kzQUtDoRaTcqg37imMFP67HyPoIXMxzMEvl6hbP1ChDo0OJo3VFERsYiO+oC4mI+sNitXCehznzvPr8iXPw8KFNRgC6rCOgVYmaFJXVoETamH2FKX87G/F9BngXp1bcqZYdGEfXBz9MfYruswfUVPtU3bV6lfCiPmdMC6mUexc9k5roRkJDaUbNCa9ajB3qPLx+/B+ivTFAMzaYWxpX7iYabGttBI53MpfxaGL+2FMXXm4Or+u2gzrDFKVcv8zd/3BHIZIaRUEVMFVWdoTaNjiozyZRP85JRRUjmV4z3ltL4Cmhp8/JI6KpNR+l9QCxCZ3lNJXkFGBXkNURqY0tUvyGSUhnWVldAQ+bZuYnIq3faTyvaif/l7Ukbz58rDF3Xis5qf70dFtiSjOoKMsjJaSNo90jATwUC7IJNR8hqtUFwygA2mA/XzvzARZXpf0UNTSDMftDTzISIqDt5+4ShhZQBLoX64Kfl8ymSU7J2UyWVpW1Mmo2/tfdC6bUXF48uUN2Mlk3pGXd8HKMr2Muo3L8tk9P71d+zXSbZPqqCTSpdBdbFu/ikc2nwTzbtU5Z7Tr4ESiigRaGKXNUy+lk3Yh6mr+2T6EM73DGpZ2L7kLO5fslfkmHce1gCdBtfP9GEKUukvHn2C3asvc38qoUwlSwya1AKlRGLX9wL6bFM2tZO9D947+MLVyR/u7wMUC096no+IN10o9xqJbXkTgTLji9kYoURpE5Qubw7rMkXUOtGeHtAw4eojo7BgzB5ORpsxZDtHrcrRvRlF69614O0aKFmzTdrPw33FMxBcMGR2Bzy/9Q7+niHY9udJjFzYNUPDTFcO3udkpoMrz6PfHxnv87SuVBSNyepp921smLQbK2/OzvRN4PeEXwVR/DeVZJTem4KFC3CZnjyPkyOjmtoFFISVekvloSXliXwiozRgai7WMQJtCGUyKkPuUVc+3mlgSfk+RZleqWeUEBySoIxKt6MVymh4ZBy72OTg50a2JKPaIskiNDpW0T9KZJQWPzmVKSgsGjqFCnAfC/WPkvm9nFcfE/cRkdEfUKigBkyNC0tk1DdMIqNiot7TO5SJBJE4Mr6nAz4sPBYhIdGK3SFN1BPeqmS5E2ksX8kCj+4681S9Khklj1GjItrw9wnDg5uOTE6TQ9NOlXFg0w2EBETi0tEnPNiSGpAdESmkswZuxu1zL7ksQ3n2P1rJNKMgNWDvqou4cPAhxzLS/7BZt2roPb65ovE/M/HyoQv+WXSGlTVCEQtdDJjYAjUbl/4u/hdUUvdwCcLLR654/cwDb194stqZHLT1CsLETAeGJtqsatLCRe0mNIVLDhGkwpHtC22i6H2mPjPaAH76+C/iYuNZPaUI1dCQaF4AKenFzzsU3u4hiAiLgZ9XKF+ol5pAvWoly5miYvXiHBhRvJTxN3nPyMlgya6hWDXzGK6dfoG1c0/A1zMEgyY1VwuRGjK9LXxcg/Dk5jvMHboNq0+OV6hdaUUBzXwY93cvTO++Fmd23kbtVhXYID+9w0xD5nfFgn4bcGTtRTTrXQtGFvpqsXq6c/wxHJ+4shl+455S0Ed2AB0XhH//k0JWUgNyIiEyGp1CahOtT0RIiYjS1H1SMqrJG54wpXx6vl9M6ocJRVO5TB+qNAxFQ03KZFRXT0UJFc8TLJ5fTxBQIqMk9Mhe3iFhMSig8e3PeTnIPGRPMlogn6JMryt6RuM//Sv5jspkNDyaD34DHU0uy9OEPQ00aWvl54gyv8AIiYyaaOONkx+8/KQhJmNDLSaT1NjtFxDB36feUDMzXXh4BHOpXiajpcpIQ0zeXqGICI/lhm9liyeJjLqga5/EJXZaVImAHth6i6fqUyKjVF7vOqQeRxce2nyDyWlq1FEC+WJOWd4Li0bvxrl997nfiPoivwcSlNmIjozj4aQT228rzPXJXWDA1FawEL6xmQlSHDYvOYe7QoktWEgDvUY2ZkUtI5PT6kBUZBye3H2Px3fe49l9Z/YVVAa1n1hZG7IyWdTGCFYlDGFR1IDLfZkFIqOkwjo7+MHR3htvX3qx/dnrpx582bnuKi+KNRqUQt2mZWBb0SJLFTU6Dict7gpTK33sWn0Zx7bfZruciYu7pvp4TAlkb0aVi3HtV7Ll08KRO7Fo74h0J41RWETL3rVwbs9drJy0DxuuTku3+k/JTBXqleLe0U0zD2PWrt+QUZC612NKW2ybdQjbZhxCrbaV1eJn+iPgF1Gdoo1xalFAK99XU5uoGiaR0aQbSbLUI4QrkU5lFZSOsyTEU7lML8hmiMoAU1hYDIs1umLIKjw88e2Q0GhpQl+nIK+j1ApXoEiOO8jPjOxJRkWZPiw6Dvny5EYBjTyI+fARIREx0NcWO7MIaZE11CkokVFRRjDR12IySvfZFDVk43uCj/Bio52muakODzF5eAYzGSUUL2YgkVHnQFQXvU5kAmxmrgsvzxA4vPVB9ZrSwJOyxZP9C0/Ef/iUpORIU/VERp/cec99d5paCURWGc07V8GhTTc5LePSkcdo3TP1ptHUg0a9iiunHsSJbbd4sGTYrPY/LSH9EBuPUzvv4PA/1xTJSaUqWnIwgK34f2Qm6P9MufF0odI0bYZadquGPqMbo5CYMv0WIFXj7tW3uHftLV499Ui0GNLnkshd2UqWKFvRgsvkWd1jrKVdAHbVivGFQBUOX89QvHjkiqf3nHnQj/6GM4ce8YWmfhu2Ko9m7Sqy2pwVoGOmx4iGMDTVxoo/juLWhde8AaVY1q9Zr30N1Ms3Z/MgjO2wkltryO92xJyO6X6+gTPa4cn1t1yu3/HXGQyf1yn9fZ4Lu+G3uvNw78xzPL/pALt6UgpdRtBhTHOc334Dfm6BPF3ff04XZAuk47xbUI4Q/UKePQ2wyZs6VRQWZFKVjMqG+mFBCQSWhpUI1A+uuE9FGdUuLNoC/v0fJzEVVmoTCA2NViijcp+onrZERomcWuaQ0Z8a2afhRgmFC2goyChBUapXmq6nsjyBlNFE3qPiIKQUJgKV6ZUn7AnmwrzXwythyr6YiO9zcZWSeZKzeFKGmaUe9AwKcZnytRiYUYZlcQNWoKiUeftyyrnyRAxosp5AJfvUetTJaNa1GsYslE72J3fcxoqpB9m25WdC/IePOLH9FgbU/ZN7Q4mIWlgbYdY/A/H3kdFZQkQfXHuLYa1XYO+6q0xEy1crirXHx7B/5bcgoqQOnz/6BFMGb0Pvpsuw/q+zePHIjYmoRTEDdOlfG4s3D8CR29Pw5/q+6D6oLsrYWXwXw25EgohktupSBbNW9MChG1Mxb01vNG1nx4NQ5I94aNttDGq3ClOHbMedK2+y7DPdsI0d5m3sz0NZLx+44Pf+m3l4JKMwLWaAyX9LWe60obp24mm6n4vK9WOW9JCea9tNODyVInzTA8tSRdB6kHT++We6es4d9Bkbskh6fUdWnoe/UuJdDhKjgBApYr5ERgUBTE4ZJdVUtRxPoBYb1ft19KX7aI6BWmsIuuJx1F5D+DXXLygsKoB0H4k3Ogo1NEahjIaKiots9URl+hz83MimZFQqXcTEf0T8p89s6UQIjSQT/MTKqBxBFii82oyFxxpFhBLkoSZlMmppJibqvRIm6ouJieckZLSM1DfqoEJGaUGtVK1oin6jhIbCc5Sm6r+EZl2qcIQb9Y6eTaXvqDJa9KiBCct6cJno8uFHmDdsOycl/QwklAj2oPoL8c+8EzwgZGSmg0l/98S6c5NQo6ltpqvA1Oc4e8ROzB25m8vz+sZaPHW9aPtgWKn0CmdFDygpiYumHkKPxkuxav4pvHrizkoj9V8OmdAM206Pwz9HR2HQuKZsM5ZbTPh+zyDyQq4TE+Z2wP6rkzFjWTe+TYrMy8duWDDpIAa0WYUTe+/zQprZsKtZHIt3DeVNBiWlTem7Oclinx5Ub2LLYQuE1dMOsTF+elGpfik06lSF//erJu9nG5/0os/UttyX6O7gg/O7bkMdqNm2EsrXK4VP8Z+wZfoBtTznzwjZ7zgmMuU8+0LCAurLZfqv94ySowVtsgihQjFNVi0VBJXUTmXCGhISpVBGo2PiOSZUT6y/wV/wSs1KUFpSZlxykE3L9AU18uJXSnr4738Ij/mQQEajYlHMWCrbBYdHJ1JGaaCJIBvhy6lMRUQ+NB0slLykkTc3zERGOg0xyShWTCKjPj6hiIv7iHxiAr5UaWli3/Gdr2LgSQbl1F88/QLPHrgCY5L+HfWal8XWVZfx+qk7ggIiFIkXqqC+tJ4jGmL17OPSZH3nKmm2bWnSqQoKaubDX2N24dG1txxLOGvTwG+eB58eEJGmPtijm6+zTx5B36Qwuo9sgqZdqqa73y4toJ7io9tu48DGa6yE0u/s2L82egxvyNP6WQkaOrp4/CnOH3vK0/DK6juVs+s1KwvDn8DDVCamtRuX4QvZTJ078gTnjz3h6xuXnsf+LTfRqW8ttOlWNVPtokqUKYKlu4dynr2HcwCm9tvMGxDZUDy96DWuGd698MDzO07cP7rq5Ph0WzQNndMJT244wMPRD0c2XEWPsc3S9TxERPtMa4f1U/Zh96KTqN+pKgqm0FaUNqun3hhZfQZuH3uE13ccUba2DX5m/E8MLqVlgyyT0dioD+kyx6fUr+TK9HL5Pslgk25BxMWGssk9VSd0xONoAJHOc5QQx2T0fYBCLdUVZDgkJAYF8udR5NeHhEVDT3wvWKy/3xp1zi3Hr/nV26P8b2zK/5vshGypjMZ//gyt/NJBGh4Tl4iMyiX7yNh4Vk3lHlIFGRVl+gBBRgtpavABRKDeFgL1jBI8vUMUyRU62gWgXTg/Twm7uyfYPllY6kMjX27Exn7k3lFl2FWR4j5dnQOSnVI2MC7M/XqEG+dff/FvJmN0Y3MdVv9O7L6H9ICUwsX7R/IJiszxKc/+yU0H/CiICJWiO/vVns9+oUREDUy02Slgy7XpaNmzRpYQ0deP3TCqw2rsWnVJUZJff2IMBkxonqVE1OmND5b8cRR9mv2NHWuvMhGlyfa23athzf7h2HB4JLoOqPPTENHkjp/+oxtj1/mJGP1HGxibarOF1LZVl9G/1Uqc2PcAnzLRUsa8mAGW7B7Kr8PLNYgJaXJJOGkBbWanrOzNU9FeLoFY80f6E5pIMRs2V+oX3b/qAnxUqjppQav+dWFubczq2/6/z0IdKFrWHM0HSC0AG6fsYWX/ZwaHQSgNMqUG+cXgYGzUF5RRUQonL9KU8u1lWzkZ2sIfNDw0OtHnK0ExlR5P5xMioAQF+VQp3SeU5qWhJT3lsr1Yf3PK9D8/sqUyGhUXz32jZO1EZFRbUxDT6DgUKqChsHMKo7K9Chk1FAdhgNgp0sFjYlQY710D2X/UylwPZkW0udec8ujDI2K5aZtAFk9Pn7nDxS0QpUqZKBYPaxtjvHrhyaV6S6sE+xNq7iZbJ0pjev7YDQ2TmZpv0KIc7J954Mb5V9zHlxKIZPUd0wSLJx3Eka030apb1XT1Ipa0s8DqU+Mxf/h2vH/tjZn9N6PjoHroN7nld9EvmJJPKE3GXz36mIeECCaWeug6vCEadqicZRPqZE20ddl59g0lEKkfMrUlBxRk1VAYLdgPbznh6K67/LmRUbKsKVp3rYo6Tcp8c3/OrAb9vdRf2rxDRVy/8Br7/rnBBv0bl5zDyf0PMHh8U9RsUCpT/keUyrR41xBM7bsZPu7B+H3gVizZOUShSKUH9LO/r+6DqT3W4/rJZ6hQy5oV//SgfvtKuHL4IZ7dfIe10w5i4YFR6XofaOp/yPwumNltNU5tuobWA+uzOX5G0W9WJ9w4dB/Oz91xZe8dNO1TFz8rqHJG+CUN739+zVQoo2IdSK53uXAK+fayMvrv5/+4x57s/5RJKuXRE+izoq0jGd+TWmpkUlhRpg8NiUm2bE89pDQQTLcVPaPfSZn+dssJmZTAtAjZHb9kVzKqJYaYImI+QLtgPsVAE9tJKLxHE8goDTTRxJ+hKNOTz2icTGxEMpOsjObNmxuGQkH18pEsnwhFBdF0c0vccF+qlDTE9M7BN8lrtatiyV+JjCYHIg/UFO7i6A9P1y838tdtUQ5FSxojNjoeBzffRHqhb6KNZYdHs+k24djWmxjV6m/Yp9Db+q1O3A+uvMGMfv9gaOPFOLf3HhPREmVNMW1NX2y68juadaueJUSUlIMbZ19iaOsVCiLaomtVbDo7gQdasoKI0uDI1bMvMbzzOswdt4+JKH1uqAy/eu8wrNw9FI3bVMh2RFSVMDVuXQGbjo3G6BltWOWhnt75Ew5g+vCd8FKqaKgTRqY6+GvnEO7rJjXzj8HbECXcHNIL2ypF0Wd8c76+fvYxeLukT9WkzyaZ35O124s7Trh5Mv2DUZUb26Jig9Lcf7pt7lGoA4UNtNDzd8lQf/usw/gQ8/OWPP/7LMhortQv27Lt1ZeUUU1tUQ2kYAkVaIkyOZ07lecEqPWLLOcIylU7bd0CScr3OuI+BfnUSV4ZVfSQKghozHc3wCQnMKn7koNsSkYj4z5AS/R9RMQSGc2vUEYJZHYvDzTpiN4mIjcR0XEomD8v8osFO1BM2JO3KME3UCKjBNMiIrdeqW/USiaj7olJo41QSd85JB5iItiJSW4io8mV28g0vJKIGPzaIBN5K/YfL/V9ndpzjwdm0gtSQUfO74TZmwexMTItopO7rcXS8XsRmIHnzSj8vUK4FD+g7gLMHbIVT2858oJavXEZLN7/G/fQ1W1dIcsSpYL8wjFnxE4snnSAS11mxQywdM8wjJnbgeMtMxsU8XfpxDMMbr8aS/84yhuW/AXzsoq+8+wETPmzE3uC5iBxFaFV5yrYdmosug+uyxuW5w9d8VuXddi94Rr3+6oblCD11/bBTIBd3/lh9vAdGR6m6jK8IcrXLMFeuYvH7Un3EJKJpT66j27K1zfNPY6YLxCbL4GOw8HzuvDX2yefwuGxC9SBdiObwtjKAKH+4TiophaA71kZlWNBUwPZ3zcuOuWBU01RuYsWDjLKoH5jucxObU7JqabKJXxZ0ZeVUb5PkE2ZtCZVQhOTVeWyvVymJ/EnJ4Xp50a2JKM0RV9IkNHI2A/QErtHGmYiaIumbyKjuXP9isKi1CHbPenLQ02KCXuJjAYo9XtRqZ5AyUwyrERZykNFYbEpZaxQTONVrJdsK5gjV65fEOgfAV/v5EkeleoJZID/tf6wynWsuUeRSApFTGYURPL+uTwVzbtX50WGLGUGNVzImdlEDLMC1Fx/du89TO66lu2Z9q66hCDfcC4/dRpSH1tvTGfSXK568Swth5/Z/4Dtmh7ddGSC03tUI6w9Nhq2lSS1O7MXLlJCh3Rcg+VzTsDPO4z9OKlHcvf5iTwNT36bOUgZNMDUf1Rjdg+oUrsEPn36F3v/uYFR3Tdwv626Qfnyf24dhIJa+eDwwhMLx+1LdQ55cqAN16S/e3AJ1dneG7tXXEj3c3Ua0QhFrPQRRqlkf59P9/MULWOKxt0lr+Otc46mu59VdWM86M/ufP3oynMIUhIAfib8K/qXqaKRZmU0OmXFWC6xJ6fG0/lSHnCKUAm4UBBPJRWUSvKqBFVHhaDKyijFXSvfDhXqJ81XyGoozWTQ+sfP+QV7qhz8+MiWZDQqToWMipK9QhkVA01hUdKHX0/sHEMUZDSxMa+Rwu5JSRkVZvfeSiqhucitp1jQcKVEDAODQtwfSkbALs6Jy2k0dV9SxIa+fOqe7N9To0FJLq9SSdHpTdJSv+rJZeCkFnz96qnneK+GRZUM98cu6opVJ8ehXPVi+PzxX5zZc5ctk0idpEx3GtRRF2gBI9uaI5uusxrbq9ocrJ1xhA2/6e+j9ChKpdl9fxYGT28LY/G+ZxV8PYIxtd8WrJt3EnGxH1HazgLrjo/hFKWMJu6k5r15cPMdfuu6npVQ+kwQCaW+x53nxrMfaGamIf2MoBhT8imdvrgrCusUYHV5XN/NrJKq25+U7LzmbujHx/PjW45YPed4hgibnlFhjP1Lypg/8s/1dLfSEOEbsUD4DW+7yRP26UXf6e247G9//z0eXHgJdaB2+8ooU9OaVeAdcw7jZwRthghpGbLMp1BGv94zSo9JbvMjl+qTKqMFFENMScr0QuVM7j75NpXp6bMtT9OTEkqtcIrpejHQpKNYf3PI6M+MbElGoz/Eo5CwbYnk/tF8iv5ROjgKyz2kohylI3pISSklGOgmVkYVE/ZKymgRQUZ9lfxHiVgaiexfdyWjZjrgrG0kT0mnd0nJZIXKkpL24knyfaMa+fKgev2SfP3GhS+X6gnWtqZo0KYCX9+y5Jxa1AlCibJmPG3/174RqFjHhk8s1Lc5b9g29Kgyi61myFLJjWys0rCIR4XH4NUDZxzbcoOfo1fVORjRfCm2LjrNiyv9HuoFHfR7a+y8MwML9wxH/TZ2WT5QRWrk8R138Fv71bB/4saT8cP/aIOle4by5HRmw5E8Kwdvw5yx++DhEsiTrAPGNGYS2rlfbf6c5CB9oGO0bjNbVknrNbNl839SSScN3AZ/Nbel0OZl2vIe7IN6+dhT7Ft/NUPPV6tZOTTpUpWP878n7fuiSvY179Eazcvx375h5pF0nzf0i+ig/bBGfH3H/OOK8nNG/z/DFvfi61f33cX758lv3H8GZTRXGja0+Qt+nYzmL5RPUTGic22KA06qymgyiqnCCipRmT6BfCorodTuEhMTD23x/HQej4yMSyjTC6VU7hsNTea15eDnQbacpqfoTz3ZzkJpmOnT53/x4dNnRVleoZSKvlGKCyXIP6uYsBdklPpaYuM+In++PDCRk5n8wvikLR/slhZ68PePgIdHCCqUl2yZCDRR/+iBC947+SdLRvdsucVRjMrPpQzKp7954TVuXrTH4PHNvtoT2W9sU9y5aI9Xj1xx/+pb1GxcBupC+Rol+EJT7BcOPMTN08/YcP/2uZd8IeTK8ytMLPSgb1yY4+jyFczLuea00FGvHE2ek82Nv3dokpOgIoayalFUaVCaWwW+td+pt1sQlk8/wuVVQoXqxTB2fkceTslsUKLQ9jWXcfWM9N5Sj1f7XjW4L1RTtJzkQD0glXna4q68+Vvz52k4vPLisv3E+R1RQ2wI1YFqDUph5Oz2WDP7OPasvQpjM100bGuX7ucbNrM9Xt59D3+vUGxbfAaj5ndO1/MMnd2Bo0Jf3nXCvQuvUKtF+XQ9T5exzXFu5y14vPPFtUMP0KRHTWQUNpWLokG3Grh+8D42T9uHxeen/VTRxZTGl9aeUQ3hMfulkBJaKwoU0uCpeDrvylGfSRKaVM7DySmmimSmkBjFWqWjQlA1NHIjf/48bGdIpXqKxKZobCKioWHRijJ9AhkVz/mdDDHlIHOQPclo/EdY5curIKP58+ZGrl9+wef//kNkzAeFMkoDSwRtoYyS1ZOcl6s84Vcgf172Go2J/cilewtTXRgbabG9U1zcp0T2TlSqf/DQhXPrlVFCpO04OSYloyXLmDLBoJ0lTfSaK9k/yahcqzhnVIcGRcH+mTvKV/lyhKVhEW10HFAbB/+5gS1Lz6FKXRu1T5abFTPEkD/aYtC01nB66YWnt96xwkmWUHRy9HwfwJfUwKCINoqVLgKbCuYoXcmKv34PVlKk6pzcfRc7V0qeodTwP2RKSzTvUiXTF0JSFo7tuov9W24pLKsatS7PfY76QoHPQeaA+rRLlTPDX78fxrvX3uxQ0G1gHfQd2Uhtw3Etu1aFn2cIjmy9hRUzjnI6GKmm6QG1Zoxf2h3Tem3A2T33ULtFeVSoWSLNz2NkrodOwxrhwOqL2DL/BKo0LJ2u45CGZrqNa8F9o7v/OoV6Hauo5XgeMLcr7px4gpc3HfDowktUayFVgH4GUNoUIS3n6XxCaPkQE8997DTEmhwKFi7AZDQ6mVI4bcAIkSrG87LiGa5Ukpfvo2E5cm2hz522uE/uEZV7S2NjQxVklIaYiIyGhcXC0lJKMKR1kywWdcXaGZbTM/pTI1uS0diPn6CpIZHR6A8fmTTQlDwpoWR2Lw80RYjShkxGw0Wkmlw2kFOa5NK9W2wIAoMlMpondy427w0KiYaff4SCjFqI/kVPFYP7EtbSEJOHR5AiqUIGXS9la8o9o6+eeSRLRimWsVajUrh4/BluXLD/KhkldBtSH5eOPoWfZyhO7LqLLoPrITNAJ0DyJ6VLr7HN+KRIE/e+7sE8bU7KJ6mhpIr+3y//x+VkSmjR0ddkEmpkrqsoN31P8PUMYTX0jejlpZjHcfM7wSALTOIptpPy4n3E56h0eTMMn9IyZzI+C2FURBtLtw3E1hWX2CD/4LbbcHH0w++LuvDGUB0YMKEZfD1CcO/KG8wfvQerD4/kakJ6QOSzVe+aTEZXTj2IjRcnQyMdKVNdRzXB5UMP4O8RzNn1nUc0TtfraTO4AY5vvIJArxBc2H0HbQc3QEZhaKGH9r81weEV57B1xgFUblouy5wzMhufhRtCbqW14WtQTt+Kj/2oGGhSBTl7kAxCymhqy/RU0SJEKCmWdO6mSFDqlQ8PjWEyqpimT0RGC8DHO5T7RPl24QJwRzDfrlDenFtUqGwfERELHWE99T2U6Sm6M5ea4ztz4kCzMRmNi/+IgkIZpZI9oZAgo1E80JTQQ0qQTfHlnlF5oClU6cDV19OEm5dERmUYGRWWyGhABEqXlOybzMx0k1g+8c8baEJLKz8ffG5ugbARj5dRrqKFREafe6B1p8rJ/l31mtoyGb137S1G/t7qq43udKIaMLEZlk87gv0brqFRWzvoZDCOMLXk1MhMly8/Iqj8dPbAQ1aU4+M+8cl38NRWaJEFaigZR/+z7AK3ZBDICojaMhq2LPdTlSR/FNAmkDYBNmVNsXLuSTy564zx/TZj7urePPikjmNl0l9dMKl3KFs+ESFdtndYulXEgVNb4/E1BwR4h2LX8gsYOqNdmp+Dzhv9prTG8gl7cWD1JTTpVl1BTNICIsI9JrbCusn7OJWpWa9ayKuGvuZuk9vi/I6b8Hjrg8u7b6F5fyml6UfHR1kZTYMXcJ58ufm8QOcsqkalREbleNboZNRHRXZ9WPJletV0JlJHJTIaLUWCijI9e5USIc6fR2HnJJfelW/T5qGwVn4u01P1UR5gCsug9646UOPkKvyi5jjQ/3LiQBk/x5YxjYj79BkFxMlcJqMyOSWllFKYCERMCYXliFBZKdUSZFT0kBL0VYaalP1H/YUZvjIZDQqK4ox6GXTCKFbCkK+7OCctXZe1M+ev9i88UxwcKF/FiksqFGn44nHqpmaJgNqUM+WTxLa/02/9kl0Q5B/BpuQ0KU9EtFzVothwahyXVDOTDNL/nLLjh3ZYw0SUlIP2Patjy4kxaNSq/A9DROnviIqMg7dHCBxee+PJfWfcuf4O1y/Z49qF17h+0R63rr7FwztOeP3cA24ugexPSCrJ9162X7Z9ENtlebkFY3zfTXj32kstz03kb9baPuwpTO4X6+adSvdzUYVh9EKpX/Tk9ltwepW+19ioS1W2aYqJjMO+DFhGNe9TBwZmuggLiMCZbTegDmhqF0DPqRLJ3j3/GE/Y/wz4JFpx0rIRoc2MRgGJ4H+I/ZLXaMpkVC7TR6mY4svDSqokVVZCw8X9RD7lMA3Z3kkeWlLYO8m3hcCjuE1kVFwPV1pvc/DzIZsqo5+QP2+exGRUQ7odHRePQqZi0l5M1yt8SOWBJnHgfoj/jNgPH5FfI4/C7ilYaZcoWz4pk1GtQvnYOy0y6gN8fcNQrJhEQAnFihng2RM3uCaTlkL2TrRjDA6Mgr9vOIyFj6lqgkydxqVx5vBj3Lpoj8qp6Amjk9WIP9pifPcNbPXUvGvVLPHB/NEgpygRCY2J+sCtEwMnNkebXjVS7MNSF2hae+W8k3jxUNpglChtgjEz26KECEv4HhEd9QGu7/3h7hIET/dgbiegz21QYGS6bL7os69nUAjGRQrD1EIPlkX1YVXcAMVtjHmx+x5A/49Ve4Zh9pg9cHbww9QhO/DH0m6oWsc6w89NPd6/L++BGYO34dKxJyhtZ45mnauk67kq1yuF+u0q4sbJZ1g9/RBWnRjH5460gD7zg2e2x/Tua3Fu9x20G1SPzfHTCup/7DmpFVaO3YXDqy+gVf96iqGbjKDNsEY4se4itwCc2nAZXSa0wo+Oj4KM5k6jKq5RQINN76lvNCVQz2hKkaCFUrB2kpVR6jUlSyi5Eif3jSb2Hy3Axz+RTxNTHaU+0sTkNESsn9pijSV1VBZwlCuR3wr3243NpDjQBcjuyJ5k9OMnFBDkM/bjRyYaCmU07iM0hQz/73//Y+KqpRhokpTRfHlzI2+eXIj/+JmbqomMKvpIlZq8DWUyqmT5RChSRAeR73zZg1SZjFoJ+5/kyChNIFqXMoaDvQ+ro8mRUUKdprZMRu9df4cxMxJOEF+CTTkzNOtcGRcOP2aytebIqDR52f3soBM0vS+3RGncuqwpJi/uCtNkenfVCeqtPXfkCbasuMQ9taQu9P2tISuiaSUPmQk6fjzdgrmf+c0rL7yz904xoEFG/gJ5edK/QMG80MiXG7lz/4pffv0F//vvf7ywxdNGLyYekTRUERXHg2KUb02XF08SbHtIELYqZogyFcxQvpIlKlS2QqEsSLZKCbr6mli6dSAWTj6Ex3ffY864fZg8vyMatJSCKTICuxrF0XdsU+xYcRHrF5xCCVtTjvdND4bNaIcn1x3g8sYHp3ffRfsBac90t6tjw3ZPT284YNeSM/h9/YB0vRYywT+44jz83INwdsdNdBoppT1lBHk08qDvrE5YNmQTDiw7jRYD6ysI148KOUGLPFrTArKY+3oKk6yMJi2FJ9cbyj+jlU/R20nnSLnFS2GGH5IMGRXDTuSrnVKZnm8rTdSXL2cmfU/MbHxLZEZ85+ecONDsS0Y/fP7ME/QEqniTnZOCnH74CI08uViJoQUwSmmgKTo2nqf7clFPS6F8CAiO4qGmIoaFeViJEJKIjEpl+sAgVTKqDYd3vvBRSmciFBVklEqTyVk4lSlvxmSUFvwmrZK3VLGtaMH2GnQieP7QBVVqp06VoZjQu5fs4e7kj5N77qHTgDqp+rmfHU/vOPGQErkUUPJJj+EN0X1Y/Uwng2TXtHz2cTx7IEUmlq1kgfGz28Mkiw38UwKV2p/cd8Hje8549shV4SGoDENjLVgVN4SFlR6KmOvyBsrASAu6epqJBvS+hs+f/+XnD/STUsi8PYPh5hwIFyd/rhS4Ogfw5fSRJ7w4lrQtgpp1bVCnUekUN22Zndw0e2VPTr66dvYllvxxFB8+fEKLjpUy/NxdBtflgTkyxF84fh9vHJWHVFKLwnqaGDC1Ndb8cRi7lp9H3VYV0tUvPmBaWzy7+Q43Tz5Dl9+aoJgI6EgLyKqo+4SWWDFmJ46suYjWA+urpXe0YY9aOLT8LDwdfHBk5Tn0nyOZ9v/oymhayaj8+YhLTQpTcj6jOglleloT5YEwUsdpuIl6RmlYSUFGFUqq8pR9YnsnWQkNF6V/ecBXlYyGhccopukzI4Y3B98PsiUZjf/0LzRy506klJK6KZftebo+Xx5WQqlsb2GUMIhAhJR8SOnCZFQ2xk9mqMlAX/SRKg01EWQPUl/fBEN8grm5Hn759f8QFfUBIcFR0FPxeytdzhzY+wBvX3mn+LfRiaJWw1Ksjt6+/CbVZJT6ggZNaoGVM49hz9orqNOsbJZMhX+vICWSemhP773Pt82K6mPS4q4cGJDZuHXJHqsXnEZ0ZByroQPGNEHb7lUzvR3ga4gMj8Xt6w64fc0BL5+4JzIrJ3JZppwZb5hKlzWFdSkT7nFUB8h/1sBQiy8Uj6uMkKAovH3tzf2lzx+5wcMtiI8PumxZexU2ZUzQuEU5NGhWNksVU6osTJrfgRXgM4ceYdW8k+wW0apL+krrqgNNIzuugY97MDb8eRoTRA9oWtG8ezVcOvQQji89OUBi8grJND4tIPJZj0r+J55i5+LTmLd7RLpeS6Nu1bF36RkxWX8b7YZKpvgZAZ0L+8/ujHndV+HYmgto/1tTFBYCwY+Ij6L3NU86yvRf8xotqCCjyQwwibWNBBLqKVUeViPiyWRUWQWVfUWVlFTl1CW+rZQ/z7dVvEVlckoDTHnz5mbv7shP6QtryMGPgWw5wPTx02dWUPKKUrTUQyod4LHxcg+pmLaP+8hKqExWqY+UUEhM2EcqyKjwIg2PVQwY0YQ9P0fsR8QqNY+bCJLn55eYjNKCTiX85PLrCWXKSUTIwzUQMV/Y5dZpKhnY37/xLk1JR006VkLpihb4EPsR6+afVFsy048G5zc+GNNlnYKIUl/o6iOjMp2IEgEmNW3hlENMRKk3dO2BEVyW/1ZElCII71x3wOxJB9CtxXKsWnQWzx66MhG1sNJH1z41sWR9Hxy7OgWL1/VB36H1UblGcbUR0dSUxes0LIXfJjbH5oMjsOfUWIya0gJ2Vaz4GHd844t1yy6gR6vlWDL7BJzefjkuV52g/9nIaa3QobeUxU4m+eePPsnw85IaNWVJNymh6fhT3Dr/Kt2v77d5nXjzfe3EU7xJIeHta+g9sSW3WDy+9hYO6XwOUke7jWvO1w+vvqgoSWcUNdtWgnWlomxrdHDZGfyooJad9JbpFSlMYu36ojKqMqQkb6zkCGHVnlKF8b3S/XIJntRSGXKPqKyEKpflaZ2Rb5ObDJ1bVI3vZbEnBz8vfsmuZXqCrI7Gf/rMfaCEODFcUSBfQtmeUFD03cQIUqnqRUpWFHKKE6mnBNrN0YUQrNT8TZZPBH+lqFAZFhaS4a+7W1IySjtOQ+PC3Frg+IVF1baiJbS08yMqIg6vUsizT2lxGjO3A598Ht14xwlN2Ql0Ejy0+QbGdV8PL5dA9jldsHkAfpvRNtOjNF0d/TGqx0ZcOvGMyUH3wXWxYucQmAkD6KwG9XdtXXsFPVuvwLyph3H/lhO/P8WsjTBwZENsPzKSyd/g0Y25TzOPmgMT0gtqA2jbuQoT4/1nx2PEhGYoWsKQ02uunH+FUf23YMKQ7TytnxWbLfpfDp3YXEFISfGm0n1GUbaKFboOkSyL1sw9gWClIcm0wJr6xbtW5ev/zDvOpCetKFLUAE26VuPru5edRXrRpEct6BhpIdg3jFOZ1PX+95vdia+f3nQVwT6JLfV+NI9RQm4hjKQW8kDYlwaYKISAEJ2Cl6diiEnJ4J4gq6TKyqhMUJV7RhMIqqyMyub4/3IkKNka0uaKDkkipIoIUJVI0Bz8vMiWZPSjUAvzilg1JqN5JDL64aPUl6NcticoDzgRCgkyGiV2mxp5cyOf2LFGKDVa6+kmnbKndCZCYFBUklxmc0vhQ6qS0CSjVNki/PWdvc8Xy1NyVv3dqw5ICyyKG6LrEMn8ntTR5KYrf0YE+ITh9/5bsH35Rfz7+T/UamqLDSfHolIq2xwyZNl09AnG9tkEb/dgnhj/a1N/TlHK6iEyei00HDd3yiH067AaB3fdY5swHb2C6Na3JjYfGIENe4aie7/a3AP6vYM2bx26V+PXvGrbQDRqURa5cv0C+5demDnhAEb23ZwlpFQmpG26Sfnwy2Ydx8Nbjhl+3l4jG6GEbREeOlnxx9F0/x39JrVEfk0NTka7evxpup6jx9hm3FP9/LYj3qTSVk4VpPh1HNGErx9eczFdxDg5VGpcFmVqWHOC0Y+qjsr9ooS8+dLZM/oFMiob2ydXplcmnZEqZLWwbnL9oUnvk8vyspUTl96FwEP30ZpFhJQQSv2nOqrKaNZUWnLw7ZAtySgNRBDkMj0NMNHQktw/SsgnBiyohK+slMbESQe0puxFqlQup6EmQrjSRKLqQUXQ1dXkRZGIqGxlIcPMXFLCvLyS38HblJbI6JeUUULtRqX5673rDmk+qXcb1oBJKZ1MNi76MU/eacH1My/wW/tVsH/ixjZB4//shD9W9lScoDOzLP/3rONYNf8Ul+DIAmjdwRHsF5uVIBLz4LYTxg/ejglDd+DujXesUNhVtcLsJV2x99Q4DBrVGBZFM9c9IDPJICWYTZ3bAbtPjkWX3jV4gt/Z0Z9J6cShO/DujU+mv4YRU1tyXCv1jlIrxtsXnhl6TtqskKsDtfc8u/ue3TDSAxpm6v6blKK0c9k5/lymFYZmugp1dP/K9PuOtuxfjw3Yvd/748H5jCvI8nvfZ2ZHvn5++40fUh2VySj9LWkdnswnSuxfGmBSNr1PblOjUECV7Jr4flnxVFZBZcunqA/49Olz4ujQLxBUbTlpSclbNDo6ntvq5B7Sb43YTx8z5ZKDbDrA9EmokXly5VIopWTVJKukBA2hlKqS0VhxUtAUu02atpdBfaR+gZGIEH2kBNXeFwKVI/T0NOHvH4HAwEgYKE2xmonUFm+VuFAZNqUlb0nHt19ePMtXLcrEiqbA37/1g42tRGJTAyq5jlvQERN7bsT10y9Qu6ktajaW+lB/JlBfJqm/N85Ii17J8maYsrQ7jNWQnJMa79D5E/bDxdGfPw/9RjVCl/61s7Q3lBadh3feY9emG0zMCLnz/MoDPx17VP9hyefXekyHjGmCrn1r4fDuezhx6BErpWMGbEXjluUwZHRjxQCGukH/W3JEoEGwx3ck26flOwezb2p6YVbUAP3GNcXmxeeweck5VK5rA31ReUkL2g2og7N773Ey0/GtN9FjlKRQpgXdRjfFpYMP2erJ8bk7bOzS7ldMCm3LAfVwaOV5nqyv2coO6kCF+qVhW8sG9ncdcXj5WYz4uw9+JHwS7WO58uRKc8CF3DMam4pperJpio36gAIqcbZymV61UibbOCmTTLZ8+vUX3nRFhMZyEIQ8wPS1SFAgiPtINQtqsGDz+fN/CA+PVUzUf2tUPboWv+RTcwJTXM5gVrZVRsk/lA66PGKHSX2eeQUxpUl7gqKHVFZK5bK9UA0KiExnuYdUeahJWS2V05rkZAkZ+mLSPontkyBCpJhSKpIqitkYMXkJDY7mifsvEcpKwvT+/o20leoJJcubo9NAyXtwzZwTSSLffnSQCjqyw2omonTi7D2qEZbtGZYlRJQst0b33MhElJSFRf/0Q7eBdbOUiFI5fvyQ7Zg18QATUdq40DDS7hNjMf6PNj8lEVWGVuH83O+6/cgohU3alXOvMLDLOpw9/jTTEp9IzSQjfBpOI1I6a9Qe/poRtOtTizdSVIZdO/dEusr1NKHdb1ILvn74n2tJDM5TAyNzPTToIEUVH1x7GelFu6EN2Qz/7SMXvHuSvpK/KojA9Zrenq+f23Ydocn063/P+Pwp7bn0MuQI0LioD19skZBTkpKzd5IV0KQDTMKDVOnzQucxmllIZGovHkfewRQLmmiISU5hkquIoTH8/9IWai1N1FevZIXRA36OWNccJI9sqYwSPv/3L3LLZPTf/xIRU4JCKRWN4zI5/ZCkbJ9AGDUL5k1KRsVBGa4Ss6avJ6mhwSqEUlMzH1vQkNm3j08oipcwSvT9fPnywMxCjy1snN/5Qbe2RGqTQ/X6Nrhz5Q0e3HTkHsS0ggga+RmS9+jq2ccxc03vHyZ2MiVQOXzv+qs4tOkmL9pGZjo8mVxKxTIoM0C/7/TBR9i49DyrBtZlimDm8u7QF7GxWQFf71BsWXOFIzgJefPmQruuVdGlT00maNkN+oaFMHl2O7TpXBlrFp/D+3d+7Bhw49IbTJzZFkaZYG9Gw3Dz1vTG2N6b4OsVigWTDmDhhn7p7hGmfrtxCzphVMc1isHDOs3Lpvl56rWxw9HNN9gI/9D6qxiSjtz6rqOa4NrRx7h/4RU8nPxgYZ12U35do8Ko16kKruy/j+MbrmDa1qFQB+walEHJKsXw7rELjq0+j8ELe+BHgTxJTyQ9PWozgRTPL4FCAeL9wxEZFgsjldOhYmpeNYdeKJ7KyqhMPimBSRYxKNyCgi3InYPIJx1XijJ9mEpEqCDDVFUMColmpbRmteIw0vt2YRYyHnUalTkJTMPmIrsjWyqjhM///o8tm6Tr//KBkmi4SS7hqyiligEnmYwqqZeKPlIlCw15yl6VjOrpCZP8ZBRHExPJqNtPxYdUWR0luL5PmmGvjKq1rVlFdX8fgIAUnutragn1pNEief/qW5w/9Ag/MrzdgjCx10Yc/OcGE0Oyslp3fEyWEFGy2Fq38AzW/3WWiWjj1hWwbNvALCOiZLq+fcM1DOm2gYkofS5adqiIHcdHs0KYHYmoMkqWKYLV2wdh+PimrBC9fOqO4b02slqaGaBWgHlrerEi/eqJOzb9nf4+S9XBQ/IepcjatIIUrf6TW/J1SmUKTod6aF7CCDUEET664SrSiw7Dpc3z7VNPEaSmHk/aSPf4XSLYZzZfQ9QPNJwpT9OTBVZakV9U7GKV2seSQyEhnCT3vmiJcnySMr2sjH6FpNJ7r4gJ/Vo+fTIpTN8L8ufOkymXHGRjMvrf//5DLlEWpVSl3L8mVkbzCHIq95DKSinl0StP28s9pYSConQfrURQtcSJQHnCnqArJzap7CgJxrIPaQoEsmhxg1SRUfJ6LCmi1J7cfY/0gOIGKZ2JsOmvs/BMJqr0ewcRz7MHHrJy9N7eBwW18mH6yp6Y8GdnNiXPbJAn7KwxezmIgE7Kg8Y1xcT5HdJsXp1ePLr7HkO6rcf+7XdYmahYrSg27B2GcdNacxpSDhIURuqV3bh3GJv3x8Z8xJI5J9ifNC4dQz1fg2VxQ0z5U7IdOnXgIa6cfpGh5+s2tD6KWOgiLDgKu9ekr0xeqW5J2FYpykrcwXXpI5OdR0hE8vrxJwjxT5/lVLGy5ihb05o3bme334S6UK1FBVjZmvEwz+lNV/DDkdE8v2aaMirbOyWbwiSIoWr7htwzSi1lcvmdoJ1sJKh8nxhYUirL823tFG5/R2Q0B5mHbExG/8fqkNxDKquk/4rJc5mMElFVtoGiyb5EPaVKB6BsVUG+aTIKFRJmwSpkNOFASyZGUfiQBqSgTJBvIsHlK2SUULW21DdKOdnpRYd+tWBXszifbBaO25euadtvBVqY54zYyb109PorVC/Glk2UMJUVCAmMxOSB2/D0njMrbjP/7s6DSlnR7hARHotFM45hxvj9CPCLYA9Omo5ftLoXrET0bA6Sgvq2l23oh77D6vM5gvxJx/TfCm+P5IcKM4IaDUqh1zCpF271glNwdZIGydID2tyMmNmWr5/e9wBu6XgunjyfIJnPXzj0AEEqkcWpQalKVihTtSg+f/oXpzNAJKl3lHB+1218VNr0ZwT093Wd0Iqvn1x/CfE/yLmM7OYyqozGfE0ZTWFIKdGgkooCmr9gXkV7SeKJ+mTIqG4Kyqgin16kMn3HymgOMg/ZloxSj/8vghCwSqoo2YuDPkWlVJTxRSN5vCjbK5fuYxP1kUongmgVjzdFNm8ywwtGsg9pQOLhJhmU902gfrOv5fXKQ0wvH7kqbDbSU76jcr22niY8nAOwbt6Pkc5078obDG+7Co9uOnKv1dCprfDn1oHQy6LSuJdbEMb328wEg5SCpVsHombDUlnyu+/ddMSQ7htw/ZI9E6rOvaqzSX2t+iV/+L7frAB5ZvYeVBdL1vdln1Xq0R49YAse33dW++8iMlq5VnF8jP+MPycf5CGP9KJSLWv2yCVF8Z+Fp9N1nJarXhzlqhfD54//4vDGa+l6HR0EkTy35266N681WlaAnnFhRARH4e7pZ1AX6nauBgMzXYQHRuLq/rv4kewIadgyrZAn42NUBBFVFBJk8EtleirHK3+meNBItJzJhvYEHfk+JZN8HVktVRlY+mqZPoMDfjn4MZBtySjhV1GmJzH0V6GSylO0quRU7ilNGHAS6U1KZFAmo3HCKF91qEn5IC4sevSSI6P6wuopMDD5Ehcd6AU1Nfi1fk2tKVbSiCchqYzy7guZ9l8DEdGpy6QIwisnnuHcwe+3f5T65ZZPP4L5o/fwLt/KxgirD49Ehyy0TnJ644OJA7Yi0C+CDeJX7BrCA0uZDfo//z3/FOZMPsj9WjQVT4bvQ8c25eG3HKQN5SpaYN2uIShdzhQx0fGYOX4/TqXTz/OLm70FndgCx8cjBOsXpT/FiDBkSkv2Hn350BX3rrxN13P0HNOUv144+BChgclvir+E6k3Lwshcl03Urx9L3/tFfpot+kmOHuos1ZO62H6k1Hp0fM0FtZnrZybkWGfaJKUV1JZEiFGZW1BFSkNKysoobZhUzfMLJ+NBKj8+LCRhQFfRM6qST08Z9rQ2ygINVRGJfMveojnKaGLMmTOHNwHKl5IlpZAbwocPHzBy5Ejo6uqiYMGC6NSpEwICEldRPT090apVK+TPnx8GBgaYPHkyPotkym+FbEtGlYnh/0Al+8Rl+iRkNIVpexpwkp8rYeJeiaCKPlLyS1NWMbXEbpUOPFUbGX0DqY8vOCh5exX68JmLmEjPZDLslUF/V8Xqxfj60wyqOuWrFUO/cdJJfMOfp/D6cfpyqDMTLx644Ld2qzizm96nzoPqYuWhkbC0TuxKkJl49cQNvw/dwZY9ZOHz947BMCoiDaVlJlyc/DlV6OLpFyDxk6yaiEjJQQk5SB+or5YU0qZkWP/f/7B26XmOSlVndYA2jL8v6ixt9s68wI0Lr9P9XIZFtNGxfx2+vm3Z+XTlvJM6WrqSJf/ssS030tV/27qf9BpOb7+V7veqWe/arAba338PT0c/qAvN+9fjXkrPd754dvX7jz3+n1gj/k+IJmkBTcnLxvlfaneQldHkyKhG/rzIKzazqqV6mcQq3y/3g8r9oQS5Pz2BjIpI0E//IirqAwoVysefG35MWAx0FYExP5etoDpQpkwZ+Pn5KS537txRfG/8+PE4ffo0Dh8+jJs3b8LX1xcdO0qhD4R///2XiejHjx9x79497Ny5Ezt27MCsWbPwLZFtyahqqVK+JZ8yZXJKJXxlFVUmp3LZXpmgamgktn9SVktVJ+/pwOPn/+9/iXpM5YQmAmX0plSGlzPLvT2+TEYJFaoV5a+v1EAeuwyui7otynEP04Kxe+Gbit+fFaDd+vr5JzFtwBYE+oWzZdOS3UMxaFKLLM1Nf3bfGTNH7eFSKyUpLd48QKEIZBZooT934hnGDNzKYQl6BppYuqEvT8l/L5nxPzrofSSrp/7DG/Btikpd8eeZJHG+GYFtRUv0GCxNxK/98zSC0pk3T+gypB6XT309Q3AuHS4YdH7sJlKZzu2/zwERaUXT7jW4T9rNwTfdEaF6Jtqo2lTq7764J2HBzSgKaOVH077Se31yQ/o9UbMKsmCRnsoOkW55vYv+QslbkT+fzFCtstqpSla1hWd2ov5QQTyVS/fyUFOoeBwdU5piuIr6SGkjpjzEpJpP/z3ge0lgypUrF4yMjBQXPT2JD0RERGDr1q1Yvnw5GjZsiEqVKmH79u1MOh88eMCPuXTpEt6+fYs9e/agQoUKaNGiBebPn49169YxQf1WyFmpVMmp2MHLG1C5giPv2OTFJ7dSueTT5/9AVfs8cta9EoGkA4wy62nQSSrfF1AciEReyXKHSvjyQUkgn1FF+kRYLAwMk/qamQhzdp8UYkOVIcdLOr7x4f4t8jnMyPtEcZl+niF4/8YHs4btwLJ9wxWlmm+lhq6aeRT+3tKwRavu1ZiEypnMWQVyLJg7fj+rSVVql+BhpcyemKeyGSl1F04959vVapfA5Fnt2EkhB+oFffZ7DqzDKU4r/jzN7zlN2f8+t0O6yqfJoefQejxsSG0eK+eexIJ1fdLV40suEb1HNebAiv0brqFJh0ppdo6o0qAULG2M4O7oj3P77qHr8EZp+nlK9anfoTIu7r+Ps7vuwLaqVKFJjzpK0aBXDt7HgFkd0jXEkxzaDm+ME+su4vGFl/B1DYBJUakX/3tGetq9icAW0MrHRJQuOin0zCf0hUalSEYpoYuGQpWhIyueSvfLw0qR4XE8yEZDTsmppVSqJ1WULA4tLPW5T5S8t0NCoxVphHFxnxLNYXxLVD24PtMSmCIjE7fD5M2bly/J4f379zAxMYGGhgZq1KiBRYsWwdzcHE+fPsWnT5/QuHGCrziV8Ol79+/fR/Xq1flr2bJlYWiY8Hlv1qwZRowYgTdv3sDOTj2pZ2lFtlVGqUdULh39HxKuJz3qpfvlnlL5cb+KASdZ9ibkEbYbVHZQRl65fP8hscpZQCwO0SoxbezJptghJl+iMBFlXz9BwL4EQ5PCHBFIaubbl17IKIjMztnQDwbGhbnHbeaQ7WxflNUgtWbVrGOshhIRpdezcOsgjJrdPuuJ6L0EIlqzQSnMWtEj04kopXBNHrGTSRFtegaObIi5y7rnENFMRrM2FfDHws68Ybx5+Q0WzTymmHbOKKhPcvKCjjxwRw4MF0+kf3CnacfKbPVESteJnWlXFek81HGwNOl/asftdJX7W/WtzV/vnH2RrlQnQtUmZaFtUIgHmR5fUV9JvUhxI1RuWk6qLGxJ36DWjwJNsZ58yVtVeUgpORSW1U4VMqroD1XqGdXUys/tFfTeyl6jqspooiGmEJUUprAY7nHXEOfQ70kdzSyYmZlBS0tLcSGCmRyqVavGZfULFy5gw4YNcHNzQ506dRAVFQV/f3/kyZMHhQsnDusg4knfI9BXZSIqf1/+3rdCtlVGf/m/X9jeSUFMv7L1lNUJsoGSf0YGKZiJ+kpVyKiGPHmv0q9TsEBe3hHGKkWKKg84BQdFsT1PcjAWZNTf7+vG1PTabSta4Pq5V3jzzEPRQ5oR6Ohr8mT6pN7/wPmtLxPSBVsGZolvJ53gbp1/jX8WnVacAEkNHTCxOQqI6LusxMvHrpgnE9GGpTBdBAVkJtycA9iyKSggEpqFNDBtQSdUVsP/NQepQ52GpZBrcRfMn3oYt66+Re48v2Ly7PYKu7iMwMxKH/1GNsSWFZew+e+LqFLbmtXYtII+g71HN8HiSQdwbMcdtOlVk3PD04J6bSpi+5KzCAmIxO1zL9GwfaU0/XyJcuYoXtYMzq+9cO3II8WUfVoJesMu1XF03SVOZarRogLUhdZDGuHJpVe4tPs2+s7unGXev2mF/LlKb0xtQVEpSc5DVEZhuT0sNIaHulRbAhTleBUyKpfkw4IS7qdKIrUnhQZFcfmehvPkaXqy2KM2JlorFARVbFQU9k4h0bxuUd+oj184K6WFCmZdUl1KeNTtt8xJYBo5G15eXomeOyVVlMrqMsqVK8fk1MLCAocOHUK+fN8+pSq9yLbKaK5f/0+pDydBGVWQTIVS+n/JclQ6UBKsoVQm8FWmM2myVdmjVAalr8hlCFVoieQmVX9SZbVTVseoVPs12NpZ8Ne3Lz2hLpha6WPBpgE8renwwhPTB25J1qNOnSDT/T8GbcNfE/czETUrqo8lu4ayGvotiOi7116YPWYf/w+q1bPBtMVdMp2IPn/kyrnyRERNzXWxetugHCL6DVCjjg1m/tWFF96r519j/d8X1DbU1KFXDR5+o4rDxiXn0v08dVuUhWUJQ3aYOJ4OdZTOXW361Faoo+lBsx41+Oulgw/S/f406i49x6NLr75IqNKKqs3LQ9dYm1XXe6ee4nuFPLgkDzKlFbKhffSXyKgglWQLFh2edN1RkFEl0ikLE3x/kvJ9Yq9RWu/kNS+5PHrl22FhsYntnr4Te6fMTGAqVKhQoktKZFQVpIJaW1vD2dmZ+0ep7zM8PLFIRdP09D0CfVWdrpdvy4/5Fsi+ZPSXXxWkkXaAMjGVFVD5mFdpJU0E1e+p9pXKkHtJP35UUUzFwFOs0mCTct8ogTLqkwN9n4YDCKkZdCglkpiob1SdVibFyxTh0jj1KDq+8sbEXv/A5ysT/ukBWcRsXHgav7Vfhef3nbmMST1xa4+PQVnRE5vV8HQN4mEl6sOlIbE/lnRFbjX1s6UEKgv/MW4fpwOR7dDKrQPZOioH3wY16tpgytz2fC4gy6cDO9QzZENq4LhZ7bjUefvyG24DSQ/o3NZzpNTreXL33XQNIrXoUZ2TfxxfesLxhUeaf75++0rIo5Eb7u/88P5V+tqEipYxhWXpIlx9uHNKfZ6j9D436y8NMl3cqT77KHWDXqeyxVNa8aVJeRm0iZYV1LDgpHZeySmg0v1CzVQq0/P9suqZqJdUJA+K55DV0hDxmIRkwsRKqXw7B0kRHR0NFxcXGBsb88BS7ty5cfVqQnqao6MjWzlRbymBvr5+/RqBgQlpipcvX2YCXLp0aXwrZMsyPSmapIYqbJt++SXB7F7hPSpP0SdmnIkUUr5B9ycorMmRUeotUzYuliH3w6iW7wmyyhcdnfziQaSZ/EhpeprK+V8jJBbF9Jm8xkbHw8czVDGNrw6UKFMES/cMwx+Dt3H++7ju6zF+QSfUbFxGLVPyJ/fcw5GttxR521Xrl8Swaa1h8g1JWHBAJP74bReiIuJgY1sEs7OgR/T8yedYyUbmQN1GpZkE/QjT8nQ8+PqEwd0tCL6+YQj0j+D2FNpoxcR84E0aPYY+0+TnS+oJDfTRQkTDe9QfbW6hB0tLfUWV4XtCg6a2bOO1btkFbN9wnXuXG4l89oygWEljtOtRDcf33Gfv0Y1HR6Xr/12rSRnOrqfACkpm6iEcAVILUszqtbLD1eNPcHbvPdhUkKosqUVBrfyo0awsbp58hiuHH8K6vDnSg/qdqmLH2+O4efwxWvSVbKPUgaZ96mDfohN4fu0NgrxDoW8qDc58T8glyCgNA6UHheRs+a+QOiKcNOQUHhQFC2vjVCmj8v10rv4Q+xEaQv2UyasyGSXlk8Ja5L5RPdEaIN9OmKYXZFTcTi42O7ti0qRJaNOmDZfmybZp9uzZPMPSo0cP7jUdNGgQJkyYAB0dHSaYo0ePZgJKw0uEpk2bMuns06cPlixZwn2iM2bMYG/S1KqxmYHv78yeBcgjk0PZU5Qm11X8RRN6Q2WLp2SsNZKU8mXimvj3JSimib8hLyzxyZTZ5eGmmJiUpwipj4zIqLzL/NrO2srakI3vnR181UpGCebFDLDq0EjMH70b7156seF84/YVMWhyi3RN2pNn3dkDD3Bqz31e6AlkXj94cktUrCWlSn0rUL/T7DF7EOQfwQMi89b0Rj7hJ5tZOH3kCdaIcm2rDpUwakoLxefqewP1QL964YmXLzzx9o03nJ38k/2MpxW//Pp/sCpqgDJlTFHezgJ2lSwVFmnfGu26VkWAfwSO7LmP5QtOMYEuVdY0w8/be3gD9hylBfzk3vvoMiDtJIzOWd2G1ceSyQdxYtddjvdNq6NGq941mYzePP0cQ2a04wGVtKBxl2pMRukydHbHdLWy1O9YBTvmH8er2+8QFhjJQ03qgLGVAWxr2cD+riOuH7yHrhNb43tDLrFWyBn1aYWWOAdHfkEZ5cfpacLLOSBJyZ2grS+932FBiVVT6v0koYN6QYl4yiKBXKYPVfLLlnuf5dK9rIzKZXpdWSkVZFT2Gs1RRhPg7e3NxDMkJAT6+vqoXbs22zbRdcKKFSv4mCez+/j4eJ6UX79+veLnibieOXOGp+eJpBYoUAD9+vXDvHnz8C2RLcmovMtURH3myqVQLRU7UKFuygv+f8kMLiUQ1C8PLSg8S1XK43Kqk6piqpxzH5fMcFPSrN/U7RqLlzRhMuryzg8NWpSDukG9Q9S/uXPVJRzbfoeTmu5efoP2fWvxgJHuVxYPKsGRTdO1U8/55+TpXTq59RrVCPVblc+yBKWUQAre4mmH4eLozw36f67vy4blmYkzRxOIaKee1TF0bJPvLtKTymy3br7DvTtOeP3SUzHUJ0MjX25WN01NdWBkrMVeulqF86NAwbycZkbHGYVPkK8upUiRxy6pJUTwfISqSkqqy/sAvpw68ZTJqW1ZM9SpVxL16pdSLGzfCoNHNeaqw/1bjpg75RAHDqRn8Ei1QjJobFMsm3kM+zbfROO2dopSZ1pQt3lZ7Fp1iV0nLh97ija9pJJdalHSzgKWNsZwd/TDteNP0U6Y6qcWdnVsWEEjVe3ZTQdUbWybxr8AMLLQRwk7C7x/7oF7Z5+h1QBp0l8daNyrNpPRawe+TzKaW547+IJp/ddI5pdsm5L0fyaTuqWsjFLvr3wO4khQfU34k+IZlEBGdQV5TaSMiteRUKYXSqggpwqj+1AplUlXO3FefQ6AAwcOfPFtILsn8gylS0ogVfXcufT3omcGsiUZzSsIZ7wYKMqT61f2C5SvEz4Lu6bcKhn1snJKB4osjMpkVNGcr8ITFJ6lKo2nCuKbjC2MHN1IPqQpQbZ/oji11KCoSCFye5+4eVmdoF5OUi9rNbHlDHsXB1/2OTz4z3WUqWTJ/Z00dEQehITIsFj4eoTA6bUXJzoREZFhU84U7fvWRp1mtoqeqW+NHWuu4OEtJy4Xz1nVM9OTlS6ffYnVi6WTRpfeNdjI/nshojS0dee2Iy6ee4lnT90S9VUbmxRGhYqWKFvODCVLmcDUTDdDk+Z0bAUFRuGdgw9ev/Ti3+fhHswKLF02rL2MatWKo1U7O1StVlwtU+1pBf3O3+d1wNhB2+DuEoj50w5j2cZ+iuM8vWjYqhxO7n+A9299sWfjdYz+o02an4OOH4rD3bDgNI7vuoOW3aulSVmnz1zz7tWxce5xXDr0MM1klH5/nTYVcWrbTdw4+TRdZJRQp20lJqN3Tz9XKxmt06EK1o7dATd7L7i/9YZl6Yyr2uqEnH70MZ1+mwm2TF8p0wvBQNW+iaAjvsfT8FEfFJn3/D1BRpVL+Dr6sjKqdJ+ij1SQT1GmJ3tDaleTe0TlVKYcZTT7IJuSUbHLlKM9c+dCRFRcIjIqk0+Fein3lKoop8mV8uXbMhQcVYVEpDTwxK9D7IS/REa/NuSkCsviBvzVwyWhcTmzUKqCOVYfGckK58nd9/DmqTuTza9FiFKfUe1mtlzit7b9vhaEWxftcVgMqIyf0x4ly0pDYZkFUtj+XnCKr3foXu27IaKkYpw8/gRnTj5nBVNG6TJFWKWsUcsapsKwWl2gv5v6R+lSt34pvs/PNxx37zjixrW3ePfWF/fvvedLEVMddOleDU2bl8vynlrqd529pCtG9duMt6+8sW3dVQwdK+W8pxdUDRg6sTkmD9qG88eeon2vGulqs2naoTJ2r7kCP89QPLrxDjUapW1YoWH7itiy6BRcHXzh/MYbxcuk7fis11Yiow8u2XM0JQ01pRW1WlfEtrnH8PKOI6IjYrkfVR2gyMxKTcri4bkXuH3s0XdHRimOk/AhJj6RKplaFBaqZrhKiT2lUnxoMkOx1NpBaU5EREODIpOQUf45pedXVUGl+xIPLFFlhI5RqohQH7mJiTYKaWogkozwQ6OVBpq+D2WU0pJypSMx6WvP+aPAwcGBldnbt2/Dw8MDsbGx3B5ARvnUDkCtAentO82WZFSD4pKoBP5RInoauXMpVFIipoR40SieN7dqST+pmin7i8o9ob/+mvhEkbizNAEKRVW1yVSpnzS5Er6MgprSyUAe7PkaSJGUh2+o/J/ZfY60iNZpVpYv/t6heHLbCU6vveHnFYoYQf4LFsoHI1Md7ge1rWyFYqWMv3kpPqXJ+eVzTvD1Lv1rZ0qbgzIcXnvjzz+O4r9//8eZ6MPGNf3mRDQ4KBL799zDubMv8Ek4Q+jra6J5q/Jo0rwcLyT/z95VQEd1dd3ztUDc3d2FQCC4BHeX0kKNulPjK3V3Wr4K0lKhFIq7uycEiLu7K0nw/v86V14mk5lk3psZGEj2WlmZmYwkmXn37bvPOXvfTqD6OmtOP/KFKune3bFwYG8CFBfVwPff7IO/15yBBY8OhrHjemosIUkVOLlYwuvvTSWl+s1/R0FYHw+IULPPOSTcHfoN9SWq/F8/H4UlX80R/Rw4WDJ+dgRs+vUEGQoUS0bRHmjAqGDiN3p4S4xoMuof7g42jhZQWVILF0+kwoCx4o8hJy87cPVzIDn1MYcTIXJmP9AUhszoR8notvOw4J2WLG9dgD4baMV2MSTyXClVFeaMZNYpKL8rUj9rlNzP0saUkFH0nXXxajFO5y1Y1RWX2/aHVjUKvqX8Nk5GcU1DtRT9snGTi2sIXidktLoRvLyogFJX39zuufB2IeKvFVpLYNJlXLp0Cd588004ffo0DBo0iHibTp8+nfia1tTUQFJSErz99ttkWArv98orr4gmpZ2SjBowoneV9STq9+gmXBbIKLuO/aTkOiOrgrH9zZZGch4NypOY5Mtf3BuOe8W1wf+1Nz2p3IYJd5V8oEYVmJgaEAsmHAgqLawFT7/b5ymGhHPSvP4A8+CuA1o3ffL6P9TCKcIDHn1BXCyiWJQW18J7r/9DvUsH+cCiJZPvSNmZo/HyVVi39gxs2xIjkNCAICeYPbcfDBrsd1uJnjK4uVvDsy+MhkcfHwZ7d8fBpg1RUFnRAEu/2gtbN8XAcy+Nht7ht88CbNBwfzLUtGPjefjm452wct0zQhyiVDz64mg4fyoTTh5MggcWDpV0/OIxuOW3kxAflU08e3HwUAxGzexLyOiJnbHw5JIpotpnkIwMHN8Tdqw+Dmf2xEkio4j+48MIGcWIUE2S0QETe5G/Jz+lGIqzykhCk67AwFiPEDdURZsbrogmoxa21DC+ufEqUVf1lYST8KhQZWTUys4UinIq2vwcSar847gyiiQSzzk4yGqlQC21sm4ho+S6pTHk5VWRifrevdzJ+RSrh7UyVZgu3F6g4vnGG2/A5s2b26Q7yQKjRpctWwbffvstLFmyRNRrdE4y2r07Oaiv3qDKqEGP7nCFNYYb8OhOrpry9CROVvkEPDspo00UJ58ji4hBAAEAAElEQVTXmZrKCSvHTWUkVUmPaUclfA4+Ecv7XVUB9jjiwlBWfHvJ6N2MVd/uJ8oo+ukt/ny2VvtXcWPx3mv/QH1tM3j7O8CSz2beMbKHKgz2g/668phQjg8OdYFHHhsKYb3d7rhSq6xMPnNOBEye2ht27bgEa9ecJsNPby5aB5GjguC5F0cL9jHaxpMvjoKES3mQm1UB33+2Gz74eo5a/zMPHzsYOjYYTuxPhLUrj8F7S8Xv7GwdzaFfZACcO5ICezdEwzNLxPWf9h7iB6aWRsTtIu5sFoQP9RP1+EETKBmNPpIsZJaLRb8xobDx+31w8WgyWR815SqBpfqQIf4QdywZovfGwoyXWpJu7jSQyBuaGkBTfTNpT7BQki+vDFheRwJ77cp1qKmoB0cP23bJaLWSZD8r/vOy1mV8TFhCVMmQUXxvccgT40BRMUUyam1LyWhT4zVy3sLZCE5Q0aKQvAbrK62qaiSbcLR3qsS8+g6cAG4Hzi94RjsJTIveBV1GRkYG8S/tCDidj183GLcSgzsvadwBGOr1ICV6zgXJdUZGDRkZFcgpK+lfZdY0nKzKklN+guExoPJ9avJxoRwtE/r3tWOorzxxQ0+fEeN2+krlYetAFxP0euxCx4g6kQZ7N18g7/Ebn8yUNMmsKvC9/uajHZCfU0l6qz76Zq4wyHa7UVhQDa++9Bd8+9UeQkRdXa3gky/nwHc/LCCWSrpIROV7rpGUrln/LEyd0Yec1I4dToYnHl4Fp0+m3bbf4c0PphHrOOz/PXpA/Vz1B58cRv73Z4+mSh5ERGcLxJEdl0StHZxgDJnQk1w+sUu8+XxgX09iwI5elsnns0EK/Pt4EHN2fI70i+33oItFv3H0bzt/IB50DUKkpwQDeFIOt2eqZ5nyCGlrdh8MGcF2AHlYsZ9Xy/WUomJKb2+tmApleUY0uQ0U+T3YbdaC8X1jazLKJv+ted+oDkzUazOBSZchS0RzcnJE3V9VdFIy2h2arl4XlE0s2zddu96KbDazA9FAn6mP8sopu85TlGRv4+opB48B5cNQHLwHRqryxdN+eOlUFXC7jeoOeoe6AERBXvYRHSCasWAA9NZy9vvmv8/B6WNp5HOCQzDWGvJRFAPcIG3bHANPP/4rJCUUEkumZ54fBav+eBL6D/DReRIqDxMTA3jxlbHww4pHiUcpEusP3tkC3329V2HYhKbh5WsPDy4cSi4v/3a/ys4XyuDmZQuDR9Fez39Wn5T0HL0GehOFtLHhKpw5KJ4gD5vUi3w/eyBRpShiWaCKGcF6VaMPSSPnWJnoNYwOsaE6qkn0HUdz75NOp8PVJt3q5TPhXqES04isHWhPd3VpfbuEl5PFKgWklSuj8j/jPaNV5fWtBJSWXlJ6vsH1w1qub1QgrJx8sgl7roRac7/SrhQmnYC3tzdERkbC2rVr4epVzR0jnZKMGun3EMgoXsYDpFnmOoJfN5a7bsAOVHlyiuDG3jxZiYMv2PIklSup8oqp7DCU0j7TdpKd2gOPbuOmw11QjlXf7Cf/J1dPG3iERSpqC6lJRbD6Jxrh9uyrYyHgDjgJ1Nc1wzuLN8BP/ztIplvD+3rC6j+fhllz+6ltT3Sn4efvCD+tegzmPjiAVB327IqFl5/7k/SqaRsPPDIIPL3tiOvFqu8Pqf98jNyeOphE2m2klHzHzOhDLh/cekH04wP7eBBfSRycjDubIfrx3Nbp/BHpRLL3cEpoY0+kgibh7GMPdq7WxOMYzfV1CWaMpDV04BWqDFwZrSpR/pnBc6GVvbnCUjzCmlXWqtqU6entmMCEKX8cnGjKlu9b1NLWKUzyZXqBjDISXsPy6rtw54eZQkNDScoTZtk//fTTcP78ebWft1OSURN9PbgsRzYbWd+liQFLPuLklJVJuVIqXGf3N2SPV0RYOXiJX0+epPIhKQX2M3wYqj0SgLnVHZXy5YFG4wieatQFxYiNzobDu+PI4ow2TtqM+sQ+0c/f2Uom54eNDoKJM8Jv+9uSnlYCzzyxGs5HZ5PPI6qJX3zzANixE9i9APy7nnxmBHzxDcbmGUJWZjk8/9TvkJQoLS9dVeAx/MrbkwgJPrwvgfSRqhsTiio9qtjb/z4n6TlGTw8nn+346BwoF0loUd0cxIaPzu5PFP3avYf6k2pQcU4FlBVUgRSEMWUUy/RXGjWnzuD/pNcIGmMcr2Giqy74RHy9Col7imDN3C6qStt/v60dKBlF14M2P2NEVZ6MolODsam+oI4K97dTPmWP7hytrle1LttX8YEmK90p03cBICwsjAwpYRTpb7/9BqWlpSQFKjg4GJYuXQqVlZWS/k2dkowiAW1ovtqKfF6+QndzxszuqJFdN2HXm1gSkrFB6+tGLCkJceUK6zuVuY3czkiqoUFrQsOVVD0FeduCatpeg3+LgamKfzm1UiJ/n4p2UJ0RN27chJ8+30MuT54bAQGh2vUTXfn9QSgrqQM7BzN45a2Jt70Ujj6di174i0yfo0fnjysfJX2Wd1tJXlWg4vvzr4+Dt48dKdu/sehvOHlcuyqYf5ATiXFFYIb9LQVBF2Iw8+FB5PuB7ZdUtnaTBZbpQyOou8Cx3XGiHz9wbAj5joNI7Q1ZKgL6UwYwZ4OLEv/vDu42YOtiBbdu3oLk6CzQJEKHUqKra8qoua1yD1BVgLZaHSmj9H6McCqoGtgwoooJTfi/l4UVm9iXJaNC+b5ChqAKaikjnzIDTCis8OtYlscNl9AzWiONhHdBO+jWrRvMmDEDNm3aBF9++SVkZWXB66+/Di4uLvDwww8TkioGnZKMIgFtYGTT1JDu5jg5Fa6zfiFOTi83y5FVgYy2WGQItzHCykvonHTKD6Ncudq271S+tN+eaTcv5Yux/cEGcl5O6YJi7PrnPBTlVZFJ0IefG6HVf9Ol8zmwb0csuYzelBj/eDuxYf05+OSDbUSl7zfAm5SyPWX8A+9V2NmZwXc/PgwDB/uSnutPPtgK+/aIJ2Vi8OgzkWBiqk+m6/ftpO+5VPQe4EXaRzCx7JDE54qcTHs/j+8WP6wT0s8LjEz0yVR9ely+JHUUEasG4Qsd5Eu+J0VlgiYRPJA6BGTH5+tU36glUyXbG0BSRRmtLFZNGVVERs2tjYmqjSRRNlmJPM6+7RBTy5R9y315Lzwv3XNyigEvTU3XwNLSiOgrOPiLm0WulHaV6XULFy5cgOeeew4cHByIIopENDs7Gw4dOkRU06lTp4p6vk5JRk0N9AWyKU8+TQ31yMAR9x3lP7/Mfm7CyBwnnvw6uY3dR1YtbZIhfbLEFcGjLw0VmM9fbYeocvCdqZh+PmEC/zYMb9yNuNxwhWSAIx55YZSgJGsDOMm8jCmwU2b3hZ7h7nC7gArELyuOwi/Lj5LrM2b1hY8+mw3Gt5kM30ng5vD9j2fChMlh5OT67Zd7YPdO8RPiqgI9fuc/OYxcXrPquMr+wIqAqvUUNhW/a+N5Ua06HINGB5Hp+PyscsjLKBP1WHxcH5aEdf6o+HJ22BBK+OLPZhJDdCkI6k+DBJKjNKuM2rpaEeKG62vGJc1O66sDocxeXCPp8TbONBWtsoPH2zhZKiWtxLie9YfKl/FtGFmulBmQshEGnuqVklE8x/F1B9VRPJ+ZmxsJE/UtKUxdcw66ACSeISEhMHDgQEI616xZQ9KYPvnkE/Dw8IAhQ4bAH3/8QXpLxaBzklFDfahrpglA5kb0IKhjRNLMyADqWQ/S/ff9h5TlcaEXyCq7fz0rjZnKnLwb2ONMZG7jBBWHmuRL7gJ5VWBA3MzIrnzJXxZccRUTecg9MtUtE96r2PLnGWhsuEKmlsdMpcqRtrBhzRlicI+L8+NaVmBlgZ/nlT8dgQ3raL/hk8+OgOdeGqMxv8a7Cfg3L3p9ArGBQmBy08F9CVp7vUkz+oCjiyXxXtyyLkqt5xoxsSepdBTnV0N8BzG7ioAbrT5DqLp4UkLvZ0QkJaMxx1JEP9a3pysYGOsTe6aclGKQgqB+3kLf6E3mWKIJINH3j6DPnSbRfkobsHG2It8rC6slPd6WPb6mrJ4MaHVUpq8oUkxaeam+Uk455cpoK+LJlFFsC8PUP3Ib8xqtlFVLhT5SXrpv8Rq1YQNOmFV/p9F844ZWvu4mLF++HB588EFCQLdv3w6TJk1qk5poa2sLq1evFvW8ndL0HgloXSNVAsyNDIgqwsmmubE+1DVcEYgnlsBRFb3FPEHNWQRnfSO9j5lxi3LGDxYzdh8ExpohTEzaKk78/rLklQPLFbIpS4rA1VOudqoCVfxLOytwqGvHekoQcHpem+SsvLSOkFHEM4vGCO0TtwO//3ocNm+MJpdffm0cTJ56+wemdAlIPtC+CpPStm6OgW++2k2Ou0FMvdMkcEP62DORJOp1y7pzJKXJ1Eya+o6fmcgJobBnUwzs33oRwiI8RT8HRvVGHU0lFk8PvzRatAE+ArPqMZOcp/CouikOivCEC0dTIPFcFngHi+/LdvaxE/xGc5KKwLeX5ioLvr094PT2GMiMVW/YTJOwc7MWlE1UbcWGb2A+PTe+x+dQZnzPldEKJb2lNk4WABdy2yinfLipUqaNANuODI31yIQ9xlC7eNiALU95qr5MRBEs+yMZxXAKPsRkY20CmZnlUFl5GYyN9chcxU0d4Gz9VnfOOFBZZGZ23BbTo0cPeOSRR0AM7jop5KeffgJ3d3fQ19cn+ahSLAUsDA2glpFJC2MDqG++Cv8ycmZubAC1LDfdwoROntcycoqT8z2Yt2c9u81cpoxbxx5nJnNbfX3b2xDYo8fJpKmCUjAfMDKWIbvyuMIIqxgiwxVRPonfhRbs/CeatE54+trDgEja06Yt/PbzUdKriKX5ISOownQ7sHXTeVj311ly+aVXu4ioLCF99sXRMHZCKHE1+Oyj7ZAmUbHrCENGBoKnjx00N12HLRKn4TnGsaGoM0dTSYuJWEQM9ycld4wGLcoVNwVrbm0C3syCLPZUhqS+U4RU83tUY/x600GoDA2TRq8wN/I9J7EAdAWWDubQXa87/HvrX6iQoI7iZ9yWlerLC5Q/3s6F3gdJPsaHKhp+Q1SUtFZGbZliWiHnY8pL9fx27MXHjT4eZzwC1IYpozhESa5b040NJi8Rb1Itho10QTdwVymjGzZsIN5WK1asIET0+++/h7Fjx0J6ejqRhVWFmZE+1DRSayNLY0OovdwsDDZ1v/9+qGHXuQpa00CvW8iQxlp2m7kpJayIOhaZ2Iqg8tvMWu4nS2ZRecWdnzx4/CIOPCgDV1aNFaiuytCenVRnxvVrN2DXBqoWzl04RKuT5NkZZXCMpfE89fLo2za1fuZUOiz/kfpcPv7UcJgyrXMrovLA9+HV1ydCbXUTsbh6d8kmWP7L42AtQvFTBXjML3hyGHz45kbYsek8zJo/AEwk9iZ7BziAh68d5GaUk5jQSazdQEypPjTCEy6dySQRobOfoD2tqqLXYF/ISiqC2DMZMJJ5l6qKwAhKRlNickilRspxgGooGt9noF3W46AxeAS7ku8lWWVw/ep16CFj4XengOTbwcMGCtJKoCS7HByUKJvtwd7NGgozy6AsrxKA2WPJw9BYH0zMDUkKU3lhDXgEOLb6uS1XTuWUURvmQYrle9n308beFPKzK6CSTdkjEUU7J0wBxNts7EyFY6xtmZ4ppVYmkJ8vrq9ZG4heqKU40MXvQGeHaHkMpdeTJ6Ulf2iicfbJJ5+Exx57DAIDAwkpNTQ0JF5XYoDxm9WMcFqZGEI1I5ZWZkatyKeVKb/e1Orn5DZGFi1lSGYN8+60ZM3X5DbmjYb5urKoZbdbmBspXITrmMGvhaXyHO3L7HcwlSO67YFP0RsY3fnFVZdw4kASyYO3sTeDwSwhRlv4iw1Ioaeoj78D3A7k5lTA55/sIG5gk6f1hnkPDbwtr3u3AUuG73w4Hdw9bKC2pomkNfENnCYxYKgfuHvZEnV012bxxvMcuHaMmkRTg45ImIpH9Ge9n9ESbJbCBtIhooSoLNGtP76hrkSVra28DGXtKHXtwbsnJY1ZCeIn+jsyiDe2MCItXEWZd54EcTj70PWiML1E0uPt3W3I99L89v1d7Vxof2m5AgXWFsv0hIzWKOwlxXNMI6sIktv5wJNMLykSUHIbm7y3EfpIG1orpcyLFMv2ugDD7t218tUFCWS0vr4eRo0aBT4+PvDZZ59BcbF2SlnyuH79Oly8eJG8tuxOEa+fOye+1CVLRgXyycry1fWMfDLVs7quSQHxbH0beolyI/zWZJSWISwtWhPGmpqmdskmjz6zkCOxigirudxzt4fLDWxoqhNNTauCfVsoIZg4q4/oXiwxyM2ugLMn0knv7oInaJKOtoH9x0iqrl65QXLlX3hp7D3rIaoJoLvFR5/PJn3eaaklsGo5TcbStDo69xHqFbp943nRsZqyGD4uhLyfqQmFkhKZsFSPSI0rgMsyJELVNCYklJUldVBWKG7Ku4d+d/BiZf40iUEA3j1pOb0gvbTdoRyxwP+nCyN+RRni/BK1CRc/RkYl/k68T7Qkp0IyGbVzVqyMYoyoOSunl8uU8AXFVMbySSCjnHyyCXvsEW3lPcry6nWFjHZBh8goTk8hAX322WdJ2Rz7N8ePHw+bN2+GG1qcCquqqiKpRHZ2rT0Q8XpZmeKd67Vr14gELvuFuHHrltAziupnZUNr8llV31oJrWQqpjUjmU1XrguJTIIhL7sPRn7KWjtVM9LJI8+Ev0fI4W3bC4Mm0lw55ekTisCzfS1E9NPUs+dFm5kuUOA0ckp8ISEIo6f21uq/hfcIDooMAFcPqlJoG8u+3QfFRTVkwX/n/elE/etC+3B0tID/vkN98rZvuUBaHDSNYaMCyUkZJ+uPSJhmlzUWD+3jLkSEioWdkwW4eNmSXsQ4kTZJ+gY9wJeFQiRJ6P30Y0NHGRK8ShHYA4km+jdv3IKiLM0qmE4+9uR7cXY56AqcfdUjyFjmR5Rimb4d2LtSMlqar1wZxbAFXp2T7yeVTfWyZYNNFTLT99zeSVBGWZm+RRml1ysqG4ji7uluAz1Dbn9EchduHySdlWxsbEjvZnx8PERHR4O3tzcsWLAAHB0dYdGiRSpNW90OfP7552BmZiZ8YTIAgiuh3e6/DyyMDKCyju6+bM0pqePXbbjXGVM3bSzYz1kShKFBDyEOtJI3YlsZt1KdsAEbwb3SOFp6Y9ru+JCIYnP3fff/ByzYayqCkGDBShqqoIb9PpZdO00Bxw8kCkbiPJpOG8CyL+8Vnf3QALgdOHYkGY4eTiafJSSiPA62Cx0DQwBmz6Venku/2gu1GvY5RD9FnKZH7JDoFcoxdCzNez95SFree/ggWm6/dFr82h3Ul07xJ0uwl/JhRDYzQdqgEK617oFO5HKehgfOOHEry21fRbydcPWnf2t+arHk5CpEaU5Fu5+3FjJapXADIiigcmo4J6Oytk/Y+kRvaynT84l63kdqyy2gGq8SW0OuhHIj/NGRgfDFB7Mk/c1duH0YMWIEfPzxx9DcLD5uXC2JBOOe0G0fv+6//36YMGECJCYmkn7O7777DjQJa2tr8hrl5a13qXjd3p7uYOXx1ltvkbYC/lVYSDOouRJqY2pE1LAKeTLKyKethUnr65b0egVTNe1k1M4KRvJs2RSgcDsjnbZyJAd3fOR3UEB+Kthu0crKRKmKhQtJBbPQ4FOMqoD37fAySRcAzh6hPolDR9MTurZwYFcsiXn1C3KEgNuwy8dNzQ/fHyCXH1owGIK6lAXReOzJ4eDpZUsGCpct3a/x92jclF7EtiYnsxyS4+n6JAUDIwMIMctMKWmlQKmK3oyMxp4TbyAf2JuqmykSSu3eIZSM5iQXSza/d/OnAzb5adL6KJXB1pVaKZUXtN9feTvhFkDJaG15PdSxc4hYMoqfE5ySr2fnLIX3YzZSisr0shP35XJepLbMmL+VMiqU6esFAmzLCSo712FrDLcxRHUUjfBN2WAuP1d2Qffh6uoKR44cAX9/f+2TUSzFb9myhRidurm5kVzSV155hTjx//nnn3D48GHYuHEjfPTRR6BJoG9VeHg4+UM5cPHC6wMGKFaZ9PT0yOSb7Beiop6RSzO2u6tlE3vmxuRgKWfKpx0jn/y6LVM3BTIqoy6WV9EDxlbmtpu3/hXK8XZyE7nl7CC0Y3m+rX7GSKY9O2AVoaH+Chl+IPcTQUZ5T5kd28F2duACmZ1eRhbofsM07yvJgZ+rAzvjBOPz24GVPx8hnxMvb1t4iGWZd0Ec0HVi8dtTyATw6ZPpcPqkZvPK0WN0+Bi6Cdq7TXr6E7bqBIZRYndOwiBScLg72fgiiShTYnauDP6MjBZmlZPACDFw8bYjvaNoU1eaJ4308d7OAg33dnKT+eoOstxvJzAowJHF9UqxncL/NU9iKmqn/YArozhYpkhB5X2j8n3Cdk5ty/RofI/rK/ZFY0uKrBiCE/UctuxcWCFXqud9pF3QfWDy0vHjxyEpKUn7ZBRzSHGiHYkoenxiPukzz7S2O4iMjARzc82THWwN+OWXXwjpTU1NJX2rTU1NZLpeDLgSaseUzzJGRu0tTUgGfTOLyrSzoOS0jBFKeyv6N5axnZq9jApaxg4gB9YLw20p0Cy/e7f725TpyxjhdGC7RlmUsubv9khmCVsEMM2ih55qNk34t5QU0Mc5sZ1vZ0fsOdrn5hvkCGbtDIupi7SkYigurAF9g+4wVMvT+oikxEI4fCCRDEphwpCYyNgutIaXtx3MfbA/ufzTsoNwhQ0qagoTptE+5ZNHU6BJga+jqhjABpGiT4jvbzUw0gM/plImnM8R9Vgs2dozpSwjXhxBwmFBN19a2ZKaxOTsTclZSXaFTmXBawteocxBQKK3qjMjs+25BGAvLlYN0SC/RmbwiMOBkVV55dSOK6MyBL57925gxabl+e12TGjB1iU+vMcn6nllsGWiXnfIaFcCU/vg5Xkp9leizSax/D579mxiOq8MSERzczWf6Tt37lyorKyE9957jwwthYWFwf79+9sMNXWE8jr64Xa0MCHqJe8RdbQ0hdJqeiBYmhqSCE+0cLp2/SY5qfOyfAkjnvYyamdJOSOXMkpnCSuXOdibkQObA0u15ew5HB3owSsLHDZBOLHdpyIUssZyZ7YoqFqixzxsVEAcXNq+bmdEwkW6oEtJrxGD46yXb+AwfzBoJ+JVE8BNx4ofD5PL4yaGgT/rqeuCdDz08GA4ejgFykrrYP3aM/D4k5Ea+3f6BzuBm4cN5OdWks/JRGZkLxb9hvnDr98dhMSLeSR60cBQXKpXSF8PSInNh6QLeTBGpHqP8Z6okmUmFgrJTKrC3d8RMhMKIT+9FIZMEh/B68TIVUluBamWyUcTSoUZq3Kh+TvGjXZjgSd3Gj69PeHUthjIuChu08Dh7GsPl46nEL9RZejeoxshpKiMluRVgpVclY4ro6XyZFSwfWqtJmMrGSYw4ZS9f4gLmJgZkI05OnxgdcrJ1QpsbZUPMekK+q9aCfe1w32k4N+rd1cC08iRI0kevZNT6/MKipPz58+HjAzxARgI0UctDiq1R0S1jRdeeIFkouKkPA5Pofm9WJQy8mlvYUpUUlQvcZgJJ+tLqmjZwJ4Tz0p63drcmCic5LYKSjIdZYkna8R2YI3ZiKJSekA6sB228PpldcS/DvtiLBVYOxUwzz1npjYoQiGbhnRxV13hxHI0eYyHDdmtdgEgLbGI/BuCelGLGG2RwzOsdHo7VNGzpzOIJREu9o8tFGdi3gXF0NPrDs++QG3lNm2IhnKZ8qK6wBLm6Ek9yeXDexMkP4+zmxXYO1mQzW7cefFiQFA4Lbcnsw2aGPgwi6ZMdjyJgRuzK0IyKgW2LpYkUe761Rskd11TMLFsGUZtZC4kugC/Pix16pI0wceFuQR05J/qyAa4kIwqL+PXKCSjjQ1XybS9cDufsmdVP5IGxQgubvBkh5q4MsrnLDg57YJuAPlfaGgocVNC4Abwgw8+gMGDB5O5IanolIykrJapkpamUFLNSKSlKVEvi9kuzMmaHhjFjIw6yRLPCnqbo615i9LJHucso3QWs5KEMytdcBSyEruzk0Ubv0ckLgVsgtHVzapdv0qEu6fqKRyZrAzmfZuM1nUdqB6hrRMv02sLuVkVpDcKB1XC+2lXgcXPz5rfaSjFjFl9wbIrRk9jGDjYF8J6uUFcbD78sfoE6SXVFEaMDYbVPx4mQ0zlpXVgJ6IPnAPXkvCB3iSrPjYqWyjbq4qAMJY6VFANdTWNYC7XWtQeuF9ojoQpb1dWpm+vh7E9oGKJeekYcYlf1nLrrVRgn7ChqQE01TeTNCJzBf39dwLeYXTTUJ5fRYaQuIKrKlz9HAVv1vbg6G4Dl06kQYmCmFhH1uZVVlRNrAjxf8XbPcwsjaC+pon0Hnux9Cb+eZaNEMXbCnKrhJhQPlFfwSfsmVLKh4B1AVFPPa2dBKYlb8Pdgj179pBY9scffxx27NgBeXl5RCDcvXs3jBkzRvLzdkrDwZIaRjitTKGYDR45sf7P4ip6sDjZMDLKyu9OjHheuXoDqtgu2Znt7Eor6qnSqdcNrGT6DgtYud1FrtzOlU9XNq0pb/nU1HiNWPE4M+NhRcjOoAu3h7fqZBS9NBEBzE6ls6Mgu5KQNxz+EHPiFYuL0bQvtWcfd2IMrU3EnM+B7KwKMDDoAbPm0j7HLmgGSPaeeGYEuXz4YCLkd+DVKAbouxjC1PmTzN1BCtCeDBHLPnNio0HRbxSRLnKy35ORDvSlVJRnrlIPY04lITZSYCuYtFdpfGAIceWyuMEsbcLY3EjwG02LEf8+u7LHluVXkZ5QZXBiQkexAoN8awdzEnZw8/otqJZTo+2dLdoMN8kro+Q2dv7kVQY+wFQuR0bLmfijC+hKYKJ4/vnn4aWXXoJ//vmHzA3hILs6RLTTktFGdgA6WppBMSvLO1ox8sk++FwZLWRk1MWOHkxFZVTtNDXWB1NjmiddyBRQF0fLVkpnATsYXeXIaD6zCnFToHxibCPC2dlKaX48Nn1XV14mfayePqr1y966eQvSEmgJLZApIJ0dxbwdQkSrgxTEXaBlz95a7ktFbNl4nnwfPykMTCXmnXdBOfwDHGHwED8Sq7p2zRmN/quGjgpUm4yG9vEga1BhbhVZI8TCn21U00WW280sjcGSkYd8kfGZ2JvYrUc3uHn9JlRJnFzH50BUSkigag/6RrTv9mrzNdAlBPTzJt9To8X7wprbmICJhRHZiLcXFODkScv0RQoGw1AJ5X2jJXJepA5sY1BapICMytiOccsneWUUy/Io7tjJpDLh9S7oBmpra2HmzJmwfPlyWLlyJcyZM4cQ0Z9//lmt5+2UZJRHfxrqdYeiSkY2bejBUljRmnwWMvLpwvo+C1gfqItMOT6/iJIaF9Yvg8ChpxI2hekm1/uZyxQVdwUT7ahqIdDbUBnSk4uFflFDtlh2hMzUErh65TpRP9y8bk/yj66jjJ34sM9OW8BFNCWBqkxc+dIWcPDtYkwO2aRMm3l77KM6I+Y/Oph8P3E0RRg21AQGD0evUDy+S6BKYp+ciakBePrRsneSBN9PnyA6lJCZJKH3k5Xb81lvuqpAYsOns4sVlIRVAS/NV7P1WVPQM6DDhteuaC9dUAoC+1Nf2OSz4odFcLPiyvt02/Fm5coo9owq8oB1ZJv4EjlLLns+3CTTT8rXWFRGuVWUHTuncitDHFjCVrmbN/8lcdgYCIPHA7bB1bH47S7ceQQHBxN/99jYWOKstHbtWli9ejW8++67MHHiRMnP22nJqAtXPjkZtTWHmzdvCQNMLrb04ClgZNTVnl7PL6YHmJtjC8HMY2TUnfnSkectqiFExNhYr5WtE5ah8tjB68lygmWRxVQF73YUzzRGRv3ZiUMVXGQWRj37emhs2vRuR01lo+CDpy0UFVSTtgvsF/VkFjTawv698eR73wgvEmfZBe3A28ceIvp7keMbh5k0BUtrY+GYjjolbSIVEcw2PYkXxUdserPXz04VbyDvytasgizxvZ/cZB1Lx1JgxYhNtUzKjyaAU+UIVG11CSGDaT9w6vlsuM6sCDUdFGDHFOsb124qVJwdlKQ0CWV6mY0a5tMjCb529YbgNcqV0XL2nqHLixXrf8UhJrSjw+AXcp+uISadAVp5njx5Ejw86CAddzrCRM7r16Xb3nVaVuJibU52aPlMCXW1MYeiqnoyWW+g1x1sLYyh7vIVqGf9T5yM5hUz4ukkQ0ZZudddpsczh6mfnm408UKWpOJOD3v6HBQMKWSwpnIftnNVhFRWQhOT4hNzmp7cwgfQ8k4XABrqqCeaNv1Fs9Lo++nla6/VTHj8LB85RI2Gx4wP1drrdIFizjwatHFofwI0iDR6bw/9h/iS79FnpEcqB/WibTipIj0/ER5+9kSdqq1qhBqRBMCVbbYKJQwi2XHfSolKswXrN6zVsA0QTukj/pXYy6otOPvYg7mtKdy4dgMyL4qfqncP6DhCFT1g+SZBUameDzHJl+m556xsz6is1ygPXuE+2lgFQCGodR9pXeu+UQVep124M0AFVJGg5ezsTNI4paLTklFXGwuoudwMjVeukVIAKqN5pazH045OueeWUJLpYG1KPEcReWyx9GAqKKojuaxp3lNmICmb5Rl7MXsMjkymfHp52rbyHkVg5CA3vPdlpTZ54EGbwshooIqDSDgZm55IF50IdrLrAkBzE91o8Bg6bSCP9QB7aFkVRSsnVBNwkzOARTt2QXvoGeZKWmmuXbsJB5girQlEsPcO+4yvS1TjAntSMpqbWU4cI8QAc8c5ycjNEFdud2ZlXRxEktrzWSGZjFKiU88GUjWF/7A1ur0c9zsBPD8FD6R+rolnxCduuTPv4dwOggZc2ICsIqeDFusnxT2jGEsrO5DmICimlIzi4Gj3HveTcyiPBeWpg2VMLeV9oxU6NMTUGVFQIG5jW1ws3lWj05JRd1sLyCuvFSye9Lp3E8ioO+sHzWUleXdWkkcimF/CyKgL2xWW18HVazehR/f7wUmmjzST7SSRdMoig5FRHwVl+FS2MLi4WoGJieLhk4yUElLqwBhBNMpWBeeOp5PF1CfQUasl6bsNPPlD1QQrKShi1lGuntodkjrDyrr9BngTT8wuaJ8MTGHm9Lt3xmqMrOBAItpx4THOe43FAo9xnM7Hk3xWqnjvTndfujblZYpTOJ3YeoSG5zdvUKVLVfBM80qJA0ymLLq5vpq23mgMusVBWyF0CC3Vx59IFf1YjyBaVasorIamBlohUgQX5nSAUa/ycGI9o1iml+0ptbIzpZP2N25BlcykvT2rJnJlFMUYoW+UDTZxZZSTTzsds3dqvn5DK1+6jr59+8LTTz8NMTExSu9TX19PEjKxpxQj48WiU/qMcjKakEMXag8HupPLYUoov55bRHd8Hk70emFZHdy4eQsM9bsLUaDZrBzv4WpNjPMReGLKYoqYjxwZTWNlWz9mryGLFDY0ENhOL2hsDC3JhPZ2a6OsKsOpg7R8O2hEgEr37yzgE5ra7KEtYSpAe2lamkBMdBb5PmBglyp6uzByVDCs/OkIGWJKjC+EUA24VCDJ7RXhAUf2JRJ1NIwZnIuFb7ATVB1tgIzkYghhZvaqwt3HDk4fSIJ8kb2fOE2P1mVIpCuKa4hPpapAqyBElcy0tRiYsvAQTEuS9b1UF7w8z8v1uoSewwOFIabrV69DD33Vk91MzI2IGo1KdG5yEQQP8G03arVAgUMC9pRi6xG+32jvZMM2FPi/xyGmotxKKMmvFozweS9pqyl7BzPSV1/GKoJCmb5UN+2dBv60qlMmMKWkpMCnn34Ko0ePJqb34eHh4OjoSC7jdD3+PDk5GXr37g1fffWVJPN73TvCbgOwLI9l+txS1utpZ9GKjHox8pnFyKiXM90BZhcw4uliLRDBTFaO95ZZeDGnvr7hCnTrdh94yqiXqKxmsgXeX4HxfBJPA2qnF/QSy41W1SaotroR4hiBHTI6WKXHdBbwXl5Fk6KaAi8/2cjF6WkS9XXNggtD777SyEsXxANjXYdF0g3eoQPSk5Pk0ZORx3gJSUgcPsz3U4oy6sI20IUis97xeLJT0C+oCqwYGa0ub5CkMqNVEUejBieveS8jKn26BrcAJ7C0NyNeoSlRmZLV0Rw2ENueJ2mhApUce0rtWUkeiacsHF3bxoU6MFJayjboCHtGYAUyylKYypiiyq939YzeWVhZWcHSpUuhtLQUfvzxR/Dx8YGqqirIzKSfu4ceegguXrwI586dk5zC1CmVUQcLU9Dv0Q1yWFne08EKbv37L+Ty647WZEHMZr2g3qwXNJOpoN6uLQQzQ4ECms52kR5u1tBDJnYzJ6eS9IHhhL2zzAAUAm9PS6GTjcEhintBMVeeDy/1VjHJ58SBJLK79wt2Aqd2Ep06I7BfCXHjuriSoqrA9/QyG27hU6LaQFIiLee6e9iAhRaHsbrQFqPHhRAXgxPH0+DFV8ZppOUDqx7cwg1VJylBCV5ss5stIWLThftL5tJQCPmUuPaA5KQgs1w0GbVg0Y84tY7qpiy5VAVIjNAT9GrTNWhquAJmbApbXaDiiOiug60v+L6EDQ+Co/+chbjjKeSyWDIafSABcpOUt4O4MGW0ruoyNNQ0CQq0bGsG2nHhV69Bvm0m7THNq82Uvcxkvj3zH21RRllSU3k9+ezZyaUy3Wmcff4p7SQwfbAEdBkJCQmk/G5gYACzZs0iX5pGp1RGPZgSms2UUSSjGPuJ3qB63e8HZ1szqKxtJJP09/3nP+DhSA+szHxGPJkKigdLeg7dMfp6tvSApmXQE4C/XCk+KYWV4QOc2pTYkYgieTG3MCI9o8pK9OjB5uhsAY4qln0P7Ywl30dOClPp/p0Jhkb6AsnXBi7XUyKK77WxiWZLO7JIYcpGYLDqVl9d0AxCQl3BxsaEfIZizotPw1EEVJDQ5gmP9fQOBkyUwZNHbOZVibb+4QNMmC/OHSe03fvZQ687GJvRPvnaKmn9gYbsGGuWyURXF9eZv2gPLSenSUVYJCWgl47QViwx8GTKaHY7ZBTjPflwWYECg3xnVvkrkktpcmTCB5bpORzY81SVNwjDeVwt5Z7P3Pj+6tUbZKDXjrkkNFy+ClfaSYu6XTDs0V0rX7qOXr16ESUU4enpCdXVLe+rptBJyagl1DVegap6Ws7xcrQSSvKoit5/332QyUry6Ceq16MbJZ6sJO/nQYlnZXUj1NQ2wf33/Qd8ZDxDU5kaESBnz5TEekKDFPSExjKDasy+VqZEcO9BPnGritF9dlopdO9+Pwwb21Wil4cJO/nVs3hXTaPxcsu0vqr9vVKQxaaefduxA+uCdoDv65BhdJDk1Ml0jTwnHv9BzCmDO2eIBdro4Ocb+6IxjUkMUIm1Zm0lsmRCFdgwpatSQu+nOase1EkcVhGiO0XGkbYHnrzEk5h0Db1H0HU981IuNNSIG97yZBU4tHfChL4O/WMVuCu0RIa2LtM7CbZPLZ8fc0sj4taA51KctG+ljBbT65g6aGVtLEzUGxnpkUoioqtUf+dgbm4Oubm03Q+z6LXR2tZpyWhWCV2gHa1MwUi/B2QUst5P1h/KyagvK8lXVF+G2vpmQjy9WNk+je0U3V2tBesn7DFKYwdtEDMWRuABmMhOLCHBzkrJaC8lwwbYlM+9B7kXYUfYt+UC+T5wZKBWvTTvVlhYGQl9tdrAVVbiwwVYm+ARsl5ato/qgmIMGkotdqLPZcGtm5pZpP2Zyp2WVCyZ0LqxFLd8kb2fCAfe+ynSasmK9fhVSyirmrJwkHqRpIpD35BFd2qw0tHMMumNdDRa18bZEtwCncim49LhRFGPdfS0BQNjPbh+9QYUtmPj5epjr5SMOsu0dCg0xC+sFogLfiaFISbWxsHJaE11I2lJIbcJyUz0M2TPPlOVLJCmC7cfGP85bNgwYnSP72OfPn2IQqroSyo6Zc+ol70VZBTRg8fHiRLLdEY+/Rj5TMujC7ivG13Q03JpOd7DuYV4prByfKBPiyKFU/RXr90guzlXmUSm4uJaqK5pJCplgAxJRTRhLygrtfYOVzyAkpZURJIrUGVTJVayqfEqHN1DhyomdEVDKoQ1KwFh2Ugb4PY2+J5rC/jZqWGJJsraO7qgXQQHu5AYTuwPTkkphhAV/X/bg18gXSMymfuGFLh42EDSpXwokOD7idPQiTG5giekqrBkZVYcRBILU7ZhviyyNYCD99ZyUqMubt64Cdea6YbSUInVni6g75iekJ9SDBcOJcDwOTSMQRWgi4hXiCskncuEzPh8wXtU2RBTATvfKfKWxal8tMrjPdOYRY+T9ngbfhZs2IAaluXRMowPMaF6b2jUA5qbrhN7J1cPG2KGn5xUBGUydk9Z2RVdyugdxKpVq2DGjBmQlZUFL730EokBNTHR7BxEp1RGcXo+g5XlfZ0p+cwoYCV419bk05+V31OZ6W8A811DpGQyMirTG5rIeryC5fpC4xIKhCl6eR/IuEt5RPl0crIAB7ZTlMfpY2lCiV4VcnNoZxzJonf1tIHQPuKsXToL7J14iUizeda30zqqlPVamZkZgjErU3bh9gJPun2Yu0VMtGb6Rr39HIjrB7oxoFuCFLgwH8giCRGbtmwdQs9QsfZOiFoJ8Y0m5oZqTcP3YBUIPnSkLppYzzfCyIz+brqI8NEh5PvFw0minQi8Q6kdWTY7PymCK+s/zldARnHwDNVVXOtKC6paT9qzflDZIaaWKfuaFrVUfqKetYiUcjLKRANd8RrVJXzxxRfkf/jKK68It129ehWef/55MgFvbGxMVE3Mkpc3sccceUNDQ7C1tYU33ngDbt5sP2Rj3Lhx8MILL8AjjzwCL7/8stIvqeiUZLRHt26Qzsryfi62UHu5GcpraWnIx8WGxICWsiQPf3dKPlOzWB+oFz0wb976F1I5GWVlDERiMi3FB8vtMmNjaU50r55tVc3oKOoR2aefl8LfFw/0k0dSyOUhI6i3XHvAssiO9VHk8pQH+omahu1McBRKSTXt9kypHSWoTesodtLnjf93G7CtJTYuH9atPwffLTsAX369B3746RBs234RsnMqdC75Rhn6MEutSxfERzMqgqGRnjDwkS0yCYmDu2cUy5ABVcGVrEoWy6gqLFjfZ2PDFbghMkHKmBE+PvgnNUces9Q1gcvsnICDUUiudBXBg/xAz7AH1JTVQU47pFIRvFlaV5YKZLSmvAEuy/XX47lFsAKT86XlpfpiBUNMJTLtH7xUX8o2PlyQEZRRtrZ19Yy2BhrQr1y5EkJDW8c/L1q0CHbt2gWbNm2CEydOQElJCVE1OW7dukWIKObInz17Fv7880/4448/4L333gNV8Pvvv2tcFe20ZXo0rueT9H7ONpDGpuQxBtTYQA/OJeQKefTGhnTXl8L6Q3lJPjsPy/E3yc/dWRoTnjgTGBntGdxSqsPHx8UxMipXYsfHnI/KFtJzFCE1qYgoJFjOiBjYcbZ89Il0QrBwgnvU5NszRV+cVwWXzmRCWnwBFOdXQX1NEyCPwDIMTucGhLlCxDA/YVJXF2DrYCaYdKM5PVeSNIXu7AR2XUvWUQheoudN/3cLMM990+bzsHtvHNS3Qz4cHMxh8qReMHVyLxJ1qqvo1ZuS0Yz0UtI6gYMXmkhjKimsgZzMcpV9hWXhyPo+SwtrRVs0cV/cqjJxCidOxKNSjL2zddWNAqlVBUam+m0USSlWbdwbVF00sF5yE9bLqqtAJ4JekUEQtScWovfHgZcCwUMZvEPpfbMTC8imWVEVx8jEQDDIz0svhZD+3m1SmjISCtv40mJC04VTGeTc0PYzWdPWf5Rn1ivtGb3z+fSYltRNw4lJUhKYGhsbibcnJh598sknrVKQVq9eDevWrYMRI0YI5DEgIACioqKgf//+cPDgQWJSf/jwYbCzs4OwsDD4+OOPYfHixfDBBx9Ajx53Zp3tlGQ0t6yGKJumhnpkgGl/FC2BB7jTHV5yNiOezK4pr7gamq5cBwO97uDJiGc8L8f7Owrl+PzCaqitayYTgf5sN4nIyakgt+vrdye2TrLIziqHqsrLoKfXDcLCFC8ixw8mk+8Dhvqp5GO46Y/T5PuE2X21OjyDbQBHd8XBvg3RkMU8UuVRXlxLfnZyXwKs/Hw3BIW7w8zHhkD/EQF3XLHFhReHPDClJje9TONkVNM9bIrQwE7cWKa/W3D6TAYs/X4/1LHys7m5IfQKcwMXZ0vy+UYXgpzcSkhILCSlulW/HIMtW2Pg5RfHwGAZL0NdAirTqOiUltRBcmIhRMidsKXA3dMGTh9NhXwJPZ8ITL7BYwyPU3SMMBdBqjDSEVElchAJjylTcyNiz9RQ2ySKjBryafgmadPw991PyegtkVGkylDPLKbMWNqeLiNiXBgho+f3xsGDi6eq/DgXX3vQM+gBVxqvQXFWObgoSAZEuPs5UDKaVtKGjDqzQbkieTLKhAdZMsoH47BnlJPfFjLKlFAHbnxfR4QcnldfoaXefjEY/N0quF/DCUy3WAJTQ0Prv09PT498KQKW4VHdHDVqVCsyisbzN27cILdz+Pv7g6urKzGkRzKK30NCQggR5Rg7diw8++yzJEUJbZzuBDolGZUt0eNinZJLyWeAm30rMhrkRQ/MhPQSQRXlkZ8JqVQBDQ1smYyPjaeljpBAp1Zm9xcuUqU1rKdrm37Pc2xCPryvp0Kiibv8E4cpGY1UwZ4pKTYfUuILyetMndcftAEsv+1eHwUbfzlB1A8EqiHB4e4Q0tcT3H3twcLamPxv8SSYn1kOseeyyEBE8sU88uUX6gzPvTsVfBU4C9xOoDk4klG0wRqqYfsrLLUi0INSrDKlKlCFQ2hCidM28H/wz4Zo+GX1cXLd3d0aHntkCAwc4KMwvhF9BY8dT4W1686SRJb3PtgK06b2huefHaWxuEdNe44iGcUkNU2QUTfm4VggN6msKohNjo0JVFU0QHlxnTgyyno/my5fFW28b2JhKJBRKdZMzY3SpuH5Z4JHeKqLWhZBac7+F7pORhFpMdmERJupGLKB7QeewS6QGpMNGXH5Ssmom78DnD+SDPkKQhRcGBktZHMV8tn1smTU1t6MnCvwHIKDo7YO5uDgLOc1amtKBB4MI6mtaQR7O7qhqauX1jt9t8DFpfXg4/vvv0+USnn8888/cOnSJYU58WVlZUTZRCsmWSDxxJ/x+8gSUf5z/rM7hU5JRtMYGQ1ysyMnyGRGRoM97cn1pGx6wAV70wMzKYMlI7ESPSnHM2W0p4zSeYmR0V6sD4cjhvWR9VGQM336FPUmHKDEO/TCuWwyRY8ebaqU6jasPkm+Y3keT0SaRszJdFj+6U4oLagRBh2mLRgEI6b2Umof1T8yAOY+NRyqKxpg59qzsOvvc5CeUASL5v4Ms58cBvOfH3XH4vYwmQotsNIk+jmq4mOKw2k4LYpOCJoGV131DXTfOHnz1hiBiM6c0QeeXDicECZlwLL8hPE9YdTIIPhjzWnYsDEKtu+4RHrHPnhvulZdCqQAQwcO7k+AVIlG9fLgSn1hfrXkzQyW2wkZLa0Dv3ZihuVhZKJPejCRNOCGk+eLqwJURhGYpCQG+oa0ioPxllLwH1ah4oOD6qKWqcKWrGysy0CLJ49gF5KmdPFQAoyYN0jlx/r2cidkNDM2D0bOUSxguPtRdweFZJRZyhXltE7s4mQU7cGwJx+JL37ZOZiT9hPMqCdklA0wYasUPr5bt/vBxtaUlOnRaxSPKyNDPahvuPMZ7qcXaSmB6bMlUFhY2Oq5FamieB8cEjp06BDJhb+XoHvywm1AGpucD3SzI4NLaH6P/qH+rrZQWFYHDY1XoUf3+8GH2TzFp9GTS6gfJZ75RTXEc5SU49nwEhKOWNYE3lumZ6e5+RoksoSLiD6tySSqKNmZ5WQXOFBJ+fHwXmrPFDkmmByk7SEzpQRiTmeS55v96GDQJNBu5as3N8B7T/9BiCgOKrz80QxYvf91mP7oYJV8TFFteezVcfDrvtdg+MSe5KSxYeVxWPzoL6LLgZpCINs4oDrKrZg0BWzL4CSxTqJ3oir9z4iOPht3Gpdi82DlqmPk8hOPDyPqZntEVBZ4v6eeGE4IKLaznIvKgs+/3KUx0qEp+LM8eOwb1cTv5sRKmti2wNsxpPRFIypFHl9IKCysqJLKqx+qgicp4RCTGGC5WC0yquHCAw4E3S1kFBExnqqjUXtp6p6q8GFzDBmx1OtaEdxZvCyW6eWHCnEOAIc1rzRdgyrW54mwcTAj1T5cV8vZpLzsRH1JYa1gA4XvHW6sa6ubWk3U4xATfhb5ENO9nMBkamra6ksRGcUyfEVFBfTu3Ru6detGvnBI6X//+x+5jAonDibV1bUePMRpent7ylXwu/x0Pb/O73Mn0CnJKM+kD3SzF1RQb2cb4h8an0mJZ4CHPRlAqapthOJyPCAAglkJIzaZkku8zsvxGdnlcLnxKhgZ9gA/men6CxfzSKyfk6MFOMtFeJ4+SXtVQ3u6ghmzNZEFnoDOsVSX0RNbT8wpwvpfTpDvw8eHCpPimkB8dDY8O20ZHNsVR4jujEcHw6/7X4Nxs/tKUjTR/mXxNw/Aku8fBENjPUi5lA+vzP1Zad+pNuHsbgWm5oZkIczQkKIlC55JXy0x4rBDsBPDne6/bQ/Xrt2Ab5fuIwRt7JgQmPeAtPaRIYP94KP3ZxBF9PiJNDKBr0tw97AhQzRNjdeESWB1QJKQbE3aTB+LgTX3/awQ//kzYznkYskoDrwgMCNe7CCOOmRU08YLVaxsbMmIka5jwMTe5HvMwQTikaoqfMPchVhQFFUUwdnbjhDOxvorUCX32cZzAJ+cl+0bxX5Qfh4qkbEXc3RhLibsM43Hsw0bUuKlej5RL9g7sZ93dowcORISExMhLi5O+EIDehxm4pe7d+8OR44cER6Tnp5OrJwGDKAetPgdnwNJLQcqrUiAAwM7duvRFjolGb35779gaWIIDpYmkJjDSvKelEAmsJJ8KCvJc1XU29UGTFiW+SWmgPYKaSnHX+AJSj3dhL5SRFQ0tW3qp8C26eQJSkZ5nKA8juxPgBs3boGXrz3xHWwP2PN49lgqISUPLBwKmgA2mK9ffhTeemw1MS7Gssu3656BJxdPFPoh1cGQsSHww+YXSM8RPv+bC1ZCHHMWuF3ABTOEpV4lxGjGlkcWNowMVIicSlYVfPpVm/ZR6mLbjktQWlYP1tYm8OLzo9Qizn37esIrL40hl/9Yc4qYzOsKUJ32YH2eWZmtlQepEIY7RJrPc1iyVp1qCR6NphZ0gyw2n55nxGO/qRjw/HexllAcXLHTVPRuNSNGNk6tRQRdhV9fTzCzMYHmhiuQdJZGR6sCJ2874hWKBv+FCsrwfKPAB5VQHZWHKyvVF8jZO3H3lCKZSFreIyrrP8rtnUq4vRMbfCstZdfvkg2BtmFiYgLBwcGtvoyMjIinKF42MzODhQsXwquvvgrHjh0jSupjjz1GCCgOLyHGjBlDSOeCBQsgPj4eDhw4AO+88w4ZilI2MHU70CnJKCLY3Z6cFBOz6YEV4kVLbAmZjIz60pL8JaaChrFBJVR3YlnZvbcMGY1mQ0oRvVsM5vG+0cwEe6DcQAMqJ5i6hOflwSxOUH5h3b+DllvGT+14um3tCloCHT4+hBjdqws8kXz4/F+w5n+HyO8yZkYfQhz95fph1QUuVkvXPQM9+3nClebr8O5Tv8N5RtJvF3r1o+0TF8/RjYMmgf1RsrYlmga3s9GmfZQ6wM3Upk3R5PLjjw4BQxbZqA7Gj6N9pHh8LV22X6macyfgwTwXeUSrpj4/2PMpBZZMma+RQEa5Cb1oMsp6o7FsKwa8yiKVjPLBJe7vqy6qiqlyZ+V4d5BR3JhiGhMiem+cqMEvb9Zaln5J+YbcnSUH5qa2JaMu3qoPMQlqKZs7kN108QASBwd2vbReSJdDt40udIzvvvsOJk2aRMzuhw4dSkrvW7duFX5+//33w+7du8l3JKnz58+Hhx9+GD766CO4k+i8ZNTDHq7duAmpzGO0p5cD1DY0Q14JPUB6+tADLzaFEc9AOumWlVcB9ZevgAHaNLFyPJbnU1KL2/SFpqaVEEsnbL4OCWk9KXfiWCr5HhrmJpRyZYGZ1LlZFaTnpqMp+rTEQuItiorAQ08PB3WBHnCvzlsO54+nkSGGRZ/OJF8GWprYNjY1gI9WPgoDRgaS/qKPX1x7WwlpOPNuTY4rFN3n1hGcWH9UsYyvnqb7UhFo36OLiD6fTY4BS0sjQiA1heefHQmmJvqQk1MJe/fFg67AzZ1uBPMlpB4pAre5kaqsC32fEnqWTZhdGJZmpWTEX2kWR0a7MzcRqb3bfFOC09rqAgkxH2DC4aC7Bf0nUOEiem+sqMAIP+6T207fqAfriVasjNorNL539miHjBbWCL8jJ6M4xITASFDZhLmpk3vD8p8eVfnv6Uw4fvw4fP/998J1HGz66aefoKamBpqamggRle8FdXNzg71790JzczNUVlbCN998Q3pO7yQ6LRkN9XCA1LxyMgBiZWoIzrbmEJdOCaWnkxWYmRhATV0T5LHdcVgAVUZj4ql5fViQizA0cjEuH279+3/g6mIJDjK9LeinyEv08pO/R48wuyYliUq7t14k34eNCiK51+3hjx+PCBP0zmqayqfGFcCiB36GguwKMnD09dqniCqqbWAZaMl3D8LgscHkZPTpy3+TXtXbAUwFcfGwJsrKpXOafU1nV/p+FMgsxpqEEWsdaZRoh6NtnDpNe55HRAZqdMgKfVUfXkCH9P5ef05jRufqwtXdSpiA1wR4Lx1OxEsBt3OqrxVvi4OhGQixG7SWqXhx/rqo1CDQMF8KuL+oJtKSuCqKrQOq2iTpSjQoCgjFWWVQyCwJxZBRVZTRPIXKKCvTZ3asjGIMMwonuIGuqaKbJMHeSS6FCT24sbrShXsfnZKM4uQ8lunj2LBSqLcjKdlfSqUqaC9/SjwvshK9j7sNIaeImDi6c4xgTd+Ic+dZglJ4iyqKO77TpykZHSxn25SfV0mm6LE8MmR4235RLIsdP5RELk+aEd7u3xIbnQ1x0TnkRP/Q05GgDqKPpcJbj/1K0pO8Ax3h+43PgZ+coqtNYJlu8dcPQL/IALh+7SZpE8hKvj09gf1Yq8S545pVZNG4HFGYW6mVcrIpm1yu10EPPjwGcIAPMUADvpvymDQxDCzMDaGiogFOMou0Ow0XNpxRUtyi+qgDa9bziSdlKTA1NxAiNsV+/njvZ3Pj1dsyiMQVTanRvFxR1YRNXEUh3UzYuljp9HCgPAxNDCB0WIDoUr0f65vPTS6G60pCOrgyiuqnvHrNvUZx2E3WX5aT0YrSOqF60717N2LpJNs36sj7SBkZtbA0Ii4a2IrDI4+7cG+jU5JRLwcrMNTvAbEZlOj08qXk81Ia9ZoMD6AE7EISHVQKD6J9klev3RD8RfuytCTSF3ohh1weGNEypJSbVwnFJbVEEY3o29rS6QgjmhH9vBQm5xzYHUcMf3FwyT+4dWKTLHBo5bdlh8jlCbP7EIsMqTi8/RJ89OJaMlXeZ4gvfLXmKbC+AxOMeCJZ8t08CI3wJD1n7z3zB/Gp0zYGRrIF/FQ6XJfYs6YIuONHO6Jr125KnohuD+ZsyKRWpMH47UB5RQP5vXDTFRSo/HMsFXiymjyZliV371H9xKtNoCUNqj74fteInEJXBEsW81oj0Y2Be90iMRY7UMQTkdAdQAy4QT5uKKUM40kl8bzXtDuzylEHFQVUybNhm4u7Cf3Gs1L9PtUtnnBICxVg3AhgNKgiYCQoBhMgES2S6w3FFi5b5hcqO8SEln/c6qtUZmCJx4JiqR7hwIbEUCm9evUG2QDw5CU+Ua8LwOhObXx1oZOa3ge528Otf/+F+CxabgjzcSR9oNlFdAEK83eiqk4iLcn3YYNKOLiEZX07GxNwZQdPakYp6YkzNtKDUJk0Ia7U9An3aDW0geT1yCFaoh85pm0vKKoXOzddIJenzOrT7q781KFk4i1qYNgDHnxSeq/ozr/PwvJPdpHLo6b1Jv6hd8qEnisr7/20AN5csApy0krh3af+gKXrnxVOrNqAf6gzmTzGQY/YqGxBKVUXSMQwYzw1qRiy0srARc02CnlYWXHrKO34mKqDQnaicXayUNlTVCzGjwuFNX+dgfiEAqiqukwm9u8ksEKBaiZGF6Jpt6J+cDGw4GX2umaydoidFEcVCp0vMAUM1VG0MVMVhka03H5VZO8nn4pXprApA1/qpHq03mDkl/eeqoPyfJp6Zeem/jDo7Ua/CWHw86trIPlsBjRUXwZTtka0BzzP+PV2h/MHEyH9Uh4E9PVSeB8PfwdIuZBL+kZ52V52iKmipJbYOwUzAQYf4+xuDWnxhVCYUwkezBUGyeilqGwho97EVJ+EguDGB4c9PbxsSd9oQUG1RmzSNIUh36yC+/U0HAd67c6b+esCOqUyGurpCJmFVdB45RoY6fcAXxdboorihtzDyQqszIyIt2hpZQOxaeL9olGsnyYizEMgiWeZdVPf3u6teuJOsAGcYXKkJiG+gJyk8AShKHXp/JlMMjmLB2fkuBClf8ONGzfhjx8Ok8uzHhlEEpqkYNOvJwQiOu3hQWRQ6U4SUQ4jY334cMUjxDi5KLcSPn3lb42b0surMoNH0f7dkwepcq0p+LLyVroWbIgwEx1RV9tE/Dx1CVVVDVr3CLSzNYMAf0dy7Eaxdpk7DVv292JSlLowY8o3ErQGia0YmKYkrfeTDyKJK7djz6KUqXi+pkrtbrh+9XqrNgF1UJZHyag9G0i7m2DvZkPSmPAzc/5AvKgkpg7N71niYI6CtUzoG83quG/UgQ92MrUU33vs3Ze1MeN9o7pERrugPXRKZbSnpwNEpRUKU/NIOC+ksJI8I57nE6gqGuzrSEr6qJRGMzLaP7wl1vNMFCWjg2R64rBEn19QTUr0Awe2JpwH99FEpWGRAaCnYNHcvuE8+T5uSi9hUloRdm84Tw5aVPNmPqx69Jss1q84BmuWHSSX5z07Aha8qJ4HpKaBbQIf/PwIvPbQCoiPyoaVn++G59+bqrXXGzYmGHauj4azR1NF53G3B78gJ4BNMcQhQdMwNTUQlC9ctPk0ty6ggZWF8XfUJvr38yLOFRcu5MKkCTSF5k4CowwRVZXqk1Hc4OIgEUlhqmsGcxWSzuSBihNSqyaRvZ/6LBHpqlgyyi2axG4e+dIjkY3yaNweBpojo3ZsAPFuQ/+JvUg0KPaNjnpwsMaGmHjfaK4iMsoz6tuQUZu2E/W8t1rGZcTRyQKy0koFG7yWiXrdIaOnXtdSHOiXS6Czo1MqozbmxnAxnfWH+tH+0JhkSkb7sv7Q6Hg2qBRKe0MLimuguKyOpDL1YbcVFddAbn4VKcX2lylrHD+eKpTojdm0M48GPcl+Nm489YOTRU5mOcTG5JJS3JTZfZX+/pcbrsA6lra04NkRwklDDP5Z2UJEH355DDz80midIqIcnv4OJK0Jf7fd66Ng7wbqWakNBPR0IX23qARFadBaKoBlgmemlYruo+sI+H9xYrYoRVqyj5IK7HtGaKtEz9GL9W8nJBZqZGhIXVgzOyVNtU7wITWpkaC89xM3LGLAo2w5yVMV9zMyKnoQib91Eteh62xARk9f/Hooj9JcSkYdPCjButsQMY5uyi4eTlQ5jcmXeWQXZ5XD5TrFPeierPc7N7VUqb2T/EQ9lukRRTJk1InZO5W2sndiSqgcGdUlZVSbcaCdHZ2SjGK/aGwGJaN9/F2gvOYy5JfWwn3/+Q8ZXsK+UD5J368nPUDPMVP7sCBnMGTk7+TZTPK9V6grmLAFHw+sY4xwRg6nQzGy3qLYnO3sYgmBCgaTtv1DidbgyADB7FpZ7Cf2f7l52cKYKeKVoM2/nYQ/v6dE9NFFY2HeM+pN4Wsb/SMD4JFXaOrO8k93QUosVa21UaofMZFuEg7v1NxADE6KWloZE6UoTQvuAGgIrUlvS02B9zdqmyD6+tqTDWFdXTNUaECNVBe8z7NGgrenInBrt8uXJZJR1vvZ3CRO4eTl7usi2z94u5LYthr+OZG6J+bT+zzjXiqw3M/TlxxYotbdBr++XiSNqam+WeU0JjMrE+HvzVSyxrqxjPrqsjq4LDc06epDy/TYNyobeCB4jea3tnfCjTRukOrZ8whlerlIUF0io13QHjolGc0qrILLzdfAyKAH+LnaQgybmg/wsCORn0kZJdB85TqYmxqAnwc9wM5eYElKfVoU0FPnKBkdIlOKz8wsh6LiWjJBPXBAazub/Xto/87Y8T3bqJA4RXh0fyK5PPNB5dndaIWBpWTEk6+NFe2ph8NKq7/eJyiic59S3yT/dmDOk8MED9LPXlkHtVrKeh81iSkK57KgWkOWIvheh/SiinsCi43VdCY6Ii+Hqjm6Aq6sNYss84oFKq/O7ESWryF/T004HCA51gRaej6lDTroG+hJCkbAwA1JU/H307VNrJXU/7HBJakVGt5OoM/It1SUF1QTYoyT42Y2mi3J3i7g5ixiLEtj2hMrOqc+I1Zxqd7IxIBM1SNy5czvTS2MwJxVBQplMup5bj2GJ3DiiRsdG3v6vy1mxywnn/LG93gcie1b7sLdh05JRi9msFQlX2fSL3o+ie4CI4Jpue9cXK6giqK6gwlLCSlUSR3IEpYqqi5DSloJjfOU6Rc9cjRZ8FWUnaLPy62E5KQislCPUTCYtGPjeaKcBYY4C2VdRfj1u4PE4BtTg/rI9aN2hEPbLwrDSqiG6roiKgs8QS36dBbNsa9ogC9e+0eyH2F7cHKzgsCetPn/8G7NqaM9mY8ftmFoGp4sii9H5gSgCzAz5aRM+7ZTTuxEpgs2MNyuTerAkTyMWPKZWIsl+U2BWDIqdRCJWzTxeE4xFSv6ePFkFG3uuDKqL9MaJQVlufQ4svew0cnWJVXRb0Jv8j16X5xGh5iEvlEF5vdcHZXtG8U2MhxEReAwqjJ7J3vWboQDvLj+GhvrgwnbiOnCcd0F7aJTktFLrF80IsCVThwyMtovhJFRtiscEEYbus9dzCEJSx4uVuBoT096J1m6UnCAE1gz6wxUAo6yEj0mzshiLyM2/Qf4tLF7uXLlOuzeSu2cZs0foPT3jo/JhbPHUkn28lOvjRP1N585lAzfv71FmJpf8NJouNuAgzrv/u8hYmWVcD4H/vqRugloGmOn06CBA9suaazE3CuCbmJSE4s0vsv35lOsBVWkDURXYMMM29GUXvuvxYaGtKSYS+nxvCzS17O9z72UeE0O3lMuNhGJDyKJLbfzbHixx86/t/5PcoLSVZkWBJ4AJRWlnIzehbZOsug9Mpj8LzGNqVjOF7Qj8/uMdio4HmyiXlEsqLMXI6Nyr+esaIhJJhaUu1Cgoou95tUs5IGrpeVlXWT0XkenJKPx2bT5um+AK6TnV0Dt5StgqN8dQrwdoKyqAbILqkj/KO8XPX2eTswPjmhRQI+zmMNhg1usm+LiC6C6upHs5vrJGOBjmevQAVqCnzC5bY/n/h2xcLnhKtkpDlDib4lEd8XXe+lzzOxD+kVV/nujs+GL19YT4j16Rjg89d+Jd+2O38XTFl7+eCa5vGHlcbigheSdYWODCQHARRI3AJrqG8U+4Js3/9V4qR43N5j9jidzTPbSFTgxE2w0v9e27ZQ588+sF2lfpA1wNUfTZFRqu4OePlU4xW5UuMUbrhtiSu58aRG7j+NKKi/zi8GVpquCqqpuz2hpTsVdPbzEYWRqAEEDfcnlmP2qqaPeoW7kf1hVWgfVStRId9Y3qigW1JVP1MtVaXjfaFFulVJlFBO47JiCWsriWO2Y+FNWWq/S79+Fuxedkoxiwg56iXo5WUF0IiUG4YGupPGeq6JBPg4kAvT6jZuCv+ggRkYrqy5DEivbDxtED3bEocPUn3L4sIBWWfQnT6SSCXi0fOkrQ1IRWHLfsi6KXJ710ACyM1QEVOlyM8qJzcvDz41Q+W/NTi0hsZqobgwcFQQvfzj9riWiHMMmhMKkebSv9pv/btJYb6eskhQ5IZRc3ruZKtbqAv/nfQfQ9/78Wbq50RSIYTUrnaVqwctUKpAgI0lEMpOt5RYCoZQtcmJcm78LKplSDdwVltklklGp5XY+FY8Q0xLT4hcq7m/HtVA2o14MrjDbKuzzVHd948qog+fdTUYREeNo3+j5/ar5jeob6YEbUz7TLtJkQXl4BLYoo9geochrVN7eyZGFfZTIDDE5MDLKje9lS/VC36iOpTB1JTBpD53SZ5SX6HHROsssnAaEUBX07CUW7dmbllUvJhTAlas3wNrSGAKYdcWJ0+lk148leltWHsRSO09dGj0qqNVr7dpxiXyfODmsDdk8figZKsrqSRbvGDbJLQ80q/7zJ1qSnv9MpMopKuXFtSS9CCcbQ/p6wOJv5koqgekinlw8gUzVY0LT129ugE9XL1RK5KUA1ec9m2LgzNEUEsVoqYFkn76DvGH31osQfToTXnjj/zS6KQgMcoZzZzJJX/Ksuf1AF4B/n7+/A0RFZUNySjEEaiESlAMt12QJzZ2EAesVxzXi6tXrrXrHpYD7DUttwZBMRmWOp1s3/wXQ065f6L/4GnIkWFVcYf20SEbVRQsZpcTqbka/Cb3g1yX/QMLJVLjadFWlflrsG81NLoLMuHwYNIn2ncrCycOGpFzh5qisoBocZbyNudcokk78vPHPniLje2Veo3i2lPca1ZWJ+uGfdSUwaQudUhlF9Atyg8tNVyGJRYIOCHUn2fMxLJd3ECOjJ6PYxHyEt9BYf/QU9aCMHOovPN/pMxnkZOHoaN4qhxuHSpIT6eDSuImtS/Sommz48wy5PH1eP2F6VR5/rzwO9bXN4OppA5PmRKj0912ua4Z3nvydTJ27+9rDez8u0Egyia4A/5a3ls4j/WHx0Tmwkfmuagpe/g4QEOpCTsL7tl7UyHP26utJ3mPcfKCnrCYRHEr9chMTdMNrkyOUR+nGa8eOSx66oPqjkwb/NTTRHyw1652jBzehZ76vksioyGEkKeAbiW7dxJ+WmpntFfdUlQo8djgZdbwHlFEXXwewc7MmxDD+pGreyb693NodYkJBw9WHCjP56a39Rq0dzElOPa6bsln0OBjK3WC4murgbCGILVg5lFVGy5jRPSejXT2j9z46rTLaP8gNopPyyWCSu6MlONqawakLWaQsb29jCl6u1mQB5v2iQwf4CP1vyal0in744JYS/YGDtCd0zKjgVifEXTsokRk8xK9Nbnb06QzIz6kkPWGTZ/ZR+HsW5FTCTmb0/tTr41SK6kRfwA9f+ItMLuIU48erHgVjLafg3Ak4e9jAc+9OgaVvbYa1Px6GXgO8wL8nJT+awKS5EZCaUAh7N8XA3MeGqB2TigpX7whPiDqVAedOZYCXL13QNQE/fwdicYSxoAX51eDGlIg7jT693WEV9lPHFZD2GG0Z4ONzI2TbY+4U8PhHAnn1yg24poGQA/4/43+jZGX0prRBJNGT8RLN62+yv0/KcdbM+nPVVUZryurhWvN1IjzY3qXpS/KfxfDRobD316Nw4WAC9BvfsS+1D7N3yoovIORc0QbP3c8BspOKSN/ogLGhrV7P2dMGMhOLSKnelZXt7ZwsSE8obqiqyxvAxsGctENZWBtDbVUjlBTUgF+wE9hzb1FBGaVl+rIy3egZPb5ESwlM33UlMHVKZdTb2RqszYyEEv3AnnRq/jTzEh0c7kUOqoTUIqhruAKmxvoQFkjtlo6epNPyPYNdhCn68op6iI2jys+Y0cHC62D/2uEDtI908lQ6oc2BB/n6P07Tn80MJ1ns8sD74NAS7jL7DfNTycoJd51Ll2yG5It5xJ/w45WPkVjNexWjpvYmPaR4svzyjQ2iU2baw5DRQWBuaUQmOzEiVBMYOIwOqJ09rrmEJ05YgoLpZzROC16mUuHlZQtWVsakanBRi78X7xVVtySuKeixVBWpBFKh36fE5+KtOWKt0GQtlsT0vraY1/9HmjLaXfyGpZn1jBqy4TGpKM2hFQsbZyuBxN/t6DuaWgleOESjqDuCe6AT2RA01DRCeYHiIA03f9qjnienjCJchIn6ilafQXvmTyqbxMSHmEqLmL0TJ6NMGeUDTGhrJjX0QZPoSmDSHjolGe3rT30kz8azwaSeHuT6adYvOiScDpocZ6b2gyK8hFSRw8y6aeSwlnSlgweTSHtUWJgr2LODh9z3QCLpJXV1tYKw3rT0wREXk0uyyvFEM4MN48gj6ngaXDqXTdSep1W0clr74xE4sTeB7ELfXvYQuDHft3sVeMJ74f1pYOtgDmWFNbDys90aJXgTZlHFevt6OmSmLvoP8SUn+az0MqEvSlPoxWxZLrG0MF15f4axdpbDR6gHrzZQxzw9zZmt0p1G9x68NK4+Ge3OyJlYiyUOXvYmfZ8iIEsmxZFR/nhRLyf8r6SQQF6mxwlydVDKMunRY/ReQVhkECGDJdnlKlk8YQuURxDd2GYoS2Lyc1BYppcdYiqSG1rkfaMlMsEUQuoS9xplDhy1NU1kA4vVJHMLI3JbRfmdT1frgvbQOclooCuk5pZBbUMzGOr3gJ5+TpCcWQK19c1gbKhHVFBcfI+fo16ikQOpmpVXUA1ZORWkl4pbOuH99h+gO85xY0JbqQM7mHfo5OnhbVQCroqOn9ILLFhqhXypfdW3+8nlGQsGCp5s7eHorlhYv/woufziB9Ohl1wC1L0KbEF4/cs55H98cOsF4qmqKUyc1ZcQ+5S4AshMaWtlIha4sIayjckpDamtHL37UIU/9lK+TgzycIweGST0VWvK7kgelcyX0IpVK+40+Ob1hkgCqAj4+SPPJZGM8t5PKZ8JQR39PwnKqDDJpBpusp7WbozIi0ET6zlUt0xfnndv2DrJwtDEAIJYm9mlw7SdrCP4hNE1KjMur117p6Ls8jYbLizTk58xi6w2faOKJuqZMmpiqg9GxrS6Uc77RtlEfUW5bpTqu6AddEoyGurlCKfjcgSje5zEPRlDe0MH9PIg1xPTiqGmtomQ0z6h9MA8cjyFfI/o7Q5mbAeekFgApWX1YGjYA4YOafEIvXQxDwoKqsHAoAeMGddCUhHJCYUQdyGPnCRmLxio8HfcsuYslBbVgpWNCTzwxNAO/yacLP+OmdrPfmIYjFXSg3qvAt0CZi2k/6f/vb9NY3GhVramMHQMbb3Y9vc5jTzn0JE0EOHkYfp50hR8fO2J4Tq2KqQm647FE2bHe3rYEDJ14JBqJ0OxKGHTtg7sxHWn0aJG3tIYsZX6XLz3U9IQEttE/yuGjPJYT5FJSpzUSCrTs02OuspoGVNG7WQmxO8F9BpJ17BYlhCoat9oZjwd6JWHjaMFaYlAtb1YjnQ6s8GvwpyKVsOU3N6Jx3+S25gyyifqUVDg6iivHNmxY7q8Sxm9p9EpySiSzdOxrCTfy5McMCcYGR3Wl6qJx85Sm6bBEV6kTI73OcTI6CiZdKW9+6gqGjk8QLBgQWzfEkO+Y/Qn9x3k+Hv1SfqzST3BVsHJs7K8Hv5h91n4yhjBKkYZKkrq4OMX15Iy3oCRgfDoojHQGTH/xVHg4WcPDbVNhJBqaqp8+kM0FevEgUSo0sCCOCgygChOGaklUCxja6IucHPDfWyjzmnWy1Qd4AlmymRqEbN12wWNT2YjyS0poScuF6a03GnwSExN/K2c2EpVWbm6yUmiGEgxsOfT0mLJKG9DkDKEJkzTm6hHRsuZamd/DwwvyaJ3JK1OxJ1IUWlT4x1KB0GzE+gQk6JjGoeYFPWNOrpbk5/jBkFWFBASl1opo2x6XqZlqW3fKD1HVlZ0KaP3MjolGa2ouQwZ+ZVkocXhpZzCaigqqyMWKP17eZATyPGztEQ/nJXok1KKiQJqYNAdBvenJY/GxquCt+gEZi6MwBNj1Fnabzp1RmuFMiOlBC6cyyYniLmPDFKaP3/t6g0I6uUqmK8rA+ZNf/jCGqirbgRPfwd448s5womwswF7PN/4ai5pvo86mgqHmb+ruvANciLvBaoAu5izgTpAT9mwvrSkfkKDLQWIiP6UjEbrEBlFjB0TTAzwcSr26DHNKsK5uZWEkBob64GdjgzrcQKIbh1qP9f90rLe2zxeEhmVkhPPYj1FrkM3WEoXelhKVUbVHWASlNG7PApUHj7hnmBsbghN9c2QyUJc2oNbgCNZRy/XNkEFK6HLw5W5gRTIkVHsObVjtk2yfaOOrEyP/aF8k2bvRDeP1RWXhQE9TkYxox7Bj+nK2xAr3IU7h07JWvjgUoiPI1iYGsLJGEoc+4a4kR7ShNRiqMYSvZEe9GW9MwfZCXToQF9BAcWBDDyAPNxtiLk3x86tF4mS0CfCE1xZaYLj79+o4hk5NlgoUcgi4UIunNifSE5mzy5uP7YTd6xYms9JLQUzSyPiJYoeb9rA1eZrkHopDw5uOg9/LzsAP7+/FZa++Q98+/p6+N+SjfD7V7th15rTcOlUOtTdwXxwD197mP/CKHIZh5mqNNRnhH27iD2bL5ANgLqIZKX/YweSNOoL2refF/G0zcuthFKmLOgC9PS6w8zpdGP219ozGu1pTUwqJN8DA5x0wmdUXTVSHvez55Ka5sR/F/m0HFG4jWV6dQaY1FFGUTGsYgo7enPeS8CqSc9htKJ36VjHG2AklHxiPkuJR7CrLz3nFWSWKTTGRxTnUnKPsLE3IwQXFXC0d0KYWRiCgWEPsgZWcPLpoFgZ1YUBpuZrN7Ty1YVO6jPKyejQXmxqPpqS0WERVPE8doaqnUP6eUOP7t2I9+gxZhg8mpU78ODZu49GrE0YHyqcBNHket9emgM8fWbfVq+bnVEG505mEEV23mNDFC6Gy7+i+fPjZ/YBbxmCqwibV5+Ek/vY5Pz3DxEvN00Bd67JMTkQfSQF4s5msug31U9I9q5W0GuQD0SMCILeQ/yUGvprA7MeHwLnjiRDekIRLHt3K3y08lG1SUr/Yf6k2R539Qd3xMKUB9RLORoc6Q//+3IP5OdWks+FNyt5qQtTUwMICXWF+Nh8OHM6HWbN0Y00JsT0aeGwZdsFKCquhd174mCanN2ZVFxiE79hGvSYVRea5MQtyqZ6ZXpNRJOqAv57is2YV4+Mqq+MVhXXEvUZX9+SEaJ7CWHDA+HMjgsQfyIVHlw8tcP7e4W4QnZiIWQnFCpMYhKU0Yy2ZBT7Ri+eTIeinBYyihP9do7mpGcUze9tHc3Juoy35WVVQFlRLTi7WYOdI+sRZd6itnbU17Oi4s6JHBwjPuxKYNIWOiUZjU0rBri/BwwN94KislrIzK8k6sOQPl5w89a/Qr/oyEHUkibqfA5cbrwK1lbG0Jud8DIyyiAru4L0N40e1eItenB/AvFEc3K2JCqVol7RoaOCwFWBKTmqbiR/3tSgw/z5S2cy4felB8jlZ5ZMJgM8mkBBVjns/ycKju+41GYIyNLWFNx87EkJxtzaBAyM9cjELE7+Y59mZUkdeXxJXhWJiduHX+ujyN8zfEpvmLRgELhp0OhdGXDRW/TpLHhx5o9w4VQGKdePnhautrKAvaM/f7EHtq09CxNn91UrfhR9ZfsP9iUT9Uf2JWqMjCIGDfalZPSkbpFR9AB9ZMFgWPbDQfhjzWnSZ21mplq0rTJgZYJ7/PYJ18wxoGtslG+kJJNJISte+muLAf89xbYLcbcAtZRRNQaYKgppL6O1s+U92erEldHUqMxWUZ3K4IWpbusAslkqoTxcWTx2SV5lm+fjQ0yyyijCwdWKkFFMZwpjLUXoP4pkFAd2Zb1F+TS9LSvTN+qAz2gXtIdOSUZR9fNwsgA3B0v4a8d5clvvIBcwMzGA83F5xOgeL4ezJu4DR6hx/ejIQIGA7GbqJ07QoxrFF+FtbHBp2sw+rUyjc7PK4fSxNHJeeOjxtqpofW0TrPmZ2jI98vxIMGPeasoy5794bT1RZ3FqfqKaKh0+T+zpDNi88hjEnqG9sggTc0PoNzIIwof6QXCEJ1jLeKh2ZLOSfDEXLhxPg7MHEkhJZvfaM+Srb2QAPPjiGPBnkXPagpu3Hcx/YSQh7Ks+3w3hA30ImVYHY6b2gr+WHyWLJprgoym+Ohg5PpSQ0WMHk+CJF0YJFj7qYtBQP/j5h0OQlFgItTWNYGHZ1jrsTmHihJ6wa3cs5ORWwoqVR2Hxm5PUer7zMTnEjxDTzdBgX2egwdYLdZXN+zgZvV3K6C1ORqVaO6mhjDJbICmoKKRT3rYsM/1eg6u/I5jZmEB95WVIj8mG4EEt7i+K4MWHmBJpG4w8rB1p9OeVpmtQml8lRITyISZOVGXBrZzKZPpQhR5R3iLBVGmMCMVKo7ExtXuqr9OOLZwYHH1fSwlMP3UlMN172z8VMSy8dYl+eD8a7XmE5c4PH+hLLFXQTDvqAp28H8vsMZqbr8GRo7SHdNKElni181FZUFRYQ+I9x45vPXj09+pT5PvgyABwV3DS/OPHIySj18PXTjBaVwQcbPrkpbVwuf4K+IY4kzhMdUrQCVFZ8NqsH+Dth1cSIoonkAFjguGDXxfC39EfwGvfzCOqpqpElNurREQGwnMfzoA/z7wHn655GgaODSHPHXMsFRbNWAYfP/N7m4VK05j52BDwCXKCxoar8PMnO9V+Poyvmzw3glze/OdptXs9+w70JlZMNVWNcCmGfsY0AWz49/V3IHzoNBuw0xXgMfXqK+PIpuzAoSQ4y4IlpIK3yowcEagz/aLqGL8rAu+9lEomWybixT9eymNayvQilVE14kCvsAQmdXxGK4uqhfSlexF4fIQOptW+hFMdexx7sNRB7KPFQSZFz+fCQlXkS/W8Z7S0sLqVo4QDI/rc5L5VHn0xVUKReBqzdgs+xGRrqxuDiYZ63bXy1YVOOsCEGNrbG0or6iE1u4woB2jphL2hJ6PoyXEkO2iPnEiFmzf/BV9vO/BgTe1IRFGNQRuZUCxlMGzdTFXRiZPCWsUS5mVXwClGXh9iXpiyyEorhf1baYb9c4sntlv+Xf7JTshKKQFTc0N4Z9lDpNFcCpAIfvDEalg872cymIQ9nVMfHQK/nXgb3lv5OFFENRGHh38L9oy+u+Ix+OXIf2H0rL6ElJ49kAhPj/0K/vpuP8kr1la5/pVPZhLFEY3wTx+kCrc6mDy3H/m/pCcVQ7KSdBJVgS0efJDp8B7VovpUxdBh9PN78phmY0c1gcBAJ5g1g/ZTf/3tXqiSOPBWXFIL0edphO+E8S1uFrqAfyUO8bSrbErc/AhkVoNqrTYGmG7eYD2jUsgoi4NVj4xSgmTNJrzvRYQOpcmBCUx06UhUsGN2TDnJRQrv48JK9YVyQ0zWDuYkvADV7kqmeCLsuTIqQ0axZ1RWGUVwy8MK1jdqY6sbYRZd0B46JRm1MDOEYG8HOBZNS9JhAc5gaW4EUZdyobH5GthYGUNPtivcfziplSqKC/quPXGCKsrVmJzsCrh0IZcQrWlyg0t//3aKKCU4tOIpF8+Jz4d9iPh9+LgQCGGRjopwYMsF8oWv+d9v54GNhCZ7JH5rv99PiGD0kWRC1CbNHwS/n3wHnnl/OtgpmPDXFBzdbeDVr+fBz/vfIKV/XKjW/e8gvDj5W8hUUgpSF2h3NXvhMIHIo/qsDjAta9RkqoZvYila6mD0REqizpxIgyam7mgCQyPpSSc+Lh9qFagadxoLHx8G3l62UF9/Bd7/cJuk3PV/NkSR46pvHw9w0eLnVgo48eNEUi1I8Pps9XA1ekalQOgZFfm335BYpkcl9iono0bSyWg1I0PWzHT9XkTQQFoBTDufrZLfKI8FzUtRRkZ5Dn15GxFCUEFlTO45GUXFlMOO/b95j6giMmqrZotVF3QfnZKMDgrzIKTxGFNBI/vTA/TQCZY7P9if/DwnrxIyssqJ6fSo4fTkno6DS1nlZPc+ZkyI8JxbNlH/ycHD/AUrCkR+TiWcPJysVBU9tjeBRE1iCXhhO2b1OWml8PPHO8jlBS+Ogl4DxUd9ZiQUwktTlsLfyw4SIoiK5fL9b8DzH89Uu59SDHAI6uM/noIlPz4M5lbGUJBZTkr3m1ceVc9+RgnmPRtJcpFrKi/D70tpxKo6mPnwQHKCjz6ZAfly+cti4RPgAG6eNmSTcFyDnqOOjhakVI/E4NSJNJ30hH3/3elgYqIPqWkl8PmXu0UZxGfnVMC+/VRNXvCQYr/eOwmp6mC7NlFSlVE1lFUprQ/qKqNiy/TXr7RY4+gb9gCpqGYlYat7cJKewz3IhQx5YVtDLrNEa/f+gU7ke66SRDcnPqgkl8KEcGCVxFYm92zTiK1TXBjgymhDXbNgmyekLgkT9bpRpu+C9tApySimLpVVNUByVinppxrezweamq/B2Yu0b2/UkIBWquiACC8wZ1O/OHzBB5d4JCgOiRxlRGLWbNpTKOsriueAgcP8wEtukvxK8zVY/f1Bcnnu40PARskBh/GOn73yNyEsfYb4wtynh4v6e/Ekv/6HQ/DqzGWQn1FGCOB/f1gAn/z5FLh4tVZqbxfwJDdkYhisOPgmDBoXSgzlV3+xGz566nchZ1pTwFaGlz6cTi7v3XCeRKeqA7QfGRBJy+Bb/jqr9v8Bk7gQB3dRxV1TGM6Swo6zFhFdg5OTBbz/7jSy2TtxMo2U7FUhpKiifvPtXkK08TgMDqbqjS6Bm91rYiqbZ7xLJaOasHYSlcD0f6xnVCQZvcWm6cWSUV6iR+ipQUZryigZtXS4d5VRVCwDIqiQkcLEmPbgEcCU0VTFZNSZzT8U51S2+Xw6cJN7GTKKmwX0xOaDuAgjExxQ0m+ljtowO6dK5i06akwIfPu/+SL/2i7cTeiUZDTMzxmOnksXSvRW5kakVxRPcq5OluDraUtMuQ+yHN/xzLoJE5d4esyUyb2E59u5/SKxJQkIcoJAmRNjQV6VkLCz4ElaKpbFP7+ehOrKy+DgbEHUNkXAA/yH97cROwxrezN4XWTCUk1FAyyZvxzWLN1HCN+QCT0JARw2qZdODHyYWRrD2z8/Ai9+Opv0YmLrwMvTvociBTttdRAa4QljWBoW/j959KBUzGLpWcf2xJP3UB2MHBdKPBlTk4qhQM4KRR0MG0E3VYnxBTqbXtK7lzu8s2QqIS4HDyXBu+9vIceZMiCh+t8PB0mFwtREH557ZiToIrjCzw3r1cF/NKWMqkVGJZjei1xfeBAC9nqLwbUrlIzqGfSQTP7x76tjcZOWIoY170YE9KNkNDU6S6UkJkR+WrHCzwCqn/g+o4BQX93Y+mcsUrVMpiSP4H7YnIwibBxYyhLvEeURoOUtXqM+zGS/C/cmOm02/ZFztF90RH9qb3HoJC3Rjx4aQEuwF3Ohtq4ZLNDeqI8nvc/hZLh27Sa4u1tDMOuluXbtBuzcRmMnZ8qror9SVXTA0LaqaElhDWxlqtpTr41TOoi0f1MMHN8TTyZT31o6r13LJ0WT8i9M/BYSorLJjhQn49/68WFCAHUJ+P+e8OAA+Hbzi2CDpsi5laRsnxhNh1M0hYWvjwNTCyPIyyyHbX+q1+8Z2NOVRITiJmTHunNqPZeltTFEDKSBCwd30+lwTU3VB4U4k8/giWMdT8/eKaC6+eH700npPio6G5585jcyZS9/8mtsugpffLUb9u5PIBWNt/47WWd7yVq8NjVARtXuGWWPB+nZ9NJeV6QyepMReJEWZ9dYmb4HS8aTgsa6ZmGDam5zbw/LiCGjzt52RKm+0nhNYSwobgBwzVbmKYooLWj9ODS7R1Qo6hEtbW10z5VRXUFXApP20Cl9RksrW6boI/v5QFVNI1xkxr6jWYl+78FEej0ykNjR4IlxJyvRT57YoioePpgE9fXNpMdlyFBauuWq6PFDtMz/8FNtVdFfvt1PiEzvAV7Qf3jL42SRn1kOKz7bRS4/+soYCBThzYnRnCs+2k4SRdz9HIj6yI2IdRU+IS6wbPsi+PCp1ZAeVwBLHl4Bi7+fD4M1NCmNRPSJN8bD0iWb4e+fj8CwCT2FhVEKZj08CJJjC2DPpgswd+FQodQkBWMmhUEUGvTvTYDHnh2hMc/REaOCIDmxCI4eToJZc3XHAF8egwb6wrKlD8FHn+6A0tI6eOe9LSRmt39/L7C0MIKS0jo4djwV6uqaCcF78/UJ0C+idaiELoHnyGuiZ1RdZVMda6jbOYkvqMn3i+wZvXpDIEZSUVfZICQ49dCX/jx3A/z70uOmNLcC6qsug5m1cvLdrXs3cPS0JfnzhRmlYKfAg9XRwwYqimuhJLcSgvpS4Yan8JHXKaginx/+ObZ1bKuM2sopobxlraqigWzsNLGp0wRGvduVwKQtdEpl9MR52isTFkin6I+cTiMf+CBfB3ByMIfauiY4xy1jxlC/0ISEQsjPryK59KOZ2Tk+ZsuGaCH6U5ZAtKeKXjqXBeeOpxG18+nXxytUENBPFI3tsU80fLAPzFRglK8IOCH507tbSHY8nhCHT+0N3217WeeJKIeFjQl8uf454kuKQ1afv7AGDm6iwQSawKhpvSE43J2oKau+3KPWc/Ub5gfO7tZkCv4AU8clP9dgH5LTXFPdCDHnOlYsVMWwyADSApCRXgZFcuUyXYOfnwOsWv4YzHugP1FJc/MqYf0/UfDT8iOwbftFQkTRTu3rLx+AMaNbhgd1Ef9qcJpe6PmU3DPK40TFP57//rcjSlQwyxcZI8rJqDrKaAOzFzOz1k2lXZMwNjcCJ2bJlBlLo7Hbg5BBn16q1CUFgWRUFpjUh0BV9XJdc7vKKLagyZbpsVqEHz20VcRAmC7c++iUyuhxVp4YNaB1iX4Mi0s7eDSFDFL4+9oL3qJcFR0RGQjGzD4kJjobCgqqicn9+ElhClXRBU+2nqDHUtCKr/eRy1PmRoCbktSYX77cQ8rJFtbG8Nrns1XqhcJG/s9e+JMkHyHBfezNiTDr6Uid6A0VAz39HrDkp0fgx7c3wf4N0fDdm/8QQ+yJDynuqxUD/F88995UeGHGD3DmYBJcPJMB4YOom4JY4Hsyc8FAWPbxTtj29zmSVy/FsBuB7gyjxofClnVRcGBXHPQfIu13koe5uRGE9/GAmOgcOHIoGR55vK2jgy7ByEgPnlw4HObN7Q+nTqdDWnoZ6SE1MzOA8N7uENHXS5IP5e0GVyHFGr9rQxnlZFaMW4GmDPelqMmiY0SvUzKqji9yQw3tdzTRsRYmbcGnlzsUZ5VBVlwe9BndOqBFHs4sWakoq20GPcKBG9znV7ZZxy2sTUisNCqnWJmSnZ6vZO4FrXpEGRnFaiQmx+HmvKryMrHU0wUc/lhLCUwruxKYOqUymlVAs+hxij6vsBrSs8vJlOGIwX6knLDvEC3Rj2fqS01tEzkxyg8ubd4YLZjc40mUYx3zFUVVVD5zfM/mGCjIqSSm9Q89E6nw94s6mgJ7/qHP/doXs8kB3RHqqi7D4gd/JkRUT787vL38EZj9zIi7johy4Pvx0udzYBojTz++sxn2rlNvcp3Dw9ceJj/Yn1xe8eluIflFCkZO6gnmlkZkET2lpjXTGOZfiuX62hrNqQEjR9MBvKOHkm6b8bm6wAjA8eN6wqKXx8K7b0+Fl14YQ0r5dwMRRXDuponDjxNaqbZnPESDkz1pk/iqP5avOWKVXOGzKfJ/doOFZnTXk05GG+vo8WbCJr3vdXiHUT/rzEt5KvWNIoqyWnuJyls4yU7Nc9gKw0otfaM8zY8TT9np+SqZHlEr1rtbxVoodAFdCUzaQ6cko4i+oW5gbmoIB0/Q6fh+vdzJ9bSMMsjNryJlwpHDmMXT/gRSLvD3dwBftkvMyiyD2It5pKQka3JPVFGW9DP/idYqFPqo/bX8GLn88HMjwIRZQ8lPv3/39hZyecZjQ1RS7XDX+fqcHyEzoRBMLY3gi3XPwaCx7e927wbgSe2pd6bCjCeoldUPb2+GI1svaOS5F7w4mlhcFeVWwo610kkuDp5NmUd7Mbf8dUYtsufhZQt+gY5EwTqyT3OJTIMG+4GeXjcoLq6F9DTFpbYuaBZSJ8oVgU/k32JlbKlkVIoyKpT4Rby2umrqfVKn8EX2msqiqZ6WkY1MqYXfvQ6vMDp/kB3fsc2dMyvpF8sZ28sPKpXJDSrJklE8Rwm3scn5uupGuH6NqtrWMj2ifA21ZqlL1RXquZV04e5ApyWjIwf4kT4o+RL93oOUBAwb5AsmxvpkAd+1h5bop07uLTx+80baxzh0WEArk3tURfF5URX18W+tiq5dcYwY/br72MH4mW3z51F9WPr2ZkJavQIc4ZFXlJvgc+AE4xtzfiTfsTH8200vgr+IQSddB57Mn1gyGaY8MphcX/rmPxDFWiDUAXrbPbpoLLm87uejpJQkFZNmRxA1Oiu1FBIudKw0tIexTB3FqXpNqZgGhj1gANvUHGUBDF24PdDE4AVXRlVJzFGE+5majBtq0Y9lNkuc8InqM5VAfhFiP/XCFL4aqnnzZeptbGTWViC4F+EV6iYMMXXk6+zEvKgxFADN8uXBh5qw1UHW81WWjFbK9IeamBuS9VJWCeUqKM5KNF2mr2HFKoLVaqzNXbh70GmtnYb29Yb4lCIoq2wAQ4MeMLivF8mbxyx6xARWoj8fkwPl5Q3E03A4y/vGLO1j7KQuO6FcmK9cFcWknt2baHb9M2+MV5g/v3t9FFw8nUly4t/4ag5RZ9tDUXYFvPnAT1BRUgtOHjbwzeYX75pBJbGE9On3psGomX3JCe7zF9dAysWOG+87wujpvcEnyIksoGv+d0jy82DLxWhGIrf+dUat32n4mGDy/udlV0BGagloCiPZ0N3xI8mSFLIu3Dlg/xxC6vsmPF4CGe3WXbyqel839doKxG7COOlVx4GimREgA+POQUZxgt6KmfvnJbefxGRiYUS+EKV5lQoz7I0ZiS+XG5LkkdWyZBTXc2telmeleiSnxqxSWMWUUBxiQtRUtfYv7cK9iU5JRvuGuIKJkb5Qoo8c6At6et3hxJkMaGq+Dg72ZhAW6kp+tmMnnZIeOzaU3AexfcsFsjiHhLqAPzMFRqz/7TRRRXH4RF4V/WXpfrJoDhjuD2ERLfYXHIU5FbCaDTYtfGM8uLE+nXaJ6LyfSFkfrZu+3vCCpKz6uwVYLnzlizkQMSKQOAx88MTqNr52Up7z6SWTyOUDmy+QyFWpmDZ/gBARWpjXtndKVRib6MMgtunRpOdonwgv0hZSU9NE8uq7cHugCXG7m4yyKUUt5322N1jcpqTXFhESwcvlYsnvf1hLgNjyviZaIni2vTpxoncb3JlXdkFax5teRw9bhRPzHLZOlm3K8QhrYVip9e1WrCxfLRPGwcvyNaxH1JIpozjE1IV7H52SjA7v5wvXrt+E42ep8f3Y4a1L9ONHhZDyGnobxlygEaFTJtHBpSvN12H3jkttVNHigmo4eiBRoSp64UwmXDiTRRSKJ1hpWBa40H+9eCMhWb0H+cDkBwe0+/uX5FWSYaXaysvg4e8AX6x7llgi3evAkuFbPywA31AXYhXy/sJf4TLr9ZKKoN7uMHRcCDnJ//rVXsmlcYwIjRhKS+E7/lbPBH/MZOqriio7poJpAkhIhjKSy1X9LmgPvG9SE5ZIskNbUkrt3Xvc32rQRwzQZ5I8VsTnUHg9kSln99+vXnlfnfbc61dpJnoPNbxK7za4+lMhpUBJ1Kcs7N1ZmpICZRRhw8vx8mSUDStxBZTDUugHbSGjAvlkSqiFFVVju5TR1li+fDmEhoaSqX78GjBgAOzbR4UsxNWrV+H5558HKysrMDY2hpkzZ0J5eet+34KCApg4cSIYGhqCra0tvPHGG3DzpmbONVLRKcnogDAPOBuTDY3N18DW2gR6BrpAcWktxCUWkgVtPJs+3r07ligbfcI9SI42Yv++eGI1g9d5Hx7ib9Yr2m+QD/jKqKXY57Xq2/3kMg66OLG8XllsWHUcMpOKwdhUHxZ9OrPdHT7uPN96aAVTRO3hs7XP6lyikjahb6gH7/+6kPTHojL6+fNrJPfScTz22jiiAMWey4ILp+gGRQpmzKebiEO74uByB31Y7SGsjweZLr3ccBWiTkr/feQxgpXqT51I1xjJ7YJi8FZRqaVqZWRUivMDtn2Qx964Jfr34a1CYl63RU29Kak/VWo7gjrEnxN1ZUl49yKcmX9oUWbHFSE7Fu1ZUaTYq9iGGdlXlrQmo7xaV1vR0Op9tWLJaSiocKCNIaKG9YhaMjunWma71QUKZ2dn+OKLL+DixYtw4cIFGDFiBEydOhWSk6nIsGjRIti1axds2rQJTpw4ASUlJTBjxgz2aDy+bhEiev36dTh79iz8+eef8Mcff8B7770HdxKd0mfUQL877D+eLAwuoQrKE5f69vYAWxtTcrLG2EFZOyc8mLYyA/YZcyKE4YSSopoWVVTOV3Tf1ouCldM8Bfn0WSklsH7FUXL5uXenClOFyuyblsxfIfSIfvbXs2QiXFNAUpedXAwZcfmQn15KFNiq0jpoqGmCa1euE8WiW49uZPgHI/PsXazAxccevENcIKCPx20jxZY2pvDBrwvh1Vn/g9gzGfDbF7vhyXemSn4+e2dLmDJ/IGz9/RT89u1+ok4r6untCKF9PMDD1w5yM8ph/9aLMPtROnQlFvja6Dm6/o/TcGhPPAwdRZV7dREc4gJW1sZQXdUIF87nwMDBmvEy7UI7dkqaUEZlescxjhh9jaU+/sb1W6Cnf59oIotVG7Gvh68lBgKJFUm4hZQrNf7VvA1Bqk/w3QgXPyqaFGUq9g+VhZ0LLcOXFygjo0wBlSOjZlbG5DyJxwGev3h5ntsV1siQUXN2/qhlZXn0GUXU1TTpjCXdlWs3oDtzANDkc4rB5MmTW13/9NNPiVoaFRVFiOrq1ath3bp1hKQifv/9dwgICCA/79+/Pxw8eBBSUlLg8OHDYGdnB2FhYfDxxx/D4sWL4YMPPoAePe5MdaBTktHa+maIjqVTz2OHBcLNW//C/sN08GjCGDq4dOJkGjQ0XAEbGxMY0J9m+Z47kwGlJXWk927MuBbrpPW/nybWJ30GeIFfoJNwOybzcCun+c9EtrFyQrVh6ZJNpLdq0JhgGD5Reexlc+NVePexX6A4j07Nf772GY2U5utrGuHc/gSIOpgICWcz20xDyoNMOzZcIQptRhyNUOXwDHKGfqODYdiU3uAm56+qaXgEOMJr38yDT5/7E7auPgG+Ya4wjLVSSMEDT0fCwS0xkJdRBkd3xcLoaeGinwMV7anz+sP3H+6AXRvOw4wFAyWRWsSoiZSMxkRlkcVZE6bP+LsMGx4AWzfHwPGjKV1kVItomUJXXxnFkzmSQiSE3ApHDDA1Tvb45ZPMqoDfFx+nKri6yJORVAUngmLVXz64pE6FRDDc10BIwd0CPiWPpXdUsXlLhiLYONOKXqWMX6gsrJSU43HNwfNUdXkDqeZxMmrJzl2yLiZ8YKmumnq+on8zP4Ya2YDZncaY/66C+3tIj31WhFvX6d+G5vey0NPTI1/tPvbWLaKANjU1kXI9qqU3btyAUaNGCffx9/cHV1dXOHfuHCGj+D0kJIQQUY6xY8fCs88+S9TVXr2kn0fVQackoyeiMojK6edlB+4uVhAVkw1V1Y1gZmoAgxjx3LGL2jlNmhAmEApu5zR5ai8wYL1FZSV1JE8cseCJ1srnht9OkSgzLM1PUGDltH7FMchNLwMzSyN44b2pSsvzuDh/8uwfkJVURHaan655WiiLSAH+7TFHkmH/urNw4VhKq0EDnIr06+UOnkFO4OxlR8os5tYmoGfYg/wfsJyF9lQ1FfVQmlcFeWklJEe+MLMMcpKLyNf67/eDT6gLTHx4CAyfFq5WZnR7wMz6Oc+OgI3Lj8L3izeAVwD+ztLcBEzMDGDOk8OJMrr2f4dJbn1HbgaKEDk+FH5bdggqSusg+kQ6DBxBvWrFwsXNGvyCHCE9uQSOHUyCGfOoSb+6GD4ikJDRc2cy4dq1G8JQXhc0C3WGhhQB3ycko1ev3JBEjFGtxHUEe96xSqPy67JjFx+n+mMYgb2i+mMQPBNejArbesBLOhmVarh/N8PSwZxEqOKmoaKwGhw9lQ/NKusJ5bBi9oY1LFu+1evYmgpklINX9GplJuXxPChblsf1F6sAzU3XSAiIueW93c/r4uLS6vr7779PlEpFSExMJOQT+0OxL3Tbtm0QGBgIcXFxRNk0N289zIzEs6yMKuD4XZaI8p/zn90pdEoyeuRUmqCKIvawEvvoyEDo0b0bZGWVQ0pKMSFfEydQtTItpRiSEgqhW7f7YOr0FmK54c8zhNz1ivCAgBA6nYhAMrJtLR1kwaEl+fIPluexVxTx3DtTlJbbcZFc9tZGiD2dQSY9P/rtScmEC08OhzZEwZZVx6BMJi3DK9gZBk0Ig74jA8Ez0El0HB8CSzBIbM/sjSff0YD/+9fXwR9f7IIZT4+AyY8OIf2emsbDr46HtNh8SIjKhk+f/xO+3/4yiaGTAizVowE+vnf7NkTD1AWDRD8HKknjpveGjb+fhl0boiWTUcToCT0JGT28L1FjZDQgyAls7UyhoryBlOoHDaGRuF3QLHqwIR5N9ebqG3QnfchXRBI8Wa9ZSkaviX4c4qqIx+kzAotqKvaoqrqeSFFhEd17dJc8oMUhCAG6UQ2+LcD3xd7dhkzTozraHhm1ZuLH5VrasiUvMFgyxVOWcHKgmMHPEcJt7HyHxvfCbYyMymbR421IRvE2XSCjB7/QThyo/W9LoLCwsNVzt6eK+vn5EeJZX18PmzdvhkceeYT0h97N6Dw1CRlk5FTQvrwh/lBb1wRnWFb9hDG09L6L5dAPGewLlqxvZQvrFY0cGSSY8VaU18MBpqDOX9i6V/SPH4+QxT8k3B36D/Nr05/03TubSWkIy/NDxytPS/p72QGSOoTlI8xrx0lyscDX2/3nKVg4+CP46e1NhIgamxsSkrjy+Nvw44HFMO/lseAd7CKJiPIFZ9TsfvD+70/BXxc/hoXvTCWGx7gA/fbpDnh80EdwYP05jQx0yKs+i5ctIItbXnop/PrpLsnPhSfDB58bSS7jRuGqCDVIFhNn037i2OgctWyeho0OIp/TrLRSkuylCeBJdwibqj95nG7KuqB5cMVZLLFSBt4n2lEbTUePxxO7GBgIr6v6saAv09Mq5hjij7smkjD30O/WaiL+TgQL3K2w5YNJBe2vL8ZmhkRFRdRWKFY/EdjCJa+It0c8L9dfEQabzJiXaUNti0OKGfMvbaiXPhCqSRjoddfKF4JPx/Ov9sgoqp/e3t4QHh4On3/+OfTs2ROWLVsG9vb2ZDCprq7F1xWB0/T4MwR+l5+u59f5fe4EOiUZRUSEuYOFuREcPEpNwP197cHLwwaamq7BoSPJrQaXUEU6cZya4c+cEyE8x6a/zpF+lp7hbhAik3qE5OHoHuoR+eSrY9uU37f8fgpyUktJSfz5d6co/R2Pbr8Ify87SC6/8PFM6DtcvMoWczQZnhnxGfy0ZCNUl9UTgvjcp7Phrwsfw5PvTQdXFm+qSZhbmcCsZ0fB6jPvw6tLHwJ7VysyTYlK6atTvoPclI6tRMQAF8LXlz5ELu9eewai1LAuGjM9HOydLUj5aNc6aRZNdo7m0HcIHQ7aw1o7pMDM3BDC+1NP2mNMvdcEOBmNOpcp2n6nC6qBt/FckVBWVwQjRtRwfZL0eGNGRhvFPd7IWF/oWRezqePkjqfpiCO+4n5HPVZxuSZx8yibay/FreBuho0zHUyqUtILyoHnMK5+VpfWKzS+x+FWedKJwNYy+dt5qwhW/tCmj9yP3VZf2yy0TZiaGeoUGdVV/Pvvv3Dt2jVCTrt37w5HjhwRfpaenk6snLCsj8DvWOavqKgQ7nPo0CFCgLHUf6fQackoeoviB55P0U9kqujBQ0kkicnN1Qp6MuP7bVtiyIBSWC838GbkDSPK9jG/0QcfGyI8L/Gr/O4AuTx8XAj4BrUMNCEwC/3vn+gH5Zm3JglThfJIjc2D7xb/Qy7PejoSxs9r33tUHmix8dHCX+C9BSugOKeCLAjPfjILfjn1Lkx+dKhQStMmsDVh9Nz+sOrEO4T4GhjrQ3psHrw4/ivSV6pJFSJ8qB/MWEh7dpf9d0ObBVHM78zV0c2/nZKsRE2a3Zd8P7wrTi11LHIsHag7fjBZYxOlgUHOYGlpBE2N1yCODfJ1QbPg5e1mkSqfMqDtG0LqIAdPtxFrOWbEXlfM45C4oOOGbLKRKjBkxFcMgVWHxMqCl51vaHhSWtfBU5gw6rMjmNtwO6YGhe85d1OplyejXPGsaWpV0eKpTbwszwkq9v7yHmXs5Ueo6yd9L+Gtt96CkydPQl5eHiGVeP348ePw0EMPgZmZGSxcuBBeffVVOHbsGBloeuyxxwgBxeElxJgxYwjpXLBgAcTHx8OBAwfgnXfeId6kHQ1MaROdkowaG9L4z5T0UsgrqAY9vW4wYlgAOdnzHPrJk3qRAwwPir2sbC9rcr/l73Ok0T4wxBnC+noIt188lwVx0TlkgOHRF1sm2vjuZdl728juO3ywD4yYonhqrbK0Dj5+6ne4ef0WDBgdDI+9OVHlvw3/hgP/nCNqKE7J46QpluNXn3kPpjw27I746OHwBP4Ov5x4BwaMCyUDU2u+3gOLZ/+vjS+dOnjkjQnEexWJ6I/vbJZM3kZMDgNHVytoqG2CPf9ES3qO3gO8iUKK5OHUIelK7YAhmA7WDYoLayArXTPN5dhCwG2dzqjhq9qFjpVIJPyaAHfikKoQtZzUxT3ehClTjSIfZyyBRHDi2yTytXCTi8DcdKltQMKglober7sFlmwKXtHgkTwsWCm+vqotGZUdQMKMelnwKNGGuhYyKqt6cmUUFXVuC9bAbuOfe3V8m+81VFRUwMMPP0z6RkeOHAkxMTGEUI4ePZr8/LvvvoNJkyYRs/uhQ4eS0vvWrVtbJaTt3r2bfEeSOn/+fPJ8H3300R38qzopGR0c4U16uvYcoFPwwwf7gbGRHiQmFUFeXhWxQhnDjO/R5B5PKM4ulhDBJu3xQNm99SK5/ODjQ4QyPC6Evy+jGeeT5kaAPZtA5Di09SIkXcgl06YvfjBd4fQ8Wrd88szvxPICYz7f+O4hlfs4cef58cJf4PvX1hFFAqfif9i/mKiSRiZ3PnMZJy7f/fUJeON/D5MTSPL5HHhh7FcQf0YzhAiJ9mvfPkgI+Jn9CXByT5yk58Fd+wPPRAotFVclDI1gr+fY6b3J5f3b6GdFaq9fxCAfcvmEGqRWHjywIfpsps54+N1LMDU11OhJVChXspO0WHBSKTscotrjDCS9rqk5JSCNIh5nwh5zWY60dATsZ0SglyUSUikwZKSn+XLnIj1c7axXoHbKw1SJ8tmGdMp9xvhngZNO4f5MCeUbJDwf8s8brwCYcGVeR6yddAGrV68mqiiW5ZGYol8oJ6IIfX19+Omnn6CmpoZYPiERle8FdXNzg71790JzczNUVlbCN998A9263dl59k5JRkcM9ocrV6/DsZNprbxFd7JhpBGRgWBsrE96SbdtjiG3TZ/VVzC537YhmlisePvZQ9+BlKAiju9LhOz0MtJnNU/O5gnVul+/3ksuL3hxNNjJEVUEkoIf390CGQmF5EB9b9XjQgmqIyTH5MBzo7+AcwcSSan5sSVT4Nsdi4gfpy4BF5wRM/vCTwcXkyl+3EUvmfcT7P3rtEae3zvIGeY+RxXp5R9sa7MwqorISWHkPcL37eDWC5KeY8yU3uQzk3QpH4pk3AvEYtgompx0+liqxohjr97uRHGtrLwMOdktvUNd0Az44EW9hnrdzC0YmZRIRlsmlcU9nqtd9TIlVlVgqmAyuiO0kJlm0aomH67BaW8p4IS2UeLj71aYsn7OBhXamvh7elnJZ0Egl3KfUa6SN9a1PhYE4imzYTNm7R38NmMmojQ2dJHRex2dkoyG+DvBidMZ0HzlOjjam0NokAvU1TXDSWb5xHPoz0dlQUlxLSGm3OQeVdIdGylBfeDRwYK6iX6Ca36mSUqzHxvcxsvvly/3kAPKK8ARpi0YqPD32rc+Cg5tOk8IzFs/PAwOrm2jQ+WB5GTH6uOweNYyqC6rAydPW/hu92sw5/nRkg3Xbwcc3Kzh2+2LIHJGH+Iq8MN/N8Afn+/UCNl64PlR4OZrT3bwv362U9JzIKGf9TjtBd7y2ykhoUUMrO1MoQ9TNQ/uoBsdKeg7yJuYnpcU1UJOZuspSKnA5+sV7k4uR0dRN4kuaA7mjFjVaCjKkKfTYK+6FPDQBJ5uo/LrCsMn4l5XWf9gu49hr4VBHGLXATMr2ntfL+NbKQamrHe/XuTfebfDWFCwm1S/r5LWC0465dssBDIqpzrzvmKFZJQpobzdBSO4dQGYlqSNry50Up9RGv+ZIKiieH3/gQQyGe/rYw++vlTS3sImoSdMDhOmY/dsvUAOFGc3Kxgc2TLdvm/LRSgrriX5utMebO0JGReVDUd3xRHi+uKH04R0FllkJhbC8g+3Cr2PvVSIasSS/o9vbSTeoYihU3rDK988qLKaeqeBigaW7JFAr/1mL2z48RBRUl74fK5aRBr7jl7+fA68NusHOLQ5BkbPioCQfl6in2f0jD7w989HoaKkDk4dSCRqqViMmdoLzp/KgCO74uCR50dK+rvwsxfezwvOnUyHM8fTwIt9PtVF335eEHU2i/iNPjhfvKdqF5SD52pj9KomYGXDcrsrpT0fT7eRjV9U6XGsjIsbaVxvVO055+lwNSqUf+WJL8aBYo8qV9pUeqytCUkHUjRcowosbOmkeJ0Cn8x7GTgFj2hWoZ2E37dJSSuDEWtNkXde4C1i8o8Thtxk7i+4NwhklF1XYzhNkxj36kqtJTB1duiudKZFlJTVQnxSEaCoOXZUMOk12sX6C7mdU052OcTF5sN99/8Hps6gJvc4Fb1lHSV+DzwySCjbY0/hOmZg/9BTw1tNqqPp9U8f7SCXJ83rB34hbX1CcWf42fN/CgNLs5+mmbLtActRb8/7iRBR/D2een86/PfnR+8aIsqBBP2hReMJiSabgr/PwneL1grec1IR0NsdxjOj+J/e2yJJ2cSG+ikPDRDUUSmqbcRQP1KOqq68DPHnc0AqBg2ndkxnT6SDptCnL7WNSkkqkmym3gXFsGXDHpUaIjc2zFZH6vNZsd+nSuTjcYqf59NXlTeIfr0aEY/BzSlX0TDhTQwsGZmskYujFDvIU12quYHKuwH6jOzhUG1HtlbCoJiS/k0Dbh8m93NDRjrx/Cb7GoZGnGi2rD2G/DkY+TQ06qFTZLQLnVwZxWbdjz/+GI4ePUriqhwdHckE2Ntvv03MX8Xi0FHqGdq3twfYWpvAhYu5UFpaB0aGehDJvDx5r+jgof5gx04EB3fHk1gyW3szGDGO9pkitv99DupqmsDB2QLGTW+dab7tj9PEzgkV04dfHtPmd0GC892b/0BZYQ3Yu1jCq9/MUxoLylFeVAPvPPgTFGVXkAN9yYrHIVyCB6kuYey8AYRIf/nCn3BkSwzc1+1+eOWbeZJN+BGPvjEBTu9LgPyMMuI/Ou2x1sEEqmDiA/2IAX52agkkxuRCaAQlcKoCI+2GjQmG3Zti4OieBDJlLwX9BvsQso5l+gr0i2Xxe+rA0clCSGNKTiyCPiL/ti4oB/5feXkRv7DVRx3YsjWIpDA1Xxeso8SSWdwUoaWaouqMIuBaZG1nBiUF1SR3HF0mVAGPh0RnEDHAjHNURatK68DN10Hlx/GEIGXZ6R0+3slS6J3EtCltpMXpIjDVj+P6levCNLsicKFDWZCBAfufyad8yX5W0X6Lv4YBI5qyllz8ObglmiG/LiJ0QZvYv/Rp7SQwrX0bOjvuCmU0LS2NTKqvXLkSkpOTiXXBihUrYMmSJZKe7/AxOpU8fjQllLuZKjpqVBApieKQwOFDSeS2GbOoXyTaEW1ae5ZcnvlQf+jGFnM8OWz64wy5vODZEa1iP7G8u34F7SNd+Pp4wetPFnvWnoWzbOjorR8fUXgfWeSnl8JrU5cSImrtYE76Lu92IsqBbQao7iLpQsV31Qfb1OohxencR16fQC7//f0B0osmFqYWRjByKp2K376Gvs9iETmB9hufOZoi2XMUDaF53Oz5M5mgCSDRCOtF+0bj4/I18pxdAOEkyvtGse9cXWDvHJ8sLpXwfJY2xsRuDvuzqyrEleptHc2F9UxV2DByWCHyd+0oA70j83apZBQT6fhEfbkaw4Z3G7rLtF10pIzyIbFrV661S2zlE7Rw48MJqCzx5PeXJa8t8bPXW91HiqPJ3ZbA1NlxV5DRcePGwe+//07MWj09PWHKlCnw+uuvt/LOEoOqmiYwMdaHQf29obq6Ec6czWw1uLRndyzcuH4LfP3sISiYEoATh5OhrKSOkILxjJwgtqw5A02NV8Hd2xaGj29RSxE4PX/tyg0IDndX6Cmam1oCqz6hJfzH/zupw6jPrMRCeHMmDirVg6uvPSzd+Sq4++vWtLy6GDKpF7z63XxyGQezNi9vSZKQgrFz+4FngCNphVj3P5pmJRZT2cBZ9LFUKJdABAJ6uoCtgxlRtGJOS7eximDODefPam7gKIR95hITCjX2nF2gQDs4RFGhNIIkD0dGuHCQTSywwsBJZZlIwsadP8pFPM6O/a6YVY69pqrClimU5SL/Z3ZMscWoY6kbM0dPW3K5JFszQ4J3A/Dv5u1mtzpoZeLE9ca1m+2SVfTflgfaGdKftXwWeDsbniPl74duNfQ+3XWKjHahk5NRRaivrwdLS7pwKQP6cKEELvvFMWp4AOj16EYGl7A/MSjQCTw8bIgCuov5Qk6b2ZccrKjObfyLqqJT50YQH1IElua3/017SBc8N6JVSTk+OhtO7U8kB/pz705pU3q/dvU6fPnKWrIbjRgR2GEJOT0uH/475wdiVeQb5gpfb3lFUB/uNYycFUF6YBGYa3+KhQ5IAQ4MPfnOVHJ5z99noSSvUvRzuHrZQlh/L9JbvHeDeBN8/FwMHUN9a08elO4V2oeV+OMu5GosxjOYkdH0tJKuaFANw4URpHwJnzlFcGTktrigWtrjGUEszhdH9LirR2lBjShLKN5DiC1IKr+WG3utfHH/M0d3RiRzpduUOfvQtoDC9BLoVOigLYwDlXWEsv57rn4q2nxg/z1CtjLEI1hl74/+3+R+7DZ9dh2Hi/Hc3IV7F3clGc3KyoIffvgBnn766Xbv9/nnn5N4LP7l4tKiPI5jg0t799EM+UkT6aT0mdPpxHvR3NwQhkfSnNaLUdmkVw93aVNY2R6x6Y/TZMfmE+gIA2Um67Ena8Wnu4SeQw+/tr1Pv3+5h/QyYhzooi/nttsnmplQQIaVmhquQGBfT/jsnxcEz7d7FdOfGgFTWbznty//BdlJRZKfK2ygD/QZ5k8Wsz+/3SfpOSayYaiDWy9Kyq8ewkIUcLJeaqkep+hRmUfVID25GDSl3pmY6JNKQG5Ol9+oJoGbW0RujmbIqIu7Nfmenyvt+ZwY0RPreevIH5dXJU5pdKO/b4mI3xedNRDFIv9njl62wgCTmAhSWbgG0Ojm/FTNHFt3C/7vX9oK9R+mkCoD7zNWNlzKs+lxUEkZUZVdOznxlFVSe+h3a3UbV1tlCWoX7k3cUTL63//+lyxa7X1hv6gsiouLSdl+9uzZ8OSTT7b7/JjZigoq/yospKVIzJ3387GHi5fyoLSsHoyM9GDYUDqtvH0LNTifOKWXMEXKVVEsz5vyac+qy7CbWT9hr6gsmdy74TzkZZYTr1E0uJfHpVPpsOOPU+Tyoq8fAHMl+fS8lL+EEdHgfl7wyd/PaSVNCZv2C9JLIf5UGpzbGwcnt8XA6Z0X4cLhJMiIzYO6yobbntTz5PszoE9kACFvHz/xS6tsY7Hgkaond8eR/6lY9I8MIBsHNMGPPt76M6kKfIMcwcbejGxeLkVlgxSgyh7Wh/Z4xsbkgiaAn1sftlnKSC/VyHN2gcLT2458z8rUTIyruyclt/kSya0LI8eFIh/vzB6Hg5hi1gBnRiwLRYQqODNSWZRdLiraE/vDeVxlYYa0z7FniCv5nh3fefqnUTjh7yknk8ogkFUlnwFuW3fr1i3lRPbGv20IqqzS2r07J623hAFQDk1Vg7qgm7ij0/SvvfYaPProo+3eB3tEOUpKSiAyMhIGDhwIq1at6vD59fT0yJc8sESPJ+E9e+ng0uhRQaT0jkk0CfEFxM5pMusLzUwrhbgLeeS2GfP6tVJFkST5hzpD38HU2JynT/z1A40EXfDiqDZeedi7+N3iDeTypPmDoG87w0eoKLw970cSqeff2x0+XPOMRqybcPHJSSqEuBNpkHI+G7IS8qFchdIfNvl7hbhAYIQ3hA0LgKB+XtCNLR7aAC5ub/74KLw88WsozauCb1/5C97/4ylJE/aegU4wdGIYiQhdu+wAvLviMVGPxwGzMTPCyWT9gc0xMJiV3VUFft4GRPrDzvXRcO54GgxgVk1i0TPcHU4cToGES5o7Yfr42MOlC7mQndV5euVuB7x97EgFFN0KamubwIINNEmFByNqqIyiyo+xt2Lg5k0fnycyccvJ3Rruu/8+aLp8FaorGsh0vSpwYa9XKKIH08HNhhxrOMBSWVIn9J6qArcAJ6itaIDclCLwC/cAsfAOcxeU0c4yUX9dpkrDxZeOFFRlZX38jLS6nwz4YO/Nmy2Ekn9+W5PR1vfDDXi3bveRMr2UilQX7h7cUTJqY2NDvlQBKqJIRMPDw8kwkzqWPyOG+JOTw9lzdHBp4gRaot/BYh8HD/EDa2b2vHntOSGS0c7BXFBF92yi1k/zn4lspYquW36UZO26+9jB+DkRbV575UfbiW2Jo7s1LHxrktLfERv/337wJ6itvEwiPT/661kwVMMeBgloZlw+HNkQBWd2XSS/gzwMTQyIJYuRmSHp58HJW8x6rqu6DLXlDYQUx59KJ1/rv91DyOngyeEw5qFBENDXs0NLKilAMv/OqoWwaMpSOH8kGbatOgYznxkp6bkefHkMnNobT9wLctNKwEPk8Nfo6ZSMXjqTSU7K3EtRVfQfRslozKkMovpI+QyH9nYj39OSisiCzV0d1IEnIzl5Giond4EC7Zxc3awhP6+KeLkOGuKn1r/GwdmS+C6izQ0SUk8fqryqCg+m1FaW1ZOsefmUOGVAdQoJKSqcuellKpNRd2bNlCdCcUfS4uxtB3mpJZCbUiyKjHoFu0DciVTITpQ2jGftZEH8RmvK6iDzUi6EDJa2YbybgOs7AtfuHjL+2IrAy/PKgjv+045wys8NeE6RJ6OyZf8WBVWWtN5PyKgskb1TuHL1BnTvcUPjz9mFu8RnFIno8OHDwc3NDb755huorGw5adrbi0+jsbQ0hr37k8gH3N/fAbw8bUmq0hFm58RN7tHP8cQROnAyez41P+eqKPa0oCoaLuMbWZxXBbvWUfL6xOIJbbz8zh9NgcNbYsiB+do385TuvDGR4r0Fy6GsoBoc3K3h0/XPi0ojkQU2hx/dGAU7fzkKOTJ9l/pGehA6yBdCBvqCb28PcA9wBFNLY6WE8tqV61CYWQaZsXmQcDYDLh1NJlF/+/86Rb68e7rC7BfHweCp4RqPIfUMcoanP5hBI0O/3A29hviR28TCzcceBo8PJYR044qjsPh7OrWvKvCEHNjbDVIu5cPxPfEw8zEaF6oqQsLdiHUJRjJmp5WRXmOxcHazBhNTA2Iplp1RBn6BtM9NHbjyXsROZGlzuxAc4kLIKFZc1CWjqBJ5+zkQVTw9pUQ0GcXEG3snC5IUl5VWCr37q55K5ulnT8hoTlop9B2q2t+Bm2hEXnoZUb9kbe/ag1egEyGj2clF0H9Ma4eS9oBrEALXKCnAtS9ogA+c2hYDSWczOgUZ5dGeaGvV0eb45g2qTN6v5H0Uek//oxpRve8/9PVwdqM9gorKKJo/3bp5e9vEFGHii10JTJ16gOnQoUNkaOnIkSPg7OwMDg4OwpdUlXDffjq4NHE8VUUPHUiEq1dvgLuHDYSyRW3bP9Hw763/I316eBJA1NU0wt7NFxSqor8v3U/KZ32G+EL4IN825fn/LdlILs94YhgEKikjYQ/P58/+TgZ2MKv5k7XPgQVTacWWX7avOAyP9noLvn95DSGiqHYOnxkBH65/ATZmfgcf/fMSzH5pHPQc7EeyndtTNjEdxTvUFcY/MhQWr3wC1qV9C1/ueA1GzRtAmsyz4gvg8ydWwfNDPyJ9pprG+PmDYMDYEBIV+PXLf0ku2cx5jqqqJ3fFQlmh+KnkESyh69gu2uIhBtgPFcaM5S8yOzEphCQghBLQ1ETNDTEhGuqvQIMKsYBdUB1hTMnGNDdNICDYSVDGpYBvgDJTxH12vNmmJ1PE4BxO4WMoBx6rBSL6ZrEVCJEl0m7MrzddU1EZFWMnJYuQIbRtKv5ECnQGXK6m3ssoRHQEbumkzBifk8r77le+6Wh1iuEEVYaM3scVVJl+YU6S1U3l64Ju465QRrGvtKPeUjFISS2GwsIa0icaOdyfkNOd26md05Tp4YSUNTVeg307LpHbZsmoolvWnCW9on7BTq1U0ZTYfDhzKJmQhSfeoEbrslj9+S6oLm8AJ3cbWPDqOKW/28oPtsKFoynECuODP54GRzY8oCrwbzm+5Tz8/tFWqCiqEdJJpj09EsbOHwwmavatcaD62XOIP/l68qPZsPOXY4T85qUWwztzlsHAiWHw3JcPCsko6gLfk5e+mgfJMblENdnww0GY/1rb/3NH8A5yht5D/MgQ2fbfTsIzzEJKVQweGwzLP91JEplwoIMPd6gKTGDCnlEcYnrgCeoWIBa+AY5w/kwWZEgYxFIEDHqwtDSCmpomKCutA9MOghe6oDrCelEymp1ZDrU1jWChwkm/PQT2pEQtKV5aKdo/xBlOHUqGtARxZNaXBS5kiCiBk+G4YGeIP5cF6fEFpG9bpdcKo/+z9Ng8sp6p2v7j4GFDNvBYscHNcWCE6sovRy/moJJ0JgOuNl0FfRZZea+ilsWumqvQcoR9tAhlFT3e+9mte1uNiw9JKZrYV0hQZRXU+xlBvc0DtIqw5wctJTBt7EpguiuUUU3j4CFaeh8+zJ8kpcRdyofCgmpyUh7FBlMO7IolvVmuHtbQpz8lndhntWsDnaB/8KnhwiKJB9rqr6ll0JgZfcBNrnyWEJUF+/+hfqQvfzEH9PQV9+bsWXMadv1+klx+44eHydCSGOSnlcAbk76GL5/6lRBRJIIvLp0Pv1/6DGa9OFZjRFQeqKou+O8U+CP2c5jx3GjSnnB2Txw8PfB9OLqJ/t2aALoOPPfJLHIZyagYtUUWM54YTr4f3HSeDGWIgZmFEfEcRZw+KF4B7tWfKqOpCUWSLZ58AqhKn5WumSlt2bjJinJp2d5dUAwknz6+tJXofLQ0FwVZBIW6kpN3YV4V1FSJTxQLYL6yKfGFoibjfYKcyEa7srSe9EurCr8wWmVKE5Hw5R3sTEr62C+PrUqiyuxsrU46Jy1cwsXPEezcrOHGtRsQe+zeV0erS2iAAvbKqtpfyv1j5cGrVYqGWrlHqGwLV3sDUQr3HzpARg30u2vlqwt3SZle0zh9hi5UE8b3JN937aCq6MgxwYScYjlg2z+UdE6b209IqNixLopY83j52UPEkJYyfNTRVKKMopo5/8VRrV4Ly0U/vL2Zvt6DAyCkn+LdelJ0Fix/dxO5/Oh/J8MgNlSlCrC0jwNFzw/7CJLOZYKeYQ945O1psDrmE5j46LB284Y1CSS7T30yB346/i4pmaEd1VdPr4alL/zRampT3cjQiFHBZBf+01sbJdlN9R7iCy5etiSaDnt4xWIQ8ww9I4GMOrlagZWNCVm40xKLJPuNIpCQXNfQhKk1sxerlkBwutA++g+kbhtnTklP3+JAazlPH3sh/EAsvAMdydR0fW0TFOaq3iOMLh7cLznpguo9mbwdCSsaqoK0BLFSfZJIAh86iPaz4pClFCCh7T+BtuKc3UXPC/cyygvoZ8DWhXrJtgdczxFGSionOFfA3z95cFsm2XMRL8W3mjHgy3l7jadduCfRKckomue6uFiS1KUajANlJ4kp06id07mTGVBeWkcGRUaxXPHmpmuwYz1V+eYuHCqookhc//juALk87ZFBbSasNy4/AkU5FcSj8rHFiqfncbL906d+I7tHJFtzXmjrTaoMZfmV8PrEr+HPT7cTgtZvbCj8EvURzHttosJF4XbAPdAJlu5fDPMXTyZE/uC6M/D6pK+gRgOqG/7fUR3FPtWEc5lwcuclSc8x+eHB5PLedWdFE9oBIwPJc2SllJDJZLGvHcz6CJMl5sHb2JqSrHL87BVrKGoSzfQR9WygoQuaw5BhlCDFnM+GJplsbqnoHUEJ3oVz4pVWnIzn6mjc+RxRjw1mHrcJIh4X2MeDfOaLcyuhplJ1RTWEtUDhsKQYhA2lPZ+JZzMEciQWg6f3FcjovW4nxKNPHTyoo0Z7uFxLfZ6VVdh47jzPk5cFKs3yZFRQS2Usym4xgsoFIAIuoKrw93Th7kWnJKOIcWNCySK5f288OakHBjmBpxctr29nkY8TZ/QWoj/3bo4hE/fO7tYwaCTtK0Ic3RULBdkVYGxmALNZYhAHRk9uXH6UXMbeRGMFO0okkJ8/8xuxT8KJ9kXfPqhyjxSa0z8/7GNIjckmu9U3ViyED9a9ALbOHe9ytQ0s1c9fPAU+2fwKWbwyLuXBK2M+l2xILQs7FyuBsP/22U5JquuIaeFEyS7ILIfUS+Kmb82tjMGf9e7FnBSvwASwAblUiX1/+PngE/Bi1K32gBsvxOUGaek1XVAOD09bEg2KRt5nJCp2sug7kBK1mKgsSUMdvfrRVpFYkeELoWz4TgwZNTEzBE82NJVwLkvlx/VkA6BxpzNEbRbdAhxJexKuCQmnpf2vgwb6kbJ1Y20TxOwXP6h4N4FHnzorSAmUB56jeFuWIlxppGQUh9bkwVuSZBOVFKmlisr5XEHlPqZduDfRKd9d3HWNGc3iQHfR3PNJU6gqinY5aJ1CjO9n0h0ylkK3Mr/R2Y8OFg4UvH3tD4fJ5TlPDCPWKRy4gC7/YBvZWePAzJCJtCVAHr9/vhNSLuQSMvnur0+oZLSMB+cfn26DD+fTZKaAvl7w08n3YOSc/lrx+lQHvYcHwrLDS8DJyxYqCqvh9UlfQ06y9GhPDvQatbI3J72xu/6gfbZigP/vISwC9iBL0hKDvsOo7csFKWSUDYOkJxVLTrVyYmW1Yjakpi7QvxJxRaKa1AXlwGNy5OggwbVDXQSHuRJlvL62WdJUPQ7RcWX0BrPrUZWM4tqJg3vlxbTXUBX0YsTyoohjJTjCixAXrBrli/Apxf91BLODimKOKWKB6/vIeQPJ5f1/noB7FTigxZVRj6CWqGxlQP9VhIUSn1luE6UoIRBDDBD6MtU6LiLIpizxISiexERuYwS1WzfdOrd1QbPolGS0dy93sLIyhosXcqCsrJ6YUw8bQcs7OzbSHsIhkQFgY0dL7kd2x0NN5WWwtjWFERNp2R5xcHMMVJTUgaWNCUx+qGXiHnHuUBJcOJEG3XrcD899OEMhSYw6mAhbV1Ll9NXvHgJH944ns682XYNPHl0B/3y7l1yf/swo+Hr362DvSpUyXYSjhy0s3f9f8Ap1hfqqy/DWtG/JsJU6wEXtYRbxicNMTZfFWxKNnkU3G6f2xcO1q+JIWDhL3YqLyiY9u2Lg4WdPSlM4EFdRKq11wd6JDhyUlbQNL5ACfkK4do+XJe8URo/FSgxA7MU8KBFB5BQBgw4iBtHP3+lj4qNpvQMcwMLKGK40X4dEEf2fWNnxZ6r+BRH9r72ZL+nFk2kqR3xii1Eo67U9L9IqbiDv+dwbJ9kOaOyjdMgxZn88lN+j/rvZ8QVEkLG0N1NpgIkHpViz8BdlZFTeExs9uTnJlFVNFaqlbP3p3qPFHoqb3Wsi4KMLuotOSUZHjqAqxV7mFTlqbDDo6XUnPotHmXIxlaUn4eK59a8z5PL0+QOEHRsOJv2z8ji5/MDTka12fEhsVn28g1ye+UQkOCmw/8ED+7tX/yaXpz0xHAaOU6ycypdJFk/9Fs7ujiWljdd/fgye/myuViM5NQUs7aAvqU8vN2K9smTmd1BRJN7nUxYjZ0WQLGuMYN25WryCERzhCTaO5tB8+SrEHEsV9VivAEfSmoF9UhlJxaKJnyvLGc/JkDYRz9PAxPasKgNX+2UTUnQRNbVNcOBgIiz730F46+1N8Oob6+Cd9zbDjz8fhkOHk6CmRjcHsOzszSC8Ly1z75bQ5yyPoaxVCKNhZU3DVQH6NvZjBPGsSDIbwWJso46qPmke3NeTTGDjdHymCO/QfqPooOA5kWpyz6H+YGxmCLXl9cS8XgpcfB0gbHgg+d/uXEHjne81pJ6nbRO+fVSzwMLKVnvDTriuI9BeSxbNMkKBbJw1V0sxCER2ngPRQ48SVKwc8Zx6VUMTunB3olOS0X4RnjQO9DSbqp/US7Bzwl0cJpsEsZ7A6JMZpC/PyFgfxs0IF55j38bzxOLExsEMxs6mChvH1l9PQDlaKzmYwwPPt42uRIKLOesNtU1kavSxJVM6/J0ri2rgtQlfQvqlXNKD+fn2V2HUA7SUdLcATxCfbV4Ebv6OUF1aB+/MXgZNDc1qEagHF40nl7f/elzwwRNzUh7G3vuTu+NEv3ZIHzpIkihiUpjDg01E52VKy4O3sqYLfjXr47rXkZpWQkjnnAd+hC+/3gM7dl2C6PPZEBdXAGfPZcHWbRfg8y93w6y5P8LLi9YSwqoppwFNYco0un7s2x2ndjtE3wHepFRfVdEAiRIM9QeyStDZY6mi1MP+kQFCRaCJWf10BNw49xnqL1SMVMWAsbQKlXYpDypFqMn4eoOn0P81xh9LxfQXqR/03tVHobGODu/cS0g6Q9smgvpTBbo9kFjoSrrW2LsprsLVsrUILfhkcVko3+u36gXFoeA2BPUKJaP6BpSMciKK6NHjzlsgYXSnNr66cJeY3msaqEzt35NIFmH/AEeSzY074N1bmPH97L5CWZ2rohNn9yGElKuiG385Iaiisj0vVWV1sOHnI+Ty44snKuwB3f7LcdKYj6WoxT8+IuwClaE0r5IoorgztXW2hE83v0J27ncjkEh/svFleGXs51CQXko8UXHoSkpOOwLdB/76Zg+U5lXBgfXnYOpCWl5TFdg3unnVMYg5nkoUbWUesMqmi88dSSG2XmLh5kWV0QKJefBYZkXU1mjmJNnSq6Vb6kN1dSP8vOIIHDveolz7+NiRVhtnJ0syYIgT6oVF1ZCQWAiZmeWQmFREvn5ZfRxmz4qAaVN6k8rHnUa/Ad7g6GRByvQ4ODmd9aRLAdozoTq6b0csHNwdDz3D3UX73Rqb6JP2o6RLedCTqbYdwdXblsTiYvRx9LFUIZGsIwwcR2N48euR1yeo1NtuZW8GQRGekHw+B07uukT6xFXFqAf6k5jiUzsvwLNfPAAGbO0Wg4hxPcE9yBnykotg+08HYP7bM+BeAbYWJZyiqngocyBoD8U5FYLqiaKCIlSznlJLuZ7SerZGmVoatYm9RsjOWsirpZiKyMGHie8kJj+zArp112wQws0bXUOjnVYZRel//x6qhI2fRIdYLkZnQ2lxLVEbIsfS8lBGcjEkXswn/X1THugvPH7fphiyiKMqOnp6i1qKWLN0P7EUCQx3h+FsKEoW+Rml8MeXu8jlp96fDs7edh0SUTSyRyLq5G0H3+5dfNcSUQ4bZ0v44O8XSK/Q+YOJsJ71v0oB7rRnPDVCUEfF9oj5hDiTUj0ugvFnVZ/2RQSwpJjUuALRg0joyoAoktiPZspOCJfrr0gegpJFS3lMd/anp06nw8InfyVEFAdnxo4Jgd9/fQJWYnvKk5EwcUJPGDkiEKZM7gXPPzuK3L5h3XPwxOPDwMbGhCRKrVx1DBY8ugr2H0gQXc7WNPCzOpO1/2z6J0qYJpaKMZPp2nXycLLKKiUHthsNGkVL/Uf3Jqj8OCSRQ8fRAaETIh4XERlA3CtK8qogS8TQ1fCpdH09to1GMKsKVPscPW3JhPfxreK9hBG4QZ63eCq5vGXZPtLvfq8A2xea6pvB1MoYfFiManso4FP3rKKjaDPLlVP5ntJ61jpjJpc+hmsXQtZlhlufGTK1FH29+SZZ1gKqC/cedOfMcxuRnloCBQXVZKc1fARdkHdvoYvdmElhJIkJsY1N0A8bGwLWbJgJS3+bfqWq6Jwnh7eypchOKYbDm+nC98TbU9rs/nE3+u0ra0nGb58RgSRvvaPSPCqiVSW14OJjD1/ufL3NrvNuhU+YG7z47Xz49vnf4e8vd0LPIX4QrEK5SBFGzekHa77aTdJaYo4kQ382Tavy9O2IQNiz9iycP5ZCLqsKrwAH0seE7RY4yGbnpHr0qYMzzYMvkzjMgqoWAsn3tWs31VYNGi/Tk4CRCm4O2gb+Tb/+dgI2bIwWlNDXXx0PPt6KT4SysLExhQfnDSCK6OEjybBm7WkoL2+Ar77ZC7v3xMFLL44BXyUn1NuBcRN6wt9/noaK8gY4uD8BJqqoLCpCYIgzuHnaQH5OJRzakwDT5lKiqypGTuwJB7ZdglMHk+HZNye06ntvD8MnhcH6Fcfg4ukMqKtpBHMVIk4NjfWh38ggOLknDo5suwA+zNS+IwydEg4rP9wG2UlFxIXDM4g6UahyXE94ZCj8+v5m2PXrURi3YLAkp5GhMyNg47e7ITs+H9Z+ug2e/+5huBdwZjs9T/UbH9badF4J8lJoXzy2WClCZUkt2eyhwGDOWog4sFcYgV7bssDgBfmBJ56IxyfyhVK+Au/SO4FdK57RThzotnegs6NTbjUOs76lIcP8wchIDyrLGyD6dCa5bSLrC60qb4CT7H44uMRxZPslkjGP5vZjZvZp9by/fbGbqFRDJ4VBQK+2ZbMtK45AZnwBGXx55ev2/URxWOktHPJBRdTLFr7Y8do9Q0Q5Rs8bCCPn9ieL2DfP/ibEzYkFnkTHPEDfo71/nRb9+L7DA0RbzyCwvcKNKdtogC8Gdo7mgjrAF1wxQJWJA6ei1QU3u+eK650C9lK++8EWgYjOmR0BPy57WCUiKgtUUsaPC4U/f3sKnnoyEgwNe0BKagk898KfsGLV0Vblv9sJbBeY+yDt9V7752nSoy4VJLyBrUE7N8eIVn5Dwt3BwcWSfP5OHlC9l9PVyxZ8gp2IJ+QxNgSqCkay3/XYjksqm8ljaXcA21zuX3cWxGDs/MGkFSonqUiy5yiqo099MY9c3r3qMGQnSAuq0CWgKHJqG7WzGzxdtQ1MdiIdPPMMVryJKGUVHjtnyzYtV9VsyNKSCTry5XtzmfI97y81NtVvpZTyFrk7ja44UO2hU5LRUydor8w45v25f2csWchDerkKZuK7N50niy2m5fgEOAoH8SY2tT3zsSGtekVjT2fApVPpRCl79A1qOSSLouwKWLuU5tc/9cFM0g/Vnn3Tew/8D4oyy8DGyRK+2PYa8dS8F/Hclw+SPtiy/Cr4/eOtkp9n/EP0BH/hWCrZpYsBRrRiCQiV1TI2MaoqPP1py0SeSDN/XFwNWcazmKxvDixb8/5OTaTEYBIZAi3P7hTqG67Aq2+sh6iobHJsvfv2VHjmqRFq9bHi8zwwpx/8vvpJiBweQI7zjZvOwxNPr4YkCR6dmsDkqb1JG0FlRQNsk1hC5sCEOCxpFuVXQzSLORZDZsdNp61EuzeJ+z3GsPak/ZtiVG4TCR/iB1Z2ptBQ0wRnDyaKPrax6sT7DFXtT8cNL2Ljsv0gFWHDg2DI9L7ks7Ps+d8k20XpCmIOJkBNWT0p0YeP6riKhO9vRiy1APNVILLI9pQ6ebZNcqpkllA2cuV7PvDE+98RaHcnmwjXyCJIeSWoC/cuOiUZRSXJ3t4MQkJdycKCZBQxkS2wOKC0j5Xtpz3Y0it6+mAylBbUgKm5IYxnvV/8YP39q930OeYPBAfX1tYX+PMfFv9DyvO9h/nDqNnKd6P4+3zx1C8kscjU0hg+2/IK6bG8V4Hm86/87xFyedevxyFTYkQmLoLB/bzI/1psfxmWEP2Yf2KCyFQaHOhAFGTRxVgM+CJcIzEPnkfmaeLkWMEIMUaN3gmgJdMri9ZCenopmJoawLdfzyPkUVOwsTYh5PbTj2eBtbUJlJTUwcuvriUq6e2euse+3EefoGltf685Q5w9pAKJ6CRWzdm0RpxyiBg7rTch+9gfn8bUL1UQObkX6Bl0J+lzqrpJYCrbmDn9yOXdbDBUFfQc7Ess3LBycogp5qpi5gtjyHFy8WiyQKik4Jmv54OhqQGkX8iBzd9J73HXBexaSYNaRs8f0qrNTBlQFMEoUCzBeyhpkyjMoq4g+D7Jo4K1Itk4trQx4TqNcxcIS5k1B4McEGYscpQnwnGltAv3LjolGUWMHhdCF6mobFKmxzjEwcy25MSBJHJQ2NibwQDmq4cHD+8VnTJ/QKv83bMHEiEzsYhYVDzwfNtceVxAMUcdS0YvfjG33fL86vc3Q9S+eOiu1w0++Pt5jQ8rYYpG9L442Pz9Xlj++lr46vEV8PG8/8Gn83+E755bDX9+tAUOrzsNuUmFKhtUayKlKXJWBPkf//TmOskDOSPYdPKJ7dQVQQyC2DRx8gVxed0uzEO2KE/8IBJfcLkacKeAZLaMqRcOrH3gdqKy6jK88urfkF9QTYji90sfgqBAJ6281oD+3vDbrwth7OhgwI8ZqqTPPv8nZDNl53Zh1JgQ8PaxIyXy31YdU+u5pj/QjxDKpPhCSBAbbWtpTHriZXvkVQFOQPNJ+p1rVSfB4+cNILGOSedzIIf1IXYELPtOfZyS9+2/HBMVMuHgbgMj5lBBYc1n1PtZCqydLAkhJc/z0WbIuChundAV5KcWw4WDCeQcNOkp1dwJEs/SFjb/Pp5KyWseCzFxVXC+4tUmWZEG+0W5gweGxvB1iPeRWrC+0zp2nSulXbh30XnJKPOw46oolrv4JPGuDbSfZuLsvmQ3j4g7lw3ZqSVEDZj0YEsPKR5Aa1j5fdpjQ0luuSxwR7n6E7oIzn9tfLtJSQfXnYGtP1OD5Td+fhwC+9HYPnWAhDL+ZCr8/OoaeDzkDZjn8SK8N+Nb+OWt9cSu5Mj6M3B6ewyc3BIN+38/Dus+3w5fL1wJz/RdArOdn4MvH1sO53ZfgpsiYgOl4IkPZ4O+kR6kXciBU9vFKZscg7AZv9t95CTHy0aqIrA3LT+libRpcnSjC2xpQbVoEm3CdvuNrGlfLHhMnrp2TEhEcbJbT6/bbVdGkYi+9vo6KCquJdUKJKLuSnwMNQVjI31Y/OYk+PjDGWBubgi5eZWkl3TLVtVLzuoCh0aef3ksubxvTzykqNEyYGVjAmOnUGL458rjov+GGQ/TUvapQ8lQKiJedup8+ji0NystVO1xWKodPJ6uvVtFBFXgkKKphRFppTm1m67ZquLB1yeRdfzCkSSIl9g7ihizYAgMmtqHkCjcvDfoaMBCe/j7s23k+8Ap4eDo2b6TC0fcSWqrFjKQxrrKAz9vuamUjHrKbSLRLq+SpcQ5shY4BA58ciLKCW5dTRNphUCRiG/U69lG3UKFIbku3N3olGTUP8iJ+P2hR+O5k7TPatxUuphjuQq/8ATP+6kQW36n+edjZ/YRDhTEqT1xUJBZTuwpZjzZ1uPyz692k0XL1dcepj0RqfR3whLSD6+tJZcfenMyDJ0u3YMQUVfZAOu+2A4P+70Kb479DHYsPwTFWWVkR+wa4ARDZ/aDOa9Ngic+e4BMiD77zXxY8O4MmLAwEkIG+xFi2FjbBEf/OQsfzP4OFvgugg3f7JY8ZNQRrBzMYdYLY8jlPz/fITpikw87hLIF89wB1W1nEL6sTI+9vWLM8/kEPbZ+YBKUGBiwyXVMcRILjMjj5fmOfGo7QjZrMXB1s1ZpslaTaUpvvPkPIaJ2dqaw9JsHwVFJ1KA2MGigL6xetRD69/MiZPyn5UdIqhP+XrcDIaEuMHYCJWZLv96rltXTvEcHkzUrMbaAVHvEwNPXHvoM8qb9tL+dUvlxbj520GeIL3nc5tV0fVQFM56g6+TxnZeEEm5HQL9mTKpDrPv+gKjWFLR4Gv/wEHL5l3c3Sm5rwbVz0fInwN7dBsryKuGzBT9qfZOuSWReyoUTm6PJ3/HQkmkqPQb/V7EnKBntpaRtprywGhrrmsm8hItPa4JbxHyUcWIeNxPCY4ro+y7rQIJDwwhLaxNhHaplveyyQ05duDfRKcloJEsfObIvgRxsfoGO4MF6XXgj/+DRQYJlSV5GGVw8nUl2bNMeHiw8Dz523f8OksvTFw5r5ZeGQDuSfWtpb9Tzn85RGmeG6inmzWNPaf/xPeGhNydJ/tvqKupJ+f1hv0Xw54dboLKoGozNDWHsI0Ph/Y2vwJbSFfDLpS/g7bUvwMJP5sLsRRNhyjOjYdrzY2H+kunw8o+PwzeH3oGtZSth6ZF3YcaL48Dc1pSU9397dwM8GvQaHPjzhFZK+DOeG0P6ZIuzyuHENmmDHf3HUI/YmCOqxxXyviULGxNyYs1LVz2iE4mgGVsoxQ4iocrOe5TFormpZYJeXduTjHQ6fOXte/ssjxoarsCbi/+BgsJqMszz3TcPgv0dcIuwsDAifaQvvziGkLnzMTnw5NO/QcwF8alaUvDUsyOJOpuXWwnrJDhBcNjYmcLkWXRa/dcfj4gmXA+wHtaDO2NF2Y3NZo87tO2iyp9/7M8OG+RDBkQ3rqABIapgyuPDiBNJYWaZ6Fac+f+dAoYmBpAVX0DM8KUCh6JwHdUz7AGxR5Phh5f+uG1qujrA9fqnV9eQyyMeGAheodQjWZXIUDw/4TkkoI/iYAReTfIIcGyzMf5/9q4CLMq0a9/fv+7q2kUjISkNIiiIgmJ3d3d3d3d3d3e3YCAo3SndCIodu9/3X+e8M0jMMDOo6+7qvdd77YBMzzzvec65I0EUd1xDX6UAPU3cSVet8VkPkSUyza+u+nk6ky3ilYoT57433r3/+E2On/hBfUYdnYx5Abl1JZB/biYyjyaPs3vXg/NG9GJcOCRwouq5mrIVihgPrwUi6WkmL5DtBjQocB90+zvmn+HipkEba1g4SPbQpL9bPWofWzip6SphyraBJUojIkX1uU3XcXT5hbzupaGNLtqPbsZK0N8USBYi0FjL1MGQj4GLu8H9pCeOLDuPtNhMrB2+m8f7k3cNk5pTXBKUrVAGHUa44sCS8zi18QZcOtsr7A1o6yL4hIb5xHLHMX/UnCzoGKmxJ158ZBqMreVbrMX+eWRTkvPsFXSN5Of4lhJRQMTjdkXwSqQypdi8Lx3Th4u4e5RG9lfg7dsPmDbzJGLjslC1ajmsXdUTqt/RLYI+Y+3a2sDCvAYWL73IY/tpM06gW1d7DOzf4JumUlWqVBZjJjTHonlnceSQB+zrGZT4feg5wAk3LgUgNjqDU5laiKY98sDMWhvW9jXh/zgWR3a4Y9LCDnJdz7yOLkxr6yDUNx4ndrpj5GzZ0caEHqObIMAjGjdOPEaXYY3YEkgesWPnEa7Yv/wSDq66jPqtreSeClBEZd8ZbbF95gnsW3gWDi2tUaWElJSa5lqYeXAUFnRdj+v776F85XI8YSqJj+lfhUvbbyP8cQwnUQ1c1FXu6z286Mf/t29mkUdZK4wwb4E/a1y7qHk+raXitTU/KMGLoCGiORHEmyCVfNORZ+JiVMQr/d5oP/BnAtO3wg/ZGSW17tOodMTFZPKJpmETU/79nSuB+PD+E7T1lGFqJYxtiVB995LAUWrf17HATvP4ZoHf2X5ggwKRZoRH14MQ7BnDCsRBc6SPRC7uuovH1wOZNzNr33CUq6g4UTvC+ylG1ZuNPbNPcCFKRejSS1Ox8eECNO7hqHAhWhj02Eh5uTtgBYYs68FdgcB74Xyf/m6h+JpoPciZKQJxoSXzBlTXUYJKjarM6wp9oqAyXjRiog2GIhB3RsW+efJCfOoqSWflM7H/y8ZXpCSPEBWjpmbyGYp/6f3NnnsmTzW/akV3aCgQFvAtoaurhK2b+6JdG4GeQ16nYyccRppI3PWt0NClFlwam+C/f/4PyxZdKHFuPbl89BokbIr3br2jMBe532hB0HLncgDiogV1tCxQAdZ7tCtfvnbyCTLk7Kpa1NWHpYMBf0+PbLgh92NsN9iZbfEyknJwca/8nFNCm8Eu0LPQ4pEyCSW/BHVb2WD81kF8mcSgu2ce/9t2SEmMunvWcb5M0zASY8kD6q7fvyDw953aFfTUzo8QLyG5zsxOr8i/iUVqNQttsJLjhfE9RcuKkZ7yosDonl7PrAzBo1TpX+ax/RNF8UN2RgmUWEKo18CIlfQcEXpWGP206GSbt8u9cdqbjan1aqnD1OZzt+zJnTAe5/5evjTa9hP4SGLQArtXJFqiqEplKV/++PAUTgghDFrQGfoWQgEsL2ixOLb8PI4su4D//vlfVFKqgCFLe6BxT8cSZ70Xh1K/lkLn8S1Rr01tLOu7hTlIM9usxMTtg7lY/RqoULkcXLvVw+W97ri0xx2WToKbgSIwr6uPjKQnvEiKO6XyQENHUManJSqmjBd74L1V8OT/p8iknNTFiiI7U9wxKP/FXVFKcKpcpRy0850YvgWI57poyQUEBCZy0tOKpV2hK3rN/y4gU/pxY5vCxkYbq9de46J56PB9mDSxOZwbfj2rqcKg7mhIUBJSknOwad0NTJ3ZpkS3066rHYsyE+OeYd+2uxgztaXc1zU2r4H6rqZ4eDsUu9Zex5KtfeXq9lnV1eMjwOspDmy4iakru8l1f/0nt8SEjhtw+4wPiz8Li1+kBVz0m9oaayceYe5oo4515A4Doc7e+A19Mc51KR5e9IX7mSdw7qRYalV+NOvXkKOft0w4yAXpq+evMXbTAF4n/y6gETu5pXx8/wm2TS3QaogQnSwPAu6Fsx8pjehrNxIaNoXxIvtVnnip8PSPzqnRImGevqlGgd8niqygtPQ+c0xTRap7ddH0kWydxHQkZdVK+PhRmAZ9T5zf+40SmFTm4EfHD9kZ5eSQm0LiSJNWgoAgJjwNsVHp3AVsLPodiWguH/Piy+36OhRYmE/tuMv/b93bERUKpdZcP+KB1PgsHg11GSV0DQqDiO+rR+5lnmgdVzO0E+WrKyJQmtl6BQ4tPseFqHPXetjtv4KLwm9RiOaHhp4K1t6Zzdwjuu/VQ3bi6h7h9fgaaNlf6O54XQsokWLVRGTTFKGgzY14VCgm18sLsc2XoklI9N4TfivBGDhDxK9S+cLxtvdjYcRmU1vnm44Zia6yZu01eDyKZiP6xQs7wUgBSsNfDaf6Rti5fQDMTDXx5u0HLFx8gYvTb5XcRF3i6XPaMS+dYkJvXlNMgCcGTXpGT2mRF3EcFiS/dyhh4LgmTB/x83yKxwokkg2cLNwnJTJFynmfRIVp0MqKi5Odiy/I3Vls3MUORtY6PAXauUCxoAwDS230mCSEkpBgNF3BjWdhEN9+wrZB/L7dOHAfs9quwsvsv0eGPRXKC7quY+Eq0amm7B6m0Lnh2gFBlNaoi71US6eAh4IAWKeWOp/v8oMcRijggLQSurU+F6NZabl4/fI9O59o1vy8GU2OF4pRTdGmWDy2r1qt/BfHHX8t/F7mt29y/MQPWowG+MWxjQR5l9WuK4wWbpwXuDEOLsZ5xeWTe5H8xaHxV0ORHQkh1CcOYb7xKPXbL7yjzw9SYh9dL6R99JzQnA3VJeH42qtMpidCPJm+K1IIxIcmYWz9eQhwD+OR9tS9wzHjwEhUrPbX8Wpo9D9lzzB0GC3Y02wcsx/up4TC/UtBkXM0TqMO8/0S2DwZWQkd7OjgJIVGZ9VFqVjZotGQvBDz1hSNdhSPY8l/VlGkJgkLtZrml424vUQegvZ1v9xGTBroPdi24w5u3Arhk/bc2e1gKXIv+DtDRbkS1q3piV49aSMKXL0WiBGjDyA27tt4klpaaaPvAGHCsH7NNcREyy+kyw8rW100aWXJPqrrllxW6HNJXamOfQTruu0rr+G9nJQBA1MNNBZxVLctuSi3wHHg9NZsqRfoGYMHIg6/LFBBNWppF/4s3bvghyd3FKMK9ZjUkj0z37x8h+WDdpZIQJgfzfs7Y96pCbwW05o8qt4chHkJ36vvBToPkQtK8MNINutfcGYiKivJ39HLSs7Bo6tC1GvLfoJITRKe3BaaOrYSlPZhIhGggXmNPNtEQqzYk1RPOS/F8N3bD8gU0WG0RN7NKSKRk/oXrnE/8c/AD1mM3r8tKK2JK0pdAFqM3EWdCEokEePKcaG4atrRtgBR/ozIpNq1g22B9AgC8ZhIBKOqXR3NRRnUhREflsLFKGHkyh4KRX0G3AvDhEaLkJH4DOp6Ktj4QOCFfg/QSWHYyl5oM8xVEGIN2ckJJV8DLqLxWUmK0RoGqrwbp7F5pgK+iVVEizXt5hWxlipVSvgaKapgfvOq5FF3iSLOlWahtC9FkJyUzSpuslGxq1eU7/W1cOSoJ86cFd7HqZNbwqGeZDHf3xH02gwa0IC5rSS2Skh4hpGjD+LiJf9vwhHs2ac+7Oz1mFs7f9ZpvHhRMpupYeOaoAo93rgsHNzprtB1ewxpiOoqFbkzdXSX/LzMgRObs7NDZFAybpz2kXsa0XWEwFXdseg8F4jywMBCK8/qidLtXosyzeUBjdGn7x7C4+cI3zjsmHkCX4q6La2x3n0e1Goqsxh1kuti7J9/Ch+/g1L6eUYuprdYDr87IVwgLzwzkUVXiuD8zjs89TJ3NISOFPoEiWa9RRsB+6ZFY0WDRZx90zoFhU1RIQKPlKhvYiQ+zcpLpaPmDyE5UeiUanzBGvcT/xz8kMWo1wNhtNC4ufAF8roXyWR/WoCt7IURb3pyDts5EVp0+8wrovG7123hC1jYV5SKi9PbBKuS3hNbSBxtUMdgw4RD3PUjGyfnjvJzlryu+GF2u9V4+/IdzByNsOH+fGjnG398D1BHd8SaPqjbyhqfPnzC4p4b8bqEJ9D8qN9W2BSEeEbjlYK3R6+7OJYuUYHuUsUqwiJIRYY4E/lb4uUL4T7Ei6+8oMcXLxJZ6eiVnHPpflfYlFnX1kGFCgVtyb4WLl8JwN79wrhvxPBGaNpEdhb23xE21jrYtX0g7OrU5EJx/cYbWLDoPF6VMLBAGqjbN2NuO/ZBTk/PxcK5Z0vkP0qfqXEzBIu4U4cfIcgvQSH/21HThVH26QMeiIkQFNGyQBvzPmOEBLq9a67lxT3KQpfhjZivnZP5EntXCLHK8qDP1NYsWHyW9gLbZgvce3lB4SNTdwzm9evKvnu4tOfLUrAIumY1sMVzcR596diKixhhP5uz4P8qBD+MwGiHOWzJRMX20otTYV5fMd59bvYrfk0InccIky9JCHgYide579gSr5YEJX2QZ0yeWC0/okSxs0bmnwWTRJEj6ObzKU0UKe5rfGMu+0/8PfBDFqOkmCf7CGMzjTz1KKFxK8s8To14Z2/toA/1fDuziwcecjFQx6UWauQjX/O/7b3PxudUCDl3kKw+vHbwAcK9n7LwadTKnnKP5ykFaWH3jVzwOZCA6PJU9uT8u3SPpu4Zzp1a6gpsnXjoi29TVVsJWkZqvKj7uwumy4pm1RNSRKbL8gocxPxPsvmSF+KOqKKG8WQFlT+jXl5kpOUyuZ86suKRlqJga7MbwoitUWPJ4oQvxb37EVi3QaCs9OpRD12+QCzydwB5ki5d3AUjhjXi1/7+g0gMGb4XwSGK8TJlgTYGi5Z1QdmyvyEoIBHrV18tURfWoaER29bRVZfPPYeXufJvsOq51GIxE33/1nBBLN+on6KS9U3UmRO4dZF8PFCaOo1d1oUvXz3qCX8RD1EeMdPkDX24gL971ht3zyjmTWzXxBz95wgWVtumHcPjG/LRBGTZT03bNwKzj4xBVdVKSI5Kw+x2qzC91XKEPpLveZVUqERCqilNl+JZ6nNoGqpxs4Ks+RTFyQ3X8f7NB+hbavFrJA1ir1fHllZF1r7UhGdIT8phXqiZiMMvbsaIOcXkNyvGU9GGp6bRZ6/jBNHara37sxgVY9myZahTpw4qVKgAZWVltG/fHpGRBbnd79+/x6hRo1CtWjWUL18enTp1QkZGQXeMxMREtGrVCmXLluXbmTJlCv744/sGOPyQxSjBuYkJF4Ivcl7D20PYwbmK/EZpREsmzoTmnT/7jVKBcvOUEBVamCtKnpbndgoinp4TWkgsTEiMQx53hH4z20NJTosN3zvB3HGkx+XcpS5mHx3zxXZNXxvlKpUVEeT/wx6kPreCvkpmff44OkUgjl2ldBBFQCc4Mflfkc0NIT8vShaou0a8ZQJ15BVBRKgw5tLVV8njXCmK0JBkVm6TMKB+QyN8bfj4xmHJsotcCLVpZYWBhb4v/1TQ57tLZztsWt8HGupVkJn5EhMmHcXBQw9LnOwjCdo6Spi9oKMgjLkWhEP7S2bUPnJSc+aBPst8iTVyFodijJ7ZCpWqlEVcVAYObXOTe0M3YUlnLkI8boXi3lX5CjzqnpEYlLB26nG8knPsXstWl7n5hE3TjyMpRjGebddxzdG0pyML7JYO3IlQkU3Rl8Kpox12+a9Ap3EtmDJEBvkTGy/CBJeFcDvhqdD6IqsIPbbyIoeRXNx+i99fCjjZ7LEQmgaKCwTTE7JwUXQe6zuzvdRmCU0BH4reWxcJjRdv0dTFpLZuAa/nhOgM3qjQpj9/4RkVJvBIDUyE0T1NA5JEnVEd0ZTrJ4B79+5xoenl5YVbt27h06dPaNq0Kd68+Tw9nDBhAi5duoRTp07x36empqJjx455//7nn39yIfrx40c8evQIBw4cwP79+zF37tzv+hL/sMWo2Fv0/s1Q3v3Tl6CGqMtE43lKE6H4srqNP1sD3T3nw0VnDT1lWNcvuOO8eughd0VpbNRANGIujIPLLrDHna6pJnveyYMo31gs7LaBx/pkXk9iJWnmw98bJnUN0G6kEOm5fcqREkV65odFfaFIKskJorrIOJlGeIqglKi4+/RR/sf+TmQ/oojBfoYom5mKX0XH9KEBifx/k3xjLkVx+aJ/nsdlWVEs6ddCeHgq5s4/y2b+DRsYY+yYpn9rQ/CSgJwAtm/tD9fGplzI7D/4EBOnHEVGpmLit+JA3NExE4Qx6cF9D3BF5HesCIjDOWtJJ1bZU/TxqcOecl+XEujGiEzsT+17iECRubks1DRWQ4/hwvq2ZeGFvBxyecRMlF9O39mNM07JXTh3H9ecPUvfv/2IRYP34K0CkcX0uRy7rjc7mlCBOKfbRkT6fZ30LTLDH7q8J/YErUTzAc5MHyJh0/L+W9FdZzRWDtqOB2efKKy+f//mPVO2Vg7cjp41x2D/vFMc3axjqollV6Zh4vYhbG5fEuyYdZK5oNYNa/FrIg0kHKPXi6aAtCEoDC8xl7TQ1CVQ5N5hYq2ddx4jzUasKPXOUGQBlRCbyZs74tOTrdPfBd87gen69evo378/TE1NYWlpyUUkdTl9fYXmWW5uLvbs2YO1a9eiUaNGqF27Nvbt28dFJxWwhJs3byIsLAyHDx+GlZUVWrRogUWLFmHLli1coH4v/H0M0f5CqGpUgZ4o+lAsXHLJp5a/fUFQ1jdqY5XXeaKF8bIo2rN1H8cCJ1dOP9oldA66jm4isStKnqJXRTyc4cu6y1VQZiY+w7zOa3lkYt3IFFP3jfjbFqJi9JndkTujSZGpuHX4AStNSwpSvBISI9NYjEQJTfKCeEyEF6JRuLz4P9H7qkgHSdzFKRwHWxxSEkQJJFpVFS7UgkTxe+YKpETlx/Pnb3BP1Llo007yxqmkiIvLwoxZJ9kCqbaNDmZMa/2X5t3/lShXrjRmTm+DOra6WL/xJoKDkzlKdOL4FnBuqLg/riS0aVcbWZkvcfTQI2xYc40toJwUvG0DYzWMmNQcG5dfwd4td6BvpAobO8nRjoVRv7EJmnWwwY1zflgx8wy2nhiRF5NcHLoNdYH3/UgWM62aegLL9w+WuXbRZm7q+t6Y1Hkjp9tdOfIor1taHOjzNW1rf4xpvpKjQleNOYg5ewbLbWNEgqZZ+4djTteNCH4UhZkd12HRyXEwkWDiXhKo6ihjwtZB6DunE1vg3Tx4n+lMd4568EHQNFCFrrkWNPRVUV2jCipUKc+BKdQoIQsr8vtMfZqO2KBExAYncnNCDF3zGhzrTPZ+X/JdI+9Vz6sB/D4NW9JN6rpEa+OVA0KnvmXvgudCwsvnbxDkJYiX6onimcXwF/FIyZdWjOiwVPYgpvx5Ojfz78JFEcVGqn+rjWzHXltR6teSFfrS8McnYfNEfqP5Ubp0aT6KAxWfhKpVhSkrFaXULXV1/WwpaWxsDC0tLXh6eqJu3br8f3Nzc6iofKYZNmvWDCNGjEBoaCisreVPbvua+HeeJWTAwcmQP+DUnQoLTOLLDZsJXxrqbnqKcs1d8ynrQ57EIjE6g8cLjQuNJdzP+yI7PZeTQRp1+jzWz489omhQx9Y2sBR1/GRac3Rdz4sQEePnHBsnd/Td9x7Xd5ssGHafWH35i0aXZGZdTa2yINgJE8yT5QV1tQmKqGwJf4osaWg8Ki/E43ZxEpM8SBAJkMTdeHmR8+w1J4cRLGqXrBi9fMGPx2BGxmow+ooRoJRUNHXGCbx89R61jNWxcH7HEtMI/klo4mrGnqTGxmp4/Zo8Sc9j5eorHHv6NTBgsDNatLbi9WPJgnN48lixZDFCqw42aNraUriNmWfybHPkwYipLaFVU4kFSStmnJbrO02j6amrunOBGeIbj0Obb8t1X8QjHDC1dZ66PjIgQW4njNm7BuPX0qXgdTMY+5ZehCIoU7Y0Fh4fA7N6Bqzon9lpHfzchPPA1wKtZbRZPxCxFmtuz0bHMc2hJRKgJkenc5f0+MqL2DzuAIeKUNwoGdaTS8neOSc4ejTKL44LURXt6mg3ogkr+Lc9XsKOKl9SiD7PfIlNk4/w5S7jmklV0Iu9RSlZiSzpXLvYF/n3RzeCuYimEAN17eoFqElBT0S+xo6fHTWCReI6MxvtvMIzQjS2N8pnlv9vR40aNVCpUqW8g/ihxYH4t+PHj4ejoyPMzIT6JT09Hb/99hsqVy7o0EOFJ/2b+G/yF6Lifxf/2/fCv/9MIQH1RBy5B7dC8r4E1UQWTQ9uBPOXXddItYD1xHWRzZNzG2smqYtBhdLZHYKCvt0gYRRTGEEekfC+Fcw7zgFzZWc+021uHL0PTwMTOFWJrDny3+ffHa2HNMKxFReQ+jQD3tcDODqvpNA2Vkd22gskRKTCxF5+L8yyJUxFoi43QZHCX+xLKv4MyQPi4RF08qlH5YG3qLNA3S5KTVIU1LG8ILJZ6tTV/qt1HbKzX2PytOP8fx2d6li2pAt+L4F/6j8VxB/duK43Dhx8iKPHPXH9RjCCgpMwa3pb1PrCgp/eo/GTWuDNmw+47xbOlk9LVnRjFwRFbmPstFZs9RQZmoq5k45j/e4BnD4nC0QlmbmyG8b13sHZ9Qe33MGAsYJqvjiQ8HPcwo5YPukYTuxwh7GlFuq6yE6x6ji4IUJ9YuF5MwSLRx7AhgvjUVUOj0xjGx1MWNMLK0cfYFcTJY0qaDtAukdmYdBoe/HJcVjQewv874VjbveNnNjk2l2yRV9JQR1bckOhYxh1t5694iIzISwZaXGZyE59zo4kFIrxn//7D8pW+B2VlStCRVuJ3VOM69Tky1/ru0ubi5XDdvPjoCK052RhMyANp7YIMdhNu9dln+zCuHNOWF8athY0GGKEeMcxlaJK9Qp8fhUjyFugRZjZfP48hwcLzQcjUVHs6x0L/4Cvw+f9Epw9MvIbJTDNQ1JSUoHbltUVJe5oSEgIHj58iH8DfsjOqL4o+eXBLYHXIu6KEtwuC6TsRm0/t6rJ5ofGRoRm3eoW2SXGR6Rxx7RFLweJheWBJef5cou+TtDU//wllIabhx7wqJtiImcdHgNlkRjnn4Iy5cpwVB7h2j7FPA4Lg8ZXhDSRr6a8EAu8FDWiJ0oEQayqlwX6bLx9LVxHSQFuE42mCPq1FBMZeIpScezrl8yr89rlALx48RaqqpXQUIJRdUmQ+/Idpk4/wZ1RNbXKWLmsG4+TfzSQZ/GggQ2xdnVPKCtVRGrqC4wZf+iriJuo6zVjdjvUczDgDtPs6Sfg76tYwhgJ7Oav6obqyhVYHLJw2im5baN09JUxfl47vnxi7wPcFzkxyELDlhZo00sw0adxfXKc7O8xFVmTVveEZk1l5o8uGrYPH+Tk1ZGYpq+os7p9zhm4iQojeUG+nAuOj0HDDnW4KbF65D7sXXj2q4rTCqNS9Qqo09SCo5bHbOiP+acmYPWt2ayGp87n0ktT2a2k39xOLGClsf/XHF3T+YmK79Jlf8OM3UOL3YiHUVH4IJIFap2GFU0NJOtDmiLS43MpRAESTxztnY3zKBT0WRZz4K3sBO4p2SwSZzQ/L55s6A7vK5mI75+SwFSxYsUCR3HF6OjRo3H58mW4ublBU/OzdkBVVZV5ny9eFORpk5qe/k38N4XV9eKfxX/zPfBDFqP0RaG0h8iQFL7s0Eg4KWelvUCIT5wwtm9pmff37hf9uKjRMVKFkVVB8+BLIg9FGleULxQLSqBRDwlwaHzUfaLsnOjk6DRsmXCAL/eb1wmWDb5dHva3RPP+QjHqczOIFZ8lhYqmYKuliHk94f9+ERZrRURURKQXF6/ydqLJvoRQuVp5uQVMuc/fIEVk6KzIGIriRn1FXCxHZ8U5ifTcjh95xJe793LgE8qXgkbRxBGNi89Ctarl2Ry+eqFYwB8NlhZa2L1zIBq5mOSJm8ZNPIIUUbxhSUEipDkLO8Kurh4+fPgDs6adgI9o7CkvqlWvgEVre7CwKdA3HqsXXuDHKA+IV9+pr7DhXj33LK+f8mDI1JYwra3Dm7b5Iw4wFUoWylUog/m7BzEPO8I/AWsnH5c71an72KZo099JCOIYdwgeokaCvKBibNquweg2QYg4Pbn+GuZ03aAw//yfgBuHH/LzI4xf35cnUdJAr+e+5Zf4cpOu9lCpUdSM/sbJx/x/GydDKKl/Tk6iYp7cFQj1XD+LgkP9E9iNpEr18tAWqeZDAhLZhYNcIKpWF/jJ4aLN+4+O//3vf1yInjt3Dnfv3oWubkHxGAmWfv31V9y5I0xrCWT9RCKnevWETSH9Pzg4GJmZn5PkSJlPBbCJyef35q/GD1mMEh7dFeyCzGy0UFV08rwnEjPRwpm/y3VHNNZs0tmuwI40MyUHj28G8+U2Eqxr6INzZJVg4tyqf0NUz/fllAT6wq4evBMf3n6ElbMJuk4qflzyd4aWsQarO6m7QKP6kqKqmvA+5CgY0QnR+fU/CmQxv3j2Oo/vRidDeZAo2sGL85TlQZioE0A8PHH0rLxdUSpCKB6vpoLjfcLFC748RldSroim+QR7JcWHD58wa85pRESkcSd01cruUBe5GPzoKF++DGbNaMMCp3JlSyMsLIU9SS9fDfii5Cbi4M5f3Bl1HfS5qzRnxkk8ktOXUwwSb85Z3oW7rW43QrBj/U25H9PAcU1Rp74Bb2zmjzuSlx9eHIi6NHtDLyirVUZKQjYWjT3Mj10WNHSVMHt7f/4+3r8SgF1LLsr1OGmNHr6oMxp3tmPu4rLhe+EhiraUF9S5GzCnIxelxI2kpsKohgsR+CAC/xY8uOCLDeMP8uXuk1rCpXNR/md+EBc3xCuGhVVkX1gY1L2+fkIoRlv0EAofMajJ8/zZK5SvWAbW9T7TrZ6IAmhsHQzyzq20SSJY2gic+Fev3iFBwcnYvxWjRo1iFfzRo0fZa5Q4nnS8eyd4CBPXdNCgQZg4cSJ3TUnQNGDAAC5ASbxEICsoKjr79OmDwMBA3LhxA7Nnz+bblkUN+Jb4YYtRD1Ex6tjo807gwfXgvNGSGClxWbwzp5G5c6Gxw/WjntxVIFsRLdE4OT9CvaIR9jiGF+MuYwUvvOJwfvMNTs6gLOFJO4fKrQb9u8K+hcAZ8rktvK4lQcUqws5Y0e6qmPspicMrDdkiWx7ip8k7BosXcT+19OUvDgOeCBwpcwU4f4TbYueHZmYKj+mIb3jskNAV7dO//hcLi2i8O2/BOQQGJXGxRaN5nXxihZ8QiiKyftq1cyCsLLWYr7t23XUu4HNyhI1PSUDv3bxFnVG/gRG/D/PnnMadm/KNzcWwrauHyaKx+7njj3FIzthPpgus6Iqahqp4nv0as0cd4k6/LNDkYP72fjw9CPaOw9oZp+TqdFrWM8CEld358vm993F8i3xCKFo7J6zpyeEjf/7xXywdvk9hU3yCSyd7rL81gyOGibs+rd0abJ9xPI/O80+F25nHWDZ4J5+/mvWuz77XxeH9u4/YMe8MX+4w2LlA11OMu+d8OUpZWb0K6roWtHRyuyRsBhybmOWtybSx8HIXinv7fF7HfqJuv5UoRjQ0OJk7pWoipf2PjG3btrGC3tnZGWpqannHiROfI23XrVuH1q1bs9l9gwYNePR+9qzgb0745ZdfeMRP/6citXfv3ujbty8WLlyI74l/drVTQrx88ZbHA4S6onFnRspzRAUnC2P7fF8ktwuCf5dNfcMCJHrqYt4UiZpaSLEfoSQLQpOeDqykLA4ZCc9wYKEQaUfedMoSRiD/NFi5CK9jyMOCCRGKQOyXR/YmioD8YBXhfhIyRV0eJXX5u3tPw1PzvBXlhZ/IN9VaFD0rD8i03E/k0edagq7mscOPkJv7Flpa1dCs+WcKSklANiyLllzAE+9YNs1fuqQzDEVWaT9RFKoqlbB6ZQ8MH+rCo3avx08xcPBuuN+L+LKR/fyOcG1mjv/++T8sW3wBZ04KgRzyguKQyRSfcHj3fZw4INgMyUJZyjvf1JunR8nxzzB3zGG8laM40zVU5Q4p0UPuXQ3CjmWX5ep0NmpfG0NnC4XzwTXXcG6PnIVzqV84ocm1i9AhXTX2YJ4FnyLQNdHEpruz0aKfMP06v+MOhtefD5/bim0A/g6g1/v0phtYOXQPvyau3eth7Lo+Mje3R9ddQ0ZSDheh3cYWjQil8+HZ3cL70m6AUwEbLxIt3Rc1evJrMUjEmZb8nLnMtg76eescuYXQwxHbjwWKJklmZiX3Vf634H//+5/Eg7xHxShTpgx7hubk5LAZPhWihbmg2trauHr1Kt6+fYusrCysXr0apUp9Xz37D1mM+j1+yjtCXUOVPF+zR6K8eRrRVxV5VNKbfE+0o3MuZGTv6x6O7PQXbCFUr3nR4iApKg1Pbgbzl7zzaOn5vmLsmHqEx/OksKQEjX8DjGwFL7mMxGes1CwJiGtL+EOOsV5+iC2dyleSX0iTKkr8UM0X/1ocqLMTFSKoPg3lNKBPS85BUtwz7rRbyen1SLh+0Z8/s+bWWtCQ8/Hl3WfqC5w5JYzPBg9v9EVcUTrpLF95BQ89orggWrSgE8zNapT49n4UkFVY1y722L6lP/T1Vdj+iiygqKgnAVhJQO/j1Blt0FGUErdt8y3s2HpHbg4ooX03OwwYKQhR9my5g5Oi7rksUGrYkq19UaHS78wdXTD+aF4SWXEgS59JoujPi4c9cWijoMyWhQ6DGqLXOCFQY+fiCzi3V/5O7oS1vdBukMBh3zn/LHf4FBUkkbBp3Lo+WHRiLCfnpSc8w+yuG1h5nyqi6vzdQd3clcP3YPe803xuazvEBRM395dpCRXuG4cz2wQO4khyyZDAjb9/2R/JsZm83jbvXlDkSylc1BwgdwVzUbeTryPq5tOIXpx89+RRTB6XvpIoDMTfVzRJsiio1/iJfxd+yGLU1yOa/2/v9Hk08Oi2oPRzFCUzEUglT18wGisUNu+9Izq5u3S0lag+vLBLiFSzb24BdVFOujQE3AuDx0UfLlDGbOj3jx/Pi0EiIFUdwUczIVwxn1AxxDt2RVl2YrFBZQXENEkxwsidVLxy/X1sFl7nvkPpMr9y10ceeLoJ3TBzG225TfKpE3nlnBDE0KpDbSiK7VtucaIUWQHVy+fvpyioyFm99hruuoVxNvv8uR3Y2P4n5IeurhK2bOyL3r0cuEB1cw/nLqnHI2FNUhR0GyPGNMHAoUK4xKnjXli68LxCLhI9+tdHnyFCsbZ7020ck1O1TJznxVv6cqc00DsOCyceYxGgLLi0tsJIUbLTse1uOLZNWCtlode4Zug2sjFf3rnoAk5u/yzSKA60ng5b0AkDZgr3eX63OxYO2Ml+ooqiThNz7Hi0AB1GuPJ6TSbxQ+rOxebJRzgT/u+KCJ9YjHJZBLdTj/lxD1/aDSOW95B5rqHXiDrK9N2nc13dpkWz6kkXcGT9Tb7ccbAzyuZLf2KD/OPCubJ5lzp56zlt5N1F3dIG+dxs8txCROsUBXTERAvrsqX19y9G3737+E2On/hBfUYDRONOOyfDvMSIMD+BNF0vX/znA1H2rq2zcYEvGH1BPUXCJUmmv/Tvt48LsXvthwmLpzTQl3LXjGN8udVgF+iY/ru6TJQokh6fhbTYTFg4Ke4MIFbDK5o8JY4Braosv91SXISQ+qEjZ2EZLOI2GVtpschCHojtxMQODvLg/u0wZGe9QpWq5VBfgesRHnvGwONBFHc/Ro0teSwnnYzWbbiOGzeDuQCaPbMt6tWV3/f1a4JOcNk5rxGfmI2U1OdIz3yJZ9mv8SL3LV6/+cDcTCrg6e/Ip/G3X0uhLMWuViiDypXLsupfRbkiNNQqo4ZGVVStUu4vTXmhjvLA/g3gUM8AK1ZeRkJiNubMO4MmrqYYNcJVYVsseuw9eztCSaki1qy4zDY4lNq0YGlnVK4snxctFaP0Wh3c4Y5929z4New/3EXm62JkpoGFm3ph1shD8H0UwwXpnDU9eINWHMjuiTqpe1Zfw8GNQqZ6T1GhWdzz7De5JRdTxzbdwr4VV3gzOGBqK5mPk/6966gmUK1RDWsmHMaTO6EY12o15uweDG2R1Z8iHsaUUNS8jxN2zz0F79shuLzXHTeOPOSc+06jmspsQPxVIK79oeUXcGm3O7/GRBebvmsIzB0KxllLAv39uklHkRb/DMoaVTBysdDRLgzy4E6Jz0LFquXQrr9TgX8L8YlHdGgKj+KbdvocFhPqn8jiN9rI1BXxRd+8/pBHRXIQ0ee8RQEP+gYqqCJH8te3Rpfum1Gq1FdOYPpDMQravxU/ZDFKH/rKVSrDSDRa9XkYxSdbKkJU8pGkxd6i9VsU5NiRVQgZEhOpXU8Cj8X9zGMeiWgZqsHSqXgLHo8Lvojxj2duZO9ZHfFvg5KmEFOWnVayrkGe76eCBuoZIusklRrC/csCKUETRZ1RPTntlvw9hYXSUs5xOy2+4UFC4hfFLMrN8ToibGzadKmjkPCIdtwb1wm85Y5d7KCjYNpT/sewcfNNXLkayIXojGlt0EDG5/prglT7oeGpCAxJQlhkGiKj00s82pYEKlL1dJVhQDnbhmowM9Fgn9BvDWMjNezYNgD7DzzAydNPcOt2KHz94jFhXDM4ylEsFEaTZuZQUqqAebNPIzQkGaOH7sOi5V2hK2dh1HtQA/z26y/YvfkOju17yOskcUplpZGRWTlxSIk76uMRg3njjmD++p4yv7OdBzXgzfi+tTdwaNNtLk77T2hWbGFJ/9Z3Ygv8XrY09q64jFPb7/IUZOzSrnJtCBu0tYGaTnUsHLgLKbGZXJCOXtZVYlNBFsgGiWJDAx9G4uDS82zhd2XfPVzdfx92zSzQsn8D2DYy/S4RzhT2cXH3XeaHvhZZaTXuVpejqCvIuUE5tv4GuxDQ6zpj+0CJ1oWvXrzBIdEa02ts0wJNG8LpvYL1YeN2NqiUzyD/xnlh0uPU1DTvc+L5IJIFeZra1aBTU1irvEQhH/b5FPg/8e/ED1mMEmzq6uVxZbzviUYD+bwbaTyf9DSTv4j2+RT3hHsiUZNL+9oSF87rh4REhOZ9nYpdWGkhPrxEULl1GNMclf+CE+BfjYrVhDH5y+ySqYfFnoQUM6oIkmMFKxB1EU1AFqKDk5nQT+kg1eWwJyK1vjhn2UZOA/o7V4TNjWUdHbnTmshXNCYynTtNbfJ1FuTB/j33kJGeC2WViug7oGDHQpFCdNOWW7h4yZ9FBVMnt0LjQt+Hb4HMZ6/g4RmNR0+eIiA4qYgVEBVI3NnUrMoCIaVqFVCp0u+oUL4Md0F/pQLgP0JHl6779t1HvHr1Hjkv3rC9FXVTqaualpHL/E3/oEQ+xFBVrggrCy3YWGrD1lqbu6nfArS5GDrEBfUdDbFy9VUkJlGX9Cx7lI4e6cqdXEVgZaODTdv6Y/b0k0hNeY6xIw5gxpx2cKgvX3Hbta8jd6s2rbyKi6e8WSk/ZX57mZsgyzq6WLylDxekNHmaOfwAFmzqLTPhqesQZ15jd624ipO77nGIxMg57WTyGLsMb4SKVcpi46zTuHXaG8/ScjFzaz+5qC8GFlrYdH0qVozaz6Ela8Yfht/9CO78SSq4ZIHinVdfmcq59qc23uC0vcfXA/moqloJzh3t0KC9LQxtdL45BYu0CtcOPmD/UDENgVKVqJNr3VD+qcqd009waPWVPJ4opVtJwv5VV3myqG2oilaFQl9iI9LwxD2Cz4Ed+9fP+/2r3Ld5fNHm+WhHZDNGcG5iytchqom3OOPeoeT0oq+JU8dHf5sEJtUF+NHx4xaj9QRxDRHZfUU+fbaisT3hsSgtwtxOr4ABOo09Aj2i8nbZhREXlozogAReYGknWhweXw1AfGgyWzlRTvG/EZTqQfhQQl7Mc5HdUmWRqEweUJGfGCWM3LXkHLmH+QgkeRNbHblGtmRPQ6R8Mms2kKOTSo/p1gV/vuyaT1EqqxA8vOd+Xra4mNAvD8gO5ewpQV1NUZIlieak+9+89TbOX/DjQnTKpJZo2qQgd/prgrqdd+9H4LZbGELCCxqqV69WHpZmNWBuogFjQzXU1FVC6a+Qe//h4x9ISHyGmNgsRMWkIywiFTGxmVysXr8dwgfBUF8F9ez0UL+uPgz0VL76WN/ERIPz7ckg/+Spx8zL9fGNw5hRTdDIpZZC96elXR2btvfHorlnEeCfgLkzT/FmpHc/J5ldTkLrTrZc1K2cdw73bochJ/s1JzfJKizJqmzp9n6YM+oQwgKTMGXgHhY5ydp4dezvxNnwm+efx9UTT/Ai+w2mruomc9RPaXhVlCti2eiD8PeIwoQOGzBv10C5ON/EJV98dBRObLyJI+uuwe2sD4I9Y1jsZNNA8a4/vT8WjkZ8JEWn4+r+e7hzwgs56bk4u/UWH1VUKqGOqxmsnWvBrK4BC6G+FLSuxIUmM1XA45Ifn3vEoMldt4mCf6giufWeN4KwdqKQU99xWCO06CXZLSbIKwZXjwpTm1ELOxXpAB/eLNhwNWhhDs18U5nr54QQGT1jNRiLppPZz17BVzSSb9RM4KV6P3nK0x3q9hsaq+P16+8fOkDr6NeOOf706ceJTS4OP2wxam0vFKMxoSl4lfuOTc5r5UtX8nYTRZcVGqc+vh3CvnU6tdShIWHRu3tSsHuiMU0lUVdQGk6vv8r/bzW4kcSM338DiN9FUEThmx9ZouQlypmWF8RxokKRlPiaolQPWQgQCUho8yEPHop29nUbmcjV7fDzespj+nLly8g9ovfxeoqwoGTmW3XpI38+Ni3gK5ddYm++ps0tYFcCbqcwmr+FCxeFQnTyxBZo3uzLjfIl3Y9/YCIuXA3AQ69o/PGHoHKm+zSrpQEHe30uAnW0qn0TXicVtIb6qny0FIkzqIsaEpYCv8AE+AUkIDImA1Gi48DRR1BRqogGjoZo1MAYtYzUvtrj4i7pYGc0dDLCqjVXERuXhSXLLuL2nVAe3SvL2U0nVKpUFsvX9MC2zbdx4awPDu57gKjINEyf1Q7l5Qh0oO4UdZoXTDuFYP9EjB+8D4vX9ZDp9VjLogZW7hnI/qPxMZkY33cXFm3uw3GixaFlVzsudldOPcHOJjMG7MbcLX1QWUZH2s7FBKtPjcH8wXt4mjW+/XpMXturiM+lJFCB1nNCc1jT6z3uIK8bs3ps4XShwXM6MAeyJKAikDqRA+Z25C7p/fM+eHIzCM8zcnHziAcfBOJv6ltocedSQ08FqtrVUVWlEp83fi9fGqV+LZXXMCG60suc1+zgQhSkxMhUPA1KQoRvbN4YXrzeUsHbckBD/r+inVgayy8bsY+nRI071cEgkaVWYbx59R7rph7nyy161IW56HwqRrh/Asd/0uan16jGBcROF0WCpnbd7fO+O7euBLJFmYmFJo/pCffcBC9wJ+dacm2ifuKfjR+yGCVeqIrIS1I8arWwq5m3s6MvWoi3QKSu41KryK6R4CDBzomtoM4KxsqNZKRZxATEI8SDMn5/QfuRgmXJvxFiS6ZffysZbypVlGWtqi0/3zFS1B2oaaIpF1+LDJ1DRe+3lRzjTFpQPUTFqJNoFy8Ll0QLsGsbK7n4r1S879sqqIxpPE8xjvJi57Y7SEnOQXWlChgxxlXu6+W/701UiF76XIi2+EJv0sIggcyNOyE4fdEXiaJIVQLxNps2MuVCr7qMzdy3Ao357Wrr8kF4/uINvLxj4fE4Bt6+8cjIeolT5334IIqAq3MtfszaX8kb2MhIDdu29Mex4544cswTj588xYDBuzF4YEO0bWMtd5erVKlfMGZ8MxgaqWL9mmvwehSDEUP2YO7CTjCQY2JgbVcTa3f2x+wJxzjLfuyAPZzcZCFKxpEGMsRfu38wF6TkQzqp/27MWt2NqVHFwam5OSpVLYdFYw4hPCAR47tuxfytfWUKCvVMNLDhwngsGXmAJxwLhuxh1X2fCc3l+v7XstXF1lvTsXfpRVze/wC3Tj7G41shGDirHZp0sy/xaJ1cVhxb2/BBLgMhj6LhezcUQR6ReBqUyCb6dDwWnVMKgwo1+v7J2siT7ZSFoyHsm1vCsZV1ieleVw97YMuME3x/DdvZcJdY0nOn89y2eWc5CpmETYNmtC3y77tWCo0W1/a1USNf08btWhCy0nNRpVp5OLcQ1k66v+uiqVFz0dSIoo/FyWKN5Ny8/8Q/Gz9kMWqWzyIiQMRJyR9RFuQZw91PdZ3qBTiHtKD4iYyqJVlckH0GZajTrpYsQIrDlT2C+XL99rao/hXGNX9XvMkVeEtlKyimEBYjMUIwlScxmLwIFancTWwL5vZKQ4BHNI+NKDlEniQlnweRHJxAI3oLO9n3QSfyx/ej+OTSprudXI/p7o1g5ooSf697Pr6VLHh5RuOSSBwwZXprVFDwdRer5kmsJB7Nf82O6MtX73D2oh/OXvLLEyH9/vuvXMy1bWEF/b+JCjk/qlQuhxZNzPkgMdUT33i4PYjAo8cxSM/IxeETXnwYGajy37g2rIUKcsbJFqe479unPho0MMaatdcQGpbC3F3qkk6c0Bx6CrxOzVpYomZNZSyYc4Y9Z8eO3I+RY5qgdVsbmV1dip3dtG8Q5k46juiINEwffQijprSQaTFG/s1UkM4ff5Tjb6kwHTmtJVp3Lf7zT02BtcdGYO7wA1zsTOyxDZOWdy1guScJFEiy/MgIjgy9dPAhTmy9g5AnsZi6vjcXTLJANAHijDq3q41N04+zrd/6yUdx5eAD7pJafCFnkQpTGxcTPgjU6YwJTkRscBISIlJZTJWVnM2xx+9eC6JNwdA8322U+ZVpCRSIQt1XXVNNGFrrQM+8Rl4XtSQgx5K9Sy7g7E7hnNSsRz2MWdFd6qbn2jEv3Dnnw93KKet6FYlOvnvRnzcTFDjSd1yTz/fz539xYq9gG9ahd708S0QfzxikJgvK+oai9/n+vXDesGpoVIFRLfUSP7ef+OfghyxGTUTjeBI20DiBYJEvDSfgkbAjsy7UJQt9/JTTJKqqVIS+eVELpkdXhN2dXVMLzjOWhvdvP8D9pMC1aTnIBf9mvMjjfCq+W6fXKTkmnS/TKEteBInePzMZnRgxHolsuoiSIc/I9eZZkYCttZVcnZczomQbirzTlCMyk8bse7cIXdHu/R3l5oo+e/YKq5ZezlPP164jv6m++GRBPqJi+yYSK30tjigVnifOeuPcJT8egxPUVCuhc9vaaNHUnCNF/wkoXfpXODkY8EEnSypIb7qF4YlvHKv86di62w0NHAzQurklrMxrfNEYnyJWN6zrjUtX/LFrtzvCI1IxfOR+dOlUB316O8rNXzOgbuueQVix5CJ3SDesuY4AvwRMmNIS5QspoAujmlIFrNnZH2sWXmAO6YZlVxATkY4Rk5oVK2yqWLkslu/oh3ULLsDtahA2L72MuOgMDJ/aAr8WUzxRJ23DiZFYOuEoAh/HYvHYw+g2zBl9xjQptitMftAjF3SEaR1dbJhxEqE+cRjVcjVGLeqEhm2s5XofTOrUxKbr03Bx7z0cXnsN0UFJmNZlI+o0MkHfaa2h/5UCHqibSbxROiSJI2ntI8eW//33fyj12y/4vVwZph19baoKWeCtHHOA+bKEXhNb8CHtfmhiuG2+ILrtN6UlzAqtMSRmEndFewx3KcAXpq4odcopKKFVFyGogXDmmEBta97WKu/zfE0k9mzW0pIfC4kNP3z4TEf4iX8f/h3u6grCxFJYUCj+kzpiNBrSysctDBR9Ma0K7YZJcUkggrukL+vj66IRfsviBSpel/3w9uU7qGhXh0UDxb03/0mgmFOCkqbiI8yYwATu1JEiVVacat79Jecg+Wkmc6cs6snuZtDCL/aMdZQjZvNZRi4ei/KUm3aUrW6nkdRtUYpXl36ShQCFQbGMFIunolYJHbrJZznD+dsLz3Pkp56BCgYPU2yTQ76cy1dezitEZ0xr/VUK0TdvP2Df4YfoPmAHjpz04kJUT1cJ86a1weFdQ9C5ve0/phAtDIpCbdSwFpbP74Qzh0Zg9NBG0NWuzpvc2+7hGD/9OPoO24OT57y5I1xS0PvRro0N9u0ZAqf6hrxpOH7yMQYO2Q1PUbSsPKAu+cKlXTFsZGMu6oiTN3zQHoSJUsRkPdeZSzphwAjyHgWunPPF5OEHkJkubDalgbpfU+l6Y115zbxyyhvTBu9DdubLYq9HyXaLdw1EOxFX+sQOd8wavBc5WbJFLA1bW2Pz5UkwstJidf6KcYdZ5CQOwpAFEp+ScGevx1y06luf1xLvu2EY02wlFg7alUcD+lagoprsl4g/SusecUipK/o1C1Hqurqd88EI12VciFKq0swdA9F7Ukup95MSl4VFw/YxTYnsDrsME5K78mPn8ivIzXkDbX0VdOj3eaJD34lDItpR536OzJ0nPI1Kh/+TOOEzLuqaJ8RnISQoCf/3y3/QVLQm79l7DwMG7fpqz/8n/n74IYtRZVFhIza6N6v9WUH9Ivs1EqKEblxhUjbZgBCsJagt0xOfsYKbFq7ajYsfKd07LUpv6kYpLP/et4AWvKQoYcyuLsf4uzCCRaIikzp6ci/Ej28JhWWt2jpy2bT4uEewcXZV5Yowk0O8RGpfIvfTZ0bbQPZzOrHnPhd6pDQ2tS6ea0dISczGKVEk49BxTWUqisU4sO8egmg09vuvmDO/g0J+pHSiWLj4Au7cDeMiZe7sdmjcSLYApDiQX+Dp8z7oMXAn9h99xEUojeCXzOmAPZv7cxFXSgGF798dNMrv0t4W+7YOwPb1fdCmhSXTDxKTc7Bllxs69dmGFeuvcee0pFCqXgEL5nXE4oWdWMyUkfESs+acxtz5Z5EhmkDIAp30u3Svi/Vb+kJVrTLS015g/JiDOLT/AW9oigN9B3sMcMKidT1QoWIZRISkYGSfnXgiIz2KrtdtYAPM39CTixBS2o/qvg0BIjpNcUXh8JltMG11Nx75Bno9xagOG/PcT4qDunZ1rD45Br3HN+PYVAowGdZ0Je6c9eF1SR6Q4n70sm7Y6T4Lzh1s+Xl4Xg/C+FarMb3LRnjdDFY4VvTvgOSYDMztsw0rRx9g8ZOBRQ1svDYVTq2lN1Gy0l5gZp/t3Pmkv5+0pkeRNZl49Hcu+vNnbNzCDlxUi3HhqBcyUl9wl71dj88uM+RnS3BqbJInjjt/1ifPzql69Qp4+fIdJ5TJ+bb9xD8U/56zgQIQf4mI10IwyUfID/URFkjyTauUT8lJfpdPRR0EK8eiIhe/u4L63ti2ZrFFEFkc+d4WxaB1lI8/+E9FVlI2L3Y0yq6hAOdTjID7gprSQgGD9Uei1Ky6cvIcb50W7I+c29rIFIaQKbc42q5tb9nqdlLPk40Joc8IF/kU7CuuciFnW1cP9V3ke96eHlE4KipgJ01tBU0FhDQ0aqZiRpw1v3B+xy8ytKfncN8jCv2G78GmnXd5PK9VoyoWzGyHXRv7oX49g7807eivBj03Ms6fPKYZzh4aiUmjm3IRTgX/1ZvBGDruIEZOOoy798J5k1ISUHLTvt2D0a2rYNlD792AQbtx7LgXf3bkQS0TDWzfMwiNXE1ZxXxg730uSkn4Jgt2DgbYfGAIDIzV8DL3HWaPP8YxorKej30DI2w6Ogy6hip4kfMGM4YdwKFtd2UWdM6trLDx1CgWMlGzYPaQfdi+9JLM6FEqZilCdP258dClx/r8DVZPOspFFU1P5AW5pkzb3A/b3WaicWc7Lm4DH0VjwYCdGOS4ACc332Su598d2em52DrrJIY3Xgoft3CU+q0U+k5phbUXJxXrOvIs/QVm9NyGzJTn0NBRwoLdg4uIMKlY3TD3bF6YQa18G2/qgh/d6c6X+412zbtu3NNMPBCdN3sOELqoVHjeEsWEdugkjPKJJ02fa105PaO/JX7GgX47/JCcUfFJMyIwiS/XsvwsaArzEbqlpoXEL2HesXwdWphofCKtcLJxLn7sHngvjAtSIqHXtPj+WbvfEmFeQsdE17wGfiujmJcaGTZTogmhtoj0L89iGyy6jlMrK9l/TyN30WLYVIawgnDrrA+f0JTVK8PBVfZjOrDlDp+gSUVsIYeYiuxN/L3j2Mpp9FTpvK38SE7KxrLFF/ly+062cJHRlc+PN28+cGctKDiJx7BUiNqKFOQlwdO4TGzccQcBQcL3imI2B/R2RMumFv+qLqi8KFu2NNq2tOIuKVlFnb/iD/eHkZwmRQd5p7ZvbY02zS1RWUGzdeLWDRviwhGiGzbdRHBwMnbtccf1m0EYO7opaksxKc8P4orOnNse9nX1sWHddYSHpmDYwN0YOrIx2rQrXtxEXax1uwZg58ZbbI5/8tAjBPrGY/qijtAoJvVMXasa1h0Ygm0rr+LGOT8c2eHOufY0yhdPrKTxSNefGIk9q67i0lEvXDj0CH6PYjB5eRcYSkjByw99M01svDgRZ3a54ejGmyxYHN58JdoPaIAeo5sU8JEuDloGqpi8oQ/6TW2Ni/vv4/rRR8hIysG+ZZdwYMVl2DQ0hkuHZNQzaAABAABJREFUOrBvaoZyJRRsfgskRqfj/C533Dr1OM/dxK6xKYbM6yjT+i414Rlm9dnOYjIVzapYeng4qhTyfCaqE/F7ySLRwEwDvUcXdPDYsfo6q+PJU9S1zWdXjgPb3bjbSRHHuqLJ2aXzvrxB1tNXhqW1Np9zL10WtBjNmprh4H58V3TrsOFnHOg3wo93hhAhM/UF77Jpl6tn8lmtFxUodEuNC41Uw0UdUyK4FwZ9YYI9hcJLVvynr2iMbNtMIGb/mxFwTxQc4ChkDysC8ucjbpKmgSp78MkD9/M+zDElFb2KHN1BMmymkTttPLQNirePocdyWqQE7TjASaZwKSo0hUUbhAH5FKXSQBzR7etu8uW+QxpCXRSjKquYnDvjFN6++QAzixoYNlJ+Gyfilk6acowLUeJsrljWtcSFKCUbrdtyC4PHHOBClCgCfbrVw5HdQ1gh/yMWovlB33NzU03MmdoGJ/cPR/+eDlyoP8t+jd0HHqBLv+1YvekG4kURtoqgpq4y1q/phelTW6FK5bJISsrBlGnHMW/BWVb6y4PGTc2wa98QWFlrcyGwce11TJ14lEf4xYE3TVNaYO6KLjy2jwxLxYjeO3Dtgn+xo3DqjE2Y1x5TlnTC72V/Q4hfAkZ02Zr3fZEGoqxQOtOC7f04KY0S8iZ034Z9a6/L1SXtNtIV229Og10jE6YknNnljoEuS1l9T99veUGex4NmtcNhn0WYuLYXnxNo3aFu46qxB9HdYiaPwa8eeoislJLFIH8pXue+xY3jnpjSaQOGOS/BtSMeXIia2tXE8pNjsODgcJmFaLh/PCZ12siFqJp2Naw4NrKIMwG9z1sXXeTGTvmKZTBjbc8C43lPt3BOWyL62uhZbfJoaSEBiXh0L5JH+v2HOfPvqGA9e0qwRuzaox5/b/z8E5CQmM2bLxfnnxZP/2b8sJ1RMrsn6Bio5llM0LgoWjSKN8zXLSWISeuSYtEyEp+xoTEteEY2xZ/QAx+IOqguX8bJ+7uDFikfkTCotqt8Xpz5ce+csCjVb2Mj9/3dOC6oMmmUJk8W/ZUjwmi7TT6ivTTcPu+HjJTnbOfUTEYsJ6WibBcpShu3toSBDGsSeuzrll7G61fvYVhLHZ161pP5eOizSoKlxMRs9hOdu6Ajj9nlQVbWS0ydfoIXeTI2X7GsGwxlFOPSHjclFG3few8vcgWlq3N9I4wc7AIVBQzafyRQrOiA3vXRu1s9Tps6fcGHzfQvXQvkw962Jrp1rAMbSy25N6v0d02bmPP4nnLuz1/0w4OHUXj8JBbdu9mje9e63PkuDiqqlbByXS82yN+94y78feMxpP8uFsK1aV+7WNPx+i61YGiijhVzz7FB/roll+D1IBLjZ7RmP0lpaNzKUjDJn3kaEcHJWDHzNB65hWPUjNaoXIzhvF1DY2y/OA5bF1/EvatBHCNKfMXR8zvASoaDhppWNSzYMxhP3MKwa/FFNsrfOu8szu29h97jm7PqXl4fV3JMadKtLh9kzXT3rDfuXfDjyyR4ooNA0zQSU1IhWKu2LtR0qn/1RgStB2QRRemA3m7h3BwRF9j03tk3MWNRlpm9fAEYt854Y9PMU9z11DPVwMJ9Q9g+qzDO7HuA66e9BfeNVd2hlq8rTlGyG5dc4sud+jhA31igalHhLt54N29nDS1ROtPFC768SVbXqAJn0TTs9BnvvK5ouXLfX+h44ty4bxQHuhg/On7YYvRpuCCs0c/XFSW1II3QiSyfP1KOTrpk8UEwzJfSJEakrzDar8njaOmL/ttX7xAvKnZNHeTLiv6nItInln3z2JBZQceA3OxX3BklUK6zPCBFKMXw0XvXsF3xHoiE22d8kJv9mr1FHWXwS6nrcnTbHb7cZVBDmab1d68EsUiD/m7AGNld0StnfeH9KIaDAabMa8fdenmM7R97xnAXcsGSzqhazEk/P5KSczB1+nEWv1DM3qrl3aGlpbjTQVzCM6zdfBNBocLnmQzfx49whY2VbJHW18DHT38gJf0FUtNzkZaZy1n22c/f4HnuW7x6/Q6v33zEu/cf8fHTn0yVoO8wFQC//N//cdFepnQpHqOXL1salSv+zl3FalXKQ6laeagpV4KaSiUoV6ugUIyiIqDH0KyxKZo2MkFQSDJOnveBh1c0HvvE8kE8UypKyfyfzOvlAY3dR49qglYtrbBx800EBiXh4CEPXL8RzMlOLs7Fx4pSQdGhcx3UsdfD6hWXWdG8af0NuN8NYwsoihmVBmWVSli5tS9OH/bEgR1u8LwfhdDAbexJKs4alwT1GlWxZt8gHN9zH0d33cODW6EI8onHqOmt4NRU+vVIbT99TQ80bGmJzQvOIyUhm1ObXNpYYfDkFixIlJXcZFPfCNePe+HIhhtIS8jGqglHcHzLbXQf5YqGctq2iUEFZ5/JrViNnhiVjkfXg+BzNxQRfvFcnNJB3UkC0QJ0a6nz2J+up6pdDcoaVfkxV6xanpsakkCf4bev3+N55itkpT5HWnwWEqMzEBeWgpiQJLx99b7A32sbqcGlgy0adaoDJXX5EuwouW77wnO4eVLg0lOSFXm1ktq+MMhPdM+qa3x58JSWqNPAqOAGe8EFPH/2Glo1lQpw5q9d8ENUeCr7ivYbKnRFX79+jxOiaNFefR15DXwam8mBD/S57NThsxXU98TPONBvhx+2GI2NFFStNWt9FtbEhgndUl1j9QInofTEbOYwEuFbx6holysmSOiaGlgWfyJ+GpjIX1KyOaqqKp9V0T8Vd48JC2/dltbFeq5Kwu3jnryrN7DSlttf9PwegSDfqJOdTA4Yj9x3CDYjHQc3lLr4i3HxiCey0nJRTaUiWvUo3mrpVe5b7Fp7gy/3HNoQ1VWKPykmxmVhx3qhSzBwZGNo15RN0r943hdnRCeLqTPbwMhYPlPoqKh0TJ91Ei9evIWmRhWsWtkdKspF+c/FgUzfDx33wrEzjzm6s0zpX9G/lwMryeUtmhQF2SKFRaUhMjYD0XGZiE14xoVoSSNm5cWvpX6BplplaGlWRU2t6tDTVoJBTWUuVr9WZ4tux9K8Bh8pac9x6rwvrt0MRkxsJpasvoKd+++jc7va7FlaXs7OkK6uEtau7ol79yOxfeddZGa+xOKlFznadcTwxjA2Kl5MqFmjKtZu7IOL53ywe6cbgoOSmEvas48juvWsJ9WpgdbMbv0cUcdBHyvnn0dsdAaWzT6Le7dCMWZqS1ZSS7xeqV/Qa5gL7BoYYc2csxwjunTaSdS7ZoyRM1pBSQJHX4x6jU3YKH//uhssLnS7FACvu+HoOaIR2vZxKNZVgr73rfs4onFHW1zY/wBndrohKSaDi9JD666j46CGaNK5DhviK/J+UhFIR49xzXhcHvL4KXcqKR3qaWgyn0vod3RIAq2XVPyRtRF9p/7883/4+P4jF4rF0QloI25mrwdrJ2PYuZrJHYUsBoUErJt2HKnxz/h59BrflDm1khxfKA55zczTfLl9X0e0L2Rbd/6IJ7zcI3jTNW1p57zpY86z19izWdjY9xvmnNc5P3nMk8VwtDF2FQXGHD0mFKcNnIzY/J46iD/x78UPW4wmiCxWaEwvRnxkGv+flJf5ERcuFKm0k5VUuMSKup3UGS0O8aFCd7WmxdcxTv67grrLd44LI3DXXvKnB4lH3Jf3CoVl875Ocl2HlLFeN4ROartBDWX+/e0z3syDqlytPJp1/2wzIgk0ajq+XUgm6Tu2Sd6iKg1UiNJ1qBtAKSOy1PlLZ53Fhw9/wMa+Jjp0t5crYWnzeqHYHTC4IZwbycej8vWLZ9U8qUENDFSwYmk3VJbTTF8M/6BErN54A8mpAg/OwV4P40c0+eojeYrf9A1OhH9IEgLDkpEgReFNsZ2aalWgplIRytUrolqVcqhaqSwqVvidC7ffy/zK2fOlfvkF/6Hz6f+AP/78L3dLqah+8+4jXr1+jxcv3+L5i7d4lvMamdmvkZ6Zi/TMl/j0x5+IS8rm456IE06oWL4MjPRVYWKgCjMjdZgaq6NCuS9LXCJoqFXh7vLA3o64eDUQZy76IuvZK2zb446Dxx6hTQsrdGpXG8pyRMNSMeHc0Bh17fVw6vQTHDvhheCQZIwcfYBFT4MGNCw26566Ue071UE9R0NsWHsNT7yesuL+7u1QjJvYHFbFCKQ4tWn/YBzf/xBH9z5gbmCATzwGj3FFy/Y2Ukf+RGfZdGw4ju++z51ST/cItn/qO7IR2na3l9qppASgUXPboUnH2ti66AIig5KxZ/U1XCUv1kktOL2puM0DFX7UDW3TxxGXDnnwyJ4aEDS+P7j2Gpp3r4tWvRygWoK4V3JWobQ+cWIfFZNkAUgJTyQsorjjjORsZKW+QO6zV7zBovWTDnrMkri39Hirq1WGqlY1aOqpQKeWOou0qABWpJsrRm7OaxxYfZWTlQh021PW9oRFXckjffcrAVg17RTz7Zt0qI0h0wp6kwb5xGG3aIM9ZFJz6InOp/RcNq28ynQkGtm37Sx0OzPSc3H6hLC5HjTMhbui8QnP4H5PoLT16iGbtvQT/3z8kMUoZZFnpAjkfC39z7tHsb8o2TrlB41dCDpSOgqJoiJWx7j4Ll5SpCjaUkJ39d8EtxOP8Pr5G6hoVYeNgnxRr2uBSIvL4kW8cZfiC0UxyFqFFjriRdGGQdbI/chGYaHsOqKxzJH7wQ038ebVe9Q0VkPjdsXzV30eRePmBX9emMfPbVdsygxh27obiI3JYH7c1Hnti+XlESLCUrB43jk+YTVvacmdKnlw1y2MDe2pk2ltpc2qeUX4V6/ffMC2PW64LAp1qFa1HMYNd0UDR8Ov0iGk5xMekw5Pn6d45BuL6NiitjtUdNYyUIVhTWXuUOpqVefi81uJAImDl/HsJZJSngsFaeIzxMRn8f9fvn4P74B4Pgj0EOgxWZnWgLWZcFSQkWpUHKiY7t2tLrp0sMVt9zCcPOvN4qbjZ57g1HkfNHExQfdOdmywLwvEFaWkpubNzLF77z3cuh3KB3VNu3S2Q49u9kxXKI5LumRFN7jfDce2TTeRlJiNyeOPsCUUmedXk1IYU0esz5CGbE+2dvElFjdtXH4Ft68GYtz0Vnnq6aLXK4U+IxrBqYkpNiy8iPCgJFZj37oYwF1Ss2K8eklVT1GixO/ev+4m0hJzsGTcERhb1sCAic25g1ocaKJCRWn7gQ1w69QTLkppfH96hxvO7HRH7QZGaNbNHvaNTQuIdBQBNTNqmmryIekzR/HJr1++xYe3H5leQt8N6jgT/ev3sqVRoUpZhTq1snjzlw564MSW2xwOIHYVGTKrHcpLmS5dPPII25dc5vW2cTtrjFvUsUDnNDUpB4snn2CBmEsLC7Tp9plmded6MDzcI/j5TJrdJo+OtG3zLbY+I/W8gyj1cO+++6y0p5AHPT0V5qRTbOlP/HvxQxajaUk5/GUqX+l3VKpSrgBnlJCfL8q/F50cJY09KLYtK0Xo3GjKMEFPTxBuX62m4gbw/xTQgnpqnSDeaTPcVSHOHb0nJ9YJHKRWAxsy31QW6L25IyK501hMFs7vu88ReErqldFKhldoZHASrp0UbpvMt4t7LrSYr19wgS9T/rw4crY4G6er5/y4kJm2oD2qVi8v08Jp5rQTrHauY18T4yfLZ/1EXbFtIkoCdcqmT22tkCE+xV2u2XyTld+Eti0sMXRAwy8qtgh0kg2OSMFdj0jc94rmrmR+GOgqw4bG1yY1YF5LHZUrKtbF/VLQe62uUpkP+3yiRPI7jE18hrDoNIRFpiIkMhXJaS+4UKXj9BXhPTXWU4WdtQ7srHRgYqReIkcB6uq2amqBFq7m8PJ+ysVoYEgyi8boILFTzy52sDSTHTmqpFQRM6a1QYf2tti24w5bQR05+ghXrgagX9/6aNXCUirNgm7bpbEJ6tjVxL7d7kwToQ6pp0c0+g5w4g6qNPEcFZ3r9wxk+6f9290QFpSMEX12on1XO/QZ4oxy5SV/x3X0VbBm/yBcP+uHfZtuITYqHZMH7IFzc3MMGt8USqqSR/dUGFEyWv1m5ji95z7O7n/ASu9p/XbBup4++oxxLeCBKQm0QW3Ttz5a9nJgERJ1S/0eRMLnXgQfFSqX5ZQn53Y2qGWj/dWCS+gzV7FqOT6+JWhzfeOEF07vdMNzUaJVzVrqGD6vQ5GgFzGoEKSYT7LUIrTuURcjZn9WxxPIO3bO6EN4SUb6JuoYN7dt3ucyNTkHm0Wizt6DG0BP1PChSc/D+5FMSRg9rin/fWhYCnvn0uZ8QP8G/HdryL4stPiQhJ/4Z+OHLEZpREvQ0K6W92Wh8XBakmCtoq5TsONAHBr+vUj1lx+ZotsqW+F3Jp8Xh2yRVUp1Ddm2Pf9U3DvlheSoNJSvUg6tBheNiysO3rdDEOkXx5yp9sPksyk6uOoKj4vIN8/IunhvxZyslyxQIPSb1LLYkTstvpvmnecCuVEbK5jXKd4lgXwTn2W8ZDXpwLHFi5ZiItOwYfkVvtxrUAPUlnICECMr8yVb7RCnytBYDXMWdJTJz6Rib8fOuzglKtQ7tq+NkSNcZXZfxSCz+o3bb3OsJUFTvQqmjGsGK/Mv88alzuI1t1DcfhCOLFGBKx65U+HmYFuTi7+qlb/tCbmkoKLLSE+Fjw7NBS9bEk4FhSXDL0SgFhCtgDq9dBw45cWUAeG56aFebV3ufCoCes8c7PX5CItI5aL0/qOoPLGTsaEqenS2h1M9A5mbP+KLkhUUqe2pU5qcnIMNG2/izBlvDBrYkPl50grb8hXKYMyE5hzRuGndDUSEp2LH1ju4ejkAI0a7wk7KWJceE1FQHF2MsX3tDTx0i8DZY4/hdiMEg0a7wrWlhcTPJRU6LTvbwrFxLezfdJsDJNyvB/P4vmMfB3TpX59FMJJAvydaTevu9ji67S4rvv09Y/igorTHiEYws/2cvCftcddtYsZHanwWrp94jLvnfJCd8RKXD3vwUU21EhyamqNeUzPOaS9px/SvAE3+rh3zZKW8WOxEAs5e45sxb1baZ4csEFdMPo4AL4Hj2m98U3Qb6lzgtaMClwpREpKRX+z89T3zpk4Uub14xmm8ffMRZpY10F3kXkLWdBvWXOfLnbrYQ7emMq9bW7YJa3TzpubQ0a6OqKcZ/Hn/84+CAq2f+Hfh7/vN+YYgix6CWj4OEC0wf3z8k0cHSoXMlzNFnDVJ3pXPRPw58p6T1Z14KcpGriSn8vmfBhqBH1x4hi93GteCC3R5QZuBA4vP8eXWg5xRRQ4eIilV71+kTtR/0G9aa5l/v2/FFbx7/YHj7FzaFz9yP7v/ITsuUPd88NSWxf6t27Ug3LkcyCfUKYs6Fjv6f/H8DRZMPckLNAk9eg8unuP64sUbTJt4FJkZL1lYQiPT4saqBBp5LVtxGffuR/DPpKSmtB55R9q08JNSnniU9Jy6drDFwN71UVoGX7a4fPpb98Nx+XYwIp9m5P2elOz17fXh4mAIW0tt/CaD1vB3BdEFXByN+CBkkRtEYAIe+8fBJyCBx/rUAabjl//7D8yMNeBkr4+GdQ2gqqCAzMRYHQtntWfe7okzT3D9TigiotIxb+kFaKhVRteOddDC1azY94o+B1R0OtTTx6XLATh0xAPJKc+xYNF5GBmpYcighrApZmNHgrmN2/rjxrVA7NnpzqP7mVNPwM5eD8NGuUK70GY+v+J+7oqu8PaMwdbV15GSlIPVCy/g0mlvDJ/YDKZSuPQ0vRo3tx1adbVjyzTyJT226x6unvZhkSAVrNIoMaRQHz2vPboMboijW+/izkW/vKK0lpUWOg1wQt3GJjKLeHUdJQyc1hr9Jrdk03y38754dCuYgzbIp5SO38uXhpWDAWycjPj/GrpK391LOi0xGx7Xg3D/sj+igwVtg3j612mIMxehxRXQ/o9isHr6SeRkvWKB1KRlXVC/qVmBv3nz+j1mjzqE6LBUVKpSFku29UU10fotpMpdQUxkOipW+h3TF3fMG89v33yLN9pq6pW5w064eSsYERFprFofOEDoipIXL6GBoxE8buG7gjj3v/768avf5k8A//mfvEG9/wKQGq9SpUpYPfMobp8NQrdhzug/XhjthvnGYVLnTZwysf/B7AJj57a6E7j7dth3Me+E8+POSS+sGr4HVg1rYfm5icXef2eNEXiV8xq7/JdDSwa/9J+IE6suYe/ck+wUsDd4FX5XYJR786gH1o7ez7ytvb5LUKlaBZnF66R267ggde1ih0nr+xT798GPn2Jq9y18clh7ZmyRUIP8SHyaidEdN7HH3sSlnZmkLw3EkRrdYxvevv6AXkOd0Wek9G4wjXinjz7EXoxkabNp3yBUKEb5/+rVO0wZfwQx0RlQUq6I9Zv7ModPVkdzztwzCAlNRqlS/4dpU1rJnTNP192w7TbuiIQDOlrVMH1CS9SSob6WBlK+n73qjzsPI/DuvWBKTif9erVrormzCerZ1vzHFqDygtaP8Oh0PPJ5Cg+fp+wEkB+GNVXQsJ4BXByMUENO+53CYq+zl/xw/rI/Xoq6XZTm1KGNNTq0tkElOdKF3r79gJOnnuDk6SdMAyFQghMVA7VkODWQJc/h/Q9x/qw3c5Jp3NqytTX6DXBClWImRbRhOn/8MY7ue8AdM4JTo1oYOKpxsQlOdLoiL9K9628hRRQSoKJemdX4jVtZyBTwUCOCfElvnfPl7zdBtUZVtO1Vj8f7JIaSF7ShpPH9o5vBPM6nDmJ+kDF/rdo6MLbS5g0w+XVWUDBpS1HQ9IdU+7Te+T+M4mAAMagIJMP/Vj0dYO1kWCy9gII09q25jssiUVMNPWXMWt8T2oW4vjSSnzXyIBeixDNdsbN/nmCJcOrwI+zaeJs3tUs29MybAnk8iMS8WaeZ0rJ6Q29YWmmzx2j/QbuQm/sOQ4e4oHtXe/iQ8f6sk7xubFndBSbGOsjNzf3qXp/y1g4uNjNQ6pcvFyvmxx9/voeb37Lv8rz+Tvh3nwmKSbshKOWzV6IdLqFwsfky5zUXolTEVJbA66PiUux7JwviKDayiPq3IT0+E0eWn+fLAxd3U6gQffPyLfYtFHKNu09sJbMQJdw68ZgLUVKWDpjRVmbHduPMU3y5eXf7YgtRUruunnaST1S2ToZwLaaDSre7dOoJLkSJI0pdGmngDsHyK1yIli33Gxas6lZsIUojrBlTjnMhWrlKOaxc21NmIUoj15mzT3GXiwRKixZ0hJUMuzExHnpGMzc05/kbPnHQ2JcsmxQtFkmt/uBxNE5f9kOQyIWCoK1RFW2aWqBpQxNU+cYn5L8T6CRqZqzOx9DeTkjNeAGPJ09x/3E0vz5RsRl87DrykHmy1F1t7GgEdTmt36pULodBfZzQs4s9rt4MxslzPpy8tO+wB46eeoyWTczRtUMdqBcTtUmd9v79nNC2rQ0OH/HA5SsB7L5Ah6OjAQb0c+KkJ2nepsNHu6J1Oxvs2n4HHg+icPmCH+7cDEHXHnXRuas9pywVBvGWu/Z1RJNWlswlvXEpAA/uhsPzfiRadbTlrHJJhvm0Djs2MoG9kxFunPfD4R1uyEh9gbXzzuHEnvvoPrgBGrWUXpSqaFTBmPnt0WtUYxbjkB0U0bZ2Lr+CgxtvwaW1FVp0tYOBqexmASVQkQ8nHbQ5ps4jFacBHlEI90vA82ev8OhGMB9iEFe9hp4KNGsqsRqemh/VVStzxGalquX5NouD4DX6Ac+zXuJZei6r/lPEfqMRqazKzw9KPiIeqFNLS9RvYcH3Iev2ybaJXg+6fUKr7vY8HSo88UlPec6j+aS4Z6hYuSyWbu9XoBAlS6/dm4SR+7DxTfMK0YyMXKxefpkvd+lelwtRwtbtd7gQpQz6zh1teS3ZsktwMmnfyprdJn7i34sfsjM6rO1KJETlYN6WPqgrssYhn7ntC87BsbkFZm/rn3edhMg0DG+0lIvNEyHLi9zmkVWXcWjZBbTo64Rx6/sWe/8dVYfhTe5b7A5ciRqGJes2/R1BC/H0lssReC8cFk7GWHljpkLjqc1TjuDyHndo6Ktg+8P5MnlXtBAPdV6C1y/eYsjcDpwsUhz2rriMU9vv8oK/8/Z0qUpRwv71N3BihzuP57ddGIfqxXgcblh0EdfO+PBCvOX4CKmiCsKx/Q+xb+tdLvQWru0OOwcDqX9LsXgzph5n0/EKFcpgzcbeqCkjEjU4JAlz5p3Fy5fvoKJSEcuWdGW+lTxRnpQnf/Nu6Odu6MSWqKXg5/Ptu488hj992Rdpos0eFWLU9SNupaWJ5ncZWdLyRgb5Hz7+ySc3+qwS/u8/5OH4f/i1VCn89tsvbIb/V4MM+h8+iYHboyj4BSXgz3y+qeQc0Li+MR/VZRQQ+UHP8d7DSOaVUrITgT5zDRwM2USfxvyykJb2AgcPe+DW7RDm8NHb5tywFvr2doS2jM9UYEACdm69g8gIwWGkStVy6NXHEa3a2hSbEBYXk4Fdm27Dx1PgJZb5/VfmmXbuVa/YTRs5o1w68QSn9j/kLh1BTbMKOvevjyZtrGRasb1/+xF3L/nj4mFPJIheL4JeLXU06WCDhq0sUVmB1z//RpWKU+pSRgYmIiYkGRlSLMryg/jyxHcl9Twp7+m9+++f/+PNMT1XMr0vzmuUfU4NVWBWRw+WDvqwcjQsdr3Lj4jAROxdcx3B3nH8s6pmFYxd0BHWDkW5wGEBiVg48RiLlshLeem2fmxnJ4bv46eYM+EYd8vbdqmDUZOb82OjbvLEsYeYb0z89w1b+vHnwuNRNObMO8OftU3r+8DERAOnL/hi0447qFihDA7vGoL/4BOfv79nZzQ9PesbJTAp/eyM4gfE85w3eWMUMV4+F35XuPtJJuYEshqSBDIjJshj7E5/Q8Xo+zcf8G/C2Y3XuRAtXfY3TNg+WKGiI8QzigtRwpjVvWQWolRcbJl5igtRPTNNmb6ioT5xbGbNt7+4S7ELMxH0T+68x5fHzu9QbCF67awvF6L0XKcu7VRsIXr3ejAXooQRE5sVW4jSyHTW1BNciJLSeMXanjILUSoaVq+9xjQA4vwtWdSZs89lgcQvKzdcZ6U8nfSoWKGoSlJxKzImPnPVnw+ygCLQaLh9M0u0b26lUCGlCN5/+ISUjFykZr5AetZLZOa8xrPnr5Hz4g1evHzHPM1Xbz9wCpM82216zuV+/43FRpUr/M7q/WqVBd9SSmKiQ02pIlSVKn41agF1iNs0seCDvE7ve1FhGgm/4EQe7dOxZb87bMy10MSpFhrWM5RpfE+q/cYNa3Fyk39gIo6deYInvnFwfxjJh4WpJr/PJIaSJmZTU6vM9A4akx449BDu9yLg5h7Ovo+NXEzQp5ej1NQu6nJt2j4A99zCWXmfmvIcmzfcxOkTj9FngBMbmktKGCPV/dINveDvHYe9VMyGpuLYvoeswu/Uqx46dLNDOQnTFurWkZCpVZc6uHzyCc4c9EBa8nNsWnwJh7e7oX3PumjZyVbqeJx4kC272XM3lIqwayefcGeQ+OJ0kILcxsEAzq0sYd+olsTHIAlUBJva6vKR33GDvEWpi0ndzPTEHGSm5CA7I5eTimgCJ/YYlQV63KRtoKx4de3qqKGvwmEtNU3UUVZBp4vwgEQc3+GGJ+4Cx5y6s50GNkDXIUXT5mj9vXzSGztWXWPrKT0jVSzY2LtAuEeATxzmTz7BhShRL2jNE3umkmctFaK0yRZHGNM0Zq3IRaVrF3suRMlfd89BgSs6pF8DXlNevhQoJN8TPxOYvh1+yGL0Fe+gf0GlfBYawu9QZNF691rgYRE5XRLIT008DpGFitXKIyedzI3/PUkS4Y9jsHfOSb48bEUvqCtgW0Wv7ZpR+/lys971YSVHbKj7eV94XA3gE9qENb2K5YiRwnP1xCPc3XElA+9CxPv8IIL+yinHecFs3rkOnJpL90elrsCWpcKYiQy5bYspLv2exLJIg9Cxhz3adbUrthCl0XxocLJQiK7uAcNi+Jr0vPYffIDDRwS7FfLkI/seWTnkdD9bdn/2Da2hUYW7oWa15Ocxk0jn2AUfXLwRiA8i+glxHru1tWU+aEnFToXx53//i4SUHETFZyImIQuxSc8Ql5yNDJEYUFFQR5Tw30IVKj0HOnJy3yIRgihREujqVJhqqVWBtnpV6GhWg65mdehpVUPF8oqp5PODit+2TS34oIKaitLbDyIQEpEK36BEPtbuvA3HOnpo5mwKe2udYh0V6ORP0ax0PI3Lwslz3uxZSvGtdJA7AvmYNm9sJvXzQl3QubPbo1ePDOw/9BAeHtG4czeMfWupU9q7lwOPVAuDilyygqrfwAhXL/vj6EEPpKfnYtWyyzh66BH69neCsxTRkHUdXWzcOwge7pE4uNMd8U8zcXCHO84e9eJOKX1/SAhTGNRN7DrAic3xaZN45tAjdrfYt/E2ju68hyZtrdGuZ13UkCKuoteLfEjpGPH8DdyuBOLOBT9Eh6TA+34kH9SptHE0gENjE9g5GxdoZsgD2gib1NblozCoY0/rFaUzkcjy/fuPLKil9YjOLbRJp8KwbHnyGi0n0x9ZFqjT6nknjNPlQkVx1vS+kZdy79GuUFYvSut4RZzyhRfw8HYY/1zf1RSTFrZn/1MxfDxjMF8k0LR3NMD0RR3z3ufjRzxx41oQ38/s+R2gqlaZ17Blyy+xWLKmrhJTQug5E2WIpi0mRmqcPkaRv//53/cvRn/i2+GHLEY/ffiDU1nyd8lo/EEovKukLxVB2rhH3F2Qh+2gpFkV8aHJyBRZSP3TkZ36HIt6bGQbJKeOdmg56HP+sDzYNv045ysra1bF0MVdZP49jbm2zBQK357jW3BnVBo47WPWKeaDES9r+Nz2Uv+Wxl7LJh7j7oSOgQqGzZSuzCd+Go2nqCtQ39UE3QZJT4mKDEvB/ClCh6BhE1MMHddU6t9SKsn0KccQQUKA8mWwfE0PGNeSPlIloQkZ2d9/EMk/d+9WF4MHNpRp3RQYnISla68yr5BAUZPUeZBVwIpBGfCHzzzmkTwlFBGM9VXQq6M9nOz0vzjLnTqawZEpCIxMQXBkKiLjMvBe9B0sjArlSkNDpTJUq1eESvUK3MmkgzqOVBjSv5NlVJnfaBRPSUz/l9e1p88HjcWpm/z+4ycWWJHqn+4/l/K/c9/iee4bZD1/g6ycV1z8pmXl8mOhy3R4BycWeDxKVcvDUEcZRrrKqKWnyl6j9HgUBdladWppwwdxTG/fj8CtB+GIT8rmkT4d1ClydTJGCxdTFkEVN43Q01XCjIktMbivE4udLl4LYDX+ui23sPfQQ7RtYcWCp2pSuthkOr5ofidERafj0GEPHqlSp5QOUuX36lkPBvpFwyao69Wugy2atbDEhXM+OHnUCynJOVi2+AIOHXiAXn3ro1Fj0yKdUnouZJbv0NAI9++E4cju+0iIy8KhXfdw+ognWnesjY4960o03KcirUNvB7TuZod710Nw5pAH4qIyuGtKh01dPbTuagf7BoZSN7JEyWrX24GPpNhMuF8JxP1rwUiOy+LuobiDaGiuidr1DblANTLX/CJbJxITUSPkWwqc6DMfHZrCkalulwOQK5oQUpHt0sYKXQc3hKYE+0LC4/uR2LjoIrKzXvEmaMA4V3Ts7VDgc0dWXasWnOf1jgrROcu75FEzbt8Mxh7RhGrEmCaoXUcIICAnB+Imly5dCrNntePvKXnoej55yjSaqeNb8N8tWHMZyalFwzB+4t+DH7IYFYPEL2J8eCfsukr/XvCk/F9R5/MXKXwn8QJEBa4saOirwftGEJIihCSmfzLev3mP+V3WITvtObSM1TFhm2LjeXIhIAU9FU+Ttw1EORmm5lQwrhi5nzsHxjY66DameC/Pq0c9ce+SP5/opm3oXWxe/e5VVxHiE8efh1kbekntOlDnYt7Yw8yTovHUpIUdpCpSE2KzMGvcUbx/94m7PVPmtZNaKOa+eItpk46yWIn4cSvWFN8RpazxOfPPIDo6gxfsieObo3kzi2JfD4q/3HXgAU5f8OGxtapKJUyf0ALWFvL5hpIp/aHTXrh063MRSjzQvl3qoo6ldon5oB8+foJ/WAq8g+PhE5LI3c/C+7qyZX6FvraScGgpQbdGNe5KfokRPj3eUpT9/cv/cWxolYryncypSE1Of4HEtBzEpwgHdWuJKpCV85oPD7/P5twq1SrA1EAN5obqsDDWgIG2kkyP2Pwg0316jft0tkdUbCZu3AvDnQfhyHnxFmeu+POhU6Mad6OpY1ocLUKpegUMG9AQfbrXw9UbQTh90Rdp6bk4dMITx848RqMGtdjGy0AKLcTQQBWLFnRCTEwGFxHkVUqbITrs6tTkotTcrKg9E210uvWohzbtbHD+jA9OnXiM5KQcrFhyEQf33Uf3Xg5o0sy8SBgDfV+cm5jyqPfh3XAe21Ni2anDnjh/4gkaNTdnTql2Pq6iGGT15NrGCo1bWyLQOw7nj3rh8b1I+Hk95aOqUgU0bWeNZu1toKYpXb1fo6Yy+oxpwt3ChOgMeNwKxWO3cC7qooKT+Ti27S6fN0ystWFuq8um+lSoSvNA/StBkcMhvnHwvhfJndDMfAIneg2ada7DAiWxFVNhZGe+5ASs+zdD+GdNneqYsrgTjMw0Cnwvjh/wyKMiNXQ1wdQFHfIKUVLOr1x2iS936mqHDp2EGFBPrxgcPPSQL48f24w57mnpL9jRg9C/lyOnjJ27HoDQqDT8Vko4F//EvxM/pIDJ1WACypYthwsBi/L+bcGQPfC6HYqxS7ugRb4s3AeX/bF02F6Y2eth1dnxRW7z9KYb2D3vNFy62GPajsHF3v+Ng/exdtguFvmsujkL/1TQiGdB13VcWBP1YP29+dCQwWvMj9iQJExovpwj73pPa4Pe04pXwxN2zj+Lc7vcuKjcfGMqVLWkCyki/BMwpftmHnMNmt4anYsROJHFy9qZp/ny7I29OcdaEj59+gNzRx+G/+NYXsQ3HBoqlSdKaSOThh3gLoKRiTpWbOkj9cT0LIsM7Y8hMeEZZ8WvXFc8R5TSSShj/vnzN6hU6XcsmNcRFuaS/RnFCI9Kw9I1V5AoCmho1dQco4c2kulXSqDi68jZxzh3PZDteAhWppoY2N0B1mYlM8CnmM2Hvk+5aPMLTWaBUX7QCNzSWAPmRhpcyFHhKa9Z//cCdVVjErMQFZeJyLhMhD9NR3xKdpHCukzpUlyYWtXShI1pDZjoq+FXBfPESaREUaTX3UPx8MnTvPeFXiPaGLRoZIb6dvoyub9kO0UuCqTAD8nnfGBlXgNd2tuinp1esZ3uuPgsHD3myR1SGrcSzEw10b2bPeoWw0klmsiFs77MIyU7H0K16uXZ+LxVW2upUbV0qnriEc2FT2hgUt7vbevpoWOPuqhtX7PYTRGpv6+c8ubI3lyRRoBgXlsbjVtbwcnVVG5rp5zMl/B+EAW/h1EIeBybpzkQgx5HjZpK0DNRR00jNegaqUJLTxnVVCp+tcQmSaN+irkmrmtkUBJzQen/+QVPpcv8CntnYzRqa81uIdK6wySWOnv4EU7ufciX6b3s0Lse+o5szLeR3yNz3ZJLcL8pCCCJSkHKefF77/UoGvNnn+ZuKW04psyg1Kb/4GlsJsaOP8zXb9vGmotRmlKMnXoUYZFpMDfRwPoVPZgO1G/cfp5cDOlph35dG35XAdO3uO9vedv/JPywxWjlKpVw6vG8vH+bN2g3ntwNw/gV3dCsq33e7x9dD8SiQbu5G7fu0qQit3nziAfWjtmP2o1MseR00WI1PxIjUjDEejorJc+kbcdvZb6M9/M98MenP7Cs71Y8PO/NgqzlV6fDpK50zmRhvHj2CuNclyAjMRs2LiZYdHKczNGu+wVf7ooSZu8eDMcWlsWeJMa2W8dWXQ7NzNkZQdoJirqhMwbu4cW658hG3AGRtsivmn0WbleDuGu6au9AGEgZoaenvsDk4QeQmZ4LHT1lrN7Wl9X2kkAjSzK0Jz5ddaUKbN+kVYxa+fqNIKzbcIMXbeJXLV7YCarFWADR31HX6/BxTx5Jk6hp6rjmXGTIU1wdv+CDExd98jxCzY01MKSXY4mK0MTUHNz1isJ97xhExH5WLROUq5WHvYUOaptrobapVolG239HvHn3ERFP0xESnYbgqFSmH7wqJF6k4tTSWBO1TWugjoU2DLSVFSq8STRG/NJrd0M5XjV/oEBjGuM3MoOJgarMznV4ZBpOnvfGvQeReap+spei8X3LphbFCqdSUp7jOE06boXwZ46go1MdXTrVYY9bafGzVIhcvRSAUye88EwUS0lc6dZtbdChky2qK0k/MYcGJeH0YU88uheRV/ATH7RtZ1u4trSUGjMq3lh6ukXg+llf3lyKT4E05bJzMkTDpmawa2AoNy+T1ofEmEwEecci1DcB4QEJyEoTaDCFQR1U6sQSdYg2s2TKT5tb0i8QbYyKYbpfGlvTNO4/In4zrVEf339iT9Y3r97h5fO3yHn2iu2XMlOeI5Utnp6xE0dhVFethNqOBsxzJUpBcc+LOqnXz/ni+J77TFsiGFtoYtSM1kXWPOLzLpl5hikUtIaTYr51J9u8fycR27JFwti+gUstzJrTnidVNNkZM/4QsrJewcpKCyuXdeNpASnnSUFfvnxp7N7UHypKFTFh3kn4hSTBopYGlkxtiSpVKv8sRv+l+GGL0arVq+LEo9lFi9HlXdGsW9283/veC8fsnltR00QDW25NL3KbPrdDMLvrBuiaamLbg8/FrSTQS91LbxyPthedmwQ7UZzgPwVkV7K831Z4XPDhhXv+6QmwbWIh//Xff8L09msQ9uQp1HSUsPHOLCbjF4fooERM6bCeF8kuo1wxcGY7qX/74f1HTOuxFZEBiawuXXd2nNROB/G/JvbYhle571C/mRlmrO0hsWNB79nONddx7rAnCwkWbuwFW0fJxTcVoFSIUkGqqVUNq7f3k5o5Hx2VzmIlSmTS0KjCqnki9EsC8VO377iLs+d9+ef6jiRUas3KTmmIjc/CsrVX8+x9SF09fmQTmSbo1KU8fz0QB097sQk+gTiJQ3vV56x1RcbxaVkvcftRBB/R8Vl5v6eboO5g/dp6cLCpCV3Nz7G8/2ZQ95DEVwHhyfAPS4JfWBIr//OD+K51zLVhb6kDewtthWJRk9Oe47pbKHdMM0TFHUFbsyoXpc0amsh0NyBO8HnmlQbilVi8WeZXNGtshg5tbNj6Sxqys1/jzFlvXLzsj7eiooh4qO3b2aB1a2upnz0qYIlTePKYF6c5EYh+4tzYFJ0614FBMZQVmkLQyP7m5YA883yyhaIRfsv2NjAshndNyErPxZ0rgbh7JRCJsZ8/o9T9q+2gDweXWlygSttQFieIjAlNwdOINMRFpiE+OgOpCc/yBK/fCsT/JGN6AzMNTpgytdGBer7Ya2kg6hEJvy4ef4znIvN+VY0q6De6MZybmxe4Pn2OL5x6gj2b77Cmgta42Us7w8zq8yaVOMKb19/gjYJzIxPMmN2OC1HqhI+feAQJidnQqlENG9f3RsWKv+PGnVCe3hCWzOmA+vUMcOTcE2w/eJ83bHvX9kOl8r98d2unjG9k7aTy09rpxy1GqylVxXGPz8XoouH72Jx49OLOaNXLIe/34b5xmNh2LVRqVMV+rwVFbjMxMg1D681ltf3ZhE0yv/Sbxx/ApR234dy1HmYcGIl/CoirubjnRvjdCeFCdM7xcbBvIX8xTSPBpQN2wOOyH4/a192YAS0ZyT5ZKc8xvs1q5GS8hG0jE8zfP0xqF5W6E8vHHMKDq4HsEbrh/HiO8JMEMqOmQjQ9+TmMLDSx4sDQAqOn/Di6yx0HtwhcqMmLO8K1teTnnJH2AlNGHORCVF2zChei1aXwsPx94zFv1ik+YesZqGD5qu5S02poHL9oyQUEBApimX5967O1jrTuGb3OpJzec/AhczvJo2/CqKZcjBYHOsFQUtKuIw/yfEK1NKpicE9HONczlLtYpG6gm1ckrt0Pg3/Y5/hBet9szbTgYm+A+rb6bJn0rUHP6c27D3j7/hPeffjEhfbHT4LfqHjZo+f1C3NHf0HpX39Bmd9+5eKrbJnfFLK4Kunji0t+Bp+QJPgEJ3CBSo81P4xrqqCetS7qWemilr6qXH6odLt+IYncLb3nGZXndkBRpHbWumjZ2AwOMtKvSCB30y0UZy/6IS5fapSttQ46tLYudoT/+s17XL4SiLPnfPBM5HpAnb6mrmbo0MFWqv8tPW4a69L4Pkj0eSeYWdRA+462rM6Xxrd98/oDbl8NxKUzPkiM+/x49Y1U0ayNFVyamUtU4YtBnwcSOrlfD8KDW6FsDyUGfdco1II2oXTUNFQp0aidupuZqUIXk7ibmWkvkJP5ipObiDZANoJkaE8bb9q4i6kPBCrkqMNMvHbaYJPIqkr18sz1JOU7RVtr6lbn/1NBKg9ozaRoVQoPuH8zNC+RirLluw10QtP21kViVpMSnmH90ssc3iGmSEyZ1579ZMXrz65td3H65GP+uXVba4yZ0Jw/K+SBPHnaceYcV69eAZs29IaKciWmiEyYfpy/m3261cPgfk4IjUzFqFnH+famjmzK9mffc5wtvu/GZlNR6pevywX+488PuBOy8ueY/kctRqtWq4ITnnPy/m3F+MNwv+CHIbPaouNg57zfp8RmYrDTIvZ1Oxe9RmK3sL3maPaIOxS8Akoa0snwhCjfWIypP48LukNR61GlGC/LvwsyE59hbue1iAtOQplypTH3xDjUbizd+khi+tCEQ7h28AE/78Wnx8OyvpDjLQ2vc99iSsf1iI9Ig7aRGtacn1CsCGnXkos4u9udF+IlB4fBom5Ro2axCGlav13Mq6IYwHXHRqCyhKQXwtlDj7grShg+pQXa9/rMJc6PtJTnXIhSZ5QK0VXb+kEpn+9efty9HYqVSy/y6MrSWhsLlnRm9bwkREamYe6CszzOKlv2N0yf2pq7otJACunla68iOEwY19arUxNTxjWXqpIWg3wtt+y/x0lABOqeDejmwEULCXzkeX9J+X7xbjDuekXmqd+pfrWuVQOujsZchFaqUHLro8L39/zlO6RkvkDqs5fIyBZ8RrOev0b2izd4/vItK+Jfv/sgl8eoNPz26y+oULYMKlegg3xHy6J65fKoXrkclKtWgKrIe7RqxXJfhdNKm4eQqFQ8DoyHV0A821nlR+WKv8PBuiYca9eEnYUO+6LKO8a/ejeEbaLEoPeiSYNaaNHIlJOfpG026LX2C0zE2Yu+ePTkaV6BpKpcEW1bWqFlU3NOgZL4fD79yXzS02eeICZfLKVtbV10aF+bRU/SClryojx76gmPeqkgEfNKWxFtoLWV1BE+fxb9E3DlrB8euoXn0QZITFPXyRCNW1igjoN+sQb8dBtPI9Px6G4YPN0juEjND8pft6xTExa2OjCz0YFWzerfhAdKxSJ9fumz9bUmB5wUFZoKj7thcL8ewgWxGAYm6rzGEU2hcEFLlIrj+x8yNYJeU+o+Dx7jijadbPMeGxWbSxeeh88TQcDXf1BD9OrryP9OHdEpVIg+zUSVymWxbm0v7owmp+Rg5KQjPIWpX1cfi2Z3QO6rdxg86RAys1+hkaMR5k9qjRsPw/F///2IZs7WP4vRfyl+2GK0QsWKOOszP+/fyAaIFNi9xjVF7/HN837/7s0HdDSczJdPR6xEOQkn1GEO85AQkYp5R0ahnhzdwnEN5iPC+ym6TGyFwUu64++MwPvhWNJ7E3KzXnHhvPDMRBjWFmw55AF9vLbPOIELO+/wojpjzzA4tZOe9U4g0+fZvbYi5PFTVFWpiLUXJzHHShpO73TDHpFac8ranmjUwVby7b7/hNlD9jFXlArQNUeGsWG0JNC4autyYWzUZ4QLZ19LQmJcFqaNPsxiJRrNk1hJUiFKr8OJo57YvUOwN2noUgvTZraVGv939VogNmy6yQu/pmZVLJrfUWr6Dd32hasB2Lbbnc3gyc6IBEpUKBR3EiOroG0H7+GRj3DyoOv16mCHLm1s8LscfGayQbr+IAwXbgfx+FkMLfUqaNnAFE2darHt0peAisvoxCxEJ2UhNjkb8anZSEh7zh1YecGK+dK/cieQCkwaAef3G/3zz//hjz//5A7ie5HfqCKgjqqaUiXUUKnM4isdtaosutLVqIaK5cp80XP39I+DV0AcF6j5nzOJnkgA1aCOPtMdyFZKFhJTcrgoveEexu4IYujpKKFlIzM0cTKWWlgS0jJyceGKP67cCMLLV+/zHkfD+oYc12hmoiHx80afz8CgRJw554NHj6LzNghqqpU4gpScIKSN8KmzSvGiVy7554WV/N8v/0HdegbcdatdTEFLiUx3bgTj5qVAPI1Kz/t9hYplUL+RCSv1Lay1JZrw5wcVbE8eRMHbIxpB3nFFeJkVKv0OY3NNGFvUYJW5vrE6KufzsP7eIEV8kG88/L2ewudRDFMIxCBhZYOmZmje0QZGZkVT0ogidOtyIA7sdEeOiENKxfzoKS2gpvE5njMsJBlLFp5HRnoud8FJqETjeQJxRKdOP4HEpGxUqVIOq1d2Z39aMrYfPfkI0jNfwkhfBRtW9uAJxYT5pxAYlsy+xbtW9eaN5sAZh/HmzWt4n5v9c0z/L8UPW4z+9tvvuBy8OO/Lt2/lZZzcdhdt+9XHiPkdC1yvi+k0TvzZensGdCVwkEjAREKmruNbYODcgteVBK+r/pjXaS1+Lf0rdvotU8go/q8CdSNOrLqIQ4vOcjdEz1Ib80+Oh3IxKvbCoI/WthnHcXGnMOaeuLk/mvZ0LPY61GleNHg3fO6GoWyFMlh5elyxfqI3Tnhh/XTBe3TgtNboMlyycp4UxwtHHYTvw2g2jqbRvL6JusxClMZV/ce4SjzJRkekYebYI2zNRPYyKzb3kcgRJZ7YpvXXcfmiP//csYsdho9yldhNo8e5cdNNXBUZ0js6GGDa1FYoL6Woych8iRXrr8E3IIF/JqumaRNaQK2Yjjul/ew99ggXbwayWIVO5u2aWqB/Nwe5cuOpY3fmuj9uekTkFW7E62pczwhtXMxhbqReok4OFVuhT9MQHJOG8Nh0hMdl4NmLgiplMejmlaqUh4ZSJaiQz2jVCvwzdS+rVCyLyuV/R8XyZVChbGmFE5PIaJ9EW5TgRAX3i1fv8OLVW2TnvuXu67MXr5GR/TqvI1vYQD8/lKqUg55mdejXUIKhthKMdFRQQ7WywvGjVBQERqTgoV8sPHyfsr1UfpCvKRWmDe30oaNRrfjn9+d/4ROYwIUpxZHSeJRAn4N6Nrpo0dgM9WxqSu0ekk3Y3fsROH/FHxH5ijyy4aFuadNGplIFTxQ1ev6iH65dD8Tr14KYi+7HxbkW2rS2hkktyZ8d2pQ9uBeBS+d9ERz0WUmvRBZNLSzQrKUl1NWlZ5dTMXr7ahDcbobkFVXiLqejszHqOxvD0la32I6p8Dj+QGRICivoQ/ziER6UzJvcwqimVAG6hirQ1lPhmEwSV6lrVUWlKuW+GT+a1tvszFdIjM1EbFQ6osPTEBGUxN7I+fF72d+YbuDUxBT2DYwkUpTo80bJcUf3PUSqyIVDVb0yeyU7OhvlPQda244e9mDfWIotVdeognmLOkFPXzin0Uh+xuxTzCdWVqqIlcu7cXoXpS6Nm36MHT401Ctj86pe3DFdufUmexjTxnj7ip4sYhoy6yhvdi0NlbB9cb+fAqZ/KX7YYpR4H+f8FuQpC8/tvYediy6gQSsrzNhcMGN+bMtViA5MxOxdg+DYsmjn89axR1gzah+MbHSx4fZMmY+DXvIZrVfA/24oLBrUYkX6l5qFf02kPM3AmiE7EeoZxT+79qqPMRv7o4wcVkD5T3g0mr9x+CEvXGPX9UGLvtIN4gnEWVo2Yh88rwfxArn46EiY2UsetxPcLvhi1YSj/Hp2HuqCQTPaSPw7KvCWjDvCZtWkZl2yeyAT+yXh/BFPbF8lRNN17ueIQeObSjx5cOTdlBMsmiCRxNINPSWKHF6/fo9F887B1zuWC6gRo5twMSrtRD1/0Tn2D6VCldJIenSvJ7Foped87VYINu+8gzdvP3I3Ymj/hujYxkbqyJg4k+RLeeCUJ1+HUL+OHkb0a8j80OJAPEtSwp+65sdFkRg1a1RHhyaWaO5UC+UU+HwQXr55D//wZPiEJyEgMhkxic+KFHb0mmmpVuFiTq9GdehqVOXOo4Zy5W/O6ZQHdNJOz36FlMxcJKY/5yM+NQcJaTnIyJacEkVdWkNtZZjUVIFJTVWY6anxuF/eIoXee0qluu8Tgwc+TxEWk1aAjkCd6YZ1DOBsb8Cc0+Jul0RKtx+Ec2EakS+bnTqVTRvUQnOX4sf4EVFp3JW/cy8cH0T0DPosujgZo00LS5gaSy4uiZNKaU4XLvoWGOFTx6xVK0s0aWzGkZGSkBCfhSsX/XHrZginAolhblEDTZtbwMnZWCr1hdYl6hK63wrFQ7eIAtenLmGdenqwdzJEnXr6qCSHaImK09iIdIQHJ3PhFx2eipQE6aEmtK6pqFfm+MxqShVRpVo5LlDJ7L5chdKcZkS+rERnoo4tx2iKwhk+ffzEvsXEK6XHTeLH51mv2IkgI/U5c+AlqelpPdA1VIWVnS5q19OHWW0dqQ4HL3Pf4fpFfxaFPRNxx+l16N6/Ptp0ti1wvZjodKxZcYXFmAQXV1OMn9Qiz5rrwcNILFtxmd9rba1qWL6sK3NEs3NeY+LME4hPzIayUgVsXNmTN88HT3lh19GH/HiXTm/PvOa5G67gjmckqlcph40z20FXW/1nMfovxQ9ZjDatNQn/979fcdBtep5X5P3LAVg25iBMautgzemxBa63euxB3Dnjjb5TWqFHvhG+GM9Sn6O32VReOI5FrEblYixJ8hd8I+1ncU5996ltMWCB7ASibw0qBs9uuIYjy87zqJw6kyPX9UOTXvUVuh267oqhu/DoSgAvLBM29UeTHp9FYVKV+iP3cyH6a+lSLFayKUZ0437JH6vGH+aubcteDhi9qJPEk17+QpRG4gu294dVXcnWRmRnsn+TYLjcdUB9DBjbROJtPrgbjuVzz+LTxz9hYaONBau7S7SSSU19jjnTTyIh/hmfYGbMaQdHJ8lcWUq1WbHqMneLyD909sx2qC2lYH6W/QqrNt6Al7cwXjetpY6ZE1tCU0pBSV/xB49jsPXAPaSIOmoGNZUxZoCzTJum128/4OKdYJy+4c/G7gTaODnbGaBzcytYGEkezUoraINjUuEVFI/HwQmIiM8owulUq14R5gZqMNVTg4muKgy0lFhQ9E8EcVapoxOd9Iw9SCMTMplyIIkGQN1cM301WBjQoYFauipyF9s0zqei9L53NHyCE/l1FoOSqcSFKXWsi+vIxiU+46L05r0wNtUXo6Z2dU56cnWqJVWNT0XtzbuhuHQtsIDgidT3rZpZcLe0soSuO302IyLScPGSH9zuReR5plLRQ/G2LZpZwMpKW/IU4cMf8HgYhetXA+HnQxZNwu9//e0X1HMwQCNXU9jZ60ulwnC32TceD+9GsEWUmAZAoI+0oYk6bOvqwbpOTdSihCU5hUFv33xg9XxcTAYSnmYiKTYLyQnZHE/6rU+35PihplkFugaq0DdWhaGpBqdDlSsmr57W0JCABFy/GMCJV+LUQRIldepZF2061+Fuav4N9uH9D3H2zBPuhtKmYfT4ZmjcxCyv4D9w6GFeTLG1lTYWzOvAGwQytZ80+yRSUl9AiTyqV/TgaFqa0qzadov/fvyQRpw+dvD8Y2w/9pDXm81zu0BXveJ3FzD99Bn9dvghi9HOdefg9YtP2HR6NPRNhSSJyIAEjO+wgU2JD3t95pISzmy/g92LzqNecwvM3TNE4m2PabQY0QEJGLWqJ9rIGYt59/gjrBiwjS+PXNMH7UZKj4v8lmAz6euB2DXjGJIiBZGDlYspJmwbBFVtyYp0aXie+RILem9BhE8sF5XTdw2BY2ubYq9DpspLhuyGj1s4X4deY1sXgW8kCXfP+WDN5GO8iJIn7NhlXSQKCGh8tnjsYfg8iOIT0vyt/WDtoC/x+e/bdBsn9z7gn3sNdUbvES4Si6wLJ59g65rrfOKj8d6MRR0lnuwCAxKwYM4Z7jSQ8GLxsq4SLWrohLhn332cEKlPaUxJeeDKEpT49Dhv3g3Dxh23uWglvt6gvvXRtUMdqZ31mLhMbNrrxl59BPIaJZumFi5mxYpuyJj+5DU/XLgTzBnRhMoVfkf7JpbcCZWHo0jIff0OjwLj8NA/Do+D43n0nR866lVRu1YN2NTShKWhBo/a/80gCkBCag4i4jOZkhAWm46ohKwCBSSBuK3UNaXXxMZYExaG6qzwl8cf9pF/HO49iWa+KbkIiEEOBjTKp8LUxqSGVGV6nqm+WyhvYsSJW/R5sbPSQTNnEzbVLyMhIpk+o6Hhqbh0PRBuDyLyuqXE03Wsa4CWTcxga6MrURj36tV73L4TiitXAxAb99lmSUWlIivxmzYxZxs0ScjKfInbN0PYIoo2f/m7nQ71DdHQ2Ri1yUFASmFKawnF93rdj8Ljh9Gc9FS4o2lqWYM5pmRhRGEW0hw4pIEKbfIfJecN8gcln9Dn2W+Y2/rq5Vu8efUB795+4NeMGgM0AqfX8z//9x9+r6gYpqKQFPWU1EYd1crVyrFrByngqQhV1axSRAEv9fmGpuCBWzju3w5j8aUYNfVV0L67HRpRKla+14vWqmtXAnBg7wPuyhIaOBtj9LhmqCoSgWZlveRuqNj9g4RqI4Y14scf9TQD0+edRnbOG06AW7e0G9TVKrMV2dKN13hN7dPJHkN7O7En8ex1gg5g8qDGvOa8evXqZzH6L8YPWYwObbMCidHPMW9rX9R1qcX/9urFG3S1FtT1Z0OWFYgKDXnylL0uK1evgKMBSyQWKWe23MSuOadgYK2NTXc+W0bJwsFFZ3Bk6Xm+3Gd2B/Sa2eEv81yktz7oQQQOLTqD4IdCxnll5YoYvLQHXHsKKkhFQMlK83ttQWZSNspXLov5R0bBrJ509Tfh1Yu3mN9/B8K8Y3lxn7dvKKyL6YhePfoIm2ef4cdeXCH65vV7LBh5EMHecTyap0JUUkf0zz/+xOall3HtrODhSWP5Lv3rS1y8d2++zWpSQqsOtTF6aguJRSAJLjatv8EdAkMjVSxc1pWtTAojIzMXi5dc5FQlQqeOthg62EViB4ZGW2s338RDrxj+2chAlfPGiacnLTlpz1EPXLodxI+dipvu7eqgV0c75mNJA0VbHr3kw+pVsYqZfEC7t6qNpvWNUfq3X+Xq1Ln5ROOeTwx8w5PyTNQJlcqXQV1zHdiba6OOqRar0r8W6DNBo//nxPF8/Q65b95z8UsdyrfvP4rsnf7Exz/+YDeD/AUgfdTpvaQi6bdSpVD611I8TqeubPkyv6H876U5675Sud+5KCdOqjxOA/KAOqWR8ZncNQ6KFo4cUTKRGGTLVKumKhfudFgaqkssBgve7ic8DkzgwpQSr/Ib7leqUAZOtvpwsTeErbmW1BQo6niS5ReJnkJEG1UCfYbI8osKUyvTGhI3NqTkv+MexoKnyHzFXfVq5dHExQTNXc2gI4GDTu9jZFQ6rl0Pwl23MLzJ97hNTDTQxNUUzg1rSRQ90XUpVpdcK9zvhLITRd5jLvsb7Ovpw6G+Eezq6klNeiLQiNr3cSz86PCORe7zgu8HFdcUCWxsosEdVKLqaGpX+1vRrSQ9p0C/BH5OPp4xBTrBVLRTjGfzttYwNis47aCi+O6dUBza/wCpKYLlVQ2tapwxb2evl/e6k3MCiS5pU0GToEkTmnPoAcHDKxqLVl5mLjatWasXd0H1ahV4w7N0k1CIdmhuhQlDGzMNaPyS0/xd7dzMChMGNMKyvbfxe6n/YWL/Zj98Z/T+/ftYtWoVfH19kZaWhnPnzqF9+/Z57xe9F/PmzcOuXbvw4sULODo6Ytu2bTAw+OyPnZOTgzFjxuDSpUt8/uzUqRM2bNiA8uW/XzPghyxGZwzZAf8HcRgxuw3a5vMU7WE7lz3f1p8bByMr7bzfk+cbiZjo/9vdZkLbUE1islAfs6m8o11/cwaMbeVTnNPLf2DBaRxbcZF/tmtuifFbB6OaFAP0r5Wi5HnJD2c2XkP4Y6G4ITFV+1FN0X1KG5QvQQKO2+nHWD/uII/oNfSUseDYGGjqq8r0EZ3TZxsSItPYtmnBweEwrVNT6ut0ctsd7F91lX9u08cRw+dLzoZ/kfMac4fu5/xoEivRaJ54UpI6p8unn2L7FjqZjpndFi06FlX6E+dp5fzznI9NGDDChTlUhYt14nWR0TMpfwkujU0waVprXpgljeVXrr7CCzedFKdMaokGEkb49Lxvu4dhw7Y7XBjQSbBfDwf07GIvsbNF3Yuz1wKw7/gjHrHz43AwZF6omrJ0URNZCh288AQPfZ7m/Y66Zz3b2qKupa5M6yKyU7r7JBq3H0fCPzK5wPhdT7ManGz0UN+qJkz05PPKlAQqqrNevEZS5nMkZQi2TqnZuczZpN9nvXiT18X71qC3ngrS6pXKcTdXpUoFFlGpVqsIdTqUKkG5cvkSWT7Re56U/oJ5tP6RKfCPSEbaM4EiIQYVj0RnqGOihTpmWqilq1pscUyvi29IEtyfROH+kxgWZeVPa3Ky1eOOKVlGSaMHkBqfRvh0iL1oCcrVKsC1gTGaNjSBnpRJSkxsJq7dCsYtt7C8MAXxpopG+I0bSlbyk1iKvis3bgbD1y8+z1qKir46dXTRyNkEDvX0JUbb0t+GhiTjgXs47t+LyEt5ItD3yNJKG3UdDLgw1SjGrYPeD0obCvJLYH/NkMDEAiIoMYgrS6lruvoq0NKtzgc5bKiQYE2GYv9rgyYy9JhJuBUZloqwoCT2QM4PKkDtHPXh1MgEdg76RTq9xD+9eT0Ip048RrrIAooii3v1q88pWeJNM3VDN26+xe8TwchQFTNntEUNzar8Hhw8/gj7Dnvwv9Wmkf3MdqhQvgzOXfPH2p13+Pftmlpi4jBXRMdnYvTCkyxmpM/k0kltcfJmANYfccefn97D98SsH74YvXbtGjw8PFC7dm107NixSDG6YsUKLFu2DAcOHICuri7mzJmD4OBghIWFoUwZga7RokULLmR37NiBT58+YcCAAahTpw6OHj2K74UfshjdsOAUrh3zRbs+Dhg+87PoZWaf7fB/GIUxSzqjZc+CHMeZ3TfD/0Ekhs7rgA5DJSu2V4/ai9vHPFG3hSXmHxmt0GO7vt8dm8cfxCey5qlQBt2ntEWb4a4o+5W8GQkJ4Sm4c8wDtw49QI6IO0hFaPP+DdBtclsoFbMgSwMVnztmncDV/ff5Z4pFpdG8PMlK1BElQ/tqqpWw6NAI6JoIlInCYCPlxRdwYb8wRu82sjH6TW4psXOblpSD2YP3srE0GUMv3jUABiIqRn6QyfT8cUcRHpTEYoFpyzqjfuOi1IDsZ68wb9IJRIWn8uI7aU5bTneRZEGzcM4ZhIWmcKEyYIgzevRyKPIYaVS3c7c7G4KLF+45s9vzuKrIfee8xprNN+Eh6oYa6ClzN1RPV1ni6/TYLw4b97px0cB/X1MZYwe6cOdKEuir7xuahAPnHsM3RBir0cMljmHvdnU4N704UJfjvl8MrnmE40lIQoEOqKmeKlyIq2irjxoq0lXO0pDz8i2iEjMRnfwMMSnP8DTlGeLTcth6SRbIf7NKhd+5i0lqeupqli3zK3c6S4vtnX75hYti8dtDqyCN0Klo+/iH2ObpE5vQv3n/Aa/ffuROK3Vec9+8k8u/9LdSv3BRqqVSBTqqguWTjmpV6KpXZf9SRZCalQu/8GT4hSfBOyyRVfz5QQWlrUkN2Jtpc9eZBF7SQB1hSoFyfxyFe09iuJOdv+NZ36YmXOoacgqUpO4rFRhB4cncLXV/FJW36RHzS5s41YKrkzFUJWx+aMPm+eQprt8JYc6zuPtOnV8a31PHtH49fYnWYvQdo07pHbcwFvmJQfxS8ix1bmiMuvZ6UgtT8i71uB8Jj4eRSBYpxMWg8b+tXU22irKw0pIqgBJ/b6iwI9ESFXokWoqJSmdxkSRQ4ayiVomFS8oqldj6rWr1CqhMY/YqZXnkXr5iGS4OS5f+tdgNDHUp31K3/9V7To+jcXlO9mtkZbzkUTslUqUk5vDvCoNuV89QFdZ1dFHbvibMrLUlTmGI5nD1sj9uXA1ifiihUqWy6NTNDh06fuaP0ntJdl2HDnuwDykV+L16OqBXj3q8UX6R+xZL11zFY5F1HCV4jR7iwq/HnmMeOHDKi3/fqZU1xg5sxFMZKkTJwcKqlibWzewIr6AETNt4kb9vg9vZYGgXl+9r7ZT2jRKY1JRK9Lzo/JK/GKXPprq6OiZNmoTJkwVLSrpdFRUV7N+/H927d0d4eDhMTEzg7e0NW1vBBvH69eto2bIlkpOT+frfAz9kMXp63x3sXnELtesbYPGugXn/Tl23E1tvo0nnOpi4qkeB657b5Yad88/CvJ4+2w1JQlJUGnuO0sK39to0mBSjBJeEuJAkrB2+m43xCeUqleVxeaPuDjC0ramwsfL7N+8R/uQpfG8Hw+uKfx4fVDyObzHAGW2HN0HVYvLNi328YclYMWQ34sOpAPsPuk9sid7T28ocVT245I814w9xZ1LHWI07ospSxDfEJ1098Qg8rgfzz0Nnt0OHQQ0l/m1kUBLmjTiA3Jw3UNGowoWopm7RTk1S/DPMHXOYC1fKg56/vgebVxcGFaCkmH+W+YrTW+at7Apz688dczGCAxOxaN5Z5OS8YSHTzDnteRxY5H6TczhNiexOihvL01fyxt1Qzmombigt8n27O6BXV8ndUIqBJF6o2C+UzNGH9HJCq8ZmEt8Lun0yVd931hMhUWn8O/q7ZvVrcRFanDUQXTcgMgWX7ofi7pOoApxEY10VNLE3gqu9oUL+otQFCYtPR3BsGkLJ0ikhA5nPi55MxY9To3olaCpXYlsntWoVoVqVjgpQqlwe1SqVVdjKSVFQ0UqdxeyXb4WO7PPXyHj+Chk5r5Ce8wqpz3KRlv0qr9CSBOUq5aGnUQ36mkowJNunGkrQVq0qd8gAdU69QxPxJDQBvmFJRbi4miqVUddcG/UsdVHbuIZUERgXlpEpcHscBffH0cjKV+SSXReZ7FNhSilQkjirVLQ/8nmKW/fD4eUbV6AzbW6swUUpdeYldT2pWLntHo5bbqEFLKKoAHaoq4fGDWrBzlZX4vuZkPCMC1MSPSUnfy4s6btUu7YOnByNuGNKRZQkUOyop0c0nnjFICQ4iWkbYpCPqaGhGqxsdLgwNTXTLHakL34dyQIploRLTzM4BSopIRspSdksdFQEJMCi5yF8d6kw/R8/PhIWFfeZKgxl1UrQM1SBgbEajE01WIQlTchESW/33cJx62YwIsJSCxTp7TvXQfOWlnnxw/Rc7z+IxO697kgVdVuJPjFxfDPUFG2Un/jGYfm6q8wPpc3CxFFN0KKJOX9eVmy5wZ8XwsDuDujftR6i4jIxfulp5L56DxN9VWyY1ZkFf+NWneVxfXsXc4zsZIfKlb9vNr3YiedrJzDdjl6HpKSkAs+rdGnanJRWqBiNjY2Fnp4e/P39YWX12fmnYcOG/DON4vfu3cvF6vPnn1PG/vjjD+6anjp1Ch06dMD3wA9ZjD65H4y5Q4+gqlIFHLn/2YrJ2z0ccwfsgqpWNey7N6vAdTOSc9Dffh6/+QceL4CSFCI9jaqvH3oAfUstbLg1E79I4WIVl5BBwqZjyy8gOTqfUXPV8jCpqw89C22o66uiqkolHm3/8msp/PnpD7x59Q65mS+RnvgMyVFpXNjGhyZzMpQY1AGs3cQcrj3ro25rG/65JCCe5enNN3F4+UWmJVRRrojJWwdyV7TY61FK1crLOLFZUE3Wdq6FGdsGSE1WyiEx1JA9iApKQqnffsGk1T3h3MZa4t963AzBqmknucCtWUsNi7b3R1UJIqCAJ7FYPPkEXr98x52KRZv7sA9gYZDH3toll/gEQOO2hWu6Q71Q55i+OhRduGvHXVaV6ugqYf7iztCsUfTviP+2eettHvmTWn7q5FaoJyElirLB12z6rJQ31FfB9AktJHZDSVhENk0nL/nyyYpOXp1aWnN6kiSfR3ocJG7Ze9oT4U+FzxZ1Cds0MkevtnWKLSAzc17hyoMwXL4fguTMz2IHDeVKaOZgjBYOJmz4Lg+ev3oLv8hk+EUlwz8qBTHJki2daihXgYFmdRiQrZNGNeiqV4Nm9UpShTd/J1D3kYrTpIznSKCDLJ/Sc7i7K63QJvN8Kk6NtZVRS0cFpjqq/JxlFahUHEfEZbBDgVdwAkKephUoWmikb2WkwVxdBytd7sxKmipQkUE2USQeoeI0QxTlSaCCsK6VDo/yyWSfOrGFQTQSt0dRbBUVEJqU1z2mjpyNuRYa1zdGA3t9VJQw7aGNGsWP3nEPR0q+VKByZX/jnHLn+kawtdEpUphyWtLTTNy7H4F7DyILFKZ0v6amGqhX1wAOdfVRo4bk502dRoro9fEmfmgcUkS8yPy3o6unDFNTTZiYacC4lgY0NKvIxamn1/RZ1kukpzxHRloudy9pc5uT/Yo5m8RFff3qHceZ5o//lAWiBJDZfqXK5dgeSolETKqVeI1Sr1EFNbSrc6dVGuh1S0nOgdejGDzyiEJIUFLe/VMxbm+vjzbtbWBrp5fXqeX1wzMGBw8/zOtMV61aDoMHNmRxGf0d8YS37XHDZZFPsnaNapg3vS30dJVYFDlnxUWEx6TzWjVpmCvHfFJs8LRV57nDTn6562d1YhrO6OWnhXG9dU0sH9cWb9+8/u4Cpm9ZjBYG8T7nzy8oppZVjD569Ig5oqmpqVBT+zzZ6tq1K//tiRMnsHTpUh7hR0YKOhExlJWVsWDBAowYMQLfA/+4YvTDhw+wt7dHYGBgkepf3g9UemomBrqu4y/fkXsz8oqWt6/fo4vVbC7g9t2fBdUaBTtEUztvQLBnDPpMboWeE4paPBFyMnIxtO5cjrPsN6s9ekxqVaLnSUUp5cDTSP3J9QC8FSWeKIrq6lVYGV+nqQXqNLPkbuuX4GlwItaPP4hof8Fk3b65JSZs6CvTzupF9iusHH0Q/vcj+OeOQ10wcHZ7qV1UKkAXDtuL7PRcVKhcFnN3DISZXVE+KX18T+2+h31rb/DPtk6GmLGup8SF+PLJJ9i28iqPuowtNDF/fU9ULqQKp3/bs/VOnlCJOFWkmC/cUaAx2eoVl/HwvvCFJhuZCVNa5nUPxKCIvLXrr3MnQWxzMmNa6yKCJnoepEDevsedPUCpgOjXywE9OtsXKUboc3vDPRTbDz9g82h+nNY6PJLX1iza1aTb9vCL5SI0QhT5SV2v9q6W6NnGFtWlKNipyPEMjMd5tyB4BMTlFYzUIaPuZysnUxbSyDopU/fUNzIJj8MS4R2eyMVnYVBn01xPHWY1VWGiowIjLWW51OP/RNBJV6AeZCMmOQuRSVmIScrC23xdZjGIv2mspQyzmmowp0NPjbmpxd7+uw/cLSULLc+g+CJ8U4oxdbDU5a4pjfYlvc5suRSbwUWpm1c0UjI+F4j0eaxjrs2FKfH6KlcsuqZkZb/CnYeRuPMwvIB/KXM9LbXh7GCIBvYGzB0scr/R6VyUkhr/Wb5xMxWmDvb6aOBoCDsb3SJcbOZ2xj9jf8sHD6PwNLZgnKqaWmUe59NhZalV5LsqRkZGLgt9yBEjMCAxjy+ZHzTGNzBUhb6BCvQMVFBTTxmaNapJ9e+UBXrsNOanSRB7in76kzf99JUT1PT/xyp5KkJJXCuvzVT+209Jfs5d4OCgRAT4JXBaUn4YGqvxOtaosWmeOv5zrGsYTp56kudyQK9dl8510K2LPV9mAdODSGzZdTfvPevY1gbD+jfk9+mxfxwWrb/KfGEKo1g4pS1qW2jx52vBpmvsgWxprIHV0zogMeMFxq44jZdvPrCTxLopHbD/6hNU/v0X9Ghe7187pk/6Cp3Rn8XoX4hx48YhOjqaSbwlLUbpwzyt9172gpuzqTccXD939KZ03YwQ71iMXNARbfoWVFXfPeONVWMPorpaZezznF8kv1eM2yc8sXrEXvZ8W3FhEswdileUyyM4ivaLR6TPU+Z9psVl4kXmS7x9+Y4XLOq+/k752UoVmfdJnVOdWhrQt9aFcqGCuqR48/ItDq+4hAs7qQv4X+5mDl/WHa7d68ksRoI8o7Fy9AEuLIkkP251T7hIiewk3D7jzfGs1JWsoaeM+XsGS4ztpIV7w9yzcL8cyD+36VkXw2a0LtKNJmPqbSuu4uppgafp0sICE+a3w2+F+HDEv1o2+yz8veP45279HNF/uMBxyo+oyDQey6elvuCTBBnZt+1Qu8jr4Ocfj+UrrzDXjW5jIHFzu9oX4YSlpD3Hqg034B8k8DZNjNUxbXwL9mgsjLCoNGzYc5f/T9BQrYwxA13YILrw/Ys7oXtOPSpQhHZqZo0erW3Z6kcSiEN4wT2YDxIHiUE2Q+2czdCojmGx3p9syp7xHA8DY/EoJJ67n4WFRdTptDHShI2hJqz0v9zSibikz3Jf8+g8+9VbkZr+HV6+/cAj7DfvP+Lth49C3OenP3j0RxGgf/z3f7zxI/yH/qMTPx2//MIbAuKYlvlNUNaXK/0b81Er/F4aFcuKlPXlf0fVCr+jasWyqFK+bIkV9rTBSM56gYiETKYphMcLBz3uwlCpUh4W+uqw0FOHpYE6DGsoS71fei/IiJ+KUs/AOPhFJOclLhHoOVoba8LRSpcLVAoYkHQbMQlZcH8SDTevKMSLOMlirqdlLU32nSXbKBIzFQZ1Ou94RLAqPzafByl9d2wttNGwniHq2xUtatn/MjwF7g8i4f4wgke++Uf51CmlPPN6dF0Jn+X0jFx4esbA63EMWw19yv+8f/0FpiYasLHWgY21NoyM1KRujOn7GxqcjLBQOlLY7F3S6J06iuT1W0O7Ghem1D2lVChVtcpQUqr4l4mYaKOcnJSNxIRsxMVl4WlMBhvT5zf4F78GZhY12JOV7K/oceZHevoLToK7cjWQx/gEKjzbt7NB1852eRQIEqdREeonsnOiRKVp41rA0rwGj+V3H32I4xd88njsi6e2ZTHl4Yve2H7sARfc9WvXxKLxrREZn4UJa87xhs3CQB0bpnbE2XvBWH/yHv78+B4Bh38KmPLj55j+O4EK0IkTJ+LMmTMwNTX9omL0wNo7uHriCdr3deQCRozTO+5iz/LLsKynj+VHRxYxZqdRPaVeTFzbC0261ZV4P7R4rxy2G26nn6BStfJYd2MG1GtKFp383UHFLkWdHlh6Hi9EalTKlqdCtJoMrukfn/7E0fXXcWLjDT6x1NBXwcwdA6FjLJkgTcXnzsXnceWwYJZs18gEU9f3RjkJSSwZKc+xaMxhPA1P5UWehGite9SVmMtMY3kSKtEXd8BYV7ZuKly4kRhh0YzTbH9S5vdfMXlOOzRwNSnyvp4/44Od2+7wiU1FtRLmLOgI40IRsSRS2rP3Hk6d8eafNTWqYNaMtnzCK/D6/PlfnD7vg72HH7K3IHU9Bvd1Qqe2tYucGLOfv8GOw/dx7W4o/0zFYL8uddGlTW2Jo0vKMt9zyhOhMULRSsVUp+ZW6NnaVmIni/PDo1Jx+nYA3Lyj82yPqIvR2skU7ZzN2RNUGqiLGhSTinv+T3E/8Cl3N/KDuJ11TbVhZ6IFW+MaqFJBsQ79pz//REpWLpKyXvCR8iwXqdkvkZbzivmaJC763qCPVLUKZZm7yur6KhWgWqUC1KpVgHq1SkwxqFSujNyWafSdSUjPQWhcOh9BT9O4k5pfKCZ+b6ljSkW9jZEGzHTVpNo+vf/wiROvqDB9FBjPwqj8oGK0nqUOHC1rwtpYQyJfMz45mwtT4phSNGx+EN+vga0+GkiJJU1IzuZRvptHJGITPxemtEEjoV2DuvrsYUoRr4Vfi7CIVNzziMR9jyjOM89/XbNaGlyU0kGbuMKvMQls/PwT8MQ7Ft4+sUgv1BUk2yczU01YWmjB3FwThgaqUruc5FgRF5vFoiUqTIkmEBebyaN2aaDHSN1GmojQ/ymjnZKNiItOpvEkuqJCjzbrv/32C1NR6DqcwPQ/gTNKaw6dg+i5UPLbK6Jm5b7F8+dvWbBEdIC0tNwiRWd+LipxYakAtbLRhpl5jSLd4ddv3sPDIxq3bofAPyAhj2pRrVp5dGhXmyNbxclYZGC/74gHhx3Q3xHlh1w+enatyx39yKfpWLrxet77TNZNowY483u5fOdN3PIQpmSdmllhfH8XFkFO33CJN4xEK1k7qQOueoZhxREhTnpAcyuM7tr4h1fTyyNgIvES8ULFdQ+N4AsLmHx8fFiRT7h58yaaN2/+U8AkDzIyMviFO3/+PKpXr86WBV9SjPo/jMfyScegY6CCbRfHF+SGOgmZ9QcfzUH1QgXXqa23sXfJBahqV8dO91lSeZfv337AlNar2AhfWbMqVl6eAlUFct2/N+hD7Xk1APsXn0NipFDQaBqoYvjSbrBtLCRtFIdEioobfwhRAcJumQr3kYs7S40UTUvMxrLRBxAdnMw/9xrXFD3HNpUo2vJ5EIkVU07gde47VKpaDjPX9YSFhBF+kE8clk07hefZr3nMTop5OyfDogXmiSfYueEW8+zIimXuii5s0ZIftOivXn6ZRQ8ERydDTJ7eGhUK8d+iY9LZ9JnGhYQ2rawwfFijIos+dRNWrr+W579oY6mFyWObQaMQ75LGV6cv+7HyVGw+39zZBMP6NJCYhkOq+F0nPRAkEqtxJ7SpFXq2rcMpP4VBnYubXhE4dTOABQNiUBpQp8aWaGxnKNXqh07KPhFJuOMbDXf/GPb3FIM6dbWNasDRQhcOZjrQVpWfY5f8LBfRKVnCKDstG09Ts5GU+QJ/iDqY0kCcy+oVy3GhW7VCWfY0FbqYZVCuzG8oWzqfor6UcMIvJVLUi0/6dFKl+6Hn9unP//Lr8+7TJ3YOePPhI3cqObP+7XvuvtLxnI5X74rNqBeDlP01lCpBW7mKoLJnpX1VaKtUwe9yeLgS5SE0Lo0L00DyJH2aWkS8RK89pVfVNtJEbUNN7qJKG8VTdCmFEtBBwrT83qv0WtmZacHRqibqWehI9IRNzczlopS8TEOiUwu4DGirV+VuKY3yyZmh8ESACtN7ntFw94pCdKGRurG+CpzsDLhjqqtVvcBnhx43/b2HZzT77tJ3KT/IUN3eVhf2tXVhbaFVRF1P109OeQ4/v3ieXlDXlCzWCncNjY3UWJhTy1gNtYzVuZCU9hmm2yTrKFKiJyVls1o/NYWOF8jMyC3Qlf0rQFxOLe3q0NZVgp6+MvQNVKFbU1myh3H2azx+8hQPH0XB1ze+wGOlrnHrVlao72iYx9VOTsnB0VOPcf1OaB432cXJ6P/Z+wooOc5r6RIu8ywzM++KmZksy5aZkzhxnDj8wi/JH78kL2jHiZltWbZsMbNWKy0zMzOT+D91e7p3ZkGS85LYsXRzOmNJuzM9PT3d9dWtqosvPTwfri62cp16bdtZbN+dLgsnGiq/99XlssjgQuaHf9gtk8nIqn/joUXYtCwau0/m4dnXjsjP81z79VNrsSspD79997g8/0OrEnH/kqjP3MD0eZjA1NfXh7IyJWElNjYWv//977Fw4ULY29vDy8tLop2effZZo2innJycUdFOxFR/+9vftGgnOutvRzvdoPhFZ+wAhbk/+tGPUFVVdVNglPpSboYfuqenp3zouDIJW+f8Sm5+bxz9HpzcbEe16hkfdPdXl4wCmY/M+rmwo9eLeVKnEX17zW9QX9YMexcb/PKDp+EXMXbMzuel2LI8tz8b7/x2D8r1bWPGNN3z7TVY8+iCG5qeyKTuePE43vrdXly6cFnC75/69V2Yty7uuqM92ZanLpb60O/84V4kLggd87nffu4o3v+7coEKjvLAD/94LxxHtJf4Hra/fgZvPHdUPl8uOH5CA9KItjcZhN//cjeSTigr9LmLQvHMj9aNGu2ZlVGFZ3+1S242vJg/8eRibNiUYBwMfeUq3n0/GW++lST/bWdrjm9/a9UokxJzE19/9yy2fZQiF15LSxM8+ehCrFoWOeqGm5xeIS75Or1mLTTABU8/tgjhwaOZ5dySBry4LUmLaCKjtXFZNO5flwj7MZzMbV19+OhoNnYczdEyJwnmls8KxeYlMQj2cRqXAU0vqsOhlCIczygzYiQZozQnyg/zY/wxI8JbgNf1iu+xsaMHeVVNyGdbuqYZRTUt6BujNc1iu9yLIM7JVhz1bvbWwrgqDKSlvN6/a2DEWMeFgLS1uw8tXX1iUmrqVNz1fI8E2G3dw23mkcXd5vvxd9MhwF2HQHl0EMA6ZdL4+kCe3xUNbSKFyCytR1Zp/SiDFFn2cB9ncdWTlY72Hzswn1pTslPUCVMj3D5if4O8HYUxZUt/rLzYts4+yak9lVY2aiypg60FZsf7SdB+QoTnqOEJDU1dOHW+FKfobi+uNwK1nFs+O8EfsxP9ER02eiyntONTypGcWoHM7GojGQLfe0SoGxLjfBEX4y25piMlDfy+VlS2IDunFjk5tcjNq0V392h2kWwmo9gCApwR4O8Efz9n0aHeKEuWn1FnR59MiWLLn6kblAR1dw2gp3dIDExkOsl40oApEpLLV8QUyf9NnDBBuj+UVFBaxM6NhTmnMJnC2tpMIqLItjo6WkmmqYurzZjxVmoReOfl1wkIJyAfqa3lHPlFC8OwZHG4vD9tQEp+HT78JB2nk0u0zycxzgePPjAXoUGu8jPHkorx19dPokUv71k0JxjfeGyxANKdR3LwpzdPyAKP5wPb8hxR+/y203hnnzJ0ZOXsUPzXo0vxzqEMPL/jjPzd/SsS8MCKBGnTO+ocbnkweuLECQGfI+vBBx8U9lMNvX/xxRcl9H7OnDn461//iqCgIKPQ+6997WtGofd//vOfb93Q++9///uC4q9XpJRJIX/wwQc4efIkJk2adNNglE40usNGlroC+fZ9f0d+ehW+/F9rsP7+2UaaRY6bdHKzw6snRzviD7x7Fn/6znsiJP/78R+O66xX59b/6M4/SfyRidlUPPX7+7Dkrpn4vBXzQo9tP48dzx9Crd7Fb2ZpgvVfWozNX1sOy5swPjE7lMelPE9hNxMWheHp32wVje1Y1d87hBd+tgNHdyh6orAEX3zvj/fBaYzj2drUjd98+33kpVfJn1ffPR1P/GDNqFZaV0c/fvfjj5CWpKwcl6yJwdd+uAamI5jJ/Jxa0YfS3cqb2+NfX4r1WxKNwAwZgtdfOYkP3kuWiy+njvzXTzaIcWFkzMyzv92LYj2DzJna33x6hQREG1ZaZpVMUVLdwvPnBOPpLy+GwwiGkzmhf37lGM5nKu/V3tZcRuSNNcKzuKIZL36QJKMfWbxhrVsciQc2TB9zZCdHT753IB2Hkos0sEBDyx1LorF+fiRsxnA68xJRUNWM/cmFOJxaLLpMtaiVXBAbgEXxgUgI9riu052vV1LXioyyemSV1SOnogFtBs+lFllLP1cHBHk4wt/NQTZfF3s421r9QyHyn5cavHhJYp9qWrpQ3dIpUoaq5g5x2XeNIzPg5+nv6oBgT0eEeDqJmYnHZTwWVYwqbd2yYGBaAVMLGtuNDUwEY1H+rkgI8UJiqKeYo0ZOYJJxkdUtSMqqENaUY0sN7xTqJC0CUz6OPG+o+TubWYHTqeVIzqrUWH2VracBiq78WXF+AkwMq6OrH2fI1KWUIT23RptXr8pTEqK9MSvBH9NjfeA4QqPKtIr07GqkpFUiNaPSyJmv5qhSyxjLVnWkF/z9RuttJTqrrgP5+fUoLGpAYWEDKqtax3S705zj5ekAb28HeaRj393dXnKDxzNI/TuLhqEq6kYrWlBS2oSiokbU1LYb/QwveWzfM3GADKiPzzATLSNaTxRg1/5sVFQNj2idkeiH+++aiQh9NnROQR1eePOUNqWLC4hvPLZIPqfWjl48++Jh7RqVGOWNn3xVmV7347/ukwUQ69ENM2SjPvS9I8rgkEfXTMeWxTH4yp8+gr3ZZPz9O/fe8mD0i1qfKRhtbW1Fe7vxF2Nk+fn5SSwBEbwxE3VFgOm9994rdPSnZUYJRj9+4wxefHYvQmO88Pv3huMMqMt5YPYv0N3eJyzdog3xo5g3jgctSKtE7Nxg/PLdJ6+bAcpRo79+5EVknCiQP89ZF4+vPHtjzeW/o5iNuv/N0zj83ln06kXqNCetfWwhNn5lCWzGMCSMNdLzrd/uwd43z8gFm2zo4z/ZiKVbpo/LVGUnl+L333kfLfWdAjDuenKJtObHisJKOpyPP/74I2nLM3D56/+9EQtWx4wZ2/SbH36EjtZeman8le+txoqNcaMYzPdeP4O3Xz4pzIObhx3+65d3yEg/w+IF/Ne/3IlyfYTJyjUxePKppUY3GD7X9g9T8NobpwW4kuV86qtLhVEwfE3mKT7/0nHRVrEcHSzxjSeXSmSN0XHsH8Lr25Lx0b5MeW4aPDavjpMcPjIhRvtX1y4glC1SFlteqxZE4OE7ZoyKaBKWNacK7+xLQ1qBMqOeRYPA3cvjMD8hYEwDDF3Ye5MLRLdlqAElEFkUF4hl04LFhDTeRCWeC2UNbThfVIPU4lpkltWPMuSwTc74pggfF4R6OyPMyxm+rvbXZQOvVxz1ybZ5h76F3jM4JCYmvi7b7HSsM8yeJqYLbMWTgbpGExNb9MqlkJ8dz0m+rykyHlQ1Mk0REGhhqpiZKAFQZQC2NDNZKLKAf4SdZch/RVM7yhraRZ7A48bHsRz2ZMoIzsO8neWY8dgFuevGzVel1pZpBpRUpBfVonkEc0rGOTbIHYmhXpgW6i2ZpyNBPyds8RwiOGWElKE0gPvDIQc0QDE6KsjLyej3eYwz8mtxOq1MxpK2jAhkD/FzFlA6O84Pwb7ORr87OHQRadk1SEotk05BR5fx4oUh+9NifDA91heRoe6jJCU0B6ZmVMlCMCunVuKnRoLT8FA3RIZ5IDLMXVrzY43LJcgVQEedaHmz6ESrqtuMgPLI4mLU2ckazs420uIXvaidhTCstrZmwmoyTYDXlE97zoj7fuiSgEVeX8i2tnESGeP9mrsl/5Pt9LEYXpaHhz2iIjwQG+uD+Dgfo4UzuzeMlmMGLBln1XxITTuHEmxen6CNIc4vbsCr284iRb9w5kLjno3TcM+GRDH4fnI4R0xKjGjigudLd8+R0cIcffuj5/fK8Aaefz96fDnmxPrhxy/tw4lMZQrcN7bMx7LpwQJEK5s6YGs6Ecf/+I3bYPQLWv8R0U41NTUCJNVihtby5cvx4YcfSsyTh4fHP6TNYI7l/QuflRvRS/ueMQpIf++5w3jzf/eL6eaFA98ZZSipLWvCUyt+K4ziA99dg61PL7/uaxNcvP+/e/Hu7/ZKu9nc0hSbvrpUAJ/FGFq+f2Uxfur0zjQc334eRenKapXl7OWAdY8vwor7546b/TnyPR189yze+M1e9OjDshdsiMcTP9sEu3Ginhif9fpv9mL3W8p4OBdPe3zrf+9BxBhjQAf6L+DFX+/BwY/0Tsxwd3yf7fYRznq65d98/hg+fCNJLtLMDf3B/2yBb6Cz0c9xaspvfvox8rIVQLZweQS+/r3VRm15ngs7PkzBKy8eF8csDQbPfGcV5swLMXou3oh++7t9wpywGBfzrWdWwtEgsonPxRGIf3v1hLTjeL/ZsCYOjz841whc8jjuPZqLF985o41KpDv+aw8vhKeb3SiNHt3xB08XCojicy6dHYrH7pwJD5fRetODyUV4d186KurbNdC6MDEI96yMQ7i/65iaRGpA9yTlC3hRizd5tt9XzQgVI9J4DChb0ckFVUguqBYQSmBoWGylx/i7ITbADdF+bgjzdpGb0U2PA+3pQ21bN+rbu9HQ0YNGhs139qKlpw9tPf0CPD/LIrjm9CedlYXoVx1tLOBkYymsrivNTCIpsL6p98z3y/dZUtuKotoWbTNkprXXnTQRwR6OYl6K9HVBpK+rGKbGSlig/ja1kOCUUVu1AtoNiyYrtvM5anR6qBc8nGyNnocMN8HE2axKAafldcaEAlMaZkb6SHQUp0FZW5gavT5NT0npFQJM1ZQHtexszDEj2gczYnwxPdob1pZmRsejpKJZQOm5jEoUljYasbU8R6PCPCQyKCHKC4EjgC2/Z+WVLZJakZldI21nxqiNyhT11iE02BUhQa4IodbSWzfm+c7nq2/oFH04daLVNe3CqDY2dMr3/WaLr8mJU2RZuYimEYhteYJ8fsGvXb0mMhAaQmUy2NAlDAxcvOkAfFcXG/j4OCIwwFlMlNS/juzacNrb+bRKnE0pQ2p6lRjd1GJG6KplUVi+OFzAMz+HlMxKvPdJKjLylGsE748cssGMY2rZKRv6w2vHtM+XxrYffmUFPF1s8dqu83ht53mRKfHPz359rSwAvv3cLjnXufj76SPLEeLjjK/+ZYcYFZkg8dtHliEy0Oc2GP2C1n8EGB1ZN9umHw+MUkfBR9ZPv/w6Uk4WY9NDc/D494YzQft7BvHQvF8KG/f0r7dgxd2jndoH30/GH7/1rlyof/Tyo5i1IvqG+1CWU4PnvvW2BgI57nPZPbOw/P458A27OVD9aYsfcWV+HdI4gu9AjkxlUj92xk8lLo3EqofmiTHpRtOT1OdLPZqP1369C1VFSmvaM9AFX/nFZmGKx6uU4wV4/scfCRvKWrl1Bh77r3UCzEdWTkoF/vDDD9FU1ynHd/Oj83D/U0tGaVarylrw2x99hHL9fnC2/Je+s9KoLc/9Pbw3G3/93wOizSK7+tR3V2HJqiij52po6BSTUo7edDVtuj++9b3VcDAAmNRyvb/tPN56J0nYUILKJ7+yGCuWG2s+K6vbpCXPGx4rwM8J335qudzkDCszr1Z0oaWVim7L290eTz26UJgew+JknNd3nMPuY7lae53mkMe3zIb/CGMctX8fH8vBtoMZaNWz3RyHuWFhFO5aFjsmc0q39s7TeTiUWiwshlqJIZ5YPSsMC+MCJdZozPnf1U04nVuJM3mVApYMiyaY+EAPJAZ7IiHIQ1rMN5pNTyamsrkDZY3tqGhuR0VTB6pbO1Hb1oULN2EEISC0tVTYShtzU83AJCamqVOE4aQ+durkycJ8EsgZjgalT+rqtatynC/pjUxDly5Lm51OX0ZEUdfaO3hBNpqZCLr57zdbOmtzuNvbwN3BBp46G3g62sLb0Q4+Tnayv9crTn0qqGlGQbWy5Vc1jdnmt7M0E1Aa7e+KKAH+zqPa+/z8OGo1tagWKQXV0tYfycZSl8t2/rQwbzkfHGyM2+rN7b2aCYpToQyncqms6YwoHzGmcEqX4efPGLHkzAqczahESk6VjF81/F3qpDmWdHqUN0IDXI0Y/K6eAWFNmWGZmlUliROGReAUE+6B2HBPxEZ4ws/bmPEVrWhVK3IL6pFbUIe8gnq0GMyvV4vgkICU32G29QnOfL0dYXOdBTvHaNKxT5aypbVH9ObM3+zo6ENX14CwmcwgNpz89I8Uuyc2jBWzM4eDgxWchIm1FpkApycxamosuUBnV7+875y8WolkKtfnh6rl4mSNBXNDhAnl+1Y7NxwB+8n+LFTr4714v6Ch8v47ZsDd1VbyaP/+/hkcOavkKvOa8cRds7FpeQwq6trxy5cPyYAG1orZofjug4tFsvOTl/aL/pwLud99bT2u4hq+9bddcl7zu/H81zfCasqEz9zA1NzY8i/KGXX6TN7X56luSTCakVKE2EQFNJ0/XoifPfmmxAe9efz7RmHpH79yEi/+cqfEM7187AcyOnJkPfeDbdKenmo6RearR80ybr2OVWzzn9mVgbf/Z5fmVGd5h7hh+vIoxMwLRUiCn8yo/0eKgfsVebUSTF+YWo68c6VaLJNaIfG+mL9pGuZvSpRpTjdbuefK8OZv9yJPPy+dLfn7nlmJ1Q/MHTd3tb25Gy/+YidO7c2SPzt72OPpZ7cgdvbo/NXB/gt440+HsPMtJd7JydUW33r2zlFued5IPnknGa8/d1SmQFnbmuPpn6zD7EXGcUx00v/p2b04e1K5OIZFeeB7P98IVwNdKm/Ie3ZlSGQTg6dpEPjyk0uwel2sEcCkJvR3v9+vCf45B/ub31hhxIayrfjWe8l4f0eq7CONIo/cPxt3rE8wupHSsPHXN0+Km1iOo4UJHrlrFjaujDFiYbp7ByWPb/v+TGE6Vc3Vl++eI9NKRpqSth3MxI5jOdq8cEc7C9y1LE7G6VkZMFSs3oEh7EsuxCencmUGvFo0B62dE47VM8PgOsZUJu5HSnEtTmSX41RO+SjdZ6iXE2aF+WBGmDeifEfrEQ2L7fOC2mYU1rWgqK4FJfVtAkTHc84TaNLo4+ZgDXeOAbWzhjOjlGwt4WhjKYwkM0A/CyMTW/8Epe29/XJM+Chmpu4+NHX1obGzR0xNY7XeDcve0hy+4rS3hx83Fwf4uzjAycZizPel6kRpAsutakRuZZMsCkZmu/LYUXtKA1Osv7s86kYASy62+DwcTkBwSte+oRGJRVmFtPTDvCQn1tCpz3Mjp6QBZ3OU6KhKPSNvKPFIDPcWxpTjSg0d+tzfnKJ60ZhSX0jHtWFx6lN8uCcSIr2RGOkFT9fhhAZJBqhrR1pWNdJyqpGVX2ekU5XftzCREaVRoe6ICHEToMtZ8IbV2taLwuJGFJY0oqikESVlzTJVaMzPyc4CXp728HK3V/JF3e3g5moHV2frUc87VnGf2ebnyF/u69DQRYl442dAkEpGlDdnvkMypbwukP0lg8ooKgbv87+vd67zNfieKqraBHiXlDWhuLRZrj8ji+aumYl+MliAk9/4vLyGZeTW4MCJApxMLhFmlkUmc82SSGxZGw9nR2uZrvTmJynYdSxXfoe7tGp+OL68lV2gqXh9Zwre3KtcE60tTPDtBxdjcWIgXvjkLN7Yr0TgcdjFb766DmkltfjFO0fkfAj3dsZvn1iL/911Cp42Znh602cb7bTE60lMnvhPnsB09QKO1Pz1Nhj9TwSj/9cT6n9/th3P/HSzBgyfWP0H1Fe14dFvrxQGTi2CnK+u+h1qy1uwfMt0fON/7hr1nGy5/+Kxl3H+cJ4YlH766uOIHdHSve6UpWMF2PfmKaQczJE2jFq8ELj5OcLN1wlufs6wc7YWp7mJuYlcmHihujB4CQO9g9Iib2/qQkttB+rLm9E+xsQQUwsTRM0OQsKSSMxcES3h+DdbPEU4eYqZodlJJfJ3U0wmY93D83HXU8tkv8YqHr/db57B2386iMG+C8JKbHhkPu7/5vIxI54ykkrx559+LBmirBWbE/HY91aNmn5UR9bxJx+jQN9uT5wdiG/8bAMcHK2M9vnUkQL85Tf70NM9qMx3/9IC3HnfLCP2t6G+E7//zV5k6SdKRTFi6QdrJKxaLbpcX3/zDD7akSrAlVqvr35lsZE2lK93JrlM5sk3tyqSEgZyf/3LS0Q3plb/wAW89eF5GeHJiy2Pyfpl0Xhk6yyj/E+ykx/sS8e7u9M0pjIyyA1f3joHsWHGiQx1zV14e18a9p7O15zEzAS9b3UCls8MMdISqizoRydyhAVVby5kChfFB2H93HDEBXmO0gyS7UrKr8SxzDKczqs00n6ScZwZ5o25Eb6YFe4DB+vR7n2NhWtqR1ZlA3Krm5Bb3SjAc6wrELWXAa4OAsQIyMgYMg7J1c76Hw6WH6skw/HKVQG/ohuV279S4mKeOMyc/rNer3tgSNrvddzalMeaVsXU1NozvuOex4Qu+0BXxW0f7O6IAFedRFaNLILCotpW5DAGqqIB2eUNaB3Dze/haIPYAHcBp5RPMGLKENzwc88sqRNwyglabKMaFr9LUX6uGjiN8HUxWkw1tfXgXG6VjCmlUcWQdWf5ujtgeoS3REgxfN8Q2NKRzbxcbqm5NcLMGZaTgyUSIrwRF+4pmyHjz8+0uLwZWXk10krOLayXeC7D4jUh0MdJ0ilCA10QGugKD1djSQI/LwK30vIWWYSWVbZI16NxRE7pWECV7CLD7qkRp0mRcUtMtrCVbFFFL0pQ94+a8ni+8nrS0zuoZI129svkKzKxjc09IiGgZnZwcOzFD9neSDLHkZ6SNKAODiAYzi6ol3SDE8kl2pQ3+R1PB2xYEYPlC8KkK1RV3473dqdh/6kCbdEyLcobT947D4HejjiRVoY/vXtSmwI2P94f331osWiOf/LyARnwwLpzYTSe2jwHz+9KxnvHFfPSwpgAfO/uhfjhWweQUlqLCZcvIvuv378NRr+gdUuC0XUzf4JtR3+otXIP7UjDH374kWRWvnboO+KSVysvpQLfues5+e+fvvgIZiwdnbF5cegSfvHYS0g7XihA8eu/2Ypl4wTiX8/klHo4F+nH8pF7thQtIxyPn7aYbRrAKJM4X4TPCJDHTzuLnqvYc4dy8eFfj6AoQxGo8/0t3zoLd399GRxH6BmN2vgnCvHyr3YJkGcFx3jha7/cjIDw0VKErvY+vPybfTi6K1NjQ2lSip8TNDo26q2zePMF6jkvC4v9+DPLsWKT8fSjjrY+PPfbfThzXIls8gt0xnd/tkEeDd/bxx+l4rWXTggbQYbh0ScWYv2mBKObA/P3/vjng2huVi6mjDwhEKUJQS1e8P/8t6PaPHnehL7+5cWYPSNwhC40T6aRdHYrTCJdwV97eAH8vYe1ygSHHx/Oxpsfn9cilwJ9HPHEXXMwK9bX6H2W1rTijd0pOHq+RMu4jAxwxf1rEjE3dnimtAoqDpwrxPbj2UaAgpOQNs6PEi2oobaPxZY0Aeih9BKczq2QP6tFLeSCaH8siA6Q9vtY7CeD6tlOTi+vR0Z5vYBQtrVHloutlRiXQjwcBWCFuDsJ03mz7CZNSwRxbb0Dohvt6BtAZ/+gtPi6B/RTmIb0U5guXlImMdHAxLGLV24u/5HAVDMyTZks7W6CQEtTE1ia6qcymVESYAI7MTOZwZ6bpbloR61v0tjEfaxq6UBVS6cA9fKmDjE2UaIwMuyexaf0crST4xbq4YQQDyd5ZIt+rBit7PJGZJU3IKu8XkxSI6/+zGeNC1TAaWygOwLddUZAnEYrAlNhTgtr0DBi1CiPSWyQhwZOGVOlnocEOXnlTQJOU3KrUVjZbJTNStDP8zch3AuJ4V4I9xsGttRMFpU3IzW3WmKjqEkcyfy6OdkgNsxDFmscLck/q8ecQIlAMqewXoApGVhDkGXIngb5OSPY3xlBfk4I8HES3fZI+RKZzGpOOartQE1du+SW1jV0oqGxaxQje73isSEgNdPrRRl5NWXyRDFyimaUnx2U0HsePzKpQxcuywKZQPRm7t7cdw83O5EXBPJ9UTsa6GI0ipXMZnpOjRiRKHswZIM5+GLh7GCsXBiOMIlwgkgqth/I1BzyLC4IHt08U45/Xlkjnnv/FDKL6+XfnB2s8Mx9CzA72hfvHM7AizuTcfHyFdEn//DBpZKL+4NX9iK7QukUPrZyOtbMCMPTr+wUmQ7Pq19sWYCliZG32/Rf0LolwejiiO/imZ/eiVWblZGUZCS/tOYPaKhpx9avLMIDX19q9Hsv/XIndrxyEpY2ZvjL7mdGzaxXHfi//+bbOLkzQ/686r7ZYuQhW/qPVFdrDyoL6tFQ0YzmmnbJLOVIzqGBizKOkxdZSgPYyrfiqtvZRgAomVTPIJf/kymK7vgjH5zDrtdPo0k/vo9MKAH2nV9dKm328aq8oB6v/L/dyNQzqLYOlnjoO6uw9M5poxIHxAD1URpe+/0B0ebyPa25ZwYe+ubyUbPlSwsb8Mef79S0oXEz/fH0j9fD2SAflqfyoT3Z+PsfD8lIPF6Etz48B1sfnmuUTVhR3oz//Z+9KNY/V0ysN5757mq4GbTuGQT9/AtHcOKkAmipxfrG15dhxvTh3FAaCd7Zfg7vbU+RGyOZlrvvmCaRJ4Zzs9Oyq/GX145roxB5c/vqQwuMRnjyRrP3ZL7Mj6c+VH7O1Q6P3TkLi2cGGwFLtkFpAqBGTy3q8R5cO00mlxiCnuqmTnx4PAu7kvI1Voqgaum0YGyaHyURP0ZxVleuIKWoFgdSi3A8q8yopczW+OLYQNno4B7J6IjBpKEV54prhMkgAB2poySIi/JxQZSPKyK8XRDp5TIuk2q4TzQq1bR1CSir61DMSw1se3f1inP+815MB3CkocnaQoA2AbirmJqs4cbN3vq6gJUSAAJUHl+CyJKGNpQ2tI3LpKoAP9zTWXvkjd+wuDBgaL5EbZU3iPaUAMGwCLTZzidAjQvwEN2p4cKDI0xTChRwOqYZytIUCcGKGYqmKEPmtbtvEGn5tTifp7CmKntmqDfm+ZwQ5oX4ME/JOVWBMQ022UX14tLnVlTRNAqs6+wsER3ihihOpQpyE6ZOBbcCzlu6kV/cKKN1aYaibtswo1Qtxsf5eDiIc9/PSwcfRjm520t7eiRI5fPSvMTpRNSfkqVsbe8Tg1Bn14BoNakXpQt+rNf6R4pAloYkO1sLYWGdmDfqZCO6UYJQajkN2WpedzlwoKC0SYB5dkEd6ke07amHnZPoL6NaObKV18/G1h4cOFWAPcdz5b9Z/CgZ0XXfukREBrujuKoFL32cjNMZ5VrH5Z5VCXhwzTSJdXv2rSOaJGh2pC9+9OBSZFc24JfvHJFFI8+3nz+4XAD6d17fK10ELnz/+Og6eNiYwc7uduj9F7VuWTDq7eeGF3c8pV1Mkg7l4ZdPvyOr07/t/iZcPe2NxlR+967nUJxdA59gV/xu+1Njjqhk2/3dPxzAO7/fL39293PC07/disgRweefx5L2bUo5DrybjNN7MoXtZbEFT2C97tEFsDdoN4+shqpWvPXHgzihB+OTp07C+gfnYuvXlo7pzC/KrsFff7kLpXnKytkv1BVP/XQDQqK9Rjnq33z+KHa9f16JjbI2wxPPLMfS9cZ6zrrqdtGGZutzSANDXPHMj9bC3yATlODxrddOY/sH5yTWiS76J76yGKvWxGjPxQv1zt0ZePW1U+JYJeDatDEBDz84VzMCiAQgqUTimtSWfEKsD57+ymJ4eQwvVKpq2/HXN06K+1eOpaWpxDRtMtCF8j0dSS7Cyx+cRZ3+hkAWgRFNjGpSW9Iy4jOvGm/sSpH54iwyJ4umBeHBtYkI8h4OqSeLdDa3CtuOZuJcviI/YHk42WDzgmisnR0OGwPmTD776mbsPV+IQ2nFRg54F3srLI0LwvKEIIR6KToyw2rv6cfZomokFVYJCCUjaViMO4rz90C8vzvi/N0R5OY4bpudgL6ipQOljW0ob24XVrCypUPa2DeavqSCPR2nL1lyTryZZmDixpscWUwLTmHSm5hMJ0+WBQR/l0YmiXSawBGMNDApx0VczDQyXbkiTCpZWALsAU5m0huZ+i5cFBNTj97M1CWGpgEBye19A2OywWOVlakJPDg21MEang628NLpTU2OdjJmdCygyuNf3NCGwtpmFNUrrnuC9rGKz80FQLiXMyK9XRDq4Wzk6mdrn+dBRmm9xHBlVzSMiuIiK0zHPsEpjWlsy6umKJ7LpXWtGmvKIH5DMxPL0dZC8k0JTLm56ay190W5SUp+DVLzqpFeWIvuETFM1IzGBLlLOz8u1EPOefVc4kIrt7geGQW1yCqsExZ1pNaVekvGSEUEuiKMm78LnBysjBaEHF3J9j638qpWlFW1CBM5VtHY5OZiCw9XO7i72MDdxVZmrkuck856zIgow+L1iOwmrzOiGb1wSUyRqmZUWONrimSL5yk3Sm640DXTB99TNzrehDRey9i259AMXov43sqrW+V9qfIctXidCwlwEeA5nd20IFe5NzLzlaNfObqT4F8tKwsT0YRylKe7sy2ySurx5u5UbYHM79HKOWH40h2zMGEi8NxHZ0Sfri5QvnnXAsyJ8sVvt5/A/hRlwU996K8eWYlDWaV4ft9Zef88V39x73L8+pPj8Le3xH/dtfK2m/4LWrdsm/7CwDV891d3YNFqxQHPw/CDR15B9rlyxMzwx/979VGji39rQyee3vBHmbwUPSsQP3/lUZiMMWKPlXGqSFjSdr2uaP76ODz4vbVwHRFJ9Hmo6pJGYXOPf5ymsaAsn1A3rH1oHhbdkTgqMN6wmmrbJQbryEdpwtiy5q+NFTZ0LAaZ4fVv/OGg1pI3tzTB/U8txdp7ZhhljArgO5SHF393AO1689X8FZH48ndWws7B0mihsO3NJLz/xhmJYmIW3v1PLMAdW/l8w6DnXHIpnvvDQW0m9Zx5wfjaN5ZL9p9aDLf+w58Pokw/opMxKM98YzkCA4YBLfVi1IWmZykgj+zIVx9fiHmzg7TzhewHs/d2H8oRtoYXdc5lJhBVHbh8f0kZFXjx/SSU1Shtc04peXDDdGxYGq3dYHiDP5VRhtd2pWguVN6AV88Nk3a8p7OdkSFp15l8fHAsS7IlNeYiyk80WTPCfYzYTLZtCUD3nisUvaJaBHJL44OwMjFE9ICG3wPuT2FdM07lV+J0fiXya42jeQhMEgI8MD3IC9ODPEXTOJYmjoxrUX0L8uv05qWG1usal0wmT4KnzlZAGkEVzUtkFBmV5GxjJaD3s5q+dKMigKWhifFTNDM1i6GpV9hePpLhbe8dHddkWATTBKW+TvayUUcb4OIgx2KknrVv6AKK6lqRT8d9bbNIJcYCqIz54udDlprglI8Ev+rnRSAuQwpK65FRWofM8oZRzCfPRYKIuEAPxAUopih18pa05SubJCKM4DS3vHFUa52LHU6GohEqPsRDzHP8HCWjtrYN6QU1ko1LsKOa8gyZU7b1o4PdBaQyqowsIYvArqCsCTnF9cgtbpBRpb1jGJEYQxXs5ywgNcjXCUE+znAxGPsp8VpNXaiobhUwV1nThuq6DtQ1dt6Q2SR41lEvyglJttzMxfnOAQFWliZiKKS5h6CVAJPfeYJNXi+4aQsjNdrpsjKeljmgMp524KLMku9m1mgPWdcBtHf2SY5rS1sPmlt7Rx1v7diZThEpAvWynGpFYxclCrwulde0ycACxm+NHPEaF+aJ1QsjsHB6oJwnR86X4INDmSK5YHGfl8wIwmMbZ0rqwhsHUvHu4QwN/K6bE46v3TEHaaV1+O0HJySmjL/z0PJE3DEvEj9//wiSi5Rr6/rp4bh3fgy+/dY+VLV2Yuq1y8j4w3dvg9EvaN2SYPSVP+/FB6+cg6uHHf6+4yltig9NTF/d+GcZyfbkj9Zh7b3Gk5LK8urw3bufF8d33Nxg/PjvD48L1Ohof/VXu2RaEw8xgdGC9fHY8MRCBHyGI0G5Wi7JqhbD1dkDOdq0JRa1snPXxmLFPbMQEudz3Zt7bXkztv/tGI59ko4r+niShPkhePA7q8bUhZLh/PDlk9jx+hk5vqylG+Px8DPLYWcACFlVZc144X/2ITtVWWWTpf7qD1YjYURSQVpyGZ7/3QHU1yoxIwkz/PHU91YZOeWbm7rxwl8O48xpxU3v6GSNp76xHLMM9KiMWnn5lRPYfzBHLrwMr3/0kflYsypGY85pEnj9nbP4ZE+GAEyyImzJ37tlhtaS503igz0ZePuj85pujK2urzw4Xxy32n7nVuPv25KQX9qoxZ/cszYRd62O0wwcZHWOnCsWTaiaEUoWa/3CSNy3KsHIhcwJPtuOZGLP2QKNieJozg1zI7B5YQzcHYfTEsjq0YS0KzlfXKvqt5+MFzWgq6eHYnqotxF7yRZxSkktjueV41RexajWMHWKs0O8MTvURwDNWNN8KlrakVXViJzqRuTWNKGiuWPMWe5kBwNdFfe4v7ODHnzZCeC8GaMHb9ps7XVQMzrAjYylwlrKbHkG30tE0yUMXb4sgOLiFUU7qpqYDPeLN0q+Lp3oCoPKSKhJMJlM3aheOzp1qjCu3Heyr3wkG2ur3/jnGwFlfi71HYqZqZYbJzW1dcpNmKB1vLn3Mq3KyV7MXgEuirkpyFUHZxtjzS0ZW4LTvJom5Il5rGlMAEztqwpMVZCqRk1JRFxThwDTdD1AHWmK4vFifBdNUQSnfOSULhaPOQEpwSmjpGikG5mVyTxJak65xQW5w8fVXnF1ExhXtyKjsBaZRXXIKq43Ct5XwTXZ0shANwGpEQGukgahgtuahg7klTaioKwR+WWNAi7H0uGS9fP3cpTINH9PHfw8ddKmp3ZSO8+uXJWuSG0jTUJd0tVga57t66aW7lH5pZ9VkU11c7aV6w/NR4y3CvR1hKebvZzX6nHJKqpHVkEt0vNrJW7LsJjasXhmkMiFyPiW1bZiz6l87DtToLHXvB6umhOGe1clyOf9/tFMvHsoXcv9jQ5wwzN3LxCAThB6tkDpYPm42ONn9y9Da28/frHtiHRWeC363h0LxXX/o/cPyXeWspNf37kQiaEBt8HoF7RuSTDa3NSKp+99FZ1tfXj0G8tw50NztJ/Z+VYS/vb/9ojZ5/fvfhkB4cq4M7Vyz5fjxw+/JGH3YfE++MmLj8BmjLGLanE0JvM4008oLQpWUIwXFmxIwJxVMdcdJfrPKH68deXNyD1XLk74rDMlWkA9i3FMcfNDJax+5vLIMV3uhs+Vn1aJHS+fwLnD+VpWaeycINz/zRUIjfMZ9TsU3O//IAXvvXAM3R3KRS4szhtPfH81giONQXlP1wDe/ttx7NmeKiwrJRN3PTJXPh/OZDYMr6cuVJ0pb6+zxFe+uRzzloRpN2Ayptu3ncO7byWJQWnipAnYvGU67me73XyqUUv+9TdOS7wKa/nSCDzx+ELNoERQuHtfFl59+4wWZM3JSV97fCFc9RO0+DyHThbg5XeTtJnMNEHQnMR8w/Hmx5MJuXNlrOit1HBvMhm8yL+5J1XalipYvXNpjExLstPf2KVtn1+Nd49kSEteLT83B9y9JFYMSer8cbUNv/NsHg6mFhvNfqf5aO2MMCyKDRRXvFpsz54uqMTRnDKcKag00o4SgM0K8ca8cD/MCfMRg45h8T3k1TYhvaIeGZUNyKoa27jkZG2BMGoa3RXTTbCbo9x0xgNuBCRkFes6u4VNbOzqRXOPwjRK6H0fzUuD4wK3z6oI7MXMZGGuhOFbmcPRygKOVpZwYSC+DR+t5N/HAtxkVslsUjNKGQOBPDdKGGjEGqsIhglKeUy5hbg7CrhXFwo8JxgzRYDKBUJOVaOwqGPluJKFJTCN9lUAqp+zg+ynGilFzanKnjIdYGQRcHDIgerap/aYnzEXTtllDTIVKr2kDgWVTaNa67aWZogJdENMoLtswV5O8h4kmaGuTUApt5zSepnmM7LIzrEdTzNUqJ8zQn2dNYnKhYuXUFrViuLKZglnL6lskSzM8cLkObbU280eXm52MmDCk1meztxsxHhkWGy/Uyva1tGHtk69XrR7QBhMXke48Wf6BxnrRKbz4k1njhL48bttYWEibCZBMjsu9jYWwsKSjSVopJGSMgR1Qc3vD0EzmU8OHigqb0JhefOolAJel2hG4kQs6kH5HBy2cTSlBIfOFcmiQC1KijYtisL6BZHy/NuOZolJklnHcu64OeDJjbOFuX71QAreP5ElnzE/w4eXJ2Lj7Aj8cfcZ7EtXruVBbjr8973LsTMtH++cVqIA4/3c8fTqObCeDAR4ut8Go1/QuiXBKHPKzh0vx+9/+jFMTKeIdlQ1wvBw/Pyrb0n+KF3df/zgyVHMHQHZzx59GX09gzJB6Md/exh++hm941VJdg12/P0okvZlG0U4+Ya6IXp2EMIS/BAQ5QlnT65Y/7EYGZqoGqvbUFPchIqCepTl1aIksxo9I1yjND0lLAjF9GWRmLY4/IZz5wnsTu/Nwq43TqMkZ3gqz8ylEdjylcUIifUe9Tt0vh/ZmYl3/3oULQ0KqHL3dsDD31qJWQagUZ6fEVDbzuO9F0+K8Yg1Z0kYHvvmcrgYgHU6SD94Mwnb306WfSLA3LBlGu5/fIE2RYmf37mzpXjhuSMS26TGNT31zeXw1Yc3szIyqvD8C0dl5jQrwN8JX//aMkREDLO659Mq8NeXj6Oqpl2LQvnaE4tEH6q+VkpWlcxkpg6L5exohSfunYslc0M1YMEL/0vbkqQtr4KTDUui8OCmGdpcbrJGu0/m4a29aRIirmqrtq6Ix+Yl0VpGKH+OM+I5u7miod2oFX/P0jjR4anHli3VfSmF+ORsvoyWVMvdwRprZ4ZjzYxQuDnYGLV3T+ZV4HBWKc4WVRkBE5oIFkUGYH6EHxIDPSQwXi3eXArqmnG+tBap5bXIrGwYBZLIIkZ4uiCabJuXKyI8nWUy0cjiMW3rGxDQVdnKrRM17V2obutEfVfPKLAyXtmYmYqrnY80BpHxszRRg++V8HuymxJ+T8Zz8iRpd6utUT7yyiijQiX+6YpeO6oE4F+4fFkeBy4qI0ZV1rVn6IKiHR0cQlf/IAbHAYvjsZwEpW62VnC3U6QIfPSytxF5AllWo9G2V6+KkauMY0Sb2kVrW9LYKmzqWIwfz7tAF50A01CDBYCq+SQ7TFNUblUTsqsaBKCSoR1ZPJbCnHq7INrXDZE+LsIIs5irmklgWlYnALW8cXQqiJOtpQBTJe/UTRz3PPYEp3kVjRK8n1FSJ/89Ehzz8wr3dUFUgBsi/d3EgGdnZa7FSOWUNiCXW1kjSmpaxwSW7k42Mt2HLGqIj5MYm9Qgfxm4UNcu2sqK2jaU17bJ48gRpiOL32MXR2tp8TvaWwmA0xEY2lmKFIBtei4qr8eQc1/5+gSl/G91UcVfmTxpkqJv5nk6juaa3x1KEWiA5Dz4ptYeNLR2o76pWxjcmsaOMaUFBJ+ckBQb6oG4cC9EBHG4wCQUVzUjKasSpzLLxZhkeB5xdOfa+RGSFVtY1SzSoMOpJdr3kyD0kTXTRRe6/VQ2Xj+Ypi1I50T44pnN85BV2Yg/7DolqRfSql+cgKWxgfjx+4dQ0qhcrx5aEC9myR9/dBg+1mbY/q1Hb4PRL2jdsmDUysoK33n0VeRlVCNuhj9+9cID2oWCIPMbW55HfXU7giI98OxrjxnFPbGqS5vws8deQVNNu7Coj/5gLdY+MPuGQLKrrRcnd2Xg1K4MFKZVauyiWnTfu/noxBnv4GwDKzsL0VVONZ0q4IvGG4LOof4Lsp/dbb0SKt9a34m2xi5hDEYWXffBsd6ImhmImDlBCInzHTeg3rDqKlpw8IPzOLQ9BT16VpPvdfGmBGx8dD68AozHbbIItI/tzsT7fz+OxhqlfW7vaIV7nlyM5XckGL0uDV8nD+bhjeeOokkPHH2DnPGlb69EjEHIPd/T0f05eO2FY2hrUYBadLwPnvz2Cvj6DwPM6qpWAaFpKQroc9BZikFp0ZLhPND6+k787aVjSEpSwuatrUzxyMPzsXpVtHaRZzj0C6+cQIp+ShZZh4fvm4O1K6O19nVxeZOAUMahsNh+um/zdJklr+o9eVOjMen4+ZLh+fHzw/HQHTPhqh+XSuPFjmPZeHd/Ojr0kU86WwtpdzGoXm3bt3f348Pj2cI6qLo9xp2smxOBuxbHaNpRnk8EATuScnE0o1RzR/MmThf8+lkRYjxRgTKB1Kn8ChzMLBEG1NBNTQPN4ugALIoKQISXsXu+tr0LycXVOFuiOOcZnWRYBIJkNLjF+roh2G3YbKIWwVxpUxuKGltR0tQm/13a3Cat9fGKz+Fuq9eL2loJeHOytoSztaXGONpZmP9Ts0j/L8X3yNZjRz9D8AfE0MSWJLcWPavb3NMrf77RlZjtfi8HW3jrbOGjs4O3zg6+NDjp7GBhMtVIVkEDGI1NBKfFNDY1tI7JThMEkPkM83BCmIezPDJaSwWo3GcG6ROYZlc1SpvfMOKLxa8WJQJkThX21A3ejkpeJ89VZpySPaUpqqimZZQumAsETopizmm0n6sYpPh3BGYFVc3IKq2XLaesQab0jCwa8yL93BDh5yJANcjTUbSXXLgRRBWUNyG/ogmFFU2oaxk7H5SAMdDLEQGeOvh76ODn7gAfNwdNg0oWs7qhA9UNndLWlvZ8s9KeH5mdOl7xnBQW08pMrhfczM2mKKNAqRedOlnAJn+O9xH1+6Zl4RKsciFE8xw1o4MXRUfb2zckyQSd3YPjakTV4rWJsgPGxQX7OksLPsBLJ9e+2uYukUCkMR0hrwad+mg59TyhcWzJjGAJq+eEpIPni2Rqm+HADLbj71+egLhgD7kGvXU4XTNEBrg54OlN82SR/ZsdJ+R8UtnQH25ZjLSKOvz14DlZFNlbmuGnm5cgraYeb5xRTLGRznbY9s2Hb0c7fUHrlgWjnOBQS43oXX8Vlo3GmA0GGlHqR5/Z+oK0jjn95+d/e3CUPpTZoL/71ntIOVYgf46Y5idZmt6BxpNxxquu9l5pm+efL0dxZhUqixpxecSF/tOWmaUpvAJd4BPiCv8IDwRFe8Ev3OOmM0YJcJP2Z+Pwh6nCAKulc7XFqq0zZYSn7QimmEUd6OEdadj+yimNCWVu652Pzcfqu6ePGs+ZllSK1/9yBOXFTRpgfeDJRVi6LtZo5Z+VVokX/3wEZfoYJmdXWzz+9SWYuyh0mAHs6sebr57Gnt0ZAtYZQ7Lpzmm494HZMNfLDhil8va7Z/HxJ2nCPEjY/Lo4PHj/HAmxZzF+he34fYdyBQCTidi0Ng4P3D0LVvr0BBoXXnr3DI6dUTSovHlwatIDm2do5qS6pk68vD0Zh5MKBWBwN5fMCpEMPi83RTva0z8kwn+O7OzRGyuob7t/dSLWzAvXAG1ZXRveOZSOA+eLtBsNxzMSgG6YGyk3NDkGfYPYc74QO07noKp52IzEeeUbZkeIGUnNEeXFniaBfWlFogM1BBcMl18aE4RlMYESrK4eYwKctPI6nC6qxJnCKlSPMMSQLZsW4IlEfw95pLnGiP2+fBlFjW3Iq2tCXl0zCuqbUdHaMSaDxxufu521aCF9He3hrXeWE4gRdF4vgJ437K5Bgr9BdA4MoluvFyVj2XeBmz5rlJrRS3rdKPMbyUjRJCK6UbJSw8+pMqXUjRIoqNpRmqrIrpJlVTeLqYprnyystamSPWprptePmpkJ+zlW8TMhOG3o7EU9ZQhdvRJhpW6UI1yv2O73c7SHnxO1tvbw56OTg7wuS1rqHT1iGiusb0UhH+uaJZt1PIBKJjuCsVAezgIYyIbz+JY2tAqrpQDUBtS3G0cysWgoi/R2RYyvm0zh4vOYm0wVbSxNTZn6OKncysZRjn2+PtlSAtNIP1dE+brB09FGvkvVTR0Cbqk9JTitbFQWvIbFz4iANMzHBWEEXN7O8HW1lwQLfu9oBCRILapqQUl1C2qbO8ddCPA7yQES3q7c7ODpYgcPZ1s42SvnocJGDqG+uVuY2ea2XpHqtOrb89Rf0pFuOOb0X13sojjpW/VujtZw5z672MLH3V7YW+43F75870VVzZL9ylzQzhGT1DhCeFqEN2bH+GFOjJ/IA07nVAgITc6v1lhnLnSXTQvB5oXRcLSzxLYTWfjwVI62+PHQ2eCJNTNkwfG3A+e0ljwXPF9eMUPY8V/tOC7nJGt+mC8eWZSIZ/eeQL7+7+6fFYvHZkfB0cHhsw29d3kCkyf+Y3GN49XlqxdxpOnF2xOYbkUwWlZaA/8ARcu3e1sKnv/1HrlQ/eaVhxFmEC1UnFMrDnsalsLjffDzFx4cFenEw7fnrSS8+j97JAOUs945x/7ery+7bhTSWMXWdmNVm8QktTZ0obO1R1rsZEHJhnLq0oSJEwRYUtvJyCSOKuXrODH3zssBdo7ja+7Gq4G+IQmpP7k7Ux4vX1RADwEb2/kr7pqBaYtCjdzuanV39mPPu+ew+91kTRNqp7PEpofnYs3dM2Cq12eqx4qmJEY1qdOTmCe6+aHZ2HTfLCPAWlnWjFeeP4qUJGXsqLnFVNz90BxsunuGaElZXETs+DAF7759VgxSrNlzg4QNdddnoTIqZfeeTLz51rDmMzHBF1/58mL46NMNaDba9lEKtu1I1aa0zJsVhC89Ml9y+ljUfr3+QTL2HBked7d0Xhgeu2e2xLmwqKt67aNkyeJTQdb8xAA8tmWWGCJYvAm8dyAdHx7JxoD+JuzlYocH1iZi5axQOQ9VPejbh9KNopl4Y75nWZzMiecNlz/HCTu88B9OL9FYTbqMVyQEY9OcSMmF5PkgP1vViD2phTiUVWI0y5xt++WxwVgZF2wEQBkgf6KgAicLKnC+tAaDBqCVwIwt91nB3pgZ5C2MmiFIbO3pQ0Z1A7KqG5Fd04iChpYxA+appQxxdUQQNxedbASgNDGMLL6/xu5e1Hd1y2NDt6IZberpRQtHcPb1CwD9PF/RCFIdLMzlfessLeBoaQEn6kfJ7lJDaq1satvbkGGt66BcoQtVbZ3aIzeyreMV2eJAZ51scnxddQJS1ePLz4mJCAV1LSK14ONY2aUC8Fx1eoDqIjILAlZ+5jxPONBAwGmloj0dmVdKgMlzSzFGuWjsKVvRlJAQmBJk8nxuGAfckjFly5aghuc1c1MJLmmEIjjlY15l46hIKBYXAWQ9qTkN9nQSsBrgoZPOA7/z1J9yiAQfubGrYcgMjnU82N1wc7QRwMqN+kkaCwnIHG0tNVZV1aeK650T8/qGJFSerCa1onx9ShQYrcXrFa8dBP3qrVminfQOewI/GQlKzSjvAWZThW2l5tyOcgAbc20hSwaVkp/61i7UNnWhpqlTxrPSEKl2YQyLC+twfxeJzWIuLI1g7MicyanEqaxyMZ0ZMq8E+Wtmh2HF9BCRd2w/lYNjmaXatc/H2U5c8jSivX40HR+fy5P3xcvLmoRQPLQkAe8nZWN7cq6cB5TTfHvdPPRduog/HkySc54ym/9auwBHSssRZGeFry5bcBuMfkHrlgSj3/nKy/if5x/RbtK/+s4HOHMkX9i5P731BBxdhnV0BZnV+PETr2Gg7wJ8Ap3xsxcehPMYpqPmug6ZY3/2YK78mYBx6eZErH943pjt7M+6Whu7kHq8EOeP5iPzTIlMNFLLK9AZizcmYNHGeOj0Jp2RVVnShF1vnZWWPEEhy8nNFnc8MhfL70gULa5aPMaZ5yvw7osnRBbBIqBce9c0bHl4LmwMphk11nfizRdP4NiBXAEVvACv2hiH+x+fD1v9zxEMHj2Uh9deOYnWFuXGFRDojC9/bakE2KuvefJUEV5+9SQa9Eytt7cOX35iIaZP89eiZ3YfyMEb7yaJwYAVFuyKJx9bKGPyWGyBvbMjBR/uHY4nmR7rgy/fPw8BvopEgIzIGzvOY8+JPI0tmBXnh8fvnCWxMazmjl68vTcNO0/kas/DmyOD6hdPD5KbOm9GB88X4+1DaSjXO+h5E18YF4B7l8WLTo5FJml/SqFc/EsNtKAhnk7YNDdSWFDVjFTX1oXdqYXYm1ZopP9jbuXy2CCsjA8Rx7QKQGmMOZZXJoxpTs1w0oJ8vjaWmBvig7mhvpge6KkBJjHJdXYjraIeqZV1yKiqR23H6HYoWboIDxdEeDgj3F3ZaGIaqYOs7exGRVsHKgm22jtR09GN2o4uNPb03hTQ5NOJZtRc0YzamCq6UQJBSxMTWOhZTNMp3CYLUOE2ZSJ1o3TP67WjMv1G0Y1Kq/TqVdk/YVKZO3qZ2aOXMXhJYVq5kX2ldrR3SNGPkplVt09jrOK+ulI/amMtsgTZ7KzhYWcDTzsbeV9qUdZAfS11tuUt7SjXP9LgNVbxvZFlJjgNdnWUxUCIm6OwzvwsGD+VV9ssIDW/tkkex5JOkNniIkRlUDnAgPIJAg7GdamtfQJMRliNZbJi7im1p5EcguDlIgCztatPMk5zKpTfZWt/JLhleTraSqwUGVA+8vxnu5umqoLKZjFEcdwkf3+8Vjpb/GRh/d11onPko5ezrbT5yRRWNXTIVt3YIWCOpsL6lu6b0i4T6Ipe1NoctlZm0p4W4MhIJzMFSJJ9JLAkgOR0L1UbyvPQcNQwryt8TWo+5Zxjm35ImcLEVAG26bt6h9DR3S8Akszs9cA0n5rSHupmw/ycERnghmAfJwHF1OuqcVxVI5hnbxc7LE0MwvJpIZIiwmi43ckFqG0d7pQwg/a+xfEy4ODNE+nYlTI8KnRmiDe+unIGsmua8MKhc9K1YK2KDcGdsyPxh4NnZAErPxvgha2zovHrgydR19mDqVcuIfdX37vdpv+C1i0JRhfG/QDP/PAOrNkUL39PVu2ZB19CVVkLvP2d8LtXH4GVgamnrKABP/3y6+ho7YW1nQW++9stiJ9tPKrS0G3/+u/2ocCgxR2R6CfAbs7KKFjpDSv/7qKkIC+lEtnJpcg6W4rqEmOgQZ3q3FXRmL8mVlr8Y7GrNBqdPZyHve+dR54+XJ4VGO4uTOjc5RFG7CnbnSmnS/D+K6dQlKMEtbOFvvKOBHHJOxgwxy3N3Xjv1TM4sCtTA3TzFofhoS8vhIe3g5E56ZUXT6CqUjEMOTpa4eHHF2DJskhNY5WRWYWXXjmJ4mLlokZnPEPrV66IEnDLFvyxU4XSkq9XzVVs/z80DwvmBMt7J1v64Z4MvLczVRuNxyDoL90/T3PIsx33xsfnsftYrnaxTYzyxhNbZiM80FX+zJsXnfGcG6/+DC/+D62bro3s5I3ko5M5+OBoFtr0UTlkN9fPicDWpXFaNFO5nn3gDUBtbRJMLU0Iwp3zouWGzH2nEelQZil2pxbIFCRD8EAN6OqEUEwL9NTYVbJhR3JLcTS3XBzahsXJPQvC/TA/1E+ML+p5wZZyclkNzpfXIqWidhTw4Y8FuTgi1tsNMV6uiPZyhaf98HhGvi5ZzaLmVhQ3taGkpQ1lLe2obO8cE3ioxfcrmlEbawFrZBEJoqgbJcuoY+C9udlNz5InwCQDo8Y7cSOzQ9BpdGnknHp1Vr1Bu15t1aujG8crnnMEpx0DA6IfpUmrTdWP9vWjpbdPz/L2jdLfjlU2ZiYCTL3tbeFtbydSBh8HO9nU1jxBcVlzu+hwqcctocmpuW3UYILh5zQVcBrqpgJUJ2n9ExgxvYCRXHmMh6ptknNm5HQtVSvMc4bMKcFpuKeLLHyau/qQI6aoJnkkWB3LuU85BgGqbDIi1kmObXFdq7CeuWRBqxpRp8/RNSz+HAFQqJeTDGgI0TOg1NOSHSyuaUVxTYtsHImrftdGFt8vv3PeLvbyfOxceDnbwdPJVhhPjuck40hzUAOjnNr0G+fCdyot+pG62s+qeB1hq57SAr4PpgFQD+vnrpMwesqAaEASdrmiUSa2jTymkf6umBvth/kx/iILOppZKiOCyWarRf36Srbq50aha3AI757MxMn8Cm3xyOzhLy2fIfro5w8mi2SExSiyZ1bPEW3oa6fT5RrJheLTy2ajdbAfL51Jk0Ucv/M/Xz4Xc8ODbxuYvqB1y4JRc3NL/PnVR7V55S2NXfjmAy9JwHpQuDv+3wsPyLQfQybxv7/2lgBT3lA3PjRHxoYaMoBq8ZBypv3Hr5wU5lE1FbGFzzgoZpRGzQhAYKSHUWTRP6soK6gqbkR5fj1KcmtRnFWNmlLjcHK+B86Ln744HDOWhMM7aJgdG4sFPfRRGo7tyhQNrfpe6Ipff/9shMd5G4+UvHQZx/fl4qM3k1Ctn01PpnjlHfHY8tBc6JyNQei2N5JwYGemtKjUvNCHvrIQQaEKE8jKTK/Cay+fQEG+Aq44eWTrfbOw4Y4EmOiPIcHnK6+dQpreeMSV+11bpmPL5mkyPUna32kVeOmN0yirUPbLztYcD26dpZiTJk+SrNBPDmZLVmhXj3LT5gjAJ+6bq43vJAh9a2cKdh3N1dpWjEJ5fMssRIcojCpduMwIPXyuWGPE4kI8BIROi/CS56lr6ZJA6F1n8rSbFyfU3L0kDpvmR8LK3FTA0YmscnGkppUogJ7l7WSHzfOiJJaJTAvPsdTSWuxMycfR7DLNzc6PhQH0axPDxIjEm4acn7XNOJRdgsM5pdqNgUWQNT3AE4si/LEg3F9zvJP1S62oxdnSagGhZN8MiwAt0tMFCb7uiPfxQIy3qxhuNL1iVw/yGpqRV9+MgsYWFDS1jGtUIsDz1dnDT6eAKy97W9nICBJsjjxPCRzbVYDXr4C9jgG9ZnRoSG6OBHi9Y2hGL91gstPNFh35vImaTVFYV4WFnQrLqVNhZWoq4JEMrcrY2qubhbn8nSGYJYgkMK3v7kFDFzdKE3pQ10WGuFve6/WKEgAeNz+dPXx1yqO/o73c0Pk6PE50Kxc3tYrBiQay8fS7ZIzJoBKchro5IczNSSQVnFjFhUtujcKeEqjyOcdiDMmWhns6CTAlSKVRiosKjjYlOM1l9mxV05jB/DyvAtx0yu97uSDM00mC+rkYY5g/DU751U0oqG4elXlqKENh9mkgN3edbAzXZ4ufYIxbeX2bpFOUN7Rf15DENrmrzkYmRzGJwsXBCi4O1hLe76Rvz/M7xP3rYAh9T7+0xLvZnmdAfd+QaEzJZlJHynB+ynXIdkrm7aUrsojnZ6HemvmZcREtCyAufphvazJFmFeyq8wUpimK7Cuj3xxszEUq4GxvJZmp1KRzbGtNc6eATeps+V7J9I7F1pMhjg/2QGKolzzWt3cjKb8Kp3MrkVc1TGLwlKUZkjPkGRF3LLccH53Nle6KWvPCffHAwniR1bx0JEWSHlT5yFeWz5QhJX8+lISmbkUTPT/EFxsTw/Hn48kobVG6Q2sjg2Vym7eFGZbHfLaz6f8Vr/2vfO7/pLolwegzX3oRuRmNcHGzxXOvPwZrW3MtbP27j70mgCswzA2/eO5+2NoPM5nUbf7913uxb9t5LaroyR+vR9xs4zB2wyKIPf5JOk7syhCDkmHRWS5moyAXuPs6wsXLAToXGzEIkZk1o4veZLLm0KemlEYhgk3Oj+9mK6a1V/SlLfWdaKxpQ11Fq0gGxipPfycZTRozMwAxswOvy9K2t/Tg5L5sHNuVhfLC4RUw92/F5kQs35wAnfOwnEHVj+7/KA27tqUIi6xqQlffmYiN982EvYHxie34D948i4O7M7V8veh4bzzwxAJEGkRF5WbX4I1XTyErU2nv8+K1cfM03HXPDFhZKYsFxjMxK/T0Gb1rfdJErF0Tg/vunQ17fWs/M6cGr7x5GrkFCpjl1JOtm6dh84YE+W+2yPcczsVbH50XfSjLw9UWj9w9G4vnhAiD2dzWIyB097E8DYTGhHoICI0NU9hSGgEIQk/pZzOrc+MfXj8d0UFK/BeNFzQlHc8o024GZHDuWx6PpYnBcsNp7e7Dx2fysONMrsTlyPuaOAHzo/xx5/xoTAtWIpwY7bPrfD52phTIf6vl62yPddPChAXlLHSVAT2YXSIg1BCAEhjMDfXBkshAacHTjCQB562dOFVciTMlVUirrDfSfPJGxDb7DH8vTPPzRKyPm4AwFpnZnPomZNU2Iru+Cbn1TWIoGll8PwRKQc46BDvrEODkgEBHB7jZKiYLtfovXpTWfV1Xj+hFqRVt7O5BU6/CJFIreuWfcBmbpGrzJk7EpAlKq1QtNeKJoJ8AllFP/6wLJwEXdaQE2k6iIbWUTdOQWlnC1cZawC2LQJrHo6ajS7bq9i6RM3Cjdna8IshXgKmDHOsAR3sEOungoW+ts7VPYFrc2IrCBgWkEhiP+bk52gs4FYDq7iRglUwxAanCoDbJgqeqtWNMaQWnSanmKDKpTFugyY25pwzkz5dw/mZ0jKGH5evQUBXq6SQb3f/UozLYv5DMZ22LtOYLa1vQ1DG2VIHnPEGXn4u9PPq62MPXxQGu9lai6yRgo1mK4I0grralCw1t3WMC9pHFdryOmZ/WFgpAZIvewkxp0ZubyCKT7XlKacxMFCc9W/T83k/h2M9Jk4ySKwzb9DKWVkbRXlIixQYvilGIOtRupjb0EAAPiNShtbNP3v/IkayGxX0LYaueWlw/V4T5uqCjd0AMZpySlFpcO2rqFo1li+OCMD/SFyWN7SIBIguqLkTYgVmbGIoNMyKQWVWPt05lCrMux8bcFA/Oj4O/qw4vHDsnWnIWJShfWzITGfWN2JauDB/hd+Lri2biUHEZzlRUw3bSBKT88Ju3wegXtG5JMFpb04T/emqbhKdHRHvi2efu10wxFcVN+MGXX0d35wDcPO3x38/dB48RYzzPHS/Ecz/7RAAba9qCEDz0jWXwDVZas+NVY0070k8WSZs8P7UCXTfIrvu/FI1M/mHuCIjwQHCMt2SB2hqM0Ryr2pq7kXykAKcP5iIvrUpbmRM0T18QIhOTEuYGjTIylRY2iBHs+L4cTXvq4GiFDffMkJa8IcNMY9IHb53F8UN54nxXQei9j85DTIKv9nM5WTV4643Twoiq7f3V62Kx9d5ZcNCD2pradrz5VhKOnyjQXOuLF4XjoQfnws1V0brmFdbj1bfOaOM7GZ+yaW0stm6eDlsbc2Fj9x/Pwxvbz6GlrVfLCn1oyyysWBAmbCmnqrwtIHS4HR8b5oFHN88SRlTSAQpqBYSm5itRT9yXBQmBeGjdNMk0JHt3MrNcQCiDvtWaFekjetBpoYpxjjo5ulGPZJRqETj2VuZiRuJGBoY37WM55WIIOF9So93sOTJyRVywjNFTdaDlTe3Yn1WMA5nFRg543jDoWl0WHYTZwT7CmPJ5UyvqcbKoQjbqtAyLIHF2kDdmBXoLAFXbwWTx0mvqkVZdj4yaBhQ3t44CIGTSCDoj3JwR7uqMUBqWnHRyEzbUipa3daCivUPa9QRX1R1dwnbeqMgekWmkKcjBwgx25mzXm8JWz0Zam5oKmCNbK873KcO6UYI0Mps329pnqRpS6kZlXv0l5o5eQr9eP0oQRxaWbKxkjw4pulGytGRsOzklamBA/u1mi+580ZDaWEsWqYetjX6zFtaYTn6+Lo8bjx/ZTupuRX97HfkDgVmAowMCuRhwotnJQRYHDubmcg4UNbagsKEFBXTgN7SMubBgUSoQ5q4MMSCDyjY/AT5d0io4pf5UBSZjR0wp8VLcyMBymhYZUP6+jDatbRkzoooAmQswtvXJohGsBrk7CtDnSFNu1FeX1reiorF9TIkAi4CQzn1vZ3t4OdnCy9FW2vMeOlvYWZoK+8pRu9Kib2drvgfNnX2iCW/p7LthtNKnKV5D/ll3Z7K2Hk62IjvgVCt/AnE3BzmHeVx4jPOrmiXdYOTxJWjm4pf5oGRKSxracCynTDKJDQdoMLd208wIhHk5YU9GET5JKdAWM4xqum9urLDSr55KR3qVQgpQQvHovASYm0/F8yfPad2S9dGhssB57vQ5+R7xO/rUjDg8sWjubTD6Ba1bEoySDu9oHcI3H38N/X0XMHNeMH787GYBHqy66jb88CtvormhCxaWpvjOrzZhxvwQo+fq7x3CW385jN3vntNmss9cHIbNj85DaIzShr1e8bCTzSzLr0NtWYs46Mlotjf1COPJ5x/vo2GLnACP+lV7JyvJI6Wb3tXLHu6+TvAMcLruVCjDfagoakTKyWIJ+Wd6gGFxUtLC1dGYtzJKXsuwhgYv4tTBPOz7KA1FucPt44BQV4nImr88AlP0QIOvk5VWhQ/fSUbqWcUdr7bjtz48R2NCJSMzrRLvvJmEnGwF1FHMv2JVNLbePxvOeiaWIPTtd87i2PECTQIxb24wHnxgDnx9FNd6QVEDXnsnScsK5fOsWR6N+++eAZ2DlQZC3/zwnMxwZunsLXH/HdOxZmmkGBiYIfjWJ+exj+54/WfM2cyPbJ4pIJSvfTqjHK/vPo+CimaNlV0xMwQPrJ0mkTBsw+1Oysc7h9O1jEPe8OhAJQilo5ct+kPpxXj/eBaKaofDpTkX/q75MVgcGyD7Q2C542wu9qQVGrnhqf8kAKUelCCTk3UIQPdmFKG4odUIdMwL88Xy6CBhQPmzBEiniipxrKBcGFACKUMGKtHPA3ODfDAnyEcyLXleE3ymVNUipbIOKVV1AhhHFlvCMZ6uiPZwRZS7C0JdHDXgSY2kaEWb21Dc0oqSlnYBTNRtjleMRyLwEiOPXi/qam0lelEyiDoL81FgksH0nTQPDQ0JGOzVg8MBgkZp1V+UaCdu/FlFN6qwT2RaCZCV89I44klhTicoEU8TJyrjQScp7JYZx4ROYcSTfkwoW/ZTTWClRj2Z0EhlorXlCWQpKeAxUTeym9SQqswv0wJuBrSSSfIy0JH66OUNfOQ+EViWtbaLNre8tV3aoAT/44FULjaCnR0FmHLjYoKglaaTgoZmYU9VkNrUPTYDyQWMgFOG7Ls6Sdj+RExAvjj3m4UJ5X+P5eDnIeI4WDWgnyYrhvQTLBGYkvmk9rSorsXo+2B0TJgm4KaMSWV739/VQVz8NPeUNbQJMK1o7JAxp9XNHeOCVM1Bz0EEdM87WMPVzlrGlzLE38nOCg7W5nKdoIGorXsAHWzRMwua5qL+QQmkJ3vL6UR9AxelPc/vPvNQb3aYA4vnDtlU5pMSKLJNz9GZnFZla2Uu+0Fmlq16F3trYWopF+B0LDK8jH7j+y5raNcmJRkWn5uJBWzBxwe6w8rSFGlldThTUCVSIMPzhV0XpnAsjPRHZVsXPknJk6lravHzu3dujEy9eispA1k1SneQ35kt0yKFFX8pKU1ryZOtf3h2PD7Kzkd6rfI80W4uWBIegCAbKywMC70NRr+gdcuCUWozstOr8F9Pv4NLF69gzqJQ/OAXm4SBY3W29+EXz7ynRRCR5Xvk6aWjNJ51la1468+HcfpgngYe/UJcpY1NEGd7E6BwrKJu6MLgJZEGSJQQJmDylIkSYM99+LTxTWoxAzQ7pRzZyeXIOFuGTj0bqFZItCdmL4vAvBVR4o43LL4/As9DOzNx8kCuFqdEEM+JSXTHhxkAcRqeThzKx8fvn0e53jDF9tOchaHY8sAsTRNKUJd0uhjvv3MWxXopgwZC75sNZ326AdvxBKEnTir5naxZMwMEhAYGuGhM6BvvntVAqIDDxeG4f+ssuDrbSDt+39E8vL3jvAZC2cq/b+M0rFseLXqsqrp2vP7xeRxJKtLa6ImRXnho00xhRMl+HDxbhLf2porTVtWSrVsQKWH1jHmhOWL7sSwJqleDutmiu2NBtGSE6mwt0djRI7FMH5/J1W6mvEgvTwzG3QtixITBVtzhrBLRYqkh0SxqOddPD8OG6eHC2nDiz5GcMuxJL5TwaPX4kBni3PgVMcGiA2XWI4PWjxaU4Uh+GdIq64xaj9RyzQ/2E+3WjAAvYS6otzxfWYuzFTVIrqgRtm3kzTHExRHxXm6I93ZHrKebgERZcPX2I7exWfSi+U2KXnQ8ptN08mRpI/s52MFXb8YRzaidjTCb6jnYNTQkznoBa729aCGAI5Dr70f7wADa2a4cHPhU04/+ncXjZWNqIrmjdmamsDc3h4O5mTCRBNU6Cws4WpjD0dISzpYWAiTJDlGaQIlCXbciV1B0pD2o7exC9w3AqqOlOXwd7OW4cvNzoCbXHs5WFqjv6kVpSxtKmhUjGYEBW/9j6Qm57/xMBKC6OCKEelJnR2GWCU4VkKoA1LESFdRzLMzNWcCl0up3xNSJk4RBJXOqZKC2oGUMgMpytbMSUEqQysdAFwdpbVODyoD/EtnaZDDDeHc3jp1la55sLBlV5ut66exw+cplVDUr+soa6ixbOsUsxe/qzQBGAjkCYHtrC9izRW9pDlu9g97a3FQkMNR58ntF3Sc3/o4spGRf+X9Kyou663rLn/JfE9hFuKY46tmmH7oogJIMMvWoDJhnq55xW2zV0zg2ss1uWLw+kCml6SuMsglvZ0yaMgl51U1ifkwtqx2lxaUGd2FkAOaF+6Bn8CIO5ZTgRH6FplPnOTI/zA/rE8PQ0NOLd5OzZIqaen3bFB+OWF93vJ2aJVIeFrsXj8yOR3NfH95Pz5HFILsXD8+MR25rM46XV8LVZCrOfPNrt8HoF7RuSTB69EgGFi2Olb9LSSrFz7/7gTBlCTP98eNf36nNLqcR5+XfH8LO987Jnz18dHj6x+sQGT96Bnt1WTN2vHYGx/dkaa1qMpiRib6YPj8E8XOD4Ok37Eb+dxT1pZXFjSjOrUNRVg0KMqrFqGVYzAGNnu4vUoMZC0LGzEZtqO3A8f05OLY3W6ZSqeXqaY8VG+OwfEOcEehua+nBnh3p2PdJBrr02aM0ei1bE4077pkBN30GKCOhDh/Kxfb3z6GuVg/qTCZj1ZpYbNk6A476faEx6Z33knEmSdGEqiD0gfvmICjIRckvzavFm+8la+14tu2WLY7AA3fPlJa9MJSHcvDuJ6maJpRznO8lCF0WJSao4opmccefTC3VbmIzY3zx0B0zEBnkJkzGzhN5eHd/mjYHm+7SOxZHy9x4xrjQCPH2QeOQejpz6YqnO543HhqROKP5ZHa5dsMn43LnvCgJqCfDwZvqh0k5EhCttsL4njgPnq2w2aE+8rtni6uxK61AbgaGjAUnH62KC8GyqEDYWphJcPqhvFIczitFTq1xkgLbsgtD/bEozF90oLwNEjyeLq3CmfJq5NQ1GQETnsJhrk6Y7uOJab4eiPdyl/Y3I45yG5qRVdeArLom5DQ0CdM3svgNIKAhiAl20km7PsjJAe62NnIjI0NZ29WN6s4u2Wpo3OnqRl13N+p7ej4VyCSDKW16E7KTCkPJdrbaqjedTNPRZHHEy1hQGkX0EU/UjfK9KiFP+ognKIzpZWpHOSKUUU9XrijsKgHC5UuyfzwW1Lr2ceOYUH27/nrs73jF/SYodbGyUvSj1lZws7aCu7U+VcDKUphdyhzIUtfIYyeqOhQtKZnX8UrMYg728NcNb2Q/yTbzuchel9Do1NKGoqY2kRiM68R31smiRN2of6XRTWvxN7aIgWUskEsJBcFpiKvCgLJFSza8tKldCeqvY1h/i5HW2bAoM+EUqEBXBxl5ykxUd3sbmSDFkH7mYJY1tkt3gX83XvF5PHX69ryOmw3cHWwEAOPaBLR09Up7vpEbW/Nd3PqkRW/Ysv68lSXTF3Q2mgSBQJwtezrqaTgqqmvV2OaROmECyFg/N4llYrYwGXZeb84UVRklKlAHvDY+VMxixwvLsTe7WPt3dgU2T4sQreh7qTnIrmvUujVbE6IErL92Ll1bVC0O8pf0jldSM+R7xA7EI9ER+O7yJZ9ttFNDy7/EwOTs5nTbwHQrgtFli36OP/z5UYSFK4aStOQy/Px72wW8BQS74Ge/uwtOBuac86eK8adf7NJMOQtXRuGhp5Zo8+wNi8YiZm8e3ZmJUr3zWy1qNtnCD4zwgF+wi+SPkn0cb9bwzRQ/vr6eIWnxEyiSqa0pa0ZVaTPqqto0CYFaBMiB4W6I0RuZ2IqnjnJkcTxn0tECGddZYvA+CCrJgi5bH4fIeG/NXEV2M+N8uYDQc2dKND2ozskKazcnYvXGeFjbmGkTk3Z/koGdH6ejq7Nfc8ev2xgnk5NsbS2Uln1mNd7fdg7pGcMxUmzH33fPLAQEOGvu+Le3ndOMSSoTet9dCghlDt/H+7OwbVea5o53dLDEPRunYe3SKJkqklVYhzc/ScH57OHXYVg9Z8eH+DlL3uAHhzMlqJ5GARZnWd+9IhabFkUL03G+oAbvHkrH2bzh5+DcbLbiF8QFiEt2b0ohPjiRJe0xtRKDPYUFnRflJy3CAxnF+Cg5V5gJtTwcbASAshVP1oU35d1phdiXWYQOA9aDk3fWxIdidVyItBDJRhzMLcGh3FLNKMAiwIr2dJXW1+LwAMmcpAP9TFk1TpZWIqm8epTTneBxlp8XZtKw5OMh4INAU7SitfXIqG1AUVPrKCMRwSANM5F6rWi4i5OAFrJ9lASUtbejtK0dZdzaO1DR0Smu8RsZksgiEphxc7a0FOCjsor8N9WtTje7ugAkiBRwyHny1HZeUh6VNv0VXLgy3KpXM0U59nDkJVJCyMXgROA6QfJJJat00iRhd80mE+RO1utSp8JS/0gWiqBRdfhTQtDJaVEDSgpA+8Ag2vr75b/J8pLt5b7dTBGsUr7gYWMDDxtreNrawMvWFl62NgK2CVAJTCuoIaUmlzrSjq4xBxFojJm9rQBT0ZPqN0o7yls7xIlPcEp9MCUWYxl7+Bx08ws45cLDxVEkBO29/UqLn1rU+haUNrePuR/8fU7hCtbnoXKjVra1Z0BYUP4u9YtlTWP/Psve0lymgZEB9XdWHqkr7uofQCXb1c0dqGruQHVrp0ySul4WLBdK7Ei42FkpG9vztlZwYkvcxlIWZHI9HryAjt5BMQLRDMUWPZ30PcwEHbyg5IMOXpAhEmzRs1X/aTJo1TY9gTMNUJYMvjc3lYxWOytz2FmaSZue8gH+N7tRlFbUtXdLYgEZ36qWDtS0dI0azcriZ8xorTg/Ts9ykwVYZlWDjP+lpMJwV8kwL4sORGKAJ0qaW7Enq8goaYOf3+bECEycPBHvp+XIuaMugu6Ii4C7vbUwpGT8WTzHNsaE4eOCQhS1KhnK0a4uSPRxR6StLdZER3+mYHSx7QOYPOGfPIHp2kUc7XrzNhi9FcHo/Jk/gq2tLZ79360I0beKC/Pq8JNvvS/GJRs7c2nZxxnMR+eYzFf+dBgHdqTLBYft/BWb4nHnQ3PgpDfLjKzG2g6cO1qA1FPFkstpGCyv1qTJEyVkn7pPOvfpopdZ9CZTpC3PGx+BHme+q056mUnf0S9Sgo6WHgwOjL8i50jO4EgPBEV6IizWW9rwZhbG011YfE8czXn+ZBGSTxShrHC4JcyLGWfFL1wVhdmLw8QhbxjNdGhPNg7uykKzAesaGeuF9VumYdb8YE2LW1bahI8/SsWxI/kijWCR/bxjyzSsWhMjozspSThxsggffHgepfo4Kr7+4kVh2Hr3TJmaxHbZidNFeO/DFC2iiTrMVcsjcc/m6XBxtkFnVz8+3JuJHfsztZxQVydr3HfHdKxYGC5tvaSMcnHH55U0ahf5JbND8MCGaTK/mRmhnBm/53S+FlTPvL77ViVg1ZwwAXX7zxXhvSMZEg+jPsf8WH+Zz8yQekaqMBv0k6Q8zRjAG8ma6WG4a0E0/N10Y7Kg1KctivTHHbMiMS3QS1zF1IB+kpovN1/Dm+2quGCsiw8TJoFRQAdySgSEqqP01P1K8PXAsohALAn3h87KQtqyx4srcLykEjn1jUY3Gd5YZ/p5Ym6AD2b5e4tWk1rR89W1SK2uQ0p1Pao6jNv1LE4TivVwQ4y7ohUNd3USYMZ2XUFLKwqbW1DY0ori1jZhO8e7+BDIedvZykZAxU0FWmQGyWQSOBK0sbXXOsA2PQHdANoH9dFOQ4PS0ucmsU4XP1vminpSspzW+o1RTzRY2Zrq2/Vm5rA3U9r10rI3M5PvJd8X3yNlCZQnNPb2yvHkxvinGwFW3vg9bWzkWPrY2cHbzkYeeUz5XaK5iYsBAgV5bOsw0g4bFnWylFEIOKXZydFBQCvZYJVFLRSg2jquzpWpAUqCgtLmJxvLE4GZqHTwi6O/Yfzfd7DkVCk9A+qiE0ZuyoSJqGvvQWljm7I1tY3LoqrnN1vz1I+yPe+ts4WbvZWw4WROa1u7pc1PnSVBHNv018u/NSyCRIJAadHrQSLBIodEWLFFb6pv09NAp3fS8xo34Zqeg6dxybAzf03/Z1zDVb2Ei0CWrOMAddB01A8oY2+lTd+nOOrZqh8vU1Yt7keAq4MYv0I8HIUB7hm6KHFdWVWNYjobCfQpjaD2nCYzLnJGdlt4vi2NCMSsIG+JcPskuwDd+msfGfDNcRGyqH4vI0ekJup14+6EKOQ2t+BImZJEQinL3bFROF1bhbyWFjhOmoSUp79xG4x+QeuWBKNffvxvKC1qE1D1y19vQVSM4mSmu54te+obCTQ23zsTD35poea0V53jL//+oIy1VMHk3CXhWHPXNIRfx7hE7SeZUpqE+FhV0oz6qrYxAeo/UmRd3bwc4O6jEzmAd6CzaFcZLD/ePjHCKiulAunJZUhPKpP2ulq8OEbEeWPu0ghhQu0MnPiDgxeRdKIIR/blIDNlONjYwtIES1ZGYfWmePj4K9OJKH84c6pIWNA8A4NUcIgrNt81HXPnhwhY7esbwr792djxSTpa9PshLfuV0bjzjkS4uNjK6Lz9h/PwwcepaGxS9Ggcubd+dQy2bEyEg70lGpq6hAXdezRPA5De7vYCQpfMDZGL+qEzhXh3d5qM/GORHV29IAL3rE2Au7OtxDMRhB5PLdUYCwbV37c6EQsSAoTl+OhEjmhCedE3DKm/e2msZBieL6oRQ9LpvOHj4+Fogy3zY7B+puLSP5RZgg/P5sqkGsPQ702zIrBuWrjcuE4WVOKTlHwkFVdp7BNZOOo/1yaEyQWfrCbB5/7sEmTrNVgstprpel8eGYTFYf6iV0utqsOx4grZCFwNiwzWvEAfzA/0FeMRwdv5qlokV9bgXFWtgBbD4lnFFnuClzviPd0R5+kmUUQETTmNTchtakZeUwvym5uFBRyrCLqCCGx0DvCzt4c/dY32dsL0EWTVdncrW0836np6pE3f0KvoRdsG+v+heCXJBCVbOWW4VU/AzL8XhpMGJf1GEE/DjepsJkukxjyps+zVVj1ZT+7zoPoo7Oulf6g1rxb3y9HcAk6iI7WQ40Im2MXSStrzzhaWAszJUlNLSikDdaTVXV0C9glYx2K/1CJrSmDKY+5rp9eT2tnBfMpk1Hf3KoYnglR5bJf3M1ZR9hCgc5DzQVz5OgdhzzkcgYseGtbIpFI+MNYdR1hQR3v5fTLnfA626aXN3twucVPcGGU13h2LEVVkPznu1N9JyVXlCUJQWtHcLhOqyITyz9djIgkg2Y1gm5/MHTcygASPJAbIdDbRQc8WfXefxLDRgEXwdz0D1GdVbIWL8creWvTlXjob+TMXvDQwcnFb3NgmcoixJAyckkbmk9IfypLy65txsrhSjqda/H5wsbskLABXJwH784qRaXAt4mezKSYCl65dxgeZeZpunKa7LXGRqO/rxc6CQvlc+J3bGBmKKxOu4ePCAvmOcxH3VHQMHp8z53ab/gtatyQYbWxswW/+3wGJD5oydRK++4N1WLg4TH6G7OMLfziIfR9nyJ89qRP9/mpExQ1nX8qc77RKvPfSSWSlDE9aoqaU7CHBqZef4uq+XonzsrkHrU1d8ki2k6wnjUEEr2RD+ekQGDJeiS1yspp0+NPdbutgIWCT2Z+Gc93HKzKpBdk1MpIzJ61KYqwMP34+f9wMf9GOTp8XZKQDJahkG/74oXycPVmEocHhmxKPzYr1sWJMYtA8q6G+E/v2ZOHAvmytFc8W+rwFIdiwKRFhEe4CkmvrOvDJznQcOJgrIJdla2uODevisH5dHGxszNHe0YePd2di575Mbb68jbUZ7lgXj41rY2FtZYbi8ibRg544W6I57EMDXHDvpmmYOz1Q9J67juZg274MmZDCYnt907IY3LkyVuY6n8msEBCaVVxvlBF63+oExId6yojO949kYF9yocaS0E27ZXGshNRTsrDnXAG2ncxGVdPwhXpmmDe2LozFrDAfCQonC8oRnSpTyhvxoih/bJ4VhcRATwkiJwO6J71IjAnacfZ2FVMA3fBEgmQk9mUXywQkQ8d3oq8nVkYFSRuerMvpsiocLSrHiZJKo+k+ZDBm+nlhIQ1Lgb7CsmbWNiCpohpJFTXIb2w2Anu8SdAVP83bQzYCUAKh3KYmZDVwa5SteQydKN8jAUqok6NsIdSJOuqEGSTALOvoQEVnByo7O1HR2SlgqqnvxtFn1JIpIM0SOrKJelaRDKOdmZmeeaRm1FTRjE6dKuxeP1v0Fy8pGk/VUa9v03MjY3j5mr5Vb2AmkWOsPxaqs57vjfvBdr1MZJo0WUCktOynTJF/50KC7v3eixcVd/+FC0q7Xr/RcEXAzkeF3R38VEwuAavoSK2s4a7Xk7pb28DV0lLANFv+1N5W8dh2dqGScojunusCVR5Tfwc7+Ds4CBvKxYLFlClo7+sX9pQpCNSSVrR3jtsmZ8C/aIIdFaDKCCoeTJqbJE1Bn6ow3tQpMpjUEwsL6+QgU7wmUrtJkNukMKAEq+1j5JFq78PaUtrF3jo7kQ0w05KfCUPnyX5W06jU1inRZ9fTkxruE13kzjaW0FlbwNHaQjoNZGwJWKWuUVN8VckAHRhu0XMjm9l/4ZIwm1wwU2vMhcyly1zYMPReWeyocXVagoM+uYGLZ74ON7KwjHTjQpPsK9lYOwtTWRzLtDnKBoYuStoBc4jVVj1NjGMVF7AE9IyGC3V3hoUpUxi6ZcxvZnWDyFnU4jHkkIvZQT4wNZks14xTpVXauSAa9wAfTPfzQmFLC/YXlGi/z+4G45ua+vuws6BIOw8X+PnI57S9IE87/5cHBODqhGuIsbPDk3Pm3zYwfUHrlgSj1JyYmJjh1/+9E2dOF8u/cZrPQ4/O1/SbZ08W40+/3oNOvQFnwbJwPPLkYgnKHytjk+5yAlm13L0ckDgnENHT/IQxVYP1/23vtWsAFSVNKC9uREl+g5iYqAMdWRx/SgAaPysAUQk+RmkBNBhlplbg9LFCOR59eiDIcvOww+KVUVi8MlIzJHF6UdLpEuzfk4VMA52ng85STEnMCdXprASEp6RWYOeuDHlUy8dHhzs2JmLJ4jAxFLEFv/2TNBw9UaiZgdxcbLFlUyJWLokQreu5jAq8vzMNmXnDrOu0WB/cs2Ea4iI9ZVrS9gOZ2HkkR5usorOzwJ0r47BxabSwA/vOFODdA+mobVJkBvy75TNDcM+qeBmbdzavUiYlpRQocVOsMF9n3LM0HkviA6WV98HJbOw+V6CN6WQrjtORtsyPlmktR7LKsP1sjtF4TrpS75gZKY54nnfShk/JR5FBHBNZiXWJYVgbHwY3e2vJ/6Qui2H0hu5ejtxcGRWM5ZGBEgPF9vuhglLRfxreQMhEEHwuCvYTIEqG4nR5lWxkP0e2ZwN09pjp64UZvl6Y5u0uWs60ugak19XLIx3yI6cYUSdKoBnp4oxI6kSdnRCkc0D3hQsoamtFcVubbCXt7Sjv6Lhum5ntbC+2562VFr2blQK0XC1p5rGCjYmJtOVbBxSdJf9b2vSDxm36ngsKAOy9eEGyQD+LIpBjzBN1rNKqnzrcrrcxMYWdtOvNYK9/tJisTMvicWvpV9ICCNBb+vvkke16bhdugnklQOdxVDZbeeRxJAvMzNPKzi6RXfDzIFC9XrYrQX2Ag70woQqTbQvTiZPF3FShB6mlrWRBu8Zlrt1srASc8jkY58NkAYKyqvYuYVLp7mdqw3hgmVOmArTwfgfRDPNORpaS+arULVa0tqPtOuCS33OCW5nu5WALLwcbOFhaiA6YGm+yndSRNnR2o7GzV7abGdVqdKwY58XoJTO26ZUWvUR+cSb9FH2bnqw8A+/VgQv6ufTcxFUvLPw1ZTa9gNYriklO2vSXZMhEjx70UuvNVv14i4ORo1uZJBCg19Jycc7vIsF9bm2jsKUjj7+jlYXkDDOq6+K1K0iuqMW5yhoB3mpx0bAsNEC6hgcKS1HcokiYWJTtLAj0Q0lHGw6WlGnnx0wvT4S5OWJncZGc66wwRyfEuLvgk+IC+c5aXL2K/G989zYY/YLWLQlGU9OKkRAfJKDo5b8fFzc3KzrWG9//4TrNxd3TPYjX/noM+z6hTlQfN7Q+Dnc9MAvOI3Si/X1DSDpaiFOHcpF1vhKXR+iLCE6Zwekb6CxtdDdPBzi52gjL+Y8UdUMEnG0tvTLlqbGuEw017ZKRWl3Ris620StfXtzI2LL9zi060ddoKhKru2tAskCTTxUj7Vy5kR7V3sEScxeHYdHyCITomU2Z7JNXj8MHc3D8WIHktiqvBSRM8xMQOnN2oLSlOzr7ceBgDnbvyURzc8/wuMrp/ti0IQHxcT7CIJ09X4aPdqYjK3cYYIaHukkrfu7MQIlnOniiANv3ZKCmXmEgCeYWzQ7G1g2JCPR1QlFFM97bk4ZjycVae9vH3R5b1yRg+dxQiUH58EgWdhzL0UxJzOvbuCgKdy6NkXbU3rMFeO9IpsS8GOpBaUqK8HOREXkMqD9XOAxSfZztsGVBDNZMDxVz0Udnc7DzfIGm3VId8XfOjpJ80NTyOuw4n4djeeXaDYTM3cIIP2xIDMf0QE9kVDUIAKUb3tDpSr3cquhg2XiDO1JUhoMFpThXUWt0E/Gyt8HikAAsCfFHuJuTTEU6UVqJk2WVwnAZFsHqLF8vzPbzwiw/b7lhp9TU4XxtHc7X1InZaGQxhijW3Q0xbi6IdXMV8ElwmNfcLFqv/JYWFLa2CNs3VrE9ztawn509/NgutlVaxgRMwp6zRd+rtOjre3vQ2NeLpr5eNPb946169fM0Z4t+isJiktEURz0NSQaTmPhzo1z1zCHVt+qvXFOySQnKL+gZVi4AVNb1nwFideYWcDQ3h6OFJZz0bXu26PloPmWqXMsIvuupJe3tEUmDtOx7egSEX69En2trCx/ZlGPvZGGOq1eUTNgKstYEqu0dwq6O1+Jmy5/gNMBBadNTk8qFCYES9aglrUp01HhTonh0CQwJUAloJB91Mo1uDPLvksgpgtSRwxgMi65ttvtlFKqDnbCiE68BgxeYNtAlbn7GVtHcdyMNKAGvq601XG2tZHOxsRKml++J7CVb8mzZS4u+t09Y1Q69ZpPv+bMuAmEyt2RwKTOgHpTh8/Q78Lzl51BJCUZzu7DCYwF/LoZjvd1kmAEX/5RZnB0j3o2M88IgP9HHZtQ1SAqH+nz8Ti0LCZB0glNVVchpHB5NPc/XW2QV+8pKZGHFcreywkJ/X5yoqZLvPivC0Rlfj4rFsvCI22D0C1q3JBhdsvyX+O+f3YWZMwLk72mo+f1v90rrma7uJ7++FEuXR2pay7LiRrz0lyPI1LfkJ06agHmLw7D+zkSERSljGUcC08xz5UhPLkdeRhVqK4dXhiOLMVLUe9JpTmDKdjulA3S9i3mJ7UI6fQcvob//Agb6hgQkc/TmFf0YzfHK1cMOvkEuCAx1Q3CEO4LC3Y2mIbH43MX59Ug/XyHgk/9teEbQDT9rfgjmLgpFRIyXxhxXV7Xh2JE8OXaNDcPGJWaCLlsRiRWrYuS/edGmG37vviwknS3VwuOtrEyxYlkk1q2Lg7ubHbq6B7DnQI604lv0qQUy/nJOsIzsDA9xQ3NrjxiSdh/ORa8eQFqYTxVX/OY1cXCws8TptDJ8sC8D2UXDDCSD6reuicfMWD8UV7fg/YMZOHKuWGMW3RxtcPfyWKydHyFh2NuOZmLnmTyNSSVjsGFupOSDch70J2fzJB+UES8sfvxzI/xw14IYxAe541ReJbYn5eBcyTBIZVtv04wIbJwZKa04MqCfpBagqWs455WRNhumhYsbnjeKXZkF2JdVLMYhwxBxgs81MSHSGjxcWIYD+SWi7TR0NNMgQvC5PCwQTtaWOFVWheOlFcKAMmpILd5YYzxcMdffR1pqbKOm1tXjbFUNkqtrUTIG+CTgSPBwQ4KHO+I93MSYk93cjKymRmQ3NSG3uXlMAERQR6ATotMhyEGHYJ0OgQ4OsDU1QVV3t9Km7+pEVVcnqru7ZGNb+0bF90CwJm16MQHpjUBmZrAxVVr1ZFClVa93tUtE07VrAhYJGtU2vYDJq0pkk0Q3XbuqtE3FVT/y/XBT2vRqq150pxMna+16/pltcpY6TpSvQYa2h5u+Xd/JCU0XhjRGV2nXD+IiEeFNFt8bGWNublZ6FtnKGrYmprLv1HvW9XQLoOSxremmprTnumCezC0/My4W+OhpbSPvi6wc2/0EqExBIKs6kiE3GkNqT5BqLyCVLdpJmCASFLb4CTBLW9slYWCs4nnD81Jip3QO8LCzEUaXuZZsIRPokpFltNV4dzM+BwclcEqUj72dMKJkePkLdLQ3dfWJdIARaPWdPTfNgFqbmWgtei7kyDYSxFqZmcr75gKGr03yQEbJ8py6TAOSEgGmtujJxIo0RC8L4c/yf/L7jBmjVEtNbeC5NUXvpp+isKq8LktW6cQJ8vt8HbKkbb39cv2QNn1nz7jGNHkvpiZKfqubkyQE8NMk+KT2Uw2lV4v7w+tGgrcHTKZOQnZDk7TpDRnZCFdn6b50XRzC/uISLbaJi+3lQf4yInVfabG2SHUyN8fiAH9kNDegqF25Z3LhNcfHG8dqyzFH54rn1m6+DUa/oHVLgtG5C36KqVPN8Ngj83HXlukC+upq2/HrX+zUQtdj43zwtW8sg7d+og+LIfnvvnoamXrzEsvLV4clq6Iwf0k4XN3txn7drgGUFNSjvKgRVWUtErnElnlv9/WdjjdTNBbpnK3h4m4n40vdvXXw9nMU9tXQ9a4Wg+jLihqRm1mDnMxq5GXVjHLj+wU6Y/qcQHHCB4a4aXOSa6rbcOpEIU4eL0Kl3sXOMjWbgrnzQrB0RSRiYn3k5xsbu3DwUC4OHMrVDEms0BA3mRu/cEGorLQZybRzbyZOninRWvHUg65ZHoUNa+MkhikrvxYf7c3E6ZQyTQ/q5myDzavjsHpJpFzE9xzPxYcHs9DUqrwWL85LZgXj7tXx8PfU4WR6Od4/lIGckuHpIJwVv3VFHObG+SG9uA7vH8nEmZxhw5GXsy3uWhyLtbPDJf6FWtBDacWaSYEswLqZ4dKKnzBxggTTf3I+D216UxNB6uwQH2FBqQU9WVCBHSl5OF9aa3QzYx7opmkR0FmbSzbfrsxCMWsY/gxNSASgfk4OOFZUjn35xRJEbwhAmf1J8LksLFBuFkeKy3GspFwmmRiyWYw8IvCcH+CLGb6e0pY9XVmNpKoaMR6NjFVii32Gtyeme3og1t1VWM/0hnqkNzQgs7FR2LeRRRBGsBnh5IRwJ2eEOzkKOKru7kZxe5u06Uo72kUrSif8jfSQHtbW8BCApYAsFXQRLBGwdQwNom1QadO36dv0/DsCPG5dF4YEAPZdunhdneS/owhcLadMVdr1U021lj1b9QSO4q7Xt+3J2BLMUrs6cOmyMMFsYzb394nDvmWArfvemwLtfF0eMwJKHk8+8s8El5evXEHbwACqu7pFt8sFAZmq8W4OvCK4WVsLSPW3s4ePnS0spkyVSLfm3j4NpJJVNZSJGBbBO4GhwqbaizlrIiaif+iCZKQSoHJS1PUC/ZmHqgb5e9nZyvHisWIngjIBGY3a1nldEKYOBSDIZdYt46PIgDKIn7dH6jr5fAR0Td19oldt7e2/aXf9WEUQaTqVo2gVMMmNn4/WpjcwzfG7q2Tb6mfTM1nl8mVF83yD9zXme7WykPQAbwc7YUwJJrmQ4LQvmYzW1Dpmlq+/o72YFRlj1XthCKnV9chvGr4PsPg5zPb3lhb92eoaLZ6JRU3zggBf9Fy6gANlpZqxj9/nuT7eyG1rRn6r8nyWU6dgkZ8/8jqaUd6ldG/8TS1w7KEnb4PRL2jdkmD0F7/6EMeOl8rfzZ4ViO98axWsrc2Eafzg/XN46/XTAtrIgLLNfN+Dc0TrqBaZ0p0fpOLEoTxcuDD8pfUPcsG02QGIn+6P0EgPbZrTeDU4cAHtrb1iXCLbSUaVDCgd9rz4XLt6TUwxU6grMpmsmJesTGFlYyYxUHb2lmJsGq/IQtbXdqC0qBElBQ3CepYWN2qxSmqRlY1N9EX8DH8Z0anTyxQI/EqKG3H2TIlMSCIbqhYlC/GJfli8NELa8GZmU8URf/JUMQ4fyUOOQYvdki77xeFYvSoG/n5O6O4ZxKFj+dhzIBtVNcMr7pAgF2xcE4eF80KEsWUr/uMDWaiqHf6ZuAhPbF4Tj1kJfuKG/+hgFg6eKcCQ/nOwsTLF+iXRuGNZjOzjzhO5kg/a2qmwi2w7L5keJCH1Xq722JtcIK74ysbhdvWMcG/cvSQWcUGeOJpZItFMeVXD0SUhnk7YsiAaS2KDZEIJQeiZwkoNxDK2ZOOMCMkGJQvJNjwnIxm27th+v2N6JGYGeeFMaTV2ZRQguaxGA43cz/nBvlgXF4Y4HzcxIe3LLcHZimojfRYB6MrwICwLCxBAcqSoHEeLy1DSasxkUJ+3KMgPCwP9ZAIOwSc3MqAjjTKMAJrt7SUAlK13tspS6uqRWl+PzMaGUZpLAhMynNEuLoh2cUWkk5PE2JS2t8nNpaCtFYVtrdJiH6/Ychb2jW1iWzt429gKWJo8aQJaBgZQ19uN+r4eNEh7vheN/b1oGei7KRA2XrFFzxY1W8Fkd2Wk5+TJmhlJWE1mik5UuE3R8Y0KwCfDqgcKV5WM0gtXFSMUAYPKvA7qmdf/S3E/qCfVmSkteydzSziasV1vIaCW2acKaL0kQJXHiseciwUesxuBcAJkVVPqY2MLVysVqF4V1lIxl9Fo1nnd1j9BtoBUe3v5LKmJJc3GkazMNmW2LMHqeMMLeMypDyZIJaNKkEr2myCssbtXpCUVbe1ovY5piZ+dpzYa1VY0s9RkkpXkeyELSiaV7nzDTsG478lkqjZ6lmDO0dJC/o7Pyf29cuWasJtkOulQ7xoYRPcAtZxK5BKZVkpsPk2e6Kc9N7hotTU3g62FKewtzIWhtTE3lalyZPB5nvLcIOgUyUJ7l+zreOkIvLYweossL5MhCDyz6xtHLS4iXJ1k6tqESROQXt+AnKbhNjxZULbiKXPIbGpEbsvwv1ETGuHihNSmejmvWKaTJ2Gxnz9q+ruR06pcc22mmmCWlydWunhjfUTcbTD6Ba1bEox2dXXhxKly/PWFo+ISd3CwxLefWYnp0/zl59h2fuG5wwLCWGTwVq6JweYt0+FqYGCiPvLU0QIcP5iLnIxqjbWT3zGZjOAwNwSHuyMgyEW0ou6e9mMGzP9fi8YpxlI11HWgtrodNZWtohutqmg1MlWpZWNrLi13ZoFGx/vAN8BZYz8JKDPSqpByrgyp58vR3j7cIibbGJfgg/kLwzBrTpAAeJqWzqeU49jxQiSfK5PjyeKqPi7WByuWR2LO7CDRjGZkV2PfoVycPluqsaCmJlOweEEo1q+KQXCgC0oqmrHzYDYOnyrEoH7f6dRcviAcd6yKhYebHU6mlGLHoWwJq1crwMtRXPHL5oSgrLZNAOiR88Vyg2DZWZlh0+JobFochd6BC9h+PFs0oarhiC2v1bPDcNeiWFnVsw2/KzlfG+XJHNMlcYHCgtJB//G5fOxIzpNoF7WoASULmhDogcM5pQJCC+qGmQOyEBsSw8SQRIZlZ0bBKB0ojUjr4kIxP8RfJhntyysWF7whC8Pom5URwWISIJt1uKgMR4rLtOBo+awmTECitwcWB/tjrr+3GF5OlFfhZEWlMFaGxTb2bB8vzPH1Rry7mzhcz9fV4nxdHbKamkZFExFsxLm6Is7NDXGubhIxVN7ZgeyWZuS2NCGvpVnazmOVi4UlQnSOCLR3QJCDA3xt7MTEQYavoqsTld0dqO7pko1A6kbh9ywCSWdzuuktlDa9qbm06MkskmnkzYyudvUcl1gm3pgFJBo46q8Mt+r572qbngCP+zHeeExxO09Q2vRKu54tev28ev2maFIngU17wbPCeCkLPoLEgcvKlCYyuNykVT+ktOzJ9rKlf7Ml4ezmFnCxsIKrhSVcLa3lkeCbYJrfPYbt1/b2yEKD0Vn8zK9X3H8uELz1QJXHmswhz0saqghQyYLW9owfm8RzknmnBKkEqzRpTb42UUApI6gk47S947pAl3msjKEiSCXTxmPLRTdd6gSXle0dqO7svq6Bh58T5S4cDMD4Jw5KoEaYu62CSYJedRsv73S8sjEzUaZ+McXBTD/5y9REAB4XOzxH2FFnE1+GhjAyTI6Z/sSQUv97+O8Mj6qwpXJO8jy9Kiwp95OAn+155uwy9WA8VtqweCyYF+tpby3jgglaGZ2W39gyKs6NRSCe6O0ORytL9F66IAtVSjbU4h4neLrLczYP9uFkVZV2DeGxn+fjAyvTqThZUyXnuHpN4d/X9XcjWw9CKXOY7+WDou5W1PR2wWuyKU4/8PRnHO3U/C+awOR8O/T+VgSjlVUN8PF2RUlpE371612o1Y+iJHv3pccXCjhlZWdV49WXTiA/VwE9vJnNmh2ENevjEBvvYzQ5ifFFNP6kJpdJG5/h+SOLv+/obAMXNxthH9liZ3SRpbWptNTpIBe96EQagxST0uVLVwXwsZXOyKee7gF5brr8yaq2tvRoIzfHKjKqZGwDQ1wFGIdGuEs733B+fHFhAzLSq5CRXonCgnptehKLjGfidD/MnhOM6TMDYGllKvuTmlaJU6eLRQeqRjKpjviliyMkpN7JyRrVte3Cgh48mo/WtmGwFOjvhDUrorFkgRIef/RMEXYfzkFR2fDK2dvDHhuWx0hIPQEko5l2H8tFR/fAsBkoMRCbV8QixM8JR1NKxZRUWGmw+vZzxp1LY7EgwR/JedWSD5piYDjydrHDnYtisGJ6CLLKG7D9VDaSC5SRoiwXeytsnhslzngCS05HOp1fqd1wqRFbNz1M9KBs3X2cko9D2cMRJhJeH+EvbXi652lEYhueujS1GDWzNjYUq6KC5aa8J7dIGE5DkEpDxqqIICwLDZQ27aGiUmnDtxu4ntn6m+fvg8XBAYhyd0ZGQyOOlVXgTFWNjNTTzsMJE8RoNM/PB7O8PXEFV3Gurg7JtbXSeh8JPmmSmebugQR3d0Q5Owtgy2ppEo0ot7GAjEQ52TsgwtEJoY5OCLJzEMBPRrOkox2lne0o62oXjej1dJEEPGzPu1vZwMNS36K3sIKjmbkcW3J9fZcuSGu+bagf7UN6N/0FvZv+wqBo1v4vWZ//juL7VNz1BM/6dr1sbNmbwWqqifwMOVrRBF6+Iox26+AAmgf6lLb9gNK2vxkZAgG8uyWlDzaiKyVYNZs0RRDP0KUraO7vFU0ptaU0j13vOWmwovGJIJWsKhlWFoPZaTpT2dTrRVXZmZrC394Bvna2wpKT2WTUERlGgkuCVNXgMlbxasYJVOqQBC6weLzIhBKkNXT3SNueGaw3cpqTzXO2spBRq2RCKWvhYoYtdF6TeewJ/kST2T8gOb9tfQPjsoyfdVELSlaXmlmGyzPonuQAF1kcBsHgembIjjc21svORvSf9lbmoqemiTG7scnonOAxS/Rwk2lunRcGcbq62ujzDrS3R6SrC5oGenG2tkYD1owei3d3R1FXq1wTlOeaiHme3qgf7EFRpyJXsjcxw0N+4Xh65uLPFIwuMtnyL5nAdOzCB7fB6K0IRtds+S1+/l93Ii7aG0NDl/Dq66ew4+M0YSnMzafinq0zccfGBAGHPDyMKdr2TjLS04a1onTcL1ocjnkLQxAU7GpkYuLv1Fa1oTCvHsUFDRKxRJaSYPJfVQSzBJkeXvbw8tHBy9dRgufJxhqCZjKfBJ95uXUSQl+QX2ckNWB5eNpjGufVzwiQgQBkc/l7ZEDPJJXKI4+bWgSdixaEYtHCMPj7O6GzawDHTxcJCC0qGW5vW1maYsmCUKxaFolAf2fkFNZj39E8HD9brLGgbK3PnxGE9cujEBHijnNZldh5NBfJmcNaTgdbC6xbHIn1i6Mk2uST4znYcypfAKvKYi6dESwz4x3tLfHJ6Vx8cioXrV39GhibG+2HOxdGw8fNATvP5uHjpDyZMc3iRzkz1EdmxQd46LA7pQA7zuWhWf/vrIQAD2yeFYkoXxfszywREMr8PrU4gnDjtAgsCPdFSmWdsKB0xavFG8KKyCCsjQ0Rs9revGIxInUYTEwRs1J4EJaGBaBrcBAHi8pwtLjcyOjBKSV0sS4JDhDna1J1rQDQ7IZGIyaFbcr5fj7SMqNWjCAyqboaZ2trR4EEgs8Znp6Y4eGBQJ0Orf19SGtsQHpjA/JbR0c58XgG2esQ7eyCSCdnASZXJ1yVm0the6tsJZ1t4wJCsltkSP0IaKwVUONgZi6LjYErl9DQ14P6/h5p0zf2c+tF29CN8yBHFveTQMlqiok80oVuobXpp8B00ghHvV7Dx/Y325yKYUn5ng8H4JOlGs4kvaRv10ubXpjWK8K4iknqymUZQcqM0/7Ll+SRGtZ/tMgy6UzZsreQdr0T2/dmlqLdJOvGfSPLS7ascaBPmGYeQ2p0b3TRpxnK08oWXtY2AloJlHkc+HxdgxdQ092Fqu4uYVav13qmrEDC9G3txGBGcxePE4Eb9alk1K8HMsmmcvKWpCtY24isgpB86NIlAYCib2Wr/QZyDbb6OR6V7X+G6ZtMnCzXaZqgCHjZuiZg5ePNttItpk6VaVLK6FlzeV4mMxCYMR5KGaWknCNXyLJzOMKlq7L4IgNL0xyBrWSM6s1L3Lhf6j6o8hBVTyrmJdGYcuysMr3JOBZKMb6q0hGCZoLMpp5e2a6nv+VrUdpARtPBykKuxRLH1tIqAHTkUfGwtkKUu6vEVTHB4Xx9ndF3nPIRmhxp/jtbVyOMv1oJrm5yvTrXVCeLRxYHLcx090LdQBeKuxRJmPnkyUh09UBuRyMW2HvgD0s/WwPTbTD6r6tbEozOWvJzTJlqKlFBj94/R0BnUXEj/vSXQyguVgxMnOZDULpqZZT8O4umnT07M3D0cL6AM7V0jlZInO6PhEQ/REV7ipZzZPEwd7b3o7G+Q2QA7S296Ozo07SiBKoEhQy6F2aSN75JEzFl8kTJ/qTrnhOOLK3MYGNLzail5Hc6OlvDycUWVtamo139/Rdkn8tKmlBS3ITiogYxIY38xBkyHxPnI2xvfIIvXFxtFUBd2yHAM/l8GXJz6zQnvApA584Jwvx5IQgPc0cfJQvJJTh2skja8apkQaYAxfti2eIIzJ4RIK55akH3H89DncH4UE5JohmJLCgD6vccz8PeE3lo0wfmsxIivLBhaTRmRHvjTFYlPj6Wg4yi4Va9q85aoplWzw1DSW2rsKCnsyu0C7u9tTnWz42QSUnVLZ346EwuTudWaCYgW0szrJ8VLlsl//1sLpIKq7TfpxZrbWKYzIhnNAzb8GeKhv9dAGZMkATTU1e5K6MQR/JLNZaUQGZGgBfWx4XJCENGMe3OKdJG4sk+WphhRXgQVoQFSOuYOX1kQA1bhbz5LQ0JwOIgf7lhHK+oxNHSctR2G2syGbHEiJTpXp7ouTiE0zXVOF1VrcWlqEWnOcHnLC8v0X5SX5jaUI+UhjoBCyOL4CfOxRUxLq7Said6L+1sQ05rM3LbmlAz4vnV4s0zyE4nwDXQzgGeVjaYMmkC+i5fQlVPJyp7OlDFFn1vp9GNa7wi8yXTicwsBYgRwFJPaT/VTIACwZo6WlGNX+q7rGSN9upBodKqv4jBKwZtenVGPTWg+ugmzeU8ak79cKtenVc/ZYICDpR2vb5VP3GSBnq5sWVuMVkBxBxlqUZIsaT9KtrTK6LxI7urMr1kfgnE+R5utnicKGMgo8zWPY8VX5uvefnKNXkNttoJVGt7u4VdvV4JQLSygbe1rTxSBsG/I5PJZACa1Mh4k63F9QxQVtYSJ0VtMJlfjsMkMGPoP4ceEGheLxOWiwZqXPkcTpQhTJmCa1fJ7F6SRR2/DzWdNwaq3HcyoGz785HAm+10stDUy9Jtz+9fW1+/DA9ou8n29/WK4JKvYWJgXqJbntdL7o+cWCxt2hc3ZZFDaYTokcfR3N6ouIClWYtMKfNPhYXGVZFuMN2Ax30sQE7wGeriJL/Tf/mCJGiQ+Tb6GStryRamGiWjqcFocAV1zpT2dF8ewvnGOu01KClhx6W4uxW1fd0aCI13cUdpdyuaBpXn8JlijpNbb7fpv6h1S4LRnz/7IY6eVObfurva4ptfXYbEOB8BUEeO5uHV109rDnAbGzOsXxuHtWtitfY9w+DPJZfhxPEC0VYaTiOS53S3Q3CoGwKDXODn7wQvbx0cdFaaZu2fWTRdtbX1orGhE/X1nairaUc1s0ar2tCsH5k5sgg2wyM8EB7pgahoL3j76ATI9vQMIiu7GmnpVUhNq9CyQNXy9tZh9sxAzJkThOAgF5mGlHSuDCfOFCM9q0paYmqFBrkKC7povuKaP5lcgoMnC4zC6TnKc+GsYAGhgb6OOJlaJiA0I3/4Z2ytzbBqfriwoAQENCQxpJ45oSzewGfH+AoI9ffSYe/ZQmFBG/WxS6y4YA9smh+FSH9X7E8pEhaUs6a1fw90xx1zohDs5Yi9aUXYeT5fsgMNWVCG0/u72mN3ehF2pxdKlqD2+75u2DAtAkFuOhzMK8HuzEK0GPw+RxMSgBKIMlh+T06RzO9Wi1qypaEBWB4eKBqygwJAy4wAKN2+S0MCsTDQV4AT5zcfL6uUQHe1eFOh9pMAlC7lvNZmnKisRFpDg3FLbeJExLu5Yba3N8KdnATkkNU4V18rbdmRFWTvgAQ3dwGf1OzRGJPV2iit+gq903VkuVtaIUznjFB7R/jZ2IqZj7rH0q42lHYpLfrGgfEZMZaDqTk8LG0EtLpbsJVsJYwmv0dkWwgmWwb7ZGsd7Jc2vbjqh/o/VSTS57l4fttOHW7Xc7M3MRfnPYPmCXh5BSczS6aNIJWpAk0DfbK1D95cDqvVlKlwt1RYUBdzKwncnzRhkqLHvHhRwCp1vDW93deVPAjItLSCt7WdPBcZVjKZBE+cMFWjB6rXA9MEZgQ1zD4liCbI5JsYuKikCfA5arq6xo2SYhHQEex6stWuB6pcLBAwU7JCQMlM1sae3us+j+H7YnQTp33pLMzFlMXFlRrdpQbTX6L2WALpL6OPQxYuXJRHSm76L176lyQ5TNAvhKlNJTvLtjwNhBL7NGWyyFm4wOF3gsCcaQfMoB1vRK+64A121IlZi983tt4LWlrQrA+kN7yWRLk4S1wX2f6MxgajhSQ7D5T3cNGc0dKgaURZUU7OsvhOa6nTOgRc2EQ5uaCoqwWtQ8pr6UzN4W9ni+U6Hzwae3sC0xe1bkkwSpo/r7AF//vcIbTpDTpzZwXiyw/Ph4e7vZhw9h3IxrYPzqNJD+jY6p4xw1+yMacl+mtOeQLTrKxqpKVUIDO9yijyaKR2kyCQ7X2CWls7C3GxM9eUukz+O40ziqBdyZnjfvD5qcnsH7ggE5DIpHZ19YuxiJpRPhoap0YWWVv/AGcBxpwHHxLqpjG3dLXn5dUiO6dW3kN5RYsRa8r3GBXpKaH0zGRlHmhTczfOnCvDmeRS5OQZRwv5+Thi4dxgAaCMZDqbXoGjp4uQnF6hGYlYsRGewoDOnxGI0upW7D+Zj6PnSjCg157KSMtIb6xbFIn4CC+cTC/DrpN5yC0bnnXsZG+JtfMisGZuOMoa2vDxqVwk5QxrORlgv2ZWmDChnKJCAHomz+DfzUywZkYY1s4MkxGdNCOlGEQu2VmaYd20MKyIC0ZBfYu04XOqh1+fjvl18aFYHBWIgoYWfJKRj7y6Ya0qDQwro4OxLCJQLvxkQJkFqh5f3nDnBvpgdWSwuHKPlpTjUFGZUQueAHRZSKDEMLUPDeJIabk44A0nFhEcLvT3wzw/b2HSk2pqcKKqclTr09vGRgwCBJVkLdIa60W7VTaC+ST4CXd0wjQ3D4llYqIEM//Sm+vF3TpWiDtBR7STCyJ0TmKWuTbhKqp7u1DQ0YKijmG2YzzA6WdjD1+2563sRDvImx9ZSYJMGhrqpE3fLZpIgq5PwwgSvBHIiR5zCiOUTGGpb9PTlEOAIoYS/cQbWS5OGDaOqOfLcM6osZlEsiCv6U0m+igeeQoCFPVn9K1appUqDJdiOiE4YPu+n+YliZ0iY6vkj3ZfHPqH3Pd8HzymClusMMbmk6fKseAO8bUJ4pntyMUAJRBkXW8GrHpY2cLT0loMYqYTaYaCsHNczFBXyoXMjWQHXFCQUaWRTRYWmCAaVcpQyKhXdXVd932rQJVGKLLgBIQ85tJuHxyU5ACC1RtphAkimRbAgHUa3WRs64SJkmAiObBDF0WPzdG2bf39N2WkG1kEgzTmECSSqScgZhufry1td2HSFVZdy2nQhiuo56ByjhkOW1CYUoWt5/vk9YAgUzEwKbm1N7u3MpnL1kbkBlwUXwEnfg3JgoHHcazjH6rTiZ6W1xF+5pyqZvh6/K5Fu7rI2NL89haR1ahFgyGvK+0XB5DbPizh8rK0FhlFdnujfAdYlJ748e866+V6oLs2BSlbv3fbTf8FrVsSjL7+/gnct3mu6BRfees0du7JFFBFwLlyaQTuu2smXJ1thBU4faYYOz5OR15+nVFUEcEZY6Hi43xhYZDn2ds7iMKCBpQUNaK8rFnAaUNDp5Ep6J9dBI1OzjZwc7eFp6cDPL0d4O3tCG9fnRikWIxKqqxqRVFRIwqLGpBfUK8ZtwzL28tBJiElJPghOspTYqXyC+txPrUCyakVqKgaZvRYAX5OmDcrCAvmBsPF2QbnMytlPvyZlDJNB8ry8XTAsvlhWDYvVG4cB08X4uDpAjTqc0FZbk42woKumBcmzObeU/k4llqKwQvK8/DCPTvGD+sXRsLd2Ubc8HuSCtDWPbxajwl0x4Z5kQjxccKB1GJxxBv9u78bNs2NhJezHfalF2Ff2vD8d5kGFeQlkUyc80wG9EhuqbAc6uvPDfXF+oQwXJsI7M0uwonCSs0QwQv1nGAfyQMliNufXyJjOQ1benFeblgTGSyTXU6VVwkLamhCIiOxPDRQsvpoVDpcWo5zNcYTlTjGcWmQvwTO07hD8Hm2psZoLCSd22y9z/X2Fvcr2+2na6qQ3WycIzpBH7Eyw90ToTpHXJ5wVUBnWlM9ijtGD2tgOzXGyQUxjq5yI+dxYHs9r71ZbjwEUWMVbyzBbNHb6kSLyP27eO2ysHfSnu/tlPY8W+XXK964nc0s4WxuBRdzS/lvOxNz0Zup7c0r16jPu4LeyxfRfXFQ9olbz6UhudH16bfPA3tKkMiWOXWelpMJkk1E08qNLfypE5QQfaWFP0EDIQSxBCBkrMgKs33fcWHgpkEIpQM8fq7m1gJaLSdP1VhWAhwCEoJVRmrdSJ/LPSODyc+Vz8nnosaW7WRqFKknrO7tvqG0gO1aAlVGVpGZZeaoolEdRH1vrwCfG4FMNZOWjzymBJiinbxwSbSJDPknu3czulAuVqifJhtKJppgksdo0gSaS6HP/LwsjGevHgR2DZEN/eynL7EIgu3NlJgnsqUE3JR98UoydPmSJF7U93TLJLPxigYjJhfw9/l9oYyjpL1t1HkWYG8voJYjQvPaW2SBoha/m9HOruAorOy2RpHGsHhKxzi6SEZzVvtwFrJiVLREdke9fvF5Ta4bm51D8Vjsgttg9AtatyQYnbH6F4gK98UzTyxBsL8zKqvb8LdXT+Ccfk66jJacF4I7NyRI3BCLQO7AwVwcO1aA9g7juKOQYFfERHshPNwDoSGuGgBUi0CQLXOyrG2tPWhv6xP3PdvijIeiGYgOdf4cQfEE/fPS8ciIKFPTKTKdiQYgakPJqtrZWQjrSabV3t5SkwCINrWzH1XVbaiqakNFRYswnhWVrVrskmF5eToI6IyK8pL3YG9vgWkc5zIAABwOSURBVIamLqRnViMtswrpWdXoMzBe8XUiw9wxe0agjOak3pTz4U+eK0VyWoURAHV2tMLiOSFYMjcU1lamOJpcgiNni2RUp1rmZlOxcHogVs2PgL2tOQ4kF2L/mUI0tg2DVC8XO6ybH4EFCQHILKvH7jP5yCwdnrBErefqWWFYMT0Y5U0dAkDTSuqM/p3jOZfEB6Ggrlna8AW1xpFL66eHYXqwF1LK67ArrQB17cOsgK+TvUQyhXg44VRJJfZlF6PdoE0f7OqI9bGh8HK0w8nSSgGhhs5ahkWviQxBoLMD0mrrsb+gRIwS2v6Zmcq4PM5/bxnsx+GScqTV1RvdMDm5ZlmgvzwXncnHKitk1KZh0Wm+yM8Pkc7OcsFn2z2ptmYUCKDBaI6nF0J1TmI0Ivikhott2JFFY1GCiztCHRwxdfJEiWrJaWuSm8pYuk627QJtdQizdxLGkzfwi1cvC7NZwhZ9d7u00ccrAkp3Cxt4W9nCw9JWmD2yX6JJvHZFWMTmoV59e74XLUN94wLgmy0CFtXAZDppimJiEgMTGSy9nk+v6SSbZTgaVNJGaWLSs6jaeFDRm16RG7iYma4O61EHr1z6p+RNcg9spyptewdTCwHlBHFkLbmfZGMJyvsvXUbPhSG0DPWjqb8X7RduzvxFV7/II8ythFGm6YcohDIRxi+R8WLkjgourseqEqjyeQiyeTx5nWMLW2n/dwv4ve6+mJiKgYnnAxlVvj+afygh4MhSRkrdCOzyeFFbSoDFKV3U7fJ5JNhenuuCLAy5CDSUv9y0nIJRTjLpS1lIMDNTzEwq+66dM8p1WkxweqZT/s5w0pdqYNJrR5VZ9cP6ZGXdZXAOAnrjHOUa+oXK0JDobw07KeOV9dSp8LGzk8UwTVE8Z6kdLutsH/P3+VnQZU+zKM8DdkAMz2jKMygBYqMvv6MZ3QafjTvZcVtbVPZ2GEh1romkZ+rkCcjrUhlTglBHXMUlVPd3IMpUh+2rv3objH5B65YEo4s2/w8uXlZuKqsXR+LRrbOhs7dEbn4dXn/3rIAwtcKCXbF6eRQWzA2BpYWJsKVkFZOSSiRXs65+dA6bs7M1/HydRGPp6WEPNzdbODvbQOdgKQDz/1L8uGgWamvvRVtbH1pbe6R1zolHDQ1dqK1rl38fq8joBge5IiTEDWGhysasUP5+dl6dzILPzKmRPxsWgWRinC9mTvPDtHg/mUhyNq0cSWnlSM+u0TJDWU46KyyYGSRz4p2drCUTlCA0u6hOa2GKqSnaR2bERwW743RmOQ6cLUKeQRueYzfpiF81O1SMHPuSC3E0rQRDepZSzEAR3jIdyc7GXLSgh9JLtNxQ1RG/bmaYgPm96UU4llOm5XVSR7Uw0h+r4kOEydidVojzZcNtejEjxQZhfpifZO1RB1rSNMwUcvwfGdA4X3fkNTZLHJPhzGy22FdFhiDaw0XcqASgjFDRPguTqQJAp/l4Crt5uLQMGfXD758V6eKMJYF+Ms6T2Z1HKiqM2u+8FcW6umKejy8cLc1Q3tmJUzVVMtloVI6oh5doPqndKu5sQ3J9jZiFDIvHNMzBCYku7sIuXcYVlHS1I7OlHhU9o89zgrUQe0dEOjiLtnPSpAkCDIu7WlHY2SIO+PGKukR/a3v4WdtL25dGDoK43stDAlxr+7tQ199100CTINjBxEJAGcEZN6vJJgII2BYl6FAbnvz/y9cUsEjwSKA4dEXJG71w9ZLmgieIlp/RO+VlNCg3g/a98jko4EDUg4ZGJgJZyR9VgK1iZNI79icyb1LZL9Wtr4cdsodspJB5kzbsFbbyL4kJrfPioLChZHk/bfGYkEnWmVrCeooCLvn6BIYEHASEXGwQINxMrimBJT93PicZXRq3eH0iOCULSUMUme/rFd87ZR5s3xNY87Mi68jJQh369v+NJnSJPlSfpUrQzEUFi991MpYEl2RWb0b2wOeSdAIZJKCwiSJx0A8B4efBfSMI5oKTDOD1TFafl6JcgCyvrZmZXHv4feNnxYUF3wNb8uOBeTKbAfYOMpWK5z7PD05FGrmgYhqGO7WjVy6KRMewy8FUBZoWed4Wdg0vormwCHXQoWmoGw0D+vHKuIZwe2f0Xh5Aw6ByzTSdNAkr7QPx7Ly7boPRL2jdkmC0vLIOb36UKdmWLE6o2LgyBnevT4SDnQWKS5vwwcepYsxRTTk04cxM9MO82UGYkegvwJRFEJiZVY3cvDoBqXV1Yxs61KIhypbZopam0t6nXnTq1EmywmS7gqXpRS9eFtaUmlHOYu/tGUJP7+CYDKdh8cbo6moLXx9H+Po6ytSjgABnuLnainaztLwZhcWN0n7PK6hHq0GwPfSsbFiIGxJivTEtzhf+vo4oLm/GuYxK2UorjRk5D1dbzJsRiHkzguT4cT788fOlRgCUFR3ijiWzQjA9xgc5pQ04lFyElLxqTXdKMDQ90hsr54TB08UWR9NLceBcIZr105NYbK8TgCaEeuB8US32nC9ATcswqPLQ2YgONCbAHcnF1didWmgUTB/oqhMW1MPRFsfzy3Ewu0RaeGpND/CU8ZzUQx3MK8XZ0mrtokuWY1GYHxaE+knYPOOY8htaRhmRZvh5Sl4oAShHGhpqyBYF+WOaj4eArEMl5ZLXp31ubOO7u2GBvy8szaZKlNLxykqjth9ZQrbeGZnCvaL280xttTii1eJxpNudrXdOYCFzkVRfI+yFYfHnInXOAj7ZyifrSB1Xekv9mGDEz9oO0TpXCT4nwOq8OICCzhbkdTSNC17IhpHd4O+SMeK5OXjlomhBy3vaUd3XccN2OUGKm7m1bARSvLHSgU7WhQD2wpVL4pJnm7r9Qj86LvTLvt2o5f+fVgR/NlPMYDNV2cyFxZ0iIHCCnuGjGYfvm7pQgoy2C4qx62a1tswaZeve0VTvKp/IdvkEYdxUrWlDf89NsavMhiRY5SKB5y25QYI5sqqcnkUt8I0+e2p+yc4SzHDfCNq5+OVzcCwtAe+NWvfilrewFBmAClbVEav9F5Xoq3aOWR0Y+FSMNdlOLvSYB8tzkuy6oR5USh3nKQsaxRF/6YrySKc+Py/+t0zy0ic2qMwpi4sb7j+9BHxUYqMmSlqD4sCfKAtrQ90zf5dSHIJvXhf43aTx60bTypSEAyu4WFmKxvXqhGuy8KnsHjvVgD/raW0t9y0uHPl5GhalG9Sq87vJHNHhuCqyoE7CghZ2N2vnpuWUKQi0cUDtQDu69YstGqB8rWxR0deMeda++NP8h26DUQDPP/88fvvb36KpqQnR0dH4y1/+gmnTpuE/uW5JMLrzcBrWLo5DblEDXnjzJPKKlPxHCq5XLozAnWvj4O3hgI7Ofhw4kicbw9sNwRpb1QmxPoiJ9BRnOV2LLEY+lZe3oLyyBbU1HahjlFNTF1pbe28IIj9NkeXkiFInR2thXV1dbISB9fCwFxOWZIMy2qmqFWWVrQJAS8qaUFHVZhTRpL4fyhH4XrhFhLmjvbMf6bk1SM2qQkZuDfoN5tcTUIQHu2FWgj9mJ/iB/o2k9ApxwxeWD4MrVniAKxbOCMKsOF+U1bXh8LlinM2uNDI0hfg6Y8XMEMSGeiC1qBb7zxVKNJNaNCMtTQzGwvgAyfrcl1Jo1IY3M5ki05EWxQSisatHWM686uH9ICBbER+MGcFeYkbiaM56Aze9h4MN1saHwtvZTkZyjjUVaXlUIKZMmSxh9MkVBmM7J07E7ABvzAv0kQs2w+hzG4zH4XECEmfAk92iCz6nsXnUtBLmf1L7m1xXKyYkwxssTQaLfX1lPGLnhSGcrK6UEZuGxQxHTiuhvmvo6iWkNNUjvYnCf+PPmu32aS4ecLQwR+/lC8hqa0Rm6+ige7YwqQtlu503WraWeUPJbmuQEPmxmEmCzlBbJ4lw4Q2SkUlsr5V0twr4HK/4u14WdvCytIOzmZXMpeZxJQvJCJnWoT40DnajcbBHNKCfpsi8yfz3KWZiYLKaYiqGHgIS7Waub8Hzs+CjoUWJ+6C1VfXMqvzNDS6b8myar0nRssofDVr66sbPiKCMLKwwtJcuCbukaFyH/mFQzfdlT7bYxELAK7WpUyYo+lO+7hCD8wlaLwwII0rW9WaKz+diZiVAkceSIFOMURcviXa1ob/3how294ELFbKqqgSA+zQgrvtBkRPcyFilalWpeSVw5md67doEDay265/nZtzyPA9orqH5y1L/XDx+/MBoNiNzTBc+DUIdQwMY+AdjlT7rIstJ5tfOnDrrKdLN4GfHz4uLVkO3u2Gxw8CsWE7NolyG32dDYxKLYJnsJxedzUN9ogEfrmvwt7GHrZkJKnrbDZj9a9IdMZsyCWU9Lcp3C9fgyPxcMzOU9zVr38dIU2e8u+ypWx6Mbtu2DQ888AD+9re/Yfr06fjjH/+I7du3o7i4GE5OTvhPrVsSjCZu/CXiIvzw7UeXSBwQ2b43PkhGfkmj0Qz0rRsSMSPeT25EpRUtOHGqCKfPlaJmhPGHrCYnChHQUT+6YnHEqNcm29ndPYCurgF0dvULaGUOKDWWFy9ewZXLVxRXPNt9XAUzX3SKohdlED9ZVLbUyaza2VqMGivK/M5jp4pQW98h+0fwbDjxyLDIzIYGuyI8xA3hbNcHu8nrcAQnj0VmXs0ottTGygwJ0d6YEe+L6bG+6O0fkpGcZzLK0WDQ1idQjQxyw/xpgQJCqxo7JA80OadK2vtqebvaSRt+2cwQ5FY2YdfpXNGBam7zSRMxO9IXK2eGwt7GHNtOZuNUTrnMp1ZfJz7QE2tmhEJna4HtZ3NxKr9C2AbN7MQ2/bQwuTF9fD4f2QZueLbhl0cHYVGkP9Kr68WMxBGdannYWWNNbCiC3RxxoKAUx4rLxXilVrSHK9ZGhQg7t7+wFKnVdZpmijfamb6eWBEWJLqrY+UVRgCU/57o6Y6VwUECCE9VV8ncd0NWhpqqZf7+ouPKaG7A8apKLRxa3j9BsosrFnj7wsJkCrLbmnCmrnrUzYQt0Lke3gjXOaOmv1O0noxlGslIMT4l0dkDCc4e6L40IA74rLYGVBrdUIbBY6idEyIdXBFko0PDUKewbwSdZT1t47JdbBMHWuvgZ+0APysHdF7qR98ltp4HUNvfKdvNtJ/JkDmZcgqTpTzqTCylPU8Y2XqB4yivijmKwG7g8gV5zp5LSmubr8e2/Oe5yNoR5FmIoclUHvmeyVKKhlVa+hMFGjtMtRZ5AY8hGWGyw3xUmaWbLX42PI5koc0nmcg1iKejzWRzNA72ommgB/UD3TfUh6oMLtlV5bloZpoAs4kmwsxRY0ogc6OWOVvjbhbWAg4JokXuMGGySBd4bpKF4/u+UZG1JFil/pUAk8MAyCJPxWQZoMDpYTczBMBo3yZNEqaWZj4u2tSFjeiJ1QXHNX42Zspwg4uXZNgBWUoeP5qyqFHlMbgZoDzWsWFGKQ1WZJzJYtKsRZ0mr5t9ly8qiyoaraRzwEWHMmqW15AbJQMwmouaUHaHKGchC87PbeTv8TVoSrSYOkUWq+x0GC6c+O+hdjpMnTJRFqWGCxSdibnEvzUOdcm5q1agtT0u4SIaBtVu1zUEWDug+1IvFlgH4ifTt36mYLTpXzQO1OVTjAMlAE1MTMRzzz0nf+ZUME9PTzz11FP4/ve/j//U+ucPSv8cl4q7J+EyMvMr0EvRe68JwgN1+J//WiMTgT7enyWO8JTMUkSEOCIsUCe/4+JohrvviJWNTGd6drVEIuUV1UvUUk5epWy+PjrMSvQa8/UnTQIcHExk+7/U0NAARurr6xs68L9/3jPqZ6lT5T4xdinQzxkBfo7CphoG5F+8OCjb7oNpSM2u1gB2WJALYsO9EBfliQAfJ4NJTpdR19CCd3ed1RjlmBAPzIrzw6xYX9jbWmjPnZ5bjqNn8+S/3RytMS8+AIsSA+HvqWSbsk6lFSA1T8l9ZRbokoQgLIgLEOMR6wjb9ck58t/eTnZYlhCEZfFBcLFXvri7UwtwOFV5jUA3HVbEBWF5TBDsrZX9+O/tR5BRUqmAQH8PacPPC/OF2dQp4ob91lsfo+/CRdFSLQ73l7GcMd5usn9kQnenZ8vzeNnbCMBcGREEL3tb+buf7j2C5OIy+e9od2esCA2SQHo6WFlb392GwuY2ea4EdzcsCfLHkgA/OFgo+/boxzuQ2qAw85zZTgPSEj8/md/N3/m4qAAfZKTLv5MxnOnpLQzoXC9vMWGwfn3uJD4pUPaRNyW23We7e8k0E7qT+Tx1vV344cld2udCIwiBZ4KzO+IdPeBnY6d9Hvccfg857cPAnZFLkQ4uiHJwQYS9qzhbqXtk8YY6Y+dOIyBtMcUEAVY6BNroBKz6CwDVCeAxrEfPvI2sjrrR56yJ4vJ2NbOBm7kNXM2YfWkDZ1MyadYCdkYOeGDtr8vBnwpP4WZLgugnTVU2ARXUB1LTOUVxsevZMcVBzUByfRyPnuXUoqDU2B39o9aWvWZsZrp09bIyfUe0qIqRicdP2NArDN5XwBWhfDeGMD6XPFxvz3kC/laOo/6er9PJ8agEqBcH0D7UJy17Zje2X+gVtpkLiLahXly6dhWtA0NohfEimwD49Kpnho0y164pDNpAj7DUfGwgQzbIR+XPXUwv4L6PiAX6cewybPaL1o4V809r+7tR39ct2uI6/X/zkSzt0LVrqOjvh2IpVWqzfyR+Nn2Zti9kKOv7lXgqPgfBpehU+XcDvSIr6BgcQkeXsTY63MEZ21Zu1f5MZpBt7GZp1fejnbm1AwNKSsEgx8sOyv62D3Gs7GXw0tvQd30dK4Fi2gNP3vDzU6UVqvGNhIRqimOprXdlAtMEAaJjnftqHasux9eP7r3ua/K5KFlwtbSSbFkvKxt4WdvK5DNKcHgN4RCLjXvfHiW74LHjtYBdk0idi3wXZu34q9ZqdzAxx0wXb8x19cEsVx+ca6nC91OU+xLZ+UWuAVjhGYJQW2esPPy8fBdovFvlHo6N3jHYXZeB96pS5Lu53C0Sd/lMw4tlh1HdXYvz3YXaMfusarPbw5gMZQjOP6suQ/neE5QalokJR4QbY4WLFy8iPT0dP/jBD7S/o4RjyZIlSE5Oxn9y3VLMaF1dnawgbtftul2363bdrtv1n1e1tbXw8PD4t77m0NAQbMzscFGWIv/8srS0RN+IiK2f/vSn+NnPfmb0dw0NDXB3d8fZs2cxc+ZM7e+/+93v4uTJkzh//jz+U+uWYkbd3NzkRLaysrru6vLzXFw9EVDzffy7WxW36/Zn8Xmu29+Nz0/d/iw+P/VF+SzIm/X29sp9/N9dpqamaGprFGbyX/L85qO7PSNZ0S963VJglHT2v3tF9a8qXlT+ky8sX6S6/Vl8vur25/H5qdufxeenvgifBXWbn1XZOSjSrM+ydDodJk2ahObmYQ8Ci392cVEy0f9TSxUB3q7bdbtu1+26Xbfrdt2uz2lNnToV8fHxOHr0qPZ3NDDxz4Zt+//EuqWY0dt1u27X7bpdt+t23a7/1HrmmWfw4IMPIiEhQbJFGe3U39+Phx9+GP/JdRuM/ocVdSQUNt9qepLPY93+LD5fdfvz+PzU7c/i81O3P4svVt11111obW3FT37yEwm9j4mJwYEDB+D8/9u7n5Ao1yiO4wcDw5KEBHMRZUYkaCZaJghqEBm0yBbpokVGCIKKbkRz4SoqMFKotFYVahQYFUoJKQwFJYmpaJBQYkoSUVAaREVyOc/FmOremAt33jOvfj8gOqPgw/vqPL85z79168TPltVqegAAAEQW5owCAADADGEUAAAAZgijAAAAMEMYBQAAgBnC6BLx5csXt6pOT3EYGRmxbs6yMzU1JceOHZNNmzZJTEyMbN682e16EK4TO/CzCxcuSFJSkjspZdeuXfLkyRMukcdOnTolO3fudCfcJSQkSFFRkUxMTHAfIsDp06dd31BTU2PdFOAfEUaXCD2b1uKYNPzt+fPnbvPhS5cuybNnz6S5uVkuXrwoDQ0NXKIwu3Hjhtt7T8P/06dPZfv27VJYWChv377l2ntIz8auqKiQgYEBuX//vnz79k327t3r9kCEncHBQfe6lJ6ezm1AxGJrpyXg3r17rjO+efOmpKamyvDwsKuSwlZTU5O0tbXJ5OQktyKMtBKqFbnz58+7x/qmQM/irqqqkvr6eq69Ed0LUSukGlLz8vK4DwY+ffokmZmZ0traKidOnHD9gm6SDkQaKqM+p2fSlpWVSXt7u6xatcq6OQjy8eNHWbt2LdckjHQaxNDQkOzZs+fHc1FRUe7x48ePufbGf/+K/wE7Wqnev3//T/8fQCTiBCYf0/MKSktLpby83B0NpvMWERlevHgh586dkzNnzlg3ZUl79+6dfP/+/bfTR/SxTp2ADa1O6/zE3NxcSUtL4zYYuH79upu2osP0QKSjMhqBdGhRJ5v/6UM7Wg078/Pzcvz4cesmy3K/F8Fev34t+/btk0OHDrmqNbAcK3Lj4+MuEMF7MzMzUl1dLZ2dnW5RHxDpmDMaoXOt3r9//8efSU5OluLiYunu7naBaJFWiVasWCGHDx+Wq1evetDapS3UexEdHe2+np2dlYKCAsnJyZErV664IWOEd5hep6d0dXW51duLjhw5Ih8+fJA7d+5w+T1WWVnprvuDBw/c7hLw3u3bt+XgwYOuLwjuG7Sv0Nck3X0l+HuANcKoj01PT8vc3NyPxxqEdBWxdsy6qGP9+vWm7VtutCK6e/duycrKko6ODl7sPaJ/69nZ2W6kYHGIeMOGDS4UsYDJ22lDumjs1q1bEggEZMuWLR7+dgTTEbNXr1799NzRo0clJSVF6urqmDqBiMOcUR/TDjdYbGys+6x7XBJEvQ+iWhHduHGjmyeqFdVFiYmJHrdmedGdJLQSqvOmNZTqamHdTkg7X3g7NH/t2jVXFdW9Rt+8eeOej4uLc3vvwjt6/X+dq7t69WqJj48niCIiEUaB/4Huq6iLlvTj1zcCWjFC+JSUlLjw39jY6AKQbl/T29v726ImhJduY6b0TVmwy5cvu4WWAPBvGKYHAACAGVZXAAAAwAxhFAAAAGYIowAAADBDGAUAAIAZwigAAADMEEYBAABghjAKAAAAM4RRAAAAmCGMAgAAwAxhFAAAAGYIowB8S8+kT0xMlJMnT/547tGjRxIdHS39/f2mbQMAhIaz6QH42t27d6WoqMiF0K1bt0pGRoYcOHBAzp49a900AEAICKMAfK+iokL6+vpkx44dMjY2JoODg7Jy5UrrZgEAQkAYBeB7nz9/lrS0NJmZmZGhoSHZtm2bdZMAACFizigA33v58qXMzs7KwsKCTE1NWTcHAPAfUBkF4Gtfv36V7OxsN1dU54y2tLS4ofqEhATrpgEAQkAYBeBrtbW10tXVJaOjoxIbGyv5+fkSFxcnPT091k0DAISAYXoAvhUIBFwltL29XdasWSNRUVHu64cPH0pbW5t18wAAIaAyCgAAADNURgEAAGCGMAoAAAAzhFEAAACYIYwCAADADGEUAAAAZgijAAAAMEMYBQAAgBnCKAAAAMwQRgEAAGCGMAoAAAAzhFEAAACYIYwCAABArPwFVim42+kGrZwAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "fig.suptitle(\"Himmelblau's function\")\n", + "\n", + "C_exp = np.linspace(-5, 5, 400)\n", + "y = C_exp\n", + "X, Y = np.meshgrid(C_exp, y)\n", + "Z = himmelblau([X, Y])\n", + "\n", + "contours = ax.contour(X, Y, Z, levels=50, cmap=\"viridis\")\n", + "fig.colorbar(contours, ax=ax, label=\"f(x, y)\")\n", + "ax.set_xlabel(\"x\")\n", + "ax.set_ylabel(\"y\");" + ] + }, + { + "cell_type": "markdown", + "id": "5f35bb0c", + "metadata": {}, + "source": [ + "`fmin_nelder_mead` does not use derivatives. This makes the method robust on rough problems, but typically slower than gradient-based alternatives on smooth functions.\n", + "\n", + "The method also accepts a callback function, which we can use to record the solution trajectory." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "5b4acc49", + "metadata": {}, + "outputs": [], + "source": [ + "path_nelder_mead = []\n", + "def callback_nelder_mead(k, xk, fk):\n", + " path_nelder_mead.append(xk.copy())\n", + " return (False, False)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "09d19467", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + " method: Nelder-Mead\n", + "success: \u001b[92mTrue\u001b[0m\n", + "message: Function value spread is less than `tolf`.\n", + " nfeval: 107\n", + " niter: 56\n", + " x: [2.99999018 2.00002511]\n", + " f: 9.3584127648721e-09" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x0 = [0.0, 0.0]\n", + "fmin_nelder_mead(himmelblau, x0, callback=callback_nelder_mead)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "5120c849", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "for i, simplex in enumerate(path_nelder_mead):\n", + " simplex_closed = np.vstack([simplex, simplex[0]])\n", + " ax.plot(\n", + " simplex_closed[:, 0],\n", + " simplex_closed[:, 1],\n", + " color=\"tab:blue\",\n", + " alpha=0.5,\n", + " linewidth=0.9,\n", + " label =\"Nelder-Mead iterates\" if i == 0 else None,\n", + " )\n", + "ax.legend(loc=\"upper left\")\n", + "fig" + ] + }, + { + "cell_type": "markdown", + "id": "400ea917", + "metadata": {}, + "source": [ + "`fmin_qnewton` is a local gradient-based method. If no gradient is supplied, the solver estimates it numerically by forward finite differences, which is convenient but usually more expensive and less accurate than providing an analytical expression." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "ddeb1d2d", + "metadata": {}, + "outputs": [], + "source": [ + "path_qnewton = []\n", + "def callback_qnewton(k, xk, fk, gk):\n", + " path_qnewton.append(xk.copy())\n", + " return (False, False)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "38ddcc46", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + " method: Quasi-Newton (Global: Dogleg, BFGS: Factored)\n", + "success: \u001b[92mTrue\u001b[0m\n", + "message: ||∇f(x)*sclf/sclx||∞ ≤ tolg\n", + " nfeval: 44\n", + " ngeval: 0\n", + " nheval: 0\n", + " niter: 13\n", + " x: [2.99999997 1.9999999 ]\n", + " f: 2.6354236176940717e-13\n", + " g: [-2.41161170e-06 -3.53914313e-06]\n", + " L: [[8.57642809 0. ]\n", + " [2.2562301 5.28706529]]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fmin_qnewton(himmelblau, x0, global_method=\"dogleg\", callback=callback_qnewton)" + ] + }, + { + "cell_type": "markdown", + "id": "ba32ebba", + "metadata": {}, + "source": [ + "When an analytical gradient is available, passing it explicitly usually reduces the total work. The optimizer follows the same local strategy, but avoids repeated finite-difference evaluations." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "3bbfdd2f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + " method: Quasi-Newton (Global: Dogleg, BFGS: Factored)\n", + "success: \u001b[92mTrue\u001b[0m\n", + "message: ||∇f(x)*sclf/sclx||∞ ≤ tolg\n", + " nfeval: 16\n", + " ngeval: 14\n", + " nheval: 0\n", + " niter: 13\n", + " x: [2.99999999 1.9999999 ]\n", + " f: 1.8569681700439245e-13\n", + " g: [-2.41465638e-06 -3.54515898e-06]\n", + " L: [[8.57643868 0. ]\n", + " [2.25622574 5.28702547]]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fmin_qnewton(himmelblau, x0, grad=himmelblau_grad, global_method=\"dogleg\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f526259a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ax.plot(\n", + " [point[0] for point in path_qnewton],\n", + " [point[1] for point in path_qnewton],\n", + " color=\"tab:red\",\n", + " marker=\"o\",\n", + " markersize=3,\n", + " linewidth=1.2,\n", + " label=\"quasi-Newton iterates\",\n", + ")\n", + "ax.legend(loc=\"upper left\")\n", + "fig" + ] + }, + { + "cell_type": "markdown", + "id": "efc0044b", + "metadata": {}, + "source": [ + "Starting from the same initial point, the quasi-Newton method follows a much more direct path than the Nelder–Mead simplex algorithm. As a result, it typically requires far fewer iterations and function evaluations.\n", + "\n", + "**Recommendation**\n", + "\n", + "* use `fmin_qnewton` for smooth objective functions when you can provide a reasonable initial guess;\n", + "* provide `grad` whenever possible, as gradient information usually improves both efficiency and robustness;\n", + "* use `fmin_nelder_mead` when the objective function is noisy and derivatives cannot be estimated reliably." + ] + }, + { + "cell_type": "markdown", + "id": "0ae6286f", + "metadata": {}, + "source": [ + "### Reaction Network\n", + "\n", + "Most optimization problems encountered in chemical engineering are more demanding than the toy examples above because the variables can be strongly coupled, poorly scaled, and only available through a numerical model. As a more representative example, we fit a simple reaction network to concentration data measured at different temperatures.\n", + "\n", + "We consider the series network:\n", + "\n", + "$$ A \\xrightarrow{k_1} B \\xrightarrow{k_2} C $$\n", + "\n", + "and assume an Arrhenius-like temperature dependence written relative to a reference temperature, $ k = k_0 \\exp [-E (1/T - 1/T_0)]$." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "bcd11d1d", + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.integrate import solve_ivp" + ] + }, + { + "cell_type": "markdown", + "id": "9754986b", + "metadata": {}, + "source": [ + "The concentrations are obtained by integrating the transient mass balances for the three species with `solve_ivp`." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "9d5147cb", + "metadata": {}, + "outputs": [], + "source": [ + "def model(teval, C0, T, k0, Ea, T0=300):\n", + "\n", + " def dCdt(t, C, T, k0, Ea, T0):\n", + " k = k0 * np.exp(-Ea * (1 / T - 1 / T0))\n", + " r1 = k[0] * C[0]\n", + " r2 = k[1] * C[1]\n", + " return np.array([-r1, r1 - r2, r2])\n", + "\n", + " sol = solve_ivp(\n", + " dCdt,\n", + " (0.0, teval[-1]),\n", + " C0,\n", + " t_eval=teval,\n", + " args=(T, k0, Ea, T0),\n", + " method=\"LSODA\",\n", + " atol=1e-7,\n", + " rtol=1e-7,\n", + " )\n", + " return sol.t, sol.y" + ] + }, + { + "cell_type": "markdown", + "id": "1607dcaf", + "metadata": {}, + "source": [ + "The dataset below contains three experiments carried out at different temperatures from the same initial composition." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "9d1b456b", + "metadata": {}, + "outputs": [], + "source": [ + "data = {\n", + " \"exp1\": {\n", + " \"T\": 280,\n", + " \"C0\": [1.0, 0.0, 0.0],\n", + " \"t\": [900.0, 1800.0, 2700.0, 3600.0],\n", + " \"C\": [\n", + " [0.832, 0.640, 0.494, 0.375],\n", + " [0.206, 0.430, 0.517, 0.713],\n", + " [0.00104, 0.00429, 0.00821, 0.0143],\n", + " ],\n", + " },\n", + " \"exp2\": {\n", + " \"T\": 300,\n", + " \"C0\": [1.0, 0.0, 0.0],\n", + " \"t\": [900.0, 1800.0, 2700.0, 3600.0],\n", + " \"C\": [\n", + " [0.424, 0.163, 0.0706, 0.0257],\n", + " [0.665, 0.744, 0.881, 0.597],\n", + " [0.0277, 0.101, 0.177, 0.260],\n", + " ],\n", + " },\n", + " \"exp3\": {\n", + " \"T\": 320,\n", + " \"C0\": [1.0, 0.0, 0.0],\n", + " \"t\": [900.0, 1800.0, 2700.0, 3600.0],\n", + " \"C\": [\n", + " [0.0886, 0.00629, 0.000526, 3.12e-05],\n", + " [0.490, 0.301, 0.176, 0.0669],\n", + " [0.329, 0.639, 0.846, 1.000],\n", + " ],\n", + " },\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "8891991b", + "metadata": {}, + "source": [ + "We estimate the two pre-exponential factors and the two activation parameters by minimizing the sum of squared concentration residuals over all experiments." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "6c17b136", + "metadata": {}, + "outputs": [], + "source": [ + "def sse(x):\n", + " k0 = x[:2]\n", + " Ea = x[2:]\n", + " error = 0.0\n", + " for experiment in data.values():\n", + " teval = experiment[\"t\"]\n", + " C0 = experiment[\"C0\"]\n", + " T = experiment[\"T\"]\n", + " _, y_model = model(teval, C0, T=T, k0=k0, Ea=Ea)\n", + " y_exp = np.array(experiment[\"C\"])\n", + " error += np.sum((y_model - y_exp)**2)\n", + " return error" + ] + }, + { + "cell_type": "markdown", + "id": "eabb664d", + "metadata": {}, + "source": [ + "The initial guess `x0` is used to infer characteristic variable magnitudes. It is therefore important to provide the correct order of magnitude for each parameter." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "66056732", + "metadata": {}, + "outputs": [], + "source": [ + "x0 = np.array([5e-3, 5e-3, 1e3, 1e3])" + ] + }, + { + "cell_type": "markdown", + "id": "26b572a4", + "metadata": {}, + "source": [ + "We start with `fmin_nelder_mead`, which is robust against numerical noise although not particularly efficient." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "c2c35935", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + " method: Nelder-Mead\n", + "success: \u001b[92mTrue\u001b[0m\n", + "message: Function value spread is less than `tolf`.\n", + " nfeval: 570\n", + " niter: 329\n", + " x: [1.02365100e-03 1.13579227e-04 5.32813110e+03 9.47936666e+03]\n", + " f: 0.07341888421258223" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sol = fmin_nelder_mead(sse, x0)\n", + "sol" + ] + }, + { + "cell_type": "markdown", + "id": "f7b19e86", + "metadata": {}, + "source": [ + "`fmin_qnewton` can be more efficient for this smooth problem, but only if the finite-difference gradient is estimated with adequate accuracy.\n", + "\n", + "Because the objective is evaluated through an ODE solver, `epsf`, `tolx`, and `tolg` should be chosen consistently with the numerical accuracy of the model output. If the model is accurate to about $n$ digits, the finite-difference gradient is usually reliable to only about $n/2$ digits. As a practical starting point, set $\\mathrm{epsf} \\approx 10^{-n}$, $\\mathrm{tolx} \\approx 10^{-2n/3}$, and $\\mathrm{tolg} \\gtrsim 10^{-n/3}$. Some trial-and-error adjustment is often required." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "49f88c75", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + " method: Quasi-Newton (Global: Dogleg, BFGS: Factored)\n", + "success: \u001b[92mTrue\u001b[0m\n", + "message: ||∇f(x)*sclf/sclx||∞ ≤ tolg\n", + " nfeval: 279\n", + " ngeval: 0\n", + " nheval: 0\n", + " niter: 46\n", + " x: [1.02324505e-03 1.12680592e-04 5.34496071e+03 9.49832036e+03]\n", + " f: 0.07345033490325709\n", + " g: [-6.11813220e+00 3.07777014e+00 1.68829170e-06 -6.00114125e-07]\n", + " L: [[-1.48004230e+03 0.00000000e+00 0.00000000e+00 0.00000000e+00]\n", + " [-3.43225362e+02 1.09210658e+04 0.00000000e+00 0.00000000e+00]\n", + " [ 2.34053992e-04 7.18201904e-05 -2.05196239e-04 0.00000000e+00]\n", + " [-3.35781736e-05 2.02918950e-04 -1.49243078e-05 1.18333997e-04]]" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sol = fmin_qnewton(sse, x0, sclx=[1e3, 1e3, 1e-3, 1e-3], epsf=1e-6, tolx=1e-4, tolg=1e-2)\n", + "sol" + ] + }, + { + "cell_type": "markdown", + "id": "08f0a09a", + "metadata": {}, + "source": [ + "Finally, we compare the fitted model against the experimental data." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "142ac094", + "metadata": {}, + "outputs": [], + "source": [ + "def plot_model_fit(data, k0, Ea):\n", + "\n", + " fig, ax = plt.subplots(len(data), 1, sharex=True, figsize=(7, 2 * len(data)))\n", + " species = [\"A\", \"B\", \"C\"]\n", + "\n", + " for i, experiment in enumerate(data.values()):\n", + " t_exp = experiment[\"t\"]\n", + " C_exp = experiment[\"C\"]\n", + " T = experiment[\"T\"]\n", + " C0 = experiment[\"C0\"]\n", + "\n", + " ax[i].set_title(f\"Experiment {i + 1} at T={T} K\")\n", + " teval = np.linspace(0.0, t_exp[-1], 100)\n", + " t_model, C_model = model(teval, C0, T=T, k0=k0, Ea=Ea)\n", + " for j in range(len(C0)):\n", + " ax[i].scatter(t_exp, C_exp[j], label=species[j])\n", + " ax[i].plot(t_model, C_model[j])\n", + "\n", + " ax[i].set_ylabel(\"Concentration\")\n", + "\n", + " ax[0].legend(loc=\"best\")\n", + " ax[-1].set_xlabel(\"Time (s)\")\n", + " fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "7e295440", + "metadata": {}, + "source": [ + "The fitted profiles capture the main trends across the three temperatures and reproduce the expected consumption of A, transient accumulation of B, and formation of C." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "6c3000c6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_model_fit(data, k0=sol.x[:2], Ea=sol.x[2:])" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "polykin", + "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.14.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/mkdocs.yml b/mkdocs.yml index 31efab13..d1abf7b2 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -178,6 +178,7 @@ nav: - Derivatives: reference/math/derivatives/ - Miscellaneous: reference/math/misc/ - Fixed-Point Solvers: reference/math/fixpoint/ + - Optimization Solvers: reference/math/optimization/ - Root Solvers: reference/math/roots/ - Special Functions: reference/math/special/ - Properties: diff --git a/pyproject.toml b/pyproject.toml index e8703160..11f458ef 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -13,7 +13,7 @@ classifiers = [ "Topic :: Scientific/Engineering :: Chemistry", ] -requires-python = ">=3.10.0" +requires-python = ">=3.11.0" dependencies = [ "matplotlib>=3.8", @@ -34,6 +34,7 @@ dev = [ "pytest-cov>=6.0.0", "pytest-xdist>=3.6.1", "ruff>=0.14.9", + "ty>=0.0.33", ] docs = [ "black>=26.1.0", @@ -58,7 +59,7 @@ addopts = ["-v", "-s", "-n=2"] [tool.ruff] line-length = 90 -target-version = "py310" +target-version = "py311" [tool.ruff.lint] select = ["E", "F", "W", "I", "UP", "D", "NPY201"] @@ -72,6 +73,15 @@ pydocstyle = { convention = 'numpy' } [tool.ruff.format] line-ending = "auto" +[tool.ty.environment] +root = ["./src"] + +[tool.ty.src] +include = ["src", "tests"] + +[tool.ty.terminal] +output-format = "concise" + [build-system] requires = ["hatchling"] build-backend = "hatchling.build" diff --git a/src/polykin/copolymerization/binary.py b/src/polykin/copolymerization/binary.py index 52fa5045..ff9b3a52 100644 --- a/src/polykin/copolymerization/binary.py +++ b/src/polykin/copolymerization/binary.py @@ -8,8 +8,8 @@ from numba import jit from scipy.integrate import solve_ivp +from polykin.math.machine import eps from polykin.utils.exceptions import ODESolverError -from polykin.utils.math import eps from polykin.utils.typing import FloatArray, FloatArrayLike, FloatMatrix, FloatVectorLike __all__ = [ diff --git a/src/polykin/copolymerization/fitting.py b/src/polykin/copolymerization/fitting.py index a094d398..5f3adaeb 100644 --- a/src/polykin/copolymerization/fitting.py +++ b/src/polykin/copolymerization/fitting.py @@ -471,7 +471,7 @@ def sse(r: tuple[float, float], atol=1e-4, rtol=1e-4) -> float: npar = 2 if ndata > npar: s_sq = sse_opt / (ndata - npar) - H = hessian2_centered(sse, r_opt, h=1e-4) + H = hessian2_centered(sse, r_opt, epsf=1e-6) Hinv = np.linalg.inv(H) cov = 2 * Hinv * s_sq else: diff --git a/src/polykin/copolymerization/multicomponent.py b/src/polykin/copolymerization/multicomponent.py index e794eda2..6269c92e 100644 --- a/src/polykin/copolymerization/multicomponent.py +++ b/src/polykin/copolymerization/multicomponent.py @@ -8,8 +8,8 @@ from numpy import exp from scipy.integrate import solve_ivp +from polykin.math.machine import eps from polykin.utils.exceptions import ODESolverError, ShapeError -from polykin.utils.math import eps from polykin.utils.typing import ( FloatArray, FloatArrayLike, diff --git a/src/polykin/copolymerization/penultimate.py b/src/polykin/copolymerization/penultimate.py index e77dafdb..1103654a 100644 --- a/src/polykin/copolymerization/penultimate.py +++ b/src/polykin/copolymerization/penultimate.py @@ -9,7 +9,7 @@ import numpy as np from polykin.kinetics import Arrhenius -from polykin.utils.math import eps +from polykin.math.machine import eps from polykin.utils.tools import check_bounds from polykin.utils.typing import FloatArray, FloatArrayLike, IntArrayLike diff --git a/src/polykin/copolymerization/terminal.py b/src/polykin/copolymerization/terminal.py index 42a2daac..d9eb4ca4 100644 --- a/src/polykin/copolymerization/terminal.py +++ b/src/polykin/copolymerization/terminal.py @@ -15,8 +15,9 @@ from scipy.integrate import solve_ivp from polykin.kinetics import Arrhenius -from polykin.math import root_brent -from polykin.utils.math import convert_FloatOrVectorLike_to_FloatVector, eps +from polykin.math.machine import eps +from polykin.math.roots import root_brent +from polykin.utils.math import convert_FloatOrVectorLike_to_FloatVector from polykin.utils.tools import check_bounds, check_in_set, custom_repr from polykin.utils.typing import ( FloatArray, diff --git a/src/polykin/distributions/gold.py b/src/polykin/distributions/gold.py index 50514182..09670ba5 100644 --- a/src/polykin/distributions/gold.py +++ b/src/polykin/distributions/gold.py @@ -7,7 +7,7 @@ from polykin.distributions.analyticaldistributions import poisson from polykin.math import root_brent -from polykin.utils.math import eps +from polykin.math.machine import eps from polykin.utils.typing import FloatArray, IntArrayLike diff --git a/src/polykin/hmt/diffusion.py b/src/polykin/hmt/diffusion.py index 3d6d2d90..7df9eb90 100644 --- a/src/polykin/hmt/diffusion.py +++ b/src/polykin/hmt/diffusion.py @@ -5,8 +5,8 @@ from numpy import cos, exp, pi, sin, sqrt from scipy.special import erfc +from polykin.math.machine import eps from polykin.math.special import ierfc, roots_xcotx, roots_xtanx -from polykin.utils.math import eps __all__ = [ "profile_constc_semiinf", @@ -299,9 +299,7 @@ def uptake_constc_sheet(Fo: float) -> float: else: # Solution for normal times B = -(Fo * pi**2) / 4 - S = sum( - 1 / (2 * n + 1) ** 2 * exp(B * (2 * n + 1) ** 2) for n in range(0, N - 1) - ) + S = sum(1 / (2 * n + 1) ** 2 * exp(B * (2 * n + 1) ** 2) for n in range(0, N - 1)) result = 1 - (8 / pi**2) * S return result @@ -433,9 +431,7 @@ def uptake_convection_sheet(Fo: float, Bi: float) -> float: N = 4 # Number of terms in series expansion (optimal value) x = roots_xtanx(Bi, N) b2 = x**2 - S = sum( - exp(-b2[n] * Fo) / (b2[n] * (b2[n] + Bi * (Bi + 1))) for n in range(0, N) - ) + S = sum(exp(-b2[n] * Fo) / (b2[n] * (b2[n] + Bi * (Bi + 1))) for n in range(0, N)) return 1 - (2 * Bi**2) * S else: return 0 @@ -501,9 +497,7 @@ def uptake_convection_sphere(Fo: float, Bi: float) -> float: N = 4 # Number of terms in series expansion (optimal value) x = roots_xcotx(Bi, N) b2 = x**2 - S = sum( - exp(-b2[n] * Fo) / (b2[n] * (b2[n] + Bi * (Bi - 1))) for n in range(0, N) - ) + S = sum(exp(-b2[n] * Fo) / (b2[n] * (b2[n] + Bi * (Bi - 1))) for n in range(0, N)) return 1 - (6 * Bi**2) * S else: return 0 diff --git a/src/polykin/kinetics/emulsion/desorption.py b/src/polykin/kinetics/emulsion/desorption.py index 9dcc591d..f56147e9 100644 --- a/src/polykin/kinetics/emulsion/desorption.py +++ b/src/polykin/kinetics/emulsion/desorption.py @@ -10,7 +10,7 @@ def kdesorption_Asua( kfmp: float, - kpp: float, + kpp1: float, Mp: float, K0: float, beta: float, @@ -19,18 +19,19 @@ def kdesorption_Asua( The desorption coefficient is given by: - $$ k_{des} = k^p_{fm}[M^p] \left( \frac{K_0}{\beta K_0 + k^p_p [M^p]} \right) $$ + $$ k_{des} = k^p_{fm}[M^p] \left( \frac{K_0}{\beta K_0 + k^p_{p,1} [M^p]} \right) $$ where $k^p_{fm}$ is the transfer-to-monomer rate coefficient in the particle phase, - $k^p_p$ is the propagation rate coefficient in the particle phase, $[M^p]$ is the - monomer concentration in the particle phase, $K_0$ is the monomeric radical desorption - rate coefficient, and $\beta$ is the probability that the desorbed monomeric radical - reacts in the aqueous phase by propagation or termination . + $k^p_{p,1}$ is the propagation rate coefficient of a monomeric radical in the particle + phase, $[M^p]$ is the monomer concentration in the particle phase, $K_0$ is the + monomeric radical desorption rate coefficient, and $\beta$ is the probability that the + desorbed monomeric radical reacts in the aqueous phase by propagation or termination. !!! note - Nomura and Harada's model can be seen as a particular case of Asua's model where - $\beta=\bar{n}$. + * Nomura and Harada's model can be seen as a particular case of Asua's model where + $\beta=\bar{n}$. + * For sparingly soluble monomers, $\beta$ is often much smaller than 1. **References** @@ -44,8 +45,9 @@ def kdesorption_Asua( ---------- kfmp : float Transfer-to-monomer rate coefficient in the particle [L/(mol·s)]. - kpp : float - Propagation rate coefficient in the particle phase [L/(mol·s)]. + kpp1 : float + Propagation rate coefficient of a monomeric radical in the particle phase + [L/(mol·s)]. Mp : float Monomer concentration in the particle phase [mol/L]. K0 : float @@ -76,7 +78,7 @@ def kdesorption_Asua( >>> print(f"kdes = {kdes:.2e} s⁻¹") kdes = 8.33e-03 s⁻¹ """ - return (kfmp * Mp * K0) / (beta * K0 + kpp * Mp) + return (kfmp * Mp * K0) / (beta * K0 + kpp1 * Mp) def K0_Nomura( diff --git a/src/polykin/kinetics/emulsion/entry.py b/src/polykin/kinetics/emulsion/entry.py index 5d9eff8c..cf7605d1 100644 --- a/src/polykin/kinetics/emulsion/entry.py +++ b/src/polykin/kinetics/emulsion/entry.py @@ -58,16 +58,17 @@ def kentry_collision( def kentry_diffusion( r: float, Dw: float, - f: float = 1.0, + fe: float = 1.0, ) -> float: r"""Radical entry coefficient assuming irreversible diffusion-controlled entry. The entry coefficient is given by: - $$ k_e = 4 \pi r D_w N_A f $$ + $$ k_e = 4 \pi r D_w N_A f_e $$ where $r$ is the particle radius, $D_w$ is the diffusion coefficient of the radical in - the aqueous phase, $N_A$ is Avogadro's number, and $f$ is an efficiency factor. + the aqueous phase, $N_A$ is Avogadro's number, and $f_e$ is an entry efficiency + factor. Parameters ---------- @@ -75,8 +76,8 @@ def kentry_diffusion( Particle radius [m]. Dw : float Diffusion coefficient of the radical in the aqueous phase [m²/s]. - f : float - Efficiency factor. + fe : float + Entry efficiency factor. Returns ------- @@ -97,7 +98,7 @@ def kentry_diffusion( >>> print(f"ke = {ke:.2e} m³/(mol·s)") ke = 7.57e+08 m³/(mol·s) """ - return f * 4 * pi * r * Dw * NA + return 4 * pi * r * Dw * NA * fe def kentry_diffusion_reversible( @@ -172,5 +173,5 @@ def kentry_diffusion_reversible( """ X = r * sqrt(k / Dp) Y = X / tanh(X) - 1.0 - f = (q * Dp * Y) / (Dw + q * Dp * Y) - return kentry_diffusion(r, Dw, f) + fe = (q * Dp * Y) / (Dw + q * Dp * Y) + return kentry_diffusion(r, Dw, fe) diff --git a/src/polykin/math/__init__.py b/src/polykin/math/__init__.py index 90697401..11945d55 100644 --- a/src/polykin/math/__init__.py +++ b/src/polykin/math/__init__.py @@ -2,12 +2,12 @@ # # Copyright Hugo Vale 2024 -""" -This module implements auxiliary mathematical methods. -""" +"""Implement auxiliary mathematical methods.""" from .derivatives import * from .fixpoint import * +from .machine import * from .misc import * +from .optimization import * from .roots import * from .special import * diff --git a/src/polykin/math/derivatives/ndiff.py b/src/polykin/math/derivatives/ndiff.py index 9d5b6ad0..c74b5508 100644 --- a/src/polykin/math/derivatives/ndiff.py +++ b/src/polykin/math/derivatives/ndiff.py @@ -2,12 +2,12 @@ # # Copyright Hugo Vale 2024 +import math from collections.abc import Callable import numpy as np -from numpy import cbrt -from polykin.utils.math import eps +from polykin.math.machine import eps from polykin.utils.typing import ( Float2x2Matrix, FloatArray, @@ -19,6 +19,7 @@ __all__ = [ "derivative_complex", "derivative_centered", + "gradient_forward", "jacobian_forward", "hessian_forward", "hessian2_centered", @@ -44,16 +45,16 @@ def derivative_complex( **References** - * J. Martins and A. Ning. Engineering Design Optimization. Cambridge - University Press, 2021. + * J. Martins and A. Ning. Engineering Design Optimization. Cambridge University + Press, 2021. * [boost/math/differentiation/finite_difference.hpp](https://www.boost.org/doc/libs/1_80_0/boost/math/differentiation/finite_difference.hpp). Parameters ---------- f : Callable[[complex], complex] - Function to be diferentiated. + Function to be differentiated. x : float - Diferentiation point. + Differentiation point. Returns ------- @@ -76,6 +77,7 @@ def derivative_centered( f: Callable[[float], float], x: float, *, + epsf: float | None = None, h: float = 0.0, ) -> tuple[float, float]: r"""Calculate the numerical derivative of a scalar function using the @@ -85,19 +87,23 @@ def derivative_centered( **References** - * J. Martins and A. Ning. Engineering Design Optimization. Cambridge - University Press, 2021. + * J. Martins and A. Ning. Engineering Design Optimization. Cambridge University + Press, 2021. * [boost/math/differentiation/finite_difference.hpp](https://www.boost.org/doc/libs/1_80_0/boost/math/differentiation/finite_difference.hpp). Parameters ---------- f : Callable[[float], float] - Function to be diferentiated. + Function to be differentiated. x : float Differentiation point. + epsf : float | None + Machine precision of the function values. If `None`, machine precision of 64-bit + floating-point type is assumed. If the number of reliable base-10 digits in the + results returned by the function is $n$, then `epsf` is approximately $10^{-n}$. h : float - Finite-difference step. If `0`, it will be set to the theoretical - optimum value $h=\sqrt[3]{3\epsilon}$. + Finite-difference step. If `0`, it will be set to the theoretical optimum + value $h=\sqrt[3]{3\epsilon_f}$. Returns ------- @@ -110,28 +116,107 @@ def derivative_centered( >>> from polykin.math import derivative_centered >>> def f(x): return x**3 >>> derivative_centered(f, 1.0) - (np.float64(3.0000000003141882), np.float64(1.0000000009152836)) + (3.0000000003141882, 1.0000000009152836) """ - if h == 0: - h = cbrt(3 * eps) # ~ 1e-5 + epsf = max(epsf, eps) if epsf is not None else eps + _h = math.cbrt(3 * epsf) - h *= 1 + abs(x) + h = max(h, _h) if h != 0 else _h + h *= max(1.0, abs(x)) - fp = f(x + h) - fm = f(x - h) - df = (fp - fm) / (2 * h) - fx = (fp + fm) / 2 + xp = x + h + xm = x - h + fp = f(xp) + fm = f(xm) + df = (fp - fm) / (xp - xm) + fx = (fp + fm) / 2.0 return (df, fx) +def gradient_forward( + f: Callable[[FloatVector], float], + x: FloatVector, + *, + fx: float | None = None, + sclx: FloatVector | None = None, + epsf: float | None = None, +) -> FloatVector: + r"""Calculate the numerical gradient of a scalar function $f(\mathbf{x})$ using the + forward finite-difference scheme. + + $$ \frac{\partial f}{\partial x_i} = + \frac{f(\mathbf{x} + \mathbf{e}_i h_i) - f(\mathbf{x})}{h_i} $$ + + The step size $h_i$ is optimally determined according to the machine precision of the + function values. Typically, the gradient is accurate to about half the number of + reliable digits returned by the function. + + If the function value at $\mathbf{x}$ is provided, $N$ function evaluations are + required to compute the gradient, where $N$ is the dimension of $\mathbf{x}$. + + **References** + + * J.E. Dennis Jr., R.B. Schnabel, "Numerical Methods for Unconstrained Optimization + and Nonlinear Equations", SIAM, 1996, p. 323. + + Parameters + ---------- + f : Callable[[FloatVector], float] + Function to be differentiated. + x : FloatVector + Differentiation point. + fx : float | None + Function value at `x`, if available. + sclx : FloatVector | None + Scaling factors for `x`. Ideally, `x[i]*sclx[i]` is close to 1. By + default, the factors are set internally based on the magnitudes of `x`. + epsf : float | None + Machine precision of the function values. If `None`, machine precision of 64-bit + floating-point type is assumed. If the number of reliable base-10 digits in the + results returned by the function is $n$, then `epsf` is approximately $10^{-n}$. + + Returns + ------- + FloatVector + Gradient vector. + + Examples + -------- + Evaluate the numerical gradient of f(x) = x1**2 * x2**3 at (2, -2). + >>> from polykin.math import gradient_forward + >>> import numpy as np + >>> def f(x): return x[0]**2 * x[1]**3 + >>> gradient_forward(f, np.array([2.0, -2.0])) + array([-32.00000024, 47.99999928]) + """ + fx = fx if fx is not None else f(x) + sclx = np.abs(sclx) if sclx is not None else scalex(x) + + epsf = max(epsf, eps) if epsf is not None else eps + h0 = math.sqrt(epsf) + + g = np.empty_like(x, dtype=float) + xh = x.copy() + + for i in range(x.size): + h = h0 * max(abs(x[i]), 1 / sclx[i]) + xtemp = xh[i] + xh[i] += h + h = xh[i] - xtemp + g[i] = (f(xh) - fx) / h + xh[i] = xtemp + + return g + + def jacobian_forward( f: Callable[[FloatVector], FloatVector], x: FloatVector, *, fx: FloatVector | None = None, sclx: FloatVector | None = None, - ndigit: int | None = None, + epsf: float | None = None, ) -> FloatMatrix: r"""Calculate the numerical Jacobian of a vector function $\mathbf{f}(\mathbf{x})$ using the forward finite-difference scheme. @@ -139,21 +224,22 @@ def jacobian_forward( $$ J_{ij} = \frac{\partial f_i}{\partial x_j} = \frac{f_i(\mathbf{x} + \mathbf{e}_j h_j) - f_i(\mathbf{x})}{h_j} $$ - The step size $h_j$ is optimally determined according to the number of - reliable digits of $\mathbf{f}$ and the magnitude and scale of each - $\mathbf{x}$ component. + The step size $h_j$ is optimally determined according to the machine precision of the + function values. Typically, the Jacobian is accurate to about half the number of + reliable digits returned by the function. - Typically, the first `ndigit/2` digits of the Jacobian are accurate. + If the function value at $\mathbf{x}$ is provided, $N$ function evaluations are + required to compute the Jacobian, where $N$ is the dimension of $\mathbf{x}$. **References** - * J.E. Dennis Jr., R.B. Schnabel, "Numerical Methods for Unconstrained - Optimization and Nonlinear Equations", SIAM, 1996, p. 314. + * J.E. Dennis Jr., R.B. Schnabel, "Numerical Methods for Unconstrained Optimization + and Nonlinear Equations", SIAM, 1996, p. 314. Parameters ---------- f : Callable[[FloatVector], FloatVector] - Function to be diferentiated. + Function to be differentiated. x : FloatVector Differentiation point. fx : FloatVector | None @@ -161,12 +247,10 @@ def jacobian_forward( sclx : FloatVector | None Scaling factors for `x`. Ideally, `x[i]*sclx[i]` is close to 1. By default, the factors are set internally based on the magnitudes of `x`. - ndigit : int | None - Number of reliable base-10 digits in the values returned by `f`. This - parameter is optional when the function is evaluated analytically, - but is essential when the function involves numerical procedures (such - as root finding or ODE integration). If `None`, machine precision is - assumed. + epsf : float | None + Machine precision of the function values. If `None`, machine precision of 64-bit + floating-point type is assumed. If the number of reliable base-10 digits in the + results returned by the function is $n$, then `epsf` is approximately $10^{-n}$. Returns ------- @@ -183,16 +267,16 @@ def jacobian_forward( array([[-32.00000024, 47.99999928]]) """ fx = fx if fx is not None else f(x) - sclx = sclx if sclx is not None else scalex(x) + sclx = np.abs(sclx) if sclx is not None else scalex(x) - η = eps if ndigit is None else 10 ** (-ndigit) - h0 = np.sqrt(η) + epsf = max(epsf, eps) if epsf is not None else eps + h0 = math.sqrt(epsf) J = np.empty((fx.size, x.size)) xh = x.copy() for i in range(x.size): - h = h0 * max(abs(x[i]), abs(1 / sclx[i])) + h = h0 * max(abs(x[i]), 1 / sclx[i]) xtemp = xh[i] xh[i] += h h = xh[i] - xtemp @@ -208,7 +292,7 @@ def hessian_forward( *, fx: float | None = None, sclx: FloatVector | None = None, - ndigit: int | None = None, + epsf: float | None = None, ) -> FloatSquareMatrix: r"""Calculate the numerical Hessian of a scalar function $f(\mathbf{x})$ using the forward finite-difference scheme. @@ -219,21 +303,19 @@ def hessian_forward( - f(\mathbf{x} + \mathbf{e}_i h_i) - f(\mathbf{x} + \mathbf{e}_j h_j) + f(\mathbf{x})}{h_i h_j} $$ - The step size $h_j$ is optimally determined according to the number of - reliable digits of $f$ and the magnitude and scale of each $\mathbf{x}$ - component. - - Typically, the first `ndigit/3` digits of the Hessian are accurate. + The step size $h_j$ is optimally determined according to the machine precision of the + function values. Typically, the Hessian is accurate to about a third of the number of + reliable digits returned by the function. **References** - * J.E. Dennis Jr., R.B. Schnabel, "Numerical Methods for Unconstrained - Optimization and Nonlinear Equations", SIAM, 1996, p. 321. + * J.E. Dennis Jr., R.B. Schnabel, "Numerical Methods for Unconstrained Optimization + and Nonlinear Equations", SIAM, 1996, p. 321. Parameters ---------- f : Callable[[FloatVector], float] - Function to be diferentiated. + Function to be differentiated. x : FloatVector Differentiation point. fx : float | None @@ -241,12 +323,10 @@ def hessian_forward( sclx : FloatVector | None Scaling factors for `x`. Ideally, `x[i]*sclx[i]` is close to 1. By default, the factors are set internally based on the magnitudes of `x`. - ndigit : int | None - Number of reliable base-10 digits in the values returned by `f`. This - parameter is optional when the function is evaluated analytically, - but is essential when the function involves numerical procedures (such - as root finding or ODE integration). If `None`, machine precision is - assumed. + epsf : float | None + Machine precision of the function values. If `None`, machine precision of 64-bit + floating-point type is assumed. If the number of reliable base-10 digits in the + results returned by the function is $n$, then `epsf` is approximately $10^{-n}$. Returns ------- @@ -260,14 +340,14 @@ def hessian_forward( >>> import numpy as np >>> def f(x): return x[0]**2 * x[1]**3 >>> hessian_forward(f, np.array([2.0, -2.0])) - array([[-16.0001093 , 47.99984347], - [ 47.99984347, -47.99979503]]) + array([[-16.00001242, 47.99984347], + [ 47.99984347, -47.99972236]]) """ fx = fx if fx is not None else f(x) - sclx = sclx if sclx is not None else scalex(x) + sclx = np.abs(sclx) if sclx is not None else scalex(x) - η = eps if ndigit is None else 10 ** (-ndigit) - h0 = np.cbrt(η) + epsf = max(epsf, eps) if epsf is not None else eps + h0 = math.cbrt(epsf) N = x.size H = np.empty((N, N)) @@ -276,7 +356,7 @@ def hessian_forward( xh = x.copy() for i in range(N): - h[i] = h0 * max(abs(x[i]), abs(1 / sclx[i])) + h[i] = h0 * max(abs(x[i]), 1 / sclx[i]) xtemp1 = xh[i] xh[i] += h[i] h[i] = xh[i] - xtemp1 @@ -302,7 +382,7 @@ def hessian_forward( def hessian2_centered( f: Callable[[tuple[float, float]], float], x: tuple[float, float], - h: float = 0.0, + epsf: float | None = None, ) -> Float2x2Matrix: r"""Calculate the numerical Hessian of a scalar function $f(x,y)$ using the centered finite-difference scheme. @@ -324,23 +404,24 @@ def hessian2_centered( \frac{f(x+h,y+h)-f(x+h,y-h)-f(x-h,y+h)+f(x-h,y-h)}{4 h^2} + O(h^2) \end{aligned} - Although the matrix only contains 4 elements and is symmetric, a total of - 9 function evaluations are performed. + Although the matrix only contains 4 elements and is symmetric, a total of 9 function + evaluations are performed. **References** - * J. Martins and A. Ning. Engineering Design Optimization. Cambridge - University Press, 2021. + * J. Martins and A. Ning. Engineering Design Optimization. Cambridge University + Press, 2021. Parameters ---------- f : Callable[[tuple[float, float]], float] - Function to be diferentiated. + Function to be differentiated. x : tuple[float, float] Differentiation point. - h : float - Finite-difference step. If `0`, it will be set to the theoretical - optimum value $h = \sqrt[3]{3\epsilon}$. + epsf : float | None + Machine precision of the function values. If `None`, machine precision of 64-bit + floating-point type is assumed. If the number of reliable base-10 digits in the + results returned by the function is $n$, then `epsf` is approximately $10^{-n}$. Returns ------- @@ -358,16 +439,15 @@ def hessian2_centered( """ x0, x1 = x - if h == 0: - h = cbrt(3 * eps) # ~ 1e-5 - - h0 = h * (1 + abs(x0)) - h1 = h * (1 + abs(x1)) + epsf = max(epsf, eps) if epsf is not None else eps + h = math.cbrt(3 * epsf) + h0 = h * max(1.0, abs(x0)) + h1 = h * max(1.0, abs(x1)) H = np.empty((2, 2)) - f0 = f(x) - H[0, 0] = (f((x0 + 2 * h0, x1)) - 2 * f0 + f((x0 - 2 * h0, x1))) / (4 * h0**2) - H[1, 1] = (f((x0, x1 + 2 * h1)) - 2 * f0 + f((x0, x1 - 2 * h1))) / (4 * h1**2) + fx = f(x) + H[0, 0] = (f((x0 + 2 * h0, x1)) - 2 * fx + f((x0 - 2 * h0, x1))) / (4 * h0**2) + H[1, 1] = (f((x0, x1 + 2 * h1)) - 2 * fx + f((x0, x1 - 2 * h1))) / (4 * h1**2) H[0, 1] = ( f((x0 + h0, x1 + h1)) - f((x0 + h0, x1 - h1)) diff --git a/src/polykin/math/fixpoint/__init__.py b/src/polykin/math/fixpoint/__init__.py index f43a3b90..77dce045 100644 --- a/src/polykin/math/fixpoint/__init__.py +++ b/src/polykin/math/fixpoint/__init__.py @@ -4,4 +4,7 @@ from .anderson import * +from .damped import * +from .dem import * +from .steffensen import * from .wegstein import * diff --git a/src/polykin/math/fixpoint/anderson.py b/src/polykin/math/fixpoint/anderson.py index c56a20b6..5ac22c31 100644 --- a/src/polykin/math/fixpoint/anderson.py +++ b/src/polykin/math/fixpoint/anderson.py @@ -24,6 +24,7 @@ def fixpoint_anderson( tolx: float = 1e-6, sclx: FloatVector | None = None, maxiter: int = 50, + callback: Callable[[int, FloatVector, FloatVector], tuple[bool, bool]] | None = None, ) -> VectorRootResult: r"""Find the solution of a N-dimensional fixed-point problem using the Anderson acceleration method. @@ -50,7 +51,7 @@ def fixpoint_anderson( Parameters ---------- g : Callable[[FloatVector], FloatVector] - Identity function for the fixed-point problem, i.e. `g(x) = x`. + Fixed-point mapping defining the problem `g(x) = x`. x0 : FloatVector Initial guess. m : int @@ -64,6 +65,10 @@ def fixpoint_anderson( all components. By default, scaling is determined automatically from `x0`. maxiter : int Maximum number of iterations. + callback : Callable[[int, FloatVector, FloatVector], tuple[bool, bool]] | None + Optional callback with signature `callback(niter, x, fx)->(stop, success)` called + at each iteration. If `stop` is `True`, the iteration is terminated. If `success` + is `True`, the optimization is considered successful. Returns ------- @@ -72,8 +77,12 @@ def fixpoint_anderson( See Also -------- - * [`fixpoint_wegstein`](fixpoint_wegstein.md): alternative (simpler) method - for problems with weak coupling between components. + * [`fixpoint_damped`](fixpoint_damped.md): + Alternative method for problems with weak coupling between components. + * [`fixpoint_dem`](fixpoint_dem.md): + Alternative method for problems with weak coupling between components. + * [`fixpoint_wegstein`](fixpoint_wegstein.md): + Alternative method for problems with weak coupling between components. Examples -------- @@ -96,69 +105,73 @@ def fixpoint_anderson( message = "" nfeval = 0 - sclx = sclx if sclx is not None else scalex(x0) + sclx = np.abs(sclx) if sclx is not None else scalex(x0) - # Different ordering of arrays to optimize memory access - n = x0.size + x = x0.copy() + n = x.size m = max(m, 1) + + # Historical buffers with different layout to optimize memory access ΔG = np.zeros((m, n)) ΔF = np.zeros((n, m)) - g0 = g(x0) - nfeval += 1 - f0 = g0 - x0 - - if np.linalg.norm(sclx * f0, np.inf) <= 1e-2 * tolx: - message = "||sclx*(g(x0) - x0)||∞ ≤ 1e-2*tolx" - return VectorRootResult(method, True, message, nfeval, None, 0, x0, f0, None) - - x = g0 - gx = g0 - fx = f0 - - for k in range(1, maxiter): - mk = min(m, k) - - ΔG[:-1, :] = ΔG[1:, :] - ΔF[:, :-1] = ΔF[:, 1:] - - ΔG[-1, :] = -gx - ΔF[:, -1] = -fx + Q = np.array([]) + R = np.array([]) + fx = np.full(n, np.nan) + niter = 0 + for niter in range(1, maxiter + 1): gx = g(x) nfeval += 1 fx = gx - x - ΔG[-1, :] += gx - ΔF[:, -1] += fx + if callback is not None: + stop, _success = callback(niter, x, fx) + if stop: + message = "Terminated by user callback." + success = _success + break if np.linalg.norm(sclx * fx, np.inf) <= tolx: message = "||sclx*(g(x) - x)||∞ ≤ tolx" success = True break - try: - if k == 1: - Q, R = scipy.linalg.qr(ΔF[:, -mk:], mode="economic") - if k > m: - Q, R = scipy.linalg.qr_delete(Q, R, 0, which="col") - if k > 1: - Q, R = scipy.linalg.qr_insert(Q, R, ΔF[:, -1], mk - 1, which="col") - - except scipy.linalg.LinAlgError: - message = "Error in QR factorization/update." + if niter == maxiter: + message = f"Maximum number of iterations ({maxiter}) reached." break - try: - gamma = np.linalg.lstsq(R, Q.T @ fx)[0] - except np.linalg.LinAlgError: - message = "Error in least-squares solution." - break + if niter == 1: + x = gx + else: + ΔG[-1, :] += gx + ΔF[:, -1] += fx + + mk = min(m, niter - 1) + + try: + if niter == 2: + Q, R = scipy.linalg.qr(ΔF[:, -mk:], mode="economic") + else: + if niter > m + 1: + Q, R = scipy.linalg.qr_delete(Q, R, 0, which="col") + Q, R = scipy.linalg.qr_insert(Q, R, ΔF[:, -1], mk - 1, which="col") + except scipy.linalg.LinAlgError: + message = "Error in QR factorization/update." + break + + try: + gamma = np.linalg.lstsq(R, Q.T @ fx)[0] + except np.linalg.LinAlgError: + message = "Error in least-squares solution." + break - if k + 1 < maxiter: x = gx - np.dot(gamma, ΔG[-mk:, :]) - else: - message = f"Maximum number of iterations ({maxiter}) reached." + ΔG[:-1, :] = ΔG[1:, :] + ΔF[:, :-1] = ΔF[:, 1:] + + ΔG[-1, :] = -gx + ΔF[:, -1] = -fx - return VectorRootResult(method, success, message, nfeval, None, k + 1, x, fx, None) + return VectorRootResult(method, success, message, nfeval, None, niter, x, fx, None) diff --git a/src/polykin/math/fixpoint/damped.py b/src/polykin/math/fixpoint/damped.py new file mode 100644 index 00000000..0ba1eccd --- /dev/null +++ b/src/polykin/math/fixpoint/damped.py @@ -0,0 +1,129 @@ +# PolyKin: A polymerization kinetics library for Python. +# +# Copyright Hugo Vale 2026 + +from collections.abc import Callable + +import numpy as np + +from polykin.math import scalex +from polykin.math.roots import VectorRootResult +from polykin.utils.typing import FloatVector + +__all__ = ["fixpoint_damped"] + + +def fixpoint_damped( + g: Callable[[FloatVector], FloatVector], + x0: FloatVector, + *, + q: float = 0.2, + tolx: float = 1e-6, + sclx: FloatVector | None = None, + maxiter: int = 50, + callback: Callable[[int, FloatVector, FloatVector], tuple[bool, bool]] | None = None, +) -> VectorRootResult: + r"""Find the solution of a N-dimensional fixed-point problem using direct substitution + with damping. + + Direct substitution with damping is a fixed-point iteration where the next iterate is + obtained from a convex combination of the current iterate and its direct substitution + update. For N-dimensional problems, each component of the fixed-point vector is + treated separately according to: + + $$ x_{k+1} = x_k + (1 - q) (g(x_k) - x_k ) $$ + + where $0 \leq q < 1$ is the damping parameter. When $q=0$, the method is equivalent + to standard direct substitution. For $q>0$, the update is damped, which can improve + robustness for mildly unstable problems. + + Parameters + ---------- + g : Callable[[FloatVector], FloatVector] + Fixed-point mapping defining the problem `g(x) = x`. + x0 : FloatVector + Initial guess. + q : float + Damping parameter in [0, 1). Typically 0.0–0.5; higher values improve stability. + tolx : float + Absolute tolerance for `x` value. The algorithm will terminate when + `||sclx*(g(x) - x)||∞ <= tolx`. + sclx : FloatVector | None + Positive scaling factors for the components of `x`. Ideally, these should be + chosen so that `sclx*x` is of order 1 near the solution for all components. By + default, scaling is determined automatically from `x0`. + maxiter : int + Maximum number of iterations. + callback : Callable[[int, FloatVector, FloatVector], tuple[bool, bool]] | None + Optional callback with signature `callback(niter, x, fx)->(stop, success)` called + at each iteration. If `stop` is `True`, the iteration is terminated. If `success` + is `True`, the optimization is considered successful. + + Returns + ------- + VectorRootResult + Dataclass with root solution results. + + See Also + -------- + * [`fixpoint_anderson`](fixpoint_anderson.md): + Acceleration method suited for problems with coupling between components. + * [`fixpoint_dem`](fixpoint_dem.md): + Alternative method for problems with weak coupling between components. + * [`fixpoint_wegstein`](fixpoint_wegstein.md): + Alternative method for problems with weak coupling between components. + + Examples + -------- + Find the solution of a 2D fixed-point function. + >>> from polykin.math import fixpoint_damped + >>> import numpy as np + >>> def g(x): + ... x1, x2 = x + ... g1 = 0.5*np.cos(x1) + 0.1*x2 + 0.5 + ... g2 = np.sin(x2) - 0.2*x1 + 1.2 + ... return np.array([g1, g2]) + >>> sol = fixpoint_damped(g, x0=np.array([0.0, 0.0]), q=0.2) + >>> print(f"x = {sol.x}") + x = [0.97458614 1.93830761] + >>> print(f"g(x) = {g(sol.x)}") + g(x) = [0.97458604 1.93830719] + """ + method = "Damped fixed-point" + success = False + message = "" + nfeval = 0 + + if not (0.0 <= q < 1.0): + raise ValueError("`q` must satisfy 0 <= q < 1.") + + sclx = np.abs(sclx) if sclx is not None else scalex(x0) + + x = x0.copy() + fx = np.full_like(x, np.nan) + niter = 0 + + for niter in range(1, maxiter + 1): + gx = g(x) + nfeval += 1 + fx = gx - x + + if callback is not None: + stop, _success = callback(niter, x, fx) + if stop: + message = "Terminated by user callback." + success = _success + break + + if np.linalg.norm(sclx * fx, np.inf) <= tolx: + message = "||sclx*(g(x) - x)||∞ ≤ tolx" + success = True + break + + if niter == maxiter: + message = f"Maximum number of iterations ({maxiter}) reached." + break + + x += (1 - q) * fx + + return VectorRootResult(method, success, message, nfeval, None, niter, x, fx, None) diff --git a/src/polykin/math/fixpoint/dem.py b/src/polykin/math/fixpoint/dem.py new file mode 100644 index 00000000..fd7b569e --- /dev/null +++ b/src/polykin/math/fixpoint/dem.py @@ -0,0 +1,167 @@ +# PolyKin: A polymerization kinetics library for Python. +# +# Copyright Hugo Vale 2026 + +from collections.abc import Callable + +import numpy as np + +from polykin.math.derivatives import scalex +from polykin.math.machine import eps +from polykin.math.roots import VectorRootResult +from polykin.utils.typing import FloatVector + +__all__ = ["fixpoint_dem"] + + +def fixpoint_dem( + g: Callable[[FloatVector], FloatVector], + x0: FloatVector, + *, + q: float = 0.2, + tolev: float = 0.01, + tolx: float = 1e-6, + sclx: FloatVector | None = None, + maxiter: int = 50, + callback: Callable[[int, FloatVector, FloatVector], tuple[bool, bool]] | None = None, +) -> VectorRootResult: + r"""Find the solution of a N-dimensional fixed-point problem using the dominant + eigenvalue method (DEM). + + The dominant eigenvalue method is an extrapolation technique that accelerates + fixed-point iterations by estimating the dominant eigenvalue of the iteration + implicitly. When this estimate stabilizes (according to `tolev`), a promotion + step is applied to improve convergence. A damping factor `q` can be used to + enhance robustness for unstable or strongly coupled problems. + + DEM is particularly effective for slowly converging problems (e.g., recycle + systems), reducing iteration count at the cost of modest additional overhead. + + **References** + + * Orbach, O.; Crowe, C. M. Convergence Promotion in the Simulation of Chemical + Processes with Recycle—The Dominant Eigenvalue Method. Can. J. Chem. Eng. 1971, + 49, 509-513. + + Parameters + ---------- + g : Callable[[FloatVector], FloatVector] + Fixed-point mapping defining the problem `g(x) = x`. + x0 : FloatVector + Initial guess. + q : float + Damping parameter in [0, 1). Typically 0.0-0.5; higher values improve stability. + tolev : float + Relative tolerance for the dominant eigenvalue convergence. The promotion step is + applied when the relative change in the dominant eigenvalue estimate is less than + `tolev`. Decreasing this value delays the application of the promotion step. + tolx : float + Absolute tolerance for `x` value. The algorithm will terminate when + `||sclx*(g(x) - x)||∞ <= tolx`. + sclx : FloatVector | None + Positive scaling factors for the components of `x`. Ideally, these should be + chosen so that `sclx*x` is of order 1 near the solution for all components. By + default, scaling is determined automatically from `x0`. + maxiter : int + Maximum number of iterations. + callback : Callable[[int, FloatVector, FloatVector], tuple[bool, bool]] | None + Optional callback with signature `callback(niter, x, fx)->(stop, success)` called + at each iteration. If `stop` is `True`, the iteration is terminated. If `success` + is `True`, the optimization is considered successful. + + Returns + ------- + VectorRootResult + Dataclass with root solution results. + + See Also + -------- + * [`fixpoint_anderson`](fixpoint_anderson.md): + Alternative method better suited for problems with coupling between components. + * [`fixpoint_damped`](fixpoint_damped.md): + Alternative method for problems with weak coupling between components. + * [`fixpoint_wegstein`](fixpoint_wegstein.md): + Alternative method for problems with weak coupling between components. + + Examples + -------- + Find the solution of a 2D fixed-point function. + >>> from polykin.math import fixpoint_dem + >>> import numpy as np + >>> def g(x): + ... x1, x2 = x + ... g1 = 0.5*np.cos(x1) + 0.1*x2 + 0.5 + ... g2 = np.sin(x2) - 0.2*x1 + 1.2 + ... return np.array([g1, g2]) + >>> sol = fixpoint_dem(g, x0=np.array([0.0, 0.0])) + >>> print(f"x = {sol.x}") + x = [0.97458605 1.93830731] + >>> print(f"g(x) = {g(sol.x)}") + g(x) = [0.97458605 1.93830731] + """ + method = "DEM fixed-point" + success = False + message = "" + nfeval = 0 + + if not (0.0 <= q < 1.0): + raise ValueError("`q` must satisfy 0 <= q < 1.") + + sclx = np.abs(sclx) if sclx is not None else scalex(x0) + + x = x0.copy() + n = x.size + + fx = np.full(n, np.nan) + Δx = np.full(n, np.nan) + Δxm = np.full(n, np.nan) + + ev1 = ev1m = float("nan") + nss = 0 + niter = 0 + + for niter in range(1, maxiter + 1): + gx = g(x) + nfeval += 1 + fx = gx - x + + if callback is not None: + stop, _success = callback(niter, x, fx) + if stop: + message = "Terminated by user callback." + success = _success + break + + if np.linalg.norm(sclx * fx, np.inf) <= tolx: + message = "||sclx*(g(x) - x)||∞ ≤ tolx" + success = True + break + + if niter == maxiter: + message = f"Maximum number of iterations ({maxiter}) reached." + break + + if nss > 1: + Δxm_norm = np.linalg.norm(Δxm) + Δx_norm = np.linalg.norm(Δx) + ev1_abs = Δx_norm / Δxm_norm if Δxm_norm > eps else 0.0 + ev1_sign = np.sign(np.dot(Δx, Δxm)) + ev1m = ev1 + ev1 = ev1_abs * ev1_sign + + if nss > 2 and abs(ev1 - ev1m) < tolev * max((abs(ev1m), abs(ev1))): + denom = 1.0 - ev1 + if abs(denom) < 10 * eps: + message = f"Nearly zero DEM denominator at x={x}, (1 - λ1)={denom:.2e})." + break + x += (1.0 - q) * fx / denom + nss = 0 + ev1 = ev1m = float("nan") + else: + nss += 1 + xm = x + Δxm = Δx + x = gx + Δx = x - xm + + return VectorRootResult(method, success, message, nfeval, None, niter, x, fx, None) diff --git a/src/polykin/math/fixpoint/steffensen.py b/src/polykin/math/fixpoint/steffensen.py new file mode 100644 index 00000000..d0414876 --- /dev/null +++ b/src/polykin/math/fixpoint/steffensen.py @@ -0,0 +1,106 @@ +# PolyKin: A polymerization kinetics library for Python. +# +# Copyright Hugo Vale 2026 + +from collections.abc import Callable + +from polykin.math.machine import eps +from polykin.math.roots import RootResult + +__all__ = ["fixpoint_steffensen"] + + +def fixpoint_steffensen( + g: Callable[[float], float], + x0: float, + *, + tolx: float = 1e-6, + maxiter: int = 50, + callback: Callable[[int, float, float], tuple[bool, bool]] | None = None, +) -> RootResult: + r"""Find the solution of a scalar fixed-point problem using Steffensen's + method. + + Steffensen's method accelerates the direct substitution iteration for a + scalar fixed-point problem, `g(x)=x`, by applying Aitken's delta-squared + process to the sequence of fixed-point iterates. The update can be written + as: + + $$ x_{k+1} = x_k - \frac{(g(x_k) - x_k)^2}{g(g(x_k)) - 2 g(x_k) + x_k} $$ + + When the denominator becomes very small, the accelerated step becomes + numerically unreliable and the method terminates. + + Parameters + ---------- + g : Callable[[float], float] + Fixed-point mapping defining the problem `g(x) = x`. + x0 : float + Initial guess. + tolx : float + Absolute tolerance for the fixed-point residual. The algorithm will + terminate when `|g(x) - x| <= tolx`. + maxiter : int + Maximum number of iterations. + callback : Callable[[int, float, float], tuple[bool, bool]] | None + Optional callback with signature `callback(niter, x, fx)->(stop, success)` called + at each iteration. If `stop` is `True`, the iteration is terminated. If `success` + is `True`, the optimization is considered successful. + + Returns + ------- + RootResult + Dataclass with root solution results. + + Examples + -------- + Find the fixed point of the cosine function. + >>> from numpy import cos + >>> from polykin.math import fixpoint_steffensen + >>> sol = fixpoint_steffensen(cos, 0.5) + >>> print(f"x = {sol.x:.6f}") + x = 0.739085 + >>> print(f"g(x) - x = {cos(sol.x) - sol.x:.2e}") + g(x) - x = 1.92e-11 + """ + method = "Steffensen fixed-point" + success = False + message = "" + nfeval = 0 + + x = x0 + fx = float("nan") + niter = 0 + + for niter in range(1, maxiter + 1): + gx = g(x) + nfeval += 1 + fx = gx - x + + if callback is not None: + stop, _success = callback(niter, x, fx) + if stop: + message = "Terminated by user callback." + success = _success + break + + if abs(fx) <= tolx: + message = "|g(x) - x| ≤ tolx" + success = True + break + + if niter < maxiter: + ggx = g(gx) + nfeval += 1 + + Δ2 = ggx - 2 * gx + x + if abs(Δ2) <= eps * max(abs(ggx), abs(gx), abs(x), 1.0): + message = f"Nearly zero Steffensen denominator at x={x} (Δ²={Δ2:.2e})." + break + + x = x - fx**2 / Δ2 + + else: + message = f"Maximum number of iterations ({maxiter}) reached." + + return RootResult(method, success, message, nfeval, niter, x, fx) diff --git a/src/polykin/math/fixpoint/wegstein.py b/src/polykin/math/fixpoint/wegstein.py index 0a5d7f44..42debcf9 100644 --- a/src/polykin/math/fixpoint/wegstein.py +++ b/src/polykin/math/fixpoint/wegstein.py @@ -6,9 +6,9 @@ import numpy as np -from polykin.math import scalex +from polykin.math.derivatives import scalex +from polykin.math.machine import eps from polykin.math.roots import VectorRootResult -from polykin.utils.math import eps from polykin.utils.typing import FloatVector __all__ = ["fixpoint_wegstein"] @@ -18,12 +18,13 @@ def fixpoint_wegstein( g: Callable[[FloatVector], FloatVector], x0: FloatVector, *, - tolx: float = 1e-6, - sclx: FloatVector | None = None, wait: int = 1, qmin: float = -5.0, qmax: float = 0.0, + tolx: float = 1e-6, + sclx: FloatVector | None = None, maxiter: int = 50, + callback: Callable[[int, FloatVector, FloatVector], tuple[bool, bool]] | None = None, ) -> VectorRootResult: r"""Find the solution of a N-dimensional fixed-point problem using the bounded Wegstein acceleration method. @@ -33,7 +34,7 @@ def fixpoint_wegstein( problems, each component of the fixed-point vector is treated separately according to: - $$ x_{k+1} = q_k x_k + (1 - q_k) g(x_k) $$ + $$ x_{k+1} = x_k + (1 - q_k) \left( g(x_k) - x_k \right) $$ where $q_{min} \leq q_k \leq q_{max}$ is the acceleration parameter determined by: @@ -55,9 +56,16 @@ def fixpoint_wegstein( Parameters ---------- g : Callable[[FloatVector], FloatVector] - Identity function for the fixed-point problem, i.e. `g(x) = x`. + Fixed-point mapping defining the problem `g(x) = x`. x0 : FloatVector Initial guess. + wait : int + Number of direct substitution iterations before the first acceleration + iteration. + qmin : float + Minimum value for the acceleration parameter. + qmax : float + Maximum value for the acceleration parameter. tolx : float Absolute tolerance for `x` value. The algorithm will terminate when `||sclx*(g(x) - x)||∞ <= tolx`. @@ -65,15 +73,12 @@ def fixpoint_wegstein( Positive scaling factors for the components of `x`. Ideally, these should be chosen so that `sclx*x` is of order 1 near the solution for all components. By default, scaling is determined automatically from `x0`. - wait : int - Number of direct substitution iterations before the first acceleration - iteration. - qmin : float - Minimum value for the acceleration parameter. - qmax : float, optional - Maximum value for the acceleration parameter. maxiter : int Maximum number of iterations. + callback : Callable[[int, FloatVector, FloatVector], tuple[bool, bool]] | None + Optional callback with signature `callback(niter, x, fx)->(stop, success)` called + at each iteration. If `stop` is `True`, the iteration is terminated. If `success` + is `True`, the optimization is considered successful. Returns ------- @@ -82,8 +87,12 @@ def fixpoint_wegstein( See Also -------- - * [`fixpoint_anderson`](fixpoint_anderson.md): alternative method better - suited for problems with coupling between components. + * [`fixpoint_anderson`](fixpoint_anderson.md): + Alternative method better suited for problems with coupling between components. + * [`fixpoint_damped`](fixpoint_damped.md): + Alternative method for problems with weak coupling between components. + * [`fixpoint_dem`](fixpoint_dem.md): + Alternative method for problems with weak coupling between components. Examples -------- @@ -106,42 +115,52 @@ def fixpoint_wegstein( message = "" nfeval = 0 - sclx = sclx if sclx is not None else scalex(x0) + sclx = np.abs(sclx) if sclx is not None else scalex(x0) x = x0.copy() n = x.size + wait = max(wait, 1) + gx = np.full(n, np.nan) + fx = np.full(n, np.nan) xm = np.full(n, np.nan) - wait = max(wait, 1) + niter = 0 - for k in range(maxiter): + for niter in range(1, maxiter + 1): gxm = gx gx = g(x) nfeval += 1 fx = gx - x + if callback is not None: + stop, _success = callback(niter, x, fx) + if stop: + message = "Terminated by user callback." + success = _success + break + if np.linalg.norm(sclx * fx, np.inf) <= tolx: message = "||sclx*(g(x) - x)||∞ ≤ tolx" success = True break - if k + 1 < maxiter: - if k < wait: - xm = x - x = gx - else: - Δx = x - xm - Δg = gx - gxm - s = np.zeros(n) - mask_s = np.abs(Δx) > eps - np.divide(Δg, Δx, out=s, where=mask_s) - q = s / (s - 1) - q = np.clip(q, qmin, qmax) - xm = x - x = q * x + (1 - q) * gx - - else: - message = f"Maximum number of iterations ({maxiter}) reached." - - return VectorRootResult(method, success, message, nfeval, None, k + 1, x, fx, None) + if niter == maxiter: + message = f"Maximum number of iterations ({maxiter}) reached." + break + + if niter < wait + 1: + xm = x + x = gx + else: + Δx = x - xm + Δg = gx - gxm + s = np.zeros(n) + mask_s = np.abs(Δx) > eps + np.divide(Δg, Δx, out=s, where=mask_s) + q = s / (s - 1) + q = np.clip(q, qmin, qmax) + xm = x + x = x + (1 - q) * fx + + return VectorRootResult(method, success, message, nfeval, None, niter, x, fx, None) diff --git a/src/polykin/math/machine.py b/src/polykin/math/machine.py new file mode 100644 index 00000000..833d20ec --- /dev/null +++ b/src/polykin/math/machine.py @@ -0,0 +1,28 @@ +# PolyKin: A polymerization kinetics library for Python. +# +# Copyright Hugo Vale 2026 + +import math + +import numpy as np + +__all__ = [ + "eps", + "huge", + "tiny", + "sqrt_eps", +] + +_finfo = np.finfo(np.float64) + +eps = float(_finfo.eps) +"""Machine epsilon for double-precision floating-point numbers.""" + +huge = float(_finfo.max) +"""Largest finite double-precision floating-point number.""" + +tiny = float(_finfo.tiny) +"""Smallest positive normalized double-precision floating-point number.""" + +sqrt_eps = math.sqrt(eps) +"""Square root of machine epsilon.""" diff --git a/src/polykin/math/misc/jcr.py b/src/polykin/math/misc/jcr.py index 31b7b460..30dad858 100644 --- a/src/polykin/math/misc/jcr.py +++ b/src/polykin/math/misc/jcr.py @@ -12,9 +12,9 @@ from scipy.stats.distributions import f as Fdist from scipy.stats.distributions import t as tdist +from polykin.math.machine import eps from polykin.math.roots import RootResult, root_secant from polykin.utils.exceptions import ShapeError -from polykin.utils.math import eps from polykin.utils.tools import check_bounds from polykin.utils.typing import Float2x2Matrix, FloatVector diff --git a/src/polykin/math/optimization/__init__.py b/src/polykin/math/optimization/__init__.py new file mode 100644 index 00000000..3458d31d --- /dev/null +++ b/src/polykin/math/optimization/__init__.py @@ -0,0 +1,9 @@ +# PolyKin: A polymerization kinetics library for Python. +# +# Copyright Hugo Vale 2026 + +from .brent import * +from .qnewton import * +from .results import * +from .secant import * +from .simplex import * diff --git a/src/polykin/math/optimization/brent.py b/src/polykin/math/optimization/brent.py new file mode 100644 index 00000000..159dfa09 --- /dev/null +++ b/src/polykin/math/optimization/brent.py @@ -0,0 +1,171 @@ +# PolyKin: A polymerization kinetics library for Python. +# +# Copyright Hugo Vale 2026 + +import math +from collections.abc import Callable + +from polykin.math.machine import eps +from polykin.math.optimization.results import OptimumResult + +__all__ = ["fmin_brent"] + + +def fmin_brent( + f: Callable[[float], float], + xa: float, + xb: float, + *, + tolx: float = 1e-6, + maxiter: int = 50, + callback: Callable[[int, float, float], tuple[bool, bool]] | None = None, +) -> OptimumResult: + r"""Find the minimum of a scalar function using Brent's method. + + Brent's method is a derivative-free optimization algorithm that combines + golden-section search with inverse parabolic interpolation. It maintains a + bracketing interval that contains a local minimum and iteratively refines + this interval. When the function behaves smoothly, the method attempts a + fast parabolic step; otherwise, it falls back to the more robust golden- + section step. + + **References** + + * Brent, R. P. Algorithms for Minimization without Derivatives; Prentice-Hall: + Englewood Cliffs, NJ, 1973. + + Parameters + ---------- + f : Callable[[float], float] + Objective function to be minimized. + xa : float + Lower bound of the bracketing interval. + xb : float + Upper bound of the bracketing interval. + tolx : float, optional + Absolute tolerance for `x` value. The algorithm terminates when the search + interval becomes smaller than approximately `tolx`. + maxiter : int + Maximum number of iterations. + callback : Callable[[int, float, float], tuple[bool, bool]] | None + Optional callback with signature `callback(niter, x, fx)->(stop, success)` called + at each iteration. If `stop` is `True`, the iteration is terminated. If `success` + is `True`, the optimization is considered successful. + + Returns + ------- + OptimumResult + Dataclass with the results of the optimization. + + See Also + -------- + * [`fmin_secant`](fmin_secant.md): + Derivative-based minimization method using the secant approach. + + Examples + -------- + Find the minimum of the function `f(x) = x^4 - x + 1`. + >>> from polykin.math import fmin_brent + >>> f = lambda x: x**4 - x + 1 + >>> fmin_brent(f, -3.0, 3.0) + method: Brent + success: True + message: |Δx| ≤ tolx + nfeval: 14 + niter: 14 + x: 6.29960526e-01 + f: 5.27529606e-01 + """ + method = "Brent" + success = False + message = "" + nfeval = 0 + + # Golden ratio constant: (3 - sqrt(5)) / 2 + c = 0.38196601125010515179 + + # Initialization + a = min(xa, xb) + b = max(xa, xb) + v = w = x = a + c * (b - a) + fv = fw = fx = f(x) + nfeval += 1 + + d = e = 0.0 + niter = 0 + + for niter in range(1, maxiter + 1): + xm = 0.5 * (a + b) + tol1 = eps * abs(x) + tolx / 3.0 + tol2 = 2.0 * tol1 + + if callback is not None: + stop, _success = callback(niter, x, fx) + if stop: + message = "Terminated by user callback." + success = _success + break + + if abs(x - xm) <= (tol2 - 0.5 * (b - a)): + message = "|Δx| ≤ tolx" + success = True + break + + p = q = r = 0.0 + if abs(e) > tol1: + # Fit parabola + r = (x - w) * (fx - fv) + q = (x - v) * (fx - fw) + p = (x - v) * q - (x - w) * r + q = 2.0 * (q - r) + if q > 0.0: + p = -p + q = abs(q) + r = e + e = d + + # Is parabolic step acceptable? + if abs(p) < abs(0.5 * q * r) and p > q * (a - x) and p < q * (b - x): + d = p / q + u = x + d + # Convergence check for u + if (u - a) < tol2 or (b - u) < tol2: + d = math.copysign(tol1, xm - x) + else: + # Golden section step + e = b - x if x < xm else a - x + d = c * e + else: + # Golden section step + e = b - x if x < xm else a - x + d = c * e + + # Numerical safety: ensure step is at least tol1 + u = x + d if abs(d) >= tol1 else x + math.copysign(tol1, d) + fu = f(u) + nfeval += 1 + + # Update points + if fu <= fx: + if u >= x: + a = x + else: + b = x + v, fv = w, fw + w, fw = x, fx + x, fx = u, fu + else: + if u < x: + a = u + else: + b = u + if fu <= fw or w == x: + v, fv = w, fw + w, fw = u, fu + elif fu <= fv or v == x or v == w: + v, fv = u, fu + + else: + message = f"Maximum number of iterations ({maxiter}) reached." + + return OptimumResult(method, success, message, nfeval, niter, x, fx) diff --git a/src/polykin/math/optimization/globalmethods.py b/src/polykin/math/optimization/globalmethods.py new file mode 100644 index 00000000..6455ae51 --- /dev/null +++ b/src/polykin/math/optimization/globalmethods.py @@ -0,0 +1,391 @@ +# PolyKin: A polymerization kinetics library for Python. +# +# Copyright Hugo Vale 2026 + +import math +from collections.abc import Callable +from enum import IntEnum + +import numpy as np +from numpy.linalg import norm + +from polykin.math.machine import sqrt_eps +from polykin.utils.typing import FloatMatrix, FloatVector + +__all__ = ["line_search", "dogleg"] + + +def line_search( + f: Callable[[FloatVector], float | tuple[float, FloatVector]], + p: FloatVector, + xc: FloatVector, + fc: float, + gc: FloatVector, + tolx: float, + sclx: FloatVector, + maxlen: float, + verbose: bool = False, +) -> tuple[bool, bool, int, FloatVector, float, FloatVector]: + r"""Perform a line search. + + This function performs a line search along the quasi-Newton direction to find a step + size that satisfies the Armijo condition. + + **References** + + * J.E. Dennis Jr., R.B. Schnabel, "Numerical Methods for Unconstrained + Optimization and Nonlinear Equations", SIAM, 1996. + + Parameters + ---------- + f : Callable[[FloatVector], float | tuple[float, FloatVector]] + Objective function. For compability with optimization and root-finding algorithms, + `f` can return either a scalar objective function value or a tuple including the + scaled norm of the vector root function and the vector root function itself. + p : FloatVector + Quasi-Newton step. + xc : FloatVector + Current value of the variable vector. + fc : float + Current objective function value, `f(xc)`. + gc : FloatVector + Current gradient of the objective function, `∇f(xc)`. + tolx : float + Tolerance for the step size. + sclx : FloatVector + Scaling factors for `x`. + maxlen : float + Maximum step length. + verbose : bool + Print iteration information. + + Returns + ------- + tuple[bool, bool, int, FloatVector, float, FloatVector] + `(success, ismaxstep, nfeval, xp, fp, Fp)` + """ + nfeval = 0 + success = False + ismaxstep = False + + newtlen = norm(sclx * p) + if newtlen > maxlen: + p = p * (maxlen / newtlen) + newtlen = maxlen + + slope = np.dot(gc, p) + + α = 1e-4 + λ = 1.0 + λ_min = tolx / np.max(np.abs(p) / np.maximum(np.abs(xc), 1 / sclx)) + + A = np.empty((2, 2)) + B = np.empty(2) + λ_prev = float("nan") + fp_prev = float("nan") + Fp = np.array([]) + + first = True + while True: + xp = xc + λ * p + + res = f(xp) + nfeval += 1 + fp, Fp = res if isinstance(res, tuple) else (res, Fp) + + if verbose: + print(f" λ={λ:.2e}, f={fp:.2e}", flush=True) + + if fp <= fc + α * λ * slope: + success = True + if first and (newtlen > 0.99 * maxlen): + ismaxstep = True + break + elif λ < λ_min: + success = False + xp = xc + break + else: + if first: + λ_temp = -slope / (2 * (fp - fc - slope)) + first = False + else: + A[0, 0] = 1 / λ**2 + A[0, 1] = -1 / λ_prev**2 + A[1, 0] = -λ_prev / λ**2 + A[1, 1] = λ / λ_prev**2 + B[0] = fp - fc - λ * slope + B[1] = fp_prev - fc - λ_prev * slope + a, b = 1 / (λ - λ_prev) * A @ B + if abs(a) < sqrt_eps: + λ_temp = -slope / (2 * b) + else: + λ_temp = (-b + math.sqrt(b**2 - 3 * a * slope)) / (3 * a) + λ_temp = min(λ_temp, 0.5 * λ) + λ_prev = λ + fp_prev = fp + λ = max(0.1 * λ, λ_temp) + + return (success, ismaxstep, nfeval, xp, fp, Fp) + + +class TrustState(IntEnum): + """Codes for the status of the trust region step and update.""" + + accepted = 0 + convergence = 1 + rejected = 2 + exploratory_success = 3 + start = 4 + + +def dogleg( + f: Callable[[FloatVector], float | tuple[float, FloatVector]], + p: FloatVector, + xc: FloatVector, + fc: float, + gc: FloatVector, + R: FloatMatrix, + tolx: float, + sclx: FloatVector, + maxlen: float, + trustlen: float, + verbose: bool = False, +) -> tuple[bool, bool, int, float, FloatVector, float, FloatVector]: + r"""Perform a dogleg step. + + **References** + + * J.E. Dennis Jr., R.B. Schnabel, "Numerical Methods for Unconstrained + Optimization and Nonlinear Equations", SIAM, 1996. + + Parameters + ---------- + f : Callable[[FloatVector], float | tuple[float, FloatVector]] + Objective function. For compability with optimization and root-finding algorithms, + `f` can return either a scalar objective function value or a tuple including the + scaled norm of the vector root function and the vector root function itself. + p : FloatVector + Quasi-Newton step. + xc : FloatVector + Current value of the variable vector. + fc : float + Current objective function value, `f(xc)`. + gc : FloatVector + Current gradient of the objective function, `∇f(xc)`. + R : FloatMatrix + Upper-triangular factor of the current Jacobian QR decomposition. + tolx : float + Tolerance for the step size. + sclx : FloatVector + Scaling factors for `x`. + maxlen : float + Maximum step length. + trustlen : float + Current trust region radius. + verbose : bool + Print iteration information. + + Returns + ------- + tuple[bool, bool, int, float, FloatVector, float, FloatVector] + `(success, ismaxstep, nfeval, trustlen, xp, fp, Fp)` + """ + nfeval = 0 + state = TrustState.start + ismaxstep = False + + cauchylen = η = float("nan") + v = sSD = np.array([]) + + xp = xp_prev = xc + fp = fp_prev = float("nan") + Fp = Fp_prev = np.array([]) + + newtlen = norm(sclx * p) + + first = True + while state not in (TrustState.accepted, TrustState.convergence): + # Perform dogleg step to determine s + if newtlen <= trustlen: + isnewtstep = True + s = p + trustlen = newtlen # type: ignore + else: + isnewtstep = False + if first: + first = False + α = norm(gc / sclx) ** 2 + β = norm(R @ (gc / sclx**2)) ** 2 + sSD = -(α / β) * (gc / sclx) + cauchylen = α * math.sqrt(α) / β + η = 0.2 + (0.8 * α**2 / (β * abs(np.dot(gc, p)))) + v = η * (p * sclx) - sSD + if trustlen <= 0.0: + trustlen = min(cauchylen, maxlen) # type: ignore + + if η * newtlen <= trustlen: + s = (trustlen / newtlen) * p + elif cauchylen >= trustlen: + s = (trustlen / cauchylen) * (sSD / sclx) + else: + a = np.dot(v, v) + b = np.dot(v, sSD) + λ = (-b + math.sqrt(b**2 - a * (cauchylen**2 - trustlen**2))) / a + s = (sSD + λ * v) / sclx + + # Update trust region + state, ismaxstep, trustlen, xp, fp, Fp, xp_prev, fp_prev, Fp_prev = ( + _update_trust_region( + f, + xc, + fc, + gc, + R, + s, + tolx, + sclx, + maxlen, + trustlen, + isnewtstep, + state, + xp_prev, + fp_prev, + Fp_prev, + ) + ) + nfeval += 1 + + # Display iteration progress + if verbose: + print(f" δ={trustlen:.2e}, f={fp:.2e}", flush=True) + + return (state == TrustState.accepted, ismaxstep, nfeval, trustlen, xp, fp, Fp) + + +def _update_trust_region( + f: Callable[[FloatVector], float | tuple[float, FloatVector]], + xc: FloatVector, + fc: float, + gc: FloatVector, + R: FloatMatrix, + s: FloatVector, + tolx: float, + sclx: FloatVector, + maxlen: float, + trustlen: float, + isnewtstep: bool, + state: TrustState, + xp_prev: FloatVector, + fp_prev: float, + Fp_prev: FloatVector, +) -> tuple[ + TrustState, + bool, + float, + FloatVector, + float, + FloatVector, + FloatVector, + float, + FloatVector, +]: + r"""Perform trust-region update. + + **References** + + * J.E. Dennis Jr., R.B. Schnabel, "Numerical Methods for Unconstrained + Optimization and Nonlinear Equations", SIAM, 1996. + + Parameters + ---------- + f : Callable[[FloatVector], float | tuple[float, FloatVector]] + Objective function. For compability with optimization and root-finding algorithms, + `f` can return either a scalar objective function value or a tuple including the + scaled norm of the vector root function and the vector root function itself. + xc : FloatVector + Current value of the variable vector. + fc : float + Current objective function value, `f(xc)`. + gc : FloatVector + Current gradient of the objective function, `∇f(xc)`. + R : FloatMatrix + Upper-triangular factor of the current Jacobian QR decomposition. + s : FloatVector + Step vector. + tolx : float + Tolerance for the step size. + sclx : FloatVector + Scaling factors for `x`. + maxlen : float + Maximum step length. + trustlen : float + Current trust region radius. + isnewtstep : bool + Flag indicating if the step is a Newton step. + state : TrustState + Code indicating the current state of the algorithm. + xp_prev : FloatVector + Previous value of `xp`. + fp_prev : float + Previous value of `fp`. + Fp_prev : FloatVector + Previous value of `Fp`. + + Returns + ------- + tuple[TrustState, bool, float, FloatVector, float, FloatVector, FloatVector, float, FloatVector] + `(state, ismaxstep, trustlen, xp, fp, Fp, xp_prev, fp_prev, Fp_prev)` + """ # noqa: E501 + α = 1e-4 + ismaxstep = False + + steplen = norm(sclx * s) + slope = np.dot(gc, s) + + xp = xc + s + + res = f(xp) + fp, Fp = res if isinstance(res, tuple) else (res, np.array([])) + + Δf = fp - fc + + if (state == TrustState.exploratory_success) and ( + (fp >= fp_prev) or (Δf > α * slope) + ): + state = TrustState.accepted + xp, fp, Fp = xp_prev, fp_prev, Fp_prev + trustlen *= 0.5 + elif Δf >= α * slope: + rlen = np.max(np.abs(s) / np.maximum(np.abs(xp), 1 / sclx)) + if rlen < tolx: + state = TrustState.convergence + xp = xc + else: + state = TrustState.rejected + trustlen = np.clip( + -slope * steplen / (2 * (Δf - slope)), 0.1 * trustlen, 0.5 * trustlen + ) + else: + Δf_pred = slope + 0.5 * norm(R @ s) ** 2 + if ( + (state != TrustState.rejected) + and (not isnewtstep) + and (trustlen <= 0.99 * maxlen) + and ((abs(Δf_pred - Δf) <= 0.1 * abs(Δf)) or (Δf <= slope)) + ): + state = TrustState.exploratory_success + xp_prev, fp_prev, Fp_prev = xp, fp, Fp + trustlen = min(2 * trustlen, maxlen) + else: + state = TrustState.accepted + if steplen >= 0.99 * maxlen: + ismaxstep = True + if Δf >= 0.1 * Δf_pred: + trustlen *= 0.5 + elif Δf <= 0.75 * Δf_pred: + trustlen = min(2 * trustlen, maxlen) + else: + trustlen = trustlen # no change + + return (state, ismaxstep, trustlen, xp, fp, Fp, xp_prev, fp_prev, Fp_prev) diff --git a/src/polykin/math/optimization/qnewton.py b/src/polykin/math/optimization/qnewton.py new file mode 100644 index 00000000..7917598a --- /dev/null +++ b/src/polykin/math/optimization/qnewton.py @@ -0,0 +1,764 @@ +# PolyKin: A polymerization kinetics library for Python. +# +# Copyright Hugo Vale 2026 + +import math +from collections.abc import Callable +from typing import Literal +from warnings import warn + +import numpy as np +import scipy +from numpy.linalg import norm + +from polykin.math.derivatives.ndiff import ( + gradient_forward, + hessian_forward, + jacobian_forward, + scalex, +) +from polykin.math.machine import eps, sqrt_eps +from polykin.math.optimization.globalmethods import dogleg, line_search +from polykin.math.optimization.results import VectorOptimumResult +from polykin.utils.typing import FloatMatrix, FloatVector, FloatVectorLike + +__all__ = ["fmin_qnewton"] + + +def fmin_qnewton( + f: Callable[[FloatVector], float], + x0: FloatVectorLike, + *, + tolx: float = 1e-10, + tolg: float = 1e-5, + sclx: FloatVectorLike | None = None, + sclf: float = 1.0, + maxiter: int = 100, + maxlenfac: float = 1e3, + trustlen: float | None = None, + epsf: float | None = None, + global_method: Literal["line-search", "dogleg"] | None = "dogleg", + bfgs_update: bool | None = None, + bfgs_method: Literal["factored", "unfactored", "inverse"] | None = None, + grad: Callable[[FloatVector], FloatVector] | None = None, + hess: Callable[[FloatVector], FloatMatrix] | None = None, + H0: FloatMatrix | None = None, + callback: Callable[[int, FloatVector, float, FloatVector], tuple[bool, bool]] + | None = None, + verbose: bool = False, +) -> VectorOptimumResult: + r"""Find the minimum of a multivariate function using a quasi-Newton method with + optional global strategies. + + Parameters + ---------- + f : Callable[[FloatVector (N)], float] + Objective function to minimize. + x0 : FloatVectorLike (N) + Initial guess for the optimum. Moreover, if no user-defined scale `sclx` is + provided, the scaling factors will be determined from this value. + tolx : float + Tolerance for the scaled step size. The algorithm terminates when the scaled + distance between two successive iterates `||Δx/max(x, 1/sclx)||∞` is below this + threshold. If the value is too large, the algorithm may terminate prematurely. + A value on the order of $\epsilon^{2/3}$ is typically recommended. + tolg : float + Tolerance for the scaled gradient. This is the main convergence criterion. The + algorithm terminates when the scaled gradient `||∇f(x)*sclf/sclx||∞` is below this + threshold. If the value is too large, the algorithm may terminate prematurely. + A value on the order of $\epsilon^{1/3}$ is typically recommended. + sclx : FloatVectorLike (N) | None + Positive scaling factors for the components of `x`. Ideally, these should be + chosen so that `sclx*x` is of order 1 near the solution for all components. By + default, scaling is determined from `x0`. + sclf : float + Positive scaling factor for the function values. Ideally, this should be chosen so + that `sclf*f(x)` is of order 1 across the domain of interest. The value is used to + scale the gradient; if too low a value is provided, the algorithm may terminate + prematurely. + maxiter : int + Maximum number of outer quasi-Newton iterations. + maxlenfac : float + Factor determining the maximum allowable scaled step length `||Δx*sclx||₂` for + global methods. Used to prevent steps that would cause the algorithm to overflow, + leave the domain of interest, or diverge. It should be chosen small enough to + prevent such issues, but large enough to allow any anticipated reasonable step + length. + trustlen : float | None + Initial trust region radius for the `dogleg` global method. By default, the length + of the initial scaled gradient is used. + epsf : float | None + Machine precision of the function values. If `None`, machine precision of 64-bit + floating-point type is assumed. If the number of reliable base-10 digits in the + results returned by the function is $n$, then `epsf` is approximately $10^{-n}$. + global_method : Literal['line-search','dogleg'] | None + Global strategy to improve convergence from remote starting points. With + `line-search`, the search direction is computed using the quasi-Newton step and + the length of the step is determined by backtracking until the Armijo condition is + fulfilled. With `dogleg`, a trust-region dogleg method is used to compute both the + step direction and length. If `None`, no global strategy is used and the full + quasi-Newton step is taken at each iteration. + bfgs_update : bool | None + Whether to update the Hessian approximation using the BFGS positive definite + secant formula. If `False`, the Hessian is evaluated anew at each iteration + using `hess` or forward finite differences. If `True`, the Hessian is updated + using the BFGS formula, avoiding the cost of a full evaluation. The BFGS + update typically increases the number of iterations required for convergence, + but decreases the total number of function evaluations when the Hessian is + approximated via finite differences. By default, the BFGS update is used if no + Hessian function is provided, and is not used otherwise. + bfgs_method : Literal['factored', 'unfactored', 'inverse'] | None + Method to carry out the BFGS Hessian update. In theory, all methods produce the + same result, but the computational cost and the numerical stability may differ. + By default, the `factored` form is used when the dogleg global method is selected, + because the dogleg method requires the Cholesky factor of the Hessian. Otherwise, + the `inverse` form is used because it has the lowest algorithmic overhead. + grad : Callable[[FloatVector (N)], FloatVector (N)] | None + Function to compute the gradient of `f`. By default, the gradient is approximated + using forward finite differences. In this case, setting `epsf` appropriately is + essential. + hess : Callable[[FloatVector (N)], FloatMatrix (N, N)] | None + Function to compute the Hessian of `f`. By default, the Hessian is approximated + using forward finite differences, using `grad` if available or `f` otherwise. + In this case, setting `epsf` appropriately is essential. + H0 : FloatMatrix (N, N) | None + Initial Hessian approximation at `x0`, expected to be symmetric positive definite. + By default, if `bfgs_update` is `False`, `H0` is computed using `hess` or forward + finite differences. If `bfgs_update` is `True` and `hess` is not provided, `H0` is + initialized to the identity matrix. If `bfgs_update` is `True` and `hess` is + provided, `H0` is initialized from `hess`. + callback : Callable[[int, FloatVector (N), float, FloatVector (N)], tuple[bool, bool]] | None + Optional callback with signature `callback(niter, x, fx, ∇fx)->(stop, success)` + called at each iteration. If `stop` is `True`, the iteration is terminated. If + `success` is `True`, the optimization is considered successful. + verbose : bool + Print iteration information. + + Returns + ------- + VectorOptimumResult + Dataclass with the results of the optimization. + + Examples + -------- + Find the minimum of the Rosenbrock function `f(x,y) = (1 - x)^2 + 100*(y - x^2)^2`. + >>> import numpy as np + >>> from polykin.math import fmin_qnewton + >>> f = lambda x: (1 - x[0])**2 + 100 * (x[1] - x[0]**2)**2 + >>> fmin_qnewton(f, [-1.0, -1.0], global_method="dogleg") + method: Quasi-Newton (Global: Dogleg, BFGS: Factored) + success: True + message: ||∇f(x)*sclf/sclx||∞ ≤ tolg + nfeval: 98 + ngeval: 0 + nheval: 0 + niter: 28 + x: [0.9999964 0.99999277] + f: 1.3039626656861953e-11 + g: [ 7.80959496e-06 -3.03099592e-06] + L: [[-28.34545479 0. ] + [ 14.14251074 -0.70808768]] + """ # noqa: E501 + # Check/set method options + if bfgs_update is None: + bfgs_update = hess is None + + if bfgs_update: + if bfgs_method is None: + if global_method == "dogleg": + bfgs_method = "factored" + else: + bfgs_method = "inverse" + elif bfgs_method != "factored" and global_method == "dogleg": + bfgs_method = "factored" + warn( + "BFGS update with dogleg global method requires factored form. Setting `bfgs_method` to 'factored'." # noqa: E501 + ) + + # Construct method name for result + method = "Quasi-Newton" + method_options = [] + _global_method = global_method if global_method else "none" + method_options.append(f"Global: {_global_method.title()}") + _bfgs_method = bfgs_method if bfgs_method else "none" + if bfgs_update: + method_options.append(f"BFGS: {_bfgs_method.title()}") + if method_options: + method += " (" + ", ".join(method_options) + ")" + + # Initialize result variables + success = False + message = "" + nfeval = 0 + ngeval = 0 + nheval = 0 + niter = 0 + + x0 = np.asarray(x0, dtype=float) + n = x0.size + + # Set scaling factors + sclx = np.abs(np.asarray(sclx, dtype=float)) if sclx is not None else scalex(x0) + sclf = max(abs(sclf), 1.0) + + # Set maximum step length for global methods + maxlen = max(0.0, maxlenfac) * max(norm(sclx * x0).item(), norm(sclx).item()) + + # Set initial trust region radius for dogleg method + if trustlen is None: + trustlen = -1.0 # Sentinel value + else: + trustlen = min(trustlen, maxlen) + + # Helper functions to evaluate gradient and Hessian + def eval_grad(x: FloatVector, fx: float) -> FloatVector: + nonlocal ngeval, nfeval + if grad is not None: + g = grad(x) + ngeval += 1 + else: + g = gradient_forward(f, x, fx=fx, sclx=sclx, epsf=epsf) + nfeval += n + return g + + def eval_hess(x: FloatVector, fx: float, gx: FloatVector) -> FloatMatrix: + nonlocal nheval, ngeval, nfeval + if hess is not None: + H = hess(x) + nheval += 1 + elif grad is not None: + H = jacobian_forward(grad, x, fx=gx, sclx=sclx, epsf=epsf) + ngeval += n + else: + H = hessian_forward(f, x, fx=fx, sclx=sclx, epsf=epsf) + nfeval += n * (n + 3) // 2 + return H + + # Evaluate function at x0 + xc = x0.copy() + fc = f(xc) + nfeval += 1 + + # Evaluate gradient at x0 + grad_analytic = grad is not None + gc = eval_grad(xc, fc) + + # Check initial solution with tight tolerance + if gradient_condition(xc, fc, gc, sclx, sclf, 1e-3 * tolg): + message = "||∇f(x0)*sclf/sclx||∞ ≤ 1e-3*tolg" + return VectorOptimumResult( + method, True, message, nfeval, ngeval, nheval, niter, x0, fc, gc + ) + + # Evaluate Hessian at x0 + H = L = Hinv = np.array([]) + if H0 is not None: + H = H0.copy() + elif bfgs_update and hess is None: + # D = max(abs(fc), 1 / sclf) * sclx**2 + D = np.ones_like(x0) + if bfgs_method == "unfactored": + H = np.zeros((n, n)) + np.fill_diagonal(H, D) + elif bfgs_method == "factored": + L = np.zeros((n, n)) + np.fill_diagonal(L, np.sqrt(D)) + elif bfgs_method == "inverse": + Hinv = np.zeros((n, n)) + np.fill_diagonal(Hinv, 1 / D) + else: + raise ValueError(f"Unknown `bfgs_method`: {bfgs_method}.") + else: + H = eval_hess(xc, fc, gc) + + # Factorize or invert Hessian if BFGS update requires it + if bfgs_update and H.size > 0: + if bfgs_method == "unfactored" and hess is not None: + try: + H = make_hessian_spd(H, enforce_symmetry=True)[0] + except np.linalg.LinAlgError as e: + message = f"Cholesky factorization of initial Hessian failed: {e}." + return VectorOptimumResult( + method, False, message, nfeval, ngeval, nheval, niter, xc, fc, gc, H + ) + elif bfgs_method == "factored": + try: + L = make_hessian_spd(H, enforce_symmetry=True)[1] + except np.linalg.LinAlgError as e: + message = f"Cholesky factorization of initial Hessian failed: {e}." + return VectorOptimumResult( + method, False, message, nfeval, ngeval, nheval, niter, xc, fc, gc, H + ) + elif bfgs_method == "inverse": + try: + Hinv = np.linalg.inv(H) + except np.linalg.LinAlgError as e: + message = f"Inverse of initial Hessian failed: {e}." + return VectorOptimumResult( + method, False, message, nfeval, ngeval, nheval, niter, xc, fc, gc, H + ) + else: + pass + + # Main optimization loop + gm_nmaxsteps = 0 + for niter in range(1, maxiter + 1): + if verbose: + print(f"Iteration {niter:3d}:", flush=True) + print(" Current point:", xc) + print(" Function value:", fc) + print(" Gradient value:", gc) + + # Ensure Hessian is SPD + if not bfgs_update: + try: + H, L, _ = make_hessian_spd(H, enforce_symmetry=True) + except np.linalg.LinAlgError as e: + message = f"Perturbed Cholesky factorization of Hessian failed: {e}." + break + + # Compute Newton step + if bfgs_update and bfgs_method == "inverse": + # p = - H⁻¹.gc + p = Hinv @ gc + p *= -1 + elif bfgs_update and bfgs_method == "unfactored": + # H.p = - gc + try: + L, _ = scipy.linalg.cho_factor( + H, + lower=True, + overwrite_a=False, + check_finite=False, + ) + p = scipy.linalg.cho_solve( + (L, True), + gc, + overwrite_b=False, + check_finite=False, + ) + p *= -1 + if global_method == "dogleg": + L = np.tril(L) + except scipy.linalg.LinAlgError as e: + message = f"Cholesky solve for Newton step failed: {e}." + break + elif not bfgs_update or bfgs_method == "factored": + # (L.Lᵀ).p = - gc + try: + # L.y = gc + y = scipy.linalg.solve_triangular( + L, + gc, + lower=True, + overwrite_b=False, + check_finite=False, + ) + # Lᵀ.p = y + p = scipy.linalg.solve_triangular( + L, + y, + lower=True, + trans="T", + overwrite_b=True, + check_finite=False, + ) + p *= -1 + except scipy.linalg.LinAlgError as e: + message = f"Triangular solve for Newton step failed: {e}." + break + else: + raise ValueError(f"Unknown `bfgs_method`: {bfgs_method}.") + + if verbose: + print(" Search direction:", p) + + # Compute actual x step + if global_method is None: + xp = xc + p + fp = f(xp) + gm_ismaxstep = True + gm_success = True + gm_nfeval = 1 + elif global_method == "line-search": + gm_success, gm_ismaxstep, gm_nfeval, xp, fp, _ = line_search( + f, p, xc, fc, gc, tolx, sclx, maxlen, verbose + ) + elif global_method == "dogleg": + gm_success, gm_ismaxstep, gm_nfeval, trustlen, xp, fp, _ = dogleg( + f, p, xc, fc, gc, L.T, tolx, sclx, maxlen, trustlen, verbose + ) + else: + raise ValueError(f"Unknown `global_method`: {global_method}.") + + nfeval += gm_nfeval + gm_nmaxsteps = gm_nmaxsteps + 1 if gm_ismaxstep else 0 + + # Display iteration progress + if verbose: + print(f" x = {xp}\n f(x) = {fp:.2e}", flush=True) + + # Evaluate gradient at new point + gp = eval_grad(xp, fp) + + # Call user callback + if callback is not None: + stop, _success = callback(niter, xp, fp, gp) + if stop: + success = _success + message = "Terminated by user callback." + break + + # Check termination and convergence conditions + if not gm_success: + message = """Last global step failed to decrease f(x) sufficiently. + Either `x` is an approximate local minimizer and no more accuracy is possible, + or the finite difference gradient approximation is too inaccurate, or `tolx` + is too large.""" + stop = True + elif gradient_condition(xp, fp, gp, sclx, sclf, tolg): + message = "||∇f(x)*sclf/sclx||∞ ≤ tolg" + success = True + stop = True + elif norm((xp - xc) / np.maximum(np.abs(xp), 1 / sclx), np.inf) <= tolx: + message = """||Δx/max(x, 1/sclx)||∞ ≤ tolx + `x` may be an approximate local minimizer, but it is also possible that the + algorithm is making slow progress and is not near a minimizer, or that `tolx` + is too large.""" + stop = True + elif global_method and gm_nmaxsteps >= 5: + message = """Maximum number (5) of consecutive steps of length `maxlen` + reached. Perhaps f(x) is unbounded below, or f(x) has a finite asymptote in + some direction, or `maxlen` is too small.""" + stop = True + else: + stop = False + + if stop: + xc, fc, gc = xp, fp, gp + break + + # Update Hessian approximation + if bfgs_update: + if bfgs_method == "factored": + L = _update_bfgs_factored(xc, xp, gc, gp, L, grad_analytic) + elif bfgs_method == "unfactored": + H = _update_bfgs_unfactored(xc, xp, gc, gp, H, grad_analytic) + elif bfgs_method == "inverse": + Hinv = _update_bfgs_inverse(xc, xp, gc, gp, Hinv, grad_analytic) + else: + raise ValueError(f"Unknown `bfgs_method`: {bfgs_method}.") + else: + H = eval_hess(xp, fp, gp) + + # Next iteration will start at xp + xc, fc, gc = xp, fp, gp + + else: + message = f"Maximum number of iterations ({maxiter}) reached." + + return VectorOptimumResult( + method=method, + success=success, + message=message, + nfeval=nfeval, + ngeval=ngeval, + nheval=nheval, + niter=niter, + x=xc, + f=fc, + g=gc, + H=H if not bfgs_update or bfgs_method == "factored" else None, + Hinv=Hinv if bfgs_method == "inverse" else None, + L=L if bfgs_method == "factored" else None, + ) + + +def gradient_condition( + xc: FloatVector, + fc: float, + gc: FloatVector, + sclx: FloatVector, + sclf: float, + tolg: float, +) -> bool: + """Check if function gradient satisfies the tolerance condition.""" + sclg = np.maximum(np.abs(xc), 1 / sclx) / max(abs(fc), 1 / sclf) + return bool(np.max(np.abs(gc) * sclg) <= tolg) + + +def _update_bfgs_unfactored( + xc: FloatVector, + xp: FloatVector, + gc: FloatVector, + gp: FloatVector, + Hc: FloatMatrix, + grad_analytic: bool, +) -> FloatMatrix: + r"""Update the Hessian approximation using the BFGS positive definite secant formula. + + $$ H \gets H - \frac{H s s^T H}{s^T H s} + \frac{y y^T}{y^T s} $$ + + where $s = x_p - x_c$ and $y = g(x_p) - g(x_c)$. + + **References** + + * J.E. Dennis Jr., R.B. Schnabel, "Numerical Methods for Unconstrained + Optimization and Nonlinear Equations", SIAM, 1996, p. 355. + + Parameters + ---------- + xc : FloatVector + Current value of the variable vector. + xp : FloatVector + Next value of the variable vector. + gc : FloatVector + Current gradient vector, `g(xc)`. + gp : FloatVector + Next gradient vector, `g(xp)`. + Hc : FloatMatrix + Current Hessian approximation. This will be updated in-place. + grad_analytic : bool + Whether the gradient is analytic or not. + + Returns + ------- + FloatMatrix + Updated Hessian approximation. + """ + s = xp - xc + y = gp - gc + + # Check curvature condition: yᵀ.s > 0 + ys = np.dot(y, s) + if ys < sqrt_eps * norm(s) * norm(y): + return Hc + + # Check if the update is small enough to be ignored + tol = eps if grad_analytic else sqrt_eps + Hs = Hc @ s + if np.all(np.abs(y - Hs) < tol * (np.abs(gc) + np.abs(gp))): + return Hc + + sHs = np.dot(s, Hs) + Hc += np.outer(y, y) / ys + Hc -= np.outer(Hs, Hs) / sHs + + Hc += Hc.T + Hc /= 2 + + return Hc + + +def _update_bfgs_factored( + xc: FloatVector, + xp: FloatVector, + gc: FloatVector, + gp: FloatVector, + Lc: FloatMatrix, + grad_analytic: bool, +) -> FloatMatrix: + r"""Update the Cholesky factor of the Hessian approximation using the BFGS positive + definite secant formula. + + $$ J = L + \frac{(y - \alpha L L^T s)(\alpha L^T s)^T}{y^T s} $$ + + $$ \alpha = \left(\frac{y^T s}{s^T L L^T s}\right)^{1/2} $$ + + where $s = x_p - x_c$ and $y = g(x_p) - g(x_c)$. + + **References** + + * J.E. Dennis Jr., R.B. Schnabel, "Numerical Methods for Unconstrained + Optimization and Nonlinear Equations", SIAM, 1996, p. 356. + + Parameters + ---------- + xc : FloatVector + Current value of the variable vector. + xp : FloatVector + Next value of the variable vector. + gc : FloatVector + Current gradient vector, `g(xc)`. + gp : FloatVector + Next gradient vector, `g(xp)`. + Lc : FloatMatrix + Current lower-triangular Cholesky factor of Hessian approximation. This will be + overwritten. + grad_analytic : bool + Whether the gradient is analytic or not. + + Returns + ------- + FloatMatrix + Updated lower-triangular Cholesky factor of Hessian approximation. + """ + s = xp - xc + y = gp - gc + + ys = np.dot(y, s) + if ys < sqrt_eps * norm(s) * norm(y): + return Lc + + LTs = Lc.T @ s + sHs = np.dot(LTs, LTs) + + alpha = math.sqrt(ys / sHs) # α = √(yᵀ.s / sᵀ.L.Lᵀ.s) + + Hs = Lc @ LTs # L.Lᵀ.s = H.s + + tol = eps if grad_analytic else sqrt_eps + if np.all(np.abs(y - Hs) < tol * (np.abs(gc) + np.abs(gp))): + return Lc + + # u = y - α.L.Lᵀ.s + Hs *= -alpha + Hs += y + + # t = Lᵀ.s / √(yᵀ.s * sᵀ.L.Lᵀ.s) + LTs /= math.sqrt(ys * sHs) + + # QR rank-1 update + n = Lc.shape[0] + _, Rp = scipy.linalg.qr_update(np.eye(n), Lc.T, LTs, Hs, overwrite_qruv=True) + Lp = Rp.T + + return Lp + + +def _update_bfgs_inverse( + xc: FloatVector, + xp: FloatVector, + gc: FloatVector, + gp: FloatVector, + Bc: FloatMatrix, + grad_analytic: bool, +) -> FloatMatrix: + r"""Update the inverse Hessian approximation using the expanded Sherman-Morrison + formula. + + $$ B \gets B + \frac{(s^T y + y^T B y)(s s^T)}{(s^T y)^2} + - \frac{B y s^T + s y^T B}{s^T y} $$ + + where $s = x_p - x_c$ and $y = g(x_p) - g(x_c)$. + + Parameters + ---------- + xc : FloatVector + Current value of the variable vector. + xp : FloatVector + Next value of the variable vector. + gc : FloatVector + Current gradient vector, `g(xc)`. + gp : FloatVector + Next gradient vector, `g(xp)`. + Bc : FloatMatrix + Current inverse Hessian approximation (B = H⁻¹). This will be updated in-place. + grad_analytic : bool + Whether the gradient is analytic or not. + + Returns + ------- + FloatMatrix + Updated inverse Hessian approximation. + """ + s = xp - xc + y = gp - gc + + # Check curvature condition: yᵀ.s > 0 + ys = np.dot(y, s) + if ys < sqrt_eps * norm(s) * norm(y): + return Bc + + # Check if the update is small enough to be ignored + By = Bc @ y + tol = eps if grad_analytic else sqrt_eps + scale = np.maximum.reduce([np.ones_like(s), np.abs(s), np.abs(By)]) + if np.all(np.abs(s - By) < tol * scale): + return Bc + + yBy = np.dot(y, By) + Bc += ((ys + yBy) * np.outer(s, s)) / (ys * ys) + Bc -= (np.outer(By, s) + np.outer(s, By)) / ys + + Bc += Bc.T + Bc /= 2 + + return Bc + + +def make_hessian_spd( + H: FloatMatrix, + enforce_symmetry: bool = True, + maxiter: int = 10, +) -> tuple[FloatMatrix, FloatMatrix, float]: + """Make a Hessian matrix positive definite by adding a scaled identity matrix. + + Parameters + ---------- + H : FloatMatrix + Hessian matrix to be made positive definite. + enforce_symmetry : bool + Whether to enforce symmetry of the Hessian by averaging it with its transpose. + maxiter : int + Maximum number of perturbation iterations to attempt. In each iteration, the + perturbation is increased by a factor of 10 until the Hessian becomes positive + definite. + + Returns + ------- + tuple[FloatMatrix, FloatMatrix, float] + Tuple containing the perturbed Hessian matrix, its Cholesky factor, and the + perturbation value. + """ + H = H.copy() + if enforce_symmetry: + H += H.T + H *= 0.5 + + # Ensure all diagonal elements are positive and sufficiently large compared to the + # off-diagonal elements, to improve the chances of the Hessian being SPD + maxdiag = H.diagonal().max() + mindiag = H.diagonal().min() + maxposdiag = max(maxdiag, 0.0) + + if mindiag <= sqrt_eps * maxposdiag: + mu = 2 * (maxposdiag - mindiag) * sqrt_eps - mindiag + maxdiag += mu + else: + mu = 0.0 + + Ht = np.abs(H) + diag = np.diag_indices_from(H) + Ht[diag] = 0.0 + maxoff = Ht.max() + + if maxoff * (1.0 + 2 * sqrt_eps) > maxdiag: + mu += (maxoff - maxdiag) + 2 * sqrt_eps * maxoff + maxdiag = maxoff * (1.0 + 2 * sqrt_eps) + + if maxdiag == 0.0: + mu = 1.0 + maxdiag = 1.0 + + if mu > 0.0: + H[diag] += mu + + # Perturb Hessian by adding a scaled identity matrix until it becomes SPD + Hp = np.empty_like(H) + perturb = 0.0 + perturb0 = eps * max(float(norm(H, np.inf)), 1.0) + + for _ in range(maxiter + 1): + Hp[:] = H + Hp[diag] += perturb + + try: + Lp = np.linalg.cholesky(Hp) + return Hp, Lp, perturb + mu + except np.linalg.LinAlgError: + perturb = max(perturb0, 10 * perturb) + + raise np.linalg.LinAlgError( + f"Perturbed Cholesky failed after total perturbation={mu + perturb:.3e}" + ) diff --git a/src/polykin/math/optimization/results.py b/src/polykin/math/optimization/results.py new file mode 100644 index 00000000..1dd193f1 --- /dev/null +++ b/src/polykin/math/optimization/results.py @@ -0,0 +1,137 @@ +# PolyKin: A polymerization kinetics library for Python. +# +# Copyright Hugo Vale 2026 + +from dataclasses import dataclass + +from polykin.utils.tools import colored_bool +from polykin.utils.typing import FloatMatrix, FloatVector + +__all__ = [ + "OptimumResult", + "VectorOptimumResult", +] + + +@dataclass(frozen=True, slots=True) +class OptimumResult: + """Dataclass with the results of the optimization. + + Attributes + ---------- + method: str + Method used to find the optimum. + success: bool + If `True`, the optimum was found. + message: str + Description of the exit status. + nfeval: int + Number of function evaluations. + niter: int + Number of iterations. + x: float + Optimum value. + f: float + Function value at the optimum. + df: float | None + Derivative at the optimum (if available). + """ + + method: str + success: bool + message: str + nfeval: int + niter: int + x: float + f: float + df: float | None = None + + def __repr__(self) -> str: + """Return a string representation of the optimum result.""" + result = ( + f" method: {self.method}\n" + f"success: {colored_bool(self.success)}\n" + f"message: {self.message}\n" + f" nfeval: {self.nfeval}\n" + f" niter: {self.niter}\n" + f" x: {self.x:.8e}\n" + f" f: {self.f:.8e}" + ) + if self.df is not None: + result += f"\n df: {self.df:.8e}" + + return result + + +@dataclass(frozen=True, slots=True) +class VectorOptimumResult: + """Dataclass with the results of the optimization. + + Attributes + ---------- + method: str + Method used to find the optimum. + success: bool + If `True`, the optimum was found. + message: str + Description of the exit status. + nfeval: int + Number of function evaluations. + ngeval: int | None + Number of user-supplied gradient evaluations. + nheval: int | None + Number of user-supplied Hessian evaluations. + niter: int + Number of iterations. + x: FloatVector + Optimum value. + f: float + Function value at the optimum. + g: FloatVector | None + Gradient at the optimum. + H: FloatMatrix | None + Last evaluated or estimated Hessian matrix. + Hinv: FloatMatrix | None + Last evaluated or estimated inverse Hessian ($H^{-1}$) matrix. + L: FloatMatrix | None + Last evaluated or estimated Cholesky factor $L$ (where $H = LL^T$) of the + Hessian matrix. + """ + + method: str + success: bool + message: str + nfeval: int + ngeval: int | None + nheval: int | None + niter: int + x: FloatVector + f: float + g: FloatVector | None = None + H: FloatMatrix | None = None + Hinv: FloatMatrix | None = None + L: FloatMatrix | None = None + + def __repr__(self) -> str: + """Return a string representation of the optimum result.""" + rows = [ + ("method", self.method), + ("success", colored_bool(self.success)), + ("message", self.message), + ("nfeval", self.nfeval), + ("ngeval", self.ngeval), + ("nheval", self.nheval), + ("niter", self.niter), + ("x", self.x), + ("f", self.f), + ("g", self.g), + ("H", self.H), + ("Hinv", self.Hinv), + ("L", self.L), + ] + + return "\n".join( + f"{name:>7}: {value}" + for name, value in rows + if value is not None and not (hasattr(value, "size") and value.size == 0) + ) diff --git a/src/polykin/math/optimization/secant.py b/src/polykin/math/optimization/secant.py new file mode 100644 index 00000000..0241753b --- /dev/null +++ b/src/polykin/math/optimization/secant.py @@ -0,0 +1,184 @@ +# PolyKin: A polymerization kinetics library for Python. +# +# Copyright Hugo Vale 2026 + +import math +from collections.abc import Callable +from typing import Literal + +from polykin.math.derivatives import ( + derivative_centered, + derivative_complex, +) +from polykin.math.machine import eps +from polykin.math.optimization.results import OptimumResult + +__all__ = ["fmin_secant"] + + +def fmin_secant( + f: Callable[[float], float] | Callable[[complex], complex], + x0: float, + x1: float, + *, + tolx: float = 1e-10, + tolg: float = 1e-5, + maxiter: int = 50, + epsf: float | None = None, + diff_scheme: Literal["centered", "complex"] = "centered", + callback: Callable[[int, float, float, float], tuple[bool, bool]] | None = None, +) -> OptimumResult: + r"""Find the minimum of a scalar function using the secant method. + + The secant method starts from two initial guesses and applies the secant update + to the first derivative $f'(x)$ to generate the next iterate: + + $$ x_{k+1} = x_k - f'(x_k) \frac{x_k - x_{k-1}}{f'(x_k) - f'(x_{k-1})} $$ + + The derivative $f'(x)$ is approximated numerically using either centered finite + differences or complex-step differentiation. The complex-step scheme is usually + more accurate, but requires that `f` accepts complex-valued inputs. + + This is an efficient local method for smooth functions, but it is less robust + than bracketed methods such as Brent's algorithm and may fail if the initial + guesses are poor. + + Parameters + ---------- + f : Callable[[float], float] | Callable[[complex], complex] + Objective function to be minimized. + x0 : float + First initial guess. + x1 : float + Second initial guess. + tolx : float + Absolute tolerance for `x`. The algorithm will terminate when the change in + `x` between two iterations is less or equal than `tolx`. If the value is too + large, the algorithm may terminate prematurely. A value on the order of + $\epsilon^{2/3}$ is typically recommended. + tolg : float + Absolute tolerance for the function gradient. This is the primary convergence + criterion. The algorithm will terminate when `|f'(x)| <= tolg`. A value on the + order of $\epsilon^{1/3}$ is typically recommended. + maxiter : int + Maximum number of iterations. + epsf : float | None + Machine precision of the function values. If `None`, machine precision of 64-bit + floating-point type is assumed. If the number of reliable base-10 digits in the + results returned by the function is $n$, then `epsf` is approximately $10^{-n}$. + diff_scheme : Literal['centered', 'complex'] + Numerical differentiation scheme used to approximate `f'(x)`. The 'centered' + scheme uses a centered finite difference, while the 'complex' scheme uses + complex step differentiation. The 'complex' scheme is more accurate, but requires + that `f` can accept complex inputs. + callback : Callable[[int, float, float, float], tuple[bool, bool]] | None + Optional callback with signature `callback(niter, x, fx, dfx)->(stop, success)` + called at each iteration. If `stop` is `True`, the iteration is terminated. If + `success` is `True`, the optimization is considered successful. + + Returns + ------- + OptimumResult + Dataclass with the results of the optimization. + + See Also + -------- + * [`fmin_brent`](fmin_brent.md): + More robust derivative-free minimization method for bounded intervals. + + Examples + -------- + Find the minimum of the function `f(x) = x^4 - x + 1`. + >>> from polykin.math import fmin_secant + >>> f = lambda x: x**4 - x + 1 + >>> fmin_secant(f, 2.0, 1.0) + method: Secant + success: True + message: |f'(x)| ≤ tolg + nfeval: 16 + niter: 6 + x: 6.29961354e-01 + f: 5.27529606e-01 + df: 3.94747093e-06 + """ + # Initialize results + method = "Secant" + success = False + message = "" + nfeval = 0 + + # Set machine precision for function values + epsf = max(epsf, eps) if epsf is not None else eps + sqrt_epsf = math.sqrt(epsf) + + # Helper function to evaluate the derivative + def eval_derivative(x: float) -> tuple[float, float]: + nonlocal nfeval + if diff_scheme == "centered": + dfx, fx = derivative_centered(f, x, epsf=epsf) + nfeval += 2 + elif diff_scheme == "complex": + dfx, fx = derivative_complex(f, x) + nfeval += 1 + else: + raise ValueError(f"Invalid differentiation scheme: {diff_scheme!r}") + + return (dfx, fx) + + # Evaluate derivatives at initial guesses + df0, f0 = eval_derivative(x0) + if abs(df0) <= tolg: + message = "|f'(x0)| ≤ tolg." + success = True + return OptimumResult(method, success, message, nfeval, 0, x0, f0, df0) + + df1, f1 = eval_derivative(x1) + if abs(df1) <= tolg: + message = "|f'(x1)| ≤ tolg." + success = True + return OptimumResult(method, success, message, nfeval, 0, x1, f1, df1) + + # Main optimization loop + x2 = f2 = df2 = float("nan") + niter = 0 + + for niter in range(1, maxiter + 1): + Δdf = df1 - df0 + if abs(Δdf) <= epsf * max(abs(df0), abs(df1), 1.0): + message = f"Nearly zero slope between x[k-1]={x0} and x[k]={x1} (Δf'={Δdf})." + break + + x2 = x1 - df1 * (x1 - x0) / Δdf + + df2, f2 = eval_derivative(x2) + + if callback is not None: + stop, _success = callback(niter, x2, f2, df2) + if stop: + message = "Terminated by user callback." + success = _success + break + + if (f2 - f1) > sqrt_epsf * max(abs(f1), abs(f2), 1.0): + message = ( + f"Function value increased from {f1} at x[k-1]={x1} to {f2} at x[k]={x2}." + ) + break + + if abs(df2) <= tolg: + message = "|f'(x)| ≤ tolg" + success = True + break + + if abs(x2 - x1) <= tolx: + message = "|Δx| ≤ tolx" + success = True + break + + x0, f0, df0 = x1, f1, df1 + x1, f1, df1 = x2, f2, df2 + + else: + message = f"Maximum number of iterations ({maxiter}) reached." + + return OptimumResult(method, success, message, nfeval, niter, x2, f2, df2) diff --git a/src/polykin/math/optimization/simplex.py b/src/polykin/math/optimization/simplex.py new file mode 100644 index 00000000..05c2bc29 --- /dev/null +++ b/src/polykin/math/optimization/simplex.py @@ -0,0 +1,239 @@ +# PolyKin: A polymerization kinetics library for Python. +# +# Copyright Hugo Vale 2026 + +from collections.abc import Callable + +import numpy as np + +from polykin.math.derivatives.ndiff import scalex +from polykin.math.optimization.results import VectorOptimumResult +from polykin.utils.typing import FloatMatrix, FloatVector, FloatVectorLike + +__all__ = ["fmin_nelder_mead"] + + +def fmin_nelder_mead( + f: Callable[[FloatVector], float], + x0: FloatVectorLike, + *, + tolx: float = 1e-8, + tolf: float = 1e-8, + sclx: FloatVectorLike | None = None, + maxiter: int | None = None, + maxfeval: int | None = None, + adaptive: bool = True, + callback: Callable[[int, FloatMatrix, FloatVector], tuple[bool, bool]] | None = None, +) -> VectorOptimumResult: + r"""Find the minimum of a multivariate function using the Nelder-Mead simplex + algorithm. + + The Nelder-Mead simplex algorithm is a derivative-free optimization method for + unconstrained minimization of multivariate functions. It maintains a simplex of $N+1$ + vertices in $N$-dimensional space and iteratively updates this simplex based on the + function values at the vertices. + + The initial simplex is aligned with the coordinate axes. For each coordinate, the + corresponding simplex vertex offset is: + + $$ \Delta x_i = 0.05 \max(|x_{0,i}|, 1/\mathrm{sclx}_i) $$ + + where $x_0$ is the initial guess and $\mathrm{sclx}_i$ is the scaling factor + associated with variable $x_i$. Therefore, it is important that `x0` and/or + `sclx` reflect the expected scale of the variables. If `sclx` is not provided, the + variable scaling is inferred from `x0`. + + **References** + + * Nelder, J. A.; Mead, R. A Simplex Method for Function Minimization. + Comput. J. 1965, 7, 308-313. + * Gao, F.; Han, L. Implementing the Nelder-Mead Simplex Algorithm with Adaptive + Parameters. Comput. Optim. Appl. 2012, 51, 259-277. + + Parameters + ---------- + f : Callable[[FloatVector (N)], float] + Objective function to minimize. + x0 : FloatVectorLike (N) + Initial guess for the optimum. Moreover, if no user-defined scale `sclx` is + provided, the scaling factors will be determined from this value. + tolx : float + Absolute tolerance for `x`. The algorithm terminates when the maximum scaled + distance between the simplex vertices is less than `tolx`. + tolf : float + Absolute tolerance for `f`. The algorithm terminates when the maximum difference + between the function values at the simplex vertices is less than `tolf`. + sclx : FloatVectorLike (N) | None + Positive scaling factors for the components of `x`. Ideally, these should be + chosen so that `sclx*x` is of order 1 near the solution for all components. By + default, scaling is inferred from `x0`. + maxiter : int | None + Maximum number of iterations. By default, a value of `200*N` is used. + maxfeval : int | None + Maximum number of function evaluations. By default, a value of `200*N` is used. + adaptive : bool + Whether to use the adaptive parameter scheme proposed by Gao (2012). If `False`, + the standard Nelder-Mead parameters are used. + callback : Callable[[int, FloatMatrix (N+1, N), FloatVector (N+1)], tuple[bool, bool]] | None + Optional callback with signature `callback(niter, x, fx)->(stop, success)` called + at each iteration. If `stop` is `True`, the iteration is terminated. If `success` + is `True`, the optimization is considered successful. + + Returns + ------- + VectorOptimumResult + Dataclass with the results of the optimization. + + Examples + -------- + Find the minimum of the function `f(x) = (x[0] - 1e2)^2 + (x[1] - 1e10)^2`. + >>> import numpy as np + >>> from polykin.math import fmin_nelder_mead + >>> fmin_nelder_mead(lambda x: (x[0] - 1e2)**2 + (x[1] - 1e10)**2, [1, 1e8]) + method: Nelder-Mead + success: True + message: Function value spread is less than `tolf`. + nfeval: 226 + niter: 122 + x: [9.99999864e+01 1.00000000e+10] + f: 1.9451564775785983e-09 + """ # noqa: E501 + method = "Nelder-Mead" + message = "" + success = False + nfeval = 0 + + x0 = np.asarray(x0, dtype=float) + n = x0.size + + sclx = np.abs(np.asarray(sclx, dtype=float)) if sclx is not None else scalex(x0) + + maxiter = maxiter if maxiter is not None else 200 * n + maxfeval = maxfeval if maxfeval is not None else 200 * n + + # Set the algorithm parameters + if adaptive: + # Dimension-dependent parameters from Gao (2012) + a = 1.0 + b = 1.0 + 2.0 / n + c = 0.75 - 1.0 / (2 * n) + d = 1.0 - 1.0 / n + else: + a = 1.0 + b = 2.0 + c = 0.5 + d = 0.5 + + # Initialize the simplex vertices + x = np.empty((n + 1, n)) + x[0] = x0 + for k in range(n): + x[k + 1, :] = x0 + step = 0.05 * max(abs(x0[k]), 1.0 / sclx[k]) + x[k + 1, k] += step + + # Evaluate the function at the simplex vertices + fx = np.empty(n + 1) + for k in range(n + 1): + fx[k] = f(x[k, :]) + nfeval += n + 1 + + # Main optimization loop + niter = 0 + while True: + niter += 1 + + # Sort the complex points by their function values + idx = np.argsort(fx) + imin, imax2, imax = idx[0], idx[-2], idx[-1] + xmin = x[imin] + fmin = fx[imin] + fmax2 = fx[imax2] + fmax = fx[imax] + + if callback is not None: + stop, _success = callback(niter, x, fx) + if stop: + success = _success + message = "Terminated by user callback." + break + + if np.max(np.abs(sclx * (x - xmin))) < tolx: + success = True + message = "Maximum distance between complex points is less than `tolx`." + break + + if (fmax - fmin) < tolf: + success = True + message = "Function value spread is less than `tolf`." + break + + if niter == maxiter: + message = f"Maximum number of iterations ({maxiter}) reached." + break + + if nfeval >= maxfeval: + message = f"Maximum number of function evaluations ({maxfeval}) reached." + break + + # Centroid excluding the worst point + xc = (np.sum(x, axis=0) - x[imax]) / n + + # Reflection + xr = (1.0 + a) * xc - a * x[imax] + fr = f(xr) + nfeval += 1 + + shrink = False + if fmin <= fr < fmax2: + x[imax, :] = xr + fx[imax] = fr + elif fr < fmin: + xe = (1.0 + a * b) * xc - a * b * x[imax] + fe = f(xe) + nfeval += 1 + if fe < fr: + x[imax, :] = xe + fx[imax] = fe + else: + x[imax, :] = xr + fx[imax] = fr + elif fmax2 <= fr < fmax: + xoc = (1.0 + a * c) * xc - a * c * x[imax] + foc = f(xoc) + nfeval += 1 + if foc <= fr: + x[imax, :] = xoc + fx[imax] = foc + else: + shrink = True + else: + xic = (1.0 - a * c) * xc + a * c * x[imax] + fic = f(xic) + nfeval += 1 + if fic < fmax: + x[imax, :] = xic + fx[imax] = fic + else: + shrink = True + + if shrink: + for k in range(n + 1): + if k == imin: + continue + xs = d * x[k, :] + (1.0 - d) * xmin + x[k, :] = xs + fx[k] = f(xs) + nfeval += 1 + + return VectorOptimumResult( + method=method, + success=success, + message=message, + nfeval=nfeval, + ngeval=None, + nheval=None, + niter=niter, + x=xmin, + f=fmin, + ) diff --git a/src/polykin/math/roots/__init__.py b/src/polykin/math/roots/__init__.py index 31ce0d2b..b20b1bae 100644 --- a/src/polykin/math/roots/__init__.py +++ b/src/polykin/math/roots/__init__.py @@ -3,6 +3,6 @@ # Copyright Hugo Vale 2025 +from .qnewton import * from .results import * from .scalar import * -from .vector import * diff --git a/src/polykin/math/roots/qnewton.py b/src/polykin/math/roots/qnewton.py new file mode 100644 index 00000000..a2d6db0a --- /dev/null +++ b/src/polykin/math/roots/qnewton.py @@ -0,0 +1,428 @@ +# PolyKin: A polymerization kinetics library for Python. +# +# Copyright Hugo Vale 2025 + +import math +from collections.abc import Callable +from typing import Literal + +import numpy as np +import scipy +from numpy.linalg import norm + +from polykin.math.derivatives import jacobian_forward, scalex +from polykin.math.machine import eps, sqrt_eps +from polykin.math.optimization.globalmethods import dogleg, line_search +from polykin.math.roots.results import VectorRootResult +from polykin.utils.typing import FloatMatrix, FloatVector, FloatVectorLike + +all = ["rootvec_qnewton"] + + +def rootvec_qnewton( + f: Callable[[FloatVector], FloatVector], + x0: FloatVectorLike, + *, + tolx: float = 1e-10, + tolf: float = 1e-5, + sclx: FloatVectorLike | None = None, + sclf: FloatVectorLike | None = None, + maxiter: int = 100, + maxlenfac: float = 1e3, + trustlen: float | None = None, + epsf: float | None = None, + global_method: Literal["line-search", "dogleg"] | None = "line-search", + broyden_update: bool = False, + jac: Callable[[FloatVector], FloatMatrix] | None = None, + jac_check: bool = True, + J0: FloatMatrix | None = None, + verbose: bool = False, +) -> VectorRootResult: + r"""Find the root of a system of nonlinear equations using a quasi-Newton + method with optional global strategies. + + This function implements a quasi-Newton solver for systems of nonlinear + equations according to Dennis and Schnabel (1996). The user can choose the + approach to calculate and update the Jacobian approximation, as well as the + global strategy to improve convergence from remote starting points. + + The default settings are meant to favor the likelihood of convergence at the + expense of computational efficiency. For situations where maximum efficiency + is desired and the initial guess is known to be close to the root, consider + disabling the global method and using Broyden's update for the Jacobian. + + !!! note + + Solving systems of nonlinear equations is a surprisingly complex task — + often more difficult than solving systems of differential equations or + even multivariate optimization problems. + Convergence is guaranteed only when the initial guess is sufficiently + close to the root, which is rarely true in practice. The choice of a + good initial guess, appropriate scaling factors, and a suitable global + strategy is an essential part of solving the problem. + + **References** + + * J.E. Dennis Jr., R.B. Schnabel, "Numerical Methods for Unconstrained Optimization + and Nonlinear Equations", SIAM, 1996. + + Parameters + ---------- + f : Callable[[FloatVector], FloatVector] + Function whose root is to be found. + x0 : FloatVectorLike (N) + Initial guess for the root. Moreover, if no user-defined scale `sclx` is provided, + the scaling factors will be determined from this value. + tolx : float + Tolerance for the scaled step size. The algorithm terminates when the scaled + distance between two successive iterates `||Δx/max(x, 1/sclx)||∞` is below this + threshold. If the value is too large, the algorithm may terminate prematurely. A + value on the order of $\epsilon^{2/3}$ is typically recommended. + tolf : float + Tolerance for the scaled residual norm. This is the main convergence criterion. + The algorithm terminates when the infinity norm of the scaled function values + `||sclf*f(x)||∞` is below this threshold. A value on the order of + $\epsilon^{1/3}$ is typically recommended. + sclx : FloatVectorLike (N) | None + Positive scaling factors for the components of `x`. Ideally, these should be + chosen so that `sclx*x` is of order 1 near the solution for all components. By + default, scaling is determined from `x0`. + sclf : FloatVectorLike (N) | None + Positive scaling factors for the components of `f`. Ideally, these should be + chosen so that `sclf*f` is of order 1 near the root for all components. By + default, scaling is determined from the initial Jacobian. + maxiter : int + Maximum number of outer quasi-Newton iterations. + maxlenfac : float + Factor determining the maximum allowable scaled step length `||sclx*Δx||₂` for + global methods. Used to prevent steps that would cause the algorithm to overflow, + leave the domain of interest, or diverge. It should be chosen small enough to + prevent such issues, but large enough to allow any anticipated reasonable step + length. + trustlen : float | None + Initial trust region radius for the `dogleg` global method. By default, the length + of the initial scaled gradient is used. + epsf : float | None + Machine precision of the function values. If `None`, machine precision of 64-bit + floating-point type is assumed. If the number of reliable base-10 digits in the + results returned by the function is $n$, then `epsf` is approximately $10^{-n}$. + global_method : Literal['line-search','dogleg'] | None + Global strategy to improve convergence from remote starting points. With + `line-search`, the search direction is computed using the quasi-Newton step and + the length of the step is determined by backtracking until the Armijo condition is + fulfiled. With `dogleg`, a trust-region dogleg method is used to compute both the + step direction and length. If `None`, no global strategy is used and the full + quasi-Newton step is taken at each iteration. + broyden_update : bool + If `True`, the Jacobian is updated at each iteration using Broyden's rank-1 update + formula. If `False`, the Jacobian is computed at each iteration using either the + provided `jac` function or finite differences. Broyden's update significantly + reduces the number of function/Jacobian evaluations required, but may lead to + inaccurate Jacobian approximations and poor convergence if the initial guess is + far from the root or if the function is highly nonlinear. + jac : Callable[[FloatVector], FloatMatrix] | None + Function to compute the Jacobian of `f`. By default, the Jacobian is approximated + using forward finite differences. In this case, setting `epsf` appropriately is + essential. + jac_check : bool + If `True`, the Jacobian provided by `jac` is checked against a forward + finite-difference approximation at `x0`. This can help identify errors in the + user-provided Jacobian. + J0 : FloatMatrix | None + Initial Jacobian approximation at `x0`. If provided, it is used instead of + computing the Jacobian at the first iteration. This can be useful in case of a + restart, or when a simple initial approximation is sufficient (e.g., the identity + matrix) and one wants to reduce the number of function calls. + verbose : bool + Print iteration information. + + Returns + ------- + VectorRootResult + Dataclass with root solution results. + + Examples + -------- + Find the steady-state concentration of species A, B, and C at the outlet of + a CSTR, assuming a consecutive scheme of type A+B→C, C+B→D. + >>> from polykin.math import rootvec_qnewton + >>> import numpy as np + >>> def f(x, A0=1.0, B0=2.0, C0=0.0, k1=1e-3, k2=5e-4, tau=1e3): + ... "Steady-state mole balances: inflow - outflow ± reaction" + ... A, B, C = x + ... f = np.zeros_like(x) + ... f[0] = (A0 - A)/tau - k1*A*B + ... f[1] = (B0 - B)/tau - k1*A*B + ... f[2] = (C0 - C)/tau + k1*A*B - k2*C*B + ... return f + >>> sol = rootvec_qnewton(f, np.array([0.5, 1.0, 0.5])) + >>> sol.x + array([0.41421356, 1.41421356, 0.34314575]) + """ + # Construct method name for result + method = "Quasi-Newton" + method_options = [] + _global_method = global_method if global_method else "none" + method_options.append(f"Global: {_global_method.title()}") + if broyden_update: + method_options.append("Broyden update") + if method_options: + method += " (" + ", ".join(method_options) + ")" + + # Initialize results variables + success = False + message = "" + nfeval = 0 + njeval = 0 + + # Evaluate function at x0 + x0 = np.asarray(x0, dtype=float) + n = x0.size + xc = x0.copy() + fc = f(xc) + nfeval += 1 + + # Set x scaling factors + sclx = np.abs(np.asarray(sclx, dtype=float)) if sclx is not None else scalex(x0) + + # Evaluate Jacobian at x0 + if J0 is not None: + J = J0.copy() + else: + if jac is not None: + J = jac(xc) + njeval += 1 + else: + J = jacobian_forward(f, xc, fx=fc, sclx=sclx, epsf=epsf) + nfeval += n + + # Check user-provided Jacobian against finite-difference approximation + if jac_check and jac is not None: + J_fd = jacobian_forward(f, xc, fx=fc, sclx=sclx, epsf=epsf) + nfeval += n + _epsf = max(epsf, eps) if epsf is not None else eps + tol = 1e2 * math.sqrt(_epsf) + if not np.allclose(J, J_fd, rtol=tol, atol=tol): + message = "User-provided Jacobian `jac` does not match finite-difference approximation." # noqa: E501 + return VectorRootResult(method, False, message, nfeval, njeval, 0, x0, fc, J) + + # Set f scaling factors + if sclf is None: + sclf = np.empty(n, dtype=float) + sclf[:] = np.max(np.abs(J), axis=1) + sclf[sclf == 0.0] = 1.0 + sclf[:] = 1.0 / sclf + else: + sclf = np.abs(np.asarray(sclf, dtype=float)) + + # Check initial solution with tight tolerance + if norm(sclf * fc, np.inf) <= 1e-2 * tolf: + message = "||sclf*f(x0)||∞ ≤ 1e-2*tolf" + return VectorRootResult(method, True, message, nfeval, njeval, 0, x0, fc, J) + + # Set maximum step length for global methods + maxlen = max(0.0, maxlenfac) * max(norm(sclx * x0).item(), norm(sclx).item()) + + # Set initial trust region radius for dogleg method + if trustlen is None: + trustlen = -1.0 # Sentinel value + else: + trustlen = min(trustlen, maxlen) + + # Objective function for global methods + def fN(x: FloatVector) -> tuple[float, FloatVector]: + """1/2*||sclf*f(x)||².""" + fx = f(x) + fNx = 0.5 * np.sum((sclf * fx) ** 2) + return (fNx, fx) + + gm_nmaxsteps = 0 + restart = True + niter = 0 + Q = R = np.array([]) + gc = np.array([]) + fNc = float("nan") + + for niter in range(1, maxiter + 1): + if verbose: + print(f"Iteration {niter:3d}:", flush=True) + + # QR decomposition of scaled Jacobian + if not broyden_update or restart: + try: + Q, R = np.linalg.qr(sclf[:, None] * J) + except np.linalg.LinAlgError as e: + message = f"QR decomposition of Jacobian failed: {e}." + break + + # Condition number of R + Rcond = np.linalg.cond(R / sclx, 1) + + # Solve (Q*R)*p = - sclf*fc + if Rcond < 1 / sqrt_eps: + p = scipy.linalg.solve_triangular( + R, + Q.T @ (sclf * fc), + overwrite_b=True, + check_finite=False, + ) + p *= -1 + if global_method: + gc = R.T @ (Q.T @ (sclf * fc)) + fNc = 0.5 * np.sum((sclf * fc) ** 2) + else: + if verbose: + print("R is ill-conditioned (cond={Rcond:.2e}).", flush=True) + H = R.T @ R + Hnorm = norm(H / (sclx[:, None] * sclx[None, :]), 1) + H[np.diag_indices_from(H)] += math.sqrt(n * eps) * Hnorm * sclx**2 + gc = R.T @ (Q.T @ (sclf * fc)) + R, _ = scipy.linalg.cho_factor(H, overwrite_a=True, check_finite=False) + p = scipy.linalg.cho_solve((R, False), gc, check_finite=False) + p *= -1 + + # Compute actual x step + if global_method is None: + xp = xc + p + fp = f(xp) + gm_ismaxstep = True + gm_success = True + gm_nfeval = 1 + elif global_method == "line-search": + gm_success, gm_ismaxstep, gm_nfeval, xp, _, fp = line_search( + fN, p, xc, fNc, gc, tolx, sclx, maxlen, verbose + ) + elif global_method == "dogleg": + (gm_success, gm_ismaxstep, gm_nfeval, trustlen, xp, _, fp) = dogleg( + fN, p, xc, fNc, gc, R, tolx, sclx, maxlen, trustlen, verbose + ) + else: + raise ValueError(f"Unknown `global_method`: {global_method}.") + + nfeval += gm_nfeval + gm_nmaxsteps = gm_nmaxsteps + 1 if gm_ismaxstep else 0 + + # Display iteration progress + if verbose: + print( + f" x = {xp}\n ||sclx*f(x)||∞ = {norm(sclf * fp, np.inf):.2e}", + flush=True, + ) + + # If global method step failed, restart once + if not gm_success and not restart: + if jac is not None: + J = jac(xc) + njeval += 1 + else: + J = jacobian_forward(f, xc, fx=fc, sclx=sclx, epsf=epsf) + nfeval += n + restart = True + continue + + # Check termination and convergence conditions + if not gm_success: + message = """Last global step failed to decrease ||sclx*f(x)||₂ sufficiently. + Either `x` is close to a root and no more accuracy is possible, or the secant + approximation to the Jacobian is inaccurate, or `tolx` is too large.""" + stop = True + elif norm(sclf * fp, np.inf) <= tolf: + message = "||sclf*f(x)||∞ ≤ tolf" + success = True + stop = True + elif norm((xp - xc) / np.maximum(np.abs(xp), 1 / sclx), np.inf) <= tolx: + message = """||Δx/max(x, 1/sclx)||∞ ≤ tolx + `x` may be an approximate root, but it is also possible that the algorithm is + making slow progress and is not near a root, or that `tolx` is too large.""" + stop = True + elif global_method and gm_nmaxsteps >= 5: + message = """Maximum number (5) of consecutive steps of length `maxlen` + reached. Perhaps stuck in a flat region or `maxlen` is too small.""" + stop = True + else: + stop = False + + if stop: + xc, fc = xp, fp + break + + # Update Jacobian + if broyden_update: + Q, R = _update_broyden(xc, xp, fc, fp, Q, R, sclx, sclf) + else: + if jac is not None: + J = jac(xp) + njeval += 1 + else: + J = jacobian_forward(f, xp, fx=fp, sclx=sclx, epsf=epsf) + nfeval += n + + # Next iteration + xc, fc = xp, fp + restart = False + + else: + message = f"Maximum number of iterations ({maxiter}) reached." + + if broyden_update: + J = (Q @ R) / sclf[:, None] + + return VectorRootResult(method, success, message, nfeval, njeval, niter, xc, fc, J) + + +def _update_broyden( + xc: FloatVector, + xp: FloatVector, + fc: FloatVector, + fp: FloatVector, + Qc: FloatMatrix, + Rc: FloatMatrix, + sclx: FloatVector, + sclf: FloatVector, +) -> tuple[FloatMatrix, FloatMatrix]: + r"""Perform a Broyden update of the QR decomposition of a Jacobian approximation. + + This function updates the QR factors of an approximate Jacobian according to the + Broyden rank-1 update formula, using scaling factors for both the variables and + function values to improve numerical conditioning. + + **References** + + * J.E. Dennis Jr., R.B. Schnabel, "Numerical Methods for Unconstrained + Optimization and Nonlinear Equations", SIAM, 1996. + + Parameters + ---------- + xc : FloatVector + Current value of the variable vector + xp : FloatVector + Next value of the variable vector. + fc : FloatVector + Current function value, `f(xc)`. + fp : FloatVector + Next function value, `f(xp)`. + Qc : FloatMatrix + Orthogonal factor of the current Jacobian QR decomposition. + Rc : FloatMatrix + Upper-triangular factor of the current Jacobian QR decomposition. + sclx : FloatVector + Scaling factors for the components of `x`. + sclf : FloatVector + Scaling factors for the components of `f`. + + Returns + ------- + tuple[FloatMatrix, FloatMatrix] + The updated orthogonal and upper-triangular factors, `(Qp, Rp)`. + """ + s = xp - xc + y = fp - fc + + w = sclf * y - Qc @ (Rc @ s) + w[np.abs(w) < eps * sclf * (np.abs(fp) + np.abs(fc))] = 0.0 + + t = s * sclx**2 + s = t / np.dot(s, t) + Qp, Rp = scipy.linalg.qr_update(Qc, Rc, w, s, overwrite_qruv=True) + + return (Qp, Rp) diff --git a/src/polykin/math/roots/results.py b/src/polykin/math/roots/results.py index 4b21e9b3..eafc0e8d 100644 --- a/src/polykin/math/roots/results.py +++ b/src/polykin/math/roots/results.py @@ -71,15 +71,15 @@ class VectorRootResult: nfeval: int Number of function evaluations. njeval: int | None - Number of Jacobian evaluations. + Number of user-supplied Jacobian evaluations. niter: int Number of iterations. x: FloatVector Root value. f: FloatVector Function (residual) value at root. - jac: FloatMatrix - Last Jacobian value evaluated or estimated. + J: FloatMatrix | None + Last evaluated or estimated Jacobian matrix. """ method: str @@ -90,7 +90,7 @@ class VectorRootResult: niter: int x: FloatVector f: FloatVector - jac: FloatMatrix | None + J: FloatMatrix | None def __repr__(self) -> str: """Return a string representation of the vector root result.""" @@ -103,5 +103,5 @@ def __repr__(self) -> str: f" niter: {self.niter}\n" f" x: {self.x}\n" f" f: {self.f}\n" - f" jac: {self.jac}" + f" J: {self.J}" ) diff --git a/src/polykin/math/roots/scalar.py b/src/polykin/math/roots/scalar.py index e78cf2d8..66d8c510 100644 --- a/src/polykin/math/roots/scalar.py +++ b/src/polykin/math/roots/scalar.py @@ -7,7 +7,7 @@ import numpy as np from polykin.math.derivatives import derivative_complex -from polykin.utils.math import eps +from polykin.math.machine import eps from .results import RootResult @@ -25,7 +25,7 @@ def root_newton( tolx: float = 1e-6, tolf: float = 1e-6, maxiter: int = 50, - verbose: bool = False, + callback: Callable[[int, float, float], tuple[bool, bool]] | None = None, ) -> RootResult: r"""Find the root of a scalar function using the Newton-Raphson method. @@ -60,8 +60,10 @@ def root_newton( when `|f(x)| <= tolf`. maxiter : int Maximum number of iterations. - verbose : bool - Print iteration information. + callback : Callable[[int, float, float], tuple[bool, bool]] | None + Optional callback with signature `callback(niter, x, fx)->(stop, success)` called + at each iteration. If `stop` is `True`, the iteration is terminated. If `success` + is `True`, the optimization is considered successful. Returns ------- @@ -85,14 +87,19 @@ def root_newton( nfeval = 0 x = x0 + fx = float("nan") + niter = 0 - for k in range(maxiter): - + for niter in range(1, maxiter + 1): dfdx, fx = derivative_complex(f, x) nfeval += 1 - if verbose: - print(f"Iteration {k+1}: x = {x}, f(x) = {fx}, df/dx = {dfdx}", flush=True) + if callback is not None: + stop, _success = callback(niter, x, fx) + if stop: + message = "Terminated by user callback." + success = _success + break if abs(fx) <= tolf: message = "|f(x)| ≤ tolf" @@ -110,13 +117,13 @@ def root_newton( success = True break - if k + 1 < maxiter: + if niter < maxiter: x += Δx else: message = f"Maximum number of iterations ({maxiter}) reached." - return RootResult(method, success, message, nfeval, k + 1, x, fx) + return RootResult(method, success, message, nfeval, niter, x, fx) def root_secant( @@ -127,7 +134,7 @@ def root_secant( tolx: float = 1e-6, tolf: float = 1e-6, maxiter: int = 50, - verbose: bool = False, + callback: Callable[[int, float, float], tuple[bool, bool]] | None = None, ) -> RootResult: r"""Find the root of a scalar function using the secant method. @@ -156,8 +163,10 @@ def root_secant( when `|f(x)| <= tolf`. maxiter : int Maximum number of iterations. - verbose : bool - Print iteration information. + callback : Callable[[int, float, float], tuple[bool, bool]] | None + Optional callback with signature `callback(niter, x, fx)->(stop, success)` called + at each iteration. If `stop` is `True`, the iteration is terminated. If `success` + is `True`, the optimization is considered successful. Returns ------- @@ -192,10 +201,10 @@ def root_secant( message = "|f(x1)| ≤ tolf" return RootResult(method, True, message, nfeval, 0, x1, f1) - x2, f2 = np.nan, np.nan - - for k in range(maxiter): + x2, f2 = float("nan"), float("nan") + niter = 0 + for niter in range(1, maxiter + 1): Δf = f1 - f0 if abs(Δf) <= eps * max(abs(f0), abs(f1), 1.0): message = f"Nearly zero slope between x[k-1]={x0} and x[k]={x1} (Δf={Δf})." @@ -206,16 +215,20 @@ def root_secant( f2 = f(x2) nfeval += 1 - if verbose: - print(f"Iteration {k+1}: x = {x2}, f(x) = {f2}", flush=True) + if callback is not None: + stop, _success = callback(niter, x2, f2) + if stop: + message = "Terminated by user callback." + success = _success + break - if abs(x2 - x1) <= tolx: - message = "|Δx| ≤ tolx" + if abs(f2) <= tolf: + message = "|f(x)| ≤ tolf" success = True break - if abs(f2) <= tolf: - message = "|f(x)| ≤ tolf" + if abs(x2 - x1) <= tolx: + message = "|Δx| ≤ tolx" success = True break @@ -225,7 +238,7 @@ def root_secant( else: message = f"Maximum number of iterations ({maxiter}) reached." - return RootResult(method, success, message, nfeval, k + 1, x2, f2) + return RootResult(method, success, message, nfeval, niter, x2, f2) def root_brent( @@ -236,7 +249,7 @@ def root_brent( tolx: float = 1e-6, tolf: float = 1e-6, maxiter: int = 50, - verbose: bool = False, + callback: Callable[[int, float, float], tuple[bool, bool]] | None = None, ) -> RootResult: r"""Find the root of a scalar function using Brent's method. @@ -270,8 +283,10 @@ def root_brent( when `|f(x)|<=tolf`. maxiter : int Maximum number of iterations. - verbose : bool - Print iteration information. + callback : Callable[[int, float, float], tuple[bool, bool]] | None + Optional callback with signature `callback(niter, x, fx)->(stop, success)` called + at each iteration. If `stop` is `True`, the iteration is terminated. If `success` + is `True`, the optimization is considered successful. Returns ------- @@ -310,9 +325,9 @@ def root_brent( raise ValueError("Root is not bracketed.") xc, fc = xb, fb + niter = 0 - for k in range(maxiter): - + for niter in range(1, maxiter + 1): if fb * fc > 0.0: xc, fc = xa, fa d = xb - xa @@ -323,22 +338,26 @@ def root_brent( xb, fb = xc, fc xc, fc = xa, fa - if verbose: - print(f"Iteration {k+1}: x = {xb}, f(x) = {fb}", flush=True) - tol1 = 2 * eps * abs(xb) + 0.5 * tolx m = 0.5 * (xc - xb) - if abs(m) <= tol1: - message = "|Δx| ≤ tolx" - success = True - break + if callback is not None: + stop, _success = callback(niter, xb, fb) + if stop: + message = "Terminated by user callback." + success = _success + break if abs(fb) <= tolf: message = "|f(x)| ≤ tolf" success = True break + if abs(m) <= tol1: + message = "|Δx| ≤ tolx" + success = True + break + if (abs(e) >= tol1) and (abs(fa) > abs(fb)): s = fb / fa if xa == xc: @@ -376,4 +395,4 @@ def root_brent( else: message = f"Maximum number of iterations ({maxiter}) reached." - return RootResult(method, success, message, nfeval, k + 1, xb, fb) + return RootResult(method, success, message, nfeval, niter, xb, fb) diff --git a/src/polykin/math/roots/vector.py b/src/polykin/math/roots/vector.py deleted file mode 100644 index cfc1b959..00000000 --- a/src/polykin/math/roots/vector.py +++ /dev/null @@ -1,778 +0,0 @@ -# PolyKin: A polymerization kinetics library for Python. -# -# Copyright Hugo Vale 2025 - -from collections.abc import Callable -from enum import IntEnum -from typing import Literal - -import numpy as np -import scipy -from numpy import dot, isclose, sqrt -from numpy.linalg import norm - -from polykin.math.derivatives import jacobian_forward, scalex -from polykin.math.roots.results import VectorRootResult -from polykin.utils.math import eps -from polykin.utils.typing import FloatMatrix, FloatVector - -all = ["rootvec_qnewton"] - - -def rootvec_qnewton( - f: Callable[[FloatVector], FloatVector], - x0: FloatVector, - *, - tolx: float = 4e-11, - tolf: float = 6e-6, - sclx: FloatVector | None = None, - sclf: FloatVector | None = None, - maxiter: int = 100, - maxlenfac: float = 1e3, - trustlen: float | None = None, - ndigit: int | None = None, - global_method: Literal["line-search", "dogleg"] | None = "line-search", - broyden_update: bool = False, - jac: Callable[[FloatVector], FloatMatrix] | None = None, - jac0: FloatMatrix | None = None, - verbose: bool = False, -) -> VectorRootResult: - r"""Find the root of a system of nonlinear equations using a quasi-Newton - method with optional global strategies. - - This function implements a quasi-Newton solver for systems of nonlinear - equations according to Dennis and Schnabel (1996). The user can choose the - approach to calculate and update the Jacobian approximation, as well as the - global strategy to improve convergence from remote starting points. - - The default settings are meant to favor the likelihood of convergence at the - expense of computational efficiency. For situations where maximum efficiency - is desired and the initial guess is known to be close to the root, consider - disabling the global method and using Broyden's update for the Jacobian. - - !!! note - - Solving systems of nonlinear equations is a surprisingly complex task — - often more difficult than solving systems of differential equations or - even multivariate optimization problems. - Convergence is guaranteed only when the initial guess is sufficiently - close to the root, which is rarely true in practice. The choice of a - good initial guess, appropriate scaling factors, and a suitable global - strategy is an essential part of solving the problem. - - **References** - - * J.E. Dennis Jr., R.B. Schnabel, "Numerical Methods for Unconstrained - Optimization and Nonlinear Equations", SIAM, 1996. - - Parameters - ---------- - f : Callable[[FloatVector], FloatVector] - Function whose root is to be found. - x0 : FloatVector - Initial guess for the root. Moreover, if no user-defined scale `sclx` - is provided, the scaling factors will be determined from this value. - tolx : float - Tolerance for the scaled step size. The algorithm terminates when the - scaled distance between two successive iterates `||Δx/max(x, 1/sclx)||∞` - is below this threshold. If the value is too large, the algorithm may - terminate prematurely. A value on the order of $\epsilon^{2/3}$ is - typically recommended. - tolf : float - Tolerance for the scaled residual norm. This is the main convergence - criterion. The algorithm terminates when the infinity norm of the scaled - function values `||sclf*f(x)||∞` is below this threshold. A value on - the order of $\epsilon^{1/3}$ is typically recommended. - sclx : FloatVector | None - Positive scaling factors for the components of `x`. Ideally, these - should be chosen so that `sclx*x` is of order 1 near the solution for - all components. By default, scaling is determined from `x0`. - sclf : FloatVector | None - Positive scaling factors for the components of `f`. Ideally, these - should be chosen so that `sclf*f` is of order 1 near the root for all - components. By default, scaling is determined from the initial Jacobian. - maxiter : int - Maximum number of outer quasi-Newton iterations. - maxlenfac : float - Factor determining the maximum allowable scaled step length `||sclx*Δx||₂` - for global methods. Used to prevent steps that would cause the algorithm - to overflow, leave the domain of interest, or diverge. It should be - chosen small enough to prevent such issues, but large enough to allow - any anticipated reasonable step length. - trustlen : float | None - Initial trust region radius for the `dogleg` global method. By default, - the length of the initial scaled gradient is used. - ndigit : int | None - Number of reliable digits returned by `f`. Used to set the step size - for finite-difference Jacobian approximations. By default, 64-bit float - precision is assumed (i.e., ~15 digits). - global_method : Literal['line-search','dogleg'] | None - Global strategy to improve convergence from remote starting points. With - `line-search`, the search direction is computed using the quasi-Newton - step and the length of the step is determined by backtracking until - the Armijo condition is fullfiled. With `dogleg`, a trust-region dogleg - method is used to compute both the step direction and length. If `None`, - no global strategy is used and the full quasi-Newton step is taken at - each iteration. - broyden_update : bool - If `True`, the Jacobian is updated at each iteration using Broyden's - rank-1 update formula. If `False`, the Jacobian is computed at each - iteration using either the provided `jac` function or finite differences. - Broyden's update significantly reduces the number of function/Jacobian - evaluations required, but may lead to inaccurate Jacobian approximations - and poor convergence if the initial guess is far from the root or if the - function is highly nonlinear. - jac : Callable[[FloatVector], FloatMatrix] | None - Function to compute the Jacobian of `f`. By default, the Jacobian is - approximated using forward finite differences. In this case, setting - `ndigit` appropriately is essential. - jac0 : FloatMatrix | None - Initial Jacobian approximation at `x0`. If provided, it is used instead - of computing the Jacobian at the first iteration. This can be useful in - case of a restart, or when a simple initial approximation is sufficient - (e.g., the identity matrix) and one wants to reduce the number of function - calls. - verbose : bool - Print iteration information. - - Returns - ------- - VectorRootResult - Dataclass with root solution results. - - Examples - -------- - Find the steady-state concentration of species A, B, and C at the outlet of - a CSTR, assuming a consecutive scheme of type A+B→C, C+B→D. - >>> from polykin.math import rootvec_qnewton - >>> import numpy as np - >>> def f(x, A0=1.0, B0=2.0, C0=0.0, k1=1e-3, k2=5e-4, tau=1e3): - ... "Steady-state mole balances: inflow - outflow ± reaction" - ... A, B, C = x - ... f = np.zeros_like(x) - ... f[0] = (A0 - A)/tau - k1*A*B - ... f[1] = (B0 - B)/tau - k1*A*B - ... f[2] = (C0 - C)/tau + k1*A*B - k2*C*B - ... return f - >>> sol = rootvec_qnewton(f, np.array([0.5, 1.0, 0.5])) - >>> sol.x - array([0.41421356, 1.41421356, 0.34314575]) - """ - method = "Quasi-Newton" - if global_method: - method += f" ({global_method})" - - success = False - message = "" - nfeval = 0 - njeval = 0 - - # Evaluate function at x0 - n = x0.size - xc = x0.copy() - fc = f(xc) - nfeval += 1 - - # Set x scaling factors - if sclx is None: - sclx = scalex(x0) - - # Evaluate Jacobian at x0 - if jac0 is not None: - J = jac0.copy() - else: - if jac is not None: - J = jac(xc) - njeval += 1 - else: - J = jacobian_forward(f, xc, fx=fc, sclx=sclx, ndigit=ndigit) - nfeval += n - - # Set f scaling factors - if sclf is None: - sclf = np.max(np.abs(J), axis=1) - sclf[sclf == 0.0] = 1.0 - sclf = 1 / sclf - - # Check initial solution with tight tolerance - if norm(sclf * fc, np.inf) <= 1e-2 * tolf: - message = "||sclf*f(x0)||∞ ≤ 1e-2*tolf" - return VectorRootResult(method, True, message, nfeval, njeval, 0, x0, fc, J) - - # Set maximum step length for global methods - maxlen = max(0.0, maxlenfac) * float(max(norm(sclx * x0), norm(sclx))) - - # Set initial trust region radius for dogleg method - if trustlen is None: - trustlen = -1.0 # Sentinel value - else: - trustlen = min(trustlen, maxlen) - - # Norm function for global methods - def fN(fx: FloatVector) -> float: - """1/2*||sclf*f(x)||².""" - return 0.5 * np.sum((sclf * fx) ** 2) - - gm_nmaxsteps = 0 - restart = True - Q = np.array([]) - R = np.array([]) - - for niter in range(1, maxiter + 1): - if verbose: - print(f"Iteration {niter:3d}:", flush=True) - - # QR decomposition of scaled Jacobian - if not broyden_update or restart: - try: - Q, R = scipy.linalg.qr(sclf[:, None] * J) - except Exception as e: - message = f"QR decomposition of Jacobian failed: {e}." - break - - # Condition number of R - Rcond = np.linalg.cond(R / sclx, 1) - - # Solve (Q*R)*p = - sclf*fc - if Rcond < 1 / sqrt(eps): - p = -scipy.linalg.solve_triangular(R, Q.T @ (sclf * fc)) - if global_method: - gc = R.T @ (Q.T @ (sclf * fc)) - else: - if verbose: - print("R is ill-conditioned (cond={Rcond:.2e}).", flush=True) - H = R.T @ R - Hnorm = norm(H / (sclx[:, None] * sclx[None, :]), 1) - H[np.diag_indices_from(H)] += sqrt(n * eps) * Hnorm * sclx**2 - gc = R.T @ (Q.T @ (sclf * fc)) - R, _ = scipy.linalg.cho_factor(H, overwrite_a=True) - p = -scipy.linalg.cho_solve((R, False), gc) - - # Compute actual x step - if global_method is None: - xp = xc + p - fp = f(xp) - gm_ismaxstep = True - gm_success = True - gm_nfeval = 1 - elif global_method == "line-search": - gm_success, gm_ismaxstep, gm_nfeval, xp, fp, _ = line_search( - f, fN, xc, fc, gc, p, tolx, sclx, maxlen, verbose - ) - elif global_method == "dogleg": - gm_success, gm_ismaxstep, gm_nfeval, xp, fp, _, trustlen = dogleg( - f, fN, xc, fc, gc, p, R, tolx, sclx, maxlen, trustlen, verbose - ) - else: - raise ValueError(f"Unknown `global_method`: {global_method}.") - - nfeval += gm_nfeval - gm_nmaxsteps = gm_nmaxsteps + 1 if gm_ismaxstep else 0 - - # Display iteration progress - if verbose: - print( - f" x = {xp}\n ||sclx*f(x)||∞ = {norm(sclf * fp, np.inf):.2e}", - flush=True, - ) - - # If global method step failed, restart once - if not gm_success and not restart: - if jac is not None: - J = jac(xc) - njeval += 1 - else: - J = jacobian_forward(f, xc, fx=fc, sclx=sclx, ndigit=ndigit) - nfeval += n - restart = True - continue - - # Check termination and convergence conditions - if not gm_success: - message = """Last global step failed to decrease ½||sclx*f(x)||₂ sufficiently. - Either `x` is close to a root and no more accuracy is possible, - or the secant approximation to the Jacobian is inaccurate, - or `tolx` is too large.""" - stop = True - elif norm(sclf * fp, np.inf) <= tolf: - message = "||sclf*f(x)||∞ ≤ tolf" - success = True - stop = True - elif norm((xp - xc) / np.maximum(np.abs(xp), 1 / sclx), np.inf) <= tolx: - message = """||Δx/max(x, 1/sclx)||∞ ≤ tolx - `x` may be an approximate root, but it is also possible that the - the algorithm is making slow progress and is not near a root, - or that `tolx` is too large.""" - stop = True - elif global_method and gm_nmaxsteps >= 5: - message = """Maximum number (5) of consecutive steps of length `maxlen` reached. - Perhaps stuck in a flat region or `maxlen` is too small.""" - stop = True - else: - stop = False - - if stop: - xc, fc = xp, fp - break - - # Update Jacobian - if broyden_update: - Q, R = _update_broyden_qr(xc, xp, fc, fp, Q, R, sclx, sclf) - else: - if jac is not None: - J = jac(xp) - njeval += 1 - else: - J = jacobian_forward(f, xp, fx=fp, sclx=sclx, ndigit=ndigit) - nfeval += n - - # Next iteration - xc, fc = xp, fp - restart = False - - else: - message = f"Maximum number of iterations ({maxiter}) reached." - - if broyden_update: - J = (Q @ R) / sclf[:, None] - - return VectorRootResult(method, success, message, nfeval, njeval, niter, xc, fc, J) - - -def _update_broyden_qr( - xc: FloatVector, - xp: FloatVector, - fc: FloatVector, - fp: FloatVector, - Qc: FloatMatrix, - Rc: FloatMatrix, - sclx: FloatVector, - sclf: FloatVector, -) -> tuple[FloatMatrix, FloatMatrix]: - r"""Perform a Broyden update of the QR decomposition of a Jacobian - approximation. - - This function updates the QR factors of an approximate Jacobian according - to the Broyden rank-1 update formula, using scaling factors for both the - variables and function values to improve numerical conditioning. - - **References** - - * J.E. Dennis Jr., R.B. Schnabel, "Numerical Methods for Unconstrained - Optimization and Nonlinear Equations", SIAM, 1996. - - Parameters - ---------- - xc : FloatVector - Current value of the variable vector - xp : FloatVector - Next value of the variable vector. - fc : FloatVector - Current function value, `f(xc)`. - fp : FloatVector - Next function value, `f(xp)`. - Qc : FloatMatrix - Orthogonal factor of the current Jacobian QR decomposition. - Rc : FloatMatrix - Upper-triangular factor of the current Jacobian QR decomposition. - sclx : FloatVector - Scaling factors for the components of `x`. - sclf : FloatVector - Scaling factors for the components of `f`. - - Returns - ------- - tuple[FloatMatrix, FloatMatrix] - The updated orthogonal and upper-triangular factors, `(Qp, Rp)`. - """ - s = xp - xc - y = fp - fc - - w = sclf * y - Qc @ (Rc @ s) - w[np.abs(w) < eps * sclf * (np.abs(fp) + np.abs(fc))] = 0.0 - - t = s * sclx**2 - s = t / dot(s, t) - Qp, Rp = scipy.linalg.qr_update(Qc, Rc, w, s, overwrite_qruv=True) - - return (Qp, Rp) - - -def line_search( - f: Callable[[FloatVector], FloatVector], - fN: Callable[[FloatVector], float], - xc: FloatVector, - fc: FloatVector, - gc: FloatVector, - p: FloatVector, - tolx: float, - sclx: FloatVector, - maxlen: float, - verbose: bool = False, -) -> tuple[bool, bool, int, FloatVector, FloatVector, float]: - r"""Perform a line search. - - This function performs a line search along the quasi-Newton direction to - find a step size that satisfies the Armijo condition. - - **References** - - * J.E. Dennis Jr., R.B. Schnabel, "Numerical Methods for Unconstrained - Optimization and Nonlinear Equations", SIAM, 1996. - - Parameters - ---------- - f : Callable[[FloatVector], FloatVector] - Function whose root is to be found. - fN : Callable[[FloatVector], float] - Norm function. - xc : FloatVector - Current value of the variable vector. - fc : FloatVector - Current function value, `f(xc)`. - gc : FloatVector - Gradient of the norm function, `∇fN(xc)`. - p : FloatVector - Quasi-Newton step. - tolx : float - Tolerance for the step size. - sclx : FloatVector - Scaling factors for `x`. - maxlen : float - Maximum step length. - verbose : bool - Print iteration information. - - Returns - ------- - tuple[bool, bool, int, FloatVector, FloatVector, float] - `(success, ismaxstep, nfeval, xp, fp, fNp)` - """ - nfeval = 0 - success = False - ismaxstep = False - - newtlen = norm(sclx * p) - if newtlen > maxlen: - p = p * (maxlen / newtlen) - newtlen = maxlen - - fNc = fN(fc) - slope = dot(gc, p) - - α = 1e-4 - λ = 1.0 - λmin = tolx / np.max(np.abs(p) / np.maximum(np.abs(xc), 1 / sclx)) - - A = np.empty((2, 2)) - B = np.empty(2) - λ_prev = np.nan - fNp_prev = np.nan - - first = True - while True: - xp = xc + λ * p - fp = f(xp) - fNp = fN(fp) - nfeval += 1 - - if verbose: - print(f" λ = {λ:.2e}, ½||sclx*f(x)||² = {fNp:.2e}", flush=True) - - if fNp <= fNc + α * λ * slope: - success = True - if first and (newtlen > 0.99 * maxlen): - ismaxstep = True - break - elif λ < λmin: - success = False - xp = xc - break - else: - if first: - λtemp = -slope / (2 * (fNp - fNc - slope)) - first = False - else: - A[0, 0] = 1 / λ**2 - A[0, 1] = -1 / λ_prev**2 - A[1, 0] = -λ_prev / λ**2 - A[1, 1] = λ / λ_prev**2 - B[0] = fNp - fNc - λ * slope - B[1] = fNp_prev - fNc - λ_prev * slope - a, b = 1 / (λ - λ_prev) * A @ B - if isclose(a, 0.0): - λtemp = -slope / (2 * b) - else: - λtemp = (-b + sqrt(b**2 - 3 * a * slope)) / (3 * a) - λtemp = min(λtemp, 0.5 * λ) - λ_prev = λ - fNp_prev = fNp - λ = max(0.1 * λ, λtemp) - - return (success, ismaxstep, nfeval, xp, fp, fNp) - - -class TrustState(IntEnum): - """Codes for the status of the trust region step and update.""" - - accepted = 0 - convergence = 1 - rejected = 2 - exploratory_success = 3 - start = 4 - - -def dogleg( - f: Callable[[FloatVector], FloatVector], - fN: Callable[[FloatVector], float], - xc: FloatVector, - fc: FloatVector, - gc: FloatVector, - p: FloatVector, - R: FloatMatrix, - tolx: float, - sclx: FloatVector, - maxlen: float, - trustlen: float, - verbose: bool = False, -) -> tuple[bool, bool, int, FloatVector, FloatVector, float, float]: - r"""Perform a dogleg step. - - **References** - - * J.E. Dennis Jr., R.B. Schnabel, "Numerical Methods for Unconstrained - Optimization and Nonlinear Equations", SIAM, 1996. - - Parameters - ---------- - f : Callable[[FloatVector], FloatVector] - Function whose root is to be found. - fN : Callable[[FloatVector], float] - Norm function. - xc : FloatVector - Current value of the variable vector. - fc : FloatVector - Current function value, `f(xc)`. - gc : FloatVector - Gradient of the norm function, `∇fN(xc)`. - p : FloatVector - Quasi-Newton step. - R : FloatMatrix - Upper-triangular factor of the current Jacobian QR decomposition. - tolx : float - Tolerance for the step size. - sclx : FloatVector - Scaling factors for `x`. - maxlen : float - Maximum step length. - trustlen : float - Current trust region radius. - verbose : bool - Print iteration information. - - Returns - ------- - tuple[bool, bool, int, FloatVector, FloatVector, float, float] - `(success, ismaxstep, nfeval, xp, fp, fNp, trustlen)` - """ - nfeval = 0 - state = TrustState.start - ismaxstep = False - - cauchylen = np.nan - η = np.nan - v = np.full(p.size, np.nan) - sSD = np.full(p.size, np.nan) - xp_prev = xc - fp_prev = fc - fNp_prev = 0.0 - - newtlen = float(norm(sclx * p)) - fNc = fN(fc) - - first = True - while state not in (TrustState.accepted, TrustState.convergence): - # Perform dogleg step to determine s - if newtlen <= trustlen: - isnewtstep = True - s = p - trustlen = newtlen - else: - isnewtstep = False - if first: - first = False - α = norm(gc / sclx) ** 2 - β = norm(R @ (gc / sclx**2)) ** 2 - sSD = -(α / β) * (gc / sclx) - cauchylen = α * sqrt(α) / β - η = 0.2 + (0.8 * α**2 / (β * abs(dot(gc, p)))) - v = η * (p * sclx) - sSD - if trustlen <= 0.0: - trustlen = min(cauchylen, maxlen) - - if η * newtlen <= trustlen: - s = (trustlen / newtlen) * p - elif cauchylen >= trustlen: - s = (trustlen / cauchylen) * (sSD / sclx) - else: - a = dot(v, v) - b = dot(v, sSD) - λ = (-b + sqrt(b**2 - a * (cauchylen**2 - trustlen**2))) / a - s = (sSD + λ * v) / sclx - - # Update trust region - state, ismaxstep, trustlen, xp, fp, fNp, xp_prev, fp_prev, fNp_prev = ( - _update_trust_region( - f, - fN, - fNc, - xc, - gc, - R, - s, - sclx, - tolx, - maxlen, - trustlen, - isnewtstep, - xp_prev, - fp_prev, - fNp_prev, - state, - ) - ) - nfeval += 1 - - # Display iteration progress - if verbose: - print(f" δ = {trustlen:.2e}, ½||sclx*f(x)||² = {fNp:.2e}", flush=True) - - return (state == 0, ismaxstep, nfeval, xp, fp, fNp, trustlen) - - -def _update_trust_region( - f: Callable[[FloatVector], FloatVector], - fN: Callable[[FloatVector], float], - fNc: float, - xc: FloatVector, - gc: FloatVector, - R: FloatMatrix, - s: FloatVector, - sclx: FloatVector, - tolx: float, - maxlen: float, - trustlen: float, - isnewtstep: bool, - xp_prev: FloatVector, - fp_prev: FloatVector, - fNp_prev: float, - state: TrustState, -) -> tuple[ - TrustState, - bool, - float, - FloatVector, - FloatVector, - float, - FloatVector, - FloatVector, - float, -]: - r"""Perform trust-region update. - - **References** - - * J.E. Dennis Jr., R.B. Schnabel, "Numerical Methods for Unconstrained - Optimization and Nonlinear Equations", SIAM, 1996. - - Parameters - ---------- - f : Callable[[FloatVector], FloatVector] - Function whose root is to be found. - fN : Callable[[FloatVector], float] - Norm function. - fNc : float - Norm function value at current point, `fN(fc)`. - xc : FloatVector - Current value of the variable vector. - gc : FloatVector - Gradient of the norm function, `∇fN(xc)`. - R : FloatMatrix - Upper-triangular factor of the current Jacobian QR decomposition. - s : FloatVector - Step vector. - sclx : FloatVector - Scaling factors for `x`. - tolx : float - Tolerance for the step size. - maxlen : float - Maximum step length. - trustlen : float - Current trust region radius. - isnewtstep : bool - Flag indicating if the step is a Newton step. - xp_prev : FloatVector - Previous value of `xp`. - fp_prev : FloatVector - Previous value of `fp`. - fNp_prev : float - Previous value of `fN(fp)`. - state : TrustRegionState - Code indicating the current state of the algorithm. - - Returns - ------- - tuple[TrustRegionState, bool, float, FloatVector, FloatVector, float, FloatVector, FloatVector, float] - `(state, ismaxstep, trustlen, xp, fp, fNp, xp_prev, fp_prev, fNp_prev)` - """ - α = 1e-4 - ismaxstep = False - - steplen = norm(sclx * s) - slope = dot(gc, s) - - xp = xc + s - fp = f(xp) - - fNp = fN(fp) - ΔfN = fNp - fNc - - if (state == TrustState.exploratory_success) and ( - (fNp >= fNp_prev) or (ΔfN > α * slope) - ): - state = TrustState.accepted - xp, fp, fNp = xp_prev, fp_prev, fNp_prev - trustlen *= 0.5 - elif ΔfN >= α * slope: - rlen = np.max(np.abs(s) / np.maximum(np.abs(xp), 1 / sclx)) - if rlen < tolx: - state = TrustState.convergence - xp = xc - else: - state = TrustState.rejected - trustlen = np.clip( - -slope * steplen / (2 * (ΔfN - slope)), 0.1 * trustlen, 0.5 * trustlen - ) - else: - ΔfN_pred = slope + 0.5 * norm(R @ s) ** 2 - if ( - (state != TrustState.rejected) - and (not isnewtstep) - and (trustlen <= 0.99 * maxlen) - and ((abs(ΔfN_pred - ΔfN) <= 0.1 * abs(ΔfN)) or (ΔfN <= slope)) - ): - state = TrustState.exploratory_success - xp_prev, fp_prev, fNp_prev = xp, fp, fNp - trustlen = min(2 * trustlen, maxlen) - else: - state = TrustState.accepted - if steplen >= 0.99 * maxlen: - ismaxstep = True - if ΔfN >= 0.1 * ΔfN_pred: - trustlen *= 0.5 - elif ΔfN <= 0.75 * ΔfN_pred: - trustlen = min(2 * trustlen, maxlen) - else: - trustlen = trustlen # no change - - return (state, ismaxstep, trustlen, xp, fp, fNp, xp_prev, fp_prev, fNp_prev) diff --git a/src/polykin/math/special.py b/src/polykin/math/special.py index b4b43a3e..717ecdea 100644 --- a/src/polykin/math/special.py +++ b/src/polykin/math/special.py @@ -3,9 +3,10 @@ # Copyright Hugo Vale 2024 import functools +import math import numpy as np -from numpy import arctan, exp, inf, pi, sqrt, tan +from numpy import inf, pi from scipy.special import erfc from polykin.math import root_newton @@ -42,7 +43,7 @@ def ierfc(x: float) -> float: if x > 30.0: return 0.0 else: - return exp(-(x**2)) / sqrt(pi) - x * erfc(x) + return math.exp(-(x**2)) / math.sqrt(pi) - x * erfc(x) def i2erfc(x: float) -> float: @@ -108,7 +109,7 @@ def roots_xtanx(a: float, N: int, tolx: float = 1e-6) -> FloatVector: elif a < 1e2: for i in range(N): sol = root_newton( - f=lambda x: x * tan(x) - a, + f=lambda x: x * np.tan(x) - a, x0=pi * (i + 0.5 * a / (a + 1)), tolx=tolx, tolf=1e-10, @@ -119,7 +120,7 @@ def roots_xtanx(a: float, N: int, tolx: float = 1e-6) -> FloatVector: x0 = i * pi e = 1.0 for _ in range(0, 10): - e_new = arctan(a / (x0 + e)) + e_new = np.arctan(a / (x0 + e)) if abs(e_new - e) < tolx: break e = e_new @@ -165,7 +166,7 @@ def roots_xcotx(a: float, N: int, tolx: float = 1e-6) -> FloatVector: elif a < 2: for i in range(N): sol = root_newton( - f=lambda x: x / tan(x) + a - 1, + f=lambda x: x / np.tan(x) + a - 1, x0=(i + 1 / 2) * pi, tolx=tolx, tolf=1e-10, diff --git a/src/polykin/properties/equations/base.py b/src/polykin/properties/equations/base.py index 7bf9d7c9..f6dc32da 100644 --- a/src/polykin/properties/equations/base.py +++ b/src/polykin/properties/equations/base.py @@ -12,7 +12,7 @@ from numpy import log from scipy.optimize import curve_fit -from polykin.utils.math import eps +from polykin.math.machine import eps from polykin.utils.tools import ( check_bounds, check_in_set, diff --git a/src/polykin/properties/pvt/tait.py b/src/polykin/properties/pvt/tait.py index 3043210d..e6a04405 100644 --- a/src/polykin/properties/pvt/tait.py +++ b/src/polykin/properties/pvt/tait.py @@ -11,8 +11,8 @@ from numpy import exp from numpy import log as ln +from polykin.math.machine import eps from polykin.properties.pvt.io import load_PVT_parameters -from polykin.utils.math import eps from polykin.utils.tools import ( check_bounds, convert_check_pressure, diff --git a/src/polykin/thermo/eos/base.py b/src/polykin/thermo/eos/base.py index be63208e..c82cd6e8 100644 --- a/src/polykin/thermo/eos/base.py +++ b/src/polykin/thermo/eos/base.py @@ -16,9 +16,9 @@ derivative_complex, jacobian_forward, ) +from polykin.math.machine import eps from polykin.math.roots import root_newton from polykin.utils.exceptions import RootSolverError -from polykin.utils.math import eps from polykin.utils.typing import FloatVector, Number __all__ = [ diff --git a/src/polykin/thermo/eos/cubic.py b/src/polykin/thermo/eos/cubic.py index d29d8d6a..adecdff4 100644 --- a/src/polykin/thermo/eos/cubic.py +++ b/src/polykin/thermo/eos/cubic.py @@ -16,10 +16,11 @@ from polykin.constants import R from polykin.math import fixpoint_wegstein +from polykin.math.machine import eps from polykin.properties.pvt.mixing_rules import geometric_interaction_mixing from polykin.properties.vaporization import PL_Wilson from polykin.utils.exceptions import ConvergenceError -from polykin.utils.math import convert_FloatOrVectorLike_to_FloatVector, eps +from polykin.utils.math import convert_FloatOrVectorLike_to_FloatVector from polykin.utils.typing import FloatSquareMatrix, FloatVector, FloatVectorLike from .base import GasLiquidEoS diff --git a/src/polykin/thermo/flash/vle.py b/src/polykin/thermo/flash/vle.py index 18e2a1e5..202d7a50 100644 --- a/src/polykin/thermo/flash/vle.py +++ b/src/polykin/thermo/flash/vle.py @@ -4,9 +4,9 @@ import numpy as np from numpy import dot, exp, log -from polykin.math import root_brent, root_newton +from polykin.math.machine import eps +from polykin.math.roots import root_brent, root_newton from polykin.properties.vaporization.pvap import PL_Wilson -from polykin.utils.math import eps from polykin.utils.tools import colored_bool from polykin.utils.typing import FloatVector diff --git a/src/polykin/utils/docs.py b/src/polykin/utils/docs.py index 1fa6a9bf..49e03561 100644 --- a/src/polykin/utils/docs.py +++ b/src/polykin/utils/docs.py @@ -26,8 +26,8 @@ def to_html(plt_obj, fmt="png", dpi=100, transparent=True, **kwargs): dpi : int, optional The resolution in dots per inch. The default is 100. transparent : bool, optional - If True, the axes patches will be transparent. Useful for - documentation with dark/light mode toggles. The default is True. + If `True`, the axes patches will be transparent. Useful for + documentation with dark/light mode toggles. The default is `True`. **kwargs : dict Additional keyword arguments passed to `savefig`. diff --git a/src/polykin/utils/math.py b/src/polykin/utils/math.py index 32c4d9c6..22df3a80 100644 --- a/src/polykin/utils/math.py +++ b/src/polykin/utils/math.py @@ -28,11 +28,6 @@ FloatVector, ) -_finfo = np.finfo(np.float64) -eps = float(_finfo.eps) -huge = float(_finfo.max) -tiny = float(_finfo.tiny) - def add_dicts( d1: dict[Any, int | float], @@ -49,7 +44,7 @@ def add_dicts( d2 : dict[Any, int | float] second dictionary new : bool - if True, a new dictionary will be created (`d = d1 + d2`), otherwise, + if `True`, a new dictionary will be created (`d = d1 + d2`), otherwise, d1 will be modified in place (`d1 <- d1 + d2`). Returns diff --git a/src/polykin/utils/typing.py b/src/polykin/utils/typing.py index feff8cb0..013a1c8c 100644 --- a/src/polykin/utils/typing.py +++ b/src/polykin/utils/typing.py @@ -57,6 +57,11 @@ Floaty = TypeVar("Floaty", float, NDArray[np.float64]) """A TypeVar representing either a float scalar or a float64 NumPy array.""" +# --- Boolean Arrays and Sequences --- + +BoolVector: TypeAlias = np.ndarray[tuple[int], dtype[np.bool_]] +"""A 1-dimensional NumPy array of booleans.""" + # --- Integer Arrays and Sequences --- IntArray = NDArray[np.int_] diff --git a/tests/kinetics/test_desorption.py b/tests/kinetics/test_desorption.py index 9a9c862f..abce7e36 100644 --- a/tests/kinetics/test_desorption.py +++ b/tests/kinetics/test_desorption.py @@ -4,7 +4,7 @@ def test_kdesorption_Asua(): - kdes = kdesorption_Asua(kfmp=1e-3, kpp=1e2, Mp=10, K0=1e3, beta=0.20) + kdes = kdesorption_Asua(kfmp=1e-3, kpp1=1e2, Mp=10, K0=1e3, beta=0.20) assert isclose(kdes, 8.33e-3, rtol=1e-2) diff --git a/tests/math/optimization/__init__.py b/tests/math/optimization/__init__.py new file mode 100644 index 00000000..7ae51940 --- /dev/null +++ b/tests/math/optimization/__init__.py @@ -0,0 +1,3 @@ +# PolyKin: A polymerization kinetics library for Python. +# +# Copyright Hugo Vale 2026 diff --git a/tests/math/optimization/_tester.py b/tests/math/optimization/_tester.py new file mode 100644 index 00000000..1dc366dc --- /dev/null +++ b/tests/math/optimization/_tester.py @@ -0,0 +1,95 @@ +"""Test functions commonly used in optimization benchmarks, with their gradients and +Hessians. +""" + +import numpy as np + + +def rosenbrock_grad(x): + g = np.zeros_like(x) + g[:-1] += -400.0 * x[:-1] * (x[1:] - x[:-1] ** 2) - 2.0 * (1 - x[:-1]) + g[1:] += 200.0 * (x[1:] - x[:-1] ** 2) + return g + + +def rosenbrock_hess(x): + n = len(x) + H = np.zeros((n, n)) + # Diagonal elements + H[np.arange(n - 1), np.arange(n - 1)] += -400.0 * (x[1:] - 3 * x[:-1] ** 2) + 2.0 + H[np.arange(1, n), np.arange(1, n)] += 200.0 + # Off-diagonal elements + H[np.arange(n - 1), np.arange(1, n)] = -400.0 * x[:-1] + H[np.arange(1, n), np.arange(n - 1)] = -400.0 * x[:-1] + return H + + +def ellipsoid_coeffs(x): + # Safe division to handle n=1 edge case + n = len(x) + denom = n - 1 if n > 1 else 1 + return (10**6) ** (np.arange(n) / denom) + + +def zakharov_u(x): + # 0.5 * sum(i * x_i), using 1-based indexing for the coefficient + return np.sum(0.5 * (np.arange(len(x)) + 1) * x) + + +def zakharov_grad(x): + u = zakharov_u(x) + scale = 0.5 * (np.arange(len(x)) + 1) + return 2.0 * x + (2.0 * u + 4.0 * u**3) * scale + + +def zakharov_hess(x): + n = len(x) + u = zakharov_u(x) + scale = 0.5 * (np.arange(n) + 1) + return 2.0 * np.eye(n) + (2.0 + 12.0 * u**2) * np.outer(scale, scale) + + +TEST_FUNCTIONS_MULTIVAR = { + "sphere": { + "function": lambda x: np.sum(x**2), + "gradient": lambda x: 2.0 * x, + "hessian": lambda x: 2.0 * np.eye(len(x)), + "global_minimum": 0.0, + "global_minimizer": lambda n: np.zeros(n), + # Simple start to verify basic algorithm correctness + "initial_point": lambda n: np.full(n, 5.0), + "properties": ["convex", "well-conditioned", "separable"], + }, + "ellipsoid": { + "function": lambda x: np.sum(ellipsoid_coeffs(x) * x**2), + "gradient": lambda x: 2.0 * ellipsoid_coeffs(x) * x, + "hessian": lambda x: np.diag(2.0 * ellipsoid_coeffs(x)), + "global_minimum": 0.0, + "global_minimizer": lambda n: np.zeros(n), + # asymmetric start → exposes conditioning issues + "initial_point": lambda n: np.linspace(1.0, 2.0, n), + "properties": ["ill-conditioned", "convex"], + }, + "rosenbrock": { + "function": lambda x: np.sum( + 100.0 * (x[1:] - x[:-1] ** 2) ** 2 + (1 - x[:-1]) ** 2 + ), + "gradient": rosenbrock_grad, + "hessian": rosenbrock_hess, + "global_minimum": 0.0, + "global_minimizer": lambda n: np.ones(n), + # classic challenging but not extreme start + "initial_point": lambda n: np.full(n, -1.2), + "properties": ["valley", "non-convex"], + }, + "zakharov": { + "function": lambda x: np.sum(x**2) + zakharov_u(x) ** 2 + zakharov_u(x) ** 4, + "gradient": zakharov_grad, + "hessian": zakharov_hess, + "global_minimum": 0.0, + "global_minimizer": lambda n: np.zeros(n), + # Initial point recommended by standard benchmark literature + "initial_point": lambda n: np.full(n, 1.5), + "properties": ["convex", "steep-walls"], + }, +} diff --git a/tests/math/optimization/test_brent.py b/tests/math/optimization/test_brent.py new file mode 100644 index 00000000..6a6bdfc8 --- /dev/null +++ b/tests/math/optimization/test_brent.py @@ -0,0 +1,91 @@ +# PolyKin: A polymerization kinetics library for Python. +# +# Copyright Hugo Vale 2026 + +import numpy as np +from numpy import isclose + +from polykin.math.optimization import fmin_brent + +TEST_FUNCTIONS = { + "quadratic": { + "f": lambda x: (x - 2.0) ** 2, + "xa": -5.0, + "xb": 5.0, + "xmin": 2.0, + "fmin": 0.0, + }, + "scaled_quadratic": { + "f": lambda x: 1e6 * (x - 1e-3) ** 2, + "xa": -1.0, + "xb": 1.0, + "xmin": 1e-3, + "fmin": 0.0, + }, + "quartic_flat": { + "f": lambda x: (x - 1.0) ** 4, + "xa": -2.0, + "xb": 3.0, + "xmin": 1.0, + "fmin": 0.0, + }, + "absolute_value": { + "f": lambda x: abs(x - 0.5), + "xa": -1.0, + "xb": 2.0, + "xmin": 0.5, + "fmin": 0.0, + }, + "multi_minima": { + "f": lambda x: np.sin(5 * x) + (x - 1) ** 2, + "xa": -2.0, + "xb": 3.0, + "xmin": 0.9467389984, + "fmin": -0.996, # approximate + }, + "degenerate_parabola": { + "f": lambda x: (x - 1) ** 2 + 1e-12 * x, + "xa": 0.0, + "xb": 2.0, + "xmin": 1.0 - 5e-13, # exact minimizer ≈ 1 - ε/2 + "fmin": 1e-12 * (1.0 - 5e-13), + }, + "sharp_minimum": { + "f": lambda x: np.exp(50 * (x - 0.3) ** 2), + "xa": 0.0, + "xb": 1.0, + "xmin": 0.3, + "fmin": 1.0, + }, + "boundary_minimum": { + "f": lambda x: (x + 2) ** 2, + "xa": -2.0, + "xb": 5.0, + "xmin": -2.0, + "fmin": 0.0, + }, +} + + +def callback(niter, x, fx): + print(f"Current point: x={x}, f(x)={fx}, iteration {niter}") + return (niter >= 5, True) + + +def test_fmin_brent(): + for name, data in TEST_FUNCTIONS.items(): + f = data["f"] + xa = data["xa"] + xb = data["xb"] + tolx = 1e-6 + res = fmin_brent(f, xa, xb, tolx=tolx) + + assert res.success, f"Optimization failed for {name}: {res.message}" + assert isclose(res.x, data["xmin"], atol=2 * tolx), ( + f"Incorrect minimum for {name}: x={res.x}, f(x)={res.f}" + ) + # with callback + res = fmin_brent(f, xa, xb, tolx=tolx, callback=callback) + assert "callback" in res.message.lower() + assert res.success + assert res.niter == 5 diff --git a/tests/math/optimization/test_qnewton.py b/tests/math/optimization/test_qnewton.py new file mode 100644 index 00000000..ab3a1804 --- /dev/null +++ b/tests/math/optimization/test_qnewton.py @@ -0,0 +1,111 @@ +# PolyKin: A polymerization kinetics library for Python. +# +# Copyright Hugo Vale 2026 + +import numpy as np +from numpy import allclose + +from polykin.math.optimization import fmin_qnewton + +from ._tester import TEST_FUNCTIONS_MULTIVAR + + +def test_fmin_qnewton_basic(): + ATOL = 1e-5 + for fname in ["sphere", "ellipsoid"]: + test = TEST_FUNCTIONS_MULTIVAR[fname] + f = test["function"] + grad = test["gradient"] + hess = test["hessian"] + + for N in [2, 3, 5, 10]: + x0 = test["initial_point"](N) + xopt = test["global_minimizer"](N) + for global_method in [None, "line-search", "dogleg"]: + if global_method is None and N > 3: + continue + for bfgs_update in [None, False, True]: + for bfgs_method in [None, "factored", "unfactored", "inverse"]: + for hess0 in [None, np.eye(N)]: + # No derivative information + res = fmin_qnewton( + f, + x0, + global_method=global_method, + bfgs_update=bfgs_update, + bfgs_method=bfgs_method, + H0=hess0, + ) + assert allclose(res.x, xopt, atol=ATOL) + # With gradient + res = fmin_qnewton( + f, + x0, + global_method=global_method, + bfgs_update=bfgs_update, + bfgs_method=bfgs_method, + H0=hess0, + grad=grad, + ) + assert allclose(res.x, xopt, atol=ATOL) + # With gradient and hessian + res = fmin_qnewton( + f, + x0, + global_method=global_method, + bfgs_update=bfgs_update, + bfgs_method=bfgs_method, + H0=hess0, + grad=grad, + hess=hess, + ) + assert allclose(res.x, xopt, atol=ATOL) + + +def test_fmin_qnewton_advanced(): + ATOL = 1e-5 + for fname in ["zakharov"]: + test = TEST_FUNCTIONS_MULTIVAR[fname] + f = test["function"] + grad = test["gradient"] + hess = test["hessian"] + for N in [2, 3, 5]: + x0 = test["initial_point"](N) + xopt = test["global_minimizer"](N) + for global_method in ["line-search", "dogleg"]: + for bfgs_update in [None, False, True]: + for bfgs_method in [None, "factored", "unfactored", "inverse"]: + for hess0 in [None, np.eye(N)]: + # No derivative information + res = fmin_qnewton( + f, + x0, + global_method=global_method, + bfgs_update=bfgs_update, + bfgs_method=bfgs_method, + H0=hess0, + ) + assert allclose(res.x, xopt, atol=ATOL) + # With gradient + res = fmin_qnewton( + f, + x0, + global_method=global_method, + bfgs_update=bfgs_update, + bfgs_method=bfgs_method, + H0=hess0, + grad=grad, + ) + assert allclose(res.x, xopt, atol=ATOL) + # With gradient and hessian + res = fmin_qnewton( + f, + x0, + global_method=global_method, + bfgs_update=bfgs_update, + bfgs_method=bfgs_method, + H0=hess0, + grad=grad, + hess=hess, + ) + assert allclose(res.x, xopt, atol=ATOL) diff --git a/tests/math/optimization/test_secant.py b/tests/math/optimization/test_secant.py new file mode 100644 index 00000000..aba5b9c3 --- /dev/null +++ b/tests/math/optimization/test_secant.py @@ -0,0 +1,100 @@ +# PolyKin: A polymerization kinetics library for Python. +# +# Copyright Hugo Vale 2026 + +import numpy as np +from numpy import isclose + +from polykin.math.optimization import fmin_secant + +TEST_FUNCTIONS = { + "quadratic": { + "f": lambda x: (x - 2.0) ** 2, + "x0": 0.0, + "xmin": 2.0, + "fmin": 0.0, + }, + "scaled_quadratic": { + "f": lambda x: 1e6 * (x - 1e-3) ** 2, + "x0": -1.0, + "xmin": 1e-3, + "fmin": 0.0, + }, + "shifted_parabola": { + "f": lambda x: 3.0 * (x + 0.7) ** 2 + 2.0, + "x0": -3.0, + "xmin": -0.7, + "fmin": 2.0, + }, + "anisotropic_scaling": { + "f": lambda x: 1e3 * (x - 0.25) ** 2 + 1e-6, + "x0": -1.0, + "xmin": 0.25, + "fmin": 1e-6, + }, + "mildly_skewed_quadratic": { + "f": lambda x: (x - 1.0) ** 2 + 0.05 * x, + "x0": -2.0, + "xmin": 0.975, # shifted minimum + "fmin": None, + }, + "narrow_convex_basin": { + "f": lambda x: np.exp(20 * (x - 0.4) ** 2), + "x0": 0.0, + "xmin": 0.4, + "fmin": 1.0, + }, +} + + +def noisy_quadratic(x, ndigit=4): + """Add noise specifically to the n-th decimal digit.""" + random_digit = np.random.randint(0, 10) + noise = random_digit * (10**-ndigit) + return (x - 1.0) ** 2 + noise + + +SUCCESS_ON_CALLBACK = False +NITER_ON_CALLBACK = 1 + + +def callback(niter, x, fx, dfx): + print(f"Current point: x={x}, f(x)={fx}, df(x)={dfx}, iteration {niter}") + return (niter >= NITER_ON_CALLBACK, SUCCESS_ON_CALLBACK) + + +def test_fmin_secant(): + for name, data in TEST_FUNCTIONS.items(): + for diff_scheme in ["centered", "complex"]: + f = data["f"] + x0 = data["x0"] + xb = x0 + 0.01 + tolx = 1e-8 + res = fmin_secant(f, x0, xb, tolx=tolx, diff_scheme=diff_scheme) + + assert res.success, f"Optimization failed for {name}: {res.message}" + assert isclose(res.x, data["xmin"], atol=2 * tolx), ( + f"Incorrect minimum for {name}: x={res.x}, f(x)={res.f}" + ) + # with callback + res = fmin_secant(f, x0, xb, tolx=tolx, callback=callback) + assert "callback" in res.message.lower() + assert res.success == SUCCESS_ON_CALLBACK + assert res.niter == NITER_ON_CALLBACK + + +def test_fmin_secant_with_noise(): + ndigit = 6 + epsf = 10 ** (-ndigit) + tolx = epsf ** (2 / 3) + tolg = 1e-4 * epsf ** (1 / 3) # force termination based on tolx rather than tolg + sol = fmin_secant( + lambda x: noisy_quadratic(x, ndigit), + 0.0, + 0.01, + tolx=tolx, + tolg=tolg, + epsf=epsf, + ) + assert sol.success + assert isclose(sol.x, 1.0, atol=10 * tolx) diff --git a/tests/math/optimization/test_simplex.py b/tests/math/optimization/test_simplex.py new file mode 100644 index 00000000..e89ea1a8 --- /dev/null +++ b/tests/math/optimization/test_simplex.py @@ -0,0 +1,34 @@ +# PolyKin: A polymerization kinetics library for Python. +# +# Copyright Hugo Vale 2026 + +from numpy import isclose + +from polykin.math.optimization import fmin_nelder_mead + +from ._tester import TEST_FUNCTIONS_MULTIVAR + + +def test_fmin_nelder_mead(): + for name, data in TEST_FUNCTIONS_MULTIVAR.items(): + N = 2 # test in 2D for simplicity, but should work in any dimension + f = data["function"] + x0 = data["initial_point"](N) + tolx = 1e-6 + res = fmin_nelder_mead(f, x0, tolx=tolx) + + assert res.success, f"Optimization failed for {name}: {res.message}" + assert isclose(res.f, data["global_minimum"], atol=2 * tolx), ( + f"Incorrect minimum for {name}: x={res.x}, f(x)={res.f}" + ) + + # with callback + res = fmin_nelder_mead( + f, + x0, + tolx=tolx, + callback=lambda niter, x, fx: (niter >= 3, True), + ) + assert res.success + assert "callback" in res.message + assert res.niter == 3 diff --git a/tests/math/test_derivatives.py b/tests/math/test_derivatives.py index 413c6c22..3d71af7f 100644 --- a/tests/math/test_derivatives.py +++ b/tests/math/test_derivatives.py @@ -8,6 +8,7 @@ from polykin.math import ( derivative_centered, derivative_complex, + gradient_forward, hessian2_centered, hessian_forward, jacobian_forward, @@ -56,7 +57,7 @@ def test_hessian2_centered(): np.array([[2 * x1**3, 6 * x0 * x1**2], [6 * x0 * x1**2, 6 * x1 * x0**2]]), rtol=1e-6, ) - H = hessian2_centered(fnc2, (x0, x1), h=1e-2) + H = hessian2_centered(fnc2, (x0, x1), epsf=1e-6) assert allclose( H, np.array([[2 * x1**3, 6 * x0 * x1**2], [6 * x0 * x1**2, 6 * x1 * x0**2]]), @@ -64,6 +65,12 @@ def test_hessian2_centered(): ) +def test_gradient_forward(): + x = np.array([3.0, -2.0]) + grad = gradient_forward(fnc2, x) + assert allclose(grad, [2 * x[0] * x[1] ** 3, 3 * (x[0] ** 2) * x[1] ** 2], rtol=1e-6) + + def test_jacobian_forward(): x = np.array([3.0, -2.0]) J = jacobian_forward(fnc3, x) diff --git a/tests/math/test_fixpoint.py b/tests/math/test_fixpoint.py index 66f86ded..928e030a 100644 --- a/tests/math/test_fixpoint.py +++ b/tests/math/test_fixpoint.py @@ -3,61 +3,168 @@ # Copyright Hugo Vale 2024 import numpy as np -from numpy import allclose +from numpy import allclose, isclose -from polykin.math.fixpoint import fixpoint_anderson, fixpoint_wegstein +from polykin.math.fixpoint import ( + fixpoint_anderson, + fixpoint_damped, + fixpoint_dem, + fixpoint_steffensen, + fixpoint_wegstein, +) -def g(x): +def g_vector(x): """Test for vector fixed-point solution methods.""" x1, x2 = x return np.array([0.5 * np.cos(x1) + 0.1 * x2 + 0.5, np.sin(x2) - 0.2 * x1 + 1.2]) -g.xs = np.array([0.97458605, 1.93830731]) +G_VECTOR_XS = np.array([0.97458605, 1.93830731]) + + +def g_scalar(x): + """Test for scalar fixed-point solution methods.""" + return np.cos(x) + + +G_SCALAR_XS = 0.7390851332151607 + +SUCCESS_ON_CALLBACK = False +NITER_ON_CALLBACK = 2 + + +def callback(niter, x, fx): + print(f"Iteration {niter}: x={x}, f(x)={fx}") + return (niter >= NITER_ON_CALLBACK, SUCCESS_ON_CALLBACK) def test_fixpoint_anderson(): # stop tolx tolx = 1e-13 for m in range(1, 5): - sol = fixpoint_anderson(g, np.array([0.0, 0.0]), m=m, tolx=tolx) + sol = fixpoint_anderson(g_vector, np.array([0.0, 0.0]), m=m, tolx=tolx) assert sol.success assert "tolx" in sol.message - assert allclose(sol.x, g.xs, atol=tolx) - assert allclose(sol.f, g(sol.x) - sol.x) + assert allclose(sol.x, G_VECTOR_XS, atol=tolx) + assert allclose(sol.f, g_vector(sol.x) - sol.x) # stop maxiter maxiter = 3 - sol = fixpoint_anderson(g, np.array([0.0, 0.0]), maxiter=maxiter) + sol = fixpoint_anderson(g_vector, np.array([0.0, 0.0]), maxiter=maxiter) assert not sol.success assert "iterations" in sol.message assert sol.niter == maxiter - assert allclose(sol.f, g(sol.x) - sol.x) - # initial guess close to solution - sol = fixpoint_anderson(g, g.xs) - assert sol.success - assert sol.niter == 0 + assert allclose(sol.f, g_vector(sol.x) - sol.x) + # with callback + sol = fixpoint_anderson(g_vector, np.array([0.0, 0.0]), m=2, callback=callback) + assert "callback" in sol.message + assert sol.success == SUCCESS_ON_CALLBACK + assert sol.niter == NITER_ON_CALLBACK def test_fixpoint_wegstein(): # stop tolx, normal - tolx = 1e-8 - sol = fixpoint_wegstein(g, np.array([0.0, 0.0]), qmax=0.5, tolx=tolx) + TOLX = 1e-8 + sol = fixpoint_wegstein(g_vector, np.array([0.0, 0.0]), qmax=0.5, tolx=TOLX) assert sol.success assert "tolx" in sol.message - assert allclose(sol.x, g.xs, atol=tolx) - assert allclose(sol.f, g(sol.x) - sol.x) + assert allclose(sol.x, G_VECTOR_XS, atol=TOLX) + assert allclose(sol.f, g_vector(sol.x) - sol.x) # stop tolx, no acceleration + sol = fixpoint_wegstein(g_vector, np.array([0.0, 0.0]), wait=100, tolx=TOLX) + assert sol.success + assert "tolx" in sol.message + assert allclose(sol.x, G_VECTOR_XS, atol=TOLX) + assert allclose(sol.f, g_vector(sol.x) - sol.x) + # stop maxiter + maxiter = 3 + sol = fixpoint_wegstein(g_vector, np.array([0.0, 0.0]), maxiter=maxiter) + assert not sol.success + assert "iterations" in sol.message + assert sol.niter == maxiter + assert allclose(sol.f, g_vector(sol.x) - sol.x) + # consistency with fixpoint_damped + q = 0 + sol_wegstein = fixpoint_wegstein( + g_vector, np.array([0.0, 0.0]), qmin=q, qmax=q, tolx=TOLX + ) + sol_damped = fixpoint_damped(g_vector, np.array([0.0, 0.0]), q=q, tolx=TOLX) + assert allclose(sol_wegstein.x, sol_damped.x, atol=TOLX) + assert allclose(sol_wegstein.f, sol_damped.f, atol=TOLX) + assert sol_wegstein.niter == sol_damped.niter + # with callback + sol = fixpoint_wegstein(g_vector, np.array([0.0, 0.0]), callback=callback) + assert "callback" in sol.message + assert sol.success == SUCCESS_ON_CALLBACK + assert sol.niter == NITER_ON_CALLBACK + + +def test_fixpoint_damped(): + # stop tolx tolx = 1e-8 - sol = fixpoint_wegstein(g, np.array([0.0, 0.0]), wait=100, tolx=tolx) + sol = fixpoint_damped(g_vector, np.array([0.0, 0.0]), q=0.2, tolx=tolx) assert sol.success assert "tolx" in sol.message - assert allclose(sol.x, g.xs, atol=tolx) - assert allclose(sol.f, g(sol.x) - sol.x) + assert allclose(sol.x, G_VECTOR_XS, atol=tolx) + assert allclose(sol.f, g_vector(sol.x) - sol.x) # stop maxiter maxiter = 3 - sol = fixpoint_wegstein(g, np.array([0.0, 0.0]), maxiter=maxiter) + sol = fixpoint_damped(g_vector, np.array([0.0, 0.0]), maxiter=maxiter) assert not sol.success assert "iterations" in sol.message assert sol.niter == maxiter - assert allclose(sol.f, g(sol.x) - sol.x) + assert allclose(sol.f, g_vector(sol.x) - sol.x) + # with callback + sol = fixpoint_damped(g_vector, np.array([0.0, 0.0]), callback=callback) + assert "callback" in sol.message + assert sol.success == SUCCESS_ON_CALLBACK + assert sol.niter == NITER_ON_CALLBACK + + +def test_fixpoint_dem(): + # stop tolx + tolx = 1e-8 + sol = fixpoint_dem(g_vector, np.array([0.0, 0.0]), q=0.2, tolx=tolx) + assert sol.success + assert "tolx" in sol.message + assert allclose(sol.x, G_VECTOR_XS, atol=tolx) + assert allclose(sol.f, g_vector(sol.x) - sol.x) + # stop maxiter + maxiter = 3 + sol = fixpoint_dem(g_vector, np.array([0.0, 0.0]), maxiter=maxiter) + assert not sol.success + assert "iterations" in sol.message + assert sol.niter == maxiter + assert allclose(sol.f, g_vector(sol.x) - sol.x) + # with callback + sol = fixpoint_dem(g_vector, np.array([0.0, 0.0]), callback=callback) + assert "callback" in sol.message + assert sol.success == SUCCESS_ON_CALLBACK + assert sol.niter == NITER_ON_CALLBACK + + +def test_fixpoint_steffensen(): + tolx = 1e-10 + sol = fixpoint_steffensen(g_scalar, 0.5, tolx=tolx) + assert sol.success + assert "tolx" in sol.message + assert isclose(sol.x, G_SCALAR_XS, atol=tolx) + assert isclose(sol.f, g_scalar(sol.x) - sol.x, atol=tolx) + # stop maxiter + maxiter = 1 + sol = fixpoint_steffensen(g_scalar, 0.5, maxiter=maxiter) + assert not sol.success + assert "iterations" in sol.message + assert sol.niter == maxiter + assert isclose(sol.f, g_scalar(sol.x) - sol.x, atol=tolx) + # test denominator zero + sol = fixpoint_steffensen(lambda x: x + 1.0, 0.0) + assert not sol.success + assert "denominator" in sol.message + assert sol.niter == 1 + assert allclose(sol.f, 1.0) + # with callback + sol = fixpoint_steffensen(g_scalar, 0.5, tolx=tolx, callback=callback) + assert "callback" in sol.message + assert sol.success == SUCCESS_ON_CALLBACK + assert sol.niter == NITER_ON_CALLBACK diff --git a/tests/math/test_roots.py b/tests/math/test_roots.py index a959a6b0..03cadc68 100644 --- a/tests/math/test_roots.py +++ b/tests/math/test_roots.py @@ -14,7 +14,7 @@ def f1(x): return 2 * x**3 + 4 * x**2 + x - 2 -f1.sol = min(np.roots((2, 4, 1, -2)), key=lambda x: abs(x - 0.5)) +f1_sol = min(np.roots((2, 4, 1, -2)), key=lambda x: abs(x - 0.5)) def f2(x): @@ -22,7 +22,15 @@ def f2(x): return np.exp(x - 1) * (x - 1) ** 2 -f2.sol = 1.0 +f2_sol = 1.0 + +SUCCESS_ON_CALLBACK = False +NITER_ON_CALLBACK = 2 + + +def callback(niter, x, fx): + print(f"Iteration {niter}: x={x}, f(x)={fx}") + return (niter >= NITER_ON_CALLBACK, SUCCESS_ON_CALLBACK) def test_root_newton(): @@ -31,7 +39,7 @@ def test_root_newton(): res = root_newton(f1, 1.5, tolx=tolx, tolf=0.0) assert res.success assert "tolx" in res.message - assert isclose(res.x, f1.sol, atol=tolx) + assert isclose(res.x, f1_sol, atol=tolx) assert isclose(res.f, f1(res.x)) assert res.nfeval == res.niter # stop tolf @@ -51,11 +59,16 @@ def test_root_newton(): # nasty test res = root_newton(f2, 0.5, tolx=1e-10, tolf=1e-10) assert res.success - assert isclose(res.x, f2.sol, atol=1e-10) + assert isclose(res.x, f2_sol, atol=1e-10) # devirative is zero at the root res = root_newton(f2, 0.0, tolx=0, tolf=0, maxiter=100) assert not res.success assert "derivative" in res.message + # with callback + res = root_newton(f1, 1.5, callback=callback) + assert res.success == SUCCESS_ON_CALLBACK + assert "callback" in res.message + assert res.niter == NITER_ON_CALLBACK def test_root_secant(): @@ -64,7 +77,7 @@ def test_root_secant(): res = root_secant(f1, 1.5, 1.4, tolx=tolx, tolf=0.0) assert res.success assert "tolx" in res.message - assert isclose(res.x, f1.sol, atol=tolx) + assert isclose(res.x, f1_sol, atol=tolx) assert isclose(res.f, f1(res.x)) assert res.nfeval == res.niter + 2 # stop tolf @@ -84,11 +97,16 @@ def test_root_secant(): # nasty test res = root_secant(f2, 0.5, 0.6, tolx=1e-10, tolf=1e-10) assert res.success - assert isclose(res.x, f2.sol, atol=1e-10) + assert isclose(res.x, f2_sol, atol=1e-10) # derivative is zero at the root res = root_secant(f2, 0.0, 0.1, tolx=0, tolf=0, maxiter=100) assert not res.success assert "zero slope" in res.message + # with callback + res = root_secant(f1, 1.5, 1.4, callback=callback) + assert res.success == SUCCESS_ON_CALLBACK + assert "callback" in res.message + assert res.niter == NITER_ON_CALLBACK def test_root_brent(): @@ -97,7 +115,7 @@ def test_root_brent(): res = root_brent(f1, 0.1, 1.0, tolx=tolx, tolf=0.0) assert res.success assert "tolx" in res.message - assert isclose(res.x, f1.sol, atol=tolx) + assert isclose(res.x, f1_sol, atol=tolx) assert isclose(res.f, f1(res.x)) # stop tolf tolf = 1e-10 @@ -114,13 +132,18 @@ def test_root_brent(): assert res.niter == maxiter assert isclose(res.f, f1(res.x)) # a is solution - res = root_brent(f1, f1.sol, 1.0) + res = root_brent(f1, f1_sol, 1.0) assert res.success assert res.niter == 0 # b is solution - res = root_brent(f1, 0.0, f1.sol) + res = root_brent(f1, 0.0, f1_sol) assert res.success assert res.niter == 0 + # with callback + res = root_brent(f1, 0.1, 1.0, callback=callback) + assert res.success == SUCCESS_ON_CALLBACK + assert "callback" in res.message + assert res.niter == NITER_ON_CALLBACK # root not bracketed with pytest.raises(ValueError): _ = root_brent(f1, 0.1, 0.2) diff --git a/tests/math/test_rootvec.py b/tests/math/test_rootvec.py index 3b7f32cf..1b098a0f 100644 --- a/tests/math/test_rootvec.py +++ b/tests/math/test_rootvec.py @@ -69,7 +69,7 @@ def f_case10(x): def f_example65(x): - """Example 6.5. Dennis & Schnabel (1996).""" + """Example 6.5 of Dennis & Schnabel (1996).""" x1, x2 = x f1 = x1**2 + x2**2 - 2 f2 = np.exp(x1 - 1) + x2**3 - 2 @@ -114,14 +114,16 @@ def test_rootvec_qnewton(): # Easy ones also work with approximate jac0 and Broyden update f = f_example65 - sol = rootvec_qnewton(f, f.x0, broyden_update=True, jac0=np.eye(f.x0.size)) + sol = rootvec_qnewton(f, f.x0, broyden_update=True, J0=np.eye(f.x0.size)) assert sol.success # With analytic jacobian f = f_example65 jac = jac_example65 for broyden_update in [False, True]: - sol = rootvec_qnewton(f, f.x0, jac=jac, broyden_update=broyden_update) + sol = rootvec_qnewton( + f, f.x0, jac=jac, jac_check=True, broyden_update=broyden_update + ) assert sol.success assert allclose(sol.x, f.xs) diff --git a/tests/math/test_special.py b/tests/math/test_special.py index 5b712a1d..a0b6a275 100644 --- a/tests/math/test_special.py +++ b/tests/math/test_special.py @@ -4,8 +4,8 @@ from numpy import inf, isclose, pi +from polykin.math.machine import huge from polykin.math.special import i2erfc, ierfc, roots_xcotx, roots_xtanx -from polykin.utils.math import huge def test_ierfc(): @@ -29,21 +29,13 @@ def test_roots_xtanx(): x = roots_xtanx(0, 4) assert all(isclose(x, [pi * i for i in range(len(x))])) x = roots_xtanx(0.01, 6) - assert all( - isclose(x, [0.0998, 3.1448, 6.2848, 9.4258, 12.5672, 15.7086], atol=1e-4) - ) + assert all(isclose(x, [0.0998, 3.1448, 6.2848, 9.4258, 12.5672, 15.7086], atol=1e-4)) x = roots_xtanx(1, 6) - assert all( - isclose(x, [0.8603, 3.4256, 6.4373, 9.5293, 12.6453, 15.7713], atol=1e-4) - ) + assert all(isclose(x, [0.8603, 3.4256, 6.4373, 9.5293, 12.6453, 15.7713], atol=1e-4)) x = roots_xtanx(1e2, 6) - assert all( - isclose(x, [1.5552, 4.6658, 7.7764, 10.8871, 13.9981, 17.1093], atol=1e-4) - ) + assert all(isclose(x, [1.5552, 4.6658, 7.7764, 10.8871, 13.9981, 17.1093], atol=1e-4)) x = roots_xtanx(1e5, 6) - assert all( - isclose(x, [1.5708, 4.7124, 7.8540, 10.9956, 14.1372, 17.2788], atol=1e-4) - ) + assert all(isclose(x, [1.5708, 4.7124, 7.8540, 10.9956, 14.1372, 17.2788], atol=1e-4)) def test_roots_xcotx(): @@ -52,14 +44,8 @@ def test_roots_xcotx(): x = roots_xcotx(inf, 6) assert all(isclose(x, [pi * (i + 1) for i in range(len(x))])) x = roots_xcotx(0.01, 6) - assert all( - isclose(x, [0.1730, 4.4956, 7.7265, 10.9050, 14.0669, 17.2213], atol=1e-4) - ) + assert all(isclose(x, [0.1730, 4.4956, 7.7265, 10.9050, 14.0669, 17.2213], atol=1e-4)) x = roots_xcotx(2.0, 6) - assert all( - isclose(x, [2.0288, 4.9132, 7.9787, 11.0856, 14.2075, 17.3364], atol=1e-4) - ) + assert all(isclose(x, [2.0288, 4.9132, 7.9787, 11.0856, 14.2075, 17.3364], atol=1e-4)) x = roots_xcotx(1e2, 6) - assert all( - isclose(x, [3.1102, 6.2204, 9.3309, 12.4414, 15.5522, 18.6633], atol=1e-4) - ) + assert all(isclose(x, [3.1102, 6.2204, 9.3309, 12.4414, 15.5522, 18.6633], atol=1e-4))