From 1c8fafb6389ffe768bbd73bf28a4f77b6304d2e0 Mon Sep 17 00:00:00 2001 From: Siva Dasetty Date: Wed, 13 Jul 2022 16:12:57 -0500 Subject: [PATCH 1/9] SD: crude state --- pysages/colvars/__init__.py | 4 + pysages/colvars/ann.py | 172 ++++++++++++++++++++++++++++++++++++ pysages/colvars/utils.py | 36 ++++++++ 3 files changed, 212 insertions(+) create mode 100644 pysages/colvars/ann.py diff --git a/pysages/colvars/__init__.py b/pysages/colvars/__init__.py index 565ee669..ed5c5af4 100644 --- a/pysages/colvars/__init__.py +++ b/pysages/colvars/__init__.py @@ -29,6 +29,10 @@ Distance, ) +from .ann import ( + PIV +) + from .utils import ( get_periods, wrap, diff --git a/pysages/colvars/ann.py b/pysages/colvars/ann.py new file mode 100644 index 00000000..3493691e --- /dev/null +++ b/pysages/colvars/ann.py @@ -0,0 +1,172 @@ +# SPDX-License-Identifier: MIT +# Copyright (c) 2020-2021: PySAGES contributors +# See LICENSE.md and CONTRIBUTORS.md at https://github.com/SSAGESLabs/PySAGES + +""" +Artificial neural network based collective variables +""" + +from jax import numpy as np, vmap +from pysages.colvars.core import CollectiveVariable +from pysages.colvars import coordinates +from pysages.colvars.utils import rational_switching_function +import numpy as onp + +class PIV(CollectiveVariable): + """ + Permutation Invariant Vector (PIV) of a given system of points in space. + + PIV collective variable is generated using the user-defined set of points in space. + Reference to the points is provided as a list of lists containing indices of + unique atom types. PIV is constructed by first computing the unique pairwise distances + between the indices across all the combinations of lists except those specifically + excluded by user. The generated pairwise distances in each cross-pair + list are referred as a block and are wrapped by a switching function. + The values in each block are then sorted. Finally, PIV is + returned as a single vector by catenating all blocks. + + + Parameters + ---------- + indices: ``list`` of ``lists`` + List of lists containing indices of unique atom types. + exclude_indices: ``list`` + List of indices pairs referring index of lists to exclude + in PIV calculation. + switching_params: ``list`` + List of switching function parameters. It contains R_0, m and n values. + + Returns + ------- + piv: JaxArray + Permutation Invariant Vector (PIV) + """ + + def __init__(self, indices, position_pairs, solute_list, solvent_oxygen_list, + hydrogen_dict, switching_params, neighbor_list): + super().__init__(indices, group_length=None) + self.position_pairs = position_pairs + self.solute_list = solute_list + self.solvent_oxygen_list = solvent_oxygen_list + self.hydrogen_dict = hydrogen_dict + self.switching_params = switching_params + self.neighbor_list = neighbor_list['neighbor_list'] + + print("sol list") + print(solute_list) + print(solvent_oxygen_list) + print("end") + + @property + def function(self): + """ + Function generator + + Returns + ------- + Function that generates PIV from a simulation snapshot. + Look at `pysages.colvars.ann.piv` for details. + """ + return lambda *positions, neighbor_list=self.neighbor_list, params=self: piv(positions, neighbor_list, params) + + +def piv(positions, neighbor_list, params): + """ + Implementation of permutation invariant vector as described in + [Section 4, Handb. Mater. Model. 597-619 (2020)](https://doi.org/10.1007/978-3-319-44677-6_51). + + Parameters + ---------- + positions: A ``list`` of ``lists`` containing positions of all atoms and of each atomtype. + + params: A ``object`` containing all the helper parameters. This includes + indices combination to exclude from PIV calculation, switching function + parameters. + + Returns + ------- + piv : DeviceArray + Permutation Invariant Vector (PIV). + """ + + all_atom_positions = np.array(positions) + + neighbor_list = neighbor_list.update(all_atom_positions) + position_pairs = onp.array(params.position_pairs) + solute_list = params.solute_list + solvent_oxygen_list = params.solvent_oxygen_list + + print("solvent_oxygen_list") + print(solvent_oxygen_list) + print("end solvent_oxygen_list") + + hydrogen_dict = params.hydrogen_dict + + i_pos = all_atom_positions[position_pairs[:,1]] + j_pos = all_atom_positions[position_pairs[:,3]] + + piv_solute_blocks = vmap(get_piv_block, in_axes=(0, 0, None))(i_pos, j_pos, params.switching_params) + + # sort based ij combination + + + print(piv_solute_blocks) + + if solvent_oxygen_list: + + nsolute_types = len(solute_list) + # for each solute keep oxygen atoms that are their neighbors + solvent_i_j = [] + + solute_list_indices = list(np.arange(nsolute_types)) + + + for i in range(nsolute_types): + _solvent_i_j = [] + + for i_p in solute_list[i]: + + for j in neighbor_list.idx[i_p]: + + # check if j is the id of oxygen atom + if j in solvent_oxygen_list: + _solvent_i_j.append([i, i_p, j]) + _solvent_i_j.append([i, i_p, hydrogen_dict[int(j)][0]]) + _solvent_i_j.append([i, i_p, hydrogen_dict[int(j)][1]]) + + solvent_i_j.append(_solvent_i_j) + + solvent_i_j = onp.array(solvent_i_j) + i_pos = all_atom_positions[solvent_i_j[:,1]] + j_pos = all_atom_positions[solvent_i_j[:,2]] + + piv_solute_solvent_blocks = vmap(get_piv_block, in_axes=(0, 0, None))(i_pos, j_pos, params.switching_params) + + print("sol") + print(piv_solute_solvent_blocks) + print("end") + + print("\n") + + +def get_solute_atoms(solute_list, solute_list_index): + + return solute_list[solute_list_index] + +def get_neighbors_solute_atom(neigbor_list_solute, solute_atom_id): + + return neigbor_list_solute[solute_atom_id] + + +def get_piv_block(i_pos, j_pos, switching_params): + + r_0 = switching_params['r_0'] + d_0 = switching_params['d_0'] + n = switching_params['n'] + m = switching_params['m'] + + r = coordinates.distance(i_pos, j_pos) + s_r = rational_switching_function(r, r_0, d_0, n, m) + + return s_r + \ No newline at end of file diff --git a/pysages/colvars/utils.py b/pysages/colvars/utils.py index 95afbdd4..944b43bc 100644 --- a/pysages/colvars/utils.py +++ b/pysages/colvars/utils.py @@ -25,3 +25,39 @@ def wrap(x, P): Given a period `P`, wraps around `x` over the interval from `-P / 2` to `P / 2`. """ return np.where(np.isinf(P), x, x - (np.abs(x) > P / 2) * np.sign(x) * P) + + +def rational_switching_function(r, r_0, d_0=0.0, n=6, m=None): + """ + Rational switching function applied to a given variable r. It takes + four parameters r_0, d_0, n, and m. + + Parameters + ---------- + r: ``float`` + variable to which switching function is applied. + + r_0 : ``float`` + + d_0: ``float`` = 0.0 + + n: ``int`` = 6 + + m: ``int`` = 2*n + + Returns + ------- + s : ``float`` + Rational switching function applied to a given float. + """ + + if m == None: + m = 2*n + + s_common = (r - d_0)/r_0 + s_n = 1 - s_common**n + s_m = 1 - s_common**m + s = s_n/s_m + + return s + \ No newline at end of file From 0bdf6399b628e1e9fd82b1786c5c13c87afdfb4b Mon Sep 17 00:00:00 2001 From: Siva Dasetty Date: Wed, 13 Jul 2022 17:54:41 -0500 Subject: [PATCH 2/9] crude complete --- pysages/colvars/ann.py | 38 ++++++++++++++++++++++++++++---------- 1 file changed, 28 insertions(+), 10 deletions(-) diff --git a/pysages/colvars/ann.py b/pysages/colvars/ann.py index 3493691e..2b260f1b 100644 --- a/pysages/colvars/ann.py +++ b/pysages/colvars/ann.py @@ -106,12 +106,11 @@ def piv(positions, neighbor_list, params): j_pos = all_atom_positions[position_pairs[:,3]] piv_solute_blocks = vmap(get_piv_block, in_axes=(0, 0, None))(i_pos, j_pos, params.switching_params) + piv_solute_block_index = vmap(cantor_pair, in_axes=(0,0))(position_pairs[:,0], position_pairs[:,2]) - # sort based ij combination - - - print(piv_solute_blocks) - + idx_solute_sort = np.argsort(piv_solute_block_index) + piv_solute_blocks = piv_solute_blocks[idx_solute_sort] + if solvent_oxygen_list: nsolute_types = len(solute_list) @@ -141,12 +140,18 @@ def piv(positions, neighbor_list, params): j_pos = all_atom_positions[solvent_i_j[:,2]] piv_solute_solvent_blocks = vmap(get_piv_block, in_axes=(0, 0, None))(i_pos, j_pos, params.switching_params) + piv_solute_solvent_block_index = solvent_i_j[:,0] - print("sol") - print(piv_solute_solvent_blocks) - print("end") + idx_solvent_sort = np.argsort(piv_solute_block_index) + piv_solute_solvent_blocks = piv_solute_solvent_blocks[idx_solvent_sort] + + piv_blocks = np.concatenate( (piv_solute_blocks, piv_solute_solvent_blocks), axis=0) + + else: - print("\n") + piv_blocks = piv_solute_blocks + + return piv_blocks def get_solute_atoms(solute_list, solute_list_index): @@ -169,4 +174,17 @@ def get_piv_block(i_pos, j_pos, switching_params): s_r = rational_switching_function(r, r_0, d_0, n, m) return s_r - \ No newline at end of file + + +def cantor_pair(index1, index2): + """ + Generates an uniuqe integer using two integers via Cantor pair function. + This unique integer can be mapped back to the two integers, if needed. + """ + + pi = index1 + index2 + pi = pi * (pi + 1) + pi *= 0.5 + pi += index2 + + return np.int32(pi) \ No newline at end of file From 22edee1c9d0631fb57136463f6b35b6d1b9ff270 Mon Sep 17 00:00:00 2001 From: Siva Dasetty Date: Wed, 13 Jul 2022 18:01:02 -0500 Subject: [PATCH 3/9] crude complete - example --- .../Metadynamics-ADP-checkpoint.ipynb | 362 ++++++++++++++++++ .../alanine-dipeptide-checkpoint.py | 274 +++++++++++++ examples/openmm/pivcv/Metadynamics-ADP.ipynb | 362 ++++++++++++++++++ examples/openmm/pivcv/alanine-dipeptide.py | 274 +++++++++++++ 4 files changed, 1272 insertions(+) create mode 100644 examples/openmm/pivcv/.ipynb_checkpoints/Metadynamics-ADP-checkpoint.ipynb create mode 100644 examples/openmm/pivcv/.ipynb_checkpoints/alanine-dipeptide-checkpoint.py create mode 100644 examples/openmm/pivcv/Metadynamics-ADP.ipynb create mode 100644 examples/openmm/pivcv/alanine-dipeptide.py diff --git a/examples/openmm/pivcv/.ipynb_checkpoints/Metadynamics-ADP-checkpoint.ipynb b/examples/openmm/pivcv/.ipynb_checkpoints/Metadynamics-ADP-checkpoint.ipynb new file mode 100644 index 00000000..c8cab7d9 --- /dev/null +++ b/examples/openmm/pivcv/.ipynb_checkpoints/Metadynamics-ADP-checkpoint.ipynb @@ -0,0 +1,362 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "KBFVcG1FoeMq" + }, + "source": [ + "# Metadynamics-biased simulations" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "BBvC7Spoog82" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2022-06-29 11:39:38.911094: W external/org_tensorflow/tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /software/slurm-current-el7-x86_64/lib64:/software/slurm-current-el7-x86_64/lib:/software/gcc-7.2.0-el7-x86_64/lib64:/software/gcc-7.2.0-el7-x86_64/lib:/software/python-anaconda-2021.05-el7-x86_64/lib:/software/git-2.10-el7-x86_64/lib64:/software/subversion-1.9.4-el7-x86_64/lib:/software/serf-1.3.9-el7-x86_64/lib\n", + "2022-06-29 11:39:39.748220: W external/org_tensorflow/tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /software/slurm-current-el7-x86_64/lib64:/software/slurm-current-el7-x86_64/lib:/software/gcc-7.2.0-el7-x86_64/lib64:/software/gcc-7.2.0-el7-x86_64/lib:/software/python-anaconda-2021.05-el7-x86_64/lib:/software/git-2.10-el7-x86_64/lib64:/software/subversion-1.9.4-el7-x86_64/lib:/software/serf-1.3.9-el7-x86_64/lib\n", + "2022-06-29 11:39:39.829378: W external/org_tensorflow/tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /software/slurm-current-el7-x86_64/lib64:/software/slurm-current-el7-x86_64/lib:/software/gcc-7.2.0-el7-x86_64/lib64:/software/gcc-7.2.0-el7-x86_64/lib:/software/python-anaconda-2021.05-el7-x86_64/lib:/software/git-2.10-el7-x86_64/lib64:/software/subversion-1.9.4-el7-x86_64/lib:/software/serf-1.3.9-el7-x86_64/lib\n" + ] + } + ], + "source": [ + "import numpy\n", + "\n", + "from pysages.utils import try_import\n", + "\n", + "openmm = try_import(\"openmm\", \"simtk.openmm\")\n", + "unit = try_import(\"openmm.unit\", \"simtk.unit\")\n", + "app = try_import(\"openmm.app\", \"simtk.openmm.app\")\n", + "\n", + "\n", + "pi = numpy.pi\n", + "\n", + "T = 298.15 * unit.kelvin\n", + "dt = 2.0 * unit.femtoseconds\n", + "adp_pdb = \"../../inputs/alanine-dipeptide/adp-vacuum.pdb\"\n", + "\n", + "\n", + "def generate_simulation(pdb_filename=adp_pdb, T=T, dt=dt):\n", + " pdb = app.PDBFile(pdb_filename)\n", + "\n", + " ff = app.ForceField(\"amber99sb.xml\")\n", + " cutoff_distance = 1.0 * unit.nanometer\n", + " topology = pdb.topology\n", + "\n", + " system = ff.createSystem(\n", + " topology, constraints=app.HBonds, nonbondedMethod=app.PME, nonbondedCutoff=cutoff_distance\n", + " )\n", + "\n", + " # Set dispersion correction use.\n", + " forces = {}\n", + " for i in range(system.getNumForces()):\n", + " force = system.getForce(i)\n", + " forces[force.__class__.__name__] = force\n", + "\n", + " forces[\"NonbondedForce\"].setUseDispersionCorrection(True)\n", + " forces[\"NonbondedForce\"].setEwaldErrorTolerance(1.0e-5)\n", + "\n", + " positions = pdb.getPositions(asNumpy=True)\n", + "\n", + " integrator = openmm.LangevinIntegrator(T, 1 / unit.picosecond, dt)\n", + " integrator.setRandomNumberSeed(42)\n", + "\n", + " simulation = app.Simulation(topology, system, integrator)\n", + " simulation.context.setPositions(positions)\n", + " simulation.minimizeEnergy()\n", + "\n", + " return simulation" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3UrzENm_oo6U" + }, + "source": [ + "Next, we load PySAGES and the relevant classes and methods for our problem" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "fpMg-o8WomAA" + }, + "outputs": [], + "source": [ + "#from pysages.grids import Grid\n", + "from pysages.colvars import PIV\n", + "#from pysages.methods import Metadynamics\n", + "\n", + "import pysages" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LknkRvo1o4av" + }, + "source": [ + "The next step is to define the collective variable (CV). In this case, we choose the so called $\\phi$ and $\\psi$ dihedral angles of alanine dipeptide.\n", + "\n", + "For this example we will use the well-tempered version without grids. But these options can be configured.\n", + "\n", + "We set the initial height, standard deviation and deposition frequency `stride` for the gaussians, as well as the $\\Delta T$ Metadynamics parameter. And the number of time steps to run the simulation (here we use $9\\times10^6$ or 18 ns for the timestep chosen).\n", + "\n", + "We also define a grid, which can be used as optional parameter to accelerate Metadynamics by approximating the biasing potential and its gradient by the closest value at the centers of the grid cells.\n", + "\n", + "_Note:_ when setting $\\Delta T$ we need to also provide a value for $k_B$ that matches the internal units used by the backend." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "B1Z8FWz0o7u_" + }, + "outputs": [], + "source": [ + "cvs = [PIV( [[4, 6, 8, 14], [0, 1, 2]], [1], [2.3, 3, 6])]\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Fz8BfU34pA_N" + }, + "source": [ + "We now simulate the number of time steps set above.\n", + "Make sure to run with GPU support, otherwise, it can take a very long time.\n", + "On the GPU this should run in around half an hour." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "K951m4BbpUar" + }, + "outputs": [], + "source": [ + "state = pysages.run(method, generate_simulation, timesteps)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PXBKUfK0p9T2" + }, + "source": [ + "## Analysis\n", + "\n", + "Let's plot the negative of the sum of gaussians accumulated. This will get close to the free energy surface for long enough simulations (larger than what is practical to run on Colab, but we should get close enough for illustration purposes here)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "X69d1R7OpW4P" + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "from pysages.approxfun import compute_mesh" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6mrlIOfoszBJ" + }, + "source": [ + "We are now going to gather the information for the heights, standard deviations and centers of the accumulated gaussians and build a function to evaluate their sum at any point of the collective variable space." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "id": "zJqvpbw8szxR" + }, + "outputs": [], + "source": [ + "fe_result = pysages.analyze(run_result)\n", + "metapotential = fe_result['metapotential']" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VfTQ5yeyxt8e" + }, + "source": [ + "Next we use the biasing potential to estimate the free energy surface. For well-tempered metadynamics this is equal to the sum of accumulated gaussians scaled by the factor $-(T + \\Delta T)\\, / \\,\\Delta T$." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "id": "6W7Xf0ilqAcm" + }, + "outputs": [], + "source": [ + "plot_grid = pysages.Grid(lower=(-pi, -pi), upper=(pi, pi), shape=(64, 64), periodic=True)\n", + "xi = (compute_mesh(plot_grid) + 1) / 2 * plot_grid.size + plot_grid.lower\n", + "\n", + "alpha = 1 if method.deltaT is None else (T.value_in_unit(unit.kelvin) + method.deltaT) / method.deltaT\n", + "kT = kB * T.value_in_unit(unit.kelvin)\n", + "\n", + "A = metapotential(xi) * -alpha / kT\n", + "A = A - A.min()\n", + "A = A.reshape(plot_grid.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Kf_CMdih90Cd" + }, + "source": [ + "And plot it." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 461 + }, + "id": "3s9LL9apBMVb", + "outputId": "55abf4e5-fef0-4faa-bf01-9719cbe8aa2b" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(dpi=120)\n", + "\n", + "im = ax.imshow(\n", + " A, interpolation=\"bicubic\", origin=\"lower\", extent=[-pi, pi, -pi, pi]\n", + ")\n", + "ax.contour(\n", + " A, levels=12, linewidths=0.75, colors=\"k\", extent=[-pi, pi, -pi, pi]\n", + ")\n", + "ax.set_xlabel(r\"$\\phi$\")\n", + "ax.set_ylabel(r\"$\\psi$\")\n", + "\n", + "cbar = plt.colorbar(im)\n", + "cbar.ax.set_ylabel(r\"$A~[k_{B}T]$\", rotation=270, labelpad=20)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "a-LGmeZ_3_m-" + }, + "source": [ + "Lastly, we plot the height of the gaussians as a function of time and observe that their height decreases at an exponential rate as expected for well-tempered metadynamics." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 457 + }, + "id": "SI_fhUW9CGlP", + "outputId": "5d32f99d-4911-44bb-9d89-69c3e6212cb7" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "_dt = dt #method.context[0].sampler.snapshot.dt\n", + "ts = _dt * 1e-3 * numpy.arange(0, fe_result['heights'].size) * run_result.method.stride\n", + "\n", + "fig, ax = plt.subplots(dpi=120)\n", + "ax.plot(ts, fe_result['heights'], \"o\", mfc=\"none\", ms=4)\n", + "ax.set_xlabel(\"time [ns]\")\n", + "ax.set_ylabel(\"height [kJ/mol]\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "R6rEuwWAZ8Qp" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [], + "name": "ADP-Metadynamics.ipynb", + "provenance": [] + }, + "jupytext": { + "formats": "ipynb,md", + "main_language": "python" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/openmm/pivcv/.ipynb_checkpoints/alanine-dipeptide-checkpoint.py b/examples/openmm/pivcv/.ipynb_checkpoints/alanine-dipeptide-checkpoint.py new file mode 100644 index 00000000..17383dbb --- /dev/null +++ b/examples/openmm/pivcv/.ipynb_checkpoints/alanine-dipeptide-checkpoint.py @@ -0,0 +1,274 @@ +#!/usr/bin/env python3 + +""" +Metadynamics simulation of Alanine Dipeptide in vacuum with OpenMM and PySAGES. + +Example command to run the simulation `python3 alanine-dipeptide.py --time-steps 1000` +For other supported commandline parameters, check `python3 alanine-dipeptide.py --help` +""" + + +# %% +import argparse +import os +import sys +import time + +import numpy +import pysages + +from pysages.colvars import PIV +from pysages.methods import Metadynamics, MetaDLogger +from pysages.utils import try_import +from pysages.approxfun import compute_mesh + +import numpy as onp +from jax import numpy as np +from jax_md.partition import neighbor_list as nlist, space + +import matplotlib.pyplot as plt + +openmm = try_import("openmm", "simtk.openmm") +unit = try_import("openmm.unit", "simtk.unit") +app = try_import("openmm.app", "simtk.openmm.app") + + +# %% +pi = numpy.pi +kB = unit.BOLTZMANN_CONSTANT_kB * unit.AVOGADRO_CONSTANT_NA +kB = kB.value_in_unit(unit.kilojoules_per_mole / unit.kelvin) + +T = 298.15 * unit.kelvin +dt = 2.0 * unit.femtoseconds +adp_pdb = os.path.join(os.pardir, os.pardir, "inputs", "alanine-dipeptide", "adp-vacuum.pdb") + + +# %% +def generate_simulation(pdb_filename=adp_pdb, T=T, dt=dt): + pdb = app.PDBFile(pdb_filename) + + ff = app.ForceField("amber99sb.xml") #, "tip3p.xml") + cutoff_distance = 1.0 * unit.nanometer + topology = pdb.topology + + system = ff.createSystem( + topology, constraints=app.HBonds, nonbondedMethod=app.PME, nonbondedCutoff=cutoff_distance + ) + + # Set dispersion correction use. + forces = {} + for i in range(system.getNumForces()): + force = system.getForce(i) + forces[force.__class__.__name__] = force + + forces["NonbondedForce"].setUseDispersionCorrection(True) + forces["NonbondedForce"].setEwaldErrorTolerance(1.0e-5) + + positions = pdb.getPositions(asNumpy=True) + + integrator = openmm.LangevinIntegrator(T, 1 / unit.picosecond, dt) + + integrator.setRandomNumberSeed(42) + + # platform = openmm.Platform.getPlatformByName(platform) + # simulation = app.Simulation(topology, system, integrator, platform) + simulation = app.Simulation(topology, system, integrator) + simulation.context.setPositions(positions) + simulation.minimizeEnergy() + + simulation.reporters.append(app.PDBReporter("output.pdb", 1000)) + simulation.reporters.append( + app.StateDataReporter("log.dat", 1000, step=True, potentialEnergy=True, temperature=True) + ) + + return simulation + +def gen_neighbor_list(pdb_filename=adp_pdb): + + pdb = app.PDBFile(pdb_filename) + top = pdb.getTopology() + positions = np.array(pdb.getPositions(asNumpy=True), dtype=np.float32) + + dr_threshold = 0.5 + box_size = 3 + nl_cutoff = 1 + displacement_fn, shift_fn = space.periodic(box_size) + neighbor_list_fn = nlist(displacement_fn, box_size, nl_cutoff, dr_threshold, capacity_multiplier=0.5) + neighbors = neighbor_list_fn.allocate(positions) + + return neighbors + + +def gen_atomtype_lists(pdb_filename=adp_pdb, atomtypes=['C', 'N', 'O'], solventname='HOH'): + + pdb = app.PDBFile(pdb_filename) + top = pdb.getTopology() + + # separate each atom type of interest - solute and solvent oxygen into a list + atom_indices = [] + for residue in top.residues(): + if residue.name != solventname: + for atomtype in atomtypes: + for atom in residue.atoms(): + if atom.name.startswith(atomtype): + atom_indices.append([int(atom.id)]) + + solute_list = atom_indices + + oxygen_list = [] + hydrogen_dict = {} + for residue in top.residues(): + if residue.name == solventname: + for atom in residue.atoms(): + if atom.name.startswith('O'): + oxygen_list.append(int(atom.id)) + hatom_list = [] + for bond in residue.bonds(): + if bond.atom1.id == atom.id: + hatom_list.append(int(bond.atom2.id)) + elif bond.atom2.id == atom.id: + hatom_list.append(int(bond.atom1.id)) + hydrogen_dict[int(atom.id)] = hatom_list + + + #atom_indices.append(oxygen_list) + + print("oxygen list") + + print(oxygen_list) + + #print("hydrogen dict") + #print(hydrogen_dict[23]) + + print("\n") + + num_atoms = top.getNumAtoms() + natom_types = len(atomtypes) + 1 + + return atom_indices, solute_list, oxygen_list, hydrogen_dict, num_atoms, natom_types + + +def gen_atompair_list(atom_lists, natom_types, exclude_atomtype_pairindices): + + position_pairs = [] + for i in range(natom_types): + + for j in range(i, natom_types): + + for i_particle in range(len(atom_lists[i])): + + for j_particle in range(len(atom_lists[j])): + + if i == j and j_particle <= i_particle: + continue + + if [i, j] in exclude_atomtype_pairindices: + continue + + position_pairs.append([i, atom_lists[i][i_particle], j, atom_lists[j][j_particle]]) + + return position_pairs + + +# %% +def get_args(argv): + available_args = [ + ("well-tempered", "w", bool, 0, "Whether to use well-tempered metadynamics"), + ("use-grids", "g", bool, 0, "Whether to use grid acceleration"), + ("log", "l", bool, 0, "Whether to use a callback to log data into a file"), + ("time-steps", "t", int, 5e5, "Number of simulation steps"), + ] + parser = argparse.ArgumentParser(description="Example script to run metadynamics") + for (name, short, T, val, doc) in available_args: + parser.add_argument("--" + name, "-" + short, type=T, default=T(val), help=doc) + return parser.parse_args(argv) + + +# %% +def main(argv=[]): + args = get_args(argv) + + atom_indices, solute_list, oxygen_list, hydrogen_dict, num_atoms, natom_types = gen_atomtype_lists() + exclude_atomtype_pairindices = [ [1, 1], [1, 2] ] + + position_pairs = gen_atompair_list(atom_indices, natom_types, exclude_atomtype_pairindices) + + all_atoms = list(onp.arange(num_atoms)) + #atom_indices.append(all_atoms) + + print(atom_indices) + + cvs = [PIV( all_atoms, + position_pairs, + solute_list, + oxygen_list, + hydrogen_dict, + {'r_0': 0.4, 'd_0': 2.3, 'n': 3, 'm': 6}, + {'neighbor_list': gen_neighbor_list()})] + + height = 1.2 # kJ/mol + sigma = [0.35, 0.35] # radians + deltaT = 5000 if args.well_tempered else None + stride = 500 # frequency for depositing gaussians + timesteps = args.time_steps + ngauss = timesteps // stride # total number of gaussians + + ## Grid for storing bias potential and its gradient + #grid = pysages.Grid(lower=(-pi, -pi), upper=(pi, pi), shape=(50, 50), periodic=True) + #grid = grid if args.use_grids else None + + # Method + method = Metadynamics(cvs, height, sigma, stride, ngauss, deltaT=deltaT, kB=kB) # grid=grid) + + # Logging + hills_file = "hills.dat" + callback = MetaDLogger(hills_file, stride) if args.log else None + + tic = time.perf_counter() + run_result = pysages.run(method, generate_simulation, timesteps, callback) + toc = time.perf_counter() + print(f"Completed the simulation in {toc - tic:0.4f} seconds.") + + # Analysis: Calculate free energy using the deposited bias potential + + # generate CV values on a grid to evaluate bias potential + #plot_grid = pysages.Grid(lower=(-pi, -pi), upper=(pi, pi), shape=(64, 64), periodic=True) + #xi = (compute_mesh(plot_grid) + 1) / 2 * plot_grid.size + plot_grid.lower + + # determine bias factor depending on method (for standard = 1 and for well-tempered = (T+deltaT)/deltaT) + #alpha = ( + # 1 + # if method.deltaT is None + # else (T.value_in_unit(unit.kelvin) + method.deltaT) / method.deltaT + #) + #kT = kB * T.value_in_unit(unit.kelvin) + + ## extract metapotential function from result + #result = pysages.analyze(run_result) + #metapotential = result["metapotential"] + + ## report in kT and set min free energy to zero + #A = metapotential(xi) * -alpha / kT + #A = A - A.min() + #A = A.reshape(plot_grid.shape) + + ## plot and save free energy to a PNG file + #fig, ax = plt.subplots(dpi=120) + + #im = ax.imshow(A, interpolation="bicubic", origin="lower", extent=[-pi, pi, -pi, pi]) + #ax.contour(A, levels=12, linewidths=0.75, colors="k", extent=[-pi, pi, -pi, pi]) + #ax.set_xlabel(r"$\phi$") + #ax.set_ylabel(r"$\psi$") + + #cbar = plt.colorbar(im) + #cbar.ax.set_ylabel(r"$A~[k_{B}T]$", rotation=270, labelpad=20) + + #fig.savefig("adp-fe.png", dpi=fig.dpi) + + #return result + + +# %% +if __name__ == "__main__": + + main(sys.argv[1:]) diff --git a/examples/openmm/pivcv/Metadynamics-ADP.ipynb b/examples/openmm/pivcv/Metadynamics-ADP.ipynb new file mode 100644 index 00000000..c8cab7d9 --- /dev/null +++ b/examples/openmm/pivcv/Metadynamics-ADP.ipynb @@ -0,0 +1,362 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "KBFVcG1FoeMq" + }, + "source": [ + "# Metadynamics-biased simulations" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "BBvC7Spoog82" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2022-06-29 11:39:38.911094: W external/org_tensorflow/tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /software/slurm-current-el7-x86_64/lib64:/software/slurm-current-el7-x86_64/lib:/software/gcc-7.2.0-el7-x86_64/lib64:/software/gcc-7.2.0-el7-x86_64/lib:/software/python-anaconda-2021.05-el7-x86_64/lib:/software/git-2.10-el7-x86_64/lib64:/software/subversion-1.9.4-el7-x86_64/lib:/software/serf-1.3.9-el7-x86_64/lib\n", + "2022-06-29 11:39:39.748220: W external/org_tensorflow/tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /software/slurm-current-el7-x86_64/lib64:/software/slurm-current-el7-x86_64/lib:/software/gcc-7.2.0-el7-x86_64/lib64:/software/gcc-7.2.0-el7-x86_64/lib:/software/python-anaconda-2021.05-el7-x86_64/lib:/software/git-2.10-el7-x86_64/lib64:/software/subversion-1.9.4-el7-x86_64/lib:/software/serf-1.3.9-el7-x86_64/lib\n", + "2022-06-29 11:39:39.829378: W external/org_tensorflow/tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /software/slurm-current-el7-x86_64/lib64:/software/slurm-current-el7-x86_64/lib:/software/gcc-7.2.0-el7-x86_64/lib64:/software/gcc-7.2.0-el7-x86_64/lib:/software/python-anaconda-2021.05-el7-x86_64/lib:/software/git-2.10-el7-x86_64/lib64:/software/subversion-1.9.4-el7-x86_64/lib:/software/serf-1.3.9-el7-x86_64/lib\n" + ] + } + ], + "source": [ + "import numpy\n", + "\n", + "from pysages.utils import try_import\n", + "\n", + "openmm = try_import(\"openmm\", \"simtk.openmm\")\n", + "unit = try_import(\"openmm.unit\", \"simtk.unit\")\n", + "app = try_import(\"openmm.app\", \"simtk.openmm.app\")\n", + "\n", + "\n", + "pi = numpy.pi\n", + "\n", + "T = 298.15 * unit.kelvin\n", + "dt = 2.0 * unit.femtoseconds\n", + "adp_pdb = \"../../inputs/alanine-dipeptide/adp-vacuum.pdb\"\n", + "\n", + "\n", + "def generate_simulation(pdb_filename=adp_pdb, T=T, dt=dt):\n", + " pdb = app.PDBFile(pdb_filename)\n", + "\n", + " ff = app.ForceField(\"amber99sb.xml\")\n", + " cutoff_distance = 1.0 * unit.nanometer\n", + " topology = pdb.topology\n", + "\n", + " system = ff.createSystem(\n", + " topology, constraints=app.HBonds, nonbondedMethod=app.PME, nonbondedCutoff=cutoff_distance\n", + " )\n", + "\n", + " # Set dispersion correction use.\n", + " forces = {}\n", + " for i in range(system.getNumForces()):\n", + " force = system.getForce(i)\n", + " forces[force.__class__.__name__] = force\n", + "\n", + " forces[\"NonbondedForce\"].setUseDispersionCorrection(True)\n", + " forces[\"NonbondedForce\"].setEwaldErrorTolerance(1.0e-5)\n", + "\n", + " positions = pdb.getPositions(asNumpy=True)\n", + "\n", + " integrator = openmm.LangevinIntegrator(T, 1 / unit.picosecond, dt)\n", + " integrator.setRandomNumberSeed(42)\n", + "\n", + " simulation = app.Simulation(topology, system, integrator)\n", + " simulation.context.setPositions(positions)\n", + " simulation.minimizeEnergy()\n", + "\n", + " return simulation" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3UrzENm_oo6U" + }, + "source": [ + "Next, we load PySAGES and the relevant classes and methods for our problem" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "fpMg-o8WomAA" + }, + "outputs": [], + "source": [ + "#from pysages.grids import Grid\n", + "from pysages.colvars import PIV\n", + "#from pysages.methods import Metadynamics\n", + "\n", + "import pysages" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LknkRvo1o4av" + }, + "source": [ + "The next step is to define the collective variable (CV). In this case, we choose the so called $\\phi$ and $\\psi$ dihedral angles of alanine dipeptide.\n", + "\n", + "For this example we will use the well-tempered version without grids. But these options can be configured.\n", + "\n", + "We set the initial height, standard deviation and deposition frequency `stride` for the gaussians, as well as the $\\Delta T$ Metadynamics parameter. And the number of time steps to run the simulation (here we use $9\\times10^6$ or 18 ns for the timestep chosen).\n", + "\n", + "We also define a grid, which can be used as optional parameter to accelerate Metadynamics by approximating the biasing potential and its gradient by the closest value at the centers of the grid cells.\n", + "\n", + "_Note:_ when setting $\\Delta T$ we need to also provide a value for $k_B$ that matches the internal units used by the backend." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "B1Z8FWz0o7u_" + }, + "outputs": [], + "source": [ + "cvs = [PIV( [[4, 6, 8, 14], [0, 1, 2]], [1], [2.3, 3, 6])]\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Fz8BfU34pA_N" + }, + "source": [ + "We now simulate the number of time steps set above.\n", + "Make sure to run with GPU support, otherwise, it can take a very long time.\n", + "On the GPU this should run in around half an hour." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "K951m4BbpUar" + }, + "outputs": [], + "source": [ + "state = pysages.run(method, generate_simulation, timesteps)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PXBKUfK0p9T2" + }, + "source": [ + "## Analysis\n", + "\n", + "Let's plot the negative of the sum of gaussians accumulated. This will get close to the free energy surface for long enough simulations (larger than what is practical to run on Colab, but we should get close enough for illustration purposes here)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "X69d1R7OpW4P" + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "from pysages.approxfun import compute_mesh" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6mrlIOfoszBJ" + }, + "source": [ + "We are now going to gather the information for the heights, standard deviations and centers of the accumulated gaussians and build a function to evaluate their sum at any point of the collective variable space." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "id": "zJqvpbw8szxR" + }, + "outputs": [], + "source": [ + "fe_result = pysages.analyze(run_result)\n", + "metapotential = fe_result['metapotential']" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VfTQ5yeyxt8e" + }, + "source": [ + "Next we use the biasing potential to estimate the free energy surface. For well-tempered metadynamics this is equal to the sum of accumulated gaussians scaled by the factor $-(T + \\Delta T)\\, / \\,\\Delta T$." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "id": "6W7Xf0ilqAcm" + }, + "outputs": [], + "source": [ + "plot_grid = pysages.Grid(lower=(-pi, -pi), upper=(pi, pi), shape=(64, 64), periodic=True)\n", + "xi = (compute_mesh(plot_grid) + 1) / 2 * plot_grid.size + plot_grid.lower\n", + "\n", + "alpha = 1 if method.deltaT is None else (T.value_in_unit(unit.kelvin) + method.deltaT) / method.deltaT\n", + "kT = kB * T.value_in_unit(unit.kelvin)\n", + "\n", + "A = metapotential(xi) * -alpha / kT\n", + "A = A - A.min()\n", + "A = A.reshape(plot_grid.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Kf_CMdih90Cd" + }, + "source": [ + "And plot it." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 461 + }, + "id": "3s9LL9apBMVb", + "outputId": "55abf4e5-fef0-4faa-bf01-9719cbe8aa2b" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi0AAAG2CAYAAACzoLZvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAABJ0AAASdAHeZh94AAEAAElEQVR4nOyddZgsV533P6eqbazH9bq75vqNy40LERIsuMuysAu7LM4usAssL764BU0IxCDu193dx92nreq8f5R0VXX1zFwJF0L/5jlPd586dbq6Wuoz358cIaUkZznLWc5ylrOc5exv3ZQLfQA5y1nOcpaznOUsZ6OxHLTkLGc5y1nOcpazvwvLQUvOcpaznOUsZzn7u7ActOQsZznLWc5ylrO/C8tBS85ylrOc5SxnOfu7sBy05CxnOctZznKWs78Ly0FLznKWs5zlLGc5+7uwHLTkLGc5y1nOcpazvwvLQUvOcpaznOUsZzn7u7DAhT6Av1UTQhQDlwGngcQFPpyc5SxnOctZpoWAccALUsqev8YTCiHqgNLzMFWXlLLxPMzzD2U5aMlulwEPXeiDyFnOcpaznI1otwIPv9JPIoSoKypUGvr69fMxXZ8QYmYOXM7MctCS3U4DLJh6D/mRMpASoUmQEnQQuk4s0cu20/czrfxSKvMmGNs0CVjjdONWYt6ajwF0a82nM137SaTvKuZ9Yd0qnseO+0p6W0+ihQNdL1AYqmBm6aWoasixj3Df986T5VYK53H5HXZ6uz1W8d9uvUZpdSnpx1LXae86QH3zJkAwacKVFBdPMOayjkURxr7mrXHffF4VWut30HDwOcYvvJniuulIxdxHAV0Fic7ptX8gNdTPuOvfBOEgUjXmSGlxGv/wC4LVVVRcfzNSFciARBeSjgceRB/sp+Idr4OwilB1hKrT9cvHSLZ1Mu5f7yQUUQgGNFQh6d14kOM/X8fiT15N+dQSQmqKkNAIKRrtu5t55r+2suZf5zB9ZTlhJUVIpAgIjaDQCJv3n/lNK0/+poMPfrGGufPDCKGjIlGQKEJHQaLapzHzs6abJ1kDdAS6VNARaAikVEhKla//exPjZuSz5s3VpKRKSqrE9QApqZIgQEIPsPmPDRx4soEbvnkFSV0lKVUSmjHu5BNHOPXoPub9910kCaDpKklNITGQ4tSnfk7ZXVcRWTADmVKQugANhnYfpOehJ6l+7ztQ8woRukDoICTG90+D9iceIdnZSd2db0KgIszriDC/gqP6agmj2Z816755q+spTv/4m5SvuZH86dPtfqkAijQ/OxIE9L28jvixk5S/425QQCgSFIlQJIowbtGTnP7Y96n7p1vJn1qDquioivFeqQLzsY5AogrJrs//marl45l44wzzPZUIYb2/GO+3+b6KYV6wNL9TmjTeV10a77eUAl0KNOt91xWaXjrGqfu3M+9rd6NLFU2CLhU0TUGTAl1X0HSFvs2H6PrjS9R85p2gK0hdgZTxRRWaoO0nvyJv0mSiK1cjNON9ESkQuqD+Z9+j5KJVFE9bYGzTQdEg1d/HsYe/x6Qr30xeURWKLkEDRQc0nf0v/YjqcUuoqlsAOsT629m3/Zdg/l7/Fay0r1/nwZ/WMnVS8KwnOXI8ye1vbSrCUGxy0HIGloOW7JYAyI+UUZhXBZpEWCBiQsvxtnUUhauYWLrE+HLpOqgmsEgJmoaUMg0oFrToMn3Blg5i17P86CjC/diCE2e/E1zMfuEFDEUBISgKllMarmNr20Ps7XiaRdW3kB8scQGLVPzgxZpnBHDJBiN+4OIc7zM2E1wERYW1jBuziqMnn+bgkYeprV7M1KnXEwjlmxcVYdyqJrQo5mNFIFWYMOd61GCY07seI7+0hmjddHTVgBapGm3SdW/l0ANfp3PXWsZcd48BMyqEVBhz91s59ZNvEDt1kujKFeY2SdU77qXxy19jYON2Sl93I0KViIBO9Yfvpv7j36Hrye2M/8D1BAMaQVUjOrmEoVMdHPjhRq786Z0URRXCSoqwmqJqWhFDHUM8960DTFu2isrpRUREiqBIEVGSBIVGUKR426fHoirw/c+38tXfjGPGnDyCImWAiwkwgH3rBZc0tBigokvFvG8AiyYVqseFkLpk3LQ8kjJgAIkMENeDxGSApB5g0W3j2PSLI4TCguIxxQxpQeJagISuIu5ayPHfbCPZM0ThwkkkUgHUlEpQV4heOp+hnYeJ3ngpUhNITYGUIFhdzeC6rQzu3kP5bbcZFzZNGBc+g7Covu0eTn7zywweP0LZsstsWBEOYBHZ4EVYn0P8oUUxwGTwxGHQdaKLl6IU5Jnwi/lZkeY4CSqg6wSrKgiNqTFgRTWgRVEN0BCKjt7dDUDe9LHkjytFMaFFVQz4CJjQEhA6Qkj0eIqiiWVEJ5WhCJluWPfT0KIMAy26A1p0qaBLYUKq0VK6io4gpSvE7t9BycKxFE6qJKUboJLSVDTd2K7rBsB0P7uD8JQ6wuNqjPcupYAmQBeQ0NHa2sm7/npCNTUIzYASoYHW04822EfRtDlEKmrM9xaUFPR2tqEEQpRMmIMiVZSUNPeTJHraScZ6qRqzmIKCyvR7bdhf1YU/eVKAWTPOHlr0M/5nNWeWvWoCcYUQC4UQjwkhTgkhhoQQnUKI9UKIN57z5J6VsIWU9A420di7lxmVl6N4P38W3Lj69Ix5bGDRZXZg8dvu3C/beMB3BW+zryBYyorquwmp+axruI/mgUOu7a773lvdv1/Y282WbT7nWDxjnXNKaVykZPo5rf0CSpgZk29k8by30917go2bv0F7217zhyx9nPb+5r7Gf+uSsTOupGbKKg6v/SWx3naEOdb6Dz0YLmTCmjfRdWALXXs2peeREKkZS8WaW2h/7E8kmpttBUAtLKLi3nvoe/plhnYdMl6KBFFQQPUH76T76W10rTuApgsTFhSmf/gqUBS2//eLJHXjQqKZF5Ll75jNlEtquO+DW+hpS9owoUklffFB5S3/Uceyq4r4xFvqObIvZoxxAAhg31oXKas5t2WzkooAPR0p320WDFVMKaKoOo+T65sB9wU0ryyPsqUTaHt2n/E+iLRiUHLNEob2HiPV3J4WEQUIRaH4xmvoe3kDqZ5uWxGBNGgEiqJUXHUj7c8/TrKv234+6RhrzZfRrHF+5ugfOHKQyNjxqHl5w50iAFLdvagl0WHHaD0DAASKC0acDyDZFyMYjYxq7Nma9Tmwbrt3N1I8d8yI+yWONxGeWGd+Z9wnM9nShkymCI015nFujTfVI1SVSEWN3Wd9RwdbT5FXMRYhVDx8TXfrYUKRKHmFlel9LtC1X5c62jk0XZ4X99I/pL1qoAUowZAIPwHcANwLnAB+KYT45FnP6rwgm64hgEOtz1FZMIWyvHHpcbp0XZhtlcVPTckCHlJKV3PZcOAi/eeVThBwgpSUhNQ8llTexsTii9jR+hj7259FlykDFrKAyWjAxQUv1jYPjGCOs8d7QSdjXmx4s+eXUBqdwPKFH6CmaiG79/yafXt/h5ZKpCHEfE+ETtplYLYJ82+isGw8h174CXoiZgCGjg0hBdUTqV11M43P/oF4S6OhsJljSpZeTP7UGbT86hfIeAJM90XezBkUXXUJHT/+PVpXv+HukILIzEmU3X4pDd9+lHhLL5qukNIViESY9+nraXr5OIcf2EdSV0nphgsmJQJc+7ml5JeGuO+ftjEYM2T6pFRJyoANJygq7//yeOavLODDd9ez/rmhrODiBRQv1PhZcXmAno4kKhKV9GdIEen7qoBJq6o5va7JBhanKlB7zUzaXzyEHkvawCKEJDK1lvCUOnqfXI+wyNBseYvnEqyupPupZ2w3nwQHfEiKl64kVFFF65N/csGKU0Hxg5MMZcVz37odPHqQ/KkzMidwXlHNsVrP8NAihAEtIqCiFoayjrNM13RS/QmCReERxw47j0NlGcliXUMMnu6yoUUC0twvfQu6LomfbCY0sTZzEgmJ0w0oBQWoxcVu+JCCWGM94cpahGoI/c7tgy2nKKgabz92qmc9rUcorpxmXLRyQsU/rL1qoEVK+byU8j1SyvuklM9JKR+VUr4O2Ai865wm96gG7X3H6Bg4yfSKy9L9zous7qeqSDewONSTrJDit02X2cFntODiOFYhFKZGl7O0+naaBg6yseG3DKV6bXARuue1OW+dz+tskAkjOhljzmi8R3Wxx0tQlQDTJl7LkoXvprvnJDu2/4hEvN/+sbNjkSTGa9KMW0UqTF/+BpCSoy//CjTNhhJMeKmcdwnRCbM49cjP0WMxG34UKai5+W70eIL2hx+yYQddUHrz9QRKi+n40e/RUxJdM1SN0jsuJzyuihP/8ydSCR1NGjEEBVNrmPXhy9n1zfU072olKRUbXkQ4xGu+voruphh/+PQ+ErpiAkkaXhJSRQmqfOTr47j53jI++c4GHv51bwa4eOHFCyq69P85KKkI0N2eVloUD7ioJrxMvria05tb0RKa7bqw3FE1F08CoHvDYRtYBIbHsuT6FfS9sA19KGZ4Bc0mVIWSm9bQv34Tyc5O481UcMeVqArVN99J/4Hd9B3Y6Qsu1n3phZgRruGp/j7iTQ3kT5uRjn0ZZj/NqbTYnlP3d1rrGUAtLki7bod7/r4YAOHouUGL05zvsVNts8Cme08TSiRA/pQqe5sx1ri1wCXV0YveN0hofB1SCltVtGAicbqR0NgxKPYbkN4Wb6onUjvW1YcEqesMtp0mv2J8hooipU5P21FKKqY6O0d6C18x05Hn3HJ2dvaqgZZhrB0jPOzsTHeoLBj3T3duoaZoBoXhiqwXdZfK4rqvZ8CK8Tx69gY+4x2A4pgzG7i4tnnABaA8PI7VtW9EEQHWN/yKrlhj+jVbr9GvuSAqc7uvmuIDJMOO94MXIzrQBhekpLhgDEsWvhspdbZt+z6xgQ5bcRGaBWBuN1EwkMfM1W+hr+04jTufMkEtrbgoUjD2irtB6jQ99YANM0KDQKSA2jveQN+WjQzu3WvEXGgglADlb3898cMn6H9qA+gCqQskQar/6U4SDR00/WatEScgBUlNpfa6eYy5biYbPvUsA11JUlIx4EWqRKoKueP/rWDPk828eF+9CStGXIkTXDQR5I3/UsMHvlDHNz7Vyq//r9sFLk548TbLLBeU8+LW360RyXf/VDgVFwBV6ExaXomW1Gje0WLHWlgBwcG8AFWXTKX92X0m0GAqLlC0eg5KOET/i9vADGq1DimyYDahMbX0PPV0GlYgDRGKJDxmHOWXX0vTn37FYP1xf3AZyUUkPGOB7i1rCZSUEq4bSzaz9tdjMfTePgIVpb7jLHhJtvcQKC/KOp/T4i29xjmodLuShotdGY1Z8Sx+/QOnOimYUI4SUF39TpNSkGzuBCEI1pRnPoGEVFs7weoq+7F1KyQkOtoIlde4xgNo/b3oiRh5ZcY267stJCQGe0glBigqGWf3XUjTz8Nfzs7OXnXQIoRQhBABIUSlEOJ9wLXAf4+wT5UQYo6zAVPAASzmRTSRHKCt7yh1xfMyL96WygKZwGKZ7lVO3GDiUiLsfdwAk1V10R3HYfV5n9MLLo6+sJLP0po7qMqbzKbG33G482V0PWmcIz930Ejw4rl/1gCjmePt7C3dhhd0idB0G0gigUIWz307kXAJ27b+H329jZngorsVl/yCKqYufx2Ne5+m++SeDHAJBCOMX3MvPYd20Lt3u+0+EhrkjZtM6erLaXvg92i9/SbQCELlVZTedTPdD/yFxKlWI1BRCtTSEqreeyut96+lZ/dpkppKSldI6CrTP3A5akGIDf/5IglNsd1ESalSMbuCaz+5kD9/9QAHN/fY4OKMb0mYAHP13WV87Btj+en/tvPDr3SSkoIEqgteLChxPs7mIjq0a5DpC/Iz+lV0O+AXoCCqUregnFPrGh3AYgSXKkJSe/UMuracINUzaGTICGkEooZUotcsoffJ9SA1O+vGCGYVlNx8Lf2btpDoaM9QWyw3Udll1xBdsJSG3/6IeFtzVpXF/pplcRtZpsVjdG98idJLrkQ4LuC2eeJmEs0tAARrq51BVBm7JZs7CNWmL/QWvFnNqcwMnOokVJZPqCjiGJ/9au0LIqNwDTkBNd4xSKi80OwXuNUWkVZauvpRowWgqtgxLY6TqnX3EigudgGLdZvq7SYYLfHEm0GirxOAcEEZXi6L9bUDgkh+mf1PijPW7a9tugRNyrNuF+iwXxX2qoMW4LtAEmgFvg58SEr5/RH2eR+wx9MeAlwAIaSkuWcfQTWP8rwJw6ssXjOhwhdWPPCQ0efsd4CLr+piPbb3HUWMi6NPkQpzK65hQeX1nO7dzbr6++geMlQXl7toJHgZTp0ZToHRnHPpGeO9oOOMXbH+MwuoIRbOfhOlJZPZvv2HdHUeHRFcympmM2bW1Rxd9xtiXa1paDGzHgoqxlK99BqannmAVE+PkcFigkv55dejFhbS/uADkMIGl8KVKwjPnEb7D36HHtcNN5GuULB0NsVXL+bUVx8i3hszMjR0BT0UYcFnrqdtawP7frOPuB4wM3ACxPUAs26ZzKLbJ/Crf95Je1PSBhdLaXGCy6obSvjU/43ngR938b+fbCcWw1ZdnJlClqVdR5k/CYd3DjHNAS2qkLZLCLBTrAGmXFzNqbVNruwWK66lfPFYgtEInS8dQAiJqlguIknJmiWkOnoY2nnQJEJsKAjPmU544ji6n3jSyNrxqCJSACpU3XQH+ROnUv+bH5Ds7coMyCULrPjM17NlLSIQJLpoqb1fRnq0Y/9kUwtqabGRYeQ1B2gkmzsJ1RpqjNd1ZJkFJv0nOimcUDbsmHM1bxBuvH2AcHmBDSeWOR9LKUh19aGW+CtGQgq0nh7U4mJzB6sftFgMPR4jEC1JbzO3J3o7CeQVoQSCnkwwSay/nUh+KapwAKT13c/ZP5S9GqHli8BS4EbgJ8C3hRD/MsI+3wXmetqt9lbrYgk0du+mNjrb8NU6oWE4lcUPWKx5vRCTxTXkOxaP6gIZkHLG4GIec03BdC4ecy/RUBUbGn/DgY7n0TQjq3BU8HKWADNyXItjjObsN4HEVF0UVOZMv5O6movYufNntLXuSYOLxAUuVgDuuFlXE62azOEXfooeH7LrR1guoepFVxEqqaTxid+BZqZi6qCKADWveQMDB/YxsG0bQhPmPgoVb7gLrbuHnj8+bab0CnRNoeLe6xDhEKe+9QQpTZA0wSU8vopZ/3Q5u7+3kda97a74lpSucMW/LqR0QiE/ee82+np1OwXZD1zmX1bCF34+gbVP9vPeW09xcE/CEcCrZLiHLGCx3UhSoaNdp7UhybT5BrQ4g2+dF07VrAkzeXUNncd76W/qzXARBYKC6ium2y4iZxZRqLyQwlXz6H18HcKsbWK4iiRCERTffB0DW7eTaGm2XUjpeikWuCjU3PlGgqVl1P/6B2ixgQyXj8uyQIieTNC1/gVKV1+BCAWHj32x3D6NzYbK4ul37iuEJNHcSaimbFSxGAMnuyiakHY3nSmoeJUXb8yS1+0DEO/ot5UWy+wAXEdfqrMPtbTIobKkB0hNQ+vrRy2O2ifXOvRUbzcAwWiJC2aQkOjrIlTkUVnM72usv51IQYU9/kLDSi6m5cLZqw5apJSnpJRbpJR/llK+F/gB8CUhROUw+7RKKfc6G3DUHmDGP8STffTEmqgpmuHc2V9l8QBLei4HJFiPvenRTvMCjA9wnBO4OGHLc+whEWF+5XUsrrqFpv6DrK3/BW0Dx5Dm+GHhxXnfCzDebaNRYbyuIV1Pb3f2S2zVRUjBtAnXMWn8Fezd+7u04qI5gnolrsDcacteh9R1Tm3+U2Z8Cyrjrno9A6eP0L1zfTq+RYe8qjGUX3Et7Q89iNbZZcS36EYadNkb7qT3Ly8QO3ACqQt0XUAgQs0/3UnfxoO0PbkbTVdI6gpJTaV6zRxqr5zG+k89w2BPyhXfklJD3P71laQSkl/8006G4iIruOgoTF8S5Vt/mcbYKWHe/5pT/OLbnSSTVnCuuxkfD/dPwuFdQ4TCgvHT/dNuDSXF+DyoQqd6ehGFVXmcHsZF1Lu3kXhzj6HAmP1CSEpvXE5s7zESp5vTaovpCorMnEJ46mS6H3/ShBXphg7TTSRCQerueTsoCvW//TF6KpGhzGSLabFVlm0bQEqKly5Pv1BXLI3MUHGSTS0E66rTc3lNSPShOFr3AKE6/7gX13Ah6T/ZSaEJLX7A4gTIMzU/YNGlINE5QKjMiKExRA4TWByZQwBatwktPqb19IGUhnsIx+mQwkhfV1QC+QYYOV9WoreTUKF5bjxgMtTfTl5hhQtoLmjKMxLtHFoOWs7eXnXQ4mObMIroTT7XiTr7TxJQwhSHa9IXa+si7FVZPCa9cOBRS4ZrtnnhxfG8Zw0uzuNxzuuYryp/MhePuZfyvPFsa/4jGxp+RcfgKXtMBrx4m/38PgBzNm4k73Yr5sWhutjggmDimEsZW7uc3bvvY6C/JQ0uNpSk3URBNY9py19H+/FtdJ3YmQEuecWV1K66mabnHybZ2e7IGoKylVcQqqym9f7fG8UIzYJoBfPmUrBqCR0//D1af9IEF4XghDoq3ng1DT94goHT3XZ8S1IGmPHhKxFBlY1ffIlYSrVdREmpEijO57XfXUXr0X5+9ykjo2g4cCkoDfGv3xrPR74ylj/8uJMPvfY0TQ0pVzyLM87FUl6SCcnTD3YzeU4egeDw2oB1AQ0okkmraziZxUVUMquKvLEldD6311RazJgORZI3pY7IzPH0PmmoLc70ZxQouflaBnfsIt7QYECEpbBY9xVASJSCPMa+8V2k+npo/MMv0LVEWpnxNCfESAFabIjOtc9SsvIylFDY3x3kMYkk2dBMsK7GDSzCdUOiqQOAUE3a5ePKpHJcpbV4isHGHgonjgw4Z2J+QbjOx/GOAYJlBb5QY5mUkOruRy0u9NloxLMAqNFoGjwcSkugKIoQSho4TPhI9ncRKix1Z5Ob22L9HUTyKyySMn83SJc/yNk/jP0jQMsVGJe0Y2e1t6myICWDiU4KQ+WIDEe5HwSkVRZfYLF3HflL5wsvjuc9r+Dik1mELgkSYk75VVwy5i0UhMrZ3PR7tjb/kb54Wya82M/lAyzex2cAMSPBy3DgMm3itZSWTGb3rl+STAyaCosHXMzbaOkExsy6khObHyQ12OcCE6FDxdxV5FePM91EukuJqbntdcROHKN/0yaj9LwGaIKyO24BoPv+xw03kQ66rhC9biV508dy8uuPkEpKO75FhvNY8Nkbad5wmgO/3euq35KUKnm1xdz5rZXsebqFZ3580gaWbK4iHZVLbinhO3+eSiAoeN8tJ3niT730D0rfTKLmRo2Pvf4kezcN8NZ/q0H3+akwAnEd7iLzKjRxaQWNO9qRunS5iAKKhqpA7TWzaH1qLwp6+qJtqi4lN62i/6UdpHr6TBcR9q9UeNpEIrNn0vXIo+g20JAZbyIkakkxY+99N7Gm0xz/9pfo3r4BiZaptjj2k0haHvotSjhCycqL3WqK15XkeN5UewdaTy/hKePtc+EtIg1GMbZAeZRAND8j6NY+h2Zf964GhBCUzKoetaJyrllF1gF707G96c4AJDWUUBC/dGeZNNzISjCzFo1MJFBDYV+FREvEUENGTJCdFWhtSw4RDGUGg18oy7mHLpy9aqBFCPEDIcRXhRCvFUJcJoS4QwjxW+BNwNeklG3n+hyxZB/hoCmJ+l2IwVdlsc0BHr61V7I1331eIXCx5vJTS3RJfrCE+RXXsqr2Deh6irX1v2BP25MMJDoz4GVY9WU4qBkBYLLHtZiqi2YAmDDnMMBFYc60O1CUIHv3/AaZShk/ivZzpBUXJIydeRWhSJSTm/7okwatMPaKexhsPk3XdrebKFxaRfmV19Hx2MNoXT1YReeUYITyN95F//MbiO0+itSMdXakDFD13tcQP91O02/X2W4iTVeITKxizkevYPd3N9K8M12/JWEqLhWzKrjxc4t58huH2PVce1Zw0bBcSAGi1RE+/8vJrHltKd/8ZAuvXXqE//xAIy8+3s/gEGhSYdu6IT54y3EAvv7wVKYvzvyP2lmrxSg6J81+ybhFZcR7E3Sf6Lb7rOyYgNCpWzOTocYuBvY32GvvCIwLfNHSGQQrS+h7ar3tijGUFgNgyu68mdjRYwxs3eZSWiy1xY5vEZJgZRWTPvTvFF+0gtYnH+LE/32FvoO7kUiXiyjR103vri003f8LBo4eoPbuN6OEw25gcZrncezQEdTiIgI1la7tTigRAmJHGohMG5M1ADd9biXtm09SOq+WUP7wpeLVEeY6U1PDAbT42VeIAAz3sRN+zEMU0tymOIJp7W0SqaVQ1EAG0AgJWiqBqgTtxxc8pkWefeaQkT2Ug5aztVcNtADrgWXAd4CngR8BNcCbpJQfO9tJ09VXjZiWiOrjx9U9YAD+KotzrP14FB9eH3hxzXWm4OLT5wsuzsceoIiGq1hacwdLql9Db7yFl07/hA0Nv+Z0z06SqSF/gLHmGU51yQYwPmNd8JJFdUnHsEgCSpgFs99AX38jR4/8JQ0j3owiXaISYOrSu+ms3+PrJooUlVG78gZaXnqUZHenS40pXX45wYoq2v74AKQs15Mgb9o0Ci9dScdPH0Drj6fToMtKqH7PLbT+7iV6djfY4JLSFaqvnsPYG2ax/pPP0NueJK6rrsDcaddOYPU7pvO7j+2k/vCga90gC1yM4FtrUTwFEVC592M1/HLTLD7ylTHoCL7ykUZet+wwn377KT7x5lNcelMx//XrSZTXjH59FdUsNBetzaOoOo+Wna3pdXEsF5HQKagtonTRONqe3G0rDqqiG/EtAUHJzavpe2ojMhFLqy3m9S9QV0nxdVfT+ceH0Ab604sWOpUQB7iISITyK65l0oc+Qf7k6TQ+8AtO/fRbdG/fQPOfH+DYd77M8a9/ntbH/wRIal/3NsI1NRmVcSVkxrOYSk/s4BHCM6chFJG+mrqAxbgfO9JA3rQ61znLlu7cufkkFUvHZ441AdBrfirLmSgvljtIiQTRY8mMfsu8WUVZJksv0Oo5BKlpCNWAFu/L0DUNxQE0VuaQsS2JGgh5XEcX7sKvn4eWs7OzVw20SCl/KqW8VEpZKaUMSilLpZSXSynvOw+TAxBL9REJFmXGs+C46IM/iDjgJQMqALtInLc57XyBi1cVOhNw8cxbkTeBlbWvZ1XdGykO13Co82WeO/V/7Gh5lLaBY2hacnQAMxLEDKO+ZFNdXO4iE1zyQqXMm3kPDQ0baGrcYoKP4783iR3fUlg8hjEzh3MTrSZSUUfTk/cbMSy2m0ih5pa7GTx0kIEd2+2ic+iC0ttuRKgqXb951IhtsdKgl8+l+IqFnPrfPxHvTRjgoqkkdJVpH7icUFk+Gz7zLImksANz43qQlK6w6j1zmLSyil98YBtd7SmjfosDXDSZDta1wCUpAwQiAVZeX8LHvjWeX22awYe+WEdhSYCPfnUs7/xMHcGQsc6R+yM48k9GQJHULSyneUebfZH1BuWOuW42bS8cdJf1x0h/Lr58PiKg0v/8FhC46rYgoHjN5ajRKJ1/etiGEztQ1gIWB7hIAWq0iKobb2fiB/6NYGkZbU89Qqqni+KLVjD+PR9hysc+T+09b6Fg2vTsBel8TEpJ7OBRIjOmpDszgjJAxuPET7WQN81ci8eM5/GaIiTxzgH6T3RSuXSsq9897pW57KnhAJoDWs7YJMZ31Fvx1/p6axpCcde9Efa2lF3a3wk7uq4hpYainv0ChTl79dirBlr+GhZL9REJeJQWL+2PQP9ZgSXrDh54OR/g4hx7JuCSRXURQhANVTKr7HKuGPdOFlTeiJQa25r/xDMnv8Pmpvs51rWBnlhTRubRGaswjucdSXXJUGFMV1FZdDLTJt/AwUMP0dt9yj8w17wdO2skN9FrGTh9hN6921xuokhFLWWXXk37w39E6+sz3EQaKIEQ5W++m4G1WxnadgB0Rxr0m68HVeX0dx8nkRJ2mX89EGb+Z2+k+2A7u3+03eEiMjOKRIAbvrCUSHGIH75jKz1dmi+4WI8TDngxitMphAoCrL6phH/+2jguuaUEwAYWe1yWK7eVQaSYac8A4xaV07iz3ZVd5FyLqOZSIy6+Z/1BQ2URpFWXcIDi65bT8+e1oCdtKLHVjZBK+RvuYmDrdgYP7DeDcA1FxlJEnOAizaBeKSBYUU7tnW9k6r//F2Pe+E7KVl9uVLxVFY+K4lFZwCd2BpLNLeh9/URmTnXDjeu+JH68CaQkb2rtiOnOfQebUUIq0akV9nnzs9Gs7uy1bHNZ/WokiH4e3ENCEfgelq4hFMXXvSP1FEIJ+OxiQJSqmjEyZhDuhbRzyRyyWs7OznLQMkqTUiepDRFSfYLBvAAAbtfQcCAz2tU+zxe4OO+fCbiMpLqY+ypCpTp/CouqbuaqCe9lYdVNFAbLaezbz/qGX/HCqR9ysP15eoZMgDlbN5L3dVjzDAMuzhiXsTXLqK6Yx/79D6Br/vEtSFxuIr9quXnFVVQtuZqmFx5CHxxyqTHlq68iUFRMx8MP2TVfhC6ITJxE0dWX0vHzB9H6YmZsi4BQHrUfvouetfvpfH4/KU2141tCNaXM/cQ1HPjldk5vbHIF5sb1ACIvzF3fvRgQ/PS92xkcIgNcrMfOOixGkG4aXpwN8A3AdVo2V8W4hWX01A8w1D7oqtViuYiCeQGqL59OyxN7EJB2D5ngUnL9MmQsTv/zWz11WwABoSnjKLpsNR2//wN6Iu4CCa+ryBmga4GJO4NIuoEFN6AYHyzSYxw2tPcAgcpyAhUldp9TZLDuxg6dJjS2EjU/bI6RGZlDdhDunkai06tQAqq7Lo6Pa8gLLMNtt+FxmAummh8i1R/Put0xGTJ15mqPlBKE4zPl+t9N9wUaXTMgSgifysQXyHRpCLtn20YTFZAzf8tBy0hmXwwFQqho+ij+C/EDEd0HOvxSo3Vpt2HnPdtP/ZkssmhtH0l18cKLOUdAhKjKm8Ssssu5eOybuXzcO5lYfBGdsXrWN/6KF07/iAMdz9M91DA6gHHe97qNssS0ZICLCScCwfRJ15NIDtBQvz4zvkW63US10y7m5NaHkMlkhpuoauEVqMEwbesedysxIkD1zXfRv2sHQ4cOpbOJdEHJjdeihMN0//4vSE2xF1UMThxD+Z2X0viDJ4h1DLjiW8pXTGXCa+az5T+fZ6A7kS48Z2YUBaJ5vPa7q+lpjfPbf9tDXFNc4KLJtNKShhg3vHgbMKzKks2qpkUJ5qk07+5wXWydQbljb5xD9/ZTxJs6M9Kfg0URSm5aRfdDz6MnHWqLlQqtQMkt1wLQ9ZfHzSBcaaY9ZwKMK+XZk07tSn/GfetSbnBsFxKJZGDTVvKXLDD7pb2vASTWfRjYfpiCBZPtgnrZTEHSvv44lSsmZKyWbY8xM7Jc+znGeMdDZsButmMoGF/GwMn2Ecep0QK0nn7/11CQj0wkjffNu18kDy0+5D9nKIyWzAQmNWCAnpZKuDdIRlS2c/bqsxy0nIEFlTApPX7WX5Th0pv9QMUXXrLVgIGzD8wdCVy8c44EL9Ycunv/iFrIxOgiVta9nsvGvYOJ0UV0x5rY0PgbQ4HpeDGdheQHMNngxXo+x7aRwEVoOsFAPlMmXM3xE8+SiPW641sy3ERXo2sJWg68nKG2qEqQuotvo2PHWuKtzQbMmHPk100ketFy2v/0B2Q8iZ1NpAYpe8Md9L+0mdj+Y7abSOoKJbdeRqCimNPfeZyUhh3fkpIKU951McFohI2fe45kSnEF5ialSriigLu+vZLD69r58/8eSa9R5AAXQ1kRbtXFhJdsiotxis1CdFJkSYGWdjBuMAg1c8po2d1mu4hUR9CpgqRkdhUFkytofXxXOq7F0UpuWI5MJOl/dnNabbHUE0Dkhym753b6XniZ+KlT6RiWbOBiBfRmKC3u5pfq7HRR2a6hhkaSDc0UrLzI5QpyBuMKIdEHYwwdOEXhRdPsc+W35pAiJIMN3fSf6KRm9URz3PCAM9wYJyiOdnvhlAoGjoycaBkoi6J19fpuU4vMtYv6M6FGzS9AGxzw3y+UjxYfzDxOJYBQVDRHgP+Ftlwg7oWzHLSMxswviqqEDGhx9F1Q81NbXgFwyXAXOZ/H258NXjwAk6cWMTG6mBV199gKTPvQcV46/RM2Nz5A88BhdD3lCzBZ4WU0iot933Al1VVdRF64lKPHnsCuNeHjJgqqeYybfQ2Ne58hNTiQAS7R8bMoGjedpuf+aBeWM+aCyitvRI/F6H7+Oaz1jIQuyJsylYJVS+j8+YPosVS6Wq4SoPr9r6Fv62E6nt2Ppiv2atB6IMy8z95Ix+4Wdv14u+kiMgJzrYyi0qllvOary1j7i+Os+22Da40ia3VoJ7gkZYDhVoD2rlPkZ6rPhXHM/FKadxkF1fxcRKoCY26YS8sTe5ApzU5/Vi21pTBM6S0X0/PwC+iJBHbqs30LefNnkr94Pu2/vR8pNbvAnAswzMJzLkBRHM0DMvZjHHPg3Ga81v4NWwhNnkCwpiJ7PAswtOcYIqCSP3uCmdqd/bejfcMx8mqiFE0u93UNeVWW87UGkWWFUyqJNfeQGvB3EVnHrpZFSXX6QIsAtdCAFm3AB1ryCtCGBlzj7W2RfFI+0CKEIBDII5WMkRHge4FMH+a7Mprmt7hlzkZnOWgZjZlfFFtpOc/m6woabruPm2g0Reqy2gjg4prf6y7yU12cj0cBMJYCs6r2jayovYdwoIBdrY/xwqkfcrhzLQltMANe3MfruPXMnRmM67wvUVGYPvkGmlt20Nt10u0mMiFGaAbgVE9cQTBSROOep1zAgg6KFNRefBuDDcfoO7TLtT0QKaDy2lvofv4ZUq3tLjdR6WtuQh+K0fPIc3btFl0KguNqKb/rchq//xcGm3ptcNF0hcjYcub9+zUc+Pk2Tq89nRmYqyuMW1nHdZ9cyCNf3Mu+FzttV5ABKIKEWbfFUF/SqouzMm76bbMq5Y7u58L6z71ufhkt+7uQKc3o93ER1a2ZgTaYoHfjYX+15fplgKT/mY2G2uJSTAw4KbvrVrTubroe+0saOJxl/sHRT0ZMi291XGsf0s/jAphUioHN2w2VxTLhE88iJAPbD5M/dyJq2JHO6xPPoiBpW3eMqtWTUM15/Fw9znNsP3YGQ3uCny1TRRoa0/u57xdNLgcBQydaHf3pY7ZsOKVFRMKIYACtzwEt5hxqfj4ymTCyCj0WCOehxQd9F6QMBCOkkkMZ/Tn7x7MctJyBqUqYlJ4wfpn+ysQ/Eti47GyyiewnGgW4OMc5n8/q9wKUX58PwAghKAnXMr/iWi4f9y4mFS+lqf8AL53+Cad7dyE94JJRvM56Lt39fMJ73xPfUhqdRFXFXA4dedTIbrCUGCu2RRrKiSJUJsy9gdbD64j1tBn9rqDcSioWXErzCw8j4wmj34SeorkXERk3gbY//QGpSdtNpIbzKXvtbfT++XkSJxo9bqJLCU+o5tT/PkQygV3mP6UrlK+axuTXLWbz556lu77fdhFZpf5TusKc10xhxVum8Zt/3saBdd0Z4KKZAbiW6pIw3Uh+AGMBizZCnQ5nsOfY+WWkYhpdhzttlcXrIsorDlF9xXSaHtlhX8Cd6c+B/CClt15C98MvosfiGUoLApSSQire+np6n3uR3g0b0u4hT4xL1lTmbMDi52Iyt/Vv2ITUNAqWLnCpL9jAZX/4GdxxmMLFU10LRPpZsi9G984Gai6eZJ5LN1A4qws7t2dLf3ZlbXkhJ0sAbyAvRF5dCQNH24ZlgkBZEVrvAGipjJ9CoQiUwkK0/v4MsFDzjXWNXGqLtS2cj5bIFu+SRyoVy9xwgZQX58/X2bacnZ3loGUks74UiiAcyCee6ruwx2PZcLEtw+02kpvI7zlGCy5+8DKS+mLN7/kmh5QIE6OLuHjMvUwuWc7+jmfZ1/400lo920918QMX+/WmxzgLBlpuomkTr2VgsIWWlt0uN5FVdM5yFZXVzqGwfAINu54wVBbzGmpsh+qLrkZqKTq2vZRWYqShxFTdcCdDx44wtHevy01UsGgBeQvm0PmzB9GTMu0mQqX6g3cQO9FK60Ob0XRhl/lPSYXJb11FdEYV6z/9LIkkaReR6Q5K6QqXfGAOi++ayK8+tIVj2/tc4GLFuriziIStvHgXU7SAJZ0CrWQUH3NaQXmY4rEFNO/pdF1wnS4iRUjG3TLPCMht7DQLzRnF5iw1onjNEkRApfeJtUafHdsibRUkMncGZa+9jc7fP8jQwYM2rDhjXCwgyRbH4t3mrPPifJzq7aX7kSeIrrkcJT/imMcCF2x4iR9tINXRS+GS6cYmZ8CxJ56l9YVDBIrClC2oHRY4rH7j1hinCulq6XHu3wk/15J3TNHMGnp219vH67w17kOgsgSkJNXa6XjN6TkCxcWkurrS28xzqxZGAUj19WQU8AvkFZEc6HXtY1kwVEAi/jfy20vOPXQhLQctZ2DRcA09sZaRBwr/0+pd0yM9/Bw/wGcQ2+Jr2eJb/LbhAy7DwYvfGGffCACjCJVJ0YtYWn0HzQMH2dHyCJqWcB3naMBlJDdRJFTM2JrlHD/xjFHkyhmUa6ktunGdHD/nOjpO7WSoozEjtiUQiFC1ZA1tm59BGxiwM4yEDpHyaoqXrqLjL49CSkPowjgOTVB25y0km1vpf2GzkQJtLqqolpdS8aY1tPzqeYbqu12rQadEkNn/di0Djb3s+cl2MxjXnVGUIsBlH5nPnOvG8Mv3b6bh8JAd46JLxRWoa6kuLnhxNGDEFGjLrIDcmpkltB3ssvszXEQYiygWTqmk9S87bSXGUluEgEBegLI7Lqfn0ZfRBwYNN4wzKFdIUKDwshVEr7iE1p/+kkRzsxtcrIuqU3kh3fwgxl0fxpwHScd9vydQUU702svSsGKJr5YrBaO/97lt5M+dSLi62HWZ8rqGhNSpf3g3Y6+fRSCguM+VR2VxwoYXUtLnX2ZWI8b92O/9EEJStXoKnRuPocWT9rHap8gCjMoSlMI84ica3U9sbg/W1ZBobs48rnCEQGGUeEerq18KQbikklhvq/374uThvMJKhvrNfRRxwV1D5wIszjW+cnbmloOWM7BoXg39iXY03eOPtXMbHafTCyLK386p9q3dkjkosy8buPiNHy28OPuzAQxQGhnD8pq76Ym3sKX5QWOpAMfz+oKLNYcXXMBz33g8YcwlJJL9NDdtc6ktacgxWnHFZIqrp1K/+wnbjeQEl/KZywhECmjf9KxLbUGHikvXoPX30bvevWZRoLiE4huvoecPj6N1DxhuIh2krlB05RLyZozj9LcfI5XCFd8SLI8y51+u4uAvttG8szUdmKunoSRFgGv+YzHjLyrn5+/eRFtD0lRbrLWJFJe7yAkv2VKghzPV8Z979awSWg902RfNDBeRFZB741xantwLqZStRli1W4SQFF+1CDVaQM+jL6ZXgHYoLcYbCSWvuYHIjKm0/ODHaH196dWfFWm4i5wQki0Y1zGv1z3U//J64oePUf62u+1y9GlwcbuGZCJB/9rdFF+1CHC4vnwgo3d/M31H2phwyxyHEuWvshhzeQJykRnNeC+yf8ezZR+VLZ8IuqR323F7m1tpkSiKIDx5DInjDe73wDwfwbpaEo1NrgUmwTiPocoaEh3Nrn6ASEkVWnyIVNwZCyOQAvKKqhjsbxtxxe2cvfrtb+dK+rds5q9QNFIDSHrjTuLP/i0SQhiw4h2jZELOOastpvm6iM5GbXHuN0xhu2FVF+s5s8HLcADjmsN4XBgqZ0Xt3ST1GBubfkciNeg6TuE99mzuMifEONSWcCCf8XUrOX7qOaSWzFRbHCnQ4+ZcR1fDXgbaTrlcREhQlQDVy66lY+fLpHp7bdeR0CGQV0jZpdfQ+cwTZjE6YQbzCqKXX4JaHDVWgrbVFgFSoerdtzB0uJH2v+xA0w1gseJbKlZPY+z1s9j8+WcZ7E2aSks6oygpVTQ1yE1fWk7JuAJ+/u5NdHfoNri4F1pUXfCSLQV6tEG5NbOK6TjSC46aHW4XkdFqr5mBNpSga4MRkGu7hzC+PmpIofzuK+l9fD1ad687KNdZeC4gqHjr61ALC2j58U/NGi9Ot08aXjKaE4IygEWSbG2l68FHKbnjRoI1Vb4Xa6drqH/jPgCiK2fZF/1srqH6h3dRsXQ8RWOLzXHZVRYnsDgBxWtOcHGqLdZj9/Ok349QXpCypRPoePlQxrE44SU8eQzxY/Xu129aaEwtqfZ29EQifXTmvqGKauLtLS7YBAiXVAKCWE8r0vObmVdURXyoO62yQsaYv6bpGAHzZ91ySstZWw5aRjDpqBAVVCMUhirojNdngIhwjBvOsrmIYHhwOV9Qk2G+riU/mPAHFxiF6gL+8GKNHQ28mKpLJFDE8prXAoJdbX+xlwVwgYvTRTScmwjcQbnA+NrVpFIxmpt3ZKotDjCJloyntG429WZsi1dtKZ2yiFC0nLZNT6f7TbWlZOklKOEI3c8+bTy/CS5CqJTecxsD67YSP3QqDS5SoFaWU/G6q2j++dPEWvpcaktKKkx7/2WIYIBNn3uOpCYctVvS4CJDIW7/+irUkMIv37+Z/n7sdOb0raG6JB1BuU5z9lnqTDZTkNTMLEZL6nQc63WpLNZ26zZcFKL68mm0/HmXCSrOYnMGwEQvnkOwtpzuPzyDN6bF5aYJB6l871vRenpp/9Vv0KWWTnu2VBVPgTkvrNgrRpvuJ6lrtP/sN4SnT6bw8pWO8TLtGsK4tVxDfc9tI3rxXNRIwH5NkOkaSvUM0vLcIcbdMtc4H57zMxywGOMzM4e81W+94OJ6Hh81pvLS6XSuP4pMWplf6W2WWhSZUkfiRKMRZ+aYQwpJsK4GpCTZ0mT2WTtDuLLGgBZPvxIIEioqY6inxe6ztucXVQKSoYH2dFD1BbRcTMuFsxy0nIkpgvKCibQPnvD0K/Z2123G/j7uI0/8i1CEb8uwLHEzozV/RWaYbCLv9rMBFzg7eHHtLwmqERZV3URXrJFjPZvckDLc8/scozMo15g7zJiapZyuXwu6nl1tkZJxs6+lp/kg/a3HM9QWRSjULL+ert3rSXZ1poN2dUOJqbz6JrrXvUSqo8MBO0btlvwlC+i870/IlDTdREY2UfS6FYTGV1H/3b/YRecscBGRCAu+cDMdu5rY/aNtHqVFsf/DCxSFufM7FzPQleCX79tMX6/0BRcLXmy3kQdgnAG41r5+VlAeobAyQtv+LtcF0+siUoRk7E1z6dp6kmRLZ1qFUIyfd0WRKKqg4t7r6HtuK/EjJ9NBuXYDK75FLSmi6n1vI3bwMM3f+A6JtrY0lChpMHE1lyLjjmvpfuxJUh2dlN97l/GPh9PN5HANWbeplk6G9p6g+KpFrqwh4QAFq7/pyX0EiyPUrJ6YoUBlzQyy1SpHwK6jGX3u9aCcZkOMI/3cGddSuXISejxJz/YTbthyKi1TxiLjSZINpvJsfUkAtSAftaSYRFOTyzUEEKqsJtndiW5WuHUG5EZKqoh1t2YoWIFIEYFQAYP9La7+C6m25OzCWA5aRjLF/GKYX47qohl0DZ1mMNWDK/XZG9ciFFCEr4soQ205RwA5IxvOReQalwU6hhnjCy7DwYufDRe063jegmAps8uv4Gj3RmKpftd2XzeRI+ZlJLVlXM1yBgbb6O0+NazaUhito2zMXJr2P++rthRPmEO4vIb2Lc+lXUTmbeGsBYRrxtD19FOmAiNs1aX09ptJtbYz8PI2A1g0c20iVKrefSv9O47Rte5QhpsoMs6o33LwF9to2tLkABbFlVGUV5HP6354KX3tcX7x3s309+FwDbljXZzw4mwwehdR+eQo3afSmR/pi6X7Al06t4aCSeW22uJdSFEISeHCyRSumkfHTx4GqaVVDgdgGE8CwbE11H7yIyh5EZr++3/pfflldHScAbkZzbNWkZQ6fS+upfep5yh782tRS6L+KovVMPq7H3mZ8ORa8qbVGV1O5chx4dfiKU7dv40Jr5lPICBGpbJY5844l+n5VEed1Qx4cbiFsqktLhdRYYjyVVNpeXSHyy1kueuEALWskEBlCfH9R11ByNa5CI8fR+zkyXSfeRuurgMBQ8317n2AvPI6BjtOAw6ANK2oZCy9XaeMJ3+llOdRmqGYKOfQcrB1tpaDljMxISjJG0thqJJTPTtc/cbNKFxEfmoLGOAyWnjxjnPMM5z7KauNBCjZ1BbfoaNQOOznzaK6ZNvHAy51BbPID5RwtHtjxhiXm8ixz2jUlrxQMaXFk2hq2Ya1enQ2taV68kq6GveTHOhxqy1mwbmqRVfRtW8TWn9/Rgp0xRXX07d9C4nWNncGUlGUoqsupedPT6LHkqbSYqgbwTHVlN68iqbvP06yN+F2E5n1W8bfPJctX3iOwZ6EKzDXCS4FtYXc84NL6e80FJfBAd0O3HWqLk548UuDzlYpN33R1SmqjtDXOoRKupy/c5wda6HA2Jvn0/z4bkgmfdUWISSVb15Dqq2b3ic32EqLsJQWS3UxJkctK6bqA++g9Pab6HroMVq/90OSPV1pF5BTWXGsCi2lxsD2nTR9+et0PvgIZa9/DfkLZhvzOgHJoa5YAozW1Uvvc9upuPMS4/8V0iqF1zXU9Ogu9ITGpDvm+aosIwGLim43wPXYON/+4GK8N+nn8L5vAOPuWkzXxqMMnepwg4v9vgjyF85gcMfB9BvvAI3w9KnEDh9xn2MBaiRCuKqOwfqjGYHOBbWTGGw7bRSfcyo0AqKVU+jpOJL+6nqg5q9p8lziWaT1T0jOzsZy0DIas9QWQKgKE0ovor5vNymZcriEfFxEo1FbvP8xDAcvftsu8H8co66SlA1c4MxcRk5FRcL00lXU9+1mMNmd3U3knSeb2oKtblNbuZDWtj1oyeSwaktJ5VQiBWW0Ht3oARqjlUyaR7AgSuf2l1x1XYQO+ZOnExk3ka6nnzT70kG5xVddhtR0+p5c63ARGW6i0juvQERCNPz0GVttcca3TH3PJaj5Qbb+90skdZEOzPWAS351Aa//0SX0tMb45fu3MGSCi9Nd5IQXJ6C4C88N/xmM1uTT3+Iuz64I6esiqlszAz2WonPtIZfaYgXmKookWFZE2T1X0XX/02hdPbZbxhXf4gAXVCi8fCW1//7PyESCxi99jd4XXyZ++hSp2IBZhE6ayorGwJbtNH3pa3T88rdEpk+h7gsfp/DSFeZ87udwqSzmxbz74ZcJ1pVTtHym7QLyC8AlleLk77Yw6Z5FhPKDLpXFFbviW+NG2qCy/5Hj/OmDL/L7tz3DfXc/wU9ufJTvXf5Hvrnsfh7/+FoSfXF7HtcijM77LmXGOL7SObVE54yh6cHNZn9m/Ev+wunE9h+3V9p2KieR6VNJdXaS6Oyw+8CAjfzxkxk8fczTL8ivnojUdQY76+2x1u9mccUUBvtbiSf6LnhMSy7l+cJZDlpGY0KYsrHxQauNzkYgaOzfP7yLKOtcinnXAS7Z4MXZvObZZ1Qqy0ip1yMoKaMZk7XI3XDuIjgz1cW0yrzJFIerOdK1LmOsOFOgcriSKstnI6VOe8d+f7XFrtsiqJq0nLajGyGl+ca2VC68go6dL6PF4z5qy3X079pOornFUcQOlFCE4pvX0PvnZ9E6+9LQIgUiEKLq3bfS/fR2enacygAXwmHmf+o6mtee4PijhxzAYi526Cj3n1dVaIBL0xC//OBWhgalDSxO1cX6kfXCi7M/2w9xUVUefS3pSqf2xdf5H755EQ0Vhqi5egbNplvC6RqyFAtF0SlZs4RQXQWdv/yz+fXwxLc4wcW8mAZqKqj+6PsoXnMFPY8/RfNXvkn9xz/D6Y9/mqavfIO2n95H4399lY5f309kzkzqvvBvlN5zK4GyEnMeP7eQW2VJ9fTR8/QWQ2VR0yoL5q1TZWl77iCpgQQTb52bobKkz5MbZJyuIJnSeO6/t/LUF7ZQXJfPpFXVzLttIqveM5s1n17Cjf+9ko4j3fz2nsdp2paOBXG6iTJjW9zp1rW3LKDjhQPG6ubO98JseXMnIoQgtu9omvgxg3FrqlCKiogdPZKRQZQ3fjJDDSeMIF7rPQICkTwiZTX0txw33fLWfFBYUocaiNDdedR2EV1oeMnZX99y0DKSOUDAim1R1RBjixdwqmebcYF2pD67XER+aotlXnABf3jJZiONcz7XmbiMzia+xgcOhq3Oe67g4lFbppWspnHgAH2Jtuzjh8skgoy6LUElRFXFHJpbtrtqtPipLdUTlpCM99PdeMBVHddqZdOXIBSV7l0bMtSWggnTyJswma6nn3CpLUIXFK1cTqCynO4/PG7GvKTdRJFZkyi++iIavvMoqSHNgBZHfEvB5GqmvWs1u77xMt0ne21gcca5aBhj82uKeP2PLqGrfoD7PrSFwSFI6gEy3UT+/y16FRijzkv6MxetidDfMoRwuCss87tgjrt1Pj27Gxg60eq4yOOokgtqUFD5zpsZ2LSXwV2HbDCxlQ+fqrkIICCIXncF4/7ns4z72uep+bd/ouz1d5C/cB5KJEz+onnU/ee/U3rnTWb8iuODZgX6Ot1CijS+MuZFvOuBZwlWlRJdNTsjANcFYeicemAbY2+cTbgo5KuyeLOFLFPRiXfHePD9L3LoydPc9X+Xct1/LOTid81k2RumsODW8cy4egwzrqrjDb+6mkkX1/DHdz/Hxu/uRKZS7vgWH7XFFZC7ejJS0+ndfNRx7On/1ZRIkMicyQztOGBDnA11iiBv2lSGjhyxXUCWSydv/GT0RJxYW6OrXwoorJlEX+uxDPcQaoDi8kn0dBxN918gpdn6nJ9tG2kB0pxlt9yZG8HsIFwPjIwrXUR/spOO2ClHv8NFJDLrs2S4iRzg4gsvwzWPuff/O39bRxMs7ICS8vBYyiMTONK1PmPbqNQWpwJku4skNZUL6eg6TDzR51JbjHFptSUYKqR8zHxaj27AKvfvVFtUNUjF/Etp3/4CUtPcBeckVFxxPf27dxJvbLSDcZEgUCi781YGNmwjfrTe4SIyft3L37AGmUjR9JsX0czUaKebaOxrFlM6t45Nn3uWVEL3pEAbtza41BZxzw8vpePkAD9+8zp62uL2j6ufmyhzbaLsF4+iqjy0pM5QV7rGhnVRdrqIwLh4Fk+roHh2Dc2P7cRVs8WhtgghyZ9WR/GapXT89BFDCXDGtzjBxaGOpONXJCI/QmjCGPIvmk/0+isoe9OdlLzmOtTiwnSgLmQCi49bSBGS+PF6ep/ZSvXbrkUJiLQyZLpVnCpL97ZT9B1rZ/Kd8zNUFqcryOsWUtFp3t3Or974NLGeBG++7womLin3xMKkY13C+SprPrmYm7+6kj0PHOHBtz1F2742F6xkU1sAQvlByldNoe2ZveZ4d2C0EJC/aDpDOw4a5Qc8LqLw9KnEjhxB4j7/gaIigmWVDJw+6upHQGHtZPqbjyN1LSPmpbhyKt3tR9GRZ/bP2Hk23UDwc2g5iehs7e/86vZXMGf2kHW2hCAvVEJd0WwOd61zSJ/GuAwAMdWWdJ8HXLLByygsE3gU7wDfbRnH+Ne24dQWyB7jksUmFy+hdfCokUmUbbyP2uI04QGXsqIJBIP5dHQc8Ixzu4CElFRNuIiepoOkYgNptcWhupTPXkFqsI++4wcc+xnb8sdNJm/iFHpeesER7GuoLZGpU8ibP5uePz0JOiawGGqLyMuj8i3X0/HwRgZPd2W4iaSiMPvjaxhq6WPXdzeR8gCLE1x0KSgaU8S9912Boir88I1raTnWb4OLV2mxLJvi4rTBzjhKQBAuCgLYgaBec/6XX3f9XFqfO2BUyLW2edQWISTlr7sSGUvQ+8iLdp+lgNjg4kyHdsKLpxqu6771Rrv2Ja3mKG63kJ5M0PLtP1C0cg6Fi6ZkqCyux+gc+8k66q6aTmFdNNMFRCa8KEIitBQbf7CX373tOcYvqeCNP7+M0rH5aZeR0O1qxF54mX5lHW/6/RqKx+TzwJuf5OhTJ1yw4o4vcmQsIam7YR5dG46QaOvxdREVLp2F1t1H/MiJDADJmz0drbeXeP1pt3ICFEyazsCx/RlrEBWOmYaeitPXdiINLKaV1swkNtjB4ICRZj2Kf0ly9iqzHLSMxhzg4qwLMKV8Nb3xFlqHjvkH5Fpqi9dNZI1zKjgeoHA2pw23bVhg+Vu0cwUXx/2yyDgigSIa+/ed0XM53ULGc1r9IIRCZelM2tv3Z3cRYfQVV0xFDebRfWqPDTIWsCAhGC4gOmU+Xbs3ZCgtSChdeTl9u7aT6ulNqy3mmJIb1xDbe4jYgRMg3UG5+cvnkDdjHE0/eQpdV5COTKKUrhAoK2Lef1zL0Qd2c/qFk2YlT8V1axWf06UgUp7P3T+4hOrpxfzoTes4vrXTSIX2UVac8GL3+4BL+7FeSscXogYVT1qunnGhti7Q1ZdPRY+n6NxwJOPirwppF5wLFOZRce+1dD/8IsnmNju+xQUultKiOO47XS5OUMGx3Uelsed2uImEkHT++inkUIKad9/gjr8RHteLkHSsO0rv4VZmvH25r8pinRv7HJnwse47u9l630Fu/uJSbv7CRUTyVRtUVOscIt19Dngpro5w8/+sZPUH5vHs5zbQcaAjDStZ3gchJGWLx5I/roy2x7b5uogC5UVE5kxmYN0O17mVQhIoLSE0fhwDe3YbXxfznEkBhdNnM3DqKFoillbAhCCQX0hB1QR66vel41rscv6V5BdV09Gy54JmD+WKy104y0HLSJbhGrJuBfnhUsYWz+dw58um/CncastowMWa13rsUF7Sh5AFUizz2ScDWEajsgy3dpJr7r+xDCaM38kxhXNosKDlPLmIKspm0NlzFC0VzwjINZ7XDMgVCuVj59Fxeoc7rsUBJuWzltN3Yh/Jvm7XdqFDwbRZBEvK6F33clppMWNcQnV15F80n56HnkRq0hWUi1SofOsN9G87QveWo5luIl2hdPFEJr9xKdu/+Bw9Df2uwNykrtolyS1wUfJC3Pq1lcy6biw/f9dGdj/RbPxIO/zxvi4i89b7g9x+tI+KyVFXn7fgmTcINVwUourSabQ8scfjRiId0KoY8BK9dB6RWRNo/X+/QY/H3HDhVFpcqovjsfWGuoJ4ccfD2G6nNAwJxTiOwd2H6Xl8IzUfuJVAUZ6vyqJa93WNoz9ay7ib51BYV+RRNvxUFgM4jj1fz9ZfHOSWLy9jznVjMkDFCSu+feY8ipAse+sMplwxhsc/+gKxjkHcQbmZTRVQd9siWv+8E5lI+LqIii5ewODG3ZBKZYBe/vx5DO7ejUS641omTkWoKgOnDmXEtRSPn0P36b324/Q2QVntXNqb9mSoMH9NO5d4FudyGGdqQoiFQojHhBCnhBBDQohOIcR6IcQbfcYuFkI8LYToF0J0CyEeFEJMPucXf4EtBy0jmgUUHrXFbFPKVzGY6qFx4GA6INdUUXwhwwEuruBcJxyBG2BGaq75s8xjbx4FsGQc8wWEkjNQW6rzpzKQ7GQw2eM/1np8Bi6i8uhkQNDZfTTjMJxAAlAxZgE9rUdIDvXZGUY4romFdVMIRcvo3rvZva8ERSqUrriMnk3r0eNxU9FxqC03rCF++DjxfccygnKD42opvmYJzT9+kmRcutxEUgpSUmHyvcspmlrBps88QyIubbBxpkI7wUWqKtf8+0Iuee8s/vCxLbz88+NoEhe8DPcj7HzcfrSX8slF9mNnMK5TXbD7zIv1mBtm07n5BImO3uyuFvMrVPvhO9HjCdq+8wCgeVQRMpUTV+oyHjeRE1ZwxLC4XUQC0Af7af3uHym5fhmFCyf7qixOGGh5Zj+xll6m3bskrbI4QUU44cVw7fTW9/HEpzez8h0zmXZJdXZVZYQ+212kwJpPLyG/PMIT//oiJFP+qpcjILf2mllIXdL5/D5/F9GyWciUxtCuA47zbLT8BXNJtrWRbG919SvBIAUTp9F3dF/GPtGJs4n3tDHUZwbXO8ClfMxcBnobiQ11XlCl5VzbWVoJcBr4BHADcC9wAvilEOKT1iAhxEzgeSAEvBZ4GzAdeEkIUXm2T/63YDloGcHsOgEulcW6FYSDRUwouYgjXWvRZMrYKVtQrrN0v3nfBhcvvJwpKPjt46PYpLcNM797oRHP84xOZTmrInfnaIVqGWE1n46hk/4DzsJFpKohykqm0N6R3UVkwUm0YjLBcCGdp3e74lZsMEGhbOZyuvZuRGp62k2EsT26YAkIQf/WrZ5idoJgdTUFyxbT/ccnkJrFW+l/Q8vvvhKtd5C2P6zNcBNpuoKuBJjzH9cx2NjLnv9Lx7doZrErL7ikdAVdqCx/6wxu/q8lPPuN/fzs7RtpONCX9YfX22e4ngTtR/som1Kccd5dReZ8XBPlC+vIq4nS+uRez3//uOBACEkgmk/dx19PbO8xuu9/xqWGOFWSM1JaTFBxAou1UKP1vO0/fgw1P0zVm66y+52AZdSZSddlOfazDUy8cyH55fme1+QAFcc50OIpHv3X9dTOLeWS98y0QeSMlRYPuITzFG79+ir6Gvt56UsbjfDQDLUl7V4K5geouX4ezX/aarzLHheRUhAm/6JZDKzfkYY7jHMYqK4gUFnBwL40nFgf3cJps+k/ut+uVCxNNSVcWk2oqJye0/scwGK4iPJLxhDOL6W9ee8Fg5YLZVLK56WU75FS3ielfE5K+aiU8nXARuBdjqGfB+LATVLKP0spHwRuBCqBf/nrH/n5sxy0jGRWLQCPyuJUWyaVLUeXOvs7n3MVQ8rqJoJMcIFM5cQJMCM11zFnqivDAks2t9ArDSyjHTdSNpFVBVcIyiMT6Bg65eoHRu8i8t7XJRWlM+joPIS03UNuF5ExPygIysbMo/P0LlewrtNdVDZjCYm+Lgbrj2WkR6uBECVLVtG97kWkLjNiW4pvvIbEyXpiew5lqC2ioIDKt91A2/0vMXi6w+Um0qUgpSuEy4uY98lrOXr/LhrW17sCc9PKi2qvN5TSjbToWdeP5+0PXEkgL8AP736Bx7+6n9iQ8eK9AONVXfY/0UCsL0nVjJKspz3bKsWqAnXXzaH5ib3GuScNC5lqi05kfBXVH76L7odeZGDtzjS4eIBjtEqLs/aLdd/aXwhJ34vb6N+4l9p/uh01EkRRdDveRlXMrCfSrq+GP+0gNRBnyusWeVSWdIqzq2y/1Hjmv7Yy2BXj1i8tIRhwqCa+8StGCyopf6XFAy7F1RFu/t/VHHniBDt+sidDbQkobtVl7G0LGDzZTt+OE9ldRNsPoPcP2CAoFYlQBPlz5zBoxrU413TKnzoLbaCPoebTrnWfhCIonjCH7lN77LgW6dhWXjeX9qbdF2ztISOm5ezL+L8CMS3tQApACBEAbgL+IKXstQZIKU8CzwGvOd9P/te0HLSMYH2DzW5w8VFbgoE8FtTeQkPfPk737/F3Ew0HLoonZmU494+fZRnvH6zrhBLlbx9YslkW1aQkXEtPonnksU4XUbax5v2SovEkkv3EY90Z03hdRKXVM+hrP4GeSprbpQtcQvnFFNROovfoHrvfhh8dihevINnRTvzE8XRogKW2lJWTv2QBvY+/6KmSawTlFqyaT/6sCTT96ElSmkAz416cbqLSxROZcMcCdnz5eWI9CTsgN+lQXrzgkpQq0Qkl3PHNVdzx9RXs/nM937/reY5t6crqItIR7HuygYc/sYXL/3kuZROL8DNnJpE3ewWg5sppDDV0M3i8NavaYgTlGo8LF0+j/A3X0Pb9P5I41pABLjjgQzgVGOEAFUuhEe59LWBRhKR/817afvgIlfdeQ97UWl+3kNWEkKS6+jn+iw1Mf9tyuy6LM/g2YEEHkoCioaKz/b6DHHrqNHd8fQVF5cEM+HCBitBQkXbzAkw2cKmbV8b1X1rJ5h/s4sAfDmZVW4SQFNRFqbxsBk2/XefrIspfOAW1MJ+BjTvdECggf/EC4idPkurpcgFIsLiEvDET6T2409UvBZRMnk9/y3ESQz2ufimgYtwi+rpOkhjK/E7+New81mmZIoSY42lVIz2/EEIRQgSEEJVCiPcB1wL/bc0J5AG7fHbdBUwVQkTOw2m4IJaDlhGsoWWLQfMOcPFTW0rzxzKr6ir2dzxLV7zJoZsOAy7WY8iAl4w05tHGtDAMrAwXdHuOwDLqdO2zcX2dgRWHahhK9RJPDfgPyLI0gHCqMp7tBZFyVDVMb1/9iFlE0fLJSKnT337S10WEhOKJc+k7tsdQUxxjhIRQtJT8KTPo3bTRVFqw67Ygofjqy4kfPELiRD32v63WIUiFirfewMDOY/RuOoRuuoZcbiIEU96+GjU/xLb/eZGkZsCMM5PICy7O1Z6nXFbHOx+8mnGLK/j529byx09sY+sfTnFqZxexQc1WXfY/2cgfP76Vyz80m+Vvnp7xNnjTnt2uovTFsnBsMUXTqmh/wbigetUWS81Ir4cjKb1lFYUr5tD8tV+hdffZBeCE4sj6ccCKcCgpThUm3Wd9bI105e5HX6blf39H2R2XUnbTcntNJG/cjVNlOfrDl4lUFTHBWf3WFUOSdgup6Jx4uZGXvrGLGz67mHHzin2gw1zHyQMpfhCjmIATFBpBobnARRGS6VfWceV/LGXt/2ym81C7r9pi3Y5/w3J6d51mYO+pDBeRCCgUrl7AwNrtNvAZXygITRhLoKyM/l07bHXLApGi2QvoPbjDrL1ifqQVQX7NBIIFxXSedAKNoboUlI4lr7CKjtb9/t/zvx97CNjjae8bxX7fBZJAK/B14ENSyu+b28rN206f/Tox3oHSczjmC2o5aBnBuntP0DfQZINLNrUFIRhXsogxRXPZ0foIMX1gZHABx2M3vEAaBM602eZXjG44dQXcQDHKtY7+FmDFsqJgOYpQ6Yk3GR1n4iIaJvU5WjjGgJYsZmURBYIRCkvH0tt82FOILj1fdOIcEr2dJNqbMoAGCcWLl9O/dyf64FBabTHrtoTq6ojMnk7Po89lqi1SEBpbTckNK2j+8ZOkYilfNxGhEPM+dT0t609y6Fc7jX5HJtFI4BIqCnPdZy7inu+tZrAnyUvfP8jP3vQS/7PiMb59/VP8+n0b+OO/beHyD85m2ZtnjHo1aMh0FSlCUn3FNNpePAR4FxS0lI00sFgL+VW9+2YCpYW0fv03yKE46diUNLy4U6L9twlHH3qK9p88Qudvn6bmQ7dT+dpLUBSBMzvIT2Xp3X2apif3MeefL7NXcnaqLF630EDLAH/+xAZWvHU6828c4wssKtIAEA+8+KktzrEWvFhzGf2SebdNZNJlY1j3xQ0oMplVbSmaVE75xdNo+t26tAvM6SK6dCGJY/WkmlptKJTCcBEVLF5I/44dLheRVIwVz1O93Qw1n/S8FwqlkxfQdXyHy0VkVcKtHL+YzuYsJQ5eYTu3wnJGM+1WYK6nfXcUh/BFYClGnMpPgG8LIbyxKsP94I3CX/63aTloGcGiReM40fCi+YUZXm1BCGZVXUUkEGVH26PoQsu4UGeAi1d18cLLmZb2Hw5URlJXvMDiN7fntQwLLNlibs6X+bhyFKESDVXRE2/JstOZz4kuXdDitxYRNpRIiiun0tN6xKGguF1EkWgFkbIaeo/uzXQRSSicPgclFKZ/5/YMoDEyia5haMceEicbDZXFAS1SF5TdeTl6PEnbHzeYAblpN5GmGwBSOKWKuR+7mn0/2EjD+nobStIp0EpWcElKoyDdhBXV3Pmt1bz/iev455dv4k0/u5Tlb5lOyZh81vzHIpa9ZYZ9KnVPbqqzEJ2VTZThKjJPavVl0xiq72bwWGuG2pIZlGu4i9RIkLp/fR2pnj7qP/4tYnuP2jAiLIHToaa4VBXrq2nFtgAyFqP5K7+if/0exnz6zRRfOs+hvmCqPsZF3BnLgpbi4DeepW7NTCoW1mVVWZxuoef+ezvlE4u44gMzswKLE1Sc8OJsfvDiBy4qOgFF54qPLaTrRA8H/3DI465Kx7YEhM74NyynZ8txhg43ZihM4QnVhCbU0r92myPg2bjNv2ghifp6ku1tDuXEdBGNnUTvgZ32StvW9tKpixhoO0l8oNOxMrcBMBXjF5EY6jnz7/h5ME1ifJ/OutlTHZVS7vW01pGeX0p5Skq5xQyyfS/wA+BLZmaQuUKlrbg4rQzjl6T7nE/CBbIctIxgdbXLaG3fy8BQu/kFHF5tUdQgC+tuZTDVw77O5zPiW8ALLh7VxdXvAxmjLe2fbaHF0cDKcHDDCLDySoHKaEr7m1YcrqXbUlosG6mQ3QhjiwrqDMVtuOOwlJLKKQx0nkZLxhwwg9uNNGkuvcd2u2DEghdFBIguWELvlo2uei2W2hKeONFQWx55xnQdCQNeZLpSbsUbrqH9Dy8z1NJjZxJZwGKV+a+6YiYT717Mls8+TfepPtNNlE6FdoKLVYDOSom2QMaCmVBhiLqFFSy8azLX/PsiFrxmIoBLZXHCz3DmTYkuHBOlaFoVbS8csi+SiudiqXjARQhJsCLKhK+8l4JF02n6r5/R/uOHkLE4zqq5nv85XDEuFnhoXV00fPZHJJs7GP/Fd1AwZ7zLJeRWG4z9Aia8NP1xG/G2fma/bxUBoRFQdAJCNwDFpbYY8HD0uXqOvtTEDZ9ZREDFBpagkkq7dxwAYu3n14Ii5XIVZQOXoAlLxTV5rHz/fDZ9dztDbf0EHS4kRRhgI4SkeHoVJUsm0fKnzWllyRGkXHjpIgbW7UBKI/Xc+AJAcEwNweoq+nbvsGHG7SLa6c4iUgSRyrGEisrpPLkTqbjVlnBhGQUlY4f9LP0D2SYgAEwGjgJDwDyfcfOAI1LK2F/x2M6r5aBlBItG6yguHs/x+udtZSWr2mICSiQYZVH1LTT07eV0326HopJWV2xwAbfqAm5Q8FvteTTNab7qy3mElVdaUTlDKw5W0ZtoHQEw7Ku8b5yLt15LYV4lmhYnkTSXCfDGtTisqGwiUkoGOus9Kkz6fnTCbIZa69EG+n1dRNGFy4g31pNoaR5WbUk2tLjUFusXvfCShYQnVNPyy+dNYEm7iVImvOgIpr59FSWzqtn8qSdIxjRXKrQTXOwKuh7VxQkvfg0yVZbhzA0s6ZL0VZdOoXPDMfuxBSh+biKnq0jND1P1zhup+9SbGdx5mIZ//w7xo6fTXgifOBQLVhIn6mn70UOc+si3UCIhxn/xHYTHlLuAxXpOVcmEqXhLN0d/tp4Z71pJXmlehlvIqWYoQpLsT/Dcl7ex/E1TqZ1R5A66dUBHGlx0u2BctpYeo/uCi+p4fkVIFr52MqUToqz78gYEOkFFy8wkEpK6WxfS+dIBUl19jnNuBEQXrpqP1tNHfN8RO3bIyiIqWLSQgW3b0KV0uYiKZi0g1dfDYMMJU00BK1OodMpCOo9tc6kzltpSNtbvuvzKm34OmUOa2z10vuwKDKf2MSllCngEuF0IYUfACyHGm+MePN9P/te0HLSMZIrCxIlX0dK6a2S1xdFKCsYxu/Iq9nY8w4n+HW5wATe4eFUXr9totG6ikRQYL1yMxm1EFlj5GwMVwIaHomAlST1GXBtw9XvHec0bgOu0ULAQgGRywB37Ys+Z3l8NhAgXlBLrbTXnxQUuQkJ+xVhEIMRA4zGXymK1SEUNocpq+vc41Rhh34YnTSQ8ZSK9T77kVlvMFGiEQsWbrqX3pd0MHG5yuYkk2MG5uhJgzieuJd4dY+c319swc6bgMlyDtMoyWrNdRuaJK50/hv7j7WgDQ/b2jMBXr+vIsT5Q4fxJjP/Ke4lMH0fDp39Ix6/+zMD6XcSPnELr7gWpIYRExmL0PbuJ+k98j/p//z8SDW1Uv+smxn3uXoIleY45HbE0ptrgdAsJdA5+7WmKp1cx4ZY5Wd1CQYda8tI3dhKIqFz23uk+cSdO6EjDiqGipPtCIuVRWzQbXoIirdao9vNrNrwEhUYoCGs+s4TT65s49vhRF6ikK+fqVK6YSLgqSvtftjrOOyiKJFhaQP7imfS/sJk0HRotf/lFJFtbiTecdkFIIFpM/sRp9Ozb4uqXirFK+lBnIwNdjS6lRSqC0jGzR/2ZOp+m418ZetTtLC+9QogfCCG+KoR4rRDiMiHEHUKI3wJvAr4mpbSWuv8MkA88KoS4XgjxGuAxjNTor52HU3DBLActI5gUgtKyKRQXj+fE6edHrbYgBGNLFjK/6noOdr7I/u4XjZ9fC1wcwbm+8GKN9YLBqN1DIrPZ24ZxPdm7+wT2jhZUzjDb6ZzMBzQKgiUIVPoS7RnbzjYYNxiIAIJkIktWkj2/AS+Rwgpi/R2uWBene0hRVApqJjDYcNytopC+Xzh7Af17dqYLsVpQY2YVRa+6jIGN29C6+9Jqi/mLLnWFyMyJFCydSctPnyKlk+EmkiZUBIsLmP+p6zj16D5OP33UgJlRgIsV2+IFFPv0edSYdN+ZfwZKZlYhAir9+5sM9w7YnocMtQU3uKTXKYpQ88HbqfnQ7cT2n6Dtp4/S8KkfcPK9/8Oxez/PqQ9/nRPv+R86fvs0eXMmMuH/fYDxX3gbxZfNRw2pttvJGXirKm5gstxCrU/tpXtXA3P/9UpUxR2c63ULKULSsLWFXQ8e56bPLCCcp/pmCVnA4lJRHIpJUKRQTDhx9nvhxesyUkz1xhpbNb2YZe+aw4avbSbWMWCrLVZMiyIkqgp1r1lM66M7EKmk20WmSIquXMLgtv1ofX2G2gJIRRKsKCM8ZTJ9W02gUbBjVYrnXUTvgR1oWjLdLwTh0iryK8fTcdTI5LSUGDub6ALYBazTsh5YBnwHeBr4EVADvElK+TFrkJTyAHA5RobRA8DPgCPApQ6w+bu0HLSMZAJDbZl0Fc2tO7OrLao/uNQWz2FJ7R009O9lR8djaFJzqy7OOBfIHtfiByHDNddr8HEdjRZUnM/tZ2cDJa8kxACKUCkMltGXPH/fTSEUgoF8ksnBdJ83GNdheQUVxPpMaMoS11JQM4mBxmPuYF7H9qI5C0m0NLldRHb6syBv3mwCpSX0Pbs+Q22RGBBT8cY1DB2qp/v5PSas4HITWfEtxfPGMeUtK9jxP8/Te7LHBpd0XIujgi5WgG5adXHGt3gBxs9NZCwHkAYgP0sH6ErUcIDo9Cq6dzdkuEC8QbmZqdHu+9GL5zH+y+9myk8+zpRffILx//t+6j72OkpuXkX1+29j8g8+StWbryUyriJjDgs2nMBiVb111mQ5/N0XmPqWZUQnlGRVWSwQIJ7gqc9vZeHtE5m8rMJVg8Udj5KurxISVv0V3QQVI0bGaoZSY2xzwosfuASVFHYVXfN1LHvLDKJjCln3pfUIaewXUHTXa6m9bg4ypdH1wl6X8iSEJH/+VNSSQgbWbnMQNyCgcNkSBrZvR0+lXIXmCmfOQ2oa/cf2uQrNWWpL57FtdpyMC1z+gUxK+VMp5aVSykopZVBKWSqlvFxKeZ/P2K1SyqullAVSymIp5WuklJnrkfydWQ5aRjDry1NSNtVQW+qfRyr+aoufmwghKM+fwPK6e+iJt7C57Q8kdDMGyifOJQNevABzLvEtZwMq3v5XAjheAXgpClbQ71VaRhuMm2VcKJhPImkoLb6uJAd0GEpLuysryNgvfb+gdhJDbQ1oibjLRWSNi1TUEKqupW/XDl8XkhAK0Ssvpf+F9eixhEttsW6DNRWU3X4pLT95kmTvoFm7Je0msiEDwcTXL6V0wRjW/ctjDLQN2qnQTpUlpaskHfCimzAzXHwLpIFlNCqLX4VcRUhK5tbRu7fROD8+aktGtVwywcVSXazAUTU/TGR8FYWLp1F67VKKV882VRWnUmPs5+eS8qonipAc+tZz5FUXMeV1C13Bt34qi4rOhu/vIRVLcfU/z3bEmLizf5zA4YQVG1R8AnFDJshYAOMHLvbzeJSZQFBw9WeXUb++keOPH3WpLZYrLFwQoPr6ebT8aTPC2maeVyUARZddRP8Lm5FInJlE+QvnI1MpBg7scwGIEolQNGMePfu2uvoRUDJ1EVp8kO7GA/Zvrw02F8DOLXPIaDk7O8tBy0hmFpUTimDC5KtpbjHVFhso3CqLn9oiFUFRuJIVY16PJlNsaPkdA6lut+LiAy++ADOa9OcR3Ecjun5c7qgzhJRzkWvPB7hYcS2hcsM9dCZZQ8PMhy4JBguMmJaR5pTY7iEpdV9wERLyqyeAgKGmk+ntTtVGQnTuIvp3bTcDfnE3XVCwYgkAA+u2ptUWU42x1JbSWy9GjebT/NNnbLeQ5SZyrgatC5V5n7qBcFk+6z/yKIM9SV9wsVw89mPbZZQ9zsU4hSbAMPyPtlM6d6ZBl8ytpWd/s7GSMG4lRtj3YXhwcWz3ZP04HyuKR6HBDUZW4K0zjkVVdNpeOEDbS0eY9/GrCAQUlyIUVLSM4Nu2A51s+eVhrv+P+eRHAxmBt9mARRXSgBJHlpDVkBrt9UPseqmLzoYhcz+Zdh055nOmS1vxLkHFuK2eFuWit89my7e2oMeSttoSMF1NRmn/hQydbKd/1wnXuRQColcsJtXSQeLwcftDLYVEyQ+TP38e/Vs3uyvdKhCddxF9R/eTHOq3wUUKQSAvn+JJ82g7tMEGGQQ+ePvXMWlj49k1mbv0nrXlztwIJgGpGuBSWjaFkpJJHD76KDrSUFxUj8pifsn8wCUSLGJ53T3kB0tY23Qfh3vWk5KprPDiBZisEDMKOMmY42whZTRuqdG4rLLZcHCULRvIByIKg+UMJLuQcvSp0iOZqgTR9OSoxoYjUaSeMtKeIQNckBAIhImU1jDUVp8Rz2LHtcxaQLKjnWRba0ZArpCgBEMUXrKCvufW2RV2rcUUbdVFDVL1rlvoeW4H/ftOu9xEVrPiW5RIiIVfvBUpYdMnHicekza4pFwKi1n+39nnghe/4EPhApbhXEN+VjAmih5PkRqIu4HF3O4MjPUDlzSUOL9yaTXF2eca75jbqMXiBhYrFTje3M3Brz3NlLcsp3RGZVa3kBV8q+jG2kLTr6hl1pU1roDYtPvGH1icSknriSEe/r8mvvsvx/nEbft464Lt/NOVe/jKu47wz1ft4psfOsyRrT0ESZnKS4qQSKXndWQkOd1EAUVn8ZtmICUcfGB/htoihCS/Nkr5xdNp/eNGw11G+vwFK4vJWzCNvudM0HAsRlm4fAmDBw6Q6us1gcXYlj9lOoH8AnoObHOpKVJAxayV9NbvJzbYmY5tyV3B/uEs95aPYHYxIxMIps28la7u47S077aVFZebSFHcbiIPuATUMBfV3M7cyjXU9+/h5aaf0zh4MB2k64QXZ5950T+ryrjeeUYLKWcLHtnsfMwxSisIlKKjMZTqMzqyrT9kpT37bfN2IRGj1KPVQBgALeFTDsExdaS0inhna4ZryLJwWSXBsnIGDx7ICMi1IKZo9QpSzW3EDx7PVFvMX/7IzIkUXTKfpu//BV3TbTeRphvOGGd8S6Aoj8X/fSv99T1s+89nSabSLiTLPZSUil3XxVJdXPDi0wAXsFg2mvgWAJkyAFQEjH2F40QpTkjJBi544WWEhrG8gKro9iKIrtgNx/Oipdj3X3+maFol09+0OK1GeNxHllsoKDQO/vkE7Ud7WfOxuS63UNo1NDywqEg2/aWTj992gLWPdKIqkotvKOZfvjGB7zwzi9/uW8Bnfj6FVELyhdcf4NN37mPDw23IpOEussDFUF+kr5uooEDhorfNZtcvdpPqj7vUFsvtNfbOJfRsPkbsVKsdkKuYqc7Ra5YzuHkvWn+fSyEJT59KoKSY/m1b0q4jAUJVic5bQveuDejmB95yExXUTSFSXEXbwQ22AnPh3EPntvaQc52unJ2Z5c7cSGZLlwaAFBRWMWHCZRw5+mcSqSG8QbnZKuU6wUUoCnVFs7lk3NuoK5zN7o6n2NR6P71W4KgXXvwA5kybZdkgJcs+ukyR0IYYTPXQl2xnUOs1fNSjfT7fczqKX5ozVVs8FglEESgMpLpGNX5UbiQp/Y/duwYRoASM9ci0VNzuy4iDkRAurSbe2WI/doKLdb9g6iwGDx2wx7ibIFBaSt7cmfQ/v97ut9UWU1GREireuIZkazedf9lqqyuWq8gb3xKqLGbxl2+hdeNJ9nxnvau2S4Z7SAozriWtvAznx7fdRDINM8OZFeOim9ASUNOfDfu//iz7OsEFcMGLX7PmsiDDN8jXCSFmrMupX6xjsL6bhZ9cg6oK++KeLfg2NZTk5W/tZvmbp1FaE8EqIOeuYusGlpDQbFeQTOr88kun+caHj3Pne6r4+qPT+MhXx3DXeypYcXUh4yaqBFXJgpUFfOIHk/jmU7OYvrCAH3/6BB+9cgfHtvcaEGRnIzncQ3YRO7N2y52TCOYF2PfrPb5qS+mcaqJzx9L64EY3OCqS/IXTUEuLGHhxC3bNFiERAUHh8mX0btqILi04MWq3FC9aQbyt2VXWXyoCVEHFnFV0HNqIrqfM3+YLQy1GAt/wkD58y9nZWuBCH8DfvFlfGsf9cRMvp6VlJ0dPPsmsKbfaEfBG6rI0KEcFuyCkqoCW/phKBWOdGiXE9PJLGFs0lwOdL7Cu+deUh8dRnT+N6rzJhNWC9HGc7ywbIZBSZ0jrZzDVzWCqh6FUj30/pvWT0pNItIxdFVTygyUUBEopCJZSECilMm8SITXPNX/6BfsAgRDnHm/iNA9QKEIhP1DCYLILmDTi+FE9hZ/SInH9tyekBF2gBk2lJRV3wYyw2Mbsi5RW07bzBcO1o4iMDCIk5E+dSc/W9ejxOCIStmHFSqOWEoouXUXr936K1tWLWhY1jkm3ntBIgVZLopS/9gpaf/Uc0dVziJTloUuJkMJoALrxOQsoOoVTqlj4hZvY+vGHyKsqYurd8wgoRsVS4xgVQEdDGAse2q9z+M+qHePiUF+GC9C1xjmVFiFkhiqjCIluHxUoCHSZVmSczzBSxpJw3HqBxZu91L39JCd+s4XF/3kD+VUFKI6Yj2yVbzf83IDQ1W+d4lA23HEsXmCx1JXe9jhf+9AJGo7E+OzPJrJwdSGYsOM0VWjGe4PO2IlB3vmZMdz94Vp+8eUGvvL2A3z0hzOZelEUZACEkRurIIwmFYJCQ5eCUFhl2bvn8eL/bGXGnbNQSoocbi+jjX3tUvZ//iFq770CpTiKokh03QjIjV69jN6nN1J0/WUIodpvUMGKpXQ//iSxE8fInzgFdBAKhMoryJ84je6dGyi4dqLRb/72lk5fQuOmP9N1ciflky/K+pl5pU0/R7XkbNL+c2ZYDlpGMKcEKc14EYUg02fcys4dP6W2ahElheOMgF0MGJHWLopE6ubFQBGuGiAWuADkh0pZXH0rXbEGmvoPcLR3A/u6nqU0PIbq/KlURyYTUYsyXT7DXfTNsVJK4vogsVQvA6luBpJdDKSMNpjsNi85gkggSn6gmPxAMSXhOiJqEQElZDQ1hCqM+yk9bsxhztOdaKa+fw/7up5nYtFCJkYXE1QimcdyPsFF14eHOBNICoIlDCRHqbSMwqT0EMowpigBEAq6pbT4gIuQEC6pQk/ESA32ESiKpsdaTyUhf+JUEIKho0fJnzPbOAITViyAicycTqCqgr5n1lJy5/WO7eY5FkZQbvF1y+h5dhstv3iGsf90swkp5qVeMSvQSnNhRQVKF49n7sevZveXnkLqOlPvmY+qiPRFSwrzQq+nT80o3lKvuwjwKDlpRcferhkALQKG9mJBil/eaxpg3OAChgKlCP+D9MJK+n4aWJwqTKp3kH1fepzxt86j9uJJnmJs/pVv+5sH2PLzg9zw6YUUFIjsbiGHS8jadmhrL1/70AnKa4J8/eEp1NQFscJC/c1SaQ0IKilWeN9/jSUYFHz1HQf46A9nMGVJKUhLOVDQkehCR0cQVDQ0XWHujePY9vP97Pn5Li765xXGe6No9vtVvmIS4ZoS2h7ZRPWbrrLdcLquUnTZYrruf5rYvsPkzZ5hLPSpSAJlxeTNmE7f5k3kT5piq9pCQMmiFTQ9+juqr7iNYCCC1AEhUMMRyqZdRNv+tZRNuYjctf8fz3LQMgqTikgXJTPdQKUV06iuXsCBww+xbNH7UIRiZBdL0rBiKi/p+2SAC6ThpTRvLKWRMcySV9Ada6R54DAnerdyoOsFFKESUYvIU4uIBIzboJKHREOXGpo0bnWZIqnHGNL6iKX6iWl9mD/thJV88oOGOjImPMdWSfICRSjq6D4KITWP/GAJlQ71Qpcajf37OdqzkZN9O5hXcS3VeVPcO1rA5YWUVwpcMOJaepNtGaqK0KUNoGf4pJngmMUUjMq4WjI+7LhIcSUIQaKzhUBR1AU01llRAyHyJk5h8PABCmbPdsEKZq0YFIXiqy+j84GHid5wBUph2IxtsSYTpjgSoOodN1L/mZ9Seu1iCmeOQZjuIykFUkhSukJA0U01QqHm6lkIRbDnv5+m/2QXCz56CYGQ9eHFVl0MscihvAxjfq6ikSzZEzNVFuHiIgtAdBNGdMxYHkzgwFJ2hj8md4yMQ6HJAiwBRWf3154iVBxh5ntX28rKcMG3Kjprv72byqnFLLhxjCMVOdMt5IxhUZHsfLGbL7/7GNe8tox3frKGSFjYsKKKLNDiVb+E8b151+fGoKiCr73joAEuS0vRUAiSsnfVpIJVeE4PBlj5vnk88R/rmfW6OQSrSlxqSzAgGXvXEo7/8AWq71qNCOWbnmKrQu4sBl7cTN6cGWk1WkDhymW03/dbtFtuQw3l2d/NghnzUB5/kJ792yifvwoU82MsoXzOKg7e/1UGO+oRyoW5hDnT+c92/5ydneXO3EimGnDhXaxLCpgy/UZi8W7qmzcZSosjKNcdjOu8nxn/IT19QlEpzRvLrIoruGzsO1hd9yYWVt7ExOhiouFqdKnRHj/Nqf6dNAzsp2XoGJ3xenqTrQymekAISsNjmBS9iMWVt3Bx7b1cPfZ9XDH2XSyvfS1zK65hUslFVBVMpiBc6g8sZxAvowiVsUVzuWTMW5gQXcyOtkdpGNzvymRyzftKmQd+CoKl51VpSaXiBNTwmR2Ps06OR20BUNQAgbxCkgO9GYG4dlyLqbYMnTjmimdxbkdCwZLFiGCQgfXbHYG4mFlElltKEJk5iaJVc2n63mNoSc0u8W+lQVvxLfYCi1Kh+sqZLP367TSvO8G6jz5GrCfuioFxBuU6A3NHG9sCuFQWryUHEhz6v7XUrpk1qlPvimOx4SO9zT+eJZ2AZ0OKFVjqARZFSDrWHaVt3TEW/Mc1BCOqDRzZgm8VIek82s3+v5zi6o/OJqC6q9563ULOoNuBrgTf+fgpbnpzOR/8Qq0NLE7Xkl8LmZVurWq56WBbyTs+Xcfld5bztXce5PDmbjsw106BVtKVdRUhmX5VHeVTS9j5ox0oQk8rSCa81FwzC6EqdD2/JyMgt+jKixjctg+trzcdWKRA3rw5iHCI/h3bcQbdKqEAxfOX0rVrvRlDZ/3uCvLKaymsnULb/rWjFT7Pu1nZdmfbpM9nPGejs5zSMoJZ7iGpYMQRCGmDSChcyKTJV3P82DNUV8wjHCjwdxPhvu9VXCBTdbFMKApF4UqKwpXmwPMUB3I+4cGcSxEBppWuJKTmsbv9SVJ6ggnRhf7ZOd79XwG1pSBQSkzrQ9NTqGrQ6DyLWBbLkqlBgsF8d+cwU2laEsV63mEsEClAi3mWB5Du27xxk2h/5s9og0MohXlpgcMeJxCBAIWrl9H3wjoKr1hhKn8mvJhxAcY+koq3XM+pj36Htt+9TPUbL0MFO74FPe0qSt9XiM6uY8X37mbbvz/Ci+9+kGX/fRPR8VH7Io0w1Q4kulSzumAs88a2uCrmWgBkbtv3/55HqIIZH7h02DkFpmtIWp9J474Q0nQLDbu7r7pizens04fiHPz280y4fQEl0ypcbiG3OyjtFgoKjfX/t5eJyyuZtKTc+F/dBRwet5CV1ix1fvCp0xSXqbzlo1U2rAB2HIuSTWkB94+LFYskjPf0nZ+uQwJff9cBPvLDmUy6qMzlJgoKDc2Kb1ECrPrAPB7+4IvMecNc8iZUmIqcjq4IAuEA1dfNp+2xrZRetxhFKOgmuOTPn4paGmVg7Tai116edgWFVAqXLaV343qKlq9EFYbrCF1QfNFKOjc+z1DrKQoqJ9iwIxWomLuak8/+mrIZy4Z/Q3P2qrOc0jKCDQ10pMFFxayGm1Zb6sauJByJcvTkU4Zq4lRTXKX9wZVR5KO4QDpuJmtGzrlkEGXL7jlf85hzTShexLyKa9jf+RydsfpMxeV8AtMw2UT5wVIABkebQTSCJVNDBIMFIw8EdF0DqWdCi8y8r0YKSA0NZN2OhHDdOISiEDt90rMqtLBVFyQUXWylPx9LA4u5zam2qMVFVL3zJtr/8BKDhxodRecc6wV5/jvUpEK4upjl37mL/HGlvPTuB2jZ3GBvd2UYudSXLM2RCp25Pf3TVP/UYZqeOczcT15HIC+U9Zx7IckJINZjZ/Pr88KJH7AIdA78z5MIRTDtbcsdMSlpt5Bf8G3bgU4OP9PA5e+f6Rt863ULWUCz7pEONj/by0e/NoZIGB93UmY1XGfzVr71Ki5v/9RYLru9nK+/6wDdTUMutcW5qGJQaExcUUXtoip2/GC7Q1nSbViru2k+QyfbGdp/2tjmrJB7xRL6n99kuKtNpQUBRSuXk2hsJNFQb6YyG9tC5ZXkT5xG1471ptqNneocnTSXQKSA7hO7s34eXknTOLe1h7QLJRG9CuxVAy1CiCuFED8RQhwQQgwIIRqEEA8JIc4pxLzp2Dp3TQD7y2aAh6KqTJt+M03N2+joPoKVhud0Eznrt2SAC/i6izLgxWdcVnBIn5SzA48zsSxzjCmaS13BTA52vmgEsJ5pDMkoU5uzmpSElDwCInxeXESalkDXk5lKC/i+Nl1LAKAGRlBaJATyCtCGBlx9XlPVIOG6ccRPHnfBjNtFZKY/z59NnyP92SJsqTsKzkkoXDGHotVzafjGQ6TiRsClMw3ahhXnfakgIhEW/edNjL1hFhs+8jCbP/s0PfX9mfAiTXDJlvbpARXIXJ9ooKmPvV9/jqlvXU7xzBpDlh9NmnSGayjtLrLMu03xwIvwzGONqX9gG+0bj7P4C9cTLgwarhJHmX81I6bFaOu+u5epl9YwfkGpb/Ct1y2kIulujvHDz9bzhn+qZNrscPYsoyzuIRVJCM2Gl6DQ7NRpC1xCisbbPjmWcdPzuO8zRwiSdK0GrTpeh6rAyg/O58SzJ+nZ30rA8dqFkBTUFVG6bArtj211LJmgIwQUXb6YVHs38YNHsRZRRECgpoLI1Cn0bkpXu5XmbcnilfTs304qPpT+/RUgAirlc1bSdXT7iJ+FV8LkuazwLBVkLoL4rO3VdObeC0wEvgHcAPwTUAVsEEJcebaT9rYcor+73gYX963RSsqmMnbsKvYevJ9Yqt/SqDPBJZvi4qe6OODFG/OSAQpnoIKc1+Y3t8OmlV5MX6KdpoGD/sdyvswJOA43kxCeDKIzcUF5ji+ZGgIgGPCBFmu8uYtUQNPNUvOjcQ+FC0jFBv1VFrBjXPLGTWTo5HF7u3COdYBM0WWrGNqxl1Rnd4baghVwqyvouqDyrTegDcRo/dVzxmZTbbHhxQdcdAS6CDDtvZex7Ft3Mtjcx3Nv/DW7vrmOwa5kJrjoIyguHoXFcgtJTWfnfz1F0eQKJtyzxHXOzqSSrrcInbdZY1yuIdLA4rzt2VXPke+/xOyPXOFyCwEZoOJUWZp3t3P0pWYuf/+MjDgUW2XxuIWE1PjOv51i/NQwd72zzAUsgAtWnMqIX3OCkfXYCS7BgOS9XxzPvvW9bHyo1R7rqs5r3o6bX8qES8aw++e7HCqLZsNL3S0L6Fp7EK2r31xc0ji/ofIi8hfPoP/5jSZ8SLsSbuHK5fTv2I4Wj5lxLRKpQOGMuSjhCD37t6QVbjPGsGz2ClJD/aP+HOTs1WGvJmh5v5TySinl96SUL0gpHwCuATqAT5ztpEUVkzi99wkX5TsLHhll/GHK1GuJRErZd/ABJNLtJjJhxXk/o/hcNjDxAZhhXUhnoKh45xyu+Vo2eDEtLxhlfPFCjvdsMTrOKmPn3KwgUEZ/svOc50noJrQE84cFLqvYlZYylBZFze7OsEyN5KPFzdWjfWDF6s8bN4lYw2mk5lnPyLyAW4pLZNpUAhVl9L+0OVNtke6gXKWwgOr33krnIxvo33MKTVol/bGVFye4aA4XkJSC4rljWPbtu1j4mWtpWX+SZ+75JQd+to14f8oFI15wyQSZNKwkhlI0vnCMDR95mL6j7cz7xBqEqmSoLNnAxep1KivCdTJx9XsVFy+w2HEsSY29X3qcMTfOYdx1M91uIZc7KFNl2fD9fcy4qo66WcUulQVIw4THLfT8Hzo4sG2Aj3xlDGpAuBZPtIDFDSXZW2bsjLk/6dsJ08Lc8cFafv3FEwx0xuzX4QQW6/UsvncmJ184xWBDj+t1qkKnbOlEQpVROp7ckVaurIDcq5YyuHUfWm+f7R5CgfyF8xCqSv9Od0CuCAYoWbCczh3rjAq5juq5gYIoReNmZPlWvbJmuIfOreXs7OxVAy1Sylafvn5gHzDubOetmr6a7qYD9HWdtgnf7S4ywEUEgsyeczc9vac43bSRDDeR8FTJzQYuWWJdvI/PBDjOCESynd/h9vVTfkwrj0ygP9mBfh7XAPK1LO6kolAlfYmMj8bozXwtiUQvihIgoEZG2MGwZKwXgGCk6MyfMgu4hKpqkckEqW5LOcKGHKeLSAiFwkuWM7B2M1LTfdUWJ8AULJpO8ZWLaPzmQ6QGEwZEONYncoKLBS8ps+S/JhV0qVJx8XRW/+wNzHjPak48tIcnbvoxL7znQfZ+byNN608T70+R0lW7eeXywfZBTjy8l80ff4Snbv4RO//zSYLFEZZ97x7C1cWubAsnrJxJFoZfxpBltuKCP7AoQtLy9H6SfTFmvnuVK5bDm+IMuFSWntN9HFvbwsq3TBlWZYG0epIYTPLr/23mrndXMG5S0LXduPWCyMgtKJyBvwa4hIRV0t+4vfUd1ZTVhPjdF49nwpHlKhKS8YvLqJhRxsH79xFQNEf1XyP9uebG+bQ/vh10LX0enQG567Zi+TalkIhQgMKlS+jduDG93pBVIXfxChLtrQw1Hk8rLSbslM1dNer3/3zaiOtsjdRy0HLW9qrOHhJCFAOLgWdHGFcFVHq6pwDkldRQUjeL+n1PMfPit1m/akbdFpH2vSIgr6CCqVNv4MiRxygrnUJhpNJwE+lmJVVnsTmwH4NT6jfjP/QsWS7nkP1yzuZwr1jgIpyZQUKkx5j3C4NlSHSGUj0UmIGxI9poF0bMdh6scyQlxaEqDnZ3kdISBEahemSzWKKPcNAo8Gdc84d/DxJDvQRCBShqwC9EJfN4h/sRM0EjWFKGCARItrYQLC+3NwsHkAhTRSlctoTuPz1ObM8h8hbMdAXtGmONz69Vo6Xi3us49S/fpeUnT1H3/pvMeYVRyNlcTstZG9mVAGd8tBFqgLqb5lO7Zhbduxvp2tVAx44Gjt2/A12TFE+vJFSch9R1pC6RmnGbGkjQd7SDcFk+VasmseCzN1B+0ThEKGieHuPcWHEw4K+y+PU5M4n8zKXGkB1YhKZx8jebGX/bfMLRkA0nzlol2VSWXfcfoXpmMePml6A4AmPBX2UBeOgHLSgq3PEOP7eQG1i8r8PXnJuFbkoZRkCsivG5UIUgHFJ4z3+O55OvPciqW9uZdomRrRREQxcKipR2JtGC103nxf/Zyvx3LkbJUwkoGimztkvd9XM49fO19G85TMHSWa4KuVZAbtG1l2JXyFWgcNVyel94kXhjPZHasXaF3GBpGQWTZ9C5cx35YyYbn3Hz8MMl5f6v9xU2/RzVkhy0nL29apSWLPYdoAD4rxHGvQ/Y42kPASCgbt41dDfup7+rIe0aUt1qC2Ydl7oxyygtmcy+gw+gS91es8g3vsVyGzGM6gLZFZfh4lf87BxcSRnHYVqG8uJRXCKBIhQRSMeVnI2LyFrY0K/faT6wEw1VAvLc1BYgHu8hHC52P/0w5z0e6yGUF83c4MuhmUXr/K5BilAIVVSTaHOsVWTeuicEtbCQ/IVz6H9pkw+wYPdZq0GLSITqD9xO9zPb6Vl3AInDPaQLl+Kime4dq1aFU3WRUkAwROlFE5j81lUs++adXPnoe1jytduoWjWJwkllRKdXUTK7hrIFY6hYMp7aa2ay/Huv5bIH3s7sf7mKipWTEaGgHVfjDNyFNJzILAAzmsglb2Cu8GzzupNaXzpMrLWPSa9daI7RXXNkU1mSQyl2/ekkS+6ZRECRNoA45/CqLH0dcR76URtv/mg1BflOSNEzgMV2y4zoHnKPc8e5pI8rKFLMXJTHmjdW8ovPHUcOxV3Pa7mKFCGZce04AhGVY48etucPCCP4NlySR8VlM2j787bsAbkH3AG5wboqwpMn0btpo+02spSVksWr6Duwi9RQv+sfxTMQ2nL2KrFXLbQIIb4AvAH4Zynl1hGGfxeY62m3GhNBYcV4iutmUr/vKUe6s0Cq2F8cq6EozJh5O7FYN8frn0+7hTzxLRng4ucucsLL2QbjninYDDefd5vDsrmbjGDYUgbONq5kpODZEbYHlDD5gVJ6zgFapIBYopdIOJrxI2m/7x5LDPUQynNDTtZ/rrxF6Oz+zK5QRRXx1hYfUBEuFxESClcvZ2j3frTuvuyxLY77ebMmUP7aK2j8fw8ysL8xA1w0B6hI0itDOwttWdlCziwkEQpSunA8E9+0gqnvvpRp71zN1LevYspbVzLxTSuYcPcSojNrkUKx4cgJK8CIwHImgbkZWUSOfuc2W2WROsd/tZlxN80hryzPpaI4VRZjn7TKAnDw8VMIAfOvr7NdSIA7MNYZyyJ0Hr+vjfLqIFfeWmTPmQ1YrLnADATO0pz7eMHFL77l9R+pQ0/pPPytUxmxLVaV3EgY5t45lQP370eVSXucHZB780J6tx4n0dTpE5A70zcgt2jVCvq3bUVLxE1gMfoLZsxCzS+ke/dGd/rzBbqCnZNryGw5Ozt7VZ45IcRngE8C/yGl/PZI46WUrVLKvc4GHIV0DMuYeWvobthLf0+jTflWMK5XbQnlFTN9xm2cPPUC3X2nseNb1GHAxdHnCy/gBpizDcY9F7VlmNiVjHEOKwiWjT7t+GxSnZ3gYu3v6IuGKulLtI1+Pp/XFU/0EA4V+ww2n87xmUBAItZrQIutxg13+MO4/DxwEqqsIWkqLWlI8b8fmTYVtbSE/rVbsqotzqBcXReU3n4p0Uvnc/q/fk2svtMFLlZwrhWMK0nXV3EF6Up3qrOlwDhBRnMAj2ubM0XaJ7vIGgf+wOJlOS/MDAcsdp9wQ0nHpuMMnOhk0j2LzbG6ax+/jCFjbp0dvzvCgtvGE8lXbEXFVZfFo7LEh3Qev6+D295eTiiQdv/4AYt93wIT4d+AtArkCy7u+BZV6BQWCd722fE88bMmmvZ1Z1Vb5t85lf6WARrXnnalP6tCJzq7hvwpVXT8ZRuZAblLjAq5noDcvIXzEYpC/64dru+TUFVKl6ymc/s6pLUS7Rn+H3Y+zVow8WxbDlrO3l51Z84Els8Cn5VSfvF8zCmFoKBqPMW1M2jY97SjwJxIB+ea/3Fb2URV1XOprp7PvkMPkNRiaXCxAMcLLpCpuuAYOxqIOZfmfzL9ASYLuPiqLUIQVguIawOZ2+wds6glZ5KiPMwcBYFSc7XnMzTHtyOe6CMcjmb0Z7P4YBfh/OyQ4zrEVHLEtZ+sa2qovIJEZ8eo5hWKQuGqpQys32IsOOejtjjdRFZ0Y+U7biIyfRwnP3MfidbeDHBxgYdPkK4FL6Ou18LIxei8sOKt72K9NKeNpL54t2aLC2l68gDVl06hoKbQFcti3XpVFjAgpOtYD60He7jojgn2XM4MHjuo1gE6Gx7vQtcka+6IuqDCua9LDcINJ77uIQumHKpLpktJt5UeS21ZdlUxS64u5XdfPm6rKM66LSo6ReUhpq6ZwP7f77dBLGBmGQVVSe1NC2l/ahcymUzHCZkBuYGy4oyAXCUcoGDpEvo2bMgIyI0uWo420EffsX222ygXGvKPZ68qaBFCfAoDWP5TSvm58zGn/cURgpq5V9J1eg+DfW3pL4zVvPAiBNOm34KiBNi1/9fo1n8HyjDg4gKStOriu/18uYEsGwlmhlNZ/MDF0afpCQLKKNbsyVJvJd0lXW1U8wBFoXL6Eh3D7zOCJZIDhIKF6Y4RTnOsv51IYcWo5k4N9RPILxx5oAQ1vxB9aBA0Pa2smNt8XUTLLyLV1kH88HFftcWZAm3dRwlQ+5G7CFaVcPKz95HsHvQFFwsmrOq5Xnhxwo0d+2I2b/qzXy0XpwLjBzL2y/acJuf20dhwKosQkp59TZQtHGOO1dPA4nD3uOHF2P/E2ibKJhRSManQlebsLLmvuOBFZ+2jXay6NkqBWQ7IqXA4zVJYvLBizJluzm1OeHGCize+xbmm0Z0fquXgpj4a9xhqi52BZAGKorPwddNo2txE34kuW3Gysomqr5qBTGn0bThgnBdHhdzCyxbT/9IWpJCu39GilcuInz5FvLnRlSkUKCykaPZCuravc8W7XAjTYUQIH77l7GztVQMtQoiPAp8HHgceE0KscLaznzhN9EXVkymsnED9nidAeNQW2w0gbDdRIBhh/vx7GRxs48DRh81rhsgKLn7uImeg7rDqi/tknD+XkB+8jHTfY0k9RnCUqcJ+lg1SMvq9Y8zHhcEKUjJOLNWLFdQrRloPyWG61EimBgl5S/ibEOq1VGKQVGJwWGhxupOSQ30E8keXGq3m5YOU6LGhkQdLCJSWEpk7k/4X19t9TrXFdhPpwnYTSQkEw9T92+sRkRAnP/crUn1xG1x0XTFjXITLzeOFFyeIeF1Bw7mIvBV5RwMr3u1natlUlqGWXmItfZTNr3NnDDmDcB1H4lRGjq9rYcrqqow0Z2sOq/otGGDR35Vgx9p+LrsxHcuSntMDGh5g8YKKfTyOZruahgEXr9oyaUaEeRdHefJnDS61JV0xV6dudglVc8s59MA+F/Cpik6oIEjlFbNo/8v2jIDcwksXkmruIHH0pBGQa34fgmNrCE+YQN/mTel/CM2Pa8lFqxg4fpB4dzsXMhA35x66cPZqOnM3m7fXAet92lmZs/ItqsLYxTfReWoHfZ2nMtUW4bgWCEN1iOSVMn/eG2lp28WJhhdt1cYPXLIH4+La7lJgLDvfcSvebaMBlyyW1GMElTOAFmdq9SjUEV9wcagtBYESFKGeWVyLw5JJo/BbKJRFDTGB1QLYwQHDfRMpMqDFqb7ZnyWHpQb7COSNDlqUfAOctMHBzMPwxrWYVnTxSga37UHrsdY3cqotbjeRbruOQMmLMPY/3oRMpDj1n78h1Rez41jSCojbXeSEFwkZEDOa6ri+qkv6pbliabyg4oUfr50p1HTvaiQYjRCdVGqcfw/c+LmGAFJDSeq3dTDt4ipXP7jTnK19VaGz8ckeCqIqi1fluZQPy4YDFuNYsjdIg4ulujgDdDMylBxqy41vq2LzXzrobx6w3UhOtUURkvl3T+fIY0eRg0Ou1Z8DQqf2hvn07T5NoqnT/r9OCEm4qoTInMkMvLwFb0Bu4arl9G/dgpZKugJyI2MnEK6qtdcjulDuodFXeM7ecnZ29qqBFinl5VJKka2d9bwWjJjwUlg9idLx8zi141HHP6z+aou1rah4PLNn3sWxE0/T0rE3O7hAZjwLmdv9FJiRWlYbDmS8j70BwH5zkRnb4gstFlz4QEZ6yOjVkOHGCgSFwQr6Eu3+xzCcCUEiZVzsQ8HCUUFarL+dQLgANZQ3qv8EU4NnoLTY0GKUL3eCisscrqC8OTNQi6MMrNvsvvJbqorDTeSMb9F1gVJUwJhPvRmtf4ijH/4B/Xvr04qKQ3Xxgxf3mkVp8LBAJlvzAop34UZnBtFIkJKt38+8ac5CSLp3N1A6vxahCI9bZ3jXUP2mZoQCE5aUm/3Osvrp53GCydo/d3PxtUUEggI/lcVrXmAxjsu/WfDichk543LsWJxMtWXRxUXUTc7j2V82GrEq5ppEzmJz068ZSzAvwPE/H0m7h8wYlqIZVeRNrKDz6V2ottpikHXR5YsZ2LgLPZFIB+QKyF+8AKnrDO7dnf6H0HwhJRetpmfXJnQtdcGgJWcXzl410PJKmgUuVhu76Ab620/Q1bRvWLXFchMhoLJ6HlMmr2HfoQfo6W/IDi7DuYu8YJHtF8r3NZwB1IwEL85+520WS2rx0Sst2UDCKM/q3+xdZeYc5v2iYMVZKy2J5AAChUDAeA0jFZYb6m8nb5TxLFoyjp5KEBwltCiBICIYQhsYygQV4+Ayyv8LoVB48XL6XtqI1KQ9ztdN5IhvscAlUBZl/JffTcHCKZz85M9o/e2L6Endpbo44cVyGzkDc73xLaNt2dxH2eJcsv0nm62ibsb5dbg3ALp2NlA2f4zHBeS4n801tLaFCUsqiOQJV20WyyzXkAUnvR0Jdq8f4NIboy6AcD6nU2XxAos7hsXdcG4T7p8IfzeRW20JKJIb3lrFC79vJdmfcAXtOtOf59w+hf3370dILSMgt3rNXDqf2Z1RIbdg6WxQFIa27LLlQalIlEiIgsUL6d24wfH7a6gt0XmLkVqK3oM7Lxi0nNsKz0bL2dlZ7syNYNJ2y6RbuLiKiqnLaNj7lPEDb0GGt7y/wy2AgHHjL6Wqch67D/yGRGrQH1wgw12UEcvivO+nkGSDmWHAZliXk/Mx+MZx+JoQ6FIjrg0QDpjxIKOMJXEpJyPt4wcu4FJvikNV9CRa/J5oxGNJpWKogTDCUUtlOHCJDYw+CDfR1wVAsLBkVOMBRCCA1FKZGzwvxeUiWrkUrauH2L5DHrUl001kxbc4wUWEQ1S/51ZqP3wHnY9u4PjHfsLQ8VZbRXHCSzo9Or34onfV6NG2kaBkOKXFb+wwp8vX4h0D5NWmiwQ6s4bSfW6VUBGS5n3djFtU5ur3Zg3Z/UJn7/pe8goUFiyPmGPdGUPZzK2epCHF/bxGc6outqvIx03kp7ZcdkspgaBg0yOtLsBxpj/Pu2MKvad76djVbAfkWgBYc81MEp39DB04bUKL8XOihgMUrpjHwPodZvyKtONYClcsI3b0KMnuznRArgCRF6FoziJ6dm26YDEtUp6bi+gccgL+4S0HLSOZSH9Z7GJGAmrnXMFAVyPdLYcylJh08K4JJCZ8CEUwY/otBAN57Nz3y+zg4hPPkjWTaLRxLV4bBmJ84cV73+smynIRH0h2IdEpDPqU2/a6hszHIwKL1I3mNO84z69CSaiWoVQvsWSf73EOZ7qeQlUyV2t2gqzzvY8NdBApLLdjXbI1KSDW04oSDBMojKa3jWBS0xCeFGnXbk53kQkianGU/EVz6Xt+HfYvvePW6SayXUe4wUXXBYUr5zHx6x8gUB7l2L/8kNZfPf//2XvvOEmu+tz7e6qqc08OuzObozYq7CoLhLKEQBLBJIMDNuBr89oGZxv7XmxfG19HbGOwDZhgMkIIJIKEAspCq7CSNmhz3p2cp3PVef+o0BU7zK60IM+zn9rpPnVSd1d46vmFQ3ki5yEvttnIcBQWL4lxryJ9ulvgu4nYH0Vc6kFJaMhSOXSf6lNcbCIjpWTs6Azdy71RQ55+Xev6AOx5Ls+681Ooqtc0ZP4NV1n8hMWckwjd3HXCiItnnBC1JZmEq97WzYNfOYUivSs/2+HPbQuS9G9dwJH7DjqExc6Qm+xM03beUsYf2uVyxpUIRZK5YjOFXQfQp6Y850d8xRK07i5mnt/uEBnbt6X1vAvJHd5PZXaqqd9zHj/7mCct9eAhITg3m3hrN13LL+DkrvtMVSVEbXFuaIr9XqBoCc4795cwjArPvPBp8sWJAHEJqC4Q6cfi1KlHVOrVCSEwkcSlCcyWRtGUBAk1U7+yH24iYhMVN1nxvzfCSI8BUtIS60ITccaLJ4LqSphZyT0NKihK48t0FWZHSTSotBQnhkm09+BO4+8cAxGQlQpCdT1Tu6btNw25X2evvJzCjj1URsYCakt1YPvGT4C42Bl01fYW+v7gXfR98E1MPLidvb/6Txz/hzvMVaKtSGw3gbEVGMNl6nETGJvU1Nv8beq1AzzkxQghMZ7vNaRMTWjoRXPVpfBoIe8xowhJcTxPcbpM1/KMb583oZxTjsFLz+VYvyUVMA0FzEous1C1zPrrO0fd9RwC49rnJi622mKPEaa23PiuLk4eyHPgaW+yObdD7tobl3L4/sOoRjBDbu/V6xh/7CUUo2KJ0aaZKLVuOWp7ltzTL+JZRFERZLZcwMxzz3osmQhILl1BrL2D6f27/T/ZKwLTjfr0tnnMDfPfXB1UijnPk7R0EZi+zdcwPXyYyeGDnnKHhFjkw/80Hk+2seWC9xOPt/D0C//JTG7QQ1zARVxq+bHgJTCRvimNkhkb9YhLLTORr/+Z8ijZWJdPCQgx4fhVFj9hqYUQ4uIfRwiF9kQfE4WTwTnUgW40Tloq5QKV4izJTGMLuRUnhki094bvDPl6pZRg6F7SEtY0hLwkV60g1r+A6Yee9Kotjnmo+l4atYmLlArZ15zHin/7MIt+/x3ouSJH/vQLHPjNTzHy3W2UJ/NO1I87gigqzNlwqTNRW7MKjJ+8mGVeBcb2yzFc+90wSUu40uLU8RGX8SOm43b30nSAoLjb2EpKsWBwcFeejVuCpiEb7oghs71NOOz3wqpnbhPjBu/55THe+fOjfPazsxw9XHHqhZqQ7ORzNdSWhYtjXHB1Ow9++ZQn/NntkLv6msWUpkoMPXMqYCLqfs0q9Nki088fCuRsyVx6Lrknn68641p/MxdtoXzqFKXBU64HSJPQtG7eysy+HTV/m5cLZqbnuW/zCybOHfOkpQ4mDjzvVU1c5CXZvpCOJZs4uft+xxRgp/131wM80UQIUGMpzj/vl2lvXcYzL3yG8anDXuLiV10aIDAQJDF1yYy/3IaPGNVEjf0zpVGy8cZu4HUJi71wonsLq+fuy9W2PdHPePFkddoN+tcYRjnUPBSGgh3unK1+Zvt3DzMnFSeGSXT4Fxh3wffVSt186hdaCIkK+TjOfU5iRlFdeRmzjz2FLJd9KgsB4uLxd8EiK4biEBopBSgK6S3rWPTH72HlJz9E9pL1jHzrEfb+4t+z/4Of5Pi/3s3Yj7ZTOD6KbhAgMv6kdM1uYQQIe64u8mKXOV+Vi6j44S5XEhpGUQ/UCfqxVN+PHZmmZUGSeMqkB+6ss36owuDQjlkMHdadn4w0DdWCm7AAHD+hc+ubRzl5Qmf1Co3/+PQsl7xmmCuvGuIv/nKKbU+VHR8Xt9qC72+Y2nLDu7t59r5xpgfzAYdcFYNsR4xFlyzk8H2H0BTdk7Ml0ZakfesKxh/eVTUPWf4t2Ss2U9x/1FQB7a9fQGxhD/HFi5h+7hnnwdA+f1rOv5DKeGPZoefx6sE8aamDif3PYVhLuHuIiLX1bbqWyVN7mJk4Ub0pufxY3GoLUCUmAhRFY+P6d7Cw93y27/gCI+N7nf0B1QW8RKMWganhp9KQs20ICQkNw24AM6VRsrHO4I5aSeGccpcKUyvVv2Peseq7zURSOmpOR7yPqdIwFaMUHDtCoQHTp6URpUUqkM+NocaSqIl0fTOPlKbS0tFbt67TxnLA9fu0eCvZKorvPZC9aCtSN5h9+nmPylI1FbkUFsPebOUlqLoYjn8KqN0ddL/rOlb++++y9GPvo+26LegzBYa+9AAHPvhJ9v7SP3D4I1/g+Me/y+BXH2b8/heY2XGU0tAUlZIe7bQINbegk6OXvICXuDSTI0NNalTytZUWpy6m2jB+dIbOpeE5fZwFEl0EZs9zOZatSZBpqZIc918g1JfFrZjYp/v4qMEtbxqhp1vhrm918//+qp1nn+jlkft6eMfb0jz7XIk3v3WUL38l5yEu9hhu35wwteX8K1roXhTnsdsHvKqM20R0w1IOP3gEoeuOImPv6736HCYe3wsV00Rkqi2S5Kp+tAVd5La9YDnjVnO2ZC7cwsz255Am83bUlnh3D/EFfQ39Nmca83lazh4aN9T/D4VeyDFzYj8ti8/BDrkTLuKS6V5MS+9KBvc/TvbCtzl1/CRHYF5ppCHNBwlpEgGhKqxZ/UY0LcmLu7/KOatuoa/3AgTCct415yFdN1XhfvwOW2zPvumGUVKbB7jaCHcfdlshzNdKtU2z0PUSs+UxWuKWkuBXNlzRPQGVRXrNRtU2rvdKyPcgDRCKWc9nvmqPL0SgMJ4/Tk9mZVN+OpHWJMd/yeyrlJ8kkW5HCFE3OqWSm0Iv5kl2LnT1R7hZyCrTZ0zHQzXTQNp/MO/qAofAKMkE2csuZPr+R8lcutX8CiTeSggk0jrO7FfS6koghURKgZACIaTJG0X1kBGqSmL1EpJrltBxi/nbVobGyL90jPKpUUpD48xuP8jE0ASV8enq3NIJ1LYMWlvG+RvrbkXraiXW3ea8VpNa8CO6TCf2DcF/+BtI55AwpHAObUVI8727DwQqklRfG7PHJkK/Wn/SOBvFmTLp9ljkfhs2GTh5uMTS1fFIRaVWP6oQLmdcwZ/87yna2xRu/3I3yaRF2ID162KsXxfjNz+Y5VP/McNf//U0N1yfoLNHtcYAkOjW5zasMQ0kujBQEZSlSkyVXP22bh74xhA3/8ZSFKGiSq+JaOVVi3jgL59iePsAnVuWUBGKo7h0XbqSvX9XYXbHUVLnrsawI4kUyFy8gfxzu2h9/VWe62f6vM2M33kXpYFTJBf2ex4cM6vXmaajVxgm8Zj7M/88aZk75klLHaT7VjCx91lalpwTICP2zapnzWUc/sk3WXreG4lpSfNSL4T5xGBf2DHrC0WYBESI6q1BhRXLr0PTUuw5cBeDIy+wbtVtpJIdWBTHIS8Y0rmBCfNqXZ2sm3C44b7jOv24dgthEhe7bQRx8dRz+hORIcnTpWEkkta4y2cjygnW+mxmWQhhCRvDT2D8xAXzhikADANV0ehI9DFaOGqSFvccrO9MSOl85zaEoiKlz0QgCPXpKeUniSVbA+VOGxeRzY+dQihquE9LhPJSnhgHRUFriRjD+Uw45EdIV18SsldfwfSPH6O4/zDJNStwk5VGiIt5TFMlL3ZLaQ4m7f2uw0jr7aKltytwaBrlCvroBJXJWXR7m5qlMjlLZXyGwqEBKqNTVCZmnN87tqCd9MblpDcuI71pOfHedt93Z91wXeRFWPMykCgI/Ink7Pp+/5TWNT0cu/OF2t+1D3rJQIubx19UUjk3Rk+VWb42DgT9WYL5XYIqi1lPcM99Be68K8+9d/U4hMWcg602SVQE7/uVDF//Zp6/+qsZPv7xNrOSdRqrQoI0iZzuOwBVJDoGV97awdf/4QSHt0+y+PyuqtIiTRNRplWj77wejj96jO6tizwmonhLnNbNi5ncto/M+Ssd4iuEIHXBWibvfhR9ZgY1nQXDfCDQujuI9S0kt3sXCYu0CAEISXbT+Yw/9mBTv8+ZgIFAPw2/lHmflrljnrTUQcuK9Qxvu49FV70VRYkHlBQhoGPZZo4/9z0G9j7Ckg3XW8oKnnqAaSayb4kC143AJC5Ll7yG7s5z2L3v2zz53L+yetn1LO67BIFSJQzVR0XPTS1AYCCcxPhVGJ/y4qgutRxV6+23MFkcJK21mesO1TAHedPwN0BY7DquvCmOsuImLoYSIBZdiSUM5Pe7xqijWgEKCtIeU/E28aNUmCKeqt4IAseAC/mxUyQ6ehGaWjU5+uC5bwioTI6jtbYhtIjnb99H8nRk3TTj3d2kzt3A5F0/IvGh9yEUxdlnDhhNXJBUSXgIecGlvphdSMdE4z9shJAITUNb0I22oNupE/qxKjr6xBTl0SmKhwbI7TzM0Bd+hD6VQ+tpI7NxOe3XX0B6wzLXAOa5ZqsqwiEzoCBMlQXzFLDJinR9T1IKWtf0MHt8gkquhJat7fxsQy8ZxBLhdd3rDdkYPlXmkqvTznu3P4vTLixqyKWyTE8b/P4fT/Dr78+y5fx46NiKEBhSkowp/O3H2rj1LaO8/R1JLrnMXMw0TG3RhYEqBQYKOgaqEHT3xVl3UQvbfjDK0gs6TaXFZyJa/tp+dtxxgC2/fbHLRGQqLl2XruTEnc+x6P03OCYiw5Ck1i5FSSUovLiXzKVbLBMRCEOQ3riB3O5ddFxznVfBjs3fwv6nYd6npQ4yS9YgDcnU4d0RSgsILUbfpmsZ2PMwlXLeuWmEhUBj+apIp72o/lUgnelhy7m/yuoVN3Hg6H088+JnmMkPOXUcs45vJWbHn8ZzkxPVLaosKsw5ECnU/Hc3VRqiNbEgfKc/bX+UU6xbfYkKefb5stQiVF3JJUyXhynq5to9dZ1xpUQIJai0RKBcmCaeam3I9FQYHSDZ5bXJh/q2uN6XJ8aJtXU0NJfAg73tBAK0v+VmSoeOMPPQE4F9nvcuHxcMk7RIy9/FdtQ1X1d9Xjy+JYbifCjHR8ZqZ+d+MVx5W9xlhqsuqora1UFy7TLab7qE/t99Bys/+wcs//hv0Pmm16DPFjjyp5/n2N98neKJsapjrvUx/L4ufth1cP0FaFndAxIm94+EtguDXtbRYrVPGJuYSCkZPlmmt18LOPfa8JOcwH4Ef/GxKeJxwR//fgsqInQzxzX/XnZRgne9I8VHPjKNXqr6yrjHs31W/A65qjDYem0bL/x4zMnZ4o8iWvm6fqaOTTNzdDIQRdR16UqKA5MUj4842XHNKCKF1HlryT8fvNYmN66nePQo+uyMx5n9bFlZ5n1azh7mSUsdKPE4ras3MbH3WRdxwGNXRUD36otQ4ylO7X3Ye+PxKC2um1IN4iIUlcWLLuWSLb+FpqV4avu/8eKerzMxfQSJDDrUng6BcT5o9WWAuBCyL2K/G1PFQdM0ZKaPDFYImIp8KovfXFQLfuJilxnS45DbGutFE3HG8kfrzEU6KpQiVIwGSUupMEU8yjxkw/rdC2OnAqTFUycE5clxtPYQx+YohN3vJMR7eml/yxuZ+Nb3KQ8M4XfGDXPOrUleDC+BCSMxbiJjbwFC4yIqbmLjDY+2iBSC2KIFtN94Mf1/+PMs+5v3o0/nOfBbn2TgMz+kPJn3kBc3cbHXSvKHQPuJi5JKkF7cztS+kYZvNJWigZqof2lVhUFhukJ+1qC33xudVjMLLt6cLE8+VeTz/53jn/5fOy2paDXIT1z+7COtjI7ofPrT1cU3Fedv1Tzldsg19xlceHUrQ0eLDBwKjyLqWpahbUkLxx896iEsQkgyS9pJLu5gatt+VwSRmWguvWUthRf3mQ7nrutmYsUSlHSK2Zd21VUwXwkY1krNp7PNY26Y/+bqQApoW3cB04d3USkXPQqLm4QILUb/pmsZ2PsoeqXkqueLJAKcaCKX6cJPXABzheiNv8C5G96Drpd55sXP8syLn2Fs8qBXzfGQjyYIjP911NHQhMOqDd0oM1Ma9SotIQqI9BOaWoSlbiYxF3GJUFsUodCRWMRo/mi1TsDZ1/tWCBXDaIC0CJO0xJLedYQC4c6ANAwK44Mku/o8T47+/vyvKxOjxNobU1qqEwhRXYDslZeSWLuSkf/4EvrMrJeomBOvvnfUlBDyYpMKN4FxkZgAkfEpIP6on5qkxkVmqkTGLEusWsziP38v/b/7Nmae3ceBD/4ro9/bhjRkJHGx4SYkTsSR9aVnl3cwdWQ88P1F+SUYukRRGztnxgbNyKSuBaaZw09W3EbA4LpBJhH53BdzvOGmJK97bdLXtvrP6cNFXHo6VP7sI63808enGTpVXQ3HzpIbRpzsKKL+FUkWLEuw8+Gx0CgiVYHlr+3n+OPHXdFDVfNR58Urmdx2wCQr4BCX9HlrMfJFSoeO4Uk0p6mk1q8nt3t34Bo8j/9ZmCct9SAgs3QNSMidOuhRRvxsv2vFVkAwevz5ULUlYCYi5MTzERehKHR1ruW8Tb/AZVt/m1Syg+d2fp5nXvwvJ7eL2U9IOLN7VWYiyIv/tT83S4QaU1dlKQ0jMWiL+8xDrhBkb3lIgjg3CWl0/aFAXhef2oJpIhotHKvW8c/PB01NoOtFa5yI8QVIaaCXC2jxVLW7iK+pND2G1CveyCGrnygYSIqDp6phns1esD3qiXlT63rvu0ARDP3zZzBy+UCdwHubvNgEwiYkbgLjIjEBIuMjM6GEJoTUuAmNh8i4CIxhmCdT9uINLP/HD9L11isZ+u/7GPj0D5GySlw8X4lLqo8yEbWt72P8xWqEikHtyJFERqM0G7I2VAiKBXNGyXQdc1KNfbt2l7nkorhDSMz63hZhxAXgnW9PsXqVxj/8o7lqeIAYhZiIzHoGmy5tYd+2Sate0ES05KJehl4cgUolYCJqP28Js3tOQsVeQNEcT2tNEVvcS3Hf4aCJaM0qiocOmb8leK69rzQk1nEwx63O1WweNTBPWhqAEouT6lvGzPH91Sdl318EKLEYXSu2MHTwKXATG8C5xrnLLLXFYyYCL3ExPQhBCFLpbjasexuXbvlN4vEMz+74LE+/8GmGx19C2rlkqKG+4JszzElFqQnrpj9VHCSttZtOuBH1whLAVV8HzT3SahO2eepaRCUUhkFXcin5yiS58qR37Ig2mpqkoheD8/VBr5jERo0lw31TXCiMD6JocWIt7cGdvrb268rkOEaxYEZQ+OrPFVo6Q+9vvR/KFYb+5bMYhUIEcfGXVcsDBMZFYgJExmcKCiU0dRQaj3+Ks99ua5EXTaPjlitY/JH3MPHAdgY/9yPn9wtTW9zkxa+6dJy3iOmDo5SmCg2ZiJKtMfKTjeV2qZQt0uKyDkVFDoWhXJbsP1hh3TnVDvyEJapcEYKYovBnf9LKN76R58DeikdtiVrB2g7VPueiLHufmUYYerWOy0S0+PxO9KLO+O4RV+4XU1Fp29SHUaxQOHjKk2QOIUmuWUpx/9EAaUmsXI4+PU15fOysm4dOJxuuvc1jbpgnLXVgE4rMsjXMHNvnOVn8JiIz/PkSZkYOMzs14Cn3qC1Ov6I+cYHqr2S9T2d62bT+nVy65bdIp7p58aWv8ZPt/8apoedM34so9SXEbOTuN1Jtce9rAMKQpj9LIiI9vRuGDKosIUni6hGG0Gy6hnMH9JRn1Q4SSprR/BFnvrWgqQmk1DGM2k/Perlg1o9FEDXX8VKYGCTe3mNF7hAgKuAnl1AcOImIxYh1dtckRHXhJh6A2pKl97c/gDGbY/hfP4eRL7gOand9HyExXPvcCoyLxHjIh+Ha/ITGqENoXGTG7y/jVmDc5EVKSK1fzqI/ehfjP9jG0Jd/HGgHQbXFX9Z2Ti9KXGPk+ZBVwkOQbIuTnyzVrwhUyhYRqBEEU4u8HDpcoVyGjWtN0uInJu4FE9373WrLVa9L8Jor4nzsY9NWG7ttVWVxz0WxyMumi7LMTlQYOjgbmu032Zagc3U7g9sHqqYhq69Ee4rU0i5md5mKp5u4JNYuobj/qPUgVh1bW9CNkklTPHLIPF+iv7KXHZLT82cJxoLNo1HMf3P1YF1vM0vXUBg6QaUw63EQc/5ar9Md/WQ6lzB88KnAPr/aEnqTCiEuYaoLmORl/Tlv4fILf4eu9jXsOXA3Tzz7T5wcfAYne6TTt095cY8JQeJSA3XT+hPihOsyz4R3KoOEAwgsfhi1uev6iZAzhDkHIQSdtokoZE7Crmft0zSThFT0gtWRv4H5p2KRFiWMtPi+ssL4EMmOYGRVmLnQRnHwBIkFfSbRcddvBNK6/gcOOhBSoLa10PuhD6BPTnHij/6a8W/cZS2s6CIubpISoqgESIxbKfE72YaYhyIJTZipKYTABMmL+Te9eRX9f/BORu98jOFvPBIgLmHrE9kwsFSbjQsZfb66BEQtpNriFKYaU1rKJYkWF4gGHwpsJ1zbn+WlPRVaWgT9fV4HXD9ZCSMuYKotKoLf/50WfnRfkcEBSzVx9eU3EZn9GSxYpNHVH2fftonI7Lj9F/QwtH3Q6cft19K6cREzu44H/FqSa5diTM2iD4+ZE7D9WhRBYsVyCocPV6+VDX1rrx4IIa4RQvyXEOIlIcSsEOKEEOI7QoitvnqfF0LIkO2lszX3M4V50tIIBKT6liK0GDMnDjjqiVtpseshoGf1JYwcetpx3oxSW8w2QadcP3Ex+whRXayyRLKN1atezxUX/R59C7ay5+D3eHbHf5HLu2RUXAQI33hhaMJ/xQ/dqASdcG1Yqy4HHHBtuMhGgLDUgp+42H251RZX3a7EEsbyx6r13SErnvlIVNXMY1GpFGpOwW0e8iDk6yuOD5LojAgH97exXhcHT5JY0B/uVVsLYdVdSotNXLSOdvr+7HfoePstFPbs5+Sf/j+GP/UF8jv3IStGNIGpQTwwXJubzIQRGp9CE2lqkkEC4ycvbuJiGILMBWvp/923M/z1hxi543GPylI1FXlNRG7y0n7uIkafP+lxHNZdf91o1jwUi5nt3WqFbU6pF+68Z1+Fc9ZoCCEizUI2/KtAu9WWC7fG6O1VeOD+YqSJqNpPNZJovWUiMucc9GtZtKWHge1DCEN3+rIVl9YNfczsPomw/F3s6cX7OlGyaYoHjgRNRBZpAc6qE+5ZDHn+dWA58M/AzcBvA73Ak0KIa3x188Blvu0dcx34pwXzpKVBCE0j3b+c3KnDVoH5R7r+2uSkc/n56JUSk0P7vISGCLXFbyaC+sQlhLxo8TQrll3DJRf8fyAEz+74DPnChKcPbz/C8xnC1JZGVBU/ZkojSAxvJtwo2HedEJXFfF1VUjzEwr/ZdSGaELnKuhKLKRk5ZsqjtRUgIK74lJYI6JUiQqgobq0/7OsTUJwcJtHeUzXT+RUWH6QwzUOJhYvq9l1tFMFv3BdMH3FRtDjZyy5i4Z98iN4PfQAkDP/rf3Hi9/+SoY9/mvGv38XMI9soHjyGkSsGyYlfaQkjNG7zUlS7CFNTwOlXhpAXLBXFtbijYQiyF62n77ffwtCX7mfsB8/4HG+tr0FWnSTdIdGd5y9icu8wpcnwY8CQCjoKhhSkOxLMjBUxGliQs86h50HYxfrQoQprV/nCpWucs9XFFb1qS0xRuObqBA89ZBFvVxceR1w3scJg7ZYsB7bPeMptvxaA/vO7Kc+WmT48UXXEtQ7K1g19lMdnqYyZpMc2DwnFjAQrHToRULUTy5ZSPjWAUSl5yl9pnI4Trr3NER+UUl4jpfyUlPIhKeXtwPXAKPAn/mlKKZ/0bc+fzuf+acB8OsF6cN1MEj0LKY4O1DQPAajxJC09K5gc2EtH33rzziFNAmBmnAU7G677QUYKnDT/ZoZbq57Vxu4DLBOGe10gIZwrYCrdxQUbf4ntO7/A9l1fYOvm9xGPZZw+PKiRhj8UDaxFNFUaJKm1EldTzV2Vo1QWs6BOW2l+B4YBtvnEkKBYmXFV+8naShmutZJUW5gonKAlUWOVZUBRYihCo1zO1awnDd1juvFfl2xyopeL6MU88ZaOYCc2iXG3AfRCnvL4KPH+RaF9R5b5q0hX/9Yx5v8rpEAgSK5dRXLtKvTZWQo791A6foryyQFyz+5AH58AQO1oQ21rRWnJora1oLa2oLZmUVozqNksSksGtSWDkkkjVLU6R/eH9B+XwnVeCFdd+xC3PoR5KlgZdwUIgpl6kdV8vlJCy+WbMfIlBv7jLlJr+kiv6XOpLmbfhtXGnZG2dWM/WjrOwJPHWH7T6prfdduSLJWCzvRQgUR/7dXBk2mFQs4wj/c53MdGxw02rosewyYnhodUCHTrfFIR6NaXffmlcf7ir6atuVjqj/V9uGGn8weVletTjBwvUpwpoWZU03wk7YUfDVp7EyRa40wcGCO9osf5ToWQZBa1gSIonRgh2dHmlIMgtqib8olR87d2PbxpC3tASipjoyi9fWdVbTkbkFIOhZTNCCF2AUvOwpReccyTlnqwbiJCQqJrAdP7XjTfhxEW1xNzW99aRg4+7XRj94Ew1Rahu/oHhHNFxlRcfMTFrGo/DroIkDsdvz0pKRGqxuYN7+a5Fz7L87v+mws2/wqaEveQH/c6QtX5uedBXYIShqniEG1hKovfNOQ8HrvruKOB/MnmakxGUTzERSqK109A2o/2qtNfa6yH6ZKZ6VQYpt0cw5InDFENOxeCWCztJS0hHEpKA6HUT/VenpkAIBZGWuy+3BdjAcWBEyCEaR4Kq193VKrkxB7AJgd+4mKNKaxJqJkMmYu3kLm42pVRyFM+OUh5cARjehp9chp9eprigVH0yWmM6RkrhLo6MyWdQm1rRW1vRW1vQ+0wX2ud7WgLe9G6OxCq4iEp1fm45yqs8yKCvAjv4o42cTH5rKTt2q3knj/AyU/cxcq/ex8ibt7aDSlNtQmT8BjSXBTSEAJVU+m5ZBmDjx1m+U2rnbBnQ0gz/NmVzbZ9cQahwMjRHN39bTV/knRWQUoo5CTxGmtgRqV9GRsz6OpUqw62Ub4rKB7iElZ2yUVxRkYMjh7SWbJSQwHsy5QiJKo0U/vbhi9VGCxdm0QIOLEnx7KtyUBKf1WBztXtjB+YYPH15vnnhD/HNJIL2ygcHyO1eaWzzIIQEFvYTe5py/3CuhBKIVHbWhCJBOXhEeILfOkCXkGYl7C5M6ZmnuXqQQjRBmwBHvDtSgkhBoAe4BRwJ/C/pZRjZ270Vx7zpKVRCEh0LaQ8NY5eKiK0BAjhEAn7Kdo+jFv71nJs+/co5CdIJtscAuK+KThqC1XiIpGeZWDc7dxKTSOqi6YlOW/TL/HM8//Ji7u/ynkb3oMi1GB/zaotdTBZHGBBerV9ZntNOGEIc5xthrDY+93EpdZYqklsWuLdjBVPRLeR1bt8TEtRrtRRWqSBEOEWV/f1rTQzjlBUtEzWayb0w1VWPHWCeHcvSjxu3ogj6jUCR20JIy74XmMRah/URBpl5XISK5dHjiMNHWM2jz4zgzEzizE9iz45RWViCn1ikuL+w+gTU+jjk8hy2YyM6l9ArH8hsUULiC/pJ7F6OSKuOUQFR2kBO62A/TM55MU5k4LExTycJD2/ejNHPvQJhr/1GAve9VpzvpYfjHvBRcUyESkIei5fwa5/fJBKyUDzuS2ZJMacjxZXaetLM3J4FuOSDtcTShCpjElyZ2cMWhtcuNuN0TGDrs7gMRfm3+ImKW61BUwT0bJlKr29Ck89VWLZSg0dW1WRnsUBFdeqz5msoHdpguN7Zli2NTxTc/fqNiYOjFttbWdeFUVIUks6KRwfBaxTwV4fq6+LyvA46BUg5lwIhRDEeropDw8DEefNK4DTzWrrarsqxAl7OExRqYF/AzLAX7nKnre2Hdb71wEfBq4VQlwkpZxpetI/JZgnLXXg+BtISHSZ6kFpfAitZ4lnv0f1FoJUZx9aIsPUwD6Syy/0EoU6z8W2mQhrUcRaxMWsH6G6SEk8nnWIy5Hjj7BiyVW1x3VuXC7FpQkYUme6OMKa9suabutRWSCUsISFPjsnvcc0ZKktBpEmohatiyPT23FWgg6dE6BATEtHm4fs38HQq0qLW+TxdV6amSCWbTPXNMJXzz8R631h4DiJvkWuH8i7vy7cKoun3EVc7P4a/NmF+4OF9C2EhpJtQcu2WEOFdyylgT42QenkAGVrm33yWSbu+AEippFcv4bU5nUkN69D62itEhjbvCrMCbiVF+e7VKSHuNi/p9qapfdXb+bUJ75N62XrSC/v8agtQgZXfO6+eBl6oczo86fou7jfXOlXCjTXZ7eJS+eyDGNHZ60yt7TqRSprHq/5WWtiTWIsgrREwa+uWBoTOhJNKFx6cZxt28q87Z0Wt3d9BapLZXG/X7YuxbGXctV0/tLrjNu9uo1Dj55EdYU822ai9OIOZg6POXEBwlLKYn3dphloaAxtgeWwbv2mWk835ZER6/0ZlCzODr4TUvbnwEcbaSyE+Evg3cBvSimfscullP/kq/ojIcRzwO3A+wH//p8ZzJOWBiEFqOkMWraVwugp0j1LvBdq30VbCIXWhWuZHNhD74qLTLOIixTYinKY2uI2EzVNXKCquljEI53qYuWy69h/6Acs6ruYuJaONBOd3pckmS2MINFp9WfCDdQNccC14VZVwqKCAsPasrKoEpdI5aRqIsrGuqnIEoXKNCmlLVoRktIkLZWcR30JVotWWpw6wlRaYtmO6Eoh3RdPnaD1gos9ZXN6yrRVCelq75hjXOTFPZdGDo+wOv5zwj9he1hUlM4uYp1dyM0bnN1GIU9h1z7yO15i4s57MP77W8SW9JO56DyyV16Ckkl51RdbecG1MrVhflihuIiL9Rtmr9hM9rEdnPzX77Lyb98LqoKQrnBpv4kom6Lj3EWcevQICy5a5MzfjiCyyYuOQvuSFkaPzFY/SwRxSWXM42V2unnSUihIZmYlXR3NtQszFdm4+KI4n/3crKfM9GuRGAiLlJirPpcxnXGXrUvzzIOTkeN1rm5j5uQs5VwZElo10Rym0jLyqLnquiIkOubPqHVmEYkY5YFhk7S4Dp1Ybw+F/Qeb+sxnGqe76KGr7W3AAd/u4Ub6EEL8H+BPgY9IKT/RQJNvA7PApQ1O86cS89FDDcB9bCY6F1AcH6qeRH7i4tpae1cwM3rE24eomnUiIVxRRIEIH3tOovreXwaBhHR9C7cghMrY+P7wMeuFQNsIu9a5bvZTxUESaoaElvG1qxHq7E617+4zcg7SuzlNfO0Nw+s/40NGa0OgMFMaDXweP5GLaamg0hL4HNGExo1KbgYt3VK3njOMoVMaHSK+0LW44unI4ta0raVdXOXCu9l157oZEVvYfqtMGMLcpEBNpElvOZeuX3w7i/7mT1nwh/8fqXPXM/3A45z4o79h4ls/RJ+YsdoK19jCiSTCJiCGVY5rP4Le97+R0slRRr7zE7OpFNZh5V0Tyf674DUrOfXwQaQhA+n83a+7V7UwuG/a87Wb5MZ7yU1lFLS4YHKsgt7k5TiXN3+8TMb8rcIig2ohLMpo65YYhw7rTE8YVl/RsJPMLVmVYOCwGVUVtnhi5xLzWpAbmPZkxgVI9bVRHJ5yzk/Hr0VR0LrbqYxNeq+1AtSOdvSJybNmGgLzYfP00vg7kz8gpdzp2+qahizC8lHgo1LKv25i6oI5eSr+9GCetDQJLdtKJWddjMKIiwuZ7qUUZ8cpFaeD9QR4rl/WCRkWOVKXuESVuYiLIlRasv1Mz5ysqhBRJ30dUmUnXwtTSsxMuL5FEptRcmqpLFFrEPnLovxfDOn5KySktTZylYnw+q55x2MZShZpiVSmhIL0kaOw30gv5VETaWs/XrLraWv+LU+MgmEQ7+719NMoHGLiISje/QECY0+gic0hHNYWWdfwbWEExnpt96UIleSyZbS/8Ub6//IP6XjbG8k9+yIn//hjjH35TipDY64+AU+uF6r+KvYTskVC1I5Wen7pRoa/+mMKx8eqGXbtDe9Tde/rVlMYmWF0R/W+4iYvdthz34Z2Jk7kmJ4IZlE287uY9YUQdC/UnKRujUJFYK/haed5CYOCcLZ6/SlCsG5dDEWB3bu987adZwMZcoVB75IEuSmd4nR4FuB0RwKhCvLDebMvVwRRvCMNhqQynXcIi7lTorZkMKYt1cc1fTWTRs8Fy19JnMU8LQgh/gyTsPxfKeWfN9H054A08OScB/8pwDxpaRTWTUXLtFKZmQqyfB/hAEh19KGoMaZHjjhEILxdyAEcVd89HxogLi60ZhcxNXMiosMzg8niIG02aZmrc6+lkpgvvUQjEmEZdCFIYKS3XlprJ1ceBwhN528TFNM8NBvY76krRKii44dezKMmkqG/bdjxURoZRsRiaK1tZ/bpMuQrdROYmpsR3PxKS1gdz+b05SM6fjLj+isMgaLGyF5+MX3/5/fo/KV3UDxwhJN/+ndMfOsHyLLuUV08xMWoEhcny64UtF6zhdS6pZz8xF0Y1orQfrUFTHIS72qh49x+TjywP3Dzcefe6F7TjqIJTu2a8jixuqFLBV0qdC+MMTLQ2AKLblSsJlpEwJqfqLjf+yOLbLSkFFasUNm1u+xJMhfo2xUt1bMoDsDIiaJT3x1BJBRBuitJfrSqVDrp/DtN8q5PVP1CbfKitKbRp2cDbFrJppH5AlJvjui9GiCE+F3gL4AfAt8TQlzq3qw6y4QQjwkhflMI8XohxE1CiI8BXwB2Ap85e5/g9DFPWpqElm2lMjvlvPcThOoDpUAoKpmuJcyMHPZ2UuvGE0J+gKDa4hkzWBiWQbcl28/07ClTDTjNBHJhMKTBdGnY9GeJUiPcoc72a9s05CMYoYTFs7qe4SUJ/qR0boISQXrSWhu58kR1vqHmK1nbEdeCCFFawmAqLanI/f7fuDQ6RKyz25sDxl2/7og1Ks/V7DOXdmH9BMxDLkLjSybnJjC2+pLZeh4L//i36X7/e5h55CkG/+4/zKiTOsRF4lJfECz89VsoHDrF2A+eCagtWHXt8r6r13DiwQPoFfPL1N3ExnqtJVR6VrdyYueEWQcRaf7p7osxfNKbQbeRJ3FdN8dXtcbPXz+RCTMRbdwQY9eu+iTKXvG5rUOQzCiMnch7cts4YwpJpjtFfiTnITuKkMRak6AIKuPmA4E77NmjtFiQQqJkTHOTka99Pr6cMDhNtWXuQ99i/b0JeCJkA5gCBoHfAb6F6ez7VuBfgCuklLWfvn7KMU9a6sF3TmuZVsqzXlt1retLtnt50K8Fiyi4zD2e987YPqISYSZy+guZrxstLf3oepF84eUJ058tjWDISngmXFl/0UO7XvS+iFPdb5KJ6sOu5/yVZLR2ZsPMQ2E+LZV8zc9gkpb6n9FUWqJJi9lZ9WV5dNg0DYVFDoUcC6Hd+U1D9aZZg2w0o740tPnaepUVe/MRGDd5QSF9/iYW/umHEIrCwF/+M7lnd+JP/+8nMhIc1UXt7qT7HVcz/NUfU8kVHbXF/io8JqIr11AczzP6woDXNOQ6wXUU+ta3cWLXlMfXJYy49PTFGD5DSkuj/iy1sHFDzDEP+TPj+qFiRuL1LE4wcrwY2We6xyQt4E3aJ1SFWHua8vis1zwEqK1u81B1n5Kx1JnZXHOE/QxCng5hcZHh5seVV0kpRdRm1RmXUr5FSrlCSpmWUiaklGullH8opZw8o1/EWcA8aWkCUoCWbUHPzyB1vSGpPtuzjJmxY0jbAO1rExXqXyUm4YOEERcHfjORNUYy2YmmpZiaaWzht6YgJVP5ARJqhqSW9ZTXzbHih8evxb5z1OnDtzK0009I8jr337TWRr4yhRHWv6sorqaQUkfq5hOxcCszNoQSPU/X72SUCqjxOqTF1aY0Oky8y5u1t+6x18jBWUsFsacQQk6CiolNJsK3ur4uPv+WULOTX4EJIS+xtg56P/QBslddzsin/pvxr30XWdJxp/1HVtct8puJ2m64GBHTGL17m8cB1+OQiyDWkaHr/EUcu2+/x3QEpjOuTUwWbOjg5K4Jp9yGgeIhL90LNYZPVUlLlDnJj4ql9Kghmedq+bDY+6IIzsYNGnv2lJ3+oboGUlg6fzBNRMMWafGvQQSQ6U6RG81X52CVK0ISb09TDjEPqa0Z0zzkg2qRFmP2Z1owmMccMU9aGoR9D1DiZlYpo1IO3e+BgGRLF1Kv1DUt+NtFjV8ryqeemUdYDrlnNB0jOP1NFgdoSywMlIeiUdMQeIiANGRgC63nbm9HEYUgqbYgMShVZsPna5VpmkkyylGLJkpQFNVZJLMWDL2C0Lyp12txjMrMFGprW7Ugqm5YuY+A1EOAoNh9uAmKn5DUUVwa8nWRePxb3KqKW43xKjA+8iJBUTTab7mR3t96H7NPPc/g//sU+uR0kLhIYVkpbTMQiHiMzrdeyei3H6c8lQs45AIOeem//hxO3H+AckF3Qp4NqbjIi2DRuZ1MnMgzNVywyryXWx0zdLhvWYKBYyX0igwQFlu90UN+O80yCxn66Zt3FRTHGXfNKo1iEYYHakcQ2cqLgkFHT4yp0XKAzIBJTBKtcYpTxdAFINVMAj1nOvG6P4mSjGMUSq7s45bpKKaBqiLLjS1K+XLgbDri/k/HPGlpEkI1vzIpQ25OIvhaS5j213Kh+iRR83j1mHxqz6Wm2hJWX0rKlTyxWJ2n/EZJjZ3t1sJk4RRtib7qvtD6IeqHe9wwlcXeHeGXEiiPctqtrornFCWE+V0U9dnqvpD5xVRr0cRKPrDPhlA1pFGpbyIyDM8SA57f0a/ECdBzOdS0L4R8jqjnYFsd2L25SEot1cXnn1LXnBTW1k1K3CTGp8J41BdP1JD5PrluDX1/+iGQMPRPn8WYyVVNQxb5ssmKtL5oKQVt125FbU0z8q3HrZtLyA0KQe/r1mBUdAaeOOohKu6/XavbSWQ1Dj494XytYTer/lUJKmU4cbQ5x9JUyuzLDn2eK/x+LUsXaSgKHDnauMmqpVNjdiKaRCSyGuVZc78/wZyajGEUvG2FkIh4DFn2zcG2gqvqWXXEPYsLJv6PxzxpaRJCMfPxOSdMwA/FW6bF04CgXJwN1vO9j1RKInxbmoVhlJFSR4ul61eu6VsSvLHrRpnp0jDtiYWhbRvyZwmra6knUYSlWs0mJI2boqSUaCKOgkpJz/l3Vl8boKkJwFrp2RrC/9CoKDFrCrUvpoGFFWvWNTDyLtLycl7r3CQCqmSFGiTFTUxwbVHEph6hcY8VpqxYCoxNatz9uH1WhCHQWtro+c1fBUMy9M//hZErOWqR9JEyxylXVel+1zWMfX8bpZEpj9riNhkpqQQ9ly3n+P1mXjC/X4shBYoqWHx+J0eeHbMccW3VRPH4v3T3xUgkBUcPekOG65mJUklzf6HQPGmpZT6KxQT9/SpHj9bPHGPnamltV5kejyY58UyMci58v5qKYRRKgcuaiGnIUjgREpqKrDTvB3SmcLZ8WuYxT1qahlBNr7d6NyanvqKixlNUirMB/xTb+TbUr6XZY9rvx+J/D46JyjZ11IWBLycLkTlKpoqDSGQ13Nnpo4ayUnPsWqQpJHIorFqYP43PGVcIQULNVJWWCCiKhqLEqESZhwDFOjYMvbZsLaWEkHT/YTAKeUCentJS7+uXvjq1yIqrvpukRJGZSHNQlAnJTVRcJCbKr8Vp71ddrDZaOkvvb78PYzbH8Ce+gFGoeNQjabjMRIaClILsZZuIL+pm6GsPoxuKo7ZIqkqJlIK+a9Yw8PgRSrMVR4Gx16TRLb+VJRd0ceTZceerddMAm+goimDRyjjHDoTnOQmDjiRpkZZ8HaVFFQpqRKbmKL+WZUtVjh7RfXWruVr8aOnQmLFIiz/BHFikZbZ6Xriz4qrJGLpLaXEuYWFKi/OhLKVl/t7/Pw7zpKVJ2E/I0mic5ceSGSrFua1P1bCJqAGULdNGXG2QtDQKKZnMnyQb60JTEp7yUIT5s9RK0x/ht+J/76nnaRNCXlyIq+lQ0hLIiqsmw81DVjVbaTGMSiRRkNL87CGLpHnrWbvtJFpqugF1rGaHeOfkJyL2oLWUFR9ZCVVcPP4p5iZ1g9LwMDM7X2Tq2aeZ2vYTJp96ksknH2fi8UeZePxRcjt3UB4cglKl6r/iIjEeAuMmNX7y4qg0wqmntbTR+9sfoDI0ysi/fwlZNsDA698irY9gCBAKPe++jon7t1M4PuJRWtwmoq6LVyAUwcnHjjrrEIHbKVeweEs3A3unmJ3UcSegs2Hnalm8MsFRi7SYpKd6fNiv/UdwPG7e4BtVWqKISxiWLTWVFqet74D2J5hr6dCYHi+jEHyYUzGIZzRKs2WUkBNDScaQhSDRF3ENKjrSMALkRGiatZji2cG8T8vZw/zaQ03CXhBP6o2bIbR4mkop2hciOAjBm55/AcM5rMxcKs0gUNB8S9Se1tpDVtuJwsn6Tri1/Fkg6DBbg6AEyt0XZP/7OkgoaYqWI64wZLjyJc1Vsx1H3JCPoai26bDWxdRq2OD89IIVJppMn5nEcmFfv6vjgF+L66+IKve9N4oF8gcPUjh+hMKxIxSPH8MoFhDxOGoqDYpirtGkmLmMkJLyxJjpWKkoxNo7iHX3EF+wkMy6jSSXLUcoipM92J6HvWqCebpY/xvmxxECpH2OKBDr6KT3Q+9n8B8+xehnvkbXB96FEJYDrttMBBiGIHXeatIbljH4pR+z4o/fiiHNpHNSSIfAqPEYC16zkmP37Wf5DSstlcU8Rg1pTmzBhk7UmMKhZyc47+pO7DWIzAgiScy6yS9ZleCZh6bRUVBDbvxRP2U6JZjOnXnfjqVLVe79UXQIM1gRQNK8Hra0a5SLklLegGSwbixtKi1hZmK/0uL0H7fOp3IF4cugJ1QVWTmLPi2ysVw6tdrPY26YJy1Nwk4e1qhPgtlGBkxDcx5fBH0pGsXU9DGy2b7wRf2aPYtcTrhSSiYKJ1nTcQWhydma7f9lOqPN1ZytG5kdJiolmpKgIkvuiqGvVTWOrkdfyB2lxWUeElLiXUPaHrdB0muN38zxVm3bwMESRljmSFb0XJ7JJx5h4omHkeUyif7FJBcvo23rZSQXLUFr64hOkGcYVKYnKY+OUBodpjw6ROHIYSYefQg1kyWzfhPZjZtJrVptJiZxnVLO6WWt2SUUicRSeVzEJd7TS+9vvY/Bf/wPxr/yHTrf82bPx7LlHHPRRIXud1/L0T/+LNN7TtK6rg9DWosnWn+lFCy87hye+8jd5CeKZNrjjuKiWOn8EwmVJed3cuDJUTZd3UWMKqEBU0WJASvWJ7n9P0fMhHGu+7OBCDXH2OjqUhgZjT6W/OqKKhT0Bo69nm6V0THDalP/lExaCz+WCgaxENIST1hqUcVw9H0nnb+mOg+B9qKJgLnSPYQ/6Jyh6+k8fvYwT1qahO2Aa/u2NNTGqKAoZ+erdqsoE5NHaG9dZk0qeCEwnzijr04e/xYX8pVJivos7Yn+YKNGk8pFoGEHW0tdkYasXuzqwSIvmohRNOrnfFCVOLru9TsQsnrTU9QgaanOz6pvZUo+6ynIfU+JDRGWKLIym2Pi8YeZfOIRlGSSrmtvpvWCi1F9Yd2OuScEAoV4Swfx1g4yK9Y4U6xMTzH70g5mdr/AyS9+BiWeoOW8LXRcfS1qW5uXvFjzlYZACFldSd1FXBL9i+j5jV9m6B//g8SqZWQuv4BqtlyrHwWQksTqpWQvWcfgFx8g+3/fjS7MkGBDChTLRNSxdRmxlgTHHzjIOW9ZV11XSBiOX8uKS3vY+f3jwFqHpOhSIWat+mygsGJjimJecvxQmTWrLd8oKQIhwjoeTkNPt8LQ8NyOJQWB4SJEirU8vIGks0NhfLxxNTmRNJlIMa8Taw/uV2PmfqNsoCS9n0mowjQB+SFqkJYz+CA4F0hOz8Qj/faueTSMedLSJBzS0gQJMfQKQj27X7Uhdaamj7Ko76L6ld1Oty4n3ChM5I4TU1JkYh2+QWuYc+r5szQRBXS60JQ4s/qEt9C6yUFVLQkjLW5USUtth0qhqA07cjcF+67tKQtRW5ohLGHqim0GyhcYf/gBJp58FDWdofvGW2g77yLT30AG24aO6Z+SXW5NO5Zppf3Cy2m/8HIqhRyze3Yw/uiPmXr2Kdouew0dr7sGxfL3EVTvZVIR5lpS9n3PRVySq1bQdtuNjH35ThKrl6Mt6PCYiaSjpED3z1/L4Q9/kqnnDtG+dYWTk0WxFJeYqtB37VqO3rOPNW9Z75iI3H4tSy9ZwIP/spvJ4TLdvSaRiaGjS4GKaS7q7ovR2qGy58USK1enUXwKi4GXrNjo7VEZHjn9c0UVAt06DxUh6OxUmJqSlMsStcaCjKowKEuVlOVyVSqEz0XRqqTFbz4SqgJh5nablITKPGfXvuJe4mGu7ecxN8w74jYJ2wHXztfSWBv9lVdafOf07MwAul6qKi0hdZofwyQ04/kTdCQXVZ1LI3KdRJqOoGYCuKhxz1RUkipiVIz6kRuqGkc3yhEqlUQIFYQSSDwYqKu+TKTFmYuvwHawdTnaBurWISx+x9zS8DDH/+NfmH7hWXpufjMrfuuPad96mUnOXfU8jrn2+3oJ5/z1bIfaRJq28y5m6W/8Hr23vo2ZF5/nyN/9FeMP3IcsFE2ijbs/4enbDJc2y1uvex3xpYsY+fRXLcdcr1OuYf2N9ffS+trNDN/+WCD82VmL6Lp1jL04wNRxc3kP20Rk1+ld10GyNca+J8YinXGFEKzamGT/rqD5Ua9xg+vpmbvSUgudneaYUw2qLbbSUsqH17eVFj3ED0UoItxH0KWgBXB2Ocs8ziLmSUuTsE+uppUWpXFzUi04Nxnr5uu/6YQ61RowMXWEVKqLRCzr2SVqEYko+JLKTRRO0JHs98wrWL/Bp0FX+1DTUDNExahhmnKVa0ocXdYnLZri82nxdS2EuQJxvZDnl01paRJ1TUJWmT8z7uze3Rz/94+jtXew9Nd/j/YLLrYcaqt1IpPHRRGVqLBn/37DNGO0nXshy3/zj+i67vVMPvEoR/7+Y8y+8Hw10sgZI4S4SFCEStd730llYJjJux+wzEPucOkqiem87QpyO44wu/eUJ/xZSkFFKmTXLiCztJ2j9+53lBg79BlAqirLL+7mwBMjZhZcq9ydzl+XCis3JNm700taPFFE0v5bPfB6ulWGR5o7lvx+LmFhz52dZtnYmPe8jfKvibvMQ6FjusxDfghViSAtdfy/zqJ5aD653NnDPGlpEnZkSDNKi6GXUPz2/VcY4+MHaG9dbr45g/4sJT3HTHmUjsSi0Pan48/SEKKijTyrP9cmTKbSEuaH4p27osZMpaUGFFWrr7Qoap0II09lcypnmOQ048Pifl88dZKBr3yetgsvY9HPvw8tmQqSFZ9CcqbUFn86f0XR6LjotSz/0J/QduGlDHztvxn9/t3mDTCEuOC0NRWXWFsHne/5Oabuvp/i/qOWaQhnJWhHbVmykMwFqxn+9hMYVi4Xb+iqQv/16zj6w70OsbDDom1SsvzSBex/YhjDkBZxEeiO6mJ+62s2pdj3YoGSLgJhz1HoX6hy4tSZJ8BtrebcpqaqB4F7/SE/VE2gxgRlyzxkr1Fkw2Me8sH0aQm5TtQwD73s15U6mE8ud/YwT1qahLRuSEJtjIQYho5eyhNLZOtXrjlw8yeprbqUyzlGx/fR073B1V+NcZrwZ5nMnUARGq0J38rOc00qB9FPVi/ThUqExpgHx1aEauZgqQFFjWHYxCaiSyUWr0tsnLoJM++NUWo88RiEmIga2BfpdGttRqnIwNe/SOacjXRf90YzCi1KWYkoC6hT7npu+MmMi6x4lBMDVC1B99Wvp/8972Pq6Sc59blPY8zMBoiLJ4+LtaUv2Ezm0q2MfubrVsbcatI5v9oy9cRu8ifHLaHRlSEX00Q0e3ySkR3D2GsQuU1Eq69cyPRwkWM7TBNSVWGxc7AorN2SITdjcHhv8Lf252qx/65coXL0mE6pJK1y77nTSKRQGBLWukbliv+HiYaimKe9exVne8FER9wJ7U7UPv3CFBXZhMP9ywDPulRz3OYxN8yTliZhVMoITaubHMxGxUrfb69B1BBcJ/Ccwpt9bQaHXyCmpejsWO0pP+38LFIyXjhBe6LPXIjRvS+yXYgTbrOrQJ9hCKFYSd9qfx+KooUuiOj+jVQlaB7y/4ZCjVVJS52fQIlbpKUYnYm3GdTKw+J/7Xa6BRi5+05kpcKCW95uET0CJCCUrLj6q6W2hC6g6J5jSDv3ONnV61n6a7+DPj3NsX/7OKXjJ3x1hCt7btW/peNttyINg/Gv32UmnbPqu9WW5MYVJFf1M3Lnkw5hcZOSxMI2Oi9YxJEf7HWiSmwTkSEFmd40/Rvb2fXAcMCvxX7f3Rejt1/jxaeLTtp/W7EJg45k9aoYug4Hj5zZRGtCCFQ1On+bW0WxoWoCI2xlR6s/iFBIbA/qZiAlzeRimserB/O/epOQlbJp6gm74NvvXWUVa6HEWLLlZVMK6vmznBp8loW956OGxR8Ysjli5PNnsZ1ww/Z55yhr+s5E+568/IRGIJC15CQLilCR0jIPRsy3EZ8WRYs5il3dMRPWquKlYu3fKexeEKJqRNWP9GOx3s88/yxT25+m7+d+ATWV8tbzERa/UuMxGckgKRFhZS5y4t7njOtSWtyv4+1dLHn/b5FcvJTj//GvzDz7jM9sJTwkBglqMkXXe9/J7KNPk3tud9Up1/mrIKVC55uuYOL+7ZTGZtGNoEPuohvXc/y+/ZSLepXQWCYiHYU1Vy1k94ODAb8WqGbG3bA1zY5nwhNR2keomzYvXCjIpAX7DpQ9vi5nAjEzIS1Q+0bhrPYc5VALznppthnIrcZEPgDWfPiRZ9enRZ5uVtyzNvWfebyqSIsQokUI8bdCiHuFEMNCCCmE+OiZHENWKtGmoZCbQtlac0iLB1PnCzt3eIOIdMINrWvunJkdZHr6BAsXXGDNqwapiDANRfmz6EaZyeKAmZ8lqt9mnHDd02nmrD7Ni7VJWqLm76on1FClxdOXqmFEPZ5aQyhaHKNSNQGE/Y52maO0FBpUWkKISqj5Jax+BAGvTEww9N3b6brmJlJLlocSFI+6gu+9j4w4pMZwbf73IY64bhXGnp+fvCBNc1HfW3+Brmtfz+DtX2PysUe9xMWzZpGpuCRXraDl+tcx/qVvYxRKFmExD12JeYhlLlxPrKed4bu2Vc1D4JiIeq9cjVExOPHo0XAT0VX9DO2fZuRowePXYpIa8wa8/sIMO54peKOLXEsE+CGEYNVKjb2+dYuMZi4sEVA1gd6MeUitpbSYf6OUlpo+KmEf/afAp2XePHR28KoiLUAX8AEgAdz5cgxgmocad6qtFGbQ4plgFlrXOedcyCP2N3WC+qoODD5HS7afbGaBp85pmYYs2IskdiT7wqfS7Bg1F0l8+S5SQoJsgFgpioYhG/Bp0cs1CaWixTDKjSktQlEQsThGqXZK9abQjMoCjPzgu8S6e+m84ppIwuLuN5LM1FNbQtQXfG3dKoyHvLj7NUwi2nnZVSx40zsYuftOZp57zjO2HSXk9nlpe/21ICVT33/IIizWzcX2bREqHbddztj3n6YyWwo4YyqpBAtft4rDESairtVttPen2fXgIPaiiuD1a9mwNc3g8TIjg5VQZ9ywCKLVqzT2H4g+Lv1+LY36uWgaNLOQsqJS1zx0BriU2Y2Uc17tfh4/23i1kZYjQIeU8nXAH78cA8hKxVljpn5lKBdmiCVP0wm3zhgQTkIMXWdg6DkW9l4QfhOdq0ZpqS6T+VNkY53eRRLh9JxwzwpcF78a81aEEiQ3ru9QGGYq/0ilxa6n1TchecZNJGsqLXO+dDegsuhTU8zseoGe612OtzX6ckhACFkJJSNRaopfaXHIRkgbXz+4xmg77yK6b7yFwdu/Sn7vXu/83P4tEtREkrY3vZ7pex6iMjyBO1Ou7dvScuX5KMk4Iz941uOQ65iIblrP4JPHmB3OUTZUj4nIECprr1nIzvsGATzExTYXLV6bJNum8Ozj3t/bsHxcvGUmtpwf5+HHihjWseh3xp0rKhVoIvE3iiJC3dMUIZ2DNDJKyJCIKKYfUSzmfuSfNuyMuHOOHpoPeZ4zXlWkRVp4Wccw9NAU/lHnW7kwbfqzNFDXTzxqEY1GTEPj4wcpl3Ms6D3XmnywkRPqXO9rs31SXPWmi0O0uKOG5prwzTPOK++UKzHC12MKQNT9fEJRkLK2CSnMp6XW76kmUxiFvD3Z00MdlcWPmZ0voGZbSC1bVW3jV1lCCIvTn5/A1FJTfJt/xWg/MfGTGntMD3ExoPOyq2i/9DWc+tLnKR0/bta1yEqVWJkEJXPxFmKL+pi4/QehaovQNDpuuYzR7/6ESsFANxR0KdANhYpUaD13KakFLRz8/r4qYXHdrM65bjFHnxtnfMhUzsw6lolIKqCoXHBFhqcfmfU447rhPkN0JLe9McWxEzo/eSbaRKRLw9kaga5LZmclLS3NrbEW5WZil4uQgyzKp0XUSuMP0SbdVwBui/lct3nMDa8q0jJXCCF6hRAb3RuwylPHOsikrps6aIMo503S0rCzayShiW7ikB13HcM0DXV1nkNCc0UuyRqmoVr+LCGYKg3RGu+x2jbwARtJ338WIEVjT21C1PB9saAomjenSkh1RY1hlENCmF0EwFPfTVoaQSNfa63jzEUuZnY+T8vG8xyVZS6EJYq81Eo2F/B7cZGYuuTFRVjs9z3X3UJ23UZOfv4zlEdHqxl/bf8WaywFlY633UJu2/MU9xwJqC2GIWi77kKMcoWx+14IqC0IhcWvX8+R7+1Bl3gSzRlS0HduF9meJC/cO2SREiWQr+WC17Tw9CM5yobfNCRCnXH7+hSuuDTON749Mydn3DBlZmbG7KelpXFFoKZvbCQxkeazQK08LZF+eA1P7YxjPrnc2cM8aTHxG8AO3/adsIrS0JvKbmsqLU2ah9wnY5Q64q/n7DMLK5UCw6O7WNh7fng/p+m+bhgVZktjtMR7Gldpwjs6rXkANa6UjcGjtNTsqwGlRSihieDs30zIOZiHkkl0N2nxHB8Rr8MQtT+ivDI1Sf7IIVo2nl93joH+XAQl1FRkEQVZqTB9cBfjLz7J8NMPMPDo3Zy4/xscvfsLHL3r84w8/QC5k4eRpYrT3p98zu+I6yFQdh2hsPC2d5JY0Mep//pPKlPTXqXHZSZKrlhB+uLzGf/aXciKEVRbkgk6br6E4W8/jlGRAYfcvps2MHtikqHtAw5ZcUxEisq66/p58Z5BT+izQ25QOO+1WcZHdA7sLjl+LfUy4771zWm+fVeecrnx87qWs+70jHleZrNNnFsSIu/FdnnY+aME8yTZq3Y7/fq7E/XPxXm8OjFPWkx8Etjk227zVxLSVFqayYZr+rS4zEOnc57VdFT1vh0a2YmiaHR3nhNZxzENzQGzxREkhklaojDHyKEzgiZyOEgpG7SPh4nb/mHrp+hvJuRZSFBTaYx8iNJSazLN/qwh9Wd2vYDW0kpy8TJvvVoqSwhhwVcuJOiFPMNPP8Cez/0VR7/3eYa33c/kvu3kh46jFwvEUhm0RIrxXU9z8Bv/wq5//xMOfeMTDD72ffInj3j8ZDx//YqLm7ioGn3v/GWURJKBL/wXslyx2gTNRO1vupnyyUFmH98eqra0v/5SKhOzjD+6J+CQm+hppeeipRy+e0+4iej6RRx9bozx4ZKL1FRDn3v646xcn+DRe2cD+VqikszdenOKqWmDHz9asMoN6+/czu/xKbN9a2sz51G0YlmLswhE+LWtVsTRWVYq5qOHzh7mV3kGpJRDwJC7LMrO6lZaGjH5VOaitPj6bsg05IYBA4PbWdCzGVVo9eu7TUG14DIdTReHSagZEmo69ErUjGvRy56jRal94ZUYiAb4u/l0V3tOQlFrrgQNVvRQxYwwauRbUpIp9Jkp7zgS/9qHtRGiyPib+4+zmV0vkt1wrtc0FNF3TcLiqiN1neFnf8zwtvtQ40m6z3stXRsvQ01Uc79UJ2T+qRRmyZ06zOypQ8we28/wtvtoWbGRhZffTKKnz3oqr25SsRQUpfrwLw3zrxpL0v/u93H0k3/P2L0/pOvmN5qHr2EGvmP9xLH2DlpvvIrJO35AeutGlGwchP2ZBEo2TduVmxm5+yk6X7ceIRQUIVFth9ybN/Di39xH8cOXo7UqHhNR/3ndZHuSvHjvEFe9p58YVp4WoaBgoEuFS69v5dF7J3nfh9sDX7eBueKz7vyVtLULrrs6ydfumOX6q1OoruuXgUSpc5P3m5Wmp833mYyXJNVCQ+ahsGNIiXh2ch48QkafS0K6MwibqJ5O+3nMDfNKy5zQ+AFXKeZqZsMNDXeuNbLrJhDcZxaWK3kmJw/T07XRquurXC+0ODRfi7dNQZ8hpbUG259NXxW/uqKIhjIXG1I3M/o2YmaKTIRl7466ArunqTW+9hCgxOPhPjD1UONYqdnGIhjFwQEzL0uNvkOJjJ/g2P2ND3Pw9n9j+On76XvNrZzzix+h94JrUOMpS/GQCOnaDHPTEhlal2+k77I3svrnfovVb/8wUq+w78t/z/F7vkJpciygtgR8YFz7YplWFrzpnUw88mPy+/cHzET2atAt178OVNVaUDFEbXnjZeRfOs7M7hPOTcx2yO25fCVqMsbhe/aHmojW39DP9rtPOhFEtokIzNDny29u4+BLJfa9VPaYiOw6YSaid78zzXe+l2N4VLf6qd7s/YpLPQXm2LEK3d0KiUQzPi0yUuCspvEPjisUBRliJnYU7bCEdRFt5vHqxzxpaRLmTdB74kU9gRqGjqGXUWPJ8HoeNSVCAXE6q0U0vG/Hx/ejqBrtbcsimzTsGByBkp4jrqZ98zh7Tz5Nw/0kKnUUUV90lNJowIwUPD4CNdTmVnlWYnFkg3ldApjjT2IUixi5WbT2zkB//mMnNGcL3rLyzBQHv/mvKFqMte/6fbo2XIaiaB6C4jYjeR10vUQm3bOElbf+Givf9L8ojg6y7/Mf49SDd6LncoHIoYBzrvU6u3YDbRddxtA3v4I+m/OYiZwkdbEEHW99I9M/epTyyeGAb0usv5fMhWsZuuOJYPizFmfxzes5eOcudIOAiWjjG5dx7IUJBo/kPCYiw8qMu3RNkjWbk9zz7Rnv71Ij9PnG65L0dqt84SvhDrkG0tmqZYbntY7EkJL9B3VWrWpOiDd0M8FcGGql8ReaEkpMhGYq2lIP8RHTNAgpf6UwHz109vCqIy1CiNcLIX4OuMUq2iCE+DlrS9dqWw/Sdg5r8IjTS6Z9WYtFZMMNDNDoRGr0YcDI2F4621d7TUOhT8RzP3NKep6Y6vpcL8dZ+HKsLRKSkEqXFe/aSRGQ1NK/TYh62T1pzO/FGtCsH5uj0tIIIqZanhgHzJWQwWfqseAvi/JtkYbBiR99jVi2neW3vJ94tsMhIX5fl0YSzdnkJbtoDavf9iGW3Pgepg/t4sBXP05hdNDr1xKVy8WAnutvRcQTjNxxu+V/RTXpnJUpN3XBZhKrljFxx71VtcUiKFIKOm+9nOmf7CF/bBzdUDwOuYveuJmpA2MM7xgKRBH1nNNOz6oWnr1rwCEh7uy4ulS45s3t3H/nFCWdQOizHVRlH0U6psrxK7+U4bNfnKFiZbKda86WAwcrrFqpeqKU3Fl5bSdiNwxdRpMWJ41/yD5VQVZqkJZKCGlR1VAy80rB/p3nvJ21mf/s41VHWoBPAd8E/st6/zbr/TeB3qhG9VA9X+uHvdrQy6bzpK20NDaQ922zvi1SGoyN7aWrc21kHe94sjGDtQ8lPUdcsUjLz/hCGobUA74/oZCygXwuCnWVFqV6wW1E8VJicWSTqzyfLioTYwhNQ822BD9O2PuQMpsojG5/hJmTB1l6w3scdcVPVrzKinfzlLsIjDAkioT2leex5h2/Q7JzAQe/+nGmD+7ymod8xMUeV4nFWfhz72Fm9w6mn3k6lCApUqH9tpvIP/MipcMnTbXFUlykIUisW05y9SKG7vwJhsQ0DxkmMUn2tdNz8VL23/FS0EQkVDa9YTHb7z6JbohQE9Hr3tjGxJjOtseKDZuI3vOuNMOjOt//Ud4pjyIutQjNgQMVVjettMhI9zH7tAlVWlTFs2aRk2TONg/ZpMXNhzQ1lMzM49WPVx1pkVIul1KKiO3waQ/QhAOYrbQ0RVpo0nTjqzs9c4pSeYauDou0NOjPUisfSxgc89ArpXPWy1p1GnB8WsLgOkOk49YZDSGEc2GOTCLYqNJi1481nvb/TKE8MY7W3lnXHBZpKrKQHz7BwGN3s+jKN5Fo73UIS62Ec0HzUFBx8fqrSNRYkmU3v5fu86/kyHc/y8hT9yMNGVRZ7D4sIpNasJju617PyHe/TXlkxPFpEa4Q6MTK5SQ3ncPknT9ylBhbbQGFztsuZ+KB5ymN55zwZ91QkFKw5NZNnHjwALMTJcpS8ZiI1t+8lLFjOQ49PxVqIsp2xbjoqiz33DFdjRqqEUWkI+noUHjLbWn+43PTAJHExf3eb0oyDMnBg5VQ85A//NouM9uZ6xWFwTEPhVx//KTFKa9lHqq1BPUrgPnoobOHVx1pebkhhOLc+O3jLur408s2afGluW/2Ph92okeYhsbG95NJLyAZdznJ1lBvAmiQhJSNAjF/+v6fAog5rEeiUzmDPi3U/Q6VJkmLEoshXy7zUAQqkxNore2B8oDPirs85P3JB75J64qNdKy7xENY7Pb1Es6FlYeZe0zVRbDw4tez9Ib3MPiTezn+/S9hlErBhHV4x+y49CqSi5cw+LUvQ0X3OuUaAmEI2m+5kfzzuynuPxpQWzIXbUDramX4u0+jG1VSUpEKHZeuIt6W5OBdezCkQsVQqUgzvX/LwgzLL+pm2x0nKEvVSTTnNRF18Og9M8xMGb5cLeGJ5gA+8CsZHn6syPM7/UsBVP/54S47clQnX4AVqxrPRyWlRK/IyPPPTiIeRloUTcGoaR5ykRMrQkyomhmyfpZweis8n17k0f90zJOWJtFMYjApDRBKgyniA40jykPm5Ko7OztIS7a/+fHcaCD8WRUx9DqLBzaKRiJ8Ihqe3jiK/YRYRhX1F8GUssF0//Xm1WxiLGH6StSKcT7Tl0Bp6Ciaj8j5SUlIuZsYFEYHyA0eZcFFN5oXmhB1JaCq1Np8hCY0OkhK2ldfwOq3/ia5U4c5+PV/pTI7XXtdIxQWvuXnKY+OMPaje6yxhEeVSSxZQmrLZia++QOkDhii6tsiVDpvu4LR72+jMlN0UvsbUiAUlaW3bebAt3ZSKUvHIbcsVcpSZcvbl/P8904yPWFHCXkTzW29poVkRuHe784GEs2ZxMb8rnUpHbVl86YYV12Z4G8/7lVbwuDep1s/3H0PFFi0SGXFctWqE9ncgc3BtVgNnxYBsiJRhElQrKMaEdeQpUrAdCRUFVQVWQxeb0UiIqv0KwVHbZvbNu/UMnfMk5Ym0VT4qZRzvyH7EBVa6sf0zElassFVlwMkpJGbZkQdYUhiSoKKHr2I38sC93fp/15Pw2m3IisN+bSYpKX202dj/k5zcMR7pcMNGh2uBpGZ2P00yZ5FJLvCjkdCyUqoyhJCVEJT+Du+K5JU92LWvP3DCCE48u1PoxcLgbrusWPZdhbc+jYmHn6Q4qlTjspi1rESzt12E8UDRyg8v8e8+dhqi4SWqy5AScQZ/t6znvBn2yG3OJ7n+MNHAg65K69aTLI1zrY7TrqSyFXXIlJiGte/tZ27vjJFRYI70RwEHXJt/MGHW/ju9/O8sMs8R3UpA+QlNMJISn54X4Ebrks0de2qWJl41QjSAqCoCkaIGUhLVB1uPYsmComSiCGLpQArVxJJjOJZJC3zOGuYJy114H+4VbRYw+GnptIyd9IS6RMRcQPT9RK5/AjZTJ89gTmP7SAscZwiiClJykbx9Pv3e+75yUfgvWhAyahzWPskbF2WUZUzp7TU9QPxKy31CKmIqlS7i9NDkz36yIs0DCb2PEPnORd5zUJ+ckK0b4tNTjw+LS7CEowqwkVMJFoyy4pbPoBeKnL0u5+rLgXg78vqI7vuXNJrzmHk27eDYQSWCYj39JJ97SVMfOuHyIqsqi2GAmqMztsuY+S7P6GcqzjEpWIoaG1pFt+4jj1ff5GKb+VnYhpb3r6cJ752lEqluhaRLq1MuCjc8PYODuwusvP5+jlbbLXl4ovi3Hhdkl/6tTEGR6rXK5u8uAmL2zQ0PW3w+BMlrruuOdOvHa2katHnh6IJZIhso8TNBwajGFRuRTKOUQpTWuLI0hm4/swR8z4tZw/zpKURuB/wY3GMSpD5h0I2mh7+DMCAmdkBQIYqLWadOagtEdDUJGX58l005uKbUhORYQ3CJC1h5iEfOapJWpw85Q3Mpel1U8QrLydLvJ8/ZHybVIeZimaP7aOcn6Z9zQXVOj7C4lZXIqOIQsiJn7D4nWurZSZxWXnrr1EcG+TED78CFSOQw8UhR1LQe/NbKJ48wfTT2xyVxXHKNaDt9ddRGR5l9rFnA2pL67UXgYTRe7c7JiIpTd+UJW85n7EXBxnZPUJZKpRt8iIF571lJdNDRXY8NIIhFcpS9TjkLlyR5LzL0tz11anQtP5utcVNRv79X9vJZARvfc8IE9PhplybsNimoQcfKhKLCS6/LGHtx9pf+3yslMz2UeYhiFZalIRJWoTrYdBWXJRE3FRaAm0SoQrMK4V50nL2ME9amoTSVM4M2ZDZwgkBDUOdcGK36jI9c5JUspOY2ly0Uu0Bwk8uxzwkRGjuk7pQlGDfcyUq1nfsITru13WUGb0R85AQSAyUur+nbPBC2gQLOZ3rmzjN9s1AVv+Ov/Q0LUvXE0tla3/UCCLTVBSR4e3Ho84YknhLJytu+QDTR17i1I+/DYaMJEjxti46r7qe0e/fjTEzEyBLWmsrLddfyeSdP8IoVLxqSzxBxxsvYeiOJykXDaSltBhSkF7eTfeFS9j3jR2Oaahi+bWkOpNsvKmfx798NNIh96Z3dvLAXdNMmW4qkWoLVCOJWloUvvGlLmZnJT//3lFyBd3jjBuIKJKSe+4rcNWVcZJJETA51YJuKS1KLNp8KiKUFtUiLUYpRGlxkxbhLTeKZ09pmcfZwzxpaRJKLI6slAPRH+HEWdDU+jn17mN19ufyo6TTvgUMT+cJvcbNPqFlyOvT3rpChJMRNxpMre+dx9wOU2HPpw5ClZYQAtWYeUhSlyW4wqIbwlx/w0a+5qg6Qsx5BW4pDaYO7aR9zfmuwiA58ZQRorRIGdxcmXP9Sk1gDBdxSXX1s+KN72N8x08YeuwH4blgrL+dl16F1tLK6N3frTrlutSW1mtfZ65O/aPHAmpL242XYMwWGP/xDifZnB3+vOxt53PsvgNMDeY8GXLLUmXLz6/mwJOjnNg3E+qQe/ENrSRTCvd8a8qT2C1KbbGJS1eXwh1f6+LA4Qq//L9GQ1eBtlWW0TGd7/2wwOtfn4zIqBuWmNGcS7lkHiu1lRbhRAkptpIipMs8ZCotbr8WJRnHKHjJiRQSJZkIlL+SCOHUTW/zmBvmSUszEKAmzaS6ejHvlEVB0eIYetn0bTnTCDnqpVFpyDfjTKAt0cd0cRjdCPfvEbYCI5SqGlPjhu8hMmHKSd1FTRqEXd/VTjfKaEq8btOGo4fOtLRhGGYkxemgySkp8ThGmM+ADP/rNhWVJkcxSgXSC5Z59tn1axIWqmQl6mrvpPW3CIzH9yUsQshqk+lbyfI3vJeRpx9k6Mn7gv4y9ntFo/e2tzO9/VlmX9pddcq1/qrJFG233MDU9x5En5gFiaO2KOkU7a+/iKHbH0evGKYzrh3+fOEKskvb2fv1HZZ5qOqQu2B9J0su6OTRLx51zD9lqXkccm9+dye3f26SYqXqkOtXW/xXGh1Jf7/Kt7/WxbZnS/zah8Yo6VWTkE1YDCn5l3+bobdH4bZbvRm83X1GheqWCmY/8VT0+aHG1NDQZjVtXrP0fPBaomSSGLngcaik0xi5XORYLzckp2keOsurVP8sY560NAk1ZZGWfP0Txk4qp1dqmJN85KOpxHI+GEbFWYH6dCHrqCFtiT4kBlOloZr1GoJbDallIqrhpOsQnDmoMhVZQlVdZC9qhe8GSEsjAkqzfk7S0BtSjHyDzG2fBSWZDCctDaAwfAIlniTe2hVKSgLT8SkrkU65PnXFaeMiL34zkZ+4tCxZz9Ibf4GhJ37A1P4djsJiReE6ddOLltN+6WsZueN2ZLHgHduA7OUXo7a3MXX3j6t5W8BaSPFyyiNTjD+yxyQWViQRQmH5O7Zw6Du7KUyXqUjFTDhnRQtd/J5VbL/7JFOjFRdhEY6Py82/0MX4SIUffrsa/gxetQW8aov5XrJqlcY3v9LFjx4o8KE/mOCeB/N8+7s5vviVWT7xH9P8zd9P8dnPz/L7v9tCzKWWhIU7V/1qqsdksWCOFktEX38UTfHmXLHL4xooAiNf8qgsQoCSTmLk8oELo5JJnVXSMi+1nD3Mk5YG4H64UNPmis16YTZ48fe9t5PKGeUaF/8zSLhrZnZtBg0cFTE1QTbezXjh5GmMU8OUFKa22OX21vR44WNVjDKaiJtmmxqkqeHooQadtBuFNAyTjJ4Oow3rt8Y+JZ5o3mfA6jA/dIJU96LqYeQaKMqcUy+1f6R/i1FtL+wMuD6lxeN0a0jaVp5L74XXcfyer1IeH/XWtUgJErqveT0IhdHvfy+gtihCo/2WG5j+8ZNURqZM3xZDIA0FtTVL+/VbGfzmo1QqeNSWhdeeg5aOs+/OlxzzT8VQqRgKK69aTLY7yWNfPxEa/pztjHPbL3fxhX8eo1AKqi123ha/mQis/C0bY3z9v7u4+wd53v3eUf7gI5N8/BPTfPOOPI8/WeLn35Xm1ltN05COV2HRIxQWGyWLtMSTtZQWBb1c7dXO16IqoCZj6IXqw53jiJtJIXP5QF+m0pKvu1r1PF59mCctTULRYggtTqXgYvkR57OimSYHXX9lbK/S0OvmEamLJvxN2hP9TBTnQFoi/FqifF3qRRIF9jfo0CuEwJCmSN6sechRogJjNSS1NAddRzSrtJzmuEoi0bjS4vvIxbFBJzdLrSR0AcICPhWlUbXFS16CZfiihSQLLryRVM8ijn3vi8hyxee8a25KLMGC297O1E+eoHDwYIAQpc7fRGxhD1N3PVj1bcFSW269gtKJMSae3O+oLYYUSDXGsp87n/3feJFiASpSccKfpapy0btX8uRXj1Iqgo5CSWqe8Ofb3t/D7LTBd78+46gt/rwttYjLRVvj7HtxIacO9bPnhYU8/dgCHvxhD9++vYuP/d82lDk6w+fzpj9LVBp/MEOejbIRuk9NxzHyIVFC6SRGzsoH5fZ1yaRNn6tXeE0uG+5FM+e2nZVpvyowT1rmADWVRi9ESJNuVcZSWvRaSssZhJQGSjPmobnkkLEcbqUi6Ej2M1E4ad5vFIHfGbcpv5YwE1GY+afm3Fz1fZ/N6zNTfV2Rph29VkZcm6BIGs2746vjviGH7a8DaRjVPOhNDHs6EIkkRnEOyQMlFMeHSLRHOIRLIgWjWuHPSJCGJD8xyOzYCVN9CqgthBKXsLT/ihAsvf49lKcnGPjxd7xqC9V6mZVraTlvCyN33Qm6gZ1oDkOgoNJ2643MPPoUlYExj9qidbbRdvV5DH3jUSo6vmRzm6jkKxy+d79p/jFUJ3/L5jctp1zQefb7A6ZZyFJbylJDlwqplhhveX83X/rEGLmCrEYRudSWgF+Lj7hIperP4vFrifhJ3Rl4o1DKGzVVFjAji4yKgRpyAKjJOIaltLhHMX1aXMehkCBASZt+N0bhFU5waUPaxGVu27xANHfMk5ZGIapmIi2dpZKbrlkXQNESCEWlUpx9+ecHqGqcSuU0TuI6UT/+/Z3ppZSMPBPFU3Mf02ciCqgtPuLiJi/+95F911ApKoZ5oWxMaWkk7079yCAhlKbWHkIazUVcnQHyosQTyHI5dLG66ryCr6WUlKZGibd1B8iaL9lpgGB4CI3dX6XC1Km9HHnmOzx/98d44Qd/x457/oln7/xz9j/+ZYYPbKOUmwxxxrXMRT6y4n4dT7Ww9MZfYOzFJxjf8VQg14sdktN93Rsojwwzve2pQMK51Kb1xJcuZuI79wfUlo43XUn+4ABTzxxy8rZULGfdpbdu5KUvv0C5Ul39uSxVlEyS89+yjIc/f6S6+rMv2dwbfqmLSgXu+NJ0QG3xO+Xav55NXKKIieGqZ5uGwh17ww+u3IxOMlOHtGgi4IhrRxGp6Rh6zquaCCFR00n0mXzg0qRmLd/C3FkiLWcJQohrhBD/JYR4SQgxK4Q4IYT4jhBia0jdLUKI+4QQM0KICSHEHUKIlWdj3mcS86SlHnx5LqQALdtKZXaquh+CNwph3lRjqVZK+UmnbVhdt9Pr6eQcSqW6yOVHoivUyF0S6XhbIwNtSmulI7mYkzO7m5uoUMJNRFEOuT51JpSs2HWalLcrmEqLpjSa26Z2/4qiImVtQiJU1VRPzgaijlcflITlj9Wk/K4XckhDJ5ZpMwt8JCTgkBtBWIozY+x77Is8c+f/4aWHP0Nu8iQLV1/B+Tf9AVvf+KcsO++NgOTo83fz3Hf+khe+//cM7f+JaTJw92n5ufiJi71l+1fT/9pbOXn/7eRPHnElmqvWj2Xb6bzyWsbu+QFGLu+EQCMFilRov+0mck8+R+nooFdt6e2g9XXnMvi1oNqy5K0XkDs5xfFHjwaSzW1992qGD82w6+FRT7I5W22Jp2O87X9185VPTTA9Kz1Zct1OuWHEBaqp/92be38YwsKdnd9cKsxMVsi218515F4YUfFJDWo6jp4rBk5fJZvGmA2q2iKZBE1F5l+ZB0I/zmJyuV8HlgP/DNwM/DbQCzwphLjGriSEWAf8GIgDbwd+BVgLPCKE8MmgP1uYJy1zgJZppTwz1RDBiKfbKeUm61f0kaO5IJPqIZcf8T7pz7VPpQaRcWFRdgMDs3vMRFWNmogCY0WoLY2EPIfsq6lKKN6+K7JxpcXsu85+pb6KIhQVpNEwcWkqp8tcIbyEWUmYJM4oNfckW541j/V4uiW4M0BWQj6XNMfc8/BnKeUmWHnhz3HhrR9l4+v+F/1rriSV7SGebKN36YWsveTdXHjL/2bTdb9NZ/9Gjjx7J7vv+xT58QFf0jnpISt+RaZr02tpX3MBR+/6PJXpqVAzUcelVyHiCcZ/dK/jqOuoLWvXkFy3msk77g2oLV1veS25vSeYfv5o1SHXUIh3tbDoxnW89KXnnZWh7WRz6YUtnHvLEn70yQOUDCVUbbnx3V2omuAbn5v2ZMn1m4k8/i1Er0Fkl/kdcM393oPeziMDYFh/Z8Z1WuqRFlVgVMKPZS2d8Cgt9nmmtqSRhZIZdeQi3EII1GwWPYTQvCKQ4vS3ueGDUsprpJSfklI+JKW8HbgeGAX+xFXvL4Ai8EYp5fellHcAbwB6gN87jU9+1jFPWuaAWLaNymyViDg395DjMJ5uc5SWlxvpdA+VSoFyucmnD/9RUOvObJMSy69lQfYcdFlhOHeo6fnWUlsiiYuboPjfezLihhzaIcSnYhRRRayBTLfQiCFaCLU+aVHNi7unXr2uz9DCm+F9B187SksTEURCQmVmEqGoqMlMwNTjrmeXB3K2GAb7n/wq0tBZ/5pfpXvx+WixVKhjLhIECi3ti1m66SbOu/H3ULUEO+75J449/wNkuezyaZGhJiJhgCJh0VU/RyzTyvHvf9n0XfGpMooao+em25h84lHKg4PehHMS2m67ifz2XRT3HfOqLQt7aL1iI4Nfe9RK6S8sU5HCsndsZWznIAPPDZmhz5bSYkjBpe9bx6mXptj1SLjaoiU03vHBHr7x6XEmp2SomchPXMCruvgJjPuorZKd6sHhz9Hi3jc9USHbEU5aVGGYSeRcSosbCtJ0xLXysSguO6LaYvqu6DMWOXFNQW3JnrWwZ8np+bTM9TFEShnIMSGlnAF2AUsAhBAa8EbgW1LKKVe9I8CDwJvnOPxPBeZJS4Nwn69ai6m01KsHFmnJTQbKG1ExmkUq1QUIZvPDIfOKMEEFfEhqmIlCVJKYmqA3vYqTM7vqT7CWQ65bbfETjqiw55A6AYdbRamqPSEoG0U0pZnF4Xz9+JZZEIpaN5mgHQkURW4ajmw+A4dQ1FCO0mI74zY4VmV2Ci3TGnSEDpiJpHefRUSO77iXqaH9nHPFL6PF0qHRQoGwZ+t9Mt3Jutf8CqsveRfDB5/ihR/8PVMn97rqyoCJyG6vKhpLb/gFcqeOML79iaCZSEL2nI2kVq5m5K47zXT0Tgg0JJcuJbVlMxPfugfDkB61pfMtVzK78wiTLx73qC2pxZ0svHIVu/97ezX02VJb2hZlOe+WJdz3yYORast1b+sg3aLy9c9Meh1yqU9cwjaYuzPu9ERz5iHwkZN0PMSnBZSs5XA7630Qk0KiZDNmDpefbawSQmz0bb3NdCCEaAO2ADvtPoEU8EJI9ReA1UKIM7jWyyuLedJSB9JvthGgWUqLlNIhAG4i4H5tkpYJT/szgpB+VDVGMtEWSloaQRiRkg2sqryoZSNDuYOUjHxtE1EY/GpLlFNuTYfbJr9UJyuuoCJLxJR4bbLWCOybcQNOtkKxlBbdl2jL7dcR6D9iR53pzUmJFiA0DRSldo4hgvMtz04RS7eG7g8SFzysafzUbk7svp/Vl/w86ZYF3vq2mScirb9DMBB0LzqP82/6fdoXrOWlH3+aUzsfDCUunhwuBiRau+m7/A0MPnIX5fHRqglIWvWkoPf1byZ/YD/5nTtdpMYkL+233EBxz0EKOw541JbY4gW0XLqewa8/5qgt9kKKK999IYNPHmN492ggtf8l71vHyd2T7H40XG1R4hrv+s0evvVf44yNedUWm7jYcBOXMGLi9W2pqiy69PYD4cRlZkIn025G4EVlzVVjInTBRADN8mkRvgNKtUnLTC5wrKvZbKi/yyuCEBLd9GbiO8AO3/YbTc7m34AM8FfW+y7r71hI3THMb7KjyTF+ajBPWuaAWEs7slIxE8xFwLxZCBItXRRnRsOfvhu5mXjMI/Wrt7UuY2zigFU/zH8knCCEHglRR4fPRNSVXk5Sa+HI1Pb6E7TbR6ktvtcB4hK2Od1GKDU1UDYKxBp0whUozu8Y6o+BSRwNPXxpAxuKHQrfYB4UJRZDVmr3WQ9eda1+fSEEQtVqRw+FoJKbRvP7s9QgLs5r3eDo9rtZsPJSOvs2BLPe1krr79pvEwlNS7Fyy1tYc9m7Of7iDzn6zF2uMGnpcbSt+qhIujZdQapnMSfu+ZrHTOQQm64FtF/yGka+912MUrmqtkiIL1hI5tKtTIaqLa9l5rkDTO8dQDcUKtaWWbOQnouXsvtLzzuhzxUr1LltUZbNb1jMA/95yLuQoitL7lVv7qCjW+PLn5pwstTaxAVw1BaoEhc3efGTmLCIIWefx1TkPceGjxfp7KvvF+Y/M53ooVQMvRBc5VloipmrZSa4bIpyNs1DZ84R9zZgk2/7ZKPzEEL8JfBu4MNSymf806z1ERr+sD9lmCctjcKluMTaTZJanhqv7iP8iTbZ2ouhl0215WUwCfnVke6udYyN78cwXE/xTT9ph6grjnoS7EwRCivaLuTo1HYqRrm+Q26wAy/h8JEPIeovshggLFGhzr5+Sm7SUncMBaNOZJCqJamUC44yErhJS9ASlp2+0Ji0rcST6HNY0fZ0ItHAMmM1GeVUyc+gha3s7CEu0imzv5/Ro9spzo6xeN11HgXGkynXiNh0HNLhIS8GdC86j3Wv/VWGDjzJwce/hqHr1ZBol3nI8W9BsPjad5EfPMb4s4+G1ul63Y3IYpGpRx4OqC1tb7iO0tGTFJ7f56gtSEF8+SIy569i8PYnA2rLip/fyokHDzJ5dMpRW8qWmeiSXzmHo8+Ns+/pcY/aYiaeU0FV+eU/WMgdnx/npV16TTORJ9W/BzA9/gABAABJREFUDN+qJqSqyuImQW6yolsEqViCoRMlFi6rTf6lJFIVVZIxjEI4MVcyKfRZ37kiQG09i464Zw4HpJQ7fVtDa6MIIf4P8KfAR6SUn3DtGrX+dgVb0Yl5Rk2czqTPJuZJSz345HUpQE2kUBJJStNjQULge5/IdiIUlfzUsKcP53WNX6Cpm47VT1fnWgyjzPjkoZD+6vu1RJqIomCpLYtaNwGCEzM7o+s6bcJ9W0LNRIp3f1jSuFqExkOWQlQZU2lJuRs4L/2fuxF/FTWWQK+TK0eJJwCBXmzsgqskUxiFfHDBcJ95pWnUO74U0VCEk1vR1/OzJmmB4PzCFBdA6jrHdt7DwtVXEE+5TUteAuLp06+2eJxsXeRFQnvPGjZe9b+YHNjDvoc+ZyZ7tOu5yY/VT7Klk74rbmXg0e9RGh1ylBR7U5Mpuq57PeMP3Ic+OelRW2KdXWQu2cLkXfc7aoshham2vOk1TD2xm9zxcaTl12JIQeu5S2hfv4BdX37BlWjO3NexrJX11/fzoEttsbPkmiRG45IbW7nkmhb+7g8HKFVEqJnIyd+CqGkisus0g6HjJaQBC5bXUSwNc5lAf7izENKjtDgqi53KP5sKNQOdTUfcM2gemhMswvJR4KNSyr/27T4A5IHNIU03A/ullD+zCW7mScscEWvtoDw9Xi2IkN+FopJs6aYwXYM8h10jAnlU3K+jLyqalqS9bQUjY3uix2vURCREhNnIpaRYUJUYy9ou4NDUMxjuu2sjvi0uQiHcCombuISQl8g8L00oWmWjQNxvHorw41GEUjcHi6Yl62ZAFkJBTSTNlcIbuHgpiSQYxmmbiJqFEE0oLdbncJQWdz+1iIuE4UPbqBRm6V97VTDpnI+shPq1uH1bdBd5cRGXbPtiNl39QQpTg+y5/z+p5GeDNxEX8enccBmZvhUc/+HXoOLNvisMaDv/EmKdXYzf71ot2iIvrTddTengMYq7DnrUlsSGFSRX9zP0rSfQDcWyiimAwsqf38rRH+xldihnJZpTPGrLvsdGOLJzyiEzzppECCrE+MCf93PySJlvfHYyYCbyKC4+1cVvInIcbl2+LIarjVnHe1E4dbhILCHoWBBHr/EUJiWRRFmtpbRkU6Z5yOOVbZGW2f9xeVoQQvwZJmH5v1LKPw/OTVaAu4C3CCFaXO2WAlcDd8x58Mbm9+9CiO6Xq/950tIoXIqLFBBr7aQ0Oebs8/y1X1tbsrWX/NSg0zZQF4uICO84jcwpDN2d6xge223m96gRjl277zByEX4zB5CKYGnbBZT1HAO5faEZdL19heRtCQtZFr6yMJOPu9xFdCIVGNc4JT1PTEuF1/NPWdRPCqfGkkijguF3snVDgppIN6a0SFckzyudslxR6ipLHkiTtKipTGBXFHEx9Aondv6IvrWvJZbIRBKWen4tAd8W3SYw1cy4qWwPm67+/zAqJV6675PohXxAbbHHVSQsvuYdFEcHGH36x96oIwMECl3X3sTUU09SGR01T1rbt6Wnl/SF5zH53QecvC2meUWh882vZfyBFygMT3sWUuy8bDXp/jZ2f22HlWhOcQhK77oOVr+mN1Jt0aVCW0+CX/2ThXz+n0Y5cqiCjrDqBh1z3aqLf3Pvt+u44Y4isnO0nDpcZOGyhGfdInc7h8hInKSQiueAqC6YqPhUFiHM7LfGjO9cEaC0Zk2/o/9BEEL8LmYOlh8C3xNCXOreXFX/D5AG7hZCvF4I8Wbge8AI8A8v8zTfC+wRQvyWaGSF2SYxT1rqwSYfPthKSyMEI9XaS35yMFDecNhzHWfc6uJ95p/urnUUi5NMzRyvOWbDJqKoRHMuh1yAuJpiUctmDk485UtwV0dtcZuJ/P4t7nGc+op3838Gf2Zd4e7H6+zblCOuUDFkCBlx+Wiomr3eVMHrl2Htt6EmXOtX1VFb1KTlA5NvTgo/7UWhhah+tgb6lVJSKcwSSwZJS6Cd9Xp66CDlwjR9q18T3q+LxNTdwsxD7jID4slWNl7160hDcuCxL1kqisu/xWUqSmTa6X/tmxh6/IcURwZ9iy5Cdu0mEv2LGb/vR0G15fXXUNxzkOLeo2ARF2kIMlvPId7XxfB3nnZS++uGGcK/4l1bOXTnbgrTZSpS8agtl/7qOey8b5BTB2edNYnKUnPUFgOFa9/WwYatKf7hIyNUpM+3xUVcPKpLyAZ4fFmqfVgJ5Xx+LccOFFm4PFV3JWjDkJEPElqqtk9LmHlIacmG1H6FcPbMQ7dYf28CngjZzOlJ+RJwFVAGbgc+D+wHrpRSzi28tHGcjxl+/U/A80KIq89k5/OkZY6It7mUFlw39ZBzMt3ZT27ilJk1NqJOFKKuA7UITyrVSWfHGo6eeNwaL6RuMyYi//saIcwrOy4hV5ngVO6lSLUlkCXXnk+Yf4uflDSoAAVNR8F2UkqKRo6EGn6T9UNVYuiuyKCwCKJ40lRjy8WZmn3Fsm2UZyZcfQXJgP1ezWYRmkZlfOz0iUgTkOUyIha9kKQfRjEPhoGWynpzq7hgR+6YA8DU4D6yXcvQ4umgyhJCWGqt+uzP5RLWlzBAi6VYd8UvMzN6lGPP3W2RlWDyOSR0nHMRmUWrzEUV3WNYIdBdV93I9HPPBNSWxMI+UueuZ+oHD1vmIdPMIlHpuOVSRu99jnK+5FFbFl6zFjWlceDuvY6KYqstiy7oYfF5HTz8hWNORlodyzHXUlsMVH7jL/rZ8XSOH38/h47iTfHvMQ0FQ5mBKqmJuEjZpiG3GWjXT2ZYuyUbqONHJV8hlg7P5SJUYZG76gHj+LSkExiFYvUUty8N2cbO25cH4gxszUNKeZWUUkRtvrrPSCmvk1JmpJRtUso3SykPzGng5ua4W0p5JfC/gQ3A/UKI24UQS85E//OkpQ5sxcCTr0VArKOL8uSYJ1eL08Zn4kl1LkYvFyjOhITN1zp2a/i1+Nv7SczSRVcwNLKDfGG85lg11ZbA+LXVFqkIklqWZW1b2Df+eFWV8EUSedv7yvz+LRCuqPhUntB6tfK3CIEuSxiyQkJNh5MhHzQ1gW7UXotHi6cRQqFsL93gqC143sezHZTcPlG49vtv9EIh1tFNaazGulIRCFussBFIKTFKRctpODinMFTyJlHTkr4n4FDyYv6dHNpPW+8qz/cTSljsNnVSjboXScSOEjJkNcLIIi6pbA9rL3sPA3sfZWT/NieiyBnfiSaCvstvYebwHmYP7w2EQGdWryPRt4iJBx/wqi0SWq5/HfntuyifGnX8WqQhyF5xHkIRjN230yQSVm4WqcVZettmDty+k1LZJDImgTAJysW/uIbt3z3O2EDRUVt0aUYR2WpLz/I0b/7Vbj75V8PMzuLxb3Ey5oaQFzeJcUKkfSqLP8GcjmDkZIlTh4tsvKzqQG3DrcgYUlCaLRNLR5BgJ+GigT9Xi5JMIK0VoN3XMCURA612QruXFa+8yvKzhkesv58HbgVeEkJ89HQT282TljowSgXvzd56HW/rxCgXPblawsmLIJHtRI0lmR0/7twcAxFEwqvWBAhKo/larF+0o2M12cwCjp18IlAlknz4+vDsCy2LUFvaL6ZilDg2vSPC8TbETOR+7yMukeTFDSVEpfH15d9f1E3JOaE2JjOrahxdjyAt9o0VhViylVIhehVwISHeYpoXGyETQkKsq5vy6LBnrKg5hLVvpj5grvViGE5OmUb6tElLmE+LM56rnV7MMzt+nNae1VafrqfsKMJCI2qLj7zYZMX2c7GIS3vPWpaffwuHtt3O9NBhh7D4nW5TXf10bLiIgYfuAt3w+doIOl93PVPPbKMyNl5VWwxIrlxJfNlipu951DIPYTpgxuK037CV4bueolLxLqS46JZzyQ/PcPLxY2bos527xVBYffUiulZkue/fD3nUFjvhXMkKh/653+hBSvjyJ8eq5iMXcYFqArgwvxY3sfHDn59l+xOztHRo9J+TcZyDo1CaLRPPVEmL26/FWQDVCB5YSiqBkQ93blfSjfmjzeOsQQAfBi4AngT+DJO8/NxcO5wnLXVQmQm/+cTazBD40pQVEu8oHsG6QgjSnYuYHT/h2xHScVOmoyrJCRtz6eLXcHLgacqVfJWUuOsqQQIVag7yj1lDcZGKIKYmWdF+EQcmnqRiFIN5W9zw527xE5ew9Px+n5YwwhJI/S8CBKZomKQlrjZ24VOVOBW96Llhh92848kWyvmpgLrirhtzKS01iYutzHR2U3YrLQ20mfN+wLAS3zlKSwP9VPIzKPEkilrn6ddqNz18ECFUWjqXVb8jg0C/DhGxSYkhnU3o5uYpk942AXORTVwkLFx5BT3LL2Tfw5+nND3uSTxXJTGSBRffRHF8iKldz3rJjQHZtRuJ9yxg4qEHPXlbBIKW665k9rGn0SdnTeIiBVJC6w2XUBoYZ+rZQ57U/rGODH3XrGHvN3a6IoVMtcVQVF77wQ088+1jDB3Ne9QWt1NuPB3jfX+8kG9+ZpwjByqhxMVNTvwb+BxunXZV05BhJbrb8cQMGy9r8TjhQpXcuM1IpdkKaibuqlNtI1TrWuRzdBdCoiTjGIWfMtJyOirL/yy1BQAr/8y1wDswP/03hBD3CyE2NtvXPGmpA33WIi0u85AUoCaTqKkMZZdfi4MQk2Wmc7FDWhoNX67WCX8drGffsM0/vT3nomlJTgxsi65bc1xfnSi1JaSvZW1bUJQYByafCnbsdsp1+vL5t9hlrvdRoc6Bcn/7CBSNHDElhSJU8/PWWQ5AUxPoeily1WVbKYgnWykVpiLqmH8T2Q6MUsEMe4bwC5mb5HT2UB71moc8N+SaM28SEmQjpMWeozVPM0dLxlNeS+WZHNxPa/cKVGtZgyq5k972NvnwkRLP53c5yNokpuqrIqsmH0+yOomCYMUFbyLV2su+hz6HUSp6zUTW30S6jZ7zX8fgYz9AlspBteWq65ne9hMqdt4WaY6XPn8TSmsLMw88aZqHJOZCip2ttF6+geHvbAskm1v61gsYfuYEI/vGTWdcl9qy8rV99G1o595/O+jkabHVFrdT7iU3d7D54jQf/eAppqdkJHGJ2sBLWADPawApJS88McOmy7wZkP1qjA3TPKSZpijfhcxejwvdUtPc+1IJpJu0uJ9f0mdpCR0Jjh/AnLazM+2zDWtV6i3A3ZiOwtub7WOetNSBPjsTSRScsGd7v7+eqG6ZzsXMjh0Ld8aN6N/0o3GfoUETUS3yoSgqSxZdwdHjj9ZVW8zyCBORT11pRG1RlRjruq7i8OSzTJeGQ3O7BMxE9YiLLzlceK6WkHahjsgKRX22YX8WMM1DIDGMsic7l//GHE+1UbTWmwpNWw/EWzsBKE6Oene4b8ju+l09lCfGMAq1fWqIGC8KUZ9ct5J2Kcnqk2wtRUhIqORm0FItoUqJsE00rn3TI4do7Vlp1ZGBeQcIi1NW3dy5WgIOuy7yUu0Hx1RkExcVjXMu+wX0cp4jT33bS4KM6pg9W67BqJQYf/7xgCmp5ZzNxDq7qllyDUAKFKHRcu1rmX7wSYyS4Unt337zJcw8dyCQbC67ZgGdFyxi71dfDKotQuWq31zPC987weCRXDW02ae2SKHye/+8hHJJ8rHfG6SiCw9x8ZuLnN8drx9Ltdzln2L1s/eFAuODZTZe3m5FHikeMmKrLIYUlHIVjLJBorV2qn8ZcuAqiThGsWz9IO4DC5TUvHnoZwA3CyH+RAjxNSHELmAIeIO1r2kOMk9a6kD3ZVx0E5h4e2fAPBR1F8h2L0Mv5SlMhztTevxaQpSaumqLn8RYv+yiRZegagkOHX0wOOYcw5+944arLVIRLMisoSe9gh0jP6rm+wgxEzVEXPzkxZ/fRRHhhMUZRKmGU1v9FyrTJFXfOjk1ENPSAJTLwVBlx+HVgGS2m8LMaGCfm1BoyQxaqoXi6EBD5pxk/xIQgsKJo6cXQRTW1lE4qq8rE+MoiSRKsvEn2UpuOpBYLgxCgtR1cpOnyLQv9pqG7PmEzNM9P4eouOrboc4BpaYOcUFCLJ5l9SXvYuTQM8wMHHT8XqoOvaBpCXouuJqRpx5AFkvV+Vp5W9ovu5Kpp36CUSyCIZz22Uu2IvNF8s/t8qb2X7WExLJeRu993pNsTkrBsrecx7H7DzA7XvIspFgxFBZduIC+je089LmjDgFxp/e3SUy6Lc4ff2opzz02y5c/Ne7ygxGh5MWtqDjmHZss2fVcZp97vjLKpstb6F0SVOP8ZGjqpOn7l+0LPz7sbLhqMkhqhCKCSQ7tPC7xxqPbziTq+IM3tL1aIYT4RyHE/ZhJ7CTwZeAvgbda778B/BFm2PbCZvufJy11YETkxrATzDnrD7khgsQilu0glmpleuSwc9NsPIlcg2pLSH+qEmPNyps5fupJZnNDZ0xtCdQNqSeEYEP3tcyWxzkyvT0kP4sS/tn8xCWMvPj3OeP7CEsNFaWgz5DSfKSlRn07CV25UjtfSirdSWFmJHy1ZxdxSXYtpDB2ynkfRkbsMiWeILGgn/zRQ95+3HXDxpK+92GvQ96XJ8bR2jtMNavBC6y5WGIwiiQM+clBpKGTbe/3jG8TEb/K4s6UG1RVQsiKfx0i2/fFT1ycCCNo7VxB97ItHN72bajoAbMTEro2XoE0DMZfeCKgtrRu3gqKwszTT7simARqKk36ovOYefAn5s1K2v4cCu3Xb2X8/ufRy7ov2dwqEh0pDt61x7OQoq22XPbeNTz3neNMDJccYlGSWnVhRctMtGh1mg//7SK++E8j/OThnMeB109egmSlSlhs2CrL9ESFR+8e57p39fjMU14Tkh2RNHE8h5ZQSXWGk2C9UEbEVIQaljxShDroAoh4/UUaXxbIM7C9evHbwEXAHuDfgV8DLgVapJQbpZTvllL+nZTyR3PJGTNPWuqgkrOig8KIiJWrRfrJA/Z7ezOf8LPdy5gZPeLtRATb+fuo9zrYxqu2dHetp711OQeO3Bdd199nHbUlWBautiRjraztupJ944+RK0/WNhPZ/UCVuIQ51trkJWzz17Xrh/ir5PVpkjZpqfEbCOvRKKYkEShe0hJCBJLZbqRRoZSfCtyMPfU6FlIYOeUbi9CLmpCQWrqCwtHDnn5C64cRkiYvkuXxUWIdYeutRfdlkpaQJ+mQOc5OnCCWbCWebA2ahtzKj4+w2Ps9RMWVi17oXgLjX4fIQ1zs/TaBkbDs3DdQyo0zuOfxatI5Vwi0FovTs8WltthzNkDR4rRfdBmTjz2CdKX+x4Dsay6hsHs/lYExb/jza89DzxWZeHK/J/xZKCpLbtvMgTt2UqlIj9piSMHKqxbT2pfikS8d8+Rz8ZuJDBQuvqmTN/9qF3/92yc5fqzsUlj8BEV4yIqbsLhVFoAHvz1Btk3jgms6wg8GqoQFYPLkDC39maA5165brKAkInK4KApIGepLJhJni7SI099evVgnpWyVUl4hpfyglPLTUsptZ2q9o3nSUgdGftb7COw61mJtnZSnx5DS8KT4j0K2Zxkzw4fD6wlqm4iaVFvcxEUIwcrl1zM8uoupmRNzV1v8++z3PgLiL1vSci6tiQXsHL2/euHxm4lqOdKGqS5RiPocUDUNWQpPvjJFSmtMGbDbx2IpymXfirPup0AJyXQnICjMjDhl4DuMJCQ7F1IYG6gfPWTtTy1ZTuH4YaQe3cD5xPX6hKAy40JlfNxZzTy0v5D+y7lpYpbSEkW+7LLc2HEytsqCzzQE0fq5TV5cRKVSznPs+OMcP/EEU1PHMSqVqpLiEJYQ4mKbf1xbPNHC4o03cuLFeyjnpqpOuS6C2L35CqQ0GH/+CWscHHLTdtHllMdGKRzcjye1//KlxPoXMPPI0xZhASkFSjpFyxUbGf3hc+hWun8n/PnmjRTH85x49Jgn2VxZqkhV5dJfWs1TXz9Cblb3Eg2fmchA4T2/t5BVG1L8+a+fZDYvXU624RsQICy2yjI8qHPnp4e45p3daDHF48/iV2zM9gpTJ2Zp6c9GOunqhTJqMiqHi3WkhiyhoZwtpWUekZBS7ns5+58nLXXg92lxI97eidR1KrPeSJEon5Ns93LyU4NVn4gGyXZdtaWBftraltLdue701BYfmZF+shISZiwVgVAUNnbfwHjxOCdnd4fkZ2mQuPjJS9jmn3uEylLUZykZOVriza3rFdPSlMohi7S5brKKopFIt1OcDoYouwlKqrOP8swEejEf4mAaNBcll6zAKBQoDUcQnQaIRSN1hITyxBix9s6a5McfwVPJTROzsuHWw+zESTLtizzExmMagqDK4iYsmOsWHT7yII8/9fccOfYQR48/xtPbP8XDj/0lTz/37+zdezeDAy8g9UokcXHUFmedIuhbdRmJdAfHn/0ebhOQrbaoqqW2bHsAWSp5yE8s205m3UamnnjC5cQrUKRC5jWXMPPo0xhlwwx9xnLIvW4rM9sPUjg1gXT5rmhtGfqvWcO+23da5iEztb+ttmx84zLUuMoT3zgZqrY4JiCpgGo65k6PG/zznw4hZZW4RG2O6uIiLDMzkr/59SN098W59QMLHZIUBVudmTiZo7U/a5UFs/HqhTJKBGlxIotCTERny6dF4CKrc9nOyqxfHZgnLXVg5PPBQksFibWaT6LOas8iWMetmGQ6FyNUjenhw85NVfoVlZBxqu8j1BYLtdQWgJUrbmB8/ADDo7vOvNrif+8ryya6WN1xGbtHH/SaiZwx6hCXMPISBvf+sGUBLEyWBlGESibWWbs/3xN/TEtTLs9YJgbfRdRNSFp6yU8P1/RTSXYuBAT54ZPR49v1JcRa24l1dJE7sK86nps42PX9cwpRPfx13OTDqFQojw4T7+6N/Hx+GOUiRqmAlq7v2CylJDc5QLqtL9i3pGq+ceYWJCy53DDPPv+fHD3xGKuWX8/lF/4OV1z4O7z24j9i8/p30dm+ilxuhJf2fZvnX/gilUIuaCqyCItjbrLUGQWVFRe8iZHDz5IbORFog4TuTVdgVMpM7Xk+8P21bb2E2d070WdzHofczMUXYEzPUth9ECTV1Z/XLiW+qJvxH+90HHLtlYCX3LaZ4WdOMH1qJpDaX8bjXPiuFfzkq0coGwTVFlkNWTZQyHbG+aNPLuGhu6f42IcHmJiQ9cOeZZWUTI1X+OgvHmJqrMKHP7kaLa65Fl/0+snolnkKTP+d0f0TtC1v8x4zFvmSUlCeLKC1hEcCOblbnPPadSCerYy4/vNqLts85oR50lIHRtkMMQ0jF0osbuZqmZ6oFta6n2oa2e5lTA3tD+yzTUKB7LjO/jqv65mJgGxmAUsWX86eA3dTqRSDSkpI/2dKbQFY0XYRLYleXhj5QTDFP0QTl7C8K24zVIhJKjyCqKrqjBdP0RZfiKI0d9FLxFsolapKi5+42O9TLdWVvT3RQ67XqpYg0dFLfuiYl4D46zp9Q2btBmb37IqeoK1a1PgM9UxIpYGTSF0n2bckUC9KRSnPTAIQy7QF9rnDnYUEvTCDXs6TzvaEzj1sLJuwSCk5eWob2579JJqW5NLz/z8WL7wYVcRMM4yWobtjLauWXssFG3+Ri8//IKXSFE8/9ylmZ4a8xEWXHiLi3lq7V9Lev47j279XJSw+taV97QVM7NzmTUQnIbPiHJR4gtyOFz19a+ksyfVryD31grMekUlOFFqu2MjEo7sxJB6H3JZ1C8ksbuPIvQc84c92Yrlz37SCycE8Lz02EVBbbDOR279l5eYsf/P1Fex7scCv33yQpx/NOwQjbLMJy+CpCn/0jkMUiwZ/8bVz6OiNeZPNRdjFDSnIjRWZOj5L76auyHqFoWkSPVXC6z4UZLEMMQ2hqcFjq8F0BfN49WCetNRDpYLUXVEgvnMk1tJukha/yuKDfXNv7V3N1NABqyy8bgB11JZ6xMWsa/5ZsexahFA4eOz+8P5fJrXFNBOpnNd7M/nKFDtG7nPNO5q4RKouYYnjIhxyAxc2IZgonaI90Rco94wVgngsQ6nsXQzRfyMXBqRbFpCfGgqv43qd7llikpYa/bnbZNZsIH/kAHq+6FFYPGpLDeISKAsZq3D8KLHOLtRMeHhq2PxM0iIcnxa7Xljd/LQZMJDMdjsKR6BvJy+L9Mzx0OH72LP/LlYuvZbzN/wiiXirx7zkjyxKJzu5cPMHyKR7efq5f2dk+CUPccGVfM4xE9lOuZtuZnJgH1Mn94X6tnSsu4jZY/spTYx5w58VlezGc5l5fruL8JgkJb31XPLP7UTaJiJpJpxruXwjxSND5I+O+jLUqiy64RyO3rMP3cDlkGsShXR3inOu7uPJrx72ONG6c7e4zUQGCqvOzfLxu1Zz2Q2tfOSXjvLJPx8k5xKUDUupsU1CRw+V+MO3H6SlQ+OjX15La2/cIkLCk7rfY16iagI68fwoakKlfU2nq573SCwOTRHvCfcvMwpFc52hMJwt0jLviHvWME9aGoBeinB6FiZpKUWYh8KOz9aFq8mNn6RcqvrKhJIXW22pp7BEEBc33GYiVY2zdvUtHDvxBFMzJ19+tcVXPxlrZcvCNzGQ22dmy3WHJocQF/NPiOoChEYOOfPytXXNwZA6k6VB2pP9NIt4LEuxHFzB2X9zTrf0UsyNe46dsAiiVO9ickPHQ2/wHhXAapNatgqhauT27Q70FXgNYVbKQD0/+SkcP0Zy0VLP5wqQD9/78uwkWjqLUNW68ndhaph4uh1VqzpRusmJ/3PbKkshP87R44+yYc1bWLrocgSKQ1T86xa5CYymJjh33TtZ0n8ZL+z8EocPP4R0crpgEiSXCcrO35JuXUjP8q0c3/49cyE/FxkSEtK9y0h09DK5c1uA0LRs3kL+wD4qU9PVDLkSUuduxMgVKLx00MzZIgEpiC1aQGJpLxOP7PZkyDUQLLh2HdOHxxnbO+aEPxsucnLxL69l70NDHHphxnHUjTIT2cRFS2r86v9ezEc/v5zH753it249wLaHc+x4usDTD03z0Pen+OE3J7jjM6P84dsPsvScFH/yX2tItsa8kUeOs6431Nnep6Nw+PEB+rf2osZUjy+Lm7wUh6aJ97Y65iI3jGIZkYjIzFzPMf/lQpi5p9ltHnPCPGlpAEYhSFrs88pRWhqBgEzXEhRVY2r4YOApwWMi8rULU1v8xCXQl93W/V6B7q519HRt4KX93zGTvrnIkXSRDpNMRagtfiUlQGZ8711morZkH+f13sz+iSc4OfNSw8QlQF4CeV+85cFsuWaf0+URDFnxKC31UvjbiMeylErh61G5b+zpFtMfJD895LlI+SOIMt1LKE0OB9P5R5hKVFWjZdP5TD71WOBpLaDmRF0YfYqMv7xw4qhJWupdWF038MrMpGkaaqBNfnqIVLYnfI41/IQOHX2ATLqXBd2bHIIBeNYd8m8OgUFh1dJr2bTuHRw++iC7d33TJCKRywKY5Us23kBuYoCJoy9im4DsOgqm2jK+cxsYhsdMlF66EjXbQu7F56v9GgItnTFNRNtedHK22IpLyxUbmXhkF7ohHYdcQwqS/R20b1zI4R/ur2bHde1fuLGTtVct5P5P7LXMRkEzUckqdxMXA4Vzr2jl499by+rNKf73e4/w++84xF/+2jE++Wcn+dq/DvHAt8a54g0d/O6/rUJLqQ5hsVUW8+uvZs/1+7NIKTn82CmWXt7v1PGrLLo0lZZEb5TSUvrpU1rmcdZwFtf1/tmBUfSSFimqNwitpZ3cqSOufQIRduUWmBc6VSPbs4Kpwb10Ldrk6SusjURUL87WA5uQmCerlJ72zmtrLCmstv73wNrVb+DJp/+ZoyefYNmiKzxzBIIJnazxnM/ovrkoVNPa2xcRd2iz671UhLkAXWYN53ReyYsj95LUsnQmF5vjuesrihnm6CqziYgTOh1BNoSPMLlfjxdPkdbazBT+TSKhZU3zkD1X//DWjUiLp4klWyhMDpLpXlrdR/XmKDFXEEYo5AaPkV2+Njig/Xu6XndcehVHPvW35I8dJrV0WfVoExFtwhBCogD0fI7yyBDJ/qWBurX6K9ukJQouglKYHibZ0hO6D/CahgAMyM0Oc2rwOc7f+IuOwlKtV2NYu45inksLujaSOreTZ1/4DCeOP8HiJVdgm4nM4986tg2BVCCR6qBnxUUM7H6YjmXngbAca62Hi45ztjLw5PfJHT9Eetkq5/MIodCy6Txmnt9O6xWvqf7m0jQRTdzxPeQv3oZUBRLpmIhGvvog+SMjaCu7PY6q/defw4EvbuP837wEXXFlsxXmukKv+Y0N/NfbH+DQc5Os2tKCgkBBQbEPNAG689qoPhkJSLfF+dA/LOMDH9WJJQSxuEUuXGqKX0WxF0z0h0i7TUOGFAzvn2b6VI4lVyy2+hJW3ar5qDJTRM+XifcEnbilFMhCCeHOlOsiPeJsxeGcrlryKlNahBBLgT+fS1sp5XubqT+vtDQAWalE7tNa2qjMTAVMN47Jx6eSSAFdy85j5MhzGBUzdTWu+jXVFlcfZplP2fDss+t6FRezLiQSbaxZdTMHDt/L9Myp2maiZtQW974IM5G0VJjlbVtZ0rqZZwe/w1RxKFpx8aku5ktRc/OMa/djYTh/kO7U8uo4jT6tSUk8lsEwKui6awE3+6bnqRsRQeR7rcTiJDsXkB8+7lEu/BFBbnUk0buQzDkbGf/xjwJjehx5Iz9HyHurbW7/PkQ8YS4b4Bs3sj1Qnp4g1tIRPpavfmF2jFQ2GGouQuZvE5dTA8/QkllIV9vqcMISkSvd6dPlx9Ka6WP1ips4cPBeCrkxj5NwmNqyYOUlzIwcoTg5XP2OLUUllmkn07+S6b0vOGX2/sy6zRSOHHaiiBwT0ab1GDM5SodOmETGiiKK9fUQX9TN1NMHAyai3teupjiWY3TXsMch1yY2PWvbWXPlAh774iFf6LJ7dWZfSn6XKmKgkGyJoca1qj+L7ZCLTTSqKgtg9WW/rvbnxo7vHqZnXQdtS1qcul4TkWD64CgISCzqcvn5VM1E+uQMamu4f5XH3/CVhDwD26sL3cAvAq9rYrsB+KVmB5onLQ3AOTFC7m1appVKbsaTYC6yH+vm2Ln8fJCSkePb6w8u8BIPh4zY+0Vd/xYZRiwU6Fuwle7Oc9i171sYRsXTxt2fPU5tgoL3vbuPCNVDKArru66hJ72Spwe/zWx5PEhcwsxFjZCMiLYlPc9Y8TgL0qvr9xGCeMxcxbherhaAVLbHNA8RYrpxvU71LCY/dDx0PPeN3P2363U3MrtvN4WjRwMEJzICKaqeC7N7dpFZtRahaTUVDP++0tSoswhk6Nh2sZQUZ8dIpjsCTrih8wekoTMwvJ2+3guC9Rpc6MVPXBYt2EpLtp89e79jqjESM5rIFwKNhExrP6nWBYwcerYaeeRsktYVm5g6sNOXVwbSi5cjYnEK+/d5yJDakiW2uI/Czn3WEw6OQ27m/JVMP3fQcrOpkpJYZ5a2db2cfOyoz0RUJSYXvmcNu+8/xeiJgi8NvyuayEVcwsiLZ8O/RpHL+dblyxJYAsBqXyxJdt11mA1vWeNSWNwmJbNseu8gqSVdqKnwRHGV0Um0rrbQfbJUDi1/+SGqT6dzcsI9SwrRywsBrJFSrmxkA940l0HmSUsDkIYReoWXArRMFqSBnq+dMM5NaFQtQfeKCxna/2SVdNRRW7wkIdhnQ8TFR2KEKjhnzW0Ui1McPv5w9SYvoKZTbiRBCSEz7tcup1jbh0QoCpt7b6ItsYCfnPoGE4VTwXWDolSXWpszJ+8hPlQ4hKYk6EgupilYN9eYQ1qCzriA50ZtKy3OVxBBIMwIoqPh4bcR/Sf7FpM5ZxOjD94T2mc9/5YwYqPnZpl96UWy6zeHkpswR2FTKZCUpseJZzsiI4Zs6MUcRqVEIt3p6kda85DeMgADxiYOUCrPsqD7XEdlEe76rrqezd4XQlwECutX38b4xEGGBp93yIqbeNjkRUHQvWwLo4eftRx48fxGrSs2Up4aozh8qvq9GSBUjfTK1eT2vOQQGaRAGILk+jUUdu23piasjy9In7ea3K6j6PmKJ4pISkHPZcs59dgRL2FxEZMlF/XQs6qVJ756xJckziYcXuISSl5cW7C98JiFbF8Wz2KLLtPQ3vtPohcNVt+43NkHXp8WKQXTe4fIrlkQecxURidRO1t9FyKrfbnOqufzeKWQB3bQnIZkt2kKryrSIoTICiE+LoQ4KYQoCCG2CyHeeZqdQtjCdxa0jOk8Vsm5suL6yIT3pm/+6Vl9KTOjR5gdP1FzeDtvS6BvN3GJcMwNjSjyEZd4PMva1bdw+NiPw81ENUKgowiK9BGUULOPi7goisYFC2+jN72Spwa/yamZPeHEJYy81IK7jtV2MLef3vQqlLCQaf9nDIGqxFDVhCdXS6AL6yk9le0xF050SdhOxIrzHjK9yyhNjVH2ZVYGwsmL9b7rqhvI7X+J/NEjoUpOzYgkVz27fPyRH6NmsrRsdCkaUWTHBaOYxygVvEqLD/a4RWv160SmI7yiTR6oEpeBwefo6lhrqlxhhMVFUkLXJLLr+YhLJtXD8iWvY9/+uykXZ6q/jS/1PxJ6lm6hODNKbuSoi4CY5qBEazeJzoVMH9jpUWGQkF59Drl9e6pqjlWeXLeG4oGjGPmSNYaptKTWL0dKyczOYx4yYyDouXwlU/tHmTo25XK0dYVHC5UL372KZ751lNys4SMfIkBcgPBwZbdq4jIt+QlLIN2/R6VReOFbB1lz0zK0jCtE2qW4OErLvkHSqxdYyhIOSbPVp8roJFpnu/U7eg8XWT47SovbnDjX7dUEKeVuKeW5UsoQ7TSyzQ4p5bnNjjUn0iKEWDWXdq8A7sC0kf058HpgG/D/s/feYZJk5Znv70Sk91nedLXvaW/Gw2AHGBi8hECIlUUGaWVW5mq196656+5arVZ7dVdIK7MS8kggQAIGOyBmBgbGm56e9l3tqsubrEqfce4fYfKEy8yq7pmWoL7nyScjjosTJ8x54/3M+XMhxD/acIua1o7IiB/s68kUCI3mmsejJIgBVIBGqjBCdnAn02e/EThRet2dfWoiT3u9AJdAjyINhgYPM9C/v6OayGVH0xGgqH1WQU4IwFGAy8HBN7OncA/PzD3AmaVHg4/pZVE6/TzHa8o6c9WLpmroOrwOYlHLGFeZIINeQqnMINJoUSsvdJz8k/2jaNE45avnlS98d5kgFVBiZAvpfYdYsNgWr3u0Wtb3olTKmd4/JZa++TD9r3+L6bbsacMlnvT6yoI5Llk/aLFVKLbU1hbQo0ki0eDop95jNBsVZudfYHTwVlc7ZhnpAyvuY3vAiwe4IGH7+GuIRTOcOfOAf+wtUCKkJJ4skBvaxdy5JwJVRPmdhyided7D0kB6935ay8s0p6exVUFIiO/eAQJqL553AAtSIBJxUvu2svLkOaCtRjGkIL1riPREgUtfOqvYtLTZEEMKDr5tAj2i8eQnL3tYlGDgorIugT8bGAUAFpVl8cZmWZgscfnxWQ6+Z5cbrNh2OFa5erlB5dICmT0jwbdBs0VraRU9RD1k1G6SekjegN+mbEg2yrScFkIsCCG+JIT4z0KI9wkhgu+6l0mEEG8D7gN+Wkr5v6SUX5FS/gTwReBXhRD+cIq9NRy4UFc7WyOSytAoB7vBtgv694d2v5K5ySdp1NZ8KiK1nKMmegmAC2CqiXa/i1pthbMXv6QABDebsiE1kYsh8YAP1TAXEJrGjuJd3Dr8Ts4tP8Zzc5/DEK1w1qUb8PCAnWvlM+hCZyC51Z/vPYcOEotaofy9h/O8iOKpAkKLtFVEAcADCULTSQ1vZe3aheDT6ABe+l/3FspnTlKZnGwnqsDF+3IMATbzX/480XyB7KHb2oxAUHuedoQ0QYsWS6DH20Ak7GuytrZIIt3ne4EHljdgdv4FNC3KQPEW5fylD7CYfZKBPxd4cRnoSjQRYd/u7+LazNMsLZ5z1E8226L2b2DrrSxcfAbZcsdsQUJu+0Eq05dorK64mKxYsZ9o/wDl06dc106Pxonv2uGoiNp2LYL00Z2sPnPeZ9cCGqNv2MPlr5xzuz0rBrlaLMJt37udb/35BZqGX83jBS4u8BLwcxnlBgAWp21P2P6nPnqOwX1F+vcNWJey7RbdZlsEpdOmzVdq11CbYVFugebCCkiJbjMtzr1nvTvqm+qhv28ihHjnS4kHNgpafgT4IyAB/CzwUeCKEOJTQojRThVfQvluYBX4K0/6HwBjwN0batUwEHoHz3Bhsi1GrewHJkoZW1QQUNx2hGg8w7VTDwXWcQGGIPuWMODSxThXBoCSWCLDgX3v4+LlR5iee97PpnSI3RIIUDzn2itwQQiG03u4e+z7mK9e4rFrf02tuRasYlL3O9m1AFJKzq88wZbsYTThvp7SayzcRSJ6wlwGIUDUiUkIjXiyQGNtyV0oAEgkB7dQmb0SbtcSUEdISIyOk9l/mIWvfM78Uu8AMHxpVn8rF86x8sSjDL39Pe3F6dTzUf6DvhDri7PE8wOm+2mnr0gJtfIisVQhpICfmVlcPEtfYRe60IMXzOtmhAvOvxe42GqiQnaCkaGjnDn7gBNETmVRbIPc4ugBmrU1yvOXXMBOSEgOTqDF4lQun/OBxsTWHVQnL7TrWIxLfOdW6ucvW120VUGQ2LuV2sUZmmt1cyK38g0EA680VURrs2VFLaPGSdE4/O7tzF1Y49Jzy0q6CAQuKngJ+qnqHtUWpd2ewqBYBr2lhQbP/fU5jv3APqTQXGBFBSwAC09cJHPLKCKZcN8q1iWqT04jYlEig0VfCB8kGKvhatpNuWnySeCqEOKKEOKTQoh/KYS4XwjRfyMa3xBokVL+kZTyF6SUrwZywCHgV4BjwBeECDMYeEnlEHBCSun1T35WyQ8UIcSQEOKg+gNMFZhhILosyqUnUjSrIYa4LsDiTtM0nbEDb+Da6YdpNqputsWpI9qgRLFv6QhczJMKBy6e+vZ2f98t7Nx+HydO/TWra9PW5K+cywa8iXzqI7WMpx0VuOTjw7xy/PtpySYPXf0Il0vPm/0PAy9hYpWbqZyl3Fxme+62dQGUIInocVpGly886wUbS+WpVZb9LIJnck/2j1Odu9KOPxPQlr3tZUH6X/cWymdPUZk0VQo+I9uQfSHBaDSY/uRfkjt2J6kdKpvhOa4i3nOpLc0SLwwGF/acQ728RDxV7FwWEyxIKVlcPk8xt1Npp82yiABgAriNcT0ARl10UVUT7dz6RtZWp5mZMYPIedkWISWxeJZ0cQtLV0647F1MtkwjNbqDNQu0qOAzsWUrtUsXXawNQGz7BPWLV5BNo80eSEF85zgIwdqpKYdpsSW3Z5BoPsG1b11xqYig7YKcG8uw9Y5+nv6by44XkOH6V4CLCkwCPYjcgMVmWcxtEciyPP6np0kPJNn5pu0OG+SKz2LZs0gpWHh8ksLt261L6HZ1BqhfnCa6ZagNpj33Xmvl5oCWTZuWjnIEk9j4GKYr9D8HPgvMCiHOCyH+SgjxK0KINwghgiMKdpCN2rR8jxVMBimlIaV8QUr5a8CdQD/wgY20e53SDywEpC8o+WHy05hWzOrvU3amiEadGT/oZtPjKYxqe/EOaQGGAGN3pYz5P7DjDvRogmunH/Lnq/WvA7iok73ars8VWoNtE6+lr28Pz574M5rNqtNu21VauM+rE0AJTfeAmBDgkohkecX4B9iZv4sXFh7ksemPud2i1breY6htSsnZlcfYkj1IIpJxH3udIiToWswdpyVMJMSTeeqVZaduUBkhITkwTqtWaa8Yjv/l5lPZWPvxkTEyB44y/+Dnw+9Tz76dv/DVL2HUqgy+5V2B5XzqLHXb2q8tzRILAy0e8FMrLxG3mBbhAA8c5kMtWynPUauv0Jff2TbADTyGlaEa3triBS9qHUVNlIwXGB+7i4sXv+bYKHlthISEwug+lq++6AJ+dhuZsZ2UL591s20Sklu201xapLmy4rAsSIhvm0DWGzQuT7tOQ8RjJHaOsvbCZYdccryINJ3BOyaY+dalUBVRC41D79jK85+7Sr1uuACL2ZYfiLSUqUC1abGPrXobedVCKsuyttLk6Y+e5bYfOQARvW3rYv2bl8T8r63UKJ2aJn/bdscIt315TPBSm7xGbOtoG9SB6x4xVkO8+F5qsV+s1/P7NhUp5XGL2Ph5TPvSBvCXwI8Dnwd2Av8e03RjMbShENkoI/JXwHkhxIwQ4gEhxL8XQrwLiGKqY961wXavVzrh1055H8ZkYtTfu+3MXpgWJwx72ME9wMLeFpEIYwfewNTJh2g2a8E2LV4D2nUCF2c/DLgo20IX7L/le0DAiTOfbA+a2g+nDT9AUY8JBKevA7hoQmdn8S5ePf7DCDQeufrHnF36JoYwgqPhBoCRufpFSvUZduRuD2Z7gqRDnq7HaLZ606XHEnnq5eV2syF3YSI3gBaJUZm9GshyhNWzJ8j+17+FyuRZZj/7CWSj5eSpwMe7X5uaYvHhBxl623vQE/7owF3tWqz92tIsiXxAhNuAPtfLS8STBb9RradNDFhcPkc8liOZUOO/eFgWFbAAbcNoz5pELnsW2d4HByyND9/B6uoUq6W267JLXSWhOLKPtYXLNMslnxovPbaL6tw1muU1V158cAQRjVG/NOlK1/M59GKe+rnLDpixJ+vkvgnWTlyyTtnt+tx/x1ZmvnUZaUifisgGI7e8aQuNaouTX522VmFusyPmKatuy8IFTMx8d7pq1OtVCzlqJsuWJZaOsPcd251L5vJwUn7zT15Cj0dI72uvAeZde6g+eY3YVsU8QsmThrGpHvp7LEKIHwY+A3wLeA9wRkr5U1LK2zE1NK8CfnG97W4UtOzDjH73J0Aa+HlMPdZFqxNvsvRYbxNChDvg31iZJ5hNsd94QSwMAFLKGQsdOj/grJ3v2LSEvGf1RJJWtRyciR+wSM+EOLjzLrRIjOnTj7QTPWA8FLgIm9kRzv71ApdILM6h/R9gbuFFLk096prAN2Tf4k23/zsY2EqPGigVK3LH6Hs52H8fF1ae5JGrf8LZpW9Ras61z8sDYsqtFV5Y/CpPTf8N45mDpGJF9/Gg5zWHVNH1GK1eQYvCtNgS5G0kNI1E/6gZGVcVz9e+/e8z+h0aYcsP/CSl557i8h98mObysusG8paXLcn0Jz9K+pYDZA4ccbfrARw+exYlr1Ut06qsEi8MdqW9jUaNZr1MPFkIL6TI4tI5ivkd7ZdUGNAxcAOUIJWQVS4IuNjAJJ0cJJsZ59rUUz6DXDsIXqZvgkgsxdLUi67rICQkhyYQuk7l6gX3+Gk68fEtVC9edMqa9keC2PYJaucvoeAiAJL7tlJ58TJGU/rsWvru2EZ9ucrCyXm3F5HytRPJxDn8zq185cOnaTTNVn2AQ/oZFdXuRGVXvPVVtZDN8qwuN3niT09x7Af3IyJRl9dQu317TSLBwjfPkz+2DS2q+8CKlIJWpU5jesEELQHMRGu5FH5PvNQib8Dv21iEEP8Ck8D4b1LK+4BfA/5UCDEAIKWsSSkflVL+xnrb3qhNyykp5Z9KKX9JSvlaII/JTvwo8AiQxdRjfRq4upFjbECeA/YLIby0yGHrf91BbGzRoiGLddn58WQ40xI2JyqgRNMjjO2/l6snv0qzXvGAFQhjVVSvIl++A2jsMr0DF4BsbpRbdr+TM+cfYG7xFHiATah9y40ALta/1NzgRQjBeO4gr9nyQYZSu5hae5FHrv4JD135Q04uPMRS7Rp1WeHi6rM8Ov2XfO3K/2aheokjg/dzcOA+3yUI7r+yHSK6FsUwFFdL+yUUYCgaS2SpV4Nfrt4JPtE/Sm3hmrtdz3aQisgGGqmde9j6k78EUnLxt3+d6qVJvJS0NKB65QrTf/1nNOZnTeNb24DWKwHARQUwQkJt0fT+6GbTIiQO4xRkiBsEeJZWJinmdriP62VZ7H1wMy/OOSggxaofZKRrsy2jQ8eYmXkWqQJLZ5zNoHT5kb2sTJ322bVoWoTU8FbKV863+2y1kRjfSu3yJfd1lJZdy+QV89rY10hC4patGNU6lck512QOkBjMkNnex/QT5qvVHf+kvf2qf3yApatlnv3slMO2BAEXVwA5NBdY8bo1q4BFVQsBfOk/PEWqL8HB9+x2ASlDATb2f6PeYvbhM/S9eq8LsEjl8tQuTAEQnRhpXwdwWKnWwpLvPnpZZROwBIoQ4rcx1UI/I6X851byvwDOAX94ve1v1KblPwkh3iOE2AYgTXlBSvkRYAl4GBO43Iqpx3o55BNABvgeT/oPYwKnb260YT0VvO6FLVo01l5HKEy87IeSLgUM7X4F0USWU1//CEaz4QEU6vY6gIvSvsqKdAMudhtjY3ewdctreO7En7NcuuQCLuaJh8RvuYHAxTxH934skmJv/2t59ZYf5rVbfpSJ7GEWapd5dOrPefDS/+LM0qPkY8O8YvQDvGr8hxjJ7EWEtO2SHu1cDNki1IPeM2lqegzDZmUCXlYqsxHL9lEvLXa2ZekkEqK5Als++DOk9+zn8h/8JitPPwaY0W6XHv0aF3/r17j02/+dxtIiY9/3I0SzhcC+BKqGAvpTm79GNFNAj7m9P+xyKqtUKy8hhEYskW236ztXE2DUaivU6yWymfE2GOyoUvIAlwAPoqA4Li41ETDQt49afcVREak2K/Z+dmA7q7MXfEBSSEliaAtVW8VHe0zjQ8PUZ6Z9k1ZsdJjm1IwZC0qZlPViFj2XojppgkKvaqV4cISF4zNuQ1yPiijdn+DW9+3gkf99hqZBIHDxghd3JF2vy7QbsKjGt8c/f4XTD17mjf/ulWixqMsA1+s1ZEjB3CNnwTDoe/WeNmDxsC3VE5PEJobRUqn2JVLGrnltFi3b+d28KTdFfhD4Xinlb9kJVtC57wPuEkL84vU0vtFVnn8WUy0khRDzwBPAeWACeBsmwmoBz1i/l1yklA8IIb4I/JZlkXwG0yD4fuAHrP6sX6JRk2np8L7UIlFkEGgRBNcLSNf0CPte9xO88OXf5NQ3/ohb7vlhdC3ilJU2XpDmxO+s3kwbuNgUtrQyBNaXoKsNAdJaHdpaydnXNhJ7demdO++jXl/lmeN/zO1HfoJ0ahCUfDTRDm1uT/pSmgDFsPvZId3+t8GXPYmoeVI6q0O72rLURjuid7KjcCeVZolqc4V8fDQ44m0YGOokHiAjBUjZQtM6hP1Rrq2mR5FGy5yUOtUBYpmiyxAXzEnPfo+r20j3bSRo52l6hOF3v5/48CjTn/gLVh5/lOqVi2ipNLmjdzD2vh8iNjCkTJLhwCgUvFjb1YVp4n3Drq/IMDVRvbxENJlDoHUGIEBp9SqaiJBODrY/v51jW2CkoweRbINh5T4SmPcfmo0qrHTzwpKMF0inhpmfe5FMfrzdjsRZHDnXv40LawvUyytEs3mzeasbqYFxlk895ezbYxgbGqW1skKrUkHLJLHVTtGxEWSjSXN2kdiY6tYriG8fpnJhBkMe9Nm15PcPc+Yj3zLBgGjHQTGEdBiNltC46wd388Sfn+PEV2Y4/MYha2g03Cs9h8ehCvIUsgGL/b88W+NL//Ep7vixgwzt76MpQ1gWRTU09bkX6H/tXrREjEarHQnXzpdSUHnxIvG925Tr7u5b49oMkf4i9dLLb4x7vR5A3+beQ2+WUj7iTZRSTgkhfgDTyeXXN9r4Rm1abDfnDwJ/ARSAHwDuBX4f+J2Ndug65T3AHwP/DvgcZmyWD0gp/3SjDepJv4GiV0QkitH02DgI/7bPRsVhQMz/eKbI/nt/irXFK5z55p9hyJa/vlNe9Ma6KHXabfTOuAgh2Lv33eRyEzx9/CPUaisO4xLoUXQ9jIvVVqA3EPjURe3xNcsmozmKiXE/YFHb8kqP7IoqhtGBafGIppuLwBktC9R2eFnFskWaldX2vRQEGLq97OyJEkHxla9j/Ac/RHRgiNHv+yA7f/FfMXjfO3yAxVXXfhl7jxNSvrpwjUSxtzhSthFuL1Iuz5JK9qN7rmWoAa+q5jE827ZtilXO7fasAB5LRTTQt5f5+ZNtlshzzFR+FC0SZ01hWxw1UP8YzXKJZnnVNY7xfhMwNGemlT6DXiwgolEaV6adF4TNNsS3DVO9MBN4urkDo1Rn1yjPrDqMhlcMKUgPpjjy7q08/HunaUlcqzB7WZZ2vRDVUABgaRnw+X/3JLmxNLd98CBquH6fAa4FXipzayw8McnQfYdcQMX+l1IgDYPqyUkS+3ZY96X9cmqPXePaDJEB/2rhL4vIG/D7NhMhxG8JIX4KMIQQ6aAyUsovcB2ABTZu02Krg/5ISvlPpJSvlFLmpJQZKeWH1rP+wI0UKeWqlPLnpZSjUsq4lPKolPIvrqdNPWWClk50vRaJdlcP9SiJ7AD7Xv8hVmbOcvaxv8Jw3q7mX6hRbyfgYu8rAMkxeA0BLnYdKQSapnNo//cRj+d46vhHaDTKrnxgw8AlMI5L0ErPSjmvka5LQuq48tU21ON6RQveNmQLrQtosSdDTTftoRzQAqEvLFtV0ygtdXypdXKddrUvIb1zLyPvej+ZWw4gNN39wlSYgM7n4imnlK8tTJPo6wG0SBO0xJL5gLw2YEACBpQrc6SSA+7jqm8VL8sCbpuioLwQexc1bouQksG+fayULlOvldrHdwCdadeS7d9KaeaCq39CQrw4BEIzF09Uzl2LJ4gUitSnp11gRhM6kdEhGldnzO7ZwyAF8a0maLFZFjvdQJDZ1oeejDJ/vL0gZxsotI1rW2jc/cFbmHphiTOPLrRBhweUmPXdRrcug12Poa/tLfTMJy9y8ZvT3PfvX4Ee9bIrbpbFBi/XvnSCxFCOzMGJNkhxzs9sv3ZhGlmpEb9FZVrcwMVkWsLXu9qUl11+FHgfZkyWFSHEaSHEx4QQ/0oI8S7bnATTvmXDcjOCwP2DEj2RdD8sAS94EaYeCpIOH/Y2aEgVRtn3+g+xePU455/8RE/ARWVVpIbPu8h1bIELYAQBF2/wOT0a48jBHwTg6Rf+mKYdp+Q6gYvd/47AJeDfx7p0YlM8xw1laxSWx+vhpYo0WmiaolkNKGrX1yMBoCVEoqk8aBr1lUVPY55/Jd3LigQBi077fmNTT14IoBESWrUqjdUlEsVhP10e8FVZqyy5jHAdQ9YAKZfboMVsT2FEgsCHEZLvcouWzr6PbVHq5DLjRCNJ5udPusZCtWvJ9G9nde683xhXjxIvDLhXfLbGIzY4TH162mnPfliio8M0rs5Y3bUZB4hvH6a5UKKx7Dbyt+O1FPYNsfD8dGAcFNWOJD+e4cD9Ezz0u6cD7FHcICUIxKiARd1euFrhwV99hnt+5jCFHQUfy+IVQwoMA6Y+9wJD9x1wnvH2pWufe+WFSSIj/USK1urOzn1qtVtv0ZybJzpwk0DLJtMSJDUp5RullEVgNzCC6SBzCPgPmCYkyMAImr3LJmjpIlom27mABKHrrpV81UnMwTveNHuyFwQyHOm+Lex7zY8xf/Fpzjz6ZzQaFVfbUq3XA+viAjZOmr3dG3CJxlMcO/wjNJsVnnz+f1NvrLnyzQFbB3BRbFmkmubkdQAuQeDF23YAmPHZsfSgHvICmEarQkT3GJ4q49cJmLYb9ScJTSOSyNCsrIaW68iKhAARX5kOzElou9464Hg6JfqGA8t6pV5ZIZ7M44TG7yCV6oIZnyXAI6t9rACA4s0LsncJ2rZtqQyTSekr7mFx4Uzb9dkjmf6tlBevYrTaMXHMf0m8b9j0qvKAwOjgEI3ZGR+YiY4M0rw263tZRMdMj6za5TmXTYstub3DLJ2e87gVu4PE2XFWXvHBPUw+Nsf0qWXrdN3AJdAQNwSw2CzLg//1aQZ25znyj/b62BWzXbdqCGDpxWnKFxcYfNMhl42Oe2VnQeX4ORL7d7g9p5Rxq09dAylvmnqoW7TbXn7fhuJEo5dSngcaUsp/K6V8v5TyMOYyO9ctm6Cli0TzhdC89ktf9jT59SLqM5oZ2sGBe3+a1YVLPPO5/8rM5BNI2wDXC4YU4BLKuoArLxS42MAjALjEkzluO/oTADz+3O9SqS258oGuwKVj5Fw7zclzMyA+W5cw8BI0tmEqoV6vnVWuWlsikch3LGNLy1qjSI/EezpEmKqxqzdPNzDjKROkSvK9SIPYE+W/OjdFNFMM9BwKkl5tWgyjSa1eIhkvWseTVp/bAMNl2+KxWQlkYux/hZERQYDGkmJ+B4tL59uuzzbLYq1DlCmMIY0W1eUZn/osnh+gtjjntOW4Nxf7aCxa4aKUsY0M9NGca6eb/wItHiPSn6U6teTCTfYEn9nRR+n8opPmtiVxL044sKfAllv7eeyjk22wQjswnMvWRdkPAyynvjbNua9N8br/6w7HwNzteh2sGrr6wAvkj00QGylaQy/cpy0FstmicvwcycO725fHcx/WL1xC7yuipbvbHL4kYn81Xs/v20+uCSF2AwghokBWCKG+HDa2aLFHNkFLF9Gz1uTUcVKQ9PR53aGI2xC2vZ3qG+Po/f+U4V33cO6Jj3H8qx9mdfmqq72eWZcAIIL6DAkFbHQALrFEhluP/DiJeIHHn/0dVsvtdYo6ApcgZsXO1+huoOtN7wBegn7t6+BpS21flRCVU6W6RCJR9JcPEBu0aJFY17JCdvBECygLBDMpdP6aCwInQfW71alMXyQ1PNGRXbHFqFdpNaqBNi2qW7GQkmp1CZAk4soY28xML27P9nYQ0+LYz7gZFltFZPejmNtOvV6iUp53nbPDmsSzRGIpqkvT7TzrP5YfoL405wOT0cIAzYV5pMv2BiL9fRilNYxKzdfV2HAf9akFa9/NtKS3D1BbKFNdDl5SQnUzbqFx2/fu4LlPX6Ky2vSBEvCDFVe0WwWwzF8q84V/9wRHv3c3g3uLPpYlzAC3WWky85UXGXrz4bZ9jlSAi3VZKicvIWsNEgd3WWNuv8TMPyEF9YuXiW+d+Had/P+hyu8DfymE+CBmlPkp4P8AEEIcA8IjsK5DNkFLF4nmi4GGiL6Xeo/PjvcZ8wZ1C9oW0ShbDr2Zo/f/UyKxNM998X9w/qlP0qxXwlkXEcy62Pk+A127fgfgonoVRWJxjh75IfK5bTzx3O+xuHzBBVzsAHQqIHIGKkwlBH42xpUXAlic8QoGGYH5HepLpY+uPKAlGzSaa+aE2sNFbzXrCKGjeVcKD6mqeqJ1BBdBEgBkOtLSQcxLp3Y92+WZSySHJlx57mO11/CxowK7mJYQYFWtLiLQSMS6xODwAhA1PWg/IN3N2LTLJBN9xGJZlpbO+/ppGuMKkrkhKivTvnGP5wdplBYxmk0HuAgJkWIfstnEKJVQ7TRsY9Lm3KLzENsTeXS0SG1q0dNt2xi3CAJWzi8GGsACrjWF9rxxnGhC57lPm1GXvQBF/XnzbcCyMlXmoz/xNfp353nlz9/adq/ugWWZfvgsSOh/9S0uVZeqGgIoP3uW+K5x9HRKASzCNWa1yUvEtm3hpoq8jt+3oVjrD/4l8FPAEPB64LuEEKvA45ievdctm6Cli/jUQwE3nOzGtHizVGZEbUcEbCvPbDzbz97XfJC9r/5RFq+9yFOf+y9cO/cNpNHysyauugpToqiLfOH/7eOGABenLauupkU4dPD9DA8e5ann/4BrM087wMUpGxTyP4xZCWJjfHkinHUJ2g+wawllccJEeUqqNXPyTcQL7j6GSKtZQ48qqqGA6+46VIB6qBf9940AOF4D3DAjXyHBaNSpzl8jNdjbxFErLyOERjSR6dq/am2JeDyHJnQPyJLW8TsAFSVdeL2J7H+vnYonwJxp1yIo5newtHiunSbtY5tJydww1WXFsNb6jxUGQEoaSwpLA8TyJjhpLLjZGy2bQUSjNGfdKiIpBbGRPhrXFl0eRM75xWOkxvIsnw1eoURVERlSEInpHPnu7Tz+0fO0rIbCVENewAJQmqnw5x96iPyWNO/8tVehxSLKMdQAd36WRUrB1QeOM/j6fYh4zDm/ttdQG7iUnz5N8nA76Jxropdg1Oo0pqaJTUzcPNuQgI+BddmzfPsCl/8spbxbSvluKeU54C7gjcBdUspfuhHH2AQtXUSzJ5xuN1n3j+7e64cwJ3ZacWw/R+//ZUb3vo7JZz7DM1/6HyxMvdC2d0EBLwFMCdDdzkW4V4gOAy5CaNxyyzvZteMtHD/1cc5MftH0dlKO67aT8bInHmYFfKAm1LtI87RFQPth6Z3YG0W8i0RWaosIoRNXWIBOwKXVqLVVQz3cI1ok5o/54+pQl7SwbTXNA1h6evF7yphRXw1Sg71NHO7Acp3LVqqLDig0j93jG94GNYZ0AIu6HerybImqIgLTrmVp6TwYfqthISGZHaKyPK3Yxph/0VQOEYlSW5x1jbUWi6FnczQX5t1eWkKYdi2zC3iaIjLcR23KD0psliK7vY/ShUUHJHi9d1R1UguNY9+zg/kLq3zrzy74WBUVvHhD9FdWm/zFTz1Mqi/Bu/7Hq9GSMaece6Vpt2u0LZVryyw9dYmht4SrhgAa8yvUz18leevedrrnstUvXQHDID5xk5mWTekqVniUb0opn7xRbW6Cll4k6KtUzW7Ue7JZCG3eMzECfuDiSRORKOP738Cxt/0zsgM7OPXIRzj+1Q+zPHfOz5y46rYBis/ORSmrMiM+4KKUN0GJxtatr+LIwR/gytS3ePK5/021vqy01QYILnVRmJ2LB9QE5oWBjl4BTMi+oxoKYWeW166SSQ2D5n50XPZ1yq9RWyGWyAUCoiCRRgsRFM1X7a7KhHRt0PNT073lQuoHqZSqc1eI5fvR40lXn8KkXlkmFma8rPbTgHpthUTcXda1dpAtiguzUy7E28jHugSAFe/x8tmt1Oor1KpLgca4idwg1dI8Uqoh+EEIjViuj8ayB2xIiBSKNBeXlDRz4US9v0BrYdnX7+hQAWO1SnOtHuhBlJoosnbZXw9wqYjsepnxLG/7N7fxpV99luceuOqU66gekoIv/udnadUN3vUbr0FPxR3Vj5nvZlnsOq7YLF85TWK8QGbfaKBqyL4s5SdPoeczxLaPE2bPUjs3SXRk2ApHEXjqL714n6uN/L7DRQiRVWK39CyboGWdEhTXwqhX0VQPiqAbMmzOCgEl3v0w1iWayrHzju/h6Ft/hViqyAtf+W1efOQPqJYXXcyJD3BYbfnsXFzlcCZvF3DxlsfcHhjcx123/SwA33zqN5ldeJEgOxfnHNejLgqzdVFVRp2C0gWBHXVxxE6gQslbXpmkkLOesx6enuraAvF0b7EkpACj2Wize+uUnl2Yg+qo+2EUttJ+ZW6KRP+Yv8GQF3SjskIsGRA+IMCluFYvEY9m/a7GYW7LYfseY1zhtX/x7tuxW6y0dHKASCTB8vJFf7+BZHoAaTSpry6Z7TsTqzRBy8pCO91mYfIFmkuLPjCoF/K0FpetbrQn8Uh/AYDG3Irr2PZknxrLsXZlxe32jB9QqHLondt4/S8c5m//xeOc+fqcL9+lHpLmukIvfPYib/0Pd5PIxpx2g1gWu45XNTT9lZMMvm4fknYof18UXClYe/IUyVv3IjRNASxu4FI7d4H4zh3+C/Iyys10ebYm+/8qhPiCEGJWCCGFEP8moNwfWnne34vXceo3UvZjxW5Zj2yClm7Sw1dtq1ZFi61zolGBCG62xVuuXcaTrjzT8dwAe175/Rx+8y/QqJV55nO/ypWTX8Gw7V3U+iqIsICLaueitt+u4wYuUijlle1EqsCtx36M8dG7ePbEn/Hi2b+hZTTcgClMXWQBlHBDXM9YeQEO+AGMV8JsYux2FZbFa5BrCIPl0iUK+e2B1yFIamsLJHoELWDaimjRDbB262BOfGqhHl6g3vu/On+VRP9ozwCpXl0hmsj11MdavUQsZpUNUg2FqItC1UDetKD4Ll4NkBWvJZedYGXlohvISROYxNN9IDSqpTmfsX4010d9ecF3jpF8gebSkqdvECnmaS2u+CZqPZ8GXaM2W7K66mZaEqN5ytdKyJbhAg6AS0VkG+Ta23f90B7u+P7dfPwXH+Xy88uBrs+GFMxfLvPFf/8kr/zQAUYODzisjd2+yrIAgQa4pYuLrJ6Zpf91+xzVkH0uzi0oBUa9QeX5s6Ru3eu2Z1HGQxqS2rkLJHZsv7mMxc1lWvqBDwFx4JNdylaAV3p+77+uo3cRITp9AV6/bHTBxO9MCbnRjHqtp1gV0prfJR1AkFVACqWMXYn2O82VR7tOqm+cg2/8aWbPPcbks59mdvJJdt7+HnL9O1ynIJw65gKJSBO4CANcCy666lhLKWrtF4jZtXZ5iRn2f9euN9NX3M0LJz/G4tI5Dt7yXnKZcRO42OU1HPdPeyFHE7hYx/UuuAiuPPX0fbFypOxsYBsGWELKSgGra9doGXXyuW1+ZkZlbRSpri3Qv/VoeD88YjTraFYU3Y2IkArQDLhHNiRKPSFBSoPq3BSDR1/fc7uNSolMwfQ0Et44Kx6p1VeIxxRWRgEUvnrdAsyB67oIQ7bd322worf3hZRWNTMtn51gbvFkYD81oZPI9FFbmQP2KhMsxLN9lKfOO/vC6mYkX2DtzEl3OuYaRE2LaVEnaqFrRPuyNOZWMKQ70IWBIDmaR7YMKrNrRMfay70YUvhufzPNbLyFxut/4RDlhRof/Zmv84N/+Fr6t5tj3jLg6nOLPPnRc5z8wmXGjvVzx4/uV9RMngByuEGKCqoApj53nPSuQdI7BmkYdhl7yIVzCcvPn0e2DBIHPfFZlHFtzsxirK7ddKblJsskUJRSSiHEAPDjHcoaUspHX6Z+2bIshHgeeNL6PQU8L6W8IWvdbDIt3aSHL1hHPbTRScH5uBKefTc74mVdwpgXNI3B3Xdz7K2/Qro4zvEHf4szj/+VuWaQ+iEXxJYE2bmorIsIMdBVyttMSbFvJ3fd/nNks+M8/uzvcP7SV3s30u3EunRTGRHQVlgZddyVei7WxZLF0kVSiX5i8YxTz8eQ2eevgSENM3R9us9l8yKFwPNed8RobpBp6SQBX3ZBLItPNeRlGK3txsoiRqNGsn/Ulxcm9eoKsWSuI1gBaBkNms2KG7SAnz3xqHZ8tixSUm9VeH7ui1Rs+6qwY3tdn8HxFMpnt7K6OmUaRwd4ECUyA1RX5lwTK0DMZlo8/YrmirSWlnzjpRfytJaWkS3D1VUpITKQpzG37OmyeQMlh7OgCUpXSi5jXGeYPOwLtI1zhRDc/3/fxtihPv7ip77O/OQaT/31JB/5wIP8yQ99lfJijXf86iv5nt96HZrunyrCWBZ1u1U3mPrccUbeftTJs1VB3sUSy0+eInlgB1oiTpg9S/XMBfRclkhfn3l/+nr1MslNZFos49abxTH1Ig9gujz/Y+B3gSeAVSHEk0KI3xdC/KwQ4h6gS0yDYNlkWnqQINdP9cXeqlXQ471FBfWKi1FxHbR9TB/rgjvP1U8lP5LMsusVH2Bwx52cf/zjPPuFX2f33R8gP7BTbcLPlliMi82K2EyMud9mRaQAoQmFLVHKW9vRWJKDB76XgWv7OHnmU8wunGDvzneQz20Fi5mBANbFliBmxWZVpGyrjOx8L+PSQVyAI8j41ikHaILF5XNt1ZDmzg8CIbXKEkiDRCZYPRRUz7hOo27wsC0h+dcj1bkpRCRKLOc+rzBdvZSSRqVELN55SQwhpbNIYTyaWX8/lZleSsmzsw8wV7nAUvUqd499H1E9YQIUA8WWSxkowzoJo8265TPjSCkplS6T69/pO99EZoBKadaKSSMcFjWa7ceoVzFqFUQ05QDASL6IUatiVCqIbMJ5h0QKeWgZGCuraAPud3l0IEdjbiXQ7ZlIhORQhvLVFWDUVc+QGrpoWdvCfshcbAtRjXf/17v46E89zO+86wvEs1EOvXs77/gvryC/NefU9bIsKlBx2leOawOomW+co1VtMHDvgUDVkANgDCg/dYrcW19lXUPh+Tf/aucuEN+xHSFE16UgXkoRXN9zpNx1uwK0KbNSyuDlvdcvSSHENWAQM9jbJ4H/W0oZ7Cd/A0RK+X4AIUQOuBW4Tfn9EPAjXAfe3GRa1iFhN2ljdYVI2tbBb7Rxq7rrq7+9GcqshJVR8nLDuzn0ll+gMLqPF77620w+91laRtPPutjHtxgXl51LAOOi2rl0CkQnhWB45Ah33/7zpJIDPP7s73L81Meo1UuhrIuPeVENdcPsXRTmJZAFccZJybPqdfMgqjfWmF86zdDAQYWp8bbrHvfVpSvokXh3Q1yrvNFsYNSrRFK5zuXDpId7b0PB5Txl68vzxHP9CKEF1vMGljMaNaRsEY0Hf1g57AU4K4jHopaqwxv8zZvm66eZN7X2IvOVS9w98n4kBk9P/y2G0QwtH2jIa0gikQTp1CAry5f9HkSYoKW2qhiz2kxLtghAfXnRNUaRXB6A1sqy64HWc5ZqZrnkpNsTfKSYpbm05uu6DRQSgxkqs+5lXdoeQMHPgAoytGSM7/p/X8V9//I2fvILb+feXz7qAizB9du2LUEGuLbMPnyGvrt2EknH2/nKeDiuztcWac4u+eOzgAu41M6eJ7Fzp4/Z+gcsnwKe9/x++ga1/Qzwy8APAvcDfwh8EHhECLEhlmM9IqVckVL+nZTy16WUPyilPAjkgFcBPwv89Uba3QQtXURlVMKkUVoilim4E6+H/gsBLmZedwATBF70SJwdd76Xva/6EWbOf4vnv/w/KZemPUDE3m6DlLBAdCqw6KYusrfjyRwHD76f247+OKtr03zjif/BhctfoyWb7mNsVGWkgBvVaDcQyChlVHWR3xjXPK8rM08Qi6YpFHe5r5EN2rwiYG3xMuniFoSmB4JMb/nG2jIA0UzOuY7dJAxshIGJjtJLWxLqpQWiuf6e223WzAk3EvOvE+Ot22isIYSOrsWUMuFqHZM5cauK6q0KJ+a/yq7CXRQTY9w+9N2U6nM8P/dFM5aRt47N8DlxWtRZFdLpYdbWAj58JSQzA9RWF5CG2+1Zj6fQojG327OESCoDmkZzedmVLlJJiERoLZacNPMUBXohQ3Oh5Dq0CibiA2kqs2WfF49TVrnpVENatY1kIc7R9+4kloz48juxLEGqIbtuq2Ew/+h5+u/Z7cpTF0g096Fy/Bx6MUtkdADsS6O+dyW0Vko0Z+fa9iz/8AELwLsxV0FWfx++EQ1bYOHXpZRftH7/EpPp2Af8xI04xgb6VJFSPiql/DDwXzfSxiZo2YhYD5NpXCdplJaIZgvrb8c7KXWY0ILyOgIYCAQvhS0HOfLWXyaWzPHsF/8HU2cecYLStYGIe1Luxc7F5V2kh7AumrldKG7nzjt+mt273srFK4/w6JO/wezCi0gkXvDSjXUJBS9eAOP9BZQPM8ZtNCtMXnmYbVtehyZ0vxcTdnvutNXFS6SLAQGwQq5no2y6tTqs3XWKqq7pNWKuO1x9cLn6yoJPNdRJbNASVUFLiCqp0SwTjaQIdUAIY0aUtJMLf0dMT7IzfwcAqWie24ffzfTaKc4sfr239pQgc+nUEOW16XaflXFJZPqRRov62hKgjLcQRLN9NFYW3YyWphHJ5WkuLfkCzOmFHK0lt2sztJkWry2I2U1hMi0z/gV0g1Q2ncoE7bdCpggvQHGF8Lf2l569QrNcp3DnLpcqSO27vV957hyJgzvbquEAe5ba2QuIWIzY2Khik9UDsn8pRN6AnylnpZTHPb8bpRoKkk8Aa8ArXsJjvKSyCVq6SQidbotRKSObdaKZgitOw7oOEQhIgo08ewYwHcBLNJHlltf+KNuPvYuLz36Gk1//CI2630i3o1u0B7iEsS5BTI0JDnTGx+/iFXf+EoP9+3nuxT/nqRc+wmpl1g2QglRGmhYIXjoCmCCVkrLtAiweEHbh6sNEIknGRu9Q6gaMrX0tNFOTsbp0mXRfh6idnmvZWFtGT6T96xRdp6zfNoTAe91up7Eyb4KWLs+GLc16GaHpaJHu0aUbjTLRaDKgT72dxHx5kiurL3Co/01oUjdZFEOSj49wdPBtnF36JpdLz7vb86qgPIHnMslh1sozeG0fhZTEU0VEgNuzGaulaIIW5zjmL5LL01xZ8bQl0PNZWssrbRxl5emFDM3lNcdI1+mqdeMlxwqWTUtbWgqICJIg0OFNc+ercVlUt2gtsA7AzMPnKBydIJJNKGXwuzq3JOXj50laXkNh9izVs+eJb99mMpdW/k0L4/8PWwR+J/9/MLIJWnqRDl+sDSuw1IaYliDxToBhX5zC83PV6QJeBAhNMLTnHg6++eeprs7x7Bd/nZX5Cx4Gxd5ug5TQdYtUUBFi6+LU09rgJZJIsWfP27nr9p9DCMG3nvyfnDz3WRrNioud6Qhe9I0BGFfZEMBSbZS4NPUou7a9EU2LeBgePMHy2mNdXZun1aiS6dviApRB19O+Vs3yClGbZRH+/J6kl5e4p8x6XvxSSpNpyfYHZAbXadbKRGLpcPZEkUajTDSS7lwoJOpty2hwfP7LTGSPUIyN+eoMpXaxv+/1HJ/9InPlC34VUZD9DJBODdJq1alXl9weRIAQOnHH7RnXGESzRTPAnIdViuTytJaXzPoS5wLr+RytJZMxcQWYK2bAkDRX2ovkuqLijucpX13BaBq+PPDbtagxW4JEVQuFSZhqyInTYsDs18/SZ6mGvKDIdnUGqF2axVhZI3lwZxd7lgvEd253598kuZnB5a5T3gukgJfbDTpM1j0Sm6BlA6LSuo3lRUQkhh7v8KK9zhu0F+PS9RjmquAlVRjh4Jt/nvzwLRz/yoeZfP4Bx0jXqy5ysS56O70n1kX3gxd1O5Ud5uiRH+HwwX/E/OIpHnn8v3HmwheoN9a6g5cQlVCQPYsPqASoi+w+tzB44cwnSCcHGBo6EsiymPvCDRwFlBYuEImliKf9k3sgOyOgXloimsmH3QYvrXS7R+25vVbBaNSJ2SC9B7VTs1EmEkuGMjiqNJoVopGkH0TQBgquNCWU/6XSczSNGrfk7wlu3JBsyx1jW+5Wnpn5DIZsWX0O6ZRljJtMFBFCZ21tOvBcE5kBqqU5vMxTLFukrjItlkRyedOmxXNYPWcyLV7R86aRbnPRDWjABAmpMTNWS3lmzc2Q4N4OUhH1su9lVsIZmXa58sVFajMl+u92e1z51VtQPXGByFAR3Yr+61wO5V82GtQvXyGxfbv7A/JmTf43Tj20IRFCvFUI8V7gnVbSASHEe61fSgixTQjxiBDi56yy9wsh/hPwEeA48HvX1wNff3JCiHevs9pJ4P9a77E2XZ57kNCHQ0Jtfpp435D5FRlQrteoo1IoZUXn8kHAxfVCV7Ole4IUnnQhQY/G2Hn391IY38/5xz7G0tUT7Lrr/WQK407XhVNNcWm2g9FZ5y4smxSk1X0hrOBZ1lep1z1arQegafQPHaCv/xamrz3D5KW/49LUo4wN387W8XtIxovtOo6rs92eDShE+62nEz4h2WU92w5DBJy58HlWVq9w59GfMilpTRl7LwDEZpHM7eWZ0+SH9iA0rQ3WPOIFLrXlWeKFwfD+3gjZyMtSqdOsml/7eqJ3kN5q1tH1Hty4DXNV7Iged6WFH0cqm5KLK88wkT1CVEv4yyjXelf+LiZXnmSxcpm+zPZ2OSW4nJBtd3xN6KRTg6ytztA3uM8y5jXzhIR4up9aad7Ztw8Zy/bRKC06aU6AuVye8oWzTn/sdD2XpX7pstV2+xhaOgGaoLFc8QWYA4hbLtKV2TVy4705hbTQ0AlmZux8VVRmxUmTfsbGsWc5OU20kCI6XLA0buH2LLVzU8R32msN2QXc/alfngLDIDYxYeWvh358CeR6gcf1g63fArYp+++zfgA7gGVgGvglYBjztpkEfgP4j1JKvzva9clu4BNCiKiU9tdAV9kL/GfWaZC7CVrWK56btbYwTbxvOLzsRqWNEnrrlgfIOCAmAMCo8VxUnNQ3cZjswA4uPP7XPP+l32B07+vYcuA+dD3qKueN6QIERtJ12lfBi25tdwAvQo8wMn47I6PHmJl+nsnLX+Py499keOAQ27a8hmx61KljtmfBoqA4LyqI8YoyZs470GJ0rk4/weWpb3Ls0A+TTPW3x9hhnfCsXdQeUwPJ4vRJth5+m+d4+MGLsl9bmiO7/YD7ffwyvpt7oawNC7RE4gF2J6ooX5SGutJ1p/JAy6ib6w6Flgvu5Hz1IpXmEhPpw8Hl7Pg9hiSqJygkxpkpn6M/tc1SeQahSiv2ioRUatDnQSQMkLppjLsye8YFdISEaKZAq7KG0aiDcv56JkdrZcX3LtFzGYyVVdd4IM2ouHou5VIPmd2zjhWLEs0nqM625yE7RktQZNxu0k19BHSM0wJQOjlN9pbh9sec0mcXISUFtfNXSd9zVEl0v5yEFNQvXibS34+eSimu73ADJv9/kCKl3N5Dsfe81P3wiAR+WAjRK2jZtZGDbIKWLuLzpvBs1xamye20X5TBZTulde9AD2UC2lVBjBfAOADEBi8KmIkmM+x+1Q+yePl5LjzxCeYvP8vO27+HwtAep24n1sVOR7jZH7OexWb0CF7QdIZGjzI0fJjFhbNMXnqIbz39YYqFXWwbfw19+Z0IIVAD1Dnnp9o9iGCDPdd71rFNESyuXODFc3/LLbveTrG4q612svvoUw8p7QgoLUzSrJUpjO0PVAX5wIsA2WpRX5m/MUyLepG86d6ueNPCmEJLWlXbqDYWWscrrVYdvRNokWrZGnrCo1Lr4Clky6WVZxhK7SYR6cA0KIEHh1I7ubTyLPv6X08bbVp0iOFB9kAmOWSG81cYE7vvicwA1VV7tWfdOZ+oFaulUVoilhhy2JZINk9rbRXZakGkzWho2QytFb8XkJQQyaZoLbdBi3dEzFgtJmgxEGgdLoodzl9lW2zxMSwB0XSNkJeSatuycnKawu3b3PVc4MUELEa9Qf3yDH3bx0wQFmKEW7t4mdjEuFP/ZhvgXq9dys3u/0sov/tSH2ATtPQiYWDEkNQWZojfMRQatKurKKogl4poPRIGbJx2PQAmgGVx7WuCvq2HyQ3v5tIzn+HE3/0ug9tvZ+vRdxCLpd2siwI0pG42EgZebNY7kHkB08jR0yYAmkZxYA99/bsprVzl4qWHePr4R0gm+hgbvo3R4duIRzNt9gUcBsYzFKEihUBKycz885w8+7eMDd/O+NjdDmDxgRWLZXHZ/Fjv94Wp42T6txJL5tQPZr9aT9mtry6ANIgXBwPzX1YJoejBNKrVEynfF3QnMZp1tDD1kMeottmqu9VDTrnOx1ioXmZ/373mTjdPI0MymNjByYWvsVZfIJ0ccAEa1zE18/5Np4aZvPKQ5UHkfoCSmX5kq0ljbYVIvujkRZM50DQay4vEBoecZiPZHEhJq1RCj+cdxkDPZpC1Oka1jp6OuE5Dz6dprligRAqfiigxkKYyu+YAEvfpqpFxNTQllGwQcLGP0R4Gv9eQWsZn+NuUrJ6ZYcv3vcJngAu41ES1yRloGcS2K4bT6kNj7dcvXSZz660uw+WbzrLc7OP//ZIXgDtfjgNtgpaNiHWzNlaXMBo1Ev0jTtZ63Z1fUvGohqA9cfYCXiLxJDvufC8D22/n/GN/xTOf+1W2Hnk7Q9tuRwjNDV5UlVEX8OIcI8jmBXzgxa4rEWTy4xzMvZ9d1fu5du1Jrlx7nHOTX6a/7xZGho4xULwFXYu2z7WHyyExWFg6w/lLX2Vl9QoTY69k5/b7fIBF9RjysSyOaggWrr7A0I472+nKdfAyL/Z2bWkWoUduniGuR8LAc6tqgpb1iLkIZG9LE7RaPdi/eNyV6801GkaVTKQvvBy0VYVCkI4WSUUKzJbPkon3I3Vhf/47di3tNgTp5IDjQRTTi869aro994EQVEtzZHNFB4QLTSOaKdAoLbq6YQcPbJVWLONT82B2VFxjZRU9XXDVMdVDFWvCb5+XIQW6gMRAxqUeAlOF44Tsl+a9G8TAdPISChM/gGnvr12Yx6i3yOxxq82DjHBr568SGSygZVJIw81g2f+y0aAxNU3s3RNKY+bfzcL1m+IWKWUVc3HEl1w2QUs3CWNQJNTmriF0nVguwP1zo4frgW1Zjw2ab80isNRBHvAi2+2q4EUA2aEdHHrLL3H1xINcePITTJ38KhOH7qdv7JClnsECFusAL/YxoQ1eBOakoYAXV7s2eBGCeLLAth1vYNu217G4cJ6pa49z4tRfY8gm6dQw2fQo2cyY+UsNOxOhIVsYrYa1MF+VmfnjXJ1+glp9hcGBg9y993tIpQbMDgcAFq93lItlEbAyf57q6hx9E4f9tikBYMWWyvxV4n3DDhi84XaGNwJLS8wVzaMBTEgHMYwm0WjA2lwBAN8w6mja+la5XmssAZCKFDq2rbIpQsJgagcz5XPsKN4VyLQ4NiqGJJnsszyIZoili658TYsQS+apl+aBPa760UyBxsqSaxLW4glELE6r5PYU0jKmaqtVWiM6UgSkw0ro2SStktumRZVYX4qly4uh+V4JYmT8ZbqDmSAj3PLlJSLZOPGBDE0DnxEutNmWxtU5olsscBPC8DWmZ00j3LFRbPXczZZN9dDNk03Q0qMEeQFV56aIF4dNzxJJbxNDL1/+N3DC8rblUtWr4MWhYhTgpBAVWiTClsNvZnj3K7nywpc5/eifksqPMnH4fgpDt/QEXgC/wa4KmKRp92KDF5fdi92uh31B0ykO7KavfxetVp3lpYuUVq9SWr3KpavfoFKdBwS6HsMwGqbdgSLJRB/jo3cxOnxbe0E/j5eQClh8cVlo/0shuHr67yiOHSCRHXTAR6hhraJuqsxcJjU04S+zUVGvcy9ley1qNBFW8Lswey9fHWkgRG9f84Y0zKjDwQ25du2VnavNElEtQUSLdlcN2e0IwVByJxdXnqbeLBONpe0O4Ni1aPYxBRo6qWQ/5bVZ+uTetprIOlw83Udt1QrZL3HYlmgmT3N12dcFPZOhtaoY3UoQsShEdIxVv8GtlkrQmHaDEltNJKUgmo3TKNW6n3sP0skAF/xxX7zlawtlYn0ZfIs7WqICmObcMpGBQqBKyCkzO49IJNBSaRewuaksS6/v+071N2VDsglaNiCOEe7ctbZqyHsT2kj85bg5uz29Kptuz8VdwIuXoLH3o8ks22//Lkb3vpYrz3+RFx/6fbIDOxjf/0YKQ3v84MVjn+LyNvICELt/Ejf7ItqTQCf2RRNxigN7KA7scdpr1quUVqdoNstoWgxdj6JpUec/Ec+bE6o3NL8CRFTAYrMsNnOisiyV1VkWp05w4N5/3G5DaSfMcBegPHuJoTvfHHz9BG6QdBNFtlrtiKQ9V5KIHlUQ0mj1DHBsqbZKJHTF48gVJM4CqZrWzrOucTExjq7FmCtfYDR20M+2WMDEvvdSyUHK5Vkl3/wTEhI2aPE879F0nuritTaQsd4JejpDq7Tavq/BDOWfTrVBi9KWlkpgrFXbpyUFuoIUo9kEdQW0bMRrKEi8Rrfe2C9BUltYI9bnd4kP8hxqzi2T2jnhK2uLkILG7BzRgf512VG95LIJWm6abIKWHiQoGq6QUJ2forDnWGh5R16KG3Q9LyRvWRsMBGR73ZbDwEs808fOV7yf0f33cuX5L/DiQ79PMjvA8O5XMbTtDvRIzG3z4rVP6UV11Il9ASc6aTD4MdP0eJJCfGdHWyP3GkJKmsKEqIBFVQup4OXqmYdIF7eQHdzhZliC1EJKWqO8QmN1idTwhI8ZC/Q8Wq/cwPtPGi2Evj7QIqXhU710KivCmJYQqTZLwV5DhuHe1hQwJCUaGgPJ7cyUzzKWO2DatfjawAG06dQASysXXeNpuz3H030sTZ800xRwEk3nWb100tdsRGVaFNHSaYw1vxpISyVolWtW1/39jGTiNFf9TEuQJ5HXGPdGiApg6gtrRIud7Z7sc2jOLxEZyFuJwvNv/jVn54kMDrTzAljvTfnOkU3Q0qt4HhRptMzAcq8YdYOUl/pB6vDu76ZWCrdvUfKd90Vv4CWZH2L3q36AidUlZs58ncvPf55Lz32OoR13Mrz7VSTTfQr48LftUx31yr6E2b4I5YXnBTFdJChwnFsd5AcsNnPUqK8xO/k4O+/8XpNt8rx/3ayL+788ewmhR0j0tQ26vTYwf19EtpoIbX2vjUD1UMhzYsgWWi9MiwJCq00P0xImNnBRXZ+TO3lh4UEM2UJIQZgxrpCSVHKQK9ceBxRgYp2LrR5SY7WAqR5qrAZEuU1naa0pKzdL897W0klaq2UU7G6VT9Baq/oMcW2JZBM0yw2MpoER7W6vAr3ZtYC6jlFvN2R9oUxiwm0U7XV3BjDqDVrLa0T6C+Hh+4HG7JwrEi4oj8bNAi4S/8fpOutvysZkE7RsUOpL88hWk0T/qJPW6Wv+ug2vQt4X67F/6W7f4k/vnXkpMHHsbYwfvI+5i08xffIhpk49RH5kD4Pbbqdv7JAZq8MBE+HsC7gBTBD7gkoV2+3ZJxYGYjpJEBuiqoPsdOWnrsN09ezDROMZ+ieOKMa67fwwbyPbniU5MIbQdccOppPccCPddYg0jI2ph3pU+XRlWgLWHao2S+SSQwSqhXz13YzLYHI7LaPujo6riApC0okBGo01mvUyur0+knXIRLqPRrWE0WyYgeSsSS2aztOqriEbDdCjDtjR0xnql+accnbPtXTaZ9MCoKXiLvVQezhM8BzNmsbRtVKdSN/6DKV7kfUY5dYX1sgd2eJL90pz3lrVvD8f3qiE5tw8kdtvX0dvXwbZVA/dNNkELV0kkEWRUF+as1xUCy9DJ4KTQyevbpOazRb5tSJq9obAi4hFGdp1F4M776Q0c565849x/slPcO6Jj9M3foiBbbdTGNptffHSFcAEsi+dAIxXhQQOiOlJVGYFXOyKj2Gx9tdWprj64lfYeef7EJoezLIE7Nv/pSunSY3tdOf1KC83gPGudNxzvfW8pXtUJdnSMKrEdEsd0cVryJUGREWcQnyMufIFE7RY6w15g8vZHkQA1coC6UTKXKjTkniyAEC9vEws3o61E0laHkHlVfRE0UnXUymMSgA4SSYwqm41j5SgJWLIRstc6TkA0+lx81Vu1HoNRvrSidFoocWs/nSI0dKyQJhIdY6u3CqtOu7gm143m7IJWnqRACqwvjxPNNcXuubQDZOA93fgRLWe93wAQglmWfxVfODFAQ7tMZIAQpAb3klueCfbG+9h8epx5i48wcmHfp9IPE3f+CH6J46SG9jREcCo6KNXAOOokMABMc65hYjbw8cLXAgFLIZscvrxv6Awto+B7bcHsizqAHoBTbNWpnztAiN3v/WmMii9yjrxhFVJA4/XVtj9KhDBwCNMpKRp1ImIEDdpuy0VuHjYlv7kBDPl8whDuu1abHsWyyA3GkkS0RNUqouk2dKOxyIl0YQ5qTYqJWJFP2hpVtbQaYMWLZHEqFT85x+PYSwvW11uR5wWNgioNyHmf22LiIlkjObNBS1SCgf4d1MnyUYTABHVrbp2RvtfNprQbKIlk6501//Nkpt9/O9Q2QQtG5T6yiKxXF9o/rq+COwJ15sWIL0aZvYyAXo/JvF0I5B9cdpvsxuh7It1XiIWpX/bMfq3HaNRWWXh8rMsXHyWF/7ufxGNp+kbP0zfxBHyAztDAUwn9VEggLE7pMTl6GVMwtU4fsAikUw+/wD18hL7XvcTVpRcO79d3wVkXG1C6dJJtGic9NgOd0eUOoGeQ93O5SUDQEE3a5caQuudoREC2S38rUeaRp2IpgSks1VDYesPeaQ/sZUzS49Sb1WI6ml/HQXFJxJFqpXFdneVWC2RWIpGZdlKtxiSaAKERqu85rKD0RNJjKoHtEjQEnGa036DWi1mBUysNwh6bWvWcgBG48Ya2DrtCwND9qYWFOAsz9FJZKNpXg9dD72ljKrJxmgJT5yfmwxcNuO03DzZBC3rFPtmaywvtEGL9wbcyAOlzgUbBCzr/VLfmI2L//CO4aEFHlRbQS+AiaQyDO+5h+E999ColFi4/BwLF5/lxN/9DpFYir7xQ/SNHyI/tBtNi7QZF6+hnovWwYyroeyrEX9dQMZ7Et6TUbZdsVq0dp4NWC4e/xzXzn6dva/+EaLJbABYES7AEQRCVi6+SHZir9ueJew6/n1gYqzlDtZXRfji44SWZX3tG7KJQYuI1qMdRwBwycdH0EWUhcolhqN7sY1x2wexyCIgkShQrdorN1s3p1U0mszRKJd8bsyRZJpmpe0pJCRo8SRGrWape9rqTBGPY9TquB4igKgJWox6Uzn3djh/m61YD9PSixEugC6kE123J2NcTQQ/Yx6RzRYiolv3R3AZo2wCOy3ZZYHOTfmOkU3QskGpryyQGvbHF7guBN3hfbBuwLKeCc6jIvJW75V9MdMsZsOrPlLKtQFM1gVgFq+8wMLl5zj5yB+i6VGKo/vp23KYwvDejRnx2p10wJenI0FD4VXneMCK2aRk8vgDTJ1+iL2v/hEKo/tcbIq0y3rAivfYEoPS5AlG73lnZ7Di6l/3Mj5ZPznSoS3hZzC6VtF6ryPW19mm0QAgInpbJsARRUWkaTp9iS3MlycZzu1td8XjCQSQjBcpV+cDm4wlcw7TooqeTNOquEPsm+oOiVGrocXaLIKWiCFrdV8bwmFamr48UJiWZndwuB53Zw0ZGo8lSISQlspcmosydrhhZb3pqL3CxKiEMC03W67XJGCTadmwbIKWbhJyczVKS84qri95FzoAkhsSx8Nbx8NMdAMwwcBE+doKYGDa4AMHwAztvpuh3XfTrFdYunKChcvPceabfw5AfngPxbGDFEf3E0tkuwMYT2ddQKaLuBwlFLCCgEajwvmnP8H8lefY+5oPkh/d6wMseLfBB1ykgNXLZ2hVy2S37/P3oQcQs2FD7OsQG7atr5KGlAEMQABAMZmW3ifVpmFO8Po6Q/+7xJD0JbdyufScP08BW0JKEvECC8tnlXw7D6KJHPVKCa9EEn7QosdN5sCoVNCy7QnZZFoU9ZB1kTXVpiVAhG7etPIlUg/ZoiFphdxgDhOjCZNB6iatlqka6iBGtQpCIGKxv1cT/aZ66ObJJmhZjygvKGk0EZHreFH2esjrASwbmby8di7XAWDcxrlCSfOwMCqAwXyh9++8jYEdt9Fq1lmeOsXSleNcfO6znHv8Y2T6JyiOHqAwspd0Ycz6klc74D4PF5DxdlwV19h6GBcBy9OnOfP4R9EiMQ7e+9OkB7a6wIkawyUIxKjqI4nB1KOfobjvDqLpnM+At90Pf1rH6/oSAhYANB0Z4E4sRfiLWNMjGEZvagtNi2AYwRPzukRdnNPaFg775lcR5aIDlBuLZpyYoOi9liooFk3RaJQD76FINEm1suB8hQvLFkuLxjEabvZEWOoe2Wy403UdglQ8dnjbEFsR24ZEBAXIW6fY4MO0Y+nNVV1lZKL5JI3litNW2JUX8Siy1gjJtcrYcXWk98V0k2WTablpsglaNipSIl7ih6hnwNIDWOmmVggMPBfUp5DDdE1XAcw6WBgtGqO49RB9E4eQhsHq/EUWrxxn7tJTXHr+c+ixJPmh3eSH9pAf3kMi3W9eFweweBiWbu8+zxg3G1UWrj7P3MUnWZ4+w8ieVzFx5G1o0VgoYPEyLS6PIWt/8eSTVBen2faOH+1Z5XNd3kV+UmNjzWgaskcAYoumRcz4JT2VjdJaB2ix479s1BXbllS0iERSaSyT1vpNcGAvOaGoiSKRFM1GBSklQlorPVtRcfVonNaKP5aKFomacVpU5s9iGGTTc666FsxSKKrJIJEW0BGR9a/YvF7RhbSGJ1h1FCumqC+0mSUTuJjlhGIgpyUTyFod2WqBCJ6K2uCuaca/2ZTveNkELRsVie9rbV3VO3yZ2vku6QWweOqsZ5ILKuvzLvLshwKVMLYlNF241DuusioLo2lkhraTGdrO1mNvp15eZmX6DMvXTnPlxJc5/+RfE0vmSRfHSRXGyRTGSBe3EEvm267pPYyJYTRZmj7J3ORTLEwdR9Oi9E8c4eAbf5bM4DYXEAkCLGHqInvfaNa59s3PMnjs9cQyhQA3aU9d10VRxtIrL8OHqFCYlm73sFNHj2DUQ1Yo1oSLPdC1KIbRG8ABnA+HXjyOpJRttsUjCT2DJiKUawuk4/12BbyDGo0kTeNfo4GG2/hXj8QxGn7PHxGNYTQVpkXisLRe0CI03VSbeNtw3LWDB9y2ZdE8oMUbwt9JVy6croxdq8c1orxtqd2K96dZPjHdvV7KVIsZlRpaKgy0mOmy8fcMtGwyLTdNNkHLBuV6v+w6tn2dgOWGTGjS306nJrzODhsFMaEsjNUnFcRE03n6d95O/87bwZBUS7OUZs6ztniF5elTTJ38KkarQSSWIpEdIBJLE42nicTTRGJpIrEURrNGo1qiXl2hUS3RqJaorS1iGC2KYwfY84ofID+2D02PuAFDCFgJBB0ekDPz7NeQ0mDw9nt7A5Yi5Jp6yrwcsmGmpdUbe2KqktYBWm4Q0yKEIB0tstZYYLBDuWjEnGibjQqxeNx1z+uROK0A0KJFojSrHkNca6XsQKYlKJpvlw8kaYEWPar17BUEbsBi77fQfJ5CugeY2C7QQR5Fsb409UXP+QqcI9mnoqdN0CcrVUj5F1gEBbS0er8nXg4J+p5Yb/1N2Zhsgpb1iDXJms+oXy8eVj5MXC7FrBNs9AJYOnQvlFnpUNd7Ki8ZiFHGpaMqSR0/XZDID5HIDzFo1zUMqqVZ1hauUFtbpFlfo1lbo7IyTaO2RrNWRo/EiCazRBM50sUtRJJZ4qkCueE9RGJJP7PhY1l6BCzWf6O8wuyTX2b01e9Giyc6ll0Xy9KLhN2PXe5TV1FNh/WCFj2K7KTyUc6nq3pIE9BSjGPXwbQEimLfko4WWasvuvOVBRMxJJGIaUDbaFaIUXAV1aNxWs0A0BKNYay62xWaBpoWwLRogUyLM0YKclDBiQ1aNMsgdz3ApZNowgCpmQsvdonVognTYyjRl6I+v9bVe0hLmaDFKFfR+2kHtlaqOIxU4wbYOW3Kt4VsgpZuEvLMCV33GdGBRZljzanSk25PtNJfp5djq5NlUJlOgKWXia5TmW6B6AIO6W/bA4q6q40IBzFOmoeJccoBmkaiMEyiMOw+jy6i2vL6xtcBDqID80IgCGk1qkx+4Y+J5QcoHrw7tKxLPCzLzVILOYcKMcQNrwBCj2J0+1K2v761KEbL7/IbJpqww8VvYFLzRMaN6xnKzaWOVSK6OdG2mh7bFQlaxKMGskToET+jggVQvGOpaT0FZvOK0TCBjhYLVu/oQqIhXe7OXpZFTQ9iWwBXmnu7DWjigxmapSqtSh0RVzyjFGt7IaSpHtI0jFIZIfzu5QgQcVMlZAeZ+3slmyqemyIvvdXWt6nEC4NUl2bNnZdi0tgoYBH+dB+YWe9PaUf9ectJzVNG85TROpTX1pGutdOlJsyfEO1tjcAfIji9YzlXnfZxEN48ujIsZz75YRprK2x/x4+ZE1aIrMtjKOA+cV2jGyxC713V4wCRSJRWq9H9OdEgEknQbPnZCrM94duO6DF0EaHeqoSXDT2e+xpI2ULrtFij2nwgFRkyi4XYv8mgCL2G4bgvu8paTIodrt8rzbIJliLp7nYf18vCeO1kvO2lt5lBN8sXzXg2Qsl33dKaRmQgT2NmgcACgJZOIWJRWktLvT0PL5PYLs/X89uUjckm07JOsRmTeN8wtYXuxmaAn13x7geV9xwzrEwYu9KLmqhb3JKOwdgCbF6CivpOU3geWGUsvIyL2QflOD7WJSxd+NLN/fW9KVzj4x1vEbDtASt2+eriNc59+veIpnPs/K6fRE9lOgIcL1gMVQuFXW/c6WHjvW4RFmvQC2hRjqPpCgPRZbKJRJLUa/5YJ2gQ5jsb01PUjBBDX7VLQfe7ktaUDXSt86Tftp0JOZGgY0gj+NgBoEVKwwemgLZ3UNQNWmzAYFTqICCSiGIPvG7ldQsmp4IOmzmx2RanvtRAtLVTYR5EmpDEsnHigxnWzs+R3DNu9luhau1tISTR4T6a0wHB+qwHXGiCSF+R5rwJbKSgHd7HC+xfTtk0xL1psglaehGBT90T7x9m+dQzrjLdbkTXBKJOuHjSPHV8+b0CFh/4Wd8T3qm8CDnZriClWxnPuHRUHdnlugCZdt7633BBY+wDEgHgxf4vXT3L5AN/QHp8FxNv+QGfq3QgYCHkOKr0AFjU/LAvu055QSL0iN8Qtwso1yIxt3qoQ38jkQTl8mzbq0izOtkBcMb0NPXWWmh+mMeQV1pGg3gk2CC0LTYS87cZ5p0kw+zfDMPPuLU8oMW6OG2X5nCmJZKKIbTeUKmtGvKyJF6VkH+/rQZyb0s02QYw6R0DlCfnXHYtLsbFAi7Rkb4202IDG48uWu/ro7nosTXalO9Y+bYALUKILPCvgGPArcAA8G+llP/metv2TVrW82QyLTPWd4blwSBEm52w6gpwvUMCv3x7PbbyHzqZBrTrnayNZoPqwjUqc5epLcyYxXUNoemmoaWmoUfjRNN5otkC0UyRSCrjeGrQAQAEgZmegEzAxBcEZLz2K92ADHjATGinPMfy9k3JC1LFuYCHlbd45mkufenP6Dv0SkZf+10IXfPVDQQsnv0wwLIe9c+6wEkASLdF65VpUUSPxGh5bT1C+h6NJGna9iJhSwZ40uN6ipqhqIeCbEV6kKask9KK7kQPpnAC1XkznAc96AbygxbDAT++AwSrDq0xD4vD0lyrE0n5g11uRBVkAxWVbQnKD9sHyGzvp3R2zsmXVqwWb9nocB/VU5eUe1/9CjH/In0FmouL7fcpoSP98skm03LT5NsCtAD9wIeAZ4BPAj/+kh3Jmlzj/cPIZp1GaYlYts81wToPVAc1yIZitAQ9pR1BjLlhtJosnXyCtalzVGYvU12cBsMgmi2S6BsGKzaENOyfgdGo0lhdplUzJwOh6UQyeWLZPuKFQdcvlutvB8sK6qTABeac/nrHwDMu6wYy1n5PgKXTG8+T1xU8erabjTpzz3yV6ce+wOg976T/ttchNGXxxCCgE5AeeuwO6T4Jus86fYyreQHlhK6vG7S41ENq14S/66ZNS29Gl1ITiJYkbjMtasRb6Ax6AqRlNNyrRXtFXQiwVxsVqz/Cq2q0QZVXPdRqQYBNCz0yLZ1EE4YLxKwH0Hg9h+xw/l5jXM1Ky+zo59qXX/S0YTpjtdVDmEzLtQX/2Fn3nhSSSH8f5cnLVrpV7iarh67XLmXTpmXj8u0CWiaBopRSCiEGuMGgJYgxiRb60RMpVi+doe/AXb1NBB7gAgGTtLdewHbHL3+njMBoNVk88S1mnvgSRqNGZus+CntvJzm0heTAOJGknwr39qFVr9EsLdFYXaJRWqS2PE9taYbyixeoLc2aE5jQiOX7iReGiBcHiReGSBSHiBeH0BNpcxXXjYIZzzgFMS1qfqB6yXUAenvRdWM3AvYblVXmnnuY+eceRmg6W+//QfK3HGuXC2BVfOl4tsOOH9THsPNYB1ju9jIVerRzdNuA50CPxJCyhWE00XFPul7gEokkzTD5oe37D5CIZFmuXevc8S4ikaw1FpiIHvMcyy1Ny7NJ06xXp1LEMJrtdEWMZtNkMNXj2cyJZ+0d2WyZaZ4LYVguv3bcElWEkDRWa0QzcVNN4/ESArfxrNdrKMimRWVbEJoZ1h8Jwm/Xopa3Jbt7kPr8Go35EnpfztVXpHCGNrZlEFmr05pfQu/rM/GIZ9ijQwM0pmeQRpvV3pTvXPm2AC3ypYz0ph5HtL/chaaR232Y5TNPm6AFLJZFURHZHwQqYPG8c0Mp/kDmpEOaktcyWiy++BgzT3yJVq3C4K2vZ+Doa5xF2ux6vQyaHouj9w8T7x/25Ulp0Fhdpr44S21pltrCNNX5KZbPPEOjZOqgtViCeGGAWH6QeH7A2h4glusnksoGL2PvABG3qs3c8J+vj00JASZBbtth0pMNiTDBYW1pltmnv8rii48RzRQYvuftFA/cgRaJdWdX8O+vR/UXuA/rZ/lCQLe3vBaNIVtNDCnRehxMPWq6vbYaNfRoKvAYCIFAEotmaLaqJuvheT251K82iyIE2dggZ5cexZBGu0+2isjLtgglX5Gl2jUaRpX+1HazjGKzoqpC6w3TSDgez+GVVr1MJO4/P6NeRYsnXdfJqFvgJ+6OqitrNbSEO00IMKpW+UTMdBf2XMTGcpVY3l3PFj3ggtv1O9m0BKl9zHQ/6+I1xs3u6ENPx1g5foXia3KBHkRCSKIjfWjJOPWzl0n1F1HXKLP/Y9smkPU6jdkZ4kMjjjHuy/PWD5FN9dBNk28L0HK9IoQYAl8gzF3qjvPyVl7uuVuOMfnJ36VVKxOJKS8rFawQMFF4J2AC8jz7vQAWKQTLZ5/h6iN/S6tWZuDoaxm89XU+sNLxeOsQITRiuSKxXJHMtltc52M06tSWZqkvz1FbmqO+NMfa1bMsnPgmzbUVs34kSizXTyzXp/z3Ecua/06/A5mX3gCNWdZTrkcJGysDqC3NUrp4gtLkCVYvnSY5tIWJt3w/uV2HzaixIYxKoE0Lnm3P8QINq7udS9CYbFBdqYoWtQKCNetokeBJ0itt0FKFANBiixSCWDwLQKOxRiSSd9JFAMNiSzY+iCFblJtLZCLFcKDiFSEcgDJXOU8+PhJuiGu1Ua+vomkRdD3uXBd7TcFm3XoPuK67oFWvEk33u5ozaqYKzAtajFrdiU2iTvSyUoeIhh7TIMCItr5cIZZLuNoKC+HfTcLis4Db8La9qKLuBJazjXGFrpE/MErphSv0v3YfLWl6CznrkFovU00XxHaOUTt3mdRdh3HUP+B8jejFPFo2Q/3iJeJDIxs6p5dCNlU8N0c2QYspPw3868Ac70Sh6FIzE7vRYwmWzz5P34G7fCokVx21rZDJNey4vQAWA8m1b3yW2aceZPDWexm87V6X+qcXtcJ6J3VXdz0shhaLkRwaJzk0rhzA6mujRn1lkfryPPWVefN/eZ7VK6dprCw667dosQSxbJFotkgsWyCaLhDNFolmCsSyBSKpHFok2gGsyOs6L/sLW0pJs1yiMnuJ0sUXKU2eoL6yQCzXR2bbfnbc9SbS47ucr/NA9Y+6HZbndNyTFgRa8JRRq4eAk7adwDpfuEobWswK9tWoQyQe2L5XHNDiDcgWILFYBoBqY41ENB8MVuyouFZeQs8S0eKUmnNkon1twBJmkBtg6DpbvsBgeqe/rAJ4pBDU6yVisaxpo6QUkwKa9Qq6wrTY18aoV9FjbkBh1M17XCTcUZGlAlpc5at19IQ/3QYujZUqye0Ff/87iJdlcbs526BEglTSFRVRkF2LKvlD48w+ctZpz/Y5s8vbwCWxa5zqmSued631QhEghCC+bYLapUtk7rzTrOcsILkp32ny9w60CCFeD3ylx+K3SimfvgGH/TDwV560XcCnzE7h+yqVAkRED1cRmY6OwWxL+Eejb2IKtldxpzUbNS5+8U9Zu3qW7W//MXI7DvjLdmq7h36EynpYDGsMtFicxMAIiQH/V5OUkla1TGNlkfrKAvWVBcueZonyzCUapSWa5XYcDz2eJJLOEU3liKRzRFJZIvEUejyJHk+hJ8xtLRpHaG0PKaGb/0azgdGoYTRqtOrWf61iMUSz1JZmqC3OYjRqCD1CenwX/UdfQ3bHfmKFwbYaIYgxCWBWnLHaIFjpZZx99lKd7rd1ihaxQUsNktme6ugWI9MMWJfHKxE9jqZFqTdWgwsE6AWEEBTio8xXLjKavMVdzgtcbMCigJFac42V+jQHBt/UZl+EaKuFFIxTbZQcYGW20950mBaPtOpVc8kGS6QAWbeBuRuIeNVDdvNGtY4WAFpsaaxUfUwLuGO0aEKiYwSClfPfmOaz//oJ7v+Xt7L9teNO+SAwYrdrSN1n16Ia4xYPj3L+I9/AqNQgkbC8iITPGDe+a5zlLz5mRloWtj2PUEC2JLZ1C5XjJ11jeFOZjk310E2Tv3egBTgJ/ESPZS/eiANKKWeAGTXNtvaXngkjTEXUrK4SSWQCXXltBsY1mXSZfLp6jVj/1eVZLnz2D5CGwe73/bzpDRRS1tduQPvrlnXW7fqsCoGeSqOn0iSHtwQWMZpNmmvLNNZWaK6tOP/NtRWqC9do1Sq0qmXzv1Zel/uriETRYwnLsHiQ3O6jlnHxINHigMnsgA9QBBrohoEXOoCVTiDGk95Rgu43r03VBsCMFrPUQz0AELDuf11Di8RoNqsmENAkneKdxaKZYNCiBpizQInUBMKAkfQeTi48xP7i69FFxA1swqIPW6qhmfJ5olqSXDJc9WCPZb2+SiyWbdcH53o0amVS2aLvehn1Kno84bq+Rr2GiERMbyzlIpjqIb/rsqzVEAl/ui315SqxvAlaNCF9diw+w1wr3zbK/cbvnSQa1/n4L3yDO75/N6/86UPEku3pwTbIDVMRaVK47FoA8vtGEEJQOnGV7K07HXWX1xg3sWsMWanRvDZHZGQ40Bg3vm2C5S98BdlqIrSIi/G+GbLpPXTz5O8daJFSTgG/d7P7oYoKPHwqoq27iWYKzD3zMCN339+eaCy2xaHj7fp2eyE37Xq8RpbOP8elL/056bEdTNz3A0SSqdCyXSe+m/TwdxKfca0lIhohWugnWuj31fGJIS0mpW4GRTMM063bcvEWegQRj6NHE2ixmM/LI8yOpJMXUVj6eliVdRveghuAKIAkCGx770H7HnXwdIia07RpEY4rfNDxXG1aaZFokpbiFWTaqbRVPKok4jlqteV2gjfAnF1HYV1GMns5ufAwF1efYUf29na5Li7PUhpcWH6C8ewBMw6RaoSrucsioFyZI5Mba9uzKMClXlmikDrgnLvJupqqRT2lsDNAq1xGSwUY7ZYr6Lm0zwyntVZDT/mZFDDBQ32pQqyQCHRj7mbbMnt6mUtPzPHBj76B0myVz//7pzj14FXe9C9uY8c9JpBzxWWx1EK+bcWuRROSSDJCbv8Iy09Nkr3VVL05DIu1LYQkOpRH78tRffEC2dEh0xjXBiTWPRLfuR1aLaoXLpDctbu9jtHNem9tMi03TTb9x3oRz2TVfmEBus7AHfey8PRDNKurLruFoEX11P2gn+uYQRObMFUoU499nsnPfYTBW1/P9nf8uB+wBNX3pOPpU6d+3Yif75jr+Wkhv271dIGWSBDJ5ojmi0SL/cT6h4gPjZIY2UJ8cIRYroieSpoxMDztu9YlEvjXKrLSnD6KkLLea9ipXsi5SCSNlSXK505RnjxHbWGWlsp4eK9nh3vIVSdIQtKFpqEnUjQr4RFozeO5G4jEUjRqIa7MmnBd50SiSLW+bKV3mZXsNYi0OLsKd3N2+VvUW1WFBRH+n52uCabKp6g0V9hRuMsDUDzbmkBKyeraFJnMiHWO7XOV0qC2tkA86zG4rVcxGnWimbwrvVleRU+ryzmYAdiMtTJaxgIzTleluRJyJuF4DglsAABGvUlzrU6y6DHE7fI5b7MsT/3VecaP9jGyL8+e1wzzYx9/E7teM8LHf+ZhPvPPv0V5wc+q+Zmc4GP13bGNxScmHUBjn4+6LYQgeXAH1RfOtYEK6j9o6SSxbRNUXzzltH09Nnib8g9X/t4xLRsVIcRbgTRgK9oPCCHea21/VkrZfXGSwIbNPx/bItrbxUN3sfjcN7j4uT9hx7s+1I4cq7ahGkDaD1vQ16wiQV/bLaPFla/+FUtnnmbb2z5Ifseh4IkppL53+4bYtfQoL8nHxY3qY0g76xrDoHH3poeV9bRtNBpUL1+gevUS9dkZ6rPXqM9OY9RqPjsNLR5Hz+SIFor0ve7NpLbtdN9j3vvPOoZqcxV27j42RkIkmaFZXW0/Az1IJJ6iWe/tEUzECywtX/BnCGH1QbaNccFREW3NHWVy5SnOlR5jX+E1dGNaDGlwZulRtuaOte1UVHsW1a4FqDfXaDTKpDOjvjD+9WoJ2WoSz/S7gGmjvAyAns0rAAVaqyX0jJt9AUzQkk760ltrVfR0MNNSXzJZr3jRX08FF0H2LPVyk+Ofucib/6+jTloyG+G+//MYB962lQf+zZN8+p9+ne/9/XtBulVEXrsWMz6M265l4M6tnP/Db9BcWkXks6F2LcmDO1j48y+1g8wF2LUk9++l8twLFN/xNudlfNOAyybTctPk2wa0AL8FbFP232f9AHYAFzbSqMtoEtyGtdYDJaJRJt75I5z9019n+tHPMnLPO5Q5w4otETJxdDyuLdZ2s15l8nMfoTp/lV3f/TOkRra6y3aYSEPzA/I69mUD0sv53kjZcH+D6oWNWQ9j2YvKyP6XhkHt2hXWzp2icu40lclzyFaL2NAIsaER0nsPUHj1vcQHh4n2D4CUNFdLtEorNEsrNFdLVCfPc/kPfpP8nfcwcN/bTY8VBVxvyJYloGwkmaZZaduchIEbV51Ymma9MztjSyJRoDqz5EoLi9GighJNi3BL8dU8N/s5tuWOkdSy4UyNJphafZFac5Wdxbva7frK4YCX1bVrCKGTSlvREUT7V10zF/2LZ4qu6o3VFRAaEa96aG0VPeM3ZHYxLShsymqVaMEPSjQklQ6gpX26MnD7xAMX0aMa+9887is/fqSPd/7HO/jD73uQ+XMrFHe02SKv55A3dostuVuGiWTiLD11kb7XHwy1a0kd2sHs8irNq7NERhW7FuWSJA/cwvIDXzQBXzprZt0k45BNm5abJ982oEVKuf0la9vDsjjgRbTz4oUBJt76/Ux+6vdJDm8lv+tIR+DSkyjlamvLXPj07yJbLXa99+eJW/YcPbErPUy8gfk99i1QPJPYDZHrbadL/cB+9sJKdWFNAvMEtCpl1s68yOrJ45TPnMSolIkNDpPctYf8K15FYscu9ET4RBQpFokUi9i+Jvm77yF76x3MfOpjrJ08ztC73kdm934XcHGxK6KNZ4Jsr9TzVl+yejJNqxoMQMLstSLxFI1q70xLrbaCIVtoQnO7PXtXe3aAhmXbkr6FC8uPc3rx6xwZvL8dvtUWiyExkJxd+obJsuipNqNiq6QUexb72pXK10ilBtH0CIZ9XS1Stba2QDSZR0RiZp6V31hbJpLOIjStnS5M0BIdGvKpjY21Mno65RtEo1xFG3cDIltqi2W0qEYkHQP80XCDRMdASslTf3meI+/eSiQevDzA8L4Cw/sLPP+p87zmF46521AYFhvAOGyLZdeiRTSKt21l8fHz9L3+IKAwLNa2EJLYcIHIQIHqibNkxxS7FsC2a4ltn0AkE1ROniZz+22bbMV3qHzbgJaXTDwTkAuw0GZbpIDszgMM3f1mLn/hz4m9t5/UwLhST1ibNlXT2zGlEJSnL3Lhgf9NLNfP9rf9KJFU2spzlw/7snfldUoPOueNyk1qoyeAFFKma91u49mB6ZJImsuLlC+dp3rxAtVLF6hdu4oWi5Pas5eBt72b1K49RPJu24dO/fXdQxJSe/ay9ed+mYUvPsDVP/k9skduZ+j+d6On0k75MHCi9j00X1jqoXKIS3KIRONpqiuzLnZCVZdYMxgISCT7kBhU6yVSUWU8VGbFY8Brq4iEpnFL32t57NpfMZbZz0BSJV/b7VxaeYZaq8yO4p1Ix21duNgWqe4LWF2dIpMZVcq2x6u6Ok8i0+d7XzTWlkx7Fs81bK2uktixw5Ummw1kveEwLar5TWu14qiHhAfQNJfKxApJhBBoduA5ZWzCQMzMi4tMn1zmu371LnRPmZbUHBblyHdt45H/9SKv/tnD6BEww/q32/a6Pnul745tnP/DbyAw0IRGyzoHb7yW5KEdVJ4/R/ZNr7SACta4mWMtdJ3k3j1UTrxI5vbbfEzMyy6boOmmyCZo6Sb2y5XubAsSBl9xH7WFaS787e+x+30/TyxT8NgVKKxLB5FCII0Wc09/jWvffID87mNsufd9aNGola/0L2C/I/PiTffkdUx7GWRdzEyHsutmeDzlO45RB4ACII0WtemrVC6dp3LxAtWL52muLKMlkiS2bid98AgDb383iYltiEhkQ6xXWLYWjzPwju8ic/goM5/8KyZ/69fY+pO/SMRWR2xENaRsx7J9LM9cdvoYGItIbUNANJGjXl3p6bCJRAEhdMqVuTZoURgW5xmyV+DzRL/tT21le+52np79DK8c/QDpaBEpJbXWKqXGPKX6HGeXHuWW/tcQjabbYMUJDugGL1iB5BaXz7Fjx32Bz9Ta0lWSxVEnzTSoFtSX5ogVBnzn2FxeIlIouNJaKyYQ1PJqHBjz3FqlCtFcsu3YpBiz1hYrxIupgJD8nRmXU1++yujBIoPbw6MUa0Jy4K0TfOW/P8e5h6bYde+WdttS8y+aGGDX0n/rFk7+9zVqVxeIjg2E27Uc2cXc733aXDRSKGs7Oe9OSfLwARY//rem55+m3zTcIKT0rZu23vqbsjHZBC1dxGfTEvQiV9gWoWmMv+UDXPjr/8X5v/kddr3354jEkj7goko7cms7vTJ7mctf+Utqy3OMv+49FA/cjbAMEdsVlT4q+53UFR3VQxtlIG6k9HCs6wUjoW10GY9QAGi0qM9NU526TPXqZWpXL1O7dgXZaBDtHyCxdTvFe99Mcvt2ogNDCGUVXyk8GGId5ybdZIOvamLbDrb89C9y5Xf/J1Mf+2O2/OBPKqtxt8v7VERh9inW8WKFfurLc907qAKdZJ56pTfQogmddHKAtcoMA4XdZhsd3J0dNY4Gwvrc39v/WtYaCzx27eMkIzlKjTmaRg2BTibWx0TuKFtzt7bru7yK3P9SCMqVWer1VQr9u00QI5TnVUB58QqFrQd991VtaZb09r2uZ7PVapp2GYWii1ForZhBE/V81s/MrJTRc8Hgor5UIV4INtJ1j6t0AswBnHpwikNvD46FpAuDlqX7SuRi3PKmLRz/5Dn2vGHctn+2yqlGuP41iTQhSY7lifWnWXn2MgNjAy67FmHZtQghSR/ZxUylRv3sZeJ7tpljb42ZPXbJw/uZ/5O/pHr+PMndu28e07JpiHvTZBO0dJHmyhJyaMTNsgjlfWxvK2laJMrWd36Q8x/9/zj/id9m+BX3k926D9fy9K6JoZ1uNOpMP/55Zp/6O/I7D7H9HT9ONJOzylmFuoCVjmU95bqyC6q8xC+IG2lAe92gxJsvQBoGzeUlanPXqM9cozY7TX3G3JaNBnomS3xsC8ndeyi+7l7iE9uIZLO+9mVA22Givtu6DU+QvbMWjTLyfT/EpQ//OnNf+RyDb3p7l1ZwM4l2g0pHYvkBWrUKjVqFaCwZWMZXJ5nDaNZoNqpE9S5rFmmQSg2xWnbFe1QYFrB0DNZ2gJoIjaPDb+fUwiNEtBhb88fIxgZJRQvOSsxSdam2tl1eQ8pHwsLyORKJIslUn8s2RQpBvbZKvbJMqm/c6mc7v7Y0R1/fq13n0VxZAghgWlYQiThaPAYYzgUw6g2Map1Izm/fJISkUWoHlvMPpdmGd2XnxckV5s6V2PuGEVdZNUCcClyOfvc2/uJDD1GaqZAeTKGqiFzHU+xaHBWSBoUjW1h+7jID9x9z+t3GieaLNZJPEd85RuXZUxZoscCpDewQ6Jk08V07KD/3/M0FLZty02QTtHSR1eeeIr1nr2lMa7/MQ9gWVWUUSabZ9p6fZObhz3Dh079PvDDIwLHXUdx7O5oe9T1szWqZtavnmHrkUxjNBtve+sPkdx128tetDuoAYELzCc4Pkpfd1fAlZkvsfSklrbVVGgtz1Bdmqc/P0ZifNffnZ5H1OiISITowRGxomPT+Q/Td+ybiYxPo+ZwvknIoO9PjObr6HlRZ+Kt5wUu0r5/h9/0jpv7kf5OY2E5270GnXBDb4upPgFFuLG8agddX5okObOkKWABiKVPNU68sE80MmQasUgkwp2EyJ1bddGqQ+cXTzjGFh2HxeRM5HWxHyY3oCQ4MvEHpV7ucA1iCWBZVrBgyC0tnKRbdaxPZcXbWlq4ghEayMOKAFTCf6VZllVhx0AEyUkBzeRGEMO2XRPseaS2XLJbFPXjGqmnAHAlhWhorVVKD4SqeIDn9lSmKW9MM7DRBtQ1u7H/vqs0Ttw+QH8/wwt9c4M4fO2ClB7s+q2KrrApHxpn8i8dN1RCErkOUOrqbtWdOU3jvfWaBANfn1NGDrHz1YYrf/e51nfONlJvpPSSEyAL/CjgG3AoMAP9WSvlvAsreBvxX4BVAE3gQ+GUp5bmN9+DmyiZo6SKlF55l8B3vMSOBKpO/TZvbLyMXE2P+EcsV2fLWH2DkVe9g7pmHmHr4b7j2jc/Sf/geEsVhqvNTVOauUp27SmN1CYSg78DdjL7qnc4Kx9ejDlqXJ5EnLzD/pZaQ460XnPRii9JaW6U2N0N9YZbG/ByNhfbPqJnBtCK5PNH+QaL9A2SO3kq0f4DY8AjRYp8Zfj3o2nj70mOfVfH2P9BORGXqAuZulzcQkN57gOJr38j0X/8p8Z/6P4gV+53+edsPUgmpaXo8iZ5IU1+eIz24pStgAYgksiA0atVlUtnhrjr9dHqYi1cewUC2cYTKsNgAxk5XiQQHuEjPoOA3urVtWdSYLB7VkESytHyeW255l/W8twdWCsuepTCCiETbXkUC6suzAET7Bl3gpLm8iJ7LuUP4C1M9pOezVhek05VmyQIt+aRjwKrarzRWa0R3Fs2hEGYI/zAXZ1tOfWWKfW8YtYx3/fk262KzLUIIDn/3dp79+Hnu+OB+B9wFLZqo2rXYK0D3HRnn1P/7IPWZJfTBos+uRQjzozB1bDeLn/gaRmkNkc74XZ8FJI8eZPHjf0tj6iqIYK+nl1xurnqoH/gQ8AzwSeDHgwoJIfYBXwWeBr4XSAD/DnhICHFMSjl7Xb24SbIJWrqJlJSef4r8bXdbrsv2lx9+lkUBLOpXbCRXYPTV72Torjez+MK3mH/6azQrayQHxkgMjJHbcdDc7h9Fi5qLonU1oO0VsHQDKzcaqFxH/Z4Zn3UAFKNWozp1mdrMVeoz09RnzV9rbdX82s0ViPb3E+1rA5No3wDR/n5nMbvrAied+go9fXK56tk7wl81kHhQutD3xrdQvTTJ1Ef/kIkf+ye+dZTCVEIOYFFu7HhhkNqiW30TxswgQGgasWSOenmph/MVZDNjtFo1ypV5MvF+P8PidX12+mCfjGwDlKAyHsDiBSqqamh59TLNZpV8n8eexcpfXbhEqm+L+1kTUF2aIZLKmusOKWPUWFogWii6gAxAa2nFAS12MwCt5TXQhOU95AcjjZUqsWzcvxBiyL1VWa5z5dkF3viLBwLzg0QTkiPvnODh//k8V5+aYfz2YQx05zhhdi22pLf1EckmWHn+Cn33Fn12LfZ2Ys8WtESMyvGzpO8+4nd9RhAZ7CM6NkL5ueOkjh72Hes7QCaBopRSCiEGCAEtmAClBrxDSrkCIIR4AjgN/DLwz16Ozt5o2QQtXSR98DDL3/w62dvuMi33FeM7lW0Ryuzge/lbaXoszsCx19B/9NXWh6L/pRo2+a0nBsh1exKFyToByQ3xAuoEqjzbstWiNnWVytWLVK9cpHblEvXZacBUkcSGRkhs207uzruJDQ0THRiy7AeC21YnGqdMWN9CQaEMLBNYNkRcc4+QLjBh0ykqqLDjrql9FoDQNYa/9/u59Jv/nZkHPsHIu763nd8JrKjp1n9ycJzy7CXXeXgNeFFVOEAiM0Bl1W/A63V7FlKSSBRJxPMsrpwnMzxg2q0EqYjsRmy2xXvygQMqfPtBLIutGpqZO04+v414IuuzZ5FISrPnmLjtHS4VEEBl9iqJofF2mvWrz8+ZAQKd45sh/FuLy0THh3zday2vEsmnEZofFWpC0lipEQ2xafGKjsHVp+eIxDTGDxc7rkvkZVsyg0m2vWKYFz49yfjtw267FeFeSNEXr0UX5A+MUjpxlb57D1lD7bdr0SIaiQPbqb5wlvQrjuByfVa+CpNHDlJ57gVSx24OaLmZ6iEpu7seCSEiwDuAP7IBi1V3UgjxFeC72QQt356SOXyMa0/9PrUrF0ls2eZMEKFsi/KSD9o3N5WvhyDqX5FOKp71qIO6ehIFSUj+jfDe6aVML4axtekpyudPU7ajyNZrRIp9JMYnyN52B4nxrcTHx9HiicBz72pzcp3ApKMNTdi5eTrhZlpogxSlUDsOkJXqYV1svBHJZhn5vh/iyu9/mOS2neSP3OE+fhi74pHkyFaWzz7rhF0P9ThS62QHqa76Y7UEtS+EoJDfyeLyOSaG72y36TLClW62RXWBVhgXpVH3v8sQlzZ4EW02xZAtpmefZeu217pUQ7Y9S7k0Q7O2RnZkl3PuNqCpzl0hObbVd20bc7OkDx1yqz2A1uISySO3WH20uyppLa+h58NtVhqrNeLZWGCe6vZsMzGXn5pn7HARPaqhDr4aq8U2wPXKgbdv40v/6Unu/We3IRIxH7PSKV5L7sAIs4+c62jXYq9DtPKFx1zj4B3D5NEDrHzuy7SWS8EHeznk+lQ8tuwK+HidlVLOBBVeT7tAEng2IO9Z4D4hREJKWb3O47zssglauki0r4/k7ltY/ubXLdBif+nhfEE5IAbaIAH3x6ma4DD8KnfvkdAJuxtg6QROgiZqr3SadLuU7SodyndVDVnbzdIKq2depHz6BOXzZzDKa0T7B0nt3E3u9veT3LGrvaaLcr4+EKJcJ9/x1glObohnVpAo5YNsTFwAxmJgzNXFlXLq/G0lJ7fvoO8Nb2Huc58is/eQo75w3cfeG1i67/Xk0ATNcon62jLxdMHpWyBgsSbnRHaQldnz3c9ZABoUCzs5c+6Btl1LgBGui21RY7fY++qEoIIVe18BKkEsy9TMM7RadUbG7vCphqSAlblzxFIFYtl+FwiRSKqzVygefaXr3Awkjfk5ogODvnNuLiyh9+WV7prn2FxeI1LIOPYs6m1k1Ju0Kg1iuc4eWarq6NLT8+y4yx07xhtczqmneBRpQrL3DSN88f+RnH/oKjvv2+6U6SVeS2H/CBf+6Ju0ag2IxQLtWgBSh3Yy/0efo7WwjFYouO1arJdmbOs4ej5H9czZjuf9ksl1Mi3Ki+dTAbn/Fvg319E6mHYvAAsBeQuYo1kEpq7zOC+7bIKWbiIg/4p7mP6LP2Hgre80l5i3P9Ac3h33F6pV1QdcVJE9TmIBk+D1qIN6sRtZtzfROibj0HMOOaY0DGpTl1k99QJrp05Qu3oJLZUivWc/A299F8kduxz7ALWd0DHxHi8Q3PnBSS/AxA80PW+19YIWp2Gl7SB1kPUvrMK22sipEgBcCq96HSvf+jqL3/gqA/fe775JA1gTL/MSLw6hRWNUZi4R31FwPQOu81XSE9lBqqtzSGnY0MoEHaoHkeK+XCzspNEss1qeIZca9quIADSJNIKAS4iaKAiwhLAsEsnFKw8zPn43kWjCFZ7fPr+V2XNkhxWWxfpvrC3RqlVIDI+7wEyrvIZRrRAZGKTtygtGpYKs1tD7Cr77prW8RqSQdg+tbc9SMo3Go7m2eqiTyqfVMJh6fpHXfuiWtjt0AGBR3Z3V/Vgywp43jnPiM5PsuW+rz67FHOJgu5b8vhGkYVA+M036wITrXFS7ltjWIbRsisqJs2TusSLf2je99cEodI3kkf1UT90k0HLj5N2A9yRupIFsJ2h1Y7iil1k2QUsPktp/AD2dYeWJb1F8zRuch8f7Qnd9paoiaKuKvCgm7LbpNjH2Clg6Taqd8tcLXMLaD5IuwKW5WmL19AnKZ16kcv4MrbVV4iNjpPYeYOAd30Viy1ZXgLaNAhUfSOkwdl3BTYfyHdM6icqu2Ps2o2IBEwfA2MWdfdlmXfCQDhK0WJS+N97P7Gc+QeGOe4hkcm62JQCoqP9C10gObqE8c5HCzsPu+9gDVmxJZgeRRpNaZZlEsgiaRAQY09pMRiJRIJnoZ3H5HLnUsEtFJA23vYx5XGWAg7Ub7TJBgMXDsswtnqJSWWB866vaqiHr/KQQSCkpzZxl/Nj97XO2fpXZK4hIjGhxwHVfNRZM1j860K/0CZoLywBEBgrebtJcWiWx1R9VV0NSK5nsvs202OogVS2kxmgpzVQwmpK+7f4Vpr1iAxVv/JYDb9/GX//cw5QXq8SLKZc6yGZdnH3FriWajZHa1k/pxFXSByaw1x2yB8ixa9EFyf3bqR4/R+ZVt1kD4fn0E5A8coDVrz/W9TxeEpFc35TfrntWSnn8uvvjl3nrvz8gr8/qwdJLcNyXXDZBSxeRgIjoZO+8m5Unv0XhNfciEG6bFnC9pH1si61KUrZ9E1KY3ADAcl1gJaDuRm1hwvJlq0V1+irlMy+ydvI41SuX0JMpUrv30n/f20jdso9ILu+u2wtQ2ShICSvv7XsoqLFUF40mrbU1jFXz11pdw1grm2HKWwbSMMAwkK0WQtfRsxn0Qg49n0XP59AyGYSmWV0QAeChrRJywIpUMXEwcLGbyt52B0tf/zvmvvIAI+96vxtMBwAVVUUEkBrbwdql08p502YgFbGZhlimiKZHWVu+aoKWgDIqCEOD/uIeZhdOsHXsHoTKsASxLerKz2HGuFa6C6S4wIvNssD5iw8yMnIr8UQOaamGECj2LNM0qiWyI7utejj1yzMXSQ6NI3STz7Dr1mdn0PN5tHgcKaRzj7UWFxHRCFo2rdyflnpoaZXI4W2Bp9NcMVd4jmXjPoYliHFZnTFBTnawN8PdINl61xDxTJQLD19j7zt3+uK1QNsY1/C8LHJ7h1k9M40mJC2FXfHGa0ns3xZs1yJwEHVi3+7w6/wSy800xO1RzgIVIMhS+TBw5h+iPQtsgpaeRALZ225j8UufpzZ1mcTohHvdoQC2xUumOF/D9ktZeA6gindSD5gcbwRguW5bjA2CF6Nep3JlksrkOSqT56levoCs14kNjZDee4CBt76L+MQ2Z8JeF1Cx94OAx3pBirecq6zEqNZozszSnFugOb9Ic2GR1sIizYUlmgtLyHJFqSfQMmm0dAoR0c1z0+1/Ddls0VopYSyvIBtNp050dIjEgb0kD+0lvmsHIhJxAxi7vxZ4cd1z1lYgcAGErjHw1ndz9SO/Q/6uV5Ec3hLItiDwMS9SQGbrXmafeNCJjOv3HjLPwWZEhKaTLm5hdeEi/SMHlUkI9zOgpA0PHeXyM49SqS6Sihfa6iObbbHrWMDFe7m80l7NGQewuG1azLGdWXiB1bVpDh35AQeM2AyLff5LUy+SyA0Szw347qny1CTJse3usQBqM9eIj4z67qnm7AKRwT5EAOprLq4S689YdsOeGC2lGnoySiTmDVYTLGvzVRLZqLWqs/Sphrysilc0IYnqMHq4j5kXF9n7Tn+ZTsa46W39XPvyi05bUrSZGXUdosTuceY/8gBGuYJIpBS7FkVFFIsSmxinfv5i1/P+ThMpZVMI8bfAe4QQvyKlLAEIIbYC9wK/flM7eB2yCVq6ifX8RvsHiG/dRunpJ0mMTbgRiudrNKiNII2Qy7gyRG4oYFH2u6lAutXvJV0aBo2VJWrTU9Rnpqz/a6YbspTER8dJbttJ4a5Xkti2A10JeR8EGILOO0j1EwQ+Aut2AynWf6tRo3HpKvXLV2lMz9K8NkPj2iytxSUAtFQSvb9IpK+IPtBH/JadRPoKaPksejaDlk2hpZJtENZBpJTIcpXW8gqtpRK1C5epPv8ipQcfRkQjJPbtJnFwL+nbj5ltuqyMFXsWCdIIBi7t0pDacwvpvQeY++wn2fLBn8HxbPOyLAH3eGp0O0KPsHb1LIXth5xynYxxM30TrC5cDH5WPHYtUghyuQmSiX6uzT3DzvHXWY+c50lSGBeMNjAJWtPLURsF2rTYLIvk3IUvMT5+N/FkUYmea5+fub04dYLC2P72vWT9S9miMj1J322v8j1f9ekp4lu2WP3CGajm3Dz6QD9elgWjSWtplWif8mzQNqytL4eH8PeKjkF5oUp6INhoV42KawMX1bZF3e7bkWX29Iqrbst3h+Ezxs1u7+PcxQVkywDNZmXacMu+VPHtI6Bp1C9cJbF/V9uuxRbr/RvbMXFzQIuU0N3zuHP96xAhxFuBNGDfGAeEEO+1tj8rpSwD/xp4DPi0EOI/0w4uNwf82nV14CbKJmjpJvbLSEL21ttYfPBLDNz/ThCa+wvUBiZBbEsQy2J/xeJ/wffEjrxEgKUrUAnom1GvU1uYoTE3S31uhsa8+V+fm0XWa4hIhNjQCLHhEXK33kF8ZMy0S0kkwtvudr7eOl4QotbvUsaVbxjULl2mPnmZ+uQl6pOXaVw1QVZkqJ/o6DDRrWOk7jpKdGSIyOggejoVOjbui9v9RSWkQGSSaJkk0fFhEgd2k3/b6zHWKlRPnKHy/EmWP/0llj/1efJvfxOZ17yizb44enYLpGgWs2IoaeDWngjof+s7ufgbv0rpxLPk9h8171vlfrbH0SYB7G0tEiE9tpPVy6cp7DgUzBiqgAfI9G9l5ty3HGNcVzh/5Vg2QyN0wcjwMa7NPMP28dehacLPtqgnpLU7YTMvdlmzT8L59wIWx2No9mlqtWW2bX9dG4jYgMZSDTXqZUpzFxg98iaXagsB1YUpjEad5Ph21/0rBdSnr5G94w7XcyaFpDm3QGSwaHVNOl1tLq2BhIgHtNjlGqVqR88hb8C5tbkq6f7uqiQv4+Ld79+R4+QXLqNjOMa49vFUDyIva5Pe3odstKhfWyI61ja38Brj6okosYkhaucukziwyyok2+DRBs7HDrH64COh5/9SiYI3N1z/OuW3AFVn+D7rB7ADuCClfFEI8XrgvwAfwx3G/x9kNFzYBC3rksyRY8z97aconz1Fevc+MzHoqzRAXQTudPXB62gjEgQ2rkPCQICv/RCwYtTr1K5doTp1yVzR+Mol6nMzICVaMkVsYJDowBCZg0eIDQxZYe/7EZrW1bamG6sCHrDiAzbSA0w8ZVRGRSnTWF6i+sIpqi+cpHriNEa5QmSgj9i2LaRfcRuxbVuIbRtDSymLA6K0h3SnB51br6J+gSn0nJZJkrrzMKk7DiPrTUpf+TpLn/4ipa9+ncJ73kbyyEE0oTI5CkjRPMBF4LJviQ0OUnjla5j7/N+Q2bMfLRJz3c8OeBHu+1cKyEzsYfGFx5Qxxh2/SO2RgPTAVlrNKuXVWdIZdzh/p746fhJGho5xfvLLlNaukE+Pu9kWrz2LOo7qcHhitLgAiyYsd2YzLsv5yQfZMnEP0XjOAVAqKJEC5i8/SySWJDeyy2XPArA2dYFovt8xbrbrNNdWaa2WiI6Mts/PqtOcnSe+f6dq6wtAa9GMQxLtyzhgRpXGSpVYrrcVngHW5mtkBjZuz2JL3/YspWsV6uUGItm7B1FiKIeWiLA2OUdhrN93TqphbnznGLWzV6wMT0PWvaFl03wnipRye4/lngDe9NL25uWVTdDSRdQvdS2TIXP4CEuPfI30nn2BtIr6dep7cXsAjZfl9kk3QOGbtAPKdijXK/tiNJuUnnuS5ce/TvXKJZCSaP8g8bEt5G6/m/jYFuJDw+jpjL897yl2mNg7nqOa3iNYCWVVBDQWF1h95DEqzzxP48o1tEyaxIFbKL7/3SQO7m6HU3cBFBk4Pu18ZXeDANPFGkvl5G0mQoCIR8i95bWk77md5U9/mbnf+RPiu7ZRfN+7iE2Mt1kXIwS4WAsKqvYtxXvfROmpx1n4+lcZeO2bXcyKc65eVREmaLn2yKepl1eIJXPuc3EmevOGFxJiqSLRRIbV+UnSmWEXGHCOpVmoSprgIpnsI5/bxtTM0+R2bjEZJENRePViz6KCFfAY4dqsi+DK1OM0W1Umtr7GbMxjgCstNmZ28gn6t98KeqQ9PsJsf+3aBVKj23z3YX1mCoQgOjjkul8kFtMy1Nduy5LmYgkRj6KnokDAukMrFQe0qOsOhYXwX5uvUhgzmUHbniXMRdobEVeVvp3mtV68UGLgQLyjB5EqQhOkt/VTnpynYIWwUSPj2vsgiO8aZ+mTDynpysdHoA7yZRSH1byO+puyIdkELT2Iw5ZIyN39Sq7+7m/TWlttx2zxPkMqOEH5YA5gYpzyXY7vyA0GLJ2McVtrqyw9/g2WvvUwslEnd9vd9L/p7cTHx9ETSV8fA5/DoHPrBlTU/nnzQsCIi6JHebmpadKg8sJJVh/6BpXnXiQyMkj6zltJ/sj7iE6Mtd2o7bqe4zrHtDcD0kLPuUcJ0iY5QMYeZAvA6Lk0fR94F9l772HpY5/h2n/6DYrveyfZe19tTugabuBi38eq540lejJJ/1vezuzffJzcoVuJKYv8OXhCuddtRiUxNE4knWP53PMMHrrHNVEH2bUITZAb3M3SzGmGt9/lB/UWDaSqiNBgfPQuXjz9SXZMvJ5YNIPoZs/iObQLrNj1hDtYXL1Z4fzkg2zb9noisVSbPVHKSGF6Da3OXWDrXd/dvh+FfXkka1fOMfiKNzmXzB6T6rUrRIeG0WJRJO17s7W0gqw3iA4PeO4vSXN+hWh/1meg69i0LJkrPActiugtC7A6V2P8cDG0bK+SzMeIpSOUpisMdFnCSHV7NoQkMZyjPuuPZKuqloSA2JZBmnNLyEYDdE/EX+fFenNmf2HYHwEbr78pG5NN0NJNPO6uie070FIp1l48Tu62u530joa4Sn01v5ePhY4qm27SBbAElUWYUWfnv/oFVp55DD2dofjqN5C77W70pFt33lXd0yHt5QQrrbU1Sl//JqsPPUpraYXUrYcY+qUPEb9lh7Wei91GkPqobV+g7qt9Fp575LrEASrtm8Mkecx96WzjsBHR0QEGf/aHWX3kCRb+6GM05xcpvOftaEJ3AxcNxzhXbcL+gs3edicrTzzG3Jc/y9j7fjiYbfHuaxr53UdZPvO0CVrwlBX+eoWx/Vx48pMYsmX10URCwgEr1jDaYADB8NARLlz8Chevfp3d295sMiCGtBhLBbiAC7w4EmjTAlLXrGPA6fOfRY8k2DJhgS9NOMyKClxmzn2LdN8W0v3jTsA5u9/10jzN1SXSW3f77uvalUvEx8ZdwA6gOTMLmtZmWmjfU835FaID+ZCbBRrLVWJ7+gLztICZsbxQI93fOXpuJzHZGfNGSvUnKM9XOpZXgYgtsWKK6tyaL5w/4FIPxYZNcNWcXSI6Ouhm7lSm+mbIJtNy02QTtPQizucloOuk9x9k9YXnyd1+dztPAS6+DwBvmvIC7wRcQm1YQsDIem1egsBMefIcU3/5ESKZHMPf/QEy+w8jIlpwPU9/uqV1AyoQDFacul5vIC+g8aiBZLPBylcfZvmBB9FSCTKveQWZV9+Jns8ok2kwUAkDKcK37z1v/8UMGp7Qd5ajEpLtgqK9a2uppE19KIUyr7qdSDHP7G/9Mc2FRfo/+AH0SCwYuNi2IKINXNAF/fe/nSv/6/+j+upLJEYnnLH1MizqPZy/5RjzzzxMvVwilsxiMzLu0xLO9cmP7qXVqFKanyTfv7M9SCogsgxu7ZD9QtfYtvX1nDr9N2wdfxWxSLqtJlKBC7iMcdsXwQ1WnGNYk+DZyS8yM/s8x279cYQeNQGNlS+FQOpm/1pGg9kLj7Pl1re52Bf7HEuXThFJ54j2qZOsWaZ29TK5V97juswIaEzPEhkoIiIRwHCdSmN+hehAlqAQ/pqQ1JYqJHr0HpJSsrZQI7NB0OI1rM0MJlibrVp9CY7V4gUsALG+FKXT7aV1NOFWJ9nnrxezENFpzi4QHR30NrMp36HS3QfzO11ck6a5nT54mMqZUxi1ajuP4Ek5dIJXJ2rR/qn7gfXWKV3VQvY+ksVHv8blP/wwmQNHmPjQz5M9dMwFWFz9Ul7Irj560rzn5gYH6vHbKgj116bopSvN2daC8iWrTz7FlX/3q6x88e8ofPf9jP0//4z82+9FL2TMu16T5k/g7AvlZ+cLTSJ081/Tpek0pitlRfunaYZjc+D8NAMR8Assq7TV7gvWr52Or5/t80kc3M3w//mPqV+4zMz/+B2aa6X2OYo2k2GPme0NY/+S27aT3neQuS991jfW6jVTVSep0W1E0zmWzz4TeO2893I0kSHTv5XF6Rfd94Bj8Cp896gUJtsSjaWZvPKQk9ZeD8iq1+UnBWYdXXNcmS9e/ToXLz/EoUPfT66w1byndOG+z6y6C1eOYxgt+rYf84+PgNLkCTLb95nqHOVZM2pVGvNzxMe3uBlDoDk9S2TYHdYf63RMpsVtK6Qye/XlCrFCb6ClXm7SrLbI9LdVLao9iy6MwLgtYZLuT7A2v/74ZLFimvpi2X0czz1i3usa0YECzdlFfyOesXq5Rcjr/23KxmQTtGxAknv2gKazdurFdYGLXsp2Vbn0+qCu44E26jWuffxPmfvipxl+9/cy9I7vMb/6rCfLN/EEnUcvQKUXsGJtu8GK9E2ULnbFBh8CahcmufZrv8n8Rz5K6vYjjP37XyF77ysRUc0PVgQBAMANXhzAoAAUF8hwgRF3XU030DQZ+vOWN38WqAkEMWaf1f76wIuQxLaMMPzPfwbZaDD9q79JfXbGDVxcQMUaW2Xc+978VsrnTrF2/rR7rJXr67qmmkZuz1GWzjwdfF8E/Aqj+1maOmG1Z7kSe+4fFKYDQNN19ux6OxevfJ3ZhRddwKUTeJFqnm10a5Wbmn2G0+ceYN++99I/cIt1PnZdpW9Wv6fPPUr/9mPosYTvXjSMJmuXTpPd2Y7dYpepXTO9YGJjY65nSApJY3qW6Iga1r89qzXmlgPVQxoS2TJorFSJF5OudFXUEP6VBRNgdGNawhZP9Ep6IEE5BLSEGQKDqR7ygpYgEUISGSqaoMX7/rjpYtGdG/1t6oc2LJvqoV5EAIplrRaNkrplL+WTJ8geOtYuE6D+cbXRKX+dsiHVkLes9T/1sT+mNjPFlh//JyTGtlh50l1WKR+23xWUqRNfULqvf9KdJjxlVHZFGix96gFWvvBVUrcfYeDHPkBkoM9VxrstlDRV7eOk20WdPCvN6oP6xSsEGPUGzcUSzfmSaVxZa1ih+qX53zInAz2XQi9kiBQy6PksWiaJvcKtoxWym5bmfefcMgLnPnQ8bAwQmEHRbM+bSDHH8K/8FHO//SdM/7ffYuRXfoZo/4CjKsKajIVhNWerjQTER0bJHr2NuS99htSP/zwI4aiEpD0MyoQshKUievpr1FaXzFWfBYFfk3adwvh+Lj//OSrlBZLJPjeosdU9lo2LczwEg4P72bHtXo6f/CuOHvxBirntptrLXigRkN5wrMpnvApY5pZOc+LUx9m9662MjB5z2BQvOLbPtVyaoTRzli23vd2lGrLLrl05i9Fqkt5+i++erk5dJjowgJZIIJV7DaB5bZbksf2+e0pK0xA3NpB1ouGqUl+pgsQJLhe07pAtOgbleXNxxXRf3AdMgvaDFkxUJd2f4OqzQYsId5ZYMYVRbdCqNiDeZn2Eqoa3JDpYoDm7pJRRno1N+Y6UTdDSRdTnQ7U/iY+Ps3b8eXPHa9dCe9fnKeSVGwBgukoHQFObucbaqRfY+pO/SNwDWELbeDnAipXuZWt8gEaYsWPm/vDPqJ48y+DP/SjJQ/tQGZquYMUBIVY+bqDiBSlGaY3quSlq565QPXuV+tQCzYUSxmrbKFHPJhGJGELTTGNfXTMj4kpJs1SmtbzmDIaI6EQG8yT3TZDav43k/m1ERvoRQrgDb0ozAJf9nWYCFUz7FPvjXGK6/2oSLRVj8Gd/hNnf+ANm/ufvM/xPf4aI5fEmNYkw7DW02vFb7OvQ96b7mfz1/0zphWfIHTjmjL1jJ6leSAHJ0W3ECoMsnnyMkdvvc18v59cO6Z8qjJHIDDB36Skm9r5ReW6E1R+zjrBAmLTPVsL2rffSaFR4+vhHOLzvHzFQ3INq7SE8/LFjlOvcO4Kl0iWee+HPmNjyaia2vrrNqASwLDZAuXbmEdL9E2QGtwawfoLl88+THt+Flkj67tvqpUniW7a60gCMRoPm/CLR8SGP2y8YyyVko0VsqM20qJ5AzcU1ABJ9qZ7WHSrNVknm7RD+1+++EktHaJSb666nRU2bF9lsITykj/fVoaXiNOaW/Y044Hbdh78hcr0qnk310MZlE7RsQCRmWP/G/HzXsr66nQDMTZClb36NxNYdxMcnfHk+exjP9nWDFWV7o4ClubTEzG//AUalysg/+xmiY8M+kNINsPjAisKoCCFprayx+q0TlJ85Q/XsVZqzy/D/s3feYZJc1d1+b3XunpzDzszuzuaco6RVFso5ASKDEWCDMTY44PDZxphgDJick5BQQijHlVZhc85p0u7kHDp3V31/VFd1pZ4Z7QqE8Zznqaerq27dququqvvW75x7rlvCX1+Jf1Y1oYX1eEoLcJfm4y7Ox1MaQvKMf2spaZnUSITUQJjU0Bjxjn6iR87Q++uXSA+O4SoKEZzfQGjVHPI2LEbyuA3KchZedOVF0XKVKHomXGSB8EqU3ftuur/0Xfq+8zMqPvlhNXmcprAIMopLRn1RP3CXllC0/kL6X3iS/LmLQHKb1Jbs76b+uUIIihesYeDgVipWXo6Uaej1MpZJSIKy6Svpbd1N7dxL1fLaqM96gySyakvmIlKEQLgkZjdei8vl5cDRX7Fw7u1Uli40XGuWC9EAK4oi0ztwjGMnHqWyYgkzG6/K9hAyuZgM150EyWSU3pZdTF9zm67IGK9LBYXRpsOUrb7EfK6Zvyd2ppWiSy41X+9CjWdBUfBUV+jHqh1usldtrD3lZveQBi7xwQjCJfAX+XB689HKaZ+jPVHyDAMlamAzWXeQ1dx+N8loFlrGy89iPCZtNAs11874JrwelEQyx8q38UF6vh6eP6I24H+bTUHLOZqntAw5GiEdjeD2B/Xlk4YS69vqH9oEpKNRRg7spuqmuw3LHdxChm00GxdYLOveMmAxyuoC4mfO0vudn+AuL6Hikx/ClZ9nhhQ9dmXysKKBSmp4jPD2o4xtO0zkcAuuvAB5q+ZQdusFBGZV42uowOV12U4p+yY8wZ/rFrhLQlASQlYqYWUjXL8GWVFIdA4QPnyGyOE2en74FL0/f56id6ym6MpVuArzneEFkek6TCZ1v0CRFJAFUshH+Z+/j+7/+Db9P3uA0g+8U+9qrKAmmtOVFJF9gS2+5DJGdm9ncNcblKy9KFtGK2Bo4IWA4gWr6d76NGNnT1FQO9t2ytl4E/X3L52+grOHniU8eJb84rpsnTioLVpPIjLH7ILGGVficnk5fOw3yLNvorpyhfNvn4GV7t6DtJx5hUi0j9qa1TTOuhYhmV1Cph5DBpWlt2UXLreP4oYlZljJzEf7zpIcGyJv1iL9XLUpNTpEamgQf/10W6xXsqsbKS+U6dFmhodU7yCugiDuoAdhWSeEQnwwircokOm2P/HDZKw3Rn5FYMJykzVPwGWClsmanmYg16iKxrJed25oeTvtPJWWKWg5d5uCljdrmeeDu1QNnEsO9OGuqf+DKyi6+/c8JNLwySMIl4u8+U6jl2s7mszBOM/bfg7hUMYILDaIISewRPYdpO+nvyawYjGl99yG8LizdRgDbR2ARWQCUq2wAjKRvScZfPwNokdacBUEKVg3n7LbLyS0sB7JLUyHrwGKObblzV8EwkCAkiJw15bgryml9IplpCJXMfjifgYe38HAw69ScOFiiq5bh6+hOgsv+mhzmR9PVjLqSRZc3GWFlH/y/XT/53cY+u1TFN9yHULWACLjJjJCDCAFg5RccgUDm5+jcOlqXL5AbrVFgDuvgPzp8xk8up2CabPtYGNxKfnzS8kvm05v227yi+syQbV2tUVLxKYuMoCLpDC9/mLcbj9HTj5KZ+8+QsFK8jJTKFiOcLnp6t5P69ktxOMj1FSvYumS9+ALFGdUFOO4Q8KskghVZZEVma6Tr1Mxez2S241sOCcNcEaaD+GvqMVbWGy7fqNnWhFeH56qKsNy9cdIdnTjqakwXD/owdfJniGTymJNIJcYCOMvCTJZG+2Jkl8x+RT+WhxLrpGfPQEXyVjaYcvcJisCJSO1KJMIThE+L3LizYPRlP3p2hS0nKO5/AGkYIjkQD+Bmvq3+3BMqWQma+HjhwnNmo9wuSYGfyfQsCzPCSy5yhiBxbYMs+JiWDay+VUGH36cwhuuouDqSzLdS8cHFiGN5wpSCO84ysAjrxBv7aZw0xIq7novwfnTTKBihRTt09hdMxe05MpZAZgCC+XMFw1kpJCX8uvXUHrNKkZ3naT/8R20/tV3yb9gERUfuBopP9OFO6O6yGTeZB3AxVtXTdm976b36z/BXVJMwaYL1DxhGgrI2m+SdRMVrtvI0NbXGHjtBcovv35CtaVk4Vranv45yXgUjzdgAxt9ypxz6fSVnD34DA1LrseFy1FtEQrZZHLYwWXatHUEA2UMDJ4kHO6ht/8I8fgwAC7JC0IwrWYtdXUb8fjys3BsABZ9XgMZV1Z1Geo6TiI6RPmcdYZAXvO5jzQdomD2ErOSkrlwYmda8NfXI1xSNggX1J5DnT1ml6bBkr3DpngW7TrSLDEYwVcS0Jc7pfA3ZcPtidGwwjkR3bmYJ+AmFUurgc+2hEXjmBZ0PgmlRfqjVVoUzisieCqa+JxtClrOw9yFhaRGhu0rDA/lnPZmrlmjmnIuyorTNgrEujooWrX+TVZmsLcSWIQdWLLbZUEkcvAwgw8/Tun77iS0boV5vROwZLoqG4FFMqgryY5een74BLFjbRRetpy6z96Bt7JQfdvN7N7Y9Vj9ntmtJWbAuMxo2npt+DgrvCiG7xqsaM80OQMjkhAUrp1L4dq5hI+30/GtJ2j51Leo+NA15K1fhBACWc7wi3aQSqbR18AFCCycQ8l7bmXgZw/hKi0mtGhhFkQMDbHeBnnclF55DT0P/ZqiVRvxFJaMq7bkzZiPyxdg8PhOKpZcZGvcM7So/2el9Utp2/s7BjoOUl67THVvSTiqLSIHuACUlM6ipHRW5keDVCpGONJDLDFESfFs3N7sSNympHCWOBajW0gRIKPQefwVSuqX4gkWmF1JmW3iI/3E+jqpufqddjgDom0tBGfPyf7hhnXJzi78Cyz3oHZt9gzhry/Tu9lbr6d4fwRfiXMKf6ceRJrSYoxhOdd4FiAT0AvpRBrJ93vKnuFyQfrNqTl/CJsKxH37bCpPy3mYkk5nslhaV/w+dmZfNG74xCSW+SqqiPd2vbnDeLPApNkEwJKznAFY0tEIA79+mPzLL7IDiwl4DApLDmBBkRl4eDNtn/k2QhLM/Pq91Nx7Db6qAvNbayYRnEtSUDsBqcucJrck48psq00eh2XWyZ2jPldmvy5JyRyDOuXPq2HmVz9E8dWr6Pz6I3R+5X7k4ZFs7hcdssjmc9GgTlLIu2AVBddcQv9P7ic50K8DnzogoGE+83vmLVmGt6qGvpefMUOI/ntnG3HhdlGyeD39B99AURwaREuj7vYFKZ+xhvZjLyOjmJQME1wYE8NZ1uuwIbSBD8Ht9VNQ3EBF5VIVWJzq1OsStuPSpqGuY4z0NlOz6FJbAK5W3/Dp/XgLS/FX1Jh+C0VAOpkg3nEW/4wZtutUSSVJ9fTjqa3S3ULG1izZM4i3qtjp1kASCrHeMYLlkxzlWJYZ7ojogyU69S6ShOwIO7nM2k3fyYXkZOlIAgB30GtbZz0qJZZA+M592IEp+9OzKWg5D1OSSSSP/cYbz2yEbY0ZVMah+PEgxanuHMs089fWEW8/k7vAOVhOlUVbnwNYrJK6KY4lY4MP/Q7h91N4/ZXZOvQGRNE/c7mEdGBJpej+5kMMPvY6VZ+4kfp/fje+2hJdXdGUFckADY5A4QAfxsnjSjtu53GlbWVtMJMDXjQg8Xglqt65icavfpBU7xDNn/oWo1v2IYSW5E52BpcMoBTeeAXeuhr6fvxrZCVl+g31317LNuwSlF55DaP7dxPv7bL3nLEoCyWL1pEY6We0/ZTjeuO1oAionreJyHAnwz0nsteDPlaQ4XqwXkcGWLGCxHjLrMBicgsZVJa0nKJ13++onL0Bf1GV+VgMn8OnD1Awe0m2TsNxxzpaQZbxNzSYFRog2ZXpOVRbab1N1MRx3UN4q4pMy41KXqwvjH8caNESy7mQGeuNIqcUimqdY2CMsDJZcNG6ljvFpqTHebtJRRIgCSS/Z8J9yNEYUvCPFFqU85im7JxtClrOw5REAuGZ+MabrFkBY1wJUsmWMX53KmOd17bx19QT7+lCTiTOT66c6AVrgvU53UKGZZFDRwlv30Ppe+9A8nks67PwInJ814BFjkTp+I9fED3cQsO/v5+iTYuRpGxMgFFZMcKK0EDCAVLGU15yTRNtkxtgzMpLaGYljV/+AKU3rqfrO4/R99OnEaQzsOIALhrIuQSlH7yTVHcvw088b2uQrfOBOXMIzGik76Wnc6ot2rw7v4iCmYvoP/S6BRyMk9DL+/JLKKtfRvuxzdl1BtjI1m0ImsV6rMIGK87LsAOLBiqWIQ26Tr1OKh6hdsmV5qy6hs/E2CDRrjYK5i51vO6jrc34amoRPkMAbOb6THZ0IeXn4SrI9nrLHJaanDCVxl9VZEssJ6GgKAqxvjECBmiRUHICx3CHmoG2qOat6z2U7QX05rZLjcVxB726UqOZ4gA6cjSBFMgBLecs+56/GV8uz3WasnOzKWh5s2a42GSD0qILB5O5GB1AY7ztTOsc5sUE9eTa3ldTB4qspxhX14txj+d8brZxu0lbyxl2JEeiqlvo0gvwzWzIHoi10TSoN1pjrQXdIhTSA8O0/+OPSA+OMv2LHyQws8o0BlA2TT96HIH2aQQVzW1kgxNhnlzjTB4pbS6fA2ZMAJMDXtxeQeUdFzD9n97F8OZ9dH39IUgnM+6iHOAigbuskJL3387Is5uJnjihD3NgHc9JcxOVXnUN4aMHiba3Oqotxka9dOlGRpoPEx8bsqstxinzf1fPv4SR3tOMDrRml0uY/mOrm8hJ2dBhxTA6s0kRclJYbKADifgY7UdeoHbxlbj8QcdjV4RguOkgnvxi/JV1jucWbW3CP32GGa4zluzoUlUWh/sg2T0IAjy5EsuFE6SjKfxlIRusGF0/2jZD7RHyK/x6HApk41nGU1bGi3nJuofe3EMhHUngsriGnGJyFUUgR+MIJ2iZavT/z9pUIO45mqIoKMkJlBYjVEwWSiYoM24358xyoRgAwVjWMC8UcPn8eEoriLWfIVA/I/c5jLdP6z4mY45k5VROnQZ/+wTC66HwxqvM5UygYo9jMfYSSnb20fGvP8VTXsi0v70bd0FAHcyQrDtIc78YYUVbry3D8F1rHLTliqKQ7B8j3DpA+Mwg6Wgik8JffTPW0uf7y0IEagrxVxXir8hDcrv0AFyXyDysMw2CrAg1EFcR6jygiEx+lsy6tAwuSaZgaQMzvvAeWv/l13T8xy+p/sxdSAE/MjLI2sBF2UETkQTBZQvIu2QDfT++n+p/+EvcoXz1N5Uy+V/UQwbAV99AaP4i+l58irr33KvDgND+f8MUrJuFr6icgSNbqV5ztQkesuXUjYUCweJqimrm035sM/kb3gdaThYJULTcv9qllukGDXpwrvWysQGyCXAcYlMkM7ycOfQs3mAhFXPWO4KZ7ho6tZ+C2Uvs+V4EyHKaWFsrBWvXmw9OqP9hoqMbT21VdpUO2wrJ7gE8pQWZXEB2CEn0jQIQqsjl7jH/JkPtYQprApMOvFVHa57gnVaDyxy9gHL1lktFErhDPr2MUzlNdZEj8dxKC7x98CIrk8ozM+72U3ZONgUtE5ipjcy+yJMaHQVFwRXKzxY4B8Ujp4qS40B0ILHAhG25w76dQCY0ax5DO1+naPUGhNudqUM4n8Dv2xyOW04kGNu2m7IPvxvJm3k7s7yxZt/Gs8t174NQkJMJur56P966CqZ99g5cfo8JWFS1JauuuIzrDACDtoxMwzIWp3fLSYYOtjPWOki4bZBUOIFwCYI1hXjy1DT+SGqKfOGSUNIy0Z4xoj1jICtqRtOKfPLqiylbU0/5uukEaotxoT7QJVSAGQ9eQEJlIoXQzEpm/uf7afnn+zj7Tz9h2j+8G6kgPwsuhkRkigxIUHz7NcRPNDHwywcp++j7kISkXgICPQEdafV7yZVXc+YbXyHSeppgfaOpJ5EwNOZCEpQs2UDvzhepXHUVkpAyileOSYGaBZdx5IX/ITLSRSi/Cn1MIYHeWwiy4KJny7UMEazIirkfOlmVJjufOW7J7BZSJAgPd9LTvJ25F38IXC5bfIw2JSMjRDpaqLzwOlOsirY+3tWOkojbg3AzluzoIrh8vv16RlVaPJkgXGvvIYBY7xjCLWUGS5z4Xh06M0bJNNWVNN7IzW+1OQFJciSKK88/qRQA6dEw3roqPRbkj6an8AQvopPafsrOyaagZTKmYHt1i7e3I9xuvOUV9te68S5Iw8WuP4cm61J6E+BietscR20p3XQFIwd2M7h1CyUXXmqCm3MBpGyTODlzDLA0WKKlDRQF/9xGO9TkgBSjyoJQGLj/BeRwjJp/fR8uv8cUcDtZYNFgRUml6N/ZQudzx+jZ2owr4KF8dR1VG6aTd/dyCqYXkjetEMnjcuyKqpmcShPtDjPaMUqkY4Thk320PLiPo998lWBtIRXrGihbO52ipdNweT3jwguSrKsuIOOvKmTmF99Ly7/eT9vf/4hpn78Hd0WpM7gAwuei9EN30f3v3yT8+nbyN65X1yjZsYmQBMjgraoib+ES+rc8R/Aes9qig05mKpq/iq7Xn2Sk5RBFM5bYWFgHicx/ll8+nYKKRs4efZE5a9+lKzj6wI5O4AK66qJdEiZVRV9hdyUZ41iMgyW2HniSwqo5FNbMNcWwmOdV15A7lE+gtsEONaiuIU9ZOa78fJtCI8eipPsH8dRV4WSJzgG81eacKsY8QdGuUQIVeaZsuNbrzQja/c1jzL+sWl83GdfQRKYpLEZodFJnZEUgo16viiKI94XxleY512n541K9QwRXzLcUOudDfsvsfONSpmJazt2moOXNWuZiS3S2462oQrhcaiBaDgDRXEPWi9QJWHJdyCb4AGdwsAIFdnVFBxlDPW5/iLLLrqH32cfIX7ICT2FRdqdv5s56sy6i8cyw39ipJrx1tUgBSyZPUwOkmJYZASbZ3sPw09up/Zs7cRcEDHEr9vgVI7C4DLEuEgqx7mFaH9hN1+YTpKNJKjfOYOU/X0XVumkmQMk2HPK40IJX4K3LI39aPlADqINAj7YO0bX1DN3bWml97BCefB/T71hO3Q2L8YR8yIogrUgmeEHOJC2TpUyUmoyvOMCMf72Hti8+yJl/+DF1//4h3OXFOrho6oGmjnjrKim69RoGH3wc3+xGvOUV6qCKitAbaq188SWXc+abXyV6ppnAtBm25HFaWZc/SNGc5fQf3krRzCW29cJwHepqy8LLOfby94kuvJJgqFwHlVzgom6evfAU0w1lWG5UOoTZFWScH+o6wXD3CRZd/WkdTqzxO9r88KkDFMxajJAks9KS2Ue0pQn/jEbHvz/Z0Q2Ap7bS3N054+ZMdg0Q3DjflvdHz9HSM0qwMk9fpiWUU7vqm0FEURT6m0cpm2EfWuHNmEvIyEo2JkaHFtebu/Hj/WEC08xApji4iWRZIdU7hLus2F6JIv4o4GXK/vA2FYh7LqZAvKNd7RWQ68ZxWm6VFCcBLNo6E9nnUmqMy61lnPaTmS9cvhZveSV9zz1uKzPuPiznYLNc20zGMg1D/FQzvtkz7Ots5Q3gIrQEZDK9P3ua4JKZ5K2enY0ZAEMuk/GBRaTTnHl4D1vf/0tGjnUx78/Wc+Wj72fN/7uCaRfV4/ZK5p5B4s1NXkNArselUDKzkHnvXMymb1zHtU++j9nvXE7rQ/vYcudPafrpVuTRMC5D8K4pWNcSpOsNuWn4h7vwTiuj/Qu/RA5Hs7+BHpCb7VGUd9kGfI0NDNz3MFrqfGtQLgK8NTWEFiym/xVzryOngNuSxesZO3OC2HBf7oBcstsWVMwir6Se9mMvmUEjx/VhUkEgo9wIXVlx2qfe9dkQx6IINV1/6/4nKJ+5hmBxtSOIadsno6OE20/bsuAqhrqiLU0EZs7MgrXhM9Heibu8FMlvj9dQMuNPaUqLFltltGj3KIHK/JxgbOzuPNoTIxFJUzrDWd14M2Z0LenQYukFNFG+lsRAGG9JtteTU68hRYH08BhKMoW7PAMtNjJ8m03Linsu05Sds01By0SWAzLiHe34qmsBQ3s5ycbZCgUmAMg1Wbc1KDhGSBk3+DfHOklIVFx9C6OH9hFpPmUoL+z7tNbjtNzxrI3HkS0x3m+lJJPEm1rxzTJAi+nHy3wYlBV9lVCI7DlB9GAzFe+7EiGEPQ+LMGS7xQ4s0dZedn3yN5z68Vbmf2wDF373NmZeP49AoVvvRaSBioSifgoFt5TGLaXxTHLSyluBJpDvZt47F3P1g3ez8KNraX/2GC/f+VNOffcV0gZ4seWN0btoK3h8gobP3Y6QBB1f+jWkkwgpA2R6tuAMvLig+N03E29qY2zn7mwjq7tQso13yaWXEzl1zNyTSPtPDPP+qnr8ZbX0H9nqCBqamqGVF5KgduHl9LbuIRYZyFwuWcjIunKEbZ9OgbJWWLHWZQSSnubtxMP91C65yqSyWIEEYPDoDjx5hQTrLW7LTF2Jvi7kaAT/jJkOx6GQPNuJZ5qW+0UFGZG5luWxMHIkjr+6yHQ/GAPBo12jBKsmByH9zaMIl6Cs3tzd2ajIuFD0yWm9k8npzPG4xMRBuwZL9IfxluSpjzALhCgZFxJAqmdIPbbSInO5P4I23/giea7TlJ2bTUHLZEwRphf5dDRKaqAfb3Wt4YmG+ZMsHOiQYAEUJ9Uj9zFky+RUXZzUj/H2Y9gmWNtAwbLV9Dz5MHI8bqjfAi6TNP0Rcx43Z7y5DSWdxj/HQWK3kWLmI/PwV2SZ/l88Q9E7VuOrq8hK8GByC5liVgxT+6N72Pbh+/Dm+9j083cy46ZFuFzmMtnuyhZIETIeA8hMNGnlfVIKj5TG50qZIMbnl5h9yzyuuv8ulv3VRfS80cwb7/8VAzuaVKVlAtXFW+Cl4R/vJtk1QPe3Hs0moAOERFZ1EeCpKqXw2ksYeugJ0tFwFgYyg0zqakvtNELzFprUFidwUANy1zN4dCdp2ZKO3daYq1Nh9TxCRdW0H99siCOxwAbZZTZgygEs+rwljgUBY0Nnadn7O6YtuRpvsGD8ulAYOLKD4kVr1UBr675RXUPu4hI8xcWO13ayvcvUc8i0rnsQAG9VsS1Hi2bRHjO0OOVo0VSY/qZRSqYFcXvUwQ+tPYgmMfKYY/CuU0yLZrkgJp1WSAxFcJfYgcu6h2TvIFJeEMnvkMDT6aVsyv5P2BS0TGQOhB89cQzh9elKiw0WJgMgxvnJKC3WMkwMLuMBkk3dAcqvuA45maTrkftQZNkGLk7nmEttyXXObwbU5GgU4fXa41lymeEwE2e6SHb2U3zDRh1OwDyOkO4CIquyCGSafvQ6J779Kgs/fTGrv3Qd+VXBDJhYXEAZSHEJBY+QbRAzWbXF7aC2eDK5XIwA4/XAzGtmccXPbqPuytns/tzjHP3aSyjxuKq6jAMugcp8Gj5/F2O7jjPw4OaMiyiTw0XrDZ3J31LwjouRAn6Gn3oho7IoemNvVDGKL7mMyIkjxPu6HXvPaFPh3BXIyTijrUfMKoh2GTioLTULLqO3eRfRsd7c4GJVXawTdnXFCCxauVQ6wclt91E8bRGV8y6wqSyKpb5IVwuJoT6KFq22B+pmzkHLz6KArR4FhUR7p9orRlNZDBCd7BrAVRjEZcgEq8dMoahB3D1jBKvyM+vMOVqsLqO+08OUzyqY1C0Ek4MYyCotuWJatOBbORODJSuCeH8YZAVfebbXpaw4Ky7J9j48tWWZBaheFeuhvV3uoome1ZOZpuycbApaJmFWGAgfOUxozjxcbo+5jOFTK2tTWXIpIxaFxlFGdNjG6h46J3DJfHcH8qi9+0NEmk/S9/wT5vMxqE1v2k3kBDRODxv9XIQ67/OhxOMTJ6+y+tuA6MHTeGrL8JYXYGgPdZWFzLwGLBrEdD1zmNbf7GLFF66l4boFeIwBuZq6YoAVXU2R0kgZ0NAgRgWZ9ISTT0rp5U0gYwEYbZnPL7H8L9Zywdevp3dbC1s/dB+jRztM7iIncMmbVcG0T99M/0NbGHt9v558DqEpLeokfC6Kbr+W0ZffINHdnU3nLzCpLb76Bvx1DQxue8WmmBgbcpfPT8HMRQwe320rZwOdzN9fPG0x+WUNNO15xP7/a+CCcRvhOJnUFW1bQxyLIqB13+PI6STT19yq9pJyVGqy5zV4fCehull4Coptl7Ii1EEWoy1NBGbMdLxc0/2DKLE4nrpqx/XJrgG8VSU5g3ATvaMgK+TV5E/YfVkSCj0nRqicU2BZrsW8nHvrmU7KuDySHtMyXup+zWLdIwD4KtTjsQ8emgWYxJkevNMqc4PK2xjfIhTlvKcpOzebgpYJzNQeAkoqReTYUULzF2XXOzTK47lTnLYZz9dpW5dj+3MGF8N6f3kV1be/l8FtWxh8/WX7b3C+4IL9HE3HYDDJ5wNFQUmm7CtNlVsWC4XowSaCSxpNyxwTxBmmWPsgJ775MnM/vIGq9Q24RdrmCpKEbIMVs9qSgZEMZEhCwSPSE05ZpUWdjO4iDVas8FK9qporfn4bpYsr2f7nD9H0kzeQlJQOLpqKpMW4CKFQvG4Ole+9jK5vPUb8ZBtCaNCGyU0UWDEf35wZDD7ypPo7Z5Zb1ZaiCzYxum8X6chYFliwqCkCiuatZLTlCMl41DnmhKy6AaraMn3VbYz2NdN3Zo9ZbcnUaVROck7YlRkjWA2cPUhP83Ya178Tty9gOg6n45RTSYZO7KNowSrbfrT55FAf6dERQzyLYvpMtHcivB7cFSW2nkMAia5BvNXFpuvWaJHOETUXUGXucYe0bRRZoeekHVreCpOTMpLnzTUhsa4RNQjX4xl3tHMwQIteQDi/AL0dJr8F05Sdk01By2TM0KhGm04jJxME58x3vomsgGBRWXIBi2k/uSYc4MVaT479OIIHlu0yZfNmzqXqpnfS+/zjjOzbZSgj7Meb6zyMy407s6ot48GdT/VlK/F47kJaWcNJyYkk0aOthJbMdIwH0HsOGbdNpzj0709TtLCKmXcs1WV2DVjUeQOwZJSVLMDkhpTxxiDSB1ccB2KssKJ/FzKBfA/r/vFiVv/LFbQ9coCD//YMIp00KS4auGhp/ytuWkvhpsV0fPVBlEgkOzK0wU0kJEHxndcTO3SMyLHjpobeqLYEFy7ClZfP0O6tzgG5mSlv+jwkr5/h0/tN/4UJDgzbKQICBeXULriMlv2Pk0yEHcEFDPBirFeyQA12YInHhmna9RA1Cy4lv3KmY/CuUWVRhGCk5TAosjpAIlh+F3WKtTThCuXhKS+3gw2QbO9UR3aW7I9frbuzLwMtmplytHQME8hkUgatm7Ni6+7sQmaoI0IymqZybsE5J5XLlUVXU1qMlithnGbR7lFdZdHM2t1ZUSAdT5Ls6sdTV6nCzB9ZIO6UvX32JwEtQohLhRA/FkIcE0KEhRDtQojHhBArz7tyizIRPnKIwIxG3P5sJL7VNZRLzXBabgQNY32OLiIneLFMNlUlx3crYFjLFi5aQflVN9H12P2MHT9iKHNu4GKdH0+J0kzKDEmvxBMTFwbdDRQ/eQYllSawYHpmebabs9ZjSN9H5oHf+ovtRDuGWfK3l+OSVPncrMSogKKpKyZlRVJBw4WsQ4oRXiQ5Tbw/TN/RPtre6KDnYC/h9hGIxXMCjg1gnODFMN9w6XQu/NYNDOzvYN8/PA6JeA5XkYLLpVDzkXcgBbz0/OBxQLa7iSQFb30VeResZujBx1HktF1tAYTbReH6Cxna/hpyWhst2qy4KEItVzRvBYNHtzs25Fb3kLasev6luL1B2g4+ZSprAhcLvNhHiBY2YJGROb3jAXx5pdQsvtJS1gJShroGj+2iYNYSJJ8vZ8+iSGsT/hkzbV2B1foVEmc7VdeQAQCNJRMG95D1WgWIdo0QrC4wLTOay/Aa33tiGG/QRUmtGhfmMkFN7psw1zpjd+Z0RmmxgkraAiHGxHKx7hF8lVloUUywku05lGzvA0XBY1JasEh5vI0Ac76uoSnyOlf7U0kudy9QCnwdOAKUA38FbBNCXKUoykvnVXvmxVKRZcJHDlN80aWAg2pibZSdrksHuNDLj2PG9fqsUJcrIrNQGI7VOI9lXY5thWIuW7LmQtKRMTp/81Oqb3sPefMXZcpkwAXFtu+cx6SJKtrBa8+qTEFhWaUgEJkcFvJYBMrNyaj0H8LhxS56pAVfYw2ukJ9cOqwx4230TD/Nv9rBsn++mmBFCMngFtJ6ZWjAYlRXNLBxkQUcFzL9zaMceKSZnpPDDHdEGO6IIKfUs5PcQp8H8AZdhEp9FNYEmbm+gsYLKiidVYQi1JY3LSQkRUFGkBZKJrW/hCwUJEUmJbuQhQIylM4u5uLv3MCrn3qS3X/zW1Z88Ubcfn/21USWMtlzXXgCLuo+fROn/+bH5G09SGj9UiShqGMeSeofqEhQePNVdPzdlxndup2CjRtUANEbW/XHL1i9hoEXn2Xs6H4KFq00XQN64jmgZOFaTu57lehgD4GiCrWctl67ZoQxdT9ILjczV93Gkc3fpWLGWvJL6tV7QRiuw0x5JzO5kwxA1X1qG6P9rSx+x6eRJJdjbI31eyo2xmjrMabf/JHsOmM51Lpjrc0UrN+ot7HWYN5keyf5l26wHasQoMRipIfCunvIuhuAaOcIwercOVqM1n1CDcKVTJlz7ffEpMYaslgqoeBy597GaVyhWPcIoZkV6m9jBBbLtvHWblxFebjyQyhpzKlNDM/OnK7j37edL3dMMcs5258KtHxcUZQe4wIhxDPAKeDvgHOHFu15qECstZX06Ah5CxZnXzW1MjkUC5tbKAewKIpCrLdDHRqgoBTJleOvEdntbe2/9uUtBJeyTe9ACImOB35CxdW3ULR2o2EbS3bS8cDFsNr4u46nJrsCQdylJSRa2vBOn5bdYIKHdXo0grtk8j78ruePkjejlOpNjUjIFmBRTJBidA8ZYUWk0zS/1smuX5+mZVsvNQuLmL62jEVXVFFUE6CwKkBhhQ9/vptkNE14IMFYfzwzJehpGuPAY2289N9HyK/w07ixgsYLKpm+oQpPwJMTXpAy3UslkBSZorp8Nn37Brb8xRPs/utHWfHFm3CHAiZwUSR10KG82ZWU33YBPT96mumLGxF5eQhFURt6Sb0QXIUhCq66iJGnXiRvzWoktyfzH2QUjTRIgQD5i5cyvHcnBYtXmpUUAwz4ymvwlVYx3LSfwIor9OVag67BiAYs2vf8ykaKaxdy5vAzLLjoI6Z1KuyMcxEZX8w1aIiHOXvoWaYtuhJfQZlNZdG3MwCHIgTDpw/gDoQI1c/KeY6psVGS/X0EtJGdLSYnE6R6+tX0/ZqbzWCJTjU3jb+mGGNPYmMsVrh9mNqLpuc+Z7IKTO/xIarnFU5QNpvS/82ASyqWxu13TVzQYNGOYYo3zDEtc1JbEs0deKfXmBt3B1CI7j30pvY/Zf/77U8CWqzAklk2JoQ4AtS9VfsJH9iHf/pMPPmFZoXEciPldMtYbkChQDI8wuCxXQwe2UF8KHMaQsJbUIKvqAJfUTn+0mqKZi9D8nhNpJITOLJFzhtcBIKyTVfhLiqm+/HfkBzso+zK6/XU5RpEWPdtq1evL/PWpIGMrtwo5mPMmLehjnhbO7asDuPAixJLIPm8mdgVTEG4xngWNVBVpuelY9TdsFh3A4ExUFfOQooDsCRG4xx6pIm9v2lirDfGwqtq+PB9G5m2uFiPITBK8pJI482DUJ6XinovoHb9VBuLeQycjXD8tX5OvNbD7/5hDy63xJp7Gll5dyPefJ8NXpDRlRYJoXZZrgyy6X+uZ8tfPKmCy5duwp0XzACOwCXJ+j4rb9/AyOtH6f3ZM1R+4tZsbIsCZMbmyb/iAkZfeI2xbTsouHBjFjI0tUVA/orVtP/w2yRHhvDmFel/kbFhFwIKG5cwfGo/VSuvsFBs9tpUDGqLtr5u0VUceParjPQ2UVA+0wwuWOox1qcdR8ZSqTjHX/spnkA+lXMuyEKTVt6qjBimoZPqiM64JHsHlkyZ2JlmhMeLt6YmszxzHpnPZEc3KAreablGd+5HCvlx5asDIRpjsrTrKdIxTKhWcw/JWdUPe9Bu17FhZn2owvbT5HL/vBlwScZSePxqEzJRFlyAVFoh3j1CIJM0T1VisuuNakrsdDuBxZlhB2wxLUJ/niaa2yZ1rG+5nW9m26neQ+dsfxLQ4mRCiEJgBZNQWYQQFaguJaM1QlZlUdIyY4cOUHLx5eo2VhAxwonxu3VfCiipNKMtRxk8sp2RlqN48gopmbeG4nmrQEgkhnqID/USH+wlPtDF4LGddO94hso176B47ipTAJ/1mW0EFev681FcipauwV1QROeDPyPe00X1bffgCgbt4GJpiKzHYwIX4wEazaDCeOtqCe/aaz8Jy3ZqsJ4KKXIsjrtoctlCR450Eu0coeqy7Nuf1S1kVFuMwDLUOsIjH3+VdEpm1R3TWXVrHXmlvkwCr7Rjt9JcWUblTJnKOh9ld9ey8e5a4jGFXY92sOWHp9j+i1OseWcjK981C19BFl40EEHKdDnNjNycXx5g07eu59W/eILdn3mU1V+/DbfPhywJ3U0kKwJ8ErWfuI6mz/2EggsX418yF5FW61MU9SKQAl7yL93AyPOvkL9xHUK41K7BBmXEN2MG7qJiRg7spnTjZVnlhGwZgMLZS+nZ8Ryx4T78GZXD6iIyqyjqbKC4mpK6pbQdfpaFmz6KQJi5NUebaYSKVDrB8dd/QjI+yoLLPoZwu/V1E6ksatr+U1Ssv9KwTXYfejxL8yn8DdMRLpc5MDljyfZOXCWFSHlBU/4gzRIdA/hqSjDG6BpBJDkaJzkSJ1SbO7BWH59oNM5wR5SquYWOSeXUsufejSUZNSstzoMlGnK0dI+gpGX8NUXmmBdDLIuigJxMk2jppPCGi7MqjEIWVjKmyDLx1jPnfPznYyLH8/3NbD9l52Z/EoG4OexbQAj490mU/RhwyDI9ZiwQb2kmPTZKaOES/eYxuYQwzCv2T20+HYvR9PD/0PbMzxFuLzOu/wjz7vl7qlZfiS+/BF9eEfnT5lC2aCO1F97EzOs/wvx7/p6Seavp2PIIJx/4CiMtR9RslJa6wT5vVYRyqkBYtsNeNm/GHBo+9ClSw0O0/eDrxHu6DQHBwrGOXMdj/K5vb30QKALvtFqSnd2QyOG7tkVMghxPIJyyaBpMU156XzpG0ZJaQpV5ph5DxmRexrdZDVg69vVy33tforwxn48/dikXf2QWBaVeNXhWSmUCc9VgXElkA2u1ZcbJaZlHpAn6YePdtfzV05u46i/nc/DxNr599bO89q1DpMdi5mDdTKCuW8p+5pX4uOib15EajXHkS88D2QR0AjLdoiF/QQ0l166h67tPQDyWDcoVip5wLu+yjchjYcK79+l5W/QJEJIgf/kqRvfvQhu3yMl94i2rwltUzvDpA7n/RgeFBKBu0ZWM9jUz3HvKVMZazhZHIiAtpzjxxs+JjfUz/5I/wxMqtKssOeoDGDl9AHcwn2DtDNP5WLeNNp8i0DjLpjqq+1KTynlqLflZMjeREJA0jDlkUlky87GuIQDya/OZyHqODSMkqJ5jyJx7HpBitWQshSdgfu9Vg24lPfjWaJH2YYRLwlNeqC+zuoYAEmd7UJIpvDNrM8sddq5A6mwXSmzinoVT9qdlf3TQIoS4WAihTHJalqOOfwXeBfyloii7J7HbbwOLLNONgN6wjh3YR2BGI55Qfu4A3FyNfqYxlhNxWn73A1KxCPPu+XsarryH/Lo5qqxvrMsyuTx+qla/g3nv+ltCVTNoeerHNP3220R6ztjgwAgnVjXICaTGBReHst6Scuo/+Em8ZRWc+cF/M3bssKFu9Yk/GXAZV0w2HI+3bhrIMon2LjPwGOu3Lo4lkfxex4HYwJDDIi3T/fJxqi+b61jOqLJo20lC4cRzbTz4Z1tYeFUtd/73agKhbHp0FWwUHVTM4JLCI1K4kE2TttwjUibA0aaAV2HDnTX89VMXcM1nF3D4qTP85I6X6D7Yq/c40noZWcElVOxjw39eRc+2Ftru26FnzjX2KBJCofqeixEC+n79IpI+NhG6a8OVHyDvorWMPLcZRZHNbo9MuYIVq0j0dhPvPGMDDw0GhBAUzlqqdn22Qg0YthP6dw0+/IWVlDWs5PSOBwgPdZi2M4GKpa60kubk1l8SGepk/iUfxZdXYirj1BPJ7hraR8HsJVm3qAO4pMZGSXR3EWiclfOYkmc78Rp7Dlks0TWAtyZ7fEaVRQiFSPswnjwv3gK/qYzLUpcLme7jw5TNyMeTI+7kzQJM2qCkpJFIRlO4/JMX6yMdw/gqCxAuydRTSAGD0iKIn+7AVVKAuzDf/pw1qC3RYydxlToE6P8h7HwGS5waNPG87I8OWoDjwIcnOdkcmkKIfwL+Afh7RVH+ZzI7VBSlR1GUw8YJOK0XSKYYPbifvMXLTDeNVW0ZT81IRcI0P/pdUuERZt50L55QYbb7mwU0ck3eQAHTNt3G3Dv/GrcvyKmHvk7v3s1m1QUHCMkFLmDatw1ccC7r8vmpvfP9FK29kI5f/5iep3+LnEgaygkzNFnr0b7b9m9XsFzBEO7yMuKnmw3bmmViqympNLgmvrTHTvaQHIpStakxG79icA05qSzdh/t58m+3s+lj87jm7xfj8ahqjKauGNUTDVS0rtCTTTSX7T5trtPvVVh3azWffPQCZqwu4efvf409vzqBm9S44FI6q5iVf38pJ368naE9LSpgZbpla92g3UEPNR+7hqGntxNv6jC8/WfVlvwrLyTZ3Uf02AlTg679He7SUvz10xk5uMfWHdjYuBfMWky09yzJsWHzeqvC4sCcM1feSl5ZA0de+R6RkW479GjbGepqP/w8o33NzL/kz/AXlJl6EWnlrUqP0TWUio0Rbm+icPZSR5eQtq9o62l1eI/aaXYoEaBgGCjRsFyA3l0/0dmPr7rEUWUBteEP1hbq312mcrKpu3P38SHHpHLnkwXXaMlICk9wYmjR3D/R9iECNUVmsdVBaYmdPIuvcVpmofFCQv8UiiB27CS+6fVvwZm8eRMKCPk8pilmOWf7o4MWRVE6FUX54SSnAeO2GWD5Z+CfFUX5wltzQDB2+CBKKkn+ouX2XkK2NwHLeiAxOkjTQ/+DnEzQeMsn8IaKHGHFVo91ytQbKKpg+jveR90ld9K14xnanv4pcixiKmtVed4UuDgBhrUsEuWXXEPtuz7M6KG9nPnRN0j09Tq7i6zgYn6W59ynVi6wcB6RA0cQVljJfFcs5+cqCpEeHlOLWB4OxgYg3j+KK+jFW2Qe/dbJJKGgpNI8+y+7mXflNC74wCzckqIDiwYpRlgxgopXpPCKFC5hVlask1bODDFmd1NeSHDnFxZyy78sYvM3jvC7v9mBHM66i5zApeHS6TTetogD//4cqcFRPYeLIJt4rnBlI3mr59B33/OOaou7pIDg8oWMvbrN3NDrqgvkLVrC2LFD6C4i/U9GLxOoqMXlCzDaedrRtWPcxgQYAoTHw+x17yK/bAZHX/0h8eiwqW6r+hIZ6qTj2Gamr7qFQKEh5wdavQaVxbA/o422HUfy+QnWTnfch7ZNtK2ZQMN0hNugbBjgJT00ghyJZsccspgcjardnTNKi5bRWJsHtfdNNgh3/Javv2mU8lkTu5HO1eIjSfwF3pyBu7IiTAG6kTMD+KeVGNarn6rqos1D7HgbvjkN9ngWY93RGLGTp/E3Og+V8Hu3KaXlbbM/Omg5VxNCfB4VWP5NUZR/ecsqVmB4x1byl6zAlUnzbW1khWXeCA/x/m6afvNN3IEQjbd8QldYcrljjPVZJyuUlM5ZxexbPklsoIsTD36NWO9ZZ2Ujx/Y5wcW6veG7FULyGucx/c8+gysYou17/8XooX2G32ECcHG6bx3UluCSRcRPNZEeC5uOx9EUgauogNTAaHaRJehPs8RABF9JNhW6MZ7FmmXUhczOnxwl3BvlHZ9Th3DQXEJWYNHiXlzIGQBJIWGIaxEKXpG2TS6TEpOFGCu8aNPam6q59771dB0b4mfv3Ez/qWFHcNFyzCz7+BoCFXkc/MKzIGcT2WmKiyTJVL3rYiIHmogeaTGrLRqUbFpH9MARksODGF1D2hRasIjU4ACJnk6TEmNSNiSJUG0j4fZTNsXG/Fc6SC2AkFzMXv9uvIFCjr36Q5LJqP0SEhAb6+f0zt9QVD2fkrqlzseCBZSs8wJGWo+S3zAXIbmcy2XqiLWogyTaymS+Jzs6we3CXVmmLzOOPp7UujvXFjuet5RxD4VqCsYFFm3dcEeE4tpgznKTtXQmRsVqsZEE/kJvpowaw6J9WuNZZASRs4ME6kpM622ZcEcjJDt68c9pyL6QQBZcFFVliR49gZBceBveHqVlyt4++5OAFiHEXwH/D3gGeFIIsc44nU/dyYF+Ys2nKVy1zjkmBMO8ZX2sp52mB79JoGIaM274CC5vQAcWK4iY4MShTnAGmGBJNXNu/RSB8mmcfPgbDBzZZj8WLMdt+e4ELrZ1lvXGfbhD+Ux750co3nAJnQ/9gp4nH0FOpuxxLjnAxaa2WORg34wZSIEA0YNHzbCi12F+QLpLCkgPjOT8TzVLDozhLZncQ32gaYRtPzjKFZ9dQn6JV4WVTAyLFVg0ZcUlZCRkHVKM8SuSYVttMisuKshosJILXurnhfiL36yjcnY+P3v3y5zd2WUHl0z2XK9XsPZfLmP4WA+t9+9UzyET26JlCw7NLKfggoX0P/AiIuMuExJq3hZJwTd/Bu6KUsZe3+EYkOsuLcVbVc3Y0YN2F5H2KSA0bRZj7aftP7RDY29drwiQ3B7mXfhBFEXm+Os/JS0nUYTaC2u4+wTHX/sJ+576TxRFYfqqWxCSvdHVB1QE27FqriE5nWK0+Qj5MxfmjJlBqAH28a4O/NNnmi9Jw/kkz3biqalEuF1YeUwIhWRnH66CIO68AJIBZoyuokjHCHnT7IMfWnsSpeMpIoMJCqrVFy3tWjVuc66mgUZ0OIGvYPyAd628nEgR6xzGP61UX26MY9Gm2ImzCI8bb0MmWNmmrqpT9OAR/PNmZ3uA/aHN+nw+l2nKzsn+JKAFuD7z+Q5gq8N0zjZ2aD++mmn4azJEb2nMrQ28Ni+nEpx5+hfk1c6i4R3vRXJ5TcCi1eWkophgCEz7tQIMihqoO/3ye6hedx1nX3mI9pcfgnQ6N4TkAJfx3Ejjqi4KCCFRdtGV1L37o4we3s+ZH3+TRH+/Lc5lQnDBvl6SXAQWzSdy4FDWReTgV9BkZldxPqnBUZMC6zQmSrw/jK9UVVqsD31r7ovdvzhGzZISFl9TY1rvQrEBiwYrHk1BQYOStF7eSWnRFRfMwbsTwUt+gcQ9/72E1bfX8+BfbKdrf49eRht5WgOXorp8Vn72Ik79ZDvDB8/qbiJjUG7lXRcRPXaG6IHTNrVFSIK8i9YSfn2Hmtpfdw1pnxCav4ix45mkXw7KBUBoWiOJ4T7i4WHt7zMBik0JcVBi3L4g8y76MPGxfo6//jO6Tr7OgWe/ytEtP0JIbhZcei+LrvoU3mChvZ5c7iCra6j1KEo6RX7jQn29UzxL7GwzSBK++uybv/kc1J5DXkPPIWG5sRKGnkOaGXuxyYkU0Z5RQjXmHC3WsgCj3ar6VFgdPOcxhyYyo9LiZFp3Z1DdWsiK7h4yBuEav8dOnME7s1aFERNFZutVZJno4WMEFy5822JD1L/ufFL5vz3H/adgfxLQoijKxYqiiFzT+dQdPnqIwtUbJlZZMH92v/406USM2kvuQAiXGVgmqmu8ZZZJV18QVCy+kFnX38vQyb20PvcLlGQiJ4TY1BhLGadjtKkuDuWDM2Yz/c/+Csnro+17XyXa0mSKc5nQVWQoa9xPcPEiYkdOICcSlt9GfaAZAcVVXJCBFsUx0E97kCYGw3iL7UqL9S00NpLg2DNtrLx7FkIIXWXRYMXkEjKoKzZYMagpEs6xLcbldrXFDC9qvIwaT+OVZK7/7GyWXl/L/R/fRt+xfnN3aCmt55mpv3wmDdfM49AXn0dOJJGEoneFdkkKwfoSii5eQv/9WbXFCCahjStJj0WIHDpihpHMlLdwEfHOdpJDA46uFAT4y6px+YOE209NGNfiZFoZX6iYeRd9iNHeJlr2PUZx7UKWX/u3zNn4HvIrMuP/5KrHCisOgDV0ci/5Mxfi8vlt9RiPM9rajL+2Dsnjyf5WWhldaenKZMK1HocKhImOfny1JY75W0BNgY8CodrCCXO0jHRFEBIUlntM69+qIFxFUYgPJ/AW+GyuI6fuzmNnBnEFPHhK80wKi/qJ/hk73opvdn02zsXw0qM+GwTx5jbkcITggvn/5xSLCXrXnpdX4X+L/UlAy+/VFChYuNzekJNbZRk5eYD+fVuou/Qu3L6gDVhyqStikpMTKGnL86pmMuumTxDpbuX0Y98hHRl1hBAnl5ATxFjLOrmwrN/doQLq3v1R8hev5OzPv2uLczHVbzCjm8i0bwX88+aASyKy5+C4/xUKeCpLIJUm2T2kLs7BrXIijeQdX16WhEzXnm6EEMy9pEpVWMhmztUaAX0MIguwGGFFQqanLcrBN0Z47bf9PPq9Xn7875185ZNt/OfH2/jtD3ppPjCKlEqZtrEDS1p3QRkVF68kc/Pn5zHv4kru/9hWhtvHsr2KLO6iJZ9YSzqW5MxDu3EL2ZwlWChU3HUhsaZOYoea1UZVyk6u/CDBlYsJb91lUh60F2JPTS3uwiLCJ9WBNp3cREgSweoZhLtaTBeAPRDXDB02lQQIFlWz+tYvsObWL1C/5Bp8oWL7pWFRWaxdqq2uIUB1DbUcpXD2UtMxGuFGKxtra8bfMN0Z0gAllSLZ1YOnNtNzKAOAxisz0dFvUlp0lSXzGe0YRvJIhComdmmOdEfJK/OPOzbQuZjW7Tk2miadlAkUZcYH03Oz2Ed9VhRBuKWfQH2pPoikMQhX/QQlmSJ+6iz+uQ25XwoViO47iK+hHle+oUv0H9re/kDcvwPWW6b/E2MaTEHLBJa/eAWS12dvzMGxwY/3d3P2uV9TueZK8hvmOQKLVU3J6SJymsYpry0PFFcx55ZPoqTTnHzo68T7DTlOxoEnRzeSU1nsqouTu6jy6lsovfgqOh/6BQOvqV2zbeBi3c50jFm1xeX1EVq1krFXt5pdRPq22RbEXVmGFAoQO3k2pwwtKwJPQYDESEz97vA6rnUnHWgZoXRGPi6P+XYxqiwuMuqLA/Ywn3EAAH7rSURBVLBIyIwNJPjGZ1r5s0tP8s/va+EnX+rm1SeH6WyOEQoJ8gsEzz84yKdvaeaO5Uf5x3ua+M03umg/Hja4m7LA4tIDe83BuT6XzO3/uoCqOQU8+LHXSQ5HDKNOZz6lNIF8Dws+vIamX+1SexNJskltCVQXUrB+PoOPv47ODZqCIEFo3XKih46RDof1BlhviCVBcM48xk4dcwx41WGjsp5ozxlzQ5/DbG4cS51CCCSXx7Z8MmqNbqZjFUS6WpBTCfIa5owbzyLLaWLtZ/A1TM8+HvT16m+S7O4BWXbsOSQEKIqSUVpKHbs7C6EQ7RkjUJlvi89xytES7ouTX+7n92WjPREA8ipzA5Txngo39RGcXu4YhJvt6tyOkkrjmzPdQpLqh1AEiqwQ3nuA4LKl2efF22EKavbpc53OH7ZOKoqyzTKNnXet/wtsClomsIIlKx2hw6nBT8djtD3+E0K1jVSsusLWKDspGE7QMCmVJccyUJd5goXMuvFj+EurOfnINxg7c9y2rdO8tn2u+sd1FxmXKSAQlG64jOqb303/S0/R89QjKKn0hOBi/H2Mn/kXrCfe3EriTIepnNHnrWRaN9/sOmInz2aWGddlPz2FAZLD5p4nTjbQPErJjIKsWygDJJoZ3ULq9yywCCXNy4/087ErT9J0OMaX72/gyeNzeHDbTL73eD1f+FEtn/mPSv76i5X89PnpPLxzJn/3X1U0zvOy7cVRPnHtab7y5630NEcMrqcssLh0F1G2d1LAp3DPfy/B7ZV45FPbkGPJbGBuJr7FLaVpvG42odpCTv1oq567xai2lN28nvDeUyTbuxGSnE23LxT8CxuR8oKE9+zPQodhCs6dR7T5JHIqaVYeDPOBymnE+jqQ04Zsxw5KiqM5wJA2b1drsKssTgBi2f9o6zGCVQ24/EF9nVP9id5OlEQCf12D+XgM9Sbbu5Dy83AV5uvrjMG48ugYciSOr1YNVHXqHRTtGiFQkc1uq/VwU8ubXZrh/hihUp+tjvMxI4SMdUeR3BKBYjsYWXsPyQjCzSq0ANnAW+O8IogeacHbUI0UzPzexpeRzDMg0XKG9OAQoaVL3ta4kPOLZ8nk55qyc7IpaJnAXP6gIxhYwUGRFdqf/TWKLFN/xbsQSOgBV5No/CertDgBTC64cLl9zLjifZTOW0vTEz9g8Mh2XfmxAcZEcJJjfyZ3EQ7Hg+pem/buexk9uIeOB36CHI+PCy4mN5HhgeWrrsY3cwajWxzUFjD5wH2zphE7cdYGLMYB2twFAZIjUccgXaMNNI9QNsM+lpEaVJtN6KWpLBqwdLVE+ef3NPHtf+jglg+W8O3HG1ixxofXlVVprL2GysvgoneE+MTny/jB43X89wN1DPamuPeqU/zP584w1Bk1xbwYP43gkl8g8YHvrmC4PcIz/7QTN+p6tx7gK+Nxw9K/WM/Zp48QPt1li23Jn1tFcEE9Q4+/YRrUTwgQbheh1csI79hjasy1vyPYOFsNmGw7bYMVbQpU1KHIaaKD3TYlYzylxOnvsikhkzTjfqxKymjbMfKmz3NUgkzxLGdacRcV4y4ssAOXQA/C9UyrssGK9psmOvoBdXRnwyEAhhT+PaMEq/JNy4xmTCwX7o+TV3bu0JIeR8NIIzHaFSGvIoAiXLbuzppp8CInUkTODhKcUT5uPEv0SDP++TOyy63PWyCy9wC+GdNxFxWZlv8vtkYhxELLZB/h0m7fEkKkhBAjQohnhRAX/N6P9I/EpqBlAnNSFpwgoW/nS4y2Hmf6te83dW0eD1DeaqXFab0kJGrX38C0DTdx5uXf0LX9GZDlnMdjAxfs8+OeF87rg/UzafjAJ0n0dHH2Z99BTiQcwUXfn/H3N/wP+ResJ7xzD3IkZn5g6QCjtpq+WfXEWzpJx1P6m5xRllbQlJaYXoUTvCiKwmCz6h4az4wqC8CTP+nmU9ecQADfeWom7/p4CX6v3aXkJdujSO9ZRDqzXGbFGg9ff6CGL/y4luajMT5y2Sl+9K/tREeSSMh4MxBiBBcNXkqqfLz32ys5sbmLw79t1uNbNDeRJGRqVlVTtXE6x7/9KhJpu9py0zpGthwgPTSSHQE64/IIrl9OoqmV1MCAvkz7w4TfT6B+BuGTR9Xf0aj2Zz5doTw8+cWqi8j4m9sAQZiUEt0mocTkAhmn2JjscQqS4RFifR3kNRiGeLDsX49nOdOKv77BdtEa602e6VDT92tFLNCR7OzHXVaA5PNg9P5o5SShEOseI1CZN6kcLeG+GHllb517KG2JVRnpjo7vGjKUH20dBFkhMKMss05dbotnOdGmQot2L4N+j2ddQ/sJaiqLsdwf2t66mJbHsI9797Fx9jwMfB34M+AS4JNAHfCyEOKq39fp/jHZFLRMZJYG2KmhjnS00v3GU9Rddif+kmqMcSyOSoLsXM9bobTkgpuyhRuZcdX76d3/Cmde/LW5Z9E420+mbqOqMp7q4i2toP4Df0FqdISu396PkpZt4OL8O2TVltDSJQivh7Htuyz/kVFxEXhnToN0mnhThymuxRiU6y4IkhhUffPmN0T1tkgrgkhflEQ4ZYIWc36V7AlrKsu+V4b46X90cu+/VPMfv6ijfqbb1C1aAxWtS3JWcbF/d6HgEzIbNvn43u+m8Xdfq2LXy2N85uZT9LdFdaXFCC7GmJf6+SGu/NQcnvvSQcLtIxk1RXUTafCy5ONrGTzQSf8bp01qiySgcM1sPBWFDD+7Xf8zhaR+eqfX4C4vZWz3PpOCYnQRhU+OH9cSqJhGtKfNvK1m47RH48asWJdNxjVk2Wb0zHFc/hCByjrneBbDecTOtOCrb3CuT4CCQuJsB966Gsu+Ff2GSXT04zOMOeTUeyjaPUqwMmRb7mTn6h4ywoasSLbEctp9MtYTJVRhzyRt7TmkKIJwUx+e4iCeopBjPIuiiGw8y9zphvvd4hpqbtNdQxifG2+HvXXQciP2ce++nXu3yl5FUT6lKMpvFUV5VVGUnwAbgE7gS7/fk/7jsClomYQZG2UNOrQbSU4maX/+formLKdo9nJzY24oNx70ZL9Pwg867vbO89r3woaFzLrxY4y1n+LUI/9DcqTfEVxyqi4TwMtkVBd3qIDaOz9I5NQxep58xDE41+omMq4XLjf5my5k5NnNKPGUDWo0WdkVCuBrnEZ49wnTM8Kouvhri0mNxoj1R/T/2qq2pBOqcmIdzdZoWgCuZs/+qpdNNxZx1R3FuCVzHhdzN2mjuiLrn9q8EWw0eLnsmgDff7yOmnoPf31HE61Ho5h7FBmDc9XPC+6pp2Z+Ic/9+16Tm0iDl+KGAmbctICTP9qKJKfM6f3dCqXXr2X4+d2QSugBuWpPIkFw1RIiew7oYKArGAKCs+eS7O8lOTxgbswN84GKOqK97fYfdQKlxKmsdX6ibW3gYzi2cEcTodqZCEkylbfCSzoaIdnfh7+uISv8WRSX9PAI8mgYT311drlJTYFEez/eHEG4EgpKWibWN0aw0jBiM9lcQlaLDiUJFk2c+O1cbbBllMJp+ZZRnQ3AY4CX4aOd5M2pMoMK2XsRIHLwNN4ZNUjBoDkLrvapwNiOPfgaZ+IpLDI9L/6X22nruHeKovS8mQoURRkCngCWCCEmHpPkf7lNQcsEZlURrKpDz9ZnScci1Fx4cwZolJwNupNioZa3A0lupcVePpca4gQ1wbI65tz6l0geHyce/BpjbcfHrWuykJRzvWaGdf7KWmrv/jAjB3bR9/wTJnCx/WbY91W46UKUZJLwzr2WB5uh5VQguGYh4e2HVW+Y4QEpK+p3f0M5ktfN8PGejP/d/NAFcAXVB38inJzwWpGETGQ4wf7XxrjkhkJLYG4WWAATsGTdNdnJY4AaL7IJXvLz4As/rGbZuiCfu7uZozvHMkG5sklx0VxAPpfMrf88n5ad/Zx4pi2bul8oeu6WBe9dRqR9mJ5XTuhqi5Ylt+TSxSiJFOEdRy0BuRBcvYRkWzvJvj69Mdb+Rk9VFa5QHpHmkzZY0eYDldOI9XeSltNm6DHaRN8tdYIDkDiVN5gVRiKdLQRrZjgqQMZjjHeeAUnCW1PjvF8BybMd4HbhqSo33RQCzAMlZoJwncAl3h9GSSsEKrWYFnPgrVHxUxSF2GgSf745R8v5muYiSiYUeo4NUrHQPsKyUxDu6JFO8ubVZo7NMLqz/iIB0YOnCSyeZXsJAVTXUCJFZM9e8lavsj973g47n55D2vTWmvaj/+/HuAlsClomMgOwWFWUSGcrfbs3U3vJ7bh9IZwCb3N9agDi1OiPNzkBzERKiXXe689n1rV/RsnsVTQ98X26djxryqCbC7AmgqRx12P+Hpw2g9rb38/Q9i0MvPpizrrMk/p2JXl95K1fw+jLr2W7D1rUFkURBFcvJNk1QKK12zGuRbhdhGZVMHKsS12GfdwUb1B98EfD6UldLtufGyaYL7F0fcihl5EZWPRxjnCejDBjhBePSBPyyvzT18u4/KZ8Pv/eVna9OGJyFalDB2S7Q1c3hrj4wzN57ksHSY1ETblbXEIhVBZg5i2LOP2TbQg5hchAjUuScQc9FF60kJEXd2eARdGzuXrqq3BXlBLee8DQwKvwIlwSgVmzCTedMPEkZBt+f8U0FDlNrK/D9lua3UpCByKn9eOZFUhy1aHNp2Jh4oPdBKunmytygKfY2TP4qqqzSeWMdWpAcrYTT01VdiBFgSkYFzlNsnMAX02pKYbFaPFedSytQEVowgy3ckLNoeLPf3Mp7nW3qAPpaRCfRqL3xBCpWJqKxRWkMyebKwg3HU0y1tRL/oKazP2nrs/2GoL0aIz4qbMEFs023Mdm11D06AnkeIK8xYvNLzdv6gzfOhOcZ++ht5AthBDFwHXAPkVRYhOV/99uU9AyCXMCDjmZpP1Z1S1UOGORHR5k+3bZTwUhK2ZQMbiSxldanBSNLLyMp7qQOS4UNTV+7YYbmX75PfQe2MLp332X1NiQI7g4qSrntB7z99DMuVTfcg/9m59hcPurJjAx/V7Y68vfuIFkRxfxk03ZdwsD3KCAp6IUb0M1Y9sOZ13JYMrVkjenipFj3Xa3UEZ5cXldSG6JRCTFZOz1JwfZcFUBXo/W+GRVFjADiz4/zuTJbKsBjHHYAI8En/6XEu7+aAn/dm8bmx8e1INzjbEtWnzLJR+eQbDIw+avHUQbfVpLNueW0iy4Zwmx/jDdLxzT1RghFFySQvGVK4gcaiHZ1adnyNVdRCvNLiJTXMusOUSbTqIosq1RVwS4g3n4iisIdzWbfsfJKiVO4OK4rciAj0MdZhVFEOluRbhc+CunOas/BvCJdZzBV1tnqEuxnKOSDcK1wIo+UGLvkBrPUZsdlwfMOVpiPWN4Cnx4x3FT6qrMqKoK+icxLlAuM6qO1iDcjv39FNbl6d2dbYMjZsorimDoWDcAobnV5kB4g6socqgZ4fXgnVWf0zUU2bufwPx5SP6A+bnwf8yEEPcJIb4ohLgtkx33w6hD1VQCf/02H94fxKagZQIzNaByFgSsbqFckOAELE6qwmRUlvEUDWPduYDCaZ9FM5cy99ZPo6SSHH/gq4y2HDHXY4QvefxjmHC99iAi+z1/7hKqrr+T3md+y8iB3Rl4E2bw09o7DWpk8JSUEli0gNHNryEc387UB2No7ULGth8x5YMwTqG51Ywc60KWDV00yT5cZQTekJtEOKU/vK1ZPzUb7UtwaOsYF15XaFtnHqdIyWbS1WBGUzYcJg1gbLAjZNwCPvipQj7++Qq+/rl2djwzoOZyQTEM0KiqLwGfws3/vIgDv22jY2eX7j7SlJlAsZ8ZNyyg5YHdCEULxlXBJW9OJb7plYxu3qMqLZKSBRPNRdTfD0Ix/Q2Bxtmkw2PqqM/6TYUJGII1Mwh3GLpGj+e6cbDzVl+0Y8pYpLOFQEUdkmUwPiu8KALiZ9vw1dWZ63BQWrx1NdldGW4Erbuz8LjwVWhjChlvFNVivaOmHC3jWWw0AYC/YPJKi9M1nSsIt+NAP1VLyux1YE8cN3y4k9D0MoRfDQrW4ln0eQWiB0/iXzAD4XJjVFHUZ4RAjieJHDxM3vJl+vrs82DSp/jWmvr2cx7TOe/5AHAV8EPgBeDfgSPABkVRXngrTu2P3aagZSJzUEwi7c2ObiFNLdE/jY25bFZDcoGHCRYc1Bch27cxg0Fu1cURaGTw55cy+4ZPUDpvDc1P/YizWx5BTsTGhY+J4MRpvWkd2e+FS1ZTdum1dD/+IPGujkxZ5x5FRqgpuPACIgcOk+zuyz4EMr+ZIqsPt+DqRSTbe4k1d5pcRJpMHZpbTWo0RvjssB7XYo1v8eZ5iI6ob6/jgcu+V0bIK3KxYLXaw8OorjiZhAFOGGcywIuHTI4VoQbsajB0+3vzeO+nSvna37TT2xLJpvbPDOCouYnmrCpk5a31PPtve5FSSZvaMvvOxYTbhhja3ZKNexEKkgTFVyxjePNekNOZeAwVXjQXUcSUaE5tWdzFxXjKygk3nbDBijYfqm0k3NGsqjHY12vfbS4iC0BY3UDacps5lDPuM9LVanYNOdUtIDU2SmpkGF9tXfYftiguciJBqqcPT0ZpydaRvSaSHX14q0sQLknv7qwV1XO09IYJlE8WWtRr1RfKHdOSC7xz5WfRrvu0DB37+qhaWu4YhGuCfgQjRzrIm+8cz6IooMgQPXCKwKJZGOQpE7xEDx8DWSY4f4Hjs/Jtsbeu99Cb3K3yRUVRliuKUqQoiltRlApFUW5RFGXnW3yGf7Q2BS2TMQOIpCNhzjz1S4rnr9bdQo5wYYIMxQYiVsgxKSpy9sLWAnud1BbH73r9ZheUTTWxHK8kuahZex2N13yEkZYjHP/1lxk5fcCU08URuGTn83bah/n4DL+tAiXrLiY0az7tv/4RqdFRHVxygQ8K+GfNwjdjOkO/ewYhO6stnupy/PNnMPz0dpuLKC1LeKtL8FcX0vtGk/7ANSouaUVQPL2QvpPDEyahi4bTFJV5cLmy5YwJv4xKiQYs2nJQb0anyeMAL1pdRnB598eLWLw6wJc/dRY5mQ3MNbqJJCFzzV82Eh1OsPu+kza1paAqSM3FM2h7eB9uzSWV6f5csmkh8liM6IFTppwtQhIEVywmsveQWS3RlJjGOUTGiWsJ1c0iHQsT7e+0wcdklZNxzQl4sByHtkxRiPSexV9ZN6HqE+88g3C78VZVmdcZPpMdXaAoeOvNYw5p8+pAiX14Da4hTYkxKjKq0pLt7qzBpDWFP0A6rl5zbt/4j3cV0CWH8YIs3w0/Qn/TCGPdUerWVFq2sce0KGmZ4YPtFCypyxHPIki295LqHcK/ZK7e808DEU1BjezcQ3DRIiSvH6PKoj973g57m6BlyqagZWKzNLQdzz+I5PFSe1HWLZQTDIzAkqPhVpePDylGiEExrJft+7SDg2LZl/OxassLaucw746/pqhxKS3P/ZzmJ35IYrDHDh/jwckkXEpWcJGQqL7hblzBEB33/wQ5kcycozBvg1aPQEJQfP21RPbuJ95yJvsA09QWBRRZkH/5Wsa2HiQdjiPLErIskZalzENUonj9bHpfO2VQYbLAIisSZQtK6T4ymKla5FRbnMYv0iyX2qICjHojukTuyQovTuDil2Q+9+UKejuT/Pq/uvQRoI1uIo9Ik1/k4dJ7Z7HtxyeQIzGT2iIJhdl3LKJ3eyuRswOm7s+ewgD5a+YwsnmPnqsFAUgKgZWLSLSeITU4aIYTAYHZc4i2NplS+huBwZNfhK+4gtEzJ0y/zXhxLePGvIynsljKGOtThCA5OogcjxIorx23PALiHe14K6sRLpd9n5nP5NkOXKXFSMGASV0xVpdot485ZDRJKMR6x/BnlJbxkssBpJMyLo+kD05oWjfONWpcp7mGjPEsaSRaXu+iqD6f/GmFpky4mmlKpaIIhk/2kg7HyV9Spy+TDcACEN5zAndVKZ7KMttLCgqkx8JEjhwlb+WK7HPE8nyZsv9bNgUtE5ixgR05fZiR04eov/LdSC5f1i1kuJEmAhYrrKQiowy2H+HMwWc4tuVHHH/jF7Tuf4KuU28w2HmM6EgPcippVmOMSsy4wKTtz0F1cTgurbF3u33Urrueebf9FUo6xfH7v0zX1iezLiMbdNlBxnF9rrw1qPMut5fa2z9AaniAnt/9Ru8Kbfx9jWCELPBPn05wySIGf/skpLX1mRZTVj+DK+YjvB5GXj1oU1tkRVC8cQ4jRzqIDURsLiJZEZTNL6X3xBBJQyyu9oC3qi8TvUAZVRYNWEAFE3BWWrT1GryMBy5V5YLPfaWCR340wIHXRrMBuULJ9GZSlZe1t9fi9knsfeC0SW3xSGkqFpVTNK+c9kf3mbo/uySF4suWMrbrOPJYWBUiJFUt8M6oxVVSRHj/IdDjXRQUwN/YiJJOEzvbYldiUD/z6ucwdvak4zrIApAtOZyhjG0+hzm5kTSL9p1F8njxlpRNHITbeRZfTa1JOTHWrwhFjWeZVm07HyDb3bm9z9bd2ZijBTT3UMgRWKzdn1VoeSskqqxp13nza13Ub6i2r3eIZxnce5ZAfSnu4vysWwiz2BDZe5zgsrkGYDG7hiK7DyAFgwRmz3V+br1d4bh/fF2e/8/YFLRMZJmbQ04m6Xr5t5Qu2UigrFZ3Czm6e5TcwIKs0N+2j5Nv/IK9T3yBXY//Cye2/oKRntME8srweINEhjrpPPkqx9/4Kfue/TI7fvt5Tmz7JSPdp1EsvY4c4SUHLJhUF6e4GwsUBIqqaLzuo9RfejeDx3Zy/NdfYvjkvqzLKOe5Z+uxKz/2ef2Zq4A3v4jaOz7I6NED2a7QsnA8Tm2/xddeQ/x0M7HDx1VlhuyxKQrg8pB34QpGXtrtHIw7rxZPYZCeHC6iknmlpGJpepvGTMGJGrhob6MOL7aTMiOwALgskxFgxgMXLTh3w8UBbn5vEV/9zFnGBhKZmJZUZqRoNSg36IdNH5jJjp+fQonGs+n9UXBJMPuORZx95ihyOKp3fxZCoXDlDNz5QUZfP2jI2aIgXILgikVE9x60gYkrEMA/rZ7w6ePZ28oCJ3n1cwh3NpG2Dp6olXUwpzgT2zoNdCx1muYN20Z7O/CX1SCE+dHoGITb2Y63dpq9LsNn4myHGs9C9vowDZQYjZIaHMNXaw9s1feVlon3RwhW5E6bb7R0SraNSG5a79DQZyFcMqkrRrUlNpaifW8f9RurJxXPMrT/jO4aAkz3HEB6LEbseBv+pfNsvYY011B4527yli9DklzmZ0omtk2JvV09fM93sMQJ3m6mLKdNQcsEpjXGfbtfIZ2IU7X2HTYJ06ogmLozy9kpOtjJkc3f4dT2XyOEi5q5F7Pk0k+y9sZ/Y/GmjzNjyY00Lr+VBRd8mBVXfpZ1N36Ble/4e+auvQc5leDwlu+x/7mv0HniVVKxiKkR19QXJyAxw9ObjHVBUDJzOfPu/CzFjctoe+FXnHr0f4h0tugQZD53+3zOfcjG488uD1TVUX3jO+nf/DSjh/frb2Cm+kBf7i2vIG/tGgYfewolLWeAxay25F28ikRzB7HTHfaAXMlF8bpZ9L122tFFFCoPEiwL0HV4MCOHZ+MA0mRT/iu5WteMjTtmTObT5bDOZVg+HrgYE9Ld+9liSsrcfPOzZxGKOhyAMSjXhcLa22txuQX7fpNVW7QsufWXzcQd8ND5zOFsMjpJRnILCi9ezOjLe3Vg0VSVwMpFxE+3kB4ZMasUAgKzzHEtGP4iBASnqWpMpKvFHvcCOdWVSce8CHNZx+0ERPva8RtdQ5bttPNJR8KkBgfw1dTamx9NcVFkkmc7Hccc0j61gRKN7iHJ8pkYiqKkZd09NJFp7iGrmboxG11BBmDRyzq4htp29CBcgurlVZZ6zSqLrAhSSZmRg2cpWFqfWe7Q1Xn/aYTXjd+Uuj87JXv6ibe0krdypX7PZ59P6ovM8K5tk/pNpuxPx6agZRKWHBqgd8cLVK+/BpcnYHYLWdQNK7CgQDIyQtPOBznw7H/hcnlZeuVnmLP6bqpnbCCvaBoufUToTExLZpIUgd9fSGn1Ahasfz8rr/ocpTWLaD/+Erue/H+c3H4fsZFeC5hk4SWXMmFTXRyUD5vLyOOnZt31zLvzs3hDhZx65Bs0P/VjYr3t+jlPpKyMq+xYPgvmLaVs09V0PfIrIs2n9DcrHRINsIMsKLrqSlJ9/Yy+YhgB2tCTyFNVgW/+DIae3o4sC3VShB7fUnLBHAb3tBIbitpcRCnZRcWiMs7s6SVN1tevBTFq4OLxSUTDsu1h72Saa8gQs6uDiUsI54ms8pILXLTU/wEffP4blezfGualB/oyGXKzQbkekSIYgIs+MIPtPzsJsbjuRpJQ8HoFM25awJnfHkDI2e7PkoDSy5YQO91Jok3tNq25iHyz6pHy80wuIkVSXUTBOXOId7aTCo/a1A5FgMsXIFhVz+iZY2alhuynyUVkMCuAjBvvYjHrtrHedvwVtTblxlo2pmXCrTK4Siznle4fRIkn8GjuIQ1aDeCS7OjDVRjCk692CbYCC0CiL5NYrmxySoucUoOjJ7I0YtwYF72+zIk3vdrJtNUVuP3unPEsoALJ6PFu0tEkeYsbsnEsaI8nobuGAotmIVweHUSM8BLesRtPZSXemmmm+1l7ZsmxOKNH9k/qN3nLbSoQ922zKWiZyGSFjs2PECivpXj+GrNbyBRngk1xSCcTnD34LPue/A/G+tuYf8EHWbDxgwSDZTbVAwVE2qzM6FNanfyBYhrmv4NVV/0989bcQyIyxN7nv0LTrodIRoYtMJAN6s3tEppYdbG6jPz5pUy//D3MueVTKOk0J37zVVqe/TnxgS7zuYwTjJtL2bEuK91wGYXL19H54M9IDg5kzkE4bufJL6D4+msYevxp0kMj2YegoVdR4XUXMfbafhLdgza1JW/ZTDzFITqePuLoImq4pJ6mze0k4nI2SNEQ1yIjMW1+iL6OBCMDKWQkW4OQq/eR8SZ0GRpke1yLum48cDG6iWbOcvO+T5fy4y92ExlOqEpLBli0cuturwVF4eBjahdnLUuuJGRm3zyPaPcog7ua9Z4qLkkm0FCGf3YNo6/sBaFkXURuieDKxZauz+rkq29ACgQJnzziDCUC8qcvYKTliPnHGU9RsSgnRoUmu9wBcBxgSBGCVCxCcmwIf5klZsNB5Yl3tOOtqELyeszHZyib6OhCeD24K4rtdRmUFmtSOdOuhEKsP4Ir4MYdmlyyOJdbQk6/uUYxO0ioAcoNaksqqXBqczszL62zuYb0e8UQ19K/o4XQ7Eo8RUGbW0hRQEmmiew+RmDVQsdeQ0paZmzHLvJWr0JC2FQWFBjeu8M0NtQf1FTp6PymKTsnm4KWCWzszAlG245Ru+lWJIuEaXeBZN0zyViYYy99l56m7cxYcTNLLv8UxZVaMJkBFgxgYpVHrZMGNS5clFQtYNEFH2XBuvcxNtjGnmf/k7YDT5GOm91GuVxG1kDd8VUZ63lCqKyOxms+zOwbP0E6Osbx+79M20v3kxwZMB9zjjqdIMW6TCCovPxGvGVVdPzmp8jxRBakZCwwJChYvwF3STFDTzxn6AINyAJFFvgXzcHbUMXgY6+b1BZFESiSi4prltLxxAFSabuLqO7CetJJmeY3uk0uImNcS/3cIG6P4MTBN+9nt7qFrDdmNqYlq7o4gYs1Ad2t7y2ksMTFI9/rRSLbtVmDl1BIsOGe6Wz/6UmkVFKHE4+QCZYGqL14Jmce3a/3LDIG5I5sOQDptJ6vBaEQXL2E+Mlmm4tIuCTyFixk9MgBW+8i7bNg5gLiA93ERgZyuohsaksuocBBzZlIVIgPdAECf1mVcxCu4VjiXe1qEK5hX1ZwSbZ34ampVBtWg3KiFxPZgRIBW44W/bj6w/hLQggh9EESxzPJI0gnLcG54+QXMgKLk6WROLOrl/hokpmbpjlsb3EPIRjY2ULR6pl6V2frqM6Rwy3I8QTBpfOyF4Phno2fbCY9PEzeilX2Z64CSlpmaPsW8hcsH/e3+L1Z5tl67tPbc9h/CjYFLRNY384XKV+2iUBpjaNqkF2WVTXi4SGOvvgtZDnJkss+SWX9aiRFMisbBlAxDppochM5BXAZAEZSBCXl81h68SeZtew2+tv3s/uZL9J5fIs+lpA13iWX0mFNfpcrwNj6AMmrnEHjdffSeM2HifV3cuxX/0HHlkdJhUdsZW31OKhK2jJ9G8lF7S3vIR0eo+fxB1HSiikw11i3wEXJDdcztnUHibOdGXDJPggFEoU3XMLoy7tJ9o/oD9C0LJGWBWVXLiXeM0r/rjZSsub+Ud8m3SEf9RtrOfbMGZuLKI06CY+LhgVBTu2PqNK7AWysqouTLK8pKSblBYHLUNaoujiBi9FNJAkZv1fhfZ8q5YmfDzDUE3dUWzbcXUdsJMHRp9v0MYnUXkNpZt2+kN7trUQ7Bk0BucUXLUCOxIjuP5EZh0hthH1z6nEV5hPedyDrIsr8BaFFS4k0nSAdi9oaekWAt6waT34xo6051BiL5QQXYVnvZA71Rvs78RaWIHl8zuUNxxrvbJ+w51CyvRNPbdW455Do7MdXU+KYm0VPy983hq80aHIZjTf+kMstmaDF2hXfmJ/Fqdu+SW3JnNCJF85St7oSb2HA5BrKwkq2bGwwytiJLopWzbC4hrLjDYV3HMG/oBEpGDSpLNr82PadBObNxZNfYFFpBcgQPnqQ1MgwBQvfJmiZsrfNpqBlIhMSlSuvMOVPMQWQKppyAigQG+rhyAv/g9sbYuFF9+LzFdjVDA1WLCCiNeT6IICy5bsVcDIAJCkSFbXLWX7ZZ2iYfyVnjr3A/pe+zlhviwU+nF1G43WPHreXUWadhKCgdi5zbv4UDZe9m9Ezxzn2yy/Qve1px27STvDnFFejfXcH86m99f2MHtnPcGaMIiELE+hoZYNz5hKYN5fBR9TRo8nEvGhqS2D5fDxVpQz+7g2b2uIqLqB4w2zaHz+AoghSipSBF/XtceaV02l+pZ14JG1yEelwg0Tj4hAn9kfGeWudOIbAUJh4XH2aG+FlXHCxuIk8Is2VNwSoqffw0Ld79B5EmtoiCZnCIol1d9Wz7ccnQFYVFU9mIMWKReUUzimj/bH9poBcb4GP/LVzGdm8FzSlRVIQroyLaLfBRZSBl8Ds2UheL+ETzknohCTIn7GAkZbDlntQ/bAqM7YyuZZbzDHIV0Csrx1/WY2trDUQV47HSfb34bUoLdbPREcXnmlq0Kq155AQoMgyiY5+U2I5fTcGQIn3RwiUhWxlcikuwuNCTtmhJtc1OdG6VFLh1EvtzLwst2sIsoG2/bvacIV8BOfW2t1CCihphciuowStrqHMfS1HY0T2HyB/1SrDcvMzYmDbKxQsXoXbb/9d/iA2FdPyttkUtExglSsvx+X22d/s9QY/Cx3hvjMcefFbhAprmH/hh/F4AjZgsYKBGUiMIGSZDOVM2xjqciluaqZvZMVlnyGUX83BV77N6d0PkYqNWeBjHJeRwzE6KjQ54KV4xhLm3f4ZajfezMCxHRy/7z8ZOrEH5LRZXbFASi5w0coGquuouuZ2ep77HZHTJ9FcQsb/Q61bUHL9dcROnCR26BimoFwZwKWqLS/uJDkYtqktFdcup3/racZ6wtlAXEUiKbuo3VCHkASnXum0uYjSqF1FZyzJ49SBCIqi6HEtacyupGy30NzWcTbNxkt7WbCiiy98aYSREbW0Bi9O4KKuz7qJtN5EXhd88DOlPHP/IL1nYoZ8LSm9J9GF72lguCNC88tnVJhBwS1kXBLMum0hZ58+ghyNmwJyiy9bytjuEyhjY2q7n/kjgmuXEj/VQmpwyOwicrsIzV/E6OH9OV1E+TMXEG4/TSoZd3YRGS3jJnJSVIzLxoUdg0W6zxAwZsLNAUDxrg5QFHw1NVm9w6q4pFKkuvvUHC3aKouakh4aQYkn8VtytFgt3q8qLZM1l1t1D6WV8WFEM9115KCypJE4u7eP2EiC6ZfUO25vigFDMLijhaLl00FymXoNaVPs+BnSI2GCK+ZjuhAy931kz0GEy01wwSIb0KBA9EwLsbMtlKzZNOnf5K238wWWKWg5V5uClgksr7rR9vZvnYQMw+1HOfrSdyiqmsec9e/BLXnQlZFMIK3RBWODFHniC92ULdeoxijmun2efOauuIuFGz/MSF8ze579T9qPv4ySShlgQNHhxelNxtbLKAewOMOLi7K5a9Ru0rNXcual+zn50NcZaztuPn8jmBhcQ0Z4Mu6jcPFqildfSPsDPybW1popJ2wg5K2oJn/jBgZ+8yhyNJ4FnIziEly9BHdZEYMPbrapLcHF0/HXFnP2kb2kZRVYdJ+9z8v0Sxs4+EhTzl5Es1YVMjqY4uShuO4iMpp9NGnn6+6+ByIIAZ//2wIeejTKmgt7+PkvI6Qyb9BGcNHM6iZCmxcyF17uZ84iPw98o9sW2yIJmaJyLytunsa2H5/AZQjG9UhpGq5oRAhB78vH1bgW1Ay5hcun4y7I5GwRalp/ISl4G+twlRYT3r3X1osotGQp4dPHScciZgUl8xmaNgvhcjPadtQOD1bIMZgGLyaIGU/UMuxTEQI5mSDW30mgyrlhNu4v3t2Op6QUye83rzN8Jrt7QZbx1FQ6Hofac2gAJIGnssjRLaTNxwej+N8EtHgyI0Eno2l9mZ5bKJOHxTgZ11tNVgTHnm5j2qpKAkV+m2vImlAulVIY2NFE4ZqZti7OmmtobPthfHMacBUUZJ+joL9gjG3bQWjFciTJrQfgmlSWrS8TapyPv7SSCcJ7puxP0KagZSJTzI2o8e1fi2MZ6TzBiS0/oWr2BcxadScu4cq6YiyNv7mBdYCRtOI8OcCN8Wa2uo9QoLhkFssv/ksa5r+D9hOb2ff8VxhsP6JGrhvqG6+XkQY4bwpeMpPb5aN2zbXMv/NzBIqraXri+5z+3XeJ9pxRz8Oq9BjPw+l3V6DisuspmLeUs/d9n2RvTxZcLNuVXH01igKDjz5lDspVACFR/K5rGXlxJ7GWbmQ5q7bIikTNnevp+N1+IkNxNeeE7CKlSKQVwfw75nN2Zw9dx0dIyi6SijqlM2+aJbUBZq/I45XHhkzBj9a4FlNXUdRkvmmDZNzalmbFMg8fuCePbS9X8vE/y+Mf/3WYS6/uZctrcSALLlY3EWALynUL+OBflbD5sWE6m6J6bItxMMVN72+g6+gQZ3d0Z5QYVXHx+SXqr5rN2ScOZQZWVDPkSm5B4SWLGdm815TWX0iC0PoVhLfvQUExwUdw9hwkn5+xowfMUJKZJI+H/BkLGD59QL39xgUVcoPJBAqN6RM1PwuKrCotxnIOakuipwtvZRXjWbKrGykYQCrMuC80EDEASaJ7EE9pAZInOxqzU9xKYjCKrzgw7v6MFixRY3LCA/FJlTcCjVVlScbSnHj+LHOvm56715Ahdf/QwQ5S4TiFa2ZlQQXDu1daIbz9EKG1i22uIRRIdvcRb24hf/Va04uQpsQk+vsYO3aQ0rWXmIDnD25TvYfeNpuClgnM0S2kN/YQH+nn1Ou/pGr2BTQsvBoJQwNqBRa9YTaASjp7EZvgxDo5ldPUEkOvJSu8SMJFzfQNrLr0byiunMexbT/j6Gs/JDrcY3cZmSALy/pzhxdfqJiGi+9i7m2fQXJ7OfnQf9P+6m+R41EzyFlVF+vvKKtjFFVdcweBmgbaf/NT5HjcDDiZsi5vgPK77mDs9a3Ejp3KBuVm1JbAorkEFs+i//4X1B4OBrWlaNMiPMUhzj5sVltSsouiueVULStnz/2nnANyFYl115XxxpMDJNPC0UWk9zgaRwpoO5OmoV5tzPx+wSc/ns/O1ypZudzLrXf3890fjullreCSKyh39UYfi1cHuP/rWbVFy9siCZmKugALLqti7/2nTMnmJCHTeOM8ho92M9bUowfkuiSF0suXEm/uItHaqbbxkhrfEtqwnGRHF8n2DlVlEaBIINwu8hcvZeTgnty9iOYsZaTlKOlUInMT4qi2ZG9Sh++Yv+cCH61spKcNX3EFLn/Aseu0cdt4TzfeiirT9la1JdXVi7uqXB3/RwcWrYz6PdU9gKeq2DE3izavKArxwcg5QUtkUP39xlNTjMDiZCc3d6DICtMvbjCBNmR7DRmz4Pa9fpqCRdNwF4Ryu4aGxgiuWoTpAsjc6+Edu/FUVeGrqc2qLIYXvcHtW/BV1RKsazTy3x/eFPn8pyk7J5uClonM8gZvbIzTyTgnX/0pwaIaGhZfY27cDW6bbKOs6AqJDiA56s7lhrJCjA1gnOBFVnB7gjQuupHlmz6Foijsf+GrNO//Hel41BKMO4ku0m8CXozHEiyqovHKDzDzHR9kuPkQx+//MqNNhx2gDkOMSrY+7bskJGpufBdKIkG3sUeR8TxkCDTOIX/9Ovrve1B1E8mYgnKLbruK6J7jRI626W6itCwhCxfVd6yj/dE9REcTdrXlzgUcf6qV8EDCFpCbVFysvLqc0cE0+18PO/YiMj/onV1ELa0pGurNHaErK1x8/cvFfO1LRfzrf4xw8lTS1LNIM2NQLmBSWz7w6RK2PDlC2/GISW3RwGX93fWcfKWLaNeoqftzcWMxxQsr6XzykB6QKwmFQF0pgbm1jL68x5TW31NVhndGHWM7dhuUlIyLaNkKoi2nSY4OmRv9TPuVP30eAKNtxxzX2wCG7Hfjz+GosjitExDtPkOg0tk1ZK1TVVoMbh8NMPRjVUh29eCprshZlRCq0uKtKs59kEA6mkROpPG+CWjxBty4/S4iDkqLjDBN4BDTklFZEnGZ7d87zLzrZugup1y9hmRFkJah/41TFK+fnds1tO0QvrnTcRXaXUNKWmZs5y7yV61CGF7+NKhJh8MM799B6ZqLTS+HU/Z/y6agZQJzdFNkgKN524OkkzHmrHs3Ei5nYDEqGRnYyIJGtpxTRlzTZOkxZAIDDWDGg5fMtqH8Khat+xBz19zDYMdh9j77n3Sd3prtIi3b68gNJuPDi5NqgwKF0+Yz//a/pmjmUpqf+TEtz/6c1OiwBfAs9RlgRMjg9oeovfV9jB09wPCO1/UgXOv+S669FkVWGPrds1k3UQaAPPW1BNcuZuDXL5BOo44ArahZcosvXYIr6OPso/tsakvdRQ0Eiv3se6RFdw8lZXfGTSQRLPaxdFMRLz7Un4GarNoC2UykVheRZrGYQle3TH2dU1J/uOfuIBds8PGJvxwinVYc3UTgrLYsX+Nj1UVBfv21rNqi9SjyiDRz1hRSNj2P/Y80q+MUZVxMklCYeeM82p8/jhJP4pLkzKRQfNkyRl49COkUiGxPotCGlYR37kWR0ygSaostgb+hAXdhEaOH9xmAJjtJXi8FM+YzdPpAJkZFuxmzv4FiARfFss66PntDZ+sxLo90txGoMriGrPVktk2NjSJHwngqzUqL9VOHFodj1yzZlYUWYwJbUzbcwQjApJQWY7xUqMRHeDA+oZIyngqz82cniI0kWP3RpZPqNTRyrId41zBF6+eM4xo6nNM1FDvZRHpomNCKleaXtcw0tOsNXIEQBXOXmp4Lb4uZTuxcprfpuP8EbApaJjLL278Wx9J1+GWG2g8zd8P78HhDkwIWDSxMoGKCEOfcLOOVM93Y48GLwVUlKVBWsZAVl/wVNbMuovXQk+x/4WsMdRzNxrucJ7zkcjNp8y63j2nrbmDuTZ8kMdzHsfv/k/7D29AHYzTu0xLXooFLoHIalVfdQs9zjxFtacqUEaZYGZc3QNktNzP66uvm3C0ZxaXo5iuInWgjsudUVm1RBIrLTdXt62h/eA+xsaRZbXG5mXfbPA785iTJhGJTW9JIXHhnFTufH6K3RzEF5FoHl0sjdGDR4lra2tUAyvo6N7Kla6QLgVtI/PeXijl5OsV3vh92vGxzqS0uFD746RK2vTBK08Ex05hELlQIWXdXPfsfbkZJmQNy6y+bCYpC75ZsQK4QCiUXzUOOJYjsUZcjVCUhuGYxcjhK9PgJVWWR1J9euCTyli5n9OAedZmE2VMgoGDOMkaaD5OKhXXQsKotVphxggzjvNM6LRNuYrhPVVqMAIW9fKKnC4TAU25XUTRTZJlUd6+utDh1dwZIdg/irSoyBeFad5sYigIQKPaPO3aV1YLFPsb6EqZlVnCxAotRZRk4E2bHj46y4ZPL8BX4HANwrb2Gul84Sv7CWryVRY6uoeixNtLDYwRXLjT92Xrule271NwseQWGZ476oiEnUwzueo2SVRchCZdZCX47TFHOL55lqsvzOdsUtExgJmDJNOhD7cc5c+ApZq6+g1BhTaYxdQYWoblw0g5BuToEKRngYNxJVWjMEGOFHyG/CXiRPNQ1XsLKS/+G/NLpHN36Uw5v+R5jfW0O5z15eMmV58U2L0OwrI65N32SqhWX0/7ao7Q8/RPS4dGs6mLYjxO4FC9dR9HydbQ/8CMSXV36g04Yfrfg3AUE58+j/1cPoiTTJjeRu7KCvItX0f+Lp5ETaVVtyUwlVy5H8ntofWC3TW1pvHEuyUiK/b9ttaktScXF/I0lVNT5+O0PunW1RQvYNca0aGqL9vcDlJdJeL1w6Ki50TFabY2Lf/3HQr741RGaW1JvSm1ZuNTL2ktDPPzdXlwiq7ZoYLPyxmqS0TRNL54xBeT6gy7qrphFuyEg1yXJuPN8FGyYz8jmPSalxVUQIrB4HuHtu9UD0lxEAvKWrSDecZZ4X7ej2lLQuAh3MI++/a/Y1RYnFcWy3ElN0cy6LNqrjiPkL6+xF7aUTw704i4uQfJ4si/LFjdRengEJZnCXZl75GY5Gic9FsVTUZSzDEBqNIrkc+Pyucctp9ebgY7C2iCDZ1WgNaoouXoNWYHm5a/up2J+MXOvm6GrK9b9GANwUwmZns1HKbtsYRZWwOwaeuMg/vkzVNeQ4VmEov4ekf0HyFu52q6yyDB2ZD9yIk7xkjWmdW+bYnFeKssUtJyPTUHLBJZ921cb4vhwH6df/yXVczdRXrcsq74YstuaGntTzxxjg24AlXT2Qs7lHtIvdAPc6BBjAZiJ4EVzkWjlvb58Zi+5lRWXfBqPJ8DBl7/J8W2/IDrUbQENZ3ixztvPdXx4EbioXHwJc2/+SxKjgxx/4CuMtBxVz8XoLjLEtRjnqy6/mVDDbM7+6vukBgdN5dX/R1B6y20ke3oZeelVm5uo6NYrSY+GGXxym1ltcXuofc9FtD+0i3BvhJQs6WqLO9/PonctZOcPDxOL2tUWxeXixj+v5/lf9dLdKetqi1POFqvaklcguHiTj8ceV4cDsKotoCou774ryKrlXj7zuWEUpzLjqC23vq+IbS+MMtQdN+R2UQEmlOdi6XW17PlNUyZ+JRuQO+umeQwe7CTc0qf2IDIE5Ib3nkIeHNYVGIRCaONKIvsOI0ejejAuAnw11Xiraxg5sNsxIFe4XVSsvYK+/a+SilvUFswgkUtdsbmIrApKZj7S3UagrAbJ47Hc/Ni+J/r78JSU2qHI8JnqHwDAXVqkL7fmaEkNDAPgLS3IVm+RDYRQSI4l8ORlxxyarNpSNquA3lMjbyoIVwOepte7ad7SyYV/vRIFlw7WRtdQ9rs637e1mXQ0SfGmBSZ1Re2ZB0pSJrz9EMF1S1Fkwx+eeR5F9h5AuNyEFizU2Db7rFJgaNfrFC5ahcsbyK7TXmCm7P+UTUHLJEwDASWV4tSrPyOvpI6GRVeb4jSMCkouYLHBirW7sxFOLFPOcmlNkTACy/jwYuzijGFZMFTB/NXvYckFHycVD7Pvha9yYsd9xIZ7x4WX8cHEogIZFROjxKtAoKiKuTd+kpLZK2l+6ke0v/IwSjxuOE7zw0oDFwmJmhvehaeohLP3/QAlFscamOvJL6T0xhsYevJZkp09JjeRFMyj6LYrGXp0M8m+0Qy4qKM/F21ajK+mmOafbiWdSTSnwcucOxaSiqfZ/1CTo9qy7KpyqmYEeOg7zmqL2kg4qy033hDg6WdjhGNmp33a8GophOC//rOIbTvjPPBQdEK1xWgrN/qpmuZh84N9tmRzHpFm/V21nNnTz8DJQT2DrkfIlMwppWh+BR1PHVSVlgy45C2ux1NexOiWfWpAbiZnS2DpHCS/j/Cefba0/vnLVzK6fzeKIpshIFOmaP4qXIEQffu3OKotxqBcq3vJKQ7GaMb10e42PQhXsdRrLZ8c6MdTmltBAUj1DeAqKkBoEKS1rIYWNtU/Ai4Jd5HaJdoKLBqcpEZj+gjQucxpPKGyxgL6To+aYHbcINwMsCQTCpu/vI+FtzRSPq8kCyhOriGDi6jrmUOUXjAHV9Bvcw3JsiB8sAk5Eie4anH2mYn6QoGipu0PLV+O5PZk12fWxTrPEm1voWT5xqzqalBh3xabUlreNpuClgnMCCJdh18mER1h1tq71eZBa/DTZFUBJ2AxBNNqsEJaJhYdpKfvME2tL7D/8C95fdd/sXXPN9hz6CccPvEQp1qe40zHVnr7jpBMRk3+UNOwAkZ4SU8OXqxdnI3HWVDcwOINf8bCjR8mHh5k7wtf4eTOB4iP9r85eDFByjhBuwa4kCQ3tWuvZ9a1f8Zwy2FOPPQ14n2dWXeRbH5oafMuyUPdrR9ATsTpfuqRbGCuoe78lWsINM5U3UQpOesmSgtCF63BU1VG36+eNSWck4WL2g9cStezhxhuHlSBRVHVFhEMsOQ9i9n54yNERtOmvC1JxUVauLnxL+rZ/GAf7WfSutqSVNy62pIrtuWyy70kEwovvaz2ADGqLUZwmdXo4TOfLODz/zJMX382mZhm1rwtmovIIylc/85Cnrl/ECWVtiWbq5uXT/3yYvY+2KSP/qyNRzTzxvm0P3PMFJDrdkPx5UsZ3rzXcCGA8LgJrl3G2HZDL6IMvOQtW0FqZIjomabsOsMk3C7K11xO374tdrXFYd5+86ofVrgxqTGKoiotuXoOYS6fHOjLQksOtSXVP4C7tCSnDCCEQqp/BE9JPsJlfwQbAUZVWpyhxQlWNCufVUAinGKkKzpxEK5Bqtr765NEB+OsvXeJeo0qWXXFmpsFUGNVesMM7Gym/KrFFtdQpm1WBOE3DhJYMhspGDC96KFAsqefeFMz+avXmJXbzDS083WC9Y34y6ptLzpva0zLFLS8LTYFLRNZpsGLDfXQfvh5GpZdj9eXl3ULybkVFhuspBUiYz0cPvoAW7b9O2/s+ipHTjzMwNBp/N4CptdeQF3lGgpDtQhFMDraQXvXLg6ffJhXd36RvYd/SnvndhKxYfWGtwKMpsCMBy8Kph5MjvCSWVZcMoslG+9lwbr3Ex3pZu9zX+LUrgeJjUxCeZkg7sW23PKwyq+ezbxbP4O/sJyTj36T8NnTFjDEBjFuX5BpN76HkUO7Gdm70wQu6naC0ltvJ9HRyegrb5jcRAIXJffcQPiNg0QOt5JOS8iyICVLhJbNpGBpPU3ff1VVW+TMpEjMvm0BksfFzl+edMzbsvjSUurmBnnoW10qrGR6EiVwmVQXq9qSlydx+eV+fvrzMCmHnA5GcPnze/OoqnLxD/88Apjztmjf1U/zCNBX35bP8ECafVuGHbs/r7uzjsNPtJGKJEzjETVcMRNkmb5XLQG5ly4m2TVA/HiLujyTsyVv4woSp1tJ9vSacra4CwsIzJrNyIFd+jKrWlK8YLVdbbG4eGxxLbliWmzqiSAZHiYVGbX1HHLaRlEUVWkxuIecLN03iKu8OLO9Yq4n8z3ZN4y7NF9dNE7LmxqL54QWo1kzLedPK8Dlleg9pV4TxjgWU0yLdt0hMdITY+v3jrDuY4vxF/nGV1kMwN31/FF85QXkLW4wuYb0ITLiKcI7jxBau8TyBwOKGoDrqarEVzPNprKkIxFGDu/JqiwG2NHj1qbs/5RNQctEpgBpheYdD1FQ3kh53Qo9xkWLY8kGipqBRXcLyRCPj3D85GNs3/NN4olR5jXewIZln+TiNX/H6gUfYt70a6krW0V9xRpmT7ucRTNvZuW897Bh8ce5eMVnWT7nXQR8xTSdfYVXd3+FnQe+R1v7a6QTWoI2IziMAy/GOBMrvBgfBJljlxQoKZvL0gs/wby17yEy0sXe577M8W2/INx/1qKqmCEqF7zov58RXqxvUDJ4PEFmXP4+Smev4vQT32Pg8Ha74mLcXoZgdQMVl1xH99MPE+9oxxiYKxTwFpZQcu11DD3+lNlNlBZ4Z04ndMFy+n78uCkoV1Fc1Lz/MgZ3nKZ399lMUK6LlCyheH0s+9Ay9v3iGMPdcZvaksLNTZ+sZ8uj/bSejJNQXDnztmhqS1pR1Za/+qs8tm5L8ItfqT1InGJbALxewX9/qZiHHo1y4ljKtM7oItI+NbWlpERw0dV5PHPfgKn7swY2S66qxON3cezJFn08Ij0g98rZnH3cHJDrr8wnb3kjIy/uBqFkc7Y01OCprWJs+66M0qIuVwTkL1vJ2KEDyKnEhGpLOhHVIcUEL1aXkHbrjuciyiyLdrchebz4SipN+3WqLxUeRUkmVGjR61FM+1KEoiotZSWO/5Ve18AInpIC23JrzEpyLG6KaRnP1Hgp9XqSXILyWQUceKwN2ZAIyKi6GIFFVgSvfvMQhdPymH/zLEeVRdvGmpul69nDlF+5CITk0GsIInuPgywTWL4gCyWoLxFKSmFsxy7yV63GmJtFU5FH9u/E5Q+QP2ux+UUpU27w+K5J/TZvuckKyPJ5TFNKy7naFLRMYALobdpJeOAMM1fcgjnpURZOUBRLoje10U8l4jS1vMDWnf/F0EgrS+a/i5UL3k9V8UKCvhIkWUwYzyIJF6UFjSxouI6Lln2a1Qs+REl+A60db/Dq7q9ysvlp4rEhu/qSC14sQbJ6kjqHYF29PILS8gUsveDjLNz4YdLJGAc2f53Dr36f4a4TmLpKGxUco4JiVGIs8KKpPdbeSRIStetuonbdDZzZ8hBnX34QJZk0wYo1ULd05SbyZi+k/f4fkR4aya5Pq/UWrFmHf2YjfT/5FUo8ZXITFd1+NenhMQYee410OhuU65tRTdlVSzn1jRdJJBRTUG7DtXPIn1bAlm8cNAGLOrmZc0EZ89YU8LP/6FDjWtAUFjO8pBVhCNCFmbPd/OPn8/mHfxpmzwG1J1EucFm90kt5mcShI0nbuvECcq+7u5Ddr4zR3xHTA3K9IoVHpAj4FFbcXMeeB5pwibQ5IPfm+ZmA3F49IFcSUHLFMka3HkGJRjLjESkIF4Q2riK8bTcKssmlE1q8BIRg5JA5Q65RdSlasAqXL0D/wdcxjitkBRcwv8gblxvLG9eFu1oIVNYjpAkehQJSI0MAuIuL9WWmz4ylh0fVHjI4r1fLRHAVhSYMrE3HUrj8nnHL5LLL/m4FLdt6eOLzu03gAmZgATjx/FmOPtHCRX+9Askl2VQWyAbuaiqLogiGDncSPTNA6WW5XUOjr+wluHoRwuczPTuRIX78FOmREfKWr7QF4CqyzOCeNyhath4huUzPEmQglWLw2M5z+m3O33I/ryfnGpqClnO1KWiZwNLRMG37Hmfagivwh0p1d5DJLWSKL0Fv6Pt6j7F151fp7NrN3JnXsW7Jxygvmj1x4G3aMhkDchUoCtYye9oVXLjkk8xruIaBoVO8vvdrHD7+IKNjHWaQcoIXYw8mDRY0eNHORzbDiw4XCIpLZrFo3YdYevEn8XiCHHnth+x/8Wv0NO1AThmAwnCOuWNdjCDjAC8ySIqgYv4FzL7uYwy3HOb0b79FcmTQ5NYyA4+g5uo7cecX0P7Aj1DiCUQ6G5grCYmKO+8iPTLK0OPPItJZN5ErL5/iu65l6LevEG8fUKElrQbl1rz3EpLDUdp+s4dkBlgSaRey8LDmM+s4/lQLrXsGbEG5Kdzc9rlGDrw2zI6Xx2xxLZrakiTzdkvWTfTe9wa59ho/H/jIIL2DasxKLnCZ1ejm1GlVabG6iMA5IHfpGh/1s7w8f/9A1jVkUFs23FVLf/MoHbt6zAG5s0soXlhJx+PZgFyXJFO4djZSwMtYZhBFBJm0/stIj4wSPXpcVVm0nC0+LwVr1jG0dQv6OEVgUj0kt5vSFZvo3b8FOZ2wA4h1G6d5i2nwE+lqJVg93VmN0UyLVRkZRnh9+kCJucqlR0ZxFebb6tQPR0B6LIK7wDwIohPAyPEULl/2X7QPuOl84LIiqF5Uwl3fv4DTr3bxu7/bRSqp6AoJqMCSTsps/uoBnvzcNtbdu5jqFZU2lUWrzykAt/uZwxQua8BbWeToGkoOjBHdf5LQhStMRKm5Zsd27CQ4bx7u/ALDi6B6r0ZPnyQ52E/x4nUm97X2rBg8uZd0Mub8X/y+bSqm5W2zKWiZwNqPbsYXKKJ69kXZOJa0UU1Bd7UYYzY62ndx8PCvqKlYwfrln6K2fDlCESZFwwQpWtyFMReLNqUVex6XjAJTU7qEdQvvZdnsu0kkx9hx4DvsPfJzRkfbzfBihCQHeHEK1h0PXlAgP7+WeSvfxcorPktR+WxaDj7B7if/jbYDT5EIDzrHvYznOjLAiy3YToH8ihnMu/nTCCFx8sGvEe056wg5QgaXy0vdLR8gFR6l67H7IS2b4ltcwXzKbrudkc2vEG9qy4CLqrYE16/AP7uBvh/9jnRK6JlyCeVR+4FLaPvVVsY6Rk1BucWLa2h8x0xe/s89JJKQlF26yyepuKicU8CmOyv5+b+fJRrPxLVklJik4iKhSfsWN5EsBF/8YgF5IcHH/3yIRFp14juBy+xZbk6eStmWOw2kqLmI3EINyH3uwUHkpD0gt6zGz9xNlex54LQpIFcSCo03zaf9+WMosUSm67OMxydRfMlShl/Yrce0IMBVmEdg+ULGXt+ezdmSWVe4YSOJvh7CzSdMyeaMbprixetAkRk4ulMFDidwcYIUgwJjhRw5nSLac4ZgVYNexlqXkQlSI8O4C1QFJVeTIycSKLE4roK8HCVUS49EcBVMnOU2nUgheSeXo0U/BsNBl88v5a7vX0jLth5+97c7SSdlFVaQGOuJ8puPbOHw4y3c8M2LWPnBRTZQUT+dA3CTkRS9rxyn/KpFGVdRVoHRXEOjr+3DVVKAf+5M/RmigYccjhE5cJC81WtszwAUGNz9OvlzFuHJK8yqLJl1iizTu3czRTOWvqnfZsr+99sUtExgw13HmLniNn3kZrNrKNMYG/KkIMu0tLzCsZO/Zc7Ma5nVcCVuyW3qtaNPVkiR5XHJXMiyCWR00AHKCmaxcu57WLvgIwjhYsfB73Lg2P2Ew92GY3SAF4MaYw3WtfU0clJeZIWAv4SZC65jzRV/T8OCdzDQeYTdT/8Hx7b+jJHuUxm1yPjQcXYdmRUTZ9XF6y9g1jX3kl87m9OPf5dod3bEaGtZT7CAuts+xNjJI/S/8rwemKutD81fSGj5cvrv+w1KPKWCiywQskTxe24idqKNkS37s2qLIii6dCnBxipO/s9mVW0xBOUu/fgaRtrH2PdQs0lt0YJyr/2LmYwMpvjtD3tMQbkTuYl8QYnv/6CInbsT/Nd/j+lBuLKi6PAiK4pJaXGyXAG5V92SR2RUZvdLQ5ll9vGITmzuJNwT0QdS9Ehp6i6bCbJC32sncUlyNiD3ymXEm7uIN7eryzLwkn/xWqIHjpIaGjIH5BYXk7doCUNbXzEDg56QDlw+H6XLLqR372YUJa2DC5CFEbLlcwbjGizW146SThGoaZjMo4DUyBDuwiLzQn2/mf9hVB3I0lWoBdli+tQsPWJWWnK5ieRE2qS06MsNZGZKHoc9ZqVsXgl3/GATbbv6eOyzO0gnZdp29PDzu14gnVJ4131XUr++OluHQWUZLwC3Z8tJAArXz82CCoZHlgxjr+wh74IVICTVBWsIwI3s2Yfw+gjNnW9QqdX1yaFBxk4epmT5RpOCrT1nR1uOER/upWT2Ssff7fdu2jP1fKYpOyebgpYJrHTaMgpK6s2gomQVDHT3igJymlOnnqK59UUWzb2DaVVrskqJUV0xxZhoy8YHFqdyOsQYktQVBKtZPusuVs//IKl0lG37v8Xhkw8Tiw5gDdg1qjyTDta1wIvRreNyealuWMeKiz/Nwo0fBlnh8KvfZ9/zX6HrpBo0bI5vMYLUJOFFAZdwM/2id1JQt4DTj3+PaFdbtmeRMX5FhkBZDTXX3k3/q88RbT6tLje4isquvwk5HGH46Reyb4EyeCrKKbz+EgZ+8TTJwWg2d4viZtrH3sHgjiZ6XmsiLUskZDcpWcJTks+yDy1j27cPMjKQtAXlBou83PG3M3nkfzppO5XQlZZcbqIkQhfhGma4+dp/FfJfXx/jxZdipt5DGrjMbnRzujlF2mkExoy5DNtpakthgeDi6/J55r4Bxwy5s9cXU1Qd4NiTzeYMuQGJaZfPov2pw7r64pJkgvXFBBfUM/LibtMgir4FjbjLSxjbugNrQG7hBZuInDxmypBrVVtKll1AKjLG0Mm9diCxxrLgvF5dpgJPpKsVb1E57kCeWZ1xMqEpLYXjlk2PjAIg5VBahFBVgvRYFJfFPeRY3ySVFi041r5cXVY+u5A7f7iJ9v39/PLdL/HgR7cw96o6bv/hxQSr8rIBthOoLEaA6Xr2MKUXz0fyeR0CcAWxUx0k23sJXbAiAyyZ3yADJmPbd5G3YgXC5c4+XzPT8J5teIvLCdbNMq/LPH969r1E8awVeAIFtnP+g5gio5zHNDXK87nbFLRMYNWzLrA0nFojb5wUlFSKI0cfoqNrN8sWvIfK0kWItJxxGykOgGABFYPrRwcFw2RyDVniXDC4krQyRaFprJzzHlbMvYdItJ839n2Dk01PkUpGdHjJAoh6bJMK1p0EvGhxLwvWvJdVV/4tpdWLOXvsRXY9+a+c2vUbxvrPWGJRlGydVnhRsnUbYUZCYvqFd1HYsJBTj3+XsbYTORWXwjlLKVq2js5HfkF6ZMS0zh0MUXbzrQy/uJnYqVaTm6jg6k24CvPo+9mTyGlJ7QatCLz1VVTetJpT//MikdEUKQ1cFImZty0mWBZgy3/tJ25INKcF5a6+oZJ56wr59t+2Ek+5xncTWeJbrniHn49+NMS9fz7Eq6/HbV2hCwsl4nEYHTWAiSXRnLpMMcELwA3vKmTf62G6W6K2DLkeCZbfOI2Dj7XaAnJnXD+PgX3txDsGcOmjP0PxlcsZffUASiJhCsjN27SWsdd2ZNQSdEDxN9Tjr5/O4LYt2cy5mN017mCI0qUb6XzjSVKxMbObCEwg4xiMa5kPdzYTrG5wXGc0rZ7U2Aiu/ALbcqOlR8cQPi+SL3ePHzkSB1nBla/GxkjjQJCcSCN5nAfOHM+MAKNBRsnMQu74wcV4/C6u+cI6Nv31CvB4TMAyGZVFUQThjhGG95+h7ApzAK6aATfjGnplD75503GXlZqUEhRIdvcRb20lf+VqewBuMs3Qvm0UL9+ApGRfMLRtw12thLuaqVx0sbp8yv5P2RS0TGAel1dvLG3En3F7yOkUBw/9ioHBU6xY9AFKCmeqwKIBgckVYweVybiITK4hi7piBCCtnFZ3af4MVs//IItn3krv4DHe2PsN2jt3gJzW1SITvDjEu9iCdSeCF4Orye8rYvq8q1h9xd8xe8WdxCODHNz8DQ689E36WvagpFMGBctQpwN8GOERRQWXhgvupHTuOpqe+iFDJ/aYwSWd3bbq0ptw5xfS8dDPIJkyxbeEFi4mb9Uq+n72K+SxaNZNJDyUfPA2wtsOMbrtsMlNVPHOixAuF00/MOdukV1u1v3dRk481cyp17sdg3Lv/n9zOHsyxu9+PL6byBrfAvDZv8njiit83H7XAJsu6+N7Px5jcEQN0H1xc4zFizwUFTnf1i5D42h1Ec1f6mXmPB8vPtSfHTzR4CJaeUM1A61heg71q9tlpvIFpeRPL6bzuaPZ5ZJMyQVzQQgi2w9nA3IFhC5YQXosTOTwUYwBuQpQuPECRvfvJh2PZNWWjItIg5CKDVfhDgRpe/4+1J5IwrTe5h6yxLRopigyY2dPkTdttg1qbK6mjKXDYVx5DgqKobwcjSEF/Kbl1jwsckztCeYKTJx/BUVBWH1LWj05/F6ai8hpfcmMAu74yWXMvrLe5ErK1ilNrLIg6H7+CIG6EoJza23Bt7IsUJJpwtsOkrfRHICrg8f2XXhravDV1BpUbBVQxo4fQo7HKFqYHYfIrLJspqBuAYGiKiw/7R/OMs/Cc57eruP+E7ApaJnIDMBiDGw1xrGcPPE4o6PtrFr8IQpCNTmBxUlxeVMuIst6q7riBDlaA15ZPJ/1iz5GQ+U6TrY+y/YD32VwqMl0TrniXd4MvJjgzhD3Igk35dVLWLz+Iyy/7DPkFU3j9N6H2f3UFzh7+DmSUYMCMhG8KNnlEhJ1a26getU1tL50H737tpjARft0CQ91N72PRH8vPc88hkiDlBY62JTdcBOS203/rx9GMShbvoZ6Cq+/mL4f/o5Ef0R3EymeAPV/cQ1dT+6nd1e7yU1UuLCWBXcu4KX/t4PhIdnmJiqqCnDH387kwf/uoOlEwqS0aIG7SQ1elCy4yAAuwX9/rYitb5Rz1VU+vvaNMZas7OGTfz3Ibx+PcvVV4zeE1hveGJD7jjsLeenhIT0gV3MReUSa0ml+GlaWcPiJNjwijYSCW8i4JGi4Zi6dzx7FpahBukIouPxuCjctYvilPdmAXEnBlR8iuHIxY69tMwfkShBatATJ72d4306TUmKEEcnjpe6a9xLpaKJ378sZyMjGtzi148ZlWtlYfyfpWJi8utnOt71DPXIkjCsUGvf3VYzQYjENXjRokQKTyL+ioJ9bLkgxHaOljFOvHzCDjVFZAWwqi7EuRRGk/n97Zx4eR3Xm6/erbm0tyZas1ba8b8iLvIFtvGBjMMSYQCAMNxACyWQlk+WZLXcmy71JZiYzGcKdzCQhy+WSZEjIQliSEMBmsQnGu+VN3m1Zlm1JtiXZ2qXurjr3j6rurmq1FsvCQtJ5n6eebp1a+pS669Svvu2ELM6/coDcNXNQJK7N0lx6HNURInBD57L9Kqxo3rmbjIXXu8YKou8vl25lRPF8fCmueYacJXiploaKMtvK4jruNac3rvyeFk2f0KKlJ+IEizu9WZSiumoX1TW7mXPdhwik5jpCAq9gibOueCwqnnW9WEz39l7rSuIJGGPixaf8TBq9nGVzPs+IQCGlh37GviO/oq2tjoTBum5xlSjTKE68JEpvjncdoSA9kM/UOR9g0W1foWjaKi5W7mb3y99ypgqo7Sxe3J8XeR8X61I4exUTVz5I1bY/Ule2NSpcDJOocEnKyKboA49wec9WGkq34w7M9flTyH/wIVoPlNGyZZdjibGXEetW48/JovbJ32OGJeomSps9mdy18zn2+HraWkyPm2jWpxeRFEhi07dLE7uJ7hlN8dIsfvg/T9Me8nlK/CeKbzFd8S0mUFTk40tfymT3jnz+4/GRlJebnKowWXdHF+m4LtyF5tysuTuT5gaTPW81eGq22HEsJgveP4bD68+iwmbUPWSIxaS1U2mvbebS3kq7rL84kyiumUfbodOEqi9Gg3TFUGSsWkT7wWOE6+tjAbkC+H2MXHQjDTs2237/iJUlztqSkpPPmFv+gpqtL9NSc8orXNwP9XFWE+WyWDSfOU5Kdj7+EVlAYpHiRilFuKUZXyA9erxEWG3tSBeiJbaNPTWDkZrcbTVc+3M7f5a7fH80PRnvTMyJrCjx6xK6heKsLNHtiAma85uOE2pqJ2/tXBIF4KKE5rf3kbagGElNjYkWZzzoOH7Sqc2ywP7KLKJWmGB9Ha0Vx8ieu8QZX2L7ioILB94ikFtEZsHk2JigGVYMCdEiIvNE5E8iUikibSJSLyJbReShqz52XGxHNDjVUjQ1nuPYsT8wbdJasjInxIRDRDCYLnHiiRlxLYnESE+Lx8zoXTzWly7ES0pSBrMm3s2imZ8gFGph697vcezUK554l4hY6ByL43X/RINqE80o3Y3rSCyF35/G2EkrWLj6S1y3+CO0NV2gdMNjnNj1Wzqa6j1uIVzWFU96tEu4jJq8gPHLPsjZzc/RcGJ/J4uLYUL62CkUrL6b86/8jvbK057A3NQxReSsu5P6514gVF0bFS5iJDHq4/fTuvcYTZv3Y5oxN1HhI7eglOLkT972ZBORksyS/7WSExtOc+T1qphwibqJknjgG9OpOd3OCz+x3UQhfHbFXGdixe7iWyKzDPmS7MkVn38uh2OHC7huhl2IrCdXf6JCc1nZwo23ZvD2HxuiriH3NiW35xNsDXN6c5XjPrJrtgRy0ihYMp6a9YeiAbmGKAJTC0iZWEDTxtLoJIqIImX6RPyFeTRt2Y47IBeBzCVLCDVcpuXkkS6tLQhkFS8ke+YNVL76NOH2Fq8o6cJF5F7XdPYY6RErSzdWmghWqANMs5OlJT5uxurG0hLdp6MDBCS5d0XjunIPddlXlzXFLV7cf3dltXFbWSLbxVfAPfubneS/rwRfRsAZKrzuoXBTG617jthZQwlcQ807dpE2Ywb+jEzXQ429NO7bQXJOAWmFE2JjizMGmK3N1B3dSf7slUSKfMpAWSyuqhqus2j6xJAQLUAWcAb4MnAH8DBQATwtIl+9qiO7VL47vTkUbKXswDPk5c6kqHCxIwi8giWheyhqYelBqLh/3N25ieJFT8T64hYv8aLGufONDIzh+hkfdeJdjrJlz3c5c24LygrTbbxLnHiJzzbq0XUUL2AwotV2Zy56hNaGavZs+DYndj8bnaSxuzRod1vetCWMWbiW02/8guYzx+11ptdVNGreckYUz6fqdz/DbGyKxb+YMGLpClImTqLuF79GBU1HIQjJYwsZefct1P3sT4TqWqLxLaSmMf6L66h5aS+1u8543ERZxYXMeXgOm761k4baEO1WEh3KT7uVREj5SM8P8KGvTuG571dx/HBHNL4l5AiXSHxLyHnqDSojoXAxnYE7Pd2IuZHi1iUivtAcwE13ZLJzYxOhtnDURRSJa8kY4af45gIO/qmyU82WietmUPPWCazm9tgkij67Qm7Dpn1g2uWIPQG57+wkEpAbsab4R4yw05+3v+0SNJ2tLQiMXnUPRkoqZ17/FZHCdPb8RN4bcrQtIk5Mk9aqcts1FH/vjhc5TpvZ2gKAL737TCPV7oiWbkwAqj2IkZKMdBeBG9u6F9vEcJfbjxAvXuKtKV1ZWRIF4NbvPkNLRS2F91wfbevkGtpahhFIJXXWtJiFBduqabUHad13wC7b7xIrKFCmRcP+nWSXLMYgJnIiY0vtwa0kpWUyanxJ1E2s3UPDjyEhWpRSm5RSn1FK/UIptVEp9ZJS6gFgO/Cpqzm2200RsSRgmRw69Bt8viSKp9xtq/5oqnCcUHALlq7ESnysimm5btD2392Km3gBEy9eTFefXO1234SC7GKWzv4sk0avoPzsRnbs+xGXG051H+/iEi+Jso26dB11E/tiKBiVX8zcFZ+neNEjtF6uonTDv3Nq7+8xg+0uC4vLZRR9GnO7ilaTV7yMU68+ZU+06BY6pl1hd/Sa+/CnZ1L9/NMQNokE5hpKyL/vfkLnL9D46ptOUC7RbCJ//igu/uj5aNE50zIIzJlC3h3zOfadV2ltDHncRNd9bCHpBem8/s2dhEzpFN+y4M5C5q7K5vt/W0FrK3GZRN5JFTsVnsMWLia2OOlOoHRHJK7Fh8WNNwewTMX+rc2xLCJXQO6C94/hxFs1BJs6PDVbxi4bhz8tiQtveSdRzF41G6uljbb9x+1aJAIikLF0PqqtjdayQ9EicxFX0cgbl9N64igdly56rS2uui1KwEhOZty6R2g+c4xLh3d4BEdEqHisL85r3eHtWOEw6eOmui70zv8Xd/Cu2dpq/68C3acpWx0dSKorrigiXlwixuoIISm9Lc0vqATfa6JKuFbcSXQV32K/7yxYerKyWAjnXiglZ9l0bwVcXPdhJTRv2W9Pjmj4PMIDBW37D4JhECh2zUPkWGHaTp0g3NTIyJkLvQ+LSmGFw1w8uJn8mSswxOcZewYCpRTKsvq+aNHSZ4aEaOmGWqDralu9IXJDdN18K05tpKGhkpLiB/EZyd7AWwtXvEoCwZJAePRGoFyZkOn8WYkCdt0uI0N8TCi4kaVzPkdmoJDdB5+y411aa4l3GSUSL/EBuwldR72JfbFc4mX55ym+4WHqqw+yd8Nj1J094IjDrqwuTtCvEopuuIuc6Ysof+VJW7iY3m19vmSK7v4o7efPUffm+lhgrgVJI7LJve9+Lq9/jY6j5TE3EX5yPvkh2o9U0PDqjujcRGHLoOCjtyLJfk/RuaDpR/mTuPHrKzm7vZr9L5zuNDdRmCQe+OYM2lssfviVSoJWLL7FnUkUclld4oULeK0u7iWeyDxE0b9do74PRSAAJYsD7HmrMaGLaMbyUaSk+zjx+hlPzRZ/ksG426ZR9artIopMopg8MoXMJdfR+GZp1NKCoTAyA6QtnGNXyHVZUhBImTiBlDFFNOx4x2ttcbZzb5uaU0DBjWupevv3BBvrE7uGXILl4t63qNr0HKNvuhtfqi1A4l08iTDbWsEwICWBIHEPF8EwktS9IFEhE+llGrP4BGWphO4cT1E5T8Cs16rSOaDW6CRwIsfwTozotbK01jRRv72cgrvmOxYW4qwsQqiuiY6jp0lfMpdEZftbdu8hfc5sDF+SV5hY0HBgF+mTZ+APZHYKwG08VYYZ6iB3qiujyEr4FWiGOENKtIiIISJ+EckTkc8CtwPf7sV++SIyy70AU8AZx1yxGXW1x6ioeJOZ0+4lkJoTC7y1rDg3kOu9aSWOP3FbZxJYXHpaOu2fSLy4xI0nHTpO0ESsMSn+dGZPvodFxZ8kFG5l677vcfTkHwkFm7sVL50Cdl1xL/HWl65iX+KtLwaQUzCTBSv/lvyiBRzb8QuObPkpHc2XvFaXBO4iQwnjFn0gJlzOlXeyuKRkjmLsugep2/oGzUcPOSLMzijKnF1C5uIlXHz6GczGtqhwScrPJ+tD66h/5lXaK2vtoFxLUMmpjP+bu7j45mFqNh33zE2UPiGXBX91PW8/XkptZWunNOiUrFQ++V8z2bnhEi/9d50nvsWdVWRFA3I7W1zcVpd43G2R1On4IFz334tuTmf3piaUUp1cRMlJwpz3jeHQy5VRS4stUkwm3jGdywdraD9T55lEMefWuTTvPobV2BS1wCCKjJtuoP3gMUKX68GV/owII5Yuo7F0B2ZbS+eaK3FuopwFK0nLG8vxXz9O3eEdeOYwclAoqt95iep3/si42x4kd96K2PHc23UhXKy2VozUtB7jS1Qw2AvREkaSelea3/AZKDPm8EtkTXGLlFh7V+nMrhiXOCtL9HhR11CcleWlA6SNzyF99vioWAG8rqFtZfhGjSR5ynivJUTZ8y21HTlK+jwnADc6JtgWqqYj+8madX20ze36rTu8jezJ8/AnpUXHXJ09NDwZUqIFeAIIAReA/wC+oJT6cS/2+yxQFrf8HvAIlnCwhcOHf8u4sUvJz5npinFxiRS3eLGsTrEm0Zt0gvYely5ruPRCvHQhUhJaY0zFyHQ73qVkyv1caijnndLvUnFmE1a4o3fiRXnFS6+tL84gFbG+iKXw+5KYWHwH81Z+kXBHK3tfe4yqo5vAsmIDm0v0xAuXUVOv59SrT9FRd8ET4yIWjJg0i5zFq6n+/S8J19V7RE3OurswUlKpf+a3qHDs/DJuWkzqrKlc/P6zmO2WI1wM0qaNo/BDyzjx3ddoudhKyPQRVj6Clo8p980hb3Ye67+2nWCQTm6i0TOz+PD/nsoz/3aG/TtaE9ZviQTmujOKIsIFvFYX99IT7hLyPiyWrAxw4VyIqhOxQnORdYZYzH//aCp31dFc02KnRBv2RIqjZuQwYmoO1esPemq2ZM6dQNKoTJr+vC8akCuGImXGJPwFuTRv2dkp/Tlz/gKM9HTqt2zsbG1xWVCUgPgMJt77GfKuX03Vxt9R/uKP6Lh8MbaNMjn7xm+oO7CZie//BFnXLexct6WL9xHM9jZ8aYnnCvLsGwp1G2ArolBhE8Pv686wE9veZ6DCVs8bOnjK+zsiJV6suNObIySysrgJBy1qXj5Awbp5gEFXrqGWrQdIXzwH3DEpznXZtvcARiCNwORYlVuUPct985EDiGGQOWWWyyVvL8GGOpqqjpM3bYnr+ib6MDQguJMh+rpo+sR7TrSIyCoRUb1c5sXt/i3gBmAd8BTwfRH5u1587BPA7LjlbohdPKIU5SfWk+QPMHXCmuiNO+bqSCRe4sSC4+JJJCwsK0Rj+3ma2i8SDLXaT1eJfujdiJnujt+ty8j0tkXjXYD8rBksmf0o08ev4UzNdt4p/Q9On30LM9SGe8TyiJdItlG866iXAsZtfXGLl4yMQkqWPcqkWe/nzJE3OPLOU5jtrd26iwwljF98D+kFkyh/5UnM1pbYdo54yV/2PlLzx1D13M9dcxCBz59MwQMfoe3wEZrf3hYrOqcMRn30PsKXGql/9o1otdywZZD/F8tJHp3N0cc2ELKEoOkjbPkI4WfJ127iUkUj7/z4iCcNusMJzL3hnjGsuC+f737hFBdrwp3iW3oSLm6rSzyJ2nxxI74h9lZjJyYzdlIye95qtLfDcsr72y6iCXNHMGpcgKOvnHZmhVbRui0T7phB1YYj+KxwtGaL4ReyVpfQuLE0cjGBYAfkrriBli27UMqKS3/2M+qW27i87W3CzY1dWlsi78XvI/eGW5j20N8DimPPPMaF0jcJh9qpePlnNJ46yKR7HiVz4nWdRUki91DcNlZbK0Za9/EsShQqFMboISvoSiwt4hO7blAvcNdZSYSFeARLd1aW6PaOOKndfAKzLUTurbOdbTu7hoLV9XScOENgcQke15ATs9JSuof0krmIK9YlIj4aD+wmc0YJPqeYp9tCW3dkO6lZhWTkTuhkvdUWi+HHe060AEeBT/ZyqXTvqJSqVErtUkq9rJR6FPgJ8K8iktfdByqlLiilDroX4CTEbrSNDWeoqt7FjCnvjwaCueNYIjdrcYuEOGtI5L2yLFqCl6hqOsSh2jfZWvUMr51+gi01z/BOzS9489yP2XDme2w893/ZUv0MpRf/wLnmg4TNjp4FTE+Wl0RWF/c5xAXqYtkF3IryrmfZnM8zcfRyzlRvZ3Pp/6H89OuEg53TpOPr1MRbX6KxLwkETLz1xWNFcQJlx4xfzNwVn6O95RL7N/4XLZfOxcW1xAkXDCav/DA+fzKnXv0ZKhiKxrjY5+ejaN1HCDc1cHH9i4gVKzyXUjiaUXfexaUX/kCosjoqXHwZmeR87D4aXtpMS9mpWBq0kcT4v7mLxgNnOPPifkxlEHRiXPy5I1n61eWU/vQg5dsu0mHFMoki9Vvu/fI0copSePwLFbR1GAmFS6IaLlEXkTOGW3GLm4QCxmVnN8Ri0ap0dm1q8sxFFFnnF5h751gOvlSJONaXiKtowm1TCV5qo770tF1kLlKz5ZYSgmdr6Th+xhYzhrIr5C5bgNnUROuBgy6Lii1qMuYvICl7FHWbX+/S2hJveUnOzmPSvY8y5ub7uLjrDQ796Mu011Yx5f7Pdy7Z7xZCiXAd22pv9VpauthPBbu3tABXFtPi92HFWVoSzzHkHco7uZE6uZXig2+9WUedXEN/3E/e6mKMQGpMrIDHNdT05z0kFRWQPCFW5dY+YQhfbqL9RDkZ8+Z7XUMKwo2NtFQcI2uWq9icM0Yo06Tu2E5ypy9GkNiDjjPGqIFKHY7MH3Q1i6ZPvOdEi1KqWin1ZC+X+h4OtwPwA5Ovqk+WxfFjL5GfO4tRIyNTrMduyuK+0XchIiLv61oqeOfc07x97qccrt9EW7iBvNRJLMi9k9WjP8HNoz/BsvwHWZh7F9NHLGV0YDrJksrhS2+xsepJ9teup67ttH2xus2MyvXak3jpbaBunKDxG8lMKLyR5SVfZNq4NVTX7rPFS+UbhIItXvESF7fSlfXFLWASWl9cx3CbjNPT85i74nOkjxjD/k3f5/zJrUSCdO3P9woXvy+Vqbd8nGBjHadf/yWErZjf3LRnhC6662Eu793O5Z1bnHW2cBm5ZCmB4plc+OnTWG0dtnAxhbSSYjJXL+biD54lfDk2qaJ/dD5Fn1zDqR9v4tKxOk8adMHyKRTfX8xrX9tKQ22oU3wLSUl8+j+Lqalo5+nHqmMuIuVOgY7FuERuOu5ZoSNWl3jcbWYXd92IeFm4PMDh0lZC7XYce2Quogjz142mtryJ+pMNHhdR+qgUCm4cT81rR/BH5yJSpIzOIr1kIk2bSkFUdBJF38gM0hfPp2nj5pgIiQTb+gyyb72dxl3bCDc1JLS2JLK6YAjZsxcx7SP/wIS7PsGU+z9PSna+fXnEuYWi9BCMa7a1YvSQOQTY7qGIFSWaORS/zRVaWhLcmOODbaP9dAfcOpaV+IDdxPEuiS0ukQDchn1nyLu9xGNZAdcQYmFnDS2bh8c15Cxt+8vwZWSQOmGiq91xDR3ehz89k0DR5E4BuM1njxNuayZn8gJvxpAzHlw8tbNX/8f+xj5n1fclwfXZW0QkQ0S+KyJVItIuIntF5EP9d3bvbd5zoqWfuRl7HC/v8xGU4nzNXppbqpk68XbXTZbYzR688SEuQRC54bYE6ymteZGd558jK7mQ5YUPs3rMp1iYexdTRywiL3UCyZJKiqSS6R9FbnIRY9NmMCl9HrOzVnNz4V8yO/sWQlYbuy6+yFvVT3Hi8lbCZnv3lhdILFzc/aSbc0kgaAzxUZS3kGVzPs/0cbdRfWEPm3d/h4PHfkdD42lUVJD0zfriedpyiZeYELP3TzJSKF7wYSbNupPy/b/n+I5nsJzU6ETCJSWQzdTbP0Vz9QnO/vk5MC3PNuljJjN6zb2cX/887adPxdYpIe+D94NpUv/bF6M+eiwh6/51GBnpXPjR85gm0Wq5WbfNJ2vJNA7/80u0t4adonN2cG7JZ28gkJfO+q9uIxR2BAkSFTAZ+QE+/p3rePW/z/P2y43O+lh8SySjyJMKHSdcICZeuhIx4K3V4ra2zL7BTn0+uqc1VkHXlfqcOzGdwutGcGx9ZSzDCFugjL9tGhfeKUe1BaMuIhFF9pr5NG0uc4qrOZlEosi8dRkdx8rpOHcuamWJvKbPnkNSTi7177zZSaSoOMHiES6APyOTzMkz8WdmdZ4BOn6/HjBbWvAF7HmHurvf9BTTAqDCvbe0GD4Dy/ny4i0spvIKEnd7IrwZRp2tLNH2OFFzYdNRUgpHkn7daGcb5zxcAqbjVA3h8/UEFs3B7RqK/LPaDhwkMGsWIobn+kZB05H9ZM4oQYiti6yvP17KyHHFJKVkxMYEZ1GWRd3Z/b36P/Y7A2tpeR54BPgGsBbYCfxKRB7shzN7zzMkRIuI/EREviMi94vIShH5oIj8GvgI8LhS6mJfj22Gg5wsX8/4sctJS8myG92Bp+4bu3sd9o0yFG7jSO0mNp/9OSGrg6WFDzJ71C1kJGXHhpv4CokJhIdP/IxOncrCUXeyavRfMiFjHmdbDvHn6p9zunEvljK7tro4fYlv65VwcbVHxYvTFhUvc7/I7Kn3EQw1s6vsSXbse4KzNTsIhzs8/bka8dIp5iWyDmHshBuZu/yvaK6vZP/G7xFsuRQVLvFPfIGRhUxZ8wnqj+/m/I5XPbEzYkH23BsZOecGqp57GrO52X4atMCXmkb+hx+iZVcpzdtLo9lE4ksm99EHaD9YTsMrOxwPm2ApH+M+dwdWyOT4f21EKSHsmNyVP5mb/mUV58vq2PGzo1GxErOmGMxYOop7vjCOJ75UweF9Ha4y/97Cc5GMoq6ESzy9GSp9WGRmCNPmpHJoe1O0DWKpz4ZYzH7fGI5sOGu7iBzBAjBm+XhEoHbbSU8WUdaNM8Bv0Ly1zO6lgAgkjx9NyvTJUWuLexGfQfbNa2jYtZVwc6NXZLhe4wVJl1Gu3QiU7sSL2doSK+HfzfFUMNS77CF/by0t3uyh7khkQQFbrLjjWBLuizf41u0auvDmUfJuLkbEW8NFubZv2VZG8uSxJOWNshucoUOUYLW203b8BIFZs13t9jbhliZaz5QzYnpJzDDljAFmsIOGigPkTF4YGwcgel03VB8l1N7cq//NUEFE7gDWAJ9VSv3YqUv2SeA14DERufIpwQcZQ0K0AFuBRcAPgNeBJ4FC4CNKqS9dzYGrqncjCBOLbgK8VpYobssEsfcXW8r585mnON96grl5d7Ao/z5GJOXFtnGLlTiR4iFuXYqkMSl9HisKP8LEzAUcb9jC5uqnOd96IjbAdSdc3Ouh18Ilcv5u4QJ2zEtBdjELZzzM0rlfIGfkZMorX2fzzn+n7OizXKw9hBkOesSLp2/diBd7O9c+VmfhgoKMkUXMW/lFkpLTObDpCdobL3ieyiIDoSjIzJvIpFsf4fyeN6k7uDXqJooIl9G33IMvLY2aF5+x3UjOZ6SOm0D22rXU//Z5QucvRtuTRheQ/dCd1P3yVdpO1kT9/RJIY8o/3M2FNw5zdsMRLCWELR8WQmDsSJb9441s++EBzuypi1pbIu4fSwl3fKaIRWtH8e1Pn6T6TBgrWoLdiIqTRG6enoRLdLseTAwli9M5sK0Fn0QsKd4jzlwzmkuVLdSdbIwG8RpikZTqo/CmKVS/4S00ZyT7yVpZQuObpbE5dxyLSuaa5bTs3IPZ3NxJPKTPKSFpVA71m9/slDmU0Hri+jthcG0vLCvxfTB7MVki9N7SYlxBnZb4mJbeEBEqCYvQxbV1Eiuuf1BLZT3NJy6Qs6o4ul3k9x15b1mK5m0HSI9aWbyf13boKOL3kzZtWtSIZu8MzUfK8KWlEyiaHHu4cGioKAMxGFk00zMWRKgp30ZWQeIJL99trso15Cx95B6gGXg2rv2nwBhg8VWc1qBgSIgWpdRPlVI3KaXylFJJSqlspdQqpdQvrvbYNTWlTJl0eyyq3YUkEhnO3zVNRyiteZGizFksH/MwhWlTYzUeutjHdT7RpROuNp8ymJy5kJsKHyEvdSJ7a19mx4VnaWir6XzcK3wvidrjhVqCvgdSc5g2/naWL/w7iqfcjWWFKTv+LG/v+DfKjv6WC7VlmGbIm6roFknEi5UEwiUBouy5jGYu/QTpI0dzYNMTNNefTWhtQUFWUTHjlt3LubdfoKWq3COADH8yY+95hNbKU1x6Z6PHzz5y5SpSJk6g9qlfooLh6D4ZK68nsHAm5//zt5itwajZPDBjLOM+toJj332DpsrLnhoYk2+bxHXvn8zL/7idlsuhqKUF7NLrFj4e+eZkiqal8U8fP0VDg4UZN1me/eq1trixunjvJr5mS4S5SwIc29dGR5t3T7t6riJvfIC8qZmc3HQu2h5h7K3TqNt+mlBDm7POdhFl3TqP9qNnCJ47j7hERFpJMb6skTS9vRXA410QwyB71Roadm2xrS3xdBejEnnfk1DpYb3V6sS0dGepUcqJV+lCtDg/4CsLxDV6nT3UE4nSnruKjYlYUqo3HCYwMZfARPthy21diVyawVPVhC9cIrB4tvcDnWujdX8ZaTOLMXwu65JznKbD+2zXkBid9rt0vJTsSSUY/qRYO/a/MdhyiUs1h8kdW9K3f8bVMnDuodnAYaVUfNHU/a71Q5re2SiHJ8kAGemFZAQKaG6psW+cUReFFZ1fKDrPkBOQqyxFxaWdTBgxnzEZM2kNX3buGK6bv9vC4qar8Sl+sIyM+IZ9sRelzyI3dTwVTXsoq3uNkry1zmAtse0Tvu96m2gJdLe0ddqUSKzdffch9pSaESggI1DAhLEruNxYQf3lE5Qd/R2FeSWMH7vMsy3xn5Vg/hjPk7ThPO1F2gyi/R1ffDuVh9dTdezPjJ25GmU4+xqgDIkGe6YXTGLExNlcPrEXX1oAy+ds47OPl7viNppPHCJtRjEk2edr+SBrzS3U/u552g4fw58/CnwK8SlGrF1K3f97keY9JwhMyMHvswj7TEZeP5mGXeVcfOckfjWedjFJ8Zm0GmGuu3c6tYfrOPl2NeNmZpJihPGLRbKESZEQfjG5/6/H8ORXKti6oYFZc1NJEhMRiyQs/GLiwxYFkdTjSJyKW4wI3p9WROSAfQMLKwMz+t5HWJlkjPQxY34aR0qbycgLO1MTdNChkggqPx2Wn2k3FRBsDlF3siFae6bd9JM2KpWsWYU0lJ0jqTCHkGUQCvvAZxCYP5X242dJNg0sU1CmASakL5qP2dBAsLrGSUe3A6FFQXJ+ASljxtN66jipeWNjLj1FTOxasZPstvBYnIvJEwsTEUvO79AueKdIKRqHAMHzNfZhDewU7UjQsKFQmKTOnI7V0UHw3Hn7dyH2b0NEYRh2HI8vOwMRRXvlBXxOu88JWrb/tlPMfaIIjB6BL9lH46l6DJztsN1t4mwjru/c6EbZu1OZlSNalDLskDgE04qU9renpzAtg+ClVnJXTKe1otaOjbJ8dhVoJVimLbI7KqpJWzAD1REkePY8yhK7QJAldtA6kDppIsGammg8mpgCYYX4k0gdM5722hqnKjWICZgmgpBeMJm2SzUYlgITDCc+rfVSFSPypuDzRyenTO7yxN8FWmnp+vfV2/1tpiQoWHhRKXWhi11zSByjWe9aP6QRPQdCYkTkLiIF5jQajUbzXuZupdQf3u0PEZExwBEgsx8OFySx2PqGUurrXXz+MeCkUmptXPtooAr4R6XUv/VD396zaEtL17yFXWDuDPaPK54p2KLmbpyaLkOU4XCew+EcQZ/nUGM4nGdP55gMjMMer991lFJVInIdkN0PhzNI7LXtLnGkjsTWFCcCOmpxGbJo0dIFSqkGoEvl7jLpnXSK0Q1JhsN5DodzBH2eQ43hcJ69PMc916g7gC1csK0aA8EB4AER8cfFtcxxXssGoE/XlCERiKvRaDQazTDgBSAD+GBc+yPYQmr7Ne/RNUZbWjQajUajGQQopV4RkdeAH4rICOAE8ADwPuAhpVRv5kgd1GjRotFoNBrN4OFe4F+Ab2LHshwBHlBK/XpAe3WN0KKl71zELqPc52q7g4ThcJ7D4RxBn+dQYzic53A4xytCKdUMfNFZhh065Vmj0Wg0Gs2gQAfiajQajUajGRRo0aLRaDQajWZQoEWLRqPRaDSaQYEWLRqNRqPRaAYFWrT0EyIyT0T+JCKVItImIvUislVEHhrovvUXIrJaRJ4SkSMi0iIi50Tk9yKycKD71p+ISKaI/LuIbBCRiyKiROTrA92vviIiGSLyXRGpEpF2EdkrIh8a6H71J0PtO0vEMLr+hvxYquk7WrT0H1nY8xR9GbgDeBioAJ4Wka8OXLf6lUeBicB/Yp/jF4F8YJuIrB7AfvU3OcCngBTgxYHtSr/wPHbFzG8Aa4GdwK9E5MEB7VX/MtS+s0QMl+svi6E/lmr6iE55fpcRkW3AGKXU+IHuy9UiIvnxU6aLSAZ2VcYypdStA9Oz/kWcCU+UUkpEcnFqRXQ18+p7GRG5A/gT8KBS6leu9g3ALGD8UKiiOZS+s64YLtdfVwylsVTTd7Sl5d2nFgj3uNUgIH7AdNqagUPYM60OCZTDQPejn7gHaAaejWv/KTAGWHzNe/QuMMS+s4QMl+uvG4bMWKrpO1q09DMiYoiIX0TyROSzwO3Atwe6X+8WIjISWAAMyVlmhwCzgcNxM8IC7Het1wxShvL1N9zGUk3v0GX8+58ngE8774PAF5RSPx7A/rzb/ABIx54LQ/PeIwcoT9Be71qvGbwM5etvuI2lml6gLS0JEJFVTvZBb5Z5cbt/C7gBWAc8BXxfRP7uWp9DT1zlOUaO8U/Ah4G/VkrtvqYn0Ev64zyHAN25TYa0S2UoMxiuv6tkUIylmmuLtrQk5ijwyV5uW+n+QylV6Wp72YkP/FcR+blS6r006VefzxFARP438FXgK0qp7/dnx/qZqzrPIUAdia0po5zX+gTrNO9xBtH112cG0ViquYZo0ZIApVQ18GQ/HW4H8BlgMu+hmUqv5hydAfPrwNeVUt/qz371N/38XQ5GDgAPiIg/Lq5ljvNaNgB90lwFg+n662fek2Op5tqi3UPvPjcDFonjCgYdIvI17AHzn5VS3xjg7mh65gUgA/hgXPsjQBWw/Zr3SNNnhvn1N6TGUk3f0JaWfkJEfgI0Yj8NnAdygb8A/gfw2FAwZ4rI3wLfBF4F/iQiS9zrlVLbBqRj7wIishY7wDHTaZopIvc5719WSrUOTM+uDKXUKyLyGvBDERmBXdPjAeB9wENDoUZLhKHynXXFcLn+hsNYquk7urhcPyEiHwM+BhRjV3RsBvYBTyqlfjGAXes3RGQTsLKr9UopuXa9eXcRkQpgQherJymlKq5db64OpwDZvwD3Y8eyHAH+VSn16wHtWD8zlL6zRAyX6284jKWavqNFi0aj0Wg0mkGBjmnRaDQajUYzKNCiRaPRaDQazaBAixaNRqPRaDSDAi1aNBqNRqPRDAq0aNFoNBqNRjMo0KJFo9FoNBrNoECLFo1Go9FoNIMCLVo0Go1Go9EMCrRo0Wg0Go1GMyjQokWj0Wg0Gs2gQIsWjUaj0Wg0gwItWjSaYYaI7BORZwe6HxqNRnOlaNGi0QwjRCQdmAVsG+i+aDQazZWiRYtGM7y4AfChRYtGoxmEaNGi0QwDROQvRWQ/sMFpek1EXhSRwoHsl0aj0VwJWrRoNEMcEXkc+AHwa2APcAT4e+B9wK8GsGsajUZzRWjRotEMYUTkHuBvgI8qpb4FjAG2KKV+APwSWCUi+QPZR41Go+ktWrRoNEObLwB7lVK/ccRJEbDLWXfCec0ckJ5pNBrNFaJFi0YzRBGRHOAm4CWn6XrnNSJaxgIdwLlr3DWNRqPpE1q0aDRDl6nY13hElFwPhID9IiLAncBLSqn2AeqfRqPRXBH+ge6ARqN512hyXic5r9cDZUqpDhH5K2Ac8MiA9Eyj0Wj6gBYtGs3Q5TBwAHhURA5j12g5ICL/BPwD8BWl1FsD2UGNRqO5EkQpNdB90Gg07xIiMgn4MXZsSwoQxBYy31ZK6VL+Go1mUKFFi0YzDBCRDwAvAHOUUmUD3B2NRqPpEzoQV6MZHiwCmoFDA90RjUaj6StatGg0w4PFwC6llDXQHdFoNJq+ot1DGo1Go9FoBgXa0qLRaDQajWZQoEWLRqPRaDSaQYEWLRqNRqPRaAYFWrRoNBqNRqMZFGjRotFoNBqNZlCgRYtGo9FoNJpBgRYtGo1Go9FoBgVatGg0Go1GoxkUaNGi0Wg0Go1mUKBFi0aj0Wg0mkGBFi0ajUaj0WgGBVq0aDQajUajGRT8f7eZF/9tAF/wAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(dpi=120)\n", + "\n", + "im = ax.imshow(\n", + " A, interpolation=\"bicubic\", origin=\"lower\", extent=[-pi, pi, -pi, pi]\n", + ")\n", + "ax.contour(\n", + " A, levels=12, linewidths=0.75, colors=\"k\", extent=[-pi, pi, -pi, pi]\n", + ")\n", + "ax.set_xlabel(r\"$\\phi$\")\n", + "ax.set_ylabel(r\"$\\psi$\")\n", + "\n", + "cbar = plt.colorbar(im)\n", + "cbar.ax.set_ylabel(r\"$A~[k_{B}T]$\", rotation=270, labelpad=20)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "a-LGmeZ_3_m-" + }, + "source": [ + "Lastly, we plot the height of the gaussians as a function of time and observe that their height decreases at an exponential rate as expected for well-tempered metadynamics." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 457 + }, + "id": "SI_fhUW9CGlP", + "outputId": "5d32f99d-4911-44bb-9d89-69c3e6212cb7" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "_dt = dt #method.context[0].sampler.snapshot.dt\n", + "ts = _dt * 1e-3 * numpy.arange(0, fe_result['heights'].size) * run_result.method.stride\n", + "\n", + "fig, ax = plt.subplots(dpi=120)\n", + "ax.plot(ts, fe_result['heights'], \"o\", mfc=\"none\", ms=4)\n", + "ax.set_xlabel(\"time [ns]\")\n", + "ax.set_ylabel(\"height [kJ/mol]\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "R6rEuwWAZ8Qp" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "collapsed_sections": [], + "name": "ADP-Metadynamics.ipynb", + "provenance": [] + }, + "jupytext": { + "formats": "ipynb,md", + "main_language": "python" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/openmm/pivcv/alanine-dipeptide.py b/examples/openmm/pivcv/alanine-dipeptide.py new file mode 100644 index 00000000..17383dbb --- /dev/null +++ b/examples/openmm/pivcv/alanine-dipeptide.py @@ -0,0 +1,274 @@ +#!/usr/bin/env python3 + +""" +Metadynamics simulation of Alanine Dipeptide in vacuum with OpenMM and PySAGES. + +Example command to run the simulation `python3 alanine-dipeptide.py --time-steps 1000` +For other supported commandline parameters, check `python3 alanine-dipeptide.py --help` +""" + + +# %% +import argparse +import os +import sys +import time + +import numpy +import pysages + +from pysages.colvars import PIV +from pysages.methods import Metadynamics, MetaDLogger +from pysages.utils import try_import +from pysages.approxfun import compute_mesh + +import numpy as onp +from jax import numpy as np +from jax_md.partition import neighbor_list as nlist, space + +import matplotlib.pyplot as plt + +openmm = try_import("openmm", "simtk.openmm") +unit = try_import("openmm.unit", "simtk.unit") +app = try_import("openmm.app", "simtk.openmm.app") + + +# %% +pi = numpy.pi +kB = unit.BOLTZMANN_CONSTANT_kB * unit.AVOGADRO_CONSTANT_NA +kB = kB.value_in_unit(unit.kilojoules_per_mole / unit.kelvin) + +T = 298.15 * unit.kelvin +dt = 2.0 * unit.femtoseconds +adp_pdb = os.path.join(os.pardir, os.pardir, "inputs", "alanine-dipeptide", "adp-vacuum.pdb") + + +# %% +def generate_simulation(pdb_filename=adp_pdb, T=T, dt=dt): + pdb = app.PDBFile(pdb_filename) + + ff = app.ForceField("amber99sb.xml") #, "tip3p.xml") + cutoff_distance = 1.0 * unit.nanometer + topology = pdb.topology + + system = ff.createSystem( + topology, constraints=app.HBonds, nonbondedMethod=app.PME, nonbondedCutoff=cutoff_distance + ) + + # Set dispersion correction use. + forces = {} + for i in range(system.getNumForces()): + force = system.getForce(i) + forces[force.__class__.__name__] = force + + forces["NonbondedForce"].setUseDispersionCorrection(True) + forces["NonbondedForce"].setEwaldErrorTolerance(1.0e-5) + + positions = pdb.getPositions(asNumpy=True) + + integrator = openmm.LangevinIntegrator(T, 1 / unit.picosecond, dt) + + integrator.setRandomNumberSeed(42) + + # platform = openmm.Platform.getPlatformByName(platform) + # simulation = app.Simulation(topology, system, integrator, platform) + simulation = app.Simulation(topology, system, integrator) + simulation.context.setPositions(positions) + simulation.minimizeEnergy() + + simulation.reporters.append(app.PDBReporter("output.pdb", 1000)) + simulation.reporters.append( + app.StateDataReporter("log.dat", 1000, step=True, potentialEnergy=True, temperature=True) + ) + + return simulation + +def gen_neighbor_list(pdb_filename=adp_pdb): + + pdb = app.PDBFile(pdb_filename) + top = pdb.getTopology() + positions = np.array(pdb.getPositions(asNumpy=True), dtype=np.float32) + + dr_threshold = 0.5 + box_size = 3 + nl_cutoff = 1 + displacement_fn, shift_fn = space.periodic(box_size) + neighbor_list_fn = nlist(displacement_fn, box_size, nl_cutoff, dr_threshold, capacity_multiplier=0.5) + neighbors = neighbor_list_fn.allocate(positions) + + return neighbors + + +def gen_atomtype_lists(pdb_filename=adp_pdb, atomtypes=['C', 'N', 'O'], solventname='HOH'): + + pdb = app.PDBFile(pdb_filename) + top = pdb.getTopology() + + # separate each atom type of interest - solute and solvent oxygen into a list + atom_indices = [] + for residue in top.residues(): + if residue.name != solventname: + for atomtype in atomtypes: + for atom in residue.atoms(): + if atom.name.startswith(atomtype): + atom_indices.append([int(atom.id)]) + + solute_list = atom_indices + + oxygen_list = [] + hydrogen_dict = {} + for residue in top.residues(): + if residue.name == solventname: + for atom in residue.atoms(): + if atom.name.startswith('O'): + oxygen_list.append(int(atom.id)) + hatom_list = [] + for bond in residue.bonds(): + if bond.atom1.id == atom.id: + hatom_list.append(int(bond.atom2.id)) + elif bond.atom2.id == atom.id: + hatom_list.append(int(bond.atom1.id)) + hydrogen_dict[int(atom.id)] = hatom_list + + + #atom_indices.append(oxygen_list) + + print("oxygen list") + + print(oxygen_list) + + #print("hydrogen dict") + #print(hydrogen_dict[23]) + + print("\n") + + num_atoms = top.getNumAtoms() + natom_types = len(atomtypes) + 1 + + return atom_indices, solute_list, oxygen_list, hydrogen_dict, num_atoms, natom_types + + +def gen_atompair_list(atom_lists, natom_types, exclude_atomtype_pairindices): + + position_pairs = [] + for i in range(natom_types): + + for j in range(i, natom_types): + + for i_particle in range(len(atom_lists[i])): + + for j_particle in range(len(atom_lists[j])): + + if i == j and j_particle <= i_particle: + continue + + if [i, j] in exclude_atomtype_pairindices: + continue + + position_pairs.append([i, atom_lists[i][i_particle], j, atom_lists[j][j_particle]]) + + return position_pairs + + +# %% +def get_args(argv): + available_args = [ + ("well-tempered", "w", bool, 0, "Whether to use well-tempered metadynamics"), + ("use-grids", "g", bool, 0, "Whether to use grid acceleration"), + ("log", "l", bool, 0, "Whether to use a callback to log data into a file"), + ("time-steps", "t", int, 5e5, "Number of simulation steps"), + ] + parser = argparse.ArgumentParser(description="Example script to run metadynamics") + for (name, short, T, val, doc) in available_args: + parser.add_argument("--" + name, "-" + short, type=T, default=T(val), help=doc) + return parser.parse_args(argv) + + +# %% +def main(argv=[]): + args = get_args(argv) + + atom_indices, solute_list, oxygen_list, hydrogen_dict, num_atoms, natom_types = gen_atomtype_lists() + exclude_atomtype_pairindices = [ [1, 1], [1, 2] ] + + position_pairs = gen_atompair_list(atom_indices, natom_types, exclude_atomtype_pairindices) + + all_atoms = list(onp.arange(num_atoms)) + #atom_indices.append(all_atoms) + + print(atom_indices) + + cvs = [PIV( all_atoms, + position_pairs, + solute_list, + oxygen_list, + hydrogen_dict, + {'r_0': 0.4, 'd_0': 2.3, 'n': 3, 'm': 6}, + {'neighbor_list': gen_neighbor_list()})] + + height = 1.2 # kJ/mol + sigma = [0.35, 0.35] # radians + deltaT = 5000 if args.well_tempered else None + stride = 500 # frequency for depositing gaussians + timesteps = args.time_steps + ngauss = timesteps // stride # total number of gaussians + + ## Grid for storing bias potential and its gradient + #grid = pysages.Grid(lower=(-pi, -pi), upper=(pi, pi), shape=(50, 50), periodic=True) + #grid = grid if args.use_grids else None + + # Method + method = Metadynamics(cvs, height, sigma, stride, ngauss, deltaT=deltaT, kB=kB) # grid=grid) + + # Logging + hills_file = "hills.dat" + callback = MetaDLogger(hills_file, stride) if args.log else None + + tic = time.perf_counter() + run_result = pysages.run(method, generate_simulation, timesteps, callback) + toc = time.perf_counter() + print(f"Completed the simulation in {toc - tic:0.4f} seconds.") + + # Analysis: Calculate free energy using the deposited bias potential + + # generate CV values on a grid to evaluate bias potential + #plot_grid = pysages.Grid(lower=(-pi, -pi), upper=(pi, pi), shape=(64, 64), periodic=True) + #xi = (compute_mesh(plot_grid) + 1) / 2 * plot_grid.size + plot_grid.lower + + # determine bias factor depending on method (for standard = 1 and for well-tempered = (T+deltaT)/deltaT) + #alpha = ( + # 1 + # if method.deltaT is None + # else (T.value_in_unit(unit.kelvin) + method.deltaT) / method.deltaT + #) + #kT = kB * T.value_in_unit(unit.kelvin) + + ## extract metapotential function from result + #result = pysages.analyze(run_result) + #metapotential = result["metapotential"] + + ## report in kT and set min free energy to zero + #A = metapotential(xi) * -alpha / kT + #A = A - A.min() + #A = A.reshape(plot_grid.shape) + + ## plot and save free energy to a PNG file + #fig, ax = plt.subplots(dpi=120) + + #im = ax.imshow(A, interpolation="bicubic", origin="lower", extent=[-pi, pi, -pi, pi]) + #ax.contour(A, levels=12, linewidths=0.75, colors="k", extent=[-pi, pi, -pi, pi]) + #ax.set_xlabel(r"$\phi$") + #ax.set_ylabel(r"$\psi$") + + #cbar = plt.colorbar(im) + #cbar.ax.set_ylabel(r"$A~[k_{B}T]$", rotation=270, labelpad=20) + + #fig.savefig("adp-fe.png", dpi=fig.dpi) + + #return result + + +# %% +if __name__ == "__main__": + + main(sys.argv[1:]) From 5d57d5ca133c7303b0163ce67acad9e7360983c4 Mon Sep 17 00:00:00 2001 From: Siva Dasetty Date: Wed, 13 Jul 2022 18:02:05 -0500 Subject: [PATCH 4/9] crude complete - example --- .../Metadynamics-ADP-checkpoint.ipynb | 362 ------------------ .../alanine-dipeptide-checkpoint.py | 274 ------------- 2 files changed, 636 deletions(-) delete mode 100644 examples/openmm/pivcv/.ipynb_checkpoints/Metadynamics-ADP-checkpoint.ipynb delete mode 100644 examples/openmm/pivcv/.ipynb_checkpoints/alanine-dipeptide-checkpoint.py diff --git a/examples/openmm/pivcv/.ipynb_checkpoints/Metadynamics-ADP-checkpoint.ipynb b/examples/openmm/pivcv/.ipynb_checkpoints/Metadynamics-ADP-checkpoint.ipynb deleted file mode 100644 index c8cab7d9..00000000 --- a/examples/openmm/pivcv/.ipynb_checkpoints/Metadynamics-ADP-checkpoint.ipynb +++ /dev/null @@ -1,362 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "KBFVcG1FoeMq" - }, - "source": [ - "# Metadynamics-biased simulations" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "id": "BBvC7Spoog82" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2022-06-29 11:39:38.911094: W external/org_tensorflow/tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /software/slurm-current-el7-x86_64/lib64:/software/slurm-current-el7-x86_64/lib:/software/gcc-7.2.0-el7-x86_64/lib64:/software/gcc-7.2.0-el7-x86_64/lib:/software/python-anaconda-2021.05-el7-x86_64/lib:/software/git-2.10-el7-x86_64/lib64:/software/subversion-1.9.4-el7-x86_64/lib:/software/serf-1.3.9-el7-x86_64/lib\n", - "2022-06-29 11:39:39.748220: W external/org_tensorflow/tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /software/slurm-current-el7-x86_64/lib64:/software/slurm-current-el7-x86_64/lib:/software/gcc-7.2.0-el7-x86_64/lib64:/software/gcc-7.2.0-el7-x86_64/lib:/software/python-anaconda-2021.05-el7-x86_64/lib:/software/git-2.10-el7-x86_64/lib64:/software/subversion-1.9.4-el7-x86_64/lib:/software/serf-1.3.9-el7-x86_64/lib\n", - "2022-06-29 11:39:39.829378: W external/org_tensorflow/tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /software/slurm-current-el7-x86_64/lib64:/software/slurm-current-el7-x86_64/lib:/software/gcc-7.2.0-el7-x86_64/lib64:/software/gcc-7.2.0-el7-x86_64/lib:/software/python-anaconda-2021.05-el7-x86_64/lib:/software/git-2.10-el7-x86_64/lib64:/software/subversion-1.9.4-el7-x86_64/lib:/software/serf-1.3.9-el7-x86_64/lib\n" - ] - } - ], - "source": [ - "import numpy\n", - "\n", - "from pysages.utils import try_import\n", - "\n", - "openmm = try_import(\"openmm\", \"simtk.openmm\")\n", - "unit = try_import(\"openmm.unit\", \"simtk.unit\")\n", - "app = try_import(\"openmm.app\", \"simtk.openmm.app\")\n", - "\n", - "\n", - "pi = numpy.pi\n", - "\n", - "T = 298.15 * unit.kelvin\n", - "dt = 2.0 * unit.femtoseconds\n", - "adp_pdb = \"../../inputs/alanine-dipeptide/adp-vacuum.pdb\"\n", - "\n", - "\n", - "def generate_simulation(pdb_filename=adp_pdb, T=T, dt=dt):\n", - " pdb = app.PDBFile(pdb_filename)\n", - "\n", - " ff = app.ForceField(\"amber99sb.xml\")\n", - " cutoff_distance = 1.0 * unit.nanometer\n", - " topology = pdb.topology\n", - "\n", - " system = ff.createSystem(\n", - " topology, constraints=app.HBonds, nonbondedMethod=app.PME, nonbondedCutoff=cutoff_distance\n", - " )\n", - "\n", - " # Set dispersion correction use.\n", - " forces = {}\n", - " for i in range(system.getNumForces()):\n", - " force = system.getForce(i)\n", - " forces[force.__class__.__name__] = force\n", - "\n", - " forces[\"NonbondedForce\"].setUseDispersionCorrection(True)\n", - " forces[\"NonbondedForce\"].setEwaldErrorTolerance(1.0e-5)\n", - "\n", - " positions = pdb.getPositions(asNumpy=True)\n", - "\n", - " integrator = openmm.LangevinIntegrator(T, 1 / unit.picosecond, dt)\n", - " integrator.setRandomNumberSeed(42)\n", - "\n", - " simulation = app.Simulation(topology, system, integrator)\n", - " simulation.context.setPositions(positions)\n", - " simulation.minimizeEnergy()\n", - "\n", - " return simulation" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "3UrzENm_oo6U" - }, - "source": [ - "Next, we load PySAGES and the relevant classes and methods for our problem" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "id": "fpMg-o8WomAA" - }, - "outputs": [], - "source": [ - "#from pysages.grids import Grid\n", - "from pysages.colvars import PIV\n", - "#from pysages.methods import Metadynamics\n", - "\n", - "import pysages" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "LknkRvo1o4av" - }, - "source": [ - "The next step is to define the collective variable (CV). In this case, we choose the so called $\\phi$ and $\\psi$ dihedral angles of alanine dipeptide.\n", - "\n", - "For this example we will use the well-tempered version without grids. But these options can be configured.\n", - "\n", - "We set the initial height, standard deviation and deposition frequency `stride` for the gaussians, as well as the $\\Delta T$ Metadynamics parameter. And the number of time steps to run the simulation (here we use $9\\times10^6$ or 18 ns for the timestep chosen).\n", - "\n", - "We also define a grid, which can be used as optional parameter to accelerate Metadynamics by approximating the biasing potential and its gradient by the closest value at the centers of the grid cells.\n", - "\n", - "_Note:_ when setting $\\Delta T$ we need to also provide a value for $k_B$ that matches the internal units used by the backend." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "B1Z8FWz0o7u_" - }, - "outputs": [], - "source": [ - "cvs = [PIV( [[4, 6, 8, 14], [0, 1, 2]], [1], [2.3, 3, 6])]\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Fz8BfU34pA_N" - }, - "source": [ - "We now simulate the number of time steps set above.\n", - "Make sure to run with GPU support, otherwise, it can take a very long time.\n", - "On the GPU this should run in around half an hour." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "id": "K951m4BbpUar" - }, - "outputs": [], - "source": [ - "state = pysages.run(method, generate_simulation, timesteps)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "PXBKUfK0p9T2" - }, - "source": [ - "## Analysis\n", - "\n", - "Let's plot the negative of the sum of gaussians accumulated. This will get close to the free energy surface for long enough simulations (larger than what is practical to run on Colab, but we should get close enough for illustration purposes here)." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "id": "X69d1R7OpW4P" - }, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "from pysages.approxfun import compute_mesh" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "6mrlIOfoszBJ" - }, - "source": [ - "We are now going to gather the information for the heights, standard deviations and centers of the accumulated gaussians and build a function to evaluate their sum at any point of the collective variable space." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "id": "zJqvpbw8szxR" - }, - "outputs": [], - "source": [ - "fe_result = pysages.analyze(run_result)\n", - "metapotential = fe_result['metapotential']" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "VfTQ5yeyxt8e" - }, - "source": [ - "Next we use the biasing potential to estimate the free energy surface. For well-tempered metadynamics this is equal to the sum of accumulated gaussians scaled by the factor $-(T + \\Delta T)\\, / \\,\\Delta T$." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "id": "6W7Xf0ilqAcm" - }, - "outputs": [], - "source": [ - "plot_grid = pysages.Grid(lower=(-pi, -pi), upper=(pi, pi), shape=(64, 64), periodic=True)\n", - "xi = (compute_mesh(plot_grid) + 1) / 2 * plot_grid.size + plot_grid.lower\n", - "\n", - "alpha = 1 if method.deltaT is None else (T.value_in_unit(unit.kelvin) + method.deltaT) / method.deltaT\n", - "kT = kB * T.value_in_unit(unit.kelvin)\n", - "\n", - "A = metapotential(xi) * -alpha / kT\n", - "A = A - A.min()\n", - "A = A.reshape(plot_grid.shape)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Kf_CMdih90Cd" - }, - "source": [ - "And plot it." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 461 - }, - "id": "3s9LL9apBMVb", - "outputId": "55abf4e5-fef0-4faa-bf01-9719cbe8aa2b" - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(dpi=120)\n", - "\n", - "im = ax.imshow(\n", - " A, interpolation=\"bicubic\", origin=\"lower\", extent=[-pi, pi, -pi, pi]\n", - ")\n", - "ax.contour(\n", - " A, levels=12, linewidths=0.75, colors=\"k\", extent=[-pi, pi, -pi, pi]\n", - ")\n", - "ax.set_xlabel(r\"$\\phi$\")\n", - "ax.set_ylabel(r\"$\\psi$\")\n", - "\n", - "cbar = plt.colorbar(im)\n", - "cbar.ax.set_ylabel(r\"$A~[k_{B}T]$\", rotation=270, labelpad=20)\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "a-LGmeZ_3_m-" - }, - "source": [ - "Lastly, we plot the height of the gaussians as a function of time and observe that their height decreases at an exponential rate as expected for well-tempered metadynamics." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 457 - }, - "id": "SI_fhUW9CGlP", - "outputId": "5d32f99d-4911-44bb-9d89-69c3e6212cb7" - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "_dt = dt #method.context[0].sampler.snapshot.dt\n", - "ts = _dt * 1e-3 * numpy.arange(0, fe_result['heights'].size) * run_result.method.stride\n", - "\n", - "fig, ax = plt.subplots(dpi=120)\n", - "ax.plot(ts, fe_result['heights'], \"o\", mfc=\"none\", ms=4)\n", - "ax.set_xlabel(\"time [ns]\")\n", - "ax.set_ylabel(\"height [kJ/mol]\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "R6rEuwWAZ8Qp" - }, - "outputs": [], - "source": [] - } - ], - "metadata": { - "accelerator": "GPU", - "colab": { - "collapsed_sections": [], - "name": "ADP-Metadynamics.ipynb", - "provenance": [] - }, - "jupytext": { - "formats": "ipynb,md", - "main_language": "python" - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.9.10" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/examples/openmm/pivcv/.ipynb_checkpoints/alanine-dipeptide-checkpoint.py b/examples/openmm/pivcv/.ipynb_checkpoints/alanine-dipeptide-checkpoint.py deleted file mode 100644 index 17383dbb..00000000 --- a/examples/openmm/pivcv/.ipynb_checkpoints/alanine-dipeptide-checkpoint.py +++ /dev/null @@ -1,274 +0,0 @@ -#!/usr/bin/env python3 - -""" -Metadynamics simulation of Alanine Dipeptide in vacuum with OpenMM and PySAGES. - -Example command to run the simulation `python3 alanine-dipeptide.py --time-steps 1000` -For other supported commandline parameters, check `python3 alanine-dipeptide.py --help` -""" - - -# %% -import argparse -import os -import sys -import time - -import numpy -import pysages - -from pysages.colvars import PIV -from pysages.methods import Metadynamics, MetaDLogger -from pysages.utils import try_import -from pysages.approxfun import compute_mesh - -import numpy as onp -from jax import numpy as np -from jax_md.partition import neighbor_list as nlist, space - -import matplotlib.pyplot as plt - -openmm = try_import("openmm", "simtk.openmm") -unit = try_import("openmm.unit", "simtk.unit") -app = try_import("openmm.app", "simtk.openmm.app") - - -# %% -pi = numpy.pi -kB = unit.BOLTZMANN_CONSTANT_kB * unit.AVOGADRO_CONSTANT_NA -kB = kB.value_in_unit(unit.kilojoules_per_mole / unit.kelvin) - -T = 298.15 * unit.kelvin -dt = 2.0 * unit.femtoseconds -adp_pdb = os.path.join(os.pardir, os.pardir, "inputs", "alanine-dipeptide", "adp-vacuum.pdb") - - -# %% -def generate_simulation(pdb_filename=adp_pdb, T=T, dt=dt): - pdb = app.PDBFile(pdb_filename) - - ff = app.ForceField("amber99sb.xml") #, "tip3p.xml") - cutoff_distance = 1.0 * unit.nanometer - topology = pdb.topology - - system = ff.createSystem( - topology, constraints=app.HBonds, nonbondedMethod=app.PME, nonbondedCutoff=cutoff_distance - ) - - # Set dispersion correction use. - forces = {} - for i in range(system.getNumForces()): - force = system.getForce(i) - forces[force.__class__.__name__] = force - - forces["NonbondedForce"].setUseDispersionCorrection(True) - forces["NonbondedForce"].setEwaldErrorTolerance(1.0e-5) - - positions = pdb.getPositions(asNumpy=True) - - integrator = openmm.LangevinIntegrator(T, 1 / unit.picosecond, dt) - - integrator.setRandomNumberSeed(42) - - # platform = openmm.Platform.getPlatformByName(platform) - # simulation = app.Simulation(topology, system, integrator, platform) - simulation = app.Simulation(topology, system, integrator) - simulation.context.setPositions(positions) - simulation.minimizeEnergy() - - simulation.reporters.append(app.PDBReporter("output.pdb", 1000)) - simulation.reporters.append( - app.StateDataReporter("log.dat", 1000, step=True, potentialEnergy=True, temperature=True) - ) - - return simulation - -def gen_neighbor_list(pdb_filename=adp_pdb): - - pdb = app.PDBFile(pdb_filename) - top = pdb.getTopology() - positions = np.array(pdb.getPositions(asNumpy=True), dtype=np.float32) - - dr_threshold = 0.5 - box_size = 3 - nl_cutoff = 1 - displacement_fn, shift_fn = space.periodic(box_size) - neighbor_list_fn = nlist(displacement_fn, box_size, nl_cutoff, dr_threshold, capacity_multiplier=0.5) - neighbors = neighbor_list_fn.allocate(positions) - - return neighbors - - -def gen_atomtype_lists(pdb_filename=adp_pdb, atomtypes=['C', 'N', 'O'], solventname='HOH'): - - pdb = app.PDBFile(pdb_filename) - top = pdb.getTopology() - - # separate each atom type of interest - solute and solvent oxygen into a list - atom_indices = [] - for residue in top.residues(): - if residue.name != solventname: - for atomtype in atomtypes: - for atom in residue.atoms(): - if atom.name.startswith(atomtype): - atom_indices.append([int(atom.id)]) - - solute_list = atom_indices - - oxygen_list = [] - hydrogen_dict = {} - for residue in top.residues(): - if residue.name == solventname: - for atom in residue.atoms(): - if atom.name.startswith('O'): - oxygen_list.append(int(atom.id)) - hatom_list = [] - for bond in residue.bonds(): - if bond.atom1.id == atom.id: - hatom_list.append(int(bond.atom2.id)) - elif bond.atom2.id == atom.id: - hatom_list.append(int(bond.atom1.id)) - hydrogen_dict[int(atom.id)] = hatom_list - - - #atom_indices.append(oxygen_list) - - print("oxygen list") - - print(oxygen_list) - - #print("hydrogen dict") - #print(hydrogen_dict[23]) - - print("\n") - - num_atoms = top.getNumAtoms() - natom_types = len(atomtypes) + 1 - - return atom_indices, solute_list, oxygen_list, hydrogen_dict, num_atoms, natom_types - - -def gen_atompair_list(atom_lists, natom_types, exclude_atomtype_pairindices): - - position_pairs = [] - for i in range(natom_types): - - for j in range(i, natom_types): - - for i_particle in range(len(atom_lists[i])): - - for j_particle in range(len(atom_lists[j])): - - if i == j and j_particle <= i_particle: - continue - - if [i, j] in exclude_atomtype_pairindices: - continue - - position_pairs.append([i, atom_lists[i][i_particle], j, atom_lists[j][j_particle]]) - - return position_pairs - - -# %% -def get_args(argv): - available_args = [ - ("well-tempered", "w", bool, 0, "Whether to use well-tempered metadynamics"), - ("use-grids", "g", bool, 0, "Whether to use grid acceleration"), - ("log", "l", bool, 0, "Whether to use a callback to log data into a file"), - ("time-steps", "t", int, 5e5, "Number of simulation steps"), - ] - parser = argparse.ArgumentParser(description="Example script to run metadynamics") - for (name, short, T, val, doc) in available_args: - parser.add_argument("--" + name, "-" + short, type=T, default=T(val), help=doc) - return parser.parse_args(argv) - - -# %% -def main(argv=[]): - args = get_args(argv) - - atom_indices, solute_list, oxygen_list, hydrogen_dict, num_atoms, natom_types = gen_atomtype_lists() - exclude_atomtype_pairindices = [ [1, 1], [1, 2] ] - - position_pairs = gen_atompair_list(atom_indices, natom_types, exclude_atomtype_pairindices) - - all_atoms = list(onp.arange(num_atoms)) - #atom_indices.append(all_atoms) - - print(atom_indices) - - cvs = [PIV( all_atoms, - position_pairs, - solute_list, - oxygen_list, - hydrogen_dict, - {'r_0': 0.4, 'd_0': 2.3, 'n': 3, 'm': 6}, - {'neighbor_list': gen_neighbor_list()})] - - height = 1.2 # kJ/mol - sigma = [0.35, 0.35] # radians - deltaT = 5000 if args.well_tempered else None - stride = 500 # frequency for depositing gaussians - timesteps = args.time_steps - ngauss = timesteps // stride # total number of gaussians - - ## Grid for storing bias potential and its gradient - #grid = pysages.Grid(lower=(-pi, -pi), upper=(pi, pi), shape=(50, 50), periodic=True) - #grid = grid if args.use_grids else None - - # Method - method = Metadynamics(cvs, height, sigma, stride, ngauss, deltaT=deltaT, kB=kB) # grid=grid) - - # Logging - hills_file = "hills.dat" - callback = MetaDLogger(hills_file, stride) if args.log else None - - tic = time.perf_counter() - run_result = pysages.run(method, generate_simulation, timesteps, callback) - toc = time.perf_counter() - print(f"Completed the simulation in {toc - tic:0.4f} seconds.") - - # Analysis: Calculate free energy using the deposited bias potential - - # generate CV values on a grid to evaluate bias potential - #plot_grid = pysages.Grid(lower=(-pi, -pi), upper=(pi, pi), shape=(64, 64), periodic=True) - #xi = (compute_mesh(plot_grid) + 1) / 2 * plot_grid.size + plot_grid.lower - - # determine bias factor depending on method (for standard = 1 and for well-tempered = (T+deltaT)/deltaT) - #alpha = ( - # 1 - # if method.deltaT is None - # else (T.value_in_unit(unit.kelvin) + method.deltaT) / method.deltaT - #) - #kT = kB * T.value_in_unit(unit.kelvin) - - ## extract metapotential function from result - #result = pysages.analyze(run_result) - #metapotential = result["metapotential"] - - ## report in kT and set min free energy to zero - #A = metapotential(xi) * -alpha / kT - #A = A - A.min() - #A = A.reshape(plot_grid.shape) - - ## plot and save free energy to a PNG file - #fig, ax = plt.subplots(dpi=120) - - #im = ax.imshow(A, interpolation="bicubic", origin="lower", extent=[-pi, pi, -pi, pi]) - #ax.contour(A, levels=12, linewidths=0.75, colors="k", extent=[-pi, pi, -pi, pi]) - #ax.set_xlabel(r"$\phi$") - #ax.set_ylabel(r"$\psi$") - - #cbar = plt.colorbar(im) - #cbar.ax.set_ylabel(r"$A~[k_{B}T]$", rotation=270, labelpad=20) - - #fig.savefig("adp-fe.png", dpi=fig.dpi) - - #return result - - -# %% -if __name__ == "__main__": - - main(sys.argv[1:]) From 2563fe49252e813bb7cb625b4b48d5b622533814 Mon Sep 17 00:00:00 2001 From: Siva Dasetty Date: Tue, 2 Aug 2022 17:34:49 -0500 Subject: [PATCH 5/9] Updated comments/reorganized - tests pending. --- examples/openmm/pivcv/Metadynamics-ADP.ipynb | 362 ------------------- examples/openmm/pivcv/alanine-dipeptide.py | 274 -------------- pysages/colvars/__init__.py | 2 +- pysages/colvars/ann.py | 190 ---------- pysages/colvars/utils.py | 17 +- 5 files changed, 9 insertions(+), 836 deletions(-) delete mode 100644 examples/openmm/pivcv/Metadynamics-ADP.ipynb delete mode 100644 examples/openmm/pivcv/alanine-dipeptide.py delete mode 100644 pysages/colvars/ann.py diff --git a/examples/openmm/pivcv/Metadynamics-ADP.ipynb b/examples/openmm/pivcv/Metadynamics-ADP.ipynb deleted file mode 100644 index c8cab7d9..00000000 --- a/examples/openmm/pivcv/Metadynamics-ADP.ipynb +++ /dev/null @@ -1,362 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "KBFVcG1FoeMq" - }, - "source": [ - "# Metadynamics-biased simulations" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "id": "BBvC7Spoog82" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2022-06-29 11:39:38.911094: W external/org_tensorflow/tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /software/slurm-current-el7-x86_64/lib64:/software/slurm-current-el7-x86_64/lib:/software/gcc-7.2.0-el7-x86_64/lib64:/software/gcc-7.2.0-el7-x86_64/lib:/software/python-anaconda-2021.05-el7-x86_64/lib:/software/git-2.10-el7-x86_64/lib64:/software/subversion-1.9.4-el7-x86_64/lib:/software/serf-1.3.9-el7-x86_64/lib\n", - "2022-06-29 11:39:39.748220: W external/org_tensorflow/tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /software/slurm-current-el7-x86_64/lib64:/software/slurm-current-el7-x86_64/lib:/software/gcc-7.2.0-el7-x86_64/lib64:/software/gcc-7.2.0-el7-x86_64/lib:/software/python-anaconda-2021.05-el7-x86_64/lib:/software/git-2.10-el7-x86_64/lib64:/software/subversion-1.9.4-el7-x86_64/lib:/software/serf-1.3.9-el7-x86_64/lib\n", - "2022-06-29 11:39:39.829378: W external/org_tensorflow/tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory; LD_LIBRARY_PATH: /software/slurm-current-el7-x86_64/lib64:/software/slurm-current-el7-x86_64/lib:/software/gcc-7.2.0-el7-x86_64/lib64:/software/gcc-7.2.0-el7-x86_64/lib:/software/python-anaconda-2021.05-el7-x86_64/lib:/software/git-2.10-el7-x86_64/lib64:/software/subversion-1.9.4-el7-x86_64/lib:/software/serf-1.3.9-el7-x86_64/lib\n" - ] - } - ], - "source": [ - "import numpy\n", - "\n", - "from pysages.utils import try_import\n", - "\n", - "openmm = try_import(\"openmm\", \"simtk.openmm\")\n", - "unit = try_import(\"openmm.unit\", \"simtk.unit\")\n", - "app = try_import(\"openmm.app\", \"simtk.openmm.app\")\n", - "\n", - "\n", - "pi = numpy.pi\n", - "\n", - "T = 298.15 * unit.kelvin\n", - "dt = 2.0 * unit.femtoseconds\n", - "adp_pdb = \"../../inputs/alanine-dipeptide/adp-vacuum.pdb\"\n", - "\n", - "\n", - "def generate_simulation(pdb_filename=adp_pdb, T=T, dt=dt):\n", - " pdb = app.PDBFile(pdb_filename)\n", - "\n", - " ff = app.ForceField(\"amber99sb.xml\")\n", - " cutoff_distance = 1.0 * unit.nanometer\n", - " topology = pdb.topology\n", - "\n", - " system = ff.createSystem(\n", - " topology, constraints=app.HBonds, nonbondedMethod=app.PME, nonbondedCutoff=cutoff_distance\n", - " )\n", - "\n", - " # Set dispersion correction use.\n", - " forces = {}\n", - " for i in range(system.getNumForces()):\n", - " force = system.getForce(i)\n", - " forces[force.__class__.__name__] = force\n", - "\n", - " forces[\"NonbondedForce\"].setUseDispersionCorrection(True)\n", - " forces[\"NonbondedForce\"].setEwaldErrorTolerance(1.0e-5)\n", - "\n", - " positions = pdb.getPositions(asNumpy=True)\n", - "\n", - " integrator = openmm.LangevinIntegrator(T, 1 / unit.picosecond, dt)\n", - " integrator.setRandomNumberSeed(42)\n", - "\n", - " simulation = app.Simulation(topology, system, integrator)\n", - " simulation.context.setPositions(positions)\n", - " simulation.minimizeEnergy()\n", - "\n", - " return simulation" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "3UrzENm_oo6U" - }, - "source": [ - "Next, we load PySAGES and the relevant classes and methods for our problem" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "id": "fpMg-o8WomAA" - }, - "outputs": [], - "source": [ - "#from pysages.grids import Grid\n", - "from pysages.colvars import PIV\n", - "#from pysages.methods import Metadynamics\n", - "\n", - "import pysages" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "LknkRvo1o4av" - }, - "source": [ - "The next step is to define the collective variable (CV). In this case, we choose the so called $\\phi$ and $\\psi$ dihedral angles of alanine dipeptide.\n", - "\n", - "For this example we will use the well-tempered version without grids. But these options can be configured.\n", - "\n", - "We set the initial height, standard deviation and deposition frequency `stride` for the gaussians, as well as the $\\Delta T$ Metadynamics parameter. And the number of time steps to run the simulation (here we use $9\\times10^6$ or 18 ns for the timestep chosen).\n", - "\n", - "We also define a grid, which can be used as optional parameter to accelerate Metadynamics by approximating the biasing potential and its gradient by the closest value at the centers of the grid cells.\n", - "\n", - "_Note:_ when setting $\\Delta T$ we need to also provide a value for $k_B$ that matches the internal units used by the backend." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "B1Z8FWz0o7u_" - }, - "outputs": [], - "source": [ - "cvs = [PIV( [[4, 6, 8, 14], [0, 1, 2]], [1], [2.3, 3, 6])]\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Fz8BfU34pA_N" - }, - "source": [ - "We now simulate the number of time steps set above.\n", - "Make sure to run with GPU support, otherwise, it can take a very long time.\n", - "On the GPU this should run in around half an hour." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "id": "K951m4BbpUar" - }, - "outputs": [], - "source": [ - "state = pysages.run(method, generate_simulation, timesteps)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "PXBKUfK0p9T2" - }, - "source": [ - "## Analysis\n", - "\n", - "Let's plot the negative of the sum of gaussians accumulated. This will get close to the free energy surface for long enough simulations (larger than what is practical to run on Colab, but we should get close enough for illustration purposes here)." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "id": "X69d1R7OpW4P" - }, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "from pysages.approxfun import compute_mesh" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "6mrlIOfoszBJ" - }, - "source": [ - "We are now going to gather the information for the heights, standard deviations and centers of the accumulated gaussians and build a function to evaluate their sum at any point of the collective variable space." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "id": "zJqvpbw8szxR" - }, - "outputs": [], - "source": [ - "fe_result = pysages.analyze(run_result)\n", - "metapotential = fe_result['metapotential']" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "VfTQ5yeyxt8e" - }, - "source": [ - "Next we use the biasing potential to estimate the free energy surface. For well-tempered metadynamics this is equal to the sum of accumulated gaussians scaled by the factor $-(T + \\Delta T)\\, / \\,\\Delta T$." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "id": "6W7Xf0ilqAcm" - }, - "outputs": [], - "source": [ - "plot_grid = pysages.Grid(lower=(-pi, -pi), upper=(pi, pi), shape=(64, 64), periodic=True)\n", - "xi = (compute_mesh(plot_grid) + 1) / 2 * plot_grid.size + plot_grid.lower\n", - "\n", - "alpha = 1 if method.deltaT is None else (T.value_in_unit(unit.kelvin) + method.deltaT) / method.deltaT\n", - "kT = kB * T.value_in_unit(unit.kelvin)\n", - "\n", - "A = metapotential(xi) * -alpha / kT\n", - "A = A - A.min()\n", - "A = A.reshape(plot_grid.shape)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Kf_CMdih90Cd" - }, - "source": [ - "And plot it." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 461 - }, - "id": "3s9LL9apBMVb", - "outputId": "55abf4e5-fef0-4faa-bf01-9719cbe8aa2b" - }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAi0AAAG2CAYAAACzoLZvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAABJ0AAASdAHeZh94AAEAAElEQVR4nOyddZgsV533P6eqbazH9bq75vqNy40LERIsuMuysAu7LM4usAssL764BU0IxCDu193dx92nreq8f5R0VXX1zFwJF0L/5jlPd586dbq6Wuoz358cIaUkZznLWc5ylrOc5exv3ZQLfQA5y1nOcpaznOUsZ6OxHLTkLGc5y1nOcpazvwvLQUvOcpaznOUsZzn7u7ActOQsZznLWc5ylrO/C8tBS85ylrOc5SxnOfu7sBy05CxnOctZznKWs78Ly0FLznKWs5zlLGc5+7uwHLTkLGc5y1nOcpazvwvLQUvOcpaznOUsZzn7u7DAhT6Av1UTQhQDlwGngcQFPpyc5SxnOctZpoWAccALUsqev8YTCiHqgNLzMFWXlLLxPMzzD2U5aMlulwEPXeiDyFnOcpaznI1otwIPv9JPIoSoKypUGvr69fMxXZ8QYmYOXM7MctCS3U4DLJh6D/mRMpASoUmQEnQQuk4s0cu20/czrfxSKvMmGNs0CVjjdONWYt6ajwF0a82nM137SaTvKuZ9Yd0qnseO+0p6W0+ihQNdL1AYqmBm6aWoasixj3Df986T5VYK53H5HXZ6uz1W8d9uvUZpdSnpx1LXae86QH3zJkAwacKVFBdPMOayjkURxr7mrXHffF4VWut30HDwOcYvvJniuulIxdxHAV0Fic7ptX8gNdTPuOvfBOEgUjXmSGlxGv/wC4LVVVRcfzNSFciARBeSjgceRB/sp+Idr4OwilB1hKrT9cvHSLZ1Mu5f7yQUUQgGNFQh6d14kOM/X8fiT15N+dQSQmqKkNAIKRrtu5t55r+2suZf5zB9ZTlhJUVIpAgIjaDQCJv3n/lNK0/+poMPfrGGufPDCKGjIlGQKEJHQaLapzHzs6abJ1kDdAS6VNARaAikVEhKla//exPjZuSz5s3VpKRKSqrE9QApqZIgQEIPsPmPDRx4soEbvnkFSV0lKVUSmjHu5BNHOPXoPub9910kCaDpKklNITGQ4tSnfk7ZXVcRWTADmVKQugANhnYfpOehJ6l+7ztQ8woRukDoICTG90+D9iceIdnZSd2db0KgIszriDC/gqP6agmj2Z816755q+spTv/4m5SvuZH86dPtfqkAijQ/OxIE9L28jvixk5S/425QQCgSFIlQJIowbtGTnP7Y96n7p1vJn1qDquioivFeqQLzsY5AogrJrs//marl45l44wzzPZUIYb2/GO+3+b6KYV6wNL9TmjTeV10a77eUAl0KNOt91xWaXjrGqfu3M+9rd6NLFU2CLhU0TUGTAl1X0HSFvs2H6PrjS9R85p2gK0hdgZTxRRWaoO0nvyJv0mSiK1cjNON9ESkQuqD+Z9+j5KJVFE9bYGzTQdEg1d/HsYe/x6Qr30xeURWKLkEDRQc0nf0v/YjqcUuoqlsAOsT629m3/Zdg/l7/Fay0r1/nwZ/WMnVS8KwnOXI8ye1vbSrCUGxy0HIGloOW7JYAyI+UUZhXBZpEWCBiQsvxtnUUhauYWLrE+HLpOqgmsEgJmoaUMg0oFrToMn3Blg5i17P86CjC/diCE2e/E1zMfuEFDEUBISgKllMarmNr20Ps7XiaRdW3kB8scQGLVPzgxZpnBHDJBiN+4OIc7zM2E1wERYW1jBuziqMnn+bgkYeprV7M1KnXEwjlmxcVYdyqJrQo5mNFIFWYMOd61GCY07seI7+0hmjddHTVgBapGm3SdW/l0ANfp3PXWsZcd48BMyqEVBhz91s59ZNvEDt1kujKFeY2SdU77qXxy19jYON2Sl93I0KViIBO9Yfvpv7j36Hrye2M/8D1BAMaQVUjOrmEoVMdHPjhRq786Z0URRXCSoqwmqJqWhFDHUM8960DTFu2isrpRUREiqBIEVGSBIVGUKR426fHoirw/c+38tXfjGPGnDyCImWAiwkwgH3rBZc0tBigokvFvG8AiyYVqseFkLpk3LQ8kjJgAIkMENeDxGSApB5g0W3j2PSLI4TCguIxxQxpQeJagISuIu5ayPHfbCPZM0ThwkkkUgHUlEpQV4heOp+hnYeJ3ngpUhNITYGUIFhdzeC6rQzu3kP5bbcZFzZNGBc+g7Covu0eTn7zywweP0LZsstsWBEOYBHZ4EVYn0P8oUUxwGTwxGHQdaKLl6IU5Jnwi/lZkeY4CSqg6wSrKgiNqTFgRTWgRVEN0BCKjt7dDUDe9LHkjytFMaFFVQz4CJjQEhA6Qkj0eIqiiWVEJ5WhCJluWPfT0KIMAy26A1p0qaBLYUKq0VK6io4gpSvE7t9BycKxFE6qJKUboJLSVDTd2K7rBsB0P7uD8JQ6wuNqjPcupYAmQBeQ0NHa2sm7/npCNTUIzYASoYHW04822EfRtDlEKmrM9xaUFPR2tqEEQpRMmIMiVZSUNPeTJHraScZ6qRqzmIKCyvR7bdhf1YU/eVKAWTPOHlr0M/5nNWeWvWoCcYUQC4UQjwkhTgkhhoQQnUKI9UKIN57z5J6VsIWU9A420di7lxmVl6N4P38W3Lj69Ix5bGDRZXZg8dvu3C/beMB3BW+zryBYyorquwmp+axruI/mgUOu7a773lvdv1/Y282WbT7nWDxjnXNKaVykZPo5rf0CSpgZk29k8by30917go2bv0F7217zhyx9nPb+5r7Gf+uSsTOupGbKKg6v/SWx3naEOdb6Dz0YLmTCmjfRdWALXXs2peeREKkZS8WaW2h/7E8kmpttBUAtLKLi3nvoe/plhnYdMl6KBFFQQPUH76T76W10rTuApgsTFhSmf/gqUBS2//eLJHXjQqKZF5Ll75jNlEtquO+DW+hpS9owoUklffFB5S3/Uceyq4r4xFvqObIvZoxxAAhg31oXKas5t2WzkooAPR0p320WDFVMKaKoOo+T65sB9wU0ryyPsqUTaHt2n/E+iLRiUHLNEob2HiPV3J4WEQUIRaH4xmvoe3kDqZ5uWxGBNGgEiqJUXHUj7c8/TrKv234+6RhrzZfRrHF+5ugfOHKQyNjxqHl5w50iAFLdvagl0WHHaD0DAASKC0acDyDZFyMYjYxq7Nma9Tmwbrt3N1I8d8yI+yWONxGeWGd+Z9wnM9nShkymCI015nFujTfVI1SVSEWN3Wd9RwdbT5FXMRYhVDx8TXfrYUKRKHmFlel9LtC1X5c62jk0XZ4X99I/pL1qoAUowZAIPwHcANwLnAB+KYT45FnP6rwgm64hgEOtz1FZMIWyvHHpcbp0XZhtlcVPTckCHlJKV3PZcOAi/eeVThBwgpSUhNQ8llTexsTii9jR+hj7259FlykDFrKAyWjAxQUv1jYPjGCOs8d7QSdjXmx4s+eXUBqdwPKFH6CmaiG79/yafXt/h5ZKpCHEfE+ETtplYLYJ82+isGw8h174CXoiZgCGjg0hBdUTqV11M43P/oF4S6OhsJljSpZeTP7UGbT86hfIeAJM90XezBkUXXUJHT/+PVpXv+HukILIzEmU3X4pDd9+lHhLL5qukNIViESY9+nraXr5OIcf2EdSV0nphgsmJQJc+7ml5JeGuO+ftjEYM2T6pFRJyoANJygq7//yeOavLODDd9ez/rmhrODiBRQv1PhZcXmAno4kKhKV9GdIEen7qoBJq6o5va7JBhanKlB7zUzaXzyEHkvawCKEJDK1lvCUOnqfXI+wyNBseYvnEqyupPupZ2w3nwQHfEiKl64kVFFF65N/csGKU0Hxg5MMZcVz37odPHqQ/KkzMidwXlHNsVrP8NAihAEtIqCiFoayjrNM13RS/QmCReERxw47j0NlGcliXUMMnu6yoUUC0twvfQu6LomfbCY0sTZzEgmJ0w0oBQWoxcVu+JCCWGM94cpahGoI/c7tgy2nKKgabz92qmc9rUcorpxmXLRyQsU/rL1qoEVK+byU8j1SyvuklM9JKR+VUr4O2Ai865wm96gG7X3H6Bg4yfSKy9L9zous7qeqSDewONSTrJDit02X2cFntODiOFYhFKZGl7O0+naaBg6yseG3DKV6bXARuue1OW+dz+tskAkjOhljzmi8R3Wxx0tQlQDTJl7LkoXvprvnJDu2/4hEvN/+sbNjkSTGa9KMW0UqTF/+BpCSoy//CjTNhhJMeKmcdwnRCbM49cjP0WMxG34UKai5+W70eIL2hx+yYQddUHrz9QRKi+n40e/RUxJdM1SN0jsuJzyuihP/8ydSCR1NGjEEBVNrmPXhy9n1zfU072olKRUbXkQ4xGu+voruphh/+PQ+ErpiAkkaXhJSRQmqfOTr47j53jI++c4GHv51bwa4eOHFCyq69P85KKkI0N2eVloUD7ioJrxMvria05tb0RKa7bqw3FE1F08CoHvDYRtYBIbHsuT6FfS9sA19KGZ4Bc0mVIWSm9bQv34Tyc5O481UcMeVqArVN99J/4Hd9B3Y6Qsu1n3phZgRruGp/j7iTQ3kT5uRjn0ZZj/NqbTYnlP3d1rrGUAtLki7bod7/r4YAOHouUGL05zvsVNts8Cme08TSiRA/pQqe5sx1ri1wCXV0YveN0hofB1SCltVtGAicbqR0NgxKPYbkN4Wb6onUjvW1YcEqesMtp0mv2J8hooipU5P21FKKqY6O0d6C18x05Hn3HJ2dvaqgZZhrB0jPOzsTHeoLBj3T3duoaZoBoXhiqwXdZfK4rqvZ8CK8Tx69gY+4x2A4pgzG7i4tnnABaA8PI7VtW9EEQHWN/yKrlhj+jVbr9GvuSAqc7uvmuIDJMOO94MXIzrQBhekpLhgDEsWvhspdbZt+z6xgQ5bcRGaBWBuN1EwkMfM1W+hr+04jTufMkEtrbgoUjD2irtB6jQ99YANM0KDQKSA2jveQN+WjQzu3WvEXGgglADlb3898cMn6H9qA+gCqQskQar/6U4SDR00/WatEScgBUlNpfa6eYy5biYbPvUsA11JUlIx4EWqRKoKueP/rWDPk828eF+9CStGXIkTXDQR5I3/UsMHvlDHNz7Vyq//r9sFLk548TbLLBeU8+LW360RyXf/VDgVFwBV6ExaXomW1Gje0WLHWlgBwcG8AFWXTKX92X0m0GAqLlC0eg5KOET/i9vADGq1DimyYDahMbX0PPV0GlYgDRGKJDxmHOWXX0vTn37FYP1xf3AZyUUkPGOB7i1rCZSUEq4bSzaz9tdjMfTePgIVpb7jLHhJtvcQKC/KOp/T4i29xjmodLuShotdGY1Z8Sx+/QOnOimYUI4SUF39TpNSkGzuBCEI1pRnPoGEVFs7weoq+7F1KyQkOtoIlde4xgNo/b3oiRh5ZcY267stJCQGe0glBigqGWf3XUjTz8Nfzs7OXnXQIoRQhBABIUSlEOJ9wLXAf4+wT5UQYo6zAVPAASzmRTSRHKCt7yh1xfMyL96WygKZwGKZ7lVO3GDiUiLsfdwAk1V10R3HYfV5n9MLLo6+sJLP0po7qMqbzKbG33G482V0PWmcIz930Ejw4rl/1gCjmePt7C3dhhd0idB0G0gigUIWz307kXAJ27b+H329jZngorsVl/yCKqYufx2Ne5+m++SeDHAJBCOMX3MvPYd20Lt3u+0+EhrkjZtM6erLaXvg92i9/SbQCELlVZTedTPdD/yFxKlWI1BRCtTSEqreeyut96+lZ/dpkppKSldI6CrTP3A5akGIDf/5IglNsd1ESalSMbuCaz+5kD9/9QAHN/fY4OKMb0mYAHP13WV87Btj+en/tvPDr3SSkoIEqgteLChxPs7mIjq0a5DpC/Iz+lV0O+AXoCCqUregnFPrGh3AYgSXKkJSe/UMuracINUzaGTICGkEooZUotcsoffJ9SA1O+vGCGYVlNx8Lf2btpDoaM9QWyw3Udll1xBdsJSG3/6IeFtzVpXF/pplcRtZpsVjdG98idJLrkQ4LuC2eeJmEs0tAARrq51BVBm7JZs7CNWmL/QWvFnNqcwMnOokVJZPqCjiGJ/9au0LIqNwDTkBNd4xSKi80OwXuNUWkVZauvpRowWgqtgxLY6TqnX3EigudgGLdZvq7SYYLfHEm0GirxOAcEEZXi6L9bUDgkh+mf1PijPW7a9tugRNyrNuF+iwXxX2qoMW4LtAEmgFvg58SEr5/RH2eR+wx9MeAlwAIaSkuWcfQTWP8rwJw6ssXjOhwhdWPPCQ0efsd4CLr+piPbb3HUWMi6NPkQpzK65hQeX1nO7dzbr6++geMlQXl7toJHgZTp0ZToHRnHPpGeO9oOOMXbH+MwuoIRbOfhOlJZPZvv2HdHUeHRFcympmM2bW1Rxd9xtiXa1paDGzHgoqxlK99BqannmAVE+PkcFigkv55dejFhbS/uADkMIGl8KVKwjPnEb7D36HHtcNN5GuULB0NsVXL+bUVx8i3hszMjR0BT0UYcFnrqdtawP7frOPuB4wM3ACxPUAs26ZzKLbJ/Crf95Je1PSBhdLaXGCy6obSvjU/43ngR938b+fbCcWw1ZdnJlClqVdR5k/CYd3DjHNAS2qkLZLCLBTrAGmXFzNqbVNruwWK66lfPFYgtEInS8dQAiJqlguIknJmiWkOnoY2nnQJEJsKAjPmU544ji6n3jSyNrxqCJSACpU3XQH+ROnUv+bH5Ds7coMyCULrPjM17NlLSIQJLpoqb1fRnq0Y/9kUwtqabGRYeQ1B2gkmzsJ1RpqjNd1ZJkFJv0nOimcUDbsmHM1bxBuvH2AcHmBDSeWOR9LKUh19aGW+CtGQgq0nh7U4mJzB6sftFgMPR4jEC1JbzO3J3o7CeQVoQSCnkwwSay/nUh+KapwAKT13c/ZP5S9GqHli8BS4EbgJ8C3hRD/MsI+3wXmetqt9lbrYgk0du+mNjrb8NU6oWE4lcUPWKx5vRCTxTXkOxaP6gIZkHLG4GIec03BdC4ecy/RUBUbGn/DgY7n0TQjq3BU8HKWADNyXItjjObsN4HEVF0UVOZMv5O6movYufNntLXuSYOLxAUuVgDuuFlXE62azOEXfooeH7LrR1guoepFVxEqqaTxid+BZqZi6qCKADWveQMDB/YxsG0bQhPmPgoVb7gLrbuHnj8+bab0CnRNoeLe6xDhEKe+9QQpTZA0wSU8vopZ/3Q5u7+3kda97a74lpSucMW/LqR0QiE/ee82+np1OwXZD1zmX1bCF34+gbVP9vPeW09xcE/CEcCrZLiHLGCx3UhSoaNdp7UhybT5BrQ4g2+dF07VrAkzeXUNncd76W/qzXARBYKC6ium2y4iZxZRqLyQwlXz6H18HcKsbWK4iiRCERTffB0DW7eTaGm2XUjpeikWuCjU3PlGgqVl1P/6B2ixgQyXj8uyQIieTNC1/gVKV1+BCAWHj32x3D6NzYbK4ul37iuEJNHcSaimbFSxGAMnuyiakHY3nSmoeJUXb8yS1+0DEO/ot5UWy+wAXEdfqrMPtbTIobKkB0hNQ+vrRy2O2ifXOvRUbzcAwWiJC2aQkOjrIlTkUVnM72usv51IQYU9/kLDSi6m5cLZqw5apJSnpJRbpJR/llK+F/gB8CUhROUw+7RKKfc6G3DUHmDGP8STffTEmqgpmuHc2V9l8QBLei4HJFiPvenRTvMCjA9wnBO4OGHLc+whEWF+5XUsrrqFpv6DrK3/BW0Dx5Dm+GHhxXnfCzDebaNRYbyuIV1Pb3f2S2zVRUjBtAnXMWn8Fezd+7u04qI5gnolrsDcacteh9R1Tm3+U2Z8Cyrjrno9A6eP0L1zfTq+RYe8qjGUX3Et7Q89iNbZZcS36EYadNkb7qT3Ly8QO3ACqQt0XUAgQs0/3UnfxoO0PbkbTVdI6gpJTaV6zRxqr5zG+k89w2BPyhXfklJD3P71laQSkl/8006G4iIruOgoTF8S5Vt/mcbYKWHe/5pT/OLbnSSTVnCuuxkfD/dPwuFdQ4TCgvHT/dNuDSXF+DyoQqd6ehGFVXmcHsZF1Lu3kXhzj6HAmP1CSEpvXE5s7zESp5vTaovpCorMnEJ46mS6H3/ShBXphg7TTSRCQerueTsoCvW//TF6KpGhzGSLabFVlm0bQEqKly5Pv1BXLI3MUHGSTS0E66rTc3lNSPShOFr3AKE6/7gX13Ah6T/ZSaEJLX7A4gTIMzU/YNGlINE5QKjMiKExRA4TWByZQwBatwktPqb19IGUhnsIx+mQwkhfV1QC+QYYOV9WoreTUKF5bjxgMtTfTl5hhQtoLmjKMxLtHFoOWs7eXnXQ4mObMIroTT7XiTr7TxJQwhSHa9IXa+si7FVZPCa9cOBRS4ZrtnnhxfG8Zw0uzuNxzuuYryp/MhePuZfyvPFsa/4jGxp+RcfgKXtMBrx4m/38PgBzNm4k73Yr5sWhutjggmDimEsZW7uc3bvvY6C/JQ0uNpSk3URBNY9py19H+/FtdJ3YmQEuecWV1K66mabnHybZ2e7IGoKylVcQqqym9f7fG8UIzYJoBfPmUrBqCR0//D1af9IEF4XghDoq3ng1DT94goHT3XZ8S1IGmPHhKxFBlY1ffIlYSrVdREmpEijO57XfXUXr0X5+9ykjo2g4cCkoDfGv3xrPR74ylj/8uJMPvfY0TQ0pVzyLM87FUl6SCcnTD3YzeU4egeDw2oB1AQ0okkmraziZxUVUMquKvLEldD6311RazJgORZI3pY7IzPH0PmmoLc70ZxQouflaBnfsIt7QYECEpbBY9xVASJSCPMa+8V2k+npo/MMv0LVEWpnxNCfESAFabIjOtc9SsvIylFDY3x3kMYkk2dBMsK7GDSzCdUOiqQOAUE3a5ePKpHJcpbV4isHGHgonjgw4Z2J+QbjOx/GOAYJlBb5QY5mUkOruRy0u9NloxLMAqNFoGjwcSkugKIoQSho4TPhI9ncRKix1Z5Ob22L9HUTyKyySMn83SJc/yNk/jP0jQMsVGJe0Y2e1t6myICWDiU4KQ+WIDEe5HwSkVRZfYLF3HflL5wsvjuc9r+Dik1mELgkSYk75VVwy5i0UhMrZ3PR7tjb/kb54Wya82M/lAyzex2cAMSPBy3DgMm3itZSWTGb3rl+STAyaCosHXMzbaOkExsy6khObHyQ12OcCE6FDxdxV5FePM91EukuJqbntdcROHKN/0yaj9LwGaIKyO24BoPv+xw03kQ66rhC9biV508dy8uuPkEpKO75FhvNY8Nkbad5wmgO/3euq35KUKnm1xdz5rZXsebqFZ3580gaWbK4iHZVLbinhO3+eSiAoeN8tJ3niT730D0rfTKLmRo2Pvf4kezcN8NZ/q0H3+akwAnEd7iLzKjRxaQWNO9qRunS5iAKKhqpA7TWzaH1qLwp6+qJtqi4lN62i/6UdpHr6TBcR9q9UeNpEIrNn0vXIo+g20JAZbyIkakkxY+99N7Gm0xz/9pfo3r4BiZaptjj2k0haHvotSjhCycqL3WqK15XkeN5UewdaTy/hKePtc+EtIg1GMbZAeZRAND8j6NY+h2Zf964GhBCUzKoetaJyrllF1gF707G96c4AJDWUUBC/dGeZNNzISjCzFo1MJFBDYV+FREvEUENGTJCdFWhtSw4RDGUGg18oy7mHLpy9aqBFCPEDIcRXhRCvFUJcJoS4QwjxW+BNwNeklG3n+hyxZB/hoCmJ+l2IwVdlsc0BHr61V7I1331eIXCx5vJTS3RJfrCE+RXXsqr2Deh6irX1v2BP25MMJDoz4GVY9WU4qBkBYLLHtZiqi2YAmDDnMMBFYc60O1CUIHv3/AaZShk/ivZzpBUXJIydeRWhSJSTm/7okwatMPaKexhsPk3XdrebKFxaRfmV19Hx2MNoXT1YReeUYITyN95F//MbiO0+itSMdXakDFD13tcQP91O02/X2W4iTVeITKxizkevYPd3N9K8M12/JWEqLhWzKrjxc4t58huH2PVce1Zw0bBcSAGi1RE+/8vJrHltKd/8ZAuvXXqE//xAIy8+3s/gEGhSYdu6IT54y3EAvv7wVKYvzvyP2lmrxSg6J81+ybhFZcR7E3Sf6Lb7rOyYgNCpWzOTocYuBvY32GvvCIwLfNHSGQQrS+h7ar3tijGUFgNgyu68mdjRYwxs3eZSWiy1xY5vEZJgZRWTPvTvFF+0gtYnH+LE/32FvoO7kUiXiyjR103vri003f8LBo4eoPbuN6OEw25gcZrncezQEdTiIgI1la7tTigRAmJHGohMG5M1ADd9biXtm09SOq+WUP7wpeLVEeY6U1PDAbT42VeIAAz3sRN+zEMU0tymOIJp7W0SqaVQ1EAG0AgJWiqBqgTtxxc8pkWefeaQkT2Ug5aztVcNtADrgWXAd4CngR8BNcCbpJQfO9tJ09VXjZiWiOrjx9U9YAD+KotzrP14FB9eH3hxzXWm4OLT5wsuzsceoIiGq1hacwdLql9Db7yFl07/hA0Nv+Z0z06SqSF/gLHmGU51yQYwPmNd8JJFdUnHsEgCSpgFs99AX38jR4/8JQ0j3owiXaISYOrSu+ms3+PrJooUlVG78gZaXnqUZHenS40pXX45wYoq2v74AKQs15Mgb9o0Ci9dScdPH0Drj6fToMtKqH7PLbT+7iV6djfY4JLSFaqvnsPYG2ax/pPP0NueJK6rrsDcaddOYPU7pvO7j+2k/vCga90gC1yM4FtrUTwFEVC592M1/HLTLD7ylTHoCL7ykUZet+wwn377KT7x5lNcelMx//XrSZTXjH59FdUsNBetzaOoOo+Wna3pdXEsF5HQKagtonTRONqe3G0rDqqiG/EtAUHJzavpe2ojMhFLqy3m9S9QV0nxdVfT+ceH0Ab604sWOpUQB7iISITyK65l0oc+Qf7k6TQ+8AtO/fRbdG/fQPOfH+DYd77M8a9/ntbH/wRIal/3NsI1NRmVcSVkxrOYSk/s4BHCM6chFJG+mrqAxbgfO9JA3rQ61znLlu7cufkkFUvHZ441AdBrfirLmSgvljtIiQTRY8mMfsu8WUVZJksv0Oo5BKlpCNWAFu/L0DUNxQE0VuaQsS2JGgh5XEcX7sKvn4eWs7OzVw20SCl/KqW8VEpZKaUMSilLpZSXSynvOw+TAxBL9REJFmXGs+C46IM/iDjgJQMqALtInLc57XyBi1cVOhNw8cxbkTeBlbWvZ1XdGykO13Co82WeO/V/7Gh5lLaBY2hacnQAMxLEDKO+ZFNdXO4iE1zyQqXMm3kPDQ0baGrcYoKP4783iR3fUlg8hjEzh3MTrSZSUUfTk/cbMSy2m0ih5pa7GTx0kIEd2+2ic+iC0ttuRKgqXb951IhtsdKgl8+l+IqFnPrfPxHvTRjgoqkkdJVpH7icUFk+Gz7zLImksANz43qQlK6w6j1zmLSyil98YBtd7SmjfosDXDSZDta1wCUpAwQiAVZeX8LHvjWeX22awYe+WEdhSYCPfnUs7/xMHcGQsc6R+yM48k9GQJHULSyneUebfZH1BuWOuW42bS8cdJf1x0h/Lr58PiKg0v/8FhC46rYgoHjN5ajRKJ1/etiGEztQ1gIWB7hIAWq0iKobb2fiB/6NYGkZbU89Qqqni+KLVjD+PR9hysc+T+09b6Fg2vTsBel8TEpJ7OBRIjOmpDszgjJAxuPET7WQN81ci8eM5/GaIiTxzgH6T3RSuXSsq9897pW57KnhAJoDWs7YJMZ31Fvx1/p6axpCcde9Efa2lF3a3wk7uq4hpYainv0ChTl79dirBlr+GhZL9REJeJQWL+2PQP9ZgSXrDh54OR/g4hx7JuCSRXURQhANVTKr7HKuGPdOFlTeiJQa25r/xDMnv8Pmpvs51rWBnlhTRubRGaswjucdSXXJUGFMV1FZdDLTJt/AwUMP0dt9yj8w17wdO2skN9FrGTh9hN6921xuokhFLWWXXk37w39E6+sz3EQaKIEQ5W++m4G1WxnadgB0Rxr0m68HVeX0dx8nkRJ2mX89EGb+Z2+k+2A7u3+03eEiMjOKRIAbvrCUSHGIH75jKz1dmi+4WI8TDngxitMphAoCrL6phH/+2jguuaUEwAYWe1yWK7eVQaSYac8A4xaV07iz3ZVd5FyLqOZSIy6+Z/1BQ2URpFWXcIDi65bT8+e1oCdtKLHVjZBK+RvuYmDrdgYP7DeDcA1FxlJEnOAizaBeKSBYUU7tnW9k6r//F2Pe+E7KVl9uVLxVFY+K4lFZwCd2BpLNLeh9/URmTnXDjeu+JH68CaQkb2rtiOnOfQebUUIq0akV9nnzs9Gs7uy1bHNZ/WokiH4e3ENCEfgelq4hFMXXvSP1FEIJ+OxiQJSqmjEyZhDuhbRzyRyyWs7OznLQMkqTUiepDRFSfYLBvAAAbtfQcCAz2tU+zxe4OO+fCbiMpLqY+ypCpTp/CouqbuaqCe9lYdVNFAbLaezbz/qGX/HCqR9ysP15eoZMgDlbN5L3dVjzDAMuzhiXsTXLqK6Yx/79D6Br/vEtSFxuIr9quXnFVVQtuZqmFx5CHxxyqTHlq68iUFRMx8MP2TVfhC6ITJxE0dWX0vHzB9H6YmZsi4BQHrUfvouetfvpfH4/KU2141tCNaXM/cQ1HPjldk5vbHIF5sb1ACIvzF3fvRgQ/PS92xkcIgNcrMfOOixGkG4aXpwN8A3AdVo2V8W4hWX01A8w1D7oqtViuYiCeQGqL59OyxN7EJB2D5ngUnL9MmQsTv/zWz11WwABoSnjKLpsNR2//wN6Iu4CCa+ryBmga4GJO4NIuoEFN6AYHyzSYxw2tPcAgcpyAhUldp9TZLDuxg6dJjS2EjU/bI6RGZlDdhDunkai06tQAqq7Lo6Pa8gLLMNtt+FxmAummh8i1R/Put0xGTJ15mqPlBKE4zPl+t9N9wUaXTMgSgifysQXyHRpCLtn20YTFZAzf8tBy0hmXwwFQqho+ij+C/EDEd0HOvxSo3Vpt2HnPdtP/ZkssmhtH0l18cKLOUdAhKjKm8Ssssu5eOybuXzcO5lYfBGdsXrWN/6KF07/iAMdz9M91DA6gHHe97qNssS0ZICLCScCwfRJ15NIDtBQvz4zvkW63US10y7m5NaHkMlkhpuoauEVqMEwbesedysxIkD1zXfRv2sHQ4cOpbOJdEHJjdeihMN0//4vSE2xF1UMThxD+Z2X0viDJ4h1DLjiW8pXTGXCa+az5T+fZ6A7kS48Z2YUBaJ5vPa7q+lpjfPbf9tDXFNc4KLJtNKShhg3vHgbMKzKks2qpkUJ5qk07+5wXWydQbljb5xD9/ZTxJs6M9Kfg0URSm5aRfdDz6MnHWqLlQqtQMkt1wLQ9ZfHzSBcaaY9ZwKMK+XZk07tSn/GfetSbnBsFxKJZGDTVvKXLDD7pb2vASTWfRjYfpiCBZPtgnrZTEHSvv44lSsmZKyWbY8xM7Jc+znGeMdDZsButmMoGF/GwMn2Ecep0QK0nn7/11CQj0wkjffNu18kDy0+5D9nKIyWzAQmNWCAnpZKuDdIRlS2c/bqsxy0nIEFlTApPX7WX5Th0pv9QMUXXrLVgIGzD8wdCVy8c44EL9Ycunv/iFrIxOgiVta9nsvGvYOJ0UV0x5rY0PgbQ4HpeDGdheQHMNngxXo+x7aRwEVoOsFAPlMmXM3xE8+SiPW641sy3ERXo2sJWg68nKG2qEqQuotvo2PHWuKtzQbMmHPk100ketFy2v/0B2Q8iZ1NpAYpe8Md9L+0mdj+Y7abSOoKJbdeRqCimNPfeZyUhh3fkpIKU951McFohI2fe45kSnEF5ialSriigLu+vZLD69r58/8eSa9R5AAXQ1kRbtXFhJdsiotxis1CdFJkSYGWdjBuMAg1c8po2d1mu4hUR9CpgqRkdhUFkytofXxXOq7F0UpuWI5MJOl/dnNabbHUE0Dkhym753b6XniZ+KlT6RiWbOBiBfRmKC3u5pfq7HRR2a6hhkaSDc0UrLzI5QpyBuMKIdEHYwwdOEXhRdPsc+W35pAiJIMN3fSf6KRm9URz3PCAM9wYJyiOdnvhlAoGjoycaBkoi6J19fpuU4vMtYv6M6FGzS9AGxzw3y+UjxYfzDxOJYBQVDRHgP+Ftlwg7oWzHLSMxswviqqEDGhx9F1Q81NbXgFwyXAXOZ/H258NXjwAk6cWMTG6mBV199gKTPvQcV46/RM2Nz5A88BhdD3lCzBZ4WU0iot933Al1VVdRF64lKPHnsCuNeHjJgqqeYybfQ2Ne58hNTiQAS7R8bMoGjedpuf+aBeWM+aCyitvRI/F6H7+Oaz1jIQuyJsylYJVS+j8+YPosVS6Wq4SoPr9r6Fv62E6nt2Ppiv2atB6IMy8z95Ix+4Wdv14u+kiMgJzrYyi0qllvOary1j7i+Os+22Da40ia3VoJ7gkZYDhVoD2rlPkZ6rPhXHM/FKadxkF1fxcRKoCY26YS8sTe5ApzU5/Vi21pTBM6S0X0/PwC+iJBHbqs30LefNnkr94Pu2/vR8pNbvAnAswzMJzLkBRHM0DMvZjHHPg3Ga81v4NWwhNnkCwpiJ7PAswtOcYIqCSP3uCmdqd/bejfcMx8mqiFE0u93UNeVWW87UGkWWFUyqJNfeQGvB3EVnHrpZFSXX6QIsAtdCAFm3AB1ryCtCGBlzj7W2RfFI+0CKEIBDII5WMkRHge4FMH+a7Mprmt7hlzkZnOWgZjZlfFFtpOc/m6woabruPm2g0Reqy2gjg4prf6y7yU12cj0cBMJYCs6r2jayovYdwoIBdrY/xwqkfcrhzLQltMANe3MfruPXMnRmM67wvUVGYPvkGmlt20Nt10u0mMiFGaAbgVE9cQTBSROOep1zAgg6KFNRefBuDDcfoO7TLtT0QKaDy2lvofv4ZUq3tLjdR6WtuQh+K0fPIc3btFl0KguNqKb/rchq//xcGm3ptcNF0hcjYcub9+zUc+Pk2Tq89nRmYqyuMW1nHdZ9cyCNf3Mu+FzttV5ABKIKEWbfFUF/SqouzMm76bbMq5Y7u58L6z71ufhkt+7uQKc3o93ER1a2ZgTaYoHfjYX+15fplgKT/mY2G2uJSTAw4KbvrVrTubroe+0saOJxl/sHRT0ZMi291XGsf0s/jAphUioHN2w2VxTLhE88iJAPbD5M/dyJq2JHO6xPPoiBpW3eMqtWTUM15/Fw9znNsP3YGQ3uCny1TRRoa0/u57xdNLgcBQydaHf3pY7ZsOKVFRMKIYACtzwEt5hxqfj4ymTCyCj0WCOehxQd9F6QMBCOkkkMZ/Tn7x7MctJyBqUqYlJ4wfpn+ysQ/Eti47GyyiewnGgW4OMc5n8/q9wKUX58PwAghKAnXMr/iWi4f9y4mFS+lqf8AL53+Cad7dyE94JJRvM56Lt39fMJ73xPfUhqdRFXFXA4dedTIbrCUGCu2RRrKiSJUJsy9gdbD64j1tBn9rqDcSioWXErzCw8j4wmj34SeorkXERk3gbY//QGpSdtNpIbzKXvtbfT++XkSJxo9bqJLCU+o5tT/PkQygV3mP6UrlK+axuTXLWbz556lu77fdhFZpf5TusKc10xhxVum8Zt/3saBdd0Z4KKZAbiW6pIw3Uh+AGMBizZCnQ5nsOfY+WWkYhpdhzttlcXrIsorDlF9xXSaHtlhX8Cd6c+B/CClt15C98MvosfiGUoLApSSQire+np6n3uR3g0b0u4hT4xL1lTmbMDi52Iyt/Vv2ITUNAqWLnCpL9jAZX/4GdxxmMLFU10LRPpZsi9G984Gai6eZJ5LN1A4qws7t2dLf3ZlbXkhJ0sAbyAvRF5dCQNH24ZlgkBZEVrvAGipjJ9CoQiUwkK0/v4MsFDzjXWNXGqLtS2cj5bIFu+SRyoVy9xwgZQX58/X2bacnZ3loGUks74UiiAcyCee6ruwx2PZcLEtw+02kpvI7zlGCy5+8DKS+mLN7/kmh5QIE6OLuHjMvUwuWc7+jmfZ1/400lo920918QMX+/WmxzgLBlpuomkTr2VgsIWWlt0uN5FVdM5yFZXVzqGwfAINu54wVBbzGmpsh+qLrkZqKTq2vZRWYqShxFTdcCdDx44wtHevy01UsGgBeQvm0PmzB9GTMu0mQqX6g3cQO9FK60Ob0XRhl/lPSYXJb11FdEYV6z/9LIkkaReR6Q5K6QqXfGAOi++ayK8+tIVj2/tc4GLFuriziIStvHgXU7SAJZ0CrWQUH3NaQXmY4rEFNO/pdF1wnS4iRUjG3TLPCMht7DQLzRnF5iw1onjNEkRApfeJtUafHdsibRUkMncGZa+9jc7fP8jQwYM2rDhjXCwgyRbH4t3mrPPifJzq7aX7kSeIrrkcJT/imMcCF2x4iR9tINXRS+GS6cYmZ8CxJ56l9YVDBIrClC2oHRY4rH7j1hinCulq6XHu3wk/15J3TNHMGnp219vH67w17kOgsgSkJNXa6XjN6TkCxcWkurrS28xzqxZGAUj19WQU8AvkFZEc6HXtY1kwVEAi/jfy20vOPXQhLQctZ2DRcA09sZaRBwr/0+pd0yM9/Bw/wGcQ2+Jr2eJb/LbhAy7DwYvfGGffCACjCJVJ0YtYWn0HzQMH2dHyCJqWcB3naMBlJDdRJFTM2JrlHD/xjFHkyhmUa6ktunGdHD/nOjpO7WSoozEjtiUQiFC1ZA1tm59BGxiwM4yEDpHyaoqXrqLjL49CSkPowjgOTVB25y0km1vpf2GzkQJtLqqolpdS8aY1tPzqeYbqu12rQadEkNn/di0Djb3s+cl2MxjXnVGUIsBlH5nPnOvG8Mv3b6bh8JAd46JLxRWoa6kuLnhxNGDEFGjLrIDcmpkltB3ssvszXEQYiygWTqmk9S87bSXGUluEgEBegLI7Lqfn0ZfRBwYNN4wzKFdIUKDwshVEr7iE1p/+kkRzsxtcrIuqU3kh3fwgxl0fxpwHScd9vydQUU702svSsGKJr5YrBaO/97lt5M+dSLi62HWZ8rqGhNSpf3g3Y6+fRSCguM+VR2VxwoYXUtLnX2ZWI8b92O/9EEJStXoKnRuPocWT9rHap8gCjMoSlMI84ica3U9sbg/W1ZBobs48rnCEQGGUeEerq18KQbikklhvq/374uThvMJKhvrNfRRxwV1D5wIszjW+cnbmloOWM7BoXg39iXY03eOPtXMbHafTCyLK386p9q3dkjkosy8buPiNHy28OPuzAQxQGhnD8pq76Ym3sKX5QWOpAMfz+oKLNYcXXMBz33g8YcwlJJL9NDdtc6ktacgxWnHFZIqrp1K/+wnbjeQEl/KZywhECmjf9KxLbUGHikvXoPX30bvevWZRoLiE4huvoecPj6N1DxhuIh2krlB05RLyZozj9LcfI5XCFd8SLI8y51+u4uAvttG8szUdmKunoSRFgGv+YzHjLyrn5+/eRFtD0lRbrLWJFJe7yAkv2VKghzPV8Z979awSWg902RfNDBeRFZB741xantwLqZStRli1W4SQFF+1CDVaQM+jL6ZXgHYoLcYbCSWvuYHIjKm0/ODHaH196dWfFWm4i5wQki0Y1zGv1z3U//J64oePUf62u+1y9GlwcbuGZCJB/9rdFF+1CHC4vnwgo3d/M31H2phwyxyHEuWvshhzeQJykRnNeC+yf8ezZR+VLZ8IuqR323F7m1tpkSiKIDx5DInjDe73wDwfwbpaEo1NrgUmwTiPocoaEh3Nrn6ASEkVWnyIVNwZCyOQAvKKqhjsbxtxxe2cvfrtb+dK+rds5q9QNFIDSHrjTuLP/i0SQhiw4h2jZELOOastpvm6iM5GbXHuN0xhu2FVF+s5s8HLcADjmsN4XBgqZ0Xt3ST1GBubfkciNeg6TuE99mzuMifEONSWcCCf8XUrOX7qOaSWzFRbHCnQ4+ZcR1fDXgbaTrlcREhQlQDVy66lY+fLpHp7bdeR0CGQV0jZpdfQ+cwTZjE6YQbzCqKXX4JaHDVWgrbVFgFSoerdtzB0uJH2v+xA0w1gseJbKlZPY+z1s9j8+WcZ7E2aSks6oygpVTQ1yE1fWk7JuAJ+/u5NdHfoNri4F1pUXfCSLQV6tEG5NbOK6TjSC46aHW4XkdFqr5mBNpSga4MRkGu7hzC+PmpIofzuK+l9fD1ad687KNdZeC4gqHjr61ALC2j58U/NGi9Ot08aXjKaE4IygEWSbG2l68FHKbnjRoI1Vb4Xa6drqH/jPgCiK2fZF/1srqH6h3dRsXQ8RWOLzXHZVRYnsDgBxWtOcHGqLdZj9/Ok349QXpCypRPoePlQxrE44SU8eQzxY/Xu129aaEwtqfZ29EQifXTmvqGKauLtLS7YBAiXVAKCWE8r0vObmVdURXyoO62yQsaYv6bpGAHzZ91ySstZWw5aRjDpqBAVVCMUhirojNdngIhwjBvOsrmIYHhwOV9Qk2G+riU/mPAHFxiF6gL+8GKNHQ28mKpLJFDE8prXAoJdbX+xlwVwgYvTRTScmwjcQbnA+NrVpFIxmpt3ZKotDjCJloyntG429WZsi1dtKZ2yiFC0nLZNT6f7TbWlZOklKOEI3c8+bTy/CS5CqJTecxsD67YSP3QqDS5SoFaWU/G6q2j++dPEWvpcaktKKkx7/2WIYIBNn3uOpCYctVvS4CJDIW7/+irUkMIv37+Z/n7sdOb0raG6JB1BuU5z9lnqTDZTkNTMLEZL6nQc63WpLNZ26zZcFKL68mm0/HmXCSrOYnMGwEQvnkOwtpzuPzyDN6bF5aYJB6l871vRenpp/9Vv0KWWTnu2VBVPgTkvrNgrRpvuJ6lrtP/sN4SnT6bw8pWO8TLtGsK4tVxDfc9tI3rxXNRIwH5NkOkaSvUM0vLcIcbdMtc4H57zMxywGOMzM4e81W+94OJ6Hh81pvLS6XSuP4pMWplf6W2WWhSZUkfiRKMRZ+aYQwpJsK4GpCTZ0mT2WTtDuLLGgBZPvxIIEioqY6inxe6ztucXVQKSoYH2dFD1BbRcTMuFsxy0nIkpgvKCibQPnvD0K/Z2123G/j7uI0/8i1CEb8uwLHEzozV/RWaYbCLv9rMBFzg7eHHtLwmqERZV3URXrJFjPZvckDLc8/scozMo15g7zJiapZyuXwu6nl1tkZJxs6+lp/kg/a3HM9QWRSjULL+ert3rSXZ1poN2dUOJqbz6JrrXvUSqo8MBO0btlvwlC+i870/IlDTdREY2UfS6FYTGV1H/3b/YRecscBGRCAu+cDMdu5rY/aNtHqVFsf/DCxSFufM7FzPQleCX79tMX6/0BRcLXmy3kQdgnAG41r5+VlAeobAyQtv+LtcF0+siUoRk7E1z6dp6kmRLZ1qFUIyfd0WRKKqg4t7r6HtuK/EjJ9NBuXYDK75FLSmi6n1vI3bwMM3f+A6JtrY0lChpMHE1lyLjjmvpfuxJUh2dlN97l/GPh9PN5HANWbeplk6G9p6g+KpFrqwh4QAFq7/pyX0EiyPUrJ6YoUBlzQyy1SpHwK6jGX3u9aCcZkOMI/3cGddSuXISejxJz/YTbthyKi1TxiLjSZINpvJsfUkAtSAftaSYRFOTyzUEEKqsJtndiW5WuHUG5EZKqoh1t2YoWIFIEYFQAYP9La7+C6m25OzCWA5aRjLF/GKYX47qohl0DZ1mMNWDK/XZG9ciFFCEr4soQ205RwA5IxvOReQalwU6hhnjCy7DwYufDRe063jegmAps8uv4Gj3RmKpftd2XzeRI+ZlJLVlXM1yBgbb6O0+NazaUhito2zMXJr2P++rthRPmEO4vIb2Lc+lXUTmbeGsBYRrxtD19FOmAiNs1aX09ptJtbYz8PI2A1g0c20iVKrefSv9O47Rte5QhpsoMs6o33LwF9to2tLkABbFlVGUV5HP6354KX3tcX7x3s309+FwDbljXZzw4mwwehdR+eQo3afSmR/pi6X7Al06t4aCSeW22uJdSFEISeHCyRSumkfHTx4GqaVVDgdgGE8CwbE11H7yIyh5EZr++3/pfflldHScAbkZzbNWkZQ6fS+upfep5yh782tRS6L+KovVMPq7H3mZ8ORa8qbVGV1O5chx4dfiKU7dv40Jr5lPICBGpbJY5844l+n5VEed1Qx4cbiFsqktLhdRYYjyVVNpeXSHyy1kueuEALWskEBlCfH9R11ByNa5CI8fR+zkyXSfeRuurgMBQ8317n2AvPI6BjtOAw6ANK2oZCy9XaeMJ3+llOdRmqGYKOfQcrB1tpaDljMxISjJG0thqJJTPTtc/cbNKFxEfmoLGOAyWnjxjnPMM5z7KauNBCjZ1BbfoaNQOOznzaK6ZNvHAy51BbPID5RwtHtjxhiXm8ixz2jUlrxQMaXFk2hq2Ya1enQ2taV68kq6GveTHOhxqy1mwbmqRVfRtW8TWn9/Rgp0xRXX07d9C4nWNncGUlGUoqsupedPT6LHkqbSYqgbwTHVlN68iqbvP06yN+F2E5n1W8bfPJctX3iOwZ6EKzDXCS4FtYXc84NL6e80FJfBAd0O3HWqLk548UuDzlYpN33R1SmqjtDXOoRKupy/c5wda6HA2Jvn0/z4bkgmfdUWISSVb15Dqq2b3ic32EqLsJQWS3UxJkctK6bqA++g9Pab6HroMVq/90OSPV1pF5BTWXGsCi2lxsD2nTR9+et0PvgIZa9/DfkLZhvzOgHJoa5YAozW1Uvvc9upuPMS4/8V0iqF1zXU9Ogu9ITGpDvm+aosIwGLim43wPXYON/+4GK8N+nn8L5vAOPuWkzXxqMMnepwg4v9vgjyF85gcMfB9BvvAI3w9KnEDh9xn2MBaiRCuKqOwfqjGYHOBbWTGGw7bRSfcyo0AqKVU+jpOJL+6nqg5q9p8lziWaT1T0jOzsZy0DIas9QWQKgKE0ovor5vNymZcriEfFxEo1FbvP8xDAcvftsu8H8co66SlA1c4MxcRk5FRcL00lXU9+1mMNmd3U3knSeb2oKtblNbuZDWtj1oyeSwaktJ5VQiBWW0Ht3oARqjlUyaR7AgSuf2l1x1XYQO+ZOnExk3ka6nnzT70kG5xVddhtR0+p5c63ARGW6i0juvQERCNPz0GVttcca3TH3PJaj5Qbb+90skdZEOzPWAS351Aa//0SX0tMb45fu3MGSCi9Nd5IQXJ6C4C88N/xmM1uTT3+Iuz64I6esiqlszAz2WonPtIZfaYgXmKookWFZE2T1X0XX/02hdPbZbxhXf4gAXVCi8fCW1//7PyESCxi99jd4XXyZ++hSp2IBZhE6ayorGwJbtNH3pa3T88rdEpk+h7gsfp/DSFeZ87udwqSzmxbz74ZcJ1pVTtHym7QLyC8AlleLk77Yw6Z5FhPKDLpXFFbviW+NG2qCy/5Hj/OmDL/L7tz3DfXc/wU9ufJTvXf5Hvrnsfh7/+FoSfXF7HtcijM77LmXGOL7SObVE54yh6cHNZn9m/Ev+wunE9h+3V9p2KieR6VNJdXaS6Oyw+8CAjfzxkxk8fczTL8ivnojUdQY76+2x1u9mccUUBvtbiSf6LnhMSy7l+cJZDlpGY0KYsrHxQauNzkYgaOzfP7yLKOtcinnXAS7Z4MXZvObZZ1Qqy0ip1yMoKaMZk7XI3XDuIjgz1cW0yrzJFIerOdK1LmOsOFOgcriSKstnI6VOe8d+f7XFrtsiqJq0nLajGyGl+ca2VC68go6dL6PF4z5qy3X079pOornFUcQOlFCE4pvX0PvnZ9E6+9LQIgUiEKLq3bfS/fR2enacygAXwmHmf+o6mtee4PijhxzAYi526Cj3n1dVaIBL0xC//OBWhgalDSxO1cX6kfXCi7M/2w9xUVUefS3pSqf2xdf5H755EQ0Vhqi5egbNplvC6RqyFAtF0SlZs4RQXQWdv/yz+fXwxLc4wcW8mAZqKqj+6PsoXnMFPY8/RfNXvkn9xz/D6Y9/mqavfIO2n95H4399lY5f309kzkzqvvBvlN5zK4GyEnMeP7eQW2VJ9fTR8/QWQ2VR0yoL5q1TZWl77iCpgQQTb52bobKkz5MbZJyuIJnSeO6/t/LUF7ZQXJfPpFXVzLttIqveM5s1n17Cjf+9ko4j3fz2nsdp2paOBXG6iTJjW9zp1rW3LKDjhQPG6ubO98JseXMnIoQgtu9omvgxg3FrqlCKiogdPZKRQZQ3fjJDDSeMIF7rPQICkTwiZTX0txw33fLWfFBYUocaiNDdedR2EV1oeMnZX99y0DKSOUDAim1R1RBjixdwqmebcYF2pD67XER+aotlXnABf3jJZiONcz7XmbiMzia+xgcOhq3Oe67g4lFbppWspnHgAH2Jtuzjh8skgoy6LUElRFXFHJpbtrtqtPipLdUTlpCM99PdeMBVHddqZdOXIBSV7l0bMtSWggnTyJswma6nn3CpLUIXFK1cTqCynO4/PG7GvKTdRJFZkyi++iIavvMoqSHNgBZHfEvB5GqmvWs1u77xMt0ne21gcca5aBhj82uKeP2PLqGrfoD7PrSFwSFI6gEy3UT+/y16FRijzkv6MxetidDfMoRwuCss87tgjrt1Pj27Gxg60eq4yOOokgtqUFD5zpsZ2LSXwV2HbDCxlQ+fqrkIICCIXncF4/7ns4z72uep+bd/ouz1d5C/cB5KJEz+onnU/ee/U3rnTWb8iuODZgX6Ot1CijS+MuZFvOuBZwlWlRJdNTsjANcFYeicemAbY2+cTbgo5KuyeLOFLFPRiXfHePD9L3LoydPc9X+Xct1/LOTid81k2RumsODW8cy4egwzrqrjDb+6mkkX1/DHdz/Hxu/uRKZS7vgWH7XFFZC7ejJS0+ndfNRx7On/1ZRIkMicyQztOGBDnA11iiBv2lSGjhyxXUCWSydv/GT0RJxYW6OrXwoorJlEX+uxDPcQaoDi8kn0dBxN918gpdn6nJ9tG2kB0pxlt9yZG8HsIFwPjIwrXUR/spOO2ClHv8NFJDLrs2S4iRzg4gsvwzWPuff/O39bRxMs7ICS8vBYyiMTONK1PmPbqNQWpwJku4skNZUL6eg6TDzR51JbjHFptSUYKqR8zHxaj27AKvfvVFtUNUjF/Etp3/4CUtPcBeckVFxxPf27dxJvbLSDcZEgUCi781YGNmwjfrTe4SIyft3L37AGmUjR9JsX0czUaKebaOxrFlM6t45Nn3uWVEL3pEAbtza41BZxzw8vpePkAD9+8zp62uL2j6ufmyhzbaLsF4+iqjy0pM5QV7rGhnVRdrqIwLh4Fk+roHh2Dc2P7cRVs8WhtgghyZ9WR/GapXT89BFDCXDGtzjBxaGOpONXJCI/QmjCGPIvmk/0+isoe9OdlLzmOtTiwnSgLmQCi49bSBGS+PF6ep/ZSvXbrkUJiLQyZLpVnCpL97ZT9B1rZ/Kd8zNUFqcryOsWUtFp3t3Or974NLGeBG++7womLin3xMKkY13C+SprPrmYm7+6kj0PHOHBtz1F2742F6xkU1sAQvlByldNoe2ZveZ4d2C0EJC/aDpDOw4a5Qc8LqLw9KnEjhxB4j7/gaIigmWVDJw+6upHQGHtZPqbjyN1LSPmpbhyKt3tR9GRZ/bP2Hk23UDwc2g5iehs7e/86vZXMGf2kHW2hCAvVEJd0WwOd61zSJ/GuAwAMdWWdJ8HXLLByygsE3gU7wDfbRnH+Ne24dQWyB7jksUmFy+hdfCokUmUbbyP2uI04QGXsqIJBIP5dHQc8Ixzu4CElFRNuIiepoOkYgNptcWhupTPXkFqsI++4wcc+xnb8sdNJm/iFHpeesER7GuoLZGpU8ibP5uePz0JOiawGGqLyMuj8i3X0/HwRgZPd2W4iaSiMPvjaxhq6WPXdzeR8gCLE1x0KSgaU8S9912Boir88I1raTnWb4OLV2mxLJvi4rTBzjhKQBAuCgLYgaBec/6XX3f9XFqfO2BUyLW2edQWISTlr7sSGUvQ+8iLdp+lgNjg4kyHdsKLpxqu6771Rrv2Ja3mKG63kJ5M0PLtP1C0cg6Fi6ZkqCyux+gc+8k66q6aTmFdNNMFRCa8KEIitBQbf7CX373tOcYvqeCNP7+M0rH5aZeR0O1qxF54mX5lHW/6/RqKx+TzwJuf5OhTJ1yw4o4vcmQsIam7YR5dG46QaOvxdREVLp2F1t1H/MiJDADJmz0drbeXeP1pt3ICFEyazsCx/RlrEBWOmYaeitPXdiINLKaV1swkNtjB4ICRZj2Kf0ly9iqzHLSMxhzg4qwLMKV8Nb3xFlqHjvkH5Fpqi9dNZI1zKjgeoHA2pw23bVhg+Vu0cwUXx/2yyDgigSIa+/ed0XM53ULGc1r9IIRCZelM2tv3Z3cRYfQVV0xFDebRfWqPDTIWsCAhGC4gOmU+Xbs3ZCgtSChdeTl9u7aT6ulNqy3mmJIb1xDbe4jYgRMg3UG5+cvnkDdjHE0/eQpdV5COTKKUrhAoK2Lef1zL0Qd2c/qFk2YlT8V1axWf06UgUp7P3T+4hOrpxfzoTes4vrXTSIX2UVac8GL3+4BL+7FeSscXogYVT1qunnGhti7Q1ZdPRY+n6NxwJOPirwppF5wLFOZRce+1dD/8IsnmNju+xQUultKiOO47XS5OUMGx3Uelsed2uImEkHT++inkUIKad9/gjr8RHteLkHSsO0rv4VZmvH25r8pinRv7HJnwse47u9l630Fu/uJSbv7CRUTyVRtUVOscIt19Dngpro5w8/+sZPUH5vHs5zbQcaAjDStZ3gchJGWLx5I/roy2x7b5uogC5UVE5kxmYN0O17mVQhIoLSE0fhwDe3YbXxfznEkBhdNnM3DqKFoillbAhCCQX0hB1QR66vel41rscv6V5BdV09Gy54JmD+WKy104y0HLSJbhGrJuBfnhUsYWz+dw58um/CncastowMWa13rsUF7Sh5AFUizz2ScDWEajsgy3dpJr7r+xDCaM38kxhXNosKDlPLmIKspm0NlzFC0VzwjINZ7XDMgVCuVj59Fxeoc7rsUBJuWzltN3Yh/Jvm7XdqFDwbRZBEvK6F33clppMWNcQnV15F80n56HnkRq0hWUi1SofOsN9G87QveWo5luIl2hdPFEJr9xKdu/+Bw9Df2uwNykrtolyS1wUfJC3Pq1lcy6biw/f9dGdj/RbPxIO/zxvi4i89b7g9x+tI+KyVFXn7fgmTcINVwUourSabQ8scfjRiId0KoY8BK9dB6RWRNo/X+/QY/H3HDhVFpcqovjsfWGuoJ4ccfD2G6nNAwJxTiOwd2H6Xl8IzUfuJVAUZ6vyqJa93WNoz9ay7ib51BYV+RRNvxUFgM4jj1fz9ZfHOSWLy9jznVjMkDFCSu+feY8ipAse+sMplwxhsc/+gKxjkHcQbmZTRVQd9siWv+8E5lI+LqIii5ewODG3ZBKZYBe/vx5DO7ejUS641omTkWoKgOnDmXEtRSPn0P36b324/Q2QVntXNqb9mSoMH9NO5d4FudyGGdqQoiFQojHhBCnhBBDQohOIcR6IcQbfcYuFkI8LYToF0J0CyEeFEJMPucXf4EtBy0jmgUUHrXFbFPKVzGY6qFx4GA6INdUUXwhwwEuruBcJxyBG2BGaq75s8xjbx4FsGQc8wWEkjNQW6rzpzKQ7GQw2eM/1np8Bi6i8uhkQNDZfTTjMJxAAlAxZgE9rUdIDvXZGUY4romFdVMIRcvo3rvZva8ERSqUrriMnk3r0eNxU9FxqC03rCF++DjxfccygnKD42opvmYJzT9+kmRcutxEUgpSUmHyvcspmlrBps88QyIubbBxpkI7wUWqKtf8+0Iuee8s/vCxLbz88+NoEhe8DPcj7HzcfrSX8slF9mNnMK5TXbD7zIv1mBtm07n5BImO3uyuFvMrVPvhO9HjCdq+8wCgeVQRMpUTV+oyHjeRE1ZwxLC4XUQC0Af7af3uHym5fhmFCyf7qixOGGh5Zj+xll6m3bskrbI4QUU44cVw7fTW9/HEpzez8h0zmXZJdXZVZYQ+212kwJpPLyG/PMIT//oiJFP+qpcjILf2mllIXdL5/D5/F9GyWciUxtCuA47zbLT8BXNJtrWRbG919SvBIAUTp9F3dF/GPtGJs4n3tDHUZwbXO8ClfMxcBnobiQ11XlCl5VzbWVoJcBr4BHADcC9wAvilEOKT1iAhxEzgeSAEvBZ4GzAdeEkIUXm2T/63YDloGcHsOgEulcW6FYSDRUwouYgjXWvRZMrYKVtQrrN0v3nfBhcvvJwpKPjt46PYpLcNM797oRHP84xOZTmrInfnaIVqGWE1n46hk/4DzsJFpKohykqm0N6R3UVkwUm0YjLBcCGdp3e74lZsMEGhbOZyuvZuRGp62k2EsT26YAkIQf/WrZ5idoJgdTUFyxbT/ccnkJrFW+l/Q8vvvhKtd5C2P6zNcBNpuoKuBJjzH9cx2NjLnv9Lx7doZrErL7ikdAVdqCx/6wxu/q8lPPuN/fzs7RtpONCX9YfX22e4ngTtR/som1Kccd5dReZ8XBPlC+vIq4nS+uRez3//uOBACEkgmk/dx19PbO8xuu9/xqWGOFWSM1JaTFBxAou1UKP1vO0/fgw1P0zVm66y+52AZdSZSddlOfazDUy8cyH55fme1+QAFcc50OIpHv3X9dTOLeWS98y0QeSMlRYPuITzFG79+ir6Gvt56UsbjfDQDLUl7V4K5geouX4ezX/aarzLHheRUhAm/6JZDKzfkYY7jHMYqK4gUFnBwL40nFgf3cJps+k/ut+uVCxNNSVcWk2oqJye0/scwGK4iPJLxhDOL6W9ee8Fg5YLZVLK56WU75FS3ielfE5K+aiU8nXARuBdjqGfB+LATVLKP0spHwRuBCqBf/nrH/n5sxy0jGRWLQCPyuJUWyaVLUeXOvs7n3MVQ8rqJoJMcIFM5cQJMCM11zFnqivDAks2t9ArDSyjHTdSNpFVBVcIyiMT6Bg65eoHRu8i8t7XJRWlM+joPIS03UNuF5ExPygIysbMo/P0LlewrtNdVDZjCYm+Lgbrj2WkR6uBECVLVtG97kWkLjNiW4pvvIbEyXpiew5lqC2ioIDKt91A2/0vMXi6w+Um0qUgpSuEy4uY98lrOXr/LhrW17sCc9PKi2qvN5TSjbToWdeP5+0PXEkgL8AP736Bx7+6n9iQ8eK9AONVXfY/0UCsL0nVjJKspz3bKsWqAnXXzaH5ib3GuScNC5lqi05kfBXVH76L7odeZGDtzjS4eIBjtEqLs/aLdd/aXwhJ34vb6N+4l9p/uh01EkRRdDveRlXMrCfSrq+GP+0gNRBnyusWeVSWdIqzq2y/1Hjmv7Yy2BXj1i8tIRhwqCa+8StGCyopf6XFAy7F1RFu/t/VHHniBDt+sidDbQkobtVl7G0LGDzZTt+OE9ldRNsPoPcP2CAoFYlQBPlz5zBoxrU413TKnzoLbaCPoebTrnWfhCIonjCH7lN77LgW6dhWXjeX9qbdF2ztISOm5ezL+L8CMS3tQApACBEAbgL+IKXstQZIKU8CzwGvOd9P/te0HLSMYH2DzW5w8VFbgoE8FtTeQkPfPk737/F3Ew0HLoonZmU494+fZRnvH6zrhBLlbx9YslkW1aQkXEtPonnksU4XUbax5v2SovEkkv3EY90Z03hdRKXVM+hrP4GeSprbpQtcQvnFFNROovfoHrvfhh8dihevINnRTvzE8XRogKW2lJWTv2QBvY+/6KmSawTlFqyaT/6sCTT96ElSmkAz416cbqLSxROZcMcCdnz5eWI9CTsgN+lQXrzgkpQq0Qkl3PHNVdzx9RXs/nM937/reY5t6crqItIR7HuygYc/sYXL/3kuZROL8DNnJpE3ewWg5sppDDV0M3i8NavaYgTlGo8LF0+j/A3X0Pb9P5I41pABLjjgQzgVGOEAFUuhEe59LWBRhKR/817afvgIlfdeQ97UWl+3kNWEkKS6+jn+iw1Mf9tyuy6LM/g2YEEHkoCioaKz/b6DHHrqNHd8fQVF5cEM+HCBitBQkXbzAkw2cKmbV8b1X1rJ5h/s4sAfDmZVW4SQFNRFqbxsBk2/XefrIspfOAW1MJ+BjTvdECggf/EC4idPkurpcgFIsLiEvDET6T2409UvBZRMnk9/y3ESQz2ufimgYtwi+rpOkhjK/E7+New81mmZIoSY42lVIz2/EEIRQgSEEJVCiPcB1wL/bc0J5AG7fHbdBUwVQkTOw2m4IJaDlhGsoWWLQfMOcPFTW0rzxzKr6ir2dzxLV7zJoZsOAy7WY8iAl4w05tHGtDAMrAwXdHuOwDLqdO2zcX2dgRWHahhK9RJPDfgPyLI0gHCqMp7tBZFyVDVMb1/9iFlE0fLJSKnT337S10WEhOKJc+k7tsdQUxxjhIRQtJT8KTPo3bTRVFqw67Ygofjqy4kfPELiRD32v63WIUiFirfewMDOY/RuOoRuuoZcbiIEU96+GjU/xLb/eZGkZsCMM5PICy7O1Z6nXFbHOx+8mnGLK/j529byx09sY+sfTnFqZxexQc1WXfY/2cgfP76Vyz80m+Vvnp7xNnjTnt2uovTFsnBsMUXTqmh/wbigetUWS81Ir4cjKb1lFYUr5tD8tV+hdffZBeCE4sj6ccCKcCgpThUm3Wd9bI105e5HX6blf39H2R2XUnbTcntNJG/cjVNlOfrDl4lUFTHBWf3WFUOSdgup6Jx4uZGXvrGLGz67mHHzin2gw1zHyQMpfhCjmIATFBpBobnARRGS6VfWceV/LGXt/2ym81C7r9pi3Y5/w3J6d51mYO+pDBeRCCgUrl7AwNrtNvAZXygITRhLoKyM/l07bHXLApGi2QvoPbjDrL1ifqQVQX7NBIIFxXSedAKNoboUlI4lr7CKjtb9/t/zvx97CNjjae8bxX7fBZJAK/B14ENSyu+b28rN206f/Tox3oHSczjmC2o5aBnBuntP0DfQZINLNrUFIRhXsogxRXPZ0foIMX1gZHABx2M3vEAaBM602eZXjG44dQXcQDHKtY7+FmDFsqJgOYpQ6Yk3GR1n4iIaJvU5WjjGgJYsZmURBYIRCkvH0tt82FOILj1fdOIcEr2dJNqbMoAGCcWLl9O/dyf64FBabTHrtoTq6ojMnk7Po89lqi1SEBpbTckNK2j+8ZOkYilfNxGhEPM+dT0t609y6Fc7jX5HJtFI4BIqCnPdZy7inu+tZrAnyUvfP8jP3vQS/7PiMb59/VP8+n0b+OO/beHyD85m2ZtnjHo1aMh0FSlCUn3FNNpePAR4FxS0lI00sFgL+VW9+2YCpYW0fv03yKE46diUNLy4U6L9twlHH3qK9p88Qudvn6bmQ7dT+dpLUBSBMzvIT2Xp3X2apif3MeefL7NXcnaqLF630EDLAH/+xAZWvHU6828c4wssKtIAEA+8+KktzrEWvFhzGf2SebdNZNJlY1j3xQ0oMplVbSmaVE75xdNo+t26tAvM6SK6dCGJY/WkmlptKJTCcBEVLF5I/44dLheRVIwVz1O93Qw1n/S8FwqlkxfQdXyHy0VkVcKtHL+YzuYsJQ5eYTu3wnJGM+1WYK6nfXcUh/BFYClGnMpPgG8LIbyxKsP94I3CX/63aTloGcGiReM40fCi+YUZXm1BCGZVXUUkEGVH26PoQsu4UGeAi1d18cLLmZb2Hw5URlJXvMDiN7fntQwLLNlibs6X+bhyFKESDVXRE2/JstOZz4kuXdDitxYRNpRIiiun0tN6xKGguF1EkWgFkbIaeo/uzXQRSSicPgclFKZ/5/YMoDEyia5haMceEicbDZXFAS1SF5TdeTl6PEnbHzeYAblpN5GmGwBSOKWKuR+7mn0/2EjD+nobStIp0EpWcElKoyDdhBXV3Pmt1bz/iev455dv4k0/u5Tlb5lOyZh81vzHIpa9ZYZ9KnVPbqqzEJ2VTZThKjJPavVl0xiq72bwWGuG2pIZlGu4i9RIkLp/fR2pnj7qP/4tYnuP2jAiLIHToaa4VBXrq2nFtgAyFqP5K7+if/0exnz6zRRfOs+hvmCqPsZF3BnLgpbi4DeepW7NTCoW1mVVWZxuoef+ezvlE4u44gMzswKLE1Sc8OJsfvDiBy4qOgFF54qPLaTrRA8H/3DI465Kx7YEhM74NyynZ8txhg43ZihM4QnVhCbU0r92myPg2bjNv2ghifp6ku1tDuXEdBGNnUTvgZ32StvW9tKpixhoO0l8oNOxMrcBMBXjF5EY6jnz7/h5ME1ifJ/OutlTHZVS7vW01pGeX0p5Skq5xQyyfS/wA+BLZmaQuUKlrbg4rQzjl6T7nE/CBbIctIxgdbXLaG3fy8BQu/kFHF5tUdQgC+tuZTDVw77O5zPiW8ALLh7VxdXvAxmjLe2fbaHF0cDKcHDDCLDySoHKaEr7m1YcrqXbUlosG6mQ3QhjiwrqDMVtuOOwlJLKKQx0nkZLxhwwg9uNNGkuvcd2u2DEghdFBIguWELvlo2uei2W2hKeONFQWx55xnQdCQNeZLpSbsUbrqH9Dy8z1NJjZxJZwGKV+a+6YiYT717Mls8+TfepPtNNlE6FdoKLVYDOSom2QMaCmVBhiLqFFSy8azLX/PsiFrxmIoBLZXHCz3DmTYkuHBOlaFoVbS8csi+SiudiqXjARQhJsCLKhK+8l4JF02n6r5/R/uOHkLE4zqq5nv85XDEuFnhoXV00fPZHJJs7GP/Fd1AwZ7zLJeRWG4z9Aia8NP1xG/G2fma/bxUBoRFQdAJCNwDFpbYY8HD0uXqOvtTEDZ9ZREDFBpagkkq7dxwAYu3n14Ii5XIVZQOXoAlLxTV5rHz/fDZ9dztDbf0EHS4kRRhgI4SkeHoVJUsm0fKnzWllyRGkXHjpIgbW7UBKI/Xc+AJAcEwNweoq+nbvsGHG7SLa6c4iUgSRyrGEisrpPLkTqbjVlnBhGQUlY4f9LP0D2SYgAEwGjgJDwDyfcfOAI1LK2F/x2M6r5aBlBItG6yguHs/x+udtZSWr2mICSiQYZVH1LTT07eV0326HopJWV2xwAbfqAm5Q8FvteTTNab7qy3mElVdaUTlDKw5W0ZtoHQEw7Ku8b5yLt15LYV4lmhYnkTSXCfDGtTisqGwiUkoGOus9Kkz6fnTCbIZa69EG+n1dRNGFy4g31pNoaR5WbUk2tLjUFusXvfCShYQnVNPyy+dNYEm7iVImvOgIpr59FSWzqtn8qSdIxjRXKrQTXOwKuh7VxQkvfg0yVZbhzA0s6ZL0VZdOoXPDMfuxBSh+biKnq0jND1P1zhup+9SbGdx5mIZ//w7xo6fTXgifOBQLVhIn6mn70UOc+si3UCIhxn/xHYTHlLuAxXpOVcmEqXhLN0d/tp4Z71pJXmlehlvIqWYoQpLsT/Dcl7ex/E1TqZ1R5A66dUBHGlx0u2BctpYeo/uCi+p4fkVIFr52MqUToqz78gYEOkFFy8wkEpK6WxfS+dIBUl19jnNuBEQXrpqP1tNHfN8RO3bIyiIqWLSQgW3b0KV0uYiKZi0g1dfDYMMJU00BK1OodMpCOo9tc6kzltpSNtbvuvzKm34OmUOa2z10vuwKDKf2MSllCngEuF0IYUfACyHGm+MePN9P/te0HLSMZIrCxIlX0dK6a2S1xdFKCsYxu/Iq9nY8w4n+HW5wATe4eFUXr9totG6ikRQYL1yMxm1EFlj5GwMVwIaHomAlST1GXBtw9XvHec0bgOu0ULAQgGRywB37Ys+Z3l8NhAgXlBLrbTXnxQUuQkJ+xVhEIMRA4zGXymK1SEUNocpq+vc41Rhh34YnTSQ8ZSK9T77kVlvMFGiEQsWbrqX3pd0MHG5yuYkk2MG5uhJgzieuJd4dY+c319swc6bgMlyDtMoyWrNdRuaJK50/hv7j7WgDQ/b2jMBXr+vIsT5Q4fxJjP/Ke4lMH0fDp39Ix6/+zMD6XcSPnELr7gWpIYRExmL0PbuJ+k98j/p//z8SDW1Uv+smxn3uXoIleY45HbE0ptrgdAsJdA5+7WmKp1cx4ZY5Wd1CQYda8tI3dhKIqFz23uk+cSdO6EjDiqGipPtCIuVRWzQbXoIirdao9vNrNrwEhUYoCGs+s4TT65s49vhRF6ikK+fqVK6YSLgqSvtftjrOOyiKJFhaQP7imfS/sJk0HRotf/lFJFtbiTecdkFIIFpM/sRp9Ozb4uqXirFK+lBnIwNdjS6lRSqC0jGzR/2ZOp+m418ZetTtLC+9QogfCCG+KoR4rRDiMiHEHUKI3wJvAr4mpbSWuv8MkA88KoS4XgjxGuAxjNTor52HU3DBLActI5gUgtKyKRQXj+fE6edHrbYgBGNLFjK/6noOdr7I/u4XjZ9fC1wcwbm+8GKN9YLBqN1DIrPZ24ZxPdm7+wT2jhZUzjDb6ZzMBzQKgiUIVPoS7RnbzjYYNxiIAIJkIktWkj2/AS+Rwgpi/R2uWBene0hRVApqJjDYcNytopC+Xzh7Af17dqYLsVpQY2YVRa+6jIGN29C6+9Jqi/mLLnWFyMyJFCydSctPnyKlk+EmkiZUBIsLmP+p6zj16D5OP33UgJlRgIsV2+IFFPv0edSYdN+ZfwZKZlYhAir9+5sM9w7YnocMtQU3uKTXKYpQ88HbqfnQ7cT2n6Dtp4/S8KkfcPK9/8Oxez/PqQ9/nRPv+R86fvs0eXMmMuH/fYDxX3gbxZfNRw2pttvJGXirKm5gstxCrU/tpXtXA3P/9UpUxR2c63ULKULSsLWFXQ8e56bPLCCcp/pmCVnA4lJRHIpJUKRQTDhx9nvhxesyUkz1xhpbNb2YZe+aw4avbSbWMWCrLVZMiyIkqgp1r1lM66M7EKmk20WmSIquXMLgtv1ofX2G2gJIRRKsKCM8ZTJ9W02gUbBjVYrnXUTvgR1oWjLdLwTh0iryK8fTcdTI5LSUGDub6ALYBazTsh5YBnwHeBr4EVADvElK+TFrkJTyAHA5RobRA8DPgCPApQ6w+bu0HLSMZAJDbZl0Fc2tO7OrLao/uNQWz2FJ7R009O9lR8djaFJzqy7OOBfIHtfiByHDNddr8HEdjRZUnM/tZ2cDJa8kxACKUCkMltGXPH/fTSEUgoF8ksnBdJ83GNdheQUVxPpMaMoS11JQM4mBxmPuYF7H9qI5C0m0NLldRHb6syBv3mwCpSX0Pbs+Q22RGBBT8cY1DB2qp/v5PSas4HITWfEtxfPGMeUtK9jxP8/Te7LHBpd0XIujgi5WgG5adXHGt3gBxs9NZCwHkAYgP0sH6ErUcIDo9Cq6dzdkuEC8QbmZqdHu+9GL5zH+y+9myk8+zpRffILx//t+6j72OkpuXkX1+29j8g8+StWbryUyriJjDgs2nMBiVb111mQ5/N0XmPqWZUQnlGRVWSwQIJ7gqc9vZeHtE5m8rMJVg8Udj5KurxISVv0V3QQVI0bGaoZSY2xzwosfuASVFHYVXfN1LHvLDKJjCln3pfUIaewXUHTXa6m9bg4ypdH1wl6X8iSEJH/+VNSSQgbWbnMQNyCgcNkSBrZvR0+lXIXmCmfOQ2oa/cf2uQrNWWpL57FtdpyMC1z+gUxK+VMp5aVSykopZVBKWSqlvFxKeZ/P2K1SyqullAVSymIp5WuklJnrkfydWQ5aRjDry1NSNtVQW+qfRyr+aoufmwghKM+fwPK6e+iJt7C57Q8kdDMGyifOJQNevABzLvEtZwMq3v5XAjheAXgpClbQ71VaRhuMm2VcKJhPImkoLb6uJAd0GEpLuysryNgvfb+gdhJDbQ1oibjLRWSNi1TUEKqupW/XDl8XkhAK0Ssvpf+F9eixhEttsW6DNRWU3X4pLT95kmTvoFm7Je0msiEDwcTXL6V0wRjW/ctjDLQN2qnQTpUlpaskHfCimzAzXHwLpIFlNCqLX4VcRUhK5tbRu7fROD8+aktGtVwywcVSXazAUTU/TGR8FYWLp1F67VKKV882VRWnUmPs5+eS8qonipAc+tZz5FUXMeV1C13Bt34qi4rOhu/vIRVLcfU/z3bEmLizf5zA4YQVG1R8AnFDJshYAOMHLvbzeJSZQFBw9WeXUb++keOPH3WpLZYrLFwQoPr6ebT8aTPC2maeVyUARZddRP8Lm5FInJlE+QvnI1MpBg7scwGIEolQNGMePfu2uvoRUDJ1EVp8kO7GA/Zvrw02F8DOLXPIaDk7O8tBy0hmFpUTimDC5KtpbjHVFhso3CqLn9oiFUFRuJIVY16PJlNsaPkdA6lut+LiAy++ADOa9OcR3Ecjun5c7qgzhJRzkWvPB7hYcS2hcsM9dCZZQ8PMhy4JBguMmJaR5pTY7iEpdV9wERLyqyeAgKGmk+ntTtVGQnTuIvp3bTcDfnE3XVCwYgkAA+u2ptUWU42x1JbSWy9GjebT/NNnbLeQ5SZyrgatC5V5n7qBcFk+6z/yKIM9SV9wsVw89mPbZZQ9zsU4hSbAMPyPtlM6d6ZBl8ytpWd/s7GSMG4lRtj3YXhwcWz3ZP04HyuKR6HBDUZW4K0zjkVVdNpeOEDbS0eY9/GrCAQUlyIUVLSM4Nu2A51s+eVhrv+P+eRHAxmBt9mARRXSgBJHlpDVkBrt9UPseqmLzoYhcz+Zdh055nOmS1vxLkHFuK2eFuWit89my7e2oMeSttoSMF1NRmn/hQydbKd/1wnXuRQColcsJtXSQeLwcftDLYVEyQ+TP38e/Vs3uyvdKhCddxF9R/eTHOq3wUUKQSAvn+JJ82g7tMEGGQQ+ePvXMWlj49k1mbv0nrXlztwIJgGpGuBSWjaFkpJJHD76KDrSUFxUj8pifsn8wCUSLGJ53T3kB0tY23Qfh3vWk5KprPDiBZisEDMKOMmY42whZTRuqdG4rLLZcHCULRvIByIKg+UMJLuQcvSp0iOZqgTR9OSoxoYjUaSeMtKeIQNckBAIhImU1jDUVp8Rz2LHtcxaQLKjnWRba0ZArpCgBEMUXrKCvufW2RV2rcUUbdVFDVL1rlvoeW4H/ftOu9xEVrPiW5RIiIVfvBUpYdMnHicekza4pFwKi1n+39nnghe/4EPhApbhXEN+VjAmih5PkRqIu4HF3O4MjPUDlzSUOL9yaTXF2eca75jbqMXiBhYrFTje3M3Brz3NlLcsp3RGZVa3kBV8q+jG2kLTr6hl1pU1roDYtPvGH1icSknriSEe/r8mvvsvx/nEbft464Lt/NOVe/jKu47wz1ft4psfOsyRrT0ESZnKS4qQSKXndWQkOd1EAUVn8ZtmICUcfGB/htoihCS/Nkr5xdNp/eNGw11G+vwFK4vJWzCNvudM0HAsRlm4fAmDBw6Q6us1gcXYlj9lOoH8AnoObHOpKVJAxayV9NbvJzbYmY5tyV3B/uEs95aPYHYxIxMIps28la7u47S077aVFZebSFHcbiIPuATUMBfV3M7cyjXU9+/h5aaf0zh4MB2k64QXZ5950T+ryrjeeUYLKWcLHtnsfMwxSisIlKKjMZTqMzqyrT9kpT37bfN2IRGj1KPVQBgALeFTDsExdaS0inhna4ZryLJwWSXBsnIGDx7ICMi1IKZo9QpSzW3EDx7PVFvMX/7IzIkUXTKfpu//BV3TbTeRphvOGGd8S6Aoj8X/fSv99T1s+89nSabSLiTLPZSUil3XxVJdXPDi0wAXsFg2mvgWAJkyAFQEjH2F40QpTkjJBi544WWEhrG8gKro9iKIrtgNx/Oipdj3X3+maFol09+0OK1GeNxHllsoKDQO/vkE7Ud7WfOxuS63UNo1NDywqEg2/aWTj992gLWPdKIqkotvKOZfvjGB7zwzi9/uW8Bnfj6FVELyhdcf4NN37mPDw23IpOEussDFUF+kr5uooEDhorfNZtcvdpPqj7vUFsvtNfbOJfRsPkbsVKsdkKuYqc7Ra5YzuHkvWn+fSyEJT59KoKSY/m1b0q4jAUJVic5bQveuDejmB95yExXUTSFSXEXbwQ22AnPh3EPntvaQc52unJ2Z5c7cSGZLlwaAFBRWMWHCZRw5+mcSqSG8QbnZKuU6wUUoCnVFs7lk3NuoK5zN7o6n2NR6P71W4KgXXvwA5kybZdkgJcs+ukyR0IYYTPXQl2xnUOs1fNSjfT7fczqKX5ozVVs8FglEESgMpLpGNX5UbiQp/Y/duwYRoASM9ci0VNzuy4iDkRAurSbe2WI/doKLdb9g6iwGDx2wx7ibIFBaSt7cmfQ/v97ut9UWU1GREireuIZkazedf9lqqyuWq8gb3xKqLGbxl2+hdeNJ9nxnvau2S4Z7SAozriWtvAznx7fdRDINM8OZFeOim9ASUNOfDfu//iz7OsEFcMGLX7PmsiDDN8jXCSFmrMupX6xjsL6bhZ9cg6oK++KeLfg2NZTk5W/tZvmbp1FaE8EqIOeuYusGlpDQbFeQTOr88kun+caHj3Pne6r4+qPT+MhXx3DXeypYcXUh4yaqBFXJgpUFfOIHk/jmU7OYvrCAH3/6BB+9cgfHtvcaEGRnIzncQ3YRO7N2y52TCOYF2PfrPb5qS+mcaqJzx9L64EY3OCqS/IXTUEuLGHhxC3bNFiERAUHh8mX0btqILi04MWq3FC9aQbyt2VXWXyoCVEHFnFV0HNqIrqfM3+YLQy1GAt/wkD58y9nZWuBCH8DfvFlfGsf9cRMvp6VlJ0dPPsmsKbfaEfBG6rI0KEcFuyCkqoCW/phKBWOdGiXE9PJLGFs0lwOdL7Cu+deUh8dRnT+N6rzJhNWC9HGc7ywbIZBSZ0jrZzDVzWCqh6FUj30/pvWT0pNItIxdFVTygyUUBEopCJZSECilMm8SITXPNX/6BfsAgRDnHm/iNA9QKEIhP1DCYLILmDTi+FE9hZ/SInH9tyekBF2gBk2lJRV3wYyw2Mbsi5RW07bzBcO1o4iMDCIk5E+dSc/W9ejxOCIStmHFSqOWEoouXUXr936K1tWLWhY1jkm3ntBIgVZLopS/9gpaf/Uc0dVziJTloUuJkMJoALrxOQsoOoVTqlj4hZvY+vGHyKsqYurd8wgoRsVS4xgVQEdDGAse2q9z+M+qHePiUF+GC9C1xjmVFiFkhiqjCIluHxUoCHSZVmSczzBSxpJw3HqBxZu91L39JCd+s4XF/3kD+VUFKI6Yj2yVbzf83IDQ1W+d4lA23HEsXmCx1JXe9jhf+9AJGo7E+OzPJrJwdSGYsOM0VWjGe4PO2IlB3vmZMdz94Vp+8eUGvvL2A3z0hzOZelEUZACEkRurIIwmFYJCQ5eCUFhl2bvn8eL/bGXGnbNQSoocbi+jjX3tUvZ//iFq770CpTiKokh03QjIjV69jN6nN1J0/WUIodpvUMGKpXQ//iSxE8fInzgFdBAKhMoryJ84je6dGyi4dqLRb/72lk5fQuOmP9N1ciflky/K+pl5pU0/R7XkbNL+c2ZYDlpGMKcEKc14EYUg02fcys4dP6W2ahElheOMgF0MGJHWLopE6ubFQBGuGiAWuADkh0pZXH0rXbEGmvoPcLR3A/u6nqU0PIbq/KlURyYTUYsyXT7DXfTNsVJK4vogsVQvA6luBpJdDKSMNpjsNi85gkggSn6gmPxAMSXhOiJqEQElZDQ1hCqM+yk9bsxhztOdaKa+fw/7up5nYtFCJkYXE1QimcdyPsFF14eHOBNICoIlDCRHqbSMwqT0EMowpigBEAq6pbT4gIuQEC6pQk/ESA32ESiKpsdaTyUhf+JUEIKho0fJnzPbOAITViyAicycTqCqgr5n1lJy5/WO7eY5FkZQbvF1y+h5dhstv3iGsf90swkp5qVeMSvQSnNhRQVKF49n7sevZveXnkLqOlPvmY+qiPRFSwrzQq+nT80o3lKvuwjwKDlpRcferhkALQKG9mJBil/eaxpg3OAChgKlCP+D9MJK+n4aWJwqTKp3kH1fepzxt86j9uJJnmJs/pVv+5sH2PLzg9zw6YUUFIjsbiGHS8jadmhrL1/70AnKa4J8/eEp1NQFscJC/c1SaQ0IKilWeN9/jSUYFHz1HQf46A9nMGVJKUhLOVDQkehCR0cQVDQ0XWHujePY9vP97Pn5Li765xXGe6No9vtVvmIS4ZoS2h7ZRPWbrrLdcLquUnTZYrruf5rYvsPkzZ5hLPSpSAJlxeTNmE7f5k3kT5piq9pCQMmiFTQ9+juqr7iNYCCC1AEhUMMRyqZdRNv+tZRNuYjctf8fz3LQMgqTikgXJTPdQKUV06iuXsCBww+xbNH7UIRiZBdL0rBiKi/p+2SAC6ThpTRvLKWRMcySV9Ada6R54DAnerdyoOsFFKESUYvIU4uIBIzboJKHREOXGpo0bnWZIqnHGNL6iKX6iWl9mD/thJV88oOGOjImPMdWSfICRSjq6D4KITWP/GAJlQ71Qpcajf37OdqzkZN9O5hXcS3VeVPcO1rA5YWUVwpcMOJaepNtGaqK0KUNoGf4pJngmMUUjMq4WjI+7LhIcSUIQaKzhUBR1AU01llRAyHyJk5h8PABCmbPdsEKZq0YFIXiqy+j84GHid5wBUph2IxtsSYTpjgSoOodN1L/mZ9Seu1iCmeOQZjuIykFUkhSukJA0U01QqHm6lkIRbDnv5+m/2QXCz56CYGQ9eHFVl0MscihvAxjfq6ikSzZEzNVFuHiIgtAdBNGdMxYHkzgwFJ2hj8md4yMQ6HJAiwBRWf3154iVBxh5ntX28rKcMG3Kjprv72byqnFLLhxjCMVOdMt5IxhUZHsfLGbL7/7GNe8tox3frKGSFjYsKKKLNDiVb+E8b151+fGoKiCr73joAEuS0vRUAiSsnfVpIJVeE4PBlj5vnk88R/rmfW6OQSrSlxqSzAgGXvXEo7/8AWq71qNCOWbnmKrQu4sBl7cTN6cGWk1WkDhymW03/dbtFtuQw3l2d/NghnzUB5/kJ792yifvwoU82MsoXzOKg7e/1UGO+oRyoW5hDnT+c92/5ydneXO3EimGnDhXaxLCpgy/UZi8W7qmzcZSosjKNcdjOu8nxn/IT19QlEpzRvLrIoruGzsO1hd9yYWVt7ExOhiouFqdKnRHj/Nqf6dNAzsp2XoGJ3xenqTrQymekAISsNjmBS9iMWVt3Bx7b1cPfZ9XDH2XSyvfS1zK65hUslFVBVMpiBc6g8sZxAvowiVsUVzuWTMW5gQXcyOtkdpGNzvymRyzftKmQd+CoKl51VpSaXiBNTwmR2Ps06OR20BUNQAgbxCkgO9GYG4dlyLqbYMnTjmimdxbkdCwZLFiGCQgfXbHYG4mFlElltKEJk5iaJVc2n63mNoSc0u8W+lQVvxLfYCi1Kh+sqZLP367TSvO8G6jz5GrCfuioFxBuU6A3NHG9sCuFQWryUHEhz6v7XUrpk1qlPvimOx4SO9zT+eJZ2AZ0OKFVjqARZFSDrWHaVt3TEW/Mc1BCOqDRzZgm8VIek82s3+v5zi6o/OJqC6q9563ULOoNuBrgTf+fgpbnpzOR/8Qq0NLE7Xkl8LmZVurWq56WBbyTs+Xcfld5bztXce5PDmbjsw106BVtKVdRUhmX5VHeVTS9j5ox0oQk8rSCa81FwzC6EqdD2/JyMgt+jKixjctg+trzcdWKRA3rw5iHCI/h3bcQbdKqEAxfOX0rVrvRlDZ/3uCvLKaymsnULb/rWjFT7Pu1nZdmfbpM9nPGejs5zSMoJZ7iGpYMQRCGmDSChcyKTJV3P82DNUV8wjHCjwdxPhvu9VXCBTdbFMKApF4UqKwpXmwPMUB3I+4cGcSxEBppWuJKTmsbv9SVJ6ggnRhf7ZOd79XwG1pSBQSkzrQ9NTqGrQ6DyLWBbLkqlBgsF8d+cwU2laEsV63mEsEClAi3mWB5Du27xxk2h/5s9og0MohXlpgcMeJxCBAIWrl9H3wjoKr1hhKn8mvJhxAcY+koq3XM+pj36Htt+9TPUbL0MFO74FPe0qSt9XiM6uY8X37mbbvz/Ci+9+kGX/fRPR8VH7Io0w1Q4kulSzumAs88a2uCrmWgBkbtv3/55HqIIZH7h02DkFpmtIWp9J474Q0nQLDbu7r7pizens04fiHPz280y4fQEl0ypcbiG3OyjtFgoKjfX/t5eJyyuZtKTc+F/dBRwet5CV1ix1fvCp0xSXqbzlo1U2rAB2HIuSTWkB94+LFYskjPf0nZ+uQwJff9cBPvLDmUy6qMzlJgoKDc2Kb1ECrPrAPB7+4IvMecNc8iZUmIqcjq4IAuEA1dfNp+2xrZRetxhFKOgmuOTPn4paGmVg7Tai116edgWFVAqXLaV343qKlq9EFYbrCF1QfNFKOjc+z1DrKQoqJ9iwIxWomLuak8/+mrIZy4Z/Q3P2qrOc0jKCDQ10pMFFxayGm1Zb6sauJByJcvTkU4Zq4lRTXKX9wZVR5KO4QDpuJmtGzrlkEGXL7jlf85hzTShexLyKa9jf+RydsfpMxeV8AtMw2UT5wVIABkebQTSCJVNDBIMFIw8EdF0DqWdCi8y8r0YKSA0NZN2OhHDdOISiEDt90rMqtLBVFyQUXWylPx9LA4u5zam2qMVFVL3zJtr/8BKDhxodRecc6wV5/jvUpEK4upjl37mL/HGlvPTuB2jZ3GBvd2UYudSXLM2RCp25Pf3TVP/UYZqeOczcT15HIC+U9Zx7IckJINZjZ/Pr88KJH7AIdA78z5MIRTDtbcsdMSlpt5Bf8G3bgU4OP9PA5e+f6Rt863ULWUCz7pEONj/by0e/NoZIGB93UmY1XGfzVr71Ki5v/9RYLru9nK+/6wDdTUMutcW5qGJQaExcUUXtoip2/GC7Q1nSbViru2k+QyfbGdp/2tjmrJB7xRL6n99kuKtNpQUBRSuXk2hsJNFQb6YyG9tC5ZXkT5xG1471ptqNneocnTSXQKSA7hO7s34eXknTOLe1h7QLJRG9CuxVAy1CiCuFED8RQhwQQgwIIRqEEA8JIc4pxLzp2Dp3TQD7y2aAh6KqTJt+M03N2+joPoKVhud0Eznrt2SAC/i6izLgxWdcVnBIn5SzA48zsSxzjCmaS13BTA52vmgEsJ5pDMkoU5uzmpSElDwCInxeXESalkDXk5lKC/i+Nl1LAKAGRlBaJATyCtCGBlx9XlPVIOG6ccRPHnfBjNtFZKY/z59NnyP92SJsqTsKzkkoXDGHotVzafjGQ6TiRsClMw3ahhXnfakgIhEW/edNjL1hFhs+8jCbP/s0PfX9mfAiTXDJlvbpARXIXJ9ooKmPvV9/jqlvXU7xzBpDlh9NmnSGayjtLrLMu03xwIvwzGONqX9gG+0bj7P4C9cTLgwarhJHmX81I6bFaOu+u5epl9YwfkGpb/Ct1y2kIulujvHDz9bzhn+qZNrscPYsoyzuIRVJCM2Gl6DQ7NRpC1xCisbbPjmWcdPzuO8zRwiSdK0GrTpeh6rAyg/O58SzJ+nZ30rA8dqFkBTUFVG6bArtj211LJmgIwQUXb6YVHs38YNHsRZRRECgpoLI1Cn0bkpXu5XmbcnilfTs304qPpT+/RUgAirlc1bSdXT7iJ+FV8LkuazwLBVkLoL4rO3VdObeC0wEvgHcAPwTUAVsEEJcebaT9rYcor+73gYX963RSsqmMnbsKvYevJ9Yqt/SqDPBJZvi4qe6OODFG/OSAQpnoIKc1+Y3t8OmlV5MX6KdpoGD/sdyvswJOA43kxCeDKIzcUF5ji+ZGgIgGPCBFmu8uYtUQNPNUvOjcQ+FC0jFBv1VFrBjXPLGTWTo5HF7u3COdYBM0WWrGNqxl1Rnd4baghVwqyvouqDyrTegDcRo/dVzxmZTbbHhxQdcdAS6CDDtvZex7Ft3Mtjcx3Nv/DW7vrmOwa5kJrjoIyguHoXFcgtJTWfnfz1F0eQKJtyzxHXOzqSSrrcInbdZY1yuIdLA4rzt2VXPke+/xOyPXOFyCwEZoOJUWZp3t3P0pWYuf/+MjDgUW2XxuIWE1PjOv51i/NQwd72zzAUsgAtWnMqIX3OCkfXYCS7BgOS9XxzPvvW9bHyo1R7rqs5r3o6bX8qES8aw++e7HCqLZsNL3S0L6Fp7EK2r31xc0ji/ofIi8hfPoP/5jSZ8SLsSbuHK5fTv2I4Wj5lxLRKpQOGMuSjhCD37t6QVbjPGsGz2ClJD/aP+HOTs1WGvJmh5v5TySinl96SUL0gpHwCuATqAT5ztpEUVkzi99wkX5TsLHhll/GHK1GuJRErZd/ABJNLtJjJhxXk/o/hcNjDxAZhhXUhnoKh45xyu+Vo2eDEtLxhlfPFCjvdsMTrOKmPn3KwgUEZ/svOc50noJrQE84cFLqvYlZYylBZFze7OsEyN5KPFzdWjfWDF6s8bN4lYw2mk5lnPyLyAW4pLZNpUAhVl9L+0OVNtke6gXKWwgOr33krnIxvo33MKTVol/bGVFye4aA4XkJSC4rljWPbtu1j4mWtpWX+SZ+75JQd+to14f8oFI15wyQSZNKwkhlI0vnCMDR95mL6j7cz7xBqEqmSoLNnAxep1KivCdTJx9XsVFy+w2HEsSY29X3qcMTfOYdx1M91uIZc7KFNl2fD9fcy4qo66WcUulQVIw4THLfT8Hzo4sG2Aj3xlDGpAuBZPtIDFDSXZW2bsjLk/6dsJ08Lc8cFafv3FEwx0xuzX4QQW6/UsvncmJ184xWBDj+t1qkKnbOlEQpVROp7ckVaurIDcq5YyuHUfWm+f7R5CgfyF8xCqSv9Od0CuCAYoWbCczh3rjAq5juq5gYIoReNmZPlWvbJmuIfOreXs7OxVAy1Sylafvn5gHzDubOetmr6a7qYD9HWdtgnf7S4ywEUEgsyeczc9vac43bSRDDeR8FTJzQYuWWJdvI/PBDjOCESynd/h9vVTfkwrj0ygP9mBfh7XAPK1LO6kolAlfYmMj8bozXwtiUQvihIgoEZG2MGwZKwXgGCk6MyfMgu4hKpqkckEqW5LOcKGHKeLSAiFwkuWM7B2M1LTfdUWJ8AULJpO8ZWLaPzmQ6QGEwZEONYncoKLBS8ps+S/JhV0qVJx8XRW/+wNzHjPak48tIcnbvoxL7znQfZ+byNN608T70+R0lW7eeXywfZBTjy8l80ff4Snbv4RO//zSYLFEZZ97x7C1cWubAsnrJxJFoZfxpBltuKCP7AoQtLy9H6SfTFmvnuVK5bDm+IMuFSWntN9HFvbwsq3TBlWZYG0epIYTPLr/23mrndXMG5S0LXduPWCyMgtKJyBvwa4hIRV0t+4vfUd1ZTVhPjdF49nwpHlKhKS8YvLqJhRxsH79xFQNEf1XyP9uebG+bQ/vh10LX0enQG567Zi+TalkIhQgMKlS+jduDG93pBVIXfxChLtrQw1Hk8rLSbslM1dNer3/3zaiOtsjdRy0HLW9qrOHhJCFAOLgWdHGFcFVHq6pwDkldRQUjeL+n1PMfPit1m/akbdFpH2vSIgr6CCqVNv4MiRxygrnUJhpNJwE+lmJVVnsTmwH4NT6jfjP/QsWS7nkP1yzuZwr1jgIpyZQUKkx5j3C4NlSHSGUj0UmIGxI9poF0bMdh6scyQlxaEqDnZ3kdISBEahemSzWKKPcNAo8Gdc84d/DxJDvQRCBShqwC9EJfN4h/sRM0EjWFKGCARItrYQLC+3NwsHkAhTRSlctoTuPz1ObM8h8hbMdAXtGmONz69Vo6Xi3us49S/fpeUnT1H3/pvMeYVRyNlcTstZG9mVAGd8tBFqgLqb5lO7Zhbduxvp2tVAx44Gjt2/A12TFE+vJFSch9R1pC6RmnGbGkjQd7SDcFk+VasmseCzN1B+0ThEKGieHuPcWHEw4K+y+PU5M4n8zKXGkB1YhKZx8jebGX/bfMLRkA0nzlol2VSWXfcfoXpmMePml6A4AmPBX2UBeOgHLSgq3PEOP7eQG1i8r8PXnJuFbkoZRkCsivG5UIUgHFJ4z3+O55OvPciqW9uZdomRrRREQxcKipR2JtGC103nxf/Zyvx3LkbJUwkoGimztkvd9XM49fO19G85TMHSWa4KuVZAbtG1l2JXyFWgcNVyel94kXhjPZHasXaF3GBpGQWTZ9C5cx35YyYbn3Hz8MMl5f6v9xU2/RzVkhy0nL29apSWLPYdoAD4rxHGvQ/Y42kPASCgbt41dDfup7+rIe0aUt1qC2Ydl7oxyygtmcy+gw+gS91es8g3vsVyGzGM6gLZFZfh4lf87BxcSRnHYVqG8uJRXCKBIhQRSMeVnI2LyFrY0K/faT6wEw1VAvLc1BYgHu8hHC52P/0w5z0e6yGUF83c4MuhmUXr/K5BilAIVVSTaHOsVWTeuicEtbCQ/IVz6H9pkw+wYPdZq0GLSITqD9xO9zPb6Vl3AInDPaQLl+Kime4dq1aFU3WRUkAwROlFE5j81lUs++adXPnoe1jytduoWjWJwkllRKdXUTK7hrIFY6hYMp7aa2ay/Huv5bIH3s7sf7mKipWTEaGgHVfjDNyFNJzILAAzmsglb2Cu8GzzupNaXzpMrLWPSa9daI7RXXNkU1mSQyl2/ekkS+6ZRECRNoA45/CqLH0dcR76URtv/mg1BflOSNEzgMV2y4zoHnKPc8e5pI8rKFLMXJTHmjdW8ovPHUcOxV3Pa7mKFCGZce04AhGVY48etucPCCP4NlySR8VlM2j787bsAbkH3AG5wboqwpMn0btpo+02spSVksWr6Duwi9RQv+sfxTMQ2nL2KrFXLbQIIb4AvAH4Zynl1hGGfxeY62m3GhNBYcV4iutmUr/vKUe6s0Cq2F8cq6EozJh5O7FYN8frn0+7hTzxLRng4ucucsLL2QbjninYDDefd5vDsrmbjGDYUgbONq5kpODZEbYHlDD5gVJ6zgFapIBYopdIOJrxI2m/7x5LDPUQynNDTtZ/rrxF6Oz+zK5QRRXx1hYfUBEuFxESClcvZ2j3frTuvuyxLY77ebMmUP7aK2j8fw8ysL8xA1w0B6hI0itDOwttWdlCziwkEQpSunA8E9+0gqnvvpRp71zN1LevYspbVzLxTSuYcPcSojNrkUKx4cgJK8CIwHImgbkZWUSOfuc2W2WROsd/tZlxN80hryzPpaI4VRZjn7TKAnDw8VMIAfOvr7NdSIA7MNYZyyJ0Hr+vjfLqIFfeWmTPmQ1YrLnADATO0pz7eMHFL77l9R+pQ0/pPPytUxmxLVaV3EgY5t45lQP370eVSXucHZB780J6tx4n0dTpE5A70zcgt2jVCvq3bUVLxE1gMfoLZsxCzS+ke/dGd/rzBbqCnZNryGw5Ozt7VZ45IcRngE8C/yGl/PZI46WUrVLKvc4GHIV0DMuYeWvobthLf0+jTflWMK5XbQnlFTN9xm2cPPUC3X2nseNb1GHAxdHnCy/gBpizDcY9F7VlmNiVjHEOKwiWjT7t+GxSnZ3gYu3v6IuGKulLtI1+Pp/XFU/0EA4V+ww2n87xmUBAItZrQIutxg13+MO4/DxwEqqsIWkqLWlI8b8fmTYVtbSE/rVbsqotzqBcXReU3n4p0Uvnc/q/fk2svtMFLlZwrhWMK0nXV3EF6Up3qrOlwDhBRnMAj2ubM0XaJ7vIGgf+wOJlOS/MDAcsdp9wQ0nHpuMMnOhk0j2LzbG6ax+/jCFjbp0dvzvCgtvGE8lXbEXFVZfFo7LEh3Qev6+D295eTiiQdv/4AYt93wIT4d+AtArkCy7u+BZV6BQWCd722fE88bMmmvZ1Z1Vb5t85lf6WARrXnnalP6tCJzq7hvwpVXT8ZRuZAblLjAq5noDcvIXzEYpC/64dru+TUFVKl6ymc/s6pLUS7Rn+H3Y+zVow8WxbDlrO3l51Z84Els8Cn5VSfvF8zCmFoKBqPMW1M2jY97SjwJxIB+ea/3Fb2URV1XOprp7PvkMPkNRiaXCxAMcLLpCpuuAYOxqIOZfmfzL9ASYLuPiqLUIQVguIawOZ2+wds6glZ5KiPMwcBYFSc7XnMzTHtyOe6CMcjmb0Z7P4YBfh/OyQ4zrEVHLEtZ+sa2qovIJEZ8eo5hWKQuGqpQys32IsOOejtjjdRFZ0Y+U7biIyfRwnP3MfidbeDHBxgYdPkK4FL6Ou18LIxei8sOKt72K9NKeNpL54t2aLC2l68gDVl06hoKbQFcti3XpVFjAgpOtYD60He7jojgn2XM4MHjuo1gE6Gx7vQtcka+6IuqDCua9LDcINJ77uIQumHKpLpktJt5UeS21ZdlUxS64u5XdfPm6rKM66LSo6ReUhpq6ZwP7f77dBLGBmGQVVSe1NC2l/ahcymUzHCZkBuYGy4oyAXCUcoGDpEvo2bMgIyI0uWo420EffsX222ygXGvKPZ68qaBFCfAoDWP5TSvm58zGn/cURgpq5V9J1eg+DfW3pL4zVvPAiBNOm34KiBNi1/9fo1n8HyjDg4gKStOriu/18uYEsGwlmhlNZ/MDF0afpCQLKKNbsyVJvJd0lXW1U8wBFoXL6Eh3D7zOCJZIDhIKF6Y4RTnOsv51IYcWo5k4N9RPILxx5oAQ1vxB9aBA0Pa2smNt8XUTLLyLV1kH88HFftcWZAm3dRwlQ+5G7CFaVcPKz95HsHvQFFwsmrOq5Xnhxwo0d+2I2b/qzXy0XpwLjBzL2y/acJuf20dhwKosQkp59TZQtHGOO1dPA4nD3uOHF2P/E2ibKJhRSManQlebsLLmvuOBFZ+2jXay6NkqBWQ7IqXA4zVJYvLBizJluzm1OeHGCize+xbmm0Z0fquXgpj4a9xhqi52BZAGKorPwddNo2txE34kuW3Gysomqr5qBTGn0bThgnBdHhdzCyxbT/9IWpJCu39GilcuInz5FvLnRlSkUKCykaPZCuravc8W7XAjTYUQIH77l7GztVQMtQoiPAp8HHgceE0KscLaznzhN9EXVkymsnED9nidAeNQW2w0gbDdRIBhh/vx7GRxs48DRh81rhsgKLn7uImeg7rDqi/tknD+XkB+8jHTfY0k9RnCUqcJ+lg1SMvq9Y8zHhcEKUjJOLNWLFdQrRloPyWG61EimBgl5S/ibEOq1VGKQVGJwWGhxupOSQ30E8keXGq3m5YOU6LGhkQdLCJSWEpk7k/4X19t9TrXFdhPpwnYTSQkEw9T92+sRkRAnP/crUn1xG1x0XTFjXITLzeOFFyeIeF1Bw7mIvBV5RwMr3u1natlUlqGWXmItfZTNr3NnDDmDcB1H4lRGjq9rYcrqqow0Z2sOq/otGGDR35Vgx9p+LrsxHcuSntMDGh5g8YKKfTyOZruahgEXr9oyaUaEeRdHefJnDS61JV0xV6dudglVc8s59MA+F/Cpik6oIEjlFbNo/8v2jIDcwksXkmruIHH0pBGQa34fgmNrCE+YQN/mTel/CM2Pa8lFqxg4fpB4dzsXMhA35x66cPZqOnM3m7fXAet92lmZs/ItqsLYxTfReWoHfZ2nMtUW4bgWCEN1iOSVMn/eG2lp28WJhhdt1cYPXLIH4+La7lJgLDvfcSvebaMBlyyW1GMElTOAFmdq9SjUEV9wcagtBYESFKGeWVyLw5JJo/BbKJRFDTGB1QLYwQHDfRMpMqDFqb7ZnyWHpQb7COSNDlqUfAOctMHBzMPwxrWYVnTxSga37UHrsdY3cqotbjeRbruOQMmLMPY/3oRMpDj1n78h1Rez41jSCojbXeSEFwkZEDOa6ri+qkv6pbliabyg4oUfr50p1HTvaiQYjRCdVGqcfw/c+LmGAFJDSeq3dTDt4ipXP7jTnK19VaGz8ckeCqIqi1fluZQPy4YDFuNYsjdIg4ulujgDdDMylBxqy41vq2LzXzrobx6w3UhOtUURkvl3T+fIY0eRg0Ou1Z8DQqf2hvn07T5NoqnT/r9OCEm4qoTInMkMvLwFb0Bu4arl9G/dgpZKugJyI2MnEK6qtdcjulDuodFXeM7ecnZ29qqBFinl5VJKka2d9bwWjJjwUlg9idLx8zi141HHP6z+aou1rah4PLNn3sWxE0/T0rE3O7hAZjwLmdv9FJiRWlYbDmS8j70BwH5zkRnb4gstFlz4QEZ6yOjVkOHGCgSFwQr6Eu3+xzCcCUEiZVzsQ8HCUUFarL+dQLgANZQ3qv8EU4NnoLTY0GKUL3eCisscrqC8OTNQi6MMrNvsvvJbqorDTeSMb9F1gVJUwJhPvRmtf4ijH/4B/Xvr04qKQ3Xxgxf3mkVp8LBAJlvzAop34UZnBtFIkJKt38+8ac5CSLp3N1A6vxahCI9bZ3jXUP2mZoQCE5aUm/3Osvrp53GCydo/d3PxtUUEggI/lcVrXmAxjsu/WfDichk543LsWJxMtWXRxUXUTc7j2V82GrEq5ppEzmJz068ZSzAvwPE/H0m7h8wYlqIZVeRNrKDz6V2ottpikHXR5YsZ2LgLPZFIB+QKyF+8AKnrDO7dnf6H0HwhJRetpmfXJnQtdcGgJWcXzl410PJKmgUuVhu76Ab620/Q1bRvWLXFchMhoLJ6HlMmr2HfoQfo6W/IDi7DuYu8YJHtF8r3NZwB1IwEL85+520WS2rx0Sst2UDCKM/q3+xdZeYc5v2iYMVZKy2J5AAChUDAeA0jFZYb6m8nb5TxLFoyjp5KEBwltCiBICIYQhsYygQV4+Ayyv8LoVB48XL6XtqI1KQ9ztdN5IhvscAlUBZl/JffTcHCKZz85M9o/e2L6Endpbo44cVyGzkDc73xLaNt2dxH2eJcsv0nm62ibsb5dbg3ALp2NlA2f4zHBeS4n801tLaFCUsqiOQJV20WyyzXkAUnvR0Jdq8f4NIboy6AcD6nU2XxAos7hsXdcG4T7p8IfzeRW20JKJIb3lrFC79vJdmfcAXtOtOf59w+hf3370dILSMgt3rNXDqf2Z1RIbdg6WxQFIa27LLlQalIlEiIgsUL6d24wfH7a6gt0XmLkVqK3oM7Lxi0nNsKz0bL2dlZ7syNYNJ2y6RbuLiKiqnLaNj7lPEDb0GGt7y/wy2AgHHjL6Wqch67D/yGRGrQH1wgw12UEcvivO+nkGSDmWHAZliXk/Mx+MZx+JoQ6FIjrg0QDpjxIKOMJXEpJyPt4wcu4FJvikNV9CRa/J5oxGNJpWKogTDCUUtlOHCJDYw+CDfR1wVAsLBkVOMBRCCA1FKZGzwvxeUiWrkUrauH2L5DHrUl001kxbc4wUWEQ1S/51ZqP3wHnY9u4PjHfsLQ8VZbRXHCSzo9Or34onfV6NG2kaBkOKXFb+wwp8vX4h0D5NWmiwQ6s4bSfW6VUBGS5n3djFtU5ur3Zg3Z/UJn7/pe8goUFiyPmGPdGUPZzK2epCHF/bxGc6outqvIx03kp7ZcdkspgaBg0yOtLsBxpj/Pu2MKvad76djVbAfkWgBYc81MEp39DB04bUKL8XOihgMUrpjHwPodZvyKtONYClcsI3b0KMnuznRArgCRF6FoziJ6dm26YDEtUp6bi+gccgL+4S0HLSOZSH9Z7GJGAmrnXMFAVyPdLYcylJh08K4JJCZ8CEUwY/otBAN57Nz3y+zg4hPPkjWTaLRxLV4bBmJ84cV73+smynIRH0h2IdEpDPqU2/a6hszHIwKL1I3mNO84z69CSaiWoVQvsWSf73EOZ7qeQlUyV2t2gqzzvY8NdBApLLdjXbI1KSDW04oSDBMojKa3jWBS0xCeFGnXbk53kQkianGU/EVz6Xt+HfYvvePW6SayXUe4wUXXBYUr5zHx6x8gUB7l2L/8kNZfPf//2XvvOEmu+tz7e6qqc08OuzObozYq7CoLhLKEQBLBJIMDNuBr89oGZxv7XmxfG19HbGOwDZhgMkIIJIKEAspCq7CSNmhz3p2cp3PVef+o0BU7zK60IM+zn9rpPnVSd1d46vmFQ3ki5yEvttnIcBQWL4lxryJ9ulvgu4nYH0Vc6kFJaMhSOXSf6lNcbCIjpWTs6Azdy71RQ55+Xev6AOx5Ls+681Ooqtc0ZP4NV1n8hMWckwjd3HXCiItnnBC1JZmEq97WzYNfOYUivSs/2+HPbQuS9G9dwJH7DjqExc6Qm+xM03beUsYf2uVyxpUIRZK5YjOFXQfQp6Y850d8xRK07i5mnt/uEBnbt6X1vAvJHd5PZXaqqd9zHj/7mCct9eAhITg3m3hrN13LL+DkrvtMVSVEbXFuaIr9XqBoCc4795cwjArPvPBp8sWJAHEJqC4Q6cfi1KlHVOrVCSEwkcSlCcyWRtGUBAk1U7+yH24iYhMVN1nxvzfCSI8BUtIS60ITccaLJ4LqSphZyT0NKihK48t0FWZHSTSotBQnhkm09+BO4+8cAxGQlQpCdT1Tu6btNw25X2evvJzCjj1URsYCakt1YPvGT4C42Bl01fYW+v7gXfR98E1MPLidvb/6Txz/hzvMVaKtSGw3gbEVGMNl6nETGJvU1Nv8beq1AzzkxQghMZ7vNaRMTWjoRXPVpfBoIe8xowhJcTxPcbpM1/KMb583oZxTjsFLz+VYvyUVMA0FzEous1C1zPrrO0fd9RwC49rnJi622mKPEaa23PiuLk4eyHPgaW+yObdD7tobl3L4/sOoRjBDbu/V6xh/7CUUo2KJ0aaZKLVuOWp7ltzTL+JZRFERZLZcwMxzz3osmQhILl1BrL2D6f27/T/ZKwLTjfr0tnnMDfPfXB1UijnPk7R0EZi+zdcwPXyYyeGDnnKHhFjkw/80Hk+2seWC9xOPt/D0C//JTG7QQ1zARVxq+bHgJTCRvimNkhkb9YhLLTORr/+Z8ijZWJdPCQgx4fhVFj9hqYUQ4uIfRwiF9kQfE4WTwTnUgW40Tloq5QKV4izJTGMLuRUnhki094bvDPl6pZRg6F7SEtY0hLwkV60g1r+A6Yee9Kotjnmo+l4atYmLlArZ15zHin/7MIt+/x3ouSJH/vQLHPjNTzHy3W2UJ/NO1I87gigqzNlwqTNRW7MKjJ+8mGVeBcb2yzFc+90wSUu40uLU8RGX8SOm43b30nSAoLjb2EpKsWBwcFeejVuCpiEb7oghs71NOOz3wqpnbhPjBu/55THe+fOjfPazsxw9XHHqhZqQ7ORzNdSWhYtjXHB1Ow9++ZQn/NntkLv6msWUpkoMPXMqYCLqfs0q9Nki088fCuRsyVx6Lrknn68641p/MxdtoXzqFKXBU64HSJPQtG7eysy+HTV/m5cLZqbnuW/zCybOHfOkpQ4mDjzvVU1c5CXZvpCOJZs4uft+xxRgp/131wM80UQIUGMpzj/vl2lvXcYzL3yG8anDXuLiV10aIDAQJDF1yYy/3IaPGNVEjf0zpVGy8cZu4HUJi71wonsLq+fuy9W2PdHPePFkddoN+tcYRjnUPBSGgh3unK1+Zvt3DzMnFSeGSXT4Fxh3wffVSt186hdaCIkK+TjOfU5iRlFdeRmzjz2FLJd9KgsB4uLxd8EiK4biEBopBSgK6S3rWPTH72HlJz9E9pL1jHzrEfb+4t+z/4Of5Pi/3s3Yj7ZTOD6KbhAgMv6kdM1uYQQIe64u8mKXOV+Vi6j44S5XEhpGUQ/UCfqxVN+PHZmmZUGSeMqkB+6ss36owuDQjlkMHdadn4w0DdWCm7AAHD+hc+ubRzl5Qmf1Co3/+PQsl7xmmCuvGuIv/nKKbU+VHR8Xt9qC72+Y2nLDu7t59r5xpgfzAYdcFYNsR4xFlyzk8H2H0BTdk7Ml0ZakfesKxh/eVTUPWf4t2Ss2U9x/1FQB7a9fQGxhD/HFi5h+7hnnwdA+f1rOv5DKeGPZoefx6sE8aamDif3PYVhLuHuIiLX1bbqWyVN7mJk4Ub0pufxY3GoLUCUmAhRFY+P6d7Cw93y27/gCI+N7nf0B1QW8RKMWganhp9KQs20ICQkNw24AM6VRsrHO4I5aSeGccpcKUyvVv2Peseq7zURSOmpOR7yPqdIwFaMUHDtCoQHTp6URpUUqkM+NocaSqIl0fTOPlKbS0tFbt67TxnLA9fu0eCvZKorvPZC9aCtSN5h9+nmPylI1FbkUFsPebOUlqLoYjn8KqN0ddL/rOlb++++y9GPvo+26LegzBYa+9AAHPvhJ9v7SP3D4I1/g+Me/y+BXH2b8/heY2XGU0tAUlZIe7bQINbegk6OXvICXuDSTI0NNalTytZUWpy6m2jB+dIbOpeE5fZwFEl0EZs9zOZatSZBpqZIc918g1JfFrZjYp/v4qMEtbxqhp1vhrm918//+qp1nn+jlkft6eMfb0jz7XIk3v3WUL38l5yEu9hhu35wwteX8K1roXhTnsdsHvKqM20R0w1IOP3gEoeuOImPv6736HCYe3wsV00Rkqi2S5Kp+tAVd5La9YDnjVnO2ZC7cwsz255Am83bUlnh3D/EFfQ39Nmca83lazh4aN9T/D4VeyDFzYj8ti8/BDrkTLuKS6V5MS+9KBvc/TvbCtzl1/CRHYF5ppCHNBwlpEgGhKqxZ/UY0LcmLu7/KOatuoa/3AgTCct415yFdN1XhfvwOW2zPvumGUVKbB7jaCHcfdlshzNdKtU2z0PUSs+UxWuKWkuBXNlzRPQGVRXrNRtU2rvdKyPcgDRCKWc9nvmqPL0SgMJ4/Tk9mZVN+OpHWJMd/yeyrlJ8kkW5HCFE3OqWSm0Iv5kl2LnT1R7hZyCrTZ0zHQzXTQNp/MO/qAofAKMkE2csuZPr+R8lcutX8CiTeSggk0jrO7FfS6koghURKgZACIaTJG0X1kBGqSmL1EpJrltBxi/nbVobGyL90jPKpUUpD48xuP8jE0ASV8enq3NIJ1LYMWlvG+RvrbkXraiXW3ea8VpNa8CO6TCf2DcF/+BtI55AwpHAObUVI8727DwQqklRfG7PHJkK/Wn/SOBvFmTLp9ljkfhs2GTh5uMTS1fFIRaVWP6oQLmdcwZ/87yna2xRu/3I3yaRF2ID162KsXxfjNz+Y5VP/McNf//U0N1yfoLNHtcYAkOjW5zasMQ0kujBQEZSlSkyVXP22bh74xhA3/8ZSFKGiSq+JaOVVi3jgL59iePsAnVuWUBGKo7h0XbqSvX9XYXbHUVLnrsawI4kUyFy8gfxzu2h9/VWe62f6vM2M33kXpYFTJBf2ex4cM6vXmaajVxgm8Zj7M/88aZk75klLHaT7VjCx91lalpwTICP2zapnzWUc/sk3WXreG4lpSfNSL4T5xGBf2DHrC0WYBESI6q1BhRXLr0PTUuw5cBeDIy+wbtVtpJIdWBTHIS8Y0rmBCfNqXZ2sm3C44b7jOv24dgthEhe7bQRx8dRz+hORIcnTpWEkkta4y2cjygnW+mxmWQhhCRvDT2D8xAXzhikADANV0ehI9DFaOGqSFvccrO9MSOl85zaEoiKlz0QgCPXpKeUniSVbA+VOGxeRzY+dQihquE9LhPJSnhgHRUFriRjD+Uw45EdIV18SsldfwfSPH6O4/zDJNStwk5VGiIt5TFMlL3ZLaQ4m7f2uw0jr7aKltytwaBrlCvroBJXJWXR7m5qlMjlLZXyGwqEBKqNTVCZmnN87tqCd9MblpDcuI71pOfHedt93Z91wXeRFWPMykCgI/Ink7Pp+/5TWNT0cu/OF2t+1D3rJQIubx19UUjk3Rk+VWb42DgT9WYL5XYIqi1lPcM99Be68K8+9d/U4hMWcg602SVQE7/uVDF//Zp6/+qsZPv7xNrOSdRqrQoI0iZzuOwBVJDoGV97awdf/4QSHt0+y+PyuqtIiTRNRplWj77wejj96jO6tizwmonhLnNbNi5ncto/M+Ssd4iuEIHXBWibvfhR9ZgY1nQXDfCDQujuI9S0kt3sXCYu0CAEISXbT+Yw/9mBTv8+ZgIFAPw2/lHmflrljnrTUQcuK9Qxvu49FV70VRYkHlBQhoGPZZo4/9z0G9j7Ckg3XW8oKnnqAaSayb4kC143AJC5Ll7yG7s5z2L3v2zz53L+yetn1LO67BIFSJQzVR0XPTS1AYCCcxPhVGJ/y4qgutRxV6+23MFkcJK21mesO1TAHedPwN0BY7DquvCmOsuImLoYSIBZdiSUM5Pe7xqijWgEKCtIeU/E28aNUmCKeqt4IAseAC/mxUyQ6ehGaWjU5+uC5bwioTI6jtbYhtIjnb99H8nRk3TTj3d2kzt3A5F0/IvGh9yEUxdlnDhhNXJBUSXgIecGlvphdSMdE4z9shJAITUNb0I22oNupE/qxKjr6xBTl0SmKhwbI7TzM0Bd+hD6VQ+tpI7NxOe3XX0B6wzLXAOa5ZqsqwiEzoCBMlQXzFLDJinR9T1IKWtf0MHt8gkquhJat7fxsQy8ZxBLhdd3rDdkYPlXmkqvTznu3P4vTLixqyKWyTE8b/P4fT/Dr78+y5fx46NiKEBhSkowp/O3H2rj1LaO8/R1JLrnMXMw0TG3RhYEqBQYKOgaqEHT3xVl3UQvbfjDK0gs6TaXFZyJa/tp+dtxxgC2/fbHLRGQqLl2XruTEnc+x6P03OCYiw5Ck1i5FSSUovLiXzKVbLBMRCEOQ3riB3O5ddFxznVfBjs3fwv6nYd6npQ4yS9YgDcnU4d0RSgsILUbfpmsZ2PMwlXLeuWmEhUBj+apIp72o/lUgnelhy7m/yuoVN3Hg6H088+JnmMkPOXUcs45vJWbHn8ZzkxPVLaosKsw5ECnU/Hc3VRqiNbEgfKc/bX+UU6xbfYkKefb5stQiVF3JJUyXhynq5to9dZ1xpUQIJai0RKBcmCaeam3I9FQYHSDZ5bXJh/q2uN6XJ8aJtXU0NJfAg73tBAK0v+VmSoeOMPPQE4F9nvcuHxcMk7RIy9/FdtQ1X1d9Xjy+JYbifCjHR8ZqZ+d+MVx5W9xlhqsuqora1UFy7TLab7qE/t99Bys/+wcs//hv0Pmm16DPFjjyp5/n2N98neKJsapjrvUx/L4ufth1cP0FaFndAxIm94+EtguDXtbRYrVPGJuYSCkZPlmmt18LOPfa8JOcwH4Ef/GxKeJxwR//fgsqInQzxzX/XnZRgne9I8VHPjKNXqr6yrjHs31W/A65qjDYem0bL/x4zMnZ4o8iWvm6fqaOTTNzdDIQRdR16UqKA5MUj4842XHNKCKF1HlryT8fvNYmN66nePQo+uyMx5n9bFlZ5n1azh7mSUsdKPE4ras3MbH3WRdxwGNXRUD36otQ4ylO7X3Ye+PxKC2um1IN4iIUlcWLLuWSLb+FpqV4avu/8eKerzMxfQSJDDrUng6BcT5o9WWAuBCyL2K/G1PFQdM0ZKaPDFYImIp8KovfXFQLfuJilxnS45DbGutFE3HG8kfrzEU6KpQiVIwGSUupMEU8yjxkw/rdC2OnAqTFUycE5clxtPYQx+YohN3vJMR7eml/yxuZ+Nb3KQ8M4XfGDXPOrUleDC+BCSMxbiJjbwFC4yIqbmLjDY+2iBSC2KIFtN94Mf1/+PMs+5v3o0/nOfBbn2TgMz+kPJn3kBc3cbHXSvKHQPuJi5JKkF7cztS+kYZvNJWigZqof2lVhUFhukJ+1qC33xudVjMLLt6cLE8+VeTz/53jn/5fOy2paDXIT1z+7COtjI7ofPrT1cU3Fedv1Tzldsg19xlceHUrQ0eLDBwKjyLqWpahbUkLxx896iEsQkgyS9pJLu5gatt+VwSRmWguvWUthRf3mQ7nrutmYsUSlHSK2Zd21VUwXwkY1krNp7PNY26Y/+bqQApoW3cB04d3USkXPQqLm4QILUb/pmsZ2PsoeqXkqueLJAKcaCKX6cJPXABzheiNv8C5G96Drpd55sXP8syLn2Fs8qBXzfGQjyYIjP911NHQhMOqDd0oM1Ma9SotIQqI9BOaWoSlbiYxF3GJUFsUodCRWMRo/mi1TsDZ1/tWCBXDaIC0CJO0xJLedYQC4c6ANAwK44Mku/o8T47+/vyvKxOjxNobU1qqEwhRXYDslZeSWLuSkf/4EvrMrJeomBOvvnfUlBDyYpMKN4FxkZgAkfEpIP6on5qkxkVmqkTGLEusWsziP38v/b/7Nmae3ceBD/4ro9/bhjRkJHGx4SYkTsSR9aVnl3cwdWQ88P1F+SUYukRRGztnxgbNyKSuBaaZw09W3EbA4LpBJhH53BdzvOGmJK97bdLXtvrP6cNFXHo6VP7sI63808enGTpVXQ3HzpIbRpzsKKL+FUkWLEuw8+Gx0CgiVYHlr+3n+OPHXdFDVfNR58Urmdx2wCQr4BCX9HlrMfJFSoeO4Uk0p6mk1q8nt3t34Bo8j/9ZmCct9SAgs3QNSMidOuhRRvxsv2vFVkAwevz5ULUlYCYi5MTzERehKHR1ruW8Tb/AZVt/m1Syg+d2fp5nXvwvJ7eL2U9IOLN7VWYiyIv/tT83S4QaU1dlKQ0jMWiL+8xDrhBkb3lIgjg3CWl0/aFAXhef2oJpIhotHKvW8c/PB01NoOtFa5yI8QVIaaCXC2jxVLW7iK+pND2G1CveyCGrnygYSIqDp6phns1esD3qiXlT63rvu0ARDP3zZzBy+UCdwHubvNgEwiYkbgLjIjEBIuMjM6GEJoTUuAmNh8i4CIxhmCdT9uINLP/HD9L11isZ+u/7GPj0D5GySlw8X4lLqo8yEbWt72P8xWqEikHtyJFERqM0G7I2VAiKBXNGyXQdc1KNfbt2l7nkorhDSMz63hZhxAXgnW9PsXqVxj/8o7lqeIAYhZiIzHoGmy5tYd+2Sate0ES05KJehl4cgUolYCJqP28Js3tOQsVeQNEcT2tNEVvcS3Hf4aCJaM0qiocOmb8leK69rzQk1nEwx63O1WweNTBPWhqAEouT6lvGzPH91Sdl318EKLEYXSu2MHTwKXATG8C5xrnLLLXFYyYCL3ExPQhBCFLpbjasexuXbvlN4vEMz+74LE+/8GmGx19C2rlkqKG+4JszzElFqQnrpj9VHCSttZtOuBH1whLAVV8HzT3SahO2eepaRCUUhkFXcin5yiS58qR37Ig2mpqkoheD8/VBr5jERo0lw31TXCiMD6JocWIt7cGdvrb268rkOEaxYEZQ+OrPFVo6Q+9vvR/KFYb+5bMYhUIEcfGXVcsDBMZFYgJExmcKCiU0dRQaj3+Ks99ua5EXTaPjlitY/JH3MPHAdgY/9yPn9wtTW9zkxa+6dJy3iOmDo5SmCg2ZiJKtMfKTjeV2qZQt0uKyDkVFDoWhXJbsP1hh3TnVDvyEJapcEYKYovBnf9LKN76R58DeikdtiVrB2g7VPueiLHufmUYYerWOy0S0+PxO9KLO+O4RV+4XU1Fp29SHUaxQOHjKk2QOIUmuWUpx/9EAaUmsXI4+PU15fOysm4dOJxuuvc1jbpgnLXVgE4rMsjXMHNvnOVn8JiIz/PkSZkYOMzs14Cn3qC1Ov6I+cYHqr2S9T2d62bT+nVy65bdIp7p58aWv8ZPt/8apoedM34so9SXEbOTuN1Jtce9rAMKQpj9LIiI9vRuGDKosIUni6hGG0Gy6hnMH9JRn1Q4SSprR/BFnvrWgqQmk1DGM2k/Perlg1o9FEDXX8VKYGCTe3mNF7hAgKuAnl1AcOImIxYh1dtckRHXhJh6A2pKl97c/gDGbY/hfP4eRL7gOand9HyExXPvcCoyLxHjIh+Ha/ITGqENoXGTG7y/jVmDc5EVKSK1fzqI/ehfjP9jG0Jd/HGgHQbXFX9Z2Ti9KXGPk+ZBVwkOQbIuTnyzVrwhUyhYRqBEEU4u8HDpcoVyGjWtN0uInJu4FE9373WrLVa9L8Jor4nzsY9NWG7ttVWVxz0WxyMumi7LMTlQYOjgbmu032Zagc3U7g9sHqqYhq69Ee4rU0i5md5mKp5u4JNYuobj/qPUgVh1bW9CNkklTPHLIPF+iv7KXHZLT82cJxoLNo1HMf3P1YF1vM0vXUBg6QaUw63EQc/5ar9Md/WQ6lzB88KnAPr/aEnqTCiEuYaoLmORl/Tlv4fILf4eu9jXsOXA3Tzz7T5wcfAYne6TTt095cY8JQeJSA3XT+hPihOsyz4R3KoOEAwgsfhi1uev6iZAzhDkHIQSdtokoZE7Crmft0zSThFT0gtWRv4H5p2KRFiWMtPi+ssL4EMmOYGRVmLnQRnHwBIkFfSbRcddvBNK6/gcOOhBSoLa10PuhD6BPTnHij/6a8W/cZS2s6CIubpISoqgESIxbKfE72YaYhyIJTZipKYTABMmL+Te9eRX9f/BORu98jOFvPBIgLmHrE9kwsFSbjQsZfb66BEQtpNriFKYaU1rKJYkWF4gGHwpsJ1zbn+WlPRVaWgT9fV4HXD9ZCSMuYKotKoLf/50WfnRfkcEBSzVx9eU3EZn9GSxYpNHVH2fftonI7Lj9F/QwtH3Q6cft19K6cREzu44H/FqSa5diTM2iD4+ZE7D9WhRBYsVyCocPV6+VDX1rrx4IIa4RQvyXEOIlIcSsEOKEEOI7QoitvnqfF0LIkO2lszX3M4V50tIIBKT6liK0GDMnDjjqiVtpseshoGf1JYwcetpx3oxSW8w2QadcP3Ex+whRXayyRLKN1atezxUX/R59C7ay5+D3eHbHf5HLu2RUXAQI33hhaMJ/xQ/dqASdcG1Yqy4HHHBtuMhGgLDUgp+42H251RZX3a7EEsbyx6r13SErnvlIVNXMY1GpFGpOwW0e8iDk6yuOD5LojAgH97exXhcHT5JY0B/uVVsLYdVdSotNXLSOdvr+7HfoePstFPbs5+Sf/j+GP/UF8jv3IStGNIGpQTwwXJubzIQRGp9CE2lqkkEC4ycvbuJiGILMBWvp/923M/z1hxi543GPylI1FXlNRG7y0n7uIkafP+lxHNZdf91o1jwUi5nt3WqFbU6pF+68Z1+Fc9ZoCCEizUI2/KtAu9WWC7fG6O1VeOD+YqSJqNpPNZJovWUiMucc9GtZtKWHge1DCEN3+rIVl9YNfczsPomw/F3s6cX7OlGyaYoHjgRNRBZpAc6qE+5ZDHn+dWA58M/AzcBvA73Ak0KIa3x188Blvu0dcx34pwXzpKVBCE0j3b+c3KnDVoH5R7r+2uSkc/n56JUSk0P7vISGCLXFbyaC+sQlhLxo8TQrll3DJRf8fyAEz+74DPnChKcPbz/C8xnC1JZGVBU/ZkojSAxvJtwo2HedEJXFfF1VUjzEwr/ZdSGaELnKuhKLKRk5ZsqjtRUgIK74lJYI6JUiQqgobq0/7OsTUJwcJtHeUzXT+RUWH6QwzUOJhYvq9l1tFMFv3BdMH3FRtDjZyy5i4Z98iN4PfQAkDP/rf3Hi9/+SoY9/mvGv38XMI9soHjyGkSsGyYlfaQkjNG7zUlS7CFNTwOlXhpAXLBXFtbijYQiyF62n77ffwtCX7mfsB8/4HG+tr0FWnSTdIdGd5y9icu8wpcnwY8CQCjoKhhSkOxLMjBUxGliQs86h50HYxfrQoQprV/nCpWucs9XFFb1qS0xRuObqBA89ZBFvVxceR1w3scJg7ZYsB7bPeMptvxaA/vO7Kc+WmT48UXXEtQ7K1g19lMdnqYyZpMc2DwnFjAQrHToRULUTy5ZSPjWAUSl5yl9pnI4Trr3NER+UUl4jpfyUlPIhKeXtwPXAKPAn/mlKKZ/0bc+fzuf+acB8OsF6cN1MEj0LKY4O1DQPAajxJC09K5gc2EtH33rzziFNAmBmnAU7G677QUYKnDT/ZoZbq57Vxu4DLBOGe10gIZwrYCrdxQUbf4ntO7/A9l1fYOvm9xGPZZw+PKiRhj8UDaxFNFUaJKm1EldTzV2Vo1QWs6BOW2l+B4YBtvnEkKBYmXFV+8naShmutZJUW5gonKAlUWOVZUBRYihCo1zO1awnDd1juvFfl2xyopeL6MU88ZaOYCc2iXG3AfRCnvL4KPH+RaF9R5b5q0hX/9Yx5v8rpEAgSK5dRXLtKvTZWQo791A6foryyQFyz+5AH58AQO1oQ21rRWnJora1oLa2oLZmUVozqNksSksGtSWDkkkjVLU6R/eH9B+XwnVeCFdd+xC3PoR5KlgZdwUIgpl6kdV8vlJCy+WbMfIlBv7jLlJr+kiv6XOpLmbfhtXGnZG2dWM/WjrOwJPHWH7T6prfdduSLJWCzvRQgUR/7dXBk2mFQs4wj/c53MdGxw02rosewyYnhodUCHTrfFIR6NaXffmlcf7ir6atuVjqj/V9uGGn8weVletTjBwvUpwpoWZU03wk7YUfDVp7EyRa40wcGCO9osf5ToWQZBa1gSIonRgh2dHmlIMgtqib8olR87d2PbxpC3tASipjoyi9fWdVbTkbkFIOhZTNCCF2AUvOwpReccyTlnqwbiJCQqJrAdP7XjTfhxEW1xNzW99aRg4+7XRj94Ew1Rahu/oHhHNFxlRcfMTFrGo/DroIkDsdvz0pKRGqxuYN7+a5Fz7L87v+mws2/wqaEveQH/c6QtX5uedBXYIShqniEG1hKovfNOQ8HrvruKOB/MnmakxGUTzERSqK109A2o/2qtNfa6yH6ZKZ6VQYpt0cw5InDFENOxeCWCztJS0hHEpKA6HUT/VenpkAIBZGWuy+3BdjAcWBEyCEaR4Kq193VKrkxB7AJgd+4mKNKaxJqJkMmYu3kLm42pVRyFM+OUh5cARjehp9chp9eprigVH0yWmM6RkrhLo6MyWdQm1rRW1vRW1vQ+0wX2ud7WgLe9G6OxCq4iEp1fm45yqs8yKCvAjv4o42cTH5rKTt2q3knj/AyU/cxcq/ex8ibt7aDSlNtQmT8BjSXBTSEAJVU+m5ZBmDjx1m+U2rnbBnQ0gz/NmVzbZ9cQahwMjRHN39bTV/knRWQUoo5CTxGmtgRqV9GRsz6OpUqw62Ub4rKB7iElZ2yUVxRkYMjh7SWbJSQwHsy5QiJKo0U/vbhi9VGCxdm0QIOLEnx7KtyUBKf1WBztXtjB+YYPH15vnnhD/HNJIL2ygcHyO1eaWzzIIQEFvYTe5py/3CuhBKIVHbWhCJBOXhEeILfOkCXkGYl7C5M6ZmnuXqQQjRBmwBHvDtSgkhBoAe4BRwJ/C/pZRjZ270Vx7zpKVRCEh0LaQ8NY5eKiK0BAjhEAn7Kdo+jFv71nJs+/co5CdIJtscAuK+KThqC1XiIpGeZWDc7dxKTSOqi6YlOW/TL/HM8//Ji7u/ynkb3oMi1GB/zaotdTBZHGBBerV9ZntNOGEIc5xthrDY+93EpdZYqklsWuLdjBVPRLeR1bt8TEtRrtRRWqSBEOEWV/f1rTQzjlBUtEzWayb0w1VWPHWCeHcvSjxu3ogj6jUCR20JIy74XmMRah/URBpl5XISK5dHjiMNHWM2jz4zgzEzizE9iz45RWViCn1ikuL+w+gTU+jjk8hy2YyM6l9ArH8hsUULiC/pJ7F6OSKuOUQFR2kBO62A/TM55MU5k4LExTycJD2/ejNHPvQJhr/1GAve9VpzvpYfjHvBRcUyESkIei5fwa5/fJBKyUDzuS2ZJMacjxZXaetLM3J4FuOSDtcTShCpjElyZ2cMWhtcuNuN0TGDrs7gMRfm3+ImKW61BUwT0bJlKr29Ck89VWLZSg0dW1WRnsUBFdeqz5msoHdpguN7Zli2NTxTc/fqNiYOjFttbWdeFUVIUks6KRwfBaxTwV4fq6+LyvA46BUg5lwIhRDEeropDw8DEefNK4DTzWrrarsqxAl7OExRqYF/AzLAX7nKnre2Hdb71wEfBq4VQlwkpZxpetI/JZgnLXXg+BtISHSZ6kFpfAitZ4lnv0f1FoJUZx9aIsPUwD6Syy/0EoU6z8W2mQhrUcRaxMWsH6G6SEk8nnWIy5Hjj7BiyVW1x3VuXC7FpQkYUme6OMKa9suabutRWSCUsISFPjsnvcc0ZKktBpEmohatiyPT23FWgg6dE6BATEtHm4fs38HQq0qLW+TxdV6amSCWbTPXNMJXzz8R631h4DiJvkWuH8i7vy7cKoun3EVc7P4a/NmF+4OF9C2EhpJtQcu2WEOFdyylgT42QenkAGVrm33yWSbu+AEippFcv4bU5nUkN69D62itEhjbvCrMCbiVF+e7VKSHuNi/p9qapfdXb+bUJ75N62XrSC/v8agtQgZXfO6+eBl6oczo86fou7jfXOlXCjTXZ7eJS+eyDGNHZ60yt7TqRSprHq/5WWtiTWIsgrREwa+uWBoTOhJNKFx6cZxt28q87Z0Wt3d9BapLZXG/X7YuxbGXctV0/tLrjNu9uo1Dj55EdYU822ai9OIOZg6POXEBwlLKYn3dphloaAxtgeWwbv2mWk835ZER6/0ZlCzODr4TUvbnwEcbaSyE+Evg3cBvSimfscullP/kq/ojIcRzwO3A+wH//p8ZzJOWBiEFqOkMWraVwugp0j1LvBdq30VbCIXWhWuZHNhD74qLTLOIixTYinKY2uI2EzVNXKCquljEI53qYuWy69h/6Acs6ruYuJaONBOd3pckmS2MINFp9WfCDdQNccC14VZVwqKCAsPasrKoEpdI5aRqIsrGuqnIEoXKNCmlLVoRktIkLZWcR30JVotWWpw6wlRaYtmO6Eoh3RdPnaD1gos9ZXN6yrRVCelq75hjXOTFPZdGDo+wOv5zwj9he1hUlM4uYp1dyM0bnN1GIU9h1z7yO15i4s57MP77W8SW9JO56DyyV16Ckkl51RdbecG1MrVhflihuIiL9Rtmr9hM9rEdnPzX77Lyb98LqoKQrnBpv4kom6Lj3EWcevQICy5a5MzfjiCyyYuOQvuSFkaPzFY/SwRxSWXM42V2unnSUihIZmYlXR3NtQszFdm4+KI4n/3crKfM9GuRGAiLlJirPpcxnXGXrUvzzIOTkeN1rm5j5uQs5VwZElo10Rym0jLyqLnquiIkOubPqHVmEYkY5YFhk7S4Dp1Ybw+F/Qeb+sxnGqe76KGr7W3AAd/u4Ub6EEL8H+BPgY9IKT/RQJNvA7PApQ1O86cS89FDDcB9bCY6F1AcH6qeRH7i4tpae1cwM3rE24eomnUiIVxRRIEIH3tOovreXwaBhHR9C7cghMrY+P7wMeuFQNsIu9a5bvZTxUESaoaElvG1qxHq7E617+4zcg7SuzlNfO0Nw+s/40NGa0OgMFMaDXweP5GLaamg0hL4HNGExo1KbgYt3VK3njOMoVMaHSK+0LW44unI4ta0raVdXOXCu9l157oZEVvYfqtMGMLcpEBNpElvOZeuX3w7i/7mT1nwh/8fqXPXM/3A45z4o79h4ls/RJ+YsdoK19jCiSTCJiCGVY5rP4Le97+R0slRRr7zE7OpFNZh5V0Tyf674DUrOfXwQaQhA+n83a+7V7UwuG/a87Wb5MZ7yU1lFLS4YHKsgt7k5TiXN3+8TMb8rcIig2ohLMpo65YYhw7rTE8YVl/RsJPMLVmVYOCwGVUVtnhi5xLzWpAbmPZkxgVI9bVRHJ5yzk/Hr0VR0LrbqYxNeq+1AtSOdvSJybNmGgLzYfP00vg7kz8gpdzp2+qahizC8lHgo1LKv25i6oI5eSr+9GCetDQJLdtKJWddjMKIiwuZ7qUUZ8cpFaeD9QR4rl/WCRkWOVKXuESVuYiLIlRasv1Mz5ysqhBRJ30dUmUnXwtTSsxMuL5FEptRcmqpLFFrEPnLovxfDOn5KySktTZylYnw+q55x2MZShZpiVSmhIL0kaOw30gv5VETaWs/XrLraWv+LU+MgmEQ7+719NMoHGLiISje/QECY0+gic0hHNYWWdfwbWEExnpt96UIleSyZbS/8Ub6//IP6XjbG8k9+yIn//hjjH35TipDY64+AU+uF6r+KvYTskVC1I5Wen7pRoa/+mMKx8eqGXbtDe9Tde/rVlMYmWF0R/W+4iYvdthz34Z2Jk7kmJ4IZlE287uY9YUQdC/UnKRujUJFYK/haed5CYOCcLZ6/SlCsG5dDEWB3bu987adZwMZcoVB75IEuSmd4nR4FuB0RwKhCvLDebMvVwRRvCMNhqQynXcIi7lTorZkMKYt1cc1fTWTRs8Fy19JnMU8LQgh/gyTsPxfKeWfN9H054A08OScB/8pwDxpaRTWTUXLtFKZmQqyfB/hAEh19KGoMaZHjjhEILxdyAEcVd89HxogLi60ZhcxNXMiosMzg8niIG02aZmrc6+lkpgvvUQjEmEZdCFIYKS3XlprJ1ceBwhN528TFNM8NBvY76krRKii44dezKMmkqG/bdjxURoZRsRiaK1tZ/bpMuQrdROYmpsR3PxKS1gdz+b05SM6fjLj+isMgaLGyF5+MX3/5/fo/KV3UDxwhJN/+ndMfOsHyLLuUV08xMWoEhcny64UtF6zhdS6pZz8xF0Y1orQfrUFTHIS72qh49x+TjywP3Dzcefe6F7TjqIJTu2a8jixuqFLBV0qdC+MMTLQ2AKLblSsJlpEwJqfqLjf+yOLbLSkFFasUNm1u+xJMhfo2xUt1bMoDsDIiaJT3x1BJBRBuitJfrSqVDrp/DtN8q5PVP1CbfKitKbRp2cDbFrJppH5AlJvjui9GiCE+F3gL4AfAt8TQlzq3qw6y4QQjwkhflMI8XohxE1CiI8BXwB2Ap85e5/g9DFPWpqElm2lMjvlvPcThOoDpUAoKpmuJcyMHPZ2UuvGE0J+gKDa4hkzWBiWQbcl28/07ClTDTjNBHJhMKTBdGnY9GeJUiPcoc72a9s05CMYoYTFs7qe4SUJ/qR0boISQXrSWhu58kR1vqHmK1nbEdeCCFFawmAqLanI/f7fuDQ6RKyz25sDxl2/7og1Ks/V7DOXdmH9BMxDLkLjSybnJjC2+pLZeh4L//i36X7/e5h55CkG/+4/zKiTOsRF4lJfECz89VsoHDrF2A+eCagtWHXt8r6r13DiwQPoFfPL1N3ExnqtJVR6VrdyYueEWQcRaf7p7osxfNKbQbeRJ3FdN8dXtcbPXz+RCTMRbdwQY9eu+iTKXvG5rUOQzCiMnch7cts4YwpJpjtFfiTnITuKkMRak6AIKuPmA4E77NmjtFiQQqJkTHOTka99Pr6cMDhNtWXuQ99i/b0JeCJkA5gCBoHfAb6F6ez7VuBfgCuklLWfvn7KMU9a6sF3TmuZVsqzXlt1retLtnt50K8Fiyi4zD2e987YPqISYSZy+guZrxstLf3oepF84eUJ058tjWDISngmXFl/0UO7XvS+iFPdb5KJ6sOu5/yVZLR2ZsPMQ2E+LZV8zc9gkpb6n9FUWqJJi9lZ9WV5dNg0DYVFDoUcC6Hd+U1D9aZZg2w0o740tPnaepUVe/MRGDd5QSF9/iYW/umHEIrCwF/+M7lnd+JP/+8nMhIc1UXt7qT7HVcz/NUfU8kVHbXF/io8JqIr11AczzP6woDXNOQ6wXUU+ta3cWLXlMfXJYy49PTFGD5DSkuj/iy1sHFDzDEP+TPj+qFiRuL1LE4wcrwY2We6xyQt4E3aJ1SFWHua8vis1zwEqK1u81B1n5Kx1JnZXHOE/QxCng5hcZHh5seVV0kpRdRm1RmXUr5FSrlCSpmWUiaklGullH8opZw8o1/EWcA8aWkCUoCWbUHPzyB1vSGpPtuzjJmxY0jbAO1rExXqXyUm4YOEERcHfjORNUYy2YmmpZiaaWzht6YgJVP5ARJqhqSW9ZTXzbHih8evxb5z1OnDtzK0009I8jr337TWRr4yhRHWv6sorqaQUkfq5hOxcCszNoQSPU/X72SUCqjxOqTF1aY0Oky8y5u1t+6x18jBWUsFsacQQk6CiolNJsK3ur4uPv+WULOTX4EJIS+xtg56P/QBslddzsin/pvxr30XWdJxp/1HVtct8puJ2m64GBHTGL17m8cB1+OQiyDWkaHr/EUcu2+/x3QEpjOuTUwWbOjg5K4Jp9yGgeIhL90LNYZPVUlLlDnJj4ql9Kghmedq+bDY+6IIzsYNGnv2lJ3+oboGUlg6fzBNRMMWafGvQQSQ6U6RG81X52CVK0ISb09TDjEPqa0Z0zzkg2qRFmP2Z1owmMccMU9aGoR9D1DiZlYpo1IO3e+BgGRLF1Kv1DUt+NtFjV8ryqeemUdYDrlnNB0jOP1NFgdoSywMlIeiUdMQeIiANGRgC63nbm9HEYUgqbYgMShVZsPna5VpmkkyylGLJkpQFNVZJLMWDL2C0Lyp12txjMrMFGprW7Ugqm5YuY+A1EOAoNh9uAmKn5DUUVwa8nWRePxb3KqKW43xKjA+8iJBUTTab7mR3t96H7NPPc/g//sU+uR0kLhIYVkpbTMQiHiMzrdeyei3H6c8lQs45AIOeem//hxO3H+AckF3Qp4NqbjIi2DRuZ1MnMgzNVywyryXWx0zdLhvWYKBYyX0igwQFlu90UN+O80yCxn66Zt3FRTHGXfNKo1iEYYHakcQ2cqLgkFHT4yp0XKAzIBJTBKtcYpTxdAFINVMAj1nOvG6P4mSjGMUSq7s45bpKKaBqiLLjS1K+XLgbDri/k/HPGlpEkI1vzIpQ25OIvhaS5j213Kh+iRR83j1mHxqz6Wm2hJWX0rKlTyxWJ2n/EZJjZ3t1sJk4RRtib7qvtD6IeqHe9wwlcXeHeGXEiiPctqtrornFCWE+V0U9dnqvpD5xVRr0cRKPrDPhlA1pFGpbyIyDM8SA57f0a/ECdBzOdS0L4R8jqjnYFsd2L25SEot1cXnn1LXnBTW1k1K3CTGp8J41BdP1JD5PrluDX1/+iGQMPRPn8WYyVVNQxb5ssmKtL5oKQVt125FbU0z8q3HrZtLyA0KQe/r1mBUdAaeOOohKu6/XavbSWQ1Dj494XytYTer/lUJKmU4cbQ5x9JUyuzLDn2eK/x+LUsXaSgKHDnauMmqpVNjdiKaRCSyGuVZc78/wZyajGEUvG2FkIh4DFn2zcG2gqvqWXXEPYsLJv6PxzxpaRJCMfPxOSdMwA/FW6bF04CgXJwN1vO9j1RKInxbmoVhlJFSR4ul61eu6VsSvLHrRpnp0jDtiYWhbRvyZwmra6knUYSlWs0mJI2boqSUaCKOgkpJz/l3Vl8boKkJwFrp2RrC/9CoKDFrCrUvpoGFFWvWNTDyLtLycl7r3CQCqmSFGiTFTUxwbVHEph6hcY8VpqxYCoxNatz9uH1WhCHQWtro+c1fBUMy9M//hZErOWqR9JEyxylXVel+1zWMfX8bpZEpj9riNhkpqQQ9ly3n+P1mXjC/X4shBYoqWHx+J0eeHbMccW3VRPH4v3T3xUgkBUcPekOG65mJUklzf6HQPGmpZT6KxQT9/SpHj9bPHGPnamltV5kejyY58UyMci58v5qKYRRKgcuaiGnIUjgREpqKrDTvB3SmcLZ8WuYxT1qahlBNr7d6NyanvqKixlNUirMB/xTb+TbUr6XZY9rvx+J/D46JyjZ11IWBLycLkTlKpoqDSGQ13Nnpo4ayUnPsWqQpJHIorFqYP43PGVcIQULNVJWWCCiKhqLEqESZhwDFOjYMvbZsLaWEkHT/YTAKeUCentJS7+uXvjq1yIqrvpukRJGZSHNQlAnJTVRcJCbKr8Vp71ddrDZaOkvvb78PYzbH8Ce+gFGoeNQjabjMRIaClILsZZuIL+pm6GsPoxuKo7ZIqkqJlIK+a9Yw8PgRSrMVR4Gx16TRLb+VJRd0ceTZceerddMAm+goimDRyjjHDoTnOQmDjiRpkZZ8HaVFFQpqRKbmKL+WZUtVjh7RfXWruVr8aOnQmLFIiz/BHFikZbZ6Xriz4qrJGLpLaXEuYWFKi/OhLKVl/t7/Pw7zpKVJ2E/I0mic5ceSGSrFua1P1bCJqAGULdNGXG2QtDQKKZnMnyQb60JTEp7yUIT5s9RK0x/ht+J/76nnaRNCXlyIq+lQ0hLIiqsmw81DVjVbaTGMSiRRkNL87CGLpHnrWbvtJFpqugF1rGaHeOfkJyL2oLWUFR9ZCVVcPP4p5iZ1g9LwMDM7X2Tq2aeZ2vYTJp96ksknH2fi8UeZePxRcjt3UB4cglKl6r/iIjEeAuMmNX7y4qg0wqmntbTR+9sfoDI0ysi/fwlZNsDA698irY9gCBAKPe++jon7t1M4PuJRWtwmoq6LVyAUwcnHjjrrEIHbKVeweEs3A3unmJ3UcSegs2Hnalm8MsFRi7SYpKd6fNiv/UdwPG7e4BtVWqKISxiWLTWVFqet74D2J5hr6dCYHi+jEHyYUzGIZzRKs2WUkBNDScaQhSDRF3ENKjrSMALkRGiatZji2cG8T8vZw/zaQ03CXhBP6o2bIbR4mkop2hciOAjBm55/AcM5rMxcKs0gUNB8S9Se1tpDVtuJwsn6Tri1/Fkg6DBbg6AEyt0XZP/7OkgoaYqWI64wZLjyJc1Vsx1H3JCPoai26bDWxdRq2OD89IIVJppMn5nEcmFfv6vjgF+L66+IKve9N4oF8gcPUjh+hMKxIxSPH8MoFhDxOGoqDYpirtGkmLmMkJLyxJjpWKkoxNo7iHX3EF+wkMy6jSSXLUcoipM92J6HvWqCebpY/xvmxxECpH2OKBDr6KT3Q+9n8B8+xehnvkbXB96FEJYDrttMBBiGIHXeatIbljH4pR+z4o/fiiHNpHNSSIfAqPEYC16zkmP37Wf5DSstlcU8Rg1pTmzBhk7UmMKhZyc47+pO7DWIzAgiScy6yS9ZleCZh6bRUVBDbvxRP2U6JZjOnXnfjqVLVe79UXQIM1gRQNK8Hra0a5SLklLegGSwbixtKi1hZmK/0uL0H7fOp3IF4cugJ1QVWTmLPi2ysVw6tdrPY26YJy1Nwk4e1qhPgtlGBkxDcx5fBH0pGsXU9DGy2b7wRf2aPYtcTrhSSiYKJ1nTcQWhydma7f9lOqPN1ZytG5kdJiolmpKgIkvuiqGvVTWOrkdfyB2lxWUeElLiXUPaHrdB0muN38zxVm3bwMESRljmSFb0XJ7JJx5h4omHkeUyif7FJBcvo23rZSQXLUFr64hOkGcYVKYnKY+OUBodpjw6ROHIYSYefQg1kyWzfhPZjZtJrVptJiZxnVLO6WWt2SUUicRSeVzEJd7TS+9vvY/Bf/wPxr/yHTrf82bPx7LlHHPRRIXud1/L0T/+LNN7TtK6rg9DWosnWn+lFCy87hye+8jd5CeKZNrjjuKiWOn8EwmVJed3cuDJUTZd3UWMKqEBU0WJASvWJ7n9P0fMhHGu+7OBCDXH2OjqUhgZjT6W/OqKKhT0Bo69nm6V0THDalP/lExaCz+WCgaxENIST1hqUcVw9H0nnb+mOg+B9qKJgLnSPYQ/6Jyh6+k8fvYwT1qahO2Aa/u2NNTGqKAoZ+erdqsoE5NHaG9dZk0qeCEwnzijr04e/xYX8pVJivos7Yn+YKNGk8pFoGEHW0tdkYasXuzqwSIvmohRNOrnfFCVOLru9TsQsnrTU9QgaanOz6pvZUo+6ynIfU+JDRGWKLIym2Pi8YeZfOIRlGSSrmtvpvWCi1F9Yd2OuScEAoV4Swfx1g4yK9Y4U6xMTzH70g5mdr/AyS9+BiWeoOW8LXRcfS1qW5uXvFjzlYZACFldSd1FXBL9i+j5jV9m6B//g8SqZWQuv4BqtlyrHwWQksTqpWQvWcfgFx8g+3/fjS7MkGBDChTLRNSxdRmxlgTHHzjIOW9ZV11XSBiOX8uKS3vY+f3jwFqHpOhSIWat+mygsGJjimJecvxQmTWrLd8oKQIhwjoeTkNPt8LQ8NyOJQWB4SJEirU8vIGks0NhfLxxNTmRNJlIMa8Taw/uV2PmfqNsoCS9n0mowjQB+SFqkJYz+CA4F0hOz8Qj/faueTSMedLSJBzS0gQJMfQKQj27X7Uhdaamj7Ko76L6ld1Oty4n3ChM5I4TU1JkYh2+QWuYc+r5szQRBXS60JQ4s/qEt9C6yUFVLQkjLW5USUtth0qhqA07cjcF+67tKQtRW5ohLGHqim0GyhcYf/gBJp58FDWdofvGW2g77yLT30AG24aO6Z+SXW5NO5Zppf3Cy2m/8HIqhRyze3Yw/uiPmXr2Kdouew0dr7sGxfL3EVTvZVIR5lpS9n3PRVySq1bQdtuNjH35ThKrl6Mt6PCYiaSjpED3z1/L4Q9/kqnnDtG+dYWTk0WxFJeYqtB37VqO3rOPNW9Z75iI3H4tSy9ZwIP/spvJ4TLdvSaRiaGjS4GKaS7q7ovR2qGy58USK1enUXwKi4GXrNjo7VEZHjn9c0UVAt06DxUh6OxUmJqSlMsStcaCjKowKEuVlOVyVSqEz0XRqqTFbz4SqgJh5nablITKPGfXvuJe4mGu7ecxN8w74jYJ2wHXztfSWBv9lVdafOf07MwAul6qKi0hdZofwyQ04/kTdCQXVZ1LI3KdRJqOoGYCuKhxz1RUkipiVIz6kRuqGkc3yhEqlUQIFYQSSDwYqKu+TKTFmYuvwHawdTnaBurWISx+x9zS8DDH/+NfmH7hWXpufjMrfuuPad96mUnOXfU8jrn2+3oJ5/z1bIfaRJq28y5m6W/8Hr23vo2ZF5/nyN/9FeMP3IcsFE2ijbs/4enbDJc2y1uvex3xpYsY+fRXLcdcr1OuYf2N9ffS+trNDN/+WCD82VmL6Lp1jL04wNRxc3kP20Rk1+ld10GyNca+J8YinXGFEKzamGT/rqD5Ua9xg+vpmbvSUgudneaYUw2qLbbSUsqH17eVFj3ED0UoItxH0KWgBXB2Ocs8ziLmSUuTsE+uppUWpXFzUi04Nxnr5uu/6YQ61RowMXWEVKqLRCzr2SVqEYko+JLKTRRO0JHs98wrWL/Bp0FX+1DTUDNExahhmnKVa0ocXdYnLZri82nxdS2EuQJxvZDnl01paRJ1TUJWmT8z7uze3Rz/94+jtXew9Nd/j/YLLrYcaqt1IpPHRRGVqLBn/37DNGO0nXshy3/zj+i67vVMPvEoR/7+Y8y+8Hw10sgZI4S4SFCEStd730llYJjJux+wzEPucOkqiem87QpyO44wu/eUJ/xZSkFFKmTXLiCztJ2j9+53lBg79BlAqirLL+7mwBMjZhZcq9ydzl+XCis3JNm700taPFFE0v5bPfB6ulWGR5o7lvx+LmFhz52dZtnYmPe8jfKvibvMQ6FjusxDfghViSAtdfy/zqJ5aD653NnDPGlpEnZkSDNKi6GXUPz2/VcY4+MHaG9dbr45g/4sJT3HTHmUjsSi0Pan48/SEKKijTyrP9cmTKbSEuaH4p27osZMpaUGFFWrr7Qoap0II09lcypnmOQ048Pifl88dZKBr3yetgsvY9HPvw8tmQqSFZ9CcqbUFn86f0XR6LjotSz/0J/QduGlDHztvxn9/t3mDTCEuOC0NRWXWFsHne/5Oabuvp/i/qOWaQhnJWhHbVmykMwFqxn+9hMYVi4Xb+iqQv/16zj6w70OsbDDom1SsvzSBex/YhjDkBZxEeiO6mJ+62s2pdj3YoGSLgJhz1HoX6hy4tSZJ8BtrebcpqaqB4F7/SE/VE2gxgRlyzxkr1Fkw2Me8sH0aQm5TtQwD73s15U6mE8ud/YwT1qahLRuSEJtjIQYho5eyhNLZOtXrjlw8yeprbqUyzlGx/fR073B1V+NcZrwZ5nMnUARGq0J38rOc00qB9FPVi/ThUqExpgHx1aEauZgqQFFjWHYxCaiSyUWr0tsnLoJM++NUWo88RiEmIga2BfpdGttRqnIwNe/SOacjXRf90YzCi1KWYkoC6hT7npu+MmMi6x4lBMDVC1B99Wvp/8972Pq6Sc59blPY8zMBoiLJ4+LtaUv2Ezm0q2MfubrVsbcatI5v9oy9cRu8ifHLaHRlSEX00Q0e3ySkR3D2GsQuU1Eq69cyPRwkWM7TBNSVWGxc7AorN2SITdjcHhv8Lf252qx/65coXL0mE6pJK1y77nTSKRQGBLWukbliv+HiYaimKe9exVne8FER9wJ7U7UPv3CFBXZhMP9ywDPulRz3OYxN8yTliZhVMoITaubHMxGxUrfb69B1BBcJ/Ccwpt9bQaHXyCmpejsWO0pP+38LFIyXjhBe6LPXIjRvS+yXYgTbrOrQJ9hCKFYSd9qfx+KooUuiOj+jVQlaB7y/4ZCjVVJS52fQIlbpKUYnYm3GdTKw+J/7Xa6BRi5+05kpcKCW95uET0CJCCUrLj6q6W2hC6g6J5jSDv3ONnV61n6a7+DPj3NsX/7OKXjJ3x1hCt7btW/peNttyINg/Gv32UmnbPqu9WW5MYVJFf1M3Lnkw5hcZOSxMI2Oi9YxJEf7HWiSmwTkSEFmd40/Rvb2fXAcMCvxX7f3Rejt1/jxaeLTtp/W7EJg45k9aoYug4Hj5zZRGtCCFQ1On+bW0WxoWoCI2xlR6s/iFBIbA/qZiAlzeRimserB/O/epOQlbJp6gm74NvvXWUVa6HEWLLlZVMK6vmznBp8loW956OGxR8Ysjli5PNnsZ1ww/Z55yhr+s5E+568/IRGIJC15CQLilCR0jIPRsy3EZ8WRYs5il3dMRPWquKlYu3fKexeEKJqRNWP9GOx3s88/yxT25+m7+d+ATWV8tbzERa/UuMxGckgKRFhZS5y4t7njOtSWtyv4+1dLHn/b5FcvJTj//GvzDz7jM9sJTwkBglqMkXXe9/J7KNPk3tud9Up1/mrIKVC55uuYOL+7ZTGZtGNoEPuohvXc/y+/ZSLepXQWCYiHYU1Vy1k94ODAb8WqGbG3bA1zY5nwhNR2keomzYvXCjIpAX7DpQ9vi5nAjEzIS1Q+0bhrPYc5VALznppthnIrcZEPgDWfPiRZ9enRZ5uVtyzNvWfebyqSIsQokUI8bdCiHuFEMNCCCmE+OiZHENWKtGmoZCbQtlac0iLB1PnCzt3eIOIdMINrWvunJkdZHr6BAsXXGDNqwapiDANRfmz6EaZyeKAmZ8lqt9mnHDd02nmrD7Ni7VJWqLm76on1FClxdOXqmFEPZ5aQyhaHKNSNQGE/Y52maO0FBpUWkKISqj5Jax+BAGvTEww9N3b6brmJlJLlocSFI+6gu+9j4w4pMZwbf73IY64bhXGnp+fvCBNc1HfW3+Brmtfz+DtX2PysUe9xMWzZpGpuCRXraDl+tcx/qVvYxRKFmExD12JeYhlLlxPrKed4bu2Vc1D4JiIeq9cjVExOPHo0XAT0VX9DO2fZuRowePXYpIa8wa8/sIMO54peKOLXEsE+CGEYNVKjb2+dYuMZi4sEVA1gd6MeUitpbSYf6OUlpo+KmEf/afAp2XePHR28KoiLUAX8AEgAdz5cgxgmocad6qtFGbQ4plgFlrXOedcyCP2N3WC+qoODD5HS7afbGaBp85pmYYs2IskdiT7wqfS7Bg1F0l8+S5SQoJsgFgpioYhG/Bp0cs1CaWixTDKjSktQlEQsThGqXZK9abQjMoCjPzgu8S6e+m84ppIwuLuN5LM1FNbQtQXfG3dKoyHvLj7NUwi2nnZVSx40zsYuftOZp57zjO2HSXk9nlpe/21ICVT33/IIizWzcX2bREqHbddztj3n6YyWwo4YyqpBAtft4rDESairtVttPen2fXgIPaiiuD1a9mwNc3g8TIjg5VQZ9ywCKLVqzT2H4g+Lv1+LY36uWgaNLOQsqJS1zx0BriU2Y2Uc17tfh4/23i1kZYjQIeU8nXAH78cA8hKxVljpn5lKBdmiCVP0wm3zhgQTkIMXWdg6DkW9l4QfhOdq0ZpqS6T+VNkY53eRRLh9JxwzwpcF78a81aEEiQ3ru9QGGYq/0ilxa6n1TchecZNJGsqLXO+dDegsuhTU8zseoGe612OtzX6ckhACFkJJSNRaopfaXHIRkgbXz+4xmg77yK6b7yFwdu/Sn7vXu/83P4tEtREkrY3vZ7pex6iMjyBO1Ou7dvScuX5KMk4Iz941uOQ65iIblrP4JPHmB3OUTZUj4nIECprr1nIzvsGATzExTYXLV6bJNum8Ozj3t/bsHxcvGUmtpwf5+HHihjWseh3xp0rKhVoIvE3iiJC3dMUIZ2DNDJKyJCIKKYfUSzmfuSfNuyMuHOOHpoPeZ4zXlWkRVp4Wccw9NAU/lHnW7kwbfqzNFDXTzxqEY1GTEPj4wcpl3Ms6D3XmnywkRPqXO9rs31SXPWmi0O0uKOG5prwzTPOK++UKzHC12MKQNT9fEJRkLK2CSnMp6XW76kmUxiFvD3Z00MdlcWPmZ0voGZbSC1bVW3jV1lCCIvTn5/A1FJTfJt/xWg/MfGTGntMD3ExoPOyq2i/9DWc+tLnKR0/bta1yEqVWJkEJXPxFmKL+pi4/QehaovQNDpuuYzR7/6ESsFANxR0KdANhYpUaD13KakFLRz8/r4qYXHdrM65bjFHnxtnfMhUzsw6lolIKqCoXHBFhqcfmfU447rhPkN0JLe9McWxEzo/eSbaRKRLw9kaga5LZmclLS3NrbEW5WZil4uQgyzKp0XUSuMP0SbdVwBui/lct3nMDa8q0jJXCCF6hRAb3RuwylPHOsikrps6aIMo503S0rCzayShiW7ikB13HcM0DXV1nkNCc0UuyRqmoVr+LCGYKg3RGu+x2jbwARtJ338WIEVjT21C1PB9saAomjenSkh1RY1hlENCmF0EwFPfTVoaQSNfa63jzEUuZnY+T8vG8xyVZS6EJYq81Eo2F/B7cZGYuuTFRVjs9z3X3UJ23UZOfv4zlEdHqxl/bf8WaywFlY633UJu2/MU9xwJqC2GIWi77kKMcoWx+14IqC0IhcWvX8+R7+1Bl3gSzRlS0HduF9meJC/cO2SREiWQr+WC17Tw9CM5yobfNCRCnXH7+hSuuDTON749Mydn3DBlZmbG7KelpXFFoKZvbCQxkeazQK08LZF+eA1P7YxjPrnc2cM8aTHxG8AO3/adsIrS0JvKbmsqLU2ah9wnY5Q64q/n7DMLK5UCw6O7WNh7fng/p+m+bhgVZktjtMR7Gldpwjs6rXkANa6UjcGjtNTsqwGlRSihieDs30zIOZiHkkl0N2nxHB8Rr8MQtT+ivDI1Sf7IIVo2nl93joH+XAQl1FRkEQVZqTB9cBfjLz7J8NMPMPDo3Zy4/xscvfsLHL3r84w8/QC5k4eRpYrT3p98zu+I6yFQdh2hsPC2d5JY0Mep//pPKlPTXqXHZSZKrlhB+uLzGf/aXciKEVRbkgk6br6E4W8/jlGRAYfcvps2MHtikqHtAw5ZcUxEisq66/p58Z5BT+izQ25QOO+1WcZHdA7sLjl+LfUy4771zWm+fVeecrnx87qWs+70jHleZrNNnFsSIu/FdnnY+aME8yTZq3Y7/fq7E/XPxXm8OjFPWkx8Etjk227zVxLSVFqayYZr+rS4zEOnc57VdFT1vh0a2YmiaHR3nhNZxzENzQGzxREkhklaojDHyKEzgiZyOEgpG7SPh4nb/mHrp+hvJuRZSFBTaYx8iNJSazLN/qwh9Wd2vYDW0kpy8TJvvVoqSwhhwVcuJOiFPMNPP8Cez/0VR7/3eYa33c/kvu3kh46jFwvEUhm0RIrxXU9z8Bv/wq5//xMOfeMTDD72ffInj3j8ZDx//YqLm7ioGn3v/GWURJKBL/wXslyx2gTNRO1vupnyyUFmH98eqra0v/5SKhOzjD+6J+CQm+hppeeipRy+e0+4iej6RRx9bozx4ZKL1FRDn3v646xcn+DRe2cD+VqikszdenOKqWmDHz9asMoN6+/czu/xKbN9a2sz51G0YlmLswhE+LWtVsTRWVYq5qOHzh7mV3kGpJRDwJC7LMrO6lZaGjH5VOaitPj6bsg05IYBA4PbWdCzGVVo9eu7TUG14DIdTReHSagZEmo69ErUjGvRy56jRal94ZUYiAb4u/l0V3tOQlFrrgQNVvRQxYwwauRbUpIp9Jkp7zgS/9qHtRGiyPib+4+zmV0vkt1wrtc0FNF3TcLiqiN1neFnf8zwtvtQ40m6z3stXRsvQ01Uc79UJ2T+qRRmyZ06zOypQ8we28/wtvtoWbGRhZffTKKnz3oqr25SsRQUpfrwLw3zrxpL0v/u93H0k3/P2L0/pOvmN5qHr2EGvmP9xLH2DlpvvIrJO35AeutGlGwchP2ZBEo2TduVmxm5+yk6X7ceIRQUIVFth9ybN/Di39xH8cOXo7UqHhNR/3ndZHuSvHjvEFe9p58YVp4WoaBgoEuFS69v5dF7J3nfh9sDX7eBueKz7vyVtLULrrs6ydfumOX6q1OoruuXgUSpc5P3m5Wmp833mYyXJNVCQ+ahsGNIiXh2ch48QkafS0K6MwibqJ5O+3nMDfNKy5zQ+AFXKeZqZsMNDXeuNbLrJhDcZxaWK3kmJw/T07XRquurXC+0ODRfi7dNQZ8hpbUG259NXxW/uqKIhjIXG1I3M/o2YmaKTIRl7466ArunqTW+9hCgxOPhPjD1UONYqdnGIhjFwQEzL0uNvkOJjJ/g2P2ND3Pw9n9j+On76XvNrZzzix+h94JrUOMpS/GQCOnaDHPTEhlal2+k77I3svrnfovVb/8wUq+w78t/z/F7vkJpciygtgR8YFz7YplWFrzpnUw88mPy+/cHzET2atAt178OVNVaUDFEbXnjZeRfOs7M7hPOTcx2yO25fCVqMsbhe/aHmojW39DP9rtPOhFEtokIzNDny29u4+BLJfa9VPaYiOw6YSaid78zzXe+l2N4VLf6qd7s/YpLPQXm2LEK3d0KiUQzPi0yUuCspvEPjisUBRliJnYU7bCEdRFt5vHqxzxpaRLmTdB74kU9gRqGjqGXUWPJ8HoeNSVCAXE6q0U0vG/Hx/ejqBrtbcsimzTsGByBkp4jrqZ98zh7Tz5Nw/0kKnUUUV90lNJowIwUPD4CNdTmVnlWYnFkg3ldApjjT2IUixi5WbT2zkB//mMnNGcL3rLyzBQHv/mvKFqMte/6fbo2XIaiaB6C4jYjeR10vUQm3bOElbf+Givf9L8ojg6y7/Mf49SDd6LncoHIoYBzrvU6u3YDbRddxtA3v4I+m/OYiZwkdbEEHW99I9M/epTyyeGAb0usv5fMhWsZuuOJYPizFmfxzes5eOcudIOAiWjjG5dx7IUJBo/kPCYiw8qMu3RNkjWbk9zz7Rnv71Ij9PnG65L0dqt84SvhDrkG0tmqZYbntY7EkJL9B3VWrWpOiDd0M8FcGGql8ReaEkpMhGYq2lIP8RHTNAgpf6UwHz109vCqIy1CiNcLIX4OuMUq2iCE+DlrS9dqWw/Sdg5r8IjTS6Z9WYtFZMMNDNDoRGr0YcDI2F4621d7TUOhT8RzP3NKep6Y6vpcL8dZ+HKsLRKSkEqXFe/aSRGQ1NK/TYh62T1pzO/FGtCsH5uj0tIIIqZanhgHzJWQwWfqseAvi/JtkYbBiR99jVi2neW3vJ94tsMhIX5fl0YSzdnkJbtoDavf9iGW3Pgepg/t4sBXP05hdNDr1xKVy8WAnutvRcQTjNxxu+V/RTXpnJUpN3XBZhKrljFxx71VtcUiKFIKOm+9nOmf7CF/bBzdUDwOuYveuJmpA2MM7xgKRBH1nNNOz6oWnr1rwCEh7uy4ulS45s3t3H/nFCWdQOizHVRlH0U6psrxK7+U4bNfnKFiZbKda86WAwcrrFqpeqKU3Fl5bSdiNwxdRpMWJ41/yD5VQVZqkJZKCGlR1VAy80rB/p3nvJ21mf/s41VHWoBPAd8E/st6/zbr/TeB3qhG9VA9X+uHvdrQy6bzpK20NDaQ922zvi1SGoyN7aWrc21kHe94sjGDtQ8lPUdcsUjLz/hCGobUA74/oZCygXwuCnWVFqV6wW1E8VJicWSTqzyfLioTYwhNQ822BD9O2PuQMpsojG5/hJmTB1l6w3scdcVPVrzKinfzlLsIjDAkioT2leex5h2/Q7JzAQe/+nGmD+7ymod8xMUeV4nFWfhz72Fm9w6mn3k6lCApUqH9tpvIP/MipcMnTbXFUlykIUisW05y9SKG7vwJhsQ0DxkmMUn2tdNz8VL23/FS0EQkVDa9YTHb7z6JbohQE9Hr3tjGxJjOtseKDZuI3vOuNMOjOt//Ud4pjyIutQjNgQMVVjettMhI9zH7tAlVWlTFs2aRk2TONg/ZpMXNhzQ1lMzM49WPVx1pkVIul1KKiO3waQ/QhAOYrbQ0RVpo0nTjqzs9c4pSeYauDou0NOjPUisfSxgc89ArpXPWy1p1GnB8WsLgOkOk49YZDSGEc2GOTCLYqNJi1481nvb/TKE8MY7W3lnXHBZpKrKQHz7BwGN3s+jKN5Fo73UIS62Ec0HzUFBx8fqrSNRYkmU3v5fu86/kyHc/y8hT9yMNGVRZ7D4sIpNasJju617PyHe/TXlkxPFpEa4Q6MTK5SQ3ncPknT9ylBhbbQGFztsuZ+KB5ymN55zwZ91QkFKw5NZNnHjwALMTJcpS8ZiI1t+8lLFjOQ49PxVqIsp2xbjoqiz33DFdjRqqEUWkI+noUHjLbWn+43PTAJHExf3eb0oyDMnBg5VQ85A//NouM9uZ6xWFwTEPhVx//KTFKa9lHqq1BPUrgPnoobOHVx1pebkhhOLc+O3jLur408s2afGluW/2Ph92okeYhsbG95NJLyAZdznJ1lBvAmiQhJSNAjF/+v6fAog5rEeiUzmDPi3U/Q6VJkmLEoshXy7zUAQqkxNore2B8oDPirs85P3JB75J64qNdKy7xENY7Pb1Es6FlYeZe0zVRbDw4tez9Ib3MPiTezn+/S9hlErBhHV4x+y49CqSi5cw+LUvQ0X3OuUaAmEI2m+5kfzzuynuPxpQWzIXbUDramX4u0+jG1VSUpEKHZeuIt6W5OBdezCkQsVQqUgzvX/LwgzLL+pm2x0nKEvVSTTnNRF18Og9M8xMGb5cLeGJ5gA+8CsZHn6syPM7/UsBVP/54S47clQnX4AVqxrPRyWlRK/IyPPPTiIeRloUTcGoaR5ykRMrQkyomhmyfpZweis8n17k0f90zJOWJtFMYjApDRBKgyniA40jykPm5Ko7OztIS7a/+fHcaCD8WRUx9DqLBzaKRiJ8Ihqe3jiK/YRYRhX1F8GUssF0//Xm1WxiLGH6StSKcT7Tl0Bp6Ciaj8j5SUlIuZsYFEYHyA0eZcFFN5oXmhB1JaCq1Np8hCY0OkhK2ldfwOq3/ia5U4c5+PV/pTI7XXtdIxQWvuXnKY+OMPaje6yxhEeVSSxZQmrLZia++QOkDhii6tsiVDpvu4LR72+jMlN0UvsbUiAUlaW3bebAt3ZSKUvHIbcsVcpSZcvbl/P8904yPWFHCXkTzW29poVkRuHe784GEs2ZxMb8rnUpHbVl86YYV12Z4G8/7lVbwuDep1s/3H0PFFi0SGXFctWqE9ncgc3BtVgNnxYBsiJRhElQrKMaEdeQpUrAdCRUFVQVWQxeb0UiIqv0KwVHbZvbNu/UMnfMk5Ym0VT4qZRzvyH7EBVa6sf0zElassFVlwMkpJGbZkQdYUhiSoKKHr2I38sC93fp/15Pw2m3IisN+bSYpKX202dj/k5zcMR7pcMNGh2uBpGZ2P00yZ5FJLvCjkdCyUqoyhJCVEJT+Du+K5JU92LWvP3DCCE48u1PoxcLgbrusWPZdhbc+jYmHn6Q4qlTjspi1rESzt12E8UDRyg8v8e8+dhqi4SWqy5AScQZ/t6znvBn2yG3OJ7n+MNHAg65K69aTLI1zrY7TrqSyFXXIlJiGte/tZ27vjJFRYI70RwEHXJt/MGHW/ju9/O8sMs8R3UpA+QlNMJISn54X4Ebrks0de2qWJl41QjSAqCoCkaIGUhLVB1uPYsmComSiCGLpQArVxJJjOJZJC3zOGuYJy114H+4VbRYw+GnptIyd9IS6RMRcQPT9RK5/AjZTJ89gTmP7SAscZwiiClJykbx9Pv3e+75yUfgvWhAyahzWPskbF2WUZUzp7TU9QPxKy31CKmIqlS7i9NDkz36yIs0DCb2PEPnORd5zUJ+ckK0b4tNTjw+LS7CEowqwkVMJFoyy4pbPoBeKnL0u5+rLgXg78vqI7vuXNJrzmHk27eDYQSWCYj39JJ97SVMfOuHyIqsqi2GAmqMztsuY+S7P6GcqzjEpWIoaG1pFt+4jj1ff5GKb+VnYhpb3r6cJ752lEqluhaRLq1MuCjc8PYODuwusvP5+jlbbLXl4ovi3Hhdkl/6tTEGR6rXK5u8uAmL2zQ0PW3w+BMlrruuOdOvHa2katHnh6IJZIhso8TNBwajGFRuRTKOUQpTWuLI0hm4/swR8z4tZw/zpKURuB/wY3GMSpD5h0I2mh7+DMCAmdkBQIYqLWadOagtEdDUJGX58l005uKbUhORYQ3CJC1h5iEfOapJWpw85Q3Mpel1U8QrLydLvJ8/ZHybVIeZimaP7aOcn6Z9zQXVOj7C4lZXIqOIQsiJn7D4nWurZSZxWXnrr1EcG+TED78CFSOQw8UhR1LQe/NbKJ48wfTT2xyVxXHKNaDt9ddRGR5l9rFnA2pL67UXgYTRe7c7JiIpTd+UJW85n7EXBxnZPUJZKpRt8iIF571lJdNDRXY8NIIhFcpS9TjkLlyR5LzL0tz11anQtP5utcVNRv79X9vJZARvfc8IE9PhplybsNimoQcfKhKLCS6/LGHtx9pf+3yslMz2UeYhiFZalIRJWoTrYdBWXJRE3FRaAm0SoQrMK4V50nL2ME9amoTSVM4M2ZDZwgkBDUOdcGK36jI9c5JUspOY2ly0Uu0Bwk8uxzwkRGjuk7pQlGDfcyUq1nfsITru13WUGb0R85AQSAyUur+nbPBC2gQLOZ3rmzjN9s1AVv+Ov/Q0LUvXE0tla3/UCCLTVBSR4e3Ho84YknhLJytu+QDTR17i1I+/DYaMJEjxti46r7qe0e/fjTEzEyBLWmsrLddfyeSdP8IoVLxqSzxBxxsvYeiOJykXDaSltBhSkF7eTfeFS9j3jR2Oaahi+bWkOpNsvKmfx798NNIh96Z3dvLAXdNMmW4qkWoLVCOJWloUvvGlLmZnJT//3lFyBd3jjBuIKJKSe+4rcNWVcZJJETA51YJuKS1KLNp8KiKUFtUiLUYpRGlxkxbhLTeKZ09pmcfZwzxpaRJKLI6slAPRH+HEWdDU+jn17mN19ufyo6TTvgUMT+cJvcbNPqFlyOvT3rpChJMRNxpMre+dx9wOU2HPpw5ClZYQAtWYeUhSlyW4wqIbwlx/w0a+5qg6Qsx5BW4pDaYO7aR9zfmuwiA58ZQRorRIGdxcmXP9Sk1gDBdxSXX1s+KN72N8x08YeuwH4blgrL+dl16F1tLK6N3frTrlutSW1mtfZ65O/aPHAmpL242XYMwWGP/xDifZnB3+vOxt53PsvgNMDeY8GXLLUmXLz6/mwJOjnNg3E+qQe/ENrSRTCvd8a8qT2C1KbbGJS1eXwh1f6+LA4Qq//L9GQ1eBtlWW0TGd7/2wwOtfn4zIqBuWmNGcS7lkHiu1lRbhRAkptpIipMs8ZCotbr8WJRnHKHjJiRQSJZkIlL+SCOHUTW/zmBvmSUszEKAmzaS6ejHvlEVB0eIYetn0bTnTCDnqpVFpyDfjTKAt0cd0cRjdCPfvEbYCI5SqGlPjhu8hMmHKSd1FTRqEXd/VTjfKaEq8btOGo4fOtLRhGGYkxemgySkp8ThGmM+ADP/rNhWVJkcxSgXSC5Z59tn1axIWqmQl6mrvpPW3CIzH9yUsQshqk+lbyfI3vJeRpx9k6Mn7gv4y9ntFo/e2tzO9/VlmX9pddcq1/qrJFG233MDU9x5En5gFiaO2KOkU7a+/iKHbH0evGKYzrh3+fOEKskvb2fv1HZZ5qOqQu2B9J0su6OTRLx51zD9lqXkccm9+dye3f26SYqXqkOtXW/xXGh1Jf7/Kt7/WxbZnS/zah8Yo6VWTkE1YDCn5l3+bobdH4bZbvRm83X1GheqWCmY/8VT0+aHG1NDQZjVtXrP0fPBaomSSGLngcaik0xi5XORYLzckp2keOsurVP8sY560NAk1ZZGWfP0Txk4qp1dqmJN85KOpxHI+GEbFWYH6dCHrqCFtiT4kBlOloZr1GoJbDallIqrhpOsQnDmoMhVZQlVdZC9qhe8GSEsjAkqzfk7S0BtSjHyDzG2fBSWZDCctDaAwfAIlniTe2hVKSgLT8SkrkU65PnXFaeMiL34zkZ+4tCxZz9Ibf4GhJ37A1P4djsJiReE6ddOLltN+6WsZueN2ZLHgHduA7OUXo7a3MXX3j6t5W8BaSPFyyiNTjD+yxyQWViQRQmH5O7Zw6Du7KUyXqUjFTDhnRQtd/J5VbL/7JFOjFRdhEY6Py82/0MX4SIUffrsa/gxetQW8aov5XrJqlcY3v9LFjx4o8KE/mOCeB/N8+7s5vviVWT7xH9P8zd9P8dnPz/L7v9tCzKWWhIU7V/1qqsdksWCOFktEX38UTfHmXLHL4xooAiNf8qgsQoCSTmLk8oELo5JJnVXSMi+1nD3Mk5YG4H64UNPmis16YTZ48fe9t5PKGeUaF/8zSLhrZnZtBg0cFTE1QTbezXjh5GmMU8OUFKa22OX21vR44WNVjDKaiJtmmxqkqeHooQadtBuFNAyTjJ4Oow3rt8Y+JZ5o3mfA6jA/dIJU96LqYeQaKMqcUy+1f6R/i1FtL+wMuD6lxeN0a0jaVp5L74XXcfyer1IeH/XWtUgJErqveT0IhdHvfy+gtihCo/2WG5j+8ZNURqZM3xZDIA0FtTVL+/VbGfzmo1QqeNSWhdeeg5aOs+/OlxzzT8VQqRgKK69aTLY7yWNfPxEa/pztjHPbL3fxhX8eo1AKqi123ha/mQis/C0bY3z9v7u4+wd53v3eUf7gI5N8/BPTfPOOPI8/WeLn35Xm1ltN05COV2HRIxQWGyWLtMSTtZQWBb1c7dXO16IqoCZj6IXqw53jiJtJIXP5QF+m0pKvu1r1PF59mCctTULRYggtTqXgYvkR57OimSYHXX9lbK/S0OvmEamLJvxN2hP9TBTnQFoi/FqifF3qRRIF9jfo0CuEwJCmSN6sechRogJjNSS1NAddRzSrtJzmuEoi0bjS4vvIxbFBJzdLrSR0AcICPhWlUbXFS16CZfiihSQLLryRVM8ijn3vi8hyxee8a25KLMGC297O1E+eoHDwYIAQpc7fRGxhD1N3PVj1bcFSW269gtKJMSae3O+oLYYUSDXGsp87n/3feJFiASpSccKfpapy0btX8uRXj1Iqgo5CSWqe8Ofb3t/D7LTBd78+46gt/rwttYjLRVvj7HtxIacO9bPnhYU8/dgCHvxhD9++vYuP/d82lDk6w+fzpj9LVBp/MEOejbIRuk9NxzHyIVFC6SRGzsoH5fZ1yaRNn6tXeE0uG+5FM+e2nZVpvyowT1rmADWVRi9ESJNuVcZSWvRaSssZhJQGSjPmobnkkLEcbqUi6Ej2M1E4ad5vFIHfGbcpv5YwE1GY+afm3Fz1fZ/N6zNTfV2Rph29VkZcm6BIGs2746vjviGH7a8DaRjVPOhNDHs6EIkkRnEOyQMlFMeHSLRHOIRLIgWjWuHPSJCGJD8xyOzYCVN9CqgthBKXsLT/ihAsvf49lKcnGPjxd7xqC9V6mZVraTlvCyN33Qm6gZ1oDkOgoNJ2643MPPoUlYExj9qidbbRdvV5DH3jUSo6vmRzm6jkKxy+d79p/jFUJ3/L5jctp1zQefb7A6ZZyFJbylJDlwqplhhveX83X/rEGLmCrEYRudSWgF+Lj7hIperP4vFrifhJ3Rl4o1DKGzVVFjAji4yKgRpyAKjJOIaltLhHMX1aXMehkCBASZt+N0bhFU5waUPaxGVu27xANHfMk5ZGIapmIi2dpZKbrlkXQNESCEWlUpx9+ecHqGqcSuU0TuI6UT/+/Z3ppZSMPBPFU3Mf02ciCqgtPuLiJi/+95F911ApKoZ5oWxMaWkk7079yCAhlKbWHkIazUVcnQHyosQTyHI5dLG66ryCr6WUlKZGibd1B8iaL9lpgGB4CI3dX6XC1Km9HHnmOzx/98d44Qd/x457/oln7/xz9j/+ZYYPbKOUmwxxxrXMRT6y4n4dT7Ww9MZfYOzFJxjf8VQg14sdktN93Rsojwwzve2pQMK51Kb1xJcuZuI79wfUlo43XUn+4ABTzxxy8rZULGfdpbdu5KUvv0C5Ul39uSxVlEyS89+yjIc/f6S6+rMv2dwbfqmLSgXu+NJ0QG3xO+Xav55NXKKIieGqZ5uGwh17ww+u3IxOMlOHtGgi4IhrRxGp6Rh6zquaCCFR00n0mXzg0qRmLd/C3FkiLWcJQohrhBD/JYR4SQgxK4Q4IYT4jhBia0jdLUKI+4QQM0KICSHEHUKIlWdj3mcS86SlHnx5LqQALdtKZXaquh+CNwph3lRjqVZK+UmnbVhdt9Pr6eQcSqW6yOVHoivUyF0S6XhbIwNtSmulI7mYkzO7m5uoUMJNRFEOuT51JpSs2HWalLcrmEqLpjSa26Z2/4qiImVtQiJU1VRPzgaijlcflITlj9Wk/K4XckhDJ5ZpMwt8JCTgkBtBWIozY+x77Is8c+f/4aWHP0Nu8iQLV1/B+Tf9AVvf+KcsO++NgOTo83fz3Hf+khe+//cM7f+JaTJw92n5ufiJi71l+1fT/9pbOXn/7eRPHnElmqvWj2Xb6bzyWsbu+QFGLu+EQCMFilRov+0mck8+R+nooFdt6e2g9XXnMvi1oNqy5K0XkDs5xfFHjwaSzW1992qGD82w6+FRT7I5W22Jp2O87X9185VPTTA9Kz1Zct1OuWHEBaqp/92be38YwsKdnd9cKsxMVsi218515F4YUfFJDWo6jp4rBk5fJZvGmA2q2iKZBE1F5l+ZB0I/zmJyuV8HlgP/DNwM/DbQCzwphLjGriSEWAf8GIgDbwd+BVgLPCKE8MmgP1uYJy1zgJZppTwz1RDBiKfbKeUm61f0kaO5IJPqIZcf8T7pz7VPpQaRcWFRdgMDs3vMRFWNmogCY0WoLY2EPIfsq6lKKN6+K7JxpcXsu85+pb6KIhQVpNEwcWkqp8tcIbyEWUmYJM4oNfckW541j/V4uiW4M0BWQj6XNMfc8/BnKeUmWHnhz3HhrR9l4+v+F/1rriSV7SGebKN36YWsveTdXHjL/2bTdb9NZ/9Gjjx7J7vv+xT58QFf0jnpISt+RaZr02tpX3MBR+/6PJXpqVAzUcelVyHiCcZ/dK/jqOuoLWvXkFy3msk77g2oLV1veS25vSeYfv5o1SHXUIh3tbDoxnW89KXnnZWh7WRz6YUtnHvLEn70yQOUDCVUbbnx3V2omuAbn5v2ZMn1m4k8/i1Er0Fkl/kdcM393oPeziMDYFh/Z8Z1WuqRFlVgVMKPZS2d8Cgt9nmmtqSRhZIZdeQi3EII1GwWPYTQvCKQ4vS3ueGDUsprpJSfklI+JKW8HbgeGAX+xFXvL4Ai8EYp5fellHcAbwB6gN87jU9+1jFPWuaAWLaNymyViDg395DjMJ5uc5SWlxvpdA+VSoFyucmnD/9RUOvObJMSy69lQfYcdFlhOHeo6fnWUlsiiYuboPjfezLihhzaIcSnYhRRRayBTLfQiCFaCLU+aVHNi7unXr2uz9DCm+F9B187SksTEURCQmVmEqGoqMlMwNTjrmeXB3K2GAb7n/wq0tBZ/5pfpXvx+WixVKhjLhIECi3ti1m66SbOu/H3ULUEO+75J449/wNkuezyaZGhJiJhgCJh0VU/RyzTyvHvf9n0XfGpMooao+em25h84lHKg4PehHMS2m67ifz2XRT3HfOqLQt7aL1iI4Nfe9RK6S8sU5HCsndsZWznIAPPDZmhz5bSYkjBpe9bx6mXptj1SLjaoiU03vHBHr7x6XEmp2SomchPXMCruvgJjPuorZKd6sHhz9Hi3jc9USHbEU5aVGGYSeRcSosbCtJ0xLXysSguO6LaYvqu6DMWOXFNQW3JnrWwZ8np+bTM9TFEShnIMSGlnAF2AUsAhBAa8EbgW1LKKVe9I8CDwJvnOPxPBeZJS4Nwn69ai6m01KsHFmnJTQbKG1ExmkUq1QUIZvPDIfOKMEEFfEhqmIlCVJKYmqA3vYqTM7vqT7CWQ65bbfETjqiw55A6AYdbRamqPSEoG0U0pZnF4Xz9+JZZEIpaN5mgHQkURW4ajmw+A4dQ1FCO0mI74zY4VmV2Ci3TGnSEDpiJpHefRUSO77iXqaH9nHPFL6PF0qHRQoGwZ+t9Mt3Jutf8CqsveRfDB5/ihR/8PVMn97rqyoCJyG6vKhpLb/gFcqeOML79iaCZSEL2nI2kVq5m5K47zXT0Tgg0JJcuJbVlMxPfugfDkB61pfMtVzK78wiTLx73qC2pxZ0svHIVu/97ezX02VJb2hZlOe+WJdz3yYORast1b+sg3aLy9c9Meh1yqU9cwjaYuzPu9ERz5iHwkZN0PMSnBZSs5XA7630Qk0KiZDNmDpefbawSQmz0bb3NdCCEaAO2ADvtPoEU8EJI9ReA1UKIM7jWyyuLedJSB9JvthGgWUqLlNIhAG4i4H5tkpYJT/szgpB+VDVGMtEWSloaQRiRkg2sqryoZSNDuYOUjHxtE1EY/GpLlFNuTYfbJr9UJyuuoCJLxJR4bbLWCOybcQNOtkKxlBbdl2jL7dcR6D9iR53pzUmJFiA0DRSldo4hgvMtz04RS7eG7g8SFzysafzUbk7svp/Vl/w86ZYF3vq2mScirb9DMBB0LzqP82/6fdoXrOWlH3+aUzsfDCUunhwuBiRau+m7/A0MPnIX5fHRqglIWvWkoPf1byZ/YD/5nTtdpMYkL+233EBxz0EKOw541JbY4gW0XLqewa8/5qgt9kKKK999IYNPHmN492ggtf8l71vHyd2T7H40XG1R4hrv+s0evvVf44yNedUWm7jYcBOXMGLi9W2pqiy69PYD4cRlZkIn025G4EVlzVVjInTBRADN8mkRvgNKtUnLTC5wrKvZbKi/yyuCEBLd9GbiO8AO3/YbTc7m34AM8FfW+y7r71hI3THMb7KjyTF+ajBPWuaAWEs7slIxE8xFwLxZCBItXRRnRsOfvhu5mXjMI/Wrt7UuY2zigFU/zH8knCCEHglRR4fPRNSVXk5Sa+HI1Pb6E7TbR6ktvtcB4hK2Od1GKDU1UDYKxBp0whUozu8Y6o+BSRwNPXxpAxuKHQrfYB4UJRZDVmr3WQ9eda1+fSEEQtVqRw+FoJKbRvP7s9QgLs5r3eDo9rtZsPJSOvs2BLPe1krr79pvEwlNS7Fyy1tYc9m7Of7iDzn6zF2uMGnpcbSt+qhIujZdQapnMSfu+ZrHTOQQm64FtF/yGka+912MUrmqtkiIL1hI5tKtTIaqLa9l5rkDTO8dQDcUKtaWWbOQnouXsvtLzzuhzxUr1LltUZbNb1jMA/95yLuQoitL7lVv7qCjW+PLn5pwstTaxAVw1BaoEhc3efGTmLCIIWefx1TkPceGjxfp7KvvF+Y/M53ooVQMvRBc5VloipmrZSa4bIpyNs1DZ84R9zZgk2/7ZKPzEEL8JfBu4MNSymf806z1ERr+sD9lmCctjcKluMTaTZJanhqv7iP8iTbZ2ouhl0215WUwCfnVke6udYyN78cwXE/xTT9ph6grjnoS7EwRCivaLuTo1HYqRrm+Q26wAy/h8JEPIeovshggLFGhzr5+Sm7SUncMBaNOZJCqJamUC44yErhJS9ASlp2+0Ji0rcST6HNY0fZ0ItHAMmM1GeVUyc+gha3s7CEu0imzv5/Ro9spzo6xeN11HgXGkynXiNh0HNLhIS8GdC86j3Wv/VWGDjzJwce/hqHr1ZBol3nI8W9BsPjad5EfPMb4s4+G1ul63Y3IYpGpRx4OqC1tb7iO0tGTFJ7f56gtSEF8+SIy569i8PYnA2rLip/fyokHDzJ5dMpRW8qWmeiSXzmHo8+Ns+/pcY/aYiaeU0FV+eU/WMgdnx/npV16TTORJ9W/BzA9/gABAABJREFUDN+qJqSqyuImQW6yolsEqViCoRMlFi6rTf6lJFIVVZIxjEI4MVcyKfRZ37kiQG09i464Zw4HpJQ7fVtDa6MIIf4P8KfAR6SUn3DtGrX+dgVb0Yl5Rk2czqTPJuZJSz345HUpQE2kUBJJStNjQULge5/IdiIUlfzUsKcP53WNX6Cpm47VT1fnWgyjzPjkoZD+6vu1RJqIomCpLYtaNwGCEzM7o+s6bcJ9W0LNRIp3f1jSuFqExkOWQlQZU2lJuRs4L/2fuxF/FTWWQK+TK0eJJwCBXmzsgqskUxiFfHDBcJ95pWnUO74U0VCEk1vR1/OzJmmB4PzCFBdA6jrHdt7DwtVXEE+5TUteAuLp06+2eJxsXeRFQnvPGjZe9b+YHNjDvoc+ZyZ7tOu5yY/VT7Klk74rbmXg0e9RGh1ylBR7U5Mpuq57PeMP3Ic+OelRW2KdXWQu2cLkXfc7aoshham2vOk1TD2xm9zxcaTl12JIQeu5S2hfv4BdX37BlWjO3NexrJX11/fzoEttsbPkmiRG45IbW7nkmhb+7g8HKFVEqJnIyd+CqGkisus0g6HjJaQBC5bXUSwNc5lAf7izENKjtDgqi53KP5sKNQOdTUfcM2gemhMswvJR4KNSyr/27T4A5IHNIU03A/ullD+zCW7mScscEWvtoDw9Xi2IkN+FopJs6aYwXYM8h10jAnlU3K+jLyqalqS9bQUjY3uix2vURCREhNnIpaRYUJUYy9ou4NDUMxjuu2sjvi0uQiHcCombuISQl8g8L00oWmWjQNxvHorw41GEUjcHi6Yl62ZAFkJBTSTNlcIbuHgpiSQYxmmbiJqFEE0oLdbncJQWdz+1iIuE4UPbqBRm6V97VTDpnI+shPq1uH1bdBd5cRGXbPtiNl39QQpTg+y5/z+p5GeDNxEX8enccBmZvhUc/+HXoOLNvisMaDv/EmKdXYzf71ot2iIvrTddTengMYq7DnrUlsSGFSRX9zP0rSfQDcWyiimAwsqf38rRH+xldihnJZpTPGrLvsdGOLJzyiEzzppECCrE+MCf93PySJlvfHYyYCbyKC4+1cVvInIcbl2+LIarjVnHe1E4dbhILCHoWBBHr/EUJiWRRFmtpbRkU6Z5yOOVbZGW2f9xeVoQQvwZJmH5v1LKPw/OTVaAu4C3CCFaXO2WAlcDd8x58Mbm9+9CiO6Xq/950tIoXIqLFBBr7aQ0Oebs8/y1X1tbsrWX/NSg0zZQF4uICO84jcwpDN2d6xge223m96gRjl277zByEX4zB5CKYGnbBZT1HAO5faEZdL19heRtCQtZFr6yMJOPu9xFdCIVGNc4JT1PTEuF1/NPWdRPCqfGkkijguF3snVDgppIN6a0SFckzyudslxR6ipLHkiTtKipTGBXFHEx9Aondv6IvrWvJZbIRBKWen4tAd8W3SYw1cy4qWwPm67+/zAqJV6675PohXxAbbHHVSQsvuYdFEcHGH36x96oIwMECl3X3sTUU09SGR01T1rbt6Wnl/SF5zH53QecvC2meUWh882vZfyBFygMT3sWUuy8bDXp/jZ2f22HlWhOcQhK77oOVr+mN1Jt0aVCW0+CX/2ThXz+n0Y5cqiCjrDqBh1z3aqLf3Pvt+u44Y4isnO0nDpcZOGyhGfdInc7h8hInKSQiueAqC6YqPhUFiHM7LfGjO9cEaC0Zk2/o/9BEEL8LmYOlh8C3xNCXOreXFX/D5AG7hZCvF4I8Wbge8AI8A8v8zTfC+wRQvyWaGSF2SYxT1rqwSYfPthKSyMEI9XaS35yMFDecNhzHWfc6uJ95p/urnUUi5NMzRyvOWbDJqKoRHMuh1yAuJpiUctmDk485UtwV0dtcZuJ/P4t7nGc+op3838Gf2Zd4e7H6+zblCOuUDFkCBlx+Wiomr3eVMHrl2Htt6EmXOtX1VFb1KTlA5NvTgo/7UWhhah+tgb6lVJSKcwSSwZJS6Cd9Xp66CDlwjR9q18T3q+LxNTdwsxD7jID4slWNl7160hDcuCxL1kqisu/xWUqSmTa6X/tmxh6/IcURwZ9iy5Cdu0mEv2LGb/vR0G15fXXUNxzkOLeo2ARF2kIMlvPId7XxfB3nnZS++uGGcK/4l1bOXTnbgrTZSpS8agtl/7qOey8b5BTB2edNYnKUnPUFgOFa9/WwYatKf7hIyNUpM+3xUVcPKpLyAZ4fFmqfVgJ5Xx+LccOFFm4PFV3JWjDkJEPElqqtk9LmHlIacmG1H6FcPbMQ7dYf28CngjZzOlJ+RJwFVAGbgc+D+wHrpRSzi28tHGcjxl+/U/A80KIq89k5/OkZY6It7mUFlw39ZBzMt3ZT27ilJk1NqJOFKKuA7UITyrVSWfHGo6eeNwaL6RuMyYi//saIcwrOy4hV5ngVO6lSLUlkCXXnk+Yf4uflDSoAAVNR8F2UkqKRo6EGn6T9UNVYuiuyKCwCKJ40lRjy8WZmn3Fsm2UZyZcfQXJgP1ezWYRmkZlfOz0iUgTkOUyIha9kKQfRjEPhoGWynpzq7hgR+6YA8DU4D6yXcvQ4umgyhJCWGqt+uzP5RLWlzBAi6VYd8UvMzN6lGPP3W2RlWDyOSR0nHMRmUWrzEUV3WNYIdBdV93I9HPPBNSWxMI+UueuZ+oHD1vmIdPMIlHpuOVSRu99jnK+5FFbFl6zFjWlceDuvY6KYqstiy7oYfF5HTz8hWNORlodyzHXUlsMVH7jL/rZ8XSOH38/h47iTfHvMQ0FQ5mBKqmJuEjZpiG3GWjXT2ZYuyUbqONHJV8hlg7P5SJUYZG76gHj+LSkExiFYvUUty8N2cbO25cH4gxszUNKeZWUUkRtvrrPSCmvk1JmpJRtUso3SykPzGng5ua4W0p5JfC/gQ3A/UKI24UQS85E//OkpQ5sxcCTr0VArKOL8uSYJ1eL08Zn4kl1LkYvFyjOhITN1zp2a/i1+Nv7SczSRVcwNLKDfGG85lg11ZbA+LXVFqkIklqWZW1b2Df+eFWV8EUSedv7yvz+LRCuqPhUntB6tfK3CIEuSxiyQkJNh5MhHzQ1gW7UXotHi6cRQqFsL93gqC143sezHZTcPlG49vtv9EIh1tFNaazGulIRCFussBFIKTFKRctpODinMFTyJlHTkr4n4FDyYv6dHNpPW+8qz/cTSljsNnVSjboXScSOEjJkNcLIIi6pbA9rL3sPA3sfZWT/NieiyBnfiSaCvstvYebwHmYP7w2EQGdWryPRt4iJBx/wqi0SWq5/HfntuyifGnX8WqQhyF5xHkIRjN230yQSVm4WqcVZettmDty+k1LZJDImgTAJysW/uIbt3z3O2EDRUVt0aUYR2WpLz/I0b/7Vbj75V8PMzuLxb3Ey5oaQFzeJcUKkfSqLP8GcjmDkZIlTh4tsvKzqQG3DrcgYUlCaLRNLR5BgJ+GigT9Xi5JMIK0VoN3XMCURA612QruXFa+8yvKzhkesv58HbgVeEkJ89HQT282TljowSgXvzd56HW/rxCgXPblawsmLIJHtRI0lmR0/7twcAxFEwqvWBAhKo/larF+0o2M12cwCjp18IlAlknz4+vDsCy2LUFvaL6ZilDg2vSPC8TbETOR+7yMukeTFDSVEpfH15d9f1E3JOaE2JjOrahxdjyAt9o0VhViylVIhehVwISHeYpoXGyETQkKsq5vy6LBnrKg5hLVvpj5grvViGE5OmUb6tElLmE+LM56rnV7MMzt+nNae1VafrqfsKMJCI2qLj7zYZMX2c7GIS3vPWpaffwuHtt3O9NBhh7D4nW5TXf10bLiIgYfuAt3w+doIOl93PVPPbKMyNl5VWwxIrlxJfNlipu951DIPYTpgxuK037CV4bueolLxLqS46JZzyQ/PcPLxY2bos527xVBYffUiulZkue/fD3nUFjvhXMkKh/653+hBSvjyJ8eq5iMXcYFqArgwvxY3sfHDn59l+xOztHRo9J+TcZyDo1CaLRPPVEmL26/FWQDVCB5YSiqBkQ93blfSjfmjzeOsQQAfBi4AngT+DJO8/NxcO5wnLXVQmQm/+cTazBD40pQVEu8oHsG6QgjSnYuYHT/h2xHScVOmoyrJCRtz6eLXcHLgacqVfJWUuOsqQQIVag7yj1lDcZGKIKYmWdF+EQcmnqRiFIN5W9zw527xE5ew9Px+n5YwwhJI/S8CBKZomKQlrjZ24VOVOBW96Llhh92848kWyvmpgLrirhtzKS01iYutzHR2U3YrLQ20mfN+wLAS3zlKSwP9VPIzKPEkilrn6ddqNz18ECFUWjqXVb8jg0C/DhGxSYkhnU3o5uYpk942AXORTVwkLFx5BT3LL2Tfw5+nND3uSTxXJTGSBRffRHF8iKldz3rJjQHZtRuJ9yxg4qEHPXlbBIKW665k9rGn0SdnTeIiBVJC6w2XUBoYZ+rZQ57U/rGODH3XrGHvN3a6IoVMtcVQVF77wQ088+1jDB3Ne9QWt1NuPB3jfX+8kG9+ZpwjByqhxMVNTvwb+BxunXZV05BhJbrb8cQMGy9r8TjhQpXcuM1IpdkKaibuqlNtI1TrWuRzdBdCoiTjGIWfMtJyOirL/yy1BQAr/8y1wDswP/03hBD3CyE2NtvXPGmpA33WIi0u85AUoCaTqKkMZZdfi4MQk2Wmc7FDWhoNX67WCX8drGffsM0/vT3nomlJTgxsi65bc1xfnSi1JaSvZW1bUJQYByafCnbsdsp1+vL5t9hlrvdRoc6Bcn/7CBSNHDElhSJU8/PWWQ5AUxPoeily1WVbKYgnWykVpiLqmH8T2Q6MUsEMe4bwC5mb5HT2UB71moc8N+SaM28SEmQjpMWeozVPM0dLxlNeS+WZHNxPa/cKVGtZgyq5k972NvnwkRLP53c5yNokpuqrIqsmH0+yOomCYMUFbyLV2su+hz6HUSp6zUTW30S6jZ7zX8fgYz9AlspBteWq65ne9hMqdt4WaY6XPn8TSmsLMw88aZqHJOZCip2ttF6+geHvbAskm1v61gsYfuYEI/vGTWdcl9qy8rV99G1o595/O+jkabHVFrdT7iU3d7D54jQf/eAppqdkJHGJ2sBLWADPawApJS88McOmy7wZkP1qjA3TPKSZpijfhcxejwvdUtPc+1IJpJu0uJ9f0mdpCR0Jjh/AnLazM+2zDWtV6i3A3ZiOwtub7WOetNSBPjsTSRScsGd7v7+eqG6ZzsXMjh0Ld8aN6N/0o3GfoUETUS3yoSgqSxZdwdHjj9ZVW8zyCBORT11pRG1RlRjruq7i8OSzTJeGQ3O7BMxE9YiLLzlceK6WkHahjsgKRX22YX8WMM1DIDGMsic7l//GHE+1UbTWmwpNWw/EWzsBKE6Oene4b8ju+l09lCfGMAq1fWqIGC8KUZ9ct5J2Kcnqk2wtRUhIqORm0FItoUqJsE00rn3TI4do7Vlp1ZGBeQcIi1NW3dy5WgIOuy7yUu0Hx1RkExcVjXMu+wX0cp4jT33bS4KM6pg9W67BqJQYf/7xgCmp5ZzNxDq7qllyDUAKFKHRcu1rmX7wSYyS4Unt337zJcw8dyCQbC67ZgGdFyxi71dfDKotQuWq31zPC987weCRXDW02ae2SKHye/+8hHJJ8rHfG6SiCw9x8ZuLnN8drx9Ltdzln2L1s/eFAuODZTZe3m5FHikeMmKrLIYUlHIVjLJBorV2qn8ZcuAqiThGsWz9IO4DC5TUvHnoZwA3CyH+RAjxNSHELmAIeIO1r2kOMk9a6kD3ZVx0E5h4e2fAPBR1F8h2L0Mv5SlMhztTevxaQpSaumqLn8RYv+yiRZegagkOHX0wOOYcw5+944arLVIRLMisoSe9gh0jP6rm+wgxEzVEXPzkxZ/fRRHhhMUZRKmGU1v9FyrTJFXfOjk1ENPSAJTLwVBlx+HVgGS2m8LMaGCfm1BoyQxaqoXi6EBD5pxk/xIQgsKJo6cXQRTW1lE4qq8rE+MoiSRKsvEn2UpuOpBYLgxCgtR1cpOnyLQv9pqG7PmEzNM9P4eouOrboc4BpaYOcUFCLJ5l9SXvYuTQM8wMHHT8XqoOvaBpCXouuJqRpx5AFkvV+Vp5W9ovu5Kpp36CUSyCIZz22Uu2IvNF8s/t8qb2X7WExLJeRu993pNsTkrBsrecx7H7DzA7XvIspFgxFBZduIC+je089LmjDgFxp/e3SUy6Lc4ff2opzz02y5c/Ne7ygxGh5MWtqDjmHZss2fVcZp97vjLKpstb6F0SVOP8ZGjqpOn7l+0LPz7sbLhqMkhqhCKCSQ7tPC7xxqPbziTq+IM3tL1aIYT4RyHE/ZhJ7CTwZeAvgbda778B/BFm2PbCZvufJy11YETkxrATzDnrD7khgsQilu0glmpleuSwc9NsPIlcg2pLSH+qEmPNyps5fupJZnNDZ0xtCdQNqSeEYEP3tcyWxzkyvT0kP4sS/tn8xCWMvPj3OeP7CEsNFaWgz5DSfKSlRn07CV25UjtfSirdSWFmJHy1ZxdxSXYtpDB2ynkfRkbsMiWeILGgn/zRQ95+3HXDxpK+92GvQ96XJ8bR2jtMNavBC6y5WGIwiiQM+clBpKGTbe/3jG8TEb/K4s6UG1RVQsiKfx0i2/fFT1ycCCNo7VxB97ItHN72bajoAbMTEro2XoE0DMZfeCKgtrRu3gqKwszTT7simARqKk36ovOYefAn5s1K2v4cCu3Xb2X8/ufRy7ov2dwqEh0pDt61x7OQoq22XPbeNTz3neNMDJccYlGSWnVhRctMtGh1mg//7SK++E8j/OThnMeB109egmSlSlhs2CrL9ESFR+8e57p39fjMU14Tkh2RNHE8h5ZQSXWGk2C9UEbEVIQaljxShDroAoh4/UUaXxbIM7C9evHbwEXAHuDfgV8DLgVapJQbpZTvllL+nZTyR3PJGTNPWuqgkrOig8KIiJWrRfrJA/Z7ezOf8LPdy5gZPeLtRATb+fuo9zrYxqu2dHetp711OQeO3Bdd199nHbUlWBautiRjraztupJ944+RK0/WNhPZ/UCVuIQ51trkJWzz17Xrh/ir5PVpkjZpqfEbCOvRKKYkEShe0hJCBJLZbqRRoZSfCtyMPfU6FlIYOeUbi9CLmpCQWrqCwtHDnn5C64cRkiYvkuXxUWIdYeutRfdlkpaQJ+mQOc5OnCCWbCWebA2ahtzKj4+w2Ps9RMWVi17oXgLjX4fIQ1zs/TaBkbDs3DdQyo0zuOfxatI5Vwi0FovTs8WltthzNkDR4rRfdBmTjz2CdKX+x4Dsay6hsHs/lYExb/jza89DzxWZeHK/J/xZKCpLbtvMgTt2UqlIj9piSMHKqxbT2pfikS8d8+Rz8ZuJDBQuvqmTN/9qF3/92yc5fqzsUlj8BEV4yIqbsLhVFoAHvz1Btk3jgms6wg8GqoQFYPLkDC39maA5165brKAkInK4KApIGepLJhJni7SI099evVgnpWyVUl4hpfyglPLTUsptZ2q9o3nSUgdGftb7COw61mJtnZSnx5DS8KT4j0K2Zxkzw4fD6wlqm4iaVFvcxEUIwcrl1zM8uoupmRNzV1v8++z3PgLiL1vSci6tiQXsHL2/euHxm4lqOdKGqS5RiPocUDUNWQpPvjJFSmtMGbDbx2IpymXfirPup0AJyXQnICjMjDhl4DuMJCQ7F1IYG6gfPWTtTy1ZTuH4YaQe3cD5xPX6hKAy40JlfNxZzTy0v5D+y7lpYpbSEkW+7LLc2HEytsqCzzQE0fq5TV5cRKVSznPs+OMcP/EEU1PHMSqVqpLiEJYQ4mKbf1xbPNHC4o03cuLFeyjnpqpOuS6C2L35CqQ0GH/+CWscHHLTdtHllMdGKRzcjye1//KlxPoXMPPI0xZhASkFSjpFyxUbGf3hc+hWun8n/PnmjRTH85x49Jgn2VxZqkhV5dJfWs1TXz9Cblb3Eg2fmchA4T2/t5BVG1L8+a+fZDYvXU624RsQICy2yjI8qHPnp4e45p3daDHF48/iV2zM9gpTJ2Zp6c9GOunqhTJqMiqHi3WkhiyhoZwtpWUekZBS7ns5+58nLXXg92lxI97eidR1KrPeSJEon5Ns93LyU4NVn4gGyXZdtaWBftraltLdue701BYfmZF+shISZiwVgVAUNnbfwHjxOCdnd4fkZ2mQuPjJS9jmn3uEylLUZykZOVriza3rFdPSlMohi7S5brKKopFIt1OcDoYouwlKqrOP8swEejEf4mAaNBcll6zAKBQoDUcQnQaIRSN1hITyxBix9s6a5McfwVPJTROzsuHWw+zESTLtizzExmMagqDK4iYsmOsWHT7yII8/9fccOfYQR48/xtPbP8XDj/0lTz/37+zdezeDAy8g9UokcXHUFmedIuhbdRmJdAfHn/0ebhOQrbaoqqW2bHsAWSp5yE8s205m3UamnnjC5cQrUKRC5jWXMPPo0xhlwwx9xnLIvW4rM9sPUjg1gXT5rmhtGfqvWcO+23da5iEztb+ttmx84zLUuMoT3zgZqrY4JiCpgGo65k6PG/zznw4hZZW4RG2O6uIiLDMzkr/59SN098W59QMLHZIUBVudmTiZo7U/a5UFs/HqhTJKBGlxIotCTERny6dF4CKrc9nOyqxfHZgnLXVg5PPBQksFibWaT6LOas8iWMetmGQ6FyNUjenhw85NVfoVlZBxqu8j1BYLtdQWgJUrbmB8/ADDo7vOvNrif+8ryya6WN1xGbtHH/SaiZwx6hCXMPISBvf+sGUBLEyWBlGESibWWbs/3xN/TEtTLs9YJgbfRdRNSFp6yU8P1/RTSXYuBAT54ZPR49v1JcRa24l1dJE7sK86nps42PX9cwpRPfx13OTDqFQojw4T7+6N/Hx+GOUiRqmAlq7v2CylJDc5QLqtL9i3pGq+ceYWJCy53DDPPv+fHD3xGKuWX8/lF/4OV1z4O7z24j9i8/p30dm+ilxuhJf2fZvnX/gilUIuaCqyCItjbrLUGQWVFRe8iZHDz5IbORFog4TuTVdgVMpM7Xk+8P21bb2E2d070WdzHofczMUXYEzPUth9ECTV1Z/XLiW+qJvxH+90HHLtlYCX3LaZ4WdOMH1qJpDaX8bjXPiuFfzkq0coGwTVFlkNWTZQyHbG+aNPLuGhu6f42IcHmJiQ9cOeZZWUTI1X+OgvHmJqrMKHP7kaLa65Fl/0+snolnkKTP+d0f0TtC1v8x4zFvmSUlCeLKC1hEcCOblbnPPadSCerYy4/vNqLts85oR50lIHRtkMMQ0jF0osbuZqmZ6oFta6n2oa2e5lTA3tD+yzTUKB7LjO/jqv65mJgGxmAUsWX86eA3dTqRSDSkpI/2dKbQFY0XYRLYleXhj5QTDFP0QTl7C8K24zVIhJKjyCqKrqjBdP0RZfiKI0d9FLxFsolapKi5+42O9TLdWVvT3RQ67XqpYg0dFLfuiYl4D46zp9Q2btBmb37IqeoK1a1PgM9UxIpYGTSF0n2bckUC9KRSnPTAIQy7QF9rnDnYUEvTCDXs6TzvaEzj1sLJuwSCk5eWob2579JJqW5NLz/z8WL7wYVcRMM4yWobtjLauWXssFG3+Ri8//IKXSFE8/9ylmZ4a8xEWXHiLi3lq7V9Lev47j279XJSw+taV97QVM7NzmTUQnIbPiHJR4gtyOFz19a+ksyfVryD31grMekUlOFFqu2MjEo7sxJB6H3JZ1C8ksbuPIvQc84c92Yrlz37SCycE8Lz02EVBbbDOR279l5eYsf/P1Fex7scCv33yQpx/NOwQjbLMJy+CpCn/0jkMUiwZ/8bVz6OiNeZPNRdjFDSnIjRWZOj5L76auyHqFoWkSPVXC6z4UZLEMMQ2hqcFjq8F0BfN49WCetNRDpYLUXVEgvnMk1tJukha/yuKDfXNv7V3N1NABqyy8bgB11JZ6xMWsa/5ZsexahFA4eOz+8P5fJrXFNBOpnNd7M/nKFDtG7nPNO5q4RKouYYnjIhxyAxc2IZgonaI90Rco94wVgngsQ6nsXQzRfyMXBqRbFpCfGgqv43qd7llikpYa/bnbZNZsIH/kAHq+6FFYPGpLDeISKAsZq3D8KLHOLtRMeHhq2PxM0iIcnxa7Xljd/LQZMJDMdjsKR6BvJy+L9Mzx0OH72LP/LlYuvZbzN/wiiXirx7zkjyxKJzu5cPMHyKR7efq5f2dk+CUPccGVfM4xE9lOuZtuZnJgH1Mn94X6tnSsu4jZY/spTYx5w58VlezGc5l5fruL8JgkJb31XPLP7UTaJiJpJpxruXwjxSND5I+O+jLUqiy64RyO3rMP3cDlkGsShXR3inOu7uPJrx72ONG6c7e4zUQGCqvOzfLxu1Zz2Q2tfOSXjvLJPx8k5xKUDUupsU1CRw+V+MO3H6SlQ+OjX15La2/cIkLCk7rfY16iagI68fwoakKlfU2nq573SCwOTRHvCfcvMwpFc52hMJwt0jLviHvWME9aGoBeinB6FiZpKUWYh8KOz9aFq8mNn6RcqvrKhJIXW22pp7BEEBc33GYiVY2zdvUtHDvxBFMzJ19+tcVXPxlrZcvCNzGQ22dmy3WHJocQF/NPiOoChEYOOfPytXXNwZA6k6VB2pP9NIt4LEuxHFzB2X9zTrf0UsyNe46dsAiiVO9ickPHQ2/wHhXAapNatgqhauT27Q70FXgNYVbKQD0/+SkcP0Zy0VLP5wqQD9/78uwkWjqLUNW68ndhaph4uh1VqzpRusmJ/3PbKkshP87R44+yYc1bWLrocgSKQ1T86xa5CYymJjh33TtZ0n8ZL+z8EocPP4R0crpgEiSXCcrO35JuXUjP8q0c3/49cyE/FxkSEtK9y0h09DK5c1uA0LRs3kL+wD4qU9PVDLkSUuduxMgVKLx00MzZIgEpiC1aQGJpLxOP7PZkyDUQLLh2HdOHxxnbO+aEPxsucnLxL69l70NDHHphxnHUjTIT2cRFS2r86v9ezEc/v5zH753it249wLaHc+x4usDTD03z0Pen+OE3J7jjM6P84dsPsvScFH/yX2tItsa8kUeOs6431Nnep6Nw+PEB+rf2osZUjy+Lm7wUh6aJ97Y65iI3jGIZkYjIzFzPMf/lQpi5p9ltHnPCPGlpAEYhSFrs88pRWhqBgEzXEhRVY2r4YOApwWMi8rULU1v8xCXQl93W/V6B7q519HRt4KX93zGTvrnIkXSRDpNMRagtfiUlQGZ8711morZkH+f13sz+iSc4OfNSw8QlQF4CeV+85cFsuWaf0+URDFnxKC31UvjbiMeylErh61G5b+zpFtMfJD895LlI+SOIMt1LKE0OB9P5R5hKVFWjZdP5TD71WOBpLaDmRF0YfYqMv7xw4qhJWupdWF038MrMpGkaaqBNfnqIVLYnfI41/IQOHX2ATLqXBd2bHIIBeNYd8m8OgUFh1dJr2bTuHRw++iC7d33TJCKRywKY5Us23kBuYoCJoy9im4DsOgqm2jK+cxsYhsdMlF66EjXbQu7F56v9GgItnTFNRNtedHK22IpLyxUbmXhkF7ohHYdcQwqS/R20b1zI4R/ur2bHde1fuLGTtVct5P5P7LXMRkEzUckqdxMXA4Vzr2jl499by+rNKf73e4/w++84xF/+2jE++Wcn+dq/DvHAt8a54g0d/O6/rUJLqQ5hsVUW8+uvZs/1+7NIKTn82CmWXt7v1PGrLLo0lZZEb5TSUvrpU1rmcdZwFtf1/tmBUfSSFimqNwitpZ3cqSOufQIRduUWmBc6VSPbs4Kpwb10Ldrk6SusjURUL87WA5uQmCerlJ72zmtrLCmstv73wNrVb+DJp/+ZoyefYNmiKzxzBIIJnazxnM/ovrkoVNPa2xcRd2iz671UhLkAXWYN53ReyYsj95LUsnQmF5vjuesrihnm6CqziYgTOh1BNoSPMLlfjxdPkdbazBT+TSKhZU3zkD1X//DWjUiLp4klWyhMDpLpXlrdR/XmKDFXEEYo5AaPkV2+Njig/Xu6XndcehVHPvW35I8dJrV0WfVoExFtwhBCogD0fI7yyBDJ/qWBurX6K9ukJQouglKYHibZ0hO6D/CahgAMyM0Oc2rwOc7f+IuOwlKtV2NYu45inksLujaSOreTZ1/4DCeOP8HiJVdgm4nM4986tg2BVCCR6qBnxUUM7H6YjmXngbAca62Hi45ztjLw5PfJHT9Eetkq5/MIodCy6Txmnt9O6xWvqf7m0jQRTdzxPeQv3oZUBRLpmIhGvvog+SMjaCu7PY6q/defw4EvbuP837wEXXFlsxXmukKv+Y0N/NfbH+DQc5Os2tKCgkBBQbEPNAG689qoPhkJSLfF+dA/LOMDH9WJJQSxuEUuXGqKX0WxF0z0h0i7TUOGFAzvn2b6VI4lVyy2+hJW3ar5qDJTRM+XifcEnbilFMhCCeHOlOsiPeJsxeGcrlryKlNahBBLgT+fS1sp5XubqT+vtDQAWalE7tNa2qjMTAVMN47Jx6eSSAFdy85j5MhzGBUzdTWu+jXVFlcfZplP2fDss+t6FRezLiQSbaxZdTMHDt/L9Myp2maiZtQW974IM5G0VJjlbVtZ0rqZZwe/w1RxKFpx8aku5ktRc/OMa/djYTh/kO7U8uo4jT6tSUk8lsEwKui6awE3+6bnqRsRQeR7rcTiJDsXkB8+7lEu/BFBbnUk0buQzDkbGf/xjwJjehx5Iz9HyHurbW7/PkQ8YS4b4Bs3sj1Qnp4g1tIRPpavfmF2jFQ2GGouQuZvE5dTA8/QkllIV9vqcMISkSvd6dPlx9Ka6WP1ips4cPBeCrkxj5NwmNqyYOUlzIwcoTg5XP2OLUUllmkn07+S6b0vOGX2/sy6zRSOHHaiiBwT0ab1GDM5SodOmETGiiKK9fUQX9TN1NMHAyai3teupjiWY3TXsMch1yY2PWvbWXPlAh774iFf6LJ7dWZfSn6XKmKgkGyJoca1qj+L7ZCLTTSqKgtg9WW/rvbnxo7vHqZnXQdtS1qcul4TkWD64CgISCzqcvn5VM1E+uQMamu4f5XH3/CVhDwD26sL3cAvAq9rYrsB+KVmB5onLQ3AOTFC7m1appVKbsaTYC6yH+vm2Ln8fJCSkePb6w8u8BIPh4zY+0Vd/xYZRiwU6Fuwle7Oc9i171sYRsXTxt2fPU5tgoL3vbuPCNVDKArru66hJ72Spwe/zWx5PEhcwsxFjZCMiLYlPc9Y8TgL0qvr9xGCeMxcxbherhaAVLbHNA8RYrpxvU71LCY/dDx0PPeN3P2363U3MrtvN4WjRwMEJzICKaqeC7N7dpFZtRahaTUVDP++0tSoswhk6Nh2sZQUZ8dIpjsCTrih8wekoTMwvJ2+3guC9Rpc6MVPXBYt2EpLtp89e79jqjESM5rIFwKNhExrP6nWBYwcerYaeeRsktYVm5g6sNOXVwbSi5cjYnEK+/d5yJDakiW2uI/Czn3WEw6OQ27m/JVMP3fQcrOpkpJYZ5a2db2cfOyoz0RUJSYXvmcNu+8/xeiJgi8NvyuayEVcwsiLZ8O/RpHL+dblyxJYAsBqXyxJdt11mA1vWeNSWNwmJbNseu8gqSVdqKnwRHGV0Um0rrbQfbJUDi1/+SGqT6dzcsI9SwrRywsBrJFSrmxkA940l0HmSUsDkIYReoWXArRMFqSBnq+dMM5NaFQtQfeKCxna/2SVdNRRW7wkIdhnQ8TFR2KEKjhnzW0Ui1McPv5w9SYvoKZTbiRBCSEz7tcup1jbh0QoCpt7b6ItsYCfnPoGE4VTwXWDolSXWpszJ+8hPlQ4hKYk6EgupilYN9eYQ1qCzriA50ZtKy3OVxBBIMwIoqPh4bcR/Sf7FpM5ZxOjD94T2mc9/5YwYqPnZpl96UWy6zeHkpswR2FTKZCUpseJZzsiI4Zs6MUcRqVEIt3p6kda85DeMgADxiYOUCrPsqD7XEdlEe76rrqezd4XQlwECutX38b4xEGGBp93yIqbeNjkRUHQvWwLo4eftRx48fxGrSs2Up4aozh8qvq9GSBUjfTK1eT2vOQQGaRAGILk+jUUdu23piasjy9In7ea3K6j6PmKJ4pISkHPZcs59dgRL2FxEZMlF/XQs6qVJ756xJckziYcXuISSl5cW7C98JiFbF8Wz2KLLtPQ3vtPohcNVt+43NkHXp8WKQXTe4fIrlkQecxURidRO1t9FyKrfbnOqufzeKWQB3bQnIZkt2kKryrSIoTICiE+LoQ4KYQoCCG2CyHeeZqdQtjCdxa0jOk8Vsm5suL6yIT3pm/+6Vl9KTOjR5gdP1FzeDtvS6BvN3GJcMwNjSjyEZd4PMva1bdw+NiPw81ENUKgowiK9BGUULOPi7goisYFC2+jN72Spwa/yamZPeHEJYy81IK7jtV2MLef3vQqlLCQaf9nDIGqxFDVhCdXS6AL6yk9le0xF050SdhOxIrzHjK9yyhNjVH2ZVYGwsmL9b7rqhvI7X+J/NEjoUpOzYgkVz27fPyRH6NmsrRsdCkaUWTHBaOYxygVvEqLD/a4RWv160SmI7yiTR6oEpeBwefo6lhrqlxhhMVFUkLXJLLr+YhLJtXD8iWvY9/+uykXZ6q/jS/1PxJ6lm6hODNKbuSoi4CY5qBEazeJzoVMH9jpUWGQkF59Drl9e6pqjlWeXLeG4oGjGPmSNYaptKTWL0dKyczOYx4yYyDouXwlU/tHmTo25XK0dYVHC5UL372KZ751lNys4SMfIkBcgPBwZbdq4jIt+QlLIN2/R6VReOFbB1lz0zK0jCtE2qW4OErLvkHSqxdYyhIOSbPVp8roJFpnu/U7eg8XWT47SovbnDjX7dUEKeVuKeW5UsoQ7TSyzQ4p5bnNjjUn0iKEWDWXdq8A7sC0kf058HpgG/D/s/feYZJk5Znv70Sk91nedLXvaW/Gw2AHGBi8hECIlUUGaWVW5mq196656+5arVZ7dVdIK7MS8kggQAIGOyBmBgbGm56e9l3tqsubrEqfce4fYfKEy8yq7pmWoL7nyScjjosTJ8x54/3M+XMhxD/acIua1o7IiB/s68kUCI3mmsejJIgBVIBGqjBCdnAn02e/EThRet2dfWoiT3u9AJdAjyINhgYPM9C/v6OayGVH0xGgqH1WQU4IwFGAy8HBN7OncA/PzD3AmaVHg4/pZVE6/TzHa8o6c9WLpmroOrwOYlHLGFeZIINeQqnMINJoUSsvdJz8k/2jaNE45avnlS98d5kgFVBiZAvpfYdYsNgWr3u0Wtb3olTKmd4/JZa++TD9r3+L6bbsacMlnvT6yoI5Llk/aLFVKLbU1hbQo0ki0eDop95jNBsVZudfYHTwVlc7ZhnpAyvuY3vAiwe4IGH7+GuIRTOcOfOAf+wtUCKkJJ4skBvaxdy5JwJVRPmdhyided7D0kB6935ay8s0p6exVUFIiO/eAQJqL553AAtSIBJxUvu2svLkOaCtRjGkIL1riPREgUtfOqvYtLTZEEMKDr5tAj2i8eQnL3tYlGDgorIugT8bGAUAFpVl8cZmWZgscfnxWQ6+Z5cbrNh2OFa5erlB5dICmT0jwbdBs0VraRU9RD1k1G6SekjegN+mbEg2yrScFkIsCCG+JIT4z0KI9wkhgu+6l0mEEG8D7gN+Wkr5v6SUX5FS/gTwReBXhRD+cIq9NRy4UFc7WyOSytAoB7vBtgv694d2v5K5ySdp1NZ8KiK1nKMmegmAC2CqiXa/i1pthbMXv6QABDebsiE1kYsh8YAP1TAXEJrGjuJd3Dr8Ts4tP8Zzc5/DEK1w1qUb8PCAnWvlM+hCZyC51Z/vPYcOEotaofy9h/O8iOKpAkKLtFVEAcADCULTSQ1vZe3aheDT6ABe+l/3FspnTlKZnGwnqsDF+3IMATbzX/480XyB7KHb2oxAUHuedoQ0QYsWS6DH20Ak7GuytrZIIt3ne4EHljdgdv4FNC3KQPEW5fylD7CYfZKBPxd4cRnoSjQRYd/u7+LazNMsLZ5z1E8226L2b2DrrSxcfAbZcsdsQUJu+0Eq05dorK64mKxYsZ9o/wDl06dc106Pxonv2uGoiNp2LYL00Z2sPnPeZ9cCGqNv2MPlr5xzuz0rBrlaLMJt37udb/35BZqGX83jBS4u8BLwcxnlBgAWp21P2P6nPnqOwX1F+vcNWJey7RbdZlsEpdOmzVdq11CbYVFugebCCkiJbjMtzr1nvTvqm+qhv28ihHjnS4kHNgpafgT4IyAB/CzwUeCKEOJTQojRThVfQvluYBX4K0/6HwBjwN0batUwEHoHz3Bhsi1GrewHJkoZW1QQUNx2hGg8w7VTDwXWcQGGIPuWMODSxThXBoCSWCLDgX3v4+LlR5iee97PpnSI3RIIUDzn2itwQQiG03u4e+z7mK9e4rFrf02tuRasYlL3O9m1AFJKzq88wZbsYTThvp7SayzcRSJ6wlwGIUDUiUkIjXiyQGNtyV0oAEgkB7dQmb0SbtcSUEdISIyOk9l/mIWvfM78Uu8AMHxpVn8rF86x8sSjDL39Pe3F6dTzUf6DvhDri7PE8wOm+2mnr0gJtfIisVQhpICfmVlcPEtfYRe60IMXzOtmhAvOvxe42GqiQnaCkaGjnDn7gBNETmVRbIPc4ugBmrU1yvOXXMBOSEgOTqDF4lQun/OBxsTWHVQnL7TrWIxLfOdW6ucvW120VUGQ2LuV2sUZmmt1cyK38g0EA680VURrs2VFLaPGSdE4/O7tzF1Y49Jzy0q6CAQuKngJ+qnqHtUWpd2ewqBYBr2lhQbP/fU5jv3APqTQXGBFBSwAC09cJHPLKCKZcN8q1iWqT04jYlEig0VfCB8kGKvhatpNuWnySeCqEOKKEOKTQoh/KYS4XwjRfyMa3xBokVL+kZTyF6SUrwZywCHgV4BjwBeECDMYeEnlEHBCSun1T35WyQ8UIcSQEOKg+gNMFZhhILosyqUnUjSrIYa4LsDiTtM0nbEDb+Da6YdpNqputsWpI9qgRLFv6QhczJMKBy6e+vZ2f98t7Nx+HydO/TWra9PW5K+cywa8iXzqI7WMpx0VuOTjw7xy/PtpySYPXf0Il0vPm/0PAy9hYpWbqZyl3Fxme+62dQGUIInocVpGly886wUbS+WpVZb9LIJnck/2j1Odu9KOPxPQlr3tZUH6X/cWymdPUZk0VQo+I9uQfSHBaDSY/uRfkjt2J6kdKpvhOa4i3nOpLc0SLwwGF/acQ728RDxV7FwWEyxIKVlcPk8xt1Npp82yiABgAriNcT0ARl10UVUT7dz6RtZWp5mZMYPIedkWISWxeJZ0cQtLV0647F1MtkwjNbqDNQu0qOAzsWUrtUsXXawNQGz7BPWLV5BNo80eSEF85zgIwdqpKYdpsSW3Z5BoPsG1b11xqYig7YKcG8uw9Y5+nv6by44XkOH6V4CLCkwCPYjcgMVmWcxtEciyPP6np0kPJNn5pu0OG+SKz2LZs0gpWHh8ksLt261L6HZ1BqhfnCa6ZagNpj33Xmvl5oCWTZuWjnIEk9j4GKYr9D8HPgvMCiHOCyH+SgjxK0KINwghgiMKdpCN2rR8jxVMBimlIaV8QUr5a8CdQD/wgY20e53SDywEpC8o+WHy05hWzOrvU3amiEadGT/oZtPjKYxqe/EOaQGGAGN3pYz5P7DjDvRogmunH/Lnq/WvA7iok73ars8VWoNtE6+lr28Pz574M5rNqtNu21VauM+rE0AJTfeAmBDgkohkecX4B9iZv4sXFh7ksemPud2i1breY6htSsnZlcfYkj1IIpJxH3udIiToWswdpyVMJMSTeeqVZaduUBkhITkwTqtWaa8Yjv/l5lPZWPvxkTEyB44y/+Dnw+9Tz76dv/DVL2HUqgy+5V2B5XzqLHXb2q8tzRILAy0e8FMrLxG3mBbhAA8c5kMtWynPUauv0Jff2TbADTyGlaEa3triBS9qHUVNlIwXGB+7i4sXv+bYKHlthISEwug+lq++6AJ+dhuZsZ2UL591s20Sklu201xapLmy4rAsSIhvm0DWGzQuT7tOQ8RjJHaOsvbCZYdccryINJ3BOyaY+dalUBVRC41D79jK85+7Sr1uuACL2ZYfiLSUqUC1abGPrXobedVCKsuyttLk6Y+e5bYfOQARvW3rYv2bl8T8r63UKJ2aJn/bdscIt315TPBSm7xGbOtoG9SB6x4xVkO8+F5qsV+s1/P7NhUp5XGL2Ph5TPvSBvCXwI8Dnwd2Av8e03RjMbShENkoI/JXwHkhxIwQ4gEhxL8XQrwLiGKqY961wXavVzrh1055H8ZkYtTfu+3MXpgWJwx72ME9wMLeFpEIYwfewNTJh2g2a8E2LV4D2nUCF2c/DLgo20IX7L/le0DAiTOfbA+a2g+nDT9AUY8JBKevA7hoQmdn8S5ePf7DCDQeufrHnF36JoYwgqPhBoCRufpFSvUZduRuD2Z7gqRDnq7HaLZ606XHEnnq5eV2syF3YSI3gBaJUZm9GshyhNWzJ8j+17+FyuRZZj/7CWSj5eSpwMe7X5uaYvHhBxl623vQE/7owF3tWqz92tIsiXxAhNuAPtfLS8STBb9RradNDFhcPkc8liOZUOO/eFgWFbAAbcNoz5pELnsW2d4HByyND9/B6uoUq6W267JLXSWhOLKPtYXLNMslnxovPbaL6tw1muU1V158cAQRjVG/NOlK1/M59GKe+rnLDpixJ+vkvgnWTlyyTtnt+tx/x1ZmvnUZaUifisgGI7e8aQuNaouTX522VmFusyPmKatuy8IFTMx8d7pq1OtVCzlqJsuWJZaOsPcd251L5vJwUn7zT15Cj0dI72uvAeZde6g+eY3YVsU8QsmThrGpHvp7LEKIHwY+A3wLeA9wRkr5U1LK2zE1NK8CfnG97W4UtOzDjH73J0Aa+HlMPdZFqxNvsvRYbxNChDvg31iZJ5hNsd94QSwMAFLKGQsdOj/grJ3v2LSEvGf1RJJWtRyciR+wSM+EOLjzLrRIjOnTj7QTPWA8FLgIm9kRzv71ApdILM6h/R9gbuFFLk096prAN2Tf4k23/zsY2EqPGigVK3LH6Hs52H8fF1ae5JGrf8LZpW9Ras61z8sDYsqtFV5Y/CpPTf8N45mDpGJF9/Gg5zWHVNH1GK1eQYvCtNgS5G0kNI1E/6gZGVcVz9e+/e8z+h0aYcsP/CSl557i8h98mObysusG8paXLcn0Jz9K+pYDZA4ccbfrARw+exYlr1Ut06qsEi8MdqW9jUaNZr1MPFkIL6TI4tI5ivkd7ZdUGNAxcAOUIJWQVS4IuNjAJJ0cJJsZ59rUUz6DXDsIXqZvgkgsxdLUi67rICQkhyYQuk7l6gX3+Gk68fEtVC9edMqa9keC2PYJaucvoeAiAJL7tlJ58TJGU/rsWvru2EZ9ucrCyXm3F5HytRPJxDn8zq185cOnaTTNVn2AQ/oZFdXuRGVXvPVVtZDN8qwuN3niT09x7Af3IyJRl9dQu317TSLBwjfPkz+2DS2q+8CKlIJWpU5jesEELQHMRGu5FH5PvNQib8Dv21iEEP8Ck8D4b1LK+4BfA/5UCDEAIKWsSSkflVL+xnrb3qhNyykp5Z9KKX9JSvlaII/JTvwo8AiQxdRjfRq4upFjbECeA/YLIby0yGHrf91BbGzRoiGLddn58WQ40xI2JyqgRNMjjO2/l6snv0qzXvGAFQhjVVSvIl++A2jsMr0DF4BsbpRbdr+TM+cfYG7xFHiATah9y40ALta/1NzgRQjBeO4gr9nyQYZSu5hae5FHrv4JD135Q04uPMRS7Rp1WeHi6rM8Ov2XfO3K/2aheokjg/dzcOA+3yUI7r+yHSK6FsUwFFdL+yUUYCgaS2SpV4Nfrt4JPtE/Sm3hmrtdz3aQisgGGqmde9j6k78EUnLxt3+d6qVJvJS0NKB65QrTf/1nNOZnTeNb24DWKwHARQUwQkJt0fT+6GbTIiQO4xRkiBsEeJZWJinmdriP62VZ7H1wMy/OOSggxaofZKRrsy2jQ8eYmXkWqQJLZ5zNoHT5kb2sTJ322bVoWoTU8FbKV863+2y1kRjfSu3yJfd1lJZdy+QV89rY10hC4patGNU6lck512QOkBjMkNnex/QT5qvVHf+kvf2qf3yApatlnv3slMO2BAEXVwA5NBdY8bo1q4BFVQsBfOk/PEWqL8HB9+x2ASlDATb2f6PeYvbhM/S9eq8LsEjl8tQuTAEQnRhpXwdwWKnWwpLvPnpZZROwBIoQ4rcx1UI/I6X851byvwDOAX94ve1v1KblPwkh3iOE2AYgTXlBSvkRYAl4GBO43Iqpx3o55BNABvgeT/oPYwKnb260YT0VvO6FLVo01l5HKEy87IeSLgUM7X4F0USWU1//CEaz4QEU6vY6gIvSvsqKdAMudhtjY3ewdctreO7En7NcuuQCLuaJh8RvuYHAxTxH934skmJv/2t59ZYf5rVbfpSJ7GEWapd5dOrPefDS/+LM0qPkY8O8YvQDvGr8hxjJ7EWEtO2SHu1cDNki1IPeM2lqegzDZmUCXlYqsxHL9lEvLXa2ZekkEqK5Als++DOk9+zn8h/8JitPPwaY0W6XHv0aF3/r17j02/+dxtIiY9/3I0SzhcC+BKqGAvpTm79GNFNAj7m9P+xyKqtUKy8hhEYskW236ztXE2DUaivU6yWymfE2GOyoUvIAlwAPoqA4Li41ETDQt49afcVREak2K/Z+dmA7q7MXfEBSSEliaAtVW8VHe0zjQ8PUZ6Z9k1ZsdJjm1IwZC0qZlPViFj2XojppgkKvaqV4cISF4zNuQ1yPiijdn+DW9+3gkf99hqZBIHDxghd3JF2vy7QbsKjGt8c/f4XTD17mjf/ulWixqMsA1+s1ZEjB3CNnwTDoe/WeNmDxsC3VE5PEJobRUqn2JVLGrnltFi3b+d28KTdFfhD4Xinlb9kJVtC57wPuEkL84vU0vtFVnn8WUy0khRDzwBPAeWACeBsmwmoBz1i/l1yklA8IIb4I/JZlkXwG0yD4fuAHrP6sX6JRk2np8L7UIlFkEGgRBNcLSNf0CPte9xO88OXf5NQ3/ohb7vlhdC3ilJU2XpDmxO+s3kwbuNgUtrQyBNaXoKsNAdJaHdpaydnXNhJ7demdO++jXl/lmeN/zO1HfoJ0ahCUfDTRDm1uT/pSmgDFsPvZId3+t8GXPYmoeVI6q0O72rLURjuid7KjcCeVZolqc4V8fDQ44m0YGOokHiAjBUjZQtM6hP1Rrq2mR5FGy5yUOtUBYpmiyxAXzEnPfo+r20j3bSRo52l6hOF3v5/48CjTn/gLVh5/lOqVi2ipNLmjdzD2vh8iNjCkTJLhwCgUvFjb1YVp4n3Drq/IMDVRvbxENJlDoHUGIEBp9SqaiJBODrY/v51jW2CkoweRbINh5T4SmPcfmo0qrHTzwpKMF0inhpmfe5FMfrzdjsRZHDnXv40LawvUyytEs3mzeasbqYFxlk895ezbYxgbGqW1skKrUkHLJLHVTtGxEWSjSXN2kdiY6tYriG8fpnJhBkMe9Nm15PcPc+Yj3zLBgGjHQTGEdBiNltC46wd388Sfn+PEV2Y4/MYha2g03Cs9h8ehCvIUsgGL/b88W+NL//Ep7vixgwzt76MpQ1gWRTU09bkX6H/tXrREjEarHQnXzpdSUHnxIvG925Tr7u5b49oMkf4i9dLLb4x7vR5A3+beQ2+WUj7iTZRSTgkhfgDTyeXXN9r4Rm1abDfnDwJ/ARSAHwDuBX4f+J2Ndug65T3AHwP/DvgcZmyWD0gp/3SjDepJv4GiV0QkitH02DgI/7bPRsVhQMz/eKbI/nt/irXFK5z55p9hyJa/vlNe9Ma6KHXabfTOuAgh2Lv33eRyEzx9/CPUaisO4xLoUXQ9jIvVVqA3EPjURe3xNcsmozmKiXE/YFHb8kqP7IoqhtGBafGIppuLwBktC9R2eFnFskWaldX2vRQEGLq97OyJEkHxla9j/Ac/RHRgiNHv+yA7f/FfMXjfO3yAxVXXfhl7jxNSvrpwjUSxtzhSthFuL1Iuz5JK9qN7rmWoAa+q5jE827ZtilXO7fasAB5LRTTQt5f5+ZNtlshzzFR+FC0SZ01hWxw1UP8YzXKJZnnVNY7xfhMwNGemlT6DXiwgolEaV6adF4TNNsS3DVO9MBN4urkDo1Rn1yjPrDqMhlcMKUgPpjjy7q08/HunaUlcqzB7WZZ2vRDVUABgaRnw+X/3JLmxNLd98CBquH6fAa4FXipzayw8McnQfYdcQMX+l1IgDYPqyUkS+3ZY96X9cmqPXePaDJEB/2rhL4vIG/D7NhMhxG8JIX4KMIQQ6aAyUsovcB2ABTZu02Krg/5ISvlPpJSvlFLmpJQZKeWH1rP+wI0UKeWqlPLnpZSjUsq4lPKolPIvrqdNPWWClk50vRaJdlcP9SiJ7AD7Xv8hVmbOcvaxv8Jw3q7mX6hRbyfgYu8rAMkxeA0BLnYdKQSapnNo//cRj+d46vhHaDTKrnxgw8AlMI5L0ErPSjmvka5LQuq48tU21ON6RQveNmQLrQtosSdDTTftoRzQAqEvLFtV0ygtdXypdXKddrUvIb1zLyPvej+ZWw4gNN39wlSYgM7n4imnlK8tTJPo6wG0SBO0xJL5gLw2YEACBpQrc6SSA+7jqm8VL8sCbpuioLwQexc1bouQksG+fayULlOvldrHdwCdadeS7d9KaeaCq39CQrw4BEIzF09Uzl2LJ4gUitSnp11gRhM6kdEhGldnzO7ZwyAF8a0maLFZFjvdQJDZ1oeejDJ/vL0gZxsotI1rW2jc/cFbmHphiTOPLrRBhweUmPXdRrcug12Poa/tLfTMJy9y8ZvT3PfvX4Ee9bIrbpbFBi/XvnSCxFCOzMGJNkhxzs9sv3ZhGlmpEb9FZVrcwMVkWsLXu9qUl11+FHgfZkyWFSHEaSHEx4QQ/0oI8S7bnATTvmXDcjOCwP2DEj2RdD8sAS94EaYeCpIOH/Y2aEgVRtn3+g+xePU455/8RE/ARWVVpIbPu8h1bIELYAQBF2/wOT0a48jBHwTg6Rf+mKYdp+Q6gYvd/47AJeDfx7p0YlM8xw1laxSWx+vhpYo0WmiaolkNKGrX1yMBoCVEoqk8aBr1lUVPY55/Jd3LigQBi077fmNTT14IoBESWrUqjdUlEsVhP10e8FVZqyy5jHAdQ9YAKZfboMVsT2FEgsCHEZLvcouWzr6PbVHq5DLjRCNJ5udPusZCtWvJ9G9nde683xhXjxIvDLhXfLbGIzY4TH162mnPfliio8M0rs5Y3bUZB4hvH6a5UKKx7Dbyt+O1FPYNsfD8dGAcFNWOJD+e4cD9Ezz0u6cD7FHcICUIxKiARd1euFrhwV99hnt+5jCFHQUfy+IVQwoMA6Y+9wJD9x1wnvH2pWufe+WFSSIj/USK1urOzn1qtVtv0ZybJzpwk0DLJtMSJDUp5RullEVgNzCC6SBzCPgPmCYkyMAImr3LJmjpIlom27mABKHrrpV81UnMwTveNHuyFwQyHOm+Lex7zY8xf/Fpzjz6ZzQaFVfbUq3XA+viAjZOmr3dG3CJxlMcO/wjNJsVnnz+f1NvrLnyzQFbB3BRbFmkmubkdQAuQeDF23YAmPHZsfSgHvICmEarQkT3GJ4q49cJmLYb9ScJTSOSyNCsrIaW68iKhAARX5kOzElou9464Hg6JfqGA8t6pV5ZIZ7M44TG7yCV6oIZnyXAI6t9rACA4s0LsncJ2rZtqQyTSekr7mFx4Uzb9dkjmf6tlBevYrTaMXHMf0m8b9j0qvKAwOjgEI3ZGR+YiY4M0rw263tZRMdMj6za5TmXTYstub3DLJ2e87gVu4PE2XFWXvHBPUw+Nsf0qWXrdN3AJdAQNwSw2CzLg//1aQZ25znyj/b62BWzXbdqCGDpxWnKFxcYfNMhl42Oe2VnQeX4ORL7d7g9p5Rxq09dAylvmnqoW7TbXn7fhuJEo5dSngcaUsp/K6V8v5TyMOYyO9ctm6Cli0TzhdC89ktf9jT59SLqM5oZ2sGBe3+a1YVLPPO5/8rM5BNI2wDXC4YU4BLKuoArLxS42MAjALjEkzluO/oTADz+3O9SqS258oGuwKVj5Fw7zclzMyA+W5cw8BI0tmEqoV6vnVWuWlsikch3LGNLy1qjSI/EezpEmKqxqzdPNzDjKROkSvK9SIPYE+W/OjdFNFMM9BwKkl5tWgyjSa1eIhkvWseTVp/bAMNl2+KxWQlkYux/hZERQYDGkmJ+B4tL59uuzzbLYq1DlCmMIY0W1eUZn/osnh+gtjjntOW4Nxf7aCxa4aKUsY0M9NGca6eb/wItHiPSn6U6teTCTfYEn9nRR+n8opPmtiVxL044sKfAllv7eeyjk22wQjswnMvWRdkPAyynvjbNua9N8br/6w7HwNzteh2sGrr6wAvkj00QGylaQy/cpy0FstmicvwcycO725fHcx/WL1xC7yuipbvbHL4kYn81Xs/v20+uCSF2AwghokBWCKG+HDa2aLFHNkFLF9Gz1uTUcVKQ9PR53aGI2xC2vZ3qG+Po/f+U4V33cO6Jj3H8qx9mdfmqq72eWZcAIIL6DAkFbHQALrFEhluP/DiJeIHHn/0dVsvtdYo6ApcgZsXO1+huoOtN7wBegn7t6+BpS21flRCVU6W6RCJR9JcPEBu0aJFY17JCdvBECygLBDMpdP6aCwInQfW71alMXyQ1PNGRXbHFqFdpNaqBNi2qW7GQkmp1CZAk4soY28xML27P9nYQ0+LYz7gZFltFZPejmNtOvV6iUp53nbPDmsSzRGIpqkvT7TzrP5YfoL405wOT0cIAzYV5pMv2BiL9fRilNYxKzdfV2HAf9akFa9/NtKS3D1BbKFNdDl5SQnUzbqFx2/fu4LlPX6Ky2vSBEvCDFVe0WwWwzF8q84V/9wRHv3c3g3uLPpYlzAC3WWky85UXGXrz4bZ9jlSAi3VZKicvIWsNEgd3WWNuv8TMPyEF9YuXiW+d+Had/P+hyu8DfymE+CBmlPkp4P8AEEIcA8IjsK5DNkFLF4nmi4GGiL6Xeo/PjvcZ8wZ1C9oW0ShbDr2Zo/f/UyKxNM998X9w/qlP0qxXwlkXEcy62Pk+A127fgfgonoVRWJxjh75IfK5bTzx3O+xuHzBBVzsAHQqIHIGKkwlBH42xpUXAlic8QoGGYH5HepLpY+uPKAlGzSaa+aE2sNFbzXrCKGjeVcKD6mqeqJ1BBdBEgBkOtLSQcxLp3Y92+WZSySHJlx57mO11/CxowK7mJYQYFWtLiLQSMS6xODwAhA1PWg/IN3N2LTLJBN9xGJZlpbO+/ppGuMKkrkhKivTvnGP5wdplBYxmk0HuAgJkWIfstnEKJVQ7TRsY9Lm3KLzENsTeXS0SG1q0dNt2xi3CAJWzi8GGsACrjWF9rxxnGhC57lPm1GXvQBF/XnzbcCyMlXmoz/xNfp353nlz9/adq/ugWWZfvgsSOh/9S0uVZeqGgIoP3uW+K5x9HRKASzCNWa1yUvEtm3hpoq8jt+3oVjrD/4l8FPAEPB64LuEEKvA45ievdctm6Cli/jUQwE3nOzGtHizVGZEbUcEbCvPbDzbz97XfJC9r/5RFq+9yFOf+y9cO/cNpNHysyauugpToqiLfOH/7eOGABenLauupkU4dPD9DA8e5ann/4BrM087wMUpGxTyP4xZCWJjfHkinHUJ2g+wawllccJEeUqqNXPyTcQL7j6GSKtZQ48qqqGA6+46VIB6qBf9940AOF4D3DAjXyHBaNSpzl8jNdjbxFErLyOERjSR6dq/am2JeDyHJnQPyJLW8TsAFSVdeL2J7H+vnYonwJxp1yIo5newtHiunSbtY5tJydww1WXFsNb6jxUGQEoaSwpLA8TyJjhpLLjZGy2bQUSjNGfdKiIpBbGRPhrXFl0eRM75xWOkxvIsnw1eoURVERlSEInpHPnu7Tz+0fO0rIbCVENewAJQmqnw5x96iPyWNO/8tVehxSLKMdQAd36WRUrB1QeOM/j6fYh4zDm/ttdQG7iUnz5N8nA76Jxropdg1Oo0pqaJTUzcPNuQgI+BddmzfPsCl/8spbxbSvluKeU54C7gjcBdUspfuhHH2AQtXUSzJ5xuN1n3j+7e64cwJ3ZacWw/R+//ZUb3vo7JZz7DM1/6HyxMvdC2d0EBLwFMCdDdzkW4V4gOAy5CaNxyyzvZteMtHD/1cc5MftH0dlKO67aT8bInHmYFfKAm1LtI87RFQPth6Z3YG0W8i0RWaosIoRNXWIBOwKXVqLVVQz3cI1ok5o/54+pQl7SwbTXNA1h6evF7yphRXw1Sg71NHO7Acp3LVqqLDig0j93jG94GNYZ0AIu6HerybImqIgLTrmVp6TwYfqthISGZHaKyPK3Yxph/0VQOEYlSW5x1jbUWi6FnczQX5t1eWkKYdi2zC3iaIjLcR23KD0psliK7vY/ShUUHJHi9d1R1UguNY9+zg/kLq3zrzy74WBUVvHhD9FdWm/zFTz1Mqi/Bu/7Hq9GSMaece6Vpt2u0LZVryyw9dYmht4SrhgAa8yvUz18leevedrrnstUvXQHDID5xk5mWTekqVniUb0opn7xRbW6Cll4k6KtUzW7Ue7JZCG3eMzECfuDiSRORKOP738Cxt/0zsgM7OPXIRzj+1Q+zPHfOz5y46rYBis/ORSmrMiM+4KKUN0GJxtatr+LIwR/gytS3ePK5/021vqy01QYILnVRmJ2LB9QE5oWBjl4BTMi+oxoKYWeW166SSQ2D5n50XPZ1yq9RWyGWyAUCoiCRRgsRFM1X7a7KhHRt0PNT073lQuoHqZSqc1eI5fvR40lXn8KkXlkmFma8rPbTgHpthUTcXda1dpAtiguzUy7E28jHugSAFe/x8tmt1Oor1KpLgca4idwg1dI8Uqoh+EEIjViuj8ayB2xIiBSKNBeXlDRz4US9v0BrYdnX7+hQAWO1SnOtHuhBlJoosnbZXw9wqYjsepnxLG/7N7fxpV99luceuOqU66gekoIv/udnadUN3vUbr0FPxR3Vj5nvZlnsOq7YLF85TWK8QGbfaKBqyL4s5SdPoeczxLaPE2bPUjs3SXRk2ApHEXjqL714n6uN/L7DRQiRVWK39CyboGWdEhTXwqhX0VQPiqAbMmzOCgEl3v0w1iWayrHzju/h6Ft/hViqyAtf+W1efOQPqJYXXcyJD3BYbfnsXFzlcCZvF3DxlsfcHhjcx123/SwA33zqN5ldeJEgOxfnHNejLgqzdVFVRp2C0gWBHXVxxE6gQslbXpmkkLOesx6enuraAvF0b7EkpACj2Wize+uUnl2Yg+qo+2EUttJ+ZW6KRP+Yv8GQF3SjskIsGRA+IMCluFYvEY9m/a7GYW7LYfseY1zhtX/x7tuxW6y0dHKASCTB8vJFf7+BZHoAaTSpry6Z7TsTqzRBy8pCO91mYfIFmkuLPjCoF/K0FpetbrQn8Uh/AYDG3Irr2PZknxrLsXZlxe32jB9QqHLondt4/S8c5m//xeOc+fqcL9+lHpLmukIvfPYib/0Pd5PIxpx2g1gWu45XNTT9lZMMvm4fknYof18UXClYe/IUyVv3IjRNASxu4FI7d4H4zh3+C/Iyys10ebYm+/8qhPiCEGJWCCGFEP8moNwfWnne34vXceo3UvZjxW5Zj2yClm7Sw1dtq1ZFi61zolGBCG62xVuuXcaTrjzT8dwAe175/Rx+8y/QqJV55nO/ypWTX8Gw7V3U+iqIsICLaueitt+u4wYuUijlle1EqsCtx36M8dG7ePbEn/Hi2b+hZTTcgClMXWQBlHBDXM9YeQEO+AGMV8JsYux2FZbFa5BrCIPl0iUK+e2B1yFIamsLJHoELWDaimjRDbB262BOfGqhHl6g3vu/On+VRP9ozwCpXl0hmsj11MdavUQsZpUNUg2FqItC1UDetKD4Ll4NkBWvJZedYGXlohvISROYxNN9IDSqpTmfsX4010d9ecF3jpF8gebSkqdvECnmaS2u+CZqPZ8GXaM2W7K66mZaEqN5ytdKyJbhAg6AS0VkG+Ta23f90B7u+P7dfPwXH+Xy88uBrs+GFMxfLvPFf/8kr/zQAUYODzisjd2+yrIAgQa4pYuLrJ6Zpf91+xzVkH0uzi0oBUa9QeX5s6Ru3eu2Z1HGQxqS2rkLJHZsv7mMxc1lWvqBDwFx4JNdylaAV3p+77+uo3cRITp9AV6/bHTBxO9MCbnRjHqtp1gV0prfJR1AkFVACqWMXYn2O82VR7tOqm+cg2/8aWbPPcbks59mdvJJdt7+HnL9O1ynIJw65gKJSBO4CANcCy666lhLKWrtF4jZtXZ5iRn2f9euN9NX3M0LJz/G4tI5Dt7yXnKZcRO42OU1HPdPeyFHE7hYx/UuuAiuPPX0fbFypOxsYBsGWELKSgGra9doGXXyuW1+ZkZlbRSpri3Qv/VoeD88YjTraFYU3Y2IkArQDLhHNiRKPSFBSoPq3BSDR1/fc7uNSolMwfQ0Et44Kx6p1VeIxxRWRgEUvnrdAsyB67oIQ7bd322worf3hZRWNTMtn51gbvFkYD81oZPI9FFbmQP2KhMsxLN9lKfOO/vC6mYkX2DtzEl3OuYaRE2LaVEnaqFrRPuyNOZWMKQ70IWBIDmaR7YMKrNrRMfay70YUvhufzPNbLyFxut/4RDlhRof/Zmv84N/+Fr6t5tj3jLg6nOLPPnRc5z8wmXGjvVzx4/uV9RMngByuEGKCqoApj53nPSuQdI7BmkYdhl7yIVzCcvPn0e2DBIHPfFZlHFtzsxirK7ddKblJsskUJRSSiHEAPDjHcoaUspHX6Z+2bIshHgeeNL6PQU8L6W8IWvdbDIt3aSHL1hHPbTRScH5uBKefTc74mVdwpgXNI3B3Xdz7K2/Qro4zvEHf4szj/+VuWaQ+iEXxJYE2bmorIsIMdBVyttMSbFvJ3fd/nNks+M8/uzvcP7SV3s30u3EunRTGRHQVlgZddyVei7WxZLF0kVSiX5i8YxTz8eQ2eevgSENM3R9us9l8yKFwPNed8RobpBp6SQBX3ZBLItPNeRlGK3txsoiRqNGsn/Ulxcm9eoKsWSuI1gBaBkNms2KG7SAnz3xqHZ8tixSUm9VeH7ui1Rs+6qwY3tdn8HxFMpnt7K6OmUaRwd4ECUyA1RX5lwTK0DMZlo8/YrmirSWlnzjpRfytJaWkS3D1VUpITKQpzG37OmyeQMlh7OgCUpXSi5jXGeYPOwLtI1zhRDc/3/fxtihPv7ip77O/OQaT/31JB/5wIP8yQ99lfJijXf86iv5nt96HZrunyrCWBZ1u1U3mPrccUbeftTJs1VB3sUSy0+eInlgB1oiTpg9S/XMBfRclkhfn3l/+nr1MslNZFos49abxTH1Ig9gujz/Y+B3gSeAVSHEk0KI3xdC/KwQ4h6gS0yDYNlkWnqQINdP9cXeqlXQ471FBfWKi1FxHbR9TB/rgjvP1U8lP5LMsusVH2Bwx52cf/zjPPuFX2f33R8gP7BTbcLPlliMi82K2EyMud9mRaQAoQmFLVHKW9vRWJKDB76XgWv7OHnmU8wunGDvzneQz20Fi5mBANbFliBmxWZVpGyrjOx8L+PSQVyAI8j41ikHaILF5XNt1ZDmzg8CIbXKEkiDRCZYPRRUz7hOo27wsC0h+dcj1bkpRCRKLOc+rzBdvZSSRqVELN55SQwhpbNIYTyaWX8/lZleSsmzsw8wV7nAUvUqd499H1E9YQIUA8WWSxkowzoJo8265TPjSCkplS6T69/pO99EZoBKadaKSSMcFjWa7ceoVzFqFUQ05QDASL6IUatiVCqIbMJ5h0QKeWgZGCuraAPud3l0IEdjbiXQ7ZlIhORQhvLVFWDUVc+QGrpoWdvCfshcbAtRjXf/17v46E89zO+86wvEs1EOvXs77/gvryC/NefU9bIsKlBx2leOawOomW+co1VtMHDvgUDVkANgDCg/dYrcW19lXUPh+Tf/aucuEN+xHSFE16UgXkoRXN9zpNx1uwK0KbNSyuDlvdcvSSHENWAQM9jbJ4H/W0oZ7Cd/A0RK+X4AIUQOuBW4Tfn9EPAjXAfe3GRa1iFhN2ljdYVI2tbBb7Rxq7rrq7+9GcqshJVR8nLDuzn0ll+gMLqPF77620w+91laRtPPutjHtxgXl51LAOOi2rl0CkQnhWB45Ah33/7zpJIDPP7s73L81Meo1UuhrIuPeVENdcPsXRTmJZAFccZJybPqdfMgqjfWmF86zdDAQYWp8bbrHvfVpSvokXh3Q1yrvNFsYNSrRFK5zuXDpId7b0PB5Txl68vzxHP9CKEF1vMGljMaNaRsEY0Hf1g57AU4K4jHopaqwxv8zZvm66eZN7X2IvOVS9w98n4kBk9P/y2G0QwtH2jIa0gikQTp1CAry5f9HkSYoKW2qhiz2kxLtghAfXnRNUaRXB6A1sqy64HWc5ZqZrnkpNsTfKSYpbm05uu6DRQSgxkqs+5lXdoeQMHPgAoytGSM7/p/X8V9//I2fvILb+feXz7qAizB9du2LUEGuLbMPnyGvrt2EknH2/nKeDiuztcWac4u+eOzgAu41M6eJ7Fzp4/Z+gcsnwKe9/x++ga1/Qzwy8APAvcDfwh8EHhECLEhlmM9IqVckVL+nZTy16WUPyilPAjkgFcBPwv89Uba3QQtXURlVMKkUVoilim4E6+H/gsBLmZedwATBF70SJwdd76Xva/6EWbOf4vnv/w/KZemPUDE3m6DlLBAdCqw6KYusrfjyRwHD76f247+OKtr03zjif/BhctfoyWb7mNsVGWkgBvVaDcQyChlVHWR3xjXPK8rM08Qi6YpFHe5r5EN2rwiYG3xMuniFoSmB4JMb/nG2jIA0UzOuY7dJAxshIGJjtJLWxLqpQWiuf6e223WzAk3EvOvE+Ot22isIYSOrsWUMuFqHZM5cauK6q0KJ+a/yq7CXRQTY9w+9N2U6nM8P/dFM5aRt47N8DlxWtRZFdLpYdbWAj58JSQzA9RWF5CG2+1Zj6fQojG327OESCoDmkZzedmVLlJJiERoLZacNPMUBXohQ3Oh5Dq0CibiA2kqs2WfF49TVrnpVENatY1kIc7R9+4kloz48juxLEGqIbtuq2Ew/+h5+u/Z7cpTF0g096Fy/Bx6MUtkdADsS6O+dyW0Vko0Z+fa9iz/8AELwLsxV0FWfx++EQ1bYOHXpZRftH7/EpPp2Af8xI04xgb6VJFSPiql/DDwXzfSxiZo2YhYD5NpXCdplJaIZgvrb8c7KXWY0ILyOgIYCAQvhS0HOfLWXyaWzPHsF/8HU2cecYLStYGIe1Luxc7F5V2kh7AumrldKG7nzjt+mt273srFK4/w6JO/wezCi0gkXvDSjXUJBS9eAOP9BZQPM8ZtNCtMXnmYbVtehyZ0vxcTdnvutNXFS6SLAQGwQq5no2y6tTqs3XWKqq7pNWKuO1x9cLn6yoJPNdRJbNASVUFLiCqp0SwTjaQIdUAIY0aUtJMLf0dMT7IzfwcAqWie24ffzfTaKc4sfr239pQgc+nUEOW16XaflXFJZPqRRov62hKgjLcQRLN9NFYW3YyWphHJ5WkuLfkCzOmFHK0lt2sztJkWry2I2U1hMi0z/gV0g1Q2ncoE7bdCpggvQHGF8Lf2l569QrNcp3DnLpcqSO27vV957hyJgzvbquEAe5ba2QuIWIzY2Khik9UDsn8pRN6AnylnpZTHPb8bpRoKkk8Aa8ArXsJjvKSyCVq6SQidbotRKSObdaKZgitOw7oOEQhIgo08ewYwHcBLNJHlltf+KNuPvYuLz36Gk1//CI2630i3o1u0B7iEsS5BTI0JDnTGx+/iFXf+EoP9+3nuxT/nqRc+wmpl1g2QglRGmhYIXjoCmCCVkrLtAiweEHbh6sNEIknGRu9Q6gaMrX0tNFOTsbp0mXRfh6idnmvZWFtGT6T96xRdp6zfNoTAe91up7Eyb4KWLs+GLc16GaHpaJHu0aUbjTLRaDKgT72dxHx5kiurL3Co/01oUjdZFEOSj49wdPBtnF36JpdLz7vb86qgPIHnMslh1sozeG0fhZTEU0VEgNuzGaulaIIW5zjmL5LL01xZ8bQl0PNZWssrbRxl5emFDM3lNcdI1+mqdeMlxwqWTUtbWgqICJIg0OFNc+ercVlUt2gtsA7AzMPnKBydIJJNKGXwuzq3JOXj50laXkNh9izVs+eJb99mMpdW/k0L4/8PWwR+J/9/MLIJWnqRDl+sDSuw1IaYliDxToBhX5zC83PV6QJeBAhNMLTnHg6++eeprs7x7Bd/nZX5Cx4Gxd5ug5TQdYtUUBFi6+LU09rgJZJIsWfP27nr9p9DCMG3nvyfnDz3WRrNioud6Qhe9I0BGFfZEMBSbZS4NPUou7a9EU2LeBgePMHy2mNdXZun1aiS6dviApRB19O+Vs3yClGbZRH+/J6kl5e4p8x6XvxSSpNpyfYHZAbXadbKRGLpcPZEkUajTDSS7lwoJOpty2hwfP7LTGSPUIyN+eoMpXaxv+/1HJ/9InPlC34VUZD9DJBODdJq1alXl9weRIAQOnHH7RnXGESzRTPAnIdViuTytJaXzPoS5wLr+RytJZMxcQWYK2bAkDRX2ovkuqLijucpX13BaBq+PPDbtagxW4JEVQuFSZhqyInTYsDs18/SZ6mGvKDIdnUGqF2axVhZI3lwZxd7lgvEd253598kuZnB5a5T3gukgJfbDTpM1j0Sm6BlA6LSuo3lRUQkhh7v8KK9zhu0F+PS9RjmquAlVRjh4Jt/nvzwLRz/yoeZfP4Bx0jXqy5ysS56O70n1kX3gxd1O5Ud5uiRH+HwwX/E/OIpHnn8v3HmwheoN9a6g5cQlVCQPYsPqASoi+w+tzB44cwnSCcHGBo6EsiymPvCDRwFlBYuEImliKf9k3sgOyOgXloimsmH3QYvrXS7R+25vVbBaNSJ2SC9B7VTs1EmEkuGMjiqNJoVopGkH0TQBgquNCWU/6XSczSNGrfk7wlu3JBsyx1jW+5Wnpn5DIZsWX0O6ZRljJtMFBFCZ21tOvBcE5kBqqU5vMxTLFukrjItlkRyedOmxXNYPWcyLV7R86aRbnPRDWjABAmpMTNWS3lmzc2Q4N4OUhH1su9lVsIZmXa58sVFajMl+u92e1z51VtQPXGByFAR3Yr+61wO5V82GtQvXyGxfbv7A/JmTf43Tj20IRFCvFUI8V7gnVbSASHEe61fSgixTQjxiBDi56yy9wsh/hPwEeA48HvX1wNff3JCiHevs9pJ4P9a77E2XZ57kNCHQ0Jtfpp435D5FRlQrteoo1IoZUXn8kHAxfVCV7Ole4IUnnQhQY/G2Hn391IY38/5xz7G0tUT7Lrr/WQK407XhVNNcWm2g9FZ5y4smxSk1X0hrOBZ1lep1z1arQegafQPHaCv/xamrz3D5KW/49LUo4wN387W8XtIxovtOo6rs92eDShE+62nEz4h2WU92w5DBJy58HlWVq9w59GfMilpTRl7LwDEZpHM7eWZ0+SH9iA0rQ3WPOIFLrXlWeKFwfD+3gjZyMtSqdOsml/7eqJ3kN5q1tH1Hty4DXNV7Iged6WFH0cqm5KLK88wkT1CVEv4yyjXelf+LiZXnmSxcpm+zPZ2OSW4nJBtd3xN6KRTg6ytztA3uM8y5jXzhIR4up9aad7Ztw8Zy/bRKC06aU6AuVye8oWzTn/sdD2XpX7pstV2+xhaOgGaoLFc8QWYA4hbLtKV2TVy4705hbTQ0AlmZux8VVRmxUmTfsbGsWc5OU20kCI6XLA0buH2LLVzU8R32msN2QXc/alfngLDIDYxYeWvh358CeR6gcf1g63fArYp+++zfgA7gGVgGvglYBjztpkEfgP4j1JKvzva9clu4BNCiKiU9tdAV9kL/GfWaZC7CVrWK56btbYwTbxvOLzsRqWNEnrrlgfIOCAmAMCo8VxUnNQ3cZjswA4uPP7XPP+l32B07+vYcuA+dD3qKueN6QIERtJ12lfBi25tdwAvQo8wMn47I6PHmJl+nsnLX+Py499keOAQ27a8hmx61KljtmfBoqA4LyqI8YoyZs470GJ0rk4/weWpb3Ls0A+TTPW3x9hhnfCsXdQeUwPJ4vRJth5+m+d4+MGLsl9bmiO7/YD7ffwyvpt7oawNC7RE4gF2J6ooX5SGutJ1p/JAy6ib6w6Flgvu5Hz1IpXmEhPpw8Hl7Pg9hiSqJygkxpkpn6M/tc1SeQahSiv2ioRUatDnQSQMkLppjLsye8YFdISEaKZAq7KG0aiDcv56JkdrZcX3LtFzGYyVVdd4IM2ouHou5VIPmd2zjhWLEs0nqM625yE7RktQZNxu0k19BHSM0wJQOjlN9pbh9sec0mcXISUFtfNXSd9zVEl0v5yEFNQvXibS34+eSimu73ADJv9/kCKl3N5Dsfe81P3wiAR+WAjRK2jZtZGDbIKWLuLzpvBs1xamye20X5TBZTulde9AD2UC2lVBjBfAOADEBi8KmIkmM+x+1Q+yePl5LjzxCeYvP8vO27+HwtAep24n1sVOR7jZH7OexWb0CF7QdIZGjzI0fJjFhbNMXnqIbz39YYqFXWwbfw19+Z0IIVAD1Dnnp9o9iGCDPdd71rFNESyuXODFc3/LLbveTrG4q612svvoUw8p7QgoLUzSrJUpjO0PVAX5wIsA2WpRX5m/MUyLepG86d6ueNPCmEJLWlXbqDYWWscrrVYdvRNokWrZGnrCo1Lr4Clky6WVZxhK7SYR6cA0KIEHh1I7ubTyLPv6X08bbVp0iOFB9kAmOWSG81cYE7vvicwA1VV7tWfdOZ+oFaulUVoilhhy2JZINk9rbRXZakGkzWho2QytFb8XkJQQyaZoLbdBi3dEzFgtJmgxEGgdLoodzl9lW2zxMSwB0XSNkJeSatuycnKawu3b3PVc4MUELEa9Qf3yDH3bx0wQFmKEW7t4mdjEuFP/ZhvgXq9dys3u/0sov/tSH2ATtPQiYWDEkNQWZojfMRQatKurKKogl4poPRIGbJx2PQAmgGVx7WuCvq2HyQ3v5tIzn+HE3/0ug9tvZ+vRdxCLpd2siwI0pG42EgZebNY7kHkB08jR0yYAmkZxYA99/bsprVzl4qWHePr4R0gm+hgbvo3R4duIRzNt9gUcBsYzFKEihUBKycz885w8+7eMDd/O+NjdDmDxgRWLZXHZ/Fjv94Wp42T6txJL5tQPZr9aT9mtry6ANIgXBwPzX1YJoejBNKrVEynfF3QnMZp1tDD1kMeottmqu9VDTrnOx1ioXmZ/373mTjdPI0MymNjByYWvsVZfIJ0ccAEa1zE18/5Np4aZvPKQ5UHkfoCSmX5kq0ljbYVIvujkRZM50DQay4vEBoecZiPZHEhJq1RCj+cdxkDPZpC1Oka1jp6OuE5Dz6dprligRAqfiigxkKYyu+YAEvfpqpFxNTQllGwQcLGP0R4Gv9eQWsZn+NuUrJ6ZYcv3vcJngAu41ES1yRloGcS2K4bT6kNj7dcvXSZz660uw+WbzrLc7OP//ZIXgDtfjgNtgpaNiHWzNlaXMBo1Ev0jTtZ63Z1fUvGohqA9cfYCXiLxJDvufC8D22/n/GN/xTOf+1W2Hnk7Q9tuRwjNDV5UlVEX8OIcI8jmBXzgxa4rEWTy4xzMvZ9d1fu5du1Jrlx7nHOTX6a/7xZGho4xULwFXYu2z7WHyyExWFg6w/lLX2Vl9QoTY69k5/b7fIBF9RjysSyOaggWrr7A0I472+nKdfAyL/Z2bWkWoUduniGuR8LAc6tqgpb1iLkIZG9LE7RaPdi/eNyV6801GkaVTKQvvBy0VYVCkI4WSUUKzJbPkon3I3Vhf/47di3tNgTp5IDjQRTTi869aro994EQVEtzZHNFB4QLTSOaKdAoLbq6YQcPbJVWLONT82B2VFxjZRU9XXDVMdVDFWvCb5+XIQW6gMRAxqUeAlOF44Tsl+a9G8TAdPISChM/gGnvr12Yx6i3yOxxq82DjHBr568SGSygZVJIw81g2f+y0aAxNU3s3RNKY+bfzcL1m+IWKWUVc3HEl1w2QUs3CWNQJNTmriF0nVguwP1zo4frgW1Zjw2ab80isNRBHvAi2+2q4EUA2aEdHHrLL3H1xINcePITTJ38KhOH7qdv7JClnsECFusAL/YxoQ1eBOakoYAXV7s2eBGCeLLAth1vYNu217G4cJ6pa49z4tRfY8gm6dQw2fQo2cyY+UsNOxOhIVsYrYa1MF+VmfnjXJ1+glp9hcGBg9y993tIpQbMDgcAFq93lItlEbAyf57q6hx9E4f9tikBYMWWyvxV4n3DDhi84XaGNwJLS8wVzaMBTEgHMYwm0WjA2lwBAN8w6mja+la5XmssAZCKFDq2rbIpQsJgagcz5XPsKN4VyLQ4NiqGJJnsszyIZoili658TYsQS+apl+aBPa760UyBxsqSaxLW4glELE6r5PYU0jKmaqtVWiM6UgSkw0ro2SStktumRZVYX4qly4uh+V4JYmT8ZbqDmSAj3PLlJSLZOPGBDE0DnxEutNmWxtU5olsscBPC8DWmZ00j3LFRbPXczZZN9dDNk03Q0qMEeQFV56aIF4dNzxJJbxNDL1/+N3DC8rblUtWr4MWhYhTgpBAVWiTClsNvZnj3K7nywpc5/eifksqPMnH4fgpDt/QEXgC/wa4KmKRp92KDF5fdi92uh31B0ykO7KavfxetVp3lpYuUVq9SWr3KpavfoFKdBwS6HsMwGqbdgSLJRB/jo3cxOnxbe0E/j5eQClh8cVlo/0shuHr67yiOHSCRHXTAR6hhraJuqsxcJjU04S+zUVGvcy9ley1qNBFW8Lswey9fHWkgRG9f84Y0zKjDwQ25du2VnavNElEtQUSLdlcN2e0IwVByJxdXnqbeLBONpe0O4Ni1aPYxBRo6qWQ/5bVZ+uTetprIOlw83Udt1QrZL3HYlmgmT3N12dcFPZOhtaoY3UoQsShEdIxVv8GtlkrQmHaDEltNJKUgmo3TKNW6n3sP0skAF/xxX7zlawtlYn0ZfIs7WqICmObcMpGBQqBKyCkzO49IJNBSaRewuaksS6/v+071N2VDsglaNiCOEe7ctbZqyHsT2kj85bg5uz29Kptuz8VdwIuXoLH3o8ks22//Lkb3vpYrz3+RFx/6fbIDOxjf/0YKQ3v84MVjn+LyNvICELt/Ejf7ItqTQCf2RRNxigN7KA7scdpr1quUVqdoNstoWgxdj6JpUec/Ec+bE6o3NL8CRFTAYrMsNnOisiyV1VkWp05w4N5/3G5DaSfMcBegPHuJoTvfHHz9BG6QdBNFtlrtiKQ9V5KIHlUQ0mj1DHBsqbZKJHTF48gVJM4CqZrWzrOucTExjq7FmCtfYDR20M+2WMDEvvdSyUHK5Vkl3/wTEhI2aPE879F0nuritTaQsd4JejpDq7Tavq/BDOWfTrVBi9KWlkpgrFXbpyUFuoIUo9kEdQW0bMRrKEi8Rrfe2C9BUltYI9bnd4kP8hxqzi2T2jnhK2uLkILG7BzRgf512VG95LIJWm6abIKWHiQoGq6QUJ2forDnWGh5R16KG3Q9LyRvWRsMBGR73ZbDwEs808fOV7yf0f33cuX5L/DiQ79PMjvA8O5XMbTtDvRIzG3z4rVP6UV11Il9ASc6aTD4MdP0eJJCfGdHWyP3GkJKmsKEqIBFVQup4OXqmYdIF7eQHdzhZliC1EJKWqO8QmN1idTwhI8ZC/Q8Wq/cwPtPGi2Evj7QIqXhU710KivCmJYQqTZLwV5DhuHe1hQwJCUaGgPJ7cyUzzKWO2DatfjawAG06dQASysXXeNpuz3H030sTZ800xRwEk3nWb100tdsRGVaFNHSaYw1vxpISyVolWtW1/39jGTiNFf9TEuQJ5HXGPdGiApg6gtrRIud7Z7sc2jOLxEZyFuJwvNv/jVn54kMDrTzAljvTfnOkU3Q0qt4HhRptMzAcq8YdYOUl/pB6vDu76ZWCrdvUfKd90Vv4CWZH2L3q36AidUlZs58ncvPf55Lz32OoR13Mrz7VSTTfQr48LftUx31yr6E2b4I5YXnBTFdJChwnFsd5AcsNnPUqK8xO/k4O+/8XpNt8rx/3ayL+788ewmhR0j0tQ26vTYwf19EtpoIbX2vjUD1UMhzYsgWWi9MiwJCq00P0xImNnBRXZ+TO3lh4UEM2UJIQZgxrpCSVHKQK9ceBxRgYp2LrR5SY7WAqR5qrAZEuU1naa0pKzdL897W0klaq2UU7G6VT9Baq/oMcW2JZBM0yw2MpoER7W6vAr3ZtYC6jlFvN2R9oUxiwm0U7XV3BjDqDVrLa0T6C+Hh+4HG7JwrEi4oj8bNAi4S/8fpOutvysZkE7RsUOpL88hWk0T/qJPW6Wv+ug2vQt4X67F/6W7f4k/vnXkpMHHsbYwfvI+5i08xffIhpk49RH5kD4Pbbqdv7JAZq8MBE+HsC7gBTBD7gkoV2+3ZJxYGYjpJEBuiqoPsdOWnrsN09ezDROMZ+ieOKMa67fwwbyPbniU5MIbQdccOppPccCPddYg0jI2ph3pU+XRlWgLWHao2S+SSQwSqhXz13YzLYHI7LaPujo6riApC0okBGo01mvUyur0+knXIRLqPRrWE0WyYgeSsSS2aztOqriEbDdCjDtjR0xnql+accnbPtXTaZ9MCoKXiLvVQezhM8BzNmsbRtVKdSN/6DKV7kfUY5dYX1sgd2eJL90pz3lrVvD8f3qiE5tw8kdtvX0dvXwbZVA/dNNkELV0kkEWRUF+as1xUCy9DJ4KTQyevbpOazRb5tSJq9obAi4hFGdp1F4M776Q0c565849x/slPcO6Jj9M3foiBbbdTGNptffHSFcAEsi+dAIxXhQQOiOlJVGYFXOyKj2Gx9tdWprj64lfYeef7EJoezLIE7Nv/pSunSY3tdOf1KC83gPGudNxzvfW8pXtUJdnSMKrEdEsd0cVryJUGREWcQnyMufIFE7RY6w15g8vZHkQA1coC6UTKXKjTkniyAEC9vEws3o61E0laHkHlVfRE0UnXUymMSgA4SSYwqm41j5SgJWLIRstc6TkA0+lx81Vu1HoNRvrSidFoocWs/nSI0dKyQJhIdY6u3CqtOu7gm143m7IJWnqRACqwvjxPNNcXuubQDZOA93fgRLWe93wAQglmWfxVfODFAQ7tMZIAQpAb3klueCfbG+9h8epx5i48wcmHfp9IPE3f+CH6J46SG9jREcCo6KNXAOOokMABMc65hYjbw8cLXAgFLIZscvrxv6Awto+B7bcHsizqAHoBTbNWpnztAiN3v/WmMii9yjrxhFVJA4/XVtj9KhDBwCNMpKRp1ImIEDdpuy0VuHjYlv7kBDPl8whDuu1abHsWyyA3GkkS0RNUqouk2dKOxyIl0YQ5qTYqJWJFP2hpVtbQaYMWLZHEqFT85x+PYSwvW11uR5wWNgioNyHmf22LiIlkjObNBS1SCgf4d1MnyUYTABHVrbp2RvtfNprQbKIlk6501//Nkpt9/O9Q2QQtG5T6yiKxXF9o/rq+COwJ15sWIL0aZvYyAXo/JvF0I5B9cdpvsxuh7It1XiIWpX/bMfq3HaNRWWXh8rMsXHyWF/7ufxGNp+kbP0zfxBHyAztDAUwn9VEggLE7pMTl6GVMwtU4fsAikUw+/wD18hL7XvcTVpRcO79d3wVkXG1C6dJJtGic9NgOd0eUOoGeQ93O5SUDQEE3a5caQuudoREC2S38rUeaRp2IpgSks1VDYesPeaQ/sZUzS49Sb1WI6ml/HQXFJxJFqpXFdneVWC2RWIpGZdlKtxiSaAKERqu85rKD0RNJjKoHtEjQEnGa036DWi1mBUysNwh6bWvWcgBG48Ya2DrtCwND9qYWFOAsz9FJZKNpXg9dD72ljKrJxmgJT5yfmwxcNuO03DzZBC3rFPtmaywvtEGL9wbcyAOlzgUbBCzr/VLfmI2L//CO4aEFHlRbQS+AiaQyDO+5h+E999ColFi4/BwLF5/lxN/9DpFYir7xQ/SNHyI/tBtNi7QZF6+hnovWwYyroeyrEX9dQMZ7Et6TUbZdsVq0dp4NWC4e/xzXzn6dva/+EaLJbABYES7AEQRCVi6+SHZir9ueJew6/n1gYqzlDtZXRfji44SWZX3tG7KJQYuI1qMdRwBwycdH0EWUhcolhqN7sY1x2wexyCIgkShQrdorN1s3p1U0mszRKJd8bsyRZJpmpe0pJCRo8SRGrWape9rqTBGPY9TquB4igKgJWox6Uzn3djh/m61YD9PSixEugC6kE123J2NcTQQ/Yx6RzRYiolv3R3AZo2wCOy3ZZYHOTfmOkU3QskGpryyQGvbHF7guBN3hfbBuwLKeCc6jIvJW75V9MdMsZsOrPlLKtQFM1gVgFq+8wMLl5zj5yB+i6VGKo/vp23KYwvDejRnx2p10wJenI0FD4VXneMCK2aRk8vgDTJ1+iL2v/hEKo/tcbIq0y3rAivfYEoPS5AlG73lnZ7Di6l/3Mj5ZPznSoS3hZzC6VtF6ryPW19mm0QAgInpbJsARRUWkaTp9iS3MlycZzu1td8XjCQSQjBcpV+cDm4wlcw7TooqeTNOquEPsm+oOiVGrocXaLIKWiCFrdV8bwmFamr48UJiWZndwuB53Zw0ZGo8lSISQlspcmosydrhhZb3pqL3CxKiEMC03W67XJGCTadmwbIKWbhJyczVKS84qri95FzoAkhsSx8Nbx8NMdAMwwcBE+doKYGDa4AMHwAztvpuh3XfTrFdYunKChcvPceabfw5AfngPxbGDFEf3E0tkuwMYT2ddQKaLuBwlFLCCgEajwvmnP8H8lefY+5oPkh/d6wMseLfBB1ykgNXLZ2hVy2S37/P3oQcQs2FD7OsQG7atr5KGlAEMQABAMZmW3ifVpmFO8Po6Q/+7xJD0JbdyufScP08BW0JKEvECC8tnlXw7D6KJHPVKCa9EEn7QosdN5sCoVNCy7QnZZFoU9ZB1kTXVpiVAhG7etPIlUg/ZoiFphdxgDhOjCZNB6iatlqka6iBGtQpCIGKxv1cT/aZ66ObJJmhZjygvKGk0EZHreFH2esjrASwbmby8di7XAWDcxrlCSfOwMCqAwXyh9++8jYEdt9Fq1lmeOsXSleNcfO6znHv8Y2T6JyiOHqAwspd0Ycz6klc74D4PF5DxdlwV19h6GBcBy9OnOfP4R9EiMQ7e+9OkB7a6wIkawyUIxKjqI4nB1KOfobjvDqLpnM+At90Pf1rH6/oSAhYANB0Z4E4sRfiLWNMjGEZvagtNi2AYwRPzukRdnNPaFg775lcR5aIDlBuLZpyYoOi9liooFk3RaJQD76FINEm1suB8hQvLFkuLxjEabvZEWOoe2Wy403UdglQ8dnjbEFsR24ZEBAXIW6fY4MO0Y+nNVV1lZKL5JI3litNW2JUX8Siy1gjJtcrYcXWk98V0k2WTablpsglaNipSIl7ih6hnwNIDWOmmVggMPBfUp5DDdE1XAcw6WBgtGqO49RB9E4eQhsHq/EUWrxxn7tJTXHr+c+ixJPmh3eSH9pAf3kMi3W9eFweweBiWbu8+zxg3G1UWrj7P3MUnWZ4+w8ieVzFx5G1o0VgoYPEyLS6PIWt/8eSTVBen2faOH+1Z5XNd3kV+UmNjzWgaskcAYoumRcz4JT2VjdJaB2ix479s1BXbllS0iERSaSyT1vpNcGAvOaGoiSKRFM1GBSklQlorPVtRcfVonNaKP5aKFomacVpU5s9iGGTTc666FsxSKKrJIJEW0BGR9a/YvF7RhbSGJ1h1FCumqC+0mSUTuJjlhGIgpyUTyFod2WqBCJ6K2uCuaca/2ZTveNkELRsVie9rbV3VO3yZ2vku6QWweOqsZ5ILKuvzLvLshwKVMLYlNF241DuusioLo2lkhraTGdrO1mNvp15eZmX6DMvXTnPlxJc5/+RfE0vmSRfHSRXGyRTGSBe3EEvm267pPYyJYTRZmj7J3ORTLEwdR9Oi9E8c4eAbf5bM4DYXEAkCLGHqInvfaNa59s3PMnjs9cQyhQA3aU9d10VRxtIrL8OHqFCYlm73sFNHj2DUQ1Yo1oSLPdC1KIbRG8ABnA+HXjyOpJRttsUjCT2DJiKUawuk4/12BbyDGo0kTeNfo4GG2/hXj8QxGn7PHxGNYTQVpkXisLRe0CI03VSbeNtw3LWDB9y2ZdE8oMUbwt9JVy6croxdq8c1orxtqd2K96dZPjHdvV7KVIsZlRpaKgy0mOmy8fcMtGwyLTdNNkHLBuV6v+w6tn2dgOWGTGjS306nJrzODhsFMaEsjNUnFcRE03n6d95O/87bwZBUS7OUZs6ztniF5elTTJ38KkarQSSWIpEdIBJLE42nicTTRGJpIrEURrNGo1qiXl2hUS3RqJaorS1iGC2KYwfY84ofID+2D02PuAFDCFgJBB0ekDPz7NeQ0mDw9nt7A5Yi5Jp6yrwcsmGmpdUbe2KqktYBWm4Q0yKEIB0tstZYYLBDuWjEnGibjQqxeNx1z+uROK0A0KJFojSrHkNca6XsQKYlKJpvlw8kaYEWPar17BUEbsBi77fQfJ5CugeY2C7QQR5Fsb409UXP+QqcI9mnoqdN0CcrVUj5F1gEBbS0er8nXg4J+p5Yb/1N2Zhsgpb1iDXJms+oXy8eVj5MXC7FrBNs9AJYOnQvlFnpUNd7Ki8ZiFHGpaMqSR0/XZDID5HIDzFo1zUMqqVZ1hauUFtbpFlfo1lbo7IyTaO2RrNWRo/EiCazRBM50sUtRJJZ4qkCueE9RGJJP7PhY1l6BCzWf6O8wuyTX2b01e9Giyc6ll0Xy9KLhN2PXe5TV1FNh/WCFj2K7KTyUc6nq3pIE9BSjGPXwbQEimLfko4WWasvuvOVBRMxJJGIaUDbaFaIUXAV1aNxWs0A0BKNYay62xWaBpoWwLRogUyLM0YKclDBiQ1aNMsgdz3ApZNowgCpmQsvdonVognTYyjRl6I+v9bVe0hLmaDFKFfR+2kHtlaqOIxU4wbYOW3Kt4VsgpZuEvLMCV33GdGBRZljzanSk25PtNJfp5djq5NlUJlOgKWXia5TmW6B6AIO6W/bA4q6q40IBzFOmoeJccoBmkaiMEyiMOw+jy6i2vL6xtcBDqID80IgCGk1qkx+4Y+J5QcoHrw7tKxLPCzLzVILOYcKMcQNrwBCj2J0+1K2v761KEbL7/IbJpqww8VvYFLzRMaN6xnKzaWOVSK6OdG2mh7bFQlaxKMGskToET+jggVQvGOpaT0FZvOK0TCBjhYLVu/oQqIhXe7OXpZFTQ9iWwBXmnu7DWjigxmapSqtSh0RVzyjFGt7IaSpHtI0jFIZIfzu5QgQcVMlZAeZ+3slmyqemyIvvdXWt6nEC4NUl2bNnZdi0tgoYBH+dB+YWe9PaUf9ectJzVNG85TROpTX1pGutdOlJsyfEO1tjcAfIji9YzlXnfZxEN48ujIsZz75YRprK2x/x4+ZE1aIrMtjKOA+cV2jGyxC713V4wCRSJRWq9H9OdEgEknQbPnZCrM94duO6DF0EaHeqoSXDT2e+xpI2ULrtFij2nwgFRkyi4XYv8mgCL2G4bgvu8paTIodrt8rzbIJliLp7nYf18vCeO1kvO2lt5lBN8sXzXg2Qsl33dKaRmQgT2NmgcACgJZOIWJRWktLvT0PL5PYLs/X89uUjckm07JOsRmTeN8wtYXuxmaAn13x7geV9xwzrEwYu9KLmqhb3JKOwdgCbF6CivpOU3geWGUsvIyL2QflOD7WJSxd+NLN/fW9KVzj4x1vEbDtASt2+eriNc59+veIpnPs/K6fRE9lOgIcL1gMVQuFXW/c6WHjvW4RFmvQC2hRjqPpCgPRZbKJRJLUa/5YJ2gQ5jsb01PUjBBDX7VLQfe7ktaUDXSt86Tftp0JOZGgY0gj+NgBoEVKwwemgLZ3UNQNWmzAYFTqICCSiGIPvG7ldQsmp4IOmzmx2RanvtRAtLVTYR5EmpDEsnHigxnWzs+R3DNu9luhau1tISTR4T6a0wHB+qwHXGiCSF+R5rwJbKSgHd7HC+xfTtk0xL1psglaehGBT90T7x9m+dQzrjLdbkTXBKJOuHjSPHV8+b0CFh/4Wd8T3qm8CDnZriClWxnPuHRUHdnlugCZdt7633BBY+wDEgHgxf4vXT3L5AN/QHp8FxNv+QGfq3QgYCHkOKr0AFjU/LAvu055QSL0iN8Qtwso1yIxt3qoQ38jkQTl8mzbq0izOtkBcMb0NPXWWmh+mMeQV1pGg3gk2CC0LTYS87cZ5p0kw+zfDMPPuLU8oMW6OG2X5nCmJZKKIbTeUKmtGvKyJF6VkH+/rQZyb0s02QYw6R0DlCfnXHYtLsbFAi7Rkb4202IDG48uWu/ro7nosTXalO9Y+bYALUKILPCvgGPArcAA8G+llP/metv2TVrW82QyLTPWd4blwSBEm52w6gpwvUMCv3x7PbbyHzqZBrTrnayNZoPqwjUqc5epLcyYxXUNoemmoaWmoUfjRNN5otkC0UyRSCrjeGrQAQAEgZmegEzAxBcEZLz2K92ADHjATGinPMfy9k3JC1LFuYCHlbd45mkufenP6Dv0SkZf+10IXfPVDQQsnv0wwLIe9c+6wEkASLdF65VpUUSPxGh5bT1C+h6NJGna9iJhSwZ40uN6ipqhqIeCbEV6kKask9KK7kQPpnAC1XkznAc96AbygxbDAT++AwSrDq0xD4vD0lyrE0n5g11uRBVkAxWVbQnKD9sHyGzvp3R2zsmXVqwWb9nocB/VU5eUe1/9CjH/In0FmouL7fcpoSP98skm03LT5NsCtAD9wIeAZ4BPAj/+kh3Jmlzj/cPIZp1GaYlYts81wToPVAc1yIZitAQ9pR1BjLlhtJosnXyCtalzVGYvU12cBsMgmi2S6BsGKzaENOyfgdGo0lhdplUzJwOh6UQyeWLZPuKFQdcvlutvB8sK6qTABeac/nrHwDMu6wYy1n5PgKXTG8+T1xU8erabjTpzz3yV6ce+wOg976T/ttchNGXxxCCgE5AeeuwO6T4Jus86fYyreQHlhK6vG7S41ENq14S/66ZNS29Gl1ITiJYkbjMtasRb6Ax6AqRlNNyrRXtFXQiwVxsVqz/Cq2q0QZVXPdRqQYBNCz0yLZ1EE4YLxKwH0Hg9h+xw/l5jXM1Ky+zo59qXX/S0YTpjtdVDmEzLtQX/2Fn3nhSSSH8f5cnLVrpV7iarh67XLmXTpmXj8u0CWiaBopRSCiEGuMGgJYgxiRb60RMpVi+doe/AXb1NBB7gAgGTtLdewHbHL3+njMBoNVk88S1mnvgSRqNGZus+CntvJzm0heTAOJGknwr39qFVr9EsLdFYXaJRWqS2PE9taYbyixeoLc2aE5jQiOX7iReGiBcHiReGSBSHiBeH0BNpcxXXjYIZzzgFMS1qfqB6yXUAenvRdWM3AvYblVXmnnuY+eceRmg6W+//QfK3HGuXC2BVfOl4tsOOH9THsPNYB1ju9jIVerRzdNuA50CPxJCyhWE00XFPul7gEokkzTD5oe37D5CIZFmuXevc8S4ikaw1FpiIHvMcyy1Ny7NJ06xXp1LEMJrtdEWMZtNkMNXj2cyJZ+0d2WyZaZ4LYVguv3bcElWEkDRWa0QzcVNN4/ESArfxrNdrKMimRWVbEJoZ1h8Jwm/Xopa3Jbt7kPr8Go35EnpfztVXpHCGNrZlEFmr05pfQu/rM/GIZ9ijQwM0pmeQRpvV3pTvXPm2AC3ypYz0ph5HtL/chaaR232Y5TNPm6AFLJZFURHZHwQqYPG8c0Mp/kDmpEOaktcyWiy++BgzT3yJVq3C4K2vZ+Doa5xF2ux6vQyaHouj9w8T7x/25Ulp0Fhdpr44S21pltrCNNX5KZbPPEOjZOqgtViCeGGAWH6QeH7A2h4glusnksoGL2PvABG3qs3c8J+vj00JASZBbtth0pMNiTDBYW1pltmnv8rii48RzRQYvuftFA/cgRaJdWdX8O+vR/UXuA/rZ/lCQLe3vBaNIVtNDCnRehxMPWq6vbYaNfRoKvAYCIFAEotmaLaqJuvheT251K82iyIE2dggZ5cexZBGu0+2isjLtgglX5Gl2jUaRpX+1HazjGKzoqpC6w3TSDgez+GVVr1MJO4/P6NeRYsnXdfJqFvgJ+6OqitrNbSEO00IMKpW+UTMdBf2XMTGcpVY3l3PFj3ggtv1O9m0BKl9zHQ/6+I1xs3u6ENPx1g5foXia3KBHkRCSKIjfWjJOPWzl0n1F1HXKLP/Y9smkPU6jdkZ4kMjjjHuy/PWD5FN9dBNk28L0HK9IoQYAl8gzF3qjvPyVl7uuVuOMfnJ36VVKxOJKS8rFawQMFF4J2AC8jz7vQAWKQTLZ5/h6iN/S6tWZuDoaxm89XU+sNLxeOsQITRiuSKxXJHMtltc52M06tSWZqkvz1FbmqO+NMfa1bMsnPgmzbUVs34kSizXTyzXp/z3Ecua/06/A5mX3gCNWdZTrkcJGysDqC3NUrp4gtLkCVYvnSY5tIWJt3w/uV2HzaixIYxKoE0Lnm3P8QINq7udS9CYbFBdqYoWtQKCNetokeBJ0itt0FKFANBiixSCWDwLQKOxRiSSd9JFAMNiSzY+iCFblJtLZCLFcKDiFSEcgDJXOU8+PhJuiGu1Ua+vomkRdD3uXBd7TcFm3XoPuK67oFWvEk33u5ozaqYKzAtajFrdiU2iTvSyUoeIhh7TIMCItr5cIZZLuNoKC+HfTcLis4Db8La9qKLuBJazjXGFrpE/MErphSv0v3YfLWl6CznrkFovU00XxHaOUTt3mdRdh3HUP+B8jejFPFo2Q/3iJeJDIxs6p5dCNlU8N0c2QYspPw3868Ac70Sh6FIzE7vRYwmWzz5P34G7fCokVx21rZDJNey4vQAWA8m1b3yW2aceZPDWexm87V6X+qcXtcJ6J3VXdz0shhaLkRwaJzk0rhzA6mujRn1lkfryPPWVefN/eZ7VK6dprCw667dosQSxbJFotkgsWyCaLhDNFolmCsSyBSKpHFok2gGsyOs6L/sLW0pJs1yiMnuJ0sUXKU2eoL6yQCzXR2bbfnbc9SbS47ucr/NA9Y+6HZbndNyTFgRa8JRRq4eAk7adwDpfuEobWswK9tWoQyQe2L5XHNDiDcgWILFYBoBqY41ENB8MVuyouFZeQs8S0eKUmnNkon1twBJmkBtg6DpbvsBgeqe/rAJ4pBDU6yVisaxpo6QUkwKa9Qq6wrTY18aoV9FjbkBh1M17XCTcUZGlAlpc5at19IQ/3QYujZUqye0Ff/87iJdlcbs526BEglTSFRVRkF2LKvlD48w+ctZpz/Y5s8vbwCWxa5zqmSued631QhEghCC+bYLapUtk7rzTrOcsILkp32ny9w60CCFeD3ylx+K3SimfvgGH/TDwV560XcCnzE7h+yqVAkRED1cRmY6OwWxL+Eejb2IKtldxpzUbNS5+8U9Zu3qW7W//MXI7DvjLdmq7h36EynpYDGsMtFicxMAIiQH/V5OUkla1TGNlkfrKAvWVBcueZonyzCUapSWa5XYcDz2eJJLOEU3liKRzRFJZIvEUejyJHk+hJ8xtLRpHaG0PKaGb/0azgdGoYTRqtOrWf61iMUSz1JZmqC3OYjRqCD1CenwX/UdfQ3bHfmKFwbYaIYgxCWBWnLHaIFjpZZx99lKd7rd1ihaxQUsNktme6ugWI9MMWJfHKxE9jqZFqTdWgwsE6AWEEBTio8xXLjKavMVdzgtcbMCigJFac42V+jQHBt/UZl+EaKuFFIxTbZQcYGW20950mBaPtOpVc8kGS6QAWbeBuRuIeNVDdvNGtY4WAFpsaaxUfUwLuGO0aEKiYwSClfPfmOaz//oJ7v+Xt7L9teNO+SAwYrdrSN1n16Ia4xYPj3L+I9/AqNQgkbC8iITPGDe+a5zlLz5mRloWtj2PUEC2JLZ1C5XjJ11jeFOZjk310E2Tv3egBTgJ/ESPZS/eiANKKWeAGTXNtvaXngkjTEXUrK4SSWQCXXltBsY1mXSZfLp6jVj/1eVZLnz2D5CGwe73/bzpDRRS1tduQPvrlnXW7fqsCoGeSqOn0iSHtwQWMZpNmmvLNNZWaK6tOP/NtRWqC9do1Sq0qmXzv1Zel/uriETRYwnLsHiQ3O6jlnHxINHigMnsgA9QBBrohoEXOoCVTiDGk95Rgu43r03VBsCMFrPUQz0AELDuf11Di8RoNqsmENAkneKdxaKZYNCiBpizQInUBMKAkfQeTi48xP7i69FFxA1swqIPW6qhmfJ5olqSXDJc9WCPZb2+SiyWbdcH53o0amVS2aLvehn1Kno84bq+Rr2GiERMbyzlIpjqIb/rsqzVEAl/ui315SqxvAlaNCF9diw+w1wr3zbK/cbvnSQa1/n4L3yDO75/N6/86UPEku3pwTbIDVMRaVK47FoA8vtGEEJQOnGV7K07HXWX1xg3sWsMWanRvDZHZGQ40Bg3vm2C5S98BdlqIrSIi/G+GbLpPXTz5O8daJFSTgG/d7P7oYoKPHwqoq27iWYKzD3zMCN339+eaCy2xaHj7fp2eyE37Xq8RpbOP8elL/056bEdTNz3A0SSqdCyXSe+m/TwdxKfca0lIhohWugnWuj31fGJIS0mpW4GRTMM063bcvEWegQRj6NHE2ixmM/LI8yOpJMXUVj6eliVdRveghuAKIAkCGx770H7HnXwdIia07RpEY4rfNDxXG1aaZFokpbiFWTaqbRVPKok4jlqteV2gjfAnF1HYV1GMns5ufAwF1efYUf29na5Li7PUhpcWH6C8ewBMw6RaoSrucsioFyZI5Mba9uzKMClXlmikDrgnLvJupqqRT2lsDNAq1xGSwUY7ZYr6Lm0zwyntVZDT/mZFDDBQ32pQqyQCHRj7mbbMnt6mUtPzPHBj76B0myVz//7pzj14FXe9C9uY8c9JpBzxWWx1EK+bcWuRROSSDJCbv8Iy09Nkr3VVL05DIu1LYQkOpRH78tRffEC2dEh0xjXBiTWPRLfuR1aLaoXLpDctbu9jtHNem9tMi03TTb9x3oRz2TVfmEBus7AHfey8PRDNKurLruFoEX11P2gn+uYQRObMFUoU499nsnPfYTBW1/P9nf8uB+wBNX3pOPpU6d+3Yif75jr+Wkhv271dIGWSBDJ5ojmi0SL/cT6h4gPjZIY2UJ8cIRYroieSpoxMDztu9YlEvjXKrLSnD6KkLLea9ipXsi5SCSNlSXK505RnjxHbWGWlsp4eK9nh3vIVSdIQtKFpqEnUjQr4RFozeO5G4jEUjRqIa7MmnBd50SiSLW+bKV3mZXsNYi0OLsKd3N2+VvUW1WFBRH+n52uCabKp6g0V9hRuMsDUDzbmkBKyeraFJnMiHWO7XOV0qC2tkA86zG4rVcxGnWimbwrvVleRU+ryzmYAdiMtTJaxgIzTleluRJyJuF4DglsAABGvUlzrU6y6DHE7fI5b7MsT/3VecaP9jGyL8+e1wzzYx9/E7teM8LHf+ZhPvPPv0V5wc+q+Zmc4GP13bGNxScmHUBjn4+6LYQgeXAH1RfOtYEK6j9o6SSxbRNUXzzltH09Nnib8g9X/t4xLRsVIcRbgTRgK9oPCCHea21/VkrZfXGSwIbNPx/bItrbxUN3sfjcN7j4uT9hx7s+1I4cq7ahGkDaD1vQ16wiQV/bLaPFla/+FUtnnmbb2z5Ifseh4IkppL53+4bYtfQoL8nHxY3qY0g76xrDoHH3poeV9bRtNBpUL1+gevUS9dkZ6rPXqM9OY9RqPjsNLR5Hz+SIFor0ve7NpLbtdN9j3vvPOoZqcxV27j42RkIkmaFZXW0/Az1IJJ6iWe/tEUzECywtX/BnCGH1QbaNccFREW3NHWVy5SnOlR5jX+E1dGNaDGlwZulRtuaOte1UVHsW1a4FqDfXaDTKpDOjvjD+9WoJ2WoSz/S7gGmjvAyAns0rAAVaqyX0jJt9AUzQkk760ltrVfR0MNNSXzJZr3jRX08FF0H2LPVyk+Ofucib/6+jTloyG+G+//MYB962lQf+zZN8+p9+ne/9/XtBulVEXrsWMz6M265l4M6tnP/Db9BcWkXks6F2LcmDO1j48y+1g8wF2LUk9++l8twLFN/xNudlfNOAyybTctPk2wa0AL8FbFP232f9AHYAFzbSqMtoEtyGtdYDJaJRJt75I5z9019n+tHPMnLPO5Q5w4otETJxdDyuLdZ2s15l8nMfoTp/lV3f/TOkRra6y3aYSEPzA/I69mUD0sv53kjZcH+D6oWNWQ9j2YvKyP6XhkHt2hXWzp2icu40lclzyFaL2NAIsaER0nsPUHj1vcQHh4n2D4CUNFdLtEorNEsrNFdLVCfPc/kPfpP8nfcwcN/bTY8VBVxvyJYloGwkmaZZaduchIEbV51Ymma9MztjSyJRoDqz5EoLi9GighJNi3BL8dU8N/s5tuWOkdSy4UyNJphafZFac5Wdxbva7frK4YCX1bVrCKGTSlvREUT7V10zF/2LZ4qu6o3VFRAaEa96aG0VPeM3ZHYxLShsymqVaMEPSjQklQ6gpX26MnD7xAMX0aMa+9887is/fqSPd/7HO/jD73uQ+XMrFHe02SKv55A3dostuVuGiWTiLD11kb7XHwy1a0kd2sHs8irNq7NERhW7FuWSJA/cwvIDXzQBXzprZt0k45BNm5abJ982oEVKuf0la9vDsjjgRbTz4oUBJt76/Ux+6vdJDm8lv+tIR+DSkyjlamvLXPj07yJbLXa99+eJW/YcPbErPUy8gfk99i1QPJPYDZHrbadL/cB+9sJKdWFNAvMEtCpl1s68yOrJ45TPnMSolIkNDpPctYf8K15FYscu9ET4RBQpFokUi9i+Jvm77yF76x3MfOpjrJ08ztC73kdm934XcHGxK6KNZ4Jsr9TzVl+yejJNqxoMQMLstSLxFI1q70xLrbaCIVtoQnO7PXtXe3aAhmXbkr6FC8uPc3rx6xwZvL8dvtUWiyExkJxd+obJsuipNqNiq6QUexb72pXK10ilBtH0CIZ9XS1Stba2QDSZR0RiZp6V31hbJpLOIjStnS5M0BIdGvKpjY21Mno65RtEo1xFG3cDIltqi2W0qEYkHQP80XCDRMdASslTf3meI+/eSiQevDzA8L4Cw/sLPP+p87zmF46521AYFhvAOGyLZdeiRTSKt21l8fHz9L3+IKAwLNa2EJLYcIHIQIHqibNkxxS7FsC2a4ltn0AkE1ROniZz+22bbMV3qHzbgJaXTDwTkAuw0GZbpIDszgMM3f1mLn/hz4m9t5/UwLhST1ibNlXT2zGlEJSnL3Lhgf9NLNfP9rf9KJFU2spzlw/7snfldUoPOueNyk1qoyeAFFKma91u49mB6ZJImsuLlC+dp3rxAtVLF6hdu4oWi5Pas5eBt72b1K49RPJu24dO/fXdQxJSe/ay9ed+mYUvPsDVP/k9skduZ+j+d6On0k75MHCi9j00X1jqoXKIS3KIRONpqiuzLnZCVZdYMxgISCT7kBhU6yVSUWU8VGbFY8Brq4iEpnFL32t57NpfMZbZz0BSJV/b7VxaeYZaq8yO4p1Ix21duNgWqe4LWF2dIpMZVcq2x6u6Ok8i0+d7XzTWlkx7Fs81bK2uktixw5Ummw1kveEwLar5TWu14qiHhAfQNJfKxApJhBBoduA5ZWzCQMzMi4tMn1zmu371LnRPmZbUHBblyHdt45H/9SKv/tnD6BEww/q32/a6Pnul745tnP/DbyAw0IRGyzoHb7yW5KEdVJ4/R/ZNr7SACta4mWMtdJ3k3j1UTrxI5vbbfEzMyy6boOmmyCZo6Sb2y5XubAsSBl9xH7WFaS787e+x+30/TyxT8NgVKKxLB5FCII0Wc09/jWvffID87mNsufd9aNGola/0L2C/I/PiTffkdUx7GWRdzEyHsutmeDzlO45RB4ACII0WtemrVC6dp3LxAtWL52muLKMlkiS2bid98AgDb383iYltiEhkQ6xXWLYWjzPwju8ic/goM5/8KyZ/69fY+pO/SMRWR2xENaRsx7J9LM9cdvoYGItIbUNANJGjXl3p6bCJRAEhdMqVuTZoURgW5xmyV+DzRL/tT21le+52np79DK8c/QDpaBEpJbXWKqXGPKX6HGeXHuWW/tcQjabbYMUJDugGL1iB5BaXz7Fjx32Bz9Ta0lWSxVEnzTSoFtSX5ogVBnzn2FxeIlIouNJaKyYQ1PJqHBjz3FqlCtFcsu3YpBiz1hYrxIupgJD8nRmXU1++yujBIoPbw6MUa0Jy4K0TfOW/P8e5h6bYde+WdttS8y+aGGDX0n/rFk7+9zVqVxeIjg2E27Uc2cXc733aXDRSKGs7Oe9OSfLwARY//rem55+m3zTcIKT0rZu23vqbsjHZBC1dxGfTEvQiV9gWoWmMv+UDXPjr/8X5v/kddr3354jEkj7goko7cms7vTJ7mctf+Utqy3OMv+49FA/cjbAMEdsVlT4q+53UFR3VQxtlIG6k9HCs6wUjoW10GY9QAGi0qM9NU526TPXqZWpXL1O7dgXZaBDtHyCxdTvFe99Mcvt2ogNDCGUVXyk8GGId5ybdZIOvamLbDrb89C9y5Xf/J1Mf+2O2/OBPKqtxt8v7VERh9inW8WKFfurLc907qAKdZJ56pTfQogmddHKAtcoMA4XdZhsd3J0dNY4Gwvrc39v/WtYaCzx27eMkIzlKjTmaRg2BTibWx0TuKFtzt7bru7yK3P9SCMqVWer1VQr9u00QI5TnVUB58QqFrQd991VtaZb09r2uZ7PVapp2GYWii1ForZhBE/V81s/MrJTRc8Hgor5UIV4INtJ1j6t0AswBnHpwikNvD46FpAuDlqX7SuRi3PKmLRz/5Dn2vGHctn+2yqlGuP41iTQhSY7lifWnWXn2MgNjAy67FmHZtQghSR/ZxUylRv3sZeJ7tpljb42ZPXbJw/uZ/5O/pHr+PMndu28e07JpiHvTZBO0dJHmyhJyaMTNsgjlfWxvK2laJMrWd36Q8x/9/zj/id9m+BX3k926D9fy9K6JoZ1uNOpMP/55Zp/6O/I7D7H9HT9ONJOzylmFuoCVjmU95bqyC6q8xC+IG2lAe92gxJsvQBoGzeUlanPXqM9cozY7TX3G3JaNBnomS3xsC8ndeyi+7l7iE9uIZLO+9mVA22Givtu6DU+QvbMWjTLyfT/EpQ//OnNf+RyDb3p7l1ZwM4l2g0pHYvkBWrUKjVqFaCwZWMZXJ5nDaNZoNqpE9S5rFmmQSg2xWnbFe1QYFrB0DNZ2gJoIjaPDb+fUwiNEtBhb88fIxgZJRQvOSsxSdam2tl1eQ8pHwsLyORKJIslUn8s2RQpBvbZKvbJMqm/c6mc7v7Y0R1/fq13n0VxZAghgWlYQiThaPAYYzgUw6g2Map1Izm/fJISkUWoHlvMPpdmGd2XnxckV5s6V2PuGEVdZNUCcClyOfvc2/uJDD1GaqZAeTKGqiFzHU+xaHBWSBoUjW1h+7jID9x9z+t3GieaLNZJPEd85RuXZUxZoscCpDewQ6Jk08V07KD/3/M0FLZty02QTtHSR1eeeIr1nr2lMa7/MQ9gWVWUUSabZ9p6fZObhz3Dh079PvDDIwLHXUdx7O5oe9T1szWqZtavnmHrkUxjNBtve+sPkdx128tetDuoAYELzCc4Pkpfd1fAlZkvsfSklrbVVGgtz1Bdmqc/P0ZifNffnZ5H1OiISITowRGxomPT+Q/Td+ybiYxPo+ZwvknIoO9PjObr6HlRZ+Kt5wUu0r5/h9/0jpv7kf5OY2E5270GnXBDb4upPgFFuLG8agddX5okObOkKWABiKVPNU68sE80MmQasUgkwp2EyJ1bddGqQ+cXTzjGFh2HxeRM5HWxHyY3oCQ4MvEHpV7ucA1iCWBZVrBgyC0tnKRbdaxPZcXbWlq4ghEayMOKAFTCf6VZllVhx0AEyUkBzeRGEMO2XRPseaS2XLJbFPXjGqmnAHAlhWhorVVKD4SqeIDn9lSmKW9MM7DRBtQ1u7H/vqs0Ttw+QH8/wwt9c4M4fO2ClB7s+q2KrrApHxpn8i8dN1RCErkOUOrqbtWdOU3jvfWaBANfn1NGDrHz1YYrf/e51nfONlJvpPSSEyAL/CjgG3AoMAP9WSvlvAsreBvxX4BVAE3gQ+GUp5bmN9+DmyiZo6SKlF55l8B3vMSOBKpO/TZvbLyMXE2P+EcsV2fLWH2DkVe9g7pmHmHr4b7j2jc/Sf/geEsVhqvNTVOauUp27SmN1CYSg78DdjL7qnc4Kx9ejDlqXJ5EnLzD/pZaQ460XnPRii9JaW6U2N0N9YZbG/ByNhfbPqJnBtCK5PNH+QaL9A2SO3kq0f4DY8AjRYp8Zfj3o2nj70mOfVfH2P9BORGXqAuZulzcQkN57gOJr38j0X/8p8Z/6P4gV+53+edsPUgmpaXo8iZ5IU1+eIz24pStgAYgksiA0atVlUtnhrjr9dHqYi1cewUC2cYTKsNgAxk5XiQQHuEjPoOA3urVtWdSYLB7VkESytHyeW255l/W8twdWCsuepTCCiETbXkUC6suzAET7Bl3gpLm8iJ7LuUP4C1M9pOezVhek05VmyQIt+aRjwKrarzRWa0R3Fs2hEGYI/zAXZ1tOfWWKfW8YtYx3/fk262KzLUIIDn/3dp79+Hnu+OB+B9wFLZqo2rXYK0D3HRnn1P/7IPWZJfTBos+uRQjzozB1bDeLn/gaRmkNkc74XZ8FJI8eZPHjf0tj6iqIYK+nl1xurnqoH/gQ8AzwSeDHgwoJIfYBXwWeBr4XSAD/DnhICHFMSjl7Xb24SbIJWrqJlJSef4r8bXdbrsv2lx9+lkUBLOpXbCRXYPTV72Torjez+MK3mH/6azQrayQHxkgMjJHbcdDc7h9Fi5qLonU1oO0VsHQDKzcaqFxH/Z4Zn3UAFKNWozp1mdrMVeoz09RnzV9rbdX82s0ViPb3E+1rA5No3wDR/n5nMbvrAied+go9fXK56tk7wl81kHhQutD3xrdQvTTJ1Ef/kIkf+ye+dZTCVEIOYFFu7HhhkNqiW30TxswgQGgasWSOenmph/MVZDNjtFo1ypV5MvF+P8PidX12+mCfjGwDlKAyHsDiBSqqamh59TLNZpV8n8eexcpfXbhEqm+L+1kTUF2aIZLKmusOKWPUWFogWii6gAxAa2nFAS12MwCt5TXQhOU95AcjjZUqsWzcvxBiyL1VWa5z5dkF3viLBwLzg0QTkiPvnODh//k8V5+aYfz2YQx05zhhdi22pLf1EckmWHn+Cn33Fn12LfZ2Ys8WtESMyvGzpO8+4nd9RhAZ7CM6NkL5ueOkjh72Hes7QCaBopRSCiEGCAEtmAClBrxDSrkCIIR4AjgN/DLwz16Ozt5o2QQtXSR98DDL3/w62dvuMi33FeM7lW0Ryuzge/lbaXoszsCx19B/9NXWh6L/pRo2+a0nBsh1exKFyToByQ3xAuoEqjzbstWiNnWVytWLVK9cpHblEvXZacBUkcSGRkhs207uzruJDQ0THRiy7AeC21YnGqdMWN9CQaEMLBNYNkRcc4+QLjBh0ykqqLDjrql9FoDQNYa/9/u59Jv/nZkHPsHIu763nd8JrKjp1n9ycJzy7CXXeXgNeFFVOEAiM0Bl1W/A63V7FlKSSBRJxPMsrpwnMzxg2q0EqYjsRmy2xXvygQMqfPtBLIutGpqZO04+v414IuuzZ5FISrPnmLjtHS4VEEBl9iqJofF2mvWrz8+ZAQKd45sh/FuLy0THh3zday2vEsmnEZofFWpC0lipEQ2xafGKjsHVp+eIxDTGDxc7rkvkZVsyg0m2vWKYFz49yfjtw267FeFeSNEXr0UX5A+MUjpxlb57D1lD7bdr0SIaiQPbqb5wlvQrjuByfVa+CpNHDlJ57gVSx24OaLmZ6iEpu7seCSEiwDuAP7IBi1V3UgjxFeC72QQt356SOXyMa0/9PrUrF0ls2eZMEKFsi/KSD9o3N5WvhyDqX5FOKp71qIO6ehIFSUj+jfDe6aVML4axtekpyudPU7ajyNZrRIp9JMYnyN52B4nxrcTHx9HiicBz72pzcp3ApKMNTdi5eTrhZlpogxSlUDsOkJXqYV1svBHJZhn5vh/iyu9/mOS2neSP3OE+fhi74pHkyFaWzz7rhF0P9ThS62QHqa76Y7UEtS+EoJDfyeLyOSaG72y36TLClW62RXWBVhgXpVH3v8sQlzZ4EW02xZAtpmefZeu217pUQ7Y9S7k0Q7O2RnZkl3PuNqCpzl0hObbVd20bc7OkDx1yqz2A1uISySO3WH20uyppLa+h58NtVhqrNeLZWGCe6vZsMzGXn5pn7HARPaqhDr4aq8U2wPXKgbdv40v/6Unu/We3IRIxH7PSKV5L7sAIs4+c62jXYq9DtPKFx1zj4B3D5NEDrHzuy7SWS8EHeznk+lQ8tuwK+HidlVLOBBVeT7tAEng2IO9Z4D4hREJKWb3O47zssglauki0r4/k7ltY/ubXLdBif+nhfEE5IAbaIAH3x6ma4DD8KnfvkdAJuxtg6QROgiZqr3SadLuU7SodyndVDVnbzdIKq2depHz6BOXzZzDKa0T7B0nt3E3u9veT3LGrvaaLcr4+EKJcJ9/x1glObohnVpAo5YNsTFwAxmJgzNXFlXLq/G0lJ7fvoO8Nb2Huc58is/eQo75w3cfeG1i67/Xk0ATNcon62jLxdMHpWyBgsSbnRHaQldnz3c9ZABoUCzs5c+6Btl1LgBGui21RY7fY++qEoIIVe18BKkEsy9TMM7RadUbG7vCphqSAlblzxFIFYtl+FwiRSKqzVygefaXr3Awkjfk5ogODvnNuLiyh9+WV7prn2FxeI1LIOPYs6m1k1Ju0Kg1iuc4eWarq6NLT8+y4yx07xhtczqmneBRpQrL3DSN88f+RnH/oKjvv2+6U6SVeS2H/CBf+6Ju0ag2IxQLtWgBSh3Yy/0efo7WwjFYouO1arJdmbOs4ej5H9czZjuf9ksl1Mi3Ki+dTAbn/Fvg319E6mHYvAAsBeQuYo1kEpq7zOC+7bIKWbiIg/4p7mP6LP2Hgre80l5i3P9Ac3h33F6pV1QdcVJE9TmIBk+D1qIN6sRtZtzfROibj0HMOOaY0DGpTl1k99QJrp05Qu3oJLZUivWc/A299F8kduxz7ALWd0DHxHi8Q3PnBSS/AxA80PW+19YIWp2Gl7SB1kPUvrMK22sipEgBcCq96HSvf+jqL3/gqA/fe775JA1gTL/MSLw6hRWNUZi4R31FwPQOu81XSE9lBqqtzSGnY0MoEHaoHkeK+XCzspNEss1qeIZca9quIADSJNIKAS4iaKAiwhLAsEsnFKw8zPn43kWjCFZ7fPr+V2XNkhxWWxfpvrC3RqlVIDI+7wEyrvIZRrRAZGKTtygtGpYKs1tD7Cr77prW8RqSQdg+tbc9SMo3Go7m2eqiTyqfVMJh6fpHXfuiWtjt0AGBR3Z3V/Vgywp43jnPiM5PsuW+rz67FHOJgu5b8vhGkYVA+M036wITrXFS7ltjWIbRsisqJs2TusSLf2je99cEodI3kkf1UT90k0HLj5N2A9yRupIFsJ2h1Y7iil1k2QUsPktp/AD2dYeWJb1F8zRuch8f7Qnd9paoiaKuKvCgm7LbpNjH2Clg6Taqd8tcLXMLaD5IuwKW5WmL19AnKZ16kcv4MrbVV4iNjpPYeYOAd30Viy1ZXgLaNAhUfSOkwdl3BTYfyHdM6icqu2Ps2o2IBEwfA2MWdfdlmXfCQDhK0WJS+N97P7Gc+QeGOe4hkcm62JQCoqP9C10gObqE8c5HCzsPu+9gDVmxJZgeRRpNaZZlEsgiaRAQY09pMRiJRIJnoZ3H5HLnUsEtFJA23vYx5XGWAg7Ub7TJBgMXDsswtnqJSWWB866vaqiHr/KQQSCkpzZxl/Nj97XO2fpXZK4hIjGhxwHVfNRZM1j860K/0CZoLywBEBgrebtJcWiWx1R9VV0NSK5nsvs202OogVS2kxmgpzVQwmpK+7f4Vpr1iAxVv/JYDb9/GX//cw5QXq8SLKZc6yGZdnH3FriWajZHa1k/pxFXSByaw1x2yB8ixa9EFyf3bqR4/R+ZVt1kD4fn0E5A8coDVrz/W9TxeEpFc35TfrntWSnn8uvvjl3nrvz8gr8/qwdJLcNyXXDZBSxeRgIjoZO+8m5Unv0XhNfciEG6bFnC9pH1si61KUrZ9E1KY3ADAcl1gJaDuRm1hwvJlq0V1+irlMy+ydvI41SuX0JMpUrv30n/f20jdso9ILu+u2wtQ2ShICSvv7XsoqLFUF40mrbU1jFXz11pdw1grm2HKWwbSMMAwkK0WQtfRsxn0Qg49n0XP59AyGYSmWV0QAeChrRJywIpUMXEwcLGbyt52B0tf/zvmvvIAI+96vxtMBwAVVUUEkBrbwdql08p502YgFbGZhlimiKZHWVu+aoKWgDIqCEOD/uIeZhdOsHXsHoTKsASxLerKz2HGuFa6C6S4wIvNssD5iw8yMnIr8UQOaamGECj2LNM0qiWyI7utejj1yzMXSQ6NI3STz7Dr1mdn0PN5tHgcKaRzj7UWFxHRCFo2rdyflnpoaZXI4W2Bp9NcMVd4jmXjPoYliHFZnTFBTnawN8PdINl61xDxTJQLD19j7zt3+uK1QNsY1/C8LHJ7h1k9M40mJC2FXfHGa0ns3xZs1yJwEHVi3+7w6/wSy800xO1RzgIVIMhS+TBw5h+iPQtsgpaeRALZ225j8UufpzZ1mcTohHvdoQC2xUumOF/D9ktZeA6gindSD5gcbwRguW5bjA2CF6Nep3JlksrkOSqT56levoCs14kNjZDee4CBt76L+MQ2Z8JeF1Cx94OAx3pBirecq6zEqNZozszSnFugOb9Ic2GR1sIizYUlmgtLyHJFqSfQMmm0dAoR0c1z0+1/Ddls0VopYSyvIBtNp050dIjEgb0kD+0lvmsHIhJxAxi7vxZ4cd1z1lYgcAGErjHw1ndz9SO/Q/6uV5Ec3hLItiDwMS9SQGbrXmafeNCJjOv3HjLPwWZEhKaTLm5hdeEi/SMHlUkI9zOgpA0PHeXyM49SqS6Sihfa6iObbbHrWMDFe7m80l7NGQewuG1azLGdWXiB1bVpDh35AQeM2AyLff5LUy+SyA0Szw347qny1CTJse3usQBqM9eIj4z67qnm7AKRwT5EAOprLq4S689YdsOeGC2lGnoySiTmDVYTLGvzVRLZqLWqs/Sphrysilc0IYnqMHq4j5kXF9n7Tn+ZTsa46W39XPvyi05bUrSZGXUdosTuceY/8gBGuYJIpBS7FkVFFIsSmxinfv5i1/P+ThMpZVMI8bfAe4QQvyKlLAEIIbYC9wK/flM7eB2yCVq6ifX8RvsHiG/dRunpJ0mMTbgRiudrNKiNII2Qy7gyRG4oYFH2u6lAutXvJV0aBo2VJWrTU9Rnpqz/a6YbspTER8dJbttJ4a5Xkti2A10JeR8EGILOO0j1EwQ+Aut2AynWf6tRo3HpKvXLV2lMz9K8NkPj2iytxSUAtFQSvb9IpK+IPtBH/JadRPoKaPksejaDlk2hpZJtENZBpJTIcpXW8gqtpRK1C5epPv8ipQcfRkQjJPbtJnFwL+nbj5ltuqyMFXsWCdIIBi7t0pDacwvpvQeY++wn2fLBn8HxbPOyLAH3eGp0O0KPsHb1LIXth5xynYxxM30TrC5cDH5WPHYtUghyuQmSiX6uzT3DzvHXWY+c50lSGBeMNjAJWtPLURsF2rTYLIvk3IUvMT5+N/FkUYmea5+fub04dYLC2P72vWT9S9miMj1J322v8j1f9ekp4lu2WP3CGajm3Dz6QD9elgWjSWtplWif8mzQNqytL4eH8PeKjkF5oUp6INhoV42KawMX1bZF3e7bkWX29Iqrbst3h+Ezxs1u7+PcxQVkywDNZmXacMu+VPHtI6Bp1C9cJbF/V9uuxRbr/RvbMXFzQIuU0N3zuHP96xAhxFuBNGDfGAeEEO+1tj8rpSwD/xp4DPi0EOI/0w4uNwf82nV14CbKJmjpJvbLSEL21ttYfPBLDNz/ThCa+wvUBiZBbEsQy2J/xeJ/wffEjrxEgKUrUAnom1GvU1uYoTE3S31uhsa8+V+fm0XWa4hIhNjQCLHhEXK33kF8ZMy0S0kkwtvudr7eOl4QotbvUsaVbxjULl2mPnmZ+uQl6pOXaVw1QVZkqJ/o6DDRrWOk7jpKdGSIyOggejoVOjbui9v9RSWkQGSSaJkk0fFhEgd2k3/b6zHWKlRPnKHy/EmWP/0llj/1efJvfxOZ17yizb44enYLpGgWs2IoaeDWngjof+s7ufgbv0rpxLPk9h8171vlfrbH0SYB7G0tEiE9tpPVy6cp7DgUzBiqgAfI9G9l5ty3HGNcVzh/5Vg2QyN0wcjwMa7NPMP28dehacLPtqgnpLU7YTMvdlmzT8L59wIWx2No9mlqtWW2bX9dG4jYgMZSDTXqZUpzFxg98iaXagsB1YUpjEad5Ph21/0rBdSnr5G94w7XcyaFpDm3QGSwaHVNOl1tLq2BhIgHtNjlGqVqR88hb8C5tbkq6f7uqiQv4+Ld79+R4+QXLqNjOMa49vFUDyIva5Pe3odstKhfWyI61ja38Brj6okosYkhaucukziwyyok2+DRBs7HDrH64COh5/9SiYI3N1z/OuW3AFVn+D7rB7ADuCClfFEI8XrgvwAfwx3G/x9kNFzYBC3rksyRY8z97aconz1Fevc+MzHoqzRAXQTudPXB62gjEgQ2rkPCQICv/RCwYtTr1K5doTp1yVzR+Mol6nMzICVaMkVsYJDowBCZg0eIDQxZYe/7EZrW1bamG6sCHrDiAzbSA0w8ZVRGRSnTWF6i+sIpqi+cpHriNEa5QmSgj9i2LaRfcRuxbVuIbRtDSymLA6K0h3SnB51br6J+gSn0nJZJkrrzMKk7DiPrTUpf+TpLn/4ipa9+ncJ73kbyyEE0oTI5CkjRPMBF4LJviQ0OUnjla5j7/N+Q2bMfLRJz3c8OeBHu+1cKyEzsYfGFx5Qxxh2/SO2RgPTAVlrNKuXVWdIZdzh/p746fhJGho5xfvLLlNaukE+Pu9kWrz2LOo7qcHhitLgAiyYsd2YzLsv5yQfZMnEP0XjOAVAqKJEC5i8/SySWJDeyy2XPArA2dYFovt8xbrbrNNdWaa2WiI6Mts/PqtOcnSe+f6dq6wtAa9GMQxLtyzhgRpXGSpVYrrcVngHW5mtkBjZuz2JL3/YspWsV6uUGItm7B1FiKIeWiLA2OUdhrN93TqphbnznGLWzV6wMT0PWvaFl03wnipRye4/lngDe9NL25uWVTdDSRdQvdS2TIXP4CEuPfI30nn2BtIr6dep7cXsAjZfl9kk3QOGbtAPKdijXK/tiNJuUnnuS5ce/TvXKJZCSaP8g8bEt5G6/m/jYFuJDw+jpjL897yl2mNg7nqOa3iNYCWVVBDQWF1h95DEqzzxP48o1tEyaxIFbKL7/3SQO7m6HU3cBFBk4Pu18ZXeDANPFGkvl5G0mQoCIR8i95bWk77md5U9/mbnf+RPiu7ZRfN+7iE2Mt1kXIwS4WAsKqvYtxXvfROmpx1n4+lcZeO2bXcyKc65eVREmaLn2yKepl1eIJXPuc3EmevOGFxJiqSLRRIbV+UnSmWEXGHCOpVmoSprgIpnsI5/bxtTM0+R2bjEZJENRePViz6KCFfAY4dqsi+DK1OM0W1Umtr7GbMxjgCstNmZ28gn6t98KeqQ9PsJsf+3aBVKj23z3YX1mCoQgOjjkul8kFtMy1Nduy5LmYgkRj6KnokDAukMrFQe0qOsOhYXwX5uvUhgzmUHbniXMRdobEVeVvp3mtV68UGLgQLyjB5EqQhOkt/VTnpynYIWwUSPj2vsgiO8aZ+mTDynpysdHoA7yZRSH1byO+puyIdkELT2Iw5ZIyN39Sq7+7m/TWlttx2zxPkMqOEH5YA5gYpzyXY7vyA0GLJ2McVtrqyw9/g2WvvUwslEnd9vd9L/p7cTHx9ETSV8fA5/DoHPrBlTU/nnzQsCIi6JHebmpadKg8sJJVh/6BpXnXiQyMkj6zltJ/sj7iE6Mtd2o7bqe4zrHtDcD0kLPuUcJ0iY5QMYeZAvA6Lk0fR94F9l772HpY5/h2n/6DYrveyfZe19tTugabuBi38eq540lejJJ/1vezuzffJzcoVuJKYv8OXhCuddtRiUxNE4knWP53PMMHrrHNVEH2bUITZAb3M3SzGmGt9/lB/UWDaSqiNBgfPQuXjz9SXZMvJ5YNIPoZs/iObQLrNj1hDtYXL1Z4fzkg2zb9noisVSbPVHKSGF6Da3OXWDrXd/dvh+FfXkka1fOMfiKNzmXzB6T6rUrRIeG0WJRJO17s7W0gqw3iA4PeO4vSXN+hWh/1meg69i0LJkrPActiugtC7A6V2P8cDG0bK+SzMeIpSOUpisMdFnCSHV7NoQkMZyjPuuPZKuqloSA2JZBmnNLyEYDdE/EX+fFenNmf2HYHwEbr78pG5NN0NJNPO6uie070FIp1l48Tu62u530joa4Sn01v5ePhY4qm27SBbAElUWYUWfnv/oFVp55DD2dofjqN5C77W70pFt33lXd0yHt5QQrrbU1Sl//JqsPPUpraYXUrYcY+qUPEb9lh7Wei91GkPqobV+g7qt9Fp575LrEASrtm8Mkecx96WzjsBHR0QEGf/aHWX3kCRb+6GM05xcpvOftaEJ3AxcNxzhXbcL+gs3edicrTzzG3Jc/y9j7fjiYbfHuaxr53UdZPvO0CVrwlBX+eoWx/Vx48pMYsmX10URCwgEr1jDaYADB8NARLlz8Chevfp3d295sMiCGtBhLBbiAC7w4EmjTAlLXrGPA6fOfRY8k2DJhgS9NOMyKClxmzn2LdN8W0v3jTsA5u9/10jzN1SXSW3f77uvalUvEx8ZdwA6gOTMLmtZmWmjfU835FaID+ZCbBRrLVWJ7+gLztICZsbxQI93fOXpuJzHZGfNGSvUnKM9XOpZXgYgtsWKK6tyaL5w/4FIPxYZNcNWcXSI6Ouhm7lSm+mbIJtNy02QTtPQizucloOuk9x9k9YXnyd1+dztPAS6+DwBvmvIC7wRcQm1YQsDIem1egsBMefIcU3/5ESKZHMPf/QEy+w8jIlpwPU9/uqV1AyoQDFacul5vIC+g8aiBZLPBylcfZvmBB9FSCTKveQWZV9+Jns8ok2kwUAkDKcK37z1v/8UMGp7Qd5ajEpLtgqK9a2uppE19KIUyr7qdSDHP7G/9Mc2FRfo/+AH0SCwYuNi2IKINXNAF/fe/nSv/6/+j+upLJEYnnLH1MizqPZy/5RjzzzxMvVwilsxiMzLu0xLO9cmP7qXVqFKanyTfv7M9SCogsgxu7ZD9QtfYtvX1nDr9N2wdfxWxSLqtJlKBC7iMcdsXwQ1WnGNYk+DZyS8yM/s8x279cYQeNQGNlS+FQOpm/1pGg9kLj7Pl1re52Bf7HEuXThFJ54j2qZOsWaZ29TK5V97juswIaEzPEhkoIiIRwHCdSmN+hehAlqAQ/pqQ1JYqJHr0HpJSsrZQI7NB0OI1rM0MJlibrVp9CY7V4gUsALG+FKXT7aV1NOFWJ9nnrxezENFpzi4QHR30NrMp36HS3QfzO11ck6a5nT54mMqZUxi1ajuP4Ek5dIJXJ2rR/qn7gfXWKV3VQvY+ksVHv8blP/wwmQNHmPjQz5M9dMwFWFz9Ul7Irj560rzn5gYH6vHbKgj116bopSvN2daC8iWrTz7FlX/3q6x88e8ofPf9jP0//4z82+9FL2TMu16T5k/g7AvlZ+cLTSJ081/Tpek0pitlRfunaYZjc+D8NAMR8Assq7TV7gvWr52Or5/t80kc3M3w//mPqV+4zMz/+B2aa6X2OYo2k2GPme0NY/+S27aT3neQuS991jfW6jVTVSep0W1E0zmWzz4TeO2893I0kSHTv5XF6Rfd94Bj8Cp896gUJtsSjaWZvPKQk9ZeD8iq1+UnBWYdXXNcmS9e/ToXLz/EoUPfT66w1byndOG+z6y6C1eOYxgt+rYf84+PgNLkCTLb95nqHOVZM2pVGvNzxMe3uBlDoDk9S2TYHdYf63RMpsVtK6Qye/XlCrFCb6ClXm7SrLbI9LdVLao9iy6MwLgtYZLuT7A2v/74ZLFimvpi2X0czz1i3usa0YECzdlFfyOesXq5Rcjr/23KxmQTtGxAknv2gKazdurFdYGLXsp2Vbn0+qCu44E26jWuffxPmfvipxl+9/cy9I7vMb/6rCfLN/EEnUcvQKUXsGJtu8GK9E2ULnbFBh8CahcmufZrv8n8Rz5K6vYjjP37XyF77ysRUc0PVgQBAMANXhzAoAAUF8hwgRF3XU030DQZ+vOWN38WqAkEMWaf1f76wIuQxLaMMPzPfwbZaDD9q79JfXbGDVxcQMUaW2Xc+978VsrnTrF2/rR7rJXr67qmmkZuz1GWzjwdfF8E/Aqj+1maOmG1Z7kSe+4fFKYDQNN19ux6OxevfJ3ZhRddwKUTeJFqnm10a5Wbmn2G0+ceYN++99I/cIt1PnZdpW9Wv6fPPUr/9mPosYTvXjSMJmuXTpPd2Y7dYpepXTO9YGJjY65nSApJY3qW6Iga1r89qzXmlgPVQxoS2TJorFSJF5OudFXUEP6VBRNgdGNawhZP9Ep6IEE5BLSEGQKDqR7ygpYgEUISGSqaoMX7/rjpYtGdG/1t6oc2LJvqoV5EAIplrRaNkrplL+WTJ8geOtYuE6D+cbXRKX+dsiHVkLes9T/1sT+mNjPFlh//JyTGtlh50l1WKR+23xWUqRNfULqvf9KdJjxlVHZFGix96gFWvvBVUrcfYeDHPkBkoM9VxrstlDRV7eOk20WdPCvN6oP6xSsEGPUGzcUSzfmSaVxZa1ih+qX53zInAz2XQi9kiBQy6PksWiaJvcKtoxWym5bmfefcMgLnPnQ8bAwQmEHRbM+bSDHH8K/8FHO//SdM/7ffYuRXfoZo/4CjKsKajIVhNWerjQTER0bJHr2NuS99htSP/zwI4aiEpD0MyoQshKUievpr1FaXzFWfBYFfk3adwvh+Lj//OSrlBZLJPjeosdU9lo2LczwEg4P72bHtXo6f/CuOHvxBirntptrLXigRkN5wrMpnvApY5pZOc+LUx9m9662MjB5z2BQvOLbPtVyaoTRzli23vd2lGrLLrl05i9Fqkt5+i++erk5dJjowgJZIIJV7DaB5bZbksf2+e0pK0xA3NpB1ouGqUl+pgsQJLhe07pAtOgbleXNxxXRf3AdMgvaDFkxUJd2f4OqzQYsId5ZYMYVRbdCqNiDeZn2Eqoa3JDpYoDm7pJRRno1N+Y6UTdDSRdTnQ7U/iY+Ps3b8eXPHa9dCe9fnKeSVGwBgukoHQFObucbaqRfY+pO/SNwDWELbeDnAipXuZWt8gEaYsWPm/vDPqJ48y+DP/SjJQ/tQGZquYMUBIVY+bqDiBSlGaY3quSlq565QPXuV+tQCzYUSxmrbKFHPJhGJGELTTGNfXTMj4kpJs1SmtbzmDIaI6EQG8yT3TZDav43k/m1ERvoRQrgDb0ozAJf9nWYCFUz7FPvjXGK6/2oSLRVj8Gd/hNnf+ANm/ufvM/xPf4aI5fEmNYkw7DW02vFb7OvQ96b7mfz1/0zphWfIHTjmjL1jJ6leSAHJ0W3ECoMsnnyMkdvvc18v59cO6Z8qjJHIDDB36Skm9r5ReW6E1R+zjrBAmLTPVsL2rffSaFR4+vhHOLzvHzFQ3INq7SE8/LFjlOvcO4Kl0iWee+HPmNjyaia2vrrNqASwLDZAuXbmEdL9E2QGtwawfoLl88+THt+Flkj67tvqpUniW7a60gCMRoPm/CLR8SGP2y8YyyVko0VsqM20qJ5AzcU1ABJ9qZ7WHSrNVknm7RD+1+++EktHaJSb666nRU2bF9lsITykj/fVoaXiNOaW/Y044Hbdh78hcr0qnk310MZlE7RsQCRmWP/G/HzXsr66nQDMTZClb36NxNYdxMcnfHk+exjP9nWDFWV7o4ClubTEzG//AUalysg/+xmiY8M+kNINsPjAisKoCCFprayx+q0TlJ85Q/XsVZqzy/D/s3feYZJc1d1+b3XunpzDzszuzuaco6RVFso5ASKDEWCDMTY44PDZxphgDJick5BQQijHlVZhc85p0u7kHDp3V31/VFd1pZ4Z7QqE8Zznqaerq27dququqvvW75x7rlvCX1+Jf1Y1oYX1eEoLcJfm4y7Ox1MaQvKMf2spaZnUSITUQJjU0Bjxjn6iR87Q++uXSA+O4SoKEZzfQGjVHPI2LEbyuA3KchZedOVF0XKVKHomXGSB8EqU3ftuur/0Xfq+8zMqPvlhNXmcprAIMopLRn1RP3CXllC0/kL6X3iS/LmLQHKb1Jbs76b+uUIIihesYeDgVipWXo6Uaej1MpZJSIKy6Svpbd1N7dxL1fLaqM96gySyakvmIlKEQLgkZjdei8vl5cDRX7Fw7u1Uli40XGuWC9EAK4oi0ztwjGMnHqWyYgkzG6/K9hAyuZgM150EyWSU3pZdTF9zm67IGK9LBYXRpsOUrb7EfK6Zvyd2ppWiSy41X+9CjWdBUfBUV+jHqh1usldtrD3lZveQBi7xwQjCJfAX+XB689HKaZ+jPVHyDAMlamAzWXeQ1dx+N8loFlrGy89iPCZtNAs11874JrwelEQyx8q38UF6vh6eP6I24H+bTUHLOZqntAw5GiEdjeD2B/Xlk4YS69vqH9oEpKNRRg7spuqmuw3LHdxChm00GxdYLOveMmAxyuoC4mfO0vudn+AuL6Hikx/ClZ9nhhQ9dmXysKKBSmp4jPD2o4xtO0zkcAuuvAB5q+ZQdusFBGZV42uowOV12U4p+yY8wZ/rFrhLQlASQlYqYWUjXL8GWVFIdA4QPnyGyOE2en74FL0/f56id6ym6MpVuArzneEFkek6TCZ1v0CRFJAFUshH+Z+/j+7/+Db9P3uA0g+8U+9qrKAmmtOVFJF9gS2+5DJGdm9ncNcblKy9KFtGK2Bo4IWA4gWr6d76NGNnT1FQO9t2ytl4E/X3L52+grOHniU8eJb84rpsnTioLVpPIjLH7ILGGVficnk5fOw3yLNvorpyhfNvn4GV7t6DtJx5hUi0j9qa1TTOuhYhmV1Cph5DBpWlt2UXLreP4oYlZljJzEf7zpIcGyJv1iL9XLUpNTpEamgQf/10W6xXsqsbKS+U6dFmhodU7yCugiDuoAdhWSeEQnwwircokOm2P/HDZKw3Rn5FYMJykzVPwGWClsmanmYg16iKxrJed25oeTvtPJWWKWg5d5uCljdrmeeDu1QNnEsO9OGuqf+DKyi6+/c8JNLwySMIl4u8+U6jl2s7mszBOM/bfg7hUMYILDaIISewRPYdpO+nvyawYjGl99yG8LizdRgDbR2ARWQCUq2wAjKRvScZfPwNokdacBUEKVg3n7LbLyS0sB7JLUyHrwGKObblzV8EwkCAkiJw15bgryml9IplpCJXMfjifgYe38HAw69ScOFiiq5bh6+hOgsv+mhzmR9PVjLqSRZc3GWFlH/y/XT/53cY+u1TFN9yHULWACLjJjJCDCAFg5RccgUDm5+jcOlqXL5AbrVFgDuvgPzp8xk8up2CabPtYGNxKfnzS8kvm05v227yi+syQbV2tUVLxKYuMoCLpDC9/mLcbj9HTj5KZ+8+QsFK8jJTKFiOcLnp6t5P69ktxOMj1FSvYumS9+ALFGdUFOO4Q8KskghVZZEVma6Tr1Mxez2S241sOCcNcEaaD+GvqMVbWGy7fqNnWhFeH56qKsNy9cdIdnTjqakwXD/owdfJniGTymJNIJcYCOMvCTJZG+2Jkl8x+RT+WhxLrpGfPQEXyVjaYcvcJisCJSO1KJMIThE+L3LizYPRlP3p2hS0nKO5/AGkYIjkQD+Bmvq3+3BMqWQma+HjhwnNmo9wuSYGfyfQsCzPCSy5yhiBxbYMs+JiWDay+VUGH36cwhuuouDqSzLdS8cHFiGN5wpSCO84ysAjrxBv7aZw0xIq7novwfnTTKBihRTt09hdMxe05MpZAZgCC+XMFw1kpJCX8uvXUHrNKkZ3naT/8R20/tV3yb9gERUfuBopP9OFO6O6yGTeZB3AxVtXTdm976b36z/BXVJMwaYL1DxhGgrI2m+SdRMVrtvI0NbXGHjtBcovv35CtaVk4Vranv45yXgUjzdgAxt9ypxz6fSVnD34DA1LrseFy1FtEQrZZHLYwWXatHUEA2UMDJ4kHO6ht/8I8fgwAC7JC0IwrWYtdXUb8fjys3BsABZ9XgMZV1Z1Geo6TiI6RPmcdYZAXvO5jzQdomD2ErOSkrlwYmda8NfXI1xSNggX1J5DnT1ml6bBkr3DpngW7TrSLDEYwVcS0Jc7pfA3ZcPtidGwwjkR3bmYJ+AmFUurgc+2hEXjmBZ0PgmlRfqjVVoUzisieCqa+JxtClrOw9yFhaRGhu0rDA/lnPZmrlmjmnIuyorTNgrEujooWrX+TVZmsLcSWIQdWLLbZUEkcvAwgw8/Tun77iS0boV5vROwZLoqG4FFMqgryY5een74BLFjbRRetpy6z96Bt7JQfdvN7N7Y9Vj9ntmtJWbAuMxo2npt+DgrvCiG7xqsaM80OQMjkhAUrp1L4dq5hI+30/GtJ2j51Leo+NA15K1fhBACWc7wi3aQSqbR18AFCCycQ8l7bmXgZw/hKi0mtGhhFkQMDbHeBnnclF55DT0P/ZqiVRvxFJaMq7bkzZiPyxdg8PhOKpZcZGvcM7So/2el9Utp2/s7BjoOUl67THVvSTiqLSIHuACUlM6ipHRW5keDVCpGONJDLDFESfFs3N7sSNympHCWOBajW0gRIKPQefwVSuqX4gkWmF1JmW3iI/3E+jqpufqddjgDom0tBGfPyf7hhnXJzi78Cyz3oHZt9gzhry/Tu9lbr6d4fwRfiXMKf6ceRJrSYoxhOdd4FiAT0AvpRBrJ93vKnuFyQfrNqTl/CJsKxH37bCpPy3mYkk5nslhaV/w+dmZfNG74xCSW+SqqiPd2vbnDeLPApNkEwJKznAFY0tEIA79+mPzLL7IDiwl4DApLDmBBkRl4eDNtn/k2QhLM/Pq91Nx7Db6qAvNbayYRnEtSUDsBqcucJrck48psq00eh2XWyZ2jPldmvy5JyRyDOuXPq2HmVz9E8dWr6Pz6I3R+5X7k4ZFs7hcdssjmc9GgTlLIu2AVBddcQv9P7ic50K8DnzogoGE+83vmLVmGt6qGvpefMUOI/ntnG3HhdlGyeD39B99AURwaREuj7vYFKZ+xhvZjLyOjmJQME1wYE8NZ1uuwIbSBD8Ht9VNQ3EBF5VIVWJzq1OsStuPSpqGuY4z0NlOz6FJbAK5W3/Dp/XgLS/FX1Jh+C0VAOpkg3nEW/4wZtutUSSVJ9fTjqa3S3ULG1izZM4i3qtjp1kASCrHeMYLlkxzlWJYZ7ojogyU69S6ShOwIO7nM2k3fyYXkZOlIAgB30GtbZz0qJZZA+M592IEp+9OzKWg5D1OSSSSP/cYbz2yEbY0ZVMah+PEgxanuHMs089fWEW8/k7vAOVhOlUVbnwNYrJK6KY4lY4MP/Q7h91N4/ZXZOvQGRNE/c7mEdGBJpej+5kMMPvY6VZ+4kfp/fje+2hJdXdGUFckADY5A4QAfxsnjSjtu53GlbWVtMJMDXjQg8Xglqt65icavfpBU7xDNn/oWo1v2IYSW5E52BpcMoBTeeAXeuhr6fvxrZCVl+g31317LNuwSlF55DaP7dxPv7bL3nLEoCyWL1pEY6We0/ZTjeuO1oAionreJyHAnwz0nsteDPlaQ4XqwXkcGWLGCxHjLrMBicgsZVJa0nKJ13++onL0Bf1GV+VgMn8OnD1Awe0m2TsNxxzpaQZbxNzSYFRog2ZXpOVRbab1N1MRx3UN4q4pMy41KXqwvjH8caNESy7mQGeuNIqcUimqdY2CMsDJZcNG6ljvFpqTHebtJRRIgCSS/Z8J9yNEYUvCPFFqU85im7JxtClrOw5REAuGZ+MabrFkBY1wJUsmWMX53KmOd17bx19QT7+lCTiTOT66c6AVrgvU53UKGZZFDRwlv30Ppe+9A8nks67PwInJ814BFjkTp+I9fED3cQsO/v5+iTYuRpGxMgFFZMcKK0EDCAVLGU15yTRNtkxtgzMpLaGYljV/+AKU3rqfrO4/R99OnEaQzsOIALhrIuQSlH7yTVHcvw088b2uQrfOBOXMIzGik76Wnc6ot2rw7v4iCmYvoP/S6BRyMk9DL+/JLKKtfRvuxzdl1BtjI1m0ImsV6rMIGK87LsAOLBiqWIQ26Tr1OKh6hdsmV5qy6hs/E2CDRrjYK5i51vO6jrc34amoRPkMAbOb6THZ0IeXn4SrI9nrLHJaanDCVxl9VZEssJ6GgKAqxvjECBmiRUHICx3CHmoG2qOat6z2U7QX05rZLjcVxB726UqOZ4gA6cjSBFMgBLecs+56/GV8uz3WasnOzKWh5s2a42GSD0qILB5O5GB1AY7ztTOsc5sUE9eTa3ldTB4qspxhX14txj+d8brZxu0lbyxl2JEeiqlvo0gvwzWzIHoi10TSoN1pjrQXdIhTSA8O0/+OPSA+OMv2LHyQws8o0BlA2TT96HIH2aQQVzW1kgxNhnlzjTB4pbS6fA2ZMAJMDXtxeQeUdFzD9n97F8OZ9dH39IUgnM+6iHOAigbuskJL3387Is5uJnjihD3NgHc9JcxOVXnUN4aMHiba3Oqotxka9dOlGRpoPEx8bsqstxinzf1fPv4SR3tOMDrRml0uY/mOrm8hJ2dBhxTA6s0kRclJYbKADifgY7UdeoHbxlbj8QcdjV4RguOkgnvxi/JV1jucWbW3CP32GGa4zluzoUlUWh/sg2T0IAjy5EsuFE6SjKfxlIRusGF0/2jZD7RHyK/x6HApk41nGU1bGi3nJuofe3EMhHUngsriGnGJyFUUgR+MIJ2iZavT/z9pUIO45mqIoKMkJlBYjVEwWSiYoM24358xyoRgAwVjWMC8UcPn8eEoriLWfIVA/I/c5jLdP6z4mY45k5VROnQZ/+wTC66HwxqvM5UygYo9jMfYSSnb20fGvP8VTXsi0v70bd0FAHcyQrDtIc78YYUVbry3D8F1rHLTliqKQ7B8j3DpA+Mwg6Wgik8JffTPW0uf7y0IEagrxVxXir8hDcrv0AFyXyDysMw2CrAg1EFcR6jygiEx+lsy6tAwuSaZgaQMzvvAeWv/l13T8xy+p/sxdSAE/MjLI2sBF2UETkQTBZQvIu2QDfT++n+p/+EvcoXz1N5Uy+V/UQwbAV99AaP4i+l58irr33KvDgND+f8MUrJuFr6icgSNbqV5ztQkesuXUjYUCweJqimrm035sM/kb3gdaThYJULTcv9qllukGDXpwrvWysQGyCXAcYlMkM7ycOfQs3mAhFXPWO4KZ7ho6tZ+C2Uvs+V4EyHKaWFsrBWvXmw9OqP9hoqMbT21VdpUO2wrJ7gE8pQWZXEB2CEn0jQIQqsjl7jH/JkPtYQprApMOvFVHa57gnVaDyxy9gHL1lktFErhDPr2MUzlNdZEj8dxKC7x98CIrk8ozM+72U3ZONgUtE5ipjcy+yJMaHQVFwRXKzxY4B8Ujp4qS40B0ILHAhG25w76dQCY0ax5DO1+naPUGhNudqUM4n8Dv2xyOW04kGNu2m7IPvxvJm3k7s7yxZt/Gs8t174NQkJMJur56P966CqZ99g5cfo8JWFS1JauuuIzrDACDtoxMwzIWp3fLSYYOtjPWOki4bZBUOIFwCYI1hXjy1DT+SGqKfOGSUNIy0Z4xoj1jICtqRtOKfPLqiylbU0/5uukEaotxoT7QJVSAGQ9eQEJlIoXQzEpm/uf7afnn+zj7Tz9h2j+8G6kgPwsuhkRkigxIUHz7NcRPNDHwywcp++j7kISkXgICPQEdafV7yZVXc+YbXyHSeppgfaOpJ5EwNOZCEpQs2UDvzhepXHUVkpAyileOSYGaBZdx5IX/ITLSRSi/Cn1MIYHeWwiy4KJny7UMEazIirkfOlmVJjufOW7J7BZSJAgPd9LTvJ25F38IXC5bfIw2JSMjRDpaqLzwOlOsirY+3tWOkojbg3AzluzoIrh8vv16RlVaPJkgXGvvIYBY7xjCLWUGS5z4Xh06M0bJNNWVNN7IzW+1OQFJciSKK88/qRQA6dEw3roqPRbkj6an8AQvopPafsrOyaagZTKmYHt1i7e3I9xuvOUV9te68S5Iw8WuP4cm61J6E+BietscR20p3XQFIwd2M7h1CyUXXmqCm3MBpGyTODlzDLA0WKKlDRQF/9xGO9TkgBSjyoJQGLj/BeRwjJp/fR8uv8cUcDtZYNFgRUml6N/ZQudzx+jZ2owr4KF8dR1VG6aTd/dyCqYXkjetEMnjcuyKqpmcShPtDjPaMUqkY4Thk320PLiPo998lWBtIRXrGihbO52ipdNweT3jwguSrKsuIOOvKmTmF99Ly7/eT9vf/4hpn78Hd0WpM7gAwuei9EN30f3v3yT8+nbyN65X1yjZsYmQBMjgraoib+ES+rc8R/Aes9qig05mKpq/iq7Xn2Sk5RBFM5bYWFgHicx/ll8+nYKKRs4efZE5a9+lKzj6wI5O4AK66qJdEiZVRV9hdyUZ41iMgyW2HniSwqo5FNbMNcWwmOdV15A7lE+gtsEONaiuIU9ZOa78fJtCI8eipPsH8dRV4WSJzgG81eacKsY8QdGuUQIVeaZsuNbrzQja/c1jzL+sWl83GdfQRKYpLEZodFJnZEUgo16viiKI94XxleY512n541K9QwRXzLcUOudDfsvsfONSpmJazt2moOXNWuZiS3S2462oQrhcaiBaDgDRXEPWi9QJWHJdyCb4AGdwsAIFdnVFBxlDPW5/iLLLrqH32cfIX7ICT2FRdqdv5s56sy6i8cyw39ipJrx1tUgBSyZPUwOkmJYZASbZ3sPw09up/Zs7cRcEDHEr9vgVI7C4DLEuEgqx7mFaH9hN1+YTpKNJKjfOYOU/X0XVumkmQMk2HPK40IJX4K3LI39aPlADqINAj7YO0bX1DN3bWml97BCefB/T71hO3Q2L8YR8yIogrUgmeEHOJC2TpUyUmoyvOMCMf72Hti8+yJl/+DF1//4h3OXFOrho6oGmjnjrKim69RoGH3wc3+xGvOUV6qCKitAbaq188SWXc+abXyV6ppnAtBm25HFaWZc/SNGc5fQf3krRzCW29cJwHepqy8LLOfby94kuvJJgqFwHlVzgom6evfAU0w1lWG5UOoTZFWScH+o6wXD3CRZd/WkdTqzxO9r88KkDFMxajJAks9KS2Ue0pQn/jEbHvz/Z0Q2Ap7bS3N054+ZMdg0Q3DjflvdHz9HSM0qwMk9fpiWUU7vqm0FEURT6m0cpm2EfWuHNmEvIyEo2JkaHFtebu/Hj/WEC08xApji4iWRZIdU7hLus2F6JIv4o4GXK/vA2FYh7LqZAvKNd7RWQ68ZxWm6VFCcBLNo6E9nnUmqMy61lnPaTmS9cvhZveSV9zz1uKzPuPiznYLNc20zGMg1D/FQzvtkz7Ots5Q3gIrQEZDK9P3ua4JKZ5K2enY0ZAEMuk/GBRaTTnHl4D1vf/0tGjnUx78/Wc+Wj72fN/7uCaRfV4/ZK5p5B4s1NXkNArselUDKzkHnvXMymb1zHtU++j9nvXE7rQ/vYcudPafrpVuTRMC5D8K4pWNcSpOsNuWn4h7vwTiuj/Qu/RA5Hs7+BHpCb7VGUd9kGfI0NDNz3MFrqfGtQLgK8NTWEFiym/xVzryOngNuSxesZO3OC2HBf7oBcstsWVMwir6Se9mMvmUEjx/VhUkEgo9wIXVlx2qfe9dkQx6IINV1/6/4nKJ+5hmBxtSOIadsno6OE20/bsuAqhrqiLU0EZs7MgrXhM9Heibu8FMlvj9dQMuNPaUqLFltltGj3KIHK/JxgbOzuPNoTIxFJUzrDWd14M2Z0LenQYukFNFG+lsRAGG9JtteTU68hRYH08BhKMoW7PAMtNjJ8m03Linsu05Sds01By0SWAzLiHe34qmsBQ3s5ycbZCgUmAMg1Wbc1KDhGSBk3+DfHOklIVFx9C6OH9hFpPmUoL+z7tNbjtNzxrI3HkS0x3m+lJJPEm1rxzTJAi+nHy3wYlBV9lVCI7DlB9GAzFe+7EiGEPQ+LMGS7xQ4s0dZedn3yN5z68Vbmf2wDF373NmZeP49AoVvvRaSBioSifgoFt5TGLaXxTHLSyluBJpDvZt47F3P1g3ez8KNraX/2GC/f+VNOffcV0gZ4seWN0btoK3h8gobP3Y6QBB1f+jWkkwgpA2R6tuAMvLig+N03E29qY2zn7mwjq7tQso13yaWXEzl1zNyTSPtPDPP+qnr8ZbX0H9nqCBqamqGVF5KgduHl9LbuIRYZyFwuWcjIunKEbZ9OgbJWWLHWZQSSnubtxMP91C65yqSyWIEEYPDoDjx5hQTrLW7LTF2Jvi7kaAT/jJkOx6GQPNuJZ5qW+0UFGZG5luWxMHIkjr+6yHQ/GAPBo12jBKsmByH9zaMIl6Cs3tzd2ajIuFD0yWm9k8npzPG4xMRBuwZL9IfxluSpjzALhCgZFxJAqmdIPbbSInO5P4I23/giea7TlJ2bTUHLZEwRphf5dDRKaqAfb3Wt4YmG+ZMsHOiQYAEUJ9Uj9zFky+RUXZzUj/H2Y9gmWNtAwbLV9Dz5MHI8bqjfAi6TNP0Rcx43Z7y5DSWdxj/HQWK3kWLmI/PwV2SZ/l88Q9E7VuOrq8hK8GByC5liVgxT+6N72Pbh+/Dm+9j083cy46ZFuFzmMtnuyhZIETIeA8hMNGnlfVIKj5TG50qZIMbnl5h9yzyuuv8ulv3VRfS80cwb7/8VAzuaVKVlAtXFW+Cl4R/vJtk1QPe3Hs0moAOERFZ1EeCpKqXw2ksYeugJ0tFwFgYyg0zqakvtNELzFprUFidwUANy1zN4dCdp2ZKO3daYq1Nh9TxCRdW0H99siCOxwAbZZTZgygEs+rwljgUBY0Nnadn7O6YtuRpvsGD8ulAYOLKD4kVr1UBr675RXUPu4hI8xcWO13ayvcvUc8i0rnsQAG9VsS1Hi2bRHjO0OOVo0VSY/qZRSqYFcXvUwQ+tPYgmMfKYY/CuU0yLZrkgJp1WSAxFcJfYgcu6h2TvIFJeEMnvkMDT6aVsyv5P2BS0TGQOhB89cQzh9elKiw0WJgMgxvnJKC3WMkwMLuMBkk3dAcqvuA45maTrkftQZNkGLk7nmEttyXXObwbU5GgU4fXa41lymeEwE2e6SHb2U3zDRh1OwDyOkO4CIquyCGSafvQ6J779Kgs/fTGrv3Qd+VXBDJhYXEAZSHEJBY+QbRAzWbXF7aC2eDK5XIwA4/XAzGtmccXPbqPuytns/tzjHP3aSyjxuKq6jAMugcp8Gj5/F2O7jjPw4OaMiyiTw0XrDZ3J31LwjouRAn6Gn3oho7IoemNvVDGKL7mMyIkjxPu6HXvPaFPh3BXIyTijrUfMKoh2GTioLTULLqO3eRfRsd7c4GJVXawTdnXFCCxauVQ6wclt91E8bRGV8y6wqSyKpb5IVwuJoT6KFq22B+pmzkHLz6KArR4FhUR7p9orRlNZDBCd7BrAVRjEZcgEq8dMoahB3D1jBKvyM+vMOVqsLqO+08OUzyqY1C0Ek4MYyCotuWJatOBbORODJSuCeH8YZAVfebbXpaw4Ky7J9j48tWWZBaheFeuhvV3uoome1ZOZpuycbApaJmFWGAgfOUxozjxcbo+5jOFTK2tTWXIpIxaFxlFGdNjG6h46J3DJfHcH8qi9+0NEmk/S9/wT5vMxqE1v2k3kBDRODxv9XIQ67/OhxOMTJ6+y+tuA6MHTeGrL8JYXYGgPdZWFzLwGLBrEdD1zmNbf7GLFF66l4boFeIwBuZq6YoAVXU2R0kgZ0NAgRgWZ9ISTT0rp5U0gYwEYbZnPL7H8L9Zywdevp3dbC1s/dB+jRztM7iIncMmbVcG0T99M/0NbGHt9v558DqEpLeokfC6Kbr+W0ZffINHdnU3nLzCpLb76Bvx1DQxue8WmmBgbcpfPT8HMRQwe320rZwOdzN9fPG0x+WUNNO15xP7/a+CCcRvhOJnUFW1bQxyLIqB13+PI6STT19yq9pJyVGqy5zV4fCehull4Coptl7Ii1EEWoy1NBGbMdLxc0/2DKLE4nrpqx/XJrgG8VSU5g3ATvaMgK+TV5E/YfVkSCj0nRqicU2BZrsW8nHvrmU7KuDySHtMyXup+zWLdIwD4KtTjsQ8emgWYxJkevNMqc4PK2xjfIhTlvKcpOzebgpYJzNQeAkoqReTYUULzF2XXOzTK47lTnLYZz9dpW5dj+3MGF8N6f3kV1be/l8FtWxh8/WX7b3C+4IL9HE3HYDDJ5wNFQUmm7CtNlVsWC4XowSaCSxpNyxwTxBmmWPsgJ775MnM/vIGq9Q24RdrmCpKEbIMVs9qSgZEMZEhCwSPSE05ZpUWdjO4iDVas8FK9qporfn4bpYsr2f7nD9H0kzeQlJQOLpqKpMW4CKFQvG4Ole+9jK5vPUb8ZBtCaNCGyU0UWDEf35wZDD7ypPo7Z5Zb1ZaiCzYxum8X6chYFliwqCkCiuatZLTlCMl41DnmhKy6AaraMn3VbYz2NdN3Zo9ZbcnUaVROck7YlRkjWA2cPUhP83Ya178Tty9gOg6n45RTSYZO7KNowSrbfrT55FAf6dERQzyLYvpMtHcivB7cFSW2nkMAia5BvNXFpuvWaJHOETUXUGXucYe0bRRZoeekHVreCpOTMpLnzTUhsa4RNQjX4xl3tHMwQIteQDi/AL0dJr8F05Sdk01By2TM0KhGm04jJxME58x3vomsgGBRWXIBi2k/uSYc4MVaT479OIIHlu0yZfNmzqXqpnfS+/zjjOzbZSgj7Meb6zyMy407s6ot48GdT/VlK/F47kJaWcNJyYkk0aOthJbMdIwH0HsOGbdNpzj0709TtLCKmXcs1WV2DVjUeQOwZJSVLMDkhpTxxiDSB1ccB2KssKJ/FzKBfA/r/vFiVv/LFbQ9coCD//YMIp00KS4auGhp/ytuWkvhpsV0fPVBlEgkOzK0wU0kJEHxndcTO3SMyLHjpobeqLYEFy7ClZfP0O6tzgG5mSlv+jwkr5/h0/tN/4UJDgzbKQICBeXULriMlv2Pk0yEHcEFDPBirFeyQA12YInHhmna9RA1Cy4lv3KmY/CuUWVRhGCk5TAosjpAIlh+F3WKtTThCuXhKS+3gw2QbO9UR3aW7I9frbuzLwMtmplytHQME8hkUgatm7Ni6+7sQmaoI0IymqZybsE5J5XLlUVXU1qMlithnGbR7lFdZdHM2t1ZUSAdT5Ls6sdTV6nCzB9ZIO6UvX32JwEtQohLhRA/FkIcE0KEhRDtQojHhBArz7tyizIRPnKIwIxG3P5sJL7VNZRLzXBabgQNY32OLiIneLFMNlUlx3crYFjLFi5aQflVN9H12P2MHT9iKHNu4GKdH0+J0kzKDEmvxBMTFwbdDRQ/eQYllSawYHpmebabs9ZjSN9H5oHf+ovtRDuGWfK3l+OSVPncrMSogKKpKyZlRVJBw4WsQ4oRXiQ5Tbw/TN/RPtre6KDnYC/h9hGIxXMCjg1gnODFMN9w6XQu/NYNDOzvYN8/PA6JeA5XkYLLpVDzkXcgBbz0/OBxQLa7iSQFb30VeResZujBx1HktF1tAYTbReH6Cxna/hpyWhst2qy4KEItVzRvBYNHtzs25Fb3kLasev6luL1B2g4+ZSprAhcLvNhHiBY2YJGROb3jAXx5pdQsvtJS1gJShroGj+2iYNYSJJ8vZ8+iSGsT/hkzbV2B1foVEmc7VdeQAQCNJRMG95D1WgWIdo0QrC4wLTOay/Aa33tiGG/QRUmtGhfmMkFN7psw1zpjd+Z0RmmxgkraAiHGxHKx7hF8lVloUUywku05lGzvA0XBY1JasEh5vI0Ac76uoSnyOlf7U0kudy9QCnwdOAKUA38FbBNCXKUoykvnVXvmxVKRZcJHDlN80aWAg2pibZSdrksHuNDLj2PG9fqsUJcrIrNQGI7VOI9lXY5thWIuW7LmQtKRMTp/81Oqb3sPefMXZcpkwAXFtu+cx6SJKtrBa8+qTEFhWaUgEJkcFvJYBMrNyaj0H8LhxS56pAVfYw2ukJ9cOqwx4230TD/Nv9rBsn++mmBFCMngFtJ6ZWjAYlRXNLBxkQUcFzL9zaMceKSZnpPDDHdEGO6IIKfUs5PcQp8H8AZdhEp9FNYEmbm+gsYLKiidVYQi1JY3LSQkRUFGkBZKJrW/hCwUJEUmJbuQhQIylM4u5uLv3MCrn3qS3X/zW1Z88Ubcfn/21USWMtlzXXgCLuo+fROn/+bH5G09SGj9UiShqGMeSeofqEhQePNVdPzdlxndup2CjRtUANEbW/XHL1i9hoEXn2Xs6H4KFq00XQN64jmgZOFaTu57lehgD4GiCrWctl67ZoQxdT9ILjczV93Gkc3fpWLGWvJL6tV7QRiuw0x5JzO5kwxA1X1qG6P9rSx+x6eRJJdjbI31eyo2xmjrMabf/JHsOmM51Lpjrc0UrN+ot7HWYN5keyf5l26wHasQoMRipIfCunvIuhuAaOcIwercOVqM1n1CDcKVTJlz7ffEpMYaslgqoeBy597GaVyhWPcIoZkV6m9jBBbLtvHWblxFebjyQyhpzKlNDM/OnK7j37edL3dMMcs5258KtHxcUZQe4wIhxDPAKeDvgHOHFu15qECstZX06Ah5CxZnXzW1MjkUC5tbKAewKIpCrLdDHRqgoBTJleOvEdntbe2/9uUtBJeyTe9ACImOB35CxdW3ULR2o2EbS3bS8cDFsNr4u46nJrsCQdylJSRa2vBOn5bdYIKHdXo0grtk8j78ruePkjejlOpNjUjIFmBRTJBidA8ZYUWk0zS/1smuX5+mZVsvNQuLmL62jEVXVFFUE6CwKkBhhQ9/vptkNE14IMFYfzwzJehpGuPAY2289N9HyK/w07ixgsYLKpm+oQpPwJMTXpAy3UslkBSZorp8Nn37Brb8xRPs/utHWfHFm3CHAiZwUSR10KG82ZWU33YBPT96mumLGxF5eQhFURt6Sb0QXIUhCq66iJGnXiRvzWoktyfzH2QUjTRIgQD5i5cyvHcnBYtXmpUUAwz4ymvwlVYx3LSfwIor9OVag67BiAYs2vf8ykaKaxdy5vAzLLjoI6Z1KuyMcxEZX8w1aIiHOXvoWaYtuhJfQZlNZdG3MwCHIgTDpw/gDoQI1c/KeY6psVGS/X0EtJGdLSYnE6R6+tX0/ZqbzWCJTjU3jb+mGGNPYmMsVrh9mNqLpuc+Z7IKTO/xIarnFU5QNpvS/82ASyqWxu13TVzQYNGOYYo3zDEtc1JbEs0deKfXmBt3B1CI7j30pvY/Zf/77U8CWqzAklk2JoQ4AtS9VfsJH9iHf/pMPPmFZoXEciPldMtYbkChQDI8wuCxXQwe2UF8KHMaQsJbUIKvqAJfUTn+0mqKZi9D8nhNpJITOLJFzhtcBIKyTVfhLiqm+/HfkBzso+zK6/XU5RpEWPdtq1evL/PWpIGMrtwo5mPMmLehjnhbO7asDuPAixJLIPm8mdgVTEG4xngWNVBVpuelY9TdsFh3A4ExUFfOQooDsCRG4xx6pIm9v2lirDfGwqtq+PB9G5m2uFiPITBK8pJI482DUJ6XinovoHb9VBuLeQycjXD8tX5OvNbD7/5hDy63xJp7Gll5dyPefJ8NXpDRlRYJoXZZrgyy6X+uZ8tfPKmCy5duwp0XzACOwCXJ+j4rb9/AyOtH6f3ZM1R+4tZsbIsCZMbmyb/iAkZfeI2xbTsouHBjFjI0tUVA/orVtP/w2yRHhvDmFel/kbFhFwIKG5cwfGo/VSuvsFBs9tpUDGqLtr5u0VUceParjPQ2UVA+0wwuWOox1qcdR8ZSqTjHX/spnkA+lXMuyEKTVt6qjBimoZPqiM64JHsHlkyZ2JlmhMeLt6YmszxzHpnPZEc3KAreablGd+5HCvlx5asDIRpjsrTrKdIxTKhWcw/JWdUPe9Bu17FhZn2owvbT5HL/vBlwScZSePxqEzJRFlyAVFoh3j1CIJM0T1VisuuNakrsdDuBxZlhB2wxLUJ/niaa2yZ1rG+5nW9m26neQ+dsfxLQ4mRCiEJgBZNQWYQQFaguJaM1QlZlUdIyY4cOUHLx5eo2VhAxwonxu3VfCiipNKMtRxk8sp2RlqN48gopmbeG4nmrQEgkhnqID/USH+wlPtDF4LGddO94hso176B47ipTAJ/1mW0EFev681FcipauwV1QROeDPyPe00X1bffgCgbt4GJpiKzHYwIX4wEazaDCeOtqCe/aaz8Jy3ZqsJ4KKXIsjrtoctlCR450Eu0coeqy7Nuf1S1kVFuMwDLUOsIjH3+VdEpm1R3TWXVrHXmlvkwCr7Rjt9JcWUblTJnKOh9ld9ey8e5a4jGFXY92sOWHp9j+i1OseWcjK981C19BFl40EEHKdDnNjNycXx5g07eu59W/eILdn3mU1V+/DbfPhywJ3U0kKwJ8ErWfuI6mz/2EggsX418yF5FW61MU9SKQAl7yL93AyPOvkL9xHUK41K7BBmXEN2MG7qJiRg7spnTjZVnlhGwZgMLZS+nZ8Ryx4T78GZXD6iIyqyjqbKC4mpK6pbQdfpaFmz6KQJi5NUebaYSKVDrB8dd/QjI+yoLLPoZwu/V1E6ksatr+U1Ssv9KwTXYfejxL8yn8DdMRLpc5MDljyfZOXCWFSHlBU/4gzRIdA/hqSjDG6BpBJDkaJzkSJ1SbO7BWH59oNM5wR5SquYWOSeXUsufejSUZNSstzoMlGnK0dI+gpGX8NUXmmBdDLIuigJxMk2jppPCGi7MqjEIWVjKmyDLx1jPnfPznYyLH8/3NbD9l52Z/EoG4OexbQAj490mU/RhwyDI9ZiwQb2kmPTZKaOES/eYxuYQwzCv2T20+HYvR9PD/0PbMzxFuLzOu/wjz7vl7qlZfiS+/BF9eEfnT5lC2aCO1F97EzOs/wvx7/p6Seavp2PIIJx/4CiMtR9RslJa6wT5vVYRyqkBYtsNeNm/GHBo+9ClSw0O0/eDrxHu6DQHBwrGOXMdj/K5vb30QKALvtFqSnd2QyOG7tkVMghxPIJyyaBpMU156XzpG0ZJaQpV5ph5DxmRexrdZDVg69vVy33tforwxn48/dikXf2QWBaVeNXhWSmUCc9VgXElkA2u1ZcbJaZlHpAn6YePdtfzV05u46i/nc/DxNr599bO89q1DpMdi5mDdTKCuW8p+5pX4uOib15EajXHkS88D2QR0AjLdoiF/QQ0l166h67tPQDyWDcoVip5wLu+yjchjYcK79+l5W/QJEJIgf/kqRvfvQhu3yMl94i2rwltUzvDpA7n/RgeFBKBu0ZWM9jUz3HvKVMZazhZHIiAtpzjxxs+JjfUz/5I/wxMqtKssOeoDGDl9AHcwn2DtDNP5WLeNNp8i0DjLpjqq+1KTynlqLflZMjeREJA0jDlkUlky87GuIQDya/OZyHqODSMkqJ5jyJx7HpBitWQshSdgfu9Vg24lPfjWaJH2YYRLwlNeqC+zuoYAEmd7UJIpvDNrM8sddq5A6mwXSmzinoVT9qdlf3TQIoS4WAihTHJalqOOfwXeBfyloii7J7HbbwOLLNONgN6wjh3YR2BGI55Qfu4A3FyNfqYxlhNxWn73A1KxCPPu+XsarryH/Lo5qqxvrMsyuTx+qla/g3nv+ltCVTNoeerHNP3220R6ztjgwAgnVjXICaTGBReHst6Scuo/+Em8ZRWc+cF/M3bssKFu9Yk/GXAZV0w2HI+3bhrIMon2LjPwGOu3Lo4lkfxex4HYwJDDIi3T/fJxqi+b61jOqLJo20lC4cRzbTz4Z1tYeFUtd/73agKhbHp0FWwUHVTM4JLCI1K4kE2TttwjUibA0aaAV2HDnTX89VMXcM1nF3D4qTP85I6X6D7Yq/c40noZWcElVOxjw39eRc+2Ftru26FnzjX2KBJCofqeixEC+n79IpI+NhG6a8OVHyDvorWMPLcZRZHNbo9MuYIVq0j0dhPvPGMDDw0GhBAUzlqqdn22Qg0YthP6dw0+/IWVlDWs5PSOBwgPdZi2M4GKpa60kubk1l8SGepk/iUfxZdXYirj1BPJ7hraR8HsJVm3qAO4pMZGSXR3EWiclfOYkmc78Rp7Dlks0TWAtyZ7fEaVRQiFSPswnjwv3gK/qYzLUpcLme7jw5TNyMeTI+7kzQJM2qCkpJFIRlO4/JMX6yMdw/gqCxAuydRTSAGD0iKIn+7AVVKAuzDf/pw1qC3RYydxlToE6P8h7HwGS5waNPG87I8OWoDjwIcnOdkcmkKIfwL+Afh7RVH+ZzI7VBSlR1GUw8YJOK0XSKYYPbifvMXLTDeNVW0ZT81IRcI0P/pdUuERZt50L55QYbb7mwU0ck3eQAHTNt3G3Dv/GrcvyKmHvk7v3s1m1QUHCMkFLmDatw1ccC7r8vmpvfP9FK29kI5f/5iep3+LnEgaygkzNFnr0b7b9m9XsFzBEO7yMuKnmw3bmmViqympNLgmvrTHTvaQHIpStakxG79icA05qSzdh/t58m+3s+lj87jm7xfj8ahqjKauGNUTDVS0rtCTTTSX7T5trtPvVVh3azWffPQCZqwu4efvf409vzqBm9S44FI6q5iVf38pJ368naE9LSpgZbpla92g3UEPNR+7hqGntxNv6jC8/WfVlvwrLyTZ3Uf02AlTg679He7SUvz10xk5uMfWHdjYuBfMWky09yzJsWHzeqvC4sCcM1feSl5ZA0de+R6RkW479GjbGepqP/w8o33NzL/kz/AXlJl6EWnlrUqP0TWUio0Rbm+icPZSR5eQtq9o62l1eI/aaXYoEaBgGCjRsFyA3l0/0dmPr7rEUWUBteEP1hbq312mcrKpu3P38SHHpHLnkwXXaMlICk9wYmjR3D/R9iECNUVmsdVBaYmdPIuvcVpmofFCQv8UiiB27CS+6fVvwZm8eRMKCPk8pilmOWf7o4MWRVE6FUX54SSnAeO2GWD5Z+CfFUX5wltzQDB2+CBKKkn+ouX2XkK2NwHLeiAxOkjTQ/+DnEzQeMsn8IaKHGHFVo91ytQbKKpg+jveR90ld9K14xnanv4pcixiKmtVed4UuDgBhrUsEuWXXEPtuz7M6KG9nPnRN0j09Tq7i6zgYn6W59ynVi6wcB6RA0cQVljJfFcs5+cqCpEeHlOLWB4OxgYg3j+KK+jFW2Qe/dbJJKGgpNI8+y+7mXflNC74wCzckqIDiwYpRlgxgopXpPCKFC5hVlask1bODDFmd1NeSHDnFxZyy78sYvM3jvC7v9mBHM66i5zApeHS6TTetogD//4cqcFRPYeLIJt4rnBlI3mr59B33/OOaou7pIDg8oWMvbrN3NDrqgvkLVrC2LFD6C4i/U9GLxOoqMXlCzDaedrRtWPcxgQYAoTHw+x17yK/bAZHX/0h8eiwqW6r+hIZ6qTj2Gamr7qFQKEh5wdavQaVxbA/o422HUfy+QnWTnfch7ZNtK2ZQMN0hNugbBjgJT00ghyJZsccspgcjardnTNKi5bRWJsHtfdNNgh3/Javv2mU8lkTu5HO1eIjSfwF3pyBu7IiTAG6kTMD+KeVGNarn6rqos1D7HgbvjkN9ngWY93RGLGTp/E3Og+V8Hu3KaXlbbM/Omg5VxNCfB4VWP5NUZR/ecsqVmB4x1byl6zAlUnzbW1khWXeCA/x/m6afvNN3IEQjbd8QldYcrljjPVZJyuUlM5ZxexbPklsoIsTD36NWO9ZZ2Ujx/Y5wcW6veG7FULyGucx/c8+gysYou17/8XooX2G32ECcHG6bx3UluCSRcRPNZEeC5uOx9EUgauogNTAaHaRJehPs8RABF9JNhW6MZ7FmmXUhczOnxwl3BvlHZ9Th3DQXEJWYNHiXlzIGQBJIWGIaxEKXpG2TS6TEpOFGCu8aNPam6q59771dB0b4mfv3Ez/qWFHcNFyzCz7+BoCFXkc/MKzIGcT2WmKiyTJVL3rYiIHmogeaTGrLRqUbFpH9MARksODGF1D2hRasIjU4ACJnk6TEmNSNiSJUG0j4fZTNsXG/Fc6SC2AkFzMXv9uvIFCjr36Q5LJqP0SEhAb6+f0zt9QVD2fkrqlzseCBZSs8wJGWo+S3zAXIbmcy2XqiLWogyTaymS+Jzs6we3CXVmmLzOOPp7UujvXFjuet5RxD4VqCsYFFm3dcEeE4tpgznKTtXQmRsVqsZEE/kJvpowaw6J9WuNZZASRs4ME6kpM622ZcEcjJDt68c9pyL6QQBZcFFVliR49gZBceBveHqVlyt4++5OAFiHEXwH/D3gGeFIIsc44nU/dyYF+Ys2nKVy1zjkmBMO8ZX2sp52mB79JoGIaM274CC5vQAcWK4iY4MShTnAGmGBJNXNu/RSB8mmcfPgbDBzZZj8WLMdt+e4ELrZ1lvXGfbhD+Ux750co3nAJnQ/9gp4nH0FOpuxxLjnAxaa2WORg34wZSIEA0YNHzbCi12F+QLpLCkgPjOT8TzVLDozhLZncQ32gaYRtPzjKFZ9dQn6JV4WVTAyLFVg0ZcUlZCRkHVKM8SuSYVttMisuKshosJILXurnhfiL36yjcnY+P3v3y5zd2WUHl0z2XK9XsPZfLmP4WA+t9+9UzyET26JlCw7NLKfggoX0P/AiIuMuExJq3hZJwTd/Bu6KUsZe3+EYkOsuLcVbVc3Y0YN2F5H2KSA0bRZj7aftP7RDY29drwiQ3B7mXfhBFEXm+Os/JS0nUYTaC2u4+wTHX/sJ+576TxRFYfqqWxCSvdHVB1QE27FqriE5nWK0+Qj5MxfmjJlBqAH28a4O/NNnmi9Jw/kkz3biqalEuF1YeUwIhWRnH66CIO68AJIBZoyuokjHCHnT7IMfWnsSpeMpIoMJCqrVFy3tWjVuc66mgUZ0OIGvYPyAd628nEgR6xzGP61UX26MY9Gm2ImzCI8bb0MmWNmmrqpT9OAR/PNmZ3uA/aHN+nw+l2nKzsn+JKAFuD7z+Q5gq8N0zjZ2aD++mmn4azJEb2nMrQ28Ni+nEpx5+hfk1c6i4R3vRXJ5TcCi1eWkophgCEz7tQIMihqoO/3ye6hedx1nX3mI9pcfgnQ6N4TkAJfx3Ejjqi4KCCFRdtGV1L37o4we3s+ZH3+TRH+/Lc5lQnDBvl6SXAQWzSdy4FDWReTgV9BkZldxPqnBUZMC6zQmSrw/jK9UVVqsD31r7ovdvzhGzZISFl9TY1rvQrEBiwYrHk1BQYOStF7eSWnRFRfMwbsTwUt+gcQ9/72E1bfX8+BfbKdrf49eRht5WgOXorp8Vn72Ik79ZDvDB8/qbiJjUG7lXRcRPXaG6IHTNrVFSIK8i9YSfn2Hmtpfdw1pnxCav4ix45mkXw7KBUBoWiOJ4T7i4WHt7zMBik0JcVBi3L4g8y76MPGxfo6//jO6Tr7OgWe/ytEtP0JIbhZcei+LrvoU3mChvZ5c7iCra6j1KEo6RX7jQn29UzxL7GwzSBK++uybv/kc1J5DXkPPIWG5sRKGnkOaGXuxyYkU0Z5RQjXmHC3WsgCj3ar6VFgdPOcxhyYyo9LiZFp3Z1DdWsiK7h4yBuEav8dOnME7s1aFERNFZutVZJno4WMEFy5822JD1L/ufFL5vz3H/adgfxLQoijKxYqiiFzT+dQdPnqIwtUbJlZZMH92v/406USM2kvuQAiXGVgmqmu8ZZZJV18QVCy+kFnX38vQyb20PvcLlGQiJ4TY1BhLGadjtKkuDuWDM2Yz/c/+Csnro+17XyXa0mSKc5nQVWQoa9xPcPEiYkdOICcSlt9GfaAZAcVVXJCBFsUx0E97kCYGw3iL7UqL9S00NpLg2DNtrLx7FkIIXWXRYMXkEjKoKzZYMagpEs6xLcbldrXFDC9qvIwaT+OVZK7/7GyWXl/L/R/fRt+xfnN3aCmt55mpv3wmDdfM49AXn0dOJJGEoneFdkkKwfoSii5eQv/9WbXFCCahjStJj0WIHDpihpHMlLdwEfHOdpJDA46uFAT4y6px+YOE209NGNfiZFoZX6iYeRd9iNHeJlr2PUZx7UKWX/u3zNn4HvIrMuP/5KrHCisOgDV0ci/5Mxfi8vlt9RiPM9rajL+2Dsnjyf5WWhldaenKZMK1HocKhImOfny1JY75W0BNgY8CodrCCXO0jHRFEBIUlntM69+qIFxFUYgPJ/AW+GyuI6fuzmNnBnEFPHhK80wKi/qJ/hk73opvdn02zsXw0qM+GwTx5jbkcITggvn/5xSLCXrXnpdX4X+L/UlAy+/VFChYuNzekJNbZRk5eYD+fVuou/Qu3L6gDVhyqStikpMTKGnL86pmMuumTxDpbuX0Y98hHRl1hBAnl5ATxFjLOrmwrN/doQLq3v1R8hev5OzPv2uLczHVbzCjm8i0bwX88+aASyKy5+C4/xUKeCpLIJUm2T2kLs7BrXIijeQdX16WhEzXnm6EEMy9pEpVWMhmztUaAX0MIguwGGFFQqanLcrBN0Z47bf9PPq9Xn7875185ZNt/OfH2/jtD3ppPjCKlEqZtrEDS1p3QRkVF68kc/Pn5zHv4kru/9hWhtvHsr2KLO6iJZ9YSzqW5MxDu3EL2ZwlWChU3HUhsaZOYoea1UZVyk6u/CDBlYsJb91lUh60F2JPTS3uwiLCJ9WBNp3cREgSweoZhLtaTBeAPRDXDB02lQQIFlWz+tYvsObWL1C/5Bp8oWL7pWFRWaxdqq2uIUB1DbUcpXD2UtMxGuFGKxtra8bfMN0Z0gAllSLZ1YOnNtNzKAOAxisz0dFvUlp0lSXzGe0YRvJIhComdmmOdEfJK/OPOzbQuZjW7Tk2miadlAkUZcYH03Oz2Ed9VhRBuKWfQH2pPoikMQhX/QQlmSJ+6iz+uQ25XwoViO47iK+hHle+oUv0H9re/kDcvwPWW6b/E2MaTEHLBJa/eAWS12dvzMGxwY/3d3P2uV9TueZK8hvmOQKLVU3J6SJymsYpry0PFFcx55ZPoqTTnHzo68T7DTlOxoEnRzeSU1nsqouTu6jy6lsovfgqOh/6BQOvqV2zbeBi3c50jFm1xeX1EVq1krFXt5pdRPq22RbEXVmGFAoQO3k2pwwtKwJPQYDESEz97vA6rnUnHWgZoXRGPi6P+XYxqiwuMuqLA/Ywn3EAAH7rSURBVLBIyIwNJPjGZ1r5s0tP8s/va+EnX+rm1SeH6WyOEQoJ8gsEzz84yKdvaeaO5Uf5x3ua+M03umg/Hja4m7LA4tIDe83BuT6XzO3/uoCqOQU8+LHXSQ5HDKNOZz6lNIF8Dws+vIamX+1SexNJskltCVQXUrB+PoOPv47ODZqCIEFo3XKih46RDof1BlhviCVBcM48xk4dcwx41WGjsp5ozxlzQ5/DbG4cS51CCCSXx7Z8MmqNbqZjFUS6WpBTCfIa5owbzyLLaWLtZ/A1TM8+HvT16m+S7O4BWXbsOSQEKIqSUVpKHbs7C6EQ7RkjUJlvi89xytES7ouTX+7n92WjPREA8ipzA5Txngo39RGcXu4YhJvt6tyOkkrjmzPdQpLqh1AEiqwQ3nuA4LKl2efF22EKavbpc53OH7ZOKoqyzTKNnXet/wtsClomsIIlKx2hw6nBT8djtD3+E0K1jVSsusLWKDspGE7QMCmVJccyUJd5goXMuvFj+EurOfnINxg7c9y2rdO8tn2u+sd1FxmXKSAQlG64jOqb303/S0/R89QjKKn0hOBi/H2Mn/kXrCfe3EriTIepnNHnrWRaN9/sOmInz2aWGddlPz2FAZLD5p4nTjbQPErJjIKsWygDJJoZ3ULq9yywCCXNy4/087ErT9J0OMaX72/gyeNzeHDbTL73eD1f+FEtn/mPSv76i5X89PnpPLxzJn/3X1U0zvOy7cVRPnHtab7y5630NEcMrqcssLh0F1G2d1LAp3DPfy/B7ZV45FPbkGPJbGBuJr7FLaVpvG42odpCTv1oq567xai2lN28nvDeUyTbuxGSnE23LxT8CxuR8oKE9+zPQodhCs6dR7T5JHIqaVYeDPOBymnE+jqQ04Zsxw5KiqM5wJA2b1drsKssTgBi2f9o6zGCVQ24/EF9nVP9id5OlEQCf12D+XgM9Sbbu5Dy83AV5uvrjMG48ugYciSOr1YNVHXqHRTtGiFQkc1uq/VwU8ubXZrh/hihUp+tjvMxI4SMdUeR3BKBYjsYWXsPyQjCzSq0ANnAW+O8IogeacHbUI0UzPzexpeRzDMg0XKG9OAQoaVL3ta4kPOLZ8nk55qyc7IpaJnAXP6gIxhYwUGRFdqf/TWKLFN/xbsQSOgBV5No/CertDgBTC64cLl9zLjifZTOW0vTEz9g8Mh2XfmxAcZEcJJjfyZ3EQ7Hg+pem/buexk9uIeOB36CHI+PCy4mN5HhgeWrrsY3cwajWxzUFjD5wH2zphE7cdYGLMYB2twFAZIjUccgXaMNNI9QNsM+lpEaVJtN6KWpLBqwdLVE+ef3NPHtf+jglg+W8O3HG1ixxofXlVVprL2GysvgoneE+MTny/jB43X89wN1DPamuPeqU/zP584w1Bk1xbwYP43gkl8g8YHvrmC4PcIz/7QTN+p6tx7gK+Nxw9K/WM/Zp48QPt1li23Jn1tFcEE9Q4+/YRrUTwgQbheh1csI79hjasy1vyPYOFsNmGw7bYMVbQpU1KHIaaKD3TYlYzylxOnvsikhkzTjfqxKymjbMfKmz3NUgkzxLGdacRcV4y4ssAOXQA/C9UyrssGK9psmOvoBdXRnwyEAhhT+PaMEq/JNy4xmTCwX7o+TV3bu0JIeR8NIIzHaFSGvIoAiXLbuzppp8CInUkTODhKcUT5uPEv0SDP++TOyy63PWyCy9wC+GdNxFxWZlv8vtkYhxELLZB/h0m7fEkKkhBAjQohnhRAX/N6P9I/EpqBlAnNSFpwgoW/nS4y2Hmf6te83dW0eD1DeaqXFab0kJGrX38C0DTdx5uXf0LX9GZDlnMdjAxfs8+OeF87rg/UzafjAJ0n0dHH2Z99BTiQcwUXfn/H3N/wP+ResJ7xzD3IkZn5g6QCjtpq+WfXEWzpJx1P6m5xRllbQlJaYXoUTvCiKwmCz6h4az4wqC8CTP+nmU9ecQADfeWom7/p4CX6v3aXkJdujSO9ZRDqzXGbFGg9ff6CGL/y4luajMT5y2Sl+9K/tREeSSMh4MxBiBBcNXkqqfLz32ys5sbmLw79t1uNbNDeRJGRqVlVTtXE6x7/9KhJpu9py0zpGthwgPTSSHQE64/IIrl9OoqmV1MCAvkz7w4TfT6B+BuGTR9Xf0aj2Zz5doTw8+cWqi8j4m9sAQZiUEt0mocTkAhmn2JjscQqS4RFifR3kNRiGeLDsX49nOdOKv77BdtEa602e6VDT92tFLNCR7OzHXVaA5PNg9P5o5SShEOseI1CZN6kcLeG+GHllb517KG2JVRnpjo7vGjKUH20dBFkhMKMss05dbotnOdGmQot2L4N+j2ddQ/sJaiqLsdwf2t66mJbHsI9797Fx9jwMfB34M+AS4JNAHfCyEOKq39fp/jHZFLRMZJYG2KmhjnS00v3GU9Rddif+kmqMcSyOSoLsXM9bobTkgpuyhRuZcdX76d3/Cmde/LW5Z9E420+mbqOqMp7q4i2toP4Df0FqdISu396PkpZt4OL8O2TVltDSJQivh7Htuyz/kVFxEXhnToN0mnhThymuxRiU6y4IkhhUffPmN0T1tkgrgkhflEQ4ZYIWc36V7AlrKsu+V4b46X90cu+/VPMfv6ijfqbb1C1aAxWtS3JWcbF/d6HgEzIbNvn43u+m8Xdfq2LXy2N85uZT9LdFdaXFCC7GmJf6+SGu/NQcnvvSQcLtIxk1RXUTafCy5ONrGTzQSf8bp01qiySgcM1sPBWFDD+7Xf8zhaR+eqfX4C4vZWz3PpOCYnQRhU+OH9cSqJhGtKfNvK1m47RH48asWJdNxjVk2Wb0zHFc/hCByjrneBbDecTOtOCrb3CuT4CCQuJsB966Gsu+Ff2GSXT04zOMOeTUeyjaPUqwMmRb7mTn6h4ywoasSLbEctp9MtYTJVRhzyRt7TmkKIJwUx+e4iCeopBjPIuiiGw8y9zphvvd4hpqbtNdQxifG2+HvXXQciP2ce++nXu3yl5FUT6lKMpvFUV5VVGUnwAbgE7gS7/fk/7jsClomYQZG2UNOrQbSU4maX/+formLKdo9nJzY24oNx70ZL9Pwg867vbO89r3woaFzLrxY4y1n+LUI/9DcqTfEVxyqi4TwMtkVBd3qIDaOz9I5NQxep58xDE41+omMq4XLjf5my5k5NnNKPGUDWo0WdkVCuBrnEZ49wnTM8Kouvhri0mNxoj1R/T/2qq2pBOqcmIdzdZoWgCuZs/+qpdNNxZx1R3FuCVzHhdzN2mjuiLrn9q8EWw0eLnsmgDff7yOmnoPf31HE61Ho5h7FBmDc9XPC+6pp2Z+Ic/9+16Tm0iDl+KGAmbctICTP9qKJKfM6f3dCqXXr2X4+d2QSugBuWpPIkFw1RIiew7oYKArGAKCs+eS7O8lOTxgbswN84GKOqK97fYfdQKlxKmsdX6ibW3gYzi2cEcTodqZCEkylbfCSzoaIdnfh7+uISv8WRSX9PAI8mgYT311drlJTYFEez/eHEG4EgpKWibWN0aw0jBiM9lcQlaLDiUJFk2c+O1cbbBllMJp+ZZRnQ3AY4CX4aOd5M2pMoMK2XsRIHLwNN4ZNUjBoDkLrvapwNiOPfgaZ+IpLDI9L/6X22nruHeKovS8mQoURRkCngCWCCEmHpPkf7lNQcsEZlURrKpDz9ZnScci1Fx4cwZolJwNupNioZa3A0lupcVePpca4gQ1wbI65tz6l0geHyce/BpjbcfHrWuykJRzvWaGdf7KWmrv/jAjB3bR9/wTJnCx/WbY91W46UKUZJLwzr2WB5uh5VQguGYh4e2HVW+Y4QEpK+p3f0M5ktfN8PGejP/d/NAFcAXVB38inJzwWpGETGQ4wf7XxrjkhkJLYG4WWAATsGTdNdnJY4AaL7IJXvLz4As/rGbZuiCfu7uZozvHMkG5sklx0VxAPpfMrf88n5ad/Zx4pi2bul8oeu6WBe9dRqR9mJ5XTuhqi5Ylt+TSxSiJFOEdRy0BuRBcvYRkWzvJvj69Mdb+Rk9VFa5QHpHmkzZY0eYDldOI9XeSltNm6DHaRN8tdYIDkDiVN5gVRiKdLQRrZjgqQMZjjHeeAUnCW1PjvF8BybMd4HbhqSo33RQCzAMlZoJwncAl3h9GSSsEKrWYFnPgrVHxUxSF2GgSf745R8v5muYiSiYUeo4NUrHQPsKyUxDu6JFO8ubVZo7NMLqz/iIB0YOnCSyeZXsJAVTXUCJFZM9e8lavsj973g47n55D2vTWmvaj/+/HuAlsClomMgOwWFWUSGcrfbs3U3vJ7bh9IZwCb3N9agDi1OiPNzkBzERKiXXe689n1rV/RsnsVTQ98X26djxryqCbC7AmgqRx12P+Hpw2g9rb38/Q9i0MvPpizrrMk/p2JXl95K1fw+jLr2W7D1rUFkURBFcvJNk1QKK12zGuRbhdhGZVMHKsS12GfdwUb1B98EfD6UldLtufGyaYL7F0fcihl5EZWPRxjnCejDBjhBePSBPyyvzT18u4/KZ8Pv/eVna9OGJyFalDB2S7Q1c3hrj4wzN57ksHSY1ETblbXEIhVBZg5i2LOP2TbQg5hchAjUuScQc9FF60kJEXd2eARdGzuXrqq3BXlBLee8DQwKvwIlwSgVmzCTedMPEkZBt+f8U0FDlNrK/D9lua3UpCByKn9eOZFUhy1aHNp2Jh4oPdBKunmytygKfY2TP4qqqzSeWMdWpAcrYTT01VdiBFgSkYFzlNsnMAX02pKYbFaPFedSytQEVowgy3ckLNoeLPf3Mp7nW3qAPpaRCfRqL3xBCpWJqKxRWkMyebKwg3HU0y1tRL/oKazP2nrs/2GoL0aIz4qbMEFs023Mdm11D06AnkeIK8xYvNLzdv6gzfOhOcZ++ht5AthBDFwHXAPkVRYhOV/99uU9AyCXMCDjmZpP1Z1S1UOGORHR5k+3bZTwUhK2ZQMbiSxldanBSNLLyMp7qQOS4UNTV+7YYbmX75PfQe2MLp332X1NiQI7g4qSrntB7z99DMuVTfcg/9m59hcPurJjAx/V7Y68vfuIFkRxfxk03ZdwsD3KCAp6IUb0M1Y9sOZ13JYMrVkjenipFj3Xa3UEZ5cXldSG6JRCTFZOz1JwfZcFUBXo/W+GRVFjADiz4/zuTJbKsBjHHYAI8En/6XEu7+aAn/dm8bmx8e1INzjbEtWnzLJR+eQbDIw+avHUQbfVpLNueW0iy4Zwmx/jDdLxzT1RghFFySQvGVK4gcaiHZ1adnyNVdRCvNLiJTXMusOUSbTqIosq1RVwS4g3n4iisIdzWbfsfJKiVO4OK4rciAj0MdZhVFEOluRbhc+CunOas/BvCJdZzBV1tnqEuxnKOSDcK1wIo+UGLvkBrPUZsdlwfMOVpiPWN4Cnx4x3FT6qrMqKoK+icxLlAuM6qO1iDcjv39FNbl6d2dbYMjZsorimDoWDcAobnV5kB4g6socqgZ4fXgnVWf0zUU2bufwPx5SP6A+bnwf8yEEPcJIb4ohLgtkx33w6hD1VQCf/02H94fxKagZQIzNaByFgSsbqFckOAELE6qwmRUlvEUDWPduYDCaZ9FM5cy99ZPo6SSHH/gq4y2HDHXY4QvefxjmHC99iAi+z1/7hKqrr+T3md+y8iB3Rl4E2bw09o7DWpk8JSUEli0gNHNryEc387UB2No7ULGth8x5YMwTqG51Ywc60KWDV00yT5cZQTekJtEOKU/vK1ZPzUb7UtwaOsYF15XaFtnHqdIyWbS1WBGUzYcJg1gbLAjZNwCPvipQj7++Qq+/rl2djwzoOZyQTEM0KiqLwGfws3/vIgDv22jY2eX7j7SlJlAsZ8ZNyyg5YHdCEULxlXBJW9OJb7plYxu3qMqLZKSBRPNRdTfD0Ix/Q2Bxtmkw2PqqM/6TYUJGII1Mwh3GLpGj+e6cbDzVl+0Y8pYpLOFQEUdkmUwPiu8KALiZ9vw1dWZ63BQWrx1NdldGW4Erbuz8LjwVWhjChlvFNVivaOmHC3jWWw0AYC/YPJKi9M1nSsIt+NAP1VLyux1YE8cN3y4k9D0MoRfDQrW4ln0eQWiB0/iXzAD4XJjVFHUZ4RAjieJHDxM3vJl+vrs82DSp/jWmvr2cx7TOe/5AHAV8EPgBeDfgSPABkVRXngrTu2P3aagZSJzUEwi7c2ObiFNLdE/jY25bFZDcoGHCRYc1Bch27cxg0Fu1cURaGTw55cy+4ZPUDpvDc1P/YizWx5BTsTGhY+J4MRpvWkd2e+FS1ZTdum1dD/+IPGujkxZ5x5FRqgpuPACIgcOk+zuyz4EMr+ZIqsPt+DqRSTbe4k1d5pcRJpMHZpbTWo0RvjssB7XYo1v8eZ5iI6ob6/jgcu+V0bIK3KxYLXaw8OorjiZhAFOGGcywIuHTI4VoQbsajB0+3vzeO+nSvna37TT2xLJpvbPDOCouYnmrCpk5a31PPtve5FSSZvaMvvOxYTbhhja3ZKNexEKkgTFVyxjePNekNOZeAwVXjQXUcSUaE5tWdzFxXjKygk3nbDBijYfqm0k3NGsqjHY12vfbS4iC0BY3UDacps5lDPuM9LVanYNOdUtIDU2SmpkGF9tXfYftiguciJBqqcPT0ZpydaRvSaSHX14q0sQLknv7qwV1XO09IYJlE8WWtRr1RfKHdOSC7xz5WfRrvu0DB37+qhaWu4YhGuCfgQjRzrIm+8cz6IooMgQPXCKwKJZGOQpE7xEDx8DWSY4f4Hjs/Jtsbeu99Cb3K3yRUVRliuKUqQoiltRlApFUW5RFGXnW3yGf7Q2BS2TMQOIpCNhzjz1S4rnr9bdQo5wYYIMxQYiVsgxKSpy9sLWAnud1BbH73r9ZheUTTWxHK8kuahZex2N13yEkZYjHP/1lxk5fcCU08URuGTn83bah/n4DL+tAiXrLiY0az7tv/4RqdFRHVxygQ8K+GfNwjdjOkO/ewYhO6stnupy/PNnMPz0dpuLKC1LeKtL8FcX0vtGk/7ANSouaUVQPL2QvpPDEyahi4bTFJV5cLmy5YwJv4xKiQYs2nJQb0anyeMAL1pdRnB598eLWLw6wJc/dRY5mQ3MNbqJJCFzzV82Eh1OsPu+kza1paAqSM3FM2h7eB9uzSWV6f5csmkh8liM6IFTppwtQhIEVywmsveQWS3RlJjGOUTGiWsJ1c0iHQsT7e+0wcdklZNxzQl4sByHtkxRiPSexV9ZN6HqE+88g3C78VZVmdcZPpMdXaAoeOvNYw5p8+pAiX14Da4hTYkxKjKq0pLt7qzBpDWFP0A6rl5zbt/4j3cV0CWH8YIs3w0/Qn/TCGPdUerWVFq2sce0KGmZ4YPtFCypyxHPIki295LqHcK/ZK7e808DEU1BjezcQ3DRIiSvH6PKoj973g57m6BlyqagZWKzNLQdzz+I5PFSe1HWLZQTDIzAkqPhVpePDylGiEExrJft+7SDg2LZl/OxassLaucw746/pqhxKS3P/ZzmJ35IYrDHDh/jwckkXEpWcJGQqL7hblzBEB33/wQ5kcycozBvg1aPQEJQfP21RPbuJ95yJvsA09QWBRRZkH/5Wsa2HiQdjiPLErIskZalzENUonj9bHpfO2VQYbLAIisSZQtK6T4ymKla5FRbnMYv0iyX2qICjHojukTuyQovTuDil2Q+9+UKejuT/Pq/uvQRoI1uIo9Ik1/k4dJ7Z7HtxyeQIzGT2iIJhdl3LKJ3eyuRswOm7s+ewgD5a+YwsnmPnqsFAUgKgZWLSLSeITU4aIYTAYHZc4i2NplS+huBwZNfhK+4gtEzJ0y/zXhxLePGvIynsljKGOtThCA5OogcjxIorx23PALiHe14K6sRLpd9n5nP5NkOXKXFSMGASV0xVpdot485ZDRJKMR6x/BnlJbxkssBpJMyLo+kD05oWjfONWpcp7mGjPEsaSRaXu+iqD6f/GmFpky4mmlKpaIIhk/2kg7HyV9Spy+TDcACEN5zAndVKZ7KMttLCgqkx8JEjhwlb+WK7HPE8nyZsv9bNgUtE5ixgR05fZiR04eov/LdSC5f1i1kuJEmAhYrrKQiowy2H+HMwWc4tuVHHH/jF7Tuf4KuU28w2HmM6EgPcippVmOMSsy4wKTtz0F1cTgurbF3u33Urrueebf9FUo6xfH7v0zX1iezLiMbdNlBxnF9rrw1qPMut5fa2z9AaniAnt/9Ru8Kbfx9jWCELPBPn05wySIGf/skpLX1mRZTVj+DK+YjvB5GXj1oU1tkRVC8cQ4jRzqIDURsLiJZEZTNL6X3xBBJQyyu9oC3qi8TvUAZVRYNWEAFE3BWWrT1GryMBy5V5YLPfaWCR340wIHXRrMBuULJ9GZSlZe1t9fi9knsfeC0SW3xSGkqFpVTNK+c9kf3mbo/uySF4suWMrbrOPJYWBUiJFUt8M6oxVVSRHj/IdDjXRQUwN/YiJJOEzvbYldiUD/z6ucwdvak4zrIApAtOZyhjG0+hzm5kTSL9p1F8njxlpRNHITbeRZfTa1JOTHWrwhFjWeZVm07HyDb3bm9z9bd2ZijBTT3UMgRWKzdn1VoeSskqqxp13nza13Ub6i2r3eIZxnce5ZAfSnu4vysWwiz2BDZe5zgsrkGYDG7hiK7DyAFgwRmz3V+br1d4bh/fF2e/8/YFLRMZJmbQ04m6Xr5t5Qu2UigrFZ3Czm6e5TcwIKs0N+2j5Nv/IK9T3yBXY//Cye2/oKRntME8srweINEhjrpPPkqx9/4Kfue/TI7fvt5Tmz7JSPdp1EsvY4c4SUHLJhUF6e4GwsUBIqqaLzuo9RfejeDx3Zy/NdfYvjkvqzLKOe5Z+uxKz/2ef2Zq4A3v4jaOz7I6NED2a7QsnA8Tm2/xddeQ/x0M7HDx1VlhuyxKQrg8pB34QpGXtrtHIw7rxZPYZCeHC6iknmlpGJpepvGTMGJGrhob6MOL7aTMiOwALgskxFgxgMXLTh3w8UBbn5vEV/9zFnGBhKZmJZUZqRoNSg36IdNH5jJjp+fQonGs+n9UXBJMPuORZx95ihyOKp3fxZCoXDlDNz5QUZfP2jI2aIgXILgikVE9x60gYkrEMA/rZ7w6ePZ28oCJ3n1cwh3NpG2Dp6olXUwpzgT2zoNdCx1muYN20Z7O/CX1SCE+dHoGITb2Y63dpq9LsNn4myHGs9C9vowDZQYjZIaHMNXaw9s1feVlon3RwhW5E6bb7R0SraNSG5a79DQZyFcMqkrRrUlNpaifW8f9RurJxXPMrT/jO4aAkz3HEB6LEbseBv+pfNsvYY011B4527yli9DklzmZ0omtk2JvV09fM93sMQJ3m6mLKdNQcsEpjXGfbtfIZ2IU7X2HTYJ06ogmLozy9kpOtjJkc3f4dT2XyOEi5q5F7Pk0k+y9sZ/Y/GmjzNjyY00Lr+VBRd8mBVXfpZ1N36Ble/4e+auvQc5leDwlu+x/7mv0HniVVKxiKkR19QXJyAxw9ObjHVBUDJzOfPu/CzFjctoe+FXnHr0f4h0tugQZD53+3zOfcjG488uD1TVUX3jO+nf/DSjh/frb2Cm+kBf7i2vIG/tGgYfewolLWeAxay25F28ikRzB7HTHfaAXMlF8bpZ9L122tFFFCoPEiwL0HV4MCOHZ+MA0mRT/iu5WteMjTtmTObT5bDOZVg+HrgYE9Ld+9liSsrcfPOzZxGKOhyAMSjXhcLa22txuQX7fpNVW7QsufWXzcQd8ND5zOFsMjpJRnILCi9ezOjLe3Vg0VSVwMpFxE+3kB4ZMasUAgKzzHEtGP4iBASnqWpMpKvFHvcCOdWVSce8CHNZx+0ERPva8RtdQ5bttPNJR8KkBgfw1dTamx9NcVFkkmc7Hccc0j61gRKN7iHJ8pkYiqKkZd09NJFp7iGrmboxG11BBmDRyzq4htp29CBcgurlVZZ6zSqLrAhSSZmRg2cpWFqfWe7Q1Xn/aYTXjd+Uuj87JXv6ibe0krdypX7PZ59P6ovM8K5tk/pNpuxPx6agZRKWHBqgd8cLVK+/BpcnYHYLWdQNK7CgQDIyQtPOBznw7H/hcnlZeuVnmLP6bqpnbCCvaBoufUToTExLZpIUgd9fSGn1Ahasfz8rr/ocpTWLaD/+Erue/H+c3H4fsZFeC5hk4SWXMmFTXRyUD5vLyOOnZt31zLvzs3hDhZx65Bs0P/VjYr3t+jlPpKyMq+xYPgvmLaVs09V0PfIrIs2n9DcrHRINsIMsKLrqSlJ9/Yy+YhgB2tCTyFNVgW/+DIae3o4sC3VShB7fUnLBHAb3tBIbitpcRCnZRcWiMs7s6SVN1tevBTFq4OLxSUTDsu1h72Saa8gQs6uDiUsI54ms8pILXLTU/wEffP4blezfGualB/oyGXKzQbkekSIYgIs+MIPtPzsJsbjuRpJQ8HoFM25awJnfHkDI2e7PkoDSy5YQO91Jok3tNq25iHyz6pHy80wuIkVSXUTBOXOId7aTCo/a1A5FgMsXIFhVz+iZY2alhuynyUVkMCuAjBvvYjHrtrHedvwVtTblxlo2pmXCrTK4Siznle4fRIkn8GjuIQ1aDeCS7OjDVRjCk692CbYCC0CiL5NYrmxySoucUoOjJ7I0YtwYF72+zIk3vdrJtNUVuP3unPEsoALJ6PFu0tEkeYsbsnEsaI8nobuGAotmIVweHUSM8BLesRtPZSXemmmm+1l7ZsmxOKNH9k/qN3nLbSoQ922zKWiZyGSFjs2PECivpXj+GrNbyBRngk1xSCcTnD34LPue/A/G+tuYf8EHWbDxgwSDZTbVAwVE2qzM6FNanfyBYhrmv4NVV/0989bcQyIyxN7nv0LTrodIRoYtMJAN6s3tEppYdbG6jPz5pUy//D3MueVTKOk0J37zVVqe/TnxgS7zuYwTjJtL2bEuK91wGYXL19H54M9IDg5kzkE4bufJL6D4+msYevxp0kMj2YegoVdR4XUXMfbafhLdgza1JW/ZTDzFITqePuLoImq4pJ6mze0k4nI2SNEQ1yIjMW1+iL6OBCMDKWQkW4OQq/eR8SZ0GRpke1yLum48cDG6iWbOcvO+T5fy4y92ExlOqEpLBli0cuturwVF4eBjahdnLUuuJGRm3zyPaPcog7ua9Z4qLkkm0FCGf3YNo6/sBaFkXURuieDKxZauz+rkq29ACgQJnzziDCUC8qcvYKTliPnHGU9RsSgnRoUmu9wBcBxgSBGCVCxCcmwIf5klZsNB5Yl3tOOtqELyeszHZyib6OhCeD24K4rtdRmUFmtSOdOuhEKsP4Ir4MYdmlyyOJdbQk6/uUYxO0ioAcoNaksqqXBqczszL62zuYb0e8UQ19K/o4XQ7Eo8RUGbW0hRQEmmiew+RmDVQsdeQ0paZmzHLvJWr0JC2FQWFBjeu8M0NtQf1FTp6PymKTsnm4KWCWzszAlG245Ru+lWJIuEaXeBZN0zyViYYy99l56m7cxYcTNLLv8UxZVaMJkBFgxgYpVHrZMGNS5clFQtYNEFH2XBuvcxNtjGnmf/k7YDT5GOm91GuVxG1kDd8VUZ63lCqKyOxms+zOwbP0E6Osbx+79M20v3kxwZMB9zjjqdIMW6TCCovPxGvGVVdPzmp8jxRBakZCwwJChYvwF3STFDTzxn6AINyAJFFvgXzcHbUMXgY6+b1BZFESiSi4prltLxxAFSabuLqO7CetJJmeY3uk0uImNcS/3cIG6P4MTBN+9nt7qFrDdmNqYlq7o4gYs1Ad2t7y2ksMTFI9/rRSLbtVmDl1BIsOGe6Wz/6UmkVFKHE4+QCZYGqL14Jmce3a/3LDIG5I5sOQDptJ6vBaEQXL2E+Mlmm4tIuCTyFixk9MgBW+8i7bNg5gLiA93ERgZyuohsaksuocBBzZlIVIgPdAECf1mVcxCu4VjiXe1qEK5hX1ZwSbZ34ampVBtWg3KiFxPZgRIBW44W/bj6w/hLQggh9EESxzPJI0gnLcG54+QXMgKLk6WROLOrl/hokpmbpjlsb3EPIRjY2ULR6pl6V2frqM6Rwy3I8QTBpfOyF4Phno2fbCY9PEzeilX2Z64CSlpmaPsW8hcsH/e3+L1Z5tl67tPbc9h/CjYFLRNY384XKV+2iUBpjaNqkF2WVTXi4SGOvvgtZDnJkss+SWX9aiRFMisbBlAxDppochM5BXAZAEZSBCXl81h68SeZtew2+tv3s/uZL9J5fIs+lpA13iWX0mFNfpcrwNj6AMmrnEHjdffSeM2HifV3cuxX/0HHlkdJhUdsZW31OKhK2jJ9G8lF7S3vIR0eo+fxB1HSiikw11i3wEXJDdcztnUHibOdGXDJPggFEoU3XMLoy7tJ9o/oD9C0LJGWBWVXLiXeM0r/rjZSsub+Ud8m3SEf9RtrOfbMGZuLKI06CY+LhgVBTu2PqNK7AWysqouTLK8pKSblBYHLUNaoujiBi9FNJAkZv1fhfZ8q5YmfDzDUE3dUWzbcXUdsJMHRp9v0MYnUXkNpZt2+kN7trUQ7Bk0BucUXLUCOxIjuP5EZh0hthH1z6nEV5hPedyDrIsr8BaFFS4k0nSAdi9oaekWAt6waT34xo6051BiL5QQXYVnvZA71Rvs78RaWIHl8zuUNxxrvbJ+w51CyvRNPbdW455Do7MdXU+KYm0VPy983hq80aHIZjTf+kMstmaDF2hXfmJ/Fqdu+SW3JnNCJF85St7oSb2HA5BrKwkq2bGwwytiJLopWzbC4hrLjDYV3HMG/oBEpGDSpLNr82PadBObNxZNfYFFpBcgQPnqQ1MgwBQvfJmiZsrfNpqBlIhMSlSuvMOVPMQWQKppyAigQG+rhyAv/g9sbYuFF9+LzFdjVDA1WLCCiNeT6IICy5bsVcDIAJCkSFbXLWX7ZZ2iYfyVnjr3A/pe+zlhviwU+nF1G43WPHreXUWadhKCgdi5zbv4UDZe9m9Ezxzn2yy/Qve1px27STvDnFFejfXcH86m99f2MHtnPcGaMIiELE+hoZYNz5hKYN5fBR9TRo8nEvGhqS2D5fDxVpQz+7g2b2uIqLqB4w2zaHz+AoghSipSBF/XtceaV02l+pZ14JG1yEelwg0Tj4hAn9kfGeWudOIbAUJh4XH2aG+FlXHCxuIk8Is2VNwSoqffw0Ld79B5EmtoiCZnCIol1d9Wz7ccnQFYVFU9mIMWKReUUzimj/bH9poBcb4GP/LVzGdm8FzSlRVIQroyLaLfBRZSBl8Ds2UheL+ETzknohCTIn7GAkZbDlntQ/bAqM7YyuZZbzDHIV0Csrx1/WY2trDUQV47HSfb34bUoLdbPREcXnmlq0Kq155AQoMgyiY5+U2I5fTcGQIn3RwiUhWxlcikuwuNCTtmhJtc1OdG6VFLh1EvtzLwst2sIsoG2/bvacIV8BOfW2t1CCihphciuowStrqHMfS1HY0T2HyB/1SrDcvMzYmDbKxQsXoXbb/9d/iA2FdPyttkUtExglSsvx+X22d/s9QY/Cx3hvjMcefFbhAprmH/hh/F4AjZgsYKBGUiMIGSZDOVM2xjqciluaqZvZMVlnyGUX83BV77N6d0PkYqNWeBjHJeRwzE6KjQ54KV4xhLm3f4ZajfezMCxHRy/7z8ZOrEH5LRZXbFASi5w0coGquuouuZ2ep77HZHTJ9FcQsb/Q61bUHL9dcROnCR26BimoFwZwKWqLS/uJDkYtqktFdcup3/racZ6wtlAXEUiKbuo3VCHkASnXum0uYjSqF1FZyzJ49SBCIqi6HEtacyupGy30NzWcTbNxkt7WbCiiy98aYSREbW0Bi9O4KKuz7qJtN5EXhd88DOlPHP/IL1nYoZ8LSm9J9GF72lguCNC88tnVJhBwS1kXBLMum0hZ58+ghyNmwJyiy9bytjuEyhjY2q7n/kjgmuXEj/VQmpwyOwicrsIzV/E6OH9OV1E+TMXEG4/TSoZd3YRGS3jJnJSVIzLxoUdg0W6zxAwZsLNAUDxrg5QFHw1NVm9w6q4pFKkuvvUHC3aKouakh4aQYkn8VtytFgt3q8qLZM1l1t1D6WV8WFEM9115KCypJE4u7eP2EiC6ZfUO25vigFDMLijhaLl00FymXoNaVPs+BnSI2GCK+ZjuhAy931kz0GEy01wwSIb0KBA9EwLsbMtlKzZNOnf5K238wWWKWg5V5uClgksr7rR9vZvnYQMw+1HOfrSdyiqmsec9e/BLXnQlZFMIK3RBWODFHniC92ULdeoxijmun2efOauuIuFGz/MSF8ze579T9qPv4ySShlgQNHhxelNxtbLKAewOMOLi7K5a9Ru0rNXcual+zn50NcZaztuPn8jmBhcQ0Z4Mu6jcPFqildfSPsDPybW1popJ2wg5K2oJn/jBgZ+8yhyNJ4FnIziEly9BHdZEYMPbrapLcHF0/HXFnP2kb2kZRVYdJ+9z8v0Sxs4+EhTzl5Es1YVMjqY4uShuO4iMpp9NGnn6+6+ByIIAZ//2wIeejTKmgt7+PkvI6Qyb9BGcNHM6iZCmxcyF17uZ84iPw98o9sW2yIJmaJyLytunsa2H5/AZQjG9UhpGq5oRAhB78vH1bgW1Ay5hcun4y7I5GwRalp/ISl4G+twlRYT3r3X1osotGQp4dPHScciZgUl8xmaNgvhcjPadtQOD1bIMZgGLyaIGU/UMuxTEQI5mSDW30mgyrlhNu4v3t2Op6QUye83rzN8Jrt7QZbx1FQ6Hofac2gAJIGnssjRLaTNxwej+N8EtHgyI0Eno2l9mZ5bKJOHxTgZ11tNVgTHnm5j2qpKAkV+m2vImlAulVIY2NFE4ZqZti7OmmtobPthfHMacBUUZJ+joL9gjG3bQWjFciTJrQfgmlSWrS8TapyPv7SSCcJ7puxP0KagZSJTzI2o8e1fi2MZ6TzBiS0/oWr2BcxadScu4cq6YiyNv7mBdYCRtOI8OcCN8Wa2uo9QoLhkFssv/ksa5r+D9hOb2ff8VxhsP6JGrhvqG6+XkQY4bwpeMpPb5aN2zbXMv/NzBIqraXri+5z+3XeJ9pxRz8Oq9BjPw+l3V6DisuspmLeUs/d9n2RvTxZcLNuVXH01igKDjz5lDspVACFR/K5rGXlxJ7GWbmQ5q7bIikTNnevp+N1+IkNxNeeE7CKlSKQVwfw75nN2Zw9dx0dIyi6SijqlM2+aJbUBZq/I45XHhkzBj9a4FlNXUdRkvmmDZNzalmbFMg8fuCePbS9X8vE/y+Mf/3WYS6/uZctrcSALLlY3EWALynUL+OBflbD5sWE6m6J6bItxMMVN72+g6+gQZ3d0Z5QYVXHx+SXqr5rN2ScOZQZWVDPkSm5B4SWLGdm815TWX0iC0PoVhLfvQUExwUdw9hwkn5+xowfMUJKZJI+H/BkLGD59QL39xgUVcoPJBAqN6RM1PwuKrCotxnIOakuipwtvZRXjWbKrGykYQCrMuC80EDEASaJ7EE9pAZInOxqzU9xKYjCKrzgw7v6MFixRY3LCA/FJlTcCjVVlScbSnHj+LHOvm56715Ahdf/QwQ5S4TiFa2ZlQQXDu1daIbz9EKG1i22uIRRIdvcRb24hf/Va04uQpsQk+vsYO3aQ0rWXmIDnD25TvYfeNpuClgnM0S2kN/YQH+nn1Ou/pGr2BTQsvBoJQwNqBRa9YTaASjp7EZvgxDo5ldPUEkOvJSu8SMJFzfQNrLr0byiunMexbT/j6Gs/JDrcY3cZmSALy/pzhxdfqJiGi+9i7m2fQXJ7OfnQf9P+6m+R41EzyFlVF+vvKKtjFFVdcweBmgbaf/NT5HjcDDiZsi5vgPK77mDs9a3Ejp3KBuVm1JbAorkEFs+i//4X1B4OBrWlaNMiPMUhzj5sVltSsouiueVULStnz/2nnANyFYl115XxxpMDJNPC0UWk9zgaRwpoO5OmoV5tzPx+wSc/ns/O1ypZudzLrXf3890fjullreCSKyh39UYfi1cHuP/rWbVFy9siCZmKugALLqti7/2nTMnmJCHTeOM8ho92M9bUowfkuiSF0suXEm/uItHaqbbxkhrfEtqwnGRHF8n2DlVlEaBIINwu8hcvZeTgnty9iOYsZaTlKOlUInMT4qi2ZG9Sh++Yv+cCH61spKcNX3EFLn/Aseu0cdt4TzfeiirT9la1JdXVi7uqXB3/RwcWrYz6PdU9gKeq2DE3izavKArxwcg5QUtkUP39xlNTjMDiZCc3d6DICtMvbjCBNmR7DRmz4Pa9fpqCRdNwF4Ryu4aGxgiuWoTpAsjc6+Edu/FUVeGrqc2qLIYXvcHtW/BV1RKsazTy3x/eFPn8pyk7J5uClonM8gZvbIzTyTgnX/0pwaIaGhZfY27cDW6bbKOs6AqJDiA56s7lhrJCjA1gnOBFVnB7gjQuupHlmz6Foijsf+GrNO//Hel41BKMO4ku0m8CXozHEiyqovHKDzDzHR9kuPkQx+//MqNNhx2gDkOMSrY+7bskJGpufBdKIkG3sUeR8TxkCDTOIX/9Ovrve1B1E8mYgnKLbruK6J7jRI626W6itCwhCxfVd6yj/dE9REcTdrXlzgUcf6qV8EDCFpCbVFysvLqc0cE0+18PO/YiMj/onV1ELa0pGurNHaErK1x8/cvFfO1LRfzrf4xw8lTS1LNIM2NQLmBSWz7w6RK2PDlC2/GISW3RwGX93fWcfKWLaNeoqftzcWMxxQsr6XzykB6QKwmFQF0pgbm1jL68x5TW31NVhndGHWM7dhuUlIyLaNkKoi2nSY4OmRv9TPuVP30eAKNtxxzX2wCG7Hfjz+GosjitExDtPkOg0tk1ZK1TVVoMbh8NMPRjVUh29eCprshZlRCq0uKtKs59kEA6mkROpPG+CWjxBty4/S4iDkqLjDBN4BDTklFZEnGZ7d87zLzrZugup1y9hmRFkJah/41TFK+fnds1tO0QvrnTcRXaXUNKWmZs5y7yV61CGF7+NKhJh8MM799B6ZqLTS+HU/Z/y6agZQJzdFNkgKN524OkkzHmrHs3Ei5nYDEqGRnYyIJGtpxTRlzTZOkxZAIDDWDGg5fMtqH8Khat+xBz19zDYMdh9j77n3Sd3prtIi3b68gNJuPDi5NqgwKF0+Yz//a/pmjmUpqf+TEtz/6c1OiwBfAs9RlgRMjg9oeovfV9jB09wPCO1/UgXOv+S669FkVWGPrds1k3UQaAPPW1BNcuZuDXL5BOo44ArahZcosvXYIr6OPso/tsakvdRQ0Eiv3se6RFdw8lZXfGTSQRLPaxdFMRLz7Un4GarNoC2UykVheRZrGYQle3TH2dU1J/uOfuIBds8PGJvxwinVYc3UTgrLYsX+Nj1UVBfv21rNqi9SjyiDRz1hRSNj2P/Y80q+MUZVxMklCYeeM82p8/jhJP4pLkzKRQfNkyRl49COkUiGxPotCGlYR37kWR0ygSaostgb+hAXdhEaOH9xmAJjtJXi8FM+YzdPpAJkZFuxmzv4FiARfFss66PntDZ+sxLo90txGoMriGrPVktk2NjSJHwngqzUqL9VOHFodj1yzZlYUWYwJbUzbcwQjApJQWY7xUqMRHeDA+oZIyngqz82cniI0kWP3RpZPqNTRyrId41zBF6+eM4xo6nNM1FDvZRHpomNCKleaXtcw0tOsNXIEQBXOXmp4Lb4uZTuxcprfpuP8EbApaJjLL278Wx9J1+GWG2g8zd8P78HhDkwIWDSxMoGKCEOfcLOOVM93Y48GLwVUlKVBWsZAVl/wVNbMuovXQk+x/4WsMdRzNxrucJ7zkcjNp8y63j2nrbmDuTZ8kMdzHsfv/k/7D29AHYzTu0xLXooFLoHIalVfdQs9zjxFtacqUEaZYGZc3QNktNzP66uvm3C0ZxaXo5iuInWgjsudUVm1RBIrLTdXt62h/eA+xsaRZbXG5mXfbPA785iTJhGJTW9JIXHhnFTufH6K3RzEF5FoHl0sjdGDR4lra2tUAyvo6N7Kla6QLgVtI/PeXijl5OsV3vh92vGxzqS0uFD746RK2vTBK08Ex05hELlQIWXdXPfsfbkZJmQNy6y+bCYpC75ZsQK4QCiUXzUOOJYjsUZcjVCUhuGYxcjhK9PgJVWWR1J9euCTyli5n9OAedZmE2VMgoGDOMkaaD5OKhXXQsKotVphxggzjvNM6LRNuYrhPVVqMAIW9fKKnC4TAU25XUTRTZJlUd6+utDh1dwZIdg/irSoyBeFad5sYigIQKPaPO3aV1YLFPsb6EqZlVnCxAotRZRk4E2bHj46y4ZPL8BX4HANwrb2Gul84Sv7CWryVRY6uoeixNtLDYwRXLjT92Xrule271NwseQWGZ476oiEnUwzueo2SVRchCZdZCX47TFHOL55lqsvzOdsUtExgJmDJNOhD7cc5c+ApZq6+g1BhTaYxdQYWoblw0g5BuToEKRngYNxJVWjMEGOFHyG/CXiRPNQ1XsLKS/+G/NLpHN36Uw5v+R5jfW0O5z15eMmV58U2L0OwrI65N32SqhWX0/7ao7Q8/RPS4dGs6mLYjxO4FC9dR9HydbQ/8CMSXV36g04Yfrfg3AUE58+j/1cPoiTTJjeRu7KCvItX0f+Lp5ETaVVtyUwlVy5H8ntofWC3TW1pvHEuyUiK/b9ttaktScXF/I0lVNT5+O0PunW1RQvYNca0aGqL9vcDlJdJeL1w6Ki50TFabY2Lf/3HQr741RGaW1JvSm1ZuNTL2ktDPPzdXlwiq7ZoYLPyxmqS0TRNL54xBeT6gy7qrphFuyEg1yXJuPN8FGyYz8jmPSalxVUQIrB4HuHtu9UD0lxEAvKWrSDecZZ4X7ej2lLQuAh3MI++/a/Y1RYnFcWy3ElN0cy6LNqrjiPkL6+xF7aUTw704i4uQfJ4si/LFjdRengEJZnCXZl75GY5Gic9FsVTUZSzDEBqNIrkc+Pyucctp9ebgY7C2iCDZ1WgNaoouXoNWYHm5a/up2J+MXOvm6GrK9b9GANwUwmZns1HKbtsYRZWwOwaeuMg/vkzVNeQ4VmEov4ekf0HyFu52q6yyDB2ZD9yIk7xkjWmdW+bYnFeKssUtJyPTUHLBJZ921cb4vhwH6df/yXVczdRXrcsq74YstuaGntTzxxjg24AlXT2Qs7lHtIvdAPc6BBjAZiJ4EVzkWjlvb58Zi+5lRWXfBqPJ8DBl7/J8W2/IDrUbQENZ3ixztvPdXx4EbioXHwJc2/+SxKjgxx/4CuMtBxVz8XoLjLEtRjnqy6/mVDDbM7+6vukBgdN5dX/R1B6y20ke3oZeelVm5uo6NYrSY+GGXxym1ltcXuofc9FtD+0i3BvhJQs6WqLO9/PonctZOcPDxOL2tUWxeXixj+v5/lf9dLdKetqi1POFqvaklcguHiTj8ceV4cDsKotoCou774ryKrlXj7zuWEUpzLjqC23vq+IbS+MMtQdN+R2UQEmlOdi6XW17PlNUyZ+JRuQO+umeQwe7CTc0qf2IDIE5Ib3nkIeHNYVGIRCaONKIvsOI0ejejAuAnw11Xiraxg5sNsxIFe4XVSsvYK+/a+SilvUFswgkUtdsbmIrApKZj7S3UagrAbJ47Hc/Ni+J/r78JSU2qHI8JnqHwDAXVqkL7fmaEkNDAPgLS3IVm+RDYRQSI4l8ORlxxyarNpSNquA3lMjbyoIVwOepte7ad7SyYV/vRIFlw7WRtdQ9rs637e1mXQ0SfGmBSZ1Re2ZB0pSJrz9EMF1S1Fkwx+eeR5F9h5AuNyEFizU2Db7rFJgaNfrFC5ahcsbyK7TXmCm7P+UTUHLJEwDASWV4tSrPyOvpI6GRVeb4jSMCkouYLHBirW7sxFOLFPOcmlNkTACy/jwYuzijGFZMFTB/NXvYckFHycVD7Pvha9yYsd9xIZ7x4WX8cHEogIZFROjxKtAoKiKuTd+kpLZK2l+6ke0v/IwSjxuOE7zw0oDFwmJmhvehaeohLP3/QAlFscamOvJL6T0xhsYevJZkp09JjeRFMyj6LYrGXp0M8m+0Qy4qKM/F21ajK+mmOafbiWdSTSnwcucOxaSiqfZ/1CTo9qy7KpyqmYEeOg7zmqL2kg4qy033hDg6WdjhGNmp33a8GophOC//rOIbTvjPPBQdEK1xWgrN/qpmuZh84N9tmRzHpFm/V21nNnTz8DJQT2DrkfIlMwppWh+BR1PHVSVlgy45C2ux1NexOiWfWpAbiZnS2DpHCS/j/Cefba0/vnLVzK6fzeKIpshIFOmaP4qXIEQffu3OKotxqBcq3vJKQ7GaMb10e42PQhXsdRrLZ8c6MdTmltBAUj1DeAqKkBoEKS1rIYWNtU/Ai4Jd5HaJdoKLBqcpEZj+gjQucxpPKGyxgL6To+aYHbcINwMsCQTCpu/vI+FtzRSPq8kCyhOriGDi6jrmUOUXjAHV9Bvcw3JsiB8sAk5Eie4anH2mYn6QoGipu0PLV+O5PZk12fWxTrPEm1voWT5xqzqalBh3xabUlreNpuClgnMCCJdh18mER1h1tq71eZBa/DTZFUBJ2AxBNNqsEJaJhYdpKfvME2tL7D/8C95fdd/sXXPN9hz6CccPvEQp1qe40zHVnr7jpBMRk3+UNOwAkZ4SU8OXqxdnI3HWVDcwOINf8bCjR8mHh5k7wtf4eTOB4iP9r85eDFByjhBuwa4kCQ3tWuvZ9a1f8Zwy2FOPPQ14n2dWXeRbH5oafMuyUPdrR9ATsTpfuqRbGCuoe78lWsINM5U3UQpOesmSgtCF63BU1VG36+eNSWck4WL2g9cStezhxhuHlSBRVHVFhEMsOQ9i9n54yNERtOmvC1JxUVauLnxL+rZ/GAf7WfSutqSVNy62pIrtuWyy70kEwovvaz2ADGqLUZwmdXo4TOfLODz/zJMX382mZhm1rwtmovIIylc/85Cnrl/ECWVtiWbq5uXT/3yYvY+2KSP/qyNRzTzxvm0P3PMFJDrdkPx5UsZ3rzXcCGA8LgJrl3G2HZDL6IMvOQtW0FqZIjomabsOsMk3C7K11xO374tdrXFYd5+86ofVrgxqTGKoiotuXoOYS6fHOjLQksOtSXVP4C7tCSnDCCEQqp/BE9JPsJlfwQbAUZVWpyhxQlWNCufVUAinGKkKzpxEK5Bqtr765NEB+OsvXeJeo0qWXXFmpsFUGNVesMM7Gym/KrFFtdQpm1WBOE3DhJYMhspGDC96KFAsqefeFMz+avXmJXbzDS083WC9Y34y6ptLzpva0zLFLS8LTYFLRNZpsGLDfXQfvh5GpZdj9eXl3ULybkVFhuspBUiYz0cPvoAW7b9O2/s+ipHTjzMwNBp/N4CptdeQF3lGgpDtQhFMDraQXvXLg6ffJhXd36RvYd/SnvndhKxYfWGtwKMpsCMBy8Kph5MjvCSWVZcMoslG+9lwbr3Ex3pZu9zX+LUrgeJjUxCeZkg7sW23PKwyq+ezbxbP4O/sJyTj36T8NnTFjDEBjFuX5BpN76HkUO7Gdm70wQu6naC0ltvJ9HRyegrb5jcRAIXJffcQPiNg0QOt5JOS8iyICVLhJbNpGBpPU3ff1VVW+TMpEjMvm0BksfFzl+edMzbsvjSUurmBnnoW10qrGR6EiVwmVQXq9qSlydx+eV+fvrzMCmHnA5GcPnze/OoqnLxD/88Apjztmjf1U/zCNBX35bP8ECafVuGHbs/r7uzjsNPtJGKJEzjETVcMRNkmb5XLQG5ly4m2TVA/HiLujyTsyVv4woSp1tJ9vSacra4CwsIzJrNyIFd+jKrWlK8YLVdbbG4eGxxLbliWmzqiSAZHiYVGbX1HHLaRlEUVWkxuIecLN03iKu8OLO9Yq4n8z3ZN4y7NF9dNE7LmxqL54QWo1kzLedPK8Dlleg9pV4TxjgWU0yLdt0hMdITY+v3jrDuY4vxF/nGV1kMwN31/FF85QXkLW4wuYb0ITLiKcI7jxBau8TyBwOKGoDrqarEVzPNprKkIxFGDu/JqiwG2NHj1qbs/5RNQctEpgBpheYdD1FQ3kh53Qo9xkWLY8kGipqBRXcLyRCPj3D85GNs3/NN4olR5jXewIZln+TiNX/H6gUfYt70a6krW0V9xRpmT7ucRTNvZuW897Bh8ce5eMVnWT7nXQR8xTSdfYVXd3+FnQe+R1v7a6QTWoI2IziMAy/GOBMrvBgfBJljlxQoKZvL0gs/wby17yEy0sXe577M8W2/INx/1qKqmCEqF7zov58RXqxvUDJ4PEFmXP4+Smev4vQT32Pg8Ha74mLcXoZgdQMVl1xH99MPE+9oxxiYKxTwFpZQcu11DD3+lNlNlBZ4Z04ndMFy+n78uCkoV1Fc1Lz/MgZ3nKZ399lMUK6LlCyheH0s+9Ay9v3iGMPdcZvaksLNTZ+sZ8uj/bSejJNQXDnztmhqS1pR1Za/+qs8tm5L8ItfqT1InGJbALxewX9/qZiHHo1y4ljKtM7oItI+NbWlpERw0dV5PHPfgKn7swY2S66qxON3cezJFn08Ij0g98rZnH3cHJDrr8wnb3kjIy/uBqFkc7Y01OCprWJs+66M0qIuVwTkL1vJ2KEDyKnEhGpLOhHVIcUEL1aXkHbrjuciyiyLdrchebz4SipN+3WqLxUeRUkmVGjR61FM+1KEoiotZSWO/5Ve18AInpIC23JrzEpyLG6KaRnP1Hgp9XqSXILyWQUceKwN2ZAIyKi6GIFFVgSvfvMQhdPymH/zLEeVRdvGmpul69nDlF+5CITk0GsIInuPgywTWL4gCyWoLxFKSmFsxy7yV63GmJtFU5FH9u/E5Q+QP2ux+UUpU27w+K5J/TZvuckKyPJ5TFNKy7naFLRMYALobdpJeOAMM1fcgjnpURZOUBRLoje10U8l4jS1vMDWnf/F0EgrS+a/i5UL3k9V8UKCvhIkWUwYzyIJF6UFjSxouI6Lln2a1Qs+REl+A60db/Dq7q9ysvlp4rEhu/qSC14sQbJ6kjqHYF29PILS8gUsveDjLNz4YdLJGAc2f53Dr36f4a4TmLpKGxUco4JiVGIs8KKpPdbeSRIStetuonbdDZzZ8hBnX34QJZk0wYo1ULd05SbyZi+k/f4fkR4aya5Pq/UWrFmHf2YjfT/5FUo8ZXITFd1+NenhMQYee410OhuU65tRTdlVSzn1jRdJJBRTUG7DtXPIn1bAlm8cNAGLOrmZc0EZ89YU8LP/6FDjWtAUFjO8pBVhCNCFmbPd/OPn8/mHfxpmzwG1J1EucFm90kt5mcShI0nbuvECcq+7u5Ddr4zR3xHTA3K9IoVHpAj4FFbcXMeeB5pwibQ5IPfm+ZmA3F49IFcSUHLFMka3HkGJRjLjESkIF4Q2riK8bTcKssmlE1q8BIRg5JA5Q65RdSlasAqXL0D/wdcxjitkBRcwv8gblxvLG9eFu1oIVNYjpAkehQJSI0MAuIuL9WWmz4ylh0fVHjI4r1fLRHAVhSYMrE3HUrj8nnHL5LLL/m4FLdt6eOLzu03gAmZgATjx/FmOPtHCRX+9Askl2VQWyAbuaiqLogiGDncSPTNA6WW5XUOjr+wluHoRwuczPTuRIX78FOmREfKWr7QF4CqyzOCeNyhath4huUzPEmQglWLw2M5z+m3O33I/ryfnGpqClnO1KWiZwNLRMG37Hmfagivwh0p1d5DJLWSKL0Fv6Pt6j7F151fp7NrN3JnXsW7Jxygvmj1x4G3aMhkDchUoCtYye9oVXLjkk8xruIaBoVO8vvdrHD7+IKNjHWaQcoIXYw8mDRY0eNHORzbDiw4XCIpLZrFo3YdYevEn8XiCHHnth+x/8Wv0NO1AThmAwnCOuWNdjCDjAC8ySIqgYv4FzL7uYwy3HOb0b79FcmTQ5NYyA4+g5uo7cecX0P7Aj1DiCUQ6G5grCYmKO+8iPTLK0OPPItJZN5ErL5/iu65l6LevEG8fUKElrQbl1rz3EpLDUdp+s4dkBlgSaRey8LDmM+s4/lQLrXsGbEG5Kdzc9rlGDrw2zI6Xx2xxLZrakiTzdkvWTfTe9wa59ho/H/jIIL2DasxKLnCZ1ejm1GlVabG6iMA5IHfpGh/1s7w8f/9A1jVkUFs23FVLf/MoHbt6zAG5s0soXlhJx+PZgFyXJFO4djZSwMtYZhBFBJm0/stIj4wSPXpcVVm0nC0+LwVr1jG0dQv6OEVgUj0kt5vSFZvo3b8FOZ2wA4h1G6d5i2nwE+lqJVg93VmN0UyLVRkZRnh9+kCJucqlR0ZxFebb6tQPR0B6LIK7wDwIohPAyPEULl/2X7QPuOl84LIiqF5Uwl3fv4DTr3bxu7/bRSqp6AoJqMCSTsps/uoBnvzcNtbdu5jqFZU2lUWrzykAt/uZwxQua8BbWeToGkoOjBHdf5LQhStMRKm5Zsd27CQ4bx7u/ALDi6B6r0ZPnyQ52E/x4nUm97X2rBg8uZd0Mub8X/y+bSqm5W2zKWiZwNqPbsYXKKJ69kXZOJa0UU1Bd7UYYzY62ndx8PCvqKlYwfrln6K2fDlCESZFwwQpWtyFMReLNqUVex6XjAJTU7qEdQvvZdnsu0kkx9hx4DvsPfJzRkfbzfBihCQHeHEK1h0PXlAgP7+WeSvfxcorPktR+WxaDj7B7if/jbYDT5EIDzrHvYznOjLAiy3YToH8ihnMu/nTCCFx8sGvEe056wg5QgaXy0vdLR8gFR6l67H7IS2b4ltcwXzKbrudkc2vEG9qy4CLqrYE16/AP7uBvh/9jnRK6JlyCeVR+4FLaPvVVsY6Rk1BucWLa2h8x0xe/s89JJKQlF26yyepuKicU8CmOyv5+b+fJRrPxLVklJik4iKhSfsWN5EsBF/8YgF5IcHH/3yIRFp14juBy+xZbk6eStmWOw2kqLmI3EINyH3uwUHkpD0gt6zGz9xNlex54LQpIFcSCo03zaf9+WMosUSm67OMxydRfMlShl/Yrce0IMBVmEdg+ULGXt+ezdmSWVe4YSOJvh7CzSdMyeaMbprixetAkRk4ulMFDidwcYIUgwJjhRw5nSLac4ZgVYNexlqXkQlSI8O4C1QFJVeTIycSKLE4roK8HCVUS49EcBVMnOU2nUgheSeXo0U/BsNBl88v5a7vX0jLth5+97c7SSdlFVaQGOuJ8puPbOHw4y3c8M2LWPnBRTZQUT+dA3CTkRS9rxyn/KpFGVdRVoHRXEOjr+3DVVKAf+5M/RmigYccjhE5cJC81WtszwAUGNz9OvlzFuHJK8yqLJl1iizTu3czRTOWvqnfZsr+99sUtExgw13HmLniNn3kZrNrKNMYG/KkIMu0tLzCsZO/Zc7Ma5nVcCVuyW3qtaNPVkiR5XHJXMiyCWR00AHKCmaxcu57WLvgIwjhYsfB73Lg2P2Ew92GY3SAF4MaYw3WtfU0clJeZIWAv4SZC65jzRV/T8OCdzDQeYTdT/8Hx7b+jJHuUxm1yPjQcXYdmRUTZ9XF6y9g1jX3kl87m9OPf5dod3bEaGtZT7CAuts+xNjJI/S/8rwemKutD81fSGj5cvrv+w1KPKWCiywQskTxe24idqKNkS37s2qLIii6dCnBxipO/s9mVW0xBOUu/fgaRtrH2PdQs0lt0YJyr/2LmYwMpvjtD3tMQbkTuYl8QYnv/6CInbsT/Nd/j+lBuLKi6PAiK4pJaXGyXAG5V92SR2RUZvdLQ5ll9vGITmzuJNwT0QdS9Ehp6i6bCbJC32sncUlyNiD3ymXEm7uIN7eryzLwkn/xWqIHjpIaGjIH5BYXk7doCUNbXzEDg56QDlw+H6XLLqR372YUJa2DC5CFEbLlcwbjGizW146SThGoaZjMo4DUyBDuwiLzQn2/mf9hVB3I0lWoBdli+tQsPWJWWnK5ieRE2qS06MsNZGZKHoc9ZqVsXgl3/GATbbv6eOyzO0gnZdp29PDzu14gnVJ4131XUr++OluHQWUZLwC3Z8tJAArXz82CCoZHlgxjr+wh74IVICTVBWsIwI3s2Yfw+gjNnW9QqdX1yaFBxk4epmT5RpOCrT1nR1uOER/upWT2Ssff7fdu2jP1fKYpOyebgpYJrHTaMgpK6s2gomQVDHT3igJymlOnnqK59UUWzb2DaVVrskqJUV0xxZhoy8YHFqdyOsQYktQVBKtZPusuVs//IKl0lG37v8Xhkw8Tiw5gDdg1qjyTDta1wIvRreNyealuWMeKiz/Nwo0fBlnh8KvfZ9/zX6HrpBo0bI5vMYLUJOFFAZdwM/2id1JQt4DTj3+PaFdbtmeRMX5FhkBZDTXX3k3/q88RbT6tLje4isquvwk5HGH46Reyb4EyeCrKKbz+EgZ+8TTJwWg2d4viZtrH3sHgjiZ6XmsiLUskZDcpWcJTks+yDy1j27cPMjKQtAXlBou83PG3M3nkfzppO5XQlZZcbqIkQhfhGma4+dp/FfJfXx/jxZdipt5DGrjMbnRzujlF2mkExoy5DNtpakthgeDi6/J55r4Bxwy5s9cXU1Qd4NiTzeYMuQGJaZfPov2pw7r64pJkgvXFBBfUM/LibtMgir4FjbjLSxjbugNrQG7hBZuInDxmypBrVVtKll1AKjLG0Mm9diCxxrLgvF5dpgJPpKsVb1E57kCeWZ1xMqEpLYXjlk2PjAIg5VBahFBVgvRYFJfFPeRY3ySVFi041r5cXVY+u5A7f7iJ9v39/PLdL/HgR7cw96o6bv/hxQSr8rIBthOoLEaA6Xr2MKUXz0fyeR0CcAWxUx0k23sJXbAiAyyZ3yADJmPbd5G3YgXC5c4+XzPT8J5teIvLCdbNMq/LPH969r1E8awVeAIFtnP+g5gio5zHNDXK87nbFLRMYNWzLrA0nFojb5wUlFSKI0cfoqNrN8sWvIfK0kWItJxxGykOgGABFYPrRwcFw2RyDVniXDC4krQyRaFprJzzHlbMvYdItJ839n2Dk01PkUpGdHjJAoh6bJMK1p0EvGhxLwvWvJdVV/4tpdWLOXvsRXY9+a+c2vUbxvrPWGJRlGydVnhRsnUbYUZCYvqFd1HYsJBTj3+XsbYTORWXwjlLKVq2js5HfkF6ZMS0zh0MUXbzrQy/uJnYqVaTm6jg6k24CvPo+9mTyGlJ7QatCLz1VVTetJpT//MikdEUKQ1cFImZty0mWBZgy3/tJ25INKcF5a6+oZJ56wr59t+2Ek+5xncTWeJbrniHn49+NMS9fz7Eq6/HbV2hCwsl4nEYHTWAiSXRnLpMMcELwA3vKmTf62G6W6K2DLkeCZbfOI2Dj7XaAnJnXD+PgX3txDsGcOmjP0PxlcsZffUASiJhCsjN27SWsdd2ZNQSdEDxN9Tjr5/O4LYt2cy5mN017mCI0qUb6XzjSVKxMbObCEwg4xiMa5kPdzYTrG5wXGc0rZ7U2Aiu/ALbcqOlR8cQPi+SL3ePHzkSB1nBla/GxkjjQJCcSCN5nAfOHM+MAKNBRsnMQu74wcV4/C6u+cI6Nv31CvB4TMAyGZVFUQThjhGG95+h7ApzAK6aATfjGnplD75503GXlZqUEhRIdvcRb20lf+VqewBuMs3Qvm0UL9+ApGRfMLRtw12thLuaqVx0sbp8yv5P2RS0TGAel1dvLG3En3F7yOkUBw/9ioHBU6xY9AFKCmeqwKIBgckVYweVybiITK4hi7piBCCtnFZ3af4MVs//IItn3krv4DHe2PsN2jt3gJzW1SITvDjEu9iCdSeCF4Orye8rYvq8q1h9xd8xe8WdxCODHNz8DQ689E36WvagpFMGBctQpwN8GOERRQWXhgvupHTuOpqe+iFDJ/aYwSWd3bbq0ptw5xfS8dDPIJkyxbeEFi4mb9Uq+n72K+SxaNZNJDyUfPA2wtsOMbrtsMlNVPHOixAuF00/MOdukV1u1v3dRk481cyp17sdg3Lv/n9zOHsyxu9+PL6byBrfAvDZv8njiit83H7XAJsu6+N7Px5jcEQN0H1xc4zFizwUFTnf1i5D42h1Ec1f6mXmPB8vPtSfHTzR4CJaeUM1A61heg71q9tlpvIFpeRPL6bzuaPZ5ZJMyQVzQQgi2w9nA3IFhC5YQXosTOTwUYwBuQpQuPECRvfvJh2PZNWWjItIg5CKDVfhDgRpe/4+1J5IwrTe5h6yxLRopigyY2dPkTdttg1qbK6mjKXDYVx5DgqKobwcjSEF/Kbl1jwsckztCeYKTJx/BUVBWH1LWj05/F6ai8hpfcmMAu74yWXMvrLe5ErK1ilNrLIg6H7+CIG6EoJza23Bt7IsUJJpwtsOkrfRHICrg8f2XXhravDV1BpUbBVQxo4fQo7HKFqYHYfIrLJspqBuAYGiKiw/7R/OMs/Cc57eruP+E7ApaJnIDMBiDGw1xrGcPPE4o6PtrFr8IQpCNTmBxUlxeVMuIst6q7riBDlaA15ZPJ/1iz5GQ+U6TrY+y/YD32VwqMl0TrniXd4MvJjgzhD3Igk35dVLWLz+Iyy/7DPkFU3j9N6H2f3UFzh7+DmSUYMCMhG8KNnlEhJ1a26getU1tL50H737tpjARft0CQ91N72PRH8vPc88hkiDlBY62JTdcBOS203/rx9GMShbvoZ6Cq+/mL4f/o5Ef0R3EymeAPV/cQ1dT+6nd1e7yU1UuLCWBXcu4KX/t4PhIdnmJiqqCnDH387kwf/uoOlEwqS0aIG7SQ1elCy4yAAuwX9/rYitb5Rz1VU+vvaNMZas7OGTfz3Ibx+PcvVV4zeE1hveGJD7jjsLeenhIT0gV3MReUSa0ml+GlaWcPiJNjwijYSCW8i4JGi4Zi6dzx7FpahBukIouPxuCjctYvilPdmAXEnBlR8iuHIxY69tMwfkShBatATJ72d4306TUmKEEcnjpe6a9xLpaKJ378sZyMjGtzi148ZlWtlYfyfpWJi8utnOt71DPXIkjCsUGvf3VYzQYjENXjRokQKTyL+ioJ9bLkgxHaOljFOvHzCDjVFZAWwqi7EuRRGk/n97Zx4eR3Xm6/erbm0tyZas1ba8b8iLvIFtvGBjMMSYQCAMNxACyWQlk+WZLXcmy71JZiYzGcKdzCQhy+WSZEjIQliSEMBmsQnGu+VN3m1Zlm1JtiXZ2qXurjr3j6rurmq1FsvCQtJ5n6eebp1a+pS669Svvu2ELM6/coDcNXNQJK7N0lx6HNURInBD57L9Kqxo3rmbjIXXu8YKou8vl25lRPF8fCmueYacJXiploaKMtvK4jruNac3rvyeFk2f0KKlJ+IEizu9WZSiumoX1TW7mXPdhwik5jpCAq9gibOueCwqnnW9WEz39l7rSuIJGGPixaf8TBq9nGVzPs+IQCGlh37GviO/oq2tjoTBum5xlSjTKE68JEpvjncdoSA9kM/UOR9g0W1foWjaKi5W7mb3y99ypgqo7Sxe3J8XeR8X61I4exUTVz5I1bY/Ule2NSpcDJOocEnKyKboA49wec9WGkq34w7M9flTyH/wIVoPlNGyZZdjibGXEetW48/JovbJ32OGJeomSps9mdy18zn2+HraWkyPm2jWpxeRFEhi07dLE7uJ7hlN8dIsfvg/T9Me8nlK/CeKbzFd8S0mUFTk40tfymT3jnz+4/GRlJebnKowWXdHF+m4LtyF5tysuTuT5gaTPW81eGq22HEsJgveP4bD68+iwmbUPWSIxaS1U2mvbebS3kq7rL84kyiumUfbodOEqi9Gg3TFUGSsWkT7wWOE6+tjAbkC+H2MXHQjDTs2237/iJUlztqSkpPPmFv+gpqtL9NSc8orXNwP9XFWE+WyWDSfOU5Kdj7+EVlAYpHiRilFuKUZXyA9erxEWG3tSBeiJbaNPTWDkZrcbTVc+3M7f5a7fH80PRnvTMyJrCjx6xK6heKsLNHtiAma85uOE2pqJ2/tXBIF4KKE5rf3kbagGElNjYkWZzzoOH7Sqc2ywP7KLKJWmGB9Ha0Vx8ieu8QZX2L7ioILB94ikFtEZsHk2JigGVYMCdEiIvNE5E8iUikibSJSLyJbReShqz52XGxHNDjVUjQ1nuPYsT8wbdJasjInxIRDRDCYLnHiiRlxLYnESE+Lx8zoXTzWly7ES0pSBrMm3s2imZ8gFGph697vcezUK554l4hY6ByL43X/RINqE80o3Y3rSCyF35/G2EkrWLj6S1y3+CO0NV2gdMNjnNj1Wzqa6j1uIVzWFU96tEu4jJq8gPHLPsjZzc/RcGJ/J4uLYUL62CkUrL6b86/8jvbK057A3NQxReSsu5P6514gVF0bFS5iJDHq4/fTuvcYTZv3Y5oxN1HhI7eglOLkT972ZBORksyS/7WSExtOc+T1qphwibqJknjgG9OpOd3OCz+x3UQhfHbFXGdixe7iWyKzDPmS7MkVn38uh2OHC7huhl2IrCdXf6JCc1nZwo23ZvD2HxuiriH3NiW35xNsDXN6c5XjPrJrtgRy0ihYMp6a9YeiAbmGKAJTC0iZWEDTxtLoJIqIImX6RPyFeTRt2Y47IBeBzCVLCDVcpuXkkS6tLQhkFS8ke+YNVL76NOH2Fq8o6cJF5F7XdPYY6RErSzdWmghWqANMs5OlJT5uxurG0hLdp6MDBCS5d0XjunIPddlXlzXFLV7cf3dltXFbWSLbxVfAPfubneS/rwRfRsAZKrzuoXBTG617jthZQwlcQ807dpE2Ywb+jEzXQ429NO7bQXJOAWmFE2JjizMGmK3N1B3dSf7slUSKfMpAWSyuqhqus2j6xJAQLUAWcAb4MnAH8DBQATwtIl+9qiO7VL47vTkUbKXswDPk5c6kqHCxIwi8giWheyhqYelBqLh/3N25ieJFT8T64hYv8aLGufONDIzh+hkfdeJdjrJlz3c5c24LygrTbbxLnHiJzzbq0XUUL2AwotV2Zy56hNaGavZs+DYndj8bnaSxuzRod1vetCWMWbiW02/8guYzx+11ptdVNGreckYUz6fqdz/DbGyKxb+YMGLpClImTqLuF79GBU1HIQjJYwsZefct1P3sT4TqWqLxLaSmMf6L66h5aS+1u8543ERZxYXMeXgOm761k4baEO1WEh3KT7uVREj5SM8P8KGvTuG571dx/HBHNL4l5AiXSHxLyHnqDSojoXAxnYE7Pd2IuZHi1iUivtAcwE13ZLJzYxOhtnDURRSJa8kY4af45gIO/qmyU82WietmUPPWCazm9tgkij67Qm7Dpn1g2uWIPQG57+wkEpAbsab4R4yw05+3v+0SNJ2tLQiMXnUPRkoqZ17/FZHCdPb8RN4bcrQtIk5Mk9aqcts1FH/vjhc5TpvZ2gKAL737TCPV7oiWbkwAqj2IkZKMdBeBG9u6F9vEcJfbjxAvXuKtKV1ZWRIF4NbvPkNLRS2F91wfbevkGtpahhFIJXXWtJiFBduqabUHad13wC7b7xIrKFCmRcP+nWSXLMYgJnIiY0vtwa0kpWUyanxJ1E2s3UPDjyEhWpRSm5RSn1FK/UIptVEp9ZJS6gFgO/Cpqzm2200RsSRgmRw69Bt8viSKp9xtq/5oqnCcUHALlq7ESnysimm5btD2392Km3gBEy9eTFefXO1234SC7GKWzv4sk0avoPzsRnbs+xGXG051H+/iEi+Jso26dB11E/tiKBiVX8zcFZ+neNEjtF6uonTDv3Nq7+8xg+0uC4vLZRR9GnO7ilaTV7yMU68+ZU+06BY6pl1hd/Sa+/CnZ1L9/NMQNokE5hpKyL/vfkLnL9D46ptOUC7RbCJ//igu/uj5aNE50zIIzJlC3h3zOfadV2ltDHncRNd9bCHpBem8/s2dhEzpFN+y4M5C5q7K5vt/W0FrK3GZRN5JFTsVnsMWLia2OOlOoHRHJK7Fh8WNNwewTMX+rc2xLCJXQO6C94/hxFs1BJs6PDVbxi4bhz8tiQtveSdRzF41G6uljbb9x+1aJAIikLF0PqqtjdayQ9EicxFX0cgbl9N64igdly56rS2uui1KwEhOZty6R2g+c4xLh3d4BEdEqHisL85r3eHtWOEw6eOmui70zv8Xd/Cu2dpq/68C3acpWx0dSKorrigiXlwixuoIISm9Lc0vqATfa6JKuFbcSXQV32K/7yxYerKyWAjnXiglZ9l0bwVcXPdhJTRv2W9Pjmj4PMIDBW37D4JhECh2zUPkWGHaTp0g3NTIyJkLvQ+LSmGFw1w8uJn8mSswxOcZewYCpRTKsvq+aNHSZ4aEaOmGWqDralu9IXJDdN18K05tpKGhkpLiB/EZyd7AWwtXvEoCwZJAePRGoFyZkOn8WYkCdt0uI0N8TCi4kaVzPkdmoJDdB5+y411aa4l3GSUSL/EBuwldR72JfbFc4mX55ym+4WHqqw+yd8Nj1J094IjDrqwuTtCvEopuuIuc6Ysof+VJW7iY3m19vmSK7v4o7efPUffm+lhgrgVJI7LJve9+Lq9/jY6j5TE3EX5yPvkh2o9U0PDqjujcRGHLoOCjtyLJfk/RuaDpR/mTuPHrKzm7vZr9L5zuNDdRmCQe+OYM2lssfviVSoJWLL7FnUkUclld4oULeK0u7iWeyDxE0b9do74PRSAAJYsD7HmrMaGLaMbyUaSk+zjx+hlPzRZ/ksG426ZR9artIopMopg8MoXMJdfR+GZp1NKCoTAyA6QtnGNXyHVZUhBImTiBlDFFNOx4x2ttcbZzb5uaU0DBjWupevv3BBvrE7uGXILl4t63qNr0HKNvuhtfqi1A4l08iTDbWsEwICWBIHEPF8EwktS9IFEhE+llGrP4BGWphO4cT1E5T8Cs16rSOaDW6CRwIsfwTozotbK01jRRv72cgrvmOxYW4qwsQqiuiY6jp0lfMpdEZftbdu8hfc5sDF+SV5hY0HBgF+mTZ+APZHYKwG08VYYZ6iB3qiujyEr4FWiGOENKtIiIISJ+EckTkc8CtwPf7sV++SIyy70AU8AZx1yxGXW1x6ioeJOZ0+4lkJoTC7y1rDg3kOu9aSWOP3FbZxJYXHpaOu2fSLy4xI0nHTpO0ESsMSn+dGZPvodFxZ8kFG5l677vcfTkHwkFm7sVL50Cdl1xL/HWl65iX+KtLwaQUzCTBSv/lvyiBRzb8QuObPkpHc2XvFaXBO4iQwnjFn0gJlzOlXeyuKRkjmLsugep2/oGzUcPOSLMzijKnF1C5uIlXHz6GczGtqhwScrPJ+tD66h/5lXaK2vtoFxLUMmpjP+bu7j45mFqNh33zE2UPiGXBX91PW8/XkptZWunNOiUrFQ++V8z2bnhEi/9d50nvsWdVWRFA3I7W1zcVpd43G2R1On4IFz334tuTmf3piaUUp1cRMlJwpz3jeHQy5VRS4stUkwm3jGdywdraD9T55lEMefWuTTvPobV2BS1wCCKjJtuoP3gMUKX68GV/owII5Yuo7F0B2ZbS+eaK3FuopwFK0nLG8vxXz9O3eEdeOYwclAoqt95iep3/si42x4kd96K2PHc23UhXKy2VozUtB7jS1Qw2AvREkaSelea3/AZKDPm8EtkTXGLlFh7V+nMrhiXOCtL9HhR11CcleWlA6SNzyF99vioWAG8rqFtZfhGjSR5ynivJUTZ8y21HTlK+jwnADc6JtgWqqYj+8madX20ze36rTu8jezJ8/AnpUXHXJ09NDwZUqIFeAIIAReA/wC+oJT6cS/2+yxQFrf8HvAIlnCwhcOHf8u4sUvJz5npinFxiRS3eLGsTrEm0Zt0gvYely5ruPRCvHQhUhJaY0zFyHQ73qVkyv1caijnndLvUnFmE1a4o3fiRXnFS6+tL84gFbG+iKXw+5KYWHwH81Z+kXBHK3tfe4yqo5vAsmIDm0v0xAuXUVOv59SrT9FRd8ET4yIWjJg0i5zFq6n+/S8J19V7RE3OurswUlKpf+a3qHDs/DJuWkzqrKlc/P6zmO2WI1wM0qaNo/BDyzjx3ddoudhKyPQRVj6Clo8p980hb3Ye67+2nWCQTm6i0TOz+PD/nsoz/3aG/TtaE9ZviQTmujOKIsIFvFYX99IT7hLyPiyWrAxw4VyIqhOxQnORdYZYzH//aCp31dFc02KnRBv2RIqjZuQwYmoO1esPemq2ZM6dQNKoTJr+vC8akCuGImXGJPwFuTRv2dkp/Tlz/gKM9HTqt2zsbG1xWVCUgPgMJt77GfKuX03Vxt9R/uKP6Lh8MbaNMjn7xm+oO7CZie//BFnXLexct6WL9xHM9jZ8aYnnCvLsGwp1G2ArolBhE8Pv686wE9veZ6DCVs8bOnjK+zsiJV6suNObIySysrgJBy1qXj5Awbp5gEFXrqGWrQdIXzwH3DEpznXZtvcARiCNwORYlVuUPct985EDiGGQOWWWyyVvL8GGOpqqjpM3bYnr+ib6MDQguJMh+rpo+sR7TrSIyCoRUb1c5sXt/i3gBmAd8BTwfRH5u1587BPA7LjlbohdPKIU5SfWk+QPMHXCmuiNO+bqSCRe4sSC4+JJJCwsK0Rj+3ma2i8SDLXaT1eJfujdiJnujt+ty8j0tkXjXYD8rBksmf0o08ev4UzNdt4p/Q9On30LM9SGe8TyiJdItlG866iXAsZtfXGLl4yMQkqWPcqkWe/nzJE3OPLOU5jtrd26iwwljF98D+kFkyh/5UnM1pbYdo54yV/2PlLzx1D13M9dcxCBz59MwQMfoe3wEZrf3hYrOqcMRn30PsKXGql/9o1otdywZZD/F8tJHp3N0cc2ELKEoOkjbPkI4WfJ127iUkUj7/z4iCcNusMJzL3hnjGsuC+f737hFBdrwp3iW3oSLm6rSzyJ2nxxI74h9lZjJyYzdlIye95qtLfDcsr72y6iCXNHMGpcgKOvnHZmhVbRui0T7phB1YYj+KxwtGaL4ReyVpfQuLE0cjGBYAfkrriBli27UMqKS3/2M+qW27i87W3CzY1dWlsi78XvI/eGW5j20N8DimPPPMaF0jcJh9qpePlnNJ46yKR7HiVz4nWdRUki91DcNlZbK0Za9/EsShQqFMboISvoSiwt4hO7blAvcNdZSYSFeARLd1aW6PaOOKndfAKzLUTurbOdbTu7hoLV9XScOENgcQke15ATs9JSuof0krmIK9YlIj4aD+wmc0YJPqeYp9tCW3dkO6lZhWTkTuhkvdUWi+HHe060AEeBT/ZyqXTvqJSqVErtUkq9rJR6FPgJ8K8iktfdByqlLiilDroX4CTEbrSNDWeoqt7FjCnvjwaCueNYIjdrcYuEOGtI5L2yLFqCl6hqOsSh2jfZWvUMr51+gi01z/BOzS9489yP2XDme2w893/ZUv0MpRf/wLnmg4TNjp4FTE+Wl0RWF/c5xAXqYtkF3IryrmfZnM8zcfRyzlRvZ3Pp/6H89OuEg53TpOPr1MRbX6KxLwkETLz1xWNFcQJlx4xfzNwVn6O95RL7N/4XLZfOxcW1xAkXDCav/DA+fzKnXv0ZKhiKxrjY5+ejaN1HCDc1cHH9i4gVKzyXUjiaUXfexaUX/kCosjoqXHwZmeR87D4aXtpMS9mpWBq0kcT4v7mLxgNnOPPifkxlEHRiXPy5I1n61eWU/vQg5dsu0mHFMoki9Vvu/fI0copSePwLFbR1GAmFS6IaLlEXkTOGW3GLm4QCxmVnN8Ri0ap0dm1q8sxFFFnnF5h751gOvlSJONaXiKtowm1TCV5qo770tF1kLlKz5ZYSgmdr6Th+xhYzhrIr5C5bgNnUROuBgy6Lii1qMuYvICl7FHWbX+/S2hJveUnOzmPSvY8y5ub7uLjrDQ796Mu011Yx5f7Pdy7Z7xZCiXAd22pv9VpauthPBbu3tABXFtPi92HFWVoSzzHkHco7uZE6uZXig2+9WUedXEN/3E/e6mKMQGpMrIDHNdT05z0kFRWQPCFW5dY+YQhfbqL9RDkZ8+Z7XUMKwo2NtFQcI2uWq9icM0Yo06Tu2E5ypy9GkNiDjjPGqIFKHY7MH3Q1i6ZPvOdEi1KqWin1ZC+X+h4OtwPwA5Ovqk+WxfFjL5GfO4tRIyNTrMduyuK+0XchIiLv61oqeOfc07x97qccrt9EW7iBvNRJLMi9k9WjP8HNoz/BsvwHWZh7F9NHLGV0YDrJksrhS2+xsepJ9teup67ttH2xus2MyvXak3jpbaBunKDxG8lMKLyR5SVfZNq4NVTX7rPFS+UbhIItXvESF7fSlfXFLWASWl9cx3CbjNPT85i74nOkjxjD/k3f5/zJrUSCdO3P9woXvy+Vqbd8nGBjHadf/yWErZjf3LRnhC6662Eu793O5Z1bnHW2cBm5ZCmB4plc+OnTWG0dtnAxhbSSYjJXL+biD54lfDk2qaJ/dD5Fn1zDqR9v4tKxOk8adMHyKRTfX8xrX9tKQ22oU3wLSUl8+j+Lqalo5+nHqmMuIuVOgY7FuERuOu5ZoSNWl3jcbWYXd92IeFm4PMDh0lZC7XYce2Quogjz142mtryJ+pMNHhdR+qgUCm4cT81rR/BH5yJSpIzOIr1kIk2bSkFUdBJF38gM0hfPp2nj5pgIiQTb+gyyb72dxl3bCDc1JLS2JLK6YAjZsxcx7SP/wIS7PsGU+z9PSna+fXnEuYWi9BCMa7a1YvSQOQTY7qGIFSWaORS/zRVaWhLcmOODbaP9dAfcOpaV+IDdxPEuiS0ukQDchn1nyLu9xGNZAdcQYmFnDS2bh8c15Cxt+8vwZWSQOmGiq91xDR3ehz89k0DR5E4BuM1njxNuayZn8gJvxpAzHlw8tbNX/8f+xj5n1fclwfXZW0QkQ0S+KyJVItIuIntF5EP9d3bvbd5zoqWfuRl7HC/v8xGU4nzNXppbqpk68XbXTZbYzR688SEuQRC54bYE6ymteZGd558jK7mQ5YUPs3rMp1iYexdTRywiL3UCyZJKiqSS6R9FbnIRY9NmMCl9HrOzVnNz4V8yO/sWQlYbuy6+yFvVT3Hi8lbCZnv3lhdILFzc/aSbc0kgaAzxUZS3kGVzPs/0cbdRfWEPm3d/h4PHfkdD42lUVJD0zfriedpyiZeYELP3TzJSKF7wYSbNupPy/b/n+I5nsJzU6ETCJSWQzdTbP0Vz9QnO/vk5MC3PNuljJjN6zb2cX/887adPxdYpIe+D94NpUv/bF6M+eiwh6/51GBnpXPjR85gm0Wq5WbfNJ2vJNA7/80u0t4adonN2cG7JZ28gkJfO+q9uIxR2BAkSFTAZ+QE+/p3rePW/z/P2y43O+lh8SySjyJMKHSdcICZeuhIx4K3V4ra2zL7BTn0+uqc1VkHXlfqcOzGdwutGcGx9ZSzDCFugjL9tGhfeKUe1BaMuIhFF9pr5NG0uc4qrOZlEosi8dRkdx8rpOHcuamWJvKbPnkNSTi7177zZSaSoOMHiES6APyOTzMkz8WdmdZ4BOn6/HjBbWvAF7HmHurvf9BTTAqDCvbe0GD4Dy/ny4i0spvIKEnd7IrwZRp2tLNH2OFFzYdNRUgpHkn7daGcb5zxcAqbjVA3h8/UEFs3B7RqK/LPaDhwkMGsWIobn+kZB05H9ZM4oQYiti6yvP17KyHHFJKVkxMYEZ1GWRd3Z/b36P/Y7A2tpeR54BPgGsBbYCfxKRB7shzN7zzMkRIuI/EREviMi94vIShH5oIj8GvgI8LhS6mJfj22Gg5wsX8/4sctJS8myG92Bp+4bu3sd9o0yFG7jSO0mNp/9OSGrg6WFDzJ71C1kJGXHhpv4CokJhIdP/IxOncrCUXeyavRfMiFjHmdbDvHn6p9zunEvljK7tro4fYlv65VwcbVHxYvTFhUvc7/I7Kn3EQw1s6vsSXbse4KzNTsIhzs8/bka8dIp5iWyDmHshBuZu/yvaK6vZP/G7xFsuRQVLvFPfIGRhUxZ8wnqj+/m/I5XPbEzYkH23BsZOecGqp57GrO52X4atMCXmkb+hx+iZVcpzdtLo9lE4ksm99EHaD9YTsMrOxwPm2ApH+M+dwdWyOT4f21EKSHsmNyVP5mb/mUV58vq2PGzo1GxErOmGMxYOop7vjCOJ75UweF9Ha4y/97Cc5GMoq6ESzy9GSp9WGRmCNPmpHJoe1O0DWKpz4ZYzH7fGI5sOGu7iBzBAjBm+XhEoHbbSU8WUdaNM8Bv0Ly1zO6lgAgkjx9NyvTJUWuLexGfQfbNa2jYtZVwc6NXZLhe4wVJl1Gu3QiU7sSL2doSK+HfzfFUMNS77CF/by0t3uyh7khkQQFbrLjjWBLuizf41u0auvDmUfJuLkbEW8NFubZv2VZG8uSxJOWNshucoUOUYLW203b8BIFZs13t9jbhliZaz5QzYnpJzDDljAFmsIOGigPkTF4YGwcgel03VB8l1N7cq//NUEFE7gDWAJ9VSv3YqUv2SeA14DERufIpwQcZQ0K0AFuBRcAPgNeBJ4FC4CNKqS9dzYGrqncjCBOLbgK8VpYobssEsfcXW8r585mnON96grl5d7Ao/z5GJOXFtnGLlTiR4iFuXYqkMSl9HisKP8LEzAUcb9jC5uqnOd96IjbAdSdc3Ouh18Ilcv5u4QJ2zEtBdjELZzzM0rlfIGfkZMorX2fzzn+n7OizXKw9hBkOesSLp2/diBd7O9c+VmfhgoKMkUXMW/lFkpLTObDpCdobL3ieyiIDoSjIzJvIpFsf4fyeN6k7uDXqJooIl9G33IMvLY2aF5+x3UjOZ6SOm0D22rXU//Z5QucvRtuTRheQ/dCd1P3yVdpO1kT9/RJIY8o/3M2FNw5zdsMRLCWELR8WQmDsSJb9441s++EBzuypi1pbIu4fSwl3fKaIRWtH8e1Pn6T6TBgrWoLdiIqTRG6enoRLdLseTAwli9M5sK0Fn0QsKd4jzlwzmkuVLdSdbIwG8RpikZTqo/CmKVS/4S00ZyT7yVpZQuObpbE5dxyLSuaa5bTs3IPZ3NxJPKTPKSFpVA71m9/slDmU0Hri+jthcG0vLCvxfTB7MVki9N7SYlxBnZb4mJbeEBEqCYvQxbV1Eiuuf1BLZT3NJy6Qs6o4ul3k9x15b1mK5m0HSI9aWbyf13boKOL3kzZtWtSIZu8MzUfK8KWlEyiaHHu4cGioKAMxGFk00zMWRKgp30ZWQeIJL99trso15Cx95B6gGXg2rv2nwBhg8VWc1qBgSIgWpdRPlVI3KaXylFJJSqlspdQqpdQvrvbYNTWlTJl0eyyq3YUkEhnO3zVNRyiteZGizFksH/MwhWlTYzUeutjHdT7RpROuNp8ymJy5kJsKHyEvdSJ7a19mx4VnaWir6XzcK3wvidrjhVqCvgdSc5g2/naWL/w7iqfcjWWFKTv+LG/v+DfKjv6WC7VlmGbIm6roFknEi5UEwiUBouy5jGYu/QTpI0dzYNMTNNefTWhtQUFWUTHjlt3LubdfoKWq3COADH8yY+95hNbKU1x6Z6PHzz5y5SpSJk6g9qlfooLh6D4ZK68nsHAm5//zt5itwajZPDBjLOM+toJj332DpsrLnhoYk2+bxHXvn8zL/7idlsuhqKUF7NLrFj4e+eZkiqal8U8fP0VDg4UZN1me/eq1trixunjvJr5mS4S5SwIc29dGR5t3T7t6riJvfIC8qZmc3HQu2h5h7K3TqNt+mlBDm7POdhFl3TqP9qNnCJ47j7hERFpJMb6skTS9vRXA410QwyB71Roadm2xrS3xdBejEnnfk1DpYb3V6sS0dGepUcqJV+lCtDg/4CsLxDV6nT3UE4nSnruKjYlYUqo3HCYwMZfARPthy21diVyawVPVhC9cIrB4tvcDnWujdX8ZaTOLMXwu65JznKbD+2zXkBid9rt0vJTsSSUY/qRYO/a/MdhyiUs1h8kdW9K3f8bVMnDuodnAYaVUfNHU/a71Q5re2SiHJ8kAGemFZAQKaG6psW+cUReFFZ1fKDrPkBOQqyxFxaWdTBgxnzEZM2kNX3buGK6bv9vC4qar8Sl+sIyM+IZ9sRelzyI3dTwVTXsoq3uNkry1zmAtse0Tvu96m2gJdLe0ddqUSKzdffch9pSaESggI1DAhLEruNxYQf3lE5Qd/R2FeSWMH7vMsy3xn5Vg/hjPk7ThPO1F2gyi/R1ffDuVh9dTdezPjJ25GmU4+xqgDIkGe6YXTGLExNlcPrEXX1oAy+ds47OPl7viNppPHCJtRjEk2edr+SBrzS3U/u552g4fw58/CnwK8SlGrF1K3f97keY9JwhMyMHvswj7TEZeP5mGXeVcfOckfjWedjFJ8Zm0GmGuu3c6tYfrOPl2NeNmZpJihPGLRbKESZEQfjG5/6/H8ORXKti6oYFZc1NJEhMRiyQs/GLiwxYFkdTjSJyKW4wI3p9WROSAfQMLKwMz+t5HWJlkjPQxY34aR0qbycgLO1MTdNChkggqPx2Wn2k3FRBsDlF3siFae6bd9JM2KpWsWYU0lJ0jqTCHkGUQCvvAZxCYP5X242dJNg0sU1CmASakL5qP2dBAsLrGSUe3A6FFQXJ+ASljxtN66jipeWNjLj1FTOxasZPstvBYnIvJEwsTEUvO79AueKdIKRqHAMHzNfZhDewU7UjQsKFQmKTOnI7V0UHw3Hn7dyH2b0NEYRh2HI8vOwMRRXvlBXxOu88JWrb/tlPMfaIIjB6BL9lH46l6DJztsN1t4mwjru/c6EbZu1OZlSNalDLskDgE04qU9renpzAtg+ClVnJXTKe1otaOjbJ8dhVoJVimLbI7KqpJWzAD1REkePY8yhK7QJAldtA6kDppIsGammg8mpgCYYX4k0gdM5722hqnKjWICZgmgpBeMJm2SzUYlgITDCc+rfVSFSPypuDzRyenTO7yxN8FWmnp+vfV2/1tpiQoWHhRKXWhi11zSByjWe9aP6QRPQdCYkTkLiIF5jQajUbzXuZupdQf3u0PEZExwBEgsx8OFySx2PqGUurrXXz+MeCkUmptXPtooAr4R6XUv/VD396zaEtL17yFXWDuDPaPK54p2KLmbpyaLkOU4XCew+EcQZ/nUGM4nGdP55gMjMMer991lFJVInIdkN0PhzNI7LXtLnGkjsTWFCcCOmpxGbJo0dIFSqkGoEvl7jLpnXSK0Q1JhsN5DodzBH2eQ43hcJ69PMc916g7gC1csK0aA8EB4AER8cfFtcxxXssGoE/XlCERiKvRaDQazTDgBSAD+GBc+yPYQmr7Ne/RNUZbWjQajUajGQQopV4RkdeAH4rICOAE8ADwPuAhpVRv5kgd1GjRotFoNBrN4OFe4F+Ab2LHshwBHlBK/XpAe3WN0KKl71zELqPc52q7g4ThcJ7D4RxBn+dQYzic53A4xytCKdUMfNFZhh065Vmj0Wg0Gs2gQAfiajQajUajGRRo0aLRaDQajWZQoEWLRqPRaDSaQYEWLRqNRqPRaAYFWrT0EyIyT0T+JCKVItImIvUislVEHhrovvUXIrJaRJ4SkSMi0iIi50Tk9yKycKD71p+ISKaI/LuIbBCRiyKiROTrA92vviIiGSLyXRGpEpF2EdkrIh8a6H71J0PtO0vEMLr+hvxYquk7WrT0H1nY8xR9GbgDeBioAJ4Wka8OXLf6lUeBicB/Yp/jF4F8YJuIrB7AfvU3OcCngBTgxYHtSr/wPHbFzG8Aa4GdwK9E5MEB7VX/MtS+s0QMl+svi6E/lmr6iE55fpcRkW3AGKXU+IHuy9UiIvnxU6aLSAZ2VcYypdStA9Oz/kWcCU+UUkpEcnFqRXQ18+p7GRG5A/gT8KBS6leu9g3ALGD8UKiiOZS+s64YLtdfVwylsVTTd7Sl5d2nFgj3uNUgIH7AdNqagUPYM60OCZTDQPejn7gHaAaejWv/KTAGWHzNe/QuMMS+s4QMl+uvG4bMWKrpO1q09DMiYoiIX0TyROSzwO3Atwe6X+8WIjISWAAMyVlmhwCzgcNxM8IC7Het1wxShvL1N9zGUk3v0GX8+58ngE8774PAF5RSPx7A/rzb/ABIx54LQ/PeIwcoT9Be71qvGbwM5etvuI2lml6gLS0JEJFVTvZBb5Z5cbt/C7gBWAc8BXxfRP7uWp9DT1zlOUaO8U/Ah4G/VkrtvqYn0Ev64zyHAN25TYa0S2UoMxiuv6tkUIylmmuLtrQk5ijwyV5uW+n+QylV6Wp72YkP/FcR+blS6r006VefzxFARP438FXgK0qp7/dnx/qZqzrPIUAdia0po5zX+gTrNO9xBtH112cG0ViquYZo0ZIApVQ18GQ/HW4H8BlgMu+hmUqv5hydAfPrwNeVUt/qz371N/38XQ5GDgAPiIg/Lq5ljvNaNgB90lwFg+n662fek2Op5tqi3UPvPjcDFonjCgYdIvI17AHzn5VS3xjg7mh65gUgA/hgXPsjQBWw/Zr3SNNnhvn1N6TGUk3f0JaWfkJEfgI0Yj8NnAdygb8A/gfw2FAwZ4rI3wLfBF4F/iQiS9zrlVLbBqRj7wIishY7wDHTaZopIvc5719WSrUOTM+uDKXUKyLyGvBDERmBXdPjAeB9wENDoUZLhKHynXXFcLn+hsNYquk7urhcPyEiHwM+BhRjV3RsBvYBTyqlfjGAXes3RGQTsLKr9UopuXa9eXcRkQpgQherJymlKq5db64OpwDZvwD3Y8eyHAH+VSn16wHtWD8zlL6zRAyX6284jKWavqNFi0aj0Wg0mkGBjmnRaDQajUYzKNCiRaPRaDQazaBAixaNRqPRaDSDAi1aNBqNRqPRDAq0aNFoNBqNRjMo0KJFo9FoNBrNoECLFo1Go9FoNIMCLVo0Go1Go9EMCrRo0Wg0Go1GMyjQokWj0Wg0Gs2gQIsWjUaj0Wg0gwItWjSaYYaI7BORZwe6HxqNRnOlaNGi0QwjRCQdmAVsG+i+aDQazZWiRYtGM7y4AfChRYtGoxmEaNGi0QwDROQvRWQ/sMFpek1EXhSRwoHsl0aj0VwJWrRoNEMcEXkc+AHwa2APcAT4e+B9wK8GsGsajUZzRWjRotEMYUTkHuBvgI8qpb4FjAG2KKV+APwSWCUi+QPZR41Go+ktWrRoNEObLwB7lVK/ccRJEbDLWXfCec0ckJ5pNBrNFaJFi0YzRBGRHOAm4CWn6XrnNSJaxgIdwLlr3DWNRqPpE1q0aDRDl6nY13hElFwPhID9IiLAncBLSqn2AeqfRqPRXBH+ge6ARqN512hyXic5r9cDZUqpDhH5K2Ac8MiA9Eyj0Wj6gBYtGs3Q5TBwAHhURA5j12g5ICL/BPwD8BWl1FsD2UGNRqO5EkQpNdB90Gg07xIiMgn4MXZsSwoQxBYy31ZK6VL+Go1mUKFFi0YzDBCRDwAvAHOUUmUD3B2NRqPpEzoQV6MZHiwCmoFDA90RjUaj6StatGg0w4PFwC6llDXQHdFoNJq+ot1DGo1Go9FoBgXa0qLRaDQajWZQoEWLRqPRaDSaQYEWLRqNRqPRaAYFWrRoNBqNRqMZFGjRotFoNBqNZlCgRYtGo9FoNJpBgRYtGo1Go9FoBgVatGg0Go1GoxkUaNGi0Wg0Go1mUKBFi0aj0Wg0mkGBFi0ajUaj0WgGBVq0aDQajUajGRT8f7eZF/9tAF/wAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(dpi=120)\n", - "\n", - "im = ax.imshow(\n", - " A, interpolation=\"bicubic\", origin=\"lower\", extent=[-pi, pi, -pi, pi]\n", - ")\n", - "ax.contour(\n", - " A, levels=12, linewidths=0.75, colors=\"k\", extent=[-pi, pi, -pi, pi]\n", - ")\n", - "ax.set_xlabel(r\"$\\phi$\")\n", - "ax.set_ylabel(r\"$\\psi$\")\n", - "\n", - "cbar = plt.colorbar(im)\n", - "cbar.ax.set_ylabel(r\"$A~[k_{B}T]$\", rotation=270, labelpad=20)\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "a-LGmeZ_3_m-" - }, - "source": [ - "Lastly, we plot the height of the gaussians as a function of time and observe that their height decreases at an exponential rate as expected for well-tempered metadynamics." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 457 - }, - "id": "SI_fhUW9CGlP", - "outputId": "5d32f99d-4911-44bb-9d89-69c3e6212cb7" - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "_dt = dt #method.context[0].sampler.snapshot.dt\n", - "ts = _dt * 1e-3 * numpy.arange(0, fe_result['heights'].size) * run_result.method.stride\n", - "\n", - "fig, ax = plt.subplots(dpi=120)\n", - "ax.plot(ts, fe_result['heights'], \"o\", mfc=\"none\", ms=4)\n", - "ax.set_xlabel(\"time [ns]\")\n", - "ax.set_ylabel(\"height [kJ/mol]\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "R6rEuwWAZ8Qp" - }, - "outputs": [], - "source": [] - } - ], - "metadata": { - "accelerator": "GPU", - "colab": { - "collapsed_sections": [], - "name": "ADP-Metadynamics.ipynb", - "provenance": [] - }, - "jupytext": { - "formats": "ipynb,md", - "main_language": "python" - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.9.10" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/examples/openmm/pivcv/alanine-dipeptide.py b/examples/openmm/pivcv/alanine-dipeptide.py deleted file mode 100644 index 17383dbb..00000000 --- a/examples/openmm/pivcv/alanine-dipeptide.py +++ /dev/null @@ -1,274 +0,0 @@ -#!/usr/bin/env python3 - -""" -Metadynamics simulation of Alanine Dipeptide in vacuum with OpenMM and PySAGES. - -Example command to run the simulation `python3 alanine-dipeptide.py --time-steps 1000` -For other supported commandline parameters, check `python3 alanine-dipeptide.py --help` -""" - - -# %% -import argparse -import os -import sys -import time - -import numpy -import pysages - -from pysages.colvars import PIV -from pysages.methods import Metadynamics, MetaDLogger -from pysages.utils import try_import -from pysages.approxfun import compute_mesh - -import numpy as onp -from jax import numpy as np -from jax_md.partition import neighbor_list as nlist, space - -import matplotlib.pyplot as plt - -openmm = try_import("openmm", "simtk.openmm") -unit = try_import("openmm.unit", "simtk.unit") -app = try_import("openmm.app", "simtk.openmm.app") - - -# %% -pi = numpy.pi -kB = unit.BOLTZMANN_CONSTANT_kB * unit.AVOGADRO_CONSTANT_NA -kB = kB.value_in_unit(unit.kilojoules_per_mole / unit.kelvin) - -T = 298.15 * unit.kelvin -dt = 2.0 * unit.femtoseconds -adp_pdb = os.path.join(os.pardir, os.pardir, "inputs", "alanine-dipeptide", "adp-vacuum.pdb") - - -# %% -def generate_simulation(pdb_filename=adp_pdb, T=T, dt=dt): - pdb = app.PDBFile(pdb_filename) - - ff = app.ForceField("amber99sb.xml") #, "tip3p.xml") - cutoff_distance = 1.0 * unit.nanometer - topology = pdb.topology - - system = ff.createSystem( - topology, constraints=app.HBonds, nonbondedMethod=app.PME, nonbondedCutoff=cutoff_distance - ) - - # Set dispersion correction use. - forces = {} - for i in range(system.getNumForces()): - force = system.getForce(i) - forces[force.__class__.__name__] = force - - forces["NonbondedForce"].setUseDispersionCorrection(True) - forces["NonbondedForce"].setEwaldErrorTolerance(1.0e-5) - - positions = pdb.getPositions(asNumpy=True) - - integrator = openmm.LangevinIntegrator(T, 1 / unit.picosecond, dt) - - integrator.setRandomNumberSeed(42) - - # platform = openmm.Platform.getPlatformByName(platform) - # simulation = app.Simulation(topology, system, integrator, platform) - simulation = app.Simulation(topology, system, integrator) - simulation.context.setPositions(positions) - simulation.minimizeEnergy() - - simulation.reporters.append(app.PDBReporter("output.pdb", 1000)) - simulation.reporters.append( - app.StateDataReporter("log.dat", 1000, step=True, potentialEnergy=True, temperature=True) - ) - - return simulation - -def gen_neighbor_list(pdb_filename=adp_pdb): - - pdb = app.PDBFile(pdb_filename) - top = pdb.getTopology() - positions = np.array(pdb.getPositions(asNumpy=True), dtype=np.float32) - - dr_threshold = 0.5 - box_size = 3 - nl_cutoff = 1 - displacement_fn, shift_fn = space.periodic(box_size) - neighbor_list_fn = nlist(displacement_fn, box_size, nl_cutoff, dr_threshold, capacity_multiplier=0.5) - neighbors = neighbor_list_fn.allocate(positions) - - return neighbors - - -def gen_atomtype_lists(pdb_filename=adp_pdb, atomtypes=['C', 'N', 'O'], solventname='HOH'): - - pdb = app.PDBFile(pdb_filename) - top = pdb.getTopology() - - # separate each atom type of interest - solute and solvent oxygen into a list - atom_indices = [] - for residue in top.residues(): - if residue.name != solventname: - for atomtype in atomtypes: - for atom in residue.atoms(): - if atom.name.startswith(atomtype): - atom_indices.append([int(atom.id)]) - - solute_list = atom_indices - - oxygen_list = [] - hydrogen_dict = {} - for residue in top.residues(): - if residue.name == solventname: - for atom in residue.atoms(): - if atom.name.startswith('O'): - oxygen_list.append(int(atom.id)) - hatom_list = [] - for bond in residue.bonds(): - if bond.atom1.id == atom.id: - hatom_list.append(int(bond.atom2.id)) - elif bond.atom2.id == atom.id: - hatom_list.append(int(bond.atom1.id)) - hydrogen_dict[int(atom.id)] = hatom_list - - - #atom_indices.append(oxygen_list) - - print("oxygen list") - - print(oxygen_list) - - #print("hydrogen dict") - #print(hydrogen_dict[23]) - - print("\n") - - num_atoms = top.getNumAtoms() - natom_types = len(atomtypes) + 1 - - return atom_indices, solute_list, oxygen_list, hydrogen_dict, num_atoms, natom_types - - -def gen_atompair_list(atom_lists, natom_types, exclude_atomtype_pairindices): - - position_pairs = [] - for i in range(natom_types): - - for j in range(i, natom_types): - - for i_particle in range(len(atom_lists[i])): - - for j_particle in range(len(atom_lists[j])): - - if i == j and j_particle <= i_particle: - continue - - if [i, j] in exclude_atomtype_pairindices: - continue - - position_pairs.append([i, atom_lists[i][i_particle], j, atom_lists[j][j_particle]]) - - return position_pairs - - -# %% -def get_args(argv): - available_args = [ - ("well-tempered", "w", bool, 0, "Whether to use well-tempered metadynamics"), - ("use-grids", "g", bool, 0, "Whether to use grid acceleration"), - ("log", "l", bool, 0, "Whether to use a callback to log data into a file"), - ("time-steps", "t", int, 5e5, "Number of simulation steps"), - ] - parser = argparse.ArgumentParser(description="Example script to run metadynamics") - for (name, short, T, val, doc) in available_args: - parser.add_argument("--" + name, "-" + short, type=T, default=T(val), help=doc) - return parser.parse_args(argv) - - -# %% -def main(argv=[]): - args = get_args(argv) - - atom_indices, solute_list, oxygen_list, hydrogen_dict, num_atoms, natom_types = gen_atomtype_lists() - exclude_atomtype_pairindices = [ [1, 1], [1, 2] ] - - position_pairs = gen_atompair_list(atom_indices, natom_types, exclude_atomtype_pairindices) - - all_atoms = list(onp.arange(num_atoms)) - #atom_indices.append(all_atoms) - - print(atom_indices) - - cvs = [PIV( all_atoms, - position_pairs, - solute_list, - oxygen_list, - hydrogen_dict, - {'r_0': 0.4, 'd_0': 2.3, 'n': 3, 'm': 6}, - {'neighbor_list': gen_neighbor_list()})] - - height = 1.2 # kJ/mol - sigma = [0.35, 0.35] # radians - deltaT = 5000 if args.well_tempered else None - stride = 500 # frequency for depositing gaussians - timesteps = args.time_steps - ngauss = timesteps // stride # total number of gaussians - - ## Grid for storing bias potential and its gradient - #grid = pysages.Grid(lower=(-pi, -pi), upper=(pi, pi), shape=(50, 50), periodic=True) - #grid = grid if args.use_grids else None - - # Method - method = Metadynamics(cvs, height, sigma, stride, ngauss, deltaT=deltaT, kB=kB) # grid=grid) - - # Logging - hills_file = "hills.dat" - callback = MetaDLogger(hills_file, stride) if args.log else None - - tic = time.perf_counter() - run_result = pysages.run(method, generate_simulation, timesteps, callback) - toc = time.perf_counter() - print(f"Completed the simulation in {toc - tic:0.4f} seconds.") - - # Analysis: Calculate free energy using the deposited bias potential - - # generate CV values on a grid to evaluate bias potential - #plot_grid = pysages.Grid(lower=(-pi, -pi), upper=(pi, pi), shape=(64, 64), periodic=True) - #xi = (compute_mesh(plot_grid) + 1) / 2 * plot_grid.size + plot_grid.lower - - # determine bias factor depending on method (for standard = 1 and for well-tempered = (T+deltaT)/deltaT) - #alpha = ( - # 1 - # if method.deltaT is None - # else (T.value_in_unit(unit.kelvin) + method.deltaT) / method.deltaT - #) - #kT = kB * T.value_in_unit(unit.kelvin) - - ## extract metapotential function from result - #result = pysages.analyze(run_result) - #metapotential = result["metapotential"] - - ## report in kT and set min free energy to zero - #A = metapotential(xi) * -alpha / kT - #A = A - A.min() - #A = A.reshape(plot_grid.shape) - - ## plot and save free energy to a PNG file - #fig, ax = plt.subplots(dpi=120) - - #im = ax.imshow(A, interpolation="bicubic", origin="lower", extent=[-pi, pi, -pi, pi]) - #ax.contour(A, levels=12, linewidths=0.75, colors="k", extent=[-pi, pi, -pi, pi]) - #ax.set_xlabel(r"$\phi$") - #ax.set_ylabel(r"$\psi$") - - #cbar = plt.colorbar(im) - #cbar.ax.set_ylabel(r"$A~[k_{B}T]$", rotation=270, labelpad=20) - - #fig.savefig("adp-fe.png", dpi=fig.dpi) - - #return result - - -# %% -if __name__ == "__main__": - - main(sys.argv[1:]) diff --git a/pysages/colvars/__init__.py b/pysages/colvars/__init__.py index ed5c5af4..588d5733 100644 --- a/pysages/colvars/__init__.py +++ b/pysages/colvars/__init__.py @@ -29,7 +29,7 @@ Distance, ) -from .ann import ( +from .piv import ( PIV ) diff --git a/pysages/colvars/ann.py b/pysages/colvars/ann.py deleted file mode 100644 index 2b260f1b..00000000 --- a/pysages/colvars/ann.py +++ /dev/null @@ -1,190 +0,0 @@ -# SPDX-License-Identifier: MIT -# Copyright (c) 2020-2021: PySAGES contributors -# See LICENSE.md and CONTRIBUTORS.md at https://github.com/SSAGESLabs/PySAGES - -""" -Artificial neural network based collective variables -""" - -from jax import numpy as np, vmap -from pysages.colvars.core import CollectiveVariable -from pysages.colvars import coordinates -from pysages.colvars.utils import rational_switching_function -import numpy as onp - -class PIV(CollectiveVariable): - """ - Permutation Invariant Vector (PIV) of a given system of points in space. - - PIV collective variable is generated using the user-defined set of points in space. - Reference to the points is provided as a list of lists containing indices of - unique atom types. PIV is constructed by first computing the unique pairwise distances - between the indices across all the combinations of lists except those specifically - excluded by user. The generated pairwise distances in each cross-pair - list are referred as a block and are wrapped by a switching function. - The values in each block are then sorted. Finally, PIV is - returned as a single vector by catenating all blocks. - - - Parameters - ---------- - indices: ``list`` of ``lists`` - List of lists containing indices of unique atom types. - exclude_indices: ``list`` - List of indices pairs referring index of lists to exclude - in PIV calculation. - switching_params: ``list`` - List of switching function parameters. It contains R_0, m and n values. - - Returns - ------- - piv: JaxArray - Permutation Invariant Vector (PIV) - """ - - def __init__(self, indices, position_pairs, solute_list, solvent_oxygen_list, - hydrogen_dict, switching_params, neighbor_list): - super().__init__(indices, group_length=None) - self.position_pairs = position_pairs - self.solute_list = solute_list - self.solvent_oxygen_list = solvent_oxygen_list - self.hydrogen_dict = hydrogen_dict - self.switching_params = switching_params - self.neighbor_list = neighbor_list['neighbor_list'] - - print("sol list") - print(solute_list) - print(solvent_oxygen_list) - print("end") - - @property - def function(self): - """ - Function generator - - Returns - ------- - Function that generates PIV from a simulation snapshot. - Look at `pysages.colvars.ann.piv` for details. - """ - return lambda *positions, neighbor_list=self.neighbor_list, params=self: piv(positions, neighbor_list, params) - - -def piv(positions, neighbor_list, params): - """ - Implementation of permutation invariant vector as described in - [Section 4, Handb. Mater. Model. 597-619 (2020)](https://doi.org/10.1007/978-3-319-44677-6_51). - - Parameters - ---------- - positions: A ``list`` of ``lists`` containing positions of all atoms and of each atomtype. - - params: A ``object`` containing all the helper parameters. This includes - indices combination to exclude from PIV calculation, switching function - parameters. - - Returns - ------- - piv : DeviceArray - Permutation Invariant Vector (PIV). - """ - - all_atom_positions = np.array(positions) - - neighbor_list = neighbor_list.update(all_atom_positions) - position_pairs = onp.array(params.position_pairs) - solute_list = params.solute_list - solvent_oxygen_list = params.solvent_oxygen_list - - print("solvent_oxygen_list") - print(solvent_oxygen_list) - print("end solvent_oxygen_list") - - hydrogen_dict = params.hydrogen_dict - - i_pos = all_atom_positions[position_pairs[:,1]] - j_pos = all_atom_positions[position_pairs[:,3]] - - piv_solute_blocks = vmap(get_piv_block, in_axes=(0, 0, None))(i_pos, j_pos, params.switching_params) - piv_solute_block_index = vmap(cantor_pair, in_axes=(0,0))(position_pairs[:,0], position_pairs[:,2]) - - idx_solute_sort = np.argsort(piv_solute_block_index) - piv_solute_blocks = piv_solute_blocks[idx_solute_sort] - - if solvent_oxygen_list: - - nsolute_types = len(solute_list) - # for each solute keep oxygen atoms that are their neighbors - solvent_i_j = [] - - solute_list_indices = list(np.arange(nsolute_types)) - - - for i in range(nsolute_types): - _solvent_i_j = [] - - for i_p in solute_list[i]: - - for j in neighbor_list.idx[i_p]: - - # check if j is the id of oxygen atom - if j in solvent_oxygen_list: - _solvent_i_j.append([i, i_p, j]) - _solvent_i_j.append([i, i_p, hydrogen_dict[int(j)][0]]) - _solvent_i_j.append([i, i_p, hydrogen_dict[int(j)][1]]) - - solvent_i_j.append(_solvent_i_j) - - solvent_i_j = onp.array(solvent_i_j) - i_pos = all_atom_positions[solvent_i_j[:,1]] - j_pos = all_atom_positions[solvent_i_j[:,2]] - - piv_solute_solvent_blocks = vmap(get_piv_block, in_axes=(0, 0, None))(i_pos, j_pos, params.switching_params) - piv_solute_solvent_block_index = solvent_i_j[:,0] - - idx_solvent_sort = np.argsort(piv_solute_block_index) - piv_solute_solvent_blocks = piv_solute_solvent_blocks[idx_solvent_sort] - - piv_blocks = np.concatenate( (piv_solute_blocks, piv_solute_solvent_blocks), axis=0) - - else: - - piv_blocks = piv_solute_blocks - - return piv_blocks - - -def get_solute_atoms(solute_list, solute_list_index): - - return solute_list[solute_list_index] - -def get_neighbors_solute_atom(neigbor_list_solute, solute_atom_id): - - return neigbor_list_solute[solute_atom_id] - - -def get_piv_block(i_pos, j_pos, switching_params): - - r_0 = switching_params['r_0'] - d_0 = switching_params['d_0'] - n = switching_params['n'] - m = switching_params['m'] - - r = coordinates.distance(i_pos, j_pos) - s_r = rational_switching_function(r, r_0, d_0, n, m) - - return s_r - - -def cantor_pair(index1, index2): - """ - Generates an uniuqe integer using two integers via Cantor pair function. - This unique integer can be mapped back to the two integers, if needed. - """ - - pi = index1 + index2 - pi = pi * (pi + 1) - pi *= 0.5 - pi += index2 - - return np.int32(pi) \ No newline at end of file diff --git a/pysages/colvars/utils.py b/pysages/colvars/utils.py index 944b43bc..0dae3566 100644 --- a/pysages/colvars/utils.py +++ b/pysages/colvars/utils.py @@ -29,26 +29,25 @@ def wrap(x, P): def rational_switching_function(r, r_0, d_0=0.0, n=6, m=None): """ - Rational switching function applied to a given variable r. It takes - four parameters r_0, d_0, n, and m. + Rational switching function applied to a given variable r. Parameters ---------- - r: ``float`` + r: float variable to which switching function is applied. - r_0 : ``float`` + r_0 : float - d_0: ``float`` = 0.0 + d_0: float = 0.0 - n: ``int`` = 6 + n: int = 6 - m: ``int`` = 2*n + m: int = 2*n Returns ------- - s : ``float`` - Rational switching function applied to a given float. + s : float + Rational switching function applied to a given r. """ if m == None: From c5b334717555ede4339b09157b57f8e18c565ace Mon Sep 17 00:00:00 2001 From: Siva Dasetty Date: Thu, 4 Aug 2022 11:53:37 -0500 Subject: [PATCH 6/9] renamed and updated docs in cv --- .../openmm/metad/pivcv/alanine-dipeptide.py | 275 ++++++++++++++++++ pysages/colvars/piv.py | 221 ++++++++++++++ 2 files changed, 496 insertions(+) create mode 100644 examples/openmm/metad/pivcv/alanine-dipeptide.py create mode 100644 pysages/colvars/piv.py diff --git a/examples/openmm/metad/pivcv/alanine-dipeptide.py b/examples/openmm/metad/pivcv/alanine-dipeptide.py new file mode 100644 index 00000000..51a20305 --- /dev/null +++ b/examples/openmm/metad/pivcv/alanine-dipeptide.py @@ -0,0 +1,275 @@ +#!/usr/bin/env python3 + +""" +Metadynamics simulation of Alanine Dipeptide in vacuum with OpenMM and PySAGES using +Permutation Invariant Vector (PIV) as CVs. + +Example command to run the simulation `python3 alanine-dipeptide.py --time-steps 1000` +For other supported commandline parameters, check `python3 alanine-dipeptide.py --help` +""" + + +# %% +import argparse +import os +import sys +import time + +import numpy +import pysages + +from pysages.colvars import PIV +from pysages.methods import Metadynamics, MetaDLogger +from pysages.utils import try_import +from pysages.approxfun import compute_mesh + +import numpy as onp +from jax import numpy as np +from jax_md.partition import neighbor_list as nlist, space + +import matplotlib.pyplot as plt + +openmm = try_import("openmm", "simtk.openmm") +unit = try_import("openmm.unit", "simtk.unit") +app = try_import("openmm.app", "simtk.openmm.app") + + +# %% +pi = numpy.pi +kB = unit.BOLTZMANN_CONSTANT_kB * unit.AVOGADRO_CONSTANT_NA +kB = kB.value_in_unit(unit.kilojoules_per_mole / unit.kelvin) + +T = 298.15 * unit.kelvin +dt = 2.0 * unit.femtoseconds +adp_pdb = os.path.join(os.pardir, os.pardir, "inputs", "alanine-dipeptide", "adp-vacuum.pdb") + + +# %% +def generate_simulation(pdb_filename=adp_pdb, T=T, dt=dt): + pdb = app.PDBFile(pdb_filename) + + ff = app.ForceField("amber99sb.xml") #, "tip3p.xml") + cutoff_distance = 1.0 * unit.nanometer + topology = pdb.topology + + system = ff.createSystem( + topology, constraints=app.HBonds, nonbondedMethod=app.PME, nonbondedCutoff=cutoff_distance + ) + + # Set dispersion correction use. + forces = {} + for i in range(system.getNumForces()): + force = system.getForce(i) + forces[force.__class__.__name__] = force + + forces["NonbondedForce"].setUseDispersionCorrection(True) + forces["NonbondedForce"].setEwaldErrorTolerance(1.0e-5) + + positions = pdb.getPositions(asNumpy=True) + + integrator = openmm.LangevinIntegrator(T, 1 / unit.picosecond, dt) + + integrator.setRandomNumberSeed(42) + + # platform = openmm.Platform.getPlatformByName(platform) + # simulation = app.Simulation(topology, system, integrator, platform) + simulation = app.Simulation(topology, system, integrator) + simulation.context.setPositions(positions) + simulation.minimizeEnergy() + + simulation.reporters.append(app.PDBReporter("output.pdb", 1000)) + simulation.reporters.append( + app.StateDataReporter("log.dat", 1000, step=True, potentialEnergy=True, temperature=True) + ) + + return simulation + +def gen_neighbor_list(pdb_filename=adp_pdb): + + pdb = app.PDBFile(pdb_filename) + top = pdb.getTopology() + positions = np.array(pdb.getPositions(asNumpy=True), dtype=np.float32) + + dr_threshold = 0.5 + box_size = 3 + nl_cutoff = 1 + displacement_fn, shift_fn = space.periodic(box_size) + neighbor_list_fn = nlist(displacement_fn, box_size, nl_cutoff, dr_threshold, capacity_multiplier=0.5) + neighbors = neighbor_list_fn.allocate(positions) + + return neighbors + + +def gen_atomtype_lists(pdb_filename=adp_pdb, atomtypes=['C', 'N', 'O'], solventname='HOH'): + + pdb = app.PDBFile(pdb_filename) + top = pdb.getTopology() + + # separate each atom type of interest - solute and solvent oxygen into a list + atom_indices = [] + for residue in top.residues(): + if residue.name != solventname: + for atomtype in atomtypes: + for atom in residue.atoms(): + if atom.name.startswith(atomtype): + atom_indices.append([int(atom.id)]) + + solute_list = atom_indices + + oxygen_list = [] + hydrogen_dict = {} + for residue in top.residues(): + if residue.name == solventname: + for atom in residue.atoms(): + if atom.name.startswith('O'): + oxygen_list.append(int(atom.id)) + hatom_list = [] + for bond in residue.bonds(): + if bond.atom1.id == atom.id: + hatom_list.append(int(bond.atom2.id)) + elif bond.atom2.id == atom.id: + hatom_list.append(int(bond.atom1.id)) + hydrogen_dict[int(atom.id)] = hatom_list + + + #atom_indices.append(oxygen_list) + + print("oxygen list") + + print(oxygen_list) + + #print("hydrogen dict") + #print(hydrogen_dict[23]) + + print("\n") + + num_atoms = top.getNumAtoms() + natom_types = len(atomtypes) + 1 + + return atom_indices, solute_list, oxygen_list, hydrogen_dict, num_atoms, natom_types + + +def gen_atompair_list(atom_lists, natom_types, exclude_atomtype_pairindices): + + position_pairs = [] + for i in range(natom_types): + + for j in range(i, natom_types): + + for i_particle in range(len(atom_lists[i])): + + for j_particle in range(len(atom_lists[j])): + + if i == j and j_particle <= i_particle: + continue + + if [i, j] in exclude_atomtype_pairindices: + continue + + position_pairs.append([i, atom_lists[i][i_particle], j, atom_lists[j][j_particle]]) + + return position_pairs + + +# %% +def get_args(argv): + available_args = [ + ("well-tempered", "w", bool, 0, "Whether to use well-tempered metadynamics"), + ("use-grids", "g", bool, 0, "Whether to use grid acceleration"), + ("log", "l", bool, 0, "Whether to use a callback to log data into a file"), + ("time-steps", "t", int, 5e5, "Number of simulation steps"), + ] + parser = argparse.ArgumentParser(description="Example script to run metadynamics") + for (name, short, T, val, doc) in available_args: + parser.add_argument("--" + name, "-" + short, type=T, default=T(val), help=doc) + return parser.parse_args(argv) + + +# %% +def main(argv=[]): + args = get_args(argv) + + atom_indices, solute_list, oxygen_list, hydrogen_dict, num_atoms, natom_types = gen_atomtype_lists() + exclude_atomtype_pairindices = [ [1, 1], [1, 2] ] + + position_pairs = gen_atompair_list(atom_indices, natom_types, exclude_atomtype_pairindices) + + all_atoms = list(onp.arange(num_atoms)) + #atom_indices.append(all_atoms) + + print(atom_indices) + + cvs = [PIV( all_atoms, + position_pairs, + solute_list, + oxygen_list, + hydrogen_dict, + {'r_0': 0.4, 'd_0': 2.3, 'n': 3, 'm': 6}, + {'neighbor_list': gen_neighbor_list()})] + + height = 1.2 # kJ/mol + sigma = [0.35, 0.35] # radians + deltaT = 5000 if args.well_tempered else None + stride = 500 # frequency for depositing gaussians + timesteps = args.time_steps + ngauss = timesteps // stride # total number of gaussians + + ## Grid for storing bias potential and its gradient + #grid = pysages.Grid(lower=(-pi, -pi), upper=(pi, pi), shape=(50, 50), periodic=True) + #grid = grid if args.use_grids else None + + # Method + method = Metadynamics(cvs, height, sigma, stride, ngauss, deltaT=deltaT, kB=kB) # grid=grid) + + # Logging + hills_file = "hills.dat" + callback = MetaDLogger(hills_file, stride) if args.log else None + + tic = time.perf_counter() + run_result = pysages.run(method, generate_simulation, timesteps, callback) + toc = time.perf_counter() + print(f"Completed the simulation in {toc - tic:0.4f} seconds.") + + # Analysis: Calculate free energy using the deposited bias potential + + # generate CV values on a grid to evaluate bias potential + #plot_grid = pysages.Grid(lower=(-pi, -pi), upper=(pi, pi), shape=(64, 64), periodic=True) + #xi = (compute_mesh(plot_grid) + 1) / 2 * plot_grid.size + plot_grid.lower + + # determine bias factor depending on method (for standard = 1 and for well-tempered = (T+deltaT)/deltaT) + #alpha = ( + # 1 + # if method.deltaT is None + # else (T.value_in_unit(unit.kelvin) + method.deltaT) / method.deltaT + #) + #kT = kB * T.value_in_unit(unit.kelvin) + + ## extract metapotential function from result + #result = pysages.analyze(run_result) + #metapotential = result["metapotential"] + + ## report in kT and set min free energy to zero + #A = metapotential(xi) * -alpha / kT + #A = A - A.min() + #A = A.reshape(plot_grid.shape) + + ## plot and save free energy to a PNG file + #fig, ax = plt.subplots(dpi=120) + + #im = ax.imshow(A, interpolation="bicubic", origin="lower", extent=[-pi, pi, -pi, pi]) + #ax.contour(A, levels=12, linewidths=0.75, colors="k", extent=[-pi, pi, -pi, pi]) + #ax.set_xlabel(r"$\phi$") + #ax.set_ylabel(r"$\psi$") + + #cbar = plt.colorbar(im) + #cbar.ax.set_ylabel(r"$A~[k_{B}T]$", rotation=270, labelpad=20) + + #fig.savefig("adp-fe.png", dpi=fig.dpi) + + #return result + + +# %% +if __name__ == "__main__": + + main(sys.argv[1:]) diff --git a/pysages/colvars/piv.py b/pysages/colvars/piv.py new file mode 100644 index 00000000..5707520a --- /dev/null +++ b/pysages/colvars/piv.py @@ -0,0 +1,221 @@ +# SPDX-License-Identifier: MIT +# Copyright (c) 2020-2021: PySAGES contributors +# See LICENSE.md and CONTRIBUTORS.md at https://github.com/SSAGESLabs/PySAGES + +""" +Implementation of Permutation Invariant Vector (PIV) as described in +[Handb. Mater. Model.: Theor. and Model., 597-619 (2020)] +(https://doi.org/10.1007/978-3-319-44677-6_51) by Fabio Petrucci +""" + +from jax import numpy as np, vmap + +from pysages.colvars.core import CollectiveVariable +from pysages.colvars import coordinates +from pysages.colvars.utils import rational_switching_function + +import numpy as onp + +class PIV(CollectiveVariable): + """ + Permutation Invariant Vector (PIV) of a given system of points + in space as described in Section 4 of + [Handb. Mater. Model.: Theor. and Model., 597-619 (2020)] + (https://doi.org/10.1007/978-3-319-44677-6_51). + + PIV collective variable is generated using the user-defined + set of points in space. These points are typically the coordinates + of solute and solvent. Single or multiple solutes in a given + solvent can be defined. For determining solvent atoms in a solvation + shell around solute, + [JAX MD](https://jax-md.readthedocs.io/en/main/jax_md.partition.html) + neighborlist library is utilized. This requires the user + to define the indices of all the atoms in the system and a JAX MD + neighbor list function + (see alanine dipeptide example in examples/openmm/metad/pivcv). + + solute-solute blocks of the PIV are determined by using the indices + of the solute pairs defined by the user. To sort solute-solute blocks + and solute-solvent blocks, user need to provide the indices of all + solute atoms and oxygen atoms in two separate lists. The indices + of the hydrogen atoms bonded to the oxygen atoms are determined + by using the oxygen-hydrogen dictionary provided by the user. + + The switching function parameters parameters for each block + should be provided as a list of dictionaries. + + Example definition: + cvs = [PIV( all_atoms, position_pairs, solute_list, oxygen_list, + hydrogen_dict, [{'r_0': 0.4, 'd_0': 2.3, 'n': 3, 'm': 6}, ...], + {'neighbor_list': gen_neighbor_list()})] + + Parameters + ---------- + allatoms: list + List of indices of all atoms required for updating neighbor list. + position_pairs: Array + Array containing indices of solute-solute pairs for the solute-solute + block of PIV. + solute_list: Array + Indices of all solute atoms + oxygen_list: Array + Indices of all oxygen atoms + hydrogen_dict: dict + Dictionary mapping each oxygen in water with their hydrogen atoms. + switching_params: dict + Dictionary containing switching function parameters. + neighbor_list: Object + JAX MD neighbor list function to update the neighbor list. + + Returns + ------- + piv: JaxArray + Permutation Invariant Vector (PIV) + """ + + def __init__(self, indices, position_pairs, solute_list, solvent_oxygen_list, + hydrogen_dict, switching_params, neighbor_list): + super().__init__(indices, group_length=None) + self.position_pairs = position_pairs + self.solute_list = solute_list + self.solvent_oxygen_list = solvent_oxygen_list + self.hydrogen_dict = hydrogen_dict + self.switching_params = switching_params + self.neighbor_list = neighbor_list['neighbor_list'] + + @property + def function(self): + """ + Function generator + + Returns + ------- + Function that generates PIV from a simulation snapshot. + Look at `pysages.colvars.ann.piv` for details. + """ + #return lambda *positions, neighbor_list=self.neighbor_list, params=self: piv(positions, neighbor_list, params) + return lambda *positions: piv(positions, self.neighbor_list, self) + + +def piv(positions, neighbor_list, params): + """ + Implementation of permutation invariant vector as described in + [Section 4, Handb. Mater. Model. 597-619 (2020)] + (https://doi.org/10.1007/978-3-319-44677-6_51) by Fabio Petrucci. + + Parameters + ---------- + positions: Array + Contains positions of all atoms in the system. + neighbor_list: Object + Points to function to update neighbor list. + params: Object + Links to all the helper parameters. This includes + indices combination to exclude from PIV calculation, switching function + parameters. + + Returns + ------- + piv : DeviceArray + Permutation Invariant Vector (PIV). + """ + + all_atom_positions = np.array(positions) + + neighbor_list = neighbor_list.update(all_atom_positions) + position_pairs = onp.array(params.position_pairs) + solute_list = params.solute_list + solvent_oxygen_list = params.solvent_oxygen_list + + print("solvent_oxygen_list") + print(solvent_oxygen_list) + print("end solvent_oxygen_list") + + hydrogen_dict = params.hydrogen_dict + + i_pos = all_atom_positions[position_pairs[:,1]] + j_pos = all_atom_positions[position_pairs[:,3]] + + piv_solute_blocks = vmap(get_piv_block, in_axes=(0, 0, None))(i_pos, j_pos, params.switching_params) + piv_solute_block_index = vmap(cantor_pair, in_axes=(0,0))(position_pairs[:,0], position_pairs[:,2]) + + idx_solute_sort = np.argsort(piv_solute_block_index) + piv_solute_blocks = piv_solute_blocks[idx_solute_sort] + + if solvent_oxygen_list: + + nsolute_types = len(solute_list) + # for each solute keep oxygen atoms that are their neighbors + solvent_i_j = [] + + solute_list_indices = list(np.arange(nsolute_types)) + + + for i in range(nsolute_types): + _solvent_i_j = [] + + for i_p in solute_list[i]: + + for j in neighbor_list.idx[i_p]: + + # check if j is the id of oxygen atom + if j in solvent_oxygen_list: + _solvent_i_j.append([i, i_p, j]) + _solvent_i_j.append([i, i_p, hydrogen_dict[int(j)][0]]) + _solvent_i_j.append([i, i_p, hydrogen_dict[int(j)][1]]) + + solvent_i_j.append(_solvent_i_j) + + solvent_i_j = onp.array(solvent_i_j) + i_pos = all_atom_positions[solvent_i_j[:,1]] + j_pos = all_atom_positions[solvent_i_j[:,2]] + + piv_solute_solvent_blocks = vmap(get_piv_block, in_axes=(0, 0, None))(i_pos, j_pos, params.switching_params) + piv_solute_solvent_block_index = solvent_i_j[:,0] + + idx_solvent_sort = np.argsort(piv_solute_block_index) + piv_solute_solvent_blocks = piv_solute_solvent_blocks[idx_solvent_sort] + + piv_blocks = np.concatenate( (piv_solute_blocks, piv_solute_solvent_blocks), axis=0) + + else: + + piv_blocks = piv_solute_blocks + + return piv_blocks + + +def get_solute_atoms(solute_list, solute_list_index): + + return solute_list[solute_list_index] + +def get_neighbors_solute_atom(neigbor_list_solute, solute_atom_id): + + return neigbor_list_solute[solute_atom_id] + + +def get_piv_block(i_pos, j_pos, switching_params): + + r_0 = switching_params['r_0'] + d_0 = switching_params['d_0'] + n = switching_params['n'] + m = switching_params['m'] + + r = coordinates.distance(i_pos, j_pos) + s_r = rational_switching_function(r, r_0, d_0, n, m) + + return s_r + + +def cantor_pair(index1, index2): + """ + Generates an uniuqe integer using two integers via Cantor pair function. + This unique integer can be mapped back to the two integers, if needed. + """ + + pi = index1 + index2 + pi = pi * (pi + 1) + pi *= 0.5 + pi += index2 + + return np.int32(pi) \ No newline at end of file From 076465632636f4a317accf22c3d0f1760c20af53 Mon Sep 17 00:00:00 2001 From: Siva Dasetty Date: Fri, 5 Aug 2022 08:12:42 -0500 Subject: [PATCH 7/9] minor changes -- testing and debug --- .../openmm/metad/pivcv/alanine-dipeptide.py | 11 +++---- pysages/colvars/piv.py | 32 +++++++++++-------- 2 files changed, 23 insertions(+), 20 deletions(-) diff --git a/examples/openmm/metad/pivcv/alanine-dipeptide.py b/examples/openmm/metad/pivcv/alanine-dipeptide.py index 51a20305..7ff13df0 100644 --- a/examples/openmm/metad/pivcv/alanine-dipeptide.py +++ b/examples/openmm/metad/pivcv/alanine-dipeptide.py @@ -1,7 +1,7 @@ #!/usr/bin/env python3 """ -Metadynamics simulation of Alanine Dipeptide in vacuum with OpenMM and PySAGES using +Metadynamics simulation of Alanine Dipeptide in water with OpenMM and PySAGES using Permutation Invariant Vector (PIV) as CVs. Example command to run the simulation `python3 alanine-dipeptide.py --time-steps 1000` @@ -41,7 +41,7 @@ T = 298.15 * unit.kelvin dt = 2.0 * unit.femtoseconds -adp_pdb = os.path.join(os.pardir, os.pardir, "inputs", "alanine-dipeptide", "adp-vacuum.pdb") +adp_pdb = os.path.join(os.pardir, os.pardir, os.pardir, "inputs", "alanine-dipeptide", "adp-vacuum.pdb") # %% @@ -134,9 +134,8 @@ def gen_atomtype_lists(pdb_filename=adp_pdb, atomtypes=['C', 'N', 'O'], solventn #atom_indices.append(oxygen_list) - print("oxygen list") - - print(oxygen_list) + #print("oxygen list") + #print(oxygen_list) #print("hydrogen dict") #print(hydrogen_dict[23]) @@ -168,7 +167,7 @@ def gen_atompair_list(atom_lists, natom_types, exclude_atomtype_pairindices): position_pairs.append([i, atom_lists[i][i_particle], j, atom_lists[j][j_particle]]) - return position_pairs + return np.array(position_pairs) # %% diff --git a/pysages/colvars/piv.py b/pysages/colvars/piv.py index 5707520a..0ca1c7e2 100644 --- a/pysages/colvars/piv.py +++ b/pysages/colvars/piv.py @@ -23,28 +23,30 @@ class PIV(CollectiveVariable): [Handb. Mater. Model.: Theor. and Model., 597-619 (2020)] (https://doi.org/10.1007/978-3-319-44677-6_51). - PIV collective variable is generated using the user-defined - set of points in space. These points are typically the coordinates + PIV collective variable is generated by using the user-defined + points in space. These points are typically the coordinates of solute and solvent. Single or multiple solutes in a given - solvent can be defined. For determining solvent atoms in a solvation + solvent are supported. For determining solvent atoms in a solvation shell around solute, [JAX MD](https://jax-md.readthedocs.io/en/main/jax_md.partition.html) neighborlist library is utilized. This requires the user to define the indices of all the atoms in the system and a JAX MD - neighbor list function - (see alanine dipeptide example in examples/openmm/metad/pivcv). + neighbor list callable + (see alanine dipeptide example in examples/openmm/metad/pivcv) for + updating the neighbor list. solute-solute blocks of the PIV are determined by using the indices - of the solute pairs defined by the user. To sort solute-solute blocks + of the solute pairs generated by the user. To sort solute-solute blocks and solute-solvent blocks, user need to provide the indices of all solute atoms and oxygen atoms in two separate lists. The indices of the hydrogen atoms bonded to the oxygen atoms are determined - by using the oxygen-hydrogen dictionary provided by the user. + by using the oxygen-hydrogen dictionary generated by the user using + a PDB file of the system configuration. The switching function parameters parameters for each block should be provided as a list of dictionaries. - Example definition: + Example PIV CV definition: cvs = [PIV( all_atoms, position_pairs, solute_list, oxygen_list, hydrogen_dict, [{'r_0': 0.4, 'd_0': 2.3, 'n': 3, 'm': 6}, ...], {'neighbor_list': gen_neighbor_list()})] @@ -53,10 +55,10 @@ class PIV(CollectiveVariable): ---------- allatoms: list List of indices of all atoms required for updating neighbor list. - position_pairs: Array + position_pairs: JaxArray Array containing indices of solute-solute pairs for the solute-solute block of PIV. - solute_list: Array + solute_list: JaxArray Indices of all solute atoms oxygen_list: Array Indices of all oxygen atoms @@ -64,7 +66,7 @@ class PIV(CollectiveVariable): Dictionary mapping each oxygen in water with their hydrogen atoms. switching_params: dict Dictionary containing switching function parameters. - neighbor_list: Object + neighbor_list: Callable JAX MD neighbor list function to update the neighbor list. Returns @@ -94,7 +96,7 @@ def function(self): Look at `pysages.colvars.ann.piv` for details. """ #return lambda *positions, neighbor_list=self.neighbor_list, params=self: piv(positions, neighbor_list, params) - return lambda *positions: piv(positions, self.neighbor_list, self) + return lambda positions: piv(positions, self.neighbor_list, self) def piv(positions, neighbor_list, params): @@ -107,7 +109,7 @@ def piv(positions, neighbor_list, params): ---------- positions: Array Contains positions of all atoms in the system. - neighbor_list: Object + neighbor_list: JaxArray Points to function to update neighbor list. params: Object Links to all the helper parameters. This includes @@ -127,6 +129,8 @@ def piv(positions, neighbor_list, params): solute_list = params.solute_list solvent_oxygen_list = params.solvent_oxygen_list + print("position pairs") + print(position_pairs) print("solvent_oxygen_list") print(solvent_oxygen_list) print("end solvent_oxygen_list") @@ -182,7 +186,7 @@ def piv(positions, neighbor_list, params): piv_blocks = piv_solute_blocks - return piv_blocks + return piv_blocks[0] def get_solute_atoms(solute_list, solute_list_index): From 83c28a9b41916afb62e9945257b55a9c065e7749 Mon Sep 17 00:00:00 2001 From: Siva Dasetty Date: Tue, 9 Aug 2022 19:55:31 -0500 Subject: [PATCH 8/9] crude state complete - clean up.test pending --- .../openmm/metad/pivcv/alanine-dipeptide.py | 64 +++++++---- pysages/colvars/piv.py | 100 ++++++++---------- 2 files changed, 89 insertions(+), 75 deletions(-) diff --git a/examples/openmm/metad/pivcv/alanine-dipeptide.py b/examples/openmm/metad/pivcv/alanine-dipeptide.py index 7ff13df0..cbf090f5 100644 --- a/examples/openmm/metad/pivcv/alanine-dipeptide.py +++ b/examples/openmm/metad/pivcv/alanine-dipeptide.py @@ -26,6 +26,7 @@ import numpy as onp from jax import numpy as np from jax_md.partition import neighbor_list as nlist, space +from jax_md.partition import NeighborListFormat import matplotlib.pyplot as plt @@ -41,14 +42,14 @@ T = 298.15 * unit.kelvin dt = 2.0 * unit.femtoseconds -adp_pdb = os.path.join(os.pardir, os.pardir, os.pardir, "inputs", "alanine-dipeptide", "adp-vacuum.pdb") +adp_pdb = os.path.join(os.pardir, os.pardir, os.pardir, "inputs", "alanine-dipeptide", "adp-explicit.pdb") # %% def generate_simulation(pdb_filename=adp_pdb, T=T, dt=dt): pdb = app.PDBFile(pdb_filename) - ff = app.ForceField("amber99sb.xml") #, "tip3p.xml") + ff = app.ForceField("amber99sb.xml", "tip3p.xml") cutoff_distance = 1.0 * unit.nanometer topology = pdb.topology @@ -84,7 +85,7 @@ def generate_simulation(pdb_filename=adp_pdb, T=T, dt=dt): return simulation -def gen_neighbor_list(pdb_filename=adp_pdb): +def gen_neighbor_list(pdb_filename, custom_mask_function): pdb = app.PDBFile(pdb_filename) top = pdb.getTopology() @@ -94,7 +95,8 @@ def gen_neighbor_list(pdb_filename=adp_pdb): box_size = 3 nl_cutoff = 1 displacement_fn, shift_fn = space.periodic(box_size) - neighbor_list_fn = nlist(displacement_fn, box_size, nl_cutoff, dr_threshold, capacity_multiplier=0.5) + neighbor_list_fn = nlist(displacement_fn, box_size, nl_cutoff, dr_threshold, capacity_multiplier=0.5, + custom_mask_function=custom_mask_function, format=NeighborListFormat.Dense) neighbors = neighbor_list_fn.allocate(positions) return neighbors @@ -106,46 +108,57 @@ def gen_atomtype_lists(pdb_filename=adp_pdb, atomtypes=['C', 'N', 'O'], solventn top = pdb.getTopology() # separate each atom type of interest - solute and solvent oxygen into a list - atom_indices = [] + solute_list = [] for residue in top.residues(): if residue.name != solventname: for atomtype in atomtypes: for atom in residue.atoms(): if atom.name.startswith(atomtype): - atom_indices.append([int(atom.id)]) - - solute_list = atom_indices + solute_list.append([int(atom.id)-1]) + + solute_atoms = [] oxygen_list = [] hydrogen_dict = {} + hydrogen_array = np.ones((pdb.topology.getNumAtoms(), 2))*(-1000) for residue in top.residues(): if residue.name == solventname: for atom in residue.atoms(): if atom.name.startswith('O'): - oxygen_list.append(int(atom.id)) + oxygen_list.append(int(atom.id)-1) hatom_list = [] for bond in residue.bonds(): if bond.atom1.id == atom.id: - hatom_list.append(int(bond.atom2.id)) + hatom_list.append(int(bond.atom2.id)-1) elif bond.atom2.id == atom.id: - hatom_list.append(int(bond.atom1.id)) - hydrogen_dict[int(atom.id)] = hatom_list + hatom_list.append(int(bond.atom1.id)-1) + hydrogen_dict[int(atom.id)-1] = hatom_list + hydrogen_array = hydrogen_array.at[int(atom.id)-1].set(np.array(hatom_list)) + if atom.name.startswith('H'): + solute_atoms.append(int(atom.id)-1) + else: + for atom in residue.atoms(): + solute_atoms.append(int(atom.id)-1) + #atom_indices.append(oxygen_list) - #print("oxygen list") - #print(oxygen_list) + print("oxygen list") + print(oxygen_list) - #print("hydrogen dict") - #print(hydrogen_dict[23]) + print("hydrogen dict") + print(hydrogen_dict[22]) + + print("hydrogen array") + print(hydrogen_array) print("\n") num_atoms = top.getNumAtoms() natom_types = len(atomtypes) + 1 - return atom_indices, solute_list, oxygen_list, hydrogen_dict, num_atoms, natom_types + return solute_atoms, solute_list, oxygen_list, hydrogen_array, num_atoms, natom_types def gen_atompair_list(atom_lists, natom_types, exclude_atomtype_pairindices): @@ -188,23 +201,32 @@ def get_args(argv): def main(argv=[]): args = get_args(argv) - atom_indices, solute_list, oxygen_list, hydrogen_dict, num_atoms, natom_types = gen_atomtype_lists() + atom_indices, solute_list, oxygen_list, hydrogen_array, num_atoms, natom_types = gen_atomtype_lists() exclude_atomtype_pairindices = [ [1, 1], [1, 2] ] - position_pairs = gen_atompair_list(atom_indices, natom_types, exclude_atomtype_pairindices) + position_pairs = gen_atompair_list(solute_list, natom_types, exclude_atomtype_pairindices) all_atoms = list(onp.arange(num_atoms)) #atom_indices.append(all_atoms) + print("solute atoms ") + print(np.array(solute_list).flatten()) + print(atom_indices) + + def filter_solvent_neighbors(idx): + mask = np.isin(idx, np.array(atom_indices), invert=True) + return np.where(mask, idx, num_atoms) + #return idx cvs = [PIV( all_atoms, position_pairs, solute_list, oxygen_list, - hydrogen_dict, + hydrogen_array, {'r_0': 0.4, 'd_0': 2.3, 'n': 3, 'm': 6}, - {'neighbor_list': gen_neighbor_list()})] + {'neighbor_list': gen_neighbor_list(adp_pdb, + filter_solvent_neighbors)})] height = 1.2 # kJ/mol sigma = [0.35, 0.35] # radians diff --git a/pysages/colvars/piv.py b/pysages/colvars/piv.py index 0ca1c7e2..d4a82454 100644 --- a/pysages/colvars/piv.py +++ b/pysages/colvars/piv.py @@ -76,12 +76,12 @@ class PIV(CollectiveVariable): """ def __init__(self, indices, position_pairs, solute_list, solvent_oxygen_list, - hydrogen_dict, switching_params, neighbor_list): + hydrogen_array, switching_params, neighbor_list): super().__init__(indices, group_length=None) self.position_pairs = position_pairs self.solute_list = solute_list self.solvent_oxygen_list = solvent_oxygen_list - self.hydrogen_dict = hydrogen_dict + self.hydrogen_array = hydrogen_array self.switching_params = switching_params self.neighbor_list = neighbor_list['neighbor_list'] @@ -123,64 +123,59 @@ def piv(positions, neighbor_list, params): """ all_atom_positions = np.array(positions) - neighbor_list = neighbor_list.update(all_atom_positions) - position_pairs = onp.array(params.position_pairs) + position_pairs = params.position_pairs solute_list = params.solute_list solvent_oxygen_list = params.solvent_oxygen_list - - print("position pairs") - print(position_pairs) - print("solvent_oxygen_list") - print(solvent_oxygen_list) - print("end solvent_oxygen_list") - - hydrogen_dict = params.hydrogen_dict + hydrogen_array = params.hydrogen_array i_pos = all_atom_positions[position_pairs[:,1]] j_pos = all_atom_positions[position_pairs[:,3]] piv_solute_blocks = vmap(get_piv_block, in_axes=(0, 0, None))(i_pos, j_pos, params.switching_params) - piv_solute_block_index = vmap(cantor_pair, in_axes=(0,0))(position_pairs[:,0], position_pairs[:,2]) + piv_solute_block_index = vmap(cantor_pair, in_axes=(0, 0))(position_pairs[:,0], position_pairs[:,2]) idx_solute_sort = np.argsort(piv_solute_block_index) piv_solute_blocks = piv_solute_blocks[idx_solute_sort] if solvent_oxygen_list: - - nsolute_types = len(solute_list) - # for each solute keep oxygen atoms that are their neighbors - solvent_i_j = [] - solute_list_indices = list(np.arange(nsolute_types)) + nlist = neighbor_list.idx + atom_ids = np.arange(np.shape(nlist)[0])[:, np.newaxis] + atom_ids_nlist = np.hstack((atom_ids, nlist)) + solute_atom_ids_nlist = atom_ids_nlist[np.array(solute_list).flatten()] + oxygen_array = solute_atom_ids_nlist[:,1:] + solute_array = solute_atom_ids_nlist[:,0] + solute_array = np.repeat(solute_array, np.shape(oxygen_array)[1]) + solute_array = np.reshape(solute_array, np.shape(oxygen_array)) + solute_array = solute_array[:, :, np.newaxis] + block_ids = np.arange(np.shape(solute_list)[0]) + block_ids = np.repeat(block_ids, np.shape(oxygen_array)[1]) + block_ids = np.reshape(block_ids, np.shape(oxygen_array)) + block_ids = block_ids[:, :, np.newaxis] - for i in range(nsolute_types): - _solvent_i_j = [] - - for i_p in solute_list[i]: - - for j in neighbor_list.idx[i_p]: - - # check if j is the id of oxygen atom - if j in solvent_oxygen_list: - _solvent_i_j.append([i, i_p, j]) - _solvent_i_j.append([i, i_p, hydrogen_dict[int(j)][0]]) - _solvent_i_j.append([i, i_p, hydrogen_dict[int(j)][1]]) - - solvent_i_j.append(_solvent_i_j) - - solvent_i_j = onp.array(solvent_i_j) - i_pos = all_atom_positions[solvent_i_j[:,1]] - j_pos = all_atom_positions[solvent_i_j[:,2]] - - piv_solute_solvent_blocks = vmap(get_piv_block, in_axes=(0, 0, None))(i_pos, j_pos, params.switching_params) - piv_solute_solvent_block_index = solvent_i_j[:,0] + hydrogen_array = hydrogen_array[oxygen_array.flatten()] + hydrogen_array = np.array(hydrogen_array, dtype=int) + hydrogen_array = np.reshape(hydrogen_array, (*np.shape(oxygen_array)[:2], 2)) - idx_solvent_sort = np.argsort(piv_solute_block_index) - piv_solute_solvent_blocks = piv_solute_solvent_blocks[idx_solvent_sort] + + solute_atom_ids_nlist = np.dstack((block_ids, solute_array, + oxygen_array, hydrogen_array)).reshape(-1,5) + + + i_pos = all_atom_positions[solute_atom_ids_nlist[:,1]] + j_pos = all_atom_positions[solute_atom_ids_nlist[:,2]] + piv_solute_solvent_blocks = vmap(get_piv_block, in_axes=(0, 0, None))(i_pos, j_pos, params.switching_params) + piv_solute_solvent_block_index = solute_atom_ids_nlist[:,0] + idx_solvent_sort = np.argsort(piv_solute_solvent_block_index) + piv_solute_solvent_blocks = piv_solute_solvent_blocks[idx_solvent_sort] + piv_solute_solvent_blocks = piv_solute_solvent_blocks.flatten() + + piv_blocks = np.concatenate( (piv_solute_blocks, piv_solute_solvent_blocks), axis=0) + else: @@ -189,15 +184,6 @@ def piv(positions, neighbor_list, params): return piv_blocks[0] -def get_solute_atoms(solute_list, solute_list_index): - - return solute_list[solute_list_index] - -def get_neighbors_solute_atom(neigbor_list_solute, solute_atom_id): - - return neigbor_list_solute[solute_atom_id] - - def get_piv_block(i_pos, j_pos, switching_params): r_0 = switching_params['r_0'] @@ -211,15 +197,21 @@ def get_piv_block(i_pos, j_pos, switching_params): return s_r -def cantor_pair(index1, index2): +def cantor_pair(int1, int2): """ Generates an uniuqe integer using two integers via Cantor pair function. This unique integer can be mapped back to the two integers, if needed. """ - pi = index1 + index2 + pi = int1 + int2 pi = pi * (pi + 1) pi *= 0.5 - pi += index2 + pi += int2 + + return np.int32(pi) + + + + - return np.int32(pi) \ No newline at end of file + \ No newline at end of file From bbb6d53614019c6894df5bf873629703ad015430 Mon Sep 17 00:00:00 2001 From: Siva Dasetty Date: Mon, 15 Aug 2022 13:23:05 -0500 Subject: [PATCH 9/9] NumPy crude state - Minor modifications to comments --- .../openmm/metad/pivcv/alanine-dipeptide.py | 4 +- pysages/colvars/piv.py | 72 +++++++++++-------- 2 files changed, 44 insertions(+), 32 deletions(-) diff --git a/examples/openmm/metad/pivcv/alanine-dipeptide.py b/examples/openmm/metad/pivcv/alanine-dipeptide.py index cbf090f5..50520d8c 100644 --- a/examples/openmm/metad/pivcv/alanine-dipeptide.py +++ b/examples/openmm/metad/pivcv/alanine-dipeptide.py @@ -225,8 +225,8 @@ def filter_solvent_neighbors(idx): oxygen_list, hydrogen_array, {'r_0': 0.4, 'd_0': 2.3, 'n': 3, 'm': 6}, - {'neighbor_list': gen_neighbor_list(adp_pdb, - filter_solvent_neighbors)})] + {'update_neighborlist': gen_neighbor_list(adp_pdb, + filter_solvent_neighbors)}) ] height = 1.2 # kJ/mol sigma = [0.35, 0.35] # radians diff --git a/pysages/colvars/piv.py b/pysages/colvars/piv.py index d4a82454..7d634484 100644 --- a/pysages/colvars/piv.py +++ b/pysages/colvars/piv.py @@ -48,7 +48,7 @@ class PIV(CollectiveVariable): Example PIV CV definition: cvs = [PIV( all_atoms, position_pairs, solute_list, oxygen_list, - hydrogen_dict, [{'r_0': 0.4, 'd_0': 2.3, 'n': 3, 'm': 6}, ...], + hydrogen_array, [{'r_0': 0.4, 'd_0': 2.3, 'n': 3, 'm': 6}, ...], {'neighbor_list': gen_neighbor_list()})] Parameters @@ -58,14 +58,15 @@ class PIV(CollectiveVariable): position_pairs: JaxArray Array containing indices of solute-solute pairs for the solute-solute block of PIV. - solute_list: JaxArray + solute_array: JaxArray Indices of all solute atoms - oxygen_list: Array + oxygen_array: JaxArray Indices of all oxygen atoms - hydrogen_dict: dict + hydrogen_array: JaxArray Dictionary mapping each oxygen in water with their hydrogen atoms. - switching_params: dict - Dictionary containing switching function parameters. + switching_params: list[dict] + List of dictionaries containing switching function parameters for each + PIV block. neighbor_list: Callable JAX MD neighbor list function to update the neighbor list. @@ -75,15 +76,18 @@ class PIV(CollectiveVariable): Permutation Invariant Vector (PIV) """ - def __init__(self, indices, position_pairs, solute_list, solvent_oxygen_list, - hydrogen_array, switching_params, neighbor_list): + def __init__(self, indices, position_pairs, solute_array, solvent_oxygen_array, + hydrogen_array, switching_params, update_neighborlist): super().__init__(indices, group_length=None) self.position_pairs = position_pairs - self.solute_list = solute_list - self.solvent_oxygen_list = solvent_oxygen_list + self.solute_array = solute_array + self.solvent_oxygen_array = solvent_oxygen_array self.hydrogen_array = hydrogen_array self.switching_params = switching_params - self.neighbor_list = neighbor_list['neighbor_list'] + self.update_neighborlist = update_neighborlist['update_neighborlist'] + + self.time = 0 + print("simulation timestep init, 0") @property def function(self): @@ -95,11 +99,10 @@ def function(self): Function that generates PIV from a simulation snapshot. Look at `pysages.colvars.ann.piv` for details. """ - #return lambda *positions, neighbor_list=self.neighbor_list, params=self: piv(positions, neighbor_list, params) - return lambda positions: piv(positions, self.neighbor_list, self) + return lambda positions: piv(positions, self.update_neighborlist, self.time, self) -def piv(positions, neighbor_list, params): +def piv(positions, update_neighborlist, time, params): """ Implementation of permutation invariant vector as described in [Section 4, Handb. Mater. Model. 597-619 (2020)] @@ -107,14 +110,15 @@ def piv(positions, neighbor_list, params): Parameters ---------- - positions: Array + positions: JaxArray Contains positions of all atoms in the system. - neighbor_list: JaxArray - Points to function to update neighbor list. + update_neighborlist: Callable + Function to update neighbor list. params: Object Links to all the helper parameters. This includes - indices combination to exclude from PIV calculation, switching function - parameters. + solute-solute pair indices, solvent oxygen indices, + solvent hydrogen indices, and + switching function parameters. Returns ------- @@ -123,10 +127,24 @@ def piv(positions, neighbor_list, params): """ all_atom_positions = np.array(positions) - neighbor_list = neighbor_list.update(all_atom_positions) + + update_neighborlist = update_neighborlist.update(all_atom_positions) + + print("neighbor list state:\n") + print("time is " + str(time)) + time += 1 + print(update_neighborlist.idx) + print(update_neighborlist.reference_position) + print(update_neighborlist.did_buffer_overflow) + print(update_neighborlist.cell_list_capacity) + print(update_neighborlist.max_occupancy) + print(update_neighborlist.format) + print(update_neighborlist.update_fn) + print("\n") + position_pairs = params.position_pairs - solute_list = params.solute_list - solvent_oxygen_list = params.solvent_oxygen_list + solute_list = params.solute_array + solvent_oxygen_list = params.solvent_oxygen_array hydrogen_array = params.hydrogen_array i_pos = all_atom_positions[position_pairs[:,1]] @@ -140,7 +158,7 @@ def piv(positions, neighbor_list, params): if solvent_oxygen_list: - nlist = neighbor_list.idx + nlist = update_neighborlist.idx atom_ids = np.arange(np.shape(nlist)[0])[:, np.newaxis] atom_ids_nlist = np.hstack((atom_ids, nlist)) solute_atom_ids_nlist = atom_ids_nlist[np.array(solute_list).flatten()] @@ -208,10 +226,4 @@ def cantor_pair(int1, int2): pi *= 0.5 pi += int2 - return np.int32(pi) - - - - - - \ No newline at end of file + return np.int32(pi) \ No newline at end of file