diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml new file mode 100644 index 00000000..bfb078eb --- /dev/null +++ b/.github/workflows/docs.yml @@ -0,0 +1,25 @@ +name: Deploy Docs + +on: + push: + branches: + - main + +permissions: + contents: write + +jobs: + deploy: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - uses: astral-sh/setup-uv@v5 + + - name: Install docs dependencies + run: uv sync --extra docs + + - name: Deploy to GitHub Pages + run: uv run mkdocs gh-deploy --force diff --git a/.gitignore b/.gitignore index 621dcc23..4fd44aeb 100644 --- a/.gitignore +++ b/.gitignore @@ -9,4 +9,10 @@ logs_tensorboard *.lock .python-version .DS_Store -.idea \ No newline at end of file +.idea +.claude +.cache + +# mkdocs +site/ +.cache/mkdocs-jupyter/ \ No newline at end of file diff --git a/PtyLab/Engines/__init__.py b/PtyLab/Engines/__init__.py index 21a0f6ac..35472584 100644 --- a/PtyLab/Engines/__init__.py +++ b/PtyLab/Engines/__init__.py @@ -4,6 +4,22 @@ # # for other Engines (like one you are developing but which is too specific) you can always import PtyLab.Engines.. from .BaseEngine import BaseEngine + +__all__ = [ + "aPIE", + "BaseEngine", + "e3PIE", + "ePIE", + "ePIE_TV", + "mPIE", + "mPIE_tv", + "mqNewton", + "multiPIE", + "OPR", + "pcPIE", + "qNewton", + "zPIE", +] from .e3PIE import e3PIE from .ePIE import ePIE from .ePIE_TV import ePIE_TV diff --git a/PtyLab/Operators/_propagation_kernels.py b/PtyLab/Operators/_propagation_kernels.py index 27b98353..e5397b62 100644 --- a/PtyLab/Operators/_propagation_kernels.py +++ b/PtyLab/Operators/_propagation_kernels.py @@ -4,7 +4,9 @@ import cupy as cp except ImportError: # print("Cupy unavailable") - import numpy as np + pass + +import numpy as np # from PtyLab.Operators.Operators import cache_size cache_size = 30 diff --git a/PtyLab/Params/Params.py b/PtyLab/Params/Params.py index d2e8b95d..3695113a 100644 --- a/PtyLab/Params/Params.py +++ b/PtyLab/Params/Params.py @@ -153,6 +153,8 @@ def __init__(self): # map a change in positions to a change in z. Experimental, do not use self.map_position_to_z_change = False + self.OPRP = False + # Default values of all OPR parameters # Index of the incoherent probe modes that are linked in a subspace. self.OPR_modes = np.array([0]) diff --git a/PtyLab/config/__init__.py b/PtyLab/config/__init__.py deleted file mode 100644 index 31aa2732..00000000 --- a/PtyLab/config/__init__.py +++ /dev/null @@ -1,7 +0,0 @@ -# all the settings involving configuration go here -from pathlib import Path - - -def get_fracPy_folder(): - """Return the folder that PtyLab is installed in.""" - return Path(__file__).parent.parent diff --git a/PtyLab/io/__init__.py b/PtyLab/io/__init__.py index 85f2b215..5057d97e 100644 --- a/PtyLab/io/__init__.py +++ b/PtyLab/io/__init__.py @@ -7,3 +7,6 @@ def getExampleDataFolder(): """ fracPy_folder = Path(__file__).parent.parent.parent return fracPy_folder / "example_data" + + +from PtyLab.io.generateSimulationData import generate_simu_hdf5 # noqa: E402 diff --git a/PtyLab/io/generateSimulationData.py b/PtyLab/io/generateSimulationData.py new file mode 100644 index 00000000..97d73863 --- /dev/null +++ b/PtyLab/io/generateSimulationData.py @@ -0,0 +1,135 @@ +""" +Generate synthetic CPM simulation data and save as simu.hdf5. + +This module contains the simulation logic from example_scripts/simulateData.py +as a callable function with no side effects (no plotting, no os.chdir). +""" + +from pathlib import Path + +import h5py +import numpy as np +from scipy.signal import convolve2d + +from PtyLab.Operators.Operators import aspw +from PtyLab.utils.scanGrids import GenerateNonUniformFermat +from PtyLab.utils.utils import cart2pol, circ, fft2c, gaussian2D + + +def generate_simu_hdf5(output_path: Path) -> None: + """ + Generate a synthetic CPM ptychography dataset and save it as an HDF5 file. + + The simulation produces a focused Gaussian probe and a complex spiral object, + computes diffraction patterns using Fraunhofer propagation, adds Poisson noise, + and writes the result to *output_path*. + + Parameters + ---------- + output_path : Path + Destination file path (e.g. ``example_data/simu.hdf5``). + The parent directory must already exist. + """ + output_path = Path(output_path) + + # Physical properties + wavelength = 632.8e-9 + zo = 5e-2 + binningFactor = 1 + + # Detector coordinates + Nd = 2**7 + dxd = 2**11 / Nd * 4.5e-6 + Ld = Nd * dxd + + # Probe coordinates + dxp = wavelength * zo / Ld + Np = Nd + Lp = dxp * Np + xp = np.arange(-Np // 2, Np // 2) * dxp + Xp, Yp = np.meshgrid(xp, xp) + + # Object coordinates + No = 2**10 + 2**9 + dxo = dxp + Lo = dxo * No + xo = np.arange(-No // 2, No // 2) * dxo + Xo, Yo = np.meshgrid(xo, xo) + + # Generate illumination: focused beam via pinhole + lens + f = 8e-3 + pinhole = circ(Xp, Yp, Lp / 2) + pinhole = convolve2d(pinhole, gaussian2D(5, 1).astype(np.float32), mode="same") + + probe = aspw(pinhole, 2 * f, wavelength, Lp)[0] + + aperture = circ(Xp, Yp, 3 * Lp / 4) + aperture = convolve2d(aperture, gaussian2D(5, 3).astype(np.float32), mode="same") + probe = ( + probe + * np.exp(-1.0j * 2 * np.pi / wavelength * (Xp**2 + Yp**2) / (2 * f)) + * aperture + ) + probe = aspw(probe, 2 * f, wavelength, Lp)[0] + + # Generate object: complex spiral pattern + d = 1e-3 + b = 33 + theta, rho = cart2pol(Xo, Yo) + t = (1 + np.sign(np.sin(b * theta + 2 * np.pi * (rho / d) ** 2))) / 2 + phaseFun = np.exp(1.0j * (theta + 2 * np.pi * (rho / d) ** 2)) + t = t * circ(Xo, Yo, Lo) * (1 - circ(Xo, Yo, 200 * dxo)) * phaseFun + circ( + Xo, Yo, 130 * dxo + ) + obj = convolve2d(t, gaussian2D(5, 3), mode="same") + object_ = obj * phaseFun + + # Generate scan positions (non-uniform Fermat spiral) + numPoints = 100 + radius = 150 + p = 1 + R, C = GenerateNonUniformFermat(numPoints, radius=radius, power=p) + + encoder = np.vstack((R * dxo, C * dxo)).T + positions = np.round(encoder / dxo) + offset = np.array([50, 20]) + positions = (positions + No // 2 - Np // 2 + offset).astype(int) + numFrames = len(R) + + # Estimate beam size for entrancePupilDiameter + beamSize = ( + np.sqrt(np.sum((Xp**2 + Yp**2) * np.abs(probe) ** 2) / np.sum(abs(probe) ** 2)) + * 2.355 + ) + + # Compute ptychogram + ptychogram = np.zeros((numFrames, Nd, Nd)) + for loop in np.arange(numFrames): + row, col = positions[loop] + sy = slice(row, row + Np) + sx = slice(col, col + Np) + objectPatch = object_[..., sy, sx].copy() + esw = objectPatch * probe + ESW = fft2c(esw) + ptychogram[loop] = abs(ESW) ** 2 + + # Simulate Poisson noise + bitDepth = 14 + maxNumCountsPerDiff = 2**bitDepth + ptychogram = ptychogram / np.max(ptychogram) * maxNumCountsPerDiff + noise = np.random.poisson(ptychogram) + ptychogram += noise + ptychogram[ptychogram < 0] = 0 + + # Save to HDF5 + with h5py.File(output_path, "w") as hf: + hf.create_dataset("ptychogram", data=ptychogram, dtype="f") + hf.create_dataset("encoder", data=encoder, dtype="f") + hf.create_dataset("binningFactor", data=binningFactor, dtype="i") + hf.create_dataset("dxd", data=(dxd,), dtype="f") + hf.create_dataset("Nd", data=(Nd,), dtype="i") + hf.create_dataset("No", data=(No,), dtype="i") + hf.create_dataset("zo", data=(zo,), dtype="f") + hf.create_dataset("wavelength", data=(wavelength,), dtype="f") + hf.create_dataset("entrancePupilDiameter", data=(beamSize,), dtype="f") + hf.create_dataset("orientation", data=0) diff --git a/PtyLab/io/readHdf5.py b/PtyLab/io/readHdf5.py index d097730d..fcfb12c7 100644 --- a/PtyLab/io/readHdf5.py +++ b/PtyLab/io/readHdf5.py @@ -1,9 +1,10 @@ +import logging from pathlib import Path -import tables + +import h5py import numpy as np -import logging +import tables from scipy.io import loadmat -import h5py logger = logging.getLogger("readHdf5") @@ -34,7 +35,7 @@ def loadInputData(filename: Path, requiredFields, optionalFields): """ filename = Path(filename) if not filename.exists(): - raise FileNotFoundError(f'Could not find file {filename}.') + raise FileNotFoundError(f"Could not find file {filename}.") logger.debug("Loading input data: %s", filename) # sanity checks @@ -48,7 +49,6 @@ def loadInputData(filename: Path, requiredFields, optionalFields): dataset = dict() try: with tables.open_file(str(filename), mode="r") as hdf5File: - # load the required fields for key in requiredFields: value = hdf5File.root[key].read() @@ -66,19 +66,20 @@ def loadInputData(filename: Path, requiredFields, optionalFields): except Exception as e: logger.error("Error reading hdf5 file!") raise e - if 'encoder' in dataset: - print(f'Found encoder with shape {dataset["encoder"].shape}') - if dataset['encoder'].shape[0] < dataset['encoder'].shape[1]: - dataset['encoder'] = dataset['encoder'].T - print('Warning: Automatically changing the shape of encoder. ') - dataset['encoder'] -= dataset['encoder'].mean(axis=0, keepdims=True) - print(dataset['encoder'].shape, dataset['encoder'].mean(axis=0)) + if "encoder" in dataset: + print(f"Found encoder with shape {dataset['encoder'].shape}") + if dataset["encoder"].shape[0] < dataset["encoder"].shape[1]: + dataset["encoder"] = dataset["encoder"].T + print("Warning: Automatically changing the shape of encoder. ") + dataset["encoder"] -= dataset["encoder"].mean(axis=0, keepdims=True) + print(dataset["encoder"].shape, dataset["encoder"].mean(axis=0)) # dataset['encoder'] *= -1 # dirty hack for now # upsample from PtyLab.utils.utils import fft2c, ifft2c + # dataset['dxd'] = dataset['dxd'] / 2 # padwidth = dataset['ptychogram'].shape[-1]//2 # padwidth = [[0,0], [padwidth, padwidth], [padwidth,padwidth]] @@ -95,8 +96,9 @@ def getOrientation(filename): orientation = None with h5py.File(str(filename), "r") as archive: if "orientation" in archive.keys(): - orientation = np.array(archive["orientation"]).ravel()[0].astype(int) - return int(orientation) if orientation is not None else None + raw_value = np.array(archive["orientation"]).ravel()[0] + orientation = scalify(raw_value) + return orientation def checkDataFields(filename, requiredFields): @@ -121,5 +123,3 @@ def checkDataFields(filename, requiredFields): raise KeyError("hdf5 file misses key %s" % k) return None - - diff --git a/PtyLab/utils/visualisation.py b/PtyLab/utils/visualisation.py index 4b954c97..695a17d5 100644 --- a/PtyLab/utils/visualisation.py +++ b/PtyLab/utils/visualisation.py @@ -1,11 +1,13 @@ # This file contains utilities required for Monitor -import numpy as np -import matplotlib.pyplot as plt -import matplotlib as mpl import math + +import matplotlib as mpl +import matplotlib.pyplot as plt +import numpy as np +from matplotlib.colors import LinearSegmentedColormap from mpl_toolkits.axes_grid1 import make_axes_locatable + from PtyLab.utils.gpuUtils import asNumpyArray, getArrayModule, isGpuArray -from matplotlib.colors import LinearSegmentedColormap try: import pyqtgraph as pg @@ -51,7 +53,7 @@ def complex2rgb(u, amplitudeScalingFactor=1, force_numpy=True, center_phase=Fals # u = asNumpyArray(u) if center_phase: N = u.shape[-1] - phexp = xp.sum(u[...,N//3:2*N//3,N//3:2*N//3], axis=(-2,-1)) + phexp = xp.sum(u[..., N // 3 : 2 * N // 3, N // 3 : 2 * N // 3], axis=(-2, -1)) u = u * phexp.conj() / (abs(phexp) + 1e-9) h = xp.angle(u) h = (h + np.pi) / (2 * np.pi) @@ -63,11 +65,11 @@ def complex2rgb(u, amplitudeScalingFactor=1, force_numpy=True, center_phase=Fals ASF = v.mean() + 2 * np.std(v) ASF = ASF / v.max() elif amplitudeScalingFactor is None: - ASF = 1./v.max() + ASF = 1.0 / v.max() amplitudeScalingFactor = ASF else: ASF = amplitudeScalingFactor - + if ASF != 1 and amplitudeScalingFactor != "2sigma": v[v > amplitudeScalingFactor * np.max(v)] = amplitudeScalingFactor * np.max(v) v = v / (xp.max(v) + xp.finfo(float).eps) * (2**8 - 1) @@ -253,29 +255,86 @@ def setColorMap(): return cm +def _is_notebook(): + """Return True when running inside a Jupyter kernel.""" + try: + from IPython import get_ipython + return get_ipython().__class__.__name__ == "ZMQInteractiveShell" + except NameError: + return False + + def show3Dslider(A, colormap="diffraction"): """ - show a 3D plot with a slider using pyqtgraph. + show a 3D plot with a slider. + + In a Jupyter notebook an inline ipywidgets slider is used. + In a script the interactive pyqtgraph viewer is used. + :param A: a 3D array :param colormap: matplotlib colormap, default, customized colormap for plotting diffraction data return: a pyqtgraph plot """ print(A.min(), A.max()) - app = pg.mkQApp() - imv = pg.ImageView(view=pg.PlotItem()) - imv.setWindowTitle("Close to proceed") - - imv.setImage(A) - # choose colormap from matplotlib colormaps + # resolve colormap once — matplotlib LinearSegmentedColormap works for both paths if colormap == "diffraction": cmap = setColorMap() else: cmap = mpl.cm.get_cmap(colormap) - # set the colormap - positions = np.linspace(0, 1, cmap.N) - colors = [(np.array(cmap(i)[:-1]) * 255).astype("int") for i in positions] - imv.setColorMap(pg.ColorMap(pos=positions, color=colors)) - imv.show() - app.exec_() + if _is_notebook(): + import ipywidgets as widgets + from IPython.display import display + import matplotlib.pyplot as plt + + # Create output widget for displaying figure + out = widgets.Output() + + def update_frame(change): + # Create new figure for each frame update + # Handle both old API (event dict) and new API (direct value) + if isinstance(change, dict): + frame = int(change['new']) + else: + frame = int(change) + fig, ax = plt.subplots(1, 1, figsize=(6, 6)) + im = ax.imshow(A[frame], cmap=cmap, origin="lower") + plt.colorbar(im, ax=ax, fraction=0.046, pad=0.04) + ax.axis("off") + plt.tight_layout() + + with out: + out.clear_output(wait=True) + display(fig) + plt.close(fig) + + # Create slider widget + slider = widgets.IntSlider( + min=0, + max=A.shape[0] - 1, + step=1, + value=0, + description="Frame" + ) + + # Link slider to update function + slider.observe(update_frame, names="value") + + # Display slider and output + display(widgets.VBox([slider, out])) + + # Initial display + update_frame(0) + else: + app = pg.mkQApp() + imv = pg.ImageView(view=pg.PlotItem()) + imv.setWindowTitle("Close to proceed") + imv.setImage(A) + + # set the colormap + positions = np.linspace(0, 1, cmap.N) + colors = [(np.array(cmap(i)[:-1]) * 255).astype("int") for i in positions] + imv.setColorMap(pg.ColorMap(pos=positions, color=colors)) + imv.show() + app.exec_() diff --git a/README.md b/README.md index 68d76515..850140d9 100644 --- a/README.md +++ b/README.md @@ -1,16 +1,19 @@ # PtyLab.py: Unified Ptychography Toolbox ![Python 3.10+](https://img.shields.io/badge/python-3.10+-green.svg) -![Version](https://img.shields.io/badge/version-0.2.3-blue.svg) +![Version](https://img.shields.io/badge/version-0.2.5-blue.svg) ![Tests](https://github.com/PtyLab/PtyLab.py/actions/workflows/test.yml/badge.svg) +[**Getting Started**](#getting-started) | [**Installation**](#installation) | [**Development**](#development) | [**Documentation**](https://ptylab.github.io/PtyLab.py/) + PtyLab is an inverse modeling toolbox for Conventional (CP) and Fourier (FP) ptychography in a unified framework. For more information please check the [paper](https://opg.optica.org/oe/fulltext.cfm?uri=oe-31-9-13763&id=529026). ## Key Features -- **Classic reconstruction engines**: ePIE, mPIE, mqNewton, -- **Advanced corrections**: multi-slice, multi-wavelength, position correction (pcPIE), defocus correction (zPIE), angle correction (aPIE), orthogonal probe relaxation (OPR), mixed-state object and probe. -- **Multiple propagators**: Fraunhofer, Fresnel, Angular Spectrum (ASP), scaled ASP, and polychromatic variants -- **GPU acceleration**: Same code runs on CPU and GPU. +- **Classic engines**: ePIE, mPIE, mqNewton, qNewton +- **Advanced corrections**: position correction (pcPIE), defocus correction (zPIE), angle correction (aPIE), orthogonal probe relaxation (OPR) +- **Multi-modal**: multi-slice, multi-wavelength, mixed-state object and probe +- **Multiple propagators**: Fraunhofer, Fresnel, Angular Spectrum (ASP), scaled ASP, polychromatic variants +- **GPU acceleration**: same code runs on CPU and GPU The reconstructed output is a 6D array of shape `(nlambda, nosm, npsm, nslice, No, No)`: @@ -30,7 +33,7 @@ The simplest way to get started is to check the below demo in Google Colab. [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PtyLab/PtyLab.py/blob/main/demo.ipynb) ![demo](assets/recon.gif) -To explore more use cases of PtyLab, check the [example_scripts](example_scripts) and [jupyter_tutorials](jupyter_tutorials) directories. However, please install the package first as described in the below sections. +To explore more use cases of PtyLab, check the [tutorials](https://ptylab.github.io/PtyLab.py/tutorials/) under our documentation page first, followed by more examples cases under the [example_scripts](example_scripts) directory. ## Installation @@ -44,53 +47,45 @@ pip install git+https://github.com/PtyLab/PtyLab.py.git > Just as a tip, to install the package very fast, we recommend using [uv](https://docs.astral.sh/uv/getting-started/installation/) and simply doing `uv pip install git+https://github.com/PtyLab/PtyLab.py.git` -This package uses `cupy` to utilize GPU for faster reconstruction. To enable GPU support, install the package with the appropriate CUDA extra: +This package uses `cupy` to utilize GPU for faster reconstruction. To enable GPU support: ```bash -# For CUDA 12.x -pip install "ptylab[cuda12] @ git+https://github.com/PtyLab/PtyLab.py.git" - -# For CUDA 13.x -pip install "ptylab[cuda13] @ git+https://github.com/PtyLab/PtyLab.py.git" +pip install "ptylab[gpu] @ git+https://github.com/PtyLab/PtyLab.py.git" ``` -To check if GPU is being used, please do `ptylab check gpu` within your environment. +To check if GPU is being used, please type the below command from within your environment + +```bash +ptylab check gpu +``` ### Development -Clone this repository and navigate to the root folder: +Clone this repository, navigate to the root folder and install dev. dependencies with [uv](https://docs.astral.sh/uv/getting-started/installation/): ```bash git clone git@github.com:PtyLab/PtyLab.py.git cd PtyLab.py -``` - -Install [uv](https://docs.astral.sh/uv/getting-started/installation/) if you have not already, then install `ptylab` and its development dependencies: - -```bash uv sync --extra dev ``` This creates a `.venv` virtual environment in the project root. Select this environment from your IDE. -To use the GPU, install with the appropriate CUDA extra instead: +To use the GPU as well, install with the `gpu` flag: ```bash -uv sync --extra dev,cuda12 # for CUDA 12.x -uv sync --extra dev,cuda13 # for CUDA 13.x +uv sync --extra dev,gpu ``` and check if GPU is detected with `uv run ptylab check gpu`. -#### Contributing - -If any new changes are made, add a new test if necessary and run the test suite. +If any new changes are made, add a new test if necessary and run the full test suite. ```bash uv run pytest tests ``` -Note that CI will also do this at every PR. Please bump the package version when modifying dependencies. +Note that CI will also do this at every PR. Please bump the package version when modifying dependencies. ## Citation diff --git a/docs/advanced/gpu.md b/docs/advanced/gpu.md new file mode 100644 index 00000000..109a411a --- /dev/null +++ b/docs/advanced/gpu.md @@ -0,0 +1,62 @@ +# GPU Acceleration + +PtyLab.py uses [CuPy](https://cupy.dev/) as a drop-in GPU backend for NumPy. The same reconstruction code runs on both CPU and GPU — no changes to your script needed beyond toggling a single parameter. + +## Installation with GPU support + +GPU acceleration requires installing PtyLab.py with a CUDA extra. See [Installation](../getting-started/installation.md) for the full instructions. + +```bash +pip install "ptylab[gpu] @ git+https://github.com/PtyLab/PtyLab.py.git" +``` + +## Verifying GPU availability + +From the command line (within your environment): + +```bash +ptylab check gpu +``` + +## Toggle GPU switch + +By default, GPU is automatically detected and used for your reconstructions, however this can be also manually controlled via the following parameter + +```bash +params.gpuSwitch = True +``` + +## Memory optimization + +For large datasets that do not fit entirely in GPU memory: + +```python +params.saveMemory = True +``` + +This reduces peak GPU memory usage at a slight performance cost by keeping some arrays on the CPU and transferring them as needed. + +## Single precision + +Converting to single precision (float32) halves memory usage and can significantly speed up GPU reconstruction: + +```python +engine.convert2single() +``` + +Call this after creating the engine but before `reconstruct()`. + +## Manual GPU/CPU transfer + +In advanced workflows you can control data placement explicitly: + +```python +engine._move_data_to_gpu() # move all arrays to GPU +engine._move_data_to_cpu() # move all arrays back to CPU +``` + +## Notes + +- GPU support is **optional** — PtyLab.py runs identically on CPU without CuPy installed. +- The `params.gpuSwitch` property validates that CuPy is available before enabling GPU mode. It will raise an informative error if CuPy is not installed. +- Results are automatically transferred back to CPU before saving with `reconstruction.saveResults()`. diff --git a/docs/advanced/index.md b/docs/advanced/index.md new file mode 100644 index 00000000..d81aa937 --- /dev/null +++ b/docs/advanced/index.md @@ -0,0 +1,9 @@ +# Advanced Topics + +Capabilities beyond the standard reconstruction workflow. + +## In this section + +- [**GPU Acceleration**](gpu.md) — Run reconstructions on a CUDA GPU using CuPy with no code changes. +- [**Multislice**](multislice.md) — Reconstruct thick 3D samples by modelling them as a stack of thin slices. +- [**Position Correction**](position-correction.md) — Correct lateral probe-position errors during reconstruction. diff --git a/docs/advanced/multislice.md b/docs/advanced/multislice.md new file mode 100644 index 00000000..32911595 --- /dev/null +++ b/docs/advanced/multislice.md @@ -0,0 +1,55 @@ +# Multislice Reconstruction + +## What is multislice? + +Standard ptychography treats the sample as a thin, 2D transmission object. For thick samples — where the beam diffracts significantly as it propagates *through* the sample — this approximation breaks down. **Multislice ptychography** models the sample as a stack of thin slices separated by free-space propagation, allowing accurate reconstruction of thick 3D objects. + +## When to use multislice + +Use multislice when: + +- The sample thickness is comparable to or larger than the depth of focus of the probe +- You observe a systematic defocus-like artifact in reconstruction that cannot be corrected by `zPIE` +- You need 3D (depth-resolved) information about the sample + +## Setup + +Set `nslice > 1` on the `Reconstruction` object and use the `e3PIE` engine: + +```python +import PtyLab +from PtyLab import Engines + +data, recon, params, monitor, engine = PtyLab.easyInitialize( + "data.hdf5", + engine=Engines.e3PIE, + operationMode="CPM", +) + +# Configure multislice +recon.nslice = 4 # number of depth slices +recon.initializeObjectProbe() + +engine.numIterations = 100 +for loop, posLoop in engine.reconstruct(): + pass + +recon.saveResults("multislice_result.hdf5") +``` + +## Output + +With `nslice = N`, the reconstructed object has shape `(nlambda, nosm, npsm, N, No, No)`. Each slice `[:, :, :, i, :, :]` represents one depth layer of the sample. + +## Notes + +!!! note + Multislice reconstruction requires more iterations to converge than single-slice. Start with `nslice = 2` and increase if needed. + +!!! tip + The `e3PIE` engine internally handles free-space propagation between slices using the Angular Spectrum propagator. Setting `params.propagatorType` has no effect on inter-slice propagation. + +## Related + +- [Engines](../cpm/engines.md) — `e3PIE` engine details +- [Configuration Reference](../cpm/configuration.md) — parameter overview diff --git a/docs/advanced/position-correction.md b/docs/advanced/position-correction.md new file mode 100644 index 00000000..d6a634e8 --- /dev/null +++ b/docs/advanced/position-correction.md @@ -0,0 +1,80 @@ +# Position Correction + +## Why correct positions? + +Scan position errors are common in practice — mechanical stage imperfections, thermal drift, and vibration all introduce deviations between the nominal encoder positions and the true sample positions. Even small position errors (a fraction of a pixel) degrade reconstruction quality. Position-correcting ptychography estimates and corrects these errors as part of the reconstruction. + +## Using `pcPIE` + +The `pcPIE` engine extends the standard PIE update with a cross-correlation based position correction step: + +```python +import PtyLab +from PtyLab import Engines + +data, recon, params, monitor, engine = PtyLab.easyInitialize( + "data.hdf5", + engine=Engines.pcPIE, + operationMode="CPM", +) + +params.positionCorrectionSwitch = True +params.positionCorrectionSwitch_radius = 2 # search radius in pixels + +engine.numIterations = 100 +for loop, posLoop in engine.reconstruct(): + pass + +recon.saveResults("corrected_result.hdf5") +``` + +## Parameters + +| Parameter | Default | Description | +|-----------|---------|-------------| +| `params.positionCorrectionSwitch` | `False` | Enable position correction | +| `params.positionCorrectionSwitch_radius` | `1` | Search radius (pixels) around each nominal position | + +!!! tip + Start with a small radius (1–2 pixels). Large radii slow down reconstruction and can cause instabilities early in convergence. Run a few iterations without position correction first to let the object and probe stabilize. + +## Visualizing position corrections + +After reconstruction, inspect how much each position was corrected: + +```python +recon.make_alignment_plot(saveit=False) +``` + +This opens an interactive Bokeh plot comparing the original encoder positions to the corrected positions, with arrows showing the displacement magnitude and direction. + +To save the plot to a file: + +```python +recon.make_alignment_plot(saveit=True) +``` + +## Resetting corrections + +To discard all position corrections and revert to the original encoder positions: + +```python +recon.reset_positioncorrection() +``` + +This restores `reconstruction.positions` from the original encoder values. + +## Corrected positions + +The corrected positions are stored in: + +```python +recon.encoder_corrected # corrected physical positions (meters) +recon.positions # corrected pixel positions +recon.positions0 # original pixel positions (before correction) +``` + +## Related + +- [Engines](../cpm/engines.md) — `pcPIE` and other specialized engines +- [Configuration Reference](../cpm/configuration.md) — full parameter list diff --git a/docs/assets/ptylab_logo.png b/docs/assets/ptylab_logo.png new file mode 100644 index 00000000..fa99119b Binary files /dev/null and b/docs/assets/ptylab_logo.png differ diff --git a/docs/assets/ptylab_logo.svg b/docs/assets/ptylab_logo.svg new file mode 100644 index 00000000..b3c5814f --- /dev/null +++ b/docs/assets/ptylab_logo.svg @@ -0,0 +1,664 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/cpm/configuration.md b/docs/cpm/configuration.md new file mode 100644 index 00000000..0d0be628 --- /dev/null +++ b/docs/cpm/configuration.md @@ -0,0 +1,152 @@ +# Configuration Reference + +The `Params` object holds all shared configuration for the reconstruction. It is created once and passed to both the `Reconstruction` and the engine. + +```python +from PtyLab import Params + +params = Params() +params.propagatorType = "Fraunhofer" +params.positionOrder = "random" +``` + +--- + +## Propagation + +| Parameter | Default | Options | Description | +|-----------|---------|---------|-------------| +| `propagatorType` | `"Fraunhofer"` | `"Fraunhofer"`, `"Fresnel"`, `"ASP"`, `"scaledASP"` | Wave propagation method from sample to detector | +| `fftshiftSwitch` | `False` | `bool` | Pre-shift FFT for slight performance gain; changes coordinate convention | + +!!! note + `"Fraunhofer"` (far-field) is the standard choice for most experiments. Use `"ASP"` (Angular Spectrum) for near-field or when the Fraunhofer approximation breaks down. + +--- + +## Update control + +| Parameter | Default | Options | Description | +|-----------|---------|---------|-------------| +| `probeUpdateStart` | `1` | `int` | Iteration at which probe updates begin | +| `objectUpdateStart` | `1` | `int` | Iteration at which object updates begin | +| `positionOrder` | `"random"` | `"random"`, `"sequential"`, `"NA"` | Order in which scan positions are visited each iteration | + +--- + +## Momentum acceleration + +| Parameter | Default | Description | +|-----------|---------|-------------| +| `momentumAcceleration` | `False` | Enable momentum-based acceleration (used by mPIE/mqNewton) | +| `adaptiveMomentumAcceleration` | `False` | Automatically adjust momentum strength during reconstruction | + +--- + +## Object regularization + +| Parameter | Default | Description | +|-----------|---------|-------------| +| `objectSmoothenessSwitch` | `False` | Apply smoothness regularization to the object | +| `objectSmoothenessWidth` | `2` | Smoothing kernel width (pixels) | +| `objectSmoothnessAleph` | `1e-2` | Smoothness regularization strength | +| `absObjectSwitch` | `False` | Constrain object to be real-valued (absorption only) | +| `absObjectBeta` | `1e-2` | Relaxation parameter for abs-only constraint | +| `objectTVregSwitch` | `False` | Enable total variation regularization on the object | +| `objectTVfreq` | `5` | How often (iterations) to apply TV update | +| `objectTVregStepSize` | `1e-3` | TV gradient step size | +| `l2reg` | `False` | Enable L2 regularization | +| `l2reg_object_aleph` | `0.001` | L2 regularization strength for the object | + +--- + +## Probe regularization + +| Parameter | Default | Description | +|-----------|---------|-------------| +| `probeSmoothenessSwitch` | `False` | Apply smoothness regularization to the probe | +| `probeSmoothenessWidth` | `3` | Smoothing kernel width (pixels) | +| `probeSmoothenessAleph` | `5e-2` | Smoothness regularization strength | +| `probeBoundary` | `False` | Apply a soft boundary constraint to the probe | +| `absorbingProbeBoundary` | `False` | Zero the probe outside its support (hard boundary) | +| `absorbingProbeBoundaryAleph` | `5e-2` | Boundary strength | +| `probePowerCorrectionSwitch` | `False` | Normalize probe power to match measured intensity | +| `modulusEnforcedProbeSwitch` | `False` | Enforce probe modulus from an empty-beam measurement | +| `absProbeSwitch` | `False` | Constrain probe to be real-valued | +| `absProbeBeta` | `1e-2` | Relaxation parameter for abs-only probe constraint | +| `binaryProbeSwitch` | `False` | Enforce a binary probe support | +| `l2reg_probe_aleph` | `0.01` | L2 regularization strength for the probe | + +--- + +## Probe orthogonalization + +| Parameter | Default | Description | +|-----------|---------|-------------| +| `orthogonalizationSwitch` | `False` | Orthogonalize incoherent probe modes during reconstruction | +| `orthogonalizationFrequency` | `10` | How often (iterations) to orthogonalize | + +--- + +## Orthogonal Probe Relaxation (OPR) + +| Parameter | Default | Description | +|-----------|---------|-------------| +| `OPR_modes` | `[0]` | Which probe modes to include in OPR relaxation | +| `OPR_subspace` | `4` | Number of subspace vectors for OPR | +| `OPR_alpha` | `0.05` | OPR feedback strength | +| `OPR_orthogonalize_modes` | `True` | Orthogonalize all modes within OPR | + +--- + +## Intensity constraint + +| Parameter | Default | Options | Description | +|-----------|---------|---------|-------------| +| `intensityConstraint` | `"standard"` | `"standard"`, `"sigmoid"` | How to apply the Fourier modulus constraint | + +--- + +## Autofocusing + +| Parameter | Default | Description | +|-----------|---------|-------------| +| `TV_autofocus` | `False` | Enable TV-based autofocusing | +| `TV_autofocus_metric` | `"TV"` | Focus metric: `"TV"`, `"std"`, or `"min_std"` | +| `TV_autofocus_stepsize` | `5` | Step size (µm) between focus planes | +| `TV_autofocus_range_dof` | `11` | Number of planes to test (should be odd) | +| `TV_autofocus_roi` | `[0.4, 0.6]` | Region of interest (fractional) for metric computation | +| `TV_autofocus_run_every` | `3` | Run autofocus every N iterations | + +--- + +## Other constraints + +| Parameter | Default | Description | +|-----------|---------|-------------| +| `couplingSwitch` | `False` | Couple adjacent wavelengths in polychromatic mode | +| `couplingAleph` | `0.5` | Coupling strength | +| `backgroundModeSwitch` | `False` | Estimate and subtract a background term | +| `comStabilizationSwitch` | `False` | Stabilize center of mass of the probe | +| `adaptiveDenoisingSwitch` | `False` | Adaptive noise clipping during intensity projection | +| `CPSCswitch` | `False` | Constrained Pixel Sum Correction | +| `CPSCupsamplingFactor` | — | Upsampling factor for CPSC | + +--- + +## GPU + +| Parameter | Default | Description | +|-----------|---------|-------------| +| `gpuSwitch` | `False` | Move all arrays to GPU (requires CuPy and a CUDA GPU) | +| `saveMemory` | `False` | Reduce GPU memory usage at slight performance cost | + +See [GPU Acceleration](../advanced/gpu.md) for setup and usage. + +--- + +## Output + +| Parameter | Default | Description | +|-----------|---------|-------------| +| `dump_obj` | `False` | Save the object estimate to disk at every iteration | diff --git a/docs/cpm/data-format.md b/docs/cpm/data-format.md new file mode 100644 index 00000000..d13279b1 --- /dev/null +++ b/docs/cpm/data-format.md @@ -0,0 +1,79 @@ +# Data Format + +PtyLab.py loads experimental data from **HDF5** files. All fields are stored at the root level of the file. + +## CPM required fields + +| Field | Type | Unit | Description | +|-------|------|------|-------------| +| `ptychogram` | `float32 (N, Nd, Nd)` | counts | Stack of N diffraction intensity patterns | +| `wavelength` | `float64` | m | Illumination wavelength | +| `encoder` | `float64 (N, 2)` | m | Scan positions (x, y) in the sample plane | +| `dxd` | `float64` | m | Detector pixel size | +| `zo` | `float64` | m | Sample-to-detector distance | + +## CPM optional fields + +| Field | Type | Unit | Description | +|-------|------|------|-------------| +| `entrancePupilDiameter` | `float64` | m | Diameter of the probe aperture | +| `spectralDensity` | `float64 (nlambda,)` | — | Relative spectral weights for polychromatic reconstruction | +| `theta` | `float64` | rad | Tilt angle for reflection ptychography | +| `emptyBeam` | `float32 (Nd, Nd)` | counts | Reference probe image (for modulus-enforced probe) | + +## Loading data + +```python +from PtyLab import ExperimentalData + +data = ExperimentalData("path/to/data.hdf5", operationMode="CPM") +data.loadData("path/to/data.hdf5") +``` + +Or pass the filename directly to `easyInitialize`: + +```python +import PtyLab +experimentalData, reconstruction, params, monitor, engine = PtyLab.easyInitialize( + "path/to/data.hdf5", + engine=..., + operationMode="CPM", +) +``` + +## Built-in example datasets + +PtyLab.py ships with simulation datasets for testing and tutorials. Use these special filename strings: + +| Name | Description | +|------|-------------| +| `"example:simulation_cpm"` | Synthetic CPM ptychogram with known object and probe | +| `"example:simulation_fpm"` | Synthetic FPM ptychogram | +| `"test:nodata"` | Empty object for unit testing (no diffraction data) | + +```python +data = ExperimentalData(operationMode="CPM") +data.loadData("example:simulation_cpm") +``` + +## Creating an HDF5 file + +Use `h5py` to create a compatible data file from your own measurements: + +```python +import h5py +import numpy as np + +ptychogram = ... # shape (N, Nd, Nd), dtype float32 +encoder = ... # shape (N, 2), dtype float64, units: meters + +with h5py.File("mydata.hdf5", "w") as f: + f.create_dataset("ptychogram", data=ptychogram.astype(np.float32)) + f.create_dataset("wavelength", data=np.float64(532e-9)) # 532 nm + f.create_dataset("encoder", data=encoder.astype(np.float64)) + f.create_dataset("dxd", data=np.float64(6.5e-6)) # 6.5 µm pixels + f.create_dataset("zo", data=np.float64(50e-3)) # 50 mm distance +``` + +!!! note + All distances must be in **meters**. The `ptychogram` should contain raw intensity values (counts), not amplitude. Negative values and NaNs are not supported. diff --git a/docs/cpm/engines.md b/docs/cpm/engines.md new file mode 100644 index 00000000..5bcd2269 --- /dev/null +++ b/docs/cpm/engines.md @@ -0,0 +1,115 @@ +# Engines + +Engines implement the iterative reconstruction algorithms. All engines inherit from `BaseEngine` and share a common interface. + +## Available engines + +| Engine | Full Name | Best For | +|--------|-----------|----------| +| `ePIE` | Extended PIE | General-purpose starting point, simple and robust | +| `mPIE` | Momentum PIE | Faster convergence than ePIE; recommended default | +| `mqNewton` | Momentum quasi-Newton | High-quality results with faster convergence | +| `qNewton` | Quasi-Newton | Newton-step updates without momentum | +| `multiPIE` | Multi-mode PIE | Multiple probe or object modes simultaneously | +| `mPIE_tv` | mPIE + Total Variation | TV-regularized object reconstruction | +| `ePIE_TV` | ePIE + Total Variation | TV regularization with ePIE updates | +| `zPIE` | Defocus-correcting PIE | Unknown or uncertain sample-detector distance | +| `aPIE` | Angle-correcting PIE | Reflection geometry with uncertain tilt angle | +| `pcPIE` | Position-correcting PIE | Corrects scan position errors during reconstruction | +| `e3PIE` | Enhanced ePIE | Multislice (thick sample) reconstruction | +| `OPR` | Orthogonal Probe Relaxation | Spatially varying probe (e.g. aberrations, drift) | + +## Common interface + +All engines share the same constructor and iteration pattern: + +```python +from PtyLab import Engines + +engine = Engines.mPIE(reconstruction, experimentalData, params, monitor) +engine.numIterations = 50 +for loop, posLoop in engine.reconstruct(): + pass +``` + +The `reconstruct()` method is a generator that yields `(loop, posLoop)` at each scan position, allowing you to insert custom logic mid-reconstruction. + +## Engine-specific parameters + +### ePIE / mPIE + +```python +engine.betaObject = 0.25 # object update step size (0 < beta ≤ 1) +engine.betaProbe = 0.25 # probe update step size (0 < beta ≤ 1) +``` + +### mqNewton / qNewton + +These engines use quasi-Newton updates and generally require fewer iterations than PIE-based methods. + +### pcPIE (position correction) + +```python +params.positionCorrectionSwitch = True +params.positionCorrectionSwitch_radius = 1 # search radius in pixels +``` + +See [Position Correction](../advanced/position-correction.md) for a full guide. + +### e3PIE (multislice) + +```python +reconstruction.nslice = 3 # number of depth slices +engine = Engines.e3PIE(reconstruction, experimentalData, params, monitor) +``` + +See [Multislice](../advanced/multislice.md) for details. + +### OPR (Orthogonal Probe Relaxation) + +```python +params.OPR_modes = [0] # which probe modes to relax +params.OPR_subspace = 4 # subspace dimension +params.OPR_alpha = 0.05 # feedback strength +params.OPR_orthogonalize_modes = True +``` + +## Engine selection guide + +``` +Is the probe spatially varying across the scan? + Yes → OPR + No → continue + +Is the sample thick (multislice)? + Yes → e3PIE + No → continue + +Are scan positions unreliable? + Yes → pcPIE + No → continue + +Do you want the fastest convergence? + Yes → mqNewton or mPIE + No → ePIE (simplest, most interpretable) +``` + +## Chaining engines + +You can run multiple engines sequentially on the same `Reconstruction` object. A common pattern is to warm up with `ePIE` then refine with `mqNewton`: + +```python +# Phase 1: rough convergence +engine1 = Engines.ePIE(reconstruction, experimentalData, params, monitor) +engine1.numIterations = 30 +for loop, posLoop in engine1.reconstruct(): + pass + +# Phase 2: fine convergence +engine2 = Engines.mqNewton(reconstruction, experimentalData, params, monitor) +engine2.numIterations = 30 +for loop, posLoop in engine2.reconstruct(): + pass + +reconstruction.saveResults("result.hdf5") +``` diff --git a/docs/cpm/index.md b/docs/cpm/index.md new file mode 100644 index 00000000..9bb7c6ef --- /dev/null +++ b/docs/cpm/index.md @@ -0,0 +1,10 @@ +# CPM Workflow + +Everything you need to reconstruct data from a Conventional Ptychographic Microscopy (CPM) experiment. + +## In this section + +- [**Overview**](overview.md) — What CPM is and how PtyLab.py models the physics. +- [**Data Format**](data-format.md) — The HDF5 file structure expected by PtyLab.py. +- [**Engines**](engines.md) — Available reconstruction algorithms (ePIE, mPIE, PcPIE, and more). +- [**Configuration Reference**](configuration.md) — Full reference for all `Params` settings. diff --git a/docs/cpm/overview.md b/docs/cpm/overview.md new file mode 100644 index 00000000..8f515fa3 --- /dev/null +++ b/docs/cpm/overview.md @@ -0,0 +1,123 @@ +# CPM Workflow Overview + +## What is conventional ptychography? + +Conventional Ptychographic Microscopy (CPM) is a computational imaging technique where a coherent probe beam is scanned across a sample at overlapping positions. At each position, a diffraction pattern (intensity only) is recorded. An iterative algorithm then recovers both the complex-valued object (amplitude and phase) and the illumination probe from these intensity measurements alone. + +## Data flow + +``` +HDF5 File + | + v +ExperimentalData (loads diffraction patterns, geometry, scan positions) + | + v +Reconstruction (holds mutable state: object, probe, positions) + | + v +Engine.reconstruct() (iterative phase retrieval: ePIE, mPIE, mqNewton, ...) + | + v +Monitor (real-time visualization of object, probe, error) +``` + +## Step-by-step reconstruction workflow + +### 1. Load experimental data + +Diffraction patterns and experimental geometry are loaded from an HDF5 file into an `ExperimentalData` object. The required fields are: `ptychogram` (diffraction intensities), `wavelength`, `encoder` (scan positions), `dxd` (detector pixel size), and `zo` (sample-to-detector distance). + +See [Data Format](data-format.md) for the full HDF5 specification. + +### 2. Initialize reconstruction state + +A `Reconstruction` object is created from the experimental data. It computes coordinate grids and allocates arrays for the object and probe: + +- **Object**: complex-valued 2D array representing the sample's transmission function +- **Probe**: complex-valued 2D array representing the illumination beam + +Initialization types: + +| Type | Description | +|------|-------------| +| `"circ"` | Circular aperture with random noise | +| `"circ_smooth"` | Smoothed circular aperture | +| `"ones"` | All-ones array with random noise | +| `"rand"` | Fully random initialization | +| `"gaussian"` | Gaussian distribution | +| `"upsampled"` | Upsampled from diffraction patterns | + +### 3. Configure parameters + +The `Params` object holds shared settings: propagator type, constraint switches, regularization options, position ordering, and more. See [Configuration Reference](configuration.md) for all options. + +### 4. Choose and configure an engine + +An engine implements a specific reconstruction algorithm. All engines share the same interface: + +```python +engine = Engines.mPIE(reconstruction, experimentalData, params, monitor) +engine.numIterations = 50 +for loop, posLoop in engine.reconstruct(): + pass +``` + +See [Engines](engines.md) for the full list and selection guide. + +### 5. Iterate + +During `engine.reconstruct()`, the algorithm loops through scan positions. At each position: + +1. Extract the object patch at the current scan position +2. Compute the exit surface wave (ESW): `probe × object_patch` +3. Propagate the ESW to the detector plane +4. Apply the intensity constraint (replace computed amplitude with measured amplitude) +5. Back-propagate to the sample plane +6. Update the object and probe estimates + +The `Monitor` shows live plots of reconstruction progress. + +### 6. Save results + +```python +reconstruction.saveResults("result.hdf5") +``` + +## Reconstructed output + +The reconstructed output is a 6D array of shape `(nlambda, nosm, npsm, nslice, No, No)`: + +| Dimension | Meaning | +|-----------|---------| +| `nlambda` | Number of wavelengths (polychromatic reconstruction) | +| `nosm` | Object state mixture (incoherent object modes) | +| `npsm` | Probe state mixture (incoherent probe modes) | +| `nslice` | Depth slices (multislice for thick samples) | +| `No` | Output frame size (pixels) | + +## Key concepts + +| Term | Description | +|------|-------------| +| **Object** | Complex-valued transmission function of the sample | +| **Probe** | Complex-valued illumination beam at the sample plane | +| **Ptychogram** | Stack of 2D diffraction intensity patterns, one per scan position | +| **Encoder / Scan positions** | Physical (x, y) coordinates where the probe illuminates the sample | +| **Exit surface wave (ESW)** | Product of probe and object patch — the field immediately behind the sample | +| **Propagator** | Method to compute wave propagation between sample and detector planes | +| **Intensity constraint** | Replacing computed amplitude with measured amplitude while retaining the phase | + +## Multi-modal capabilities + +PtyLab.py supports advanced reconstruction modes by adjusting dimension parameters on the `Reconstruction` object: + +| Parameter | Default | Description | +|-----------|---------|-------------| +| `npsm` | 1 | Number of incoherent probe modes (partial coherence) | +| `nosm` | 1 | Number of incoherent object modes | +| `nlambda` | 1 | Number of wavelengths (polychromatic) | +| `nslice` | 1 | Number of object slices (multislice, thick samples) | + +!!! note + Polychromatic reconstruction requires `spectralDensity` in the experimental data. Multislice reconstruction requires setting `nslice > 1` and using the `e3PIE` engine. See [Advanced Topics](../advanced/multislice.md). diff --git a/docs/fpm/calibration.md b/docs/fpm/calibration.md new file mode 100644 index 00000000..4ade817f --- /dev/null +++ b/docs/fpm/calibration.md @@ -0,0 +1,65 @@ +# LED Calibration + +## Why calibrate? + +Physical LED arrays are manufactured with small tolerances — actual LED positions deviate from their nominal values by tens of microns. These errors translate into incorrect illumination angles, which degrade reconstruction quality. The `IlluminationCalibration` class fits a geometric model to correct LED positions before reconstruction. + +## Getting the calibration object + +`IlluminationCalibration` is returned automatically by `easyInitialize` in FPM mode: + +```python +import PtyLab +from PtyLab import Engines + +data, recon, params, monitor, engine, calib = PtyLab.easyInitialize( + "fpm_data.hdf5", + engine=Engines.mqNewton, + operationMode="FPM", +) +``` + +## Running calibration + +```python +calib.fit_mode = "Translation" +calib.runCalibration() +``` + +After `runCalibration()`, the corrected LED positions are propagated into the `ExperimentalData` and `Reconstruction` objects automatically. + +## Calibration modes + +| Mode | Description | +|------|-------------| +| `"Translation"` | Fits a global (dx, dy) offset to all LED positions | + +!!! note + The `"Translation"` mode corrects for a uniform shift of the entire LED array (e.g. from physical misalignment). For more complex distortions, more advanced calibration may be needed. + +## When to skip calibration + +If you are working with synthetic (simulated) data or have independently verified your LED positions, you can skip calibration: + +```python +# Skip calibration, go straight to reconstruction +recon.initializeObjectProbe() +engine.numIterations = 50 +for loop, posLoop in engine.reconstruct(): + pass +``` + +## Inspecting corrected positions + +After calibration, the corrected encoder values are stored on the `Reconstruction` object: + +```python +import matplotlib.pyplot as plt + +plt.figure() +plt.scatter(*data.encoder.T, label="Original", alpha=0.5) +plt.scatter(*recon.encoder_corrected.T, label="Corrected", alpha=0.5) +plt.legend() +plt.axis("equal") +plt.show() +``` diff --git a/docs/fpm/index.md b/docs/fpm/index.md new file mode 100644 index 00000000..db77b414 --- /dev/null +++ b/docs/fpm/index.md @@ -0,0 +1,8 @@ +# FPM Workflow + +Everything you need to reconstruct data from a Fourier Ptychographic Microscopy (FPM) experiment. + +## In this section + +- [**Overview**](overview.md) — What FPM is and how PtyLab.py models LED-array illumination. +- [**LED Calibration**](calibration.md) — How to calibrate LED positions for accurate angle assignment. diff --git a/docs/fpm/overview.md b/docs/fpm/overview.md new file mode 100644 index 00000000..1623d575 --- /dev/null +++ b/docs/fpm/overview.md @@ -0,0 +1,108 @@ +# FPM Workflow Overview + +## What is Fourier ptychography? + +Fourier Ptychographic Microscopy (FPM) uses an LED array to illuminate a sample from different angles. Each LED illuminates the sample with a plane wave at a specific angle, producing a low-resolution image on a camera. By combining many such images from different angles, FPM computationally synthesizes a high-resolution, wide-field image — recovering both amplitude and phase — without mechanically scanning the sample. + +## Data flow + +``` +HDF5 File + | + v +ExperimentalData (loads intensity images, LED positions, geometry) + | + v +IlluminationCalibration (optional: refine LED positions/angles) + | + v +Reconstruction (holds mutable state: object, probe/pupil) + | + v +Engine.reconstruct() (iterative phase retrieval in Fourier domain) + | + v +Monitor (real-time visualization) +``` + +## FPM vs CPM + +| | CPM | FPM | +|---|---|---| +| Illumination | Coherent focused probe scanned across sample | LED array: angular illumination scanning | +| Scanning | Sample plane (real space) | Fourier plane (pupil function) | +| Output | Complex object + probe in real space | Complex object + pupil function | +| Resolution | Limited by probe overlap | Limited by LED array NA | + +## Step-by-step FPM workflow + +### 1. Initialize with `easyInitialize` + +```python +import PtyLab +from PtyLab import Engines + +data, recon, params, monitor, engine, calib = PtyLab.easyInitialize( + "fpm_data.hdf5", + engine=Engines.mqNewton, + operationMode="FPM", +) +``` + +`easyInitialize` returns a **6-tuple** for FPM — note the additional `IlluminationCalibration` object: + +| Object | Description | +|--------|-------------| +| `experimentalData` | FPM diffraction data and geometry | +| `reconstruction` | Mutable state: object array, pupil | +| `params` | Shared configuration | +| `monitor` | Real-time visualization | +| `engine` | Reconstruction algorithm | +| `calib` | LED calibration helper (`IlluminationCalibration`) | + +### 2. Calibrate LED positions (optional but recommended) + +Real LED arrays often have small positioning errors. The `IlluminationCalibration` object fits a model to correct these: + +```python +calib.fit_mode = "Translation" +calib.runCalibration() +``` + +See [LED Calibration](calibration.md) for details. + +### 3. Reconstruct + +```python +recon.initializeObjectProbe() +engine.numIterations = 50 +for loop, posLoop in engine.reconstruct(): + pass + +recon.saveResults("fpm_result.hdf5") +``` + +## FPM required data fields + +| Field | Type | Unit | Description | +|-------|------|------|-------------| +| `ptychogram` | `float32 (N, Nd, Nd)` | counts | Stack of N intensity images | +| `wavelength` | `float64` | m | Illumination wavelength | +| `encoder` | `float64 (N, 2)` | m | LED (x, y) positions | +| `dxd` | `float64` | m | Camera pixel size (in the object plane after magnification) | +| `zled` | `float64` | m | LED-array to sample distance | +| `magnification` | `float64` | — | Microscope magnification | + +## FPM optional data fields + +| Field | Type | Description | +|-------|------|-------------| +| `NA` | `float64` | Numerical aperture of the objective | + +## Recommended engines for FPM + +| Engine | Notes | +|--------|-------| +| `mqNewton` | Recommended — fast quasi-Newton updates | +| `mPIE` | Good all-purpose choice with momentum | +| `ePIE` | Simplest; use for debugging | diff --git a/docs/getting-started/index.md b/docs/getting-started/index.md new file mode 100644 index 00000000..798f02d9 --- /dev/null +++ b/docs/getting-started/index.md @@ -0,0 +1,8 @@ +# Getting Started + +New to PtyLab.py? This section walks you through everything you need to get up and running. + +## In this section + +- [**Installation**](installation.md) — Install PtyLab.py from PyPI or GitHub, with optional GPU support via CuPy. +- [**Quick Start**](quickstart.md) — Run your first reconstruction using `easyInitialize()` with an HDF5 data file. diff --git a/docs/getting-started/installation.md b/docs/getting-started/installation.md new file mode 100644 index 00000000..0f4e31e0 --- /dev/null +++ b/docs/getting-started/installation.md @@ -0,0 +1,71 @@ +# Installation + +PtyLab.py requires **Python 3.10–3.13** and is distributed via GitHub. + +## From GitHub (pip) + +=== "CPU" + + ```bash + pip install git+https://github.com/PtyLab/PtyLab.py.git + ``` + +=== "GPU" + + ```bash + pip install "ptylab[gpu] @ git+https://github.com/PtyLab/PtyLab.py.git" + ``` + +!!! tip + For faster installs, use [uv](https://docs.astral.sh/uv/getting-started/installation/): + + ```bash + uv pip install git+https://github.com/PtyLab/PtyLab.py.git + ``` + +## Verify GPU detection + +After installing with a CUDA extra, confirm the GPU is detected: + +```bash +ptylab check gpu +``` + +This prints available GPU device information or warns if no GPU is found. + +## Development setup + +Clone the repository and install with development dependencies: + +```bash +git clone https://github.com/PtyLab/PtyLab.py.git +cd PtyLab.py +uv sync --extra dev +``` + +This creates a `.venv` virtual environment in the project root. Select it in your IDE or activate it: + +```bash +source .venv/bin/activate +``` + +For GPU support during development: + +```bash +uv sync --extra dev,gpu +``` + +## Running tests + +```bash +uv run pytest tests +``` + +## Serving documentation locally + +```bash +uv sync --extra docs +uv run mkdocs serve +``` + +Then open [http://127.0.0.1:8000](http://127.0.0.1:8000) in your browser. diff --git a/docs/getting-started/quickstart.md b/docs/getting-started/quickstart.md new file mode 100644 index 00000000..21a485ba --- /dev/null +++ b/docs/getting-started/quickstart.md @@ -0,0 +1,122 @@ +# Quick Start + +## Using `easyInitialize` + +The fastest way to run a reconstruction is with `easyInitialize()`, which wires up all components from an HDF5 data file: + +```python +import PtyLab +from PtyLab import Engines + +experimentalData, reconstruction, params, monitor, engine = PtyLab.easyInitialize( + "path/to/data.hdf5", + engine=Engines.mPIE, + operationMode="CPM", +) + +engine.numIterations = 50 +for loop, posLoop in engine.reconstruct(): + pass + +reconstruction.saveResults("result.hdf5") +``` + +`easyInitialize` returns a 5-tuple for CPM: + +| Object | Type | Description | +|--------|------|-------------| +| `experimentalData` | `ExperimentalData` | Diffraction data and geometry from the HDF5 file | +| `reconstruction` | `Reconstruction` | Mutable state: object array, probe array, scan positions | +| `params` | `Params` | Shared configuration (propagator type, constraints, switches) | +| `monitor` | `Monitor` | Real-time visualization during reconstruction | +| `engine` | `BaseEngine` | The reconstruction algorithm instance (e.g. `mPIE`) | + +## Using built-in example data + +To get started without your own dataset, use the bundled simulation data: + +```python +experimentalData, reconstruction, params, monitor, engine = PtyLab.easyInitialize( + "example:simulation_cpm", + engine=Engines.ePIE, + operationMode="CPM", +) +``` + +Available example datasets: + +| Name | Description | +|------|-------------| +| `"example:simulation_cpm"` | Synthetic CPM dataset | +| `"example:simulation_fpm"` | Synthetic FPM dataset | + +## Headless mode + +For batch processing or server environments without a display: + +```python +experimentalData, reconstruction, params, monitor, engine = PtyLab.easyInitialize( + "data.hdf5", + engine=Engines.mPIE, + dummyMonitor=True, +) +``` + +## Manual initialization + +When you need more control (e.g. custom initial probe, multiple modes), skip `easyInitialize` and set up each component explicitly: + +```python +from PtyLab import ExperimentalData, Reconstruction, Params, Monitor, Engines + +# Load data +experimentalData = ExperimentalData("data.hdf5", operationMode="CPM") + +# Configure parameters +params = Params() +params.propagatorType = "ASP" +params.positionOrder = "random" + +# Set up visualization +monitor = Monitor() +monitor.figureUpdateFrequency = 5 +monitor.objectPlot = "complex" + +# Set up reconstruction state +reconstruction = Reconstruction(experimentalData, params) +reconstruction.npsm = 2 # two incoherent probe modes +reconstruction.nosm = 1 +reconstruction.nlambda = 1 +reconstruction.nslice = 1 +reconstruction.initializeObjectProbe() + +# Create and configure engine +engine = Engines.mPIE(reconstruction, experimentalData, params, monitor) +engine.numIterations = 50 +engine.betaObject = 0.25 +engine.betaProbe = 0.25 + +for loop, posLoop in engine.reconstruct(): + pass + +reconstruction.saveResults("result.hdf5") +``` + +## Saving and loading + +```python +# Save the full reconstruction state +reconstruction.saveResults("result.hdf5") + +# Reload probe or object from a previous run +reconstruction.load_probe("previous_result.hdf5") +reconstruction.load_object("previous_result.hdf5") +``` + +## Next steps + +- [CPM Workflow Overview](../cpm/overview.md) — understand the full reconstruction pipeline +- [Engines](../cpm/engines.md) — choose the right reconstruction algorithm +- [Configuration Reference](../cpm/configuration.md) — all available `Params` options +- [FPM Workflow](../fpm/overview.md) — Fourier ptychography with LED arrays +- [Tutorial Notebooks](../tutorials/tutorial_CPM_sim.ipynb) — worked examples end to end diff --git a/docs/index.md b/docs/index.md new file mode 100644 index 00000000..e345db7b --- /dev/null +++ b/docs/index.md @@ -0,0 +1,47 @@ +# PtyLab.py + +!!! warning "Work in Progress" + This documentation is under active development. Some details may be incomplete or vary from the current state of the codebase. Report an [issue](https://github.com/PtyLab/PtyLab.py/issues) if you find inconsistencies. + +PtyLab.py is an open-source inverse modeling toolbox for **Conventional Ptychographic Microscopy (CPM)** and **Fourier Ptychographic Microscopy (FPM)** in a unified framework. It supports a wide range of reconstruction engines, advanced correction algorithms, and transparent GPU acceleration. + +For the original publication, see: [PtyLab.m/py/jl: a cross-platform, open-source inverse modeling toolbox for conventional and Fourier ptychography](https://opg.optica.org/oe/fulltext.cfm?uri=oe-31-9-13763&id=529026). + +## Key features + +- **Classic engines**: ePIE, mPIE, mqNewton, qNewton +- **Advanced corrections**: position correction (pcPIE), defocus correction (zPIE), angle correction (aPIE), orthogonal probe relaxation (OPR) +- **Multi-modal**: multi-slice, multi-wavelength, mixed-state object and probe +- **Multiple propagators**: Fraunhofer, Fresnel, Angular Spectrum (ASP), scaled ASP, polychromatic variants +- **GPU acceleration**: same code runs on CPU and GPU + +## Demo + +[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PtyLab/PtyLab.py/blob/main/demo.ipynb) + +## Where to start + +- **[Installation](getting-started/installation.md)** — Set up PtyLab.py with CPU or GPU support +- **[Quick Start](getting-started/quickstart.md)** — Run your first reconstruction in a few lines of code +- **[CPM Workflow](cpm/overview.md)** — Understand the conventional ptychography pipeline +- **[FPM Workflow](fpm/overview.md)** — Fourier ptychography with LED array illumination +- **[Tutorials](tutorials/tutorial_CPM_sim.ipynb)** — Jupyter notebooks covering common use cases + +## Citation + +If you use PtyLab.py in your work, please cite: + +```bibtex +@article{Loetgering:23, + author = {Lars Loetgering and Mengqi Du and Dirk Boonzajer Flaes and Tomas Aidukas and Felix Wechsler and Daniel S. Penagos Molina and Max Rose and Antonios Pelekanidis and Wilhelm Eschen and J\"{u}rgen Hess and Thomas Wilhein and Rainer Heintzmann and Jan Rothhardt and Stefan Witte}, + journal = {Opt. Express}, + number = {9}, + pages = {13763--13797}, + publisher = {Optica Publishing Group}, + title = {PtyLab.m/py/jl: a cross-platform, open-source inverse modeling toolbox for conventional and Fourier ptychography}, + volume = {31}, + month = {Apr}, + year = {2023}, + doi = {10.1364/OE.485370}, +} +``` diff --git a/docs/stylesheets/extra.css b/docs/stylesheets/extra.css new file mode 100644 index 00000000..24b36e9e --- /dev/null +++ b/docs/stylesheets/extra.css @@ -0,0 +1,13 @@ +[data-md-color-scheme="default"] { + --md-default-bg-color: #fbfbfb; + --md-code-bg-color: #f7f5f0; + --md-primary-fg-color: #a0785a; + --md-primary-bg-color: #ffffff; +} + +/* Jupyter code input cells only — light mode */ +[data-md-color-scheme="default"] .highlight-ipynb, +[data-md-color-scheme="default"] .highlight-ipynb pre, +[data-md-color-scheme="default"] .CodeMirror.cm-s-jupyter { + background-color: #f7f5f0 !important; +} \ No newline at end of file diff --git a/docs/tutorials/index.md b/docs/tutorials/index.md new file mode 100644 index 00000000..870ac251 --- /dev/null +++ b/docs/tutorials/index.md @@ -0,0 +1,13 @@ +# Tutorials + +Hands-on Jupyter notebooks covering CPM and FPM reconstruction from simulation and real data. + +## In this section + +- [**01 – CPM Simulation**](tutorial_CPM_sim.ipynb) — Simulate a CPM dataset and reconstruct it end-to-end. +- [**02 – CPM Example Data**](tutorial_CPM.ipynb) — Reconstruct a real CPM dataset using `easyInitialize`. +- [**03 – CPM Multi-Wavelength**](tutorial_CPM_multiWavelength.ipynb) — Handle datasets acquired with multiple illumination wavelengths. +- [**04 – CPM Position Correction**](tutorial_LateralPositionCorrection.ipynb) — Correct lateral probe-position errors during reconstruction. +- [**05 – CPM Reflection**](tutorial_reflectionPtychography.ipynb) — Reconstruct data from a reflection-mode ptychography setup. +- [**06 – CPM Interferometric Intensity**](tutorial_interferometricIntensityConstraint.ipynb) — Apply an interferometric intensity constraint during reconstruction. +- [**07 – FPM**](tutorial_FPM.ipynb) — Reconstruct a Fourier ptychography dataset from LED-array images. diff --git a/docs/tutorials/tutorial_CPM.ipynb b/docs/tutorials/tutorial_CPM.ipynb new file mode 120000 index 00000000..e1478875 --- /dev/null +++ b/docs/tutorials/tutorial_CPM.ipynb @@ -0,0 +1 @@ +../../jupyter_tutorials/jupyter_tutorials_tutorial_CPM.ipynb \ No newline at end of file diff --git a/docs/tutorials/tutorial_CPM_multiWavelength.ipynb b/docs/tutorials/tutorial_CPM_multiWavelength.ipynb new file mode 120000 index 00000000..016204a1 --- /dev/null +++ b/docs/tutorials/tutorial_CPM_multiWavelength.ipynb @@ -0,0 +1 @@ +../../jupyter_tutorials/jupyter_tutorials_tutorial_CPM_multiWavelength.ipynb \ No newline at end of file diff --git a/docs/tutorials/tutorial_CPM_sim.ipynb b/docs/tutorials/tutorial_CPM_sim.ipynb new file mode 120000 index 00000000..4a21c235 --- /dev/null +++ b/docs/tutorials/tutorial_CPM_sim.ipynb @@ -0,0 +1 @@ +../../jupyter_tutorials/jupyter_tutorials_tutorial_CPM_sim.ipynb \ No newline at end of file diff --git a/docs/tutorials/tutorial_FPM.ipynb b/docs/tutorials/tutorial_FPM.ipynb new file mode 120000 index 00000000..4f20f3b2 --- /dev/null +++ b/docs/tutorials/tutorial_FPM.ipynb @@ -0,0 +1 @@ +../../jupyter_tutorials/jupyter_tutorials_tutorial_FPM.ipynb \ No newline at end of file diff --git a/docs/tutorials/tutorial_LateralPositionCorrection.ipynb b/docs/tutorials/tutorial_LateralPositionCorrection.ipynb new file mode 120000 index 00000000..85f254e5 --- /dev/null +++ b/docs/tutorials/tutorial_LateralPositionCorrection.ipynb @@ -0,0 +1 @@ +../../jupyter_tutorials/jupyter_tutorials_tutorial_LateralPositionCorrection.ipynb \ No newline at end of file diff --git a/docs/tutorials/tutorial_interferometricIntensityConstraint.ipynb b/docs/tutorials/tutorial_interferometricIntensityConstraint.ipynb new file mode 120000 index 00000000..1545e2fb --- /dev/null +++ b/docs/tutorials/tutorial_interferometricIntensityConstraint.ipynb @@ -0,0 +1 @@ +../../jupyter_tutorials/jupyter_tutorials_tutorial_interferometricIntensityConstraint.ipynb \ No newline at end of file diff --git a/docs/tutorials/tutorial_reflectionPtychography.ipynb b/docs/tutorials/tutorial_reflectionPtychography.ipynb new file mode 120000 index 00000000..19e5e8db --- /dev/null +++ b/docs/tutorials/tutorial_reflectionPtychography.ipynb @@ -0,0 +1 @@ +../../jupyter_tutorials/jupyter_tutorials_tutorial_reflectionPtychography.ipynb \ No newline at end of file diff --git a/example_data/how_to_get_files.md b/example_data/how_to_get_files.md index 93d745b2..8bf41516 100644 --- a/example_data/how_to_get_files.md +++ b/example_data/how_to_get_files.md @@ -1,6 +1,34 @@ How to get the example datasets =============================== -To generate some example data to reconstruct, run `example_scripts/simulateData.py`. +## Synthetic CPM dataset (`simu.hdf5`) -This should store some data in this folder which can then be used to reconstruct. For some additional datasets, head over to and put the .hdf5 files in this folder. \ No newline at end of file +This file is generated automatically — you do not need to run any script manually. + +**From a notebook:** The tutorials `02 – CPM Example Data` and `04 – CPM Position Correction` +generate it on first run via: + +```python +from PtyLab.io import getExampleDataFolder, generate_simu_hdf5 + +filePath = getExampleDataFolder() / "simu.hdf5" +if not filePath.exists(): + generate_simu_hdf5(filePath) +``` + +**From a script or the REPL:** + +```python +from PtyLab.io import getExampleDataFolder, generate_simu_hdf5 + +generate_simu_hdf5(getExampleDataFolder() / "simu.hdf5") +``` + +**From the test suite:** `tests/conftest.py` generates `simu.hdf5` automatically before +any test that depends on `"example:simulation_cpm"`. + +## Other datasets + +Additional datasets (e.g. `LungCarcinomaSmallFPM.hdf5`, `TwoLayer_bin4.hdf5`) are downloaded +automatically by the corresponding tutorials on first run. Place any `.hdf5` files you download +manually into this folder to make them available to the loaders. diff --git a/jupyter_tutorials/jupyter_tutorials_tutorial_CPM.ipynb b/jupyter_tutorials/jupyter_tutorials_tutorial_CPM.ipynb index 43597281..7926c2de 100644 --- a/jupyter_tutorials/jupyter_tutorials_tutorial_CPM.ipynb +++ b/jupyter_tutorials/jupyter_tutorials_tutorial_CPM.ipynb @@ -4,45 +4,62 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# ptyLab introduction (CP)\n", + "# 02 – CPM Example Data\n", "\n", - "ptyLab is a highly modular coding package which can be used for both conventional and Fourier ptychography. Due to the modular nature it is easy to modify the code for various tasks and add your own functions, such as a new reconstruction engine or a calibration routine. To understand ptyLab we need to understand the basic sub-modules/classes contained within, which are briefly outlined below:\n", + "This tutorial demonstrates a complete CPM reconstruction workflow using a real experimental dataset loaded from an HDF5 file. It covers loading data, initializing the reconstruction, configuring parameters, and running an iterative engine.\n", "\n", + "**What you'll learn:**\n", "\n", - " - ExperimentalData - this module contains a single class ExperimentalData, that is used to import the experimental data from an .hdf5 file. If the file contains the experimental images stored as an image stack (called ptychogram), probe/LED positions and several experimental parameters, then the data can be successfully imported and reconstructed.\n", - " - Reconstruction - this module contains a single class Reconstruction, which creates various objects from the immutable ExperimentalData class, and objects used in the reconstruction process, which are mutable. It includes things that can be optimized, e.g. the probe/pupil, the imaging object, the sample-camera distance, the scan positions, and the tilt-plane angle. It also includes things that are needed in reconstruction, e.g. the coordinates/meshgrid of the object/probe/camera planes. \n", - " - Engines - All the engines used for the reconstruction are in this module, which take the ExperimentalData and Optimizable objects as parameters and perform object/probe/pupil reconstruction. This module contains a BaseEngine as a parent class, and the rest of engines (ePIE, mPIE, zPIE, aPIE, qNewton, etc) inherit from the BaseEngine.\n", - " - Params - this class stores parameters used to control the reconstruction. It includes general parameters such as positionsOrder, prpagatorType, and gpuSwitch, ect. It also includes all the switches and parameters for regularizations, e.g. orthogonalizationSwitch and orthogonalizationFrequency.\n", - " - Monitor - visualization classes used to display the reconstruction process. Currently it produces two plots, where the default figure shows the object/probe/error plot, and the second figure shows the diffraction patterns (both the measured and the estimated ones). There are parameters that are used to control how you want the plots to be, e.g. figureUpdateFrequency, objectZoom/probeZoom, ect." + "- How to load experimental CPM data from an HDF5 file\n", + "- How to configure `Params` and choose a reconstruction engine\n", + "- How to iterate and visualize the reconstruction in real time\n", + "\n", + "!!! note \"Dataset\"\n", + " The dataset (`simu.hdf5`) is generated automatically into the `example_data/` folder at the project root the first time you run the notebook. If the file already exists it is not re-generated.\n", + "\n", + "!!! tip \"Prerequisites\"\n", + " Complete [01 – CPM Simulation](tutorial_CPM_sim.ipynb) before this tutorial." ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ - "%matplotlib notebook\n", "import matplotlib\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", + "\n", "# import the PtyLab module\n", "import PtyLab" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "simu.hdf5 found, skipping generation.\n" + ] + } + ], "source": [ - "# To perform CP(conventional ptychography) reconstructions, we use the dataset Simu.hdf5, which can be generated by running the simulation tutorial.\n", + "from PtyLab.io import getExampleDataFolder, generate_simu_hdf5\n", "\n", + "fileName = \"simu.hdf5\"\n", + "filePath = getExampleDataFolder() / fileName\n", "\n", - "fileName = 'Simu.hdf5' # 'Simu.hdf5'\n", - "\n", - "from PtyLab.io import getExampleDataFolder\n", - "filePath = getExampleDataFolder() / fileName # get the exampleDataFolder" + "if not filePath.exists():\n", + " print(\"Generating simu.hdf5...\")\n", + " generate_simu_hdf5(filePath)\n", + " print(\"Done.\")\n", + "else:\n", + " print(f\"{fileName} found, skipping generation.\")" ] }, { @@ -56,24 +73,38 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "Copying attribute wavelength\n", - "Copying attribute dxd\n", - "Copying attribute theta\n", - "Copying attribute spectralDensity\n", - "Copying attribute entrancePupilDiameter\n" + "INFO:GPU:cupy and CUDA available, switching to GPU\n", + "INFO:Reconstruction:Copying attribute wavelength\n", + "INFO:Reconstruction:Copying attribute dxd\n", + "INFO:Reconstruction:Copying attribute theta\n", + "INFO:Reconstruction:Copying attribute spectralDensity\n", + "INFO:Reconstruction:Copying attribute entrancePupilDiameter\n", + "INFO:Reconstruction:Initial object set to ones\n", + "INFO:Reconstruction:Initial probe set to circ\n", + "INFO:ePIE:Sucesfully created ePIE ePIE_engine\n", + "INFO:ePIE:Wavelength attribute: 6.327999813038332e-07\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found encoder with shape (100, 2)\n" ] } ], "source": [ "## optional\n", - "exampleData, reconstruction, params, monitor, ePIE_engine = PtyLab.easyInitialize(filePath)" + "exampleData, reconstruction, params, monitor, ePIE_engine = PtyLab.easyInitialize(\n", + " filePath\n", + ")" ] }, { @@ -108,9 +139,17 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found encoder with shape (100, 2)\n" + ] + } + ], "source": [ "# initialize the ExperimentalData class\n", "exampleData = PtyLab.ExperimentalData(filePath)" @@ -118,21 +157,35 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Min max ptychogram: 2.462452171423518e-14, 32837.0\n", - "Min max ptychogram: 1.0704034878741355e-14, 4.516376698526149\n", - "1.0704034878741355e-14 4.516376698526149\n" + "Min max ptychogram: 2.462452171423518e-14, 32774.45703125\n", + "Min max ptychogram: 0.0, 4.5155487060546875\n", + "0.0 4.5155487\n" ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9434278fa14348178d81d6067e5a16f4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(IntSlider(value=0, description='Frame', max=99), Output()))" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "# now, all our experimental data is loaded into exampleData, and we can check our diffraction patterns (or ptychograms). \n", + "# now, all our experimental data is loaded into exampleData, and we can check our diffraction patterns (or ptychograms).\n", "exampleData.showPtychogram() # close the figure to proceed" ] }, @@ -146,24 +199,24 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "Copying attribute wavelength\n", - "Copying attribute dxd\n", - "Copying attribute theta\n", - "Copying attribute spectralDensity\n", - "Copying attribute entrancePupilDiameter\n" + "INFO:Reconstruction:Copying attribute wavelength\n", + "INFO:Reconstruction:Copying attribute dxd\n", + "INFO:Reconstruction:Copying attribute theta\n", + "INFO:Reconstruction:Copying attribute spectralDensity\n", + "INFO:Reconstruction:Copying attribute entrancePupilDiameter\n" ] } ], "source": [ - "## initialize the Reconstruction class \n", - "reconstruction = PtyLab.Reconstruction(exampleData,params)" + "## initialize the Reconstruction class\n", + "reconstruction = PtyLab.Reconstruction(exampleData, params)" ] }, { @@ -175,25 +228,40 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:Reconstruction:Initial object set to ones\n", + "INFO:Reconstruction:Initial probe set to circ\n" + ] + } + ], "source": [ "# now create an object to hold everything we're eventually interested in\n", - "reconstruction.npsm = 1 # Number of probe modes to reconstruct\n", - "reconstruction.nosm = 1 # Number of object modes to reconstruct\n", - "reconstruction.nlambda = 1 # len(exampleData.spectralDensity) # Number of wavelength\n", - "reconstruction.nslice = 1 # Number of object slice\n", + "reconstruction.npsm = 1 # Number of probe modes to reconstruct\n", + "reconstruction.nosm = 1 # Number of object modes to reconstruct\n", + "reconstruction.nlambda = 1 # len(exampleData.spectralDensity) # Number of wavelength\n", + "reconstruction.nslice = 1 # Number of object slice\n", "\n", "# set initial guesses\n", - "reconstruction.initialProbe = 'circ'\n", - "reconstruction.initialObject = 'ones'\n", + "reconstruction.initialProbe = \"circ\"\n", + "reconstruction.initialObject = \"ones\"\n", "# initialize probe and object and related params\n", "reconstruction.initializeObjectProbe()\n", "\n", "# customize initial probe quadratic phase if wish\n", - "reconstruction.probe = reconstruction.probe*np.exp(1.j*2*np.pi/reconstruction.wavelength * \n", - " (reconstruction.Xp**2+reconstruction.Yp**2)/(2*6e-3))\n" + "reconstruction.probe = reconstruction.probe * np.exp(\n", + " 1.0j\n", + " * 2\n", + " * np.pi\n", + " / reconstruction.wavelength\n", + " * (reconstruction.Xp**2 + reconstruction.Yp**2)\n", + " / (2 * 6e-3)\n", + ")\n" ] }, { @@ -206,7 +274,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -216,17 +284,26 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/mnt/home/shantanu/projects/PtyLab.py/PtyLab/Monitor/Monitor.py:178: UserWarning: For faster update of the reconstruction plot, set `monitor.figureUpdateFrequency = 5` or higher.\n", + " warnings.warn(\n" + ] + } + ], "source": [ "## Set monitor properties\n", - "monitor.verboseLevel = 'low' # low (default): plot only one figure (object/probe/error), high: add a second figure showing measured and estimated diffraction patterns \n", - "monitor.figureUpdateFrequency = 1 # the frequency of the plots\n", - "monitor.objectPlot = 'complex' # options: complex, abs, angle\n", - "monitor.objectZoom = 1.5 # control object plot FoV\n", - "monitor.probeZoom = 0.5 # control probe plot FoV\n", - "monitor.objectPlotContrast = 0.9 # control the contrast of object plot, normalized intensity is from [0,1], objectPlotContrast sets the maximum value for color axis\n", + "monitor.verboseLevel = \"low\" # low (default): plot only one figure (object/probe/error), high: add a second figure showing measured and estimated diffraction patterns\n", + "monitor.figureUpdateFrequency = 1 # the frequency of the plots\n", + "monitor.objectPlot = \"complex\" # options: complex, abs, angle\n", + "monitor.objectZoom = 1.5 # control object plot FoV\n", + "monitor.probeZoom = 0.5 # control probe plot FoV\n", + "monitor.objectPlotContrast = 0.9 # control the contrast of object plot, normalized intensity is from [0,1], objectPlotContrast sets the maximum value for color axis\n", "monitor.probePlotContrast = 0.9 # control the contrast of probe plot" ] }, @@ -242,9 +319,17 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:GPU:cupy and CUDA available, switching to GPU\n" + ] + } + ], "source": [ "## Initialise Params class\n", "params = PtyLab.Params()" @@ -252,22 +337,30 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "## main parameters\n", - "params.positionOrder = 'random' # 'sequential' or 'random'\n", - "params.propagator = 'Fresnel' # Fraunhofer Fresnel ASP scaledASP polychromeASP scaledPolychromeASP\n", + "params.positionOrder = \"random\" # 'sequential' or 'random'\n", + "params.propagator = (\n", + " \"Fresnel\" # Fraunhofer Fresnel ASP scaledASP polychromeASP scaledPolychromeASP\n", + ")\n", "\n", "## how do we want to reconstruct?\n", - "params.gpuSwitch = True # Turn on if gpu is available, with cupy imported.\n", - "params.probePowerCorrectionSwitch = True # fix the power of the probe to the maximum of the ptychogram\n", - "params.comStabilizationSwitch = True # fix the center-of-mass of the probe in the center of the probe frame\n", - "params.orthogonalizationSwitch = False # turn on when performing mixed states reconstructions\n", + "params.gpuSwitch = True # Turn on if gpu is available, with cupy imported.\n", + "params.probePowerCorrectionSwitch = (\n", + " True # fix the power of the probe to the maximum of the ptychogram\n", + ")\n", + "params.comStabilizationSwitch = (\n", + " True # fix the center-of-mass of the probe in the center of the probe frame\n", + ")\n", + "params.orthogonalizationSwitch = (\n", + " False # turn on when performing mixed states reconstructions\n", + ")\n", "params.orthogonalizationFrequency = 10 # the frequency of performing orthogonalization\n", - "params.fftshiftSwitch = False \n", - "params.intensityConstraint = 'standard' # standard fluctuation exponential poission\n", + "params.fftshiftSwitch = False\n", + "params.intensityConstraint = \"standard\" # standard fluctuation exponential poission\n", "params.absorbingProbeBoundary = False\n", "params.objectContrastSwitch = False\n", "params.absObjectSwitch = False\n", @@ -288,26 +381,35 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:ePIE:Sucesfully created ePIE ePIE_engine\n", + "INFO:ePIE:Wavelength attribute: 6.327999813038332e-07\n" + ] + } + ], "source": [ "## Initialize the engine class by passing the exampleData, reconstruction, params, and monitor objects to the chosen engine\n", - "ePIE = PtyLab.Engines.ePIE(reconstruction,exampleData,params,monitor)" + "ePIE = PtyLab.Engines.ePIE(reconstruction, exampleData, params, monitor)" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 22, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -321,982 +423,14 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 14, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "d:\\du\\ptylab\\PtyLab\\Engines\\BaseEngine.py:376: UserWarning: fftshiftSwitch set to false, this may lead to reduced performance\n", - " warnings.warn(\n" - ] - }, - { - "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "/* global mpl */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function () {\n", - " if (typeof WebSocket !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof MozWebSocket !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert(\n", - " 'Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.'\n", - " );\n", - " }\n", - "};\n", - "\n", - "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = this.ws.binaryType !== undefined;\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById('mpl-warnings');\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent =\n", - " 'This browser does not support binary websocket messages. ' +\n", - " 'Performance may be slow.';\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = document.createElement('div');\n", - " this.root.setAttribute('style', 'display: inline-block');\n", - " this._root_extra_style(this.root);\n", - "\n", - " parent_element.appendChild(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message('supports_binary', { value: fig.supports_binary });\n", - " fig.send_message('send_image_mode', {});\n", - " if (fig.ratio !== 1) {\n", - " fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });\n", - " }\n", - " fig.send_message('refresh', {});\n", - " };\n", - "\n", - " this.imageObj.onload = function () {\n", - " if (fig.image_mode === 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function () {\n", - " fig.ws.close();\n", - " };\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "};\n", - "\n", - "mpl.figure.prototype._init_header = function () {\n", - " var titlebar = document.createElement('div');\n", - " titlebar.classList =\n", - " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", - " var titletext = document.createElement('div');\n", - " titletext.classList = 'ui-dialog-title';\n", - " titletext.setAttribute(\n", - " 'style',\n", - " 'width: 100%; text-align: center; padding: 3px;'\n", - " );\n", - " titlebar.appendChild(titletext);\n", - " this.root.appendChild(titlebar);\n", - " this.header = titletext;\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._init_canvas = function () {\n", - " var fig = this;\n", - "\n", - " var canvas_div = (this.canvas_div = document.createElement('div'));\n", - " canvas_div.setAttribute(\n", - " 'style',\n", - " 'border: 1px solid #ddd;' +\n", - " 'box-sizing: content-box;' +\n", - " 'clear: both;' +\n", - " 'min-height: 1px;' +\n", - " 'min-width: 1px;' +\n", - " 'outline: 0;' +\n", - " 'overflow: hidden;' +\n", - " 'position: relative;' +\n", - " 'resize: both;'\n", - " );\n", - "\n", - " function on_keyboard_event_closure(name) {\n", - " return function (event) {\n", - " return fig.key_event(event, name);\n", - " };\n", - " }\n", - "\n", - " canvas_div.addEventListener(\n", - " 'keydown',\n", - " on_keyboard_event_closure('key_press')\n", - " );\n", - " canvas_div.addEventListener(\n", - " 'keyup',\n", - " on_keyboard_event_closure('key_release')\n", - " );\n", - "\n", - " this._canvas_extra_style(canvas_div);\n", - " this.root.appendChild(canvas_div);\n", - "\n", - " var canvas = (this.canvas = document.createElement('canvas'));\n", - " canvas.classList.add('mpl-canvas');\n", - " canvas.setAttribute('style', 'box-sizing: content-box;');\n", - "\n", - " this.context = canvas.getContext('2d');\n", - "\n", - " var backingStore =\n", - " this.context.backingStorePixelRatio ||\n", - " this.context.webkitBackingStorePixelRatio ||\n", - " this.context.mozBackingStorePixelRatio ||\n", - " this.context.msBackingStorePixelRatio ||\n", - " this.context.oBackingStorePixelRatio ||\n", - " this.context.backingStorePixelRatio ||\n", - " 1;\n", - "\n", - " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", - " 'canvas'\n", - " ));\n", - " rubberband_canvas.setAttribute(\n", - " 'style',\n", - " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", - " );\n", - "\n", - " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", - " if (this.ResizeObserver === undefined) {\n", - " if (window.ResizeObserver !== undefined) {\n", - " this.ResizeObserver = window.ResizeObserver;\n", - " } else {\n", - " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", - " this.ResizeObserver = obs.ResizeObserver;\n", - " }\n", - " }\n", - "\n", - " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", - " var nentries = entries.length;\n", - " for (var i = 0; i < nentries; i++) {\n", - " var entry = entries[i];\n", - " var width, height;\n", - " if (entry.contentBoxSize) {\n", - " if (entry.contentBoxSize instanceof Array) {\n", - " // Chrome 84 implements new version of spec.\n", - " width = entry.contentBoxSize[0].inlineSize;\n", - " height = entry.contentBoxSize[0].blockSize;\n", - " } else {\n", - " // Firefox implements old version of spec.\n", - " width = entry.contentBoxSize.inlineSize;\n", - " height = entry.contentBoxSize.blockSize;\n", - " }\n", - " } else {\n", - " // Chrome <84 implements even older version of spec.\n", - " width = entry.contentRect.width;\n", - " height = entry.contentRect.height;\n", - " }\n", - "\n", - " // Keep the size of the canvas and rubber band canvas in sync with\n", - " // the canvas container.\n", - " if (entry.devicePixelContentBoxSize) {\n", - " // Chrome 84 implements new version of spec.\n", - " canvas.setAttribute(\n", - " 'width',\n", - " entry.devicePixelContentBoxSize[0].inlineSize\n", - " );\n", - " canvas.setAttribute(\n", - " 'height',\n", - " entry.devicePixelContentBoxSize[0].blockSize\n", - " );\n", - " } else {\n", - " canvas.setAttribute('width', width * fig.ratio);\n", - " canvas.setAttribute('height', height * fig.ratio);\n", - " }\n", - " canvas.setAttribute(\n", - " 'style',\n", - " 'width: ' + width + 'px; height: ' + height + 'px;'\n", - " );\n", - "\n", - " rubberband_canvas.setAttribute('width', width);\n", - " rubberband_canvas.setAttribute('height', height);\n", - "\n", - " // And update the size in Python. We ignore the initial 0/0 size\n", - " // that occurs as the element is placed into the DOM, which should\n", - " // otherwise not happen due to the minimum size styling.\n", - " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", - " fig.request_resize(width, height);\n", - " }\n", - " }\n", - " });\n", - " this.resizeObserverInstance.observe(canvas_div);\n", - "\n", - " function on_mouse_event_closure(name) {\n", - " return function (event) {\n", - " return fig.mouse_event(event, name);\n", - " };\n", - " }\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mousedown',\n", - " on_mouse_event_closure('button_press')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseup',\n", - " on_mouse_event_closure('button_release')\n", - " );\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband_canvas.addEventListener(\n", - " 'mousemove',\n", - " on_mouse_event_closure('motion_notify')\n", - " );\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseenter',\n", - " on_mouse_event_closure('figure_enter')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseleave',\n", - " on_mouse_event_closure('figure_leave')\n", - " );\n", - "\n", - " canvas_div.addEventListener('wheel', function (event) {\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " on_mouse_event_closure('scroll')(event);\n", - " });\n", - "\n", - " canvas_div.appendChild(canvas);\n", - " canvas_div.appendChild(rubberband_canvas);\n", - "\n", - " this.rubberband_context = rubberband_canvas.getContext('2d');\n", - " this.rubberband_context.strokeStyle = '#000000';\n", - "\n", - " this._resize_canvas = function (width, height, forward) {\n", - " if (forward) {\n", - " canvas_div.style.width = width + 'px';\n", - " canvas_div.style.height = height + 'px';\n", - " }\n", - " };\n", - "\n", - " // Disable right mouse context menu.\n", - " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", - " event.preventDefault();\n", - " return false;\n", - " });\n", - "\n", - " function set_focus() {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'mpl-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " continue;\n", - " }\n", - "\n", - " var button = (fig.buttons[name] = document.createElement('button'));\n", - " button.classList = 'mpl-widget';\n", - " button.setAttribute('role', 'button');\n", - " button.setAttribute('aria-disabled', 'false');\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - "\n", - " var icon_img = document.createElement('img');\n", - " icon_img.src = '_images/' + image + '.png';\n", - " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", - " icon_img.alt = tooltip;\n", - " button.appendChild(icon_img);\n", - "\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " var fmt_picker = document.createElement('select');\n", - " fmt_picker.classList = 'mpl-widget';\n", - " toolbar.appendChild(fmt_picker);\n", - " this.format_dropdown = fmt_picker;\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = document.createElement('option');\n", - " option.selected = fmt === mpl.default_extension;\n", - " option.innerHTML = fmt;\n", - " fmt_picker.appendChild(option);\n", - " }\n", - "\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "};\n", - "\n", - "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", - "};\n", - "\n", - "mpl.figure.prototype.send_message = function (type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "};\n", - "\n", - "mpl.figure.prototype.send_draw_message = function () {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1], msg['forward']);\n", - " fig.send_message('refresh', {});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", - " var x0 = msg['x0'] / fig.ratio;\n", - " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", - " var x1 = msg['x1'] / fig.ratio;\n", - " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0,\n", - " 0,\n", - " fig.canvas.width / fig.ratio,\n", - " fig.canvas.height / fig.ratio\n", - " );\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", - " var cursor = msg['cursor'];\n", - " switch (cursor) {\n", - " case 0:\n", - " cursor = 'pointer';\n", - " break;\n", - " case 1:\n", - " cursor = 'default';\n", - " break;\n", - " case 2:\n", - " cursor = 'crosshair';\n", - " break;\n", - " case 3:\n", - " cursor = 'move';\n", - " break;\n", - " }\n", - " fig.rubberband_canvas.style.cursor = cursor;\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_message = function (fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", - " for (var key in msg) {\n", - " if (!(key in fig.buttons)) {\n", - " continue;\n", - " }\n", - " fig.buttons[key].disabled = !msg[key];\n", - " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", - " if (msg['mode'] === 'PAN') {\n", - " fig.buttons['Pan'].classList.add('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " } else if (msg['mode'] === 'ZOOM') {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.add('active');\n", - " } else {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message('ack', {});\n", - "};\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function (fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " evt.data.type = 'image/png';\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src\n", - " );\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " evt.data\n", - " );\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " } else if (\n", - " typeof evt.data === 'string' &&\n", - " evt.data.slice(0, 21) === 'data:image/png;base64'\n", - " ) {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig['handle_' + msg_type];\n", - " } catch (e) {\n", - " console.log(\n", - " \"No handler for the '\" + msg_type + \"' message type: \",\n", - " msg\n", - " );\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\n", - " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", - " e,\n", - " e.stack,\n", - " msg\n", - " );\n", - " }\n", - " }\n", - " };\n", - "};\n", - "\n", - "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function (e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e) {\n", - " e = window.event;\n", - " }\n", - " if (e.target) {\n", - " targ = e.target;\n", - " } else if (e.srcElement) {\n", - " targ = e.srcElement;\n", - " }\n", - " if (targ.nodeType === 3) {\n", - " // defeat Safari bug\n", - " targ = targ.parentNode;\n", - " }\n", - "\n", - " // pageX,Y are the mouse positions relative to the document\n", - " var boundingRect = targ.getBoundingClientRect();\n", - " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", - " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n", - "\n", - " return { x: x, y: y };\n", - "};\n", - "\n", - "/*\n", - " * return a copy of an object with only non-object keys\n", - " * we need this to avoid circular references\n", - " * http://stackoverflow.com/a/24161582/3208463\n", - " */\n", - "function simpleKeys(original) {\n", - " return Object.keys(original).reduce(function (obj, key) {\n", - " if (typeof original[key] !== 'object') {\n", - " obj[key] = original[key];\n", - " }\n", - " return obj;\n", - " }, {});\n", - "}\n", - "\n", - "mpl.figure.prototype.mouse_event = function (event, name) {\n", - " var canvas_pos = mpl.findpos(event);\n", - "\n", - " if (name === 'button_press') {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x * this.ratio;\n", - " var y = canvas_pos.y * this.ratio;\n", - "\n", - " this.send_message(name, {\n", - " x: x,\n", - " y: y,\n", - " button: event.button,\n", - " step: event.step,\n", - " guiEvent: simpleKeys(event),\n", - " });\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "};\n", - "\n", - "mpl.figure.prototype.key_event = function (event, name) {\n", - " // Prevent repeat events\n", - " if (name === 'key_press') {\n", - " if (event.which === this._key) {\n", - " return;\n", - " } else {\n", - " this._key = event.which;\n", - " }\n", - " }\n", - " if (name === 'key_release') {\n", - " this._key = null;\n", - " }\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.which !== 17) {\n", - " value += 'ctrl+';\n", - " }\n", - " if (event.altKey && event.which !== 18) {\n", - " value += 'alt+';\n", - " }\n", - " if (event.shiftKey && event.which !== 16) {\n", - " value += 'shift+';\n", - " }\n", - "\n", - " value += 'k';\n", - " value += event.which.toString();\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", - " if (name === 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message('toolbar_button', { name: name });\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "\n", - "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", - "// prettier-ignore\n", - "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", - "\n", - "mpl.default_extension = \"png\";/* global mpl */\n", - "\n", - "var comm_websocket_adapter = function (comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.close = function () {\n", - " comm.close();\n", - " };\n", - " ws.send = function (m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function (msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", - " ws.onmessage(msg['content']['data']);\n", - " });\n", - " return ws;\n", - "};\n", - "\n", - "mpl.mpl_figure_comm = function (comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = document.getElementById(id);\n", - " var ws_proxy = comm_websocket_adapter(comm);\n", - "\n", - " function ondownload(figure, _format) {\n", - " window.open(figure.canvas.toDataURL());\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element;\n", - " fig.cell_info = mpl.find_output_cell(\"
\");\n", - " if (!fig.cell_info) {\n", - " console.error('Failed to find cell for figure', id, fig);\n", - " return;\n", - " }\n", - " fig.cell_info[0].output_area.element.on(\n", - " 'cleared',\n", - " { fig: fig },\n", - " fig._remove_fig_handler\n", - " );\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function (fig, msg) {\n", - " var width = fig.canvas.width / fig.ratio;\n", - " fig.cell_info[0].output_area.element.off(\n", - " 'cleared',\n", - " fig._remove_fig_handler\n", - " );\n", - " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", - "\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable();\n", - " fig.parent_element.innerHTML =\n", - " '';\n", - " fig.close_ws(fig, msg);\n", - "};\n", - "\n", - "mpl.figure.prototype.close_ws = function (fig, msg) {\n", - " fig.send_message('closing', msg);\n", - " // fig.ws.close()\n", - "};\n", - "\n", - "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var width = this.canvas.width / this.ratio;\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] =\n", - " '';\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message('ack', {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () {\n", - " fig.push_to_output();\n", - " }, 1000);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'btn-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " var button;\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " continue;\n", - " }\n", - "\n", - " button = fig.buttons[name] = document.createElement('button');\n", - " button.classList = 'btn btn-default';\n", - " button.href = '#';\n", - " button.title = name;\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message pull-right';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = document.createElement('div');\n", - " buttongrp.classList = 'btn-group inline pull-right';\n", - " button = document.createElement('button');\n", - " button.classList = 'btn btn-mini btn-primary';\n", - " button.href = '#';\n", - " button.title = 'Stop Interaction';\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', function (_evt) {\n", - " fig.handle_close(fig, {});\n", - " });\n", - " button.addEventListener(\n", - " 'mouseover',\n", - " on_mouseover_closure('Stop Interaction')\n", - " );\n", - " buttongrp.appendChild(button);\n", - " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", - " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", - "};\n", - "\n", - "mpl.figure.prototype._remove_fig_handler = function (event) {\n", - " var fig = event.data.fig;\n", - " if (event.target !== this) {\n", - " // Ignore bubbled events from children.\n", - " return;\n", - " }\n", - " fig.close_ws(fig, {});\n", - "};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (el) {\n", - " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (el) {\n", - " // this is important to make the div 'focusable\n", - " el.setAttribute('tabindex', 0);\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " } else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", - " var manager = IPython.notebook.keyboard_manager;\n", - " if (!manager) {\n", - " manager = IPython.keyboard_manager;\n", - " }\n", - "\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which === 13) {\n", - " this.canvas_div.blur();\n", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " fig.ondownload(fig, null);\n", - "};\n", - "\n", - "mpl.find_output_cell = function (html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i = 0; i < ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code') {\n", - " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] === html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "};\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel !== null) {\n", - " IPython.notebook.kernel.comm_manager.register_target(\n", - " 'matplotlib',\n", - " mpl.mpl_figure_comm\n", - " );\n", - "}\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "data": { - "text/html": [ - "" - ], + "image/png": "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", "text/plain": [ - "" + "
" ] }, "metadata": {}, @@ -1306,1785 +440,66 @@ "name": "stdout", "output_type": "stream", "text": [ - "\r", - "mPIE: 0%| | 0/100 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "## switch engine if you need\n", + "# switch to mPIE\n", + "mPIE = PtyLab.Engines.mPIE(reconstruction, exampleData, params, monitor)\n", + "mPIE.numIterations = 100\n", + "mPIE.betaProbe = 0.25\n", + "mPIE.betaObject = 0.25\n", + "mPIE.reconstruct()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\r", - "mPIE: 12%|█████████ | 12/100 [00:04<00:27, 3.17it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - " 0%| | 0/100 [00:00 1`) reconstruction\n", + "- How to use spectral density weighting\n", + "- How to interpret multi-wavelength reconstruction results\n", + "\n", + "!!! note \"Dataset\"\n", + " The dataset (`Brain_smoothBeam_poly_bin8.hdf5`, ~500 MB) is downloaded automatically into the `example_data/` folder at the project root the first time you run the notebook. If the file already exists it is not re-downloaded.\n", + "\n", + "!!! tip \"Prerequisites\"\n", + " Complete [01 – CPM Simulation](tutorial_CPM_sim.ipynb) before this tutorial." ] }, { @@ -19,7 +30,6 @@ "outputs": [], "source": [ "# %matplotlib notebook\n", - "%matplotlib qt\n", "import matplotlib\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", @@ -32,16 +42,7 @@ "execution_count": 2, "id": "8b61d2da", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\cupy\\_environment.py:213: UserWarning: CUDA path could not be detected. Set CUDA_PATH environment variable if CuPy fails to load.\n", - " warnings.warn(\n" - ] - } - ], + "outputs": [], "source": [ "# import the fracPy module\n", "import PtyLab\n", @@ -64,19 +65,34 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "f3398ba3", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Brain_smoothBeam_poly_bin8.hdf5 found, skipping download.\n" + ] + } + ], "source": [ - "# Step 1: Download the preprocessed data from surfdrive (https://figshare.com/articles/dataset/Brain_smoothBeam_poly_bin8_hdf5/19107068)\n", + "from PtyLab.io import getExampleDataFolder\n", + "import urllib.request\n", "\n", - "# set your data folder as fileFolder \n", - "fileFolder = Path(r\"D:\\Du\\FigshareData\")\n", - "# select the hdf5 file\n", "fileName = \"Brain_smoothBeam_poly_bin8.hdf5\"\n", - "# create the complete filePath\n", - "filePath = Path.joinpath(fileFolder,fileName)" + "filePath = getExampleDataFolder() / fileName\n", + "\n", + "if not filePath.exists():\n", + " print(f\"Downloading {fileName}...\")\n", + " urllib.request.urlretrieve(\n", + " \"https://ndownloader.figshare.com/files/33950357\",\n", + " filePath,\n", + " )\n", + " print(\"Download complete.\")\n", + "else:\n", + " print(f\"{fileName} found, skipping download.\")" ] }, { @@ -89,65 +105,102 @@ "name": "stdout", "output_type": "stream", "text": [ - "\"Unable to open object (object 'orientation' doesn't exist)\"\n" + "Found encoder with shape (890, 2)\n", + "Min max ptychogram: 0.0, 14378.9013671875\n", + "Min max ptychogram: 0.0, 4.157756328582764\n", + "0.0 4.1577563\n" ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9b5d4961019140069857d2fa8c156236", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(IntSlider(value=0, description='Frame', max=889), Output()))" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "# Step 2: Initialize the ExperimentalData class \n", + "from PtyLab.utils.utils import posit\n", + "# Step 2: Initialize the ExperimentalData class\n", "\n", "# Initialize the ExperimentalData using the filePath, and choose the operation Mode (default is 'CPM')\n", - "experimentalData = ExperimentalData(filePath, operationMode='CPM')\n", + "experimentalData = ExperimentalData(filePath, operationMode=\"CPM\")\n", "backgroundOffset = 10\n", "experimentalData.entrancePupilDiameter = 0.2e-3\n", - "from PtyLab.utils.utils import posit\n", - "experimentalData.ptychogram = posit(experimentalData.ptychogram-backgroundOffset)\n", + "\n", + "experimentalData.ptychogram = posit(experimentalData.ptychogram - backgroundOffset)\n", "# show measured ptychogram in log scale. Need to close the window to continue\n", - "# experimentalData.showPtychogram()" + "experimentalData.showPtychogram()" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 12, "id": "371b80ef", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/mnt/home/shantanu/projects/PtyLab.py/PtyLab/Monitor/Monitor.py:178: UserWarning: For faster update of the reconstruction plot, set `monitor.figureUpdateFrequency = 5` or higher.\n", + " warnings.warn(\n" + ] + } + ], "source": [ "# Set monitor properties\n", "monitor = Monitor()\n", "monitor.figureUpdateFrequency = 1\n", - "monitor.objectPlot = 'angle' # complex abs angle\n", - "monitor.verboseLevel = 'high' # high: plot two figures, low: plot only one figure\n", + "monitor.objectPlot = \"angle\" # complex abs angle\n", + "monitor.verboseLevel = \"low\" # high: plot two figures, low: plot only one figure\n", "monitor.probeZoom = 1 # control probe plot FoV\n", - "monitor.objectZoom = 1 # control object plot FoV\n", + "monitor.objectZoom = 1 # control object plot FoV\n", "monitor.objectPlotContrast = 8\n", "monitor.probePlotContrast = 1" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 13, "id": "7dd91c14", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:GPU:cupy and CUDA available, switching to GPU\n" + ] + } + ], "source": [ "params = Params()\n", - "params.gpuSwitch = True\n", - "params.positionOrder = 'random' # 'sequential' or 'random'\n", - "params.propagatorType = 'Fraunhofer' # Fraunhofer Fresnel ASP scaledASP polychromeASP scaledPolychromeASP\n", + "params.gpuSwitch = True # This can be manually set to False if you want to run on CPU, but if GPU is available, it will be used by default\n", + "params.positionOrder = \"random\" # 'sequential' or 'random'\n", + "params.propagatorType = (\n", + " \"Fraunhofer\" # Fraunhofer Fresnel ASP scaledASP polychromeASP scaledPolychromeASP\n", + ")\n", "params.probePowerCorrectionSwitch = False\n", "params.modulusEnforcedProbeSwitch = True\n", "params.comStabilizationSwitch = True\n", "params.orthogonalizationSwitch = True\n", "params.orthogonalizationFrequency = 5\n", - "params.intensityConstraint = 'standard' # standard fluctuation exponential poission\n", - "params.couplingObjectSwitch = True\n", - "params.couplingObjectAleph = 0.5" + "params.intensityConstraint = \"standard\" # standard fluctuation exponential poission\n", + "params.couplingSwitch = True\n", + "params.couplingAleph = 0.5" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 14, "id": "309376a0", "metadata": {}, "outputs": [ @@ -155,12 +208,24 @@ "name": "stderr", "output_type": "stream", "text": [ - "Copying attribute wavelength\n", - "Copying attribute dxd\n", - "Copying attribute theta\n", - "Copying attribute spectralDensity\n", - "Copying attribute entrancePupilDiameter\n" + "INFO:Reconstruction:Copying attribute wavelength\n", + "INFO:Reconstruction:Copying attribute dxd\n", + "INFO:Reconstruction:Copying attribute theta\n", + "INFO:Reconstruction:Copying attribute spectralDensity\n", + "INFO:Reconstruction:Copying attribute entrancePupilDiameter\n", + "INFO:Reconstruction:Initial object set to ones\n", + "INFO:Reconstruction:Initial probe set to circ\n" ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfUAAAG2CAYAAABmhB/TAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAj6RJREFUeJzs/XmcHFW5+I+/q3qd6dn3JZNlkpCNLBAgBlQQwo2oeFFRRAUui/ejF7xq9F4IYgAXAirI/SnKV69eRUVwA1Q2NRIXQJAlkASyb5PZ1+6Znt6rfn+cql4mM9lm7Z7n/Xqd10xXneo6fZ6qeup5znOeo5mmaSIIgiAIQtajT3YDBEEQBEEYG0SpC4IgCEKOIEpdEARBEHIEUeqCIAiCkCOIUhcEQRCEHEGUuiAIgiDkCKLUBUEQBCFHEKUuCIIgCDmCKHVBEARByBFEqQuCIAhCjjAllPp9993H7Nmz8Xq9rFq1ihdffPGo9X/5y1+ycOFCvF4vS5cu5YknnpiglgqCIAjC1GXSlfrDDz/MunXruPXWW3nllVdYvnw5a9eupaOjY9j6zz33HJdffjnXXnstr776KpdccgmXXHIJ27Ztm+CWC4IgCMLUQpvsBV1WrVrFmWeeybe//W0ADMOgoaGBT33qU9x0001H1L/ssssIBoP8/ve/T257y1vewooVK7j//vsnrN2CIAiCMBKLFi1ix44dw+771re+xQ033DAu53WOy7ceJ9FolJdffpn169cnt+m6zpo1a3j++eeHPeb5559n3bp1GdvWrl3Lo48+Omz9SCRCJBJJfjYMg56eHsrLy9E0bfQ/QhAEQZhQTNOkv7+furo6dP3oDudwOEw0Gh2Tcw7VGR6PB4/HM2z9X//61yxZsoRNmzaxePFiIpEIjY2NPPzww1x88cWjbs9ITKpS7+rqIpFIUF1dnbG9urp6xDectra2Yeu3tbUNW3/jxo3cfvvtY9NgQRAEYcrQ1NTEjBkzRtwfDoeZk+ejDWPU5yooKGBgYCBj26233sptt902bP329nacTifnnHMOHo+Hl19+GcMweNvb3jbii8BYMKlKfSJYv359hmXv9/uZOXPmJLZIEARBGAsKCwuPuj8ajdKGQROVFHHyntkAJg0DnTQ1NVFUVJTcfjTlvHXrVk455ZRknddee42qqqojjNKxZlKVekVFBQ6Hg/b29ozt7e3t1NTUDHtMTU3NCdU/mntEEARByF6Odwi1CA9Fo4oLV5Z+UVFRhlI/Gq+//jpLly5Nfn7ttdcyPo8Xkxr97na7WblyJZs2bUpuMwyDTZs2sXr16mGPWb16dUZ9gD/+8Y8j1hcEQRCmO+4xKCfG66+/zrJly5KfX3vttYzP48WkT2lbt24d3//+9/nxj3/Mm2++ySc/+UmCwSBXX301AFdeeWVGIN2nP/1pnnrqKe6++2527NjBbbfdxksvvTRukYSCIAhCtuNidArddUJnMwyD7du3ZyjxvXv3Mnv27FH+jmMz6WPql112GZ2dnWzYsIG2tjZWrFjBU089lRx3OHToUEZ049lnn82DDz7ILbfcws0338z8+fN59NFHOfXUUyfrJwiCIAhCkr179zI4OJih1JcuXcqtt97KypUrOeecc8bt3JM+T32iCQQCFBcXT3YzBEEQhFHi9/uPOsZtP+/9LKUIx0mfJ0CCYrYe83xTgUm31AVBEARhfHHBKJT6FBipPm6yp6WCIAiCIBwVsdQFQRCEHMfF6NRdfKwaMu6IUhcEQRByHDejU3fZ49TOnpYKgiAIgnBUxFIXBEEQcpzpY6mLUhcEQRByHBcnmkAmk+xZ0TN7Xj8EQRAEQTgqYqkLgiAIOc6Jp3rNJHssdVHqgiAIQo4jSl0QBEEQcgR7QZfcR8bUBUEQBCFHEEtdEARByHFObk30bESUuiAIgpDjTB+lLu53QRAEQcgRxFIXBEEQcpzRBsqZY9WQcUeUuiAIgpDjjDajnDFWDRl3xP0uCIIgCDmCWOqCIAhCjjPaQDlxvwuCIAjCFGG0Y+rifhcEQRAEYYIRS10QBEHIcUbrfs8eS12UuiAIgpDjiFIXBEEQhBxhtGPqibFqyLgjY+qCIAiCkCOIpS4IgiDkOKN1v2ePpS5KXRAEQchxpo9SF/e7IAiCIOQIYqkLgiAIOc5oA+XiY9WQcUeUuiAIgpDjjNb9LkpdmGTcXsjzgYYqNnYG41gMgoFJaJgw5mgaFJWl5Gz/NdP+BnrAzJ701cJR8BWBy1pwbOi9bQKhAYhGJqFhwpRAlHoOkVcA77wUvBqseju850PgiYMjAZoJaBDXIe6AHbvhZ9+CMPDKC7DvjcluvXCivP09UFsJpYXwmTvAa4ArAbr1dDd0iDkgrME3b4a+AWjpgL89PtktF06UuafCaWeCF7ji03DKXCVrhwGYYGrqvo464bc/h38+C2ETnvwFhAcnu/VTgdEuvTqaYycWzTSn1/t7IBCguLh4spsxZrg9UD8bbvoa1Hng7avA4wdnAPQBYBCIkkqI5Aa8YBZCohAiRfBmE2w/DL/+Bfz5URgMTtKPEY6KrkN+gVLgi2fAW8+ACg1c/aAHQAui3tLsQF0HStY+MIogVgidBjz7Mmw/BP9zCwQHwMyeZFnTivwCWPM+eP+lsKQBFs5Q97ZjALR+lKyjVmUddW/7wCiAWBFEi+Av/4DWKGz8PLQcyj0L3u/3U1RUNOJ++3nv51cU4Tvp8wQIUsylxzzfVECUehZz/nvgw5fD+9dASR9oh4FW0DqBbqAfCKJu/ATqxncBeUAhUAJUglkNNECoErb2wl1fgU1PQL9/En6UMCwLlsGaC+Hm9VARBGcz0AJaO9AD9KJe4MKkhv8cKFn7ULIuA7MGqIX4DOjywVe+DJs2wa6tE/6ThBEoKoHzL4KbN8DiYsjrAA5bsu4A/ECAlFI3UbK2lDqFQDmYlUAdmDOgrxh+9Qd4+CF4Joc8NaLUj0SUehYydwl8bgO8761Q2Qf6XmAf0AS0AJ2oB32/lmmpayil7gUKTSgGKoEaoAGYBeY8CM+CJ16GnzwMv/uJWHKTicsNN98L7z4blheDax9K1gdRsm5DydqvqRe4dEvdCXiwlLoJpShZ1wGzwWyEeCNs6YHfPwt3rlOxFsLkoOvw3qvgYx+Ci04H7wHQ9gIHgMMoWXeilHq/pmQdQyl121LPR93bZah7ux6YATSCMRc6iuHRZ+Hrt8L+HRP9C8ee41fqvx0Dpf7erFDqMqaeRRSXw6q3wd1fg0U6aP8E7U1gN7AfdeN3eyDghUQxUAhmPupu11F3fwwIK/+d5gffIJRGoM6AWaDNg7yF8P7FcP7dcHMp/OlPsHfbZP3q6cs5a+Hqq+Bj54FrB2h/B3aRUuqdLuj1QLQAKLZk7UWZbaC0exi0QcAPngEoCUNlXMm6EVwL4IzFsOwD0FAKP3oAnvvDJPzYac68ZfAva+ArN0PxAdCeBnai7u2DQIsOfR4I5oNZrMbP8KLe0jWUrGPWGEw/OPxQFIGKiFLsjaDPh+qF8O8r4ZxH4fM3wQt/VUGUuc9oo9+z521XLPUswemCe34GV66FwjdBex14HdgB7NGgwwehcjBrUa/o5Sg/nI8jlXoI5ZvvQ/nz2sHTCSV+mJOABcAS4DSILIFne+D/fQj2SjDdhKBp8L6r4Zt3Q10HOF4FtgJvoJR6swf6yyBRhTK9y1D+dR/qQW+/q8dR5lwQJeseoA0cHVDYDfVROAUl62WQWA6HK+Ezn4XfPiDR8hPF/KVw/8NwdjF4tgNbgO2oe/uAQ/nOI7ZLrRIl6yKGVeoEUb75HqATtFbI64bqIMw1YRGwFMzl0L8I/u/38F9XQTx7dFYGx2+pb6KIgpM+T4ABirlALPXj5b777uPrX/86bW1tLF++nG9961ucddZZw9b9/ve/zwMPPMC2bcp0XLlyJXfccceI9XOB0gq44ztw9dvB9TxoL6Ju/G0aNPkgPAPMOSg/Wz3qxi8jU6k7UD54y1IngPLjWUo90gTtB6H7ADT1weEEtIO7A85bBb/8HXz4X2GXWOzjiqbBVZ+Cr90G5TtBexl4CaXU93qgr8qS9SyUH304pT7EUk8q9W6gDRIt0HcQ/AegtQOaItACjk6YeQZ8/5tQ5IOffJfUvDhhXFiwDH7xGCxJgPYM8KpVdjqgvQTis1GybiBTqadb6jpK1lGUrPtRsu4EswUGm+DAAWg7DE1BaDHR2qGwFz5xPrgegFuuh75pYbHnPpOu1B9++GHWrVvH/fffz6pVq7j33ntZu3YtO3fupKqq6oj6mzdv5vLLL+fss8/G6/Vy11138S//8i9s376d+vr6SfgF44vLpRT6v50H7ueBF62yTYf2ajDmA/OBRtSNX4dpKfUEPmI4iePAQEPDxImBkwQuQiil3olGG2pAvgHi1dC8C/qboD+CNghaHJatgh/8HK65HHaLYh8fNPjA1fC1DVCxE3gWpdBf0eBAIUTnoUzrRmylblpK3aSYGC5iODCs7M86Bi4SuIih4Qd6LFm3ADPBrIOeXRDcC/39MGiihaHChG/cDgNBeOTHk9ER04MFy+AHD8KSCOgvAM8DrwA7vBBoQMl6HjAbmGHJuhIoJkYeMRwk0DHR0K17200MnSBK1p1AM3AYzHoI7YbduyHQDv0GWgQ8Ubj2AuA++MyV2WuxH5vRut9Hc+zEMunu91WrVnHmmWfy7W9/GwDDMGhoaOBTn/oUN9100zGPTyQSlJaW8u1vf5srr7zymPWzyf1eXA5f/i78+9vB/QLwFyyF7oW+2cCpKH+aUuoG9USpoB8vvegMAEG0I+Lk8jBRo7AmpcRw04eDFjQOogbxdgLbwLsT5gZglQmrwTgPXnXCZe+BfdsnujdyG02Hj94AX78NqraD9hzwd+BVB7TWQmIRyk++AJiDySxiVBGikF50/GgMomUEvztRtlw+piVrgzz6cdFhyXofStZvgOMNqGuF0wx4K5hnQ/ti+NwX4aHviCt+rJm3FB76HayIgr4Z+AfwDw32FUPYHv9aCMzDZBYJ6ohSQi8u/GioGW3aEXFyPkxrYotBIWHcdKHTjJL1buBNYCuUHISlYVgFvB0iZ8H9z8Ct12fXGPvxu99fGAP3+ypxvx+LaDTKyy+/zPr165PbdF1nzZo1PP/888f1HYODg8RiMcrKyobdH4lEiERSkzMDgexJo7bq7WoM3fU88E+UQt/qBf8pwHJgKbAIk/lEqaebPFrROfaMNs268TUq8VBDFZUUU0AVUIpGMZAPYTfsfgO0HnCAXgDLz4Hr/ws+928T3Ru5jccDt34Rqpqs4ZUXgZcd0FYPxgqUrJdgsgCDWfRSRAdO2lCy7kNNdAiRGfzuBXxolKBRhk4NpVRTSAkV6FRYsi6AhBeat4DRAu4EmguqiuDWDfDr/829+c2TzQ03wjIN9JdIed/2lEJ0CbACJeuFwFwGKKcDD+2W7d2HurdDqME0g/QZbZo1o81BJT5qyaOcctyUo1FK0m3f54bXdwER8Kp8F1e/G373M/jz7ye2L4SxZVKVeldXF4lEgurq6ozt1dXV7NhxfPMtbrzxRurq6lizZs2w+zdu3Mjtt98+6rZONHOXwN13WUFxLwIvoCx0/ynAWSilvowEp9BDOU04aEKjGehCPegDpGa0pSt1LyrMpgR7RptGA14aqKWaAjy2UscDURfsfhWcfeADhxeuuABe+QQ8+D2Z7jYWFJXBnd+GWd1qRgMvAi/p0NYAxmnAGcBSTBYzQB3NeDhkybqdlFI/2oy2UtTIu5rR5mQWZdTjw0cxGgVAHhhOaH0FXmoCp4FeBHPeCnf/L3zhPyHQO4GdkqPoOnzsk/DRc8Fhy/qfwO5SiK4ATkMp9VOJMod2CjiEThNK1kOnqR+p1JPT1FHT1HUa8DGTuZRSjINCVPICj5oGuXUX5IXRPFBYAt/8BlyyJzemu2Uy2gVdsiej3KSPqY+GO++8k4ceeojNmzfj9XqHrbN+/XrWrVuX/BwIBGhoaJioJp40n9tgTVt7HSsoTrdc7suTJcESWilhDxr7UDPamklNU7eVeoSU+91KKEcRapp6FaRZezohipjFQjw4rbzSCYgMwu6tUDqIVgIV9fClL8Ovfwzh0MT0Ry7ztjVwxUXg/DNK1q9r0FwBxlLUA345Jkvpo5a9ONmHmrqcPk29j5RSH+p+t3PPlKMUg7L2NPrxMJdZlOBGQ1dHGjE4PAivd0GliasUrroYfv8bePqRieiN3MabB7d/Ccr3AK+h5L3HB5EF2Pe1yQoizOUAHvZYAyVNpKap9wHpCeXSc8/ko+5tW6mrZ4FGP07mUk0tHhzJmTAR8Edg224oMtBqYMn58Nkvwn9+dMK6ZIKYPmPqk6rUKyoqcDgctLe3Z2xvb2+npqbmqMd+4xvf4M477+RPf/oTy5YtG7Gex+PB4/GMSXsnivPfoxLLaC+ipq1t01RQHEuBZSgLfQmHKGEHWnKaenrumV4Ngg6Iu8G0A2StGW2OGOTHodBI5Z7pw34J0IjiZR7z8GJYo3ZBCA7C9jegNAEzYEY53HQX3PafE9w5OUaeD277MuTvRUW4vw7sK4C4NfeIpRicSi/1vImeMU3dVuq9QMDK+214UE94E0iAHgV3HIoSylrvQHly/Kh4iwhOFlJPGaYl6wjEA7DvFagcgArwzYIvfRU2PwUReYkbFTd/Der6UHJ+HXjDAcG52LI2WUaIeezBkzFN3bbUO4GADiEnJOx05hpggBYFZwx8CSg11b3djbo+BoAQGnFKaGAJDgwgDGYY2vywtR1qTbQquPQ8+PU74S9PTWjXCGPEpCp1t9vNypUr2bRpE5dccgmgAuU2bdrEDTfcMOJxX/va1/jqV7/K008/zRlnnDFBrZ0Y3B6V+rWyD7QdqLiWJp8V5b4IWEiCU2i1FPqbwB5SCeVaNRjwQryIEWe0GSHw90MgAH1B6DXUTT9IeoIqD/NoxIOVuIQ+6O6Ane3QCM6Z8K5z4GenSjT8aLjoUlicZ7nd3wR26xCZjQqSWoTJIvzUsQudHaiwtnSl3uOGqA/ldhlmmroRhngQBv3QOwB9MSXNEOnDMjqLqKWYhWgMAN0Q7oFdb0CtgTYPlrwN3vl+eOxnE9c3ucYpy+Cdq8G5B5LC7K7EljUsIkoj+3Gzw6qyB+WVaQK6HDCYD6Z9b+eRodSJQGIQIta93ROGgKms+gi2B0fDRQk1nIKDfiAARgc09cOOINoMqJoPH/4oPPdniEXJEcRSnzDWrVvHVVddxRlnnMFZZ53FvffeSzAY5OqrrwbgyiuvpL6+no0bNwJw1113sWHDBh588EFmz55NW1sbAAUFBRQUnHx041ShfrbK5a6/gHpN36upeejMR0XCzqeHcvZYFvoeq9o+oNUB4TKgglTuGWtoPKnUoyi/XT+YfTDQCeFuiIRTa0M4AA8aPnzMYA4OutDogkQTNAVgdwhtDixbCOddAHvekLH1k8FXBFd8BLzNkBRmdxlK1vMxmU+YGRzAwW6rii3rJg36C8GwUxKUcMzcM5EeaO+AwQGImak4CzeQh5MFNODFj2bbhN2tsKcbdkPeXPjoR+BPv4Vg/8T0Ty6h63D+Gji13JrZsBs4nAeJOdiyTjCHFnzstu5t+5I4CHR5IW771EvIVOr2NPUI6s28H+Jd0Gu9m4UTmXEWeWh4qKCceWj0AK0Qaoc9u2CWib4XPnAh3DkLDu6esC4aZ2RMfcK47LLL6OzsZMOGDbS1tbFixQqeeuqpZPDcoUOH0HU9Wf+73/0u0WiUSy+9NON7br31Vm677baJbPq4cNPXVGI37BzfHT4r2Ugj0EiUeppwsA/lcrerHXZCrBqVj8ROKFeEUuq2pW6SUuoBlM+9AOL50N6s3vIzx+Y0iqiglEaU868RBpphfxPsA9dhWH8bPPhDedCfDBdeAhecBTyJpaldEK0HlLwNZtFOPvusmAlb5gc1lVCOOqAaJesSjp1QrhiMPPC3wIFewEwFThagUUo+M5iFgxagFaJ71Uvc/hjsh7XvhPPfqyKkhROjoAhu3ACubaQE2V+Juq/nAHPwU87+NFnb1brywahHyboK5ZWxE8q5SSWUS889Y1nzITc0tQNx+2UdCoAiHBRSj4dGoAnMZuhohn0DsA/KFqrhtU++f2L6Rxg7Jl2pA9xwww0juts3b96c8fnAgQPj36BJIq9ALZ+qHSYV9RYqR2WKa8Cwpq01odEEydLqsBR6AyeWUM5OSuUGw4TuZvCE1CGpYBudImpx0qBOYNRDSzMcNtCaoHQ2lFWKUj9RNB1qy8DbCVoTSt49PrD62aSBIKVHyPowMFCKnWcoM6FcPsp6S08oF0JZb7bXxqX2D5hwuNda/wM13l6FRillFNKAZsu75yA0+dGaVLbR2jKV9U7mrZ8YZZVQNpgm6xaHSghj9XOCWlrQOUymrLvyLIXeQEqpl5Bx7w6r1NOWAYgBrW3gSaRkXY5GNfnUUI9OAzADBsvg8IBaEe4w1HpVzEcoB5ZiNnFijkLdjebYiSZ7WjoNeOelaj10Hkcp9G6Plcu9HqgjSiUtViqJFqu0apbLvS5ZLaXUj2apF6C0t/WQJw6JGHQ2Q2Hcfsir6W51FFJGnfXldTBQDM290AKFQVh/D/zHJRPRQ7lDUQn81+3geJ2UMBNVpAuyA1dyl2U74/dZy6fa4jje1O/2MIzl9DJj4I9CS1AdWgHUArW4KEyXdbwKWvwqjWw73Phl+PkDsizvifKFe8E3gBJiMxAsgrR+DlBIizVN0ZZ3pwuM6rRqJ6LUPaQ8xgkIRaCtG4rNVGR8PTrlVOKxrzmzFrrboVmlDX7Hu9R67r/76Xj3zvhjWLk0R3N8tpA9LZ0GeDXw+K310DtRq61RCVRiUkk/HjpR0ct2lQEv6olcaf21y9D1XIYqdY+13URZ8JZFF+mHrp7U93cCvTgppgyH1RYihdDVq9aL6IQisdpOGA21iJZmC7NbBzMlyAiFdFnJRuzS4wDDXlKzkpTMj+V+ty10e+w1BgyC0a+CqToTqXN0oVFPIV77BGYFdO+BThOtCwojWFMdhROhyEyTdRcQKcIWYpwyenEecW9HCsmUtV1KGFmp2xa6PWJpe+b6oT8IXSEyztOPFzeVaPZDJOCBzghaJ7gD6pmUC0wnpa4fu4owEbi9KoOc016LoQdr+dRylClWRi86PWm7ezUryr38OEvZCH/TilkKAZc6R3fauWJJh3yZVcmZ3Dm3AWYtGOcOyjFWrQFflFQnh/JIF0gQb4YMuoFQPpmyLBvy/9DPI8g4fXsoj+Q1ZZdBvJkVQ/nJnYVxOGv4PE/CCMxeBI31pDo44AIzJaQ4RUfcb/12leHkNpKsj1HiheqZkX6eXvQhlYqTF4SrH95yLriya0bwtEeU+hQhvwDe8yHQ+1Hus37NWjO5ECgigY8Ba1fAKkGHtVtVSf0tGrJtuDqFI5eo22pCWonisbJKWycIuaBfLcu+cAEsWz3OHZRjvO9qcEVICTSehy0YgwIGrQlH6cWw04Wly3loGSrPkWRtbTd86vTp5wnhxKAgVTmWl2ynKwLv+7dx7Zqc47RzYP5cda8QQE0yt4RgUkgET7Lv7Xs76mFkuQ2V9THu5/R6QUfqPP2oqaxGMrKiEChIXgj6AFx8GeTlj2v3TAi2pT6aki1kT0tzHA3wxFFBTUHrL/kon6qPGC6CaMldg6jEMvisavkj/D/U/W6Poae5YdNOAz4wvDA4CEFTNSUIhNApTH55PoQdyZ2OcDZN+JgaeAAtXdZxD7YgDLwMWrK2S8TBEXJKF0dyW/rKq3FSSYfsYZdhjo/oEDRIO5+GgRfdrhh3p3YOqrYLx48TdY8kZR1xkC6AUJqsB4GQpu7BI2Q79P4e6n63b0Irr8wR93Y+xFwQjKceM2rBJxd5diXTB4Na8ub32OkJs5w4OvFR2LCjOXaiEaU+hXDY42J2SSZMcBFHz9gVxcoU5yY1Pn60Yke/Y/09Rv2YBlEzda4Y6e3xQFxP7tTj4vI5UZy2orWL4cTuXwNnRr9HgYSDTBm5yBBHxnb7rrZf5OIML2fruIQTotEhzSHVHgxncocWBYfEUJwQOuoeSXZu3M4OoErMWkkxKXON4WU7UrGVOqgL5ih1TRdEQ5myTpDeHlfGTochMRTZhij1KYRmB60lrL/oqCezWg89Ye2yS9ruYxedVOap4zguvRnqfFrml6W1VZMb/4TRIbOTTVsoOiZ6Rt8bgKkxstz0tGJvg9SanMMdl7bd1FLnsc+ZquRQbTNSFeQF7sTQILNzjUxhDu37jFv/aDJPv6/tY0aSd9pxQ58jxtAD0mWdIy9wSTtpFMdnC6LUpxLpN6cG6qmstKeGmXHPJnfbN6CZ9ne4/7W0z+YI9dI+a2nnST030iumdppacotwnCT7S0vfoootay2tDCu7kcrR5D2C/NPPp5R22oWhmWkNEVmfFBojCNQ4Ytew8h56nw65FY+6f8i+9GeI+jvkQZIu6xx5W7c9XqM5PlsQpT6FSNheMHuhhuSlGMOJkdycTHgYS6sSHeH/9HE28yj1hnx2mWSczzX0YKeR3Gk6U5594fhIpLtY3YCeAEP1r0ZiSN8rN+gRskqXmV10Mqe0DVd/yLGOxFBZY/kKrBNqiYwLL5EjD/qJwsAaXbFvXIcB8ZQA3JgZ97XTWnhpuPsy47PtkbHd7+nXwQjHavHMZ4gKsTEyD0wb2kmIWybrEKU+RTCBqAMV/JJn/SWcLE4SeDHJQ8Nr7XbE1OIsyWpD/08PirPHV2PD1AsP+RwBj5nZFC9m5gFuI1kh4U4N6QnHRxRICtILOKJq9RVC6ESSss5DycAZR3X9UHnZIrETy5iou9papW3YukO+w5VIyVn9NdGJpCo6osmdpje7rJapQBww3KQ62Z1Qiy1YAvBYu+zdHpNjyiw9sUxyWC3K8Pd0WtGjmZedFxMX8bSDIhkVYo7c8MyI+12YcGJR2LkbZhWCVggUmmoOjKkmubgIUUhhxqyW/LhabS1jjkqAI7JJjZj7PX0uU9pnd/jIGXBeYmRMfMqLQ5GaddfVD20t49xBOcYb2yCxFJy2MF0hiCkB6ATxYVCII2NG0kBQJYzJkFs+Vng1qTTAtgWXQD2r7SxjQ+euBdS0JXvymi1vH4YVj23PYwslLzojX7VdOH5am6E7CAWFoBWh7p3+lEC8xJKytmXgjkB0qLzyycgKSIzMpEJRMmUdOPL//MSRM+KchFIVtX717ClU9/aOXRDPgbe46aTUxbkyRQgG4GffgkQhKmNUMaBZS57iB/wUY1KStrvQAC1gVenLqJq5baQyXD0/5MdInscuToJo6RV9sWRDXnoJXvjD6PtgOvGjjTDoINXBrkFsgWj0kU/0SBnYC7Okl+HkfbzXgF+dduh58olkytodSsp6wAE/unPUP39a8fyTsOVVUjeuL4YtAI0+XAxk3NclQH6U1KJLfRxd1n3HV7QAFBmZsi7GyPwSzZ/cGS+An/yPWtVPyB7EUp9ChIFIMTjtdJC+QejvBDqATkqZRSUeKlEpoCtR66EPdKLMLS/qzT3d9TqINWZLpvu9H3UfdyS/HjrB1QcVZiojZRVQjoGTHqtSB7j9yUpmpeQBPxkMoN8LRXZHlyXAn0oKm0+QSrxUoiVl3RWHji4rJ5Ftoeukxs6Plvu9D5IitMSodUFJTMnYPkclJvkEUxW1LiiLJy+Gfm9uuGMnmoBO6oaqMOFwH8TUjeekl3LKqEJPyqLThGCvVSWfVOpX29sWITVPHVLu9yDqZSBd1lbxBTOzzao08vHMSgWh5M5osbp8cgEJlBMmhVdehDebYGU1aDVASQT624B2NNpx00c1VVSjUY1ay6PXUOuhx/PJnI9uJ7JJ357ufk9X6u1W6YCSMMnvrgGqMSkiZK2xrdqC168qVauXkF8/ODH9k0uEBuHRx+CTK0GvBqpNONgBhi3vDioppQZHUh7dpvLaDraTSjKjoZ44EY5PqafJOi+QFGPyHJUYaidtqmgdyZ1GJTz6CIRD4949OcevfgYfugu8dmfn+SGm7imNdoqpo5r85L3dBfSFoauD1LrpoO5te910e/twC7rYSt26ZZ09UGGk5KyaYeKmN+3eboPSCFSDWQXbD8JrL01E74w/08n9Lkp9CrFvO2xvgpWzsZbWNKCjEyJNwCEczKGKYhrw0oN6Tg+gYm7am60IdNtCD3Ls9dT9pJR6ExT57UVeU6UeEw8dJBeE1A5DdVTtnAk9efD3Jyegc3KMaBg2/xmueSfkNaA6fkcA+qx+poliammglA6UrANAKAFNHSoLXDLi2X6QH0upd6Oe3a3g6VCXV7qsZwBFBCB9sdfiQPKiCFfCM5tU/IdwYvz1Cej9FtTanV0Vhf7DYKp+9lBPPbPoRFPp4VFii/oh0MSRL+SFHH2Vtm6UUm8BvQUqw5mybgCqiOCgBTgEHAZPZ/KiMBtg2x7Y/+YEddA4Y8f2j+b4bEGU+hTj17+AD34d8mcBs4ADfmg/CDSgcZACqphJLX50AqgX9iiQGITuw5BIv7FV1NOxlXqHUugzTXXK2dapZ2FSwQBwMFU87clKiRnwm8chEpmYvsk1XnsFtrXBGbNAmwXURCBwGIwDaNTjYgZ1FNCFkwCaeoEDEnFoboNo2gpc+MlME6sxolJ390Bd3JZxStb1xHDRjGbLWj8MNVGYDeYseO0wvL5lAjsohwiH4ZEn4P+dCY5ZwEygqQ0i9r1VRwUVzKaAXkvWISBuwqFeCNipX0MoWaro1WMqdUcHlIdScp5t/Z2JgY+ulKw5CCWBZMVQBfxm48T0jTC2iFKfYvz5Udh2M5w5D7T5wKEEdB+AeDVqne0yqikgRBGDaMRQutoBeEJqPfRIP5i9HKnU7ehoe0zdr8bQS8LKGJsFzLPKfEwaiOLiEBp7gD2g7YXaAZgH5jxoz4df/1wst5NlzzZ46m9w2kXgnA/MNaGtA/r2AFVoVFNIMY3UEbZSidoJAV1xaOuEgUEwerECsBjZUveD3geFQag2lKznYssaGjEooN2S9W5gDxR3qDbNg/hsePIx5U0STpxoGH71ELzvPKiZD9p+YN8AHNwLZgMaFbipoIF5DOAmamWQ1FDz1g/3gT9sTZAoRt3btvvd9trYbvl+0HrBE4CquLq3G1FyVve3STX9wF6w723XAWhMwHx1b7/eDc88NoEdNM7ImLowaQwG4c6vwM/uhbwFwGGgqQ+adwE1aBThoYhZLCRqzR53oGa6+FBLY3b1QKBfrbZm2G/z6ZZ6RE1by4+pmJ1qlOFgK/UFwDwMCmlBYyewA9gJhS0wz4AFYJ4Cjz8Lf31qQrsn5/j6zXDdh6F2AbALaInC63sgUQ5UolNADfkkKCOOesi7Ubq70IC2fvAHIdQFCQ/DKnVHBPIiUGKo8dQ6lKwbUbJeAFTTh84uYKcqjr0wJwYLVYWOQrj7lonrl1xk8+Pw1Atw1QLQDgJ7Dehugf6dQCkaZRSSz3xmErfmJdqpK3xAexi62mGw11rFzc4Ln2ap62E1Ha7Iim2sQ7naG0nd27MI42Yf6r627u1qf/JiCM+Cjf+h4j5yhfQ8XCd7fLYgSn0KsukJeOIKeP8S0NqAwwnob4LAduwllzw4mcs8dDx40MhHeeRKUUNp3THoj6nV1mJaKnOoy1TJLeyZc5WoB30DtlI3mY9BKS1obAe2AdvBtRPmRmAJcCp0lsOdGya4Y3KQwSB86Q6493PgORVrOKQHWt4AswTw4sBLPUswKcZlJaQpQC2jXQH0GNAbgsEQRDQrtTgqb7fHVGEVpVb9dKU+F5iPQT1+HOxAyXobaG9AbY+S9RKIzIfbvywBcmPBHbfAezZD5RKU17srDNt2qvljFKLhpgQni6jDiY4HjQKUcV6Biorvi0B/RMk6pqVS/LtMyLfubfVKqHx7KUvdZA4RPOwBtqdK8WFYmIAlYCyG370Am/840T0jjBWi1Kcg/X74ycNwwd1QsgIVyNYfgdd3QFjlcNQwycNgHo348FGERjnWdBjUkFo/agXFqKle5HXU26oX9QJQwlClrlzuykLfBrwGbAHHVmjohdOA0yC6GB7+MzTtn8BOyVEMA/78J3jpGjh7uXKb0pWAcBN0v4adWcaBwQwWkkcZRTgoRcm6DSXrPqwlWk01Dot1pG3llZCp1GcDs0hQQTc6O4DXgS3Aa1B+GJYm4DQwl8OLXfDMn8GUuWyj5tA++MVm+Phbwd2KFdvSA4e2QSIP0NGBUuIsoo4C3JRY93YN6t7usw4LmxAz1Qu7A2W0+xheqc/BpJYgbvaisRUl6y3g3QkLI7ACWAF9DfDTe2Agx6apiqUuTDq/+wncXAbf/Dy4O+21twOw+w2IulDrpsXwMMgM5lBEBZXo1KBlKnVIjsVqqAs7j6GWukm9FRSnxtB3oqy2LaC/BrVtsMKA08FYAY+8BBuuz41MU1OB3Vvhmg/BXzdB1emgdQPhGLyyx5rgrOatOQhTwXx81FKGmxo02lCzl3pRw6lhlNcdRlbqtZjUEiGPNsvl/gZKqb8KRXthaQxWgnk6tFXDNefD3p0T2CE5TCwKt3wSqn8C718Bej/QZ0CsFVpes6awGGhEKGSQ+cykBB+VaLRb93Yf6t4OQTKmxl42YqhSr8OkjgRFdONkP/AmStavgXs7zAvA6UrWkSVw0+3w+M8mtk8mAhlTFyYd04A//Qmeuw7OXaUWYiBigtYDu1+FyCB2BJSDLkpppIha6iik10oVk67UR7LUKzAoJISHdkgGxVmuWMc2pdDPMmA18BZonwU/+QYE+ia4Q3Kcfbvhob/Bv/8L5A1g5RoIwbYd0JfKKqLTQz6NNDKTaorpw0OPlf9tEPWgt/PwO1AvcCn3u0kJEfLpQ+MQGvtQA/nbga1Qsg+WRuEtwFsgvBx+/iQc2DOhXZHz+HvhJ7+Ct94LNXbadQx48SC0RSARAgJo9OKikzpmUU4VAfLoQk8q9TBK2YxkqZcSp5B+a9raflQA5JvAVmWhz++Ds4DVYK6CZ7thk3hksh5R6lOYPVvh/30Ifvk7WLpKLcaAA3D2we5tEBxEpRXtAjpwMoMy6immlHqKiOIhhG6t+2Vb6iZeTLzEcBLEmUw+0QQcQEXD7lRj6A29ykJfDeZboHM2/NdN8ORPJ6U7cppEHG77JLjug+vertbLIQG4IrBtL3QNWusA9Fg2WyuF1OGjimqKiJJPGAcRIG6tm+nERMXOJXATxEk/Ou1AC2pAdx+wE7QdUNGiLPQzgNUQOQ3+9wn40g2QkNV6xpzf/xj+2wd33w4Vb7FXOjXgtTY4FIW4yg6l7u1WvDTgoZpSSolTQBgnYTRi1sKpDtS9nYeBmwguAjjoQcm6CSXr3cAO8O2D+YNKoZ8FxirYYqpnTa7MSx9KlNEpO3G/C2PGnu1w2XvhBz+H1eeBruLkoDQI29+A7g5I2Aq5AajDQSUOyvFQSCE+Usu1ZeaJVfadnXaqCTiopq0VtqiguNOA04G3QMds+MRn4DFR6OOGvwc+cyVoD8A1F4LHjXKpFEfh9YPQ0gfhZpRCngXUoVODmzJclOJL5hNNX9FFzWnTkinl2kgp9b3gbYJ6PyxFKfQzIHImfP9JWPdv6mVDGHtME356n8qr/t27oTIf5VYpMWBLF+zth/5WMA+hIiBmoFGDi0qclODNmNOWPlF9EC0jT2wzagrNPnDsh4pOWGyoMfSzwDgTng3CNZfDvhxV6CBKXZhi7NqmbroHfwfL3wqOfNBKgNIE7GyHpgAMNINRjwqDqgTK0CgiNVE9PXH0MHlitcMqsUztgJq2diqwQo2ht8+Cz98oCn0iiMfg5uvB+A5cfQHk+UArQPnP3/DD/h3Q0wrxAyhZ16BkXcLx5YltVcXZDGV90BiHxcAyNa46uAh+8BTc+ilR6BPBIw9AfgHc9VWodoJeiBXqHoHdB6GtGyKHwKzHTuSrZD1UqQ9N/t6NSjbbrFLKFXbCjLCaorgUzNMgfhpsicG1l8PeNyb8pwvjhCj1LGH3NvjwxfAfn4crLoCKOlJzVXaHYH8TtDTDQDFECsEsJZUnNn2x7SFK3e23crlHMyeqn6qi3B95SY2hi8t94vD3wGevgJZvwCVvhZUXgT4DZbDtisG+LjjUrZLUhIrBsNf2OoZSd1iyLhlU6QPtieqLwTgVXhqAR34K3/gvUegThWnCz74DfQPwsQ/AJReC255zuMOAPQE4FID2A0rWMVvWI+WJHUQtoWplnykIqNSv9kT1RcAy6KqGn/wZ7rsrd13u6UynQDnNNKdXWEQgEKC4uHiymzEqPvoJ+NKXYUYAnHtB240aMjuM8rZ1AQEnDLog4oC4riYva6ZKT+VKqMXYfWnZZ6yJ6uZ8lVimq1xNW/vi9RIUN5ksOBV++AgszQPfIUvWe1He8xaUN92vQ9AFYSfE9MyJ6m4DPJasiw2oJSP7jHkKDDTA60G49v2wSzLGTRrFpfCV78AHz4OKLtB2gbYHJesmrPmLmpL1oBNiDohrYGpK1k4DvAnIi6nsMxVkTFQ350N8HhwuhC/cDA99f/J+61jh9/spKioacb/9vP//4SePkesdixAB/pPiY55vKiBKPQvRdPB44Ka74F3nwLJKcB0GrQn1oD/WnLYRJqonZkB7Hjz+HGz8Ihw+INPWpgIeL1z0QbjiMlh7FuS1gHaIlFK357QFUYb50PD3YSaqmzMhVAdPvgA/eQie+rVKZSpMLk4XzGyEG2+H95wDVYPgsNfXaWfIRHVS5udIc9rqwZwBsRmwpQOe+Dt8bb1aBCoXnvzHq9S/MQZK/fOi1KcmuaDU05l/Kpx3Aay/DUpDUDiglsCmB7SjTFQ3rYnqZoVaPrUnTy3O8uufS+rXqUpBMZz/TvjcBlhUrnL2OyxZ4wctSOacNmuiumkr9VKIV4DfC9u74JtfVtkLg/2T8nOEY3DuRXDpR+B9F0FZSI2UaZ0oWdtKfZiJ6mYhUAZmJfT71L19xwb4y59V4G0uIUr9SESp5wCaDvk+KKuE9fdAkQlzG2DhAnCEQY+DZigvnemEhBu6+uGll6BfU2s9P/uUWm1NFmeZ+uT5wKHD9bfDojlQ6oa3ngvOCDhiStYApq5kHXfD3zZDXwy274HvfgkSBoSCk/krhOPB5VZeube9C95/ubq3zzgTyn2WrONqVM3UwXBCwgtv7oB9h5Uxf8dnobdbRdnn4pP+eJX6nfjxjkKphwlwkyj1qUkuKvXhmLUAlq9Wxpqdk8xEGewJoK0FXvjDZLZQGCvcXrjwQ+DSlcddt7bbso4Z8IeHISZL5OYEb1kL1bUpWaff23Hg1eegaddktnDiOF6l/qUxUOobskSpS/R7jnJwpypC7hMNw+MPTHYrhIniH09PdguEqYwodUEQBCGniZLyYJ3s8dmCKHVBEAQhp4kxOqWeTZOARvM7BUEQBEGYQoilLgiCIOQ0UexFc07++GxhSljq9913H7Nnz8br9bJq1SpefPHF4zruoYceQtM0LrnkkvFtoCAIgpC1RMegZAuTrtQffvhh1q1bx6233sorr7zC8uXLWbt2LR0dHUc97sCBA3z+85/nbW972wS1VBAEQRCmNpOu1O+55x4+/vGPc/XVV7N48WLuv/9+8vPz+eEPfzjiMYlEgo9+9KPcfvvtNDY2TmBrBUEQhGzDXtDlZIsEyh0n0WiUl19+mTVr1iS36brOmjVreP7550c87ktf+hJVVVVce+21xzxHJBIhEAhkFEEQBGH6MJ3c75MaKNfV1UUikaC6ujpje3V1NTt27Bj2mL///e/84Ac/YMuWLcd1jo0bN3L77bePtqmCIAhCljJapZxNSn3S3e8nQn9/P1dccQXf//73qaioOK5j1q9fj9/vT5ampqZxbqUgCIIgTA6TaqlXVFTgcDhob2/P2N7e3k5NTc0R9ffu3cuBAwe4+OKLk9sMQ61e4XQ62blzJ3Pnzs04xuPx4PF4xqH1giAIQjYw2jFxGVM/TtxuNytXrmTTpk3JbYZhsGnTJlavXn1E/YULF7J161a2bNmSLO9973t5xzvewZYtW2hoaJjI5guCIAhZgIypTyDr1q3jqquu4owzzuCss87i3nvvJRgMcvXVVwNw5ZVXUl9fz8aNG/F6vZx66qkZx5eUlAAcsV0QBEEQphuTrtQvu+wyOjs72bBhA21tbaxYsYKnnnoqGTx36NAhdD2rhv4FQRCEKcR0cr/LeuqCIAhCVnK866mvwY9rFOupxwjwpyxZT11MYEEQBEHIESbd/S4IgiAI40kMGI1LOj5WDZkARKkLgiAIOU0UMEZxfDYpdXG/C4IgCEKOIJa6IAiCkNNMJ0tdlLogCIKQ08QYnVJPjFVDJgBR6oIgCEJOEwUcozg+m5S6jKkLgiAIQo4glrogCIKQ00wnS12UuiAIgpDTxBidYh7NePxEI+53QRAEQcgRxFIXBEEQcpooo7Ngs8lSF6UuCIIg5DTTSamL+10QBEEQcgSx1AVBEIScJg5oozg+m9YnF6UuCIIg5DRRpo9SF/e7IAiCIOQIYqkLgiAIOY3hAG0UprppkjUZaESpC4IgCDmN4RSlLgiCIAg5wZgo9ciYNWdckTF1QRAEQcgRxFIXBEEQchrTCeY0CX8XpS4IgiDkNi6mTUo5cb8LgiAIQo4glrogCIKQ27iZNpa6KHVBEAQht5lGSl3c74IgCIKQI4ilLgiCIOQ2LsAxiuOzJPEMiFIXBEEQcp3RKvUs8mlnUVMFQRAEQTgaYqkLgiAIuY0bcb8LgiAIQk7gYnTaLj5WDRl/RKkLgiAIuY2b0Wm7LBqozqKmCoIgCIJwNMRSFwRBEHKbaWSpi1IXBEEQchuXVU6W0azwNsFk0fuHIAiCIAhHY9KV+n333cfs2bPxer2sWrWKF1988aj1+/r6uP7666mtrcXj8XDKKafwxBNPTFBrBUEQhKzDPQYlS5hU9/vDDz/MunXruP/++1m1ahX33nsva9euZefOnVRVVR1RPxqNcuGFF1JVVcWvfvUr6uvrOXjwICUlJRPfeEEQBCE7cDNt3O+TqtTvuecePv7xj3P11VcDcP/99/P444/zwx/+kJtuuumI+j/84Q/p6enhueeew+VSEpo9e/ZENlkQBEEQpiyT5n6PRqO8/PLLrFmzJtUYXWfNmjU8//zzwx7z29/+ltWrV3P99ddTXV3Nqaeeyh133EEiMXK6n0gkQiAQyCiCIAjCNMLF6Fzvo7HyJ5hJU+pdXV0kEgmqq6sztldXV9PW1jbsMfv27eNXv/oViUSCJ554gi9+8YvcfffdfOUrXxnxPBs3bqS4uDhZGhoaxvR3CIIgCFOcaTSmPumBcieCYRhUVVXxve99j5UrV3LZZZfxhS98gfvvv3/EY9avX4/f70+WpqamCWyxIAiCMOlMI6U+aWPqFRUVOBwO2tvbM7a3t7dTU1Mz7DG1tbW4XC4cjlRm/kWLFtHW1kY0GsXtPrLnPR4PHo9nbBsvCIIgCFOQSbPU3W43K1euZNOmTclthmGwadMmVq9ePewx55xzDnv27MEwjOS2Xbt2UVtbO6xCFwRBEAScpBLQnEzJojRtk+p+X7duHd///vf58Y9/zJtvvsknP/lJgsFgMhr+yiuvZP369cn6n/zkJ+np6eHTn/40u3bt4vHHH+eOO+7g+uuvn6yfIAiCIEx1xP0+MVx22WV0dnayYcMG2traWLFiBU899VQyeO7QoUPoeuq9o6GhgaeffprPfvazLFu2jPr6ej796U9z4403TtZPEARBEIQpg2aapjnZjZhIAoEAxcXFk90MQRAEYZT4/X6KiopG3J983n/OD56R6x2TSADuLj7m+aYCWTRSIAiCIAgngT1P/WQxjl1lqpBVU9oEQRAEQRgZsdQFQRCE3Ga0wW5ZZKmLUhcEQRBym2mk1MX9LgiCIAg5gljqgiAIQm4z2kC5kdcMm3KIUhcEQRBym9G630WpC4IgCMIUYRopdRlTFwRBEIQcQSx1QRAEIbcZ7Zh6fKwaMv6IUhcEQRBym9G630WpC5OBpkNRCWjAqjXwvqvBAzhNNc5iAgkNYsD2bfCjjWr6ZSgI0cgkNlw4KXxF4HJCYRHc9B3I08BlpsbUDCCqQciAjf8BwX6IxSEYmMxWC4IwnohSzwF8RXDhJVBbBv91OxRFwBcDVxi0QSCKCvTQUG+rXkgshVuvgH4PPPoYbP4zvPYK7Nk2mb9EOB7OfQ/UlMEn/xsW1oAvCnkx0IJAmFRQjxPwgOmDq56HoBveaIb/725o7Ya/Pj55v0EQJhR7XfTRHJ8liFLPYvJ8cNGlcMVH4IKzwNsJjtdB6wK6gX4gyLBK3VkERcVQVAWfXAnXvBO2tcFTf4Ov3wzBIJhZlEUp13F5YFYjfOEOuOAtUBUFVydo/wB6gD6UrNOVugPwguYDXwn4yqGyGs7+MnS44E8vwFduhKYDEItOxq8ShAlC3O/CVKaoDN62Bm77MizOA28z8CRoTUAL0IlS6gHAttRtBW0pdYqAEqAS9GrImwlnzITTLoLrPgxf+ir8eRPs3jrRv04Yyrnvho98DC49F0q6gBdBO4CSdTtKqfcyolLHB5QCZaDVgLsO6mfBVfPgX/8Cv/wzPPgz+OsTE/3LBEEYa0SpZxGaDh4P3PltuOIiyN8L2j+B3cA+4DDqQd+tQygP4nkQ94DhBNMaVdcT4IiCKwSuQShLQLUJM0CbBc75ULsA7v08vHQtXPMh2LcbEln0pporuD1wyeVwzzeguhsc/wR2oWR9AGgF2jXlV4/6lKwTLjAd6gu0BDhi4IyAO6j89NUm1ClZ0wilC+DaM+Dd/wKf+Rz87mGJrxBykNFGv8fGqiHjj2aapjnZjZhIAoEAxcXFk92ME0eDj30KNtwCs3vBuR14HXgT2AMcdkFPPsSrwSwHyoFClJnmRpltJspsD6PM+D6gC/QOKApATQTmmrAQWALmcmivhYf+Crf/B/h7JvxXT1tOWQ4/fASWOcG3C7StwHaUUj+oQ0cehMvArAbKUG4XH8o0t5Q6cZSsB1GmfA9oHeDtgaoQzDJgAbAYzGUwMB+2ROHaSyS2QsgO/H4/RUVFI+5PPu+f8Kvgo5MlGIB3FR/zfFMBsdSzAE2DD1wNX78Nqg6B9hKwBdgK7NKhuwyi9UADUAdUkqnUXaSUegwIoQbc+4BOMNqgrwkCh6GtA1qi0A5aD1SfDv9vLbjug89eCfEsemPNVhYsg//9OZwFOF8CXsZ6gdOg2QehWmAmStY1HKnU7dvaVupBlKx7wGyDUAscOgSdrdAahHYTrQsKA7B6BfzgIbjuMti9feJ+syAIY4Mo9SmOpsFVn4KvbYDy7aC9CLwIvK7BvgKIzAbmA3NQSr0eqADKMSjAwIuBExMdDRONBDpRdAbQbKVOG9AExkHo2wOv74GOHuhKoPVAXhCuezvoD8DN14vFPp4sWAa/eAyWREB/BqXQXwZ2uCEwA8x5QCMwCyXrGqAUkxIM8jBwYeBAgzRZhy1Z96Bk3QLmQRjcB3t2Q2czdEShF5x9cM7Z8Ivfwof+FXaLxS7kAqMNlMsiY0aU+hTnfdfA126Dip3As8A/gZd0aK6A+CKUr3w+0IhpWeoRCgniZRAHg2jJ4HcdZbN7MfFhkE+UfIJodABNaMwAqiBRDi1vQLgJwjEwwGPANReC8R347BVisY8HC5YrC31JBPTngOeAl4DdhTDYCCxB+csbMZkF1BGngkE8BHEziEaEVKCuE2W352HiI4qPMA66gFZL1jVgVkDfdnh9H4T7Iaquk6Vnw/8+BNddLsGSQg4w2jH1LJodIkp9CvPWd8I3vwHltkJ/FnjZAW0NYJwKLAMWYTIfg5kEKaMDF11o9DD8jDYXkIdGIQ5KyKMSL5WUUkwtLmagUQ1UgFkC3a/BK3sgEVKK3Q3/dgE0fwPu/PRk9Eju4vbADx6BszTLQn8WeFaDfaUQPRVYilLqp2AwhwjVdOOlA40eyw63g9+HKnUfGiV4KMNNFYWUU4uXejRqUUM1pTBYBG9sh0gvYKIDq8+D//0NrFkiU96ELGe0lvpojp1gRKlPUVxuuPoqqOsA7WWUxfaqA9rqwTgNWAEsxWQRYWbQTj5NaBkz2mylHmOoUlej7SVAJRo1OGiglDoKKKQYnQKrlhMCOmzdAa4IFEK+D973VvjNqbBLXLNjxiWXq6A450soWb+EpdCXAitRsl5Cgka6KaEJnRaUM33oNPU4StbpM9pKgDI0atCoI5+ZzKKMYhwUopEPuFX6ub1bwdMLHnCWwIrT4b2Xwa9/MqHdIQjCSSJKfYpy873w0XPB8VfUA/4VDVprwVgBnAEsx+BU/NRxAAf70Bg6TT3dUjcYXqlXAdVAB9CFk0bqqCEfRzKKWoO+KGzdC0VRtAJYeRH832/g/GUQCU9Yl+Qs575bTVvzbSE1hr670LLQVwIrMVlKmLk04WUfGgfhqEod0i11W6mrEfhWoBudOZQykyV4ySOZMitqwq4t4O2HUigognu/Ce0d8Penx70rBGF8EEtdmEwWLIN3nw2uHagI963AgUJILEa53JdispRe6tmFnpymPpxSjzgg4QBTA0xwGOCMp1vq6kHfBwTQCKORoIx6luDAQNn5QegahNcPQinoM2Dparjog/CoWHCjwuVRiWWqu61pa6+jguIGG1Eu96WWQp/PHjzJaepDlXovENIgbqckADRL1nlmMvdMRl6iIBpR8pnLfLxgRV9EYNAPO3ZAdRStAmoa4KNXwD/+LLEUQpYy2jF1SRMrnCy6DhesgeXFoP0deAPY64HoPGAxsBiTxfRRyw503oQMpd4K9DhU7hnDB+SjVnWxV3SxpqkPBKErCF2x1EN+wNqtLL0i6lmIw57TbgagpQ/e8MNs8M2Aj10Gf3oMBmSBkJNm5hy49DxwvIiah/6mpqLcWQIswWQxYRrZi4c3gJ3AflTumRagQ1e5ZxIFYOYz7Iy24CD0DkBHBHrMzORzStYe5tGIhxAaIaAXAv3wxn6oAkcjXHo+3DUbDuyeoI4RBOGkEKU+xcgvgC/cDK7XUYlGdgF9VcApwAJMFjBAHXtxshP1kN+NetAfBvw+MMoYPveMbXiHwOiHSB90dEF/P4QSECHlpnej46WMCuaj0wP0QLgZ9u+AXTG02fDOi+D8i+C3D09c/+Qat2yEkk5Ssm72WdPWFgCnkGAuTeSxM62Kbal3uyFaipJ1MUrWeRyRe8YMQrwP+npgsBf6o0rWttGt1n3JYw5zcRJA5S7oguYO2BWEXVA6B27+Kvz7hyaiVwRhjBH3+9EJh8N861vf4plnnqGjowPDyFz545VXXhmTxk1HPnMHVASBvaind7MHzDmoucmNGMyiGQ/7rN12OajBQCmYNRyZe+YoCeXMQhhsh6YOlQpWt6qrcXcHPmrJpxGNduAg9LTCvi7YB3kt8LkN8Mffq+VbhRPj3PfABatQ0xT3oTLFhWpJyXoO3ZSwD419pC6J/UBnPhg1qICIco6eUM7OPVMC0TZobwdjUFVxkYqQL6aECuag0wq0Qmg/HNwH+wy0/bD2rfC2d8HfJEe8kG3IKm1H59prr+UPf/gDl156KWeddRaapo11u6Yti2eAsxllih0E+stQiUZmYTKLXoo4hMaBtCpNmlUtPaFcGWrRFiuw+QilbieUs1y2ER2a28AVVw/5AuxxWDeNzLTi6mdB/AAc6oaDJtohWHQWOOwFvIUToqZMrbamHUD50zvyUJnilKzDVNOEnpTzQataZz4YtqxPJKFcIeABww2dTaAPpgLpioEKdAqpwcssNA6DORPaW+FgEO0gVK+A6tLx7hVBEEbDSSn13//+9zzxxBOcc845Y92eac3b3wNvPQP4B1bEmwsSVaindx0xKmnHSbO12y79hckqR2aJPZpSz0ddAQ4gAdEYtHVCoaH0RBVQg0Y1xRSmn6BvDzQHoQVKwnD97XDXuonoodzBV6TWQ3d1oYTYisrlTh0qU1wdPXgz5NwC9LgtC90Wx/Eq9fTYCg2MKHQ3q4zAJagchDVADV7q0mUdLoMWJWtXJ1x/IzzxGAwOjG//CMKYIoFyR6e+vp7CwsKxbsu0p7YSKjTQ2lFhzb0e7EetSQ2DFNKOWm2zzSo9bjAqUW5Y2x1rK/WjWep2UJX1kE8G0A1Ce796yNvn6MODj2p0qy2EiqEtCG3g6IJFcyaid3ILlxMW1oD2Akqg7Zq1OIsSYpwKOtCSMmhDBcVFS0nJeiT3+3BK3UvqwWSo7dFB6OiAMlO9wLUDHWhUU4HTPoFZBe2Hoc1Ea4eFZ4LTdu8LQrYwjcbUT8pxevfdd3PjjTdy8ODBsW7PtEXToLQQXP1gx6URLUA9scuAMvrQ6UZFq9vTmKI+a3d52t/yjMOG/3+4v+VglECfrr6/O9kUjTiFqS8xisGvJ9tZ6ga3d3z7J9coLFIroSY7OegmJaQyBvHQY2UG7EmvcjTZHqsMc20MeMg4Rw8ag3gzDxxwJyv4olCQhYscCsJ04aSU+hlnnEE4HKaxsZHCwkLKysoyinDiFJWpIDk9gNLWfg010lkClGBSjB8NP2p4tA8IODKqZBZ7e+kI+4fWS/sc8qgm9NlNAWL4MNO/LOhK7nzruXChREWfEDd9B/JipDo5aqeIKcGkhCDupJztKolCji7LkyiJgsxz9AFB3JjplaL5yZ35cbjxW6P77YIw4bjHoJwE9913H7Nnz8br9bJq1SpefPHF0f2O4+Ck3O+XX345zc3N3HHHHVRXV0ug3BigaeA1QAuilr8OAqYP5VP1EcNFEI2gtSsIRJ3J3arkD/lsFzepeeox6397etsw9RMeGAypc9hNCeEgP/0EEScEI2hBcEbAJcFyJ4RXs2Rtl7gHu28N8hgcIuuQBmYeI8vYLrb73UTlBrZd5THUPLYh9c189d1BMyXrQTQM8nDYleKe9J3kiayFbMORUGU0x58gDz/8MOvWreP+++9n1apV3Hvvvaxdu5adO3dSVVV18m05Biel1J977jmef/55li9fPtbtmbZogCuBGgO1Cx7UU9pLzEoDE0rbbbiTu+3luIb/P3059XTl7h25RDWImCTPGYEhFfTkTkcspTuE48NtkinrhD25zIuBi8iQ3fHUkmtHldsRY+qglLsXdTl5htT1qO8OxzLPZ+C2UgV7wXAld2jhrIoZEgSLKKNbau3Ej73nnnv4+Mc/ztVXXw3A/fffz+OPP84Pf/hDbrrpplG05eic1Dv3woULCYVCY92WaY9uoB7AcetvMjTdgYFOwtpsV8E5pDiG/O8YZttw/w9TEpo6Rzx5Ti3zIENLNkYzTvJCmsboQIZAzVTfGjiSfW8XU+e45JYh+5HqD9lm6JnnSmCv02ZVTq+QAN0ct24RhClNIBDIKJFIZNh60WiUl19+mTVr1iS36brOmjVreP7558e1jSf1LL7zzjv53Oc+x+bNm+nu7j7ihwonyYmOYpjH8f+YI0/08UYb4f9hOR65i8iEaU90DAo0NDRQXFycLBs3bhz2bF1dXSQSCaqrqzO2V1dX09bWNua/Lp2Tcr+/853vBOD888/PGE83TRNN00gkRjF2MY0xbGPYtqTSzCMd4wjDO2myp8zpzP/tz7bL3RxSf6g5mFYc5lDDz8z8Ut1MNsbU1RC9cPwYkOlN0RJgqs7XSBxhVGsGKbnFGF6OSReOxdDrYgTZ68aRxryWfjGlV3BY16kgZBUxRud+V0mVm5qaKCoqSm71eDyja9Y4cFJK/ZlnnhmzBtx33318/etfp62tjeXLl/Otb32Ls846a8T69957L9/97nc5dOgQFRUVXHrppWzcuBGvN7vnVJlAzF4AOw819knEKmFcJDJ2eQE9Ckb6QGh6CaEGP22FPmRBl4zB+WGK28wcnleXbnoFIzm+m3BbowXCcRPVyBzbdsQgrvpWJ3rkMLk95/xocrMDG+y/Q2M0wsN/hzN+5LC8TixVQY8ld5jeVM54QZhuFBUVZSj1kaioqMDhcNDe3p6xvb29nZqamvFqHnCS7vdzzz2XVatWkZeXR39/P36/P6McL3Z04K233sorr7zC8uXLWbt2LR0dHcPWf/DBB7npppu49dZbefPNN/nBD37Aww8/zM0333wyP2NKYZoQ1jIC3jPCo13WpLL04Gd3HDJCpNPL4FH22WVg+O2OyJFB9XkkMit54ip62gdxN8TEVD8hQsYQWTsj2H2rEyYPM0MGeSZogxyfXI8l/7R9Wkh9d8a5MNEJpSo5IxkXw6DIWsg6xsb9fry43W5WrlzJpk2bktsMw2DTpk2sXr16tD/mqJyUpf7UU09x5ZVX0tXVdcS+E3G/n2h04HPPPcc555zDRz7yEQBmz57N5ZdfzgsvvHAyP2NKEeiBb94M374eHCVAiYmaIa4mCGv4KaaEErTkbPGihFr6OjnJ2E4La1vocdS1ONKCLumT3u3v8ENeJHM6cylYE+rSKhfEkhX+thn+ICu1nRAb/wOueh58pagOdgch3IeSdR8+opTgyZBB74BabS0phvSsgJCa0ZAe/R5CKfE+lLyHyNw5cOT0dR/RTFm7B5M7B51w1/Vj1g2CMEFMfPT7unXruOqqqzjjjDM466yzuPfeewkGg0l9N16clKX+qU99ig9+8IO0trZiGEZGOV6FfjLRgWeffTYvv/xycgL/vn37eOKJJ3jXu9414nkikUhWBPKZJvQNQMxO3FYKeAZIz+1WipGRAC6jil0tPeXcsUr3kf/rfVBiDE1GZlpLclqVHX4oNpLt7ItBbPggUGEEgv1Dksj5oqQLx0eYMswMORSkZ6A7HlkPV3fIcb7IkbLOJ5z5RQXR5EU34FFtFwTh6Fx22WV84xvfYMOGDaxYsYItW7bw1FNPHRE8N9aclKXe3t7OunXrRtW4o0UH7tixY9hjPvKRj9DV1cVb3/pWTNMkHo/ziU984qju940bN3L77befdDsnkpYO6DRgRg1oNUBJBNragDY02sijkRpKqcHO060UansHGHmkLHQ7mCrI8Euvhkit0tYJ6QnGC4OptOJ2KSGCTodVqRW8/uTOeAVsH7sQi2lDLA5vNENltSXrahPa2sFUgnDQRRWF1KBRgxJTj6HWQ4+2kVqcBUgOf6txkpGXXu0hJet2cPdClZkp6ypMHHSlKurtqm01KjX9m4chJgEUQtYxNoFyJ8oNN9zADTfcMIrznjgnZalfeumlbN68eYybcmw2b97MHXfcwXe+8x1eeeUVfvOb3/D444/z5S9/ecRj1q9fnzHe39TUNIEtPjH+9jg8+zJQi7XaWgwcHdhrdLnooIo4dWlVaoHCAThiOa8TKa3qr7sHqo3MBd9qMcmnL7NyyWCygt8L3/3SePdM7hEMwP93N8QqSXW2t4f0fi4nPEQWUB5VetZe8vyYcm0dvq7epr4r/fvrgDLCmRW9vcmd0Qr47tchJCu0CVlHbAxKdnBSlvq3v/1tPvjBD/K3v/2NpUuX4nJl5pj6z//8z2N+x8lEB37xi1/kiiuu4LrrrgNg6dKlBINB/v3f/50vfOEL6PqR7ygej2dKTjsYie2HIH46uGajllFv6oa+g8BMNA5RSgWzKKMPjQDK6I6ZcKAXBkwwY6gx1H7UKm3plrrBkeupdwDt4OmEujjYp51tlVoiaBwiuaK3sxlmmjBLLbe9vQsSEjh1UrR2Q4cL6meBNguoCsGhQ2AeRKMeD/XMZBbd6ARQBncEMAbVeuhGuixLOPZ66t1Au1LolaGUjO0yEwMvbWgcAA6Cdki1aRaYs6DdCW09498vgiCcPCel1H/+85/zhz/8Aa/Xy+bNmzPmqmuadlxKPT068JJLLgFS0YEjuSsGBwePUNwOh/I1mmZuZNj4n1vgPz4KNY2gNQL7o+A/AGYdMAOdcurx0Y+HATSiWNPJTDjcC/4oGP2ogCg7cM521Q5dT70PtC7IC0CdoZR5Y1qZRYI82tDYB+xVpawvWSFUB9/8FISCE9Y9OcVfH4c/vQBXzcPqcAM6W2FwH1CDTh1lFDOHUoJohEnZC/qgWg89agfBlXBspd6jXO7lUaXE02U9B5NSetHYD7a881pVmxrBbISn/w5/f3Lcu0UQxoGJD5SbLE5KqX/hC1/g9ttv56abbhrWOj5ejhUdeOWVV1JfX5/M2nPxxRdzzz33cNppp7Fq1Sr27NnDF7/4RS6++OKkcs92ggPwlS/DvZ8B1wKgCWjtgJ5dQA0axfgoZi6ziODEQOlrF0p/twShJwyhXjDs+Wjplro1/qoPgGsQSmJqSe4GlFKfBywA5mNQQTc6u8Au3iZojMMCME+BJ1+ATU9MaPfkHF+5Ef71L1C6ANXNrUHYsxvMCqASB4XMZAlR8pN5Zews8S1RtR76gF+ttmbaL3BDlLoWUlHuvogaQ68jpdRPQcm7gRAO9gI7VUP0PVAfVDsXQG8Z3LF+gjpFEMacyRlTnwxOSqlHo1Euu+yyUSl0UNGBnZ2dbNiwgba2NlasWJERHXjo0KGMc9xyyy1omsYtt9xCc3MzlZWVXHzxxXz1q18dVTumEqYBmzbBlivhjMWgtQBNEQjuhUgFUIBGASW4WEg9Og7sdV2KUAZbZwJ6BiAwABEdEk4wNcBUiw25ElBg1a0iU6nPRz3H6/GjswN4A9gO2ptQ74fFwGIYaICffFsioUdL0wH45Z/h2jPAsRdoN6GzGfq2A6Vo5OMlj7nMBzzY67rYC7WWmeolri+sVluLW7ncwUoEF1fz0EtQAex2LIbtlVkAzCWCl70oWVvyLmpOyjqxAB7+EzQfmrBuEYQxJsroliLKHktdM0/Cb/3Zz36WysrKrEz6EggEKC4unuxmHJMN34ab3w/uvwFPA3/XYG8dJE4HVgHLMVmKn1r242Q/Gk2o8KZO1PBpP9YSrSgXvQZHvABUoqKelVI3acSgmj4c7AC2AC8DL0DlHjgnBueCcRE8r8EFyyEanrAuyVne/i742Y+h7nXQ/gz8CdhaCIMrgDOAlZgsI0wjTeSxH42DKFm3oWTdR2rM3bboj3gBQMnattTnYNJAyFLoW1Gy/if4tsCyAbgAzPOheSlc/lF49g/j3xeCcCL4/f6jZnhLPu/9T0CR7+RPFAhC8buOeb6pwElZ6olEgq997Ws8/fTTLFu27IhAuXvuuWdMGjed2fhZaCiFfzsTHF3AoAmDrdCyBQwnKkd4jGIWspAGysinCo1ahlfqBtbyrqhZT4UcqdTriFFAu+Vy34ZS6q9CyV5YGoMzwFwJLw3ANVeKQh8r/voEfOZz8H9fgYIAKglQpB/e2G7lkwWNKF5CNDKXEkqoQKcGpdR7UEp9EGuZVut7baWej8ppkK7UGzAoo9dyub8BvA68Ap7tcMoAnA6cAf3z4NOfEYUuZDvTx1I/KaW+detWTjvtNAC2bduWsS89aE44eWIx+NEDcOFF0HCGWseaoAFmC7S+AkYMiKAxgBc/M5hFKWXU4qIL7QSUukklBsX4cdKCxh7UuOo24DUo2gtLo3AmcAYMLoJHfgq735jwLslpfvcwbNkAb1kBzj6U0CK9sHcrRE2UrEM4CVDBHAqpoQYvHWj0oNHLyEo9ZambVGFSRtiKct+PkrWl1D3bYW6fcg6cCfEV8GoYfv/LiesHQRgfZEz9qIzlgi7CyDz7NHxmHXzvHqiwV1hzJ+ClJmgehLjK8qbRgYMWCmmgkDrqKWIQD4M4GUyLkLcD6ryY+DDII0o+A2h0AE2WU3cPsAO0N6D8sLLQ3wKshsiZ8IOn4Rv/NUkdksNEI3Dt++AHP4ezz7YTSJjg6YVdW2AwgJ0tSKcVL7Ooo45qKgjiZRA3g1aEvJ0bxlbqKo98lHzCVmKZFkvWe1HRedvBtw/mD6iXt3PAOBue64frPgyx7DFSBGHac1JKXZg4HvuxGgr6+u1QEQfNBbgMeK0L9r8C4V7UZPNWNGYA9XipxEsZJRRgkIeBE3tOm0YcBxG0ZC73TlR+uibUXPTdKmKrtgeWJpQbdjVEToPvPwm3/ick4sM2VRglu7fCtR+GXz4Gp56tVrdVS/L1w443wR8AsxMl62agDic1FFNGEcWWrN2Y1iuBhoFOFJ2QJWs7pVwLStb7QN+tguIWxmAlcIZS6K9pcO1lsFc8MkJOEGV06i573mxFqU9xTBMe+A70D8B934SqQtCLgUoTXh+AXduhuwWie7FHxtVIeTk6hej4UPa5nSc2xvB5YptAPwzFHTAnBkuA08A8HcLL4fuPw+f+TRT6eLN7G3zwX+F/H4LV7wCnveBLVRTePADNHRDarzL/UIcaJS9DowQHPhzHmqhuK3XtkJqHXh9UUe7LgJXK5f5sAK67DPa+OZG/XBDGE1HqwlTChEd+DHkFsGEDzHkruEqBCqDWgD3d0BSAnoMQr7LmOJehRs6HS/5uL9PWp7LPaB1QHICaKMw1YSGwBMzl0FYNP38SvvQpUegTxe5tcN3l8INHYPlKKCgCrQKVg31XEA7ug/ZWCJeBWYWSdQmp7DPpyd/tJV37UCv2tKvUr1UhlVhmAbAYzGUqKG5LWJ1bFLogZCcnNaUtm8mWKW3DoWngcsPd/wtXXQy+vaDtAHYD+yE5p61bg1A+xPLUYueGE0wdNBO0BDii4AqBOwRl8WGzz0Tmw4tdcM2H4MAeOM7F94QxxOWG914G934TanrAsQM1BL4PknPa2jUYcEM0H+IeMFyZE9X1mFoP3T2oVlurNo+YqJ5YAK2lKsr997+UMXQhezj+KW3fg6K8kz9RIATF/567U9qEycE0VUDVF/4THn8EvvRVWPw2yJsL7ActOVHdhO6gmls5SCr8HYafqF4NzFQe3fhs6CiC278Cz/wZ9u6c6F8p2MSi8OufQHsnfPQK+OA7oGQOaPtBS05UN6EnAr0RZZCnR8o5SIW/D5nTZs4Ccw70lsMv/gQP/kwFZgpCbhIl5cE62eOzA7HUsxhvHqz9AHzsI/AvqyGvSy3qpo2UfcYOfx8yUd2ognAlvN4MT/4F7r4FQoPqJUKYGjhdMHMOrP8q/Ms5UB0HVydo7aQmqgdR4RLpSj2PjOwzZg3EKqDNCX94VqV+PXwQ4tkzY0cQkhy/pf7tMbDUbxBLXRhfwiF47Kfwp8fg/PdCbRnc+GUojEBhHFwRYBC0ISnlTC8Y+TDggH4vPPIIbN4Er2+Bfdsn9ScJIxCPwb5d8PEPwtveBdWlcP2NsPBM8EUhP46S9RBL3bSyzww6YcCj1kP/7nq12posziJMH6aPpS5KPQcI9sPvfqbG3H/+gNLdZ62B9/2btb6HqbaZQEJTl+cb2+DHd6pt4ZCMo2YTf7MW0XniMXA6oKAYbvwW5OnKEaNbHhZDU3MdBg2463p1ncQSsh66MB2JMTp1lz2uLFHqOYRpQr9f/f+nX6si5C6DlnIO+OHT/zq5bRGEqU2M0Vnq2aPUR7fMmiAIgiAIUwax1AVBEIQcJ8robNjsGZ8UpS4IgiDkONNHqYv7XRAEQRByBLHUBUEQhBwnxuhs2OwJlBOlLgiCIOQ4UdTE3tEcnx2I+10QBEEQcgSx1AVBEIQcZ/pY6qLUBUEQhBwnxuiUevaMqYv7XRAEQRByBLHUBUEQhBxntO5zcb8LgiAIwhRBlLogCIIg5AhxRjemHh+rhow7MqYuCIIgCDmCWOqCIAhCjhMFzFEcnz3R76LUBUEQhBxn+ih1cb8LgiAIQo4glrogCIKQ48QYnaWePYFyotQFQRCEHCcKGKM4PnuUurjfBUEQBCFHEEtdEARByHGmj6UuSl0QBEHIcWKMTqknxqoh44643wVBEAQhRxBLXRAEQchxooBjFMeLpX5c/PWvf+Xiiy+mrq4OTdN49NFHj3nM5s2bOf300/F4PMybN48f/ehH495OQRAEIZuJjkHJDiZVqQeDQZYvX8599913XPX379/Pu9/9bt7xjnewZcsWPvOZz3Ddddfx9NNPj3NLBUEQhOwlxugUevZklJtU9/tFF13ERRdddNz177//fubMmcPdd98NwKJFi/j73//ON7/5TdauXTtezRQEQRCErCCrxtSff/551qxZk7Ft7dq1fOYznxnxmEgkQiQSSX4OBALj1TxBEARhShJldI7p0UTOTyxZFf3e1tZGdXV1xrbq6moCgQChUGjYYzZu3EhxcXGyNDQ0TERTBUEQhClDbAxKdpBVSv1kWL9+PX6/P1mampomu0mCIAiCMC5klfu9pqaG9vb2jG3t7e0UFRWRl5c37DEejwePxzMRzRMEQRCmJDFAG8Xxo1kMZmLJKqW+evVqnnjiiYxtf/zjH1m9evUktUgQBEGY6mjE0Uah1E3MrFHrk+p+HxgYYMuWLWzZsgVQU9a2bNnCoUOHAOU6v/LKK5P1P/GJT7Bv3z7++7//mx07dvCd73yHX/ziF3z2s5+djOYLgiAIwtTCnESeeeYZE+XXyChXXXWVaZqmedVVV5nnnnvuEcesWLHCdLvdZmNjo/l///d/J3ROv98/7DmlSJEiRUp2Fb/ff1zPe4ffYzpN70kXh99zXOebCmimaZpMIwKBAMXFxZPdDEEQBGGU+P1+ioqKRtxvP+9dfgda0Sjc7wGTWHHimOebCuR89LsgCIIgTBeyKlBOEARBEE4UncQ0iX0XpS4IgiDkOG5GP6EtcsxaUwNR6oIgCEJO42K6JImVMXVBEARByBnEUhcEQRByGjfTx1IXpS4IgiDkNNNJqYv7XRAEQRByBLHUBUEQhJzGCThGcXxirBoyAYhSFwRBEHIaN9NHqYv7XRAEQRByBLHUBUEQhJxmOlnqotQFQRCEnMbF6JRdfKwaMgGI+10QBEEQcgSx1AVBEIScxs3olF02Wb+i1AVBEIScRpS6IAiCIOQILqucLKNZ4W2iyaYXEEEQBEEQjoJY6oIgCEJO42b6WOqi1AVBEIScZjopdXG/C4IgCEKOIJa6IAiCkNNMJ0tdlLogCIKQ07hQin06IO53QRAEQcgRxFIXBEEQcprRzlM3x6ohE4AodUEQBCGncSPud0EQBEEQsgyx1AVBEIScZrSBcuJ+FwRBEIQpwmjd76LUBUEQBGGKMJ2UuoypC4IgCEKOIJa6IAiCkNOMdkzdGKuGTACi1AVBEIScZrTu92xS6uJ+FwRBEIQcQSx1QRAEIaeZTpa6KHVBEAQhpxntmHpirBoyAYj7XRAEQRByhElV6n/961+5+OKLqaurQ9M0Hn300aPW/81vfsOFF15IZWUlRUVFrF69mqeffnpiGisIgiBkJe4xKNnCpCr1YDDI8uXLue+++46r/l//+lcuvPBCnnjiCV5++WXe8Y53cPHFF/Pqq6+Oc0sFQRCEbGU6KfVJHVO/6KKLuOiii467/r333pvx+Y477uCxxx7jd7/7HaeddtoYty67mb0QVpyjBKwDmrXdQI0PtTTDP56atOYJY4jbC+/8CLg0cJCStYmSddSApx+EaGTy2igIwsSQ1YFyhmHQ399PWVnZiHUikQiRSOppFggEJqJpE4qmQ0ERlFfAzfdCkQmN9XDKPHCEQYuDZgAaGE4w3NAdhFdfgYAOv/wp/P0pCIfkwZ8N5BeCywHX3w6LG6HUBavPAWcU9Kgla8DUlazjbnjuMuiLwbY98N3bIZaAwf7J/R2CMFE4Gd166rGxasgEkNVK/Rvf+AYDAwN86EMfGrHOxo0buf322yewVRPLKcvg/DVw4wYoGwTfAGidQDNoO4AgEEWZ6Brqys6DgkKYVQJUwmVfh9774JEn4FcPwebHJ+3nCEehsBjWvAfW3QILy6A4BI5OoBd4ErQgECIVqusEvGD64KISoAYSS+FzH4E3uuDeO+CPv4OB3HvPFYQMRutCj49VQyYAzTTNKZGrXtM0HnnkES655JLjqv/ggw/y8Y9/nMcee4w1a9aMWG84S72hoWG0zZ1UdB28eXDz1+CdZ8OpZeA6DFoT0Ax0Ad1AABhEKfUESqm7AS9QBJQAlUA10ACJBujwwVMvwFe/AE37IRad+N8nZOLNh3d/CK64DC48HbwtoB0EWoB2lKz7UC9wYVJK3YGStQ8l63KgBqgDcyaE6+APL8MDD8GTv4Lw4MT+LkEYLX6/n6KiohH3BwIBiouLedgP+SNXOyaDAbis+NjnmwpkpaX+0EMPcd111/HLX/7yqAodwOPx4PF4JqhlE8PHPgm3fwnq+sC5B7RngX3AYVJKPeCCkBMiDojrYGhKqTsMcCcgLw6+GFSYSaXumAU18+GqBfCev8AvNsMtnwR/76T91GnPomXww9/AqV7IPwjak8BewFbqbYDfAUGXknXMAQlrVN1hgisBngQURKHIgFqgDrRZkNcI7z0FLrgDtt4C13wAdm6drF8qCMJYkHVK/ec//znXXHMNDz30EO9+97snuzkTyrylcMN/w0fPg/I9wFbgTWA3sB9ocUCwCCJFYJaizPF8lHnuAEyIRyEShv4A4IfDfZDnh+oozARtv7ICK0+Fj78Nqh6An/wKHn8ApoZPZ3rgdMNN98C/ng2nxUB/FdgO7EK9wB3SwJ8PoRIwilGmuA9lmlu3dSIO0TAEg9DTB3of7PdD8SDMNKFRybpgMaxaCj/5ETz6LHztcxDPpkFEQTgGo00+k023w6Qq9YGBAfbs2ZP8vH//frZs2UJZWRkzZ85k/fr1NDc388ADDwDK5X7VVVfxP//zP6xatYq2tjYA8vLyKC4unpTfMFEsWAYP/haWauD4J/AaSqnvAA7nQX8lmPVAHcqnXoZS6j7UJe1ADazHUD5aS6nHOiDWDv2H4VAb7B2AvQYcAncLfOA0eNv/wH/54GffmfjfPR0pKYev3g9XnQd5b4C2GSXr7cB+F/SWQNyWdQ1K1iWklLrD+qYEStZBoA+Mbgi2QbAVOpphXx/sjcEB0A/DytNh8eVQUwlfvB78PRP2kwVhXBntmLoo9ePkpZde4h3veEfy87p16wC46qqr+NGPfkRrayuHDh1K7v/e975HPB7n+uuv5/rrr09ut+vnKguWwQ8ehOVR0F8CXgS2AG84oLsSEnOARqCBlFIvx6SQI5V6HBVN1Y9GH9AJtIHZBJGDcHAvdLdAdxj8oPdDzWq4+0sQCsIjYrGPKy4XbPwO/Nt54Pkn8BLwMkqpt5RAeCZK1rNIV+rmMZS6knUPyl/fAvED0LEPAoeg0w+9oA1A/iB8/ELQvw2fuUosdkHINiZVqZ933nkcLU5vqKLevHnz+DZoCnLKUnj4MTg1AvpmlEL/J7DHB8G5wEJgPjAHW6nHKSNOERE8hNCIoaXFyZl4AC8xXAzgpBeNDuAQcBDMBujfCVt3Ql8P9BkQgsq3wHfvhvwCZbGLYh97Ssrhju/C1eeA+1ng7yilvs0N3XVgLgJOIaXU6zGoIkYhMXyE0IlYsgY7Ts7Ei4GLIC4C6HSgBuMPArMhvBP2vwn9reCPQgA8Ubj2XDAfgFvEYhdyALHUhSnBvGVw/0NwagL0F4B/oJT67lKILACWAoswmQ80kqCGAIX04qQb6Ec5XmOkgt+tGW0U4qAELxWUUUQdHuqAWjQqgFKIF8ChbRBrBc1A06AyH+76KvQNwO9/PPH9kcs4XHDb/XDVBZZC/4dVtnmgby5wKrAEOAWTRkxmEqSYPjz0WHa4HfxuT7+xZrThw0EJJZRRTAlV+GhAoxaNKqAUzCLo3Aqv7oN4BJzgccA174Tod+C/P6aG5wUhWxntmHo2TQISpT5F0XVYeyGsLgbtGeB54B8a7CmD6HJgObZSTzAHP+W0oNOCRidkKPVhpqlTiBqFrUKnmnzqmUUFFbipRKNM1UjkQctr8MJBMA3wQrUTPvYB+NtvJSp+LJm3AD58DnhfBZ5Dyfu1fOg/BTgdJeslGMxnkBpacdOKRhvKqd7H0ZS6knUZGjV4qcVDHSXkUYlOGVCsavW54bVd4AiBrqbSXf42uH8+7H5z4vpCEISTR5T6FOW9V8GX14PnFeBV4BVgXzFEFwOnAcsxWUaURlrwsR8tOaOtE/WgP9Y09WKgCqhGowuNWRTQwDwKyUfDDejqbaAtAq+1QYmBXgiXXAgd34F1V8qY61hwihUzUdkK2qsoeW9zQf9clKyVUk+wiC5KOYiDA6RmtA2n1DVGnqbejkYvHmbTQDk+HMmIeRMCCdi2E/JiaGVQXQI/eBiu+Qjs2TZRPSIIY8to3e+S+10YFUUl8LEPQfEB1AP+VWCHF8ILgBXACkxWEGIe+3GzG419QBPqQZ+u1EMaxLSUpe40wWOmW+pqmno30IPGAG7mM5MSnNZqPwYkQnAoClu6oBjcdfDB8+DeRti3c6J6JTfRdbjgQlhZAtrTqADIrQ7oacCWNawgzmKaKWY32hHT1NOVelTLnKbuMdWkxhJUjHwt0IFKQhfAwXwqmMFSHOioV784dA/C1oNQnkArhTPXwjsugL1vKIeNIGQbotSFSeX8i+Ci062H/HZgpwMCM1BjqqpEmMsePOxATVNPV+p27pmoG4w8sI1uTJIz2twRyI9Cp2nVBwaAKBpxHCyijlLiaETU3ng/7O2HigjMgso6uPF2+H8fnti+yTXyfXDLTeDZhpL1dqCtHMzF2LJOsJBmSngDNU39iNwzOoQ8kPACHlJ3dRwIgyMCeREoNtQLQA9K1iEgjoZGCfUsxEFYbTV7obUf3uiEavA0woYvwE+/DyHJOicIUxpR6lOM/AK4eQN4D6DmoO8E2kuABcBCTBYSpZEDeNhpVbGV+mGg02XlnimB5Iy2tNwzRIEwRPsh6odgL/SFlZVnpw03ASc6i6ijkEE0eoFeFSG9+yDsMNBmwnvOgXMvgr88OWHdk3PceCdU+lGC3AHsd0NiHmpWw0IMTqGNkqSsd6JkfRBo12HAB0YJw+aesZV6IggDfTDYB/1B8BvKTR9FyVoHHJRQywJ0BoAuSHSrRDW1UTgFqmbAf98Bt39mInpFEMaW0QbKjWYxmIlGlPoUY837YHGxNba6B9jvgPhsYJ5V5tJOAXvQ2G1V2YNKKNeVB0Y1mbln8lHWmz1N3VLq9AN9KvdMV4dS8HEzfSxWo8ByxbvoRKNLzWVv64Y9AbRGqDoVLv0IPLdJcsSfDPOWwr+8FRz7UULcp0GgClvWJnPpp5p96Ek527JudkLUHiQfmntmiFJPzz0TaIdwN8Tj6nJwoB52+TgopJpC5lrhd+3gb4J9LbDbxDkX1p4LPz0V9srYupBluBidYhalLpw0778U8jqAAyhzzF+MmpM8G5PZDFDBIXQOWrvtal35YKQnlCtnZEtd5Z5RkXL5gBcCh+FQrxpz9wIFQAkaJfioYxbQCsyGyCE4FICD4GiC910E6z2i1E+G5afBqdWg/RMlxDYPGA3ALExmE6OeZlxJOR+wqjU7IWotzEINStYlJGU5rFIvRl0PXoi6oKUN9Lh63/Oh3v/KcTGXelzMRqNZtaW1Gw6G0Q7CsqWwdLkodSH7kDF1YVKYeyosaUD50Q8DLTpEqlBJZWaQoJYO3DRBRunyWgo9M6HckUrdzhJrK3XrIW+/hgYMlQo+9ZCHSjTKqcJrtQGzHtoPQFMUmqBsAbztXfDkw+PdO7mF26uWzPV0kBJkoAiYgS1vP4UctnbZl0SrA6L2JTFSltjhlPqQ5IIRA1rbIT+hZF2KCpqspIhyGpJtILAXDofhMHg74fwL4fFfQSy18KEgCFMIUepTiNPOhIUzLNd7G9DnRcWm12BSQ4RS2tBot3a3A10OiJdb1exyLEs9TMotr1snt7b7w9Aehgrr+9vRCJCHh2o0aoAaCBVDeye0g9sP779clPqJkpcP770Y9FdQHd2hgVGF0tLVmFTRiU4bJEu7BqFC7EvCrpqy1NOzxGpkKnX75c0kmT02NAgdferwKrsZ6JRRhWafxKiCtk5oA70TLnkvfOHTotSF7ELG1IVJwQt4/Kg5aZ1AMA+loVXpw0knakqSXWUw39pdlVbSlfqQRdqSSt1L6io3rG0hiAWgq11Fxdvn6EKnlFJcdltixdDVBZ0mWicUScrYE0YHCsOkOrnHQbqsB/HRaSUSskufE0xb1nbVKo5tqeejnkpps9YYBLMf+oLQGUuXtcYgPgrS2kKvEzrj0AGFEfW+IAjZxHRyv+vHriJMBL5iuOLT4BhATTr2A6a9pKYqfjT81q4+IKCrDJ9pVVKleITt6fuH1rG2DbrV96eXOD5r0RCrBF3Jdp5xJrxl7Rh0wjTimi8o13eyg2P2bPISTEoYxH2EDGI+hpfb0DKSbIf5P+Y7UtYh3GmyLoZofnKnL6HaLgjC1EQs9SmCywXz51qu9wDQr4FZiBrxLCSGl37UUHjA+htyoqxxuxQM+Zzufk+fp277kgwggko7lzoVUQ/0R1Ln6QfCuPCmf3HICYEoWgDKfVBdO67dk3MsWgyOIKqTA0DMTt5bhEEBQfRk39vFLEDJyJJTRrFnOgy11Iex0BlIHWf41HQ3uxkqtbBOOQVo9sliXggEoB/0QVi4aFy7RhDGHKehymiOzxZEqU8RNMBtr5RpF7xWySOGgzAaobTdCTuRe16yWvohqf/T3e/2qpyxtP3eIcd5IKJB2CTtfFrmyaJ6siGOWOprhePDBZmyTtgJfL0YuJOytkvcyfDySpe1/Td95VVIDa8MPcaqH3NAOJEcgSGMhoEb3a6ccCd3auHsGl8UBFAzPfRRLEo0mmMnGlHqUwiHPY88ZpVkeIeTBHpyc8yqlpx8aVdLL+nb7eXU7bHvxJB6Q49zq9SyMZO0c2qZXxrXk23V4jKOc6I4bK9J1CqGPWPchYkjQ9YxIKEzvJzTZW0XW6nbFnrs6MckHBBLZJ7PwJk6oeHI2OmQGApBmLKIUp9K2A9Lw/5fs4qOiYZh7crYradVG1r0IX85St0hxUw7T/J8GZVSbdZMCZ46UTRQnWqmb1HFlrWZXuU45ZaUN6QS/h/HtZF+vpSnccgFYRWRtZBtiKUuTAqm/ZB1WH8xUKZWAh0Th7XLLsndqWqpMnTbSPWH1rM+pzdDnc/MrGi3VQdTT9NNwnFhQGYnawaYqm81jIy+11EvTsPK2ZbZUNnCyDIeUjQzdR77nBlfqhmpnXq60heE7ECUujApxG0PbHL+RTRZnBhHeFC1KCrQLZJRNbPYA6DpgXJHq2/tcxtHemsz/MXOVAXDKQ/6EyVhr4NrFz0OCdW3OvGMXR7AkWBkudnbnSg5pwfKRUc4Lm2bI555LhVXGU9V0OPJnaY7tQqcIAhTD1HqUwQTiDpR0eo+VCQzg6jMIUHcxPBh4kNL7nbGIDGYUU0VOwo6PSguPaNceEj99DIIeljFUPnSSh5GqgKD4I0ndya8VgiAcNyENTDzQbM72BlJClMnnJR1PlaeoAQEh8rZLrYmhlRCd0gmmTni+kgTI4PgMTIvu3xM9PSLxBlJ34nknRGyDS0O2igeUloWWeoS3zRFGOyH3/4cjOS0NBO01IQmnWDGjLUi1JzhjLlIQ0vgKP+PdEy/Wpa1iIxZbriJoCUPDEBeHArVrLs3d8CW58a5g3KMX38fYh5SAnWGsPtWZ4A84snZa3bRg4wos3TRHHXbkH168MgZcvnErdXarANd4WQjoh749Q/Gt28EYcwZyTN5IiVLEEt9ihCNwD+fhdiF4ClHZQlz+CHeDXQDPZRSQzkOylEJ40pNCPRbVezFWYZJ/Trigi591lenFa0XiuLq9HYzygEXAdRK3GmVrAr7DkPTrnHuoBzjn8/AgNuSdTmQF4KgkjN04yNCGa4MOXTaVYpROQk8ZOYcsKetDZf73c8RsqYH8kMkrye7+AinKtANeYPJC2HACS89M379IgjjwmgVsyh14WQImxAtAnclaJVAURh6VAJPjU4KCVOJLz2BJz1h6O3miMVZkg/5QYZPExtAKXWVGzSZJ9QTIOP7K4FS4jjoSVVOq2RWquU8hRPDBPo9UGbLutyA7m4wlSA8BKjARyUaFaju7kxAqAeMIYuzJIdV0nO/w/BKPZUPFr0HyhIkv78SqMDETX+qotYN5aaSdQUEPBIUKQhTGVHqU4gnfwF/uQzeXQfUA+UR6G0FswVowU0XteRRh57UxQETwj0QshU3pILhhsv9nr5KWx/q2d0GtICjA6riavGveqvUYVJIv6pAsyoFAVWpDvp9cMdnx79vco1AH9z1RfjWDeC0+pJ97RBrRvV1C1VUUI+bNpQ+7gMGgtDXCqa9OIv98hbkmOup00NS1lorlAQzZV0PVBEjKWeawdme3JmohrtugYHA+PaNIIw5ydwfozg+SxClPoUID0JrFMy5oM1ArcLZ3A2Dam1OnWbKqaCBfHrQ6EVl/AwnoKnduu7Sg6OOtkpbuqXeDnoLlIfSF/5UpQ4DB60kFwDVW6DOgAYwG6Anz/IUCCeEaUBbH4QrwdcAWgNQOggdarFVjcP4mMEMqmm3ZB1AiTXep7IIJxPL2Klfj2ap95Gh1Av6lK6ekVFM68qyF3o9DGXqojBnQKgC2nrAFFNdyDaSGbtGcXyWIEp9irHx8/CBv0NZI9AIHAjCgQNqHXMacFPOTObSj5MBlEGeAIhDaxuEIigr3M9xK3VnN1RGYJZ1SrvMwaSILmBfqhR2JivEZsAdG2BwYEK6Juf44yPwp4/Av85B9WlDDPoOQ3QfUItOLdUU0kg+QSttbBzAhEO90B8DYxAl6xKOVOoJlFdmkGT8hN4JhQMw08yUdSMmVQTROUBS1u5m1SZ1MfDU32HTbyekawRBOElEqU8xWg7Br/4A150O+jzgoAlthyG0G6hDo5RSiplLNSE07JkWTtS0p7Zu6A9CvIfUIh/DKfV+0ALgC0KFMryZDcwD5gPzMakliJP9wG5VHPthRhjmgTkPtnTAX/4sltvJMtgPD/wM1n4V8uahOr+lF1r3gLWmuZcS5jCXME6ipNL3u0xo7VcxFZFeVPBcuvs9bd10e0zdMwBlMeVyt1/g5ltlNnG8HEZjD0ree6CiN1lhsA5++j/yAidkKRIoJ0wW0Qg8/BC89x1QvQi0FqApCLt3g1EFFOKgkFo8xCkBNKXQUQHRxSZ0haA3DMEeiLms8Vcr+YwWBz2qlv0sMlRwVA1Kqc9C6ZUFwBwiuNkLvGmVHVDRCQuBRRCfB0/8FvZsn+AOyjGe/g1suxnOWAjaHqDNgN79EC4FytHIp5g8TqEeAwcOlKzzUXq8LQa9vWoRtagTjPTYioSStScORQkoRck6XakvABaQoJgWtKSs3wTvATjFgEVgLoBtAfjDoxPZM4IwhohSFyaTZx6HR5+Ff18JWgfQbKoQ89Zt2MtrOdBpYAlOSvCiUYB6aJejhsm7TeiPQzAO0ZAy2uwkZl6UEV/CcErdZBZhPOxFYyvwOrAVfPtgsQFLgWVwuBC+tn5CuyUnCQXhSxvgoe+Bbxkq+rEjCLvfhHgR4EbDTRkai6nFgxMfSn7lQBVWEF0CggkIR1JZYh2oqyUfdW2UMVSpm8wlQQktaGwDW97OHdAYVLJeCsG5cNvVEAlNXL8IgnByiFKfonz9VjjnUTh1OWjtwIABoQPQZyf0NHFgUMspeKmgGAflaGrqEyomyg6siqIe9PZCX0OVejUwE2jAoJp+3Ozj/9/evUdHVd77H39PJpkJaGYShNxohAYauSpFCgeQH4JUj7hoPZ5TWCddiLdaCvpT6c82FD0BtQKW03oWYrtKW1BBKFqgPYJABakIeDgCQQTkkkQuSsI1ZEggk2Se3x+bxAQCZibJTGbn81prL5idvWc+s3dmvnn2fvaz4VNglzXF74escugHph+cSoFpU6HiYri2hr198HdY+A48OhDizgCnDFw4DUd2W2PwEouDAIlU0INvkICbpEv7OgVrX5dgHWW/SP2iHo91VP7Kom5Ip4LrOIaDvVgFPQ9iPoVvnIZbDPSDyl7wp5WwRdemSzRTRzmJtMLP4OmpsOw1SDgLjgrgwkX4ZL/VMYoK4CJOfNxAdxLoTArt6XzpcrczWP3lyviqqNe01Nth9aHzYrX0UjAkU8F1nALygc+APUAeuPbAt0rgO8BAqOoPb2yApX8I48awOV8J/L9H4a4jkPkdiCkFKgPgP2Ydjg9YPd4clHEdpXSnCx3x0plYirh2Ua9pqSfyVVFPoYpEzhHDYRzsx9rXuyEmD9K+hAEBGAiB70BBIvzsx9ZpIZGoVfc+GKGuHyVU1Fuxj/4BC1bBxBHgrhkJjgrYfQDOVYCxerw5OIObTFLpzA10wkc8Zy8N9FmG44qWejuMdf6dAIlU4eYsMXyJg8PAIWqLevx+6F4KA6n9ks+rhHmzI7E17M1fAdOnw5znIWXgpXGq/dWQ9wV8GYDqC8B5HJTg5BQd6IKHTnTGQwkxnMNBGY56RT0Wq6XeHoMXQyIB2lNKLCcu7esCYD+wF5x7Ib0I+lsF3QyE4s4wfRpURtEXmkhbp6LeipWegafvB9cb8NBIq4OUdUr9Iuw+CMWlEDiBNVjJMWL4Bm4646ITN9CBAO3xE0cVTgwOwBBLgDiqieUCNde0OSjCug79CFbP5wPgPQo9KqA/MBgCg2BzGTycDYX7IrE17M0E4M15cLEMfjcHOsZiNbWvC8COL+GwDypOw6V95aArcaTjIRUPSRi8VOKiEieBS3c8j8EQRxVxVOLgHHDm0r7+EuoWdXcBdPVBfwMDgNvgZCZMehL++kYktoZIM1NLXVqLqkqYNgnMPHh4BLjc4HADCQH4tAiOlsKFYjBfYA0h0vnS2dYOOEmgXb0L1evepq3u6DN1inrc55ByDnpUW+fQ+4MZBHkGHvp3yN8b7i3Qtqx4Da5rD3NegI4OcLQH2hvwllobv+QkBL7E+gOsMw5SgQ44SMRNe9y048oL1RsYfYbDEPM5JJ6EbhVwM3ArmAFwsjtMmQp/XRTe9y7SYnROXVqTkjPw5P1Q9QZMGA2eRHCkAukGPiuDQwfgxBdQ3gFMGlb3txto/JByReA+CYmlkFltXefUG+gH/t6w6TRMHAsFaqG3OGNg0W/BVw4v/wY6J4HzBqzebXsq4OAxOHYCfAehOhkuFXWrK9x1WMdzvmacWOcJ8JyBzn7IAnoBN0N1PzjWEf7vE/DOIjTIu9iHn6ZVO7XUpblVVcJ/TIK/DYHfzIHeI8GRfGk42S4GCs7DsfNwuti660bVpVt5mbp3/qgp6hXWbV0d5+D6C5BUYQ392gVrsJGbINALSjIgZwas36BD7uFkDKxcaI059OAEuH8UuFLAkY51mUKBHw4XwclTcDYf/NeD8Vo3aL9iSLmL4Ci39rXrvLWvO1VZIw1lAllgeoH/Jli4Dha+Dv+zPhLvWkSag4p6FCk9AxvegX/Jh6eehX8dDsnfgph8rNOjR4EvK+BkBZwptbq/lzusOh649CQ1F6onGKv7+2UXqpvucLEL/Pf/wKLfwKpFGjEuUj56Dz7+Bxz7NdwzFL49GuJ6YO3rw8CXVVBUBWfKoKTY2tcNXtN2aV/XvaatK5hMqPom7DgN7yyD2T+Fqqorc4hEvTbUUncYE7mv7A8++IBf/epXbN++nePHj7NixQruvffeRq27efNmhg8fTp8+fcjLy2v0a5aWluL1ekML3MoM/2cY90P4t+9CBx84jmHdgesk1ogkda9pC2Bd02Z1f7eOzCcCyWBSvrphxyenYeYM2LhOd+NqTb7VB0beAc88A8kXIPYL4Dg4Grqmre7YwTUXqicCHcCkAmlQ2RlOtoPnnoP3N2hkQIlO586dw+PxXPXnNd/3514FT7vQX6f0Angnff3rtQYRbamXlZVxyy238NBDD3Hfffc1er2SkhLuv/9+7rjjDoqL2+7NvP+xBrZsgNldIGc2pMXDiNHgKoU4H8RY17Q12FI3CVB1Pfi9sOcwfHoIls+E9/8KF8oj9pbkKg5+Cof2wqI/whO/hJ7fgP8zyOpM5/JBjA8cdYu6g9qWurkOAh7rKP2JAHy4DfZ8BHOfhfJyq+e9iNhDRIv63Xffzd133x30ehMnTiQ7Oxun08nKlSubP1gUqfTD4YPwk/ug3XUw6l8g3gH/NBzGjLPG/XYGIMaAcUB1DPidsP8AvDHDqgG7/tca7EZaNxOAsvPw4hPW49vuhpSOkJQAU2ZDfADiqiHmUpEOxECVEy444D9/DiXn4fgJ2LI2cu9BJCIqaVq1U+/3lrNgwQIKCgpYtGgRL7zwQqTjtCoXyuC/L12GtHIZzHja+r/jsuUMVsc73XErun34rvWvwwF/XmLt54b2tQHOl6hvhLRhfr7qPxrq+lEiqor6wYMHycnJYdOmTcTGNi56RUUFFRVfjXFZWto2ThRXVliT2J8x4Dsb6RQi0hrERDpAY1VXV5Odnc2MGTPIyspq9HozZ87E6/XWThkZGS2YUkREWp2awWdCnaLo8HtEe7/X5XA4rtn7vaSkhKSkJJzOr46hBAIBjDE4nU7WrVvHyJEjr1ivoZa6CruISPRrdO/36eCJD/11Si+Cd7p6vzcrj8fD7t2768179dVX2bBhA2+//Tbf/OY3G1zP7XbjdrvDEVFERCSiIlrUz58/z6FDh2ofFxYWkpeXR4cOHbjxxhuZOnUqX3zxBa+//joxMTH06dOn3vrJycnEx8dfMV9ERKSWn6adbFZHucb5+OOPGTFiRO3jKVOmADBhwgQWLlzI8ePHOXLkSKTiiYiIHVTStKKuc+qtl51GlBMRacsafU79CfA04SxsaQV4/ys6zqlHTe93ERERubao6SgnIiISEj9XjswU7PpRQkVdRETsrZKmFfUoOqeuw+8iIiI2oZa6iIjYW1MPn+vwu4iISCuhw+8iIiISbdRSFxERe2tqSzuKWuoq6iIiYm9+oCnDrEVRUdfhdxEREZtQS11EROytDbXUVdRFRMTeKmlaUa9qriAtT0VdRETszQ8EmrB+FBV1nVMXERGxCbXURUTE3tpQS11FXURE7K2SphX16uYK0vJ0+F1ERMQm1FIXERF78wPOJqwfRS11FXUREbG3NlTUdfhdRETEJtRSFxERe6ukaa3tpnSyCzMVdRERsbdKmnZcOoqKug6/i4iI2IRa6iIiYm9+2kxLXUVdRETsrRJwNGH9ptwMJsxU1EVExN78tJmirnPqIiIiNqGWuoiI2Jta6iIiIjZRiVXYQ50qWzZez549cTgcDU6vvPJKUM/V5lrqxkTRn1wiInJVjf0+L23i69SsX1pa/5ncbjdut7uJzw5/+ctf6N27N+vXr6dXr15UVFSQmZnJn//8Z8aMGRPUc7W5lvrp06cjHUFERJqBz+e75s9dLhepqalkAN4mTBnA9ddfT0ZGBl6vt3aaOXNms7yP4uJiYmNjGTp0KKmpqZw6dYpAIMCwYcOC/qOhzbXUO3ToAMCRI0fwer0RThO80tJSMjIyOHr0KB6PJ9JxghbN+aM5O0R3/mjODsrf3Iwx+Hw+0tPTr7lcfHw8hYWF+P3+ZnlNh6P+iflrFdycnBxmz559zefct28fPXr0YPfu3WRlZdU+365du0hOTiYlJSXonG2uqMfEWAcnvF5vq/jlDJXH41H+CInm7BDd+aM5Oyh/c2psoyw+Pp74+PgWTnOln/70pzzwwAPXXCYzMxOATz75hL59+9bO37VrV73HwWhzRV1ERKSlderUiU6dOjVq2U8++YR777239vGuXbvo379/SK/b5s6pi4iItBaBQIA9e/Zw8803187Lz8+na9euIT1fmyvqbreb3NzcZumxGAnKHznRnB2iO380Zwfll6vLz8+nvLy8XlHv27cvubm5bN68Oejncxhd4yUiImILba6lLiIiYlcq6iIiIjahoi4iImITKuoiIiI2YcuiPm/ePLp27Up8fDyDBg1i27Zt11z+rbfeokePHsTHx9O3b19Wr14dpqQNCyb//PnzGTZsGElJSSQlJTFq1Kivfb8tKdhtX2Pp0qU4HI5612pGQrD5S0pKmDx5MmlpabjdbrKysiL6+xNs/pdffpmbbrqJdu3akZGRwVNPPcXFixfDlPYrH3zwAWPGjCE9PR2Hw8HKlSu/dp2NGzfSv39/3G433bt3Z+HChS2e82qCzb98+XK++93v0qlTJzweD4MHD2bt2rXhCXuZULZ9jc2bNxMbG0u/fv1aLJ8EydjM0qVLjcvlMn/605/Mnj17zI9+9COTmJhoiouLG1x+8+bNxul0mpdeesns3bvXPPPMMyYuLs7s3r07zMktwebPzs428+bNMzt37jT79u0zDzzwgPF6vebYsWNhTh589hqFhYWmc+fOZtiwYeb73/9+eMI2INj8FRUVZsCAAWb06NHmww8/NIWFhWbjxo0mLy8vzMktweZfvHixcbvdZvHixaawsNCsXbvWpKWlmaeeeirMyY1ZvXq1mTZtmlm+fLkBzIoVK665fEFBgWnfvr2ZMmWK2bt3r5k7d65xOp1mzZo14Ql8mWDzP/HEE2b27Nlm27Zt5sCBA2bq1KkmLi7O7NixIzyB6wg2e42zZ8+azMxMc+edd5pbbrmlRTNK49muqA8cONBMnjy59nF1dbVJT083M2fObHD5sWPHmnvuuafevEGDBpkf//jHLZrzaoLNf7mqqiqTkJBgXnvttZaKeFWhZK+qqjJDhgwxf/jDH8yECRMiWtSDzf/b3/7WZGZmGr/fH66I1xRs/smTJ5uRI0fWmzdlyhQzdOjQFs35dRpTWH72s5+Z3r1715s3btw4c9ddd7VgssYJpjDW1atXLzNjxozmDxSEYLKPGzfOPPPMMyY3N1dFvRWx1eF3v9/P9u3bGTVqVO28mJgYRo0axdatWxtcZ+vWrfWWB7jrrruuunxLCiX/5crLy6msrKy9cU24hJr9ueeeIzk5mYcffjgcMa8qlPx/+9vfGDx4MJMnTyYlJYU+ffrw4osvUl1dHa7YtULJP2TIELZv3157iL6goIDVq1czevTosGRuitb0uW0OgUAAn88X9s9tqBYsWEBBQQG5ubmRjiKXsdXY76dOnaK6uvqKO9ukpKTw2WefNbhOUVFRg8sXFRW1WM6rCSX/5X7+85+Tnp5+xRdeSwsl+4cffsgf//hH8vLywpDw2kLJX1BQwIYNG/jhD3/I6tWrOXToEJMmTaKysjLsX3ah5M/OzubUqVPcdtttGGOoqqpi4sSJ/OIXvwhH5Ca52ue2tLSUCxcu0K5duwglC82cOXM4f/48Y8eOjXSUr3Xw4EFycnLYtGkTsbG2KiG2YKuWels3a9Ysli5dyooVKyJyV6Jg+Hw+xo8fz/z58+nYsWOk44QkEAiQnJzM73//e2699VbGjRvHtGnT+N3vfhfpaI2yceNGXnzxRV599VV27NjB8uXLWbVqFc8//3yko7Upb775JjNmzGDZsmUkJydHOs41VVdXk52dzYwZM8jKyop0HGmArf7M6tixI06nk+Li4nrzi4uLSU1NbXCd1NTUoJZvSaHkrzFnzhxmzZrFe++9V28M4XAJNnt+fj6ff/45Y8aMqZ0XCAQAiI2NZf/+/XTr1q1lQ9cRyrZPS0sjLi4Op9NZO69nz54UFRXh9/txuVwtmrmuUPI/++yzjB8/nkceeQSwxpsuKyvj0UcfZdq0abW3KW6Nrva59Xg8UdVKX7p0KY888ghvvfVW2I+uhcLn8/Hxxx+zc+dOHnvsMcD63BpjiI2NZd26dYwcOTLCKdu21vupDYHL5eLWW29l/fr1tfMCgQDr169n8ODBDa4zePDgessD/P3vf7/q8i0plPwAL730Es8//zxr1qxhwIAB4Yh6hWCz9+jRg927d5OXl1c7fe9732PEiBHk5eWRkZERzvghbfuhQ4dy6NCh2j9GAA4cOEBaWlpYCzqElr+8vPyKwl3zB4pp5beEaE2f21AtWbKEBx98kCVLlnDPPfdEOk6jeDyeKz63EydO5KabbiIvL49BgwZFOqJEuKNes1u6dKlxu91m4cKFZu/evebRRx81iYmJpqioyBhjzPjx401OTk7t8ps3bzaxsbFmzpw5Zt++fSY3Nzfil7QFk3/WrFnG5XKZt99+2xw/frx28vl8rT775SLd+z3Y/EeOHDEJCQnmscceM/v37zfvvPOOSU5ONi+88EJU5M/NzTUJCQlmyZIlpqCgwKxbt85069bNjB07NuzZfT6f2blzp9m5c6cBzK9//Wuzc+dOc/jwYWOMMTk5OWb8+PG1y9dc0vb000+bffv2mXnz5kX0krZg8y9evNjExsaaefPm1fvclpSUtPrsl1Pv99bFdkXdGGPmzp1rbrzxRuNyuczAgQPNRx99VPuz4cOHmwkTJtRbftmyZSYrK8u4XC7Tu3dvs2rVqjAnri+Y/F26dDHAFVNubm74g5vgt31dkS7qxgSff8uWLWbQoEHG7XabzMxM88tf/tJUVVWFOfVXgslfWVlppk+fbrp162bi4+NNRkaGmTRpkjl79mzYc7///vsN/h7X5J0wYYIZPnz4Fev069fPuFwuk5mZaRYsWBD23HWzBJN/+PDh11y+NWe/nIp666Jbr4qIiNiErc6pi4iItGUq6iIiIjahoi4iImITKuoiIiI2oaIuIiJiEyrqIiIiNqGiLiIiYhMq6iIiIjahoi4iImITKuoiIiI2oaIuEgVuv/12Hn/8cZ588kmSkpJISUlh/vz5lJWV8eCDD5KQkED37t159913Aete6Q6Hg7Vr1/Ltb3+bdu3aMXLkSE6cOMG7775Lz5498Xg8ZGdnU15eHuF3JyLNRUVdJEq89tprdOzYkW3btvH444/zk5/8hB/84AcMGTKEHTt2cOeddzJ+/Ph6RXr69Om88sorbNmyhaNHjzJ27Fhefvll3nzzTVatWsW6deuYO3duBN+ViDQn3dBFJArcfvvtVFdXs2nTJgCqq6vxer3cd999vP766wAUFRWRlpbG1q1buXjxIiNGjOC9997jjjvuAGDWrFlMnTqV/Px8MjMzAZg4cSKff/45a9asicwbE5FmpZa6SJS4+eaba//vdDq54YYb6Nu3b+28lJQUAE6cONHgOikpKbRv3762oNfMq7u8iEQ3FXWRKBEXF1fvscPhqDfP4XAAEAgEGlzn8uVr5tVdXkSim4q6iIiITaioi4iI2ISKuoiIiE2o97uIiIhNqKUuIiJiEyrqIiIiNqGiLiIiYhMq6iIiIjahoi4iImITKuoiIiI2oaIuIiJiEyrqIiIiNqGiLiIiYhMq6iIiIjahoi4iImITKuoiIiI28f8BXMCa/XxVHisAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -168,575 +233,74 @@ "# now create an object to hold everything we're eventually interested in\n", "reconstruction = Reconstruction(experimentalData, params)\n", "reconstruction.No = 2**10\n", - "reconstruction.nlambdaObject = 1\n", - "reconstruction.nlambdaProbe = len(reconstruction.spectralDensity)\n", + "reconstruction.nlambda = len(reconstruction.spectralDensity)\n", "\n", "# initialize probe and object and related params\n", - "reconstruction.initialProbe = 'circ'\n", - "reconstruction.initialObject = 'ones'\n", + "reconstruction.initialProbe = \"circ\"\n", + "reconstruction.initialObject = \"ones\"\n", "reconstruction.initializeObjectProbe()\n", "\n", "# # customize initial probe quadratic phase\n", - "reconstruction.probe = reconstruction.probe*np.exp(1.j*2*np.pi/reconstruction.wavelength *\n", - " (reconstruction.Xp**2+reconstruction.Yp**2)/(1*2e-2))\n", + "reconstruction.probe = reconstruction.probe * np.exp(\n", + " 1.0j\n", + " * 2\n", + " * np.pi\n", + " / reconstruction.wavelength\n", + " * (reconstruction.Xp**2 + reconstruction.Yp**2)\n", + " / (1 * 2e-2)\n", + ")\n", "\n", - "hsvmodeplot(np.squeeze(reconstruction.probe), pixelSize = reconstruction.dxp, axisUnit = 'mm')" + "hsvmodeplot(\n", + " np.squeeze(reconstruction.probe), pixelSize=reconstruction.dxp, axisUnit=\"mm\"\n", + ")" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 15, "id": "911f11ce", "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 0 \n", - "error: 19.4 \n", - "estimated linear overlap: 60.9 % \n", - "estimated area overlap: 76.5 % \n", - " \n", - "iteration: 1 \n", - "error: 19.4 \n", - "estimated linear overlap: 60.8 % \n", - "estimated area overlap: 76.3 % \n", - " \n", - "iteration: 2 \n", - "error: 19.1 \n", - "estimated linear overlap: 60.7 % \n", - "estimated area overlap: 76.2 % \n", - " \n", - "iteration: 3 \n", - "error: 19.0 \n", - "estimated linear overlap: 60.7 % \n", - "estimated area overlap: 75.9 % \n", - " \n", - "iteration: 4 \n", - "error: 19.1 \n", - "estimated linear overlap: 60.6 % \n", - "estimated area overlap: 75.4 % \n", - " \n", - "iteration: 5 \n", - "error: 18.8 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 75.4 % \n", - " \n", - "iteration: 6 \n", - "error: 19.0 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 75.4 % \n", - " \n", - "iteration: 7 \n", - "error: 19.0 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 8 \n", - "error: 19.1 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 75.1 % \n", - " \n", - "iteration: 9 \n", - "error: 18.9 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 75.2 % \n", - " \n", - "iteration: 10 \n", - "error: 19.0 \n", - "estimated linear overlap: 60.6 % \n", - "estimated area overlap: 74.8 % \n", - " \n", - "iteration: 11 \n", - "error: 19.0 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 74.7 % \n", - " \n", - "iteration: 12 \n", - "error: 19.1 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 74.8 % \n", - " \n", - "iteration: 13 \n", - "error: 19.3 \n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 74.8 % \n", - " \n", - "iteration: 14 \n", - "error: 19.2 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 75.0 % \n", - " \n", - "iteration: 15 \n", - "error: 19.3 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 74.7 % \n", - " \n", - "iteration: 16 \n", - "error: 19.3 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 74.8 % \n", - " \n", - "iteration: 17 \n", - "error: 19.3 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 74.7 % \n", - " \n", - "iteration: 18 \n", - "error: 19.4 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 74.5 % \n", - " \n", - "iteration: 19 \n", - "error: 19.4 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 74.4 % \n", - " \n", - "iteration: 20 \n", - "error: 19.5 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 74.4 % \n", - " \n", - "iteration: 21 \n", - "error: 19.7 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 74.4 % \n", - " \n", - "iteration: 22 \n", - "error: 19.7 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 74.8 % \n", - " \n", - "iteration: 23 \n", - "error: 19.7 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 74.4 % \n", - " \n", - "iteration: 24 \n", - "error: 19.8 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 74.3 % \n", - " \n", - "iteration: 25 \n", - "error: 19.8 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 73.9 % \n", - " \n", - "iteration: 26 \n", - "error: 19.7 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 74.3 % \n", - " \n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "iteration: 27 \n", - "error: 19.7 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 74.2 % \n", - " \n", - "iteration: 28 \n", - "error: 19.7 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 73.7 % \n", - " \n", - "iteration: 29 \n", - "error: 20.1 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 73.9 % \n", - " \n", - "iteration: 30 \n", - "error: 20.0 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 79.5 % \n", - " \n", - "iteration: 31 \n", - "error: 20.0 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 79.5 % \n", - " \n", - "iteration: 32 \n", - "error: 20.2 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 79.4 % \n", - " \n", - "iteration: 33 \n", - "error: 20.2 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 79.5 % \n", - " \n", - "iteration: 34 \n", - "error: 20.2 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 79.8 % \n", - " \n", - "iteration: 35 \n", - "error: 20.4 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 79.5 % \n", - " \n", - "iteration: 36 \n", - "error: 20.2 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 79.4 % \n", - " \n", - "iteration: 37 \n", - "error: 20.4 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 79.3 % \n", - " \n", - "iteration: 38 \n", - "error: 20.3 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 79.2 % \n", - " \n", - "iteration: 39 \n", - "error: 20.5 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 79.1 % \n", - " \n", - "iteration: 40 \n", - "error: 20.6 \n", - "estimated linear overlap: 60.5 % \n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ - "estimated area overlap: 79.6 % \n", - " \n", - "iteration: 41 \n", - "error: 20.7 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 79.2 % \n", - " \n", - "iteration: 42 \n", - "error: 20.7 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 79.1 % \n", - " \n", - "iteration: 43 \n", - "error: 20.9 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 79.1 % \n", - " \n", - "iteration: 44 \n", - "error: 20.8 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 79.0 % \n", - " \n", - "iteration: 45 \n", - "error: 20.8 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 78.5 % \n", - " \n", - "iteration: 46 \n", - "error: 21.0 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 78.8 % \n", - " \n", - "iteration: 47 \n", - "error: 21.0 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 79.0 % \n", - " \n", - "iteration: 48 \n", - "error: 21.1 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 78.5 % \n", - " \n", - "iteration: 49 \n", - "error: 21.1 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 78.9 % \n", - " \n", - "iteration: 50 \n", - "error: 21.0 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 78.5 % \n", - " \n", - "iteration: 51 \n", - "error: 21.1 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 78.9 % \n", - " \n", - "iteration: 52 \n", - "error: 21.2 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 78.7 % \n", - " \n", - "iteration: 53 \n", - "error: 21.0 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 78.5 % \n", - " \n", - "iteration: 54 \n" + "multiPIE: 100%|██████████| 100/100 [01:56<00:00, 1.17s/it]" ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "error: 21.3 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 78.6 % \n", - " \n", - "iteration: 55 \n", - "error: 21.4 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 78.3 % \n", - " \n", - "iteration: 56 \n", - "error: 21.3 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 78.1 % \n", - " \n", - "iteration: 57 \n", - "error: 21.5 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 78.5 % \n", - " \n", - "iteration: 58 \n", - "error: 21.5 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 78.1 % \n", - " \n", - "iteration: 59 \n", - "error: 21.5 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 78.7 % \n", - " \n", - "iteration: 60 \n", - "error: 21.7 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 78.1 % \n", - " \n", - "iteration: 61 \n", - "error: 21.6 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 78.2 % \n", - " \n", - "iteration: 62 \n", - "error: 21.6 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 77.8 % \n", - " \n", - "iteration: 63 \n", - "error: 21.6 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 78.1 % \n", - " \n", - "iteration: 64 \n", - "error: 21.4 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 77.8 % \n", - " \n", - "iteration: 65 \n", - "error: 21.7 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 77.9 % \n", - " \n", - "iteration: 66 \n", - "error: 22.1 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 77.8 % \n", - " \n", - "iteration: 67 \n", - "error: 21.8 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 77.8 % \n" - ] - }, - { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - " \n", - "iteration: 68 \n", - "error: 21.8 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 77.3 % \n", - " \n", - "iteration: 69 \n", - "error: 21.9 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 77.9 % \n", - " \n", - "iteration: 70 \n", - "error: 21.9 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 77.4 % \n", - " \n", - "iteration: 71 \n", - "error: 21.7 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 77.4 % \n", - " \n", - "iteration: 72 \n", - "error: 22.1 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 77.3 % \n", - " \n", - "iteration: 73 \n", - "error: 22.1 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 77.3 % \n", - " \n", - "iteration: 74 \n", - "error: 22.1 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 77.4 % \n", - " \n", - "iteration: 75 \n", - "error: 22.4 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 77.4 % \n", - " \n", - "iteration: 76 \n", - "error: 22.2 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 77.2 % \n", - " \n", - "iteration: 77 \n", - "error: 22.1 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 77.3 % \n", - " \n", - "iteration: 78 \n", - "error: 22.4 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 77.2 % \n", - " \n", - "iteration: 79 \n", - "error: 22.5 \n", - "estimated linear overlap: 60.3 % \n", - "estimated area overlap: 77.0 % \n", - " \n", - "iteration: 80 \n", - "error: 22.2 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 76.8 % \n", - " \n", - "iteration: 81 \n", - "error: 22.2 \n" + "INFO:multiPIE:switch to cpu\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 79.3 % \n", - " \n", - "iteration: 82 \n", - "error: 22.4 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 79.5 % \n", - " \n", - "iteration: 83 \n", - "error: 22.4 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 79.4 % \n", - " \n", - "iteration: 84 \n", - "error: 22.4 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 79.2 % \n", - " \n", - "iteration: 85 \n", - "error: 22.5 \n", - "estimated linear overlap: 60.3 % \n", - "estimated area overlap: 79.5 % \n", - " \n", - "iteration: 86 \n", - "error: 22.5 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 79.4 % \n", - " \n", - "iteration: 87 \n", - "error: 22.5 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 79.1 % \n", - " \n", - "iteration: 88 \n", - "error: 22.7 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 78.9 % \n", - " \n", - "iteration: 89 \n", - "error: 22.7 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 79.1 % \n", - " \n", - "iteration: 90 \n", - "error: 22.6 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 78.9 % \n", - " \n", - "iteration: 91 \n", - "error: 22.6 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 79.2 % \n", - " \n", - "iteration: 92 \n", - "error: 22.7 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 78.9 % \n", - " \n", - "iteration: 93 \n", - "error: 22.8 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 79.1 % \n", - " \n", - "iteration: 94 \n", - "error: 22.8 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 78.9 % \n", - " \n" + "\n" ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "iteration: 95 \n", - "error: 22.7 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 78.9 % \n", - " \n", - "iteration: 96 \n", - "error: 23.0 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 79.2 % \n", - " \n", - "iteration: 97 \n", - "error: 22.9 \n", - "estimated linear overlap: 60.5 % \n", - "estimated area overlap: 78.9 % \n", - " \n", - "iteration: 98 \n", - "error: 22.9 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 78.6 % \n", - " \n", - "iteration: 99 \n", - "error: 22.9 \n", - "estimated linear overlap: 60.4 % \n", - "estimated area overlap: 78.4 % \n", - "multiPIE: 100%|██████████████████████████████████████████████████████████████████████| 100/100 [03:36<00:00, 2.17s/it]\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -752,7 +316,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 16, "id": "cfed4f32", "metadata": {}, "outputs": [], @@ -760,19 +324,11 @@ "# now save the data\n", "# reconstruction.saveResults('reconstruction.hdf5')" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c0120b14", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "ptylab", "language": "python", "name": "python3" }, @@ -786,7 +342,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.13.12" } }, "nbformat": 4, diff --git a/jupyter_tutorials/jupyter_tutorials_tutorial_CPM_sim.ipynb b/jupyter_tutorials/jupyter_tutorials_tutorial_CPM_sim.ipynb index d0854bdc..97a4686c 100644 --- a/jupyter_tutorials/jupyter_tutorials_tutorial_CPM_sim.ipynb +++ b/jupyter_tutorials/jupyter_tutorials_tutorial_CPM_sim.ipynb @@ -4,20 +4,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# ptyLab simulation tutorial\n", - "At this point it is assumed that ptyLab has already been successfully installed. In this short tutorial we will simulate a conventional ptychography experiment. To simulate a ptychography experiment the following steps have to be performed.\n", + "# 01 – CPM Simulation\n", "\n", - "1. The geometry of the experiment needs to be specified. The following variables need to be defined.\n", - " - Wavelength of the illuminating beam\n", - " - Sample to detector distance (z0)\n", - " - Detector pixel number (Nd)\n", - " - Detector pixel size (dxd)\n", - "2. The illuminating beam (which we refer to as probe) has to be defined \n", - "3. The object to be simulated needs to be defined\n", - "4. The scan grid, i.e. the coordinates with which the object is scanned, must be generated.\n", - "5. For each position a diffraction pattern needs to be calculated.\n", + "This tutorial introduces conventional ptychographic microscopy (CPM) by simulating a complete experiment from scratch. Starting from experimental geometry (wavelength, detector size, pixel size, sample-detector distance), a synthetic probe and object are defined, diffraction patterns are computed, and the object is then reconstructed using the ePIE engine.\n", "\n", - "Finally, at the end of this tutorial, the object is reconstructed from the created diffraction images." + "**What you'll learn:**\n", + "\n", + "- How to define CPM experimental geometry\n", + "- How to simulate a ptychogram from a known object and probe\n", + "- How to run a basic reconstruction with `easyInitialize` and `ePIE`" ] }, { @@ -31,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -58,7 +53,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -96,7 +91,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -117,7 +112,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -126,13 +121,13 @@ "Text(0.5, 1.0, 'probe intensity')" ] }, - "execution_count": 34, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2MAAAGJCAYAAAAHcevEAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs/Xn8LkdVJ46/q/v5LHfJvdkTgkACgsgiaCCRzbDJTcyIEZBFNCE6Q4YdMiMDjN+EoGNeII6IQZaX8xIV0BB8DfwQyICRRTGCYVNBEMIqISEs2e7y+XyervP7o+pUnTp9qp/n+WS59+b2ubc/3U93LadOVXWfd52qU46ICCONNNJII4000kgjjTTSSCPdodTsbwZGGmmkkUYaaaSRRhpppJEORRrB2EgjjTTSSCONNNJII4000n6gEYyNNNJII4000kgjjTTSSCPtBxrB2EgjjTTSSCONNNJII4000n6gEYyNNNJII4000kgjjTTSSCPtBxrB2EgjjTTSSCONNNJII4000n6gEYyNNNJII4000kgjjTTSSCPtBxrB2EgjjTTSSCONNNJII4000n6gEYyNNNJII4000kgjjTTSSCPtBxrB2Egj3Up661vfCuccvv71r+9vVm43etaznoXt27fvbzZGGmmkke60xN+Sq6666nbN5yMf+Qicc/jIRz5yu+ZzR9DXv/51OOfw1re+dX+zMtJIm6YRjI000kgjjTTSSCONNJOuueYavPKVr8RnP/vZ/c1Kld7//vfjla985f5mY6SR5qbJ/mZgpJFGGmmkkUYaaaQ7hn7mZ34Ge/fuxfLy8sJxr7nmGlx00UU48cQT8eAHP/i2Z25Busc97oG9e/diaWkp3Xv/+9+PN7zhDSMgG+mgodEyNtJIhyDt27cP3vv9zcZII4000p2WvPfYt2/f/majR03TYHV1FU1z8KuAzjmsrq6ibdv9zcpII22aDv6eONKdir797W/j13/913HCCSdgZWUFJ510Ep7znOdgfX09hfnqV7+KX/qlX8KRRx6JrVu34qd/+qfxvve9r0iH58S/853vxEUXXYS73vWuOOyww/CUpzwFN954I9bW1vDiF78Yxx57LLZv345zzz0Xa2trRRrOOTz/+c/H29/+dvzYj/0YVldXcfLJJ+NjH/vYXGX5wAc+gEc96lHYtm0bDjvsMJx55pn4/Oc/n57/7d/+LZqmwQUXXFDEe8c73gHnHN74xjcOpv/oRz8aD3jAA/CpT30KD3/4w7FlyxacdNJJeNOb3mTK4i//8i/xm7/5m7jrXe+KrVu34qabbgIAXHbZZTj55JOxZcsWHH300fiVX/kVfPvb3zbz/OpXv4pdu3Zh27ZtOOGEE/CqV70KRFSE8d7jda97He5///tjdXUVxx13HM477zz88Ic/nEtuI4000kgHCr3yla+Ecw5f/OIX8dSnPhU7duzAUUcdhRe96EU9oCW/Gfe///2xsrKCyy+/HADwmc98BmeccQZ27NiB7du343GPexz+8R//0cxzz549OO+883DUUUdhx44dOPvss83356xvTI2sNWP8PfnCF76AxzzmMdi6dSvuete74jWveU0R76EPfSgA4Nxzz4Vzrrde6xOf+AROP/107Ny5E1u3bsVpp52Gj3/846ZMv/KVr+BZz3oWDj/8cOzcuRPnnnsu9uzZU4T90Ic+hEc+8pE4/PDDsX37dvzYj/0YXvGKV6Tnes3Ys571LLzhDW8AgMSfcw5EhBNPPBG/8Au/0JPHvn37sHPnTpx33nkzZTfSSLcHjdMURzpg6JprrsEpp5yCG264Ac9+9rNx3/veF9/+9rfxrne9C3v27MHy8jKuu+46PPzhD8eePXvwwhe+EEcddRT+9E//FE984hPxrne9C7/4i79YpHnxxRdjy5YteNnLXoavfOUr+MM//EMsLS2haRr88Ic/xCtf+Ur84z/+I9761rfipJNO6gGjj370o7j00kvxwhe+ECsrK/ijP/ojnH766fjkJz+JBzzgAdWy/Pmf/znOOecc7Nq1C69+9auxZ88evPGNb8QjH/lIfOYzn8GJJ56Ixz72sXjuc5+Liy++GGeddRZ+6qd+Ct/5znfwghe8AI9//OPxX//rf50psx/+8If4uZ/7OTz1qU/FM57xDLzzne/Ec57zHCwvL+PXfu3XirC/9Vu/heXlZfz3//7fsba2huXlZbz1rW/Fueeei4c+9KG4+OKLcd111+EP/uAP8PGPfxyf+cxncPjhh6f4Xdfh9NNPx0//9E/jNa95DS6//HJceOGFmE6neNWrXpXCnXfeeSndF77whfja176GSy65BJ/5zGfw8Y9/vJhOMtJII410MNBTn/pUnHjiibj44ovxj//4j3j961+PH/7wh/izP/uzItzf/u3f4p3vfCee//zn4+ijj8aJJ56Iz3/+83jUox6FHTt24KUvfSmWlpbw5je/GY9+9KPx0Y9+FKeeemqRxvOf/3wcfvjheOUrX4kvfelLeOMb34hvfOMbCUQB831jFqUf/vCHOP300/GkJz0JT33qU/Gud70L/+N//A888IEPxBlnnIEf//Efx6te9SpccMEFePazn41HPepRAICHP/zhqexnnHEGTj75ZFx44YVomgZ/8id/gsc+9rH4u7/7O5xyyik9mZ500km4+OKL8elPfxp//Md/jGOPPRavfvWrAQCf//zn8Z/+03/CT/zET+BVr3oVVlZW8JWvfKUH7iSdd955uOaaa/ChD30If/7nf57uO+fwK7/yK3jNa16DH/zgBzjyyCPTs/e+97246aab8Cu/8isLy2ykkW4TopFGOkDo7LPPpqZp6J/+6Z96z7z3RET04he/mADQ3/3d36VnN998M5100kl04oknUtd1RET04Q9/mADQAx7wAFpfX09hn/GMZ5Bzjs4444wi/Yc97GF0j3vco7gHgADQVVddle594xvfoNXVVfrFX/zFdO9P/uRPCAB97WtfS/wcfvjh9F/+y38p0rv22mtp586dxf3du3fTj/7oj9L9739/2rdvH5155pm0Y8cO+sY3vjFTXqeddhoBoN/7vd9L99bW1ujBD34wHXvssancLIt73vOetGfPnhR2fX2djj32WHrAAx5Ae/fuTff/+q//mgDQBRdckO6dc845BIBe8IIXpHveezrzzDNpeXmZrr/+eiIi+ru/+zsCQG9/+9sLXi+//HLz/kgjjTTSgUwXXnghAaAnPvGJxf3nPve5BIA+97nPpXsAqGka+vznP1+EPeuss2h5eZmuvvrqdO+aa66hww47jH7mZ34m3eNvycknn1x8t17zmtcQAHrPe95DRIt9Yyzib8KHP/zhdI+/J3/2Z3+W7q2trdHxxx9PT37yk9O9f/qnfyIA9Cd/8idFmt57uve97027du1K32sioj179tBJJ51EP/uzP5vusUx/7dd+rUjjF3/xF+moo45Kv3//93+fAKTvi0Vf+9rXevw873nPI0u9/dKXvkQA6I1vfGNx/4lPfCKdeOKJBd8jjXRH0jhNcaQDgrz3ePe7342f//mfx0Me8pDecx4NfP/7349TTjkFj3zkI9Oz7du349nPfja+/vWv4wtf+EIR7+yzzy4sMaeeeiqIqGc1OvXUU/Gtb30L0+m0uP+whz0MJ598cvp997vfHb/wC7+A//f//h+6rjPL8qEPfQg33HADnvGMZ+B73/teOtq2xamnnooPf/jDKezWrVvx1re+Ff/2b/+Gn/mZn8H73vc+/P7v/z7ufve7zxIZAGAymRRTK5aXl3Heeefhu9/9Lj71qU8VYc855xxs2bIl/b7qqqvw3e9+F8997nOxurqa7p955pm4733v25v6CYQRWyaekrO+vo6/+Zu/ARCmPO7cuRM/+7M/W5T95JNPxvbt24uyjzTSSCMdLPS85z2v+P2CF7wAQPgmSTrttNNwv/vdL/3uug4f/OAHcdZZZ+Ge97xnun+Xu9wFv/zLv4y///u/T1PGmZ797GcX363nPOc5mEwmKa9FvjGL0Pbt2wvr0PLyMk455RR89atfnRn3s5/9LL785S/jl3/5l/H9738/8bR792487nGPw8c+9rHeOmU9++NRj3oUvv/97yd58MyM97znPbfJGuf73Oc+OPXUU/H2t7893fvBD36AD3zgA3jmM5+Z9IyRRrqjaQRjIx0QdP311+Omm24anPoHAN/4xjfwYz/2Y737P/7jP56eS9KgZufOnQCAu93tbr373nvceOONxf173/vevbzuc5/7YM+ePbj++utNHr/85S8DAB772MfimGOOKY4PfvCD+O53v1uEf8QjHoHnPOc5+OQnP4ldu3b1gOIQnXDCCdi2bVuPPwC9fc9OOumk4jfLypLnfe97354sm6YplAkrry9/+cu48cYbceyxx/bKfsstt/TKPtJII410MJD+FtzrXvdC0zQz37PXX3899uzZU/1uee/xrW99azCv7du34y53uUvxngXm/8bMSz/yIz/SAyRHHHHEXOt9madzzjmnx9Mf//EfY21trfd91d/nI444AgBSfk972tPwiEc8Av/5P/9nHHfccXj605+Od77znbcKmJ199tn4+Mc/nr5vl112GTY2NvCrv/qrm05zpJFuLY1rxka6U1PNw1LtPilnFJsh/lD8+Z//OY4//vje88mk7HZra2tpIfXVV1+NPXv2YOvWrbeaD03SKnZ7kfcexx57bDHyKOmYY4653XkYaaSRRrq9qWZFuaPes8D835h56dZ8F5mn3/3d3626vN++fftC+W3ZsgUf+9jH8OEPfxjve9/7cPnll+PSSy/FYx/7WHzwgx/clAfFpz/96XjJS16Ct7/97XjFK16Bt73tbXjIQx5iguWRRrqjaARjIx0QdMwxx2DHjh3413/918Fw97jHPfClL32pd/+LX/xien5bEo/2Sfr3f/93bN26tQos7nWvewEAjj32WDz+8Y+fmceFF16If/u3f8NrX/ta/I//8T/wspe9DK9//evn4u+aa67B7t27C+vYv//7vwPAzAXcLKsvfelLeOxjH1s8+9KXvtSTpfceX/3qV5M1zMrrXve6F/7mb/4Gj3jEI+4QpWSkkUYa6Y6gL3/5y4XV6ytf+Qq89zPfs8cccwy2bt1a/W41TdObqfHlL38Zj3nMY9LvW265Bd/5znfwcz/3cwAW/8bcllQDoczTjh07blOemqbB4x73ODzucY/D//7f/xu/8zu/g//5P/8nPvzhD1fzGZpueOSRR+LMM8/E29/+djzzmc/Exz/+cbzuda+7zfgdaaTN0DhNcaQDgpqmwVlnnYX3vve9uOqqq3rPeaTs537u5/DJT34SV155ZXq2e/duvOUtb8GJJ55YzNW/LejKK6/Epz/96fT7W9/6Ft7znvfgCU94QnVUbteuXdixYwd+53d+BxsbG73ncnrjJz7xCbz2ta/Fi1/8Yvy3//bf8Bu/8Ru45JJL8NGPfnQu/qbTKd785jen3+vr63jzm9+MY445pljrZtFDHvIQHHvssXjTm95UuPX/wAc+gH/7t3/DmWee2YtzySWXpGsiwiWXXIKlpSU87nGPAxC8Y3Vdh9/6rd8yeb3hhhvmKtdII4000oFE7C6d6Q//8A8BAGecccZgvLZt8YQnPAHvec97iimN1113Hd7xjnfgkY98JHbs2FHEectb3lJ8O974xjdiOp2mvBb5xtzWxAN/+l1+8skn4173uhde+9rX4pZbbrlNePrBD37Qu8dWN70VzTw8Mv3qr/4qvvCFL+A3fuM30LYtnv70py/M20gj3ZY0WsZGOmDod37nd/DBD34Qp512Gp797Gfjx3/8x/Gd73wHl112Gf7+7/8ehx9+OF72spfhL/7iL3DGGWfghS98IY488kj86Z/+Kb72ta/hr/7qr27zTSwf8IAHYNeuXYVrewC46KKLqnF27NiBN77xjfjVX/1V/NRP/RSe/vSn45hjjsE3v/lNvO9978MjHvEIXHLJJdi3bx/OOecc3Pve98b/+l//K6X73ve+F+eeey7+5V/+pbceTNMJJ5yAV7/61fj617+O+9znPrj00kvx2c9+Fm95y1tmupBfWlrCq1/9apx77rk47bTT8IxnPCO5tj/xxBPxkpe8pAi/urqKyy+/HOeccw5OPfVUfOADH8D73vc+vOIVr0hWwtNOOw3nnXceLr74Ynz2s5/FE57wBCwtLeHLX/4yLrvsMvzBH/wBnvKUp8yU+0gjjTTSgURf+9rX8MQnPhGnn346rrzySrztbW/DL//yL+NBD3rQzLi//du/nfbLeu5zn4vJZII3v/nNWFtbK/bxYlpfX8fjHvc4PPWpT8WXvvQl/NEf/REe+chH4olPfCKA+b8xtwfd6173wuGHH443velNOOyww7Bt2zaceuqpOOmkk/DHf/zHOOOMM3D/+98f5557Lu5617vi29/+Nj784Q9jx44deO9737tQXq961avwsY99DGeeeSbucY974Lvf/S7+6I/+CD/yIz9SOPHSxAORL3zhC7Fr164e4DrzzDNx1FFH4bLLLsMZZ5yBY489dnPCGGmk24r2pyvHkUbS9I1vfIPOPvtsOuaYY2hlZYXuec970vOe9zxaW1tLYa6++mp6ylOeQocffjitrq7SKaecQn/9139dpMOuey+77LLiPrsO1u7z2dWudKELgJ73vOfR2972Nrr3ve9NKysr9JM/+ZOFO2CZJru2lzzs2rWLdu7cSaurq3Sve92LnvWsZyVX+S95yUuobVv6xCc+UcS76qqraDKZ0HOe85xBWZ122ml0//vfn6666ip62MMeRqurq3SPe9yDLrnkkrlkwXTppZfST/7kT9LKygodeeSR9MxnPpP+4z/+owhzzjnn0LZt2+jqq6+mJzzhCbR161Y67rjj6MILL0zbCUh6y1veQieffDJt2bKFDjvsMHrgAx9IL33pS+maa64ZLNNII4000oFE/G34whe+QE95ylPosMMOoyOOOIKe//znF1uCEOVvhkWf/vSnadeuXbR9+3baunUrPeYxj6F/+Id/KMLwt+SjH/0oPfvZz6YjjjiCtm/fTs985jPp+9//fi/NWd+YGtVc29///vfvhT3nnHN627685z3vofvd7340mUx6buU/85nP0JOe9CQ66qijaGVlhe5xj3vQU5/6VLriiitSGOt7K8vP39IrrriCfuEXfoFOOOEEWl5ephNOOIGe8Yxn0L//+7+nOJZr++l0Si94wQvomGOOIeec6eaetyZ4xzveMSirkUa6I8gR3QYeC0Ya6U5Izjk873nPu91GGG8tPfrRj8b3vve9mevsRhpppJFG2hy98pWvxEUXXYTrr78eRx999P5mZ6TbiF7ykpfg//yf/4Nrr732dnGYNdJIi9C4ZmykkUYaaaSRRhpppEOC9u3bh7e97W148pOfPAKxkQ4IGteMjTTSSCONNNJII410p6bvfve7+Ju/+Ru8613vwve//3286EUv2t8sjTQSgBGMjTTSSCONNNJII410J6cvfOELeOYzn4ljjz0Wr3/966v7oY000h1NB8Q0xTe84Q048cQTsbq6ilNPPRWf/OQnB8NfdtlluO9974vV1VU88IEPxPvf//7iORHhggsuwF3uchds2bIFj3/84839okYaaYgoum4/UOkjH/nIuF5spJFuJxq/SyMBYc0YEY3rxe4E9OhHPxpEhOuuuw7Pf/7z9zc7Ix2A9LGPfQw///M/jxNOOAHOObz73e++Q/Ld72Ds0ksvxfnnn48LL7wQn/70p/GgBz0Iu3btwne/+10z/D/8wz/gGc94Bn79138dn/nMZ3DWWWfhrLPOKpTS17zmNXj961+PN73pTfjEJz6Bbdu2YdeuXdi3b98dVayRRhpppJEOUhq/SyONNNJIhx7t3r0bD3rQg3r7Ct7utB89ORIR0SmnnFK4gu26jk444QS6+OKLzfBPfepT6cwzzyzunXrqqXTeeecREZH3no4//nj63d/93fT8hhtuoJWVFfqLv/iL26EEI4000kgjLUr3ve99CYB5/OEf/uF+5W38Lo000kgjHdoEgP7v//2/d0he+3XN2Pr6Oj71qU/h5S9/ebrXNA0e//jH48orrzTjXHnllTj//POLe7t27UqmxK997Wu49tpr8fjHPz4937lzJ0499VRceeWV5k7ra2trxW7u3nv84Ac/wFFHHQXn3K0p4kgjjTTSfiUiws0334wTTjhh5qbo+/btw/r6+qbz0e/LlZUVrKysmOH/6q/+Cve///1xxRVX4H73ux/W1tZwz3veE5deeil+/ud/flM83BZ0oHyXgPHbNNJII9156UD9Nu0P2q9g7Hvf+x66rsNxxx1X3D/uuOPwxS9+0Yxz7bXXmuGvvfba9Jzv1cJouvjii3HRRRdtqgwjjTTSSAcDfetb38KP/MiPVJ/v27cPJ23ZhmvhN5X+9u3bccsttxT3LrzwQrzyla80w1933XWYTCZ4xCMegZWVFXzqU5+C9x6PetSj9utH8kD5LgHjt2mkkUa689Nc36aTThp8Vw7Rot+m/UGjN0UAL3/5y4tRzRtvvBF3v/vdw4o6hzBxBsiTaBQ5uHSVifpBG5fTbEQUJ6OSyIsAH687AD5EawE0cJigRQOHFi7944Qo/utAmILgQdhAF9SsxgFtk88F2wR4CufpFOgyuy7mXbArxOKR2dWiYv4CvyXHknzktQMxt8BSG3l14eziuceADwx0XeCffCiLi5w4EvJ3sTCiTvRIc0qXcn3IOhHVxVWprx3FayEUJ1iyiFxMVgg+ydOVci2Skc2QD5YXl1MzSvGPF+XsKLc5malzQNPGc2w/jagLJ9LkdtTFOph6wHs4NJigQRPbglX/BIKHj9fhrIvZqLPVJr064ABMYlti/iV1kWfvA78AltCghUOLBku9Vst9nDCN3E7h0UWOp5wnd5qGGVYtRb9fvL7ul78UtuSlFzAFO+yww3SIgtbX13EtPL6FE7BjweXEN8Hjbrdcg29961vYsWNHuj8Eqv7lX/4F97nPfVKYz33uczj22GN7gOVQptq3qWkaOOdAsW0QUbqWxKPBclS4Fo6Ptm179yRxXt57EBG6rgMRoWmadEwmEzRNg7Zte2lw/K7rMJ1O4b3HxsYGiCiFb9s28SHjee/hvcd0Ok2j3c65Ii9J3od+zDxyGpJ4RL5t2yRXPUovy8s8cFmdc5hMJimeLiuH50OmJeuH+ZdyZD6s+uM0ZHqyHVj1rNPQ11Z963g6vObPIn7O8pEylvesvGQ7k3LU6et2YKUr0+I2wWnJuh+qfx1P8iDTsPqPbA8yDW7vVt7e+5QnnyeTSYrDfU3KmeuIZcbl5WvOU5bXkr+uB+a39r6xSIeTbYbTmevbdO21+OY3v1l8X+ahm266CXe/+90X+jbtD9qvYOzoo49G27a47rrrivvXXXcdjj/+eDPO8ccfPxiez9dddx3ucpe7FGFqbkyr5koLYwFKAXdCOXJWEJXG0EuL6pmxTg0EbR1O6PcWrJF5kfhNWTlPCTqVrQjvKAEKrfRKnMo3ZY6OtBy0yhzulVxSvMPlToU24goGiDMrISBAQV7MDOXbQY7iLEvAyfgYn9MnwRsVMfolU41gqIYsztO9yLNDVQohrCwbp+IFWCJLfjES6XJanEokqOJp5uQLOAFdV7SAfEdmR+kJoSxQimc0V5muZCPdLxqwK8F3au6keJX9JrRMyQfzluGQzITgXOqqqv/3+0CdYn8VbU1zIcMW/VE1rnmnte3A6sJgLMJd7NixY+6P5T//8z/jgQ98YPr9uc99rvi9v+hA+S4B9W+TVmi0EsbPFlGWZyniQ3EtYkVrSMmbJz2rbBbfuqwWaBiS1SK8zEMaHM0Tfp64lpK8CBCz0rLaSQ3AD9XHUD5y8ECXoxZHApaaLGrtayhvi6y2NNRGZZpDfUe3Pd1W5X0rjvytScqwBmZ12Fodz0O6zNZzmZeVt9VP5+XjsMMOmwncNHHei3yb9gftV2+Ky8vLOPnkk3HFFVeke957XHHFFXjYwx5mxnnYwx5WhAeAD33oQyn8SSedhOOPP74Ic9NNN+ETn/hENc0qUeW6Gqgks3lpZTchKnF/4J0RHvM/xMFzikd5ncPqJOOdBGDQP88uXq8I1v0yfMl3Pz6lcEVq3LHZMsVWF0/lPeu5TENmnMIgW4T4moXnVRz9XB9KOFRhPz0zohPyD9Lp1ISteZynnLJ8RZmtssn2IuSbfntxzeEFcxzfYL08c9ug3rOh66ocZwUo2r+4Tlzo6JT6G8V+lppFet4v52B9ycrt1S0V8ctBi1oGBs143KclAMsLHkuLZoJ//ud/xk/8xE+k35/73OeK3/uLDvjvErCQIjxPeKnM10BBTdmfFV5bh2oAosbzvIBGh6/9rsmjVk7rt3XNZ1nOoaMmL22B0/cseVrxh+qzVoezyj4UxlLAh9qBVZZaO7GezeJnyHI4xP+sOtf3hn4P9ZtF0rPqa6ivWTIfonna521Nm0lzVp8a6msHOu33aYrnn38+zjnnHDzkIQ/BKaecgte97nXYvXs3zj33XADA2Wefjbve9a64+OKLAQAvetGLcNppp+H3fu/3cOaZZ+Iv//IvcdVVV+Etb3kLgIC2X/ziF+O3f/u3ce973xsnnXQS/r//7//DCSecgLPOOmtxBoc0QHFbj+/3IqTLONLvoYbzqXic7hlJsALokuqXQ2RLg1QcvVAvM7dFvpwwSSXbLqv+zdG8UzqlyoaL5kFwIDRw8L1JVz1NNSZOgGtyZmzZYz6J4vQ6yiAD1LNOURZeIBflkeSgLF8U6wqUwZ2sCORoZp8XUVy8UDVQVrnkU2VR/K61y8JCxXICCjOlUxEJ5VRMAcicqkiCSAe+NDuxVUm2IQnaQMKWRCBR/1zbPlpYJCALlioy5eFju5p7VCnxAkOG4pkLYUPvCQ3GowH3MclR7md5QIRU8j2QVSAr0Y4BNjLlsAXZkKzX9A7w74/3Hp///OdxwQUXpHtXX301nvSkJ+1HrjId8N8l9JWzWhhrtFqHl2G898UIvpVGTdEHkJQ/a3RfxrEUa5mWvmeBD523vlezqsyy1kkZWOVlmXAeTdMUcWS4Ib5rZZbp13gdsohJmVvl1/lpC42+r8NLHnUYi1fLosK/a9MUuYzzTo3TdWfxWANhVvvWaWpZW1bTmpz17xovkncd3kqXKExd1P2Vnw9Nz9W8zarzIYAzyyJm/Z7HWrk/6JZbbsFXvvKV9PtrX/saPvvZz+LII48My5duJ9rvYOxpT3sarr/+elxwwQW49tpr8eAHPxiXX355WjfwzW9+s5hD+/CHPxzveMc78Ju/+Zt4xStegXvf+95497vfjQc84AEpzEtf+lLs3r0bz372s3HDDTfgkY98JC6//HKsrq4uxpzUmnvalQ6agVCOYKSXtHGh9DHVLLUib0JYyuOi6ueiQtufqJhVXlYOC5U/KsfwLk/XAgwFumROpJDy4C7OM/r6c8NylgQCUZyzLPhmDvL6IB/KyEAhIZkYMk0xowwmIqCQohUGeQAE32X9N01La2JFS7Qk5U4inxoxO6oOKf0JZyeCMwwt1WuhyJOILxGbSNzBuF/wJTJt0G93SdwlGCiqUWYZAQpxQ2xcLnSxjo8qbckVNczF4oNBTa4jgKcNcqiUHJXLOuOs+TpcSZkImchQnCifgQTESAx9yJ7GdZatZNR3f1F0Guu9QEY4V6lX+VIyog0HnZOWERa6LULdQqGvvvpq7Nmzp7CEPfCBD8SFF16Ik08+GY94xCMWzP+2pQP6u4SsZPL1LCW1NuVM3tNK5jzTmWoghmne9UAWH7pcNasIp815ayDEz7gc1nogPmvFVivyGkxyWjKe5FfyLcmSJ6/lsXi1wIKUnQXahkiDE1nn1poezsMCe4tOW5S8cnxZJxYY0LzOAiycZm3aoQQpVnzdbnQ7BdBrRzKcztcqm+RHAzHdX622p/m2ZKIti1J+NQBt8TYUjp/NGuAYCjsvzXrX1eIsQldddRUe85jHpN+8Zvecc87BW9/61oXSWoQcHYjQdD/TTTfdhJ07d4YfM/BVCFJvWHl8X4SR5pp5wJjMO+uJ0QFC6QjBUuzZLtZxAHa6wNalIp8MauB9VHhzHspGkhTnkA+yAt1IjlwP1LA1Q4MxEukyMCN2etAIfgfAWCOsbVpt9qJGCuDYk0M8C2cdGUbUyVqWpdN0yG0m/xV8ietZyvSQI5CQFstLHZp8rhc+lwA/g3FZ77ktAckKB4h68bnOU703hQz6YAxlnaRvHoMlJCtlTlPKNKeLmGbHv1rR7rUDD0Z5RMHKioDTmdcmFa5Y1VjIg8GkgbrrZKGpoiExCMx/rURmtc4bb7xxcM48v/duxE9hx4Jg7CZ02IlPz8xjpFtH8ts0C2DpMJpqSpy8N4/SpBXamiJcAxRAVi4tBw9MluMD6fBAhtfWAM6z5qjAGum3FHkNgiSvVljmWwOFGg8WUKnJfDOKqeRhFhir5cnXMvytUSOtOhnKc946HAJjlqXLCj9kldOyku1NytMC1LotybwtxzU6vORzlpMXPmswtkjf1tf69zzvGU2y3cz7bfre9763KQceRx999AH/bdrvlrEDnuZ6x5BxZYWJaiIJJVdiNX7pWGm5+EcAHbYseIjpeBT/xHNSbOWZR/9JgBsZP03H68NMUgo0IBToBPAyj8mqwcp5TJ+IYjaUlOlSVgJ3cUk8gRS/LqbpUCrmIZ6cUBagVCNBTxQDY8USHrmUvpaCBLxSCWe5V4GUS0GSei3BTq8V1fXu9LgEChnY6naYP2hAVtzFUIGo6xK3ybskyhvLEesSTuAHwbfjFiOFlqSV2xKPG1MCdQIsNTm11I5Y+p7LJq3DRWZFKYinnDrKDEsAqWSfZ7QSPDeWZF0UoC9dC+nzR8jn2uiLyPUqiwav+2nd9rSExT8N09uDkZEG6PYaIZ6lkOtrDqutGxzGGiG3FFudjwZSNWVXp6ktCVJhlYp8TTkG+uBwiFcOP2Qh0or+EBirpaEtlTUQbVl8aunNY/20ws+qPw3uhuLOUvJ1fVlAXdd5rdwWD0N1YQFkCX50elL+EhDV6kq3Qas+LAAs4wz1CSbZjjVQG4pbs3ZpmheYzZPWrDi3t2Vsf9EIxjZJsrnNU9VZbXOGoouECtRrSSj2AjiJ69RRBZhDVI5Nhgs9lXIcvpf0UZd4zFHEh88AZUmBlgq1ZID11AQ6M3KRy7gKlqWIADjKcThzDR6yxa0sdAkAskVPi8sV/zRkkmlJ66B2wM4MC9nwbyXyPjklDCpOIlQCYvxPWoi4nKm8lHlmNjQAk+nKe/yEijTDNc9EZNwtMFCZRrzITU7UQQoTI8ntBorKcQHcNBxJ9xvV5sCA0BXtDRHcm8iVo0YBpa7ikAO7GIB5hDgzaOTC9urNlm2WSOIQrrhTkrwv07v1n55lLP5p2K++oEYSNM8UpKG41oi/TktbVYYsYDL8EMioKZ9W/Bqg0bzx71lgSPJiKdLzArJamjULmlU+VspnycsClpyWNa2uRvMqz1acIauH5NFy+c/nobbBaVl1V7MEaUAtqQZ4dDp8LdOw2hDXkzzr8s1DFuCq1X1tUEPzYYFYnY8GUbMAYY0vqyy3B41gbKRbTaz4ssqSp9JplCSVfJen6vFz58IeSUn7EioYAWHo3+W1OgYVQFIGoTKMxZtUGol/S8BRHDKaUEpZkTa+XQVvrrxf6PlUhg+ydYWMZRlI2CxIxAz3XHEngxE98U2nxfXjIhxwIJFDVtKFnBIC6ivpubAyXuYyC4YTYa4aMWVVRs3xCvBZwEgOn6XSB2hsXyTxS7aByBYXS9WbVbQUvniojqYSScrF8ei5zK2Eo7J+EtfUT6/HW7/Zl227GHBwOaJO20FYbfsAP+eZQaNMYh4qxHKraQRjBzNtVvnQ0/0sJd2yIjHNa/lZVKGyrBtDVgC+ry0amkcd3nLaUVPcZ1mu5G9r6qVU5C2+pWJd478m55rlZFaZhso2FF7H0+BT39NxrHahy22VXT7nuENrz2aRBTCtOrR4qAGgWTLTbcoCP0NxFmkXUhY6Dcvap/my6ueOphGMHcKUp7kFujXVmvXMvP4kr/fKHSC7yUa6SmCMN6t1rtzxlrnzkV/vxVwySoP46czXrJf2Ru+1cucKBVE6NEhKqVyHpvmSCctbA1qn9QrTyUrwUVrEpGUsq+P2bw25XAGWdf1kQAMwRPHQ0MSVCrxZkkpr6oExEZ7yb2kPk2Csr+xT+sutyRfc53BOnBXMKECYQ24HPPWTGIgpQGYW3fotAVivbUuE51KbDsLnDwTzI5OWbUDJW4EmJ7JxQN58O/HG7ZwHQ5pcVxxQbiEQDxdbm9ygXU/LlX3KiwRv7WdkoJWNdJDT0Kj+ZtLSCrQ1RU+v2dLxOY7cOJp5Y/4sD2+a93msJPOUScex4rOiWXPsMZT2rDwBey2SpchbIEynW9tMmEkDL8vD4ywgu0iZdboSlMjNhDcD1GsyGKpDHc4C/7P6iQWuaoC6JiP2rjmLZtWBBQzlb8mP3GBdgzrLo6fk1YrLpLcI0Hxthizge6jTCMYGSCri2YIAaBVWPLCppnMrEIAit6BGyRBZMWSwo0EPkFy18zNlBXAyWJU/17u2MZNT5VbM9IbrDcSHoETX3knOzrjHoR09M9Dju5+TeW++z5UWoKiflLQT7MQ6GXoRc5wEXimDkKJMrPU7GAIXiWkJ9DdV5tTys36qGtDqvsBLsZwOzPFrRe43OR2zfECCM1U82VeNmrGfUJlt2idcdk3Z32QfLDLgesqchCjyn2xZsj4HPkxzvF/Kd5Qs7WDKBi1h8X3DFlPsRrp1ZClcNQVnUaVbxrEUQOu+ZRXR4fXalhrw4DCzyjELEG2GLHAxlIe2Muj8Z4FHPV1P3qvleWvIqhfNS81aY/GhrTlWu7TSqPG2qMXUavMWMBsqj46veeLzvIMAOu6tDTsE+mo81oBbzcpci7tZK6kVt9aOFq3z0TJ2yJJU36qoylYmDcCTFegMs/SURVaGeTPZXmKsBDauNA0RkPbi4vA+X7OCzB7iejwiwz/9WA78l+T65S+0dyp1XyKYepvAjNUuTvl5f2cAp4MVtgWC65WlH7NfBA1vAvThNClZxKSXxkJZB0pQZjUhXXATmMTIjSssQUDec453weJEnZLJ0CtJr1Uq2dGtoqTeM1GXQxFLeVXCp/biMhDtVSQDsj48ZZiTr9kmqm2lOT2ZfMJVcKLPNaUVWEYgIM1JZIs0BUuY9ErK53LntZKRbHmG3SaM94sOlEu5yAdpM5s4j2Bsf9Es0DCkeA9ZpKSnQm3BkWG1IwAerR+y/tSmK84DXOalIWWxpshzvKZpBsGRBh4W/0NK/yIgzEqrBpxkmjXFdbOWsRpfQ+B1EUCmrVe1tDT4mMVbTXazaFb6tf4geZwnvyGArPMbAlOWZ1EtU2ugQFow+Txv+7RA4TxWyM22vRGMHbIktSDhBGAoOJ+lNh/vBb2yVO9zFH3PidxZu9WATCcitTRD8ycBYlRSAq6l0uq0qIhRBEdWkqksPxCVZMroQZPLOqzMsVDqKd9TXCi++1eAXIej67AsZwm8SD0vn+l1VwTK7vJT8uqlw/NCBXgo2HDiR00Bdy7LtFDm83WtrVI6lMKvrssY8mw9k7BC1F28QbostVSdelqgIQZimg/Rzp18niGI9doP1VS2/F42skBDgNGqJyMvp65zvv2+WgAxnXbl/aKraF67bp9GMHagkx7pnmVVqAEjSVJZq4281/K3eLPS0DzMw6umeZVDfU+WW6c9j8Kmea5ZX3QZhtJfxCJmKftD4GcWSKjRLBBk8VeT5RDolWGsPG9vJXqobUmqWYtqQMyKP28dW+dZ7VT3N6uv6ftWXJ1GrU5qFi+rb9WscRZ/89AIxkYqaLBqe8o4kgZMYAduwU7TILunh4qmozuKyj875vAoXX6zch9H4/MZYRNfyke5J1OfeM1KcjeeyixCS8W50GJZBlKZZOU6p5TiqZ9Aea84K9JQiYFrP5osi5Y2QxetNJf3ZJ6cA+9fRfE671vmkKarSYQpC0LqvgQePNWUS1W0pyxX8oEbT+zlMNt8/Ay++XeWlRSyrG17/ZgFIaTcZXGL6iOkqX/pXATSkaIcdYTiWuQgmCKVO6myhOAaGIX0pI8ZArK7z0Y0VJlQ0e/kkQO6IjfBfjoobhpNac++NE2yXAiXI8tr4/bmaAkBkI10oNO8yhqfLUVIWrh4dFxvoFybYiTzrVlktEWsthEt0PcQaI3SDymEmic+83PenHkWDQGEeeMPKaUWaLKI85Jrv2r1aclY5qVB8BCQ0/FkmYbKbJXNOVdskD3LLT2XV6dryWZo0MACQLPAryUfvjcPcJgX4M/TTy2Qo8vAfUhaubQMakfNqqX7q25XkrfadhY1K9lmLWIyjRGMjTRMThxAVRti/YyVPUoqopVkUA8l7klKXtLV4wXpMPFaOBPIQKyPGTlqkVW6lk+cXTbOl0EhYAMyS0NnLKLOMoyAJok3eU/ynK0++j5UTBTXEoRZG1KzLDgmK80JG9SAWCEkLQOpRQvgUcQR91LDCRUacDkpueh1SX2lPyv/mkoerbZi3dNtp3dWoiBdob3iKrnICJxgbQFaRlUxyWzjnFWOcD96yex1CAoOcppYT/IlL/sm8+yzBLTluy+jPOVV9r0BJssEblNaxgjG7lxUGzln0goeT9ObByhoBVf+rimF0ikAMN8+XDULwyxLmw4/pAjL57U4Q+CgpnzWgKQFXGu8LQrGajxqsviZR4me1Y5k2nLap953awjI1wCT5MGyJg3V57zp16yotXiLUq0dWn1gCJANlcuSa63N1QCUHDyx+qvmv1a224JGMHbIkp64NaNSpX7v+ILvUR5dp6wI85oOAqW1Y2XuBqQgypYxz4p/fJwsZ5SAGC9hkWBDW8aoyFVaTGKIotNRXROXNwgCWYn7OlMruEhT6+t8N+vyupbiOhmX06WC/4HRGWJLF+DIhslZxYdy8MCHxbFQ0q37KRESguB6pT5IS6bOmGRMJlte+zwkcbvcmvoFlAUSsFbijpRHGU+2oV6eOhuFdWwzG/UfkoqgxcdhXD+MbNd9pzklpafcBghh14iG8jpMRu1JmKLvVevZqWLm9sbvhFQvvTYl0pnj+8IQ9OD4FI20CC2qHEoFswZapCKlvfBpa0YtD2sEndPQSp3myVJEZwGFIUVyszQPCNPKfs1qMqueZoHkRdKzlHIrHyv+UFy+b1lP5lXGF+HbstgMpaV5rCnsQyDMqpd5+9RmaQjkcVm0zGV/0uBWWrS5v0rvh7W952pgbt6+uqhMdFsaKdAIxgZIqoIztZ+kADI5odE58Tuk03VBgyMRlRJU0iBDacLehwBdUypqFJ8TgGlQCh0BDYV0WwHExKckK9zxb5rSp4GGVlmlAirumeqfgYXIKp4ZwXpu/y6sCLwBNVwGrNYHrxgxir9JlIv6VdsDMg2D1l5DyGiJclpDpWMWijLJWKl8zB+lai/wroVfmFcXlau55ZL5h7zWbKqrsmRlusUDifl12oUwWEYanIo+prMnl9LwqS6ztaq/jYHMJ7QD8vHD4QHARwsZ4lYSgseO8kAIeFpkBkXaasvTEgmEKW84kFzoO7V9FyFbCIWczFdTfqssTqNl7GCieZTGmtJsKa+WC2yZxhDwkAqfVib5Wdd1valVlst2DXI4DU01EFNTyudR8C0FdVHL2xDwsvZ1qlm65LWUwTxlmwfsLWJt0PLQ7ULe13wPycXitcb7kLWnBjgWmR6nwYcFEofiWnnX+p8uD1sQNSC1+ivnJafeSkcckh/uc7W61tOSpSv86XSaeNPp1wZNarIYAvLz0CJtVfNzoNMIxuYgGvjVe9QbYheIhij8JoBNQNkOlb2eWSoU65hJKU4mEZEvobfHUQgp7QAl3JMKW2kRUxn3FFwti1I97nUzqXRLkGCK0xXnGapGTrSIJkCGM+7pJEj+6Oda/DILSiIPjYJI1IWdTI1MLmTVVaRDZlsU56Je55GLvOnENcConYpMamTEl7epFOlwOrUgTiQie1PoMzpOyLpsc1LEqd8xecpATADidCZLEiW/+Rz+md44U1mknMkuNA39XPRjtJk1YwfHB+/OTENKx5DyMwSyLKvFrHz0WSuQFsCpjbRzGvMo8EPhdbwhui2Ut3nSmGVluLVpyzzk/UXiL0I1ED1vnjKNeeTinBsEpovyPgQebiuy2qoFXofy1BYyGc/qfzKvWX23lp6VtxXfuh7Kb1EawdhIw0TWNSFZH1g5ZEsNAXAtQBSwk2eHHnK9Uqm+JdflMTxAoLShk8g7HmEWm0sbzQKIWwNLyl4Ge+ufAKB1WSlkxT9pkVn5lHp9I5RZLSRi/uOdYoZXDylA/O6nlYNLsEUCgIn76bezk2TG0nUUgrynyWKxgi5liRrjnlG6zEJKlsolUk6dZda1d09PZkJOEPJJ6bEMXAYZnq8FMGDG5KA1aeaGmXQxrR5OhARKZSrFtD5uyeSMDaORhQmkfudivvZQBU/0JLDDHUfBAulBwQLWoF/EaI2WZZE9mUEXiyo5U3HIm0knt/mU60Z+UMg4blPazD5jszc4HWn/0JCVRyp1+gzkUXfLgYRMSwIua+RbWnRmWcRkHGntkMq9tWZlyBKmHYPU5KPB45CFoiZn/dyy+Gj+a+WXfEnric5Pl1fzUAMaVt5DFrR5yKqXoTRqAGye+mJLklzjOGSFq5Wv1v6tMg1t+izz105IrDbIZ+nMhihYj628NA8ybNd1qb8OOUmxrFqchp7WyHnV+lDNInZ7AaARjB3KVCja+Ya1R5GcQVSMzDtxlmEIgCdQdMQAoRiq10/Jjo95eaOReQ7Hexr1/4nuk8BYqdcJZb2RnGQApnkKQEyDDVZFKZWMFVEtJipSEnkOjUpxphYwM8HYQDoMHpIgCLdKyY1xy/V6pY49BFUcDGyjeZZnfV0jKQfJlBXZAaXXQqhrVzacXvs30jRlGiJrIFYe4uMu2iwQ21PKVwJyURAHUafxA0g8IOCM3ENOee82nyCV85Rxtypiwk+q3jNgFDzLciQw5jIgU/LpCY/Q9xGT+L01tJlpigfHB+/OTLNG8LXiZAEGqVBJEDRkxdHKqwYyWkG2QFhN4Za8SD6tfcysuFJ5tRR8ywIgQYqkWWDMIgtY1MCYFdfi8dYou0PxhoChxYe8b5Xj1shqUbnUjlnlvLUWO2swgNvrEO+aB5mWnDJYs5JxG9JhrcGQWYDU6vP8W7fVIZAnf9fyurU0grFDlRrViIw6LXRhEnqqFzfT2iVkcNEgKLpOjJ54MfonDp1PLy/FUcAojQBk2V6l9WkvzuxOOwGcAuhwZlT8nkd5ZgDIqqhWM21EoZRpGYMRjXyWtOABMpTngKI1yBRlzEzOTlude3u6SXkppZ0VcvbzQlxErYM7UQ0OlTJViDNMP7jc/KzS3vXLrCcXVxZKWqGsuiNSieQhAtnc+LWv7bmy4GmLCAe1xxu3E5mNS0CbYsPXW0uUxi551cDBx5wbOFRG4SHqPWVdTj2WrYyayBcPfMhBhMKDJJUdlewm32syXK8LfZA2M01xtIzdkSTBU02pHLLeWIBDAhdL4baUrJqyaPFhAaMaEKtZxHT8Wjll3rOAJCu0nN8sy4iVr1Z+awq0VdYhOQ4BinmVTMtKVFOYpcI9pMxb7cPibx5FfCjMonKppWkNPtT4HJL5vG3JAkOWjK28NbCR2wJYAwSzNii34mjZ1Nq7BmPWwIe2BM5bX4u04SFe54lzMNAIxoaoAbIiE1WcpAC53iwlAmV9PmnaQrlipUsqiNQAzkdMEBqNp3LqnwZkKTqVCl4GQbZVrOATCoy5uElw44A28qoL6CBAZjy56OkbENMs+xPLQl5ORk33ywxEwjow30iyFNqoi/VjCY6FZYGXVGHMTTykF8hZ3xMdHZDODpNy3ojf0oLIZ35nhP3n5svSxLFzkQJiPblUojn1TL54G5dBj1UAEnUr5M6tIldZaavSftwohpBrHBN+AVAMgOhOg8wb91euajk9uCm4Crm0aJAn9TKu66+VtKpBTqkkFgUDMJ4OzKOOuh6I8lrQNGrCcsl9jdS5SOvg+B6NNCdZo/KSpOWIn0uwIdPQh7RgyUX8nI62lMm0hixUenR9aKqhdCAglVmO07btoGyIyBzR13KR+WoFeQiwWHnWfs9ShiUPNYtFrZxDZCnNAHpOUGQdWHViyWIey9O8fFrhhsDtPMDDAnE1Pobqg5/LdjQ0tZbjWVNJNbix8iYKUwYtC9vQgICWybxtVwMpGb5tWxOcy3i6vwJIfbPGmy7LwQKWbm8awdgQSQUuAjF2OZ51PFYfpS9EAcoQwpeKvQQaVAIJEU3kXFXySnbLUX5XcKQwILLTgKzYS6CjMxXghJVorZgLedS5JeOqSGD2tRmb1G0pcAN4yHjpZSCvbSp0WwOEFb/FcynGahFEJsWOAKIYVe5EQ5mpf5OUDUqgWoQz4vUS1SiuTLpIJ+VRyS+lNowwnQJhOltiXrmvaYEkIM8fg/CQwJtl66ZSMuuq9+x+qpqC4IEjuAxqnWKWZU4o5M/9G5DyIsG3Uf65aTPTFEfL2B1JQ8qMpajVrDKW5clSaGuj2DLtmgJt5T+keFvWO60YW2lYMph1z5LHbUFDVqGaVakGemrxZuXPZ13PNf7mBU21vGbRvOBRg+F55KLLa/E1r6XO4msR4FADSrVwfK37mu6XciCkBnBq96y+Z7ULzc8sEDf0/rD6uMXbonRnBW8jGBsiHpIn8MZTSY90CKPnjVLDGmRX1V3yEhBVJPZYUWhsLliiPIC2CQqXR3TSkfVmC+JkFcxSBTMI41DSaYCPo/sePjoPQBiZ54VfKSmFHrjjCTn0cJtBNOPI7Es12FJrJS8iZfmI+Z6ns0sgJmne94QBvOTvhAmMaH2lX7FksNWrYi38efiWcpMJLyQv10eLxAzIulNp6kVOVIpOdjl5X6kNkK2e79RBaEzBOWGSdIlVH0EOxe2zefKjLIFS9VA6/kCPH8lH0dbTy8PlPtc6FPJPESkviIvu8sM7p0nvH8ldyIM/jKI6GgBdTygDNIKxA5149FmOnkvQwyP4kqSlS08pki615T0gWFLatk3xtAKnw0saUpwsRVDypi1i2ioxT3pDeet4Q4o839OgU6dXi8flYJpHEd2sRUzzM0vp1vEsYD2UjwWetTXn1pTX4nMo/hBwG0pzVjnltbR+cVpadjUwWAPCbdv2+pfsc7NkUANOQ21VtwtpedZ9TcdjaxhPo9SWNC0vLQd+57DzkHloMwMmBwt4G8HYPGQgDb0mis9pL2YgjOAnLYy1Tp2QE3kI5OVylBldsKcsamtdqRRKi1i2MCRFtYasLIBQARqasjJKxXV4ZqQgAVmvH1E+OQaHIlASRgaOPS6p+kOlEa5dLXQFhEnP9n1Y6YroPSBWnKl3P+Vj1Y/S5U2+Sd/ohehH7j2v1U1stFWYKdKVowypnUtQoTdH7g9E6JyM3PoxdQTBU8A+eW8wAuLqsFICOR/u93ZZ5R3STx0yIBQ8FGwbkTMIA9juzX0oc1G+RxanzawZWwjtjXQb0SzFVz5jpUkv0p+lqA+Bn3kUxFmj9zpN/VyWq2bhW4Q3nYelLOoy1NKopVuzJA7FnydsTZm34tQsRpyOFacGJmbxe2utUFZeQ5bPRXiR/Mi0h+qwlq4ln0XSqslFD6bI+IvUg06zdr8GXBkkzepr8/TTWn8YsrjNohGMHao0Y+hdusbgUWpWjliF44FttnSlxUTSqUeRvkOxFor6itwQTgp5kvrlRDgqR+i5M/QXwImUI7ARgIMPrTPyWYqKYq7SrXfikIGXk781ScWfynsu33PysSqHyyHSWVUnsoQEDb0rNFqAU04VnNVsCvlYgCmfaxAOWST8p6bUy9ukfqtfErhLLvry6IcKPyRc0TnpQQjrQ8X2FfGCV39LWbrslVC2RZ5rCBLr2DiWAmZACsO4Pog0cJLXOfaRkQSPtT5Z9F3Z5xzKAslYqTAEdGE9qdy4vY3mvdKKOOBDcWFAthnL2AjG7kiypjhpxUiuk+J7lqItXVjziH9tdH2W4jkElBZVpGpg0FL8eaRePresO5ZiK62Fksd5QFhNUbaU7kWsGzWa1/ozBK6tfOYFQ/MAVRlnSJabmaY2T/upycICo0M8cFuvtdtZVlo+18D/EDDjwRNN1j0rPuczZEG26nLIiin7mXa9b1nGhsoo+VyERjB2qJLU/AaUXAnKeETfpXOYrkjJi0PUFAkZCKXE4lg6n42stbrbwwNJLQsxecpkT6FmpVDvycSLlaQLwISoKCMpAQayalpChqyISucFebpkaRWEIgVNiFCWVjyuYTnKyTOHGogh1RuJECUom68rl25SXC+fMi3OR6ddU6lzjea2EWSfr4e561/31xxpPuUapH4Ccpu78oVHZWCXuTeZkkViBQnZrsvl1s2E1GGg2fKB5sPFP2LDO4rtvEtF0M50cmuXfbEGyHqttgBkRsMnymDM++S4o4mTE/kogSll/NnLx2BsJo1g7EAnS+GyAFRNOeJrdhYAoHAWYKVj5aEVLgsAyet5FSOZnwUmZd7Mu6VkDoEXDeKkxXCovPOWaV5ANq9SOivvGh+1+quBrZr1cij9Go/zgsIhoFijRaxR1j1trRnKW7czHV5btIb40FOEdZ5yyvCscmiyLHa6foYAzZBFTPYX6azDuTCtka+lHPQ7RctrM8BqBGOHIqU2xFqauE+sfkm1vlQVs6rLgIaCD242n0jPhFJrI3mzfMRpWqovKSCWpgK6HBNABGBSIRWpFAhLACFWEHuKbuanVAipH9xB8AcFAjUPkiiJw3pValfi2uhSQg4HDUIkECMhO6lkz/EaNMGNjC8+U/Fe5cVfpKnv8X0SVz2VPz6rnSVQLLmWEIOEnaqAjYTken+WXEjWq8UcP3byQb6Rm10GRXZiJX8AYv+i3NZJ16bISyOZJhcu9UIB0LiVlG2kbP26j3KN5ZvccF0uKJA9J6pukg/5zlHimyXrke4UNMtSNCu8ZemyQJkEbjrtmsWhFmYWX/K3xW+Nh1kK5rwgzbI2WjzOKvOQFagGmK38LYsKn2tWTivfWeBvqCyahpT4ISuIlf8QELPkMiSPIV6tvrKohdICbtZAhMyn1ubkc2sbCYuHeUEyh6vVo+7LQ6DP6vt6wIIHS3Q7m6c9bMYydmemEYzNJAM4JKWOKT+UahK7wk5uuAmgziONyLuoBDqXwZrIsgBURV59DllhTUogj7o75P3SOD87mZi/UAop+QDPwJHUWQDDwXMBAA0gKBRdSQVeUziu5L0sGiutzriyhMBSznJEupPla5HmpD/VjyFNPQ2bSvDRt7U1vdRsQCZBmFbopTVPp5HXbZGQQ/wrm4kSgWgaRfvt2wFjoKaIAMDl9CnubW7Ub/4loHMMl7ooO95pBPDh2EUzUICMPaCmDxHyVOPYLxzk+i0Vnfs8VNshLmeGcNlsHEN1lC1iFOqoZhXrk5JxWn+5CG1mzdh0wfAj3VY0a5RZK7WsAOpjOp2mUW45Ql5TLIeUYUth1hs3DyneVnqWYqvXv8kyy9/SSYDmV8pF36uVT1NtHyh5zyqz9UyTpUBb92r5zqIaYJhFi1j4avzV5DALCFvysJ4N8bFIvdbanlUmK7/agIcFDocshxKAW2nzc21NlteWrCygp6ftdl1nbr4uHetYMtDp1sLMQ0ODLkNxDgYawdgg1RUZDZFmkYsKWKmUCYUs3WeFT90HMGRJ6WEkQKKS8jfEmUTMlDelWzoDB3ntRDCZsAAeRd4GCEvTIkW+sehOhE3WL/lMCqBXzPyvdg+C/7608+/h14YGdDJ+TlW9ioYTVeJnScvW6MT9eagEqDYYK8EEFflKjqRdjzCHvl8DaxCRizA6sQyIyjCkrmM8IvTqU/9ga1TKW1xzUnxdNAQq0uLJlL0sBF/mW8Lq/7L/Eft11MMJNuk3RebX5myYNjNNcQRjBwpZI+dDirO2wsxSYufNU17PM/pvWet0ejVFe8g6Mg+wGrJOWfzMkmctfb4eAiKzeNXlmyfPRdK8NVTLs8ZfDYgNATINwJyz11cN8bGI1WYRkDlUVivsUH3MY2kaavdD+c8bT97Tgx26njTPtfRujUXszgzG+r5o9wO94Q1vwIknnojV1VWceuqp+OQnPzkY/rLLLsN973tfrK6u4oEPfCDe//73F8+f9axn9RrL6aeffuuYpPKSj7AHq7QcZGJ9rhGHI4IjCgvzO3mOh/RuUeSZFb6cbz4IYePm4DLbBXfZLcI5MRDBj5MlIIB8Xp8i+HEecF1Y5tYQR3dxpD6P0bMFheBADvBNA2pbYBKPpXhuneJHCCkirCQzI5g+O6DiYl9Dr/6KG3tbbI7XFPFLFCtpWDnmNuEBkHOgxgETB0waYKkJclkWxxIfTQjXuhDPoVhzp5rGID8lFC3dZdr/2Hm6lFXtn10PMhdZZ+ngek4okHIiXPHcViaNakMtqGmC4co50edK7h0cGnKp3TZdaMsu9bXY3r0P7Z9STeU+wrtz89Ei960m1g2c3RcFX736KTqw4idaxcrs+zBMvwfC9Swr7ry0tMnjzkUHxXcJfeDDZ71xsqWgWQoVL9DnYzqdFmnV8uc8ZJ5yjQ2PoPP6EnafXXNZL9PQPGllXG/wbJULQJH/ZDJJh+ZHA4EhwDCU92151GheIDYUX/I/Sz6z+Lm1vGieFpHP0PN56knzy9eyncr2a8lmSLY6b9nG2fIkjxoAsviRbVf3P322yOpr0+m06HOWjHUa+t1jbYexWdKW4XmPg4H2Oxi79NJLcf755+PCCy/Epz/9aTzoQQ/Crl278N3vftcM/w//8A94xjOegV//9V/HZz7zGZx11lk466yz8K//+q9FuNNPPx3f+c530vEXf/EXizMXR6hrqo1UuPUhKav+YhCeYvqsEHrKv4s8MxAgsPLnCmWsyJORjDw7lEBMAjLSR7jtfDhSNEDAGVkal/hiBRkJFDZh77RW/GawKPGNE0DMCWXelcp8DxKRllAJxCQUscGVDIviWt5D7x7XRb/OhVqUwVOBVBgoZ8CVZJR+x3vJ4yaJ9EpbS7/tiQ+JkoyUQl9aNblY8EuH6BW+t0tCqkMFxJyMLGUkj1a2pUYAodwnSPEd2mkEMrLJ+3xOfY1UDep+0jAqcqoQSLMZZT/0BV9ZWrmhiHx9/6jt4ecyh0VbsN5BBS38LeJpioscdy4wdkB/lzB7hHiWYmIprzqupSDqNGrKWA38WeBrlittC1QOpV1T/i1lVgPC2voXHb+m7NfylOlYcrfKPg8Qq5VzHtKKvlbwrd+1trIoT/OCy3nqshanBlLnAWQ6nRoI0rKaxW9NhhK41MCL1d5kvtbegpw+py3vyTJagzjc94d40WksAoQ2a+W6s4IxR/uZ01NPPRUPfehDcckllwAIo3J3u9vd8IIXvAAve9nLeuGf9rSnYffu3fjrv/7rdO+nf/qn8eAHPxhvetObAIQRyBtuuAHvfve7N8XTTTfdhJ07dwKrQFaiqBj2DqPWbEHg0Wuprmel2ceIHlSMXnPSWctSHbmomTJtmX6hqSUgBqHxGoVk4JWcBQRLGCCW1/SgifQlJ5VPEnm7DLwcMhBJBRLKL1skJF7h4CKadOxoyYZSESW3rJTnkmggUiZFRVnkmXohmew66YEmCY5bVuSbst5kwhKYs1u/uEeCDR1r3JV/S3ilwZSrSEQq/BTlIu1zWT6FLPpiTs07LccS7T85mWEw75p+Il72RS/aL4k+WNasU2VJ6/cED6GRuAy2AIkSRQE47/g77VshxTbQT3tCgmjc+TKDMds2KdkJbOS66aJXQ9KW53XgxhtvxI4dO/rlisTvvRvx/8MObKuGM+NiN3biiTPzOFjoQPwuAbmOVldXAZSKllQ+tJJmKYBcLq2sDVm/LLIU0CHQN7S+RCuFNWWqpgxKmUiSLriHQI6lxNXKPgv0aBnIa4uPIVnMUjItZbnGD1/LvDU41mnoNmJZXIdA0BCPmg/Jz6JyqZVziOZp27P4mVU/NaA31GZl3kNrEq18rY3TN1Nu675sI/O8W7QrfJkGEWF9fX3ub9MXvvAFHHbYYdVwFt1888243/3ud8B/m/brmrH19XV86lOfwstf/vJ0r2kaPP7xj8eVV15pxrnyyitx/vnnF/d27drV+8B95CMfwbHHHosjjjgCj33sY/Hbv/3bOOqoo8w019bWsLa2ln7fdNNN4YK9sYkTU1bceXtnrTpKDY3SfT5Yr3PxHELKTGqgQQYRYIsPyyQhY3PGSrF0CWDmPdPk5rKyVFzqQg13KC1fxVw0Bl+Cl8RDCcSanGJ6pgXQl6wNkJy434iQLj7RcTOQogTGCGWtSHLGEwnGEhMMjNnCwtcsN5ciC6Aq72d52W2kL4/yLofOIKyJMsh1rEGcBmN1efcBYLjFddgDIFEEPj7L3wTKzmY4MScE5ASCcoiNkKcY5i0lctN3oixxLyUuC0UQw12ANxBnxOhIADLFE5erQfSOWgrGUB3zJZW1pD2BArIPCKUixcoCzWAsQ+Re3vXv7UgVOlC+S0D922SNcvO1NQo+S1GuKVQyTRl2KC0rjARhNcXSGp3XaWrlT6ZhuaiX8YA6GNOKaQ2YDlltajKzZCfBUA1UymvJzyyQWHs2BGot4G5ZPJzrO3QZKucQ1eTC5bXakM7PAmYWzWNt0zzxbx23ZhFivuVAgubBkq3mX7e9muMbnbbsL9I9/jwyGQKDtXLX4lkDPbKcVhsaaT+Dse9973voug7HHXdccf+4447DF7/4RTPOtddea4a/9tpr0+/TTz8dT3rSk3DSSSfh6quvxite8QqcccYZuPLKK9G2bS/Niy++GBdddFE/Mw0EjHajN1SW0SwH9Ky3Wa+DerMceLEVoEunoH7Lhs9gKAYrFVhW0FHcVV2uBBwp6OyXsIWmnOKlAGJkRy0fFchT8Bg491HyzogrwRifbdvPvBTzkewUshEauOMLkQcXXCnu+b7Mycq9TypnocgzhLHC9mXArZhSK6686CHaebxwlHEUMdaRRUqRKEfSncWJwAnFuyIdCcRccVdS7o/JRT+jNK4nzWS1oE5c1wLO7t1WHYSYJSjTqcqj93AG+zZtxoHHxqKZHLB0oHyXgPq3aQgsWTTPc6m4WcDAonmUbgv4zLJ2DKVTU4gt/i1ehyw3Q2BnHiA2y9Ihy24pqDo9i7/a86G489CQfKz2MKTo14DfLBoCkRZ4rgGzGuk6kOnWwIsEorU0LT430wYljxYNte9aOvOCz1q+8w5AWL9reUpAtghtNs7BQHdKb4pPf/rT0/UDH/hA/MRP/ATuda974SMf+Qge97jH9cK//OUvL0Y1b7rpJtztbncL+5hayoxzUU+Ubt2FAs0dJj4p8JI4i71m00B7jhFCVpuRhT0KjVtqp+Kaj2gJc3HqJVvEeE1YSE6CMC6NVMqFEu2c4ZRD8kH5KNbHZYW4AGJGkeW6nJy/4M9JAFnm7xKwYcVZghxRxayH9xggkSnJUy9HbVBJG373WoG8JnEp9hGIAnGisWRM11fSE9/Sagq5h1qQhTT6hnuyqAoKmC9zAchSfekNkgULXLwoxiLJIoJoEI1kUMA7NqHGdhwsVJwHgZRNF8VQggcl3nnrBkpjE6SFkebNOkPIsoCZvVnYTfJjtQgZvW+hle09NfjofFWmJgq08LdoM67t1xfN5JCjRb9LQP3b1HWdqTxZI+c1K5oML5VEa+RbK7rzKINWuBrg0KPpkvSaGMnrLACjyzhrmpe2bFjKs1UmfVg8LGIV4LDzWDLnASE6rkxjCDRI3mvlmRe4W/kz1axsi6ZptQd5z5oGqcsk4+vfel3WkPVoVnvU8SXok22Qr7kPzAJYQ2Wa9VxarXU7keEsS61MU/+WMpsXOFs0grHbiY4++mi0bYvrrruuuH/dddfh+OOPN+Mcf/zxC4UHgHve8544+uij8ZWvfMX86K2srGBlZaUf0WelUSvrhbIr9HR5IVT/RBpD6efZUbalQ/VBRqHE8klaVqR2J5QziZUcMhCTU9kgrnJZcoLEyKAHvkSmUUFOVgd5CFZBMKdsqdJCWiKzfLgu9GS7LAcq+BMFV0kkxTshRF2sgRebuEjBNdAoWoWSVUqfzHwKfJVxUAmMOYAEEQXScikLKcGi/fZ81ZOBnpiBcJY8iNeuajuqmGVKkSUKQmsot1+Rj1lvxGBE9h5VpT1OAmQjUJFc6su6mtIDp64NShWfIhcP84TKciNreZaxCNI7o5JDahS6TkQiC3+LNmMZWzT8gUsHyncJqH+brBFpa1rXIha0WRaseawDkjcLtAwp7kMWqdr0wpqyaVk/rPLxeQhQDQExmdasuPOUVT+zFP9FLBU1HiwQtoiSz2lI8DAPL5onnYaOO0ue2qplkU5X5jWUnpWGtpLNAqnz9FMZV07PrOVfIymrWVauIQBVG5yx6qi2pcBQ/S7azmplXCTOwUD7FYwtLy/j5JNPxhVXXIGzzjoLQEDcV1xxBZ7//OebcR72sIfhiiuuwItf/OJ070Mf+hAe9rCHVfP5j//4D3z/+9/HXe5yl4X4C67owzUrROGBiyDEKSUVWYkEAT6MZ/NyFEv3LxXVDDQGqYfJBJM6M61TsyIer/P6FOkgoEAQRVYk/kGM1vfUx+InlUd0SpEc1vF1oUrrfNmNd5RRAhp8oL/eqOBFwhZBNQSofxMKJbfvbMFQzV2pD2ednvINp3iK+RRsOQR/HxK1OJUuX3OeiakY2CpP79qV1/Ls5G+l8POuzETxlAci+CjbubomSqx6KROKoyHJGY1gWhY8AjHZKrP1K0MxzUFZQtVmvcBTRR8iIWBC2g/QspYNdGQHbu8kfueiySISkJ2MOH0YEYDC6izTnI8ObTB2oH+XAPRGmvk8yzMhny3FlxUmyyObDjsP1ZTgeZRm5mcRq5a0Imhlu8a3ZYGwaJY8rXCzeK+VW6Ylz/q+5mHI4lBLwyqTBQiGwNEQILbys64tnq38NNWAuZaF1d6tNPS9GmCX1p4hCx9QrvnS/Fj1wveapulZoPRm0Zo2a3Gy8tdt15KFHiyQhyV/2b9m9c1a+UYwdjvR+eefj3POOQcPechDcMopp+B1r3sddu/ejXPPPRcAcPbZZ+Oud70rLr74YgDAi170Ipx22mn4vd/7PZx55pn4y7/8S1x11VV4y1veAgC45ZZbcNFFF+HJT34yjj/+eFx99dV46Utfih/90R/Frl27FuItzOJnpS6SrFfnBDDj5wJ0uODxjaK7aq2QAlJR7QMfk3rvDalEcr7ImQnQkJKISpv02qZeCUVGWSmU/4RfSNeUynLBD0eW7vslAOOZjTYUI+MolNLCg6MGHUI7JZWKfAm6guk+UVkWlh+DdSeSSKkqRT7lzMl4svb1zi7Y43Xj0DdU6RJGDOUcO6NQQMKp8vZIMJkAmWgDTsIqkQ4XKtWrjwMQLoKj0iGLLka4F6xZDQO4hG+oHA3hPuYkYOS2rltodnvfz9eJJ3xHtVuOwGIpwJi4SNdW6cRtg7I0mR+bUv3K9t40uf2nQJGf9K3L6Tog+liclzYzTfHO5dr+QP4uARmMWUoOgKQsamVKAxYLMMk0FrV4DIWrAbLaCP48QEamoQ9Op8aDloUEcZbb81n5yvwsa94iINTifZ78LdAwKy3LajEL+M7i1WpLfNbymFXOGpCaJc95PIVa7cSybkl5yrM1bVDzq2U71D4tWdXSG8rTSm8eqgExSRYP1rYQuo/J+PP266G8F4lzMNB+B2NPe9rTcP311+OCCy7Atddeiwc/+MG4/PLL02Lob37zmwX6fvjDH453vOMd+M3f/E284hWvwL3vfW+8+93vxgMe8AAAQNu2+Od//mf86Z/+KW644QaccMIJeMITnoDf+q3fsqciDhB7FQx7e+WxdgClcijPhc4fGyVr7ELn6yulJfWajwUYUiOjMpy4rfNJ96m8y07Ts1pI4hkl74nZ/sAJKe51w2dFMe3pFBV0kiAM6W8vqjoCy1EphVRMkc9AiT6rYIZsuWrwnTw8ZErZMF6h8n4PDLto9ZFp1BR1Qt/iZoRlAMYZU77MeCqdjboqUoqJkQxngAsAhcMKT6Ltx3pJe+W56Gs0LyXst/2SJ4c8cEFe8JKEYfAvhMS91KvHsl3LXkNlwZKYuNqleHo5S2DWK51oEGRG6nFoJZ+muaYN91y2APOZCGln8EKWQb4NaEEwNtKB/F0CSjCmLRla4ZVhZ1lQNNWUwVkArQbypEK6GdLxhvYfs0b15bW17mVeq5aVn85Xyt8CJpzOkEI+RBY4sNJYBNzJtDV/m1HyZ4GnRcHiLFlpmTgXpv4xaBoq2zwDETIfq+/N4k3zIuNblqQhssLoMupy1NKtDZTMylO2cbkeT5bDsoZxHCJKbu8Pddrv+4wdiMR7GmyLWJUQFtJPIxDxbQNipWipyeDAISpGEXx00e1254GOkk8CB7a6ZZKbCBcbObuojen+wfkkDivAC/2o+b60R0lYJF4gKEEY72lEEi2wUsi/GYAhF0Y66OD9oPLm0SWXGoB1DACdy7Ju4z5d7E5fKurOSqV2VEhr7My/OIpdBET5avKWOeozk5TGUFopPYe8Z5a45x3K9WoyscFvqAyo90kQ91IBROae23ts80Cawtii3PhcqXLxb97HzDOgMssh+kMqNIltGlzktBHrILmV5zxJ5NsfaOiTVWcl9MGM/gqwFa6FrpKcUtrOMNYjHIBJk61ibawD/mgy+O0ImIY6aDqCoyz3fegW2GfsX7EDi+3lchNuxk484IDfy+Vgp/Rt2hb2gWNlZzqdFgpo27aYTCYFGJDKUdd1SRFiZyCsKGnPjtJqpIHLrJFzSTVAYlENDGnlVo++S2Vylpt2C7xpBwYW6LSUZivPefYS2wzp/GeVSZanlpa+lr91vFn1WAP7mpeas4hbSxpsz9o0fAh4W7LWVmhru4VanRCRaUWyrFwyXm36bI1XTUOWKJnPkDVXy9A5h8lkUt0wncN3XZfeT5xP27bpPbN37965v02f/exnN7XP2IMf/OAD/tu03y1jBzI1QkUKOhHlEXairAzlAEjqldY4GaREIiApiJb6V9yTSjTpp9QLYkXrp++Ka1eogyT+olBTC4U1lZFK5VicizVqkEepJJcTtXL+GcC4DMZYGZdKuSpd/1qjq02QLrYiSxyLkFV3+rpgRbYpVzYPF38U4eZiSrb4GlSMGeg0CyTpxGBBsLiWKbtK1NwzXCpAyVm1/lKZ+3vJWWQDYuauH7Z2j3oh4rXrRyajq5Qwsex76ZFu+zIKv3ecLkn41/Q4n0WH9pqxg4Hk6LpW6Gqj10O/Od4si1eNpAI6T1jr2spPK82WdWMIhOh0akCB4wyBlyHgIvPUyuxtCTQsfmoysKhmlatZ13Q4q+4sIFHjdx6r4G1F2kIm85xlIZJpzKJaG9V5DnkgrKVnlWVW2KE0NWCshR0CbjqdWe291mbkO2xemvcdY/F8oNMIxgaoTUokwwEXvGgnjUogDEkJcVQadArUhwgFVJDoJUWRCir1gkm7VgUfFXywnuiNUPKKnDwbvEkAQijWPWWDlVQOsyWOn2awx846IslpWckKpkohQSpxpiRSkbCuBLAWdiNS0awKktmhf98GbGW9W1SCFKWc2IEAJ4CX5EFiqjhn0OkGotLMsNuqbC60lWmkNH0uRyEKhhsZkqepyuyb6LO+aFoU6peaflvuyUNk7fnDQRkN2XXCcbh8rvdMNfV4pjQNkyWWQ5Pd/6lsQn28ptaoWsxyupI5+U4gEtbnzYCxcc3YgU5t2/ZGtGsj/pKkwjRLGRsCMPOCDEtpk/drwGgW8Bka/R8CpzWLCP/WThlmgbha+WR+Up6LgI+aTDTwkmvdLGuWlbduA/MCqiErmcVvja/NKPDz0FC7kfloIGCFtfiQdSnr1kqDifPSUyVreQ6VyeKv1latPJgPWR79XJdzVvk4Ld13rPSl/IccBdVoBGOHKDF4CIDMowGvHTOU6UIZdChGqUUfE/ppj8i63wMe5bUGYg3QU71kftR7gmJ9TZ66ZeTp1CHuS/CVgkZMxLxliZooM+VWTNNMiUkgxsqoRkUQMW0E1cvVEkzkmwQTfC2zJPTv1amEHbU2oD7l0K0l/SJ9A2XdyKiMC1w+F5nZmAGlcETEwm07oy2RiEOoqyQ/gnwfZgDTnzwoWWkjMEm2WFJtOTaH3p5wcQ8yLkOIawMytgiXHFTaihGiiTmoTxqKStB1RP2a1e2h9y6Q7R7qOjHIjTZQ3jdwMTBGmIAW/DQsGn6kW0dSmZ6lMNUUXcsiVgNHs9IeCseKWg0cLgrIZgExS4Gu8SV5q5VnqGxDedfkOi+40HzXlO2h8tXAmXVtxdP3N0NDYF4DMdmurfY5T17Wbw0w5D0ZdpbMZJ+zpg5aoLdm0Zqnr1pUGwipgasab7U4Onzt+TzAWbd/2ec2YxmTad3ZaPyCDlBpxVCdgygfHMi5eA/lIcw8cmVWSgqs0EWbhGPQwYdqfFRy5ICkcJUrvhzQUxQzSzmMTEzbYhyUeat4pPlgnbDvhMICYbLszBfLAEoGHFqcKcoiYQPmkeUTUnVRiy/41JpvZibptE4mCWYqh9dpcK5a2S9/cZsqn5TEgL8sr5STyrTQ5qUDwoRgYhjH516l5bMsJoOgzIHvB3RGxFxkUT8xTZ/LxqAkDyLIvxkEul7ZxWO+byMmlP7+hchIlk9CrAyW7boMob1gwgkJwXGfkZWCYtQjf1DKHivZB2UQmpxzOJeZTnLnd1FKHE4g1KGWZpHHBH7BT8Oi4Ue6dWQpOTXLiTWabynzQ5YdDfpq4EPzooHYPBaYRQHEkFXFCid/W3xZZbf4rcWx6mIRvnR68/IzD+k61HzMy+uQ0r8IL0M8zmOVGRo0GBpgsMCZzluS1f4spyAWDYGzeeVW61tW+tphhtW/ZRzLhb5cZ2pZumRb1O72ZdmGBlE2A+5rIHZWnIOBxi/oIJXKV7ojlB5QVE6pEfcg3H2zBsrx+9YAVujSCHsCIE7uoCuUsAxGMtAJ56bktFAyhbqYlVqZVx8r9UUh1WGhZ0qAUzq54NKWyCrjnmBt7GJinvNpUToG0XaDBIIZPeUwnARvT+V0UhyU1DVXJ3I1ZjVba/rlvay4S7BVhpNr5JqqoENsAk+Q1bZKQq5DUZdJ9iR44SsuAb8sBSiTvudV/ctmztNYPRmgSCI7pxLh/bGaxHpIi+KHj4PApev+cIJLefM9D4FLhGRKsQq+tPlMNKFgiqUisSw5adMtuWpQem1UnCjZxMLx66ILoZoUQ7aWkH6oVypNxRJ4yc3d+V2kylFvYyPdWcgatbeUdqk8aXfuQ2BJWgFkOL3XWU1RtMJbeViK1ixAVlPo5hnNt/aJ0uUd4mko7yEldNGyyDRqcqqlrdOwLDWy3mdNHRsq1xAwqVlYJMiX7XDIKmPxMK+Ma8+ttCQ/HL4GTGqu82VeNfA+VBZLxrXBCCYGV/J9MKu9yWnO1uCLjCsBmDxrN//yfbMZEHWo0QjGNkWs/DihtUnFiM8WEOurXFntFiTBUczScrGegg/80oCsDsRUnr0kKf+QHUvqngKg5aian3wu4IYGBElUVMYkKlOJSn0PHMrD4Cvh2pSsK0SclfEMsJRAjHJl4EXiuuQMKFG2lU4fL9buldfSnqttuyE2WywBxPVUIo2M5ESriViKcglKQBbXl8l+wAlwaJ5TmO7HmGSXySHHzfUQQRwiEMuIqV8dPUCmr+VtkYACm8xHPwsn/pYbQpR9iEpAxowL4crpmrW6KwRFgjuWeXr/iHw3SaNl7OCmGhiwlC1J1gh+TcmVyqVWprUFoqaISt5qeUi+5rGUzWOxqVkIOLyWV42/WXnX7s1KRz+rxZvH0jAk+3n4kjSPdarWBobSlff1JsJWHrWyDwGXGj9DZamlYwGyGnDUaSxSFzVAaoEkTfNY0Ga1XZ1eLay2kMnwQ2B5MzRaxg5RkpaHwhYhAZj3SP7FnROWMAKmEShQUOib9LefE5JVAdFRBUo0wcqY2D1a67au+JVTjio4PDsOdy4DL7kOqwfEdCN2QmNXGQDZjT0Y/IQEpTsGIUV0EO7LWy67LDdBlkDm3UQAloAFoZgWCfkM5ebDgRFtuXIFGqTEb5P4ZitI3nNNioBkSoCoaWkNrdtZpEhlisWqKdEm+XdRKlHebIvMZeeWIOTZ+SxATt3JtIsaSGCjf11Os03lYUuZEzXDa7pie/E+7rcCRFfsuilKqEIprnNIhulCkD0zqOhbBRJUtzxiXyZ4T0KWOfisT2lhrdNWR89lF4GERxzdSjgQEeA7iu8WBnOivxZW+LJQPNizCI1g7MCnIQsYX7PLelbepDWMXduzhai2potJKsscVq/50IBslsIo+bcsbxrIzZMel1OmL+MOKaEWPzJOzZJmpSPjzjrPApu1vIZA4yxgIPPRMpqHZgFWLWfLwnJrrINMejPhWbzNylPXv2xLeh+tWtk0H0OWrKG2ZA2e1Pq6NZBi5Wn1rXnqUsaVxFZ2dlMv07U2U5fvh80CqxGMHYLEE77MtTpABkh8i3/78szT9fR6MfX6RImwpEIZQ0q0QeJxlf9SzZcKdAJgci5fLzGO73J5ZZIlgkhHqfaWQAxClnlapsi/gVBiBQCjXAMSqzVI2CFtJu3EvcKhSOIrc8aZSuhCKbUMJL3gPktFAiPxQkfWvTnd7Gw9tAISudfEqc8FIOq1odLmyu2sSaVjIAYAPgMyAKASWAa8U1p7AsjK/GkflYwRyMWpjLItFWDJ9QpNlKXIM/lK8KzaISg3jbKJlwCMf7jeQ8EPorMREoANiR8uo9XPpHzshxI0ib7N92MBZPolSBethsvrxTsgTf2k/M6JyZdtabGP0RQNpgOW21qcke44shQ2674OIxUkAAlkWNYuSZYyJ+9rC8Es5XpIQRoCZENpacXSSte65vCW0jsEDGuKca08teshgDBL0a/Vfa0erbRqdTgrnlVuq55uDRAdKpMESNqKNKsstTbFIEICBiZ5vwawasDGym9o4EPyPwQ4Zw2e1MqowVgNmFq8yngchmXD7xP9vrFoBGMljWBsgHizYQI7lpA2ikgMwFiZE2vE5LopBmONsLS4mC4vCQkKG/U3UU555UurC/aV+ZB2F6+zYxBXuog3+7NIjYEQlxNQ61gyTgsxM/DQKRJYrgjL7FipbMW1E6EdAE9wLlvCGhGsWJ9GUjZOWOcyQOEClxYqViRLc2SwJmoQyRtfI7YLRa5Ur83pkUoyLsE6flpAo7JenUMBlYo24dLeeNrOIkvpCs7TFsOihJSeybIzSAMILRRAJMA3Gdv4iDW8Y8AtDgmSvPhN0iLlyigFRXlxMXQADyF4l9usBcpkXEaCQPIGydhHBre6pAnMUjs2QGGsELYOUmIgB2siQwQHkM9r7brY4HWHF+UkYlcri3+I1uOxaJyR7jhiy5ZUeCzrSA2UsXKlNynmcJqGlOZ5lB1LcZd8W/zMAmI6zRpAZV5rIEXzw+E1UNWbYXNcmfaQBULKbAh0zQtkNXiUfGi5zksWCJ8FNiWvQ0BlCIguUs/W2bpnbVRu8V0DLLW8JPCYNQAwD3gauqflqa3R2qIs850XhAwNUlhhpWVQv4c47xofHM45l+IuQiMYO0RpKpRhHyf5EQMEJlb8WFvlqXoENHEqXJsU4nJ6WuyeIdUERGogyfhAiiCs8vG0pKxOiz3EOO3eNEijscoGzNcSeEog5hWrYEDmEm8ZvGRnHWnfsMaVYEwiPEQgRtGnB0ejEow1JIGPFKArfmsQNgzGAi9duir/eTghW5TnRBo05ZoqQwzYLxKAIXEtMlLlZstblF66l+1/BYyCDcbqAI3bemoKDtEihjQDrwOSdcw7EjNASchZitsBHvDB1SJyKLldQ25PzAGPExRV3ggApIUE45EGZGkPNQL5+DEvJFwHOWXNoqwqjeo4K5L1VAZ3aLLsY18DA1yrmCk9ivXAm3HMTxtYHFxtLBh+pFtH0+kUQFZurBFo7eVsFtiogasawJhFFgCyQJOV9lA+NUV8llJoWTV0PI7Ttm2akimnZWoeZNq6HBawtGQkz7V7VvktsDFLWa1ZO2pAdZ7f2pJjgbGhNjRriuy8YEyHkfLR0w4tS4/8rWXLfUzXr5W3VScatM0DyqTMrLZdA4eL0rxgTNed5qnrumr5dNuSYRehEYwdotQJtUqqrQBKJUjqeQoUlDCAFeUcKaepOoErnxaPKm1LcpuVcQEWWOnVQI81O4cMtPQzEr/1kR5lNTKXk/mBsACKMuq1cYmPUNDSPX4JwCQIC+Fcyh3gqYBN1FlLwCWnCzrBUF4rhoLnYMGksuiJZ2csSpPyc+U16SBGhRYATAAXGUDVCcUDYC9/oWTsgt0JKZTwBqBixyxf3JNHlq1YexZ5aGL+HtE6Flln+05q56Xv/ewdhE2ePr50Y/nVp1/cM55LdgtPJXwv5sV9oWiQKMMzj/wRLTLJZ117BSBjPnTiCkvLFLlFcur8/kgbzscket8Ys12JAYOR7jSklbIhJVuTVCQtBcuieRW2IeVY/7Z4tkb4+b5WcK30ZinplqXHkl8NSA3JSMaVZdHxazLR1hBLqR0CXUPtoMbrrLC19mPxO2++Ml2Z1lB55XWNJ+seAyvp6W9IRrqepGfCWXzMAsF81OpZg/pZ5bRkMy/NAoRD7wFrQGdIFrXroSmMhyKNYGyANtABhVokkEGkhB9YR6JstcmWCLkmCUlBVlhGACWtVVEP/MggMjRfB0teTJOnPfICqwKIkTjHa68SL3VPdZYCyUDGq6AMZuAAtLGcbTzY7BVDckyGRpOYcsOy9UDroSxiTYIa1Ed46R4DtMCtdKpe2osYPHTRItqBsqXUIVsyuSzWtE+rYhZ5+biYmH5ncpPMwk3TY30X7ofpfmy9c2ItlnSQIa2XWe4ZhOmpjAReqNQIaRFFm3H0rO5iBvyuZwzUcXhOv4nlS1lTEKwLaXXRqUfmVgqgHNQQSDTe4nau+qwEWelajnAa9Rg/QMyPdL/f+5zFwjpCdi7CAkgPkYUjOjLlgDFtOZxDUfqU/XU0OcliizcWKQHGRNqZNE5TPPBpYyPbIucFYhJk1Pb+qinSNWvNIpYYOZLPaS1iAatZgIaUdM6HlU+pWGsLStM0aNs2yUceQ6StPJyGVbZ5lFat8NZkcmvc71u0iGI8Sya1NCWvrMTLfa7maQdDZAHfISCv4/K5bVuzDoioZwEaAmoyL45n8Sd5r9VdrS6tqYqzBkyGwKsui87f6q/SOj8PKOU4o2Us0wjGBqhQ9pJyF8n1b5cbHZcT4uz0jUaiA0vgM9CmcrCS65yuU0BMAq6YeKHMqnyLe1aJMhBzKNkOXFEZVAJPQ6OVj4qDxDnJu6dpp4OMe2XYkJvENxKMlRYxtf4pTffks8oiZ1Ce9bVFfTbLa6s9pPVTlJ3ugY1N0lbpIPR4kXi2RuWC9EMhDSeEvPgegZIDTO1AhTFIbp2qA8nysqWsKGbJh1A/0SPqh6oHEq3VifKmS4lyqOBHtnNJjlQXYXBYfRPkcvad6DtwC2VwnfaLYyDGeariVBmcQSMYO/BplnVm6NksEDRvupaFaYjXWSP9Q8rgrQFii/Aj+diMfLRCvKgVcR6yZFGzMsrzrDQXKes86WorkOZxXpA1bzgLvGge5P0a4JXxdV3OYw2bpzyWhW7eNjwL3A+lNY81bSh+jTcpqyFrquZlBGOZRjA2RG1jgJcMWqQOyc4jeNQ8/yspTwTzyUW6GG7vk7KKOR8OzRVTUpET2HHBelMwLIEXK3ZZkZZGhXQiBltaIc4gTAIxKkLJNUOwLXQcNiquzospiF6c030HRxJwhYSDbIMww3o5afFiNZpUzXjJASABmOMzssORZA2jXJZimmKl85N4NvR+cOKi+r1zOQ02exGQPGt0FNdgETbimr4puSglu22ikE+4ytUW/jXItsUMHOILOXqjaKJZxrs4dbGJzawJcgxryBj0KC5Sh0JqSL54mZZ8W6As4ToJyri5MbYSfYEcRccoMhsByFI6USqeVMlL9ik0wnxDrmHTOIsHSRDXy8HBwYttEWQ0ObGWFRRRnl668QchbGEwJ41rxg580s4k5gFns9YwScVeK4rzWGg01RRXix++bymLs0BcjWaBRx1WWwyt8mj58Jnrg+PX8tRrl+blXfNglUHGm9dKYuW3CLCdlabFq25fvAWD5lvTrDZea9uyvVn1x3Uh604DOdk+rDRqgKkGbIbqRqer+bDSWcR6yNZha083mZ+0YEkZWvxrudestbpepKVxHhrB2KFKjVQWo1bGCrWo38JaA7lODMXfPNmLshfFFNih0O4E9gMFxVpuUJwVzRIcFbedK6fPFQnHdCMIk2XQVpfMUlYDJfCSZAGxQiAJiLmSJyFXpw8FxrKcOUGensgeEBmUlYcEZENoiOunEEDy+OhCr9GWsB4IM9LX712LBTcrgAgolW05s5BlGaf7JQzIbSe1URNKFL9ktclJnYh+G0un/QHGOiK4LjkkDG2lARofvCz2ty5ALgvLkcMRksdBloncFkDzX/a9nE0Bghn/OIgtv4wGL8EwT6mkCCR7waPsSEQXzdpgNXeixnFXTO42ahZ1XjtGQNiwW7wvxJZlsX+5XOb5v3ejZewgIMuKVFPILEV1CIjVgMK84M0iC9wNWZ/mTXdRgGDJqDZ101J0h/jSyrzOc96pXBy/BmZryn3NynhrQJS+vxmSyv2sel3UGqnjSZBhAbJZ4Gcofb1+TLuclzxYlkorTf17nkEVvtZATZdjFqjltXRD+em2X4sjgWoN2FsAbgRjmUYwNkStUOsYFLmowQ1YONQnC4BLnhhLj/AMVFwZPGeY1m/J6V/ZqBQ7oVbbqkCMk46aHwmLnrjWQK+vcgfS68KKX1obLvjIimsRrwLCsodKJ9zVaxtNtoTFZVPwzgXlH/HsIpDUgLeAkFyvQjDMexvzLkCY1splu5jxEtjcty3zwEAsNUcJHlDKnZDRERA3ZubIzIxLaTjE5o6g9BOFtUqeKImC15+VDtkdMvwNiXA9UoOMwRnbyPl1xUtTtCMn04cQceUj1y+RCElJZkRlrROihYz7eUJuKmEFWgNEot59iu04FI9EOaTc82W23IYN2nPrrhOnT0ayIYAbTsCgDSxu6RotY3csSctYzeJTG7GvgSprP6MaKAFs686QNUqmNw8Qk+nVlGkOO0uR5bBagR0Kq+PoYxa4ZbK8+ml5zOKjRpZlYgiEzKuYbhZ4WXmx/PTasHlB0BCo0GChZqnR/Fj5SwuZvG+1YXkeksGscs1q//q+FX6obmvt0rJ61fi04mgLcC2e5lm3080AqxGMHYrURlWItTaebxUVNsqoKpHU21jZ5R1/eM8vtrwEJc0pjSsCJT4LHwppk+OUQ6FiogAK2n09kJXdCMaSQwwALUnc4cAAJ6Tt0nS/EoCpRt5TWtW9xIsELBnPOAQAhgjE+tsE5AJR9PjBjjm6KFuPMEqfFNTWRdf5bV8zT51Umo+Q5c/MpV2l1bkAYwagu11JCdnFg9eNOZdZYvNPmtYZn8u4AoilMMmVpA/T3Ahw01C2JbgEyCYpdgYlLvYb14VEXJxK6RzQxOmKJNp9b/2krCc2BQEKfIp7Si4OpbOSJvmXjLCLIvgioIv7o4X+KdqAc0gmtNRmXA4s2kxv8mTsT6lVcFspRjxKoEQuvlOifUzOfJWrH6V4CKIZS7DI7WHOhfYjHVzEYEwDBL0o3gJV8v6Q1WaWFWFeYFFTkjXQs6wm2mKlFWXtgnweBV+XzbKkWB70auWdpVDLvZj4nrTGaUvDPJY4bfmaB+TeEWSBf6B01qHLx9c1EGnVD8eRm5hrsG05qZHP+VrXq2X9sSw8uizzgrNZvMmprHqbBsm7jFMbILHqQzt+GZKxzFu60OewFvjXIMvq/1z+gwUo3RE0grF5iBvbAg2HdUa+4rViSae0AIvUKhMAjEFI4poycoEHozKdFHKOnDKmdEummw89QUq7f6fiWcE/K5iMoGQw3cejrlsY0qKSy9d56qTkrkSYeWqimI4Y9WW0Lq77c3mdlwSEPRwVATCbIYkFJJhJzIvrKKVe+7g93jM9ICmzoQzCtLyT5g4hYNE+BBDL9zl8/DB5AqnNkHMVyhbPHzJ2fx+BGUMuyixoKkQoQRd7xZCAQwuFyiTzdMy8RlCoV2Vs2Q6dKlOSg2yw8Vp05H4Tz45oUm4k5C7rQCbAQLHgktS5l1mfCVmPC9C4ZuzgoXktHlIhsqYS1UacFxm5rwE+ndas0XHL6iQVuBp/lsKs09SKYS0dS6GUz3SZa0qovpaK/CwwNrSubJZSrKnG121Js5TreaxFfNZysuqsZhVdBJDX2l7NMlVLY1abssopy6oHB7RV0eq/Fp+1e0PlswZgau+VeWU7RJas5qXRMnYok1QImahy3XvEzjqyYuVdUFELcJC8x8XY5JOrcsYBYU/k/C+kr/YsYwAmz6kclPJwRMk5RpvSZwf8WYVlWwKQl5xEvFQ65Cjy4jKUyqPGQVDnNA0zWhwaODTURPjFnPGkOAd2ej4FJYvYlA2ZS22whi21wITBmJADCMkPO1Gw/BABFFOiVErBoMCc6UzlWjuoMDP0Zn1t4SczfsYe8XcoU6zdDEb5nDIRtZD8z7ex/lyux7Q+KobxFJGuB9Y7wBO6aQffUfATQqFtTlIbSpwgbHlOIPIA+WD98T6zwVmlxpEFI5tJKI+QViMl7WJ1hUjc9DI+ka2aQWH+h+iQgzEkQbzAexYsl/trsZYtg73ehF6KlrgGIEaxjc9gqREVBsB3FKeGZohrTVesfmJu5bdnHcDSJuKMdMdSTZmUZ+sZX0uLglT4NADS8TRIGNo4umbRqQE3GZ7T5Q2YZRxtCanlpa+HlLl5FXoNDnVZtJMOKVd2ey/LpMGYntY4y+I3ZM2w4tyeYGwWX1YbqYWZJWcpn67rkiVJyt9qb7pd68GIWdYleb8GziUt0oYsXrh8GpRJ3jRoG7KkSvloq5dMX/f9IeujVd7bo92NYOyQJ6Myybrt0iP5V6r2SedyLjsyYFNB0AKLtKWr/NLDmrN1rgKQWTxTGZSyc4Ym5SRVyhyW1JGVd5UXlRdOHckyIgUkBFWqtU1U6CUYy1E7BmNRHw9TEptwTFpgqVE8xprwLufpIiBjTZ7BmOzETsgMKECYdU9F64GLnqhU+AJHix8MrsipukC45wvh5vspomNh+ADImGlG5+y0RqIkzqxzCZSR99mrYEyijY5TuO0wIEkWIgBEPp5zFmh6LCcQQsx/IS1u36qR+5ib0TFyVtyuvJBfnEjM3ZAbaUpbAbLIGJeubN/ZwQZvo51SKfqFaFBcZ3LfsBjOU5mtUnfQm95ZsM1CXoxGMHZw05DyUQNk8l7Ny6EGbUyWUlabpiTj6Gtt2ZIK65AXN4tqlpShOBbfQ+nOApWWQqwBpiU351yhKFtyHyqLpQzPa+kZul/Lj+8Pgavata5zPktAoB2syLgMUmR8a+1jLf95BhCGymi161mWKCvdIUA2y8GFTN+SqS7n0CbNNXBpvTes+tLpaTlYeSxCIxg7VImBkVTSJVgSdZzXV5XABRAD6A1QbsCMUt/jGAKIsat8bbWCiAoe4U9KqlWWnLCeeecKVbKfQIQmwcLHj1rXLwPLSUzzy2t2st6ZSC5AI865iX8bNNEeKJ10sFy7dHbwjuBbB0xckO9yE84TRNMfUFjEEN0y+i78Fhax4J4dCeomRVgoxY1IsthXS8k1yz2JI9SSK8XAVAAxAfJKZCaSjGud2IBFiOuxamAt/WWffbHdJLTWhMTYFbtrA2BLiIiClk7RtWQTKqKbejQETIl6Tj0CkAaCj0veglrYpohgIQ4Fg4oBjaIBc8viBkYRoFB8ccPFza7L9ORfFzmSdZ37vZK/4BHJIpmZL+ow3qG4cXhvumJKS2QgXh4kCp2WAqKUTY4Akbi43sSHaJymeOCTHj3XFi4mbTmSyh7f43BSWbOAmAwv49TcwdcUVUtxmwVedHo1y9FQPjKu5nGWcjhkqamVR8dt2zaBMLm5tLZqDIGJobLI3/MAKt02FqEawLIA4KLK9yzQLGVubc6sBw5qaUjrTs1KpstY6xeaLx1O1qvuT0PWriGwPwSaas817xr0y7jyfSDzl4e2Psp0NM9AXo8nLXGL0AjGDlXyQpVlpTGdZUAJi/ggsecXB2OlUSiPHMlRnmoVlcAAxtgmJIGSfEmJlx9bPoYAWenOUUC8pgfESESRrviJ8RFPtSy0xywzByQ4lQAKlQdRBoOBi+AOohETJ1mV9kKuG1GZ75ifiQNWWgHGYuaNLAUBiAAsufwgAFMAPK0OIsdS7y7OQHIyUnh8ZPf7smqouEzYRgKNAotIPZ3vi/rkKX3U5LqQgAwuNlEByOCk2KPrfkKQpkOsCIZR8TqhwpgJt11C+k1TAnlKMz1Z7GzL5NmhDRpuQQi7lRE8TcM9EpBGA3yXy4FYY9nVpkNepyiEShRm+gJhSm7MtSQGTgKIEaX6MNGyrJQiuQAK9VBJchZS9CnK3USmodP0ALyL+9zF9wG4bVroUAAyfp80iEB3fkUICEBs0Q/DaBm7Y0kq7BKMSeVqyGIj42sQJgGQNSIulVgdnsMtomjNAmKWQirLoZ2WWEBpSCkfAgpSgbVAmMWXjiunJk4mk3StFeSa85UhBbQWfqicWkm34s1jUdL3h/iQbaIG5GrlG6pbS94cR1rNJD8W2NEDFZbb+lk0q13o9CUQrIEnq6y6Hw7JTpdXpq8Hc6yy6rJY0yY53JCb/FrfWJRGMHaokufxaEpKXlbSNHTJ67cEhEuKcFAc+UA+WHGSGiAJ8FKMseeIBBG+uDJIN0bJYE8jLHnPAIgiEHMZrchpliJhF5Va1pUloNHCcYWKyaBMek3MlJz7RSCWQGHjhBt/5tqh3GSLTQwRjHkPxwjCR54JxebdEDxrcJXArI+15BFc7/NZhodqOkLaJK75rEGffJ6SpTi1ziEp68X+VzGyk4mm8DFvZpJcBkVJ9CTkKfpASoh67YAAeJ/dvWjXL7k+pRU0xHRcP1JIqX9k3pvId7GnFgdyyCakuD7LR57FbSFPttAJ6db6SuXbIR9l0eeaZXifehblOijzcmV5ncvuGOMDonQFFJI1GCQEINbEfjDSnYq0sjg0Si+pFs4CGrNAVU35tPKsPR8CALXw1sH8APZ+XzUehngfAiA6zqxy1Cwc8rcE1PJalnuRPHW+lsc8DRKsPGppWGWSadV4lPUl68W6r2VORMW01SHQKH/rfGptYdb1LBqKp8EiX1vrteYB37X8rTqsDZhYwLoGmGthNW/zAGw+HyxA6Y6gEYwN0VTM1e0BiFIdYircPvDDBBacPbUPiIoZJcU/wxIn1LkiYopd6bYo1H0LDSAoixFCaZcViHYLdI7QuQh+eA1W8Gue+QYlSyI/dsgOQtKeYSwkAcJQxAjaPbvTT8ER1oel/doa5sdFr4kIThEaEYMouGQHAdRF4NVFIEbBhwIBLYNHitGlUH1ZRBDSJsQODi46GWnZFkTZ3YhQwcFuIxKg5BcS8qqfEm6XK+TSeibEjyYInnyEmV1cK+bhuewNso8OV575IPDSOYJ3Qbq+QZjy6VzcDqApE2MkxFUGAMsO8IDfCCWN+FZgI2n7RIxI0cLjkRFUFC6jDs5OzNFz8V7HFiMeHABE/wqF81OWU0CZ3GtlF8z2UK4pfRn7EcW8DCrxWmIm/eVSh5V6ud5z8gKFcfQ2Vg6H6cKF9GIpcxGf2fCXlfVN4LDRMnbg03Q6TdcakNQAkmVBkmty2F3+EIizrAo1WhQgaiVQjtxrwDCdTgvgYk39k+nodTKzwJVFNWuQVq75esixiQWm2drAzihkeEtprSmzUgbWmisJbLR1pAZyNdC1yqZdslsAc16ZWkBYOz+R4aQc9ObMsjzSejMEvuZpD5aLeGtAQIbnYzqdwjmXzkTUs5bW6lyfpQz1/VmDEHwMWbVknLZti3LrdqPrk9PXTm343masXHdWy9h+34TmDW94A0488USsrq7i1FNPxSc/+clq2M9//vN48pOfjBNPPBHOObzuda+71WkOUjbF9FCPK9QhJ5S6DG6S9sgKY4GnRILcWIr0JdlArCTqAzwbfYnbuQwKf4gjWvokCz3rieJUFpdQTvFjEAM+a8FIAFNa5tLhLH5i4hyL14JFK1iYR5evnSc0HaGJoKx28LRDmEcTwFg6WjRo4xRLeUzSGeJ+0Lj793L4cN3EwyGn32ACR23K15FDQFIu8xdnYjpRDquMbSorwXmKMurymeXIh+wQPQ8mBHJcV6oNQfSLovIkfI3/qGw7EKEl9jIbmEBb2f+I5KE/iJH5Mii9zOtDHzZlqJQHcKxkVPrFq0V2pvAuyV5US3lK4FckveC3iNeMLXLcGdeMHcjfJktpZrKUzHmsWzpuLZ5WVmsAa94yzApfs4YNTU+sTXHU/GqldOiwyqotA7PqQ4eTCro8ZPlmAbGhfCUgqx06XK38GtjpNKx789SlRVZd1+Q0C0DOkptF87YFq43p59Y+eTVZzCsfjm/xbT0fKuc86dZkMpTnrH6zWcvYvHLbbPr7i/arZezSSy/F+eefjze96U049dRT8brXvQ67du3Cl770JRx77LG98Hv27ME973lP/NIv/RJe8pKX3CZpDhHrd/KOUKk4RLymvt7DipRJchSeCg0xrxnqg7CshMl/MohqfMTpU84nps4A0gt1MUCZkGYXlWpqXd48Oe/wm5VfH0xMTVQN02bShGQRC78ZaGW3HpTOTU9RZitCXnsXFH1qSBjSFKglkjHA7ucbH6bhNZ0PoISAphO8CRCQlV0HIhd1cQeKVjBGgk3856KzkZACu7DIJKdXdrHGutReeNJZbl3Sd+Qk2o8KEJKk2KWUEZ1jgFNOI1VcP7HGXa55nqZIAFoXzr4Buihb33agxoGch294O2Sek9ggL3yL7TyuIWT37eFl6NK0zXxwrfN9OV0x1xsotm+fm61n55iOm7MAMC5uY5DYZH6CVBirNyLvfq4pYX4oEJQgiRYpOyTxIuX8l8AtLBFXm55aWl6I/OI9ViSQLXrlX0r5cMhF8dg6stFzkTh3Jjrgv01KAZRKqDzX4lppWCSV4RoPchQeQBVEzJMXh+M8peJnARUJBKRlTKdp8b6IS/6h9IZAJfPK1hr9fMjxSs1tuBWe60BaOfms5aItRpoPbZWzwMcsq58sN1G29knerXZotWuZrjxbMrLkY7VFvam3VXeSLLBlOb+QdaFlJvsIk1zXJuvQkqe8p+NYvOp+pOtThufnMs9Z7xKrrqywmh95v/ZuqdFmANbBAsgc7UdOTz31VDz0oQ/FJZdcAiA0gLvd7W54wQtegJe97GWDcU888US8+MUvxotf/OLbLE2mm266CTt37kz6fiYJjPI5A4gEjRhriLMrLUpACcI8gTfMYm99DRpMkmpeArKg0PtoKYoOGRoERxasHDuhWBIB0+DVIGAYdhrfFspjtmQQpjwVUHoq5OmJWT2O1hOgjVaYhoK1xYl7pW2gjcpkk84+yjGIQMo05pRRUywn34sFYtTnOBVKYm48MJH8xGgZjJVQARGgkjjYNYUTMCJYqvI0xSYBsbKuJACbiutyylq2bLTgKYrBHibvSWJIFyYndtEaxTCvtE1l2C3VeEYE0ZoVcaZvw7lrs7GtY+zlZOOOnhZ9fJjOEO4uQyTZa/LEVIbluSU4dLH2s/WN1yv6NmfB/HQt4jo3MZUSjgWf+9VGQHQTL93CyHpiOVLqUwlgtk1mPnVAiuWkONWV98STnk9z2px+F3tXx02N+1N6PzDocqIDUJanGGtwKp9cpxJJ8rsCuPHGG7Fjxw7UiN97r8WN2IJ6OIv24ib8d+ycmcfBQgf8tykq2POSpezXrCEyPCtLPC2Sn0sl31LG5QJ/770ZnuPo9PnQZZQgjBW4yWSSpq2xcwxdZiJK6TOP2qJjyWqWcj7LwlKziMg4tamj84IxGVdPOeXfFkgd4qNWHg3G5L1amjydVIIx7WRGKutDdaEdcligUJahBnRrfNeoZuGx9oPj57X2xWFZHhsbGyme7I86vB7gsPbek7ywO3xrumotvEx/aNqvLrcF3odkK+XE9Trvt+lDH/oQtm3bVq8sg3bv3o2f/dmfPeC/TfvNMra+vo5PfepTePnLX57uNU2Dxz/+8bjyyivv0DTX1tawtraWft90000hLkowRsa1PueRcL7mp2q0nX8wEOsNXwdtTb8SJehLjixAJU6UaZORNnHarv8I2WticopROMgoOeH05QyxJoKddF/8Y/AVUmCIQAyfYt4UniUtU5QvedngMvqUUk4xEK8Jcx6YROA18Q5NtNa0FPhoCtTcRD2eoUFOlZK9gLfgblJcX6j4pVqc4JFYe+cjUpReFbmoRICjAL4630SdvW8n5baQIRbFdXYZzLhkMct2yBbSDhnBGPnUprz3cVmYD1alBmwAArW5/QWnHw7EDiLSBskue9qI/AQLGTdJSl2gKHuqizzhl7gMBJAPLce7jFlYXqmxMUkeGgqgKuInHpDQxDIs+zBihTCHEM9EHZKMyfFdEVqW1IEC36kps4ApBy2e67zLX7I8TvHvkDdtH2k2HRTfJsPj4axxVWnFkqRH9eW1VtJrFjm+toBCTTHTSrI1al4LzwrrvNPiNP8afGrLwBAY00r/EHGeVlmYf2kR0YqzZSWx1ioxX9oyxkq1lJnFh25LNapZs3SanM5kMilkoNeO6TqxtlXgNshu7DmNofY/j41B94VFyi5lYPEylIasV7kGi+NbaVj9zCqDFW9WG6zlZfUFa7BmUdLgedY+aocK7Tcw9r3vfQ9d1+G4444r7h933HH44he/eIemefHFF+Oiiy7q3WfLmFS9WOUP1B+LlvcTpQQor9LjRizXo7HOJ1TunHdQ7ghSFY5XNSDmUIKxxGQGY/G1Xjjv8DxCP3HZWx5PT2R3g0RgZwsMehox/a+ZZuWaQQoDFYYCbEDxQLIYUXJ0QgEAgvKaMLmIL3kEiaCDYn2RmME4BVwXdfFpOE+oTVasFpPIUzhTOhw2itwCyGGAltfpZEtMA1kJrqhatk9JOdKEwS2DBiC6/oPrqLAuJZBbtAxOEKkllC005N7GgwFdXqWWLVGhdU0B8vDUofOhNjbcRgDKbZy62CAB9S66CvGRVZLWxaYBXJsbYQQZFM/BpwrBx0EIhrilpYdhDU+7I8D7ECcKIq0dBEBNAJRBnsJnokN0hMFgTGzwTOUKNhJ1l/ZVI+S+mkgAJmYtyV2CSSsWpx87O3+HnbiXi4/Cr7+Mj/J2hn8ZDpah56cpFl8DNp0d5KChg+LbFJVtqaRrQGHREBDT9yzLglasLQuRthTUpjNZwE2GGbJqDE3DsxxJSGVSOyyxym/lLRXIWYBMhrOmxElemP+lpaXCqiXlZjnCkIq2BjMSrNZAU42s8POCTx1Wtwe+rvEvgaNuI2y9mU6nybLEirw11W2IV1mHGqjo9kLU90bIPOo0NT8W+NeAjONJt/Ec15KndS1547SlrGfxra8l/xrwD/XLIdIA3gKIs2gzAHAzgHF/0OhNEcDLX/5ynH/++en3TTfdhLvd7W49vUhTFYQ55CckQrPCBRXRvJZKV0JW5r8UXA6eOzHKzoAMSNprTlGVxVUOzSARoJRZByQLWfgt1Ws57S+DlHRmnbOY2kklACxQKyu/VARv5HU8nAdaz9P9GIxFJxgJIQUg5tXatTxt08G7UA4+S9spCRiBWEZ2hpdAQ4vg/dEhT/tkQAYkCyl1PgCxhl+2SLggi4OKvHtgjALs9SA0xE+zBY1rpBFqfLAH5nbmKUBQ+JAp++4oXMtzbBcsPZRAhc8tzHEFU2bR8Vq8EM8jY9IMKliaTlxR6l6yzQX5yHbC4nG5qpglbmuqU7OMigep7ziUC0hlHqF4jrhtU4JlOv0C9iV5AcUjlmGylKmPHMtTpZ17dj/4IrQO9HifJ85Itz1Vv01KOZql2AxZszQtYmGwlFitzNaAmIwzK22rPBbQ03EthdGyiA2VQZdjluznAT1SIdfTCS1vgbIsGnRbYKwmnyHeLNloWc5ShqXiboEa6/kQ/zoda3DAqmur3me1p1pf0HKoWch0OjquVQ9DQHkWALZ4G6JFALUMp9v5UBuYF/AvGlbyNIKx25iOPvpotG2L6667rrh/3XXX4fjjj79D01xZWcHKyor5TAMWVvlYqZWezVIEeQYScJH3WZEk1vhzBkn5ZLsFPywBGIV9pUzAxHmif/TKE68TvnDRtOSyqSlZpig4gwCC572oc6e1V1O2jrlkEXNxgl1eHcTWMMI0XlProqXIRUchkbukZacFSAB82sjXgdK+0wl4IfITAVjjHVpqMcFSXIO1jDZ5JlxCAGHBXLWOYKGbAtiHMHVywwFT54Iji0lwEEFtE612yEDKqSpPWC2WjZ2gLMe4Sw2KLQ8ApE3FN3xwyT8lYD1YH/2UoldHgh7sKt413NY6giMCOo/pNMiMjUorkeEJkOCowxQurWpaR3BFsQ6PDlM/RTedhmmWFKcwNkg+PHwEN50LbuS9I5AEY3AIlrIYYYkjUCwPgaZijR+y70kkWBOgMsED3oMiH8yLj3WQpk8mBBbriK297Jbfx57Ezcwi7jNsSmOSFS36O7k4ch1bPm/N4IoIfCeC4ow+MzgDg0XNmCsvRX8OSVACtDwl1QJns+hQB2MHzbfJsM5YIKJGOq5lNauNfluj7notEJ81INCuseclDWCkdUGmKy0M2kIxNAVQW3A0/0NrriyluKa0S8DFG0E3TVNYxnRdyDU9WsY1L4izZKnlouWjwZCUT80Nfo0sGc+SdU0GbA3lNWlyDRZQWok5XQn6avUjedVtSTuTkXFlO7JkNZQXW7CkHGp9Qvd3bXG1rmX6XdcVstB1Y+Wh27cVZxbJ9GrTiRdJawRjtzEtLy/j5JNPxhVXXIGzzjoLQGiEV1xxBZ7//OcfMGmWlMFXBmJi5LoHiNIfMeJdwU+pvTh1S47355zNhCRy5AQMMFZkV/DPyMbldPXCOVACeqWnRGQX6gjrqfgMAcSCbitcS3A+vLcVT40s8iJkl+o+FZXZa8XvBA49IhBjZ/CT+HcJDZYQvB8uA3DwmCSLCDtxmEYwNoXD1EXQNGnjuVFWLUKytsh6YVC7HIHYpAGWYxrLbS5zEyMnMNYFZytTAta7cH/dBy+F0ct8rkQnzgzACZhSCA8P34UJlg1RnKbIK8l43Rsi/PFwmEYjUnQ0wY3Kpyv4WBzOzjnRvBIgoiibiJaScxWXeXYhMZqy7TGPSzSxveT1T9kKK0FM4yNWckjGOKJYB3l0IwPe1LZczIwi5qm8sCkHl304kep7vPE228YYdOWgOQHJYkqOrGxEHx3iJd0m8Wtx2sDiYOzO5Nr+4Pw2DStPtfD6d22k3VLeLCuHVqxr+dUsGjV+LGvPPA4pOO1ZYKUGLGQ+Ot6Q/LTcNN/S6QiDC+l0oyZvS8Z6WmPNSqP5ssChBeykTOVeaJacdbk1HzJ8DWBKUFirX5mWTl9bcix+rLphkl4gdb6SJw3I9FRha6Ckli+nofnWgFLLgs/6udWPrTLoMFpW1nOrv94agLUIjWDsdqLzzz8f55xzDh7ykIfglFNOwete9zrs3r0b5557LgDg7LPPxl3veldcfPHFAMIi6C984Qvp+tvf/jY++9nPYvv27fjRH/3RudJclPp4prSMJSUvNUYBvkQsB/T2TOIzpShOpgBW6XIElxTecE8o/ipdqY8l5b2HFgX1FiQxUxlChSwpKcG8DxdbxrJHuWCDEogkOelgixjBwTPwYm+NDnGXaCBYwxh8BctYQ9KvIeeZgSA7DWmiy71yf65VODQgLMNjEqcjhpVTGwgrrNbgsA8NvAM2lgDfOPilJoCoSQOsttmqxSa5pFHLxX/RQwSb6iYUtxTzwBLFNHx1mmIAYj57AQyL6pJnwmQGkpXmmpKNDR8sTxseWJuCOkK33oU1V9Own/kkBmeA1sYpm4EbdvoxSc5JHDyc30DjCH7qU/ma6H2RsaVLNRYsZJQAapSPA5IJiD0hIrTTbkq8dA55gmuAZvIXYvqIWxakVpuwXrTOMSAkthkxk5QdfDCqLEj059i+EkJxRQ/J97hciQmXXwMpd43kymmXMl0qriUq5JMrXiAZVPZsgwvRes5loTh3Jjoovk0KQGgFUCudWjHTpBXNWeElaWW3ZgmQac2rWNWUZh2XLQrS617N8qP5qQFJPWXQUootXnQ6Fh/63pBCa1l12ILGlrUhgKp5lCCM0+DfcvPvGhhjixSDKit9eZa8cDy5cbd24mDJogbMuU4ZaGjLmOZNp6XbvSwzx7XS0n1MgikgA0PtJl7WpQUW+XetTdXAUU1mGpTOC5zm6cPy9zzvG5aFtNgtQiMYu53oaU97Gq6//npccMEFuPbaa/HgBz8Yl19+eVrk/M1vfrPoKNdccw1+8id/Mv1+7Wtfi9e+9rU47bTT8JGPfGSuNBchr66zuh1VI9Y8ZVuV9c4dQBxKnxPBWcHUHg6pzKcAf76XQsIGlkanoGBx27lywZUTEdNiIUTLV3TSQQgOMqas2/I/nmTGzjrCBLhpVBKnoKCvThjYILdEF8tEcbNhR9EqE6ZgtZT9YAARgPnAh5uyAj+JfCzBYTkCMgZjSyC06MAT84A1BAvYGoB9CFMSsRIB2NYJsNKG6YVbJgFArUQw1rBCTwBtxPoWfLPpkBHjBNkRCgPRpMSLo6Ps2WSD7zmxuC5GdDGxZgK4NocjhOmNbFnbOwWmhOnuDWDDY2NfmAa5hIDxWhBW0qRN3k6BgGgta6LDE6BDQwCRB/wUHl3AgBTYcpOMFblIU+cjNqHAo6MMkNo4bbFBeOaBjrrAN7i/8PYLiLXl0SSfkR7UBaGl3SJi8Rn8UUMZ+Ml1VtwZJbNF75CIKwMmFSgHSeAog7H0DfA5nfgZTzYzIK+DkzMhqXckhJozl92Zy0/h7cTvGY+C1ZHmpAP+2ySmMtUcVQyRpZjPUgjnAWS1dGQatXSGFMVZgEwq+dJiYrl3l8pizSKmXcTPKsMsyxOnqcHYPNMLrTTktEa2rllgzCqfBDHSQqdlZYExBlByemDNaQXzq/nh+mG37tPptABm87YzDcIsaxRfWyBGy71Wxww4NaCwwLaVt5yWawFvy2I2L4CYZdXaTJqyPLX+qPvAIu8boD4V81Cm/brP2IFKvKfBCgBE5Y4ou4cOhomoeLlGKEguaqZ8BC1M6twWGGPrV7m/VgzRiHNq7zFUAi75UaOClJaxPF0QnAdH5E2dGyC5jmfLTnKTjtJzIh9TXh02iWvF8oofdoixAY+N6IFv2lDAEytNBiWTyLSL68OoA3y0iMV9zCY+45pkEeN9zLyD64KEAwhr4nTEpQgvVgQYa9KEPO+A9SaszVtvHNYbF9Y0bWsDb1smwSI2ccCWNvC6HOuDhYEAToKgGYzxnM3ILG9UncAYtyHRGLieppQNgtNYjx27MmwAaiOgCY5HMhiLQMA7YCM22HUP7ItWst3TYCnb2wH7PFpPWPWEhoBlT5gQr6Dj+g5wtcM6Oqwj7Gy3BkrQehqynASE7nmzaBexowOmDePHBpT6yySCFhFhGsu/1gFd2KduEvfCW442O96LDDF/wGMaIb5vCB2DwTaLITsjVC4YCXmx25T7K/dNaaPmvgY24KVOJsFSegekxYL8mwNRPqey5Lz4WndfbhKpB/J7B7G/SiTvY2ennC6/ezYw/z5jz8ONWFlwn7E13IQ33In2GTtQKX2b4joyVoqkZUECESArVlIpt7y9DU0LG5qaZFmMLMVUpinTrqWp+bPAiyS9zkc7xZDxpQzkeiPmhy1F0pKmZSjBw5BlzLLiMPiR0xMl8NN1IV2hSzAmpzpqAKVlrMEYAzk+S340uLAsY9KjoTUQoOuIrUQclsHYxsZGsR+Z1eakrDlfuWaMz9bARK2dDbUpWWZ5yLhSTnrtl+Sx5llRt12rTWkZ1Moh5a6fy/iaLPA6K12r3Vtt3Rrs0IMKXP/zfpve9773bWqfsTPPPPOA/zaN3hQHqINQdRhnOQRlqGHFUn3AeBQ8RmSFKChFpYc1hxKAFU84n7ZRSjsjrNhBRMRiGqSYNRe7SwZ4Oj8n7jCQZOXOUTaWISjJoGgZ6xDtUG0EP2FdFqOrYAXzycCzjvCIVtiJBeL0RJ+BDU1j/h1cdNYhN2xOYDCCFMdeJIgn2wW0RGgwjeiHvSQCDbpYr2Ej46DY+tVgnfOrbQBeSw2wYzkCMBfXfBGw1GVGHKOljaAA+/VQ+TRFQlBNBJYTnz2MFGBMHNx2gAxMPIApA4aEamJZG8AFWxaapQBw0ABYCmF4h+SuATYmgdW9ywF47N4Adk/RTQl790zhOsLeNQ83jevKPLPowDA72M1462mu0SkcedA0mO9cFyI2cR4pjx+QAzrnw0bHbBWFy041uB95hIgd0G0Q/AbFSa4U4X0T3cF4BMf5FKdaejjvgY0uejUMInCMuxyvgUOUHxRoMhSp+DcBJB774NDc/biMHDENmoj0U1+MoJgjgtI7QTaFPFgSyl6APsmgE3k5F9oXe+T0cS1clMcitJGLt1Ccke44kovxpVJkOWAYopozDAA95dKKB/TBWE3BY7JG62thpQIneZJreiywYXkotJRKyyKmLWlS0dY8WyP8FqCUchoiLpsshwRLk8kkgbDl5eUC2G0GjNUsYywLmYY1TdECY7LM1tRXTovTYDDWdR02NjYKixuHnSW3moyt9iPLJNuRTENOOWyaxuxv84DPpmmKDcf1lEXJVw3U18qp782KV1srpgciZHirzcp+oDfi1jzWQJmV5zw0j4ysOAcDjWBsgKRSlPQ3II9OJ0WaNTPqa1QhQqFzu6Tq5XuiGwhFSxyssbGGlVFWCK5AWQAqrNDxhCitdvIvyUUEY+w6ngEl5bTlDDwX1Uk+M/TM1j522EFZiWUvgskFIufHWmsAYeFA4aa+oZRoZJFXFgUEQGlFWQOftjdu4h5hAdt0AKhxAYy1LljCJi5Y6rZEMLaV14khgMaWwtov5xHmQ8aFXBRBmF8PyjY2wJYx5xi8MRhDTAN9MEYoF/gwGHMuntvg7IKaACjQRAE0SP77wRazBsLFYShbF9OaIqyz8gRsePhpEwBaF+6HzbADS8H7oosTT0MDbCKAkDvTOV6P5TNkaBjzEJIzwtAeBazghVi8fgtCBlNuCXImoRQYryPjbaLzVEVun6TGSUL34X4jekPqV/3wubdS8nbIYxcJ+DkRQXZqvsnL1Xi36pqSmvJCzJHEHeV0P+XlBLMUf1N+JZk5DdNm1n/d2daMHeg0BGJqyp5FeqTeUuxqypYV34qjFWKOJ5U6aZGQZ31fxq3lZ43SL6KwaouJxccsa5iMI68thb1m0ZBAWYImtoQxKKtZszSfGoxJ0DkvGOM1WUCeHqutSVZZdRgOJ8EsAyDLU6MF9CzZWm1Vg2imWYq95r/WRmtx512/VuOlZgmrXc/T52q8zirLPPfmea55HMFYphGMDZBQG7P+xnp/AkmuxDRdjsmj6lqF5Hus6MWuHWMRyEXLEafvHBIqglDmKB+FIprSZyDmCkVOlispcYBQEgPvacReYKY2Gnuy+3rtrKONM+wo2k8CEOvYZT476+DpkI6QpvaB4HwHEKH1JKZBiimRnYOjBo7aCMQmMc9gCQvAK1jDqJmA2gnINaCleJ5MQG0T3NQvTwIvW9sAyJYBrFDoFVs3AgBb7qJlawq0GxGMrSFMp9wAaA0AYeKnwYJDHm20d7aOQtW1BNfwtRCVy1XKFUMUn/lwzV79fedA5ODjQXCYujDd0rsW3sU5kG4lNFC/HH53E6BbClaypTZYypYRwGbXADuWQpvd0wWPjVMPvz4FPIE2pnDew3UdXNcEsNYhWqp4jaCPa/IIRGGzAvIeFK1U5Ck5U2wmCO7x0YEcO6PhBozQ1tkSvJTlMZ1SnCJMEbPyOjLuY13EcPEj3/m0f1f05ZJk3FG0GMEjbQSXKkJ2jNw9MkiKgMyXUXI0Eh1PoTL+HU111JUj6pwH54NYTi/eIXndmABgEgiC3xWA3MBs0W/RCMYOfLIUVA0mtLJWc5Ig4+o89G/LEcYQCLCUaK08a6Vcg7N5lClZZs2jBRSlwi+tOHotl+Sh5pJd528p8Rr86CmGfG0BI56SyG7wtWVMO92w6mGWrCxvirKO+GBLyGQySbIY8qg4ZAWSUwzZMra0tJSsZTzVT65TYx44rgQ81kbQGjhZ7u/Z6iV5lm2b24aWq2xLVtvmeFw30oqk5aVBs9X3aiC+NhBSA7Acl/ORVsDamr1FAbDOrwZKRzCWaQRjAyQXv2cwJhQeqRRxIEZDYtBdAiNXROhTkU/ah4pvUj+qBmKUWWAKMZ3WM0UAAc9Ew2UwJl3Xp2mCEYiF9WEZYYQpgYgreSg57QizCF3cbwtibRrbPgIIc97DxXVMk7jsqply3i6sDUsAkBdwMQgL7ibWIzijZgK0k+CSfmUSzDWrS8HitdKG9WATB2ybBDC21AGTabBkLW+Ewk7WgXYawVgEYS64/ADWAdqXQFhDAUMskcCcAl80PKvVIc1ule844j9R4Sdx7nwwaHWIjhZdxv4bTRwhcBMEU14L0ApAS4BfCsDMt8AknpcnwQLo2ziF0QG7u7Bea93D722BzsPva4LbxY0GWHdAF9zsOwrOP5aiyWfC1sw43EC+C4MK/M+LrtMESyk3Uio22mIhIQClJQfqCNMOcW+5bClqhYsKl9oqhdYW9xCTHSA5mySWMwu6QDNFn8lArLRQxf/ZU78kIvVeYHCEXD5PCSvJPinfE/zEwRVlSaAsM1gmwINDjQv5bOI7tJkph+M0xTuW9NQtyxGEVoClMmQpjzq8JG1VsfLg5xYQk8+tEf2a9WDIsqHTGXKOIdOtAcWhcllgTFLNEYf8LdeHSZf2cp8xvZ5MPtNgTFrGaqCzVs4hmQ2l1batCcJmydRKazKZJLDF0xJ5/7DJZNJbDyb3FpNTByWQt8CoPPO1bE+Sbzkt1apDmYduG1YYzY8FXC0gpu9Jvme1U/17HhAnp2vqdGr9vHZthZeOVmpr4uahEYwdysQKUwJE8ZwAGYeTCMgATcNZ9K1VlrKVAkeTgdQ3e0CMVTorkQqPREWx5H7PDMLy1MQ8PZFjhIlrhC4eyd8EEGcRupwgGIiFjbNcLFMTgVjLa9I80PqQSEutAH9hvVRwUx+8I3augWfrl2uAlSVgOYKvLcsh/5U4DXEJwCoFYLhlI/SEdgOYbITMl9YjGFsD2g0416FtN+CcR+s20KBLtriWCMsxqeV4NIj7OiOAsTQzk8GYqBanFHOKs/eIkDy3T+PMwinlWYVriD46HDB1wa1Ghw14dMEChA14P0HXrUU0vBrObimsM/Mt0CznKY1LCLtcL03C2qblJpzXpsC+JiDCfQ7wHn46xdQ3IHg05KOVjGL9TLOlyE/jZsgU0opyCuvIQhsI/YvNTbHwDZAcVLQUDFlEmJIHbwOdwRKvYwuwjLdbJgptKQGnWC8s68QjkAFT7lEMEdNDDcjgMoDuRc+1iQTIVJ8mI/RM6nVnkX4vEfPmSHci0soW0FeIrDA6vE5TXg9ZVix+dBo6Hl9bYaS1ah6eLeV0CFhaQMpKSyrs81jDLIuafKadbsj1XhJcOed61jIN1Dic3CTaAlBanlZ5LeA6VLdDmz5bgMcC3pInPktLK1u8JpNJAmiWJc17j/X19cJdulzbZfEo85RWMlk+yWtNbrpdSbBltT3ZFvTUTis9S/a1/jzUD/m6lvZQH6vlvwjV+rnmcaQRjM0k9dpGUnx0KNZ7JCCbM30TiMk5gpw4a34Jy1APhDWJgSYlZ3zy8l3Fr4PawwvIFjGwRcwJUBTWZFFUwdkatg6KnvYiK0surpOi7NiCwvoqR4SmCwr0UnSZ32yEw5HDhFo01KCJDtiD9W0p5hksYhuuxXrbgtoG2LocpuRtXQa2LIUNlg9biWCM4hqwLgCvpgvWr8YHy1e7Fqxgk73RGrYPaNYwccBqG6bnbXHBJ+MKgFUEJxJbEIq3gujvI57ZOWNyVMlNiIGYqhW+YKztKfrx8NFtBgHrEYzt4zMIawF6YS+mmALYR2H/tDUPdN4FELa0NVTIdCUcNAGmWwJi3rIM+AnQRWuZd8CaCwbAvRvB6cdGB9y8Bpp2mO5dR7c2RUthGmMDwgomqSW4sDEaGr8GQoeOOnTTDk3Ef+TCFNbOE6gh+IZSm4VrgDZ6AOkAkAN5CtMVO0qO7h0Q/WaGVsvTFh2vUPQenrIVivsWQ7eOZW7stEwpB6Y8EMP5eMrr1MwBlOTGn3LGXEzRpRVsm4/kuyGdSz4zLfbRW184xmgZ2x80z3QivrfZEeghIGYpnVoJ1oBlVn7zlEfelyBCr3WyyjGvRUyCMA1A5NQ+7SBEpmGt92IQtrKygrZtsby8PBOM8T1pLeN7FpCqkaXA66mmVhgLdMyy4NRIhpfeEa0pidY9Pa2Rwdja2lq6z/c4vgUarT3SrLZrrRtkOVkWHmvqrpS1ls0sb5wWqBrqE8yXBKQ6rZrlSjuj0Ra5RUmX/7ag0TI2Eupqkh7fpqzcDZBUwPJaEJVdD9ixpkg6ARG8nOSUY4k1ackqVubrjAF8uQbNUbaJyVAJG4I3do5sJWDpMsAUoUHh2kVQ2VBcF0Y8NdIFEEYtssv87KSDV7Z1cPBNA2rbYAVbngQwthK9Iy63wIoL8waXKW687IFJNL1NNgA3Bdp1oF2Dcx1cuw7XdHDNBlwzxXIDrDZxiRkC0FpFBmFbKACwFYQsWhctZBQd0JMAY8hgTFZ7qlIBCKIxKfjdoKD0LkeMwn45JvHeeqyNDoAjCmDaRcMXeXisA96D2ggnfHT6wd4ZfUSRTRvXU0UA7ZsA0hoA6xEkbXjQlEDeofMBPQabFlvHAkBoopWMPIUNoB0ly5/zAXclDx/ZKwvy3FtuNy7EdaFsbAfzwnaVW74ATkQJpxCVcud4GpARcb8p0+Jakf1MTv5NacmXf8rUeDcIQCYHTUoW9YvE+i1R5K3/8IzTFA8tGlK2aoBsVlit+NUsYosoV1Za1j3Nk3WWYWeBSwuYWtP7dFoajNWmHTL4kh4T2VJkgTFpaavlX5OfVW4ujyU/TfOAMX2t49fAMect94mTGyfzM21l0h4dGRjLNCRAkWBQghCLJ80bX9csWvMMKDD/uo/otjmUh9Vnh8CPbr9D8WsysMIMlVPnf1vQCMYOUWLgQUi4IVBUJhMKAgeACERC2aI0Xl8CJMQx/AiUJBoqQsX0iaKpJFyz+/oSIhUJFJa3lFcPcWWdtwBgvD6MMhBjdRvJPhDc1xNcsHQAYWoiO+lYiuc2LgBj9+8Uprc574v1YW1cqtX6Fq0PzswnWI0gbCkeDusIzivWmhZT50CrE2DrUgBhh68EALatDc45JgC2TKN7el4DthGsXm4KtLsBt4G22UDbrGPSELa0HSaOsKXpsNIELLc9grHtLoCfLQ7Y5qKfj7jUjJeXseMRNgRKL5TgGqq9I1wGs1xXae+sNuAiaoDpcjivt8C0DRazmykAt1t8AGd7PbDbA1Py2NOsYUrr2Of3Ya1r4anFRreC4E5+K0ArYY1ZtxrXlsU1ZisuyHYjboC94QPg3bMOv95hY/cGpj44X/FEWIJHiyUAHhO0CA421tHQOqjr4Nam8I6ApWAA68JO0iDn4JvoWN1NgsBaF/gjBFAzJXgPrE9542d2uM8WM/boyVYyFyxYchaky0aqvA8ZxE2EaZXgvpX7RjnswT0geP4kggCTTWgEaaRD1i8l8xwhTL+UeUlwnn1WGkT5HZPO8jXEBUw35qPRMnbgU83ZhqU4zWOp0A40LCuBTLOWhp4GqC03VjydP5fNsqRZlizLEmZdS/5rFjG9V5lMgy1v1p5c2jLGfEngtbS0hNXVVTRNg9XV1WQZ0y7qLWca0tV+be80DcpkOaU8LfC6iBWjBnAtC9TQc71vGFu/iCg58uDnMhw78GCHH13XpTVmGxsbaW0ZW8is9W3S2skWK7a8yfbIbd86LAuUtERpWcs2LK1kMg8pY/mbw8s4cnqmBosyvCzzrMELCU6lbCRfUn4yT6udaAAsr3WZ5qERjB2iJOENoCpVKkLyXqXeCewSnH+hd4TsnNDUXQZ5DMaKQ2G3AmExCJR5UGbPAGOAAGKsU5IMzhHYXQJP9wop8x5eYM+JyYOiSBAeoLhOjD0mUsZqvH9ZE2FY2LtsGQ5tnJoYLGIdH65F1zTAZBLWiK3E6YkrLbCtAba6gPSWY+JL69Er4jrQ7gXcBtDsBtw6nJuibTaw5LKDxcOa4HhwxQE7Ihg7rAkWsC1NAGaNj9Mro7Lvwgw9uOh8ERtIe1lbxh9pgCEgzdZjD/bkwEvkQEuq3bgAxLoJsEbBQjelABTXCNjjAu8bBDSYYp1inAaAb+CaDRC1cSFXB/iVuGNzGxa4dQCa6ARlA+HZBoXDA0RTdE1w6tHFVtEmMBQ2F2D3kA4eHQFNF/ddiZ74KRY5WL58GJSg2CBcE3mLjQ0ONPXokDc15k7XpB7GYCm2WuLWGvMj0eY1VkkDKHybUlunlCaKXxyCgDhggtCo+R1hpM9dKX2kZN9UUdKVHKShzEP63QNiVgFn08ZCoQNNFww/0q0nDba0lcEasa+NtMvwlkIt4+o0a0q4jDdPXCvs0PUsi9gQP1YaMu7QprZ6o2YNxgD0PCfyWq/l5eUEwnjaop6mqDd/1mcLoA05cJFAzSrzIkBM1l2tHmsH0J+WJxVzCYCk0s9rxiQYa9u22IeMKO/PJqco8hoyCQp0e5dOSSx+NeCX8tL9zQL/1no+S9ayb9bqQlvxauGs+wyuJM1Kx+o/i4KnobT0e2qe9EYwdghSm0BHUJQ6kFC2ICxkkljTjj8FnpLBfQpNhcWsl1ZSsNIwelgrBoml9PTBrIsFWxRbxFwelY9TvxIiECwXih0A3iA3q78ujdh3yFMTfesCIpk44b4+LjZjqEYeTXRp13q2ggWLkiNg4sPGzRMso8WKsIgFdxnhcFhvGnjnwkbNSw2wbSm4aV9ugG0U0NHqRpwzOAWW1uL6sD1Au47GbaBt96GBx0qzhtZ12NJ02NIEq9fhEYztbAKmWyJgSxesYFumYbuw5Q5YjeCx3YfkaNGt52v4CMqikBiUOS9kLclFEMZnBmRLAbzQEkDBgSR8dJw4WQG65TBDs20DXlqdBMC11gB7JwE73dAEgHZzFyxnGw1hdzdFB491vwcbtA7v9qFz7PBjIwAxdkviXECgSy64xW+X4lzJMGVxus/BT32oY6LY1pfgoqt/XttFiD43uw6ePNoGwIRnRlKYVuk8KAkttuvWxcEKl7pE18WPZxZfWlPWQygZURVAzDkIT/AOMrrn5gvpwEPCsNz/GlDprTFump62p0jsZHAV8qXki1Ie4d0guqDguSiT+JnnCEclhwJ/pVPzYYo75y1EIxi7Y4mtNDUrhaV4WaTDa0XUUkZ1/JoDBAvocDgOy+Gl1UZbd+ZRpiylTyreMm3Losbl1cqetNLxlEEJxGrWKWnhkmCMrWQMyvieTl+mw/lroCaB4JAjjtohZVyrqyF5W22Of2tLkZStBE/8u+u6xLsOI6ct8pmP5eXlBLyYfzn9kJ16aOBmtRnpIl+XU0+PlDzI59bAiG7jMu1ZZAE/i2eWlTVgUSuLlLc1kKMtabq8NarxaQ1ubAZYjWDsEKSmAGNa0UIBuEzqjbKHv9LNfJqGxIv9XQ6ZUBwo++SmrFRmX4blOi6KuQTdLHg2BBAtVBEkOaOBksieFbsoCbHrWLRMyb3EorK41GT39dyymlhCmgI0Dc462HV9FwFZF41V5DDBEhpM0GIFLVYR1oQtwyNMTVxH2F9rrW1BrQsgbKUJQOyIlZDv9i4kvrIeXdRvAMt7omOOW4BmHxrXYaVZD4DLEVZcsHjtiGvDjmwzKNveREeLEc81e6KDkX1AsxdhD+g98bwGNNHzfRPdHbq4JK0AY12Wb1brww+KOwVQBClowuxBtAGI0UoI4+OCNVoNh18Ctm2Nz7YCfjmAtOlSULB/0AUwdmMD3NQB+4hwQxOsZTf6dewlhw1q0fnlkIhbC4k0q+GYRI+MXRPWlbElMm4gvUEOoLDPGLoObdz+oI3WshYTeGzAAfDogOk+dPBwbZRB8t9B6JoOxIvLGoewWVmcq8leOT3QrXl00wxa4qcrAsEm27SIz7m5u9xlxI3YmKXByRMgehj3O4joacIiA0MfETejvrQfYVHb3O0A8Do4J9JU4yJDQAzgkZei7waQ6NAtBMdGOtCJFTtWTuTeSkMWI00WmLOudVqWRUQqzZZ3QR1epi+db9QAXI1/rQTXXM9bFiSWGce19mKT67f0NEIJnLgccnpi0zTJ+rW0tJQcd/BZgjHLyqblKIGXXk/Gz6UcNbjVZR+aujhUB5YVq9YmOLwE4ETlvmEMzCRAsxyn8JkBmOSF5c5p8nk6naY2wvc1gNFr0nR7kMBey05e19o3P5tnbZ4FlOUz3cYlINNxpDw1wJLPdfoaTGowZpVPkm4rGrxxu7T63KFKIxgbIKlyESj9Sg0t3RDXSkmSTZWVtny/PzUpJZbyECP6EYiVI+h9ixifU/NPgQUQc6VSWGAzU/vLQIzT9iB456Ilx2WLW2OhuqAQyw2kG56J5l1w1pGcdOSNnINFLNhWOhfd1zcuA7+VJjrpcGE64oQiUvJAsx7R0QYatwa4aXBL7zqsNB22NIRlBAC24oDDHLADwIoHtlKwB61uhCmJzXpwsOimaVZjAmOYAm6Pi9awBm7DwXUObt0B3qHZcEDnQjm7+LKMXgKT7J2ou+jGkhoCdeHadT6sxZsSaBrmdropAS2B1gm0BjTLAW/SJFh0aBnoVqKcXXA8ElZwBVpxwTfHOvHMOsI6eThM4T1h6taT0wxqEBJumgDUWgpTQ5cooNfGhamgnuCnYXNlEGFKcuvz4HjFJZtzGyxkRCAfHYDwWipHobnL6a0uLuripIA4FZZAPqy9cjl0AmY5f4h+hZJ0U+cNoXk/tNStqZ+msJo5IDkNKT5UpM6FKdp4DAXE4g3SfFvWMaDkpzpaZNNoGTvwyZr2JJXh2pQnrTRLJc6yLllkhZtn9LmmxNWsNjqvoXSt9GU6lsXI4k2StnTNY3WSIE1a0GrONzRoGgJh/Ft7WrTWmM2yhs16PqsOZfuygBn/1pYdtlhpIGXFt+qW05LAjOtXHkBpPbYAiUzfqsMasNfl02BJy1DLa0i2mqx+LuVp8TQUX4e14s0aDLHqaJ44mmYNFNVonnfCwUgjGBugJgEQQrAOsYXM+PjI4WyAsUdBErMVo97OlSP0rAoRwgg732IQk/RRdjOfI/OrLVitKCjRbRMeJ1/1glfqAzHKjCFbxZpkESME5WsahBSsI42LLuORkRYRQBsAPBrv4brg4W+J9w/jvZTRYhLXhU2wBQ4TdOlw2Bc9Jk4nLaZtA1ppQduXwnS5I5bCBsYrHbC6N7isX94bEp/sBiZ70TRTrLRraBvCYW2HLY3H1gbYGX1THN1GZxweOCzytbInnvfGGY5rQHtLBGO3BDDm9gJuDwLQWgubJztaAfwyHE0AWoGjBo6W4GgSwEf0XOioSfYb2SYAClP0EKbpEeI+XXHuI7kNEF83ewHnQctTYMkHq9l2hCl/2wFaCb44um2AnwDLW8PasqO2ABurwXP9jZOgfH8/Tl3c4z1udBtYd1PcTFOsOYcNLGGDlgG3BCwdFqYu+lWgWQnWsslSMI9OHLC3Q7e3w77dDo33mK4HkLeCNu6/5uJLJzh98ZjA+ymwsY6miRJoGMsTqPHo3EYAYg7BIscbtlFsgN7Bb3hsbASLKzfLNtnl0tw9UNxFm6Tg+czGX9lRwy7VaUqkDppt02GiIYFHUkVf4k7mXB5ccS7nwyP0AidmIEn5meSNB2e44chxj8hRI45FaAOLg7FxbPOOJTkSL0eueeS/FpZJK2E1hVEr6pZ1RCqsQ6BHh9dAQo++66lfFtWAGPNuWbD06L41ci+tVHp9mAWm5PowjsOOOXh9mJymqI9a+hrISbf3Q2vMLMBpga6htWYcxlLeay7jLeVeP9eOOeS+YdqNvfSUKC1YzCNvHC2tK9KqxlY3BoEbGxvFmjJdLmsgQDsAsabvMXhjeUmLmpwiKeVea8+aFw0+ZZvV6daAtcyvBpittmLVZe0s+5VV78yHBryL0LwDPzrOwUAjGJuDXFSzrEHpOsIS95DHzqkIyqPvInBKS42qsz7Xw4ASXYXAPTZSEBeQHBzkWrFeefoRkXdwyjofsYUibaIVj8Rw1GKjAswWMReddgTnHaw2tuKYgF3Wd9Ey1jmHaePgJ01YHLUS1y6txnmFk2lAT22cH9iEs2v2om08Js06lhwF0BXXge1wAYztdBGMIQCydgpM9gFuA1i6Jfj5KMGYC+vB9gFutwuLtNZbOArbPjusApjAYQvCysMVOEzisRTb00Qo8hmIAXEKX1yN57ERwUSY+0hYQwDGDIc70BKF6YrLlHzd+45AK0jr12gpVKVfins6xxmGAG8aHY1MDTAlwlJDWGt8sIB6j2njQdQF8xt1YXFa3IwbK0txD7cIXDoCrTlQ18A1PkxDTfYwIPwKQCnaV+HIAR5oooXMuYhRKCIa9sQJFwBSNJKlqbddtNgKK1aeDlyMdPTJZWxUADSK7TqaxrhrhGEZaXti5zyU3hUMxFK6+U+KkzMPP/WrRJ4LkoCMf6v3DresRa1iQADn7YJxRjC2f0gDGCZpwbCUaRmuNmqvFbqaclYDb5Ziq8Na0xmt0f+hkXtL6bP40XnU5GIp2kPWJF0OC2Rp0KmvLcuMnrrIv6ULfAuMyTJomsX/PGBMtivL6YWl/FpgTLdZ7eFQ3pfthdPRlkQpMyBbxiTY5rA1z4IyfWt6ni6f7D9abpyPDKtlOossYMXxrX6g+dDpzLJWWfnWwltArNZerP5V43WIRjB2CJMcjJaj4sU4GhmXQjkSzbAfTuuJpGKQCEZSyQKrfUXUYLkikNzbq43XbBkTzEkcmDBUykFaxZqYflyL1rqQLq8PS9MTmYsOIILzPux55QkTdtgRXb+3fgkNWjRYQovgjWIjArE1NFhDC984TFcmoLYBbZsEzxSrTVjgNQGwdT1Mj5vsA5Z2A80U7dJuuGYDq204VlrCzglhuQGOmgDb2zANcacPs+y27waWpsDqvmAJa9eAyY1xauLN0fP9tEW7L7h6d+urcN0ENF0GNpYBmoAo7TgWwdgSXJwYGMDYEhwmaEwwFpWcBCECEAtWlg0g2gfDvX0A9iEAs1sATOG6fQCtI8wPjAvbdu8DtRvwS1P41XXQEjDZGZaATQ8Duu3A0hLgtgVr2fIycOQkeF88YilMXdyB4Br/FnjcjA1MXYfdnsJUUVoHuZVgHXNdsJDtjFsJbHHAcgOaErqbg1MPWgc2NuK2ZWlC6koEZPGjSR3QbcAJE1EA/dEi3XS5/boYgK2+Ewf4OAd9StHKxHCJP+zcyH12RR/7FaUO5vqIiJmJ0ckjOd3Jtk0CRI0C2UpHnD54jEXcUH1ffzZyLxUPnRCBQc44FqERjB0cJBUgOQJuTcOSVLME1PKQ8SyApZVQa1R9yGqlgZLmewiI6XJJHiwHGzKsBhJSudcWKQss6X3D+CzXivE93k9M7ikm9xmT4Epv+izT1+H11LxZCrSuIwuM6bSsOtSOMGpKslVfHFav6/LeJ0sXu65nz4nSWsZ8MsjSlk2ivNcYx2d399w/mqYpXNlr640EFk3T9NaOSbAGZOBngR6Wp7TEzdOOrTrTYSwgPDSoYgHB2oDMPKDRAmQW1QYBRstYphGMLUBy0LwAMQMj2zJmr0nIhJI+lxOSbuYTKBOATKtbQc2MKr0Dsov5XtDIpABkxcg6B5RAzAk39gjOM9hZB+fReKTNeynAwrCXWPSYSBmMOQrTExssocEyGqwgrA8Lxz402AsXpqWtTsIascOWge2TuMALcd+wvWGN2GQPsHQzXLOBpr0FTTvFtgmwI+KDoyOGO2Yp4LgtXfDz0U6BpZuD5Wvp5gC+mjVg6YcRjN0Q14j5Fs2UAddOhJVkW0HYjuDt8TAQlhBWZm2Bi9fBHrQKFx2TBFDWRBDCriDYzOOjdaWDhwdhirx72z54TOGwD8De+OwWOGzA+d2A3ws3XYNbuxkBwN0IYB+o2QearMMvAe0RgF8BpjsCIFtaASZHBIC2dUfYv2xfA+yMbvJXAOzpgB/CY0Ie+wBstOtYdw5EHQirgIv7gk2WgGZrcO6x3ARwtu7hPQHrXdgYeoOih/4mQu4ltNFKFgBnA+qiVdAFA2gHwDdhbzHnfLYgOheOZNZyADVAFz7u7DSUBxbiRK2QBzd0T3ntWe4UGejxmakNgMzL/phCSEAWLWVEeWyFH6eTAGQyoR4gExElixYgUzwtCsKYAvxfjBad1jjSbUta4ZK0GWXEso5Yo9/z5M88aLCkLUoy7KIj5poXPY1QT9XUYIxJTw8cWoclAZH0jshgSgI0DaQYIFjAi+9ZaXD6mkerzocsf1JO1rnWhrTjCGlJGrJKWvUpwRiDMAZNGxsbCZBJC5O0cDHQYvCs6xYoHapIJzeSB+1pkdNjfrSFZzqdmuXXgyKyTVlWIy2TGjixZMj1ZE2xrQ20yGmBNStXLf48Vr0hQDarLcxLIxg7RImVJsYpskp1cyr0LbPulXrUa49CU9NALJ5Z+dJTjyiq8KS1MQ3CBoBYAnxp2iCrsHFUJ3HoglMFBnuFZ0YGYsGRgyMqnHWkzZDTNLUlNFgCMEGHsInzBk9LnLTRQUQLbF+K7uubsG/YEgW/8m0XXRyuoWn3oZ2so22m2DohTFrg8Ek4tjbAkS6Ai+3rwSq2shGWljUbwNINwRnH5OZoEdtoMbllKVjDNpbQ+AmcX4HDDoSFcTsBrIKwFQEVTtBhGwhLmGIFHZZBmMBjNcovbqyMNoI0B5dASJrYBlZpKfmp7CLA8whdtYPDChpsQYMpJtgKhyla7EUbLWYNtiGo01sA7APRHpC/BW7agfauo5l6gDbgNjbQrYRm4JdDFs16uN6yGoDQThdwr2sANwH2OaDzwJon7KMp1rAO3zh0WApWOUzilmIN4NuQyMYk7Eod25z3DtON8NFrIzhiuTRoYu0D5AnUhQ3BmwbRdweh89EbCe/ejKZs74T4PDoA6XW40PKIfBr4SD5CSPTf1DE4vSKJZFUjlTrnQKDyvsBeLnU/7q9OPRSJaSRXstHLu4zJBdv8x2+kA5OGrBKLjrrPiiPjLgrE5rXMWHnVpjcN8aqfyxF/5t0CYhrAWQCM70lrleWq3rJmWVYtBmMWaJNgTFrLOA1pvWPepKyGXI/XwLC2jHFYDcSlxUhaiGSeuk0M1bO0dGlQJEEHl0umpy1jzJsVXk5b5LBybZq1plGu1eJnUtbWukar7EMkZaoBkAbVMm0NAC0rVS3v2v153g9DgzI1kGnlsRlgdWemEYwNkBcKEDvvsJQiTYSk56GPhqRiJ4bYU0wUa/15CZZUJXXu2aZCca8mlGu4mhwqRIhKaPRmmDYi9qyqtkUiARZEGfD0R7aM8SIwRwAF/+3Oe7iuy+7rKTrqWAcaajGJ09NabEGDZUzjlMQODntci6lrQFuWgO0rwVPi0VviZs4eWI2mtaXoX769AWj2YtKsY8tkH1Ybj2OWCFsa4Jhl4KilAEuOpLDl2MotwNI+oN0DLN0YrGCT7wPNXmByk8PkRgdHy5j4I+FoBS0dDue3w2ErHA4HYRmEIwBsAWEbPA5DhwmmWEWHBrujRS9MLGwTwPQRbLKVsafdi/pn6Mv2yAYU4SphGR4r8JhEW1ye1LmO4OrkRgAbcPghHPaC6BZgeiOoW0N7ww9Abh8m7kZ0zc3wqx6TIyhYy44MTj+WtwKrO8PassMOA6bLwE1LwA1LwUq2rQlTF7/fruHG6To2/Br2TDZANAE6Cv72V1aArVvDRmdbl4ANB/ywBZYbdGsd9txIaDoPIqCDxxKWsIwGAWwCHlOgWwf8OppodWXwQhSc0hAQOgm3U17wBgBNXD/mHUBIKxIBxmsewDS44He5W2SQRRnsOZetZwzYYrZeDGjwuAcDJwnC2JJFFJ00FiBRkBPtoTeqowAZ5eDFGEsvJL+35qd1GAbDGTRaxu5YsrzQSZplKRlSlocUJK1s1a6tPJn0uikrjlSoZfo1y40siw4jlUbLZTpbV7TlSoMWBj9yw+bV1VVMJhOsrq72ph1a6700eGO399oKZlnL5NRICS6kMm/JfMhiVVu3JutzCAzIqXq1OgHQk6e2YvHBFinpmIMBEzvfYIcfcvNnnnbI96TjD7Z+yTTW1tawvr6OjY0NOJf3FuOwmn8GftKKpj0tyjrRbVa26ZqcrCnGlnMOna7cFNuq81l91LqeFVeD36F4nLYOa3mqnEWjZewQJRKqTanSGI1PPjKVLUNzSg2WenoXG59KIKb5y1wmmKixH4dUDPbSZyOAsNbkRCjHdJHvQhOkoGm6eCZKlrbksMMDjtjeFtw5ZLDnorMOB9808C5Oc1uJx2obnEMsx0VebQdMwv5hLh6TZoqVpsNKE6Ylbm2AbS5OGqQwLXGpC54RJ/uAZk90yLEONHsaNHsdmn0tmrUWDqtosA0OwRrWYAdCSocDWIbHThBW0WErOmxHhxb7sIIpGuwBsAcOGwD2xrKtR2ckFMsISHcwWpVGtBaRmCBKWI7uL1aiS48lEFoEO13oxstx2h/BYSOeg+OQkPQamm49wrd1BEcgHs3eDq4j0EoAgBMCsAL4DmFLsRbYaMLhXABjDYDdDWFfS4Dr0NIGOiKQmwJ+A3CTWOlNAGStC3W4rwWIQJMI8DuPjhgo8eqrNpa7iU49gnXVi/YEir0xAZbYT4u2zzuMxQ8bsv0xt+1MTjThhIVEnYQ2L6oshik+Zjm1+De/QRjE5UGaIkKOlixkzgiY0KL5OoFIv7TNjWDszkba0jNL4RhSmmoj2bNA3q1V8iwlvgYoLCtDzSKh07dkVbO61aYkSvAopxgycNLrwVgx12DMOmoOOfSat5rVzpL/EDCywJgFyi0rjAYHst70VFCrPjQg03xyGhLUyPrTFk3prIPvdV3XA5KSdwmqiCjJfWNjozcQUBu0qDnnmKcfWrLRcrq1AELKttaHh6xbNX5lvel6nmWJs/IbwVimEYwN0AZ8z/6UFOa+PpeDpbpXCncRqd5ApGVMrhWrZcV+5tI6MQcVMWqaUbFnb4aIlrGQT4BJTdyeF8KKE9InkHPRDaJIN60PC2cHH9aHsbOO9XjuJpgkZx1b4NCiwxKmmGANDnvQwDcNuu3LwHILHLEKHLklujtEQFIra8DSejRj3QDnNrCl2Y0lt46djcfREYT9yHL0lrgOHLYHmKwD224J0/CWfhhAWHMz0H4PYSri2k64bgXN9DA0OAwOW9DgODiswuFoOOyExyo2sBMdWtyEZayhwW5McAuWsA6HG9FiHWEV1244bMQyBRccvFcaonVMggRR7+kc7oYJfAzGwrS+VRBW4bEMwo54/zC02IYVrGALdmAbluCxA8dhFR1a7EGLm+CwBofrECDiD0D4AdzGGnDjD+GbdTS33Aw/2Qt/GDC5CaCVsD+23xKWgq1sC7MNV5eBtQbYsg5snwK3+A5Nt4YN2sBe32CKvUC3EX24TILHy64F2iVgyxKweyOUe73D2i0OG2sdumg3bOCjU4+lJA1PHrS+ATSEdingvLBusUuAiyWVKCIJ8i6AuAR+89qxsHIsePn03qe9pCkePrZvynMfc8Kxj1FHMf1y7KMYb4HCT/wqGBywccrEVQ6KwEiPibGcTx8gL+10c9G0n+xMOjg+d3ceks4A/v/svVmsLct91/+pqu417eHsM9xzJ994gMQh6J84iuMrh0SRkIXhASUPQcEPJIqi8ID8EAwisQTOhHASQrCIIoxAVkCAEl4AiSALxYqfMEQy4oGEmIwe7vU999wz7Wmt1UPV/6Gqun9du3qttbev7TucOqrTa3dXV1fXsNbvW99ffUsex4yheG2TG9KY8bYt5J65aYZ+G3CTM+ayXDkQEu/JGfc5UCfd0aLhL90CU8EP6ZoY2azFYsFkMmE6nbJYLDDGdMxYjlWTrFYU9Yjpy7LszqVrwcYA3S7ASbrSjQEK+X6b2mdTm+bc+8bafhNwlCBs7F0iW1aW5QUWrCgK6rq+IPiRArh4rixL6rqmqqrBerK6rqnr+kK/kv1PvuuY+2RaZ/J9xiYN5PhL63ETA5m7P/fsNOQAUg6YjYnDjAHHTd8HqSvrYzDWh8dgbENwA0OmN6Ejpor2Uk4lvg8ZE62zoi5aZCpOwIvzm4CYjMBwnVhH0wkgJsrcrUPr3BPlWrF+g+f+KFBil3cv1qGCSp1yQbjR4TdCbkE7L9ugO0VBQ4MJgh2ePXJKw6SAeQF7Ezicet/CRe03c540HlnpNZglStWUqmKmGvY0XNOwr71r4r72QovzGswKJsfBJfEBmBNQx6BfAdXqsAZrgeIGilto5iieCmDsCeiYsANqNGfAGV4i4wFedP4eUKE4QXGGFmDMw6Am1GE7qM98b4k9RQf2SwfQVeCY4pgHMHatOxoO8NL8Dr9CbYof3IolBYfAKrBkS/y6synWnqFX3qFSnS/RgF17QstNfV+ylW/HooQ6aHRUBlbOu9xp6zjVDdopKreicS2YsA9ZGzpAq8EVXg5fKzitQCvaZUsb3rGBsKlBicbiaDE0HuC3tZ9AML6vOkCpyFWH2oq+g3EAhePFeo68mF+h5vBrG+NYVOG9erDk+vwjbRblVFXPP7kud2SphufSBs9+Yaj+4NQQzcncwkOUeHDEbc7F944XL/djVCXl3yW8Pn7u3jghNysfgzSycgBrG4syNnu9iW2RYRNLMGY4brp3jLnJve9YWeJnacxJQJKTnk+PEbRFIDadTjtQNZ1Os8qLEUjJNWBybZlUX0zVEVPQtAuLtamdcuvCcuIfuTBmOKf7b40xj5vyTMFiKjSRggYpyBGfG8FKBFspkxfPSQYtAr/o9lhVVZefZM5iPcW/c+AkvbbpneXnHBDOgbld2KSx+3IsVtoGacgB+fQ5u34vyLJ8JaxYLo9d73k9hMdgbFNIB1a0gS5rqVwAYn1+8kNqwOX2FYupHb32XjTChr5FKRATOC2wVkNmTAcwpjsmoYdc4V9XqJBJB8bCGqdQXm3x+3FZMC7mWoRtfwscBouhxlChabT2Qh0T4xUTF4Wntmatd02crv3is/IcinO0XlHqipKGI2XZU37j5ieNd0k8WPlbZ8cwOfH7hJV3PRjTj0r0eYFaTlBugWIKPIVjD8Ut4Alapqy5gWVKxQE1C9aUnAb26y6KczwYu4+i1nA60dRGsZ5o1qWi1YqqNFgNrfH7pDnlsJG1wfU4Qra9i3DBu+ZF9zzbOrSFqrGsG88+nq9bitbxoHLMGsce8ADHFHiI/3tOyR5z/Eq9FkOFYYbhEDgFJsASD98eoaoK/egcN2kpqbEz2+1VpqdhG7PSy+Cb0jfPWsPKOaxrUM7RuhW1PfMLz/ymZ3i1EDxAOyh9W68tWLBtS137/lx06xULNBMIkF05i2stVvl+FlmsVkWGCzpaS2lQnsmNQMh2wyNON/gz8V7n6Nam6agNQrcLGhcmTjrQF/KPwyLh0rrkjgviibHtLxOUiIOQ4rX0Dre7PqI1l/+Oc3Gm4XH4mgTpEiaNzsuGXdmQ3H3pPdtA2BhjsC3/MUYs99xNIC8FYjnWKQVhcoPluFZMArHpdNqtIxsDTNIdUa4Vi66NcvPmsXfMvVOO8Ro7H/PfVJ9jwHiTsS3rNF2LJ5mjnBG9qb/I58R2TYVFpICIBGmxLHFcyGenYAy8W2NkxOJ7jTF+EdDJ+kwVJnP1KuMm8Cvfa1OdbTuXu75p0kJe/2qCl3Si6LLPewzG3qyh0P3MtKPfUXaHkDe2Nlk4F2UdxKXBxyEYQ7gmxihSuZ4Ri2ZuFO6IQAynBBCLkusSiAmWQNH7OLqA6KxfCWVc8GJsvLaGdgpjDdppCqYYZngpihKHpkKzQmFLg9sLuxBfn3n1xAPr/eCKBhZLMHWnPV9Qs6eXTLE8obwX45MGnitgUsPeQy/SMbkPkwdemr64A2qtUGczWM+AI3C38RszPwvs47iN4zYNJSfsUWF4QMFJEOZ4Bc06gLEzFI9Q3ENjjaI9MLiJwh1q2POf2VNQKM8yFcpXjrEZpB2PkcoJDWmVX3NlQa2dp49WFnXuoHKohy1UDnPcohvLHo5bQcPxCfzfh0y5QcEUxy32mWFZsGLBCscJjiMcSxRHwAPU6hGs74CpcKcnMLGYU7/Orp37IrczL5N/tAcHrRdSPHfQuhpNzdI5atd6HX1jPBDD9fvStVOvnV95INSsNasGjHMUoed5VlChqClcg6XFtXX4Meyrx2lL243RUG+KIMHYq4wG3rZzZuy3F1Ao5x0fnWVAsPVg2Y8jRwB7cVojfnS9W6AZDlefRUBmksXKzsmkQcW+MBJSxCcvxfM6vEw9ns3j8PoLEoxFQ/TVNjpejZnrTSzcthn5sZi7f2z2PZ7LiYGMreWSYEwCptlsRlmWLBaLDogtFouBEmIKIqF3gyzLsmPQ4lGuMdsFrO5SPymjJ8FDyozFkANNOXZkE4MjwZiMzrkB0ySBS8xrU/vF50gwGZ8jRS+iq2IEYdGFMQVDEVBFl0Zg4PYYyxZdFyWok2WK7RYFRtJ3GgNVKduXY51iXmlbpAIgOUCbA8pp2MR0ybDt/pRZk3ltAn2xf+bG5ps1PAZjm4JKrKbY0VImK/TFDgOxwcAa3EgwInuWpMsruUWa7X2UU+2xrBK5OX+6m7Uf4oC4ViyyBUrk55I41NgPKZzPJJ+vz1u5HuDFFVBRWbBV4bOJzJj2ihSl88jONGGH6Ap0jdY1SjWUqmWuHNOAd/bxjNik9kvKiqV3TTRnoE9BLzVqXaAqA+0euChJf4RjTsshjj0ci8CGFTyioMJwH8MxmjMUD7RmreCk0Cy1Ymk8G2YnGnvD+PVthxoODEwU7HswxhT/Xtr1I05ZUdOx3qP1H4x9AcbcCs88nCvcufNgxuD38jKgC8XaOs4bReMcZQOVdTRhImGKdwecYWkosVj82rh9/GbUZ5FjBXcOdo1qGkCjlw3utMVZr0KpLJQLj7Wm+DZQyrdBhV/ntXYNDk2ra48MTBkkNTWUhaeqSuXbvHVYrVAWrFOBYPFMbb8lgPN9yXkAJ7uj7oZRz38NEZAKcyhOjJnImsV+r/pJF9HNI96yydDyhYioLRTGifFCd2oAyBD5KCLQk10g/NE9S/zQiSiLIbvPMHW8YdMk0MVgi0vf8pgZ+xqH1BjaZtBchpWSITWqtjFiY6zYWL6b3Kd2AWIpeEiNw7GwDcxI0CJVDCVoS0U10vVXkl3bdN8mpiRX7pwL4xgYkwAzBWOpEb2JwUkB5pj8PfQCGqmRnwIjCVZybRxDDhTGMsi1ZhKgyTLmwJhUIoz3pm2UK9e2fpmWOwVhKRCL53N1nQNJuXObAFMOBOaembtvU/pt4zyXd+575DJ9Pz73MTP2VQq/+qu/yj/+x/+Yl156iW/7tm/jV37lV3jPe96TTfu7v/u7fOQjH+Gzn/0sn//85/mn//Sf8uM//uODND/90z/Nz/zMzwzOvfOd7+T3f//3L1+4IvqUucAC+Zlx5yyRIUsBWQzq4imyFlnHYPUG0CBPYeDF2MmIRACmlWccZJ4uwDUXFOgJrJXzxrRqo8HZbzysOrDkgsKhDcIgrr+5K5RfDKacV+DTeJFD7UC3oFsd1olNMRTAlJaSNgixtyjqwtCYIH9+feIVE/cdLFqYr2Gy8mvEJg/BVEzNOTOzYl85nlJ+l6+3ar+H2OIM9h55l8TZl4N0/ctQ3AXVTlHVLZSdYe2T+DVgN4C30DLllOtUTDlmxiNmLNHcpWSF5h6GYwyrQnEy07SFormuaeeK9kDTHhncTMETxu8qfU37naan+N2lC2AWQJhxnhnD4Wmu0K+cNOwV3S7aVvv1VhZYKn/LuYOzAMbut7CyuPst7SPLcmmpH1j02nH3gUUvLYvKsb+2THE8gWKOF+a/jmZGyQ1KJjTscZ0Z53jHy+tgl6jll1H6FNYP0Q8fYBZA5UU9CGvx9BzMkd8sWll44OCBa8BZal1zDrQm7EPmWlAF1HPfKa8Z0FNsUeMqi20tqxoK65hQdP1S0+Ao0NZhnN8OG+3QYaBY5SXy21ifEbJor+ToLLSuZ4ch7qBnQm8PgjWuxbUeWKkIbFQ/zBonxlekt6K/ZHB3tHYI+fwIS+Z05PdD/M+FAZqlujI/fJmUEgh2jJjW+E3adg9XBmPry93zWg+v5d+movA/3SkY2WWWOQdYUsMrvTYGGtKZ/3iU62o2gbfU8Ezl2uW19Jnp59x75FgWCbAkYJHgKHVPTGXsp9NpJ0sv13vJMsf85R5k0q1RsnC5OpQhlk3uMxaP6Vow+Wz5bqn4h3xWuv5KXhsDmOmEQIySFYtruKK0fJou9i15PVcG2bayzmRfju8JHvhVVdXlm3unmDYyYrPZrMtXSupHlkzmoVQvh5+ygmP9Mv08BjJT4DvW38dYMTkGUnYuvZYDSJu+G9LzufG1CWBJxvYqbP5jMPZVCr/xG7/Bhz70IT7+8Y/z/PPP87GPfYz3v//9fO5zn+P27dsX0p+fn/OOd7yDv/bX/hp/+2//7dF8//yf//P81m/9Vvd3/OG6dOhmnFVY1Z+Z/pbJxbmkO4e8cuZTJlkmRYBWw0fHWe/OkKcvX2TvVM8ixDVdnZqiYMWkeeef4QLwc/0mz6q/GgGfN5cF2IsS9t3m0ZHd8ILlNgh2tPh1Vc5ov6HzRPfMWGE9sjO1j3qN0hWFrpnolhlBtl55oY59YNoGRuzcM2LmzCsm6lMFrkC5BbDAKyNeB25guU7LhDUHrJhwTME9igDGDCsU95TmGE1lFGel9u6HB9qvabuu4Zb2IOy2gbkKYEx5ZuxQEXCoZ/s0vbKJC7C6A/ayHYN7rHUegFlgBTQKzvHqIWt8fa2VX/Y1U7RnitYCK8dyBbSKpbMsa5g6B2jmzmExWBx7aGYoWlqmOCzT0MPOUUxR9tT3lWaJW3sGy5x6NU5zBsXUL/3aw2OrfeW3FFs5x9S1XpZeV7RxR2lTBaLL+omOUnnX1FWLMxrrPKgCKIirryKz6iGU71sE0Q06ZsxeGC39gHIKotiHh2opQxY+O4VyDqd7gir2627MxS/2mCA+Ln43qD6JlNMXQ3K3kJ/NGYYUu8Xnyu+tiCQvEVzBRu/I0bK8gcJr/bdJGm6p0trYXkbxes4w3AR4xvLYhREbY7Ryz0yN0LFy5T6nYew525iwNE3qxijZsRwzJu+X58eYsRygGavDFHClhm2aRj43B8bS9hsDtek7yfzTsqdskgRg6d/ps9N7xyYHZJkkwwV07okw7EfyneJR1pFzXq0xAjO5hnCsXLlzm/rhNlAwxpCldZy2nTzm6i035nOga1v5LxM25b9LvW0qz2Mw9lUIv/zLv8yP/diP8SM/8iMAfPzjH+c3f/M3+cQnPsFP/uRPXkj/nd/5nXznd34nQPZ6DEVR8NRTT33lBdSJsZXpOJuk5y8mFjHmu2PoIZAw2o34PJhqdwMXrqhE34Ex59dzBVMzpu5Ytxa/La4NinUu4qmI5BiuQ5OXVAvKeuVEFXbCchQ0YQPkBkWlNa3W2Hnh95/aNx5dTRxM1h6MFWdgTtG6ZqqWFKrhhmo5VH63r2e1J5wOT2BawfQ+TF7Cq96/ZDDnCnN2iHYH4A6A54AFLW/Bcp0zFjzkkDUFLzHljIJXKLlLSVVoTvYKmkKz3NOs554Jc9e1B1ZPao88IhibOjha+/LPK5g2XnBkWnma0FTeRU81+MU71u/HRest98jmKB3aMmi4Y2AyAadhOvHKCvslVBPvvngzHI8LODNwquAOXurwjoYTR3PmWD60XiDj1FBUjgdLw2Jl2KflAYo5LbdZcEjJHoYjphhWaKbAMYp9lJtBtaZ45QG2rLHOenbu3BN4egJP7MFiAmXQ01gqB6pirRoqbah1C2YavnUKL3WP8ezfqsBVlto52tqibHAnQWM6lqxA0aKtxTUWtPd69GCr3+vKYgMr1I8N5zyismLM+UmEOCGhu6kI5whKkD5RzF+7IbDzY1oJz0gV2jaMQtenTL85lDiKn0mRME78uAvAbPA10gG/5CHyu+qSP3jepfZyt7zRNhp7rf82pQIeOaMmxyxd1QBLQYNMmxrSsnzbZtvHAEZaltxxzDAbm8nPPS+NkhGLxxgjEEvBVPreMf/IlknlxFS+Pn3PHBCUAiGp4Id8Zvoe8bgJjI0xT2mZ4jFlxtK80nZNgViOqYlru+Q6r8hqxbgJqEYgFcsZ84kMl1JDlcVcPUtX1FjHWvuNpMfW140BNFl3aXlz4yAXUsAn2yfek65TG8sjLVeMObY7V/4c87Zt0iB939z31GWBmCz/Ze95PYSvGxirqorPfvazfPjDH+7Oaa153/vex2c+85mvKO8/+IM/4JlnnmE2m/He976Xj370o3zDN3zDaPr1es163fvYHB8f+w+xszg3NGgSAKYcF4yt4XouMgkjvOqTpFhNGlpdVPSGptbDG1Qoa3BPlICsUzl0dJsvC06rK68lOtA5D8YiNRDVP4IEY89bCMDXAm3M34MxvztWQRPk3hulqIzfU4xZAXsmROWt+LLyronmFPQxWjfM1JKJshwpuIXHQE8FscXFKZSnMHkFyjugl4rijsEsDZrrKLxbIrwNxwLHczhucIbiy0GY4wuUnGC4S8kdSqzR1AclbqbhtoIjBQfKf54peApPx103cFv7PdDmlRcbMadeMURVoE5CbZ6CW4OrwS49+GrXdEqU0eCOYExPPCDTJegZUIDaB0pwC3B74CbQHnrFwuUC1qUHYy/hwdhLwImjfQjtKxaWcPqSgXNH4TRmpdmn5QRYYFiiuEHDLRYccAPNGodBcwzMAIOpT+DeEq0dVjVQtai1L4qZw82p341Aa6gtnCnHSlUYBVY7alN79Y+i8O8y06ACGFsWUFqatQ36/xYXNoSehm2hVQBjuAbVKnAObTxWjfMF1oVZARfGR8cWeWDUushY9aNPCyAG2m/PYF0P8nTfx50LwiFy/CqCu2L4I/5YChw1GNOX+Q3qxvSFk/2cTsjzwoRQN1FzyR+9CW9qMPZ6+G1KDbQYdnUb2mYU5pilTbP/shy5We/cbH48nwKFNOT2VNvExuVCDnilMcdkRQAlY87dTz5DGvYpGItASgoYpGWP1yQoiG6N0k1RAt70HbeBsbTtYj3HfFPgItsqB2bH+kEunxwzJuXpY3tLIBSBVdrGOSAk3STlM1NRjrE2k4A31nX6Hul7at0LiYxNEORCDuik/WGsPuO7pvWbuydX95vC2Hvs8k5jgDQHhK8CrB6DsVc5vPLKK7Rty5NPPjk4/+STT15tfVcIzz//PL/2a7/GO9/5Tr785S/zMz/zM3zP93wP/+f//B8ODg6y93z0ox+94Mt/IcQGje2aADIYTmCLrzv/l0ouRKNsrKMkQKw/JQwsRc/ede6J8TFDQNYdBRiTO48FXcSwHi2CMDVEc7juhTsw5vpLxLydN10dhjZYdQ2KRnmxDjcJlMZMw9x4Rkk3YbHZGtQarSoKVTNRln3lmAHXVNhLrPUEWllD4QUWMScKc6rR6wLdHqCYoLiB5haWAxqOaJlzwpQVhlfQ3EVzrjQPi5JTY1hOStppiZ1r3JOFdzu8reC68mvZnnAwtXB9DfMW9iyUQfHRnOAlJE8CGFsHMFYDZx0YU6zAWTQ1uLAFdPxhUh5cO13ilMGpAMZUgXcGnAQwtu8RkLsGlFDs+4VcMw0HhRcSsRPYL7wv5yRsDKaVZ7KmoCaKqtGcLB21tcxrR2sVYNmjZUrJIftM0BjWGFbABM0Jzp1h1me40yXOOMyJhQbKPd895wauhf2ejwkgCUtLg1U1jVp75K5L3w8KfNk1ft2gc9ha01ZekKNxkbeKkMsPHhXYLmyYmwgTE9aF/isHqdHdELHWdRtw93MZqvvX4aU4XiJx2Q0uF3GbPBkOoSBWnh9waXlAJoVxlPgm6b4n+o/yVplnxIL9nMzr40fotRZeb79NOZADF42zMXYqXpdpdjXGdpkh35Z2rKw5Bi73fjljNE2Te2Za3jGXwnQ9WY4BSI369P7cPmZjZU33JYuATrpK5t4lV/+bYlqvst53BWPyugQjEpzIe3NtJdPHfGLfHFtPlwMqsq4jEJVgL5Yt3aB5GyAHBkqLKeub9gP5XhIMpaAoVw+yHXLgKv07HbdjDFQKlGXb58bNZcJlWK+rgKk3S/i6C3i82uGv/JW/0n3+1m/9Vp5//nne+ta38h/+w3/gR3/0R7P3fPjDH+ZDH/pQ9/fx8THPPfec/0P2G+cN5w6XcBFjSUDW3RrtyAig4tXIiKR90w0/+iiMPaOHx+gXFf2wQhkjWNJBTT0e/f9eONwGVqyBTrCj1cobs4UKrpBtsEiDCescRvnOo/EYCgfKBp8uCmCCw1CHdWK1NlTaKya6g9KvEzsqPXiYVDA5h6IG8xDMiqles1ArFsrxDI6Fgrco7yE4WcH+K15AYvYCFA+hfGCY3Jmg2gVl+1Y0B8BbUDxLyz5LnqJiyhcoeQXDyxj+lJKl1tw/mLGaGuztgvZ2idtX8KzxQOZJB9cd7LVws/Jr2Iq7HnAVx1A+9ADS3A/roo49O6bWoI7pwBhrlKvRdo3Cefwp2skRGReoVdyXrMCqaQ/G1ATsngdjdgLuCNQUJtfAHMBkDvOb/tpzt33a4xIeFF4A5EXgXGHvtNi7lvbEsn6hxKwsD48L9pc1T9ByRsM+BW/jGa5hmXNIyRGKEzQTnDuBRy+gT+6izxqwFXbh0UB5DuoQFje8zgjKE3alalCqodINp8ZiKX03sS0spqDmXoqxcTDVNKfQtg7jwLV+e+Yi7EIGoJzvt6ptwYE2UJjgZqvCF37cv0FrD5Ccl+uIY9k517kqxt31/OhwHVAWuj0eY0WkI9FanCBBibFrwfrVaVLjcTMgC+6Vcj2ahm7D6WTiJ/fd0y1H7Hwqe7C/c3iTM2NfrfBq/zaNzZBDHuikRlsuSGNxEyDLsVNjxvqmZ+UYlvQZudn/nItfzlAfM5THDO8IeuR+YJHRkoZ+DsBJgY0oXx9ZLbnWbMxoj1FuDB3dE2Necq2WrKO0/WQ7pGqKubbJgbBN9ZmycmNGfeqWOJZvPB8ZrbIsu82Yo+tiXdcXXBZzfRz68RDbRSnV3TsGyuTasclk0sndx/ti/imDmGPEcn1Zgqzcu+fac4z9TAFsGtL8ZTlyG8aPgaex75H0/k3pc5MqVwVlj5mxr0K4desWxhju3LkzOH/nzp1XZ71XCEdHR3zTN30Tf/iHfziaJm7ieCF0qMpdoKhys9NyVt1Jjiydzk4eoDIILofRury6h6o+YWeF9QXNbWUVGTGSoyNArWB4DvwPxUsOhA3i38Huhej+6K9GGfsWhVUKpwOA7AQ7VBDscN2aKqVrUDWFaphgmeIx0R6wcDC3HrMVK6+caM5Bnyv0yqCrCcrNUOyjOMBxiGOflj0q5qwoOUHzCM2xMpxow7o0rOaGal7AYQE3jF8PdlPDArjewpGFRQ37K7/+S50AJ6AfgrkHao3S90Gv0eoEpbybotInKGr8FtEV2tUYVaFdIAMJYJkhGKuU1+pwGFo19SwZNVDi9Bpn1zg9wekGZyc4XYNbgdr3wM3NwO0ROSmc8szTOrB9jYFWYY2ieligtOV81eAqx8zBI+uF75dMw85we8xYhW5wACh0ex/XTjBrhV7WgMMsPWE3mXmMZZWvQqtgrhwTBU61aNV4nKBr3+6m8P3A4fuFdVBqL+phPWPnXRaHjrEquDIqJ1jgGCMuih1Uq57N8lhLDOt+L7LowNiP5T7vATsmB6fq/usfvstsoxhLF8b6hdsdmYd23zUXvmIc/QteNoSlfJcKbyBZ+9fDb9OuRk0KxHIAa9PMeO7aWB65mD4zx8al6XcJOdCYgq0cwBtjQ1Jwlou5e2We2+7fBDxlOaRQSLrGLAVSkvWQ9ZJ7txT8whAsxTxzgH2szdLnpsByDBTIvOJnyYZJ19QIIqOLoVRHHKtH+W6x3uLnsX4w1o7xvgjWcu+Xvs+2sbYLsJH5yPs3lSEdX+kxfUYORI+Np7E8ciEHPOUzt00KjYXHYOyrECaTCd/xHd/Bpz71Kb7/+78f8IPsU5/6FB/84Adfteecnp7yR3/0R/yNv/E3Ln+zdb1RY21YcNIbZ1HrDYYYadD0nW9guBKP6SAlvXFwhR7UqV64Q8f8Lt4r9/uKjJjq/Kp6F8Uo1teosFSnUB4sadXv4uwgbvA8EAPBgzDVBJvXGhQGG9aIWTSVNrTKYOclzCZ+ndiNqQdiixamtZdBLE9QpmZaLCmKNdeN5ZbxW3Z9Q+HFC4/OYL70hNTsBdDnMPlySXFsMNUNCvcUigMM34jikCVPsuYJjin4AjNO0fwhBXfQnO4VPLgxoZ1rmrfOvBz9MwbeYmDPwTONX5Q2vQflIyhOoXgZ1Ar0i8AxmAdQ3EXrhkVxRqFbFqZmZmpKZVnoGqMss7CzV4Fl6rydO3GdgH1HYgSC0YMxoMGyVmtaNCsaGjQre8zKFtROc6Yn1NawamZUegZ2H3gS3BzcM+AOYXENylt+rdb129DM4K6BVybwyMJ1jTtzLL+oqO41NKcN6/uGPWuxNNzA8iSHPM2UkjMWKAxneDGNPdTqGHf3ReykBl1TnFgvee+gmMCz+7AqgiaLhVNnsWZNRc26KGnCFgm4wjNY1wq/1UFgfW3dUJ+3fo2YbbFO4WFZgcJCa8EGVc9AzJowVFoVlUBDZ3Vh3FiFbSzUFut6QFwQHRU9YvNAzPbTFnKiRG4q2A24OJNBT6Wlybg47p04XhjEcXAnCQbAU0wC6TANZG34ERrMyOwYrgLGLsukvYbD6+G3SarSyc11oTdIcwv007BtJlumS/8eA2TS4B+b8R8DNjGtXN8j3yuVvpcubTkDPWeQxjJKNixGyYjJa+keY6m6omSzJLsm14ylbZKCorg+aTqddgybFO4YE5KQ7mYxSvn7eG8qhT/W5unnTfUp00cGKcrAR/EM2T6yH6TAKH1mFOKI4ExrPRD1kM+WfUQ+q23b7n0jgyWZLvBr02LfiuAv1pXsh6nbonSrjH/nxlsKzHJ9X06sSNCZ6ytjY2ds3EqAGs9tmpDZBl52/U5JAbZ8R9lGlwmPwdhXKXzoQx/ih3/4h3n3u9/Ne97zHj72sY9xdnbWKVj90A/9EM8++ywf/ehHAb+w+vd+7/e6zy+88AL/+3//b/b39/mzf/bPAvB3/+7f5a/+1b/KW9/6Vl588UV+6qd+CmMMH/jABy5fwCi91tFGAYxBtztXNIZ8sg2N3rkebZjFFLE/E47djHs8xmn6xNoTs+HSDu3L2S906R0P/b5iNpIOhe5Rgop5uk5SvIN0js4TTHV0WoGLbBiaRikv1lEamBc+7pXe4Js2wTVxDcUKpWtKXTHRjQdf2u+hfDPoe8zXMDmB4hEUDzwjVjwyFCclmn00T6A4RAfRjpabrDjiFMXLKE5QfJmClzDUk4LV0QR3oOHZ0otxPKvhOe3Xgj1lYdKCOwH3CrgH4L4AnIN+AdSxd000d9G6ZVpUTLTj0Hjl+7jlWKm81sdMee+vRajWKT0Yi63cgTE8OK5wnNPSuJYTaioHZxqOLayDZ2ploaGkUgbaA7AnHozZJahrMHnCqz2qfdDXPHW1KLyC5UMNrYITR7V24Pz6rPUDyx6WQ6CiZcqC68xxTFkEps9vEt1Co3Enr2ALh1s0XsSlALfwoh7X96E2sNR+LzKtHY90A05Rm3VYpGigWIAqvMtiY7wCSOUVE9uVZ8t0mP7wkL8AWpRTuNAPccIbWIFSDqcsKE23h5fS4ZkK2wTQFsaLdyf0YzSO6dirbejvTg5L1/3Xj0VFD8IG49hlPo+dEeBLiXNJkN89Pnlfbj/Zo4KKyCV/jCa8qZkxeO3/NklDXDIFY+uaxmbqYTfjKh7HGI70+qaZ9E1ALIbUcMvdF983TbepLDJuUtHbJmE/Bsqkm6IEQTkXwbQsUvBDgjsJrmT9yGP6bqnb5NjaN1k/l2Ul03KkwCv+nQLmTaBEPkOCkdjHU6Av807LKM9HkBMBotxXLVWljHUFdO0m84p5jDGem9isXLun7yxDyn7LPGLfHxvXaVuN1fPYfbsw7rnzub6VKj/KtrtMeAzGvkrhB3/wB7l79y4f+chHeOmll3jXu97FJz/5yW7h9Be+8IVBZ33xxRf59m//9u7vX/qlX+KXfumX+N7v/V4+/elPA/ClL32JD3zgA9y7d48nnniC7/7u7+Z//I//wRNPPHH5AtoAdFzPZKUz0slXABGSdUZbtAwHPk50n6WLlbyYBWSDGwePRIKyCJRkMlnquN+Xl7GP9rDylEKhAxgLM/24AEK9tds5idnAuFnQrkNxEBQUGzROadyk8G5oEYTNtBfBKPFrxYoKijXarChMw76xzA1cL+BW4cHL/Dzc8gjKB36NWPFQo1cFpj5Cs4fhSTRP4dhnxXVaDrjPjHsY7qF4Ec2pUpwcGOqZoXmiwH1DQE5v016k49YKrlcwXXmgpVbAF4A7oB+g+CKaFfvmIaVaMivOmBcNE225XnrdjKMIxlQCxhBgjB3AWDieh88n4e8zC8fOg7H72qvLP9KWkxbqdsW5ekDjTjlrGyo3x/EQ3LkHY6oBdQjza3B0CGXhmbIzBbWGqcHOLXVdsFxb7h47VrWixDHFskdJwQFTJhQ8gcGhMRhOUPYce3YP2iWUFrdw6LVfxqbnXozyZuF7yHEBE+VomprGORwFzq19h7IT3w/nCuqwrmxdQK2w64a2aVFhQwU/SoowX2Cx1qGUEPKIa7qUHbrbai/mQetl7G1tcS56MEb4NQRPkfgaTJak++/FBN13fwRKrhvT0pE5ZjHc0yuOO4Z5KSXQoBzpfdD0a+LiHIqfSLoCM3bZX4bmkulf4+G1/ts0trnsJpAzZtTJo/ycc1OLn2U+uefn0uVCrowpgyIBhtxsONbDJrCXrrmRQEqyWjJK4YxURTEFXjK9zCsHfuR6rxQQSjCWCoCMAWtpjMc8Y/2k5ZeALgUBr0aIrnyRWYqCFxFgRFZrbAPmHEiQwGgTII2fZRlkXadsTKq0KJkvycrK9LJM8X3KsgTo/pafc2Nnl3Eax0w6DlLQm+a9DZDlrm8CZblxm+uDab5jEyMpM5a+12XC6wVcXTZ83QU8PvjBD466fsQfsRje9ra3bW2IX//1X3+1ihZ8fRgyQ8GJKbooxi7nxLHTTuvAGIkVR2K0SbtuCPGU+L/7OMBlweB0/jgEizGZ/xc5Lb+Wyysohl2vvFvYxHjRjokOedrujbygQQ8gTOee6PcU8w5SJY4Si6GmwGmDm01gUnjN86Op98/bs34frnIN5hxtzimKMybGcr10HBbwdAlvmXgvxoNjn3Tyspew14805UsFup5S2KfQ3ETzLJp30LDHGU+zZs4LGL6I4R6a/4fh3CiWt0qqWwaeKeCdhafevkXDDe1R3/wuqGNQfwycgPo8cAelHqD1F5nomicKy6GGG8Zyu3R+z+cC5oHNO9AefF3T3q59VcGYC2DMwb02HlsetS0nbcNLxRlLq/hS8yUaq3D2FtY+CxwA94BrcPAW2H8W6j248bT3I5w5uKVoX/TlqE8sX6gVZW1Z09LScsSMKQX7tBygKDnAryFr0PYEHlQYVaNbvy6s3QNKaBdw6xrMDzzDuWzgVMOqXbFWCqsVjZp5IKanXkveaa+2uNRQtbBuaFoPxgj157cOb8JQbVFNg9ZgTGCzlPObSEdmTDn/Ge8CiVNgHU3r5fTj9tIejkVA5qOf4OjdFZWKwzfIc1ywNccGuxzRbjCU3QDxJffE83TzQh0PJp8UVgmGza0Bu5Gvfxw2hNfyb9MmMJZbWxTDJrYpDXJGPwfeciyAvFfmkV4bA23SWI55S1XCqCSYMkO5/HPgRwKqKKwxm806oY4olJEDY9L9MLo0TqfTTqxDAjQJIjatG5OgK3VrlOAzB54kwEwBnRQcSQU8xtr7KwmyH0rWqSgKnHOd+Ebbtt2eXznRmRjS/iv3IZOgKPadsc2kJRBOpfPlWjStdeeumLLNEWAVRUFd1wCduEjMr2margy5sTn2vqmgi3ymzG/TJMvY+MsBvVz6sTS574jcvbnvmVx7yva6KjP2Rg5fdzD2mg7ODcGYuKQGZlR3Q/f/oIsplcx2u0H63tNJ5rrty9INP4dZc6UEsOsYtyE0i4Idgwn8qA2upTEo8g/1MFiL5ggy+RoCTxJNWacUTgeWrTR+HVqp/V5iJkTdgK7RuqHQjol2zIwHNTNgEpTjzdorJ5ol6CXotUa1M5SdodjDi3Xs07CgZs45JUsMJ2iOUZxqxbrUVBNFe6C8Rv6R8mzYgYP5yrvylWEdmDoGXgFOKHiI4ZhCnzE1a6aq5abxQOtmAbdDeZ80ng07BPatBwsHjR9gCxvexXnMMxDwoF+WFwU8tPLeg4XqP2sNtfJL7SbKA7NCwxqvfzIF5jga6zhXcO5alIJaLanUCdZZau7hqPCQcAGugekBMPUIcqng3NeP1Yp6T2FrxXmtedR4PvU07Pk1YcqEeaj/fTx7tEC5c3RVoZfeB9CsAOO3IZi0vppn2rsGTg2U1tE4S2NqD5RsUO4sAq3YhD7UajCebcW50Ic1KkQdFEU7r7wYU+nT2K2jmEzcIFoy2oK/6sdi8kMzGIXJiFdk0kvgFKdrFJF1G7JjRHQ2zCv+kInnyxEuc43r3ByI75sdw4TL/zK8gdaMvR5CanTGsM3QHgNG8fO22fPU8JLG1VjYBNYuU8Z0DdwmJiDHKKUgbcztcAxI5eTqc26MqfE6VobccRs4Tj+nZYzsUepGKQHdJgP6KiHtP1H9EIZsUwwpSJFHCfDlRICMEmSn6wRz4C69N5Yrgju5ViwCL5kunSyQ6SOQkyylfO7YOrK0/sb6h6yz9POmcbstjE2yjE2uyLKO5ZG7V5YtvXZVl8PHbopvxmBbQAlWLEINJYwraV6JEAGOvyExVvKdXeapAnMlIdRFw08ehdCAEk9w0TSLhVCde2KrgsKhxrNi0yJ4G/r8aG3HjinnvFti673JTKsorEa5As0Uh8EGVszqwqs3TArYm8K8hIPSs1CF9RskmwrMGZhjJrrmRulYaHhqAkcF3Gxg/wTKJczuQnEO5ZehuAOqWWDat+BVE98B3GbNLVY8xRklf8yEYwx/hObzGFYLzekzhmZP477ZwNMGnlXw5xzMKjh4AcoTKL4E6ougHoL+fyh1ynV9wjW95JpueKawLBS8tfQM2E0DTxUehN0Oromzlfe+VOH1VOMVH1UFuga18lhD1XTrnCIe0No317QACrAF7M/AGWj3wJVgZ55pagtYzvzyqnuF1+I4tvBiCecOPl/DAwv321O+3FSsXMnL9i4rNwX7ZbDPgT6C6UO/Qdjbn4Gnr/tdtUuNO1bU2tHcs9y523L+MlxzGmg4RPFWDrHMKJmyoEVxit/Wex9O76LqFXbP4SZgDzxI0sq/y9MTOCtgGVDFaVtR6ROcq8DMAq0zBzPxrpTrCawM1A3UFmc1rvGi8YYpGoNzCttav8dYYz2ALeOcQhCYVwxFbwhr5uqwGNw6WhtFMOJoj2MsjK/wHv5MFK5XSRyOUwnEeldIK74J3BC7xQHcZRVQeTc5NP7tIeX5O4D2GIy94cImV6/UoM+xSNHYlIZnDGOgbJd8N4XU8MsZ0HK2fGx91ibjXgKR3LtF1imyWmVZdsxYPCddDKVLYhT1mE6nF9JHVmtsXZasQ5lujLmS9SODzFe678X85BozCdLSMNZmu7jX5UIOQDrnKMuyO0pmTLJJkgXK9akckAIGTJcU1MgBO+neGq/HOnPOdWWRro3S5TB1vZTMWLw/pk37ppTjl8IjOUY7llGuZRurF9kesY62gam0ftKJgDGVSple1q2sozGglAOb8R0fg7E+PAZjm0LKYAHDOemLHXbIiNEbfoPO7USC3Ay6GhhwefAl8xKDWpSwX7cvZjNSZkzTM2JG9aIdXfHcIAcp2KFdLKeXVPBmrAalPStmAis28fuLUSrf44oWdOv37DIVRrdMtXf3WxivnDi3YUnZ2ostmnPQZz4qV6Kcl6/3XNQhLQesmHMeuKyHKB6geaA0TamoDzXuQMEN5QHHLeCmC5s2PwL9APRdUC+BeoTSdzDqjLlZc6Brbmjv2bin4S2FXxt2U/t9z2bK7w09JagG1sAa3Bm4GjgGtwrnlngkvAYXt2+L7WQCKAvGcDHFk1iFB8FMfZuqks6dsVWeadpXfl2WwoOxxnlGzlBz5mqM0xSsUa7EuZnPRFdgjkCv4eCGdx9dAbcUlGCPFDSa81NHoxzWWR6gabHcZMI1CqDGcS30gUMca3R96hktWg9EjXcztRVMJ36rApTfHHpmYY1FuRrnlGfrVOsnBCbKv2AZNhAzBozBy9BHA8O7yVpaL77hQv+MpJeOXVgyZM4jX6Pw7pAKVNzeIYIYCWxCgSWOU3IcJmM7890/ZL0dcnolG9LvC0XHlLkLd6bfSZHFD6zbZR0VyxAvEzb//j8Or3LYZmBsM8himjEWZlNaGa+67iP3zE0AMAdu0vtS5iT3fjlwJ9eBSZA0BgbTdWQ5ELat7lImbay8m+oiB8bk+rBcnaXtlWu7sXNjIF2WT56LnyW4loZ4PEqAEj+n+chnyDVZEQxsYqDieQkaItCJdSeZMQmQI+CQf8f0RVEMmLToFimDBCvpREZuIiW+S9p2EoylgCj3rruG3ATJZVjuHGDP3bNpguEy4TEYe7OGaHA5R29t9J/jJ9dF1RlKHYRRIo65VXQx/dcbbp2R59KpcTeIKuIpN8yTjh3r9xTzAog6cU8kXvWsmLNoZwMbFqKFwhoMJYoyMGPeVdGiPTM2CXFR+jgDJo1nxIoV6IrCrDGmZk87jkrY13ANuOZgsQ5eg6dQ3AN9Dnq5D24B7hbwNJYDKm5jucV99vhycEv8EwwP0dy7ZqgONfaGxv0ZDYcK3mHhaQvXTkHfB3UG6vdB3cfoFyjMF5npJU8Up8x0zVtNy5MGbhl4R+HXPL1F+XLOz2F/CUUD0zMwDXAMzakHX/YhUIOLYKwCd44HY5UAY5FcCUulVGQmJqAiGDsENQW97z8zAX3dpz2cw3QK1yZwtIC1huslPAReMl4o8sQ5DpqaE2u5r+/wqF3R2iMa1+DcAdgaeAD7+/ANN/yirqWCI2hLTeXgdKX44n1Y1IoCF2DYFMV1SmYUPIWmxG8MfoaqK8yjY3TV0E7BljBbwOHM46sj7TU6nLIcU9M4RcM6gLICT6spr/5oDMzWsCpwFVjllRQNEwpsYKlaWmcxQe7eaL/s02pH68L6z26NV0BWGj9pYKMfexzdcTD40SInOeLPresAWY6uyjNj/Scr0slvAvGg7nT8DulhlXzqELa5bGkuFSY8BmOv8bDNCJLGcxpTo38XA2wsyuftUt6xPHJGZc6dMH2mXFsmwZOUcZchZbriUW7unIpGSJl5KdIhQdC2d4llyYG3HIBL6yFl0uT6MKnWGNfUjQEfWWdjbEaOXRljXCQ43OaiKdsnApzIkElpeMlUpcBO9qOYl+zXsl/IsqdpJOsU2zyuB4v3S6YtXfOktaaqqu7+2N+i8EcM8T7JdI2xgSlolEzbLgBp2ziWgC4HBMfy3PRc+cw0/xR4XnXiJn2Hx2DsTRlS0AMXTZ9uDnpgCDkJwmKHVirJxw2OKQzrDUAnrK4IDuNtEgrSkXGDCXxhCkowZhEbMWtxU5eiBWdR1nXLvCIYMxgKShQTNJOwA5kOyozGu5dNC++iuFd6JY6y8WxYGcCYrih1w6KAo9IzO0fKg7HZyqsnmpOgIH+mUMt9lLuJ4gkcT+M4YM0T1NzgFQxfQPMQxZ+ieagM1TVD9az2TM87AtJ7u/Wy9eYBmD/Ai3X8X9D3KMyXmRYvcqgd75g4DjX8mQKelWAMeLqFAwssQd31bJd72QOu9j7YR2BX0D4EV/VgzEVFjgDGopSlssGwj+oRGTCmIxg78J/1DMwT/tzhLVDXgH1wwXXxZgHHCr5svNvnsXXMdMMD2/AnzcusuEutDmlthbP7oTCP4OBpmO3DeemFPa5prPJrx+yx4ovHjkmtKLDUtNxmyiE3mLFmzgkTJkCD4hTdnMHDc9x5QzH3LpZTBwdHnii9bjyBVinHjIbKgVUrWgu4KdCAM7CY+LqZlX7xmfUOin6tmAmrFR02CHq0tgZaTAutAawAY872YyZqdIQx4FqHxaH7gTDgs+SYkmPsIhhTgzEqc1AXRqZKODLF8KP47ui+EFw34iPLnZhOojxX+CF6DMbeECE1jnJgLDW6xoDE2OeUZdnkJpXLZyzk2KMcwyNdpVLXwhTkRDYpimxIl0WpphjTybzG0o+BvrQuJXiQrNamtWIpwIxuiFKkI3V1TMsh6yiNErSMuZeNXZPtmDJ1sUzQu8NK8JNjoiT4kiAlBwpSdix14xtjlNL7Y4j1OJlMuj6d7iMWyxWPMX0OjEl2TwI56a6YuvelZdvG+I2NyW0hfVaah7y2C0Abq+tt3wVXDY/B2Js1iH7UkVLE2ece5gwNKWFaDaw3Ru0iCZXimdREy4eLBlf6yBSIxYJ0d3RWZTTgIisWo+3l9x1CMsGEHZ88IxaBmEV5kQUTY7jcCXZ40Q6lK0ptmWkvgLHQMCfgtdaLduglqJVCVcZvVmUXwD4uuCc27HNGyTmKh2juoznRmtVc05Qae0PBLd27JB5YmJ0EJZBXQN9FqWNK8wCtjzk0K64VliPtl5UdhuPTBo4sHJ57t7riHC9DeQ/syx6MxWN7H9oIxh6Aq8GdadxaQ6P80SovJW9BRdUOAO08KCud33C7sKhTC4VDn1nUxKEPPFtoZ74MaupBnj4HDnxz6inM5l6c8Ib2y632NDwKIiNLByvnWLU199sTahoa/QqtM56R0jegmMNhoOAeAQ8UttC0R5q6cJyuNQ8qQwk8QLFAY1hgaPDuo/t+vDQzUC1q3aLPLaYI28o5j9UXBuYOphqUdVSqodV+A2l0E/qO82omRkFhcLXFKo12TsASgwxCF7MAAQAASURBVMEAfj8yh/VOszawjc4GUjn28Tgg3YUBGPms4WhMfpgujMPMWBWn+gmWOP7kZEsGy8gL3fxNP3ZjeXJMmTCPe2GQ18fv0eOwY8gZOens82UYr12ZrTTfyxpbOUNuV2NpjO2LeUnwlq6/iiFl2sYEOORxLG0KDtN3yTFiOYCZgrIcI5i6So7llYIPCQKktPxlwFjuespQxWdHUCaZnRzIjG0BPVCT7Fhcn5WyUrm8JLiK6eW1MQNe3hvvS9caynxl/vEoo2RoZb3Fe2O6lLWTzNdlgIOs85Tpukwel7knZeHG7k/HaK4NtoH9N1t4DMY2BW/bdRglDJduNhrGjKAQlAo+TXF2+2Iiv66rN9Qu8mOCFNvwxDHDrs9JCzdF79TV7dOsY0GCz5xrPIPQNtD6jXxNC4VVFK6gQFMyoWSGo8BSAl4YpAFaU3gWY2a8e+LUehfFcuUXfxUnKF2xZ2oOVVAlLGHRwuIcJiso70PxCuhzgzrdh9UE527jeBbHk1i+IcjXz7mL5osY/oCS1URz/GxJfaBx32jg7RpuWvhzDSwqmH4e9B0wXwLzfzH6lMPyRebmlG+YtLythOsavqX0iol/RsMzGiansLgLegX6RbDHYO9B+5IHYc1Lfp/lFIzRKGw9gbbEuRLcDOU0uLKvfKcYSACqGqdaoEbplQcz5QplWg/GDkHNoLjVM2TmumfMzLPAHK4/A9cO4cY1eMstOFV+ndtDB0/U8GQB99sV/099ibO24CErztWLwMvg1jC7Bt/wTmiuh3Y0uAdQWUV97HjxBceDV+ABftXWASUFT1ByhHeIXXmKcHWMWhvMwzNfeTVMDnz5rx/5dXGt8uU6d5alPqe261A/M3+cTkBpvzhuVuBaR0NDD0yg3z3PYKnRKFrb0LbWS8a3rQdiphFDJ4wuP8uAE7hYrkmLZyKQkmOyxzqO4UiVkE6yYP4u3e0Ipru0F75ABjMrF788+hL1t8spld4VmcvtA1bi2bHH4TUbpHtWNLRTw3PMEBpjxsZmstP0lwFxaT7yKM/vko9keKLhLg1dyWJJMCbzlqxYZDTiuXQNmFJqcF2ml2llXaf1FcslXR0liyTTS4YpvocUDZHr1WI6eX/aH+Ix1tWughm5Ntp0PWXGUlfKeC7HAkqGTLouKqUuiGJI4z8CGgmCpADHmIR+joWSTKNktyQ4lM+U6/KstQNGtSiKjhlL20S6Ocb6S6Xsc3W9KVyGFdslH/l3Dtynz8zFGHJgLL6nBLASnG4Lj5mxN2sYoprE6Bku8Y9X+r+FJZXkc5HQkq6JSphug0T0xt7wXKeieKHIF3kyyY7l87SCFXOdrSqZsV5OXAf3RG8KR205F8VAjOq123UQ7VA+KtVQKMdUe52GKd7+M43XlVDrGBU0pad5mOPYwzKnYUrNlDO/5TCnSnOmNVWpafc07iCsETtScOhgr/HKieYU1AOUfojSjzD6jLk+Z2HWHAaFxOvai3McKjhycNj6pW7lGahzsA/APQT7SohLaO8pf3ygaI8Vdq1oHyloFa6ZeSCGfwe/YfEEgYSRrKSjxlvPdWiTFlU4lKpxrcO1Dj0Dpa335tPOe5RWoKagFmD2wt7dEy8oYgzcwDfJQw0nDpyz7OkKR8OZPkUrjdN7OPUwuAWu/FqyA+X9SK3DHWqcdaynGms0Z05zYn2fWDGhRmOYo1igqDyFp9ZQrVBrrxWiK9DG73IwDW0/Vf6NtWpDtQQhD228fGcnMuPFYZxSAnzE3mhw2K5/Kqe6fttR2zHGfp6EmN9wFGV+6Fw/mpw8IcfSYKjmfyzjqB/mkUneIcAIPfvx3I/k/v7BVM1lf6cnPAZjr/GQYy1S96BNbMcY6MoZXfLvr9ToG8t7W9jGiqUxx47Ev3Ms1CbAmWPNcuu8UjC7KY8UCOfSjTFqqdtmzgCWoDWCihwzto05jXluSiPfOy2LrLMcm5q2l2TLUpn5MaM/98yUUZPvMdZOOaZLgm2ZRjJjuX4kyxXraIxRHdsjbVvIjderjM9N91wlP1m/m97lqnk/BmNvxtBrWANh9rzHKJ27UDJnRIYjy4QhqzUMGRiWArqBlSnyiOSKgGcqGPw94EuLIl/KgvNrxXTrvD0cmDHtFNoVwSGs7ABFg6ZB0ShFq5RXZ5gXMFdBrVAFv8NztFlShrVih9py3cARfk+uWQXTYyhOvGiHeRlUXaKam/hNi58B3sI5B7xMyRmaP6XgJQru75ecH01orxnsNwV6653AOxTMTmH2Jz5j839Bf5FZcY/DyUssTMU3TiuuF/BnSvizpQdg3xjw28ErUDwE7kPzeXBn0H7ei3O0r3hGzK01zaM5rjI01YK2muPaElcvcM7g3B69hTsL7ZGCMehcRKlxHRjz8ouqPQNVo89XqHqFNjXtw1NU0WC+vMLs1ehDKF8KYOwVL/DBk778izm87UmoZt4l9LqBu63/AnhkHX/MMS/rJedNyzEKZw9BTcDdhttPw/xZuK+hMvDAUStFWxgenGs+f89yYFv2aFmiOeKAWzyLZg/FA3Az9FkLzZkX0LwG7MFi4V0qz5wvT+kcD1xDa1savaYx5357iWIKrvAs67zA1ZbWGJRztNbXlAprGL3TrF/wpF0bNqD2/dc6h2stjuDTr/TFuQ4xagAxZvw0hOtAHWIfPwmEwuRGGJvuwteBSo7pX1/ZD4cLvHf4Eui72GXCYzD2mg/RSJQz6zFsA2SvVpB55wztbUECpW3AQjITqZR5zpUvXTsV/5YslWS4cntypayW3Eg5Z1TH8seyxPRRQj+eywEKCbyisIjchDoyZBKcxGfKTZZTFkwyRClTtAmsbwpjLFm6Zkxr3bFbkX2K9RffOQewYv7GmE5UI7JNkrVKyyQZ4lgPkimTLIxk2WTfAL+GLMrWS6XHeIzlT5U14zmZXr5T2kdl35bCH3LSYax9UiC/a8jl/bUAKzl2XgL0q+az6z2vh/AYjG0KGo+COk+iYaO6C2diuMrsYY7bkvm7HoQlVwfmnSjU0Nkxx47Rv1ckZqJwh3UoG0iJIDKhXc9AKApUt1ZM+aiEIMjEeHenwvo1P6YGXaFUTaEaStUy116dcOFg3sK0CTL2Z6BP8doa1uCB2BGO68ANKmbcx3CM4i6Glyk4mxZUN0rcde03/7qlInYDVQEvg3oA5gUwL1AWjzgsH3KoLc+WcLuAtxXwduOJtLc0vkzuAfBlz4A1fwru1IOy9kEPxmytac8n2HZCyzUshzhmOK7hKIF9PP/jXe88GCtD/cl2scGo98yYhxkrvJDFKcpVtOsz1PoYzTqITayx84Z2WmMOgTWoPY+pzSPvGWi039v59jVwU3AaCuPl8E8dPLSOk3bJmiUAJ63B6RPgtgdDh/ueJpwbvxf23IuTtOeKM+145YFhaeE2Go2iZM5NbuAHznXfv1b30Suwxrcvym9dQOul7vf8EjqmyrJSYFUdKDQd1hkqvzXC1BfeKY1Vfj8x6xxedqMInJHxnK3TnpQNfRigtYFlQ4WJB5WhkYZwzL+HFec2TaS40eE/9l3hJ3Qu84ORfergNVxu2O8aCi4v4LG7p8nj8CoEOTufGlabjLmrhE3G3lWek2M2NjFyqSuTZHY2MU9pfjJdbu1VLq9Na7Vi2XLvlsrgRzAWXdzSIAFMCgClC6Z8nxwLJvfwSt3tpIDENiCWK+OYS6Nsl1h/cs1XbN/IdknGLMcQyskEoNtYOQfA0r8luC+KYsBIpaqE8bNk42I5JWBMWSvZxvE9Zb/IsXExL+n2GOtMtqEcCzn2d6xtdgmb2jSX9tWYzNnGZF81v8ve83oIj8HYpqBVD1KETRYnx3tjDQhuiwOeTMyio8IUuZNmkxvc3/8/tJ+yXSntxwNLjIw1JoFZTCSm7SM7FhQUcYn7o4s5REUOjd/oWdHgXcxcFFmYaG80T1yg1FoPiNQKrSvmyjFVXsr+wPilXMUyAIcAxPR6gmYKXENxhOOImn3qoNl3n4ITZTiZFCxNQX1U4p4sPCP2tIGbwMFJQHV3QH0Z1EOmxX1K84ib5TnPFo5rBp4r4Lbxive3Ki+rr+/7dV/2C2BfDGAsMGPNiyX2WNOeTmnWM1w7oXXXsUywHAUwNsVxDShwRGasxIMyD1l6VixlxprA3oQNy2iBMxQVijPgEMsaxRzHGtpjXHWKO6vh7hJ10uJMQ3tsMWsPvtQh6DlwDItrcOvQt+ID7b0QH4Vvgik1S3tMZS1rd4dWtcABuBswm8Ht6571vO9gqWi1Y/mggbXiYVVQtI4FJefMKFkw5RoGB9wHDtFNjT5bAQ5zDmbul4Ttz/2r72moHVjdUNmVHze69v2qLMPm5C1MvFBMW7XUzjt+xo3NVTw6hVL90IUA3OJm7sp6MRWXjjbJi0k+OU5gqH5cjwWZfEvSC6xa/J6IP1bp2O4ekbJs/co1/+IhD53cuC1chRl7ffzevWGCXG+RGjapG1Yu5Fy2xozt9HwOPEkjNcduybTyc87gk8/b5MKVun5tc7fa5PoXr28CZHIt2dizcmvXUvYtVw9xzVI8puvSJNOXStRLaXjJgkk3RQloN0ml79pvcvdtU/5LRTlS178UNEcwFTeMjvWTYyTTvhnBWHxuZLrG3j1l9NJySoAoJ0JkeglGNz1nbIykjHYOyKR5yfSbgkyzK/s5ludVJnzS74DHzNjF8BiMbQqRGYtGUuvPufYiKzZcPyYBTjDc4t8dIOtDD82cMLAyE/bx2FFgIuEwo8S9Kq7rSqfKXc8OWM+G4VqgRTmHds6TWo5ug2cCK+YocJi4fzGNgrYMQGxhfJzaXs4+7NpcqIYDbb2rnPaS8fstlCdQnkNx37vVmfM52t3AOzE+jeOIJTc544B7FLzAhBNluLc35eF8Ak+X8GcmcFPBNxmvnjh/AMUXPBDT/w+tHrJffpG94hXeUji+Zea4ruH/Kz0Ye2oFz6xAPQL3OWiPof5DaF8AexfqPwK31DSvzLDnJdbdoLVP4Nwcy20cswDEDgIYO8CDsTkDvfrA4lykLoILBU343BA18BVewlFxjuIMxRrLAxRr2uoeun6EXp3SPnoJZda0D87Qexbzsn8Pfeg30NbX4drb4JqBGyWYBZyEx18r4Av1ijPWnLcn3GdGa+95NGensHcd3n4IqxmsFRhHPVcc37eszgpeetSyav0b3kQzR1PyJIY5mhPgDOpzioc1dt1QHIErYHEAN/f8urGjsJSrsRVnirCPwr4v4LTw1FplPEunLXXcUwyFxQQ4EhkyHTYnBx0QkbJtADnKH63273fBnzD298iK+XHkx6gdjLVB6LIZ+SETky5u8HdmEDuH373aXXjWcGKlP9uDMXoUelk3xcfhNR9SQyYa3DBusOSM2PTvyxgu0rhL3QLH0ubKkgM38h1SYQNp6ErDbhtIikZz6qaYW5Mlma10XzEpvpG+k5TBl/uYSRn69J74zMlkgtY669Yo3VJTV0TJgkUwJgFYTjlxF6M2x+5sSifBdSoHH9kt6bIo60SKYgAdEIt5xrJHt0f5HBni8yJrFYFRyhLm+kdsV+mmGI/xWXLNWARgsR/Fc2P1mwL9HNsb0+UmImQeKUuWGz9jbbVprG0DYennFESOjcEUCMp6fBx8eAzGNobQqSKrldprYv7ckZhGTn5IAVkuYfjiGzBWbpCif0CmA1+YOU+ZMJLPaRlj2YIR6JxYEzNk2KKaZNtFRQs4o7xqRJQj73zEomhHi1GWUnnRjjgBX1pPfugqxDWopkS5GV60Y45iTkPJCs0KzRLNUmnqicbNtadUDrT3CJw3nj0pzvG+jicodRrEOioOtOUwbDp8pOEQ2Ld+T+HiFNwJNA/BPfJiHfY+tI809sxgVwW2WmCbKZYDvCviDMchjnk47uOYhGMRgFkZPpehHk1Sr9LaNvhNAgo8+G3DiqWWyEp6hs0CaxwNzoF1CmVPUbakXVoPvo9b1IMW14J+EHK/4XVMyhnsB4x4TcGJhkfacaAdioYTc06FwdkTnDoGXcJkDZShvj296Raa1jpWp5rz0DbrsBOdY4aiQTEH5ijboCuF00HMo/bk6cT1In4TBYVyaNXiaHG69ZMFcWbAAIXCtX6NokJhcWIb5SEbrJwbjgTnPGsU+3uOdqIbueLOyFqxOURXYjkvQ78dRhqyLoqRGetotQjIkh94UcIL+URa8OIX1+bwmBl73YRdXX02GW05IJZ+HgNvu5RlLN9tYYwNu8y9KVDIuSXmXOVywgw517r03VNAl3uWDGPp0/skEE0VJSXIkAb8GLuS+zsXtoGxXdo7x5ZJV8VoxMt9t2T+khWUDJRMm7tHppeG/5h7abxXtn8qp5/2kTR9jqW9TL/NsVxXYYHSSZexsb8p/xzjmOa3y7vlWLscmNw1PGbG3qwhGjIXDKD+qBJzLfJQ3m5ycVJdzJYPQVlvBg610ML8ezgvAdqGEO1LC26gWx+ZsXSCPYIviKIdYNEBiHV3Orp8HAaHoQIsLWs0S7x4h50Z2AvCHZMmiHeswKwxZk2hK+bacqQd+zooFdYwW8L0YQAI9xXmgcK0+2iexPsbPkvLEacc8BIlX6bkBSacGcPy9sTr4r+9hHcYOKzg2j1YLEH/iWfE9MtMiz9hqk9563TFW8L6sP+v9PtAv2MNRw0UL0DzBQ/A6v/jldnrP/DMWLuc0T66iWtntPXTgf26jusYsZvhuI9jgaOkZYFf1aW95H+AJaGJQjtIIO/oa9rXdoF3vpuFmtesUSxR1Bge4ZUX7wMnwAmOmyi7xJ68hDo/xqxOaB/eRx847NpL4BdnHnCW1+HpPwv1HNoJXA8bbzfAA1tTuTu0+h51W1K3JagnQB/5G5+6DubAG+33S+xDzf3TCadnXkfxJo4j4AZPMucaihNgiapLePgKetLSXrdQepLLHnnhxOuh257rlkfG0jpNY5YeahVl2Ezcwp7BGcX6vKUO9VX4Xe7CyjXfTyOzFZkx3c01WL99QAQ7Utd+ME4kxeSPblc3RQClcMrhnF8XZjvYlEy0DB7uhqciCHMXCa/EJBTMupjkudzv3dWk7R+vGfuahtQgSo2enMGTinzE466GovycYyV2yeMyxtcYGBsDh7E8Ulo8xnTz5jFXwHSdWJpWGvgyRCN8Mpl0TFgU3ZBy9PK+yODEKMU6JGMnGa6maTomrKoqnOtdEiMjBhcl01OmZQyoyXrPhRwjI8FPCljiZ8kspaxZdEOUroGyLeJ7xPeTfb+u61HmaDKZDECqdN2U7F2uH8WySvfG1M1TCn6UpV9kG8+lbSHzzY2blGGS7XXZkAN1MqQuhmOy+rsAtRxzl7qSymduO7fLuz0GY2/m0M0w9waOZJ36Zf1O/C3A1QXDLZ2BjzL5Ui4/BWuhHCN5DE53ttwQNo7fFUGZ7Z6uoJe0T/JxgaNpPSfjgYYKrNhEe2NO28FGz1q1GNVSaO+ONgOmzseyCSzJCvRKYdZ+TZViD9jDsQ/sUTHhDMMZmlMMS21oFxoOww7NRwr2HUyX3u+RR6AeoPUDCnPMRJ9zzfh9zW4ZHw8tXGvgoIb2xIty2PvQ3g2KiXehuQu2KWlXezi3wHI9QI3rOG4G5utGOHrpfUeJZY5FUWM7fcQqaN21pAC8t5n7rbQVE1RwDNXh+hTNBK+4qMNRYYO6paVBsYT6HGoLbQWVwq0c+iZQg74G9sAb83sraAsPxFoNp6FelHLMzDklYN0javvAM2P6BFQJewdQKThWcE1jW1iWhgrLKYZzNFMKHAu8sMYeij2sPUNXGqxCrxVm5SgqmESZe+U3pp5oh7HOAybdePfEKOtZOCi115nRKqxb9HVsiK6+cj3eRX7Xz424MAGhBy0wnLBIx5Afy51XoxNJBiH5kQ+jO51yScd5fzE5EwHZhamg/jmpruuVw1WYscdg7OsSxhia9G/pRhT/jsdNBtjY9bGZ8zSMgadNIZd2VyMxNWpj2XLrv8YYspTpGGOtZDkke7bpGbKuxsol15bFkDJiOcn6XUCWBNKbmLNcyAEtCa5y94/1nZRJjH9L4Yz4LLl/WUwjGbJUIVGCwwju0jVgUmlRtqF0RcxF2d9zfUWuHZOgZ5dxsI0Z22UiQ+axKf0mdmtTOTd9P8jn5T5fBXzlnv8YjL2ZgxNRBG/yqcEZHRgtAKwNiRIQ5cQUd3c2mmY9oLMdL9ahoqGNF2wzFy47J224CJx6Vsx2UchfR6DoIlfjhjPu8TLe6G3D+9V4GFBpcKX2xvEiMGMzC5MWisYvVDIrStOwCN6EhyboC678/l3mFIpjMOc6MGITNNfR3KDliBULKmY8YuJVFMuCZlHQLgzuloEnFTxh4WYNs3MoXgL3APQXQX+emTnhLUXDofaM2DsMfIOCZ1uYr6H8sgdizZ9A88fQ3vPrw+yxorl/jbbaw7ZHWPccsMDxLF5E4yiAsQkN17CUrCioMDRo1jS0wKoDY466A2PSFB/2KQnGytCn/PorRYljQonBMMdgsBRMMOwDZ3gkvMKiUBxh233c2qBZwxcf0t6viFs0mGNQ+8AhHD0L0xvQOnhYeJD6cuGB0cvuES/ZL+DcCuyzoJawtwB9AEsHtzUUYG8Y3NKyXBvuL/2auBOmlGimHDLlRuAGr6NcSbE8w51UFAsv3FIGIQ9rPKbe01AZR2MqL0Zf1n7z5qny/cw475LaWtpGsW5cEAvx9ej7elgrGSq7H0aepxK0dXdnvCIhXT+WBkRVP+ZyoEz1w7Qf40r8FYuV9oKYmev/DA/0jLUebFbRP06e2YG9GwuPwdjrJowZ0CkLE8+ls+LbZs/T58i/L2MYbQJ928qzybCU4CJdEwW9q9omSfscIIrXN20ILcsWma807dhaughAUqGP9B7J6sQ1YVVVDcQ6NgExyYzl9hlL7x1rgxgkiEpdOiVoSl0s4985NcH4TCmAAT3LFNPH/FNQmuYjwYFs/5in1rq7NwUlco2ZLIMUQpHv6Zzr+ohMH9srB4A3bS0QQ+56bqIhN6lymTGZfh+kz4l1sqmMKWDMTTqkYP2qAOkxGHuzhpy17HqjR10wh3qAZiUyco7MhkPdDb3pNVxX4gJocrih4FumjNEg7A2/ngeIa7wG+Q0QpoRqYn1Nl7cK7lUq7OmkWAMVjlaDmyrPiO0VsF/CvIayCrsNr6FYM9FNt6zrMBjbs8ob4cVp2AJsqTHNPoY9NDdQ3KThGksWLJnykKIDY/W1gvbAwBMantRwO0ghFuegXwLugPo86M8zNzXPFTU3NLyj8PFZB29poVxB+2JgwP4oCHbcC8dTRVsfYZvbOG4Ab8O7ID4D3Xqx67QU1CxoMZzRckpLjeOUmgbHChsYREcjwFiU6+jt+CiR4j95MOYN7zmGIoCyRdhRS7NHiUKxQLPGcY5mhpfDL4BjWrtAVQpbn+Kqc3RR+Q5iwR2D3veiHtcP4MY1X5CzsJ7ubgBjtXvEHbvG2aUHY5zD/hOwdxvW2qufFBp708DScf7Icn/VopzmFMUUg+GQOTfxzprXUa6gWNY4U9EugovqHPZnoAwcWA/GtLOcmTUt1vensvFCHh0YM9C0NGvLqnEURBc+P3EQ+34HxsSo8NVvQ+yBVhwjHZATo8LJc+kQQhzpGrUDWynw6sehSJ/OgoAX1unmSnppnotgrGexVfzKScu0S7iKm2K7Pcnj8OqFTcZXusYlPQ8X1+2k6bbNlG8ywmSZNjEv24zAy9RDKg0uDckoFpGKcaRuhykoywG4lOWKz4jXcmnTOon1JYFCCsYi6JBiHdE1sa7rC+52ab2mboqpm14KynJ1n2NlcmBMgqTYnyI4TQ3xtN0kqJDiG7k1e/F8LLNSXmAj15diWeN90qUwlciX6WPZY/1JcJWuO8uBsSi4Utd1V9/y/S4DyHLtkBvzm0BOmj4HjFKAnCvTtrGdY5Zz9469167hMRh7s4cIrAZ2kzSG5LqfEdTk3OjM+SDZJstJbbg2uJSCMGlkiqQqudEJx0YB7uQ7RgDhdyNTWK1wRWDGChWi64U7dAOqxmjrRTtU76ZYtEPRDr1WKDtBMUMxR7HAMWON6UQ7ztFURmHnChYQPBlhUgPn+LVTj4BjSrVkomsOVMtRUG+8rrw3417lVe85AfcwCHXEeKyx9QzXlDh7iHdJvIbjEP/QfRz7tMxoKGkxnOMF6c+wnGOpsJzT0gYwVuOCW+fubooaRRP4GIfXCLQBsE9wTNDejRCNC/xTyR5+WB+EPFc4jgGDaw+8TX9e0T6ooPTvC6AfesXF6RSu7XtD/kh74utQWfZUTa3WrDnBMSGuUcNM/O7Na+U3DFsomqVf1bYM6wlXaPaYhPaco5ihqVG1Ce0ehDwKjwEaFXZGUNAoh995XAWX1xaM8a9YKL/3WKlxjcIqz+yFbTr7vu7UoN/3w0ggqGRs2dDj4+5ibtBCCfbKTNiIp3VQzGXuz90+fIAbnOvB5BDAxycNpnxSoPg4vOFCahjl3IM2MUtj1yWoGTOmd807l3YXELbNQNwFQGxyNZSsziYXxTFXRlnG3LWxOh57Vg7QpixQDkCN1Um8P3Vn3ATGxuo6ljt9nxSkxfNRyVCmyRnospwR0MFwHVO6HcAmd1GZZ678st5zQEWmS/tIvGdTX5Hukzl2emxSQl7fFmR5x/Ia64PpvdvGZJrP2CTLGCMWQ9reVwFVb/TwGIxtChZvDPX+fZ3d1htEw84ahbAVYXYahpbbGFYTyeLfvTthJvEARPnoMWMPxCCKgPhcmvDJyhfQ0RAVP2KxmI6w5Zh30XJoqvCwtYJKeUOYvQKmBuY6LAazgRlbg1mizDlT7ff0OjJww3j1wsXaL+0qHkHxAExlMPU1DDdR3EbxJC1zHjLhEYa7GO5SsJoZ7O2Arp4BnnFw7RHwIrhXgD9GcYcjdZcbZsWzheObCsctA+8MGztPT0D/sV8X1vw+tHe8WEf1ObDrGc3Zc9hmD+fehuNpvMT+W3DMsTyBY481hlMKKhwPaaloOKXmjIYaxzlNB8Zi3TcBJPROoQzqPfahCMYKvJviFE0BzDBBV1JzhmWC5hDNHjOmTDhgjqZBM0FxhpfXn+HcCTSg2kfUL93BnbyMvQd64kU99MSv2Tu4Dd+4D8cGHpR+KV5lG45byxnHfJnPU/EQ3HWwJcyO4Knn/N5jTytoNOeV4e6dgtZZ7obRsMchGhUA6BM4O6E4uwdrsHMoj0FZuOZgVsBDC/c1KFqMWVIr48Vg7MzL0c8ApWBRgPWbOdulxji/1kx3g83L0Tsb1muJrt939tASWgUXTkfrghplyMkPhzgOwhgLEzTDMX5xkEfuczieHYPbwl0bGfBkfA5BWTJB1M3AuA2ZjoSruCk+Zsa+pmFMFCBlE2TIgZtdQNUmoz/mm16TaVIDNJ2Vl0xOCqY2GZVjUTIikQWTohqSHZNMWLpJc+rOKPcYS2PKsqWMDwwFLlLpfOn+KAGKZMSim2LKiMl6ifUp9xuLDI1k1GQeVzGMc8AovnsU45DS/KnLoWxrueZN1pNzrqt/CWxSZiyCuE2sUwRS6bYEuXe31g6YtFh+CQ5j/wIGzNhkMhkwY/LZ8nmbGElZx7nxKtfKjYG7+DmnUpmGsfGdK8emkJvciO8vy5tOAlwmXPWe10N4DMY2BRcMGeeQVlNv8kgzKBpdI3grtdFUPxkvL7nBDfGTS04lfwcglhJnnYHXReEYNSx+Hx0DY865C6/fHZ1S3oA1Okjaq6C87jo5ey9pb/2evcp7QMVo2iBpX4OqFarWKFeimEKIjglV0BCMsTYKN8Mb5DNg5vx6Is7AnQI+TlTFnrLsq+AeqcJaJOvZOE7AHYON8URhTxW2KXHtAuc8AxaZME/BzbDMcExp8NswV1hWWNZYluFzHY4tjnUHxrgAxmSdXgRjjiaAMcLn2FANUGJpITBkOrjmeV1Bz0IBLIH9kMM+uBa7fojFoOYWe+JQxteDO4biAOYttMpza2fab869pyytatDqHN/Ip76u9cyvEawczIGZop0oKq1Y277NmiDxr7pGW6Lawu9fVzvfDxpPqjoX+ory5JdSYe2lsoFxtXR7jxfK9z2t/HZ5rscFkTnqGCk575CMxe6cCiyak2Nm2E7DPF1/fwzxeyMTXOav7tw2IJb5TRlOBiUTNCq81GV/jB6Dsdd8yIGQGMZYrjGXscs8cyxsYtJy9+XKvcs77JrXrkzXGOuVuz/NN/07ZQJS1kGC11zZcu902fVd8rpk1VK3xjTPy4bcc9N+BnQAbYyFkX0lVSyU7yvrVhr3m4BCCs43MZi58o8xl+n1Tf0sNykyVo+5CZGxsTTW/mP5bkq77dqmMHZf7p1zwPIxGOvDYzC2KTjXs2PRQhPGjxL/p+GSc9GdgR55rd69SZRFybKIh8S/uyerLi9/2V1kxqQ2tpJ39sxfj+IUBKnwNjADtggAbGI8KzLVXhKvcH6TZ12hTM3EOIpg0B9o7+RXroO2x5lfK2SWBbqZouweyh0B17Fco+WAJSUPKLiP5rjUnJUae6BxtzTcUF604zpeG999CbiLUl/C6Je5USx5ewFvCevEbgDXjmGy8knbP/Fues0fQ/MyNHf3aFeHOHsNZ5/D70D2HPAkXrDjNpaSE6ZUKE6wPKJljeUhFevgmnhOQ4NjGcBYBYNtnMG7ePZt7K35HoxFDsZvGa1wrPDYY4plRkuBpsZShuMKy9zzSJQY9rnGlD38yjOFB6hrHI+wjWd+eLSi+fxD3P0Wc+ixjmqhPIL5HJ45hPkEjlvPkt1VFXfqO1TuEdY+BW4PSgfXnvHrt24pWCmah4rzuaas4X6l0RZuM6PCoDnHcOTf2h6g3DF6XWPO1jjtl/y50sO1Ay+YyCLYKbVpaOzauymahk6asy1gXcDE4FpoK41zFoNGY8C5XjTRiX4expPrGGJfyc5CayOLpcVoTBxL4/iQgoxywqTb8D0zu58m3zFs+17x00RissbhEeplwlXWjDXbkzwOr17YxmrsMpO963PkcYypkp+lYZsz9nMgMvceOaM5zSOXdky0QzJcuXVJcv1WLt0Y0zhmfKfvKNOmZZPll+vEpHCHdC/M1YUU9YgiH3Vdd/Lv8ZiTMt/kWpbrB/GzXKsnj5EdgyErFd89ns+9g3O9hH1koJzr16HJPOI5Ke8/NlEh2bUI5uKz0/eWTJ/sC865QR7x71geWdbIpknWc9e+nB7HQFhuIkJeT5mxXSZJcmX6SkMOVKb9eNfwegFXlw2PwdimYAXwiSCoM58ltZQP6YT5puAufM7dKYysyGJJIJaxEyMXFlUU22iNatW7KCpH/I5QSuQZDc3gruVBno8uMmJlkLOf6ADEWm8o6xqlG0rlmGiP1WbKkyhF7VUUvZQ9qMqg7BRlZ6iwEMyyR8M8uAIajlGcF5r1RPl9zA6V3yTsoPU+j/oMuAfuFbR6Ba3vcxC0JZ4M8bqFvXMwj7xIh30Z7D3votjeAftojq2O8PuHPYFfI3YTuIELgh0thiWOcxzHWB7RUGE5pqGi5ZyWZWDCllgsUNFvjB1FJWzn7iZ7S8+5RGbM7y3mZfENXsEygjBw4eiBdkVBgWGKZsoi2NMu8GhTHMcopjh7SmtP4fyU9u4JnLe0L4GZgZlDcR+m+3BzzzdrrD/rGkr9EOUKFK/guAlm3y/AUwUc+t2j231NO9WsgNPay/MvKWkoMCww7KGoUW6OclPPii0rTOEwa6/GPyk8xl8p33caHK2OVGoTJO7xBWwIaxa9k7BVCpwK0idhxmEwYSGI4G7WQfXCig5a5VBOhVYaguXhJAkdy33h/AUKjgGYS4q0NWw3r1VyRHxvXSJchRl7DMa+pmGTm9OrDcTiZ8kcbGKoJIu1q8E3xhztAv5SlionxpF+TpmOMVZj09qyMZZkrE6AC+XKgb1oqKYS9mMslgQyqeCHdFOUgEWGnPG/iaEZ63dSQEWCtLRe4vnce8RrEYzlQFMK0GK9xmtpv0r7Rvxbsmvp+InXJOBKN5we628ReI6BuE1MXtoO8jm5tGNtkV7bdE7ml35+NcIYqL/Kcx4zY2/WMABhPqSmVf+ph1Bx/nxsqUbOqNv68ykBUvi7g4Ou/zvm5nGUQyopuvigzg9OiZtcz4pJcBdeRHVcTWB0lApuiaoX7tBtT6+oBkUAY4j9owhuiZWPegWqNni/wzl+X6oFFSVnRIdDxalSVDPlKbZD5UmrAwflEtQa1CNQDzH6hAPdMtV+bdpN45eWXXMet5Wn4O77aO9B+wDsSYk909hqPwCxI7xoxwGOQxz7NMxYQVBJbDnHcUbDWQBj593RhjVisAoArEYHMKZ7ZlFsOSB7hIRqHoz5z7Y7EtaeWfxubA7TOTL6XchqLNOw4XFJERgyheJaaPjrwDGu1djlfXBgHzW09yzqENwD34SLW6AXPvUNDWsD1z3RxKleslKPfL1z7Nt+cQCHE+/feKBoC8X5WjFplW9DLBMMBXM0Fd6vcY6y1veHdegTle9O09L3G7+rGqxp8QvfmtDHwoRAEfqhDrGDtKHfxg2dbd+/LXQTEB0gi5MUTnWTHbbLLYVO/VRLsuSyx2Hx+yO079hPQu57IDsVE4k2cT2uR0u/P74iczz6EV/2nsfhaxZys/6b0ubu2fU5286Nzdrn0kvAkbotyTRjYCyXdhegJPPaFVSlRuS2co6VeRPok9ckm7FtDzFZF9IdUQKvHKOWgtcIECRzkwMNEvABA9l2yXCkf0cVwphnfH5ubVH6TlEEJKofpsBWMlhy77GU5cr9vQ3kj7XxWF+T6cfu3TbJkAspUN4WxsbaZUM6sTL2/BTI5kDwpomiqwCrx2DszRhcEjOXhwIb/Zqs7pavwCpy6V8RdNnAYCUJlevZumB7BlYs7CoWvQKM8i0f3RU701VER6f6raL/VoAIFg06MBFxo+eJ8ps8q4i01mhVM1WWuYI9FdwUayiWgRU7BXUKal2i3AHglQst1zlnzj3gFeAuivtKs9zXfk+r29rvLXathekD4BjUl0G/SKmPebKoODDwDQV8Qxk0PizsNz5D90VovwDN56F9pGlentE+mNC6m1iew0vWPwPsB7GOm6xQPECxxnKPOkjYNzyiog4MWY1lCayBBq8iaFFUFLQBVrXB8dCG7YmjqR+NfX+mDYDMUtCgcEyoMVhWOKZYigDICvyGx2sMc1osjikamLBCsc8sCOHvBQC0j4c2FlsvaB/ex5WG5oUzVFuhNNhboG/AjafBHcB9BfdLv4bruQLmWF5oHrJSL4Ca+Lo31+AoUCqv+DZqTuDhsaau4BUsrwD7FCw4DG98DXgEtUWfPsLh0GegS5gZj7trfN+xCpaqCYitDAwZUBZ+t+rIjDntJwoGMigaZT19FScaNGLSIQ4kQ0BoCtowhsJkTMyRMMHRjTeBjnp4FoZr5rujh2aXCHFQDoBY/KaJF4YbSg8e+HgPsDdc2MaK5YzkXcHbV1qe9FyabtM9m9iZMSC2aT1YzniW90sDW7qm5db75Opum5Eu45hAiFxT5ZwbMFpSjj4FYlKsI92DrKqqwfm0/NJdUh5jHQADACXLlsrk5/Y7kyIhsb7atu0EMeI5WfcpMxbvjfmn7pxyO4AoTuKc6z5LIJC2cwqCt7FpaYxMl1y3lut3uaNk2XJ9fKyf5cbCpgmW3Pmcm+umcJWJm8gebsvjqm6Kb9Sgtyf56odf/dVf5W1vexuz2Yznn3+e3/md3xlN+y//5b/ke77ne7h+/TrXr1/nfe9734X0zjk+8pGP8PTTTzOfz3nf+97HH/zBH1y+YC45Di5dgEoiZtCbStJu7eNq+CkCMZf/OxqWcsi67p8Eh6pPGBPHU66P0bgMP40dz9AXSvWIsEsoZSe9U57B7/0UlcgNHXHWRVqFG0h7lDQY1jCIbRnotZnqxTuKGtQqxCVarZgqy0J7b8aF6pOZCliBO/fRnoNbKlxd4uwU3AwX2BrHFMcMG8pSh528KrwgR5VE7z6IiIoaTY0O9xtqihDLC7FiEo7yvE/f329ovIMfNd790T/XlyuWZY0NZbXUoRXaIKDhmIU490c7xbUT3NpgY52cg1t6hspUXhxzrvzarYXyopmF9y0EtQx1v/ZrBmfKJ54pXBTywO9LtwIqNLZblBTa2xrv5iZIL+OE0At+7ZyO/Uq1vo8p208oDPph37FV13e7QXGByeo6O0k+kTlLxlE/Ii5OYAyY5csGB5lvjj4oOd0jv2sYnNuQw25hcsX4Bguv2d8lNrNQm5irMfBzmZBjTHYxDqURniv/JgZhzFC+DDu16V3kPZuYk9RY3uX5m5iVXP6bJOfHolTVTBm1tBySTUo3t94UUyCZuuKl75QrV+7dxvrspph7p22AONdmuTaWx219YlNIWa1t/WQXZi439nLPTN9pl4mSbXlse89NDNlY/ldlxi4bXw/h686M/cZv/AYf+tCH+PjHP87zzz/Pxz72Md7//vfzuc99jtu3b19I/+lPf5oPfOADfNd3fRez2Yxf+IVf4C/9pb/E7/7u7/Lss88C8Iu/+Iv8s3/2z/jX//pf8/a3v51/8A/+Ae9///v5vd/7PWaz2eUKmAFknm0aXowMmQ3XPPARMc0zM2veh6GhJ2/rZ+iTCfMebSFnyaNbm9fgUP5mI27W4UvH9WyBCnhKOW/laowXQhBsA6i+MDrkoxo8RPCmt6Zh5ix74BUNVVgztvRLvFTY54u6xCsXHmK5huKIc2a8guIuirtoHijN6iAuYNLwtIGDBubHYO5AcQeKlyjNkicmNU8YeLaEZwu4voTiFeAM7IvQfgmaENvzgnZ9i5ZDLM/geArvmvgElj3OWbBCc0rLfRrWWB5QcU7DGS3HQcb+JICxFYZ1AGBLplg0FRNaCloKGiaBGfPwIjomSlc43Tk0tpRUKCwT1hhaJtRMqSmwtAFitQKEOby6ogZWAcgZCkpK9rgWXARXQIOlpOU+zp7Q3G9gvURNoHkqMJcv+mY9OIJnjzz2fmYCReO42z4CW3k/Rl6GSQM3noU9A/cUPOloCsWDz2vOcNxFcQtwFDzFIQUGF/dua85Rpx7e6DO/ddl0zzOptfN9xwJFgJa4ElwVBsRUdEnVx8CI6SA8Q2QincVZh9L9EjEbQA46oiHn3R+VZ8b8hEe3ffRwlCaTIN2wdv2S0+HXgEyZfDE4pIrPMISBHpO4rufE5HHbgOxU0OXCVQQ86q/kga+98Jr/XSJv8EQDOE0nDeMYthlumwwpyTqk96bpcs9I7x8DRWPvGQ3vXYQ20vfKvdMmsCTrNKaR5ciJPci8InCJoEYyZJJ9SoU7Uhl72Y7OuYFYR0wfJfAlUxTLHcsowdVkMkFrzWQyGQA0WS/yuZERk8+JbNx6vb4ABCMrF58vZf6hl/iXdRv7BzB4l6IocM4NNtSOIhllWXbljPWWa9+YJpZF9oecamWOHUv7wC7Gf5qP3Cg7B8rTfpwT4dgEUHNhDJTlJj3S+2Ta9L3SfOUec/G+tK6vCpCuAq5eL2Ds686M/fIv/zI/9mM/xo/8yI/wLd/yLXz84x9nsVjwiU98Ipv+3/27f8ff+lt/i3e961188zd/M//qX/0rrLV86lOfAnzFf+xjH+Pv//2/z/d93/fxrd/6rfybf/NvePHFF/lP/+k/Xa5wbmhIDQ0ulxz7fcEc7LRf0CYglvtrMLsv/lbuYhmBpIT04ElO5YeUcmY/sgcqmLMqfFLy5gGTEG+04FofaVABLJTQbfhcQtwHuls3RmPATQJz42NNwTlemP0cxblSNBMFe9r7re0JaUZ9DuoM9ClaL1nolgPjjfkDBXML6hyvxn4CNsT2FL9WrJ1jOaCXr9/DhQ2na4qO1VnSdnEVYs9CEaJijWGNoaJgHVivNVMRZ6xG4poZa6bhc0w/YU0Z8iqo0EHuP7KGLkTLOpRriQ1ldaxQgZGKjNgC173nPtbtYVcFragbd+LrizOYVD2YPtCwbxylrrwUpj4Ldb/0Fb2nfOI9jZ0p1lr59kNxDqzRWCaelSO0eVtCraAK/aKGwgbCRfUMmaYFFyi0wLz2dFTs/BKe9P1WhX4c0cwogxXzymh/yOQDJozhRZV8zmGr3JlBkA8USZ3qN2+Xe9VdYMBFTVwamT1mxl7bv0tsNjCuOkO8yVjalRnYBnZy5cyly6Udy1MafptA4K5lzIGxXD2maTcxMzlBkZwbZI7ZSo1v+VmmH1sjFoN0TYyAbDqddnE2mzGbzQaf0xivxXvivm0RcOaMcOnOmBMlGWMBxxi1tM1SQDzmJphzY83Vf66vpe19lbCJIZNlyN23S7pc3tvSbypjGnL9P017GZbqKiBpl/wv+733WglfV2asqio++9nP8uEPf7g7p7Xmfe97H5/5zGd2yuP8/Jy6rrlx4wYAf/Inf8JLL73E+973vi7NtWvXeP755/nMZz7DX//rf/1CHuv1mvV63f19fHycf1g3O+0CO9ZzZJEZGxhEeStshBEbSzx49MAtcZDa9QfFSPaRPYgy3p2l1hdI+ZfBEwWRXdCdMp0O66D6xI6wM7Q3lF2Dcg3aWQrnuh3DytbL2ZsK9BrUCqg1NApsGUDCnJYpjpJzDCcozrSimSncVOOuGTjScOhgtobpCopT0McU5pxJ0bBvGq4FoYkj7eO8AXXsN3i296G9D+2xwS4ntOs9rL2GC3L6lkMcBzTMaJlyjuKElhMaTgMzdk7DMoh4LPGkwDmGBs2SCaugHLhkTouhCts0W1VgdYlTGqc9M4bCr3EK7AvOoVyLci3aNhhbooIgR0FDg6FFUYSNnYqwtoywMrCgZYJlit/suEAxC6vFZpQoDIY9DIdBZuQ6yhna+gDlTmhPG9r7FSgv+6/mMD2AIwVL7et1DRwULXuto2FFZU5wagqTc0+p7Wm/u3cF9lCj1o7VWnFSwwLNijI4XM5QzMFNoSlQtYN1i1oHEY/GK+dPXehDzru8WmexrgGnQ58z9Auj/AiIEwkmrHOEsCah66tiPkL6+Dr6CQutEsTmx4mch5BjL36OY3C3n2yJtAavMDwfMwyfnYstrrp/bjgdlH3ETuEq4OoNxIy9Vn6XYLffppzRJdmcTQZeGi4z054LYwZaej2dZc/NuG96hmTGcmu8xtiDTe93WSM2liN115PMWAQ/qbx+DrRIoCIBiwQJEpjIzZxTJi2WW4KU2WyGMYbZbNaBqHhOMmOpy2HMSz6zLEuapumAWNx8ObJzkc1Kyx/Xd0mVwbTuZdljvQDdMQVV8j3lVgFyPZdcQyZZuvSZaZ+Rbb0NRO0CBGSfkeWS6pMxv21jQvbxeD1X5jR9mm4sbGLLZBnlMZ5P6z63PmzXcqTPfKMyY19XMPbKK6/Qti1PPvnk4PyTTz7J7//+7++Ux0/8xE/wzDPPdD9yL730UpdHmme8loaPfvSj/MzP/MzmBw1spuiWaIMRJO2o4BKo8MBHGnPS2LqA2rYHSWipSE4NHz4AYi69USvhzjUsjMRmfilO5BKiSetF1pX4RwAPuMb7ZNkGXI12LaWzTAIYm+HXHcV1W90Sr7WG2u+e5QIbVTOlZcIZhkfAiVE0+wY7DwjrpoGjGuYrmJ6DOQH1kLI4Y7+oOTQt1wu4UfikNxQULeiH4O55Sfv2FWgeFrTLBbbex3Idyw1sUFJs2aNmTsOUM2oe0nBGzTE1FZYTGlZYzoEz/Pqwcwrq4Jq4YkpDyTl7tBjWzKmZgC5wZQlKQ2HofOVUpF9CfTYtWAttg7Jei7HGYGiYUtCiKWgggC+osUFO39BSoQJw8+1aopmjOWASFBj38dtVO+AGigJbH9LWj9AnK9p7NTiHvQdqBrMn/Hq/SnmFylrBNWPZLywrtaJuH+F0CerMq1seTOHmBBqFu2awa1geKx7VqgNjBZYyyNxjZyhboCqLWlnU0kvcF7VnxKbO96GJg8I5Wttibe39C20DtvATAmGGoufE/D/Xic84nPWbQ8ch4MdR5I7jDIcKqooIQOa6AXUBjA0GW34sbh7XChfbPx3Tg4R+0PvLwY0GX37VvUXvqngJRDgMV3FTrK7wnNdoeK38LsGOv00iSMM5ZyzGMGaobUs3FsaA1WVB1jZWbIxpGluztCsYG2NL5PNzhnUOiMWyxOMmMBZBigRgkkGSYAaGyokR8DRNQ13XA7EOWb747NlsRlEUzOdzZrMZZVkyn8+zYEy2VQrGnHOdm+J6ve6AmVKKuq47IzsCRVn+GKLIg3RbTAGZdA11rnd5jHuYSVCW7u8lgZzMMwJCqfJ4mXFwWSAmo7w39g2pFJkCMXluF2Ak06WfZT2m53IhB8bHgFAKxORnWe/y2mUmeGR4I4Oxr7ub4lcSfv7nf55f//Vf5z/+x/94JZ/7GD784Q/z6NGjLn7xi18EBPgJ/cYBThpDiWvQEIjF3MXNDBJ3QKwHNxcvy240MALDxQFAy6UbfBCJ5c3xkhMkQXjZIfhKBpDMK4BTnEU5i3b98rQC0FHxXoh34Ayqk/eIwh2aOkCFCkWtwZXKa5xPFcy0p0vCxtLoNeg1RjVMlesk9GdAaf2WZ6oCtwK7Arv00dUG66bBdW8q4gQbVif14hz9sQ58Uh8VDZqGgiYR6GhUSasn2KLETQrctIBp4aUCZ8YrYcxCnId3i9dmBqb+HleWtGZCq32evchHEUQ9dCiHCuIhrtuPbCg04oU+vKzKhM5NMETLFNuW2JXq6ynIQ5rGg9opvn6nYe+4UlnRDsHvtLD9XgZThZsqGqMGrpxez9HgnVhjHzCoVglhF99fDCK6uA1zFIpx4pgGlfnHiHuiiIjBhMveEMerFO0YF/AQrsLIcd0/VKUXR8sY7ok/lF10yVN2A4KPw6sfXq3fJRj/bYohBxy2GSybwMZXYjRJAy73+ap5yTKm1zcxfLn7di17mtc2w3xM1THnHpfmn7JekknKxTSdjGkZJTMXXRMjK5YKc4y5+ckoBT9yoh+TySSbn6zHtNzb3jf33rsA6rH2kNc2tflYH0kBz1j/25RHrh/lwi59fFP63N/b8siFbWzftvseh+3h68qM3bp1C2MMd+7cGZy/c+cOTz311MZ7f+mXfomf//mf57d+67f41m/91u58vO/OnTs8/fTTgzzf9a53ZfOK/s9bQySDIDGt6I23uHeXNOxk0iRKENVvLxv/7uFeB7BU/zgt8x0UUuTj/bD6B12Yzg8/uvGyC9uFOTCBFZPrbrpMpPXoWs9MOA9hDK13T3RC9DBuDbXyy4v0SqGaCTBHeYkPLAvOMayARygeojk1hvbQwGFgxW4aOLRQnPjdm81D0A+ZledcL1y3t9hNA/s1TGpwx54Ns69AczfEkxmNvYnjkJYb9G6KB9SUHONY0/AoMGJRyr7CcYYLa8h0x4idhfVlZ+yxZEGrS6pyD6cL7HziJdgnGqbG95GS4V5vkRlxeLawdV69Yj3Btpb1eYFqGppmQt0UAS56UYvIzrZYDE2AtS1t6FFlUHXcC0dHSckBfhe06ygMLTdxLFGr+zT3HuFaX2dq6lnF4hRmBVyfQKP7OtZUPLSPsM4AD0Fdh0UBN69BqzybWcHq3PDwkWaB4zj0U8OMgn1gH8UCZTVq3aCXtmNPjcek1KEfTQGcpXI1fv+wGu+m2A4HUwe+/DXP7IK2noXS2pO5wtwbDqRkUkVlY+YHUtzezcO49Oowz+4vF8CULErsG5E9Vapj7Zz2mQ/zF18sF564Y7iKm+IbaM3Ya+V3CS7x25QJY0bTGPuUm8nflPeYkTVm/L0aRtkY8BljtHZlw3Ky55vebcw9cYwZk8qFUvwht94rt+5LMmjxemTDoptiTBOfHV0TIwt2cHBAWZYsFgum0ylFUTCdTgduc2PMinOuY8ycc5RlibWWyWTCZDKhaRqMMdR13eUXWbFU/j66KabS8LFe0r4TXS8jMza2kXJ0PUxZpxwgkWnT524D/rKfpGEbCyv7cGQHI3sk3YpzTFn6nLSsm1ix3HulZR7r8znWS9blpvKldZKGyzJkj5mxr1KYTCZ8x3d8R7fIGegWPb/3ve8dve8Xf/EX+bmf+zk++clP8u53v3tw7e1vfztPPfXUIM/j42P+5//8nxvzzIXBbHU2pAacEkdhxYk8BsZcYvvJR7n0oYqsKEiKsdTwlgu5DhKM2J/ymkqt0pRKG6BLz1bE7aENYV9owjK1qEreaS/oYCx7ZsQFF7wazzrVeMPflapXAJkoz4xFFRDtGTKtWiYqbBKsvG1YtP0G064Ct/bRrsHWumOH6FiiEkeJxQRmzHVsWB3cAGPsJUo0LaZjxmJsVYnVJdYUHohNCw/EplrI86serc4Zno/U08TAxOCKAmtKGl3SEGNUaDSd/qJnyCJrZ2lE+XtmTOF6aZXu/S1TXFv4+onR69GjajAt3QbeU+WxZaksqtvFuxYJh23Wmij330v/WyQzGpgxqzpGTIU9xGM/klqeQ2ZsbIBGyCS4Z0eeGO66cWZQXsi1Z7Jzo0Opi/dKBkuei/nFE4PvhguvJid6ku+Xsde/SniTC3i81n+XZNhmYMWQA0fbXJ/S9Luwbum9m2bpN+W3C7uXM+R2Me7G7tuF8Uiv5Qz1MZYmzXMb8yNDjlHKKSzKMqbrqGSUrFjq8pd79/SdcuxYun/aNqGSsXfP1c2mmJYxx35ti5v6xqZ2vmrY9dm7MrxfybvJZ42Bu/T6psmNXZ4l87xMuEy/uOz31dc7fN2l7T/0oQ/xwz/8w7z73e/mPe95Dx/72Mc4OzvjR37kRwD4oR/6IZ599lk++tGPAvALv/ALfOQjH+Hf//t/z9ve9rbO335/f5/9/X2UUvz4j/84//Af/kO+8Ru/sZMQfuaZZ/j+7//+S5cvTkxnT0ara2AcqSHKSsFO8CSI/SOaiyJTwYeNlCVFbl0+kV2Lotf4jWmz42LEiBVsXc49sbMRFWINmh1EpSyF8uuMoj1eDPeDRq0Vqi0hiDgoj0aoMKxQLNEs0ay1xs5Vr6J4oGDe9tr46gTUCRO94kDDoYZD5eOkAnfimTH7CNoQ7SOwVYlzB7gg2OHYx7HAMqNBBTVCl6gn+n271p2SYckqKD+umPt9wsyCWi9wkxK3N4Uy7F48Cwhx0XpkOg3HGB1BY11BZbywSaXgXHm1STOBymKXHsw4W7NqGxpXhO2kHY6GMmz8vAptWwZVRYfjnAaCfIelQFPhVRUtlgM0h9j6FHvsW90+BLvn68sdg57D3swXK9b1UjcodQq68Lt4u1OYHPq9pc99u7mFoy5016YrNNOgqohoe+UsqtK+fwRsp4FyEjB46FONcihlcRGtKevrMOy+0LsSy/HRjzQ5hLpOfeHExTCEdv25sa9619/kmazuvBvkMchHAMXRksTvmm5d2yDzC2Uef6ORcJU1Y+Ul07/Gw2v9d2lbyBlGm2avYXwT1m2G1S7X4wy6fO4uBls6G39Zg3ibkbqLob4NaO0CxHJAR4KQnLpgznUvFfqQ6eVzo7vgbDZjPp8zmUzY29vr1oxFSfvICuVcJXP1Lhk0pVQnlhGZpsjQgWewJCuWGvKR8UrLIftGLJNS6sK75/pSfP+0PuTfuXbKXU/z/Ur6z1h/fzWAncxLfh4DIbJud8kzZbl2ef5YGTaVa5fwRmbGrgTGVqsVv/Irv8Jv//Zv8/LLL1/4Ev9f/+t/7ZzXD/7gD3L37l0+8pGP8NJLL/Gud72LT37yk91C5y984QsDWv+f//N/TlVV/MAP/MAgn5/6qZ/ip3/6pwH4e3/v73F2dsbf/Jt/k4cPH/Ld3/3dfPKTn7zyHmNZgyadCu9mrOPJPNCJx7GhlwViKolJEEOwm68flGATeTBSnihtnwNiVuFdpDr5bwnGWrTykgmF6jd71ha/DijK2td44YVuWt2v12owQbbdx0prXGST5sozSFPrVfvUEtQ56HNKVbGnHQvlMdsCKCpwZz7a0xDPfHRtgXNe4j0qOUa59QbHmjUrrJCvt4EpI6xp01SYbv3Wmqlfx6VntMUMJgUsJlBqD0xm+E3WFi0YC7PaH5UEYwFJrAuoC6i03+8q1lXhXdLaClxrqNoKi6GipqBFATUawibUBhf2H/PXVlg0ipoybLw8RTPzjcICWOCaKfZMoYyoqxC18ur1lep3F5jqFqVXfrdoFTaBLuu+rcIG0G0R2hMd1gPqrgwwQTHFuRrVKN83Qh/Rul9RGAG+jpvhDSKglRdYZMiZ9UN12J/zYzBBZoMJj36aI46z+L/rE/VH5Sdd5NBzIf/hnmVxGmVYhDin49QgWfichXL5cNnfotexm+Kr9dv0mv5d4qKBsWlG/zL5pQb4ZZ4/Zmxetiy7hE3l22Y0p+XZZmjn0mwDWtvAm6zvMbZrjDnLAbgYImsl13BFN8XpdDpYMybrIuaVuhTGd5GAKQVhEXRZaztlxQig1us1SqnOpTJ9H+hdNYFuL7EIjtJ3j6BMqiPKkLaLdINM22Zb223qI/LaWHvv0vdz6WXf2GXMjIG9MTCUC+mzZFnSe3IA+DLA7zJgMFfOx2BMhB/90R/lv/23/8YP/MAP8J73vOcr/pL94Ac/yAc/+MHstU9/+tODv//0T/90a35KKX72Z3+Wn/3Zn/2KyjUwjnLtGYHYILVMHDptBHWu/xxnysXEeZ6BC+DOpT6NmfJE0zCae/3suyjjBRZAhKRs8i1cmM+34YhSwgeRnuEJL6m088RZSKYdQ/ezFlQQ8JDRomlRwZNReeAXPRnjhlOmpd9c2vsgaprehQ4fTeOTuFWIa3C1wVmNc9I9cYJfZaWF+IWPvWsiXZn6LZlNcBMsOtdBa4RL4kz58s4tzB3MGtgLIGxe+ffQ1kenwBqPdIvSg7GiABf24Kq1r/NG+bxrR9OUuJbAh9W0WFoMGkUryi3dK+sA1DxYUxhKlBDywE1wtsS1Dle1uJXDrYAVqIlXNIz1O8Uzb8oJP1DW3oW0cIHK8m1nNcK1U4XtEQp0AIaKAuUKsMoLeLT4/cBsv7ROh26nZH+LSjHRL1Yrv1UAcT8uD3+0hD/bJicy46EHYkNmTCbr/o4gLCaKu0snz03H/2BYivtV/OzSVCr8Gc531NrwAVug2hsqvJq/Ta/V3yUZUlecMbAR0+buT8u46e94T84Q3ZRuk0G3Sxulz9zmgpQzuMcM77F7N0V575jrVprn2HttcqvaBMpyrmJSZTIV2JBKg9GAjvlEdcQoTZ8DYxF0RSYp3dw6rimLz40S+MAAtMl32wZAx9o8l2ZTX9vG6Mj+sqnfpu051j82rWWMZUqPKXu4aVzE9kuBUFpfm8q+S9iUNvd8eU/ufCoy83oBSl+LcCUw9l/+y3/hv/7X/8pf+At/4dUuz2sqRDtnYMRdTBEsxOSSG1peSsSUcYufI+AZzISb/hkO17lg5S2sCL3URaOxu3EkpCBRADK/OsfR4ndVswpPUZTaG93Gepk7Y6GwKOMw2osvlDqwGQ5vZHfLixTKFsFhbYZhhmJGS9ExJ2sUtdK4iRquryob4DxQNqfAKRNq9pULchB+6+bJGtwx3UbP7kTh1hNcU+I3Po4pFzjmYaNpxxLbsWIrwYp5FUBFFUQ7aiZUTMOmzl6+3k1mnhGbB3/JCXDUeEZsvob9lVczWYSjsT5aBW0AY8sZrCewKmEy926LLvjqUUCrsWtDta7RbRE4uTawXhXQUoX9xzxk9TB6JRiycxwTFCUzFBbPjO3j3B6uXeBqjT1dYo9b7+p5AqaAhfX9YV9Fwq9BcYZHHGGXaFPBzA3WwDWFYo3q2jYKiehOlmMKbo2uNc7QsaeqCDhceZLQaNCxrxH7nev7Y+OrUIV+60VMOjppiGd2Gg+qGxQpCBtCqYu39eM0pLOq2w7NuYvjPw3KheRK/rDJGR35RREzTL4grvJbFyc9LnvPayC8WX6bIA8Cthmm8r6xsM1YG3tGaghKg/Ey+Y+FlC0ZAzDRII4AIJWUzykcxvtywG0XwZCcUR1d8MaA6DZwld6TY8fkOiupnCg3cp7P5x0zFsEYeEaqqiqstZyfn9M0TbevnWSr4vvKfckWi0UH8OT1oigG963Xa7TW3XPic+MxGujyc7xX1lWubjcB8jFANtZXIthM00RwtolBk30i5iHFXGIeY+VJ1/tdFqBcdqznWLhd8s+FMSAY/5bfSzkAetnwmBlLwrPPPsvBwcGrXZbXXoigyQVsFc9Fo2f0Hje8P4kbHtU/oLtBGlrjdpZ0UHTJucG0+479Ur7uIMoXkaoKio4ZU8p1+FTFy2lGYS8zFdQaCUcX+IcuWcygiy7QbFGmogXnuRYpBVGAX58Xk9XgGsDGfae8YEQQ3gdMgCy9ER8/x610e8kIFdL6vFzYg83qgBYKLQrivMZ+2fo4rT0Im1VeYcQEt0Wn/Nowqz1DhvLn1q2viNJ6NZMi1LtROGVCuUyIOkTbSan48srye/GR+HcvtRLrw0fnjFdD7JRUfDROvJqKtebbwMfQJpK5UrHZlegCvmFV4Oe6Bu7Rf4c7lBrGrq/ZmICeOovZBADjckCJnYdBuEGO2n6911geEb8NB7sS4xlwbpBkkDR+fYRbBr8low/OXLhQhh3D63jN2Jvlt2nbTP+2+3JG1Db2Jk2Tu2/bbH7M7ysFZPGzPMrnSEN5jBXLlS29fxs7lpYtHtOybarbXd97ExCJ+adueikITQGkdE2s65q6rjtmLLoVSkAh14bFPNMyyGfG9NtUKi9rZF8mfY512tSnU8C1Szp5bpNwSPr8HNjcNYz14zHgl96361jaFFKwNTbx8moBosdgLAn/5J/8E37iJ36Cj3/847z1rW99tcv02gm2N4YUPVt0wcgZTFQLIBbBWLARO+PSyVvVRSOxkzxX3vrtMvefbTRQ5WPDp/gvAoZhAd0gHxlyhmoklL37m6VR9Db7JCr9RaBBb9MXfq2P1sK9zNEpKUY3NOW8m5oXX/c8jQugog3uihZwxgYAElgk1XiZP7VE2RVarZk4x5y48gkWDsqKjkDjHFgqXDsJKbxwhBPMTIsJDJjtXPqaTkWxd1FsgoB8Q0nNhEZNsMUE9CTsI6a9W+Je69e3Haxgr4K9JRyd+Po6XMKk9YCsDMxYZaDVcLqG5QTOw1qSqvBuigYPyFYalIGJ18dvmwmNrUM5CxTQ0oSyEzaD9u9ToDplRY3CN5wNdRBlHRce7K9XuPMGF+pQz/2yNyfqeYbF2Art1ti4kZuqQlvRsaVO926eETT6dvc0jAtH1eq+fwg1xc5VUYOOYh0u9DdHUIox/iGlghZs42isHUBAuZZs81e046J8aVx11k99uO7ouskDC35NZbjWxQjGXPiBcPKrpB+5ogR9lJMvSqYQZZQvFb97ku+bncLreM3Ym+a3iaEBdBlwM8ak7ereJY3OXN7y8zaglhqEuwLJlEmR921SEUyBSbrXVArktsnnx3JE4JKrv23G4LZ0uwIx+c5Rcj5G+e4RgFVV1TFiJycnrNdrqqpitVp1YCzWZ2Tdqqrq1nXNZrNOGl/G+Pwofa+UYjKZDAQ70raUm0DnAE6uH2wLKfsk19mNsWSxbDJuW1sW+xvQraWTrpqRLcsB4RzDedkwxkyPpc3Vp5TV33ZPDkTGdNsmH9I8rwKs3qhg7ErS9u9+97tZrVa84x3v4ODggBs3bgziGyYE40ZirPRaj85cbzG5/oYI4qQEfYzSkOpXt8QEAcEpOePvXRgvqsVdNBqlydixLLFcI30zBWSOnqTo1t9063NUHwUjgfasGFqwGfR1qETGPTPWR8mMWYI9HEUutKPbPZoGbNzquMUEOQi/+its49WCq/CsWNRUtwYV1igR1qlFhOnQtIE5agWbdLEuIgPl14xZDGjj/TJN8MssCYyYhUkD08qzYYs17K1gP7gsHqz7GM8t1t6Ncbb2901qD9xKF/JVnn0zBqcNTvlytOEdHDpsMKBEuV0XW3qXU9exYQVKbsDsCr8+rdeiR8WlYKKOIzOmXINyNdjIjNkBO+ZUZOpUVzbPjBV9+0f1jSTG4aAUYb0YKLmreERqReyP/lxQye9G1m4gTA6GOFbieOo/90ENxgwwdFGUC9469VH5kP7OwfeDS2J3ixMx+XtQ9pHvrV3C11Da/ld/9Vd529vexmw24/nnn+d3fud3rpZRCG+a36YQxmaiYxibhR+7ZxdglwMsKZDZNMOe+3xZA3vb5r8pQ5RzTbwKG5YzeNM6zrkcXtYgHAOuY22ZAoOce6ZsmwhMIhu2Xq9ZrVasVqvOVVHG9Hxk0KQoR64MKUuWA/Dy3dLP6fvtWp9j4DW3Pi2tc9l/cuArbZ9tAF6Kn2wq22Xea6w8Y+N/00TDtjG/aRyMtdmm75xtEzS7vP9l41XCZX6bfu3Xfu1C/VxWmOlKzNgHPvABXnjhBf7RP/pHPPnkk5eu0NdLiIaRE0AKMvZNMkEdjbgLZluwTbfeLoFY9NPqGC0/C69CAaNNpoQpJ+fYLzhUbemXnWmo4kDzpqzF9S6DEYSVJvVu6wzhHCCTqEZZ5Y3vzlWt31TaJ1ODsngUFxb/uhZsDbrBWL8+rXAeq0idDx3dFAWg8C6Aw72tYsF7N8WhW1/vNaeT6F0UrfKgyEv/KeGe2HoQNa18nK89Q1ZUUD7ya6tURIray9crA7ND0Atf1vPKv/uk8W6MpYLChDbQYByuNT4GgGix4V3694mgbOh+2TUoagDISi+m0aoBkFWNqF83jAVQuxYXAZkLbaX6PiQ6OBGpKNH+oH2/kG6K8Q4lhkFf7P5YBIBaut6NswXb+p5kw5jJTThsHAyixOkoG/TR9BaFB1/yW0DOTIjC+D/Fxu6ZoiS3jJdXArHh03cPJrjPXvaeS4bf+I3f4EMf+hAf//jHef755/nYxz7G+9//fj73uc9x+/btS+cHb6LfJmFYX4YZ22aAxjQpW5UagCkzFtOMAZDIMKRluUrYZMRKQzMFAWMsV67u0vfcBMgksyDbZZMhuOndN5Urd2/ahikYSt9XuiZWVdUBq/hZStGn7xDZq6iSGNUT5WbXKSCTmyvLcuTqYJvxnkufsk656+mebKnKag5sxHcdK0OaNvZxyaaNgZ6rgIZtkymb2CuZNh2HKajLjfVNdZCO8xwgTNOPTdpsC18rZuwqv02Hh4d87nOf6/6+7G/PlcDYf//v/53PfOYzfNu3fdtVbn/dhFTAMBpk3enYyCpMhQ8Wlw3txoFZNugb0UgMsKlLqPpZdXpA5pwDK0FYzKU3ErMWn3yuY3izTKXo1rzYUPZevMPhojxiqYWAhxoCsmgkp7aoI6rfB2bMG+I6xMHaoa6Ygh4g+Mi5GqzfQrhwlsJ5lb8J/VEyY5Edo1Yoa4hwrQMegpWLa6p6dqwHLn3smTGLwVF4ZqwwARDgQcGk9azWrIJ5YLz2V1CsobwPegks8XKFBZgFmBIW2ismOgVnE19p0zqAMdMjIuNdF50qQlmKDiTaBFzGd4qALL5bD8R6VqxjyGrtRStDHarGv5alr+NJBGTW0doGa6uA3qJxHuT71RAAuQEQi6qaYtPn2ORyLiKC+9jHwPc9qwIb6VUmI0Pm2TifiQl9yameJRsN2QSSadahJvvO3bFvYfy4buyG6FT4u88vjn1IhopjOHTVYBiJH5eQMPMym4DdayX88i//Mj/2Yz/W7d318Y9/nN/8zd/kE5/4BD/5kz95pTzfNL9NmZl5GaRBFf/exqikBlkKxHLp5XOli5kESWNGnEwnyz3GCqV/S/e2tGw5diYHCNJn5QzyMaZE1muqPLiLkX0Zw3Ibg5ICIBmlaAfQrfmqqmrgmrher7u1YzKkLmxN0zCZeCo8gjHnXKecmLJzzrmNYGwXdmiXPpGrKwnExrYPkM+QYEX2522ARK6pAy60QbpuLgWGY5Mku4RcHx5Ll4IxOUki+3Euv21l2jbmL5PX1ztc5bdJKcVTTz115WdeyU3xm7/5m1kul1d+6OstqOSTGjNxOhvJpZbnwNVoJ0MptdsgWKX5R27LYpeQs0EHLl4pzpMz/YnFKI3HbNm6GfzUHO3Lki9diM5HRacRcTEKg77zN+wga+6O+Nzkh39Y8u7osw7qlyrz8gP5dTtUneykJWs6xKOCUoZufbqBa6YApYP+kDKJch1T2gIuU6+y3hPwkFR57MedXktae85djNl67MeREs8frG1yMuWwm6VFHfZF1X3uwDzDNoxLwXYzg64a1OCQG7vb7u7uyLTDLjlIx8rLheqKEY6PjwdxvV7nn1BVfPazn+V973tfd05rzfve9z4+85nPXLrEMbzpfpsu2a/GjNB43GYs5dKMsUbymbn7N5Vxl/JvAia7gK1dw2WMUFnGy+Y99vkqZdzWHjnGaFu5x9icMfCUPv/VNsQv049yfWUX0HfVNhljlbYxeFcN29paptulPLn8x56zK7O3S17bwqY+uK1/frV/m05PT3nrW9/Kc889x/d93/fxu7/7u5d6tyuBsZ//+Z/n7/ydv8OnP/1p7t27d+El30ghxUTbgVh6YphmJyAmH9i5Kw7vzNitF24FaZLtHnqbz134PDB4O3UOLlrmIUpgJA36i6WMTMnFGuoghHNgIy1owVmUcwOxRem51u1tFvar6hehSQnIvvBO1K3r/sk6iUCnT++j9ntbDVQfodtDLLp9lUHQo2wCK3bmowoxfi7CGrEo8BHv1wHMpc9RfTniOw3LLW14yQzJxrpQ+I6MlHsrX0zV40Y1AGKhnYa9JwFk/rmjoGzsuz2HoxV0ijEZQBZdbdOsd/352zRuR/OKAF1OWgzQ6+7PGH3olnD50Q9fCRh77rnnuHbtWhc/+tGPZp/wyiuv0LZtt4lyDE8++SQvvfTSFcrsw5vqt+mShuImY+myRvM2UPOVGpfbwiZmI8dupet2YvptYRMDmQOEuwCVNK9dwGP67rky5ljLXN6SkWnbdhA3Aeex+1K3v1x5UiZ1V6ZrG8jctd9L1idtl01ttOszxvpe2h5pmXYty6bnXjbsOoki06TP2gaktr3HVwLIrwLE4Kv72/TOd76TT3ziE/zn//yf+bf/9t9ireW7vuu7+NKXvrTze13JTfEv/+W/DMBf/It/8UIHU0oNNvZ7owTFrvbPhh+8V6ks8kk7zmtwFR6gz1/c2xmTaniO0T83lsofL0Le+NRsqeUPRhKzz88yCvm7ttdSz0ANntSB1Pi3oHYG6i0BuVjvMNg7D4qo7DB9rqjd554J68s/Yu3vFMR9EThLIM3FOAzjFI4s54VnjZ7Zcj3X6KFglwVc28Kmsn21nqFGB7n7KlJ7ka297D3wxS9+kcPDw+7sdDp99Yq1Q3hT/jap1+fmqRIcXCbskn7MyLwMEzAGdr8a5X21whjrsKvhvK2suzCTu5QxvWcMYG47t+n8LmXbxOrF74zLvN9VgeLXc/xedlJiU4jv8Wqxn7n8rzr+vpq/Te9973t573vf2/39Xd/1Xfy5P/fn+Bf/4l/wcz/3czvlcSUw9tu//dtXue11HSSzsHlaWw3AwiAP1dvoO3Wn7qGCUrvg7LU9i8tabb2hrcQxQKbAlmAFC5LohcciD8ohrPfeTaznaiJfI7k4WQ4H9IxHrwySwJhB1CHpgMbp8pcp81xRChNjqVUuOufrJGZnVYjab+bcai9LX2uwBegZqEZUSAHMwU3Alv6+Rvv7YuzyFMW2sZ6kfqJ0VtyM5S6CJ1Efml49M3yWNdfByPAKrmsbEcPKtCHEvvjcvv1FyHRwd/FWUezYH52ol74fx/aMI/gyoyI+JjfmRqGvo0ezqdvnSPKYX3dOjSUXwH/DizguOqtuDz3Tdbl7/CJm+YM3Fm7duoUxhjt37gzO37lz5yvyu39T/jbtaKBsMizlOo9djZ1NhtcuRuxVjdBNM/qb3O8uw0LkAEeso02M1iZGKs1/22f53F3DLgxBytrI9VwpgySDZLlSUZQcWB0rQ+6dcsxRrm7G6mcbs7ON4Rl7zq71n3vnsbVpuXJ9LSdU0rG+7R1z43zsnsuAtqsAtq8EjH0tf5vKsuTbv/3b+cM//MOdy3klN8Xv/d7v5fnnn2c+n3NycsKjR48G8Y0UkqG/yZbqgxpnJuT9G/NJE0VDMz5CHHNPEl8tV55AV8n/PUsijN7Utg6fnTjmnt9v4SQN8m5h1whnEsFYD8icUgN8MoBXKgAICSou7D4twZ8bPCut49SRsQM/KSCVBbDKqxJaAcYa7UFXt8fZTMQptEFWvglAzuoe2GVwk4pflh2ATd9H1uLA1B+Jfo1a9Ojs6i+HBUXs+r0ScdB+CdAIOXSgPIJ0JdMMSzpe9Ngf+07nJz7khEJaF7tNaKSP3T2lG5Zxx4x2+n7YWvD+oZcf/1d3U9w1TCYTvuM7voNPfepT3TlrLZ/61KcGM4yXDW+q36YrAplN+W0zQnPXNxmcr3bYBsRyZdwETHYJObCUY50uw+bI8qWft4VN773pPWXZd9lDLRdk+lQyf9M7vpoM0K555UDXNtZqV7D+/7P3b7G2LOdZN/6r6u4xxhzzuA577VN8dj7xj5RgFCvmBikCE4crIkiUcGMTiVwgmYP2BcQJOBiCnASUWIiQSKBIIYKQCxAXBCUIky2BsIgUhAgfST5i4viw91p7neZpnLq76v1fVFWPd9TsHnPO5W17H1Yt9eoxu+vU1VVjvE89bz11Wb36wN1VQdl1y7wsbAPKl+XR1x6vF2h8kny2jenXa7y/Hr9Nzjl++7d/m+eff/7K5T4RM/Zrv/ZrfPSjH+XBgwcX7r0VXUE27an0Kc5Mb7jrmTVgMj1pta0v6X6P0MKGBbpZut7E9aKpu1njC/luQXAd4Ij5azZlvarHYLwgHnCyPjqmjA1LPav6mgQy6XPixJKYfPasRFO6u2SAAsz68MYEZz/Dxrklqp2vt9EKi5tM0LuXHr1E2Fx/Zi4cmg3b1FdEfHA9dHZdkdYGBcS2hLqCuoVVCW4EZjfsS2ZHYCahgn4SWLN6Ak0V4tYlNGXMJ7FlRFoqlim+2yJb7+RFV+duFVj2PlNf0S6T6ihkQyFTinXbdmezPsTYoCopWhVTrSXozusd0PT7B0GSGotd95Vu7KQ+dQEJRiDW9Ufp+qN+7q5PdWNvSzB5hDCeNsXsN/sqm9E3K94Bs/QdIf3Rszpc3FOwe4oc2V7IT8d+I4aXXnqJj33sY3zwgx/kO77jO/jMZz7DbDbrFKyeJLztfpsyg2PINU3PvF9lhlvfH7o2dG8bKLuu8XhZvKG1OPmGuttU9IaerQ8spXbM27LPqL7sOS4DMdvib2ME+w6gU/rTjFhVVYhIt0lx37OnsvTeZXoTbQ3KUvrL2n5bH7mMSdwWr6+dLjvyMq5r2Ot7+ln7nj2v45OCsKu0TypnCJT31f+qeV/lO+eyvL6ebOB1w2W/TR/96Ed58cUXu3Vnf/fv/l3++B//47z//e/n+PiYf/AP/gF/+Id/yF/6S3/pymU+ERj7K3/lr/B93/d9fPKTn7ywyO2tFLoZeukziKAzczS4MWsrLvWzzhwzylNunfVGnI1Z/g51aYNONmW/VdGQ3L3ogM11ebENUEbY/UkI4uMIwQo3HloPdRSWaGNFWjZt8Gh3irJDscFWlwLEeCQCI98BJI+GqIaYUKIshynDYUeIHdEaizdQG1iZMD+/IpxNCeUIzJhuY1qxjrQmRuLmY6EOLYaqE3rXW1GHR0pALQAfi43nFisWXHz41kJTxApVYCwsJmuli1ENozI82KgNAh2VD5RTG90ZZ1NYjGC2A/OdkM9yFM61jTL9As6Bc1hpQz3iBtgG14nvB6F7LXBiOnwVaPEkdN+SGA6hRkwDpYdxaD8zDt6TTWpj3dYGGmPwtgKJEU0VX3YSWtF9NfXN9XtP/QAroW9Y1h07df8IvsSjEKGEcyPQuNAnWw9OsEK3g13658V08yeDzJjJzl2Q7p8GZZqB1GNzPfbiBQ0eM0AYckzjfQPCXTjW9RqYbFln/4ThydeMXSd8//d/P/fv3+eTn/wkd+/e5QMf+AC/9mu/9lX9prxtfpt6Zt7h6izNVRiAPtCVjMzL3LtSebo+lxmFQ/XOrw9t4KwN4iQu0bZtB8KttTjnOqnxqxrXuoy+/amGNvndZmhfxRDN23KojVI8La6RJOrbtqVt205i3hjTgTLnHJPJhKIoqOu6e5aUZ2qj9DxlWXbxd3Z2mEwmjMdjqqq6sI9ZKjcdQyIh+nmG2irVuy9sM/5zsKPfi5atT2X0AaqrAnctZpLaP392naeu02XPeNmz9gGcoXbse5YhwNiXZhs4vSqw3DaZc1l4EqbrScq57Lfpi1/84oYg0OPHj/mhH/oh7t69y40bN/j2b/92/ut//a98y7d8y5XLfCIwdu/ePV566aW39I8dBAzQQavMeNq0g5R1h5CsqfipAyLmgpEkKiOzWVbXgXSi8HnTsNV5bea5YQx2FuiWL6+ev9frxlizVJqN6D6rB00ALEewOT2hmDG689q4NXnCtIkTlsSMibF4k+8PFg4x9Ox9lnZN0zFzAJgYJAVOY70G2TFJ7Jgoosms3Q3bIjBcdRlya+IGz0mww5ngwuhsYMXqEuoiMmIRpHU0lG7/CHbUmrHNY13/xBCZDqAohNOxk4op1BKVsf28WbeYM3G9GObierFuwy3TIYjcjTK988SKCv7C9gkXFPb70Enqg073yfWEwsZcCWpMXxq60Uu+ZXQaW3leqWuHvfr0+I4X5eKAkK5NNr9fNgBYOhuzOYbTjFFXnrqlSr9eSDukXzfN9cPHP/5xPv7xjz9R2r7wtvltUizNtnAZy/Ckhs0QuOqbLd+Wz1WMUB1ysDnEjPUdQwZ239/b6riNtRpyh7vOMw4ZnNvy0IBMP6s+53VN7Jj3nrIsO8CQ9g1L71i7JWpmLN/oOa//kzJj1w2XMWRD76MPOPSxY/rvPORxLlur2Aew8wmFqzyvBnXbxqRmK4fiDAXd76/yPXOVCQNd76vk21enrwcYg+2/TS+//PLG3z/zMz/Dz/zMzzxROSk8ERj73u/9Xl5++WXe9773fVWFv+GDtuAk2NoXrutDR074gbW92EXrsQZ1FiIEw7IDd5BYsq64DUC2hn0SS+vbYyoIKui69j9yAiKd5kUy5cUEzQkP1BKZMR/sMEPHjIkFqeL6omgjd+u3CpASKMAbhyfsyGyoEarINglFPLxA6wyixSxsFMCwE7wZY8yY2rQsaJkDC2BhoIregGYaDhYCZR2faomwRBgT+J0VBSNGGBoMFZYGocTEI9YHocDFbYobKmpEwLR1QCkrC8vIfM2LAMZGE/BFWP8lJkjbL0fhXPrAjnkTGDVvYTaB1SiwY6e7AZSdj2BRhodbelg5qBtM01JITUVNSU1JQ4nrtoCOWylTYuN2zpYKwwhDhWBo4vMv47EA5mCXmImDKRDbz+/A0sKc9bHC4kyFNxPETkCiCIkWHnESVPmBAoksY2BFPQ2SDtMGN8WS9Vo/o/B+8sp0BnEm9Ld0NLE/1j58bsH68Nw2bikOJtuqeUtIY7SLqKc2EkBbQ6UO5Ml6n3afZlbSj4Fy4b3oaixxg+rNOlxwU9z4njEbWG+jzpLFv9bv0ZMLeHyjw9vmtykL1wE315k1HyorGZ1D+Q3VL/+c/s5l5/tCH8vRt94pZyeA7lyW5SAToJkwfU73+gxODWqGhC2u0j6XxcufOzfEEzuTnjMxXVVVUdf1hhuiMaZjyqbTaQe+JpMJq9WK0WjU5Sey3rC5LEt2dnYoy5Ld3V1GoxGj0YiyLLu66A2l09E0TXekPHU/1c/WB5KGWJjL2jOddZvpDZhzljMHkJeBK30MsWKJGcvHSyo/1advw/Sh5/pqJ1P6Jhu25dO3EbSuT/73VwOsLwtfTzD29Q5PBMb+8T/+x3zf930f//k//2e+9Vu/tRvkKfzVv/pXX5fKfcODQRlgXG2aOaEt2QRkG0HyP3TGyvqycZZfU2rmIgZcA7JkKJruU1YxhQZ7qp19DnkHFoXIvZg0Lp107mCb0nqAGCTaoBtaharCkrFUolgqGw32BDrXKoLxkLgIzFRgSsSUOISGdkNOwBdARXBRrMJhrMNEALhpzTsMolwT1+dw0NVr7QLoOldF44N7oLQeGh8WrNWRVlqVUJjwMKWDsg2NUxZxI2gfrO42grFFBGPLKhxNEfKqTQDBjXRuisa3XT2Kzj3RKbfK3EXRdK6KgflL7d6qNonMSCmYEZjk4lkGN8XkxBZiG7wpEJPeRxWe2VslPGLU5EF6twLKPbHrA1aU2Mp6OCSxRPz6vLnUTcBt9kej3p3u0319/mJQQCejtEX9n65sYLfNW+G/NAgEEv2n3RsvfEfoyRwzcP/C94i6ntI/ERj7+rgpfi3C2+a3iYsMzlXCZW5M29LlcTUg6JsVH5odzz9flz3axnjoug2tWxpiafrYshS/DwDlde8DE1c1sC973r5nH6qrdglMYCABS13HtGbMWstkMrmw7isBJ82KJTdFDcQSkNbt21eHHJT0vcu+Z7tue+XxNPi5Kui7CrPV1/bb+txlz/wkbNF1Ga8+INbXZvrZ+sJVx+xQ+icBVU+a7i0Nxn75l3+Z//Af/gOTyYSXX375wpfFW+YHLxk0ve9SoSMRyDulidPaPQZX38R1+isZc13StHZMM2MmT5eXkGbtkyS8Oi4LCbNF7LDe5ni9JbMREC9hvU5ScShMlF+3iDeBxTBKU0GxYt1hXGRFajw1wogC37E6FYIXwbSytg9rE0QimICZgNkBJjhgIavAihE4nraiY3XMFOxcMFUDVjCyxMiiY8YMK0oc48iMjQkrrwKDZCJLFlq2xONoKWkDMwZU1IDQtiV+WYKxMDeBGauKuCYsGuWlCwCriMyijWAsth/LURD8WJVwXgX3xZmJxJWHZYtpWkq/wsY6VB0r1lLiIismig0Lxyg+2xhLiURgqpmxJcbWmLLGTHzXdmYa9EVWJjKPEo6aAtFqkGayubisFqjDI1bxnZaxDYOQSnj3PjFjhWz2kWJTK8YJUUBGgz3U+jHpgF/ysOzGVd9QGBoTHajJx283tZB9zpKLwnAdCJMMWfV/PyQcuOHl2d3rG8iiqtNTn2tPVNaE2YvrpvnGh7fLb5M23IYM2CHgdZnhdhnjlYMWXU6fO9i29NcNlxnvKf9kBKe1Ype5y+UsgTag+yTfc1CR1y99vgyEbQOVedwcROQgKD0vQNM0HTO2Wq3w3neMV3IxTAxZAmOJPUusWd+asfF4jLW2A2Jp/ZmI0LYt3nvquma1Wm0wY+meBvE5w3lZe+TPvk0Bsg9kpGMb6NagagiQ6XR9eWgw+rUU8Ogbh3no+17oe548bl852+q4bZwPlXVVAJnn+RSMqfCjP/qjfOpTn+KHf/iHr+Re8GYNm0YQF2ejk6VltgAyggG/MVud8sv6yMalZMBFNQATp/evMmTXk/B5J+ypY0/hJn7WhquwFn7wgHeCJDCWFhC5ACjEGZw3OCMBr0m4RUVwQRuB1IK3LTYa47DEU0VwEYz2UQJjNbCS5E0YVAjZAXa7o8EzxzATYQbMgGYMZg/YA7sPsgQzbjBFg/ELcPMItRYIS0paTARhYywOGEUA02IYxQaqcHh8BEEFgjBmGVimuqSWIqgilgWMTHjomuC+2FQBgI3HEYjJGowlcJEUFFcWZmVo49PYBjMH8xrjGipZUtIwYknFioqGKoKxCt+RgmMFwMYUTLBMMNFlcIVhgWEOzDB2jikWmKoOAHZ/3YZ+BxaWrn1nwJISMVOCP2h8H24MS7N+X7VQtOF9VhGIlXgMDZ4VnhXCCm8apPRIte4rvojcpQTiK7gqmvW+bd1aOqJ7omDjHmNr8Q41KnJUti2o+2Ik4pww0dG3bYAeRmnSAok/BgJas78PTvWMVpUsTxFL6sWD6mIO5t7i4e3y26TDkDE3xFylNDqe/tzH/PTlrY20vjoM1SnP/6rG0pBhPsRwJIM4CXckdqiPHdPp+gxx7UaWG9fXZXf0vdzdMn9X6XMClImlStdSfdI5uRzWdd0Br6qqcM51YCyxYrrMdG7blp2dnQtgTDNpGsSloEU7VqsVi8WiA2XaZU8zREPCJ0Mg6zJGaVt7bwO825Qft4GyPjZMM4I5GLvKs/TVry9chdkaCrq/6LoMlTP0fbCtrL4xrfv2k4DPt3p4IjBW1zXf//3f/5b/sdMCHhf6lgJX4aZGMwN5ZXmkP3X04Lwkm5EUOOrNe6P09ax9hHGXG57agryQs2R1zNixTlQjHmKQ6KbY6SrE509rxjrKIropmk4az3VrxbpDAtsRXPMIh4uL0lgfXorgwcfaTdEVQHSzyw8aj3FhrVJYs9Zgojy8Ra8VS+utkgtjqhvx7ClpKWgpMbTSYnwLLUgTuDRqGxcSAYUNLKJEEGYlHEKkDw2soox9HQFNy3otVOMwrsX6llJCuUV0UUxuilqzZO2WGNaKlZjO1dJsuCfGNrAtppLgcahcFI1yU6yJS7QEWjHhhlTrd+JtQE+NIaFxK6HdysgwFgimU3Fcv/8kmtm7ZiyepZvN0P1O1ofqr0b13G5Ubf0d6LnZDS5ltG7LYV2NdWRV+Gbd1mIgKaphPaxkozpZ3TbKSM+vopr+ZJeHNy8z9nb5bRqa8b4qU5Dnld/fBsiG4l+n/G1AcaiOl+WZ16Xv76GZ9SFglj/XNiatr1yd7ioAbpuxm8frA28aROj1S8aY7lwURQdO0zjRa6pSHXNjvW8dnAYk+VqpISXBoecZev7L2ir1o6H33Pde+t5d371t/WMoDNXhqnHz578sXIf5uUr9++qTA6mrArGh8ZbyuW7Ylt9V6vNGDk8Exj72sY/xK7/yK/zIj/zI612fN1zofY0d3pG1tWTjZ6tSZCBoIy+TXxDWchlrSJZswK7fSl/aNRBLhp1P8/emF2WpSlysmxDK8wLrPaHoXL+sBIZivU4sbUYcNOu9mG5ZU52M9oLAiI1AJiCtIEUNLBAWCDMMBSNapnimeHbx4Dx27qGycObhVIKbot8FacAfAAes/IoTb5gY4cTDroXVGMwh2HMobgBtOBc3QGY1bXOCEcFwSuDA9oE5JQVTCiwlcxxNfP4FngKhJigpehpaoKCkoaChQhyI93g3ohECO9ZUMI4s2aQMjTgq475nsVGF9QK7xgT3xkaCW2IrMGugdhT1kqJeUEnDjswoadhhzoQlYxwTHBXCDoYJlikFU0p2sOxSMsUyxmFpsMwxnMXjBMMxdjSnOBKKQyhjWxVHYI7Aj+HMwrGPh4O5r/D+ILwH2Q/HahyYvFOBc8GcC6Pas4tjimcHzwSPZQXM4/tfIGaJjFzoH+PQV3wZoOIq4XEBJwbxcX+E5P/qXXBRdBHfZr1e1L/Ux7eYp70fg/iH2uybizI5elLDqELS5T6QuFEfNbch2feHmmdZf/d0n/ufZNvoHw5v3jVjb6ffJh2uAnb6DOHr5KWDBmRXBWFPYhT1uTMlAJAAxFDYxmxc99DrjXI2JAcDOj6wAXxSW2mAkwBQYrxyUQedf7qX4iW2T7MdItIxUil9WhtWVVUXXzNdOfu17V3ottXAazab0bYt5+fnzOdzmqZhsVjgnOvEO1I+6bnzPctSPfQ532haH1qqXoPQbW6pGkBehQXLr+fAMs9zCKD39dXrgLzLQg72t8Xre7eX5ZniDTG/edlDz/vVhKdgLAvOOX7qp36KX//1X+fbvu3bLgzen/7pn35dKveNDp0h0wN+LsQS2Fgkkvdts469cS3G18aZ2by5vp5AmbrcVy3Zcm/jocxmREEZgrFeyXhd24UhA4MoMJqm8ZPMhdlQG09qiht7jHXMWBuZscCOFJHZSWueCklrxiTaiBKAiq8UuhvhpOyAX9pnLDFjxL3G7Fida4cxNUZqTOTSTKyLBSpKHGG9VWDGPCUmqikmZswTpEMMBS0eQyktVtrQRk0b1jeVShceE5CCM5u7S4MCY6x1RVYRjK1cYMXalsI3WJrIxqU1Yi7WUTJGzERGLDBjVWT3wrMmRrDuDmyLGUm3t5gZA3GftgSMuv3FBJoknUl6F1VoeP2+muA6WKr3WiLYDWasJSGprn9EhqzT55DEjmVopXdxle6vXe9eJ8sj9oGegZDg3NDXwoXv/uzroA+IbXzO65NHlvSdI9tRpfpqul6ouf5PwxuDGXu7/Dal0MdSpaABWX4tz2Mo5DPi+vplYZsxdhVWrK/uV6nvZff6wOZVZ/P1/T6DPB19jFhf+dtYHw3E9DvIXQtzwAZrVivtN6aZsbTvGNCdr6P8mPLvA2R6b7M+ZmzoGYfET/LnHmLR8ve77cjf8dDn/F31fd7Wp64atgGxq465vE9dVv62sobSXoURu0rZfWVeNTwFY1n47d/+bf7YH/tjAPyv//W/Nu49CfX4pgnxnWrYFJ32gn0kEqS5czi0ng5HJV1nG6PZC/PYKqHIGiSlCfE8z1jmhn0mRATXb7Am0JfSdJgK8CIgQTkwcG1WZ8qa1ilCGSaY254i2OFmvWwoqbbLmMB8NERmDJJQumXEBIcF9hD2EcR5ivNIwx07OC5gZKHdDUIY7IMcUJsTTpxhTIi2C8wraEsw+2BvBFu/vAH+BnhfUzw8jvDqBM8IwxmWGRVjdpkwomQRxdcNhmUEZA1BEVCikEeB0LKKPJnB4GllhG3Au4JGJvhlBaUNjJg14bONgMxkDEdSqWwdrFqMeMp6ifUtI79gzIKSlmk8T6iZ0DImSGkE3RLbsWF7VOxg2Y/M2IQFlhmWcyynGE6xHFPwmHIcmbGbhOMGcADtNHhPnhJYsZP4Ouauwrv9wIy5ffD7QYDk2MOxwKmDU8d45dnHs4ewB+wilKwIK88iO2ZWyMivmbFxwKy1CcxY536a+pqJC8tMEfqkuGyiwl88jGy4QF50A1SzJmogbUK64emOjXHX831hexmx+H8qfpNCC8HH2LpeYjBiNqJJHJsJKm6dRxoMb14w9rb9bcpCbrDmxmgfGOoDXdvy3xaGgFhe3pCBd9lMvWaCEii5DGjmhm0fs3EdJkOvE9IsljZIjTEdM5bcAxMDlrNjei2Y3gxY1yexaDrffB0c0NUpSdy3bduJcCQAlfYWS4yZZqN0e+nyUxlarGO5XG4wY/P5nMVisbFOLOWh5f/zPcu0G2Su+pjvc6ZZsdTeuXBGvm6r7xhyobzsnV8GCi4DjUNr1K4ahkDPZc+wLb+hvIbAsY6Tf7f0PfN1gdqTPMdQmjdDeCIw9hu/8Ruvdz3eFMHAxiy32bCa6EgxhOArZbqrWSZ0xJdsMZWSmZXHSVCog24bbFZeokZuKYPc4tvMsGOxfPwCilLuokvX6C2pi1CAKfHGdsu7EpPikgE8Aj8CMxKkaAktEPa3MkyY4ClJshye2tngpigmuik62LPgdoJrGnsgezRmzLkLmn5nPrjTLaugg1FMoToIALA4DIefN1hzBoDlDGEHywxhTglMMbTRxW8Z38CcAkvQXhQkyukHNq/BUsSVWCC00iIOnCvxTYBtFCVUAtYGERJrI56NLy/ptzsX/EBdC3WNwVMxp6RlzIJJB8JW8dwwxjGGDowFkY5NN8U9CqYYKtroojjHcI7hjIIzLKcU1ZLiQLp2sofg9kJz18B5Dac+HGcelq5A3BT8XnAd9VNYVXAm8UV4zLmPborCLsIU2EEoonBLp39panzl8Ypk84SdAjopfQNtXNW3BmI5xZj6aXJM9OttpbN5CTWfODBm1nBmc6pkPSq7uQ6VpPv+7/LI+bCUh+TR+idvEDqJ1ViQkfwbCDoH5xT9icKb103x7frblMI2IzCFPuCSf76KAdMX7yoz8l8tKNZgLAeZum7XaYtt7FXKry9NAmEajAEbgEYb/rru6X6fm2Jy6dPrtlK+CUQlN8UEKIAL6ZqmQUQ2gE+6n1hjXX4CPX3tlQuEOOc6sY4Ewtq2ZbFYsFqtujVruZGegzENrvoUI7e5J+aTDX1CGvn1HAz1vZMhVnYb29bX7/r6W199dfl5fxsKfYBIn/vK3ZbPZWX1Tdb0jZu+CZHXA4jp8q6b5s0QngiMvV2CXPgQglGMWDKxOmwi0eDTlp62mGQjo0Gs1lPsBvjq616SfZb8phCs27SubcMClDVxFkFkMmMTCyQdMFTOiwbAEnwo19v6emMiWIlGtA3KeL5AqeV5xIIRh5HAexTRVXCMZQdYiGBXgjGCzD3MJdjuTRV2dS7HwA7Oj1j5gpUR5t4z8zDzgXMbFVDuEAT/9qDYA7fjsFVwuDNugZUZPjI0Bhu5PcsYYYcChzCOvMYYR5AegZrAF47i3l4uyrWHzyUOB1gKPCJhVjKInET5e0O05gkWvAjGO/AO4x2WGotjzIqClhE1o7ix8yi6KI6QqJoII8KGzgGMFfEI6olhM2g2FBQNs3Aullizwkwa7B7YKI5odqEdxa2gha5dF86wcobGV4jfCbr3bUTaS6siCmYpjBxMECYIFY6SFkuDYYWYFoxHCt9pskhUUlQiibQmicHECQB99Iwc6frt+iAyY3oMST6gEkOpJxxE57sORidVpNqFeD2f1/FkONLGd4R0dQnzJdFAY73KVPBd3t2atbcPIfS2C9tcivI1VX3AachQyt3erlKPPkNsmztUXx59rlK5wZ0+54bsUH3zmf3cUO5jyYbq22f852As/Z3ia2ZM11Xnp9kwrZiYG8A5mwZs5Ks3Vc5BSNM03VqxVMdUbrqejhzowBqMJUbMOdfJ12sXxT7RDs145RtjD0nbX6a2qPutiAwyYjmjtY2RylnNvH/29ZHLGN6+/ja0viwHPdvGb17OZX33ScYzrCcWdH7bwFXeV/W4vs4zvd3CG0Jy6md/9md597vfzWQy4UMf+hC/+Zu/ORj3n/7Tf8qf+BN/ghs3bnDjxg0+/OEPX4j/F//iX7wwsL/7u7/7q6ukQjcGg41MSElBSRE/22AYSTKE5CJqiqyT3tR20/LbXrxPM/BmfaStli7O9ueJRW3MnCKGSnSSBIawZseCM478X+Iauhl6LNgSbBWPEd5W1MZSG9vxHqsCmhG0Y5AdkCnI2MGogXKJYUbBOWMW7LBin5YbCAetUJ067GOHeejgXguPDMx2YLEL9RG0t6jbfU6bEcdNyf3W8FoL9304TkqQW2DvQPEslM9Beauh3DunmJxQ2AdYXsNyH8sjCo4ZMWPMgn2Em1TcoOKIEYeMOKDigIr9KPkRXO8a9qjZY8k+cw6YccAZh5xyxAlHnHDoT9ivT9irT5kuT5kuTtiZnzKJx878lOnilN3VCXvNCQftCUcch7SccsgpB5yzz4x95uyxiuU69oF9DAeUHFBxyIgjRhxRcZOKIwp2qBkxp+QUyyMsD7G8RmFeoxg9ptw9ozxcUj0rlM+F9rJ3YD6F+wKveXjNwf0WHrcFp03FvJki7Q1ob8JyP0Q+qeC+g/sO+8hRHDumS89N4BDHlBU7rCiZYTgHO0dGDYxbZEfwU3CT0F/qMgJBAiPZGEtrSrCjeMR+Z9Z+h2kSweGz3uvxUd1j001RUVJ6rDiJ8o168JqN0erTmNSHHqeDIzobnHpztI3vBtaATEW1EtYDlt2axvB9pPcD3CjiWqF+wuOtFd4Uv0tcBC654EGfXPhlM/p9AOg69dl2bHuGy+KlONrozvewyttCn4cM5yGWYluavA75eim9jkofqb6pHL2Plz5yxihniKqq6jZfHo1GVFXV7ROW6uq9p2ka6rpmPp8zm804Pz/n9PSU09NTjo+POTk52TjSPX3kcfL4Z2dnnJ+fM5vNWC6X3XNqgz7J7Os66/3KNOOVuyb2tUsy7PW6tbyd8/VrfYAxD9cBUHmaPmCZj4tc/j4BaD0O+vrnZZMNVx1v1wFkKf+hNX15OZcB6fx5rhsu+265znfOGy18w8HYr/zKr/DSSy/xYz/2Y/z3//7f+aN/9I/ykY98hNdee603/ssvv8xf+At/gd/4jd/gc5/7HO94xzv4ru/6Lr7yla9sxPvu7/5uXn311e745V/+5Seqn2QHrJ2Oku20Pq85s0EDqG/2+0KJw3XJY3TXTF89M38nDRB7ipHcAIQOfG3+yyuQEiaWIpzFmE3hepNt/pyEGqwnqVbYeJT4pBtB6cM+VbaW9X5jtQmbIUefNpER3le0UrLyhqUPQoQLCcryMibsER33ibYTMCOPHTmMXWFYYtDnGktDiY8aICbuOZY2UDbxWAvsh42qfcf8VN3RMKKhogkbM0tNJTWlNOHw4dDXKmnivmHp0Pm5WIbEMlP5mxs8p02ew8bVQtGxUbV61niUbWiPsazbKe7j7EpYSjx8OBpf4KRCpAqN60dhgV5t455qglmF91Y4oZKwvXaoR+gVSUQEEza/7vpDYsWMOgBvDGJsZBJz18S+wZT127i3hF46qX5OLw521dHz3PWECHmynqpc++dAj0WVScBs8cfwwj82Pl0NDPaFp2Dsjf67NBSG3In6DMOhtJe5WF03bDNer1rONuN0KP+hMJTXUB2G6nlZXfoYqm311YZsHzjuY/i2sUupbrnr3hBI1EfarPkqcS6Tsc9BcV7f3OWwjwW8ChjQba3Pfdf7QNXQ2Mnf8VXCZX37OoAhv3+VuF8L9mnbRMZQvG3j5knCWxmMfcPdFH/6p3+aH/qhH+IHf/AHAfj5n/95fvVXf5Vf+IVf4Id/+IcvxP8X/+JfbPz9z/7ZP+Nf/+t/zWc/+1k++tGPdtfH4zHPPffcV1e5DRchfdlcAF/auEuH2wbIttmQ0beozy5Ms+4btpr6w3Qdb22c2WhoetdlvRaOsCFWWhFmIjOGB2+Sy1PYAyqshwoC3xugLtEDlHSbUjHB07I0SwrCRsznPhjW0524E8AesA8sGkx9jpGCILG+wxTLLaZ4hGcQCvGcnHlmrznYEbhnAmVyZx/27gAPgOdo5ZwH5Wt4WfFqAc8WASO8cBtGu1C8AGYFfgnVq+DOWlz9EJoFwZFuF1hiOUBYssMtKioKDC0VK4LD25ii2yS6Cbte00AESp42nj2Whia6LBZxS2sTNSMtSSh9LZUeVAbDfmeOkgaLUFFT4BjhGNPGdW1h5dReFOuYUHDEiBGWm4zYpeAAwyE+Ki+eYFlguI/hLoaHFLyKteeUN+ZUN6B8MRzmFpjngWfhbAyvOHjVwSsN3HeGeXMAzSH4Z8HdgeYIHpdw7uBeoNDKx56jJkjZ3wZuAYe0lJxhOUc4Bc4w1RLZJWwsvQtuGvbHPhM4F5hJYMbaDnZOYh+r1htlp/V2IgQJSx//ue4QPEYxY4m92pzRiFRz3LbBeNMNLxsjbkyGJECWgTIUUEsJsp8wLgRF0F2IqvIIMDQwYxsTQB0IyyT3r/172HD9n4Y3xpqx1yu8oX+X2HT3yUFXbrhe1wDsM0hFLt8XbMhQy+uZ13cobr5XnH6WfI2UMWtXwW0MwpCBrI10zbjodH3ue6n8xG7kQEG/A2tt5yqoVT5TvnotVap/yj/9rV1PU7xUjt4EOv2tgUdSUxQRmqahKArquu4EPDTrpp9bt08CW0mqXot0pGfTdU1HYuzKsmQ0GnXPmQMt7aqZi3ak9FrcRLtganDYJ9aR3lcOyHT/yNuwD9RdZ2JB97EcFA+Jv+j+pftnH+jZVl4eJ++bfXnoMvPnGypD53MZM9g3Lq4TngRcPQVjVwh1XfNbv/VbfOITn+iuWWv58Ic/zOc+97kr5ZH2s7h58+bG9Zdffpk7d+5w48YN/uSf/JP8+I//OLdu3erNY7VasVqtur9PT0/XN3tAk2bG1reDEWSjce21sZWMKaOyinhmOKwNP00+SV4fRdclZf21TWc64CigNmpmc0o/fTRsGJLS1SEJIGj/xmT4otweLWHdWFC6E6DBUuNZRWalMEqVPirm0TqMWWFkzdSMaIMiIkF5b4UwX0XViDOCgoQBjiYB1fl9cPs4YOYeUhg48XR7jvldoCLsO3YU9s6yR4Dx2HKGp8FwiuGMYO6eA4YR+1TBjGdKQUmQ+BBQAh5Qxz3IJLZNG8+eICXvaOO2zG0GxjZfZug9YfNmG0GUxVPFzZ0rhHEUORmHlmZCWCO2Q8EOBeO4T9ouBVMCxLS4CMRm8RnPCCqKpxhzTrHThDY5DIc5BOLWYSvClmEnUUXx1BlqPwlt7veDeIfbhXmxVvY4E+xc2PFBtCOpKO7gsYqRE5ZgGxhLt7eYjMK+dCvRKoqxzUxFUO0sQl9Lu0J33XJj2mIt3JEidBMRuicbLlDLXsAn9juB5fW0i+aHu0+accuGv+nOG1COjWDCZEjPnY2LGrOldWMm1tGk5/mqQkPYMvy6ad4a4Y3yuwTbf5tyoy1dG2IQhgw9Ha4yk90HsPryuC7blN/vA345UMoB2GUA8yrPNWT49hmXOYjTQKgPOGrwpl23dJoEQlKclIduDw1IEnhK+SZgp58j/5wEQFJ909+5MZ23SwIzCYxpUQ/tbpcD2NzNULvQDjF/uWtm7m6r236beqJ+TzkQ6wMU2yYVrtLPLgNJeb23TXD0lZkDLF2Xvs95n9XXNEDqy+Oy5xr67tH9ehvwui5z9hSMfY3CgwcPcM7x7LPPblx/9tln+d3f/d0r5fE3/+bf5IUXXuDDH/5wd+27v/u7+XN/7s/xnve8h89//vP8yI/8CH/mz/wZPve5z218caXw6U9/mk996lMXM08oJnuX+k+jDGn9V86YPUkwF/5aW2PaADTxlhhR5a/tzrQezGvw5EXNwpsgipg933rPsZRI5eZlva6mlWCLeRs2o5ISpEIQGjEdEFsKlAbcKC7FiTL31A7MguBoF9YRjTlknwAEDhFaEU4WAifxOJbw4M1eNKRvgNzCieXYl9RxbdP9MijhPyqDgT/Zh9FtMGdQPANUgr1XU7QeqU/x9QPCvle3CA8V9AkrKvaYRsmJgiKCXI9Q4/EEQGaRKHVPFPEQSloctuNoJPJedOazWbcrRE3GBMaCMMioOwtjTFSctFTAHhVTCnbierExlgMsUwwTVhH8zDE8Bs4xPMLwAFs8xk7m2NEKe8thnwH7DJhnQI7gfBw8QR/62JYOHjh46AwLvwv+FshN4EYAZeclHBPezYmnmHn2nOcAIWzNDTs4ik7FMWxpQFkHOft4+HHYCmER+0za08wR1V8k9rHky9jGPpjWeOFZ88oRqRnZcB9M8xFCjJLOaWwkoQwxpK3Y09YTrhuHsrlBc8/Y6Rm6X1W46JiIOvcmeIJCa67vwf7WcVN8o/wuwfBvk5Zz7wt9xtPr7TJ0WZl9RljffbhoRCZxicvi5Yb20N99bdUXP5V7VQYkz0ODpDxOAgxwcSNo3TYJJCUAAmyAsrw+uky9qXN+T6dN4Cnlk0BgDhDzZ0hp9Do9zTClMtM5MVl9YGybO2YO2PqAWKpPHwjrA6J9/aKvL24D3H3pL+uTfW6Tus1yAJvK12IvmqXVdd4GNIYmSrYxY08SEqDrA9V9ZeiynwQovVnA1XXDN9xN8asJP/ETP8G/+lf/ipdffpnJZNJd/4Ef+IHu87d+67fybd/2bbzvfe/j5Zdf5k/9qT91IZ9PfOITvPTSS93fp6envOMd71hTWGlxPTkQ03ZOMqiDW6BHvjoklgeFrnJSSwOpZNAnIAamM02NxPn8BKK0aIBROC0BvLQsRwTxwRUv5GYwPoEwD7UPMu0uqSIE2ssLrCSUPZPgclYYaCcRt+2C7IKsGoSzCE1OMEzY4WY3N38LAfE8OPdhD64d4DVCee86JMjbPwb/PI0puN+OKAWeb+FWG+z2uyYort+5BeMCigbK+2D2hPK1JXiDP32IrUuEGZ59YIaJboUT9ijZoaXAU7GDMIqcSR0dOOu4XqzC0QJVELSnieDME9bQJTCW3lR6j+mvdYywa1vYhDps5jzGRDAWpOorDAeM2KVkSsFNRowx3MQyJSgnFjyKz/IacIrhFQxfwVZnFIdn2OmK8nko3wnlO8B+U8C4j3fgvAguil9q4ZUWvuzgcWto3SHI8+CfB3k2+BaeVOG93Be47ylWnqNGuIFwG+EWUNJScIrhGDgBzpByiZ9Kp4zvp7AqgxjjuRLQbKUMCN6PA+jvdqGO/bD14DxGum3HAY8Yv1ZQjA29IbCRkJlH7SxtglAGiRlLoOcCP3zBTXFjzGbfEFcNGxM5sSDNiK0PPR2kjIgL9Xgavl7h9fpdguHfpnwWv2+Guw+MDbFWQ+GymX5dzlXi9qXR9ekzci9jArShnNipPgZk6Eggqs+1ra8thsDYkJGuy0ksUtu2ABfUC3NWK+0L1segpM8pTkqvmbimabo69AmdaBGRoWfse5ZtgEa7OyaXxNFotCE8okGbTq8FPLRrombRUpnJTVK7S+o1a0P1zfuEHj/5M/f1iav0qSFA1tcvt4W8nfvG2rbxsW1S5jIgN9QXrprmsnK+1pNDb7bwDQVjt2/fpigK7t27t3H93r17l/rV/8N/+A/5iZ/4Cf7jf/yPfNu3fdvWuO9973u5ffs2v//7v9/7ozcejxmPxxcTps5iFCCL/Uo2TOjrhdQ1deo8p+T2eLE+shF5A5CJTr+eMbesXSghp3pNAFvq4Tbq111eQwcTMtlkx5zEtTuG9a66YfVTIi4aiQRaEQm0Kroslh5sC65BorhEEM9oozueDeIPUchDavBLgaUJMo21CRL3doqwi2MHZMJSGs6949wHIFgBN0YEJccoc2+beJ4Jtm4w5/MoCjIjOBiG/biEMgKbilHkrsYYJnHvsXR20SWuQCK/tca7HqL7YnKgM6ofrU1pG+FzAGPh7iiyYUlIpCLsI1bG8wTLGNvtM1bEtWaWFcRnCKzYDGNmGDPHlEvM1Acp+/1wsBfAkNuBhQ3tdhaPuRhaP8LJiLBb2C7ITthmoC7D+1gE4Q7bCGUrjCTJ2fu4ai7tYRV3DjMNUjikktAfIuHVmiTpsia9RJL6i1r01fU96ZQP13zj2m00oZcNxioPEvu12r8rqROyMULUKNFjUecr2c0umI23nldn209z329a/6Pk3xtbMu0Nb29m7I3yuwTDv03bZp8vM7K+2pnlvjyGZsG3GYN9s/TaQL5K6DNo+wziIfGM67AnQ/XqM8KH6j/EtORtp9mgnHnQ+eu0uUiGiHQsW87a9bVZ/ncfUM7T53XW5V8mSz/UNzTj1wfagA2QMwSudP22geah97Qt3VVA2DbQ1heG+tZQGOpj+fgaYsj6xnDefpeFrwZoPQkYuwqA7UvzZgjfUDA2Go349m//dj772c/yPd/zPUAYZJ/97Gf5+Mc/Ppjup37qp/j7f//v8+u//ut88IMfvLScL3/5yzx8+JDnn3/+ehW0Zm3XiKETr0iXuv9fH4S/Nsz6jbhgVCrUtZ4SV9UIHwxp1UcySw0S3emchH2FO4QQn3NDGt8QhBEFgiCCw0R4YvH41uPEQWlh0QYLer8MtFNbgRvjgaWz1CYwHKcxejMJUdo9KA7ALVp8OQPxiHsMUmK5xYhTpoy5xR6Wkldrz17jaE4Ni9cEaYEHJUwt7N+Ao3cCU7z/MjDhfvuQ37ePWAo8W8JtC3tHsHcYmrA4B/MYqlOwByBfOMPPlkh7jl+NEdmPDbDCcEiBYBhzwCG7TCIIGrHCM8KywrNDy4KWBmEeNwNYEdaQpb3JJH4Oba2Zk/Be1RbaUa48MGIF6/3DKiwHVFRYDinZp2QCHBLYpxEnFCyBh8CrBCD2BeAEW36JovoKxQ1H9Z6W4gjK90PxLpBvguZFmI/gSxZea+H3m3Act2OW/jmc3wXeBeZdUN+Bx1M4q4Lu/T2heuSZzD0Hree299zGs8+SEYvIfD5COMYXJ3hzjh973D60+9DuQjuFhQv95dTF7cq8wbsS3Dj4ubYVNAaWDcw9LFuow95spUjn6pmUOEycI0D1cd+NHbO+4ELfKCVwTmVs9zSOvGKiNJpKea9nMkzvME7je3Pt2OsVEvhUwRr1vXDVEPbYu15466wZe8P/LrEp5PC1Mja2GXV9Bm8+W69BRN9svY6vnyc9k36+PkYo/6yNYC03D3TiFW3bdtLvuQiItbZjrJIboV7nlcrQz6dZNX1fP6dmdFK8nBnTgEPHr6pqI39dRjrnboXpunZ11O6Xmj3K2b+rGrv6PWs2yxizIbShxTqGtlnQ+eg8klR/3j75dgKaIUt9pc/9MwfBQwA9X4Omyxtal5ZvZdAnq58Lhgy1p34POcjM+1R6/4kZ1fnpuHm/HAKtQ5MqX23Inztfl3idfJ6Csa9ReOmll/jYxz7GBz/4Qb7jO76Dz3zmM8xms07F6qMf/Sgvvvgin/70pwH4yZ/8ST75yU/yL//lv+Td7343d+/eBWBvb4+9vT3Oz8/51Kc+xZ//83+e5557js9//vP8jb/xN3j/+9/PRz7ykSeoYTRmTARCkkyeDrbQZ+hcuNLT5zSMuzhLnhlsGzcVIEtXNu7LRvQEI5N55ZNLVj4lL2pCP1bOmM0INs3qi4ALbmG0Pi4GM5Edizs8W4sXg0RWrI7MmCtitDIwY74UxLZh819WiJKXL7GM8UwQRl6CmEYtmIUgcxPom5WFyRjSKjPZR2TBUs44jSIepx5GBpZVWDtW7EJxGFT17SHIEuy0xVYtngJTn0XG8AzYi7zUHItnxG7U6bM0hL2dlngsptuJrYjcV5LraEi2fmi/JGyZc6yGze0SSkwEY5YSwzhu5FxFUDbqhDts3FTZU+AJGzvPIehYQifacYYpzrHVHDsOIDQJdtjDAIjcNBBd58267U49zKSglSlIpNDMPvidwE4ui7CXwNxjl1A1QuWl2+h5REtBHd/vKpxNE957EftBZMZcEbpULesNn50Q2bC4c3hiYZ2EyG1gxowXjEjs65F7TKx2AmJpjkWzV91MhGAkCd+Yzk0xgeZ8KmZjbG6MT31zM+g5lJTsqj8XV/imWV/pmP0rZt6F+gkSvXWYMXgz/C6FkDMm8GQGy7b8dTkp9M2q9xl0Q+5KQ8BOhxyc6bh96YfYjMvczPI02xiNvmfZxnwMGdl97pC5wa0N6fRZC5b0taNmxDQATOAzBx19z3PVkAMDrQqp13xptmwI2OfP3Cd9n7ffZWxTX7/K33kehvrDdVxeh/ratna8rA598Yf6QR5327jty1fn+aSgLB+jfeU8ZcY2wzccjH3/938/9+/f55Of/CR3797lAx/4AL/2a7/WLZ7+4he/uCFx+3M/93PUdc33fu/3buTzYz/2Y/ydv/N3KIqC//k//ye/+Iu/yPHxMS+88ALf9V3fxd/7e3+v3xVxW0jMWAIuyUL269l1/ZovXMv7Wg5+sssmi6KX6MuFBAqQxYQGMEbi5TXvkta8SBLgkDgbpneKzs3MlKeJeUbDNrEEPoJS33rc0oW8lj4wY9bCuAoFuAliPLVtOfctIxMU+byEPXuLXSj2oD2AYuVwZ+fQFFgeAQ+x7HLADgbLTQw3gfPasHgkeCdwH5iakMkzz4Mdg3kHwohzv8D7xxjn+IJrOZPAjhkDh7vw3DsCCCkeg9kF78DX4M9r/Ffu4ZfH4EtE6gjKwDAlqB3uMWLCHjtMsBQUNBTsYJhhafDMcLR4VniayIa1HRiTC/0nvYGiYzZNBGMmuiQGt8gdCkYYDiMzFhwzW0pqCmYYGgz3CADsPoYvA2cUxZcw9pTy1hnlM1DcgfK9QVXSvgfMO2G2H3YNOPbwBRfXi7mCu65g6fdo5QXgBvBNYF6EegoPS3hMWCv2QJjMHDdw3MRzA8cNPGPOER7F4zFiTvA7NW68ZsSanQAbF1GQ8dzDwlu8iyitHUdGrAiqHiuJALDF1o7CC4UIVWSzwtqu4PJpMkC20dk3dmtev4MgH2+7vJJj6XqLdNZuj3oQZ9/9aRwngLcuWLFswOBvhi5DNr9nNr9/LrplYk2chbnOD9JTMPaG/l1izSTptUIalORGyxCouIphNGRA67Bthn3I4NfgQT9PX9y++uR1y9sgMRbABkOWWLLEpCTmSwtsaIYssWRaRCFnFzQI6mvjvP00e6fXWOWgJF1LDJlub61emLdLSqfj67rmQLCPeRtq+/yZNJuVzn0CHH3GfQ6+0nPqtWI5EMvXiuWMUx9Q12yXPuvnTfkMsWE5K7Zt3zbNiOmxmPeFockO/bx5e2mAqsVmto2Jbe/1svF9WX+4DDzq8ZgD7icBVk/B2NcwfPzjHx90/3j55Zc3/v7CF76wNa+dnR1+/dd//fWpmAY9xoTNsXw0wDqjaM1ryKY5tAFqekMvIFsnMN3fF5yPLhqAG+VoZb5gWCo7E9dRBCgwtq7SRTAGSXKijHVyCF4CIPLLNkjmryKdUdpgNCNRbMFT+yWzCMbOIpjdGcFkGgxxtw+UHr+YYRvwPMbwGItjn9sUjDjCc4RBao957MPCoofAroGDXTDjcPACUHAu9zl3IzAtX2odMys8W0Bh4cUdePbFwI4VD8HsQFkHhsw9rHGPXsO0YZMy55rIMpUI0/hOFow4oIzC8yMqHEVct9VSI4xpaRGWeJq401XurgjrPqTBWHpvZQQDCYztRNn6EZYjSipM3FC6xjDH8oggG3+XINZxD/gy1pxhi1ewxRnFTSjfFcHYuyIYewfwDphb+DLwyMMXXRDteMUV3PMjvJ8CzwLPgHkBeD7ILT4q4JHAQ4FHnvHccyQBhB3hOcQxYo7nEfAYzzFiznCTBrdHOHahnsC5gbkLfWTmYektkgQ73AhcpDZrAhhbOlg6bOPD5uCkNXOGlqBmaYxgsjGifroVGDMRx6yBWGLH0nvagNBxbHQAz8Tx1DtU9cjuInefNuuUJe4ZnzkYM/m1NHG07ftnMDRPkOit46aYwhv2d4mLRlzutrgNjF0lDIErXb428vqYjjxdn5GYjtxdTtdhWxsMAR5ttAMb57ZtsdZugLD0dwI8On7u1piDIg3s8vVZQ0axdpFMZaV0KV4CJcnwz4FmH3DN3fNS39DsWHpWzTD1qfvl77avrTXQSq6JfczYkMGv80iCHQmUaYCa2kqDpT73Pz0W8mfKQVQOQHVb9AGyPtYrB2S5a2IOmPWz6/O2kAPNPmC7bZzl1/M8t6UfCn1l55M9+qzfxZO6KOoyrpvmzRDeEGDsDRs6sBMBWRfWRlkwo9dgSdTddTqj8pKemfN0NurvTVhmRJCLCgFr0MTmQazXmiFbz86nz5v7ERnSIjFB1o9rQAsiJPuuJKyfaT3Bl8xIUFVceagkKB1aC64EW+K8pZZoP/vQ8ZoiYrUx+AkYL3i7iuty5lhmGEoqGsa07AC7wMJZioWnLQySFCbODcxKGI1gcgBFDdwAuUnjFxz7oGn4wMOBC4KMx5HAGx1C4cE+BvsQsFDcBjMS5GwB82NELOIfAUuC3H3SRyywVBR4DCUjYIqhAiwFLYGpabBxXzLfw4ytG9vQB8Zgp3NTNEzwVHgqGkoEyxzT7SH2GFhieAScYMxjrD3GlHOKwxY7Ds+WDnsLOILFDrQWHpsgZf9I4KELn2d+gvhDOhl7jqDegaaMHpDhHZi5YOaeUe2ZEo4xLSNaLEuEOUGpco6YBX7U4qKUvY84qyZI2q986CuNGKTzZy2iD6MJfS2pKDYe68JEQREP2/Vu6eZUujmIrturEaOuBRxjuDimpMuvw0j5hEg3N3MB9W2MPNn4m3VcnV+qaFeJ9XeHhvHr5Otvnx5M+DS8hcJVZtS1MdR3PU+vjf1tZaa8+srclm5oln8bq9FntA7l02dEajYlgRDNjGhjUbMMQyp6Q/XMBSVy97Q+QNbH2PQ9TwIqsF7PlBu5+h33gVQtWa/bJuXTtwYxB+T6szaoczfFy2TrUz6a3dHs4DYp+7y9rmKc5+Cp732mMvoA25DbYQ7e8nRDTHBfv8/bd+he/i7yMT40rnUb9rGpVwVGef3y5xgC9Jfl9zQ8BWPXC9qgiwyH7TGIkvdfAGOmfxG9bFhVGzPnGpTZWIIXE9LowpKtZrrIHf5LXJiJK15gcy1SKmMNGrsVZd0zaEs07Z9VxmdOoGHlYLn0SAOctes00zJkPpqAMaxsgxSh7Ec2aC/cGAchPruC5gh86SgfnADnWA4QbgANU15khOUWE84AV8PoUYGbe9pXKsRY2Cngzgh29+HOO8Ouzn4O0jCTB/y+PWNqW3ZtgFPzAnZK2J/CN70b9p8DRmAq8A9Dw/gTj/3CA9q7j5H2EW41R2SKZ0aQyriB5RRhzIibCCMKpuzGlVuOCR7DAk8dWbGGtZvixblgYruG91NiossdTCMYK6gpqLG0lMwwtFiOsZwT9u66F4HZlzAcY8tHFKNXsbuO6v0N9hCq90P13rCnWPktgZl6cAiPK/hDB7/TBBD2Ow286mDW3kTce4E7wPsDKDu9BSfjEOHLLTx2FPda7P2WPd9yRxpu4jhiyQE1lsc47iLcx3Mfb+Y005b2Rnj3zUFYp3Zi4LiFYwdnDhpn8e0ksGL1OERaAKdNQPXnDuaeUgJnaSMQTpDHx0OP3eC+uG5pTNiSIY3B9VqxNI4g7V22PsKwkTjEN17g5swMiWlLAG+NuHq2Z9YIrxvYBFYeg0hwEbbrKR9VVBKG2WTvLhZyWXgSl8O3lpvimz1sY8fgosG/LVwGdC6b+e9jVPryz9NeJeTMSj7rngzkpmkQkY5xATqZ+fS3ZlXSveQql+Jptie1gTaK9b1cVEHXOQHEVFcttqHboCzLro01y6TdCzVI0OydBmY5Q5Tyzd0Ur8JG6neWg6ocjKXn0c+Vg7eqqrp2zgU/NPBJbFNyBUzvNu/X+jn1+9eCHxrUppCua1fD3OVQgy0tIpKOuq67NBrwazCs33MfaNPt29fm+bX8fVx1bOfAWL//fOJgKG2fQudVGPltgHRbeMqMve1D/jK1g5lciNldM2rGfWNQbAIxPR2+Ntc24FKMv6VTbU7ugyRXxbVlaDrTUs3QGzWdb4Kxt2FLdplKl3UCdCUmbG7sQYwgrY/7Pdko4rEWXPBicWJoRKglmG4pmisDM2JH4AuHtR6RFSILYBkl5RtGlEwoGYunaj1NY/ALj5sLYf9gA7YIuuzigD1gHycLFr4Cas6858QLJyasqDJR3dEVIPtBxAIXXPcA7G6LnbT4eoFpz8E7jD9jDZsmQEPgrFpKbATQJS7uURbEU4JrYhFb0rHZzpoQSUCgQKLLHYzxlIClxVITuLYFhprAiJ0RFBNPgQXGnGHMObacYSdL7I5gD6JoyVEU7TgI7oHtFBZlaI9TWYt2nPuCubc0fgfkANgH2QPZhboK7T03MA+sWLHyFK1nhGeCj3VuYn2DMIuwxNsGKVqk8vjRpnBHt22YJOEOw4akvbdBNKbxIZILoh2JSUxtt2axNgHLejLFrNFU1/LrAaTmITbGUDcOzPp+v1y+dAXqCRZdkuZDLzgim556dYBS1JNlz7eRR37hquEpGHuzhWTYXDYjrVmxlK6PdbrKTPt163aVPPqAWW649QG3IcC3jenShmLfMcSM9Rmv2g1QH33rYvJ3pNPqOuvn1KAmgUddhz4WRLd7ip+zpPk7yuuXv5u+9zLkknkVwLBN/l630WXvMI+r23aIsex7D69XX9kGQIaCbqe+vt73Hvryv+5kxnXG9bb6aMZWh21M63XDUzD2tg6SndfGs/TGUvPSyWKzrI2rzgLbBDf5wcZnc6G83hAn+Y2PM/qSeABPAmCJHVuXoOqZBlVcH5bIuFDXkE8Qr7BRNj9tehwM53rlcJbg+1fHHbLaCViDc2PEj1jiOPUtzsBJVKXf2YHqEKSE4kaQSSgWM8r5a4SduV5FWLDHbe5Q4BCex3LuCu4/qJi1JiwUOizgyML+rYA0qlMoW7zss+IEb0/5onnIzJ8zL4O64pEJIPDWCA5egMNxcFcE8Cdgd6C4Cf5kSfvKa/i6wp0vkXoHz008jxAmwDMIEyxBaVAYYdhFKNhhxLjbFKAkyarIxpted44kF2HxWFoMQkkd236JYY6hxnIczw8JkvFnFLwKZkWx/wg7mlPcqimfDUCs+v8FIFa8D8r3wHIXHh3CooL/D3ilgT9s4H/XcOZKHjfPsHRTnHsP+PeDvwX1i4HGujsOO0B/uYUvNthTx81FzS41z9HwLC17LLG8FpnEVzHcw1entLstfuIDI3YEi104K+HcRlZMYOYLal/g3RhxO0G8oxkFKnXVwLzGLD0j56MbZ1hXZzouzJEkPEh92cRt8EwCY9GV1tj1GMjG3xqApXEkgaXqxvXAWOy+ENYuwkmZUY8+3zvC1TeB2azU5jSQdCnJrn51oWX4wbaleRq+UeEyg1+zIHDRME7xhoytPG4u577NgM9dqa4ahmb4h/LrY2ZS/MSgNE3TrQFL7FdVVRsGNdCtK0vMh2bJ8vaFtSFa13V3v6qq7nrOIqX0qQ6JJdP5J4YoPZsGZBrA5WxN3j45QNHAPV//NvT++q7rd5Tqpd+Dfh7NhmnBj1ysI72bVG5ixLz31HWNc65jnzSA0u8hHYkFq+uauq67d9nHRqV3kMrrY8RywKWFO3T+qb66X6a2vmyM9bXtk4CJbaBMg/0cUOv0l+Wvz9tAvr7/1YanYOztGkS4bPHFRVeh9Qw8cHGG2+gIupOsZ9A32bEU75IOlSM40bXp42DSR53QdiAxsWIbTF/keQw+rssJ5m5FWGPWNh5nTdSvt3GLpxK8IL7E+bDl79w7jBUWJijTFxW0O6FQNwW7Eoxb4eenBF7oGAHG7HGIY47hiBbrheOzNlAqRxbu+2BtL/ZgKmBugz1DjKflFt6XPLLnrOScEXCnDOU/WwV7fHQUXCeZAifg94FleIVu3CBnDXZhYdHgGREk/TzCDsHpcEJg8hYIY8IOYyUjdghosQJGsa2TaL1+B8mUdupYxfMCE1ovMmE1hseELQAeYDjBcorlFYytKcfn2N06iHV8U5CwL78pgrFvAvtiWKN1sgNnFu418JUWvuLg1SaAoVl7QOMOQW6D3AF3E5obsNoN1NkDgQceHjrsectu3XJEyxGOAxw7NNGN8ww4QTjFFzP81OEma1auGcOigIWJBKeHlbe0UgSEnnTvXRn6VWOiWEwQ7UitOiI4EKaNt9e9VzZGQmCDNZpaS3ToobEGY16n3hw224Iadhf5sS3MmJoY2fhbBMzGVtYbKfs5Mtn880qh5vqJ3noCHm/kcBWjZMhAgn5j7SrsU9/ny0IfM3ad0Gek9sUZMi41GNMKhlolMQes6Zzia+ZqGzOh42thjrRmLW/jVHZRFJ0Rr8FKarf0PFpMRLNqqWz9rhMz11fvJzXyh8IQ69XHgCU3Pa2cqF1A0ztLz9cnkpELkKSgQXVfmly4Q4d83VfultjHhvXF7Vv/l4Ofbe2o06XPV31Xef6XlbVtsmNbP8+fTQfdv7fV+0mB1VMw9nYM3aS4xIlxUYZVipB/UkEzTsmCiwaViqTgV35V1pBtw+LKgFz6U+GqUPWwqu1i7dQMfDJMDXFdioAUhA2iw2a5nQK+JNZBMzdhXZMBVq0EWm7lw3oeJG4qJkGlQSY4aVhKAyKcedgzgZw42IlMwR64Fky9QswZYTfdx4Aw4pAp++wz4iaWSuDxqqUWS/vYUN9tg6H+CgHD3NqFm89FQ/YFxExZtDNEWh6ami81S86scMMEMOANlGOo9mD3xbDsTFowFdi98Gh+LphJjT/3+OUJbiF4P8a0K7yM8Rzi2ccwRjggQIVpZMpKYEyAscHpUJv9Se9SaAkArEVYYXCE/cKaCMTOMdQUPMKwwhaPscUZtlpS7i4wo5byWYfdh+J5KN8diMLiXcAhzG7CchwETL4YXRK/2MCXHNxrKk7bHZZ+inPPBgAmL4A8D6u9oHs/90Hz/lVH8aBhdNYwWTiOXMstHIfU7LJgxAzLCcIJcAKc4ssVbtfjpwF4uymsRpB0WGYe5gKNlEHVxY/XfoyNCf0qAjHTeAofJgPChtwJOAUgK3GvNzHSbUsmiQUjMmI+jgFjWIOuNEq0q6868omPfPAmudUsrOFY4rSGMJ0qwMTBnBRdM6Al6rtjI7/ue8tcf//mp2DsDR9y96g+17ahdH2G82UGyzYDr8/tqy99bjT3fdbxtUHf55KXl30Vw2/IBU27WGlQlozrXH2xz4BN8RPo0GvStgHddC+lSzL8GojptWgamOk4GuxpJkfXT7fVUJ103YbeT9+76ANfeu8xrZiomTHNlmkgqVkqzXQlcJXi6aCZtFzdcGic5H2jT8ZeA7+hfpSD4aHQ1191H9fgTYvK6LSXvZu+97ltciYvdyjPHCDqa1cd/9tcOS8LT8HY2zV4AnhSQCzZa5sz53Sfeme4N2a5bWStcsNqDcouArMs9AGyPHKnvJbAU5IeyNkYG4FYEcEYIEG/35vwRNaAN1GsRFysa4vBxU2ZC6yAbSRswLvwQZ/cA3sVFAVUO+AbWrPkzC9Y4XnsIk9UwK19MCNob8QqLRZYs8RITZBpXzDhkDEHtIx5kZJTER7PVrQzz6wSmtIgjwvYk6ASwg04OASzB+YU4TEzWTK3gvOntLLioBAKA894mMe1awdjeNcujBqwU5Bb4B+ErczkXGgPlvhjQ/toTnvvPtJUtP4e4irCDlsHwATPIYEN20UYE6QlJtDJTKxlIjYN/iYCsiCMDy2GcwIYO8dwhmFFyQMMK4rROcVogT0Qquc9ZgrlO4XiBtjnoXh3AGP2/wE5hNMK7laB1PrfbdhT7H/V8KUGTtoJD1a3af1BEO3wd0DeD7wPZgV8oQi+hL/fwBcc1aOG/UcrdhvHc9LwLA13WHLIOSUnWF4DHiHcQ7iPr4T2SPB70B6F/eXmNgiGnEmoy4nAUiqQvQDGXNxfbEnoV3MHC49pPSMvjAmAzOLwtEg6TBSjMZGkBcQm18SS7uuvG5/rMaXdAQP7lMaRbGwifSF0kyYxL+mLprmwPs4sTZCoiRITx3RXTFo5ptOov9MPkJfw8E/DWyoMGYnbZt+3sWO5cdXnatTHjA0Z+TrtNhC2zb0pdzvU6bUBmLfBUHuJSGeYJyYqMUoJLGgQlliqVI8ErvQeSXkbJMCWQJgWa0iCFH3vR7uypfKrqtow0rVaYco7laOZIBHZELjQAK2PTcrf8bagnzVPnwtUJNYrZ780CMsFV9I71GIdq9UK51x31tsB5PXSUvSr1Yq2bXvdGvN3lzNwGvhpoJWDLw0Otykp6mfTY1e3Xb5WLo+T55W3WR6GvgP6xtpVvgfyfC9j1vrS6O+sNFaehhCegrFtQYT1wik6Q2t4RlvTV9u/1NY56bTSc70n+wyICWu7TVNpWYwtdYyJNjKxiDFBmMPEZkDI2bGQ2gZIkbL2PoAyZ8IhRTxKRAocllYMtQgrCfPwTRG1N0ZQjEFGAiNBXItplyAjwlqpORWGaWTudkXYxeNqz2zm8SXIiQ09+9TAeRHorvEBWI/4A4QDGueY+1MsLceupTDCDQ+PI0N2qwqkXLkHxY3wqPYYZAz2HLBC4QVZgjQgdolvHeJm4A0iqyA0IRVCjekc6QIYC5+1m9wa6QsNJgrhmw6MzYAaY+eYYoY1NUWxwNiaYreh2GmDQMdNMFMoboG9ASaq0fs9WO0E18TTInCNjyTsJ3bs4dQVzHzB0u3g/AHiD8AfhqOZQl0Ef8YTgRPBnHnMuadaeqbesyuePTy7CBMaChYYFsAcYYEUDVJ4ZBTa0I8CvmqL6HUoUbgDQyvgk4uilFEExobmaT04AZGwNlK06qHv2jGBlY0txPTkiAY6W8fqxirQzSHI5qhdJ1kDMR19qJRe83HIKDIpRfZjtzkNtCXjq4TmCRI/XTP29Qy5UdwHnraFISbk9ZhF7jPU82tXLafP2NsGBIeM4Jz16vvcl09ugOt8LjN2c1GP9LnveTSLlcvwwyYbt81NLC+7r31SeX1trc9D7Zg+52lzqfr8nKtR9gl15Ma6Pudspq5HH6gaEuC47J3l8bf1EV3fq5Yz1OY5IMo/5+/hOmP1OoDt9QyXjf3rft9sm3DZlubNEJ6CsW3BEZkx6awuPSmuDazX93UHY0tjKyMmsl1mjb4krfFS5mJXqWQ8+ng3aPrRxY6hw142SPCnEsXjixYhqCX6ArwXvLQ4EQoaPDVQUEY5j9IHlklqh1+0QBFEF1obhDycwwPLYkRr4cS3FHhKG9iaHQPlQSAtzBKKJdhlA4/uQ3NOEMQw7HKLd3LAAsuChj2EV89hWRuax5bVSPBHcW3RwsLhDrzzfTBZBKBoj1j4u7wGHNsFwiP2yhXHVcAaN0yQvj+w8MKLcOtOAGLVTWAO5bPgj8E9AHcXZOlp7s+RpaE9m+POS6Q2+PMScRZxU0QSGNthE4xtMmPh3dQQhfDDWjGHKeZgGuzUYXcdduQpDxvMSChvOYqDuC7sxQDG7LvAHIG/De0LsCzhS5MgkvF/PfxhCw8c/K8VnHnLq6sjjptdnHsOX0cKzX0LyDNwbw9e9YG++n8DdVV9vqF6teVm2/IeV3OA5z047uCZcIrlSwTXxK8AJ8j+OX4f3BG0N8NasfkOzKsABh+1MBPDzJcsvcW7SfRjHEE7Cqht2cC8xaxarHMUPuwtFqRiHJ4aT4ujwdHire8EPV0BYg1SWCj0jmTEQb2msNJ4CS6Aa+EOyb4A1msq00DKz9qJMB/felJEf388+Y/j+vvIYCTCs/7lEZeEmusnfArGvp4hZzm08ZYb7V+tMTKUfoiBu0p+fW5ifTP26azXgCW3twQqErOVZtrTua9uiRVLQgspfmKQckl4zcBoIQ8NOobYscSuJMYtbeCsgUgfI5HqVFUVsGbN9F5cuk20/H36rDeL1uxOH0DJ21uHIaO/r79p10TNghmzdknULKfun9otMYl1JIZqtVp11/Rz6Hpo5lMLd+Quin2ueKlsLdqR8sjFUfLNoIc2es5DX/r0bnWb6fbtY5v6zrodLgvbWKs83usFYvq+JzTbeJ3wFIy9XYNXjFg2Bb5e55W/aMnOQ2HNbuUOR8PpTc9twwYYi5fWEG0dWZCeXDfZsG6TagxEj0rNLIRVaEGtLoi1m8750QA2frHSSNz82URWo+yYDi8FrVhqH3iflYXaQmGDR5p3IDsgU0I5dhGN4uCiVzJlD0cVV2itcJw2BVUTBnf92AX25KEN24FRQHMI1QS4BbLEmSULt0cjhofulAU1e1bYd9BYuB0Zm6PdoLhIAaYGFmFfNDuJoBHwC0F8iywA02AkPDLL0L5e5mHdEyPYAGNFZFEUM2YkgrCWuAUyGIcpFhjbYkdQTMGMA2NnJ1A+Ez6bAyieC2DM3AlgzN0EdyO077ELSoX3BV5zAYzdd3DuDKduzMLtgjsMqolyCD4mnhXwUMLxyGOOheLUUZ07JjgO8RzgCJyjx7ACzghy+zMwM6Rq8FPwO3Ep2CTsGV3buBF4PFqxOMWkBgGYsD0CbRMk7Z3H+LXTbeh7axXFxNx6JHS91H+Tqqm16Y/BsbYeMXrkqFHWa4OqsdQNnHQnjStd1tBn+siv3hquoaBRZ7Uxdfa9dbXwFIy90YM2Rvtm21+PGe/rGDHasL5q2VcxrPrYIA2WdD6XMWQpbs5m9IETLX4xtM6s7/l1ORoc5ntr6WfLn1Mb6lpsJMXrU77LDXSRTaXE1F8S46bjbWv79Czb4qRDC48MgbE+lzb9LvI9vHKWK18Lp99p35qvXHwjf1d9DFcfaL1svVh+DE02DLkU943Zy8ZRHxC7zvi7Srzr5LetjNcL8D0FY2/X4NVZNuUWcmZs8xwtKUmMmum3+zb6p5CDJbnwf0qUffFvADuye5oVC+ckDNIlEFivXxIwRTRai0CSFR5vE/wKq28sTQATCMRtdm28gnO4uoVCgl1XG6iKIE8uHuwUsQWLYoYVx4SwxGtXYHcSohYLKGcglceeLjCmwTSPwFVRJP4mwpQ73GLCLgZHTcussbz6mmV+WuBGgvcCx8DYwt4Innke9qJyhPV4OWPWVqzklJIzlpxxwwYsd2iDVsVDC3sl3L4V1pHtjmG8AB6CvQOygOIO+AUUj8GdgCzBPQZpBL9soHaIa6CpQ39wBaZDCWaDnZHCBTqy8JiqAesxO74TEikOwUygvB3AmL0dXSn3wb4AMoazo+CWeDqJ67Ec/J4LLNTnW/hCC+duzIPmiJUfU7fvAncb/AvgvxmaXXhtL1CEfwB83mEeC+UXHcW5cOfccYOWOzjeiWePlj0eUTIH7mF4DcwpMjqFYo7fb3BHAes1+2FvtzO73uD51MHCW1o3AanCXnHtGNoyoOMaqD3ULaZ1FLgo2hE6sY9MraelpcXR4iIzJgUB6Vsb+rQJWqABkBHHqSjSS+9PpuTxs/G1Cc/6vhUki6unRzb/bQxvnWhNmsZD4og3HcBLddbJu1pIGHLXCw3XB2NP/f+/nkG7r8FFRiw39FPIwYo2trYBmNwIelKjqA8EXDUfzcBoZgzWwg2JQcoBWwo5o5GuaWasD1gmlkxEOhVAoBdg5IxPyjvd0/XvO3LglYz7tDZMA0W91kiDMi2JnxiI1C59AOUyF7ah+31g7DKXxJSXVrhMdUpr3TSr1eeumAPvHMT1rcvSIU+b1qcNqS/2gbw+tcYcKOp+oOOlkO+vdt1x9STjKI+f94OrTGjocayPvgmG9Dm/NrS27rI6PwVjb8eQxtTaTlaMWD8s2oBGGwbUepZ8I4XR8+5rsywt8e+HWLoGa4tNNv5a12kTkKk6pgRJLrFjx4rw2RYgglhwRfgCaY1DJG0+HFSfbNj6mQJDgUG8g6YNXmANAYyNyrAZmQgUU0QKFqxwsmIMPI5CiLcmMJkEF8V2DkXhKaeLYDjLI4xL7X8Tyz7PsMshUyyehpbjxnL6mqW1Qm0LfENYOza1AV1NnoPdZwhyfoKXE87bFvwjlmK4zzmHVvAS3BTnJTwq4XYViKIpML4NEw/FI+A+EMGYLME9ysEY+NMGWQI1yDy2d1DFxyQvuI65IRBoJZgRMI0M3EFkw/aDO6KJjJgZBzBmjgh7XD8f1mKdFXBq4a6DL7igmPi7TQBj/7cNboqNGzFvnsH7PXDvBf88uOfBvz9IHN6t4JGB/yvweY858ZRfcozmnmdoeRHXgbEJLbs8puAxcBfhHtgZMj5DqsXaRfEA2n2oR0Gw45EL7/6khUYMzkXarE1grAj0WQfGHLZpKcRT4LtREkQ7alwHxtyalLUGsUUU7ohAjHQWNQb0mFaDf4MZ0wBMA7FcGEff3xyj61GpRz5hAiQPXYI4drIb+XdQLxi79m9RcD++XngKxr6eIXfT0kBF/z0UciP8MnenbczCdcKTAro+dzgdtNtTcvfqYxz0/mFagj6BhlyCXueRwFjKQ7uJ9bFV28BYSqP/TqBLG+v6fgJjifVKZ73/Wd4PEiDaBsaG3v2295zu5XuKpbNmAnXQzGOqhwY+Q8qJmpHKmaz0TjTg0SxV/ix99dDuiTqPnCXrE+3YJp2v660BW+pbfUImOZgbCn1gqu9dXSWfobxSGGq/oT40NEHRx2g/aV2vk+bNEJ6Csa0hn+FeuwL1wSGdwkg0tCReTeiss+Q2zTk9+7423PQ1XSeztrSUKdafow5rINYZaz5aoKKfUR3Gboh4JCVwLx5HS1j31JIcxiwWI0nAIxjPVEXceyyyEq4EPJ7orogwt4K1QWJ+YsCWwavQtAE3GRFsu8Kszglb/J4CQsU5hjG7TLhBgQVuIljxnC0M58cGKQz+gQl1uGVhbGCyCwfPgExAHoFUOO+o3YqFNDywC5bimJpgpa9sEKXfjU2/b6AawWgvbBpdSnBfNJOguuiXwC5IHcCTLEFWhI20EhiLEn/GRywcMXACY4zATIEq5ME4MGM2AjO5BTIKHphuN+CXhFte8XAq8KoL+4edebjnLCfecOYm1H6C84eIPAuyD/IsyB2oj8ICvlkBD4GHgnnkMY89o5lw5DxjhBsINxEOaJmwYMQSyxmm21fsHLELZOKCOv1OJLtGsLSwMkF0cxGV6tu4r5i46M7qirCnWGuCa2ItoU+1DnzYViG5JvoOjLkg6xKl7KVzUYyd1mTMlZ4skWxcbIzJTRCmh/JmUKl1MZJyWX+fXIRVWdBDewP95fUMES9ycRevPA1vj6ANn5zdSaGPEeszWoaM9asabUPhMgOpb9a9L38NljRLpiXmdVm5K1xijrSyYm5Q5oyVlrtP7NQQE5c/T85o5vUben4N1DTTpEG5Bj85eO1rx8sYEB1v6F4fM6aBRR+LktpYb3idA6htrElf39DATKfT9defNUgaWhOWg7AhdqxPYETXtQ9E9k0UbHu2vjYYSrttDPal6Ys/lFff90ae/xBL/DRsD0/B2GXhwqbPqqN14IwNN6HODEodUHott81i0CZakqJfSwdsTnkrgw9YM17gJbhbebMGirLBinlMhFAIGOcRMcEvr9P4UAyZAbGe1obUZcBRtK7F+GAQr4UoKgoKWkdABQjM6gD4yhLGVSjHTMGVNMWMtqg5844H0rAs4IYNbIbbgepWIEmKBchMKN0JZnYOrDAywbDPDhOCBt8NJow5wwCOYxH+8CE0J4J7ZKkF5MAEI//YwHPPwPQmjObgd4HHtHwJxy1qc8q5/wNKO+deU3O7aLlt4ZUqgLF3lmGP6Rt7cHsPxgI3fTgXMyjnwBL8CdCAnIa/ZQUsQPRezqLAmGLGTFxiZqYEliyCMbMHZh+kCiyTK8N+YWcm7ER2z8BC4IstPPZwN7kkiuGL7YhzKWnci7T+BcTfQPw3g98nyNc/C8cFfL4I2hv/r4MHQvElR/VFz0HreV/TcoDwfhwvIuyw5JDXKJgBX0K4D7yCmK/gR472Vovfg+YZqG/BfASPS1gA99twHLuCRVvhZIS0OyA7UE8Cfbb0cN6E87yGVYtxLVYaLIKLypOeFcIKbzxtEdaKtUU4sCb2ZRsObJxZiAPMhckD4yXi4TX6CRBKc1isx2WaaOl1UdwYoArWiRqTl8CyDvWtj82SkrtiXqJReenPVw1PmbE3Q7jMiE7noVlpDSSuW1afcX8ZE6fZiMtcsnL2I4l0aCMxF4TIjfzcPQ7WTE5d150gRFVVG3XRa520Ma0FNFJ87SaYuwtqQKIZmgSsUp7pes6upbYCNpgaze4ZE9ZjaQn5dK2PJbvM0M+BzNA1/bdmyfQ1DZI0qEnPkgRR9CbOfRLyef/RfUOzlbkbY17HHBAmJk5L5zdNs9E3dP7p7+Vy2cVPsvm5FL5+f7quyTU2dy/N+/1VQKlul+u4/OXMlAb7OeO+bdImL7ev7+dlXnWy5rLnvW6aN0N4Csa2hoRortqBNK/FenZ7EIytZ9zNwF+b1Rk29vrSyAbjtWbFQuxoxKW6bUz7p7zWJh+RGZMIysQHTsLgsbgEBUO+4gPI8z6wGpUPLoptRBw+KNmJCUeLUHtYmiDisCJI3bsKzCgAMuPBVw5bukA7uRlBUn+OYcGYKbuxHgdYPDBtDePW0MyE5lQC6DwhIKr9Khj8pgBzFJ5PzhF/ijeG1kyx4jkm7K9mRNiznl0TPB5bQAoYRSZvJ7ZLVQTGjFV4VFrCkrpVPBbhWXI3RRPbNmLajhmTCMZkj0DNTYH9oGux2g1gbBZZsDMPD9qwafJrDh47eOAMj5xlJgWnfsxCRiD74G+A3Ai+l7K39h9c+rCA68TDCZgToTwXxgvPRIR9wlbWQcbeMaamZIFljmeGMAuMmK2R0ndiHW4chRHLYOqviMIdHhpv8N4iEoU6fBkRuQlHExkx54MapvexV/qODUublHs8YiWTs9djRB2JFUvISoEdPWY0YNoYJkNAzGyORZ3LJvQa+JFI9dJ/K1A29A1wMahJm2v9IDVcH1w9kWzj0/BVhG2sxbY0OuTGzTaW5qtxL3qS0Meq5EEb2ilNMixzwJeMTQ0MtIS8djHTzFdKl5ixPhZE13GIadDnHJDmLGaeVgM63Tba6NXubin/9Ny6vfTnbWBsKM42djK/r8GPZpa0W+nQOrBtfXHbcVnoAzxDIiFD8fL4OfDMy9LnbezRdZ4n71P55zxs61tD+Q2V2XdtqJ9dlv464SkYe7sGk2aqoiGVOitr4yqHQBtdUIhugKbnxsWQM2Nr6YA8RTL80lXbpfbIZp0MID5CrzhDRhTaELo9m2hcYBAKnU7NwRuDWMFHgsHFjaGNtFipu7wNEWC0sRbzuN9WaaAsotbHKAgqlLtQCLVdcCw1Sye8ZsPSICxM9mBUgV2GqFIHAGTnC3j0CtbtYJhgmFGx4ICSMRPezREzRhSEXb1OF54vfRlW48Dw+WPgJBr6eyN48Z2w9xyMjmB0G+QE3AGec47dayzMYx7ZGffaR0yM5yttWH52q4DnSphYeDaCsj0L0zGUFeyMofAwuQWlg9LDqAUj4W8rkYOMeNjH5m5t8NBzFuoyXF/GPblWZZCpb0zATI0PqognEUO90gbRkS9GYYy53+PMHdGwQy3Pg+yCvBN4B/gDWL0rqGm8uhs2H3tF4Hc95tRT/r6jeOy5M3c8J44jhP8Hzz6eO5xxyAzLQwx/iHCG54t4HuB2z3FHgt+F+hlwe7C4AYu9sHXAvRZmAg9qeNzAylVIGzd4bnfCeVFEP8YWzmtYOVjW0DQYcVhcZMSC8qQ3Dd644JoYtyUTm+ZRYt9PfrZImBxo6FgxnISNy0lHEvFIh++GQ8JKm4AsXzO2HqMaiKmfaXWHi98PegKoA4yb3wAb8VWuG98bhoj0r/ODtB7PVw9PwdjXM/SBqnTODfy+oJmdqxhzGuTkAOmqoLBvlj1/lpxNSob8UP11eg2k0rPlgESfE/uR5OC162BimhJ7lcBNURSdbHx6nsRupXv6OfRz6zbM1231CVz0talmIjRrlurWNA3W2k5kJBcLyds7D333rsJm6PbTfaNvE2rNNuWgYxsAy9k1nYcGRH156nVb3l+Uzm/bdoMZ02vX9HqvFC+dE4ummbGhsvM+n7PU6ZwDvm2MU85kDbXh0DvL351u76H3kL/zvrHYl1bHzZ//OuHNAq6uG56CsW3BKMNK1oZTgmHrK9lMEdH2EenSBnw18KXWoaeUbzLVtMNUiqjn7vU5qCVKTLA5L68/G2zM2xNcGsURjNLGBeutsGsWLlmgyQi18XEsYAXrPUgbyy8xFBgxGBfZslUb8li6QIN4Ap1UGsLuv462cMyMobXCSVTI3hvDahLKG+8T1k0dgWkBWyPHj/FujuU+ACUjRtygouUZ9jigYoGnQRg1lvsPPb40+F3BJyGRPeCghKPbYR1ZMQLZAU4IEnRnzCmYYzk2lnvumJHxLDwcFgGMHUtgxR7H85ENpNvEhO3NKkIxE8JSMGEtHZFD6vSuW9bC9vP4+Sz+PSOwYCuBh259ToqEr9TBTfFLbWDGRMZ4fxPYB94NHADvBL4J/F7YhKweBUrtVR+2BfuyhzNPcc9TnjgO8DyP5wjhOTz7OA5YsMMpwmM89xHOEB7geYAfO9wNwU2hPQzClfU0vM95CycLOG/hrA1n74rgnuhHYV86XwXRl6WPRxv6UePABRAWDo/EfcUEF9aKRfVEUWKJdIDMKIXUCMg6tk26UXQRiG2OJpGI6TaAWD62e2Yhu5z0dE5PyC93hcrFext5i8pfg8XrhoanYOyNHbRhPWSA9jEaOj6sRSN0uGxmvK+8y9wU8/RDjMu2Og6V0ceM5WWleLlsfDLotauhduvT7aGBRYqbgNyQgEbfs+fPlEKfS16eXp9T/JSXBo2pTlpZUsvqp7q+XkH3Bw2idZtpV78hkH1ZGX1MVV9/HKqXFg1JYCxXUdQCHvqc3BpT/Dxt35qxnPXToY9B7HumFPeyMXYVkNKXRx/IukoZQ23el3dfnCfpf5eVN5TmzRCegrFtIX2hegn0hd+YJ1dcUE9HI11Ws9wi6+iymVa6yevkhtTHuWV/C2tbq5sGV8a9mhBPMM8oefvEkBnAO0FM9JdzJtA3EGfVwxEwZXTlMoEh8wjGh8VPYd+xFgMUWIwYfO0QMbBoAghrDYxsnOmvQEYBMJhxAGWuxeB5XMBeCzsCo2mIauYBjIkRzJnDrhrM4gRawVJh2AP2GDOmoOYmO9SMqYBjWs694dGpYSbBaHe7Lkgm7vqgs344hqOjQGtNGijmwbJnD+Ex4kc4U3MicxrXsCxXnMuSsRUeiWdi4KiAfRvBmIlgzAQPwzFhl7Eifi5kbcqHPhXOtQnmcEMGxiQwSgmMPXLBrfO4NZw6y8KVHDc71L5g6aaIHyE8A/IisAfmvSAHsHomCHUsJvDQBAbqix7uOuxdR/Gao5x7btUt0wjEnsOxj2OPOTvUFDyI4Os+jtcQM6PdWeArT3vkaY4iCNsPZNdZGWXso3Li3EHtSrwr8G4clD38COoo3LEQmLUBiC0DELMuMGIWB90+d0EFxRvfgTDftWWaULBqEWUcfG1kxLysGUo2gdh6rVj8l4ZxOq9Huh718YYGJ7IxVHPYtN6OLM14EMZfjtLJp2PWeSQOzm9Gj2sRzTWxUpM911XCm+MH760ScqCQQjLo+sBACnptiM5jm9ta38x3fu8qs+l5Wl2ndM4NT11XHXeboTfkBqiZKQ0UUugDY6lMLeCRAFxiThKLpvPJn2NonVy6lu5r9cU+2fq8DTU408+awGJaP9bHsvSFIeP1sviamUwgJK0LS8xRDjbyvHNWNAdQGkjlbEsOBjUb1qfW2Cdj3yddn8fvS5uv8conRba99z7wlq/F6usH2yZedBlDbpB9rrF5/8rT5hMf+nrep/Jxl9dT9/erhqdg7O0airgQyHjwNoAVkQ27RvNU4e/13kdri0gBsngr3RMMxkiIoiJozLb+K6Ir3bc6EJbMsRC8Wbu/JY4tuSpalXMZ11e1zuO8D4ZrZ5lGK9UHeBUUEAPjZYpg4+EE51pMlAMMIE+oMHgR6mWN1D5EFgM7BVTjIHU/nkBlkFJoWSK+5XExY+590A+xsF/AzkHUupDgwVbuCNK02IWHe3eR80cUrGJLHbBLSWCAbrJPya24uu3MGz5/X3APC5ozwS0N7EXp9BvAC3vw4h5MHdy5A7YB/yzIayCP8fI8tVnwmn0VY86wxWNM+YDKOg7bhpGVNRizwZXxawLGfFAgfOTC+awtmLsScbv45llEJnj/PCIHYJ4BE8GYfU84n03g8Tisn/sDgXMPv9/C3ZbiYcv4SzXT1vMu33ADz7sQ3oMwYclNHlCxQPginleDWyJ/gC9WNDfmuL2G9hmonwsgbHE7eEE+qOFuHYDYaw0snWHWTGibEbS7gTpz1dof86yG4yYwYrMampbSNZQ4isgbhs2do5uiJewRHecSPOAlzhiICR3ImOiWG1ng2gWXUZ94XenAWO4knACTV3hpY1HaJkLbGOgaLCX4tAGWdHRjdNL4WdSRvnMMRhWWSkq17sCoNeF77OmezG+poEUk+taowMVZ8KsYckPGY244DwGw3GDrS99XtjbGNdDURrWOPwRGYc0U6XZJ+es9vOq67tgjXYZ2T9RtkTZfTtfz+up8tu2vlbeBzkNL5idXSc3a6XR9DGBi7RJY1OIeaU1Zn3DE0LvS4bL4WoQjgSjt5qeBRg6+NfDNgZRmpfrk7nUd9HvUQCrVY7VadecEquq6xjm34bqYykrxNRuWC36ke32gIx+ffW2mx6QGq7p/Db2zbUAvpb8MqOX1zc95vG1gLO8nOUDOn+vNApS+HuEpGNsWjAJBaaMx5bIoGQDqktEzT9xZZOqubN7aiNZ3daPjRoCX3Ak3jjhYkl0n65zW8C6As8TuJSIML9Edymw+jIQ/9DN3HowmlRGEFIKoRzAerQjiPdJGMY/CBFQBwVWxSIINFWKCxLmxhpWHuRcKC4tkU46gmIDZCawLCH7cYlZg/ALrzgCD5RywVOwwYcoUywElBsue98y8Ybl0uDOHF3CPfQSKFnajDP90HFRE7B6hAMDOQRZ4VmAqnAF82GC4cisacdgoIrEQoRVPZWCBZ2SEETAR6cCYXqOUDGhPAGMtoRoLExzyZmJoMMy9ZeYNKzGcu4JaDAs/YuWqoIrob4DsgNwGOQgCHf4ImAaJSpnAaZRgPJGA6M4Fe+IwZ47RwrHbOnadcIDnMAp1TGgZs8QywzDHc4ZwhjczfFnjqxo/8WH7tiRjP4FlEZ5nQRAWWQisvKEWi/dFcEn0ZTicjSjUh4WDjYPWYZwPWxuIKOZqzX9pPNTBpwRstIKHsHb1i6glDeu126hGQRpAoQdRFow6r0HTZpDs3HclXVDjWIYjSnZx/bfZrNI13UEMLWb4YXvDFqfLp+FrEC4DWSnkf/exK0MAaij0xesz6C7Loy9ebqQPpUkGfZ+BqGf8t9VVgzYt5pHyh02AlZepXdJSuhRfg8H0d5/xqYGJBjPp+bWb4bb2ztsl5aXL1XXP19INAe++d9OXThvcqT3T0Qeo82fK+07uitgnI9+XLn83eT76nIMEfQyVr//exoL1vaN0HnruPmB1FbfE64y3vP2H+tZVyhwav9u+g3SZT90UN8NTMLYt2NhZPECcYRbBO4lG3JolS8ZLr2HV+SEZBcguQjZRVy/kltJ7CbP71qyNLJ1NNrHuY3Eegsph5wRpIhuwFpNDwLeCF79W9VNS94IPyvQETOUTRi2J9XIgAeSNqPAYcC3OCG5haVsTrHNDdFW0sLsTM3J437AsHTUFtmhoXcMegaDatfDsLtyaQjkNdS4WgpiGYrelPHsAxzVG9iAyZCPOKVlQsYPhJnNKKhy3sDyalbzyFUc9spzPPc20gFfLcOwCL1qYVnB0B/aPYLKEvXdAUYO8ApyBHIM8wJsV5/4Ea2tmxZyiWGBNQ2lnWBwFCywNhThKabDASNbkYwfGYjdJYMyZgtZUCBbHDp4SJxOc38FLRdPu4X2Fc/thozG/B+5OAFzyAsg+LKZwvhuUQB5OQ/vfE7hfB9WPLzSYuWf62orJacuNtuVF17CH55vx3MRzyCmHnGA5x/AFHOc4voDjVdxkSX1zhp84Vt8kuEOob8LyTthP7CsGZg282gaFx4WznLkxrStwzT40O+FYTYIqyXEbfC/PajhtML6lalqsOEbiKIMWfWTEPFL4TqDTxz7puj5tWO+kHUdWI+AIMvY+tH9JWsen14o50pRLylcP4zCINNBL3xWiJjQSKMsB3sXvid6fi+RnvPZjHMhDcniK2Lju09r199gVg31CMPZU3P7rF/RGwenvHGTkM9WXgajLwEsKQ8ZbXrbOb4iV61sPptmSFCfF18zWtln9oWfRACkBhSTkkYxrvUmyftZUdpKUT2ApMRcaTKW1ZPq9bNuPTLNZ3vuO0UogcTQaXWBHhox37aaYnivVL99ouu8d9xm8fSA5BxV6rVjuWpi73uV56fciIhssWGKnEoOVr8vS716XmeJrpusqboqJAUtsWTqnNKk+fW6KVwFkfeNz27sc2uS8jzHOQx9YHgp9dd0W7yrfFRrYpmfSLO2TAKunYOztGBITZgkGkZptTnbWGkDlLzwzZnr7Q5byIml2MQibhXfXlWGoLiVbLkyyi86EJG9vCevHLIAPzoiIWRtxqR2UY1T37NFINZYgZS8S8wuGbRGZAt968NFcW7gAKHeLsO+XLYPuOQbnK5w4lt5RRnv2xIelZgdVIKvw4PZBSij2PLRg6yXeCFZahEdAS8EuBbuA54h9JhiOEVo8voXH5wZTWuZFC5MIcK0JfoVlAVMTaDg7AZnCzh5Qx6Y4J6C2CWJWtGYHZEXNKXAe2DQBImgggljrHRYJYEwBsgSYheA12QJiLN6UYAo6CRDZBYnKg+4orLNyR+AOwj33TIgrz4EcBBA2Hwd68YGJm5F5eM0Hf8d7LWbhGR23TOYNezhu0rKPcAvPEZ4pK0acA6fAI4RzPI/xHOPLFjdt8VPB7Qd1/HYPmmmQrz+rg+T+mcC5wMpbal/gIxvaad67Mjz0qo1iL9GN0HsKH5jWIvYriQysEIBYtyWAYsZ8N4jM5g0n0IIRUaxY2rJ8Pcgi97vpiYg+D4xvYc2+DQCxjfHJQOj7UtgY33KhWH2EBzP92iKXhKdg7I0fkiGnDXzgghF4Fcbr9TSIhuqi663r1Rc/xRsyVrfl3/dMfWVqINjHjOlzYrvytH3MmF7vlUBdvgYsr5+uWwJO6X4yXLVCZJ8b2BDToVkyXVYfmOkzsnV+GjT3sRp9YCxnxvI88z6q2ag+MQ2dX9+kwDZGLWfWckDTx6RpgKZB2xAYGgI02yYKhtIk4NLHpA3lu22iJC8rlTFU175w1e+KvnJTeZf1o8vyfQrG3o4ht4Pyjp7d7rvW2WN5kIHPGWHWW6KPEYzvmfU20WCUDoh1YCxSYMnNKwDJYGkW8ZzWZokPoh4IETEksBcZMiMdyWeKkL9xqeJJyEOoKCmJe495j2+gnbcBcYzjmrwJwf+QMuig24pGSmYSJPQf0HIuQumD7PtuCbePoJpGzDMBKofxNbYGzl/FtsfRXbIG9hnhsEx4jkN22WEfj8Wz8JZ7c2FeF8x8y+y8QqYWf1LAjoHXgBsG9gRuW6gq2LsJo12YHgVJ/KIGc0IAamdgZsCKsNtzCxL+FqnxfoXgqb3DSti/LAhFxO0DAG8LxFjEVAEIUoDZo9t4TPYCCPOH4dzsh3VXqwrOpgGxzqawsnBq4GEbwNirAnMw9x32oWO09Owf14waxzNNzQEtz+B5N44dWg44ZsKKgtfw3APOEL4YxDp2j3GTmvbQ0zwnuB1Y3YbmAE7GQV1yJnCXgP8eS8FMCloZIX4/ArFdcNGX8cwF18SzAMaKlaNwjkI8IwSLj8IdQWsyALG4p1jU52hRjFg3eswahAkYF9jcQgwlayC26fro18ArHokZ8zrfFCGNzQ6IpcHWN4YvXhR9MXcPTmNduzdn4cJXSfquSpMo1/zBC9sGXC+8OX7u3jqhj3XKg76f/r6KYdIH6PrK1/H7QM5lRmRf/D5XuG3P1vc8feUOGcDa/VCLeiRWSa/XyV0Y82fQZac8NKuhDeacOcwBht7/LH3Wm07rZ83fc8p7iIHR69KG3l/etnm9NUjoA7l9efaBvRyIpWdOjFRa06UZL/0Oc2YtsVqJ/dLMmAaHfWChDwhqhk4LevQxYUPgawiY9I2tvv6vQw5ah8Z0XpecmRwa13keOVjL2eht6YYAZt5vrhOegrG3c0g2UGfcsF6qxTDY2jSw9FWzeb0vA2V3rWMHgx0R8J4LRlaHjExnF0qc2fep+pJm/6PBiE98WFRVDNAs2JOCtCE9BWF9l7FduV7AmcAfWBvYHaxgvCC0IA0GT8UIsAGMicM14GYtUliobMBtzsLOhEB5eSgmNN7SSEstLSKOMYHJqD0cVbBzAyYuGNcyBSk9xtXYeYNZNhRtgaUFFhgOGQMjpjyP5Q4VBxgqHDNvqGaeMyz3T1tWrzj8xCIPSmRi4RkDN2zQp382KnM8eyP8fcNCaaFyUMzANMA5AX7U4M/CtQjG8DXil4h4vF+BuGi4p5edXMtGgS00Fdgdgh/oXvg7gTGpIhiroJ3Cahyop3s+uPkF7ATHwP0ou/iqhwXYRy3FccuOOO7Iiimeb6LhJo7bCO/CU7FixH0spxjuInwF4QzHHyJmTrvX0N5wNEdBrMPtwPIZaPbg2MNXJGxGfVfCWrFzKZnLKCBnvx/EOtoptOO40XSb1Ehg5SmcY+Q9BY4xPvb/Foky9hiPmADEpCA6L8bm7EBN7K/OROVEg5WwPrLAhC3vIErYaCAmIW8TPGk78Y44xMJgUuM6jeE0NhMgI63NXMO3jUGtQ0J9iWomFUjXP/SET+9ZfT+tgVhPWZeE0UAVtwUhMKFPw9cvaCakb0Z8mxEyNIM+9PdV80jgQQOLIeNLx++brR8CY0NMgi4jP+t7OUjQYCx38UvgJ78/BGC0kIMGLSle+jsBqj5jPrF0CQDouiT3ReACIEpnDZjy97CNJRwCTX1sRq462demOes0BFx0nASakphGAkQ6j9yg13nkrojp73w/siGmU7sp5mBMM2N5HnnfHAJgfZ/7nmcbaO878rCtXn3vdSik+Fed7El/D43RbRMsVwlvZTB23c1kvibhZ3/2Z3n3u9/NZDLhQx/6EL/5m785GPff/Jt/wwc/+EGOjo7Y3d3lAx/4AL/0S7+0EUdE+OQnP8nzzz/Pzs4OH/7wh/k//+f/PFnlOktHvVA14d793ZPkwsVu2ro/YRelJ8/OvtIWmEi2NmUds1uqpo+4TCvOe3X/UuJURjBhTVBITLf1gpm4gVMyTjVzEJboJNM1HEnQoyQo1pVesF4wjYc6MiJJPjC5r/kRyBgvYxpKVlKwEMO5BMxxBpwbqMfBpne7gVTz++D3HH7q8NUc4QThGHiM4TE2HhPOOGDFETW3aLmN47Y4npGWm67lYOHYm7WMTxzlA4e97+GuD+zSXdRh4J6FBxU8HMPJFM4OYHYIy5uwvA31HWiehfZ58C+AT+cX4/kFkBdB1DX3ArjnoX0WmjuBdlregtkNONuHkz14NIaHI3itCPW4a1S9BO56zGuO8qGjeuSYnjv25y036pbbvuW2uPDcOG7QcEjNLnMKjrE8Bh4BjxEeI5zg7Tl+p8bvOtye4PZCu7fTsOxrXoT3ckZ4RzNgJZaaEicj8JPgXunjXmKtDZunNRFlNx7rhMJ7ChFKJE4ShD4UgJJDTGDELjBX3RhSA7QDNJEDFjqXXDV/HseDGhV940fPn+RBuybG8agB2FYg1hd61Rl1ffujb+b/5vgReqOGN/TvEv2G3lXS9MUfYqX6yrtqGX3swLb4QwZ7bjReZjwO/d1nnOb1zcHEdd3S9HMMiT5sYzX6wEHuspevcdrmbjcEkIbASA7MLkuzDdhcll+fG2CfZPw2AKLL7GtvzYT1uWbm77/vmfPnGUq7rY/3uQPmfXnb5ENfWX1AaWji4qrx8zK/2vBmAUJvhPANZ8Z+5Vd+hZdeeomf//mf50Mf+hCf+cxn+MhHPsLv/d7vcefOnQvxb968yY/+6I/yR/7IH2E0GvHv/t2/4wd/8Ae5c+cOH/nIRwD4qZ/6Kf7RP/pH/OIv/iLvec97+Nt/+2/zkY98hP/9v/83k8nk6pXrXIRk80jBZOaOxkSaBUsfLygAbMa+kNKwYdQFoQfBe2FjH7C01ilVKubh4iVrNo1CiyAulBIcEy2JJQuiHma95qazMSWUVVowEh254gaasRpEuXvvPMYHZqygCWuksFSUtOLBOZwX6hm0dWQSxmXYeHm0E56tLMBVOGpm3mBNDbJiJg2nBAJiCrzjEI4Ogp1PFUQ9TOHwc0f54DV4/CiIesgMmGI4oeAGBxyxw3M0VNxCWFDxEMcDHIvG8uBRy8pYjh8WnFtLPTYs9gpkRGDI9kzYVOy2hE3FnpmE+h/sBdZsJMG1sQDGPuinGw9FlJeQFsTHI73kyIy5uE7M2whOTXA5dCa4G85NADGPCedHkVk6l6CSsZTAkJ0L1cKzM/OMvHDTOSZeOHIth7Ts4XiOhgmeG5yzy5KSEyruYphj+DLBNfE+3txDJo722Qa/I9TPCc2N4CG5eA5WJbxi4MTBAwmYdSWWY5nQ+BLv9wNadqNAnzU2PMeMsHbtpME0nlHdUrSeMZ5x7GMmyJngaPA0AYyVYTg5u2bFHCDGRDorzjyELfCwPjBiZezjAeSlnr0GeuA7ti2BvE4UpBvfZn0k8JVcen14n2GLBz0iN4Nk5y7mhvpj/ALocVFMODN9rVyYHJI4XvPvrCuETrfnGuGiePObO7yhf5fod5VLhtY2AHJZGFpDovPWTFZiSYaM1L6Zd/13vvZHG4vbjMa+Mofi6jjanbAPhCXjXW/snPJL+5G1bbuxoXLePhoAaBdHzZblz5rXUddHu0yWZUlVVR27plmqnEnJxUPSc/eV2acwmLepbo9Udp5XXzvqNskBYrqX0uSslo63jSHV8vdajl6DMp0mr2uKn9iwxMxpF8m8Pn3Pchkoy0POhOlrff22r8w8zbZ0uqyrTrhsY6r7JhNSP9f39PdKPvauE540zZshfMPB2E//9E/zQz/0Q/zgD/4gAD//8z/Pr/7qr/ILv/AL/PAP//CF+N/5nd+58fdf+2t/jV/8xV/kv/yX/8JHPvIRRITPfOYz/K2/9bf4s3/2zwLwz//5P+fZZ5/l3/7bf8sP/MAPXL1y6SX2vUzdj5ORlmyf3rxMB662TpNn+W4mEbo9x7ppehWpJw8hs+nS312aYJCm/NeiHimr4CC2ASgVsktGYRKhEBswR5C4N+TsmMS8RSSsMTM+MCONBCTn4gKgxI5Z8FLixbOixUpDRbDhxQQQ0Biw47A5tDHgd8Pz+HGDLRoQi3FnIC1hY2hLSUHJIRWehjGjCEs9hrkUNK1liVA3AQqY2tC2BjcCqUxYEtZ6RExY82biGjMfNy0eE560JBjqJVD4cCB0K5xEAiDDrMEYRTi8CQInngDCWpLPX9j1+XEEXg89HAvMPOaBD0r8jz1mJoxWnskiAJt9HBOEIxw3cOziOKRljGOXFVOWsWVPMMyBU8Sch6NY4CvB74Cfro92B5q4V/PChXViScK+FksrJY4SZBSOTsreBtfB9O4bj2k91gehjiTWkXrYGjAF98SOFYNNxqqb7NA3TRxLqW+nPbrWkEjiZ8mTpUONn/UgigWmrPp+yNSxUb2N+vaETWR14VaXn848/zpJX0bX/DEKjsXXC281MPaG/l1iE/Tkoc/wSX8PGdlPUnafC6Aupw/YDRmAeV3zzzr9dUDlUP23HYkF0WqE29YJ9b0LDTKTe2NKr+uQ1zUHwSm+FvDQ0vd52+Qqm7m7Yp4uN+zzOuo21+m0e2nultbHiF12HhL8yNt3CJD1sW5DefT1gSH2bghoDY2pvvHVFy+Pcxk46qt3XsZQHYbqlNdvKH5fGUP1HGIA87hPwdjF8A0FY3Vd81u/9Vt84hOf6K5Za/nwhz/M5z73uUvTiwj/6T/9J37v936Pn/zJnwTgD/7gD7h79y4f/vCHu3iHh4d86EMf4nOf+1zvj95qtWK1Wq94OD09DR+SIEUymNOst8iGgdVbt42/hqyldC0YXHrtfl9qWIujCUSGjLUl1FUqfjDBzHQm2vgJt8WzSYAIT9jNKpiqaVvoImUnBpfKKKKZFpm5kL8P+0KnphKJOMNT+BpwFBgsBSWWcYRmvgXxgl8Y/Ekd1mPtRMEKOw5ryvwosEq+YcUZrjB4HNY2TBBKE9wVj0ZgbkO5jATUItj+TMGsVhQn9zFthaxW4O5juAGcUTBhjztMmTLlgDscsaLgBWBFwUOEUwrmznC89DQ1nDnHqjQsRpbZxOLHBrnVBkGSQxt2qh4DexGMjYl0g4RnIYJQJBrKsbcYv25EfARjLtAySwIYW0hAPAmMrXwAXmeOUSPsLz2lE/YXnnEj7DnhKLJMz9AyQThkxT4NJQsmPMRSM+I+hjMC3fYKmBUyfgDFAre7wu8Lbrq5Pqw+hLMC7jpYxHVixwJnUnImVVDGbA/DO6zjxs6rAhZlYPROGzhtMfOWYtVivTAWH1xZaSloEVpaVggOb1q8FXwh+MhctTa5KMaZAMV7JWrLSBCoCds5pFWSiRELZyGKgcSZCJ+WmxHnBvRI1C6ECfD4OKkha0bMkn1PKIy4Mbg39gvsCz0/0sQkWawOpHWzQj5DkZeHtzsYe6P8LsHwb1M+06//vkr98tDHXmkjPKXri5cb5bpe+X5WeXl9zIouH7iQhz5r17NtRqcGCilvzRrkDIUWz0ghbfZbVVV3LUl050BHt116P6m8tF4ssWu6jD6wqQGDlvbX7Z+XrVmzJJmv2ay+dtfAI29P3WY5Y5hCH6DRa+i2uTkOgac+UK7z0IIfelPmxHT1lQubTFqSrV8ul9R13Y05LdiRg8Q+8Let7+k+kb+/ITC1DeznZej4fXnkZQ6lz8M2EJY/k37WoXAZeL0sPAVjX6Pw4MEDnHM8++yzG9efffZZfvd3f3cw3cnJCS+++CKr1YqiKPgn/+Sf8Kf/9J8G4O7du10eeZ7pXh4+/elP86lPferiDefX1k3aOyg3sFJIs+eDtR5IQDLEIKVOeejLGs51E/EI0qkLSOaPmACewaU6m8hK2Wi4eTAdg5VAmemez0ZWrFs7tlGDaNIajzM+xI+smLdgrGDF46XFiCc4P7ZYCipKPELpPa0HVg4/bwMLtCSAsLqCNjJErQMaWtvQ0uJNg5GGsQmuiq0BU8LhBGQMTQOyiMC1ADtrsfUprAy0DbhTYE4AiTvsIBj22Mdg2aGh4oiKBjhCOEM494YHtWWJ4f5SmEUUvMBAZXAPfABjBxb2HIxMBGMmgjED1kMhAcimowvxrYohyl4Gt0Tng6W7BFoJYGwuYY3VYwcrwZx6zHlQHTzogJdnD+EA4RbSXZvg2aNlSo0wx/MIYQ68SlhbdwzcDWCsOkOqGn8A7nbYaLu9FQQQ6yOo94NIx8Mm4MOHhH2kF1gWMgogrJ2GdWLtNOwC3digpLmSgODmLWbRYltPKUKFJ+ysFiYIkmiHx+HtWrQjCWskT8TUY9fTFbZr0rROLO2tp34mEXyU7PAdEJN0sF75uCbCspHfAbLN7wZ9dNW7+LZJkyYdSrvwQ2ZQg2/93cAwIAP1A5QmbK4R0r5r1wlvJVn7N8rvEgz/Nmnj7yoGymUz8/nffQZwDs7y9DkgG0p3FRep3IDty2MIKPa5fOV5D7EeOWhr27bLp65rRILrXQJSmrHKBTU0yEv1SzL5WhGxr875u0rAML13zZBp0KhBU6qTZvnSfQ0A+4z+IcM8B2VDbapBylA7b2Oj8nL7+okGcXqtWXKN1OqLedn5nmLaPTH9rfPP631ZnfN65+Mpb8886LJ0+r488vt5HkPvsC8Mgbdt3xE67dB3hI4DDLbZZeEpGHuDhf39ff7H//gfnJ+f89nPfpaXXnqJ9773vXznd37nE+X3iU98gpdeeqn7+/T0lHe84x3rNWOJwbjsnaYJc+lS9YeBGxLzMHm8aHltmmWQ9gLq+loCd8lKM5ZkjXb7WIlSqU/Gp2fDJSw6Jl40KDvEGa+ahOpCOR4BG/CGFATWK7KJlhZPAwiWEhBKLCOgcdCubMh73tAhu7EN66fKUbS+d6D0eLNiZVvEOM5wiBEqganAxAdANrYgoTiKCqjB1mCqBrM0mOYUs7KITKKJvoehwdBQMGKHQyoqhB12GLFPyZSKFYYpwhzDCYZ9Amu4XArOQSMFbmXxpaE9swE4VKZbgyRFfFkmwekL3adrXyNgXHifRSMYB7b2FLVgG2E0c9hWGDUBiO0i3EYYA8/Ev3dpOaShomWfBRUNJecYZgTlx1cwLBDuAidINYPxAilb/IFDxuBuQHsUsNRyD9pRUMw/bwMefNzCAphLwUoMrYyDD6NU0EyCcmJdBlZsKTBrg4LiooVli20dlfjomuhjXwz9xScgZlxkxeJSOptAUhwwXgMxo2YsjJpg0KBmvVeZj4Mrudn2CXaI3nBMl+E7SAWYDTYs/znqslhXIn/zPd8Nm0BsK65SaQ3xR8hea4YICMzY2xmMPWl4vX+XYPi3aWj2HLbPZg8ZbX1p+gyuofhXAWR9+ef1zdNpw3CbEdlX15xdywGHXo+VQr4eLhnk2siv67rLV0vNDzFksOk2mNiwtDF0uj7EIl6lrXT+6V7OYmlmLC9riIHJQW5+1mm0S+VVXfyGnlOHvj6RQJBeY6Y3ck4ALWfa0t8pbl3XHQBLZ73WrM+lchsQ0/0ttU8+sTD0nHk7DgFT3a90/tvA9GVM3FUnavreyVXD0HfJdfN4Csa+BuH27dsURcG9e/c2rt+7d4/nnntuMJ21lve///0AfOADH+B3fud3+PSnP813fud3dunu3bvH888/v5HnBz7wgd78xuMx4/H44o1WO9+sZ777qbHNIBf+MuqchziwFDNmWBtumkAx6pxWvnSkHahNXk0XUWwASw7BRBvSxnsmLvgS8d0muEWUBkhMgo9GpgiIj89RFKFixoT0CE5cZ9gaA0Gpvg2T82JjnUtKCiwFY4pgvLaeeibIysLIBiPdT6AaQVWEzEoXrMSqojULZoVjaRowK05oWRaBdNkNuIpdE/YTlj2wi6ALYmuhfLjEni8xZ+fYhw8wrsJwTODYbgG3KdnhgGeBCTe5BRzQMmHJHg2WB0hcWRX0BmtneHwGK2OYHRtmJmybOzcWbww1htaEd5WM1rxnXXy36V0QN4kOyoJj8UwksEcH3lMBh17YQ5gCtyGCMcMuMGLFmHOC8Ph9YIHwCM8jYEaQrV8i3Ec4xU8Ef9sjY6G9FdaItYfQHIW1YbODgKtebeHBMmzI/YqDlRhOpGIpFfg98EdhfdhqLwDqeRXcE2dNSLhycLKCWUOBMMFRIFQ4CjyOFY4lHkdrGrzxwTWxisvNioiF0nYLtghr0aDzKzRiNtozuSeG/z0OF9hlG0Ze8nLsJO0JI34Nt2JZWuvepztGvTfp3uXGi1Xv26vPg0EufNi4NWhzJwQJa1frp+HK4Y3yuwTDv019a49gOxDbFrbNZg/Fz8u7KggcMgwT+OljBTSoGAp5vjp+Kl+La2hXxASo+kClFt8oy3JDdh7oGLIhl8Uk+JHSJOGPoiioqoqqqjpwluqtmauh9tTG9xBDkgNS3S59hv1lbE4er+99Da3Tyt/TNlCW10EDIu0+mFwSV6vVBsAaYsbS+0/Aa7VaMZ/PaZqmOyeA1rduLGfj9Ibauo11m+VuvNtYW+3ymMocAvh97ZSHISC9ra2vGvqA0WXfI3mffbMApa9H+IaCsdFoxLd/+7fz2c9+lu/5nu8BQgf87Gc/y8c//vEr55MGI8B73vMennvuOT772c92P3Knp6f8t//23/jLf/kvP3FdL3Qvhav6Z7sHEmg8tuW3T8wahOnPKVluwHdFbJRvYoQImiLc0xtBr9k8bXquc0/G5YVHkVS6UeUETk3LjUcciHiPF0eAZK7LvYiAz4oPS/IaDzbK3a98KKeJhnC391aLUOKAxjZYY4L0RBzYcyJGLMKWXaWHYgpSgllIMKBbh5k4cIK4OcZLcKuTEqgxTDCssIwIKpMtBkuJZReL7VrGsgJELLUEtb4SocFQIjgiGCOBsVw6Qhkj6soajIU1SCM8BTCJroYjhEOkO+8h7BDcFEcI0/h3yZwqgjHPKcICxzEBSs6RYoaYFWKXeNsgUaBDxkG23u8EcqseQVMFHZEVMPcwi2vFVs6wEouTEpG4NYGLQh2tXUvYr+I7rR3UDuM8RoQC3wl2JBkVieqGPjKfyXWw20LBxJYysaXUHnvZCLgwdyLqX/dXGhMKa629c9NN1f83P2yU0zesNduGGtcXI6rvie7vzbqv+0rPd0/PxM11f+7e7szYm+l3CYYZLNg+G32Vmfrrgrvc4LzM2LpK/n0z/kMG6WXGZ84g6Hw1m5TfS0ayMeaCe1sCViKb7op9xnMy3vXm0slYz8GmZrDytsifeQjY9LWXNvDz/K/CTOX3hlwQ+8JQXfvYrzx/7fqYS9j37QOWy9rnjNrQVgHbJPVzRiyfZNDv+6pj4LI2yPPuA8d9n3VafR5Km8fP412FJXs9x/1QWU+Zsa9ReOmll/jYxz7GBz/4Qb7jO76Dz3zmM8xms07F6qMf/Sgvvvgin/70p4HgQ//BD36Q973vfaxWK/79v//3/NIv/RI/93M/B4SX/Nf/+l/nx3/8x/nmb/7mTkL4hRde6H5YrxrKbr5bOiNIkM5AMt1/KlwAZhuIZ20wmv4OkoxAnZehH5BdMLYEvJNNWkXWiEiSO2E0bmENlpBgGIfarlfWmMi/pWgurUHpXBUjEDNJgMREvsGHJWxVAEWuaaH1WBxBRqGI3FgQ0hYE5z3L8xVuYQPV1/gg6tGMYFzAZAyjImRYCWIaFtayskucbaiLhh0b3B6nFm4ZuDGF8RgOdwK5Vu1BMYfiHIobYGpHeXqMXZ1RzI8pZq9gmWC4i2WCRGbMMKXiiIKK2+zhGNEwoWZKQ8GMigbLOTAnODwusAEwRigXoEYOuS6GBNesOiqCwuAYYUJkxBAqYErDhJaSmhEzClpGnFOywjAj7LW2xHMfYYHncTiqlnZ/ha8c7qDGT6L6/M2wzKs5CuvDzqtwLATu1VE5v4nuib7gxI1wUtD6w8Boup24AZkNbFhr4bgO8vuLFh4tMY1j3LRUOEYIIxwGj09sGEtaVngruFHor20ZxTatwdvUR0vAgtELvTw4opiG6ZiqMJJT74xAD9ZrxNJhWLs/SizHQLeZmY+A3m+ybkM/Lxtq9fHv/t+HBMT0eWOEpw7S5XuhzG74p//Dub2GxEbF9X8Y2mvGf6OHN/LvEmy6QUG/8XZZGDKwrmO89OUxZCxuy/f/397bx9x2XOXhz+x93o9rx1+psZ1EKcGk1ECTmiaKFSAQiiFUFR8ClSCqECIUWiioyEU0KTQhUNUpRdRqGhopJW0AtUk/UP9owKVcNT8BdRspjSHKhwVWohC1NklKfO177/uec/as3x8za2bN2mv23ue99n3v9Z117373PnvPrFmzZvY565k1s0Z6b7Qxr0GY5b2Z88LUpmZJD4qe6sf6lc84vD17VtjTdXh4mDZl5umA8szeN/aS8bqxzWaD/f19dF1XeMhkHqkbrQOtC67/1NoradRPTa3UpPnzWV7X2qDmiZM8GEBZgEtOO5QASnrG+B57xqw92Hiq6dHRUfKCXbhwAcMw4OLFiwVAk3qUQFCvJ5MAfMp7O+UVkv3RCgYypT8NGCVNeVitd0bLZYH4Wlk6nSbdb5kX63oJNTD2DNJrX/tafO5zn8Nb3vIWPPbYY7j77rvx4IMPpoXOn/nMZ4oOdf78efzoj/4oPvvZz+LMmTO466678Ou//ut47Wtfm9L81E/9FM6fP48f/uEfxhe/+EV8/dd/PR588MGd93Lpi4lHXngxSJtH8S6yw6gAYsKPRSRQlLjWA+8xm5Mj6WWymCSHoveg0m5LGdhqiy+fi4E5HEQo+lCrLoYzcMjpky1JBEeju8EQdhSkcADBh2mTHUAxsJ0fgl8IADw2cW3QCg49VggGoCOHbj1gcASsNmFPs2EFXLcXBY3Meg/QIdD12PYXAbeF6z1AG6y7EGH+uAf29oC9VWBxZh8hLoYHaA/BAUaAOyZ0w3Fgv7mIzjkQHUb4fQgKIQzhcB0c1uiwH6P8nYl9YoUBPS7CYYs+gjFgq8DYkMBYF/uT0fBJsxKMheAoe9F7dADCATz2AdwAYA+EQ2ywjw0cjtDhqeiL+zOElVxPIgTmOAbh8yBcBOHP4PEEfE8YDj1oHxhujJtmXx/Wh/k9YHNjmOp5BOC8C8E6vngcvGFPbAO2WnuH46EH0V5I7A/DeRs3dT7ugmfzgg9TFOM6MWw9evLYg4+bOxMQYZhPxxDwT4+8bVjH4EbAIAZMBeKJ7QveriEDG4p9XHrERps6y/dGe8WCqOItyB5kSolQXBUxcHSzl1ni59GNMpH1e0/ytgzFs9so5D52/2HYNfrilU5X8u8SUBrmNW+IvjflJavdn5tyVPOu6fvacNRprWst3y6GGHuaLP4yZD1QTgezglxwmXrvLE7DUxcZZPFnqR95lgE1WCYZ/ZDLlGu8GBDINW1aP1pPteAPGvjKcue8L9rTZHnGZFlS57V20l4n7YGywBgDYblmjMEYex0lGNM85Fox5iXXm9W8YtrjpvuVDoxi1Vf3Ca2Hmg6ngLJVnh5UqLWnJqvtax6vpe+j9Y7P1ceiZzMYc3S1SHoZ6dy5c7jppptwiINoxvG/OJIejTl2DI1stWg3Zc3KcXOXTwyQHCKY4S/nnLqLPNwQkwgjyyXDPgYzAMK4PzsMeuRI30CI5seCRWDFfN02XHfUoY+hwbvodfCIIb4BbNkDth/Xd3UErGIdOt47y8P5AY4IewPB+YCt+m3YfHdv2EMIdH+IPk7AG6Jv5CJ6bF2H7cEK24O94BG75TB4xJ7jAtLa2wKH6zCdcXUO6I6w6o+xt7qAvW7ATfsb7Hcef24PuGUvZLm1C0bmDWvgcAvsHQOHTwHdBtj7f0B3FFitzjl02xVWR9fD+RX64+vQrQ/h6BCObkKAjTdHoHY9CDfAY4U1roNHjzX2sMYKPvqnQjgU9mt1sWFkXD8+srFNvFMxPMIuZ4QOeRPtFTbo4XGADXoM2MMRVjgGcIQO5wBsENbBXQS58yD3JKjfYDg4D1ptsd2/iGH/IvwhsLmFQtDDW4Iza3MQg3T0wLm4f9gTHvgzH0DY48dhpuGTmz1c2K6w9ftYb68PUxKHG4NL7XgvHBsATxKwJuDcGnhyjW4zYO/iGp33OBO9Yh226LABMGCLiyBsse222PYDKDpGqQO2vcPQAXAdqAt6zLs/uxBWc6CwHs0DK+/UK8DvsA8rxtwQBgqic833jOtcBntpzi3SBtLgwDCU14p1ib9PbZn86Ry8BeKcvhtkOchfJuk5lQeLpr4nHJCCcAKIW1u7dD7GGk888QRuvPFG1Ii/977xCWBVT2bS9hzw/92E2TIaXRql36bDw9EotTbmah4kmUZHAJyjWhrNQxpv2vCTXgS9ebD2WAEZLMn01vQ95i89Upq/XvsjDU32bHE5esoh39vb20Pf99jf38fBwQH6vsfBwQFWq1U6NEiTGzZ3XYf9/f3Eg+/JsyzLOVd4zXhtmRWqXnvGLOBmecZkPWuh9iXA06BJt4HuB9ZaKh3wQwbkkFMHJQjTUxLX63U6y3D13H+0N4v58xozXjfGPCR40wBM8pI6kf1Mgmndz+T6MksXnEdG6Fz6nljvvtUv5PUugzNWOnlYXi+LJ+tHevaPj48X/zZ967d+a7G1xBLabDb47d/+7Sv+t+nUPWNXMnE47DwYHoxm7XzSnwEUa0PGw97iVvHb5gBX8vcugrDEj0bZ2LQPMlLAWx7ZrZaAnwCCXBNhzTkXzUkawJMTM+wLRudAFAxJT2IfthhVEX0yZAnxi4LixDy2nT3B+XUMruCiVvewjx4+Go5bIhwdAdsjCmHut/F8vA9cHwGaPxM8ZCsA/SG2qwvYDsBRt8ERDeg7jws+AInrOuD8fpjxeOt1YRuwM1uAbgL6TfAIdUfA6klg7xyhW28w/NkX0a0dVk98Af0AOH8ANzwHDnsAbgRwiLAy6zkg7GEVz3u4DtfjDBAnEDr0cdrjKh77UZ8rYcZnMJZBfzg81hE8HCF46Y7isUGIhriFw3l4XETwfp2DwwbAOQBH8O5iWBe2R9jcBNA+YXsjsH1OcGKtb4kR6G8MoeuPVsCTezHcxyY4tL64Bf7fJgRA/MI6LPnabvcxbA/DPMbNDdGVdl1gdjGKtvbAnx2H8/k1cGGLDh6H2MagHcErFrxgR6A4PZEwhL2u94InbMvREzsH6lzwkLKXlOcVeoT+OBDgKU0h5H7LwxUMxigm4KmJI2ysQVKKcY+8M4F4L/Q7nuCTK78T0veFizfkm1yiNMFTf8tE0TBNTvzbhfbisQvtVkKjSyUdrc3ygtQMK21gz9ESsKZH/HVeWQ57n/g5AwtdhuUFkp6rmvdGepAkAJQ8te4sg5Gf83ow5g2gMM45gAeDJwm45LRDOa2N+TIPGaqepzLytEYZnl4HE6l5ZGrgW+pce2isKXYWGLPOcx4d2eaal1yrJT1d8h4RFUBNgjHtGZNbEEhPGnvENHhjHnJPNNk3rGmT3E/kYYEfS0dWv7X6omwnC+BYYFjn0zTnWdJetCnAZvGqedB0Gu63J/FyPVs9Yw2MLaICWZWmEQMblx+WQEzmUg/4VnEdAR+PelNZVgrqAfaJ8SNXsAMC8CmKNERIt6Pd6VIFgOSpE2vn+CufPIEYjK2iMewcwtodSsP3Ye1Nng7mXTCsO8+gjzeZHiL/AF9W8NiDA3kHv/EgAuhoCHH5vQvgrAdw2APYA9w+0B2A0MP7LYAex37ABe/hHeHAE44B7FFYUrRGMMJXq7AUbdXlLZm6dah6t45fOivADQO6zRrOD8GV4reA34L8BqAViI5B2IPDRQCHAPbgcB2ikIACYy55yBiQBRgWYGz0MMbwHwGwhl2fSYCxENNxA+8uwrkjwK3h+gvBzdldBHXrEKJ+z4P2AuDyB8BwA7C9ARj2gePrAug52gvRKC864ByFbcCeoADGnvQOF7zD2jtshx7ed6DhIExHHPbj0Yf9w3gvtIsEbDzcOgTs6AZKPsIVKIavj8AoTkmkGKzDcz9hLOQYt8T+JYESe4M4pChR8ibnlAkaJT3z+yTfgTTMId8TBmKChcRslnnKJRTOLnkNIL3giW/tB8P4MeQxFRaVvyPM751G1xJNeSek4V3LK2nKC1Yz2JYCMg0GtWyXakBpgCBlsmS08jGAsICENoQZQMkw8gykZLnSs8SfJcCTe4mxjHJdEpOcVsigjj9rvS7RJddHT5+0QN3UIfnpfiefcX01GNNeMB2QQ045tA49NVFPP9TrvWSwDqv9tQewBmotgFUDqrKddB5NWm9Sp1ruJfynQLMsQ787S8jitUv+a50aGJshiWOkTVYsh9dWGYl7xMZg+CDH0UkWIHkwgJGPXU7Wkb3iKH49BzN3CBvk5kAbRjkU144lxqFiFEPbZ4gXwqrLug8DYfBDQDHJs9AJYR3gfNj+ybFXglJQD/IAtluQH+LKKoJDjz0cYh+ruI7MYRgIx+eBoXMY1h7+yW1wcR3thY2UbzoAzpyJe5EdAN0WWxzC9RuccxfxlLuIPe/xRWyw1xG+QCH8/fUOuCXOtHzuLQEuXbcBrt8EMLY6F6Ywrp4E+otAd7xFf/58mMp5/jywcXDHHXAhum02+wD1cDiDDL6uQwhOEjxjhB4OYYqmT3EkGeYi6ggIGx376MXZRA/ZcQRpxwiwcgPgQrjXb8I80D0CXeeBFYGuG0D7BH9AISpiXAPm92KQjuvDFMQnD8KSrj8DcB5h8+Y/W4eZhf8vbQfW4Wi7Bz+sMGyfAxpWoPV1YU7jsAesz4Qpgk944OIAXNgCT27htoT+aINuIOz7MBE1rHvzCME6jjHEvcS2OA4biK98Cl2/jdP7hr6L3ThuAp7mFLo8f3ZDIUIj8fTBEImyT702hrGPLi7e4Hn03jKq4Rd8oIgMKQBNQhw+cOJVyiCPkCYxw7vMtnz3XFmePPQrKvoFRFbGoimN+L1zUSXsLbdN6jrto3nGrgaqjb5r75FlCE+BMp0WKI1/nV8DHgl2LFCmjcja9KZdictlMCHva13IkXntpdFgxApZrw1aBjLb7bbwhDG4kYCJ+dV4cD7mx94ynq7G0x/ZAzcXwdHSk/ROyPaSfUfqgNtK60vqewr4WX1VRpasgTHpsbKCe8jphwy6OKgHe8F4OiLfk2VqwCWBl+QvPWJSd9qbKMG25i/1P0VTQE3zl3LrPmDpXd6zPN67DojogY3a940cfDiJR0zya56xa5jKiYMTg8/asCseBbNIDl47kBoQj6CJ9++SI00MxkgaaGksP52L15hH3CWiLIQdCSkYUPGcYRvbsEPbf+bSAACojUlEQVRCZoSE3fgMFwGZ8E1EjwccQjAGAM5lzxvF4B59XGXVRw+KA7DxHuQ7+M5nkQ58BEFd3ItsDxiiCeq3INdh67eA32DAAPgtVgBWPpTku9D5DxxwGKdQ9jHoRxfBYreJ4u8BdExAN8BtAKIBbh31sgUwODiKc+qwRvBcrQA6RoAEISSCR4+O9qIeeZpinkRGqWXZYzTAuw3C5FMGY2uQO0bwkl0A3ABabYG9sA8bHSIEKLkeITx9DGzo98LUxGEP2F4fpiQed2Fa4tqFDZyf8gGMPUlhZuFT3sVo9D3WvgdoFaYh+r143g/RUbarEE6PQ9fHww0e3ZbQeZ/aM0xGpQjG8nTMADgp7O8VD+kZy/0p9ik9fVBOI4Q8kp9q1KdTT3d8143fFfkOjXjLhOVbk4BSmVheIL2DBZDKII/EeZRVk0iYRafi81JqYOzqIW1o1AwPbTRZnqG5KUqWZ2lp+TX+NcOvZrzW5JbPLK/QlDdAAywJaPV0R8lLAhdtEAOl50d6wSRotDxSUnYNnLT+GaDJz7JOlp60nllufd/ykFjATAMFqw/IZ7V1WNpzpT1gEnxYXiud1gpXrw9dDw025dnqPzWv2FzfW0pWn67pX8o0JY+VdupdroG1qTpZ3xG1OuxKVwu42pUaGJugbMxQ2vmIQCmEe7IN48dgEJVD1Alb6WQQRhNFsyuhNJfPjL7irs7UIW3qI0FifKUS/56BHxH81hBADL3rrp2CI1JCVxGEhb8su4tJhnWcPsgoq4vIJlmwHuQG+C5MQ9vGMoCoPz8AwzF4OmQIBL+P/RgAI3iSPNZbYOMJ3hM2hOAZIwIu9sB1DnjOYdhUrOsBGoDuAOiug6ct1t0RNjTAuyM8iS2eII8naMC+C9PxDh1wA8UIhSvghhtCXJLrbwDO+OgtOx/AV3cecGvAHQHdBQBbgjvawg0ObkNw2zXgO7jNUwA5dEMPFxY9wfm4Do93FU6tJvpbR8Gr6TyoCx5OWgXdYTWE686D9ragjoAYEZH2QzRErMKZ9sOSru11Yd3VU6vgBTvfh+mIRxTWg20I+H8+REs8JoenfI+BehwNBxj8Cn7Yj1MS9wKzoQ8bjx3vhfmM5zaByRfDwrJ+PWC13qLzhIMExAbsYQCilw8YMOAoeMY6j6GjGKQjdKMtrxFzDil8PfXhiJs6wyOgxgHoBo+OkEKk5JiV7JUNZxc9zi6BPJQvAF/7+CHOGHUkg3VorxjgoyutgH48FtG5PEihy2GwF/2k/EoADCTTh5Bco0Hn8pdJmkPMU27D1NBdIx02MHblkwYOepqaHrW3PDryvpVGAgK+N7U2ZsoArRl9cgpgbVTf4mPdY0AhjWy9Hsvay4vvSw8Gy6WDKciyJGhj/iy3zCfrIteLSY+bBj/ysDxvzrlRgBBZv1oYfK1juZaupmOmGhCw2r6WVoKgmqdLPpO6tACXDncvoyPyujA9TdHiqUGiFRaf9aO9xBqQavmZLO+q1cf1PfmOSM+YfOdl2+vBC90+OojGVBtbHq/aoI3uX9zX9RpMWaddgdVJANzVAt4aGJsgL6w0Of2oCmxQXjMIK5MTtOmSx68VMzbgeKGYD5403nOMDa2y+Pgli5QlA0QHI1ABEiBzo/vxJYsuCIewnithRgRn1OApRFVk7wUzYyQaPWPUeTgPDF2M5NizLeyBwaODw4AegE87kRG6CMU6wHs4T9gMhO0AUO+CobshgPaA/f0g8/4KoaCARggbbPwegC3WngBH2HPAUzRg5cLypgMH3OiAG7sQH2SzH6Yw8hZW/QYYLkYwdiGAM3cEdPGeu+DD+Sh4zcJ1EMPHzxyRz1E8+9xPCk8Kx6aIs/KoC8CK4vI4OkBwUp2J+OQMgIPorIqbW/vrg0qGA2B7JvjrnhiC0+qJATjnwxTEPxvClMQnCLhAwNp3OE6bN18fmR7Gow/obuiBTR8XmW2BJ2OQjie3wPGAbvDYG3wK0tEnj1hYH7bFGoQtBqxD8A4Xl+G5wNp3ec1YGBmIUxOJpygigiQKbT+E/iQjJ3J0Q0RARpbbTJMESJ4HQcLBQXKk50pmLP9J0OTyu5AQFR9yMIUqvEUpTmHHNGgjEnER/JWxs18sALH9nXM1upxkeVGYrOlKAMzruelF+trKXzPCa2VK4KM9DtLYrfGxSBq4WiYGSjXQt7QuevqnZVxyeg5IoiM6rlbB5NLeMs2D+ejpXXIaIz/T0fy0YV47tC5qfUW3xRTY0s+090mCG71+y5p6p4G1BDqWJ0wG99Dh7iV/69D85NREq69ZoEeDPCtPDdTI/mvp3tKL1dZWPgmuam2u0/NnC+TJ9LW+U+tPsi67UgNj1yhpz1iiBDTEkTMBhgHEybqYOPicgpnorGyFoeWC5d7FlOlFQcrPEyAZjGXReN1XzMbOro7GYhblx4PYoJUugy6uR8l1IXLwbBz3Qkc9I8BoJjsP78JURO/CzL4OEZAQ0A1b8DC/i3mCIdxhlcLDeww+QDZ/HMPF9i6Ev98PxWCvA9wqeuz66IHbxoL24LstNt0xCISnaItj5zF0IXbhAQXn474P+5Wdp+AlO+iAbgXsHwL9CljtAXuHAWj1hwjbBBzHYwhgDB5wm/AZPp4pn8F1F4g9e1Qy/qC9CLyiBwx9BmP+MNwbemB9EMDMei9iJgDH23D+syE6sgbgSR8jzg/BD3nkV9hQj4FWIL8f0NEQoyNu94HtYdw3rA/rwy76cFyIGzlvPLrtgM577MX9w8I+aUP08GzA+4cNvA6uowTABgZgaXpiRMFpHzFOEDvcNrh/eLeGHtkbzL5bHkTQ04xldy++pykOiBCBN3jmcZDydaf4VoVyNAhLAzauKwFZ8Y6pEVGUQM+pFOn7walc+vdR9iNCkqvRs4sswxgYG301gCVJj2TzPQCmwaSNLTmVT3sLasan5sHp9XQ9KXsNkOn7GtDJus8BSymPlIsNcyuNZXzK+spIkbx2SU4tZLBl6dKKkijbnMuQYI35LAVjuu41PWuAbgEyoFwTOAXGLHClwZi8rgX84DODLys8vgZh1hRHLY9+r6w+wm1ntY1ML9tS958pPcvPc/zlIIGVfqofWO9HDbDrfmCR9S7Ifm7V5VqnBsYmaEhTjyBGu12edsQ4gyl1LCpOnEwml8YWAXDkRFCQyJwBDRBBRZTEh6lrfqDCQAw5GebJ+ATRLB0ipOSV/dJTICUXBl26Sz5xdfAI+4Q5DPGuJ2CzBrzzIboiRZkRgZBzgOtCkAbEdVCOMPi4h3MXIiyC1nDeYRXXTGX/WB8De6ywJQcMHoN3OD7vMVzsgK0PC9kOImLZj7HR4WIBZ4BuAOg6oNtg6Nbw/UUcuy0uuqfg3AZ73Rb73Rb7DrjRh1mQNwwhNP4hgOesQtWecwDsO+AMQiCQzgOr43B2xwiesSGcGYxJjxiA5BUbAeDUz5BxiAtgDHHZFu0hTEU8DGm2+2EG4TFxsHvgKQresIsEPBVnET4RvWBPxSmJA3U49nvw1IP89SA6iEDsTPCCbc+ENWGbFbCJ+4Y95SOzNXA+ArEn1nCDx/52QO993JiaYpiSsD/agGMMOEZo/SMQCMOKgrOty8E6tp3LwTocT0+Me4ltY+UGAjZh/WBPDj3CfmKrCMBy9MRBeMREX3cC/CK/VsURPWNhIMCloYH8umQglqcwy7brgD6+7WxQFSMuVIil+fPQShqsoVLm9P0AfrdUX0IAqwRgoN1GIE8S2r79pF5ekiP20qCp7RdVM3qs9NrQ1gYYUBqlEkBII1w+k4adnuLHBrAsrzYSr2kKVMjR9yVGqZwyKA1sDp4h68HTA5mfNMyZl/R0ycAgch80CaT4LL1cLJPMKyM26nR6uuEuYGwXsgxy6eGzPCw1cGUBtBoY0+vBjo6O4L29bxifpYdLT/OTXjAZ1MMK1mEBGEtWJqtNpM7mdK4Bnjxqba7zSg+a7itT75h+XzUYk++u9d0gdWeBeCnbLnQSAHe1AL4GxiaI4lC0ObYsgVJMHe5Fq4k7QLIB5RSkPFlxNAqeLjQiivyZIc9VTMVkrxjfZL5OW2qUHhRlpls5YwSKJJ5n3gADPhd9X3EaJXsvIM4dG4/5HIIzUJiGR8Er4roQLdLTAI8h4sb4xZiAYLgicui8gycCbTpgEzbxxXGs4J4L6GkVXVpdF1BQ76ItPACuw9DtZ5mix27lCHsuGPYDhajt5KKR6sK0Ru+ivC4G/vDB4dg5hHVMsTi3Qlp35MRsuQKNC6WmUOgMyFzAI+iCw4pWCB6xvQDWNqsAZtYUvHhbCmDsmCIYi/jpvHfYEHAUw9QP1GM7hA2pU1AOiqHqfR8Cc/jIfONixEKKZx82HNsMcMMANxA68ilABwfpyOHrQ3v6FL6e4t5hKIJ1hHcoKtYM1kFBl74EMaFM3cGFcuXrxHrWrzUhox4aJVeNFa6z91yUKr8bJGACIyoq2JTebP6eKN/hohD5A1rw5wxZeCKpi2W0jzZN8UqnGkgCMGlkTaXXI/78bAlNjZxrD5JV5pR8Ms+StLocmVaP/NfqauWToEnXQRvC8rlcr8ZrlvjMxrFuT2noSjktbwWXKfNba8D0dLNLAWRan1PAofZce6f0PQuoybVi2kMmpyhaa7502dZheZ6s65oedNpd3kWtr7n7VltaeWoyWe+rLGMOxC95V6fSnxRYNTB2DZKPhj8xEOqEwZMOtuw4l0Qy2cqWhhaAFCqezS6P+EfPWUsvWVeceE+lYD+yUShXnuRy2RGWfAZEOTYHD9pn+zNU0yGlIQ94Yi+cL2rjIjRiIDcgeLuGNUJwCXJxDpkLm3ohWtHwIaBH58OeZY7yHmoE0HaA3x6H6YnkEfwf+3DYQ4cO+1iFuIt+CGvNjocQPXGvA4YheMYu7gHXrcK961dBjoM+eMr6TZhb2A1AfwZwWwz9Gr47xrYbsOmP0XUeX+yO0XVbHHQhJH6P4A3bdzEcvgtTGA99nh25tx9A2d5BnJxJtmdUnosuxDpwKUAghni9dXG5lAtgy3vgeA2stxGMITw/H3HTEQEXBsBTh60/gPc9hmEPw7APoh40HAZkNxzG9WErYBvnOh73oeAjD1zYBLD75Dp4pZ5aAxc36LYeq+0GPRH2yceIiRyow8eQ/AMGbDC4TZiauBcA73aVpycOXQBg5PoAxIijNyIF0cCGgG3Q5ypO+N2LXjGX1qSFt4l9Vh6U9reDy6CPSIAnids8v2bZD1x6xDhhOT0xj064gMJjfRK4lHm5YA84yvz7ApTlGcUKksWOI76ECnAW30S5IeGOYOwka8aujp+7Zw/JkekpjwhQgiv+zGSltxbeSw+TzCtJesikp4tBjJaD5dbGpvQuyXJk2XItlfZecB5ZnjbiZDmah8yn13RJTwOHmZeASx7Sq8Wh6Hk/Mg7EsV6vi82h2TPGHjD2fnE5cn2YXicmdWa1UQ2ITRn1mmogbO6ezK/BmDVNUYeUl/ckGOMw9uwZk6HtJQ/ZhrItOR3LId+nmleI62R5dmqBU6z6LwGwWp+ynS2PmFUGp5na/kDnmdKBXttYIwvIyvexrRkrqYGxGaLCUnPKKlMj1AJ8SfNEGt66C2dYQ9nRlUbAZcLIn427aFRyHoZinJ1lkCyCXymmJAaMABwl0SUoG4XnJhLcKfHvBaB0EYQObO12sZyOy+K1QEF4nuaFmNRHvAZPIDeAiD1hQ1pvF6YuBq2tImKkuIYIQ5wetmEk6eI6sr3gJUMX0FPfB4+Z8/G8BfkVqO/huy22IIAGgLYAbbEXgU3vgIsIBushwlTFFYDrkEPl77uQ7iBWexXxaOciGBP2swXGWM2EMCOPEHAIL8lbU5jteIQwO/MIwPEQZhGeR3h2ASHdMYWlXWFPrujpGg4D4KK9MBWRuhwt0fdh3qN3wLELzC76gOjWA3B+E3R7cQMcb+C8x8oP6EAxeH9YJxZiZg4YsA5gzG0xuCF4wWJQEt+F5iLnQMlzKsJwcGccENsWySMWdmlz4J3H0muS4FEEZAKz6M2XicQrK71hJN9L3Tr8nUDFE+bJ72Z+T4uXGDpT/m6QnvOcOg0GWVTwZwDmMuP4bu+KlE7iGbs6fu6eXWSNfFtG0pJRbCuvHjmXZ21oSY+MNLKsvDLflIzaK2TVQRqbmq818m9da+Am87ExKg1vGTlR600b7hLg8nMZvIONSzlNcbVaYRiGtDeZBpgSKEvwyDwtmtLPLmCM9aZBidbpVH+zwJgEXHzWGzPryIneh33D+CzXjEnwZoEda61YbYqh1U+1DuTz2vuk+94UHw3E5Ps1BfQ0fy3XVDAOq91qfaRWN0uuufd8F2pgrFEkCbZQXidwI0HZNJkgjfQRjbuEzihncEhT/NKAO78UiZ36gbWMO1EG274uMukQjOYuiuC9F/4w5h38CL24R1El2yG+PPxCdkBYD5StUepc8mJsETaG7ih6D4nghgGePDrv4DAgPBkQIi32WKEDyIP8ANp2GI4AWkcP2Xob9iE7HgIqOojoaEURLXXAwQHQ7wfPXb8XvGX7+4AbgNUh0K3hO4/jbkDnCN4N6OBxIYZr7wEcUtgYmw3Z3oVZkh3iLEmXjwTGFCBjIJ7aMwKwtN9wBGObCMaOkc9r5zCgwzpOFNxQjwEdtr4LETKoD0E4aBUDcsSpiBuO+NGFqYhbAtbryNgHr9TRJoCvrQcuHgNbj36zgRsGrMhjhSH6RsOUxCEt7vIY3BbkPHxPAXixOA4Yep6q2gEdh5AU8xaHWMEtAR7ovYuh6/MubV0xH9bHfhT8iZ6nwLo4HTKy44GD9BbI3ZOJW8T6sYo/kPHMXjfILAzEipYV3xFFwWXWZSSQZfo6kvJf+g9PA2PPLjqJMTJn8MkRdJlHAhj9XBtsFjCrAbK5Osmpg7Xw9ZyuZuhq74OUyZKBgYGst/YgcDoGW9JLyN4y3rx5b28Pzrm0aTQDM+dcSrNarZIHjZ/pdUBaP1Y7SV0B9QicWuc1YLO0TJ1PAy8GUhyeXnquNBjjiIkyjD3fY5A3JbOelih1YXnEuC014LXA7ZTualMiL5V0v7Zkq+WrgbdLkUW3+dNBDYxdw8QDzIHiFYMLUilTo7sy/Qx/ebBBLlxNpSRsxXeIc6/YQBS2WbTm81oxbe4p4zOBvVxs4b1hxtHYc0RhzVbk00VBV3GHp+D38sGhMQwIM1ZiQQmVQAT28PAuRFEkhPD1fVwj5TxAGEIwSTAg6+GwhYthPXr0cBQM+cE70HbA4BxwtBc2Des74HAvAq9VAGf7XZjC2HfAc/YDYto7AFbbsPhruwnTGVdroN9g6LYY+mMAHhfdMUKs+jVAx+hA2PdhzdI+gD2K68gixu37PGuNZ5GwcxAQtjR3r2iwEwF+iCBiiOA2HgPCZs0DgI1z2DqHEK3yEEAPSvHv98IaMBLAa7MXQtP7PlwPCJ6vYx/Wgl3YBpfccQRg6wFYb8KcyHXwhvXYJk/YXpgwCkQvmMc2wmqKU1HzWrfB5WAdvo/7iLkQfgNwMSFXDDFYR+iDDMJ6OOwlr1UGYbxZdpycmDeQFmCMwa342QmHepfHAIk9bsJX7srDBGQy6gYDMbFuUB+zVLyzQnaZmdG88uA1enbRnDdJ3z8J3ykgZPGseVjYCJ3zwGhP3NwIvgRBku9UeH9tCMvpinrfLQ6yIcuzAjboqY5SFr1mTJ4luJKAi6co6mc18Fab0jnnvZH1lMCuxounn0qgYwVJkeXo9uZ0EmRJIMWeLssjpj1jErzJ59wmVttJ+SXJwCga0M95snQwDam3qXVwOq0ka7Biyisly6vlq4H1uX5yEmBWG4yR/K8WoHQ5qIGxCSoGuSGAEhABGacS9xmUGX2sBHWVH6NROeIBf1b3kn3GxnzBRE5eNACZfJQG3XO4fS9wn2PeiF9saU1diK4YACBFj0Xg0EVPHBFAQxTQuyyCiyvaIrgNxjlAHSUsyhtEE7EnwgPEPo5tLDeU1COuaqMO8ANoCO1B6w7oKEg3EIjdM6soyx6FWPZ7iOH4+wDUiKJrMG427IZoeHOkvzD1cxun6oECLOgQ91NDDurhOpIzNJO+U9Nyu/rYhTxA3mVQRsBADgMBHg4bF0JkeNcH7xJWgDsIsicwtooBOTpgvcpesLWLXrChBGMbDxwNcIOHWw9hI7ntFm4YAO/haIh69nHqKCH7mzhARwRHLgMiz4FI+OxiT0molFENdzwk1CTX2+U1XBR7FoMxnu4a1h8SxmCpgCeEXK5+H9RrwUAsbe/gcvYilL3Jh0pAlgZK5qmEfvleWTDyl0YcLMkespP90J1kzdjus/8bXQpZhm4NxMwZPFPptcGkjbYaYJrydOlry0iTZ3l/zlvHZwZW0mul+U/JJfPUzjVjWq/nkyCUjXA9vZCvJRiUafkek56mKCM7al3MgTFZL8urIvlMbZZcK6fGqwau9D3tGZMBOqzw+BIkTvVdS9a5PbXm9DmVx5JJ8ph67zTPmte29i7V+EzVq1amzGPJI/vPHIjdlU7C42oBfA2MTZAMtkAIxnEADpTtOF4TpcFTTJDH08NDH82wcn1XzgEgrJcijxxC3+XyuGMpbMUGoWeM6DmpXPVmvJiJTxfLIMAFs5bBhEfAIjI2gB88Op8NVBc9YkCPDg576KMDIEws3G4J2yGGve8gAhxw/VwsNxjzIIJ3Pi016yKYI09wngJYIAC0Aa8x2oueub2QA34gkPcg18GvPcg5DK6Hdx1818Gv+gC8zvTBjXXYAWe6EIXjhoM4rfEwArQhBP1whLDjs49lr0HksaUNQB4b2sJhgHME52IUyBWHWaS0oTPvY1x6NMJBcU+yEIwwgtQY6YKoA8V49+T2QOhA3SqCwx5w+4Gxj96woQ9rxQYHHLmAm85vA/jaEHDhOICyi+GzGzy6YYAjwspv4UDo/BYdDQHm0jYCoQ1inHl4jrDhhtDbeoLvKU5FRDqHaYoOvuPAFhysgwN2RPk8AihcEzpy2KMueh27OD2RexUheOA8PAYM2AYAyJ43BoEAbxsm3gGGd+KdMl4LEm+wi9nYC8ZL8ZJXrEDWgkvaQNoHcIs8cJKT58EHEvcKAFnkKBLm7wbPAx7hPou2C1g6yTTFBsYuL0nvhRzxnxrNrgEhmZ95aJKGVS2qYM0QtECXBaCs8nV9purGHig2DqVRqD0EcrqgDMrBaaxADHJvMAlIAJj6159lOQyyGFiwh0t7Zthjtbe3lzxlfM2BP/TG0lb7yntSJhkghL1iEtjpdpfrrOS11IFsQwkgtXEuARh7xngNGE8/lABQl2l5zTQgs/qZ7mvSq6XBmGxfvbZsKnCK1JcO12/1c3lP9qXaYIflZZ4Cw1IueW29/1o2Oaig81lAZ0rn8h2Q799SamDsGiVtJ+cPbEkxCBMAKQ2TkzLowv3Req083l6WSoQ8+q3yGH2LvWHORfGEUZglyVlDcv2SC0NVeBc6kY89ZJ1D9AAxagByCI8cF46/otJMRU+RSTRQ2ZJ10Th2HmFC4hBuuTC1z/tot3MtvNB5hLh5xZqPBugQ1EgUtx7ucp0dRRwXf7RXLk+R26cQhWOIoAEI13tR7s5FMBbDR5AH+biOjXqk8H+ui1a3AGMBJ2bZE8gWhwRj29gHeG4fAxd0gNvL5y6CMTAYi/Hvhy6GLUSI6LFFAGUXKQCe83FK4pGHW3t0ROiil6+PEQq76AULIMjDpSmBYVEXT0lE9IYlT5SYJigjGmbwzXNVORHXm1L9XUohoxqyonh6Yt7pi7uULDfdS50/oafc3wvEowdKoqdYvB7FWjGoawJyVFRC0bZAEsQYGknfD0XydI+/G2QGKvtP4k+5f+1IDYxd+VQzsk5iqEiAYHnCdJnSEKsBLg2GLFlr10s9YhYA1LJNeUJq+rBksTxrczz0Pbn3mDS4h2FIwEyCgFpwDult09EoZQRMqQ9dJwm0pAdRt7cGY1PRDq2+ottO8rLAmN6wWYIYHa5eg69asA6rXSVNebakDi0gsNQjVtOPvtbvosVT6rLWx2syyfQ1HdXyahmmaAqkTcm4hG8DY9cgSZuZA1gQEEO+UzB6OglvMDK8stlYwi5pt+XkbLzFp55zInvJjLHyZHM5QHc7En8YlI26JnHZsYzksfLR8MwRD2UExy6Oxg/DAI7TGOBOkC/AMqSpikB0DmxiYAgWmDeHzpAvyjnAO8LW+QTEegRbumcDNHrKQFvAB3jYxWmTK+zBIYCULvL3ORu2Pkyf3Bx5+A7Yrgnb80MAXReHsI7sTAccdDn4R+dy7Hq3B7iD0CF82MgaFLxFACHs/Ewxtj1xTPag25VLKh91hoEyINu66CGT8/x4riODsVUAY+SQPExbF9ddUQjIsaXgDePzxQHdQNjbBA/naiD0nmJUxAx6Qssx4BpA2EQtBs9Y2CfOB3DbUQJBLO42AbG4PiyG4EiywuVgHR5hzZoPMVT6nDqtQwxqYiAYPGIeHr7zqUzpGcvTE2OfZkSYQ4QKlKZeCXFFyBiuiMqoM41uIHvGiPIgQgG6JAQrWfmSU0nJlcZfNpE/5W0iuojVdgFLJ5mmOMwnafQ0kja6NVDS3p0aSSPWWis0Nfo95xmbopqRPOUNkIavVbeptUsyvwZT2mPDAEmCFYtqnij53AKnS3RjedKccylaYNd16cwBP6ReJC/djtKbIwOFSM+YrhsftSmDMp3lGdTy1NaAMX/pddSy13Sm004BCNmPaqDHAoIyf83zJNNLHjWd1Oqy5LnmO5Wn9l1h6Uc/0yBuKgBJLT3THPidq3sDY9cgFV2FhM1MJFCJz96T8HDEJ/h68jXjCGbM0CXDqngmCoa5i/ecyKlG5mWpyWHH98VDE4gVngIXvRYUo01ET4cEkhJ/egBDnnwZX/P0uUefjEqCw0AEv/HBoO17UV0n9OhSQQSPQWNExOB7BLhtaBjyA+AHuDSNrZNB0rFKIDG3w5YInoCjdQjEDnhs4cJbwdEXr1sBh3GvsjOrgAL3uwyqumg2++gNIw4BSBHMSjCGiCxcAKNiuVSBsUUod2wQ0Q1b/wzGYs1cB7g+r2ljtHnsYxAOD1zchkAcHJb+yANHAXjtR/0cRtGCiLKHckiObYyTuAZ7w0KseeQo9CskD1hYyyYwZAJi7Nnjzww2U6MAQ5ie2Ecwv0pesVA5Et64IYIxiUN5amSaQshKJpdfDj7nRZCQxMMW6a7Irgc9qLig8rpAVKRyUOqLLkJcSdyUBcbTYK8ok8EepW4l3+yldBLPWANjl5cs75E2VORUJsA2SmTgiRqfmsE1NYpvyajz1njP8Zgy5qShqKeTTe3BpeXifHN10Z4pyatWRo1XDbgAOQgIAxe+lmDM0ssSMOZcjtaowZj0yE2t37L4W3WSbSMBmJ6SeKm0pH9ZwFy/P3qNHFAOBOh8OkiHzCf1XnsvlwKxXbxMNaA1VSbXwXq/rQAkVn4LDMt+1cBYSQ2MTZADCuMnQwU3AjlFAvk5TlVig4qn/CVgl85UALL8XAzBE2Wh0nVZnhaJkhyyNDdONLL6XD65/JniVDtO6hGwAAggHwKbBzPbpzwhDD7FYA8ivPgQYSq7u5L1GANnIIJeCtrxERF3lMPvp+VHQNxwKn6JgNDRNuk27jwdi+ijec9+PJewVcgPDGEJWMA+g4+bSfsYs74L5062hwiaThTBbHzeu3ggxrt3ce2cqDOiMoliKHcKgG0Tlb0Vz0la+BHwhbCTEQlR3CCZwkbNRyEQR3e8hRsI3RDagvdK6wHsgaIHKkxJBAge66j1TTyGsPebnI4Y12UxpuJlX6wNohzSBS6iJK40o40h1pXXA1IG0aVHjKdI5oiJLEdaH+bk4XLfLcId1vq8JOWtEjiOP6es8v1MLyFloBc/5k/5OyF8KicvS6iWxRPvo0zoVAYgDUhw8t1/8hpd6WSBMaaTGh81QLGrZ2JKtlp5S/jPAT7toeNrucZNTsnT+XQ9rNF8naYGLC3jXvKVcllgydKNBL860MccGLN0LIEXy7KrZ0yuGbN0qttMelQs79rc2kVdLytgh9UuVttY7aPrqz1AU2DCkkfrW+eVbbr0vdXvQu16ChBN8ZZpnm4gs9Q7eC1SA2MTxIaMtNd4zJniNWOGvEZEZIbLRlsET6R5F8ZgBmIMY9Ijz8mCERoSUWbkUNpksp9zGk/qpiAipCiHnRNpIrCIXjmiXH7yFERRsB3gPSLoomgUBi8Ib9IcQzzAE2G7IfhtBDgUUdWqE6K5CD5CrQYKfpAOEQQ6YNVHg72LM/U8QvQ/iqO+tAHQw6epiwfoY4D0feyD4HCAHgSHYxAO4MNGykdbDA7YHG0wdFGu/T4UuteNgZSM/8/t0sc0exGMrbrgVetc4MVh/h3XM9Z1PUSA4sM1B7QYEOZ5ei8aWTV+AnQ+gjIPbMJ2AavBoyfggIADhDDxZ2LgFV4blqciDvA4jucNPNYBArkhTFtdoQwb7zJe5CMMJLAXLIbS52sgb5629cA6eFdXPkxrXQEJHOZgNzl0/RB70rDKgJA9YgEccufsBBAT/Z5BYOpf4lUQfwsVKxYFJWzsU3n8DudsGTmROHNTOiFa6k3pC8OQPw1WZDE68f0RVknuDsaaZ+zKJwk8LAChjbI5gGQBil0NMTlaLvfSmjIeLbBS8yZZRrXl3eA8DBbYi+ScS9P5dH4ZkIQ9NFyPmmdtyoDWetRy8joxDchqBqo1LUzKVQNjUhZtaEsvDU9XlAE85FRY1qf2YOnphJr/VD0Y2FlAwZo+qGWZWjtm1bumE9a/fKanGDJZni1ZL60X2ee4jWQ9p9a5WaSf1fq/lEvqbSqtLmducGDqnba+b/T7pvW+hHYBrVreK50aGDsBOfGXtHHkVEpeYMXJXE6iBrTThfzKz6CM/WbRoJOj4vq90vezDaj46rLHxl2ZGskopAg4nDBSMxYN5iShgJPsH8lntjoTuqIcIYTLIglyXao6v18SP3ogBeeDB7zzERc5eGzRoUeY3sbcwrRG3jMtrJcKX159NNIHcvAR4BAoFMTA0WV9BJmp1HkfQaxH3Kc6Gv8d8pkVQshAir1aAwFrZE8XT10cTXsTbcbgIoIxt/XAdgizJONeaOwjzP5BRG8YzxfMEQp9XJ8VvGJxXVhs81GQDOTm4u6UO4hGNCiDdQgMy0CC3zB5FP8cRkdqE4dcJrOR1+UoSGqE8lUpBBoPcGgWVD7OcExmkMkz4HMQ79EoJTN1Rpnl+yXr4Ywyl9AKYd3YLrTZuZRGzwQt8ULJdCcZjV8yoq29OZxPG3ja0LNklHwskCPTT8lpyWSVJcuxPEuSXw3EWnXVMlhgxjI2a8Y6n2WUR2st3ZR+paxsIOupq7JcK7R9zUC2ZJAApxb4o+YpsqYASj1aurHaXNbZ6n81YFTz5ljtUwNNS7x9Uu4pr5kFxKz0c++45fGdklPrrKYTq4xL9Yg1MHYNk+pShXkF8O5aCtSwDdTFtF1KjhSlUCKxeAR7nqJPiUGLtO7LUPneh+lixaK0VFa08DxyFD9RjkvJ+UVkOz4CAfb8ML+eQUdcR9aFiYPMyLEx7QDnIxBIhmFZm5WAaB0APxA8xXVkqWwWtMsFICAAcsFfAxA8EZwTTiYC+j2kUPh+8NgSYRg8OjgM2KDHCh16dHHrYBIhInphwg5RdcGB48KG0s6FPb1caaGbo1KxDZKnZoUYkdHlcwrMghzoYetzEI9NaBhefuYoB2fIRLE/5UZ2PL/de/RE6AhpfdgeclCM4GcCXApTz54wwgbr4IPqCEPnQR3lUPUdUrh49or4OCWRGKk5h+QZkwiNPXs+BuugiFujbGEfMyCvEYttzVMUnQjSwUvlUuRGh7Szto7SSJSmQ8IjBO4U74OJq/gdkCBPfrmnlzGcO3Sxl7v0j7lpSAlEABaD0xTfEykDIzTjByxjufS91MUvICcT7Egn8YxtT1RSo0uhmsGzC02tf7GM/ymjShqCc8asNvTZEzVFEiTIa0ummlHO5VieLjlSb0030x6BJQa/vNa82GuivWTWxssaiGi96ylwUx6TmtdC60WDKUsXc0a/1GdNr1Y9pPdJA0FeN8fXNVC4BJhN9XtJllxaL/IsPUByQ239jugAIVPAQb9LcqpqzXvF5Vhh+3UdNEkvpfxsgcYpuhTwpamBsWuUJK5CuhYjaCptSkniYbLZI6d0FoyZBwOy+ECadLkcDtHOoM5lXrJMxDKdeMBeOiVaQTwDjgQgYysyeRyijJ2DjxubMW5KHiqfMiGtGULYJLqLYKwTrDxvCC29RenMa8hY6jxVchDeDIpJXeRJMWUX9yXLwVMGdOjRR3kymu3iLmkugRWKGh/IgQaX9J+F1YZ3qlI6O0RbmgN4OJf3W5M6ZcAwxIODFpLCBKLd2LDP8JYnCPok6Sqe9+CSCLxazqfVXRwt0WPAJvrFtiE8huM9wiII6rIPjSifE+jiRvRCaglaYsQ/xPVhIodofgldMijzoMIrVwIxVo7LssiGIGTvIpV61cTVyR5QoXQn+IoM3BNKMIZYm+IbIlwXPCtlFIBMZpbvg3yPy/Visuyl1MDYlU96VH/Kw8TpNdWM9pq3QJYr88vnDJSWTF3b1Tsn01rT+6x66L2M+Lo2Rcq6L8u0PCqWEay9dPq5DGPPxrI03rV3asoLpOurAdUu3oha+imgYpFOPzUdzzL6NZiVgIUDfsiAIlPl63t8PeVFsgYR5nRSG3yYym+1p6S591r3e12XKXmYJAjUZVnfEUuAr9XfNK+TAqsGxq5ByiEoxraXJLahZpvcORSbRDM44gEicVvyzucSGoaNluOLMRKAAZh6EMvkRf7JMybqmfaNHaJ8MsBG4hnnAjoE7xyy7Zv2lwLgPAOeMBFQ1qQrrc9YdkBzIW5HLNNHnSXDuBORUAIw89GqT14HV2K5NAuSBvQUgEgfZXMptGEOM7IVcABR1j7BhC7pn03vLt1zqS6cl4MjkifQNoIJjxxgQqJJAF30kHXepWmWvNpKAzFkiBL/xZHfCGC6GPSC5ZDwJrQJb54c1mCR8xjiurCtowTEUoRCBkFgYCraiUPup4Vbol4RVISpqXE9YQQwYdokKc3xi5Gl9TJYB2OtdLgShAHlArbYl5OHEbYjyieUpt9mVyZktB8Pfo86AcxdmUH8pfLFloMPQKyHlCxlHl+XqVRZJ6OThLZv0xQvL8lIiScxUDRJA97y5Mh0+poNLDkKXzPWNA8JpGqGoEwrDdhagA352TJUZb1qQMWSqQZaawazBVo1WR4Vuf5L69Ka1ijrym2ovTFTMiwxpOXzuTppWTXg0Ma/ll9+lm2lN3+eM/wleJ4DNFIWPeAg66v7o66n5FmLmijTWx4xqy9bgy8WuNFlSaBrecb0gIEsywL2mnb97pF9Vsu8S/5d81wNZA0KX3Z65zvfiRe96EU4PDzEPffcgw996EPVtL/xG7+Bl7/85bj55ptx/fXX4+6778av/dqvFWl+8Ad/cNRZv+3bvm1nucpgBNJeztBFmk2iixepCyuajcZOHoDAKUV+ttF401s2/+XhpOeBC3LinA4hLLKPJwRMEAeF9UVu8GHK3JbiGiaUVjA6wHUpgAIbyRxMIdzL08t47ZGL65PCxsIYld15oBsc3BZwGwAbF7e1ciHEu+8AiiEeXDiTW2FwHbZdj3XnsO6A4x443ovHQTiO9jwurrY46ta42B3hojvCRVzAEZ7CEZ7CMZ7EMZ7CBk9hi/PwuADgIhyOsMIxVjjGfjwOcIxDrHGIDc5gi+uwxXUYcD08rofHc+L5emzxHGxxnd/iYLvBwWaDveM19o6OsLp4hP7CRawuXsTe0RH2jo6wv17jcLPB4bDB9RhwPba4HoPg53EdhljeFmewiXIcYx9r7OMYKxxhhSN0OAJwEcBFDDiPbazbcTyOcB5HOI+L7mI4umNcXG1xcTXgaJ9wvI9w7AHrvaDTdeew7ToMroN3fWqD1Ca+D+207VLbuU1szwHovUPvQ7vnneAYkCX0BMT+4uExuLAXnI9xQLzoc8TvFb9I7DLjsI5biv047KnWE7Ci3O947ZyAl+q9Fe+TPggCMHfq3dTezPxep1c1uQPF94F8X8svFvO7YQzdCtiH0pxutJSu1N8lIBt0S9buME2N3ktDTU6VqxlxU2l1vl1G9uW1NAYlPwBpqpr0ktSMWm18Wrqr6UPXXRukc4BEAw1dD+/Dpsfr9RpHR0e4ePHi6Dg6OsLx8TGOj4+xXq/TwZ+Pj49xdHSU0sk0m80GwzCM9MTBOFiHm82mkEPKwp+ZH2/SbPGc4qvl1LLKetV0cfHixaJesq/ovlprG9luU4MLNV7WoIAGhzWwxHlYR6xLBpxy7zer/Bpv3ffkwMjUuzk1EFFLXyt/l+8fqbdGgU7dM/b+978f9913H971rnfhnnvuwQMPPIDXvOY1eOSRR3DbbbeN0j/3uc/FT//0T+Ouu+7C/v4+/st/+S94wxvegNtuuw2vec1rUrpv+7Zvw7/+1/86fT44ONhZNrtbRS9NOmeKr1wwtUb7FzmVMOYnEiPhYsScJP9w7QoGeS+vVIaT5URjjqS88TaJvMkjUXIHHFwavYrZPYl5iE6wdUh+GleKnh4jr3XK06ay4ct+BALSNEZm4iPDLEd8lBapuVJ38RlR8F74WF9ecyWDTjiiHKE+TVek4O0BUETYYDkiBKbsnhNnhreZuujb6aKnis1xuf4v29zSkHdxOmHWT26jPH0vR/UI1yS8Srw4KpcUvIjcV5MvKHrBqAueMDDm7VzyiGVdA8kLBn7IjS8GBghw8bOsA69r4rqVfSFrR/apVFTJXpEbs+IpkRE0dcQtKv1WpRz6NUp1drFw+e7KVy/xZf9o7TtEZGC+XGgSSiYQtRXl5zYs0+oBo13HBU8yTfHZ5hm7kn+XgHK0t+Z1quVbYqTKtHpUfsoLpD/XQGKtHH5WA0DynvQ0AHma25w8kqRsNUOyZrBK2efyTxnmVpRGJm2sSn1a5em1dPKQ3lTNzwL02rti8bIMer2+TV/X9GTdtwYPpCx6OqaVdq5drba05NDvgtUWU++WBiM1T9pSwD/3rtfqyddLBkmsvNZ3j/Z41ch6/3alq8XTtSudOhj7pV/6JbzxjW/EG97wBgDAu971LnzgAx/Ae97zHrzpTW8apX/1q19dfP67f/fv4r3vfS9+7/d+r/jROzg4wB133HFJsg3Idn4gCRFcggz5nkyVDbW0QbQyp8NJFMB7eA0S2HlRljTyXAzyHgNkEGVjOPHlxAxapIA8sk6JJ5t3KZg4dfBEcZmPD0AMTnjyhGFOPEkuWN6uQwJfeRusaFQWAJENc9Yp1zz7KXhLae9DwA5ioOViQRxchFFVQldi+l4IiYjtMACe0HmgHzh5nHhIee0VCVEpIQCX8Q3CCjOemIboXxkHcCi9I9zWvOcaww5Z+07kk9cQOYIYMbx7XOEVriMYS4XG9gDlWCgMbEC5Si56gXldmAOo75OOyakVa3JnZ27GuNbNkYOLUyw7pQeks/RCedFWwg8dZfdcpPS+JmDWZXlcbh8Qojc3RNTsozwruKRTfh14ymaaogjxsHhPXYmwiDuKE//K6QYy5I4E4EmA5AnjMhQlYCm+TyJf/h4S3zhGr5oAhBVqYOzK/l0CyvVLQDYWLS+TJiuPZUjxZ2svLMsAnTL6ZblTxqZl+MvpkywLrxXiPao4fLg0audG6U86Km8ZqXpKnAZCMoS8lkMb6HMeA6sNtGwsD3thLE+PVbbUi1UXPQ1S82Jd6IiJ7EGT8lv6rNVbyj8XjEJvHC3799z7MQUUa0B+aT+TOtlsNoUcfd9P7u9WA0M6vcyn202Dfqve1lrDmp4sMGp9j1jfG3NAeUrOk+S5GuhUpymu12t8+MMfxr333pvudV2He++9Fw899NBsfiLC2bNn8cgjj+AbvuEbimcf/OAHcdttt+Ev/sW/iB/5kR/BF77whSqf4+NjnDt3rjgARIMVo9H4bFohfZJTkJLRzZ1A2HiZhHGnO7uzsozvOP2J9BMuwwBoiaewC8U5H8GIzYEXIOZtMvgLB6nbBYaRn4t/5SRQV5EhY4tg6GeLnOepdUjbBLse6OLRhzP1Hahz8L0Ls+jE4cXZ9wTfUYgW2cdz58PhhnxgQAiTLw/eHHkLFEeYL+cwoFPnEGgjfO6K+/ngcPMYlbWNZW2UHEJOF2UXdfLpyNP+eF0YX/vOBa9Y34H6LuqxCzp1falvxMZlcJbWZY2n7JXANPdr2R+KTaWR2VvvYWCR0CWKl4coy0IZMilYmXpuAjjq9RmDJPtdy3BMUwmOJJuyoOKmwSZ8p5SDQGONmDragXjN2C7HrqHwr2S6Un6XgInfJpTGF59rRpIlo3WtaReDdSpPLd2UcWwZk7WNc60AETVZl+rN0qGW0wKPNbCp68IGOB8aYEzJYl1LMGUd+pkFAJccVvq5sq21Y7W2qele9gG9L1ptKp1ug7m2mpJj6ftVA0dSPzKvBuzWofnPDbTI6yX1PAn/qXsW77n3cgnt0i5LwPKVRKfqGfv85z+PYRhw++23F/dvv/12fPKTn6zme+KJJ/CCF7wAx8fH6Psev/zLv4xv+ZZvSc+/7du+Dd/93d+NL/uyL8Ojjz6Kf/AP/gH+2l/7a3jooYdGI1MAcP/99+Ntb3vbuKC+K0fCY2QLSoM3GcxAmWEuJae8aIONRWkJcuQNJ0CTGksfkzOuFpKsD5AMO2tqFQel5xvkAb+lLHcvmSJZyx4BtLEzkO3ZZOj6yJS8KJFLyyt4unRmCcVkvIh1/Tbql1xec8NjDMJDFkKsE+AHgDzIe/gulOu9T1M3u1hXDvKgLVsHhCAQUSEU73uiiL8dPHFfYL1kFtwVfGTG9wtznHJdZZAJ54RZ78J0QwLi3l9Rh4xLSpycup4eYPApfRfC9nfsaXRAtwJSGH/hgQKi8ik0xAaAp+wNI8SolEhbBXBfI4HmqZhSKTYbE7LKuqRAKGDYDuERE5XbBvncAHTk0FHwiDk4CR9j06h1YjVixXKDykfiSW5NBkb6n2gXlTNdp/EJSoFHuOIliMxUDg0hv3AuyjLM1E/QSTxju6a/kulK+V0C6r9NPIrOhob2ZjBZ04xkOu3FmgMUS42cpYBsSkYtj/RwyPJlgAft5dMeIGsUf4msc8a9RZbhWTOyibLXTwZ1mDJg5wxbCX5kX6l5s5boiO/XgkHocvmYA6ma5DPpVax5eXRQEF2POY9YLd8UWXria71hNoBiXzXpEZOAUspmbfewpN/J51NppvRkkWxTvUdcTb+6j1rv85JtLbTMu1ADY88g3XDDDXj44Yfx1FNP4ezZs7jvvvtw55134tWvfjUA4Pu+7/tS2pe85CV46Utfii//8i/HBz/4QXzzN3/ziN+b3/xm3HfffenzuXPn8MIXvjCCMReMIiAYisRHaZKVq5yQrikBMpctfOeUT5KNt3Aml4vNRlaewKdJg6h8N57FZWH5E3NG9AoUECJF8GMj15MwJlMx4kMElkQOA6UJZKGq0V52FG4kvVCuN3tSQnLeijlL5OCi38Ql3dAgMB0jC/S5jknPvBHUAM7ku0EYvBSn1cVkQk0SH7BBzFYv+bAXwBCnw1H0xAhEm3SdMJ0rH8szdw8uk5fnpeZjLOSQt/Dq8pmnIqp9sm3vLmMr54LXy3XZm+gcQmAOAcSKDuZDZQfEDaZD4BUGYKvYXtLEDKqQ0R99OhJzJ7qUAGIFZEtySMQmmjluC9AlYJj3j8t9Wug0w6QRW8z84EmSUC2/qyX3XEqsqFMNBZFIVtgEYso4k3fSPoEx9Q4/eNc6GDspPd2/S0D9t0mCMW2E8jWTZfRKI1wbeLyJsEW1smpGnFWmfm6BBX3W4IpltECZNIYtEKnrUTMgtYxza9Kk/FpPOr0FZiRw2sWTpGWW17J95bUlo6UnqSN5bQFei5fWl9UXpzw/0uOlI0RK+ebqIPlafdUC7FZ+nV7zqOlDtiWn0V49DTAln5p+av3W0q9uR6vNdF7JV9ZDr3nTcun8GsRzfRsYy3SqYOzWW29F3/d4/PHHi/uPP/745Lz6ruvw4he/GABw99134xOf+ATuv//+9KOn6c4778Stt96KP/7jPzZ/9A4ODuyF1GzIJBATzSwGZQVJD0CAFh0bYRK4aetb33dsHkocyKZrhiVkMtEGs0EStSWQUJqJ0lwtDUBlMHrxEED2TlABPmQya+/alBiAF0HTpUeMz/x1FfxcMfRtQIqgLYUHA4WCVk4AUQ62oSoPQph2F/VOwer1yHtgcRfgeCFsbKdn3EWoBFI5YAkKfSRVodJcJA165L4g8zmhbjFTMEV1VyAslZVAWexDaS1YH685ImE8O1FQChFPIsImpcAoAfBk75MsOYOvAMYgQFnx4og68P3kWOZu4mRC3SdzX3LEPtYaoBr7nnXZo2tZrfSIoREJ7J0hmIRk0ltZcCmEiPVgZyFKFXVKoNF3AXdIBnu16jcy6Ur5XQLqv00SbFhG9pQXgoGFNrhrAE3zsQCNzDNlxNZ4To2m6/poY3QulL7+vMQ4s8AI17HruiKAha7nlH5kPr2vltaJNu4tHVmGs2V8T+mhBp7mAPnc/SmAbcm+1HMmAaEGCFZ00TlvmPYqy3tWXWRaTbX3Q6efimY4x5/PNeCj00o9aBAm62nx1HXWgFLmnQpEI/lLQHa1AKXLQacKxvb39/Gyl70MZ8+exXd913cBCD8EZ8+exY/92I8t5uO9x/HxcfX5Zz/7WXzhC1/A8573vN0E7HQkvejS4amF0rqOZliBTeKVXG5FA1DO3+MMY4ueiGPdBS45GEIONSDjwHF2IQ6Kh9rohfjCEHBPgh+A4wuGTx1RrAtllNVDMGcdBUN7EDwkeEky8jluEu18YBp2UBvgkDdizgEyQpG8d9hAgN96DD4GGaHYdr4H9jqh52wqBxcWA7QtMPLSCG8NSrs2BXFEYJFYk7iW6hffN1Q5c3qr2cqLEtAlwKXAVwHCqCwnAS7HIMwhrQNzHUDxHvUo3VIErH1Q+HoAtkMIjjEEjnvI67G6BEEyAOMtDjjYSAFM5HxMJXc6pwcuvpvI6InlA6W9xOR6w65kjSK4S4ooKeRJYAYlkToS39ByNPqHWHPN39l8gRQc0xEPCLhCfjfKIlo3NUDssF23Mxg7yT5jz6Y1Y1f87xKmIwdqsgw4a8ReT/PTgEHzqEXuq3kWauBK8teGot7YWaeX08F4hF2DUy2DZQBqA7MGUKR+dLADXR/Oy3LpMrh+ekqbbgN5zyLdrnyeqot1z+JbI6nHKeA+5RGrlT+XT/ZZ2Xd5eqcO4GHxlQMP3D4yn9UfLECmSQfWsdJJQGJ56yyQOadr3a9r/V4PujAYmwJ3MgCJBm/SS2l53SRv58ZTTXcFY7X3dy7P1UCnPk3xvvvuw+tf/3q8/OUvxyte8Qo88MADOH/+fIpi9QM/8AN4wQtegPvvvx9AmEP/8pe/HF/+5V+O4+Nj/OZv/iZ+7dd+Df/yX/5LAMBTTz2Ft73tbfie7/ke3HHHHXj00UfxUz/1U3jxi19cRLVaTA7Z4NND4uojT/ULj+R4fIQy0igu+odkFq8TWJLGl+5UOZ9jT4ekkWUfX5YYHMEJeeSovgULNJYDAzI9qs/lEsDGaSjTEN36HBGlNGXzZEUJP+XeUBARGxHXx1D0LkTk1LEQDMYEginQQKyManOS6nC5XTq+ZpAp0tltXX7U11rz6bllu7vymjFTujcqQ9TXxfrzmVwEYlFHssGYcYyWCO+T54ZBD/f/rujLErUw2BXeKAfbUySbSACy9DAVoWTkRDWlicQMFRWuEt5FLVChyFS++slL3Kn4VLwSgq1UgJJfAL18yLdz3Lrjd2pHFBZpD7uDq2cTGAOugt8llAZ/7Vqm1ca9cy4BMAAjY60GACzDUZJVtiYJFqZG+JfKVONvyWZ5gOYArZV/Sjc1wMcATAJNaeBq/paXZQlZ3rG5dtJ5L4Wm2rZWvm4z7WWy0luBSOb6rFX+HMiq5bUA0BTYr8ki01nASZIF3mqy13RZk8kCrFIuLYMGzkt0dyn9q4GxZ5Be+9rX4nOf+xze8pa34LHHHsPdd9+NBx98MC2e/sxnPlOMAp4/fx4/+qM/is9+9rM4c+YM7rrrLvz6r/86Xvva1wIIC5v/8A//EO9973vxxS9+Ec9//vPxrd/6rfj5n//5E+/pMiJpMdP4UTav+C+HaEcytDiAQwIK3EGThQ+AKHl/QDLSYCh81MW4EJ5f1wmewugLa4VC7qHL/EmAycBOboMb7nYQ63YIGdExQis0ke/nKZZZQcU7yQP40SFF5OGJ0JEDpUVhOSg5ByjfQ1gTNFBYH+SJMByHSILYDMAqeoD6WCCH1pPWMaVFbMheTx1QgvLeZC7X0zMSBI13L2CVzHz3LEgidKnyFsDB5WqkQBsQ9eR07BVzCB4xILv4EFAtXABdcCUA23iACH3cPDkEx2AgRnFqboY67AULwUYo7VlGQA6EqTCV/pC+S0dAUYGvWFftBcs+X7F1gfg3RJZ8zptIC90WuJKS50qWwWcegmCvNgf+TO974s/1QeE+D120i/rknm9pyPiR0cD2BNTWjF2lv0uYNoisUXgmHQCB72ljS3u/OB2AYpS8JsMcGJLPNEipefZqda8ZptpAtTxuUx41eZZTFy2DVtaDPQuWh8AqS3sldJ2s8mpnC3A+nUZqzdOpy7KA51SdnHNV740EXzJ0vuRV6/NTAE6vSdNkgRmuR+39muMlvdJ81IJk6PxLALveeqEGrizeci1j7ZijXfVSo2czGHN0tUh6GencuXO46aabgOsPkI2xaJDyOQZuYNs+R2nLcIEto/gqBecC2DiM07Q4AmAyoigjHaJkoHFwhBLoxS/adLgckKF30mUR6xDlj0dHQB/l52AHY9ll4G+WP8cWSAZhes9IYIMomZP3AD3nSibnKWZ83RHQe4Zfebpi9ot1SZ5tPK9Zqj7qtusiKFP64HaFF+iS8j0FxuDkWdaVyrRCLc8YpTZVlaJ4j8/FPZmW0bAAZhohpxmbBAw+nwkRBIdjlXLnbQrYCzYkMIa0E4Hvsjgk7JAMuqxDAJdUV1G/pBaXgnTI7t+JnswZGDYOXQZMaTphF/XitG4R1sp54ZEFGWBJTHgtosFEnrxWj5N7JN3ydgAOHHBEbJchJOetvAfRvAlIdl2uAwBcXOOJJ57AjTfeiBrx996nnwAmklXyAi+6CbNlNLo04ja6/vrr0z1tWGrDXYdNn5oSpY0/nUca1dp0mDLoZBoJQCxwVUs/Jbs2que8E1rm2ki/1rEkK7iEJZ8VhKMWjKJWN8sIteTdxUB+JmjKYyPbZkm9gPm1VQxY9FS+uX4mp//pABK1Ps/Xc0FVLFlrbWS1v/UuM029B7X0mpaCVj0gYMk9B3J1Xv0uExEuXry4+Lfpq7/6q6uRZ2s0DAM+9rGPXfG/TafuGbuiyQvrkJCBjAAgvH6Ik8iumX1MGeIUYSSICnYhuRNGPRfA6bM4QJ6ulylKQCyvQ5lEIB+itDVU8Tol3CQNv/EuaiO0Iesg5eTP40U7yUBNyfizAJ+pGkQg8nCka80TQmXgiAgLeNpiDEGvvTCZRVmXkId1F9tAAmYr1CL0+XKQK88SiOmlb/IZ5JeoAabFpQMC8PCU1jAB4YujjyCEg3UwGCugArepAmAJiDmlfn1d4qexekfqptRHeYIrr+Qa9euojsGVKsogLN7gjihDzgOF4LKrI4KkYhZsAklGJ0yBOgIHCcbyQaImZbWdM9Sg5NuFmmfsyqeah8EybDmN5QHia+kFq031kvl4qh3zlrLociVJA08bc9qzJdOz56BmuMq0czSVpuZtsuqoZdT5JD9t2EpQWwMatfpoWWpgpSbHErI8aSelGviyvDq6v86Ba52PDX4AI29lrQ01+Lba0AryMfW+WbLKekkwYvVpq84aKE15uqx0miydyXxSt1puC7Auef/ku9/WjJXUwNgUDZSNbUZNDHSQsVMiAcgyMMu+srwqiQN8Z5aJJNMUvo8SGCPK4dfZwCSIPMyMp6kpez2Xw1Mn2XyMni6HMP1KoL88QTJfV7u3ZSy7yJxj3Mu6srHuQmKKKqcOaaZgmjnIkfyitEGzAemxv4wQpi0S4uy6gaeMDSO7XiDTUjURVgDIU0g7l3ctBhvViGvSZLVqyOLpJAOE8ZnDKA6UI/LxXlXxGMMBflj2Jk4jA2BkrxMlb1OG6uyryWEAqc8eMUQQ5jn2Rvr+d3lUgAcpGfSkjonF6tRTBpHOIo3od2lGpwZiUr9FmHlSspBoAkq8immYBW8uHGW7UPiWkGCMBxd0QJmkItlQsg8mwLhIZY2uMrLWes2RNMy0ASqNMQts1EAGgJFHTeaxeE4BG2tkXnourJH4OT5T6YnGYfCBMlql1pXlgbPArgYCSw1omWeKaga+Nq5PAqpOCsSsdpfHnPdS85L85kC09obpPq0HGjSAngIZGhjq9pvTV+3dsPLVgOKU58rqT1NgtlZfKy2AkUfL8rhpuXQdNO+pQZ9rkRoYmyI2tAGUZrzoQAwU4rWjYAKOsE/8myENj4MjGk5ieJsNNwZE0TuTzOV4iwGZhH/ZnBZCIT2OQnI1KCVRtqW0y4WpaYfUt76GSn6u4FfIZRRaeBSA5KRCJ/RFThjbXpmugVdXSOvStfw8roEr68s6YLDgkQ1q9pgVVZAVNeo4h9VMsQwNF1MQxcFgzOcjeRNjeTzZ06YxIONpeKxhBmNuVHg4dJTHAnALHJL6otUfYhuPXzkp+RiclNc0SlP0KdHPwlkCMcVUgkP1+uekGYgVaDYBMZTvgeAbNvrOU5zdZD1L79hIfaTy7Ph7t/Lh2DVPo8tHFhiQZwDQRmxtJF6mt4xp7a2oAToLxE3JrmXTcujrGk/LuJ4DOZahahnMU/W15LD0WwOxU1TzdC01XrVed823i1w1HtIoX+JFqnn4lpRdAxaWXPq6Bsas/rzU+zN1f2k71jx1S+SZAlcWwKvVV/Oa0+/c4IoFaneh5hm7Vmk7lMa1XBPkBHxgA4+TIU+JYuOKc/JWxsQAgnwI/tcltFSUUZTPRjaXTWPbPZnEPppsXTShCwPRZd5RaE8xJyk8Ecul9NyCmU5dyWeBvI+mavI0IYM0cD1jpRBHRF1cxxbl4SAIHQF+8KE8ytMUMwhjPbh05Krk+ZJydR9DuFh6mnDnKR4OGHwAGhgii65DuUDJlX1EkzSS574fZDtV+cWHYk+q5AWL0Sh6AB054W3hUO+uaC9p3pPQRO65lEBY1myeCxnAV5yiKNeF9TFFF9ZmAQAlAKt6DAMeBpJxQLwTbTRSgZC6rAVyW7isTsmGOuMh90MZMj/JxWu6Rqxy2QJ4JlDWqXZ0KL19XtYzt5XsJHyVY1Ki2Mh7RF68rzv+GHXbcOyap9HlI73OZQos6BF8y9ujDTIecbf46/QyKmBtRNwywuR+XTrPFFjSRr6UUZ6nPFU6vbW2RZJlhHI+y/NllamB7RRgtK4tHUzxWeqB0umX0FJQWfPISB5zQGpJPaa8PPKw+mgtr3NutP5J8pL9xAI/NbmnALslgzzX2l8OHtTk0XXW69W4vjqPTF/bS0yuD5vyeMlgIJZsc9TA2LVMqSEpoy+2kyQgQ/6sB6Vt+MIeGJd51xJTvmYDT9v8QqRUbrrIKFEkih8YkIl7JNMWukAueFR+adzn7OEq1TfZ+S6fU51zRdO0RZnEIU9fTGpjcNCJEsUXSXFVWsRyVQ7Ly9w40Eoy8vkHllTVHQSQjNfW71TqRqK9a5TayUmV2DwJMfKEBGEIHjEwTgzGfZ+mwJXbesmmzsBGd4CsW+0Ro3SG6Q0b7SJQlCzBmAAPxP1GtpAla3mVrjXw0p0TyO0GV14XrLjPUsGae4z5msiqpcMJnop/Kln7xMra5n85exFgsngw5r+UGhi78qnmIZryfumR+Zr3pca3lnZuxN/yRll1sAxUXfYc8LDuTfGteQNqdZb5JW/Jr6ZnDXiXeIGmwJgOxGCl24WW5tnFQyf51jxhGvzWvCkn0Zfko8HrFBCb4yHz8/XUwMAUT0v2qfpoOWoDIBbVBmPm3ss5j5iWrZZmDqjOUQNj1yitihhpwV+SbDJp5AlinBDCXpcespBNwgPpM0Nh8JW4QaAvYdNJk63kmtMQAcR7bTEvzb8TlpyUIZ0FACsMVHEtJGJjtQRCgn2KjS8NVFdWhBhTZIOXnFh2FkPyd4QYfZE9NVJwGWkje9CyhDytkc/ZiyZzyCAnQacReAziRS8iV6qX34j6N2sjM5+iH1CZgD+mtUwuRKNE9ib1cOgTGGPvmOyPJbAqQ0TkgBwW+JIAAS57w7w4hoITlyo2bGbwxSEBBw/ev4z7UPaMSfVxvxCdtWCv+pPu9xIg6X7IAoNyyHmU3kQN3VLLFO2lPsty+D2jMqkyvdK/vENbnolKAlFTzqL4hb8Dls8jbGDsyqfVKvx0y5Fpi6a8BHp0fMrInjOoZZrac1nGlDFW8xJY+bSnYClP7aGSepQeESKajehXM4qlt2IJkLA+14AkgGJDbEuGGtCs8V5Kl8qXn9cCbei0c8C5dk97arSuarLKdFZkQEtu5iU9vRpALvF+zXm2aqDSyj8HXCygvxTsaP3IwYHaAIIlK9E4muWScnehBsaeBbSKhkwyguK1XkpfgLN8GV7GeLcrzLZy7FtAocwgMYofJF5y2mjLvPhKRm0ciILxJ18SApIXpyhHAQcGTQl4CSPSyzRl3TKkCSRXcw0cpTJZjC6fO1eADgIwFOAhB4BwUYYQ5yRG+4u5sq+rS7Jkybr0vGyJ/JeDgTjwrEQ2/SnExohokdhod0ABmIsOInVY6mWaGGAIvok/5Q+eryhNdesFGFvFe6uibZgvwyTdyxkKZ8CW72UUkcCBy9NIvQ4VH7kmeeWCLWbAoGfI1S6DWCi9JHmETnLzlmBLn6UuCyBWsI+y0UgelxJxHxpj61HgDrsKSpwSdEpfWJo2y1nHyK3gzWCW+8PynzvAbQG32SFDzNPo8hGHd9aG+C6GpjaKp2iJx4jLnAJDNXlqaS0gZ8kkeU1t/GsZwlakPGlUc7lzQQuAEhTXAh4s9YTM6bkGwKdAqyXznFeplm+Kbw1gWt6oOcBqATJZRq1PWGCsBhh0Xk5rhc7ndrX6w1T/10FhlnjCZL2nAKWlvylZlngBrXtaFit4yJQc8juHBxMaGAvUwNgEhah8lbDubIsVtrwDiEBxXyyKAMaL3JbhBiAE/igxjU5h5tRi6ByFV4fiH16vJdkmQCaLY3CmyxUAEcLWJTbc2agspQsbRlMEOrG+XiRJupR6ZhCUsV+nMI+L+E1OvWOZXfStcbiPDKqCqZrBhrTkA3zOXJgXt6MEfUI3lNMK9aB0n2ovT4aNUs+kL2J7FC1BZds4MOSkkUq5zvmqRNTCzI/XEOeMHLySUU5DZFCWIV48ZP+SupDh9xPoYYCTJ+zJ9tRArGBrgZ8pQCYromXiQQeMgZhLd3WrjTBW+W4VCsnPJT9SfLNHLLaQjNCY1t5RqR4g6W46WEujq5X6vjeNMwm0tIGnjXcNPKY8YzL9HCCT6WuGnwUmtMEtjXCZT6fVebRXYcrzJPPoNXJ8luvCrDrqa+ldk3qtAUtdj5pnRcs11f5zslp60FTzzmivy1Jjt+bdYpAyVV95XdO5dW8OxNT0VAMZGvhYOtJ8dfpa/qVtLWkKzC5tlykd1dLqAQwpi45iackswVijQA2MTdAqbSxMcevaYBA5IhHhz0U04DL66SjucUXJ+EoBO8TaJkTuyYslw6Tr+Y80/qgxGxvjOXlGWoT45SRSjsCP/m4ugJgozVEOVU9I8UFyRHNhKCvTNcMhh2GgEK6+R5Yn4aKsK6JwHogSdktR/eJ0RZAAaZRhB4RKs3b4LKcpWmCsDP6R68VtJp7KL19lECc1C07WJE4JlnK7iS9kfprwnuwUXJZXJWS4OAiAmnsQ/4hlj1fmS+kTCUEZhAECjElOFIEZZ3II7jInMgEi4iOlwCPjsO4aUFLW1AiEAWZGZ7dCrky8kOHrU7COcgNmyUECrxEI45vO5T4twZjYW4x7WgaaGYjFDTAwxGiq6AD0sYIcGMST4JnfPblWcCdax2PXPI0uG8lpijx6L40koPTMMDiQI/5ADpG/NFT1HGDTZE2hkvml90LmsQzaGl8NyCyZtfEr+UmPhZZHgjH2Rup6yLJ0gALL+NYG+FIviaxbrfzaWZMGfjX5tExLgZ7lJbG8I7W0Nd5TdZefawMUNZl0G2qvGr8j2sMl+VjAW+rTmu46VWc9IKAHQyT40e/X0gETXZ7Vfy3d8veHnLrJ7wfLI79vuC4MwrquS99hR0dHO8u5C10tgK+BsQnqkM3vMcDgBhZAxrloiccz257R2Au5dMdQ3hUQigho8n1SnpApkqbn6JVkg5BH6zWsG2UQ5bpx8sRTWqmjGxoIIesj7UGWi0mGLISsyPpLgIBQ4OCizpRZZJmYi4ughHOWmsqwi+/LlpN9gYp7+b7EBNx/9KTI8nrMKQMjjwKaoaSyX2S5cmNlE58w7RnLcCDJ41BcM/cimp+4lt0rZXIqM1dKZMp4yvKIZZ0UStNAbKSXic/qtUuCC2SlWet2W/w1nxF0UZZcGzf+dsjtzzouBn7SWVUo8XSC9w7UwNgVT3JUecp45msLECzxplg0Ve4SHjU5dH4NAJd4cpbqxLpfA3XW9dxzC5zMebyW3rPKmgJhU6BW0hxIsDwcNRBWey5Jehyn2niqTjr6nwXCZB4LQE0BWQ3o54CyJOsdXEI1cKmf1bxi1mBBrW9Z774ETjWZ5mSZAvVTz+eogbFrlrKRxGZNMIpi43YO6KNxxB6yDmGkuosWF4Vpii4N/PmKgUTREKTScE35XGko0hJDkApbLU8PpBiRkLKhPGnUSpigSpVWapSV0rUOLO+SHDlLmM7pt7GK/P53ENOwSqRGoLhRbwlOnAJnxeGUQc26TIpkNJEnI2oNytpr6CNhewkqHFxadSZbvm4mSw9Vno4n6i6uszyuuMdYiKPwc1swLweg2BshufMoqYIpxQdR9WdAxjwILuaVN+U5MvaZWQi+Ir1hrD/Zb6jQho7YWEUbacCBtSFqJSvDaxhZLlDhXKsVY71/RVGMVjmznrtZItYRXw+fp4X2sQP3Xb5OHd1n3iraKffDnWgTj13zNLqsZI2+S6O27/vRyDlROS2MvWqS55RB7L1P+a2pYfrzFIiqGbc143CJR0HrwJLJKh8YA1wtA3sD5gzJJQBqylM2RTXDvGZw1jxulkdsSfkyjQVutJxThrBV5hIjfQps1cqY4qFllvd1sA4tXw0s1cDRErA/Bwr5XAM1UibrPZTvsvRgEdmeMS239Kzzd0zf9+laHpqf1EkDYyU1MDZBEkS40sSMhpA45DSP3kVA5pPxmaY4VsqRoCIZrAzumJL1q374xJ28/knXg4q7xNZ1MurItjrN90VYeqTOKA1SLY8TyXk9i2eASCWfkMGVBTgAcT8rEEAJUGaZtAHNaize/WQQi+ukG6lTrT0GX+M6CbiOPP2M01BKkfNWfkDB3qsMQ/gaCHt9lVMJS6ih/Cmi/LIPu1L48oFoS6kiiSdKoWMmJ5hQqTMASPuHMRCLT+XURMMUzIeQdbS5Mhc1AjlRO1poZpvQZm7x3J6IetNS0YgN6UcU9UIqkSirfHNJ8BPw0yF8v3QuH8XoQhc335PfMJfgGdtgd09XA2OXlaYMeG0QSYMSyIBKgrGakSNHzwEkg83ab8gycPnznFdKl8NyWsbgUk+ZTKvlkWXLtJr3EsCj6yLT1vJYdbJksnjV2srixeXUvBS1sqfAnQVqp+ScAiqaz5z3ac5DU6ujvrb6RK3/L/XmTIFBqz9Z+aYAmZZnV9LATIO2KT3qdpT9qu/7NPVQtx/vJSj1IY+TAKWrBVztSg2MLSDpbcjmGoMDNkCFcZQMKITFMwlPkDC9JJ/Spiz6WtHvxkZlNtycSE6mAeaEsVc8T3JFw9HauJgXZhmMC3FZDbEQTxIASMjAdygZ48FOjbqWa7tlqPIkvCgoyUvl3/icUNY5ZVf2MLFhjgxCAAIVe4PJcCBAubZPtmUJRBiKsX9KTsTTVE4pFAKOziXkgCMUbaHbi5uXVSnxE4MvJ/OjnJYIJ/qmAbTGUK8UOQKR5FhGBjxF/y8lSFrgkO4sZwGAMMocPtT2dRMVc9Uv9wzC8hsmq5Q3YB4TI0YlmyedoughOWHk69TBYEx+36T3whUsTP0soTZN8aohbURpA3/O+2CN9M8Z81OGW82IlABuDphp43TKm7CLV0nnlQE2LFm0wTpXvlWXuedLZLcAqZZD0lKgqvnMgaWpMqWsc+m0fLX+OAUgNY9dDPQlOrQ8ULW8PECxtEydd2meqXSyb1ggy/KeyWvZx6cAn5WmBlhP8v2xpK7NM3YNkjZtEyXjyAGuy4AsgS5kINZRYWmGjkGjsXYOS548PlwmgzkuVxiR2WOS0+fYgSX0kaSBGODiZsaSk8xApQzKepYGMjuqOoHrslcxg5VwDle90MUAfuEAzwFN2NDkgAUcMcRBAUdK8uZJbeXeY4b4Jtbh95cigCgt2wAoSKtFYR+hQCWBDPVuUTlFT8tfpsSobSSIKjBBl7uQk8/FWVazNOYTGsifteerWFwmFEiUgmMwh+A51ECsLL2cnBhb0olinNaOVQEbleg1fOUzLZOlDzvkSaFQ/fIJt+IoxogoQU7HFAoT3zGyAaXA4n56+WtgsdHVTHOeESusOhtHMpKZnJo3ZZjKPa0AjLxj2hi05Kx5unT+Wr3mAJEOHV7jw9cy35SXSMpX05UFLqbAxFKSbWrpaxfjdImRvRRs1Z7NtaHFq2bIz5VXoymvV+2s5ZrT1ZRHaSpPTR6Zb85zqNNYdZJTD/me7DP6fdUh/2vlaDAmg5pY+64t6XONAjUwNkmlR6wwxtgwWkoKGTE40aApTXQjmc8VxpXMkT/xlcw8B8Zqpqj+Mov3xuyLcpKoEZCNEaE0gGUFBebSRSSlUwZlWl7jlv2BxF+DhBAkGjsBnggmpKBmFyB9WTTmtAwjJmTeLQpXwIuvSd6LdjoZ6eRZY5mSscioEZ0UzHppVN8fX5cMxlAMBRArPHhamQUYmypTfh7XetxqFnsa50zbRgilFp0pcM3aI7OcMYmOJ1+WlDt/T2TZ3AxPg5pn7KqgmkG4qwFbAw0WaNLlz3lCpgDXnFeiJpOWb47fXPlzHiGrXMmj5q2xeJ4EXNR4W88tYGB5RWrt+kwYyJZ+LG9YDWycVGeSltZ1Cjxwnl2AWM0jJtNrvVg01YbWQMFcO06lXQKEp/Qz9X2yi4w1/s0zdg3SEP1MhBDanpfTU80IBZTxSSNLMZuzGZhQcV/hrhH/MWyhdIcmjc6SeNLcOEcOoZBLoOjh8CA7nLhQRTJiCwBDqTxKJXQjXXQo9UFQHjJ+2AuEgYgAGSklxKThXZ5wavoL6hZ3YNuF5pSxLpLWDBQz7hoSiNkeC90ak21ogTD1mVipQA6OMgle5Q0rjAUzE43OamYES5RC1csQ8ZJD2cOA3I/zzlopUImoi7lOTAO+6IHiNYkhec7EfU7DrvJ1s+7JJ2aTCzJeCNFfdDV0U5I4jwpPXw7OSORi0RSdkbWVqhPU1oxd8STXeg3DYG50XBsV16PmkrQRrIGKxbPmReJ0NU/YFGmDuGbkWqP77MWrGdacR0fi0x7Fml50uUQ08hLq89Pt6ZHyy7Zfalhb6eeA8q5AqZZOg6+nE4RpcKzrVNsfC4A5jVa3s+Zh1UfLo8vkfibLmgJx1rtau1d7xjQ3eDHVDnMDM1MDLzqdDAKyCzUwdo0SG4N5OpKwe/QXRTK4SBzGcyNTsKdcYVcVgMwyuERKbVY649ouWxqnrviUP2tbl+CoLDMkdOKavxRifrYZSQJGs7aFvGGTaGHnAzEwik6py5dU7utWkrqvAY16XOiWxl1A5p0q0bLRl7WZXZasOnH5GrhYlv8ixhomxCMhBkZK8Y/sLOodKDmoHxIBUeVarKQjU3aNyHLZGfjl3i17eH6tSOSWQVNsssCX+AlCobOJ93+MKWn0XGsor38jpXeIF6SsFQ8m7URrAHu7ZWmesctL2hCfAzq1kXx+NmU4cxr+bAEymX7KCDup104bhPxZG8Za1hrPpSBkCpxOechknksBYlP59FTTGiCTNOUhmtPDSYxaC9CzTqyAD5dKlpxLgMyUDNoTtlQPc4DKAqKWrDVwOVWWpjkQVks7NdCiZbLeganvgpMCqwbGrkEaIhRgwzAbiMIQ4hDxTGyAEuXNWAmjYIVLvnYKEGI9TcAnvgCGxZeeauxE5c0gUzZXxesolrrkckIUcEo5QRAhC6m04SmsAWNd+FipDnnLACFZccVbMBe2vQcw+FAWxV2feT3ZpGKlGT4qckzWF4ngYDXNCEyJrpLARVSX3tcbQOFtk32mKEDJQgS5lHAK90edWQmEcFLwLI2WpARcRMELljYgzm0cziUHKpjkvpv8YlJHMnqg1plERz5onz1icsNmHVWQwFCFB11KOQpArfBmKX9FZ1rHsl0xTYlbbH/izahT2HoaK5PTpFsh7ZCD4y+nBsaueJKbrmqvEIB0TxthfHD+GnCwyDKsa+k0b3n/JIBMyibraHnnLLCoPRHymZRT6nEpmGN+zLMm70mBqCZt6C4x0KfIatMpWef4LjWYdzGST2q083ugvVpMus/X2lXWSYPKKe+rzCejmuqQ+bo855zpxavR1EDB0wl2pZxcjpRT6kLqnonTWt8/S8ttYOwapEGMkXuQsHWiyc0GoHPZQJIG6hAMUxcNU9O4Nigb+mr0e5RRmZcRCGkjn4A0kM6BJ7gQuV6ljGwngZET5ioHVvcZqxTrhyD2B+NyonHuAXIUcBRRxG8kyrZBGfu2Qgh85AowsOii/jshhxMc0rsoYVSsqZ5zWChuDB3Gn6wbuXzZFhwNMHmtKhT23hL4Q4rIfAUokHiE1L1lIMwZ1wqA1UCQJwHA8lYOLCBz6EQ/KxkIAIYySEfI7MLeWnytZSgAIZfVjYBYuUOEDHyjNZjL1pEliwrIvm8C2FE1RZplPw6y7Ymn6sr8I1lKiFt6/XagNk3xiie5P5j3vliAL40kCVakQTo1VdEizWdJeiYJlk5iENamtDFvPU1P6kYDJElz+pAenKk6Wnq0DHcNGmU6i/cU8F0KxHTbL9H/LkBsqadtjueUR7VWjsVbpre8xzWd1nSs88q+NLf3mL62gl3ojZV1W+0CJKb6zFy7a4A5x5/lld8xWj9S/zLPpYCjBsauUfLRaDenLSVrWAAxvl8cCEbiRH9gk0mu+DJNthQ3PuYqjDNXFqJQHyECMX4cs4RqhLLz1DEJWEqJ4isLV0tTs0vlvs2OcqAPYVeyFBKKSolGeiEA5GPESWGZuiJBvCwgilACjMbherDCXG5Lvl3a76JuyB6UKGzhtRKArACMyuXC7dWRajslaupiumy5+I4fOCFAIbwQMl1rXRWligqR2MS5VIyCcwaeo+IqqZqBF3tanWhf9rwWdXDFddkjdcTEDFDK95qKdik2s3aj7KJGqnYknlkNZrCRgXwsckDepJ3rrt7vApjWxG30rKGpUNraELRAg2XUzE3R4s9WOssglgBEe11qBrS8dxLgp8tdmp6n+mnDsWbg1jwR2pBeAkim2mEJeJLlWOuTdB+YKqcGXOfqthSkLQWj1nMr7ZROrUPnnaurlV56OmseV51Hl1d7h/S7ZpE1sDE3GKDzzoH4qfrIdJKPtVVETfc1ua9lamBsgrYAnOkxkcZoGTpdegVApUGqbSc2efMR7k52T8tqcwzEFBiSc940gPDhczL2hWHqlKnojGueCBaqqWrJxjSEDORjYRSmGILgPZIXiHXFRnwuMVMXnwa1R3lT6H9XWUuW22J030IJhf5ydoFcE65jkMSyaV4JhMU5egw2AtCQbcUJI3/2NiE4V7OOFG6U3ZBFVM9G3iT9PJ1p/ExC4QI4Sj6xTQXwcMjTEsceMSUzQhN6pauwn1b8wPtqjd4gxPePQZicoJiBmCvySACo1qc50VY6dkmhd6cU7krWUNcVIvGXSXdFF5OwJxnJWJR9SIDRNLqRue/8e7fG7r8MbZriZaVhGGaNJMtA00aUNg4tT9qljGbXAlvUjHLp5WLjjsPoz4FAuXZqKr02ZvmsR/mlXFZ5FjizgJFV5pTBrdtmqlydxwouYelA8tfeHgtg6LPlgZqry1SddH6rrLn216BYn636zg1AaK/WlEdM5rdA/Fy5Vtm1DZNr+qsNbCylOQAo5eD0Vlj8WtvK+1bQoSXynSTP1UANjE2RQ306GZFhpIkDY7t+xKJMHu9NATJhfY8YSkBGAhDROC2hiJafQaE0VBl45cLyXzZ+LZtT1poEGHAqSZBzVBUaV0/KKU1YxxAyWfUjYTJTcSqYjkQWwEO7RBK6EmUarJkXkTinclTN5D0tE+W6KhxRimXczshPlyl5SeEq/AHkvQqMwpHl5PbR/b32CgEogowkkZ3LB3NwMgHLo5VfTnRVPwfqOnvj0qHf9xEGdJmNc2M9FUVNPhwBMUu7fF++D8SdihueXcxW2ar7LqYGxq460qPRlldparRfkwXCprxjcwbPlOdF8psDANrTM1XW3DPNSxuZlnwWP8tDJmnKa7QkvZZhTv+7GOJT4FJe12Sa85Bp+Wu6quloV+N7FzAyBWqttFNgbgkQnbq2eMjPc2BW63VpX7TIKtf63piSdwnPk1ADY9cq9epzMvqzEZhH3+MLUhjBbKSWVq5lV5f3JESqdFwNJPgee4eSESnAGRfSUfCMASn+BYhydng4UTNLjvSJkIML8E7PKYFCF5ypE/rxSDM9+RbjEFmGZSOP1sREA33sy9Or0Vyqr6QCY7nMPUENlcHc5FnghNQVCg+GBRdkBqDYqDoKRSyctLO1zS0x0+DUw7KPjlbo0Thd0pDUi9KKFMqqXaGf+KEIVS/OWVcKjGlAzx2G+x7ZbVH2D4p3KF3xVhVeysVHJ/SX2q5gXl4v/L7npONokjZ0lkF1SD2l6BUmkq3ildzxvEsU4bZm7Iqnvi9/nLRnBMDIaJvzLDCfKU+ITLerUVUbOZcGX9d1I0+LNfVuVzBYA5Las6bTWnx02ewtYflreefqv1R+zf9SjdOl9azJc1LvxhKvnfW8NkAgn9c8OVPvgqXbmjes1gctgDqlAyuvXr+oPZeW/M45c4uDpW0zB6J1mXNAVMug68LXRLRTiPsGxq5VkgaNgZ7C42D8dymphg3a6CpH5PP9ccoqELOIgJEnLGWXhnnk2yEb+pDB2krD2oZgnCZCIhbcqyQSkEmDlgNuOJfmSaZ9pV3OS9HIlizEY6WzUiYZEEQDZlkXrnIJLSjibbmKjYq8umUKeUimF5ok9dmQJyhTLrCjLKCXUpRQOXGQmC6rpdBBeW1KkT5JQCOBjH4tJmpU3NTBMYolbBKMpXsGRCF1CI9oqFN+d8ZALAOyFCU0ATCuhMtnSzGFgg25ZqnsTbI/69rm75Tx6jcgvcKxPoLr+OVdThvs/svQwNhlJcsYmjImlxr8NW9HbWR7idFuGXFTeRiQ6froaX9LwaBlvNc8ZDpMvFWXGiCTZ63Hmg5q4KAGOLj8KQNTA5aal0TynLo3Z2wvIUtvlreFz0vBk9VXtQeuxtOqy5Q3agqITclUK0vnAcpgPJLmyra8YZcCWuSgxxS45c81XhZYnmqHJTI+W8GYHSboMtM73/lOvOhFL8Lh4SHuuecefOhDH1qU733vex+cc/iu7/qu4j4R4S1veQue97zn4cyZM7j33nvxR3/0R7sLJuNxG/0m2G9udPTo0EeAJjee1TYkG4LjzWx1gWbOaInpQyTxI8aqQq64JJcjZIfokYQh+g989CT4IvZdCWFAlMObyyPJJGQU9dOGOUcdlM+sNpA2NB8OVDRbfuZSe/Ux3l6HLl33IgJfSCPbsczDKWWO3BPYcI4lp0qJxs5KzojAizRepUkdpCynLDcf+h/XTdYx33MpjdRFLzhqrCI3be7EZ5Nk28pDtq1szNStOKPqO6lfiTD6YgABqq/yv7IfI21ePnrvXBdBmOp4heDiSNtXVN7R0XvC5WS2MFgL/4b4ntH916V24jSjdjgJKFuf8HiW0RX7uwTMrlthYKGPvu+LzxZ4sIzkOUNw6tDRCuXof41qngfmxZvGys+6DMvIrcko61Ern9PotFPySz1LD4u+p9un7/viWp6nPDUWz1r6mm6tNrN0XOsfVr+bktlKb9Vb6sTKp/U7947odrTacwnomut/kr/Wr+7Pl/LuTZU/d1hlaeBsfT9IXcvvFtlOtcEHzrsLXUr9rnQ6dc/Y+9//ftx3331417vehXvuuQcPPPAAXvOa1+CRRx7BbbfdVs336U9/Gj/5kz+JV73qVaNnv/ALv4B//s//Od773vfiy77sy/AP/+E/xGte8xp8/OMfx+Hh4XLheMpfaktp9CEZQ06Z4YipeP+iYG/HHwUoQ1QagsJWy/abLFMDNGED8iOPYExK54qOLpHKjgURhaARUS6KgClv0FzWqzRUKZfj45xDxyY7hKVOIrkLgrucn+If71CEcGeZzGiUNPYkyOsSS/NfN9IlS0CpzfiMou3KaW+6VCWYSF94DIFs7GvhmXECaBGUgVKHkd4sy1OiJ7PJ2o49Yjnke8mLIifpxaXCgzPWSiFEeKLakM/cBbx85oRepC5kB096oRzIIn3RZuky/JFX5R1zSqLcz0zKUGQUhxxoKKpe6rLQj3zf4ymliJguzyoufbu6B1NKFdJ7cY9G5TXaha7o3yWMp9QxsbHDBpE2gpms/X6mIjRaHg3Li2DJJO9rj8VUOTLCoQRV/GyKjy5Xli/3eJLl1upleTKWUM27MwWiarJLQ1sDaEumKV7WtRUJT5Yj0+n8S7xYUzJqYAaU+29ZwFH3B8uTapW55HmtXrW8GhBNlVvrS1OgSL+/WgbrqHnXanqwnlvyy2sLYMt0fM8aeOG8VwtQuhx06p6xX/qlX8Ib3/hGvOENb8BXfdVX4V3veheuu+46vOc976nmGYYBf/Nv/k287W1vw5133lk8IyI88MAD+Jmf+Rl853d+J1760pfiV3/1V/F//s//wX/+z/95N+Gcy4d+VBi5pXFsAQRls6mMTpzZUHejnAEc8aHKkAUQG4kCKOmIh1K6VM+cnJNoY1xeiwLzNRvP0mMgr0llS4blWFejpFqpo2axuOjnI45GurINdTGWJkuxdG6H0vXBeomfLU9ZIWpZiiuup2Wx6jRV7zrRsvxunMJyKMmumTIW3Un1maIPyb4mueRplON/QhZLWa6iycIjRtUKlLnyezrSFQMx+c7J7xj13lnKLXtXCbDl8xMTrxnb5XiWTVO8on+XgJEBpJ/pNFMGc80gmhrVnstn0UlHrmsgYYpnrWx5PeVJWyK/5rsLLQGRT3dercMayJH6mdNRrW8slcWSo9bWc3XStKQt5fVc36mBHqtPLOVh1aemmykQpu8tJT04smSAoEYn4bFrX55qi5N+v1wpdKqesfV6jQ9/+MN485vfnO51XYd7770XDz30UDXfz/3cz+G2227DD/3QD+F3f/d3i2ef+tSn8Nhjj+Hee+9N92666Sbcc889eOihh/B93/d9I37Hx8c4Pj5On8+dOzcu1JWXDux5KT1jFhzIU6NisACHchSeO6Q09kYDG4TSDM93U1lEoCEmoMi32D1YGHx8kWKzs5FL/D+YsPFWWk/GL6+QooOQHw40EMgNpbLGiKX8QFTYuDIqvzYydVYWU8I63RZZoXIDrjGklAY9xNmmXKoSJ/YJ/pKMnDziJuExZe17iPsBkALCiJ8n8deSR98p13fpvkPFp/J6DGcADhBBQjMWUB7DJFE1LVDhQos3RV/UGNoBwlMqgZhqM+6Wo07kyrNTCYryBOhKQDmuXaHcGrpvMgtnyCO+PJCAGSi9nzSE3D5lsyNU6r5GcEbvVhmX0Bq7D9M9i6YpXim/S8Cy3yZtvPKotR5Zt4w5a41KbbRbGp+Sj/RSyfL5uczP13NAT/OrGbrWsynj3vIYWOH3JX9drnVvKRjh+rAnao6mDHydRt9bauhKHbInY0lZuxjSVrvNee9q6aS8WtYloKhWluyzVj/Whv0SQ3+uPtrDO+dl1J437kvyWS2/fpc0Sc+kfCetzbO5/+otJPR3Bnu/9PePlGcXOgm4amBsAX3+85/HMAy4/fbbi/u33347PvnJT5p5fu/3fg+/8iu/gocffth8/thjjyUemic/03T//ffjbW97206ySyNM23q66RmQkcgJ50TEtmxWZWQhjMBURjantVEtjcDCAp41qtgQjHIkMUTBXvB1/FiCMhnBMMst84wUlYQWdSeVV9W/qJuqAm+KzIBsHGIiy2qxyDa/hCdjQKa+TgyBJGxyhSRZJ2TkMyqlrqyfvnptLC5lapbPJhuK5ScKvjmdW1yL9iTR3OlGUqPLGSQTn681IMmylleklZb6HoMfvq86ZiG4ddCo6XTXlkQjhvzOx7Lle8dBddJ7EX+8oZVmVKtS/onoGgdjV8rvEnDC36YJoDNnoHI6Cci0Ab5kRJ/5amN2Tu4p3tqoqxnWU0DE4i8Dg9SM/6nrKaOyZoTWZJmSd2qk3wJJJzFCL9VwXQoatYw1YGbprwaK5gDz1DMLfFkDGDUZJM2BTN3HasBpKr8e5NCAeuqs+WnSANECVLr8qTrs6jWdogbGrhB68skn8brXvQ7vfve7ceuttz5tfN/85jfjvvvuS5/PnTuHF77whSjMm8n2JEiTie/kUBfReO2Qw5z3wih0KK1URhbIj7PBpUO3S0iQ1wCBXGDpnTBMBZoqrDkBXEbeMy4gyuSFWRjRkYtmPTCCZMl+zcmFeTqyYI0vsXQO5dfgT7Lp2ZaVICjJCDhRKEudU5XwS0MxG0KV4GtsNJfAaPnXgtQn58ocLNBYg4ql4Z7rPr6XuWe+tqewAFeVepEo3JrkWFSVMxT9PoAUGbZen7nNJNQcbdjsILZTqKA0rcK0Vk+kJlesXZwCQrLdinZ3iBXqbEDGqT0F/Q3Zqw4QOtGj6hp1Qnb9Ri6gDXYHY8+yaYq70DP1uwRM/TZlWjI6rw2pqfDZvNaM71tUGw23RuIBTK4PkXJNebWsMqz1ZDq/niq1xMCem161FAhqwGYZqHO6s7w9tXu67pqvfvZ00S5eKEsXS/SyRAf6/pyMS+qkz0vBjnzvrPfF6ptTcliy1OSotf0UyLNks9JoAFgDg5rvFEBeSg2MPUN06623ou97PP7448X9xx9/HHfcccco/aOPPopPf/rT+PZv//Z0j7+AV6sVHnnkkZTv8ccfx/Oe97yC5913323KcXBwgIODg/EDaRzBCWPRqURsCmYTLOAWiqCMs7kMwtLeU5EcsgHoMm9pTyJdlwZ/ZlHCkCRuYeNSaZwmw1WBtFQaCRQiUVU+M0DMhn1RWgRkMly8KlMDREUk/livVWEQxw8yTD/LyFclIDG8Kkp+62xJUeog39WyLvkZNMGNgohZJntaiQUU8j0nPmd9lNoogZdkslgv5MqGMdPwQWDkXuComNfCB3lHNoGackYBeLTmXZZPr9MjGk0Tzmz5Sq7btFtLlSTk5E7qxDtgiOfD1FYiSgFl8tslQZZshfL9Kx4vpTUmm6ua51lCV8rvElD/bbIMpCnShquM6sbGog74weScK7xH8r4+W8bfnJdBfrYA2VSwDuZrGejSqLSitnFaKwjESY1l/XmJB2gOjMn8NfBhySHrocuq0RKQNiWDfl6TSV8v8azMgc9d7umyLJrzOllT+mRePaVQepqsoDpzZS/xZmkZ56jWP6YGCbz32G63AOypkUvoJKDqpPmuFjB2qgE89vf38bKXvQxnz55N97z3OHv2LF75yleO0t9111346Ec/iocffjgd3/Ed34Fv+qZvwsMPP4wXvvCF+LIv+zLccccdBc9z587hf/2v/2XyXETFZkgoAFlhw4FDZ6spXiPDUF6zoaj5lyYXX+djHMhDQoxyLVtXhCh3QEZqhbHmBDM3lrcsSNmSJOSSIf3LQOwZCumyWc9lLdPh9L0sTxEenK+7/Jmjxetr7yheE7yj+JyKfFMiaXHGE/vyWQd14OtOHLJNZRtLPhqGmSBEHYVe0kGx3kh1z+dSX8XRjfUy2j1hst20IEY/iKnKLQpyX9J9Ob0HRvcw+zG/b1Q/ZLmyL2vAXb4W48AdlkiJSFS8AIwOxcvl9HeL7Gu5V5S8xzpttIyumt8ljEEWUBpF2qizwpNbI/W10fEpw7aWVxt4cyBnyssxJ2vNEzCVfirs+5QxPgVCdTtYn/W9OXCj8+1SD81riU512PhafafA15L2WgqKLLktvexyrwY6al5GXae58O1Wubu8a0uAxBIANQW65nhPHXJAZ8pbJmmub1+rdOrTFO+77z68/vWvx8tf/nK84hWvwAMPPIDz58/jDW94AwDgB37gB/CCF7wA999/Pw4PD/GX/tJfKvLffPPNAFDc/4mf+An8o3/0j/AX/sJfSCGEn//854/2fZklOeBsGI3BGMohwPO9YDRt+UnXxcOFM5ANQs6ZPAPyHJOqQ5MTYmXjMF/1EXMn440InqKkFC1POOEl43PkzAXwVEouzOfHwXCVHrJSdR2cXPqTs7NBLstMlrWiTjYIpx+bomHqnLwjjG+d3/xcZpv8ukr9gr9A87ViAyB7eaSOZPsFlraRrXGzuQfbhLBpDKsQT+pUZ3biljb2jYLStgZCECtd6vNUFM8gJ4MgCcQy16wH4b0TGCZv4sx9WtbDqfeaYqj8WDYBefgCorUIebJgqY/aOymv0/gKXxBlWaRsocL5XevDaRg8HPkI23mj+fyWZekUnQSUXeOeMeAK/13C2GCzvDO1xf5ElEa29V5NwNhAmzKu5oxqNtgsQ9AiKbM2vC1vAvPnQ362gJgsX9fLOTfSmUU1L5vOtxQY7EJLgo1oeSyPktbFFJiweFntZHmAauBgTu4aLQG4UwBgrh9asuj66LNMY+nKym+9a1q30mvNaafA65wX0qq/rq/3vlgjpvOy3H3fm4M7Mo3Wg6Wfk3i5nq2esVMHY6997Wvxuc99Dm95y1vw2GOP4e6778aDDz6YFjp/5jOf2XljuJ/6qZ/C+fPn8cM//MP44he/iK//+q/Hgw8+uPNeLoXRNnoUDKI87Sibh3L0OpETFrN+mbizKCC27Gu7YkSDAZkT0oVrDxHeQgNOs1A2ZmnR7bEkfB0kcSgnWiZDNd0wkIVZRUar+iEZ95xCPTMvqMhOhhhJZoMIKAKK8Dl+XY+AtVN5ASWqLkrgiRGzTsmoBVtEGoXWOoZUEso+ToKHFS0RuZ9nTtrjlcGZBjdSKqlfgmKggZgkUocqT17z+0Mg8TkwmdLOqD2L75SJnLxQzmUu/J1ifS2NPGOjsnagTUWsuTzPIrqif5dgG//ymTa0+L7l6ZkazZ8yZJaOru+Sx5J7iRyyzlPyyBF9y9is6c0CL9Zzq7ypz7qcXXjU7u+qP8671HOyhH8N7D1dNAVIrD48Vzf5Piz1ROr3RvdBqz2WDkpoADM1JVLWcaknbaq+c++arpv+TtGy1/ifBFjNyXc1k6Nna80ugc6dO4ebbroJ2I9j8wySBg5pzaP32WADsrGUlqDwb3XPXrF4FEYsISwMAbD18TPBeW2Uju2jsbEexssBFBMT5Rh/ltHH0fR47qLx1yGMxgN5nhjnJOT9njzgfHBWdVFW3gCbDVlJXpQ9jO5l+ZNBr79wio8CqcroDtm9IvJoYKGJct0WWK8mGLOMekLeNUCImQ4at2nBzin9uHwGn63O4ZSMszVh/Vg9TDOicZ01ICsErAiSBh+yr5RflewNy++XMQ6dNuPmgQ/vgCFWgXpmEvuR7Et6bzcK/diRK6Yk8lmWaE9Djd8JMZ2lQS/OSUW8ZrTr8jpSJ2vK71v53cD9KujIFWWGalE6Q5azJTzxxBO48cYbDQkD8ffeEz8A3LhfTWbnXQM3/Spmy2h0acRttLe3l+4RUdq8WY7C642hrc1XV6vVaLRe8uVju92OjKe5NTPyPOel4rMOny15yI2sdZkyRP8wDIVB7Jyr5pN1tPbVYpIj/kuN6BrY089OAtDmyPJA1Lx30stTk1HzqW2ybPE4CWiX/JbWU8pppZnjN+W1kfqxPGNMug/Kfjy3CTun57wsr+x7sswlbTzVz6YGZ/S7pvNJD/vceyLTy3eZPXDb7Xbxb9PNN9+8cz8iInzxi1+84n+bTt0zdkWTnPfDhqdE/fFvtk9lsA5kQ1AufpEUgVcJcqgasa3IKg59lz120pyUZ57k5MU4f/DkBJCVZCdZuKuUVn52lU+yDk48Hf3U8FQ3MjJqbnIPNb4vPQpW5U1eUffpGuI8QdIK1g0Sr53Fg8VWzxxKDGPJn9JUgNgsFQA1Zl4ExCAQISNOIXBKNyNE8R4xmEhQvNrfJXc9Ha9Qe2JicOKEcVoiv6wd8crKEowVIhdsJBjLaaymk/3cZQYgLzoBv3MdlcARXA8K3yGe1Z9LzV5mJzzyQorxl8Q8Nc/YFU9ynyo9Es2j3XJxvTSItEFoGZUWSJGkDWwtQ00unVcbe13XjULNS35c777vIanm1Zoj7SW4FG+G9Vzntbwqc3xr+pyTQ/YFC2CcpB41rxGfLSC21Hg+KVCVdbP6zC7lT9WPr+fqNedZstJb75rVX/Q01Rr4tOq/RBc1YFbrD/y+6u8brUstp06/lJ7NnrQGxqYo2TwkPrvikUxc2KMWIKCcNhn8njIQIyQAFY4yIDgZZ2kLcwRBAttuPq19kaYvG7+8QWy2r2MdPIMaZ1u+bEwLLMmPwqoWaYoKWdMRvyhqMDMJKwDhGLWNs0p0U4A5CdiAUbGpDJGp8gJPvtaGBa6XTLl4j+LZEiXFixGYVDqcxgEzdpBR6jYBMRbOAC+6344KEpWUQG1u47GcQSXLwIwHCoqs6ZDr6kpxJsv2VHT68n0bq5VEaV5cp+mCIjFRzl8DZwBPFY5qKCKoUn7vtH4cgpcrbRqe31nAFfpIGU76G3QSYNXA2GUny0i3PvO9KSPZMvSlp4jJ8njIfFOGjzb05GbUFiCTZWkwYW2aXPP+1HSi89UAizZopR4sXkxW3SyqeY5kWbsAsSVl7aIf+byWbhdwuZR21Qs/s7xlS+Sq6Vi3/5I+KMGGBRKtMvS7NheQRfdZy/Oty9E6qOlWDnxwOkt3Gnxb5U19L+zalxsYu1aJDSWgMM6z+TO2d0h6weR0P84p0Q8hTEMaAheOT8HBC6QlrI3PZJTLspOcBEIXefjI0d6fLNeQghikzN+0MbUoOIHJrCaGqF0codfTFG3jWWpPIS5pzZJ+TvnUGXn5lnXD+i42wd64npOkLHACMtoVxLpivEvIAC2lkcALJb6YBGJLZJVATDJy48mAuU5Uql4jIO7L+tmIEcR7lBNa651Cr5VPhOEoIFKadci6N19KPlMO1sG4B4Q0q1GVwpLksnwCZcQASiEuOT3VJb7xx0oO5MT3jAYKszUdgN4HIJY8ZMyIwnuof+Q831L3C4SIRs9CmjPOLQPImmKlAZk8hmGYHKVnmgq6IXlbYbBrZznFUstk5bHAlPSWTBm1OmBCDZBZxvdSoKTTTXnQanm0PLvQnOdwCQCdal/LKJ/yplny6QEDXYZOO0VTwLzGZyq9vMf9oPb+cBrtma71KwDFu8ay6ffVqp/3Pk1RtqbnWnWz3gcpN/PebrdwbnrLC76v9XOp4P5apAbGpoiiUVT0FxJ/FTlxduoeW+rJcC0N2JDFFWeZswAzI97IhmiaJynBYr7WEMkSn2S9rZclCUCJpzaxu5GBmOsAlb7kIFAN6XvCyqWoNAaHLnIjxaPCuqoGC2xMUYloR2zZptYiWDxIXZO+VxvU042whAq9uGm9FP1V3NQdkoT+R22nGVqFWNVxEcCWz/UxokJZpDIwZzmNVypAl1X4wnKbVEBx4iSK7URJZXkUxEmIXJwBmHNZZZ8y213qHlaCaVrvnqV5xi4vWR4Xy7CxjP4pr44GTTLP1PSsOUNdyyuN0yUj7tqzoL0jtdH3OaNvzluh6yO9HFY5U2VZ3hXNtya7vt4F4Cx9NgfUauVO9addAFlNxl31YrW5NTCh083V08qr5bJ4WKCoVhfrXVvyvsmyrDwW8LQ8ZFZ7Wfqsvd9zQLZWxlK6XHlOgxoYm6Ml7ajBl0O0wpmHABc8TSqegxesSyPoDMZC0RK8uLQon3hRfh/PhQUf+PoBcBQNPXjBtwR6PBVyZHdzB2ZEkYCPrnjekDZLihSkw6KR7V7kZ0NAI02RTgrrxAet+85FV5TL97guhUDKWIdoJy2eJZa81j8cQGpFjQunsFVqhwrfEVC2ZK3JzZ4XGfzEEih3BqEjdQYwXjdmFWwJRsUdQnbEDkCadmtR0V+BqB/VT+Nrl+QHUruG9y28DXlLhsQt/Q17ewX/GO/DlgKD6I3bKXq5fPxhTerl9y7DP/b6Je+eJwwU+z6/11yW1p9T57qaTkYNjD2rSHqbtLGmjVgGY0RULOLXnjQrz9Q6NIu/3khaG5HaS2YF95jz+HDZOsDJVNra2fLWTBmWlhHKh/auWAZ0DWxoj4uWRV5b9+RnXcZS/SwB9TL9HDDisw4KM6eXJV5NS35Z7hTwqPXhOf5zAwO1wQVgenqirLd+j2TADe1Js/YXlHqQAUIs/vx9UNuseuk7canUwNg1TpaNWk1YJJbWtDT4hXGLbKbJCG4OwsmVDDdRBgOMNI2QwZ5L/ClOs/TEITtY+jKwByFv1FwAK0YDxToWpRWBMDKMqmhI4wnLTjfzVleXyT/Z+Gb98PqaAqTRuIgCZCBXZikYc9UbEI2cijCrrcUxn0jQQyVTA+vI2YWFaB4ogp+4mGlWL5QXO0kwJmo1bidrEqIQUlUv9XF+dSa+R+1e4ZQuRN+gDMSsQxfG3rBRYAyOiir7VMoedeF1zV3xN0A/itMx42TIBBiRgVjxQ8LozuVrEuwNvDau1QLanCDTdtdCGl1OmjKyLWAl80kjjO/VounJPFZ6yV+CuCmZLaO0FsBkqo583hWQyfvaW1Mru2aMa2NZe0OsPLWjVqb2VFiA1fKUTNWd80xRjd8UEJM60ABIyq7TWyB1Sjc13S65vpQ2t8q35Ndpl4Bdndc5Z0ZA1HrUa9nkM66rBcr4fbUGWyxP2TNBDYxdw+SKK8LI6qmSADLSwE8R3ALnHh164Rkry5ZlCjm6LhiBaQSdjXQuz4HDhhPxJYngGprnuM4OGYtZRneRWrEsUrGhrwuQt7VKhVFrYZ/aZ8mTiIRuqNwI2vIyhUxRXAdHedWerkqaMir1kyx6p/hrK5m9lVoAV3xKco6AHicShnpECqWjy5VqpkKtIP5h0aE7izKSMmPdc182o0TOEIm/o/JkF+bPo+7mcj3kAyqfVwpWQEzqR4Ow3MYJiKVY+y6Hou+EsJRzgvte0cG5TPmNEv6FNZZdLjN9X5DMLrqS0qHZFhN9cI7WqOwgPUENjJ0azU0TskgbnBIkyVFy6RnTZVokN5DWRh4bdX3fj8BcbR2OLM/yzNVk0Qb0FNU8RicxKi2PlEWWIT0HGObSWvylB0brT8u8tK5T3jZZtuS5i15q8ln8db6lupmiKZAxxatWruXZ4utd+4C1PpPftb7vR2vM5oCwJaMGxlZ76j5lAUqrzEsFbQ2MXaOUQElxp9KwThyJqPSwMBgD0tTEHq7Yn0vkVGXGs+syGJOj85w5RWaMBmOcMkVAmvaVvWR2NTrk6GwSqKRCpHHIF5Khi+FNRt8rBiibwAIJBKjnpTk7poQZSBrapHQ6LlEa6nIPpxFGgTDWo24ptQPrwpXFKAOdtFEtS+EvLCf1LcFHrGDsSy71KSd2UTC+1PkgJA/oCCBJ5DLSS6Za/2F+k19/ghkBo+aQ2Mp+qBOOBIjXZV0cxnURP5NFT5H7lwUwJkBYAcaELET5SL2k1KT1nruUOk5epODNLoRMujCA2CTW2hGIAQ2MXYU0Zdgsne4lw8bzuTbSXgMJGoxJo1Au9GdwZgUdmPKUMY8lRvtJgJi8bwGyOa/LHOjQHo0loNLivcSTtlReDVrnjPaldavlnfN01aZhWvc0v11A7ZSc8qyvnw6qAbFaYB0+62mZ+n213jt58DtulW1502ReDjIy18eXgKyT6rOBsWuWpFk7NltHxA8t+0fZUMxZG2cy69ikVeArneM16UIcENe5MA7QxnL9ldBGowQDrhRUW7bach/pg/JJ4zvDuLSgE7eJE58skaQ5ziY5FSkyR7mJ9zQYCxM7y6iRlPEqz790UgoD0jlXIg8nris1TkA7ea1yHyrlHsMxnv1GyoIve3a28KWOx03sIPUtuapalvcUEEsqGFVZ5EqAx2X9yipYja0SOFGnsl/LGuRzgeksUORcPnN5BXimokNaUyrFT72ohvHlQaOLRSR7wNXxc9RoKdW8HDXSI921Z5K3ZejW8mqZ9LUuZ24kXuar1d/yfF0KANP1sgBZrbw5A75Wxzm5LP58bUXYk2mnAJkuo1ZPqWOrTWvyaj7WekUptwalc4BQe/qscw2A6b4z1Y+W1lfynyL9vtTeCWsAYGoAQr+zFu85oKp1apWxS11r9HQD22cLNTB2AjLMJXuEWll3jtijkNeHWYauZktAmFbmEAy+4pAMxGc5f84HQJaWCgHJmC/t2LzaK5v0pSFZ2IXJMI33OlG+Ewkdl8eWaRz5Si6snCzZs1KXJGQimDrL9/TubIF8ghYyF+d1xV83uldSqEkZ3IGDL6Qw5QXQ6lRuIMe1RwWxiGupdHIpjruLMfB5s+IOwcvK9zSx3HxGlB/icylF7hUWN729gz4XVRHdRMaBSYBM9qGUgTtDJxg78VIg9yEGROrFtN+xEn5KSEZRvqQXdjV2EIE7YHTC+IG3M+i6ECiFKO1VwCCek0n1hGxB430Ej0Rh54uCr8xkKvxpoA1294xNRexpdNmoBphqHh453UiHvdfrvjTPGoizDG99bXm4LH5aVuv5lC70dc0glfy1PNpYnwNNNQBVAwc1z5ssZ0lgC6AMaFEL2DBXjzkgZOXVIEcfS8CYvJ7y7s21JcthtZ/eUFzys8rZBYjW2nIKeFs8p3hIjxjrtRbwQ/fZOUBWy2u9qzqAjsyzdBCA8+wC6ppn7JqlHRuxBsgYjMVbYwBhGfzKLyaB2BTp8tU9uaysCPAANkmzRAzEMsgZCWkAQSEfu7mkyETR+h5ZzSXoihdOlkGVdMqv4IynDIItMJZNds4v/5X8KHFw0bSmlCc9L4xkXX8TfVVIpZEgJEkR/vK011JuqYOypdlX1MVnWmcsI9df/XwK+UikLjG6vJbVdyYHmc4Zfd2NmTE4Nd9T2XZcF2WkFnXJ8lnXi5rLJNlvam0/1kbqX7qK1vcLynv5dRnv97eI1sh7JC6lBsYuK+1qYNQA2RJDXRuKNeNyyYi3BCYWSKl5R2oG+RKyvAc1WgJEpHw1PdU8FlZ5FhC1yuZnGphJXmw4s6Gup/xN8V/ikbSeT7WNBmRa7iXesKXg1yLL42fVU+tmyuOrz1Pe4qkyp2Su3Zt69+bA9RzwW0IWcJ0b7LHy1gDwHDUwds2TZbaNHtfvF4aSnNjGR2kqx9Abyesymq5I8U/ywsjMcZFaWjsmXhBlCBPyB5EKltEoQSON0vPJ5URsOMsdcJmlF1n58QhgGeRKuZmdlUdKrutca64ltjdzy2W7GA0v3M8AV1rR0sLH/LVJkbHwJmagZAGwsgY18z8/G4MayV/nKkXP7wd3g+qeaEoe2QdtYQUo00xdUWqhFyk/RJvB+JvyxAwkiioifqbonCSVU5Sd1oiKZveO0FVeV85MyBJKmUz95Gzl2Uwy1eMr1MDYVUc1g2OX+9pI1kAByCPzelNbnUcG5JDPJI+lRucuRnqtjlMGvWVMTwHVGs+a4V8DbDLNkvJk/ikQosGDZTjr6xrNpZkDzJa3xtLHlPdorn41eeS9Xbw1mheD3DlAJnW9tD21TCcZdJjaJsHyZumyZP45UDoHPGv3rDS7DKjswvvpyHMa1MDYJFnGZ/yiLe6hxDA2C0Gis0fQNQZoDNKEOZWM0lhYOovCSB6q/CgfOUP2kdDZs8CPTYM+GZ5sCYtUycIVzySS4mRLgJgkVxYpZWY++SrztprC8gnJPJWfg5iTgVilP0gvoBNKn/tuGPUlBhtKb7CBmAT8c6Tl1kBmDOns4Bypz04VPPWs1smcuNDYVvalkV6mi9GNQDKTif2E7j3laYNOZiDFNmuX32f5rkv2GSrKff9E6+z0/SIz7AzFwjTFXcHVrtMaGz1tNGdsWCPXS/nqEPI1kCbT6DwacHCaKaC4KxCaq4cFguR1DZDtSjWvyK6AbA5IWmQBmyXexyn+JwVisuwacJqSXctsgbk5MKzb8KTtaclSa8OT0pJBkynPKoC0TYQFqGQURp1fgjFrHaIso1bPJSBtLs8SamDsGiUSf8sre1B8idXDPOUouVNWVorUJ65TZml45p1xcwIGYuwZU8aqtHlHhrMpfwZm+VOWs8hHQFo0ZRrOqg4y0mSF0mOFOVl+7aRwKKfeyclpWQ1UXAMu1cWla17Fk9sn8yJRhRFkLisljWhZgdm+4nJFi/RWfyxNeZ6epqGTXC9GIs9I5gkqdSn7qdFWLou/uIi0x5a4V+jA5T5OiH28TCqnnHLBWg8l73x2zlC1E3I58X45FwcfxIuUlKF7m96Hb/zy8XPpOFZJJmn0fbQ7DGt0ldCuxs/Uc2sUnQ06bQDqaG6cXxttwzDM5p3yViwdha8ZqLV7U1OltNE6ZQjvMvqvwYO8r3Vu6UTKLvlJw1m2geRX2wx5qVG9pI5WPt0neMrkFPC15JRplnjxNOCX909aJ5ZfP5f11OVYZc71Vd1Hp/JKkKj37bPeW2sARF7LtrHyWu1z0r4i63S1AKXLQQ2MzdDT1VUk3GLzXxqL8kzFIS1CZBBTSEbZKGUjVRrwImtxzZ+lFadBQwFnIMxcSqCHuEw2TJ1DnueFbOHywaPuBhhL2MVwb2iDP2EVZPudoVS53itrUepV3+O6Bdub0qdchvqSigY0xasS3KBsh8LKH9d7TFoxZN7ORvwYgkg5+ZzrXgKFEtBmuCDrLkGnF3VP4MH4rRw1Y1R29WeVg2PwNQFpg+o0uBDBECFMyyVuJ27z1ItGGkgOnLJyhXgFyU7HbcB7CThEQMbCynyUDiISEjmMU4/7VdHXLzdtUN+7oEbNM3bZ6ek0ZCwgVnsu0wE5Up40DKd410DOlPdqDrjV6qQ9G9Ym07WgFxpMWV6SWl0lMRDhYAss85whrz0S+ix5aZLTSecA3qUY1VPAaao9ZV4NKLR82itmTamT+hqGodDBlAyaagMINVm0zLKfWXXQZOWd8yRa76LOVyvTAlayD0yVPQWWT0In4XO58pwGNTB2QpLN6yr3dXpp5IZ7VuoJQ6zWqdJ9UsYjSpvUiXtJaFemVZVgLwvSWSYYwY8xaGAjmpDP6XkWbvTqk0gishTZlDg1qeTncrkaiWuuIaVzBnLad4n0RPLREmRyY73MkW67SsYMrhDrJxWT85X1HYOxaXIpZS5n3NWkR0yciirodja6nGyQmIn7EOuQgU5ZR2HWiQEEq6ZKwJRRtJEUqPY+yed6F2wSTGIelqNkMWZY6tUqMNOS756daY0Gxp4lVFv/YZE2bnehJbyXll/zAuhyNGisya4N3RqAqAE9aaBawGbJlEc+yymc+tmUV8UCgjVPk8VPyzyli11piu9UnZimPDZL5bM8trvKXvNIWUBpqo9NAcBaP5bPp6Zh7kInBS67viMW7fK9s6t8lyPPaVADY3NkWov1hOMxbvkp3y3eM8MDNKZ412djW+8p5ZI1LMqm7LPJXoHoveJrXUw0LClOdSTmDUIpdmnoUgpwYLgdSB/lvl4WfEgvUTLyXebNbKOXkHwsHzLyOAcLRylnEoH5Mz9WnsvAQRnm+utaG/pU8FG5FJ9xj5HACdn4l5klOI2uKA8PP/LbKSmEkk0ZCQARHOV2FpNgEiTQB1yXw7+73C7cb0KbhMAmXCTHfWT+sprR0QWBXlAMNvBnz/Lmttbh4uX7luAnh6d3EGH0hRJY8RHsZf7xX1Jb6CPZASy9jpGHfAXUayB+qkphU3UNwwD2/acRhgXaVIqZoqvj9+5ZRbsCpyUG0pwnwQImTDrcdW2EfqkHaMpLIT0p2nhlj5GOJMjH3LoYycPyjMnw4lZ6yZOvdR7tGdPyMtXaTMur5ZHpa21aK2+pR0bzszw1sk/UaM5bpeW0ALLuU7U+WAO/Ug7ZP7THbsrjxe2s5ZwC9FJe9jD3fRk9SabRoe1ZXgvAyTpqubV8U1Rrd0lzPGp5LhfAvBqogbEpslFCJSGbrJy0NLl08sLemgBmqVwJCvilQgYz3UhQNtTFGiphPAYGLh8pqzB4C5fAqArpvsQLyRD1qv6SlTBwu8LElL4qIYaLKZwL+zdJ6uIzohS8cBy1TprlahDfIewHpXXgBAZIgtiUjH+rPROqKtNz/Rn4lBIi35NqVHzJldEbq86JpL8aL6Hv2IiuyJxBau6Kgp8EOOzF4nOsgKxXhjbhKvMU4FluipcqFlOK9yHrElEqKW+hrlgFJ/bDE30/gq+MOrMeOjFgIIOkJNyWdC99lEJ9+ntEyqNFle0tgZ8il2psZrg0WptFTtPV8Xv3rCHLEJxLL9NOGU+15xYw00BGG3y1fMAYLMnnlhHNRnLNa6T5W8BIl2vxs2SwDFILXFl6sQCApd+pKXFaVmn4zwFoTVJurfcp+XQd5sjy/liyMhCx5Lcib04BfPlZ7r+l61irgwXsLS/fVLlaxhoYs9JbMk+tfZN5avwtueeA2FSdJY/avV0GiHYBS5cTjL3zne/EP/2n/xSPPfYY/vJf/st4xzvegVe84hUn4rWEGhjbhQw7L9u2umNWEk8ZxqOpTuNradv10aSVG0hLw4zNYPacgEf8GdhYYKyQRyMSC+DkpT1e2IQaVDFScZQBGG9ULPl64V8g+NJo7gQYk0Y0625gQ56SkZxVGgGW1HkX+aR1ShKQJYGiYS50Yb3brjSJnbgv2650mDBAyWFDEhaIolkAj5+NZFXyhLMQrHOy8JyZdzlmQBK9U54Al9FwlMWVvDoFbhJbyvyYWeTlMN4TjVtd/vXMxxgUSN2CRFNm7SjVGC+PBvbORRnVKKx4x/q0W51UYICQA3yEgj4GdTGaxQBloVOq6kkRzN8RYVwIoGvSSXBaA2NXHVlGTW26U80AqhmPFg85Wm+Bkr7vk6FoeaI4La/vsWTRBrqc4qeBg2VYyqARNeCny9TehjmPztQG2VpHc0DG2thZ8pWyazBWAwVSnimaavspT9icjqbAHdd3anNxuYWC5cnTMsk6cB/UMktvkVUPKY/2LNXAjZZDt6FOI/WiPWNWep1Xvlt602fdR4io+p5JWTVZgGwpOJsDWVrWpXS5wNj73/9+3HfffXjXu96Fe+65Bw888ABe85rX4JFHHsFtt922M78l1MDYFLHxVNp3VUBmMxCJ2TBm61GW4VR6tuYS2EAy5Hl6Xx+N2r7Y8ldmD1MUtzHzEMIvlgUncKPqFo1yXWltyycxXfk54b7CgA5T09iozVKX5XhtynZdqHTXCS+MMvw7QnYTRZc8oTRUpdXeIfOS0+zK6paLozhwisYHqgMUdaLIVoIwJZLUrQRkAIpAJpQzjEnLIftX4blS6aQ7kevKYHaQYEYArgSMxQFk/RVAzOXP8KAEwV3yOGUNABwmxMMDFEENlQqTzciATMb9yIDOoCR/V05TTPpz4l0EeDvtHg6r1G/LknKbEYZ0JeLTyHeedZRYKDA2xp35O6DMWNzR/aZ4UZ8FQOkrv/Ir8clPftJ89o53vAM/9mM/dpklOl2SxoxlrMt0tfy1kXILFEiyvD4yfdd16Pt+ZCzq/DLQgp5+ZZUtDWQ9/c1KbwEUS25ZX20Q18rUsmqDWJYv6yfPuj00sNMBP2r1kFPQlm7yLEGi1qMuT9Z3yjNYK0fz1cfcNDvuJ8MwjOorZZQ6022iec7JpqMnMqCvtaEF4mu8LP1qcCXT86CCftc47Wq1Mvse607ryppOXOtnkpeu8xzgt/rNXH+5UuiXfumX8MY3vhFveMMbAADvete78IEPfADvec978KY3vekZKbOBMYNSJysMIozvpY/ZlMz3DQuIRLqR9WRZTMLwp/IjG60uXSkjHmwoFitmBBOuY0QLRUbKhyier7V9V7BT6WWq/CzLnfSR0kh5hazJqLfUJO9zPpZfSJOVNxbaubJ9IJ4XfMcVTHjZGfdiFifFEaXo6oy6nKgayQw1ESVjpxgwyNB9TuqPaFS/lJZkHnUU+pP8dV8qVlVBvzNl6xvT/tSrqcGcKrmsSmpz2ZcsAEmiLiyLDO1Slma9Z7J7lS+Net9ShZx60cbtILU2Hg5ROij6ObO0Xp4xndssSlbm4fO5c8X9g4MDHBwc7M5Q0X/6T/8JX/3VX42zZ8/iq77qq3B8fIw777wT73//+/Ht3/7tl8z/aqGpqVJLvSNWP6gZ2bW0NWBjyTMHiqaOGl/LS7E0vZWODUaZR3sZamVqUKx1ubRuOr/mX2uHmt7ldU02Swc1muLPVOtnFn8tkwX2lrZhLU+Np9VvrH4wJcecbmp6mOpLtbJ3fUemdKJlrYHtmlxT5Z60n031O6s+J6Glv03r9Rof/vCH8eY3vznd67oO9957Lx566KETlb2EGhgz6Atf+EK4MI3SMQnzaz4hG2S7bqoqWAzx2JyUiSfAL8/LZQLA9mQlJk4hJPqOode2T2OoNlaekKk8n5wsDpfEdWH/u3yMCKCovBN2PeAS+m2WItVmZ05bv1N/2qa++jS8sMVNK+EubBd/MSV68skncdNNN1WT7+/v44477sALH3tsJ1mYnvOc5+CFL3xhce+tb30rfvZnf/ZE/CQ9/vjjWK1W+Lqv+zocHBzgwx/+MLz3eNWrXvW0gL2rhfi3acoglTRlJNbSTk1pWpp/szkBoo95dymfR+pPKjNQ6nIXPkR2KP+T0nZ7ab+u1zJdat8Fnh79n7Q/7NrvZfqjo6MTl/l00y7fM5KW/jY9dhl+mz7/+c9jGAbcfvvtxf3bb7+9Ojvj6aAGxgx67nOfCwD4zGc+M9lBrjU6d+4cXvjCF+JP/uRPcOONN562OFcMNb3Y1PRi0+XWCxHhySefxPOf//zJdIeHh/jUpz6F9Xp94nL09JMpoPSmN70J/+Sf/JNJnp/4xCdw11134aMf/Si+4iu+IvH7gz/4A9x2222jH8xnO7XfJpvad41NTS82Nb3Y1H6bTo8aGDOI58/edNNN7UU16MYbb2x6MajpxaamF5sup16WGu6Hh4c4PDx8hqUJ9Pf+3t/DD/7gD06mufPOOwEAf/iHf4iXvOQl6f4f/MEfFJ+vFWq/TdPUvmtsanqxqenFpmv5t+nWW29F3/d4/PHHi/uPP/447rjjjmes3AbGGjVq1KjRZacv+ZIvwZd8yZcsSvuHf/iH+K7v+q70+Q/+4A/wV/7KX3mGJGvUqFGjRtci7e/v42UvexnOnj2bfnO89zh79uwzGiiqm0/SqFGjRo0anQ557/Gxj30ML33pS9O9Rx99FC960YtOT6hGjRo1avSspPvuuw/vfve78d73vhef+MQn8CM/8iM4f/58iq74TFDzjBl0cHCAt771rVfcnNLTpqYXm5pebGp6sanpZTd69NFHceHChQKMveQlL8Fb3/pWvOxlL8PXfd3XnaJ0l5da37Gp6cWmphebml5sanoJ9NrXvhaf+9zn8Ja3vAWPPfYY7r77bjz44IPP6BplRyeNE9moUaNGjRo1atSoUaNGjU5MbZpio0aNGjVq1KhRo0aNGp0CNTDWqFGjRo0aNWrUqFGjRqdADYw1atSoUaNGjRo1atSo0SlQA2ONGjVq1KhRo0aNGjVqdAp0zYKxd77znXjRi16Ew8ND3HPPPfjQhz40mf4//If/gLvuuguHh4d4yUtegt/8zd+8TJJeXtpFLx/72MfwPd/zPXjRi14E5xweeOCByyfoZaZd9PLud78br3rVq3DLLbfglltuwb333jvbv65W2kUvv/Ebv4GXv/zluPnmm3H99dfj7rvvxq/92q9dRmkvH+36/cL0vve9D865Yk+tRtcWtd8mm9pvk03tt8mm9ttkU/ttukKJrkF63/veR/v7+/Se97yHPvaxj9Eb3/hGuvnmm+nxxx830//+7/8+9X1Pv/ALv0Af//jH6Wd+5mdob2+PPvrRj15myZ9Z2lUvH/rQh+gnf/In6d/9u39Hd9xxB/2zf/bPLq/Al4l21cv3f//30zvf+U76yEc+Qp/4xCfoB3/wB+mmm26iz372s5dZ8meWdtXLf//v/51+4zd+gz7+8Y/TH//xH9MDDzxAfd/Tgw8+eJklf2ZpV70wfepTn6IXvOAF9KpXvYq+8zu/8/II2+iKovbbZFP7bbKp/TbZ1H6bbGq/TVcuXZNg7BWveAX9nb/zd9LnYRjo+c9/Pt1///1m+u/93u+lv/7X/3px75577qG/9bf+1jMq5+WmXfUi6Uu/9EuftT94l6IXIqLtdks33HADvfe9732mRDwVulS9EBF9zdd8Df3Mz/zMMyHeqdFJ9LLdbulrv/Zr6V/9q39Fr3/969sP3jVK7bfJpvbbZFP7bbKp/TbZ1H6brly65qYprtdrfPjDH8a9996b7nVdh3vvvRcPPfSQmeehhx4q0gPAa17zmmr6q5FOopdrgZ4OvVy4cAGbzQbPfe5znykxLztdql6ICGfPnsUjjzyCb/iGb3gmRb2sdFK9/NzP/Rxuu+02/NAP/dDlELPRFUjtt8mm9ttkU/ttsqn9NtnUfpuubFqdtgCXmz7/+c9jGIbRTtq33347PvnJT5p5HnvsMTP9Y4899ozJebnpJHq5Fujp0Mvf//t/H89//vNHRtPVTCfVyxNPPIEXvOAFOD4+Rt/3+OVf/mV8y7d8yzMt7mWjk+jl937v9/Arv/IrePjhhy+DhI2uVGq/TTa13yab2m+TTe23yab223Rl0zUHxho1upz09re/He973/vwwQ9+EIeHh6ctzqnTDTfcgIcffhhPPfUUzp49i/vuuw933nknXv3qV5+2aKdCTz75JF73utfh3e9+N2699dbTFqdRo0bXCLXfppLab1NJ7bfp8tI1B8ZuvfVW9H2Pxx9/vLj/+OOP44477jDz3HHHHTulvxrpJHq5FuhS9PKLv/iLePvb347f+Z3fwUtf+tJnUszLTifVS9d1ePGLXwwAuPvuu/GJT3wC999//7PmB29XvTz66KP49Kc/jW//9m9P97z3AIDVaoVHHnkEX/7lX/7MCt3oiqD222RT+22yqf022dR+m2xqv01XNl1za8b29/fxspe9DGfPnk33vPc4e/YsXvnKV5p5XvnKVxbpAeC//bf/Vk1/NdJJ9HIt0En18gu/8Av4+Z//eTz44IN4+ctffjlEvaz0dPUX7z2Oj4+fCRFPhXbVy1133YWPfvSjePjhh9PxHd/xHfimb/omPPzww3jhC194OcVvdIrUfptsar9NNrXfJpvab5NN7bfpCqfTjiByGvS+972PDg4O6N/8m39DH//4x+mHf/iH6eabb6bHHnuMiIhe97rX0Zve9KaU/vd///dptVrRL/7iL9InPvEJeutb3/qsDR+8i16Oj4/pIx/5CH3kIx+h5z3vefSTP/mT9JGPfIT+6I/+6LSq8IzQrnp5+9vfTvv7+/Qf/+N/pP/7f/9vOp588snTqsIzQrvq5R//439Mv/3bv02PPvooffzjH6df/MVfpNVqRe9+97tPqwrPCO2qF00tYtW1S+23yab222RT+22yqf022dR+m65cuibBGBHRO97xDvrzf/7P0/7+Pr3iFa+g//k//2d69o3f+I30+te/vkj/7//9v6ev+IqvoP39ffrqr/5q+sAHPnCZJb48tItePvWpTxGA0fGN3/iNl1/wZ5h20cuXfumXmnp561vfevkFf4ZpF7389E//NL34xS+mw8NDuuWWW+iVr3wlve997zsFqZ952vX7RVL7wbu2qf022dR+m2xqv002td8mm9pv05VJjojo8vriGjVq1KhRo0aNGjVq1KjRNbdmrFGjRo0aNWrUqFGjRo2uBGpgrFGjRo0aNWrUqFGjRo1OgRoYa9SoUaNGjRo1atSoUaNToAbGGjVq1KhRo0aNGjVq1OgUqIGxRo0aNWrUqFGjRo0aNToFamCsUaNGjRo1atSoUaNGjU6BGhhr1KhRo0aNGjVq1KhRo1OgBsYaNWrUqFGjRo0aNWrU6BSogbFGjRo1atSoUaNGjRo1OgVqYKxRo0aNGjVq1KhRo0aNToEaGGvUqFGjRo0aNWrUqFGjU6AGxho1ehrp1a9+NX78x38cP/ETP4FbbrkFt99+O9797nfj/PnzeMMb3oAbbrgBL37xi/Fbv/VbAIAPfvCDcM7hv/7X/4qv+ZqvwZkzZ/BX/+pfxZ/+6Z/it37rt/CVX/mVuPHGG/H93//9uHDhwinXrlGjRo0aXY3UfpsaNbpyqYGxRo2eZnrve9+LW2+9FR/60Ifw4z/+4/iRH/kR/I2/8TfwtV/7tfjf//t/41u/9Vvxute9rvgB+9mf/Vn8i3/xL/A//sf/wJ/8yZ/ge7/3e/HAAw/g3/7bf4sPfOAD+O3f/m284x3vOMVaNWrUqFGjq5nab1OjRlcmOSKi0xaiUaNnC7361a/GMAz43d/9XQDAMAy46aab8N3f/d341V/9VQDAY489huc973l46KGHcHR0hG/6pm/C7/zO7+Cbv/mbAQBvf/vb8eY3vxmPPvoo7rzzTgDA3/7bfxuf/vSn8eCDD55OxRo1atSo0VVL7bepUaMrl5pnrFGjp5le+tKXpuu+7/Hn/tyfw0te8pJ07/bbbwcA/Omf/qmZ5/bbb8d1112Xfuz4nkzfqFGjRo0a7ULtt6lRoyuTGhhr1Ohppr29veKzc66455wDAHjvzTw6Pd+T6Rs1atSoUaNdqP02NWp0ZVIDY40aNWrUqFGjRo0aNWp0CtTAWKNGjRo1atSoUaNGjRqdAjUw1qhRo0aNGjVq1KhRo0anQC2aYqNGjRo1atSoUaNGjRqdAjXPWKNGjRo1atSoUaNGjRqdAjUw1qhRo0aNGjVq1KhRo0anQA2MNWrUqFGjRo0aNWrUqNEpUANjjRo1atSoUaNGjRo1anQK1MBYo0aNGjVq1KhRo0aNGp0CNTDWqFGjRo0aNWrUqFGjRqdADYw1atSoUaNGjRo1atSo0SlQA2ONGjVq1KhRo0aNGjVqdArUwFijRo0aNWrUqFGjRo0anQI1MNaoUaNGjRo1atSoUaNGp0ANjDVq1KhRo0aNGjVq1KjRKdD/DzdTWcAOowDAAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -175,12 +170,12 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -215,14 +210,14 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 6, "metadata": { "scrolled": true }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -253,12 +248,12 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -298,7 +293,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -315,7 +310,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -343,12 +338,34 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 21, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-34.86231025806548 2.2563435662421516\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "69f1776d350a4300993be78a06578b64", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(IntSlider(value=0, description='Frame', max=99), Output()))" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Show the calculated diffraction data on an interactive gui backend such as qt\n", - "# show3Dslider(np.log(ptychogram))" + "show3Dslider(np.log(ptychogram))" ] }, { @@ -362,7 +379,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -371,15 +388,12 @@ "from PtyLab import Monitor\n", "from PtyLab import Params\n", "from PtyLab import Engines\n", - "import matplotlib as mpl\n", - "\n", - "# uncomment below for showing reconstructions with interactive qt backend instead of inline\n", - "# mpl.use(\"qt5Agg\")" + "import matplotlib as mpl" ] }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -402,7 +416,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -423,14 +437,14 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/Users/shantanukodgirwar/Projects/PtyLab.py/PtyLab/Monitor/Monitor.py:178: UserWarning: For faster update of the reconstruction plot, set `monitor.figureUpdateFrequency = 5` or higher.\n", + "/mnt/home/shantanu/projects/PtyLab.py/PtyLab/Monitor/Monitor.py:178: UserWarning: For faster update of the reconstruction plot, set `monitor.figureUpdateFrequency = 5` or higher.\n", " warnings.warn(\n" ] } @@ -447,14 +461,15 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "INFO:GPU:cupy is unavailable, switching to CPU\n" + "INFO:GPU:cupy and CUDA available, switching to GPU\n", + "WARNING:GPU:Disabling GPU switch. If this is unwanted, please set `self.gpuSwitch = True`\n" ] } ], @@ -479,18 +494,18 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "ERROR:Reconstruction:Copying attribute wavelength\n", - "ERROR:Reconstruction:Copying attribute dxd\n", - "ERROR:Reconstruction:Copying attribute theta\n", - "ERROR:Reconstruction:Copying attribute spectralDensity\n", - "ERROR:Reconstruction:Copying attribute entrancePupilDiameter\n", + "INFO:Reconstruction:Copying attribute wavelength\n", + "INFO:Reconstruction:Copying attribute dxd\n", + "INFO:Reconstruction:Copying attribute theta\n", + "INFO:Reconstruction:Copying attribute spectralDensity\n", + "INFO:Reconstruction:Copying attribute entrancePupilDiameter\n", "INFO:Reconstruction:Initial object set to ones\n", "INFO:Reconstruction:Initial probe set to circ\n" ] @@ -522,12 +537,12 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -539,7 +554,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "mPIE: 100%|██████████| 100/100 [00:22<00:00, 4.46it/s]\n" + "mPIE: 100%|██████████| 100/100 [00:20<00:00, 4.82it/s]\n" ] } ], @@ -557,7 +572,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -567,7 +582,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "ptylab", "language": "python", "name": "python3" }, @@ -581,7 +596,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.13.12" } }, "nbformat": 4, diff --git a/jupyter_tutorials/jupyter_tutorials_tutorial_FPM.ipynb b/jupyter_tutorials/jupyter_tutorials_tutorial_FPM.ipynb index a06cbd09..57712d21 100644 --- a/jupyter_tutorials/jupyter_tutorials_tutorial_FPM.ipynb +++ b/jupyter_tutorials/jupyter_tutorials_tutorial_FPM.ipynb @@ -4,68 +4,72 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# ptyLab introduction (FP)\n", + "# 07 – FPM\n", "\n", - "ptyLab is a highly modular coding package which can be used for both conventional and Fourier ptychography. Due to the modular nature it is easy to modify the code for various tasks and add your own functions, such as a new reconstruction engine or a calibration routine. To understand ptyLab we need to understand the basic classes contained within, which are briefly outlined below:\n", + "This tutorial demonstrates a complete Fourier ptychographic microscopy (FPM) reconstruction workflow. An LED-array dataset is loaded, LED positions are calibrated, and the high-resolution complex object and pupil function are recovered iteratively.\n", "\n", + "**What you'll learn:**\n", "\n", - " - ExperimentalData - this class is used to import the experimental data from an .hdf5 file. If the file contains the experimental images stored as an image stack (called ptychogram), probe/LED positions and several experimental parameters, then the data can be successfully imported and reconstructed.\n", - " - Reconstruction - this class creates various objects from the immutable ExperimentalData class which will be optimized/updated i.e. are mutable. \n", - " - Params - this class stores parameters use for the reconstruction such that they could be exported/imported for different experiments\n", - " - Engines - all the engines used for the reconstruction are based on this class, which take the ExperimentalData and Optimizable objects as parameters and perform object/probe/pupil reconstruction.\n", - " - Monitor - visualization class used to display the reconstruction process\n", - " - CalibrationFPM - this package contains k-space position calibration routines caused by misaligned LED positions.\n" + "- How FPM differs from CPM in setup and initialization\n", + "- How to use `IlluminationCalibration` to correct LED positions\n", + "- How to run an FPM reconstruction with `mqNewton`" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ - "import matplotlib\n", "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "%matplotlib inline" + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from PtyLab.io import getExampleDataFolder\n", + "from PtyLab import Engines\n", + "import PtyLab" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Cannot use pyqtgraph\n", - "Pyqtgraph not available\n", - "cupy not avialable\n", - "Cupy unavailable\n", - "Cupy not available, will not be able to run GPU based computation\n", - "Cupy not available, will not be able to run GPU based computation\n", - "Cupy not available, will not be able to run GPU based computation\n", - "Cupy not available, will not be able to run GPU based computation\n", - "Cupy not available, will not be able to run GPU based computation\n", - "Cupy not available, will not be able to run GPU based computation\n", - "Cupy not available, will not be able to run GPU based computation\n", - "Cupy not available, will not be able to run GPU based computation\n", - "Cupy not available, will not be able to run GPU based computation\n", - "Cupy not available, will not be able to run GPU based computation\n", - "Cupy not available, will not be able to run GPU based computation\n", - "Cupy not available, will not be able to run GPU based computation\n" + "Downloading LungCarcinomaFPM.hdf5..\n", + "Download complete.\n" ] } ], "source": [ "from PtyLab.io import getExampleDataFolder\n", - "from PtyLab import Engines\n", - "import PtyLab" + "import urllib.request\n", + "\n", + "fileName = \"LungCarcinomaFPM.hdf5\"\n", + "filePath = getExampleDataFolder() / fileName\n", + "\n", + "if not filePath.exists():\n", + " print(f\"Downloading {fileName}..\")\n", + " urllib.request.urlretrieve(\n", + " \"https://ndownloader.figshare.com/files/33956981\", filePath\n", + " )\n", + " print(\"Download complete.\")\n", + "else:\n", + " print(f\"{fileName} found, skipping download.\")" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 9, "metadata": { "scrolled": false }, @@ -74,27 +78,33 @@ "name": "stderr", "output_type": "stream", "text": [ - "Copying attribute wavelength\n", - "Copying attribute dxd\n", - "Copying attribute zled\n", - "Copying attribute NA\n" + "INFO:GPU:cupy and CUDA available, switching to GPU\n", + "INFO:Reconstruction:Copying attribute wavelength\n", + "INFO:Reconstruction:Copying attribute dxd\n", + "INFO:Reconstruction:Copying attribute zled\n", + "INFO:Reconstruction:Copying attribute NA\n", + "INFO:Reconstruction:Initial object set to upsampled\n", + "INFO:Reconstruction:Initial probe set to circ\n", + "INFO:ePIE:Sucesfully created ePIE ePIE_engine\n", + "INFO:ePIE:Wavelength attribute: 6.25e-07\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Found encoder with shape (81, 2)\n", - "\"Unable to open object (object 'orientation' doesn't exist)\"\n" + "Found encoder with shape (81, 2)\n" ] } ], "source": [ - "fileName = 'LungCarcinomaFPM.hdf5'\n", - "# fileName = 'USAFTargetFPM.hdf5'\n", - "filePath = getExampleDataFolder() / fileName\n", + "# fileName = \"LungCarcinomaFPM.hdf5\"\n", + "# # fileName = 'USAFTargetFPM.hdf5'\n", + "# filePath = getExampleDataFolder() / fileName\n", "\n", - "exampleData, reconstruction, params, monitor, engine, calib = PtyLab.easyInitialize(filePath, operationMode='FPM')" + "exampleData, reconstruction, params, monitor, engine, calib = PtyLab.easyInitialize(\n", + " filePath, operationMode=\"FPM\"\n", + ")" ] }, { @@ -124,11 +134,11 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ - "mean_img = np.mean(exampleData.ptychogram,0)" + "mean_img = np.mean(exampleData.ptychogram, 0)" ] }, { @@ -145,15 +155,25 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:Reconstruction:Initial object set to upsampled\n", + "INFO:Reconstruction:Initial probe set to circ\n" + ] + } + ], "source": [ - "reconstruction.initialProbe = 'circ'\n", - "reconstruction.initialObject = 'upsampled'\n", + "reconstruction.initialProbe = \"circ\"\n", + "reconstruction.initialObject = \"upsampled\"\n", "reconstruction.initializeObjectProbe()\n", "\n", "import copy\n", + "\n", "reconstruction0 = copy.deepcopy(reconstruction)" ] }, @@ -167,16 +187,16 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "# Set monitor properties\n", "monitor.figureUpdateFrequency = 10\n", - "monitor.objectPlot = 'complex' \n", - "monitor.verboseLevel = 'low'\n", - "monitor.objectPlotZoom = .01 \n", - "monitor.probePlotZoom = .01 " + "monitor.objectPlot = \"complex\"\n", + "monitor.verboseLevel = \"low\"\n", + "monitor.objectZoom = 0.01\n", + "monitor.probeZoom = 0.01" ] }, { @@ -189,12 +209,20 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:GPU:Disabling GPU switch. If this is unwanted, please set `self.gpuSwitch = True`\n" + ] + } + ], "source": [ "params.gpuSwitch = False\n", - "params.positionOrder = 'NA'\n", + "params.positionOrder = \"NA\"\n", "params.probeBoundary = True\n", "params.adaptiveDenoisingSwitch = True" ] @@ -209,7 +237,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -227,26 +255,22 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { @@ -255,17 +279,17 @@ "" + " [ 0. , 0. , 1. ]]) at 0x7ede5e7d6cb0>" ] }, - "execution_count": 8, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "calib.plot = True\n", - "calib.fit_mode ='SimilarityTransform'\n", + "calib.fit_mode = \"SimilarityTransform\"\n", "calib.calibrateRadius = True\n", "calib.runCalibration()" ] @@ -280,38 +304,36 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 15, "metadata": { "scrolled": true }, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\users\\aiduka_t\\switchdrive\\ptylab\\ptylab.py\\PtyLab\\Engines\\BaseEngine.py:378: UserWarning: fftshiftSwitch set to false, this may lead to reduced performance\n", - " warnings.warn(\n", - "c:\\users\\aiduka_t\\switchdrive\\ptylab\\ptylab.py\\PtyLab\\Monitor\\Plots.py:171: UserWarning: Matplotlib is currently using module://matplotlib_inline.backend_inline, which is a non-GUI backend, so cannot show the figure.\n", - " self.figure.show()\n" - ] + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA8AAAAEjCAYAAAD9mWieAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3XecJVWd8P9PhZtz39s5T/fkCDPkMEMGiSogKIoKiiuYMKzorggGdsVFf+uDIK4RAyiouAbCkMOQZpjMpJ7O+eZcdavq/P7oZ/qhmdQDA4NOvV+vfkGdOlV1qqbr23XqnDpHEkIIbDabzWaz2Ww2m81m+ycnH+oC2Gw2m81ms9lsNpvN9nawK8A2m81ms9lsNpvNZjss2BVgm81ms9lsNpvNZrMdFuwKsM1ms9lsNpvNZrPZDgt2Bdhms9lsNpvNZrPZbIcFuwJss9lsNpvNZrPZbLbDgl0BttlsNpvNZrPZbDbbYcGuANtsNpvNZrPZbDab7bBgV4BtNpvNZrPZbDabzXZYsCvA/6C+/vWvI0kS8Xh8v3nb2tr48Ic//NYX6h3kwx/+MG1tbYe6GDab7TAgSRLXXXfdoS7GQfHzn/8cSZLo6ek51EWx2Wy2fzgrVqxgxYoVB21/lmWxYMECvvWtb02m/aPH6QcffBC/38/4+PghK4NdAX4H2bRpE1dccQWNjY24XC4aGhr4wAc+wKZNmw510fbp29/+Nn/605/e9uMODQ3x9a9/nbVr177tx96X3/zmN3z/+98/1MWw2Q5rux4Qdv243W5mzZrFddddx+jo6KEu3iF3qOL2vjz33HN8/etfJ51OH+qi2Gz/9F4fI1//8/zzzx/qIh5S75RnzN/+9rf09/fv9yXrD3/4Q37+859Pe7/33nsvV1xxBTNnzkSSpH1W2levXs3ZZ59NMBgkEAhw5pln7vG6PPzww1x11VUsWLAARVH22hB19tln09nZyS233DLt8h5s6iE7sm2KP/zhD1x++eVUVVVx1VVX0d7eTk9PDz/5yU+47777uOeee3j3u9/9hva9detWZPmte9fx7W9/m4svvpiLLrroLTvGngwNDXHTTTfR1tbGkiVLpqz78Y9/jGVZb2t5dvnNb37Dxo0b+exnP3tIjm+z2f6fm2++mfb2dsrlMs888wx33HEHf/vb39i4cSNer/dQF++Q2Vvc/uAHP8hll12Gy+V628v03HPPcdNNN/HhD3+YcDj8th/fZjsc7YqRr9fZ2XkISvPOsa9nzH15+OGHD2o5br31Vi677DJCodBk2p7i9A9/+ENisdi0e3zecccdrF69mqOOOopEIrHXfGvWrOHEE0+kubmZG2+8Ecuy+OEPf8jy5ct58cUXmT179mTe3/zmN9x7770ceeSRNDQ07PP411xzDV/4whe46aabCAQC0yrzwWRXgN8Burq6+OAHP8iMGTN46qmnqK6unlz3mc98hpNOOokPfvCDrF+/nhkzZhzw/g/Fg8yh5nA4DnURbDbbO8A555zDsmXLALj66quJRqPcdtttPPDAA1x++eV73KZQKODz+d7OYr5jKIqCoiiHuhg2m+1t8toYOV2GYWBZFk6nc7d1bzZ+CiEol8t4PJ43vI9DoVgs4vV693hN3qhXXnmFdevW8V//9V9T0g9GnL777rtpbGxElmUWLFiw13z//u//jsfjYdWqVUSjUQCuuOIKZs2axVe+8hXuv//+ybzf/va3+fGPf4zD4eC8885j48aNe93ve9/7Xj71qU/x+9//no9+9KNv6lzeCLsL9DvArbfeSrFY5K677ppS+QWIxWL86Ec/olAo8J3vfGe3bePxOJdeeinBYJBoNMpnPvMZyuXylDx7+gY4nU7z2c9+lubmZlwuF52dnfznf/7nbq2mlmXx//1//x8LFy7E7XZTXV3N2WefzcsvvwxMfPtWKBT4xS9+MdltZn9vnzRN48Ybb6SzsxOXy0VzczNf+tKX0DRtSr5HHnmEE088kXA4jN/vZ/bs2XzlK18B4IknnuCoo44C4CMf+cjksXd1/3j9N8A9PT1IksR3v/tdbr/9dmbMmIHX6+XMM8+kv78fIQTf+MY3aGpqwuPxcOGFF5JMJqeU54EHHuDcc8+loaEBl8tFR0cH3/jGNzBNczLPihUr+Otf/0pvb+9kmV5bjumeu81me2uceuqpAHR3dwMTscLv99PV1cW73vUuAoEAH/jAB4CJB7nPf/7zk3Fy9uzZfPe730UIscd9//rXv2b27Nm43W6WLl3KU089tVuewcFBPvrRj1JbW4vL5WL+/Pn89Kc/nXb5f/WrX7F06VI8Hg9VVVVcdtll9Pf3T8mzfft23vve91JXV4fb7aapqYnLLruMTCYD7Dtu7+nbsra2Ns477zyeeOIJli1bhsfjYeHChTzxxBPARA+mXX8jli5dyiuvvDKlPOvXr+fDH/4wM2bMwO12U1dXx0c/+tEprQ5f//rX+eIXvwhAe3v7ZLleW47pnLvNZju4Xvv89P3vf5+Ojg5cLhebN2+eHI9m8+bNvP/97ycSiXDiiScCE5Xkb3zjG5P529ra+MpXvrLb886u+PLQQw9Nxpcf/ehHey3PihUrWLBgAevXr2f58uV4vV46Ozu57777AHjyySc55phj8Hg8zJ49m5UrV+62j/3F4f09Y+4qw+rVqzn55JPxer2Tz6d7+ga4XC7z9a9/nVmzZuF2u6mvr+c973kPXV1d+7z2f/rTn3A6nZx88slT0l8fp9va2ti0aRNPPvnkZFn39x1yc3PztHqHPv3005x++umTlV+A+vp6li9fzl/+8hfy+fxkekNDw7QboGpqali0aBEPPPDAtPIfbHYL8DvA//7v/9LW1sZJJ520x/Unn3wybW1t/PWvf91t3aWXXkpbWxu33HILzz//PP/93/9NKpXil7/85V6PVywWWb58OYODg1xzzTW0tLTw3HPPccMNNzA8PDzl+9WrrrqKn//855xzzjlcffXVGIbB008/zfPPP8+yZcu4++67ufrqqzn66KP5+Mc/DkBHR8dej21ZFhdccAHPPPMMH//4x5k7dy4bNmzge9/7Htu2bZv8Jm3Tpk2cd955LFq0iJtvvhmXy8WOHTt49tlnAZg7dy4333wzX/va1/j4xz8+ee2OP/74fV7rX//61+i6zqc+9SmSySTf+c53uPTSSzn11FN54okn+Nd//Vd27NjBD37wA77whS9MCYg///nP8fv9XH/99fj9fh577DG+9rWvkc1mufXWWwH46le/SiaTYWBggO9973sA+P3+Azp3m8321tn1wPHaP+aGYXDWWWdx4okn8t3vfhev14sQggsuuIDHH3+cq666iiVLlvDQQw/xxS9+kcHBwcn7e5cnn3ySe++9l09/+tO4XC5++MMfcvbZZ/Piiy9Ovl0fHR3l2GOPnRw0q7q6mr///e9cddVVZLPZ/X428a1vfYt///d/59JLL+Xqq69mfHycH/zgB5x88sm88sorhMNhdF3nrLPOQtM0PvWpT1FXV8fg4CB/+ctfSKfThEKhA47bADt27OD9738/11xzDVdccQXf/e53Of/887nzzjv5yle+wic/+UkAbrnlFi699NIpn9488sgj7Ny5k4985CPU1dWxadMm7rrrLjZt2sTzzz+PJEm85z3vYdu2bfz2t7/le9/7HrFYDGDypfB0zt1msx24TCaz24CqkiRNiZEAP/vZzyiXy3z84x/H5XJRVVU1ue6SSy5h5syZfPvb3558QXj11Vfzi1/8gosvvpjPf/7zvPDCC9xyyy28+uqr/PGPf5yy761bt3L55ZdzzTXX8LGPfWxKt9o9SaVSnHfeeVx22WVccskl3HHHHVx22WX8+te/5rOf/Syf+MQneP/738+tt97KxRdfTH9//2Q32+nE4ek8YyYSCc455xwuu+wyrrjiCmpra/dYVtM0Oe+883j00Ue57LLL+MxnPkMul+ORRx5h48aN+4y9zz33HAsWLNhvpfL73/8+n/rUp/D7/Xz1q18F2Gt5DpSmaXtsjfd6vei6zsaNGzn22GPf0L6XLl166J59he2QSqfTAhAXXnjhPvNdcMEFAhDZbFYIIcSNN94oAHHBBRdMyffJT35SAGLdunWTaa2treLKK6+cXP7GN74hfD6f2LZt25Rtv/zlLwtFUURfX58QQojHHntMAOLTn/70buWxLGvy/30+35T978vdd98tZFkWTz/99JT0O++8UwDi2WefFUII8b3vfU8AYnx8fK/7eumllwQgfvazn+227sorrxStra2Ty93d3QIQ1dXVIp1OT6bfcMMNAhCLFy8WlUplMv3yyy8XTqdTlMvlybRisbjbca655hrh9Xqn5Dv33HOnHPtAz91ms715P/vZzwQgVq5cKcbHx0V/f7+45557RDQaFR6PRwwMDAghJmIFIL785S9P2f5Pf/qTAMQ3v/nNKekXX3yxkCRJ7NixYzINEIB4+eWXJ9N6e3uF2+0W7373uyfTrrrqKlFfXy/i8fiUfV522WUiFArtMcbs0tPTIxRFEd/61rempG/YsEGoqjqZ/sorrwhA/P73v9/n9dlb3N513bq7uyfTWltbBSCee+65ybSHHnpIAMLj8Yje3t7J9B/96EcCEI8//vhk2p7O67e//a0AxFNPPTWZduutt+527AM5d5vNNn277vU9/bhcrsl8u56fgsGgGBsbm7KPXc+il19++ZT0tWvXCkBcffXVU9K/8IUvCEA89thjk2m74suDDz44rXIvX75cAOI3v/nNZNqWLVsEIGRZFs8///xk+q449drnxOnG4X09Y+4qw5133rnHdcuXL59c/ulPfyoAcdttt+2W97XP0nvS1NQk3vve9+6Wvqc4PX/+/CnHPRD72nbhwoVi1qxZwjCMyTRN00RLS4sAxH333bfH7fb2LPxa3/72twUgRkdH31C53wy7C/QhlsvlAPb7Afiu9dlsdkr6tddeO2X5U5/6FAB/+9vf9rqv3//+95x00klEIhHi8fjkz+mnn45pmpPd9u6//34kSeLGG2/cbR+SJO3nzPZ+7Llz5zJnzpwpx97VLfHxxx8HmHyb/8ADDxzUwawuueSSKQMJHHPMMcDE9wyqqk5J13WdwcHBybTXvgHL5XLE43FOOukkisUiW7Zs2e+xp3vuNpvt4Dn99NOprq6mubmZyy67DL/fzx//+EcaGxun5PuXf/mXKct/+9vfUBSFT3/601PSP//5zyOE4O9///uU9OOOO46lS5dOLre0tHDhhRfy0EMPYZomQgjuv/9+zj//fIQQU2LAWWedRSaTYc2aNXs9jz/84Q9YlsWll146Zdu6ujpmzpw5GT92xbeHHnqIYrF44BdsL+bNm8dxxx03ubwrdp566qm0tLTslr5z587JtNfGznK5TDwen2wx2Nc57zLdc7fZbAfu9ttv55FHHpny8/r4BhPfbL7+M71dPvGJT0xZ3vUMev31109J//znPw+wW4/G9vZ2zjrrrGmX2e/3c9lll00uz549m3A4zNy5cydjEOwej95sHH4tl8vFRz7ykf3mu//++4nFYpPP56+1v2fpRCJBJBKZVnneKp/85CfZtm0bV111FZs3b2bjxo186EMfYnh4GIBSqfSG973r3KYzpevBZneBPsR2VWx3VYT3Zm8V5ZkzZ05Z7ujoQJblfc4Ntn37dtavX7/XQDY2NgZMdBVsaGiY0s3lzdq+fTuvvvrqfo/9vve9j//5n//h6quv5stf/jKnnXYa73nPe7j44ovf1IjWr31Qg//3sNjc3LzH9FQqNZm2adMm/u3f/o3HHntstxcRu76t25fpnrvNZjt4br/9dmbNmoWqqtTW1jJ79uzdYoiqqjQ1NU1J6+3tpaGhYbeYO3fu3Mn1r/X6WAwwa9YsisUi4+PjyLJMOp3mrrvu4q677tpjWfcVA7Zv344QYo/Hgf838F97ezvXX389t912G7/+9a856aSTuOCCC7jiiiumvPw7UG8mdiaTSW666Sbuueee3c5xurFzOudus9kO3NFHHz2tQbD2NFL03tb19vYiy/JuI0nX1dURDod3i5/72veeNDU17VZ5DIVC+41H4+PjbyoOv1ZjY+O0Brzq6upi9uzZUxpZDoTYy5gTb5dPfOIT9Pf3c+utt/KLX/wCgGXLlvGlL32Jb33rW5Of+b0Ru87tjTaqvRl2BfgQC4VC1NfXs379+n3mW79+PY2NjQSDwX3mm84vkWVZnHHGGXzpS1/a4/pZs2btdx9vlGVZLFy4kNtuu22P63cFL4/Hw1NPPcXjjz/OX//6Vx588EHuvfdeTj31VB5++OE3PPrd3rbbW/qumzOdTrN8+XKCwSA333wzHR0duN1u1qxZw7/+679Oq5V6uudus9kOnuk83Llcrrd0qjhgMkZcccUVXHnllXvMs2jRon1uL0kSf//73/cYr177EPJf//VffPjDH+aBBx7g4Ycf5tOf/vTkOBGvr+hP1xuNnTAxVsVzzz3HF7/4RZYsWYLf78eyLM4+++xpx87pnrvNZntr7GtU5r2tm27F5kBHfH6j8ejNxuHXejtGqY5Go1NeJh4q3/rWt/jCF77Apk2bCIVCLFy4cHLQrzdTZ9h1brvGfHg72RXgd4DzzjuPH//4xzzzzDOTo+e91tNPP01PTw/XXHPNbuu2b98+5c3Zjh07sCxrr5NPw0QrcT6f5/TTT99nuTo6OnjooYdIJpP7bAU+kDc3HR0drFu3jtNOO22/28myzGmnncZpp53Gbbfdxre//W2++tWv8vjjj3P66ae/rW+MnnjiCRKJBH/4wx+mjMa3ayTZ19pbuQ7k3G0226HV2trKypUryeVyU1qBd33u0NraOiX/9u3bd9vHtm3b8Hq9k70+AoEApmnuN/buSUdHB0II2tvbp/XAsXDhQhYuXMi//du/8dxzz3HCCSdw55138s1vfhN4+964p1IpHn30UW666Sa+9rWvTabv6XrtK3YeyLnbbLZDq7W1Fcuy2L59+2SvGZgYgCqdTu8WP98u1dXV047DBytGdnR08MILL1CpVA64t8qcOXP2+Jy5J291TH/tCN8AK1eupKmpiTlz5rzhfXZ3dxOLxfbaM/KtZH8D/A7wxS9+EY/HwzXXXLPbZNTJZJJPfOITeL3eySkiXuv222+fsvyDH/wAmJjXbW8uvfRSVq1axUMPPbTbunQ6jWEYwMT3HkIIbrrppt3yvfbtvs/nI51O7/0EX3fswcFBfvzjH++2rlQqUSgUAHabggiYnIh81xD6u+aZm+6x34xdbxVfe966rvPDH/5wt7w+n2+P3fqme+42m+3Qe9e73oVpmvyf//N/pqR/73vfQ5Kk3WLsqlWrpnw71t/fzwMPPMCZZ545OWfje9/7Xu6///49zo04Pj6+z/K85z3vQVEUbrrppt26xAkhJv92ZLPZyRi+y8KFC5Flecr0IwcSt9+MPcVOYMpsA68tE+we06d77jab7Z3hXe96F7D7fb6rB9y55577dhcJ4IDi8MF6xnzve99LPB7f7W8J7L9783HHHcfGjRunNVXm2xXTAe69915eeuklPvvZz76p3lOrV6+eMrbE28luAX4HmDlzJr/4xS/4wAc+wMKFC7nqqqtob2+np6eHn/zkJ8TjcX7729/ucaj07u5uLrjgAs4++2xWrVrFr371K97//vezePHivR7vi1/8In/+858577zz+PCHP8zSpUspFAps2LCB++67j56eHmKxGKeccgof/OAH+e///m+2b98+2V3t6aef5pRTTuG6664DJoYxX7lyJbfddhsNDQ20t7dPGYTgtT74wQ/yu9/9jk984hM8/vjjnHDCCZimyZYtW/jd7343OQ/czTffzFNPPcW5555La2srY2Nj/PCHP6SpqWnyDVRHRwfhcJg777yTQCCAz+fjmGOOOeBvSabj+OOPJxKJcOWVV/LpT38aSZK4++679xi8li5dyr333sv111/PUUcdhd/v5/zzz5/2udtstkPv/PPP55RTTuGrX/0qPT09LF68mIcffpgHHniAz372s7vF4wULFnDWWWdNmQYJmPIC8T/+4z94/PHHOeaYY/jYxz7GvHnzSCaTrFmzhpUrV+7xxd8uHR0dfPOb3+SGG26gp6eHiy66iEAgQHd3N3/84x/5+Mc/zhe+8AUee+wxrrvuOi655BJmzZqFYRjcfffdkw9+uxxI3H4zgsEgJ598Mt/5zneoVCo0Njby8MMP77FVY9cgYl/96le57LLLcDgcnH/++dM+d5vNduD+/ve/73Egz+OPP54ZM2a8oX0uXryYK6+8krvuumvyE7IXX3yRX/ziF1x00UWccsopb7bYb9h04/DBesb80Ic+xC9/+Uuuv/56XnzxRU466SQKhQIrV67kk5/8JBdeeOFet73wwgv5xje+wZNPPsmZZ565z+MsXbqUO+64g29+85t0dnZSU1MzOcjqnjz11FOTg96Oj49TKBQmewidfPLJk70dn3rqKW6++WbOPPNMotEozz//PD/72c84++yz+cxnPjNln+vXr+fPf/4zMNEjNZPJTO5z8eLFnH/++ZN5x8bGWL9+/W6D+b5t3r4Bp237s379enH55ZeL+vp64XA4RF1dnbj88svFhg0bdsu7a+j5zZs3i4svvlgEAgERiUTEddddJ0ql0pS8r58GSQghcrmcuOGGG0RnZ6dwOp0iFouJ448/Xnz3u98Vuq5P5jMMQ9x6661izpw5wul0iurqanHOOeeI1atXT+bZsmWLOPnkk4XH4xHAfqdE0nVd/Od//qeYP3++cLlcIhKJiKVLl4qbbrpJZDIZIYQQjz76qLjwwgtFQ0ODcDqdoqGhQVx++eW7Td30wAMPiHnz5glVVacMV7+3aZBuvfXWKds//vjje5wyZNcQ8y+99NJk2rPPPiuOPfZY4fF4RENDg/jSl740OcT+a6f8yOfz4v3vf78Ih8MCmFKO6Zy7zWZ78/Z0D+/JlVdeKXw+3x7X5XI58bnPfU40NDQIh8MhZs6cKW699dbdpq4AxLXXXit+9atfiZkzZwqXyyWOOOKIKXFhl9HRUXHttdeK5ubmyTh/2mmnibvuumta53X//feLE088Ufh8PuHz+cScOXPEtddeK7Zu3SqEEGLnzp3iox/9qOjo6BBut1tUVVWJU045RaxcuXLKfvYWt/c2DdK55567W1l2nfdr7SnWDgwMiHe/+90iHA6LUCgkLrnkEjE0NCQAceONN07Z/hvf+IZobGwUsizvVo79nbvNZpu+fU2D9Nrnqb09Pwnx/55F9zRlZaVSETfddJNob28XDodDNDc3ixtuuGHKtJFC7D2+7M3y5cvF/Pnzd0s/kDg13Ti8t2fMvZVh17rXTylULBbFV7/61clrUVdXJy6++GLR1dW13/NdtGiRuOqqq6ak7SlOj4yMiHPPPVcEAgEB7HdKpF3/dnv6eW1c3rFjhzjzzDNFLBYTLpdLzJkzR9xyyy1C07Td9rmv36nX1w3uuOMO4fV6J6d3fbtJQhzi4cVsb7nm5mbOOuss/ud//udQF8Vms9lsNpvNZrNNw9133821115LX1/f5BSh/wyOOOIIVqxYwfe+971Dcnz7G+B/cpVKhUQicUhGWLPZbDabzWaz2WxvzAc+8AFaWlp2G/PnH9mDDz7I9u3bueGGGw5ZGexvgP+JPfTQQ9xzzz2USiVOO+20Q10cm81ms9lsNpvNNk2yLO9xwK5/ZGeffTb5fP6QlsHuAv1P7JRTTmHHjh38y7/8y+R8XTabzWaz2Ww2m812uHpHdIG+/fbbaWtrw+12c8wxx/Diiy/uM//vf/975syZg9vtZuHChfztb397m0r6j+Xxxx+nv7/frvzabP8EDnacFELwta99jfr6ejweD6effvoe52a12Ww2m81m+2dyyCvAu6aLufHGG1mzZg2LFy/mrLPOYmxsbI/5n3vuOS6//HKuuuoqXnnlFS666CIuuuiif7ruATabzbbLWxEnv/Od7/Df//3f3Hnnnbzwwgv4fD7OOussyuXy23VaNpvNZrPZbG+7Q94F+phjjuGoo46anCDasiyam5v51Kc+xZe//OXd8r/vfe+jUCjwl7/8ZTLt2GOPZcmSJdx5551vW7ltNttbZ+7cuXuclxDgBz/4weQc1IeLgx0nhRA0NDTw+c9/fnL+1EwmQ21tLT//+c+57LLL3p4Ts9lsbyk7ltpsNtvuDukgWLqus3r16imjgMmyzOmnn86qVav2uM2qVau4/vrrp6SdddZZ/OlPf9pjfk3T0DRtctmyLJLJJNFoFEmS3vxJ2Gz/hIQQ5HI5GhoakOV9dxQpl8vouj6tfb7+nnO5XLhcrt3y3n///cyfP59HH32UefPmoWkaM2bM4N57750ykfrh4K2Ik93d3YyMjHD66adPrg+FQhxzzDGsWrVqjxVgO5babAfmrYiju/Zrx9LDj2VZDA0NEQgE7Jhrs+3BgcTcQ1oBjsfjmKZJbW3tlPTa2tq9vrEcGRnZY/6RkZE95r/lllu46aabDk6BbbbDTH9/P01NTXtdXy6Xaff4GMHa7778fv9uo/7deOONfP3rX98t7+joKKqqcsIJJ+ByuVi9ejWWZXHSSSft8SHvn9lbESd3/deOpTbbW+9gxlGwY+nhamhoiObm5kNdDJvtHW9/MRcOg2mQbrjhhiktIZlMhpaWFuZzAX7c5HCioNCj5Mm7VYQuQIEW3eIEy4eDcRQc7CRBNW4a2Yni7Metz6ePRh4jTgw/eQxmY9DAZiwk0o4SZblM2lSo8hiIAhRcDvIEyJQa0NR+ag0Zl1KkqkHD3wnNFSgNQ3lUJue08BZkRLXAN1sQF0AMNpwMxUFw3TeRv0GCUhX0BGDme6G+HrQBGHoJ/EkYfA7qHTJpn6DBK+irB68CynMqlZKHweYcO4EjOqB1Hqz9rURtnUB2gPCCcEPlSCgpkG6E3hDk6tyIigsCZYK9BkfvMBEOSCsgDUNzMzxvQTQHQypERkDkoVANdSXoGAIxDloBnt+u0tBhoC6C/InQ5w+jF0KQKYJSBG8ACg5UPY5XaLR4LEKDkByUKK/zICUVwoabgJkmNqtCYAYUDShUIJODogZuE2QNMltdOJoM8u0m46/KlN0ydV6D8HzYvjxIvn4G9PeycCDF8QXQy5AdmLgGEUCthcxWcCogl0Efh+3dMZprTBYsSLFpZT2GKZF2gLd5hFJPG1gpDCWNooSZh4JemU1a2kLGchPzZqk+OUdtPWz7M9RVYEMA3EUFWZJoNGF8gYGVlShtaCdDNWvVFPlAhiPbRmkPqDy+ZhZJScVyKNRlBCeb1Qh0XGxlcfUo/dlqhrQluHERxIeFn3EkNmHQL29DV9I0VxZyAjNoIE2CBtxkeILVbOAxAoHAPu8vXdcZwaKfNoL7GFIgi0Vzvof+/n6CweBk+t4ewDZs2MCsWbMm169bt46amprdKmy2t8/eYqnNZtu3gxVHwY6lh7Ndv0czPv1LHv3Xs+lNFvngT17kp1cexdEzqg7qsXb18KmqqtpvS9qb2XY6efeVZ2/r9pT++rTXL1cqFR5++GHOPPNMHA7HAZ3zgTocru+e0t7qa5zNZmlubt5vzIVDXAGOxWIoisLo6OiU9NHRUerq6va4TV1d3QHl31u3IMiQw6RMjjSCgtNCVEmocTdVpQpzkKglTYUh8nhJoZKljMwcAnoInUYyqASIouIjhkSALSSlMkHZwHRUUMoqlhVkJGdQI5VwlaopS36qZYvt0gziUi+1PsGSY8ExFwqjgAf0jITiBLNK4EuBxwMNbZD1wII4rH/QyxLFYtlpZeJlKB0J9VUQc0H/Q7BjpYqVsaiKWrTOh+AsC383OOqgug4Cr4DuNxiM5lg4E2qGILIc8iEIdQrySQgoUFcFgwkobgQ5ALNDkHYpZI1aiLogJJPNZXkxOUJgiYUZAr0exgoKer+Ew2/gdUAVkK+BXBWogxAog+ECYyd0Ri3M+ZA4WmJgRgzDqgMBarKA02WiVZsoAY22nM4Ky6LyskRppZv6hEJea6JbSqELKAQt9HGoa4ZRASUDDA8oMkSCUBgHT4eGuQLC3RIuN3jqDdJ94BoHRZIgAJ5wBYcB3aPg6IEAUCyCJiAhQU0ENAXUKFSeBckUKNEc0WOgNjHKwBY3gXIMtUNgVvXgW+dmyAmtmkxwToaK+RzzFIHplRGtguBS0HqhXlKQikHyORcDZCnLHmSzilimH89RZca6dTJ5N7pSJlw1RjoHC8838Ln72PLoUkqmoAoJgzgjqPQqHkYS1SwSGjVAkDGKDDLEAjR8+PFSbVUTtWIcQyfNmNSgIzCBMBphNsC0u1kFcRFE2UcOcyJfMDjloW1v1q9fz8KFCyeX161bN2X5cPJWxMld/x0dHaW+vn5KniVLluxxn3uPpTabbV8OXhwFO5b+83j3u9/NE088wWmnncZ999233/y7fo8qsps/bEyyeThLa32UUxa1osgHt0u0ZVlUKhWCweAbqqBNd9vp5N1Xnr2t21P669Nev1ypVPB6vQSDwbelAvzPfn33lPZ2XePpxNxDOgq00+lk6dKlPProo5NplmXx6KOPctxxx+1xm+OOO25KfoBHHnlkr/n3ZilRZqHQQBGJAVylItX9JaKlDAZFvJQpkMJHAQ8Gs5FpIs4IGkXqiBOkFwkPHgaIk5W6cZHEL44Ecw7RYgCHFUBGoogXSTThw+BYtZ/F/i6WVqJ0iFas7HxWrQ+yMQzOueC7ACILTfwxCB4ncM0UZMdg8HmItEF8jUxN3IH2cY1tK6D7ZNgegdxW6LtDYeufPdScZVL7UYvsBeA+FrwZ8OjgUEC/L0q524FRDRk3GDFQ5sKWKuhVYcZR4FJUSltjjAxC7xgMbIW+l6G8Ck5ImzhHrInadK4B2uag1dbiHoBKEtKREH0LF5KcP5tNsp/xIZmdmszWJiclCQIa5HOQ2g61NbDoAgtlHoy2NGFEVkDVCSiZMLOfTXHsi2WWbhvnXT0pFqw12fgUPPOIREFY+NryVAe3MtszSkxN464xibRBMgsJP4xHoOAGpwqWAcUC9Mx282ptgPJ2hdyoipoHVydkOyXKHUGoeHA7KyQEZKJQKMDY8MRNEmiHGhlCKjhCYJbBCkNMFVRlFRwSdFxkETqliLtmEH9W0Npo0XxykaPmCGYcmWAsUmHTCGzKOCnXCiS3IL4R0uNQFAoVK0aTqCGkWnjDSVJShrGiQXFQJuQaoZZ+fKKWrNfHgBRi7QsqJ16W55wLn2Fm81qYsQalbQsB5xCK5GWECFAhywZ+6x7mXtnNSrrYQgKVCtVEWECI2egsYpAYvfh5nAR/ppbxA7qfwDmNn+lbv349ixYtmlxet27dlOXDyVsRJ9vb26mrq5uSJ5vN8sILLxxwLLXZbAfLdOKoHUv/WXzmM5/hl7/85Rva9odPdvHoljG++q65B73ya7MdDg55F+jrr7+eK6+8kmXLlnH00Ufz/e9/n0KhwEc+8hEAPvShD9HY2Mgtt9wCTASM5cuX81//9V+ce+653HPPPbz88svcddddB3TcEUbR8SBhEsBPWkrhEYIgAVIIyvRh0U4Bi25UHAwTQKNCOyUyOOV+aqx6ciSpJ4pLFMiRA8ZR0Ih4KoSokCh5qZWy+ISBRDXJSgzJGKdK6sIQEl5q8I66kEbg5YUQ9kN7FEY2g2MN1JwM9V4wHodQCtyzLTpPyNBfDa4ucCehMQj6yxKpNV5mX5xHCwq2rpGZ5bYw+kGZBzlVYuivLpwllRmXmhRL4OyHXDU4kpDPgEdATxZGDQlDV2hLgXcJVDlhZI3EYL8gOApuQ0Nf1j5Rw/To6Ee7GX8qTUm4sJRZ4J6LsLrRhQXuIlqtB8Q41b1J3LqgFJ9omdU8kC/ATq+XkjwLRmpgNE39L9cTTZhIp4BigicBSRlUJ4TCFt46jUEBiimoDoPbqZHJgaYCJggnyD6oKoLhgPWKg+TRCtqiEAGtQKTJoEoF53zoboOxtk5MuRGpdwvhjIaVg8EAxAahKQrOxVAqQPpFKDoh3AilEgQaoRhKQ7PFYDeUAhBrh1zGZGSNgncA6k80GRuBriOg/2mJkbSH0dR8uvTNLJtTwGqEUCPUnKET3tiNvqkeo2LiTCl4HOOUBmB1dxWGgFoM2nSTkVdDlBSL9FCQ3sX9tJxmEjgiy3ddMV4Mt1P1wjZiW+Ms2ymoTVqktAADtQF88RBmScGJxKlWNQ3SemQKZMUoGxjFSR8ugjhoxkLb1+2zBw7YZ8vF9N+1WZbFpk2b+NrXvjaZ1tXVxXve854DLNM/j4MdJyVJ4rOf/Szf/OY3mTlzJu3t7fz7v/87DQ0NXHTRRYfqNG22w9z+4ijYsfSfx4oVK3jiiSfe0LaGKbh0WRNnL6jff2abzbabQ14Bft/73sf4+Dhf+9rXGBkZYcmSJTz44IOT36f09fVNaXY//vjj+c1vfsO//du/8ZWvfIWZM2fypz/9iQULFhzQcSNEKZJExsWgVEY4nGR0lSQZajHxoWNQ5HlUBA4aqSbNThy8TNBVoW5+BqO/FzEukSDNOAFcBJFIElWTeCMWqbKPUCmGJAp4KTEq9+ERMRZ1pKlYScb7qiiSx2Hmybihr2miu23VkVBTAj0FfSoE3FDfAC43JNvhj06IPgHm8xB2QGUWDI8LGo/LUVbhqTscjBUFalhw7ImCZI/E4BofEoKWY8boPEGwfRwKO8BXAqsKkg5o2Qr57aCOuQGLggqmDKkwKCcItF4o58EbM8nmfGC6IQnCcpDtPBJMF1h+SKngaoCFJ0MpBWN9OPvKLPYkEF1gpYFjYW2bxEitg1S0BoiCruJ//EVqXy1hzIOiCyQfjKyDXAScedAtGN0+Ua52FQrhifLrwxB2QSIDA84AwimRDeUodASoNIZBaoCMTsZpsDW0hXavTrENOp0S494AJD0I3YGRUKipmGwOqcSaDbKjIGVgfO1Ed2jnMig7IJ8C+iSchoQP2PQ3GT1mUSpBNAQVQyIbMxAvqLw8x2DgDKgbVCj0hkAaw+/XKcmQ3jrRVbt6DoxtERjCj0f2UOXJsbOs0CfJNEkZIipQUZlNilrDjW6MMQcF/wZw14Gw4Ox4lr9mfYzN89EuJ5AG3Lyk+ymKBnzjcUQlRasV5ThHhpY5vyHiSWHogsKOIFLJRQ4DgwbSeMjjO8A72ce+w4kx7T11dXVRLBantFIsXLiQG2+8kaVLl3LCCSccYNn+8b0VcfJLX/oShUKBj3/846TTaU488UQefPBB3G73235+NpsN9h9HwY6l+9bW1kZvb+9u6Z/85Ce5/fbbD8oxnnrqKW699VZWr17N8PAwf/zjH/f44vD222/n1ltvZWRkhMWLF/ODH/yAo48++k0f//1HN3HPuiTP7khQMS0cyiHtzGmz/UM65BVggOuuu26vc9Ht6e3YJZdcwiWXXPKmjllEp4SDEjHKQsNnQBUZhlAZQQcULBQ0GghiItAIoOFXigRqTXzHwHxfmcfiR5IXOipRDMDCICeVyaU0UqVmgrioSBm8aomA6SBSk8R/dIWxAaj1j4MP0v3gfgHSLVBxwmAU6k6GNqCSAHkcip0gJCgOQ6QIc2QIRCGzXSZesdD6FVJdHtRVOrl8lCpHmeojUwwXFHpe8oErR0O1wHsCvKqBUQULj4WR7MRgTws0GHpCpZQxieQCSK4ihhOqyzC+CVwRyLSAtwoKDhUs9//tCyxDvhvmdIDmh20vQt8m5KwHq0qB5ol+yA6jgrEa3GVQOyFTBwNVMjm3D9PbCa4joG8nLS8O4tPdyLqOUgSnD3Qv7HRDaBYETSi8INHbolIlVyg4odoFog8SbkgukSnNb0WRKjR25fBqRfLCoIAD1444clTB22/grQPnK2AEBEp0FMMfQdINIt0mSi1UVBnpOAiuhdwIlJdCcg5UxqDxVQiqMDYINcealIqgVgS5ERA+kLOgIPAMqQybfsqnpBmq8dK0qEj7i0lUWSPmhgSQ3ORAVit40pAryJgY+JQy6WIAl6uMZPrQ5ApuUaAqMEYoKNOgqbgUk4Y5BmIBmAKMPoj9bxXnaAXigQSRuJ9ieRkjFIgwyPFFBw1U4Yz0ccyKLprmmIxuBiMNnpkZilvdZLRmxgihU43MgU4P7mTf4WT6f6BnzpzJ66cn/9vf/naA5fnnc7DjpCRJ3Hzzzdx8880Hq4g2m+1N2V8cBTuW7ttLL72EaZqTyxs3buSMM87Yayx89tlnOfroo3f7HnHz5s1Eo9E9DhZWKBRYvHgxH/3oR/famn7vvfdy/fXXc+edd3LMMcfw/e9/n7POOoutW7dSU1PzJs4Qrl3eziM78gymS/zvukEuWtL4pva3J5ZlIYTAsqY3Mvkb3XY6efeVZ2/r9pT++rR9Lb+R8z4Qh8P13VPaW32ND2Sf74gK8KGg46aWOkpYyIQZtnQiyMhUkCjQRIRuIIZEHRCnSF2sQCBo4VkCoflQchiwuZ9cupUas4SKG5MkTYYHp+nCgYRJLy5nhvIMQWN9ibZ5YEkQLQMLQM9NdHoK9MCK7SBmQH8DZIOQTYBjJ2h9kA1DvAdmCMiv8ZLEYCjrQM96QRtHK0pUaTIe080S2YXUmCF5HMR/5yWveKmJZTGjkE6CIwDbwuBSwZOCcBwyQ+AZ8yJRpEmKI9XqWGko9kDAD+UmGJjtY4QSJdUHeQscBig6VCTYvAXmXQiuEO7hV4g9ZzI6u0Cl+UQoSTjlHLF6UBXIiomRmb1Ji4rDTV4Ng0NHcWjEGjU8IxplA8ZdEE+DIySzQrVYF5LYOQ9Eu0RHySS4AQqDE/nkMLgKUJOzSMa348KkoyIYLBrUGwZKvAu1C2QnWCokZMivhUAHE32ngzJKTsPtg4wOlsNgMADh0yDggrQXkgkIA2QnWurnnSbwV0NhDaRrBNFacMoQGAd/s0l9r5Ph4zIUm2RERqYuDm6/Rjqrog+raOEyThR6XvZixAtULaoQHBojpRqUgwWOnWNyhFfHNMG/AwIB0AImqtMk1ATuKDhikB2G+EsSyaQXr5pldi1E5xR4YstOKuVZmHhoYoDFDc/T/sECrkYY65t4X2GmQZ4D7gEFn+ZDwYkDGKL/AO8ox//92Rv7GyWbzWbbt/3FUbBj6b5VV1dPWf6P//gPOjo6WL58+W55Lcvi2muvZebMmdxzzz0oykT3861bt3Lqqady/fXX86UvfWm37c455xzOOeecfZbjtttu42Mf+9jkZyp33nknf/3rX/npT3/Kl7/85QM6p9tvv53bb799smJfyme5dEkNdzw7wB2Pb+fEJtdBnxdYCEE6nQamP4jbG9l2Onn3lWdv6/aU/vq01y8bhoFhGCSTSVT1ra0eHQ7Xd09pb/U1zuVy08572FaAZXJIBDAxKaDgpEINHoKoRKjGQwI3ZbxAhVFMAiTybpKaSXVJI9wFa16WsDxjhFOdOPBRoRcVmaRkEnaWCek7QVh45gjE6WDVQNIARiB6BCgu2PFX0Da7yZgymcEijgUwmp74PrYyDsE4ZAwIFCdGge5f7ybdH8FFFkUSzPOnoBmsYQPXzCxOQJGy9C6CYjXMqi4QtQpE6sDRDq5ayPpBr0B1HjJ9gAbJMPibsjjXQ1aTcQ6p6KaJWxNoiyBXD5GSRlr4sGoXgDsCejdUzImPYY0kmEVw1hOOS6SbYlSWHw1yELm0kfpUnuRmyHaCoxZKGozX16Iv+SSo7aALTDPN8BInnf4Sg3UwWC2jaBKJmS2s7UrhjeeodZrkLBd62mSo1iKcg7o60FxQSAABiOkaRR1GvZDXoSYJtT2gBWEsBkjgl8EzF8bbZXSlCSXRhaKmKfrBa0BYsihYCs85/RyXydAch6AE1QJ8M0DZDD0vgkeCphqYefRERXL4WRDHQGizg/yYQvEInWGvijuvU5OFREpBN2pwVUJ4hrYyUomQMwsk4g7q2wwcJ2WYl4foMshFQWoGXwI81RAMgNkHpT7IqSDnJ0bVrhTBKQuaF+3EYQBtoJQEyzL9ZMbylMo+AnipnFik0AmZceh/wcPO1bNxWCX8LTupVi0UGvEwkxxlJMy93Dl742ffD26VA71FbTab7TCzvzgKdiydPl3X+dWvfsX111+/x4d/WZb529/+xsknn8yHPvQh7r77brq7uzn11FO56KKL9lj5ne5xV69ezQ033DDlWKeffjqrVq064P1de+21XHvttWSzWUKhEJFIhI+d0sIvXhpm+3iJTUnB8lmxN1TWvdnVkvZGp+mZ7rbTybuvPHtbt6f016e9frlSqaCqKlVVVW/LKNB7O6eDue2hvL57Snurr/GB7POwrQCbFPGg4QRchLFwEkNBYicxejFwIRPAT5YKXspqnIpDwe0yya5XeLVkkkfgbTeJBjbQvaMNUckyiwpRh04oViQ17MDym5jLYccZ0PQUNJYgNG+ixTW9dWKuWjUXJFxVYigKGQnqy9CegfKzwDC0zgbRBbRDoewgRxM5ErR4BvHNNUg7IH8SaHOgPwDaOFSPQcN6UJdZmCqMx6FUC+kgyJWJAbWcfiivAO84pD0QdUBsh8SIrjBaCVFEJ5LxE9g5ymzZZMwh8/zCM6DmROQ1T+Nf/yi542ch6o6F2uUQaCHwyt+ZkzJYdVwT1Lei7FjHzMGtRF+xUMcmKomZBAgV0LxQrgfLAXoBLNjZ1Ml4aAtZxYPlU5DyOsqYoKe+DstYihRWEI46xub10ptcTc2Iznyh09QA2RB0eaApD6FhmNMKtQb4QlCZCzvqXQw0BSgYEsFsHvfsCmlVIEQP/sQYbtkiLkFMQHUCBsMmulTkVTfML8MsHao1yAZgrADJLhV32AA3VDtBfxoqdeDQJdLrmxH1oxTdkKmEkXWF/qpRQlKQuGURsbwUexopijI+pYir2iAgwDwWzAQEj4HuIuQr0LR6YgTulAaSMtH13Tk8sW58VGY0XU+NMMg3jNE92k5pm5eZDFIjmzQEi0hGhbKShSpB4RV4+Tk3z25YStCs4UiCqKVBCpYEqJQpI7Ma6DvAO8rBgY5OarPZbLbXsuPowfSnP/2JdDrNhz/84b3maWho4LHHHuOkk07i/e9/P6tWreL000/njjvueMPHjcfjmKa5W/fp2tpatmzZMrl8+umns27dOgqFAk1NTfz+97+f1ij8sixT5Xdz+dEt/OSZbn701E5OmXPw53WWJAlZlg+4gnag204n777y7G3dntJfn/baZVmW39Q5H6jD4fq+Pu2tvsYHss/DtgKsUMFFiXEEGoIocaqRUZUdeKQkOw0/FQRBqUTZrzNrTpaGo8A9G+IxsBrAcAv0CoyMp6j6oUbi0U5CUg9OT5FKCIRloB8tGDoFihKkt0A6D0MvKpQrgmirhSMtU5CKuGfkaY+CtAMYAF8RtFfB3Q6yf+Jb3dyzoHTk6JQ2I5cN6gJlAjNAj0JXFNRhCGegtgvEVlBS4DwKzKMg6wJHBjyDINogmAVDhqQC/XMVdparcDlTtCwx6HvCwahsIlthdCNC81qLfiPBhhM7EJ4RlKfvo+bJ9TQV82w1u8mefRJ4O6ASouJ20nOkA62mGmnzBmatf4qq7SUqQ9DX6ePVoxZxVO/L7PAF0DtPhGgHjIyBPgZKBNMxm7Q8AKbA01eiZlwnovZAQGJ7c4FC/QmQjyBcXoqKhx5vitTwenyBEomwg5CzwuwijOnQZ0ImoBCWLUoeN6PRJRBuB3cD4+lBKHdNvIUolSiobiytguEHTVYpelSsioZPr+DLQxxY6AStAk4PsAQkj4G8E1Q3JF9VyQ4HqNSlUcsORso6sXGdLTtkzAUuTFcVr/hSzJcdCKBMkYzwo8o5mloNGmeD0MDMQnoMrP+F+jRkKiCNgtwAWhqkMRgvgqcMetLPaN5LnCBxb4lqt8R2rYqCELwanMHcTJjOops6BvGHtuGy4NU1Tv53Sxv9wQpLUlnUqg20LS6QeUVBU1di+iCilkhULMgeyB114NNz2Gw2m+217Dh6MP3kJz/hnHPOoaGhYZ/5WlpauPvuu1m+fDkzZszgJz/5yUHvUrwnK1eufFPbX3ViO794rofndyZZ259mSXP44BTMZjsMHLYVYIGgjEktJkWceEliMoo7mGbccNKda8XhSBKqSTKj3cI1G6pPhMwM0D2QMSFXAMuCYg0ccWmR7tUjaJqG5rHwRcCzQmCeAtkGaNgCgRFIdsF4IkBaVsn3xSEhM2Cq9A/JdI5ZVPVIGE+4yZgwWA7hFWka9DJlBSoeqKmDmiNzKNuh7INYJww4Qa+CxjVAFlztoB8JlR4ob4SgG0IjUAX0+iZaMMcjUIjDrAj8ORpGD4bYLFWIxytUclDxZlBzGdyjQ5SbLFI1KtXqAPU7XsVYJSGtD6HPg8ATKYzYIxTPaIF4knJdO72FLvC04erejGuThtblR8wrsvnMNigEcSmCVLATHEfAlgyM/hY58DxKLgKFNKGxNE4E3iy48rDTK9NasfBXj1MwjYkTyqehrEIxTy6ggqKwKF3BqoAzA44s6AuhYIKqSmSzc8GMQXoYwj5wa5A3kIWJWy9Q9EbIOT24fXFSSgMEmlGsftTSEJrLIFSEfBmkKBT7wTkISnbiUSXRA7kxF5pLEHOBMeDGKScpaG7aCjkS8XESNSHGZ1SRbc4S3dZIiRwmdSgODakChVdlhtcr+GMV3GFI9k/0KHc5wCpJ5LJOHHkLxTBQywJRAk04cFJFAhmjHMYxngRhYihOTEeQvDTCWlHLYtVFywyDvrUenl0zi0G/RbjspFYepqFzB86IwNtooJUM6tohbYIYONA7yn5ws9lstjfHjqMHS29vLytXruQPf/jDfvOOjo7y8Y9/nPPPP5+XXnqJz33uc/zgBz94w8eOxWIoisLo6Ohux6mrq3vD+329hrCHC5Y08Ic1g/zoyS7uuGLpQdu3zfbP7rCtAJcIMoJJlBIyY7i8/YTDKSoIRNnCJw/SHMtQXStwLAZnCPR6SLkgxUSvXdkLkgrChHQTtFw0xvgr4K+BQDv0z5loOWzph7ZX4dWNPgayIVSKKJJA+CTMiMHQFoFjuBbPE6Oo417W5tuBBBX8lIZqGQlvpSZUxlWGch+MdYFcgILpQPgr9C+EXAW0MXA4IaLCcAIcJhiRiRmAnAr0vwieReD1wEAMiiUIDsDZepJBPUlqjsS2807EOmsRnid+Taw3BcMWRR2aizrVIzppJ1jVgrRLJ7XBj+oqMqtrC+vbHsIq6qANEhhLk6sZQCko1A46EU5BX4OET+/jyOHNbKkNUqxrgJwEuR7U1AswmqDxqQTZrEVAEXTWQKEKRAqaNYvGCKTTMpg+qFSBNoAsb6RW6qOmYFFXBFwTrdqiDFICMpUajOhsEkYG0dwC3ii4WsEfhCJgvIwkK4QyBnolC14VJSNQvAKzrhlTqyabsHBlBsAB64ISSV1iUdFCXwciDgUfOMsyLqWEPLtAlQVqNIfPJ8giob4qMden8eJ5acqzWth2ykaOGMziKjTgpoDsreC1IJNRyboAB8gWWBUJM+siUREIPUJeWHjRCWDgyvgpu8sQS+PWvLiNTnQrgZRoZS4BhGGQiGdQqcMnBfEd+yJpv8nIIwuImxE6M2WWigqzPQOEFgmG0wpbt3hpq8uRq4f+YdiQDgDTH0wAvBP/AHt12IYam81mm6b9xVGwY+n0/OxnP6OmpoZzzz13n/ni8TinnXYac+fO5fe//z3btm1jxYoVuFwuvvvd776hYzudTpYuXcqjjz46OT2SZVk8+uijex3J/4265uQO/rBmkAc3jdAdL9AeO9ApDG22w9NhG0nzaITwE0bGp/RQ15iE4EQFyhc3iCbLVOuCYv3EaLtaBLJFKEehVIaCDmUBmgOswMQUQcmLQF4I1RKUA1DjBW8OvDr0lWFcVcjjQ5YKNAVSyGEBiyA44IecSjEJO8sqHqopeoYJRXup0apwDwRwRMpoKTBMhZGSj6Is4TWipGp6CCyyaF4Hep8L+WiNvBf8AkRsYkgNZwkGnZDJq2iPCVoGTBYsmPgGeKgdEnmB/DAENgj85/eTnXkqzlwI11gK0TgxB2/aCykdapxgtIOcKVK71kMpKHDkTRhbh5zL4/YVKFR5EeEyejjF8HydzoLF7Bj4KnnWzwozUr8MrBDgRCrspFUkkBIG7mEfctaBf06KrTVO2hSdVBBc1RC3wJErEdn+d7KuEUynC18pi+KwwANqamJEY58J2XHIGlCqb0I0vxtl7e+oX/030qF68qdeA3I1+JrAsQ1TGiNeZSCyGjGfhi6rFNQAJEdBMwiJFLMAKwFrWmJQkllYN4paBa4KGArIDotKADwJ0GIQOUYw4gZHUZBc48D1uJOOxjG2HVNH+phWUoNbaVqXxu+uYCgm25okpGU6y0wY7gHDgniXC1++HYMBUvhJU8KFjwAKbnTCmoE07iDYPkxdtoJztB4NgWAn8xxxdCNCRnITXPwEMxdleeaBKL2mwIfGImeKuTVd+Bo0hspw36oGBkUti/u2MLNQpFBQyRsHWgHeX8vFgU6rZLPZbIeb6bQA27F0fyzL4mc/+xlXXnnlPkeatSyLc845h9bWVu69915UVWXevHk88sgjnHrqqTQ2NvK5z31ut+3y+Tw7duyYXO7u7mbt2rVUVVXR0tICwPXXX8+VV17JsmXLOProo/n+979PoVCYHBX6YJldF+DUOTU8tmWMu57ayS3vWXhQ92+z/bM6bCvAEdx4sQgxiN85hDsIRiNI41AwZHSclMoapibwSFAaBbkdSkWwBMguMCrg80Bcn/jGN147MWetbEDbBsj8QqKgwtYFgvgsqHQWcb0osHATl7P4R6FdQGnWKOk1MTxI7GwtMlTzMq5lJZzVFs3FUcztEE6D92VIJ2XSVj1Fy8KJGzml0tSt07dKoTASQe4exVcnQIPEILhrIdUK/SWZmccalAehKCDkhKAOhRIMuicq8s4E+Pr6yFY9T3bJPNT0EMGUTnImOGQo74CeHHjDoM4Cn6uEJSAfURBmHa6BYRqHcvQ0hzAXt1Gp72DHsgSeyhgZf4Du9gVoETfOwS7QNqIHGgGJpOSh5FnM/OpXcFSXKcyVSUUVSpKEVxM0yFBySLiFoHVwjKCxkqwpEwtVKPnBUQSPA1IGaBLoSdBd4Mgn0QtjYBqwU6dK7aMwYx2i4QzQkhCoAy1MRapDYhv+9BAlj0lO60cUsiDHaNQrNMZhOANiOIBeX81QYJzoGRb+3onvtKUiSDFw94F2HIw3TPweOTTwui1Gx6qYt2UIrXk7vcEWInWCerVMMgSvRhQ2LW2jrbuf8ZUGxVcUtGiFYgay6Dhw4iVPGR9D5IlIKsH2MaKBCmigxiTmnTRG8lGNXF8dIXeSJlnDchUZmvUi8z9YZmydQn64mZ2SkwYpQ8eSLdTUW4x4oeeJIIO5ENkaE393HXWDJjWYuKiij6EDuKP2N3jLWzunns1ms/3jm84gWHYs3Z+VK1fS19fHRz/60X3mk2WZb3/725x00kk4nf/vui9evJiVK1fuNqXSLi+//DKnnHLK5PL1118PwJVXXsnPf/5zAN73vvcxPj7O1772NUZGRliyZAkPPvjgHucVfrM+sbyDx7aMcf+aAT53xkxqAu6Dfgyb7Z/NYVsBDqMiyGKQxLRMCjpU14JWhkxFoOFjuKCSe8rB0FoDkwpHmzliFwmyxkTrr+6AnDYxr6xegZICNWmY0Q3Jv8KzzwUwnWX0jE5gAdTNNCivMcBoo5ItoSlZeh5ykCqq6POyrLswRHrFXCyvBA4XpDOM6DryIo3I2BhHVKWJPGcw0j1OxaqgKQq+kkU5Dw6HSdmVIsPEd6MjTQql2RJ9hkWfqCUT6UT1v0BE1XHq8GoFAk1gJKCjAiN+SFqgDJk46p7CCDWRPD5GeXyEYMWiegSsCpTkidbQbYobM6wTylsU3W7Uos5sLU4FCSvimfhQeqybsjfEi8xFVDeCnMe3dQ1Lx3rZEK1Cr/MgsjopXy0U5pE8aiPJ5lrKPpOZO/oJ6VDlh9UhHyNyG15tO20FndoBk7BpUopATAVDh0Q1vBR14tlewdkHogEMLQIuMGceS3ZhN36RQHgzE/3XjQp4qsCtQq0LYYYYNx+lWA9K2aIjM8iM0hD1OYuxPii6wbt5iLJHYSdOKv4y81tAGYGCDH5j4sXAVicoQDQMpf6Jyvi4JdO2yU31ggLj27Zh/M3JhowLx8Is265rg5KP6nuhf2sE3Szhc1aoGCCkHD5fkbJDxl0q0KqYdLRrNC0zKe6AXJdCaUeIUqJI9KQMkeezqLWCQgzcczPM9IMIQlIXOIBO4aHR30Wg3WI4I7H26XriiVk0SiU6ze3MbixSSfgxisX9TsSxu/21XNgPbTabzbZv02kBtmPp/px55pkIMb2W8jPOOGOP6UccccRet1mxYsW09n/dddcd9C7Pe3JUW4QjW8Ks6Uvz82d7+NLZc97yY9ps/+gO2wpwgTxeHFRwkqy4CWRKhNLgiIJbVtGoZxDo0910ZxJEzTidf3DScoRGsA18FUiUoDEHW73gdEAQOGYM3BtgwwhowsJXXUH3Q0aGsAWqyCLw47eq0LJlsj438Uvy7HxvHeVY80S/5ZyG1LsDWVIwfWHM6qWMtcDT4VeZ51pLXV2S+hxo1ZAOwbaZEm4F6jo11tdAvAaSvlasGg+SoSJi80AsZWc+Q6B3M5GYYDTsptALs0cKDC4GOQo1Cqgy6L1FAs3biftAqhFE4hAMQ9IBjUXYoDmojCrUrPcgyRqx5hKBIzYzWOVjyOFBSCOwZSX+4VHalCw97jT5qgD0jxFNDpAdFZQD0sQoXsoQVDxIVU8zpPjB8jFv1Q6EBaYTnlMjJGa0oY7GqdYMYjIUaqBfB2cNjGXBm4ZyDlolnWQaPEUf8bCBFT0C3AvAGSd7xnJyifWgD0H8SfB2gp4GXzuoTlDdZBuPByONWR7HJbqJuC0qG8HcPDEPb8fMMvlkhoS/lWBlB+4NJo4UuIGgFwabYXtAwleCnBAEh6Gcq6OVWpzyCPmiRTgBcs7BaF2FsbYo5dpFRJ5ah4gbDFSlaM1LeFqgwa+RjCeZsdTA3wDZLIQFOCvQNwxbtsuokkV7NIOvS8WKQP1MgdYGffOgNgD57ERlPFZvEVrSjafLx4IjU4zlXLzw5Gw2lWI00sp8x8u0zkshagXeeJncy0Es40DnAfYBnn2sVw70FrXZbLbDzP7iKNix1PZ6kiRxzfIOrrl7NXc/38u/rOgg4H5r57G12f7RHbYVYBmFKB5GmJjuJ1KvoxxlIu0Ay2FRpsgotci4qK6kqUbBHDeQVkLg3bA5AlkH5DIQHAVPBOQyhMdg+zMKhTFweUvoaZmY2yRRAdUPqCEqZjVJyri8MPiBEvEPdqIrLaCZkF0PA1ncvRnqcib9MzoxvGXI11Jsfx+rT2gj1PgyVeP9VIwKmWCEfG0zSqBEvDxGxucFHSx/A4xLiFg9KMeDWUVh/ocoGHczWiUQeom8qmGUNDJpg+YYKAo4BcwfgZxHMOSSiGowHoZwEpQyZKOgpw1aulQiqRglOYFXthjrEAw6ZxDb3EValzFD/dQ/U0YPCPQT/OBZinPbw1i9Jr0BqLh94JBAKePv76Zc5UELhGlb202spNEtQUWBnN+NYyxBU6WflALCDWoRQhYoY1AJQd4BsRLslBzk2xV0q0j2uFZQZ8N4CLwGOOoRYQm0NRPXWG+d6Mtu9ABVIMlggjw6hlocoDsrUy+Z1AdBU8FY68GVreDwFbBqBZURi9E4tFRB3RIQBejKQDrkZUyayYwtO4jm8kieFIonT+8cDfl5haVei80XVeifN4/ynKWgZ8i5Q6id0Jm18EWh9ygJ5zGCfNlklV9B0k1iJiyqQPedCi9u8aJaLqLRNFqVgS9n4siDshD0E8HnnBih3OODcB+kSnDaZzOkXs7g2AlrH29G11y0SBlaRTcJS0bPqHg8FSKNoLwKxcyBjkS6v5aLA61Q22w22+FmOi3Adiy17e6MubXMqPaxc7zAPS/287GTZxzqItls72iHbQW4SIoxdLw48DfmmPlBE20WlCuQ0mNoNFFDgSgJcqQoUodelHjpT3m8fQX8H4KBedDdAK5RCJfh+DyIIUgMBcAwaWrKUWgFMwO1D4K7GrIOwQ4zj2IlMZaZpC6agXAsBtMCvwrxBGChV3RGqkIYVccija8CTwvCORtRcxTp2PGkRx6HsQ3Q+B5onIVVGCdRiYPigUIa8EwM9xyIgbd54iNldRHUvAtR6QPXRnTFoGvWTJoGtkLOwi+Bsx7KDqg1gaTAV4JeaeIz2mIeqsehOSyoNGv4hkxMl44yw8DMq/iGdhDZGSGj5lFiOpmkQq3fwArVoXa9yMxnn0MfkTCO95BqPBt0FYSPurKGyBfp81SoKxbZVgN9HTJyKYRZkvGND2JVT7Sgl+SJHsyqBP4y1JRgOASyClnZT2VEpalUxpsdZXj8BYyGNjD7oTwGjhSUg0iFOCL7d2g4YuKDaE9k4u1EYjPucj9qXqBZMmskhWOLOu4YxIcsjCEZYbjw5F20bhSMyeAoQbYM8WcUnGnBUWaZl46MEW/LMzexA7G5hPAUCQhwvBqjODvFcGc75dnHQ2kMNAujNca6k1uZOdbLi9V+MidWsb7GgdBNLNNBKL6TumwF/ybI7fRQEBYNgRStM0yqLQgvBqUBsvWww4CoBloR0gkQBriqQO8DuQ/yY9B8bi8hpRevKrHqj1V05Rfg7prNwvotzAmZDJRn4KAJ6D6AO8quANtsNtubY1eAbW+MLEtcc/IM/vX+DfzkmW6uPL4Npyof6mLZbO9Yh20F2EkVtXIF7+wES69Moc6Fvji8+Pcg24dnU892apFQAJl6UrhIGNWYyRbU5zexqK3IXD9sd0GhDDUukDbA039UKOsVnM1FPO2QGQK1DKYJ24dljFI1WaeET5XInuJG+Nsg75oYTtgfhLoYBA1Md4pSKAauRkQ8DbhBKFByg9sFVceBsw1is0E0Q7AOHJH/+7cxDaoATUxMVJzSIOuBYhlqTgKja2J+Jn8OuVKiWdtKKg95CfxdE7scdEFDGZQCqEHodU60DqNDawXWz7bIFkcIjYCqQthtMJJzk7Kc1HQblHwmgWYoh8BERtVy+EwTqwkytRHw1sH4AGRfoF92EC4YGP46ts+rUBYSwgpjesK48sPIAYshWaG1YiJpkA9BLgsBc6Lrs9sBORUMd4babgszD9GeErJjJb3aEmj0geGD3AtADLkoEF4FS2mAUAiK3ol1o/0UQ3XMkoYQusz2xiN4xdrEnN4cLt1LSK2QH1ToPvJddG/9K3PTgygleKUEatpBQTXoVAxmb3ianbMdKDGQCg7KMyo45gpmK6Osd7kpyzqNj/8Kc0OJbHUDxdMWk188i3WajhrIoqTLSKkiXt1gvlTAm6lgSjCQBClYYHFKoVzyUojnaVghUOuhok9MixyNg2rBmAn+dbB9WKHleJOazMQ0XiNHg9EpcDrBSAuG/ipIq6MELBX3kIxiWeRNg53kD/CO8jExhcfe2H+IbTabbd/2F0fBjqW2vbnoiEZue2QbI9kyf1o7yKXLmg91kWy2d6zDtgI8J9RF58njBE/QaTgSNg7Ag79S6VrVQidJWiiSpo0iAeKUecWXR1WKLMy6qOTnsv3v25mv5XEELbIeaA9C10oYSCrUqhWiQQEmVEZdlLIteBjBmp3DUAeJyAbho1OUOkNoOffEgEy5BIwnIbwEQmFoUMAogiuGlExBPIBwuMDpnZjo1hGG1vlQKU3UrkuOieZRlwPyysRQ1HkD5HEobwBv1URTYKUeCEPjUhh1YpCgN/sSs0hjFiBhgZKDjAQBC4o+GK4B13bwWzBqQVQBKSCz6TwvoW6Jdq1AjxzECPiISZB3GCR81biqs7g8FVCHUAJxMo1QrJYot4dgcOfEfEpWJ7qaxN29E78+RHqmhBluRDILyDsHqd+SpuKXybVHGJKSxAwLRQeXmDjVigz1EqTKMoVgM8qMETxo9DZ7kJwW6E+C/D5QIigjJrHKBjJ0Uq6eA3oDSBWoDIG3FrzHQHkT3fIcXJF+pEqO0UAdS9tyeKQ05a0yi0eLjJijDJ1zGaXnfklNcZwhv0xkgU7LJhhzQX+TG6vJiaXmyRV01jc5sSJuYsu8jDki1ItBlvVmyWYhme9lfVcI48g2avqz1PfkMDfkYVii7hiLOcdN9EoY8EHyWJDzArHJokHRaVwkCB01Mf2TuQUSG8FvQkkCRxNsezLM+mQzbT0DVD6VQoQnpvBylyd+bRo3QEvZSW+ols7KFlqrK6x+cR4jxhizcPHyAd1Rjv/7s6/1NpvNZtu7/cVRprHedrhyqQofPaGdW/6+hbue2snFRzYhy9KhLpbN9o502FaAOy8cpHYJmA7Y8jLc/RMva+ISdaaOlwBpmgkoCbKmTo+iUvTLSGYdacmkWUg4hoO8+Cs3cQTOcAa5Rmegz4VKiHD1GI4emfFXHQgrTIgwgeAQ4cWQyg+j1AnSiyUqPi+U00jlceq2vEKlLBOfKUPgdPCEwPSBpeDfkcI53kOi5izwNkIoAroGZW1iIClTBaFONMUaEqRlqGRBykPpISi+hFwMYbl8UF0NwXooy+CbD+nZDFUtwrSeoTphoRShWwPv+ESLYtYL5RIkcjI1AxbOMsQ9YLkEetTDqLuRsUoOoS5FcfaTy60jWduOtdDDUHor7oLJ7PgOTCGozILxcARh+UGb+OYWpwNlOIu1VTCrlGZ4BJKtJla7gX+ggjduMRCIgG8J3viz+MolHJ6JkbfNzMS8vy4fKGEFEexA8mQwUzqaL4acV6gZfY54pQ2rQcX01NNaGiU9NMi2KgPkDJTSUNwOgVYkhxNHOo3euYxKv5tofi0RIVgfBHOBoEEycY1A3fpH6JnrRltYTbkrScHXSFv9IIFRE/cYbG2PUvLUsDEXR1UFM4o6ibTKQNsiJDGGrOnsaHRT7JiYB1gsSiJXijSM5PA+I1PZHsEtingbS5TMiXcZviEwBiTSMwVHL7PocmmsDkrUuARHbAFlJyg7wBEAAuAfgHLZZIZ/iGhQo7wVtj7iRUaj+SST2ZeAtE5mpyZRpUtUSRVSr8TYoPkQOJhTswPGDuSO2t/0HZU3frPabDbbYWE60yDZsdS2d5cf08L/eWwHO8byPLpljDPmHfxpl2y2fwaHbQW4aSE4lInpYH95t4NtXVFkySBACAcB6ly91M3s5tWeRhpNQTKpoJKkKlwkkHMRdo/hLSiURTVyxktc7UOrqIRqM7hmQHadwMLEh0aIEZpDJfqCkFghCPtgMBjEElFIOxGmiZEwcZU0ZN8AVocD9BJ4vZDtQ8hJmp4aplr9OttP+iBm7CLQEqApMPzSRA3VVQ0ONwgNKkkojIOrAOmncffHaRrvQwlAuV9mcEYIU65ChAOgz8fSWhn2rCdZI6OW0zgcFjOK0O+QMIREIG2h+RSUGgvdBaYGSl5QOzZOw/g4vd4Y8RlzMDud9Pkj0LwQ56t3E6OIV8ggnCQibnLGDCqR8ES/ZcMDrn4wdBwOL87IREN4gwscCYO+hiNJB7NUIqMUOo4GtQb6JRgFrUXCEVUIhw1EDpIRSJgORHAe5UIfEXeaRDGJnFRoT5SIZn/HNuMEzM6j2FAsU4lI4DsJKtGJyXtjtZDVcaT+wrydWXbmHqFQA7lyA1rMpGQmqSlpmBFIZcA9WCQWeJicaOWYtVAMaBRdClrRJDAOwWQabVyhcVxQHgF/AdxljeE6HyK2gh6nF+fCUfzhAcolMAN5pHyKrANcJUEsnKesVJAXQrQEYyq0jkDqfx3UrNB54kyF1a0hZHeRhmSZ8ixYUoBYARz1UMmB1QaeU3PMcsBoNYw/Bb4xA1+LSUWCNCBMBxXVQUbN0a2DJTz0KoKgY5zgigz87kDuqP19u2Y/tNlsNtu+TecbYDuW2vYu6HbwgWNbufPJLn70ZJddAbbZ9uKwrQC71IkZhx6/x83YjmoMKYRPklksVIq4KJkVlAZB+6kDZFVI/caBZFqE32Wy40UV+dVZCBxoOAhZMsPJUVyWwO3TKSdU9EKUkqgiiR+VAiW3xKBDoj/qJOW2KAQXQBnI94PUSUn4qIplkV0eLEOaaNYUBpR0ih4/hSZwVYpgVqDcD5UyjGQIvvxzNEcSLRCEqvDEPEZWEoyZkIWq7iSulIUrCKEiFFwWw5bAlRhC9D9OccaJE8MHm2vR0nkkR4lQvkRXVCJf7UPKCSoUcYVNEoqfYtmNZaWIayaurRLjhgyNWdDX4Fv7CvWVNNboKvxjKQq+IN1VF2I6qsGvgTkbrAyMPYU8uglXVR+ljqMpzb+ErpnbcI6O49QNCrULEdp8xAyNXKgChoZn7BdkiwaBuETOV0WmaR7NlecJuyrkNRhJ1kBURxTT5Mrg8JRQ9YnKoKeYIxZYSco/k5LZBmIDpPoh6gfDAn0QeWAn7vIIOAR1+RxdTfPRZx2NbgncO/4IXo28GyrBiUGvlEKJ8qIT2dRtcWJ6I4/XupihwzYX5N0FrEKUvio3nYUygTDsyLqQSVD72DrmlvpxqxWijROV0yE9w4BHoroTYpcJmkyNp8ehYkBLGYQXLB9UXaLzrE/ilZgHacBk/toysVcVxCIT4zhoOgb0IlTWQyYIVS2Q8kC+BfzrJBx+QSAKSieMFWEwKZNzhnCp0FljoiwcYMbTBRYGU3iSB3pH+QD/Qb5LbTab7XBix1Hbm/fRE9r46TPdvNyb4uWeJMvaqg51kWy2d5zDtgL8zCNgSirPrZmJLoWYLxoxxDokLPpwUTKCVFYHqF6RI6vAgCFhpH1om/L4ZBhApYybVspIjKAIGQcm3h4HOGTc0RTxeIQkEgEEah5SkhtDDZJ214NvJoHHHyGsDJM0hjDCGjti8zC9HVDKgOYFrx8sPyJvYYZhMBDGrMg4nv4ehuSkpasHp5Gkq8YFOQ+SQ0LSUlieRqg4oGISKhuUI1BQwVcAvSJTcdUT1HuR9Q0U+1eB9zic4wLXcC/OsEVoADIBF2asGYRBwjGO0Kph9vvAdFAY/B2xtZspl2X6ZztQTQN5/VrMDRnSHTozfQV666OM5K/AKi2HXB4a1oF7hGDP0xT6LQKyzinjvTwS9pDvPh1Cx6OXLHRJh94oeNLgdk4M1qVsIOLNYSom2rESRbkZHFWM5wIsDiTJ5iVKkhO5+AI15SSBEjRkLVQDwjWwxgeVqEGs/CrDRhYRksE1DoobJA3Pyj8xs2srXtVkZwtofhlLD0AmAT4XoqoefyaNFZ1omE/JMk5Fg2w3Wxecz7y+LuaVCqw7BiQFOjZpmKu66Jsj8VKLE6fuoxItsnTV07StlTCGGxlXk8h1BepnQmyuINoiqA5BtA1WF4AEzOqHzXVQzMHyFIweAetrXMg5Bd/GAqHfRHGko4Sez1FaHGdLrUlynkXVUVC3Fgq9YC6cuMlDJwma2yqEHBOjea/9gYdXNkcpWxU8agazLYNrROEDHQnW9cpsOpABoIH9t1wc6LRKNpvNdriZTguwHUtt+1YTdPOeIxu556V+7nyyi/+xK8A2224O2wpw73aV7X0L2VKpIYSBB5MwWdI0oqOzQyrTnW3C/fNh2lakmaFK9Bkegr1FfDWComxRY2nUUsaS8jiFE0tIyK4cIbeJKPoYQyFKnupQN7LXpOh3QHUjOJchDRaY8b/j+Md8ROblyaAyLDI45j5D+fw28AVBFlDWcOojlFRQChWkgVcI514l5W8kmEzSHY4SSJXwxocQYwKr2s1YYxDiORxWHlmCjEOmTliUVTAsBeGSyBQcOPUScmIV1swINSN9iKSFNQSOXok6n0avmcSorifQO4BuGZQboqBHUbLVhJICSTVhyMTjhdCmQdRxmdRsQXfJxZjrMizrePAMQFUetfhXOtf0EihpvLL4cvK5IOODG5CerAepFnqyUCmAbwglM4Ar/CqmW8OwOjF9ixjhVKKhh8kEvVQCbUjOJP6IhuaFHQUZMzSClBUoRYu6CrhM6HfBel1FqzZpEQJhSQxFjwJJRUr8BVEOoSSdtD6/AytrkW0EOQ7+cRO2voC7xkFiwVFotacxIo9imBncOQuvYlH2yqBtx5CPZOWsEzh140p2lgRySKC8CsaIoCYBIxfLJJrrmbOlh5lrBYkRhbQjT2hOkXxpYsCxRhlC2Yl5lksFmLMGEt2QaoLRPLhiMNoA95f8zHguT/VoGTkNUUkjp2QZLpV59fkYBhJVz6XQP1Ji02kw4AIjAJQmHpm8tdB9rxNjUz2bivXkAi4ksZOOTAB53UIkK812Z4JxR5nx8oHeUXYF2Gaz2d4cuwJsOzg+dvIM7n25n5WvjrF9NMfM2sChLpLN9o5y+FaAu9vxGZ1UEcfCjYxOkpn48SIxSH9Ax6wN4hqewRxpHce9X6P5vnE8moWjCaLJPopWBU9Bw1Sh6CgQBcRiKG1zkqvIOAJ9xGZpzGzUSdRAMegEsw0sQWjD41SGDQo5BfF8LRUrSK2QqNvaz7bwfWTOmgvFahgZxZvVUdtAjeuIsELOkjClCltq67GUIlWbi1QnTIp+SGsatOjgn4ckViGbECtZyIWJz4QHnc1QO5dKQw3u1GokSYHRfvSBImoE6sZBqhYEB8BXjJM5VkeManjKA5T1l6D2Asyq2ZjVz1CVMyg6QEmCkRHEXSa1Oeg3ZmFVH0Uo90scC7YRd1+MOual1irRHXVghJxQbuFZ/4mI6nMnKr/yOry8SM22DfideZxRg6yAsFjLDn0V6abTGJfnQG0CyXqe5nyCmlCF1ULCnGtSn8wxokcwJYWoMNlcgr4w5GvDuOIm0rYUxbigof1ZhlYcg3cggac0gH8HGHGJikdgCYmMM0JEL+Ie1YiVNMzGIeKzLyUnvw/0Zyk7yghvPZhJiBwHuQCppnfzRDGOldlOIRgm0DSK0gdVHgtVFrxakfHJOpVF0N9poHlSjMyD2gy4JRiVoS4L+SEobYRsr0LkNBNRCx3dUJuFwfmg/BnEi9VkLI0mf4X6o/LUlPPEt8n0j8ikpDI+Z5mtA9B9Fpgy1FgwZzt0PisxttrDsz0qVVoDaXc1RlBQNxDFogrFyjNIhbhLwytLhEwJEAdwR+1v8BZ75FKbzWbbt+kMgmXHUtv+dVT7OXNeLQ9tGuVHT+3ku5csPtRFstneUQ7bCvC4kcHFMNVEcCIzQg0CB0VyjGJgGgKGxmgrNhF60k/tFRmos+hdF6JunUXsjCyJlyCZUKmIIGkMDGeZIaeB/yqd+id1pH6oXwJdM8AwwVJjIDXgiD9J684RnIU6dKmM05XFX3JSooxuVXAmR8HIQKYKSiY1vQKrC1J6ERo2U3ap4A5SWRLBt2U1smQiO6AI5B0yEAHHIoTRh0vvwsiCloeiXyLjOhviVZC6j5LqhEQaKZrGXxKUGkDqgLCAPgeUXQLiFmoaQqMVMs4urOY0+KKMdERwj6bQ/W4aHHk8HvAb4FZlyu6FSOoQJ898nKxe5snsC5T9LWSU9Riya6LZU12PqB6GigkLduIfv5fFq+O4MFDnGiTz4FNh3CfwOgcoOf+MFqwBRx0UEuTNcRJlH62lIo4+8JQFiXoVS/fh82TRJGjJwg6zAavPgda/mkwE1LQGFY0qTVCfteiRZLQ2i6gDMnUOSu3LMTIaTeIJepUARceJkNDAqgL/AgQdUKiGyBgUGqDig7EIidmfg9LzEGhk20k78CkPQI2TUtVSCNWxI9DPloKfkuxAyAoInWGvhaoUUZ0qy8YSFN0WRg209gvUFPT7IVqAMRmcm6BxbZGCZeEwgri8Y6R3QrgegkstZq202KiFcCSdhF1pXCVIO0DSoH6VhHF/M2u0KoaCBpYxhikslAx4rRJufLgoEaWJTSWdmOxgzskjPLPyQO4oP/v+du1AKtM2m812ONpfHAU7ltqm6xPLO3ho0ygPrB3k82fOoj7kOdRFstneMQ7bCrCTKAWq6GQIizoypBlFQ6FMHjfeYhknGiFyZLqDBFdnyCcdhAwven2SsgsKIw6KgKmAqTvZqglKa2VSiyqYOpT6PKSG8ziXQNrlQQseC2mD0NAwLbrFWOM4JQX88yv4u/pR+iTqoxaD4Qh46iFRBh8UhmV8OniiArUrjdHuQhIDiJ5R9IREqVWid1BGaDLluoXgmQHpMEYmSMYLoy4/YVGmULQwUiq4FaTMCGLQQPWPoLUuwCh4qCvmIQy6F4YMJ1pYAkcUp0MnFCkh8m2QBaI65aZTKdclIOhkYO06WNSEbI7imKFhFY/AH3+ecLbIoAcU3zpMqZ6N5XmYjdVQyILog51NUBSoDU/h6B0lb8iE5xooFhhZsCrgqAIjD0FPhpRw4c4V0SydZKkWKeRHTnVRGjcxCiCpHjIRhVcLOcYNL7GKjuZbjNMaREqDJEP+eBf4FjJWGiXv6SYVrsEVG2S0UqboAnyvUKk7ke7oxeBKoGTX4Nn6EKVIEDxLIFUPVjUUoiAcoBlQNkGvgcazQJYQcxaRr5kBsgluP8hDZDxLwecAuQ2UZtAK6MEyulKEcITukV8xJz7AyEww/BZlwNMLchVYBlQ9CVHFwunVCTvj5MdCDDly+AYtXE0Ch0tjrtaC0DM0ZdL0Z6AQAVmd+PfMVByEqNCWc+ITaZK+FHJJkEChlnGEezNCNVhcqKF60Shq24HeUXYLsM1ms705dguw7eA5oiXCMe1VvNCd5KfPdPPVc+cd6iLZbO8Yh20FuIKGSZIkHhQ20UA1Cn5SZIiiU0JmNjGqJYFkVqj0SoTyJvKSUbQjLYJZGI9UKNWBy5nEsSFGuKaEv2wwVgBtKUTGCmQVyCowFJwNrqVgPIm/lKVcDYl2k6RfRWuAmTMEUr9AE1CuroKcEypxpOIAXreBMaQglUyCDgvNXabsLWOGAjiEgUAmXRWAQBDazgFHBehHFBLkRsAp6yR8LuRCEaWuB9N3BKJ8NOasfkxtPmRrGZzVSi7XTTBdZoupUgy5QDdxpfOUNYNUPThyg1RSryC8EQgtgfAg5Laj+RsQM86FkgEjAvoDVIsX0Pqhag6opoxZVY0ROxWEAO0hkFqg8C6k/Bbak8/h1SqEgjAUctMdqEeoaZrGUvQTRIzB7EgWd80owbJAKktsLYeQHTncoyZSGaQANKoDDPpcvOypwhIqGVGP8C6mUhukYL4IcgnDFQFjJ6q/j6waBJ+FbgTx6RoBQycuRjHUzeAugQ6SSOEy45SGwhBLQGYYqiMTwzKPu0EqTRzcEkAIfDIoMrhWgJoBJQXuEOTD4NJAqwfVDeRBSYOjFlxN9Fefiv/x36ANGgy7wJOCeg1qW8AYh0AtzDkDxl0Ggzo4HyviHQBNgmyfhNtTJion0SUdTx4ympeSKehzQl2xTLOcRbUsfCKFkwqKkaFihcj6W9hcVkmYTmbKBaINQ8Qu0aH3wO4ngYrYRzjZ1zqbzWaz7T+O7spjs03XJ5Z38EJ3kt+80Md1p8wk5LVfoNhscBhXgGXSpB0dpOQsNVoWD0485OmWsoSEA5UAEQqE5vQQXGCg5ME3Jih0gNwNCQO0Zgg5Id8NwdYEVSHB1kFQSzD6LolcGBJhFSsWxqw+GfQwcnw7SUXiqSMb0OV6RKOfbK6XciWFwytRN5KmLHdCyQ1mBUciQTUWWYdEwQ2yAxrSgrwEei5P1LQwylDxFCgbMnL/01ixMCTWI8l5XBXwpCpEnDpaUIbys6BI0BYDzQGiBUQA01pIqnYGKV8RyhtBLhArFKlNFdHGYNwPS3mG0shq1tVdjdDrQBZIySKtfWsZF+MUOs6Ewiwc1l/wOIfIWJDbAlLQwlfaTqF2OUgzwL0AhluhEkMoEbpHl1GjraGqvciOdIx8aBG0pRgtPIcjUyBqmQz5VVKRVsaVHIu7xwg7MqgmtLZDKg9eC9aWQuje2XiGt+DdPE6iCmTlYayWkxjxngOecYi0An4sfy2RfDeZcQufYjFzRCBXwBsqUUisR8RNKmWVYEWgyhYlXxqtYkAlBMFOSHtBU0ENT/wXDZwWWEVQHWD4QAlAwQRHCEw/+CSwZCg+R2Dj36lODTIUXkT5uGswZp7EcPVTzBroweyVKKV9uNuKFLwW4/PhCBnG14JXSAwvFBTeq9G4EVpzUChOzGedVtI40g0MuMfR/YL/n70/j5btuut70c9c/VrVN7tvTt+fo6POkiVZNrZlW4ADBuwA15c2lwDv8kKu32MkMHhABmQAeUkGuSO5NpeExAGcEJrr3GCwsWVLsixZfXd0+maf3TfVV62+me+Pta08B9uSjOUDVn3GqHH2rpq1a9Y+e85av/n7/b5fqagovZjBLRL/yQGzl1V6sYGQOkfjHp1kgVbiMZUNKWRTiCTDPtWl/iJcOvPa1lOCRYL1NR6Pvu61OmbMmDFvBF5pH83HjPfSMa+ebzsywdHpEuc3h/z+49f5X99+8EZPacyYvxEoN3oCN4qZ+T6qvoRggESnRYoJzEsTgUuFNn0EbV+HPTCaAP8Y6DpEQ9DKMDsNdSX3W933HZLaaVh8KwQHHQbONJsnF4nn5kn1t4BxCHrbmOoG7uQ04eT7kHu+H5y/Q6KcYqt8D+t7P8gg1UgbOgw9yDyM9VWqITSnJfECFB2QBZAB1JMMy4VAQpolqN6Q2qVHoHUVFB39Upf2vjJbexdQhwod9w7KXkK18xD4V8CLgC4MHgT3PAxdMA/D5JtRhhXSdbg2VJE1SDSbJUUhGPmI9adBtCDz0LeuoV6NCVsDWD0LtS9wvPeXWKOM/iIkPTh5sUeh14FsCEQwOgCjKajEiMIWJXuVkR1TM+D+6TUOJJ9C2V5nWChRS1JKGqQuaO0OdAas1GBo2uyoR/iz5O18wbybh8Rp1g6+H6l9B/7aW2iLKorrUmo9AsPPo8ZnsJ0l6E/Bzh345lto7fkx4vp78NUKUodqBL1nS4SXJ1kIFfaPYpRRwmwmOeW2EAMX5POwPoJrKUgbYjW3q9J2L1q0AkgNEBCbMCzmprxeHXY08AxYy1h4/DJTn/A5+EdPozz2KNTmaP3A/8LZ06e4vLjIizdN8/Cbi3yuqfLUPDx5ES49bLH0YJ3qn5n0i/DoewRX3gNUoNVRaHk2kbSwEoHVjyDSKckYWwPj+0Lmf3yTyTs3sPZvc2AhZp/a47ZggsOZRlUMsKtD5ksSoUBz8bWtpwztFW9j/nr8m3/zb9i7dy+WZXHnnXfyxBNPfM3xf/RHf8TRo0exLItTp07x53/+51/2+I/+6I8ihPiy2/333/96voUxY8Z8DV7NPjreS8e8FoQQ/OTb9gPw77+wRBCnN3hGY8b8zeANu5MaWsqdt1wlbZUIdzzW+wEbQme9WmemI3CyHh1igi1J8zlwJkDugeQyZAH0m9Cfg4oPlT1wyQazD5f0IlGmobw0JJsugXMz1N8McRWx/t9oXunSmhH4zQIUbga9j9LbQE1ckkaTQUUgUzu3QOp8BgbrbJfBjkEtgufAHgEiyz1pJ9ogZqAbSCIroadpoJeg+R4mld8l3HCJF7t0ov0k5l1M915iJ9RAFsEow8XnyMtxhwjrEtLVoFwnkwaKNGimCTszKm6tSlzs4I0SMnMH3BWwejitLq4HaZrlE1zrkyQxcQpuCSoV8GRGEqXgPQv1Ldi4GbISpAMMNthfWuGFmSmup5uoUYZ9IcKob+FPVtFnu/ixIIhBeCmqJRiZFtHccbLCe0mu1GAwTzh0oRbASoyc/DswuU6a9uiXTkGzirH2KGbXIxDPIMUMivdFsqlTYBwgSi6zPejjdjNGQhDPHeD56gSlwVlKImajB0Unpepu0Z04DMsC4iJUUtALMNBBy8CIAR9UB6SfB8JuAEUD/AxkBiUd1BrDFZVRz2YahcYn/292Tp6GvafpvdfKTX8LNldlH/rPYavP41e3qVgh66MidIqcvBYi23kxXO95jaSn0ZUKFSLkw01KeoudHxJkFpRMMHUghpm7YvYWYtZ+D0aiRUJIaHpU51YpzkpefD9YMfj/9bWtpwSF5Gucp32tx8a8Mn/4h3/Ihz70IT7ykY9w55138lu/9Vu85z3v4cKFC0xOTv6V8Y8++ig/+IM/yK//+q/z3ve+l4997GO8733v45lnnuHkyZMvj7v//vv59//+37/8vWma35T3M2bMmL/KK+2jXxozZsxr4b03zfLPP3WRtZ7Pnzyzygfv3HOjpzRmzA3nDbuT9geC08dTTv1vPe74exETB0Ku12oE8xmblSI2UyBskiQi24F4AmQNWsfBvRvMebBr0D8JV5rwogmPTxtslwvUzw4pXfUgLoNzCPoqytVP0fjTT5F+PEV5qgPbT0HvIgQhmWaQJF2MS5/CdysQ18Dx0NauUO/FeE3YssHfURiGFs4KNK/D4jJkEfQkhCWdciJxDAPm74HkNFv7DjKqqWjlFLdxH5q2hlZ2Mdp9tM4GdL08kB3ugBdCrCCCL4J5FqaO0jn5XlanjjNoTmG029TWIrzQBDcDBpTcRzmUuhRskYt2RSWUjRXUuqRaAZGAqUI2KZHVBLHxFOKFT8PqNqymMIyIWsdYdQ0yS6EbQ/qEShxCXG4inJhVbYKrczcRTM8QmpO4tfsZNO4jW5wC7TxMPYGy+edwVUL7Csy2IAtzQarm+6D5bagbazgtl35xFmkfBNND9XZQVj4F1z6LXE/oXi7TXzNRGDJ18XGUpRZBVqCYKpgh8LxBtSVRhjPgzoE0IHFACohcUCLwFPB1cGOQKehh/gvwU0hcqPkQ+hCbVCcVJswYYUTMW1to6w+BjMFqAnVop7nC9PTNROZR0j1gHwfHjClXh0xkMLkCs9dh38GEUiGihEJKlc5oBvGSgnADxJbEfRqyZyC5CuEOJDW4bkHJiTHVHuV4PwfeIrC/H8omLH9S5YkvvLZAKHoVtzFfP//yX/5LfuInfoIf+7Ef4/jx43zkIx/BcRx+93d/9yuO/1f/6l9x//3383M/93McO3aMX/3VX+XWW2/lX//rf/1l40zTZHp6+uVbrVb7ZrydMWPGfAVezT463kvHvFZ0VeHvvWUfAL/z8FXSbKwkPmbMGzYD3GhIznwObtoHS7cBUYT9+wNGcREtrKAQMVG9SGBnuBNgFmA7ALcOgQKHBWyEcDZVmDAzEl1lVHNgR8c95BCVZmH6HhhKRPeTNB76IrXnQq5JQe1cTDR3mbiyA6Nl1PUrNKMOTVJeOvGD0LgP4g5peZayfBHblxgl2ImqpHGJuHMd/bqKcFKevc2AYoIyVKjGsL63CWIadgzi9BjpgQ5+9GbQDmMv/AdW2wpu14TRDjTnwJqF4CpUqshQhbKAPlDfAOlQn7pKr24x1ZIc2JAsVTxWJ1MSpwpuQr8CiikRMkH2rmCNrtLZhkoDhAqjAFqGii1Swh2XoDiBTCyojMCQyGt1utVJ6vYKlSgjnRFcty1MtUWYpUTmQp6+jC2UbguZXMYIdohiHem8FWFWqBz6I3rzBaS/CPt1GJXyzOsXdVAaGJU1zKqO9G+B4T6oS0QnQ7GbZLM3Q3eD/mGN4VZAKVlj7uw+mss7XLxjgvPVm7FLz3PTFQ/dUbkm94FrQinJva3SAIIA3G0wnwNbAedw3vMbCch8oI+YfQppGLB9Oxyc48p797Bn7hI1N2U+g53/9Am2n15DmS9Sis6hltpsHnw3VG+Fvk+mwMRpSVztIzNINyCbgsZBSHtQfl6jZ3okUUgoJaoGCIH8nMb2xxusE3C8NGJaSdh6G/S/DWq/b2FmJmltmesHMuQi9P9I4dyzdVzNANZe9Xpy+dqnae7Xt0zHAFEU8fTTT/PzP//zL9+nKAr33Xcfjz322Fd8zmOPPcaHPvShL7vvPe95Dx//+Me/7L4HH3yQyclJarUa73jHO/i1X/s1Go3GV/yZYRgShuHL3w8Gg6/zHY0ZM+Yr8Ur76JfGjBnzWvn+Ny3wrx64xFLb41MvbfIdp2Zu9JTGjLmhvGEDYNvJxXz7VyFYBvX2lD1zXbbOWxgRKKRoHkxMQXk/xCuQjSD1odgEFGifUtip1BjRx7MWQZ2EiolfsMHYB8Mh9tYXqfynVZQnJrCjAWW9CxpIDAha0H6RmfY2+zKJpsB5GZAqDlzxkaUJBlM62lqE0MByFHrVRYLtVaxqirMPqGvILKPWC7GnBdHEPlAbkAYY3WVuKVzhxcszeFP78ItllEiCSEj9CPxNECJP1ba6UE1B2wNqCMNrMCgzyuZQWhskasrjeycIzUmy+n1QrBMFFpkF2bSJrJzG6HaYVjJmGmCEMGPBqqqyI6ZRTIW0cgy2TkNUgb0J7EQQeRS1jANkFJtw7QgknsBZL+DKPZBeAXsajCoZNay1K5gMiK8XsIxP4fM/0e39FMqL+8FRkG0f8YyBdGuItQp4EN5msd04AOlxUJ6BbptS38UWQ1av3w5L74ejbbKDI5JL/wVldcQx20dRVjg/OICrvp/4lv+EVRLQmwdhggq4Ya4+VfdB/VMs5QECo4nWliQTs6DOgVNDbz3JzAvP0Z5axJ2/HboJ3sxRzlcWcVrn2LO2ir014sAjj1GfS/H2w5W5RaicgvYG7FxkowOTy9C/DME+SLZyO+X0OLRrUJuIaeyJCJausbp8jCgoUN0Z0nxBpZ0VSUQVz1pDOTxk24HsVph8RMG5vkP325cxMhj8e8GTn1lAjYaYTgf/NaynV8pMjLMWXz+tVos0TZmamvqy+6empjh//vxXfM7m5uZXHL+5ufny9/fffz/f+73fy759+7hy5Qq/8Au/wLd/+7fz2GOPoarqX/mZv/7rv84/+Sf/5BvwjsaMGfOVeDUZ3vFeOubroWBq/Mhde/jfP3uZ337oCt9+chohxI2e1pgxN4w3bAB8ft1EEyGXlsFZFQyeUrn1RMjFYAP/YpVE9XAmIH4zGEPYfh76XUgXwbagn0JFgsxM3IYNsgnmQUhTMHTob1Ba/jyz/8Wj9dwCSlIBoTM11eHSAZukOQHBACVepZpJUpl7ttZWn6Y1eQ6Uo4igxZYRU6yAPwItHiAP19i5XqOyr8XTlSLGSsiskZA5sGFbSFWBszFcOY+1+QRbOqjRWSieQOmPiHyJoiaoZUFiVsDsAQVIAkg1SIagxxhRhpJIIqPCTHSdrl3Fn/xe2JmHC3vB6hEnTYLSFtvhKZTlETdtP4KyIjB8ja1yTLUIFSfFtvt42rcjnn8PsglM+dD0YTVA1C4znW5ACLIBrfX9JOv34rpTUF0Cp4D20t/Bai8xuuWzOPGQkWeSZXVihtBaQlz7SaxBRLAIcmSiZCHaIxZmUsKv9YgPnCQrCZSN5yhsPsiweBglBdsL0ThHorwDrBoMp3HFj/PC5OdQb/0s9ZHkPTOf5TM772KlUcIuqrA6C24376EWI6gAi+ehcJ5g4vsQX4ypbH6MfrDKRCmGgsBsJZQvQdZdwZ1/GibvhPAE8tAB3OlLnFv4v7H3LMFKxFLVISmXiQ+8H6onsD/1axTpU3Chvw7dPhzUIS6BHMFLbZgow3SvjqKk9I4OObYuyCyF7IUMuW5ipz1G+4eUvitkcz9sNaBfgdt/yEVbcrFug43/oPD0GYvUT4iNEo0gfE0BcMzXvjCLv96FOuZ14wd+4Ade/vrUqVPcdNNNHDhwgAcffJB3vvOdf2X8z//8z39ZVnkwGLCwsPBNmeuYMW8EXmkf/dKYMWO+Hn7k7r389sNXeX61z2NX29x9oHmjpzRmzA3jDRsA6z2DrWFCUkzxYkHwdIm1DZd9p0OUjRajWgvzeyMePixQnpYUJgAfbAOUAXRmYUlTkdYMmKXcUqg1RJFb6P51tJ7LwScH9J8vEyZQyDQ6Rp+qBVrBJJ5cgNEAIfsoOqQZhCksdJdpnX0Y1CPI7F6SxgvQXsMbAVGE/uI2rX0nqW49TGXDZ8ZNSYvQWlTplhdgeBF6f065/SJGwWfgaySuDYHAdK+jyoyRPgmNWyCcB3MdsbyOYcdEiUQWBlCqYC4pFNwOerfDlClp1Q9B7w64Nsi9flMF5bgkDBWiUpHKtWfw0ghDh+ZAo9ZRUaZSBnoRP/sA5lPvIKsUiGcugSVAGcGhHWQlZb3lYE0OWNpYQH3xx5iI5kl0n872Jhw8iflECc2sYkwllGsx/QvTUK2QqCfg0jtR+x5R0Sc77MPkiPRN58nOP4+69p04vbvpXxBwOssPB/QMlCajumCv/iL1YIXtI5twfQqWLUjuINyfcc1+kr1LA+puxOn9f8GzhUm2Wv8zDOZASfI6+DCC0gCUs+CU4doScuk67aiA2jJwtrfZnNUptQTFjmRwkwW2BiIGez+kTSg4SKHg8SS4T8LMLXDwNtBvho1zLI4uU+nm5wWVvWAFYBXB3VAJtnXmooCZDUgYkbY1Zo+njKxzVEtDWlcFFVehcEeH6ycz1M8Lhlck3gKkXfizPSAmoeFDOtAoeBp1CcVMMO1kbAevfj2NM8CvH81mE1VV2dra+rL7t7a2mJ6e/orPmZ6efk3jAfbv30+z2eTy5ctfMQA2TXMskjVmzOvIOAM85vWkUTT5u7cv8HtfvM5HHro6DoDHvKF5wwbAojgk7jdZHPaJD8YEyxHxepFgsoN2bJV0AOZLcNO6ZN6HUQhWT6EwmZE2QJ+GYb0O+hyMXIS8SPP60zSDEBNJZRmMq7BpeKTxkJHYYDL2SDyBqJVg8gS4j1FwRwgVBjYEEbSMDGX0LNnEFizfSbpwBbH6H7HVmO0iFIfn6Bx9N2f1SQp6F3OYIg1wqUK9gNheQxpnmDSukJqSYpBxrQFYXcKggG1180xvnIBlgH0QxV2nKV5kI5lBGnUIy6Syx06mMl8KuT6xj7DxfvjLbSiNQOqwbCH3wVAaiOESFbeF1gfNgORohK6AbyssXbqX+f4HGeohvZMr0BjCdA0Cge3+X4S6gXY8Yv3sIeIX/x57wwUuLz7IcPpFSv4FPO023NsXoBAhalMs9xpko5sQ5y2cjcOY7TKu8AkPJDDTAzPE7Pwl2Gt4By3s5++A9gHIOij+dUZWDcJ5/Ll7eCbbgyxF8KQN4bMw3UdZnSMrKwzP2USXhmxLQWhIqJ6Gl94FjMAwc0snX0ChA3EK/nFwz8DkAC6DYw/INDDKCca2JJ4Db3YfqIfBdYAYoksgqpBKGAa5t9b89+Vl6IGPeu3PiTSXqy0FdUNSfZdEpMAaFC5pOPMR1RSSZ1QGg30klRam7hKUe3jLEsMtIhQNf8olTSFpCRaaksbnYMOGqwvQPQAWYP5UhP77GTMMuc2Q7KwA3Ve/njzgaxVTeV/nOh0DhmFw22238cADD/C+970PgCzLeOCBB/iZn/mZr/icu+66iwceeIB/+A//4cv3ffrTn+auu+76qq+zurpKu91mZmbcGzZmzI3glfbRL40ZM+br5Sfu3c8fPH6dhy/ucHZ9wPHZ8o2e0pgxN4S/ESrQr8Xf8nd+53e49957qdVq1Go17rvvvlf0w/xK7CuDMzOiuCWZbMPMtE+ojwgHubKylkHRggOA3A8bd4P2oxmVH4Gt74UX7xaMmlN5P2ggkT2dQjvEuS4xzkPliyAqMH1LglHdwpKgSYOhrxHFOjCFmvgc2gkxEugZEFcgrgr2bZ3BWP80qGVYeQeb9hzehEX/yM30LQXOPoA412OQ1FlRTIwORIoO19rIWAEtpG9JkhGsOgVGC7eD7pIZdVLXRA08yGLwA1AnSZt3s1a/iax8U672lRbwKqcRGayU385O9R/ARQ0R/j6l/r9BNf4E9q2jb3eJgv2IwKBXhKuqQcdW+ELrFM9feicXn/lurM6PQGIwmt+CbAOcIH+NoU7qZcjykP5gAvf83+NYsMhq5RL+woOowUsYqkdx6RlQVuHqBPLqj5N1fxj2vxWjfZxGawpNJui6BvsH0DwHyuexjC0aSoKWXSdSlxEbe+HigMb6E5RXejBch84iafbdZMsfgLaDZn2OWeM/oR78Y5ToCaa9Fv26ZDSfcS2pES7fBx0bAhV8B1DBL8BWF+xFKExD6d0wezvMVNHtiI4p0DyJ0QVHQnlrG1qbcD2AnW3oPgL9l2DzcRicgflSnh0ODRi2SeMW1ycatN5d5fKbBWtl6ByB7UPgzMTUj2QsSfBXVTTporoKmQtiURIEgoGf0gltzL+sUP1EgY2dGmuPzyA+JzjwFMyfB9k22AhNuguC4x9MOHinRD0K1dd4MDxWLn19+dCHPsTv/M7v8NGPfpRz587x0z/907iuy4/92I8B8MM//MNfJpL1sz/7s3zyk5/kX/yLf8H58+f5lV/5FZ566qmXA+bRaMTP/dzP8cUvfpGlpSUeeOABvvu7v5uDBw/ynve854a8xzFj3uiMVaDHvN4sNpyXBbB+++ErN3g2Y8bcOG54Bvi1+ls++OCD/OAP/iB33303lmXxm7/5m7z73e/mpZdeYm5u7lW/br0J5vEAOQ/hkzCTZHkdctsgmYyQZ4t0FJf6ouTFI/DsYhFd01CcGonTI7QcGPTAexZtZwt7mFHfkKgW6DtwLYNSA/ynBbgSdW6E39ORMymyUYFuCaM9pH4N3BE4R6FnQ1aTzA0ThP8nXG7cDP7tDOzbiMufQVYmSbdXAQ9tJ8TqbOMfz7imQ7QTg+ZBNUEoQ9ISrBf2kk4uQlmFTh8CSeRZSLsM/QFi+Bhysgjrc7D/HrCeBmMiz2pLl6SQAidQHvwU+uBpxKiDrGTI6QjsiECdhFIdsh0CT6FspKxop3B2fgoRT1ChSIMKm1pK0gigegWmTBhGUNwmSo8CQ/Tnb2Zvew8X9BE7JQNjGKGnIREZft1GBH9J2R8QbtxGsHELlPqEjTJyC4ppHTMUBGddksY+kCFBzSYpGqTbt1LPagyCgNhdYGfiDvTsGcS+GHllmIt/KS+iVZ+m4l/FFxKluEo6l7FSuxkzPMe2V2dkvR2uHQbh5srOSgKxgIIA1wP/GhRvBz2BqIY2EWHtSAqmpOuAMQlaH/a2NhnUHyNp1kBtQ7UNgy2IhjAy4OAJID9QQUioaGTGPGgBo4kuj1UrmHrCYt1FbWbMFmGlA6WCpBBI1Fhl+KSCmRlwJCBd8om7EdIr0vCahNUhxaRAcL6BcbFH84zBqedTOm+LGMzm4t+jITQPgeoCr+FcKQL0V3h8zNfP93//97Ozs8Mv/dIvsbm5yc0338wnP/nJl4WulpeXUZT/fp55991387GPfYxf/MVf5Bd+4Rc4dOgQH//4x1/2AFZVlRdeeIGPfvSj9Ho9Zmdnefe7382v/uqvjsucx4y5QbzSPvqlMWPG/HX4qbcd4M9e2ODPXtjg//3uIyzUnRs9pTFjvunc8AD4/9/fEuAjH/kIn/jEJ/jd3/1d/vE//sd/Zfwf/MEffNn3//bf/lv+5E/+hAceeIAf/uEfftWv27+qsVBLyCZAPQ2jK6AXEgZXofS0jhEZrJ5XGayHqDMBC9sehYHC+e+cITHvgt5liK8jFA0jCDjaSol1uCxgehbCA7BhCdSHVKqNjP5pDV/PMByNdM9B8FUMX8H2YDmDaA2mMgiK0O2ANblFuff/ZaD9MnHvu1BLZ1l87LP0NUF/360o8SUWnu+xvl9jY7GGvJ5iF3xQBL5m4tUUUn0fOAcgHEArQvUvk07MQ20/yuoS01custMfEe//fmgXQdwEzZtBX4NYUrh0Fb33ArobYJoSY0qwlR0k896GceVhmF4j2nsIAgONK3iNWcTyD1CN95DhM01KSpvUiWHvWTA64J2G5AlwL8N2E5GWmb96G5IMLbHQ0hqR831k4QOkFQvZ3g8NH6k+woT6adaPP0tq3wZXiqjyfRTRWBcSVgRcrMGBMuHCnYQkKJsnyHRJcspHrFdg9XaiEwLSI3nP9uxVaD+Kur2M6qTU98GgEqNNrrMlJxhFx+Gx+1Av3IJ0p8jMCEQJ0kEughXFkCZUzj7I6HhAKioYreeZ7G5SjySaCi0f5CR4KggLpPCg6kEADE9DsgHGMjSLeV39qAZ2DHodmreAvwPSI7Ft4ubNRGqRq1tPMJxocdYRyCRjupnSHUZEto91IiO5IFFCqJ+A4FxGfyumLQZY1Yy9J67QflqnOpeiXSijP3gLxcf6KKVlZvatstaCrauQrr62dewCX8tZcFy299fnZ37mZ75qyfODDz74V+77wAc+wAc+8IGvON62bT71qU99I6c35puEjYEAMhIUdEAgCQEdiUqCDwgECvLlVamQIne/z27U1Me8Aq+0j8J4Lx3z1+fkXIV7DzX5/KUW/+6Ra/zKd5240VMaM+abzg0NgL8ef8v/Ec/ziOOYer3+FR//at6Vqa1RWUhII/Bi8FowsQETi9CvxLQvavQTi2zQJHluGdOK6axmFGbWGNwLhdESgauRzNegss321dw2yS8VubC4iAiGJMUDzN7yFD4RvbfsQZE7uEYZ5u+BsxPY6xmxB2vCQVEzZnsBdh/6GRg9aCxcJhC/ShT/rwTl/wfdg/8HqeHCoXcQlA8gen9Elh4Gfx/l4V8QV1JEaoFZJM46MLgAvQ2o74NZldQ7CvuOAwlS1JFXdYr9Ft3BDjxfhmAFJkw4tgNpguiqGOsJ6RQMJicYHrgbWTmCduEZjqVf4OLkUZTrt6E9tol3NATnXgqXD1Eh/8NSsUjpsHNiDVU+iPRdMl/A9Weh24S5Gvolm0o8TYbOfpniZSv0j5dI9HfDCxLCIor3x7i2xaB4c96DbJYR6kkcSlRwWBEtEk1Atg7CgZ33wuRnyY6dpyvmc2XrZhuyIrhDGLSgHICfgm8TT+jU51KqRcG1YJZqfwfbucLo/AcpXXwLSaoSE5IJCVoAmQLWJhQjxOwm5faI9PJncSdM7DgiKWd0HNAkWAqUJVydV+kaDdJqCQbPgGVBfCtke3IhLY389KNlQFGB+iRU3gLVy7D8HPHczVC6FapT+LVjLA8/DdLidHSGfUUXf2abQt8gWNFRaiFxN29b3nQkg0cSBoNZ4usmS91V9tgR1h0RbqnD5oPXMbINKmqENgkNAeGTOte8DEhf/Vrma28m46zFmDF/fQRQpoBCRoyPQRGBQkpChoPExCMEFBQMUhIAFHQCMlJS5Hg1/o3llfbRL40ZM+avy0++9QCfv9TiPz+5zD945yHqBeNGT2nMmG8qNzQA/nr8Lf9H/tE/+kfMzs5y3333fcXHv5p3ZbdV5ekzm8w6MHEHTNahPwHXFsF6SiVLS8S4eEQU2ilqCIarYJ8fkNw8ZNKVqGsR3dSnuS1pC1AyyNBIZ+agUAHjrWzI28H5AvS6GOc84sYUzFQhrdFN5oni55gPUy7t3cv1tE23MUN0dYnZ0pC+KskKHsgYLtzN0PllmFyDUUxWvoeLxwYk5hGEGWGaCr4OqUxQhhukUwfzT8phBP0GVBZgaglGFog+sryH7dMOjngM0Q+ZujpHe8oi3nwGmi9CvIhbPInY/zjugXmy4ttg+a0QP4iqPcGKViR+7m5OXDhAFtc4PxEhrznUBgoqBcoorGsea5UdoukBStZGFNqYz6wTJgcgm4K+yeT5Y1RlDQMfBZWsNgLRgk4RahXIushQR2wFULyCeuUejMG7mGxPM5EVkAzwFx4Fw6Tw1Cxc0Qg1k6Q+CQvbsPcSnC1CJYTaeZT182RWDE0VtDqIKXT7IjYS6QhQR7QVA7n87Zgv3oeV2sToREJCAiQJHF2C+XPABlJbYrU2gSwJMCV9q4I3XKaQ+ZSyPPi9VtBpZ4tkhp5ndMMWhFUo7uz+eyuoF8FbhvgYdC3QNagcgMoULDbAykDMgyqg0ADDB3fESq3N0wcv0x0JkuU9aD2fg6rLhhrQfdJHrcBMKaIYL9Hxq2T9/ezEPn71PMHRCPGFgH6q01NHiHvB2IaXzklKtRTar34tj22Qxoz5xlCggIoAAmIyJGBikiFJkSSogCBBR6CgoKEygY6GQBBSRuzeG5IAEhUFC4kAbCqMiPFEQkEaQIIkQKLthsevxQBtzDeSsQ3SmG8W9xxscHKuzJm1Af/xsSX+4X2Hb/SUxoz5pnLDS6D/OvzGb/wG//k//2cefPBBLMv6imO+qndl6rN61mRohjx+HhbLYN8Jz03DgZokMyTFEKTqUytAfAQ25wXuoSlC3STQV2giMbqSupd/aLUbwHAA167BwjEoXUfuvwdaMcaVf4vzUoQ+u87WooRAI6y/lzO1MxxvL9F6UWXzHd+FCLexLl9kKwIShXTnHvCOQNSFpAZ9HeJN6Jsk9rdDo4TMRnQW72R68AV6qoKXzYK8DeIBKB04OwFzLtQTUM6DpyK6G6T9t+KKdZTCCm9Pb+Fav8/je1oYskMY1JHJ3QyPHYFqBdZrsAXssQnnGoS9O1EulFnTPkM9OMWtz7yNVQycrIpGi2XnDNf2t5HGXrCXyRo1lJ2YRNXAOAKRgzIasiecooECWCyzhpdEsFIBzYK9fdATZHyStHEY7WqdIxffzETWxCRCR2NN6xPefB5l6QATwZsQrRbbToeksQcM0JX/QnJiAbn2NlgPyPoaRucCUlkm0aawjU38tsmVaoLSBq06JAlPYZx5C5PDJiExChmK4yG0BApbyOn/mpcM6KtgSaRh5d5YUgV2SIsZQs/bg7uWwcg5AgSgD0GZAa8L6RDcGOZPgDwBm1VoXITkLIT3wjAEaebVipV7QE1AjUBmYMT5c3iazvQ+Hs3WOLDjE13vEQcWm6lDK63QvdRi8sCI+iGILmVMrDkkWOjONoercH0LEnuV/kjB9SSbfahcAeKUUmoCIa+WCFBf4fExY8Z8OYJciTJFIJCogIbcDYA1xG7RsoGGRJAhELsf2xoKGiYKKqAgAEGGio6KgoaGJC+pzcNkgYDdxwQ6Chr6bjm1QoKOgkQl3X2WRCDISMnGZdPfFF5pH/3SmDFj/roIIfiptx3gZz72LB99dIm//9b9OMbf6pBgzJjXxA39a/96/C2/xD//5/+c3/iN3+Azn/kMN91001cd91W9K80A1XdgJuSIBWkMjafg7kv5RcTo266in1MoLWaUvg2ea5ZpH70NkilE7yWC0QqeDRMZFGReLFr2QGtnVNpXCS+uEE0+Q7D3JawrG0xf8WivQlCoQK+WZ3WV02zX/x5a8NucPrfC5f/WJa31SZoh7jxk9j7k+tuhF4O9AUcE6BGMetCdhW3yPtT6FOnhH6JzJcQYPQ+ZhnrmUdK0RDFbQtt7ll5xP8R1MIqgNKi2ziPDz9FL9qGcD3lR7nBgqKEFGmqowkQ1z05uzYPvw5yAtgsvLML0m8As0Jj8GGHFY6XtcnzrB0lwuCI8doqfoXfkRaRnw/QSlEewcJRsdA+kHdgow4TJxCXJQroHC0mKoCRsKBhgbIA1C14EZgnt3H7m1xwOeE3MzAJCrup9MqfLTukiUr2MrG2yfDpCHleQDYFod9DDB8h2AmRlHebbcHEeRZbRTRex0aeSDShpcF1M4PsJynRInE2jPXU/k5szCDwEggBBkklENCI7dhHogCqhdAD2zIL3NCIKkEkMmor0FSINkgokRQNEE9JRbj0VbORy314AgwEol2BxBtQ6RA2wrkB5Bry9kFpgVSHSQKZgxrk6VZAADtSPwNY2q5ZNfCjggLHDZEulsglsVonskMSDqb1QqGS8sO2jxCZKZpMZUHRVYr/AHB6BqVJVEnoCDp2WiIs6eK8+APb42p2Fr8FSeMyYNwwGAhOFEQo6GQWRosqAPAx2MFB2g2GBiomGiYtERcXBxERFAgPS3SxugoOGioaOgY0kb2ZQ0XZzwENGqOgUpY66WyINKvFuD7GFjUKKQoaKho+Lj3vDfkdvJF5pH4XxXjrmG8f9J6ZZrDssdzz+6KlVfuTuvTd6SmPGfNO4oQHw1+NvCfDP/tk/45/+03/Kpz71KW6//fav67WbQQlzoY97D2zsBTGESx4cf0AQLBfxyhYL9+xw7madbtVmc/Y0VO+A5RWqq8vUhhJhQBjnSTmRgr4CxYuwsD9jOApx/DX62xssxhmiBG0TlrounrcE6l5QPeT8O1hLyrir/4mme5FF2yedAL9Uou99D3j7ofYsxcYf4Fdi0mgaXY5IxH3IwduhsgJbLmyG+I3vIeoZ7G8/RppkbFbLKLFPppiABG0C0hCSgFgTlNXr9D0Htb2X9WzEQWnQ6DhsntgLJQ00DQYSTgP7M1hK0M/pxHtNhPg8YXcLv18grY3YFi7z0mRZnCErfZzieodgVidOT8KSlgdtz91C4aUCkeWRGC9xonWYBg4xHio6mizTXIetox54S9CtILZqHLk6w1viCYZ4eIzYULtcuec68cIFlN4z4HcgVMnm+zC8B9oZRuPTKHZGZN8B3lnwH4ZTJ8m23oq7to3a+yIzxRG91Ia6Ri2NGRqTZK1vZ37tFKVMYUSIjUFIjJn06bzpczB1GZwjYC7Ckgq1FCrLGOlVFBKSMAFL4CUG6AoyMMHM+5YJfIgSiHZlTIYuWCF0V2EygbgEcg+Uu5A4EFXBV0ApAAYkMRQLQARChaQMzhQylnQmQDdhcKukuwPKS23qbahYoFYg0aBU8ml3UqLARy5BbWBCfBtdzjIxtYlhQjwDew+AfWDEJz726tdTxNf2VBtnLcaMyTHIP3g1dNgVpbJ2A1xFGii7MkgZMt8X0ciIUFFQ0ZEEqOiUKGEQkZISkKFioWATk5FnhDUcTCSSAEhRdrv6ywhiBCkqBgqgInFJyZBkZGQouzNI8pJrYWNKyEiJx6v5deOV9tEvjRkz5huBpir8xFv38//5+Bl+5/NX+eCdi2jq3wh31DFjXndueL3Dhz70IX7kR36E22+/nTvuuIPf+q3f+iv+lnNzc/z6r/86AL/5m7/JL/3SL/Gxj32MvXv3srm5CUCxWKRYLL7q120pEVuhYE6Bp++A0bIgO6izcUfGvt+LSTcKrNwMZ+7ZQxpZQA12OhjXnmbPhT7lAJamoOyAE0FxlCfqNk/mwfCiAYYJppbRBTZbCoYlMRlA+CxUJ6E0CVsZLL6Znn4LvewsK1c+x2L2EKavQnAXRAZF9S+4ufYCTyolzOwKe2RI6JxjqemTXXo7GF+E7M9gOEE6eR/btFmMzzPJgNXyHJl1CrwqdD1QtsCZwddS9H6G0DPiUz26lxI+LS3KvTqi+w6kpcP1BhwFJkNYF2CFxHf2YP+zyPWMoGiilDLijs5lPWZDbzFcfIi5pMW2VieR06gtjYb6It66wiidJ2geJ5M7KK2IQloHXFRAxyDB4PbtgzzycEL/iAtqAa1jUo41PPqkmJh4XJnaRkw8w8JzD1OrBaytFxltVhCmT3BkDThKePZe2DMN0zuwPUK0h8ijOgzugLW7UReuk9mXMaOAkrFFa+IwmX0Hzrl9zMdNuujYBMSk1JWE1Vuehb0PwKgE9iRcF+iPzxA3OjBhECY6Wi9DlxmEUNJjRiWdKI5BaYGoocQ9ROqTVk9AsAXZEFQNvGvgKZCokHnQbeSZfuZywa0gySWkDQ0GXq6spZpgJWDfAvoLWO5TuEJhtfwWlOqIU8EzzNUk0SXodcGYAjmT0OhohGbEoA/GPo9k5gJszCCG2+jDjGoVei5sv0ap0XEAPGbMV0eIvNwZmX/oGijoqKRkpIC+W6SsYKMiEUgyEjT0XaXnbDcY1tFJ0NEw0NGRaAgc5G45tEaCeLmA2cZE7oa1ee+o2A27AyBE7BZGKygIfAQpkJHtKkZnpLuvoO6GzwJBsluY/Up6xWNeK+MAeMw3mw/cNs9vffoiq12fT7y4wXff/OrtRMeM+dvMDQ+AX6u/5Yc//GGiKOL973//l/2cX/7lX+ZXfuVXXvXrbiuSrR2d4ScjKiOompLAS9l4UxHlfxvQEwHmpo7odmHyNPgV2HkRc30Dcx1IwDIgDCD2oGTC+YMlAlVhuNnnqgvTCVSUvHV2zdbJ6oJyK0I9t0V6eBNsA+oNiFNoSpD3EOpv5pL2HcBLEJYgusDE1NNcEzpRqiB9hctzJvZ6ij71+4RBAZIdzPAiUl4g6lkMZ+/nmptAcZmsPwvyAMhr0ChCdy9IFzmymOmC5mywMwPSLxP29jLR20P22FG29l2D2QiODGHDho0+GD1U4xnM5y+iByHhUYtw+B5I3kxrtkVLTzE6R1jtlYlvU1E655h1n6Q2DLmsTUOYkE3/V5RgCYZvJxMqQvaBAqBRQGM/U7Be4ny/jaupFF3B3t0yvhHbnHG28We/wO2Dh/BmYvqehpEl6GGCFCGGfJjoJhX8t8M5C/wSpRDq633W9S7xTRVYzojm3sG1hkVBXiEOLTKjBs+Xqa0fRCXFwCQmxcFgvbxEdOg8VmsN6Smozgr+RorlL5Bei8j2uCheRqIXSCKJyCRi5GNkEbGpI40ByB1EIhGjAizcDDvPQmUEZhMmJvJSAu9pSFWozEJSBy6C8WYwbLCrEKQgMnBDsH2Ia3mJ9PRNjMQq+GVkuYa9uoK1KQlVcCYhVED6YO0LiFafonK3h7qsk7U1eidXSXYmMVar1B9q0flOiE1QX50G3cvEfO0Lt7Fwy5g3MgU775qQfi5PBQoeGSYmDhYZ6a5slUYBAw0dDYdwV99Zp4iNhYNFgwlSEkI8BA1MLI6hIzAQ6FQxiYhwCUgISZGEqCToJIBHgMsId3dEjCREYr0c9gpCElIyrN1wWUqJRw8FHROHCH83pB6HY99IXmkf/dKYMWO+UVi6yo/evZd/8emLfOShq3zX6VmEEDd6WmPGvO7c8AAYXpu/5dLS0jfkNe26S7MjiBMorEDlJKyIlDS0WHPmkNPHCSrX0PwNkqkTcDmEfoviUyP8SyCq4BQAHUYmtIsm3SOHUc5dJgyhvgX+BNjAhAebrkT2UqyOpNj+LP3t8wzf+v+EYgaNFvhWrnzsN+D6cTDq4PhoU58gmx2w6c0gwxjRGxCHJWJtDpQBInkYLt1FeY+DKjp4pQcZpOA1/w70LlLtfoGktUyIR1x5BwQOVB2kndDSFaazLqEHg9veh/bszSgrJnqY5l5MR9qQXIOOBP9pmDiAs/08pVUPeVDFj45x8vP34cXTDMtdjNhmfjTPmb1PoAefYKZ3nnVfY6M+SzJ4L/QzDB5HD3xGB/pc7vWYH5lkgLrb+eRQ5BQFDro1PFQCUjQCltnipVLMzuFznJx4hLVKhdULp0g7GegSDjZhnwu9p2DnIhydQUSnUM9NEJVnCewRqVmDlp7bPNUdsvJdDPUpuKSDuR+lPUEhdUgpomDsFj/HDGY2obeK2IkplCTTWcC14hNk6j2QJpij60jPIHImYOQiVYlnCIQfoiQRmSOQaou01oD+HeAfh/kMtgZQ0PMG9N5ziKSDLB0AtwexDtmLkPagMQNZATIBo3WE2wZ7hDQPQfNtYNxCNqFB6zpm90WOdJfIrsFoBPpB6NWhrkK1DursEG1H4J3ZS0FkdPdcwyv2iHu3sH3+HM1ja3SkZPQaFKABRnztC7NX3008Zsy3BsbLoYxAizMUlN17c8EqE4nYVXS2MVEx0ChgkaGhYWDs2h2BQYECNgVsGtRJSOjQJ6GMikH2siK0gkRHkiAIUUgRKKjY+EgkCdDFpogJBLgE+IwYkWEjSBGESHQSMiI1RGQgpAQcsl33YYHc7VrWdp+TvZxjHvP180r7KIz30jHfeH7orj18+KErnNsY8PClFm87PHGjpzRmzOvO34gA+EZgT2eslKF4ENQj0J2HzVoNqTbAngFhkSzcS9LP8l7MwjbCV2BD0NkukrZCHDNGm4BNHda0AmwbWLFLXFIo1TM6NrgKmBqIUgKrkp0JEznXQC/70D4Pahmx8YeU0kuMCjeRnZ6H+Dg0jkB/iLX+LG4Glc4maVfgWxnUQiKgvD3ANp5hq3CKVvcHsPb9X8wvbxDbj+CXZ2DQYDZw2VwdEE8LGA1AL0JnE2mXaBke9fIAbb3IwjOznHAbdAgZijaiGCEbg9wrN7kMqoLoXyaLXIYNQXT4CNnF72LGn2RCVlDaVVYIOT/zKKODf0Ghs8JI6IRTDlnhGKQOZG1CY46QGEyF6zMuL15OUeWQCVL2UEPHICDa7TQLECic00JeqMfIhU+wV3yWVUenM/wOnHMTeFOfwGkvE0zXSdMmVCZAFKC/jJxfICldJLH3sLUtoDkP2z5Mt0FuIFZShLlBxi1wTYedCiMke1HxCTEJ2bE3iRdWob1CAgQZmClUGyNazhDhpogwJE2BwIVBCk0LYoEiI4pJhDqK6TYLSHUG4v15+XLtGEQSNv4UMomaBajhiNjchkhHZgMI2xBFoLTzAwlpU2k9R1EJUAqSnvUSbtAmm/gOUA6iDJ9iz7WrpJ6kdxpCCaUy+BKG50DvgWLD6LkynUiQCRNHFThvX2b9Lx0aw6PEX9xh4kCI13tt6ylmt8Tzazw+ZswbBUEe6opdnWctTnbVmk0U8iyfvWtplKBgYaJjY1BCI0BDwcREADoqFnUKFChRYJYFIlKgwxCTFI0YDQWJspvtjUlJSXYVoA1UyoSEQEBGjEURA5uAHiN6BEhSTCBFo7er+pzhqjKfb8rLcloJKRrKbtCrIYhRSHaLucel0X8dXmkf/dKYMWO+kVQdgx940yK/+4Vr/PZDV8YB8Jg3BG/YAJh1uO1WKDby6t4tE4pxhr93NwhORN53WalBoEHSQsY+Q12lwRQtuUpjCyY6oOwBkbloG2dR2yles8aliT5JTaK2YU+cobsZwgJnPSaMh7h3vRWyd4J7HevcC6h6l3pji8BSCGb2kNR+CJJTeLN7CNhirh1SViTLXbDsgEFpCb2d0LyasjPzFFx5P1FymijpkBTmQTZB22ElKKE0u6gFAf0OzFdyCx6tQzZRYMkJKb44yYHhJCYqHaExWBTIBQntdVCXdxWrR2gtn72O5MriLKF1B9BkQw2YTQKeFSPOTy8R3vKX0PNwnbfhdmahcg30DdTyJVQVInM/FEpQUAkObfPkKEYdqRi6yc3dmIOySBmDiIQKKY8YHV48sopq/Rf2WM/T9hzacg+sC9zFFjRb+EXIdA/SS2CegCSEQheiFSi/AD0B5QDCyyj160iRIv1pJnsvoE36rM2dgE6BUlhkliImGiUiAhR6zRY4K9AKSbDIgpDBZkZYk8iJLvbmCWJ3ElXZJPEM0CSIMqgjUqoEsoUVZGiKJN6ZhXUHFq38qF8poq15pJWA1ChCe4353nWyTGNrsokRDkikSzTUQO+gxDHzWx6OmVdMo4So859nmErS4CRZlLBS1mnGEVMuFAX0OjDhg1OGQRvMDHrSoGOtoSU28oyFequP8j1nWFo+z8JTCnZHo1hKXmEBfTmvVAg5LpQc861OHqyCgZ578CohutSwpIZCZdeLN93t0c3NjGpUKFCiQ0iZCvPMEyIBFR2TgAIRJi42Ljo+OstoZOikzJHtWh1leLsZYw2PbNfOCEw01F1NaJfCbllzAVCJUOhRJGYKnT3oRKSE+HRwCYmIUCP3ZVkslC5ChqgyfLlLWKAhdZVETRBBFSkiEB5kPq+sZzzmf+TV7JPjvXTM68H/cu8+/uNjSzx6pc0Lqz1OzpZv9JTGjHldecMGwFLPLXIrR6Dlwc0KaE/3eUp9kfMnWiiqTWpMguKCMgvFCWgcQJ/fpLM0wEoVQgl40B/AVBLSi0NGkQJBRmQJZFgjslJ2Zvp4PQVNS7E3oYjA9d8Gsok6+nP2XeyztM/EqMUEXhFbrJEEH8O3P0TWuIus1yFwLjA9TCg54LognYQeU9TsdXAE2dtfAnWC6+3vgVERlupgSIaz3w76BShosEcHR4edDJwmKAfJskdQRYVJGmgolPCRjgcND0YrCP8MsrgHKgfQlp9kx6oQ6HfkvsSHBqw9obFebNNRY+ThL2D0nyXiKIgZiPdBuIawr+AEPo4JbXsbGhZpfQFZSYiTC8RDg0DaPNLp83QAizszBLHHsDakN/MsSukR1HLI5coiqSxA4WhuEZTUgSNk+gUw6+CY0CyB1YBLFUDH2dkkCGtkhgNeh+bUFkFQYKCUEAxxRwKyEVrH4VhSoYJKCUlKwDW6+Hqw6++bInUbXcZkZLheQjy3SW3pLbR3pjCqK/mBiRqCUgK1BEmfMAmptIfsXdrhQuEBAlOFdg2mYrCWKBATd6/jNScgE5hexqwbM5VtMIhhZTKFeBst9NEGCfPAQIFhFwoKjJwQq/w4rhmDMSAMMrarOkNVsngpobiT63aNFsCu5W3n5YJP39VJM52dS3Wi5TbBB3rsfBAqw4jKcxP0ujHQfdXryeVrX5iNsxZjvpX5khOv9rLHLmTS2A0/9Zcfs1B287KCMhVsLEwMZqhiUAQK6Jgk6AwxCDGJMBjh7GaLVXxFR+bOSJCaIAWZaqAqoAgIhIHIJKpM0UVecK1mKmEmyaTEUoqI3Tz0SBikpKTECCUgFRGhapBIl0yGKMJByhRI8lumIuMMqeTCWiJLkULNU9qKQJEqQuY/8+XnjHnVvNI+CuO9dMzrw2zV5rtunuVPn1njww9e5ofevIer6232z8Kd+5uoyrgveMy3Fm/YADho5SqZrXWJ7MHmDPh3w6GVATv6iKlYcmmoER15FxQTcObh9PsJLy3TWFpCaYFahtYOqA6oCRR8SLQMvd0nahaJ9h3CvvoCbatMetwi6SZoVhd3YwY4CPoEottHliWaTOj1NWgauEmBon8Ff+6/QvEWiCuMyir6ZsI+By6GYJZSdpQmV6t1pNyESgxxGZ0+CSVkowwrs6jxAoZ3K8GREXLYBysGwwWzAqMhEQVidQ8KLgpFXDUGJYA0gQULeakEwgBtD/5cjB/NwtZxKD8OL/ToHElgPoD2AJwWyaaFUmmT+SWYSKGQITKHfXWfoAvtFUnF6DF0AqJyAk0NCi3oqWT7L+AqKecKc7BWh2ofistgN4mcOZAhbNuwFcBMG+2ZKWT8dtL9McTbUDgMwxLKs1MY16cJ60tM20O2hwmBomNUBwzCFNUfguyyUy6geCNgm9qGyawsEeOSkBLvytJkWh0SEHaC8AMKSsK6ZxObAZTOkWgB4vI+wkPPQ60AThEyDeIIdInAwNnMEAk45U2CxjoMLPASmCwynDqM0zmDooTYtqQS5oJVcQpVFdoDiTSG1FyY8aHnw7IFJQG6DmFbw5uq51nn8kH01iZSjbEMSZH8bzNYVTBXFLITCb3D4BwdUfvDAq1exjpgpgXC7QHpZZUsjRkqKdfEaytjjPjahY/ji7Yx38oYu4GvQEVDopJiy/LLfbkaKSaCIkUSAlRUZlgkJSIj4ShH8NBZQ2LRJMVkFZ0AiBEEVHDJC0fQCqBmoAXglyAzwBCg90EPQExBkkDig57midhI5J7xmczbYHaFuFAkkIISgxaCmoI1AekAsoBMjSCLIYsglchoQBqn+TiRIiOPL4X/UolRM9AzkwAVSQgMb9D/yN9OXmkfhfFeOub14yffeoA/fWaNvzizxV+c2dq99wrzNZtf/M5j3H9y5obOb8yYbyRv2AC4YkNrw4I/S8ky6DVilu4u8J72iMopjbXAQfEvws4xKM2ALcGZw7/tnXgX/gOVMMYugqaA5oI3gIIAR4WekIw8n2hjmdgqkZVSKAO2SYROpoSQhTAqkUSHGGgm9SBkWKojU4PMKTKiBd5FRNICN8Pfc4R1LrNHxMwkCWovpeP2SEtFprNlPLdFP55monWNjqET2CHV4d9lb2svBiWuBzts3boGdgxVE4IO9FxU7xoRARYqKhGusgrpMixHUIrAOAaleXCb4EyDa0IrAWUKdkZwoAXtuVzIyfPIGodgYQpcDa4koBwhE2U2xOdRKy3qkzFKDEIPMMVlQnEYlDtgLgZakNmg7cChdZAlSCsgT+Yeuq01iFKIu1CaJbn1Oso5BzZvgZ0ObBahGqAMq+zv19kMO1xv3kQmN5gprYOUuDG4SgXmFkhDBVkyMJ4+zv7+PlQSBBoRKlVs6orHummi+n2UgoIiHaqqT8eZpmmt0m3YBPM9Kqtvpj3/XC5mXTAgCkB6kBqIIKMvVTYmFwnVkzB6C6QG6DEoDtniJH5YpDTqUbDzswdfg7YDjgG1GGo7UMlgIYJVmf/oALBDKOgpfhwi1SbUFgj36FjrjxH7A9Z6BnNxhG6DLgTD/RBfF7ChUZAuTVJmCj69d3qcvzlj6osp1gBaQiHJXtvW8EoXZeOLtjHfinypR1fbNTHS0dGwUDEx0WHXkkgFbJTdztsSFjYVmkg0MhSukxLi4DPBFSYYotLGRdZMsqJOVlNJSyYUTfBSSAVQyL3aM6AfgGWBaeX+e8MMOinM1/KTsoS8NYQULHJ/8VAAcf4mhJMHwQZQ1cArQxjmOgVxnB/oJdMQdGG4DEEP0gAsD1IPohBkhpBqfhSg+ICKnhWI6e4Gw2NeiVezT4730jGvF9dao5e/ftfxSX7xnQu0Yp0PP3SVn/6DZ/jwB28dB8FjvmV4wwbAo72gLvvEcyDWVcptgaJmBE+CM5uxctggqqTQuwjyNFCDxEXuu5tg719Qu7JK5ENfByzQh7ldqyGhVTFJVQ2l7ZJMH4TZE5BtIZQvUusHkLbZEttABBOLBMMSfiFDzkzntdluQKbY0Aso6S+hd0q023+Xqyt3sjQSaP4KyjueJXJmKK1dxHIzpOEynHDZnC8j3QbC2Mfh1GE/FXpkqMNpxNMmm+UXoFyDDZfipYcoF7fphAk+LgkaIg1g0oCpZRg0Ie5BrwyKDjIBJ4OFdai8BPUEqMLWHuiHkO5B6R2CXpFsOoLDMUxIyKbYCd4Jg2XQ18BK0codhJ+ArcBgGsRWnsW0ARlBUgLbgqIGcQIyANWAgoTrU7nCU+MLZCdnoLUXsh6kT4EwSU4GXDEG1M7v49T197NlPMSEscamBK+oklQXQGlCsYxYqnLyyt0sSguVFJWYkJQIGEgB7RBZF2SKTlxZZDloAD5FP2GoLhPMn6N57TuIr7yPwfRDEK3nfr6KAKGgZgGjW6aI9R+CM7OwXczLy0nBG0I2RKgSEULPUJhRM0IDtgtlKkrIXBriCHAC0GIINQgjqBm5K1KtJOlFkjgDtDJUbyXQRoTyBXrvsGn+yQaHmhnmmzJGNej8eYXhTpFycRXHjNBTi1BXSHUNdzVl2UsxGiPmtma4+hrW0zgDPOaNhUAgURG7ty8VO6sv2xnlhc/5oyZgoVHEoUgRAwcFG4mNxKRHQoRJgkVHOAxVDc/KoGrkpSDTCtRMqFp5sJsAUgFDzRdeW8s/fAwBRR16MWgqTJm5f7iU+TglA0MBT4AHpBmoCuja7k3knn6+mgvwfSlzHMfQLYKr55nlTNv914BMze3bSHYdjFWkuvuamQJCBVSEFLtCWuPe4K/GOAM85kaRZpJf+8Q5blus8fRyl4cutvh/vXWOWxZr/J8/dDt///ee4p/++TnedXx6XA495luCN2wAHAxzBxolgvKBlK1Z0H2PM22oPZBwarTN+TsdQlZI+i0o7c9P3gslwjsPE4424EzKjhSkKuiKpBRAbEOjFeGoIcMQSJ6jU6yRzd6OHAak6dPUQ59tsYPMAtDLtO/ejxieB0sDV8DmGhR1hBOgtV3UboC68yBy5+0Uo7czJWOurH5qN6PpMJl8jqk0xYi3uX7qJjhzJ+aTDepJmYgOBSqUiGiOanxquUiUpIhgi+n563S9AkJvIDHREFRTk81NhWTfJTBOQt0AHLh+HYy1PBurtKC9nV/HNByYakEvQWTH2HPpEP20QO9qQHbYhck1mB5BpwqlAnRmQXNIvBCCFbDLoHiQprm31I7I+64dG4YNMC6CsBBX9mBfOYKmCtxJn7R6CZQ58AyQG6A9n/cAaynsrBDOuvQCwVuvLmJmk2yiYkUpMAHzp8FrQWeCuS/eyen4GAEjFPKLjzVGOFjEShv8TbK1m2HRBj8hZgoRXaLbglqyTlv7DEPnGAut2zi/vUF6qA0DLbdmSiPiyQUoHYKiBVUHziZwNAMjA5HAqI2ieoQWWL6kHcGOrZFqkiTOCBxIMqiUYWsHHAHaALareWWiSEELA2K7D6oPWgSaR1XvU/C7mEdgYwSjDPZkUJj18UcC9TAE3Qz/epmVh0x6N00x9+YrHP+Cx2DGpys7sP3q15PL195Mxp2AY751yPtnrd0AWEHFwkHfVWJWiVAJUChgU6RIiQYKDjYVZtCpkGGyQUZMhYgqW+iEQEJG19QJSzYcdqAaQDmFeQfqVh4E96K8JFmEIKuQmRAXIPVBRDDnQF+BDZkHwRpg7BrXqzqoRfCzXOG/H+UfhM0CVBJQBYQWCDvfXHQFSPOS6s/3YVPNs8LKHMQheBv54SNDiDZICQgJkaYJWUyUjEDTQehokU6KS4Z/A//v/mbzSvsojPfSMa8PT1zrsNr1+d9/4GZ+9RPneHa5x39+ZpNfWpxGUQQ//W0H+b4PP8oT1zrcdaBxo6c7ZsxfmzdsAJwczcWkbpqFZ2zB+TcZxC8qSBGR3JSiXISG6uGdCGktbcFxmZeYqTrJoe9nozWiqD+D5xZBeBh+BEF+uD7hSnwgKYLfS7AuPYUnmlCq07b3MTS3kBRyiV7LAf12ZOFK3tcVRDCKIQ6QAxUXjep2wnTlBTYmPMKLhwmChFLvs/ib70X33s3K6RjT2Caa0yF9M2xNEdYf4YlkhXt7HyDlOtcZUWUfYqMAi1tIbYnNgYEaq6SlBkELimTczmHWkot0VQHBAIpHwXBAjBBrzyB1FZw59EIX4QREhVnoXYO9O2hXS5STSSAlDXz6gUD/3AJGCbSugpr2CPUerjbKVaobDXD8/D1rddCSPFBWNqHqg7eSN1ZvH6H40m0ciYosEHB52OVMkiLR4ORZmCjlWWAOgHsVzXuetKoR3t1mtPWdLIQzXNZ0gpJGfGABkiqECfZTU5wYHqWKwMdGMOQiAVdFxpR0OZGZhGEDrh7B3dmLGg2oBjW6B6doHF+lsRLgT19jWH4RZbiP+tkZdg54iKKDrJ6C3hqUDRj5oJyFuAxpASojEC0IPIzhNvXtmKoLSl1yuV4gMk00RthajIzAB5ZcGJhQyOAAuZD3KICiAa1wxNJgC+msgRfB0EUokhkVJm4DdQceLxisZwkz94aoUyEFE1oC4pVNslSgn4c910I6S3VG22DYnde0niK+dl5nfNE25lsBfde3N+/2zf18JXI3a6dg7XrpKkiqKNSwmaRGkSZgEeHgYhFi0KdCnwJ9CmypOoktycqSuAyUY1jQoCmgosKslWeCq1keBGe7vRC6klfnaBZ4el4ZY9ngANUYtMpuhne3j1dKvsxJVlTzLG2q52bhpgKmCZ4PSQTFOvg+DENYFHmLh1OElgZuCj0DghKEPUTcB2GQqTKvHMoyoJCf1JHslkEreXAtx0HwV+KV9lEY76VjXh+2hwEAR6bL/PTbDvD3f+9p/ui5Lf7BuyPqRYsj06UvGzdmzN923rABcGkExk3QrcFK0ySxHWYfHlCvQlzNA4wdVWGgmhCugLcF8Xye4s0Okhx+H71iBBcCxHYH2MHMJIabCxiZWn7YroRg7PTwzHOwdwpZCQinTsOZcl5SXInAOgTJKcgug1lH0cAYRgTlScLSBH7jCpORj2IXCK0+rf3/jUpxQHS+wGy0QO/yT9A5HpN2FPh8DyqPQfUleonLs97jWMmjbJe2Od/8YeLONPSAap1Rcy90Kjg7BwGDKQxKpETVEWR1qOvQjcAvQ2YjsjJ0ziJLbeLqPojq0CljrTxDIiEd3kpfdDkopwhEm+GOT3O7SEkpUJI203KKIS7rxEyKlK3KCtduNckmXRAjSCXs9MFS8p4ytQabVdhQSNTz2GKeg7LBXLLA9bbLwOlDdxqqKUzdDGsb6AyYKfq0y6CXnuWJvQanzr0HT6kRHAOSkxA4qOf3cXL1LqalDpjYAJhs4THSJDPxNorsc8yb4IKWIuMyMtlLhsOtVyY4J65g7H8Ud99+xFUD6KF7dZRYR9iSVMyA1obuel7qPFiDWgmmD0Oc5SrRqoPpxWT9PJHdj4pEC6chG5CG12lbKf4oQxWSKQ0SVXBV0RgVY/YEUI1gcwf6cxn4PdAvg7uNiFzsAPQRWANYquUtf7MvSsoWvHgMDpK3722VbHp7I8y4S/CcQdTso7dt4r7OazHciPnaF27pa1ueY8b8jUO8LGn137/OA+D//riBBbt+vCWgikODMgYTxFiMUBii4WHQp0ELi7Yw6Ds6WRloSmgIqEiYFjCpQRWYUKEsoJSCJXYXWwqWzD/FbSWvPHFFXp6Mvite6ICi5AJXQZJnckUKqswbkwt2LijQl3mAbQMlCf0477UoitzaLU3zMmxTB83OFe8NIFVebvdgVMyFsRQB6SgPtoVOLlkNEnfXnEnPM9Uy45ULft9YvNI+CuO9dMzrw2TJAuDC1pD7jk1xbKbEuY0h/+6RJX7u/qNc2Bx+2bgxY/6284YNgO+owYVlkJMgzYQjl3twJMNoQ/zFvOK5NQENN2CQnSPsrkDlGFiTuYhR34XaKhQ+i+YMCEqg+aD7YKUwLOXtVvUqbA4kxEMIJ/PT75IBe1Rwr4PdgqgMhSZ0z0HiIVNJnFahtghqjaGakjmXUPwu9fl/g1X12JA/jlM4zmTU4PiWxdaOQ08d0cnqdOYHJPUBGPtpWUNM7UVEM8NIlqgN99K63CC79SjM29CaY6YzySQaOjrnRYzHMVg7AOoq9FUIPLCLZFP3gXYe7Ovwwu0gT6Cqf0GztcKm7pDxOH2nzqJb5oXmk2RTa2w0EjYKKbCIdekIyrDAgUxnr1R5S+8wL31+nYfLGyiqDmbCSA5JF7chXYE9B6BfhtoG/vFrPNZ/jNVLb+Jtw7u5tV/hkckdkpl+bjuUbqAZX6A26mKZMBmC30/o3/Qinzu0iGYXUAsmSWsPdKrMXd3LTbJBCQUVD4lghMfA7JPVz7ARfJzN6hC3cBdJ/w7kPCCWWHx8P6QzNC79MFeUOWS6QHl1DrAxkpisFcPsNGReforSXUXoIs8RdT8Hcxtw9l4Im3D02wj06ziFR1hzDFKjDvE0Qg5pxiOGCfQjFYOEUgKaJXFkTDLKNdSCNE8G1UbgjlYIwwDkNiK2KQ0kHQkH49zFyYgjihlkLpwI86pJ5Th0b+oz0KfQLw8xU5VR32QQzWMq1/OM0askIr+e/mqML9rG/G1G2w19YxFjomNKA0mGjo5NEYMQjRQLBxMVC41pyig0aDGNJCImY0SdLhp9dM6qDqkK0oyRb1XAVkExYMGGmg7zOkyqUALUbu7HnsYgfNCj/MPG2MqfE1qgmFAwoVoDsnyRV6w84A1H4Ll55rg2A/0uDAdgOnm2uJHlFm5ZAqPdEmtS6HTyILZowJEC+BZ0LSir0Eqh6MFOFXoOMjEh6kHYgjTKWzLKYb45pApptGuLJDMoVCEJIHRv2P/p30ReaR+F8V465vXhjn115ms2/8fnLvN//tDt/Ow7D/FTv/8M/+HRJX78Lfv48IOXWajb3LGvfqOnOmbMN4Q3bAD82GGB9kVJ9yWY9RJGaYmdtwuOfG5A1IZmB04/m+HOwPqhHda8s6CcgOkOcBBKU+B/F0wYoPwRKB30yMeKQZZBKeSH5moAUzbsjAYkvRbMVMCahQNF2OxDyQFCxOY6SssjnZ5DGg3SagaRC00X6cRYvkpDbrNVv5Vu9z1MXzrB3MikjERFZTpLaGRFprHg+r0MN47STDTqmcpZVWM4GvH26D42UPjs0CTYKgLHmNqe4M7MRkeQIAgQsN1ELLmI0RdQ1CWSuXvhGojVPfmF2sQUZD4svYAS9xA1QZpW0PoG+/0KfVoMSmFe6ksftqchG1IbSYbaOmcbj7PsX2TCvYmicgR1ZFNLbFIzwtUE7MxAuQj2CIoKjAyUvZepnbnM8p4Rf7nm8K7uHs55NlvOAlx1oLZBUqvhZ0NkN8LTVKSjkpQTmLtEUpyD546gndvLkW2TtwRzTKCS4RKQIIm4qA1YO34NaXyK0aCDkCbJlALNNlr1SSyxyVb97zC1M0lFOkxf+j5Kl3SibIhNSNcc4oz6cLmDt5jlkacygTa4Rjyho8geTnadUa8Kn78fLkXEJ+5ip75E1jUQRhfF+zx62CGOMkSkgK1DmDAs56LcR10I9bx8OSzC/gTcPqTtAJrbaEGI5QSUyPVrejH4EWh9QbwiWa1A+VmYOZQHz9qsRjixwPSzZxjoFtmoQbMSEe7x4YVXv55c8s7Ir8ZY9mbM30ZylWd2s725m68qtd38r7YrfqVg4WBjUMfExMbEQqFBSpmAAiMUPAy62Ax1DVfXSJwYWbDyA9GCyL3aLQOaeq7EXFJy0UE7y6Oi2M1Li8ly+yJL5m0jQuQZXUXkGVl6ICRoWZ71VWQeNGteHgDHLVBGYHogvLzyJk1zyySRgp7s2iKl+etKO8/i6hGoWq4YPSPBiCEyAAP0DNwRKNU8Q+xLEP1cL0LL8gxxGuW/UZGQ7xZa/lxixpngnFfaR2G8l455fVAVwS9+5zF++g+e4e//3lP85Fv3cbBhc7nt830ffpTrHY8Pf/DWsQDWmG8Z3rAB8DNTVYq3Jhz8jyMMVbL6fpPG2QFxFVxf5dLniqjlAdpRSaxFCPk4Ug1gax/IZXAOQFaC+ruIJ4/AsS+w6nySA59rEYawaSvoFYmrSIoeNLI+W8YiKPNgNMGIoFmDtRCmVpFVSLUqGHtgbgo2ngB1AEOdmr9GWaislN+H2HkPhy5Msyc0kSRItN2+NAsTKJJSpkAjckiJsQiZS99FlupM4SDpMu3qrF1rYq+pfFdvkeMoeET4xASil1/IRF2czecg6zOarOclxkGaC3UtncszDhMR8SBhc7SIkLdyovMmTmbHidiisXKYtaLMT/krESgOhU2bxFzDnbhENNxmdfpTxMlzmErGkl1HqhkwRFg1pHYHytkq2UIZvADxyDRDbR21dI2NYw/y9BN345dqYLtwMMg9gvVjeNsG2r7LuIP9u0rSGlROwFkd9cId3LtW4e3pJAoQMyIkxUSyQsyz032y+l8iri6TFlWo7QXFRs0+TT24ymSUcGH2UTZ7p9gXz9Jjg9XqMoOFEGfZJKqNsCw1z9Q4TdBrkBWIoy1wI7KsgNS30GYfJhkt5heTfousOY2SXqcadIkQuMYUNW8bp59hJBFOEbpm7mZSVEHt5O3imzqMBLgOSMtBKDq26mKMYF3NrznnFegUBDJVGBxIqRZAXYGVz4E+BVMzCdbOOUwlRDsRoPQHBDdlXOvlqq6vlohxADzmWw8FsFB21Y0VtF2bH1DRMNFQUBE4lChhM4mDSRmNEhGTuz2/DpsI+uhsYeGbJomjQCOEiQI0iuDEUFChbsKEDmUFioAd5YGmJkG4kG3lpc2qDrYBpHmUrsT5fhKrkI12S5wzGG3lJdAlM8/wihQCF0jATiDxcms5P8szwbuuBsjdDLChQiwg0fMAW3fAKOfK/BYwMkEz8rLs7S3Q7dzKDgnSzD/DIFeCTnd7jwW7ZdFanrXOEsYBcM4r7aMw3ku/lfie7/keHnzwQd75znfyx3/8xzd6Otx/coYPf/BWfu0T5/jAbz/+8v3X2x7/7P03jS2QxnxL8YYNgJt/2qd7usBLH3Q42Pc5arQZLuSVZo3PWPRCm7jjM+tHyCUI4zb9A5cgcEDpQrAK0/fAQIA/BeH7GBzJWL32x8xdi0ilSlcpIipDCiSYZpwrAzs6pGXYNqGWQDWBbRWM47nXsFGAnR0IY9RkiDFIqJkp6+Gbyfrv5uCVJtW0QICOg6S4K8hik5GSIdCw8MlzuhkhAhOdAI0RAQs4vEMKzrSLLGJylAI2MSoCnQRTDZDzQ1j2SUoqjpaBmsAkyGIXbfkvUa6tEysmihOSigWsze/j1v5ejqYLqOjozFL2QtTnTmGh0lZ6FITNMElojiqMNo8TlG1UtQX0kYGSl1rbJbAzZBZTvgonhtM87/Xw5m3U5e9Ajm4nUdYxVcm1hoF7exd2ItiugbcIJz3SYkqXCGE7iMI2mXIKLlTQnjzBTRszvCUrYGBgAG0CTApEjDivJfQPbyHTETSnQW3A0hyGfJxSc42sLrmaFBCdGtsyJtbPsrz3adKJDvhV3OocLJwhzlIQGWydgZm3oA+uYkUeQ2caFAPfL1J2lvCK/4FYRuhLLqnMkGWNgbQxlQCZ6PRNEysOkVc0qnMpig6eCRdVOFaE8gCCECpF6JUgMxyktBhqAqFEVMt9FqM8EHY1SXYgZX2fQvn5DFXCaGSx3i1QPdBmftGlfUzj4EsZK0cm2SoXmBteZvk1rKdxADzmWxMFBZuIhJQECw11t5O1ShEVgSRkkgp16jTZT4xNiMEOGkNsepTYpo6rCtxCRjZVgKoNExo0gHoGpXLe83tEgKnuBrAuFDwww/yAT1PBmQW3BSIGNEi6+eKShTzTq/sg3Vwcy1Rz7QrFAHMRkk7uBSzKYO5mejsxKCkUE4j9/NRMr+VlI0kCpbncBincgdjKS5tskWenFQWYgGsuZAEc25s/zwthvZjrOGQToPVzhWpiiLTcU1iI3IJBz/JSlXH8C4wD4DcaP/uzP8uP//iP89GPfvRGT+Vl7j85w7uOT/P41RZX1lv8u8c3WWp7XG2N2xXGfGvxhg2A+2eK7Lua0PoJOPP2eZR2QqbWqU4tU/ngkJ1+icKmgZFFhC/Bwgsx3r1bxJNn8w/z2b0gi2AtguKA74D6HfQOPstk+xyTaUyYDIhNiVIEOwCBjSyVwC3BQAXXBGeQX7goKjiTEFho7nmqo35u3xhAaqoExSPUli3qaQWBjo2DhkS+3DWkoZBRJKWJShOBT0SGikLMEI82UKHETUwxS4xFRkZMDRMfl0lslGwEpUtwYJuwe5J4fgkaeyGsQlkh3XBIzUOIXkLWzCit38X3dm7jJhZYxkcQcZ01IrHG8fQwQ1S0tMbtzLLBFR6eWqXQO4LRPsqgHCMnLhK0HOS8B/MtYAqim6j7TbatNuFgHeKA6JYRyDp400RZjWx6AEMPvrgXEYAUaT7vkod9eYvJ4jU6iclw2US9vIc7WhO8TxapYRACPUboCGDICgGX5kdQPA/PVzG7VUrJAbrWgyhT6ySGxEunqJx9L8dad/JiaZ1rJx4A1iCMEINZ7I09eDNu7i9suHmGpP8USaSTjgzUekJavZksWiLqXmNiZ5kNp4JRD5GBxJuaIUmHGNJHKG1UJSCaUMFR8ZU8wWMluTXySAGnlGvVdCxo6yAtO1dsjStIN0ArDEnijB0HvEzD2cmYHGY0NUh3BO5wGtXxcNagMYKlew7wzHGVrF5j4ulzlJ97bVekCXli56sxvr4d87eN3L1WkpHtdgAr6LtuvxoGJir6biF0kSI2JRKKBJh46GyTMURjJExGRZPIhKyUwpQCFfIsb13L+3zLCkwANXLVZJnmNkdKkJcvR8MvTWg3O7tr2ibSPNMrvqTMmgCjfGC2W5qsJsAgDzi1LP+5Is17cQ0V0iRvadF2hbGI87FqnB/mqQnoYZ7FlTEQ5c/L9LxX2dXzINpUwFXzQ+HABL8AfgMSmQfWUZTbLEll9z2w+x6UsSDWLq+0j8L4t/StxLd927fx4IMP3uhp/BVURfDm/Q0OVWCqUeXv/94zfPTRJX7i3v3UC8aNnt6YMd8Q3rABsFqEpGXQfK5PWVnHeF7iHo9ZPn0nvUMbiOII+1yPNTevECteBbkdUn36IsGsRmD4uSBIswPdCSjsg/5essIevD3n8HsQT+hIXzJMTIq9IWayTbCvmpedJQH069Cu51ZAcR2iScTaExR3BmQ6OCHMuHBpwUbvVNk/rGCjkAE6BoKEERYmAhMXFRVBSkhCB5ciBg08/lS9xpniJjKzedvwFOyW9HUJKBHjAQkxc5SI5AZ0VmHqKtK+hVS+CYIyTNXQPjFk8dI7mUhdqlmNtKMzkRzk7czjk1LB55JY5qHp38OvlvFWhzhDG0QTD8FBOcnlQZvVRoyISky2igzdY3iVbdT+FqK1h0ym4Du0rDbugoHcXIfza3lv3FwHmg2ymgFPDWDYpLZtYWVDdmZDErMD12fIZJWtoUPo2hjri7y51eDdOBzAxiUmJEMjRZCyzYCnLI/B0c/RbH+STEkIC3ezf2MfL5Y/TWoZVK0Q/8IdnGp9F0Njlf7JL8BUAP4CtJdQAh8hhiCGQAZWHSIP9AC5cAxvc4BQMvA3IE7xdI106v/H3p9HW3bV973oZ65+77X707fV91XqVQIJIQHCNAbDdWwTGxtie+Cb2Iw8o+QlJvEjzx5+JnkmDr4MHgq5gHOxHRNfG9sxjY2waISE+lL1/en7s/tm9Wu+P+aWMCCQSoAllc53jD3q7LVXt9epNc/8ru/v9/2aSFGis+M2SguPcqB3mXk0EhtkLoc0AjKLEXkzooYSgaw2LAwL4iWJVlCteLYLnmtBtgTGkCqjFHk6tS5tzUBmesQtmDqzyfRZi/bNIboLmbRBLt8mvmQxaUqSwmUGchA+KFlejEndK7uffF2JOt8LUrLl3rKFlxRs1EgZ4ZElh4ODho6JhYlNBoGLRZkSZYYwKVMlSxebDgZn8ehpFpHuqkijYl85nU775lASJnOwrQSlOuRScKV6sJeGoIcqE110ob0ElgRbQDcE3e6XI0vVq2s0lVIbWSAbkBiqdzefAVKIl5QjtGkAHeVE7wsoDSq351YDMoPqQWzcVhbyVqLKqbUY7EipxkmslF3bVPFKjlBO0tMWLARQN6CaBauhHvKuF6CTAWqKeFuWyiQONtS+4hiEofh8Gr1gv+sXC55tHIWtsfS5YGlpiX/7b/8tX/jCF+j1euzevZtPfepT3HTTTT+U/X/ta1/j937v93jsscdYWVnhs5/9LG9/+9u/a72PfvSj/N7v/R6rq6tce+21fOQjH+Ho0aM/lHP4x8Lr9g9zZKLIiaUmH//aZX7jTftf6FPawhZ+KHjZEuD9bovEEMxNSYb/V4K5qrG3uMHKVAuZ1dn/+CzuIrRtVWoqB8CIJEKTGBFQHEAsnsA9+3XieQgPHSbN/SZJdy8L6X2kFUiFAOlAPkd0vsfAxhpLm3VlF50twJwDRHCoqFyi/R52dZEpPeKir9PsJVQCMOY0diwOMJTk8bDQyaEhiPHRsQCBxEUQEBMT4aETsMkGXyw8xompR9AyFwl6e/i7lYTzjYNUJPSIGCdmjpAMMRUyVLQQoQXITgkGN2F5JwQGrD1MatQpsY+fjF/PdgZJQxuXAhYaF1inCzzgfo3O8AUoDrKiLaJ1RsANWQh13OY2Xr9xIzd7ebqkPGiBJW0mamNkkyl6pLSArtlAszPkF6EnKsSVdfC64FWhe1BF/oyeQ9QsOiMWnhEQH6ghZqaxLm0jmMqhuVWKczmuaR3k7YwyBGhE6CRYpOiEeMScFx0u7JhB6g9SlcNYUxtE0RqztR5WVMEYucx6PIqeOUKE5Fz5b5GDFyEqQtuHuEziSLrjCWgOdBfB3QldCZsdyF1SE9REoHmnSI08FCFI8pDLQvQKWt5OBsWnqIguS0UHHOg6BdKxGn4HWBFUyTLV7JI3JbUh8HMauVBQTBJkYILfhDSrzqtQwJv4ZyDGIa6jf+leOo88wGZ7N96D8wxtb5GYPbRMQnP+IIM0KH1zgeK1cLqp017TKOWvrNAuNbYI8BauDgjoRx2BjoaNQwYHExuBwMYgg844o2TIYzNAzCihanahCqwT42VLxFlHlWpMC5UJnnNhm1QKcNxv0h8PVLlyVkA+hWKqMngb6xD0IAjAzalsPcdUBDIKFIlMMxCLft+u3y8rziqCG/pgWopgUlb7SkPIuIq8CgFeXfXmmq6SFtMU0MG2FAGvL4KwQXfAMNTnUUMZWRmWeuCmm6DrUJb9Np9UlWrXPZCbUBxQpc8NH7y26kGOMuoKC6HyjBPQUkFKzMu5yPfZxlHYGkufDfV6ndtuu43XvOY1fOELX2BoaIgLFy5QLpefcf1vfOMbHD16FNM0v2356dOnGRgYYGRk5Lu26Xa7XHvttfzSL/0SP/mTP/mM+/3MZz7D3XffzT333MMtt9zChz/8Yd7whjdw7tw5hoeHf/Av+o8EIQS/ftcefvm/P8r/9eAs77l9BwM5+4U+rS1s4QfGy5YAH7gR5nqSuCxw1yWddR3vEcGO6ceYyQkuWEVywx6HzoV0VlVO62gtQWRgZb8BE9ehN88xNrPKxpwkGO2AHcLGdkTdRg4XwW+rMmlrAj+ukks6iOp55NirYK0A5x0o+CoCyYogWMHv3sHp+b0k43Vc8wFCI0ALHMrJCC5gkUHg4ZLBwCIgQiKwCVmhiU2PVTbpaAlnxy6zOP0gYmkDywd2ebQHNzh9fAWj4zIcR9hIvu6eoRSbXBPsJtZSVaYtm6A1YaIA8jjamUdJqwMcu84gPpPhp1qHmGKUIjYNHNaRHGeOxcocDg2ChoNkEMbOkuluYEWSQJynxU6OyAn+zqgRZFu8tjFNRWYJ8EmJ6ZCSjYqM1weAgIe1G3m455A6JyHdjpapk6YbYC8hb4XI3Umkd0CPkY3D6JQYWMizJ9nBrelO9jFAHouYmCYJMSE9IlbocZI2xwsrhNtPgL5CqmUJwhTZitnIzsBoiLaaIXEEA80sEVW8ypMq6gNNEdtcFrAg3kT4C0grC7kJ0NfAb4ETKfMZJ0Zmd4N7WGURbZyBIALnSVLxOub8V+GO3kuSL4GRRfptvMRmWzsgsUw6xTJx3MVtq7bxapIy5YMRwXqhRy/sgqhCHPUzOIdU7vDQDuTAA3QGYwa8NXrTIa0bNba3YoINnWY0wBQO9doqnaUI0U7IKU+1K8JzIsDB87pVt9DHlagJp06d4gMf+ACPPfYYc3Nz/Jf/8l/49V//9R9ony8PCJQ9k+QpKqyj992eTTTARMdCo0gBmxIJZXxyhDi00GgIQV3TiN0ssmBCWahXUYOipfp+iyieVwLcWJUbG1KVHFuhig+wPEV001iZS5kWGKYinEECoQepan8hBdJErZvY/Z/7GWgYIE1FmlIJaKqcWRNKNRZSEd5EqO+soQitJkB6ShXW6Ls3p4ooi0gpw6YHVqrKoQtCzSgMDWRWbdfywPOVgWKYV+cVx4pUCwl6otyhNYnQBSJNkVLyci30fc4EeGss/Z74T//pPzE1NcWnPvWpp5ft2LHjGddN05Rf+7VfY8+ePfzpn/4puq5CqM6dO8drX/ta7r77bv7Nv/k337Xdm970Jt70pjd93/P4/d//fd7znvfwi7/4iwDcc889fO5zn+OTn/wkv/Ebv/F8v97T552mP9oHRWn/XkzTlDv3Dj6tAv/Xr13iN974/VXgf7jtlRzn+azzvT57puXfuez7vf/HvL4/ym1fyOv7TMt+1Nf4Svb5siXAXhtuHIa0KdE7sJAKmLWZ+Nsua9sdGndMUli6hLYk6JgQFSTmkiAdl5gzHpltX6JljDM/sR83mENOTYE+DM1h9O4klj+Pp5lobBJ3DZKJhNXiNmT5f4N798I5E1H1kaVU1VhXLOgNQ3gzhueQGk9QG6vTCpexF17FToaJCdEIyKBjYWGSIACfLvdZq6xlEqS+gT/QJi2fI93xEFweh8234U9GysArrJCMGiTz0Elg3mxSP7yJt1Tg9GKPbGoiPBNpZ1S/l9TAiUm1PVAaJDUdTkwssRFleU0Q8ea0wjodIgxaRpN0JE+a5qEdIJx5DL+NFgp6moWWDpGQ5TRNurHJK+p5juLSo84Z2tT1hFnToxhpdITLhr3BstNEJha4r2T8dIDbC7kw1QB3AipZKC7BcAzdQ7AR4Y+ssX01z5vTXRykgoGD3zcHC1F9Z5fo8Peix8Vcg2DvPGQXQB+EnIlsRVCxEOJJzOACmhYS9nzKHQ0vUyeeyMLCBgyEYE+B01H938LHDJpEo+PIOIa0CSM3Qy6ARoTMFKD8CvAmIG4pNai9BNkZ2HGOqHUd3fCbmO0qiVnH7sRkg5RAg8SOoF1lPc1wsOVhSGjtgVlHCUtJU2KFG0TlGGmZyi7aBggh8kn3b6MmtxOeb9O+7RZyAxfJ5paofkFQal5kNR7Gb5Vgrsa4k7AaGfi1lCtRYmRG/Vf5nkhRGR9beF64UjWh1+uxc+dOfvqnf5r3ve99P5R9vhygYWECGWJidBIEcb/pxMQhi8ABMmgMMoSkzCpFVhHUibiEjWcOEGZKsF2HcgoDMYzqigRvQ/X65vpk0ZRADOkK+FIppXIVjAAKEnQLMKHVd9THV2qtjlJaw3qf5FaU6huk0FtUCq9pqvJkAN8DMoqcaiglV0ql6lo6uChFmlQ9VfMFRAYUCmD2Lei9FUWkjaIi4kID6mBp6v3AODQ12JRge8qy3p6Ey6lqbk2GlFO1Y0I3hlRThF3aoOskuVjVAEcJRL1/zF/7iwbPOo7C1lj6LPjrv/5r3vCGN/DTP/3TfPWrX2ViYoJf/dVf5T3vec93ratpGp///Od59atfzbve9S4+/elPMzMzw2tf+1re/va3PyP5fS4Iw5DHHnuM97///d92rLvuuosHH3zwivf30Y9+lI9+9KMkiZL+6/X68zqvK4GUkkajASgV+JeOjvC+zzb5vx6Y458cKlHJms952ys5zpWu870+e6bl37nsO9/HcUwcx9RqNQzjR0uPruQa/SDbvpDX95mW/aivcbvdfs7rvmwJ8KntkJuC61qwNgFdP6IxEtDegGhbgrWxyMDfRQSLo2SKAY0jNYYcSG2Ynof8fVW6k21OH3w1tfEjkNSV46Z9CD/6Z5j+H6NlaqQDI2BO0dV3gH4nPHgYnshh1XuYIqAbN6AUwfgibEB2Zg+5UKCffgWNok1ozTFa208Whyw2NgYJBoIuPSISejxQXGNxzyIyuwn6JgyeV1k5y3shmEbesAE7Q6iNw6UM1LNQalEfqlGf2oTKBmGSYXGpyUQ8jBlMEu5AOYs2cnDmNuhEEFVhIUZbr7BauchfGQ8Sz2fIykFO0WOeFJmOEzqHlcphWUT1lKTnoAU9nOY1ZJmmrgWQNhhmmFVCLtGkiuBkxSPQQuYnJCfGZpHRRfA6UPAg3EdbOLQND0YSNbEMOlAsQWsILnoQPUG6Q6cV7md0fWe/h8/AQKNBgEXCWVr8hd5jeXgdufsk5J6EKAe+Be0QbBPhLJKJO8SeJO0ZGO29jAUDzJZWoTyOaK4jixoU8hA0EBsaVmeF8u6IDX8VKSJSxoFBpaRmPaUCL2ThognXLEO7DrZUk16nDtkd6EtFsqtNQqEyfwcMWE4FzYyuFJKMhjMIbQn+EhSXIRoAbUrHLxhoSR3L9PFHdiHbl6Eewvh+KO0juV7QPFLHfuIEO762RiMH+rRkfGmDpbpAtfxKUs/Clza7Cm3ObVzBDWWxZQP9I8SVqgk333wzN998M8D3VBt+lArFSxUGKQJJTIrA7mf8CiwSDCIssrgUKFGii0WCRoxBk5gaGp6ZJy7ZStmttKFiwogD4yaUTOX8nEf117KhCKFuqB5bmfSjgmJlKqWnSj2NUtAKkHRVNnxW9E2nspBE6t7SQ6XY6kCuoMqiI12RWl2qV5oAUkXYaf1mU61vnhWZqjRZxN/q9U1SCFNAU4Ra1xVhlx1FWlMBfgNEEYQL/irgQM6BSFMEuxfBUF45WLcDtTyy1f4DAV5PfX+JUqDTtK9Sv0zxbOMobI2lz4LLly/zsY99jLvvvpt/9+/+HY888gj/8l/+SyzL4t3vfvd3rT8+Ps7f//3fc/vtt/NzP/dzPPjgg9x111187GMfe97nsLm5SZIk31U+PTIywtmzZ59+f9ddd/Hkk0/S7XaZnJzkz/7sz3jlK1/5Xfv7tV/7NX7t136NVqtFsVikXC4zMDDwvM/vueApJa1SqaBpGj9RqfCpR9Y4vtjkz082vm8v8HdueyXHudJ1vtdnz7T8O5d95/soijAMg0ql8l0l8T9sXMk1+kG2fSGv7zMt+1Ff4yvZ58uWAG9L4MEK7E+g9xpId6Xk2rDWgHw7wvnvEdb8BGsyJttI0Fch3CuJpRILPQmZxZCKeJSNsdtULnDdgLyA4PVEhRvAWIP5GIIsuA4slMDLgJ1ikWBLQc+sIt1FxNyXIN1PIbkZkyzDSZbB2hFqjDJKhgJW389Zo4vAIUCnxVl9mcXxJWT+cdAvqAlNMgLadWBOqRLcwy5QBbEMpgOLKWw6MLYJ1oNoM+dIdjnMX6yyo7ENZz0lLAqYGiZ3pkAUegTDDcTyEaRVJ5l8EjhGd2SYz3fOsLN6DZIOVpyn8EQZ372J+JBAr9sMXxoml5iUZY4z+jJ/N/AEkaMxsuYyG1e4xAbLooEhO+zZMJkdatIaa6LPrCKrHVJnEpJNsOtYUQ49cmknvpqMtTUyx8tsO1/kUmGJaHAWrZqys7GTAnpfw1HldAkJTTp8ydxkaUcXtl2GwVUITSCAKKsyMN0dEG/SizJY2QaRtpPi6k+QaAYb0x74o0j9FZDJqX460SVfdcjqAWlRQhBT9peoVR3kcgFeZYE2DzroD46TZiUynSdXf4Re9hrS0der3GWzTuinpAEITHQvRZgJOVuS12IaVkxFwvg+mF/Tsc+k1CJBWNfIjcX4wkTUoPxEiDF1ltQ+hxbrLLz6zci920CPMY4fp/TXp4nXE9ijBJvUCqhMLLK2UqQVQDYyMGyfC1f6gHmLAP/I8MNWE57vPoMgIAi+VXvZarWe17FfrFAFzyrxNwEsNEwMbAQGEp0EE5MsRQqM0cMiQidAp01CSxOEtgtFA4ZSKHpK9R001atgqDJhG9BSSBug9UuarRhkrJySZaw+J1EGVX6sYpLSWBFgO6PUV8NR/4pUlSTrhlJ0jTz4QCD7qm6/rFlKdR+Ger+cWldRRrKf8xtEIEJFlpM+EY1S1eqRxoo0G6nqNQaIJMQddUzNgMAHXHAkOFlVcp1NoOyCMCHbUMQ8NiHpKTOvqK4inlL6cUgR3+oNfhkS4S0C/AMjTVNuuukmfvd3fxeA66+/npMnT3LPPfc8IwEGmJ6e5tOf/jR33HEHO3fu5BOf+MQVq3LPB/fee+/z2k7TtCsmTc8HQohvO9b77trLL/7hI3z6m/P8yh27GPw+vcDfue2VHOdK1/lenz3T8u9c9g/fa5p2Ref9g+IHOdZL5fp+57If9TW+kn2+bAnw3ouw/hpYuwSJC/E1quVq0a/gnI+YmN3OptjElA5JGpILBAtDWYyMTj5tUQs0/FyWfKvH9OoDzE/+KqyOqD/guglroxDk1R/xVga8voHIaBvaarLVsULkyCWoPkalfpGkVUPKNzPMIBkkFhoF8lQwEegY2PjEpIRYeFxindOlKlI8CSyrp/MFV2Xl6IvgeGANQ9aGtABpDuINyIRoG4Okmg0DFoIU4hWe2H0/l2YTOrmbwRpDW0vZX81AmmWmY1Mrr6kSvlIK5gRUpugYi1w+1WWwOYIRwmg6wb52mfmHVrkoTBpaDkNarOkJnmsTFiXlFZMj8TDz+mnO7r6EZd+P7rVpdl0603tg+SCZmYNocZvW9jUomBBn6RUKhEMSig5UE7iQI+/tBNkjKVwC08Nu7ea28EZcsihGGxChscQqpwk4M9qAw6vgLkEyAcUJ5cqdutCtAo8hO0XIOMhuQGntFg52t/H4vpP4+8+q8mXdVoY0nS4k41iJS21SID2TRNo0kgxy2oUlDc4NwDWT6Oc1KvMTbLzmOIgKXu4aaMxD0IDedgjPYXlt3FSjNnQDSyasR5fRkx7brC71AajpFt+Is6zvehVW7wSpt4jnQzo8gCZ0Bk/UcC7vwFpcxI1zhDmPhf11uPY6QEczQlwjxSkoz7XsWcFm16BiRdh6jz2Jhn1dj8aaxsKCzhU5rZj0I1S+B7ZMW543nqua8KPe5wc/+EF+67d+63kd78UOsx9xpDpkdQwMXMBEYDGAhobApMAQFnlCTKoUaeKwjM6aGKaXzcC1JSiFUIhhogzDDkw6YHRUj2+qqbxdLVCGVaKt+n+1DNADuwpdQxFF+iQ3J0EuKcU3OwlxV2XttiPI5VRZc9AFvQiGq45hRZD3Ic4oEqyloOVUCXMQKQMrwwZ9h+rFRSryqwWqRDnuqaiifKrIaALoLuoHT7k5mwIS2fcdaINW7pcvN0B0wHUhP6YcpbUAypH6O+i7oI8qZ39Th+pFiLrq76Nl949vKROvyP9ev7KrE882jsLWWPosGBsb4+DBg9+27MCBA/z5n//599xmbW2NX/mVX+Gtb30rjzzyCO973/v4yEc+8rzPYXBwEF3XWVtb+67jjI6OPu/9vtC4c98Q106VeHKhwX/96iX+/Y8ffPaNtrCFFyletgR4YxG0U6qVU8zB5iFo58AuCnpHdrNWnyHbatGcr5C3mtQnLIxpQbu4l6DYJOxuAw4TLV/i2ke+wObm/fQyr4FqQUVNGBo0qsqsIu5CkldOWq0YEQfYWEQihF6Vgn+cwrpHt7BBYH8T6e2lSYsJBhnAoUuCwCFEYCFoiFXud1qs5OYJRx6AkRUo99STfL8Nq0tg7VaKb6kH5gg0pcpmFAaUBFpWx1kdo1d6BYldATsmycxRP6CB+CZoezAfH6KddohFhlT4iK6HdDzl6ukOQHMJigt0bq/QmVshe7HE25qHuAadDZmhgkAmOgUizpQbuH7IoZlhpLSQNIlkil0PMbQKnmuTjjSR1jIMuXSmPOjkVKmgiCDK4rlA24CzgG3DXpP17EnWvVHwdoHvMrV0I9McREcDNBJCzlDj/9aWuejW6I3HYFTBqKgSvpoJaREcH6xBCHZCEINRobBxGzfVX8HFwXP0buxCbKuJX7EOQQ6cPKyVqWcskp0jEKdQHCWReRgvwbYh2ByB4xkqjw1g6B7ka5A0SEZuA72Mce5viMd/EoomLNtMrDVxwrN4WYNWSSfrSsKcSTd7mMS/gaZRAPMW/H3nwf8aoYjg4D4qX/sbchdc4kRgeYKQgGwYYHQ3iUwL4g7hriK1owbFbsTYBViswUgISQbW3hRycgCKozCykbLtEpy77wpuKJctAnyV4/3vfz9333330+9brRZTU1Mv4Bn9sCExkH0CbKEh0TEwMcnhkiWLQx6JQw9BA5c6DnUswpyDLFpQQD0gLCaQt5QaXLFUzq0e9YloT5Usm5HKxcXqlyMLRSrDVGXnpjFIAxCKPMtY9QGnqHHc0VUOmqar3uHIVuRXoEymbEeN+bLf96vZyvwqa6iS5iRRyi2xyhrWdeXCVAvV3zBHU8TU0JS6rMl/UBbde/qaoUtFosNAKcqapnKGMVTrh6tDnIVtI7DmQ9VX+8UELQt6pp9PHCsSLiNI/L4j9csMzzaOwtZY+iy47bbbOHfu3LctO3/+PNu2bXvG9Tc3N3nd617HgQMH+LM/+zPOnz/PnXfeiW3bfOhDH3pe52BZFjfeeCNf/vKXn45HStOUL3/5y7z3ve99Xvt8MeApR+hf/NQjfPqbc/zKq3cxlN9yhN7CSxMvWwLsB7BWg6WOxvQjKfombNsDhUyNi57P0DU9FpcFzeGITd1FXFMhnjoM7CF09yoHzG98lTDwmW+5TMwf48KRGdB2KPfNuAnWRSisgtuANQs2K+BOYGw4mBrEu+YRxRqjNZ+gJNgYz2CsnmXDW6NOD0FMmSEsdCDEwmDOnOeh7ffSG72MYR9HczxSZxACDaQFbYFRrxMPC0iGoWGC1lKToc0OZHrglIh3RpSOD2JdGqIxGUGnDa1jUDoEy+tQPkRe6kiKLNinCbevol82EGcTpFyGMQ/sFogSVDeg26O3c4YvbNRZWTzENIP4huDs0BLmWolrN13adDGAZaPHeUNikVCu76cQH2JmoIM35EFaIn8mIhOex8+t0J5wkONCTfZOdpQhS2VWlQzGGdUzN7AfGjrW8mGmw9uxsBAIDGKadPm8Ncex3TPIQhXGXdV723SU+mJE0HNh1VSlgca1FC9GHGruoJQ6nMgts3D9AmR8qDqg51WepmZAewAuWySuhOw0yD1gDKjJrp2FpUFoC7S5LIONaVaHLoF7HDpVSC5C20XbTDGMLxAfupWKE+FmYGNEmcYYqYfXHmDOu51k5a2qV1kPIO9C4UbYdRP4G2BlEek3cGUVvzyD5saEqxqyFCFjHxo1RGOGHQtPsDsTUZTQXoeyJokLEaeuhdVbbLpWmdRdJ9dIOfjMc4XvDZPvP5rEz+cu3QL8aNSE57NP27ax7atzsiORSNK+ACcw+qOujomNQYUKJcro5Ohh0EZjnRwNstQxoWTDoKEijAZS5VFQAio6DDmKNMpAZeHqPTXuZFMVkycd1A2vq8qSIFFkMGmrFo3UgIKuopGiUIXY66ZylDYLgAlxovpt/eRbJchOSZlKoal9iz5ZtRNFVsOw34McAA2lxnoGrDZhOg+urf5m6KJPgBMIY1WSnfTU/pKMUpINVA+xpquSaAx1XNmCXBHsooqAElVVadPa6FseZ8HMq1JuGamHxXGqzk++DAeNZxtHYWssfRa8733v49Zbb+V3f/d3+Zmf+RkefvhhPv7xj/Pxj3/8u9ZN05Q3velNbNu2jc985jMYhsHBgwf50pe+xGtf+1omJiae0USw0+lw8eLFp9/PzMxw7NgxKpUK09PTANx99928+93v5qabbuLo0aN8+MMfptvtPu258FLFnXuHuG6qxLG+Cvybb9lSgbfw0sTLlgBLDfKnoC0kazWb0bGA+ROw25QUvS5OANaGJH+4SWzBcrfL+db1oN8LCw+jPb6Ec3EBPZZEYwJXmIpcBgn0JPgNsvN/gGYv0BmwsOKIcsFnw9+N1fox6sPbiA88Ad055sYsYj2LseQRJzoShxEkCZI8Fk/oSzw5fgLTPkPsPkDsrqG5EJujqr/YyoFrQupB6BIX9sJSCs0SZDSohFA9BX4VWkUYLcOuFlXzIgOPXkd+Zpi2WwD2gLQorgzhrQ+S8UxCzcWOj5A0N0nKm/1J0hmoW5DvO4FqKPWitUzblKRcx4zlc2o6ZsAPOJiaNOhxRlvivN2AigNumd5ARCPRWA4r2HOTTD+eYydtfjxMKLOLVTT+S+cY1dY8uD1wm6oceq0NYU8d09EgeQSzNcWNzcP8OCVG0HDwCQi5SI0nJy8h91VBz6q4DplRpmVYIOqqdHx1EhoeTAiccALfcvn6ttO0yzH0ZlUvN5NqUhqhSs1rAlaLUPGgUQSRg6SiMj2lBgsmNCSpVaarh+hJit6pYy3NIsQcfmEPFEsMeRdYbUa0zIRjew/gjd8OIgNOAJsH4PRuQIAdqN+lbyozGYqQT2CmjvQTsgMBFQP0CchVoTYsSKdL4IO9fonrkoixFvTOKB+bng31HOhrOlyEkuNz4HyKe0yHwhXKDBbffzT50bfTXLX4UagJV6tCcaUQCDLYKFk1IcFEx8QAbEwcbEo4uNhYOCSU6WCyjMWK5eAXbJi2FNEtCphOoJiBUg6O5CETgbEM0YZ6aJrpq8FEINv9PloBjgEdH9bbSjE1USpv8lTMmlBRSNmsIrsINca0Ue8jIHIVqewEQBmcUQir/VydHPTqilSWR5VK6wBpXcUQSV05PTs6DOchsqAm1ZNiP4JWADlL9RvnU0WwpYCqpsqxk1C5Rlsm5Ez1PtXVWOh4Ksu4kSo1XBuGXAzdFnQysNhUgrK3powNAx8sp9/bnILnvXz6gZ9tHIWtsfRZcPPNN/PZz36W97///fz2b/82O3bs4MMf/jDvfOc7v2tdTdP43d/9XW6//XYsy3p6+bXXXsu9997L0NDQMx7j0Ucf5TWvec3T75+qjHn3u9/NH/7hHwLwjne8g42NDT7wgQ+wurrKddddxxe/+MVnzBV+KeEpFfiffeoR/uihOX7ljp0M568wN3ELW3gR4GVLgN1XwWAEzhrUUpPNizF+IEkOpjS7yqQyU4BoDjL7YTXvQjSjnlYPRMiKQZI4JHUdczDBHJUwasNy/2l718Qwulh2h05okXohHUuS6pv4lU9g5vIYzS5pT4JrYDckk/WQS8E0QwwzQgebIjqwI8nTWy9y5sBlJp0Z1rUsvn8E2ila8xzpeBnGSpArweogBC7kfEh7qkdrtQHehiJnGU2VUNVcpDhLbXqF/IU7sY9vJxp6HTLbo+CN4o01iYJhqqNtQncF5+IU3QNrkGwoFUPEQAn8EsSTkL+EkE3S1hSPCEFqG9y5YPBzwXZOk+UzPESSGpBmINuF0QA6GfSVCpVuhltaRW7E4gAFpvFoIhggYaBhUC0MwGYTJkJIN6FsQTaE6j7o7mDwosmPbY7xlvRaCoS4dNAx6NDmvuwKncNtyMTKSbXV748TJ6BpgDUB5ZpSU7o7oLPK2sgMa9PHIBuB11BGNZEHeh00Syk37QDqZbQ4R2rGSglZz0IrCwMm4rLJ4KxLIbJoGhYi6TBQz1NbPkA6sIg51yUnz0EFfDuPlEforE0imrsgWkFL/5q0eSv421Qp5OFNtOTLmIULhN4hpPdjUNdAzEA2oRUV6BQE8QWLYCklzSYc27+TdOwWaPfQaJJGYE8o/i9mTZrlhDwa7qkchV6DnB+Q7aiYzt6V/o3eIsA/UjybmvCud72LiYkJPvjBDwLK5Or06dNP/7y0tMSxY8fI5XLs3r37Oe3z5YKnjPJAoKEj0NCeLoU2yZDFxsXApYNNF5suDoFtEecNZXA1oKvy51wKZV2NUS5K6ZU91e+rJ2CJPuGMgH4Gbz9+V5lgRZA11YI0ecqZS7VroCmFlb5xlTDU2KTpqnzZyACmihASmX68UH9iKnUQ/Zs0dvplyijCLE1IHaXcigQcR5HXVILmqFLpVKoHjppQirCm9XOD+xBSkV2DvoO1rdazE+VuHQlFjjO62q7jquuhBUoZlr4q46Zv2qWbqD9ULzO5c4sA/1Dwlre8hbe85S3Pad3Xv/71z7j8+uuv/57b3Hnnnf286u+P9773vVflA8U79g5x/XSJJ+Yb/NevXub/taUCb+EliJctAV7YBkYbsjmJ3emx/rjO1J4IytBbErQ3DcxihKFB0hH0Ovsha2GuhujNJcLSEOEbDjO++AiZTsLGkAHti9B7NYRZMBJa1+wBMQ5ijbi6SaXbINZCnGKbXFqnF4M1AJlQUA1dlvL70LzdmM2QHA4DQAdJhSxRYQBRht6cIExsVYpbrGIYXcKgAdotykAlm4GVaTBrYEeYF3JEpgPWguqzyh0GvQTuJszuIl2boz3wVfK1MtZiidxymcZQk3Bni+5GhmCoDUmPkXCQldWdeJNrYA6Dk4G1SUQtgxyZxbZPE4xux9n4McblHm5tN3gXWTRMHqROgMkIeZJI0l41aBU96Olkqnl2hUNch8EhCjhElHHxiUgwqfgadJvo1S5itUC8U2DYJbIXtpMEezjSKPDWIM9BQorY6JgITAQ+l+nyyI5T4CwC28HToCOVM7ZENX93ctDbjmjXKW3spHHERFaWIVoFLw/pZehYqi9LdsAtgT0KkZqspk4KGTAvuxRWh/DSDKJhMehlmE4K6OjkoogYj01jEzl3C2HNJZr6JmZ+g7Ayjcy8Gno7QKsgywaac4LBlSU2dAe5YcPOVQaNjzDGcVI/pamdYzE/AXO7ofRXFBeOYZo91ks6Bw4G1NdgtpShffht4GyH5CT+wC5Wog2G5xOCy9BNLJx9XRY1sAabbJPQdaDlQD6fIPYBp6/ghlKOQd8b0fO6TbfQx7OpCfPz89/mfri8vPxtE7gPfehDfOhDH+KOO+7gK1/5ynPa58sBAolBgNanvcr3We/TMAsDlyIj5JhAo8IykiouHVEgrWRgyFYPPsdNlQCQ82DKhDFdKbxhD2iDmSoy6LYVQU0ipQSbusrh1SylEBtSGRZKAf4mmEG/3cNWxlRaDGFR9fPaGXBcwFJ/c0JHqbBJU30e65AbVMQ6CSAzDJgQ6OoBphYBuipDRleOz3oMtqaIrpSgTSrjv6QNhYwis14/uz5J1T1vWoqIu0XlWt31wSio0mjXAy9RBHx4pF/anUIu278mEfhD6sFA0AAvUuRbk5B46mHBywnPNo7C1li6hRccQgjed9de3vXJh/mjb87xv796J8OFLRV4Cy8tvGwJcL4LlQYs+yALKZYlyQ2BPwCNQCImYrw6TA/AaX+I2M1R/saDFOpd6rqOGKni7Xs1wfZxihuLzI45ZDf+F73uXdA7APF24FUQ/RF4m5BYdH2djGgwbcY0HOgkJrZnsantI41fi8xsxzI1TDqAi0dCTERCSNteICl1qM6WkJMDMBchFg4SHtagV4YLwLVFGKhD2FSTi+Je5KyGaI8ho0mIY8T5FLk3Vu5HWgZy06Rlh5Y5T2FtgsF0hLUbutCUtAt1tHbC4csH+Rnp8qW1Hl9zy8jxDNpMhZ0X9tKTNVY3YuLiOFntKG+q7uB2GtyKQ4CgTQ6PTSZIAcmqZmGEZezTkt3eMEWZ4VoKHCTAxiNDSI0ubbosoLOYu4AWLlJq3UE320HzpnnH2QEORttoAdtIKdFAxyIhRidAkCIJWdAX6AzeD9EQOCn4dagYkAmV2tG4htITU7QHYxw9y7XhMA/XFuiNL0HbhCgA4auJbKxBHMBgWYVBtzLg5SDvYfQSblg8zLDM0ELH6DhouCQkRCRk6bLirLL+ihYyNih88230gpsJXnlGlQtWd8ByBXb0YGcDa/ZxCk3YEHkoB9jp/80NreNc7qTUXZ1oMoLmX6FZ0zB7Gq3W5XDR58E9uzmxEGL16mzsuQ05uAO8WcgNk+rTzLHO7gsXWJ2DjObRiOHCa4fIJw0K1QD5MLQHQebVM5QrgsX3n7j96BMlrnp8PzXhKVL7FLZv3/6yViieC54SVyMNdCnQpYaNhtEvgs5g4ZBFMMQ6Ol0CeuToWlmamRzpsIDBRFWjDBuqB3iwDJmGivdxNbAk2Dn1wEz0ja3QFCFsx/1+3bRPamzIVRQxTWPQPEgtwIJcWX0ubTBKyuQqsfvRQZoijZEGiQ7ZIfB0Fctn+YCuCLSUQKzKnLV+BFJuQkUZ+VXIBuqieIYy6NKifrWPVOZZkaceHKaWqqJBqnE0CJVb82ZPKb+WrdIGUgt6OXV8x4aCpsh1ToOMq75/TYNmRkUxlLPqgYGMQXqAATL7revxciiDfrZxFLbG0i28KHD7nkFumC7x+HyDe756mQ+8dUsF3sJLCy9bAjx2DLrXgJ2CtwCZScnmMCyNa5T2pCSaZLQE1QHoTAdgrhLHMWYCpUSiix4bC4/gVyQrBZN4Yz/59VME6/+TJPMf+iVuNyH8v0Y0ZxCaR0+6yP3bKM2fIixIkpnDdHbtY+TEPkprN3HupmOEkzOcTFcwl44ylYyQouFgcfNKmb9tawzua7JS3UGa24uoFZGzDtzsKlfRzRDsGLZVYe401C8Rj74WbbWGHPMg0tWkOHZhdidkjkNswNouZPkbdLWAua5P6i7C6SJCD3CXO7w63IlLlQ23hZwqgm4iu/vwdYGvl5DOtQjd5/XzeX5BhuQxMSmwSYZ76XJ/boZe2KElz+JNemDvpjg3ybR0OUyGmwlw6eJQwEbQokMPyV/YMyzfmCdtFqkna2DavHluhB+PdiHooQMxMVnyZPvWVzopKYKQmBlrATkYKdXEq6nv7eSg5wMV0LO0d9dJEp3B+f1cT44ToksviVXJdLQKxih0mghWwbWR2Umo6mAUlZKyfYnKhQJ7ZQGNiAIOPSQ9ElJ8UnzWzSrz+x/HsO8l6u0G8U+ozA9TTV2S13lQ0sFpQz6GYINAVpmZvhFpXgfBGkXzcZpmil+B5kqBWA5iiAsMmScxl8EKBasWlNMl1qZuQO57C4zthnABeBCSaWAf60Nv4MneIoOxh9QkIhDsq26QyJT1LIwfgtEU9Laa018RTNTkbQtbeIlAQ6gqYCHRpICny581NAwsHCyyQI4OOnWgi4ln2YQFB0oxFFKVdVtI1H08qPdLnDuKDJoa2EKpvVL+AxInIZTqnhH9ZUJXjsiEqJ7kVH2modpqUlsRxdSmL70q4pwaoFv9cmYDyKjlXQmJpnqAU1MRVaQqTRb0M4CzfYLrqZJkkShSrUvVf6ul/fVNZe4o6btKa0ql1XRlWhVFEHjKYNCxwPCVyh1rSo3WdNUPHT11HfqqsadD1lIO1m4WMrZ68Bj76iFB2lej6UcuXe3YGke38BKBEIL3vX4vv/CJh/njh+b453dsqcBbeGnhZUuA/QUIB2F9FwS7YO8E3LerQMexmZ7eoHEJVvearA9W0O069vxZTDehM2pQSGPaJlhDVURL0DMtKI3SWdlE18+R0ITEgs3dyKHXMHTqOCLw2TxcIXH3smC10Bammbz8c6w324xV97A4dAwyf4renaP5ij3MfHmE3dVRNEI6dFkiJq0NoO1O0bozpGWDtLQbBisw6EHL65eP9aAyDNJFO/sN0tEW+uokxJBu81Us0+o4UIGp3TCWwBMZWJoi3rFCa0rC0gWwXKRbpFuWnGjP8HXL4cw+qSZgCzuRY20WDzbABz32uOPJcX412ksWGw2HiAx/o23yJ9MP0LhmE9YkLKMyHhOfXiZg2fd5pdQZJEYSomMhMdDJUqXFqSmNdCQDYZH0FoN9D6S8LZogg42DQZeQHBEpATp5erTIMUpEj008Llgt8DKqfy2agtkcTK+D0YNCEaIiSaEB7mXWRIw4NcpkYFJ1BTwRqFJxy4RiGRkK0EahPgmXDUqeAVLSGH2SiTN3UMCiQUKWlC4ePjFNOqzoCdUja2Qqf092YZXG+s0MRkNEaIwt6mz+bQb/Vceh0gG9hNZ4DKvXwy+8Ak5r6JUHmBhb43xi0WlYDF9o4mwGeBMJa7fuYuzgImkz4mKhhL2SUNr+OF07IqQLYgg9WMZePIHR+yqtyZ/n4mvvJPPZL1IrgDEk2bMgscuwlCiPmj2xEq4KS/B3V3JD5fj+E7eXWSXjFl78MDDR0ZGph46DjUuKSYyBwMZhDIchAvL4OHjYLJAhqhRgbxkmVmFQwA4bKm1wE8hKVTEiPfXyAuh1laGdrqmeWs0HAhA9SBzVk5sXihC3EyiUgFgR1gEbMiY0fTAGVf766jqkfl9dHgDTVRFumlQEc9lXZoxBooilaUO2AN2Gclc2NaVIxzEETShYMLgN5CVFci3Zd2U2+3FIjnKBTmMVT0QLvFiRZLffFyx0GEhUjBFNKOYUh/frqgInSaA5p/J9TQvGB1WfbzMLQz1VCh2NKGdqSyo3626gXqm6HC+L+J9nG0dhayzdwosGr9o9yE3byjw6V+djX73Ef3jroRf6lLawheeMly0BHg6hNQ/tPNx/OMvg8R6j1S49p4u/W9Ae1Vk9sBPZK5HYw+gyoVg/y0KpRLPQxUo9WjkLEZqkhTGgQOJsw/FOEyaXQO6HRgTBQTrFMQr2LKk7AYFGUnoN+XOvZSjZS2G9ShGLav2vGTtxmvawxFuoUepomP0on5AOS/YSUW4Pi61zyGlUn9V2SxmlBB1oz6lsWmsFojIUKqTDByE8T7S3A0Ee1k+p/N6BGlR2Q3tIuUfvMGB9B2jLUKnDWhO8eSBHao5y/+Ax0olRpO9CZwBiE7oOhbVhpjYktwXDvDHaThOLE2iY5HlcLPLZ7ffS2rMIMyXQO5BYiGWJrCwTWT7LegsnHiHGIkuBBhEhCYNUqCLoJRqifhy522HoCYdf2pyghI8kICHAxSGkh0aWhIQYB4lGiqRDj547CpkRaNSU26nWg7QDrEHSBe12aOyFYpe4V6AnPbINCbGnnKo7RdAHwG1BZhKSPejntzG6CK9Is5wdnqHVG2AkmiSmhoFDQIMnjSbLJY+kIkkKIfLQGfJnV4g2E6LBearhCcqt3TT1E9CyVUSK30OcfYJMfIwgHVVxSish2thpWlLiaZJcvcdQVWK3DTqtkPVwhGapi5ZrE3dGiUsJVjKL654jzE9A9zyF5hIjaxGT9TYP1x+m9fof43F9Cen53HryAp3Lkk5qMT4eYSaQqUuSBOZLV3hDGXz/0r2XYaTnFl68UEovaEgSqfeTf1Xhs4NDkRw5XAwc2gg2NZN1wyYaMEhHUhjwYHcBKhoM6WC3laGTaYPeV079SBFV2c/uTUPotVTPrxAqj9dMVKmz1AADDLPvehyp8iRpqQzdnKtKiuMYMo5SR20b0BUxXOsqF2dhQGgpMh2ienZ7ITTrfbfmRJVGO7YqhbYSpbI2JViu8jpwUkgDIFLfJUkUsY5CRZDTvmmYgTqPTFY56fdafRW7H5mkaeo7+qmKcPLS/nfXodNUmcfjJVVmraVqWctQ0U2pCV6ozj8R/b5gvV9CfhUrwc82jsLWWLqFFw2UI/Refv4TD/HHD83zz+/YxciWCryFlwhetgRYzuboregM0uRIo8cTFuyLExKR4eTeQ2jrl9A7m8SJA2IbycEdxO1FMgKSUgGn7tMzoKL7rOk5RO0Ew8kMI/t7HD/+GDJzQOU+tnfS276fZGURuX4Zeh6i/hZGmyU62mmqcplL+WPsiE9QaQmWDkgW/QrlcAxJgEePmDbb/RGq8yHRLVMwtATFCMLHYCMHVg+WLajkIBiGDR/WhmBDA/0S5BZgagckB8CzVM9XdEYR53Qb+oJDMiaglYOWhEwJyg406qA1ScYkGE1IimiNMsXedvYtZ3hjZHE9MEZAF8lfsEkVnQI9TmgnaZmXYNmAnqlyIHUXWYzBkljzGk4qyZBBJ0ODhD/QP0MqB/mF9AamCfjZWZOFlYTZQYOfWhniOukQkmDSJUOGiAiDkBCNBJ0eBlVqNInwiDC602ROxsTiAtHoMmxfg+FJqG6HcAMqEprn0VdPgnmQnt5hLBpEb6whrBbx2BFwhkHkYUSA7ZEYq7Q8+IqcpXFwleLCEabicSAli86GaLK44zTR5AKM5WDYRa8+itv2qAqNbPkY7TRPx11hUH4GaZn4J98Ge3UmTp6iKBLO3WqreJCxcxRHLipz2KSIqftUDnZoRy3OHzlIMlxhynuCuidpZbqQT2lkx5HZfRA0yaRPMLgekZ8F/zIUK8do3fIqkt23sO/i/2CsLelu6Jhhlng1IDVjkoGYhpBol67whuq3Kn7vG+753adb2MIPHwKB1u8BTkkx+n7POhYZcrgMUcEmS4xJC9jUDDYtC8YMGElhIIAdFVX2nEkUudU8lQ9up2DG/SzbQKmisk9eO1XIlsB0VDWMHininGhARjk5d1tqu2yqiGCUhVJRxZ8FgVJkNVNFBUUGeBI2upDLgW1CYEIgVDZ83FHlyV4b6JdDC00RbSurTLaSFJopFF1Fiu1EGWilgZohxL6KJvKDfmsPiiiLfv+xbas4uq6vlhk6qnwbpfbKvnQrQrDyqm+41gAzC6MV8DqKWBdslYNsaKo1R/RLxxPxrbJrmVzdvcDPNo7C1li6hRcVbts9wM3byzwyW+djX7nE//sntlTgLbw08LIlwDUtpR06ZE7aDFwOmBwWVG+VtPyE4uwM5a83CLZLaiWBt30Q0ThNV0LW89iId+DZOlIfolpZhvoGYjmiXGszPgnnbv4a/uKt0CxA0AMrSxIJMu0qfnEKmfGZnfgMZu8hCt0lhrIBWT3G0aCVcclcvo4huYMOGxxnhvMjjxMPeyTVMlQPweQGsAxdoDUBRgBWHQJLPXm3NRiLYEiDtbJSeaMdanI2Ktx8ro0AAQAASURBVKGah3YV4hoUXUQ3hCSH1swhuiWSa3sQ9Bha3YGwMtTNFpFeQvR0il6O62SGtxNykASLiBgNi4R92FwkImKefckAT7ZLDFQtkCaBEdI16qRFl23LEdOJxfXYZOgQ0eKPmOd+bYlEjxgIzvNuuYOfkKD5txIuJhSI8EiwSdGRtJBcwqCDzXmxhk2DGcPnoq7TMUx2+kVube6E5i4eMRucNy8gzCGc5W0ML+xkNLY5s/1rtKfWQA6Sl1/nwWzELd07MBplQlNAO6OU64kMaHmYyoDzKG0zwO0cRyYj7Ft4KwUkXQwcYnoEpMbDCPMCsjEOWCStHhvFPEavi9kM8IdnELtnKTzURDegI04RX3onzYH78dw1ktY+KBXR93+BqN0gCSRu2KaXc5kT4I0YxIVJSBu4ho+v69CdgF1TyOwUaB1E+wuUdJ/sihL2Vz0YCVosXXySUmGDV1zu0CnA8BsSWpcbaKvgZzSy1Qyh2cO0UP+/niu2CPAWXirQJakbE/cEMtaBPDEWwdMe0FkcyrTI0STDJUxargZlAXsd2O7ALhsmU+Uor/cUaUNAdRYKvjLaC5JvEVU7UVm+QV6RX8tSyquegpGocmctUeprEvaVTrvfd9tVpnsyBNEBZxK0HJgl1WOLUITUt6GnweUu+FL1Adv9+CNpqnV0oQyxmjEEdZU5bGiq1Hl8UJ13lKpybdNQKq3UITH65c1mPz5pE4hV5r3oqn7hgqbijnyhopySBNpNRYgNS5U2W74yGaCjyqkTH4odpZJXgbKpysIvecrUSwj1oCCN1XVJrnL5c4sAb+ElhqdU4Hf+nw/xJw8rFXg4v9XIvoUXP14UBPijH/0ov/d7v8fq6irXXnstH/nIRzh69Oizbvenf/qn/OzP/ixve9vb+Mu//MsrOmY90yP1QxyZ0mlrbKtpNHMx0zeEbD5cRfSgew5KQZVa7n4MP2ZKJoShYKBxltWwTCNJiZ2diLXzcLHH3HgRq9XCuGEWJmfh8WtU+e/GXlJ7D0lpHVmYwKo9zO2TD7F2yqCbaohizMgAXBo0qLnXs6N+LRoBVXos6SH+iA2HzkM6C+eH4d6jcMcMuDMY+jwx+yHtgqiBNghhTT3dx4HJ69XkRSuq/qI0gsESmKOwkodWSlxxYLCF7BRg2QS/CI08pXCEg6HF49oyC1MB0lqg4czygDBZ9Iq8t3cbr8YixUfQYxsRAR4OKfcLi8QVdNKUQjWLEQuE5mC0y+zoRewUGc5rm5zVN9kep3wpd4Eo0hBWStZPiIn7VlYJoNEgIAJymFzE4O+pcYaQBm3WRtYgN0uaPU/a2wXpbrz6MofqOqfMkMuDC1CXjG/cwC8EN7KTcXwiPn92lseSr9Ku6DQnHOLGANva+9lz7i5O7n4czEXQuxBqUN4OXhaCFYzWMmPDVeY3pxiJHXQkFiDRWTNStHyVofo6VbdJ1D4M5VsISpcIRleht4Flz1K2JNWbBOayJDnSgpM12rVfgvwGnL8GUVlh33WPUAsEdkeyPQxYlQF6IthkBMwmhlxECyXG+Rg7v0SQvAKcA5D+FVJP8FwLLRei2xCVILA1pFjj0Ikz7EzhvtdArwHDc1Br6IhamUyqMTrmk8ukUL+CG8pV/92+J14UI80WtgAgQBroSEwEsm+HJRFAgo6GQ446GQIyeDgkTj/nd9iCQQtKtlJ6rQh0T5FTGam838RXjvGW8Q+ijQJVOizMvulVon6OpXqlusr6TZN+T61QY7Um1c+6rtY3nioR7meqh6kqMQ4iRaLDGKJElUD3pCo71voEWTcVsRUoZTXt5xILoYhumKgYJK0fcZRKddw4VWq2QBFoQyrlWQJ9d3+kVARf6upBa4raPk6Vk77ol0QLX+3HDiHu5wtbKThC9RMXs6pc2mwpAm6b6rs9lQ8sxNWtAD/bOApbY+kWXnS4ddcAR7dXeHi2xse+cpH/sOUIvYWXAF7wofQzn/kMd999N/fccw+33HILH/7wh3nDG97AuXPnGB4e/p7bzc7O8q//9b/m9ttvf17HbSXQzsX0OuoJ1lRsM+OlrA3m0bUeO+ox3YaksCAZuxTwpAvRqsZJ63aKdZ+75COc2qyyMOHiJSmmL+lN7mZuZZZSvEZn7ARUpmGxAms/Tpo/Qjh2HG1pALlxjPmxR2keDYnMlLwPq21Y6OaQxR1IUcBCZ5gcUT6GsQD0BrQW4EAT8cg48tgEHGyRdHuQWYLBLHQOQseAw7YyVtkcBb8FhTnV+6pHEI5AawyqtpokrRtq4pZZQroZzCBDtGwj8yFzYzWa7TYNo5+dSw3ZNgjyPpctk4veRW6XkwQ0AMigcw0OXWKWrSVwl+iNuPS2dXFWh3n9wnbWjBZf2zHP1zMuSauK1BP02CMuGFDNsLs5yCuZJKRHFhcXnQQDDx+TgCV0PqqdZpWUWBi0dY1Ui1Q8CBUYA9CZ2BhmF0W+YSwQxxUot+gmLtGKzleNc9w7+k26QQ0vOwlum+z5SQ6u3ognBA2njYhryOER5WQaNpSLtDkJtIiLCRtlA7lkkkv1/k0kyGHjm4vYuTWchkTEGXAKOI378a2KcogNJGFaYt2chMGQin0Zw20RHZpD+8u3Q/UAqWFhTHyaVt5kvXw7zJ7lQLpBo5Yyu6dI5LwGwiqyeQlpQ3ENjmQWeDKYIzIL4K9BNk8jhOXpDfbHIZUzQBF0UWU5H/C1ArhVSBahOw+6mZLKGsthhmBlFF1b44pcZ55NubjKhZstvIQgNYgcLBnhIEkAg77TMBEGghxlUnKEZPDJk+QkDAHTGRh1oGiD1VGKptFSZbxxoFROGUDYVUZ7IlTl0Z6nSKMYUOOtTFT+rpcqQ6m8rcqgg0iVVYsEuj1VMqxbfSOqnKpE6Ym+43MO2kH/5UMtgM5T6msK3QQ8FAG2UQTY0AEJUV8hLqSqJFqT0OqqOKNyoPqXk1gRZj+EbhOymur1dVKQTp+sx4qbSqFcpw0DrIzK8I365cpRW/X9ihzQAXqQRym8QQBJBjKa+t5pUZFudxOwlCt23HfFFoa6LlcznosCvDWWbuFFBiEEv/76Pfzcf3uIP3lonpu3l2k02+wch1t2DqJrW9ldW3jx4QUnwL//+7/Pe97zHn7xF38RgHvuuYfPfe5zfPKTn+Q3fuM3nnGbJEl45zvfyW/91m/x9a9/nUajccXH3SyryrO1PBSqsFhKOX/bKOH+PSCybM6dYvfcPNn+nKQV68xN6YQD17EW3cU3HvhX7A3Ok0/abJrg5yFcOEdjskirPgCVB2B6J9T2w0oJNneTvThOKbTxxU7OPwpMzGHsqpEtzLNRDuh1JkGHnmPhdluUsNgVGjyhDUNvBNGZQWYGkLdYULOgPoIs9SDMgb4G2TWo3E72mzp20KUx3kMWVmHjtHrans+pSZOmwbqJyp1sQdqC7hpISUVUcC/sZmbHHOG1m6zLHsgC2vkiheVR/EQiU8H2sMA1soCJIAZCEhqkLCCoCpOz5cchvwbJXnIbw7xx8TDXpxanQ52z9Q26lXWo5mAtIXYGIXsBIylxS28XDilzZDkAaIRINAxMauT4E57gfGaByElVjrGugxWDcCE/Ddku+sYGN3X38woGwTO5J4joxAY7kgBJg8+791HXazBlU1zZzzXnJpju7WNTGPyf41+mnTlL1rtELwyQwRQM5mCzCd5DKmOzVKcptqE7UySATY4EgYtNqq8RxV26gKQMdob8+jLh+ACpvQ/MLkzsRpYOQ1KhtraI1PIwu420vI7W02Dn/cT7Zlk0fxKxscha4RA1Q7In+SZhLaZaeJhSawPXbtLYhN42CIcqxOZ28ObALsNMinNhno2xQVo78uzNXmDgQsKuRy+T3wGXx+ANKzDgwwIuy94QddpYMkeJQdq0gfZzv6GeLb7jKp+3buGlAQMHkQpEGBKlEolGDh2dGIOEEmVsbBokgI4udCJTqHQhTSrTKDuETAr+qjLMswPAV60oqQeFMrgjUF9Q25iaKoM2DEUWM67qwQ0NVZ6sA3pF9RKXA/BLyqVZk5AZBLsEcQ8iE1IXkjIEriLPywY0BWwG34o82gS6DrSyynE6DaDZVWXYtqb6bBOpCG43qx4IiAQmC2DqsDn3rRzgehcyArYNQa/ef3hgK9VbRIrYawmQKKKcEYpoh1Ip2gJ1TE0oh2epK6U47qrKJJkBWv3WnUA59FseDDgq2k9GEOnqlaZomgAk6dU6njyXGKSr9btv4SWNV+4cYPdwjovrHd77P471l15ispzhN3/8AG88PPZCnt4WtvBdeEEJcBiGPPbYY7z//e9/epmmadx11108+OCD33O73/7t32Z4eJhf/uVf5utf//r3PUYQBARB8PT7VqsFQPsumHpUtdCWVyTnXmMTvuJayGfAH2XiyfspXYTVRUj2gpwqsb79FRCOwkyZNes2tq1dRNgp3XEIXqkRR8MwMUbqXAtaG6YboM3D+QacHMUvJKwMXQb7PFJrwQ6LyH0bS36N4eCvmDTmWLBfRSF2cBDExNzW287s2Qb1Q6NI65BSGvJFyM+Ak1VPzJNFSFyEdQ59vkFx5o3c0nsFX2k/SeOnTOgOw0oH0gGIchBpGO0MqSZJ/RoMdaG1DElEdaSDvXwd9nIFb9uamtB0U7KtAndGB8ghKHV1bsRklDYb1ElJSEg4Rps/sWssj8zjj5oQTTKwJPnphcPM6R4fHXyczcx54tRV/WpeqvJ27Qg0m3jY55H6AmPR9dxImwIxCUU0bOYw+ENngceLG8Sxp/rBhNFXUFA9dZUOhD1SaXHaqHM61LmJaziaFonqm2wj4Zh7ifbQJmir6N523rp+DW9LjvIkHf62eILWyDy0A7piGHPtKINLB1mnSTJZhd4i+NugPAFtj2xthBHKaFhYWKSEdPMpUSZLR4RE0oKgQ80uk2pDUHXA2QHmAeiNABlk9npoFiFYgNuXyTS/RLx7hiC6A2PlYUqPn8DKGaweeTVz0WEOyEcxixeopJLmPGxUobltCDn2TyF7CNLPQehQOL7E5FKPywODeLf+FJfO/wnGwgylBFotKCXqFMIaLCYCT9oUMAhpsWTNYY91Ye4KbuZnUy62Jm1beBFAFTsLRJqS8tR/Sw0dgYmGqdgoEZqq8BV98mtqYGnKrVhLFDmVPeXyHIeK/IoAZKxckHUHVWot+wSzHxVk0C9xVh7UGIZST7WMyuF1hCKYaQJ6HvSsyhOOURFCsaM+DwzoSGiiXl2jf7y+EtvRoNs/Z9l3hha6WqfXz9RNUvA01QOc7RtNSU3lABu6+o6pVCrwUyXYUqC+hKVKoNNA9f9Cv8QZIAbRL6XWpSLXQvbNrRJ1bBF+S81NuzzNaM1+WbbxD15P5QCn/WuncfWOJ89FAb5av/sWXtL421OrXFrvAOpW/5N3HUZ3cnzsq5f5F3/8OB975w1bJHgLLyq8oAR4c3OTJEkYGRn5tuUjIyOcPXv2Gbe5//77+cQnPsGxY8ee0zE++MEP8lu/9VvftbxjQnMQhisQT0LtsITQg9Gbse8/zfBGmyUJ3VscmvkBUseC0Vsh3AHmOnLjFMdKLsLzCDoGA35EMdOlObq7b361D1ZTKH4dDg2Dfxtpw4fsEyAuQsVXmbTiIdKuyXrvKIX1B8AFN5XoGOjoDDPKgZVxHji0DvkSBJeg0QRzADarsNGBoWEYthCLRdz4AmtDj/HI6ii9jAEdB+wxqGRUru1CDrFhsrslaBgJq5OaeurebkKjQ2TqzA+kEB4Ab13lUnZtvLzPesvjpngSkwwX6PJl1jmAYBqdCj2OmXUWpx9m3DjFkj5GlO5lcrWMJMOD5ZM0Dj4BpBRmJ+FiTGu8o2Ix0lDlJnc0vLSIg0GZCIsikGcOh09nT/HokcdIEwFzPTDyiHYKeoIsA11TTUj9CKt5jJM7qtx7cSdhUmGFHikGDw4+Sm3/OdKGhNIEg/P7eG2ynxwGBnUi4wR4lxHBKFMrr+b6+JVcLyt87fgS5xbWSZNpzADaue00Mm1y6yUqZNFIySBp0qExoJGOjOOtW+r3lJEkk9eDOQjeNyHvqMmv74G8DLhgpnD9HvTuE4yMPc7s8jsQtXUGasdx5iziYY/8wjdp5t5AY+Ai/lKey3GEu7lCkhOIkRuRzlE18XaPgFwlHMxRNRyiggD/FN1ykeqIxs61FGcQigI6HuirEIYpPj4RLpGICKbrzG/jygiwC2S/z+faFexrC1v4EUEQofcDkJTTgCRGI0OWDJk+KRbEWH0CnKqy35INQ6YidjJVZMzylQFU1AW7BUakjK2iQBHSTAGIFSkOdXXfWwChMogiC66lyHUvrz7XpcoMNiXEedBdVW4cl1VwfTgE3VQR3M0UNkLl3B84qmw5TJTTfyvsq7cG2JaKg0v7xlyrKAU7EynFV1gwYEE96McyFdV5WAnkBPg9qPcgKYDRd7j2LaU46x3VE6wDdh5I+qXgnjKu0mLVRpIIyOag6Sm36Fy236/cgmBd5f7GjorpIwfxYr8HOlHl0noKnYhU1xTxjq5SFvhs4yhcdWNpFEW88Y1v5J577mHPnj0v9Ols4XkgSSW/87kzvO7AMC0v4uHZOv/ziXX+v++Y4uO/cBO/8ulH+f98/gyvPzi6VQ69hRcNXvAS6CtBu93mF37hF/hv/+2/MTg4+Jy2ef/738/dd9/99PtWq8XU1BTeUn/OUIKSA9qGBkenwdwH3uMEDYhcaO4pkHpZpGGA3wQkxsYfMdp5jI1xl8KmxBcOzYbF9Ol1PP1+wtE7oDIIfgGmp6F9DnbNwbE7YWAMuhWscyHpWps4EyBG70P0WjTLg1hPZBhqF2nhUSGDxOA6f5yTl2dp3TgK+RW09jKpeQOsXMSpzeBvboNchXRoF83VAzBqsHRwVrlAiyYEBdgYhjADKwZS0+iaAWbchtyKcqq2t4PdUX4mdgIjK6DPQGiCSEm2FXgiqZIsDhKLGov2BVrG3zLR3c4vyRvYhsPBWPDEEtSHTOIhB+IOZworLNcS8tUs8uw+dgY6P9bcyWftBVrlHjQM7GWd2FxFaEPckWi8mhZZdByyrJDwCfc8D++9n9RcAH0fFFNYAVlqQtZSysNoAJ6NyDfJDrTp9roMSkkFQUeLuFBYJyjPMipPsbk+TdSdpLiqY9IjoMCXzMsqSqg1yUB9D/8kehPXYZFH56boeubWGzT6VlwLHZ/P6ytMpRYlHCQRXRqk9IiNMmSPwOAqunucJMirCaNcVCYvFR16F0DXEYvHwcggHSDTQ3hnWdVHSM/cCM4FeuUS2s4WIgOlKKE5OsyFzFHwdiKsNsnYl4gsm7R0I9hVNam0boTMJv6rsvjhOrgRhF9HipDkFknYhl6i5syxgMoR6Bo9sidW8QMBTkJ7B7T7pYbPGc+mXMTPfVdb2MKPCgYaGoKYBKOv+UpAx8AmQ4EBDPLESHpIPC2BrK9IR5yqTF7ZVyE161sqpoiUwqrp6vMkBARojnJAjnp94iyVeZW0IEh5Wk31I2W2F+rK2VkKtTwpKcfnOAuiBGYe6nVop9DWlYorY2j11E3tCZCuUottG9qRIszZriK9Rj/Dl37sUkf0+3oTRfZzFlSmIG+o9dMFpW47EXRr6niRUGqwnijynjTV94tjpd5mLKX0Cg1sZThGiiK5UqplRqiMwywfRoehByQdtY4uoZBT0UudVI3vpqnU8TDuPzzw/pH/5/wj4bkowFfZWGqaJsePH3+hT2MLPwAenqmxWPf4P372esI45Z9+/Jv81ckN/h9v8JiquPyLO3fzTz72AA/P1HjlroEX+nS3sAXgBSbAg4OD6LrO2traty1fW1tjdHT0u9a/dOkSs7OzvPWtb316WZqq8ivDMDh37hy7du36tm1s28a27e/al12DiqHaX5tAe8CEfKpUtGyTbhnCHhgLdfRyA0+/HunFkK1SWD/JQJRgL7aIIkEy6JCMj7E+dwn35CbhqAWdDmybA78OjQZG7SHS7DxpdBfm7BRDs9vpGBE9zSe60yaX+yOSxjJRYCDIkhAQY9OjRR6dXReGeSK7DuUJzNwMYfwE0jYIxvJQyIKcwDAeJj0iSDstsEYQ1f3YaxkC30HWTTAzKiqpF7Ius4jMivpjKxwwDUR9FxQuI80i7FxDrK4joyKk26Cr4dkNzooG7ak66WiX4QuCG2WWvViEROyXGvu9w5xYdCkkbfRtx/AT2DQL7AkPcGT9JiLb5yulSywOPYzb6NJrX8OB3hC+WefitphGc4EosdAosYbBfzdq3Hv9CRKr0XcH9VUkSJQDNJVbWdRUz9nqKDLI0cx00YwxbKFToE6j4uMfaECnQOTlcQarRIUmi6HHZ1cD3pD0iLQMpnYErZ3llt4k+4g5T5NNQgbR+2Y4ATVauAgMu00QGcjIxwZCVKao0ynSywYQ6OTDYyTJSdIG+O4gSWmXcoiVs7CeontdZNAlGShCfJLYWSeW1yBaI2itAdq3RLRvW8eqzSODIhTGlKpiVJDZW/DKEejDqqcvXwVxSSk+sQ3ZKSjnVQzKygyIkCV7iDVXkNZ97HCFrAyoD0lqeRN3QlDoRGhA3bFImhrgP/eb2ey/vt/nW9jCCwyhanRJkZgYmJg8lQtsYJAlDzgEpMQorocVKnKb6krhlZoq6ZWa6mkVJmAoAqlZfafiRKmepqnGV/ptOBJFflO77wCtKdfkOFWkNwJ1s+iqLFr2ja+kq0yzpKl8pNopeEmflKfQC6EtoKMr92TlTKVaREhUqTKiT676pFJzVIawkagqFDdVpc7kwbAVWQ77/blGn3SmMSS6+p6aBKOv8KaJGp8t0S917sclabEiwqmEbqyukSVVf7EegRmCPaJKnWu++i56CjkHmv9geqLpap0Ata+rFc82jvIcPn8J4ud//uf5xCc+wX/8j//xhT6VLTwPrLfVXGHfSB7XNnjlzgEevFzlD758gQ/99HXsG81/23pb2MKLAS8oAbYsixtvvJEvf/nLvP3tbwcUof3yl7/Me9/73u9af//+/Zw4ceLblv3mb/4m7XabP/iDP2Bqauq5H/yUzsANCXRBdiC7SxI428BwCIb2cPk1K4j5dYSzjWDiMBR2gLUT5k/TCWo0RkEuwOa4BmGEEfjYQYQdhNSbM8AkbDQhOgFxl9iawqrMEh8/hTv7OtZGniS+fkVlJuY6tJIjaMMXkJzgzOr1WMEALiEGIcM4OCxB70lYXyMo7oWJARjdQIa7oHwtRG2M2RXi+V2kXRe27Wf3yVdyiy84piecL9rEDY00m2ImkAtL1HZYkNQgzUPGJNfdTtybxDu0imjdj2gIpKPDagN2bYJeojXQQO7xKWws8a8aP8mN/RCgmGUeosdDQ6ewoio3Ld3ERbFIa7CJJo5xOYC5sYjAXQLrLLm1DcSKy476MLdLi93hDfyv2ctcxKZKCYsKX8fhMSFIvAQyG6qEr6BD3lWTPU2Dibya/GUT2JZCd4B0ZAdp1uMv66dJ5qfwQwF1AeUSmyuvhjUJR1r0rpnlbwZTCie38y+CQ3xlbo4TlIjQ+CNmOV1cpj3wTQgFTnwI9DKhc5FMtE5ve4fq2gAz58a5iW14WLi4uI0BavUNcCSN5Ah2dIId9QZLfpv2/BCYY7D/UUjPEpcnwBvGrp/Gcs/RHrcgTpFOglwpwFduh71NwiirDHC8Fgx+AbTdMDhBpvt1gu5e0t41qpRQ74C7A9pL4F1W+Zm5EIwCVPaQdnXCQhmKMbH/KN3WeTSvQ2qN0pMVNjId8AJorEG9dWU3s9t/fS9sVT1t4UWAgADQiLApYuJiEmCSEuLTxGEnBiY2CU2ydDEh6SoiShbQ+uQR2Kgrk6mCrkqh0wgGskqhjPr9tWEIUaQqaXQHHFupriEg8kr1TUDV+WpKKbXHVO+vZgG6ItqJCY0AaiE0LejE0O4qE6yWCc2McoLuRWp/XqIIp9uPOPJTRYaFVGXPrgM5G0QdWgGsByBGFIGOmuoYeR0GK4CENFXfT/RUFrHZJ7OJqR7CiUGwusoRWzbUQ7koUq01Fn1yr0M2ACdUaQU6ULKgVlfXYdhSJNpLYMhQfUoNA5rRt5TnNFLGWFcrnm0chatyLI3jmE9+8pPce++93Hjjjbjut1+E3//933+BzmwLzwXDeZXddW6tzQ3TZf6fb9jLT37sQf7i8SX+91fvouXH37beFrbwYsALXgJ999138+53v5ubbrqJo0eP8uEPf5hut/u0K/S73vUuJiYm+OAHP4jjOBw+fPjbti+VSgDftfzZMBAZaFHCzDc1JiZSIns3ZHcok43db0Wau5D2Goy+QTkmh3W0U39FdvOrFO1NqgYk4w7e0DhUm0wunGPMTHny+hJEa1B7EuiB1UHLrpPuup1wZR/sSUmXl0jzF7DF3xLc/GZ4Moc8fzsZq86BkXt5YqrC+MzPcSQxCDHoEDKjP0R24wQBkqmVGxk690bOjJ6kszuCJQPybfyZ69FXbsW21ggiyXBq8mp2cjRJOVGrcpKAlTBET0YpS5duJ4+fm1BP8aMm3akaMidg9wXkuo8c2Q8rIezwEe0E1mNkOYKoy9Rmm1tkhoQNHARNBF1KRPEmVtohkhla1ZuIx86CVQGzSOx20VZOY7RreLbN4doUd4ejDBJRpMDe6CYWcRgBwr7qKmIXOmUYGwSzqDKK9RCKKVo7g5gJSfQSpA7sqsOcADcH2QZrUxt8c36eYjvHZldHbo/VJEofh5KA6CTRiGDjzAC7kgEu0eUBmmzQYdPp4Q3MQnYN052hPVoDOQ7RMoX4Artsn4XwAFlCQEfHJiDEikzQJ8AywQwJIod1/RHCIQvxsIUwhkivG1CT1bYHOdACHU1aEO8G7RLccAa+dh36hQzJ+pgq/ZvehCNVVQKp7wHzBJWZdTR3jdW0ReTmVNiv+RBEs+DPQaEEQQzDE0AC+bJ6cFCYUu615QKp1VEmOyJQ8SV6HboZjKhxZZV2z1a6dxXPWbfw0oHoa8AWCZKYGB0HHQOBIMXEQMciwSYkJpAaJC5otiKOtlBlz3HUN8USKMaZUVFskVQkLg5VfJFIlEKqFRWR7aUqwsjQIZNRlSshKiLpqXLoVFdlwHaknJJjA9ZDaEv1ahrK6KqFItap3u+LTVUJcRJAoCm1VGhKUTVTpczqffYUhip+iVQZYBUMVYZspWBL9XlbV/FL9DODnaLqm+h1lUu1LpX7Pj4QKNUbTSnecaDKnS1DZSOnsm/+ZSrVPPLV9dQdFRuVpBBZSuEWer//V+tf84wqr5Zh/1pfpf2/8NxKoK/CsfTkyZPccMMNAJw/f/7bPhPiKmT8VxmO7qgwWc7w/7vvIh//hZu4bqrEa/aUue9Cnf/0ReXnM1XJcHRH5QU+0y1s4Vt4XgTY930+8pGPcN9997G+vv50GfJTePzxx5/zvt7xjnewsbHBBz7wAVZXV7nuuuv44he/+LQx1vz8PJr2w3d9yLsRoQP5oRSRh1S3lRq78jhk74Dxt6in8bU6+AZi5nNs/9s/x3UD7BtUCkRtCHALYBZZEzZeyaO352fg2DKZtftwpgLqg0dIiwfBGFamR9sdWuk3EGZC3q4RXlxALrwdzf8cxcZF8l7CQPl+1u1bsXtFTPK4xIxEh6hr55iu7eX10U9QZphr5jPcvzHPMh7BsCA0AddH8yvQNtGkIE+Cg8G72MMyXdaikCexCOmQXdzJiZZG/ebHoJUn3StgfBZ6ZbBvhsQBw8NpR0zOXsOSiElimyhuoPkBGhHgo9HCxeZWDB5rTTGRmAyzjcecIcTGNZhxh1yc0lvfJJ2yMfwche4wPxdezzYkDikJLSzy7CYli01EikNKXnbQfRd9bhdOw2XnhseaFrCydwZjYYCdF3ZhMMDZiTViaxkOtGFoFJYh1RICPeVA4tKo59m0TBjrwWhDmcpow2hrFgfDHTTwuY9l1tEQpo83vaYmkpmdRLkKRFNgrkK6Sb3m0K2Z3Dj/WqaZxsMgIgYkE57gsnCRSR3cBugD1Py3w+ObYFaQN18AsabUFr0N3lm8ssCzr4H1d4D+NazKnxDeIuHJ6yEfK7K+awGcL4DYC5vDGN7foa3HjBbAsE4zM3Qn5AYheVgpL0EZsbCELGRgKKdKoeNNVc4Yb0KyDBm9XzJpQQXIhFBrw0aC6F7hpGOLAH8Xfpjj5BZ+OBAIdAQ6CWmfAOdRWd6iXxatYRHi4BPjS0314Qq77wRN39jJV/eP0JUKLPq9wWGoTLCSniKcMlTRSHpR8bZODI6hiGE+A40UwlRFIuEoQhlpoPfJaZQBX4c5TzXveyk0bNXr2xR90qgDwbcIcBwoYhybygla65Ng11SEkkTl7xKBZygCnTegJ/su1xKasXLoH8gpEi9TGCuofzubyizLEODk+mXOnupFRgOR6bd6SLDNfvl13x0bS5VQR13QTCAL0lcEOOg7VgvZJ8BCjVuOq66p6KvOIn3G3+1VgZcpAb7vvvte6FPYwg8AXRP85o8f4F/88eP8yqcf5Z/fsZNfPDrGVy7UuffMOgL42M/fsGWAtYUXFZ4XAf7lX/5l/u7v/o6f+qmf4ujRoz/wE7r3vve9z1jyDPCVr3zl+277h3/4h8/rmGFOspgDswe1joXnHoC2C+e/CpMZMA5Db1BNHoLLlM98kcqCSTQUoy8lGBlBjETfWCBxbsAbOIg3oUM1x8TS/Uyd8wjWQ7oHlghverNSD+05WHwEpvLIaplNq0j2oRUyqy7t6Ro5L0R4gvJAnaq2SIdDZEnxsbgheTMj63uYlkOMMkqCzxTjvNsbZZkl6nNNzpk2G0JjOe8BJq2kSYOAYSxMTLZjU0Ajj2AeQQmHBSuhbjYRl/ch7+yqfrPlnJqkBZvogc0rZiYYZRiLFfTA4txoQJAKGkjKaDhKwuB6Yn4nPoSLzToWXt1ilRKW7JAjZaHqshSOsM0/w8+EWW5EJ8ZHw8HGwEKjg0GKIMLEp4eNwdBSntfP72avNBmkzedFj7/xukQ7L1A3dnJww+R82Yd4DbIFuDQGy3kyDUEmNRghx6tb2/nL3gpp5EDBhqSHtrSMsRoRAV8Tqzw+soEf66rvTbbB8UHrqTI/auAvgBaRyiJTi7t4c3IzApM2ITEJCZIDQYEnji/RftUaLJ3DiAMS7VVgGli7vormXMLzBjHDJrFVQqYGWX+BXn0YcWwYecPNyNZF8t3/g3T/fkJrApHR0Gon8XM6VPeA2ySpX6AXAR3wJ1PIplDsQGhD0EHzPDKyS88cR4ZZ6Pn9iboEbwkyF5XxjpGBdLKvzFigjYCdI9JC9Z2fK54tvzJ8XrfpSxo/7HFyC88fAg2BTggYGFi4CHwgQtAlR5ESZZT1m0RgEGISPqVWWgKyfQXWlah+2nEwGmDMguGrkt5MRhHaXp8UGkKZUYmwr+raKr4t0aEBaCWo5KCqg68pspvPKoflpVgR3tADLasIpZ/CcqAUYy0Lyx0Vh+Q7IPPKibnqgRao3mXpKmIem1APFYElVn3HugMTtiLbeqAU4ZwGEynkDFUtc2wDBkz1mg2V0pwMqCxjW6r4OWygn9cbpErVTuw+IU7U95VA1IFYxUwhNUXC4w31oFU3VL+0HqrzyafQ0tX1oqMMt1xbGYJFAXg9dT2uNjyXHOCrfCxdXFwEYHJy8gU+ky1cCd54eIyPvfMGfudzZ/ipe775bZ/tHHJ5w6Hv9vXZwhZeSDwvAvw3f/M3fP7zn+e22277YZ/PPxr0hqC8LtGHNR44ehNyxyFIPeyNZXJrH6K+/1Wk9bdC5QBa9y+ZXJjDiUdoNVZoxQl1yyFKXQrVJvWBGCrjMLMHkoTO+BS91imag4KkMAHRJDwMaLeCVUH0LrErPEZqp2yOmmQXssQrr2LWnqPgLIMXMdLtIojxKNIhosw4Geny1fxlSt4mN8QFBvFJEOymxFk2GYgyZMmynjaJmGHRbvOEV+YoQV9ljRikhEcXG1gmYl3zESemlJFUAbgwAXMdZYgiwGjkiDCYR2eECjYO5ztdlg2LR6nz4+iEeAh8eoRk8aiQw2Cdd8o8xynwF/oCp9wZBjuT/GprkENMUETQQ2JjEGMQksEkxAAkKQkBGUKmqXM09jmCJEvMAhWkTLGbe/Fdg7XrGmgPZzhwbpxTjkesF9GeHGBb3ea14XZ8ckg6vCMd5Ykzg8wMdJR8HxxHW6lyXe1VGOS4TwvwhyNkZg0WdFWmKHJKFWERnDasJKAXmJo7wM96/xtFBkmAlAjQCXBwcRicTfGunSWzuYypJeQn/4rGmEDflPTWJBCj9RKM3AZRwyDRdNzHd+EXfeTOrxBxALJlBhdPYYWPkjQsGs0J8H8OrDJW5eOUuys4ZVgq6qxODeCuPEK5FdDIaqRhwKATU0uKyMHroTCqFKDEViWQmgFRFeIm9DQom6ofMduBTR+CNow92yzsO5Drv7bwNK6GcfJqgip/lv0WSvltOcCi/zLQSdGJ0dRLGKpFQBrKsCrt/8nUpSrdlbq6n0TfRVmoh4EQK1VTN5SBk94v740NoP+wCUctQ1cGhYnol1Br6mffgHaoSG9qKeNjD1XaHEt1DlEMQd/9WfTdoxOpvpjsl2dLqfbXvwoIu38eumqR6KHOzxCKgEV9symkUnd9vW8+lajeZ8NS+04T1e+s9/0YJP3c4+Rbx0KoayaFMryKRf+iG2q9OFFkPxFK4TWMfjSTjzrYU8ZjqM/TVP1s6OrYV5sh1st0HE3TlN/5nd/hP//n/0yno7Jk8/k8/+pf/Sv+/b//9z+SKsAt/PDxxsNjvP7gKA9d3uTycpVSMc/d//NJLm10+fuz67zuwMiz72QLW/hHwvMiwBMTE+Tz+R/2ufyjYu1tGr6A9fHt9F7zVgjyoK+SiepMnt9g+/xfccbZpPeqD6C5NdppQo6IbJjhoh5SMT0CmdAolDDWHyJd3yS1ItBmae7bw/HSzTCmg1lBe+SL0PJg860U6rfQvOYUQp6jHHeIti2x2fifHDjzT6kbI5wUf45pPEFOapyhxzYyhJiMoXFWX+D0nXXE7ALnZlxu7O7iiNRYFSt8ZvRJGrkmesMh7unQu0R1d5f/ccnhVG8nr6JJjgLTRGRxqKHxJBtomw4F83qarz0P8xIWjqsJVasCwwaOV6JDjgaSSVJ6eotopE2YGjy2cp43J4cw6OATkqJRo0KLQVw65NF4UDvG6fEzpMM22dMXGfagRI6ECB2dFEmMg0bCCi46CQ4rzLPEGYosi4RrpcEaMQtIInwkOjdsmHxzX5G0vcjGmMvOswUmzh9k3m+wvVbg56Od7MBgCSiQZwSftyxMc09pjqjVhXIFhnYzUX0lT4oGx3d2kOPLEPdgSkBzQJXklVzIbQc7AG0Dcg5jVBhjHJ+IBJNlVhGUEGSJMZhojLK8YTNgplQzgmZGo9kehKEuCButKhG+ILILuO4mfm87mWgaf/cDjCT30e5uo7Pn11mZDyFdhJ4NBw/C4jDa0MfJhsfoOpJaqGFlJdmNGq+/GDC2BPO74etDDvWwQndkFwzsVfnP/mnl7KrnVLZokIDRBq2tyi71QQhyEPTQspcwdO/KhIZnUy6uQufSZ8PVME5ePVBkzEKikyDxCJEkGKRkiNGJiMli42PTwyBAI9JMcAYUMe0IoKDckc0E4g6Qgu0qMicDFSsgPOVwnKBIqWEqI7r/P3t/HmXpVZ/34p/9zmc+p07NU8+jpNYsISTEZCaDiSfsH9c2JPZycu1lJzeYXNshccwyNlkeWNzYXJNhYTv+JbaJ8RiIAAECgSQkNHZLPY81D2ce3nnv+8d+W1ixjWhZ0KhUz1pnqbrq7ap9jvrs2s/7PN/nkba+XuX1e86uamIZJZAv6PeIEUEnswPHJrQjHVIlPBgAXalrcBIJUahTmRWaxMKzzWUiMhB9G2np9GkzgdTLZmqdKgRKdwb3V3X/blSDUja3m2ShWakET0EkYGBqsuooKDlagVYJJG0oKk1IJdl6InCSLCnb1pZupL5ugF6/IHstUghNTejFAJxxyHmQdvWNgMTWlU5pBPSzGiSl0/9DpUn4VsI3owBvwb30fe9737Mp0JdvGH75y1/ml3/5lwmCgF/91V+9yivcxjcL0xC8YnedfRWo1+scW+7x0S+e5dfvOclrDoxv26C38R2DF0SAf+u3fouf//mf56Mf/Sg7dux4sdf0bcHK24+wEpVh7AB0E3B72AsPUJUNVmowZknSkg2JgSsl5UKKJEaVhuQNGDWhpQQqlsg4ZlI9Tds5S74bUuw4dONZwtwMftBnx7EniMuKtXiNau+38B7JsT6TI5fr04wtjPFPctE6RvnkP0O4IwSFI9zJtUzQxSCHS50QwURaoXaiR3Nfk83cSb66GLJreYZ7Rh+jlV8Ef4VkbApcByO9gPQMevk2X82t0e0d4jWRg8BiGo9lEhIE18k6RyclOBdhowlqBeophHsh2U1CzDoRgRgSKcXp+gXsLtgbU6yZEWFqEaFwKNMCPlpY4PTo5/ixhVt5o5xjIbeGzEvYXCMsVTD9CidxWCfPbgxmCJD0+ZwY8j/yS7xxUOUGXB7D5NNek4HTY9iHSPqsEbOfaXbiskOO8lhnhcBKSZwmsTHJD3X286lnutyd2hQJ+Ti6B/ithETYvEVOceaswWd2xqRDg8rGHBeQnB4/S7zrEjQWgboOn9nT0aFS0TikLTB9TEJmLs1wJDiEgY2DxyoN/rJyEpnsZTQa0rIcAlnGuP8NdK69SDheIPJ2w3BdH9rsSYzBgJFwnV5zgD/vIdfmCXJD0j2n2AgFabkOahXys3D2Fp0GG9kw8Qw7+vdRbSZ0DJCLEmsAF68rs0yXqXrIWA3ifB1//nugMA+rAWL4l6jRLoy8ArxBduBGzwfm89r6WBiA70OcYgQpuZ3DKyPAzze7doWC8lbAVtgntwyE7pdNEwEYmEgKODjYiGx+X2HQJSEkJUDoNGhlM0htGPahH+sbYkJA29AdtuYQbB/CWKupYaRtvsoF0dUBWn4O5EDfeCqNaatzpGBtCKUylEu6oz1U+vsOhK4n2pQQlbQ7o2Vn/a9SK6ZDoKMgKemZXSfR7+NQgTRQhkQ5PmbiIBQYJKjIgdikHPSJpHYrp139Ow4RQQtNVhNbO168WM/zIoAoe4+bOvwrh1ZrKQChJqjK0iRfxUCsK5WsKrChZ4JjS1umbRuaA3TVk5fNSgtIchC6mvznJyBvgZvoAKw41aMohtA27jjZeuovfHMzwFtwL/2DP/gD/st/+S+8/e1vf/ZzR44cYWZmhp/+6Z/eJsAvYfzUq/fw3796kZNrPf7i8SV+4OZta/s2vjPwggjwLbfcQhAE7N69m3w+j20/95Zks3kFs4NXC20XaoegWtU2M3WC+vJ9NCcr+FVJ1y0SFm/Td6TXawx2SOy4QdmVDHyII5DNBIII5XukQR/h+pCCHwZY5iLO+iUG5R0MRQ7ZSVHGbsAilA1Mu0fkCd33mruLdOwB0twvYc9FmE++jj0U8LAZEhHTpUCJaYq88nyOe6arJEdG6AZ9/qL3MBsTD+NWLyAGPsEa4BYZnWjSXfIJKjXSio339H7G8JDAKQY0UbyNHOetIoOdJ3Slh1KQFCEa6LvsTspgvEOwnpJOrnKiGTLMNcCUCOUwEVtIfBLAo8h5+nxtt4+14zwf79uoxjTVYAYjaGBVarx6bYqTtsEf5ZvMdDxeRZUC49R5jC9ZEcfnHmd5rc9rWz/EadOjY51AeU/y2EQe51wdlzkOpWO8kl2Eqs2Np8f42m4fb+jyxmSCNzDG7rTGadb5r1afE8Ul3MilO6zx44xQIceP9XdwbKVNw/C4u5HiG0s8ue8sdM9C4zCMmdCz4WIMox2YdHSIS3+BiUvX8yr/ZkwcfGJsLDbFgMXrFomcY1xIdkFuGuHPMvvAARorbyY62AD7CEwONan1TRLbZaVYxFGPk1h7QM4R7H0MZJ8ED4yWPpAeGkJpAwrHQVRhMIYlE3IdSJ8RyF2K1XKFeORmHjmS55mFNtJ18L0cIljFXXsUKS9RKDZoFSZh8xS4VW3VHE2ypNpYWzgtCfTA7uAVQyJDT0N+0/gW9AB/5CMf4Td+4zdYXV3l+uuv57d/+7e57bbbrvwbXSVsiX1yC0GQOXez2VEzszzriV6BicUQSYQiQaAwMgU3s/4aIks+Ru+PptTvG1NptROlVVJlZHOvYTYzC6SJDpiycuhUZaGJrLK0/ViaWtUNhbYgR2i7s7K1BTgU+uup0PPDafZnlf1sEeuPn/V1K4RINflV+u0npAEIzDR6NgqM0NbqbYKubRJ/wwadCAicrEIpy4T3hLZ1W0I/EqF/ZkwWCGZm3chW9or/DYVW2frrBllXsqkJs8heW2lmr5XMkumzPmOR2bul0B+Tvf5bMQvrW9QD/J2+lzabTQ4ePPi3Pn/w4MHtffIljkre5qdfu5d//79O8KHPnuJt10/hWubVXtY2tvHCCPA73/lOlpaW+LVf+zUmJiZemuEucRGqRSCn7zy3H6NR9JHJKGlhhriyD8QNEJhE4QRmzsDaKfEimOjAxRXB8MAOGN8Jl85BY8DMuuRiapDLS3rFOqlbgHqB9R98K+bncoye/n4MJSmkHoPY5YzcS71xmsHNXULnABXnfrr+TpJimRNikX1qHylwXHRYLpzGIGXn0KR8zKM5HEUam6weOAo5F+nsBBZgzIGVHEpZSG+WwtKdzCxM8ZboMAqTp5HMkPJ2DGJGeNSQyNx5GG5AMA3TBrRr4E1ArQfYpLkUxiS9Wl8rDo0pqo7NmwcGMstrDpB0bJuovky6Ibg0vsJvJ8ewjBEKK/PcveJRUyG/f+RhOt1DxL0uY7LIQbp4OGwWL6E8n3ahyD3yr0nju1CVSxjWJuOGpFNNqYe7uKlvUmJIhZSfGuzi0acNhoyymwprJNSRfIUSZ8urJIfXSE4mfLo0ynizyz+Jb6VAj6mBz+L4YzzgjeFhIvMScbqI6EwixQYUC4h2ATV3EQbLMDKEfpNNw+UTs/eDdZZrFg+xP7mTBdXBO9kjuukJ6D4GozejkjewOpliNg5C5wlQ90BpF/R2avUn76OKRUK3APlJGPGgchTyYxAN9YxdYMJSgDC+Ru3cJ0mLLr3SqzmXfy298B7SyZDBbJ3hgetATqFaN9Iv7YKxEMZalD//m+wdnuTMNdDNz4M5AeE5CCs6LbbnZZ2aDX1w7hYgbsOGDyMRSSvH132V3wQKfOPZtSs8rP7Jn/wJ73nPe/joRz/K7bffzoc//GHe9KY3cfLkScbHx6/sm10lbIl9covAUBZW4pAQoLIbOwoLiU2IiYVHiQItJCkSMAixCCwJo2u6hm2yrt+/pRCKPkzYujpMJFAKtB03UdnDBL+ehU1JPa9qAFyuSrJhckarrx2lRxLCVL8npdJM3TA0Cb5sxegnugdYFrS6Wneg19Rp9ZEJpq1dJv1Ic21MFCk2BjVsnUNFygYJkMOgiBH6KMNEObb+/mkKdgCxp/f6KA/+AKxQp1DjwJSnQ8GsAPyebkFSHpQiTfKFhLSsQ68G58EogFHWqc9RW4cM5oqa1A9Ap4dJfeM1dvRrEkrdST5MtEoulO5BVxHIFDMB+ez/yS2E59tHYUvupddffz2/8zu/w3/4D//hOZ//nd/5Ha6//vqrtKptvFj4x6/cye9/5QJLbZ///0OX+Im7dl3tJW1jGy+MAD/wwAM8+OCDL+2NKVaYTz1EYXWDpJ4nMg0OH0tIxSonD44T12+HeB/4MfE1r2Pjkfupd0+SDCQygfUpCzVaxjkTUT+zTLNYYVK0GLEl0QZ4w1UGO0ahMoFyvhtLjuNKj4Q2lqzSbU/hBZtEm3nUOR91U8ia8XZY1mFUX5vcYNfKFGfMIV/dcZZYroFncb5kINspYimHum4FGgq6IaocajWiPELumTk2Z6vkommuHd7AJCnH6RADT3krxFGV18ppTuAiZV83WNT0fJu3OE7s+6Q3+NDrQmUSRF9X5Kw4EObIrdfYlSTMIjAwEMREDLkofMRghbhfxAsipH2KZOo27n56FwUC/vjA1+iMA50YRJ5xBCMEPMI0F501KHRhOIIqnyKSj4Fr4ETQDyzmwxpv74/zJWPAmrL4QTXOBF3eLnfRwSEk4X76KCyeyrUIRgbg9WHvIpEX8+njPW5anWKeGr61iUousla9ADP7wOlAKcXciFFrOUoLOXKJYuNcEemOaxXHmCCab0H+NEZ0nKM1wfnGHgKvyeHNvZw869Kr9KA1Ar2Q+EhKPNoCsQydBka3hZleIpav0kmxzgjUCtqySA9yfYRfoLC4RiwtwptasH8U6/wJpoKI4SChf6hL2n49q5VNuKYDO2fhYhOx9hRsXgRvCjU+h/fI/UxeOM1mDuK4Rlq8TVsR+5/NDuMOGFP63BmP6rlFZ0orONMt+vkT0B5yRQT4RbZAf+hDH+Inf/Inn+0D/+hHP8onP/lJPvaxj/ELv/ALV/bNrhK2xD65RaCyEED+RghWomVL8tikQIRFnhxDBC26CDwsZWvFFUsTUiH17KuMYGhrW68dgsj+gSdKK5UYkHO04nlZGRVogouTBWeprKLI0iqvVPrvoTKb70DPDgsnI8aZshykmiALSxNtaWllNAACiZAKgQPkyBNgIwAXqZOsqJDXCdcoFI4OlooiPXNsZfO/ptTzvKGviblrQM3VBFtJfRMtTbWCbCb6uQ18MOIsIGygyaoo6+clJRBoOdp1oJjXs8We1EF8vkSnLmZ9y7YB9kDbo2Wse5fjVCu/gLRSVKquyKTyksC3wAL9UthLf/3Xf523vvWt3Hvvvdxxxx0APPjggywsLPCpT33qKq9uG/9QeLbJ//Vd+/iFPzvK73z+NO+4ZZaytwWH2bfxksILIsAHDx7E9/0Xey3fVhjrKxx68jhGLAkH4IQGlSXBhiWYb5zg7JvaOvDDM2EwSfPW9/GI9xnGeveQv7RBMlXAGK4xFz1Na2cN1fAQooWY9Rg0a0TpLhjeDs3dcKaCecljJdehkBrU4mkM5xrqub9kZWQW5XVgYzeY+4HzCP8CnflL/HkvxfM9Rno+ayM+hDXSwnnM0ZPYe0KC4k4Q6xjWOsxGyN5BeGI/hfhaRp4xmAhrzGFi0GdJLHJyImTzSJe1UxdRC8u8Ib2ThAglTBjbibkoqDRgfWcHioE+XPRsffjpObBZg5xFMNGhstJjTO5gSBeTMhJJRwWMqphYRUSjEqPX5M3HE6akyX+e2GQwdGE5h9kTzKUO8ygUEQvkiWVFVxgVFghsBzY9MOZRvd3cuezxSlnnr0oxT5SXUX6V87LJXV3J26WHpM89dp8/H40p9SZpTnRQRQHtPBQ8aAzZzDt8BZ9ZdnDdcC+njQVi7ymKlwS+miHat0linUMMBWMnHQJsZK+EaNRQpoIbehAugpcigzuJxE4SPG7x93CN8qidHeOLow7RTcCeFOwExnQQjrnZxxMDSskKnTjCT16niaeIdTXRjhY4BtWLX2Os5WMEcO74fURqnkQcYHFiwLA/Qbr8NiiHMLcTu3McsXSKuJNQThaxhwmTkcnFMyVGV7pU90hOTRcZ7ngj8FqQG2DMglsB6gi1gZecJnFrxOwA74i2KJa7Opincf+VvaHMVD++0deBbrf7nE+7rovrus/5XBRFPProo/ziL/7i19+vhsF3fdd38eCDD17Zuq4itsI+uVWgkEgkJmQ37USm9KYIJAqBxMLDJUTgM0QhMTAgzVKMheRZj7FMtRosRaZ6ZpbfRJNsyOqPEFk6chYSlURoApwRYsPQZPgy8SXr6UVpkm2S2Yo1WUcYmnxKPdOsg6Kynx0rRCCzpGsTcHEIsRCAhcJHICngASYJihQTJTPrtjT184kvE1b0rHIkITJ0J6+LDq5KszUkFpiGXn6Q6J5xCyDUH5s5SGO9fhHr52NbkHe0imym2n4dG/o1MNwsNCxLzrYMbR9Ps8Rppa3mypRft5dvJTzfPnr5GrbWXvrqV7+aU6dO8ZGPfIQTJ04A8P3f//389E//NNPT01d5ddt4MfCDN8/yn+8/x9mNAf/5S+f4uTceuNpL2sbLHC8oW/7f//t/z8/93M9x33330Wg06Ha7z3m8FKBWfXqLiiUP+l0o+JLBoIJsFOBEAA+c1L/A15r6ULO+g7j+gyzf+GM08nms6hhy6jVcmLmd5sitjPc2WEj3sLz8LwnWfwW1/j68+34U509ugIsOg5GYaPo87cNfoF25gOnfQadSpXzHJZydi9Cd1EEr8SVGmw9hbTxFY/5L2JbBD228mTFZh+oqoicZHTbI9QNo2HDhZmTtnUheBdEbobmfsJjj1mCCohpwzniQ+6p/wEO7n2Zz3xCSowzMe/nM7od4WiwhRU8fLPqSdKTB2s2LqDCCRgGaRegYsFmB5XkoTEGQh5xi3nDxsJAYOAhcTCrKI+kY1AhJOyVKnbdwc3Idx5wBA6+vSWFcwejksJCMkeARYtEhyZ8Fv4eZdqBVxFuYQWxMcGjjVn5IXo9DjTNOShpayNF1zteX+fP8Oo/h8D+tiP9+60W6BxdZes0p/N2bUOjooBTGQMQEozH35zd5jDbXy8O8vft27lx/Nz+68SZ+8NhtWJs3QOcA1sU9LJsx6yJBUERVCjoUrNiDsgX9m6DxSpzOHHtkietVhaNGwLGaJLk5hKlYzwx3BxBqO3M6sofByDQtL0+xchqRPgRmAJPzMCJ1p2b1JiJyiCaQM0nGD4DpoSZuobP3bcR7XgnzOZg/QWXxMW5+8iluunQWw63QLe4mmhSEbsqBsy1m1lIWcibt0Vtg+k59aO5a+qE6mO2nmHzqXiYfO8t1Jx7Fan4Nuk0o5KBfh9x+qMxf4Tuq/008YG5ujkql8uzjgx/84N/6Tpubm6RpysTEcysTJiYmWF1dvcJ1XT282PvkRz7yEXbu3Innedx+++08/PDDf++1Tz/9ND/wAz/Azp07EULw4Q9/+G9d88u//MsIIZ7z+Lvm8LYCDMBC4GHj4eKQx8LGxqJAkSI58jgoXAR6b+s5ko6TaAKXtCHegCTQ39B1dYetMYTxOSgkYPUh9DQpM2IouZoc9gPt1Gmk0GkCoSaStq1twcLW1te8AMfOlFMJpRmdPL3WhWIKuYwcWQqsGMyWns3tWdAfATuPqli4wsTCR7HKkIgBCUOGKGwEHj4SQUgOHwj0eoOiXodpZN3FgCv1WnwBHU8rvUaWwuwI8LJrHQdyeSiPQb6irdg5F1xLZxkYUs/4Jjk9H00Cvb5WjEOpg8PSBHKG/rvq8vx0rIn4ZULuocm1IbKwra1YjfPN7KNbay+N45jXv/71DAYDfvVXf5VPfOITfOITn+ADH/jANvndQrBMg3/1Jk16/8v951nvBVd5Rdt4ueMFKcBvfvObAXjd6173nLk2pRRCCNL0O/+2rLIjVE0xtQyL4w5Lbsr4Ro/Ul6ieAyPjsDrQd+w7PhRXYeM81onPEY7HuJfWkI3TyPUQ2z9Na2Qfg+bPIC7OoEwPt5VDVTrEu+6FmfNw7iCILqr2RVqFHhMP3UXvzFsJOo9Rb7wCp38ti5UOyp6iHZZITMippzGjV1OnxuHzb+SB3b/NtPll+qGkt3EY0duLle4l3WGiZiuoDQFmi8CLkP0qFTp8df//Qla6pMvXwnAZ5iWi1yMaS1GGhZlv61oLUQfHx3nSw/ItQqtNWvW0Na3rQT4E14ZmgrtSpJ54dIiQOCSkmEhuTHL8z7V5znsNas27eU1yC3WGrHtDmAFUAWKHVMSEJAh8JD6R6CDzLRikuk4zLBEUpjGYYG9oU6ZNj3FyQY/O3DrMxDhn6sz3XR4h5snxTeJcE+I8DI9CZz/k+pq40oUREwzF4pEBv3d8BcNuY/RhJpjDQHB9VOHeM2dZn+uRDkaIizKzJ8ZgN6Fgg+HDaA0u1ClsFDmcTrCTiC/ZHZ7em5C8ogCzka4VGV2GrgCjou19dhVUmTAXsmlFqNTA9D5Nau7Sh8+xXdBNMWoeqgYXpqrIwj6YtMFdhI0HMOprSHuG3MIidzU3OdY7zHJuN8XefdizMe3dh7iwonhl6xnWJgUb+2dQk28AMQnh5zEXvowTLOA7t5K25ymtHyMPhC2F3dxEuF8g3vEusMdhZRm82hW+o2L4hrnRMQALCwuUy+VnP/u/KxZbCS/mPnmlc3zD4ZDdu3fzjne8g3/5L//l3/t9r7nmGu69995n/2xZL+hXwnc8pMjyo5AolZKoGBcHMIhJiYlJCHEJMnXYQ6QKA0lasCBnakLnWpATkLd1crMR6rn9NLMv501NzJSCoa/nXFMLXE8HO0lLkzzT0nurymy8EZmtOMos1grUUN80zCkdSiWVZvKxqcOnMLO/A6SDTKHOGoZIMPCxKGMjcDARWnJGYAESgzTrKSZbgNI3fW3Allktk9C2ZSMBP87Cr9Bk3RNQLELSgmHWfyyzhxkD6df7fZ/tSc7U9MTSIWAx2fwzmRKc6OeappmQbui1Gam2RseZPTzagvZn4Pn30cvXbJ291LZtnnrqqau9jG18G/Cmaya5Ya7KEwttfvtzZ/iV7732ai9pGy9jvKDTzhe+8IUXex3ffixaDC/q84sjIF9SOCMx5QROH5iGQzfA2Z4O67BbkH4Wr/MZxpprmB1FXI8orDxKR4zj228g7n0vbIygxlegNEpQaMHOZ6D6CAzOwJ4FaF7PxOYpjOkLDKo1ZhvvwOl+F5PMIkmImkOm1H5WbEFj7FGMwQTXqJtoE7AkjjMrn8JwI5ylfcx0vpdLO5swaHLg3iKh5XHuYArjp4nre1l4ZIHD7ZjEnSelCSTQcDDlLHu784juGHPpCF/mcYjXYFiCBRhpjFMjZWVB0i6nOF2bfHtIe64DjTaIcab8CtOkpPSIgSoekh7XM86tvVs5OmhzfbqfVXGBjxmXOFuIoHgeilPQ8RFuhbqvZ+9sPBwlqS6UaewokPYrqPhaMEyk3ccXqa5fosOhYYG04dIqlXFjl/0UeDy3zmZ1UYe0uAa0A8RpgRHXkd4QdcCAfAcciRq9yKW5DehUKX+5jsAkweIJFH7fgHEbaQbQKmh7oxBaaQliEONwdDf5i+McTivcgMOjuQ7HDiWkMw196uwEEKxDsApeDlarGN4aptkgLs9ADMoZhV23kIaPwcYy3to6we7XwurD9Be6rLqCpFKB0gCir8LwEnQS7F6b0Jwh9Kt8Rt5GPPZGOJCjdPzLTF7q8UR5L/F8gSfMMwSlHcSj74DNgyAXsBb/mtLFJVzPxm9M4TU3GVOSltBawvyZAWnrKOdmfx+56/v04bZypQQ44hsf3PTXyuXycw5tfxdGR0cxTZO1tbXnfH5tbY3JyckrXNfVw4u5T17pHN+tt97KrbfeCvAN5/wsy3pJvaYvFErocVmTFJQkShQmDjYWATE+AQEDSvQBi5gKZqqwlCKt2lB0dS1PzoGCCUUD/DKIDvTXAKUV1IqlFdNAQbcHqQuyCKWCtvf6jrb2mja0s15dCz1u76e6Lkgmmb041sTbNmEpS0g20JVooaHJZRRphTrtgHIy9VQgiDEZ4FLCwSSHTYIkxcDERZGQIhCWgxIxMMgs2UqvyVZaaTYd3Xlsx7otIc0s3baAsgmzNVjvQDfQ4xxkDzPUhFca4GSEWAjA1oFZicgIb5YwHShtqw5tnYuQZhZsYYAItfLtOJkaTNb/uxUZ8PPto7AV99If/dEffbYHeBtbF0IIfv7NB3nnf36IP3pYh2HNj+Su9rK28TLFCyLAr371qwmCgKeeeor19XXk5XmhlxDEZodiJxup7MeseYqFEpRHQfQ2MC78NbLwenCqMLICZ87gROv0UkW1p9tpenvz+GP/DJ58pe5Xff0TkN8J9wMT58HywdyJdeZRZHGInC6CDXmvy+qdj+I+PMvs6mFCDKqUOKBsIKIWvxu1fDcGLmPMcNpocvHaRxhxfNJTu3hr6x9zf76Imv48sSFYcMZIcgswMQHGJqi91OKACjmcpkNQGcHtTRIXLUrhJj8RvIYCJl0km87TQBvsQxgbowzo0CwtEVU70C/g9qq4Rh/ybeg2MPIWN/gjzNIgwsckT0QXRYrDCa5VCYV0njVxjCdLX8EvjmLFEwi/isoNoGCRL1ocaZeo0wAUY4wy27+G8MwISZwnqheQcz4s2TzsbTAfJAxVAVM5vHtjHyubJheUyQgjrO06jZpYgeGI7tp0HMyCJLdZp7c/0gfQtVkoJ7pTs2+BdAiMlHUMFgpLxOVNVNuC08VM8QBEEZwiNE2YOQvdEUrnXXbFZW4lz1F3iSevC0ine1AJtCUyvgCbQ6hMQDuC1TLWAY+RpMfqcBTMTYhOw3AMBnfBcougugRPF6CYI+9F5BuKIIpIhyH4C1kHMcgNiWl2sQsBwVgVvOMg1qmtd3AWFdXxz9GvVUmsPOHkD8HKzdnh+xK0G1QDGBgjUMsz/+SDxC2FykOpA1yEyTHFwkaLcK4NdRdk9QrfUd8cAf5m4DgON998M5/73Of43u/9XgCklHzuc5/jZ37mZ65wXVcPL9Y++a2c4zt9+jTT09N4nscdd9zBBz/4Qebn/277exiGhGH47J9fKuMugOanqUIpgaEMCthYCCSSHjEeEXkSXAwSLKpYLGOipKFJa4KefY1Crdz2E92Va8V6n0jMLBirp9Vgw4UxoQPnQgOcbIY1MbPRjCF4EVhjYHogNnQ4lD2iv49Kde9wYOiHmf2qToGcpYmqnxHlNNX2ZOkgpIlBjIWHjUWMTYpAIcmR4pJi4TPAJMREpYMsuCrUHb8G0FW6J7xgQqEKTh+cnrZH5y2YzOnr4wjWOvoucsXUoV0qykaZHa3acjm8SkLFyWaaE+gFOnMgzWm7NUL3JVvZWsJU9/8KoWeCw1Rz62Gg659c8+uz0FsK3zwB/mbwUtlLkyThYx/7GPfeey8333wzhULhOV//0Ic+dJVWto0XG3fsqfOaA2Pcd3KD3/rsKf6fH94OidzG1cELIsD33HMP73rXu9jc3PxbX3upWKCdnRGVEMZs6ISKggndFqxJMFYCql/7K5rXS7jx+2H9PIR9bGWx2464NC2YPKro+OPgzcLk57Xtda4Oj89C8BRm9+PIfoAq+thJj/HVmKWFh+nWEppqBHXjOBuFgOrHTRq2jzQXsAd1Nr0NbNfihs40beASbb42fxaiPBuDt/HKwWH2cy2fER9FLJ5AeTWGU+cxzABGDHBb2A9e4mJQoGdZvG3hJjoLAy5S4ZxzkU59nd+e+jyvXb2FVaPP2kwPej7UY1yZI7bXiMpLUBBgC3wzxXcAownDGDkXEPV8ipFEYlMgwSREETAgBcbxyXHcO0NU60O8g1dujpB7cAcbziZFY52DQ5drOI+JS4xLlRH2Y+KEIzxRu4Q0e7CcYIYWbbPPx/YNec3ZEeZSxQ5cblIVHiJm0RgQVxRi0UAVx8BfhAMjzPplTK9PbwdwfAjlPCyPwhSIMxWULTHNlFkszhRAzW4AEXi7IdeC9RpYPUhHYcqCcQdr1eVGf44JqkDK0bmIdK8PUU8rE0YX1s7DcEZXSrV64B8iSUp0pAmb+2D+tdD/OHRWKf7V3cholOHN18ApF/bdxXBqk6B2gTS3G4IQ2utZgmxAJU2ZWjlDOgcngy8iS2WU3yVpSzYN6Nkh+zcXuTh6DYR7tHoDWOIZJq2Q3TacKPnkznyS9KjP2tBhNjUwpIlTH3But0U0WgMjU6+9K1VXhnzjSIErSJQG3vOe9/Dud7+bW265hdtuu40Pf/jDDAaDZxXQlwJerH3yG83xXQ6MeSG4/fbb+f3f/30OHDjAysoK73//+3nVq17FsWPHKJVKf+v6D37wg7z//e9/wT/vqiL75yyVQGBgYmZhUSkGNgpBgiTh2QgqpKWQdlZHZF6+MZZZkeMErATIeoAR+iGVDq0yhVZRL/dpmyKrNkp1wrIhsxC8LMxKJNo6naZZl7AEx9JuVyk0IU1NbX920kwNNvUaLANwQJgoQyBxkaSkmBiYCAwSDB14iCJBfr1CSAhNbD0jC55Crw1DB3eZWZEwCixLX2MpbYU20URdSX3NZZu/EJm1WmhyLbOAK2np56uyJG2V1T2R6K+TWcKlhCjQ9U4qe13+5oMskExsRQX4+fbRy9d883gp7KXHjh3jpptuAuDUqVPP+dp2fdzWw//9poN88dQGf/3kMq/YVUNFAbun4fbdo5jG9v/vbXx78III8M/+7M/yjne8g1/6pV/6W4eylwqOnB9Qq0DjtMCrKTYL0N0JNR96eQgdBb4CswNJA8ZzEBj0JXR9A3kw1TUa1v1U2n9NGFYJ9v40hEs49d9jZPk4G3vGSCujWMqgg00t1yENFc1CHqxpRDeHpUy6Vpe1A0vQGsIcOKsVwg5sEPL05AWCHYu85sHXcMa+SCndwQnrAhtTGyg5DcUI0WkgKxb4RRCbpK3jLEy2WLZtbrv40/wf6gj/kSUuRBLV2WShNOB/BB5WWkU6xrPhJ5GTktY3YSyAjSJsjCFVGTPuaTtez4GRAW1zAxeXGIc8KQEGBibPIPhzq0PDbKHCndTWK9TkLu5WhzmY+PhJAZsRFEM8TGwcHGCVVb7mnqDhDYgPWbCRgBORViFt1mBCcWJZ8rr+CBV8PCqUaTGqcliJjersJw5yqJkiorWXeJBjdccA1iswoUC66BoThar1wKhhNWxMLGq9cTbSAOWc0nVPAJYH5hKILuRrYJmULtpcpwosEnCWIVEiIUr09WtA0YbiDkg8SM8j4gCVGMjhEL89CpNlxMYT2MUF0pO3MtMYY12ZqC8WiWUIaUwyew3paA6MGnQbIGzE4CIjdJnqS8oKHjk3R9VqYXoNNqtjeBJ6N0IiKpx3RxjU/n/gz4JngX2SuvU404liBMH++xXnrGWafYdKbHJSuswxQq2+QOGahEJuEd/pkq5fD+t/mwB9Y7x4CjDAD//wD7OxscEv/dIvsbq6yg033MA999zzktpvvtP3ybe85S3PfnzkyBFuv/12duzYwcc//nF+4id+4m9d/4u/+Iu85z3vefbP3W6Xubm5b8ta/+EQKGWQGHp2Vkgr03olLjUsrGeJYULKgISwaJNUZDb/a+oRC9cCgsx6LLVimYbgZmRWWTrIyrJABpokWgmQVRV5Q/DK+jdvoHTQlCM1CY0j2NyATqgTmcuj4MWZTdjSWQ3FAvTW9QytVYai1AS4XwJDK8eBGMFQIQZD6lgYWITY9OijiEnwyIaOwRzTicwVS2c8OCkUUh3Qhan3QJlo5dpxNflNQqgYmqArWyuzUar7y0k1abWcjJz7+uPUgsDObiRIfX0SQtrVs8Cpqf83RZ62kPfbEHQh6eu6pMTUc8SmnRHnwdZ0QL/ICjB85++laZry/ve/n+uuu45a7UpHb7bxUsTh6TK37qjx8IUW7/uLp7PPnmW2luPfvPUQb7526qqubxsvD7wgAry2tsZ73vOe75gN9IVg+Mg4vtklSh3yaxOYuy9wKC9J05R4zqM3dwQO3ADpBRCrILt08inFPhRiyWYM0shhLq+TWx3Q2/MKODqN4CFqyRlatTrp/D5IJMIw6Xo1bqmscT60oVIG38A45+HIMq7cgL02mBegbCHWDBw8bKMP0x8jf2EnM9FrmYlqHKfLfbOXSMw6QqQYKybp7CjUA135Y48g97RJ1vsk1RrPrDT57vAgY2wgC01gCELi5xowvanvpFdGQeVJZzZh0cBqT5CELnh5MAyMqATpFOzYgJKgZyc0/ZAKI6SERJRJCPkza8Cl+RaqHuCcHONV3bu5iwLTdPBoItlAMkBSpkgFB0FMwhPWw1yYO4eiAdVxCMrQmMNY8ZCzPuQiVqsJJ/spY4RIFAepM6NC/rgX0N3l64NWrsD4sYAfjaf5A6/Dah1oF8GMYFdLP9egjtk2UYnFEIc7/RHOPTPG8XKdyFsHWlBaAdkB5zw4d0K3QNqf4jwdHjNSRmWClB60LkHVgtYA8q5ONs1bEHiogglpC2N9Fdl4I8x4jAy+QLicRzx+C54cocQAn4QKMYPaGsl4A1arULgB8gaEyyjPxB0+xXQlZXPcIoqvo7vaQ01tsD9ZYf9uxWfsXaTtH6Q/c61O7BY9iCSmfITZ5gaVYwYb5y1EawLDWWfU61LLC6qJIt9LKUaSnecl+3Jt7h1U6UVFiDpX+I765kKwrgQ/8zM/8x1l07tSvFj75Ldrjq9arbJ//37OnDnzd37976pZeanAMBSmJVGJBVIwAFJSbCQJfVw8bBwMUiQpEQopQ62+WkMdYGU4mhhaSdYJnNOBT/5AK562qcOuZKwVzEJFOzjI6pKEADevb5xFPnhVvbgwgnJJu25GDfB9CAS0bE0G/RTWEp0m3U/1/K2rIAh0GJQBFCIYAL6Jp/oobFKqtIwBJhGOjLPP2fgWOkVZmiixodfuuZrQGwJm81q9dqQmrDULaqZOtc6jSbuFtj77LRBDPSN8udqJjLQnEVgDrZbLTOW2hjqvwchUY0PowK1U6LolI1PLyfqOu75+LWUChsRIY0SaIMyvK/VbC998CNaV4Dt5LzVNkze+8Y0cP358mwC/THDPsRUeudAi88fwW9+7j52TdX73i+f4qf/2GL/7Izdtk+BtfMvxgnoEfvAHf5D77rvvRV7KtxcDNUY0liL2+XimwDhbYP7oKP1qno3v+ieo234eajfo+S0vB25CEYN6qs8mSVHQHplCudDecRg5/D44a5NvPIzXgfC626DswViB7sF3I8f2cyIeoeHeBPXrEcf2UL24nxIpgRVBvgneCVAtlKtYxmRx/C+Yap0hStt8zV7jbvYzbV7EH3scw5rhpkvXMJkegZkiVFJYXobGfsTwEHb/Jsqda7kxPEiK4KR1iVgch6ENWDDmQ8mG9g5Yn4QohlIAuQHCkpBPcLoOyhwQTvcgrkClCks2CzasosgTk2ASMMPXmODJHW3UniegtECiWjxiL/GQsUqBHAERT1PlHqvKMVFDMILEJsKjb0kUJlTHwK6B24XeCOBA7IHnEu6J+Ux5nU8ZPb7KWWxSSgwQjgfFCQhqcH4Ud2OGvYxx94UDCOFqVbfRBmsDhkuQCIQdYFoJy1aPh/IddoWC7968hvmTU5jDok6Qnp+DXUd0RdFmQjff5t6ZJ1jbeYmCMaDs+1rJcV2YccBNtULSXYVWV6sV9YvIoATtA9RP/RUjuS7Dtddi+XOEDAiA2bTKcMdTBLcuwAM3wNnbYXME+jnwbbADBrYOlQ6KKZUdJxG39invWaQyPeRL1ZtoDf8lhK+A1RGtQDsJTG5QajyCfb9B84kacWsEg0VcZ0ixCqX9ipkDPpboMlgosvaFKse+VqQfHYHAgoePX+E7KvomHi8vvFj75N+c47uMy3N8d9xxxz/4+19Gv9/n7NmzTE1twYOHACEUQml7XYzMenAlMTFp1gpM1hccI1Hp5T7cGJ28JDRhE2gVUmR23CT8+iyqYfJs96/pZsTZvbwArQwrqa3OjqEVYlKtLBccqDkw6kDdhoIBdvYzIqn36DgEh6xGKc3Wk80YCxDKwCLOpn5tQmESCkFCSoJBikUiTBLTILGFDqhy40yJTsCTULahbEAps3HnhVZ8PaV/tnWZ6KZAqOePrcwibV/uCk40aY0T7R5KYz0ffJngSTL7c/Z6isulvnH2yJKggzCbiY5BpYhnH9/Sfy1XEd/MPrr19tJrr72Wc+fOXe1lbOPbgFQqPvDJ47z+0DjvumMHAP/lwWVumKvyn37sFl5/cJxf/dRxUrll3+Tb+A7BC1KAf+d3fod3vOMd3H///Vx33XXYtv2cr//zf/7PX5TFfSuRY4wiDXp3rtLadwr3AUHPE6zvmUWN3AHRTljbgPy10HwGM2liN0KWBgBKZ4JEl4hufwXB+pth+Xqo30M6PE9/aMDQhYmS7nlcex35h29m6PcQFYX9tMPk4mFqkaePVWkboq9Begb8IvmLHn33BPH8RfzIwNyAnWmJ86zx+NgzmPsfx7xwiAPRDZza+z8gfxxiH0GCisuIgsl166/ktesHuIZRzjHgdOVLUG1BvwLmGpQSGNYpXJojKgTEo6fA3wCvSeyOY0QFxpo51vND4kIRiMGZZmKxRqAkK7S5HoMuPkMUX7bXGey8AHRgGCFHR2kmTR5ZazMbSTwK/PfdF9iYO4W7Bpcu3sS7/SplhnxfsAvnUpkL6yOs5RNk9STkG0jPgekIKEHaY/GWgD9tbuLGFf6PU3B7XEYmFa2o+Aqj5ZGmI3wByY39Gp9/8ik2b+zqVFF7SQdT2VMkFY/OXgdaHivViHtXXP7RiuTnG7dzb2eMr3g7CEp9unsNEL5WJeIB0cEWTFd4KtfBOq+0QtNPtT1y0tBhOEYDCgN9iLQERr+J4X6Eid2rXDp1N/nTr6GaGEgEJWIac5+g8Pr/SnD0XaghUHkKjIOw6UJSxSp0mOvFRCYIR/EK4yyPl0u0zX18tXgLNF+jn58b6OCZKAJlIVbPU3vsHN0Lc5gyJcLFIqEx3WLiBpi+CM1n6rTVKEEokGaX86UYJTuQ9jIV5kow4BvrMVc2t7YV8GLuk883x/eud72LmZmZZ7tAoyjimWeeefbjpaUlnnjiCYrFInv37gXgve99L9/zPd/Djh07WF5e5t/9u3+HaZq8853vfDGe/ncUZKpdt6ae7gVCBCYCTVgHBEhaFJgmIiIkRPkFsHMwTCGx0cwuqyoK/Uz1jPQeQaxnXGMP3JxWihOREbcEoiogMvXTASyt2ppa2aQ91LOyytb7mRAwp6AXwyDSKqmVzQtXy+CZmkAGjuZDpg85gTIEacckVSkJA8y0ikLSo6sTsDEgrkK5BeUBVOq6Zikfww75ddI7JfTHfqRJuBQgW/rvWw7EQ93VWxZ6zQhw8tmMMNDr6DqjyARzkL0+ZhYWVoJOpF9LS0HkfL07Oe1AHGtSnA4g6usKOiXBB8OIwEyJr1wEfYng+fZR2Ip76Qc+8AHe+9738iu/8it/ZwjW86Vdb+Olg4fPN1ls+fyHd97I/EieP310keNrAz51dJXvuWGGn3rNXn7gdx/g4fNN7thTv9rL3cYWxgsiwH/0R3/EZz7zGTzP47777ntOSIEQ4iVBgFcIGW+ntAzwDkDtEYOAFPHAJqL3V6hXzYAfYKx8mskTn6U5FyKHEAz16NbmEEQ51kT5/B4947QgKHUVtrCgFII1AxvncZ/c5LqFI6zRxdo0UOj504gewkhpHXgA/GXwAW8WO5Bs7l4lLd3AysnD1Nf2MCkrfKJ2gcUbbLAPMtbOkcMhLCyA52P5AQyHJOvnkAdqOKWYw719xDQp4KCKIeDpmTGGMP06rKMG1aDM6kgTkpw+yMhZ2Cyj8pK+IYkrNsZSAKMhshAyKmvsT+tch69fL0x6DLlQWIHaWcxLAQy7kCty97kJJqIqz7BMKqBdfZhKd4le1eSv3Sa9cwd5d+8gdzDKfHQdn41yfPKZCzRvVjDZBz8Pw7JWEpw2jPYh6BMmCefNLm+KJ6hsOvRUCnaEFReAgIAKZ+kSDJ7QFR1uHdE8hcqNYzRj3NUc/iGgZoA5pH9wlY/PrdF46jD/bPhmbu+HfH7Y4LO1B1HeGRhxYX1Wz9yVF/HLHowBizmoebBpQzMHu8pQEaDWoT4NtUnw50mbAec/fxP1S9/LfLwLn5RYdDk3+hDx7R/HSPaiLu6Bqd+DmZI+XK/MgF3ECCRrgJfAiAOPFnI0ku9DRa+Ec1XYNMALtYXRdaCYgt0m9/CnMc542HKcScrEJBgUmVh0qYfLNDdMemNdZCtlXgw5dUdEurcE4TIYRcjZf8875+9DxDfeTraeavF8eDH3yeeb47t06RKG8XVDz/LyMjfeeOOzf/7N3/xNfvM3f5NXv/rVz6rSi4uLvPOd76TRaDA2NsZdd93FQw89xNjY2D/wmX8nI0viNg2QKqvhNYiRGMS0GZKQw0DpECjDgrIFTqRJmbSz7rxQq5bC1j3fZpwFQWUE+bJBV16u9Im1Ums6kCYgfRgmmmyaUiu8MlNA3RwoF2JDd5iT13ugCEGGOkXZytYXhDqQShn67RdDNHCRqYmQJsoKUGYKrkKGUnMrN4aCBV5B36jLGZDPQS6EIjBtakWYrBLJUtrKXchByYCq8/XwqwT9/FSqSbqZ6O/vZ8QfAEsr5lGir00FOIG2SMdhFvxlZL+DMmI/GGqybOcg6UKi64++8+M1/6F4vn308jVbC9/93d8NwNvf/vZ/cGf6Nr6zsd4LADgwUaLgWvzkq3bx4c+d4Tc+c5I3XTvFgcnSc67bxja+VXhBBPh973sf73//+/mFX/iF5xy6XkqIrUskUZ7Dy4J8ThHdnrJ6EibPhyjxAN2db4OqRfHEfYydC1EpbOQMUtNGWIJyJ8BX03DmRl11YUeYzSeYDEOGczGGN0CuzsPGDMbyfoYk2EgMUkqE9NhECpvj818mOtiHVQPyBbiwk561RLh7ERYnwdhHJEy+4LRY3L+qD1xfeR1jS3tJhUClNubFJvmlhMQwSTYU7G7QcI/h976fsxja4OfcACOnIcrB8BY4ZpJvwu3K5eFWjcX1EJp1jKbENEbIdSwmZZ7BoEdqD8E3wYqomCVemVpUMLHwiZBILrC2ZwhuBXohhmMyvij4p4GNTUKPIv+x8Bh2uo7XVHQLFmlujS+8xkd8fpqfG4yRZ4EZxii1XZrLKdSEPvT0I7A7UDoLqg7lGvTLlKVFjohDjTpLhT4qCogci03LxUiqrLNMLC5iL8bE1QBb+iRWHzkZE1QWoDYGKqeDakorxP0N7p+tcNepBvvxOIpEiBVU9yx4ZYrdPURLLaJ9T0J+L8w7cMrFPT6OG00QrtskqybpwRj2VSGtIi44uOcm8J4uM9OYw8OhzzpKWFya/zTugT8nzLvEi0d02Fq9jLtyBkQPo2AR+RHueherBmEOGpMmHXcedf6VoOb0obcSakXGBfIRDH2M/iPMPHMKP8wxbS+yYafEcUhuxGc80SLVwt2SU0cmEZ2YS90q/k4bNb1D95XGRZgbAleSMLxNgP93vNj75Dea4/vfrdY7d+5EqW+sJP3xH//xP3hNLzUolCauptDkVykkghRFREyXIVBCIDVhtUwoWmAneqwBtFJ5OQFamGCVsgC9GMhqiSTaniyzfcy8PCNb0MQwjXTnb5qlKcepVlQZQK6ur0tcqJX0ja1+rGeL4xRIwEa7NAapVosjV9u1E0Xs2IjIRCgDafWzYCtQIiPjpUQHe3l5XXWUz3qOPQH5FCZFNudDRoAz63fe1bbsggmpra3NQ5WtPUFbxLPXxogzdRtNaqXShFeiP7YjfRMg7Gevg6UTrmVOK8WDVIdjWe7XO4NRyOf5N/3Sx8uTAL+Ynenb+M7GeMkD4ORaj5vma/zEXbv4w4cucqnp89++epEjs9XnXLeNbXyr8IIIcBRF/PAP//BLlvwCpPUWqS95vFalogaM1CI6MwAm/UOvglwJYofA20lnbJkiinhT0qgmeF0D0/OI0zdA9xDk2jC1xK6Fr+K6fXIVxWKcELZn4dwufJVyQQTUlcPQbrMw+jXCsbPIchc1ugbdAmCDNwZJg2DvEhQ9sIswtkxvpEKvdAaiPOLJV2A0wY4KDOhjXpxG1I8ybEFpLCVw28iNcZbHT9HYPIPNDCEw37yOp++owoUQnBo0UgY7fdbbPa4ZTrBxqU9olcAdkuv1wSiTiAIGLZLqJsQ2KIdQdNlFSgELgYlHQoUe15xMSU/dTjs0uJj3ublbZxqXTXrUsXGSMQJzhkLlIoUowBeA6XO0tsbGYBIPHxeTiURwqWOiKgWdqlpvQCGBpASNJWjsAlNxyfOJooS70xynFlMWKhEylNgqZZ4BKyR6zfU+ThqR5mzkpAeso5QB4cWsO7OThdjUMHs5htg0EJRlguV1ScotlNNH5I5jbeSIlle0/TCdgskCqblJkJgoM4e7XENtzFJ9SDCb5CjHFYy0wBl6BCSkSHxhsD71Raozf4QT9eipcZiOYdiAwhEq8jHcsy0SBzYcl3TWQNomzfo4ye7r4bHroT2jk1o9G0xTJ1A7EYQBeKewk0/RnTORkz02yxGn528mDSV1+STz6z3aLrSmigR7XweJiz9SB2+IdfJLmJvHCSu3g1/4+988fycGPKuu/Z3wX8C79KWNrbBPbjXIy3O8tiBIJRGKEgkxJiE2JmCjsFAwmsDo5VAiR4+zjFc0wZMdTWplpJXNxNJE1utr0mcIIATbg0Ieuh2Ie5oEqpxWgi1H34BLQiiVtbqcVnn213I5hVKkZU9hw7KlA6tCoe3FLhDEem63EEPDgq4JexNUz0e1Qz0njADpQd7UyndZQjGCfKKV5lwC8wGUTCgKsALdD+jmwXN0EnPS1c/D6ENnWTtETAn5nrYsy1TP//qJtjfHqX4aRUeHeKkUvFS/Tqmpn4+UutM3DPQ1gxB6JvQEhF2ImxC3IA4RKsZwE9LEyGqVXlin9nc+nm8fha24l7761a/m/vvv5z/+x//I2bNn+dM//VNmZmb4wz/8Q3bt2nW1l7eNFxG37Rphtpbj//3CGf7Tj91CwbX4p6+c4YOfvcD/c+8prp+rMTeS47ZdI1d7qdvY4nhBBPjd7343f/Inf8K//tf/+sVez7cNrpnQP2LTfdVbiC49gLNygeYOC3//QdTBGWg7oIZEh3dxYRDind3kYOcCYaIYGU1ZSl6DlG+A2IcO2N17mFbrNE2D4kQK+Tw06voAYQdEOEQYNMe/gNjzCXaKS/TNlDU1Cb7UFRQlAaWuvsseFaC7CbM+zB6FpRE4cxvlNZtE2DSNkFlZRATT5LsO+W5Me9xDVm4Gv8DQXeUMm9zCNEMCbmuOcvr0V4jcNkQ1MGqkhuJE3uIVoUsxTAnLDaT5DN3qGOQm6DVsVGJAZOk5tLTKBCk1QlyKKFRWZ1TkZ/pVxhhlAZfTkcX1DLFpo2jxMIJLaZG0/QrWx02EvYJRHJI6Fk44JCbGw6GHwsbDCFzSNIRarNUTYUPhEAQ9oA+lDk/PHeWBZ97Ka9VuXh2bfKEBTSxcJXjG3KSWlpGTt5BWH6bUbNLf5WjLn+PAugJ/CsxLUF0GdkG7wkRjjAoWF2nwF7seJNrzDCQ2Rish2f8AwcX9UJmDpADFEGpFkp1NKPYgnCD+aoPa0h3sDkeoUiZG0UUiiMhRJRU9Nup/hdj/Z3SbPSYqkG8O6OabMPAhLrOeuxVzz6PY1T5plGM4P8Uwtx9GDsPmbmjuAEKgqG2ErqWDZowuzJ4G99OE5WnW6jdgdFdoVA8gPYfcM/8TtRZgXhSMdwzyqyHdchvyTYyuwhZt7rxwktWh5OnaBWRh9grfURFZos83+PrLC1thn9xyMLLgpSRFKYHEICGz+yIRxEhCAnxkEmhVMjZ1vZFAVxUJAUZOpxpjalInMnuvI7VSrADy+nNRoO3CQuggKOHqnxeE+jewSVaFa+tRhkFTj6PkLE2mLQX1AgSu3ocb2QyxcKGY6J+dODod2kIHTjkSikamwGak0TXBEfqGYiGrO6oaUEGT4HyiLdAjBuT4+nORiSb6+Jqwk0AYayu23ddKtBAQB/oRZanPpBCGOrxLSp1crUJNetNEfy/hZ3PUQtu7E1uT+0Ffzx8n+v+ZkAJDKqQJCrGFvdDPt49evmZr4ROf+AQ/9mM/xo/8yI/w+OOPE4YhAJ1Oh1/7tV/jU5/61FVe4TZeLJiG4N+89RA/9d8e45/+4df4P1+9m9fvH+G/PrLKUjvgi6c2+OiP3rTdB7yNbzleEAFO05Rf//Vf59Of/jRHjhz5W+EuH/rQh16UxX0rMX5bzNINu2HiMEHQJn5qkakNxdm9MaSfx1o6hlpYJJ2VMDFFUu1TOgs3IXlGzBLt/FFYdnQoibFGEj3KY5MpU54iyluExd361bVDsAKigkEyMMh1RohCRbEW0elnaaFJFUZdsGpZouYyxKtQhUL5NIk/JPReg9U16U2dQRXzbPRKpMszmJ5Lvi7JAWuVSQhmwRLY6zsY4vJZVthgQFnZGCsjcCjSs7VrQNdk6A941Ojjxynu5ghROcUb5Akq6yjKekarFOqDTmyRiBFMqqRARIjApYdFlRjJJrOYXEcNE5+YIZ8xG/zxSEo3DkGNgvlKVP1BUrUOsoDvVgkIKOIARQZEMKhAI4JOrMmvUdD28NoUVvQo3sqAOOfxP3PLHBnu4w2UQeV4hj7Ha8/wmX1nKZ6dIqnvQXlLdG1Q+Ukoz+qbDUaoA1ZEB4IKmDVwY9ZyXY5HLTbsLqt3JlCpwMUeUprEeQOxv4E6/SqwRmBuBcY9hPEMYmMDWRqBaybxO3didz1SXARdIGIUQdcIuDD5Mcpjn6WdpLhVm1YuT3+0gL38FSYHPYI1QbjTpXvzYVK7DsOWvvkwciNcugnO2NAt6vRuPwYzhVTB2HGYegLCJ6GjYCCgaCCnaljtE0ydOoZHj3IdagMwaykmKdd86l7Sjsfoni7hbslMV9eUXlxZpLv3SkNHYr7xdrJlU2v+XmyFfXLLQVzum41B2SgMIiQmKSYSG5+EAT26pMOCtgAHgHL0fG+vBwUgX9bETWb2XOlrRVilWdqx1PPDSQqDgVaCTaGtwkJqQtj1dYhUTkC7C7kcFGuwvqDnfy1HK7gWuoc+zezGPQ9wdehUEn69B9gJtROkF2o1turqv6OyGeGiq1VjbwDFGEopHDR1uBYxFEKomjBb1YnQRgyDQAd3WREMlvVztTwY9sAIoNQGM6+Vab+ddftmz1/GEHf1DQRD6rAt2dcVUIkBKtA37qxQ10pJK7NCG9BuwUBCaIFhIkSCGWnntTLR9wC3JJ5vH718zdbCBz7wAT760Y/yrne96zmjGXfeeScf+MAHruLKtvGtwJuvneJ3f+QmPvDJ4/zgRx96ztcsQ3D9XPXqLGwbLyu8IAJ89OjRZwNWjh079pyv/c0Ag+9knLnrCOqGI+BVYGOCygUDbybirIrwFjc5fOYJ2o84NHMFzKnzmOWY1TwcMCHIT4OcAEx9M7ZqkPN7TIzqTsZBUoLmTiich4k+qN2ooIQYQCWYYyl/I5fURYIRgfB7KBHqA5bVg7FNEE9CPA/dlNHaBsYmXBx9hpKxGzZN2ukawfwY7nqFeT/HyRkHg4C0NgXRKJzuYS5NIzExgUVTsTZyibg7CsdsSH190BGSYa3PcCApDmzc1CM25ij68wRWB2OYQ1ZsfWCRa7C+SVPV6FHDxkYgEHRRJPQY0iemhofPGjZFAky+mA8YGBcxKxauI8g/VWTzugpMAG5EY2yJLy6P8TY5yQwGgbBJjRFodnTgiqugWYGoB/UKoiIQhiSx4Kxs8uGzCT86TPk+5ihwnmPWKrJ7mu5cHgpzkJ9BiTLYExDmddCLuQpOF0wP8p4+oJkWfhGSTkpVWhibLmnBBLcOIztJWivY7jnUxZOoiXGt/LeeQsU9Kn6bXm8Cc+1t7BxM4iCACEFEQMoUJhviUfLFz9HxJMmITVTeD8Ui0CKvzpF3A+SUiT9xEErfrecUoxXot+B4DY5lCpLX1X3PZg9mzmAY9+HJr2I83cNoC4buDIbbZNw/jTwlmE5i6onCGNOcP+hDOKtbo8b9gJHHDZKjguXjFv5sQuxC3evjizNXeMyK+cbKxdY7tD0ftsI+udUgUm0JVphZM1GCIECoIiiLDQZYuOTwGYaSdGDCWgmqtiaq60VtSy4Fel7VcvUMsGvqzlvP1P28QaIrjYxQE2PLzW52AuFQq595NHlNDa3A2llt0Ai6RzfualXXVJCuAllg1mweNhWcbmZ2aBvcoR4ZIYU62dytBT1fk8+ChJzU1UvFUFuTCzmdG5BLdJDe3lTbrt2W/l6GgnEFwUBbkkfrQAxpF5JAq8P5ST3HG/Wz7nSl1xwGWu01EjBDrYCHEYTZc5QdnV7vozM0lNA26P4Q+ln9VBzrz0WKNDWRykOFl6uptqoE/Hz76OVrthZOnjzJ3Xff/bc+X6lUaLfb3/4FbeNbjjdfO8UbDk/y1XObnFtusGtqhA/fe4ZHLrb40GdO8RvvuP5qL3EbWxwviABvhcACtfMw5McgdjG7ZzAORazGAmNtiYkkIGhA1XcpBAmEIcEErM3B5AbYiQG2o38R13IQreMFPhNLgmBWsTKcgG4JZk9C/FmYehvM7KR13zi7u+PYyxHpXgffOgTSAbMATIO4AOZKlni0G+IF1o8LRj2Jba4wVGvI3E6mGiZrBy7StapYwxHSxEXVTGi3YSmC3hgy58LQwSHm2rTEpn2SqCZAjoI90Ha3DQuKm5AW6YsLiHIPVeyzaUbkN0YgmcRtJHTGBki3QO6YQ1sOOc2QJWxMQnqEGPQ5mmuxXOxQDutc27uD25XHHB3mwhJn9oKNz11Pj7LgPEpjfYAa5qBUx4mf5LOjA2Y2alynyihTwY4USkAuhnQIwxhwIIiIxRSxs18f8HYNeKp+kf/+yE5+btDnVjw+Nxjh1M4JGJTgvA23ZpayoAdtDyYmYHRUH1JzfajGeiavU2C0X2Mei33pOF97yuLkhAlxG5bbWFHIaCnGHztK0hDQFfQP7UGoA/Qvtqle+kccGt5ESQWkWFiYCEYwafFw/jEK9n+lnh8STppYKsYUp/CHDpRjBmNFzszMIed3oAbfB4sl2DBgc1YTXX8C+gaMGdq+WFqD+qcQ3uepri1T30wZCUFEYG6ep12C0SWwNiG3F/y+djs2OyAO6ZdB5KBVhuItQ9IvmkQFWNwDG3loORbxyJWGzfTJkmr+Hrz8Eh23wj659aD/XRsIHYiFQiIxUAgkKRJFgkGApRJkkpIOU12F1JfQETrMyjE1cTNSregajnZkyCIISzt5EDr9WKKt0AL9dy+nI9umnuE3TE0cDQXK17VDIuvHNbP0ZxVk1xkZyZQ8+34TSgddOZnN2DMyR7cETP11N9VVR44BXqRzA6qm3k+KQMnRTp+81N3AhNpabShdQyQiPT4iM/uyyELA4liTW0N9Xd220Qo72Z+NzEYdhvr6NAvNSpUm8ImCSOjHINDVcpc7mNNUq+ipQkmhP7el+0Gfbx+FrbiXTk5OcubMGXbu3Pmcz3/5y19m9+7dV2dR2/iWwzQEr9hdZ18F6vU6Bc/hez/yFf70sUV+/K5dHJrarr/axrcOL4gAbwnkJfR9WPhLZGeJc7eUGbZqmBfWsBa0QhblA2yR4kUm9aGkZSuGs4YOHIkjPQeWxIjwPrx0lWbPoN5KkW4VxDnyj/+pDrm8/SxMlHHsSXzHJ919iV7hAAxv0umhUQzxBCQndOXOMzuglSLMVeKNIpNTXSJp0PAU8kjE3gd20W7fw1Nli0gexj6+l3ifB0kZ5juwsoSf388TssUdrQMUSHCbRfzY13NWtqUJlWVCRUIlgJUeSjb0QcPLU0zqtEYk9sDAHlYJZiOGk22SDY9BqFhnExeXJj6fLz/AYO86dixpDT2OFZa5P9zBD3T2cXN0Db1jVboqYUUkLI0uMh4O2MjvZuQJG8sYpXn9EvfED3N9q8qIkfVjOl3oDqAeQW8dooq2hlsC+jfA2Ekwu6ixZ3jqxoCPPST5vmSEN0cHOTuTw3yiAGGLKAq1jTrIw2YVFqS+4TDvglnSB622onp0nrd06uwjRwmP16xcw8KxgOHuIfbgJOPVkG7ZxYgiRF8RpmOMPHCY/WvXI+I5ZuRebEDhMEDh4TEgwUWSFO5l/rYznLNB+jkCr854d5HyxJBB4NBqvYp06lZ4ogiPjWoLYOyCkddWRc/QB1CFniesfAXSL5I/scJ0mGKbQE4HqxoVLeL4RSg44Dchyeu60M5OWB7NMfAcDDOmkvi0qnBwJaWwA57ZYdAqucgkhzCi522jfC5i9MDhN/r6NrZxdaFIEYCFSYpEFxTlMDAxUHgYCBJS2uTwsdIhvf46tEfAI1MzbSiWtJ1a+frmmiNAeBCU9J5aSCDY1EpuYEOQEdSKp/f8NNE3UR0X3JJ+fzMEVkBWta24XNBkT4b6+zgmVDO7tCFgXEDb1xVKqQU1qRVi4QCpJs7TdU2+Oy29z7sSGMCEDXOenvetejBWgGhdK9O5FIw2qB70hlqdtdAkPJY6kdqQ+trWEtSqkPNgYKLLevua+KvLKm2q55LbXf28VaLDuJIEgkhbwYcChgVYjWA1hfiy0ptA4GetUibP1kttWTzfPnr5mq2Fn/zJn+Rf/It/wcc+9jGEECwvL/Pggw/y3ve+l3/7b//t1V7eNr5NuGGuyluPTPHJp1b49//rBH/w47dd7SVtYwvj5UuAxQLGheOMPvE0rcCmd9tt4BxCLv41G+kyxTyYRRt7tU5oNJh0JKVcgSfqezDX2lBegfwcyFWE0cAYSLw5GNsNu9qPc/b8ecx2A6NQJ5UhBBIV5tgo9UgLLuR9jOajqDBBqUmoToBdgpbAbB3Hcdbx3Rvx9khULqA9uRO1WEPurnDmTIjXihhUj3Pn6e9hR+Nd/Glznda1TbBOQn4FRrucjWLoFiml8/hRATwFZR+xAcoUMO/B+BzG4gZet8ywsIJtLRO7M6zNlKFgkJirENoQT0KtSHm9xjRlJigyQp5lUu6ZupekK6j2JfPVNk/ZC5zf4fJh4zxWWKS4PkLSGKWzdxnVnAWxhruxh7cMdtM35vjL/ALnZmMutbvcKXM8XByS5hJ98CLN+n9TPW9nK6h2YCQHgQHddVKnwxd3rNFbuY03Dyt4T1YJOgZyTwNECaxRWC/Diq0DX7qhrtpIOojTi9AOoFfBZZYCeWxs7lSzdJ6EezpV2rMLrLireAsDSs8I3G6VSnILb0pvwcCji0OEIsVmSECFPDks8sSE9kWS6QWOVYsMhwFRbhbTs0j7AiUdOuEdsHITxiNj0CtAVEQ6OT0T5w10+Exi67lDIWDiPBSOYV1YpZgmyBK0LBgJdZ1n2gCvAxtHYMWFg13o7YJhEc6XSoTFGVABqUjZzFu0rZRD110iyEM/ByqQFOIWpQ3F6hW9oSK0ZPWNvr6NbVx9aCeyRAiFKQSpVKQqJCABcpiARR5BF5EY0PCgGACZHTnnQcXV+6lr6d5eWcwCr7rgi4yEjoEYgN3V87QihUFLk0CUnhFWgSZ7vYFWkHNCp0WrUM/JWnm9F4SRvlGaALURrbgOsnCpSGk7sXTAsyDKo4dkfW39QEHJ1WtwJEyN6xTnUOjZXdvUny8Y2pJtBHA5GMxxtWU7HGrSKixtn1ZDrczGCfSbMDS0nVqgCb+dpVeHGTlP0D2/ItCKcJjNT9uuJsJDpW3d/UCHg3UCnSgdpoCRbS1SE+stjefbRy9fs7XwC7/wC0gpef3rX89wOOTuu+/GdV3e+9738rM/+7NXe3nb+Dbi/37TAT7z9CpfPLXBl09vcte+0au9pG1sUbxsCbBz4SxJcZTCUUWuELA2OEGQRhhWk1SB24OClNimRFQTRFmRkxF7Tp1luhvy5coxEvN66MfYFx3GmyZMpzxqGHgTMXPtNaI2tCs9OkaoD01uRLFdYrjswP5lCt0NYrNAkN8Lrg92grf0BEUV0Tc83DPzDPZM8GhtN+6jO5lbGGGxez+teoN0YRq79hDn60/wls3vYteGorXuQ7WrlYDYh7SBbyySqAmisovRCChvBOTDWTZrAyJhQmBSXK1yTb/Aw9UHSBMbakpXTzR7yNGBnk9Od0CQx5V5JiiQsoaNwKGAbeeJkwBas5xMWzj9w8gwT3LLRZJyQFCsQihwL45TGOYpchPXxfu4jpA/dhRyaZPh+BKfHHmSH2+8honFBsuzA6yjFdJcipooQmMAs0VoVOG8hL0uiLJWQsLTpDsHHI2mKA3HcVZcBrMdmO0DRTittLgyZkJowKQFgx4IRWn5CWzZpxTPMsNhbAwEJmVc/lEyS/VMgUeX9jMpfa6PxqmpCuv0sckxzgSnWCPEgmzeN/+suXKJU/Y5TtzxUYYzJmrlbVB7knzzFHNJSicusx7cgVx/BeaFeexOAYmJwCFMDD076AiwCjokxrTA24T5JRgs4UYRptRnbjuFbgL5th4RXqjDQt3hkIro7IFzaNE7NEd1yI6RguqCN0ni9Tg3togqSooDSSJCXGDGZJsAb2PLQgqFSfYvVikkKYqUmCHgYJIg8BHSRQwSVDvW1uSKoWdUe+gu3YKREWBTVwHJvu6tjbIQK5RWjU208hn5mRXa0AqpzNS84SBLcXb0fK2MdWG3a+v54TTUhFGh3UuJ0EptrL6ebI0Jtg2+o23JBHq+10Cr1XGiXT+jJU3C01STcKGASNukzSTrI846jU0DSPQoSmrrGwC2ndmQlf5znM34ltXX7cyOTtXWic+Xk7JtEJnCmaI7kDH1axcr3QAUJhCFWhkOU61uZzZuIeTXReUti5cnARZC8L73vY9/9a/+FWfOnKHf73P48GGKxeLVXto2vs3YUS/wI7fv4PcfuMAH/9dx/nrPXVd7SdvYonjZEuD0fBd57Sibt5U4cKaD4a/TdDbojtcJD++hEzQwRtsYzQ2sviLx4Jp+zLATM5ACIS7pMJFokVr3AqNBiWHQxh+ayDJUqorhoTKDqVeCuxtaEBd8vKaL2b4W23+c0PSIRmZgM4X4Irb1JGYzZndOcbQxR6k3TquzgUgXifubrNablC+s4Ngmq3ftZXSQ0h79Q+7/kkWdfTCchfQVMNKAwWMwEtEohMjCALW7idpURCuTiGCUxLL1QeuSpFft8fRIirmxi7jUhWmD4uZ50uEc/rzSyadnY4xhGSspcYlRDuAT0WWCEvP+Ho7vHzJ//iCtDYVDkfMjLdLcNOLkLOJMDenYVLt7qKmY7yLPLhw6rHOmvgbWRVjv8tj0k7yutYO7Vkb5+A0dVG6YzbzGMGoB43B0EoZfhuEK5A+CMadVhIsWQS/HOcNkMnFpTW3o+bMLWY2TZ+vAFVHGuDRECkGhVYToIMLzeas8xE2M4lBEYBER0yHlVua4zZcU8GgTskGAQAKCHk1mqLPEOgMKwJAeBh7LPJq7RPvG32O+fA7rr36IIndy8fYmSp5laTjJwLwbdeZWeHoMq+dhIxk4RaSR6jAchD6QGok+xOZ6sGsJrBOYG8vUfUk+C0zNDbSr3VcgroOeDbPDCLcOl+qCnihQbA0o06Dn2BhRgCwm0I8xgyHNkqSvTJSfYnpQ7mRn0yvCgG9szdt6h7ZtvEQhBNgWMkmQqUKhSZbAIKaLRKFw8ajjElJUXYKGTRy4ULX0vK3Zg0DAeBHqUzqwLg3AG8lqieIs3ViA4YGX16RWtbOMIwn9gVaQHU+/14Wl64wCP+vN9b8eEEUDnJxWhAc+uA6M57VamgDFAriJ3tPzbjY7K8Ho6N/yOVOLuuZlItoFswOioN016yGELV2tZvY1aTcyqzN9HfBleZnlu52laRtoq5SV3Yhc18R1MAAvATIyHeR1CvWYBT1Hj7kqR699828Qa0NBlOoAMdPTarFKAAfDkDhWQhRmzugti+fbR2Er76WO43D48OGrvYxtXGX889fv4xOPLvL0cpe/eHyJyYrLueUGu6fh9t2j2xVJ23hR8PIlwPVroFekN2vQ2zzFvkbI+YLCHxkluutf0PQrNAdPYna/hHP2KSY3eswPFCUTxhYVtc2jrNsXEPFXyRtn6ZMnULC7F6McOOnupVv5cVi8Fc6ugExIutBVMfmF6wn2PIJjPUXkdCHsgSvJLXYZDyVyxCYY3oB/wMdVD3LAOMtJr4RpDen1HJJqERxJ0BplZHCOR8p/xY2N9+K2IkJzJ8RVqDUhv0hYEroeo+fDyCLDXI7ik1VKrZRO1wHRRMWK7s4GzslXYKg10g2ftJ0n9ExYzul6DGsdO5zkrN3ml9yv8JP9HbyWKpCjtj6JmHqGaSJ6xijn3S7hBFhP55k8Pcq64xFZMFRdelaVo2nItWoHJ2gS4ui5tU6FYM8I926s8461g3xqY53+9W1dL5KcAsuCgYHRmUJOtkGMAxf0f/t7dH/yoSHyKwrb97UiccYGp6prOYIyzsBj16pL0S9x0jLJJyFT/CNeGY9zCxNAXgsTJAQodBIXxCiWCWkTkSJIMbEAgSSkSxeDCEWfmICQ05PnWD7wl8xap7lw3IM4Zn80Qu+pMTbvvh24BTZc2Mzhhi4eOQJslDIwUh9ZlPowbGSBMSKEfT2YvwBrJyiHPYoCfFc7DcsFXUVsTEKjAmMKRhItILWDAsooM3Z+wEyny8VKl0oZ/AIEEpwCrElBJEzyKsXr6XsO9SvOWXm+Q9nWPbRt4yUGpSCVKHVZOU1BGCjDwE4NTBQGPpIuYGCSRyR53cPrJ9AX0DbAyXp63QAqAvK2VmzjUPfhKh+sWNcM9aUOgkpSTRaFAMPN0o4DTXKFBTgZQRaZ8pupr1haSZWuti8bmaI7ZmnLtZ9m2QGmjno3El07lMu6gJFZp3CqSW4UalW54Gkrt51dJ1X2mugdTod8mXq9QfYeFmS9xug5ZkNmyq4A0wYvp+uN0jTbvwLA0CMrQ7SCHuc01/MjaKf60Qj16xQYmghLMqKdopAkycvAAf1N7ZPbe+k2tjZGCg4/9do9/Po9J/lXn3iK9Nngu7PM1nL8m7ce4s3XTl3VNW7jpY+XLQEmljBzA3QbRMUVKv2QkXVoX9dgQ27C2DWQnyb1juA7X+Ji7X8hH1rgjlpCEsF8cJZN5x4Mq09FKBAeIy5cTATLhsGgvAc2Img8A5sziJ4PRsTAcKj3pokffiODW1b1wWLfBBin6Q9cvEpIs+Oi9hvgrpEe7bG8DsocEgiLNFRg1yHwaCbX0jY3EPPLmN2nMaIZGPFhWIXypE5PHrpaCbUEuD7mWRs3TfDNFPrZXJltgzkgun4Iz8zBICR0JNZgGhktkRRD6usDIhqszzRhsMQn/CqTaZ09mNzi7+fB6FECkSI8n3A81fO24ThJMopS61iBRT+3iaobnG01UYM6I4yQ86cJqzXIL0HicPS6Mq9Z22TibIH+jiaccmDkWhg/AVIyFiuaXo28OE03ncI8N0JSy2P6JrJ5joXK0yzO7YbCLmiZMCggQpPRXoXva1Y4IifokPJkMsY6HQ4wwfWMIhDEuASo7Pir6BEj0UfgiBgHSYwA8sTEbBCwQMIJQgJSSggaY20WXv8MxvASl5oeReETzH2SB5oLhGUP5vbCiRG4VMLojuPGZVJSVC6GOR851oXAgtjSYTuyDWMJ3DSExlnM/jq40AJ8IZhLFbkQhKEzZDoFg9XAwwmHBBHk4iGV1oDSKUW/AbV5qBRgNoJGT+fcyEgxWY+QBtSGWkRyO1f6hspU62/49W1s4zsEaQrPmqATlGGhTIGTmpgowCdFvwksShhJEYQLQw+6tp6V9SxtlYiHMG1CzYARM0stDnRIlJtoEtkXmgBfJpSmocmnTCHKgqYME4zsewvAdCGJdHKy4UCSKbtVS6dHh6HuBw4N2IwgdCE0gU2933smjFiA0r8LLPS8hOtnluoYihI8kc33ZjcE5OXXxdQE/vLrFMRZ4rTQ6xYGuC4w1FkFCLBsvbaoA6TZdal+fsO8Vn/7CiJH9/wGgV57U8KGrwlwKCBK/gYBTlCpItny9md4/n308jXb2MbWxmw1B0AqFe9+xQ5+/NZRNmOb3/3iOX7qvz3G7/7ITdskeBv/ILxsCbDR30T2ejDIETdSFp6A9aUqxVMBm//oc6gbd4OYhtwMFN6MJGRl16O0zzxJzlJYuRh4hKR8mKEsMG33WMhrG2plLcWXx7HbjyGmHIL934/q70AZgsJ9JZIICus3Em2cR1x3L2kZRPMSMsnDMKTv16Hv4mw8zmx5nU0gqbvIaD94fURrArUxA2mM3HMSUe5wQazjntzBzguCxfkciTsGvRxYfRi/F7G2CxUewGsVGGLhJn36dgtlDrS9rR9BrgX7cnrutJMSyxQzGQeWCHN9lB+B18PdGGXB7PMH4hw/l3gcSvZRuHQjI8qikipOjV9AtSuIzTr68FTEMtskO/JgN1iveJw4vsErpc0tfZPPeQdQdROigwxKJf6y1qbrr0GlB/s8GNZ0KMp4mWuMlIXlfaxfew7zdMyujRzO6jSTqckFs8tFp0hiC+yFIuawiLtZ4mDg8T3JBDdSBBwkkjnKDBnDQiuwBg4Kg4CAmJSQhAiJJMUnQWISI5CYhCSkwCkkR40eK5VVxMDFKxr0viuECUXavAWCMwzH1zAHXarFB7HKgkuPt0jX9kOritGzSVXMsBaibkrgSKDnAGUH0jWcsyeQwTKJdxuEFcTqOVLDoN93GJoJsesylD4tVweArwmHhjOOrJushZdImgq7ISkFkM9D2IROCbpod6UdQtKC+Tzs6GsnYtKAtRbI7pW+o/ro/pO/D1svuXQbL3WIv/FQQErXkFgKXGUjaGES4ZIjBGLpk7YlBEV011iWuuwJwIVYQAcwc3rbs0bAGIDKbMg4ukrISsEUkBuDQQf8DhQKmjgKX3fTKwVpE9wqeAUIytqubNrQXtRkWI7ou1UoqCvohfrnHDDBl5r0FrME5yJa5TWFVmRLlk6f7g/03K2XQLGfrc3UYV1BX5eHq6x31470zVSRhWMJQxNVfCDK2nkSrXyHXkakzSzAS+pEaTz9fBrrEChIPGiG0Eq0LVqF2vZsJfrmghKArX/uy2IPeb59FF4er8M2Xs5IpeLXP32Sw1Mlnlnp8edPLPFjN9W5cb7Gf/qxW/inf/g1fvVTx3nD4cnnvV20jW38fXjZEuBK3KMlImiuI4/12TxZw1Jj5B7x2NF8kJUQwpv/CRQOQrMI/h1E18zw2GCNG/wVWoATnSGuTLE5Ns818knWJOxcMTnlwGjpEvTAzcOy9RXS18TwpQGB3IFJBU8lqHgPcuwUxvoyY8NNOtJCFVxE+5VMf3EXrenPkHNhnwvdnM+FuEnsvY2xUztozC6R5ksQ346iA2PTRF6I80iZ0eaQhu2SWxynbz+ETJexG6MUl19FNR2w4gzIxS5CRqiShJ4FVh3O5WDEAymxYgszyePnQqBEf7YFm7qPciTciTQSnp5oc2LZ5C6VY6oxzU4JpE2EG6DEBNIP6dIidiOSioTiEFybyPD5n1aLXLSP66OUp78WsrLPga4LEyHH7xTQBPpFYAC7QmjYUOgztC3qvsdpdQSqa7RbF7kr3gu0CCyBUnsZWczz/cPd1MlRpsQcOXKI7N66IkWRx0KS4GBjABEhbSDFJCAmQLv1QiQpJnlsIiIkFkMGtJE8XGnQGL2ISmIojhHfDFzYgGYJoh6Eh4ir05j5J1DDFmvDHGnNAeVgD8sIZRLkB6hXDODgGfK9LzHRP0skhpR7PQrNmNNWmc7endB+HHOwTCLmKZfOY5Hiu5KBUaYd5ejIfST7ZyA8DeEGzTDPxMaATgFGB2DOgb8D2nntpCwMoJeCUxBsSpMlG2ZVQt0CS+pK6StDzDeuJ9lWLbbxnQb1N/4rESJBYaGUJCXFJsEgJsXHyQKxuoME4iycqSvAFVCSWoW1hbbvuo4midLUlmIVg4r0jKvl6BlhRTYTrD0mupJYZQTT1MtKQXfpxpCE+johwIj0m9RI9OdSoa/1suAqy9O/2Q3ARZNx29B/x0SrvU6WnnfZ7eykes0qS3YWsU6lFiLrMlbZWlW2XqnV3TgEoizgC632GpndOTV1GnZi6HlklUBi6hsFqaVDrroJhLEm0n42Axyn+vsrA61IX/7ZLwc83z4K23vpNrY6Hj7fZLHl86f/5x38m784xonVHr/31WV+ZXYCwxD81Gv28gO/+wAPn29y+67a1V7uNl6ieNkS4ELk00oEVryOa1iEagpoEWOQu+Ay/9kvcWZ8DHXDHGyOgNwNw52sH7R4cOFPEMEZqmFEEj5Kd2aO8xf1ueSEbdA7UMRLckTjeWx7nXQiYfxLf4TVhHX7GmRyE5HIgeeAexhhNRiPFPlKzEVxO/XBG5mNhwz7KTkDQgcGBYt0sQrNCdpjS5jzf0G64yYwR8DfhXN+F/bGJoFwGO8XuKFXJybhvroD0iEumrjDmGY1IpjtUD5RpLCyA2NVIsOYXn1NV1aspJBTVBOPnUmBiwOb1sY00UgP2AQRsDG9SHFxmnQg2WATh5A3xDPchct6PM3I0SFBUCPvF0ixCIwhcm8FvAhiC+uiZCSucokWT5s9vA0Xu+MRO1IrDlNDqOfhrK2DXyptzHYfkTvJKWMvqvAU041TFDZ9FseG3Le2h/7MKeKZNSpnruWfbdzFq5jGxGAAmDhIDBJCFDYeDiY2NfL4SEwUCosYRURMQITExCIhJMbBYUhAH4ViAAiesSKaN11A2U1Yn4U9mxjmlzA7HeLmIZgwdRpV/0bCI3vYTP6McEVCdT/GM2OUEgfDiGnctAm7z1FZ+lMOD89hdmCzps+GrVGHTulGrby0YhJrJzi30Rh5hT7MxiW6UQ6qNuQN3VPq5GHkHGE0pGQO2HAMVicUnbpLnMQEoUSmEFo2QaUEuQqUplgVPuvRCa53hoxGkFxZBDT69PuNDqnbh7ZtfKfh655aQySYJKBMBBJJhI2LSUrAgBIFbJWj31RIR+pguhUDpKHTmC0AE/KWtkqbliZ6mNranDY1wbQLmjzLBFjTMe5GZpsWSl8vpH4rJZaeD5Yh+AHYeW1f9siSpAOI83r2t6sgH+uv4+primgSbAit/BqxDpsqFLJwqSG4WT1eAZ1cHUsdhuVFWtkWRW3RvqwEG6Z+fkmkLd7hRtb5i1Z0bVenYnejrMYpp19mqcCOoR9CN4a0rMOylhvgD7RK3El1tVOQkUBl6EcSvByGfzM83z4K23vpNrY61ns6hOTQVJlfeMtB/vHvPcLHn1jjJ187ZOdokQOTpedct41tvBBcdQL8kY98hN/4jd9gdXWV66+/nt/+7d/mttv+/vLrdrvN+973Pv7sz/6MZrPJjh07+PCHP8x3f/d3X9HPFZ6Cao+CscSEnRAJRaLmSEWbQBrkTxTJHz/B4GAC5gCUq9Mz3TfQu2k/tD/LoPMUoh+RBmNYy2cY9yKOHplG5l/JsOZBdRWj2ae8fOr/Y+/No2W7yuve39pd9c2p0/f3nNs36i+6SAIkkOiCbWyMYwMPeLaHeSE4IdbLs03iGNvDMe6GQ+xgiJ0Q2wQCwTExMVgYJIRAHeql2/f39E2d6mv3e633xyoJBBLSFcYC35pjHOlU1a7d3bPXXnN/85uT6cd8/JzBenwe1zxEyQhgrAgn9iD8BykMwFp2BHnqpVRaZTLkkEGFY06AEl18NQn1y2Gsizn3RQrxGpvdB1GVa8kvHODQmQFOO+tcuOkJtlZHeOkTVxACI9UrqXWHiKMpVidSMB6AlcMRFXZ3BklosyQ8Uo0spQBc6VLNrLF52QWs4x2m23OM12c4HXTpDCkIQuIJk1bnAumGIlIu9/AE89gUKGMywo/UX80K6xQYxEdypLPB1iMBUbZLuZVlVxCzSw2QxmIlX6dFxGhziNiPqF6A2AxgPoHyJhhLUA8QdoQILWoDBkLOksmfp5UYEI2xTaVYb6RYMyrsacxyJUNEJBjkEToDBJMEhyEkITrlUqJIiEkISQgJ8RBIYgSKmJgOIWkE4BJjoPBoorh/6AHO7z+Ks+0BIi9PsusGsmtfZnttkWSb4ry5jCt2w+RLMMPHkc4kfuFHwdiA5CWY7RHShNRHOlh772JP87NYrQ7pQM8hV5IsXWsKmR8C4xqoZaHokYseJ1XfpJ3eQTJVJJM6h5GqoloN4npIUMijhkegLYiyac5NCCIpOD1TxmgaDHRrKAxiZSMHpmFwmzYJy3gQ+7S6DptNl0IO5BCweDFXVJ8A9/GDCguFRYyJaQYgE6Q06NLBJMTBROKQYJLDJzAyhLbQ0UVNE6oWSEv33xYUJJGWII8N9KqhSY8wKujmdUWYUPf4OgqyAtLpnuNyoPv/DQE5obN9paElwUavVzdAO0yn1kGm9bazNiSq93ukK6yhA9LV25U22Gm9PzLoEeK0ziEOA2205YRghmC7vYxiSxPfsCdhHug5O4dxj5wKwNH9xEkM+Yq+RyoLcuobjtApS2+3ldaGXV0Dmh40FXgmbCTQiXTlV1qgUphhgFIxSiWoS4b8Qp8A99EHjBTSAJxYb3PjrmFetmOQr53e4ndvO8Ef/1/XcGKt/bTl+ujjheBFJcCf+tSnuPXWW/nIRz7CoUOH+OAHP8hrX/taTpw4wcjIyLctH4Yhr371qxkZGeEv//IvmZyc5MKFC5TL5YveduArSBLa5VmOXa+oxGfpLtkURcC2dhZH5UhFx3lo9Q5U8VrIDoBThLYP7SmIfoKk8krIJbB0mEZyjNDcQsqXQvFGyBwGDHZFGxhGQnoGwlULK85hEOMN+Ig1QelICe+GJbYKgq3ibhjNkxEeDnniXIIxCGNSsqR8glQWkZxhTJxhxR5AMQhnc+x/aBsjMuIrE/fA5gmS2pXUuZwSiv3BNM1gjgvCZTPdQhkhZieLI1OUMTCAmsrwT71BhjBYI+C2ZsyxyWVW9txD5jGb6XAnJXeSpLWOX5pGnDSR0x7eYMj/XDtLMvxFZmtz/FLjtUzQ5jIsJpnnKtJEJNwFLHcCVGeICnAjWbZo8QQxXmhSjGxmiWmqgC1jXU/urBgqElQeghRJt0hm9RqKbpHh5iCddp5iGPNW7xAv5wALrWm+3mpzBXMUKWJj4lAgjSBEYWIhCeigkAhMBC4RPhEdYhRpTCIsFIIEQYoIcPGJkIQIHssscfiyh/Cu/QJ5o063NY0UFqnuF9kvVhnIKh50LYI0GK1lZLOL42zhnx4nu/QGVAE8M4/ZjdkquwTXnyW3+hXCSNKJ0nTrGTZUhXb3BlTxIIxcgOIFPXnttogKJhV/jVRzjVICJVMbREtXF5uXBmu0020oBWCl6EQOTiYCU5DCw6vkCNUwKrcD0pO6UiPqsL4MWRcj7LIS9JylL/qS0rX2Z8cl4WDTxw8qFAgESsieGVTS+4sVKDxiPCQuJh6GymiSGwrwTW3qlBZaAu0mupob97J6hdGrmvYygSNDb8/o/ccUvd5co9fnqu9LmvT2rifRW7fR+4liINHu9jLSZnmmo8knFqQiLYsWhnaZlhJCpc21THQl1zR0lRoP3bcbf8Oky+wRbQMd56QSvV9mL7uYELB7Sl27957Q65Nmr3fX0MenTD1+KRMCpSOOfLTZVVfpKCk30e7acdKTOwtMCVLpdpVLC881jkJ/LO3jHzuunaswNZDhj798mj95+0H+zT/Zyw/90df4/OE1Hji/xX/+ylmmKxmunavw3C0DffTxzHhRCfAf/MEf8HM/93P89E//NAAf+chH+NznPsdHP/pRfvmXf/nblv/oRz9KrVbjnnvuwba1UcS2bdte0Lb9VApyNnJ4L83pQ3ilLzL42AkKDRg63iXxQ/IbPqfO/Deak3Uo/xNYV0AaYltnG3ZmQBQQvkeUUfgjWXAug6iB4T+OFa3QsCWhKVjZlabT3ElYnkPEMXbDovjgINg+eatKO3CQ0kdUP0ta/WtiuhQym1xJk8441MUWwdVfICOquHWFPFOFTEwqPEjGS/FAapE43wUrwW4NUSeHRODi0qROVmVw2gbJeclcfYD5JE0bcBE0aSMJ2cscV5Bht5fm9082OL23TtmokmWKzWKbuebVGK1NhLRYI6S2w6ftbULY4szgFl9tblFSAQEDvJ4MeVxSKH6MUc4TYpPBRJLGJU1IkRw1P2FRmcxicdioEu/ZgikF50YxNwYYqKUZjwWXRYO8NNlPCY8BCnjNQ+QpU8JBAmMcYB8SWze0kcOkgQc4T/qZEur6p1bkARExIQoLmzQWEQk2Bi1CPDps4pJg4mDytcqDPPame0mGTsPaDpqkoTZNLv8VdqsVMjl4KBCoKCGzlae7tgeYQLTnGAtexnhUId7Ksk7Apt1AHohhr0/31Ms5EeYgG8KOMfBKsJSC7AIUHob4GGYzQnkhA8rFCnrte56uFqeFbsPLhDCbjqlVazSyNq41RjJYxMvb4FyNN1IAowrGMKiKdpeONrHOPEi+uoITJ3h2TLcFp2PYcdEmWCF9AtzHDyZiLGIsCX6vb9ckwCaNIMHtjaK63rmi3ZejCAYGdFSRBeQcSBmwCuQMXb3tRJBS4NhQ3qb7Y12vF0dk6adXOJogNrd0z60DtAKQAnJZNFs0gWKPLMcgOjpDd9MDRkBkelm8tibBMterypqQzmuyHlf1fjgW5Iu6Iit6cUNPEtyuBySQqUAq1FnAXqJ7lzMGxDldMVZN/R1lQpIFM6fPQexpCbVvQj3QRNiqaG+HAGi1oRFD3YfNABoRbCbgBtoN2oshiBGJxLH0rsWXSuvvU3iucRT6Y2kf/9hhGoJfecNe3v3xh3nXxx7kn904z+v2DvL5o1v87J89SDuI+fDbrsY0BFL2CXAfLwwvGgEOw5CHHnqI973vfU+9ZxgGt9xyC/fee+8zfuezn/0s1113He95z3v467/+a4aHh3nrW9/KL/3SL2Gaz3zTCIKAIAieet1q6Zl965rdMDKqrXDbEWRL7JyEzCh00jH2qRj7PFw2uMr9mS2isZSu9jZ87ZKcTkM3gcRFzedZUnuR7VlQBxCb/52Z1leppCXJbjg6MEbU3YZ9WR0eXsRY34OIFRUstsptzEyM17TIlk9jnc4QyCIWLn6uRLC9oR/UrxTA34u3Mo6bPYdwH4BCGtaXeHj8PJ2pBgx6iOoNTLrXcri4RqvUJYkCaKeZ6ybMhhGFzRwDOAgSlojokBATsoaFgSCkzTYmeE/7Rv7DsYT5YJxWqk64/zzhwweYDXYwT4dWLeZvjzbomg0Yegl2J+GMamERU8YkpIIiYIE25xFskcYmoobHOm32M0wJg1vUNGfpIBFsk11q52ZIFiW5zQqTUZrLyXElOcbJYhBj9v5fxKGIhQfkyePhYROhiHBIkSKF3XNvNlA6UYMYnwiBSY2QAHqE3MbFQxCSILHQJjgFQmJSfG7yLo6+8S6srS72316FX2rCtjNQs7FzNTwT3Dp0u3mi8CqSxmsw5CzFtsk2t4LCISCgToeABDnUhplFqDXAKEF2FbIB2DUomjDVBGMDu3aKXC2mLGHdE1RQlD0I02AUdOth2NbFoSgLZWB7kBC0E76ak3RHbgBnC5IRyA9DI9AT7PgJRO04heU1Zs60MWugMtBJQTAIpKBTAh66mCu6Z8DzrLjkZrJ9/AAhkT0Pqp7ZUiIkqlfZjIwAQ7oIBJ7R0FG5SmpS1y1CkoN8okln5Ouiqis04a2kYTgLbk8+7Ee6N9eywCjrKq+DJpqJ0lbsYVeTUzMDiQf4OtbI8HrVXgUpCQWjJ3FOIMxrQooC5fYqsGbPyKpXvbVtsC0td1aRNrqSHS29tpU2HpAREGnSrBIwsvo4iHRvcBJpBW6U6JPmP9m7rLSbtLIASzs6y955aLraX0KiPxM2bLah5UPHg3bcI+I6+khJg0ApkktK+vwknmschf5Y2selgNcdGOfDb7ua3/zcMd78kfueer/lx/zsy+b6EUh9fNd40QhwtVolSRJGR0ef9v7o6CjHjx9/xu+cPXuWO+64g7e97W18/vOf5/Tp0/zzf/7PiaKI97///c/4nQ984AP8+q//+rd/4GTAr2ujkpE0sVfBD6AZQi6EyoKOhHHrCtQy2A7kpH4qHhe0/M1OwO3AsEscvBVWxiH2sIJzlJVkxIHjsUXkVLDrVXZbZzmzdZKy+6M99+GEWCT4FpALGVYu7cw4roAhVWL41Nt5JP0xhHBpnbsBRl+J2r9FKrwTGSqi4TTBtCQYPgZiE+IdjN13A4OJ4tSBR0j2BmBXKP9Njn3d3YRExChsMizRZsPYoJ1zUUbCl9uCgmxzLWkkHWYpc3P7KorYbJhHoNCmll5kIMhSJ80uYH8H1oXBfNdkLjaIGOABzmKSxcVjAIMtcpxgi3U2KTBLmTQZAgwk2yiSoco0bbqUOMQQ/3RjAEGJNCFpZE/C3MUgwKFEGgMTgwhB0IspqtMkhYlJChcfRYRCah8ZfBQmERFdnbhLHR+PmBQWDgKDAAvtshoSERKSUKdjBnx27jYu7FmlcN8sr3vs5dxTfJiVyj3IpAQDLt3VAdRYk8AURKUdKHELo/VhphomBjlCbFx6kkUS4kwHrqxD6iRsHYZwSWcReUO6by7sYKQV+U7IhIpJpFY8TmQVSwpODRZRmQkMM8DpNhh3WhS7iXayNnVLYrsLBlsQtaEzAOUtHSPlhmCfh5VTFKqrWBuKBVJMqYDUFuQsPV9fS8HiRRsrhvR0nc+C/qStj+9fSKUJsIFCCVBCoXo+AVJIlPARSiBFm6ecicM0CEtXPRuh7olVsa68RiYQaSJbyvciglRPvtyTRWPr6qrRI78S/V2p9Puil+GreuZVmFpibKZ6Ob+G7i2OFQQZTcpFj4grQ/fxmnFPhm3oeCPDANkFAl2BVn4v8tfQ7tQiAmRPhi21dFv0yHDU6ydObH3McU9aLRJ98jr60DB70UWJ0orebqjJsWFrWXhiaFLc8cALevJnqY39er3F0SVJfuG5x1Hoj6V9XCp43YFxXr1vjPvPVjm7ssVjaz6ffniZ2w6v8f+9djdp+7nUEn308ex40U2wLgZSSkZGRviTP/kTTNPkmmuuYXl5md/7vd97VgL8vve9j1tvvfWp161Wi+npachFEEaQpGFTIjMmJ6ZzpC502Z4FMQb5U+D6oDqbOjuRlI6xSNowUIeVFGbtk2TWHqATvBPS+yDxiIy9LNmLLFsBW6WAdHyOGS9gwpMsWGtY+Dj4JBiIMIWNTcEKaW6l6Oy5jMA7RenMMFeHL2PhkTHOGSdQcw8jCv+ZzKNVjNE63csHEZttiE+jWktQyiKWX0a5Oc5a4TRJ+uvgnYPwZZid1+ORZoWQVRFg4NGx63QmLkAJ8MZYEy0+21rjuDSoUGQWk6/ZbXIqIePaiFqb1sxZzp+cg0DnYg4iWDI2uS6+mhuZY4EWipASRUpksPHJAi4BDRK20+UVjOOhyJOiiEGGaXw2KSCAGAMDiwSFjaRDjImFhU0BiIkwcQnxiLHxyDKMQuIhiYiJESSYxFgEBL0YI4VLTETc6+brkENHHIUYOBgEhDgAKDaFx0PZJR7cczvtHVWcw6/jxqP7KKmExvAKciIHQQGiUZKmQBUX2Vzfw/DJNzDc2kM6gQ3To1FcRtohieUSDDXAgmS2CKUnMJpfxfGr4MQkKCK1iRlJhBlRDBT7AELtpbOYhaCk56CJUChhkuSnidIznJF1Ms3TpJRLx8oyZHvMmYpps8WxZgeVHgbzGPh7oJgHVYL0LroioeBsEIzYrMQRxXVJygPXBX9Uq6QvDi58x0S+S3VC28cPChQ9DyYlQJr4htGLBnKfWkIkWyAilJFAy4CUC4UIFixIp2B2WBNHI9Y99vVAm9+NDeh4JDuln4VFSscG+B1QHe34bCgwIygV9HbdLTSJ1o/y8CzwbO36ngjdQ5v0TKcMVy8bG1DvQjYDpZIm0QbgxEBbH6QjNBk1HMDVA4uvoNvSJDiX0QNBHOqkArpadm2ndUST7ehtSKmPMYg0gS0XNH9z0ZXfTgRrTV2ZDtGOz50Auj54bX1zbQUQhRAnGBFIbW/NpSvzfa5xFPpjaR+XEkxD8NL5QXaW4MeuLfPV01ssNzz+293nefdN21/s3evjBxgvGgEeGhrCNE3W19ef9v76+jpjY2PP+J3x8XFs236a3Hnv3r2sra0RhiGO43zbd1KpFKlU6ttXtrmhMxLz27S02SjSjG5myLgDmenQ2gNtYKQE5x1JTKDJspXSsRBdG4KHKVb/N2XZJGh/lmjiJdA5j9FpUGtOoibqqAFFulMl5UiiBuRSLh4WaQw6ZDCCgJZ3A2VzBawR1PYKsf8XnGjuYmzzzUzIWVZTx2HwCOUjilLJY3FwBjU0zEjrITqBj9sagMpu8psVvPR5Ltx8p9Zyp1qg1qnvPsFd52MCEROXOvqJe3kR0ptg2ZATyG2KlYULhKf2MpP4LGGy4sT45S6TKw65xRk6O45Q23Yc48wOvNggTZqtAZs7/Ad5dWeKy8iwn4NEhGSJiXEZxeZKxrkexS4myREgESgMHGJAYZAnoINDBoWHIoXCwGKIhAADG4VJhixRr883JiTGJsbGBPweTe7gMgBEdPGJ6aIIMAjwkUCGhCwwSAlJQIsQiUGTFo9ZNe4dWmB18hTRzifILq5QuS9LXPsKTVUkxwiT5+c5ZTs4q9sJU0MMzN1P56GrGFv9l0zKQerGJsenFunsWkDtWtMVmMjTVZiMhVFbZmz5FL4dYmfBSxw6ZgqiGFtEBJkcKnQ550qapk5TKpoQdLXha2K6ePECeKsgbEQRBtyQVBWKHY9RS7FahGQ4wbSXiEdntEzTyoB1AuJ5mHw5yeAtdM/+Ddlzj5HNSMJ5yEfQWAYbkGsptMbz+UEQI77DxE2h+tO2Pr7voTAQCF3t7Sl7NcEERQKy+42/4zilDar8FKQKmnx6Prg22KZ2VBa2lh5nA8gAmV5EkaV07JAINKk0pCa6KtFGUSS9zwzNh9xeJm/OQmuQDW1qFfcych37G9m8T64nDiGV0u+pro4vEpbeT9PV1d+g05M6K3B6xlV+V2/DRkutIyCw9H1Dl6nBM7R6KkaT9wTdyxugq92B3Yt7Ej2zMKGlzm0fOl1tiBX3yu4ItAWZiYBew8qliecaR6E/lv5jwo/92I9x5513cvPNN/OXf/mXL/bufN8j45j8f6/dzf/76cf44y+f5icOTlHJ2i/2bvXxA4oXjQA7jsM111zD7bffzo/+6I8CusJ7++238/M///PP+J0bbriBT3ziE0gpMQwtEzp58iTj4+PPSH6/E8YvnKVbWKFdWEEVd0FpFga2U5uKEKe+SHogprgDIhvidL4nQetFWWQVtCvQXSUyPPwADNrQ2iJ/9i/ZsXQCpGBhAGqH3kSzeZx8eA8VI6GTNrANH18GxKSQiYLWLmJ3kJxVpbPxOSYeXKFdPsYTnTy7vTfQYAAld+DOHSNIz5Nsfx2ESzRUlbDyCmiUse4rMnFmmK1UiApCqD8OUQZW8sipU3Rv7mhtrDgL7UndS+Zme/EdUk/QdrbZUsdptccwpYFvWCgjZD1TZmRjhmDSJZqtsRVukVvIk00MBlsVnhha56HuMi9RQ9gkZEmwKKHIUiTmeiwsspi4pMiyiaudsElhk8bAIYsNCByyRLSxsen2aK0mw0XaBAhS+PgY2GiK5uFjIHoiZ4+IkIAaXRQOPgEJOtvTwMDFJY9BgyarYpkz1hoPjZzifKmLO9rCGHocYXaRVZtozWLM6XBhYo2FC8tM+zOMh7spH93PWirF5oH/itmwGFl5L1mVwRUbnNl7nu6hU6BOQDatm2vDDqJ7BjYlFa/DgJVgpeCkmcaz5rShjdzANx1tkGZI/AHoxhZLhiRnSOa6en7aiROibpfYcqBSwbSaDIuYgoBWHs4FKdopSPKKxNiE7nntHMvjoBa14Y65C6YOEM3P0Dz7GO7Rz5FaO8UEMduETnNJyYDzF3E9Gc+DAF+qNZ0+fpBgAkJLoaVCIQCr11IbQ9zuEcoEIbOAQnmGfjAqHR2N5OS0xFl52s3ZtCDt6R4FmYUs+s4rHd1SY3q6nUY3wGqSSAQ5D8y03qdOpJ+ElRzdyiAsTW6DnmzYsbSLc9KLS1KJ7kc2MkAMSQNEWX8WKpB1MLbAVZowWxKyKb2/rbYm2mlTGw3Epg6jd+Oe9DnWFWjZI8DK1t/r1nVlOxIQZPV2VI/8dhS0Ex1/1G7pirN+/tnLNDb0+p6yKLw08VzjKPTH0n9MeO9738vP/MzP8Od//ucv9q78wODHrprkv91zjsPLLf7giyf4ocvGObuyxfwEHJofwjSeS0HRRx8aL6oE+tZbb+Wd73wnBw8e5Nprr+WDH/wg3W73KVfod7zjHUxOTvKBD3wAgHe/+938p//0n3jve9/Lv/gX/4JTp07xW7/1W/zLf/kvL3rb5WXICp/UyBKtHRbB4B7o5pCD11KtreI0j1BPKTw7TSJmIXEgldVP4c2GLsmFIwg5SOxKgsEfB38KURcoQtplSXPuOpzWIuWtx0jOSRpdA29oivRShCe7mBQg1YABibWZZrDg0q0tQGBSyngo6zE6vJrAGEGcvpagsguG5qBVhukcoRiFo2UypzPMrE1QkCkW1AocuxLGWqBCsIchzEGrCcEWqFVd8ba2Q3Masi5kFBg+ZE3U1FnCaBWcaVgZBM8hGAnYaFWYfGI/y9uWiMY3WU6ybLYlqbaBl5J8fPQ+9q29niwWiqyOFCGHRQgofGIkBl18XAwSXIpY0DOuStD9dyCQpHrmVRlibCRgYJDRJRQEJm0CIrrE+KTJsEpMqzddHaDMIDZtYpoESDwswMckjc2XrPt4ZPwhqpNniSbmSIwSmENgn8doJmQsSdTIE1bLnB9bJhibobEacCHKYClBkDJZeeUXiMsuuYfeQ1qV2TCqLO08i7fnDqivwmBJTxbtLoQeRF2QCU4pobWl/5wiP6+l9VECmSKiUEXYCdVggFzcpGgopK2wtmAkD0umII4Fo0rSMEK6SUiUlFgoB9hNQXV4jEQVIZuACBGtGnb6ASJ7BOIOue4mqcw6dbeCCgwYLMK2a4jGR4iOfZ7VzbsZX44oJzDgcFEE2CJ4TgF0f9LWx/c94hgl9HNBjBihDIzIREqJwsBMTJSIkVaMsnutMcqCblVLebM52PR1T/D8kO7XRUGmqK9zdwvikjYwnLQ0YfYtGElpebQtdB6vkmBXtEzZsKBkaILbinQ1VinAAzGs23IsTz9Ii2Pt8qwzjKC5/A23Zl/oz+1E9yLHAuJAS7GFB35B9/4GbUgXdK/uZqgrvGT0drSFNXTaWvbspDRfjRVs5nTF20rBRm9//AjqdWh1YG0ZOi3tm5Gg84f9rn7mYEAS9yKbLtn+3+ceR6E/lv5jwk033cSdd975Yu/GDxQMQ/Bv/8k+3vKn9/GJ+xf5xP2LvU/OMDWQ4VfesLdvkNXH88KLSoB/8id/ks3NTX71V3+VtbU1rrzySm677banjLEWFhaeqvQCTE9P84UvfIFf+IVf4PLLL2dycpL3vve9/NIv/dJFb3umDRst2NeQHK+tc+rGEJw0ODZq/k0E1TyBvQ4ZBwav0jf2xAZ3DYwLWlZam6C995/RbpmwdAi6Lu5cCS/u0KoMkGSG2X7PFxjutmidtVDCgHgFK0lQBARY+PkVCM+Q1FtQBNtQdKdjZkrgZrfw2hLSixiVU6ihJnJuHQpDkEpDawLz9C7sWkDTatNW63i7AyiHkJ8Bcwu29SoB0bqOmigf1MZLAxtwuQ2dHCymoVPRTqTZLX2HPd3RlYEkA1fFBO06S00bdWIIo9UiHpfEqTqekaK8Ms4TVxzmA/wv/s36W7BUhIs2gUpjokhwUPhEhHQBG4nAQxESkSVFhoSIEB8bkwIJFjExDjl8Qtp4hPgYNFEk+AQ0hMtRq8ZJs8bx8Q0aZQ87cDDsLCJWiChDrpsn27IZCy1KScyJ4gOcuOxuYuGTUSEyLsHWNExHkJJYvkHWMHArU8jp/cQTR2AhR8MZ4J7L7sJsLJNMd5HZDrnb38x4d5am6LIw+TDB7N9BkIPyDARL5DtHkXWTwMpBxiDJGkQqwU7DqpMhbpUQqoFptIhzKTBNlGGh0hXSqkkhTthSEBVhy4RztoHyoZiGnJAsiRauGqNWnMAa3sQ2Gphmi1Tg0pEDGL5kYqvFVt4jDg1KKmHK6NDNf4aj2SZK7oXCiDbW2fYjbGY8putfx7hfUbxIbwmH5+4Afv6C6j76eLGgyZd6Sv6sUEaPciipK5ok+uGiVPqPXqZ1BVQAHV/311qWNn/C1CZR7Z5ZVc7Ujf1Wr6c3tCBJ6Srrk72+pqFl0aJniIUEKw2+1JVT0XN7TnoOzELqLDR6+b6W+Eb+r0x6hli9DF8lde5wL3IYIXsVWEuvL0kAS5PbINYybSl6jKs3XVASreNWkPS+F8ZaKo3Seb6tXo9vtwMbW9Bug9cB34XQ70mnI328PeMrlLqkyS889zgK/bH0ufBrv/Zr32Z8unv37mc1V30huOuuu/i93/s9HnroIVZXV/nMZz7zlJLxm/GhD32I3/u932NtbY0rrriCP/qjP+Laa6/9e9uPSxVNL3zq96tmynzwjdupRjYf/spZ3v3xh/nw267mNftGv8Ma+ujj+8AE6+d//uefVfL8TE/GrrvuOu67775vX/gikTkC821IT0CllcA1CiYzYGehmNGSMPsomI7OdSzasBBB/Dhm+zOYsSAu7UFOXwXBBHTLkP0q2fOPsJk3qZdvBHsHYfYLtAPIlGP8igmOjXdekqg0kfKQpSrT4i62RT7Lp6BSgOVRaFrQrbhE6w3s5F5mt32NVl0R1i1qhd2otQpkNkj2PEpLeLTcCQiGIfc4VM7CwLDOgFwZ0seSGgCnCB0LBtZgM9bZjv5RmFeQ2g7nB6GxAwpLemJkVCFM6b62dJc4thAjWQYWRmg1BSQ5ZMajEBUZPXYj911zjH859Dl+/viN7I1BEdMhxKKAxwZ6uqPrsFkMFAkhLiEBKRwkApsMHQRtQiQxMT4FUhgkmBh4hBwRF/jSwGmO7d+gM9wgyfhaKmhMw1obZzFLppHQ3LcKszVw0xxp1RDdKjJdgFYRsdzGy2VQgwLmajA+DadfQVS7QCNpYQUz7Dp5BcGZCTalQXPfBWxuZ8fMBmcmZsn93dvZu76Xmm2wMPRlgp2fhU4MqSJ0ClBKYfgSp5GQCmLShZDatEFOQsYEw02BAfmwQXYgYXOgiIzLCGMRwpitJE8r6VJMJ9jAalbgWmkGgy6dDkwHYK2GbOZXqQ/PgVVmMlwl5eio0URs4uXydJTJgIxwfCh7MLoGs8NtxMBtnBrfILBfoSefYoC4uIfNzGNkAx937eKuJ5u+B/T3GhczmfrTP/1T/uIv/oLDhw8DcM011/Bbv/VbT1teKcX73/9+/vRP/5RGo8ENN9zAhz/8YXbu3PkPcjzft1C9aNzEBAHKfpJMKhIMUAEiTlAxQAeMLliBrmiulsEuQSoHxZo2hhImrLQgZ8PksL5ARRc2TUjbkC5pshm52syqYH3DByrs9oy4cr0s3QRGbE0U3Vgrd1QI3a6uPmcymiGFMQQhGLmeEdaTFWMgXwZMLVW2Ek3WnbwmqYkCa0BXZn1P/x4lurptOr3e4gCcEe0Q7cd62SDWbtVhoGXZ1fPQ8GAjgAsrutKdBwIfggjh6TxkZaL7gZM++YXnHkehP5Y+H+zfv58vfelLT722rGef6t59991ce+212PbTe0mPHj3K4ODgtyWVAHS7Xa644gp+5md+hje96U3PuN5PfepT3HrrrXzkIx/h0KFDfPCDH+S1r30tJ06cYGRk5AUeWR+JVPzm545x3fwgXz+3xSMLDZ5Y6fBPrpnnT95+kHd97EH+/eePcfOe/jnu4zvjRSfALxa6RwUFS+AHkuFBn+Jjj9Iauwyccd37VJ6CTgOiBXAfBWcK5D44X2Xq9BOMrSQ0xSNsLX6BzevfBlPrOHf+d6ZPbtGeVtTtAgxfzoW9P4IIFsgtbuClxonXb8QlpT2L0wFOqcOeOGCxA2ETUgOCpGTS6UqiQoRrb6FURHZDYS/BVkWgLIFYOoxwOsgwCxMT4M9A+jzYLmwOQEFCeofOOfZC2JqDtRJETdg2Dm4RY2sWwnHUYBMxkEFGEgZTkNsGV23BWQPctJbBTZnQKqJGUtSmF6HexFnYgxnmWJ1uM705xfzdV3L+4Bq/9trjvOGuPJd3R9ghbUpsMUyZhIAmHlt0qZKigEAhcDCx8QlJiPBxKFLAIMFAIXBxWRR1Hsme5pGxYyxNrOPu8iBlQ9Db38NDsJZB1AXlaoGofBbyKWgWoXYa1ayh7DI0xqAZkhtdxfVGUd1r4EQJVhepHB9h38ZNdBPBkcIGG5kml3dmsTItWpmzjNgbbOaKZB56DdetHOLw6KNcuPpLGMbDOikkn4FkEdQKeAmtyjQYg6BCis0nsOuSlgVmFowoA5UsBSXJAc3AwGcUO7WEVKso18SxJJEN+TQ0LBt7AwihbYH0YErCtnbExvoZzs9ZmIOQFboNTzqQNroYaZhtgVWFQgDxOrSbcMM1AbPtB7hdRvipyyGlwDdpeg6R45Nef/Zr55nwpDjy2dCftH13uNjJ1J133slb3vIWrr/+etLpNL/zO7/Da17zGo4cOcLk5CQAv/u7v8sf/uEf8ud//ufMzc3x7/7dv+O1r30tR48eJZ1O/0Mf4vchElACEatv4mYRiAQlYixp625hGSCjKkqEKCqY0sdMcoSdEW1UlXag2YRspFsi6EUaFU0g3au+bmgH6JQFce9qUon+XAqoAp7SZNGP9MVm9FZlOFCY0kRXCRBbeleV06tYS4h7RDkxoJ0CT2jSKmzwQ+hu9gy00FnBshe5JCMd7aRiaHsQCF25tpSWZHt1iFIQFbTzc9DVld6mhEYEjY6OZSLShN3XDwqE6hWv0RPaPvfVeK5xFPpj6fOBZVnPaqb6zZBS8p73vIedO3fyyU9+8imD1RMnTvCqV72KW2+9lV/8xV/8tu+9/vWv5/Wvf/13XPcf/MEf8HM/93NPtfR95CMf4XOf+xwf/ehH+eVf/uUXcFRP328pv7d/CVJKlFIvaDsX893ns+w3L/P183WW6h7/8Sev4P88lufP7r3AB7+ywC2Xz+DYFv/sxnne/JH7uP/sFrvKPG2937qt7/T6Uj2/z/ezZ3r/+bz3vT7HF7POS5YA28qgiIVfCnB9uGrjMHc1qyhnG2CCPQTpOogMhFndx2TH8EAd9+5pWklCs7RMYbBGdeph1MA6ZfcUZc/B2XBZHzhDOF1HFV+H8izaQ21YWoYjs4SWDVkHVIfILHDGtWkNhWQGBY6lyMqEoAVBOkuQarMtvcywC/VRqOdMWLmAyuaxuz6RUUR581ApgtvUkyAnBU5bG7GU03B4AAZyevKThcyZvZSqM+QTC0gh1lPkRUDX9FkaOou7fQPG0zCYQ3QtBo+PUyueRbqurkDMBTDdJdy2gDg8R64TcmHfKqbdQlYt6in4+I/ew/8IY0pn0kyf8UnHLrZp0nQ22ao06SQxRdIMeGlGG6OMRzNMJhN0Dclpp8aaVWWrUsUtF0icmE62SzxroyYWoaGgG4Nb1j1wR4fh+BbMdlClNBvbJNib0BFg7NORJOMZ2CpByYWZeTpyGC7sglNZmEoQC00mVq9kSo7zpeGvEs4/xiYF7lseR40vsXP8UTqJSfzQ9VyxdAOPTd/J0sv+ClVMkVQP9rI3c7p0X1gGZ0Wf79waoubSGt6LEDW6VkDHiYjNAqQzRJaB7yZEnRg7OqP9PTcEoykPLHASWA0G8UcG2emeQbmwMaYPrZ2GvAMjzYRKJ2HFgXoJWjmIHJvhJGRmHdIuFJf1/DOpaL8cEcMVbkxLPsLXm12CoZdBOk0wlKOdaWFenKccWX3VPCv6PWvfHS52MvXxj3/8aa//y3/5L/yv//W/uP3223nHO96BUooPfvCD/Mqv/ApvfOMbAfiLv/gLRkdH+d//+3/zUz/1U9/7g/qBgNKmytDTpkrN3AyFIU30X3YMeGjS2kRIiVBSt8k4vpYCB4F2X255uhLsGFrSnDJ0a43Ri/8RpnZNhp5suffjSV2xlRaESU8mbaGvOhOMtC6nSnrM0tRSbHr9wiru9deiK7ShhETqe0QidbKBEHo/Eqm3I3vri9HybT+BwNCHakVaCh0rLX0Ohf7cjXS+b8vXcnDP08QaCVGke5BjqQ8VMHsRyH1oPNc4Cv2x9Png1KlTTExMkE6nue666/jABz7AzMzMty1nGAaf//znecUrXsE73vEOPvaxj3Hu3Dle9apX8aM/+qPPSH6fD8Iw5KGHHuJ973vf07Z1yy23cO+99170+j70oQ/xoQ99iCTR//r1ev0F7dfFQClFo9EAQIiLM5a6mO8+n2W/eZmzKzUAhuyIt11V4a8eXuJ01eOjXznJT1w1ypCtz9G5tS1GelfTk+v91m196+s4jonjmFqt9h1VA38f+H49v9+6zLN99kzvP5/3vtfnuN1uP+9lL1kCXM8nDIwkeHltXjnV9Rg8/EWqb7wForqWkpXm9BNvDkLVgNY6hrGILUv4uKTJkt3WhUEbghPEBZfUSEJgmsjZDsT/A7vaJi5fgQoHIevr3txUBEYKqGLXjpISMXIox1YpRcqqYVYVpZLgLC+FgoOa6xKasFESRKkMtuMTt0uMtjeoRhKv2YTcl3VFYWgHbJ0Fazv248OMP1amWDdxzQilTFJqF9ujcVI4pAlpYDJMgbQKseMWD65N83A3JExFkFaoKZPR5UmKj5c4N3cY1Yrh8SGYKcL2Jhz0mbttiuGjgvuvaNO9PkIcGYOHtqMGz1LbOUZtmwT36zDQodxaIt2OSUVgWxa1jMl5uUgnWUfYeVRWoGyly5RbBSiWwS6CDKAVQ/1KmLigJ1yLM2AXEeeaYHZQqXvBLEBmD2xE2uzlcABDIzDc/QYTHBOgLtfy7qgOhbOozUWO7Jti/WSLhl3Fbh/FdGK6B3cy5S0wV/K4Y+UyhldfxQPX30t31106D7P0UijnwG3AVhayMxA9CMEyWGsQK1QlB9kJlGVD0ia0HDDKYGzSSRQqAjNq4LiCRIGRFrhpTVJDTPz0XkiNsjmwRqneYnwT3AKUbK3SbOVgDkh3wUtDR8KyGVJqQ2kTamlNlsdCiBxQWW0km8/AriAhNE7xkD9GbOzHz+TxZ0G6wIXnfz059Anw9wp/H5Mp13WJoohKRQc8nzt3jrW1NW655ZanlimVShw6dIh77733GQlwEAQEwTe6D1ut1gs9pB8wCIToFVOFrXt6iXuZtQkShUzbICJwzxIzSqwqsBpBdwP8ZW1w5afBMsHM61zcpAueo+8fIxUt6wiaUF/X1dpiCXru+JieNpeyCtBoaAKcrej1SqCxpVtcrAzEeR3DVHDAzfUYZldXkmUMnXWdPayUvjCV0m0yidTOzY2kp022wZyAMNT3QZXX5NsPoLYBODC2Axob0FiH6jnY6sJGFxbPgRf0op6kJtZR2OtJBmkaCNmLUnrKDrqP5xpHoT+WPhcOHTrEn/3Zn7F7925WV1f59V//dV7+8pdz+PBhCoXCty0/MTHBHXfcwctf/nLe+ta3cu+993LLLbfw4Q9/+AXvQ7VaJUmSb5NPj46OPq0X+ZZbbuGxxx6j2+0yNTXFpz/9aa677rpvW9973vMe3vOe99BqtSiVSgwMDDA4OPiC9+/54MlKWqVSeZoXz9/3d5/Pst+8zPyEAM5QjWyumhngF17t8+t/c4z/fO8yP3n9DqrdLgBzY4OUy09f77du61tfR1GEZVlUKpVvk8T/feP79fx+6zLP9tkzvf983vten+OLWeclS4A7DrQGgGFIp6G2ANO5w1TrJ7TTciwhHgPvDvAKkJoE9ThyRw3/+FnstkVl0iUpWChjN1TqBPNnODPisTx9FUl5Art9lAPtE1Qbj0DisD4wQrgvD/VBvU7WyW0uESPxdycEjsdSFvBNwsIUFK/GCI+wIKbZ8AfJlJa4ljrnm0VWkzG2onMEIouIT2GuNoi3HwBzHmbHME5P8ZK7dvCScAQLhRs75FHEJDhkyGLRpckIkgEsMigCMlxOllo7z+nFBnLbAsQWJ24UXHHHMMnh7SyXV4hlGhY8GNiGmm9x8kcazP3VTl5+7zx3n1yjc90i5rkU1pEs/ugDcLILLQVcTrPk0IzXEEWXTX8OkYnAiFFtD5VS0JnEODOCLAoYbkDXhWYJolm4egPxUAFVvwq2KcjUIRWSbpsQVfDkCIa5jozyupfbysFcDNmT0EpBoQDtTQQmym7oTE7P11LqIRsl08RWhJ11sOYj4sUA5/wxxvMRZ9eLRCevprX3b4gPHkO4Fpbhknh/hcxPQz7XK8t2IVjUpjaOo11gCxW9LfIQbUASAgZEPp6Rwi/EqMgkNNKYcQtHJEQSjIygaRUgNQjqWhozIVLdwUzQJZVAKdZZ1TbQtcCOdNSmMqDQhXQVWo8JIkehCtCswOignu8WgXATknGYNWKq/r2cyaZI8hmiYYNU9eKkKX0C/L3D851MfSf80i/9EhMTE08R3rW1tafW8a3rfPKzb8UHPvCBbzOXuRSg0FpdTYLjXmytIOlVhBV+r184AVv2IoK6YGQhKCGqQ6jyoM709dp6LDQiyIbQzUFKQCHWfbtCalMty4FUXj+pCmJNPB2pc3nNXlW31YJMoecCnQeR1o7Unq2zeF2pL0qZ6Cxy09bjkeyZV0kDojbIUMulk7BnjJXuOUQLiGqArft947TmqjKnyXukYGkTWnXt7rzWhI0mrDZ1FTiK9fLEulqc9EYIE6xeo3WM6KfafhP6BPi7xzdLky+//HIOHTrE7Ows//N//k9+9md/9hm/MzMzw8c+9jFuvPFG5ufn+a//9b9edFXuheCb+5QvBoZhXDRpeiEQQrzgbV3Md5/Psk8uc2h+iKmBDB/+yln+5O0HeduhGT5+33lOVz3+wxdPsdbyma5kODQ/SKNe+7b1fuu2vvm1YRjf1TFfLL4fz+8zLfNsnz3T+8/13vf6HF/MOr/3/8LfpwhTsNmB4KignoPDi2Ccc6F5CowAkk1QNpnD9+Gc/jh0HoONT0P2At4bQtIHa+RHI9bGHe3823wV3dz/zcKOV5IMjJI6fDcjj59mpAtDHclc4JONWmC0tdzMMmCkS2M4IRyEvaGPEDG+7eDvu5z21FsRjxnML93GvtUjeH6G9kKFdSnYGpxCqCYpIZFDFdRgiXjkAGSvgGqazN8NcvXfbWNHOIJAYGMwjUkWSAE2MSYBFg42FnbPjiqNwQQFtpPHUJsQHQZ5B3HqcR7bdxSp0kxtTiHGYxgyYKED6y2C3SZ/+2Mt7q208AopeMglLoX4GQN8C2NsC3YosBZQcgQ1aiGHJ2HMxGaDtFtDJBbkxyEaQG5PgyGh1tCTwoEVGD0JcggjERgLj0FyH+RrUFrBu76F90oJB4rIqQCKd8PEGvhbEFVBdsBa0HrisQoqvxdKOyEch1OXY6xdRfbE1XDGpD7h4e25QLYTUU4p7E5ELRCcP3EFplPjiv13sd1bZ7ayTDbV0JEl6Q29LXsFw/4ypC0tc8wN6xNeLEFlBnJjYPu6ty9XAMMDcwjTTZNtBJiBy0AgyaDb0CNbIC0HSlX9N2nN4lo5WhIyEaya0Ax0pbhb00awTgemgD0hjB4RWIs2xoLAPwb2OtQErA1ClIdgEOomBDbMmT6p8BTkM3TyNuoiW0Bt9OTt2X76UfUvHn77t3+bT37yk3zmM5/5rnp73/e+99FsNp/6WVxcfO4v/SPA0+iZ6EmghUAJgUICISQ+JB6YLogasArGKiJcx2jU9IO2wAe/DZ0OtDvgPumUHPV+YugkuoFfpDVZjXvS4laiexjCRPcMS6DT1f3AkdKyjifzeH0buga0ehLlRGpzKmWBSOnWjMSEyNBGV36so5h8Q2cVi4x2/w8dHXcUxFqmHff6k5MMxCkthV6pwmYDar1YhY0GbNTAi3oEONTbDsMeATbBMDB6NttJv6P1aXiucbQ/ll48yuUyu3bt4vTp08+6zPr6Ou9617v44R/+YVzX5Rd+4Re+q20ODQ1hmibr608301hfX39evcl9PDtMQ/Arb9jL7cc3eNfHHuTx5SbvedkUAP/9/gVuP7bBv/0ne/t5wH08Jy7ZCrBl6IfnnQa0AAwd10rSBLmpn1h317E7DQpL61TDtpa8yVn87Ba18hLplqJ8uk20+J+J3QrdA29GXvtWxNE/Jnt2A7GlIxYLI0AAlkr0JClyNMMxxlDZKTzOMJQPGXYUa8kQqns1xpFtpB/fpD6V4Bgx5fhxxiKodkqE9s2UjK+y141YkA+zni4TjV8JboXssRxXHJtjuxwjS54UkoQUPgqfLmnyWIQ4vf9vEmAhSMijSCgCY+RI1BE4oWDShnNN4tw+NkabjC6PYyy1ScqaeKlEwBM2UV7Sng/JbuTpXO1CfRHL3YF5tkp5usF6YMOV2zUBrFigxqA6TFgztVFUTkLLhKkOwrofZU5DcxDGljXLczKwXiep2CCb8AAwH4G1EwY3wFyFpA7OIDSHMM4eJi0D3LgIQQIjBRjoQO0gyFE4UIYnTFBjFB+QXOnNcc/eZcIdFyDvYXgwhm4Z3tyfIvJHSIWPczYjKfqAK2glZZQagI0Qo7FASgimhwPOne4SGQFQwDKbUPWIZRHEst6XbAjROqmkSZCMI2VIaPnkWiFpSx+eGcJgR1JNN6mVIsh0wC+RywakgNjWc9+RFpRqul2vbunT6LR1UpdcE6SmIigp0i50ZqDQ1qezMQWzCUwLqAO5NEy7FziTMYhG0jT8iwvayPOdB5P44i7PPr4J381k6vd///f57d/+bb70pS9x+eWXP/X+k99bX19nfPwbmYnr6+tceeWVz7iuVCpFKpV6gUfxgw31FE+zAdmLRIp7uuiUlj8bsa7MGqHuz7VMRLKJkWwhN31UO6cjj9SQzma3TEhciAc0+c1LqPSMojohtLZAZDXhLUigq2OEosHeAGBpl+cgBQ1fDxqmCU4BiDQpd3uZwlEOcHsy7UbvOGxI0iB9iF0djyTMXktzHnxHO0S7CrwuqBa4LlTrsNbSFWY3reXX7QY0FvVTuHTU6yMGEHpwole9joDYIkz6I8Iz4bnGUeiPpReLTqfDmTNnePvb3/6Mn1erVW6++Wb27t3Lpz/9aU6ePMlNN91EKpXi93//91/QNh3H4ZprruH2229/Kh5JSsntt9/+rKknfTx/vO7AOB9+29X85ueO8eaPPD0VZudontfuH0P1nfX6eA5csgQ4bkCrBOMvV8hViD1IygYEPZlXEIFbZ/R8QPFEQDY+RSOVInsc8iMh9akMpyaH2LmwTCFqYZot2HiYtrgOHqrjLmbIGYJwu0tNgarCwHiXrUwNlU/rSVJrG+x+K9WRj7IozvHSSszttXFa3WuQjS5+ZhC3chnT8qukPcXGSIqunMGxT7InOEazBSpRJOk5zCMTTB/bx47uMDY5ujRxiOhikUbiERIjMHu3z4AGAoVDQAAUsTBIkyZPCQOrUSeaNTCaecT6OMl1TYIbsyx/ZZnEdzBXJRYWwfEcVqSwPZPggMGBx/JcGDhIdeI0V9ULHBnbRdVxoOtAPUP65A6C/UMoK4YoJp2/gOIcRpjgVa4E5lHxNYihI5jBEeLVQd3ntrEESQ3yRRCzkN2AYAMSB2NrC1kOYcKGcD+spkGeJyWaBComGUjr6I+VeWjsgdFzYD4O5QoYTZqR4pGqiXMhR1gahQsl1mMDp3KE8WzAhmsilqYY2PsgBwQ8akHby6OcWYgkZrJOkh4hXNwO7btJGQZxNw1JjFFKkQ99aomLpZawrQ6emgOhUG0Q1hrSGUYaCdKu0gm0EXemA8U2OOWQ+rhCjaWhW6I5+Do65mFIxQi1TIYOG6ZOtHJWtDIxNsFaB2u/JDMKC1uC+GrFWADWPTBW1tLptTI4OV0wMn0Yi2O26su0hgtE482Lup560+lnRf9Z7AvHC51M/e7v/i7//t//e77whS9w8ODBp302NzfH2NgYt99++1OEt9Vqcf/99/Pud7/7e3UoP/hQkqdqwkrRCwJGSAlKoIxES4yVxEw8SLTEV7GMboGoaHmy5UKroHt5VQxk9VPZgJ65ldRV05yppcuRoSu42PqilWgtbJTovl7D6fX6Sq3Vluh83rh35QkTfKH33e9lDotedJOK9XeCnuOVLfXT4DAEU4AXQzuCtg/dNmxtQd3VFemW0lVirxeb9KThldE7P3HcyzLu7Wui+jbG3wHPNY5Cfyx9Lvzrf/2v+eEf/mFmZ2dZWVnh/e9/P6Zp8pa3vOXblpVS8vrXv57Z2Vk+9alPYVkW+/bt44tf/CKvetWrmJycfMZqcKfTeVpF+dy5czz66KNUKpWnzLZuvfVW3vnOd3Lw4EGuvfZaPvjBD9Ltdp8yMuzju8PrDozz6n1j3H+2ytmVLYqFPP/6Lx/n5HqHzz2+SiVnc3Zli/kJODQ/1K8I9/FtuGQJcKUC4gI0ZyHJQboMa7OjMLkXXMAzsaoPkV0OyRwrMKDapCo+pSbUhlPU5l5PMnoVxyufoFw/CR0Td/ck+AFqR4XQqGEbNcwclLraY6SLwvBqJKUI3KzOw6nuR47OcEFeQCmJ51VgqoKR9ZhvpggenmB8yqAdJpy4bAQ5PkB27QGWA5Na1sQr7EcFNzN5ZBc7vUE2iDnnbJGSDkNxgiF8OmYdUpIpL8uUNBgCij1pdB6ThAgdVOFhYVFgiEHvDaxFdajmUVM1GHwc8lMkV1fgsQmSwTbJWA6xKZg5a+EairVEcWr7IlPHS9TdbVzOGOL0KOK8y3lxmg0jJuetEw2GJC8vQz2HH96E4T2BGndgdRLr2DCXrU9QTXdZmWnqiVlqCmyDTOcCwqzjzpegPQarEWZynBw12u1p1JlrwalAUEFWTBridggb2kF1PA1DGSgBPliPPkqm1aKTyqKYpHnNBKU7J5h8+HJWJjeRmWEWmtfStB9ALpZIJ+O0xi0e37DZmlVIu6AzONe6lOJNGuZlJNFNNLMnSIIplD0E1gmEkljGOtiCuC6QDqB8EJIwm9KSRtXBMbpULPCzWimYXQU6YE4phN1GyQLkRqH0epLtO6HRRNQ+j9/ukncUxhlIHjCIEhCXS9a3CU5N5tgs5giuiNi+WcN6VM9H7Rim2rDZUzxupSCbwKgJ9Y5LM5NhaeBJh9vnh+eS5vVvPd8dnmsy9Y53vIPJyUk+8IEPAPA7v/M7/Oqv/iqf+MQn2LZt21N9vfl8nnw+jxCCf/Wv/hW/+Zu/yc6dO5+KQZqYmHiKZPfxDHgyKuip/kAFJAiptCWWikGBUAI71B3CEQrstjboSwC/oyXO1oyOJ/IakJnRngG+ib6aeuZQeUe/37aBjK742mVNeuNEZ/1aEjJpTWAjqTN/VaIv9sjUBlRp8xvS5zDdk2q7Wo5tAikHar6uaBcT8Bt6faoI7VBXmC+0tDlhc0MrWfwINmt6O0ms84FRutfZ7rlJB4F2sxaab+t+335l5tnwfCTO/bH0O2NpaYm3vOUtbG1tMTw8zMte9jLuu+8+hoeHv21ZwzD4rd/6LV7+8pfjON+IPrjiiiv40pe+9IzfAXjwwQd55Stf+dTrW2+9FYB3vvOd/Nmf/RkAP/mTP8nm5ia/+qu/ytraGldeeSW33XbbM+YK9/HCYBqCl84PsrMEg4ODnK66/OHtp3jvpx4lefLBG2eYGsjwK2/Yy2v29c99H9/ApUuAxyFVgeoTMD4CZ7aZ1K6/Ut+43RBqJ5HpC9QDh7IsYm66WOMJ9R0pzt9wM8nI60GZBGM/y/qhR+CMBamboDMCl/8Yqnwfa+FRduZOMn5EEQeQjRRG4pHEMYgQsKA+gDh3iF07v0bQgMTZhPMuon6MdPo2xtJnMEVCPAG58hpty8IdP4ibz0N7HbrXk7vnWga9DJt0uZBxac0F4FpsOhGkYhAeGC0W/DSZapmxeoprkxTbsLAZxMbARFAghU+KIRxe5b6K246fobZzGbHjXkQjRjGjrYTXOkAOcxGSlI0rJN0BF8ZjtnZCM1kEr8KjmQZ+KCDK0Z1bZij3CEWnizc3gNt9CUQ+mEWkehk0TAgckuHTLCLI1CsYZ15DkmlhNSchPUs0kUCliKj/GBOHBYE6SvUVFVrhBnRNyHmgHoP0XnD2ocohLN1FNqrjxwHSc6CegOoiVpo43Q7GmCAx1iHu4OcHMOIAdW0L1pdQtYTG9E6Kj11BOjNOY8cg3rlNVMeBjA1WGxxFwy9rld9wnaozh4wVVMYgWiZwxmg3VhHhBVQ5hTQtrK06jpsgkwCV9ZB+l0o2IhgziAOFYyga2+Alk3BY5JDm66A5BsUMNC6QqX6ezFKTUbnMro4iFUBtTc9Hhx1FtgSPl+bZmh1lRB7GWuhS/qJAxQprXLcWpkLtI2Z5wAK0q1C4HIbyYIQujcCmT4C/f/Bck6mFhYWnmT98+MMfJgxD3vzmNz9tPe9///v5tV/7NQB+8Rd/kW63y7ve9S4ajQYve9nLuO222/oZwM8FBU8F1woBtoWMEoRSmBJsEkwkng1IEyMxSMK0roSaCzqD17S1IVY7r/0ArABqKdhMa/+AtAnlFKwGQKgdpI20Tg8Iu9pwyxI68s6ytASkHkM3gUpbE+BIQmdL9yznLHBiMCVYie4VThxIynr9HV/3ByupjayMvP58pQnVrjbM2GpA4ILvQ2NVk9vQABK9PyLpRSJJnW+kJIbZcwGVfdr7fNAnwN89PvnJT17U8q9+9auf8f2rrrrqWb9z0003PS+J7c///M/3Jc//gNg+nAN0tvg/PTjFe64bpRrZfPgrZ3n3xx/mQ2+5ipeM97vo+9C4ZAmwPQzlAoiHtOlmareJGh7SfVNiEzLnkJU5wtkVomMhpAWtEYelnTeiZieg/TikroFFA2v1AsKrEUUT0N4GmZeAdQAv9z9ZU2eYnYlp1aCowFqLiZ58Op9IwEE8cpD1/E72bDvOshPQXDrPsPcxnMwaDddko1RibLLN3HDC4foBpH0VFDpQu4r8AzMU6mnWRYPWSIJ3WQTTns4wjnrOnkkbjjRQUy7uvMPZ1Tk653ZxU9PgcmVgYdPAIkWaHIoYqJBhIq5QH12D0QS1bsG5DMwZpKIt9j1+NXHS4qwpaMsYb8iGmRiqBnFFwdAFHnTuhvpeWBiCHSXyImIolNj1GheWvgJLClku4Jd/hPLhMnFumc5rLtBwLpAjwtkcIlo9SHK4SL6ZxrvwE2TWHcY7OQ5FebaAr3/tLEFqjrnuGEd2f5EkdxySOpP3v4aMdQOnr97EK9dQ+WFYbYAqw0CGaG2KbngO5Y5hhFei8glBahvB6DokR6G9CQMpGH8DpQcup+SP0agdQuxbY7q+TIcWte4U2HPI+TkdX7JeJvFnYLKK6G6SDk7hxTFYYHRckuwgVtAkH7sIVxApRTlSRAMhbgS+Z1K2Ytw0jIdwzBKcyMyDuQNEAeEdZ+6hDzJ3Zo3MKvhKF4O8UUiXwJmUDNXg4aTM5lU3Mbl5G6+st1i9W+BuWhR2RxhFUIPaqLbjQNwC+WWbTJKQiiTrVwPFCJOL6zXLoSdvz4bwBV2lfXwzvtNk6s4773za6/Pnzz/n+oQQ/MZv/Aa/8Ru/8fewd5cqlCbDolfbVKoneQalJE/ZRws0uQxdwAAZgV8HYi1V3kygm4J2Bsp5yKV0JVcKTVaFhX4gFeqoIgvI9pyaDQWup2PivETLm3suy3Qj/XsY6x5cS0FW6epxoiOJkImu3pqWfq/TBqTupVipQt3TP822lkwHbs/lOdCkmVjvm0r0/ioBcdInai8AzzWOQn8s7aOPZ0IiFb/3hRMcmCxyeLnFZx9b4e1XDXLV3Ah/8vaDvOtjD/KBvz3Op//vAy/2rvbxfYJLlgAvWfpGUpyEZA4qYYi1doK4VAajpWMh/A7enKR21SYyBYwY2LkjxJ2HcHwf31jEyiwx2n2QjZYFE/eAcy3EOZhuIdYO045iulNQklrtSmNAy9VsS0utXYXyB1lZexvF3X/I4NIGzYFTNOZh+pygvFdxLltkaE+XIwtXIqs3w7gDnRSpu0eY3MixmHFxp3x4iaHla1MeeI/op/OugkYTJluQFKFdA+cuNmdH+Vxznura9cz4M+xhCANFgkOCokQaU8UYm5Jk1oJwEjaGoJJj5sImU4nFYTNAWTaJLSkslmmut3X2Y94B45zeViWCxgycn6BbvYkTpYeQ4yFOo40VSoxGQtJpcGV9N8fNLTrVaZLCILX0OcKdoxint0Hi0Z4+hkiXGT2/jZuiHBPk2RItPHsXaWUwF5RYbE5Rz61jxGdobDtPZrEAXInyM+AmYI9o5+Ukgfmd+OX9EJRx2ruxnlC4LxWwtQltHyMXIWf3gO1hhIKSl2XmL/ey9KZN8iOfoVAPcMQyjbyPXyqCMQppoas8K6Oo1WP4Q2XIJXjmHCQ1nNWzWLagUb4Cui0ywQL5MMZtQSuCXCXGTyBvwmk7TXN4BDk6A/UmxGMUTv8te+5fI94w8FOSoCswTGhepWhlYHcdWhuCo9PTYDQpn9pg8xR0NgTOfERqWseOyhxEEZAFvwmFtmBjGFJtKNQgOxFjDULtIq6n5+pd61d/+vhHCaX0xWQBCGScEGJo8hcrMGKknWhzKmlo46hCWkcfxXVo+dDsQHMFHBsyWRicgEIGmil9LyENA6aWS0cKnCxkHLDT2jU6CKBe0wTWtL6RjZYy9C9xAvUuIPV+Vkwd0yRdnT0ceuB2dPRfFPWcIT1dFd7YgLgnne5GEEba0TqM9PGnQ4gjTXgVYAiUYWBKfWpkv9/3ovB8eoD7Y2kffXw7HjhfY6nu8Yc/dSW/c9sJ7j9X4z/cucB/mZvAMATvvmkHP/7he3h0uc1rhode7N3t4/sAlywBVhbQ0HOS3DC0lyBV2yK2B7RJhx0g5AJ+Gdz90AS2S4l9YZlGtufvMXo7cWYHa8Vh7EYNWstEI+dB7YHCOVJb5+ku6MLpZBqOuA6+vRuaeUhLcAUkWZTjQzTBBbWdA879bMV/S3NuD8cZYe/4MV47ucgTzR1shG+BrRGMBUFxYQK7nULRIS4eg/E7oN2CwpA+GL8J2RJYGUhFsLkJx8YgOwWVZVRqg+7gg3x5zzLp6iuYWmhxQ/Va9sp5GngUMRC2SzKxpCdrayVS6zbBK1PMyh0os8b5y76K8vaBVaB0zCL7pTWioYB9J0c5s2eROO3jRzvAqUKY5/raTdjNnXw+n5DeuIekeBovn2HXqSKH5Dgjmw5rn4fYDlgvrNMs5rnswiypYIsvZs9hqc9zfvIy7lluMB9N87XLPLojm7jtw9y+PsHA8hyNShY5OkJ3b8LpKzZ0zEhrGB4s6YrGbAjZvDaEGa7ASZvEC4iyMUyeg7EIzl+PTO+F0Qos1zB8gzoepfo07c++kpM/tML81L0caASsVFdYi/8GLzWDV9oObh6yo4hcHWEqlGPBcB7aTUIxQ2gK6LZJuWtMeDE5UxeGbKDpOxQyETVRojF7NRR3Q3oXrI7AsKQUnSU9DisrJnFKkrcUm3moOTAeQ3bD5PFRiSotUj67yHAnojgIlTlJbGsfMqFABWBl4XwH0kA2kyAsRezBrhS08tByL+56ejKio48+Lkkk0AvRRZBgCEgsAQrMGBIzQQiJRUziRahQYBgK6WRQTgY8pR9YBpaWONcy0CyDtLSBVSWnCa/Vk0EnQptpKQMQmmALvT0iX5PfrN0jr7F2jzbR/cBrQjtWG7GO5XM9qHfAVjq2aKuqTSDDGBqhZrFSaXmzTHT7jmWAEogg1pFGChLx5HRCIGVC34T14tEfR/vo44Vho62TK3aPFfm1H9nPD/3R17jjVJ0vn9jg5r1j7B4rAFDtRC/mbvbxfYRLlgAPBBA+AXEa3BpMXIG+qadjcLegc4RKp0oxDMkbMHwWyk0oVWAm0vOO9R0tTs+ukwwUqNy3QWHhNIuH/gJ39t+Cb2GrAOFAoOB0Gc53QU2fhdQmqGloxJpspx1wK4hjDkZTMTjQwBhZovmS6wmrp3i8NsCZ+rtQj2wjv2YyHI0hVI6ELl2jQZz6O/LLX4azMU7LoDGfR5ZymPVllDmAbOsIDLOZRiqB2lNEJBbKLKG2TuDv/m8s7mvyP84eZscjP84t3WkkNldFE5xcGcCd3o3jz1GQeYJmwnKcxs19hbx5L+FolcB+BdHxBkbtJOXiBfb6/w/Tx97M3Vf/OfnMPVRLh+DcKCupUW5xB7n2iQQ72UuzuoBjCMaSywhIM65muDIs4IUKuxvz+JrPcmaL6hAwMYHRzTFZvpdT4iTHjSLx9AzG5jozZ46wvr3IirgR5R0C8xhsnIHQgsUJ3ZNWXoDhOpRGYVVpGV/qAgyNopIZ1HwKohAGu3BagrkHBiTmwyZWMkAHDxsY3SyT/J83cfq6QVYr97Db3mBXJyKMz3Khvk49HiWbfgIztYTIJjSSLHQU+HNQKYF3Ggwb1XVAuDS3IByEbmEYOZzQ7laQ4sch2A+NlJZsGyloJSxPvhMRfIzh1gU94dyA4e36mcf4EQgbGcKru+w83mTsQYfsKDi7wM70/HGCnhHNFjABwzldcFq+MWGgDZyC6R1wOgbysHoR11MOHXn8bLi4UKU++vgBg/rGL6L3QhkKQ4KhBFIlmjAiEXGCiiWGUCgDlK10v24MREKPQ1Zauy8rpUlrlIN0FlK9NHdfQS0Gw9Q9wAXd+4ZU4Hd7BNjS7tFJDJGrHZ1Fb2cdtBzaaEPX1wQ43SPAmw3t1pxIXfVVup8XiZZXG4lelwQRyZ7UWXzDGEzRJ78vEM81jkJ/LO2jj2fCSEFfOSfW21w9M8BPX7+N//K1c7z/s0e5fvswJ9baAAzl+z3AfWhcsgS4eRqmB/V9fvMclAoQXV0AFUFnhZHjR0iMhGbBZOx8QrgGG+OQL4DT0hx5sgobg3W6bZtcCtxlQf7UcdypU6AKJAUTfwJWSuA0wD4TYle+TLswjmr9rCbcvgF2Av4Y8ePDdH0DNyuZH1omf/AzxCmbIyuvRTw4h7NeoqxS2JiAT8uIaIy1kXPzBGcfpGQ0KSiFa4UEqgxRiYyo0i0NIjI1kqtOwcKrYesMg+ZDtJIJwuFhlOcTTMygdoWclCtM3xeyR84ziMJxG7hJTKo5gGUlsLDFVlBga29AoaQwoirYXeojaxQb6xSSLb46ejs/vvbT3L98E/7WOQruS+lkSxzZ00AcSXMoyBOS45zaznKyxulMg7sHwfFtTGuLppmwYzNFS7qc21lD3fwopHz8C2OY6ysMxxs0rA26D0ikOUFzLkPsFEhEBXNVkGSr0FyD0Q40J6BUhZ1fh1YA5XGoz0MrwokfxlhOCHYMQ+cK6GzX9sivscCrgrEEno1kPwIHiOmQwa7uJP2FaZLilRy//JNUouPUxwbIbyakRZfiuMt4JiI0BX5YJ9oEZbdRcQuj0iXpThJNWgQnGgRdkBVBMjEJ45PI1VeCtxfWJMxUoRNr11ZMZOU6Fq7IYMW/w/iDLezdMLwP0gl012Hj6g6zebD/LoOTVsQHe2axWzr+0wTECsiOzsDulqFWgc40mP9dMCIUwSYU5mHTvLjr6bkqF/35cB+XBtQ3isGRjvB18grZDUikQYiNYcYIoYgkWibtJRB1tDzDMnT8kDJ1JTYxABPqRU08jRhEERJL3zsyvfikaqCdnE0L2gmYkc5cjx194adj/RQsjiHsQMoE2wQ30D4RsQdWrPenCUhH9/IqT6/TsCFuI4TEtCERIaoX8SuFDRg9F+g+vhs8nwpwfyzto49vx0u2VZgayPDHXz7Nn7z9IO+9eQf/57Flluoe//H2k5ze6DA9kOHKycKLvat9fJ/gkiXArS0w07DQ1ZOU03mDcHIAVo6SP/wgu89HPDZWorMnT/3vlkkV4MJlguJhxbZNyOzWCubtF1zOjQr8QXAuQF1IKDwBg9diHi4wR5NaFqQSjOTBbQV0KkdQxgbkxyGy9BN2M41obSJaOSaaISknZL2b4ezam4jPvpH0xiCW8gkxEfi0nRat8RYyl4bjVxPVBqlZZ6in6lgDj2GMt0myY3SbV4GcRmXqcOA8TC7Dxna2VkdQ1QGwT0JlG8IIwFdE2xzuPbbBkWyI0RB0jQDq4MVdOoUa5nLASDSH3Jxna6SLcmeBQZhoMRJs4G6YuKZDG8nLFn4EQYYBNcj/LtzF1uXHePzyMtHhnezxBugYAQKb5vYLyAPLOJtnickhE8mj20bBnsM4ZjLw14O0xqvE5YCFMQtzY4RwtYVV2iJKlakbL4G4g6isw1YFVAZjICCXbdKePw3FnJ5gWindc4cBZcF4MyDrBbQuuGymI8JMAnRBbgCjlJf/ljgcxuWHKODQJk2ARShCZGLgdC+j5T2IceoU3fwEbfsnwMvjVrbodj7PqH2Ueb+OZ0BB1PE7S+QMxUm3TWikiJpQScOqmYG5NORfAd0dumJjH4bm58AYwiqVib2XQ1iC7ATrgxOMbW8xWoaW1HPczSmIipB5EMxWwsplIaoCmQWYSAEecBy6VcgPCeK0IuNoQ9jgMIx3FCoCdxPUbM+r5yJg850nbv1WwD4uOUitGA4DQCiEIVEyRkmFMNBxQVJCHGKidJE1RJtaiSerrpYup7othIgRxEhCfdMyLU1mIwMcEwKjZ5hl6r7cMNTkVihtEU+kn4j5sTbPsgUEcS8uKdau0lKbZxkEWswtnnwSFoMwUIZA9gy/AL2PKqFPy/5+8FzjKPTH0j76eCaYhuBX3rCXd3/8Yd71sQf5ZzfO8y9ePs2vfP4M//krZ1HAv7p5B186UWO+LTg0P9Q36rvEcckSYFdA04ZmHTLTsHBoGOFsMX7HMbKbLnEAKjWCMiuk28vkBaRqgnSkaI9qDxLpghmCupBifZ+Flc3h7h2FdAT+Q4jQY6cPyy48MDSBmh7BPtJB+ldqgxPhaEMsMwZfEk5dwYnpVSwP4lyB8PjL4OwrMdsmSBeBj4eBMLs09zdRjoATDnZzmqy6Bs+uEgY1kkdPQP4YFOowl4JuA6I8ZMe0wzUOKpXA9DEobEFZ4kiPmCHiE+dp7lmiOTvF4B172HXu5URLLWRU5sxLlmEjosgwV66WObW5jXPpJhuvPI9YPUtkQJwV7FzaR5ZhHjEuEKWqOHIFI8qAD2oi4cLSKltOm83td0PbRQ53yJw7z1SnS1UJmrkC0hmGgdNw9QzjX3oJcTdDa1+bQHqwazvWyjGc9gqxOooKpyBqkVaPkex8mCT1cmQ6wA1bMOHCcALyGuguaNnfpAPBKBsnRihll0jyAkZ8zMb9OEELPymStn0MXzE+3MAvfZqg+dM4GLSxSZSFTCw6wzYMj8CxLCwWQI0gVoZR9VmaahetG/6GlHUPjusTiohgxKTaTYjjDhPpDv54kdNiN8nBbTC5R8eODHdBnME8/wlwNplwH+WyTsB9s8epjfwkNBcYrC8w1NIxxI4Nh9PwxMQwB/0GFTsmKsLINWAuwuJXsqwmMaYdY2+mMGWI2ijgdhqMJ+CHkDPBHoTMKmxG0GpB1Li46+m5Khf9SVsflyJkon9MC4RQKKlzgpVE5+MqCTLGMBRKCmSMHqOEAhHrXhspwO/o3mIVI5WvCW/e0aRXmTq2yJXaIbqYemq9yN42VAiOr4l1YOpKb4Q2vopVL7rIRkuZQ22ACCTk0FdvpPfXUEgkYHyTy9WTP318t3g+FeD+me6jj2fG6w6M8+G3Xc1vfu4Yb/7IfU+9rwDLEHzw9tO9d3Q28L95/Z5+LNIljEuWAAfboJWFdABcZuBdNsjAvScZ/poLCtwcWKU6dIfxZ20GzkfMnpE4LYj36HmEGcDoLpDnQh7KOcTX7oHJH4KNuyBZglJMN4TMFoxXa6zlpvCu/L/gZBGKd0J8MxjjoLKQVqjgnxJuO0S40oLFLHQqkFZIR2L6DnkkXfMom9sbqIqF/dgsBDFJqQFtg1gsw1oXR24j/bkK7q7HUIVNpH0WNSSha/e2pyArIZ/HiDNYKw5xaog4n4eDJuYpi6E7Jti/MU2KFEGieHDsNirZL0LF42S1yo7Wz/DqeDf3uSvcufhZRKeEaZZJlRrUlwVfSV/g2NWPk0yH4GYQxyZgswQS/EaG7oHHdZlxug1dhRlLFlQa0VHYHUkwlOhi7Gieo1d2UUWpDaacCqgm8UiGWGyD7AAkDex2jdA3kGWfdPgVUjKgOfgKcDdg5ThkD0K0oqsdqTyGu4WVqtPKWSRlk9AIoVbEyxyAfAVfhnj2ThCPcNmhv+Kx+3KYnR9HSAMHQUyIVRN4y5fRyhehNQeZYdSMBTssxNeGUPf9FL54NX6mTWtIQWUFyvcxlr2PmjdGe9dPwcy8nrAGLpib4LtkNz7K9gvnGSlB3oPhZXhj/AC3OR1Ws3sZ80PKHV3IWToBXCsIrr+GBzoRb9zxZTJOiGHD4hmTzsYIAQ0qIiR2DKRh0PUdRB1MA7IR+B1wBiF/Ic2xxyXtiRDXu7jrKQdkvsPnF6mo7qOPf1RIvjVTTIlvRBspQWSneyZVaJMpBYQ6jEyQYEuTxLCIrRRIX4/hAQhfgEpQ8QY6qsDSod6WBXYK04tAJiRmpCOLhIEIuijR69lNwEBiKUXkAAKcWGIoQIFNl0QKJAI7MVFKEYuEi8kI7+P547nGUeiPpX308Z3wugPjvHrfGPefrXJ2ZYtzzZj/evcFYql4943z/NTlA09lA7/nfzzCb//wDn5icPDF3u0+XgRcsgQ48qEdw1gWjk1mMN017E91WdkSjI0oAiC7WMU51mZ1f8JgALYHbgXEBqQsSA3Bkg3VIcmuh1tkC/dxUkzSnnoNRI8jWaUbNPHXYfJwyFj4KI39izSO57DaLVYuG4TCNq2RcyxIBuCJHKRiSIXQ6gI+WJIws0JgbuHuPo28sgsLY6ioiZw8hsx4NKtXQFsijAxxoUmpNsL8A28kBFzh4mZCmuN1komY3Jk0pVqRouqSjxIKsoArYlrZDXxnjbh1kNnkAJGlOGMvsjG5gjP+OQaTOsYmNMe+zmrnekryABMyR3YjplUQnI9uRrQXkHMSte8uGF2CTQlyA7WnCGfn4MIOkokICqegKcGIIDdORymIz5EaFKjcOAxPQdqCWoCa7YC9ACIL4SBmsEZmfYlwMEVY3Auty0niJ6DURpkpQgRRkNP9bWxANA8Lh7WcMOtAvICxtkEl6WAEEG7FrJdCkkCgJidARqjmbvAHqaVvxs1c4JrXfIw7TqcQtRsQwsJIDCw8Uk/sIkr2oJRADViovV3oxqjRNsgMyP3gt6HagskYMZ6h2ZnAK78CKnt1/153C2r3QXoI8/GHcFaWGTsFQ8OwMQHZy2HKVuwxT7CR1JnaETM6DGfOQ2PWZPHqIsnYCJ4/wmL7Hg6lPbwQMonEElvYtku+LFE7FZkt6J4G/1yZ8FADy4NUHaIFONMdRZ0Yxpp8hIFdCe2LuJ6eq3LRny730YeG9oqmJx2WutobSy2JNgx9sahe1q+UoEAYCgMTJQ2UUCAkKon0yhQgFYIISFAqhkQhAJHEOpVY9Uy2hNAkW6FJuKVAgkp61dyevDnBQCiBQK8HqZBKopB9tfP3EM+nAtwfS/vo4zvDNAQvnR9kvqB4858dZudInlMbHT7x9UV+dF+Jq2YG+JO3H+Tn/uJB/uNXFnnTtTswjBd7r/v4h8YlS4AbviDdgZlrFJu7CuT+tkl8LoUz6SFMYAtUGyrlgMXtsGZBJoC2DyMFKOd0y9RSBCMZKBqgjgbsij7NIyJEHvineL5LXL1AviZpVdM49SH2txfx6hNUVZm1+jqyXNc2vWYAmVTv7maAk0DWgHaIShTh/q/QGHpCy5+iADJXEN+wRdb8DFE4SDQwDJspxKJCeRW6hoGjEjZGUmQb08x3fZLTM4RnPBzlYRJgkSVA4uOTKJOru/N8rdLm/Et8LqTvQTmgSgKsZVTT49xWnqG8T6NYRJyzKcoCIR2S9AjMO0h3CsQOrOIXSBuH6bh7IPChU9JSvoEaVL6OmakhkipmpUXgzELmjJaCT11FIEpQcXQuJT7kViBchY4D5QHYGGHMvYvWpkFJtmjED2J4Q0RMI6cuhyRCuqu6j65hwtghiE6CiqErddRI7JAInwVyGEMBSeLoZly7AqQgPQ51W1dUWqOc3NzPS6a+grHjKMloHiqSxF8jaZ1Efe2HEKe2I1UK/DwsZnREScnQE8280JnPThYWhlDhj+C1XXCLOhg620a0/goV1hHJXnZxmIwbkc5BcMrBWFVUxyPiffCIXcEwuxyPwBuBE8M5zg1djxqcg3QB5CrtkmIjC19uppjwIibMCGM6QaYhqIMhoVNpYJsGkQn1M2Ceg85WhlhOIo02zjKMDcLCRVxPfQLcRx/PHwoFSaTHCISOHTItLW0O9RJkJEQSJRXYYMQWRmSR2AqFRMaJ5qLCAMNEqAhDxcSYiDjBeDKrVwjAgEBXfZXTyyRWAtISGSukB4QxQkBkAspEYGKjECoGlZD0xbffc/QJcB99/P3h0eU2S3WPT/8/L+X9nz3K0dUWH7xzgQ+9fayXDTzPmz9yHw+cr3H9juEXe3f7+AfGJUuARc2gUkyQVwjicoh9Z4InFOUe7wkVpEPwNiE7A0UTvAjSPnQB34K1Mvg2DOqYW1KjsOZG0LwbNm8hKb2Mpvpr8qe7lFsWlvIpJIo0CR3lY3ubBA7Q7UBpAKywlx8hQTmQU5o85Y4yePrLDJw/Q9NSyP0ZtsYvg+B+omZIPNIC51G4/Frk4y4s5OiuGjSuCZAHEuRfx/h+BQFEyqFNSBabadJsw2GDTU7nH+fwzAZhLovdGCE86IP1NSiXMR64CpbeSGrrGK12kUo8QSY6QB2XUyJBhluYxCRDOyHXIGlv4dslyA6DmATyMFXUFe3SQww8cYY4gta2A3DmZigmUG6DGoCNQOdgDmRhfANOFaE9DsMnMFf/hqR1OetqhGQ+xmtmMVdrzBU3WcnUaXkSUh6ULKAJpQtQHAS/AgNXQXMd0gKiKkYnJElSJK1cT2q4B0rbodCB2gmY3ge1NKSzmLV1qn6WZPElEGQgtYJQ5zDDRaLLurDW1s3guRYEI+A4QKgjQ2QOUmmwAzBysJKCVAG8DMRNcE6QMo4SWBPQXaOVVgwUtRnOmpDY1SyptsWpcWiMvBbhP8apzDGiMKZRSqNmrwR7FMKzUFhmaSTD+eokcS3iso1V2sDIloUoxaTHoLYCTiNPuLvL6XMC8WiakQmPbjVNRJ14+ynC8QS7fnHXk4U2cHk29JP3+ujjGSDhqZJqEoOf9O4BQvflJiZCGYQkCKm0CVYvd1ckBkJEKCFQ0kECSgkMKVGGInFAKBMBOEZCLF2kElih7HXtCnCtXpaw3hmlVK8CHaNICFGofsn3HwzPNY5Cfyzto4/niyczf/dNlPitN13Gm/74bv722BZfOrbOa/aPs2tUO0I/mSHcx6WFS5YAT40njE1DOAP2mo/YyJM4LiITcb4NOQ9SvSovNrQcyLahGsHoHIRZODufphj4qKLmbGYeti2Ac67GeeMM6sAeFlWe0c08TlwiZyxjOoqkvM5oINhr/y2PyctQxrXg1iFnQ+hpabBtg+NBKoPwH2dbcp44rdjcKQjtCKzDEA8QFafAbkDzCMgBuGI/zAqCr69jlL+MeWQJ5f8ICYfoEGNgkUaSx+dC7jQPbvsaxshRmju62A9cwQ8/dCtNWtyVdAhf9hgsrjF3d4ptzWuIeCWTFFHYOBgcZokHS6fxhguIaAHSD0GiUNMF4tYBcF+qj2W6BtUGLFiI1kGquwcgY8GFq2BHHdJHYNMDP8TyXZzBDI6/QnuxTHL2lTD1BKa4n6QbQekIce1lsB4RpyaIp45yPGuBtw0yJSgsQuEcuGvQLUC0HbK9hwqD28AT0BgjGdgPyRlQ6xAbOl5k8zDGxiJmqkY0eQ7yl0PlAK2TaZ4o3ASdUVivwGaEunEf0YwFVoJqrMHMAFzYgCMZva75BBwD0msw3oDsAqxEUNsDrgJRRWRuY2DjYUSui2/YkDPwzSwTO5vEHmQSE58BLLvKYmUMZg6imiHRZpONaIludgBIdJW5ZYIcoVa6CRyH4tqDmPMxW48UWWlkmCivsv9QgjgJLAuanQjr7jL2sE/mcsj+/+z9d5xtaVngff9W3jlX7V05nRz7nNO5gYamyaIoKIiCzgw64uDjO37mdUzo+DKiTkDmUcEZeOBhBhAUUFCJ3dBN0/n06ZNj1alce9fOeeV1v3/s7kYEOpBa7P39fOpzqvZaO1S477OufV/3dZVsPLbYKHi4GdgqPbPxFAMiT3J8mF00NPQUhPh68CvxWEVmniiaJcSgx7AsDW4LBE+kKA/SnB9Lr/5HTXgFj6UxCwZvyD02FQKD1OvgH6/qin/0j3j8UYd+gJ5qHoXhXDo09HQ93vP38d7Ab3neHP/rnmV+62/Oct1slqXKYKPX4z2Eh55bnrMB8P48TI3C1jnBfKtPPeohNQzMnkXYBmzQjUE6km2CH0B8G+wJiQsHxxHRLJ6hMl9/lGhFoAxqjeAWIZ+2KUYuYe09SKAL+jGLuC3TzpjE5kFtB4w6YE3WOJP4In5t56DFzWN7u8hLgz6Mrg4pD2FHqakSWQsmXUFdCnA7RbzaDTDSB78E8THQquDfD9oo0o4yVB9E6kr0D51k9fgCeTNGRbFpJxSYswkK65BMYoyN4xSTTJ2/FTsIiBHmlhMS60svRrFzLPTnuRJdZ32hx6FLDgU7jUsHiTZhqUc/ayGSGRA3wMk47JFhtQHRFZgOg6MibYwxcjFJL9akl96JckLGnz4HYwE0JiG0gtE/jjwWMOb7CN/Hpop5zaPQzOLHFkAvQeIgVBfAk8hMfwk9WKEX0emMGKDWIZwDaw/4CTASYPhgrSO5ReROH0EcuZdG8ZK4okDgOuD1wF6GSBShT+NGRsGtopkruGO78Ob2gTYNQQ06IUhGQd6C6iJKchP/xmvBVge5xMkOdDzChYcJh7bxdIsgYRMKugRZmebIAYLOPKrfQG/fj7ZhYc6FID2KZK8TNto87GpEsz5j0z6JrR79Azatw/shvWdQyCuySdtwEZm9oGqP9Q+NP/avDSGZ9t6j3JMMyC5v069LmBUdBZOxwxBcbMFKmo5k42kO618cRzebhPQumSUD6VyYWr7DM0m2e6r2HcNVi6Ghp+uxSNYH8AZBaPDEEWL64P+jbhBAMNirK+M/sVYbIIMvkH3BYxt/sVFAEaAIPO8fB7r/tDrX0LPp6bRBGs6lQ0NPzzUT8W/oDfzvb9/Jl84VWa5bvP1vz7DVtEiFVYJA4AfDt/uea56zAfBMAUQCwg0YrYI569LrqoS9wT7JkAJ+BOQGtHqQ2ADNAGlvHPvQT4Fsoq09RLoKsTrYDBb2nDlob4GsXQRnHWuqQOua0yjbLWI6EIZOH2QbKraEPLqFP34elg5Afn3QuHXxeWCeg3gJJsehfy3F2irh7N0U03EkYeBXX4ry0PPxD98PB2+E7C448xW0rX9A12UmFIuroQLe9EHozCIQbMfbtJ+ngbgAmgfLN4F2BMf6KNGVf2BD/gDVmIybnmf/5o9zoHEjPjEELi2tjb3rbk52A55/9aeQZZ9HjzxKe+95aLUhmRq05JhXQN6GI5tI8hnUxRcRXjrKdDkFnuDCqE/2b308v08rZyNVtlD8MlJuCdnQMNuHWWp5wAY4UZAlaIUhdgSkBOGv7kAENTjyceb9JdqtEPZqjLChIge70awR5LaGHDj4cg/brRJE5xGhHr6yAVoZNVIkE1sjKvfwXYFmSKxqBaz8ixCxEdBDmjHFAACBmklEQVRXSJa/yE67zJlLf4mvy3jyLTB/EB6sw9wS+GchPo5qXSDofgWBCtk+jDcIt7c5XN5mQoaNDmz2Bgs7cggIP0wq8giT5YCSA+UUmOEopOcQ/T4bsRb048hRG1PbJDtb4+r+Bbz8iwAV4vMg6QhxzSDFPFDB7oLZAaczaG6NC+Mh2pP78U6UiJ7o0NrpcueozDE7YGLBI9vs0Gyq+NUwbSZI6C2SThxtYwwLG7euAZWnPZ6eau/a8KJtaOh7o28/tlAsQBA8scornqiIBYMjfH11mOAb062H/ll6OnuAh3Pp0NDTo8gSv/WKPfy7v3z0id7Av377DL/8V5f4+zNfT3P72Q88zGQ6zG+8bNez+GqHftCeswGwtQHxNOSiUDqh4JR08rv6hLYGsVwjNFhMlDsQK4FahYgCnekUFLJol/6OwyunyTYFrcTgB6m2QJuCdABic4nLl+7Gi8ZoRSVSYwL1hIptKqieRkuzmJnwEJ0rHB+5E3GtAvY2hvlh7J1fJPrFbTwtwJ78GUjdhr3wb7nQOApRB4oT4M0QhPsQaoLUgPYqhErIro9jBpgeiNgsytariWzECPDp72jC9CW48giEXghaDNKfIlr/JEfra7TcLJNaj9MTFZZa1yC1p9Docz5znk7q0+w59xDLjR3cH76Emv0iqbEL9CNRvNQUUq+NmJAhXIWwj7Q+Sf7uGxlppOlpCdLuCKeia/hmlE7ExjmwBVvbhKIPEs+UqTb3Il18EfMXZygqLkKy8ENN3N1t2APYUeRTs0gEmLcsgjnOI5evweiNkakf4KhXIEEUHZ0W0MdBRdAFvJqMj4OPTxOLvtyill6mdN05tPijjIo1JpNVluUN/MYouGN4XhwtaBLv9TF6Aa7zAOWpWZiU0Ct3oigdzKk3YhuTIPfBawDbYOvYJFksVGkJn1InTEM3CDf7jAuflOyj1wPyCvgdWEvLuPERcPtg1aFjIZk+sX6XVFXQCoWpj/4kRBYGVay0xGN7q1MgWeD5oBqDXp5mD6I2KNZgJdhx6b92DPPGFtV8FCXksGOxROGUjoaDjAJGH89eRpYter6CBnToMRpqc6X/9MdTlEH63tDQ0PeX+02Ltv90n6741p8NY99/9obz6NDQ99bLDxS+ZW9ggLCm8LGf24+nRnjv3Vf5lY+f4l/tlHjls/Rah36wnrMB8PZZsKOD2kjplIR+soDda5BLtxBhQdwF4YAcg1gbQh50dkA1nwPVYby0zu6Sx/o6SJ1B68Z2AWQNyjpoYR+tuYha9tlRDlCbIFoqPU3Gm7SwJj2UaeimfSRpBREtQm4/du8/wNl7iZcvY3dU7MhxSN40SOfNvBQu1gfFshIaYvcKUuoBREyAtAcmbsRpNdE2r9IydIJaHrldxRpfRIycJ66u0jn+QkTk9TC2BtOfgM0W/XCOi1aJQrhNMeLT7OZIWxniaFRZwdM+yrR1Fn9jD3PuC7g6XSQzc4GZ+3yyiSbWfJP1SJiu3AJUsGYIPZhB9O/n8q5N7ILPWuP5BKVdoLZxDi9C/kvgmYjAovfQDhbWfgXPDVHKrWCFZfTqCCIUg+xFiHZgJUUwXcf0q4w8sINk61ZUL8ZoEEFGYKBho9DBpQ8EKLTw8HGxsXGx0dHIIBENcozUoyyvhLEPdNhoekzrayzE76ZVWKKmT2FKIbZWw+wJTDp92JYt8MuwI410qYvAQuo+TKS7hRsFL6eTVNboumU8P0Qtmqbh9hF6mJFSC0uLczX6IuK9s8j6GmrDYlzAETmgaK6At85WQyKQXXS7Q6YliBxP0pszQdiAC2YfQn1QgkGVLNdFqm6ROXeO3MOX6ZoOtakRprPbMOKzeH2BYCSNmE5DXyXWX6GwBW5LxjQgGnKwRgNynSrpEZDWPHy6RDNNwjkbLjz98fRUKxdPtaoxNDQ09Fz3dFaAh3Pp0NAz83hv4PsXK7ztLx9lNhelb3tcLvf4H3ev876fv4H/9aZrecuHHubTK2V+PRBPWYxu6IffczYAVtLQvE8lPOnBHo/RK9uUN2Zo9EfIlkya0S3CuQAjgPgK6AJqMxruaAL16ueJdLdx3UHnIoBuG+ISuD5kJLiYDeNmHOLdBrkUyEsSyqRNMC/gMGxHFS4H83TiRyDQIJ6BUgJaU6DkaVyzSuz0GQqN+ymH9hKkXw12BwoeKBXwamjRLxLuLdNuToAugZJBKaQoRH2KTozQ2n3s3vd5gpjH+oogtRmgJtrUtZeD34TLWaSLLyK44TLl/ASNXXWkKzrJ8z9CzNnFitRifeYRdu05Q+XCBKb6c8y7+5jaOknJmGBz9wqTIwF0BIEloOHA1l6kRh9apyjfcB8im0FurOAdWQBxCSJdEG1Y6hOqNAmHQugrP4YTVti6fhl3lwlaDHtNhfXQIEc4sQnZcaRqlvGlGfZYWQbJfQYCiYAQNgoKMRJoOPh06WMh4xDgYOAh0cDAQEVDRRISiatpqnPjiJjE1lafQqvB+PQq9vQ2zchBVvfkqZbP4AchLOMFkDgGIQc7txecEmHtEhEjRNNPoXUapBwP1+/hKREIxZn06pi+hS/pZHsWHeUI7fhPgvFFHk3cQ3Fri7jtcGDdItKHYhKqMmxGwYuAiDvU0hHIxh/r1+kP+oR6QK+GUj3LK9pfZdeaiVXSuLARRlpfIpmGUAFcfYXlCRcieUI0uO5yFfMyVPGIjkBI8UnvgPXL0CjL5OwQ5vgmhXRAe/OZjadhADw0NDT03RkGwEND3x+KLCHLEk3T4+2v2ouhqbzmz+/ly1ca/O3JLV57bIpfesEcP3WpwvHVBs/blX+2X/LQ99lzNgDWfKDn09oC50ZIv6pP5KHLXDm1i5Q7h3NzkfWfmCRzdxlxX4jwRJdGLIXIQ/7qWfZpPuubYFqQi0BKHxRhFgmojYI1omMoVdIJi1oWxJygMAntWVge1Vl2no9jvwFaqcELimtgxsAApHHcsT2I+mlE3CMh3UnTuXVQUXnEhehJMDLIVZN818PZ3sKamEaS14kaV5ENGLvQYTM2w1K5jxvkIFHF27bxwipUr4HyGLRURLoNp29GK91C3Ogy1s6iu3MEbLM0aRG+/i6aYzql/IsQ4jKnLpVZeGQvucW3Uanex2rHQ5IX8ScE0vl59GUde/cm5osuDAK2SpEgcQi658BvQ+u2x3oC69iRR7A2r8FIh7FffAnyS4MemPW90LEHP4/NESQ3SXp5Dr2XJC2ggYaOhsBAQaAALgIfk226yGi0cLHxEHgo6AhUFARhBBIuYULozgzmCZ/eTadx8xLr7Srr5+ahZcB+B3RBr5AFawacBDSSkBQQei2MKpjVNmZpbvA7a22zxofREqeI0ia0XKcQDlgy4jSNCUa0S+ihh3G4Dnqvxxm/nrXQwyAuUdq+wkvDFSZMgb8frsTzOH2VftqjOXozpLKDqtZI4PuDjemdIoq9jmyaVA5CYt4l/7BL6bSEtRUh0vWZvt5hvaVg1DeYP94gOAdVU0KVZaK5wZ9dUoUmYLRS2MRxlSZmAToS8AxaIT1V8Zbhu6lDQ0NDT+7pFMEazqVDQ9+Zx9sd7crHiYd1fuW2HfzJHVd4+6fPcWgyRcsc7LC/b6nGTTtGUWTp2Xy5Q99nz9kAuLoYA2+B6OkrhKN9OjrM3+5DbYnLq3XSZUE9qmPujJPNdggbgvaICsoYFf0QV7vnSVltgiWV3m6P7jiYY1BKS7SEQv5Ki96YxMpkgs28RW63w5YkUYqP0pVejDBfBY0ZMDyIyFCpgVVHXf5bRKZAVHkELZAIdQT6eJOmuwXhMlL4OKJ1BvSfxN0+hLewjKx4SPImO8RxDoRNLpehnpMQdZ+uHSBUCS0RRd7lYQWTSO0HiK9cgLSPPTaNvfNliL8vkF7bQU92KUtrdBPnSC98ksBcZf3RWxBSGuYX8ef6rFwUjLQMxuqvZIVVHH0GeWuUTCNDJ72GNHofcugqflmH6Tnoz0LZxVibQ2pGcfd/Bl1bQop6OKPL2AfSkDYH1ccoADrEXei2MEpTZM6liAcSCXT6qPioWPhEkQkQdHHpqTYIH93X6NB/ojCMBYjHVoItAiwEOio9PHwCpO2dSHekENEmUieDEBlYUcAuwTUNsDW4pIPlwbSAZgS2coMWVX4H2lEwO0gzHgf9daKWhyl7eA7EPTCCPvHUFmOOoK/czZq+B3o3gDsD4XHwK9T2rHP3yt/yks1TWAKIqVgjz8eamwctC3YFLAfJbCM1t1C8DSaMi4xVLOwo1ONwQYbDB2DnskSropLdaZHYBOuvTNSmhNvfz2awzU5jm2DWxc7BeAaCNoz2FAQx1neUcX80YBTo/OVjvVaepuhjH99O8CTHhoaGhoaeeh6F4Vw6NPSderzd0eXtDsdms/zyCxe4+2KJExsdXvl/34PrD6553nP3Mp85XeJ3XrWXlx8YezZf8tD30XM2ADY0H8lLUN+MIH2lT1yH6o/B2o84KB/tMpYRrHeqdI8l0PU2TUK0b5oEzcPZucCjIwukE1/GOG/R3DtDELIwulfoaTEmH2rBJZArINIBds6glhrDiU3gBS8G6TA4MZBsUNRBwSIMwCTXOM3h1b+igoBzszQntijlDoAoElc+zlR3k1o/y/b8KEFCsBY5SpZ78PUt6r5FrQ6zDkSaPmZxg1bMAMPDTb0YqXmcTOok8eajSKrHaFtBj17iPttHCd6EQcC6tkVnwmL32P/Lq9sXuWtdotnr4MzZkOrARha5F0GlzkZ0CTH+l0jZDNKVN+EJC3Xso0Qb60Q2fERSpl5tY+oJ1OLt5DfilKb+hmzoBKPCoWGDK21SkQSicwxpOY5c00FySW55RBqz4MXx0NnCYQuBgUyIAJ0updgGzdD9eEoJb2cW2TFQrm4RiAJS5nqUThq1qaE4AXag46se/bCNIzkEgY0ikngihPCnoD2P8INBD9+2AV+bgEs5SPcGvyddG2wEV6PQDCCqg6qDa8JYH2n2YbRai1AXMj5YXRjVoSF80rRJAxNqi8/3v0I1th+s8yjeSQKvgAhfT/HwWzje/i/sbq7jT5U4Y9QIpAVoV8GpEKncz94zV0g0XOSGIDQ2iL8TNohDUMgM6mON3RaQLLcojkLlc3n65V3orCGxwYjWJ3vYp30NpCSQKmAsKjjlMTqZKrzQxBPQOw7zhwUPbz398TRcAR4aGhr67gxXgIeGvn+um80wntB5z11Xed+bMyiyxMv3Zjmx0cH1BSNxA9+2eM+br+f9967y1o+c4L0/c3QYBP8L9ZwNgNtWAp0erjXOnFTH2BewnIXtMUiFe6ymVbojEURepVHYC4ECShJwwHTASNC44XZ4AZDcCetXcJZAKirENlsEKYiqAsdO0Q+/hn7qWlDT0FLBCUB1QVXBtcDqQzgLPmw/702cv/qnZE6XKKe7dHaOYWfnwK+QbFawNYWeugtpvcL41U8zsd0gdqvH1ZBHtAjrbZgQkI7AsfGArYzFpda1BGu34hzYi+d9hGumlrioy1wq69jLR/DPvQalEmMtX8WcbWDccA/7Ly7y6EVotWXm5k5SCtbpbet40gL2aIZqd5Zw/zxBo4w0VsKLPoAdu5kgpxLUJRai0GkHWFMWZqJL4n4ZOxYmWGigehKX5Z0UWqvEdIXmg9cSK95KpDOCFCQI0SWEgsUYXfp0pQqerGLHJAKpgmO6mBNX0Wf/mpHmIiLwqfsR4kFAIt2na6j0p++htfNHsesFsLNIX80h2lHIOngzl0G5i0BMg3s9ROLQisFKDiQVZAZbjL0QVHWI+GB60LcgFAHJf6wRpzQ411cJzNs4ofWYTH2B3TWfyajAU6BQGmzZlrYgo8PzJs7w+bGPofYuM1e8SjEdpbqzgAjfyPlb/r90Hvhf3PbwWcr7TlFMqSjNEiGryrFLm2T7AZsuTCjAOnTtQYuu0QZks6D2YXsPhOtQmYDEdBWrFtDzRwgBocCEACIeaBWwapBYVXHULhzuE46AexryRyAnA597+uNpuAd4aGho6Lsz3AM8NPT9o8gSv/rCaX7j7xb5xf9znF94/hwfeHCLHaNRFss9Kh2bF48HHJtJc/38CL/4f47zB5+9wEv2FYbp0P8CPWcD4LWQRjZ/lZk5G+n2gPXJQRVn34HiS6IIPQphCSQPfBOEAV53EBjpEcAFOTXou9rrQmonHNqJiJSoLzbA86nNLeDe+GoYPQItBgWMQoCwwLCg34aYAZYKoQBaAuHsZn3037J5S4mgPwfhaWhfAblCMVpAkmuEtQqzX/sU4ZpOOyThWGBbsHcFOnFwCtCvgBuRqKfmCUq3w2yDUOIBclaRB7xpqsoxvNg4dBbAjOIkBI5RQkqf4HDtM2iyh5AhPuZTGpGZbpYJNlXOYyOmS/T1u+n3q0jbKulii3r8Mva4hJxzCU1AaBOuuGla5d2gJujqFsGEhzcfp+jcSGR7Ha2jsHLx1eTar8JWNWzFxhNNFCHhE8JCJ8YlDKPFysEIauavsfJtgt41IF0hUV0h3nMJktCVBr+big7C9jC2l2Hyb+DwLsjtQUzvgbuy4MfBlmA2Dd1LIC9C/nZY3gU5DboG4IEXHQS6uj0IchUVvMFuY7QuKBLEI4OK3PER2HbwCy9hLZagGNsm275E3K7zvEmT1hL0VqExD/m6xctDn+dkU2D3wZqNgiNDzEYU5tl4zVu5+je/S7ZTo5n8Goe0LqMdQa4FzQZgQ3EPjAPKHRJdX6JVDeNUTHKmSrPpojVVrCAgdqvPznKDr60ZBITI+zGURpfRHsQVsJogKQ7mMZvKFMSaIMpQjMDSN7VaeXJqMPh4suNDQ0NDQ9/eU82jj58zNDT0nbltZ4Y//+kjvPNzF3n9/3pwcGPbIR5S6Vge92/LbDZNZkcSvPWFO3jte+/joeU6Ny1kn90XPvQ995wNgJ//qxuE90BDh+30oIBxUxnEOJJqI2RADoMmDQKhrgaeAUp0EBBZ8iD4MQd7T+VuB6VRwo3OU3r9vwY1CdlpCBmD9jW5ERDSIPANPRZA6wH0gkFA5gYgSYNAWNpFEEyjVU+hrtxBfGuFwK6TGK3jZTzkyBJJL8GM5GDIPbzjEH4E/CT0xqGYV8iEVZZGprHnfxYlXGMy/PcUjFVWtQLbK7+IdvbFSBMn0Qt/hSy2MJ2bQVlAyB4tRaY0J3E5maJpjWNmpqmc6CNdnAVjP9LsvaTjn6OhxQlCYfrCQQqdpSBOEq35VLM65/U0rb0HEZHrIeLh7JZgrgiRNKp0AjXRYrX2ArxUjFr6v+NqOYKRAvLZlyCacVAd7NwjbE+tISZLpIO7yPnr9EoSfug+Wh0DLxpQ2SljE9BzZdodCUPxkbIKbTWHulyGXh1v3oTRAH50B9xvQjEFpoJcvkTQ3wsr+8DeBZoYLH0KwG8Nfl+qByggO2D0oWcONmlpAagaJDXoC0gboE4g2q/BER7F0Sol4xJm7S+JzzUwUqBdHhRLG98ShObhzt06Xe1GSCug2aCGCMKzHL/mNnbWPonvybQ0mZ0jPuoh2CjDViDTyMtMKh5zc4Krj0YRIoHWzVBUKqTqEoHhM3shSel5DQ7P+kytm7giic42oS0DVm3qFkTbsH2LYPkQ5MIQeRDcbQVnyqdvPbPxpFqDjPAnOz40NDQ09O091Tz6+DlDQ0PfuZcfKPCyA2P8yZcu8WdfWeIDP3eMmxZGeP3/uo/TG21++aMn+at/e/MTRbHuXaxw/VxmuAr8L8yzHgD/+Z//Of/1v/5XSqUShw8f5k//9E+5/vrrv+357373u3nve9/L2toauVyO173udfzhH/4hoVDoGT3v9DEwDfB88DXwo4AMngw93wMlwNVsHCMNnRi4AAE4HSAGncoglTm9G7VymZ1nvkqi4XA2u0rvlh2D/8XCyiCojRrgNwYryW4Aujoov+tqg2bDEQH9LsRl1JX3E+5cRHFtrqmXkTSXbkPCFIJJa1Bz6eHwKKWDGXq9FSIjBqEOlHwDeyyM/8IqFW5ke/1FiOQ40sYJrk1/lOsiJg87OmUjhxhZIVj4rxzp3kW03KCUUliaDRPMXkHyN1jkMFfXPNzMYaTTB5G6CdwDLcilSN4To6Mu0RuPI6sW/oFdBMtXSV6qYmQEba1AQ3oz0TMqYbVI//arIKJwc4R4+WNEuivUQ3O00v8aKlmM0P9mYeMC/Z5EMTqO7x7D0+N0bzkLBy5CREffug+1s85mGnRbQhd9CnaXRj9CVc4jSzWEahBgYoV9CCcQ43vwrCLq9gpy/wxB3oDxBOxyoJOF0vMIxEEI7QV/BHINEGGwBCh1iFmgmCDboPsw0oGRx1btUybEG4NjsQxcPAoiDVoIAgukCHjziKzBevarxP6mw96eRzkLEQmkGGy6Mu2MTmb1bsSH74FEiu7cUdwbf5L+xAto1L5MvOdyNZpHaReZiQvKWZlNO0rM7+PZEE1AQYG2B9OMc258m7YfUEtBpNwjehKSuwW7TnQp9UrEhEMgC/QGyCb418IjN0NrGmIV0Fd0ul2VqN8nO/nMxrHsDT6e7PjQ0NDQ0Lf3VPPo4+cMDQ19dxRZ4uaFLH/2lSWSYY2wrvCnrz/Mq/7HVzlf7HDdH9yB6foA/NlXlvjbk1vDolj/wjyrAfDHP/5xfu3Xfo2/+Iu/4IYbbuDd7343L3vZy7h06RKjo6PfdP5HP/pRfuM3foMPfOAD3HzzzVy+fJmf//mfR5Ik3vWudz2zJ3cGxZeTo4OqinV78MMY1aDfgyAasCUCNK+Oiw5uG8IFsEIgpYg/8Chsu1hqmb32VcbSDmtxkFJd0EqgyRCaAMsHWUBPQGCCb4GRRNrYRF5eQfgCEW0iUjeAM0XQmiHYWGVmZQuzmsfJbrLe0dg56dBJQqsLFOJYR36UK1YbCnEkK45Yj0A4glT/Kkg3IYIpUF1EELCkTHCmuhuzuB9xToGjFtx0me2GRPf8LjrtPQSRNMqFryJrRZicJJ4v0d4qwdrrAR+v10Ke/xz2pEdgzmPX3kB08q8J987iaSYHUz4bXo5y93WweS3x5jpm0iQd+hIdcwb5wiV2uYtszqVwZ34cVkZhWSWIqmzmQ+SjFohxAiOLOVaCY/dDdwNtpUe0XKQa5BF6QD+ZRd1cp4GKp0QQNviZHYAHiQDh90DxwVsCu48fU5H6LnRkaK7DmIAjOjywAERAKBCywFGRYicIRb9CKnyOTsHHjGfxszMgZcFsglsHo40kl1CsMl7goJgK/pgN3s0wo0A5DM0QRIAgBM1ZvPgG1eNtPDOKvqdLcbfMUmQEz4sSlupMnOviVBUi05+lKCUIXvwK6qndHOw+xMPMsRpYjNh18q2AfriHiAZULFgoQCzjQ6xMJb2N1PPBB60BGg65K9BJQXqHTeOqg9pTUVIuShU6N8DxV8JSAW60YMcZ2FjVAIv2GnipZzacJA8k98mPDw0NDQ19e081jz5+ztDQ0HfvnxbFGk+FecFYwGfXFUzXZyIVAgn+x+uP8Bd3Lw2LYv0L86wGwO9617v4hV/4Bf7Vv/pXAPzFX/wF//AP/8AHPvABfuM3fuObzr/vvvu45ZZbeOMb3wjA7OwsP/3TP82DDz74bZ/Dtm1s237i63a7DQzimXAeSh1wQxBSIW5DywFHAtMFQ4a+0KHqDNoV2VXw56HcQfnbCOm1CCplJtI+1htge08MM7wHbGeQNt2qQWwBRAepdzeia6K4MvG180x86hTaEgRxk+61cHVahrE5gqP/ht7EMVzjN3GDCkbNYGqnTWs3lDWIWDBTXaHW+TQN/fXQO4jIZGDVgkkbEf5Z2DbAcaB9FWJZqr1fAlMbpF/v1qAXwksLygfbuMHL4HiUzMX3UghKGI4gH72Xuqtz/NSPDRoJ7f4a4fSj7LxyPzNun3NSihXxb3DjP8Vo+EOsTezhVF2jrbwI4WTgmo9Qal+L0aiwt7nFmfIYhZVLqHsCKqG9oHjglSFq4paP0IpdQz/2EO6lFyL5OsHMOnhFpGaFtNWkJ0WQYzBVq1Bd7yEME6sTI2Vs44kQ3baF8FWYngT60AmBuYkaOCTDAbYh0etdQfgS2COwEzBrcEqBhApKGT32UaYm7mUs1SFlC8oWNB0obh2nI42AF0OK99CsBhHRw+0J0GW0IMAd/3u8nALbt0JPGez11uKDPyz5rdi7d9Le+iDhyyZdRbDcSTKjVrH7HTYn8uQmOyS2DNwVieijn6VzeB57dI4J8wHs4hInp/NsOh32n3cZ9QLW5sDIgxXA+M+ZXO5AMQfj50DehJYq4RQlnCr06wHSFORWNPqGwqzjYubh0ovhTAGOdGHqXrj4KYWWCcmwhKyB3X6Gg7nLYH/8kx0f+q48k2yZ973vffzv//2/OXv2LADHjh3jne985zec//M///N86EMf+ob7vexlL+Pzn//89++bGBoa+vaeah59/JyhoaHv2j8tivWWm2e4f1tmOhNmrW6y2bR4660LHJlO869vmaPUsnj7p89y2548uio/2y9/6Lv0rAXAjuPwyCOP8Ju/+ZtP3CbLMrfffjv333//t7zPzTffzIc//GEeeughrr/+eq5evcpnP/tZ3vSmN33b5/nDP/xDfv/3f/+bbg/Cg628uINMZscBXwWhAd4g61Uo4Hc9iDZAjEFXgXgU6aE1QqUkhtQlEWoxIvtcDSnUE8fAH4fAg2wOujZS+zST93wA1b1A0JaYXZGIXIbOtqBojxEOm6TXHCKtB+krO5Aa6yhscHnfAXYF91HoWLRHIXw+RK4jEzRHcQKTkfllzuz8GLZ5B6quYk9NE8zvhdo4OAZ4LVLB/6E/1sWRX45kncRonsZRRgjGb2NSvosb7Kt8xtqBG5okLzXIVAWReTBlmVOXX0zATUSu+Z/sse9kpOZgrAlKnoSNSdr6MPX0W1ke+XG4MkqreQBuXkYZ+Syhwkl6pwpQ71HvyNBfIR5qsapH8SPXg+RAeJVM6h6yhsXy2u24V38J7Dwip8DIJpKzStzs0TLj2MYEstzAW5eYULq4EajKPWxfotDrgm/TGTsC3Q44Knh9ZNkl5QSoBoi+IBFaZ8vbC/ECyHGwgbAFKQ9p/m+Jxb5EP+Wx2YZtGRIh8DwYsS1i0jo9X0K2BKoHHRFC6ijsc3pUPKhGmxCvg5WG1CjgD6p82wFEQgj5+dRem4a1y2wa5xFs0XDCJE0LQ1vD3emTPVND7U6SWl7jwtp9OLM76WwqHDnd5Xx4ipI8ya7yMmIddregp8LmuRDixyys2UFaXGCA25IZTQX0RwTuJYlgdtCxKTjokJJB+HDiBjh+DeT6sPs4bH1RolhNkEDFFz5yzOMpFiG+mfvYx5MdH/qOPdNsmbvuuouf/umf5uabbyYUCvHHf/zHvPSlL+XcuXNMTEw8cd7LX/5yPvjBDz7xtWEYP5DvZ2ho6Ft4qnmUp3F8aGjoafvHRbHe8P88DEg06iYxQ6Vre3zg3mU+eWKDcufrC2m3/NGXecdr9g9Xgn/IPWsBcLVaxfd98vn8N9yez+e5ePHit7zPG9/4RqrVKs973vMQQuB5Hr/0S7/Eb/3Wb33b5/nN3/xNfu3Xfu2Jr9vtNlNTU3gNcI1BAV7LgxQQcqDkQyqAvgNaGRQjQPgyQVCD5ARYNpJaRJ00cfMW4azAjsDp0QTGmbPk7niQ9mwGjiziXzVZuLDJ2K4Kl1JQ+LsYwVaBJh76gVViVy2s5iTCLTE3e5Gt+96N1u6R7luUj8WYzjkkNMg2JaSVPHbQ5IKnE5AifFnjqH6Jjfwl8hfBHJdZa+ZpjNyM6Pw44cqj3JQ8ycOOgtn/ENY5k9SKQD/YZWvmTiZDW+RcCeww1A+xvm+eStyitX8nwaUMPjdhTH+E6bUv49c9KrrA7cpc3T9Jb9etjJy4g/Dyh+iP/Th0M6A4GGOf5YbYcVprIU71coRyRXblXIrCo55VaBiTYOdh4z607QfI1KqMjwf0dnyJrZO3DPJ1tSZEXaJ9i0CAHLhIniAgjjJaoRWWyGoCo6Vgeiodz6XvahDqgB8G0YNuCykW4MfBAVQZ4n4AQQzasUGls4oCSgBjdRIcR3c8rI5EX47iaD5TpknUA12CsA8dVeAIGckJ8Ns+ow0b3R387YSLLt6OKiLeh7I5uIMqQ0gM3owIJyFxLUyMIIojxNc+hO2kWA4lya2fZwZBLG5hmSsUHI/2lYe5mt9NXUmyU6uSLZUoHtrN+lSJQtGkVwS3Aq7jcf6rsK8LrWWJi+d17Hac2VCH8CGb+KjAjYE0P6j6rNShthu2doBuwI6Hofw5WFqK0hFpPEwMHMJ9mC3AQ89kQLsMfthPdnzoO/ZMs2U+8pGPfMPX73//+/nkJz/JnXfeyZvf/OYnbjcMg0Kh8P198UNDQ0/PU82jj58zNDT0PfN4Uaz//oULvOfuZd7/piM8b1eeH/uzr3Fpu0uj7/DnbzzCdbMZrn/nneQTxjAd+l+AZ70I1jNx11138c53vpP3vOc93HDDDSwuLvKrv/qrvOMd7+Dtb3/7t7yPYRjfclVjrDHochS4IPchCCBkQ6YO+gJcjUMsAv2QjxvxWZcEwZkKiUtbGBsm5q0BRgz0ywpYgkjPZqTYZZQAcXaL5Lki8vIkXkrj6n4Y/XwWfX0KT9ugPdfCvEbgLdQp90xujfSQ75OZLNuUohZ6ISAx1mZqBtrrsOUJlMwqY4uQvJrCCgL6vkRiKUJY7dPbgrF+wKhW5F5/iV5fwjNNJAGHhc/SWofqKtAxUKoO4WaRs5EZzqztxB27AUSDbiRDd+Eg5KbAS6BMfJWpC18kXDLoz1poRYnQboEV3g/rt1IJ5cE4AWenBj+syShyX8Eeldg6dQiU3Ug7Ps5yRMPNLlCMlWBjCuJlZO1BIqEW2R0BdQ8YMWFyGzZ3w4QMsQLJpkRbAt20iHiLtPshmimZrhfHNGU0tUkEm7gGTsyiJVVAxJFoIGIeuiKI2WCrINnQN8LQWoAgDbY8WJ0NuUjSaRbMLdwwnE9E8Y0F5G4bxV4mZoLyWJHnuAaVjoGuOWQ9l64MWw7kkpDrBhwv1XB3XYZIBgx/0DZJc8HpD0ZZxAG/gSwustDskHEbbB+vEKwZpA9Y9CIqmj9LS17Dy9ZRt+7CTts4++AFjQZ3tLa4ui/DQmITIwfql2F72SO+qNAuBlzJS8Rvtymc8whHAmQd1I6EiAtqV0E/DsYsMALmGIzUYOpBuLikUvFDpFHw0HAjCtMjAaXaMxycDk9+4fZUF3VD39Z3ki3zT/X7fVzXJZPJfMPtd911F6Ojo6TTaW677Tb+83/+z2Sz37rdw7fbTjI0NPQ98lTzKE/j+NDQ0DP2eFGs99y9TCKsoSkyXdsjbqh0bI8/+vxFfu/V+wH4zVfu5YP3Lg97BP+Qe9YC4Fwuh6IobG9vf8Pt29vb33ZF4u1vfztvetObeMtb3gLAwYMH6fV6/OIv/iK//du/jSw//Zz8S+/PoIg+ImPh9CTCjTwNR0KlQviox9zcoHuRaoOWgc6qwL3cR2qMIEQYe7xKomtgt0YxMy2ul9q0HlSodmXC3VE2pB5j0SJnRgP0hyVai2mq8gapfTWu3i6jFGTMyCSBO86jpzcZT20S5LpUpgJeWIC8C2stg/t2RKnoXYy8z96cj9cq4ldC5IwQkV0Ou8ahX4ZIGhQbwvToTW7hqx2spkRGFZjTEGpAq20TnQTPGccs/DQSy8ADyNllEluP0PSTUFyHqEmQbLFeDqOmPNxUjKTbI5Qy8PXsoJK1egCMJrL5MUKRLRz/IGb/RTwYGYVDt0G/jxPts92IQGIEvGXIZWG6juhDK7Gf9cunyTke9rIMcR38x1pLJQtU21l2uNs0BATCJ6/12QppqE4fS4zSkSWSXp1yPE8vsxPCk6jBPdBQCMIhkBx8GSL1QaXkFU8ftLFajYAwwTAgCVK4R9r0uYKKL42DkyAI6ayoWxR0m31hcNxB9WZLt2m5OnHFp+BBNAoxEyJJoFqGmU+DFwMmIZmGaBhS8UHFcNNGKn2N2RNfZXzdxUrD/pJPs5JHPrlNbNzFjXQwi2EyJzq4Nz/KdSqMSDBSgIO9ddY1hZw72MZsvgx2nILKZR/tJpgOBKYB4Z/0SdVg/RMxXCVgdKmPdBksC+K7YTE8eLMnew6C0wqmE2aaNDYB2wSEfEHtok69HAUaT39A977L40Pf1neSLfNP/cf/+B8ZHx/n9ttvf+K2l7/85fzET/wEc3NzLC0t8Vu/9Vu84hWv4P7770dRlG96jG+3nWRoaOh75OnMk8O5dGjo++LamTQZQ/AXdy/zlkBis2nxgZ+/jt//u3Os1vr8fz52kvHkoOPMgYkkd1wo88BSjVt25p7lVz70nXjWAmBd1zl27Bh33nknr3nNawAIgoA777yTt73tbd/yPv1+/5uC3Mcv1IQQz+j5G6UjQJlm5SpVWSbpFVjAICCOeDDAP+kjpBpmro1hQrwWoh8kKBMmYAG98igXbI2e0mNuZxvzrIq5rRCogrqIERUOLVughHvMXY0RFeNsRVyWFlqMfkZFmvfZeqWEX3gF5fgVYqN/yULZ53ATYjWZv8vvZ3n/KwgiCWh8kn5kiVq6y57rHMzLDs2EQ2lWoZDx6MXBViDbgcMs8mD4XdghmfuSSQpZk3poB152N3JxlS3Hxtq7C2p3k1l9ABkf09AINB/8bajrMNNHsB/78GFs4yugpKjuiyPCfejsg4oPqxJk+0Qax9GLHsL08MI3Q/PVsL8KwQNMrtXQL7mcW3gQoc5C8xqo9BCZY0TthxmJenh1cCwJjm2AXwVMKPt4doogts2ECa0Q1GQZulFCksVeax1Xg8vBDN3Qz8HWHGgxvFwU5hbB3MQr99FbHrE6GE1Q54B8BOQIOB5EI+DY4KexMgq2HoXYFBCDchVLhDECm5QLehyKNfDlAEXyCcswGYZaB4wutBLgZyToryHHP0EgXgu6B35i0AYraQEOxpkyqe0e3QhIIbBVl9SeDeQsdH2J3J5tTp+cRL8zRctqcfdhl1ff0QddZeQFDtmyR+fLEumS4NSPgHEYOnthtQHBX41R72lEZmpMxvqoL+8y64FRg6u3QJCHYh6uhiDqwcQ6lNdT+EIihoJHkr7kEu00WG2H6IkRnlEA7ADaUxwfelb80R/9ER/72Me46667vqFd3Bve8IYnPj948CCHDh1iYWGBu+66ixe/+MXf9DjfbjvJ0NDQ98hTzaOPnzM0NPQ9p8gSr5kJ+ODlyhN7fg+MJ/j1l+3m33/8JF3bw3R9fub9Xy+8+ysfe5R3/viBYSr0D6FnNQX6137t1/i5n/s5rr32Wq6//nre/e530+v1ntjn9uY3v5mJiQn+8A//EIBXv/rVvOtd7+LIkSNPpEC//e1v59WvfvW3XLF4MjVUJriWRJBHCXSipDEJk6SDEFco+x64CULOKh1MhAijEkcjikKAaU4hEdAVHqXTHUaFRCBSVN0R1kNVxswAW8Q5lurTiQeY6kXWbxZ09UkmVwTNNZWj6aucP/a3tDNH2Uruwi03OReL0Vg4gnn4NuhsgdkC/yaIJ0idf5CRiMXDt+pcSt9I1rvC4WCThgt9GWp1MC3BpFbEiiqsjMxSDNp4G7sR4i34czZm20XeuodD5c8RXjYJ6aDtcliLSXSVIkFyJ3Qei5hCKbhuPygSotuBbeDcCEr8HkTEg5bP3gjUC9AzKmip/4Mr/wycWUAyzpEwLOyohKz4BGUZYd4Hxj4oPR97rMpmpo5Y9xFZC9rHIXoQUlHINPHVMEvVKFNRm1jfo6mHCUJZ2prM5uYK0w0PK3gpyDeB34VIBKSXgNgLc2cINIEmLRG9HKBNQi83AnYa/P6gRZECJGIE9ixldETcHFTNVnJAlbjTZ687OHVtBco6BAmFsa7HTHNQJTlUBScMa5pBEC+g1zfZc/EeKltXaF07hbXrxwj23QrtKoQ17KkpVtuPYKkaUirG/u0mAsHZI4ewSLHv/P1EtDaBrbOwbbLY1znVVJisxRG1GsUe9Ds59p3qkN9toWmgJaG/CPl2lMsBiKvzeNErvChvMXMrLKtwah5SHoQUwIOxbUg8ClK8gRzIlNwQMnliwsYW02Ro4D5lKdJ/YhgAf998J9kyj/tv/+2/8Ud/9EfccccdHDp06EnPnZ+fJ5fLsbi4+C0D4G+3nWRoaOh7ZBgADw09qw5nBX969DD/6e8vAHD9O+8EIBXWcEwXPxAsjET5jy/bwy9++BGyUZ1f+vAJ/v3tO3nbbTuH6dA/RJ7VAPj1r389lUqF3/3d36VUKnHNNdfw+c9//olUv7W1tW9Y8f2d3/kdJEnid37nd9jc3GRkZIRXv/rV/MEf/MEzfm6JUWp0CNMilF6ivReIBchjNkHGwhsVdM7qjN6VwfMl7IxBqOGTkTbQMjVqrTxNJ09WtMjKOpO39jAvtrDXPSxLwmCawEmx+pBP7fYKzT0WpjyHuKjSDsIkPZuJUwqXCgEcOYY1t4/16zyQJsEVsNQmd/UDJLwGrmtQHj/K6QMv4nL7HqzEGEhdYkslmlUIZ2FxEaInJToixui4hX8rKOsN9qzW0eOf4+Q+DXfiR0EyiTn3kg5stiyd5ugovdgYdqxGwEvAGAV/A1oXkNQwelHF5gVwfmqQQuw/xHzvk2S6HqtjGpciMzhjVbKlFqyvsjXWgm4SUZzGnpdYnClA3yJdexjVlIlq91COX0MveQs1RSCPbkIkB9vXQkofbMxWbJBUvEiE5fhh5hcfZqTaRVaWqIYNQr5PS47i+YdBacJUAKmzsEOGdg7ENH78WvpakUP7ulzMp2imXwpuftDvytcg0Ad7ddMRNu0M6C3wS0hembhvkcdHCChWoV8DSQerlcf0+oxKTdZdkJTB6nRjNI2kZdklX2C6JhhfLNLfKtJNneP8LY9iPf9VEPMRo5Mkl0IgCUxHYdOROLQD3NxuYg+fJ7osyGbbBCGJ9QMBuuzQtTWWwi0WchAdBWdRQulKPP8ExOfhyxnoHwHrygaxLYN9vseobKMYsCRDfxVuqEDwKMhRiL8a9BWICmAsoGtLJFyDx9becdHpyCMoQejJhs83GxbB+r75TrJlAP7Lf/kv/MEf/AFf+MIXuPbaa5/yeTY2NqjVaoyNDd/JHhp6VgyLYA0NPetetj/PSw+Mc8sffZl8wuA/vnwPv/k3Z9hdiHN5u8NSpcf/9fFHUWSJK+VBX7I/ueMKf/3IBr/zqr3D1eAfEs96Eay3ve1t3/Yi7q677vqGr1VV5fd+7/f4vd/7ve/6eR3up09ASTHQdIcX3dTFOQThHgSOhKtJ2K9xWH15iU4PAr+BeR6OnAH/eJKyM0cJiWm6KK5N8ZSEiYUUt4irMdxuijabtHphduuQxme7s8r50Sj2mMqOjd2sLs/TNsJg+rDWJPHwXyG5YdqjUURuH74Y4fCVDVJ0KUe+wt1KCssICLTDyM0NwvGA2gVwl0DWoOeBqthUfZWt9QLJK6usI7MwY6KkTuJek4R4mM75w3x17wGCGxRQU6Dr4N4JIgvLdeJrf02wZRJLyCxILtWRu1jN3IjdnIG5yxQvCqJtmUTKYXvfdYj6Kk7/IUbXLLajx/FjR6AWsBnEsAoTJGqXkQ2INwKSfpPoyD1cWrdwxSvwCcN2FJoyjCmQMEGpQuATVtr0KFBz58m4S6wuxNDrTSYjcGVrFJJZiHnIqa8wt/nXrMpJSKvMVmuYcsBkpM/5sREutf8twjsESgRkHwwgrYEegnCF/kgaMtdB7xJyZwlJFthNCbUuMF1wBMQ8kIVOfLxDZBtiIdi8BLVxBSt9AElqkqw7TM3AdhxEG7y1HkfPf4b7pwuI5FGIj1EcnyXTu0BmxcKfhmAKou07CVZselfG8MM9dr+wTnBAouiq2KMCeTHLJmVqtwqUI2WC89A4HWFxR5+TCSjFof/LFvmWhdaBSAVEF5b+D4xPwvS1UHNAk2Di/GA/sJ0H6wwEToBCB4ktRvCoKBK+DLPBKPVnMqC6QPAkx/vfzWgdeqbZMn/8x3/M7/7u7/LRj36U2dlZSqUSALFYjFgsRrfb5fd///d57WtfS6FQYGlpiV//9V9nx44dvOxlL3vWvs+hoee0p5pHYTiXDg39AOiqzDtes5+3fuQEf3LHZTYaJn/82kOU2zb/4RMnsdwAXZX58zceIRbS+Nn3P0hYU4arwT9EnvUA+NmSJ8tlWWIj0qWwnePMeyKk81WM1ihFex5HyOSyq6RfuoF0naBSgGQe9Gno2SbFhwIkIQjTp2qGqFd66FaYqFCwpTkaaOiEiURrJBKC5FcgW3VZONhk8yCcr0KHEDu+vMRqWMULp9l15RLtkk66HiI68Si1fUnuSyW4TbTotzyi8Sr9YBIKO4iXLjFXEmxclml0IBJREcLDm3SoXjeJPXUN+6vrJPoeV1UZq1WA85OQbiD2zCHcBvg6dM9DtzFYHhzrIhkN4uEeli5QDcGj+T3oizmk0lkm4p9D7Tu0jwac80LcnHTo1I9TjP809UKSjrpJsCuAlQrkJqjP/ixEV+hURkkbD+GG6jiRAPuqTzDVhW4YlCwUTMiakFchtwEtG1lexvIEkvMIzfh1ZO1NRq92SYtB8FYJzQ5StJWTqGtfwFzrIKkSgZYmGuviCUHVgJKbIwjvhVASYjlQuyDJ4LngyajiPMneZWqRMGgh/NQkrbaPom/QCLk0DKgLjYYyg5iKsKe8SjeAbQXWj4Edn0TE0ujmeURT0NgEeRRSbXBC0Ki6SJuXEXv2geNi7riOrXqT+OQ2t7YC1Aos+DVWt1IsIjNjpml81Wdvq8nkPofGNaBW6hgRgZQEOwvLDlinUpQ3HMZ2eSR1WJ1WWAkCGrqg8wkYvUsiYgqUfRAKgelAIKB/cVAIO+hCrQy+q2PhIbGBj0fWDxP4GuOsc+KZDKjhCvD31TPNlnnve9+L4zi87nWv+4bH+b3f+z3+03/6TyiKwunTp/nQhz5Es9lkfHycl770pbzjHe8YpjkPDT1bhivAQ0P/bLz8wBjv/Zmj/NbfnAF4Yu+vIkmoCjhewO9++hxvvmkGYLga/EPmORsA37b/HAsjPnfdl6FOksDrE+lLnGkpLOp15CDM2Kbg+Z/UiB3XEZU8+v51Kj/hsJIDSfLIjy8yMdlCvyDRNTUsMUKJED1FIRI5jZ9WKB01qCxMc9OX1glVBbG2xOGbBSzUOXc1hqr7KL0GdnYP5Vac6NIoSXrY7T67ehW2D3rcvwCzRThyR5yliQrL1ieYWFxHcsGIBvhCItOIkx3psnjEpTuTQFKX6Vzr49mgKwHG1iI2NyBZbST575h0N/EWZUTdJyYCFnffiLA7iPEdlNs3EcR8moFLoE1jHdwBiRWKIoMkyqjdNbJRB05B9sZNSkaDIP+z2NE+bHShn4FkC+QbCHlfIY1M5Zop6r0sN15YRLYE/uQkNJKQMpHqnyd6aQnDs2m4KoGaRBI+kqUiU4HINluJQ7zAvI/6TpmtdhrHuAE8B2I9QnIDkQNd7aNFAqKjgnUVdBtiyhq98hIEWbBqkNNBDh670LhMrn4PhZxFm03cYATZahGoEdysTEuDZT9BY2yGkLC50bnCnCTYDkDkwInP4S68kNHKneyxtgiAlgPGKvQl0MLQUmMEU9eC0gMc0PII6RBe98usRQJ2ZkB2YN+0w1pVpaBUSE926SSAO1VmMj7xSRc0mF2BjgFbKcjNVYjdm6L5SIA34ZO5vkVFljnYBfvLMfzKCEqoRO9Bi9XNAK8HU/vB3wR8aNQGCw2q7tGxAiw0VBJ4apOYMAn8Zzg1uDz5bDK8aPuuPZNsmZWVlSd9rHA4zBe+8IXv0SsbGhr6nniqefTxc4aGhn4gXn5gjHhI42fe/yD//vadxAyVd/zDBd73M8f4b1+4zKXtDv/ti5cB+P/96H5mc1He/IGHUGWZX/rwCd7zxiO88tD4s/xdDH0rz9kA2HZsxkXA0XSTB7aP0fRVtEaCNUbRHYdCEMdgGau1k95pgypZwqLJ/ItqjPYN+pLG+N4O4ZcJ1POC6Xt97GWbtOzR3rXG2ht1nMN7QdPAMlme2CK5rtPsu0yc9pmSJUL2DJELW1Su2aKX67Pxk69gunoXohRiSTXYqMc4dm8VedJG7YLb1Gnv00hslTj4VZ+up2EWAuo3y+S/2mZL9dntBZj1IquhI6xGoviZOFHZJGjmYPQM+9bvQU30CBcF1iKENTAj+qAAlXYULAVv4i1I8nEM625myp8nVhO45wJkQ2Lb0omOBKQUQcaFsOtyQdrG1/ogziA3TMi3CBZiID8Pr/FKpsrvY5/XY91UcTQfNw1KrYIf6EidM0w//GUKRRttDk6N6MjWOlnToa+CIqAbuZ9wROVEMU8t8XJ8MQWh/eB6kM5jh3OMddcYj3j4cpeGC11ZZ3fgEIuZ1CKn8CIp5OQ6QWoOGrMgC8K1D5P1Nmhuw4SzRTVeJSJbmBGDnpA5pUXw/Aw5f4VjnS7zCKo6FA1Y08ZwRvcTqt7PxMPrjHRAmYZqBBpRSIfBCEFFPwDaXqivgg7oLuQm6UcOcN5bxzPrZKWAyUN9putXkXIBqQTYfWhuRElsqXiGTf+SRv+hJKbk09NqBOY8PT9Lqb+JUQ8xc8EgyW76QRcvsBHMYvVl9NU+3Q2Hkb1VRuah3Ae7MfizTM9CqxxgWAqCGHXJoSO5eEJlt9oA7xkMqB7gP8lx67sZrUNDQ0PPAU81j8JwLh0a+gG7cT7LZDrMmc0WP/JYMHvzQo6//MUMN/3hndjeYN/C8bU6//OrSwCs1Ab9yn7lYycBiVceGq4E/3PznA2Av3BlN8UlDzMapWmUidp55GCZCGUCUmRYY06zsP0mm6JHi2XS821qEci9qoPUOE/v5CirrykSvR2SeZ/t5W2CMGzerOCNhMFpgxKg+hDLBniah654XLqaRJZCJPPLtG5yMJO7oacQHJ1g4+YkxqcbRL2AfLhJSGhMrEFcg9O3Nam85I3kLp3GGD9FuyUxc5NgSdZAs5EMQXsJwiEbxkB2JSQJ2vlrYGIE/FW6hszehiDkQteAXhtqnobQu+CXoT0GvSaz5ieYaJRpXYagLlO3A0hBtuPRbQsqPYXS/gg1+QX4rZeBd4ap0x9ifM3CXvY4Kf0UTIziGRmO71ll6sKn2VN3KS2obGRz+MqLQR9BGGAbEp0R8NKQ7TpsoVIfDyG6Drov0PuCqYjNiehL8asvAs2FbBg6bZB1RhyFHSEoRmE1NKghlhYuMQ2OKQF987PoG3diaBZfO/RWiO0C+yIJ81FqAroZiZntAF2yqORgBpsa4CsSMX+NnSIgpQy6P3UNuBSK0V44iGafZ2LrKsoGmC6UDsgsjeuEJBfL8HFUlW5sFpQW8tKjKNIG7swC6A4oB3HJczV9Gr21xVYS9sQFxpUsrXgduwuy6+FxCMd26LDOMnPUsBl1TDxpHR2HHYSBBpIn4dGihswyNjOUyRBBkvqMjLTJzUJoFGJjYDVBFuD2IRyAh0sfie1Qh5QakEs6bPfkZ9QFCQd4sjbcw8qlQ0NDQ0/uqebRx88ZGhr6gVFkid951V7e+pET1HuDAXhyvcliuftE8AvwmZNF0pFBGfcP/vx1bDVNfvtvz/LLHz3Bvy8P9wX/c/OcDYBVDGzRoU0EySsCCSKk2EWLablOUq6hFSxK/SpqbR6kTdJ9H6cHS9fC2JvaxN4liHwKMtfDRgyk26A9Dh3VQLE9JFFEetDg8L0NrskFXMg6VGoaEKcqu1Rv7LH0uj3YsetAiyOXr1KorNMXMxyaWWbudT6xhM9yBbaacD6eI8gvYFau0N8lYd8RxXmgx2xNIwjAnbXwY7A5egAOvpnEuU2OnrzEFafOViGE6WXZSKXZtdbGsKFWgWwTVuemIfYC8JMwC7TX6Vc9Wn1gDlJdiZwG6z2w0gGWA0dcjbv8Y5jKz0DKJPS5Oxl9OIUQJsWdHiT2ghsFv0UgkqwWYmxFZvGDowTyCHR3Q2QTPXYGZdIFC3I2NOoQSgiaqRTRbouJhkmu79P2o/jR/RCPQVoGJYCejlS7zAQlqmHoxkAPYNSCya7ASECzCjdaJv3LJqYOSqGPb+iwvU68a2LrglgFuiZE4hBLQCY0KEiNL9BkgeLBehdCDlQjMrXRBUjmSDx0iuk18Cbh4qTO6txOfDlCy93GszcIxQCthFz8FAfvvoeY6nLieQ3MAwdAssDIYrqzLKXr5BWLXZclrAsR7HiDwAkI4aLQJUGMLvtYoo6BjCr5xKUOkupgeON4OChqnQJ9Op5MVgqQRJwKPg4WI7j0TfB7kNgFlWUI+TAShXpRJo2OjY7qSsh2Bj/ZxC0EwwB4aGho6AdpGAAPDf2z9Ph+4Hf8/XmAb+gF/K6fPMQ7/uECjb5Lo++iyBIXim0+8uDaE+f8yR1X+ND9K/zcTbO87badz7TR5ND3wXM2AB7X15CnmjjNKitdmb1cYkJxUHJtpm41aS4JrAs6MUsiyiajwkcuS+zYFIyloD8h6P92G+OD4C1BFMiYMPezMKX22f6AQn1DYGwaROMq26sOfhsyXoqYKqNkmyTHBFvdGna8DP0eke0T7K4FSKqFO+/x2akpZra2yfsO3YsGEd9Dm7qTbkHilCzhhXuETIh2fQLNxQcWp1N0Dr0E4mn66j5Spy7hE8EeuxYptkRmex3fgUdHMlQyMqOlGuWFDFglSLbB2kY+/wk6TpP2RIqYNkEt0yJb3MYUMiM5D+m0zKWCjp+pg1+DqkPKKtJXNPx4m/oNt8GuODQ+A9EESDsg9Crc0A7Y3gPmWchvgrgP/cpp3MUoYbONpIA3rdBJ7EaqNciVLdIB1DSoWTKMyBBRwPPA90HV0O3zjEkmSwGk0hB3YNuTKDcFc4AVhVwUnEkYHYOwcoFu0EQa0cnXAio+ZD2QFej0YXcH0hHoO4OC0YoYXI/IcQhsWIsriFgOqdZifK0xaCs8Cu3JBH5qB/R01EaNuBfgKwFK4iqSo5AULqMVuHF9kZOaT2NuL8g2JOO0+zNI0SvYOwMyF9aROhJ2v4CFRkADhwoKR1GkNRK0SMa6JBIBimwitizOeQVkXMZGGoyVM6iSgRV0kAMPQ3i42wqy5xPkBanrYXIKWqVBtykjEHTwWJclPClEKgjRq8kko09VivSfcHnyC7fhvrWhoaGhJ/dU8+jj5wwNDf3AvfzAGC/ZV+DPvrzIu++4zI7RGFfKXWq9QeC7txDnQqmDHwj+yxcuMZ4atJNMhjVapku95/Ind1zhffdc5S3Pm+MNh9LP8nf03PacDYB3RxrsjAhM20WXprGIMTV2FmWPT9s1WF0bR+lrIDVwgRwBWaWP+1mVydM+3o8KHtwN2TfCZhu2/l+VuXxAdTmgADQelRiJQG7GpKvLdKqgXQ+ZWJWULyiOSGyMRuhpeZCLkM9jPNAmlrK5cuMK3WMq1ZFp/GqfdKRGcStGoZwkUniQC9fP0LgoDbaUJgLMlotjxwlWO+hzDugWqF1Cy0tk1nXMIwYkxhHBGEakQ6nQYGlsP/nVJfw9gkjsEk61h6Xvhe1FtEsrhGKC+oF9WPFDKMWLFPekEMZNrPsujCsE0h4Ie4PIsKvQOHSQRmYNdyyOllmjcPGd9CItPJHArPw7CL0OnBqIc4xu/j/E6j2KSZ1ubge9G/uk7usQjwjKozoiEUNSA4RdxPYgchk2I1HIJMFXBlGpZ4HUpxA9izEKO4uwUYRGXKKYzdOMOvSrHfZaLgHg2NCwwI0rENNAqKhCIgWcyRsoPSgIG8+BnjNID5Z9GLVB7YGswjLQHTEgpJKqnmNccbB80PpgaTKSW2e8fonZzRoT0cH5o+4ajZiEfwwmNiH1UECsssSdkz79+AxoMqQSyJJBeNTEOgjSSYl2R0GXusQVm3baIrINR3dXMAKP7ppEq2+gdLKUvBAV+jQ8hWY5zO4gyuyuIraosrymIyI2qiPhN6K0zvVQw4LoFLQ9UCrQlSVCxAiLEJrvskAKx2+T6naf2YDq8uQXZvZ3MkqHhoaGnkOeah6F4Vw6NPQsUmSJX719J7sLsSdWg//gsxcAaNsu//V1h/jdT5/DdH22moMN+wsjUU6sNUlHNBp9l67t8+47F3nfPTK/8Px5fuXFu4ap0c+C52wAfLZ5jCvdCp7ssD5iEZg7CW9KzJV6dNUsXVwENhGxg5x6ka4nqG/FiOgWlZLGjO9w4E0g56CcgOwbPGQLpgIofknhhJlAtmVSRRCWTzzSJLJD0HqBxFY4TSuaw8uNgWZDOEA6WUa9t0O5BvpeOGp4JO98iPK0hNqBEV9QdDIY59Yx5FUmIwFRXdCth8CewBExRjorbDnBoOJwdREp3KQxGjD3YJndqY9wfOZ6Nsd/hmL3S8wuPczzmhZrixIHlCrBdIPP2hqeliRiKFCR0JeXmfAeIbHh0nqpxurkAoH+eohmoVEdLHn7Auba2P1p9DmL2eXz5O9vo07B2TTQb0C3DIoPEZ1w7yK71kq4VYjPSpyfcQi6gnBUsChCtPUMaugiiaBPKoDmqkR7Q6KfSUMkAbIEYQE9QbT5CWbtJb5qSuRVQaIKzUDBnxmla+j0slUmyyvYJYioIEmA3ACtDnTRUj6FMjgNh1VDJd2HK2FYaEOmBiKAiDHYcmwD6+E4nrETtXgWubNNfx5Gz4EzCrGgSbL2CDee7RNtQSIDsSr424LIhODqTrB0aH5FQknAQn+TM7k8RKLgQc+Isj5hsuMaUJcC3MObXJiAdgD7PXC2N1jZDTecVNAvTrLSjdMngovDHiQ6BLT9EI8yyc7lNNOhBnN2Fmn0PFHVwb4KvTNp1FaL0R/xmXgxKAuwvKLSNUPoQkZDQkIh4Rgomw7PKNfOhSfN6RmuWgwNDQ09uaeaRx8/Z2ho6Fn1j1eD/+SOQRXoX37hDrIxA9P1mcuGWa6ZAJxYawIwk43yygMJPvLQIDW65wS8+85F3v+1ZX7h+fPDPcI/YM/ZAPguZZ3ebAtFWFjWKDP+MvkjFcYOtIiOL9JaF1y9U0a3JRzfp9hJkdcE6byL2DAob8DY+xVaNwaM3iAo3QTOOiSKsHwpjG2NkLACBDYxpcJYQrAag9W5MH4mCqoE4Q44MvLlEhN/bJHZMmgYDgVfULqrgO56TNxcxViBfq+NY9RohFLYh9MYsasU2j6XVxJUtDKy42CmZLaP3jQo71utUt01w/kb11DOQO7RgLHgIkt7fxStl6XwwDnOlRSi9QSSlmJs7zrjxy6zNT+BnQ+wJ3OM+k0KdZt2B8ZXbNYzGn7IhdAS2GvQbsNIBlk+w9zWlxi/3yS8LdiuQCEKYVllKxKCaAPCDqDi+SF8XUIIgYFA8TzyikcQhlIiDobBWH+L1IYgWgXzcgRD8fCOHoXCKOgeBAYU72fqa3djKQHmCyKs79M5eraBqYYwjFWmV3pUY3AurjPWdEi3Bn/sQsQhrIMaxZIUvJiH7wt2SS6pKpxL6YxYDnkLDB20HkhbsG2AtSsOhEmaZTrpOL1QGzvh03DhhjWH1ikHIpCbBGsTohL0m6A3YcoBZQZGVUFZhkzTJVxYwXTnQWriorARlpjJCOyj0P5yHl9vcOVVDmNVMBZgzgHzfJytIE2fNhYKM1RIECLJCDW2WJS2Oe9MMe7MYShLhCZ8Yj4kV/rUREC5IpM665NegFQOGobEBXLoksZqwudoK0mLEh4mzygAfqpTh/vWhoaGhp7c05knh3Pp0NA/C4+vBu8cjfIrHzvJb//N2SeOdexBG42b5zPcd7UOwHqtx6n15uD2hSz3LdUA6Nr+E6nRw0D4B+c5GwB7sRphxUcuGrxoxza3vqLIoRdBNwK9Mix/OobXVhCizZo5ikOSqLaGooEhIohOQGk7ApdlsksN9JeClof1HMwfMbE+G5DGZEKv4Uz7RN4A6WugofVomya+Pgq+Db6E2u2iOjI1fyeJYI24WmG7LTBjfYyWxLmJMAu+SXlXjdaPXw8TGYrhFtObZbR1nzEvgm1YXH5pBu+mXdAoo5UeIv+R82grabqyRX2fiZuXQPFwJhfoeQ+iVVNsCIHuzzN13iY7skW02KKTMtjYcy0Vs8pY9wFGHEGtLeGHNJBWiV/8ODMPXkIZU/BCBv1Mn9QVj/RF6IyC54XYujtJYnybyvP6+AcfIYgdBGUKdybMxWCaI5k1NsOCsZ5JpzLKxXEDRZRQfI+RlkAvgXNFIpntU7tlnODmF4NQIOmAr4JXx69BZ4dEb3wGaUyludIkLCyaoQK9uEIhVkepShg2eDWIxiEmrlLvLCH0Nr2uRM4DTwOvBWoNFgwHZwrkGNgy+E0wFJBLsLdX4lTbpDa+Cwo5ir0HiTk+2W1QjkNQB60Ay49CToW+Oqh1VS1rKFfCyLe2iaBgdgSGHzBdr3IpGwZhIWV7dDYE3XEofV7j4eZOJj5fJhVe5OJPBPgbcNM2+BEfX9IJiylkqU2hUEKtF7DddVTRJKprrPom5708t8km+iwkOxKmyBISCVqmjX2ixLrlEcyD1dIpoSKLgCOtUeap8gApLsuPNQp+uoYrwENDQ0PfneEK8NDQD51Bn1+Jf/fRE8xkI6zU+vzUtdO8564leu4gEI7oMrX+1wfv48HvtwqE/+fdS7z+uileun+M6+cyw2D4++Q5GwB31Hkmtrf42Z0tXvIj0E9ApwjtCPTvAuPSPtJBQJ818hRoILjcHSW12iDth2m18jhSi1GlwdaXxzBKJQovF+j7wdjps29snbwkyL3E5vJNIE1DxoclGYSiEC11CYsWjfEE/kiI3o46YluiqtikNxNkhUQj3acxEmXr9Tcjf/lepKQBM3kI+mwujFC8qcIkTUqlEJUFl+C6GfBk8JbJH3+UsdN5bCdLRm6zKi/TnDPRLn8KL3M96g6Z9FKPQBiU9AcZz5jE4oNs5fGWy8achDexh+3qaVKpHiO+INM6Th3B5NUrdCSPkZMe6g6bzVSBUlKQOLZNAnC3NDa9HFG9jBoI8qUl6pnP0i/8PPhJGjf8BI/wUZ5f2caQ4R/GQ7gTUWLlgKluA0MDRQKprXB1PEr9hn8DWhKwQLFAkdFrZSbkPoEs0DYv4TYEsUuCVNjDvs6mODNJ/nKDmc9Dqy4Tvy5gOw6u14FwDZQ49YhOsGGR7oNogp2APSZE18GJgxsBYUPMh1YZpoyAhu1wOb0TRANXEczZINagsQapMAgHVBcaAtwKBJsSkm+gMoZzqke/mWK8ZxDb2iI84lN0i/RlQarvEJdAcSFWUYigcDWd55q/byGMMvpLBBfioP9yB3HqOPXTOcaXPFIpGaEWUZ2AmCNRfXGffr3P1+4foeZMMf0PDgdiW8giyjazXAwCMm2dhHmVzSo0wxapVocAj4ncWaJjHUY2IzwsUtDYfvoDqseTr0wML9qGhoaGntxTzaMwnEuHhv4ZeuWhMd4rf71K9HvuGvQDXq72AfjvP3kNb/3IiW+63+PBb1RX6DmDJuB9N+CD963ywftWSYRUXnt0YhgMfx88ZwPg281t3nCwxexhCCxwuqCnB9Wc+wF44RVCNihyl5hTIs4UFTlHKF3FbKS47BSYESpla4KrSpVbygLjDLxsBlox2Hqhhb0A9gEIGeBUYCQD8RAU2i7Tn3GJLUosvdbh3OEQQRayBEj9NLJIIUW2MV8AkaM9XrL9VTJ3xzgX1qkdPI0zV8DPTfDIDsFO5TJBxmZ7ZDdBIg2tRYy1y4yfsrGdKFpkFW+hQ3HXUWJbK+xsneZK0KEZ98lNmwR0MUbg4jg05iWSqwKjKyH5CYSkYTwaIC8PsrV3qiUeekWHmqKS23CISdCcV2iP3wxRhbr/KVJdn8gDAYFRJaQLoq6Ct6UyWzvJ+XQLkrugfRIzLei2IFSG6Pga6YsS0zFBXAXTgJ6QUDWZzt7d4B2CwIWkApILrk/oyglWNUF4UcGd9Un0IVIbpBqnViuURJ3oosDIgHZMcN+0QjMl0Q+FByWfNQ13JEa01aazDE4WIrPglqDfgX4J9FmQEtDvglUEEYH+Tg2iIRSryGjPQStDaRmsnoSeEJgdEC1QQmCHwFNA9jR0CrSbJRxVYm/7INEv1bhl0qa10+FrahQr59EzAxwF3IRAOBpKvU6rn2PHJ7rkKyarRwIa+yAx6pP58W3c96ksfe5malKbaWOd7cBBXfPI32aSfMSj7goOtscwo1tI8TYPWy0qksqakyO+sUprw2c66XBw4SzF5TzIPeKzAS+a7dL6osddz2RAOYB4kuPDi7ahoaGhJ/dU8ygM59KhoX+m/um+YF2RKSRCtM0ud12qPOl9YyGVnuMzEtOpdL/+Lljb8r4pGH7Jvjzz8aeaKIaeylMV3P8X63VH6kxMDj53LQhnB0GLDMQOwvzzyli6jR3so8gNRGJtbvmFkxx+ex/1VUto+gWy4RVsWuTVGrGbIHEY+neD9/caSlki14eFc3DzaYh+WMb+IszpkD8D5btltrYgf6dPutMju89FM7roIo+FYMuOMLEY5uAlOIRNfE+P3IrNC/78DNd88qskq2cwCzOc3rWTs9OH8EScuc99jZ3334kbkqnt1JjOrLLnUJXFV88RzC8gNbqMVTzSS0VW98apXjvYTksIzs/EWR7NocgSyRUIFTdgbIbK/BjmQYnt/ZDe7DD9xS+SKJrsikCuL7Oz6JNpnSSYnObSyDEuRVX0a3uEbq1TSccwM3kqqd3oZ/voGyeg0YC6TcJ3aQRQ0WHiEqROCLKrMNWGYxaoeZVzt+6mf8NLBlWt3Q7kPMgkQIDWFjg9nbSrMbsF0w+phNsyuU2FPV+FF9o+id0QPQaNOWiOSpg9GaUrg9UDyaUdzdAMg+tAchwiApw2NFRwBVgbEDLBz0A6BBkdrHQCZJeMt8F0TxBeAbehYDphAhvcFsgWkIXMHpBjgqbapUMZWxOEcn2aQGN5HL4o86p1QaHVw5QkrBHY9iG132NEaRCze6SQ6bcSNL5UwLogoT0MzSI0bQjt9jC0NjWhs2Id5H7HYOXUFClkjs5X6RlQkiew82nsAx2WEx7NlMm9cpiwEeb6G6FtR9GSggmjQyALSkVwXHjhLuuZDSiXwcXbt/sYXrQNDQ0NPbmnmkeHc+nQ0D9rj+8L/oufPUo8pHJ5e9BR4+PH1wG4ZSHzLe+33R6Ud//HwS98446Ix4PhN77/IV78Z8f5D391ir95dJP7l2r4wTAgfqaesyvAqRjYHfCtQfpzQgcpCboO4Rx8opfnlLOPWS/EJAGRw1uEXxywcQ4mYzYju4uIhsrVzQYLIxaTe0D6mkr54QTL1igVrUPooSrZeQlFCtM5PYXevMD4LS6mJWG2ItQkmdIJjf5mHT0hsXdyiStXC/jCIuanCU4mmZs26UuwJNv0pixm2pD/O5dEbJuvvdoh0GfBtYh87SyZT8mIcYtItsrm6zOMFzapfy5E/OPbxA7/PROhLq4Les5mvOeiG5DcCz1ZopfeRZAaxxn7PNGTPlLThugInVtfzYOb9xBWLnJ43GTnmsvyKnQ0CJph9BM2xAUcmcLSf4yV1DqbWY92/FpEcBCCTSLFL9JdUSg8+nc4F+5ArDrsTrYxVdi2IHMORrsyhAIuFyKsaXso3vB8vIlroW2BFhqUY/bWkbYeRAQd2C+Tw8NSYMYAJSzwajLbOz3MSZDiYKmwTwOvDUe+4tF7WKUzt835n36YIHELhEGEQExCzwavBM2rEKTBEpBOgOkO3iTI7IdLkzr1iQWk7Utk/T5JBzwDbMen7XnQVAnLHoEK+Sz0NMgdAH3bRb3SoeYoZENtWtIVZH8aY7HG1L1t8tOC9hEfNwNWDEZTPi+YPs3SYhqFKNOhCttWlnOf2c8eWaA8b4mDb7UIGRKbIssCK/RR0TEwPBW5JLM32+DeaJ1zikDdjPKq/Q32dLqsSyp+ILFWj+AfN6mW54m4i0SzNlpphp60hqx5zI8+wwHV5clnE+87H6tDQ0NDzwlPNY/CcC4dGvoh8I9Xg993z1W6jxXFundpUBDrHxfHWshFWar2vuH+MV2h6/jfNiGk5wo+dXKLT53cAiCkShyYSDKZjjCRDnPzQo4b57NPWVLguew5GwCHe4NWsmYaQnHQAH8Leg34zEqeu5dewEuv/zL7gwYiojH1GpuNB2Su/sUhDNfFSyxTr8/QFTGc6Fn8msfyiZ08aIWQgJo7RsbNMHJqnDoJHGxa3hXykkt7r8C+vY91WkVLm+SrAmNVpbN6gErIwiEgZG7hyVAbheY6JB+W2YhJ2C8S3FzzCW2D1L4C6Z2gRHAll3JrDE9qkrIalOJRtnSglibdiRDvLZN85SC4uybhkurBZgHWLsBUSVDQN9nKCa6My4QOuYSmq/Qb5wgX70KPNDDEoK/triKMLIAVBynZJx4VoAN0wOzRt6chIoO8gNxdInvfQ+Q7FULCIPyAj8hWcGMQOq8QCWQie11yqMQ1mS9nd7J+4CcRN94IqgZeAFJz0Idoe4XYB97PaK2Ev9Ohukfj3NGjoPZZya4zfdFlumRxar5AZ5fGDnmdlA2lACZa0LVA1FWaCw4iEhqkVHeabCcgOAw5FzrnwK+C4oEWgZIP0RAk2pCaA9WGQO0S7qwx1YdcD8wqSDaYQkfuxJGjJcKWwFqC3PNBCw9WljurZcbTHpIn4wqooeIVr0X+9ANcf7hPuQC+BnISrBaIjseC1KGlNNGdDLNYFIJtyu4+xh/2UI9eovzFFMueYIEIYfpMMUdcXiS+HpAMw2jXYytkEjfaZHb5vOR4hZVuDJMRvmol+VdKg0z4Kku+yvOvMyk8VCaUDxibgFH/GQ4olycvmvVMH29oaGjoueap5lEYzqVDQz8kHl8NftttO74pEH48+AXQta8n42qyhBsIus7XB3pEV+g/9nUuplPtOsh841RheYLjq02OrzYB+POvLKErMJuNElIEsbDBSDzMZObrwfFzfT/xczYALq5DOAaZFFCGdhU+eC7Mopzkcur53BB7gJ98SY1eDHJ5mwsPwxc+naXdk4A6reoUMjZ5rUc2a3PlrhSnenN0qXEQHQMTpCZyaJOMAqqm4x+xWekP3sBN/GxA/u9dOp8fpfOeCFORImh98pEWTaeJkGJYjoq13efiddB7JbSyKtbOSaZXV9ktu9yruPSi7f9/e3ceJVV5Jn78e2tfuqv3rl5oum1oaEDWKASjEYEIbhGXRB1HwZPRTI7LMdFMnJNRjOZ3ghPP6CCZMWOSQWcSYExAMhgVRYgKRJB9aaBpmt73rbr25b6/Pwg1NntDL3TX8znnnu5673vvfd/3dj1VT99bb4E/hGEEWHLqsHqNZMViZDX5SFOQNbmRqn1Gjk9y0DyxmLHtBzElRdnhgulBKEg/8bXBpaqRQFsXHVNGUVZcizfFSsq+9Yz6yyEyWxVFV0BtG3TUQ2ungUlX6XTkKGIByPXV09ZZhsorAOVGazmMqeFjrDVtXP9FE106hLUwgSvAawYXEM2OkafraB5odutsypxM270PgS0fgp1g1sBsBmMA0owYPthC5t52skLpWB31NE6bQHTkDaA302Ypoe2aZPY37SGSkwpGE16vh69FuzAehdAxsFYZGWs2kTwlyNFwkEhdJRZPK/sN0JJnIccTZmQqGEOpBDwBrNYQxiiYfNBsgn1dYAqEcdbsITs7QlYQLAHo0CGggdkYxhqLYdaNdMXA0KrIqI9hdED7AROhoIlkf5hRfrAQoZIkQrqBymY3U3bWkV8cpj4fQhpYRkC3LxtnTCNNi9CtxlKolTFZ76I61k52biPUQNf+UVTRSS5u0mhiOlnYM/cw0qUT7dQoCRuxBQsoiB2n/TMzyQEnuWTRgoF0RrAmFiE1ZKNYC5Kmd+PP81FxzMHBI8kU6iGg48KfUGHAeI718qZNCCHO7XxxFCSWCjHEnCsRBqjr8Md/j5zhVmb/l5LhrsCJz0Cc6f9kRg1iX9o8HIMjzSevLPs5+Z7uFxsrMGlQnOUkyWbCZjLgNOn4Y0YcVhPTizJYeE0RFtPw/pRswibAvi7IUhDRwJIJr7c4+NAxEX2Ei4zyY8x3NeDxgWcnBNzwpz+Z2BlwYXLayfLlEMBMCe0U0ErTrhGYgqkY6CJEkNSifWS4Q/h2G7DbY9izdPQZ0DILvCYYaYMWK0TbTDR1jqCDKO3uZoq+fpg5ftjdrFH3l3wcqg0Og3Em1N7nhI40DGh83JLEzBYPI8o7OOzKBN1LLCWCe0yAlHIIr9W4xh/jvXwDrV9VxEp16jOvwLYzinmXneSru/GbwHwc0sqsVIWtOI9F+eqRKH++w0an+2aIdJG1+yNat2p06YpYBKLZYDRCrlsn3AW0QI0H9LowpjFlROyZ0OFHM6aQFt2L0xZGSwF3C7QVKqIpcOzKAvRgNpo9yrjMA1zZGeWwN422CXeC3QRpx9GOfwa2IGrMzWBtgbZyLJGD2EZ3UB/10jk2Dd0exO15h1Yti1jyCGgPYq9uIv1oBflJUWpzFXtbYOJmUDXgcuhEx/jZm5JExGjH6CtjhD2EPwRZ1jDkQ+RmyAr7COw1EkoFVzYcL4CIC3IqISkDVHMYYzpkBMHsgYgH9JARj9IxaV6MQRvJyorX68X/qYWoPYS5w0GMEEltDiJJAXINinrdQJQ0bGTR1RZl9BeNhG+NYI9AqABi2X5CHhNH1QgySENX6bg0PxMsh8gviGAphSOuFoxtRXRjIsvViDUSJM2TjsXUTVKR4sraevSjo+nqctPU5QCuxIuiAg9ubGy1FTMucoTJpQ1odjhUXsCHviIizj3kdPfyg2aSAAshxKWRBFiIYevLifBrG47wy08qCEQUnuD/Pannlmby0aFWAPJTbdR19pyPJRI7+2d9b5+cF78l+nyi6svJcU8fHmzm//2pjHSHiZHpDvzBMA6bhXBUJxyN4Y/EQGlYjAqH1YLdYqIg3cEdU/MZm3pBh78sJGwC7A9peL2KkSPhD/UGPg6loudZsewycY3/EPoVMfatHImhJYayRKn32ilREZIsddhtOrHgSFLR6Y5MoyNipJBWsi1H0WzgLA5isxjwR0fT2O7EF6rlqumN2GOQYYZgAPRmiLljTNFDlGe2U/9tH51HoXonOLzp2MkiyVVDsw2aui3QaSAnUk9ueRQfZrZarYz82E9mrIzuTAu600AoB0zVYA4pNhugfGw6tho/hlwj5rIWRn4YwNs4nmLTTkZeFcHbZaCqbjRpyoGJNiY3NdKSv4fy0mp0lUGHy0FJbhcNLRBtgZocyJwOfhtkAoZPQfeaSVER8tfsp3oB6Hku9OxxdB5NYsy7W2npiuGKxIh0xRhhgCZTO612KyHdiP8ImCrBle1Fa6tEjbCS/MF/UXpkH41ZBmr1VpzBIGnBMupK8yjPLUBZ/Jj9RmaUlVEajbLR3UZF6mgsW7aS82krlrBOhgsyUsHvgJrjJgojkDMmSudYRYvNAnqQJK2VkWkKvxV8Fgg5wREC950RupoM6PVWHJNCtMyE3C1g2gRaJlz5FfApsOng8YGugS0lhsVnRMdP0AxGk5/kEPhMNtp1I36VSzserOZOrMkKh6mTUt8h2sIzCdOGjoFRjSY6KiKER0HIDTlf91N9bComPYtmuqnDjCVSSpLWwug9TWR9NUzpKA/GNo0QPqwujcykBqzHstGqDNSFbEwZ1Y6x/SMa26bhxYmJFPwEqCKDZNr4emc6Rr5KfeO7hOt0yrot1Ce14Na9RLVevsvyc+4p9XrzncJCCJGIzhdHQWKpEEOc0aDxxJwS7p2Uxk8/qmHdvsb4uo8OtaJxYjL4U5PfZKuR7tDZ35tdaPJ7odr9Udr9nr8+OtvEqCcm7dpR3ck7fz2+3Qh2ixGL0UA4diJpRtMwoBFTOuGIgWe2r8egga6fSMYBlIKTF8AVxMehN9N76SH/+Sv9VcImwMlRyA5qGDyK1mYb0SIfhkAzUzojzBgToOHIeHYGptCkH2N0yEW+FqDC2EhBNEqaFmZE6gHMqRE+qSokqEyYTcmUzjqA41rwV2l89turccVGUE4DX/U5SNphxjkqQnMWaAbQNLBm6rRed5jca2J0uCHzjST07hD2YITC5AN4JobZ9pUkfPlZaHSTsTNKwecKZ1GY1KYwnX9JZnJTEM89QfaOS6Hsaw5sVUGyrTpH3UYiupWYy4Cj20PGX5qItZuw48eIBj7weiHZoGOPNWMnQCg1SlO+i5SDQTJ3VNKQEyVjGhgbTyTAbSNgXBGkaqA2QVPoxFcWGa6E4uYIzVVH8JeMh2AXKeVlWGtH0I6RbqJEW6pxWMOM2u1jlOUoxr/Oa6V7oMAd4lj7J3jrA6Q3HMJSo5N5TMfetZ1Jbh2XA97PaCQWVeR7Q5jDGqNbFfsjkBTuwDj+CC7NQ6TLTHPEho6fnGCMrJZUQlEdlRRBlUY5NgJCYR20VpKSvJhikG8CpYFFA7sDsnXIujKM/1ON1nqY7gVXFvjQ6AppOL06efVgiIKlFZxGOOI3UeTSqXad+LqraACysBC62U/NMSv2zx0YCBK1Wmm7NoAvxUvK5krMB3NJwYJf62ZEcz4FeytpzYhhSALTlYoWsws9lEyYdpoJY6ADo8rA3WnDFi0nf3Ynvn0tVASKaWnKxRQ4RHHEwbEvSuhQxYS7NpNlDNNCKjHy6NT2YqWeUpVONRau5SipXElNXQkOaskwNGCKJqFiGinRbKD5wp9QYSQBFkKIS3G+OAoSS4UYJowGjaX3TeXmiU0s/uMBWrwnZoL+csKnfelxss18zgT4chGIQSAQo+ftKl9OZQ1ELmAyv/6e1zphE2BnxInT7eOTWgefKzOa3UhSQzfjLG2sOzaKSm0SLdO8GCvSaPKHCGfUErGm09ydTr7vGF+b2Yg+SpG8Yj9Wg4PM/FZMV4NrEtQeMrDdqkgy7qXI5+MANlKOp+JqbsGRD9EYKB9YCsCRG8GcCeNrwebS8TZloJTO8bGtBG+GQEESZj3EiEPt5LUoOAI1HRBNB7J8lO/Iorg8g9I5VRz6hsb2b5lJbQphT41hDrUxOhbC0wb5ThijbHhdHeQVxKgZB8cydRqKKkmrjTI5pGgoitGalIJqDNHV5CKlFTwZ7aRO1AkcB6sFOvZDsAy8dRDqMpPtiGFqBYcdovY0CFog3EaOo5FwlhlLxIxujzHGGSGUDhl2KB8LWUZoqoS8qeCPGAgYnWBy0Dw5ixx3LWMC0Napc1yDGXaY2BzkWCc4j0LmaMXRVEgKg8Wvk71lH+2TXDiDiqTPI3S3mXGYY6iYDbOzG+tsH3Ul0GCDZM1Du0GjK0djnwKbD+wxSAmB3QnNEei4VpFbrnBuNxD0gH6zjiPPTH1ZAbR24DzWTjQEms+ASVcUaTHKu8DhN2JKj0FAR2UHsReDOzOEv6kcU3UqTkc3NUZIHgUZVUGyjzTQFR2Fx1hLbWQcKe9FiZUcx5UDGQU6OXlVHKnMw0eEJlsD1liAiDGJ9lAGnTXlOKwKgzKgE6Q+YqOtbRSKPPYrRQQXjdXf4CptM8VY8GMgjwBRDTKUDztBdmBnCp2YKUChU6QHmejLpUWrpoB8epUAR+Cc0w3KDP1CCHFu54ujILFUiGHm5km5zLsyh22V7aw/0MCaXfV0/vWzvl9+ujd5ghgNEDvDP8HOd3X48nLy+u7gStgEOA0nxzwxVnXnECiqxtxezI3tTRwNF7E9KZtYYRNkZ6J7o0Ta6sHegcnjxejvJhrp5ngrZKbBDTe10FAN4UYDbR+COgJVjTrB5HrSmn20k07EZMZwRTf2fLgyDFVdEPaDpx3Si8C998R34R7P9xNuDhHQUwhVJhHq8DAyvxnXEZ28o+A4BCPGA07oagLNpDMyuxXVkkTq/6YxIVxLcykEasCpw6hwkNQgRJ0Gmucoxrq8jJzZTXUStLaDo1mjRA/SOU7DpykcGjgsXgKtihBuomGoLvfiLAhSX6yR51cED0CtD1QE0jQdzQ6u6dA0A6JEoeUYBI10uoyklobJzArTkgJeB3gCkGGBMTEYZYT/SrXzeZsTPTmJmM2B8dh+nGUd2HNOXFU+oBlIMejsqwd3AEbs0eiutdKeE0RdceKriwydBlLfC9HSYKT6lmmkFOzD/EcfNj+UZNVjsYM1H7a7Tnx1UzI6AU8X/qid47lmsEYxN8bQC3WUZkZhwazr3JDtp7EGtKNWshsD2CxRRqU2oHUbiCaBN2BAa3TTTYQUSxvZRgMGv5OcSR66rZCRBkkalGZA17VeOvb5CNWacG2xMrLQj1YM7i1BGrxV2KLjaCeV9NY2nJ0aWZUKSwRCGY3kVwYJASlBF+3GAJ16HftdjUxzQmoA6mIRmoAinGTiI4AiDRMBKrHrOdSQhAMXZvLxqHl8oqpxcIC5Wh1Vyo2LI2QxEp10QjiZhKJFORnR2+/aCDNoCfC4ceM4dOjQGde99tprPPbYY/13cCGE6Cvni6MgsVSIYcho0Jg5KoOZozL4p1snnDEZjp3jfuCofA9wryVcAqzUiT+SGpzs9tgx0IK9yoxNtdOtsjiouYkZa0AvgIZq6NDRuiNoRgtXNmeSr1WQrTvwH7TgcoWIWSCw30gu4GuBPcfMNMYymdiZQYFyEjW0kzquifAk8DeDPQi2DjAeAr0W+AqUbbYQ9kLQGqE9ZiRtTDu5tUYcW2Fass7RMISi4MmGUCk4r4f8KrAcA/O6GPWZFaQYIccA4eMwVQNbGApaoXYTZKLTnAGdxVARguwgNB+BI3o+Re2tfOXTKPUmMGRGuTYcoDpgxBMNYsZHUbvC5YJmh8LWBU254GuEETngqIhRMBqSJ8IRF2R0NBL2Q5cvjdppDlozPKQZTlwULlPgMoCrHmIjoLYFAqYAuilCzGSG9kpGVDQyokonVgufm6B7jI6/Hlxp0F0N5lRFcjRIdxLUh6G9y0zIPhKmgNVcRawsildZyO/2kT0DIk7QFBy2wtFysLSDNQqukE76CB/mdoj5IckDDWbocBkwaAFs3hiqGEzdOmkjA+SmgOFqnWCKH22bAb8bqlw6poZWIsEkkhyKsCeVUr0I08FDaFf4CJjBtA1yHCe+XzjXqvhUGQlVjabpV0dwOYLYQ7WABTPjqaWMoPkYaZsVTf974vuDrRUaydqn2FQWTdjoiFmxGsM0WY0cL4dYRMMTy6TBbCcW8eMihTb8uPBRQBV1NFFOB3CMLFLJJIOxjMdPC4bkPaR6dApIwUcqx4mwHzMx2ijFgPWU58v5eM48l8L/rT/50+PpUW61WrFaradv0At/+MMfmDBhAhs2bGD8+PGEQiGKi4tZtWoVt9122yXtW5zdhf5tCJHo+iqOgsTSRHby76i7uxuz2dyvx9J1PX4cg6F3swH3ZtsLqXuuOmdbd6byU8tOfRyJRPD7/Xg8nkEf3wlZZibMGskTXy9gx/EONhxqZPWuOgLhM38Gwhfq1+YOGSc/A3xBMVclmIqKipP/Q5FFFlnOs9TU1Jzz+RQIBFROTs4F7SspKem0ssWLF1/yc/rjjz9WJpNJBYNBpZRSX3zxhQJUY2PjJe9bnJ3EUllkubClL+MoSCxNVBJzZZHlwpbzxVyllEq4K8Dp6ekAVFdXk5KSMsit6Tsej4eCggJqampwuVyD3Zw+Mxz7NRT6pJSiu7ubvLy8c9az2WxUVlYSDocvaJ+a1vP+vrNdsXjmmWd46aWXzrm/srIySktL2bdvH2PGjInva8+ePWRnZ+N2u8/bJnHxhmssvVRD4fk9GBJxXPojjp7cr8TSxDPQMffqq69m+/bt/b7thdQ9V52zrTtT+allX3480DEqEcb31LL+HuMLjbmQgLdAn7zVICUlZVi+CLtcLunXEHG59+lCX2BtNhs2m61Pj/3UU0+xaNGic9YpLi4GYO/evUycODFevmfPnh6PRf8Y7rH0Ul3uz+/BkmjjMphxFCSWDicDHXONRuNFH6c3215I3XPVOdu6M5WfWnamOgMVoxJhfM9W1p9jfKExN+ESYCHE5S8rK4usrKwLqrt3714WLFgQf7xnzx6mTZvWTy0TQoihQ2KpuFiPPvrogGx7IXXPVeds685UfmrZpfTxUiXC+F7o8QeDplRizWTi8XhISUmhq6trWP0XWvo1dAzHPg0WXddJTk5m1apV3HrrrQAUFBTwwx/+kCeeeGKQWze8yd/xmcm4nJmMy+VNYunlT55D/UvGt/9dTmPcu6ndhgGr1crixYsvebbEy430a+gYjn0aLBUVFfj9fiZNmhQvmzhxIosXL2bz5s2D2LLhT/6Oz0zG5cxkXC5vEksvf/Ic6l8yvv3vchrjhLsCLIQQQgghhBAiMSXcFWAhhBBCCCGEEIlJEmAhhBBCCCGEEAlBEmAhhBBCCCGEEAlBEmAhhBBCCCGEEAlhWCTAv/jFLygqKsJmszFjxgy2bdt2zvpvv/02paWl2Gw2Jk6cyJ/+9Kce65VSPPfcc+Tm5mK325k7dy7l5eX92YXT9KZPb7zxBtdddx1paWmkpaUxd+7c0+ovWrQITdN6LPPnz+/vbpymN/1avnz5aW222Ww96lwO5wp6169Zs2ad1i9N07jlllvidS6X8yUSW1/H1uGiN+Ny4MAB7rrrLoqKitA0jVdffXXgGjrA+vp1SwghhOgPQz4BXrVqFT/4wQ9YvHgxO3fuZPLkycybN4/m5uYz1t+yZQv33Xcf3/nOd9i1axcLFixgwYIF7N+/P17nn//5n1m6dCmvv/46n3/+OU6nk3nz5hEMBi/LPm3atIn77ruPjRs3snXrVgoKCrjxxhupq6vrUW/+/Pk0NDTElxUrVgxEd+J62y8Al8vVo81VVVU91g/2uYLe92v16tU9+rR//36MRiPf+ta3etQb7PMlElt/xNbhoLfj4vf7KS4uZsmSJeTk5AxwawdOf71uCSHOb926dYwdO5aSkhJ+9atfDXZzhqU77riDtLQ07r777sFuyrBTU1PDrFmzGD9+PJMmTeLtt9/u/4OqIW769Onq0UcfjT+OxWIqLy9P/exnPztj/W9/+9vqlltu6VE2Y8YM9d3vflcppZSu6yonJ0f9/Oc/j6/v7OxUVqtVrVixoh96cLre9ulU0WhUJScnqzfffDNetnDhQnX77bf3dVN7pbf9+s///E+VkpJy1v1dDudKqUs/X6+88opKTk5WXq83XnY5nC+R2Po6tg4Xl/J8LywsVK+88ko/tm7w9MfrlhDi/CKRiCopKVG1tbWqu7tbjRkzRrW2tg52s4adjRs3qj/+8Y/qrrvuGuymDDv19fVq165dSimlGhoaVF5eXo/3xP1hSF8BDofD7Nixg7lz58bLDAYDc+fOZevWrWfcZuvWrT3qA8ybNy9ev7KyksbGxh51UlJSmDFjxln32Zcupk+n8vv9RCIR0tPTe5Rv2rSJ7Oxsxo4dy/e+9z3a2tr6tO3ncrH98nq9FBYWUlBQwO23386BAwfi6wb7XEHfnK9f//rX3HvvvTidzh7lg3m+RGLrj9g6HPTF83046s/XLSHEuW3bto0JEyaQn59PUlISN910E+vXrx/sZg07s2bNIjk5ebCbMSzl5uYyZcoUAHJycsjMzKS9vb1fjzmkE+DW1lZisRhut7tHudvtprGx8YzbNDY2nrP+yZ+92Wdfupg+nepHP/oReXl5Pd6MzJ8/n7feeosNGzbw0ksv8ec//5mbbrqJWCzWp+0/m4vp19ixY/nNb37D2rVr+e///m90Xeeaa66htrYWGPxzBZd+vrZt28b+/fv5u7/7ux7lg32+RGLrj9g6HPRFfB6O+ut1S4hE8Mknn3DbbbeRl5eHpmm88847p9U51+fr6+vryc/Pjz/Oz8+XjxKc4lLHWJxbX47vjh07iMViFBQU9Gubh3QCLE63ZMkSVq5cyZo1a3pMGHXvvffyzW9+k4kTJ7JgwQLWrVvH9u3b2bRp0+A19jxmzpzJgw8+yJQpU7j++utZvXo1WVlZ/PKXvxzspvWZX//610ycOJHp06f3KB+K50sIIS7G2V63hEgEPp+PyZMn84tf/OKM6y9m/hTRk4xx/+qr8W1vb+fBBx/kP/7jP/q9zUM6Ac7MzMRoNNLU1NSjvKmp6ayTjeTk5Jyz/smfvdlnX7qYPp308ssvs2TJEtavX8+kSZPOWbe4uJjMzEyOHj16yW2+EJfSr5PMZjNTp06Nt3mwzxVcWr98Ph8rV67kO9/5znmPM9DnSyS2/oitw0FfxLHhaKBet4QYjm666SZ++tOfcscdd5xx/b/8y7/w8MMP89BDDzF+/Hhef/11HA4Hv/nNbwDIy8vrccW3rq6OvLy8AWn7UHGpYyzOrS/GNxQKsWDBAp555hmuueaafm/zkE6ALRYLX/nKV9iwYUO8TNd1NmzYwMyZM8+4zcyZM3vUB/jwww/j9a+44gpycnJ61PF4PHz++edn3Wdfupg+wYnZkF988UXef/99rrrqqvMep7a2lra2NnJzc/uk3edzsf36slgsxr59++JtHuxzBZfWr7fffptQKMTf/u3fnvc4A32+RGLrj9g6HPRFHBuOBup1S4hEcyGfr58+fTr79++nrq4Or9fLe++9x7x58waryUOOzO3Qvy5kfJVSLFq0iNmzZ/PAAw8MTMP6dYqtAbBy5UpltVrV8uXL1cGDB9UjjzyiUlNTVWNjo1JKqQceeEA988wz8fqbN29WJpNJvfzyy6qsrEwtXrxYmc1mtW/fvnidJUuWqNTUVLV27Vq1d+9edfvtt6srrrhCBQKBy7JPS5YsURaLRf3+979XDQ0N8aW7u1sppVR3d7d6+umn1datW1VlZaX66KOP1LRp01RJSYkKBoMD0qeL6ddPfvIT9cEHH6iKigq1Y8cOde+99yqbzaYOHDjQo++Dea4upl8nXXvtteqee+45rfxyOV8isfVHbB0OejsuoVBI7dq1S+3atUvl5uaqp59+Wu3atUuVl5cPVhf6RV+/bgmRiAC1Zs2a+OO6ujoFqC1btvSo98Mf/lBNnz49/njt2rWqpKREjRo1Sv3yl78cqOYOSRc7xnPmzFGZmZnKbrer/Pz80+qLEy5mfD/99FOlaZqaPHlyfNm7d2//trNf9z5AXnvtNTVy5EhlsVjU9OnT1V/+8pf4uuuvv14tXLiwR/3/+Z//UWPGjFEWi0VNmDBBvfvuuz3W67qunn32WeV2u5XValVz5sxRhw8fHoiuxPWmT4WFhQo4bVm8eLFSSim/369uvPFGlZWVpcxmsyosLFQPP/xw/I3JQOpNv5588sl4XbfbrW6++Wa1c+fOHvu7HM6VUr3/Gzx06JAC1Pr160/b1+V0vkRi6+vYOlz0ZlwqKyvPGJ+vv/76gW94P+vL1y0hEtHFJmfiwskY96+hMr6aUkoNzLVmIYQQQgghxJlomsaaNWtYsGABcOL2UYfDwe9///t4GcDChQvp7Oxk7dq1g9PQIUzGuH8NlfEd0p8BFkIIIYQQYjiSeQf6n4xx/7pcx9c0aEcWQgghhBAigXm93h7f8FBZWcnu3btJT09n5MiR/OAHP2DhwoVcddVVTJ8+nVdffRWfz8dDDz00iK0eWmSM+9dQHF+5BVoIIYQQQohBsGnTJm644YbTyhcuXMjy5csBWLZsGT//+c9pbGxkypQpLF26lBkzZgxwS4cuGeP+NRTHVxJgIYQQQgghhBAJQT4DLIQQQgghhBAiIUgCLIQQQgghhBAiIUgCLIQQQgghhBAiIUgCLIQQQgghhBAiIUgCLIQQQgghhBAiIUgCLIQQQgghhBAiIUgCLIQQQgghhBAiIUgCLPrFrFmzePzxx3nyySdJS0vD7Xbzxhtv4PP5eOihh0hOTmb06NG89957wIkv0dY0jQ8++ICpU6dit9uZPXs2zc3NvPfee4wbNw6Xy8Xf/M3f4Pf7B7l3QggxMCSWCiGEEH1LEmDRb958800yMzPZtm0bjz/+ON/73vf41re+xTXXXMPOnTu58cYbeeCBB3q8CXv++edZtmwZW7Zsoaamhm9/+9u8+uqr/O53v+Pdd99l/fr1vPbaa4PYKyGEGFgSS4UQQoi+oyml1GA3Qgw/s2bNIhaL8emnnwIQi8VISUnhzjvv5K233gKgsbGR3Nxctm7dSjAY5IYbbuCjjz5izpw5ACxZsoR//Md/pKKiguLiYgD+/u//nuPHj/P+++8PTseEEGIASSwVQoizmzVrFlOmTOHVV18d7KbEaZrGmjVrWLBgwWA3RZyFXAEW/WbSpEnx341GIxkZGUycODFe5na7AWhubj7jNm63G4fDEX/DdrLsy/WFEGK4k1gqhBBntnr1al588UUAioqKBjQRfv7555kyZcpp5Q0NDdx0000D1g7Re6bBboAYvsxmc4/Hmqb1KNM0DQBd18+4zan1T5Z9ub4QQgx3EkuFEOLM0tPT+3yf4XAYi8Vy0dvn5OT0YWtEf5ArwEIIIYQQQoghZ9asWTz55JPMmjWLqqoqvv/976NpWvwfgwCfffYZ1113HXa7nYKCAp544gl8Pl98fVFRES+++CIPPvggLpeLRx55BIAf/ehHjBkzJn4HzbPPPkskEgFg+fLl/OQnP2HPnj3x4y1fvhw48Q/Gd955J77/ffv2MXv2bOx2OxkZGTzyyCN4vd74+kWLFrFgwQJefvllcnNzycjI4NFHH40fC+Df/u3fKCkpwWaz4Xa7ufvuu/tjOBOGJMBCCCGEEEKIIWv16tWMGDGCF154gYaGBhoaGgCoqKhg/vz53HXXXezdu5dVq1bx2Wef8dhjj/XY/uWXX2by5Mns2rWLZ599FoDk5GSWL1/OwYMH+dd//VfeeOMNXnnlFQDuuecennrqKSZMmBA/3j333HNau3w+H/PmzSMtLY3t27fz9ttv89FHH512/I0bN1JRUcHGjRt58803Wb58eTyh/uKLL3jiiSd44YUXOHz4MO+//z5f//rX+3oIE4rcAi2EEEIIIYQYstLT0zEajSQnJ/e4BflnP/sZ999/P08++SQAJSUlLF26lOuvv55///d/x2azATB79myeeuqpHvv8p3/6p/jvRUVFPP3006xcuZJ/+Id/wG63k5SUhMlkOuctz7/73e8IBoO89dZbOJ1OAJYtW8Ztt93GSy+9FJ/DIS0tjWXLlmE0GiktLeWWW25hw4YNPPzww1RXV+N0Orn11ltJTk6msLCQqVOn9sm4JSpJgEW/2LRp02llx48fP63sy5OQnzoh+aJFi1i0aFGPsueff57nn3++D1oohBCXP4mlQghx8fbs2cPevXv57W9/Gy9TSqHrOpWVlYwbNw6Aq6666rRtV61axdKlS6moqMDr9RKNRnG5XL06fllZGZMnT44nvwBf+9rX0HWdw4cPxxPgCRMmYDQa43Vyc3PZt28fAN/4xjcoLCykuLiY+fPnM3/+fO644w4cDkev2iL+j9wCLYQQQgghhBh2vF4v3/3ud9m9e3d82bNnD+Xl5YwaNSpe78sJKsDWrVu5//77ufnmm1m3bh27du3ixz/+MeFwuF/aea6JCpOTk9m5cycrVqwgNzeX5557jsmTJ9PZ2dkvbUkEcgVYCCGEEEIIMaRZLBZisViPsmnTpnHw4EFGjx7dq31t2bKFwsJCfvzjH8fLqqqqznu8U40bN47ly5fj8/niSfbmzZsxGAyMHTv2gttjMpmYO3cuc+fOZfHixaSmpvLxxx9z55139qJX4iS5AiyEEEIIIYQY0oqKivjkk0+oq6ujtbUVODGT85YtW3jsscfYvXs35eXlrF279rRJqE5VUlJCdXU1K1eupKKigqVLl7JmzZrTjldZWcnu3btpbW0lFAqdtp/7778fm83GwoUL2b9/Pxs3buTxxx/ngQceiN/+fD7r1q1j6dKl7N69m6qqKt566y10Xe9VAi16kgRYCCGEEEIIMaS98MILHD9+nFGjRpGVlQXApEmT+POf/8yRI0e47rrrmDp1Ks899xx5eXnn3Nc3v/lNvv/97/PYY48xZcoUtmzZEp8d+qS77rqL+fPnc8MNN5CVlcWKFStO24/D4eCDDz6gvb2dq6++mrvvvps5c+awbNmyC+5Xamoqq1evZvbs2YwbN47XX3+dFStWMGHChAveh+hJU6fOliGEEEIIIYQQQgxDcgVYCCGEEEIIIURCkARYCCGEEEIIIURCkARYCCGEEEIIIURCkARYCCGEEEIIIURCkARYCCGEEEIIIURCkARYCCGEEEIIIURCkARYCCGEEEIIIURCkARYCCGEEEIIIURCkARYCCGEEEIIIURCkARYCCGEEEIIIURCkARYCCGEEEIIIURC+P8mBohfRTPpRQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ - "qNewton: 100%|███████████████████████████████| 200/200 [00:50<00:00, 3.94it/s]\n" + "qNewton: 100%|██████████| 200/200 [00:14<00:00, 13.45it/s]\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA8AAAAEjCAYAAAD9mWieAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3XecJVWd8P9PhZtz39s5T/fkCDPkMEMGiSogKIoKiiuYMKzorggGdsVFf+uDIK4RAyiouAbCkMOQZpjMpJ7O+eZcdavq/P7oZ/qhmdQDA4NOvV+vfkGdOlV1qqbr23XqnDpHEkIIbDabzWaz2Ww2m81m+ycnH+oC2Gw2m81ms9lsNpvN9nawK8A2m81ms9lsNpvNZjss2BVgm81ms9lsNpvNZrMdFuwKsM1ms9lsNpvNZrPZDgt2Bdhms9lsNpvNZrPZbIcFuwJss9lsNpvNZrPZbLbDgl0BttlsNpvNZrPZbDbbYcGuANtsNpvNZrPZbDab7bBgV4BtNpvNZrPZbDabzXZYsCvA/6C+/vWvI0kS8Xh8v3nb2tr48Ic//NYX6h3kwx/+MG1tbYe6GDab7TAgSRLXXXfdoS7GQfHzn/8cSZLo6ek51EWx2Wy2fzgrVqxgxYoVB21/lmWxYMECvvWtb02m/aPH6QcffBC/38/4+PghK4NdAX4H2bRpE1dccQWNjY24XC4aGhr4wAc+wKZNmw510fbp29/+Nn/605/e9uMODQ3x9a9/nbVr177tx96X3/zmN3z/+98/1MWw2Q5rux4Qdv243W5mzZrFddddx+jo6KEu3iF3qOL2vjz33HN8/etfJ51OH+qi2Gz/9F4fI1//8/zzzx/qIh5S75RnzN/+9rf09/fv9yXrD3/4Q37+859Pe7/33nsvV1xxBTNnzkSSpH1W2levXs3ZZ59NMBgkEAhw5pln7vG6PPzww1x11VUsWLAARVH22hB19tln09nZyS233DLt8h5s6iE7sm2KP/zhD1x++eVUVVVx1VVX0d7eTk9PDz/5yU+47777uOeee3j3u9/9hva9detWZPmte9fx7W9/m4svvpiLLrroLTvGngwNDXHTTTfR1tbGkiVLpqz78Y9/jGVZb2t5dvnNb37Dxo0b+exnP3tIjm+z2f6fm2++mfb2dsrlMs888wx33HEHf/vb39i4cSNer/dQF++Q2Vvc/uAHP8hll12Gy+V628v03HPPcdNNN/HhD3+YcDj8th/fZjsc7YqRr9fZ2XkISvPOsa9nzH15+OGHD2o5br31Vi677DJCodBk2p7i9A9/+ENisdi0e3zecccdrF69mqOOOopEIrHXfGvWrOHEE0+kubmZG2+8Ecuy+OEPf8jy5ct58cUXmT179mTe3/zmN9x7770ceeSRNDQ07PP411xzDV/4whe46aabCAQC0yrzwWRXgN8Burq6+OAHP8iMGTN46qmnqK6unlz3mc98hpNOOokPfvCDrF+/nhkzZhzw/g/Fg8yh5nA4DnURbDbbO8A555zDsmXLALj66quJRqPcdtttPPDAA1x++eV73KZQKODz+d7OYr5jKIqCoiiHuhg2m+1t8toYOV2GYWBZFk6nc7d1bzZ+CiEol8t4PJ43vI9DoVgs4vV693hN3qhXXnmFdevW8V//9V9T0g9GnL777rtpbGxElmUWLFiw13z//u//jsfjYdWqVUSjUQCuuOIKZs2axVe+8hXuv//+ybzf/va3+fGPf4zD4eC8885j48aNe93ve9/7Xj71qU/x+9//no9+9KNv6lzeCLsL9DvArbfeSrFY5K677ppS+QWIxWL86Ec/olAo8J3vfGe3bePxOJdeeinBYJBoNMpnPvMZyuXylDx7+gY4nU7z2c9+lubmZlwuF52dnfznf/7nbq2mlmXx//1//x8LFy7E7XZTXV3N2WefzcsvvwxMfPtWKBT4xS9+MdltZn9vnzRN48Ybb6SzsxOXy0VzczNf+tKX0DRtSr5HHnmEE088kXA4jN/vZ/bs2XzlK18B4IknnuCoo44C4CMf+cjksXd1/3j9N8A9PT1IksR3v/tdbr/9dmbMmIHX6+XMM8+kv78fIQTf+MY3aGpqwuPxcOGFF5JMJqeU54EHHuDcc8+loaEBl8tFR0cH3/jGNzBNczLPihUr+Otf/0pvb+9kmV5bjumeu81me2uceuqpAHR3dwMTscLv99PV1cW73vUuAoEAH/jAB4CJB7nPf/7zk3Fy9uzZfPe730UIscd9//rXv2b27Nm43W6WLl3KU089tVuewcFBPvrRj1JbW4vL5WL+/Pn89Kc/nXb5f/WrX7F06VI8Hg9VVVVcdtll9Pf3T8mzfft23vve91JXV4fb7aapqYnLLruMTCYD7Dtu7+nbsra2Ns477zyeeOIJli1bhsfjYeHChTzxxBPARA+mXX8jli5dyiuvvDKlPOvXr+fDH/4wM2bMwO12U1dXx0c/+tEprQ5f//rX+eIXvwhAe3v7ZLleW47pnLvNZju4Xvv89P3vf5+Ojg5cLhebN2+eHI9m8+bNvP/97ycSiXDiiScCE5Xkb3zjG5P529ra+MpXvrLb886u+PLQQw9Nxpcf/ehHey3PihUrWLBgAevXr2f58uV4vV46Ozu57777AHjyySc55phj8Hg8zJ49m5UrV+62j/3F4f09Y+4qw+rVqzn55JPxer2Tz6d7+ga4XC7z9a9/nVmzZuF2u6mvr+c973kPXV1d+7z2f/rTn3A6nZx88slT0l8fp9va2ti0aRNPPvnkZFn39x1yc3PztHqHPv3005x++umTlV+A+vp6li9fzl/+8hfy+fxkekNDw7QboGpqali0aBEPPPDAtPIfbHYL8DvA//7v/9LW1sZJJ520x/Unn3wybW1t/PWvf91t3aWXXkpbWxu33HILzz//PP/93/9NKpXil7/85V6PVywWWb58OYODg1xzzTW0tLTw3HPPccMNNzA8PDzl+9WrrrqKn//855xzzjlcffXVGIbB008/zfPPP8+yZcu4++67ufrqqzn66KP5+Mc/DkBHR8dej21ZFhdccAHPPPMMH//4x5k7dy4bNmzge9/7Htu2bZv8Jm3Tpk2cd955LFq0iJtvvhmXy8WOHTt49tlnAZg7dy4333wzX/va1/j4xz8+ee2OP/74fV7rX//61+i6zqc+9SmSySTf+c53uPTSSzn11FN54okn+Nd//Vd27NjBD37wA77whS9MCYg///nP8fv9XH/99fj9fh577DG+9rWvkc1mufXWWwH46le/SiaTYWBggO9973sA+P3+Azp3m8321tn1wPHaP+aGYXDWWWdx4okn8t3vfhev14sQggsuuIDHH3+cq666iiVLlvDQQw/xxS9+kcHBwcn7e5cnn3ySe++9l09/+tO4XC5++MMfcvbZZ/Piiy9Ovl0fHR3l2GOPnRw0q7q6mr///e9cddVVZLPZ/X428a1vfYt///d/59JLL+Xqq69mfHycH/zgB5x88sm88sorhMNhdF3nrLPOQtM0PvWpT1FXV8fg4CB/+ctfSKfThEKhA47bADt27OD9738/11xzDVdccQXf/e53Of/887nzzjv5yle+wic/+UkAbrnlFi699NIpn9488sgj7Ny5k4985CPU1dWxadMm7rrrLjZt2sTzzz+PJEm85z3vYdu2bfz2t7/le9/7HrFYDGDypfB0zt1msx24TCaz24CqkiRNiZEAP/vZzyiXy3z84x/H5XJRVVU1ue6SSy5h5syZfPvb3558QXj11Vfzi1/8gosvvpjPf/7zvPDCC9xyyy28+uqr/PGPf5yy761bt3L55ZdzzTXX8LGPfWxKt9o9SaVSnHfeeVx22WVccskl3HHHHVx22WX8+te/5rOf/Syf+MQneP/738+tt97KxRdfTH9//2Q32+nE4ek8YyYSCc455xwuu+wyrrjiCmpra/dYVtM0Oe+883j00Ue57LLL+MxnPkMul+ORRx5h48aN+4y9zz33HAsWLNhvpfL73/8+n/rUp/D7/Xz1q18F2Gt5DpSmaXtsjfd6vei6zsaNGzn22GPf0L6XLl166J59he2QSqfTAhAXXnjhPvNdcMEFAhDZbFYIIcSNN94oAHHBBRdMyffJT35SAGLdunWTaa2treLKK6+cXP7GN74hfD6f2LZt25Rtv/zlLwtFUURfX58QQojHHntMAOLTn/70buWxLGvy/30+35T978vdd98tZFkWTz/99JT0O++8UwDi2WefFUII8b3vfU8AYnx8fK/7eumllwQgfvazn+227sorrxStra2Ty93d3QIQ1dXVIp1OT6bfcMMNAhCLFy8WlUplMv3yyy8XTqdTlMvlybRisbjbca655hrh9Xqn5Dv33HOnHPtAz91ms715P/vZzwQgVq5cKcbHx0V/f7+45557RDQaFR6PRwwMDAghJmIFIL785S9P2f5Pf/qTAMQ3v/nNKekXX3yxkCRJ7NixYzINEIB4+eWXJ9N6e3uF2+0W7373uyfTrrrqKlFfXy/i8fiUfV522WUiFArtMcbs0tPTIxRFEd/61rempG/YsEGoqjqZ/sorrwhA/P73v9/n9dlb3N513bq7uyfTWltbBSCee+65ybSHHnpIAMLj8Yje3t7J9B/96EcCEI8//vhk2p7O67e//a0AxFNPPTWZduutt+527AM5d5vNNn277vU9/bhcrsl8u56fgsGgGBsbm7KPXc+il19++ZT0tWvXCkBcffXVU9K/8IUvCEA89thjk2m74suDDz44rXIvX75cAOI3v/nNZNqWLVsEIGRZFs8///xk+q449drnxOnG4X09Y+4qw5133rnHdcuXL59c/ulPfyoAcdttt+2W97XP0nvS1NQk3vve9+6Wvqc4PX/+/CnHPRD72nbhwoVi1qxZwjCMyTRN00RLS4sAxH333bfH7fb2LPxa3/72twUgRkdH31C53wy7C/QhlsvlAPb7Afiu9dlsdkr6tddeO2X5U5/6FAB/+9vf9rqv3//+95x00klEIhHi8fjkz+mnn45pmpPd9u6//34kSeLGG2/cbR+SJO3nzPZ+7Llz5zJnzpwpx97VLfHxxx8HmHyb/8ADDxzUwawuueSSKQMJHHPMMcDE9wyqqk5J13WdwcHBybTXvgHL5XLE43FOOukkisUiW7Zs2e+xp3vuNpvt4Dn99NOprq6mubmZyy67DL/fzx//+EcaGxun5PuXf/mXKct/+9vfUBSFT3/601PSP//5zyOE4O9///uU9OOOO46lS5dOLre0tHDhhRfy0EMPYZomQgjuv/9+zj//fIQQU2LAWWedRSaTYc2aNXs9jz/84Q9YlsWll146Zdu6ujpmzpw5GT92xbeHHnqIYrF44BdsL+bNm8dxxx03ubwrdp566qm0tLTslr5z587JtNfGznK5TDwen2wx2Nc57zLdc7fZbAfu9ttv55FHHpny8/r4BhPfbL7+M71dPvGJT0xZ3vUMev31109J//znPw+wW4/G9vZ2zjrrrGmX2e/3c9lll00uz549m3A4zNy5cydjEOwej95sHH4tl8vFRz7ykf3mu//++4nFYpPP56+1v2fpRCJBJBKZVnneKp/85CfZtm0bV111FZs3b2bjxo186EMfYnh4GIBSqfSG973r3KYzpevBZneBPsR2VWx3VYT3Zm8V5ZkzZ05Z7ujoQJblfc4Ntn37dtavX7/XQDY2NgZMdBVsaGiY0s3lzdq+fTuvvvrqfo/9vve9j//5n//h6quv5stf/jKnnXYa73nPe7j44ovf1IjWr31Qg//3sNjc3LzH9FQqNZm2adMm/u3f/o3HHntstxcRu76t25fpnrvNZjt4br/9dmbNmoWqqtTW1jJ79uzdYoiqqjQ1NU1J6+3tpaGhYbeYO3fu3Mn1r/X6WAwwa9YsisUi4+PjyLJMOp3mrrvu4q677tpjWfcVA7Zv344QYo/Hgf838F97ezvXX389t912G7/+9a856aSTuOCCC7jiiiumvPw7UG8mdiaTSW666Sbuueee3c5xurFzOudus9kO3NFHHz2tQbD2NFL03tb19vYiy/JuI0nX1dURDod3i5/72veeNDU17VZ5DIVC+41H4+PjbyoOv1ZjY+O0Brzq6upi9uzZUxpZDoTYy5gTb5dPfOIT9Pf3c+utt/KLX/wCgGXLlvGlL32Jb33rW5Of+b0Ru87tjTaqvRl2BfgQC4VC1NfXs379+n3mW79+PY2NjQSDwX3mm84vkWVZnHHGGXzpS1/a4/pZs2btdx9vlGVZLFy4kNtuu22P63cFL4/Hw1NPPcXjjz/OX//6Vx588EHuvfdeTj31VB5++OE3PPrd3rbbW/qumzOdTrN8+XKCwSA333wzHR0duN1u1qxZw7/+679Oq5V6uudus9kOnuk83Llcrrd0qjhgMkZcccUVXHnllXvMs2jRon1uL0kSf//73/cYr177EPJf//VffPjDH+aBBx7g4Ycf5tOf/vTkOBGvr+hP1xuNnTAxVsVzzz3HF7/4RZYsWYLf78eyLM4+++xpx87pnrvNZntr7GtU5r2tm27F5kBHfH6j8ejNxuHXejtGqY5Go1NeJh4q3/rWt/jCF77Apk2bCIVCLFy4cHLQrzdTZ9h1brvGfHg72RXgd4DzzjuPH//4xzzzzDOTo+e91tNPP01PTw/XXHPNbuu2b98+5c3Zjh07sCxrr5NPw0QrcT6f5/TTT99nuTo6OnjooYdIJpP7bAU+kDc3HR0drFu3jtNOO22/28myzGmnncZpp53Gbbfdxre//W2++tWv8vjjj3P66ae/rW+MnnjiCRKJBH/4wx+mjMa3ayTZ19pbuQ7k3G0226HV2trKypUryeVyU1qBd33u0NraOiX/9u3bd9vHtm3b8Hq9k70+AoEApmnuN/buSUdHB0II2tvbp/XAsXDhQhYuXMi//du/8dxzz3HCCSdw55138s1vfhN4+964p1IpHn30UW666Sa+9rWvTabv6XrtK3YeyLnbbLZDq7W1Fcuy2L59+2SvGZgYgCqdTu8WP98u1dXV047DBytGdnR08MILL1CpVA64t8qcOXP2+Jy5J291TH/tCN8AK1eupKmpiTlz5rzhfXZ3dxOLxfbaM/KtZH8D/A7wxS9+EY/HwzXXXLPbZNTJZJJPfOITeL3eySkiXuv222+fsvyDH/wAmJjXbW8uvfRSVq1axUMPPbTbunQ6jWEYwMT3HkIIbrrppt3yvfbtvs/nI51O7/0EX3fswcFBfvzjH++2rlQqUSgUAHabggiYnIh81xD6u+aZm+6x34xdbxVfe966rvPDH/5wt7w+n2+P3fqme+42m+3Qe9e73oVpmvyf//N/pqR/73vfQ5Kk3WLsqlWrpnw71t/fzwMPPMCZZ545OWfje9/7Xu6///49zo04Pj6+z/K85z3vQVEUbrrppt26xAkhJv92ZLPZyRi+y8KFC5Flecr0IwcSt9+MPcVOYMpsA68tE+we06d77jab7Z3hXe96F7D7fb6rB9y55577dhcJ4IDi8MF6xnzve99LPB7f7W8J7L9783HHHcfGjRunNVXm2xXTAe69915eeuklPvvZz76p3lOrV6+eMrbE28luAX4HmDlzJr/4xS/4wAc+wMKFC7nqqqtob2+np6eHn/zkJ8TjcX7729/ucaj07u5uLrjgAs4++2xWrVrFr371K97//vezePHivR7vi1/8In/+858577zz+PCHP8zSpUspFAps2LCB++67j56eHmKxGKeccgof/OAH+e///m+2b98+2V3t6aef5pRTTuG6664DJoYxX7lyJbfddhsNDQ20t7dPGYTgtT74wQ/yu9/9jk984hM8/vjjnHDCCZimyZYtW/jd7343OQ/czTffzFNPPcW5555La2srY2Nj/PCHP6SpqWnyDVRHRwfhcJg777yTQCCAz+fjmGOOOeBvSabj+OOPJxKJcOWVV/LpT38aSZK4++679xi8li5dyr333sv111/PUUcdhd/v5/zzz5/2udtstkPv/PPP55RTTuGrX/0qPT09LF68mIcffpgHHniAz372s7vF4wULFnDWWWdNmQYJmPIC8T/+4z94/PHHOeaYY/jYxz7GvHnzSCaTrFmzhpUrV+7xxd8uHR0dfPOb3+SGG26gp6eHiy66iEAgQHd3N3/84x/5+Mc/zhe+8AUee+wxrrvuOi655BJmzZqFYRjcfffdkw9+uxxI3H4zgsEgJ598Mt/5zneoVCo0Njby8MMP77FVY9cgYl/96le57LLLcDgcnH/++dM+d5vNduD+/ve/73Egz+OPP54ZM2a8oX0uXryYK6+8krvuumvyE7IXX3yRX/ziF1x00UWccsopb7bYb9h04/DBesb80Ic+xC9/+Uuuv/56XnzxRU466SQKhQIrV67kk5/8JBdeeOFet73wwgv5xje+wZNPPsmZZ565z+MsXbqUO+64g29+85t0dnZSU1MzOcjqnjz11FOTg96Oj49TKBQmewidfPLJk70dn3rqKW6++WbOPPNMotEozz//PD/72c84++yz+cxnPjNln+vXr+fPf/4zMNEjNZPJTO5z8eLFnH/++ZN5x8bGWL9+/W6D+b5t3r4Bp237s379enH55ZeL+vp64XA4RF1dnbj88svFhg0bdsu7a+j5zZs3i4svvlgEAgERiUTEddddJ0ql0pS8r58GSQghcrmcuOGGG0RnZ6dwOp0iFouJ448/Xnz3u98Vuq5P5jMMQ9x6661izpw5wul0iurqanHOOeeI1atXT+bZsmWLOPnkk4XH4xHAfqdE0nVd/Od//qeYP3++cLlcIhKJiKVLl4qbbrpJZDIZIYQQjz76qLjwwgtFQ0ODcDqdoqGhQVx++eW7Td30wAMPiHnz5glVVacMV7+3aZBuvfXWKds//vjje5wyZNcQ8y+99NJk2rPPPiuOPfZY4fF4RENDg/jSl740OcT+a6f8yOfz4v3vf78Ih8MCmFKO6Zy7zWZ78/Z0D+/JlVdeKXw+3x7X5XI58bnPfU40NDQIh8MhZs6cKW699dbdpq4AxLXXXit+9atfiZkzZwqXyyWOOOKIKXFhl9HRUXHttdeK5ubmyTh/2mmnibvuumta53X//feLE088Ufh8PuHz+cScOXPEtddeK7Zu3SqEEGLnzp3iox/9qOjo6BBut1tUVVWJU045RaxcuXLKfvYWt/c2DdK55567W1l2nfdr7SnWDgwMiHe/+90iHA6LUCgkLrnkEjE0NCQAceONN07Z/hvf+IZobGwUsizvVo79nbvNZpu+fU2D9Nrnqb09Pwnx/55F9zRlZaVSETfddJNob28XDodDNDc3ixtuuGHKtJFC7D2+7M3y5cvF/Pnzd0s/kDg13Ti8t2fMvZVh17rXTylULBbFV7/61clrUVdXJy6++GLR1dW13/NdtGiRuOqqq6ak7SlOj4yMiHPPPVcEAgEB7HdKpF3/dnv6eW1c3rFjhzjzzDNFLBYTLpdLzJkzR9xyyy1C07Td9rmv36nX1w3uuOMO4fV6J6d3fbtJQhzi4cVsb7nm5mbOOuss/ud//udQF8Vms9lsNpvNZrNNw9133821115LX1/f5BSh/wyOOOIIVqxYwfe+971Dcnz7G+B/cpVKhUQicUhGWLPZbDabzWaz2WxvzAc+8AFaWlp2G/PnH9mDDz7I9u3bueGGGw5ZGexvgP+JPfTQQ9xzzz2USiVOO+20Q10cm81ms9lsNpvNNk2yLO9xwK5/ZGeffTb5fP6QlsHuAv1P7JRTTmHHjh38y7/8y+R8XTabzWaz2Ww2m812uHpHdIG+/fbbaWtrw+12c8wxx/Diiy/uM//vf/975syZg9vtZuHChfztb397m0r6j+Xxxx+nv7/frvzabP8EDnacFELwta99jfr6ejweD6effvoe52a12Ww2m81m+2dyyCvAu6aLufHGG1mzZg2LFy/mrLPOYmxsbI/5n3vuOS6//HKuuuoqXnnlFS666CIuuuiif7ruATabzbbLWxEnv/Od7/Df//3f3Hnnnbzwwgv4fD7OOussyuXy23VaNpvNZrPZbG+7Q94F+phjjuGoo46anCDasiyam5v51Kc+xZe//OXd8r/vfe+jUCjwl7/8ZTLt2GOPZcmSJdx5551vW7ltNttbZ+7cuXuclxDgBz/4weQc1IeLgx0nhRA0NDTw+c9/fnL+1EwmQ21tLT//+c+57LLL3p4Ts9lsbyk7ltpsNtvuDukgWLqus3r16imjgMmyzOmnn86qVav2uM2qVau4/vrrp6SdddZZ/OlPf9pjfk3T0DRtctmyLJLJJNFoFEmS3vxJ2Gz/hIQQ5HI5GhoakOV9dxQpl8vouj6tfb7+nnO5XLhcrt3y3n///cyfP59HH32UefPmoWkaM2bM4N57750ykfrh4K2Ik93d3YyMjHD66adPrg+FQhxzzDGsWrVqjxVgO5babAfmrYiju/Zrx9LDj2VZDA0NEQgE7Jhrs+3BgcTcQ1oBjsfjmKZJbW3tlPTa2tq9vrEcGRnZY/6RkZE95r/lllu46aabDk6BbbbDTH9/P01NTXtdXy6Xaff4GMHa7778fv9uo/7deOONfP3rX98t7+joKKqqcsIJJ+ByuVi9ejWWZXHSSSft8SHvn9lbESd3/deOpTbbW+9gxlGwY+nhamhoiObm5kNdDJvtHW9/MRcOg2mQbrjhhiktIZlMhpaWFuZzAX7c5HCioNCj5Mm7VYQuQIEW3eIEy4eDcRQc7CRBNW4a2Yni7Metz6ePRh4jTgw/eQxmY9DAZiwk0o4SZblM2lSo8hiIAhRcDvIEyJQa0NR+ag0Zl1KkqkHD3wnNFSgNQ3lUJue08BZkRLXAN1sQF0AMNpwMxUFw3TeRv0GCUhX0BGDme6G+HrQBGHoJ/EkYfA7qHTJpn6DBK+irB68CynMqlZKHweYcO4EjOqB1Hqz9rURtnUB2gPCCcEPlSCgpkG6E3hDk6tyIigsCZYK9BkfvMBEOSCsgDUNzMzxvQTQHQypERkDkoVANdSXoGAIxDloBnt+u0tBhoC6C/InQ5w+jF0KQKYJSBG8ACg5UPY5XaLR4LEKDkByUKK/zICUVwoabgJkmNqtCYAYUDShUIJODogZuE2QNMltdOJoM8u0m46/KlN0ydV6D8HzYvjxIvn4G9PeycCDF8QXQy5AdmLgGEUCthcxWcCogl0Efh+3dMZprTBYsSLFpZT2GKZF2gLd5hFJPG1gpDCWNooSZh4JemU1a2kLGchPzZqk+OUdtPWz7M9RVYEMA3EUFWZJoNGF8gYGVlShtaCdDNWvVFPlAhiPbRmkPqDy+ZhZJScVyKNRlBCeb1Qh0XGxlcfUo/dlqhrQluHERxIeFn3EkNmHQL29DV9I0VxZyAjNoIE2CBtxkeILVbOAxAoHAPu8vXdcZwaKfNoL7GFIgi0Vzvof+/n6CweBk+t4ewDZs2MCsWbMm169bt46amprdKmy2t8/eYqnNZtu3gxVHwY6lh7Ndv0czPv1LHv3Xs+lNFvngT17kp1cexdEzqg7qsXb18KmqqtpvS9qb2XY6efeVZ2/r9pT++rTXL1cqFR5++GHOPPNMHA7HAZ3zgTocru+e0t7qa5zNZmlubt5vzIVDXAGOxWIoisLo6OiU9NHRUerq6va4TV1d3QHl31u3IMiQw6RMjjSCgtNCVEmocTdVpQpzkKglTYUh8nhJoZKljMwcAnoInUYyqASIouIjhkSALSSlMkHZwHRUUMoqlhVkJGdQI5VwlaopS36qZYvt0gziUi+1PsGSY8ExFwqjgAf0jITiBLNK4EuBxwMNbZD1wII4rH/QyxLFYtlpZeJlKB0J9VUQc0H/Q7BjpYqVsaiKWrTOh+AsC383OOqgug4Cr4DuNxiM5lg4E2qGILIc8iEIdQrySQgoUFcFgwkobgQ5ALNDkHYpZI1aiLogJJPNZXkxOUJgiYUZAr0exgoKer+Ew2/gdUAVkK+BXBWogxAog+ECYyd0Ri3M+ZA4WmJgRgzDqgMBarKA02WiVZsoAY22nM4Ky6LyskRppZv6hEJea6JbSqELKAQt9HGoa4ZRASUDDA8oMkSCUBgHT4eGuQLC3RIuN3jqDdJ94BoHRZIgAJ5wBYcB3aPg6IEAUCyCJiAhQU0ENAXUKFSeBckUKNEc0WOgNjHKwBY3gXIMtUNgVvXgW+dmyAmtmkxwToaK+RzzFIHplRGtguBS0HqhXlKQikHyORcDZCnLHmSzilimH89RZca6dTJ5N7pSJlw1RjoHC8838Ln72PLoUkqmoAoJgzgjqPQqHkYS1SwSGjVAkDGKDDLEAjR8+PFSbVUTtWIcQyfNmNSgIzCBMBphNsC0u1kFcRFE2UcOcyJfMDjloW1v1q9fz8KFCyeX161bN2X5cPJWxMld/x0dHaW+vn5KniVLluxxn3uPpTabbV8OXhwFO5b+83j3u9/NE088wWmnncZ999233/y7fo8qsps/bEyyeThLa32UUxa1osgHt0u0ZVlUKhWCweAbqqBNd9vp5N1Xnr2t21P669Nev1ypVPB6vQSDwbelAvzPfn33lPZ2XePpxNxDOgq00+lk6dKlPProo5NplmXx6KOPctxxx+1xm+OOO25KfoBHHnlkr/n3ZilRZqHQQBGJAVylItX9JaKlDAZFvJQpkMJHAQ8Gs5FpIs4IGkXqiBOkFwkPHgaIk5W6cZHEL44Ecw7RYgCHFUBGoogXSTThw+BYtZ/F/i6WVqJ0iFas7HxWrQ+yMQzOueC7ACILTfwxCB4ncM0UZMdg8HmItEF8jUxN3IH2cY1tK6D7ZNgegdxW6LtDYeufPdScZVL7UYvsBeA+FrwZ8OjgUEC/L0q524FRDRk3GDFQ5sKWKuhVYcZR4FJUSltjjAxC7xgMbIW+l6G8Ck5ImzhHrInadK4B2uag1dbiHoBKEtKREH0LF5KcP5tNsp/xIZmdmszWJiclCQIa5HOQ2g61NbDoAgtlHoy2NGFEVkDVCSiZMLOfTXHsi2WWbhvnXT0pFqw12fgUPPOIREFY+NryVAe3MtszSkxN464xibRBMgsJP4xHoOAGpwqWAcUC9Mx282ptgPJ2hdyoipoHVydkOyXKHUGoeHA7KyQEZKJQKMDY8MRNEmiHGhlCKjhCYJbBCkNMFVRlFRwSdFxkETqliLtmEH9W0Npo0XxykaPmCGYcmWAsUmHTCGzKOCnXCiS3IL4R0uNQFAoVK0aTqCGkWnjDSVJShrGiQXFQJuQaoZZ+fKKWrNfHgBRi7QsqJ16W55wLn2Fm81qYsQalbQsB5xCK5GWECFAhywZ+6x7mXtnNSrrYQgKVCtVEWECI2egsYpAYvfh5nAR/ppbxA7qfwDmNn+lbv349ixYtmlxet27dlOXDyVsRJ9vb26mrq5uSJ5vN8sILLxxwLLXZbAfLdOKoHUv/WXzmM5/hl7/85Rva9odPdvHoljG++q65B73ya7MdDg55F+jrr7+eK6+8kmXLlnH00Ufz/e9/n0KhwEc+8hEAPvShD9HY2Mgtt9wCTASM5cuX81//9V+ce+653HPPPbz88svcddddB3TcEUbR8SBhEsBPWkrhEYIgAVIIyvRh0U4Bi25UHAwTQKNCOyUyOOV+aqx6ciSpJ4pLFMiRA8ZR0Ih4KoSokCh5qZWy+ISBRDXJSgzJGKdK6sIQEl5q8I66kEbg5YUQ9kN7FEY2g2MN1JwM9V4wHodQCtyzLTpPyNBfDa4ucCehMQj6yxKpNV5mX5xHCwq2rpGZ5bYw+kGZBzlVYuivLpwllRmXmhRL4OyHXDU4kpDPgEdATxZGDQlDV2hLgXcJVDlhZI3EYL8gOApuQ0Nf1j5Rw/To6Ee7GX8qTUm4sJRZ4J6LsLrRhQXuIlqtB8Q41b1J3LqgFJ9omdU8kC/ATq+XkjwLRmpgNE39L9cTTZhIp4BigicBSRlUJ4TCFt46jUEBiimoDoPbqZHJgaYCJggnyD6oKoLhgPWKg+TRCtqiEAGtQKTJoEoF53zoboOxtk5MuRGpdwvhjIaVg8EAxAahKQrOxVAqQPpFKDoh3AilEgQaoRhKQ7PFYDeUAhBrh1zGZGSNgncA6k80GRuBriOg/2mJkbSH0dR8uvTNLJtTwGqEUCPUnKET3tiNvqkeo2LiTCl4HOOUBmB1dxWGgFoM2nSTkVdDlBSL9FCQ3sX9tJxmEjgiy3ddMV4Mt1P1wjZiW+Ms2ymoTVqktAADtQF88RBmScGJxKlWNQ3SemQKZMUoGxjFSR8ugjhoxkLb1+2zBw7YZ8vF9N+1WZbFpk2b+NrXvjaZ1tXVxXve854DLNM/j4MdJyVJ4rOf/Szf/OY3mTlzJu3t7fz7v/87DQ0NXHTRRYfqNG22w9z+4ijYsfSfx4oVK3jiiSfe0LaGKbh0WRNnL6jff2abzbabQ14Bft/73sf4+Dhf+9rXGBkZYcmSJTz44IOT36f09fVNaXY//vjj+c1vfsO//du/8ZWvfIWZM2fypz/9iQULFhzQcSNEKZJExsWgVEY4nGR0lSQZajHxoWNQ5HlUBA4aqSbNThy8TNBVoW5+BqO/FzEukSDNOAFcBJFIElWTeCMWqbKPUCmGJAp4KTEq9+ERMRZ1pKlYScb7qiiSx2Hmybihr2miu23VkVBTAj0FfSoE3FDfAC43JNvhj06IPgHm8xB2QGUWDI8LGo/LUVbhqTscjBUFalhw7ImCZI/E4BofEoKWY8boPEGwfRwKO8BXAqsKkg5o2Qr57aCOuQGLggqmDKkwKCcItF4o58EbM8nmfGC6IQnCcpDtPBJMF1h+SKngaoCFJ0MpBWN9OPvKLPYkEF1gpYFjYW2bxEitg1S0BoiCruJ//EVqXy1hzIOiCyQfjKyDXAScedAtGN0+Ua52FQrhifLrwxB2QSIDA84AwimRDeUodASoNIZBaoCMTsZpsDW0hXavTrENOp0S494AJD0I3YGRUKipmGwOqcSaDbKjIGVgfO1Ed2jnMig7IJ8C+iSchoQP2PQ3GT1mUSpBNAQVQyIbMxAvqLw8x2DgDKgbVCj0hkAaw+/XKcmQ3jrRVbt6DoxtERjCj0f2UOXJsbOs0CfJNEkZIipQUZlNilrDjW6MMQcF/wZw14Gw4Ox4lr9mfYzN89EuJ5AG3Lyk+ymKBnzjcUQlRasV5ThHhpY5vyHiSWHogsKOIFLJRQ4DgwbSeMjjO8A72ce+w4kx7T11dXVRLBantFIsXLiQG2+8kaVLl3LCCSccYNn+8b0VcfJLX/oShUKBj3/846TTaU488UQefPBB3G73235+NpsN9h9HwY6l+9bW1kZvb+9u6Z/85Ce5/fbbD8oxnnrqKW699VZWr17N8PAwf/zjH/f44vD222/n1ltvZWRkhMWLF/ODH/yAo48++k0f//1HN3HPuiTP7khQMS0cyiHtzGmz/UM65BVggOuuu26vc9Ht6e3YJZdcwiWXXPKmjllEp4SDEjHKQsNnQBUZhlAZQQcULBQ0GghiItAIoOFXigRqTXzHwHxfmcfiR5IXOipRDMDCICeVyaU0UqVmgrioSBm8aomA6SBSk8R/dIWxAaj1j4MP0v3gfgHSLVBxwmAU6k6GNqCSAHkcip0gJCgOQ6QIc2QIRCGzXSZesdD6FVJdHtRVOrl8lCpHmeojUwwXFHpe8oErR0O1wHsCvKqBUQULj4WR7MRgTws0GHpCpZQxieQCSK4ihhOqyzC+CVwRyLSAtwoKDhUs9//tCyxDvhvmdIDmh20vQt8m5KwHq0qB5ol+yA6jgrEa3GVQOyFTBwNVMjm3D9PbCa4joG8nLS8O4tPdyLqOUgSnD3Qv7HRDaBYETSi8INHbolIlVyg4odoFog8SbkgukSnNb0WRKjR25fBqRfLCoIAD1444clTB22/grQPnK2AEBEp0FMMfQdINIt0mSi1UVBnpOAiuhdwIlJdCcg5UxqDxVQiqMDYINcealIqgVgS5ERA+kLOgIPAMqQybfsqnpBmq8dK0qEj7i0lUWSPmhgSQ3ORAVit40pAryJgY+JQy6WIAl6uMZPrQ5ApuUaAqMEYoKNOgqbgUk4Y5BmIBmAKMPoj9bxXnaAXigQSRuJ9ieRkjFIgwyPFFBw1U4Yz0ccyKLprmmIxuBiMNnpkZilvdZLRmxgihU43MgU4P7mTf4WT6f6BnzpzJ66cn/9vf/naA5fnnc7DjpCRJ3Hzzzdx8880Hq4g2m+1N2V8cBTuW7ttLL72EaZqTyxs3buSMM87Yayx89tlnOfroo3f7HnHz5s1Eo9E9DhZWKBRYvHgxH/3oR/famn7vvfdy/fXXc+edd3LMMcfw/e9/n7POOoutW7dSU1PzJs4Qrl3eziM78gymS/zvukEuWtL4pva3J5ZlIYTAsqY3Mvkb3XY6efeVZ2/r9pT++rR9Lb+R8z4Qh8P13VPaW32ND2Sf74gK8KGg46aWOkpYyIQZtnQiyMhUkCjQRIRuIIZEHRCnSF2sQCBo4VkCoflQchiwuZ9cupUas4SKG5MkTYYHp+nCgYRJLy5nhvIMQWN9ibZ5YEkQLQMLQM9NdHoK9MCK7SBmQH8DZIOQTYBjJ2h9kA1DvAdmCMiv8ZLEYCjrQM96QRtHK0pUaTIe080S2YXUmCF5HMR/5yWveKmJZTGjkE6CIwDbwuBSwZOCcBwyQ+AZ8yJRpEmKI9XqWGko9kDAD+UmGJjtY4QSJdUHeQscBig6VCTYvAXmXQiuEO7hV4g9ZzI6u0Cl+UQoSTjlHLF6UBXIiomRmb1Ji4rDTV4Ng0NHcWjEGjU8IxplA8ZdEE+DIySzQrVYF5LYOQ9Eu0RHySS4AQqDE/nkMLgKUJOzSMa348KkoyIYLBrUGwZKvAu1C2QnWCokZMivhUAHE32ngzJKTsPtg4wOlsNgMADh0yDggrQXkgkIA2QnWurnnSbwV0NhDaRrBNFacMoQGAd/s0l9r5Ph4zIUm2RERqYuDm6/Rjqrog+raOEyThR6XvZixAtULaoQHBojpRqUgwWOnWNyhFfHNMG/AwIB0AImqtMk1ATuKDhikB2G+EsSyaQXr5pldi1E5xR4YstOKuVZmHhoYoDFDc/T/sECrkYY65t4X2GmQZ4D7gEFn+ZDwYkDGKL/AO8ox//92Rv7GyWbzWbbt/3FUbBj6b5VV1dPWf6P//gPOjo6WL58+W55Lcvi2muvZebMmdxzzz0oykT3861bt3Lqqady/fXX86UvfWm37c455xzOOeecfZbjtttu42Mf+9jkZyp33nknf/3rX/npT3/Kl7/85QM6p9tvv53bb799smJfyme5dEkNdzw7wB2Pb+fEJtdBnxdYCEE6nQamP4jbG9l2Onn3lWdv6/aU/vq01y8bhoFhGCSTSVT1ra0eHQ7Xd09pb/U1zuVy08572FaAZXJIBDAxKaDgpEINHoKoRKjGQwI3ZbxAhVFMAiTybpKaSXVJI9wFa16WsDxjhFOdOPBRoRcVmaRkEnaWCek7QVh45gjE6WDVQNIARiB6BCgu2PFX0Da7yZgymcEijgUwmp74PrYyDsE4ZAwIFCdGge5f7ybdH8FFFkUSzPOnoBmsYQPXzCxOQJGy9C6CYjXMqi4QtQpE6sDRDq5ayPpBr0B1HjJ9gAbJMPibsjjXQ1aTcQ6p6KaJWxNoiyBXD5GSRlr4sGoXgDsCejdUzImPYY0kmEVw1hOOS6SbYlSWHw1yELm0kfpUnuRmyHaCoxZKGozX16Iv+SSo7aALTDPN8BInnf4Sg3UwWC2jaBKJmS2s7UrhjeeodZrkLBd62mSo1iKcg7o60FxQSAABiOkaRR1GvZDXoSYJtT2gBWEsBkjgl8EzF8bbZXSlCSXRhaKmKfrBa0BYsihYCs85/RyXydAch6AE1QJ8M0DZDD0vgkeCphqYefRERXL4WRDHQGizg/yYQvEInWGvijuvU5OFREpBN2pwVUJ4hrYyUomQMwsk4g7q2wwcJ2WYl4foMshFQWoGXwI81RAMgNkHpT7IqSDnJ0bVrhTBKQuaF+3EYQBtoJQEyzL9ZMbylMo+AnipnFik0AmZceh/wcPO1bNxWCX8LTupVi0UGvEwkxxlJMy93Dl742ffD26VA71FbTab7TCzvzgKdiydPl3X+dWvfsX111+/x4d/WZb529/+xsknn8yHPvQh7r77brq7uzn11FO56KKL9lj5ne5xV69ezQ033DDlWKeffjqrVq064P1de+21XHvttWSzWUKhEJFIhI+d0sIvXhpm+3iJTUnB8lmxN1TWvdnVkvZGp+mZ7rbTybuvPHtbt6f016e9frlSqaCqKlVVVW/LKNB7O6eDue2hvL57Snurr/GB7POwrQCbFPGg4QRchLFwEkNBYicxejFwIRPAT5YKXspqnIpDwe0yya5XeLVkkkfgbTeJBjbQvaMNUckyiwpRh04oViQ17MDym5jLYccZ0PQUNJYgNG+ixTW9dWKuWjUXJFxVYigKGQnqy9CegfKzwDC0zgbRBbRDoewgRxM5ErR4BvHNNUg7IH8SaHOgPwDaOFSPQcN6UJdZmCqMx6FUC+kgyJWJAbWcfiivAO84pD0QdUBsh8SIrjBaCVFEJ5LxE9g5ymzZZMwh8/zCM6DmROQ1T+Nf/yi542ch6o6F2uUQaCHwyt+ZkzJYdVwT1Lei7FjHzMGtRF+xUMcmKomZBAgV0LxQrgfLAXoBLNjZ1Ml4aAtZxYPlU5DyOsqYoKe+DstYihRWEI46xub10ptcTc2Iznyh09QA2RB0eaApD6FhmNMKtQb4QlCZCzvqXQw0BSgYEsFsHvfsCmlVIEQP/sQYbtkiLkFMQHUCBsMmulTkVTfML8MsHao1yAZgrADJLhV32AA3VDtBfxoqdeDQJdLrmxH1oxTdkKmEkXWF/qpRQlKQuGURsbwUexopijI+pYir2iAgwDwWzAQEj4HuIuQr0LR6YgTulAaSMtH13Tk8sW58VGY0XU+NMMg3jNE92k5pm5eZDFIjmzQEi0hGhbKShSpB4RV4+Tk3z25YStCs4UiCqKVBCpYEqJQpI7Ma6DvAO8rBgY5OarPZbLbXsuPowfSnP/2JdDrNhz/84b3maWho4LHHHuOkk07i/e9/P6tWreL000/njjvueMPHjcfjmKa5W/fp2tpatmzZMrl8+umns27dOgqFAk1NTfz+97+f1ij8sixT5Xdz+dEt/OSZbn701E5OmXPw53WWJAlZlg+4gnag204n777y7G3dntJfn/baZVmW39Q5H6jD4fq+Pu2tvsYHss/DtgKsUMFFiXEEGoIocaqRUZUdeKQkOw0/FQRBqUTZrzNrTpaGo8A9G+IxsBrAcAv0CoyMp6j6oUbi0U5CUg9OT5FKCIRloB8tGDoFihKkt0A6D0MvKpQrgmirhSMtU5CKuGfkaY+CtAMYAF8RtFfB3Q6yf+Jb3dyzoHTk6JQ2I5cN6gJlAjNAj0JXFNRhCGegtgvEVlBS4DwKzKMg6wJHBjyDINogmAVDhqQC/XMVdparcDlTtCwx6HvCwahsIlthdCNC81qLfiPBhhM7EJ4RlKfvo+bJ9TQV82w1u8mefRJ4O6ASouJ20nOkA62mGmnzBmatf4qq7SUqQ9DX6ePVoxZxVO/L7PAF0DtPhGgHjIyBPgZKBNMxm7Q8AKbA01eiZlwnovZAQGJ7c4FC/QmQjyBcXoqKhx5vitTwenyBEomwg5CzwuwijOnQZ0ImoBCWLUoeN6PRJRBuB3cD4+lBKHdNvIUolSiobiytguEHTVYpelSsioZPr+DLQxxY6AStAk4PsAQkj4G8E1Q3JF9VyQ4HqNSlUcsORso6sXGdLTtkzAUuTFcVr/hSzJcdCKBMkYzwo8o5mloNGmeD0MDMQnoMrP+F+jRkKiCNgtwAWhqkMRgvgqcMetLPaN5LnCBxb4lqt8R2rYqCELwanMHcTJjOops6BvGHtuGy4NU1Tv53Sxv9wQpLUlnUqg20LS6QeUVBU1di+iCilkhULMgeyB114NNz2Gw2m+217Dh6MP3kJz/hnHPOoaGhYZ/5WlpauPvuu1m+fDkzZszgJz/5yUHvUrwnK1eufFPbX3ViO794rofndyZZ259mSXP44BTMZjsMHLYVYIGgjEktJkWceEliMoo7mGbccNKda8XhSBKqSTKj3cI1G6pPhMwM0D2QMSFXAMuCYg0ccWmR7tUjaJqG5rHwRcCzQmCeAtkGaNgCgRFIdsF4IkBaVsn3xSEhM2Cq9A/JdI5ZVPVIGE+4yZgwWA7hFWka9DJlBSoeqKmDmiNzKNuh7INYJww4Qa+CxjVAFlztoB8JlR4ob4SgG0IjUAX0+iZaMMcjUIjDrAj8ORpGD4bYLFWIxytUclDxZlBzGdyjQ5SbLFI1KtXqAPU7XsVYJSGtD6HPg8ATKYzYIxTPaIF4knJdO72FLvC04erejGuThtblR8wrsvnMNigEcSmCVLATHEfAlgyM/hY58DxKLgKFNKGxNE4E3iy48rDTK9NasfBXj1MwjYkTyqehrEIxTy6ggqKwKF3BqoAzA44s6AuhYIKqSmSzc8GMQXoYwj5wa5A3kIWJWy9Q9EbIOT24fXFSSgMEmlGsftTSEJrLIFSEfBmkKBT7wTkISnbiUSXRA7kxF5pLEHOBMeDGKScpaG7aCjkS8XESNSHGZ1SRbc4S3dZIiRwmdSgODakChVdlhtcr+GMV3GFI9k/0KHc5wCpJ5LJOHHkLxTBQywJRAk04cFJFAhmjHMYxngRhYihOTEeQvDTCWlHLYtVFywyDvrUenl0zi0G/RbjspFYepqFzB86IwNtooJUM6tohbYIYONA7yn5ws9lstjfHjqMHS29vLytXruQPf/jDfvOOjo7y8Y9/nPPPP5+XXnqJz33uc/zgBz94w8eOxWIoisLo6Ohux6mrq3vD+329hrCHC5Y08Ic1g/zoyS7uuGLpQdu3zfbP7rCtAJcIMoJJlBIyY7i8/YTDKSoIRNnCJw/SHMtQXStwLAZnCPR6SLkgxUSvXdkLkgrChHQTtFw0xvgr4K+BQDv0z5loOWzph7ZX4dWNPgayIVSKKJJA+CTMiMHQFoFjuBbPE6Oo417W5tuBBBX8lIZqGQlvpSZUxlWGch+MdYFcgILpQPgr9C+EXAW0MXA4IaLCcAIcJhiRiRmAnAr0vwieReD1wEAMiiUIDsDZepJBPUlqjsS2807EOmsRnid+Taw3BcMWRR2aizrVIzppJ1jVgrRLJ7XBj+oqMqtrC+vbHsIq6qANEhhLk6sZQCko1A46EU5BX4OET+/jyOHNbKkNUqxrgJwEuR7U1AswmqDxqQTZrEVAEXTWQKEKRAqaNYvGCKTTMpg+qFSBNoAsb6RW6qOmYFFXBFwTrdqiDFICMpUajOhsEkYG0dwC3ii4WsEfhCJgvIwkK4QyBnolC14VJSNQvAKzrhlTqyabsHBlBsAB64ISSV1iUdFCXwciDgUfOMsyLqWEPLtAlQVqNIfPJ8giob4qMden8eJ5acqzWth2ykaOGMziKjTgpoDsreC1IJNRyboAB8gWWBUJM+siUREIPUJeWHjRCWDgyvgpu8sQS+PWvLiNTnQrgZRoZS4BhGGQiGdQqcMnBfEd+yJpv8nIIwuImxE6M2WWigqzPQOEFgmG0wpbt3hpq8uRq4f+YdiQDgDTH0wAvBP/AHt12IYam81mm6b9xVGwY+n0/OxnP6OmpoZzzz13n/ni8TinnXYac+fO5fe//z3btm1jxYoVuFwuvvvd776hYzudTpYuXcqjjz46OT2SZVk8+uijex3J/4265uQO/rBmkAc3jdAdL9AeO9ApDG22w9NhG0nzaITwE0bGp/RQ15iE4EQFyhc3iCbLVOuCYv3EaLtaBLJFKEehVIaCDmUBmgOswMQUQcmLQF4I1RKUA1DjBW8OvDr0lWFcVcjjQ5YKNAVSyGEBiyA44IecSjEJO8sqHqopeoYJRXup0apwDwRwRMpoKTBMhZGSj6Is4TWipGp6CCyyaF4Hep8L+WiNvBf8AkRsYkgNZwkGnZDJq2iPCVoGTBYsmPgGeKgdEnmB/DAENgj85/eTnXkqzlwI11gK0TgxB2/aCykdapxgtIOcKVK71kMpKHDkTRhbh5zL4/YVKFR5EeEyejjF8HydzoLF7Bj4KnnWzwozUr8MrBDgRCrspFUkkBIG7mEfctaBf06KrTVO2hSdVBBc1RC3wJErEdn+d7KuEUynC18pi+KwwANqamJEY58J2XHIGlCqb0I0vxtl7e+oX/030qF68qdeA3I1+JrAsQ1TGiNeZSCyGjGfhi6rFNQAJEdBMwiJFLMAKwFrWmJQkllYN4paBa4KGArIDotKADwJ0GIQOUYw4gZHUZBc48D1uJOOxjG2HVNH+phWUoNbaVqXxu+uYCgm25okpGU6y0wY7gHDgniXC1++HYMBUvhJU8KFjwAKbnTCmoE07iDYPkxdtoJztB4NgWAn8xxxdCNCRnITXPwEMxdleeaBKL2mwIfGImeKuTVd+Bo0hspw36oGBkUti/u2MLNQpFBQyRsHWgHeX8vFgU6rZLPZbIeb6bQA27F0fyzL4mc/+xlXXnnlPkeatSyLc845h9bWVu69915UVWXevHk88sgjnHrqqTQ2NvK5z31ut+3y+Tw7duyYXO7u7mbt2rVUVVXR0tICwPXXX8+VV17JsmXLOProo/n+979PoVCYHBX6YJldF+DUOTU8tmWMu57ayS3vWXhQ92+z/bM6bCvAEdx4sQgxiN85hDsIRiNI41AwZHSclMoapibwSFAaBbkdSkWwBMguMCrg80Bcn/jGN147MWetbEDbBsj8QqKgwtYFgvgsqHQWcb0osHATl7P4R6FdQGnWKOk1MTxI7GwtMlTzMq5lJZzVFs3FUcztEE6D92VIJ2XSVj1Fy8KJGzml0tSt07dKoTASQe4exVcnQIPEILhrIdUK/SWZmccalAehKCDkhKAOhRIMuicq8s4E+Pr6yFY9T3bJPNT0EMGUTnImOGQo74CeHHjDoM4Cn6uEJSAfURBmHa6BYRqHcvQ0hzAXt1Gp72DHsgSeyhgZf4Du9gVoETfOwS7QNqIHGgGJpOSh5FnM/OpXcFSXKcyVSUUVSpKEVxM0yFBySLiFoHVwjKCxkqwpEwtVKPnBUQSPA1IGaBLoSdBd4Mgn0QtjYBqwU6dK7aMwYx2i4QzQkhCoAy1MRapDYhv+9BAlj0lO60cUsiDHaNQrNMZhOANiOIBeX81QYJzoGRb+3onvtKUiSDFw94F2HIw3TPweOTTwui1Gx6qYt2UIrXk7vcEWInWCerVMMgSvRhQ2LW2jrbuf8ZUGxVcUtGiFYgay6Dhw4iVPGR9D5IlIKsH2MaKBCmigxiTmnTRG8lGNXF8dIXeSJlnDchUZmvUi8z9YZmydQn64mZ2SkwYpQ8eSLdTUW4x4oeeJIIO5ENkaE393HXWDJjWYuKiij6EDuKP2N3jLWzunns1ms/3jm84gWHYs3Z+VK1fS19fHRz/60X3mk2WZb3/725x00kk4nf/vui9evJiVK1fuNqXSLi+//DKnnHLK5PL1118PwJVXXsnPf/5zAN73vvcxPj7O1772NUZGRliyZAkPPvjgHucVfrM+sbyDx7aMcf+aAT53xkxqAu6Dfgyb7Z/NYVsBDqMiyGKQxLRMCjpU14JWhkxFoOFjuKCSe8rB0FoDkwpHmzliFwmyxkTrr+6AnDYxr6xegZICNWmY0Q3Jv8KzzwUwnWX0jE5gAdTNNCivMcBoo5ItoSlZeh5ykCqq6POyrLswRHrFXCyvBA4XpDOM6DryIo3I2BhHVKWJPGcw0j1OxaqgKQq+kkU5Dw6HSdmVIsPEd6MjTQql2RJ9hkWfqCUT6UT1v0BE1XHq8GoFAk1gJKCjAiN+SFqgDJk46p7CCDWRPD5GeXyEYMWiegSsCpTkidbQbYobM6wTylsU3W7Uos5sLU4FCSvimfhQeqybsjfEi8xFVDeCnMe3dQ1Lx3rZEK1Cr/MgsjopXy0U5pE8aiPJ5lrKPpOZO/oJ6VDlh9UhHyNyG15tO20FndoBk7BpUopATAVDh0Q1vBR14tlewdkHogEMLQIuMGceS3ZhN36RQHgzE/3XjQp4qsCtQq0LYYYYNx+lWA9K2aIjM8iM0hD1OYuxPii6wbt5iLJHYSdOKv4y81tAGYGCDH5j4sXAVicoQDQMpf6Jyvi4JdO2yU31ggLj27Zh/M3JhowLx8Is265rg5KP6nuhf2sE3Szhc1aoGCCkHD5fkbJDxl0q0KqYdLRrNC0zKe6AXJdCaUeIUqJI9KQMkeezqLWCQgzcczPM9IMIQlIXOIBO4aHR30Wg3WI4I7H26XriiVk0SiU6ze3MbixSSfgxisX9TsSxu/21XNgPbTabzbZv02kBtmPp/px55pkIMb2W8jPOOGOP6UccccRet1mxYsW09n/dddcd9C7Pe3JUW4QjW8Ks6Uvz82d7+NLZc97yY9ps/+gO2wpwgTxeHFRwkqy4CWRKhNLgiIJbVtGoZxDo0910ZxJEzTidf3DScoRGsA18FUiUoDEHW73gdEAQOGYM3BtgwwhowsJXXUH3Q0aGsAWqyCLw47eq0LJlsj438Uvy7HxvHeVY80S/5ZyG1LsDWVIwfWHM6qWMtcDT4VeZ51pLXV2S+hxo1ZAOwbaZEm4F6jo11tdAvAaSvlasGg+SoSJi80AsZWc+Q6B3M5GYYDTsptALs0cKDC4GOQo1Cqgy6L1FAs3biftAqhFE4hAMQ9IBjUXYoDmojCrUrPcgyRqx5hKBIzYzWOVjyOFBSCOwZSX+4VHalCw97jT5qgD0jxFNDpAdFZQD0sQoXsoQVDxIVU8zpPjB8jFv1Q6EBaYTnlMjJGa0oY7GqdYMYjIUaqBfB2cNjGXBm4ZyDlolnWQaPEUf8bCBFT0C3AvAGSd7xnJyifWgD0H8SfB2gp4GXzuoTlDdZBuPByONWR7HJbqJuC0qG8HcPDEPb8fMMvlkhoS/lWBlB+4NJo4UuIGgFwabYXtAwleCnBAEh6Gcq6OVWpzyCPmiRTgBcs7BaF2FsbYo5dpFRJ5ah4gbDFSlaM1LeFqgwa+RjCeZsdTA3wDZLIQFOCvQNwxbtsuokkV7NIOvS8WKQP1MgdYGffOgNgD57ERlPFZvEVrSjafLx4IjU4zlXLzw5Gw2lWI00sp8x8u0zkshagXeeJncy0Es40DnAfYBnn2sVw70FrXZbLbDzP7iKNix1PZ6kiRxzfIOrrl7NXc/38u/rOgg4H5r57G12f7RHbYVYBmFKB5GmJjuJ1KvoxxlIu0Ay2FRpsgotci4qK6kqUbBHDeQVkLg3bA5AlkH5DIQHAVPBOQyhMdg+zMKhTFweUvoaZmY2yRRAdUPqCEqZjVJyri8MPiBEvEPdqIrLaCZkF0PA1ncvRnqcib9MzoxvGXI11Jsfx+rT2gj1PgyVeP9VIwKmWCEfG0zSqBEvDxGxucFHSx/A4xLiFg9KMeDWUVh/ocoGHczWiUQeom8qmGUNDJpg+YYKAo4BcwfgZxHMOSSiGowHoZwEpQyZKOgpw1aulQiqRglOYFXthjrEAw6ZxDb3EValzFD/dQ/U0YPCPQT/OBZinPbw1i9Jr0BqLh94JBAKePv76Zc5UELhGlb202spNEtQUWBnN+NYyxBU6WflALCDWoRQhYoY1AJQd4BsRLslBzk2xV0q0j2uFZQZ8N4CLwGOOoRYQm0NRPXWG+d6Mtu9ABVIMlggjw6hlocoDsrUy+Z1AdBU8FY68GVreDwFbBqBZURi9E4tFRB3RIQBejKQDrkZUyayYwtO4jm8kieFIonT+8cDfl5haVei80XVeifN4/ynKWgZ8i5Q6id0Jm18EWh9ygJ5zGCfNlklV9B0k1iJiyqQPedCi9u8aJaLqLRNFqVgS9n4siDshD0E8HnnBih3OODcB+kSnDaZzOkXs7g2AlrH29G11y0SBlaRTcJS0bPqHg8FSKNoLwKxcyBjkS6v5aLA61Q22w22+FmOi3Adiy17e6MubXMqPaxc7zAPS/287GTZxzqItls72iHbQW4SIoxdLw48DfmmPlBE20WlCuQ0mNoNFFDgSgJcqQoUodelHjpT3m8fQX8H4KBedDdAK5RCJfh+DyIIUgMBcAwaWrKUWgFMwO1D4K7GrIOwQ4zj2IlMZaZpC6agXAsBtMCvwrxBGChV3RGqkIYVccija8CTwvCORtRcxTp2PGkRx6HsQ3Q+B5onIVVGCdRiYPigUIa8EwM9xyIgbd54iNldRHUvAtR6QPXRnTFoGvWTJoGtkLOwi+Bsx7KDqg1gaTAV4JeaeIz2mIeqsehOSyoNGv4hkxMl44yw8DMq/iGdhDZGSGj5lFiOpmkQq3fwArVoXa9yMxnn0MfkTCO95BqPBt0FYSPurKGyBfp81SoKxbZVgN9HTJyKYRZkvGND2JVT7Sgl+SJHsyqBP4y1JRgOASyClnZT2VEpalUxpsdZXj8BYyGNjD7oTwGjhSUg0iFOCL7d2g4YuKDaE9k4u1EYjPucj9qXqBZMmskhWOLOu4YxIcsjCEZYbjw5F20bhSMyeAoQbYM8WcUnGnBUWaZl46MEW/LMzexA7G5hPAUCQhwvBqjODvFcGc75dnHQ2kMNAujNca6k1uZOdbLi9V+MidWsb7GgdBNLNNBKL6TumwF/ybI7fRQEBYNgRStM0yqLQgvBqUBsvWww4CoBloR0gkQBriqQO8DuQ/yY9B8bi8hpRevKrHqj1V05Rfg7prNwvotzAmZDJRn4KAJ6D6AO8quANtsNtubY1eAbW+MLEtcc/IM/vX+DfzkmW6uPL4Npyof6mLZbO9Yh20F2EkVtXIF7+wES69Moc6Fvji8+Pcg24dnU892apFQAJl6UrhIGNWYyRbU5zexqK3IXD9sd0GhDDUukDbA039UKOsVnM1FPO2QGQK1DKYJ24dljFI1WaeET5XInuJG+Nsg75oYTtgfhLoYBA1Md4pSKAauRkQ8DbhBKFByg9sFVceBsw1is0E0Q7AOHJH/+7cxDaoATUxMVJzSIOuBYhlqTgKja2J+Jn8OuVKiWdtKKg95CfxdE7scdEFDGZQCqEHodU60DqNDawXWz7bIFkcIjYCqQthtMJJzk7Kc1HQblHwmgWYoh8BERtVy+EwTqwkytRHw1sH4AGRfoF92EC4YGP46ts+rUBYSwgpjesK48sPIAYshWaG1YiJpkA9BLgsBc6Lrs9sBORUMd4babgszD9GeErJjJb3aEmj0geGD3AtADLkoEF4FS2mAUAiK3ol1o/0UQ3XMkoYQusz2xiN4xdrEnN4cLt1LSK2QH1ToPvJddG/9K3PTgygleKUEatpBQTXoVAxmb3ianbMdKDGQCg7KMyo45gpmK6Osd7kpyzqNj/8Kc0OJbHUDxdMWk188i3WajhrIoqTLSKkiXt1gvlTAm6lgSjCQBClYYHFKoVzyUojnaVghUOuhok9MixyNg2rBmAn+dbB9WKHleJOazMQ0XiNHg9EpcDrBSAuG/ipIq6MELBX3kIxiWeRNg53kD/CO8jExhcfe2H+IbTabbd/2F0fBjqW2vbnoiEZue2QbI9kyf1o7yKXLmg91kWy2d6zDtgI8J9RF58njBE/QaTgSNg7Ag79S6VrVQidJWiiSpo0iAeKUecWXR1WKLMy6qOTnsv3v25mv5XEELbIeaA9C10oYSCrUqhWiQQEmVEZdlLIteBjBmp3DUAeJyAbho1OUOkNoOffEgEy5BIwnIbwEQmFoUMAogiuGlExBPIBwuMDpnZjo1hGG1vlQKU3UrkuOieZRlwPyysRQ1HkD5HEobwBv1URTYKUeCEPjUhh1YpCgN/sSs0hjFiBhgZKDjAQBC4o+GK4B13bwWzBqQVQBKSCz6TwvoW6Jdq1AjxzECPiISZB3GCR81biqs7g8FVCHUAJxMo1QrJYot4dgcOfEfEpWJ7qaxN29E78+RHqmhBluRDILyDsHqd+SpuKXybVHGJKSxAwLRQeXmDjVigz1EqTKMoVgM8qMETxo9DZ7kJwW6E+C/D5QIigjJrHKBjJ0Uq6eA3oDSBWoDIG3FrzHQHkT3fIcXJF+pEqO0UAdS9tyeKQ05a0yi0eLjJijDJ1zGaXnfklNcZwhv0xkgU7LJhhzQX+TG6vJiaXmyRV01jc5sSJuYsu8jDki1ItBlvVmyWYhme9lfVcI48g2avqz1PfkMDfkYVii7hiLOcdN9EoY8EHyWJDzArHJokHRaVwkCB01Mf2TuQUSG8FvQkkCRxNsezLM+mQzbT0DVD6VQoQnpvBylyd+bRo3QEvZSW+ols7KFlqrK6x+cR4jxhizcPHyAd1Rjv/7s6/1NpvNZtu7/cVRprHedrhyqQofPaGdW/6+hbue2snFRzYhy9KhLpbN9o502FaAOy8cpHYJmA7Y8jLc/RMva+ISdaaOlwBpmgkoCbKmTo+iUvTLSGYdacmkWUg4hoO8+Cs3cQTOcAa5Rmegz4VKiHD1GI4emfFXHQgrTIgwgeAQ4cWQyg+j1AnSiyUqPi+U00jlceq2vEKlLBOfKUPgdPCEwPSBpeDfkcI53kOi5izwNkIoAroGZW1iIClTBaFONMUaEqRlqGRBykPpISi+hFwMYbl8UF0NwXooy+CbD+nZDFUtwrSeoTphoRShWwPv+ESLYtYL5RIkcjI1AxbOMsQ9YLkEetTDqLuRsUoOoS5FcfaTy60jWduOtdDDUHor7oLJ7PgOTCGozILxcARh+UGb+OYWpwNlOIu1VTCrlGZ4BJKtJla7gX+ggjduMRCIgG8J3viz+MolHJ6JkbfNzMS8vy4fKGEFEexA8mQwUzqaL4acV6gZfY54pQ2rQcX01NNaGiU9NMi2KgPkDJTSUNwOgVYkhxNHOo3euYxKv5tofi0RIVgfBHOBoEEycY1A3fpH6JnrRltYTbkrScHXSFv9IIFRE/cYbG2PUvLUsDEXR1UFM4o6ibTKQNsiJDGGrOnsaHRT7JiYB1gsSiJXijSM5PA+I1PZHsEtingbS5TMiXcZviEwBiTSMwVHL7PocmmsDkrUuARHbAFlJyg7wBEAAuAfgHLZZIZ/iGhQo7wVtj7iRUaj+SST2ZeAtE5mpyZRpUtUSRVSr8TYoPkQOJhTswPGDuSO2t/0HZU3frPabDbbYWE60yDZsdS2d5cf08L/eWwHO8byPLpljDPmHfxpl2y2fwaHbQW4aSE4lInpYH95t4NtXVFkySBACAcB6ly91M3s5tWeRhpNQTKpoJKkKlwkkHMRdo/hLSiURTVyxktc7UOrqIRqM7hmQHadwMLEh0aIEZpDJfqCkFghCPtgMBjEElFIOxGmiZEwcZU0ZN8AVocD9BJ4vZDtQ8hJmp4aplr9OttP+iBm7CLQEqApMPzSRA3VVQ0ONwgNKkkojIOrAOmncffHaRrvQwlAuV9mcEYIU65ChAOgz8fSWhn2rCdZI6OW0zgcFjOK0O+QMIREIG2h+RSUGgvdBaYGSl5QOzZOw/g4vd4Y8RlzMDud9Pkj0LwQ56t3E6OIV8ggnCQibnLGDCqR8ES/ZcMDrn4wdBwOL87IREN4gwscCYO+hiNJB7NUIqMUOo4GtQb6JRgFrUXCEVUIhw1EDpIRSJgORHAe5UIfEXeaRDGJnFRoT5SIZn/HNuMEzM6j2FAsU4lI4DsJKtGJyXtjtZDVcaT+wrydWXbmHqFQA7lyA1rMpGQmqSlpmBFIZcA9WCQWeJicaOWYtVAMaBRdClrRJDAOwWQabVyhcVxQHgF/AdxljeE6HyK2gh6nF+fCUfzhAcolMAN5pHyKrANcJUEsnKesVJAXQrQEYyq0jkDqfx3UrNB54kyF1a0hZHeRhmSZ8ixYUoBYARz1UMmB1QaeU3PMcsBoNYw/Bb4xA1+LSUWCNCBMBxXVQUbN0a2DJTz0KoKgY5zgigz87kDuqP19u2Y/tNlsNtu+TecbYDuW2vYu6HbwgWNbufPJLn70ZJddAbbZ9uKwrQC71IkZhx6/x83YjmoMKYRPklksVIq4KJkVlAZB+6kDZFVI/caBZFqE32Wy40UV+dVZCBxoOAhZMsPJUVyWwO3TKSdU9EKUkqgiiR+VAiW3xKBDoj/qJOW2KAQXQBnI94PUSUn4qIplkV0eLEOaaNYUBpR0ih4/hSZwVYpgVqDcD5UyjGQIvvxzNEcSLRCEqvDEPEZWEoyZkIWq7iSulIUrCKEiFFwWw5bAlRhC9D9OccaJE8MHm2vR0nkkR4lQvkRXVCJf7UPKCSoUcYVNEoqfYtmNZaWIayaurRLjhgyNWdDX4Fv7CvWVNNboKvxjKQq+IN1VF2I6qsGvgTkbrAyMPYU8uglXVR+ljqMpzb+ErpnbcI6O49QNCrULEdp8xAyNXKgChoZn7BdkiwaBuETOV0WmaR7NlecJuyrkNRhJ1kBURxTT5Mrg8JRQ9YnKoKeYIxZYSco/k5LZBmIDpPoh6gfDAn0QeWAn7vIIOAR1+RxdTfPRZx2NbgncO/4IXo28GyrBiUGvlEKJ8qIT2dRtcWJ6I4/XupihwzYX5N0FrEKUvio3nYUygTDsyLqQSVD72DrmlvpxqxWijROV0yE9w4BHoroTYpcJmkyNp8ehYkBLGYQXLB9UXaLzrE/ilZgHacBk/toysVcVxCIT4zhoOgb0IlTWQyYIVS2Q8kC+BfzrJBx+QSAKSieMFWEwKZNzhnCp0FljoiwcYMbTBRYGU3iSB3pH+QD/Qb5LbTab7XBix1Hbm/fRE9r46TPdvNyb4uWeJMvaqg51kWy2d5zDtgL8zCNgSirPrZmJLoWYLxoxxDokLPpwUTKCVFYHqF6RI6vAgCFhpH1om/L4ZBhApYybVspIjKAIGQcm3h4HOGTc0RTxeIQkEgEEah5SkhtDDZJ214NvJoHHHyGsDJM0hjDCGjti8zC9HVDKgOYFrx8sPyJvYYZhMBDGrMg4nv4ehuSkpasHp5Gkq8YFOQ+SQ0LSUlieRqg4oGISKhuUI1BQwVcAvSJTcdUT1HuR9Q0U+1eB9zic4wLXcC/OsEVoADIBF2asGYRBwjGO0Kph9vvAdFAY/B2xtZspl2X6ZztQTQN5/VrMDRnSHTozfQV666OM5K/AKi2HXB4a1oF7hGDP0xT6LQKyzinjvTwS9pDvPh1Cx6OXLHRJh94oeNLgdk4M1qVsIOLNYSom2rESRbkZHFWM5wIsDiTJ5iVKkhO5+AI15SSBEjRkLVQDwjWwxgeVqEGs/CrDRhYRksE1DoobJA3Pyj8xs2srXtVkZwtofhlLD0AmAT4XoqoefyaNFZ1omE/JMk5Fg2w3Wxecz7y+LuaVCqw7BiQFOjZpmKu66Jsj8VKLE6fuoxItsnTV07StlTCGGxlXk8h1BepnQmyuINoiqA5BtA1WF4AEzOqHzXVQzMHyFIweAetrXMg5Bd/GAqHfRHGko4Sez1FaHGdLrUlynkXVUVC3Fgq9YC6cuMlDJwma2yqEHBOjea/9gYdXNkcpWxU8agazLYNrROEDHQnW9cpsOpABoIH9t1wc6LRKNpvNdriZTguwHUtt+1YTdPOeIxu556V+7nyyi/+xK8A2224O2wpw73aV7X0L2VKpIYSBB5MwWdI0oqOzQyrTnW3C/fNh2lakmaFK9Bkegr1FfDWComxRY2nUUsaS8jiFE0tIyK4cIbeJKPoYQyFKnupQN7LXpOh3QHUjOJchDRaY8b/j+Md8ROblyaAyLDI45j5D+fw28AVBFlDWcOojlFRQChWkgVcI514l5W8kmEzSHY4SSJXwxocQYwKr2s1YYxDiORxWHlmCjEOmTliUVTAsBeGSyBQcOPUScmIV1swINSN9iKSFNQSOXok6n0avmcSorifQO4BuGZQboqBHUbLVhJICSTVhyMTjhdCmQdRxmdRsQXfJxZjrMizrePAMQFUetfhXOtf0EihpvLL4cvK5IOODG5CerAepFnqyUCmAbwglM4Ar/CqmW8OwOjF9ixjhVKKhh8kEvVQCbUjOJP6IhuaFHQUZMzSClBUoRYu6CrhM6HfBel1FqzZpEQJhSQxFjwJJRUr8BVEOoSSdtD6/AytrkW0EOQ7+cRO2voC7xkFiwVFotacxIo9imBncOQuvYlH2yqBtx5CPZOWsEzh140p2lgRySKC8CsaIoCYBIxfLJJrrmbOlh5lrBYkRhbQjT2hOkXxpYsCxRhlC2Yl5lksFmLMGEt2QaoLRPLhiMNoA95f8zHguT/VoGTkNUUkjp2QZLpV59fkYBhJVz6XQP1Ji02kw4AIjAJQmHpm8tdB9rxNjUz2bivXkAi4ksZOOTAB53UIkK812Z4JxR5nx8oHeUXYF2Gaz2d4cuwJsOzg+dvIM7n25n5WvjrF9NMfM2sChLpLN9o5y+FaAu9vxGZ1UEcfCjYxOkpn48SIxSH9Ax6wN4hqewRxpHce9X6P5vnE8moWjCaLJPopWBU9Bw1Sh6CgQBcRiKG1zkqvIOAJ9xGZpzGzUSdRAMegEsw0sQWjD41SGDQo5BfF8LRUrSK2QqNvaz7bwfWTOmgvFahgZxZvVUdtAjeuIsELOkjClCltq67GUIlWbi1QnTIp+SGsatOjgn4ckViGbECtZyIWJz4QHnc1QO5dKQw3u1GokSYHRfvSBImoE6sZBqhYEB8BXjJM5VkeManjKA5T1l6D2Asyq2ZjVz1CVMyg6QEmCkRHEXSa1Oeg3ZmFVH0Uo90scC7YRd1+MOual1irRHXVghJxQbuFZ/4mI6nMnKr/yOry8SM22DfideZxRg6yAsFjLDn0V6abTGJfnQG0CyXqe5nyCmlCF1ULCnGtSn8wxokcwJYWoMNlcgr4w5GvDuOIm0rYUxbigof1ZhlYcg3cggac0gH8HGHGJikdgCYmMM0JEL+Ie1YiVNMzGIeKzLyUnvw/0Zyk7yghvPZhJiBwHuQCppnfzRDGOldlOIRgm0DSK0gdVHgtVFrxakfHJOpVF0N9poHlSjMyD2gy4JRiVoS4L+SEobYRsr0LkNBNRCx3dUJuFwfmg/BnEi9VkLI0mf4X6o/LUlPPEt8n0j8ikpDI+Z5mtA9B9Fpgy1FgwZzt0PisxttrDsz0qVVoDaXc1RlBQNxDFogrFyjNIhbhLwytLhEwJEAdwR+1v8BZ75FKbzWbbt+kMgmXHUtv+dVT7OXNeLQ9tGuVHT+3ku5csPtRFstneUQ7bCvC4kcHFMNVEcCIzQg0CB0VyjGJgGgKGxmgrNhF60k/tFRmos+hdF6JunUXsjCyJlyCZUKmIIGkMDGeZIaeB/yqd+id1pH6oXwJdM8AwwVJjIDXgiD9J684RnIU6dKmM05XFX3JSooxuVXAmR8HIQKYKSiY1vQKrC1J6ERo2U3ap4A5SWRLBt2U1smQiO6AI5B0yEAHHIoTRh0vvwsiCloeiXyLjOhviVZC6j5LqhEQaKZrGXxKUGkDqgLCAPgeUXQLiFmoaQqMVMs4urOY0+KKMdERwj6bQ/W4aHHk8HvAb4FZlyu6FSOoQJ898nKxe5snsC5T9LWSU9Riya6LZU12PqB6GigkLduIfv5fFq+O4MFDnGiTz4FNh3CfwOgcoOf+MFqwBRx0UEuTNcRJlH62lIo4+8JQFiXoVS/fh82TRJGjJwg6zAavPgda/mkwE1LQGFY0qTVCfteiRZLQ2i6gDMnUOSu3LMTIaTeIJepUARceJkNDAqgL/AgQdUKiGyBgUGqDig7EIidmfg9LzEGhk20k78CkPQI2TUtVSCNWxI9DPloKfkuxAyAoInWGvhaoUUZ0qy8YSFN0WRg209gvUFPT7IVqAMRmcm6BxbZGCZeEwgri8Y6R3QrgegkstZq202KiFcCSdhF1pXCVIO0DSoH6VhHF/M2u0KoaCBpYxhikslAx4rRJufLgoEaWJTSWdmOxgzskjPLPyQO4oP/v+du1AKtM2m812ONpfHAU7ltqm6xPLO3ho0ygPrB3k82fOoj7kOdRFstneMQ7bCrCTKAWq6GQIizoypBlFQ6FMHjfeYhknGiFyZLqDBFdnyCcdhAwven2SsgsKIw6KgKmAqTvZqglKa2VSiyqYOpT6PKSG8ziXQNrlQQseC2mD0NAwLbrFWOM4JQX88yv4u/pR+iTqoxaD4Qh46iFRBh8UhmV8OniiArUrjdHuQhIDiJ5R9IREqVWid1BGaDLluoXgmQHpMEYmSMYLoy4/YVGmULQwUiq4FaTMCGLQQPWPoLUuwCh4qCvmIQy6F4YMJ1pYAkcUp0MnFCkh8m2QBaI65aZTKdclIOhkYO06WNSEbI7imKFhFY/AH3+ecLbIoAcU3zpMqZ6N5XmYjdVQyILog51NUBSoDU/h6B0lb8iE5xooFhhZsCrgqAIjD0FPhpRw4c4V0SydZKkWKeRHTnVRGjcxCiCpHjIRhVcLOcYNL7GKjuZbjNMaREqDJEP+eBf4FjJWGiXv6SYVrsEVG2S0UqboAnyvUKk7ke7oxeBKoGTX4Nn6EKVIEDxLIFUPVjUUoiAcoBlQNkGvgcazQJYQcxaRr5kBsgluP8hDZDxLwecAuQ2UZtAK6MEyulKEcITukV8xJz7AyEww/BZlwNMLchVYBlQ9CVHFwunVCTvj5MdCDDly+AYtXE0Ch0tjrtaC0DM0ZdL0Z6AQAVmd+PfMVByEqNCWc+ITaZK+FHJJkEChlnGEezNCNVhcqKF60Shq24HeUXYLsM1ms705dguw7eA5oiXCMe1VvNCd5KfPdPPVc+cd6iLZbO8Yh20FuIKGSZIkHhQ20UA1Cn5SZIiiU0JmNjGqJYFkVqj0SoTyJvKSUbQjLYJZGI9UKNWBy5nEsSFGuKaEv2wwVgBtKUTGCmQVyCowFJwNrqVgPIm/lKVcDYl2k6RfRWuAmTMEUr9AE1CuroKcEypxpOIAXreBMaQglUyCDgvNXabsLWOGAjiEgUAmXRWAQBDazgFHBehHFBLkRsAp6yR8LuRCEaWuB9N3BKJ8NOasfkxtPmRrGZzVSi7XTTBdZoupUgy5QDdxpfOUNYNUPThyg1RSryC8EQgtgfAg5Laj+RsQM86FkgEjAvoDVIsX0Pqhag6opoxZVY0ROxWEAO0hkFqg8C6k/Bbak8/h1SqEgjAUctMdqEeoaZrGUvQTRIzB7EgWd80owbJAKktsLYeQHTncoyZSGaQANKoDDPpcvOypwhIqGVGP8C6mUhukYL4IcgnDFQFjJ6q/j6waBJ+FbgTx6RoBQycuRjHUzeAugQ6SSOEy45SGwhBLQGYYqiMTwzKPu0EqTRzcEkAIfDIoMrhWgJoBJQXuEOTD4NJAqwfVDeRBSYOjFlxN9Fefiv/x36ANGgy7wJOCeg1qW8AYh0AtzDkDxl0Ggzo4HyviHQBNgmyfhNtTJion0SUdTx4ympeSKehzQl2xTLOcRbUsfCKFkwqKkaFihcj6W9hcVkmYTmbKBaINQ8Qu0aH3wO4ngYrYRzjZ1zqbzWaz7T+O7spjs03XJ5Z38EJ3kt+80Md1p8wk5LVfoNhscBhXgGXSpB0dpOQsNVoWD0485OmWsoSEA5UAEQqE5vQQXGCg5ME3Jih0gNwNCQO0Zgg5Id8NwdYEVSHB1kFQSzD6LolcGBJhFSsWxqw+GfQwcnw7SUXiqSMb0OV6RKOfbK6XciWFwytRN5KmLHdCyQ1mBUciQTUWWYdEwQ2yAxrSgrwEei5P1LQwylDxFCgbMnL/01ixMCTWI8l5XBXwpCpEnDpaUIbys6BI0BYDzQGiBUQA01pIqnYGKV8RyhtBLhArFKlNFdHGYNwPS3mG0shq1tVdjdDrQBZIySKtfWsZF+MUOs6Ewiwc1l/wOIfIWJDbAlLQwlfaTqF2OUgzwL0AhluhEkMoEbpHl1GjraGqvciOdIx8aBG0pRgtPIcjUyBqmQz5VVKRVsaVHIu7xwg7MqgmtLZDKg9eC9aWQuje2XiGt+DdPE6iCmTlYayWkxjxngOecYi0An4sfy2RfDeZcQufYjFzRCBXwBsqUUisR8RNKmWVYEWgyhYlXxqtYkAlBMFOSHtBU0ENT/wXDZwWWEVQHWD4QAlAwQRHCEw/+CSwZCg+R2Dj36lODTIUXkT5uGswZp7EcPVTzBroweyVKKV9uNuKFLwW4/PhCBnG14JXSAwvFBTeq9G4EVpzUChOzGedVtI40g0MuMfR/YL/n70/j5btuut70c9c/VrVN7tvTt+fo6POkiVZNrZlW4ADBuwA15c2lwDv8kKu32MkMHhABmQAeUkGuSO5NpeExAGcEJrr3GCwsWVLsixZfXd0+maf3TfVV62+me+Pta08B9uSjOUDVn3GqHH2rpq1a9Y+e85av/n7/b5fqagovZjBLRL/yQGzl1V6sYGQOkfjHp1kgVbiMZUNKWRTiCTDPtWl/iJcOvPa1lOCRYL1NR6Pvu61OmbMmDFvBF5pH83HjPfSMa+ebzsywdHpEuc3h/z+49f5X99+8EZPacyYvxEoN3oCN4qZ+T6qvoRggESnRYoJzEsTgUuFNn0EbV+HPTCaAP8Y6DpEQ9DKMDsNdSX3W933HZLaaVh8KwQHHQbONJsnF4nn5kn1t4BxCHrbmOoG7uQ04eT7kHu+H5y/Q6KcYqt8D+t7P8gg1UgbOgw9yDyM9VWqITSnJfECFB2QBZAB1JMMy4VAQpolqN6Q2qVHoHUVFB39Upf2vjJbexdQhwod9w7KXkK18xD4V8CLgC4MHgT3PAxdMA/D5JtRhhXSdbg2VJE1SDSbJUUhGPmI9adBtCDz0LeuoV6NCVsDWD0LtS9wvPeXWKOM/iIkPTh5sUeh14FsCEQwOgCjKajEiMIWJXuVkR1TM+D+6TUOJJ9C2V5nWChRS1JKGqQuaO0OdAas1GBo2uyoR/iz5O18wbybh8Rp1g6+H6l9B/7aW2iLKorrUmo9AsPPo8ZnsJ0l6E/Bzh345lto7fkx4vp78NUKUodqBL1nS4SXJ1kIFfaPYpRRwmwmOeW2EAMX5POwPoJrKUgbYjW3q9J2L1q0AkgNEBCbMCzmprxeHXY08AxYy1h4/DJTn/A5+EdPozz2KNTmaP3A/8LZ06e4vLjIizdN8/Cbi3yuqfLUPDx5ES49bLH0YJ3qn5n0i/DoewRX3gNUoNVRaHk2kbSwEoHVjyDSKckYWwPj+0Lmf3yTyTs3sPZvc2AhZp/a47ZggsOZRlUMsKtD5ksSoUBz8bWtpwztFW9j/nr8m3/zb9i7dy+WZXHnnXfyxBNPfM3xf/RHf8TRo0exLItTp07x53/+51/2+I/+6I8ihPiy2/333/96voUxY8Z8DV7NPjreS8e8FoQQ/OTb9gPw77+wRBCnN3hGY8b8zeANu5MaWsqdt1wlbZUIdzzW+wEbQme9WmemI3CyHh1igi1J8zlwJkDugeQyZAH0m9Cfg4oPlT1wyQazD5f0IlGmobw0JJsugXMz1N8McRWx/t9oXunSmhH4zQIUbga9j9LbQE1ckkaTQUUgUzu3QOp8BgbrbJfBjkEtgufAHgEiyz1pJ9ogZqAbSCIroadpoJeg+R4mld8l3HCJF7t0ov0k5l1M915iJ9RAFsEow8XnyMtxhwjrEtLVoFwnkwaKNGimCTszKm6tSlzs4I0SMnMH3BWwejitLq4HaZrlE1zrkyQxcQpuCSoV8GRGEqXgPQv1Ldi4GbISpAMMNthfWuGFmSmup5uoUYZ9IcKob+FPVtFnu/ixIIhBeCmqJRiZFtHccbLCe0mu1GAwTzh0oRbASoyc/DswuU6a9uiXTkGzirH2KGbXIxDPIMUMivdFsqlTYBwgSi6zPejjdjNGQhDPHeD56gSlwVlKImajB0Unpepu0Z04DMsC4iJUUtALMNBBy8CIAR9UB6SfB8JuAEUD/AxkBiUd1BrDFZVRz2YahcYn/292Tp6GvafpvdfKTX8LNldlH/rPYavP41e3qVgh66MidIqcvBYi23kxXO95jaSn0ZUKFSLkw01KeoudHxJkFpRMMHUghpm7YvYWYtZ+D0aiRUJIaHpU51YpzkpefD9YMfj/9bWtpwSF5Gucp32tx8a8Mn/4h3/Ihz70IT7ykY9w55138lu/9Vu85z3v4cKFC0xOTv6V8Y8++ig/+IM/yK//+q/z3ve+l4997GO8733v45lnnuHkyZMvj7v//vv59//+37/8vWma35T3M2bMmL/KK+2jXxozZsxr4b03zfLPP3WRtZ7Pnzyzygfv3HOjpzRmzA3nDbuT9geC08dTTv1vPe74exETB0Ku12oE8xmblSI2UyBskiQi24F4AmQNWsfBvRvMebBr0D8JV5rwogmPTxtslwvUzw4pXfUgLoNzCPoqytVP0fjTT5F+PEV5qgPbT0HvIgQhmWaQJF2MS5/CdysQ18Dx0NauUO/FeE3YssHfURiGFs4KNK/D4jJkEfQkhCWdciJxDAPm74HkNFv7DjKqqWjlFLdxH5q2hlZ2Mdp9tM4GdL08kB3ugBdCrCCCL4J5FqaO0jn5XlanjjNoTmG029TWIrzQBDcDBpTcRzmUuhRskYt2RSWUjRXUuqRaAZGAqUI2KZHVBLHxFOKFT8PqNqymMIyIWsdYdQ0yS6EbQ/qEShxCXG4inJhVbYKrczcRTM8QmpO4tfsZNO4jW5wC7TxMPYGy+edwVUL7Csy2IAtzQarm+6D5bagbazgtl35xFmkfBNND9XZQVj4F1z6LXE/oXi7TXzNRGDJ18XGUpRZBVqCYKpgh8LxBtSVRhjPgzoE0IHFACohcUCLwFPB1cGOQKehh/gvwU0hcqPkQ+hCbVCcVJswYYUTMW1to6w+BjMFqAnVop7nC9PTNROZR0j1gHwfHjClXh0xkMLkCs9dh38GEUiGihEJKlc5oBvGSgnADxJbEfRqyZyC5CuEOJDW4bkHJiTHVHuV4PwfeIrC/H8omLH9S5YkvvLZAKHoVtzFfP//yX/5LfuInfoIf+7Ef4/jx43zkIx/BcRx+93d/9yuO/1f/6l9x//3383M/93McO3aMX/3VX+XWW2/lX//rf/1l40zTZHp6+uVbrVb7ZrydMWPGfAVezT463kvHvFZ0VeHvvWUfAL/z8FXSbKwkPmbMGzYD3GhIznwObtoHS7cBUYT9+wNGcREtrKAQMVG9SGBnuBNgFmA7ALcOgQKHBWyEcDZVmDAzEl1lVHNgR8c95BCVZmH6HhhKRPeTNB76IrXnQq5JQe1cTDR3mbiyA6Nl1PUrNKMOTVJeOvGD0LgP4g5peZayfBHblxgl2ImqpHGJuHMd/bqKcFKevc2AYoIyVKjGsL63CWIadgzi9BjpgQ5+9GbQDmMv/AdW2wpu14TRDjTnwJqF4CpUqshQhbKAPlDfAOlQn7pKr24x1ZIc2JAsVTxWJ1MSpwpuQr8CiikRMkH2rmCNrtLZhkoDhAqjAFqGii1Swh2XoDiBTCyojMCQyGt1utVJ6vYKlSgjnRFcty1MtUWYpUTmQp6+jC2UbguZXMYIdohiHem8FWFWqBz6I3rzBaS/CPt1GJXyzOsXdVAaGJU1zKqO9G+B4T6oS0QnQ7GbZLM3Q3eD/mGN4VZAKVlj7uw+mss7XLxjgvPVm7FLz3PTFQ/dUbkm94FrQinJva3SAIIA3G0wnwNbAedw3vMbCch8oI+YfQppGLB9Oxyc48p797Bn7hI1N2U+g53/9Am2n15DmS9Sis6hltpsHnw3VG+Fvk+mwMRpSVztIzNINyCbgsZBSHtQfl6jZ3okUUgoJaoGCIH8nMb2xxusE3C8NGJaSdh6G/S/DWq/b2FmJmltmesHMuQi9P9I4dyzdVzNANZe9Xpy+dqnae7Xt0zHAFEU8fTTT/PzP//zL9+nKAr33Xcfjz322Fd8zmOPPcaHPvShL7vvPe95Dx//+Me/7L4HH3yQyclJarUa73jHO/i1X/s1Go3GV/yZYRgShuHL3w8Gg6/zHY0ZM+Yr8Ur76JfGjBnzWvn+Ny3wrx64xFLb41MvbfIdp2Zu9JTGjLmhvGEDYNvJxXz7VyFYBvX2lD1zXbbOWxgRKKRoHkxMQXk/xCuQjSD1odgEFGifUtip1BjRx7MWQZ2EiolfsMHYB8Mh9tYXqfynVZQnJrCjAWW9CxpIDAha0H6RmfY2+zKJpsB5GZAqDlzxkaUJBlM62lqE0MByFHrVRYLtVaxqirMPqGvILKPWC7GnBdHEPlAbkAYY3WVuKVzhxcszeFP78ItllEiCSEj9CPxNECJP1ba6UE1B2wNqCMNrMCgzyuZQWhskasrjeycIzUmy+n1QrBMFFpkF2bSJrJzG6HaYVjJmGmCEMGPBqqqyI6ZRTIW0cgy2TkNUgb0J7EQQeRS1jANkFJtw7QgknsBZL+DKPZBeAXsajCoZNay1K5gMiK8XsIxP4fM/0e39FMqL+8FRkG0f8YyBdGuItQp4EN5msd04AOlxUJ6BbptS38UWQ1av3w5L74ejbbKDI5JL/wVldcQx20dRVjg/OICrvp/4lv+EVRLQmwdhggq4Ya4+VfdB/VMs5QECo4nWliQTs6DOgVNDbz3JzAvP0Z5axJ2/HboJ3sxRzlcWcVrn2LO2ir014sAjj1GfS/H2w5W5RaicgvYG7FxkowOTy9C/DME+SLZyO+X0OLRrUJuIaeyJCJausbp8jCgoUN0Z0nxBpZ0VSUQVz1pDOTxk24HsVph8RMG5vkP325cxMhj8e8GTn1lAjYaYTgf/NaynV8pMjLMWXz+tVos0TZmamvqy+6empjh//vxXfM7m5uZXHL+5ufny9/fffz/f+73fy759+7hy5Qq/8Au/wLd/+7fz2GOPoarqX/mZv/7rv84/+Sf/5BvwjsaMGfOVeDUZ3vFeOubroWBq/Mhde/jfP3uZ337oCt9+chohxI2e1pgxN4w3bAB8ft1EEyGXlsFZFQyeUrn1RMjFYAP/YpVE9XAmIH4zGEPYfh76XUgXwbagn0JFgsxM3IYNsgnmQUhTMHTob1Ba/jyz/8Wj9dwCSlIBoTM11eHSAZukOQHBACVepZpJUpl7ttZWn6Y1eQ6Uo4igxZYRU6yAPwItHiAP19i5XqOyr8XTlSLGSsiskZA5sGFbSFWBszFcOY+1+QRbOqjRWSieQOmPiHyJoiaoZUFiVsDsAQVIAkg1SIagxxhRhpJIIqPCTHSdrl3Fn/xe2JmHC3vB6hEnTYLSFtvhKZTlETdtP4KyIjB8ja1yTLUIFSfFtvt42rcjnn8PsglM+dD0YTVA1C4znW5ACLIBrfX9JOv34rpTUF0Cp4D20t/Bai8xuuWzOPGQkWeSZXVihtBaQlz7SaxBRLAIcmSiZCHaIxZmUsKv9YgPnCQrCZSN5yhsPsiweBglBdsL0ThHorwDrBoMp3HFj/PC5OdQb/0s9ZHkPTOf5TM772KlUcIuqrA6C24376EWI6gAi+ehcJ5g4vsQX4ypbH6MfrDKRCmGgsBsJZQvQdZdwZ1/GibvhPAE8tAB3OlLnFv4v7H3LMFKxFLVISmXiQ+8H6onsD/1axTpU3Chvw7dPhzUIS6BHMFLbZgow3SvjqKk9I4OObYuyCyF7IUMuW5ipz1G+4eUvitkcz9sNaBfgdt/yEVbcrFug43/oPD0GYvUT4iNEo0gfE0BcMzXvjCLv96FOuZ14wd+4Ade/vrUqVPcdNNNHDhwgAcffJB3vvOdf2X8z//8z39ZVnkwGLCwsPBNmeuYMW8EXmkf/dKYMWO+Hn7k7r389sNXeX61z2NX29x9oHmjpzRmzA3jDRsA6z2DrWFCUkzxYkHwdIm1DZd9p0OUjRajWgvzeyMePixQnpYUJgAfbAOUAXRmYUlTkdYMmKXcUqg1RJFb6P51tJ7LwScH9J8vEyZQyDQ6Rp+qBVrBJJ5cgNEAIfsoOqQZhCksdJdpnX0Y1CPI7F6SxgvQXsMbAVGE/uI2rX0nqW49TGXDZ8ZNSYvQWlTplhdgeBF6f065/SJGwWfgaySuDYHAdK+jyoyRPgmNWyCcB3MdsbyOYcdEiUQWBlCqYC4pFNwOerfDlClp1Q9B7w64Nsi9flMF5bgkDBWiUpHKtWfw0ghDh+ZAo9ZRUaZSBnoRP/sA5lPvIKsUiGcugSVAGcGhHWQlZb3lYE0OWNpYQH3xx5iI5kl0n872Jhw8iflECc2sYkwllGsx/QvTUK2QqCfg0jtR+x5R0Sc77MPkiPRN58nOP4+69p04vbvpXxBwOssPB/QMlCajumCv/iL1YIXtI5twfQqWLUjuINyfcc1+kr1LA+puxOn9f8GzhUm2Wv8zDOZASfI6+DCC0gCUs+CU4doScuk67aiA2jJwtrfZnNUptQTFjmRwkwW2BiIGez+kTSg4SKHg8SS4T8LMLXDwNtBvho1zLI4uU+nm5wWVvWAFYBXB3VAJtnXmooCZDUgYkbY1Zo+njKxzVEtDWlcFFVehcEeH6ycz1M8Lhlck3gKkXfizPSAmoeFDOtAoeBp1CcVMMO1kbAevfj2NM8CvH81mE1VV2dra+rL7t7a2mJ6e/orPmZ6efk3jAfbv30+z2eTy5ctfMQA2TXMskjVmzOvIOAM85vWkUTT5u7cv8HtfvM5HHro6DoDHvKF5wwbAojgk7jdZHPaJD8YEyxHxepFgsoN2bJV0AOZLcNO6ZN6HUQhWT6EwmZE2QJ+GYb0O+hyMXIS8SPP60zSDEBNJZRmMq7BpeKTxkJHYYDL2SDyBqJVg8gS4j1FwRwgVBjYEEbSMDGX0LNnEFizfSbpwBbH6H7HVmO0iFIfn6Bx9N2f1SQp6F3OYIg1wqUK9gNheQxpnmDSukJqSYpBxrQFYXcKggG1180xvnIBlgH0QxV2nKV5kI5lBGnUIy6Syx06mMl8KuT6xj7DxfvjLbSiNQOqwbCH3wVAaiOESFbeF1gfNgORohK6AbyssXbqX+f4HGeohvZMr0BjCdA0Cge3+X4S6gXY8Yv3sIeIX/x57wwUuLz7IcPpFSv4FPO023NsXoBAhalMs9xpko5sQ5y2cjcOY7TKu8AkPJDDTAzPE7Pwl2Gt4By3s5++A9gHIOij+dUZWDcJ5/Ll7eCbbgyxF8KQN4bMw3UdZnSMrKwzP2USXhmxLQWhIqJ6Gl94FjMAwc0snX0ChA3EK/nFwz8DkAC6DYw/INDDKCca2JJ4Db3YfqIfBdYAYoksgqpBKGAa5t9b89+Vl6IGPeu3PiTSXqy0FdUNSfZdEpMAaFC5pOPMR1RSSZ1QGg30klRam7hKUe3jLEsMtIhQNf8olTSFpCRaaksbnYMOGqwvQPQAWYP5UhP77GTMMuc2Q7KwA3Ve/njzgaxVTeV/nOh0DhmFw22238cADD/C+970PgCzLeOCBB/iZn/mZr/icu+66iwceeIB/+A//4cv3ffrTn+auu+76qq+zurpKu91mZmbcGzZmzI3glfbRL40ZM+br5Sfu3c8fPH6dhy/ucHZ9wPHZ8o2e0pgxN4S/ESrQr8Xf8nd+53e49957qdVq1Go17rvvvlf0w/xK7CuDMzOiuCWZbMPMtE+ojwgHubKylkHRggOA3A8bd4P2oxmVH4Gt74UX7xaMmlN5P2ggkT2dQjvEuS4xzkPliyAqMH1LglHdwpKgSYOhrxHFOjCFmvgc2gkxEugZEFcgrgr2bZ3BWP80qGVYeQeb9hzehEX/yM30LQXOPoA412OQ1FlRTIwORIoO19rIWAEtpG9JkhGsOgVGC7eD7pIZdVLXRA08yGLwA1AnSZt3s1a/iax8U672lRbwKqcRGayU385O9R/ARQ0R/j6l/r9BNf4E9q2jb3eJgv2IwKBXhKuqQcdW+ELrFM9feicXn/lurM6PQGIwmt+CbAOcIH+NoU7qZcjykP5gAvf83+NYsMhq5RL+woOowUsYqkdx6RlQVuHqBPLqj5N1fxj2vxWjfZxGawpNJui6BvsH0DwHyuexjC0aSoKWXSdSlxEbe+HigMb6E5RXejBch84iafbdZMsfgLaDZn2OWeM/oR78Y5ToCaa9Fv26ZDSfcS2pES7fBx0bAhV8B1DBL8BWF+xFKExD6d0wezvMVNHtiI4p0DyJ0QVHQnlrG1qbcD2AnW3oPgL9l2DzcRicgflSnh0ODRi2SeMW1ycatN5d5fKbBWtl6ByB7UPgzMTUj2QsSfBXVTTporoKmQtiURIEgoGf0gltzL+sUP1EgY2dGmuPzyA+JzjwFMyfB9k22AhNuguC4x9MOHinRD0K1dd4MDxWLn19+dCHPsTv/M7v8NGPfpRz587x0z/907iuy4/92I8B8MM//MNfJpL1sz/7s3zyk5/kX/yLf8H58+f5lV/5FZ566qmXA+bRaMTP/dzP8cUvfpGlpSUeeOABvvu7v5uDBw/ynve854a8xzFj3uiMVaDHvN4sNpyXBbB+++ErN3g2Y8bcOG54Bvi1+ls++OCD/OAP/iB33303lmXxm7/5m7z73e/mpZdeYm5u7lW/br0J5vEAOQ/hkzCTZHkdctsgmYyQZ4t0FJf6ouTFI/DsYhFd01CcGonTI7QcGPTAexZtZwt7mFHfkKgW6DtwLYNSA/ynBbgSdW6E39ORMymyUYFuCaM9pH4N3BE4R6FnQ1aTzA0ThP8nXG7cDP7tDOzbiMufQVYmSbdXAQ9tJ8TqbOMfz7imQ7QTg+ZBNUEoQ9ISrBf2kk4uQlmFTh8CSeRZSLsM/QFi+Bhysgjrc7D/HrCeBmMiz2pLl6SQAidQHvwU+uBpxKiDrGTI6QjsiECdhFIdsh0CT6FspKxop3B2fgoRT1ChSIMKm1pK0gigegWmTBhGUNwmSo8CQ/Tnb2Zvew8X9BE7JQNjGKGnIREZft1GBH9J2R8QbtxGsHELlPqEjTJyC4ppHTMUBGddksY+kCFBzSYpGqTbt1LPagyCgNhdYGfiDvTsGcS+GHllmIt/KS+iVZ+m4l/FFxKluEo6l7FSuxkzPMe2V2dkvR2uHQbh5srOSgKxgIIA1wP/GhRvBz2BqIY2EWHtSAqmpOuAMQlaH/a2NhnUHyNp1kBtQ7UNgy2IhjAy4OAJID9QQUioaGTGPGgBo4kuj1UrmHrCYt1FbWbMFmGlA6WCpBBI1Fhl+KSCmRlwJCBd8om7EdIr0vCahNUhxaRAcL6BcbFH84zBqedTOm+LGMzm4t+jITQPgeoCr+FcKQL0V3h8zNfP93//97Ozs8Mv/dIvsbm5yc0338wnP/nJl4WulpeXUZT/fp55991387GPfYxf/MVf5Bd+4Rc4dOgQH//4x1/2AFZVlRdeeIGPfvSj9Ho9Zmdnefe7382v/uqvjsucx4y5QbzSPvqlMWPG/HX4qbcd4M9e2ODPXtjg//3uIyzUnRs9pTFjvunc8AD4/9/fEuAjH/kIn/jEJ/jd3/1d/vE//sd/Zfwf/MEffNn3//bf/lv+5E/+hAceeIAf/uEfftWv27+qsVBLyCZAPQ2jK6AXEgZXofS0jhEZrJ5XGayHqDMBC9sehYHC+e+cITHvgt5liK8jFA0jCDjaSol1uCxgehbCA7BhCdSHVKqNjP5pDV/PMByNdM9B8FUMX8H2YDmDaA2mMgiK0O2ANblFuff/ZaD9MnHvu1BLZ1l87LP0NUF/360o8SUWnu+xvl9jY7GGvJ5iF3xQBL5m4tUUUn0fOAcgHEArQvUvk07MQ20/yuoS01custMfEe//fmgXQdwEzZtBX4NYUrh0Fb33ArobYJoSY0qwlR0k896GceVhmF4j2nsIAgONK3iNWcTyD1CN95DhM01KSpvUiWHvWTA64J2G5AlwL8N2E5GWmb96G5IMLbHQ0hqR831k4QOkFQvZ3g8NH6k+woT6adaPP0tq3wZXiqjyfRTRWBcSVgRcrMGBMuHCnYQkKJsnyHRJcspHrFdg9XaiEwLSI3nP9uxVaD+Kur2M6qTU98GgEqNNrrMlJxhFx+Gx+1Av3IJ0p8jMCEQJ0kEughXFkCZUzj7I6HhAKioYreeZ7G5SjySaCi0f5CR4KggLpPCg6kEADE9DsgHGMjSLeV39qAZ2DHodmreAvwPSI7Ft4ubNRGqRq1tPMJxocdYRyCRjupnSHUZEto91IiO5IFFCqJ+A4FxGfyumLQZY1Yy9J67QflqnOpeiXSijP3gLxcf6KKVlZvatstaCrauQrr62dewCX8tZcFy299fnZ37mZ75qyfODDz74V+77wAc+wAc+8IGvON62bT71qU99I6c35puEjYEAMhIUdEAgCQEdiUqCDwgECvLlVamQIne/z27U1Me8Aq+0j8J4Lx3z1+fkXIV7DzX5/KUW/+6Ra/zKd5240VMaM+abzg0NgL8ef8v/Ec/ziOOYer3+FR//at6Vqa1RWUhII/Bi8FowsQETi9CvxLQvavQTi2zQJHluGdOK6axmFGbWGNwLhdESgauRzNegss321dw2yS8VubC4iAiGJMUDzN7yFD4RvbfsQZE7uEYZ5u+BsxPY6xmxB2vCQVEzZnsBdh/6GRg9aCxcJhC/ShT/rwTl/wfdg/8HqeHCoXcQlA8gen9Elh4Gfx/l4V8QV1JEaoFZJM46MLgAvQ2o74NZldQ7CvuOAwlS1JFXdYr9Ft3BDjxfhmAFJkw4tgNpguiqGOsJ6RQMJicYHrgbWTmCduEZjqVf4OLkUZTrt6E9tol3NATnXgqXD1Eh/8NSsUjpsHNiDVU+iPRdMl/A9Weh24S5Gvolm0o8TYbOfpniZSv0j5dI9HfDCxLCIor3x7i2xaB4c96DbJYR6kkcSlRwWBEtEk1Atg7CgZ33wuRnyY6dpyvmc2XrZhuyIrhDGLSgHICfgm8TT+jU51KqRcG1YJZqfwfbucLo/AcpXXwLSaoSE5IJCVoAmQLWJhQjxOwm5faI9PJncSdM7DgiKWd0HNAkWAqUJVydV+kaDdJqCQbPgGVBfCtke3IhLY389KNlQFGB+iRU3gLVy7D8HPHczVC6FapT+LVjLA8/DdLidHSGfUUXf2abQt8gWNFRaiFxN29b3nQkg0cSBoNZ4usmS91V9tgR1h0RbqnD5oPXMbINKmqENgkNAeGTOte8DEhf/Vrma28m46zFmDF/fQRQpoBCRoyPQRGBQkpChoPExCMEFBQMUhIAFHQCMlJS5Hg1/o3llfbRL40ZM+avy0++9QCfv9TiPz+5zD945yHqBeNGT2nMmG8qNzQA/nr8Lf9H/tE/+kfMzs5y3333fcXHv5p3ZbdV5ekzm8w6MHEHTNahPwHXFsF6SiVLS8S4eEQU2ilqCIarYJ8fkNw8ZNKVqGsR3dSnuS1pC1AyyNBIZ+agUAHjrWzI28H5AvS6GOc84sYUzFQhrdFN5oni55gPUy7t3cv1tE23MUN0dYnZ0pC+KskKHsgYLtzN0PllmFyDUUxWvoeLxwYk5hGEGWGaCr4OqUxQhhukUwfzT8phBP0GVBZgaglGFog+sryH7dMOjngM0Q+ZujpHe8oi3nwGmi9CvIhbPInY/zjugXmy4ttg+a0QP4iqPcGKViR+7m5OXDhAFtc4PxEhrznUBgoqBcoorGsea5UdoukBStZGFNqYz6wTJgcgm4K+yeT5Y1RlDQMfBZWsNgLRgk4RahXIushQR2wFULyCeuUejMG7mGxPM5EVkAzwFx4Fw6Tw1Cxc0Qg1k6Q+CQvbsPcSnC1CJYTaeZT182RWDE0VtDqIKXT7IjYS6QhQR7QVA7n87Zgv3oeV2sToREJCAiQJHF2C+XPABlJbYrU2gSwJMCV9q4I3XKaQ+ZSyPPi9VtBpZ4tkhp5ndMMWhFUo7uz+eyuoF8FbhvgYdC3QNagcgMoULDbAykDMgyqg0ADDB3fESq3N0wcv0x0JkuU9aD2fg6rLhhrQfdJHrcBMKaIYL9Hxq2T9/ezEPn71PMHRCPGFgH6q01NHiHvB2IaXzklKtRTar34tj22Qxoz5xlCggIoAAmIyJGBikiFJkSSogCBBR6CgoKEygY6GQBBSRuzeG5IAEhUFC4kAbCqMiPFEQkEaQIIkQKLthsevxQBtzDeSsQ3SmG8W9xxscHKuzJm1Af/xsSX+4X2Hb/SUxoz5pnLDS6D/OvzGb/wG//k//2cefPBBLMv6imO+qndl6rN61mRohjx+HhbLYN8Jz03DgZokMyTFEKTqUytAfAQ25wXuoSlC3STQV2giMbqSupd/aLUbwHAA167BwjEoXUfuvwdaMcaVf4vzUoQ+u87WooRAI6y/lzO1MxxvL9F6UWXzHd+FCLexLl9kKwIShXTnHvCOQNSFpAZ9HeJN6Jsk9rdDo4TMRnQW72R68AV6qoKXzYK8DeIBKB04OwFzLtQTUM6DpyK6G6T9t+KKdZTCCm9Pb+Fav8/je1oYskMY1JHJ3QyPHYFqBdZrsAXssQnnGoS9O1EulFnTPkM9OMWtz7yNVQycrIpGi2XnDNf2t5HGXrCXyRo1lJ2YRNXAOAKRgzIasiecooECWCyzhpdEsFIBzYK9fdATZHyStHEY7WqdIxffzETWxCRCR2NN6xPefB5l6QATwZsQrRbbToeksQcM0JX/QnJiAbn2NlgPyPoaRucCUlkm0aawjU38tsmVaoLSBq06JAlPYZx5C5PDJiExChmK4yG0BApbyOn/mpcM6KtgSaRh5d5YUgV2SIsZQs/bg7uWwcg5AgSgD0GZAa8L6RDcGOZPgDwBm1VoXITkLIT3wjAEaebVipV7QE1AjUBmYMT5c3iazvQ+Hs3WOLDjE13vEQcWm6lDK63QvdRi8sCI+iGILmVMrDkkWOjONoercH0LEnuV/kjB9SSbfahcAeKUUmoCIa+WCFBf4fExY8Z8OYJciTJFIJCogIbcDYA1xG7RsoGGRJAhELsf2xoKGiYKKqAgAEGGio6KgoaGJC+pzcNkgYDdxwQ6Chr6bjm1QoKOgkQl3X2WRCDISMnGZdPfFF5pH/3SmDFj/roIIfiptx3gZz72LB99dIm//9b9OMbf6pBgzJjXxA39a/96/C2/xD//5/+c3/iN3+Azn/kMN91001cd91W9K80A1XdgJuSIBWkMjafg7kv5RcTo266in1MoLWaUvg2ea5ZpH70NkilE7yWC0QqeDRMZFGReLFr2QGtnVNpXCS+uEE0+Q7D3JawrG0xf8WivQlCoQK+WZ3WV02zX/x5a8NucPrfC5f/WJa31SZoh7jxk9j7k+tuhF4O9AUcE6BGMetCdhW3yPtT6FOnhH6JzJcQYPQ+ZhnrmUdK0RDFbQtt7ll5xP8R1MIqgNKi2ziPDz9FL9qGcD3lR7nBgqKEFGmqowkQ1z05uzYPvw5yAtgsvLML0m8As0Jj8GGHFY6XtcnzrB0lwuCI8doqfoXfkRaRnw/QSlEewcJRsdA+kHdgow4TJxCXJQroHC0mKoCRsKBhgbIA1C14EZgnt3H7m1xwOeE3MzAJCrup9MqfLTukiUr2MrG2yfDpCHleQDYFod9DDB8h2AmRlHebbcHEeRZbRTRex0aeSDShpcF1M4PsJynRInE2jPXU/k5szCDwEggBBkklENCI7dhHogCqhdAD2zIL3NCIKkEkMmor0FSINkgokRQNEE9JRbj0VbORy314AgwEol2BxBtQ6RA2wrkB5Bry9kFpgVSHSQKZgxrk6VZAADtSPwNY2q5ZNfCjggLHDZEulsglsVonskMSDqb1QqGS8sO2jxCZKZpMZUHRVYr/AHB6BqVJVEnoCDp2WiIs6eK8+APb42p2Fr8FSeMyYNwwGAhOFEQo6GQWRosqAPAx2MFB2g2GBiomGiYtERcXBxERFAgPS3SxugoOGioaOgY0kb2ZQ0XZzwENGqOgUpY66WyINKvFuD7GFjUKKQoaKho+Lj3vDfkdvJF5pH4XxXjrmG8f9J6ZZrDssdzz+6KlVfuTuvTd6SmPGfNO4oQHw1+NvCfDP/tk/45/+03/Kpz71KW6//fav67WbQQlzoY97D2zsBTGESx4cf0AQLBfxyhYL9+xw7madbtVmc/Y0VO+A5RWqq8vUhhJhQBjnSTmRgr4CxYuwsD9jOApx/DX62xssxhmiBG0TlrounrcE6l5QPeT8O1hLyrir/4mme5FF2yedAL9Uou99D3j7ofYsxcYf4Fdi0mgaXY5IxH3IwduhsgJbLmyG+I3vIeoZ7G8/RppkbFbLKLFPppiABG0C0hCSgFgTlNXr9D0Htb2X9WzEQWnQ6DhsntgLJQ00DQYSTgP7M1hK0M/pxHtNhPg8YXcLv18grY3YFi7z0mRZnCErfZzieodgVidOT8KSlgdtz91C4aUCkeWRGC9xonWYBg4xHio6mizTXIetox54S9CtILZqHLk6w1viCYZ4eIzYULtcuec68cIFlN4z4HcgVMnm+zC8B9oZRuPTKHZGZN8B3lnwH4ZTJ8m23oq7to3a+yIzxRG91Ia6Ri2NGRqTZK1vZ37tFKVMYUSIjUFIjJn06bzpczB1GZwjYC7Ckgq1FCrLGOlVFBKSMAFL4CUG6AoyMMHM+5YJfIgSiHZlTIYuWCF0V2EygbgEcg+Uu5A4EFXBV0ApAAYkMRQLQARChaQMzhQylnQmQDdhcKukuwPKS23qbahYoFYg0aBU8ml3UqLARy5BbWBCfBtdzjIxtYlhQjwDew+AfWDEJz726tdTxNf2VBtnLcaMyTHIP3g1dNgVpbJ2A1xFGii7MkgZMt8X0ciIUFFQ0ZEEqOiUKGEQkZISkKFioWATk5FnhDUcTCSSAEhRdrv6ywhiBCkqBgqgInFJyZBkZGQouzNI8pJrYWNKyEiJx6v5deOV9tEvjRkz5huBpir8xFv38//5+Bl+5/NX+eCdi2jq3wh31DFjXndueL3Dhz70IX7kR36E22+/nTvuuIPf+q3f+iv+lnNzc/z6r/86AL/5m7/JL/3SL/Gxj32MvXv3srm5CUCxWKRYLL7q120pEVuhYE6Bp++A0bIgO6izcUfGvt+LSTcKrNwMZ+7ZQxpZQA12OhjXnmbPhT7lAJamoOyAE0FxlCfqNk/mwfCiAYYJppbRBTZbCoYlMRlA+CxUJ6E0CVsZLL6Znn4LvewsK1c+x2L2EKavQnAXRAZF9S+4ufYCTyolzOwKe2RI6JxjqemTXXo7GF+E7M9gOEE6eR/btFmMzzPJgNXyHJl1CrwqdD1QtsCZwddS9H6G0DPiUz26lxI+LS3KvTqi+w6kpcP1BhwFJkNYF2CFxHf2YP+zyPWMoGiilDLijs5lPWZDbzFcfIi5pMW2VieR06gtjYb6It66wiidJ2geJ5M7KK2IQloHXFRAxyDB4PbtgzzycEL/iAtqAa1jUo41PPqkmJh4XJnaRkw8w8JzD1OrBaytFxltVhCmT3BkDThKePZe2DMN0zuwPUK0h8ijOgzugLW7UReuk9mXMaOAkrFFa+IwmX0Hzrl9zMdNuujYBMSk1JWE1Vuehb0PwKgE9iRcF+iPzxA3OjBhECY6Wi9DlxmEUNJjRiWdKI5BaYGoocQ9ROqTVk9AsAXZEFQNvGvgKZCokHnQbeSZfuZywa0gySWkDQ0GXq6spZpgJWDfAvoLWO5TuEJhtfwWlOqIU8EzzNUk0SXodcGYAjmT0OhohGbEoA/GPo9k5gJszCCG2+jDjGoVei5sv0ap0XEAPGbMV0eIvNwZmX/oGijoqKRkpIC+W6SsYKMiEUgyEjT0XaXnbDcY1tFJ0NEw0NGRaAgc5G45tEaCeLmA2cZE7oa1ee+o2A27AyBE7BZGKygIfAQpkJHtKkZnpLuvoO6GzwJBsluY/Up6xWNeK+MAeMw3mw/cNs9vffoiq12fT7y4wXff/OrtRMeM+dvMDQ+AX6u/5Yc//GGiKOL973//l/2cX/7lX+ZXfuVXXvXrbiuSrR2d4ScjKiOompLAS9l4UxHlfxvQEwHmpo7odmHyNPgV2HkRc30Dcx1IwDIgDCD2oGTC+YMlAlVhuNnnqgvTCVSUvHV2zdbJ6oJyK0I9t0V6eBNsA+oNiFNoSpD3EOpv5pL2HcBLEJYgusDE1NNcEzpRqiB9hctzJvZ6ij71+4RBAZIdzPAiUl4g6lkMZ+/nmptAcZmsPwvyAMhr0ChCdy9IFzmymOmC5mywMwPSLxP29jLR20P22FG29l2D2QiODGHDho0+GD1U4xnM5y+iByHhUYtw+B5I3kxrtkVLTzE6R1jtlYlvU1E655h1n6Q2DLmsTUOYkE3/V5RgCYZvJxMqQvaBAqBRQGM/U7Be4ny/jaupFF3B3t0yvhHbnHG28We/wO2Dh/BmYvqehpEl6GGCFCGGfJjoJhX8t8M5C/wSpRDq633W9S7xTRVYzojm3sG1hkVBXiEOLTKjBs+Xqa0fRCXFwCQmxcFgvbxEdOg8VmsN6Smozgr+RorlL5Bei8j2uCheRqIXSCKJyCRi5GNkEbGpI40ByB1EIhGjAizcDDvPQmUEZhMmJvJSAu9pSFWozEJSBy6C8WYwbLCrEKQgMnBDsH2Ia3mJ9PRNjMQq+GVkuYa9uoK1KQlVcCYhVED6YO0LiFafonK3h7qsk7U1eidXSXYmMVar1B9q0flOiE1QX50G3cvEfO0Lt7Fwy5g3MgU775qQfi5PBQoeGSYmDhYZ6a5slUYBAw0dDYdwV99Zp4iNhYNFgwlSEkI8BA1MLI6hIzAQ6FQxiYhwCUgISZGEqCToJIBHgMsId3dEjCREYr0c9gpCElIyrN1wWUqJRw8FHROHCH83pB6HY99IXmkf/dKYMWO+UVi6yo/evZd/8emLfOShq3zX6VmEEDd6WmPGvO7c8AAYXpu/5dLS0jfkNe26S7MjiBMorEDlJKyIlDS0WHPmkNPHCSrX0PwNkqkTcDmEfoviUyP8SyCq4BQAHUYmtIsm3SOHUc5dJgyhvgX+BNjAhAebrkT2UqyOpNj+LP3t8wzf+v+EYgaNFvhWrnzsN+D6cTDq4PhoU58gmx2w6c0gwxjRGxCHJWJtDpQBInkYLt1FeY+DKjp4pQcZpOA1/w70LlLtfoGktUyIR1x5BwQOVB2kndDSFaazLqEHg9veh/bszSgrJnqY5l5MR9qQXIOOBP9pmDiAs/08pVUPeVDFj45x8vP34cXTDMtdjNhmfjTPmb1PoAefYKZ3nnVfY6M+SzJ4L/QzDB5HD3xGB/pc7vWYH5lkgLrb+eRQ5BQFDro1PFQCUjQCltnipVLMzuFznJx4hLVKhdULp0g7GegSDjZhnwu9p2DnIhydQUSnUM9NEJVnCewRqVmDlp7bPNUdsvJdDPUpuKSDuR+lPUEhdUgpomDsFj/HDGY2obeK2IkplCTTWcC14hNk6j2QJpij60jPIHImYOQiVYlnCIQfoiQRmSOQaou01oD+HeAfh/kMtgZQ0PMG9N5ziKSDLB0AtwexDtmLkPagMQNZATIBo3WE2wZ7hDQPQfNtYNxCNqFB6zpm90WOdJfIrsFoBPpB6NWhrkK1DursEG1H4J3ZS0FkdPdcwyv2iHu3sH3+HM1ja3SkZPQaFKABRnztC7NX3008Zsy3BsbLoYxAizMUlN17c8EqE4nYVXS2MVEx0ChgkaGhYWDs2h2BQYECNgVsGtRJSOjQJ6GMikH2siK0gkRHkiAIUUgRKKjY+EgkCdDFpogJBLgE+IwYkWEjSBGESHQSMiI1RGQgpAQcsl33YYHc7VrWdp+TvZxjHvP180r7KIz30jHfeH7orj18+KErnNsY8PClFm87PHGjpzRmzOvO34gA+EZgT2eslKF4ENQj0J2HzVoNqTbAngFhkSzcS9LP8l7MwjbCV2BD0NkukrZCHDNGm4BNHda0AmwbWLFLXFIo1TM6NrgKmBqIUgKrkp0JEznXQC/70D4Pahmx8YeU0kuMCjeRnZ6H+Dg0jkB/iLX+LG4Glc4maVfgWxnUQiKgvD3ANp5hq3CKVvcHsPb9X8wvbxDbj+CXZ2DQYDZw2VwdEE8LGA1AL0JnE2mXaBke9fIAbb3IwjOznHAbdAgZijaiGCEbg9wrN7kMqoLoXyaLXIYNQXT4CNnF72LGn2RCVlDaVVYIOT/zKKODf0Ghs8JI6IRTDlnhGKQOZG1CY46QGEyF6zMuL15OUeWQCVL2UEPHICDa7TQLECic00JeqMfIhU+wV3yWVUenM/wOnHMTeFOfwGkvE0zXSdMmVCZAFKC/jJxfICldJLH3sLUtoDkP2z5Mt0FuIFZShLlBxi1wTYedCiMke1HxCTEJ2bE3iRdWob1CAgQZmClUGyNazhDhpogwJE2BwIVBCk0LYoEiI4pJhDqK6TYLSHUG4v15+XLtGEQSNv4UMomaBajhiNjchkhHZgMI2xBFoLTzAwlpU2k9R1EJUAqSnvUSbtAmm/gOUA6iDJ9iz7WrpJ6kdxpCCaUy+BKG50DvgWLD6LkynUiQCRNHFThvX2b9Lx0aw6PEX9xh4kCI13tt6ylmt8Tzazw+ZswbBUEe6opdnWctTnbVmk0U8iyfvWtplKBgYaJjY1BCI0BDwcREADoqFnUKFChRYJYFIlKgwxCTFI0YDQWJspvtjUlJSXYVoA1UyoSEQEBGjEURA5uAHiN6BEhSTCBFo7er+pzhqjKfb8rLcloJKRrKbtCrIYhRSHaLucel0X8dXmkf/dKYMWO+kVQdgx940yK/+4Vr/PZDV8YB8Jg3BG/YAJh1uO1WKDby6t4tE4pxhr93NwhORN53WalBoEHSQsY+Q12lwRQtuUpjCyY6oOwBkbloG2dR2yles8aliT5JTaK2YU+cobsZwgJnPSaMh7h3vRWyd4J7HevcC6h6l3pji8BSCGb2kNR+CJJTeLN7CNhirh1SViTLXbDsgEFpCb2d0LyasjPzFFx5P1FymijpkBTmQTZB22ElKKE0u6gFAf0OzFdyCx6tQzZRYMkJKb44yYHhJCYqHaExWBTIBQntdVCXdxWrR2gtn72O5MriLKF1B9BkQw2YTQKeFSPOTy8R3vKX0PNwnbfhdmahcg30DdTyJVQVInM/FEpQUAkObfPkKEYdqRi6yc3dmIOySBmDiIQKKY8YHV48sopq/Rf2WM/T9hzacg+sC9zFFjRb+EXIdA/SS2CegCSEQheiFSi/AD0B5QDCyyj160iRIv1pJnsvoE36rM2dgE6BUlhkliImGiUiAhR6zRY4K9AKSbDIgpDBZkZYk8iJLvbmCWJ3ElXZJPEM0CSIMqgjUqoEsoUVZGiKJN6ZhXUHFq38qF8poq15pJWA1ChCe4353nWyTGNrsokRDkikSzTUQO+gxDHzWx6OmVdMo4So859nmErS4CRZlLBS1mnGEVMuFAX0OjDhg1OGQRvMDHrSoGOtoSU28oyFequP8j1nWFo+z8JTCnZHo1hKXmEBfTmvVAg5LpQc861OHqyCgZ578CohutSwpIZCZdeLN93t0c3NjGpUKFCiQ0iZCvPMEyIBFR2TgAIRJi42Ljo+OstoZOikzJHtWh1leLsZYw2PbNfOCEw01F1NaJfCbllzAVCJUOhRJGYKnT3oRKSE+HRwCYmIUCP3ZVkslC5ChqgyfLlLWKAhdZVETRBBFSkiEB5kPq+sZzzmf+TV7JPjvXTM68H/cu8+/uNjSzx6pc0Lqz1OzpZv9JTGjHldecMGwFLPLXIrR6Dlwc0KaE/3eUp9kfMnWiiqTWpMguKCMgvFCWgcQJ/fpLM0wEoVQgl40B/AVBLSi0NGkQJBRmQJZFgjslJ2Zvp4PQVNS7E3oYjA9d8Gsok6+nP2XeyztM/EqMUEXhFbrJEEH8O3P0TWuIus1yFwLjA9TCg54LognYQeU9TsdXAE2dtfAnWC6+3vgVERlupgSIaz3w76BShosEcHR4edDJwmKAfJskdQRYVJGmgolPCRjgcND0YrCP8MsrgHKgfQlp9kx6oQ6HfkvsSHBqw9obFebNNRY+ThL2D0nyXiKIgZiPdBuIawr+AEPo4JbXsbGhZpfQFZSYiTC8RDg0DaPNLp83QAizszBLHHsDakN/MsSukR1HLI5coiqSxA4WhuEZTUgSNk+gUw6+CY0CyB1YBLFUDH2dkkCGtkhgNeh+bUFkFQYKCUEAxxRwKyEVrH4VhSoYJKCUlKwDW6+Hqw6++bInUbXcZkZLheQjy3SW3pLbR3pjCqK/mBiRqCUgK1BEmfMAmptIfsXdrhQuEBAlOFdg2mYrCWKBATd6/jNScgE5hexqwbM5VtMIhhZTKFeBst9NEGCfPAQIFhFwoKjJwQq/w4rhmDMSAMMrarOkNVsngpobiT63aNFsCu5W3n5YJP39VJM52dS3Wi5TbBB3rsfBAqw4jKcxP0ujHQfdXryeVrX5iNsxZjvpX5khOv9rLHLmTS2A0/9Zcfs1B287KCMhVsLEwMZqhiUAQK6Jgk6AwxCDGJMBjh7GaLVXxFR+bOSJCaIAWZaqAqoAgIhIHIJKpM0UVecK1mKmEmyaTEUoqI3Tz0SBikpKTECCUgFRGhapBIl0yGKMJByhRI8lumIuMMqeTCWiJLkULNU9qKQJEqQuY/8+XnjHnVvNI+CuO9dMzrw2zV5rtunuVPn1njww9e5ofevIer6232z8Kd+5uoyrgveMy3Fm/YADho5SqZrXWJ7MHmDPh3w6GVATv6iKlYcmmoER15FxQTcObh9PsJLy3TWFpCaYFahtYOqA6oCRR8SLQMvd0nahaJ9h3CvvoCbatMetwi6SZoVhd3YwY4CPoEottHliWaTOj1NWgauEmBon8Ff+6/QvEWiCuMyir6ZsI+By6GYJZSdpQmV6t1pNyESgxxGZ0+CSVkowwrs6jxAoZ3K8GREXLYBysGwwWzAqMhEQVidQ8KLgpFXDUGJYA0gQULeakEwgBtD/5cjB/NwtZxKD8OL/ToHElgPoD2AJwWyaaFUmmT+SWYSKGQITKHfXWfoAvtFUnF6DF0AqJyAk0NCi3oqWT7L+AqKecKc7BWh2ofistgN4mcOZAhbNuwFcBMG+2ZKWT8dtL9McTbUDgMwxLKs1MY16cJ60tM20O2hwmBomNUBwzCFNUfguyyUy6geCNgm9qGyawsEeOSkBLvytJkWh0SEHaC8AMKSsK6ZxObAZTOkWgB4vI+wkPPQ60AThEyDeIIdInAwNnMEAk45U2CxjoMLPASmCwynDqM0zmDooTYtqQS5oJVcQpVFdoDiTSG1FyY8aHnw7IFJQG6DmFbw5uq51nn8kH01iZSjbEMSZH8bzNYVTBXFLITCb3D4BwdUfvDAq1exjpgpgXC7QHpZZUsjRkqKdfEaytjjPjahY/ji7Yx38oYu4GvQEVDopJiy/LLfbkaKSaCIkUSAlRUZlgkJSIj4ShH8NBZQ2LRJMVkFZ0AiBEEVHDJC0fQCqBmoAXglyAzwBCg90EPQExBkkDig57midhI5J7xmczbYHaFuFAkkIISgxaCmoI1AekAsoBMjSCLIYsglchoQBqn+TiRIiOPL4X/UolRM9AzkwAVSQgMb9D/yN9OXmkfhfFeOub14yffeoA/fWaNvzizxV+c2dq99wrzNZtf/M5j3H9y5obOb8yYbyRv2AC4YkNrw4I/S8ky6DVilu4u8J72iMopjbXAQfEvws4xKM2ALcGZw7/tnXgX/gOVMMYugqaA5oI3gIIAR4WekIw8n2hjmdgqkZVSKAO2SYROpoSQhTAqkUSHGGgm9SBkWKojU4PMKTKiBd5FRNICN8Pfc4R1LrNHxMwkCWovpeP2SEtFprNlPLdFP55monWNjqET2CHV4d9lb2svBiWuBzts3boGdgxVE4IO9FxU7xoRARYqKhGusgrpMixHUIrAOAaleXCb4EyDa0IrAWUKdkZwoAXtuVzIyfPIGodgYQpcDa4koBwhE2U2xOdRKy3qkzFKDEIPMMVlQnEYlDtgLgZakNmg7cChdZAlSCsgT+Yeuq01iFKIu1CaJbn1Oso5BzZvgZ0ObBahGqAMq+zv19kMO1xv3kQmN5gprYOUuDG4SgXmFkhDBVkyMJ4+zv7+PlQSBBoRKlVs6orHummi+n2UgoIiHaqqT8eZpmmt0m3YBPM9Kqtvpj3/XC5mXTAgCkB6kBqIIKMvVTYmFwnVkzB6C6QG6DEoDtniJH5YpDTqUbDzswdfg7YDjgG1GGo7UMlgIYJVmf/oALBDKOgpfhwi1SbUFgj36FjrjxH7A9Z6BnNxhG6DLgTD/RBfF7ChUZAuTVJmCj69d3qcvzlj6osp1gBaQiHJXtvW8EoXZeOLtjHfinypR1fbNTHS0dGwUDEx0WHXkkgFbJTdztsSFjYVmkg0MhSukxLi4DPBFSYYotLGRdZMsqJOVlNJSyYUTfBSSAVQyL3aM6AfgGWBaeX+e8MMOinM1/KTsoS8NYQULHJ/8VAAcf4mhJMHwQZQ1cArQxjmOgVxnB/oJdMQdGG4DEEP0gAsD1IPohBkhpBqfhSg+ICKnhWI6e4Gw2NeiVezT4730jGvF9dao5e/ftfxSX7xnQu0Yp0PP3SVn/6DZ/jwB28dB8FjvmV4wwbAo72gLvvEcyDWVcptgaJmBE+CM5uxctggqqTQuwjyNFCDxEXuu5tg719Qu7JK5ENfByzQh7ldqyGhVTFJVQ2l7ZJMH4TZE5BtIZQvUusHkLbZEttABBOLBMMSfiFDzkzntdluQKbY0Aso6S+hd0q023+Xqyt3sjQSaP4KyjueJXJmKK1dxHIzpOEynHDZnC8j3QbC2Mfh1GE/FXpkqMNpxNMmm+UXoFyDDZfipYcoF7fphAk+LgkaIg1g0oCpZRg0Ie5BrwyKDjIBJ4OFdai8BPUEqMLWHuiHkO5B6R2CXpFsOoLDMUxIyKbYCd4Jg2XQ18BK0codhJ+ArcBgGsRWnsW0ARlBUgLbgqIGcQIyANWAgoTrU7nCU+MLZCdnoLUXsh6kT4EwSU4GXDEG1M7v49T197NlPMSEscamBK+oklQXQGlCsYxYqnLyyt0sSguVFJWYkJQIGEgB7RBZF2SKTlxZZDloAD5FP2GoLhPMn6N57TuIr7yPwfRDEK3nfr6KAKGgZgGjW6aI9R+CM7OwXczLy0nBG0I2RKgSEULPUJhRM0IDtgtlKkrIXBriCHAC0GIINQgjqBm5K1KtJOlFkjgDtDJUbyXQRoTyBXrvsGn+yQaHmhnmmzJGNej8eYXhTpFycRXHjNBTi1BXSHUNdzVl2UsxGiPmtma4+hrW0zgDPOaNhUAgURG7ty8VO6sv2xnlhc/5oyZgoVHEoUgRAwcFG4mNxKRHQoRJgkVHOAxVDc/KoGrkpSDTCtRMqFp5sJsAUgFDzRdeW8s/fAwBRR16MWgqTJm5f7iU+TglA0MBT4AHpBmoCuja7k3knn6+mgvwfSlzHMfQLYKr55nlTNv914BMze3bSHYdjFWkuvuamQJCBVSEFLtCWuPe4K/GOAM85kaRZpJf+8Q5blus8fRyl4cutvh/vXWOWxZr/J8/dDt///ee4p/++TnedXx6XA495luCN2wAHAxzBxolgvKBlK1Z0H2PM22oPZBwarTN+TsdQlZI+i0o7c9P3gslwjsPE4424EzKjhSkKuiKpBRAbEOjFeGoIcMQSJ6jU6yRzd6OHAak6dPUQ59tsYPMAtDLtO/ejxieB0sDV8DmGhR1hBOgtV3UboC68yBy5+0Uo7czJWOurH5qN6PpMJl8jqk0xYi3uX7qJjhzJ+aTDepJmYgOBSqUiGiOanxquUiUpIhgi+n563S9AkJvIDHREFRTk81NhWTfJTBOQt0AHLh+HYy1PBurtKC9nV/HNByYakEvQWTH2HPpEP20QO9qQHbYhck1mB5BpwqlAnRmQXNIvBCCFbDLoHiQprm31I7I+64dG4YNMC6CsBBX9mBfOYKmCtxJn7R6CZQ58AyQG6A9n/cAaynsrBDOuvQCwVuvLmJmk2yiYkUpMAHzp8FrQWeCuS/eyen4GAEjFPKLjzVGOFjEShv8TbK1m2HRBj8hZgoRXaLbglqyTlv7DEPnGAut2zi/vUF6qA0DLbdmSiPiyQUoHYKiBVUHziZwNAMjA5HAqI2ieoQWWL6kHcGOrZFqkiTOCBxIMqiUYWsHHAHaALareWWiSEELA2K7D6oPWgSaR1XvU/C7mEdgYwSjDPZkUJj18UcC9TAE3Qz/epmVh0x6N00x9+YrHP+Cx2DGpys7sP3q15PL195Mxp2AY751yPtnrd0AWEHFwkHfVWJWiVAJUChgU6RIiQYKDjYVZtCpkGGyQUZMhYgqW+iEQEJG19QJSzYcdqAaQDmFeQfqVh4E96K8JFmEIKuQmRAXIPVBRDDnQF+BDZkHwRpg7BrXqzqoRfCzXOG/H+UfhM0CVBJQBYQWCDvfXHQFSPOS6s/3YVPNs8LKHMQheBv54SNDiDZICQgJkaYJWUyUjEDTQehokU6KS4Z/A//v/mbzSvsojPfSMa8PT1zrsNr1+d9/4GZ+9RPneHa5x39+ZpNfWpxGUQQ//W0H+b4PP8oT1zrcdaBxo6c7ZsxfmzdsAJwczcWkbpqFZ2zB+TcZxC8qSBGR3JSiXISG6uGdCGktbcFxmZeYqTrJoe9nozWiqD+D5xZBeBh+BEF+uD7hSnwgKYLfS7AuPYUnmlCq07b3MTS3kBRyiV7LAf12ZOFK3tcVRDCKIQ6QAxUXjep2wnTlBTYmPMKLhwmChFLvs/ib70X33s3K6RjT2Caa0yF9M2xNEdYf4YlkhXt7HyDlOtcZUWUfYqMAi1tIbYnNgYEaq6SlBkELimTczmHWkot0VQHBAIpHwXBAjBBrzyB1FZw59EIX4QREhVnoXYO9O2hXS5STSSAlDXz6gUD/3AJGCbSugpr2CPUerjbKVaobDXD8/D1rddCSPFBWNqHqg7eSN1ZvH6H40m0ciYosEHB52OVMkiLR4ORZmCjlWWAOgHsVzXuetKoR3t1mtPWdLIQzXNZ0gpJGfGABkiqECfZTU5wYHqWKwMdGMOQiAVdFxpR0OZGZhGEDrh7B3dmLGg2oBjW6B6doHF+lsRLgT19jWH4RZbiP+tkZdg54iKKDrJ6C3hqUDRj5oJyFuAxpASojEC0IPIzhNvXtmKoLSl1yuV4gMk00RthajIzAB5ZcGJhQyOAAuZD3KICiAa1wxNJgC+msgRfB0EUokhkVJm4DdQceLxisZwkz94aoUyEFE1oC4pVNslSgn4c910I6S3VG22DYnde0niK+dl5nfNE25lsBfde3N+/2zf18JXI3a6dg7XrpKkiqKNSwmaRGkSZgEeHgYhFi0KdCnwJ9CmypOoktycqSuAyUY1jQoCmgosKslWeCq1keBGe7vRC6klfnaBZ4el4ZY9ngANUYtMpuhne3j1dKvsxJVlTzLG2q52bhpgKmCZ4PSQTFOvg+DENYFHmLh1OElgZuCj0DghKEPUTcB2GQqTKvHMoyoJCf1JHslkEreXAtx0HwV+KV9lEY76VjXh+2hwEAR6bL/PTbDvD3f+9p/ui5Lf7BuyPqRYsj06UvGzdmzN923rABcGkExk3QrcFK0ySxHWYfHlCvQlzNA4wdVWGgmhCugLcF8Xye4s0Okhx+H71iBBcCxHYH2MHMJIabCxiZWn7YroRg7PTwzHOwdwpZCQinTsOZcl5SXInAOgTJKcgug1lH0cAYRgTlScLSBH7jCpORj2IXCK0+rf3/jUpxQHS+wGy0QO/yT9A5HpN2FPh8DyqPQfUleonLs97jWMmjbJe2Od/8YeLONPSAap1Rcy90Kjg7BwGDKQxKpETVEWR1qOvQjcAvQ2YjsjJ0ziJLbeLqPojq0CljrTxDIiEd3kpfdDkopwhEm+GOT3O7SEkpUJI203KKIS7rxEyKlK3KCtduNckmXRAjSCXs9MFS8p4ytQabVdhQSNTz2GKeg7LBXLLA9bbLwOlDdxqqKUzdDGsb6AyYKfq0y6CXnuWJvQanzr0HT6kRHAOSkxA4qOf3cXL1LqalDpjYAJhs4THSJDPxNorsc8yb4IKWIuMyMtlLhsOtVyY4J65g7H8Ud99+xFUD6KF7dZRYR9iSVMyA1obuel7qPFiDWgmmD0Oc5SrRqoPpxWT9PJHdj4pEC6chG5CG12lbKf4oQxWSKQ0SVXBV0RgVY/YEUI1gcwf6cxn4PdAvg7uNiFzsAPQRWANYquUtf7MvSsoWvHgMDpK3722VbHp7I8y4S/CcQdTso7dt4r7OazHciPnaF27pa1ueY8b8jUO8LGn137/OA+D//riBBbt+vCWgikODMgYTxFiMUBii4WHQp0ELi7Yw6Ds6WRloSmgIqEiYFjCpQRWYUKEsoJSCJXYXWwqWzD/FbSWvPHFFXp6Mvite6ICi5AJXQZJnckUKqswbkwt2LijQl3mAbQMlCf0477UoitzaLU3zMmxTB83OFe8NIFVebvdgVMyFsRQB6SgPtoVOLlkNEnfXnEnPM9Uy45ULft9YvNI+CuO9dMzrw2TJAuDC1pD7jk1xbKbEuY0h/+6RJX7u/qNc2Bx+2bgxY/6284YNgO+owYVlkJMgzYQjl3twJMNoQ/zFvOK5NQENN2CQnSPsrkDlGFiTuYhR34XaKhQ+i+YMCEqg+aD7YKUwLOXtVvUqbA4kxEMIJ/PT75IBe1Rwr4PdgqgMhSZ0z0HiIVNJnFahtghqjaGakjmXUPwu9fl/g1X12JA/jlM4zmTU4PiWxdaOQ08d0cnqdOYHJPUBGPtpWUNM7UVEM8NIlqgN99K63CC79SjM29CaY6YzySQaOjrnRYzHMVg7AOoq9FUIPLCLZFP3gXYe7Ovwwu0gT6Cqf0GztcKm7pDxOH2nzqJb5oXmk2RTa2w0EjYKKbCIdekIyrDAgUxnr1R5S+8wL31+nYfLGyiqDmbCSA5JF7chXYE9B6BfhtoG/vFrPNZ/jNVLb+Jtw7u5tV/hkckdkpl+bjuUbqAZX6A26mKZMBmC30/o3/Qinzu0iGYXUAsmSWsPdKrMXd3LTbJBCQUVD4lghMfA7JPVz7ARfJzN6hC3cBdJ/w7kPCCWWHx8P6QzNC79MFeUOWS6QHl1DrAxkpisFcPsNGReforSXUXoIs8RdT8Hcxtw9l4Im3D02wj06ziFR1hzDFKjDvE0Qg5pxiOGCfQjFYOEUgKaJXFkTDLKNdSCNE8G1UbgjlYIwwDkNiK2KQ0kHQkH49zFyYgjihlkLpwI86pJ5Th0b+oz0KfQLw8xU5VR32QQzWMq1/OM0askIr+e/mqML9rG/G1G2w19YxFjomNKA0mGjo5NEYMQjRQLBxMVC41pyig0aDGNJCImY0SdLhp9dM6qDqkK0oyRb1XAVkExYMGGmg7zOkyqUALUbu7HnsYgfNCj/MPG2MqfE1qgmFAwoVoDsnyRV6w84A1H4Ll55rg2A/0uDAdgOnm2uJHlFm5ZAqPdEmtS6HTyILZowJEC+BZ0LSir0Eqh6MFOFXoOMjEh6kHYgjTKWzLKYb45pApptGuLJDMoVCEJIHRv2P/p30ReaR+F8V465vXhjn115ms2/8fnLvN//tDt/Ow7D/FTv/8M/+HRJX78Lfv48IOXWajb3LGvfqOnOmbMN4Q3bAD82GGB9kVJ9yWY9RJGaYmdtwuOfG5A1IZmB04/m+HOwPqhHda8s6CcgOkOcBBKU+B/F0wYoPwRKB30yMeKQZZBKeSH5moAUzbsjAYkvRbMVMCahQNF2OxDyQFCxOY6SssjnZ5DGg3SagaRC00X6cRYvkpDbrNVv5Vu9z1MXzrB3MikjERFZTpLaGRFprHg+r0MN47STDTqmcpZVWM4GvH26D42UPjs0CTYKgLHmNqe4M7MRkeQIAgQsN1ELLmI0RdQ1CWSuXvhGojVPfmF2sQUZD4svYAS9xA1QZpW0PoG+/0KfVoMSmFe6ksftqchG1IbSYbaOmcbj7PsX2TCvYmicgR1ZFNLbFIzwtUE7MxAuQj2CIoKjAyUvZepnbnM8p4Rf7nm8K7uHs55NlvOAlx1oLZBUqvhZ0NkN8LTVKSjkpQTmLtEUpyD546gndvLkW2TtwRzTKCS4RKQIIm4qA1YO34NaXyK0aCDkCbJlALNNlr1SSyxyVb97zC1M0lFOkxf+j5Kl3SibIhNSNcc4oz6cLmDt5jlkacygTa4Rjyho8geTnadUa8Kn78fLkXEJ+5ip75E1jUQRhfF+zx62CGOMkSkgK1DmDAs56LcR10I9bx8OSzC/gTcPqTtAJrbaEGI5QSUyPVrejH4EWh9QbwiWa1A+VmYOZQHz9qsRjixwPSzZxjoFtmoQbMSEe7x4YVXv55c8s7Ir8ZY9mbM30ZylWd2s725m68qtd38r7YrfqVg4WBjUMfExMbEQqFBSpmAAiMUPAy62Ax1DVfXSJwYWbDyA9GCyL3aLQOaeq7EXFJy0UE7y6Oi2M1Li8ly+yJL5m0jQuQZXUXkGVl6ICRoWZ71VWQeNGteHgDHLVBGYHogvLzyJk1zyySRgp7s2iKl+etKO8/i6hGoWq4YPSPBiCEyAAP0DNwRKNU8Q+xLEP1cL0LL8gxxGuW/UZGQ7xZa/lxixpngnFfaR2G8l455fVAVwS9+5zF++g+e4e//3lP85Fv3cbBhc7nt830ffpTrHY8Pf/DWsQDWmG8Z3rAB8DNTVYq3Jhz8jyMMVbL6fpPG2QFxFVxf5dLniqjlAdpRSaxFCPk4Ug1gax/IZXAOQFaC+ruIJ4/AsS+w6nySA59rEYawaSvoFYmrSIoeNLI+W8YiKPNgNMGIoFmDtRCmVpFVSLUqGHtgbgo2ngB1AEOdmr9GWaislN+H2HkPhy5Msyc0kSRItN2+NAsTKJJSpkAjckiJsQiZS99FlupM4SDpMu3qrF1rYq+pfFdvkeMoeET4xASil1/IRF2czecg6zOarOclxkGaC3UtncszDhMR8SBhc7SIkLdyovMmTmbHidiisXKYtaLMT/krESgOhU2bxFzDnbhENNxmdfpTxMlzmErGkl1HqhkwRFg1pHYHytkq2UIZvADxyDRDbR21dI2NYw/y9BN345dqYLtwMMg9gvVjeNsG2r7LuIP9u0rSGlROwFkd9cId3LtW4e3pJAoQMyIkxUSyQsyz032y+l8iri6TFlWo7QXFRs0+TT24ymSUcGH2UTZ7p9gXz9Jjg9XqMoOFEGfZJKqNsCw1z9Q4TdBrkBWIoy1wI7KsgNS30GYfJhkt5heTfousOY2SXqcadIkQuMYUNW8bp59hJBFOEbpm7mZSVEHt5O3imzqMBLgOSMtBKDq26mKMYF3NrznnFegUBDJVGBxIqRZAXYGVz4E+BVMzCdbOOUwlRDsRoPQHBDdlXOvlqq6vlohxADzmWw8FsFB21Y0VtF2bH1DRMNFQUBE4lChhM4mDSRmNEhGTuz2/DpsI+uhsYeGbJomjQCOEiQI0iuDEUFChbsKEDmUFioAd5YGmJkG4kG3lpc2qDrYBpHmUrsT5fhKrkI12S5wzGG3lJdAlM8/wihQCF0jATiDxcms5P8szwbuuBsjdDLChQiwg0fMAW3fAKOfK/BYwMkEz8rLs7S3Q7dzKDgnSzD/DIFeCTnd7jwW7ZdFanrXOEsYBcM4r7aMw3ku/lfie7/keHnzwQd75znfyx3/8xzd6Otx/coYPf/BWfu0T5/jAbz/+8v3X2x7/7P03jS2QxnxL8YYNgJt/2qd7usBLH3Q42Pc5arQZLuSVZo3PWPRCm7jjM+tHyCUI4zb9A5cgcEDpQrAK0/fAQIA/BeH7GBzJWL32x8xdi0ilSlcpIipDCiSYZpwrAzs6pGXYNqGWQDWBbRWM47nXsFGAnR0IY9RkiDFIqJkp6+Gbyfrv5uCVJtW0QICOg6S4K8hik5GSIdCw8MlzuhkhAhOdAI0RAQs4vEMKzrSLLGJylAI2MSoCnQRTDZDzQ1j2SUoqjpaBmsAkyGIXbfkvUa6tEysmihOSigWsze/j1v5ejqYLqOjozFL2QtTnTmGh0lZ6FITNMElojiqMNo8TlG1UtQX0kYGSl1rbJbAzZBZTvgonhtM87/Xw5m3U5e9Ajm4nUdYxVcm1hoF7exd2ItiugbcIJz3SYkqXCGE7iMI2mXIKLlTQnjzBTRszvCUrYGBgAG0CTApEjDivJfQPbyHTETSnQW3A0hyGfJxSc42sLrmaFBCdGtsyJtbPsrz3adKJDvhV3OocLJwhzlIQGWydgZm3oA+uYkUeQ2caFAPfL1J2lvCK/4FYRuhLLqnMkGWNgbQxlQCZ6PRNEysOkVc0qnMpig6eCRdVOFaE8gCCECpF6JUgMxyktBhqAqFEVMt9FqM8EHY1SXYgZX2fQvn5DFXCaGSx3i1QPdBmftGlfUzj4EsZK0cm2SoXmBteZvk1rKdxADzmWxMFBZuIhJQECw11t5O1ShEVgSRkkgp16jTZT4xNiMEOGkNsepTYpo6rCtxCRjZVgKoNExo0gHoGpXLe83tEgKnuBrAuFDwww/yAT1PBmQW3BSIGNEi6+eKShTzTq/sg3Vwcy1Rz7QrFAHMRkk7uBSzKYO5mejsxKCkUE4j9/NRMr+VlI0kCpbncBincgdjKS5tskWenFQWYgGsuZAEc25s/zwthvZjrOGQToPVzhWpiiLTcU1iI3IJBz/JSlXH8C4wD4DcaP/uzP8uP//iP89GPfvRGT+Vl7j85w7uOT/P41RZX1lv8u8c3WWp7XG2N2xXGfGvxhg2A+2eK7Lua0PoJOPP2eZR2QqbWqU4tU/ngkJ1+icKmgZFFhC/Bwgsx3r1bxJNn8w/z2b0gi2AtguKA74D6HfQOPstk+xyTaUyYDIhNiVIEOwCBjSyVwC3BQAXXBGeQX7goKjiTEFho7nmqo35u3xhAaqoExSPUli3qaQWBjo2DhkS+3DWkoZBRJKWJShOBT0SGikLMEI82UKHETUwxS4xFRkZMDRMfl0lslGwEpUtwYJuwe5J4fgkaeyGsQlkh3XBIzUOIXkLWzCit38X3dm7jJhZYxkcQcZ01IrHG8fQwQ1S0tMbtzLLBFR6eWqXQO4LRPsqgHCMnLhK0HOS8B/MtYAqim6j7TbatNuFgHeKA6JYRyDp400RZjWx6AEMPvrgXEYAUaT7vkod9eYvJ4jU6iclw2US9vIc7WhO8TxapYRACPUboCGDICgGX5kdQPA/PVzG7VUrJAbrWgyhT6ySGxEunqJx9L8dad/JiaZ1rJx4A1iCMEINZ7I09eDNu7i9suHmGpP8USaSTjgzUekJavZksWiLqXmNiZ5kNp4JRD5GBxJuaIUmHGNJHKG1UJSCaUMFR8ZU8wWMluTXySAGnlGvVdCxo6yAtO1dsjStIN0ArDEnijB0HvEzD2cmYHGY0NUh3BO5wGtXxcNagMYKlew7wzHGVrF5j4ulzlJ97bVekCXli56sxvr4d87eN3L1WkpHtdgAr6LtuvxoGJir6biF0kSI2JRKKBJh46GyTMURjJExGRZPIhKyUwpQCFfIsb13L+3zLCkwANXLVZJnmNkdKkJcvR8MvTWg3O7tr2ibSPNMrvqTMmgCjfGC2W5qsJsAgDzi1LP+5Is17cQ0V0iRvadF2hbGI87FqnB/mqQnoYZ7FlTEQ5c/L9LxX2dXzINpUwFXzQ+HABL8AfgMSmQfWUZTbLEll9z2w+x6UsSDWLq+0j8L4t/StxLd927fx4IMP3uhp/BVURfDm/Q0OVWCqUeXv/94zfPTRJX7i3v3UC8aNnt6YMd8Q3rABsFqEpGXQfK5PWVnHeF7iHo9ZPn0nvUMbiOII+1yPNTevECteBbkdUn36IsGsRmD4uSBIswPdCSjsg/5essIevD3n8HsQT+hIXzJMTIq9IWayTbCvmpedJQH069Cu51ZAcR2iScTaExR3BmQ6OCHMuHBpwUbvVNk/rGCjkAE6BoKEERYmAhMXFRVBSkhCB5ciBg08/lS9xpniJjKzedvwFOyW9HUJKBHjAQkxc5SI5AZ0VmHqKtK+hVS+CYIyTNXQPjFk8dI7mUhdqlmNtKMzkRzk7czjk1LB55JY5qHp38OvlvFWhzhDG0QTD8FBOcnlQZvVRoyISky2igzdY3iVbdT+FqK1h0ym4Du0rDbugoHcXIfza3lv3FwHmg2ymgFPDWDYpLZtYWVDdmZDErMD12fIZJWtoUPo2hjri7y51eDdOBzAxiUmJEMjRZCyzYCnLI/B0c/RbH+STEkIC3ezf2MfL5Y/TWoZVK0Q/8IdnGp9F0Njlf7JL8BUAP4CtJdQAh8hhiCGQAZWHSIP9AC5cAxvc4BQMvA3IE7xdI106v/H3p9HW3bV973oZ65+77X707fV91XqVQIJIQHCNAbDdWwTGxtie+Cb2Iw8o+QlJvEjzx5+JnkmDr4MHgq5gHOxHRNfG9sxjY2waISE+lL1/en7s/tm9Wu+P+aWMCCQSoAllc53jD3q7LVXt9epNc/8ru/v9/2aSFGis+M2SguPcqB3mXk0EhtkLoc0AjKLEXkzooYSgaw2LAwL4iWJVlCteLYLnmtBtgTGkCqjFHk6tS5tzUBmesQtmDqzyfRZi/bNIboLmbRBLt8mvmQxaUqSwmUGchA+KFlejEndK7uffF2JOt8LUrLl3rKFlxRs1EgZ4ZElh4ODho6JhYlNBoGLRZkSZYYwKVMlSxebDgZn8ehpFpHuqkijYl85nU775lASJnOwrQSlOuRScKV6sJeGoIcqE110ob0ElgRbQDcE3e6XI0vVq2s0lVIbWSAbkBiqdzefAVKIl5QjtGkAHeVE7wsoDSq351YDMoPqQWzcVhbyVqLKqbUY7EipxkmslF3bVPFKjlBO0tMWLARQN6CaBauhHvKuF6CTAWqKeFuWyiQONtS+4hiEofh8Gr1gv+sXC55tHIWtsfS5YGlpiX/7b/8tX/jCF+j1euzevZtPfepT3HTTTT+U/X/ta1/j937v93jsscdYWVnhs5/9LG9/+9u/a72PfvSj/N7v/R6rq6tce+21fOQjH+Ho0aM/lHP4x8Lr9g9zZKLIiaUmH//aZX7jTftf6FPawhZ+KHjZEuD9bovEEMxNSYb/V4K5qrG3uMHKVAuZ1dn/+CzuIrRtVWoqB8CIJEKTGBFQHEAsnsA9+3XieQgPHSbN/SZJdy8L6X2kFUiFAOlAPkd0vsfAxhpLm3VlF50twJwDRHCoqFyi/R52dZEpPeKir9PsJVQCMOY0diwOMJTk8bDQyaEhiPHRsQCBxEUQEBMT4aETsMkGXyw8xompR9AyFwl6e/i7lYTzjYNUJPSIGCdmjpAMMRUyVLQQoQXITgkGN2F5JwQGrD1MatQpsY+fjF/PdgZJQxuXAhYaF1inCzzgfo3O8AUoDrKiLaJ1RsANWQh13OY2Xr9xIzd7ebqkPGiBJW0mamNkkyl6pLSArtlAszPkF6EnKsSVdfC64FWhe1BF/oyeQ9QsOiMWnhEQH6ghZqaxLm0jmMqhuVWKczmuaR3k7YwyBGhE6CRYpOiEeMScFx0u7JhB6g9SlcNYUxtE0RqztR5WVMEYucx6PIqeOUKE5Fz5b5GDFyEqQtuHuEziSLrjCWgOdBfB3QldCZsdyF1SE9REoHmnSI08FCFI8pDLQvQKWt5OBsWnqIguS0UHHOg6BdKxGn4HWBFUyTLV7JI3JbUh8HMauVBQTBJkYILfhDSrzqtQwJv4ZyDGIa6jf+leOo88wGZ7N96D8wxtb5GYPbRMQnP+IIM0KH1zgeK1cLqp017TKOWvrNAuNbYI8BauDgjoRx2BjoaNQwYHExuBwMYgg844o2TIYzNAzCihanahCqwT42VLxFlHlWpMC5UJnnNhm1QKcNxv0h8PVLlyVkA+hWKqMngb6xD0IAjAzalsPcdUBDIKFIlMMxCLft+u3y8rziqCG/pgWopgUlb7SkPIuIq8CgFeXfXmmq6SFtMU0MG2FAGvL4KwQXfAMNTnUUMZWRmWeuCmm6DrUJb9Np9UlWrXPZCbUBxQpc8NH7y26kGOMuoKC6HyjBPQUkFKzMu5yPfZxlHYGkufDfV6ndtuu43XvOY1fOELX2BoaIgLFy5QLpefcf1vfOMbHD16FNM0v2356dOnGRgYYGRk5Lu26Xa7XHvttfzSL/0SP/mTP/mM+/3MZz7D3XffzT333MMtt9zChz/8Yd7whjdw7tw5hoeHf/Av+o8EIQS/ftcefvm/P8r/9eAs77l9BwM5+4U+rS1s4QfGy5YAH7gR5nqSuCxw1yWddR3vEcGO6ceYyQkuWEVywx6HzoV0VlVO62gtQWRgZb8BE9ehN88xNrPKxpwkGO2AHcLGdkTdRg4XwW+rMmlrAj+ukks6iOp55NirYK0A5x0o+CoCyYogWMHv3sHp+b0k43Vc8wFCI0ALHMrJCC5gkUHg4ZLBwCIgQiKwCVmhiU2PVTbpaAlnxy6zOP0gYmkDywd2ebQHNzh9fAWj4zIcR9hIvu6eoRSbXBPsJtZSVaYtm6A1YaIA8jjamUdJqwMcu84gPpPhp1qHmGKUIjYNHNaRHGeOxcocDg2ChoNkEMbOkuluYEWSQJynxU6OyAn+zqgRZFu8tjFNRWYJ8EmJ6ZCSjYqM1weAgIe1G3m455A6JyHdjpapk6YbYC8hb4XI3Umkd0CPkY3D6JQYWMizJ9nBrelO9jFAHouYmCYJMSE9IlbocZI2xwsrhNtPgL5CqmUJwhTZitnIzsBoiLaaIXEEA80sEVW8ypMq6gNNEdtcFrAg3kT4C0grC7kJ0NfAb4ETKfMZJ0Zmd4N7WGURbZyBIALnSVLxOub8V+GO3kuSL4GRRfptvMRmWzsgsUw6xTJx3MVtq7bxapIy5YMRwXqhRy/sgqhCHPUzOIdU7vDQDuTAA3QGYwa8NXrTIa0bNba3YoINnWY0wBQO9doqnaUI0U7IKU+1K8JzIsDB87pVt9DHlagJp06d4gMf+ACPPfYYc3Nz/Jf/8l/49V//9R9ony8PCJQ9k+QpKqyj992eTTTARMdCo0gBmxIJZXxyhDi00GgIQV3TiN0ssmBCWahXUYOipfp+iyieVwLcWJUbG1KVHFuhig+wPEV001iZS5kWGKYinEECoQepan8hBdJErZvY/Z/7GWgYIE1FmlIJaKqcWRNKNRZSEd5EqO+soQitJkB6ShXW6Ls3p4ooi0gpw6YHVqrKoQtCzSgMDWRWbdfywPOVgWKYV+cVx4pUCwl6otyhNYnQBSJNkVLyci30fc4EeGss/Z74T//pPzE1NcWnPvWpp5ft2LHjGddN05Rf+7VfY8+ePfzpn/4puq5CqM6dO8drX/ta7r77bv7Nv/k337Xdm970Jt70pjd93/P4/d//fd7znvfwi7/4iwDcc889fO5zn+OTn/wkv/Ebv/F8v97T552mP9oHRWn/XkzTlDv3Dj6tAv/Xr13iN974/VXgf7jtlRzn+azzvT57puXfuez7vf/HvL4/ym1fyOv7TMt+1Nf4Svb5siXAXhtuHIa0KdE7sJAKmLWZ+Nsua9sdGndMUli6hLYk6JgQFSTmkiAdl5gzHpltX6JljDM/sR83mENOTYE+DM1h9O4klj+Pp5lobBJ3DZKJhNXiNmT5f4N798I5E1H1kaVU1VhXLOgNQ3gzhueQGk9QG6vTCpexF17FToaJCdEIyKBjYWGSIACfLvdZq6xlEqS+gT/QJi2fI93xEFweh8234U9GysArrJCMGiTz0Elg3mxSP7yJt1Tg9GKPbGoiPBNpZ1S/l9TAiUm1PVAaJDUdTkwssRFleU0Q8ea0wjodIgxaRpN0JE+a5qEdIJx5DL+NFgp6moWWDpGQ5TRNurHJK+p5juLSo84Z2tT1hFnToxhpdITLhr3BstNEJha4r2T8dIDbC7kw1QB3AipZKC7BcAzdQ7AR4Y+ssX01z5vTXRykgoGD3zcHC1F9Z5fo8Peix8Vcg2DvPGQXQB+EnIlsRVCxEOJJzOACmhYS9nzKHQ0vUyeeyMLCBgyEYE+B01H938LHDJpEo+PIOIa0CSM3Qy6ARoTMFKD8CvAmIG4pNai9BNkZ2HGOqHUd3fCbmO0qiVnH7sRkg5RAg8SOoF1lPc1wsOVhSGjtgVlHCUtJU2KFG0TlGGmZyi7aBggh8kn3b6MmtxOeb9O+7RZyAxfJ5paofkFQal5kNR7Gb5Vgrsa4k7AaGfi1lCtRYmRG/Vf5nkhRGR9beF64UjWh1+uxc+dOfvqnf5r3ve99P5R9vhygYWECGWJidBIEcb/pxMQhi8ABMmgMMoSkzCpFVhHUibiEjWcOEGZKsF2HcgoDMYzqigRvQ/X65vpk0ZRADOkK+FIppXIVjAAKEnQLMKHVd9THV2qtjlJaw3qf5FaU6huk0FtUCq9pqvJkAN8DMoqcaiglV0ql6lo6uChFmlQ9VfMFRAYUCmD2Lei9FUWkjaIi4kID6mBp6v3AODQ12JRge8qy3p6Ey6lqbk2GlFO1Y0I3hlRThF3aoOskuVjVAEcJRL1/zF/7iwbPOo7C1lj6LPjrv/5r3vCGN/DTP/3TfPWrX2ViYoJf/dVf5T3vec93ratpGp///Od59atfzbve9S4+/elPMzMzw2tf+1re/va3PyP5fS4Iw5DHHnuM97///d92rLvuuosHH3zwivf30Y9+lI9+9KMkiZL+6/X68zqvK4GUkkajASgV+JeOjvC+zzb5vx6Y458cKlHJms952ys5zpWu870+e6bl37nsO9/HcUwcx9RqNQzjR0uPruQa/SDbvpDX95mW/aivcbvdfs7rvmwJ8KntkJuC61qwNgFdP6IxEtDegGhbgrWxyMDfRQSLo2SKAY0jNYYcSG2Ynof8fVW6k21OH3w1tfEjkNSV46Z9CD/6Z5j+H6NlaqQDI2BO0dV3gH4nPHgYnshh1XuYIqAbN6AUwfgibEB2Zg+5UKCffgWNok1ozTFa208Whyw2NgYJBoIuPSISejxQXGNxzyIyuwn6JgyeV1k5y3shmEbesAE7Q6iNw6UM1LNQalEfqlGf2oTKBmGSYXGpyUQ8jBlMEu5AOYs2cnDmNuhEEFVhIUZbr7BauchfGQ8Sz2fIykFO0WOeFJmOEzqHlcphWUT1lKTnoAU9nOY1ZJmmrgWQNhhmmFVCLtGkiuBkxSPQQuYnJCfGZpHRRfA6UPAg3EdbOLQND0YSNbEMOlAsQWsILnoQPUG6Q6cV7md0fWe/h8/AQKNBgEXCWVr8hd5jeXgdufsk5J6EKAe+Be0QbBPhLJKJO8SeJO0ZGO29jAUDzJZWoTyOaK4jixoU8hA0EBsaVmeF8u6IDX8VKSJSxoFBpaRmPaUCL2ThognXLEO7DrZUk16nDtkd6EtFsqtNQqEyfwcMWE4FzYyuFJKMhjMIbQn+EhSXIRoAbUrHLxhoSR3L9PFHdiHbl6Eewvh+KO0juV7QPFLHfuIEO762RiMH+rRkfGmDpbpAtfxKUs/Clza7Cm3ObVzBDWWxZQP9I8SVqgk333wzN998M8D3VBt+lArFSxUGKQJJTIrA7mf8CiwSDCIssrgUKFGii0WCRoxBk5gaGp6ZJy7ZStmttKFiwogD4yaUTOX8nEf117KhCKFuqB5bmfSjgmJlKqWnSj2NUtAKkHRVNnxW9E2nspBE6t7SQ6XY6kCuoMqiI12RWl2qV5oAUkXYaf1mU61vnhWZqjRZxN/q9U1SCFNAU4Ra1xVhlx1FWlMBfgNEEYQL/irgQM6BSFMEuxfBUF45WLcDtTyy1f4DAV5PfX+JUqDTtK9Sv0zxbOMobI2lz4LLly/zsY99jLvvvpt/9+/+HY888gj/8l/+SyzL4t3vfvd3rT8+Ps7f//3fc/vtt/NzP/dzPPjgg9x111187GMfe97nsLm5SZIk31U+PTIywtmzZ59+f9ddd/Hkk0/S7XaZnJzkz/7sz3jlK1/5Xfv7tV/7NX7t136NVqtFsVikXC4zMDDwvM/vueApJa1SqaBpGj9RqfCpR9Y4vtjkz082vm8v8HdueyXHudJ1vtdnz7T8O5d95/soijAMg0ql8l0l8T9sXMk1+kG2fSGv7zMt+1Ff4yvZ58uWAG9L4MEK7E+g9xpId6Xk2rDWgHw7wvnvEdb8BGsyJttI0Fch3CuJpRILPQmZxZCKeJSNsdtULnDdgLyA4PVEhRvAWIP5GIIsuA4slMDLgJ1ikWBLQc+sIt1FxNyXIN1PIbkZkyzDSZbB2hFqjDJKhgJW389Zo4vAIUCnxVl9mcXxJWT+cdAvqAlNMgLadWBOqRLcwy5QBbEMpgOLKWw6MLYJ1oNoM+dIdjnMX6yyo7ENZz0lLAqYGiZ3pkAUegTDDcTyEaRVJ5l8EjhGd2SYz3fOsLN6DZIOVpyn8EQZ372J+JBAr9sMXxoml5iUZY4z+jJ/N/AEkaMxsuYyG1e4xAbLooEhO+zZMJkdatIaa6LPrCKrHVJnEpJNsOtYUQ49cmknvpqMtTUyx8tsO1/kUmGJaHAWrZqys7GTAnpfw1HldAkJTTp8ydxkaUcXtl2GwVUITSCAKKsyMN0dEG/SizJY2QaRtpPi6k+QaAYb0x74o0j9FZDJqX460SVfdcjqAWlRQhBT9peoVR3kcgFeZYE2DzroD46TZiUynSdXf4Re9hrS0der3GWzTuinpAEITHQvRZgJOVuS12IaVkxFwvg+mF/Tsc+k1CJBWNfIjcX4wkTUoPxEiDF1ltQ+hxbrLLz6zci920CPMY4fp/TXp4nXE9ijBJvUCqhMLLK2UqQVQDYyMGyfC1f6gHmLAP/I8MNWE57vPoMgIAi+VXvZarWe17FfrFAFzyrxNwEsNEwMbAQGEp0EE5MsRQqM0cMiQidAp01CSxOEtgtFA4ZSKHpK9R001atgqDJhG9BSSBug9UuarRhkrJySZaw+J1EGVX6sYpLSWBFgO6PUV8NR/4pUlSTrhlJ0jTz4QCD7qm6/rFlKdR+Ger+cWldRRrKf8xtEIEJFlpM+EY1S1eqRxoo0G6nqNQaIJMQddUzNgMAHXHAkOFlVcp1NoOyCMCHbUMQ8NiHpKTOvqK4inlL6cUgR3+oNfhkS4S0C/AMjTVNuuukmfvd3fxeA66+/npMnT3LPPfc8IwEGmJ6e5tOf/jR33HEHO3fu5BOf+MQVq3LPB/fee+/z2k7TtCsmTc8HQohvO9b77trLL/7hI3z6m/P8yh27GPw+vcDfue2VHOdK1/lenz3T8u9c9g/fa5p2Ref9g+IHOdZL5fp+57If9TW+kn2+bAnw3ouw/hpYuwSJC/E1quVq0a/gnI+YmN3OptjElA5JGpILBAtDWYyMTj5tUQs0/FyWfKvH9OoDzE/+KqyOqD/guglroxDk1R/xVga8voHIaBvaarLVsULkyCWoPkalfpGkVUPKNzPMIBkkFhoF8lQwEegY2PjEpIRYeFxindOlKlI8CSyrp/MFV2Xl6IvgeGANQ9aGtABpDuINyIRoG4Okmg0DFoIU4hWe2H0/l2YTOrmbwRpDW0vZX81AmmWmY1Mrr6kSvlIK5gRUpugYi1w+1WWwOYIRwmg6wb52mfmHVrkoTBpaDkNarOkJnmsTFiXlFZMj8TDz+mnO7r6EZd+P7rVpdl0603tg+SCZmYNocZvW9jUomBBn6RUKhEMSig5UE7iQI+/tBNkjKVwC08Nu7ea28EZcsihGGxChscQqpwk4M9qAw6vgLkEyAcUJ5cqdutCtAo8hO0XIOMhuQGntFg52t/H4vpP4+8+q8mXdVoY0nS4k41iJS21SID2TRNo0kgxy2oUlDc4NwDWT6Oc1KvMTbLzmOIgKXu4aaMxD0IDedgjPYXlt3FSjNnQDSyasR5fRkx7brC71AajpFt+Is6zvehVW7wSpt4jnQzo8gCZ0Bk/UcC7vwFpcxI1zhDmPhf11uPY6QEczQlwjxSkoz7XsWcFm16BiRdh6jz2Jhn1dj8aaxsKCzhU5rZj0I1S+B7ZMW543nqua8KPe5wc/+EF+67d+63kd78UOsx9xpDpkdQwMXMBEYDGAhobApMAQFnlCTKoUaeKwjM6aGKaXzcC1JSiFUIhhogzDDkw6YHRUj2+qqbxdLVCGVaKt+n+1DNADuwpdQxFF+iQ3J0EuKcU3OwlxV2XttiPI5VRZc9AFvQiGq45hRZD3Ic4oEqyloOVUCXMQKQMrwwZ9h+rFRSryqwWqRDnuqaiifKrIaALoLuoHT7k5mwIS2fcdaINW7pcvN0B0wHUhP6YcpbUAypH6O+i7oI8qZ39Th+pFiLrq76Nl949vKROvyP9ev7KrE882jsLWWPosGBsb4+DBg9+27MCBA/z5n//599xmbW2NX/mVX+Gtb30rjzzyCO973/v4yEc+8rzPYXBwEF3XWVtb+67jjI6OPu/9vtC4c98Q106VeHKhwX/96iX+/Y8ffPaNtrCFFyletgR4YxG0U6qVU8zB5iFo58AuCnpHdrNWnyHbatGcr5C3mtQnLIxpQbu4l6DYJOxuAw4TLV/i2ke+wObm/fQyr4FqQUVNGBo0qsqsIu5CkldOWq0YEQfYWEQihF6Vgn+cwrpHt7BBYH8T6e2lSYsJBhnAoUuCwCFEYCFoiFXud1qs5OYJRx6AkRUo99STfL8Nq0tg7VaKb6kH5gg0pcpmFAaUBFpWx1kdo1d6BYldATsmycxRP6CB+CZoezAfH6KddohFhlT4iK6HdDzl6ukOQHMJigt0bq/QmVshe7HE25qHuAadDZmhgkAmOgUizpQbuH7IoZlhpLSQNIlkil0PMbQKnmuTjjSR1jIMuXSmPOjkVKmgiCDK4rlA24CzgG3DXpP17EnWvVHwdoHvMrV0I9McREcDNBJCzlDj/9aWuejW6I3HYFTBqKgSvpoJaREcH6xBCHZCEINRobBxGzfVX8HFwXP0buxCbKuJX7EOQQ6cPKyVqWcskp0jEKdQHCWReRgvwbYh2ByB4xkqjw1g6B7ka5A0SEZuA72Mce5viMd/EoomLNtMrDVxwrN4WYNWSSfrSsKcSTd7mMS/gaZRAPMW/H3nwf8aoYjg4D4qX/sbchdc4kRgeYKQgGwYYHQ3iUwL4g7hriK1owbFbsTYBViswUgISQbW3hRycgCKozCykbLtEpy77wpuKJctAnyV4/3vfz9333330+9brRZTU1Mv4Bn9sCExkH0CbKEh0TEwMcnhkiWLQx6JQw9BA5c6DnUswpyDLFpQQD0gLCaQt5QaXLFUzq0e9YloT5Usm5HKxcXqlyMLRSrDVGXnpjFIAxCKPMtY9QGnqHHc0VUOmqar3uHIVuRXoEymbEeN+bLf96vZyvwqa6iS5iRRyi2xyhrWdeXCVAvV3zBHU8TU0JS6rMl/UBbde/qaoUtFosNAKcqapnKGMVTrh6tDnIVtI7DmQ9VX+8UELQt6pp9PHCsSLiNI/L4j9csMzzaOwtZY+iy47bbbOHfu3LctO3/+PNu2bXvG9Tc3N3nd617HgQMH+LM/+zPOnz/PnXfeiW3bfOhDH3pe52BZFjfeeCNf/vKXn45HStOUL3/5y7z3ve99Xvt8MeApR+hf/NQjfPqbc/zKq3cxlN9yhN7CSxMvWwLsB7BWg6WOxvQjKfombNsDhUyNi57P0DU9FpcFzeGITd1FXFMhnjoM7CF09yoHzG98lTDwmW+5TMwf48KRGdB2KPfNuAnWRSisgtuANQs2K+BOYGw4mBrEu+YRxRqjNZ+gJNgYz2CsnmXDW6NOD0FMmSEsdCDEwmDOnOeh7ffSG72MYR9HczxSZxACDaQFbYFRrxMPC0iGoWGC1lKToc0OZHrglIh3RpSOD2JdGqIxGUGnDa1jUDoEy+tQPkRe6kiKLNinCbevol82EGcTpFyGMQ/sFogSVDeg26O3c4YvbNRZWTzENIP4huDs0BLmWolrN13adDGAZaPHeUNikVCu76cQH2JmoIM35EFaIn8mIhOex8+t0J5wkONCTfZOdpQhS2VWlQzGGdUzN7AfGjrW8mGmw9uxsBAIDGKadPm8Ncex3TPIQhXGXdV723SU+mJE0HNh1VSlgca1FC9GHGruoJQ6nMgts3D9AmR8qDqg51WepmZAewAuWySuhOw0yD1gDKjJrp2FpUFoC7S5LIONaVaHLoF7HDpVSC5C20XbTDGMLxAfupWKE+FmYGNEmcYYqYfXHmDOu51k5a2qV1kPIO9C4UbYdRP4G2BlEek3cGUVvzyD5saEqxqyFCFjHxo1RGOGHQtPsDsTUZTQXoeyJokLEaeuhdVbbLpWmdRdJ9dIOfjMc4XvDZPvP5rEz+cu3QL8aNSE57NP27ax7atzsiORSNK+ACcw+qOujomNQYUKJcro5Ohh0EZjnRwNstQxoWTDoKEijAZS5VFQAio6DDmKNMpAZeHqPTXuZFMVkycd1A2vq8qSIFFkMGmrFo3UgIKuopGiUIXY66ZylDYLgAlxovpt/eRbJchOSZlKoal9iz5ZtRNFVsOw34McAA2lxnoGrDZhOg+urf5m6KJPgBMIY1WSnfTU/pKMUpINVA+xpquSaAx1XNmCXBHsooqAElVVadPa6FseZ8HMq1JuGamHxXGqzk++DAeNZxtHYWssfRa8733v49Zbb+V3f/d3+Zmf+RkefvhhPv7xj/Pxj3/8u9ZN05Q3velNbNu2jc985jMYhsHBgwf50pe+xGtf+1omJiae0USw0+lw8eLFp9/PzMxw7NgxKpUK09PTANx99928+93v5qabbuLo0aN8+MMfptvtPu258FLFnXuHuG6qxLG+Cvybb9lSgbfw0sTLlgBLDfKnoC0kazWb0bGA+ROw25QUvS5OANaGJH+4SWzBcrfL+db1oN8LCw+jPb6Ec3EBPZZEYwJXmIpcBgn0JPgNsvN/gGYv0BmwsOKIcsFnw9+N1fox6sPbiA88Ad055sYsYj2LseQRJzoShxEkCZI8Fk/oSzw5fgLTPkPsPkDsrqG5EJujqr/YyoFrQupB6BIX9sJSCs0SZDSohFA9BX4VWkUYLcOuFlXzIgOPXkd+Zpi2WwD2gLQorgzhrQ+S8UxCzcWOj5A0N0nKm/1J0hmoW5DvO4FqKPWitUzblKRcx4zlc2o6ZsAPOJiaNOhxRlvivN2AigNumd5ARCPRWA4r2HOTTD+eYydtfjxMKLOLVTT+S+cY1dY8uD1wm6oceq0NYU8d09EgeQSzNcWNzcP8OCVG0HDwCQi5SI0nJy8h91VBz6q4DplRpmVYIOqqdHx1EhoeTAiccALfcvn6ttO0yzH0ZlUvN5NqUhqhSs1rAlaLUPGgUQSRg6SiMj2lBgsmNCSpVaarh+hJit6pYy3NIsQcfmEPFEsMeRdYbUa0zIRjew/gjd8OIgNOAJsH4PRuQIAdqN+lbyozGYqQT2CmjvQTsgMBFQP0CchVoTYsSKdL4IO9fonrkoixFvTOKB+bng31HOhrOlyEkuNz4HyKe0yHwhXKDBbffzT50bfTXLX4UagJV6tCcaUQCDLYKFk1IcFEx8QAbEwcbEo4uNhYOCSU6WCyjMWK5eAXbJi2FNEtCphOoJiBUg6O5CETgbEM0YZ6aJrpq8FEINv9PloBjgEdH9bbSjE1USpv8lTMmlBRSNmsIrsINca0Ue8jIHIVqewEQBmcUQir/VydHPTqilSWR5VK6wBpXcUQSV05PTs6DOchsqAm1ZNiP4JWADlL9RvnU0WwpYCqpsqxk1C5Rlsm5Ez1PtXVWOh4Ksu4kSo1XBuGXAzdFnQysNhUgrK3powNAx8sp9/bnILnvXz6gZ9tHIWtsfRZcPPNN/PZz36W97///fz2b/82O3bs4MMf/jDvfOc7v2tdTdP43d/9XW6//XYsy3p6+bXXXsu9997L0NDQMx7j0Ucf5TWvec3T75+qjHn3u9/NH/7hHwLwjne8g42NDT7wgQ+wurrKddddxxe/+MVnzBV+KeEpFfiffeoR/uihOX7ljp0M568wN3ELW3gR4GVLgN1XwWAEzhrUUpPNizF+IEkOpjS7yqQyU4BoDjL7YTXvQjSjnlYPRMiKQZI4JHUdczDBHJUwasNy/2l718Qwulh2h05okXohHUuS6pv4lU9g5vIYzS5pT4JrYDckk/WQS8E0QwwzQgebIjqwI8nTWy9y5sBlJp0Z1rUsvn8E2ila8xzpeBnGSpArweogBC7kfEh7qkdrtQHehiJnGU2VUNVcpDhLbXqF/IU7sY9vJxp6HTLbo+CN4o01iYJhqqNtQncF5+IU3QNrkGwoFUPEQAn8EsSTkL+EkE3S1hSPCEFqG9y5YPBzwXZOk+UzPESSGpBmINuF0QA6GfSVCpVuhltaRW7E4gAFpvFoIhggYaBhUC0MwGYTJkJIN6FsQTaE6j7o7mDwosmPbY7xlvRaCoS4dNAx6NDmvuwKncNtyMTKSbXV748TJ6BpgDUB5ZpSU7o7oLPK2sgMa9PHIBuB11BGNZEHeh00Syk37QDqZbQ4R2rGSglZz0IrCwMm4rLJ4KxLIbJoGhYi6TBQz1NbPkA6sIg51yUnz0EFfDuPlEforE0imrsgWkFL/5q0eSv421Qp5OFNtOTLmIULhN4hpPdjUNdAzEA2oRUV6BQE8QWLYCklzSYc27+TdOwWaPfQaJJGYE8o/i9mTZrlhDwa7qkchV6DnB+Q7aiYzt6V/o3eIsA/UjybmvCud72LiYkJPvjBDwLK5Or06dNP/7y0tMSxY8fI5XLs3r37Oe3z5YKnjPJAoKEj0NCeLoU2yZDFxsXApYNNF5suDoFtEecNZXA1oKvy51wKZV2NUS5K6ZU91e+rJ2CJPuGMgH4Gbz9+V5lgRZA11YI0ecqZS7VroCmFlb5xlTDU2KTpqnzZyACmihASmX68UH9iKnUQ/Zs0dvplyijCLE1IHaXcigQcR5HXVILmqFLpVKoHjppQirCm9XOD+xBSkV2DvoO1rdazE+VuHQlFjjO62q7jquuhBUoZlr4q46Zv2qWbqD9ULzO5c4sA/1Dwlre8hbe85S3Pad3Xv/71z7j8+uuv/57b3Hnnnf286u+P9773vVflA8U79g5x/XSJJ+Yb/NevXub/taUCb+EliJctAV7YBkYbsjmJ3emx/rjO1J4IytBbErQ3DcxihKFB0hH0Ovsha2GuhujNJcLSEOEbDjO++AiZTsLGkAHti9B7NYRZMBJa1+wBMQ5ijbi6SaXbINZCnGKbXFqnF4M1AJlQUA1dlvL70LzdmM2QHA4DQAdJhSxRYQBRht6cIExsVYpbrGIYXcKgAdotykAlm4GVaTBrYEeYF3JEpgPWguqzyh0GvQTuJszuIl2boz3wVfK1MtZiidxymcZQk3Bni+5GhmCoDUmPkXCQldWdeJNrYA6Dk4G1SUQtgxyZxbZPE4xux9n4McblHm5tN3gXWTRMHqROgMkIeZJI0l41aBU96Olkqnl2hUNch8EhCjhElHHxiUgwqfgadJvo1S5itUC8U2DYJbIXtpMEezjSKPDWIM9BQorY6JgITAQ+l+nyyI5T4CwC28HToCOVM7ZENX93ctDbjmjXKW3spHHERFaWIVoFLw/pZehYqi9LdsAtgT0KkZqspk4KGTAvuxRWh/DSDKJhMehlmE4K6OjkoogYj01jEzl3C2HNJZr6JmZ+g7Ayjcy8Gno7QKsgywaac4LBlSU2dAe5YcPOVQaNjzDGcVI/pamdYzE/AXO7ofRXFBeOYZo91ks6Bw4G1NdgtpShffht4GyH5CT+wC5Wog2G5xOCy9BNLJx9XRY1sAabbJPQdaDlQD6fIPYBp6/ghlKOQd8b0fO6TbfQx7OpCfPz89/mfri8vPxtE7gPfehDfOhDH+KOO+7gK1/5ynPa58sBAolBgNanvcr3We/TMAsDlyIj5JhAo8IykiouHVEgrWRgyFYPPsdNlQCQ82DKhDFdKbxhD2iDmSoy6LYVQU0ipQSbusrh1SylEBtSGRZKAf4mmEG/3cNWxlRaDGFR9fPaGXBcwFJ/c0JHqbBJU30e65AbVMQ6CSAzDJgQ6OoBphYBuipDRleOz3oMtqaIrpSgTSrjv6QNhYwis14/uz5J1T1vWoqIu0XlWt31wSio0mjXAy9RBHx4pF/anUIu278mEfhD6sFA0AAvUuRbk5B46mHBywnPNo7C1li6hRccQgjed9de3vXJh/mjb87xv796J8OFLRV4Cy8tvGwJcL4LlQYs+yALKZYlyQ2BPwCNQCImYrw6TA/AaX+I2M1R/saDFOpd6rqOGKni7Xs1wfZxihuLzI45ZDf+F73uXdA7APF24FUQ/RF4m5BYdH2djGgwbcY0HOgkJrZnsantI41fi8xsxzI1TDqAi0dCTERCSNteICl1qM6WkJMDMBchFg4SHtagV4YLwLVFGKhD2FSTi+Je5KyGaI8ho0mIY8T5FLk3Vu5HWgZy06Rlh5Y5T2FtgsF0hLUbutCUtAt1tHbC4csH+Rnp8qW1Hl9zy8jxDNpMhZ0X9tKTNVY3YuLiOFntKG+q7uB2GtyKQ4CgTQ6PTSZIAcmqZmGEZezTkt3eMEWZ4VoKHCTAxiNDSI0ubbosoLOYu4AWLlJq3UE320HzpnnH2QEORttoAdtIKdFAxyIhRidAkCIJWdAX6AzeD9EQOCn4dagYkAmV2tG4htITU7QHYxw9y7XhMA/XFuiNL0HbhCgA4auJbKxBHMBgWYVBtzLg5SDvYfQSblg8zLDM0ELH6DhouCQkRCRk6bLirLL+ihYyNih88230gpsJXnlGlQtWd8ByBXb0YGcDa/ZxCk3YEHkoB9jp/80NreNc7qTUXZ1oMoLmX6FZ0zB7Gq3W5XDR58E9uzmxEGL16mzsuQ05uAO8WcgNk+rTzLHO7gsXWJ2DjObRiOHCa4fIJw0K1QD5MLQHQebVM5QrgsX3n7j96BMlrnp8PzXhKVL7FLZv3/6yViieC54SVyMNdCnQpYaNhtEvgs5g4ZBFMMQ6Ol0CeuToWlmamRzpsIDBRFWjDBuqB3iwDJmGivdxNbAk2Dn1wEz0ja3QFCFsx/1+3bRPamzIVRQxTWPQPEgtwIJcWX0ubTBKyuQqsfvRQZoijZEGiQ7ZIfB0Fctn+YCuCLSUQKzKnLV+BFJuQkUZ+VXIBuqieIYy6NKifrWPVOZZkaceHKaWqqJBqnE0CJVb82ZPKb+WrdIGUgt6OXV8x4aCpsh1ToOMq75/TYNmRkUxlLPqgYGMQXqAATL7revxciiDfrZxFLbG0i28KHD7nkFumC7x+HyDe756mQ+8dUsF3sJLCy9bAjx2DLrXgJ2CtwCZScnmMCyNa5T2pCSaZLQE1QHoTAdgrhLHMWYCpUSiix4bC4/gVyQrBZN4Yz/59VME6/+TJPMf+iVuNyH8v0Y0ZxCaR0+6yP3bKM2fIixIkpnDdHbtY+TEPkprN3HupmOEkzOcTFcwl44ylYyQouFgcfNKmb9tawzua7JS3UGa24uoFZGzDtzsKlfRzRDsGLZVYe401C8Rj74WbbWGHPMg0tWkOHZhdidkjkNswNouZPkbdLWAua5P6i7C6SJCD3CXO7w63IlLlQ23hZwqgm4iu/vwdYGvl5DOtQjd5/XzeX5BhuQxMSmwSYZ76XJ/boZe2KElz+JNemDvpjg3ybR0OUyGmwlw6eJQwEbQokMPyV/YMyzfmCdtFqkna2DavHluhB+PdiHooQMxMVnyZPvWVzopKYKQmBlrATkYKdXEq6nv7eSg5wMV0LO0d9dJEp3B+f1cT44ToksviVXJdLQKxih0mghWwbWR2Umo6mAUlZKyfYnKhQJ7ZQGNiAIOPSQ9ElJ8UnzWzSrz+x/HsO8l6u0G8U+ozA9TTV2S13lQ0sFpQz6GYINAVpmZvhFpXgfBGkXzcZpmil+B5kqBWA5iiAsMmScxl8EKBasWlNMl1qZuQO57C4zthnABeBCSaWAf60Nv4MneIoOxh9QkIhDsq26QyJT1LIwfgtEU9Laa018RTNTkbQtbeIlAQ6gqYCHRpICny581NAwsHCyyQI4OOnWgi4ln2YQFB0oxFFKVdVtI1H08qPdLnDuKDJoa2EKpvVL+AxInIZTqnhH9ZUJXjsiEqJ7kVH2modpqUlsRxdSmL70q4pwaoFv9cmYDyKjlXQmJpnqAU1MRVaQqTRb0M4CzfYLrqZJkkShSrUvVf6ul/fVNZe4o6btKa0ql1XRlWhVFEHjKYNCxwPCVyh1rSo3WdNUPHT11HfqqsadD1lIO1m4WMrZ68Bj76iFB2lej6UcuXe3YGke38BKBEIL3vX4vv/CJh/njh+b453dsqcBbeGnhZUuA/QUIB2F9FwS7YO8E3LerQMexmZ7eoHEJVvearA9W0O069vxZTDehM2pQSGPaJlhDVURL0DMtKI3SWdlE18+R0ITEgs3dyKHXMHTqOCLw2TxcIXH3smC10Bammbz8c6w324xV97A4dAwyf4renaP5ij3MfHmE3dVRNEI6dFkiJq0NoO1O0bozpGWDtLQbBisw6EHL65eP9aAyDNJFO/sN0tEW+uokxJBu81Us0+o4UIGp3TCWwBMZWJoi3rFCa0rC0gWwXKRbpFuWnGjP8HXL4cw+qSZgCzuRY20WDzbABz32uOPJcX412ksWGw2HiAx/o23yJ9MP0LhmE9YkLKMyHhOfXiZg2fd5pdQZJEYSomMhMdDJUqXFqSmNdCQDYZH0FoN9D6S8LZogg42DQZeQHBEpATp5erTIMUpEj008Llgt8DKqfy2agtkcTK+D0YNCEaIiSaEB7mXWRIw4NcpkYFJ1BTwRqFJxy4RiGRkK0EahPgmXDUqeAVLSGH2SiTN3UMCiQUKWlC4ePjFNOqzoCdUja2Qqf092YZXG+s0MRkNEaIwt6mz+bQb/Vceh0gG9hNZ4DKvXwy+8Ak5r6JUHmBhb43xi0WlYDF9o4mwGeBMJa7fuYuzgImkz4mKhhL2SUNr+OF07IqQLYgg9WMZePIHR+yqtyZ/n4mvvJPPZL1IrgDEk2bMgscuwlCiPmj2xEq4KS/B3V3JD5fj+E7eXWSXjFl78MDDR0ZGph46DjUuKSYyBwMZhDIchAvL4OHjYLJAhqhRgbxkmVmFQwA4bKm1wE8hKVTEiPfXyAuh1laGdrqmeWs0HAhA9SBzVk5sXihC3EyiUgFgR1gEbMiY0fTAGVf766jqkfl9dHgDTVRFumlQEc9lXZoxBooilaUO2AN2Gclc2NaVIxzEETShYMLgN5CVFci3Zd2U2+3FIjnKBTmMVT0QLvFiRZLffFyx0GEhUjBFNKOYUh/frqgInSaA5p/J9TQvGB1WfbzMLQz1VCh2NKGdqSyo3626gXqm6HC+L+J9nG0dhayzdwosGr9o9yE3byjw6V+djX73Ef3jroRf6lLawheeMly0BHg6hNQ/tPNx/OMvg8R6j1S49p4u/W9Ae1Vk9sBPZK5HYw+gyoVg/y0KpRLPQxUo9WjkLEZqkhTGgQOJsw/FOEyaXQO6HRgTBQTrFMQr2LKk7AYFGUnoN+XOvZSjZS2G9ShGLav2vGTtxmvawxFuoUepomP0on5AOS/YSUW4Pi61zyGlUn9V2SxmlBB1oz6lsWmsFojIUKqTDByE8T7S3A0Ee1k+p/N6BGlR2Q3tIuUfvMGB9B2jLUKnDWhO8eSBHao5y/+Ax0olRpO9CZwBiE7oOhbVhpjYktwXDvDHaThOLE2iY5HlcLPLZ7ffS2rMIMyXQO5BYiGWJrCwTWT7LegsnHiHGIkuBBhEhCYNUqCLoJRqifhy522HoCYdf2pyghI8kICHAxSGkh0aWhIQYB4lGiqRDj547CpkRaNSU26nWg7QDrEHSBe12aOyFYpe4V6AnPbINCbGnnKo7RdAHwG1BZhKSPejntzG6CK9Is5wdnqHVG2AkmiSmhoFDQIMnjSbLJY+kIkkKIfLQGfJnV4g2E6LBearhCcqt3TT1E9CyVUSK30OcfYJMfIwgHVVxSish2thpWlLiaZJcvcdQVWK3DTqtkPVwhGapi5ZrE3dGiUsJVjKL654jzE9A9zyF5hIjaxGT9TYP1x+m9fof43F9Cen53HryAp3Lkk5qMT4eYSaQqUuSBOZLV3hDGXz/0r2XYaTnFl68UEovaEgSqfeTf1Xhs4NDkRw5XAwc2gg2NZN1wyYaMEhHUhjwYHcBKhoM6WC3laGTaYPeV079SBFV2c/uTUPotVTPrxAqj9dMVKmz1AADDLPvehyp8iRpqQzdnKtKiuMYMo5SR20b0BUxXOsqF2dhQGgpMh2ienZ7ITTrfbfmRJVGO7YqhbYSpbI2JViu8jpwUkgDIFLfJUkUsY5CRZDTvmmYgTqPTFY56fdafRW7H5mkaeo7+qmKcPLS/nfXodNUmcfjJVVmraVqWctQ0U2pCV6ozj8R/b5gvV9CfhUrwc82jsLWWLqFFw2UI/Refv4TD/HHD83zz+/YxciWCryFlwhetgRYzuboregM0uRIo8cTFuyLExKR4eTeQ2jrl9A7m8SJA2IbycEdxO1FMgKSUgGn7tMzoKL7rOk5RO0Ew8kMI/t7HD/+GDJzQOU+tnfS276fZGURuX4Zeh6i/hZGmyU62mmqcplL+WPsiE9QaQmWDkgW/QrlcAxJgEePmDbb/RGq8yHRLVMwtATFCMLHYCMHVg+WLajkIBiGDR/WhmBDA/0S5BZgagckB8CzVM9XdEYR53Qb+oJDMiaglYOWhEwJyg406qA1ScYkGE1IimiNMsXedvYtZ3hjZHE9MEZAF8lfsEkVnQI9TmgnaZmXYNmAnqlyIHUXWYzBkljzGk4qyZBBJ0ODhD/QP0MqB/mF9AamCfjZWZOFlYTZQYOfWhniOukQkmDSJUOGiAiDkBCNBJ0eBlVqNInwiDC602ROxsTiAtHoMmxfg+FJqG6HcAMqEprn0VdPgnmQnt5hLBpEb6whrBbx2BFwhkHkYUSA7ZEYq7Q8+IqcpXFwleLCEabicSAli86GaLK44zTR5AKM5WDYRa8+itv2qAqNbPkY7TRPx11hUH4GaZn4J98Ge3UmTp6iKBLO3WqreJCxcxRHLipz2KSIqftUDnZoRy3OHzlIMlxhynuCuidpZbqQT2lkx5HZfRA0yaRPMLgekZ8F/zIUK8do3fIqkt23sO/i/2CsLelu6Jhhlng1IDVjkoGYhpBol67whuq3Kn7vG+753adb2MIPHwKB1u8BTkkx+n7POhYZcrgMUcEmS4xJC9jUDDYtC8YMGElhIIAdFVX2nEkUudU8lQ9up2DG/SzbQKmisk9eO1XIlsB0VDWMHininGhARjk5d1tqu2yqiGCUhVJRxZ8FgVJkNVNFBUUGeBI2upDLgW1CYEIgVDZ83FHlyV4b6JdDC00RbSurTLaSFJopFF1Fiu1EGWilgZohxL6KJvKDfmsPiiiLfv+xbas4uq6vlhk6qnwbpfbKvnQrQrDyqm+41gAzC6MV8DqKWBdslYNsaKo1R/RLxxPxrbJrmVzdvcDPNo7C1li6hRcVbts9wM3byzwyW+djX7nE//sntlTgLbw08LIlwDUtpR06ZE7aDFwOmBwWVG+VtPyE4uwM5a83CLZLaiWBt30Q0ThNV0LW89iId+DZOlIfolpZhvoGYjmiXGszPgnnbv4a/uKt0CxA0AMrSxIJMu0qfnEKmfGZnfgMZu8hCt0lhrIBWT3G0aCVcclcvo4huYMOGxxnhvMjjxMPeyTVMlQPweQGsAxdoDUBRgBWHQJLPXm3NRiLYEiDtbJSeaMdanI2Ktx8ro0AAQAASURBVKGah3YV4hoUXUQ3hCSH1swhuiWSa3sQ9Bha3YGwMtTNFpFeQvR0il6O62SGtxNykASLiBgNi4R92FwkImKefckAT7ZLDFQtkCaBEdI16qRFl23LEdOJxfXYZOgQ0eKPmOd+bYlEjxgIzvNuuYOfkKD5txIuJhSI8EiwSdGRtJBcwqCDzXmxhk2DGcPnoq7TMUx2+kVube6E5i4eMRucNy8gzCGc5W0ML+xkNLY5s/1rtKfWQA6Sl1/nwWzELd07MBplQlNAO6OU64kMaHmYyoDzKG0zwO0cRyYj7Ft4KwUkXQwcYnoEpMbDCPMCsjEOWCStHhvFPEavi9kM8IdnELtnKTzURDegI04RX3onzYH78dw1ktY+KBXR93+BqN0gCSRu2KaXc5kT4I0YxIVJSBu4ho+v69CdgF1TyOwUaB1E+wuUdJ/sihL2Vz0YCVosXXySUmGDV1zu0CnA8BsSWpcbaKvgZzSy1Qyh2cO0UP+/niu2CPAWXirQJakbE/cEMtaBPDEWwdMe0FkcyrTI0STDJUxargZlAXsd2O7ALhsmU+Uor/cUaUNAdRYKvjLaC5JvEVU7UVm+QV6RX8tSyquegpGocmctUeprEvaVTrvfd9tVpnsyBNEBZxK0HJgl1WOLUITUt6GnweUu+FL1Adv9+CNpqnV0oQyxmjEEdZU5bGiq1Hl8UJ13lKpybdNQKq3UITH65c1mPz5pE4hV5r3oqn7hgqbijnyhopySBNpNRYgNS5U2W74yGaCjyqkTH4odpZJXgbKpysIvecrUSwj1oCCN1XVJrnL5c4sAb+ElhqdU4Hf+nw/xJw8rFXg4v9XIvoUXP14UBPijH/0ov/d7v8fq6irXXnstH/nIRzh69Oizbvenf/qn/OzP/ixve9vb+Mu//MsrOmY90yP1QxyZ0mlrbKtpNHMx0zeEbD5cRfSgew5KQZVa7n4MP2ZKJoShYKBxltWwTCNJiZ2diLXzcLHH3HgRq9XCuGEWJmfh8WtU+e/GXlJ7D0lpHVmYwKo9zO2TD7F2yqCbaohizMgAXBo0qLnXs6N+LRoBVXos6SH+iA2HzkM6C+eH4d6jcMcMuDMY+jwx+yHtgqiBNghhTT3dx4HJ69XkRSuq/qI0gsESmKOwkodWSlxxYLCF7BRg2QS/CI08pXCEg6HF49oyC1MB0lqg4czygDBZ9Iq8t3cbr8YixUfQYxsRAR4OKfcLi8QVdNKUQjWLEQuE5mC0y+zoRewUGc5rm5zVN9kep3wpd4Eo0hBWStZPiIn7VlYJoNEgIAJymFzE4O+pcYaQBm3WRtYgN0uaPU/a2wXpbrz6MofqOqfMkMuDC1CXjG/cwC8EN7KTcXwiPn92lseSr9Ku6DQnHOLGANva+9lz7i5O7n4czEXQuxBqUN4OXhaCFYzWMmPDVeY3pxiJHXQkFiDRWTNStHyVofo6VbdJ1D4M5VsISpcIRleht4Flz1K2JNWbBOayJDnSgpM12rVfgvwGnL8GUVlh33WPUAsEdkeyPQxYlQF6IthkBMwmhlxECyXG+Rg7v0SQvAKcA5D+FVJP8FwLLRei2xCVILA1pFjj0Ikz7EzhvtdArwHDc1Br6IhamUyqMTrmk8ukUL+CG8pV/92+J14UI80WtgAgQBroSEwEsm+HJRFAgo6GQ446GQIyeDgkTj/nd9iCQQtKtlJ6rQh0T5FTGam838RXjvGW8Q+ijQJVOizMvulVon6OpXqlusr6TZN+T61QY7Um1c+6rtY3nioR7meqh6kqMQ4iRaLDGKJElUD3pCo71voEWTcVsRUoZTXt5xILoYhumKgYJK0fcZRKddw4VWq2QBFoQyrlWQJ9d3+kVARf6upBa4raPk6Vk77ol0QLX+3HDiHu5wtbKThC9RMXs6pc2mwpAm6b6rs9lQ8sxNWtAD/bOApbY+kWXnS4ddcAR7dXeHi2xse+cpH/sOUIvYWXAF7wofQzn/kMd999N/fccw+33HILH/7wh3nDG97AuXPnGB4e/p7bzc7O8q//9b/m9ttvf17HbSXQzsX0OuoJ1lRsM+OlrA3m0bUeO+ox3YaksCAZuxTwpAvRqsZJ63aKdZ+75COc2qyyMOHiJSmmL+lN7mZuZZZSvEZn7ARUpmGxAms/Tpo/Qjh2HG1pALlxjPmxR2keDYnMlLwPq21Y6OaQxR1IUcBCZ5gcUT6GsQD0BrQW4EAT8cg48tgEHGyRdHuQWYLBLHQOQseAw7YyVtkcBb8FhTnV+6pHEI5AawyqtpokrRtq4pZZQroZzCBDtGwj8yFzYzWa7TYNo5+dSw3ZNgjyPpctk4veRW6XkwQ0AMigcw0OXWKWrSVwl+iNuPS2dXFWh3n9wnbWjBZf2zHP1zMuSauK1BP02CMuGFDNsLs5yCuZJKRHFhcXnQQDDx+TgCV0PqqdZpWUWBi0dY1Ui1Q8CBUYA9CZ2BhmF0W+YSwQxxUot+gmLtGKzleNc9w7+k26QQ0vOwlum+z5SQ6u3ognBA2njYhryOER5WQaNpSLtDkJtIiLCRtlA7lkkkv1/k0kyGHjm4vYuTWchkTEGXAKOI378a2KcogNJGFaYt2chMGQin0Zw20RHZpD+8u3Q/UAqWFhTHyaVt5kvXw7zJ7lQLpBo5Yyu6dI5LwGwiqyeQlpQ3ENjmQWeDKYIzIL4K9BNk8jhOXpDfbHIZUzQBF0UWU5H/C1ArhVSBahOw+6mZLKGsthhmBlFF1b44pcZ55NubjKhZstvIQgNYgcLBnhIEkAg77TMBEGghxlUnKEZPDJk+QkDAHTGRh1oGiD1VGKptFSZbxxoFROGUDYVUZ7IlTl0Z6nSKMYUOOtTFT+rpcqQ6m8rcqgg0iVVYsEuj1VMqxbfSOqnKpE6Ym+43MO2kH/5UMtgM5T6msK3QQ8FAG2UQTY0AEJUV8hLqSqJFqT0OqqOKNyoPqXk1gRZj+EbhOymur1dVKQTp+sx4qbSqFcpw0DrIzK8I365cpRW/X9ihzQAXqQRym8QQBJBjKa+t5pUZFudxOwlCt23HfFFoa6LlcznosCvDWWbuFFBiEEv/76Pfzcf3uIP3lonpu3l2k02+wch1t2DqJrW9ldW3jx4QUnwL//+7/Pe97zHn7xF38RgHvuuYfPfe5zfPKTn+Q3fuM3nnGbJEl45zvfyW/91m/x9a9/nUajccXH3SyryrO1PBSqsFhKOX/bKOH+PSCybM6dYvfcPNn+nKQV68xN6YQD17EW3cU3HvhX7A3Ok0/abJrg5yFcOEdjskirPgCVB2B6J9T2w0oJNneTvThOKbTxxU7OPwpMzGHsqpEtzLNRDuh1JkGHnmPhdluUsNgVGjyhDUNvBNGZQWYGkLdYULOgPoIs9SDMgb4G2TWo3E72mzp20KUx3kMWVmHjtHrans+pSZOmwbqJyp1sQdqC7hpISUVUcC/sZmbHHOG1m6zLHsgC2vkiheVR/EQiU8H2sMA1soCJIAZCEhqkLCCoCpOz5cchvwbJXnIbw7xx8TDXpxanQ52z9Q26lXWo5mAtIXYGIXsBIylxS28XDilzZDkAaIRINAxMauT4E57gfGaByElVjrGugxWDcCE/Ddku+sYGN3X38woGwTO5J4joxAY7kgBJg8+791HXazBlU1zZzzXnJpju7WNTGPyf41+mnTlL1rtELwyQwRQM5mCzCd5DKmOzVKcptqE7UySATY4EgYtNqq8RxV26gKQMdob8+jLh+ACpvQ/MLkzsRpYOQ1KhtraI1PIwu420vI7W02Dn/cT7Zlk0fxKxscha4RA1Q7In+SZhLaZaeJhSawPXbtLYhN42CIcqxOZ28ObALsNMinNhno2xQVo78uzNXmDgQsKuRy+T3wGXx+ANKzDgwwIuy94QddpYMkeJQdq0gfZzv6GeLb7jKp+3buGlAQMHkQpEGBKlEolGDh2dGIOEEmVsbBokgI4udCJTqHQhTSrTKDuETAr+qjLMswPAV60oqQeFMrgjUF9Q25iaKoM2DEUWM67qwQ0NVZ6sA3pF9RKXA/BLyqVZk5AZBLsEcQ8iE1IXkjIEriLPywY0BWwG34o82gS6DrSyynE6DaDZVWXYtqb6bBOpCG43qx4IiAQmC2DqsDn3rRzgehcyArYNQa/ef3hgK9VbRIrYawmQKKKcEYpoh1Ip2gJ1TE0oh2epK6U47qrKJJkBWv3WnUA59FseDDgq2k9GEOnqlaZomgAk6dU6njyXGKSr9btv4SWNV+4cYPdwjovrHd77P471l15ispzhN3/8AG88PPZCnt4WtvBdeEEJcBiGPPbYY7z//e9/epmmadx11108+OCD33O73/7t32Z4eJhf/uVf5utf//r3PUYQBARB8PT7VqsFQPsumHpUtdCWVyTnXmMTvuJayGfAH2XiyfspXYTVRUj2gpwqsb79FRCOwkyZNes2tq1dRNgp3XEIXqkRR8MwMUbqXAtaG6YboM3D+QacHMUvJKwMXQb7PFJrwQ6LyH0bS36N4eCvmDTmWLBfRSF2cBDExNzW287s2Qb1Q6NI65BSGvJFyM+Ak1VPzJNFSFyEdQ59vkFx5o3c0nsFX2k/SeOnTOgOw0oH0gGIchBpGO0MqSZJ/RoMdaG1DElEdaSDvXwd9nIFb9uamtB0U7KtAndGB8ghKHV1bsRklDYb1ElJSEg4Rps/sWssj8zjj5oQTTKwJPnphcPM6R4fHXyczcx54tRV/WpeqvJ27Qg0m3jY55H6AmPR9dxImwIxCUU0bOYw+ENngceLG8Sxp/rBhNFXUFA9dZUOhD1SaXHaqHM61LmJaziaFonqm2wj4Zh7ifbQJmir6N523rp+DW9LjvIkHf62eILWyDy0A7piGHPtKINLB1mnSTJZhd4i+NugPAFtj2xthBHKaFhYWKSEdPMpUSZLR4RE0oKgQ80uk2pDUHXA2QHmAeiNABlk9npoFiFYgNuXyTS/RLx7hiC6A2PlYUqPn8DKGaweeTVz0WEOyEcxixeopJLmPGxUobltCDn2TyF7CNLPQehQOL7E5FKPywODeLf+FJfO/wnGwgylBFotKCXqFMIaLCYCT9oUMAhpsWTNYY91Ye4KbuZnUy62Jm1beBFAFTsLRJqS8tR/Sw0dgYmGqdgoEZqq8BV98mtqYGnKrVhLFDmVPeXyHIeK/IoAZKxckHUHVWot+wSzHxVk0C9xVh7UGIZST7WMyuF1hCKYaQJ6HvSsyhOOURFCsaM+DwzoSGiiXl2jf7y+EtvRoNs/Z9l3hha6WqfXz9RNUvA01QOc7RtNSU3lABu6+o6pVCrwUyXYUqC+hKVKoNNA9f9Cv8QZIAbRL6XWpSLXQvbNrRJ1bBF+S81NuzzNaM1+WbbxD15P5QCn/WuncfWOJ89FAb5av/sWXtL421OrXFrvAOpW/5N3HUZ3cnzsq5f5F3/8OB975w1bJHgLLyq8oAR4c3OTJEkYGRn5tuUjIyOcPXv2Gbe5//77+cQnPsGxY8ee0zE++MEP8lu/9VvftbxjQnMQhisQT0LtsITQg9Gbse8/zfBGmyUJ3VscmvkBUseC0Vsh3AHmOnLjFMdKLsLzCDoGA35EMdOlObq7b361D1ZTKH4dDg2Dfxtpw4fsEyAuQsVXmbTiIdKuyXrvKIX1B8AFN5XoGOjoDDPKgZVxHji0DvkSBJeg0QRzADarsNGBoWEYthCLRdz4AmtDj/HI6ii9jAEdB+wxqGRUru1CDrFhsrslaBgJq5OaeurebkKjQ2TqzA+kEB4Ab13lUnZtvLzPesvjpngSkwwX6PJl1jmAYBqdCj2OmXUWpx9m3DjFkj5GlO5lcrWMJMOD5ZM0Dj4BpBRmJ+FiTGu8o2Ix0lDlJnc0vLSIg0GZCIsikGcOh09nT/HokcdIEwFzPTDyiHYKeoIsA11TTUj9CKt5jJM7qtx7cSdhUmGFHikGDw4+Sm3/OdKGhNIEg/P7eG2ynxwGBnUi4wR4lxHBKFMrr+b6+JVcLyt87fgS5xbWSZNpzADaue00Mm1y6yUqZNFIySBp0qExoJGOjOOtW+r3lJEkk9eDOQjeNyHvqMmv74G8DLhgpnD9HvTuE4yMPc7s8jsQtXUGasdx5iziYY/8wjdp5t5AY+Ai/lKey3GEu7lCkhOIkRuRzlE18XaPgFwlHMxRNRyiggD/FN1ykeqIxs61FGcQigI6HuirEIYpPj4RLpGICKbrzG/jygiwC2S/z+faFexrC1v4EUEQofcDkJTTgCRGI0OWDJk+KRbEWH0CnKqy35INQ6YidjJVZMzylQFU1AW7BUakjK2iQBHSTAGIFSkOdXXfWwChMogiC66lyHUvrz7XpcoMNiXEedBdVW4cl1VwfTgE3VQR3M0UNkLl3B84qmw5TJTTfyvsq7cG2JaKg0v7xlyrKAU7EynFV1gwYEE96McyFdV5WAnkBPg9qPcgKYDRd7j2LaU46x3VE6wDdh5I+qXgnjKu0mLVRpIIyOag6Sm36Fy236/cgmBd5f7GjorpIwfxYr8HOlHl0noKnYhU1xTxjq5SFvhs4yhcdWNpFEW88Y1v5J577mHPnj0v9Ols4XkgSSW/87kzvO7AMC0v4uHZOv/ziXX+v++Y4uO/cBO/8ulH+f98/gyvPzi6VQ69hRcNXvAS6CtBu93mF37hF/hv/+2/MTg4+Jy2ef/738/dd9/99PtWq8XU1BTeUn/OUIKSA9qGBkenwdwH3uMEDYhcaO4pkHpZpGGA3wQkxsYfMdp5jI1xl8KmxBcOzYbF9Ol1PP1+wtE7oDIIfgGmp6F9DnbNwbE7YWAMuhWscyHpWps4EyBG70P0WjTLg1hPZBhqF2nhUSGDxOA6f5yTl2dp3TgK+RW09jKpeQOsXMSpzeBvboNchXRoF83VAzBqsHRwVrlAiyYEBdgYhjADKwZS0+iaAWbchtyKcqq2t4PdUX4mdgIjK6DPQGiCSEm2FXgiqZIsDhKLGov2BVrG3zLR3c4vyRvYhsPBWPDEEtSHTOIhB+IOZworLNcS8tUs8uw+dgY6P9bcyWftBVrlHjQM7GWd2FxFaEPckWi8mhZZdByyrJDwCfc8D++9n9RcAH0fFFNYAVlqQtZSysNoAJ6NyDfJDrTp9roMSkkFQUeLuFBYJyjPMipPsbk+TdSdpLiqY9IjoMCXzMsqSqg1yUB9D/8kehPXYZFH56boeubWGzT6VlwLHZ/P6ytMpRYlHCQRXRqk9IiNMmSPwOAqunucJMirCaNcVCYvFR16F0DXEYvHwcggHSDTQ3hnWdVHSM/cCM4FeuUS2s4WIgOlKKE5OsyFzFHwdiKsNsnYl4gsm7R0I9hVNam0boTMJv6rsvjhOrgRhF9HipDkFknYhl6i5syxgMoR6Bo9sidW8QMBTkJ7B7T7pYbPGc+mXMTPfVdb2MKPCgYaGoKYBKOv+UpAx8AmQ4EBDPLESHpIPC2BrK9IR5yqTF7ZVyE161sqpoiUwqrp6vMkBARojnJAjnp94iyVeZW0IEh5Wk31I2W2F+rK2VkKtTwpKcfnOAuiBGYe6nVop9DWlYorY2j11E3tCZCuUottG9qRIszZriK9Rj/Dl37sUkf0+3oTRfZzFlSmIG+o9dMFpW47EXRr6niRUGqwnijynjTV94tjpd5mLKX0Cg1sZThGiiK5UqplRqiMwywfRoehByQdtY4uoZBT0UudVI3vpqnU8TDuPzzw/pH/5/wj4bkowFfZWGqaJsePH3+hT2MLPwAenqmxWPf4P372esI45Z9+/Jv81ckN/h9v8JiquPyLO3fzTz72AA/P1HjlroEX+nS3sAXgBSbAg4OD6LrO2traty1fW1tjdHT0u9a/dOkSs7OzvPWtb316WZqq8ivDMDh37hy7du36tm1s28a27e/al12DiqHaX5tAe8CEfKpUtGyTbhnCHhgLdfRyA0+/HunFkK1SWD/JQJRgL7aIIkEy6JCMj7E+dwn35CbhqAWdDmybA78OjQZG7SHS7DxpdBfm7BRDs9vpGBE9zSe60yaX+yOSxjJRYCDIkhAQY9OjRR6dXReGeSK7DuUJzNwMYfwE0jYIxvJQyIKcwDAeJj0iSDstsEYQ1f3YaxkC30HWTTAzKiqpF7Ius4jMivpjKxwwDUR9FxQuI80i7FxDrK4joyKk26Cr4dkNzooG7ak66WiX4QuCG2WWvViEROyXGvu9w5xYdCkkbfRtx/AT2DQL7AkPcGT9JiLb5yulSywOPYzb6NJrX8OB3hC+WefitphGc4EosdAosYbBfzdq3Hv9CRKr0XcH9VUkSJQDNJVbWdRUz9nqKDLI0cx00YwxbKFToE6j4uMfaECnQOTlcQarRIUmi6HHZ1cD3pD0iLQMpnYErZ3llt4k+4g5T5NNQgbR+2Y4ATVauAgMu00QGcjIxwZCVKao0ynSywYQ6OTDYyTJSdIG+O4gSWmXcoiVs7CeontdZNAlGShCfJLYWSeW1yBaI2itAdq3RLRvW8eqzSODIhTGlKpiVJDZW/DKEejDqqcvXwVxSSk+sQ3ZKSjnVQzKygyIkCV7iDVXkNZ97HCFrAyoD0lqeRN3QlDoRGhA3bFImhrgP/eb2ey/vt/nW9jCCwyhanRJkZgYmJg8lQtsYJAlDzgEpMQorocVKnKb6krhlZoq6ZWa6mkVJmAoAqlZfafiRKmepqnGV/ptOBJFflO77wCtKdfkOFWkNwJ1s+iqLFr2ja+kq0yzpKl8pNopeEmflKfQC6EtoKMr92TlTKVaREhUqTKiT676pFJzVIawkagqFDdVpc7kwbAVWQ77/blGn3SmMSS6+p6aBKOv8KaJGp8t0S917sclabEiwqmEbqyukSVVf7EegRmCPaJKnWu++i56CjkHmv9geqLpap0Ata+rFc82jvIcPn8J4ud//uf5xCc+wX/8j//xhT6VLTwPrLfVXGHfSB7XNnjlzgEevFzlD758gQ/99HXsG81/23pb2MKLAS8oAbYsixtvvJEvf/nLvP3tbwcUof3yl7/Me9/73u9af//+/Zw4ceLblv3mb/4m7XabP/iDP2Bqauq5H/yUzsANCXRBdiC7SxI428BwCIb2cPk1K4j5dYSzjWDiMBR2gLUT5k/TCWo0RkEuwOa4BmGEEfjYQYQdhNSbM8AkbDQhOgFxl9iawqrMEh8/hTv7OtZGniS+fkVlJuY6tJIjaMMXkJzgzOr1WMEALiEGIcM4OCxB70lYXyMo7oWJARjdQIa7oHwtRG2M2RXi+V2kXRe27Wf3yVdyiy84piecL9rEDY00m2ImkAtL1HZYkNQgzUPGJNfdTtybxDu0imjdj2gIpKPDagN2bYJeojXQQO7xKWws8a8aP8mN/RCgmGUeosdDQ6ewoio3Ld3ERbFIa7CJJo5xOYC5sYjAXQLrLLm1DcSKy476MLdLi93hDfyv2ctcxKZKCYsKX8fhMSFIvAQyG6qEr6BD3lWTPU2Dibya/GUT2JZCd4B0ZAdp1uMv66dJ5qfwQwF1AeUSmyuvhjUJR1r0rpnlbwZTCie38y+CQ3xlbo4TlIjQ+CNmOV1cpj3wTQgFTnwI9DKhc5FMtE5ve4fq2gAz58a5iW14WLi4uI0BavUNcCSN5Ah2dIId9QZLfpv2/BCYY7D/UUjPEpcnwBvGrp/Gcs/RHrcgTpFOglwpwFduh71NwiirDHC8Fgx+AbTdMDhBpvt1gu5e0t41qpRQ74C7A9pL4F1W+Zm5EIwCVPaQdnXCQhmKMbH/KN3WeTSvQ2qN0pMVNjId8AJorEG9dWU3s9t/fS9sVT1t4UWAgADQiLApYuJiEmCSEuLTxGEnBiY2CU2ydDEh6SoiShbQ+uQR2Kgrk6mCrkqh0wgGskqhjPr9tWEIUaQqaXQHHFupriEg8kr1TUDV+WpKKbXHVO+vZgG6ItqJCY0AaiE0LejE0O4qE6yWCc2McoLuRWp/XqIIp9uPOPJTRYaFVGXPrgM5G0QdWgGsByBGFIGOmuoYeR0GK4CENFXfT/RUFrHZJ7OJqR7CiUGwusoRWzbUQ7koUq01Fn1yr0M2ACdUaQU6ULKgVlfXYdhSJNpLYMhQfUoNA5rRt5TnNFLGWFcrnm0chatyLI3jmE9+8pPce++93Hjjjbjut1+E3//933+BzmwLzwXDeZXddW6tzQ3TZf6fb9jLT37sQf7i8SX+91fvouXH37beFrbwYsALXgJ999138+53v5ubbrqJo0eP8uEPf5hut/u0K/S73vUuJiYm+OAHP4jjOBw+fPjbti+VSgDftfzZMBAZaFHCzDc1JiZSIns3ZHcok43db0Wau5D2Goy+QTkmh3W0U39FdvOrFO1NqgYk4w7e0DhUm0wunGPMTHny+hJEa1B7EuiB1UHLrpPuup1wZR/sSUmXl0jzF7DF3xLc/GZ4Moc8fzsZq86BkXt5YqrC+MzPcSQxCDHoEDKjP0R24wQBkqmVGxk690bOjJ6kszuCJQPybfyZ69FXbsW21ggiyXBq8mp2cjRJOVGrcpKAlTBET0YpS5duJ4+fm1BP8aMm3akaMidg9wXkuo8c2Q8rIezwEe0E1mNkOYKoy9Rmm1tkhoQNHARNBF1KRPEmVtohkhla1ZuIx86CVQGzSOx20VZOY7RreLbN4doUd4ejDBJRpMDe6CYWcRgBwr7qKmIXOmUYGwSzqDKK9RCKKVo7g5gJSfQSpA7sqsOcADcH2QZrUxt8c36eYjvHZldHbo/VJEofh5KA6CTRiGDjzAC7kgEu0eUBmmzQYdPp4Q3MQnYN052hPVoDOQ7RMoX4Artsn4XwAFlCQEfHJiDEikzQJ8AywQwJIod1/RHCIQvxsIUwhkivG1CT1bYHOdACHU1aEO8G7RLccAa+dh36hQzJ+pgq/ZvehCNVVQKp7wHzBJWZdTR3jdW0ReTmVNiv+RBEs+DPQaEEQQzDE0AC+bJ6cFCYUu615QKp1VEmOyJQ8SV6HboZjKhxZZV2z1a6dxXPWbfw0oHoa8AWCZKYGB0HHQOBIMXEQMciwSYkJpAaJC5otiKOtlBlz3HUN8USKMaZUVFskVQkLg5VfJFIlEKqFRWR7aUqwsjQIZNRlSshKiLpqXLoVFdlwHaknJJjA9ZDaEv1ahrK6KqFItap3u+LTVUJcRJAoCm1VGhKUTVTpczqffYUhip+iVQZYBUMVYZspWBL9XlbV/FL9DODnaLqm+h1lUu1LpX7Pj4QKNUbTSnecaDKnS1DZSOnsm/+ZSrVPPLV9dQdFRuVpBBZSuEWer//V+tf84wqr5Zh/1pfpf2/8NxKoK/CsfTkyZPccMMNAJw/f/7bPhPiKmT8VxmO7qgwWc7w/7vvIh//hZu4bqrEa/aUue9Cnf/0ReXnM1XJcHRH5QU+0y1s4Vt4XgTY930+8pGPcN9997G+vv50GfJTePzxx5/zvt7xjnewsbHBBz7wAVZXV7nuuuv44he/+LQx1vz8PJr2w3d9yLsRoQP5oRSRh1S3lRq78jhk74Dxt6in8bU6+AZi5nNs/9s/x3UD7BtUCkRtCHALYBZZEzZeyaO352fg2DKZtftwpgLqg0dIiwfBGFamR9sdWuk3EGZC3q4RXlxALrwdzf8cxcZF8l7CQPl+1u1bsXtFTPK4xIxEh6hr55iu7eX10U9QZphr5jPcvzHPMh7BsCA0AddH8yvQNtGkIE+Cg8G72MMyXdaikCexCOmQXdzJiZZG/ebHoJUn3StgfBZ6ZbBvhsQBw8NpR0zOXsOSiElimyhuoPkBGhHgo9HCxeZWDB5rTTGRmAyzjcecIcTGNZhxh1yc0lvfJJ2yMfwche4wPxdezzYkDikJLSzy7CYli01EikNKXnbQfRd9bhdOw2XnhseaFrCydwZjYYCdF3ZhMMDZiTViaxkOtGFoFJYh1RICPeVA4tKo59m0TBjrwWhDmcpow2hrFgfDHTTwuY9l1tEQpo83vaYmkpmdRLkKRFNgrkK6Sb3m0K2Z3Dj/WqaZxsMgIgYkE57gsnCRSR3cBugD1Py3w+ObYFaQN18AsabUFr0N3lm8ssCzr4H1d4D+NazKnxDeIuHJ6yEfK7K+awGcL4DYC5vDGN7foa3HjBbAsE4zM3Qn5AYheVgpL0EZsbCELGRgKKdKoeNNVc4Yb0KyDBm9XzJpQQXIhFBrw0aC6F7hpGOLAH8Xfpjj5BZ+OBAIdAQ6CWmfAOdRWd6iXxatYRHi4BPjS0314Qq77wRN39jJV/eP0JUKLPq9wWGoTLCSniKcMlTRSHpR8bZODI6hiGE+A40UwlRFIuEoQhlpoPfJaZQBX4c5TzXveyk0bNXr2xR90qgDwbcIcBwoYhybygla65Ng11SEkkTl7xKBZygCnTegJ/su1xKasXLoH8gpEi9TGCuofzubyizLEODk+mXOnupFRgOR6bd6SLDNfvl13x0bS5VQR13QTCAL0lcEOOg7VgvZJ8BCjVuOq66p6KvOIn3G3+1VgZcpAb7vvvte6FPYwg8AXRP85o8f4F/88eP8yqcf5Z/fsZNfPDrGVy7UuffMOgL42M/fsGWAtYUXFZ4XAf7lX/5l/u7v/o6f+qmf4ujRoz/wE7r3vve9z1jyDPCVr3zl+277h3/4h8/rmGFOspgDswe1joXnHoC2C+e/CpMZMA5Db1BNHoLLlM98kcqCSTQUoy8lGBlBjETfWCBxbsAbOIg3oUM1x8TS/Uyd8wjWQ7oHlghverNSD+05WHwEpvLIaplNq0j2oRUyqy7t6Ro5L0R4gvJAnaq2SIdDZEnxsbgheTMj63uYlkOMMkqCzxTjvNsbZZkl6nNNzpk2G0JjOe8BJq2kSYOAYSxMTLZjU0Ajj2AeQQmHBSuhbjYRl/ch7+yqfrPlnJqkBZvogc0rZiYYZRiLFfTA4txoQJAKGkjKaDhKwuB6Yn4nPoSLzToWXt1ilRKW7JAjZaHqshSOsM0/w8+EWW5EJ8ZHw8HGwEKjg0GKIMLEp4eNwdBSntfP72avNBmkzedFj7/xukQ7L1A3dnJww+R82Yd4DbIFuDQGy3kyDUEmNRghx6tb2/nL3gpp5EDBhqSHtrSMsRoRAV8Tqzw+soEf66rvTbbB8UHrqTI/auAvgBaRyiJTi7t4c3IzApM2ITEJCZIDQYEnji/RftUaLJ3DiAMS7VVgGli7vormXMLzBjHDJrFVQqYGWX+BXn0YcWwYecPNyNZF8t3/g3T/fkJrApHR0Gon8XM6VPeA2ySpX6AXAR3wJ1PIplDsQGhD0EHzPDKyS88cR4ZZ6Pn9iboEbwkyF5XxjpGBdLKvzFigjYCdI9JC9Z2fK54tvzJ8XrfpSxo/7HFyC88fAg2BTggYGFi4CHwgQtAlR5ESZZT1m0RgEGISPqVWWgKyfQXWlah+2nEwGmDMguGrkt5MRhHaXp8UGkKZUYmwr+raKr4t0aEBaCWo5KCqg68pspvPKoflpVgR3tADLasIpZ/CcqAUYy0Lyx0Vh+Q7IPPKibnqgRao3mXpKmIem1APFYElVn3HugMTtiLbeqAU4ZwGEynkDFUtc2wDBkz1mg2V0pwMqCxjW6r4OWygn9cbpErVTuw+IU7U95VA1IFYxUwhNUXC4w31oFU3VL+0HqrzyafQ0tX1oqMMt1xbGYJFAXg9dT2uNjyXHOCrfCxdXFwEYHJy8gU+ky1cCd54eIyPvfMGfudzZ/ipe775bZ/tHHJ5w6Hv9vXZwhZeSDwvAvw3f/M3fP7zn+e22277YZ/PPxr0hqC8LtGHNR44ehNyxyFIPeyNZXJrH6K+/1Wk9bdC5QBa9y+ZXJjDiUdoNVZoxQl1yyFKXQrVJvWBGCrjMLMHkoTO+BS91imag4KkMAHRJDwMaLeCVUH0LrErPEZqp2yOmmQXssQrr2LWnqPgLIMXMdLtIojxKNIhosw4Geny1fxlSt4mN8QFBvFJEOymxFk2GYgyZMmynjaJmGHRbvOEV+YoQV9ljRikhEcXG1gmYl3zESemlJFUAbgwAXMdZYgiwGjkiDCYR2eECjYO5ztdlg2LR6nz4+iEeAh8eoRk8aiQw2Cdd8o8xynwF/oCp9wZBjuT/GprkENMUETQQ2JjEGMQksEkxAAkKQkBGUKmqXM09jmCJEvMAhWkTLGbe/Fdg7XrGmgPZzhwbpxTjkesF9GeHGBb3ea14XZ8ckg6vCMd5Ykzg8wMdJR8HxxHW6lyXe1VGOS4TwvwhyNkZg0WdFWmKHJKFWERnDasJKAXmJo7wM96/xtFBkmAlAjQCXBwcRicTfGunSWzuYypJeQn/4rGmEDflPTWJBCj9RKM3AZRwyDRdNzHd+EXfeTOrxBxALJlBhdPYYWPkjQsGs0J8H8OrDJW5eOUuys4ZVgq6qxODeCuPEK5FdDIaqRhwKATU0uKyMHroTCqFKDEViWQmgFRFeIm9DQom6ofMduBTR+CNow92yzsO5Drv7bwNK6GcfJqgip/lv0WSvltOcCi/zLQSdGJ0dRLGKpFQBrKsCrt/8nUpSrdlbq6n0TfRVmoh4EQK1VTN5SBk94v740NoP+wCUctQ1cGhYnol1Br6mffgHaoSG9qKeNjD1XaHEt1DlEMQd/9WfTdoxOpvpjsl2dLqfbXvwoIu38eumqR6KHOzxCKgEV9symkUnd9vW8+lajeZ8NS+04T1e+s9/0YJP3c4+Rbx0KoayaFMryKRf+iG2q9OFFkPxFK4TWMfjSTjzrYU8ZjqM/TVP1s6OrYV5sh1st0HE3TlN/5nd/hP//n/0yno7Jk8/k8/+pf/Sv+/b//9z+SKsAt/PDxxsNjvP7gKA9d3uTycpVSMc/d//NJLm10+fuz67zuwMiz72QLW/hHwvMiwBMTE+Tz+R/2ufyjYu1tGr6A9fHt9F7zVgjyoK+SiepMnt9g+/xfccbZpPeqD6C5NdppQo6IbJjhoh5SMT0CmdAolDDWHyJd3yS1ItBmae7bw/HSzTCmg1lBe+SL0PJg860U6rfQvOYUQp6jHHeIti2x2fifHDjzT6kbI5wUf45pPEFOapyhxzYyhJiMoXFWX+D0nXXE7ALnZlxu7O7iiNRYFSt8ZvRJGrkmesMh7unQu0R1d5f/ccnhVG8nr6JJjgLTRGRxqKHxJBtomw4F83qarz0P8xIWjqsJVasCwwaOV6JDjgaSSVJ6eotopE2YGjy2cp43J4cw6OATkqJRo0KLQVw65NF4UDvG6fEzpMM22dMXGfagRI6ECB2dFEmMg0bCCi46CQ4rzLPEGYosi4RrpcEaMQtIInwkOjdsmHxzX5G0vcjGmMvOswUmzh9k3m+wvVbg56Od7MBgCSiQZwSftyxMc09pjqjVhXIFhnYzUX0lT4oGx3d2kOPLEPdgSkBzQJXklVzIbQc7AG0Dcg5jVBhjHJ+IBJNlVhGUEGSJMZhojLK8YTNgplQzgmZGo9kehKEuCButKhG+ILILuO4mfm87mWgaf/cDjCT30e5uo7Pn11mZDyFdhJ4NBw/C4jDa0MfJhsfoOpJaqGFlJdmNGq+/GDC2BPO74etDDvWwQndkFwzsVfnP/mnl7KrnVLZokIDRBq2tyi71QQhyEPTQspcwdO/KhIZnUy6uQufSZ8PVME5ePVBkzEKikyDxCJEkGKRkiNGJiMli42PTwyBAI9JMcAYUMe0IoKDckc0E4g6Qgu0qMicDFSsgPOVwnKBIqWEqI7r/P3t/HmXpVZ/34p/9zmc+p07NU8+jpNYsISTEZCaDiSfsH9c2JPZycu1lJzeYXNshccwyNlkeWNzYXJNhYTv+JbaJ8RiIAAECgSQkNHZLPY81D2ce3nnv+8d+W1ixjWhZ0KhUz1pnqbrq7ap9jvrs2s/7PN/nkba+XuX1e86uamIZJZAv6PeIEUEnswPHJrQjHVIlPBgAXalrcBIJUahTmRWaxMKzzWUiMhB9G2np9GkzgdTLZmqdKgRKdwb3V3X/blSDUja3m2ShWakET0EkYGBqsuooKDlagVYJJG0oKk1IJdl6InCSLCnb1pZupL5ugF6/IHstUghNTejFAJxxyHmQdvWNgMTWlU5pBPSzGiSl0/9DpUn4VsI3owBvwb30fe9737Mp0JdvGH75y1/ml3/5lwmCgF/91V+9yivcxjcL0xC8YnedfRWo1+scW+7x0S+e5dfvOclrDoxv26C38R2DF0SAf+u3fouf//mf56Mf/Sg7dux4sdf0bcHK24+wEpVh7AB0E3B72AsPUJUNVmowZknSkg2JgSsl5UKKJEaVhuQNGDWhpQQqlsg4ZlI9Tds5S74bUuw4dONZwtwMftBnx7EniMuKtXiNau+38B7JsT6TI5fr04wtjPFPctE6RvnkP0O4IwSFI9zJtUzQxSCHS50QwURaoXaiR3Nfk83cSb66GLJreYZ7Rh+jlV8Ef4VkbApcByO9gPQMevk2X82t0e0d4jWRg8BiGo9lEhIE18k6RyclOBdhowlqBeophHsh2U1CzDoRgRgSKcXp+gXsLtgbU6yZEWFqEaFwKNMCPlpY4PTo5/ixhVt5o5xjIbeGzEvYXCMsVTD9CidxWCfPbgxmCJD0+ZwY8j/yS7xxUOUGXB7D5NNek4HTY9iHSPqsEbOfaXbiskOO8lhnhcBKSZwmsTHJD3X286lnutyd2hQJ+Ti6B/ithETYvEVOceaswWd2xqRDg8rGHBeQnB4/S7zrEjQWgboOn9nT0aFS0TikLTB9TEJmLs1wJDiEgY2DxyoN/rJyEpnsZTQa0rIcAlnGuP8NdK69SDheIPJ2w3BdH9rsSYzBgJFwnV5zgD/vIdfmCXJD0j2n2AgFabkOahXys3D2Fp0GG9kw8Qw7+vdRbSZ0DJCLEmsAF68rs0yXqXrIWA3ifB1//nugMA+rAWL4l6jRLoy8ArxBduBGzwfm89r6WBiA70OcYgQpuZ3DKyPAzze7doWC8lbAVtgntwyE7pdNEwEYmEgKODjYiGx+X2HQJSEkJUDoNGhlM0htGPahH+sbYkJA29AdtuYQbB/CWKupYaRtvsoF0dUBWn4O5EDfeCqNaatzpGBtCKUylEu6oz1U+vsOhK4n2pQQlbQ7o2Vn/a9SK6ZDoKMgKemZXSfR7+NQgTRQhkQ5PmbiIBQYJKjIgdikHPSJpHYrp139Ow4RQQtNVhNbO168WM/zIoAoe4+bOvwrh1ZrKQChJqjK0iRfxUCsK5WsKrChZ4JjS1umbRuaA3TVk5fNSgtIchC6mvznJyBvgZvoAKw41aMohtA27jjZeuovfHMzwFtwL/2DP/gD/st/+S+8/e1vf/ZzR44cYWZmhp/+6Z/eJsAvYfzUq/fw3796kZNrPf7i8SV+4OZta/s2vjPwggjwLbfcQhAE7N69m3w+j20/95Zks3kFs4NXC20XaoegWtU2M3WC+vJ9NCcr+FVJ1y0SFm/Td6TXawx2SOy4QdmVDHyII5DNBIII5XukQR/h+pCCHwZY5iLO+iUG5R0MRQ7ZSVHGbsAilA1Mu0fkCd33mruLdOwB0twvYc9FmE++jj0U8LAZEhHTpUCJaYq88nyOe6arJEdG6AZ9/qL3MBsTD+NWLyAGPsEa4BYZnWjSXfIJKjXSio339H7G8JDAKQY0UbyNHOetIoOdJ3Slh1KQFCEa6LvsTspgvEOwnpJOrnKiGTLMNcCUCOUwEVtIfBLAo8h5+nxtt4+14zwf79uoxjTVYAYjaGBVarx6bYqTtsEf5ZvMdDxeRZUC49R5jC9ZEcfnHmd5rc9rWz/EadOjY51AeU/y2EQe51wdlzkOpWO8kl2Eqs2Np8f42m4fb+jyxmSCNzDG7rTGadb5r1afE8Ul3MilO6zx44xQIceP9XdwbKVNw/C4u5HiG0s8ue8sdM9C4zCMmdCz4WIMox2YdHSIS3+BiUvX8yr/ZkwcfGJsLDbFgMXrFomcY1xIdkFuGuHPMvvAARorbyY62AD7CEwONan1TRLbZaVYxFGPk1h7QM4R7H0MZJ8ED4yWPpAeGkJpAwrHQVRhMIYlE3IdSJ8RyF2K1XKFeORmHjmS55mFNtJ18L0cIljFXXsUKS9RKDZoFSZh8xS4VW3VHE2ypNpYWzgtCfTA7uAVQyJDT0N+0/gW9AB/5CMf4Td+4zdYXV3l+uuv57d/+7e57bbbrvwbXSVsiX1yC0GQOXez2VEzszzriV6BicUQSYQiQaAwMgU3s/4aIks+Ru+PptTvG1NptROlVVJlZHOvYTYzC6SJDpiycuhUZaGJrLK0/ViaWtUNhbYgR2i7s7K1BTgU+uup0PPDafZnlf1sEeuPn/V1K4RINflV+u0npAEIzDR6NgqM0NbqbYKubRJ/wwadCAicrEIpy4T3hLZ1W0I/EqF/ZkwWCGZm3chW9or/DYVW2frrBllXsqkJs8heW2lmr5XMkumzPmOR2bul0B+Tvf5bMQvrW9QD/J2+lzabTQ4ePPi3Pn/w4MHtffIljkre5qdfu5d//79O8KHPnuJt10/hWubVXtY2tvHCCPA73/lOlpaW+LVf+zUmJiZemuEucRGqRSCn7zy3H6NR9JHJKGlhhriyD8QNEJhE4QRmzsDaKfEimOjAxRXB8MAOGN8Jl85BY8DMuuRiapDLS3rFOqlbgHqB9R98K+bncoye/n4MJSmkHoPY5YzcS71xmsHNXULnABXnfrr+TpJimRNikX1qHylwXHRYLpzGIGXn0KR8zKM5HEUam6weOAo5F+nsBBZgzIGVHEpZSG+WwtKdzCxM8ZboMAqTp5HMkPJ2DGJGeNSQyNx5GG5AMA3TBrRr4E1ArQfYpLkUxiS9Wl8rDo0pqo7NmwcGMstrDpB0bJuovky6Ibg0vsJvJ8ewjBEKK/PcveJRUyG/f+RhOt1DxL0uY7LIQbp4OGwWL6E8n3ahyD3yr0nju1CVSxjWJuOGpFNNqYe7uKlvUmJIhZSfGuzi0acNhoyymwprJNSRfIUSZ8urJIfXSE4mfLo0ynizyz+Jb6VAj6mBz+L4YzzgjeFhIvMScbqI6EwixQYUC4h2ATV3EQbLMDKEfpNNw+UTs/eDdZZrFg+xP7mTBdXBO9kjuukJ6D4GozejkjewOpliNg5C5wlQ90BpF/R2avUn76OKRUK3APlJGPGgchTyYxAN9YxdYMJSgDC+Ru3cJ0mLLr3SqzmXfy298B7SyZDBbJ3hgetATqFaN9Iv7YKxEMZalD//m+wdnuTMNdDNz4M5AeE5CCs6LbbnZZ2aDX1w7hYgbsOGDyMRSSvH132V3wQKfOPZtSs8rP7Jn/wJ73nPe/joRz/K7bffzoc//GHe9KY3cfLkScbHx6/sm10lbIl9covAUBZW4pAQoLIbOwoLiU2IiYVHiQItJCkSMAixCCwJo2u6hm2yrt+/pRCKPkzYujpMJFAKtB03UdnDBL+ehU1JPa9qAFyuSrJhckarrx2lRxLCVL8npdJM3TA0Cb5sxegnugdYFrS6Wneg19Rp9ZEJpq1dJv1Ic21MFCk2BjVsnUNFygYJkMOgiBH6KMNEObb+/mkKdgCxp/f6KA/+AKxQp1DjwJSnQ8GsAPyebkFSHpQiTfKFhLSsQ68G58EogFHWqc9RW4cM5oqa1A9Ap4dJfeM1dvRrEkrdST5MtEoulO5BVxHIFDMB+ez/yS2E59tHYUvupddffz2/8zu/w3/4D//hOZ//nd/5Ha6//vqrtKptvFj4x6/cye9/5QJLbZ///0OX+Im7dl3tJW1jGy+MAD/wwAM8+OCDL+2NKVaYTz1EYXWDpJ4nMg0OH0tIxSonD44T12+HeB/4MfE1r2Pjkfupd0+SDCQygfUpCzVaxjkTUT+zTLNYYVK0GLEl0QZ4w1UGO0ahMoFyvhtLjuNKj4Q2lqzSbU/hBZtEm3nUOR91U8ia8XZY1mFUX5vcYNfKFGfMIV/dcZZYroFncb5kINspYimHum4FGgq6IaocajWiPELumTk2Z6vkommuHd7AJCnH6RADT3krxFGV18ppTuAiZV83WNT0fJu3OE7s+6Q3+NDrQmUSRF9X5Kw4EObIrdfYlSTMIjAwEMREDLkofMRghbhfxAsipH2KZOo27n56FwUC/vjA1+iMA50YRJ5xBCMEPMI0F501KHRhOIIqnyKSj4Fr4ETQDyzmwxpv74/zJWPAmrL4QTXOBF3eLnfRwSEk4X76KCyeyrUIRgbg9WHvIpEX8+njPW5anWKeGr61iUousla9ADP7wOlAKcXciFFrOUoLOXKJYuNcEemOaxXHmCCab0H+NEZ0nKM1wfnGHgKvyeHNvZw869Kr9KA1Ar2Q+EhKPNoCsQydBka3hZleIpav0kmxzgjUCtqySA9yfYRfoLC4RiwtwptasH8U6/wJpoKI4SChf6hL2n49q5VNuKYDO2fhYhOx9hRsXgRvCjU+h/fI/UxeOM1mDuK4Rlq8TVsR+5/NDuMOGFP63BmP6rlFZ0orONMt+vkT0B5yRQT4RbZAf+hDH+Inf/Inn+0D/+hHP8onP/lJPvaxj/ELv/ALV/bNrhK2xD65RaCyEED+RghWomVL8tikQIRFnhxDBC26CDwsZWvFFUsTUiH17KuMYGhrW68dgsj+gSdKK5UYkHO04nlZGRVogouTBWeprKLI0iqvVPrvoTKb70DPDgsnI8aZshykmiALSxNtaWllNAACiZAKgQPkyBNgIwAXqZOsqJDXCdcoFI4OlooiPXNsZfO/ptTzvKGviblrQM3VBFtJfRMtTbWCbCb6uQ18MOIsIGygyaoo6+clJRBoOdp1oJjXs8We1EF8vkSnLmZ9y7YB9kDbo2Wse5fjVCu/gLRSVKquyKTyksC3wAL9UthLf/3Xf523vvWt3Hvvvdxxxx0APPjggywsLPCpT33qKq9uG/9QeLbJ//Vd+/iFPzvK73z+NO+4ZZaytwWH2bfxksILIsAHDx7E9/0Xey3fVhjrKxx68jhGLAkH4IQGlSXBhiWYb5zg7JvaOvDDM2EwSfPW9/GI9xnGeveQv7RBMlXAGK4xFz1Na2cN1fAQooWY9Rg0a0TpLhjeDs3dcKaCecljJdehkBrU4mkM5xrqub9kZWQW5XVgYzeY+4HzCP8CnflL/HkvxfM9Rno+ayM+hDXSwnnM0ZPYe0KC4k4Q6xjWOsxGyN5BeGI/hfhaRp4xmAhrzGFi0GdJLHJyImTzSJe1UxdRC8u8Ib2ThAglTBjbibkoqDRgfWcHioE+XPRsffjpObBZg5xFMNGhstJjTO5gSBeTMhJJRwWMqphYRUSjEqPX5M3HE6akyX+e2GQwdGE5h9kTzKUO8ygUEQvkiWVFVxgVFghsBzY9MOZRvd3cuezxSlnnr0oxT5SXUX6V87LJXV3J26WHpM89dp8/H40p9SZpTnRQRQHtPBQ8aAzZzDt8BZ9ZdnDdcC+njQVi7ymKlwS+miHat0linUMMBWMnHQJsZK+EaNRQpoIbehAugpcigzuJxE4SPG7x93CN8qidHeOLow7RTcCeFOwExnQQjrnZxxMDSskKnTjCT16niaeIdTXRjhY4BtWLX2Os5WMEcO74fURqnkQcYHFiwLA/Qbr8NiiHMLcTu3McsXSKuJNQThaxhwmTkcnFMyVGV7pU90hOTRcZ7ngj8FqQG2DMglsB6gi1gZecJnFrxOwA74i2KJa7Opincf+VvaHMVD++0deBbrf7nE+7rovrus/5XBRFPProo/ziL/7i19+vhsF3fdd38eCDD17Zuq4itsI+uVWgkEgkJmQ37USm9KYIJAqBxMLDJUTgM0QhMTAgzVKMheRZj7FMtRosRaZ6ZpbfRJNsyOqPEFk6chYSlURoApwRYsPQZPgy8SXr6UVpkm2S2Yo1WUcYmnxKPdOsg6Kynx0rRCCzpGsTcHEIsRCAhcJHICngASYJihQTJTPrtjT184kvE1b0rHIkITJ0J6+LDq5KszUkFpiGXn6Q6J5xCyDUH5s5SGO9fhHr52NbkHe0imym2n4dG/o1MNwsNCxLzrYMbR9Ps8Rppa3mypRft5dvJTzfPnr5GrbWXvrqV7+aU6dO8ZGPfIQTJ04A8P3f//389E//NNPT01d5ddt4MfCDN8/yn+8/x9mNAf/5S+f4uTceuNpL2sbLHC8oW/7f//t/z8/93M9x33330Wg06Ha7z3m8FKBWfXqLiiUP+l0o+JLBoIJsFOBEAA+c1L/A15r6ULO+g7j+gyzf+GM08nms6hhy6jVcmLmd5sitjPc2WEj3sLz8LwnWfwW1/j68+34U509ugIsOg5GYaPo87cNfoF25gOnfQadSpXzHJZydi9Cd1EEr8SVGmw9hbTxFY/5L2JbBD228mTFZh+oqoicZHTbI9QNo2HDhZmTtnUheBdEbobmfsJjj1mCCohpwzniQ+6p/wEO7n2Zz3xCSowzMe/nM7od4WiwhRU8fLPqSdKTB2s2LqDCCRgGaRegYsFmB5XkoTEGQh5xi3nDxsJAYOAhcTCrKI+kY1AhJOyVKnbdwc3Idx5wBA6+vSWFcwejksJCMkeARYtEhyZ8Fv4eZdqBVxFuYQWxMcGjjVn5IXo9DjTNOShpayNF1zteX+fP8Oo/h8D+tiP9+60W6BxdZes0p/N2bUOjooBTGQMQEozH35zd5jDbXy8O8vft27lx/Nz+68SZ+8NhtWJs3QOcA1sU9LJsx6yJBUERVCjoUrNiDsgX9m6DxSpzOHHtkietVhaNGwLGaJLk5hKlYzwx3BxBqO3M6sofByDQtL0+xchqRPgRmAJPzMCJ1p2b1JiJyiCaQM0nGD4DpoSZuobP3bcR7XgnzOZg/QWXxMW5+8iluunQWw63QLe4mmhSEbsqBsy1m1lIWcibt0Vtg+k59aO5a+qE6mO2nmHzqXiYfO8t1Jx7Fan4Nuk0o5KBfh9x+qMxf4Tuq/008YG5ujkql8uzjgx/84N/6Tpubm6RpysTEcysTJiYmWF1dvcJ1XT282PvkRz7yEXbu3Innedx+++08/PDDf++1Tz/9ND/wAz/Azp07EULw4Q9/+G9d88u//MsIIZ7z+Lvm8LYCDMBC4GHj4eKQx8LGxqJAkSI58jgoXAR6b+s5ko6TaAKXtCHegCTQ39B1dYetMYTxOSgkYPUh9DQpM2IouZoc9gPt1Gmk0GkCoSaStq1twcLW1te8AMfOlFMJpRmdPL3WhWIKuYwcWQqsGMyWns3tWdAfATuPqli4wsTCR7HKkIgBCUOGKGwEHj4SQUgOHwj0eoOiXodpZN3FgCv1WnwBHU8rvUaWwuwI8LJrHQdyeSiPQb6irdg5F1xLZxkYUs/4Jjk9H00Cvb5WjEOpg8PSBHKG/rvq8vx0rIn4ZULuocm1IbKwra1YjfPN7KNbay+N45jXv/71DAYDfvVXf5VPfOITfOITn+ADH/jANvndQrBMg3/1Jk16/8v951nvBVd5Rdt4ueMFKcBvfvObAXjd6173nLk2pRRCCNL0O/+2rLIjVE0xtQyL4w5Lbsr4Ro/Ul6ieAyPjsDrQd+w7PhRXYeM81onPEY7HuJfWkI3TyPUQ2z9Na2Qfg+bPIC7OoEwPt5VDVTrEu+6FmfNw7iCILqr2RVqFHhMP3UXvzFsJOo9Rb7wCp38ti5UOyp6iHZZITMippzGjV1OnxuHzb+SB3b/NtPll+qGkt3EY0duLle4l3WGiZiuoDQFmi8CLkP0qFTp8df//Qla6pMvXwnAZ5iWi1yMaS1GGhZlv61oLUQfHx3nSw/ItQqtNWvW0Na3rQT4E14ZmgrtSpJ54dIiQOCSkmEhuTHL8z7V5znsNas27eU1yC3WGrHtDmAFUAWKHVMSEJAh8JD6R6CDzLRikuk4zLBEUpjGYYG9oU6ZNj3FyQY/O3DrMxDhn6sz3XR4h5snxTeJcE+I8DI9CZz/k+pq40oUREwzF4pEBv3d8BcNuY/RhJpjDQHB9VOHeM2dZn+uRDkaIizKzJ8ZgN6Fgg+HDaA0u1ClsFDmcTrCTiC/ZHZ7em5C8ogCzka4VGV2GrgCjou19dhVUmTAXsmlFqNTA9D5Nau7Sh8+xXdBNMWoeqgYXpqrIwj6YtMFdhI0HMOprSHuG3MIidzU3OdY7zHJuN8XefdizMe3dh7iwonhl6xnWJgUb+2dQk28AMQnh5zEXvowTLOA7t5K25ymtHyMPhC2F3dxEuF8g3vEusMdhZRm82hW+o2L4hrnRMQALCwuUy+VnP/u/KxZbCS/mPnmlc3zD4ZDdu3fzjne8g3/5L//l3/t9r7nmGu69995n/2xZL+hXwnc8pMjyo5AolZKoGBcHMIhJiYlJCHEJMnXYQ6QKA0lasCBnakLnWpATkLd1crMR6rn9NLMv501NzJSCoa/nXFMLXE8HO0lLkzzT0nurymy8EZmtOMos1grUUN80zCkdSiWVZvKxqcOnMLO/A6SDTKHOGoZIMPCxKGMjcDARWnJGYAESgzTrKSZbgNI3fW3Allktk9C2ZSMBP87Cr9Bk3RNQLELSgmHWfyyzhxkD6df7fZ/tSc7U9MTSIWAx2fwzmRKc6OeappmQbui1Gam2RseZPTzagvZn4Pn30cvXbJ291LZtnnrqqau9jG18G/Cmaya5Ya7KEwttfvtzZ/iV7732ai9pGy9jvKDTzhe+8IUXex3ffixaDC/q84sjIF9SOCMx5QROH5iGQzfA2Z4O67BbkH4Wr/MZxpprmB1FXI8orDxKR4zj228g7n0vbIygxlegNEpQaMHOZ6D6CAzOwJ4FaF7PxOYpjOkLDKo1ZhvvwOl+F5PMIkmImkOm1H5WbEFj7FGMwQTXqJtoE7AkjjMrn8JwI5ylfcx0vpdLO5swaHLg3iKh5XHuYArjp4nre1l4ZIHD7ZjEnSelCSTQcDDlLHu784juGHPpCF/mcYjXYFiCBRhpjFMjZWVB0i6nOF2bfHtIe64DjTaIcab8CtOkpPSIgSoekh7XM86tvVs5OmhzfbqfVXGBjxmXOFuIoHgeilPQ8RFuhbqvZ+9sPBwlqS6UaewokPYrqPhaMEyk3ccXqa5fosOhYYG04dIqlXFjl/0UeDy3zmZ1UYe0uAa0A8RpgRHXkd4QdcCAfAcciRq9yKW5DehUKX+5jsAkweIJFH7fgHEbaQbQKmh7oxBaaQliEONwdDf5i+McTivcgMOjuQ7HDiWkMw196uwEEKxDsApeDlarGN4aptkgLs9ADMoZhV23kIaPwcYy3to6we7XwurD9Be6rLqCpFKB0gCir8LwEnQS7F6b0Jwh9Kt8Rt5GPPZGOJCjdPzLTF7q8UR5L/F8gSfMMwSlHcSj74DNgyAXsBb/mtLFJVzPxm9M4TU3GVOSltBawvyZAWnrKOdmfx+56/v04bZypQQ44hsf3PTXyuXycw5tfxdGR0cxTZO1tbXnfH5tbY3JyckrXNfVw4u5T17pHN+tt97KrbfeCvAN5/wsy3pJvaYvFErocVmTFJQkShQmDjYWATE+AQEDSvQBi5gKZqqwlCKt2lB0dS1PzoGCCUUD/DKIDvTXAKUV1IqlFdNAQbcHqQuyCKWCtvf6jrb2mja0s15dCz1u76e6Lkgmmb041sTbNmEpS0g20JVooaHJZRRphTrtgHIy9VQgiDEZ4FLCwSSHTYIkxcDERZGQIhCWgxIxMMgs2UqvyVZaaTYd3Xlsx7otIc0s3baAsgmzNVjvQDfQ4xxkDzPUhFca4GSEWAjA1oFZicgIb5YwHShtqw5tnYuQZhZsYYAItfLtOJkaTNb/uxUZ8PPto7AV99If/dEffbYHeBtbF0IIfv7NB3nnf36IP3pYh2HNj+Su9rK28TLFCyLAr371qwmCgKeeeor19XXk5XmhlxDEZodiJxup7MeseYqFEpRHQfQ2MC78NbLwenCqMLICZ87gROv0UkW1p9tpenvz+GP/DJ58pe5Xff0TkN8J9wMT58HywdyJdeZRZHGInC6CDXmvy+qdj+I+PMvs6mFCDKqUOKBsIKIWvxu1fDcGLmPMcNpocvHaRxhxfNJTu3hr6x9zf76Imv48sSFYcMZIcgswMQHGJqi91OKACjmcpkNQGcHtTRIXLUrhJj8RvIYCJl0km87TQBvsQxgbowzo0CwtEVU70C/g9qq4Rh/ybeg2MPIWN/gjzNIgwsckT0QXRYrDCa5VCYV0njVxjCdLX8EvjmLFEwi/isoNoGCRL1ocaZeo0wAUY4wy27+G8MwISZwnqheQcz4s2TzsbTAfJAxVAVM5vHtjHyubJheUyQgjrO06jZpYgeGI7tp0HMyCJLdZp7c/0gfQtVkoJ7pTs2+BdAiMlHUMFgpLxOVNVNuC08VM8QBEEZwiNE2YOQvdEUrnXXbFZW4lz1F3iSevC0ine1AJtCUyvgCbQ6hMQDuC1TLWAY+RpMfqcBTMTYhOw3AMBnfBcougugRPF6CYI+9F5BuKIIpIhyH4C1kHMcgNiWl2sQsBwVgVvOMg1qmtd3AWFdXxz9GvVUmsPOHkD8HKzdnh+xK0G1QDGBgjUMsz/+SDxC2FykOpA1yEyTHFwkaLcK4NdRdk9QrfUd8cAf5m4DgON998M5/73Of43u/9XgCklHzuc5/jZ37mZ65wXVcPL9Y++a2c4zt9+jTT09N4nscdd9zBBz/4Qebn/277exiGhGH47J9fKuMugOanqUIpgaEMCthYCCSSHjEeEXkSXAwSLKpYLGOipKFJa4KefY1Crdz2E92Va8V6n0jMLBirp9Vgw4UxoQPnQgOcbIY1MbPRjCF4EVhjYHogNnQ4lD2iv49Kde9wYOiHmf2qToGcpYmqnxHlNNX2ZOkgpIlBjIWHjUWMTYpAIcmR4pJi4TPAJMREpYMsuCrUHb8G0FW6J7xgQqEKTh+cnrZH5y2YzOnr4wjWOvoucsXUoV0qykaZHa3acjm8SkLFyWaaE+gFOnMgzWm7NUL3JVvZWsJU9/8KoWeCw1Rz62Gg659c8+uz0FsK3zwB/mbwUtlLkyThYx/7GPfeey8333wzhULhOV//0Ic+dJVWto0XG3fsqfOaA2Pcd3KD3/rsKf6fH94OidzG1cELIsD33HMP73rXu9jc3PxbX3upWKCdnRGVEMZs6ISKggndFqxJMFYCql/7K5rXS7jx+2H9PIR9bGWx2464NC2YPKro+OPgzcLk57Xtda4Oj89C8BRm9+PIfoAq+thJj/HVmKWFh+nWEppqBHXjOBuFgOrHTRq2jzQXsAd1Nr0NbNfihs40beASbb42fxaiPBuDt/HKwWH2cy2fER9FLJ5AeTWGU+cxzABGDHBb2A9e4mJQoGdZvG3hJjoLAy5S4ZxzkU59nd+e+jyvXb2FVaPP2kwPej7UY1yZI7bXiMpLUBBgC3wzxXcAownDGDkXEPV8ipFEYlMgwSREETAgBcbxyXHcO0NU60O8g1dujpB7cAcbziZFY52DQ5drOI+JS4xLlRH2Y+KEIzxRu4Q0e7CcYIYWbbPPx/YNec3ZEeZSxQ5cblIVHiJm0RgQVxRi0UAVx8BfhAMjzPplTK9PbwdwfAjlPCyPwhSIMxWULTHNlFkszhRAzW4AEXi7IdeC9RpYPUhHYcqCcQdr1eVGf44JqkDK0bmIdK8PUU8rE0YX1s7DcEZXSrV64B8iSUp0pAmb+2D+tdD/OHRWKf7V3cholOHN18ApF/bdxXBqk6B2gTS3G4IQ2utZgmxAJU2ZWjlDOgcngy8iS2WU3yVpSzYN6Nkh+zcXuTh6DYR7tHoDWOIZJq2Q3TacKPnkznyS9KjP2tBhNjUwpIlTH3But0U0WgMjU6+9K1VXhnzjSIErSJQG3vOe9/Dud7+bW265hdtuu40Pf/jDDAaDZxXQlwJerH3yG83xXQ6MeSG4/fbb+f3f/30OHDjAysoK73//+3nVq17FsWPHKJVKf+v6D37wg7z//e9/wT/vqiL75yyVQGBgYmZhUSkGNgpBgiTh2QgqpKWQdlZHZF6+MZZZkeMErATIeoAR+iGVDq0yhVZRL/dpmyKrNkp1wrIhsxC8LMxKJNo6naZZl7AEx9JuVyk0IU1NbX920kwNNvUaLANwQJgoQyBxkaSkmBiYCAwSDB14iCJBfr1CSAhNbD0jC55Crw1DB3eZWZEwCixLX2MpbYU20URdSX3NZZu/EJm1WmhyLbOAK2np56uyJG2V1T2R6K+TWcKlhCjQ9U4qe13+5oMskExsRQX4+fbRy9d883gp7KXHjh3jpptuAuDUqVPP+dp2fdzWw//9poN88dQGf/3kMq/YVUNFAbun4fbdo5jG9v/vbXx78III8M/+7M/yjne8g1/6pV/6W4eylwqOnB9Qq0DjtMCrKTYL0N0JNR96eQgdBb4CswNJA8ZzEBj0JXR9A3kw1TUa1v1U2n9NGFYJ9v40hEs49d9jZPk4G3vGSCujWMqgg00t1yENFc1CHqxpRDeHpUy6Vpe1A0vQGsIcOKsVwg5sEPL05AWCHYu85sHXcMa+SCndwQnrAhtTGyg5DcUI0WkgKxb4RRCbpK3jLEy2WLZtbrv40/wf6gj/kSUuRBLV2WShNOB/BB5WWkU6xrPhJ5GTktY3YSyAjSJsjCFVGTPuaTtez4GRAW1zAxeXGIc8KQEGBibPIPhzq0PDbKHCndTWK9TkLu5WhzmY+PhJAZsRFEM8TGwcHGCVVb7mnqDhDYgPWbCRgBORViFt1mBCcWJZ8rr+CBV8PCqUaTGqcliJjersJw5yqJkiorWXeJBjdccA1iswoUC66BoThar1wKhhNWxMLGq9cTbSAOWc0nVPAJYH5hKILuRrYJmULtpcpwosEnCWIVEiIUr09WtA0YbiDkg8SM8j4gCVGMjhEL89CpNlxMYT2MUF0pO3MtMYY12ZqC8WiWUIaUwyew3paA6MGnQbIGzE4CIjdJnqS8oKHjk3R9VqYXoNNqtjeBJ6N0IiKpx3RxjU/n/gz4JngX2SuvU404liBMH++xXnrGWafYdKbHJSuswxQq2+QOGahEJuEd/pkq5fD+t/mwB9Y7x4CjDAD//wD7OxscEv/dIvsbq6yg033MA999zzktpvvtP3ybe85S3PfnzkyBFuv/12duzYwcc//nF+4id+4m9d/4u/+Iu85z3vefbP3W6Xubm5b8ta/+EQKGWQGHp2Vkgr03olLjUsrGeJYULKgISwaJNUZDb/a+oRC9cCgsx6LLVimYbgZmRWWTrIyrJABpokWgmQVRV5Q/DK+jdvoHTQlCM1CY0j2NyATqgTmcuj4MWZTdjSWQ3FAvTW9QytVYai1AS4XwJDK8eBGMFQIQZD6lgYWITY9OijiEnwyIaOwRzTicwVS2c8OCkUUh3Qhan3QJlo5dpxNflNQqgYmqArWyuzUar7y0k1abWcjJz7+uPUgsDObiRIfX0SQtrVs8Cpqf83RZ62kPfbEHQh6eu6pMTUc8SmnRHnwdZ0QL/ICjB85++laZry/ve/n+uuu45a7UpHb7bxUsTh6TK37qjx8IUW7/uLp7PPnmW2luPfvPUQb7526qqubxsvD7wgAry2tsZ73vOe75gN9IVg+Mg4vtklSh3yaxOYuy9wKC9J05R4zqM3dwQO3ADpBRCrILt08inFPhRiyWYM0shhLq+TWx3Q2/MKODqN4CFqyRlatTrp/D5IJMIw6Xo1bqmscT60oVIG38A45+HIMq7cgL02mBegbCHWDBw8bKMP0x8jf2EnM9FrmYlqHKfLfbOXSMw6QqQYKybp7CjUA135Y48g97RJ1vsk1RrPrDT57vAgY2wgC01gCELi5xowvanvpFdGQeVJZzZh0cBqT5CELnh5MAyMqATpFOzYgJKgZyc0/ZAKI6SERJRJCPkza8Cl+RaqHuCcHONV3bu5iwLTdPBoItlAMkBSpkgFB0FMwhPWw1yYO4eiAdVxCMrQmMNY8ZCzPuQiVqsJJ/spY4RIFAepM6NC/rgX0N3l64NWrsD4sYAfjaf5A6/Dah1oF8GMYFdLP9egjtk2UYnFEIc7/RHOPTPG8XKdyFsHWlBaAdkB5zw4d0K3QNqf4jwdHjNSRmWClB60LkHVgtYA8q5ONs1bEHiogglpC2N9Fdl4I8x4jAy+QLicRzx+C54cocQAn4QKMYPaGsl4A1arULgB8gaEyyjPxB0+xXQlZXPcIoqvo7vaQ01tsD9ZYf9uxWfsXaTtH6Q/c61O7BY9iCSmfITZ5gaVYwYb5y1EawLDWWfU61LLC6qJIt9LKUaSnecl+3Jt7h1U6UVFiDpX+I765kKwrgQ/8zM/8x1l07tSvFj75Ldrjq9arbJ//37OnDnzd37976pZeanAMBSmJVGJBVIwAFJSbCQJfVw8bBwMUiQpEQopQ62+WkMdYGU4mhhaSdYJnNOBT/5AK562qcOuZKwVzEJFOzjI6pKEADevb5xFPnhVvbgwgnJJu25GDfB9CAS0bE0G/RTWEp0m3U/1/K2rIAh0GJQBFCIYAL6Jp/oobFKqtIwBJhGOjLPP2fgWOkVZmiixodfuuZrQGwJm81q9dqQmrDULaqZOtc6jSbuFtj77LRBDPSN8udqJjLQnEVgDrZbLTOW2hjqvwchUY0PowK1U6LolI1PLyfqOu75+LWUChsRIY0SaIMyvK/VbC998CNaV4Dt5LzVNkze+8Y0cP358mwC/THDPsRUeudAi88fwW9+7j52TdX73i+f4qf/2GL/7Izdtk+BtfMvxgnoEfvAHf5D77rvvRV7KtxcDNUY0liL2+XimwDhbYP7oKP1qno3v+ieo234eajfo+S0vB25CEYN6qs8mSVHQHplCudDecRg5/D44a5NvPIzXgfC626DswViB7sF3I8f2cyIeoeHeBPXrEcf2UL24nxIpgRVBvgneCVAtlKtYxmRx/C+Yap0hStt8zV7jbvYzbV7EH3scw5rhpkvXMJkegZkiVFJYXobGfsTwEHb/Jsqda7kxPEiK4KR1iVgch6ENWDDmQ8mG9g5Yn4QohlIAuQHCkpBPcLoOyhwQTvcgrkClCks2CzasosgTk2ASMMPXmODJHW3UniegtECiWjxiL/GQsUqBHAERT1PlHqvKMVFDMILEJsKjb0kUJlTHwK6B24XeCOBA7IHnEu6J+Ux5nU8ZPb7KWWxSSgwQjgfFCQhqcH4Ud2OGvYxx94UDCOFqVbfRBmsDhkuQCIQdYFoJy1aPh/IddoWC7968hvmTU5jDok6Qnp+DXUd0RdFmQjff5t6ZJ1jbeYmCMaDs+1rJcV2YccBNtULSXYVWV6sV9YvIoATtA9RP/RUjuS7Dtddi+XOEDAiA2bTKcMdTBLcuwAM3wNnbYXME+jnwbbADBrYOlQ6KKZUdJxG39invWaQyPeRL1ZtoDf8lhK+A1RGtQDsJTG5QajyCfb9B84kacWsEg0VcZ0ixCqX9ipkDPpboMlgosvaFKse+VqQfHYHAgoePX+E7KvomHi8vvFj75N+c47uMy3N8d9xxxz/4+19Gv9/n7NmzTE1twYOHACEUQml7XYzMenAlMTFp1gpM1hccI1Hp5T7cGJ28JDRhE2gVUmR23CT8+iyqYfJs96/pZsTZvbwArQwrqa3OjqEVYlKtLBccqDkw6kDdhoIBdvYzIqn36DgEh6xGKc3Wk80YCxDKwCLOpn5tQmESCkFCSoJBikUiTBLTILGFDqhy40yJTsCTULahbEAps3HnhVZ8PaV/tnWZ6KZAqOePrcwibV/uCk40aY0T7R5KYz0ffJngSTL7c/Z6isulvnH2yJKggzCbiY5BpYhnH9/Sfy1XEd/MPrr19tJrr72Wc+fOXe1lbOPbgFQqPvDJ47z+0DjvumMHAP/lwWVumKvyn37sFl5/cJxf/dRxUrll3+Tb+A7BC1KAf+d3fod3vOMd3H///Vx33XXYtv2cr//zf/7PX5TFfSuRY4wiDXp3rtLadwr3AUHPE6zvmUWN3AHRTljbgPy10HwGM2liN0KWBgBKZ4JEl4hufwXB+pth+Xqo30M6PE9/aMDQhYmS7nlcex35h29m6PcQFYX9tMPk4mFqkaePVWkboq9Begb8IvmLHn33BPH8RfzIwNyAnWmJ86zx+NgzmPsfx7xwiAPRDZza+z8gfxxiH0GCisuIgsl166/ktesHuIZRzjHgdOVLUG1BvwLmGpQSGNYpXJojKgTEo6fA3wCvSeyOY0QFxpo51vND4kIRiMGZZmKxRqAkK7S5HoMuPkMUX7bXGey8AHRgGCFHR2kmTR5ZazMbSTwK/PfdF9iYO4W7Bpcu3sS7/SplhnxfsAvnUpkL6yOs5RNk9STkG0jPgekIKEHaY/GWgD9tbuLGFf6PU3B7XEYmFa2o+Aqj5ZGmI3wByY39Gp9/8ik2b+zqVFF7SQdT2VMkFY/OXgdaHivViHtXXP7RiuTnG7dzb2eMr3g7CEp9unsNEL5WJeIB0cEWTFd4KtfBOq+0QtNPtT1y0tBhOEYDCgN9iLQERr+J4X6Eid2rXDp1N/nTr6GaGEgEJWIac5+g8Pr/SnD0XaghUHkKjIOw6UJSxSp0mOvFRCYIR/EK4yyPl0u0zX18tXgLNF+jn58b6OCZKAJlIVbPU3vsHN0Lc5gyJcLFIqEx3WLiBpi+CM1n6rTVKEEokGaX86UYJTuQ9jIV5kow4BvrMVc2t7YV8GLuk883x/eud72LmZmZZ7tAoyjimWeeefbjpaUlnnjiCYrFInv37gXgve99L9/zPd/Djh07WF5e5t/9u3+HaZq8853vfDGe/ncUZKpdt6ae7gVCBCYCTVgHBEhaFJgmIiIkRPkFsHMwTCGx0cwuqyoK/Uz1jPQeQaxnXGMP3JxWihOREbcEoiogMvXTASyt2ppa2aQ91LOyytb7mRAwp6AXwyDSKqmVzQtXy+CZmkAGjuZDpg85gTIEacckVSkJA8y0ikLSo6sTsDEgrkK5BeUBVOq6Zikfww75ddI7JfTHfqRJuBQgW/rvWw7EQ93VWxZ6zQhw8tmMMNDr6DqjyARzkL0+ZhYWVoJOpF9LS0HkfL07Oe1AHGtSnA4g6usKOiXBB8OIwEyJr1wEfYng+fZR2Ip76Qc+8AHe+9738iu/8it/ZwjW86Vdb+Olg4fPN1ls+fyHd97I/EieP310keNrAz51dJXvuWGGn3rNXn7gdx/g4fNN7thTv9rL3cYWxgsiwH/0R3/EZz7zGTzP47777ntOSIEQ4iVBgFcIGW+ntAzwDkDtEYOAFPHAJqL3V6hXzYAfYKx8mskTn6U5FyKHEAz16NbmEEQ51kT5/B4947QgKHUVtrCgFII1AxvncZ/c5LqFI6zRxdo0UOj504gewkhpHXgA/GXwAW8WO5Bs7l4lLd3AysnD1Nf2MCkrfKJ2gcUbbLAPMtbOkcMhLCyA52P5AQyHJOvnkAdqOKWYw719xDQp4KCKIeDpmTGGMP06rKMG1aDM6kgTkpw+yMhZ2Cyj8pK+IYkrNsZSAKMhshAyKmvsT+tch69fL0x6DLlQWIHaWcxLAQy7kCty97kJJqIqz7BMKqBdfZhKd4le1eSv3Sa9cwd5d+8gdzDKfHQdn41yfPKZCzRvVjDZBz8Pw7JWEpw2jPYh6BMmCefNLm+KJ6hsOvRUCnaEFReAgIAKZ+kSDJ7QFR1uHdE8hcqNYzRj3NUc/iGgZoA5pH9wlY/PrdF46jD/bPhmbu+HfH7Y4LO1B1HeGRhxYX1Wz9yVF/HLHowBizmoebBpQzMHu8pQEaDWoT4NtUnw50mbAec/fxP1S9/LfLwLn5RYdDk3+hDx7R/HSPaiLu6Bqd+DmZI+XK/MgF3ECCRrgJfAiAOPFnI0ku9DRa+Ec1XYNMALtYXRdaCYgt0m9/CnMc542HKcScrEJBgUmVh0qYfLNDdMemNdZCtlXgw5dUdEurcE4TIYRcjZf8875+9DxDfeTraeavF8eDH3yeeb47t06RKG8XVDz/LyMjfeeOOzf/7N3/xNfvM3f5NXv/rVz6rSi4uLvPOd76TRaDA2NsZdd93FQw89xNjY2D/wmX8nI0viNg2QKqvhNYiRGMS0GZKQw0DpECjDgrIFTqRJmbSz7rxQq5bC1j3fZpwFQWUE+bJBV16u9Im1Ums6kCYgfRgmmmyaUiu8MlNA3RwoF2JDd5iT13ugCEGGOkXZytYXhDqQShn67RdDNHCRqYmQJsoKUGYKrkKGUnMrN4aCBV5B36jLGZDPQS6EIjBtakWYrBLJUtrKXchByYCq8/XwqwT9/FSqSbqZ6O/vZ8QfAEsr5lGir00FOIG2SMdhFvxlZL+DMmI/GGqybOcg6UKi64++8+M1/6F4vn308jVbC9/93d8NwNvf/vZ/cGf6Nr6zsd4LADgwUaLgWvzkq3bx4c+d4Tc+c5I3XTvFgcnSc67bxja+VXhBBPh973sf73//+/mFX/iF5xy6XkqIrUskUZ7Dy4J8ThHdnrJ6EibPhyjxAN2db4OqRfHEfYydC1EpbOQMUtNGWIJyJ8BX03DmRl11YUeYzSeYDEOGczGGN0CuzsPGDMbyfoYk2EgMUkqE9NhECpvj818mOtiHVQPyBbiwk561RLh7ERYnwdhHJEy+4LRY3L+qD1xfeR1jS3tJhUClNubFJvmlhMQwSTYU7G7QcI/h976fsxja4OfcACOnIcrB8BY4ZpJvwu3K5eFWjcX1EJp1jKbENEbIdSwmZZ7BoEdqD8E3wYqomCVemVpUMLHwiZBILrC2ZwhuBXohhmMyvij4p4GNTUKPIv+x8Bh2uo7XVHQLFmlujS+8xkd8fpqfG4yRZ4EZxii1XZrLKdSEPvT0I7A7UDoLqg7lGvTLlKVFjohDjTpLhT4qCogci03LxUiqrLNMLC5iL8bE1QBb+iRWHzkZE1QWoDYGKqeDakorxP0N7p+tcNepBvvxOIpEiBVU9yx4ZYrdPURLLaJ9T0J+L8w7cMrFPT6OG00QrtskqybpwRj2VSGtIi44uOcm8J4uM9OYw8OhzzpKWFya/zTugT8nzLvEi0d02Fq9jLtyBkQPo2AR+RHueherBmEOGpMmHXcedf6VoOb0obcSakXGBfIRDH2M/iPMPHMKP8wxbS+yYafEcUhuxGc80SLVwt2SU0cmEZ2YS90q/k4bNb1D95XGRZgbAleSMLxNgP93vNj75Dea4/vfrdY7d+5EqW+sJP3xH//xP3hNLzUolCauptDkVykkghRFREyXIVBCIDVhtUwoWmAneqwBtFJ5OQFamGCVsgC9GMhqiSTaniyzfcy8PCNb0MQwjXTnb5qlKcepVlQZQK6ur0tcqJX0ja1+rGeL4xRIwEa7NAapVosjV9u1E0Xs2IjIRCgDafWzYCtQIiPjpUQHe3l5XXWUz3qOPQH5FCZFNudDRoAz63fe1bbsggmpra3NQ5WtPUFbxLPXxogzdRtNaqXShFeiP7YjfRMg7Gevg6UTrmVOK8WDVIdjWe7XO4NRyOf5N/3Sx8uTAL+Ynenb+M7GeMkD4ORaj5vma/zEXbv4w4cucqnp89++epEjs9XnXLeNbXyr8IIIcBRF/PAP//BLlvwCpPUWqS95vFalogaM1CI6MwAm/UOvglwJYofA20lnbJkiinhT0qgmeF0D0/OI0zdA9xDk2jC1xK6Fr+K6fXIVxWKcELZn4dwufJVyQQTUlcPQbrMw+jXCsbPIchc1ugbdAmCDNwZJg2DvEhQ9sIswtkxvpEKvdAaiPOLJV2A0wY4KDOhjXpxG1I8ybEFpLCVw28iNcZbHT9HYPIPNDCEw37yOp++owoUQnBo0UgY7fdbbPa4ZTrBxqU9olcAdkuv1wSiTiAIGLZLqJsQ2KIdQdNlFSgELgYlHQoUe15xMSU/dTjs0uJj3ublbZxqXTXrUsXGSMQJzhkLlIoUowBeA6XO0tsbGYBIPHxeTiURwqWOiKgWdqlpvQCGBpASNJWjsAlNxyfOJooS70xynFlMWKhEylNgqZZ4BKyR6zfU+ThqR5mzkpAeso5QB4cWsO7OThdjUMHs5htg0EJRlguV1ScotlNNH5I5jbeSIlle0/TCdgskCqblJkJgoM4e7XENtzFJ9SDCb5CjHFYy0wBl6BCSkSHxhsD71Raozf4QT9eipcZiOYdiAwhEq8jHcsy0SBzYcl3TWQNomzfo4ye7r4bHroT2jk1o9G0xTJ1A7EYQBeKewk0/RnTORkz02yxGn528mDSV1+STz6z3aLrSmigR7XweJiz9SB2+IdfJLmJvHCSu3g1/4+988fycGPKuu/Z3wX8C79KWNrbBPbjXIy3O8tiBIJRGKEgkxJiE2JmCjsFAwmsDo5VAiR4+zjFc0wZMdTWplpJXNxNJE1utr0mcIIATbg0Ieuh2Ie5oEqpxWgi1H34BLQiiVtbqcVnn213I5hVKkZU9hw7KlA6tCoe3FLhDEem63EEPDgq4JexNUz0e1Qz0njADpQd7UyndZQjGCfKKV5lwC8wGUTCgKsALdD+jmwXN0EnPS1c/D6ENnWTtETAn5nrYsy1TP//qJtjfHqX4aRUeHeKkUvFS/Tqmpn4+UutM3DPQ1gxB6JvQEhF2ImxC3IA4RKsZwE9LEyGqVXlin9nc+nm8fha24l7761a/m/vvv5z/+x//I2bNn+dM//VNmZmb4wz/8Q3bt2nW1l7eNFxG37Rphtpbj//3CGf7Tj91CwbX4p6+c4YOfvcD/c+8prp+rMTeS47ZdI1d7qdvY4nhBBPjd7343f/Inf8K//tf/+sVez7cNrpnQP2LTfdVbiC49gLNygeYOC3//QdTBGWg7oIZEh3dxYRDind3kYOcCYaIYGU1ZSl6DlG+A2IcO2N17mFbrNE2D4kQK+Tw06voAYQdEOEQYNMe/gNjzCXaKS/TNlDU1Cb7UFRQlAaWuvsseFaC7CbM+zB6FpRE4cxvlNZtE2DSNkFlZRATT5LsO+W5Me9xDVm4Gv8DQXeUMm9zCNEMCbmuOcvr0V4jcNkQ1MGqkhuJE3uIVoUsxTAnLDaT5DN3qGOQm6DVsVGJAZOk5tLTKBCk1QlyKKFRWZ1TkZ/pVxhhlAZfTkcX1DLFpo2jxMIJLaZG0/QrWx02EvYJRHJI6Fk44JCbGw6GHwsbDCFzSNIRarNUTYUPhEAQ9oA+lDk/PHeWBZ97Ka9VuXh2bfKEBTSxcJXjG3KSWlpGTt5BWH6bUbNLf5WjLn+PAugJ/CsxLUF0GdkG7wkRjjAoWF2nwF7seJNrzDCQ2Rish2f8AwcX9UJmDpADFEGpFkp1NKPYgnCD+aoPa0h3sDkeoUiZG0UUiiMhRJRU9Nup/hdj/Z3SbPSYqkG8O6OabMPAhLrOeuxVzz6PY1T5plGM4P8Uwtx9GDsPmbmjuAEKgqG2ErqWDZowuzJ4G99OE5WnW6jdgdFdoVA8gPYfcM/8TtRZgXhSMdwzyqyHdchvyTYyuwhZt7rxwktWh5OnaBWRh9grfURFZos83+PrLC1thn9xyMLLgpSRFKYHEICGz+yIRxEhCAnxkEmhVMjZ1vZFAVxUJAUZOpxpjalInMnuvI7VSrADy+nNRoO3CQuggKOHqnxeE+jewSVaFa+tRhkFTj6PkLE2mLQX1AgSu3ocb2QyxcKGY6J+dODod2kIHTjkSikamwGak0TXBEfqGYiGrO6oaUEGT4HyiLdAjBuT4+nORiSb6+Jqwk0AYayu23ddKtBAQB/oRZanPpBCGOrxLSp1crUJNetNEfy/hZ3PUQtu7E1uT+0Ffzx8n+v+ZkAJDKqQJCrGFvdDPt49evmZr4ROf+AQ/9mM/xo/8yI/w+OOPE4YhAJ1Oh1/7tV/jU5/61FVe4TZeLJiG4N+89RA/9d8e45/+4df4P1+9m9fvH+G/PrLKUjvgi6c2+OiP3rTdB7yNbzleEAFO05Rf//Vf59Of/jRHjhz5W+EuH/rQh16UxX0rMX5bzNINu2HiMEHQJn5qkakNxdm9MaSfx1o6hlpYJJ2VMDFFUu1TOgs3IXlGzBLt/FFYdnQoibFGEj3KY5MpU54iyluExd361bVDsAKigkEyMMh1RohCRbEW0elnaaFJFUZdsGpZouYyxKtQhUL5NIk/JPReg9U16U2dQRXzbPRKpMszmJ5Lvi7JAWuVSQhmwRLY6zsY4vJZVthgQFnZGCsjcCjSs7VrQNdk6A941Ojjxynu5ghROcUb5Akq6yjKekarFOqDTmyRiBFMqqRARIjApYdFlRjJJrOYXEcNE5+YIZ8xG/zxSEo3DkGNgvlKVP1BUrUOsoDvVgkIKOIARQZEMKhAI4JOrMmvUdD28NoUVvQo3sqAOOfxP3PLHBnu4w2UQeV4hj7Ha8/wmX1nKZ6dIqnvQXlLdG1Q+Ukoz+qbDUaoA1ZEB4IKmDVwY9ZyXY5HLTbsLqt3JlCpwMUeUprEeQOxv4E6/SqwRmBuBcY9hPEMYmMDWRqBaybxO3didz1SXARdIGIUQdcIuDD5Mcpjn6WdpLhVm1YuT3+0gL38FSYHPYI1QbjTpXvzYVK7DsOWvvkwciNcugnO2NAt6vRuPwYzhVTB2HGYegLCJ6GjYCCgaCCnaljtE0ydOoZHj3IdagMwaykmKdd86l7Sjsfoni7hbslMV9eUXlxZpLv3SkNHYr7xdrJlU2v+XmyFfXLLQVzum41B2SgMIiQmKSYSG5+EAT26pMOCtgAHgHL0fG+vBwUgX9bETWb2XOlrRVilWdqx1PPDSQqDgVaCTaGtwkJqQtj1dYhUTkC7C7kcFGuwvqDnfy1HK7gWuoc+zezGPQ9wdehUEn69B9gJtROkF2o1turqv6OyGeGiq1VjbwDFGEopHDR1uBYxFEKomjBb1YnQRgyDQAd3WREMlvVztTwY9sAIoNQGM6+Vab+ddftmz1/GEHf1DQRD6rAt2dcVUIkBKtA37qxQ10pJK7NCG9BuwUBCaIFhIkSCGWnntTLR9wC3JJ5vH718zdbCBz7wAT760Y/yrne96zmjGXfeeScf+MAHruLKtvGtwJuvneJ3f+QmPvDJ4/zgRx96ztcsQ3D9XPXqLGwbLyu8IAJ89OjRZwNWjh079pyv/c0Ag+9knLnrCOqGI+BVYGOCygUDbybirIrwFjc5fOYJ2o84NHMFzKnzmOWY1TwcMCHIT4OcAEx9M7ZqkPN7TIzqTsZBUoLmTiich4k+qN2ooIQYQCWYYyl/I5fURYIRgfB7KBHqA5bVg7FNEE9CPA/dlNHaBsYmXBx9hpKxGzZN2ukawfwY7nqFeT/HyRkHg4C0NgXRKJzuYS5NIzExgUVTsTZyibg7CsdsSH190BGSYa3PcCApDmzc1CM25ij68wRWB2OYQ1ZsfWCRa7C+SVPV6FHDxkYgEHRRJPQY0iemhofPGjZFAky+mA8YGBcxKxauI8g/VWTzugpMAG5EY2yJLy6P8TY5yQwGgbBJjRFodnTgiqugWYGoB/UKoiIQhiSx4Kxs8uGzCT86TPk+5ihwnmPWKrJ7mu5cHgpzkJ9BiTLYExDmddCLuQpOF0wP8p4+oJkWfhGSTkpVWhibLmnBBLcOIztJWivY7jnUxZOoiXGt/LeeQsU9Kn6bXm8Cc+1t7BxM4iCACEFEQMoUJhviUfLFz9HxJMmITVTeD8Ui0CKvzpF3A+SUiT9xEErfrecUoxXot+B4DY5lCpLX1X3PZg9mzmAY9+HJr2I83cNoC4buDIbbZNw/jTwlmE5i6onCGNOcP+hDOKtbo8b9gJHHDZKjguXjFv5sQuxC3evjizNXeMyK+cbKxdY7tD0ftsI+udUgUm0JVphZM1GCIECoIiiLDQZYuOTwGYaSdGDCWgmqtiaq60VtSy4Fel7VcvUMsGvqzlvP1P28QaIrjYxQE2PLzW52AuFQq595NHlNDa3A2llt0Ai6RzfualXXVJCuAllg1mweNhWcbmZ2aBvcoR4ZIYU62dytBT1fk8+ChJzU1UvFUFuTCzmdG5BLdJDe3lTbrt2W/l6GgnEFwUBbkkfrQAxpF5JAq8P5ST3HG/Wz7nSl1xwGWu01EjBDrYCHEYTZc5QdnV7vozM0lNA26P4Q+ln9VBzrz0WKNDWRykOFl6uptqoE/Hz76OVrthZOnjzJ3Xff/bc+X6lUaLfb3/4FbeNbjjdfO8UbDk/y1XObnFtusGtqhA/fe4ZHLrb40GdO8RvvuP5qL3EbWxwviABvhcACtfMw5McgdjG7ZzAORazGAmNtiYkkIGhA1XcpBAmEIcEErM3B5AbYiQG2o38R13IQreMFPhNLgmBWsTKcgG4JZk9C/FmYehvM7KR13zi7u+PYyxHpXgffOgTSAbMATIO4AOZKlni0G+IF1o8LRj2Jba4wVGvI3E6mGiZrBy7StapYwxHSxEXVTGi3YSmC3hgy58LQwSHm2rTEpn2SqCZAjoI90Ha3DQuKm5AW6YsLiHIPVeyzaUbkN0YgmcRtJHTGBki3QO6YQ1sOOc2QJWxMQnqEGPQ5mmuxXOxQDutc27uD25XHHB3mwhJn9oKNz11Pj7LgPEpjfYAa5qBUx4mf5LOjA2Y2alynyihTwY4USkAuhnQIwxhwIIiIxRSxs18f8HYNeKp+kf/+yE5+btDnVjw+Nxjh1M4JGJTgvA23ZpayoAdtDyYmYHRUH1JzfajGeiavU2C0X2Mei33pOF97yuLkhAlxG5bbWFHIaCnGHztK0hDQFfQP7UGoA/Qvtqle+kccGt5ESQWkWFiYCEYwafFw/jEK9n+lnh8STppYKsYUp/CHDpRjBmNFzszMIed3oAbfB4sl2DBgc1YTXX8C+gaMGdq+WFqD+qcQ3uepri1T30wZCUFEYG6ep12C0SWwNiG3F/y+djs2OyAO6ZdB5KBVhuItQ9IvmkQFWNwDG3loORbxyJWGzfTJkmr+Hrz8Eh23wj659aD/XRsIHYiFQiIxUAgkKRJFgkGApRJkkpIOU12F1JfQETrMyjE1cTNSregajnZkyCIISzt5EDr9WKKt0AL9dy+nI9umnuE3TE0cDQXK17VDIuvHNbP0ZxVk1xkZyZQ8+34TSgddOZnN2DMyR7cETP11N9VVR44BXqRzA6qm3k+KQMnRTp+81N3AhNpabShdQyQiPT4iM/uyyELA4liTW0N9Xd220Qo72Z+NzEYdhvr6NAvNSpUm8ImCSOjHINDVcpc7mNNUq+ipQkmhP7el+0Gfbx+FrbiXTk5OcubMGXbu3Pmcz3/5y19m9+7dV2dR2/iWwzQEr9hdZ18F6vU6Bc/hez/yFf70sUV+/K5dHJrarr/axrcOL4gAbwnkJfR9WPhLZGeJc7eUGbZqmBfWsBa0QhblA2yR4kUm9aGkZSuGs4YOHIkjPQeWxIjwPrx0lWbPoN5KkW4VxDnyj/+pDrm8/SxMlHHsSXzHJ919iV7hAAxv0umhUQzxBCQndOXOMzuglSLMVeKNIpNTXSJp0PAU8kjE3gd20W7fw1Nli0gexj6+l3ifB0kZ5juwsoSf388TssUdrQMUSHCbRfzY13NWtqUJlWVCRUIlgJUeSjb0QcPLU0zqtEYk9sDAHlYJZiOGk22SDY9BqFhnExeXJj6fLz/AYO86dixpDT2OFZa5P9zBD3T2cXN0Db1jVboqYUUkLI0uMh4O2MjvZuQJG8sYpXn9EvfED3N9q8qIkfVjOl3oDqAeQW8dooq2hlsC+jfA2Ekwu6ixZ3jqxoCPPST5vmSEN0cHOTuTw3yiAGGLKAq1jTrIw2YVFqS+4TDvglnSB622onp0nrd06uwjRwmP16xcw8KxgOHuIfbgJOPVkG7ZxYgiRF8RpmOMPHCY/WvXI+I5ZuRebEDhMEDh4TEgwUWSFO5l/rYznLNB+jkCr854d5HyxJBB4NBqvYp06lZ4ogiPjWoLYOyCkddWRc/QB1CFniesfAXSL5I/scJ0mGKbQE4HqxoVLeL4RSg44Dchyeu60M5OWB7NMfAcDDOmkvi0qnBwJaWwA57ZYdAqucgkhzCi522jfC5i9MDhN/r6NrZxdaFIEYCFSYpEFxTlMDAxUHgYCBJS2uTwsdIhvf46tEfAI1MzbSiWtJ1a+frmmiNAeBCU9J5aSCDY1EpuYEOQEdSKp/f8NNE3UR0X3JJ+fzMEVkBWta24XNBkT4b6+zgmVDO7tCFgXEDb1xVKqQU1qRVi4QCpJs7TdU2+Oy29z7sSGMCEDXOenvetejBWgGhdK9O5FIw2qB70hlqdtdAkPJY6kdqQ+trWEtSqkPNgYKLLevua+KvLKm2q55LbXf28VaLDuJIEgkhbwYcChgVYjWA1hfiy0ptA4GetUibP1kttWTzfPnr5mq2Fn/zJn+Rf/It/wcc+9jGEECwvL/Pggw/y3ve+l3/7b//t1V7eNr5NuGGuyluPTPHJp1b49//rBH/w47dd7SVtYwvj5UuAxQLGheOMPvE0rcCmd9tt4BxCLv41G+kyxTyYRRt7tU5oNJh0JKVcgSfqezDX2lBegfwcyFWE0cAYSLw5GNsNu9qPc/b8ecx2A6NQJ5UhBBIV5tgo9UgLLuR9jOajqDBBqUmoToBdgpbAbB3Hcdbx3Rvx9khULqA9uRO1WEPurnDmTIjXihhUj3Pn6e9hR+Nd/Glznda1TbBOQn4FRrucjWLoFiml8/hRATwFZR+xAcoUMO/B+BzG4gZet8ywsIJtLRO7M6zNlKFgkJirENoQT0KtSHm9xjRlJigyQp5lUu6ZupekK6j2JfPVNk/ZC5zf4fJh4zxWWKS4PkLSGKWzdxnVnAWxhruxh7cMdtM35vjL/ALnZmMutbvcKXM8XByS5hJ98CLN+n9TPW9nK6h2YCQHgQHddVKnwxd3rNFbuY03Dyt4T1YJOgZyTwNECaxRWC/Diq0DX7qhrtpIOojTi9AOoFfBZZYCeWxs7lSzdJ6EezpV2rMLrLireAsDSs8I3G6VSnILb0pvwcCji0OEIsVmSECFPDks8sSE9kWS6QWOVYsMhwFRbhbTs0j7AiUdOuEdsHITxiNj0CtAVEQ6OT0T5w10+Exi67lDIWDiPBSOYV1YpZgmyBK0LBgJdZ1n2gCvAxtHYMWFg13o7YJhEc6XSoTFGVABqUjZzFu0rZRD110iyEM/ByqQFOIWpQ3F6hW9oSK0ZPWNvr6NbVx9aCeyRAiFKQSpVKQqJCABcpiARR5BF5EY0PCgGACZHTnnQcXV+6lr6d5eWcwCr7rgi4yEjoEYgN3V87QihUFLk0CUnhFWgSZ7vYFWkHNCp0WrUM/JWnm9F4SRvlGaALURrbgOsnCpSGk7sXTAsyDKo4dkfW39QEHJ1WtwJEyN6xTnUOjZXdvUny8Y2pJtBHA5GMxxtWU7HGrSKixtn1ZDrczGCfSbMDS0nVqgCb+dpVeHGTlP0D2/ItCKcJjNT9uuJsJDpW3d/UCHg3UCnSgdpoCRbS1SE+stjefbRy9fs7XwC7/wC0gpef3rX89wOOTuu+/GdV3e+9738rM/+7NXe3nb+Dbi/37TAT7z9CpfPLXBl09vcte+0au9pG1sUbxsCbBz4SxJcZTCUUWuELA2OEGQRhhWk1SB24OClNimRFQTRFmRkxF7Tp1luhvy5coxEvN66MfYFx3GmyZMpzxqGHgTMXPtNaI2tCs9OkaoD01uRLFdYrjswP5lCt0NYrNAkN8Lrg92grf0BEUV0Tc83DPzDPZM8GhtN+6jO5lbGGGxez+teoN0YRq79hDn60/wls3vYteGorXuQ7WrlYDYh7SBbyySqAmisovRCChvBOTDWTZrAyJhQmBSXK1yTb/Aw9UHSBMbakpXTzR7yNGBnk9Od0CQx5V5JiiQsoaNwKGAbeeJkwBas5xMWzj9w8gwT3LLRZJyQFCsQihwL45TGOYpchPXxfu4jpA/dhRyaZPh+BKfHHmSH2+8honFBsuzA6yjFdJcipooQmMAs0VoVOG8hL0uiLJWQsLTpDsHHI2mKA3HcVZcBrMdmO0DRTittLgyZkJowKQFgx4IRWn5CWzZpxTPMsNhbAwEJmVc/lEyS/VMgUeX9jMpfa6PxqmpCuv0sckxzgSnWCPEgmzeN/+suXKJU/Y5TtzxUYYzJmrlbVB7knzzFHNJSicusx7cgVx/BeaFeexOAYmJwCFMDD076AiwCjokxrTA24T5JRgs4UYRptRnbjuFbgL5th4RXqjDQt3hkIro7IFzaNE7NEd1yI6RguqCN0ni9Tg3togqSooDSSJCXGDGZJsAb2PLQgqFSfYvVikkKYqUmCHgYJIg8BHSRQwSVDvW1uSKoWdUe+gu3YKREWBTVwHJvu6tjbIQK5RWjU208hn5mRXa0AqpzNS84SBLcXb0fK2MdWG3a+v54TTUhFGh3UuJ0EptrL6ebI0Jtg2+o23JBHq+10Cr1XGiXT+jJU3C01STcKGASNukzSTrI846jU0DSPQoSmrrGwC2ndmQlf5znM34ltXX7cyOTtXWic+Xk7JtEJnCmaI7kDH1axcr3QAUJhCFWhkOU61uZzZuIeTXReUti5cnARZC8L73vY9/9a/+FWfOnKHf73P48GGKxeLVXto2vs3YUS/wI7fv4PcfuMAH/9dx/nrPXVd7SdvYonjZEuD0fBd57Sibt5U4cKaD4a/TdDbojtcJD++hEzQwRtsYzQ2sviLx4Jp+zLATM5ACIS7pMJFokVr3AqNBiWHQxh+ayDJUqorhoTKDqVeCuxtaEBd8vKaL2b4W23+c0PSIRmZgM4X4Irb1JGYzZndOcbQxR6k3TquzgUgXifubrNablC+s4Ngmq3ftZXSQ0h79Q+7/kkWdfTCchfQVMNKAwWMwEtEohMjCALW7idpURCuTiGCUxLL1QeuSpFft8fRIirmxi7jUhWmD4uZ50uEc/rzSyadnY4xhGSspcYlRDuAT0WWCEvP+Ho7vHzJ//iCtDYVDkfMjLdLcNOLkLOJMDenYVLt7qKmY7yLPLhw6rHOmvgbWRVjv8tj0k7yutYO7Vkb5+A0dVG6YzbzGMGoB43B0EoZfhuEK5A+CMadVhIsWQS/HOcNkMnFpTW3o+bMLWY2TZ+vAFVHGuDRECkGhVYToIMLzeas8xE2M4lBEYBER0yHlVua4zZcU8GgTskGAQAKCHk1mqLPEOgMKwJAeBh7LPJq7RPvG32O+fA7rr36IIndy8fYmSp5laTjJwLwbdeZWeHoMq+dhIxk4RaSR6jAchD6QGok+xOZ6sGsJrBOYG8vUfUk+C0zNDbSr3VcgroOeDbPDCLcOl+qCnihQbA0o06Dn2BhRgCwm0I8xgyHNkqSvTJSfYnpQ7mRn0yvCgG9szdt6h7ZtvEQhBNgWMkmQqUKhSZbAIKaLRKFw8ajjElJUXYKGTRy4ULX0vK3Zg0DAeBHqUzqwLg3AG8lqieIs3ViA4YGX16RWtbOMIwn9gVaQHU+/14Wl64wCP+vN9b8eEEUDnJxWhAc+uA6M57VamgDFAriJ3tPzbjY7K8Ho6N/yOVOLuuZlItoFswOioN016yGELV2tZvY1aTcyqzN9HfBleZnlu52laRtoq5SV3Yhc18R1MAAvATIyHeR1CvWYBT1Hj7kqR699828Qa0NBlOoAMdPTarFKAAfDkDhWQhRmzugti+fbR2Er76WO43D48OGrvYxtXGX889fv4xOPLvL0cpe/eHyJyYrLueUGu6fh9t2j2xVJ23hR8PIlwPVroFekN2vQ2zzFvkbI+YLCHxkluutf0PQrNAdPYna/hHP2KSY3eswPFCUTxhYVtc2jrNsXEPFXyRtn6ZMnULC7F6McOOnupVv5cVi8Fc6ugExIutBVMfmF6wn2PIJjPUXkdCHsgSvJLXYZDyVyxCYY3oB/wMdVD3LAOMtJr4RpDen1HJJqERxJ0BplZHCOR8p/xY2N9+K2IkJzJ8RVqDUhv0hYEroeo+fDyCLDXI7ik1VKrZRO1wHRRMWK7s4GzslXYKg10g2ftJ0n9ExYzul6DGsdO5zkrN3ml9yv8JP9HbyWKpCjtj6JmHqGaSJ6xijn3S7hBFhP55k8Pcq64xFZMFRdelaVo2nItWoHJ2gS4ui5tU6FYM8I926s8461g3xqY53+9W1dL5KcAsuCgYHRmUJOtkGMAxf0f/t7dH/yoSHyKwrb97UiccYGp6prOYIyzsBj16pL0S9x0jLJJyFT/CNeGY9zCxNAXgsTJAQodBIXxCiWCWkTkSJIMbEAgSSkSxeDCEWfmICQ05PnWD7wl8xap7lw3IM4Zn80Qu+pMTbvvh24BTZc2Mzhhi4eOQJslDIwUh9ZlPowbGSBMSKEfT2YvwBrJyiHPYoCfFc7DcsFXUVsTEKjAmMKRhItILWDAsooM3Z+wEyny8VKl0oZ/AIEEpwCrElBJEzyKsXr6XsO9SvOWXm+Q9nWPbRt4yUGpSCVKHVZOU1BGCjDwE4NTBQGPpIuYGCSRyR53cPrJ9AX0DbAyXp63QAqAvK2VmzjUPfhKh+sWNcM9aUOgkpSTRaFAMPN0o4DTXKFBTgZQRaZ8pupr1haSZWuti8bmaI7ZmnLtZ9m2QGmjno3El07lMu6gJFZp3CqSW4UalW54Gkrt51dJ1X2mugdTod8mXq9QfYeFmS9xug5ZkNmyq4A0wYvp+uN0jTbvwLA0CMrQ7SCHuc01/MjaKf60Qj16xQYmghLMqKdopAkycvAAf1N7ZPbe+k2tjZGCg4/9do9/Po9J/lXn3iK9Nngu7PM1nL8m7ce4s3XTl3VNW7jpY+XLQEmljBzA3QbRMUVKv2QkXVoX9dgQ27C2DWQnyb1juA7X+Ji7X8hH1rgjlpCEsF8cJZN5x4Mq09FKBAeIy5cTATLhsGgvAc2Img8A5sziJ4PRsTAcKj3pokffiODW1b1wWLfBBin6Q9cvEpIs+Oi9hvgrpEe7bG8DsocEgiLNFRg1yHwaCbX0jY3EPPLmN2nMaIZGPFhWIXypE5PHrpaCbUEuD7mWRs3TfDNFPrZXJltgzkgun4Iz8zBICR0JNZgGhktkRRD6usDIhqszzRhsMQn/CqTaZ09mNzi7+fB6FECkSI8n3A81fO24ThJMopS61iBRT+3iaobnG01UYM6I4yQ86cJqzXIL0HicPS6Mq9Z22TibIH+jiaccmDkWhg/AVIyFiuaXo28OE03ncI8N0JSy2P6JrJ5joXK0yzO7YbCLmiZMCggQpPRXoXva1Y4IifokPJkMsY6HQ4wwfWMIhDEuASo7Pir6BEj0UfgiBgHSYwA8sTEbBCwQMIJQgJSSggaY20WXv8MxvASl5oeReETzH2SB5oLhGUP5vbCiRG4VMLojuPGZVJSVC6GOR851oXAgtjSYTuyDWMJ3DSExlnM/jq40AJ8IZhLFbkQhKEzZDoFg9XAwwmHBBHk4iGV1oDSKUW/AbV5qBRgNoJGT+fcyEgxWY+QBtSGWkRyO1f6hspU62/49W1s4zsEaQrPmqATlGGhTIGTmpgowCdFvwksShhJEYQLQw+6tp6V9SxtlYiHMG1CzYARM0stDnRIlJtoEtkXmgBfJpSmocmnTCHKgqYME4zsewvAdCGJdHKy4UCSKbtVS6dHh6HuBw4N2IwgdCE0gU2933smjFiA0r8LLPS8hOtnluoYihI8kc33ZjcE5OXXxdQE/vLrFMRZ4rTQ6xYGuC4w1FkFCLBsvbaoA6TZdal+fsO8Vn/7CiJH9/wGgV57U8KGrwlwKCBK/gYBTlCpItny9md4/n308jXb2MbWxmw1B0AqFe9+xQ5+/NZRNmOb3/3iOX7qvz3G7/7ITdskeBv/ILxsCbDR30T2ejDIETdSFp6A9aUqxVMBm//oc6gbd4OYhtwMFN6MJGRl16O0zzxJzlJYuRh4hKR8mKEsMG33WMhrG2plLcWXx7HbjyGmHIL934/q70AZgsJ9JZIICus3Em2cR1x3L2kZRPMSMsnDMKTv16Hv4mw8zmx5nU0gqbvIaD94fURrArUxA2mM3HMSUe5wQazjntzBzguCxfkciTsGvRxYfRi/F7G2CxUewGsVGGLhJn36dgtlDrS9rR9BrgX7cnrutJMSyxQzGQeWCHN9lB+B18PdGGXB7PMH4hw/l3gcSvZRuHQjI8qikipOjV9AtSuIzTr68FTEMtskO/JgN1iveJw4vsErpc0tfZPPeQdQdROigwxKJf6y1qbrr0GlB/s8GNZ0KMp4mWuMlIXlfaxfew7zdMyujRzO6jSTqckFs8tFp0hiC+yFIuawiLtZ4mDg8T3JBDdSBBwkkjnKDBnDQiuwBg4Kg4CAmJSQhAiJJMUnQWISI5CYhCSkwCkkR40eK5VVxMDFKxr0viuECUXavAWCMwzH1zAHXarFB7HKgkuPt0jX9kOritGzSVXMsBaibkrgSKDnAGUH0jWcsyeQwTKJdxuEFcTqOVLDoN93GJoJsesylD4tVweArwmHhjOOrJushZdImgq7ISkFkM9D2IROCbpod6UdQtKC+Tzs6GsnYtKAtRbI7pW+o/ro/pO/D1svuXQbL3WIv/FQQErXkFgKXGUjaGES4ZIjBGLpk7YlBEV011iWuuwJwIVYQAcwc3rbs0bAGIDKbMg4ukrISsEUkBuDQQf8DhQKmjgKX3fTKwVpE9wqeAUIytqubNrQXtRkWI7ou1UoqCvohfrnHDDBl5r0FrME5yJa5TWFVmRLlk6f7g/03K2XQLGfrc3UYV1BX5eHq6x31470zVSRhWMJQxNVfCDK2nkSrXyHXkakzSzAS+pEaTz9fBrrEChIPGiG0Eq0LVqF2vZsJfrmghKArX/uy2IPeb59FF4er8M2Xs5IpeLXP32Sw1Mlnlnp8edPLPFjN9W5cb7Gf/qxW/inf/g1fvVTx3nD4cnnvV20jW38fXjZEuBK3KMlImiuI4/12TxZw1Jj5B7x2NF8kJUQwpv/CRQOQrMI/h1E18zw2GCNG/wVWoATnSGuTLE5Ns818knWJOxcMTnlwGjpEvTAzcOy9RXS18TwpQGB3IFJBU8lqHgPcuwUxvoyY8NNOtJCFVxE+5VMf3EXrenPkHNhnwvdnM+FuEnsvY2xUztozC6R5ksQ346iA2PTRF6I80iZ0eaQhu2SWxynbz+ETJexG6MUl19FNR2w4gzIxS5CRqiShJ4FVh3O5WDEAymxYgszyePnQqBEf7YFm7qPciTciTQSnp5oc2LZ5C6VY6oxzU4JpE2EG6DEBNIP6dIidiOSioTiEFybyPD5n1aLXLSP66OUp78WsrLPga4LEyHH7xTQBPpFYAC7QmjYUOgztC3qvsdpdQSqa7RbF7kr3gu0CCyBUnsZWczz/cPd1MlRpsQcOXKI7N66IkWRx0KS4GBjABEhbSDFJCAmQLv1QiQpJnlsIiIkFkMGtJE8XGnQGL2ISmIojhHfDFzYgGYJoh6Eh4ir05j5J1DDFmvDHGnNAeVgD8sIZRLkB6hXDODgGfK9LzHRP0skhpR7PQrNmNNWmc7endB+HHOwTCLmKZfOY5Hiu5KBUaYd5ejIfST7ZyA8DeEGzTDPxMaATgFGB2DOgb8D2nntpCwMoJeCUxBsSpMlG2ZVQt0CS+pK6StDzDeuJ9lWLbbxnQb1N/4rESJBYaGUJCXFJsEgJsXHyQKxuoME4iycqSvAFVCSWoW1hbbvuo4midLUlmIVg4r0jKvl6BlhRTYTrD0mupJYZQTT1MtKQXfpxpCE+johwIj0m9RI9OdSoa/1suAqy9O/2Q3ARZNx29B/x0SrvU6WnnfZ7eykes0qS3YWsU6lFiLrMlbZWlW2XqnV3TgEoizgC632GpndOTV1GnZi6HlklUBi6hsFqaVDrroJhLEm0n42Axyn+vsrA61IX/7ZLwc83z4K23vpNrY6Hj7fZLHl86f/5x38m784xonVHr/31WV+ZXYCwxD81Gv28gO/+wAPn29y+67a1V7uNl6ieNkS4ELk00oEVryOa1iEagpoEWOQu+Ay/9kvcWZ8DHXDHGyOgNwNw52sH7R4cOFPEMEZqmFEEj5Kd2aO8xf1ueSEbdA7UMRLckTjeWx7nXQiYfxLf4TVhHX7GmRyE5HIgeeAexhhNRiPFPlKzEVxO/XBG5mNhwz7KTkDQgcGBYt0sQrNCdpjS5jzf0G64yYwR8DfhXN+F/bGJoFwGO8XuKFXJybhvroD0iEumrjDmGY1IpjtUD5RpLCyA2NVIsOYXn1NV1aspJBTVBOPnUmBiwOb1sY00UgP2AQRsDG9SHFxmnQg2WATh5A3xDPchct6PM3I0SFBUCPvF0ixCIwhcm8FvAhiC+uiZCSucokWT5s9vA0Xu+MRO1IrDlNDqOfhrK2DXyptzHYfkTvJKWMvqvAU041TFDZ9FseG3Le2h/7MKeKZNSpnruWfbdzFq5jGxGAAmDhIDBJCFDYeDiY2NfL4SEwUCosYRURMQITExCIhJMbBYUhAH4ViAAiesSKaN11A2U1Yn4U9mxjmlzA7HeLmIZgwdRpV/0bCI3vYTP6McEVCdT/GM2OUEgfDiGnctAm7z1FZ+lMOD89hdmCzps+GrVGHTulGrby0YhJrJzi30Rh5hT7MxiW6UQ6qNuQN3VPq5GHkHGE0pGQO2HAMVicUnbpLnMQEoUSmEFo2QaUEuQqUplgVPuvRCa53hoxGkFxZBDT69PuNDqnbh7ZtfKfh655aQySYJKBMBBJJhI2LSUrAgBIFbJWj31RIR+pguhUDpKHTmC0AE/KWtkqbliZ6mNranDY1wbQLmjzLBFjTMe5GZpsWSl8vpH4rJZaeD5Yh+AHYeW1f9siSpAOI83r2t6sgH+uv4+primgSbAit/BqxDpsqFLJwqSG4WT1eAZ1cHUsdhuVFWtkWRW3RvqwEG6Z+fkmkLd7hRtb5i1Z0bVenYnejrMYpp19mqcCOoR9CN4a0rMOylhvgD7RK3El1tVOQkUBl6EcSvByGfzM83z4K23vpNrY61ns6hOTQVJlfeMtB/vHvPcLHn1jjJ187ZOdokQOTpedct41tvBBcdQL8kY98hN/4jd9gdXWV66+/nt/+7d/mttv+/vLrdrvN+973Pv7sz/6MZrPJjh07+PCHP8x3f/d3X9HPFZ6Cao+CscSEnRAJRaLmSEWbQBrkTxTJHz/B4GAC5gCUq9Mz3TfQu2k/tD/LoPMUoh+RBmNYy2cY9yKOHplG5l/JsOZBdRWj2ae8fOr/Y+/No2W7yuve39pd9c2p0/f3nNs36i+6SAIkkOiCbWyMYwMPeLaHeSE4IdbLs03iGNvDMe6GQ+xgiJ0Q2wQCwTExMVgYJIRAHeql2/f39E2d6mv3e633xyoJBBLSFcYC35pjHOlU1a7d3bPXXnN/85uT6cd8/JzBenwe1zxEyQhgrAgn9iD8BykMwFp2BHnqpVRaZTLkkEGFY06AEl18NQn1y2Gsizn3RQrxGpvdB1GVa8kvHODQmQFOO+tcuOkJtlZHeOkTVxACI9UrqXWHiKMpVidSMB6AlcMRFXZ3BklosyQ8Uo0spQBc6VLNrLF52QWs4x2m23OM12c4HXTpDCkIQuIJk1bnAumGIlIu9/AE89gUKGMywo/UX80K6xQYxEdypLPB1iMBUbZLuZVlVxCzSw2QxmIlX6dFxGhziNiPqF6A2AxgPoHyJhhLUA8QdoQILWoDBkLOksmfp5UYEI2xTaVYb6RYMyrsacxyJUNEJBjkEToDBJMEhyEkITrlUqJIiEkISQgJ8RBIYgSKmJgOIWkE4BJjoPBoorh/6AHO7z+Ks+0BIi9PsusGsmtfZnttkWSb4ry5jCt2w+RLMMPHkc4kfuFHwdiA5CWY7RHShNRHOlh772JP87NYrQ7pQM8hV5IsXWsKmR8C4xqoZaHokYseJ1XfpJ3eQTJVJJM6h5GqoloN4npIUMijhkegLYiyac5NCCIpOD1TxmgaDHRrKAxiZSMHpmFwmzYJy3gQ+7S6DptNl0IO5BCweDFXVJ8A9/GDCguFRYyJaQYgE6Q06NLBJMTBROKQYJLDJzAyhLbQ0UVNE6oWSEv33xYUJJGWII8N9KqhSY8wKujmdUWYUPf4OgqyAtLpnuNyoPv/DQE5obN9paElwUavVzdAO0yn1kGm9bazNiSq93ukK6yhA9LV25U22Gm9PzLoEeK0ziEOA2205YRghmC7vYxiSxPfsCdhHug5O4dxj5wKwNH9xEkM+Yq+RyoLcuobjtApS2+3ldaGXV0Dmh40FXgmbCTQiXTlV1qgUphhgFIxSiWoS4b8Qp8A99EHjBTSAJxYb3PjrmFetmOQr53e4ndvO8Ef/1/XcGKt/bTl+ujjheBFJcCf+tSnuPXWW/nIRz7CoUOH+OAHP8hrX/taTpw4wcjIyLctH4Yhr371qxkZGeEv//IvmZyc5MKFC5TL5YveduArSBLa5VmOXa+oxGfpLtkURcC2dhZH5UhFx3lo9Q5U8VrIDoBThLYP7SmIfoKk8krIJbB0mEZyjNDcQsqXQvFGyBwGDHZFGxhGQnoGwlULK85hEOMN+Ig1QelICe+GJbYKgq3ibhjNkxEeDnniXIIxCGNSsqR8glQWkZxhTJxhxR5AMQhnc+x/aBsjMuIrE/fA5gmS2pXUuZwSiv3BNM1gjgvCZTPdQhkhZieLI1OUMTCAmsrwT71BhjBYI+C2ZsyxyWVW9txD5jGb6XAnJXeSpLWOX5pGnDSR0x7eYMj/XDtLMvxFZmtz/FLjtUzQ5jIsJpnnKtJEJNwFLHcCVGeICnAjWbZo8QQxXmhSjGxmiWmqgC1jXU/urBgqElQeghRJt0hm9RqKbpHh5iCddp5iGPNW7xAv5wALrWm+3mpzBXMUKWJj4lAgjSBEYWIhCeigkAhMBC4RPhEdYhRpTCIsFIIEQYoIcPGJkIQIHssscfiyh/Cu/QJ5o063NY0UFqnuF9kvVhnIKh50LYI0GK1lZLOL42zhnx4nu/QGVAE8M4/ZjdkquwTXnyW3+hXCSNKJ0nTrGTZUhXb3BlTxIIxcgOIFPXnttogKJhV/jVRzjVICJVMbREtXF5uXBmu0020oBWCl6EQOTiYCU5DCw6vkCNUwKrcD0pO6UiPqsL4MWRcj7LIS9JylL/qS0rX2Z8cl4WDTxw8qFAgESsieGVTS+4sVKDxiPCQuJh6GymiSGwrwTW3qlBZaAu0mupob97J6hdGrmvYygSNDb8/o/ccUvd5co9fnqu9LmvT2rifRW7fR+4liINHu9jLSZnmmo8knFqQiLYsWhnaZlhJCpc21THQl1zR0lRoP3bcbf8Oky+wRbQMd56QSvV9mL7uYELB7Sl27957Q65Nmr3fX0MenTD1+KRMCpSOOfLTZVVfpKCk30e7acdKTOwtMCVLpdpVLC881jkJ/LO3jHzuunaswNZDhj798mj95+0H+zT/Zyw/90df4/OE1Hji/xX/+ylmmKxmunavw3C0DffTxzHhRCfAf/MEf8HM/93P89E//NAAf+chH+NznPsdHP/pRfvmXf/nblv/oRz9KrVbjnnvuwba1UcS2bdte0Lb9VApyNnJ4L83pQ3ilLzL42AkKDRg63iXxQ/IbPqfO/Deak3Uo/xNYV0AaYltnG3ZmQBQQvkeUUfgjWXAug6iB4T+OFa3QsCWhKVjZlabT3ElYnkPEMXbDovjgINg+eatKO3CQ0kdUP0ta/WtiuhQym1xJk8441MUWwdVfICOquHWFPFOFTEwqPEjGS/FAapE43wUrwW4NUSeHRODi0qROVmVw2gbJeclcfYD5JE0bcBE0aSMJ2cscV5Bht5fm9082OL23TtmokmWKzWKbuebVGK1NhLRYI6S2w6ftbULY4szgFl9tblFSAQEDvJ4MeVxSKH6MUc4TYpPBRJLGJU1IkRw1P2FRmcxicdioEu/ZgikF50YxNwYYqKUZjwWXRYO8NNlPCY8BCnjNQ+QpU8JBAmMcYB8SWze0kcOkgQc4T/qZEur6p1bkARExIQoLmzQWEQk2Bi1CPDps4pJg4mDytcqDPPame0mGTsPaDpqkoTZNLv8VdqsVMjl4KBCoKCGzlae7tgeYQLTnGAtexnhUId7Ksk7Apt1AHohhr0/31Ms5EeYgG8KOMfBKsJSC7AIUHob4GGYzQnkhA8rFCnrte56uFqeFbsPLhDCbjqlVazSyNq41RjJYxMvb4FyNN1IAowrGMKiKdpeONrHOPEi+uoITJ3h2TLcFp2PYcdEmWCF9AtzHDyZiLGIsCX6vb9ckwCaNIMHtjaK63rmi3ZejCAYGdFSRBeQcSBmwCuQMXb3tRJBS4NhQ3qb7Y12vF0dk6adXOJogNrd0z60DtAKQAnJZNFs0gWKPLMcgOjpDd9MDRkBkelm8tibBMterypqQzmuyHlf1fjgW5Iu6Iit6cUNPEtyuBySQqUAq1FnAXqJ7lzMGxDldMVZN/R1lQpIFM6fPQexpCbVvQj3QRNiqaG+HAGi1oRFD3YfNABoRbCbgBtoN2oshiBGJxLH0rsWXSuvvU3iucRT6Y2kf/9hhGoJfecNe3v3xh3nXxx7kn904z+v2DvL5o1v87J89SDuI+fDbrsY0BFL2CXAfLwwvGgEOw5CHHnqI973vfU+9ZxgGt9xyC/fee+8zfuezn/0s1113He95z3v467/+a4aHh3nrW9/KL/3SL2Gaz3zTCIKAIAieet1q6Zl965rdMDKqrXDbEWRL7JyEzCh00jH2qRj7PFw2uMr9mS2isZSu9jZ87ZKcTkM3gcRFzedZUnuR7VlQBxCb/52Z1leppCXJbjg6MEbU3YZ9WR0eXsRY34OIFRUstsptzEyM17TIlk9jnc4QyCIWLn6uRLC9oR/UrxTA34u3Mo6bPYdwH4BCGtaXeHj8PJ2pBgx6iOoNTLrXcri4RqvUJYkCaKeZ6ybMhhGFzRwDOAgSlojokBATsoaFgSCkzTYmeE/7Rv7DsYT5YJxWqk64/zzhwweYDXYwT4dWLeZvjzbomg0Yegl2J+GMamERU8YkpIIiYIE25xFskcYmoobHOm32M0wJg1vUNGfpIBFsk11q52ZIFiW5zQqTUZrLyXElOcbJYhBj9v5fxKGIhQfkyePhYROhiHBIkSKF3XNvNlA6UYMYnwiBSY2QAHqE3MbFQxCSILHQJjgFQmJSfG7yLo6+8S6srS72316FX2rCtjNQs7FzNTwT3Dp0u3mi8CqSxmsw5CzFtsk2t4LCISCgToeABDnUhplFqDXAKEF2FbIB2DUomjDVBGMDu3aKXC2mLGHdE1RQlD0I02AUdOth2NbFoSgLZWB7kBC0E76ak3RHbgBnC5IRyA9DI9AT7PgJRO04heU1Zs60MWugMtBJQTAIpKBTAh66mCu6Z8DzrLjkZrJ9/AAhkT0Pqp7ZUiIkqlfZjIwAQ7oIBJ7R0FG5SmpS1y1CkoN8okln5Ouiqis04a2kYTgLbk8+7Ee6N9eywCjrKq+DJpqJ0lbsYVeTUzMDiQf4OtbI8HrVXgUpCQWjJ3FOIMxrQooC5fYqsGbPyKpXvbVtsC0td1aRNrqSHS29tpU2HpAREGnSrBIwsvo4iHRvcBJpBW6U6JPmP9m7rLSbtLIASzs6y955aLraX0KiPxM2bLah5UPHg3bcI+I6+khJg0ApkktK+vwknmschf5Y2selgNcdGOfDb7ua3/zcMd78kfueer/lx/zsy+b6EUh9fNd40QhwtVolSRJGR0ef9v7o6CjHjx9/xu+cPXuWO+64g7e97W18/vOf5/Tp0/zzf/7PiaKI97///c/4nQ984AP8+q//+rd/4GTAr2ujkpE0sVfBD6AZQi6EyoKOhHHrCtQy2A7kpH4qHhe0/M1OwO3AsEscvBVWxiH2sIJzlJVkxIHjsUXkVLDrVXZbZzmzdZKy+6M99+GEWCT4FpALGVYu7cw4roAhVWL41Nt5JP0xhHBpnbsBRl+J2r9FKrwTGSqi4TTBtCQYPgZiE+IdjN13A4OJ4tSBR0j2BmBXKP9Njn3d3YRExChsMizRZsPYoJ1zUUbCl9uCgmxzLWkkHWYpc3P7KorYbJhHoNCmll5kIMhSJ80uYH8H1oXBfNdkLjaIGOABzmKSxcVjAIMtcpxgi3U2KTBLmTQZAgwk2yiSoco0bbqUOMQQ/3RjAEGJNCFpZE/C3MUgwKFEGgMTgwhB0IspqtMkhYlJChcfRYRCah8ZfBQmERFdnbhLHR+PmBQWDgKDAAvtshoSERKSUKdjBnx27jYu7FmlcN8sr3vs5dxTfJiVyj3IpAQDLt3VAdRYk8AURKUdKHELo/VhphomBjlCbFx6kkUS4kwHrqxD6iRsHYZwSWcReUO6by7sYKQV+U7IhIpJpFY8TmQVSwpODRZRmQkMM8DpNhh3WhS7iXayNnVLYrsLBlsQtaEzAOUtHSPlhmCfh5VTFKqrWBuKBVJMqYDUFuQsPV9fS8HiRRsrhvR0nc+C/qStj+9fSKUJsIFCCVBCoXo+AVJIlPARSiBFm6ecicM0CEtXPRuh7olVsa68RiYQaSJbyvciglRPvtyTRWPr6qrRI78S/V2p9Puil+GreuZVmFpibKZ6Ob+G7i2OFQQZTcpFj4grQ/fxmnFPhm3oeCPDANkFAl2BVn4v8tfQ7tQiAmRPhi21dFv0yHDU6ydObH3McU9aLRJ98jr60DB70UWJ0orebqjJsWFrWXhiaFLc8cALevJnqY39er3F0SVJfuG5x1Hoj6V9XCp43YFxXr1vjPvPVjm7ssVjaz6ffniZ2w6v8f+9djdp+7nUEn308ex40U2wLgZSSkZGRviTP/kTTNPkmmuuYXl5md/7vd97VgL8vve9j1tvvfWp161Wi+npachFEEaQpGFTIjMmJ6ZzpC502Z4FMQb5U+D6oDqbOjuRlI6xSNowUIeVFGbtk2TWHqATvBPS+yDxiIy9LNmLLFsBW6WAdHyOGS9gwpMsWGtY+Dj4JBiIMIWNTcEKaW6l6Oy5jMA7RenMMFeHL2PhkTHOGSdQcw8jCv+ZzKNVjNE63csHEZttiE+jWktQyiKWX0a5Oc5a4TRJ+uvgnYPwZZid1+ORZoWQVRFg4NGx63QmLkAJ8MZYEy0+21rjuDSoUGQWk6/ZbXIqIePaiFqb1sxZzp+cg0DnYg4iWDI2uS6+mhuZY4EWipASRUpksPHJAi4BDRK20+UVjOOhyJOiiEGGaXw2KSCAGAMDiwSFjaRDjImFhU0BiIkwcQnxiLHxyDKMQuIhiYiJESSYxFgEBL0YI4VLTETc6+brkENHHIUYOBgEhDgAKDaFx0PZJR7cczvtHVWcw6/jxqP7KKmExvAKciIHQQGiUZKmQBUX2Vzfw/DJNzDc2kM6gQ3To1FcRtohieUSDDXAgmS2CKUnMJpfxfGr4MQkKCK1iRlJhBlRDBT7AELtpbOYhaCk56CJUChhkuSnidIznJF1Ms3TpJRLx8oyZHvMmYpps8WxZgeVHgbzGPh7oJgHVYL0LroioeBsEIzYrMQRxXVJygPXBX9Uq6QvDi58x0S+S3VC28cPChQ9DyYlQJr4htGLBnKfWkIkWyAilJFAy4CUC4UIFixIp2B2WBNHI9Y99vVAm9+NDeh4JDuln4VFSscG+B1QHe34bCgwIygV9HbdLTSJ1o/y8CzwbO36ngjdQ5v0TKcMVy8bG1DvQjYDpZIm0QbgxEBbH6QjNBk1HMDVA4uvoNvSJDiX0QNBHOqkArpadm2ndUST7ehtSKmPMYg0gS0XNH9z0ZXfTgRrTV2ZDtGOz50Auj54bX1zbQUQhRAnGBFIbW/NpSvzfa5xFPpjaR+XEkxD8NL5QXaW4MeuLfPV01ssNzz+293nefdN21/s3evjBxgvGgEeGhrCNE3W19ef9v76+jpjY2PP+J3x8XFs236a3Hnv3r2sra0RhiGO43zbd1KpFKlU6ttXtrmhMxLz27S02SjSjG5myLgDmenQ2gNtYKQE5x1JTKDJspXSsRBdG4KHKVb/N2XZJGh/lmjiJdA5j9FpUGtOoibqqAFFulMl5UiiBuRSLh4WaQw6ZDCCgJZ3A2VzBawR1PYKsf8XnGjuYmzzzUzIWVZTx2HwCOUjilLJY3FwBjU0zEjrITqBj9sagMpu8psVvPR5Ltx8p9Zyp1qg1qnvPsFd52MCEROXOvqJe3kR0ptg2ZATyG2KlYULhKf2MpP4LGGy4sT45S6TKw65xRk6O45Q23Yc48wOvNggTZqtAZs7/Ad5dWeKy8iwn4NEhGSJiXEZxeZKxrkexS4myREgESgMHGJAYZAnoINDBoWHIoXCwGKIhAADG4VJhixRr883JiTGJsbGBPweTe7gMgBEdPGJ6aIIMAjwkUCGhCwwSAlJQIsQiUGTFo9ZNe4dWmB18hTRzifILq5QuS9LXPsKTVUkxwiT5+c5ZTs4q9sJU0MMzN1P56GrGFv9l0zKQerGJsenFunsWkDtWtMVmMjTVZiMhVFbZmz5FL4dYmfBSxw6ZgqiGFtEBJkcKnQ550qapk5TKpoQdLXha2K6ePECeKsgbEQRBtyQVBWKHY9RS7FahGQ4wbSXiEdntEzTyoB1AuJ5mHw5yeAtdM/+Ddlzj5HNSMJ5yEfQWAYbkGsptMbz+UEQI77DxE2h+tO2Pr7voTAQCF3t7Sl7NcEERQKy+42/4zilDar8FKQKmnx6Prg22KZ2VBa2lh5nA8gAmV5EkaV07JAINKk0pCa6KtFGUSS9zwzNh9xeJm/OQmuQDW1qFfcych37G9m8T64nDiGV0u+pro4vEpbeT9PV1d+g05M6K3B6xlV+V2/DRkutIyCw9H1Dl6nBM7R6KkaT9wTdyxugq92B3Yt7Ej2zMKGlzm0fOl1tiBX3yu4ItAWZiYBew8qliecaR6E/lv5jwo/92I9x5513cvPNN/OXf/mXL/bufN8j45j8f6/dzf/76cf44y+f5icOTlHJ2i/2bvXxA4oXjQA7jsM111zD7bffzo/+6I8CusJ7++238/M///PP+J0bbriBT3ziE0gpMQwtEzp58iTj4+PPSH6/E8YvnKVbWKFdWEEVd0FpFga2U5uKEKe+SHogprgDIhvidL4nQetFWWQVtCvQXSUyPPwADNrQ2iJ/9i/ZsXQCpGBhAGqH3kSzeZx8eA8VI6GTNrANH18GxKSQiYLWLmJ3kJxVpbPxOSYeXKFdPsYTnTy7vTfQYAAld+DOHSNIz5Nsfx2ESzRUlbDyCmiUse4rMnFmmK1UiApCqD8OUQZW8sipU3Rv7mhtrDgL7UndS+Zme/EdUk/QdrbZUsdptccwpYFvWCgjZD1TZmRjhmDSJZqtsRVukVvIk00MBlsVnhha56HuMi9RQ9gkZEmwKKHIUiTmeiwsspi4pMiyiaudsElhk8bAIYsNCByyRLSxsen2aK0mw0XaBAhS+PgY2GiK5uFjIHoiZ4+IkIAaXRQOPgEJOtvTwMDFJY9BgyarYpkz1hoPjZzifKmLO9rCGHocYXaRVZtozWLM6XBhYo2FC8tM+zOMh7spH93PWirF5oH/itmwGFl5L1mVwRUbnNl7nu6hU6BOQDatm2vDDqJ7BjYlFa/DgJVgpeCkmcaz5rShjdzANx1tkGZI/AHoxhZLhiRnSOa6en7aiROibpfYcqBSwbSaDIuYgoBWHs4FKdopSPKKxNiE7nntHMvjoBa14Y65C6YOEM3P0Dz7GO7Rz5FaO8UEMduETnNJyYDzF3E9Gc+DAF+qNZ0+fpBgAkJLoaVCIQCr11IbQ9zuEcoEIbOAQnmGfjAqHR2N5OS0xFl52s3ZtCDt6R4FmYUs+s4rHd1SY3q6nUY3wGqSSAQ5D8y03qdOpJ+ElRzdyiAsTW6DnmzYsbSLc9KLS1KJ7kc2MkAMSQNEWX8WKpB1MLbAVZowWxKyKb2/rbYm2mlTGw3Epg6jd+Oe9DnWFWjZI8DK1t/r1nVlOxIQZPV2VI/8dhS0Ex1/1G7pirN+/tnLNDb0+p6yKLw08VzjKPTH0n9MeO9738vP/MzP8Od//ucv9q78wODHrprkv91zjsPLLf7giyf4ocvGObuyxfwEHJofwjSeS0HRRx8aL6oE+tZbb+Wd73wnBw8e5Nprr+WDH/wg3W73KVfod7zjHUxOTvKBD3wAgHe/+938p//0n3jve9/Lv/gX/4JTp07xW7/1W/zLf/kvL3rb5WXICp/UyBKtHRbB4B7o5pCD11KtreI0j1BPKTw7TSJmIXEgldVP4c2GLsmFIwg5SOxKgsEfB38KURcoQtplSXPuOpzWIuWtx0jOSRpdA29oivRShCe7mBQg1YABibWZZrDg0q0tQGBSyngo6zE6vJrAGEGcvpagsguG5qBVhukcoRiFo2UypzPMrE1QkCkW1AocuxLGWqBCsIchzEGrCcEWqFVd8ba2Q3Masi5kFBg+ZE3U1FnCaBWcaVgZBM8hGAnYaFWYfGI/y9uWiMY3WU6ybLYlqbaBl5J8fPQ+9q29niwWiqyOFCGHRQgofGIkBl18XAwSXIpY0DOuStD9dyCQpHrmVRlibCRgYJDRJRQEJm0CIrrE+KTJsEpMqzddHaDMIDZtYpoESDwswMckjc2XrPt4ZPwhqpNniSbmSIwSmENgn8doJmQsSdTIE1bLnB9bJhibobEacCHKYClBkDJZeeUXiMsuuYfeQ1qV2TCqLO08i7fnDqivwmBJTxbtLoQeRF2QCU4pobWl/5wiP6+l9VECmSKiUEXYCdVggFzcpGgopK2wtmAkD0umII4Fo0rSMEK6SUiUlFgoB9hNQXV4jEQVIZuACBGtGnb6ASJ7BOIOue4mqcw6dbeCCgwYLMK2a4jGR4iOfZ7VzbsZX44oJzDgcFEE2CJ4TgF0f9LWx/c94hgl9HNBjBihDIzIREqJwsBMTJSIkVaMsnutMcqCblVLebM52PR1T/D8kO7XRUGmqK9zdwvikjYwnLQ0YfYtGElpebQtdB6vkmBXtEzZsKBkaILbinQ1VinAAzGs23IsTz9Ii2Pt8qwzjKC5/A23Zl/oz+1E9yLHAuJAS7GFB35B9/4GbUgXdK/uZqgrvGT0drSFNXTaWvbspDRfjRVs5nTF20rBRm9//AjqdWh1YG0ZOi3tm5Gg84f9rn7mYEAS9yKbLtn+3+ceR6E/lv5jwk033cSdd975Yu/GDxQMQ/Bv/8k+3vKn9/GJ+xf5xP2LvU/OMDWQ4VfesLdvkNXH88KLSoB/8id/ks3NTX71V3+VtbU1rrzySm677banjLEWFhaeqvQCTE9P84UvfIFf+IVf4PLLL2dycpL3vve9/NIv/dJFb3umDRst2NeQHK+tc+rGEJw0ODZq/k0E1TyBvQ4ZBwav0jf2xAZ3DYwLWlZam6C995/RbpmwdAi6Lu5cCS/u0KoMkGSG2X7PFxjutmidtVDCgHgFK0lQBARY+PkVCM+Q1FtQBNtQdKdjZkrgZrfw2hLSixiVU6ihJnJuHQpDkEpDawLz9C7sWkDTatNW63i7AyiHkJ8Bcwu29SoB0bqOmigf1MZLAxtwuQ2dHCymoVPRTqTZLX2HPd3RlYEkA1fFBO06S00bdWIIo9UiHpfEqTqekaK8Ms4TVxzmA/wv/s36W7BUhIs2gUpjokhwUPhEhHQBG4nAQxESkSVFhoSIEB8bkwIJFjExDjl8Qtp4hPgYNFEk+AQ0hMtRq8ZJs8bx8Q0aZQ87cDDsLCJWiChDrpsn27IZCy1KScyJ4gOcuOxuYuGTUSEyLsHWNExHkJJYvkHWMHArU8jp/cQTR2AhR8MZ4J7L7sJsLJNMd5HZDrnb38x4d5am6LIw+TDB7N9BkIPyDARL5DtHkXWTwMpBxiDJGkQqwU7DqpMhbpUQqoFptIhzKTBNlGGh0hXSqkkhTthSEBVhy4RztoHyoZiGnJAsiRauGqNWnMAa3sQ2Gphmi1Tg0pEDGL5kYqvFVt4jDg1KKmHK6NDNf4aj2SZK7oXCiDbW2fYjbGY8putfx7hfUbxIbwmH5+4Afv6C6j76eLGgyZd6Sv6sUEaPciipK5ok+uGiVPqPXqZ1BVQAHV/311qWNn/C1CZR7Z5ZVc7Ujf1Wr6c3tCBJ6Srrk72+pqFl0aJniIUEKw2+1JVT0XN7TnoOzELqLDR6+b6W+Eb+r0x6hli9DF8lde5wL3IYIXsVWEuvL0kAS5PbINYybSl6jKs3XVASreNWkPS+F8ZaKo3Seb6tXo9vtwMbW9Bug9cB34XQ70mnI328PeMrlLqkyS889zgK/bH0ufBrv/Zr32Z8unv37mc1V30huOuuu/i93/s9HnroIVZXV/nMZz7zlJLxm/GhD32I3/u932NtbY0rrriCP/qjP+Laa6/9e9uPSxVNL3zq96tmynzwjdupRjYf/spZ3v3xh/nw267mNftGv8Ma+ujj+8AE6+d//uefVfL8TE/GrrvuOu67775vX/gikTkC821IT0CllcA1CiYzYGehmNGSMPsomI7OdSzasBBB/Dhm+zOYsSAu7UFOXwXBBHTLkP0q2fOPsJk3qZdvBHsHYfYLtAPIlGP8igmOjXdekqg0kfKQpSrT4i62RT7Lp6BSgOVRaFrQrbhE6w3s5F5mt32NVl0R1i1qhd2otQpkNkj2PEpLeLTcCQiGIfc4VM7CwLDOgFwZ0seSGgCnCB0LBtZgM9bZjv5RmFeQ2g7nB6GxAwpLemJkVCFM6b62dJc4thAjWQYWRmg1BSQ5ZMajEBUZPXYj911zjH859Dl+/viN7I1BEdMhxKKAxwZ6uqPrsFkMFAkhLiEBKRwkApsMHQRtQiQxMT4FUhgkmBh4hBwRF/jSwGmO7d+gM9wgyfhaKmhMw1obZzFLppHQ3LcKszVw0xxp1RDdKjJdgFYRsdzGy2VQgwLmajA+DadfQVS7QCNpYQUz7Dp5BcGZCTalQXPfBWxuZ8fMBmcmZsn93dvZu76Xmm2wMPRlgp2fhU4MqSJ0ClBKYfgSp5GQCmLShZDatEFOQsYEw02BAfmwQXYgYXOgiIzLCGMRwpitJE8r6VJMJ9jAalbgWmkGgy6dDkwHYK2GbOZXqQ/PgVVmMlwl5eio0URs4uXydJTJgIxwfCh7MLoGs8NtxMBtnBrfILBfoSefYoC4uIfNzGNkAx937eKuJ5u+B/T3GhczmfrTP/1T/uIv/oLDhw8DcM011/Bbv/VbT1teKcX73/9+/vRP/5RGo8ENN9zAhz/8YXbu3PkPcjzft1C9aNzEBAHKfpJMKhIMUAEiTlAxQAeMLliBrmiulsEuQSoHxZo2hhImrLQgZ8PksL5ARRc2TUjbkC5pshm52syqYH3DByrs9oy4cr0s3QRGbE0U3Vgrd1QI3a6uPmcymiGFMQQhGLmeEdaTFWMgXwZMLVW2Ek3WnbwmqYkCa0BXZn1P/x4lurptOr3e4gCcEe0Q7cd62SDWbtVhoGXZ1fPQ8GAjgAsrutKdBwIfggjh6TxkZaL7gZM++YXnHkehP5Y+H+zfv58vfelLT722rGef6t59991ce+212PbTe0mPHj3K4ODgtyWVAHS7Xa644gp+5md+hje96U3PuN5PfepT3HrrrXzkIx/h0KFDfPCDH+S1r30tJ06cYGRk5AUeWR+JVPzm545x3fwgXz+3xSMLDZ5Y6fBPrpnnT95+kHd97EH+/eePcfOe/jnu4zvjRSfALxa6RwUFS+AHkuFBn+Jjj9Iauwyccd37VJ6CTgOiBXAfBWcK5D44X2Xq9BOMrSQ0xSNsLX6BzevfBlPrOHf+d6ZPbtGeVtTtAgxfzoW9P4IIFsgtbuClxonXb8QlpT2L0wFOqcOeOGCxA2ETUgOCpGTS6UqiQoRrb6FURHZDYS/BVkWgLIFYOoxwOsgwCxMT4M9A+jzYLmwOQEFCeofOOfZC2JqDtRJETdg2Dm4RY2sWwnHUYBMxkEFGEgZTkNsGV23BWQPctJbBTZnQKqJGUtSmF6HexFnYgxnmWJ1uM705xfzdV3L+4Bq/9trjvOGuPJd3R9ghbUpsMUyZhIAmHlt0qZKigEAhcDCx8QlJiPBxKFLAIMFAIXBxWRR1Hsme5pGxYyxNrOPu8iBlQ9Db38NDsJZB1AXlaoGofBbyKWgWoXYa1ayh7DI0xqAZkhtdxfVGUd1r4EQJVhepHB9h38ZNdBPBkcIGG5kml3dmsTItWpmzjNgbbOaKZB56DdetHOLw6KNcuPpLGMbDOikkn4FkEdQKeAmtyjQYg6BCis0nsOuSlgVmFowoA5UsBSXJAc3AwGcUO7WEVKso18SxJJEN+TQ0LBt7AwihbYH0YErCtnbExvoZzs9ZmIOQFboNTzqQNroYaZhtgVWFQgDxOrSbcMM1AbPtB7hdRvipyyGlwDdpeg6R45Nef/Zr55nwpDjy2dCftH13uNjJ1J133slb3vIWrr/+etLpNL/zO7/Da17zGo4cOcLk5CQAv/u7v8sf/uEf8ud//ufMzc3x7/7dv+O1r30tR48eJZ1O/0Mf4vchElACEatv4mYRiAQlYixp625hGSCjKkqEKCqY0sdMcoSdEW1UlXag2YRspFsi6EUaFU0g3au+bmgH6JQFce9qUon+XAqoAp7SZNGP9MVm9FZlOFCY0kRXCRBbeleV06tYS4h7RDkxoJ0CT2jSKmzwQ+hu9gy00FnBshe5JCMd7aRiaHsQCF25tpSWZHt1iFIQFbTzc9DVld6mhEYEjY6OZSLShN3XDwqE6hWv0RPaPvfVeK5xFPpj6fOBZVnPaqb6zZBS8p73vIedO3fyyU9+8imD1RMnTvCqV72KW2+9lV/8xV/8tu+9/vWv5/Wvf/13XPcf/MEf8HM/93NPtfR95CMf4XOf+xwf/ehH+eVf/uUXcFRP328pv7d/CVJKlFIvaDsX893ns+w3L/P183WW6h7/8Sev4P88lufP7r3AB7+ywC2Xz+DYFv/sxnne/JH7uP/sFrvKPG2937qt7/T6Uj2/z/ezZ3r/+bz3vT7HF7POS5YA28qgiIVfCnB9uGrjMHc1qyhnG2CCPQTpOogMhFndx2TH8EAd9+5pWklCs7RMYbBGdeph1MA6ZfcUZc/B2XBZHzhDOF1HFV+H8izaQ21YWoYjs4SWDVkHVIfILHDGtWkNhWQGBY6lyMqEoAVBOkuQarMtvcywC/VRqOdMWLmAyuaxuz6RUUR581ApgtvUkyAnBU5bG7GU03B4AAZyevKThcyZvZSqM+QTC0gh1lPkRUDX9FkaOou7fQPG0zCYQ3QtBo+PUyueRbqurkDMBTDdJdy2gDg8R64TcmHfKqbdQlYt6in4+I/ew/8IY0pn0kyf8UnHLrZp0nQ22ao06SQxRdIMeGlGG6OMRzNMJhN0Dclpp8aaVWWrUsUtF0icmE62SzxroyYWoaGgG4Nb1j1wR4fh+BbMdlClNBvbJNib0BFg7NORJOMZ2CpByYWZeTpyGC7sglNZmEoQC00mVq9kSo7zpeGvEs4/xiYF7lseR40vsXP8UTqJSfzQ9VyxdAOPTd/J0sv+ClVMkVQP9rI3c7p0X1gGZ0Wf79waoubSGt6LEDW6VkDHiYjNAqQzRJaB7yZEnRg7OqP9PTcEoykPLHASWA0G8UcG2emeQbmwMaYPrZ2GvAMjzYRKJ2HFgXoJWjmIHJvhJGRmHdIuFJf1/DOpaL8cEcMVbkxLPsLXm12CoZdBOk0wlKOdaWFenKccWX3VPCv6PWvfHS52MvXxj3/8aa//y3/5L/yv//W/uP3223nHO96BUooPfvCD/Mqv/ApvfOMbAfiLv/gLRkdH+d//+3/zUz/1U9/7g/qBgNKmytDTpkrN3AyFIU30X3YMeGjS2kRIiVBSt8k4vpYCB4F2X255uhLsGFrSnDJ0a43Ri/8RpnZNhp5suffjSV2xlRaESU8mbaGvOhOMtC6nSnrM0tRSbHr9wiru9deiK7ShhETqe0QidbKBEHo/Eqm3I3vri9HybT+BwNCHakVaCh0rLX0Ohf7cjXS+b8vXcnDP08QaCVGke5BjqQ8VMHsRyH1oPNc4Cv2x9Png1KlTTExMkE6nue666/jABz7AzMzMty1nGAaf//znecUrXsE73vEOPvaxj3Hu3Dle9apX8aM/+qPPSH6fD8Iw5KGHHuJ973vf07Z1yy23cO+99170+j70oQ/xoQ99iCTR//r1ev0F7dfFQClFo9EAQIiLM5a6mO8+n2W/eZmzKzUAhuyIt11V4a8eXuJ01eOjXznJT1w1ypCtz9G5tS1GelfTk+v91m196+s4jonjmFqt9h1VA38f+H49v9+6zLN99kzvP5/3vtfnuN1uP+9lL1kCXM8nDIwkeHltXjnV9Rg8/EWqb7wForqWkpXm9BNvDkLVgNY6hrGILUv4uKTJkt3WhUEbghPEBZfUSEJgmsjZDsT/A7vaJi5fgQoHIevr3txUBEYKqGLXjpISMXIox1YpRcqqYVYVpZLgLC+FgoOa6xKasFESRKkMtuMTt0uMtjeoRhKv2YTcl3VFYWgHbJ0Fazv248OMP1amWDdxzQilTFJqF9ujcVI4pAlpYDJMgbQKseMWD65N83A3JExFkFaoKZPR5UmKj5c4N3cY1Yrh8SGYKcL2Jhz0mbttiuGjgvuvaNO9PkIcGYOHtqMGz1LbOUZtmwT36zDQodxaIt2OSUVgWxa1jMl5uUgnWUfYeVRWoGyly5RbBSiWwS6CDKAVQ/1KmLigJ1yLM2AXEeeaYHZQqXvBLEBmD2xE2uzlcABDIzDc/QYTHBOgLtfy7qgOhbOozUWO7Jti/WSLhl3Fbh/FdGK6B3cy5S0wV/K4Y+UyhldfxQPX30t31106D7P0UijnwG3AVhayMxA9CMEyWGsQK1QlB9kJlGVD0ia0HDDKYGzSSRQqAjNq4LiCRIGRFrhpTVJDTPz0XkiNsjmwRqneYnwT3AKUbK3SbOVgDkh3wUtDR8KyGVJqQ2kTamlNlsdCiBxQWW0km8/AriAhNE7xkD9GbOzHz+TxZ0G6wIXnfz059Anw9wp/H5Mp13WJoohKRQc8nzt3jrW1NW655ZanlimVShw6dIh77733GQlwEAQEwTe6D1ut1gs9pB8wCIToFVOFrXt6iXuZtQkShUzbICJwzxIzSqwqsBpBdwP8ZW1w5afBMsHM61zcpAueo+8fIxUt6wiaUF/X1dpiCXru+JieNpeyCtBoaAKcrej1SqCxpVtcrAzEeR3DVHDAzfUYZldXkmUMnXWdPayUvjCV0m0yidTOzY2kp022wZyAMNT3QZXX5NsPoLYBODC2Axob0FiH6jnY6sJGFxbPgRf0op6kJtZR2OtJBmkaCNmLUnrKDrqP5xpHoT+WPhcOHTrEn/3Zn7F7925WV1f59V//dV7+8pdz+PBhCoXCty0/MTHBHXfcwctf/nLe+ta3cu+993LLLbfw4Q9/+AXvQ7VaJUmSb5NPj46OPq0X+ZZbbuGxxx6j2+0yNTXFpz/9aa677rpvW9973vMe3vOe99BqtSiVSgwMDDA4OPiC9+/54MlKWqVSeZoXz9/3d5/Pst+8zPyEAM5QjWyumhngF17t8+t/c4z/fO8yP3n9DqrdLgBzY4OUy09f77du61tfR1GEZVlUKpVvk8T/feP79fx+6zLP9tkzvf983vten+OLWeclS4A7DrQGgGFIp6G2ANO5w1TrJ7TTciwhHgPvDvAKkJoE9ThyRw3/+FnstkVl0iUpWChjN1TqBPNnODPisTx9FUl5Art9lAPtE1Qbj0DisD4wQrgvD/VBvU7WyW0uESPxdycEjsdSFvBNwsIUFK/GCI+wIKbZ8AfJlJa4ljrnm0VWkzG2onMEIouIT2GuNoi3HwBzHmbHME5P8ZK7dvCScAQLhRs75FHEJDhkyGLRpckIkgEsMigCMlxOllo7z+nFBnLbAsQWJ24UXHHHMMnh7SyXV4hlGhY8GNiGmm9x8kcazP3VTl5+7zx3n1yjc90i5rkU1pEs/ugDcLILLQVcTrPk0IzXEEWXTX8OkYnAiFFtD5VS0JnEODOCLAoYbkDXhWYJolm4egPxUAFVvwq2KcjUIRWSbpsQVfDkCIa5jozyupfbysFcDNmT0EpBoQDtTQQmym7oTE7P11LqIRsl08RWhJ11sOYj4sUA5/wxxvMRZ9eLRCevprX3b4gPHkO4Fpbhknh/hcxPQz7XK8t2IVjUpjaOo11gCxW9LfIQbUASAgZEPp6Rwi/EqMgkNNKYcQtHJEQSjIygaRUgNQjqWhozIVLdwUzQJZVAKdZZ1TbQtcCOdNSmMqDQhXQVWo8JIkehCtCswOignu8WgXATknGYNWKq/r2cyaZI8hmiYYNU9eKkKX0C/L3D851MfSf80i/9EhMTE08R3rW1tafW8a3rfPKzb8UHPvCBbzOXuRSg0FpdTYLjXmytIOlVhBV+r184AVv2IoK6YGQhKCGqQ6jyoM709dp6LDQiyIbQzUFKQCHWfbtCalMty4FUXj+pCmJNPB2pc3nNXlW31YJMoecCnQeR1o7Unq2zeF2pL0qZ6Cxy09bjkeyZV0kDojbIUMulk7BnjJXuOUQLiGqArft947TmqjKnyXukYGkTWnXt7rzWhI0mrDZ1FTiK9fLEulqc9EYIE6xeo3WM6KfafhP6BPi7xzdLky+//HIOHTrE7Ows//N//k9+9md/9hm/MzMzw8c+9jFuvPFG5ufn+a//9b9edFXuheCb+5QvBoZhXDRpeiEQQrzgbV3Md5/Psk8uc2h+iKmBDB/+yln+5O0HeduhGT5+33lOVz3+wxdPsdbyma5kODQ/SKNe+7b1fuu2vvm1YRjf1TFfLL4fz+8zLfNsnz3T+8/13vf6HF/MOr/3/8LfpwhTsNmB4KignoPDi2Ccc6F5CowAkk1QNpnD9+Gc/jh0HoONT0P2At4bQtIHa+RHI9bGHe3823wV3dz/zcKOV5IMjJI6fDcjj59mpAtDHclc4JONWmC0tdzMMmCkS2M4IRyEvaGPEDG+7eDvu5z21FsRjxnML93GvtUjeH6G9kKFdSnYGpxCqCYpIZFDFdRgiXjkAGSvgGqazN8NcvXfbWNHOIJAYGMwjUkWSAE2MSYBFg42FnbPjiqNwQQFtpPHUJsQHQZ5B3HqcR7bdxSp0kxtTiHGYxgyYKED6y2C3SZ/+2Mt7q208AopeMglLoX4GQN8C2NsC3YosBZQcgQ1aiGHJ2HMxGaDtFtDJBbkxyEaQG5PgyGh1tCTwoEVGD0JcggjERgLj0FyH+RrUFrBu76F90oJB4rIqQCKd8PEGvhbEFVBdsBa0HrisQoqvxdKOyEch1OXY6xdRfbE1XDGpD7h4e25QLYTUU4p7E5ELRCcP3EFplPjiv13sd1bZ7ayTDbV0JEl6Q29LXsFw/4ypC0tc8wN6xNeLEFlBnJjYPu6ty9XAMMDcwjTTZNtBJiBy0AgyaDb0CNbIC0HSlX9N2nN4lo5WhIyEaya0Ax0pbhb00awTgemgD0hjB4RWIs2xoLAPwb2OtQErA1ClIdgEOomBDbMmT6p8BTkM3TyNuoiW0Bt9OTt2X76UfUvHn77t3+bT37yk3zmM5/5rnp73/e+99FsNp/6WVxcfO4v/SPA0+iZ6EmghUAJgUICISQ+JB6YLogasArGKiJcx2jU9IO2wAe/DZ0OtDvgPumUHPV+YugkuoFfpDVZjXvS4laiexjCRPcMS6DT1f3AkdKyjifzeH0buga0ehLlRGpzKmWBSOnWjMSEyNBGV36so5h8Q2cVi4x2/w8dHXcUxFqmHff6k5MMxCkthV6pwmYDar1YhY0GbNTAi3oEONTbDsMeATbBMDB6NttJv6P1aXiucbQ/ll48yuUyu3bt4vTp08+6zPr6Ou9617v44R/+YVzX5Rd+4Re+q20ODQ1hmibr608301hfX39evcl9PDtMQ/Arb9jL7cc3eNfHHuTx5SbvedkUAP/9/gVuP7bBv/0ne/t5wH08Jy7ZCrBl6IfnnQa0AAwd10rSBLmpn1h317E7DQpL61TDtpa8yVn87Ba18hLplqJ8uk20+J+J3QrdA29GXvtWxNE/Jnt2A7GlIxYLI0AAlkr0JClyNMMxxlDZKTzOMJQPGXYUa8kQqns1xpFtpB/fpD6V4Bgx5fhxxiKodkqE9s2UjK+y141YkA+zni4TjV8JboXssRxXHJtjuxwjS54UkoQUPgqfLmnyWIQ4vf9vEmAhSMijSCgCY+RI1BE4oWDShnNN4tw+NkabjC6PYyy1ScqaeKlEwBM2UV7Sng/JbuTpXO1CfRHL3YF5tkp5usF6YMOV2zUBrFigxqA6TFgztVFUTkLLhKkOwrofZU5DcxDGljXLczKwXiep2CCb8AAwH4G1EwY3wFyFpA7OIDSHMM4eJi0D3LgIQQIjBRjoQO0gyFE4UIYnTFBjFB+QXOnNcc/eZcIdFyDvYXgwhm4Z3tyfIvJHSIWPczYjKfqAK2glZZQagI0Qo7FASgimhwPOne4SGQFQwDKbUPWIZRHEst6XbAjROqmkSZCMI2VIaPnkWiFpSx+eGcJgR1JNN6mVIsh0wC+RywakgNjWc9+RFpRqul2vbunT6LR1UpdcE6SmIigp0i50ZqDQ1qezMQWzCUwLqAO5NEy7FziTMYhG0jT8iwvayPOdB5P44i7PPr4J381k6vd///f57d/+bb70pS9x+eWXP/X+k99bX19nfPwbmYnr6+tceeWVz7iuVCpFKpV6gUfxgw31FE+zAdmLRIp7uuiUlj8bsa7MGqHuz7VMRLKJkWwhN31UO6cjj9SQzma3TEhciAc0+c1LqPSMojohtLZAZDXhLUigq2OEosHeAGBpl+cgBQ1fDxqmCU4BiDQpd3uZwlEOcHsy7UbvOGxI0iB9iF0djyTMXktzHnxHO0S7CrwuqBa4LlTrsNbSFWY3reXX7QY0FvVTuHTU6yMGEHpwole9joDYIkz6I8Iz4bnGUeiPpReLTqfDmTNnePvb3/6Mn1erVW6++Wb27t3Lpz/9aU6ePMlNN91EKpXi93//91/QNh3H4ZprruH2229/Kh5JSsntt9/+rKknfTx/vO7AOB9+29X85ueO8eaPPD0VZudontfuH0P1nfX6eA5csgQ4bkCrBOMvV8hViD1IygYEPZlXEIFbZ/R8QPFEQDY+RSOVInsc8iMh9akMpyaH2LmwTCFqYZot2HiYtrgOHqrjLmbIGYJwu0tNgarCwHiXrUwNlU/rSVJrG+x+K9WRj7IozvHSSszttXFa3WuQjS5+ZhC3chnT8qukPcXGSIqunMGxT7InOEazBSpRJOk5zCMTTB/bx47uMDY5ujRxiOhikUbiERIjMHu3z4AGAoVDQAAUsTBIkyZPCQOrUSeaNTCaecT6OMl1TYIbsyx/ZZnEdzBXJRYWwfEcVqSwPZPggMGBx/JcGDhIdeI0V9ULHBnbRdVxoOtAPUP65A6C/UMoK4YoJp2/gOIcRpjgVa4E5lHxNYihI5jBEeLVQd3ntrEESQ3yRRCzkN2AYAMSB2NrC1kOYcKGcD+spkGeJyWaBComGUjr6I+VeWjsgdFzYD4O5QoYTZqR4pGqiXMhR1gahQsl1mMDp3KE8WzAhmsilqYY2PsgBwQ8akHby6OcWYgkZrJOkh4hXNwO7btJGQZxNw1JjFFKkQ99aomLpZawrQ6emgOhUG0Q1hrSGUYaCdKu0gm0EXemA8U2OOWQ+rhCjaWhW6I5+Do65mFIxQi1TIYOG6ZOtHJWtDIxNsFaB2u/JDMKC1uC+GrFWADWPTBW1tLptTI4OV0wMn0Yi2O26su0hgtE482Lup560+lnRf9Z7AvHC51M/e7v/i7//t//e77whS9w8ODBp302NzfH2NgYt99++1OEt9Vqcf/99/Pud7/7e3UoP/hQkqdqwkrRCwJGSAlKoIxES4yVxEw8SLTEV7GMboGoaHmy5UKroHt5VQxk9VPZgJ65ldRV05yppcuRoSu42PqilWgtbJTovl7D6fX6Sq3Vluh83rh35QkTfKH33e9lDotedJOK9XeCnuOVLfXT4DAEU4AXQzuCtg/dNmxtQd3VFemW0lVirxeb9KThldE7P3HcyzLu7Wui+jbG3wHPNY5Cfyx9Lvzrf/2v+eEf/mFmZ2dZWVnh/e9/P6Zp8pa3vOXblpVS8vrXv57Z2Vk+9alPYVkW+/bt44tf/CKvetWrmJycfMZqcKfTeVpF+dy5czz66KNUKpWnzLZuvfVW3vnOd3Lw4EGuvfZaPvjBD9Ltdp8yMuzju8PrDozz6n1j3H+2ytmVLYqFPP/6Lx/n5HqHzz2+SiVnc3Zli/kJODQ/1K8I9/FtuGQJcKUC4gI0ZyHJQboMa7OjMLkXXMAzsaoPkV0OyRwrMKDapCo+pSbUhlPU5l5PMnoVxyufoFw/CR0Td/ck+AFqR4XQqGEbNcwclLraY6SLwvBqJKUI3KzOw6nuR47OcEFeQCmJ51VgqoKR9ZhvpggenmB8yqAdJpy4bAQ5PkB27QGWA5Na1sQr7EcFNzN5ZBc7vUE2iDnnbJGSDkNxgiF8OmYdUpIpL8uUNBgCij1pdB6ThAgdVOFhYVFgiEHvDaxFdajmUVM1GHwc8lMkV1fgsQmSwTbJWA6xKZg5a+EairVEcWr7IlPHS9TdbVzOGOL0KOK8y3lxmg0jJuetEw2GJC8vQz2HH96E4T2BGndgdRLr2DCXrU9QTXdZmWnqiVlqCmyDTOcCwqzjzpegPQarEWZynBw12u1p1JlrwalAUEFWTBridggb2kF1PA1DGSgBPliPPkqm1aKTyqKYpHnNBKU7J5h8+HJWJjeRmWEWmtfStB9ALpZIJ+O0xi0e37DZmlVIu6AzONe6lOJNGuZlJNFNNLMnSIIplD0E1gmEkljGOtiCuC6QDqB8EJIwm9KSRtXBMbpULPCzWimYXQU6YE4phN1GyQLkRqH0epLtO6HRRNQ+j9/ukncUxhlIHjCIEhCXS9a3CU5N5tgs5giuiNi+WcN6VM9H7Rim2rDZUzxupSCbwKgJ9Y5LM5NhaeBJh9vnh+eS5vVvPd8dnmsy9Y53vIPJyUk+8IEPAPA7v/M7/Oqv/iqf+MQn2LZt21N9vfl8nnw+jxCCf/Wv/hW/+Zu/yc6dO5+KQZqYmHiKZPfxDHgyKuip/kAFJAiptCWWikGBUAI71B3CEQrstjboSwC/oyXO1oyOJ/IakJnRngG+ib6aeuZQeUe/37aBjK742mVNeuNEZ/1aEjJpTWAjqTN/VaIv9sjUBlRp8xvS5zDdk2q7Wo5tAikHar6uaBcT8Bt6faoI7VBXmC+0tDlhc0MrWfwINmt6O0ms84FRutfZ7rlJB4F2sxaab+t+335l5tnwfCTO/bH0O2NpaYm3vOUtbG1tMTw8zMte9jLuu+8+hoeHv21ZwzD4rd/6LV7+8pfjON+IPrjiiiv40pe+9IzfAXjwwQd55Stf+dTrW2+9FYB3vvOd/Nmf/RkAP/mTP8nm5ia/+qu/ytraGldeeSW33XbbM+YK9/HCYBqCl84PsrMEg4ODnK66/OHtp3jvpx4lefLBG2eYGsjwK2/Yy2v29c99H9/ApUuAxyFVgeoTMD4CZ7aZ1K6/Ut+43RBqJ5HpC9QDh7IsYm66WOMJ9R0pzt9wM8nI60GZBGM/y/qhR+CMBamboDMCl/8Yqnwfa+FRduZOMn5EEQeQjRRG4pHEMYgQsKA+gDh3iF07v0bQgMTZhPMuon6MdPo2xtJnMEVCPAG58hpty8IdP4ibz0N7HbrXk7vnWga9DJt0uZBxac0F4FpsOhGkYhAeGC0W/DSZapmxeoprkxTbsLAZxMbARFAghU+KIRxe5b6K246fobZzGbHjXkQjRjGjrYTXOkAOcxGSlI0rJN0BF8ZjtnZCM1kEr8KjmQZ+KCDK0Z1bZij3CEWnizc3gNt9CUQ+mEWkehk0TAgckuHTLCLI1CsYZ15DkmlhNSchPUs0kUCliKj/GBOHBYE6SvUVFVrhBnRNyHmgHoP0XnD2ocohLN1FNqrjxwHSc6CegOoiVpo43Q7GmCAx1iHu4OcHMOIAdW0L1pdQtYTG9E6Kj11BOjNOY8cg3rlNVMeBjA1WGxxFwy9rld9wnaozh4wVVMYgWiZwxmg3VhHhBVQ5hTQtrK06jpsgkwCV9ZB+l0o2IhgziAOFYyga2+Alk3BY5JDm66A5BsUMNC6QqX6ezFKTUbnMro4iFUBtTc9Hhx1FtgSPl+bZmh1lRB7GWuhS/qJAxQprXLcWpkLtI2Z5wAK0q1C4HIbyYIQujcCmT4C/f/Bck6mFhYWnmT98+MMfJgxD3vzmNz9tPe9///v5tV/7NQB+8Rd/kW63y7ve9S4ajQYve9nLuO222/oZwM8FBU8F1woBtoWMEoRSmBJsEkwkng1IEyMxSMK0roSaCzqD17S1IVY7r/0ArABqKdhMa/+AtAnlFKwGQKgdpI20Tg8Iu9pwyxI68s6ytASkHkM3gUpbE+BIQmdL9yznLHBiMCVYie4VThxIynr9HV/3ByupjayMvP58pQnVrjbM2GpA4ILvQ2NVk9vQABK9PyLpRSJJnW+kJIbZcwGVfdr7fNAnwN89PvnJT17U8q9+9auf8f2rrrrqWb9z0003PS+J7c///M/3Jc//gNg+nAN0tvg/PTjFe64bpRrZfPgrZ3n3xx/mQ2+5ipeM97vo+9C4ZAmwPQzlAoiHtOlmareJGh7SfVNiEzLnkJU5wtkVomMhpAWtEYelnTeiZieg/TikroFFA2v1AsKrEUUT0N4GmZeAdQAv9z9ZU2eYnYlp1aCowFqLiZ58Op9IwEE8cpD1/E72bDvOshPQXDrPsPcxnMwaDddko1RibLLN3HDC4foBpH0VFDpQu4r8AzMU6mnWRYPWSIJ3WQTTns4wjnrOnkkbjjRQUy7uvMPZ1Tk653ZxU9PgcmVgYdPAIkWaHIoYqJBhIq5QH12D0QS1bsG5DMwZpKIt9j1+NXHS4qwpaMsYb8iGmRiqBnFFwdAFHnTuhvpeWBiCHSXyImIolNj1GheWvgJLClku4Jd/hPLhMnFumc5rLtBwLpAjwtkcIlo9SHK4SL6ZxrvwE2TWHcY7OQ5FebaAr3/tLEFqjrnuGEd2f5EkdxySOpP3v4aMdQOnr97EK9dQ+WFYbYAqw0CGaG2KbngO5Y5hhFei8glBahvB6DokR6G9CQMpGH8DpQcup+SP0agdQuxbY7q+TIcWte4U2HPI+TkdX7JeJvFnYLKK6G6SDk7hxTFYYHRckuwgVtAkH7sIVxApRTlSRAMhbgS+Z1K2Ytw0jIdwzBKcyMyDuQNEAeEdZ+6hDzJ3Zo3MKvhKF4O8UUiXwJmUDNXg4aTM5lU3Mbl5G6+st1i9W+BuWhR2RxhFUIPaqLbjQNwC+WWbTJKQiiTrVwPFCJOL6zXLoSdvz4bwBV2lfXwzvtNk6s4773za6/Pnzz/n+oQQ/MZv/Aa/8Ru/8fewd5cqlCbDolfbVKoneQalJE/ZRws0uQxdwAAZgV8HYi1V3kygm4J2Bsp5yKV0JVcKTVaFhX4gFeqoIgvI9pyaDQWup2PivETLm3suy3Qj/XsY6x5cS0FW6epxoiOJkImu3pqWfq/TBqTupVipQt3TP822lkwHbs/lOdCkmVjvm0r0/ioBcdInai8AzzWOQn8s7aOPZ0IiFb/3hRMcmCxyeLnFZx9b4e1XDXLV3Ah/8vaDvOtjD/KBvz3Op//vAy/2rvbxfYJLlgAvWfpGUpyEZA4qYYi1doK4VAajpWMh/A7enKR21SYyBYwY2LkjxJ2HcHwf31jEyiwx2n2QjZYFE/eAcy3EOZhuIdYO045iulNQklrtSmNAy9VsS0utXYXyB1lZexvF3X/I4NIGzYFTNOZh+pygvFdxLltkaE+XIwtXIqs3w7gDnRSpu0eY3MixmHFxp3x4iaHla1MeeI/op/OugkYTJluQFKFdA+cuNmdH+Vxznura9cz4M+xhCANFgkOCokQaU8UYm5Jk1oJwEjaGoJJj5sImU4nFYTNAWTaJLSkslmmut3X2Y94B45zeViWCxgycn6BbvYkTpYeQ4yFOo40VSoxGQtJpcGV9N8fNLTrVaZLCILX0OcKdoxint0Hi0Z4+hkiXGT2/jZuiHBPk2RItPHsXaWUwF5RYbE5Rz61jxGdobDtPZrEAXInyM+AmYI9o5+Ukgfmd+OX9EJRx2ruxnlC4LxWwtQltHyMXIWf3gO1hhIKSl2XmL/ey9KZN8iOfoVAPcMQyjbyPXyqCMQppoas8K6Oo1WP4Q2XIJXjmHCQ1nNWzWLagUb4Cui0ywQL5MMZtQSuCXCXGTyBvwmk7TXN4BDk6A/UmxGMUTv8te+5fI94w8FOSoCswTGhepWhlYHcdWhuCo9PTYDQpn9pg8xR0NgTOfERqWseOyhxEEZAFvwmFtmBjGFJtKNQgOxFjDULtIq6n5+pd61d/+vhHCaX0xWQBCGScEGJo8hcrMGKknWhzKmlo46hCWkcfxXVo+dDsQHMFHBsyWRicgEIGmil9LyENA6aWS0cKnCxkHLDT2jU6CKBe0wTWtL6RjZYy9C9xAvUuIPV+Vkwd0yRdnT0ceuB2dPRfFPWcIT1dFd7YgLgnne5GEEba0TqM9PGnQ4gjTXgVYAiUYWBKfWpkv9/3ovB8eoD7Y2kffXw7HjhfY6nu8Yc/dSW/c9sJ7j9X4z/cucB/mZvAMATvvmkHP/7he3h0uc1rhode7N3t4/sAlywBVhbQ0HOS3DC0lyBV2yK2B7RJhx0g5AJ+Gdz90AS2S4l9YZlGtufvMXo7cWYHa8Vh7EYNWstEI+dB7YHCOVJb5+ku6MLpZBqOuA6+vRuaeUhLcAUkWZTjQzTBBbWdA879bMV/S3NuD8cZYe/4MV47ucgTzR1shG+BrRGMBUFxYQK7nULRIS4eg/E7oN2CwpA+GL8J2RJYGUhFsLkJx8YgOwWVZVRqg+7gg3x5zzLp6iuYWmhxQ/Va9sp5GngUMRC2SzKxpCdrayVS6zbBK1PMyh0os8b5y76K8vaBVaB0zCL7pTWioYB9J0c5s2eROO3jRzvAqUKY5/raTdjNnXw+n5DeuIekeBovn2HXqSKH5Dgjmw5rn4fYDlgvrNMs5rnswiypYIsvZs9hqc9zfvIy7lluMB9N87XLPLojm7jtw9y+PsHA8hyNShY5OkJ3b8LpKzZ0zEhrGB4s6YrGbAjZvDaEGa7ASZvEC4iyMUyeg7EIzl+PTO+F0Qos1zB8gzoepfo07c++kpM/tML81L0caASsVFdYi/8GLzWDV9oObh6yo4hcHWEqlGPBcB7aTUIxQ2gK6LZJuWtMeDE5UxeGbKDpOxQyETVRojF7NRR3Q3oXrI7AsKQUnSU9DisrJnFKkrcUm3moOTAeQ3bD5PFRiSotUj67yHAnojgIlTlJbGsfMqFABWBl4XwH0kA2kyAsRezBrhS08tByL+56ejKio48+Lkkk0AvRRZBgCEgsAQrMGBIzQQiJRUziRahQYBgK6WRQTgY8pR9YBpaWONcy0CyDtLSBVSWnCa/Vk0EnQptpKQMQmmALvT0iX5PfrN0jr7F2jzbR/cBrQjtWG7GO5XM9qHfAVjq2aKuqTSDDGBqhZrFSaXmzTHT7jmWAEogg1pFGChLx5HRCIGVC34T14tEfR/vo44Vho62TK3aPFfm1H9nPD/3R17jjVJ0vn9jg5r1j7B4rAFDtRC/mbvbxfYRLlgAPBBA+AXEa3BpMXIG+qadjcLegc4RKp0oxDMkbMHwWyk0oVWAm0vOO9R0tTs+ukwwUqNy3QWHhNIuH/gJ39t+Cb2GrAOFAoOB0Gc53QU2fhdQmqGloxJpspx1wK4hjDkZTMTjQwBhZovmS6wmrp3i8NsCZ+rtQj2wjv2YyHI0hVI6ELl2jQZz6O/LLX4azMU7LoDGfR5ZymPVllDmAbOsIDLOZRiqB2lNEJBbKLKG2TuDv/m8s7mvyP84eZscjP84t3WkkNldFE5xcGcCd3o3jz1GQeYJmwnKcxs19hbx5L+FolcB+BdHxBkbtJOXiBfb6/w/Tx97M3Vf/OfnMPVRLh+DcKCupUW5xB7n2iQQ72UuzuoBjCMaSywhIM65muDIs4IUKuxvz+JrPcmaL6hAwMYHRzTFZvpdT4iTHjSLx9AzG5jozZ46wvr3IirgR5R0C8xhsnIHQgsUJ3ZNWXoDhOpRGYVVpGV/qAgyNopIZ1HwKohAGu3BagrkHBiTmwyZWMkAHDxsY3SyT/J83cfq6QVYr97Db3mBXJyKMz3Khvk49HiWbfgIztYTIJjSSLHQU+HNQKYF3Ggwb1XVAuDS3IByEbmEYOZzQ7laQ4sch2A+NlJZsGyloJSxPvhMRfIzh1gU94dyA4e36mcf4EQgbGcKru+w83mTsQYfsKDi7wM70/HGCnhHNFjABwzldcFq+MWGgDZyC6R1wOgbysHoR11MOHXn8bLi4UKU++vgBg/rGL6L3QhkKQ4KhBFIlmjAiEXGCiiWGUCgDlK10v24MREKPQ1Zauy8rpUlrlIN0FlK9NHdfQS0Gw9Q9wAXd+4ZU4Hd7BNjS7tFJDJGrHZ1Fb2cdtBzaaEPX1wQ43SPAmw3t1pxIXfVVup8XiZZXG4lelwQRyZ7UWXzDGEzRJ78vEM81jkJ/LO2jj2fCSEFfOSfW21w9M8BPX7+N//K1c7z/s0e5fvswJ9baAAzl+z3AfWhcsgS4eRqmB/V9fvMclAoQXV0AFUFnhZHjR0iMhGbBZOx8QrgGG+OQL4DT0hx5sgobg3W6bZtcCtxlQf7UcdypU6AKJAUTfwJWSuA0wD4TYle+TLswjmr9rCbcvgF2Av4Y8ePDdH0DNyuZH1omf/AzxCmbIyuvRTw4h7NeoqxS2JiAT8uIaIy1kXPzBGcfpGQ0KSiFa4UEqgxRiYyo0i0NIjI1kqtOwcKrYesMg+ZDtJIJwuFhlOcTTMygdoWclCtM3xeyR84ziMJxG7hJTKo5gGUlsLDFVlBga29AoaQwoirYXeojaxQb6xSSLb46ejs/vvbT3L98E/7WOQruS+lkSxzZ00AcSXMoyBOS45zaznKyxulMg7sHwfFtTGuLppmwYzNFS7qc21lD3fwopHz8C2OY6ysMxxs0rA26D0ikOUFzLkPsFEhEBXNVkGSr0FyD0Q40J6BUhZ1fh1YA5XGoz0MrwokfxlhOCHYMQ+cK6GzX9sivscCrgrEEno1kPwIHiOmQwa7uJP2FaZLilRy//JNUouPUxwbIbyakRZfiuMt4JiI0BX5YJ9oEZbdRcQuj0iXpThJNWgQnGgRdkBVBMjEJ45PI1VeCtxfWJMxUoRNr11ZMZOU6Fq7IYMW/w/iDLezdMLwP0gl012Hj6g6zebD/LoOTVsQHe2axWzr+0wTECsiOzsDulqFWgc40mP9dMCIUwSYU5mHTvLjr6bkqF/35cB+XBtQ3isGRjvB18grZDUikQYiNYcYIoYgkWibtJRB1tDzDMnT8kDJ1JTYxABPqRU08jRhEERJL3zsyvfikaqCdnE0L2gmYkc5cjx194adj/RQsjiHsQMoE2wQ30D4RsQdWrPenCUhH9/IqT6/TsCFuI4TEtCERIaoX8SuFDRg9F+g+vhs8nwpwfyzto49vx0u2VZgayPDHXz7Nn7z9IO+9eQf/57Flluoe//H2k5ze6DA9kOHKycKLvat9fJ/gkiXArS0w07DQ1ZOU03mDcHIAVo6SP/wgu89HPDZWorMnT/3vlkkV4MJlguJhxbZNyOzWCubtF1zOjQr8QXAuQF1IKDwBg9diHi4wR5NaFqQSjOTBbQV0KkdQxgbkxyGy9BN2M41obSJaOSaaISknZL2b4ezam4jPvpH0xiCW8gkxEfi0nRat8RYyl4bjVxPVBqlZZ6in6lgDj2GMt0myY3SbV4GcRmXqcOA8TC7Dxna2VkdQ1QGwT0JlG8IIwFdE2xzuPbbBkWyI0RB0jQDq4MVdOoUa5nLASDSH3Jxna6SLcmeBQZhoMRJs4G6YuKZDG8nLFn4EQYYBNcj/LtzF1uXHePzyMtHhnezxBugYAQKb5vYLyAPLOJtnickhE8mj20bBnsM4ZjLw14O0xqvE5YCFMQtzY4RwtYVV2iJKlakbL4G4g6isw1YFVAZjICCXbdKePw3FnJ5gWindc4cBZcF4MyDrBbQuuGymI8JMAnRBbgCjlJf/ljgcxuWHKODQJk2ARShCZGLgdC+j5T2IceoU3fwEbfsnwMvjVrbodj7PqH2Ueb+OZ0BB1PE7S+QMxUm3TWikiJpQScOqmYG5NORfAd0dumJjH4bm58AYwiqVib2XQ1iC7ATrgxOMbW8xWoaW1HPczSmIipB5EMxWwsplIaoCmQWYSAEecBy6VcgPCeK0IuNoQ9jgMIx3FCoCdxPUbM+r5yJg850nbv1WwD4uOUitGA4DQCiEIVEyRkmFMNBxQVJCHGKidJE1RJtaiSerrpYup7othIgRxEhCfdMyLU1mIwMcEwKjZ5hl6r7cMNTkVihtEU+kn4j5sTbPsgUEcS8uKdau0lKbZxkEWswtnnwSFoMwUIZA9gy/AL2PKqFPy/5+8FzjKPTH0j76eCaYhuBX3rCXd3/8Yd71sQf5ZzfO8y9ePs2vfP4M//krZ1HAv7p5B186UWO+LTg0P9Q36rvEcckSYFdA04ZmHTLTsHBoGOFsMX7HMbKbLnEAKjWCMiuk28vkBaRqgnSkaI9qDxLpghmCupBifZ+Flc3h7h2FdAT+Q4jQY6cPyy48MDSBmh7BPtJB+ldqgxPhaEMsMwZfEk5dwYnpVSwP4lyB8PjL4OwrMdsmSBeBj4eBMLs09zdRjoATDnZzmqy6Bs+uEgY1kkdPQP4YFOowl4JuA6I8ZMe0wzUOKpXA9DEobEFZ4kiPmCHiE+dp7lmiOTvF4B172HXu5URLLWRU5sxLlmEjosgwV66WObW5jXPpJhuvPI9YPUtkQJwV7FzaR5ZhHjEuEKWqOHIFI8qAD2oi4cLSKltOm83td0PbRQ53yJw7z1SnS1UJmrkC0hmGgdNw9QzjX3oJcTdDa1+bQHqwazvWyjGc9gqxOooKpyBqkVaPkex8mCT1cmQ6wA1bMOHCcALyGuguaNnfpAPBKBsnRihll0jyAkZ8zMb9OEELPymStn0MXzE+3MAvfZqg+dM4GLSxSZSFTCw6wzYMj8CxLCwWQI0gVoZR9VmaahetG/6GlHUPjusTiohgxKTaTYjjDhPpDv54kdNiN8nBbTC5R8eODHdBnME8/wlwNplwH+WyTsB9s8epjfwkNBcYrC8w1NIxxI4Nh9PwxMQwB/0GFTsmKsLINWAuwuJXsqwmMaYdY2+mMGWI2ijgdhqMJ+CHkDPBHoTMKmxG0GpB1Li46+m5Khf9SVsflyJkon9MC4RQKKlzgpVE5+MqCTLGMBRKCmSMHqOEAhHrXhspwO/o3mIVI5WvCW/e0aRXmTq2yJXaIbqYemq9yN42VAiOr4l1YOpKb4Q2vopVL7rIRkuZQ22ACCTk0FdvpPfXUEgkYHyTy9WTP318t3g+FeD+me6jj2fG6w6M8+G3Xc1vfu4Yb/7IfU+9rwDLEHzw9tO9d3Q28L95/Z5+LNIljEuWAAfboJWFdABcZuBdNsjAvScZ/poLCtwcWKU6dIfxZ20GzkfMnpE4LYj36HmEGcDoLpDnQh7KOcTX7oHJH4KNuyBZglJMN4TMFoxXa6zlpvCu/L/gZBGKd0J8MxjjoLKQVqjgnxJuO0S40oLFLHQqkFZIR2L6DnkkXfMom9sbqIqF/dgsBDFJqQFtg1gsw1oXR24j/bkK7q7HUIVNpH0WNSSha/e2pyArIZ/HiDNYKw5xaog4n4eDJuYpi6E7Jti/MU2KFEGieHDsNirZL0LF42S1yo7Wz/DqeDf3uSvcufhZRKeEaZZJlRrUlwVfSV/g2NWPk0yH4GYQxyZgswQS/EaG7oHHdZlxug1dhRlLFlQa0VHYHUkwlOhi7Gieo1d2UUWpDaacCqgm8UiGWGyD7AAkDex2jdA3kGWfdPgVUjKgOfgKcDdg5ThkD0K0oqsdqTyGu4WVqtPKWSRlk9AIoVbEyxyAfAVfhnj2ThCPcNmhv+Kx+3KYnR9HSAMHQUyIVRN4y5fRyhehNQeZYdSMBTssxNeGUPf9FL54NX6mTWtIQWUFyvcxlr2PmjdGe9dPwcy8nrAGLpib4LtkNz7K9gvnGSlB3oPhZXhj/AC3OR1Ws3sZ80PKHV3IWToBXCsIrr+GBzoRb9zxZTJOiGHD4hmTzsYIAQ0qIiR2DKRh0PUdRB1MA7IR+B1wBiF/Ic2xxyXtiRDXu7jrKQdkvsPnF6mo7qOPf1RIvjVTTIlvRBspQWSneyZVaJMpBYQ6jEyQYEuTxLCIrRRIX4/hAQhfgEpQ8QY6qsDSod6WBXYK04tAJiRmpCOLhIEIuijR69lNwEBiKUXkAAKcWGIoQIFNl0QKJAI7MVFKEYuEi8kI7+P547nGUeiPpX308Z3wugPjvHrfGPefrXJ2ZYtzzZj/evcFYql4943z/NTlA09lA7/nfzzCb//wDn5icPDF3u0+XgRcsgQ48qEdw1gWjk1mMN017E91WdkSjI0oAiC7WMU51mZ1f8JgALYHbgXEBqQsSA3Bkg3VIcmuh1tkC/dxUkzSnnoNRI8jWaUbNPHXYfJwyFj4KI39izSO57DaLVYuG4TCNq2RcyxIBuCJHKRiSIXQ6gI+WJIws0JgbuHuPo28sgsLY6ioiZw8hsx4NKtXQFsijAxxoUmpNsL8A28kBFzh4mZCmuN1komY3Jk0pVqRouqSjxIKsoArYlrZDXxnjbh1kNnkAJGlOGMvsjG5gjP+OQaTOsYmNMe+zmrnekryABMyR3YjplUQnI9uRrQXkHMSte8uGF2CTQlyA7WnCGfn4MIOkokICqegKcGIIDdORymIz5EaFKjcOAxPQdqCWoCa7YC9ACIL4SBmsEZmfYlwMEVY3Auty0niJ6DURpkpQgRRkNP9bWxANA8Lh7WcMOtAvICxtkEl6WAEEG7FrJdCkkCgJidARqjmbvAHqaVvxs1c4JrXfIw7TqcQtRsQwsJIDCw8Uk/sIkr2oJRADViovV3oxqjRNsgMyP3gt6HagskYMZ6h2ZnAK78CKnt1/153C2r3QXoI8/GHcFaWGTsFQ8OwMQHZy2HKVuwxT7CR1JnaETM6DGfOQ2PWZPHqIsnYCJ4/wmL7Hg6lPbwQMonEElvYtku+LFE7FZkt6J4G/1yZ8FADy4NUHaIFONMdRZ0Yxpp8hIFdCe2LuJ6eq3LRny730YeG9oqmJx2WutobSy2JNgx9sahe1q+UoEAYCgMTJQ2UUCAkKon0yhQgFYIISFAqhkQhAJHEOpVY9Uy2hNAkW6FJuKVAgkp61dyevDnBQCiBQK8HqZBKopB9tfP3EM+nAtwfS/vo4zvDNAQvnR9kvqB4858dZudInlMbHT7x9UV+dF+Jq2YG+JO3H+Tn/uJB/uNXFnnTtTswjBd7r/v4h8YlS4AbviDdgZlrFJu7CuT+tkl8LoUz6SFMYAtUGyrlgMXtsGZBJoC2DyMFKOd0y9RSBCMZKBqgjgbsij7NIyJEHvineL5LXL1AviZpVdM49SH2txfx6hNUVZm1+jqyXNc2vWYAmVTv7maAk0DWgHaIShTh/q/QGHpCy5+iADJXEN+wRdb8DFE4SDQwDJspxKJCeRW6hoGjEjZGUmQb08x3fZLTM4RnPBzlYRJgkSVA4uOTKJOru/N8rdLm/Et8LqTvQTmgSgKsZVTT49xWnqG8T6NYRJyzKcoCIR2S9AjMO0h3CsQOrOIXSBuH6bh7IPChU9JSvoEaVL6OmakhkipmpUXgzELmjJaCT11FIEpQcXQuJT7kViBchY4D5QHYGGHMvYvWpkFJtmjED2J4Q0RMI6cuhyRCuqu6j65hwtghiE6CiqErddRI7JAInwVyGEMBSeLoZly7AqQgPQ51W1dUWqOc3NzPS6a+grHjKMloHiqSxF8jaZ1Efe2HEKe2I1UK/DwsZnREScnQE8280JnPThYWhlDhj+C1XXCLOhg620a0/goV1hHJXnZxmIwbkc5BcMrBWFVUxyPiffCIXcEwuxyPwBuBE8M5zg1djxqcg3QB5CrtkmIjC19uppjwIibMCGM6QaYhqIMhoVNpYJsGkQn1M2Ceg85WhlhOIo02zjKMDcLCRVxPfQLcRx/PHwoFSaTHCISOHTItLW0O9RJkJEQSJRXYYMQWRmSR2AqFRMaJ5qLCAMNEqAhDxcSYiDjBeDKrVwjAgEBXfZXTyyRWAtISGSukB4QxQkBkAspEYGKjECoGlZD0xbffc/QJcB99/P3h0eU2S3WPT/8/L+X9nz3K0dUWH7xzgQ+9fayXDTzPmz9yHw+cr3H9juEXe3f7+AfGJUuARc2gUkyQVwjicoh9Z4InFOUe7wkVpEPwNiE7A0UTvAjSPnQB34K1Mvg2DOqYW1KjsOZG0LwbNm8hKb2Mpvpr8qe7lFsWlvIpJIo0CR3lY3ubBA7Q7UBpAKywlx8hQTmQU5o85Y4yePrLDJw/Q9NSyP0ZtsYvg+B+omZIPNIC51G4/Frk4y4s5OiuGjSuCZAHEuRfx/h+BQFEyqFNSBabadJsw2GDTU7nH+fwzAZhLovdGCE86IP1NSiXMR64CpbeSGrrGK12kUo8QSY6QB2XUyJBhluYxCRDOyHXIGlv4dslyA6DmATyMFXUFe3SQww8cYY4gta2A3DmZigmUG6DGoCNQOdgDmRhfANOFaE9DsMnMFf/hqR1OetqhGQ+xmtmMVdrzBU3WcnUaXkSUh6ULKAJpQtQHAS/AgNXQXMd0gKiKkYnJElSJK1cT2q4B0rbodCB2gmY3ge1NKSzmLV1qn6WZPElEGQgtYJQ5zDDRaLLurDW1s3guRYEI+A4QKgjQ2QOUmmwAzBysJKCVAG8DMRNcE6QMo4SWBPQXaOVVgwUtRnOmpDY1SyptsWpcWiMvBbhP8apzDGiMKZRSqNmrwR7FMKzUFhmaSTD+eokcS3iso1V2sDIloUoxaTHoLYCTiNPuLvL6XMC8WiakQmPbjVNRJ14+ynC8QS7fnHXk4U2cHk29JP3+ujjGSDhqZJqEoOf9O4BQvflJiZCGYQkCKm0CVYvd1ckBkJEKCFQ0kECSgkMKVGGInFAKBMBOEZCLF2kElih7HXtCnCtXpaw3hmlVK8CHaNICFGofsn3HwzPNY5Cfyzto4/niyczf/dNlPitN13Gm/74bv722BZfOrbOa/aPs2tUO0I/mSHcx6WFS5YAT40njE1DOAP2mo/YyJM4LiITcb4NOQ9SvSovNrQcyLahGsHoHIRZODufphj4qKLmbGYeti2Ac67GeeMM6sAeFlWe0c08TlwiZyxjOoqkvM5oINhr/y2PyctQxrXg1iFnQ+hpabBtg+NBKoPwH2dbcp44rdjcKQjtCKzDEA8QFafAbkDzCMgBuGI/zAqCr69jlL+MeWQJ5f8ICYfoEGNgkUaSx+dC7jQPbvsaxshRmju62A9cwQ8/dCtNWtyVdAhf9hgsrjF3d4ptzWuIeCWTFFHYOBgcZokHS6fxhguIaAHSD0GiUNMF4tYBcF+qj2W6BtUGLFiI1kGquwcgY8GFq2BHHdJHYNMDP8TyXZzBDI6/QnuxTHL2lTD1BKa4n6QbQekIce1lsB4RpyaIp45yPGuBtw0yJSgsQuEcuGvQLUC0HbK9hwqD28AT0BgjGdgPyRlQ6xAbOl5k8zDGxiJmqkY0eQ7yl0PlAK2TaZ4o3ASdUVivwGaEunEf0YwFVoJqrMHMAFzYgCMZva75BBwD0msw3oDsAqxEUNsDrgJRRWRuY2DjYUSui2/YkDPwzSwTO5vEHmQSE58BLLvKYmUMZg6imiHRZpONaIludgBIdJW5ZYIcoVa6CRyH4tqDmPMxW48UWWlkmCivsv9QgjgJLAuanQjr7jL2sE/mcsj+/+z9d5xtaVngff9W3jlX7V05nRz7nNO5gYamyaIoKIiCzgw64uDjO37mdUzo+DKiTkDmUcEZeOBhBhAUUFCJ3dBN0/n06ZNj1alce9fOeeV1v3/s7kYEOpBa7P39fOpzqvZaO1S477OufV/3dZVsPLbYKHi4GdgqPbPxFAMiT3J8mF00NPQUhPh68CvxWEVmniiaJcSgx7AsDW4LBE+kKA/SnB9Lr/5HTXgFj6UxCwZvyD02FQKD1OvgH6/qin/0j3j8UYd+gJ5qHoXhXDo09HQ93vP38d7Ab3neHP/rnmV+62/Oct1slqXKYKPX4z2Eh55bnrMB8P48TI3C1jnBfKtPPeohNQzMnkXYBmzQjUE6km2CH0B8G+wJiQsHxxHRLJ6hMl9/lGhFoAxqjeAWIZ+2KUYuYe09SKAL+jGLuC3TzpjE5kFtB4w6YE3WOJP4In5t56DFzWN7u8hLgz6Mrg4pD2FHqakSWQsmXUFdCnA7RbzaDTDSB78E8THQquDfD9oo0o4yVB9E6kr0D51k9fgCeTNGRbFpJxSYswkK65BMYoyN4xSTTJ2/FTsIiBHmlhMS60svRrFzLPTnuRJdZ32hx6FLDgU7jUsHiTZhqUc/ayGSGRA3wMk47JFhtQHRFZgOg6MibYwxcjFJL9akl96JckLGnz4HYwE0JiG0gtE/jjwWMOb7CN/Hpop5zaPQzOLHFkAvQeIgVBfAk8hMfwk9WKEX0emMGKDWIZwDaw/4CTASYPhgrSO5ReROH0EcuZdG8ZK4okDgOuD1wF6GSBShT+NGRsGtopkruGO78Ob2gTYNQQ06IUhGQd6C6iJKchP/xmvBVge5xMkOdDzChYcJh7bxdIsgYRMKugRZmebIAYLOPKrfQG/fj7ZhYc6FID2KZK8TNto87GpEsz5j0z6JrR79Azatw/shvWdQyCuySdtwEZm9oGqP9Q+NP/avDSGZ9t6j3JMMyC5v069LmBUdBZOxwxBcbMFKmo5k42kO618cRzebhPQumSUD6VyYWr7DM0m2e6r2HcNVi6Ghp+uxSNYH8AZBaPDEEWL64P+jbhBAMNirK+M/sVYbIIMvkH3BYxt/sVFAEaAIPO8fB7r/tDrX0LPp6bRBGs6lQ0NPzzUT8W/oDfzvb9/Jl84VWa5bvP1vz7DVtEiFVYJA4AfDt/uea56zAfBMAUQCwg0YrYI569LrqoS9wT7JkAJ+BOQGtHqQ2ADNAGlvHPvQT4Fsoq09RLoKsTrYDBb2nDlob4GsXQRnHWuqQOua0yjbLWI6EIZOH2QbKraEPLqFP34elg5Afn3QuHXxeWCeg3gJJsehfy3F2irh7N0U03EkYeBXX4ry0PPxD98PB2+E7C448xW0rX9A12UmFIuroQLe9EHozCIQbMfbtJ+ngbgAmgfLN4F2BMf6KNGVf2BD/gDVmIybnmf/5o9zoHEjPjEELi2tjb3rbk52A55/9aeQZZ9HjzxKe+95aLUhmRq05JhXQN6GI5tI8hnUxRcRXjrKdDkFnuDCqE/2b308v08rZyNVtlD8MlJuCdnQMNuHWWp5wAY4UZAlaIUhdgSkBOGv7kAENTjyceb9JdqtEPZqjLChIge70awR5LaGHDj4cg/brRJE5xGhHr6yAVoZNVIkE1sjKvfwXYFmSKxqBaz8ixCxEdBDmjHFAACBmklEQVRXSJa/yE67zJlLf4mvy3jyLTB/EB6sw9wS+GchPo5qXSDofgWBCtk+jDcIt7c5XN5mQoaNDmz2Bgs7cggIP0wq8giT5YCSA+UUmOEopOcQ/T4bsRb048hRG1PbJDtb4+r+Bbz8iwAV4vMg6QhxzSDFPFDB7oLZAaczaG6NC+Mh2pP78U6UiJ7o0NrpcueozDE7YGLBI9vs0Gyq+NUwbSZI6C2SThxtYwwLG7euAZWnPZ6eau/a8KJtaOh7o28/tlAsQBA8scornqiIBYMjfH11mOAb062H/ll6OnuAh3Pp0NDTo8gSv/WKPfy7v3z0id7Av377DL/8V5f4+zNfT3P72Q88zGQ6zG+8bNez+GqHftCeswGwtQHxNOSiUDqh4JR08rv6hLYGsVwjNFhMlDsQK4FahYgCnekUFLJol/6OwyunyTYFrcTgB6m2QJuCdABic4nLl+7Gi8ZoRSVSYwL1hIptKqieRkuzmJnwEJ0rHB+5E3GtAvY2hvlh7J1fJPrFbTwtwJ78GUjdhr3wb7nQOApRB4oT4M0QhPsQaoLUgPYqhErIro9jBpgeiNgsytariWzECPDp72jC9CW48giEXghaDNKfIlr/JEfra7TcLJNaj9MTFZZa1yC1p9Docz5znk7q0+w59xDLjR3cH76Emv0iqbEL9CNRvNQUUq+NmJAhXIWwj7Q+Sf7uGxlppOlpCdLuCKeia/hmlE7ExjmwBVvbhKIPEs+UqTb3Il18EfMXZygqLkKy8ENN3N1t2APYUeRTs0gEmLcsgjnOI5evweiNkakf4KhXIEEUHZ0W0MdBRdAFvJqMj4OPTxOLvtyill6mdN05tPijjIo1JpNVluUN/MYouGN4XhwtaBLv9TF6Aa7zAOWpWZiU0Ct3oigdzKk3YhuTIPfBawDbYOvYJFksVGkJn1InTEM3CDf7jAuflOyj1wPyCvgdWEvLuPERcPtg1aFjIZk+sX6XVFXQCoWpj/4kRBYGVay0xGN7q1MgWeD5oBqDXp5mD6I2KNZgJdhx6b92DPPGFtV8FCXksGOxROGUjoaDjAJGH89eRpYter6CBnToMRpqc6X/9MdTlEH63tDQ0PeX+02Ltv90n6741p8NY99/9obz6NDQ99bLDxS+ZW9ggLCm8LGf24+nRnjv3Vf5lY+f4l/tlHjls/Rah36wnrMB8PZZsKOD2kjplIR+soDda5BLtxBhQdwF4YAcg1gbQh50dkA1nwPVYby0zu6Sx/o6SJ1B68Z2AWQNyjpoYR+tuYha9tlRDlCbIFoqPU3Gm7SwJj2UaeimfSRpBREtQm4/du8/wNl7iZcvY3dU7MhxSN40SOfNvBQu1gfFshIaYvcKUuoBREyAtAcmbsRpNdE2r9IydIJaHrldxRpfRIycJ66u0jn+QkTk9TC2BtOfgM0W/XCOi1aJQrhNMeLT7OZIWxniaFRZwdM+yrR1Fn9jD3PuC7g6XSQzc4GZ+3yyiSbWfJP1SJiu3AJUsGYIPZhB9O/n8q5N7ILPWuP5BKVdoLZxDi9C/kvgmYjAovfQDhbWfgXPDVHKrWCFZfTqCCIUg+xFiHZgJUUwXcf0q4w8sINk61ZUL8ZoEEFGYKBho9DBpQ8EKLTw8HGxsXGx0dHIIBENcozUoyyvhLEPdNhoekzrayzE76ZVWKKmT2FKIbZWw+wJTDp92JYt8MuwI410qYvAQuo+TKS7hRsFL6eTVNboumU8P0Qtmqbh9hF6mJFSC0uLczX6IuK9s8j6GmrDYlzAETmgaK6At85WQyKQXXS7Q6YliBxP0pszQdiAC2YfQn1QgkGVLNdFqm6ROXeO3MOX6ZoOtakRprPbMOKzeH2BYCSNmE5DXyXWX6GwBW5LxjQgGnKwRgNynSrpEZDWPHy6RDNNwjkbLjz98fRUKxdPtaoxNDQ09Fz3dFaAh3Pp0NAz83hv4PsXK7ztLx9lNhelb3tcLvf4H3ev876fv4H/9aZrecuHHubTK2V+PRBPWYxu6IffczYAVtLQvE8lPOnBHo/RK9uUN2Zo9EfIlkya0S3CuQAjgPgK6AJqMxruaAL16ueJdLdx3UHnIoBuG+ISuD5kJLiYDeNmHOLdBrkUyEsSyqRNMC/gMGxHFS4H83TiRyDQIJ6BUgJaU6DkaVyzSuz0GQqN+ymH9hKkXw12BwoeKBXwamjRLxLuLdNuToAugZJBKaQoRH2KTozQ2n3s3vd5gpjH+oogtRmgJtrUtZeD34TLWaSLLyK44TLl/ASNXXWkKzrJ8z9CzNnFitRifeYRdu05Q+XCBKb6c8y7+5jaOknJmGBz9wqTIwF0BIEloOHA1l6kRh9apyjfcB8im0FurOAdWQBxCSJdEG1Y6hOqNAmHQugrP4YTVti6fhl3lwlaDHtNhfXQIEc4sQnZcaRqlvGlGfZYWQbJfQYCiYAQNgoKMRJoOPh06WMh4xDgYOAh0cDAQEVDRRISiatpqnPjiJjE1lafQqvB+PQq9vQ2zchBVvfkqZbP4AchLOMFkDgGIQc7txecEmHtEhEjRNNPoXUapBwP1+/hKREIxZn06pi+hS/pZHsWHeUI7fhPgvFFHk3cQ3Fri7jtcGDdItKHYhKqMmxGwYuAiDvU0hHIxh/r1+kP+oR6QK+GUj3LK9pfZdeaiVXSuLARRlpfIpmGUAFcfYXlCRcieUI0uO5yFfMyVPGIjkBI8UnvgPXL0CjL5OwQ5vgmhXRAe/OZjadhADw0NDT03RkGwEND3x+KLCHLEk3T4+2v2ouhqbzmz+/ly1ca/O3JLV57bIpfesEcP3WpwvHVBs/blX+2X/LQ99lzNgDWfKDn09oC50ZIv6pP5KHLXDm1i5Q7h3NzkfWfmCRzdxlxX4jwRJdGLIXIQ/7qWfZpPuubYFqQi0BKHxRhFgmojYI1omMoVdIJi1oWxJygMAntWVge1Vl2no9jvwFaqcELimtgxsAApHHcsT2I+mlE3CMh3UnTuXVQUXnEhehJMDLIVZN818PZ3sKamEaS14kaV5ENGLvQYTM2w1K5jxvkIFHF27bxwipUr4HyGLRURLoNp29GK91C3Ogy1s6iu3MEbLM0aRG+/i6aYzql/IsQ4jKnLpVZeGQvucW3Uanex2rHQ5IX8ScE0vl59GUde/cm5osuDAK2SpEgcQi658BvQ+u2x3oC69iRR7A2r8FIh7FffAnyS4MemPW90LEHP4/NESQ3SXp5Dr2XJC2ggYaOhsBAQaAALgIfk226yGi0cLHxEHgo6AhUFARhBBIuYULozgzmCZ/eTadx8xLr7Srr5+ahZcB+B3RBr5AFawacBDSSkBQQei2MKpjVNmZpbvA7a22zxofREqeI0ia0XKcQDlgy4jSNCUa0S+ihh3G4Dnqvxxm/nrXQwyAuUdq+wkvDFSZMgb8frsTzOH2VftqjOXozpLKDqtZI4PuDjemdIoq9jmyaVA5CYt4l/7BL6bSEtRUh0vWZvt5hvaVg1DeYP94gOAdVU0KVZaK5wZ9dUoUmYLRS2MRxlSZmAToS8AxaIT1V8Zbhu6lDQ0NDT+7pFMEazqVDQ9+Zx9sd7crHiYd1fuW2HfzJHVd4+6fPcWgyRcsc7LC/b6nGTTtGUWTp2Xy5Q99nz9kAuLoYA2+B6OkrhKN9OjrM3+5DbYnLq3XSZUE9qmPujJPNdggbgvaICsoYFf0QV7vnSVltgiWV3m6P7jiYY1BKS7SEQv5Ki96YxMpkgs28RW63w5YkUYqP0pVejDBfBY0ZMDyIyFCpgVVHXf5bRKZAVHkELZAIdQT6eJOmuwXhMlL4OKJ1BvSfxN0+hLewjKx4SPImO8RxDoRNLpehnpMQdZ+uHSBUCS0RRd7lYQWTSO0HiK9cgLSPPTaNvfNliL8vkF7bQU92KUtrdBPnSC98ksBcZf3RWxBSGuYX8ef6rFwUjLQMxuqvZIVVHH0GeWuUTCNDJ72GNHofcugqflmH6Tnoz0LZxVibQ2pGcfd/Bl1bQop6OKPL2AfSkDYH1ccoADrEXei2MEpTZM6liAcSCXT6qPioWPhEkQkQdHHpqTYIH93X6NB/ojCMBYjHVoItAiwEOio9PHwCpO2dSHekENEmUieDEBlYUcAuwTUNsDW4pIPlwbSAZgS2coMWVX4H2lEwO0gzHgf9daKWhyl7eA7EPTCCPvHUFmOOoK/czZq+B3o3gDsD4XHwK9T2rHP3yt/yks1TWAKIqVgjz8eamwctC3YFLAfJbCM1t1C8DSaMi4xVLOwo1ONwQYbDB2DnskSropLdaZHYBOuvTNSmhNvfz2awzU5jm2DWxc7BeAaCNoz2FAQx1neUcX80YBTo/OVjvVaepuhjH99O8CTHhoaGhoaeeh6F4Vw6NPSderzd0eXtDsdms/zyCxe4+2KJExsdXvl/34PrD6553nP3Mp85XeJ3XrWXlx8YezZf8tD30XM2ADY0H8lLUN+MIH2lT1yH6o/B2o84KB/tMpYRrHeqdI8l0PU2TUK0b5oEzcPZucCjIwukE1/GOG/R3DtDELIwulfoaTEmH2rBJZArINIBds6glhrDiU3gBS8G6TA4MZBsUNRBwSIMwCTXOM3h1b+igoBzszQntijlDoAoElc+zlR3k1o/y/b8KEFCsBY5SpZ78PUt6r5FrQ6zDkSaPmZxg1bMAMPDTb0YqXmcTOok8eajSKrHaFtBj17iPttHCd6EQcC6tkVnwmL32P/Lq9sXuWtdotnr4MzZkOrARha5F0GlzkZ0CTH+l0jZDNKVN+EJC3Xso0Qb60Q2fERSpl5tY+oJ1OLt5DfilKb+hmzoBKPCoWGDK21SkQSicwxpOY5c00FySW55RBqz4MXx0NnCYQuBgUyIAJ0updgGzdD9eEoJb2cW2TFQrm4RiAJS5nqUThq1qaE4AXag46se/bCNIzkEgY0ikngihPCnoD2P8INBD9+2AV+bgEs5SPcGvyddG2wEV6PQDCCqg6qDa8JYH2n2YbRai1AXMj5YXRjVoSF80rRJAxNqi8/3v0I1th+s8yjeSQKvgAhfT/HwWzje/i/sbq7jT5U4Y9QIpAVoV8GpEKncz94zV0g0XOSGIDQ2iL8TNohDUMgM6mON3RaQLLcojkLlc3n65V3orCGxwYjWJ3vYp30NpCSQKmAsKjjlMTqZKrzQxBPQOw7zhwUPbz398TRcAR4aGhr67gxXgIeGvn+um80wntB5z11Xed+bMyiyxMv3Zjmx0cH1BSNxA9+2eM+br+f9967y1o+c4L0/c3QYBP8L9ZwNgNtWAp0erjXOnFTH2BewnIXtMUiFe6ymVbojEURepVHYC4ECShJwwHTASNC44XZ4AZDcCetXcJZAKirENlsEKYiqAsdO0Q+/hn7qWlDT0FLBCUB1QVXBtcDqQzgLPmw/702cv/qnZE6XKKe7dHaOYWfnwK+QbFawNYWeugtpvcL41U8zsd0gdqvH1ZBHtAjrbZgQkI7AsfGArYzFpda1BGu34hzYi+d9hGumlrioy1wq69jLR/DPvQalEmMtX8WcbWDccA/7Ly7y6EVotWXm5k5SCtbpbet40gL2aIZqd5Zw/zxBo4w0VsKLPoAdu5kgpxLUJRai0GkHWFMWZqJL4n4ZOxYmWGigehKX5Z0UWqvEdIXmg9cSK95KpDOCFCQI0SWEgsUYXfp0pQqerGLHJAKpgmO6mBNX0Wf/mpHmIiLwqfsR4kFAIt2na6j0p++htfNHsesFsLNIX80h2lHIOngzl0G5i0BMg3s9ROLQisFKDiQVZAZbjL0QVHWI+GB60LcgFAHJf6wRpzQ411cJzNs4ofWYTH2B3TWfyajAU6BQGmzZlrYgo8PzJs7w+bGPofYuM1e8SjEdpbqzgAjfyPlb/r90Hvhf3PbwWcr7TlFMqSjNEiGryrFLm2T7AZsuTCjAOnTtQYuu0QZks6D2YXsPhOtQmYDEdBWrFtDzRwgBocCEACIeaBWwapBYVXHULhzuE46AexryRyAnA597+uNpuAd4aGho6Lsz3AM8NPT9o8gSv/rCaX7j7xb5xf9znF94/hwfeHCLHaNRFss9Kh2bF48HHJtJc/38CL/4f47zB5+9wEv2FYbp0P8CPWcD4LWQRjZ/lZk5G+n2gPXJQRVn34HiS6IIPQphCSQPfBOEAV53EBjpEcAFOTXou9rrQmonHNqJiJSoLzbA86nNLeDe+GoYPQItBgWMQoCwwLCg34aYAZYKoQBaAuHsZn3037J5S4mgPwfhaWhfAblCMVpAkmuEtQqzX/sU4ZpOOyThWGBbsHcFOnFwCtCvgBuRqKfmCUq3w2yDUOIBclaRB7xpqsoxvNg4dBbAjOIkBI5RQkqf4HDtM2iyh5AhPuZTGpGZbpYJNlXOYyOmS/T1u+n3q0jbKulii3r8Mva4hJxzCU1AaBOuuGla5d2gJujqFsGEhzcfp+jcSGR7Ha2jsHLx1eTar8JWNWzFxhNNFCHhE8JCJ8YlDKPFysEIauavsfJtgt41IF0hUV0h3nMJktCVBr+big7C9jC2l2Hyb+DwLsjtQUzvgbuy4MfBlmA2Dd1LIC9C/nZY3gU5DboG4IEXHQS6uj0IchUVvMFuY7QuKBLEI4OK3PER2HbwCy9hLZagGNsm275E3K7zvEmT1hL0VqExD/m6xctDn+dkU2D3wZqNgiNDzEYU5tl4zVu5+je/S7ZTo5n8Goe0LqMdQa4FzQZgQ3EPjAPKHRJdX6JVDeNUTHKmSrPpojVVrCAgdqvPznKDr60ZBITI+zGURpfRHsQVsJogKQ7mMZvKFMSaIMpQjMDSN7VaeXJqMPh4suNDQ0NDQ9/eU82jj58zNDT0nbltZ4Y//+kjvPNzF3n9/3pwcGPbIR5S6Vge92/LbDZNZkcSvPWFO3jte+/joeU6Ny1kn90XPvQ995wNgJ//qxuE90BDh+30oIBxUxnEOJJqI2RADoMmDQKhrgaeAUp0EBBZ8iD4MQd7T+VuB6VRwo3OU3r9vwY1CdlpCBmD9jW5ERDSIPANPRZA6wH0gkFA5gYgSYNAWNpFEEyjVU+hrtxBfGuFwK6TGK3jZTzkyBJJL8GM5GDIPbzjEH4E/CT0xqGYV8iEVZZGprHnfxYlXGMy/PcUjFVWtQLbK7+IdvbFSBMn0Qt/hSy2MJ2bQVlAyB4tRaY0J3E5maJpjWNmpqmc6CNdnAVjP9LsvaTjn6OhxQlCYfrCQQqdpSBOEq35VLM65/U0rb0HEZHrIeLh7JZgrgiRNKp0AjXRYrX2ArxUjFr6v+NqOYKRAvLZlyCacVAd7NwjbE+tISZLpIO7yPnr9EoSfug+Wh0DLxpQ2SljE9BzZdodCUPxkbIKbTWHulyGXh1v3oTRAH50B9xvQjEFpoJcvkTQ3wsr+8DeBZoYLH0KwG8Nfl+qByggO2D0oWcONmlpAagaJDXoC0gboE4g2q/BER7F0Sol4xJm7S+JzzUwUqBdHhRLG98ShObhzt06Xe1GSCug2aCGCMKzHL/mNnbWPonvybQ0mZ0jPuoh2CjDViDTyMtMKh5zc4Krj0YRIoHWzVBUKqTqEoHhM3shSel5DQ7P+kytm7giic42oS0DVm3qFkTbsH2LYPkQ5MIQeRDcbQVnyqdvPbPxpFqDjPAnOz40NDQ09O091Tz6+DlDQ0PfuZcfKPCyA2P8yZcu8WdfWeIDP3eMmxZGeP3/uo/TG21++aMn+at/e/MTRbHuXaxw/VxmuAr8L8yzHgD/+Z//Of/1v/5XSqUShw8f5k//9E+5/vrrv+357373u3nve9/L2toauVyO173udfzhH/4hoVDoGT3v9DEwDfB88DXwo4AMngw93wMlwNVsHCMNnRi4AAE4HSAGncoglTm9G7VymZ1nvkqi4XA2u0rvlh2D/8XCyiCojRrgNwYryW4Aujoov+tqg2bDEQH9LsRl1JX3E+5cRHFtrqmXkTSXbkPCFIJJa1Bz6eHwKKWDGXq9FSIjBqEOlHwDeyyM/8IqFW5ke/1FiOQ40sYJrk1/lOsiJg87OmUjhxhZIVj4rxzp3kW03KCUUliaDRPMXkHyN1jkMFfXPNzMYaTTB5G6CdwDLcilSN4To6Mu0RuPI6sW/oFdBMtXSV6qYmQEba1AQ3oz0TMqYbVI//arIKJwc4R4+WNEuivUQ3O00v8aKlmM0P9mYeMC/Z5EMTqO7x7D0+N0bzkLBy5CREffug+1s85mGnRbQhd9CnaXRj9CVc4jSzWEahBgYoV9CCcQ43vwrCLq9gpy/wxB3oDxBOxyoJOF0vMIxEEI7QV/BHINEGGwBCh1iFmgmCDboPsw0oGRx1btUybEG4NjsQxcPAoiDVoIAgukCHjziKzBevarxP6mw96eRzkLEQmkGGy6Mu2MTmb1bsSH74FEiu7cUdwbf5L+xAto1L5MvOdyNZpHaReZiQvKWZlNO0rM7+PZEE1AQYG2B9OMc258m7YfUEtBpNwjehKSuwW7TnQp9UrEhEMgC/QGyCb418IjN0NrGmIV0Fd0ul2VqN8nO/nMxrHsDT6e7PjQ0NDQ0Lf3VPPo4+cMDQ19dxRZ4uaFLH/2lSWSYY2wrvCnrz/Mq/7HVzlf7HDdH9yB6foA/NlXlvjbk1vDolj/wjyrAfDHP/5xfu3Xfo2/+Iu/4IYbbuDd7343L3vZy7h06RKjo6PfdP5HP/pRfuM3foMPfOAD3HzzzVy+fJmf//mfR5Ik3vWudz2zJ3cGxZeTo4OqinV78MMY1aDfgyAasCUCNK+Oiw5uG8IFsEIgpYg/8Chsu1hqmb32VcbSDmtxkFJd0EqgyRCaAMsHWUBPQGCCb4GRRNrYRF5eQfgCEW0iUjeAM0XQmiHYWGVmZQuzmsfJbrLe0dg56dBJQqsLFOJYR36UK1YbCnEkK45Yj0A4glT/Kkg3IYIpUF1EELCkTHCmuhuzuB9xToGjFtx0me2GRPf8LjrtPQSRNMqFryJrRZicJJ4v0d4qwdrrAR+v10Ke/xz2pEdgzmPX3kB08q8J987iaSYHUz4bXo5y93WweS3x5jpm0iQd+hIdcwb5wiV2uYtszqVwZ34cVkZhWSWIqmzmQ+SjFohxAiOLOVaCY/dDdwNtpUe0XKQa5BF6QD+ZRd1cp4GKp0QQNviZHYAHiQDh90DxwVsCu48fU5H6LnRkaK7DmIAjOjywAERAKBCywFGRYicIRb9CKnyOTsHHjGfxszMgZcFsglsHo40kl1CsMl7goJgK/pgN3s0wo0A5DM0QRIAgBM1ZvPgG1eNtPDOKvqdLcbfMUmQEz4sSlupMnOviVBUi05+lKCUIXvwK6qndHOw+xMPMsRpYjNh18q2AfriHiAZULFgoQCzjQ6xMJb2N1PPBB60BGg65K9BJQXqHTeOqg9pTUVIuShU6N8DxV8JSAW60YMcZ2FjVAIv2GnipZzacJA8k98mPDw0NDQ19e081jz5+ztDQ0HfvnxbFGk+FecFYwGfXFUzXZyIVAgn+x+uP8Bd3Lw2LYv0L86wGwO9617v4hV/4Bf7Vv/pXAPzFX/wF//AP/8AHPvABfuM3fuObzr/vvvu45ZZbeOMb3wjA7OwsP/3TP82DDz74bZ/Dtm1s237i63a7DQzimXAeSh1wQxBSIW5DywFHAtMFQ4a+0KHqDNoV2VXw56HcQfnbCOm1CCplJtI+1htge08MM7wHbGeQNt2qQWwBRAepdzeia6K4MvG180x86hTaEgRxk+61cHVahrE5gqP/ht7EMVzjN3GDCkbNYGqnTWs3lDWIWDBTXaHW+TQN/fXQO4jIZGDVgkkbEf5Z2DbAcaB9FWJZqr1fAlMbpF/v1qAXwksLygfbuMHL4HiUzMX3UghKGI4gH72Xuqtz/NSPDRoJ7f4a4fSj7LxyPzNun3NSihXxb3DjP8Vo+EOsTezhVF2jrbwI4WTgmo9Qal+L0aiwt7nFmfIYhZVLqHsCKqG9oHjglSFq4paP0IpdQz/2EO6lFyL5OsHMOnhFpGaFtNWkJ0WQYzBVq1Bd7yEME6sTI2Vs44kQ3baF8FWYngT60AmBuYkaOCTDAbYh0etdQfgS2COwEzBrcEqBhApKGT32UaYm7mUs1SFlC8oWNB0obh2nI42AF0OK99CsBhHRw+0J0GW0IMAd/3u8nALbt0JPGez11uKDPyz5rdi7d9Le+iDhyyZdRbDcSTKjVrH7HTYn8uQmOyS2DNwVieijn6VzeB57dI4J8wHs4hInp/NsOh32n3cZ9QLW5sDIgxXA+M+ZXO5AMQfj50DehJYq4RQlnCr06wHSFORWNPqGwqzjYubh0ovhTAGOdGHqXrj4KYWWCcmwhKyB3X6Gg7nLYH/8kx0f+q48k2yZ973vffzv//2/OXv2LADHjh3jne985zec//M///N86EMf+ob7vexlL+Pzn//89++bGBoa+vaeah59/JyhoaHv2j8tivWWm2e4f1tmOhNmrW6y2bR4660LHJlO869vmaPUsnj7p89y2548uio/2y9/6Lv0rAXAjuPwyCOP8Ju/+ZtP3CbLMrfffjv333//t7zPzTffzIc//GEeeughrr/+eq5evcpnP/tZ3vSmN33b5/nDP/xDfv/3f/+bbg/Cg628uINMZscBXwWhAd4g61Uo4Hc9iDZAjEFXgXgU6aE1QqUkhtQlEWoxIvtcDSnUE8fAH4fAg2wOujZS+zST93wA1b1A0JaYXZGIXIbOtqBojxEOm6TXHCKtB+krO5Aa6yhscHnfAXYF91HoWLRHIXw+RK4jEzRHcQKTkfllzuz8GLZ5B6quYk9NE8zvhdo4OAZ4LVLB/6E/1sWRX45kncRonsZRRgjGb2NSvosb7Kt8xtqBG5okLzXIVAWReTBlmVOXX0zATUSu+Z/sse9kpOZgrAlKnoSNSdr6MPX0W1ke+XG4MkqreQBuXkYZ+Syhwkl6pwpQ71HvyNBfIR5qsapH8SPXg+RAeJVM6h6yhsXy2u24V38J7Dwip8DIJpKzStzs0TLj2MYEstzAW5eYULq4EajKPWxfotDrgm/TGTsC3Q44Knh9ZNkl5QSoBoi+IBFaZ8vbC/ECyHGwgbAFKQ9p/m+Jxb5EP+Wx2YZtGRIh8DwYsS1i0jo9X0K2BKoHHRFC6ijsc3pUPKhGmxCvg5WG1CjgD6p82wFEQgj5+dRem4a1y2wa5xFs0XDCJE0LQ1vD3emTPVND7U6SWl7jwtp9OLM76WwqHDnd5Xx4ipI8ya7yMmIddregp8LmuRDixyys2UFaXGCA25IZTQX0RwTuJYlgdtCxKTjokJJB+HDiBjh+DeT6sPs4bH1RolhNkEDFFz5yzOMpFiG+mfvYx5MdH/qOPdNsmbvuuouf/umf5uabbyYUCvHHf/zHvPSlL+XcuXNMTEw8cd7LX/5yPvjBDz7xtWEYP5DvZ2ho6Ft4qnmUp3F8aGjoafvHRbHe8P88DEg06iYxQ6Vre3zg3mU+eWKDcufrC2m3/NGXecdr9g9Xgn/IPWsBcLVaxfd98vn8N9yez+e5ePHit7zPG9/4RqrVKs973vMQQuB5Hr/0S7/Eb/3Wb33b5/nN3/xNfu3Xfu2Jr9vtNlNTU3gNcI1BAV7LgxQQcqDkQyqAvgNaGRQjQPgyQVCD5ARYNpJaRJ00cfMW4azAjsDp0QTGmbPk7niQ9mwGjiziXzVZuLDJ2K4Kl1JQ+LsYwVaBJh76gVViVy2s5iTCLTE3e5Gt+96N1u6R7luUj8WYzjkkNMg2JaSVPHbQ5IKnE5AifFnjqH6Jjfwl8hfBHJdZa+ZpjNyM6Pw44cqj3JQ8ycOOgtn/ENY5k9SKQD/YZWvmTiZDW+RcCeww1A+xvm+eStyitX8nwaUMPjdhTH+E6bUv49c9KrrA7cpc3T9Jb9etjJy4g/Dyh+iP/Th0M6A4GGOf5YbYcVprIU71coRyRXblXIrCo55VaBiTYOdh4z607QfI1KqMjwf0dnyJrZO3DPJ1tSZEXaJ9i0CAHLhIniAgjjJaoRWWyGoCo6Vgeiodz6XvahDqgB8G0YNuCykW4MfBAVQZ4n4AQQzasUGls4oCSgBjdRIcR3c8rI5EX47iaD5TpknUA12CsA8dVeAIGckJ8Ns+ow0b3R387YSLLt6OKiLeh7I5uIMqQ0gM3owIJyFxLUyMIIojxNc+hO2kWA4lya2fZwZBLG5hmSsUHI/2lYe5mt9NXUmyU6uSLZUoHtrN+lSJQtGkVwS3Aq7jcf6rsK8LrWWJi+d17Hac2VCH8CGb+KjAjYE0P6j6rNShthu2doBuwI6Hofw5WFqK0hFpPEwMHMJ9mC3AQ89kQLsMfthPdnzoO/ZMs2U+8pGPfMPX73//+/nkJz/JnXfeyZvf/OYnbjcMg0Kh8P198UNDQ0/PU82jj58zNDT0PfN4Uaz//oULvOfuZd7/piM8b1eeH/uzr3Fpu0uj7/DnbzzCdbMZrn/nneQTxjAd+l+AZ70I1jNx11138c53vpP3vOc93HDDDSwuLvKrv/qrvOMd7+Dtb3/7t7yPYRjfclVjrDHochS4IPchCCBkQ6YO+gJcjUMsAv2QjxvxWZcEwZkKiUtbGBsm5q0BRgz0ywpYgkjPZqTYZZQAcXaL5Lki8vIkXkrj6n4Y/XwWfX0KT9ugPdfCvEbgLdQp90xujfSQ75OZLNuUohZ6ISAx1mZqBtrrsOUJlMwqY4uQvJrCCgL6vkRiKUJY7dPbgrF+wKhW5F5/iV5fwjNNJAGHhc/SWofqKtAxUKoO4WaRs5EZzqztxB27AUSDbiRDd+Eg5KbAS6BMfJWpC18kXDLoz1poRYnQboEV3g/rt1IJ5cE4AWenBj+syShyX8Eeldg6dQiU3Ug7Ps5yRMPNLlCMlWBjCuJlZO1BIqEW2R0BdQ8YMWFyGzZ3w4QMsQLJpkRbAt20iHiLtPshmimZrhfHNGU0tUkEm7gGTsyiJVVAxJFoIGIeuiKI2WCrINnQN8LQWoAgDbY8WJ0NuUjSaRbMLdwwnE9E8Y0F5G4bxV4mZoLyWJHnuAaVjoGuOWQ9l64MWw7kkpDrBhwv1XB3XYZIBgx/0DZJc8HpD0ZZxAG/gSwustDskHEbbB+vEKwZpA9Y9CIqmj9LS17Dy9ZRt+7CTts4++AFjQZ3tLa4ui/DQmITIwfql2F72SO+qNAuBlzJS8Rvtymc8whHAmQd1I6EiAtqV0E/DsYsMALmGIzUYOpBuLikUvFDpFHw0HAjCtMjAaXaMxycDk9+4fZUF3VD39Z3ki3zT/X7fVzXJZPJfMPtd911F6Ojo6TTaW677Tb+83/+z2Sz37rdw7fbTjI0NPQ98lTzKE/j+NDQ0DP2eFGs99y9TCKsoSkyXdsjbqh0bI8/+vxFfu/V+wH4zVfu5YP3Lg97BP+Qe9YC4Fwuh6IobG9vf8Pt29vb33ZF4u1vfztvetObeMtb3gLAwYMH6fV6/OIv/iK//du/jSw//Zz8S+/PoIg+ImPh9CTCjTwNR0KlQviox9zcoHuRaoOWgc6qwL3cR2qMIEQYe7xKomtgt0YxMy2ul9q0HlSodmXC3VE2pB5j0SJnRgP0hyVai2mq8gapfTWu3i6jFGTMyCSBO86jpzcZT20S5LpUpgJeWIC8C2stg/t2RKnoXYy8z96cj9cq4ldC5IwQkV0Ou8ahX4ZIGhQbwvToTW7hqx2spkRGFZjTEGpAq20TnQTPGccs/DQSy8ADyNllEluP0PSTUFyHqEmQbLFeDqOmPNxUjKTbI5Qy8PXsoJK1egCMJrL5MUKRLRz/IGb/RTwYGYVDt0G/jxPts92IQGIEvGXIZWG6juhDK7Gf9cunyTke9rIMcR38x1pLJQtU21l2uNs0BATCJ6/12QppqE4fS4zSkSWSXp1yPE8vsxPCk6jBPdBQCMIhkBx8GSL1QaXkFU8ftLFajYAwwTAgCVK4R9r0uYKKL42DkyAI6ayoWxR0m31hcNxB9WZLt2m5OnHFp+BBNAoxEyJJoFqGmU+DFwMmIZmGaBhS8UHFcNNGKn2N2RNfZXzdxUrD/pJPs5JHPrlNbNzFjXQwi2EyJzq4Nz/KdSqMSDBSgIO9ddY1hZw72MZsvgx2nILKZR/tJpgOBKYB4Z/0SdVg/RMxXCVgdKmPdBksC+K7YTE8eLMnew6C0wqmE2aaNDYB2wSEfEHtok69HAUaT39A977L40Pf1neSLfNP/cf/+B8ZHx/n9ttvf+K2l7/85fzET/wEc3NzLC0t8Vu/9Vu84hWv4P7770dRlG96jG+3nWRoaOh75OnMk8O5dGjo++LamTQZQ/AXdy/zlkBis2nxgZ+/jt//u3Os1vr8fz52kvHkoOPMgYkkd1wo88BSjVt25p7lVz70nXjWAmBd1zl27Bh33nknr3nNawAIgoA777yTt73tbd/yPv1+/5uC3Mcv1IQQz+j5G6UjQJlm5SpVWSbpFVjAICCOeDDAP+kjpBpmro1hQrwWoh8kKBMmYAG98igXbI2e0mNuZxvzrIq5rRCogrqIERUOLVughHvMXY0RFeNsRVyWFlqMfkZFmvfZeqWEX3gF5fgVYqN/yULZ53ATYjWZv8vvZ3n/KwgiCWh8kn5kiVq6y57rHMzLDs2EQ2lWoZDx6MXBViDbgcMs8mD4XdghmfuSSQpZk3poB152N3JxlS3Hxtq7C2p3k1l9ABkf09AINB/8bajrMNNHsB/78GFs4yugpKjuiyPCfejsg4oPqxJk+0Qax9GLHsL08MI3Q/PVsL8KwQNMrtXQL7mcW3gQoc5C8xqo9BCZY0TthxmJenh1cCwJjm2AXwVMKPt4doogts2ECa0Q1GQZulFCksVeax1Xg8vBDN3Qz8HWHGgxvFwU5hbB3MQr99FbHrE6GE1Q54B8BOQIOB5EI+DY4KexMgq2HoXYFBCDchVLhDECm5QLehyKNfDlAEXyCcswGYZaB4wutBLgZyToryHHP0EgXgu6B35i0AYraQEOxpkyqe0e3QhIIbBVl9SeDeQsdH2J3J5tTp+cRL8zRctqcfdhl1ff0QddZeQFDtmyR+fLEumS4NSPgHEYOnthtQHBX41R72lEZmpMxvqoL+8y64FRg6u3QJCHYh6uhiDqwcQ6lNdT+EIihoJHkr7kEu00WG2H6IkRnlEA7ADaUxwfelb80R/9ER/72Me46667vqFd3Bve8IYnPj948CCHDh1iYWGBu+66ixe/+MXf9DjfbjvJ0NDQ98hTzaOPnzM0NPQ9p8gSr5kJ+ODlyhN7fg+MJ/j1l+3m33/8JF3bw3R9fub9Xy+8+ysfe5R3/viBYSr0D6FnNQX6137t1/i5n/s5rr32Wq6//nre/e530+v1ntjn9uY3v5mJiQn+8A//EIBXv/rVvOtd7+LIkSNPpEC//e1v59WvfvW3XLF4MjVUJriWRJBHCXSipDEJk6SDEFco+x64CULOKh1MhAijEkcjikKAaU4hEdAVHqXTHUaFRCBSVN0R1kNVxswAW8Q5lurTiQeY6kXWbxZ09UkmVwTNNZWj6aucP/a3tDNH2Uruwi03OReL0Vg4gnn4NuhsgdkC/yaIJ0idf5CRiMXDt+pcSt9I1rvC4WCThgt9GWp1MC3BpFbEiiqsjMxSDNp4G7sR4i34czZm20XeuodD5c8RXjYJ6aDtcliLSXSVIkFyJ3Qei5hCKbhuPygSotuBbeDcCEr8HkTEg5bP3gjUC9AzKmip/4Mr/wycWUAyzpEwLOyohKz4BGUZYd4Hxj4oPR97rMpmpo5Y9xFZC9rHIXoQUlHINPHVMEvVKFNRm1jfo6mHCUJZ2prM5uYK0w0PK3gpyDeB34VIBKSXgNgLc2cINIEmLRG9HKBNQi83AnYa/P6gRZECJGIE9ixldETcHFTNVnJAlbjTZ687OHVtBco6BAmFsa7HTHNQJTlUBScMa5pBEC+g1zfZc/EeKltXaF07hbXrxwj23QrtKoQ17KkpVtuPYKkaUirG/u0mAsHZI4ewSLHv/P1EtDaBrbOwbbLY1znVVJisxRG1GsUe9Ds59p3qkN9toWmgJaG/CPl2lMsBiKvzeNErvChvMXMrLKtwah5SHoQUwIOxbUg8ClK8gRzIlNwQMnliwsYW02Ro4D5lKdJ/YhgAf998J9kyj/tv/+2/8Ud/9EfccccdHDp06EnPnZ+fJ5fLsbi4+C0D4G+3nWRoaOh7ZBgADw09qw5nBX969DD/6e8vAHD9O+8EIBXWcEwXPxAsjET5jy/bwy9++BGyUZ1f+vAJ/v3tO3nbbTuH6dA/RJ7VAPj1r389lUqF3/3d36VUKnHNNdfw+c9//olUv7W1tW9Y8f2d3/kdJEnid37nd9jc3GRkZIRXv/rV/MEf/MEzfm6JUWp0CNMilF6ivReIBchjNkHGwhsVdM7qjN6VwfMl7IxBqOGTkTbQMjVqrTxNJ09WtMjKOpO39jAvtrDXPSxLwmCawEmx+pBP7fYKzT0WpjyHuKjSDsIkPZuJUwqXCgEcOYY1t4/16zyQJsEVsNQmd/UDJLwGrmtQHj/K6QMv4nL7HqzEGEhdYkslmlUIZ2FxEaInJToixui4hX8rKOsN9qzW0eOf4+Q+DXfiR0EyiTn3kg5stiyd5ugovdgYdqxGwEvAGAV/A1oXkNQwelHF5gVwfmqQQuw/xHzvk2S6HqtjGpciMzhjVbKlFqyvsjXWgm4SUZzGnpdYnClA3yJdexjVlIlq91COX0MveQs1RSCPbkIkB9vXQkofbMxWbJBUvEiE5fhh5hcfZqTaRVaWqIYNQr5PS47i+YdBacJUAKmzsEOGdg7ENH78WvpakUP7ulzMp2imXwpuftDvytcg0Ad7ddMRNu0M6C3wS0hembhvkcdHCChWoV8DSQerlcf0+oxKTdZdkJTB6nRjNI2kZdklX2C6JhhfLNLfKtJNneP8LY9iPf9VEPMRo5Mkl0IgCUxHYdOROLQD3NxuYg+fJ7osyGbbBCGJ9QMBuuzQtTWWwi0WchAdBWdRQulKPP8ExOfhyxnoHwHrygaxLYN9vseobKMYsCRDfxVuqEDwKMhRiL8a9BWICmAsoGtLJFyDx9becdHpyCMoQejJhs83GxbB+r75TrJlAP7Lf/kv/MEf/AFf+MIXuPbaa5/yeTY2NqjVaoyNDd/JHhp6VgyLYA0NPetetj/PSw+Mc8sffZl8wuA/vnwPv/k3Z9hdiHN5u8NSpcf/9fFHUWSJK+VBX7I/ueMKf/3IBr/zqr3D1eAfEs96Eay3ve1t3/Yi7q677vqGr1VV5fd+7/f4vd/7ve/6eR3up09ASTHQdIcX3dTFOQThHgSOhKtJ2K9xWH15iU4PAr+BeR6OnAH/eJKyM0cJiWm6KK5N8ZSEiYUUt4irMdxuijabtHphduuQxme7s8r50Sj2mMqOjd2sLs/TNsJg+rDWJPHwXyG5YdqjUURuH74Y4fCVDVJ0KUe+wt1KCssICLTDyM0NwvGA2gVwl0DWoOeBqthUfZWt9QLJK6usI7MwY6KkTuJek4R4mM75w3x17wGCGxRQU6Dr4N4JIgvLdeJrf02wZRJLyCxILtWRu1jN3IjdnIG5yxQvCqJtmUTKYXvfdYj6Kk7/IUbXLLajx/FjR6AWsBnEsAoTJGqXkQ2INwKSfpPoyD1cWrdwxSvwCcN2FJoyjCmQMEGpQuATVtr0KFBz58m4S6wuxNDrTSYjcGVrFJJZiHnIqa8wt/nXrMpJSKvMVmuYcsBkpM/5sREutf8twjsESgRkHwwgrYEegnCF/kgaMtdB7xJyZwlJFthNCbUuMF1wBMQ8kIVOfLxDZBtiIdi8BLVxBSt9AElqkqw7TM3AdhxEG7y1HkfPf4b7pwuI5FGIj1EcnyXTu0BmxcKfhmAKou07CVZselfG8MM9dr+wTnBAouiq2KMCeTHLJmVqtwqUI2WC89A4HWFxR5+TCSjFof/LFvmWhdaBSAVEF5b+D4xPwvS1UHNAk2Di/GA/sJ0H6wwEToBCB4ktRvCoKBK+DLPBKPVnMqC6QPAkx/vfzWgdeqbZMn/8x3/M7/7u7/LRj36U2dlZSqUSALFYjFgsRrfb5fd///d57WtfS6FQYGlpiV//9V9nx44dvOxlL3vWvs+hoee0p5pHYTiXDg39AOiqzDtes5+3fuQEf3LHZTYaJn/82kOU2zb/4RMnsdwAXZX58zceIRbS+Nn3P0hYU4arwT9EnvUA+NmSJ8tlWWIj0qWwnePMeyKk81WM1ihFex5HyOSyq6RfuoF0naBSgGQe9Gno2SbFhwIkIQjTp2qGqFd66FaYqFCwpTkaaOiEiURrJBKC5FcgW3VZONhk8yCcr0KHEDu+vMRqWMULp9l15RLtkk66HiI68Si1fUnuSyW4TbTotzyi8Sr9YBIKO4iXLjFXEmxclml0IBJREcLDm3SoXjeJPXUN+6vrJPoeV1UZq1WA85OQbiD2zCHcBvg6dM9DtzFYHhzrIhkN4uEeli5QDcGj+T3oizmk0lkm4p9D7Tu0jwac80LcnHTo1I9TjP809UKSjrpJsCuAlQrkJqjP/ixEV+hURkkbD+GG6jiRAPuqTzDVhW4YlCwUTMiakFchtwEtG1lexvIEkvMIzfh1ZO1NRq92SYtB8FYJzQ5StJWTqGtfwFzrIKkSgZYmGuviCUHVgJKbIwjvhVASYjlQuyDJ4LngyajiPMneZWqRMGgh/NQkrbaPom/QCLk0DKgLjYYyg5iKsKe8SjeAbQXWj4Edn0TE0ujmeURT0NgEeRRSbXBC0Ki6SJuXEXv2geNi7riOrXqT+OQ2t7YC1Aos+DVWt1IsIjNjpml81Wdvq8nkPofGNaBW6hgRgZQEOwvLDlinUpQ3HMZ2eSR1WJ1WWAkCGrqg8wkYvUsiYgqUfRAKgelAIKB/cVAIO+hCrQy+q2PhIbGBj0fWDxP4GuOsc+KZDKjhCvD31TPNlnnve9+L4zi87nWv+4bH+b3f+z3+03/6TyiKwunTp/nQhz5Es9lkfHycl770pbzjHe8YpjkPDT1bhivAQ0P/bLz8wBjv/Zmj/NbfnAF4Yu+vIkmoCjhewO9++hxvvmkGYLga/EPmORsA37b/HAsjPnfdl6FOksDrE+lLnGkpLOp15CDM2Kbg+Z/UiB3XEZU8+v51Kj/hsJIDSfLIjy8yMdlCvyDRNTUsMUKJED1FIRI5jZ9WKB01qCxMc9OX1glVBbG2xOGbBSzUOXc1hqr7KL0GdnYP5Vac6NIoSXrY7T67ehW2D3rcvwCzRThyR5yliQrL1ieYWFxHcsGIBvhCItOIkx3psnjEpTuTQFKX6Vzr49mgKwHG1iI2NyBZbST575h0N/EWZUTdJyYCFnffiLA7iPEdlNs3EcR8moFLoE1jHdwBiRWKIoMkyqjdNbJRB05B9sZNSkaDIP+z2NE+bHShn4FkC+QbCHlfIY1M5Zop6r0sN15YRLYE/uQkNJKQMpHqnyd6aQnDs2m4KoGaRBI+kqUiU4HINluJQ7zAvI/6TpmtdhrHuAE8B2I9QnIDkQNd7aNFAqKjgnUVdBtiyhq98hIEWbBqkNNBDh670LhMrn4PhZxFm03cYATZahGoEdysTEuDZT9BY2yGkLC50bnCnCTYDkDkwInP4S68kNHKneyxtgiAlgPGKvQl0MLQUmMEU9eC0gMc0PII6RBe98usRQJ2ZkB2YN+0w1pVpaBUSE926SSAO1VmMj7xSRc0mF2BjgFbKcjNVYjdm6L5SIA34ZO5vkVFljnYBfvLMfzKCEqoRO9Bi9XNAK8HU/vB3wR8aNQGCw2q7tGxAiw0VBJ4apOYMAn8Zzg1uDz5bDK8aPuuPZNsmZWVlSd9rHA4zBe+8IXv0SsbGhr6nniqefTxc4aGhn4gXn5gjHhI42fe/yD//vadxAyVd/zDBd73M8f4b1+4zKXtDv/ti5cB+P/96H5mc1He/IGHUGWZX/rwCd7zxiO88tD4s/xdDH0rz9kA2HZsxkXA0XSTB7aP0fRVtEaCNUbRHYdCEMdgGau1k95pgypZwqLJ/ItqjPYN+pLG+N4O4ZcJ1POC6Xt97GWbtOzR3rXG2ht1nMN7QdPAMlme2CK5rtPsu0yc9pmSJUL2DJELW1Su2aKX67Pxk69gunoXohRiSTXYqMc4dm8VedJG7YLb1Gnv00hslTj4VZ+up2EWAuo3y+S/2mZL9dntBZj1IquhI6xGoviZOFHZJGjmYPQM+9bvQU30CBcF1iKENTAj+qAAlXYULAVv4i1I8nEM625myp8nVhO45wJkQ2Lb0omOBKQUQcaFsOtyQdrG1/ogziA3TMi3CBZiID8Pr/FKpsrvY5/XY91UcTQfNw1KrYIf6EidM0w//GUKRRttDk6N6MjWOlnToa+CIqAbuZ9wROVEMU8t8XJ8MQWh/eB6kM5jh3OMddcYj3j4cpeGC11ZZ3fgEIuZ1CKn8CIp5OQ6QWoOGrMgC8K1D5P1Nmhuw4SzRTVeJSJbmBGDnpA5pUXw/Aw5f4VjnS7zCKo6FA1Y08ZwRvcTqt7PxMPrjHRAmYZqBBpRSIfBCEFFPwDaXqivgg7oLuQm6UcOcN5bxzPrZKWAyUN9putXkXIBqQTYfWhuRElsqXiGTf+SRv+hJKbk09NqBOY8PT9Lqb+JUQ8xc8EgyW76QRcvsBHMYvVl9NU+3Q2Hkb1VRuah3Ae7MfizTM9CqxxgWAqCGHXJoSO5eEJlt9oA7xkMqB7gP8lx67sZrUNDQ0PPAU81j8JwLh0a+gG7cT7LZDrMmc0WP/JYMHvzQo6//MUMN/3hndjeYN/C8bU6//OrSwCs1Ab9yn7lYycBiVceGq4E/3PznA2Av3BlN8UlDzMapWmUidp55GCZCGUCUmRYY06zsP0mm6JHi2XS821qEci9qoPUOE/v5CirrykSvR2SeZ/t5W2CMGzerOCNhMFpgxKg+hDLBniah654XLqaRJZCJPPLtG5yMJO7oacQHJ1g4+YkxqcbRL2AfLhJSGhMrEFcg9O3Nam85I3kLp3GGD9FuyUxc5NgSdZAs5EMQXsJwiEbxkB2JSQJ2vlrYGIE/FW6hszehiDkQteAXhtqnobQu+CXoT0GvSaz5ieYaJRpXYagLlO3A0hBtuPRbQsqPYXS/gg1+QX4rZeBd4ap0x9ifM3CXvY4Kf0UTIziGRmO71ll6sKn2VN3KS2obGRz+MqLQR9BGGAbEp0R8NKQ7TpsoVIfDyG6Drov0PuCqYjNiehL8asvAs2FbBg6bZB1RhyFHSEoRmE1NKghlhYuMQ2OKQF987PoG3diaBZfO/RWiO0C+yIJ81FqAroZiZntAF2yqORgBpsa4CsSMX+NnSIgpQy6P3UNuBSK0V44iGafZ2LrKsoGmC6UDsgsjeuEJBfL8HFUlW5sFpQW8tKjKNIG7swC6A4oB3HJczV9Gr21xVYS9sQFxpUsrXgduwuy6+FxCMd26LDOMnPUsBl1TDxpHR2HHYSBBpIn4dGihswyNjOUyRBBkvqMjLTJzUJoFGJjYDVBFuD2IRyAh0sfie1Qh5QakEs6bPfkZ9QFCQd4sjbcw8qlQ0NDQ0/uqebRx88ZGhr6gVFkid951V7e+pET1HuDAXhyvcliuftE8AvwmZNF0pFBGfcP/vx1bDVNfvtvz/LLHz3Bvy8P9wX/c/OcDYBVDGzRoU0EySsCCSKk2EWLablOUq6hFSxK/SpqbR6kTdJ9H6cHS9fC2JvaxN4liHwKMtfDRgyk26A9Dh3VQLE9JFFEetDg8L0NrskFXMg6VGoaEKcqu1Rv7LH0uj3YsetAiyOXr1KorNMXMxyaWWbudT6xhM9yBbaacD6eI8gvYFau0N8lYd8RxXmgx2xNIwjAnbXwY7A5egAOvpnEuU2OnrzEFafOViGE6WXZSKXZtdbGsKFWgWwTVuemIfYC8JMwC7TX6Vc9Wn1gDlJdiZwG6z2w0gGWA0dcjbv8Y5jKz0DKJPS5Oxl9OIUQJsWdHiT2ghsFv0UgkqwWYmxFZvGDowTyCHR3Q2QTPXYGZdIFC3I2NOoQSgiaqRTRbouJhkmu79P2o/jR/RCPQVoGJYCejlS7zAQlqmHoxkAPYNSCya7ASECzCjdaJv3LJqYOSqGPb+iwvU68a2LrglgFuiZE4hBLQCY0KEiNL9BkgeLBehdCDlQjMrXRBUjmSDx0iuk18Cbh4qTO6txOfDlCy93GszcIxQCthFz8FAfvvoeY6nLieQ3MAwdAssDIYrqzLKXr5BWLXZclrAsR7HiDwAkI4aLQJUGMLvtYoo6BjCr5xKUOkupgeON4OChqnQJ9Op5MVgqQRJwKPg4WI7j0TfB7kNgFlWUI+TAShXpRJo2OjY7qSsh2Bj/ZxC0EwwB4aGho6AdpGAAPDf2z9Ph+4Hf8/XmAb+gF/K6fPMQ7/uECjb5Lo++iyBIXim0+8uDaE+f8yR1X+ND9K/zcTbO87badz7TR5ND3wXM2AB7X15CnmjjNKitdmb1cYkJxUHJtpm41aS4JrAs6MUsiyiajwkcuS+zYFIyloD8h6P92G+OD4C1BFMiYMPezMKX22f6AQn1DYGwaROMq26sOfhsyXoqYKqNkmyTHBFvdGna8DP0eke0T7K4FSKqFO+/x2akpZra2yfsO3YsGEd9Dm7qTbkHilCzhhXuETIh2fQLNxQcWp1N0Dr0E4mn66j5Spy7hE8EeuxYptkRmex3fgUdHMlQyMqOlGuWFDFglSLbB2kY+/wk6TpP2RIqYNkEt0yJb3MYUMiM5D+m0zKWCjp+pg1+DqkPKKtJXNPx4m/oNt8GuODQ+A9EESDsg9Crc0A7Y3gPmWchvgrgP/cpp3MUoYbONpIA3rdBJ7EaqNciVLdIB1DSoWTKMyBBRwPPA90HV0O3zjEkmSwGk0hB3YNuTKDcFc4AVhVwUnEkYHYOwcoFu0EQa0cnXAio+ZD2QFej0YXcH0hHoO4OC0YoYXI/IcQhsWIsriFgOqdZifK0xaCs8Cu3JBH5qB/R01EaNuBfgKwFK4iqSo5AULqMVuHF9kZOaT2NuL8g2JOO0+zNI0SvYOwMyF9aROhJ2v4CFRkADhwoKR1GkNRK0SMa6JBIBimwitizOeQVkXMZGGoyVM6iSgRV0kAMPQ3i42wqy5xPkBanrYXIKWqVBtykjEHTwWJclPClEKgjRq8kko09VivSfcHnyC7fhvrWhoaGhJ/dU8+jj5wwNDf3AvfzAGC/ZV+DPvrzIu++4zI7RGFfKXWq9QeC7txDnQqmDHwj+yxcuMZ4atJNMhjVapku95/Ind1zhffdc5S3Pm+MNh9LP8nf03PacDYB3RxrsjAhM20WXprGIMTV2FmWPT9s1WF0bR+lrIDVwgRwBWaWP+1mVydM+3o8KHtwN2TfCZhu2/l+VuXxAdTmgADQelRiJQG7GpKvLdKqgXQ+ZWJWULyiOSGyMRuhpeZCLkM9jPNAmlrK5cuMK3WMq1ZFp/GqfdKRGcStGoZwkUniQC9fP0LgoDbaUJgLMlotjxwlWO+hzDugWqF1Cy0tk1nXMIwYkxhHBGEakQ6nQYGlsP/nVJfw9gkjsEk61h6Xvhe1FtEsrhGKC+oF9WPFDKMWLFPekEMZNrPsujCsE0h4Ie4PIsKvQOHSQRmYNdyyOllmjcPGd9CItPJHArPw7CL0OnBqIc4xu/j/E6j2KSZ1ubge9G/uk7usQjwjKozoiEUNSA4RdxPYgchk2I1HIJMFXBlGpZ4HUpxA9izEKO4uwUYRGXKKYzdOMOvSrHfZaLgHg2NCwwI0rENNAqKhCIgWcyRsoPSgIG8+BnjNID5Z9GLVB7YGswjLQHTEgpJKqnmNccbB80PpgaTKSW2e8fonZzRoT0cH5o+4ajZiEfwwmNiH1UECsssSdkz79+AxoMqQSyJJBeNTEOgjSSYl2R0GXusQVm3baIrINR3dXMAKP7ppEq2+gdLKUvBAV+jQ8hWY5zO4gyuyuIraosrymIyI2qiPhN6K0zvVQw4LoFLQ9UCrQlSVCxAiLEJrvskAKx2+T6naf2YDq8uQXZvZ3MkqHhoaGnkOeah6F4Vw6NPQsUmSJX719J7sLsSdWg//gsxcAaNsu//V1h/jdT5/DdH22moMN+wsjUU6sNUlHNBp9l67t8+47F3nfPTK/8Px5fuXFu4ap0c+C52wAfLZ5jCvdCp7ssD5iEZg7CW9KzJV6dNUsXVwENhGxg5x6ka4nqG/FiOgWlZLGjO9w4E0g56CcgOwbPGQLpgIofknhhJlAtmVSRRCWTzzSJLJD0HqBxFY4TSuaw8uNgWZDOEA6WUa9t0O5BvpeOGp4JO98iPK0hNqBEV9QdDIY59Yx5FUmIwFRXdCth8CewBExRjorbDnBoOJwdREp3KQxGjD3YJndqY9wfOZ6Nsd/hmL3S8wuPczzmhZrixIHlCrBdIPP2hqeliRiKFCR0JeXmfAeIbHh0nqpxurkAoH+eohmoVEdLHn7Auba2P1p9DmL2eXz5O9vo07B2TTQb0C3DIoPEZ1w7yK71kq4VYjPSpyfcQi6gnBUsChCtPUMaugiiaBPKoDmqkR7Q6KfSUMkAbIEYQE9QbT5CWbtJb5qSuRVQaIKzUDBnxmla+j0slUmyyvYJYioIEmA3ACtDnTRUj6FMjgNh1VDJd2HK2FYaEOmBiKAiDHYcmwD6+E4nrETtXgWubNNfx5Gz4EzCrGgSbL2CDee7RNtQSIDsSr424LIhODqTrB0aH5FQknAQn+TM7k8RKLgQc+Isj5hsuMaUJcC3MObXJiAdgD7PXC2N1jZDTecVNAvTrLSjdMngovDHiQ6BLT9EI8yyc7lNNOhBnN2Fmn0PFHVwb4KvTNp1FaL0R/xmXgxKAuwvKLSNUPoQkZDQkIh4Rgomw7PKNfOhSfN6RmuWgwNDQ09uaeaRx8/Z2ho6Fn1j1eD/+SOQRXoX37hDrIxA9P1mcuGWa6ZAJxYawIwk43yygMJPvLQIDW65wS8+85F3v+1ZX7h+fPDPcI/YM/ZAPguZZ3ebAtFWFjWKDP+MvkjFcYOtIiOL9JaF1y9U0a3JRzfp9hJkdcE6byL2DAob8DY+xVaNwaM3iAo3QTOOiSKsHwpjG2NkLACBDYxpcJYQrAag9W5MH4mCqoE4Q44MvLlEhN/bJHZMmgYDgVfULqrgO56TNxcxViBfq+NY9RohFLYh9MYsasU2j6XVxJUtDKy42CmZLaP3jQo71utUt01w/kb11DOQO7RgLHgIkt7fxStl6XwwDnOlRSi9QSSlmJs7zrjxy6zNT+BnQ+wJ3OM+k0KdZt2B8ZXbNYzGn7IhdAS2GvQbsNIBlk+w9zWlxi/3yS8LdiuQCEKYVllKxKCaAPCDqDi+SF8XUIIgYFA8TzyikcQhlIiDobBWH+L1IYgWgXzcgRD8fCOHoXCKOgeBAYU72fqa3djKQHmCyKs79M5eraBqYYwjFWmV3pUY3AurjPWdEi3Bn/sQsQhrIMaxZIUvJiH7wt2SS6pKpxL6YxYDnkLDB20HkhbsG2AtSsOhEmaZTrpOL1QGzvh03DhhjWH1ikHIpCbBGsTohL0m6A3YcoBZQZGVUFZhkzTJVxYwXTnQWriorARlpjJCOyj0P5yHl9vcOVVDmNVMBZgzgHzfJytIE2fNhYKM1RIECLJCDW2WJS2Oe9MMe7MYShLhCZ8Yj4kV/rUREC5IpM665NegFQOGobEBXLoksZqwudoK0mLEh4mzygAfqpTh/vWhoaGhp7c05knh3Pp0NA/C4+vBu8cjfIrHzvJb//N2SeOdexBG42b5zPcd7UOwHqtx6n15uD2hSz3LdUA6Nr+E6nRw0D4B+c5GwB7sRphxUcuGrxoxza3vqLIoRdBNwK9Mix/OobXVhCizZo5ikOSqLaGooEhIohOQGk7ApdlsksN9JeClof1HMwfMbE+G5DGZEKv4Uz7RN4A6WugofVomya+Pgq+Db6E2u2iOjI1fyeJYI24WmG7LTBjfYyWxLmJMAu+SXlXjdaPXw8TGYrhFtObZbR1nzEvgm1YXH5pBu+mXdAoo5UeIv+R82grabqyRX2fiZuXQPFwJhfoeQ+iVVNsCIHuzzN13iY7skW02KKTMtjYcy0Vs8pY9wFGHEGtLeGHNJBWiV/8ODMPXkIZU/BCBv1Mn9QVj/RF6IyC54XYujtJYnybyvP6+AcfIYgdBGUKdybMxWCaI5k1NsOCsZ5JpzLKxXEDRZRQfI+RlkAvgXNFIpntU7tlnODmF4NQIOmAr4JXx69BZ4dEb3wGaUyludIkLCyaoQK9uEIhVkepShg2eDWIxiEmrlLvLCH0Nr2uRM4DTwOvBWoNFgwHZwrkGNgy+E0wFJBLsLdX4lTbpDa+Cwo5ir0HiTk+2W1QjkNQB60Ay49CToW+Oqh1VS1rKFfCyLe2iaBgdgSGHzBdr3IpGwZhIWV7dDYE3XEofV7j4eZOJj5fJhVe5OJPBPgbcNM2+BEfX9IJiylkqU2hUEKtF7DddVTRJKprrPom5708t8km+iwkOxKmyBISCVqmjX2ixLrlEcyD1dIpoSKLgCOtUeap8gApLsuPNQp+uoYrwENDQ0PfneEK8NDQD51Bn1+Jf/fRE8xkI6zU+vzUtdO8564leu4gEI7oMrX+1wfv48HvtwqE/+fdS7z+uileun+M6+cyw2D4++Q5GwB31Hkmtrf42Z0tXvIj0E9ApwjtCPTvAuPSPtJBQJ818hRoILjcHSW12iDth2m18jhSi1GlwdaXxzBKJQovF+j7wdjps29snbwkyL3E5vJNIE1DxoclGYSiEC11CYsWjfEE/kiI3o46YluiqtikNxNkhUQj3acxEmXr9Tcjf/lepKQBM3kI+mwujFC8qcIkTUqlEJUFl+C6GfBk8JbJH3+UsdN5bCdLRm6zKi/TnDPRLn8KL3M96g6Z9FKPQBiU9AcZz5jE4oNs5fGWy8achDexh+3qaVKpHiO+INM6Th3B5NUrdCSPkZMe6g6bzVSBUlKQOLZNAnC3NDa9HFG9jBoI8qUl6pnP0i/8PPhJGjf8BI/wUZ5f2caQ4R/GQ7gTUWLlgKluA0MDRQKprXB1PEr9hn8DWhKwQLFAkdFrZSbkPoEs0DYv4TYEsUuCVNjDvs6mODNJ/nKDmc9Dqy4Tvy5gOw6u14FwDZQ49YhOsGGR7oNogp2APSZE18GJgxsBYUPMh1YZpoyAhu1wOb0TRANXEczZINagsQapMAgHVBcaAtwKBJsSkm+gMoZzqke/mWK8ZxDb2iI84lN0i/RlQarvEJdAcSFWUYigcDWd55q/byGMMvpLBBfioP9yB3HqOPXTOcaXPFIpGaEWUZ2AmCNRfXGffr3P1+4foeZMMf0PDgdiW8giyjazXAwCMm2dhHmVzSo0wxapVocAj4ncWaJjHUY2IzwsUtDYfvoDqseTr0wML9qGhoaGntxTzaMwnEuHhv4ZeuWhMd4rf71K9HvuGvQDXq72AfjvP3kNb/3IiW+63+PBb1RX6DmDJuB9N+CD963ywftWSYRUXnt0YhgMfx88ZwPg281t3nCwxexhCCxwuqCnB9Wc+wF44RVCNihyl5hTIs4UFTlHKF3FbKS47BSYESpla4KrSpVbygLjDLxsBlox2Hqhhb0A9gEIGeBUYCQD8RAU2i7Tn3GJLUosvdbh3OEQQRayBEj9NLJIIUW2MV8AkaM9XrL9VTJ3xzgX1qkdPI0zV8DPTfDIDsFO5TJBxmZ7ZDdBIg2tRYy1y4yfsrGdKFpkFW+hQ3HXUWJbK+xsneZK0KEZ98lNmwR0MUbg4jg05iWSqwKjKyH5CYSkYTwaIC8PsrV3qiUeekWHmqKS23CISdCcV2iP3wxRhbr/KVJdn8gDAYFRJaQLoq6Ct6UyWzvJ+XQLkrugfRIzLei2IFSG6Pga6YsS0zFBXAXTgJ6QUDWZzt7d4B2CwIWkApILrk/oyglWNUF4UcGd9Un0IVIbpBqnViuURJ3oosDIgHZMcN+0QjMl0Q+FByWfNQ13JEa01aazDE4WIrPglqDfgX4J9FmQEtDvglUEEYH+Tg2iIRSryGjPQStDaRmsnoSeEJgdEC1QQmCHwFNA9jR0CrSbJRxVYm/7INEv1bhl0qa10+FrahQr59EzAxwF3IRAOBpKvU6rn2PHJ7rkKyarRwIa+yAx6pP58W3c96ksfe5malKbaWOd7cBBXfPI32aSfMSj7goOtscwo1tI8TYPWy0qksqakyO+sUprw2c66XBw4SzF5TzIPeKzAS+a7dL6osddz2RAOYB4kuPDi7ahoaGhJ/dU8ygM59KhoX+m/um+YF2RKSRCtM0ud12qPOl9YyGVnuMzEtOpdL/+Lljb8r4pGH7Jvjzz8aeaKIaeylMV3P8X63VH6kxMDj53LQhnB0GLDMQOwvzzyli6jR3so8gNRGJtbvmFkxx+ex/1VUto+gWy4RVsWuTVGrGbIHEY+neD9/caSlki14eFc3DzaYh+WMb+IszpkD8D5btltrYgf6dPutMju89FM7roIo+FYMuOMLEY5uAlOIRNfE+P3IrNC/78DNd88qskq2cwCzOc3rWTs9OH8EScuc99jZ3334kbkqnt1JjOrLLnUJXFV88RzC8gNbqMVTzSS0VW98apXjvYTksIzs/EWR7NocgSyRUIFTdgbIbK/BjmQYnt/ZDe7DD9xS+SKJrsikCuL7Oz6JNpnSSYnObSyDEuRVX0a3uEbq1TSccwM3kqqd3oZ/voGyeg0YC6TcJ3aQRQ0WHiEqROCLKrMNWGYxaoeZVzt+6mf8NLBlWt3Q7kPMgkQIDWFjg9nbSrMbsF0w+phNsyuU2FPV+FF9o+id0QPQaNOWiOSpg9GaUrg9UDyaUdzdAMg+tAchwiApw2NFRwBVgbEDLBz0A6BBkdrHQCZJeMt8F0TxBeAbehYDphAhvcFsgWkIXMHpBjgqbapUMZWxOEcn2aQGN5HL4o86p1QaHVw5QkrBHY9iG132NEaRCze6SQ6bcSNL5UwLogoT0MzSI0bQjt9jC0NjWhs2Id5H7HYOXUFClkjs5X6RlQkiew82nsAx2WEx7NlMm9cpiwEeb6G6FtR9GSggmjQyALSkVwXHjhLuuZDSiXwcXbt/sYXrQNDQ0NPbmnmkeHc+nQ0D9rj+8L/oufPUo8pHJ5e9BR4+PH1wG4ZSHzLe+33R6Ud//HwS98446Ix4PhN77/IV78Z8f5D391ir95dJP7l2r4wTAgfqaesyvAqRjYHfCtQfpzQgcpCboO4Rx8opfnlLOPWS/EJAGRw1uEXxywcQ4mYzYju4uIhsrVzQYLIxaTe0D6mkr54QTL1igVrUPooSrZeQlFCtM5PYXevMD4LS6mJWG2ItQkmdIJjf5mHT0hsXdyiStXC/jCIuanCU4mmZs26UuwJNv0pixm2pD/O5dEbJuvvdoh0GfBtYh87SyZT8mIcYtItsrm6zOMFzapfy5E/OPbxA7/PROhLq4Les5mvOeiG5DcCz1ZopfeRZAaxxn7PNGTPlLThugInVtfzYOb9xBWLnJ43GTnmsvyKnQ0CJph9BM2xAUcmcLSf4yV1DqbWY92/FpEcBCCTSLFL9JdUSg8+nc4F+5ArDrsTrYxVdi2IHMORrsyhAIuFyKsaXso3vB8vIlroW2BFhqUY/bWkbYeRAQd2C+Tw8NSYMYAJSzwajLbOz3MSZDiYKmwTwOvDUe+4tF7WKUzt835n36YIHELhEGEQExCzwavBM2rEKTBEpBOgOkO3iTI7IdLkzr1iQWk7Utk/T5JBzwDbMen7XnQVAnLHoEK+Sz0NMgdAH3bRb3SoeYoZENtWtIVZH8aY7HG1L1t8tOC9hEfNwNWDEZTPi+YPs3SYhqFKNOhCttWlnOf2c8eWaA8b4mDb7UIGRKbIssCK/RR0TEwPBW5JLM32+DeaJ1zikDdjPKq/Q32dLqsSyp+ILFWj+AfN6mW54m4i0SzNlpphp60hqx5zI8+wwHV5clnE+87H6tDQ0NDzwlPNY/CcC4dGvoh8I9Xg993z1W6jxXFundpUBDrHxfHWshFWar2vuH+MV2h6/jfNiGk5wo+dXKLT53cAiCkShyYSDKZjjCRDnPzQo4b57NPWVLguew5GwCHe4NWsmYaQnHQAH8Leg34zEqeu5dewEuv/zL7gwYiojH1GpuNB2Su/sUhDNfFSyxTr8/QFTGc6Fn8msfyiZ08aIWQgJo7RsbNMHJqnDoJHGxa3hXykkt7r8C+vY91WkVLm+SrAmNVpbN6gErIwiEgZG7hyVAbheY6JB+W2YhJ2C8S3FzzCW2D1L4C6Z2gRHAll3JrDE9qkrIalOJRtnSglibdiRDvLZN85SC4uybhkurBZgHWLsBUSVDQN9nKCa6My4QOuYSmq/Qb5wgX70KPNDDEoK/triKMLIAVBynZJx4VoAN0wOzRt6chIoO8gNxdInvfQ+Q7FULCIPyAj8hWcGMQOq8QCWQie11yqMQ1mS9nd7J+4CcRN94IqgZeAFJz0Idoe4XYB97PaK2Ev9Ohukfj3NGjoPZZya4zfdFlumRxar5AZ5fGDnmdlA2lACZa0LVA1FWaCw4iEhqkVHeabCcgOAw5FzrnwK+C4oEWgZIP0RAk2pCaA9WGQO0S7qwx1YdcD8wqSDaYQkfuxJGjJcKWwFqC3PNBCw9WljurZcbTHpIn4wqooeIVr0X+9ANcf7hPuQC+BnISrBaIjseC1KGlNNGdDLNYFIJtyu4+xh/2UI9eovzFFMueYIEIYfpMMUdcXiS+HpAMw2jXYytkEjfaZHb5vOR4hZVuDJMRvmol+VdKg0z4Kku+yvOvMyk8VCaUDxibgFH/GQ4olycvmvVMH29oaGjoueap5lEYzqVDQz8kHl8NftttO74pEH48+AXQta8n42qyhBsIus7XB3pEV+g/9nUuplPtOsh841RheYLjq02OrzYB+POvLKErMJuNElIEsbDBSDzMZObrwfFzfT/xczYALq5DOAaZFFCGdhU+eC7Mopzkcur53BB7gJ98SY1eDHJ5mwsPwxc+naXdk4A6reoUMjZ5rUc2a3PlrhSnenN0qXEQHQMTpCZyaJOMAqqm4x+xWekP3sBN/GxA/u9dOp8fpfOeCFORImh98pEWTaeJkGJYjoq13efiddB7JbSyKtbOSaZXV9ktu9yruPSi7f9/e3ceJVV5Jn78e2tfuqv3rl5oum1oaEDWKASjEYEIbhGXRB1HwZPRTI7LMdFMnJNRjOZ3ghPP6CCZMWOSQWcSYExAMhgVRYgKRJB9aaBpmt73rbr25b6/Pwg1NntDL3TX8znnnu5673vvfd/3dj1VT99bb4E/hGEEWHLqsHqNZMViZDX5SFOQNbmRqn1Gjk9y0DyxmLHtBzElRdnhgulBKEg/8bXBpaqRQFsXHVNGUVZcizfFSsq+9Yz6yyEyWxVFV0BtG3TUQ2ungUlX6XTkKGIByPXV09ZZhsorAOVGazmMqeFjrDVtXP9FE106hLUwgSvAawYXEM2OkafraB5odutsypxM270PgS0fgp1g1sBsBmMA0owYPthC5t52skLpWB31NE6bQHTkDaA302Ypoe2aZPY37SGSkwpGE16vh69FuzAehdAxsFYZGWs2kTwlyNFwkEhdJRZPK/sN0JJnIccTZmQqGEOpBDwBrNYQxiiYfNBsgn1dYAqEcdbsITs7QlYQLAHo0CGggdkYxhqLYdaNdMXA0KrIqI9hdED7AROhoIlkf5hRfrAQoZIkQrqBymY3U3bWkV8cpj4fQhpYRkC3LxtnTCNNi9CtxlKolTFZ76I61k52biPUQNf+UVTRSS5u0mhiOlnYM/cw0qUT7dQoCRuxBQsoiB2n/TMzyQEnuWTRgoF0RrAmFiE1ZKNYC5Kmd+PP81FxzMHBI8kU6iGg48KfUGHAeI718qZNCCHO7XxxFCSWCjHEnCsRBqjr8Md/j5zhVmb/l5LhrsCJz0Cc6f9kRg1iX9o8HIMjzSevLPs5+Z7uFxsrMGlQnOUkyWbCZjLgNOn4Y0YcVhPTizJYeE0RFtPw/pRswibAvi7IUhDRwJIJr7c4+NAxEX2Ei4zyY8x3NeDxgWcnBNzwpz+Z2BlwYXLayfLlEMBMCe0U0ErTrhGYgqkY6CJEkNSifWS4Q/h2G7DbY9izdPQZ0DILvCYYaYMWK0TbTDR1jqCDKO3uZoq+fpg5ftjdrFH3l3wcqg0Og3Em1N7nhI40DGh83JLEzBYPI8o7OOzKBN1LLCWCe0yAlHIIr9W4xh/jvXwDrV9VxEp16jOvwLYzinmXneSru/GbwHwc0sqsVIWtOI9F+eqRKH++w0an+2aIdJG1+yNat2p06YpYBKLZYDRCrlsn3AW0QI0H9LowpjFlROyZ0OFHM6aQFt2L0xZGSwF3C7QVKqIpcOzKAvRgNpo9yrjMA1zZGeWwN422CXeC3QRpx9GOfwa2IGrMzWBtgbZyLJGD2EZ3UB/10jk2Dd0exO15h1Yti1jyCGgPYq9uIv1oBflJUWpzFXtbYOJmUDXgcuhEx/jZm5JExGjH6CtjhD2EPwRZ1jDkQ+RmyAr7COw1EkoFVzYcL4CIC3IqISkDVHMYYzpkBMHsgYgH9JARj9IxaV6MQRvJyorX68X/qYWoPYS5w0GMEEltDiJJAXINinrdQJQ0bGTR1RZl9BeNhG+NYI9AqABi2X5CHhNH1QgySENX6bg0PxMsh8gviGAphSOuFoxtRXRjIsvViDUSJM2TjsXUTVKR4sraevSjo+nqctPU5QCuxIuiAg9ubGy1FTMucoTJpQ1odjhUXsCHviIizj3kdPfyg2aSAAshxKWRBFiIYevLifBrG47wy08qCEQUnuD/Pannlmby0aFWAPJTbdR19pyPJRI7+2d9b5+cF78l+nyi6svJcU8fHmzm//2pjHSHiZHpDvzBMA6bhXBUJxyN4Y/EQGlYjAqH1YLdYqIg3cEdU/MZm3pBh78sJGwC7A9peL2KkSPhD/UGPg6loudZsewycY3/EPoVMfatHImhJYayRKn32ilREZIsddhtOrHgSFLR6Y5MoyNipJBWsi1H0WzgLA5isxjwR0fT2O7EF6rlqumN2GOQYYZgAPRmiLljTNFDlGe2U/9tH51HoXonOLzp2MkiyVVDsw2aui3QaSAnUk9ueRQfZrZarYz82E9mrIzuTAu600AoB0zVYA4pNhugfGw6tho/hlwj5rIWRn4YwNs4nmLTTkZeFcHbZaCqbjRpyoGJNiY3NdKSv4fy0mp0lUGHy0FJbhcNLRBtgZocyJwOfhtkAoZPQfeaSVER8tfsp3oB6Hku9OxxdB5NYsy7W2npiuGKxIh0xRhhgCZTO612KyHdiP8ImCrBle1Fa6tEjbCS/MF/UXpkH41ZBmr1VpzBIGnBMupK8yjPLUBZ/Jj9RmaUlVEajbLR3UZF6mgsW7aS82krlrBOhgsyUsHvgJrjJgojkDMmSudYRYvNAnqQJK2VkWkKvxV8Fgg5wREC950RupoM6PVWHJNCtMyE3C1g2gRaJlz5FfApsOng8YGugS0lhsVnRMdP0AxGk5/kEPhMNtp1I36VSzserOZOrMkKh6mTUt8h2sIzCdOGjoFRjSY6KiKER0HIDTlf91N9bComPYtmuqnDjCVSSpLWwug9TWR9NUzpKA/GNo0QPqwujcykBqzHstGqDNSFbEwZ1Y6x/SMa26bhxYmJFPwEqCKDZNr4emc6Rr5KfeO7hOt0yrot1Ce14Na9RLVevsvyc+4p9XrzncJCCJGIzhdHQWKpEEOc0aDxxJwS7p2Uxk8/qmHdvsb4uo8OtaJxYjL4U5PfZKuR7tDZ35tdaPJ7odr9Udr9nr8+OtvEqCcm7dpR3ck7fz2+3Qh2ixGL0UA4diJpRtMwoBFTOuGIgWe2r8egga6fSMYBlIKTF8AVxMehN9N76SH/+Sv9VcImwMlRyA5qGDyK1mYb0SIfhkAzUzojzBgToOHIeHYGptCkH2N0yEW+FqDC2EhBNEqaFmZE6gHMqRE+qSokqEyYTcmUzjqA41rwV2l89turccVGUE4DX/U5SNphxjkqQnMWaAbQNLBm6rRed5jca2J0uCHzjST07hD2YITC5AN4JobZ9pUkfPlZaHSTsTNKwecKZ1GY1KYwnX9JZnJTEM89QfaOS6Hsaw5sVUGyrTpH3UYiupWYy4Cj20PGX5qItZuw48eIBj7weiHZoGOPNWMnQCg1SlO+i5SDQTJ3VNKQEyVjGhgbTyTAbSNgXBGkaqA2QVPoxFcWGa6E4uYIzVVH8JeMh2AXKeVlWGtH0I6RbqJEW6pxWMOM2u1jlOUoxr/Oa6V7oMAd4lj7J3jrA6Q3HMJSo5N5TMfetZ1Jbh2XA97PaCQWVeR7Q5jDGqNbFfsjkBTuwDj+CC7NQ6TLTHPEho6fnGCMrJZUQlEdlRRBlUY5NgJCYR20VpKSvJhikG8CpYFFA7sDsnXIujKM/1ON1nqY7gVXFvjQ6AppOL06efVgiIKlFZxGOOI3UeTSqXad+LqraACysBC62U/NMSv2zx0YCBK1Wmm7NoAvxUvK5krMB3NJwYJf62ZEcz4FeytpzYhhSALTlYoWsws9lEyYdpoJY6ADo8rA3WnDFi0nf3Ynvn0tVASKaWnKxRQ4RHHEwbEvSuhQxYS7NpNlDNNCKjHy6NT2YqWeUpVONRau5SipXElNXQkOaskwNGCKJqFiGinRbKD5wp9QYSQBFkKIS3G+OAoSS4UYJowGjaX3TeXmiU0s/uMBWrwnZoL+csKnfelxss18zgT4chGIQSAQo+ftKl9OZQ1ELmAyv/6e1zphE2BnxInT7eOTWgefKzOa3UhSQzfjLG2sOzaKSm0SLdO8GCvSaPKHCGfUErGm09ydTr7vGF+b2Yg+SpG8Yj9Wg4PM/FZMV4NrEtQeMrDdqkgy7qXI5+MANlKOp+JqbsGRD9EYKB9YCsCRG8GcCeNrwebS8TZloJTO8bGtBG+GQEESZj3EiEPt5LUoOAI1HRBNB7J8lO/Iorg8g9I5VRz6hsb2b5lJbQphT41hDrUxOhbC0wb5ThijbHhdHeQVxKgZB8cydRqKKkmrjTI5pGgoitGalIJqDNHV5CKlFTwZ7aRO1AkcB6sFOvZDsAy8dRDqMpPtiGFqBYcdovY0CFog3EaOo5FwlhlLxIxujzHGGSGUDhl2KB8LWUZoqoS8qeCPGAgYnWBy0Dw5ixx3LWMC0Napc1yDGXaY2BzkWCc4j0LmaMXRVEgKg8Wvk71lH+2TXDiDiqTPI3S3mXGYY6iYDbOzG+tsH3Ul0GCDZM1Du0GjK0djnwKbD+wxSAmB3QnNEei4VpFbrnBuNxD0gH6zjiPPTH1ZAbR24DzWTjQEms+ASVcUaTHKu8DhN2JKj0FAR2UHsReDOzOEv6kcU3UqTkc3NUZIHgUZVUGyjzTQFR2Fx1hLbWQcKe9FiZUcx5UDGQU6OXlVHKnMw0eEJlsD1liAiDGJ9lAGnTXlOKwKgzKgE6Q+YqOtbRSKPPYrRQQXjdXf4CptM8VY8GMgjwBRDTKUDztBdmBnCp2YKUChU6QHmejLpUWrpoB8epUAR+Cc0w3KDP1CCHFu54ujILFUiGHm5km5zLsyh22V7aw/0MCaXfV0/vWzvl9+ujd5ghgNEDvDP8HOd3X48nLy+u7gStgEOA0nxzwxVnXnECiqxtxezI3tTRwNF7E9KZtYYRNkZ6J7o0Ta6sHegcnjxejvJhrp5ngrZKbBDTe10FAN4UYDbR+COgJVjTrB5HrSmn20k07EZMZwRTf2fLgyDFVdEPaDpx3Si8C998R34R7P9xNuDhHQUwhVJhHq8DAyvxnXEZ28o+A4BCPGA07oagLNpDMyuxXVkkTq/6YxIVxLcykEasCpw6hwkNQgRJ0Gmucoxrq8jJzZTXUStLaDo1mjRA/SOU7DpykcGjgsXgKtihBuomGoLvfiLAhSX6yR51cED0CtD1QE0jQdzQ6u6dA0A6JEoeUYBI10uoyklobJzArTkgJeB3gCkGGBMTEYZYT/SrXzeZsTPTmJmM2B8dh+nGUd2HNOXFU+oBlIMejsqwd3AEbs0eiutdKeE0RdceKriwydBlLfC9HSYKT6lmmkFOzD/EcfNj+UZNVjsYM1H7a7Tnx1UzI6AU8X/qid47lmsEYxN8bQC3WUZkZhwazr3JDtp7EGtKNWshsD2CxRRqU2oHUbiCaBN2BAa3TTTYQUSxvZRgMGv5OcSR66rZCRBkkalGZA17VeOvb5CNWacG2xMrLQj1YM7i1BGrxV2KLjaCeV9NY2nJ0aWZUKSwRCGY3kVwYJASlBF+3GAJ16HftdjUxzQmoA6mIRmoAinGTiI4AiDRMBKrHrOdSQhAMXZvLxqHl8oqpxcIC5Wh1Vyo2LI2QxEp10QjiZhKJFORnR2+/aCDNoCfC4ceM4dOjQGde99tprPPbYY/13cCGE6Cvni6MgsVSIYcho0Jg5KoOZozL4p1snnDEZjp3jfuCofA9wryVcAqzUiT+SGpzs9tgx0IK9yoxNtdOtsjiouYkZa0AvgIZq6NDRuiNoRgtXNmeSr1WQrTvwH7TgcoWIWSCw30gu4GuBPcfMNMYymdiZQYFyEjW0kzquifAk8DeDPQi2DjAeAr0W+AqUbbYQ9kLQGqE9ZiRtTDu5tUYcW2Fass7RMISi4MmGUCk4r4f8KrAcA/O6GPWZFaQYIccA4eMwVQNbGApaoXYTZKLTnAGdxVARguwgNB+BI3o+Re2tfOXTKPUmMGRGuTYcoDpgxBMNYsZHUbvC5YJmh8LWBU254GuEETngqIhRMBqSJ8IRF2R0NBL2Q5cvjdppDlozPKQZTlwULlPgMoCrHmIjoLYFAqYAuilCzGSG9kpGVDQyokonVgufm6B7jI6/Hlxp0F0N5lRFcjRIdxLUh6G9y0zIPhKmgNVcRawsildZyO/2kT0DIk7QFBy2wtFysLSDNQqukE76CB/mdoj5IckDDWbocBkwaAFs3hiqGEzdOmkjA+SmgOFqnWCKH22bAb8bqlw6poZWIsEkkhyKsCeVUr0I08FDaFf4CJjBtA1yHCe+XzjXqvhUGQlVjabpV0dwOYLYQ7WABTPjqaWMoPkYaZsVTf974vuDrRUaydqn2FQWTdjoiFmxGsM0WY0cL4dYRMMTy6TBbCcW8eMihTb8uPBRQBV1NFFOB3CMLFLJJIOxjMdPC4bkPaR6dApIwUcqx4mwHzMx2ijFgPWU58v5eM48l8L/rT/50+PpUW61WrFaradv0At/+MMfmDBhAhs2bGD8+PGEQiGKi4tZtWoVt9122yXtW5zdhf5tCJHo+iqOgsTSRHby76i7uxuz2dyvx9J1PX4cg6F3swH3ZtsLqXuuOmdbd6byU8tOfRyJRPD7/Xg8nkEf3wlZZibMGskTXy9gx/EONhxqZPWuOgLhM38Gwhfq1+YOGSc/A3xBMVclmIqKipP/Q5FFFlnOs9TU1Jzz+RQIBFROTs4F7SspKem0ssWLF1/yc/rjjz9WJpNJBYNBpZRSX3zxhQJUY2PjJe9bnJ3EUllkubClL+MoSCxNVBJzZZHlwpbzxVyllEq4K8Dp6ekAVFdXk5KSMsit6Tsej4eCggJqampwuVyD3Zw+Mxz7NRT6pJSiu7ubvLy8c9az2WxUVlYSDocvaJ+a1vP+vrNdsXjmmWd46aWXzrm/srIySktL2bdvH2PGjInva8+ePWRnZ+N2u8/bJnHxhmssvVRD4fk9GBJxXPojjp7cr8TSxDPQMffqq69m+/bt/b7thdQ9V52zrTtT+allX3480DEqEcb31LL+HuMLjbmQgLdAn7zVICUlZVi+CLtcLunXEHG59+lCX2BtNhs2m61Pj/3UU0+xaNGic9YpLi4GYO/evUycODFevmfPnh6PRf8Y7rH0Ul3uz+/BkmjjMphxFCSWDicDHXONRuNFH6c3215I3XPVOdu6M5WfWnamOgMVoxJhfM9W1p9jfKExN+ESYCHE5S8rK4usrKwLqrt3714WLFgQf7xnzx6mTZvWTy0TQoihQ2KpuFiPPvrogGx7IXXPVeds685UfmrZpfTxUiXC+F7o8QeDplRizWTi8XhISUmhq6trWP0XWvo1dAzHPg0WXddJTk5m1apV3HrrrQAUFBTwwx/+kCeeeGKQWze8yd/xmcm4nJmMy+VNYunlT55D/UvGt/9dTmPcu6ndhgGr1crixYsvebbEy430a+gYjn0aLBUVFfj9fiZNmhQvmzhxIosXL2bz5s2D2LLhT/6Oz0zG5cxkXC5vEksvf/Ic6l8yvv3vchrjhLsCLIQQQgghhBAiMSXcFWAhhBBCCCGEEIlJEmAhhBBCCCGEEAlBEmAhhBBCCCGEEAlBEmAhhBBCCCGEEAlhWCTAv/jFLygqKsJmszFjxgy2bdt2zvpvv/02paWl2Gw2Jk6cyJ/+9Kce65VSPPfcc+Tm5mK325k7dy7l5eX92YXT9KZPb7zxBtdddx1paWmkpaUxd+7c0+ovWrQITdN6LPPnz+/vbpymN/1avnz5aW222Ww96lwO5wp6169Zs2ad1i9N07jlllvidS6X8yUSW1/H1uGiN+Ny4MAB7rrrLoqKitA0jVdffXXgGjrA+vp1SwghhOgPQz4BXrVqFT/4wQ9YvHgxO3fuZPLkycybN4/m5uYz1t+yZQv33Xcf3/nOd9i1axcLFixgwYIF7N+/P17nn//5n1m6dCmvv/46n3/+OU6nk3nz5hEMBi/LPm3atIn77ruPjRs3snXrVgoKCrjxxhupq6vrUW/+/Pk0NDTElxUrVgxEd+J62y8Al8vVo81VVVU91g/2uYLe92v16tU9+rR//36MRiPf+ta3etQb7PMlElt/xNbhoLfj4vf7KS4uZsmSJeTk5AxwawdOf71uCSHOb926dYwdO5aSkhJ+9atfDXZzhqU77riDtLQ07r777sFuyrBTU1PDrFmzGD9+PJMmTeLtt9/u/4OqIW769Onq0UcfjT+OxWIqLy9P/exnPztj/W9/+9vqlltu6VE2Y8YM9d3vflcppZSu6yonJ0f9/Oc/j6/v7OxUVqtVrVixoh96cLre9ulU0WhUJScnqzfffDNetnDhQnX77bf3dVN7pbf9+s///E+VkpJy1v1dDudKqUs/X6+88opKTk5WXq83XnY5nC+R2Po6tg4Xl/J8LywsVK+88ko/tm7w9MfrlhDi/CKRiCopKVG1tbWqu7tbjRkzRrW2tg52s4adjRs3qj/+8Y/qrrvuGuymDDv19fVq165dSimlGhoaVF5eXo/3xP1hSF8BDofD7Nixg7lz58bLDAYDc+fOZevWrWfcZuvWrT3qA8ybNy9ev7KyksbGxh51UlJSmDFjxln32Zcupk+n8vv9RCIR0tPTe5Rv2rSJ7Oxsxo4dy/e+9z3a2tr6tO3ncrH98nq9FBYWUlBQwO23386BAwfi6wb7XEHfnK9f//rX3HvvvTidzh7lg3m+RGLrj9g6HPTF83046s/XLSHEuW3bto0JEyaQn59PUlISN910E+vXrx/sZg07s2bNIjk5ebCbMSzl5uYyZcoUAHJycsjMzKS9vb1fjzmkE+DW1lZisRhut7tHudvtprGx8YzbNDY2nrP+yZ+92Wdfupg+nepHP/oReXl5Pd6MzJ8/n7feeosNGzbw0ksv8ec//5mbbrqJWCzWp+0/m4vp19ixY/nNb37D2rVr+e///m90Xeeaa66htrYWGPxzBZd+vrZt28b+/fv5u7/7ux7lg32+RGLrj9g6HPRFfB6O+ut1S4hE8Mknn3DbbbeRl5eHpmm88847p9U51+fr6+vryc/Pjz/Oz8+XjxKc4lLHWJxbX47vjh07iMViFBQU9Gubh3QCLE63ZMkSVq5cyZo1a3pMGHXvvffyzW9+k4kTJ7JgwQLWrVvH9u3b2bRp0+A19jxmzpzJgw8+yJQpU7j++utZvXo1WVlZ/PKXvxzspvWZX//610ycOJHp06f3KB+K50sIIS7G2V63hEgEPp+PyZMn84tf/OKM6y9m/hTRk4xx/+qr8W1vb+fBBx/kP/7jP/q9zUM6Ac7MzMRoNNLU1NSjvKmp6ayTjeTk5Jyz/smfvdlnX7qYPp308ssvs2TJEtavX8+kSZPOWbe4uJjMzEyOHj16yW2+EJfSr5PMZjNTp06Nt3mwzxVcWr98Ph8rV67kO9/5znmPM9DnSyS2/oitw0FfxLHhaKBet4QYjm666SZ++tOfcscdd5xx/b/8y7/w8MMP89BDDzF+/Hhef/11HA4Hv/nNbwDIy8vrccW3rq6OvLy8AWn7UHGpYyzOrS/GNxQKsWDBAp555hmuueaafm/zkE6ALRYLX/nKV9iwYUO8TNd1NmzYwMyZM8+4zcyZM3vUB/jwww/j9a+44gpycnJ61PF4PHz++edn3Wdfupg+wYnZkF988UXef/99rrrqqvMep7a2lra2NnJzc/uk3edzsf36slgsxr59++JtHuxzBZfWr7fffptQKMTf/u3fnvc4A32+RGLrj9g6HPRFHBuOBup1S4hEcyGfr58+fTr79++nrq4Or9fLe++9x7x58waryUOOzO3Qvy5kfJVSLFq0iNmzZ/PAAw8MTMP6dYqtAbBy5UpltVrV8uXL1cGDB9UjjzyiUlNTVWNjo1JKqQceeEA988wz8fqbN29WJpNJvfzyy6qsrEwtXrxYmc1mtW/fvnidJUuWqNTUVLV27Vq1d+9edfvtt6srrrhCBQKBy7JPS5YsURaLRf3+979XDQ0N8aW7u1sppVR3d7d6+umn1datW1VlZaX66KOP1LRp01RJSYkKBoMD0qeL6ddPfvIT9cEHH6iKigq1Y8cOde+99yqbzaYOHDjQo++Dea4upl8nXXvtteqee+45rfxyOV8isfVHbB0OejsuoVBI7dq1S+3atUvl5uaqp59+Wu3atUuVl5cPVhf6RV+/bgmRiAC1Zs2a+OO6ujoFqC1btvSo98Mf/lBNnz49/njt2rWqpKREjRo1Sv3yl78cqOYOSRc7xnPmzFGZmZnKbrer/Pz80+qLEy5mfD/99FOlaZqaPHlyfNm7d2//trNf9z5AXnvtNTVy5EhlsVjU9OnT1V/+8pf4uuuvv14tXLiwR/3/+Z//UWPGjFEWi0VNmDBBvfvuuz3W67qunn32WeV2u5XValVz5sxRhw8fHoiuxPWmT4WFhQo4bVm8eLFSSim/369uvPFGlZWVpcxmsyosLFQPP/xw/I3JQOpNv5588sl4XbfbrW6++Wa1c+fOHvu7HM6VUr3/Gzx06JAC1Pr160/b1+V0vkRi6+vYOlz0ZlwqKyvPGJ+vv/76gW94P+vL1y0hEtHFJmfiwskY96+hMr6aUkoNzLVmIYQQQgghxJlomsaaNWtYsGABcOL2UYfDwe9///t4GcDChQvp7Oxk7dq1g9PQIUzGuH8NlfEd0p8BFkIIIYQQYjiSeQf6n4xx/7pcx9c0aEcWQgghhBAigXm93h7f8FBZWcnu3btJT09n5MiR/OAHP2DhwoVcddVVTJ8+nVdffRWfz8dDDz00iK0eWmSM+9dQHF+5BVoIIYQQQohBsGnTJm644YbTyhcuXMjy5csBWLZsGT//+c9pbGxkypQpLF26lBkzZgxwS4cuGeP+NRTHVxJgIYQQQgghhBAJQT4DLIQQQgghhBAiIUgCLIQQQgghhBAiIUgCLIQQQgghhBAiIUgCLIQQQgghhBAiIUgCLIQQQgghhBAiIUgCLIQQQgghhBAiIUgCLIQQQgghhBAiIUgCLPrFrFmzePzxx3nyySdJS0vD7Xbzxhtv4PP5eOihh0hOTmb06NG89957wIkv0dY0jQ8++ICpU6dit9uZPXs2zc3NvPfee4wbNw6Xy8Xf/M3f4Pf7B7l3QggxMCSWCiGEEH1LEmDRb958800yMzPZtm0bjz/+ON/73vf41re+xTXXXMPOnTu58cYbeeCBB3q8CXv++edZtmwZW7Zsoaamhm9/+9u8+uqr/O53v+Pdd99l/fr1vPbaa4PYKyGEGFgSS4UQQoi+oyml1GA3Qgw/s2bNIhaL8emnnwIQi8VISUnhzjvv5K233gKgsbGR3Nxctm7dSjAY5IYbbuCjjz5izpw5ACxZsoR//Md/pKKiguLiYgD+/u//nuPHj/P+++8PTseEEGIASSwVQoizmzVrFlOmTOHVV18d7KbEaZrGmjVrWLBgwWA3RZyFXAEW/WbSpEnx341GIxkZGUycODFe5na7AWhubj7jNm63G4fDEX/DdrLsy/WFEGK4k1gqhBBntnr1al588UUAioqKBjQRfv7555kyZcpp5Q0NDdx0000D1g7Re6bBboAYvsxmc4/Hmqb1KNM0DQBd18+4zan1T5Z9ub4QQgx3EkuFEOLM0tPT+3yf4XAYi8Vy0dvn5OT0YWtEf5ArwEIIIYQQQoghZ9asWTz55JPMmjWLqqoqvv/976NpWvwfgwCfffYZ1113HXa7nYKCAp544gl8Pl98fVFRES+++CIPPvggLpeLRx55BIAf/ehHjBkzJn4HzbPPPkskEgFg+fLl/OQnP2HPnj3x4y1fvhw48Q/Gd955J77/ffv2MXv2bOx2OxkZGTzyyCN4vd74+kWLFrFgwQJefvllcnNzycjI4NFHH40fC+Df/u3fKCkpwWaz4Xa7ufvuu/tjOBOGJMBCCCGEEEKIIWv16tWMGDGCF154gYaGBhoaGgCoqKhg/vz53HXXXezdu5dVq1bx2Wef8dhjj/XY/uWXX2by5Mns2rWLZ599FoDk5GSWL1/OwYMH+dd//VfeeOMNXnnlFQDuuecennrqKSZMmBA/3j333HNau3w+H/PmzSMtLY3t27fz9ttv89FHH512/I0bN1JRUcHGjRt58803Wb58eTyh/uKLL3jiiSd44YUXOHz4MO+//z5f//rX+3oIE4rcAi2EEEIIIYQYstLT0zEajSQnJ/e4BflnP/sZ999/P08++SQAJSUlLF26lOuvv55///d/x2azATB79myeeuqpHvv8p3/6p/jvRUVFPP3006xcuZJ/+Id/wG63k5SUhMlkOuctz7/73e8IBoO89dZbOJ1OAJYtW8Ztt93GSy+9FJ/DIS0tjWXLlmE0GiktLeWWW25hw4YNPPzww1RXV+N0Orn11ltJTk6msLCQqVOn9sm4JSpJgEW/2LRp02llx48fP63sy5OQnzoh+aJFi1i0aFGPsueff57nn3++D1oohBCXP4mlQghx8fbs2cPevXv57W9/Gy9TSqHrOpWVlYwbNw6Aq6666rRtV61axdKlS6moqMDr9RKNRnG5XL06fllZGZMnT44nvwBf+9rX0HWdw4cPxxPgCRMmYDQa43Vyc3PZt28fAN/4xjcoLCykuLiY+fPnM3/+fO644w4cDkev2iL+j9wCLYQQQgghhBh2vF4v3/3ud9m9e3d82bNnD+Xl5YwaNSpe78sJKsDWrVu5//77ufnmm1m3bh27du3ixz/+MeFwuF/aea6JCpOTk9m5cycrVqwgNzeX5557jsmTJ9PZ2dkvbUkEcgVYCCGEEEIIMaRZLBZisViPsmnTpnHw4EFGjx7dq31t2bKFwsJCfvzjH8fLqqqqznu8U40bN47ly5fj8/niSfbmzZsxGAyMHTv2gttjMpmYO3cuc+fOZfHixaSmpvLxxx9z55139qJX4iS5AiyEEEIIIYQY0oqKivjkk0+oq6ujtbUVODGT85YtW3jsscfYvXs35eXlrF279rRJqE5VUlJCdXU1K1eupKKigqVLl7JmzZrTjldZWcnu3btpbW0lFAqdtp/7778fm83GwoUL2b9/Pxs3buTxxx/ngQceiN/+fD7r1q1j6dKl7N69m6qqKt566y10Xe9VAi16kgRYCCGEEEIIMaS98MILHD9+nFGjRpGVlQXApEmT+POf/8yRI0e47rrrmDp1Ks899xx5eXnn3Nc3v/lNvv/97/PYY48xZcoUtmzZEp8d+qS77rqL+fPnc8MNN5CVlcWKFStO24/D4eCDDz6gvb2dq6++mrvvvps5c+awbNmyC+5Xamoqq1evZvbs2YwbN47XX3+dFStWMGHChAveh+hJU6fOliGEEEIIIYQQQgxDcgVYCCGEEEIIIURCkARYCCGEEEIIIURCkARYCCGEEEIIIURCkARYCCGEEEIIIURCkARYCCGEEEIIIURCkARYCCGEEEIIIURCkARYCCGEEEIIIURCkARYCCGEEEIIIURCkARYCCGEEEIIIURCkARYCCGEEEIIIURCkARYCCGEEEIIIURC+P8mBohfRTPpRQAAAABJRU5ErkJggg==", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -323,46 +345,45 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 10, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAFTCAYAAAAk628HAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsvXecZmV99/8+5+69T68723eBhaVIWwwdUUQURI0UYzDGmjwx6s9XFMyjPDE+lmDAmII+ahJFjcZGFQUE6W3Zvjuz02fu3ts55/r9MV6XZ2YXBAIieH9er/s1M2fOfc51rvI91+dbNSGEoIMOOuiggw466KCDDjrooIMOOnjBob/UDeiggw466KCDDjrooIMOOuigg1cqOqS7gw466KCDDjrooIMOOuiggw5eJHRIdwcddNBBBx100EEHHXTQQQcdvEjokO4OOuiggw466KCDDjrooIMOOniR0CHdHXTQQQcddNBBBx100EEHHXTwIqFDujvooIMOOuiggw466KCDDjro4EVCh3R30EEHHXTQQQcddNBBBx100MGLhA7p7qCDDjrooIMOOuiggw466KCDFwkd0t1BBx100EEHHXTQQQcddNBBBy8SOqS7gz84XHHFFYyMjLzUzeiggw46+L3H1VdfjaZpL3Uznhde/epX8+pXv1r9PTExgaZpfPWrX/2d3L/zrungDwlf/epX0TSNiYmJl7opHfyOMDIywhVXXPFSN+Nlgw7p7qCD54BPf/rTfP/733+pm9FBBx38nmB2dparr76axx577A+6DS9X/OQnP+Hqq69+qZvRQQcddHAI7r33Xq6++moKhcIfdBteKeiQ7g46eA7okO4OOujAjtnZWa655pqXnHS/1G14OWB4eJh6vc7b3/52dewnP/kJ11xzzUvYqg466KCDw+Pee+/lmmuueclJ99O1Yffu3fzzP//z775RL1N0SHcHLyqq1epL3YQOOujg9xB/qLKhVqu91E34g4WmaXi9XhwOx0vdlA466OBFxB+inLUsi0aj8Tu9p8fjweVy/U7v+XJGh3R38IJBxv7t2LGDt771rcRiMU455RQAnnjiCa644gpWrVqF1+ulp6eHd7zjHWSzWfX9J554Ak3T+O///m917OGHH0bTNI455phl9zrvvPM44YQTfmubvv/977N582a8Xi+bN2/mv/7rvw573mc/+1lOOukkEokEPp+PrVu38p3vfGfZOZqmUa1W+drXvoamaWiapmJZDh48yJ//+Z+zbt06fD4fiUSCiy++uBPb1EEHPLNsAPjGN77B1q1b8fl8xONxLr30Uqampg65zv33389rXvMaYrEYgUCAI488ki9+8YvLzvnZz37GqaeeSiAQIBqN8vrXv56dO3cetj379u3jiiuuIBqNEolEuPLKKw/ZrN12222ccsopRKNRgsEg69at4//7//4/AH7+859z3HHHAXDllVcquSBjhl/96lezefNmHn74YbZt24bf71ff1TTtsG7Nh4uRKxQK/MVf/AUjIyN4PB4GBga47LLLyGQyv7UNst/OPfdcIpEIfr+f0047jV/+8peH3Puee+7huOOOw+v1MjY2xj/90z8dcs7T4e677+biiy9maGgIj8fD4OAgf/EXf0G9Xl923hVXXEEwGGRycpLXvva1BINB+vv7+cd//EcAnnzySU4//XQCgQDDw8P8+7//+7Lvy7jRu+66i3e9610kEgnC4TCXXXYZ+Xz+Gdu4Mqb7iiuuUPeV/Sbj13/+85+jaRo///nPn/EaEs/2XWNZFl/4whfYtGkTXq+X7u5u3vWud/3Wtnfwh4WZmRn+5E/+hL6+PjweD6Ojo7z73e+m1Wqpcw4cOMDFF19MPB7H7/fzqle9ih//+MfLriPn8be//W2uueYa+vv7CYVCvOlNb6JYLNJsNvngBz9IV1cXwWCQK6+8kmazuewamqbx3ve+l29+85usW7cOr9fL1q1bueuuu57Vs/z0pz9VMjkUCnH++efz1FNPqf//7Gc/Q9d1Pv7xjy/73r//+7+jaRo33HDDM17/meRss9nkE5/4BKtXr1Zy6a//+q8PeUZYeg8df/zx+P1+YrEY27Zt49Zbb112zvXXX8+mTZvweDz09fXxnve85xALsGzPjh07+KM/+iP8fj/9/f185jOfOeSe1113HZs2bVL3PPbYY5XMu/rqq/nQhz4EwOjoqJJPcl9pHxfZpptvvvk5y65du3ZxySWXkEql8Pl8rFu3jo997GPPqg2He18913n5qU99ioGBAbxeL2eccQb79u07pJ9eKXC+1A3o4JWHiy++mDVr1vDpT38aIQSwtHE9cOAAV155JT09PTz11FN85Stf4amnnuJXv/oVmqaxefNmotEod911FxdccAGwtJHTdZ3HH3+cUqlEOBzGsizuvfderrrqqmdsx6233sob3/hGNm7cyLXXXks2m+XKK69kYGDgkHO/+MUvcsEFF/C2t72NVqvFf/7nf3LxxRfzox/9iPPPPx+Ar3/967zzne/k+OOPV/ceGxsD4MEHH+Tee+/l0ksvZWBggImJCW644QZe/epXs2PHDvx+/wvWvx108HLF4WTDpz71Kf7mb/6GSy65hHe+852k02muu+46tm3bxqOPPko0GgWWZMhrX/taent7+cAHPkBPTw87d+7kRz/6ER/4wAcAuP322znvvPNYtWoVV199NfV6neuuu46TTz6ZRx555JCkVpdccgmjo6Nce+21PPLII/zLv/wLXV1d/N3f/R0ATz31FK997Ws58sgj+eQnP4nH42Hfvn2KsG7YsIFPfvKTfPzjH+eqq67i1FNPBeCkk05S98hms5x33nlceuml/PEf/zHd3d3Pqc8qlQqnnnoqO3fu5B3veAfHHHMMmUyG//7v/2Z6evq3tuFnP/sZ5513Hlu3buUTn/gEuq5z4403cvrpp3P33Xdz/PHHA0tk9+yzzyaVSnH11VdjGAaf+MQnnnV7b7rpJmq1Gu9+97tJJBI88MADXHfddUxPT3PTTTctO9c0Tc477zy2bdvGZz7zGb75zW/y3ve+l0AgwMc+9jHe9ra3cdFFF/HlL3+Zyy67jBNPPJHR0dFl13jve99LNBrl6quvZvfu3dxwww0cPHhQbeaeDd71rncxOzvLbbfdxte//vVn9Z3D4bm8a971rnfx1a9+lSuvvJL3v//9jI+P86UvfYlHH32UX/7ylx2rUQfMzs5y/PHHUygUuOqqq1i/fj0zMzN85zvfoVar4Xa7WVhY4KSTTqJWq/H+97+fRCLB1772NS644AK+853v8IY3vGHZNa+99lp8Ph8f+chH2LdvH9dddx0ulwtd18nn81x99dX86le/4qtf/Sqjo6OHEOBf/OIXfOtb3+L9738/Ho+H66+/nnPPPZcHHniAzZs3P+2zfP3rX+fyyy/nnHPO4e/+7u+o1WrccMMNnHLKKTz66KOMjIxw+umn8+d//udce+21XHjhhRxzzDHMzc3xvve9jzPPPJM/+7M/+619djg5a1kWF1xwAffccw9XXXUVGzZs4Mknn+Tzn/88e/bsWRYqeM0113D11Vdz0kkn8clPfhK3283999/Pz372M84++2xgiYBec801nHnmmbz73e9WcufBBx88ZO3m83nOPfdcLrroIi655BK+853v8OEPf5gjjjiC8847D4B//ud/5v3vfz9vetOb+MAHPkCj0eCJJ57g/vvv561vfSsXXXQRe/bs4T/+4z/4/Oc/TzKZBCCVSqn7/OxnP+Pb3/42733ve0kmk4yMjDwnV/QnnniCU089FZfLxVVXXcXIyAj79+/nhz/8IZ/61KeeVRvseK7z8v/8n/+Druv81V/9FcVikc985jO87W1v4/7773/Wz/CyguiggxcIn/jEJwQg3vKWtxzyv1qtdsix//iP/xCAuOuuu9Sx888/Xxx//PHq74suukhcdNFFwuFwiJ/+9KdCCCEeeeQRAYgf/OAHz9ieLVu2iN7eXlEoFNSxW2+9VQBieHj4GdvXarXE5s2bxemnn77seCAQEJdffvmzer777rtPAOL//b//94zt7KCDVzqeTjZMTEwIh8MhPvWpTy07/uSTTwqn06mOG4YhRkdHxfDwsMjn88vOtSxL/b5lyxbR1dUlstmsOvb4448LXdfFZZdddkh73vGOdyy71hve8AaRSCTU35///OcFINLp9NM+24MPPigAceONNx7yv9NOO00A4stf/vIh/wPEJz7xiUOODw8PL5MxH//4xwUgvve97x1yrnz2p2uDZVlizZo14pxzzlnWT7VaTYyOjoqzzjpLHbvwwguF1+sVBw8eVMd27NghHA6HeDZbhcPJwGuvvVZomrbsmpdffrkAxKc//Wl1LJ/PC5/PJzRNE//5n/+pju/ateuQfrrxxhsFILZu3SparZY6/pnPfOaQ98Jpp50mTjvtNPX3+Pj4If30nve857DPd+eddwpA3HnnncuOH+4az/Zdc/fddwtAfPOb31x2zZtvvvmwxzv4w8Rll10mdF0XDz744CH/k+v4gx/8oADE3Xffrf5XLpfF6OioGBkZEaZpCiF+M483b968bL285S1vEZqmifPOO2/Z9U888cRD9keAAMRDDz2kjh08eFB4vV7xhje8QR2Ta3N8fFy1JxqNij/90z9ddr35+XkRiUSWHa9Wq2L16tVi06ZNotFoiPPPP1+Ew+FlsuPp8HRy9utf/7rQdX1ZHwkhxJe//GUBiF/+8pdCCCH27t0rdF0Xb3jDG1S/Scj+XlxcFG63W5x99tnLzvnSl74kAPFv//Zvh7THvvdrNpuip6dHvPGNb1THXv/614tNmzY947P9/d///bI+tQMQuq6Lp556atnx5yK7tm3bJkKh0CH9bH9fPFMbVr6vnuu83LBhg2g2m+rcL37xiwIQTz755NN1ycsaHffyDl5wHE4r6fP51O+NRoNMJsOrXvUqAB555BH1v1NPPZVHHnlExXvec889vOY1r2HLli3cfffdwJL1W9O0Ze6pKzE3N8djjz3G5ZdfTiQSUcfPOussNm7c+Izty+fzFItF1ZZnA/v32+022WyW1atXE41Gn/U1OujglY6VsuF73/selmVxySWXkMlk1Kenp4c1a9Zw5513AvDoo48yPj7OBz/4QWX5lpBWTbnmr7jiCuLxuPr/kUceyVlnncVPfvKT39qeU089lWw2S6lUAlD3+sEPfoBlWc/rmT0eD1deeeXz+i7Ad7/7XY466qhDLATAb7XoPvbYY+zdu5e3vvWtZLNZ1b/VapUzzjiDu+66C8uyME2TW265hQsvvJChoSH1/Q0bNnDOOec8q3baZWC1WiWTyXDSSSchhODRRx895Px3vvOd6vdoNMq6desIBAJccskl6vi6deuIRqMcOHDgkO9fddVVyyxL7373u3E6nYcd5xcTz+Vdc9NNNxGJRDjrrLOWzfetW7cSDAbVfO/gDxeWZfH973+f173udRx77LGH/F+u+Z/85Cccf/zxy/ZBwWCQq666iomJCXbs2LHse5dddtmy9XLCCScghOAd73jHsvNOOOEEpqamMAxj2fETTzyRrVu3qr+HhoZ4/etfzy233IJpmod9lttuu41CocBb3vKWZfPd4XBwwgknLJvvfr+fr371q+zcuZNt27bx4x//mM9//vPL5NEz4XBy9qabbmLDhg2sX79+2f1PP/10AHX/73//+1iWxcc//nF0fTktkv19++2302q1+OAHP7jsnD/90z8lHA4f4j4dDAb54z/+Y/W32+3m+OOPXybLotEo09PTPPjgg8/qGQ+H00477bB72meDdDrNXXfdxTve8Y5D+vn5lol8rvPyyiuvxO12q7+lp9bhZP4rAR3S3cELjpVugAC5XI4PfOADdHd34/P5SKVS6rxisajOO/XUUzEMg/vuu4/du3ezuLjIqaeeyrZt25aR7o0bNy7bWK/EwYMHAVizZs0h/1u3bt0hx370ox/xqle9Cq/XSzweJ5VKccMNNyxr2zOhXq/z8Y9/nMHBQTweD8lkklQqRaFQeNbX6KCDVzpWyoa9e/cihGDNmjWkUqlln507d7K4uAjA/v37AZ7RjVGu+cOt7w0bNiiyacfKjUYsFgNQ8bVvfvObOfnkk3nnO99Jd3c3l156Kd/+9refEwHv7+9ftql4rti/f/8zPvczYe/evQBcfvnlh/Tvv/zLv9BsNikWi6TTaer1+rOWl4fD5OSkUngEg0FSqRSnnXYawCEy0Ov1HuKeGIlEGBgYOGSzF4lEDhvvvLKtwWCQ3t7e33kejefyrtm7dy/FYpGurq5DxqNSqaj53sEfLtLpNKVS6beu+YMHDz6trJP/t2OlrJMKosHBwUOOW5Z1yJo93Pxeu3YttVqNdDp92DZK+XP66acfMt9vvfXWQ+b7ySefzLvf/W4eeOABzjnnnEMUAs+Ew8nZvXv38tRTTx1y77Vr1wIse7/ouv6M5PXp3i9ut5tVq1Yd0t+Hk2WxWGyZLPvwhz9MMBjk+OOPZ82aNbznPe85bK6NZ8Lh9tvPFpLYPt/3y+HwP52XK9/BrzR0Yro7eMFht3hIXHLJJdx777186EMfYsuWLQSDQSzL4txzz122gT322GPxer3cddddDA0N0dXVxdq1azn11FO5/vrraTab3H333Ye1+jxf3H333VxwwQVs27aN66+/nt7eXlwuFzfeeOMhSXyeDu973/u48cYb+eAHP8iJJ55IJBJB0zQuvfTS520h66CDVxpWygbLstA0jZ/+9KeHzSgdDAZf1PY8XRZr8et4c5/Px1133cWdd97Jj3/8Y26++Wa+9a1vcfrpp3Prrbc+qyzYh5OHz4Snsxo9H0jZ8/d///ds2bLlsOcEg8HDJhV6LjBNk7POOotcLseHP/xh1q9fTyAQYGZmhiuuuOIQGfh0/fbbxuN3iaez9PxPxseyLLq6uvjmN7952P8/XZxkBx38T/FSrDm57r/+9a/T09NzyP+dzuUUpNlsquRf+/fvp1arPet8OIeTs5ZlccQRR/C5z33usN9ZqXB4IfFs+nXDhg3s3r2bH/3oR9x8881897vf5frrr+fjH//4sy5jeLjnfjFk14uF3yeZ/7tAh3R38KIjn89zxx13cM011yxLziG1oHZIF5y7776boaEh5Wpy6qmn0mw2+eY3v8nCwgLbtm17xnsODw8/7T1279697O/vfve7eL1ebrnlFjwejzp+4403HvLdpxNm3/nOd7j88sv5v//3/6pjjUbjJa2t2EEHv+8YGxtDCMHo6KiyPjzdeQDbt2/nzDPPPOw5cs2vXN+wlJ01mUwSCASecxt1XeeMM87gjDPO4HOf+xyf/vSn+djHPsadd97JmWee+bzd8GKx2CHyodVqMTc3t+zY2NgY27dvf8ZrPV0bZL+Fw+Gn7TdAZa19NvLycHjyySfZs2cPX/va17jsssvU8dtuu+23fvf5Yu/evfzRH/2R+rtSqTA3N8drXvOa53Sdp+s7aXFZOUYrLTXP5V0zNjbG7bffzsknn/yclTEd/GEglUoRDod/65ofHh5+Wlkn//9C4nDze8+ePfj9/qdVFkn509XV9YzyR+ITn/gEO3fu5LOf/Swf/vCH+chHPsI//MM/PO82j42N8fjjj3PGGWc8o5weGxvDsix27NjxtMpJ+/tl1apV6nir1WJ8fPxZPd/hEAgEePOb38yb3/xmWq0WF110EZ/61Kf46Ec/itfrfV7vl2cru+RzPN/3y+Hwu56XLzd03Ms7eNEhNVkrNVdf+MIXDnv+qaeeyv3338+dd96pSHcymWTDhg0qq7A8/nTo7e1ly5YtfO1rX1vmJnXbbbcdElPicDjQNG2ZFnBiYmJZZkuJQCBwWCLtcDgOeb7rrrvu91Kz2EEHvy+46KKLcDgcXHPNNYesHyGEKil4zDHHMDo6yhe+8IVD1p/8nn3N28/Zvn07t95663MmY7AUFrMSclMmrcOSyD9XBdvY2NghJXe+8pWvHCIz3vjGN/L4448ftgSVfPana8PWrVsZGxvjs5/9LJVK5ZDvS7dQh8PBOeecw/e//30mJyfV/3fu3Mktt9zyW5/lcDJeCHFIObcXEl/5yldot9vq7xtuuAHDMFRm4GeLp+u74eFhHA7HIWN0/fXXL/v7ubxrLrnkEkzT5G//9m8PaYdhGB0lbQfous6FF17ID3/4Qx566KFD/i/X2Gte8xoeeOAB7rvvPvW/arXKV77yFUZGRp53nO/T4b777luWn2Zqaoof/OAHnH322U9rrTznnHMIh8N8+tOfXrZWJexu6ffffz+f/exn+eAHP8j/+l//iw996EN86Utf4he/+MXzbvMll1zCzMwM//zP/3zI/+r1ugo3uvDCC9F1nU9+8pOHeOXI/j7zzDNxu938wz/8wzI596//+q8Ui0VV5ea5wF4yF5aMThs3bkQIofrr+bxfnq3sSqVSbNu2jX/7t39bJvdhuSx/Lm34Xc/Llxs6lu4OXnSEw2FVGqbdbtPf38+tt97K+Pj4Yc8/9dRT+dSnPsXU1NQycr1t2zb+6Z/+iZGRkcOWYlmJa6+9lvPPP59TTjmFd7zjHeRyOVUT0b4BPf/88/nc5z7Hueeey1vf+lYWFxf5x3/8R1avXs0TTzyx7Jpbt27l9ttv53Of+xx9fX2Mjo5ywgkn8NrXvpavf/3rRCIRNm7cyH333cftt99OIpF4nr3WQQevfIyNjfG///f/5qMf/SgTExNceOGFhEIhxsfH+a//+i+uuuoq/uqv/gpd17nhhht43etex5YtW7jyyivp7e1l165dPPXUU4oY/v3f/z3nnXceJ554In/yJ3+iSoZFIpHD1sT+bfjkJz/JXXfdxfnnn8/w8DCLi4tcf/31DAwMqEQxY2NjRKNRvvzlLxMKhQgEApxwwgm/Ndbune98J3/2Z3/GG9/4Rs466ywef/xxbrnlFlWSReJDH/oQ3/nOd7j44ot5xzvewdatW8nlcvz3f/83X/7ylznqqKOesQ3/8i//wnnnncemTZu48sor6e/vZ2ZmhjvvvJNwOMwPf/hDYKlkzs0338ypp57Kn//5n2MYhpKXK+XgSqxfv56xsTH+6q/+ipmZGcLhMN/97ndf1Li8VqvFGWecwSWXXMLu3bu5/vrrOeWUU1S5yWcLmRzq/e9/P+eccw4Oh4NLL72USCTCxRdfzHXXXYemaYyNjfGjH/3osHHXz/Zdc9ppp/Gud72La6+9lscee4yzzz4bl8vF3r17uemmm/jiF7/Im970pv9Zx3TwssenP/1pbr31Vk477TRV6mpubo6bbrqJe+65h2g0ykc+8hH+4z/+g/POO4/3v//9xONxvva1rzE+Ps53v/vdQxKC/U+xefNmzjnnnGUlw4BndIMOh8PccMMNvP3tb+eYY47h0ksvJZVKMTk5yY9//GNOPvlkvvSlL9FoNLj88stZs2YNn/rUp9R1f/jDH3LllVfy5JNPPi8vpbe//e18+9vf5s/+7M+48847OfnkkzFNk127dvHtb3+bW265hWOPPZbVq1fzsY99jL/927/l1FNP5aKLLsLj8fDggw/S19fHtddeSyqV4qMf/SjXXHMN5557LhdccIGSO8cdd9yypGnPFmeffTY9PT2cfPLJdHd3s3PnTr70pS9x/vnnEwqFgN/Ip4997GNceumluFwuXve61z1jfzwX2fUP//APnHLKKRxzzDFcddVVjI6OMjExwY9//GMee+yx59yG3/W8fNnhd5kqvYNXNmQZnsOV15menhZveMMbRDQaFZFIRFx88cVidnb2sGVzSqWScDgcIhQKCcMw1PFvfOMbAhBvf/vbn3Wbvvvd74oNGzYIj8cjNm7cKL73ve+Jyy+//JCSGP/6r/8q1qxZIzwej1i/fr248cYb1fPYsWvXLrFt2zbh8/kEoEol5PN5ceWVV4pkMimCwaA455xzxK5duw4pp9BBB3+IeCbZIMTSOj3llFNEIBAQgUBArF+/XrznPe8Ru3fvXnbePffcI8466ywRCoVEIBAQRx55pLjuuuuWnXP77beLk08+Wfh8PhEOh8XrXvc6sWPHjmfVnpUlb+644w7x+te/XvT19Qm32y36+vrEW97yFrFnz55l3/vBD34gNm7cKJxO57KSLKeddtrTloQxTVN8+MMfFslkUvj9fnHOOeeIffv2HVZmZLNZ8d73vlf09/cLt9stBgYGxOWXXy4ymcxvbYMQQjz66KPioosuEolEQng8HjE8PCwuueQScccddyy7zy9+8QuxdetW4Xa7xapVq8SXv/zlw8rBw2HHjh3izDPPFMFgUCSTSfGnf/qn4vHHHz+kLZdffrkIBAKHfP/p+mp4eFicf/756m85Rr/4xS/EVVddJWKxmAgGg+Jtb3vbslJx8pq/rWSYYRjife97n0ilUkLTtGXPmk6nxRvf+Ebh9/tFLBYT73rXu8T27dsPW57t2b5rhBDiK1/5iti6davw+XwiFAqJI444Qvz1X/+1mJ2dfZre7eAPDQcPHhSXXXaZSKVSwuPxiFWrVon3vOc9y8or7d+/X7zpTW8S0WhUeL1ecfzxx4sf/ehHy64jSzPddNNNy47LdbSyLNnhZCMg3vOe94hvfOMbap909NFHH1KSaqX8tLfhnHPOEZFIRHi9XjE2NiauuOIKVYLsL/7iL4TD4RD333//su899NBDwul0ine/+93P2FfPJGdbrZb4u7/7O7Fp0ybh8XhELBYTW7duFddcc40oFovLzv23f/s3cfTRR6vzTjvtNHHbbbctO+dLX/qSWL9+vXC5XKK7u1u8+93vPqSM5dO1Z6U8+Kd/+iexbds2JZfHxsbEhz70oUPa9bd/+7eiv79f6Lq+rH/luBwOz0V2bd++Xe3PvV6vWLdunfibv/mbZ9WGw72v/ifz8nAy+pUETYhXaLR6Bx100EEHHXTwisJXv/pVrrzySh588MHDllTqoIMOXlhomsZ73vMevvSlL73UTemgg5c1/sDt/B100EEHHXTQQQcddNBBBx108OKhQ7o76KCDDjrooIMOOuiggw466OBFQod0d9BBBx100EEHHXTQQQcddNDBi4QO6e6ggw46+D3EP/7jPzIyMoLX6+WEE07ggQceeKmb1EEHLzmuuOIKhBCdeO4/cHTk4+8OQohOPHcHHbwAeElJd0dodtBBBx0cim9961v85V/+JZ/4xCd45JFHOOqoozjnnHMOW/Kjgw466OAPCR352EEHHbwc8ZJlL//Wt77FZZddxpe//GVOOOEEvvCFL3DTTTexe/duurq6XoomddBBBx38XuCEE07guOOOU9YFy7IYHBzkfe97Hx/5yEde4tZ10EEHHbx06MjHDjro4OWIl4x0/0+EpmVZzM7OEgqF0DTtd9HcDjro4BUGIQTlcpm+vj50/fcn0qbVauH3+/nOd77DhRdeqI5ffvnlFAoFfvCDHyw7v9ls0mw21d+WZZHL5UgkEh352EEHHTwvvFLkI3RkZAcddPDC4vnKR+eL2KanRavV4uGHH+ajH/2oOqbrOmeeeSb33XffIeevFJgzMzNs3Ljxd9LWDjro4JWNqakpBgYGXupmKGQyGUzTpLu7e9nx7u5udu3adcj51157Lddcc83vqnkddNDBHxBe7vIROjKygw46eHHwXOXjS0K6X6hN5aWXXkq9XqfVatFoNDAMg3q9TrvdxjRNDMMAljQSDocDn8+Hrut4PB6lpWi323i9XpxOJ8PDw3R1deFyuXC5XJTLZbLZLM1mk3K5jGmaCCGQzgFCiEPuK/+n6zqapiGEUMc1TUPTNDweD06nk2AwiMfjIRqNEggE8Hg8eDweDMOg1WqpezmdTvx+P263m66uLjweDw6HA03TKBQK1Go1CoUCxWJR9YXT6cTr9eJwOHC73ao9AIZhYJomlUqFRqNBo9Gg2Wzidrvxer1YloVhGDQaDbLZrDofUH1l7wMAj8eD1+slHA7T09NDNBplw4YNBAIBenp61DPruk6r1aLdblMul9UYNJtNLMtSn3a7vWysZV82m00Mw6BUKlGtVqlUKhQKBVqtFpVKRfWZw+EgEongcrlIpVL4fD6i0Sher5dQKEQgEMDtduPz+ahUKmQyGarVqpqblmWpcQRoNBqqna1Wi2azSb1eV/NM/jQMg3K5rMbQsiwcDge6ruNyudS4ybHQNI1gMEh/fz+RSITVq1ereWpZFvPz81QqFfL5POVyWV3LPlbtdpt2u02pVKLdblOpVDAMQ4252+3G5XItm5tut3vZ8zkcDjVXTdNU81m22e/3L+szed9Wq0WxWMSyLHU/n8+Hw+FQY1Wr1ajX66pPHA6HmgtutxvLslRfynXi8Xhwu92q7bqu43A4cDgcai4FAgF1DKBarar2NBqNZevN7/fjcrkIBAK4XC7C4TCGYfCv//qvhEKhZyO2fm/x0Y9+lL/8y79UfxeLRYaGhtiyZQvd3d0kEgl8Ph9Op1Otu2azSSgUIhQKKRngdDrx+XxqzTscDvbs2UMikeCEE05gYGCAcrlMoVAgFotRLpfZv38/brcbp9PJ5OQkpVKJ3t5e3G431WpVrQ3TNNE0jZ6eHubn5ykWiwwMDOByudi7dy/VapX+/n4CgQDZbJaenh5gSb4cccQRBAIBFhcXGRgYIJlMsm/fPnXtXbt2sbCwgGmabNiwgU2bNrFu3Tp8Ph933XUXDz74IKFQiFKphKZpxONx5ufnsSyL4447jtNOO41YLMbExATFYpFms8kjjzxCPp8nHA6r+R0IBKjX60pOV6tVHA4Hs7OzlMtlYEkOHnPMMczOzlIqlRgYGFBr0eVy0Wq1GBoaYv369dTrdUKhEOFwmFqtRiwWw7IsXC4XsPQybzQazM/P02w2SSaTlEolQqEQfr9frcNisajGcXJyEiEELpeLRqOB2+2mXq9TKpVwu93s3r2byclJtR6OOOIITjzxRILBIJqm4ff7qVarVKtVotEofr+fSqXC1NQU1WpVrclwOIzP56Ner5PJZMhkMjQaDfL5PNVqlaGhISU/TNOkVqvhdC5tN0qlEouLi3g8HlwuF6VSCUDJgFKppOaqx+Oht7eXo48+mmOPPZbh4WEKhQKTk5PMzMzQarVwOp2Ew2EymQyWZdHV1UUoFKLdbrN3717cbjfBYFD9v16vk8/n8fl8dHV1Ua/XqVaraJpGIBBACEGpVKLZbOJ0OlU/FItF1q1bRyQSYWFhgfHxcQqFAplMhlWrVuH3+1m7di09PT08/PDDOJ1OPB4PtVqNSCSCpmm0Wi2i0Si1Wo39+/djWRaNRgOfz8eBAwcoFApEo1FSqRRdXV0UCgV8Ph9zc3PMzMwQi8UIBAIcccQR6LpOOp3G5/MxOjqKw+Fg3759OJ1O8vk8PT09DA8PU61WgSUZPzc3x549e6jX67jdbqLRKBs3bqTdbpPJZNi4caN67y8uLvJf//VfL3v5CE8vI4NbfBg9YZrxJMKXAocfjCyU09DM4A7VMUMaZsPC0zBoObsQnm2w2AajBi4H7N0J3gFonERq1wA+UcakgOmNkUmVMHp3wpgBrgBMHYDFCsytRi96sZwV8Bn4SiaGZRJEI0kPeeZpUiJBPz24mHTsZS5SQi8MYboDoGVJ1XuIABoCD0cQJ0CVRZz04ydFmn1YGIBJkd2UWSBCnRNpcEQwzTp/GV8b7qroPNjuJkQ3C7hZIEA3MfaxgMeR5/VmnDNIEsPDBAcpYtJiI7+gxD2UaTnC6GaRXgT9BIAyJm6yBKhSxcJBiRni2gIFzUPAcnI6PewH9tBkMwP4adPAQQ0XIcqsZ5p1+h4aCZNQH4ScUAeiLhAaOKOglWFql4dGJsUcTlo0SaBRJkMIL/5gG9+GOmYGinUI9UOzCpN1EH5wtaAx7cDdjFNHo4TATZDdFNgey+NwhImX3BzXMjnR3SDYX0fbAv5VUJ2ByixEo+DvhmoTJn8FtcUQblcDt2gT9oCvD2p9kPVBpgSNLGTnvaSnVuO0jiRGjRRNTAQ18jhpoVGiiMEiTbzoQJKdmFT84G7U8fjzVDQD0XYTFAUCJvQZPRzlrHLctgLDx0B+BqZ2w8xjSVrWFpw0COMnTZQmTpL0kURgkON+qlTws5oARTJYCKrUuddfQNO8HFNNMUGDqb4qGBrRQoBNLYFFlse9Jobuoq8WRcdHiklWs5afBYeZ27oAOycgVwBPBr26igH8nM4aPPRwB48wi5O1uFlNHYjQRmMfLYJE2cICTzLJI7qbRncDunwwvRePvg+DXlalR+ilm4d6i9SO3oFnYR5t1oketai518HYCUsMd0cOcj68mVF6Wg5muvbRPtIJpTyMdsGGGFR3g1YFRxzmFtH2PIGo6+B2QdSEDSdDeQCy83B0BEoxeDIPt37tOcvHl4R0P1esFJilUonBwUFqtRq1Wo1Wq6VIgiR08BuyLYmn3+9XZFQIQavVUueZpqnIVLvdxuFwUKlU1Aa1XC4vI86SPNmJoiT59nMkGbF/V9d1tQmT5Mnn86kNjaZpivhJItdsNhXpBBQRkRtaeX25cXa5XIr8OJ1OdU0hBJZlqb5xOp2KkLndbjweD6ZpKtLncrmWPa/cvNuf234tSeIkqdR1Xd1DEh75PblZbzQaVKvVQ0i3XcFhP76StEoiancTk2Pu9XoJBoP4/X78fj9erxev14vL5VL9LjfUmqZRq9Vot9s0Gg1FPqWCQhJuwzAU0ZX9KZ9VfuxtkYRR/rQ/l3wGqejx+Xx4vV41tyTptD+jfR7JZ5XkXv4UQqjznU4nTqdzmTJBKlEsy1IKDbkW7PPX5XKpNSPJhsfjUd8DcDqdGIax7BryOvY+kfeV58l5af+/bJ/T6Vw2P1e2xeVy4ff7l/WpXPdyHsqPnAdS4eLxeIhEIur83zf3wmQyicPhYGFhYdnxhYUFRUbtkGOyEqOjo3R3dytlh9frpdlsKqWDEIJKpaLOtxO5SCRCsVikt7eXWCymyJ+UL16vl927d3Pw4EG1doQQjI2N0d3drcY4n8+rdSMVmP39/cTjcUqlErOzs4TDYQKBADMzM3R1dSk5HovFlq2vQCDA7Owsu3fvpt1uEwwGMQyDjRs3ctRRRzE/P6/IV19fH+12mwMHDlCv19E0jaGhIVKpFJlMhkAgwKte9SpOP/10ms0muVyOvXv3srCwgNvtplQqkUwmicfjmKZJX18fLpeLbDaL1+tV/QWoeZTL5di6dStbt26lVqtRrVbRdX2ZIhMgGAySz+dpt9skk0kCgQCRSITBwUEl63t7e3G5XDzxxBP09/er8ZXkNZFI0Gw2qVar6v0lFYepVIpQKES1WlVKabl+5Trt7+9nbGyMzZs3s379evW+KxaLtNttQqEQPp9PycG+vj6azSbhcBiPx8PU1BQHDhxgfn6eqakppYzw+XyEQiFM0yQYDBIKhajX6zidTqrVKqVSiVarRTAYJBKJqLHx+/309fWRTCZ5+OGHMQyDUCiEZVmMjIwwMjLC0NCQUoKEQiEikQiwJDPkPPN4PEoJq+u6el/J67lcLrZv345pmoTDYU488UQWFxfZsWOHklvz8/MMDg5SKBRoNpuKhGqaRiaTUe/IUChEd3c3Pp+P3t5eurq6iMfjSjbG43Hcbjc7d+7E5/OpNScVQMlkUr3/KpUKPT09Stk/PT3N0NAQXV1d7Nq1i3A4TCKRIB6PU6/XmZubY9WqVYTDYaW4HR4ept1uMzc3RyQSUfNT/pRKpKGhIbZv345lWSQSCcLhMNFolN7eXqUYW1hYoFgsAi9/+QhPLyMro1ugOwztKLSnwduClgtcJRzhJpoQWBUHaBptfAjXq6DSC8UauCLQKkLEAH8Mqg1qnnl8DSeLMR/to73gexLSj8Fs3xJLxID4ZvTpPjymoOECb7VAl9UgTYsWWaq0aNKPmzh5R4msZ4Z6VxiRbOHevQejPkrbZ6DTwkuMVTTppkEDPxkCjDPHFHuJ0qJMkCoGp7CBATaTZRIvceYqM/Q17qStV9lrBTlIFDchAgyzhi58zOLRMrzaNPgjNFpkyeFlDx4WaKHRYJoavSSJmHE8GCQZwIWGm7vxEmCSPh7BjwBGqaI79mOaLU5iNVvxkkMjiEEUgYWPGHlCNAGDIG0KVoBWxkOy1SA4XCYag4F+MMJL3d7bAy5vk8d/XqHfjOJ1Z8FtUW8JnM0giVqLZrlOtaJBQ2AKyMw6qFb8pGIVQl5BxalRbyZpMYIHDy48FHgCd6nNEWacMa3K5niJ9cMm+lFQTUGxCG0dQj3gC0DTDaaAvg3Q6i8Trmu4DziYTkfYX3AyvdvNDtNNtqnREn5arjhdlp+jqJGgTAg3Neo4aVAFSmi0sAgSIEKcGhCgRqjmYz0ZempNHtIcNOIF4g0Q5SjDtBgNVhkchnACijkIOiGiaYALC508Gi3yeKnRoEEOPzp5evACTjws4sNPiQDzbKcZNBkrh3gDm7mFOnOlnThrgmJKMJOfZ6A1iOUt0Naa5GsNfGR5zO9gj2YiGk0ciybeRgiX3k0x7CNR6+VIkWADJWqE8aAxTBw3bvZzLwv4MLUwMSFIE2I3DYbxs2h1sZ8GQlRguAejPYe/NEfbYdBn9nNSOsU9ewVWnxc93sabEDSrc5i75qFvFfgMqGuEjCA9DJOptGm35sEfgXoAngqC6xjwA/oMhBcQQ724nhpHE05ayfUQ8YFvDNoDQBm6kzC+JH+eq3x8SUj3C7WpTKfTigRJq5phGIro2j8rN+uWZSnLqCTqhUJBEU5d19XLUFpU7ERGkgR5bUlEVxIW+SK3b7rk31ITHg6H1QZTkgd5T7l5EEJgGAaZTEYREbvV2OFwqBewvY2SqFqWpSyvknzJzawkqJLcAKof7ETH4XAQCoVwOp1K2dFoNGi1WpimSaPRUH0irSzBYJBGo0EgEGBgYIBgMKgsppK4WpZFrVZTJEuOuWy7JL3SittsNhU5tpM9+5h4PB5isRh+v59YLIbP51NEtlKpUK1W1Sax0WhQLpeVxaPVaikLvLyPVL5IJYPE4UiwJILSI0AqF+R5cgzs58k5LsmmhNPpVGNjV1jYFR72j/yOVDbZx1AqC+zzw34vOTeld4W0EktLsSRX9rkj+wCWvAHsngayP+T8gSUvC6kIkIoYTdOUIkxe165YsVvt7Z4bcj3JNS/nobyuXJdygx8IBEgmk8q7xB6y8vsEt9vN1q1bueOOO1TMomVZ3HHHHbz3ve991tcpFovk83m1piSJ0TRNkTU5L6rVKsFgUCn+2u026XSaYrFIpVKh1WqRSqWU50S9XiedTitLoFQaAszPzytZIQm3ruvU63UmJyfp7+9X8kt6HXk8HoLBIPv27SOZTGIYBmvWrGFwcJCpqSkqlQqmaZJOp1X7W62WUp5IomkYBvl8nkqlwo4dO9i/fz+vfvWrGRkZIZ1O4/V6GRkZIRaL0dXVhWVZPProozz88MNMTU0RiURYu3Ytg4ODqn1dXV1qDa5du1bJvlqtRqVSYXR0lHg8zuzsLFu2bGFwcFApVOU7asOGDTgcDjKZDLOzs8qSLL29/H6/IkXBYFBZu6enp+nr62Pjxo0YhoHf71cW5YWFBXRdp7+/XymLY7GY8jqSSmlJ1PL5PIlEAsuy6OnpYc2aNQwPDxMMBpUCWsrkUChENBrFsiyq1SrtdlspuQ4ePMiBAweo1WpYlkU0GqVUKql1KNsXCoXo6+tT/STfyy6XSxHyRqOB3+9ncHCQNWvWMDU1RSwWIxwO0263mZ6eJpvNcvDgQY466iglIyVhLxaLLCwsUCqVSCQS1Ot1ReTlXPV4PLRaLTUfNU1TIWvSK8DtdlOpVJS8k0rmUCiEruvMzs4yNDRELBZTiqd4PM7IyAiRSIRIJMLIyAiwFD4nvTiq1aoaJ7/fr6zeUgkoPeUcDoci0263m0ajQSaT4YILLlBjEAgEqFQqJBIJZbVOp9NUKhUWFxfJZDKEQiGlZO7q6kLTNGZmZtQ7LhgMKo+0cDjM8PCwktf9/f3KO8M0zUO8zX5f8ELJRwAKQGESHDNAHkI6WC1cWp5k1cQlYNbpxjDiWNUwOJOQ9cKiAWYbvGmIzIJIQ7BB9ehuqvs1iLvBU4dSBlweSITAI8A5ALsD+CvzuHDga4Tw0aBCizY6bW+dqnYQf72ftuailNChywXCAi2IMbKIsX8HerkfHwansoYjSDHDE9QxEHjZS5oqGhGqpGjRJkKNNili9NGDSY4cOhVjPU9pi9zhD7C2fhavtgZYZIEoGmNUiIs+uohhYfAQcCcVtmt1PCLKMClChDiCCl3UKRHHAQSZIIZFjhF0Ygwwj5sKRzBK1ojjZI6jgSEWCWHST5wci7Qw2EgXToKkyTFLgCp+osJPTzGOWDyAf6hNPgnhAAT84IqCMGCmu0Cvq8CmELRd4HNAY3qWPBoLDdDzDvoCJq2CoF3zErPceNrgiUGtrlGvhomTok6ZcZq06KLLrNNDkTXhIsMbLAIboNUNWEuEu92CoAkxP1huqNTAKGqYj8dwFLsYtxI8QJKFlptJh0UmVQfvJJgajnadNi32YlKlxQCCGjmqVDFxomPhRBDATZg2Der04WeUCmsdFSbMFCE8jKQztAkzjUEWNwfrbY5sFHC3wNGAaBEaokmR3Szgp0QvCQLUqVHBRNDAwR68jCHoRWcPfYSBAFk0RKVBol7CxQwbCHCw4iJPjbThoeb00N/KoxdKPEGSNk50ZkEM4dBj/JHhJLPTh0WCbkYYn4twNGGOJYqLSabx42WAEi72OauUXQtYLR0zEGDBVQUiGLkIG4WD9VhMtp20XA7QKmhTBqFCmDwt8izwBuN0mDa4fXgeBhvUqxUIJqDhhPQcmGnwLJKJT9AuHINohqEYgIQPHulGK2mII2eguw5GHbq94O2iHbIgHIGBE6GmQdEF1STMlWD1IAQM4D+es/x6SUj3CyU05UbMNE2azaYik/IlAr+x3MmXvZ28SHIiLQX2l7WmaYe4Pct22i2DdsIlX9R2V1hJHOwESbbLrgwIBAJqwyOt0vIj7ylfvnZXZXldSc7sZE8Sfdk3kuDK78ifdoupJPjy2WQ/Suu53BDK79qtvfJeckOfzWZpNBp4vV5arZYiPA6HQ1leZJvtygpAKQxkn8n2S8uDJON28ie/J/vC5/MpC7e08tjdwSVplx4O9o+0EJXLZfVTkjT7GNt/2vvNboGV5E+Ou/2n3evBbqGV81bOI/mxj9vhCLccR3lfOR/sXheHUxTY14r9GSQ5lh85FoeD3HTLe9rJv/z/yrGWBNquoJL3WDlPV64zOZflGpXfsbvgSyWb3OTHYjG8Xi+RSOT3lnQD/OVf/iWXX345xx57LMcffzxf+MIXqFarXHnllc/6GoFAQFnXpDdJsVhUli+fz4fP51MKKKlckvPQ7/eTSCQol8vKtVgmr5yfn1cKrWw2qwhLJBJRYyAVS81mU1l8FxcXmZ+fp7u7G7/fryxy+XxetVcShMnJSZLJJF1dXYpUSu+PSqWi5kKtVuPRRx9F13XWrFnDpk2beOqpp7j//vtptVr09/ezevVqWq0WXV1dylV4fHycPXv2sHPnTqV08Hg81Ot1IpEIsVhsmaLK4/EwMTGB2+0mEAhQLBbJZrP09fUpIiSJzuDgIG63m3w+rxS7breb2dlZtm/fTjwep1Ao4Pf7WbNmDbVajUAggN/vV3O7t7eXSCRCJpMhl8sBS4qT4eFhpqamAJQyVlqpJdEVQjAzM6NkmWEYeDwe+vv76e/vp7u7m97eXhKJBIlEgkajgcvlIpfLsW/fPjRNY926dcozoFQqIYRgcnKS/fv3q9Ad6ZYeDofVvZxOp1LwFIvFZQo8XdfVXLIrx/v6+mi1WjzyyCNKqSpDrnRdJxqNkkgkMAxDhTi5XC6SySSFQoHFxUWlbPF6vUrh6nK5qNfrwJJSULqux2IxYrEYmqbR1dWFYRg88MADFAoF+vr6SKVSxONxFWoxODjIwMAAgUBAySPpRXXkkUeqd6EMqZAu/QC9vb3KctxqtVhcXCQajRKLxQiFQsoyb1kW4XCYrq4uWq0WmUyGer3OSSedxEMPPaSUisFgkHg8rtZqq9WiVCrx+OOPs2XLFpxOJ4uLi0xOTrKwsMDs7Kwa60ajoUK/pIW+p6eHcDiMZVmkUinVX0NDQy+YPHuh8ULIRwCaSejvA70BlWGoFKB8gLbfTwYDfB4MnxOqOji7oWTCfBmqThA6JP0Q7oOFMvhKEHctWc1DGmizkGiBvw+yJSjnoTaIY6dJ021RjzrwZE3Mlk6VJqCDywvONA0xj2Z2o+f9OMsRett+yqEcuaN9IEzEQYN5yuytHGS1SJOiRJN+IlRx4+YxeohSZh01nsLPLHVu50m8WJxEi83keAon3/OGcHkKvL56gKNpspPddOHAx36KOJmgjx3UuI0KVRoMU8GPThcHSOKgFy9VgoxjMUAeHy0e0AYpiiC9aJQp0mIeNwGSJPFykC7PHsBgqDmChzDTQAaNDH5SGMxQ5gkyJNEpUMJPkjWLa6kf2EVgtYnfB1oYzDj0uSAyDdkDkDNAeCCchJERmAoIqIDwGphuqFShqBuE+vL0jQpEE2Zn3DQJUGeeGhqCGMcTwI9Gt1alt9cicRwkjoaGD5xtyP4S9t3vRSs5WDdcIxWEzJyD0nwKUR9iEov7sZjBoguTPjOIL6tjmGEaVhOTBlEsIvgRBCkyh5NF0Cw86OiY1EQUNx4sDAxi6HqF/oEDtPQW90wGyGs6q8w4AYJ4KaDjI+rWSIbADC8pHlwmuPxlkvUWBXOYBQR5DCo4cWGQQBAghpMeSlgIDJqU0ZknhJM0MaAbCz8bqOInwZ3kKJfyhM0+EhRJIdDwUQZ0BonX+1mNn2Esigg0vBxBkFM4Ag8WJk3KxJmjTZY6M74S7S5A68U5s0iyXKDmb1KLLqLpUfymm/X42ZXX2O9vIeINfNE2g1WNtuEhQ5a6MDmvfiTVX3l53G/QiBbQtCCOhTimq4wZduCKzeGMTlIc19AyW6HsBCMN1QlEexH2zwFRSHRBxoRoBdZHwLMBXGug0AuzYciZ0EgtxSvse36y6yVzL38hhKY97lluyA+3aZebM3m+JCXAshhRSQDtVjqp7bVbhe0uzSuvJUmL3a0bfkOy7VZO6d4cDAYJh8OKEEqrkLTiw2+sp5KcSVd5uyuzVAbIe8gNo90bQG505DPJ81cSG2m1kh4GksDYY2wBRVrtfSFJVj6fp9Fo4PF4aDQaJJNJdF1XRMCuCJEETZIw6TkgrfmS/D6dNVTG7Mv4Y9m3kuTruq5Ie7VaVTGsMuZQ9o+0cEu3Sjs5lM9rV8Cs9KSQlhP5fHKcZYyi3TVd9mckElEutisJ5UoXbTmH5P3tIQj2MZT9I+eOHB+7N4Y9FMCuNLBfVxKOZrOpxtVuRZLkTIZ4yLbIPrUrouwWb2AZmZdjJ8+X1lWpBJHH5eZWWtSkh4XcBMvxd7lcKmY0EAgoDws5J+Sm//cVb37zm0mn03z84x9nfn6eLVu2cPPNNx+SB+OZ0NXVhcPhIJ/PK2IircqwFKaTy+VUDgHZt9KFOJPJ0NPTw9DQkLKW2eeXVFRKD5d6vU40GlWxorlcTrlNP/nkk4r4aZqmXNZTqRRr165l+/btZDIZBgYGmJqawuv1cvDgQbq7uzn66KOpVCoqBn3Hjh00m00CgQC1Wo1Vq1aRy+XYuXOnsgbPz8+rWPQjjjiCarVKOBzG6XRSLBaVtXnv3r3UajXOPvtsVq1axa5du/B6vZimqUiNbPPk5CTFYlEpF6Q8lvPU5/MpjympnJicnMQwDHK5nPJmkkqD6elpDMOgt7cXWPL0Ghsbo16vK/firVu3cuedd6rnEUKQSqWIxWIcPHiQxcVF9uzZQ61WIxqNKsvrjh07aLVa+Hw+5VGWSqWIRqNomkYkEiGZTBKLxTBNE4/Hw969e7n99ttpNBpEIhGmp6ep1+s0m00mJiZot9ssLCwwPT2tyGGxWMTr9bJ69WqlmJTWdakUl+0VQjA7O4tlWXg8Hubn5zFNk9HRUTZu3Mi+ffvo6+tjamoKt9tNPB5neHiY3t5etm7dSjgcZm5uTlnwZV4CaRWORCIkEgkGBgYU8ZSx1E6nU1m5o9EohmEs835KJBIcddRRzMzMKC+8VCrFhg0bME1TyZXp6Wm2b9+uYq137tzJ4OCg8haQc0DXdeLxOIZhMDw8TCgUIp/PK2Wv9ICwLItkMqni9R0OB6VSCa/XS6FQ4Fe/+hV//Md/TG9vL9PT0zz44IMqp4Ku68p63263FbGuVCrccccdKkxEhoq43W6GhoZUDKIk2vKdKo0Os7Oz1Ov1ZbL69w0vhHwEwN0FJcdSfGczC80l8oPHSRs/pPuXYrBDhSXzZlqArw3VEFrVixAZmBvAMe3G9EyDqw3OEnQBjibUK1D3QaOExjRiPozZ6MUccsNglNq+HM6ZCCYDCG07WCYIN5ZPA1cMR7mBs53CZawlUNlOruwEzQPhKRoDXh7cfZAjCzm2EqOCixAVAvSwnSIGDTQMxljkVWykTIT72EWGIdahMcUOdGsNl+TiHM+TVNlDGA0HVYo0mGMD+4hzCyUizjJXGR5GRZjdNPAwhUmSOQawCNJFHRdR7tYtHojVWJ/Ns4UIUzhwYdJinCY6QfK0XA2KbpNgy0ITBjv1AruTbrK5LFsND5DFR5kKIfaj0cBLr9ULM3MsFnKMHQV1B0zXYXgTbG3CnXt05nIWSS8IJyRfDdEATM7AYhT27F3Sm0TWNBkdhkgAdmyHVtOFjxbjuCjhYJQwY7jQcRKJWiRPhMgZUE9CwwUTj8Ltt8cpT60lRY2pJ2ao46DBag5Soa3tYIEGZRHmGIKsIc4CFUJtPxarKVOmQBM/GXqpU6WNSYWU2yAWNxENmC15MYUHD04WqCC0AmsHFtl4Zou9P/fQZ62hRRo3LhKYDDuz9IRn2XpUi9AozFWgOg21OjQjgqDWolFuMkuBFH6SOBhA4KTKIiF8hPFQxkCnSRgnTvqJMNsyAT+CLizm6aHONmIMtKPM4mUnBt30ciKDuDCZxY0HP4IpfsFT7KKA5vEzL3ZybGuAKCGqNOnHiY8KvegYzRgLFZO2MYynHcJNHkfVpGW2aVtpHiJC2lmhaSYJTCepJAao9eTJVRfwOevs15vcOb+dPzVP5AOVo/lFBZ5avA94kig9zBFgTzVEMb6BtlFAN5IkzASN8Qo13y2EB/dSjHZhGR700l4sbwsG1yzJhZkIGL1QFEvrftGEbANtJwhtDqg9L9n1kpHuF0JoypfbStItXyTSItdut5UbJbDMpVYSTEmW7NY5e5ysnXTL7610zbVbDSXJsJNuO2mwu775fD6VwEW6VMs2yQ3tSmu9dOe0WzHld6VGXH7sFl3L+k2ctp1w292mZdtlnwDKcmm3yNot0HbLtCTfMn7P5/OpBGNer1dZx+2u+fIjSbKMm7MTX9lmewy73Woq+0fG7Xq93mWWdDuxlknJ7GMoXUbtfSXHXPbH4T52QinHVbpMy82a0+lUG1g5RjKuXCZ28/v9h5BuOR72j31OSXJsVzLJ+bLyYx9XO+wE3B4OYR9baa2097OcR/K5Zdy4HB97iIL8rpzX9jklSZokypqmKddM+E2og339SOueTPgnx0l6UUjvBrm+5EcSbpfLpeTB7yve+973Pnd3SRtkcis5RyORCLquUy6XqVQqiiBL12P739INOhAI0Nvbi67rKlSkXC6r9ZnP51UYSbVaVetL0zTq9TpCCBW76vP5iEQiGIahZIh0F5eurz6fj2QyqSyoxWKRdDqtrL61Wg232002m1Xz1P4d6cK7evVqAoEA69atI5PJKFd5WeKj2WwyNzeHz+fjyCOPxOfz8b3vfY9cLse6deuApfk0ODjIwYMHOXjwoJKHIyMjJBIJgsEgzWaTaDQKoJIe+nw+FhcXlWdBoVBgdHQUXdcZGRkhmUxy4MABFeoyPj5Od3c3uVwOy7Lwer0q1GXDhg0sLCxw8OBB4vE40WiUcrmMz+dT4yjDApLJJKFQiNnZWRYWFhBCKM8o+E2iMr/fTyqVwul0kk6nlYLh+9//PtlsVskymWxQxrGnUimq1SrxeBy/30+5XFYKkt7eXrXGhBAUi8VlSnCpeJSeE7quk0ql6O7uZu3atQQCAWU57unpYWBggHg8rghpd3c3hUKBhYUFqtWqSlYpE/ZJi/XQ0JCSs+l0mlKpxKpVq1Rb/H6/UmgDLC4uLssF0dvby8TEhPJ8aDabJBIJ5ubmyOVy5PN58vm8Skwn49k3bdqk3ilut1uFL1QqFXK5HOFwGF3XlXeDw+EgnU6TzWaVskGGibVaLZUIrVKpsH37dkZHRxkYGCAajZLNZlm1ahULCws8+eSTaq6uX79ehQREo1GEEAQCAUKhEHNzc4TDYdavX084HCYUClGr1cjlcoyPjwMoRbW0pmez2ecte34X+J/KRwByGXDVIdQG3QHOBHhaUC5BRQefBr4w1Bvo+0pYrTaMuiHdgEAW3PvRZ5M4W72YwgHBIGQbOO6qYCV8iJ5umM+DN4boCeKshnAZTerFMlpVg0adgCZIWknmcVK1fOiVMD7LoB50YiZ1aiLNgbqGs1jGsTeIafrAlQQjSEPTmCXCEGl6+SVhNAr0EsTFLFmewE8XdbawSBOdA/jw0E2dEuvRObLp5gh00kCadZSAEmn6GKJChNu1Ij7NwxuMJF5afFdfoGCZDHIk84SJAUch2EeZu5hnly4IVlycToQeKhzETxWNKFkEoyxobqoIzIpGWsxTxU1dq4Nl4RQjNHAwQoskQQ6g0cRNjRLjzNHdqJHLgOgCbwxqJaj6YP0psLDX4uADkBiB6GooDYPfBaUZKEeWvI3dfZBIQLABs1OwMOcBK0CJOgXChAA3JTIYBN0VUhsNnBtgvgWLi9Aowh1f87Fv/xpCGAySIeKt0MZBrlHBS46UgCojdOEkhaDKBFn2YTFGF/0MUqBFiAphimTQCSHwL9mEDXA2IWEFKOsmum+cZE+dbp/B2gHwC/BVBd2agSa6GMNL3PkUid4yqSOh+2woGLD4OFTnoJzRMeIWni6LUrVC1uphAy5GSNNAp04f41jALMfiR8eFoI4fnUV0BgyLMVrkmKFNA0jjQmOELopkeJw6B4nSQwuIMcU8YzxMgSYHyNPUS7RWuXlSH8f3VJ0NbEKniEGbGDG2EaJl9fDjXI39zhxuwhTRgQLxhh8TBw840tSSWbTGPrR2HxTB9A9zwOnF2crQTPZxb7DOMcUp1uPhFI7gaLZS6LmNVa/ey8JeHw/v8HFgLkRJ20DOXI8QUYoxC73XTTIiqAUEzZCOY87A8qcgcBza/giOp0JYzjpWMgvFcVgET9mLpfloD5ngCELuuYuclzSR2gshNO0kRW7C7H/Lc+wWbHl8ZYIquSmXZKBWqynia49XlbCTwZUxtna3XklcJWmQL3xJgOxZnSXhDAaDyjpqt5rKtslrSev1Sou2JCMym7M9I7oktpK82Ame1+tVrpR27wD5jPV6XbkI1mo1lfncrmBY6V680vpuT1gnrcXyvrI/peJAthEOtdjax0Eel/HH0gorhKBWW9JIycy65XJZbd4lybPPmZWkVN7broyxW7FDodAy11u5ibNnj5futrKv5fVkH8n7S7d5e7gEoFxa5TyxK31kH69UOslxk5Yae6iCbL98NkmgdV1X58u5IZVWdtdwGZstx9X+kXPSvrYkyZIeA/CbXA0yvEJapuE3mchlzK9sr8xzIOe57Ge5off7/SrGWK5v+TFNU3k5yDCFVzKk94cQgmAwiBCCiYkJlUFZ13VKpZKymIXDYVqtFtu3b1cu1rBUolESpVAoxMDAAMVikZmZGZXRW2bXl9ZEIYTy4JDWXdkmGWoh3Wqj0SirVq1SmazlepJKxUgkQiqVot1uEwgESKVSyosim82Sy+Vwu90qKZTb7Wbjxo2Ew2Gq1Sr33nsvi4uLyq04nU4ry+369evxeDx861vfYt++fUqObtq0id7eXmUVr9frBINBZX22LItHHnmEmZkZhoeHGRkZoVqt4vf7yeVyyootvUCkd4GUi5s2bSKRSDA7O0s+nycejwMo+QpLidmke7z8XWamlsq9VCrFpk2blCtyqVQik8kwODjI+Pi4sgBLWeR0OhV5k15EHo+HRx99lAMHDijljNPpJJVKMTMzw8zMDN3d3aq6Q6VSYXJyEl3XCQQCDA4OKkWbfPfI2PSZmRkqlYryXOrr68M0TXp6ekgmkwCqz6W3l5Srg4ODACpEZHp6Wr2LZTURmSBN13UqlQqapjE1NaX6PhgMkkwmOXjwoIqLbjQa6vjU1JRKwCczmkurtIyntyyLqakpTjrpJNLpNNu3b1fyp9VqKbd36ekjXcdlIlYZAhMIBGg2mywsLJDJZNQakZ4Q0hPB4/GQz+cZHBxkcHBQeV7J9aNpGvl8nqGhIXp6epienmZ+fp5arcZjjz2mPEkOHDiglBNScSEVnD6fD0CFP8icGDJ0rFQqqffmKxpBB7h8gAu0KARS0CxBS0AU0Geh5gARRqtF0cwwotICfTsiXoeoCysJzeYM2kQZkdNxlEMcWeinPV9iz/wsWimC8DRouYoIRwnT1YKWRigrcIgIPYQZQ5B3ualGgLyTltOBuwzUCjTiLdzNKMcYq7AKLh7VSrQ8IbS9bhx1N2ASZjdJxyyG6SPGLMewBjcpGjioUCDLL/EQJ8ooQcK48LPRUSUSvJOqVeG+SjcHhQ54SHEULiwmmKZXePkjESBIkRv1WXb653E2WqSMbrYQZR1hZjC4jSwzWp2kEeRko4/jSSKYwMsM+8kyhsUwOrVAGX+vRe5AgGn8GLhpWiEoFfGZHhxUcFLHCWxytUiYLmYtL3nKxJs6Igs1N2hO0L2Qa0IzB/1HQc4DrSFwDcBiC+JBcPcsJZbvOwUqRRANKE9B5kGdgUI/E8Q5gAcnDrqZx+t4HHekykC0QHQY9BBU2uDxwM5faDx6bw8Oq0mKAk49QzLZYrbsZaaRoZs2VcKkcVCizjhZLCz8DJFgNV4quFhEpkoL4SHEKqb1fVRSJk4vWB7oE1nMLuhZDckuEBFot5c+oVNaiJ89ji8/iNeVYdBZgrwfV6CGbxRmnoSGDo0IlM0IZqWGMdgkPNdEq1kUqaJTZ4oWWfqxCDFCiRQVDv4617wfjTk8+AjRQw/3s0ieBQbxsEiWGEVMejDIk2CSAr0sotFy3M1678MsVtfhdLhpRQ2wmrhKdaJ0o2NQpsEsBinmSQINnGiYmDGLRrFJTzNAmyYlFmiTwTIFvvkIOAwaoRwUUlCJYeoBKMTRGwNUGeQpovQTJUAbNzH08gkU5n7F0JoyPc4a0w872WMMcic1phyP0VqroUU95CZBq2TBdNIOboX0Groe9tI9HyVh+imgsX8+T9khcFcsfKJJsccFPSYUC89L5Lwsspc/E+RmXpKZlaXCni4uFlAbfHsJIplsTW4ApVVaJoKxX1eSCbuleaWFz+46KzeejUZDxZRLy12z2VSWWWllkK6LdrdzexI1eS3p0mfP4G7fFBQKhWVlv6SmfaWFVG6MpFVKuhfbyaJ8EVcqFSqVinLzs7uV2y3Xdou43Y1bxmVLciY3AXIsZYIZO+m2j6XdCi7HQcaJy2Rvsj3SIipjT6WlQ7oX2on8ynhpCTvpNk1TXV9a76TLKaCUKlKRIImnvXySJA32dkqFjKZpynVajpmMbVx5vuxvu9uv7O+V2fTt4RZ2Ei0VMbJ/7YnLViYQlP1iV2pIci7vaU8OJD+SQEkvAPlMMhN2KBRSxABQBE72od2qL+MmpQJCZlru6uoiGAwu21QCyxQDsrST7ONXMqTiTpZQk9mjJQHP5XIq8ZzsZ1mySSYpk7G6dm8EIQSDg4NUq1Wmp6eZmZnB7/erTN8ul4t0Oo3b7WZgYIDZ2VmEEMTjcWVBlBY7p9NJV1cXw8PDzM3NqazQUrli956xl0KMx+NqPrndbkVIZRiJXBMHDx5UZEgekyRaWo337t1LPp/HspaqGMgY4pmZGQ4ePKhIWiqVore3V5HI1atXU61WyeVySqFUqVTYuXMnExMTy5RastyT2+1mYmKCrq4u9R1JcqWy0eFwKJJWqVSIRCKcddZZysXfNE0mJydpt9sqPEmOscPhUBm2ZZkxGV4xMDCgsmhL67hs22OPPUZ3dzfT09PLEqtJt2wZY93f36/WazabVaW1qtWqkruyjZJUbtq0ie7ubhYWFpTlOBwOq3fx7OwswWAQgGazqSz6ckz8fj+Li4vK5Xnfvn0UCgUSiQTtdpvBwUHS6TTpdJr9+/cDSzJwZGSEaDRKoVBQMmh2dlZZlKXit1gsqjlimqYKW4hGo8pzYMOGDWzYsIFwOEwymSSXy5HJZFTGbxnCIeeQaZqqf6RCUCqAp6enyeVyOJ1OBgcHlUeBDJ8IhUIkEgm6u7sZHR1V73yfz0c+n8flcrFv3z5uv/12HI6lrPPJZFIlVJM5EmQSQCkbR0ZGVKb6Wq2m8idI2ZDNZpW3ihzDVzx8QbCcsFiEZA20PFp5Hj3YXrJc5y0wM6DXMJ1h0HXQTOgugN6CwgA4Img08RbdWKUoUVxsQjAgBvhBpsru+BTo41DJYq4KYfpi0PBTc6aJ5twYDPCQPkshJsAfx7KqCDOIuxUBK4tmOBmsdXEKw8wxR0aYOBohRMOkROvXCdQ0nB6LZrOFw9xDF0W2MIxOmDoGHly/LhVlkCCDQQ5nMIPVW2di3kNdRBA0aOLBoM0sU6TR8BGkjOAp3BygibtZxzSjJGmzkSq7Mbmbeeo06BZBjifMMVSoksdJjbUEqDNMjjQ6U7jbVSpZFztML+M4ENSYCQkI65RmZ2laFi1CTFChy2GgWxYeNCL4cDra6G6omWCYUDEg4l9ypY50w5kbYTYDjSaIWZjLQNuCahDMJHgboNXB6YJsxvNrpYSfbmKE0ehimoGxOXwbIBQB/zqoDEBaW7rHI3dHyVurCTNJiB5atNDKczhLQzS1OrX+eQJljYFSEZ9IUaKfBS1LTKvjs+rANHEKOBihhoGBE0GWSPggm14t6B6ChUehOQOJHggBDh2sGMzthWAAtD5oiDAxvETNJjljFUJ48C/sJD1pUjfA64V9NZ2CESEhNFqhJsPJJkdOVpgjyH4GgDZ+JtmoVUkIB3l6ceDGjYcncDGLyUY0SrSZwCBPkSpuMghWY1DBwqBChCAPEMJkhjc7J9nYbxGZnWFtdYgM4DuYIdzqRcPAYJYdNAhhcgohDBLspsi8pwq6E1c7QRtBUatRdU6ihQ8g2iHclUHCZhhn0aCph3AQou0MoVGir9rNAKN048CFDz9B5qmwo3oOe+5ZRcx3F16RZtIYYcLdJtc3S7uWhkk/ouwgZ2xAdMXA48NzcJQj949yXmsdZRzkqdEmjLvWYIIGeaqUAjlEqgaeJqQKz0vkvKxJt93qK2F3N5ZuqvaEXXbrm4Qkx9LqJmNtpZu33MTZ3ZoPB7sbryQU9kzK0rVWEjCpXa7X66okmbQCSfdNeX+5IZAkV2Zel7W2Zeyr3V1cxteujDmXRHCle7ndsmq3xMJvanvLn5I02wmZnZTJ43art12jLl0AVybAk9btYrG4zKopn8Med2xvkz3MwO4KD7+Jy5fn2vtDklk5plKhYe8T2W75HbsV365gWPn8kkDL+9nj9FeOkVTurEykZ+9b+xy2E0n789jdy+Xvh/PQkMRbrg2ZmVhaquzE3q4osM8T+zqQ1nG5OZR/S6uVdOmW/S03wdINXPafVMTYk7LJ+GvZBrmu5TqVdajD4fAyL4eVijh7yAnwiifdsi51rVZTZbzkWNRqNZVoMJfLKUKr6zrJZFL1WyaTIRqNEggEFHlzuVzE43FFvKUCQ9Z4lsm0DMNQ7uFS6SLDUyRhlB4OUmkYj8eJxWIUCgWy2Swej4fx8XElgyXhlvH5MzMzFAoF1Q7pmivHWbqmy+zik5OTah1OTk7icDiIx+N4PB4GBwdxOByMjY2pc2XiObvXiMzMnUwmWbVqlapd7vP5GB8fZ9++fSwsLKikZlJpIZWupVKJUqlEPB5ndHRUWYqllTEYDC7zGmk0GsoF/oknnmB8fJzJyUmVVfyYY46hr69P9a+suiHraMv5L4m5HGNpfd+9ezetVot4PK7WjVRSSOIZDofp7u5eFkOtaZpK2mYYhiKbTqdT1TBfs2aNst7Ckjv33Nycum6tVmPPnj3Kk0EqXiYmJiiXy8tikqWHVTqdplwuk0gklLw59thjmZycpFwuMzY2RiKRoK+vj/n5eebn55XslO/lkZERVbZtcHBQZRiXfZBIJJRbdjabVXWxXS4XmzZtUrJSxuOXSiWKxSJCCBYXF1U/SC8wl8ulEtINDg6qkAoZiiFri3s8HlKplAphkNZxuabq9Tr79+9XcfnSsi7fdXIeSuXzwMAA5XKZjRs3snbtWmXFlt4h8Jv3kswGL985v6/Zy19QWCVwaxCvwrAfKk5EKYDpdixlKvaa4K9BtgJGA1xOcOvQEwAjAmkTKhm0VgQPYTwiQD9BUgj68JB0DLBzbQECEWiEIegCnw7NOkavk2bVwGgWmY+kIeaGkhNnxUVvzYWBQdHpZ6Tk5zTLSZIC89TZSJwUMaDAfrIcIM79xGnXHLjI48VHgiwB/PjoYZYABTSqRNDIIhDMUcesRGFPkrSVoJcxvPRwDznGmSVOgxIG+0OLPGw48DRi1HsERGPExrvZUncxxww/9Wk022VGDB9OIEwLQZk8JUKUSeJiFQHKeCjQwtcc40DTxUOOKjN6hki7TdvoJpxuMWa58dAGPBRpU2gYpCgzEpthUOiYCFxdYAkQXnAZS7+3GtAswoYjweqD/bfAxH0wWYRqDSoR2HAarO4H073kwl2vOCiRwocHQQkPBgYOCi1oTII2BolumA9AoQmT26E4248bP+DEwo+BB6dXEGktEGq3CVsW3VEIhSs0Mg4WjZ30DM4xWAMx30+DNn7atAhRx02BGlBlg6tGNAhuLzCtsbgzytyBJlFPk9CYSW0n7NnhIuWANhqzBRfdtJiwhsmSJEWWSBoKc6B7oFqG9LSbMkES+gJuA3wOg1dR5SARKkwy5ssQF1X6QwZzJT9TzSNwE8BDCx9wEgU2oTFHmShtHAxiMM8gbcL0UEEnRoo5QswwzxGMM6q30XvAZRls2beKyayBgwZhenHTokSOedoUEDxJkEEEASw8WhNH3UnccjKnZ8BVoq85TK4G6GXcooKJRkp0EzNDxPFQNlMYjLCKOKsJMsgCBkXy+NlBg++lJilEvST2byNoGZQ0L6WkC/NVDZi2YK8P6gOIdgiyA4QKZc6f3cA2ay1eLKYpUyQHuBhBYFKn6GjRDtUhUISgviQbngde1qTbntRLWmTlC0Nu+O0bOztpsce6SvdUGVcr3V5lXLJM/GInR8AyggUss3xLC6jb7VZafZloS7pV2n9KsiHdfGUpJbmZlJp4aSWXVm3pBiYJqCQ+dhIs3ZllX8mfkvDaSZUkcbKP7BlnW62WSnAl/5bEyB4bLQmqVDTIvpdWfWktb7VaipjKDW273aZer7OwsLCMaK+MO5fnypJpdquS3ODKjZ48x249k88mLSzAMpd72R574jT7PewWXOkWvZLoSQ8Ae8k2+zPZrbV27weplJExpHIey/PkXJBtle2RiXCk8sWuBJDz027Zly7rPp9PJeaR5ZDkHJJ9LvvEnjhPlnmzJ5CTG1vZn1IBJeeAXGtSISVr50qiLOeVnJtSMWAnznKNhUIh/H4/w8PDinTLzaecI/aEgtKjRM6n3+fs5S8EpOt2KBTC4XAQDAZVcjWZQFB6i6xZs4ZIJKII7sDAAIZhMD8/j8vlUuW1HA6H8iiQ5ErGt8pkTdJaPTQ0pDLFy1AUWQqw1WrR19fHyMiIKtsna3TLDNX2cnLlcplAIEA8HieVSimvFUDNWV3X2b17t5o7uVxOkU9JXAAlRyXBcblcpFIp5d68ceNGHn300WWKAOklkU6nSaVSKqdGo9GgVqupCg3SwhgMBonFYqpOuuyrYrGoEneNjo4yOjqKz+ejUCjg8XiU27Qk4bquMzU1haZprF69Wr1TisUi+/fvRwjBUUcdhdfrJZfLUa1WVUZ4TdOYnp5W765cLqeeRSopw+EwXq+XRCKBaZrEYjEVVy5LwgWDQfVejcVirF27Vr0n7KE7c3Nz6rrRaBSHYykpmIytlutNKjBkf0qvKZmNXCZMW1xcZNWqVaoChgxjkMnDZMZ1WFJSb9y4EZfLpeK/5+fnabVaBAIBVXN7cHCQVCqlZGKtVqNcLquycDK3isvlore3l2azSXd3t4qVnpmZQdM0kskk2WxWJc6TewcZ595oNOjt7cXpXMrkLrPL+/1+Nm3axPr16ymXy6rKhvQ+ke8DmQxS0zRVcz2dTpPP56nVakqu+v1+BgYGVFb5YDColCbJZJKBgQGSySQjIyMUi0VVctTn86lxlm2X1m2fz6di1V/xMFvgiYI3CGjgCEGyDa4S6AFoa6Br0K5AYA14I2CNQ02H5hC4DWCe7paLXrrwY7EKwRAmMQocZWrs3tVkcXVmyTqWHQaHeymOfCFEwxgirfvAHYFyDc9CA7/pIYpJiiZho4tNDDGAixwmUVIMUsNHhRZeLAI00CgyQgkfQfLEaZNkO1myVFgAmlSIUMKDnzY7sWjhwDQ3sEODWUeTbqtInhwzkQaOmsDVatOihd5y4zOSGLoLZ7sf/0yYdc05Nuu7edjqoRLyEi7XCBkxHLSo0yKNSQo3fnK4ydNgmDIx3CSYxUuOGhmtgKk3EcRI1roZwiCOkzQVTIoIII7OiK/C6FaB1zApFsGThGIVGgXwmRBwghaAmUfB+CX4TgHnILh/BcU9sH8hhUjWOe74Ck4vZLPgyECk7cCPF40WM0zjJYZBmHxJJy4s2puXMqFHLdAjUDZgqOXAxKJIHIs8Xvc86TA4uosEZ51os2shlCW2IcvaUJExvYjQNGqzaymSYJ4Gc3jROECAKCEiONAp5ntI/3yWUtCiuS8MVgjRbKDVdEqPuchoUaqtCFVMXPjowiDCHPNYjFPDjYM6S04bdRPyNQiZgiY16u4WTgH4LTypGTYVmrjaOt2OOgW3wZwObQzCNFkgAJhsJkk3Hkz8eEkQoY1OgW4CBIhQIEEPJgmcTNHHIA2OpUjUV8F0w3TJS5kkSdqUyDLraGNYBUYFxAkw4Sjzc22a9UaTUwiwqaHxYDOEiwrDVolQK8ARbID6GJClToQZAvgJEAP8tPDhIIaPJDoBBAGi1HCylyyPU6DuqOFq6DiEh278HCEG2JOeZN+e/VgpP2ywYNFAW0gyNDfAhWaC1zBEhRJzZIniwo2XNhbr8NIgwHbdD+4GOE2wfJDf/7xEzsuadMNyIgG/IXr2pEr2GtQrCaK8htxU2C2LdnduST5X3ld+5AZJEj6ZlMR+X0mC7BZCuyuwJAaHc0e2Wz5M01TaaWnllmRvZdvhN2XOpCVLEjtpWZGWU3uMu4Q9jlpadCU5lOTS/ix2C7S9b6XrqiTddiuv7GN77LckyhJ28mfvFzuhlP0sSZzMvmqP/ZVu83aCK9tu95CQ97RbXOVmdeXH3m77T9lm2QfSymf3BJB9ar+fnXTL8bATffv59nhn2W67wsVu8ZbjaXdrlz/tz7NyftqJu/1v+/y3x2vL78t5JK2ccv6t9IyQ8xlQSh2Zj0Bez25dt9eOt6/LlaXkVsbo2+/5hwCZj0FatnVdV+75cpNfq9Xo7+9neHhYVQiQCdcMw1DrslarUSwW6e7uVpmpp6enlSV9eHhYjZkM3ZAhAjKRoAwtME2TeDyuyouVy2WKxaJKrDUxMUGxWKRWq1GtVlXMcyKRoFar4ff7CYfDZLNZpXDNZDLEYjGlVJPXCAaDKuFYf38/gUBAKQak+62cLzIkQbo3292ypXVY1nyX95WxxFI25PN5HA6HSq5WKpXweDxKeSoVdGvXrqW3txeXy6U8qmQejUAgoGLtu7u7lWW8VqsxMDDAzMyMmudHH300IyMjyvvIrhSVFltptUwmk4yNjTE2NqbGt91u4/F4iMfj1Go1TNMkGo0SjUZZWFhgYGCA0dFRVStdKhOazSb79u1TLu1SgRYOh/H5fIqM2/tbCKHmgszgDUtl0OTzSotvuVxW2dWlxbhYLAJLYRNS2ShJq8yi3mg0mJiYUPczTROv10tXVxeFQoF8Pq/el/39/YyOjlIoFOjp6VGeDUNDQxQKBXWNgYEBIpHIsrChSqVCqVRS9cT9fr+K4ZZhMdFolJ6eHpWgLRgMqlrqPT09yuosM99rmkapVKJarbK4uKjKbMpnleX9hoeHlWs9oPIe9Pb2KmWiTIoof19cXFRy4YknnlDeTFLhag+JkwqlPwjSXW1DSIDfA7XaUp0lqwAlA+iFJksZrIJ90ByGUnkpuFZLoM3qCL8BXjdogpqoYVEigosUo2TRqbCDdQWd3ByYJ2qIbHQpDXagBTUfhlbGcjRxl/zQcuI23UTR6KXFERgkKOJlL1WipHHRR5R+LA6SZR9uJmiQoYqTHCMUSNGmRhG/PknEEuSooTNEkxBFpnDho4kA0uwjxxMxHcMMMV/PgV7BV+tnuBVgLXAQB56mh83ESKPTSPcyQo1u38PE/EUi2TXEM25GrSCrGcBNmQQWISzC5NBp0MaNYIAJXPhxUwEaZBkzGlSMEFmWkpfV8JCmShuNLqKkmGadfoDe7goubcnJwN0Lrn6oByDoB9c86EGID0NpO9T3gfcIiK+FQg+0yw6sSJkjzmgQXwcFE7Q8VPZCsxWmTBUn48TJoAFtsiRHLQZeC9Y2GHdA04ByC+p+SAWmcbZSLCKIh/cR7amz0Ib+FIyOGkz9skAl4yG4QyemWTS9sK/iotHwoDNBlAAh1hGmgB8nNVqAi6AxhHu3hukoIEwNf2gGZ8KkPe8k3ejB5AgCmFTYiUaDLnRC+ChjMYRGzJ3HtcmkGYDiQ6AVIOg3MUoGjqYDj2Hi06CwysBrLFB/cpDxynpMxzhoLUwjQIAsQwywiIcFquTwYaCTIsBmRhA8TC8hthMGchyDl7142IvJGGVWMU64u0XbAvJxSqTIspeGVibdH6aZN1hTTlB3tmkFKmj1Jvt0LxstixOFi5YYQKOHTXhwihJDVOihgQkU0Zgn9mvPDcF26kxTw6SIBz8WA9Rw4yGCiUGCGq+aH6ZFnAEMVgFNnDjaEcpPjrGQsrDcTdCjaB43x9UanI0Tgz3oLM3Jn3qeYMJnECw7aJk+LGI4nCYkdUg6occLafeh8uRZ4GVNuu2baanxXkl8pfZaWszsBH0lMbS7nksyI4lbJBJZRhjtZEpa9+SGScbLyU2cnbDY3bnlx15/2v6ik/FWMjZb1tGVPyU5kZs/2XZ7LPlKhYIdchMo2yetnnJzLEmoEAKfz6cIoyRXcjMkNyOSMEqXOnkPSewk+ZUujpKcyfq89pjvSqWyjHTLMZEWM7nBl1Z8Ob7SauDxeAiHw+r+sp0y1rHVaqms23YSLMfbPkfsCc5kIi4Je9gBoM61W+VXuqLb56+03Eqrshx/OTftIQH2+uj247Jt9r46HPGWbZBrw26Btif7s7dtpWu63MiuVMRIy7n9p71f5LOsjCWXcyefzysXWLsLvmynvLe0/MgMwdIaJEMSZNIhaS2Vzyrd5+Uctse8v1JRq9UoFAo4nU7lIi2zgsv4eZndOBgMUiqVGB4eXhY+InMgyGSMco0XCgUefvhhPB4PfX19av6m02mEEIRCIUWk5b2FWMpk3t/fr+Jiq9UqPp9PlbKS7unlcllZLRcWFiiXy8RiMWq1GgsLC6qkmcx+Lsme9KSYmJjA4XAwPz8PLMmYnp4elRVfJueS1vVSqaS8AuS9R0dHFSmW3kdyDns8HhYWFhS5korArq4uYrEYMzMzSmlgWZYKl4nH48ozZH5+Xs1dGb8rS6XVajVV5k6WlIxEIuzbt49f/OIXZLNZjjzySM4991xlUW40Giq2WY6Hz+cjk8mg6zq9vb1KxtdqNdrttrIcr1mzRllRpZu9JJNdXV24XC5FSqXXkkwgJks6BgIBVXtazj3pbl0oFIhGoyphmcw8LhUDsr659FoQQihPhEgkojwbZD4SWfc8l8uhaRrBYJBEIkE2m2VxcfEQOSa9lWZnZ5ViweFw0NfXt0zxIkMNdF1ndnaW/v5+VevbrgSVMe21Wk3tDbLZrMotIDP8x+NxlaBt06ZN6p0WDodVnXepVJJeV9FodNn7RsZbSy+8RqPB/v371TkyKdxxxx2nFPOapqk1Oz8/rzzI9u7dS6FQAJZyu0iPikajoTKs5/N5pSB9xSNbBbdzyW1c94PTgEA/GO2lBGumA6wAWCEoB8FdgugQmCbCaEC9Dc4KC+Eai2YRZ9Og1AozSY5Fyux07sBjeNCtDRgiC84CzAkwNQi2CYoSQ60kdfzkEDgQHEmUVzNPFzvJkqDCEAGaDFLBTZ0qXaQJME2eHU435UA3zdIcR3I/MccCNSPEvOXBQ5xFUozTRQsPMeKYRH5dWVvncYcLI2VCehKcLjztICPtHpK4MKjQRZsk42zgSRoOFyVnmmS4RMhqUqk78VDgDGsDAcCiiUaJIHPoWhunqOGmzAJJ/LgZI0sbDyFi+JggpgmeFBspsGSR3a9ZeEQRh2aR1mJ0WRaCFvOzcbR5N+2BBULbBL6N4PBC5REwdkBtE4hh8G2CsA+8cZjYD7+430+2kmLzWdNsuwAKOhgFMHdB+vEgk0YfC+gMYDJCgQw6Om16PdAchNkAlKsg2kvfS3bDwKuy5O75Ff0uk4EtdZwBaC8uRQ4EtoKzf5GDO3QKZQuvCe1+iAZbiJ07aE040Wu9BIxeYiQJ4aeGoMA8Qp9h0fJSMNcQpUy4ppNvtjHaMdz0ouGiiwxd7gyar07NB62yjmhE8WglUokCkThknoLqr8DnBIfLpKUVcdd0cnuWqswFAxAfFGSrs6T3CDQzCbgQ9CHwIMhTIcQjZHBg0ksUJ05W0YOL1ZhU8ZMhygw6m3nU5aXFLOvbJi5Pg3oXCBc4HCbOtkmJECVHBuGsU3NEeFjXmffl0NtNvC0nIcoE6aWbMieygKCLdQQR7EZjkjAVCvSToZc0BlV68BGgjoZFhAUCZH7t69EiS5EsWd2PsDwM0KDIAcY9bdKWCe0gBkl628cxOGuyQJOpHo1Eu8g62qRZpIzGLEW+ndjL+HE5LKcTreSn9IDJpoYL3dWAwTCM6aDnYJ/jGUXL0+FlT7rtBAN+k5HcHp9t3+jbyackfnJjL0ueyPOl65V8ydvjTaUl0k66ZYyq3BhIC7IkFvAbt2h7XK897tRei1qSQ3nu4UjQSmWB3BTaSzrZLaCy34BDCKA9jlduUuyKBUm4pZVEbuzslsWV8eH22GN77Wv4TVZ5u0uwvOdKl3L5kd4AdoWJtGzLMbDHWK+0xkori2y7HFO7C7l03ZPn2F3D7fHncvzld1fGncsxsdeBl89qt44fzsJstxbL+brSQrvSIm3/3f6Rz2B3fz/cZ6UVWH7f7mkhn9XetpXWa3u77G2z97O9b4UQKjmadC+3K9RWPrP0LpAfqcyR35VjZff2kH1oT5i38tqvNMiEWfF4XCkMu7u7lcVSxoRKd+SZmRnS6TRdXV2qBrNc94FAQM1XWfrvyCOPxOv10mw22b17N7VaDU3T6O7upqurSxHFTCaj+ts0TdasWYPf72fXrl0q9lTWbZZ1nGWIgbS6ymzQsg25XI56va5kiKwDLS3k0lIdj8fJZDJK2SCTTMma1l6vl76+PjKZDAcOHKBer+PxeIjFYmzatAnDMJidncXpXMrmDSgFj8zoLjNyLywsqKRVsm3T09MqThlQbZiYmFC1ylevXq3c+5988kluvvlmurq6OO2005R7vkzyOTMzg2maqn66x+Mhm82yZ88eSqUSk5OTNJtNBgYGFKFvNpvKOi/7R2a1tocISatyo9FQHkE7d+7E7XbT29vL8PAwsVhMkTOXy6VKos3Pz5NOpykUCqoeejgcJh6Pq9wd2Wx2WWy1jAGXlt9IJKIUrsPDw+pdK+V+sVhUseJS8VsoFOju7lYZv+V9JUmWCqBCoaDi4OW6t1dLkAkWw+Ew4+Pjy0o71ut1XC4X+Xxe9aF0j69UKiQSCaXwk67bsg8MwyAYDJLP5/H7/fT396vydQcPHiSdTuNyuVhcXGR6elq5o8t9SD6fZ3FxUSUrlN4c4+PjSlEmcwc4HA4GBgZwu90qxl7uBfL5PLfffrvaSwwODioFg1wTsp9lSTqpsHpFwwwvmUsbcWi1wTIgNgxGBbQQtMPouwy8mQhW20+jbwbqabRMFyLahWYUCc068COImwG8wqKOAeRYT51+o4cgGvW5PI/fkmX3aBkRjaMfWIPV6MJlhvEToUCGBhZ9aHQzxToewqenedLaRosBenDgwWIeg+lfW2Y9tGmJFtF6lCNFiC6CVMwGFiFMBsgzygIhtgPDCIYIsgc3JWCIbrxWEN3fxDrCgCmBdzLEGgRJdBbI0MMkY5h43Wl6expkWw4OlFNUqqO4CZKizbFsp02ROVw4aZFyLYB7yRmg1PZQEt04KDDEbkz6WMDEF8zRZbjpbTgo4mVRm6ERnKUlLITXpOC3YD6Av7WBRKubRmCS0bPncR8PjRjkH4K7/jFGt15nm79BqA+cA1AMQMUPmZ1g7V9FtwMG+y2aHqimoXgb1O9IMJlPkMZHHzF6NZ225qRlhQh7suh+mK0tEe5aGYQJkRY0HWAeBXGrQrkGzfhShTkjCTsXwXUH9KZg4CQLzzB0BaDoAqcTvNsNSo8bzM+Okx6fobDYQ1iEcboqhKMZ4q4KzXSEZjtAFj9uM4zDzOOhToASpnuK2OAC3Ue3iXRD04TqDAzPLmJpYFggJsDQoJiHqgWOkMDtLyKqDgplje6kwOOC/CI4hUHYNUet2QOsxaKXEFkKzJIFDAQ6Gm008niYwYWBThZBjDZhYtyu1RmP1xnOtjDwUYu3cPVA3g2OkTncu3bT1uMYehnKVdrdcSYdRai2cDWd+PAzRBgfAQygm+ava4/XSOEnjZMiOhP4uZ8kk3hpksZihgRO+gmh46WFixx5Jlhkyj+D0ePHNR+jVmsxFzpA7oQ6lMvoB0ZxGf0EGw5CzQFalht3uk3A9OPARY0I95Pm9uDNzB8zDpobAsci3DFSlgcnPprkYVEslRecreB6yMfzyXrxiiDdK+OVpSVCWjLtJM7uhiyTLiWTSeWyGAgE1PVl9tdWq0WpVKJerzM9PU29XlcZwSXRkxlZJemWNZ+bzSaZTGYZWZMZyWVctiSI0gVUvuildtpOMOS5Uuu9kvD6/X5lCZQWJnmOPdbXTlbt1lNJAldmDPd6ver60mLWbrfJ5XIqNl0m7ZHEWManVSqVZe6BMlmXjCWzLItYLAawrA44/Ka2rLReyn6RzyDHWSY2kpY7e7IxuemT80Vu5qQSQPadTNIk3RHt9cyl22ahUFDZ0CVhl9YL+3yU7oBO51KZIqnA8Xq9isBKq6xsp32OSmuLDFGQLuf2pHorSbVUBsmP/bhU6siNoGy33JhLS/DK+bQyHl5C05YndpOEyh4nvJKk213jpQJAXl9WCpAurnIeyJ92pZrX61WWMk3TVOIsmRtB9r89iaGcv3aFjV3p9EqE9IKQa9DuPRKPx9X4hcNhCoXCsrJgMrZz7dq1ynor57usySzncqFQYOfOnXzjG99QXjF+vx9AkRdY6u/169fT19enkoHF43EsyyKTydBut0kkEmpc5HqTpZ/S6TSLi4vLMl1L2aTruspwXSqVAJQ8GxwcpK+vTxFYmTG8Xq8zPz+v6j/Lclg+n492u00kEiEYDNLf30+73WbHjh0ADAwMKPdjXddpNBpEo1F6e3vVsVWrVrFr1y7lQiyTW8n+1TSNAwcOsG7dOnp7e1lcXOSxxx7joYceolAo0Gg0eOCBB3jVq17F8PCw8gCS49XV1UUqlWJycpJ9+/YxOztLo9FgZmaG/v5+isUixx9/PLlcTiW+GxkZYWBggL6+Pvbv36/eLX6/X3mZwJJieG5ujnQ6rUqlyXedjOfP5XLKGh0MBlWWbelaLWW7EIJ6vU5PT4/yzpLeVNLbSJb6k27OUnbXajXlfi0VodIVPxaLqfJe8lzplSHfkx6PR3l6hEIhent7lXeFrusqSZn0SJBKu0wmQy6Xo6+vj4MHD6r69LquE4vFePDBB5UV3+VyKVdzXddV+btEIkEkElGeDtI6PT8/Ty6Xo1QqKTknZTssKSYXFxcVGS6Xy+TzeaXkKRQKDA8Pq3kq13WpVKKnp0eFTcgYfXmNe++9V8Xcy9AwQF1LxoJXKhVVgu2VLh8BEDo02+B1gFYBswKlNswCjhgU3YTmdEIiQosC7WwZ06tDLYS7ZdJj+thsruUIUmwggosMgkkGAC81vLgwMSkwya5KD/8wuY/dYyYi4MVf8v86RrVJ/NeO2EeywLHsp49Fxi04SAmNAi7C7CCDhcVGYoDGImCaLYbMAsNYhOgnLYaYR8NPlCYpDtAigMYAOi7KCAocpE2eFl2ixhHbNeZdPcRafhJGL3FcdNEiSIuINk9dOJhvu4kvOFloDbBXDJOhiUmAdXiIME6QFv0UaaPzVHsNGHkGqVEQMSx86Bg09BZR1z56ww7MtU30Cdg806RIkAOYaFoJK+gDv46INZgVveyf9lDwPcL6c6fo74LGLpjOwJO3Blg4OEzTUeDBuw+ycYPAE4ZCG8JNMF0QDk3Q1dUiPiCYOQi5uzQyN/dSq/dxgCoBvLiCjzJ88T6q91u4dmrEN5foOhPm1kOzD8r7wdcAU0A+sJQ7y5cANDAMmJuH9JROfcFJsO3HcJl4RypseIsgsAWm8+DwgGsEPH4YboHz8RbNe6bwajqBYROfF8Q4NEw3PWQpBxZp+QXeqInHZdKaXMS7yiJxrsC3dsnFvmoCaYhkoD4LpV1LWdq1KHj6oZ0FdxBiGviESSix5LBRq0KlvvQdIQycjiIu00uRCk5KhPj/yfuvYEmy9L4T/Ll7aK0jrhapRYkuXd3oRjeIBghyhuBguLO2tDWb4cs+8YXkE98IszXD075i5oUGkmtDcMEZDjlUANFooIGuRumqrBSV4mZeHfeG1hGufR+ivlOeF922ht6d5nbRza5lZdaNCI/jx4+f//cXX45dnpLD4ZitZXgZKXpYfKbPaTNj0/doUOFxdARmD9dd5T5NSukRlgFGHgqbJs6zJ1jsgB7AwgB7BvERODpVs8ANdrhMiSJxplgE2IyZMiRChl1OqWEyxCTGggg38XGxeQj4+Axp4xBHI8WzyIReZIDPCIpj0v0hK/MtTrIjiE9gNCWyfoITr9IrvkLPdtAOkmjtErGJR4I0Z0z5o8wPaV+6Q3pyxtxYAd9j/RP4jr3NCVPykwzuhz6xT6ek3Cy64/Dsp1hyfq5X1Z/EZIq8XKrhYWACX7LDIq+VTV0mk1EbBan+CwiG5/veikxVgIH4hQWEC9AR4BxmR8Oe5B/HdIvUXECWnHOY5ZMiQ5i9lOApASph//DF8Qq/J3zpD5ZNo4C/i6qA8O+HGX5hUsNsugC+MJssEmphWMJ/l9deHBdha8Lt0MKy5nCSdThFXABWuEVZ2DsvrGjYoyxzRMZRmD75PfnMMHN8Udot8yacByDzQxgkYWIvMufyHvI58l4/TkXw46TfF39P/i38/2SuydwWKal81/A9cvF6XvSXhxUkF88pfJ5y/4S/o2xGpfgg1ySshpDPltfAEnjLvSJFg7AkOnzdwvP+4n//l3BIcFk+n1djJdLyxWJBLpej3++zt7fHbDZTvy/p1rlcjkajoQqSYqORYDJZG99880263S7vvPOOChcToCahki+88IJKfh4MBmrdaLfbHB8fq9cIiPZ9n5OTE1KplFIcCVMpUnTXdVlfX1cKlm63C0CxWFRMsBQ4ZY1IJpM0Gg2ePXvGdDpV7yOFJ2GCHz16RC6XU4DKdV1OT0+VDFkKgqVSiVqtpnzci8WCg4MDFXgobcgkrdp1XdWTeWVlRbU1+/TTTxkMBkp+/v3vf1/JuKvVKtPplFKpxPr6uupHf3Z2pn4kkd4wDLa3t7l16xbvv/++KkTW63UikQjdble11gqvVeLz9X1fgdMgCNT1rFQqamxkfVosFqo/toBgwzDodDqqJZ1YpHK5HNvb22o8Pc9TXnxprSXhiCLXDnuzy+WyWq+kGJlMJtUzoV6vs1gslEVhsVg8l7YuNhPppy4ebMMwFAsfboEp81Ek4FKQl6JDrVZTAXACbsUSEIvFGA6Hf6FoJL3Q5bklhV8pgImFCL5UGknooRTyRbIuz7atrS16vR69Xo/RaMTKyooq/juOwyeffML+/r56pktLtEajocZS15chlpJwfnx8/BcUaF/JIwbYcQh88PMw10BzYJKEkYExW1ANcrj0OU/t4dVnMItTDHy27QprxLhJnjeoUP2CmYzjYzBZBlkxxyGKRsAbRPlvRi/x280OC92ixJwELkni3CTOCjNeZ8pNRugYDNjAp0Efn316fJg6Ie3NMa1tZsQ5QsfSfc79E5po1HHRKfMxFeZk8NDZ0weUfJcx69jkMNlHp4tJQIkoLztpIs4VpsQxGZPH/CJCa0ojZvPMzjEObjOzXDymrDOgzJgOBZqs8hk7VAkY0UMjikmdVvAuAR4lEix4hsc6Jf8KtY175L9lQhEWFYtD+z6RziqlwMSYzNHNAcNhFLejUTIDkkGe4qUmK3GPo9/VWQx0PhwXeGiusMmUwI3yR5/kmf9gyCtlsOowm0FiG1Z+ZUp2CsEamD3ovRvleJHnqeaQCXJsxU7Z/K+ekP4bHs6TBOmYTvwNH/cFOI9ArwulJ3D1GIIk2AUo9KF/AMZiWavpP9WZDYsE0TlmYcJ8GKNyGMP8zGK4BpEEFCIwMmEQWbZ9TxYg82KAMfXonmr0ZzreFEy/gEWSXLzF9orNOAu6CW7Mo9mAdBaMPfAN8GuQyi1dEYM2+EDgQjCD8i7YDdAHkKxAbGP5mVYT3MdQc5ae+LkPC8/FZEyWBCZjukRIUCPDkCgBAWm6zDhkzJNMhJjTQ1vEuIfN1DExXDiLzCm7C/rnaQZnE1IxoAa5wjHVwTqnhRp6ewbdCP5OCm0xIUOGOGk8YhywYMScChFS6OwxpsOEGToJEkSI4mISwycghk6CPFHi+IyBCQH9UoAfi0LHhUgPOxXHGpZg1oWWiW5ZVDdH9Doa5rgH6TOC3V2iTpLbkzQTHP5V+hPa23fIR86wfZ0gmyN1Z8Er7RVy6KyQYCso0XZm7DpXyBLQZu+/PNAd3vCHvXYCcqSCf5Ghk82XSBBXVlaUxFJYNAHFApDkYS5hNfIQlPTXYrGoNraatmxd0+v1mEwmtNttJc0Oe4gFYMhDXoCibGgFIIXZHPEcC6C5COCFZRJ2T8BkGICFgZBsaC6yxwJcBLiHD2Ha5fcTiYRil8KHbDrlHAQchQOWJPVXrqfIG8XbK8z2YDBQ4+X7vpKkikxRmBXDMNRmqdvtKlmjMBqSwL5YLJSHXuZPJpNRqa7ii7uolAgXTqQQIEyMbJykrZIk0MpGUphumVMiiw57wOVc5BrK54uHPXzOAlwFREpBQcYsfN3ChSmRZF+UT0r+gTBJsnEMSzLDfnCZA4BireWeCRc95JqFAwmFbZFgQHmtnKscMsfD10KUEvL9hLmXDawUneQ+ke8YlspLweWrfEgxo91uU61Wn1PJyHqUy+XodruMRiNarRYrKyusr69TKpWeW1uFnZS5I9dFZNuapnH9+nWVOg0oublIuavVqmKIW60Ww+FQMbECKA4PD2k0GiwWCx4/fsxgMKBSqVAoFFTy9tHREZqmqfW12WyytbWlim6iAhKps6zZV65cUW20BHgMh0PlY5ZiqayxwqoKCBI1kxQRMpkMe3t7qmglvb9XV1fJ5/Mkk0nFksfjcfb29jg4OKBQKKhxazabz+VdJBIJBoMB/X5fPUPEny7S8MViwenpKel0WvWzFnl4IpHg6tWrbG1t8Xu/93sqAE4k1yLTPj4+plarYds2Dx8+VD56YaLF8mHbNrVaTT1Lhc0FVLFCZOaj0UjlmITVL5qmqfcvFAqKjQ2CgHq9Tj6fV2Bf8jLks6LRqFKZVatVVfiTOSPzQsbM931lgZJxl3MdDAaqRRfAaDR6Tokh2QSO46jEcclFEYtCpVLhtdde4+zsTD3DJAlfni+DwYDFYkG73VbrajirQlQ6UuSQf5e1MVz4HI/H6pkihfjJZEKj0VBFACl2T6dTGo0Gg8FAMdcnJyeqeOJ5HvV6nWKxyNramnpOjcdjJpOJmluiAvsvIkit6IBmgt0Guwp2BBwNbZ4k3QmI+zHKZJnSxU2PMOwW9e4KW8Eau5Soo5FDJ8mAFB1iHAMjLBb4+HgsyKABczTGvMwLvNja4gF9skCEOVGgTsA1TqnSZRSZ4AY5Tr0dHgFN/QTNj+IHNsPUnHv2IdWgQYIFhv+YrjbgYVBklR3mrPJR1GTKMXqgYZZ79BNj+t0mb8w2SBKlTIQqKeLoDJiQZsY5NgEdtsiRIsciOiBd9Jm2KzwNlgz+JRLEiODikcPABXymxLCwyLGgwA5QAZLY5PQWmfSMp3ONkfcyztk5i2dtCnis6ZD/Zo9EZMDuSMNpe8S78LQF+4sKa2iU6KE9jtF8ksewkliBjUWFQSyN7gwZBQvMRYbZvwYvM8T76zAZLVuoWz6cP4H6G+AWoWWnOaeEGcS4hMvtF++wWbD50f89R/xuhUqlS2oFzhew70BsCIl3QT8H24UnrRgL32XSA3NWIo1H4I6ZY2NFAmpJn9QohuuDkbGIV0GLgDGD7BzibRg/gNEJJB0N+hGMZgnN1/GYopFhwRqT4RmFYgcvuexM518H9zVYVKBqgOFAcgzGEKwD0JsQtWD89Iuwt5fBL4Deg9gI7GtQuAWlS9BvQP8zCM4gNgPdS2LTIaHPCXyPCQWekaeLjoZBAviUMTNMKlOHbd9imxUmJCgEDrkgSy+YEqeMP/0Fup//gK3ynMoGvH51zsP39zk3L+ElUlBYQMog5hrEsDmmz6csGGodskGU69RYZYyHjY9LBBefGANczjSDu5oHvomGhYWOQYAGrKDj98Yclw2CSxlI7jOvV3jXnuBWN6A0w9cHnOspvKAKwxFUo0SPurx+liOKz7/InnDw6ghtPsKy4yxKl6B7i0Znk3UyJIhhMsFgTIMFDRZEcRnx07Wc/bkG3WH2Ncy+CQsqG+8w8IMv2Uhhw4WBlI2lYRhqIy9VZmF8RQ4t0vWLYVRhSa8EfslGQljCi7LgiwykAIOL3u2wt1reR767bHB+HEMaHp+f5NsNg8owkyvjJb8rf8rnCJNkWdZzCeThDZcA2HDyusiqRbo/Go0UMywboXBSuQDEMPANy4jDvn35XQHXEjIkYE1YEGFwwqFgYU+wMOph//HF6yU/4eskzHt4Hl6ck4C6XmHJ/8WAsvC1CReBwnPpIiscPie5nnIdLyob5LNl0y+FC0kcFhmoXHsBzgJw5L3kT7lWF0F4WGouczg8hmGG/KK/PXyEzzkc4BeevxcLJeHC28Vx/CofIhcXgB1WLggjOR6PVY/mVCrFlStXyOVyau5LMSmVSim/syiIZI2Jx+OqHdXNmzfVXNrc3CSbzVIul8lkMooVlftOgJoABAGR0kJLikGmafLkyRO2trbodDo8fvxYFaVkrbh37x5XrlxRc116lIdlyrZtK3m1FP/CgWXCFgr4kWAwz/N49OgRh4eH7O7uKtApbaPOz8+pVqt0u1329/dptVq89NJL/Oqv/iq+7/P973+fJ0+eKAvR+fm5msOy5mnaslfz/v6+YoqFlX369KkK9pJE6rD31nEcVlZWmE6nBEGgvN3S1k38u6ICkWLk0dERDx48oNvtKknzysqKao/l+8sOD9PplEgkoqw1cg3DRTUpxAlwg6U/WuTl8jwVf/pisVBstaxRcv1d1+Xg4ABAjZkEtUkQZqvVolwuq3ZzUsQeDAaqsCSfL/eBFLd1XVf9rCX0TfYEtVqNeDyugtrG4zHn5+dqrC9fvszm5ia3bt3i008/VVkHEkxXLBap1WoqzE6KvSLRl/tGPOCapqngvmq1qthusdxIy1PP85SXXOaOFG7a7TbJZJJyuUyhUFAdCT744AM1/olEgvX1dWq1Gpubm+q7t9tt/uRP/oRyuax6zpumyf379zk8PPxZLVX/+Q5zAg1A8yGIgWnAY41yB675WSwMYIKOTaxfIuunaARXSJFnBY+dLwBKjClJTBZYJLCIoQMuBhEMAmIkGDChzAm/HlwlT5YYAUU2qRClziEZnjLHYepexeQKHdY5jD9gUByjj9MEVgB+mlhQ4DpRThnSTS5wsjH2TJfaeIatjRlun+O7d6FbhiCKn5nTq5qcfdTjVnCdUwwCoIVNlwQlPAZMaLJgjM/LLFhN9PEyMO34GMwooJOmQI8J3S8YyBRjkrgUcfEY8QEzzpjxAhXy5NG0R5RdnV4w5JwDqrObdP+kyj5TWrEJL369x7f+vs+sDHf+R3jybw1wdGa4nCy7cqNbq0QoEGWEhs0OPj17zkE0SztiUjUjTAebHH06Y3XHof8YOhOwm+AcQPQM4psw96t4rFJkSooBE8vl5I+iFPd2iZSarP9an+wGnDhLH3b1HCJncGTBvWOdh80tbO2MrO5T9XYpoeFzjE8OY5FgenJAhDpDd8ZkMcKdwp4HK86yA11wDMn7YHZhPqqyCMpAmxweAQYLTFw8/JRH9jsQXF62kE+Yy1ZgSR86q5ArQTkPiyqYTcABLbdkridjSJ1CArAsaDlQdiCZhEUS2AD7cNnpSrcgZUzJlh5D2WZylEefJ+ji0kEngYbFAJskUbKs+TOq2LjE2aSBR5wUNrtBjD5j3iHDoHOZxKP7XN7w2Hwz4ButEzpPKjxaWyWI+rDvYphLT7hPHZsOhQDSjCjiEaOBh0sf6GPgMWKRdLASGswnaE4UTavS9CK4mSh6zIbBmJKXpDNOs9hwwUxDO4GT8iFqwOAyuAGecw7lKGzHIFrkxrMIf83J82+NzznYDgi0HkEixbz4KrQ2iD3apOol+RoxjunyB/kf4M3K3HZ3yTPBw6TJw59qyfm5B93CygpDJ+msIucN90oWECjARJJGxVcqG034MrBJPkeA0OrqqupPLGBaHq4i+RKfo2xOLnp95QgzewLgs9nsc0BYAL+w5AIwBMBelDeHQY+AmfDDXsBpGKzJOYU9w8JmhZOjPc9TLHI45TzcGzTM/F700Ia9xAK+Lcui3W4r9lPYeWE3ZZNvmuZzfmQpcggjD18yxlKlPz8/V71dw6zmRb+6XBvf95UHTza48h2FZRAgLz5xmUcCQqWIE5Y4iwxVxl8UC7KBClsYwgWUsJIh/JkisZRzEwYyk8kopl/GQza0EvAj3uawgsP3fYbDIYlE4rnwQdnwheeupMPL3z3PU4xXuEAiRadw8USue9gGEC6WhFUYMk7hgor8m4zrxYBBkUnK3JQ8hfD9K2Ml99BX+QgXFkVVIn5P6XU8m81Ip9Pk83kVfCXsGizl6aPRiEKhQCqVUvf/RWWGeFgF/MByzUgkEuzs7Cilhuu6tNtt+v2+UrzIvdVoNJQ6RFLL5RiPxzx9+pRarUa9XlcstPiVw2us3N8C7AX0HB8fk0wm2d3d5eDggGaziWVZrK2tqaJCoVB4rqg0Ho+ZTqeqCPDxxx9z5coV6vW6kshLyvnR0RH7+/vs7e2xWCy4du0aOzs7LBYLDg8PmU6nKitCgL2sa9lslmKxqJhYeTaZpkm/36ff7zMajVSrtVgspiTnIneWpHNhgcXHLfJ2uc8k3Tucri7KHFl/ksmkevaIn99xHJWELWoyAbXRaFQF88m8kgwBKXqWy2XW1tYol8scHx/zySef0Gw2SaVSvPjii9TrdcWCZ7NZBRaF4ZZ+6KIWEoZd1vtIJEI6nVatyK5evYrruiovotVqKcYelmvtdDpVa5kUYNPptLoOYn9IJBLcvXuXVCrFysoK165do91u02w2lTVNvNC9Xo+1tTVu3bpFu91mNpsRiUSYz+f0ej2q1araM0jhKZ1Oq+dIOIhN1nW5J+v1ugqbK5fLrK+vK3WBrL+vv/66kvfLM6rRaLCyssLa2hr5fJ5oNMrx8TG///u/j+/7PH78mGazSaVSIRqN0uv1nuvS8ZU9ogYkDXBjy/RyPUF6EGfXK1MnywSTKDPSpDny8gTkcCmRY0wBDQeHGC5j5hQZkcJlzhyXBT4eARYaFgUilPDIcYTPGI0okMVHI0GfXSxM1rDhi8Axmzn7aMYY8ia+ZhLpOFStFcqkqNAnzZwHmQKjsk5wFDBkiMNjgmoDgi2iHY9kP0pmaNDZqLCfC8iNIozRWeDiAKfanLQ2wjbmDPNZrEGPDW/A7izCwWGBx16RCSaXmJFiwYIoBarEsYkBEVYY02fKAROiHOo6HT/gFdZZ8QrkFxYxNLY5Jha9x1GQ5q5bI2pnWXw6Yutdm+SvwiwCh/M808CkgUWECQl9jmbMML0kET9HlihFvc1VYtjuKn0/Tz4AE4NBT6PyKcz2lq2UcxrEXoC10hKM1hJnxLQMkWCFCgWi93PYuklp4wHbf93GfR0WMQgM8HQInoB2HxYLmJsFOsk4vlakNodY9BlawiY5q+MFMfRok6Lt4HCOY8xpvadRdALKL0BQAdMEuwsRZwma3amD5XrMiDClgoPNGJcpMxp5l+ptOL8F9lPo/Ato3k+S3LDI/3c+oxqYPvgJyFxbtkCLB1C1wT+EhQ3JPsRtcK9CJL9k1xcaLA4h8gwy3Tgdu0iQGnDlbQs3A+O2hzMfkiGPSZocDjaQQifOFAOdGQUCTHaAJB59HgNxbOADY8bYK5F/VCO1ccbK63DtBYs3z56in6UZaxnyXoo4WcCnFv2Mtzmh7NykQ5YZY5IUGDCmmRkxS1WJtXWcuAX5ETgjglyGQLfx7ThEEmh+jsNohLwN180M/btjTjdruJEG+BaMphitMjlnDUvPML8WoHs21+8l+W+Ht+jQ5lGhT+CZMHKgdIPEk23WjtcoOTluEqPDMf+q9Pucv3xA9GGUj89vceaXyRDlNNaFn0Is+XMNumXDF06vloeyMNDiSQuziRf9xmEm7qJ/VACpgIRcLqd6WAoQCoOKMJgRMB9m38KgW4BemLEV4CAMlYBPYQQEuAhrGH4/+JIJFJAMqGKDAEEZAzknYf7C7KeAxIvvK5tneQ8BaTL2wpLLa+Q8wn9e9BxPp1MlM5X3CDPpgFIRXGT0ZazC32OxWKhgHdlYyiZWgKJc44tedQniEt9iuCWV+M+FaQp71YVBCXvMZS7JHJAxlu8nm11hlMLXRMZQ2OJwYUjmRBj0iLVC3ivM5F70l8vrwwUb2WDZtq3GVEBquGAgQFyuZ5itvqjYkDGS85Y5Hmbew97rH6diENAYvhZyDcNFNJkjcs4i+Q2z4FKUC8vxv8qH7/sKEIkFQ9hEmVPZbFZdK5mj4iOW6ynFPpmbkUhEASJhE2F5PYvFIi+99BKAWiPDqeTpdFqxeuKplWtomiaTyQTf99nd3eXs7IyHDx/SaDSoVqtMJhMeP34MLMPMJFBsMBhgmuZzoF8KZML+iqR+NptxenrKw4cPVSBir9cjn8+rZ4a0MZMUd8Mw2NjYQNd1Dg4O6PV6Kk09HMYpadTJZFLJv+PxOFtbW+q8Yek339nZUSB2Op0qQLWxsfEc6K9UKorRl/7NlmVx6dIlVfy6efOmYuildZbIwmu1mupbHbZAyfNP5oKwvMKISmtMaScn11fax4n0WexM4YKHqBDCRekwqyuBaMPhkL29PbXWbG1tKfArz3HPW7bEkoKjMNRifRmNRuRyOeDL0D5h1sX+FY/Hyefzqte2fF9hv6VQH/a2S/G9VCqp1HMJ8pNCj/TLlme9KIJee+01stksrVYL3/fp9XpKPRcuzuu6rlLl+/2+krWLN1xaHmYyGZX4L2vmysqKmv9Xrlyh1Wqxv7/PCy+8QKPR4O7du0q6LkXxzc1NGo0Gw+EQTdP47LPPODk5UQFsZ2dnbG1tkU6n+cY3vsHe3h5HR0c/m8XqP9dh+NCxIJaCeRrtOE3eSlOg8AUL6ZAiQx8PR3cI/AAflww+62TxieEzRsfFxUEnQEMnQgQTjzgBOVIE9IAhGnNKdHiJGBBlQYs5Bc7Y5im7JOiQ5oCI9oT1ACpmjP4sA3MNw/PJscBjQgefF6jyesfjT+bHRMwGGlX0YILx6DFld8jtmU8tsKlT5snTOEOtRI0cMwLG2MvSQGbKLDmDaADxFNYIZl6MU/8q9/wYn8Z1XBxWLJ88ATHWCMjQpU+RKjtkafAIgzbXucSOv8khR3SZU6bOFIcUFWIElHMfcEiLYc8nSo7TSZz0H9pUr0Lldaj+yRgOMkCcYmTMdn2K40Br4DL1NQwi1FMDNr04kcUGHS9Lkil1bKImWAmYpaF9P4IV8bn0qz6plWUr9mu/OGH0+/eJD2Nk8ClXFlhXF9TfgtomPNoDbQbGTVhsLQGyH2jY6wGFpsPqIsEUgzUgXX3E+osm8wdzfAeyEZfMSR6CAC3wWBzGibRd9E8Dulsec1Mj+ThCInAxkgGuNifFlAh1TLLADIhhY4PjYbbA3wTmMDwxeNhZJTIYcGOjT2YHbB30GSRz4NfBDyCdgnxsmVc2PIbEwCBW9xi1YDSG3M6ybZjVi+HYGyzI49o2dsUivw3xdxzy/Q47WJRpECFJlwgWOjnGeJQZk2adIescMGJAjC5Qo0GVotfmLAEH5iV234FY4YziNdh9f05lusmUgIAeCyJouR/x+gstsqca5wc1BtzgLhoNxni4uIYF8QGe4aGNDYIgD0UdtC6YNqRylDsT1u0McxIUifECSfJ2nQ/247y/EsEqG9BdIWfmKFCnqV9Fb7a4trfPf2+us0qO/0f0cwabgHEAmTzxp3W+ub9BgxXyDCni8L/oj3hUfsiGcc68EqFjFZiPNoi6GczU18G++5decn6uQbcwOLLZCCdECwiXjbkAJqmYS7KtgIiwVywMigT8wJeJzSLXdF1XeV7DYWDCYITBTliiLcBXJJ7iJy+Xy5TL5eeYVzl/AWWz2UwFBknoC6BA+sVwqzADJGnaEsImIFTAqbS5CQPZ8PeX8xfwLUBKxlokjMKSyOZXEqkFVAn4lPeTjZJsXMTDLhJruS5hgCVMkZyLgANh0gXQyrnJGIo6Ar5k9mV8BLBp2jKkCZ6XYcu5h0GlbF7DXjw57zBQ1zRNfSfZqMvGWoCuyPTD30HAdnh8woUXUQeIPFMYFZF6yvWQe0XkqFIsApSCQRisMBMtRQJ5rXi5BQSYpqmSeAUwy1hLQUb+PawCkGsgrwsXucIFIlGyyI8UNqQ4IswYLCXT4V7mF32JYbtEGOx/VY9yuaw8+MKeyT0jzNpsNqPVaqk2WuPxWBWuhI0T8Ndut9U8krkhktewGkHWVsMwaLVafPDBB3Q6HXWtXn/9dZWkfXh4SLFYZDQa0el0VE/q2WxGuVzm6tWrqqBWrVZ58cUXuXLlCuvr6wrISG9mAfnhwpsoQ+TemEwmdDodFaAmINuyLDWP5L6TOSttxyzLolgsKkC3s7OjVE3hUE7btjk5OWF9fZ3FYkGpVOKVV17h008/pdvtksvliEajdDodWq2WYjErlcpzyiFZC6RQdHJyorze9Xr9uVBJOa9+v0+xWOT69esYxrJP+eHhIfl8nkKhoMLFXNdVIXqrq6sEQcClS5fU8yafzytVjFh/pK/z2dmZKt7JuRcKBfV8Ekm6tAA7ODggCAJKpZKy+UimityrkpS+tramgtYymcxzSi+Zp/L/pDi6t7en5mSz2VQF3M8//5zbt2+r58nt27fp9/u0223a7baar9KGTHJCwmuLPKdmsxmj0YjpdKqS7o+PjxXDHo1GaTQavPHGGyQSCf7wD/+QbrdLt9tVzx1h/OU5K3PG9301Xtvb28rqIeuTqJCuX7/O4eEhpmlSrVbZ2NhQAW6u6/Liiy+yubnJ6ekprVZLhSYKg16r1dB1ncViwf7+vsq/kKLA22+/zcbGBrZtk8/nmU6n/9nWrp/ZYZQhHwczDtMk+XGOKjopPHZJM8BmnxkdWrj6AIcCXX/MXVwKTIl+EZn2NjZlbFpMiLEghY2Og8eCERF00hgEGHhEMNG1Ph5RjOASTW7yrxnywDin6DtsBza/gMk2Opf8BPteAme1hJUacdzqUvIznLFCnTwJNHBS+FFIc8x6cZ/vrg+4Gg1YT0LED3CbLV6aPKFt5ZgvVkg66xyS55gFWmQOGRMmNuhpnGiEvpOmQ5YBLq7XxdHidEizRZw4KQzmONhMsYFDovk9irUx+aMTLCvLCjouCxzusUsEjwRD4sT7deJalCIBNlNOAo31FkTeh423wP5ll0//ZES3o5FL+sSy0D2O0XKyjKNDjCCgMougRWwKqXsYXoDlBHgZn+RrNnYVjt+JMxjtYMfPqWpDziJw4sJ4HQp/xcLd/4CmD9Hveqy+CDkfzv8Izn8QIb/mUrgCmMvwscitgKOvw/jjOS99L0GQaXFl8wxv4KHd18n7HolZHH+eZhS3idQsUq6PZ1ucjRPE91/CPUwwoY/hexSYEAwDZkGWCFGm2UPy+RnWWYIjL4tHDGvu44wgsYB5DvJXPfT9Dr6bZroP2gKMdUiOIKuDvQsOS0m5vgb9P4bBTENPe2Qd0D+HiQdPn0ByGkXvNWhSpk+XqG/xsAW3roC+Y5FsnvM1p0efGS126BOQIkIchylDNCIkaZJgSJcSOkU8soyIAhpWZcZxu8Rk9BKtz3sYXYfD7gYT5hj4JJmwlrjH69/qkViHP3hc4S4VPo00cVyDOTFsJjiWBYsFXioCdgy8xJLed8dofoHicIuv2yVKpOgSMAY+Ycx1fL7traE3B3zYNymYVVbYYEGKq86Y7b7Ja1znMjkOOeVMa4FhQcKFxYjVZozr1EmgY7Lgh9o5D0oegZbF7bUZdtbQ9K9j1Tew+zaaG+On2UH+XINu2byHPdkioZVNuoBSAWfCkAlIkpYlIvETiW7Y/xj2m8qmXkCBZVlMJhPG4zGz2UyBqTCDHfbxhtlJkcRXKhXy+TyVSkVJz+R3wyy1bIDEJx5mo+U9w4AZvgQaYdZQ2KaL6d+yiZX3k3MI/ymFCNnwSehOmEUVT5o8tMOS9zBDKoeATWEeZLyE+ZfrEZaCy49sTqXgcJFRlu8GX/YFDxcUZHzD10oAm+d92Vv84iGvvehLDn+OsIfhFnGy0QoDFQH6YRAvrwmnrEuh46KsOhyyJ/JIURzIhjOcPSBjLuMl31c20eFxl3klgXVSxJDzEn+uqA/Cig75LPm3sJIhLPMWZluuedg2cpHpDnvvw/kHshEXD/DFNmdhtYjcDxdVIl+1Q4okci8Wi0UFTKX3dbjI47quaj3V7/c5Pz8nEonQbDZZXV2lUqmoQCzx/sv8k3kp69Hp6Smz2YyjoyMeP37M6empKkbt7u5y/fp1tre3lfxfgqvkmj19+lQlShcKBb7zne/wxhtvqHtZpMXD4ZDNzU02NjaYzWZkMhkVPCbtDGW9EoAj5yzycZl/Egy3sbGheoIvFgtVFBWpcDqdptvtqj7fIqEOqwFkLCXIrVqt8vbbbytWvt/vM5/PlQrB933VszmRSDyX5G4YhrK7yPOpVqsBqBaW0uZN5MNy/aQ9ldgDpMAn2SSFQkE9e9bX19nb2+Pk5ES1EZT/ZxjLpHKx+ohCQQrYohowDEOluUciEe7cuUOv10PTNNVmTMIlBUSKGkDeT54B8mwRdYb4zre3t5UvWiTlAp6lCOA4jgqtSyQSat7r+jJYTq6XFOlFzj6fzxXzfX5+rmwokhwvKesnJyfs7++r71+pVLhy5Qqbm5v88R//MQ8ePCCZTKre7ZKiLmtjsVjE95ft5GKxGKurq9TrddbX19V9JqoCKeAeHBywtramituapjEcDimXy6yurqpCsIDsfD6vQuI2NzcJgoB+v8/+/r6aa9VqlfF4zPb2tmLngefWzq/04SfBiy/7TbWnGG6RKQu6LIAiNYqcYBHgY+gui7RLd9qkmzZ5mu6h201cLUq/v87/zd+iwgyTBVPmJPGJ4OAzI4GBi4nLjIhuovlxmrzAjFd5QsC96FP6iSbjaYQpNjcCj2tk2Gad3FCjV9WhlsUeTYnNfeY4/DvtmD496q7PdeOY33jtiDd+wSeaBlyIlWA4hFHLZzNpsT7qMDvukL2/T6r1BglWmY77dM0hUTsgodlE/AwLAgLmpIiRdSM4jNDooRPFNY4pVvrsBAGzaYKgOMd8e0b6NqR+r0P7QZEpEZLU6NBm2xgT92rYTBkHAW5QR2eAThvP12mONHLvB5gdqFTg7ZcD+o8CrB70Twzm8xxRAtKegR8k6MRtopdtEokZ8zboHUhklj2zW+9B/EmFDAFGfk6ltuxdbR9D7GyZ+D34jkeyApks2C149D4M/mOVsRklf62JlgXXXiaWp7fANSAf89gufEL5V0zWb3k8/X/Byf0EDglS1MhHe1TeHKG9BtYziH0UYA5hTATNL7Ggi8GYGVmcwMDAokSf2saISDng05bBkWeTZkE/5+CuQDIOQQE2fgl2P58Ra1lsVSHpQX8OWQsaUQiyoPuQS4NTBusUYs2A7RzoORh1IHIvSuqzVaLkmbHFmBkGTRw/wcFHCwoxn0QWRvkZi56OHhSpUKbDFAeXKDUSZMiSwedj5voJaT9JEp8W0CeDiUWgDziPFTmz80S7MU6GGu+ZBY4Sx+iBwYuWzrWdBZuvwp98qvPD7jqPYhqz+DnpaQo/yGBgommgmxFKswIxfDx3wtSOQbDFmlvna8Ea10gwJOA+LnuMGBsR9rQY33VPedtfIZhXMHC4ikbAKbv41CjhkcZhhM+QGDFIlSERgcdxNu1t1gg4pc/3Yvs8utbCr3vgrnJ6kGCrdYOyn6WZbLGwIfDm/MX46P/Px8816JZqtEhYBWDAlyAUeA68yOZS/j0Wi6k2M+InFG+cfIawtZL8apqmYrilLYiE8kj6dViyHP5TWEMB2+l0mnq9TqFQIJvNksvlFBMpAFdeAyi/njAzwnbKkUgk1LkLoJECQPj7CXgSMCN/D4dchZl9+buAMQF+smEPg1sBf+G+4HI+YZ9yeIMqm4OwlDXMmAlQFumw/F0ArgAv+SzgOQl3+PMBNTfC0n5hUcMFmnCqtpxfGLCHCzIC8gXsyPUJ92MPg3QBguKnDAPsi35jGWthSuS8xUIhKoBwaKDMC/muYetAWPYdLqjM53NVeJDzEgZPwPzFXAC5BuJDFGYnPDZhgC2FiLCSRMZf5pew8+LbDRdeZMzCLeBEMRFOb5c5Ffbay3eQ7/FVPkR6KynmEjSVTqcxTVOtK1K49LxlqrgkvYsMtd1u8/DhQ956663n1h+Zr7KOCEgUwDiZTGi1WsxmMzxv2VpLCmUy9wXAClADVBEzm83y3e9+lzfffFPNLfGETyYTADXXCoWCCklLpVLcu3ePra0tBW6kEJrP56nX6woINxoN9dnxeFy18ZLCgvTUloLU4eEhyWRSvcfR0ZEq+BWLRXWfrKysKDm4rn+ZpF2tVhXgkYA5UYzIXP7888/p9XokEgkajQaWZankdFFImabJ48eP6XQ6imGWMR4Oh/R6PcbjMcPhEEAFR0pvZymIyff1/WXg23w+V/f1fD6nUChQr9dpt9vK/yxFs+FwSDabVSFyIpGWdlXC4gtIbDQaFAoFZUm4cuUKnucpC4C09UokEkqaLuuoyMDL5TLpdFq1I/M8T/XD7vV6qjAdjUYpFouKxRaJvgSyVSoVTNNUvdvH4zHxeFwVHYWZlpC1tbU1Go2Gap0mOR2yf5BxMAyDZ8+eMZ/PefTokSpcuK7L5cuXVdbLzs4O5XJZzXdd12k0Gvj+smf9wcEB3W5XJeCXSiW1fxFft+u6FItF6vW6yo+R+VepVHjy5AnpdJrNzU3W1tY4PT3l3r17dDodisUi5XKZeDzO7du31Z6kVCoxm82UWuArf5gj8HPLNmGYTLAxGJAnxRELdjHYJkWTOE46Cese7rgFxRGTfI/I4VM8s8oPog1etvL8CjOiJLGpYNPBIY1FjQSPiDDCIUYy8JhxDYu/SocEZ9xnbsyImA6XggwxHPyYi+aZRLwIhpWAgx5US7ipGvN5QEeb4EcGvOa0+JvVI9560yJ3KSBaBycH7X2YfgbEwNBBy0L5Bqx/HVaPJ6T+3TtoD14iblc4W+SJ4lPEIWBEkRb1VBfTT/KyeZkEDuVCjxo+8YJG/tsBqzqMBxNSu5C5Cq0N2Bp7jI9OObRipHyHWmSCeavP0cMDvPltIuxR1B6SDPKkyLKCwcyb0+rbaKfgZiCWhaoPXQeisyzlwCNjjJh5ZUwthrvexM3Ax48TtEcxsl7AqhnD+l9dyp5HLjtAu31GNubjPIKJA24T+ECnNYjhvGhx7a8FmE3oHsL8wwjDSRqSQxY+nFmQzYDuQqQOby9gcQorf2WGvwN//L9lWOzr+JqFFmjMM8cU3l5QfwNaI5g+A/0siuEWidNnyB5ZvbP8TnqUmV/AwSfNgNTTCK0zl64XZaavkAtaNGoesw0Y5pbsdfEF+Pb/4LG44+EnIXoEqQSYWZjMIOMuf5c4REaQXIXSfwvpKfSnX9SUHhrkyTLHoEmCDnE0KiSYU+x6zA6GGK9A5LUA690oo+ElptSAJA4mPgkapNG0PeLpM8a2Q9Q5Rgs0usQ41Lr014DcFtHzBlP6aIHFwoxwRmwpf/eekiraVN+aE6nC3p0k3SBNYH/Eip1iTJ4UNjfYBGuGE0x4M2iwSpG4N6PrWdgkuMw6YNKlyWO6HDEmQ5Kqt8a5VuIz0lSJc5UqDhYNTiizR50qUwJM7pJCJ8UOL7pFJofPmCaybJ9v8VawyhGn/K+NO7Q3HhNsONBYx3h/jcvHr/Cqn2KFGJ1FkXeYc6DN+Gmo7p/rXads4IQZ/El+XdnMCAMW7sMZiUTI5/N4nqdAaRAECoAKAJnP55imqdqBSB/Tfr/PYDBQDz0B9LLRl3MJn5NU0iUpdmVlhVKppMCESMjlO0o1X5hHkTcLWyHSawHFsqkRVkeq4gJYs9msAiFh+ak8eMNABr4EfGHgLu1RBMCFWXb5b9mYyPcP+31Fkh32uoXZeXmdbPTkeohPMsxYynvI54bZMEBdh4themGPqrSZCRcUBFSE2f+w9D8sT5b3EaAqHsEgCFRychh0y5jJNY3FYmqOyvcOHzLPRc4th4yFfHbYXxsGq8LqyvuE/dbyGgHgAqjFtiGb6HAxJ+z3FxBeLBYVQA8nr8tclLZ7kugbvoYC1mVOSmFIWO5wkUXGSsZR7jv5Uzz8shbINZHAI7nO/yUEqbmuS7lcJhqNqhTsVCrFeDxWLYdESi2BU7FYTDGX4nU+PDxka2uLnZ0dYrEYk8mE6XRKs9kEoNFoEI/HWSwW9Ho95vM5zWaTVquFpn3Z5UF85WJrcV33OVmvMIulUom//tf/Oi+99BLFYpFms6lkuScnJ7TbbaW0WV1dVbaJYrHIG2+8wXw+5/T0VCWxw/JeqdfrCowfHx+rooPjOMrv3O12FQMq6h0JRAuCgPX1ddbW1lgsFqro6nket27dUr2iBXQeHx8DUK1WnyuWlstlOp2OkvKm02ksy+LRo0dEo1EKhYJqdSeWG1EDnJ+fq3Xu8PCQ2WxGIpFgdXWV2WymWrMZxrKvuaStC4srAV6lUkn5pY+Pj5VqaDqdUqlUKBaLit2VtotS7BIGWrzZIhU/OTlRAZa5XI7d3V0+++wzGo0GW1tbqiDZ7/eBpTd/NBpxdnamALjcm77vq4C7TqejinGTyYTBYKAS1VutFplMBsdxVCFcioDdbpdYLKbGrtPpKJVDWHKv6zo7OzvKeiAqiclkQqlUIpFIqHVFCoXSlvTGjRvcvHmTjY0NBoOBKjzIGK6vrzOZTNjd3VXzS9qUhvMmxuMxjx49UsoQXddVcSdsC0gkElQqFfVclGeKBM6NRiNu3rxJvV7n/Pycra0tLMvi4cOHqvgrz1tZXy3LotlsqqA/XdeVxeorfaQMiLpLmXkhgj15ytTVsUmRYkyKDEPAxsZ3lhJXNqaQmsB8QGBGoVNkHsT5gAW3WOMyPaLMmeIyZU6TEgFrNEgTx2ERDOixRpskn9FkjzZRW8OOJOnoGXb9FOnYGbpuMR1PmCaiUMxCLg66Q68fkMTk694x/+dqm5e+blJ6GZojmD8DIwqne9C6B54NiSys/QKkXgInAaXr8Pptk/n/80MS7xVY6a3gBhmgTVxrU08t2HrJo+ialD7ZJx23iFV9XAfyWwFaBjo+pFch8iK4VegaEPkm3NwfE5zBeqzL6hgWr8DQO6Z/Z4OeATcSI+ozjQVxUkB7rnN6VAPXpbbTx3bAMiGehtJkTtdMYAc6eSwy8QlmLODOoyRPJzdwNYcxNmMtS8m2qRX3iH97znAGZ3c19HFAtA+HBzFmrTKJwGW1aXEygLNtKAwhics8fUQu5xN4YM2hnIXYFLoDKBUgsgPWNpy8G8H/9HXMwGTGE8oYFFf7FN6C0Xwp7bbbYGRdnNGIwLNIM8MJIozwKSRMfHPKiV/ijCJz2yaXGnE9PWM0P2BlfcHajYDDJIwTEO3BhgY3b4BVhbNj0J5CwYDTWzC0IdqFbHY5ZnYbsg4kSzBJwOAEjBMYGhYtOmSoEDBiToQmMeIYZFyDbm9ONLDJZWGS9JgNDboEFNBZw6BCAodTZsU/Y2d3RmcBk8mI/kmDUz/BROuDXiTeS7Btt3B5zEE7RWBf4QYeefeIze0WN77rsXEJ+ia4KZ8VkhQokaTEnC1qHHGNIZf9EgMGrPGEPDl8XNawiVFmSIofMeMe+3Qip8wjBhtmjXVM/GDBhBzP8HiVBGtEyWESx8djhgtUSeGySQed7/o5Xjy8yqe43GKTHjb/y8pDhq8sg9uYV2CwSXSoselFcLG4R5MVqlSI8czQ4KeIBfq5Bt3wZUhYOPTnItC4KCkNs7kSuGMYhvI2Ac+1EwsHWEmgi0jRBJTJ58t7CqgTkBkOhsrlcqoyXiwWVb/wMLAQYBdmk8NgRzawIisMg+5sNqu+t4DucDhVWKYt0mE5X3mAy+ZCwI3Ivy/KcuX/hZlV4Lkxu+iLDh8iNw8nHofZMECdV9gfH2aX5Qhf9zDgk/cIF2J+0iG/d1HGfvGcw6y5nM/Fz5LxELWAzAfZTAPPFUzCTHeYiRZGJ+wlD3+WJNTCl6A6HG4WPlcZ7/D3/XHe5rBSQ97zYu9yKcAIYC6Xy6qAI+oDmX/huSBjEN70hcG2SGylaBC+j8MKg7DqIXzPheeAHGHppagZfpxt4Kt0hFUB7Xab+XyuZL+XL19WEme5BgJOxR8rYENUK61WS/W0TqVSKol6b29PzV/LssjlcvR6PQaDgZIwSwhWKpVS4GdlZYWnT5+qLhPS+iibzfK3/tbf4u2332Y4HHJ2dqZ8zqenp7TbbXUugAqzGg6HuO6yB/LNmzdZX1/n5OREqZAsy1JJz9lslo2NDTVfZ7OZ6hwh/aalmCSBXLu7u8AyXEvk6xsbGySTSXq9Hqenp+q5IdJe6UUuxQspkGmapgoXUvyQ6yU+Xbm3RqORUnAdHBzgui5ra2uYpsnx8bGSuKfTadbW1jg/P+ejjz5SSoXV1VXVXkuKcfv7+/R6PV544QXa7TZPnz5VzztJtpfrKGMjAK9arSrmWzzBcl/lcjkymcxznvhLly7x4osvsrW1hed5KoBNOkvouk65XEbXdcUEh8PT5LtLb/VOp6OutectW79JkTDc4eDw8BDXdalWq6rl22AwUCF0lUoF3/c5Pj5WCeKNRoNarUav11P9ycWyEovFOD095fz8nNXVVS5fvsylS5fY3t5WAWWWZXHjxg2lAhD7zfb2NtevX1fXIBaLqT7xEhYnVozHjx8Ti8VYX19XViRdX+bErKysqPV0c3OT0WiE5y1btk0mE6Uu2dnZ4c0332R/f1+pCORZLeqhVqvFZDLh/v371Go11dZMnkFf9fURgJkBQRTiURh3wJhjFqtc7Wn8VT9FnzEToEgUQ4vgB86yj1OsDKMGXuEQtDRGy6CHxfvsMqHDLn9MCpdV+pRosscqGjoOCyzK5NnmM3x+qA8Yaz5Vr0DONvE4J0qZ6axIF48VMqy5Pk/qKYgP4WxMLEjwujHi71w/5q1f9hjl4MyDTAa8I2g+g7YObRvmrSzEF5STLvNPYRgB+1vAJbj+dzxWv96j+Wmf8aca81GAvR6QfAHcXUjbsLneJR5bhnbN5pBrgF+EsQl+BnrlZXiZu4BZGap/E269C5UqGHMYnMHGpkXK/VO6lkdzBLG5TyyIk2eB48PQzzEACpEhcd8naOtEVny0is/kpMwUjbQxJiCCsWCJSOMFDL9J3o2S8WGqt+hen2Oi8fCHm7jA+kuHmC14dF7Ao8Ja5JTo1wL8qxA5gaffSzA6zBLTZzSKc/I3l3l6Mx3MKHR+EKOXhxe+YdN+AE8/yBOjSTJ7TCa5wJrHyOnQvwfzR5B9BvE6+MmARGxG25oxnUSJuSV6+FjzOYYxJ2f4ZLw17HQL/5WA+EnAi4czbm/6NG7CfgCzMWyllmN4PoZMHKraUko+HEL3BNwsRDRI7y+vyZkOpTLM29D+EEZ3wE2Dtx4wGY4JrDVSQJU5HTT29aUq95VZhOqhzaNHUQ47SXo8oUCDIgErzPBIcp8Fs3GKdNui/l2L8ir0ftuj3quDv8A+jpIIJtRpcaS5HGs3uEmZryU+YPevtdn+Lqxsw2APrC7cfNGkv3+EvbjKBIeits+t0h2u6wtSizpaqkUs5zBfaAytALdfJevnucecH0Yf008/gCBJxtqkRPyL+EKdGiZVVjCYkOBj6kwYkScAkliMiTFA45QRRVy+zgZ1dI5J8ZHRxQ08Mh9GCWK3CZwYZnSEudHiR4sZu80NrgQaZVxKlNATNt5PEXvxcw+6ZSMflizLZikMXgXMycYmHMAlPjtYSr2ENQ8zQcJSzOdz1fdVNnNh4C0PrfDGPiy/TiQS1Go1SqWSkphJ8JsAE6k0C9gUwCNVbjk3YfxkoyG+XunfKd897BUOgzUBS8LMih8+/HlS3ZcQOvleAoTCwV7yvuENeNjLHQZMcggok01aODhHvr+mfdlCJ1wwkU2dAEdhq8MgOMxoh4sN8tk/CZyH5cwXf0deGwbdYY+1fIaEvUnR5WK6brgYI2Mm6ejyp8wtAeEyD6UYI2E44QCx8GvC5yi+64tqEOC53wsXHOSayP0RLnwIgwbL4sHKyoryjYuvUrzsIm8OM/Yy90TiKcyR2B3CY39x7kiBCXjOUy8smawFUniQe1I8mMLYfZUPGXPLslRQYyqV4vbt26ysrKggNQFWMmfleoQ9nc1mk06nQy6X44033uD69evk83nV6krTNCWTjkaXvaClF7EAL5FB3717l/l8Tj6fV/MkLOV97bXXuHbtmlK55PN5IpGIsgHJupzP59nc3CQej3N+fq5kyLImNhoN5VMVf/itW7cUIy/gRXzKwgSHmVBAFX9EPj6ZTBSIlfZQIsOXdSwajVKr1dT6FG6PJmy33PMnJyfAEsw3Gg16vR6NRkOxualUil6vp/zpnudxeHiIrusMBgOq1apirSeTCe+8845ifEWdUq/X1fgDz1kBhFF2XZdLly6pEC0pGniep0L4JLhNFFJhm0ckElGBprKGP3nyBNd1OTs7IxqNMp1OuXbtGoACyzL+ooySntjZbJbZbKYKBeE+70EQqD8FjIvcW6wRQbAMb8tmszx69Eg9q46Pj1Vqu6gRDMNQKeVvvfUW6+vrSh4vCgfZT8j5xmIxlfYtig4pcty+fVvdVxsbG7z11ls0Go3n7Dby/SeTiVIAhTMqyuUy9XqdVCpFo9FQoW1iV5BgN9mf9Ho95dOezWacnZ1h2zbj8ZhUKsWlS5eYTqdUq1WOj4+5c+cOuVyORCLB4eEhV65cYW1tjcPDQzzPU8X7r/RhmDB3loFKmTSGV+aFUZrf8LdZZYrLIXWqjOJ9nJsziBgwqMA4R+Q0gZfwCMoBs1nA/WmTo6DDrSDGf8NVbnJAzjgkG3EpOlO0QGMWVLG4hs4ah4zoxsYEuos5j3GNXTKcMMPkk2CDGQsKBGiasWzaPHkCZpKcMeKb222uvu4zWwcNyGtgGOCUgNkSMNOH/OaMjb/hE78ErX8DsTgsbsM8AkYWEl+H8u2AfD1g+Bno34TVbwMJCGZQ+RrYDmhRSMxgakM0/wX4i0KmAB7gRgEDztbBuLJse17LQ+Iz6Oeg8csewR9qdIZR7CBCQJUoJjV8YvTQKDLZr2EZI0wri+VPiMdsNBY4+pwTMmDuUOo9YSe14GA+w9QbxBmwzpRM4NN7Cv3HOi0/h12ac/hYQ18ETJIDkosyaTdLKt2HKQz+VZL546scMmPTi+JVTOZf8xnryxTzeRRcN0XiKM58p0XQg9SsjhsfcOnynFwWZnELpwKjFngTyOVBn4KzgGgCYgEkoi5Rf4TtJ3GpEfEHZIwZCWz0pEm0DM1nMRyzyvmdIVFvTv7XAtwXWALkCcRsyAQwDZbkKy0oNqHyddAr0J0uLQQLAwZzyPbBOoLAWradDwxIb5nMz57gTYrESZBhgs6MCTZmPCC7BY8eJJi4r+JxyIB9dDLoDDliwo/oU3Q3KRxtM330KW+8bbKxOyXS62ERpR24RPAxKNGPlGinUlyyZ8RqNlt/DVJZOH8AemTp5FhZD3jpW3v0/mzOLPDZuNzirSsu9SIwOSKIQ5BbyvWDjzUmQYEpl3iIwcjw0BYuKUfnBb/EFnUmpLhFnTgmqxgUGeNwxhiHKVFsAmws+kyJEmWbJFMCjojyDJ279HjBi/PWeYMZMcrk2WfCH9QfskgPmV11eOpbXDrboswVTrQe3k0P3v/LLzk/16A7vDkP91QWICfA+qJEWA7ZwIjcXLxVIkMN9/iW5FFJvZ3NZsrnLYA/DLLDzKIcAljEtyYgUM4FnvcFC1sIz0ujw/JoYbzl30XGGWZopSAQDpKTcwuzzyLzDcu8w5tIOccwwJRDwJm8Nsy2yiHnEwbTAoxk/MIM68XPCLOsYRY8DBLDgFuYYTnv8JiEAZmMQ5j1lQJNuHhy8VzCbGoQBAroSvKzvIfMkXBbGbmm4l8P/z08n35SQUA+M8zey78Lwx72nIevs8w7uX/CKhHZSIvVQACH3AcyNsLYySFzNfw78h3C3yN8DtLmTD5HNpTh+SOvlWsZHlcpssj3F3ZSAICAfQH6YnmQef5VB91yLxeLRaLRKLlcjjfffFOFJ7muyzvvvKPkytL7WQozKysryhucTCY5ODggk8lQLBZJJBJKni/XKRaL0e/3uXPnDvv7+6q4JFaD0WgEoEKqjo6OVGqzrAkbGxu8+uqrBEGglEdSCKhUKmQyGeXdLRQKbG9vMx6PabVa6lkQjUZV67F8Pq8Ko7VaTa2rMvclbFNaWYmyKawqkYIowAsvvKCYVgHEIomXLhaS3u15HoVCQd23o9FIhZGFg8LEi+t5HrVajclkolh3AccA3W5X2VIODw+p1+uK+ZT7U9hOYX3T6TS5XI5CocCTJ0/Uc0wKsp1Oh2q1ysrKCtPpFE1bermz2ax67kkrMbne0+mURCKhbDASsibJ5aIMkLnjOA4PHz5UgWbZbJZ8Pq+KCrI+i29e/k0KwfLskjRw8S2LTF6KDkdHR8+1BJNwNF3X2d7e5uzsTDHxvu8re4QUpjY2Nuj1evzZn/2ZygYIr5XSpi6RSDAajdQc/dGPfsTR0RHZbJYbN25w+fJlXnnlFdXeTLIKpOAnqhPXdVX7NUlVT6VSvPLKK0oqLxkM0m0grDyT+Sb/PRgMlP2hUCioIslisWBzc5Pd3V2CIGB3d5d/+k//Kefn58/NFdu2SaVSlEolnj17piwAX+kjF1nShRRJuFG+Psny33s32cZkwjNsAv518g6fvHwORhTjSRrPq6MtIkRcD7fSgHQPfz5muJNiODnAeZZlg1skiWH6Awi6eJqPrwXEvTwDVvkDjvkBhwTWglLgsImHjsGAOC4aGnnOGXFMk6NGFYodIt05bjzOTa/Lq1s+wRr0AjA0iOchHoPy65B5HXot8K9Cvuaz/Rp0gcGtZQ9rLQ5aDAYTcH1IlsF8Y5nYXboF/SRgQLYAgxoQhbEF4zH4C4gkYeGC6ULZg7kNrRj4LvgarL0KdKF/BpEtiBVglgS7m2DurLLQTogEPY6p4XGFAhM0WuAmGLkNFiSIzSpEzGckk+cEdhTTy5AgjztZYaW6z9fcfZqLtwgIgD6JoAC9Ce2Yw7TUQ7NiPGzW2Yl22EZnhAOxMbYHowmMJ1Gi5KnTJxcdEr/h41XAeQy1MRT7MCkO8W2DjgXlV2Cle8R07kMN5gnIroNjwPgZ1EqQSIL5DLQhTGtLWb+WCJhiYoxNFkOYBToRN4XNnJzhMPhz6JyuMieGM9FIvJcl5p0zL8FeAYwBrPmgH0AQB7sMk0+XBRbbAyMBdnIp9/dMiJ3C2SeQqkE6D9afFhj5AdXfGFF8YcLxf/wca36ZLjp23CC2qDMembjXDmkk5zT/6Sm5aRaHEi4zpto9joMGQxIUaRLlOoP3XuFHznusOBYZ2kzY4Aid17BYxyXqbHFjUCceeUSwMqP/h/Dn96McDQ2yGzY3XvO5vAGvvO4xjB+TbEO1vJyXC3sZitcewuJBHHc/w6jvoePTY0QPj4qZIuBNpoZDixkBA24Q5To+QxbEGKKxwCLNlCwmHhYtppQ4YgUdnSuMyXKZU8osaHKVA17DIs8cnwW76PwTDrCMI2gCcYtFscZJO8otr4qt+VA+/amWnJ9r0C0PUHnAhgN9hGmVwLOLSZzCAAvQESZSPNvCekgQjzAU4lcTeeNF4C0spGwcwkBJNnW5XE4FA8GXoFhAufi3LctSoE02kcJICWjPZrNq4+f7/nP9ssPSZc9btrYR1lqArrD6AmZkkyObTkBtSiRcJgyG4EsAK0x62A8tG0KR1AHPASWRR8s5yfvJcVHuLWBNPl/YemHBAXVdpeAi4DMMIOUnLHkOf6ZcGwEMYSVFWKYvrxXPsq7rqlevMHTCvgkTKJJW4LnWWbJBCs9L+Z7yueGUeGH0woUaOeRayHuFCw9h2XG4WGQYy/Z1YoEQUCKbN5Eiy1gmEonnii3CTMr1C0u/wz+A8tKK7FYSiGUuSYFIxl3mk4x9OBBQWoVJMJHIY6Vtjm3biiELZwfIuXxVj3w+T6lUUiqCa9eusba2BkCn0+EP/uAPePLkifIUl0olBoOBWq/m8zmtVovhcMj29rYKpnrw4AH1el318h4Oh6pQc35+zqNHjxRYy2azlEolptMpp6enCkyFi5kSnBWJRHjllVfI5XJKMitsuawBohSS/vECIKWN3XA4VHPU8zxms5nq0SxFRECx+uG8BynGSJFmMBio50A4c0BAm3iMo9GoYnJ93yeRSDAYDOj1egowCciX9l5yz0lbrnBR9eWXX+bZs2dEIhEVPifjK8+UyWSC53mKmRcVQyqVYmNjg/PzcyqVCru7uyr5OxzQmc/nVfq7JG+PRiMKhQKDwYB+v0+n01EdOTRNU1kS4lmWdmvil5bigbSfFPWAzAE5Dg8Pefnll2k0GrRaLQVYZY3L5XIqOFQKfNKzW9qzyX+LXFsSzqWVW7PZpFAokMlkOD4+5lvf+hbj8ZgHDx6o9V3WUllfpCADKBWPzNtaraYS4GU93djY4MmTJzx69Ih2u42maar4s7Kyonzg9+/fp9lscnZ2RiKRYGVlhWq1iud5DAYD1Us8k8lQq9VU+J2cnxTCZH08Pz9XypLxeEy5XGY4HHL37l06nQ7xeJxf/MVf5Nq1a1y6dImdnR2lDhmNRpycnKh8FHnOJRIJrly5wtHREf1+n+Pj4698URIAN4+2KFE+y/NLwzj/FRvsogFntPH43/Uzvr/9DDuZJPppgeSgxLg6INjQMAMDVsYwfIjmuATOFYgX6ZZnfNg/5EpwlUpQwrOfMqJLBEizyyFR/pxH9LQJulalEaR5EZ8xAR/jMtY9cuTJ+/Fl0nIwAMvBnWUoTDVeT/rkcuBXIGEs/cSOBpoBlCFegOoGRG+CF8A0DhF3GdRsmuA5YI5hyJKxzkyBOiQaoGlL4DPRYKGBGVuy3DrLPtjo4EfACsBxYDRYSqAzKRhFwTZgmgM7A3oNcm+B5SzPM7rrEGn7xMiQwGXAmB4x0iRJRxZEmeC620TwKGpd/LiN5xskvAK+McbzHxEEW2juKW9sd3h88D4jK0PZr6JrDtENCz2mg5cimMaZYeJlfFKWQdGJUEk5ZAtQ1kCLOxyyoKJrXNpYUC2B0wbDgakFOQ/yV2A0Dhju6ZRe9bn8jSnjIeSvw3AEfRs692B2N02sPkOrwKQCuMuxSZUgrsOsvWzvNU0NMOcRUkGJObBIL5lohyllPEq5CRg6iS6kHoLxDTAbcNSG2DEUzkG7AtoLoK3CUQXmGuR0GPsQjYMZwECHeGqZvD7MWCQXAUEA8Rcgf3KO9UGNHf8KU6eJQ4GYWeLosxOu/Z88+uMnHP2bApnxCnHmRJNj0q5P1LmGF+gkeILh5uEUCnENlvntWDxjM/2MQsYi1ZthYzO98SkbWw5P/mOeR+MtjtDwTx1ak4fE/orPShniDZg+1Gg/1jiLwqmdIOnrrLpxqrPbeBQZ8JAcJgme8hINClR5qI2wYjA0o1wNDHaZkOYhFjY6a5yxQMejzzozzqjh0yPO92N7DDLH7IwifMdLsEOfl+gDHVKcAilGRDjlHIsGhtkmHnmCHcSpHBdZ967wPf2IM20AH5z/VEvOzzXolg2NsF4SHCT+Pam+h5lueN6TG2ZvZVMi0jyRWIs81bIsxRRIKNuPY/HgS+AmG1hJBw9LoMOsKKB+R6TwYWY27NsN+7LDbKzIvn8cqxhmZMMM8EW/cvj85bUiJ/R9/zlGMsyyyhjK+19kOOW8w/L/MGsfBn7hQ65P2DIgr5WN78VzCPuf5ScsDwyfU3guCDt7cW6EmfcwqyzjLt9D2GyRbMrGLgwcBSiHfdrh7y+fG/65yL7LRknOOVyUCM+7H+dfD7+HjLf8jlzn8E94rC+qDGRMpLASBjRSZLlYmJD3E5ZbvNzymp/kAw8Xx8LWBpGnytwMF7nCc12AWzg74KsOuh3HYWdnh9XVVWUHSCQS3Lt3j3/7b/8tH3zwAdVqVQVKydhJsarVainpsQSpCZv97rvv8vjxY8XWbW5uUigUuHfvHr1eT811aVMm11/CDU3TZHt7m2azyfn58uH10ksvsb29jaYtw6aEBR6Px2iapuTX4aJYoVBgOp3y3nvvYVkWL730kpLFJhIJ5TuWHtGy3oicWdRBQRCo5Gr5f/P5nNlsRhAE6ndkLmUyGeVFj8fjXL169ble0gKwRaYtfmgBO9ISajqdKlmwsJMrKysUi0Ulb57P55RKJdLptEoeF/l6OKE7CAIGg4FSq6yurrKzs4Pv+zSbTZWkPRqNVFs2Cdir1+vk83nlx+71euzv76tn3rVr15QawrZtOp2OSsEX+bkUB4Wdv3TpkiqCb25uqmA60zTZ399XbazS6bQqcAAqjVysTsPhEF3XWV9fJ5lMcnZ2BsD29rYqIoxGI1XQicVi6nmZy+VUb/avf/3rpNNp2u22koffuHGDp0+fqnm6u7tLrVZjdXVVMdDJZJJisYhhLFu1ua7L7u6uKoZns9nn1lPbtslmszx48IBnz57RarWUOiKTydDpdHjppZdUMUzS7i3Lot/vo+s6tVpNZSaIFUTk5PI74vefz+ecn58zGAyULeTg4IBbt27x7Nkz2u02a2trZLNZVeDa2NhQdqDZbMbt27fJZDI8fPiQ09NTpX740z/905/1svUzPQr3HW5Nt/mvgzpr+JS/CJi6x5x/p73HH+YfYsZW4PMa3jzPpKDBmgZRE0YOdPfIRY5JVj26QxOvehv3cpz7Twf8zvCEG24OqOPiskOVGNv8Kce0Iz3wHfJ+kQgFjvHpY9OJ+UyvOvSCgOrDgOuey5OmRWeRZ6U/42tejK2cDmmPbh+CGJhdGL8PWhGK34SV+jK1eh6DuAmJErTH8PB9sHuw9hK4JTCAeGLJePtRCIpgW5DSAB8WFngLCHSIxmAeQG8C6QiMLIjNYbMPkTGk18BJQlMD11sC+5UM6Cm4a0EqDte/7ZJ40qLVqzPAI0aPCAmmpLFdgwTgESWidUmX+swDWAzSzEjQ9S2igU+BBboesLIbULx1TmuiMb5zzjzwKL0SUN2DztMYsUWUQtSm8lpAyZ0ze6+JkbWInoB+D1KTBTn9HtWCzc6LAa4OnSaYKWgXlsnh/gKeTqJErQj7/25GPQu5W5BJgvMZ9AZwcGxgzcuMLZNrBQ9Ng7gF9jl0PEgnlwH5ngY5TycISmiU8LQ28RcDdosQ6fRwHY3Nmz6JMsQd2DqG/WfQ34QrNkRLMLgH84dpeM1kc90jNoNeAtIubPXBN2C+A+kcmO+CnoSV/2GB/ymwtwxXC2I+KW3OLVzy7pyn5Bh7a1jfW8W5eczmrwUUtAGj//SfMB2IVQNems/wj2b0uM2ch1zaeELtr/isjMA4P+bKbMF69oDSjoWRh2r2MV7pCel4gPOewWRymSwr7DDBDlyiz8pYb3TIrMPnf27w7EmNsyDHMzIc4pAmwysYvI5NAZsEFVKcsUIbiwFTkrwQ5EkuCpRZ5RIaG0ywyeOi0yPCKUl8tpmSJkeOGau8q3kcNpoEmyM+7dVYffyIF7wk+zi0CVhngywx4oyZcJ0jbQUn/YTEOiyebXF19gpRMnxy9R52/Bnxz1f5aaJ4f65B96VLl1RFXACyeAmn06liA0SWKpvyMMsrDIdIT+Xfpbdo2Ncq4DssN74IumVjIox22P8mbIR4sjqdjpLzWZZFoVBQ1fRcLqe+p+M49Pt95fHVdV09RMVDFwZ2woYLsysMiRQOptOpYl/DfmGprEuglYyZYRjPpemGQ7LgSzb6osRezkl+R95LNkbh14UZZ9/31aZJQJKwmuI/l2soG1ApYoiHWIonIukW8CDMrTCw4UKGgDBhreVcgOeur7C8IkUV2aUkDYtPtFgsPpe+LWBGmGbpcy2febFQEAadssmSVPTwtZAjXJQIj6EUE8KSbgnLEnZO/p/4+jOZjAIa8r3lvMWPKp8hQUoiqZXrnMvlFPsum3G5jvKn5A+E1QJSjAqrU8IWAAHPwnJK6JSw9HJdTdNUVhABX1KACbPuP8vjH/2jf8Rv/uZvPvdv165d4+HDh8ASjP6Df/AP+Bf/4l9gWRa/+qu/ym//9m9Tr9f/0p91+/Ztbt68qdo7eZ7HBx98wO/+7u/y+PFjNQ7iUXVdVykcTk5OlKIhk8kopkz6p1uWxUcffaSk2/1+n83NzeeAerFYVO2dhL0TZrhcLrOzs0Or1WI0GnH16lW2trbI5/OqyALQarU4OTlR3uF8Pk+xWARQxR7f91W4Wi6Xo1arKRWMqB7kfpaij6zRsnaIwkfmnfQrHg6HKuBN05ato5LJpAo3k24KwlSKkmIymSi1jQA8USjJnBwOh0o5FYvFGI1GrKysqIKX9NU2TVP51e/fv6+Cua5evarUMb6/zCaRwpSwm2EftjwHNU1T4yUJ14eHh5TLZS5fvkw+n6fdbjMajdTzRdhsyT+R4qv442U9ksRz6TZRqVSUhFpC1/r9vkqWl2eVyKcPDw+pVqvE43GVryKFBlE3SBuynZ0d9vb2lDpD7m3btimXy6oAous6n332GdeuXVNheMIw9/t9lWAu3UmkUCFsvxQTbNtWz3Epxsh5l0ollSNw9epV5aUejUZ0Oh01n2V+y7otn7u3t8diseDGjRuqNRygZPyi2JBCv6zBsh6vrq7S6/XUvEylUnz22Wd8/PHHjMdjdnd32djY4Fd+5VeYTqd8/vnnnJycsLm5qZ4pp6ennJycEIlEVOH4Z338LNdHgL86uc23uMkOLmMG+F/4V/9x9AecxT/Ejvhg1SATxS9ZaP0Z+mEOPxWDzDHR6Alxw8PJgJ6Z47kBzGM4eoRHSYtHxmcQmZOYWuyaEXJk2dfaOCWf+CjFllVgQpo9BtiMcNIBGDmivRirfoUd4LYbodsJuI3GltajUPPwgyWA1iLQ+qHOyf0c0fIIJxKQr0FqBaIGEF8GLLs+tMc6nQdptPsT6o0lO1qMgPNFb+rEAoYezCJLn7gbBVIQjcBUg0kKFh0wXIhaS1+x8QCG59CtLuXpkTisrUC0AnMXMglYy8BebNlWLPfaHOuTE7RejImXwtEmmAwxAwOTLDpzEsGc2QJmJRjpC857CxZBgRgBY/qsaA5RB2KbkLwZ4GxOmRnQ2YR1zcd82GOUMKh/bcylyxDsw2J9jA8MfhjDnQfohsNObEF6F/QVsFn29HZdiAMpHw4O4MxKUvcLnD/KcxjvUlk4XDoIyJvQPtEZdhtkdJ943cPfBv0JDNoRTCsg6ntE5hD/QjZtm/Evur9rFDUgB3YaqtGAYRCgZyG6Br1j6P95jOHcIfHrAbM5FPOQLoG9t8Xh3RaJr/Wwc2BMILAhOlmOvR1feqYnx1DeWCbVN11Y/EdI/3sddxEhMI6wM01qlsvY1OmTYdgusP8vm9T/jselTTgmwjAbkLvq0/9UZ4MsOgkmbNJ3emxvmPgl6KcHdGZzgoWP/qSClZyT+JU5pdsB8zsQDHzS0UNsjilFTSKORz1rc80G5yGMj2OMgiJPyPIwFsX1PaJuERubCF0gygKHBSk+p4HDfW6zIMcraFqLwPgjkoGD7mcYBt+hzy4TuhzRJSBBCXBIcMwu3cAh1h0RjGMk/CwZL8cHJPkPkUPm+oIr9iZfw+TXKPOMLT7X7oG/z9SpglvnMNB5GD/F5gAKZ1irWTj4y685P9egW6R1AigloGk6nSrQfdEHe1HaLEeYbZTNaBhU/zh/rRw/TgItwEw2JmHvaliCLd4ykVeG2cHwZwtgFrZGGJYw+BemNQyMhW0VABsO8xHgLWBegtlkwyTfA76UWcv7XUyVDo+F/Cm+QSlchGXZYaZb/l2+swAiYaXgyzR52exdHPuLUvGwn/niT1gaHvawS3El/BP+LuFzD8vc5fMF9MtGV66PjGf4WoXn3EVGNuyHDzPuP46lDisVwnM9PBfDqoSwHF9+RNYa/m7ha3vx+obHXL63gAM5d8Mw1PwP32+ySZS2YmH/efjayU/4Pg378eFLZYVYCATgh9nxsEw//BMuqPysj1u3bvG9731P/T08n//e3/t7/Pt//+/5l//yX5LP5/m7f/fv8hu/8Ru88847f+nP2dzcxDCWKdv1ep2DgwP+2T/7Z4pVlAKgFK+kX/Xh4SG5XI5Op6MA3WKxoFarKcuEMMez2Uyxo8PhULHHUnASBhJQWRnlcpn19XXS6TQ3btzAcRyq1arqxiBZGsLcCrNn2zarq6tkMhmm0ympVEpJbOPxuJLMj8djLl++TLFYVPejhMbJ/Sprovixbdvm7OwM3/dVEWIymdBsNmk2myrY6+zsjK2tLaWwWF9fp1qtKtmxeH6luJfJZJT/V9Q60ipNAjSFJR6NRsxmM1zXpdfrqRTvfD7PxsaGes+VlRXW19d59uwZo9GIVCqlGOdMJqPWeil6Sb9neW7Ic6JcLhOLxRTwMwyD/f19Xn75ZQUyC4UCV65coVgscnJyotKwV1dX1bkL45rJZKhWq8q7LIA9CJYtN3Vd5+zsjMViQTKZ5MMPP2RjY0MB0SAI1Hfd2tpiMBgwmUxUK6zJZMLh4SHtdpuTkxP1bJHiugT7BUGg2PHxeKwUDPv7+8prvlgs6Ha7aJqmxn1zc5PBYKBapB0eHtLpdJhMJqrI7bquKqgDao3L5XLM53N1/Xu9nmp3JutPpVIhCAK2traIx+OqF/twOGQwGDAcDlXBQnrIS7FFpP6ZTEb1PZcCpxQvrly5gm3b6vwkkV4K5uPxWCkXTk5O6PV65HI5xuOxKs7Lten3+7zxxhv/X650P93xs1ofAb7BCpsEDJlQZJt9Pud/SvwbPl/vorc0AiO1RK8xD7QYW70iDbvOJ94hViaPN8gxTNo4fhxjkEJzMwR+gfVOhHhQoqmZLFJT5pkM545DzBtia3MMU2PHKdIgyoQRUTxiwGSawT3MURiXWQ82SfMpt7QjnACq6KQrIzLbS3AVpCEYw6Cp0zd99LaG/XFA7RdBq4A/W7KdvRlETyAx1TmcbXLyP/b41vs9cr/uYL4OcRfSGgTOslVW4MFCB6JL1toPIGJB1obU+ZJZLWvg3IfufWgeQ3OQJJn2yUYCenmHrVcC/AIENSi8AGYVnhXh1hpkpw6JmkP0bIEe8clEYXSWJvCjRNItjMBlOovgrrvEcz7RvkM2GBDgMSTPbK7hnQb0Dg0mTpJsbYH/XY/xNqxFAuJai+MduLwOvLf0XKcGGuYwhecmyaTHeBWw6pB9DRIx6ExhVoOKBgkbNBesvkbBLwFZ5vhYls/gvsX+6oQX/oZLkIb5Ox5rxQGVV6BbBvc+dMwCvm+zypiYDXkTIoHBCI0MI6rYzGImZ0mIrSyD8HOPYX68vF5nx2B2GhTe9dBi55y+4jGpw8p1CFpPSe5a9C5DdxsYQGICnTpMv+hoF/kUhp+kOD3wuW2YxG1op5aqhXzKJVvx8RcwOtbJMwKGHAcmsXs6sd/18L8G3ellWr1dupf/A1o0QpcUFgMCNumNx0z279Pvw2G/TIcME3fCmrtObuHiPXxA8IpP7huQXA1IDLtEZpA7hPkQsiWID6C/gFTCYoZOmygRzSPqV6hicR2NONfoMSeBQZMX+TdkKZDib2AQj35E9fJ9Gg2T2AKsY5120yIZ/AoLVolSooZDFY8JEeJk+QVaJOdpvHmCFC3ydHmXKl03TYE4Jj4TFlgkmDNmop2gza2lD8P/jKGRYryaguQ5+C7lRYveT7Hm/FyD7lqtptiE4XBIr9dTPVwFYAprF5blSn9RadsUlvDCl6FlkuItG0BhSMQPGAbwsnkVz1+hUKDRaChGRVhECXCSTYQwzyJXFwAmvl0ByRLgJomn0s/bNE3S6bQKdhNJvXhehanyvGVSq/QYF+AtoFt6sIonXDYPEsIkwFEk8ALMwoBQxjfMngrjGAY4AojCknFhMYTdFJAvYyabEWGnhDUG1Oum0+lzUmTZpEqhQ14rfdIFlIWT1oWtlbkhSbwC0sMJtgIChdkX1loChcTfKazuRcuAFBhEnWDbtmKrRDZ50UYQ/lyRTAPPgWwBxBLAJHLcTCbzXI92UXeEpf1ShAj74cPXLixHh+cLFeF7SL6fgB4pPkm2gQANKbDI5lSunXyWjHfY0yjzThQMMu4yTmHViyQ+h+foxfP8WR/CiF08RqMR//gf/2P++T//5/zSL/0SAL/zO7/DjRs3ePfdd3nrrbf+Up9Tr9ep1+sqNfq9995jb29PSY8Nw6DRaJBMJikUCoqlbLVaxONxarWakhivr68r0CSe5Ewmw8rKisqd6HQ6Ckzmcjm1boWl/LLeyZq7vb0NoIp7IhXudrsqYdq2bZXCHS5eyX0t6hnTNFXy9mg0UuFQss7s7e2ptU/OUeaM7/tKDWAYBsPhUCW2S+FIQIvkaEg69NbWlgLxst6EfdvyTJBezPP5nGQyyfr6uvo+sVhMrQHdblf1zZZU63Q6zeHhIbAsXjx69Ij79+8rub2AXlGoCOAH1L0l4Yj5fJ719XU1fpqmqWwFUVrdvHkTwzCU/aDf7+P7vgrgm8/niiUtFAqKmZZclO3tbZWILmuxZJQIU35wcACggsbkudzr9djd3VXrnCibgiCgXC5zenrKcDjk8PBQycFlXZMcB/HzixJD/hTGX4LcpK+63H/iHZesiEajoa6r9DaXVnQCrOW5JMUF8d8XCgVyuRzD4ZCdnR2CIFDJ4BLEJ5YBmePD4ZDr169TqVRwHIfz83NarZbKrBmPx6pHt4BkYe13dnaYTCbs7OwwHA65d++e6gmfy+VYWVlRypNUKsXq6iq+7z83dp7n0e/32d7efi4j5Gd5/KzWR4BNCtRZIYFHkzG/q93lsfYMFh7+mrbUXCc3IUhBL0/WK/EKJWLjc0ZzDde7wl4+QlyDlwfrRDB5ZJwy0sv4ho+jZwiKDdiIMHzooA86TKMeuVmSa75GwIiFZrPQAvy4ixcHohaaNgUSBJE2240W9CNEXYPgkkuwtmwb1TOhsAnuFRe7Z5Gx02BPILZkrB0fCtElaHYcSBoeU31GanCVxQ+alC7vUXh7KR/3I9CPgHUX9HfAB6JlKMVBS0NMXwaoz6YQZMHWYbi/BNydvkbEyqCbScZoWN0emciUdBrO49CNLftcGzEwNYjlIboDxQ0f/wi8GSTTCzK6Seyax9iG+QOfxBTWdTA0Fy9pErOjzD0NOxHQteH4II7vrDFvtYheHxJrwPQ+6FONq/EA6w7c/WODlV4E8GltWURW55TzAdZl6OQgnlky/OMWdLpwPb5sh35YhuQrAevGKZqpo3VjFPwokZUZ3qsueztQKvnsZs+ZVsBdg1xnKbkf6gumToNp4LDx4oL0GIqHHnHHYUKAZYwYVANmBdhMLVPH3RhEPbD6YExhgYc/ucLkeznW5p+z9VehcwO0tEWuDa0umJeW184CUgmY+JALoJ6EIVmG52UO/+Meuxs25Rug7/hkTOh9BM45eC7MsLDpYDNl4SZwngU433YZvdXE/qNvMPr0Glc2HjHWzwn8dUx6pBngzSCWhmzKoDHewWMfnTlDDIrrUN+C4yPwTgxSLZ34QZREL4kfnTAPHKJ+QCoKeS0gT5vLaKxYrzLCx47+AYGXZegXidAlTY40Wa4yZ0KZnrbPrY27VC7b2B04O4jQGqbJBeck+CNSfIcUNYoYzMjgY5LnmCp3qeAxwWGHRwyp8wek8YlTpMw2abY4I02THKuQTFLciEAwpZ/cYiOIMT1rcpTtoj8rsN1ep8fDv/z69pd+xf8fHfKAFI+eePCELXBd9y8EZ4X9nrKpD2/Cw4y3MAIXPbVyhH2z8jsCDgTYiJRWNvziO/c87zmQLBLIMBgOS4zD4FCYJwFhgGL3F4sFk8nkOZ+rfCcB9+HUU1EHCOiWzxG2VkLaZFP845jOizJzkR4LkP5xwCxc6Ai/7uKPsNuS+C5KANk8hf3X4aKFXF+5RoAKDwsXDuR3wqnhwkzIuYW94GGQG54vAqDD3zXcizosrw/PNbm2cg0kmC8MLMJgPQzAL3q2L/qZw0Fp4e8vagFRMsimMvwZP45xDhdZwt/hxylAwuNzUQEi4xBWNQjAD4fHhe85uafk+/04RYps6kWiLgzmxTkVHqv/HMeTJ09YXV0lkUjw9ttv81u/9Vtsbm7y0Ucf4TgOv/zLv6x+9/r162xubvLnf/7nP3FTKUUzOSTwSjyihmHw4MEDHj16pDbhtVoNz/PY2NhQUuPJZEI+n+fVV18lFotx//59Tk5OmM1mpNNprl69yvvvv8+TJ08UgymFJcdx6Ha7Sp4u804YUwGjF+eYAGax1MjvC9ss7HG1Wn2OqZWizXA4VPYCYUTlfGezGaPRiGg0SqfT4cMPPwSWoFUYeZHvyvomUvyjoyPVzaJYLKqe2gLwBOwMh0MuXbpEqVRSCdlPnz5V83UymZDL5VTxUtYtATRyvrJe6rrOwcGBCmErFouUy2VM0+TBgwcqLE7k8icnJ1QqFX79138dwzAYDAbE43GVan7nzh3a7bZK/b558yaNRoPXXntNSbXFErC1tUWpVCKXy7G+vq5UBdLTW0C1PON2d3cVSINlQWQymdDr9djY2GAwGDCdTpnP55TL5efaffX7feV5f/LkyXNFWrmm8uzt9Xq0222ePXumALyEJkpugewBxHIiIYIS5DYYDCgWi2SzWb7+9a/zwx/+kOvXr3N+fq5Syz3P4+rVq5yfn6uw0+FwyPr6Ovl8nvPzcxKJBHfv3uXjjz9W6eqSXZDNZikUCqpFVzKZ5Jvf/CadTgdAWVwWiwWZTIZUKsXJyQmLxYIrV66o+ZVOpzk6OuLZs2c8evSI6XRKvV5nZ2dHBbTJs04KMvF4HNu2VVq93COTyUTtEyqVCr1ej+9///s8fvxYFWdEsVEul/nggw+4cuUKq6urqkXfz/r4//X6CD95jXxIBJ8uOWw+5AkfNh7iebFlLHdjDh+tQXwTak0Yt2lrUyLk+b8El8g797mPye8MowwCmxw+L9JFdwe8c7WFnzXAdZYpZGYRN+MzHXQxnBy6H2VAlBN0zhIafsaGDSA5g0UMY6KjexPcxJRUBRIRl1TeJfc2aHlw9iHa+wKwJSAX1ahGQCsvpdJJD4w8TFkCdE+H6GrA7sNz/IXDrNFZhnJNINaGRQZmLTj4XY3oPZ1MxSOah1R9mcIduBAbwiIBvAbjIRw91pmcRdBxKH7Rz3xKipruktuARRwGf2zgGAG5Gz6dEgxfhZV34eBoCT5ifZgMDXI1j8LGkvU1puBe8UnFIAD8+oxBHSLnHrGTJnoeDufQrcxJG48o2rAaABP4o3d1rMdlSn9sM3ejBF6Sk+ic/rf62H8z4NjQWRsGZOOwvwIVG9p3liB2fgrNTpz8SxalN+HoG7D6poU2hubZgsAHfwdGZRhlobAOwQp0sxo7+wHr34deFxblBZGzBUYaEr8A8QlMB0DfwdANpprGUSFAC8A4gNlsmYZetmDaBXNoEARRhrSIe0Ocj3TabZ/JKxDTwD+GyAakx6Bb4Ptg9Jdh2t1PNaxHBjG/RwUP9IDpS5B+HWwNhiYs7i7HOF/yKbUmzDHJZjsMzQhFzWM1BuX/bgj773P56XcYZpvsNk5INfPoyYdcTY84vwe565DbPWf4ucG6VSJPnPPEPomIz9H/rPHBO1u4/R1iQRoNjVV0ivQp9HtMkk2SxSGpXoxvkuE6ETSaTGMHdGIDFvMtMsRIonHCjAUDvkOZqb5HtfEemU2bwxnsP07wUf86z6ixi88rRNjE5DJzXGZfWBbSLCgDL2AzIs05OTQcTBoYjNCpYFDCoopPnxg/5EPMRJ9oxMHTDNKDMq/7FaLmlO/fvYwWXKJI5ada336uQbd4sEajEe12m3a7zXA4VP1ehX0OtzKJRCKKAZSHzmw2Uw+xiyBBGEsBG7KRhL/ILopcWVg9kb/LBlHYw8FgoDap0jpE3lc+T0Cz4zjPJaSLT7ff76t+4SIRlJ/JZKK+p8jLxGdo27b68yK4D8vUJTwIUN5bQKW7j8djxWKFx1Lk5+LTgy+lw+PxWMnf5XPD7KUUAOQQdlYYd/Guh0Eu8BfAu/g0xe8vIE7+vzDycr5SnJDrFz7Ekx2W+odtCGEJcxicCniQz5V08Yse79FopNrhSAucsHQ83F5Ixjgs/b9ofZDvLYyy67pqsyvvBSiWOAzEw2qFi6n8YRY8rPK46PeWMZTzD8vyATXX5J6bTCbquoevkbxOlBfioZcNpLyHePZFuSJAYrFYMBwOFasZllILSy72gZ/l8eabb/JP/sk/4dq1a5ydnfGbv/mbfPOb3+TevXucn5+r+zV8iO/2Jx2/9Vu/9Rd8kAAfffQR1WoV27a5c+cOQRCws7PDxsYGp6enlEolFouFCmOS4tbNmze5cuUKP/jBDxQY+eSTTxRQDIKA6XRKLpdT19nzvOf8zRLQJAyn3AtieZHCngQ7lUolisUiH3zwAa1WSyUySxq1zDlN01RrK1kbZE2TuZ/P54lGo7z//vvKprK3t6cYVvEhT6dTgL9QpJTvKIBbClMC5MOqC03T+Pzzz/n2t79NuVzmvffeo9lsUq/XGY/HKhBOigpS4EokEozHY65cuaK8zq1Wi729Pc7Pz6nX66owMhqNODg44ODgQDHbpVJJ3Ze/+Iu/yKVLlxSbK5aLvb09PvroIzY3N/H9ZWK5yIt3dnZUezJpB1YqlYhGo4xGI7LZLNVqFdd1efbsmRqvcLCXrD3iOS+VSpyfn5NMJnFdVwEbAdmj0UiBP9M0Va9zQCWfS2Bcr9dT43T37l0ePHignt+iJJMihRTaC4UCKysrnJ2dMZvNKJVKqs+3rG0i2d/c3FRrg2EYXLlyRXWaePz4Mb7vs7q6yurqqspAuXTpEovFgqOjI/VsOTk5UX3bi8WiAtbr6+s0Gg0FyMOFc/HqB8GyTakUOlZWVsjlcqp4/sEHH6jvbJomZ2dnak02DENZDsSDLW3xhMl/9dVXGY/HKqXcNE2+//3v88knnyi1hRTE+v0+nufxt//232Y8HnPnzp3nEud/Vsf/Eesj/OQ18k/4GJcCY0z+t+oD5tsnQA22tuDkAdqsTjBeLGnMjE03G+N7wwRbQYYXsfhTjplHe3hxeM8bkpkX8Ektjc/mGeRisKjD0+gymUtLE/HjmMS5SwafGbtmlE5gMQrmSzqZCI5WZ04EI7MgngNTX7YDK96CD9+B1idRSqbP6MDDdmFn1ST2konx4rKvsz2Bng6ZNNgJMIGJDVoAKebkdm0iBTj63yHyCNiE4/fjeHfq6KUz4iWPRQKmq0AXJjOIrX/RFgzwdQgWMXQtQjFuE7VtPN8iTYVZwiCyDpEOaPMIqacu7l3o/jKc1mBxAuefaNSLAeNxlM6iyNqiT3rDJVcFb7iUxydmMFoF8xq4aci0IPIRPP1RlPNhlMbunFoBvBGMB7D/pxr7E1hdG0I3RslL49Y7fP6WxcGvgLubxJsnKTh9rnjLFu3pT+D4BxqTlwIiA538o29jWR/ibvZ49EKGxzUTJgHzNxNoloVbKuFFPBgN6GbBr6bw3RSZZ11mg4Bpx6CSd1lLnzPa9BkHEI+CtQHxYYGSt8p58oBkbc7KFIIHwLlGYEfojxOMdJeYm6NCHjO+T7kxJhEAp8vWcLF1SOYhmoZRf5lcnkpC90dw9h9SLE62ibhx8tF75KtdYlkgAeMpxGdLaXdqFzrvGszGASXNYgboOdBjLhEd7M9hsgPBrz0g/T9dxTr6BYza73Oz8SkRzcIaJPi8vUVwbLNeOGF1p8l00MNK6FxKmix+lGS/f4mhe4PH8QizRJf8eMJmUKbBCptUiC5irFsHNPwEDmVKJHDjd3DyfRbdF8B/CZv7oO8x8deIs00Kn5Xsx2QvzZkEywDBPxln+SBdZJHUeBbUeNzP8fUgR5YxOQ7ZYswaDc54nXPqaIyo4+ESp4DHLxHna9TJkyKKxpQMP6DD93KfYqVbWHoSfWHy4pnDKJigkeAbwf+VB0w55qOfao37uQbdstEWhjss0xZgI8BVGLswKBSpadgXK0dYNg5fpmiHwU0YHPwkZk6kZyJZ9jyPyWSiCgbz+Vy9NpvNMp/Picfj6t9FuhwGe/K9BayIpFZSd6V1k2ww5TuG/XzyE/YPhw+RhMfj8eda9oTZ+HD7JWEuwyBMwl5k/ESqL4UGGU/4MmhL3lOAcxh0yQY9HKAkx0UlgwA2KYaEWdGwMiEMDC8CRPleYX/zjwPfFyXYYbY/rJYIKx3CwXfz+ZzBYKB8d1J0CfvOw8x0+DzDBQX5bFEHCAi++D3lesi1CtslLp532DsoYxhWLFwsUoWLDhdZZblG4Tkokl65pnLfyveXeSxhhOFiQliGHt7UiqxU5jt86QsMq1j+c4DuX/u1X1P//eKLL/Lmm2+ytbXF7/3e7/3Ucs5/+A//IX//7/999ffxeMzGxgadTkeBCBnXsN1GvJtyTwqD+vTpU9rtNoeHh6pYZBiGaosVXt+kD3a4kCRFIQlTazabKsU7nHmQSqVYX1/n9PRUhVn98Ic/VEqcQqFApVLh/PxcecFrtRqlUkkVAyqVigLUYsEpFovs7+/TbrcplUq4rqvk5qVSSQVcDYfDv5BKLQFqIuUVybPjOEoKrGnLYKtWq0WpVOLu3busrq4yHA45PT1lMpmolG3HcVQwXaPRwPd9JXGPRCJsb2+re+vx48fKQ5zJZDg5OSGRSHB0dMT+/r4qfgrT3mg0+KVf+iXFzne7Xfr9PtFolDt37jCfz8lkMsqjrWmamhNvvPGGKhqKOkTaRT169AhN06jX6+zu7rK9vc3+/j6RSIRyuazaywnoFaAsCdtra2tKUSXPkbCdaDQaqTZuyWSSarWq/m04HKo2cfL8+uyzz9QzJxKJqGKb53kK5Mv7lctl2u22mmNSUCgWi+TzeVzX5ejoiEajwcHBAeVymWazyeXLlwH4T//pP3F0dKS8+Ddv3uT69euqGCHXTiTrIlGXPtmRSIRqtfpc+Cksi9VPnz5VvmxREcj86/V6lMtlHj58SLfbVWtpoVBgNBpxfn7OeDxmf3+f6XRKJBJhdXWVb3zjG2iaRq/XUx0EgiBgNpuRy+WoVCocHx8rSf6zZ8+oVquMx2POz88VMSDF7vl8zmQy4cGDB8+Fuf6sjv8j1kf4yWtkkw7vY/Fu9RGttw7R5icE0duQycLZOoGXglQXDB/0OV6iyYONGf/zecDcdnlKkZnm4eVHjNE4XJTRggwwXGqXtRWgjr5YQBBhnsyDbxKxDDKBQZ0U6aBIl+YSbU6LRE6gsNAx0UmlXdZXoOlD/g1Y5OEHf57m2fkb+JxzaXhORTM4XxuQcT3Kj6BaAv0SzHrL1lepCow+AfMIZr7LDI3iRGfwsU/nX2mUogGuA5M7q0SiULrmMDrVGDd1hqZH8TiKUXGp/UKAcwLtQyCAuGcwTtpkymA3wcEmDUzjGhowO4FWyqbkB7R+AP7Wkp1v3U0xGcdIxoac2gm61Ij3A04POjgl8Ndh+AQWj2BehfM1aEehHizT2Du9EpPAItOZczKBhAbH7+l80l3HCmJc2XxGtjxjMVgw/iWf89+IYMbjREZQ6Y55pQk7XeBemsXHRQq7XTIvmQztAOOhTee4wJ+PxgxqVcBa9t6y0zBvw9RH69tUH/kkNBjX50x3dM62Y+y/aVL8g4DaSCd11WdwG6wYpDxIZyGtZbBJMCpbrMUhdwyDc7DMGH6Qx6FK1JsRYcHIOKNQGJPXIDnUqAbQ2wyYfR38c0g1ITNYJtbHUvDsD1OcHbxIDIsMHlYQxfYdvJZO7N/7JEuQL0P+V8G9DfqLHsZ9Dbe+IDExsc40CsmAfAxoQuIJmNccrG/+IeU/+6uc9F7g0ov/b/L+K9a27LzvBX8zrJzzzvHkUJGlYpE0SUmkJMpBuibcF0K3YePqpQFJDVv2i/1i+Enwk54oPzQM3e4HtdqGgyzLFEVRYlFFsljFyieHfXZee+UcZu6HxW/UPJsl36YsUVDdCRxUnX3WXjONOeb4f//wvYfWgD+cL3GPCOlZjt5M45n0E648NyeyvRhnZw+e55ZfpsmYQWRKKuixFdQYMuE+PfLUqJDD8S/TBSwcwKdjXeK9pkubClXalPUnpCtNCs08bjBhkP1jaqtd7n9Qpj2OYPge8+AyjlkEfYDlNHgcGbIX8UAfU54b/IQT8CXabPJHnGnH1II2uegUX5sysxLkeZ8quxyyzOvkuG/MeVQ7xdmG+GQOdYe5vsajfITbno3pRbk4ntFkyJw7f6G56G806G42m9TrdZVWLuBQFjES8CStSML/JkBG/Fdhz60AKgHT5728pmkqNkUWobKIz2azqgWPVONF+iVgWWR3rVZLsfLCwApDGmYKpagQ7gsu8uHz+5dzlv8XqacAF+ApObbI1cMFCUDJICWZVgCzsIfD4VCxCAKY5TrNZrOnPOyiLAhLSwEVviX7B9S9kTCiMFAV+XVYih8GpHIPw62jBFCIXzvclzz8R+67FCnkeOS7wkA7LD0XkBsOXRMZdJiBDu9X7oGw/gJ4RGYu+w+H4YXPUQCpKBHkOMVbKSneYU+kFDrCifXhApEwwXJssggLKwHC4YDyOblfIucPjy8ZM57nKVWF/JHQNfGUyyZjRO5/Npt9KnwtrIoItwUUe0kYdMt8IMcgxQQ5tr8O0H1+y+fzXLp0iUePHvHFL35RFSLCbE6j0fhIj6Nswiyf32azGc1mk0gkQr/fV7Jmafck113SuiVFu9/v873vfY+XXnoJ3/e5c+eOAjS6rjMej8nlckpRI6nwYdl0JBJR/bllrppOp+zu7rK5uak+K+x0LBbjwYMHNJtN4vG4yp44OjpSCdTlcpnhcMjP//zPK/WQgAeAS5cuKZAjrLtIyMW3W6lUODg4UFLkcrmsrq2okiaTibqGolASCTzA8vIygMpFcBxHASIp9Ozt7akCWafT4dvf/ja1Wo1nn32WwWCgfPPSWiudTqtCltwbKUDK+0ssQoaxaEv1Uz/1U8Tjcd544w2y2axqRXZwcEC73cZxHC5dukSxWOTKlSt8+9vfZjAY8I/+0T8iFouxv7/PfD7n4OCAg4MDDg8PGQ6H6tpKeN61a9fY3t5WioV8Pq/S3uU6iLrr5s2bSl0DH4YfyjMt8udsNovv+zx8+JAHDx6QSCR4+eWXKZfLHBwcqILi/fv3VWFOvMji9W+327RaLTKZDFevXlUBehJUJgoGKfTI+18Kfs8++yy3bt3CsixOT0+Vjzkej6t+13Ievu9zeHioilCdTgff9ykWi9RqNSWXF0+9qMl0Xef09JROp6OS5SORiPJPVyoVYKEG+4//8T8qu0EQBKofvawJ+v0+x8fH2LbN2toaZ2dnPHz4kM9//vPcvHlTvUen06kKi7Msi9dee02FvIniIggC2u02S0tLKqOg1Wrx1a9+lY2NDTKZzFPdI/66tr+M+RH+/DnSZcarS00Gz9sw7hC4KYhb0GiClYa0D2ltYUZunZDmFMpPuJ02qD1M8EnnBYZ2lbeHD4haJQhWWWbA3plJb2Wb+OMpgTUlcCPkcHHmLnMSVIOAdUwOtCL342OcaABWgmi/z25/lxtsUtA+IJ6w0VKQXIV4CR68CadHSfaJMIpn6Vs+cUPndK4R+a7G+ijBoH7KJ9ccEhUYBjAbwtkB0IaLCQ/LdsHTSSd8htEALQZxE2bRAeSnlPNw+G6M+bjKvNuh7KZYCroEdZdEdgHkJ/dZ6McjNoEFlhcngUuSAcQ8lsrAy5BIBugfQKQN1QHYj8CbRHAD2Oumsb01Akw6bpZvv+NSm/d45hkY7EHjSMO8E2CtQf8C6CnIZUDTbdKeTjAwsWwXzdeYzPJESREwZ3wYwzA86pdt9l4xGSRqLH27xfWczTQL1hAe/2Gc09PrEOux+4LFcRHsZwOO736bx2Od/U8sLUzL+wk0a4i5f0j0wGL+JEb2IM3m1EbXLGIRg6XdKYOXXQZXIDv3MJuQvwDZAjgjSN0C/5aGmTwjVmtws+Ththb908mDFgdtlkNHx9RHpJZ7ZJZ8sib4T+DRIMMDLUrsuMuS4ZNYh9nXINODyBrsN3Xa+zUazEjSwscn53v4A5OOm6BpTcg0ElyNJchvdwh+OiD7WajlAyYziLYDPAv0+KIne2QZ8j4MXKj+r32G7T/G/uAq9V6MreycpKFR8kweax0MPcbWkyWC4Aw/F3B4FsPzd0jhkKFFduyzisc2Ldo42MRIAVFSjChgU0ZjygFjbhNjTsAyLQrEafrr+N2ASrAC5vfwth7w/2ml6Q2exwocpppHLdjkk4MYh7qG5dv0zD524gA8lw7rPCLGQ7p8Pr7HzeIAf7bIOJj6Gh3bYBLkmJLjqxzx1so+9nIWimdE88dEzzzm9TSsrDFez8KjFM68xd3I10g766TJ0v8LzGl/o0G3JNsOBgPF/MqLNSybFqZRFn/hFi8CXgSQAk8BK2FHBQQLGJCFoiysBPRK7/BUKkU6nVaMUNjnOxqNFNsiqa5hQC8LUVnQhtllYXoBBarDvnQBVBIsFm7tksvl1GJGQLfIjM8DyTDbGQadEiYkQEdAUJg5Fn94uDAQVg4I8JT9y30Ks6Xnk7TleGWxLCAuXKwIKxjCnmL5HbEehAspcv9Fkh0OdJLrIZuMobCMHFD7FdZX9h9O5IYPpery/RIqJcBR7p3sR75TAIosGmRchAsGkUhEBeKk02k1zuWaxuNxlSEgwCDMUMtnAVWkEcAv91EAf7gYJc9GuEglz4yMU7m3ApKlEBa2CIRl/eF7J6Beilfy8/D4kfsrDJQ8L+HvCj9/YWb9r3sbj8c8fvyYf/gP/yEvvvgikUiEb3zjG3z5y18G4P79+xweHvLKK6/8yN89Go1UUFK/36dUKinfu2EYqsUWLIC3SKmFAa/Vanz+859XQWDz+ZxsNks+n1fhTTI+5LpLW0RN02g0Gqr4YRgGW1tbXL58WQFhYbdN06TT6XDr1i3Ftst3OI5DJpNRBae9vT3eeecdPvvZz6LrOv1+X7XeWl1dBaBer3Pjxg1qtRqdTodYLKYY5V6vx+np6VPPp+/7KnRO1BQSkjYcDqnX61QqFQzDUL2sdV1nZ2fnqbZ8H3zwgUo3Hw6HT80Vwl6LGmkwGKiC18bGBuVymc3NTVqtlvJIJ5NJRqMRjUZDJW2Xy2W63S6bm5usra3x1a9+lV6vx8bGBpZloeu6CuUyTZNCoYDjOMTjcVZWVnjmmWcWDN/pqfLs37t3T81dUkwOe6zfeecdnnnmGTY3N7Esi5WVFVzX5eTkRIE48RYLIIWFcuvk5IRUKqXeG/l8nmq1ynA45NGjRyqsTjzoX/rSl9A0jQcPHrC6ukqn01E2qlKppMLHBOBKEXsymdBut7l+/boKWBVf8/LysiruSbs5WLTv2tnZUQVPwzCo1WocHR0pBnhpaUkFskoyuvRNB9je3qZWq3FycoLneYpZF/Za2oVNJhNisRhXrlzBtm2VRp7NZikWi7z22mvcvn1bedbX19eJRqMsLy8rG4AUYiWRPZvNquewVCopz3m73VbJ7w8ePODevXtYlsWlS5fU/TVNk9XVVVVUdd1FP/RGo6EKk2tra9y+ffsvPrn9JWx/lfMjgK2P6N90IFuE+RqU+gt6UsvAdWvRvylWhq6O6dVJFS3SEYujbIQ7rQJ/u5XgF4M4keGLtMnjMiVFmmd6Me6P+my5BTqY9AhYx2bgz4AyL+CS5JiOlsG3XZIzB2dg8AwpLlLExSVnnJFPwbwM5ia078Gt/xClNc1g8YTYPMlRNgGr9qLhtp1jNiqy9lqCpZX71P7vAU0dgj6MetAY6azGAjRM6h2DG55LbRk6p4ve0Fuf6xLpL/pB12caATkC18Snhe941EZQuAKWD5lD0AwHZ5ZgMNM5A8qkMCIe2itzzKugHcKGD34D6iVAh1v3IWV5bMbGDOwlbLLk6KFjMrIypDo95vVFi61BEGA80PAuBkQ2wStD/jKQn9LtFAn8OMn5hJGm0yBGlw5xswNenA4GJ9dtZus+mf/S5tO/n2T3ss+7X3A5y0E56lEMGpjmGaVkwEMHJnEov2yTL4O+McU/TWPe7ZI96hD5syL62Q5VH6oYJLAJcKlRI9YNyLZPSPw8LF2GSgZW4+A24OQdiDzRSGom1rpDqgqJFrR7wDXIlOBEj5OiytB4jFXpkk8EVEswqMHjxyYnxGgZM5bfX8c1zviZ/83iHvDgboTVuku3k6fpmBg0KFImzoD4ts08F5C6b5OepekFMLHydI+7VGMBp5fBWIHCXcj0IXUDmIE5AOMi9FLgBXC6DNX/W5vy/+u7uBkP4xmoaUfs3zXw/CTVIGCFOHZRRy97ZFydNKeYdBjGDsD02Y5OqOJxOijg+QUS9LFJYLBBhzMaeNwnyhF9XkTjCglshrRI0nB+lgQRqt53ee1xiq9ml/DSh+ieiR+sszqL8hmWmfkVDhnxTd/DnsfA7VFyhlQo0zOfkFkeUMpAw4LYiUZ7vMwRn+Y2m7wf3+ck2MP1ppC6gpaIkIm4jMwo9tYyZCyYuIuY/3GfnNPAxGHRhO5H3/5Gg25JJxaWO7yFA63CYV6ykAv7YgUgyiYLMQFPAvjC0mX5PQnkkhdVOp1WrIMAI2GKxXMtcvGwhxZQzF+YxZWwFGG5w+caDhULS6ZFPits5kdJqcPAOiwvD/udhcGW7xTQIvuX6xGWEof3LQxp+DrLgk4k9CK5Dyf/hkFlOBQrHKQUlmvLvgVICqCShZdIAmXhFwaLwlSFwXL4T3g8yX/ld+VYw8w48BTjGwancl3k2sl5yO+Er2c46O38OJFzD/dUl7TdSCSiQLcAiFQqpRb74Z66UsQwDEMBCQEiwqbJdZBxJiBdxoL4c+V8wmFy4f8Ksy9FIyn2yDMZlv3Ld4UD08JjW44/rP4Qu4OM13BxJ3z/ws+v7y96G/84t3/+z/85f/fv/l02Nzc5PT3lX/2rf4VhGPzSL/0SuVyOX/7lX+bXf/3Xlc/z137t13jllVf+Qsm8kuQ8HA5V2yCRCEsBT+Yc8UpPp1NWV1dZXl7m+PiY1dVVLl68qGStIlkNB5UJcyiy2NFoxLVr19ja2lLsdblcZnt7m1KppFp8SbK3JM23Wi3FmsoYlGdfCm3RaFQVbGS8WpZFs9lUCiLHcVTis64vQrV2d3fpdrvU63U1v4T7TQNPJVC7rqs6RfR6PRWG+dxzz+F5HoeHh6oQJNJuKdQ5jkOtVqPf76uCnO8vAueazSbj8VjJ46PRqAr5SqVSrK6uKpAqCiyZswRwTiYTLl++rHqIX716VfW/LhaLlMuLgBfx1Atwl+sxGo1otVrs7+9zcHDA2tqaKgLC4r0qxeXZbKZAtYSDSdEKPnxnCeiV+Vx819PpVAXc+b5PvV6n3++TyWRU4FylUlFec5kPbNvm7OxM/Z6oAtLpNOvr66yurnL79m11TXzfJ5VKPaUEkyKk5AMEQfBUf+toNMqlS5dIJpMKvD733HP0+32Ojo4UM1woFNS5j0YjxfTLXBgEgWJeRcIuyhJJpRc2WdrHSeaB5LqcnJyocV6pVNSYbLfbFAoFZa/Y3d1Vvc01TVMp+WITcRyHo6MjZX+QokcQBDQaDfX+7nQ6qpgpAXCFQoFHjx6p8DkJq/txbj/O+RGgbjbggQO1AVRjMC1BJAMrQ7CHi+bH/hQGPdAdhmMYzMCpLXGcfIEPKHETm4sU6HDMw8iUgb/CF70IO67OBwQMGTDVbO4bDnbQIeOZHGt9Ph27wy9ZRe75lzjCIE2Ry8ypcoshUaKM8FKQ2AVnBu2vQ3OvTNssMS/4xDoe2YnBpG/gxWMwHqI5AZYTMGsuwtQmGvgeWJ5Gw6nRdXwmODhdn8abkHFBL0NuCXa3oPs61M80TM/FwMXCJGJOiMQCghg4eTi0YL0ArqEzDJIEBHRxSQJBaczokwG3MjDag2gUIjUYjGDegfgcPL+IY9osBT0GdgETE13rEKS6xE1ozmAcQMfN4g88yqcTir1FkHyQhpULFim3yVALSGYDoj2N+SjBAJOEWyRFlE7uAdZliA98nv9OnOuNZ+h47xHfGNBcg+bKqvcAAQAASURBVN3rDvHDMZOYTjQOldFCtn1lAo9z8MFoTK09YffWnMF3l+kPXsDAZ4MmBl3axIhjEtHbzGMuxQ6svgWFiwvG2CmBnWDRdm0tYFZxmOxrtE9MZq6O52VJ99vkNwOmhkmFBL5p4Xsa9YMU7eKU4ZbPA5KkiVJJtLEmEUamjzsDxgbOvMZZs48XHZJnjO9ESWsx0ok+pecDWhfBizssvZklHZ/hXt6nedPHni76kXdjsHYFeg58fw3Sfdhchm4WjnSIRGA/BtOX4HLJxejBsAqlmy67X31C7LUohURA4hkH/fMesTRcXJ8xir1Gfs0lofto+gJk+hbkZ30YDslFfVzbpL/n4vo6ce2QQnCZJlvYJBgwIOCUKLs0mJPjIVaQ4dbkIjF7iG3MsHIVVtsmPhrfp80GOS4Q0PSLvBHs4KQmdHWd+izKC36OwBrSzfn4OrhRjSM2+RNtl7dLLazafSLBGcmJy/jkDGwH2wG3mQQ/DgUgnoRcHhIFhocPCKI94l4BJn/ezPLnb3+jQXer1VLspSzOw7LisN9WAKaAsrB3NLxAlwW+AG1hsYUFDIN1WXSZpqn2I31VBQiJl1vkr+EQMQFTAsrE3ytyYGFdxa8ofispGsjLG/gh4CvgVz4X9lqH2exwWJYsDuFD0HI+eEpe2mHQGva1h1O7bdt+SpYsycbCxsg9CDPP4YRqkVaGwZNssnCWz4UZVjkfCevqdDpPyY/Pe88l0C0sZz8fqBYeG3LucqxheX0YnMsWljYLKJRrK58T8C7sszDv560HYfY3lUqRTCapVCpP9cwVD244QEesDQK65WdyfWUcybWThFy5RzIe5B67rqvCe0TxEAbf4efI9z9MsZb9ivRcxtv5wpGMkzDolnsr53EedItnWJ5T2WSsy89l0f3XIS8/Pj7ml37pl+h0OlQqFT7zmc/w+uuvK5npb/7mb6LrOl/+8pexLIuf/dmf5bd+67f+QvuSVOxarQag1C5SzBKgLcyzgJ7hcEitVqNer6uQJQGGtm0Ti8VUEScMhufzOY8ePVJ+7S9+8YvcuXOHBw8eqGd/dXWVy5cvMxqNlJVD2j3KeJNndWVlRRUrDcMgk8ko60kqlWIwGKjzEjAj9/bk5ITV1VU1vzQaDQ4PD/H9RUp3t9tV0mHxKZumSSaT4fj4WKmWwgVAkQtPJhOi0SgPHz5U9pBut8szzzzD+++/r4pKuVxOtc2SZ1LOOZFIKNWJWF9M02RtbY1CocB0OqVcLnNycqLY+kgkQrVaxTRNrl69yuPHj1VGiHjOw+OsUqmQyWSUlFmsPCJhHgwGSg2h6zrr6+uqSCnvIbEGSUFLWrMJQA9nisxmM/b391VRS8C2+LtFrizPdtjvfenSJV5++WU8b9HaUj5TqVQoFov0+32VQyDvXikGVSoV1tbWCIKAN998k3w+Ty6XUwGKYp2R+QlQ6fu6rrO5uamCQpeWlojH48rDXqvVFKiPRqMUCoUfetdMp1OWl5fVc5RIJHj33XeVxaJcLnN4eKjmPcltkXEgfxf7hpzf4eGhsnM4jkM+n6dYLLK9va2ug6ZpnJ6esr29DaB6pNfrdVW0KBQKan7udrtPqeHC7xORuxcKBfL5vLomP87txzk/Aoy1CZo1JSgZMNyFYQKeMUA7hll7gUgnx2Ce4cayuMMhmr/o3+3pOq8ZFkUvQ48+B9Ees3wBa2CR88b08dkDZsyZJS1IxmA8o8tDvs+U1dKYL/Y97ozjvB1xqXopCr7NKnUuUWKU7RB/HoIiDL4PnXsxbHeVpBFlYo+JGyOu2Rm6dZMDU8fzopSDDBGzT2wjgMyibmBoEEtBgyhukCFDk6gNJ8ewkgY9D34bzgZwNAI/EbChu3StYyZeFBI+xZ2FxL0Xg14UtAT4ukYqOsEsjoi0UmieQS/e5/2IQXzqcekMHnVg1oVoD6pNyF+Fw/cMnMkatnlIlh5J8ripIYltByNYWOEZQiJYYRb0OHMnuA5cHC1AfPEzUKx4DPNQKcHZf/fp0KGcCohMY1Q9n9TzNodXFyFxpYMSI1yc+JitOVQtiGTheKNP5RmP9AZk21DqLrLvPsjHiAUaz4zneMdwfxDBpc4GHkVquBRp0mKIRcaHuD2GmYb7xCGoQeQCjNwFsGUN5jHQV8A6jjKblzgwuuhBFqPTJ1t18Isu82GfiTHDHsTAy9ApTmgb0PR1BhjEpjpX0j1efBYO43A/7ZOJDtDTNpUbC9Dff2xjFMYkCosQ/AJw8IpPp9iiZsL6LoxtmP0xbMWgUoBRDfYLcC8FCQPObHB0mAWgxSAagGWCfRlWO+CwOKfrKY8LuzPMJGQugJOC2BRSz0HBsfHXwIsuRCNzHbwRLGkB+tQjmoJExKH/bztEDl+iGLQpcYBJAQPoM2JKGpMIcY5wcLjNDg1aRJ0Itq+T7pvgRflAO0QPdA6osMOEJaqk50V6hS2cfIL+aRxndpOTwYjtbBcmC2m5AXSNU6xcB/wITqmCG1jQMUA/Y+rp+G4M5lOYVTH2TXLHJqOcj72UA6PGlSdxPuDJjzzn/I0G3fC05FeYszD4OS9pDstkJXAqDNTljyzUBXydB/XyvWHwFwSB+t7zLLkAfpH6yrEJUJBqvgC/MMgJ+69Fji3AWxaq8n1h8CfgMZy2G75uYY+ynJ8ALLkuYdmwMKKygAsvYsLHGwb/Apzk/2XhKcce9vPK8UoBQs47fD+F3Q+nWQvAkuMNs6zh4K8wEAvf67AUOnxMYV92OOld7ld4HITHT9g/KPuVBZZ4os+DzHDSeThILAziRe4vQFnGb/j3wgz8eZZcjkUAheM4yoMblgmHFSHnmX8pjoSZ6XCI2fnxJ8UqGSNyPNFo9Ieet/BzFv4TfqbDPwt7xMP3Re7d+Xt9Xk4fHns/ru13f/d3/4f/Ho/H+cpXvsJXvvKV/+l9iSe0UCgoT6kUmMT7KR5hKSCmUilKpRKTyURlVARBwNramgpVDC/aRS0hhaL9/X1yuRy3b9/m0qVLqnAo4ERk/5lMhlwupxjfdrv9VC5BuVzmypUrjMdjHjx4wHw+Z3l5mXK5rPoUCyMdi8XU8ylg/PHjx4rhExvObDZT6pDw59fW1pTMXoo6YiXK5XJKZp5MJtUzI8oZ+Q7DMMhms2xtbTEYDPB9X6W7A6pPt+xfzmF5eZkrV66wt7engt2i0Sg7OzsYhsHZ2RnPPPMMiURCpZoLIL1z547q/Z1MJpXFQuTJ0qZLzsc0TW7evMn777/P48ePOT4+Vr528dk3Gg0lj5Z2YmFgH7bwyPdK2Nfx8bFqoSWFu0KhwGw2o1wu02q18H2fixcvqmvreR6tVot8Pk8qlVLjot1uU6lUiMfjTCYTNa+F5zcpKgB0u13a7bbq0x4EH7a59H1ftfeSNqOi8pBCSjqdRtM0EokEu7u7lMvlp3p7S2Eh/AyJBUIKK6I+kiyXBw8eMJlM1PgK27Ukq8LzPJV6LoC5WCwq9YiAdECFAa6vrzMej1VhVo5RGHVJJZc5UKwNvu/TarXUsyb3SuT1iUSCZ599Fk3TeP7553/sKiD48c6PAOSrBDdGkPfgkQ/BEPYSi2bS6ROYNRZIxTAgFoNYksBcgmAFzAnHcY/TSYYpGi5r7HSiPOe1AJ0OSVyGpHFYmk4ZzDW6qSSms0fSKvDuOM6lxJzIeECgxxn7LlNsZgDakMzzY9IvQ88GrwftfhqNDZ7xjpn1h5gMuKY1GAclcm6MDkmqVFk35hTL0NfBnsKGA74fYDFiik6KOH03w+NWj5QXEHiLvs3RFMwiENMgWgqwEiOcQ4PkFmR+GrRVaAQwdCDhgpkaEjcC8ltgGXOGp1E0T8NwfJ7EIZ2F4Qk4MUgsL3qBJ7OwtXzM4DCH76TJMsWIDWBpTroEURdiyxDxoXxrDKbFO5ehewVWHoMxAH8ZqjmoVaDsQv2mj/EzAyIZyBxAeQ77FzTmus72902MyQ4DXFIDE2fPw3TAqsL8b3tYFajbEB2AYcObl6PUX6yy+fYpqT/RufMwxhSNXRLcJIer92hED3FtD8MvMNRN6hEPX/fYbkdx3naIPArQmwZmzme2GaDHID+DoRZwhEsiZuPMW/i+R2YAheSYWf4W5Z+Y0x5puL0mqZsB7RxU4y5xkvQ8k7zmkdShkwZ9NSC4OaKyC/EyjB8v2oBF9UWHukgdlgpQuArHz0MlAK8FvAbVOtgb0Lu+qDHtR1lE0sfhLAFOHHAX7HTChaQFJzq4aYgBfhKml0GvLXqcOzYkIxDJgf8MeEPwDOhVYJQGNAhmC8VFVodoHPQcmC/1ODweMPOLrNNggyYuM+aksVingoFJhgNqtKlwCZcJXXRPI+9VuBWz6MdtqgOLJlNawCYzor4JrIM/JmYlcSnhGBpmDKY+pJ2AhDYn4s9goC2M7G6BYJQEC1LWHkEbJpE55MfgFmAOS55DphvnZPYyK4HLL/o6H/wFppy/dND9G7/xG/yn//SfuHfvHolEgk996lP8m3/zb7h8+bL6zHw+55/9s3/G7/7u7z5VrRRG5kfZwgyY/DnvUZaFjyz2wy/gcLiG/J4AJ/l+AZ2y2JfFu4AjqVoHQaAq6+HQMgHLYe9tONVcjjkMuMIgRxbIsmiV1HJALSzkXGUxKQUAKTLIYil8zcLy+zDolusUBp0CtKT6HU6Q/SjgHvbrSoFAGNswiyzALOzhtm1bVeSHw+FTSdOSeCusnRxvWNYuAFoWLnKMci3k2sq/CxsjRRbxKAPq3oS99HJdwuMgzKaGCzJhBYIsiOR8RUkhgDcMDuVzYYm6eAOl8BL+XRnfspgKA3u593Lu8nvyfeHii4yvaDT6VEFIziF8n+Xv4qWez+dPAd/w8QlYl4WzPJPhokf4u8NjNJz2Lp+RhXPY3x8G5ue38P4lk+GvA3T/ODcJ6xqPxyQSCSzLYjQakUwmVdq0BIwJSFlfXyeTySg5cRAEZLNZBS5lbllZWeHw8FD1FhZpea1WI51O0+/3SSaTvPDCC5ycnChmXQqLYRk5oPyqm5ubmOYiZXx5eZlms6nAueu6St0hz7Wof6Q/srD1o9GIer1OJpPBdV3VDqvf7wOoxOtKpcLq6iqRSER1wBgOh5yentJut1XPbwHYZ2dn3Lhxg6WlJfWcWJal2mCtr69TqVQ4Pj5mPB4Ti8UoFAqYpqn8vb1eD01bpIMfHh7y9a9/XYVvplIpNZcISM3n86ysrKj2bxcvXuT4+Jhms6nakHU6HXq9Hrlcjq2tLa5du4amadTrdVVUkfZkd+7cUXJ38fg2m03S6TS1Wk0VVCzLolQqcXR0hOM4KmdEmOvBYEAqlaLb7apxJJL5RCJBr9dTCd2idkomk6yurpJMJrlw4QInJyeqgGqaJoPBAF3XVWFW5it554nCR95/Ahg1TVNM/9nZmQoylZ7b5XJZzY9SCBZmeTgcUiwWVXFV/PCJRIJ+v68K4tJ2UbonyOfDihl5H2xtbfHd735XZQKIXF+esWq1qoob8Xicra0trl+/rubf/f19otGoCv+U86pWqxiGwXw+p1arKYAtnnVd11XfdQHVYk/QNE21aNzY2KBSqeB5nrJd7OzsqJC2CxcuqL72H+tt2oBjE6YB1MbQB+PNEX4lSXB5B2YjmDXBq0Cggaktei7NM9C10J0kbXTG5Fi2Hb6ARwofhxpVaqzyOgYdNoMEt/0RPd1k2a6Q8vOMBhOS2TmfiAw4sNIMSaAZLWLmhGghIPppn2ENnPvAHnh2nAR1LuiPMfNDiimb5Sk0O1lyFOmg4XJMOv0Ys7gAk54H2gSmpzrFoMQAkyfMSBMlNTGp+w6Z+aLXd7EMkfmilzMxSGQgd8kj9xzMtsExYWUMsykEIzh1oTNOM3kyJV1atDaMjQyuHLq416H/LFyIQ8yDB2nYq4E+hxufdqgstTl+EGFiBURXXQpVMD1ozcB5B3od0CKnVONQ/gCSBuTzMMov8u0y+iIVvHW8AHPlIszXYVqFb9pw+0KV+MmM+FsubRIM0EiOKpzNjgl8MBPQvA4NDT5xCkkbustwsh3Bj8SJvh4QvJciZtfYoEwKaBbeRd85I1rxybwXx6mnsfNt8usuh09MnGGeZGOI6c2ZD+NM2hGGkxHJyx5dG6btAhoreNM5UTQSzRSDr05Ib3sULnlEHIhXA4KXPd7bhl4SKi9MyFiHZGyHxDbElmCtDs4tGEzACEBrLSTtbhnm93TMAFJLPtYAsk2onSwC3bRVSOWAFtSjUNAh1YaoA+QgW4KhCe3IYqhHPaC4ANCTIfgFiAfg25BNQWAsQHehD7a3uKZ+DpIFMHU4cX5wfNYi/D/vL1rNTXTwDUj/tMfk9dv0T3aoYxBnhAb0MCiwwXUK+AypUGKZKGViZNlkzj6u9j4Ja4N3rVUcJqSxmQOnnFEIqoxbBpP8nKhfIyCNlZ4wq4HXAb3i03CeEHS20GYJgqgLZw64M/A0bDsKMR82dKKVKa53D69aotVOEfV2qM3m/BxjLhP5yCnl/2j7Swfdr776Kr/yK7/CSy+9hOu6/Mt/+S/5mZ/5Ge7cuaNeiv/0n/5T/uAP/oD/8B/+A7lcjl/91V/l7//9v8+3v/3tH2lf5z3KYVbwPNMtnw8zv+HFv3w2zFjKJi/rMHgQ0C7/lWNIp9MKFAqgFOAvCwtZRAioEdAgWzKZfOo7w8BNzk/AR9h3K+zkeVZQwJ0wUmEweh40hwsXYYWAXEO5PnLdw8f0UTJw+LCYEZZXw4ehbx8FwGTRF25rBh9KtWV/Ya+x7F/83/L384x0+Ofh/Z4HbfL9YeZZ/p5OpxXTId8hADN8z8PjMxxEJoWccPK33AO5ZvLfcFFJPmOa5lM+5nAR4KPO9fx9EuAf7gcfLlDJvT0ftie/K8cgi2kpEIRBsyxwBaiFi2Hh7IDzQD48ZsJFqXBxQQpDAnzCYyMMps8rUsKg769DXv7j3BzHIRaLqSCydrut+jJHIhFOT0/xvA87G0jrJ03TVAsmUbcMh0NliQgH/+VyOSWPLpVKlMtlHj9+rJjgF198EcuyODo6Yn19nZWVFRXGFgSBaoeUTCapVqvAorAm/ZElzEqA72QyUdJgmccE3IVDzZLJJO12W40vAY7iORa2dDqdcnR0RLFYpNVqKaZYQJUEXsn4OTo64oMPPiCRSLC+vq4UF1JIHY/HpFIpNjc36XQ6qoAWnntFCi8+4GazqVpticdbAFKj0VD+4PX1dVXQeP311zEMg36/Tzab5fT0FNM0abfbxGIxnnnmGcrlsgKlohAYDodUKhXu379Pq9VifX1dXZdarabA56NHj/C8xUI6nU6rcFDJAzg4OFCFXcuyWF1dVa2/JL272Wxy6dIlRqMR7733HpZlsby8TKPR4ObNm7z00kvqvSpKCgkSC/ufxaYlFoStrS00bdEmq9PpPFVYDauNfN9XjHm1Wn1KvRaWXIuVRpQTMm9J2Kqk9IvSIZlMqqJfr9fj4cOH2LZNPB7n8uXLZDIZ1tbWWF5eVuPBdV1lwxAFhOMsenhnMhkODg7QNI35fE6hUODGjRscHR2ptYAcQzqdptfr4XkevV6PWCzG5uamsod0Oh22t7c5Ozvj7OyM9fV1er2eYuLFWlIsFul2u0wmk6d6yEvY3euvv87BwcFf4+z149myI4fhMALbHXTzFL9dwXccAjcOZ0XoHyyit7XlBTJLJOEkxXYXLnsJMiSIAmekWWNAljktlhijkaVOjSEmGhYGdjBmZ1BiJSixzx5u4DF0NF6szPk7vROOgjPWa1NW4gGZK5B8EY4NGB5Baw8SmTOq5QZUXXKbsJKA8T7E32+xNO+T8mAwKTHJzhisLXzRlr3wg/caOmmqJJkyxifDnCQu7VkCfa7jZ6Yc+eCMTGazCJ7lEcHCXAPnFPQH4K6A9w7UJjDtw+ksju+WaDWjTLoWpucQjXsUP4BKDWIJyF8C04EcUM6AH4PxxsJDXn3RYVQH8wwSGsyHoB+CPSwy8DKQOiGfcFn5/hqx96rw/AekfsmhH4GO9YNQ+Tl0vhch8gY892UHbsCrKYj1x1S+OSPfjzDklClr9A0TJw7+iUbKCIg9A6MytPsQr8E7VY1eOQYji8aFgPF0zOCextVRHtNoc7h2hnPFp1CEYjDnrH+KP/eYPIlSGFVIZTokn5tTugz23oSD10oEZ2mipQFWB1atGhVMBhSIUWBEk3ptxKUbMH0I7307hlV0qXoeky5EnwfjswFaekrVg9zGomWc50BQgeQhDF4FihAxwTs26UzWsPHZPjlF81w6TzQ6I7CDAO9Ex29FCIY+wdhF7wQYA8iMYF6DQgWmGjj+gvx1kuBpYNuQjMPcAW8GhgPjCOg6OFEIUqCPF4DdT0LchmRqIbHfnEPyAey9ZTDcixHZsEj+PQ8nC+ltKD47YVDXiPm79HFpAA46RbL4BHjcZ5dVslzgCRpTNgmwWErc4RXXomJDnTUgh8GABiYp0vhWn0emzzjeYzbvEDVt4jqMdOh4sG1OeIk6Z+4q/cQaftAjSLgLLf1wFzc5geKEoGUS9OOQjdHOZtHnHs/PxuTZ5VvM/0Jzzl866P7DP/zDp/7+v//v/zvVapW33nqLz372swwGA/7dv/t3/M7v/A4/9VM/BcBv//Zvc/XqVV5//fUfKRAjHM4lle8weIKngZPIv4TpPi8vDy/a5WUv4CUsz9Z1XYW05PN5Bb4l1EqkaiL3FoBRLpcV0ALUYmE0Gj0VKJZKpVRbFPFFnwe5AtKF7ZHjDIdZCVgTdlSA1Wg0eioJXc5bFl+6rqueqOFe17K/MCMuzL/8G/AUKIYPwfVsNnvq55PJRC0mwiysJI3btq1krgL4JBk9DN5kES7XSxjX89Lo80A0DNTDnvZwkUbGhwBskYdKCyFZdMsYDINHAerC7kq6b3hMyfWQhX5Y5h5WWIgXO3yfBThLn2QpQIRVA/LZcBEmHCYmBSC5BuEWO4BK2heAL35aWZTq+qJPrzCh4fOX+zYejxUgEjuEhLyJxFL+LQzwRY4Z7s0uxSuR7wrzJp87r3SReUK6DUjWgsg9P87b+vq66nnc7XZVurFlWbTbbXWtpFVYLpdT11gW8q1WC8/znpJwC3u2srKCYRgcHBxQrVbZ2dlhMplQrVbVuI7FYty4cYOVlRVyuZxiC6PRqOo9HIlEKBQKVCoVXNdVUmxpDyWFPvGY53I5NT/N53Pa7bZS4FiWpUK3hEmXwlT47wJkRJZcq9XIZrN0u11GoxFLS0uYpqkKE/1+n9XVVSzLUn2ewy20BPwLiAv7ucfjMc1mE0AFf4qEWPIQTk5OqFQqXL58Wb2XpK2kAL/Dw0MKhQIPHjxQgCwajT7VDUD+LsyztDkT2brv+yrkTOba3d1djo6OFPATmbd468VH7vs+g8FAveem06l6jgeDgSrEyXz07LPPAvDmm2/y6NEj1Y4OFqnUGxsbGIahfOypVEqFwB0cHKhAMpnXBfiOx2MODg7U+0beE67rkslkVD91yRkQub+oNuS9JYA/bJGQOU3+K+sH6XDR7XbRtIV3u9vtcu/ePQ4ODtS4Ojw8pFQqsb6+zuc+9zk6nY56h0m3Ekmrr9VqxGIxTk5OuHv3riruWpbFpz/9aV566SWOj4+xLEuNF2mPKq3tTNMkn8+rZ1kUKiJBl+KAXAtpdye2jLW1NZV1ImqIarXKo0ePnlLRfVy3COvEnB62ZZHotpl2XYJMAUxr4emeBUAa3AE4GixVIBmQ7ei8SJw4LeokyZGiQgyLGV0MTOY4DFlmEwOdR9RZocaNoMqUMQ4lNCy0fI/oNlxfmbOsQ86EeRGiPwl+BfpdmDyAyBTyL3lUby5CutJ5iMQgsQP5kouz6eKcQv3fx9DjUco5l31rwU4zglYzikGJdeJ06ZFmRpwIJiZ+EGCNwBsmMcjjM8dmSNyB0QicA4jcN9D+lkfOhcFtGHlQy08xavucjk2mzet04ydsbLfJPYDoGGp/a5EIPvGgWoCcvWAagzlMUgvWOpmHQhbGXWjtQzCFQXrIeGxSnKewMwPmxhx9lqX5KEXhUZ/IZQiikDNgeAbtZplUbMbaaZ9IEl6swvo7M4Zf24DZkDxnjCnR9EzcW8skHEibDbSpzzFwmoA5sFcw8GI+DFoEuYBgBYLjCfZozIa3zfxunPnwIdXnLPQypCszrMMkfTLUyBBJtQhWF23aoilI5btMZwZxDYwoDJb28JIORk9jNp0SPNOl+L9A24N7b8CpCZGEx+AtjWAUZaNvwaWFs2G7Am4NXstAvrSQaWtlYALzAbhHYE/jwBZJIoydKQf9Nt5hDII8tmYxOU7gEiGDQeq+z9g4IXrBIXUGTh+6PrQC8LILK4DnQTqy8HXHHNDmENUgHluA8Wh8wVwPdNBMGEUhklhYIWKAGYdWB7yvmey/uUPfW0a/3yASuc8z5YDcOlz+RZdh4x7T9y4wcCPMon1S3pB1L0aeOWbiPWLeEw5sja8z4tRok/CjXJmX+EKqyWey3+fIPsAebhCwwhukmDJAM8ZQysF8Qno+ojDV8MaL47UeaSTbEa7whLGVpmPlOdai7GVzmK7FbpCiPg7oTUc48xWYrEJ8ShBziI+jFLjIGRdo8hfr7PBX7umWsBtpsfHWW2/hOA5f+MIX1GeuXLnCxsYG3/3udz8SdMuCX7bhcAjwVChVOJAsDJzCTN9HMX/wNPiSl+x5OayAT/mMBKiFWTdhkIQJlJe59F4WICTMoGmaqgIeBlFhj/h55jXMxoe9y2EGMszgCVsoRYWwIiCsAgh/b1gaLsAtzLjKfz/K5y7fed6rK98ZZvRl0Xr+eM57dMNFlLCXVxZi8m9hsHkeYP951zHMRH/UWBEWXf4rlgQptITD6uLxuCp6yO+eB8LnrQrnffXhRPNwkeU8wy/X8qO8zB81xsNs/nnrhXyfjJHwPRXgK4FRAsgFyAoIlhyDMNskBR1RLYRVJFJECY/x8LWQ5yHsHZZjDBctwky7PGPhQDX5mbC54f7vf54y4+OybW5uUq/X2dvbI5lMUiqVmM1mNBoN1tbWWFtbo9PpqOsi7boElOzu7qpijwRISfK4LPSHwyHVapWtrS2y2Sz9fp9yuUwikVBJ34BioiORCKlUSnlVRcYrRbd8Pk+pVGI+n9PpdBiPx6yvr5NKpdjb22NlZUWBx0gkQrvdZjAYUK1WKRaLWJalWjtJS0gpJLZaLYIgoFwuK0bTMBatnSKRCFevXqXVanHr1i22t7dV32YJqqpUKip9XBh/0zRVGrjM7f1+n1arpVqQDQYDJpMJvV4P0zRZWloiFouRzWZVF4d0Os14PKbb7Sqfdr1eV+x7v99XLdtarZYqEIgfWNd1stmsYn7H47FKli+VSiQSCYbDIdPplHv37qlCirCetVqNVqvF48ePsSxLqbUkN6PX6ynZtu/7ytozm80UA55KpRTIXFtbU+/8T33qU8rOommauh4yt4iVKJ1OY9s2p6enpNNpJaOXntkCLO/evUulUlHycAnMFMAvrK8U90QiHm6FFgQBxWKR2Wym1AGwmBOl8Cc5ADKHS8aBtHvL5XI8efJE9c4uFos0Gg1effVVfvEXf5FnnnmGeDzOW2+9xdHREVtbW4rZns1mLC8vE41GOTo6IggCdRxBEHB8fEyxWGR1dRXXdXn//fc5OztT4XtBELCxsQHAnTt31P4lCT2RSHD9+nVs26ZSqVCv19VzJj3ENzc3GQwG6h0mhZnRaKRUFx/3bZcNMm2Ttz9o0V9ZIojmwXYWXm5/DTJroDXADqCXgKEFyX0epkzeH1W4TgoHm3Xa1MgxIo3DkCIxypRwmNDHYx2TLTRyNOkzo0qURHLGc6sLkKOlIaOB7ULkCiSvQc8DfQTRNkRnEK0sAq2GFaAEAwuCMxhNIH4Vihfg8I8brBRnpPQFY1k1Yb4Pg2EEDY04RZZ4RJYJPlEyuBiawzQeoPszupZJAJQjHm4EIhoYCeg0AiK34crfhroFt75msJ2DjZc8Yocep906k5cHNJch9QdFCvoIf+LgjMHPw3gE1hnkBhAJFsc2ykNrA/zthfx47EFP04jEfZbmXeJpn+wViB12mO5/n3QwpdhasLxEYTqA5j2dlm8wz87oz0HrQrEErSdRnOkVJtodamaDwDlkQpKZU2XGEaWMjzOBlT4ENhyXwEy4RIYDIpOAnW/plG4n2E9NmEcHFO0b1FyP1uGIo3aL4cUpmVJArBFQs/LE0eh24exNyGvga5CLB+hpl84ujGtwlhkzzkKuAd54jrkDXgkeAoNf1LjyqkW2CVo8oKfZeDZcsmD6Adgj0D4J9c/CExsunEF2A8xL4B5C/gHEYhPcew08v8oHsRn2FdiJWxTuj5k2MzjaADM9ZzpNE3cvMnw8wIz2SFnQ68GjAJrmwk9vGGAGECkulBLjDhTj4AYw1EG3QQsWYWmzGcSNBfCeegsvvzVYyNKnBTjWDR57Gkdak5hfIv7aKumNY/K/CLVn4Ev/jykPvneLzLHOpYjPajQge3TArAHLOESbNvv2Y1qUsfwe43ScYLrGlXGUYrTJWqmDO3d4x45yB485c+ykBVqAZW3QZJU71l0sv0cxC8QDTtCJE+clfBwitIMae4MBOjH6ZOlYY7ShTXB9Ge31CdEnHrpvcM0tsMuYGt9mF4c//HPmlf/R9lcKun3f55/8k3/Cpz/9aW7cuAEsfEnCEIe3Wq3G2dnZR37Pb/zGb/Cv//W//qGfi39P13UlfxPfs4SgnN/CPtGw1ze8CBfAIfKycOqvgALxUIXbNgnDDYtKfqPRYDab0e12MU2TcrmsWBBpJSJsR5jRFoY0LP8WcBj2yAo4OQ+4whJj+DCkS74/XL0PA2oBLhIcJIsWQDGNHxVsJt8bDl8Lg+4w4y6Mp+/7jEYj1dZGFt1yvNJ3Xc5Nvk+8171ejyAI1EIhfKzn2dqwRFmOUxZS8rOwTD1c/JDWb8IqCeiW/w+z+CJXlLERZpQFdMs1lIKMLBgl1V5YGVFZyDGFgWT4GkmCtLC/H1VYkE2ugxSVRMkg10BAbTi1XHzAkmCdSqXIZrNks9mnvPXn73sQBE8FEYXHjpyLjHFhaIRBlcKDXA8B2OK1DN/ncHEgnE4fPhZ5jgUcyD3+qPnh47TZto1hGFy4cIHpdKrA3NnZmWLMRK2RSCTU2DPNRd/sWq2mngsZ55FIRLG7kkh+48YNNjc3Vd9hsV90u12Ojo4UyIzH4xSLRTXGpG2VpmlcuHBBtYTKZDJKAWTbNv1+X/1uWIVzeHjI2dkZmqbR7/dVIVTmg7DqQo5fWpXJd8Tj8ac8xVtbW9y+fVu1YBIf9SuvvMLdu3efUhKJXeHBgwd0Oh1WV1fp9Xokk0kikUVPcFEWJJNJJpOJkg+Lh1sk6bZtP9WSajabKR+5zMvpdJpWq8XZ2dlTORDye91uF9/3lapB3g/So1zeMZJCXqlU6HQ67O3tEQSBarkm2RPCBkta+2QyUQqswWBAoVBQsnLXdVlbW1Pyd3mvAVy/fp1er8fjx4/J5/Oqt7VYHuQZPzk5Ud53GZO+v+ic0el0ODs7U+/26XTK9evXSSaT3LlzR2WBCOh2XZd6vU6tVlNzWTqdVu85GWNhBY5t2yqxXq57WCEm19PzPKWuEhuFFJCi0Sjf/va3efbZZ7l27RrlcpnPfOYzCrxns1mm06nqu+66rloLSUcAuYePHz9W75WTkxPlK5fE+SAI6HQ6PH78mFgsxsbGBo7jqAyGer2uwgOfffZZotEot27dotvt0ul0iMfj6r9yDBsbG1y5coVXX32Ve/fu/XVMWz/WbYRDOtD4VGubk5lD28kyt4f0Yg08a0gqUie60mcwXcaYFvCiA/wgwLVM6sxZZguNORmmzEjxELAwCTgjyj5ZRsQoUqPIJodMtBbZoISWbpG52aU7h6PHsFSEaBbiL0LhE4sAqqkF7m04vBNFGxtc6MzIBdDKLGTG8R6M6mDfgsR1SBeh4HvoWsCxB4EHibvQ/C7o8xkae0AZkwwRXcOMTvHmRfyggOZ0cA0fmwomBTzrMdasixmBOJBY9okXoVVbSMRz30jTa6YI7p1Saem0VzqkP+sx+0DDm5Zwy0P8NNhRMGIwug2jNiQq0DuBZAfya1DPwCAG6TkkMzA5izFvmuRTY3IbkK9AzAkY22Ps4uJYOqNFzp3bh2ETHGx0zyUIFt3ejltQH7qYnGBqM4KYRdodkwtKaLSJYTNtaFw6CSg68EEAoy0NP2rg2jpGxCM+ipKyMmSvTOmedHjSfA+fJgdBFWu6RGW6R2INtLRDxJoxjfaIZB0m5sJ77vUX51XYXISLDVeg48LJmo6eLkA/zgXrlCUroI2Jdk0j13SITCBXg1QtoL8MZW+RKD6YQ/4QYocwNyG6BwwXSgIHSMdhGATUGTHDYu7NMMdQei5g+caYR18fYx7p2FaCqT8nzl3caYT6I53KRZ+uCW3NwE0FRPAxjEXLs5YPcWuRM+jbi9A0LQV6BFwbNH3xM92BpAYjfyF/91zIxGEZmBHQY46VmGNFTJxejXt/1GHt2Rn6NYhU4NJP+exOfUwTchlwRw7WHhj3wfmeT3nkseIXOAzmOOaMWcal189xv7NDvQNZTO4Q0Nc8AixcYwQdn2Es4I/dOd1JmWh/wEbGxzUhSwyHEmd4zDCIkuAVxkRY5d8zxaNLtNHG2vGJ6hMu2AmiFFnG4gbf5wozvk7lLzTn/JWC7l/5lV/h1q1bvPbaa/9T3/Mv/sW/4Nd//dfV34fDofKiCbAT0CzgSqS48DTbDT+cXC2fOc9+iow4LKk9Hz523rcrL2UJmpGXpMg3w4slYTflTxj0hdns8OLxPHsbZqUBBRjPs/fyb/LvwA8xk+cBGnwoYxcwE/YPyzHIMYUVAmEP8J93vuf95OF9n5eof9Q5h9Oy4UOmO3z9wgWK8yx/mOk9z3iHx4IAj3AWQDioDD5MyJVrKqBf9nFeyh5mqeX+yu+Fmd7wecgWViScv3/hf5P9CVCQhaWMbWGBP4p1Dz8rclwCikWuKOqTcDhc+PmScXk+Tf2jnsXzz2n4HgtTLgtkYaPkmOUeSo6C7E/OJXy/wsqN8Hl+HLf9/X0ikQhf+MIX2NnZ4cGDB9i2zXe+8x3q9TrZbFaxk47jUCqVFAASMC6gVIo8AhxKpZIKhSoUCoodFcXHaDTie9/7nhqT8jkBRvV6nW984xs8fvyYeDyuZM0y1gTQTqdTJpMJh4eHqmfxZDJRAFRkyNlslvF4rKw6S0tLCvTJOAynmYskXDIBNjY2WFpaIhqNsru7q9jWYrFIIpGgVqvxZ3/2Z8TjcabTKWdnZ6RSKfr9PsPhEF3XaTabah4QFY9YLyQAq16vq7Tzo6Mj8vm8GpNyXq7rqqRqkanLtTk7O1MsqxSN5Hmez+fqfjUaDdrtNolEgu3tbaUCSKfTZLNZ1VdckselCBEEAaVSSRUDxA8uGRbS+jESiSh/fq/XYzAY0Gq12NjYYHNzk9u3bz81V1cqFTU/izT/gw8+YDKZsLKyogLypAhpWRZ3795V/7+/v6/6U0tB5d69eyq4T/zzuq5Tr9fVeEyn0zz33HMqzE0KMwKoBeTK/BBWg4m/X+ascGaAzKnxeJy1tTXFpsu9b7VaCoRL+0+xgsHCaiYWi2q1ymw2U0V78VnLvoIgYGlpSa0npAgsGQedTke1uZOi2mQyUYXz8Xj8VGCeruuUSiVs22Z7e5v5fM6nPvUpPM9jaWmJer3O7//+71Ov1/8aZq0f7zbhCfeJ8r/xEv/XcZ87TBhylT923+Lh+jusR8ZEMmDNGswGBYKVEvgDjCOYkmSMQ4UuCaJYTFmjToQoaQaUsDHRWaNPgRFW/JBkZgrzHvGrHiMdvnc/imb7aLbL2sYibXqYgmEXJrfgm78T48HZEulgAA9nJO9DJgNDH2IRSKTAKoD1EOod6EzAS4BuQSYG08dwcM/AtaMUaTCmyYAI84jGUhlm9Sy+t4LnpvDdNCZFdOY4EYd8bkHwu02NSDmg+gI01qCdhPVrI7q3p6SbULAC5n/HR6tC7U6clOcxbemcvQH2J2DeA2t/wWY3LfDni5A2tw5lHTYuQS8P5mcgc8HCalikUmBM4eh9yHk65pKPloexu8iyW+nC9OsaRmOZLDES6Q7+OhwB02OIjgJKzHCCCFigBxFSxAjoEtGni9T229C9C+4mONtFvFgMrBHzdIb9rQax/TYOAZmaQ7dlcRIsEZAgZtRJrEFch7nuMN05Ir3uU9QglQLWwY2CYcLSGlzIQ2YAyT5kGz63t5bwNzfxbjfZDRz2fJcDdwHMC5+GM+MHEQIWPPkT8EewchW0C2CmoTQBfQDBfUhpP8j0s+GRBnsxg/hMpxRo5B5rtJsRjE84pFcDOsdxNKuCjsUhHmOilKYOsciEszWwCxG0iIMTA88E3QDDWqgsIv7Cx52IQNRfgOp4AMYMvMhCtm0HYFtguAvpv+VCw4WoFqHMKgNvjBf1SJEgeZQjfTIj/exClu5OYRoBy4PEDAoGrG5DsgZnPVh+Mueib9PQ0owDjfRkRIIic2rskyeFRg2bq8GQBhYNOwpGkqAyZJA0uHMU4+bIxJvaDEcaZ2hM0Omygk0BnRl5okSY43BCgE5+VKbRNbCu7ZBqzfj71hYeeyyhU2ed/67fW6S+/4jbXxno/tVf/VX+23/7b3zrW99ibW1N/XxpaUmxF2G2u9FosLS09JHfFYvFnkoZl03YGwnOkWRRYXjCXtHzrF+Y8f4o2ar4P2XRU6lUngLdku4cfoG7rkuv16PX69Futzk8PFR+M2EOpNougTmz2Uy1dUmn06oll0jvhsOh8mBL9V2AUhiYC4iQRUk4XEyYWelzK0B1PB6rhakAEQGAYUAIKHYn7OmW/Yf3KccYZnw/CjjChwWCjwKjckzifw8Da/lZWFYtfr+wPF96x4pENuynDrPI4WLEeSl4+DzDBY7w74fzARzHUQmxIlOUTa6vJC7LZ+RehoGrLKilsHP+mKSwEb6ucuzCJIcVBWFWXIpIIu0NgkAl3Mof+buErcm+hXWaTCbMZjPi8bhqTSXXX+6p3D/Zn23bZDKZpwoq8r1h1YAsaiVdXb5HihzClI5GIzRNU+Na5hPxJ0rQlhTO5NrI737cmW4Z7/fu3aNarbK7u6vCwBqNBpq2CG4SqbgkgE+nU5W/kM/ncRyHdDrN5uamGkcS5CceebEPLC8v43mekiJL26harUav12MymRCLxbhz546S5sbjcd555x1isRiXLl1SIF8YTfEeJxIJLl26pOZ8CZWSOUZYZbE0hItEqVSKer3O6uqqApByjslkkkwmQzweV+28JGk7CAIuXbpEt9ulWCzS6XQYDodqnpH5z7IsdF1XidDSZ9u2bZLJJBsbG0ynU5Wkbds29XpdFZSE9RbQJgosAX+6rtPpdGg2m+p5LhQK+L6v5nDJVwB49OgRqVRKyZOlp72E3TUaDaXCkQKctBCTOU3XdarVqjomKQZsbGyo/9e0Rc5GNptlf3+fd999l1deeUV95/LyMrZtq6A+6d9969Ytzs7OVCsr0zSpVquKOe50Ouzs7JDL5RgOhywvL3P//n0VHjadTlVAn/jvRUW2v7+vFC2ACk2TexFWG4m3WTJVpACk64t8DwlX03VdJatLyv3GxgYvvPAC7777rhpzAvTffPNNEomEav22v7/P4eEhuVyO9fV1yuWyCiCMRqNUKhVVqBcZuhQc0+m0Okdphybva1EqyRx+9+5dvva1r6FpmrINyPWS7jDD4ZByuazWMYZhsL6+Tj6fp16v80d/9EfKS/9x3y5hcECU73PMBhMuMyPKhFbgcd/Q8UwNYxhgVFwC04HpMqn2kIQ/o8cMHYsCUxxGZBiwxREzXGbsYnATi1uk9X2ivo4VWJCApVUPvwD1fcjPdOJpn/wNqH0CugEMziB1H9773SQf7K2yH2mx5I9599Qg9o7H5go4GZiPF2zvNLMIOpsfG8RvzMj87UVv6JIOVKBHgoAVNCbE8bHwcSv+om1WI0bd05iRJUIKw7jNdnxAOj4jmV+o7APLJBl3CIowScBZDLZf8Nku+iQDGBk+0+tQbsGFlkMvecwgcDFuQWkLZumFxNxtL8BipQpeGqanUJ6BN1mkakc2YLwRUPgOrEXAzsPZozh2exs7VSdX7BO9smBQgz3wjw0ivkeAwdw3iOkeyQbM78F0EGATUAjS4BjMcLDQ0bAomGMYwaM+JGIwKUHgRtHHc5KTOePSKqONGVamT7IDEUPDC2okyaDxiGmyiwekJtBeAmfXx08uJOCxExjrEDwLMRsGzUUq+9CDSgbW/hT8//qI419qMom6dAO4vAwnlkY9GmCW4I4ZwS8HXLrtEvtAIz8ycTIOxyU4qUFqDnENXB2qaYjmF/3Y14vQbTZouxHiUZ+Ja3AwXCf+rS7bF3p4l6fkOkfkegZvjDcZBCus+w+w9AndQgR0g8AOcJMacVwiP2Cwpy4QXSSV48E0sUg3d/VFIYUpBC7YOlSG8LwGzhTeHoO+Dtefm2G+fYY5yzO1olSJU7BWefjfOhgZh9JFwITBI+i+DeUUxF8AdxUmwSIQMIbDNhrDIMJJf8ou22Sp4POYK7gkqbBCCheTJ9p4USVI6j+oFsRwcQjwsXS4i8Z/wWCORZ4BFWKkiTHGpsq71DjgkPWFj8EbQ8LAxGSTe+Q44Iw0f8SMk2oHPlqc/T/c/tJBdxAE/Nqv/Rr/+T//Z775zW+yvb391L+/+OKLRCIRvvGNb/DlL38ZgPv373N4eMgrr7zyI+0rzACHJcHwoewZUKD6o4B3mMmDp1nhsBdUglUEzISDVmQfAmRFitvr9Z4KeJL+yvIil4WQLCBEshY+LikKhBnRMOsbPhdZfJ5n8QQgSuicnMd5ICPXQPYb/v6wfzx8zcP7ECAowDC8hUFl+DPhaxguIMjvnL9nYcb0oxjp8yBZjjd8zOH9fhQbfX6MhMfK+cKBAEIBmuFAtDBzHT4eWWiHx50UUsIS/fDvhQH3+et2np2X3xXwLZJMAUzycymSiDIkfG7y8zDglXsnxQLxtorXW0CCHNP5Z1PGYHh8CpNzXn0RTmoX8CQskRSFpK+tdEWQBaS0ypHPSnFEnlMpCH3cQXcQBMq2c3h4yPr6OktLS3zmM5/h7bffZjAYqD7cwjKurq6qJGcpXPb7fSKRCKPRSBXwOp2OAjMCJoX5C4KAarWq2EtJxJYiyjvvvMPrr7+u5rTZbEa/36fZbLK1tcV8Puf09JTT01OVVu77Pmtrazz//PNomqYSz8vlMqPRiPF4rAovMk4FVFcqFcWyS6um09NTRqMRhUKB5eVl1UJO3hmpVIpYLEa1WqVQKNBqtdjd3VXnK/O69KEWZlXOR5jFXq9HoVCg1+tRr9efer6lQCzzkLS5Go1Gyh8sNpZw+KYUFAXwSrFX+llLMU0KYpIbIr7xSqWi7le/31dFA7GNCGMq+5F3hhSWHz58qArJ169fVzYcw1j0mO73+6yvr6tnVIrXzWaT1dVVyuUy7XZb2cykzSagkvHFXiQMdRAE3Lx5k+FwqEIAL1y4oCTZ4r+3LEvZEaQIsrKyoqwRmqapcSG5AXfv3uXhw4ckk0kF9KWAGAQLu1Wz2aTf7yuFRy6XYzKZcOPGDUzT5MGDB6pAZNs29+7d47333mNtbY18Pq+KDTLXZbNZlagvc+/Kyora33A4ZD6fk0wmVZ6CzNnz+Vy9D6QgkEgkmM1mvPXWWwD0ej1arRbT6VQVmqrVKp/97Gf5gz/4A1XkPDk54eLFiySTSSzL4g//8A/57ne/CzzdjvTjuvWIUqPGPnUOuMgGAVn+Iz/pOXzvSZbh0ox0xmFmlyGZxWhOWJ2vksEhoE8WE48YfXpEmDFCI0ZABI0uQ/LpfbSlCbNjk6y/aPkbL0AQg+pFSBfmJNah9CkIauB2wXkL3ngV/vhwiTMSRD2LCRH60zTt/RbrM8hZMHsPWn8Gk7pBfFDF1w1Wrh+jfxL2NEg3YLsG5VWH0b08Y3RMAvKAttxgloK5puHiMaHCKgVi6beprM+wenA6gnEnRcGA2jUHOwd9DwYRODBh1Qa3Au88D4MCvHAC2xmXJ2mY1sCeLzBLtQbOKrgL/IIXh/kM8mUwlqADlA4h1YXBEWS+r6FtB/gFiE5S2AbgaRg2xKswzwMFKC67NJwm0blP3AYnAh7gn4Ax87EYo7GM/YMk7DEdRukuhmMQaevEqzbjVTha0fGdOVlrQjbtMJ7AbKmKfblH+V2dwSxBjCEV45Rg+5TSLCDzps5o2ccoQ6W3YJy9CNgZwALju9C4D8MsXLsG3iW4u7FInH9Os9C6HU42I5y6NsFUY5KqEM21aTahvfoyQTng6NXXuTkPyC85nGzA24tlDuUp2B2wBzojfEZlOIlHKOGxlpsTG81JfWDSmdboXbxGuj7HP3mD5M8MqKc9to48tr7bYtzfJBGLM9iA+UpyERQYsUDXCaZgBeDNIdGB6B2ovQ2ZLDjXF/dAT8LYXHwuZkP2DHYeQjmAzhXwaov2crsv+BQfPKH0/TjTeQZ95jIKqnz3nU3+7LjO+qrGCibxw4DqQCexOsC85mNkYXa4CHmzA5sAi6vkyJLG5ZAxUVoUKBJnlQkBfXyKRAOTynDCzDcZrwFxB0OPkPAMZp7Ld+wct1bX0aOHMOyTHexw3V1lmTk16vwkDk/weVSKQ2BQffWES9aUJAdYZPnveoevp7s4+g+3pv3/Z/tLB92/8iu/wu/8zu/we7/3e2QyGeXTlv7KuVyOX/7lX+bXf/3XKRaLZLNZfu3Xfo1XXnnlR0ouBxRYEGAQZuqEPZNFvUjwhJETP2hY8hUGT+eTucMSXmHWBXy4rkur1aLX66nFonjs5Hc8z1MgXGRnvV5PJTO7rqsWHsAPgVGpzAsYkmMVoBH2nn1UIUL+mKapjlnAnxQWwqy0nPt5if756yD3Qc4hDDhF7ptOp9VCJRKJqCJDWJp9HtzKv52XDssiTdgq8RYLgy/KAvF+a5qm2BRh5eTayf4ExArABX4IjIpPU/yOcs3k+oYLChIIJJ5+kQUK0BuPxwokiIpDWNpisYjneYzH46dC9gQ4yn5lHGezWSX7lHMSwCoeZ0lklj7G4UJF2G8NKJWA+KeFUZT7KeBXgLFlWSoUSUC1FHKk4CEqDU3TFLMu91vuvQA84Kk2eHI+k8nkqWdexlwsFqNYLGKapgqmCoKATCajMgPkuyX9V5Q24VC/j+Nm2zbZbFb13b537x4nJyd88pOf5IUXXuD1119XwWOyaJexLj2Am82mCoIcDAbk83nlrV5dXaVarT4l05Z7mclkyOVySn4s9/BP//RPee+999D1D1sySTib3KfRaKQ85+FEepHoyvyt6zorKys8fvxYsZDVahXP86jVaoqJHY/HFAoFSqWSAhf9fp9MJkMmkyGbzZLL5ZTCo9vtksvlODo6ot1uc/nyZTXHChPqeYv+xqKeECZ1PB6rZ0fYd2GFpXgkxR7DMCiVSmSzWTRNY2trS6WGj0YjJQOORqOUSiX1PpGEb7nWIudPp9Pous7y8jLVapVqtUqtVlMFVJnv5XmVIqHMqfF4nCdPnjCZTCiVSupdKs+XsLzHx8dK6XByckIQLPzgy8vLVCoV1tfXlV9Y1GDSkaNSqShfveSwFAoFPM/jrbfeYjqdKn9+r9ejVCrx8ssvM5vNGI1GOI7DG2+8wd27d7Ftm1qtxmQyod1us7y8zNbWluo5Hm7RJYXLIAjU+8FxHO7fv897772nulO8/fbb6hpKUcDzPB48eMBoNFLqgbW1NTRt0QmkUqmQSCQYj8fKey4e+rAar1AoqMLGaDRS2QoyPzuOQ7vdVqogUXFIDoe87yVp/8mTJ+i6rmTmp6en6l0jaetyneX9sra2xsrKiup1r+s6m5ubPHjwgFu3bvHee+8RiUQYDoc/VGD+OG49zWEryFIhjYXHPQKOWeWTHPIZy+Y/DGu04zO8eBxI4ftzmgRoJHkWgyRRGujMyeMSYYJPHp0sSxg0WY3ZVNfA1lw8DWKXIMiBEV8kUOdvQPYi9CLgHMP0W/DH38nz9SBGdzVB5DRGxClj0yOmO+gpILoAQr37MD4xmPeLuJTwfRejpbHqBlgpaEagbMJKzeLxwzZDL4LOkAp5bM8gt+Exe6dHxi5gMGadBLiQTILVh34TMk6SdGZGfAvGOQj8RS/v4ACC75VpxDU60Rb5q2DGwN+F+B3Qegtw3W0sGF7NA80Fuw9jC9KAUQLiCzmx24TJ2ULWPHo+wDJAewhGZEDxeodsCXplaD0Lyewi3M0yQfc0SszwVhxOKzBpgT43KFtpYJmABDorxIgwMQ+wll2cGFTLi9ZlD5cTjGoZNNchhbOIe7fimJMhRkdDm5YxgwQFXFbTHeLFgL3H0CxqmDugtxa9x7mwaKtVWYHuBLrfBnMI1jqcPAH/Mcw+B+/+BMxeiNNcv4oTT/H99jtgg527SD8VZZpvE1RzEEsy8VLEN4cYm9CuQc6FlbfAnMLp2CA5KsKtLq1lj7Of2KQ5G1AZtci5kI96DL9tYZ7YLM2rVCfXGb/+fRqft6l/EjaaE66/NWJueHQyEOS0RcVC98A3sSYxYnOLogur92Dlv0KlAelL0N4HW4PSBZgVYV6ClAfzb0HnzRhzzaDoT1nehba26L2+/EJA4uaM0ZMZ3VeHBL0WaT+g1azSbBTJkMOjjlvdJ/sTPpO1hax++D0YtKGr9xnRp0uUE1xW6GCT4zYRLgNbjDB4nzI3qJFmJYgSG5X42vAMdytg0p0ynnvU93XO5gWCXJ9Ypsc0toExtdl255SwITpkTfe5OI9xbFfwn9h8enDIJRzu8yLvY/G1pdcZxaPkDpPA9Eeec/7SQfe//bf/FoDPf/7zT/38t3/7t/nH//gfA/Cbv/mb6LrOl7/8ZSzL4md/9mf5rd/6rR95XwIOAVXxlU0Ahbxsw+AzzIILaxb2f8rfzzPJ579bZK6+7ytvVbvdptlsqkWCACXDMJR0T8CQgM8wqwc/zPDKeYYlw7L/8x7V8x5ZAVdhdjTsrRawFP48oAoXYTY1DIzDPxOwGj5O+LCfsiySBXwLqJ7P56q4Ib8Tvs7h4xcwJ4Bb2m8JCyTsvYB+AVSyuAeUDPw8Ex+WE0pOwEeNK1n0SKJvWIou8kYB+lLMEEAiYDXMOgtraBgGyWRSHYN4+cLsszAbAmwlmEr6Tp/3l4cZYkkeH4/HKnwwXFSRZ0CKGzIeEomE+pn0bxZgJuNXrpmwLjImwmNSlBrAU2z4RyknpBgmYEvOR9hpuZZhZYfsT+S5kr8QVgrIcQhLKd/1cd6Oj4/JZrNsbW3x4MEDYNGm7/bt26yvr3P16lUePnyorouAE9M0WV9fV3OajN14PM58PqfVarG5uakKIALYpDAj4VtSmBQbzTe/+U0ePHiApmmKSczn8yQSCTY3N1WrMSneSQs+GfPCFq+urlIqlZRnXYpE4Tl3a2uLVqtFq9VSwFsKYeJflpZkYkXQdZ133nmHO3fusLm5ieM4nJycKKZSnh34kAkPPythu0q4iAUfdrzI5XJPFQiKxaKStK+urjKdThUwzOVyTKdT8vk87733ngoYGwwGijmWFHS5d7VajevXr3PhwgVVbJHQRun6cefOHaWAkTlAJOqFQoGVlRVVHFhaWuLq1ascHByolm3SkaRarfLw4UMVyrm6usrnPvc5dd+KxSKj0YggCFRhQzzxa2tral7o9Xo8efKEs7Mz1tbWiMfjquWZHLO0LRMrSTwe5/79+8qKYJom3W73KSm2hIqJskwKIDJ/tFotRqMR165do1KpqOR6yV6RcRwEAf1+X/VCn0wmbGxssLa2psbNpUuXmM/nNBoNtre3WVtbY29vD9/3n8o/uH79Oul0mtdee43j42MMw1BZBPv7+6qQBKgiarvdZnt7m2g0yvLyMs1mk2KxqNrMwUIhIIAZFl1jEokEL7/8Mi+88IIa64lEgldeeUXlEjz//POcnZ3x7//9v+fo6Ej1LA9buz7O25gjuiRZZYuH/AkBGRrkuE2SDdZ4sZ/gLfeI2aYN0T7oFTzdZ8UfsME2DeIc0mOKz5AhOwTMcOgx4xI1PDeLrXdIlCCRAL8KsTWIGDCZQWoZHB1634PZtwy+dm+Zr5cyTEpdiBs48wjFRp6sNmBzrU/1AvhRCNrgNmA+T+KRxmRAJMjQv5/g0sGU4i50S+DfgUgXzNgBqekSM2DEBK2l8cwWzC8MqL/lUtbvYZTHzFMOjQMTq2NiuhpJzSK3PMFIwCMH9gyYvgvRN01OrcXxrbxlECt5uCaMWIBtppCaQqwIehyMISSjC0+yboOhgRMApwswrnmgTcC4DMYm6O8uwH3lGRf3FTiIw72yxnRV58rMYzkDbg5ycY/B2oijq6B9XyP/zTXsUY4+UZKUmLFPEpMkRfJuh3SrT/WFgPqLMR5e2MDJAFaTmDOlPAs4G0UAl8T3T8ns5RkHGXQi6PiMch77VYP3l1IEGw7b1oySD2dLGic3c+gHEW7Wu1Rsj0Ffg3hAPgd3+pA4BeMdjcONFezP3gBrDdw5vcLBoi9bkMEq/RRWrgexPMx6pNemLFeh7i9S2dfehMkp5F6ERNRgRoXcbEiu7YGWQasOCSIwSYNnBvQKcxKvv8uV4zWcAFJ7uzw76PLu/9qke8khf/uQaWZMr2zANA6uC/H0IqLc1ogGDteaPjeOoLIE+t+H21M4+n/qVIYR3K5F0tIp6Rp4HsfHUU6nZSLEGX/riO1P2OQ3F72/p1tgLkHpeSiW52y9f8L6vsbjkYEXP6IcaMRiHqtf8Cn9A2jk4eQPwfr2D/qCBwY9otxiDx2Nq1xFw2UNjQjQ0u+zbbbA9qhHVwh8h8+4czbHJo+jG8SNJvN2wDu9GAMKMJlgzQusTud8aTbiJQKS1MklZyRyPl84HrDRr9LlCT/LkAZ5/t/6MUexfcZRCywbK+7B+Eefc/5K5OX/R1s8HucrX/kKX/nKV/6n9iUL/TDIE6AoQUuapil2U3prixROwIcs8AUkCosYBuxh9k4Wm7Zt02q1GI/HHB0dcXJyQqvVotvtqs8JMA57lwVMys/lHISFEM+3MCXSV1xYwzDoPQ+YBVyclwQ7jkOv1wNQwTkC+MOgMxyUdv77w57m8P6EeQzL+IWBEbAdi8XU9Zd9nAeK56X1YTa2UCiQSCRUeE84nAtQ/Vin06liM6W4kkwm1X0NX+/wsYrs+fy5yD4E0EmokQADYa9F5hyW6ocX4MJ0i3dQWl2JBFcW8MLGiCJBAKhcF9l/Mpkkl8uRy+UUgy9jXha9IiUXFYSAkvNstVxvYbUFOHmepwoVUhgQmaplWYzHY8Vqhq9zWCUg+5f9yP2SayRFjvAzHb4fHzXOwgUDTfuwfZosvuX4Re0iYVzhItF5G8HHdet2u8rPXCqVOD4+5s6dO8AiX0OY45OTE2DRReLatWsKQHjeIhRSksnlnoWfE+ncIGFSsmgXFdF4POb999/n7t27aixvbGxwenqqwGupVKJYLKpODvK8hpVMlmXx7rvvkkgk2NjYeEoNI++CbrdLJBJhf3+f1dVV+v0+6XSa6XSqQIXIrqUAZNs2JycnOI7Du+++q3zgsADNiUSCRqOhAKAAdknADsvKBcBqmsbS0pJi8qXlV6vVUj7iSCTCzZs3FfMrRWGRH4sU3DRN3n//fRX+JgUOYa7lWEzTpFQqcenSJVZWVlS4ltxDmffm87myhiwtLdHr9cjlcnz6059WEu333nuPXC7HysoKFy9eJJ1O02g0SKfT1Go1Dg4OcBxHqRkikQilUol+v8/JyYl6fkUB1W63yeVyPPfcc6oVlVgHBoOBUp7InCnvnQcPHrC7u8u1a9eUOujixYtcvHiRr33ta8xmM9XG7ebNmxweHqrCWzqd5ubNm+p9I23TpNjX7XZVizrTNLl//74qiEg/8kKhgGEYdLtd1WlDVB/SyUEsLWG1hPRCt21bBdHJfD+dTjk4OFAFKxlP0g1AfOemaSprhyTTS697KVwkEgkKhQL5fJ6HDx+ysrJCuVzm5OSEnZ0dSqUSe3t7bG5uqn1XKhX6/T5BsOjs8PjxY548eaLWRFIIEjb+47yN0xrf9wc0Jl0SQA2NY7PBOwmfV0ZVrgZ9GOX43ngHxzjhwjDgGX/OJ2J3mFt9bLaBCEMmJGgTx8QnwOQIjTiBbuGkoByFTAD95MLf7PgLv6xbh1kPRq/De/eKfCuWY5KuE3WnWLUd9MGQpUYKPchQKg4pFsGaLn4vMoSoZ2ATQWOMSQLrSZUHv3+A/w8DrA3oGAv/rx7z0aceLhpdekSaaR4cWGSu24zenpDWs0yzPY4GEYzWOmkMapwSKU1gJ0BvLfzcPRui34agZzLfbKCNYJwCMwHch947QBrMMiSKkLgIncQCaEcjMMssmOHZFPBgaQLpNAwj0N//Qc/phxDsJYlaAbPEjME6NGJw5CXxIjkizhkXDJ+avgCYsZcWfbHnfxojMszRw+CMJCYBOho55iQYkyHAqsLDSpKzy68QrJTRjl9F9wbEPEhMIOba6N4BSWvOAAOfMTU0OtEpt67n6P3cDn5iAyyLg/dfJZUfcrSSpX/hFyCd5mHj/8v2WZtaz+Cg7IETUMpA6pNwkIpjl29AfxlOxhB5QixogeNgO9+HO8sEuS14dhUiURziNGdj7Dhku+DeMXA0H/QACIgQQDvN8Hsu2tUGyWs9xuMEllmCCxrexSKFxD0Kv9ejNcgxZoWbnefR/svrGNf6+GsNui/4TG5mwc0svADxCAwdCAI0f8ZGw2djDqWX4N4y3HkbXNMnnnUYTCHyJE3B1zHifbrzJF2ypJhS8zySHQiy4GehZ0KQgHgOyp+G7DKkHwbkH7nYMSjnIV2C4EVo5Bae8OH3wDsukDLHmO4yaXKsYuESJ4GGxpw+Odr0yQdDuk4Nmw18shwmarRHB+wOMxw+zlHql8gGq7xNix6rZIY2657N81hUiPOYKVvpOqmEz9SGauaI6OCb9I06Mc/hfpDjSeoJSXzoVWBzxLyUhPdbP/Kc8ze6lCmeMwGC4Zd2mEGTBVy4x7Ku6yroSxaR4eC1cGBYmCWWn8vvyIJKGO5+v6/YlvOhUuc3+Qx8yOZJOqkAA/GTS3AbPF3YkO+Xnwm4CR+3sEfiI+73+0+Bd1nshdlyeLqPs2zn/z/sOxdWWNhkkU4LIy0S7XDYXfj7zoNuueamaapWQqVSiUKhoPYflrQPh8On+kkL8JKQImGspeAQXuBJII0w7+FworCsW85JwJ8wSPJ7UmwI+9LDPm7Zb7hvtCzA5drI9RemWu6r7/uKaZcFnyzmxEsuxRvZZ/jeiA9VAnuETQyz6Y7jqBYywijJ8yNFIGE85dpIKJtIb2UMhgG/PDdh0C33/LyHP6xSOS9DD/9Mxk84gC9832Vsi39TnoXw+P44bzs7OwwGA+r1upL2i2rhyZMntFotLly4oPIkdnZ2qNVq1Go19vf3FTMo8mwZR+IDTyQSZDKZp+ZbCWgDVI/pg4MDHj9+rJ6TQqFAs9mk1+spibcAxtlspoqDwtqJrFnTNI6OjlhdXWVpaYnNzU3l55a2V5L6/d577/GTP/mTKsCt0+mo3tK+76twM99f5HBMp1O+853vMJvN1HHIHCSfCWcRiCx9MBgQi8U4OTmhXq+ztLSk2EJ5XsViYpom7XZbeZ/X19dZWVlRdhN5TsRaIgWE09NTdR9c11XPv4SzybPyxS9+kRdffJF8Pk+n01FhgYlEQhUlHcehWCxi2zbLy8tYlkUul+MXfuEXSKVSqhWjZVlKol6v11X7LfGwZzIZksmkClq7fPky5XKZ4XCoiifynnnw4AHvv/++Usr8/M//PMVikb29PVZXV9U8Jratixcvcvv2bVWwFaBcLBbJZDIKFK6urnLr1i1VQHz06BGZTEb1Z3/hhReo1WqMRiPlYRd11dHREb1ej2w2y8nJCYeHhzx69EgVc6fTqdrv1taWerdls1k2NzefCoSUcSpZL2KzkGu+trbG1taWGksHBweqaHnv3j0qlQrVapVyuaz82ZKKDwsVhaie2u22skZI33hJvB8Oh6ysrBCLxVhfX2c0GqkUeclhODo6wjAMNjc3yeVyKjxOLFFy78UqIAqZj+tWHm3TNIfsUecqAQmGmG4cy0nzWvSYuqPzQrDN8XGEdizOi/4mV7lLrTTkSVcnO98EdAaYxKkyQ0PHoIBPwBPi5QmZ2g9aLA0WbZcaj0DvAk8WzOXch8OTCneddQaRHgEJrFwWGl0ijRlTfMp4mFGN4tWAuQm9LuAt+mhDgI7LhAGak6Hxpob2twK0Zbh9CT7596D6n2CvZxCgM8AiYsXpvqFz7Wd9Ss/tM7qVpLMXI+tfAnTgjGTSYf1Fj6AEswewPYD2axqpO1mS+pjZyMRv55iv97B9n+kAEsFCgk4aEs+CU4KzAegp8DTo3oclH+KJhYXYr0C0ALMmDBww59C5lcRwVymsHTK+DPdWTQZjE2+cAKdA09M5Gp1QsgK6BsQSkN+HzlmaMadEMdmkhEUai22ydInQpL3Wofl/qTB98QUobGJ2vkV21MSyIZ1YMOs3+h7r9ojxKuhnEzYPYBZ3uPW5Kp1/8HcWiW+9AwgmBBaYFQiqwFmLaP0el8odNg/ByboEyzDKLdrBHWZMDi5tQjkNwxmUBpizRxT6c+I2ZB600b/XoRO9R302wPvSJ2kXLnCy9y651YWMO7/j4fegngTnRQezfUy0n2HbMzAGdc4CnWlxZ9E7rhSDSJT4zl0m2zaj9xIMgxTv41I7XSbnjmj/pMfrP5diUivD2IEM4EZgHgdzTv4oINsGvwinXei8BfnHMNfBuOBjd2HoBQSFEVvrYN11mDtRlqJtNnc9KIIXLIjzuQYxwPEWIXqVGxAtwrwFfRfyfwuSN6AbXXw+uAvevRRjv8xtO0WeDTYxmZCkQ4Y4Jj1mHDCmpgXEg6s4FHBIkLM7zOw+EZaoBnFyx32qfgqXFIfUiZHhk57DJW3IOIjynylhYvKL8x6d1AnHno9emLFZ+x45L8DrG6Q6NtF5lLYZRzM0UidLxMYbdPjTH3nO+RsNukVGKp6n8CJaJMbnpdlhZlx+RxLD5YUrrXTEJytAwvd9xRS2221ms5liQCT4RIBXODjqvKf6zwvEkkWBAOwgWLTf8TxP9aMW8Hb+e+BpeXhYdi5s0XkwJgyRXKPzTPb57xfWXM7rfPiYFBGEGRXgJdJOYTDDYV7hTcAooAC6ZAFsbGyQyWRUi5j5fK6kk2FgFwbrcr2FvZUCjSTGixpAGGzx/8m9gA8l8oVCQX2PgAxJsZWF9Gg0IhKJKI+mFHLCxQ1Z8Au7LbJy8VrLtZbfPd9vXkKLMpkM+XxejVNhmOHD1jbni0cyJmUfYXm3AAqRS4qSw7IsNZ7DKgE5FvFrCjAHlJ9eAK6w4OftC+dT1uXzso/zPvuwAiIsjRdwIW2OMpmMshSIskUAkFxbKTB8nLewbUZAYqlUeirHQWS8UoyzbZsnT56o5zuszpFrms1mKRQKSuEggFSUP5I0Lixks9l8KqlZlBa5XA5Aha2VSiXa7ba6p77vqwKp3HfTNDk7O1MJzDs7O4zHY87OzhQAzeVyuK5Lp9Phxo0bPHr0SGVWuK6rugzI++Ps7Axd19V1kbERBIve2KI+EqY/XHALM96GsWjlNZvNSCQSAErZIvuX+ezKlSvs7u4qcCzzk6iwwlanbrerLC3h3A7xCdfrda5du8ZP//RPUywWefjwofL2hn3PzWZTjf2bN2/S6XSIRqP8wi/8ApVKhTfeeIPT01Pq9TqHh4dcvXqVpaUlpXqJx+MAKkU+kUiQz+fZ2tqiXC7T6/XUscucOJ1OuXPnDq1Wi1qtxu3bt/nUpz7FysoK1WpVMd3iP85kMiwvL6usCRkbnU5HSdnFV+37Pqenp3Q6HcrlMv1+n/F4jKZpXLx4kRs3bjAej9X4lTElY13GqSgTVlZW2Nvbo9frPaUmklZemrZIBBdLgjwTMu5jsZgqbvZ6PRzHoVAosLOzo3qOS4FIni3xf0t6uCinpN2cvMds26bb7aqCL6ByEERhIYnktm1TKBTodDoAav77sz/7M/X8lstl1tfX0TSN1dVVgiDgT/7kTwC4efMma2trHB8f/5XPUX/9m0vV9ThJ+Azmy6QDizUc6raLlY5w4GW45gW86Frcdn2GjLjHCo/PbhD1S0xYY8KINgEOET5BhAgzsiQpaBrZLYiuwMQD3wPnLrT3YN5KEp/qzJyAppakEVxhApjWAd7UJ7A1Yg3AKtBFYx2dYhWSO+Ccgd+FUVPDdwLi9NCZ4+tTtHQXEx9/DzLX4U4FDp6HnUfQuKszCwpE9AbZYIR9kGDUnvD856e0rCnRlk7QHWJ7OaKAk/JJ7YDRg7MRZGqwdGRiT7MY+hTbThBoaXbiPfQJkIZsETxv0ctbmwIpKCXBy4B9EZKHkDvSmJUD4msQLEOvAJ6/SOH2NyA38kjE22R+weLwE9DplAmGLonYkJldw0mvMDbO8CIuRhFiY3CeGET9ZTwMPGbU8IjQw2FGEp/9RI/jv7WK+9O/CMUKPPoq8cFDknOfJRv0KkzGsPYWpGcwq8FqDJrpOa9/ZpXuL30BytfgzdfYOP0jIscTgvc8ijdhfWnIKPqnFD2LlViAtwPjZdjLpHETMaJ5nenmNdzyJejNwZigWfsUOj10A+JTMN+E+T2NnU0H99Ztzl65iLtSpXsUIRJ3cHuQyC3ayXUzEF2GiTlitzOiEoc7xSSzTo7IgxOSxiGj9DL+apZM4LNvaBwSJYJOgxkzXDZMeHfHoH3jEox9oAVaEkbWD/wLUO4v1nlneQhGoPuwHocnY+j1IHVmkMAg5/ukO2B6GnmmlLIDYjfgLLHwfvvRhUQ80YJxbPEcZCyYdhY9vmOXYP4MPE4uDqUwgf53wWi56MYpR7pB37G4hE+ZHiYJ+hS5h08cnc3AJkqMNgXeNXuclmNkRz7axCFOgZI/YsyMd0lTjyyR9D2SXo8EE3rE0IlQJYHvfoo/a91F05pkRxPK2yPWAc3xWE22CaYR/kgfY85y7I4/SYRl/vP/GUG3BGiFZajyUgp7QgVwi4QqDEJisZh6uYlcNhxOpWmaAvHiT6zX62ohI17Z86A7DLTlTxishkG3AHsJQRHWXhZvArpFoixbGMiE/z8MrKSCLQxwuN9oGHTLNZLFrVyj8Ofkesp1Ce8nLMWWzwVBoACuAHJZDH4UwxkGcrFYjFqtRjKZVOyCtCGScCY5v/MAU5g9aZUWjUYVEJ3NZgyHw6fknCIRlJCo88clfji5LuKDHQwGtNttNX5kPwKCz4NuTdPI5XIqZVlk5CLNlTErADTsa5XrJwt9kdzLYlhAVpjhDucEyJiUgog8K/J8hP3ZAriFIZaxG/5OCXST51AW3HLv5f7L5+R85TzD903upbDhYZbx/J/wWBSANpvNFBMfBIEC3jIWw37xcGHh47zNZjOq1SqO4yip89bWlmIGRZGTyWRUeJOwoKLAEMXN6uoqW1tbT7U2LBQKT/VzlhRvSWWOxWK0Wi3a7TaxWEz5rNvttio2CTsNHxZVJIdAQr5EEhuLxTg9PeXu3btsbW3x3HPPkc/nyWQywMK2JAFw3W6Xvb095SkX1l5alsViMYbDoRrP4i8/PDzEdV1VnNjY2FDPXThpWkB5LBajXC5z4cIFZWUAVBK5FINisRidTodsNsvOzg6f/OQnmUwm/N7v/R6np6cKiL/yyit0u92n5gNN09Rck8/nabVaT1kkNjY2+PKXv0ylUuH4+Jhut6uC6MLMrwS/1Wo1dd9/7ud+jmg0yuPHj3n8+DHtdpvj42Nc1+Xo6Ajbtvn5n/95Njc31Zydz+dVb2rbttnZ2VHy8FgsRqPR4Ojo6Cmri9zTg4MD7t27x+rqKru7u3zwwQfcunVLzRWdTodLly7x0z/900oCv7OzwxtvvMF3v/tdpWy5cuWKmjcBms0mpVJJ5aQ8++yzJBIJer2eCvsDKJVKnJycqPT1dDpNLpdT41h6wocL1s1mUwFemW9EkSYM8nQ6VYWDfr+P67rUajUymYz6riAIODs7U0UZKSA/efIE3/dZXV1VxXwJiBQQPRwOlRRd3i0yp8r1lXeSZVmqMDUej5UdKryGkHA1mQO+9KUvUavVaLVaSkH4fwZPd9ucseRWiWsO9fgST2YZdqnT9o95MAsoeCMGaOhkyZHCZA6sYPkvkQcyeGToEMdnhSqXGTDnEWl80skuhYsB0TyM++AmYTaDed3gaJLHYUSMFCfBNboYlGlx09Np1kccRQ1sP4uGzlCDHhOCWMBYh7EH9hnMGjXMAPKxBhMPKppOrOhxOtRp/Hed6HWX5AvwZh785wKCVwfE6xFqZYd4NqDX1HFuQbMKfRviuz5u8ZTG/TxlVojlmow8cE8XAWdGDPKByyE9XD9GEY/JlUOyNwKSBthJcAo/KAoMwZnBZAJOHCJliF2EnA36w4DuMmg1yEdgZIB9FaIOdFtgXrTwf8Li9S/B3lQj/l86lB47mEk4fu4M7VMGsa5LtwmzC2BpoPc95vGHdIiTm5doGQ/oFPt4RhbDT9H4RAX3H3wKKjtwfBetc4vZwCUzhqUMnKShZ0D5FBIOLMdBi8Ibv1Cm+/f+Lpgvwt7bLD38I3bv9Gm2wO+ZdP80ylyfE/lfHBqbFX7fHnN5e8LQBXvVxxlkmNufhJ1d6A8XKDTTonB2wtWjAMuD0hjGLehP4sxPZ0RzU7h3DGspHu8WMW41SP+BzvFIZ7jtMurA9KKG/kWdh2OPvhujufMCxpv7bH9jQKYRYZh7xNkrMJ/5mA9qRAODgDp5SljmgPvXfI5f3IJEFXotqBQWjbaZQCkBpzqzSYNe0iefASsHvRQsd2FyBw4fgz7Q8c0pDgHNsyhdP06UAJwYg5lNf7YI84vEYKUDmfGC5bZ8GO6Bdh+qBkSWYazByAeXRSs5pw2JVYtaziLpwpPHt/Hn26wxJ84TxkyAKjmqrHKExQnvEnCqpfGiJqOUyWDisMmMXRZtwg6wcHEZRKd8x9Ko+zdwmOBpDdpGirfdEiX/J0gzZObdIzW8TX7NYxRd9L3/0qHJklWjRRUDjQGDv9Cc8zd6Vj3f/irsuZafy6Je/k2kyOHfF3muAG1hImVhKJI/ST8OtzUJy2bDoTlhb6mwkeJxlsVUmKUNB7zIIi/sLRcwJ+FW4fMKs8zwdAhamP0XMBlOwhYQJlsYzAgYE0AtwE2OMSzXDaeWywLnvExdrnkYjIZ93SIFjsfjKhF2dXVV+daE9Zc+1yInF8ZbAJ/cVwHuwmKHU9PDMuPzAFSuW9jTLcUAub7hgoFc1/A1DEv8RTYelrPLdZTFqIQ0CeiW+3feInHeWy7jRBbhYdAeTpT/KLtEuGAii0IB3SKFF3+tHJuAZTl3GWsfZaWQe34edMtCUtj8sL0DPrRIhHMXwgUhOeYwSx72rYq8X+TU4esqDJoA8I/zduHCBarVKvv7+ziOo/yqW1tb7O3tqXEUHg8yzoQxXl9fV/etVCopEHdeNSLtl05PT9X+Dw4OFCBfWlpC0zROTk6eerakf7Cwyb7vMxwOaTabTxX5pOgjBZZXX32V3d1dVldX6fV6VCoVBSQ3Nzd566236Pf73L17l3q9Tj6f5/r168rfn81mVWtHSfiWOUNYUJmDPM9TflixY8gcI+y6pmnqnSFyYAHgpVJJgbSbN29y8eJFHjx4wFtvvcX9+/cZj8fqPmxtbam5LZPJPBVOKO+UaDTK5z73OeUh3tnZYX19XRV/Z7MZp6enpNNpKpWKem6l/VY+n+fs7IzPfOYzKiV8OBxSr9dV8Jm04ZvP57z66quk02lefvllJR0XL78ElcGiQ4kUXfP5PIPBQLHX5XJZ+Z8lc0TUL8lkUoWKifxbrm8QBNy9e5cPPvhAWQwSiQTtdlvtV8YnoIoaa2tr9Ho9RqMR5XJZqW/EGjOZTKhWqwBK4SABgrFYTJ2jyOllbuz3+9y7d0+Fgko/a2HM5Ry63S7r6+skEgml6pCCuRRBKpWKKiZJUbBUKqFpGo1GA9d1qVQqSlIufczFviVFCTk+SYuX952oyvL5vLJsJJNJ9Tld17l48aIC8Nvb26owH+5z/nHeLrgXeIYy7en38XiMyxr75KiQYOzsMSDBkDQrzDjGwCPKpwjQ0YnQIG/cYTt/ij6PELEeUWJGJtYlVXaxqos2UvMRTI7BcqCTgrphAFHA5All9oiRZMA2cQxqHAUeAQ5GAL5hYgQDCtqMnr+QkycdGLYiNP11Alw0r4eHRSTuEYnAaJzC6Www+q93KVzwOV2Fez145sIYvQ3RnwhYuQ73/8Snf/T/I+/PYzRL87te8HOWd9/X2CMjIjNyq6ysvavbVb3ZvsZtW7KNR4NHDOLCXDyDZCTgDyQkEMJCQgL+APMHSGh0gRkbae5FGLBMg922y93t7nJ3VWVV5Z6RmbHHu+/LOe/Z5o9Tv6dOhsuD3WM37r5HCmVmZMT7nvc5z3nO8/19lx882IeTcYKya/NcwSGn95gFeTwjoHcC/Q7Uk2E7M2MekNVm9JM6VskjeyVgnoaiG4akTbfB6kMwDX3WhQDaH/Wz7miQWYXXanBhGrYNm82hX4DJBmR74MSh8SWYXYbWQ0i/E5C/5xAcQNI12TC62NtgT2BYCBPN53YI7ALDIrmwyfgzji5rdH7sRSjshE2ldwqwsQmTExi/gzYfUTyD57IQr0LfhZwHuReh4EMxAV+rmJx99tOQ2IbOMdro22QfDpjtwWIdsr4Lg4CyDf5bHocZi9Gndd6pFPCtEoZ3hpHp4ObmMLMBHwoJMNOQNKgWITOEuB22e64CuUCjnSTUZRtZ3NQaE1rUStBu6+hPYWsbHpoGc7PAY72Pr5vo904of9BCO9Ox+ykK7oj8WcB0BrgWZb2J5rtkzDGJnR6PbiZYrNVD5n2ihbJ3awp+CpImzH1mU4N43Ucj9PIP41BIw/oGJOZgNR3SGhRLMLcDAi+GS4LBaA3vrSeUVxYYcZgOwjlb7UNiAG4lbAXWP4KNq1BMwmQCi3zo99cHkI2BeRlqlbAQkuz00ZkTDzQqbkDVG6AxwybHBjp99nHxyDmv4R3ZzPU4h+jk0AnwWWZBEh+cLhPf4SyWphNbw08OcWNnUCzztD3kpY4OpChQY9Guo6ebXMr7OGlILGy2j11mQYBHl1Xq39Ga8z0NumVzKH8X+Z0wF9E/BajCx/LX6OZSZGwimZQHm7ymbPYajYby8QpgBtSGKCopF4Yjn8+TTCbJ5XLPBJsJYBRwI57uaAsx2XhI2q+ErUgRAD5uHSOb2SgLch64CagUlkbGL+qnBtSYCegSCfN5WXs0nEcY1qisX/4EVPBWlEUXUBSV5OfzeS5evKg20KlUSo2DBNp0u1263a4CbVEgLBsOYcXFnyy9Z+XzyiFFA/mSsRL5oFxbkRIKKASeKUTIEWVk5XdFZeG6rjo/kdmOx2MVsCTyUVFZSHsyAdvibZc04KgPXPzf8pmiPvKo11/GOgq65XPLvSFgQu4D+axSHJJrd17JEZ1f8n+FQkHNfWHLRTav67qSHgvwkSJalA2PFhNk3gnzFmXXZT4L8yTzVgo6ojYQue738yH339raGqurq/i+z507d1RaeK/XU9JaWZOOjo6o1Wrkcjnl9RSvrRTMZG4JyBCmbzAY0O/3n5FWz+dz5R1++PChAg8iP08mk2xubirQPBqNVCtFAZDiYdY0TcmFW60Wv/Irv8Jf+At/gd3dXer1uvJ3Hx8fM5lMSCaTFAoFms2myt2QsK9ut6vmlLDRuh72dV5aWqJSqag50ul0FBi1LItMJsN0OlUtnQR8rqysKBWB3Kvw8T0lbb/+3b/7dzx48EB1MZDWWZubm2ptLJfLSlkzGo14/PixUrX84A/+IG+++aYKwYu2MJSU98FgQD6fV0n98hkXiwXdbpelpSU2NzcVg1utVpWMXBQB0t98f3+fVqvFhx9+yObmJhcvXlTSfGFrBaQDSp6t67oKspNiwcbGBhsbG6rIt7Ozo2xTsVhMgcwgCDg9PeXu3bs8ffpUWRhM01QBc7u7uyp8dDaboWkaly9f5tq1a5hm2M9aQvSkaCHXbzgcYhgGa2trSr4NKCAvc1OKAysrK8rGIvuAarWq5PpiUYu2q5RUeVnrF4uFyuCQwt/p6akC4NVqVZ1rtBuAKErkOadpmgpyk0wFKdCIcsp1XeWxl3k9Ho8VG//gwQOePn3K9vY2q6urKsfg+PhYWT0kXPH7+Zjh4RGwzQobnOHT4hvk8anyMhf4ut6j48+p4dLXEhwGDh5N6lS5DiRXDslu2GhjyDw3wHRg0YH0Rthf2LofMsSdByHuGk4T9McrpPAADZuAPA9Z1frYQYW7+oxeMGfTzpJiRtOAlJ9gMw/FFTg1ID+AwaRAlzpDJszdFClMRpqNZrhMfJ3Ar5D67Rr2WpPEX4GzXajd8CnfnzBtQ+MAJh1IpaFYgOYE+oc5Opkpy6kT+voZXRPcAeCEYFh3QNOhmvMpfsYnuQ1LSZga0OmEknffAjsOySXouTC7A3EdqknolGF/BdYncGkGWg4mVZhrYU/vfin0+QYDaP87SLyrE+vpTHyDjO5grLp4F2FqwjwGpathz3NnDOMl2PsgRdqPM7kyZviTr8CbnwPfhnQZUssQy0O8BaZDdeByeQDbeXjgQLYL1xZg56G9gK6ucWf1JYLNH4HeKaTfJ6hOaRZMMikX/UDDDgKWdj0SNQjuB+h3bZJf0eletem8VMXJLKNpTVg+gOxzYVIYYwieox/r8rvpb5LRbFb6sLIBG/EZ9g70b+Rg4woELgQB3Z0M1diUYnZBxoJUFR5342jEWD4NSN2dMr+3T+wwjj9O4MWGTD248BRuXIWjnx6SOgHnAZxdmtB5EZrXVsIqiTWHjAlzD9AhpodVk0yMoK+Rt8C6BH4MSguYA14bONSYWxmSfhZTa5E2HFZYMGbMIsgyf5QhuL9gpQ5TO2yPl9XBPwrt47YLfhby18G8CFYC7AWwgFoRzCSgQXwdOsdgeAG1a3OqyzB9AsHjBVfcKR4pkkwg2aJqVTjQHWa58N7qD4e8T4auVuCNYMQKeca45DyTkbdgHrhofpUNa0Chu+BRfpUPYmNSTpqhUaHG83xtf5NP+Qdsp/uU4xoWDsc8okyVJSrf0ZrzPQ26Reas67oCRwIMhBWEj5kzYVJEIiggKJpmHmXqZAMi4EhAsvy+pmnPJDvLe8nDT4Ky5EEr4FEq0wIc5HeiQFmktdEAsKivUkDceYnw+er0J0nOBaSc/xl5vfOAXV5bJNTC3kZBm7zuebZYjvNe3SibL8y/gO5oWzBRBwjwEpAaVRpEry+gwJ20FZPNsxRZoqFuUQ+nbOqjBZTovDov5ZfzjTLNUR9s9HzkS85T2F3xpkdl23Kt5Fwl+T2bzarQIflMUUb8vAxbQHy0qCPvEwWr5+eJnHvUZx39v0+yNMj5SjFL5qlsLmWsJb1emE4BblGVh8yf8/YLuSei5yhFHVGyaJqmQvBEdimFCTnOF1i+Xw/p3ZzL5ej1etRqNS5evKgCtaTYIaDadV3a7TaO46ie1sfHxwwGAyWJFoZN7BmiNhC2W4DKYrFgfX1dtZJ6/Pgxtm2Tz+dZXV2lXC4rO4T0k5Z5HLVnjMdjleAsfZAl6Onhw4d8+ctf5kd/9Ed5+eWXGY1G3L59m4cPHyqP6/LyMu12m/l8Tq/XY3NzU4VnCeMt7ysgV6S9oj4ZjUa0221KpZIKDwN4/PixAlqXL19WntzJZML169eJx+N0Oh2SySSDwUAxyfI9CNPi4/E4y8vLPP/889y9e5f79+9z4cIFlpeXSSQSPHnyRAGsGzdu8KlPfUp5eROJhJJ5AxwdHdHr9dTa3O12VahZt9tVBbrr16+rZ2Uul8NxHN544w3efvtt9vf31fUXGfTZ2ZkKBrtz5w7Ly8uqN/RP/MRPAB8DVV3XFZubTCZZXV1V9/ja2hqmaSrVhQSjST9ykeXLObfbbU5OTlSA3+rqqvJAy/Njc3OTw8NDrly5wqVLl1hbW1PP3kqlwnQ6VWtpNFjuwYMH+L7P6uqq6vU9GAwYDofPeL8lC0HWZ3kmy5yR+0HWWhm36LNDQkzFljGdTtVzVCw6lUqFIAh7nkdVDZ7nUavViMVidDodtX5Op1P1DDBNU1mjbNum2+3S6/VIJpO89NJL6lkpzz0p6j569IgHDx4o+0e/36fT6WCapvKEfz8f+/qYop/lMuukSVDH4yUMesQZYHHF73FCgneoMAhSOLrLh0GHQuCQxCfXTXI8itG3lrmoHfPpNyz06zAZw3gfYlPw9BD7TVsa1myTJB5m7oiFC+vzFAltxlq2z2NrwogsSS/LeqBTqk7Zsi28WYH6lkNtC04IWzC5ZHCJE9BnrM0YBBXik4Bpr0HX8VnQZHkQkP3fYiyvOuz9uMaDzxm8ceAy/UqGgw+yaH6fwo0Fa0tQOfE5mKzSmrXZ3OqRK/mcaKE8PD8MwXagQyoHpgHWBgwrkByFPtyzIeh3oJyD5AVIbMJUgyeHBl4nSX02ZevToBXg0A6DteZXwIhBrhO2Gev0IbijYY01zH6ChKsDOstaEsOc8Piay+zFBKk7U7y3A2ZbkN2GaQImJmT9AHNtzuGbVZxPfSasdsxdSCzD4KN4cm1E4fiM6z0fU4cHwKQLr00g0YevdyGfhLZZYHztC6AZ4E4gtwpOj+kXTPbiPsv3A5LLcHdJw8sGZLbBOYLC0ywvtTqMJ08YXTOxpw57ZyPcH48DKZgPITkl0HM0sjVyxhlrKY/STUgHcFeD0VoFzBgM3kPTnzDN7XC7YrOy9pDLsYCjKtiFLPG5xdogQGvA3j6MZ3EKBKy6ceIs2OxB7CFUfwA2b8KdHDx5LcNsd4VgbRcSAXhuGLo2m4JpQsIAJwEpjckEHv+mxsoXA5afg9kE3AMYv6sxOkvgB3l8Ugx8jbwJFWZ4OIBOwvSI+5AEsmkYTeCwHCo1bBvSBUhZ4b8HKegAsY/EAHYJylfA7oNWgVgZ4mlIX4DKp8Ffhb7nYTRGZObvEs8t8BIadatGgRgLOsQdl4t4JOnSD9L0iXEZnecocYJBH5v0oosV9MhqcX58cYmvd1Kc6h5bpHkYxDhcSnJwaZW74xLZ0xGrTZ8Xgi0OOKTBFIvvjLT5ngbdAq4l5TQejzOdTpVnWdJEZQMn8lMJWxE2T/yd0utUgKFIBC3LeoZ9iYIGYaOl1YpsZuVBmEqlqFQqSnInjKTIwqbTqQJDAiIEWIoUTqrdskkR+dh5T6wAKtnMyiZBNmACWgRQwcfMYZRpjgJY+XmR/cmmWlhOSfkVICnjLhsu+JhxEzAk7Km0VYkCdWHz6/W62mgahqHYjHa7rTYUo9Homd+VTYy00arVaopF0jRNMXsis5TPLXNC13W1QRNPsGzEZfyi0mmR/4vMU+ZNFHRLYSiaSi4bdWEHpZgTle0L2K5UKmQyGZUcHJUkShaBvI/MPQHbkuQuKg3xaMv8i0rk5TOeL7REGf3zIPi8tUGArahFZF5Ee6qLXULyCwClkhBlhYyZjLm8fvR8ZW6el+SLPFmkqIAqeEmBRMbq+x10iyJic3NTqSmiapqNjQ2CIFCMtG3bCpA3m00lWT08PGQ2m3H16lUFUGSu5XI56vW6YsmE9XNdl3K5rNrULS0tsb29jWVZbGxscP36dXXvbWxssLy8rNKzxb/c6/VYWlpS69xwOFSKJfHq3r59m36/z+uvv87rr79Op9NRzG+tVuPKlSscHh4q+a7MaWE6JRxNgq6kECHPimKxqKTBKysrCnBDmCnSbDZ5+vQphUKBer1Op9Ph8ePH5PN51bJMAHK73VbtGovFIrqus7a2RrVa5fnnn+fJkye88847CoQuLy/TaDTUtXrhhRd49dVX1fiKTUWSq1utFsfHxxwcHChrzenpKcPhUIWNCeiq1Wp4nqfW316vRz6f5/Of/zw7Ozvquoh6YWVlRX1uUW7JlwTIybpiGAZnZ2fMZjN0PexHbhgG7Xabfr+vwvZ6vR6LxUKtafv7+5TLZdWerNvtqpCwZDLJ+vo6+XxeBZdKZofneWxvb/Pqq68+U/SRZ62sb3J+o9EI27ZpNptYlqXWH+ltDR+3oYsWZOXap1IpqtXqM11KNE17pue7qIwE5GuaRj6fVyqdcrnMcDgkFotRr9dVroI8W8VTLVkAly5dAlBstRTrhemX4sjJyQndbpd+v6/Wut/4jd9gdXVVqfl0XefRo0eqWCM5Dr7vUyqVmEwmNJtNWq3Wd3G1+h9zmEGOVfJcYx0wadPDQWeCxwk+Ba4QQ6fBHEubsyjbuJMhXd3hG55PYb5Ofz7lAXHmd/Jc2bVYXYXJY3DasFiGXAVqhdDPfTwbYjAn6wa4Kz7l2AnzrsZ4G+oLh8sfxJkFOdaXD7l+00c/9fF6HdZfAecazIsw6YMzzTBhxCSxTy63YNHzcPwlBr0hmh/gMKaPTb2dJff/6uN3Ao7fDBj9DGT7Nsl3k8QSIYupvwCxBuTezZAx5wwv9zCSMHpbQ/cC8pMQFKeK4I/BmYYq7cUcuh4EFVhJwywH5RegvAk2kPShEdc4m1ew7sPu5pTcMjxq6xw8CfDzAazBcwMomGEbsflBhbbv4ekjymQgO6e4O8bZBuO1GMnHDhv/vkhtsSD2mSkPlzXuNPN4sSmXX7cYvKYxe3UpTPD2UmBmwEiGiV0jD7P9da4dHZO9Be5SiMuzxxC/B/cBfyOUUN+P1aG2At4ciqvg69B7TCzvkvuiT2EX+q7G4Uad9GDAVtNmvm3R2bWIxWE3BRnN4VEVniQ9MHwolMEeg7cPxpx41+f61MPU4evr8KIBO6ew1j/ipP1b6PMG6f6YkT1lUavRryU427c4Gms4WYtUa86wC3ELvGyAmRyzMUiR90oMS21GNZ/UI53i7/jMfgTef6HI9NVPh/IGIwH2NIzTtxdALKym2DZ4CczxGZWFQ+uojP3vZ1w6mGMmYPY+pNsmWtLCsIfo/gyj4OGM4mjkqRt9yByTuuiysgPeCIwAFiY8TIC2A5cGYSHHLsM8Acc2NNKQ1aCUg4EO1RdgbQrjHsTSUH8ecs+HoWuVLTA2wft2QKwzJl6HzrtllniFK36JzeEESBFgU2PATeY0sXBxeQ4NnTEt5nRSffyLcR4GPv/p0XvUF6ts+hleQ+e6n+d/tU6Yul38oc/IWCVtLuguagyJM2bME/777bE/cc35Y1i3/ocdsumO+j0FTMiDVmTUwoAJEICPJdTR1xDwK4z4efm3/KxUsEVWK/I1eeDKIRt9Yf+iwAp4BuCe/2yyCRRAJEAvytILS3oecIlvNiobj/qPo35m4BkQdd7vLGMFKAmwgNbzgDn6f/J5o1LzKAsumwp5f9nAyMYwKl+X6yDX4vy1ikreheUQoCfXJ8roy+ufL0REpeFShBBJctRHHC1WRDfzwh6JZPe8dD0K9OTaRcdE3lPeV4C/FA+inymqXIjOgeg8OP/96PnLIayNvH80aC0aQCjzIQq+o4d8LxqkJ2oNURlEC0By/YUNlw17VEoePf4gD3a0QBRVe8j4R1ly+awyDt/Px3w+5+nTp8p/Wq1WlWonn88/07pPClmytgnD2Gg0VLDUt7/9bT71qU+xWCzodDrKr2sYhnodYfy2tra4ePGisnQEQcD29ja6rnPz5k3y+Tztdlux7OVymXw+j23bjMdjMpkMnucpgCnMnlw3WY8LhQKnp6fs7e3xxhtv0O/3uXPnDpqmUalUWFtb46WXXuKdd97B8zzW19fpdDpYlkWxWCSfz6twNTlPYWILhQLxeJxyuazsKmKPyGQy7OzsqF7Lvu+r1ywUCnz44YfKvy5ycbGLxONxarUaq6urvPrqqyrk7M6dO5RKJSVXN02TpaUl1tfXWVpaYmdnR8mM5T6RYtL+/r4CYPLMePToEU+ePMG2baX4cV2XS5cuqXEVqfV8PlehZ/Le8Xic0WjEwcEBnU6HjY0N1d0hl8tx9epV1Xs6KoWPKnk2NzfZ3Nzk3r17qm3bdDoll8spYA7QaDQYDoe0Wi3Vw1psKRcuXAB4hjGX57w8A15++WUqlYqyqchaJpJsy7LY29tT8nApEsozNhaLKf9+tEWXjLOsxdHwVlHpiMpNcilMM+x2IXsLsVBJMUjaMkpI5dLSklojM5kM1WpVqTrkmpmmqbz38j6SdSJ2pEQioeT0QgB4nqeKF9J3fHV1lYODAyBcUweDgSry5HI5Hjx4wMHBwTP5DN+vh52f0xk+ZoGJSZIKRRbM6WCxoEAKk236LKNhBQFjegRJH9IxJpM2J3aKJj1O9BYJv8DWtw2MtsfiCXT6Gp4RkNfBOIXFPECPtRk5KRzd4MILPhd3YbQfwM0QmFwa9THHQ55/bUG+AJ0uBFuQvgzdOlgFOPGh4McxyDJPxMjugOs4eMMCC5J4+SH+KMGCJE4wonoE134b7GWP229C8Wdc1le6lH3wNsFbg8IbDun9Ayb6nEfPQ/4ErE6SQt4mv+QzjUPCA8MIey9n26AdQ24djBpQh2Ic7Dp0TIh5kMnB6qsui1GTzDjEc4dWjH5pDQpD+HBM4kQj5zqYAcxrMKmPSTVK6DGN6sqE2cs+7c/opE2faz2H2Vc1KqMqid0px3WDd2M3mdSfo7D+X0gsdWnupCFZBwcw8uBZkIqBYcL+LRL2e5R6EDyFagy8b8HRMbTmcFSFTAoOXBPr0suhHNxbQDoBQw99HnDF8qh5cJiHYzMH8QS5kcf8LrR7GqkbAXodHiY0mjWT9pUSi9SLkL0A6RIYTRhZEMxxFykOnQT2psZwM0lwb8TzZz4vMcGa3KWd22HS8MnO9kloJxRPLZJHkMwFWAcT8o5PuxCmmu90wWjrrHgrGCyYXQiwqpAY+9hV+Fo2ReOVV0LEOhmC64Fugp4Im8YHDtq8R+rxIbEFlOcLtq2AeX6EX/Jx2xBPQmoNPNMhZcNCnxLYOsYQXMvE1DySZZfMNR+zDP4UTC9sA5ddhk4KDheQ0OBqBZbyYTGn78MiAWMv7PeeicPZAvI18H1gHVYLsLgAo3TIktdqEK+Evd1TG+A9NXCPNEy6wJBDw2YY8xhYOXJkcRkwpsgSPsvMuEQKZ5FmeOzgpX3u1U95bIzJdzJcmTpsoFMZw3QvTb6tU/AG3ETjFe4wYs43yfE24+9ozfmeBt0SiCJgTNgw2UyLNFkqx1EQIkd0A25ZFuPxWH1fWKHFYqECgaKMpDzsksmkkilalqVYo+l0qgLaUqkUhUJByccEYMCz8u7zwEJAp7xOvV5Xcmvf99Xnj1bs5d/Si1nSzqN+b+AZsHc+XEs2DFIBF8ZAQK2oDATMaZqmNiQioxe58Xw+V2yy/J78XC6XU6BSficq2ZaxEomoJLJGN14yPrKpldAeaUkjhRD53NI6So5oIUYk9KIoKBaLyk8vYylhM8L8A2qcJGwnyhTPZrNn5lJU/i3/lsKQSLFFQl4qlSgUCiwtLanPJa2WZI5GWUqZq1GVhrDq0eC+qPQ96nWOpps7jqM8hlI4kqKKFAfElhH1sJdKJfX5ZNMpny/6FYvFKJVKas5Ksr1skj+prVz0ekUtI1LciBaJ5P2jqhcB3f9HkJfL+vDuu+9SKBRU793l5WVVVMzlcooJFpAifni5F2VjLx5m3w9bH43HY7XmHR8fK/AhKgNN0xTDBqi1J5FIcOvWLY6PjxXYvXDhgpIKv/POOxhGmLItEupWq8Xy8jKDwYBWq6XWCEC1dYrH4/zAD/wAu7u7jMdj5e1+8cUX1dp97do17ty5o+T0EBaAWq0Wa2trFItFTk5OVGAVoOaurDkyttvb2yQSCeXL9jyP1dVVcrkce3t7/N7v/Z7yLBuGweXLlzk9PaVUKvHCCy+wtLTEK6+8wp07d7hz5w6+7yu58fLyMleuXMGyLE5PT9VzJQgCJd2WJOqjoyPVPaPb7VIulzFNk7t37zIej6nVas+EC167dk2Fkcm5jcdjtb5Vq1USiYRiogVkzmYzOp0O165d4+bNm6qNogTc3b9/n4cPH5LP57l06RKeF7YZk2emrut0u10ePnxIqVRSz+PHjx+rlm+9Xo+HDx8qALm8vEyr1WI0GjEYDFhaWlJZFgJ433jjDWq1mvJri21FnqmtVoujoyPVDgzCvcHu7q5i6kWhIdYlKXRLD3vx8YuFQp7tkm8gfcDFvy7FhMlkoqxS8ncpXGxubqpEcXm2SsFAbGmaplGtVtnf31cWAcm9qNfrKrF+PB6zsbGB4ziqu4AofoIgoFQq0W63KZfLLC8vK0ZeetjPZjN+/Md/nMlkwq/92q8xGAxYXV3l8ePH342l6n/Yoek+9+NzsosPsSlzhTIXMalRJ49Pmm+S0A54EOzSLKcJUga0HdCmpKYpZiwxJgA/yZQ0vbMpnj7CtzTGsyKThws4nWKNkxz7Jpn0BF2zmGg++jDEPasvQ/wiPCjBcmbBpX3IDODWQzh+opPIB3j9AM8DKw6xyzDbeYr/6AKx8TWm2jfg2oDu4V2qu0O6c5/xu3GWXJ943IZCKPk2stCKJTh906B5Zc7mKCB1DMEE3JchaXVJuhBchZQNesbDnQO10M/dvgWr25B4HvqnYeL2aUrj2MiSSlh81nAw59DwoBLA3IHFVcgmbVa/GvYqf88rE6z8IGTfJ/b4ffTf84nrYOagu66RemnB0ocdsssuG6/Dt9diPHl1m9SdU557f0JhGMDKGfcvm+yvfJ7gys/CHMZn+9y2PmRiLYcfIJcOBzexCrMDOH4fRreJWT2sFqxXIT6Au9+GRi0MRpumwrZY3dQFgmtvQCoP3QXEimC00ccNsm7A4zm4VSgnxrR6HvrCY1SDkaVTHXrMDYM7N7dZ3NyF4hbkrod07ciCB3dYevgVhvkE1qUvcOa+DKkJ2BZ3/T2e5tqs9yxWHtl4pWMGToLADag+tsgegD2ClT5s7fl4cZhmQ0CbPQtT7QdYLOFQ7kAMYA3ef0Hn/uev4dc2wHIhmwFjAVYHMMHIYpzdpnZ8zPITl0wfci6UUpB83SGZAsMCIwXZKoyfwvTeR+DR97FnaZKmQ3q5w+wyWHVITmDa+SjgbhYC9nwCai64Wehvhd7wVBcKwFEG5tkQqJMN6yX7QOkSFOtAHIZamImXdcEDli9A1gQSULnaZfLwP7JqXeI9BjSqMYKEx8PjJRLUCDjG88fYrGNSxMdhw8uSGIxoTWb49WUWFwt4ixa1aZdlpiy5ZQ7TaTq1LsNuQMUZ8dMUGLPMf2WPBB42f/Tjexp0A89stKPBSFFJqrBcwm4K+BLQIFXm89LaKDsZTUqOAnv5flSiLeA5yroLWBGAEw2gOu+DjoLwKBiOesCiBQb5TFFABKgHLvD7QEp0XKIg5vxx3jcrmwJh82VsBDCK5DrKIst7RdPdo68vQF6AnLyPSNJlwyf9vUVmHL3eUVZaWG45n/P9mGWsooy7AMqobFKsCbLJkeKDbH6j8yA6F4SJkN+JBsyd91VHWXMZo2gYnxSN5M+owkDmqBQV5Cv6Hue/ouzv+bn2SUy3WCXkiIIduY7n2XNRFsh5SpHlkxQUMv/lM8s9GZ3zf1iP9/l5Hp3v0c/+B83177dDiiDSn/n09JTJZMLOzg6XL18mm81SqVRUmykJWYoGPskmfWVlhZ2dHXUdZQ5IYU/GU4oo7Xb7Gf9zKpXi+vXrtFotHj9+zPHxMY8ePVItvuQ6bW9vc+XKFT744AOWlpZ49OgR29vbfPGLXySRSPDrv/7rBEGgPLHD4ZDLly8rVl3XdQqFggKZ0gP75ZdfVv7ljY0N1tfXOTk5od1uK4ZTGEVN09TYbG5u0mg0FJMv6qJms0kikWBlZUWlWbfbber1Or1ej9lspu5NCb68ceMGW1tbKila7q9CoaAY7mQyqYLnvvnNb7KxscFrr72m7Eb1eh1d1+n3+xwfH7O3t0cqlWJjY4OzszNl4Tg5OWGxWLCxsUGpVFJrqbRYE2tAEAQ0m00Fruv1uvLoC2O+vb3N1taWKpJ++tOfVh5nSV7XNE0VBxKJBOvr68qTP5lMSKVSvPDCCwpgD4dDFeAmfuPBYKCeWdE8DZHku65Lo9EgHo+rAvb6+jrr6+vq/MUiFO2kcfv2bZ4+faoKuBLWKayzPPsFUIsdQAr50TaWsi7HYjFVGBT1SLlcfqavvNwT0kdd7q1kMsl4PFbF5mg4oayDcp7T6ZRqtYphGDx9+pRGo6E+X6vVIpFIqKA/USlks1kVOCj2Ac/zKBQKlMtler2eel9h/UejEY1Gg/39fTqdjsov+H4/agOdjmlyly4ZPE455XcZUuYSN1klZz6mUmzwtJvENGqhNFf3wHcItAxxTLZwuGx0Wc802LlkYdaB+wGJrsfEMxiNdRw/h08K/BnFrI9tQ3sf0itQfw5yIyhkIPkCDMsw+d/heA8ejWIsjbIEt7tkfzLs6jTfhvgXhnjHH7A8v8mdvRqVH2hx5TM9MjHo/JqJ4xpMzB46Pr0EHF+H04sa/shBM3x6+RixxIIlH+YTmCYh82koO5DIh++R/swC63d02gcmqYqLk4PxKswq0JxCIQZn9QSnmxfIN0/oLfpsuJD0Qit1vwGDItzfhNEavNyFpbZL196GzoKq/yH6bIHrQTIDi3GW4IaHuTVjEYfHW9DwSwSLOrF8g2oeCpfhYMnn9EIZ7BjaN3+HYOMC/qs/QX/yEiTHUF8BLRH6uI/vYO79f/BSLYL1DPmzgKU05Dfh5CHYGchfhMdlAz2AnOXRKq5BdjPsdZYpQLCA1kP8xZTHJvTqJmXPZXMcoLtTPBNi27Cz5eGnNPZyF1l8+v8E5Q3wMjAxIG0CPsmTD/n0fMw34xms9R1wqjDuw/gI0m0WNzvYT2D3Plwxxry7PuFpLUlnbpMyfTo+JG7DzhnMlqEWg0IXmgHYRR8vaNDUNWKTgHwW2pdgb3sFf+0mLCoQG4EOTHVw+uAbsIhTv3PCzccukwHk5pBtQWoFYhlwumESvWaDdQBJN1TszxdgG2CkLGLrPub1kKWOdcPfi5XBaoPTA8sDYwwX18Me7scG3CnA9QUsz+HBGXSfg7ILExv0JPiT8BIk0qC5kPDBWoBjEM7zWBgC6LagdtXHONhj/9seJW+Z2NRjYTo48SYOcUh2eDofM7Q9bpJniwxtJvQAEgWIe7AIqE7ylKnQ44ScVyF3ojHTLXzfYKx1aRDwNKhwhI1B4Ttac76nQbeu68+0cIkmKsfjcbWZC4JAMZLCUkuVXOSDAtKkSn5eqisPLmE7oimnUR+xAJ/pdMpgMFC+skQioR7IIlOUTaJ4bqNARNqYSeX8PNgSECGMh7y2MKrCfEiwT/TcZQNzvmezjIuMk2xahBmUQyR+8vNRf7b0uoaP2UaRxAEqUCY6RqZpUiwWFZBaLBY0m01s26bX66nNQVSKLXJJAfVyvYvFoupJLNJX2UBGfcwCcCVwrV6vq/GOxWJqU2aaYYsr8Zp2Oh113aLFDumlKkz3eWDt+/4zsj9h3qMya3n/eDxOPp9X6ghh8sQbKMywvJ4w3AKAor1xP2keS4EkKiuX+SWgQwoMonAQ0J/JZBTTJJtD8b+m02l1r8kGODpG0dZgMp+i96Ku68p/L8WkaNszkbnLPSxs/HlG/Hzh4PzxB8nUv98O8T6LT3llZUUxpxsbG/T7fdW7uVQqMRqNVOL20tISW1tbJJNJdnZ2qNfrCnBG20pJ/+vxePyMnUCYz5OTE3VP1mo1er2eSsM+PT1VwFXY1pWVFX7wB3+Q4+Nj5SWWNUC81plMRiU6z+dztre3icfjSmGi67piRoMgYDAYYNu2Wkt3dnZIp9N87Wtfo91u43meaiv16NEjNWbj8ZiTkxNVSJQ1IRaLKRm0yHZv375NvV5XDOjJyYnKEhHveK1WY3Nzk9lspmTAjUZDFQqDIEzzPjo64itf+QqWZXHz5k0VFOd5ngJbb731Fg8fPlRMqCgUpOWVtFGTPBDXdWm1Wrz00kvKoy7j5Pth0ra0aSuVSmos6/W6Kpyk02l2d3dV/2jDMFQGwGQyodfrqfX+0aNHGEaY/C5j0Gw2aTab6nkg3UJWV1dVqJnIoaWQm8lk6HQ65HI5LMsin89TLBYZjUYqSV2KA6JWk/XF93263S4nJyc0m00cx6FcLqt8lahFSQIX5fkt6gZZd2U9EoY4ykxLMdhxHCW1lwKz53m0Wi0ymQzLy8t4nqeeVfJz8/lcrcGyn9G0sJWa9LoXhYj4uR3HUYqyzc3NZ7qplMtllpaWVKieMPAyTgLyq9Wqek5JpwdN01heXlbdBb7fj5XAYRL0OUm6bFoTyqxwisWYMww2qfq7rE4dkkGJN9oGj9oWbT1LfgYvUeA6ExKZQy6+OKK+A+4O2E0YPwY/PiazMEn6JVxWmDDFdzT8OSRSMHbh/ttw8gCKm7B0HbZuQGMIR/sarWac08AhoTtoBjg66COwV6DxP0Hx0SG5b2owvMH9W0fgPCTeD/AfJKgafcoJm7gJT67AB7sm03gahmB6E3KGT2YEQR+mwGAAlg2TbKg4Lu/A6k+DFgRYX0ng4ZG9GdDQYPEIxgPQBrD82MLef0g+s8BJwzwNKQ2aeRgdgf1lHefzPo/WNJzbAYO+HVLMp1uM5yVWvCbOCILLkCy4DGoJHmw6eDONbG6BMRtBo4kVT3KaHWEZ8OQqcNBn65d/Az+A489dwfvR/yu89LPgfRucx9B24bc/pPjoLdC6jKsJaosJr8w8Lm9BkIBHJuhjGCdhVipRcsfMWkm8l16E7BrMHEgtYOCDP0PLW3gtIPBxSmAMYNOHJ3WNp/UsMfLM0tt4l34kHEAvAYYDoy4slmBySLF/iuFCbDyGR78HhsZa5zExZ0jXsKk1LS49BP1+WDfYqQT0szb9VQPuB6SGAdoEej1wu6BZOs4wSbs8J10PmOOTT0PRgHYK3t4pMbn4IjirYLphK7K5C94A3AUEJfRei50jh/gTyJlQjoGxFjLotMLe2YEF9jAEjIs4LIBEDLQ0ZE2f1EVY7IBxBvEFLHTQeqHYwDXDfANnAn4A5Wz4e5MYnMWgBlw6Bj8DwTJMvXDo/BT4SUjGPpKoa6AtIJiHrzPRIFGGSibsfKav+SRODqicOdyYLHNqgeunCHydrrmJb4wIWDDB4TmKbJMhIEHL77HIuR9VFnxMAhxMbBIU7BIJXKZ4FHFIYqHTYY0KHTK/bz35wxzf06A76seOsnFSnRa/qGy8BXiLpFECn6Q9DjzL7J5nCM8z4AKSBeSLDO+T/LWyiZDCgEjvogFs8h5S7RamVgCSfN7o+8u5CQMpbL0wx1HJ+vnPE2Xro7JyeDaJXL7kZ2VTEPXLSqFAev8C6vOLVFzGR95bQFg0RE7eQ9LJZcMs4xMNQBPQKJ9XGOrzvufz7OZ5b7fMFQnkk88SLXJMp1MlqRWfqry+MCZR+bbMgeh7y9jL/8m4Rf3hUYY7ynJHFQzCoEkoWrRIFAX7n8T6RscgCorls8h8+aTrL+MvG+7zbLj8KZ5uYa2j80+OqM0hyrBHWf7z0nI5fxmH6NhFXy96jeUr+v3on3/cx+/8zu/wj//xP+add97h7OyM//Af/gM/9VM/9cxn+Ht/7+/xr/7Vv2IwGPDGG2/wL/7Fv2B3d1f9TK/X46/9tb/Gf/7P/xld1/mZn/kZ/tk/+2cKEP9hDymODIdD1St4Y2ND+W6liCPzZW1tDV0PQyG3t7epVCpks1l2d3cxDEO1SxQWV+wA4/FYsYT9fl95cqPZBOvr66ytrXF0dESr1VIJ0cJ4SrHFcRwuXbrEn/tzf45f+ZVf4fj4mEKhoAChWCvq9TrpdJqdnR02NzfV+04mE8Xudbtd0uk029vbOI7D2dkZ0+mUdDrN8vIyn/70p/nqV7+qwhkF8GQyGWV3GAwGFAqFZwCPrOW+73N6ekqtVlO/N5vNVKhVNHuiXq8rqX48HlchY5I6vbGxwenpKUdHR3zwwQfYtq18vScnJ+zs7DAej5V/+9atW2pdlLVJAiDz+Tw3b97k9PSU0WhEtVql2+2Sy+V4/vnnn1GbSKja0dGR8hiLJUcAe7VapVQqqWeM2FdEPSEsabfbJRaLqb+vrq6q0DUpMIgNSt57f3+fZDLJ2toagALtlmWRSqUYDAbK6iBAXew+zz//PNlslsFgoJ7psh5blkWj0WBvb0+l1Mtc3NzcpFgscnp6qsJU4WP7layJsu7KXJcMBLFtiHpAnk3Sqk1ez/M8dc1ms5lqpQaoNpZSpBRArGmaan8myoxkMqm6D0gyuRQqZQ4GQUA+n1fPgLW1NbrdrmpJJkV+yQGQtb9cLis7yXg8ptFoUKlU2N3dpdPpfGeL4P+P40/T+hgeBRxixNwhGQZcJcZ1XmLOhDk2Z/517s+v4zBmi9u8QoW+X2cZn2u4VGJnZF4as/vTYC5DYwDz2zCdgasHxHGxWDAmwGJB0vToWwkO7DjOKI7hB5j6lNgdk/XbFmu3PE7OYrTvlBj4SRxGDOM2sWXQMmBroDkQvwTz/8XjOLuP9ut5ssdbHDWSLHs+RX+MljyhXgxbLg1+AOYbabR+QPZgzs7IZ7sIIy1M7i5loLWdZr6IU20MSU4Chhl4vAzlnwgwFzOcWwH2uxozT8dYeKR3wiDuyl6FZHNM6pUQyI7yMFhA1wUnBkY3z863ZgxfXfCgUGCRKUP2MVx4mWn3ORZeE9cJyeSd4pwPDZ1pqYQWtyjNFqzpFg9iHazyC3x4YYnE2UPKhzabv7kgs1+jXxyQ7z6gf/IeXPhs2L/MnMLTE2q3fp0le8RTBy6ObC4PA4IETLahV4UPXs0yOM3ijnT8ahy7O2CYuwk3fjiMa9cJEeM8A5VtzKMY6xbkdB8tCZ1FmJw+LGVYVL+AVfgi6BcgmQr7sTlzWBxinv4aseGIWGPExeMW8SFcdKbkW18nvu5zteARS0JnAslvAgfQXIJZBiptuLjvs5cKcNYDCgtIdmA4BattkPYqDDQHvTRDi8NiplEmIHYRPthK0bz5achcgcEEEk5IUetDiPtgLaM32tT3npCew2gVtBi0dEhtQz0PsQVMG2GBIaaFBRnXDZloLQi7zccMcG1IAPo6OHnwDmFxDEENLAOcXNh2bLAP2QLkLkCFkME+noX++sIcbvehnwGDMMU8bYLrg5UMWe6sGd4DsxkUtbDTmZOHpA79KdRWXWzrlFzX5Xm3jMEWbVJ8e9pECwKWyDPDwcViiQKrTMk4FgvdAD3O1OjhopHiAo+T0M7pxDtlFsxIBz4jApo0WSPDCzzH/5tv/JFXnO9p0C3gxfd9xQwLM5jJZFTvzGgVWtd1xVhEfYsiVZS0Z9kUCkiK+qVFUibyRU3TlK9PDgmmiTLa0lJFmEsIPV/CnsqGRDZ40uNb2GyATqfzjE9awLD0BBVwFA1Ri4LU/54cN+qPFUAV3YgIMIq2QZPzFPZJpJ1RaXk0DVZ6NIt/PpFIUCgU1MZqPB6rDbJIOwHFfMj4CBAVoCAhRsK4CziT6xiVlRuGoVhb8c/JZxMlg8hk5/M5rVaL6XSqegfLBjQaBiagWoCeMLDRTVwUiEbl7fJ64v8XeV8+nyeXy6kNmsyR8Xiseg3LtZaxFoWHnItsAuV7UfAtYyhFBhmzKCMdDeYTmSWgws+EyQqCQPUkl89wPrU9WniSayPnJq8pAFrAT7SfuZyv+PjPF27g47R+GeeoTF8YLGFo/7iP6XTKCy+8wF/+y3+ZP/tn/+zv+/9/9I/+Eb/4i7/Iv/k3/4bt7W3+7t/9u/yZP/NnuHv3rir8/fk//+c5Ozvj13/913Ech7/0l/4SP/dzP8cv//Iv/5HOJerHlhZUsokXiaswaJJUfOXKFcWQ6rquwFYQBLRaLRqNhmIUJccCUIXEbrerJM8XLlxQIKXVaingnM1m2djYUDLYo6MjHj9+zNWrVwEYjUbKM/xLv/RLPH36FMdxKBaLKqdD5vn169dJp9N88MEHfPOb3ySdTit/b7vdVmvVZz/7WQAlGxaG/7XXXuOtt97i6OhIzSf5HWmLJsUmaVsmwVsyz4fDoQKjUemuBKHJfS9ql2j+wWw2U/eIaZqcnZ2pADxN01hfX1dMbC6X4/T0lF/91V9VPm5hfgWsihXnpZde4vr168+03rp48SIXLlx4xtds27Zae2Xdk37mKysrZDIZFXIneRaSEyFBaNJbXdM02u226qnd6/WU37vRaKhiSKVSUa9xenrK6uoq6+vrbG5ucnx8zPvvvw+gfNT1ep3BYKCKRMlkkkuXLj0TViYgUljj4+NjPvzwQ8X0bm9vs7S09IyCJp1OK8WWzGkpdgrzLYohUeFItw7ZE0gP7tFoRLFYVO2+xEcvv6tpYW9tYZXl84nCSQoe2WxWqZFk3yL7GLnnfN9Xzyv5fOJnl0KZKBhEtSCdOw4PD9XPlEolWq0WhmGwvr6OaZpsbGwwn89V//U/7uNP0/oIYGHixkrcnAfcZM669lvkzAIDVyeZnfLEz/H+9E16eoon1RhbvQR/xrVYLv0uyewUvTql/EZAbCcEFa13oPGOjteIM/ddCgSAT4BNAg3P1+iis+cnSfpZtsiw8Pv4borWQ5fWwykBF8iSYQMLj028RRv/4UNSjwNG18LU8PwYrOdhVPTpZT9k8f4x+cMiyekqSerkrRh6Yo/91wMObiTx0wbVDwdc+08BF1satd2AXhY6Z+Am4STt0/9cmTlzfGtB106Q6dnYsYDEjwfETeCtLKZVYWE0qcbmBDaMM1PMnMvYh0UsBE/DCeBA1YBOzKLQ8okfwWHWJ5i4MDwEY5mgl8FKpMi9PCehg25oBEEZbWay7Le5rEPegJMZWIkaMfrsmi61Q+iOA/bMIQvPJTHVwB+A3YPsFTg7IfaffpvyN6C/yHIhPmPtis9+CfxuKJO+OzNpvPgcXHsR7AAG32LWPsPf+jTUroYR8Z4GmSxoQ0ju4Jiv4Hgn1GYBxx0YlWGynIbMy1D8MdCvg2uF1YiZDvMuRuO/8ersbVaHHosjSHXgzIbxAjY0BzsDvxFPoo1MXrs7oXYIowuQuQyJCXhPoBrA8lZAbz2U6ndPdIz3fJINnbSXwi9OKS+DvaehzU20Sw5nL8DZ1jIUXwirNf4p6CXQrVDrra2iHd/h5vvvsNH16ALeVpi2f+R9RCZ5C56vghWAOQA/DtYM4m7Ywsv+qAWYZ4Yy8+wIkmWwCAswrg/2JAxTszUYD6HgwaALsQI8XwU7EYar2TqsarA0BMsPO5k5GszSYQcz04S0F7aaS2fDMHhNC0n7gQOVlTCs3jqGXNbFn5+S9XsYiQ7peQLfTjGiQkCGPBXKxBlzSpIJtaBI3+/D5Azb9tknT5UMTlrH265hz1usTgy2KBPjkDXiWOSo/h+xZVhUugso+Vc6nSadTqtwG2EtosFAklYq3mjZsAuglmq8AJXzHln5t4BT8f0KCBQJtzwQJXVbWFVN01Q6rniOpdItidXypzy0ZdMmcr6oVzkKzKMM+Cf5d8+zf1HmQ8Dbee96lBkV0CSstnyJXC7qtZbfjf4pmxYZa2GH5XwlhE76ny4WC/XeUiA575WPMt3CDkeLDFFWXv4tn0G8inIIiyPBPtJbdzKZqGKKbM5k8y2vHfUKR8dPxk02t/I7cu3kS143WtCISsHFPiAgNAr0Zf4IyJb3kveJqj6iADU6rgKezyseokWY8/5w8buK11CKW1EWWt7r/DU4760WVkbmu8xVkXRGWXH5d1TKeX7eyWeKFn2if/5xH1/60pf40pe+9In/FwQB//Sf/lP+zt/5O/zkT/4kAP/23/5blpaW+JVf+RV+9md/lnv37vHlL3+Zb33rW7z66qsA/PN//s/5sR/7Mf7JP/knrK6u/qHPpdPpqCCpUqnE2toaL7/8Mg8ePKBer5PP53nrrbf44IMPVEL3xsYGL7/8siokaloYoLZYLDg8POT09FTNoei9Lqy14ziql7Kwv2IDkXu13+8rplB6Jt+5c0dJm2OxGIPBgLW1Nf7G3/gbnJyc8I1vfIP33nuPTqfDlStXcByH9fV1bty4wcnJCe+9994zNiIpwkwmE7785S9jWRavv/467XabBw8e8MEHHzCZTHjppZd44403eOutt5Q0XCTAEsQoc+z09BTHcVTrJwnoFBny0dEREMqwJbTqwoULqhAprQVFkizMuYyd2EskmFPkzqJacl2Xb33rW3Q6HWVlyuVyqje0MM6NRoNsNsv169cJgkBdl0ql8ozPPHpfbG5u0mq1nlEuaZqm1GDSgkoKoyLBPzo64tatW6oYIuxoo9FQ4C2Xy/H06VPlv3ddl+FwyGAwUOBXbAYrKyt0u11V7JWiWjweZ3V1lVqtRjweJ5fLUSwWVRFXLD66rqswNinGSSEvCALVH342myllwmAwUG1E5bkkRftoErqs59LqUKxAYsWRoo0Epsna6rou/X5fAfRosVz2DNG8ALmfxNMOKJm93DeLxYKtrS3S6TTD4VDZcxwnbK0nAZyiPigUCgr4V6tVRTLIOYjkfX19nadPn9LpdP5EmO4/TesjgE+LwI0x087QgyKrhs/LVx7ycAG1NPxwRuM3Pxzx29MrfCOTQRvN2PKe8PLrLbS1gHkAWjZk2RYjOPyqxulhEd8vAVNiySamE0fzKvj0GDppHOKsmWNimT7BqE4mKJLCxSeDTowYc/oMmekLDL+G5mVIHsRIf7igEABl6JswHUB+Ddy/6dE97ZH8epeDb57RerDEFzo5Zk6apxenzJ5LoJ1A5ndh+fc2SGkTtGKfxD1IHWSx/RyXHvZ4Mj2l92aFcdsg9qDH2q2ATBe6n4H8D0N+MCP+TpyYm8I79InXbAqfsvCKcGiGoHt2CIYLyRLEA0jkLSw79P8uJcb0jmZMcCD52zDM07lwgSdXn1BNLHiUSuEWtkj4R+y4AalZmFYdLBw0/xG7g/t83vJoFqC3AcWRTcyHlp0Otc6xY/AMzG//JtvvnJKbbLDInBCv+dzJgOfB6lOdoyaMn/PQsscE1+pAGoYLfLcC1ZUw2Xu2gFgcAgOSBsRy+Gs/wsPWMTntNoZuE4+BoSfwspsQz0F/AGkjpIEHC5jeZtl5l9Jjn8e/kybVM4ibFreXAyamQerMw0x4OHWPeT7Db8d1Sus2mecdir5PtQ8dC5wWbOVhkYHJ8hL2cpql00M2Gjo+M9y5g7EHCT2g9EUH6yrcS6Wwc89BaQP0Xqj7NxKhxltbQusfc/XB+7x86jEKQh8/wGmg0y3tEng2o9kTMgmw0jDMwWQSyrtdLWwbl0lCtgZuPCxkGCPwyiHrbZ0BMUhvQFyH4CTsTBYrQjCFeDf0atsmlAFzAc0exGNQW0C3AATgA54f9rlPmeC4MLdCwD32oZwIg+kHdYi9AJ0n4X0R+GBft9j6fIP0Qxj+tyLpRZEpMMKhxYRlppTwKeOBGQe9hrEYMmBOnSNeGmT4nZM4izp4lg9unhQm69TYJ0+Xgz/SWiPH9zToHo/HCgTIQ0uq/tIeQ4CObHZ0XVfyNJGTDYdDlfbdarVUb1IBAPAxQBDvt4BsAcGykRJgLxV1eeC6rsvx8TGZTIaVlRW1sZJ+0CKnlmAT2fQIcBQZW5QljrLZ4kGUc5Xe4tGEbPENyvkJoIoCGPl9AVYC7OVcBKTW63UKhcIzXjA5D2FFxWssm3YpFET9vAJcZXMh/y9gTDYksuGR8RZZpTCYnucp31pU4i+fV/zRAvyAZ3zfAoSFyTk5OWE6naoEZOntKsWWaEFGpJLCYMgmbTKZPFP0iErHo6qIqC8/n88/k5ouCg7Z7AmrNBqN6Ha7z1ybaBKvvOd5gBstsET/FL90tBAAPLPxi/oY5X6Taw4o9tk0TZV1EGWhzrfTixYBxBoRtU/IHBTAHR3LaNhaNM9ACgHRaxQtqslnk9Cw7+YhQUg//MM/rL5XKBR4/fXX+cY3vsHP/uzP8o1vfINisag2lAA//MM/jK7rvP322/z0T//073tdUQPIMRqNAFTK95MnTxgMBgocPn36lGazyec//3nefPNNMpkMR0dHqo2YeLsFZE2nU6XGGY1GKgSqUqkodlPeP5lMcuPGDUzTpNFoKOuH7/tkMhkMw1DzVtKgRYEgHtK1tTXFrqdSKXZ3d3nhhRdoNBq89dZb3L59W3m0C4UCb731Fo8ePeLatWtKZeN5HktLS3S7XXzf5969e+q1Hz16xP7+PkEQqM37zZs3efDggcq6CIKAer1OJpOh1+s9039Zeo9LD26A9fV1BoMBs9mMUqlEqVTic5/7HFtbW3S73WfuRQHrEvrVarUUM99qtYjFYuzu7iq/cyqV4uHDhyr7Qzzbzz33HOl0WrV1E/WGyJxv3brFo0ePiMXCdnHCgM5mMwW65VxWV1f57Gc/S6/Xo91uk0wmyeVySrYuhbThcKh6qD948IBOp6Pk94Ba4w3D4OHDh1QqFa5du8YP/dAPASF4PD4+5uHDhzQaDfr9PuPxmDfeeEOpIC5duqR6aEurtUwmw/r6OoZhsLy8rALlpEgoYW2LxYL9/X2lruh2u2xubip/v/SZl7Veun8A6rkUVShJAULWVRmTxWLB6uqqmr9ra2tYlkUulyOXyyn7j9guopYqKQ51u10V6iaAX9Y6SXyXpPNKpaIUV57nqaKDMPWFQkFln4zHY3XPuW7YNUTmZCwWU33lj46OlEKj0+nguu4znVj29/e/47XuOzn+pNZH+IPXSJcGZFI8Cp7iDEvoXo5sp8NTT6NxEufzNy2+cOmYwoc9Xm465MiSzNiMYgE5CxKlMNV5dgqdQxgdxBn5BcakSRGnnGyhazbtuYaND+RI6hbPLVuYcWgsmgTzKXHy+GhkcDBo0s2NoRigTU9w+hm8xAIvFfZkLvQgWIOZGVp0Uymo7vpkboL7Z6c4bz3h8W9B0gE7S5h49tsB6d9JkZslSC638BPgxWGpNKU7hd39GDu/POG3tBGtCzlqj+bk7kGsCTUHGp8F/Qc9Ltg9tA/TxFIu/hocXYJxFtwe1OOhBLjrQXwOQzcsDhi9CovBlMvXLI4HHg9nU/zSALYu4n3uC9zeWifRfQdb00E7paYfYyTgHVvD1iE5m1Bu32JjCq170JhDaga7K+BsQ/OKBqlDePS/oo171OZPmG9onBUPqD9nM0iDewIrb2XI9jcZBW3Mbhd9MCT2/m9QfOQwiOlY1U1Ip6E3hMEMluKgmaG52rMhcxHn9f+F3uTfE2t/iJ/U8LJLMM2D5oWAO6FDbwqLI8zBN8m+N8H6nRUKozLJj1pMJaYO/TwsdIPMB30+p0+ZfarLV39knRPtAqSblI73MW65dA8N2tM0g8GM+hc9jMCH3Cru1QZZZ47XbFPuaxgjnczrPtlr8G4MDpcvQu35UCZvaiH1PJlBMgeeRXn/d/nUZET/IbRjsLEZ+qRvBUWC1SswPWTs6PQtn5kLdhrwQrU9qdCj7bVAn4JeBrMUYntjCfI5mJ7BIg35N8FyID6BtQRYOuT1cJiP3TC9PNWARAbcCsyTsLWAvB967c0uJEzQ8qG33PPClusOIVAPQiyMpkFpO2yB12qBl4fsNSg+FxbDDN2lwJQUA1xKTPCZEeBjUvGGpPYd3GSJa26DBCYPyXPRt+icnfD+8xXapTG32wV81inybfKcsmCX7+T4ngbdspAKKI1KemWjIH5B+FjeKht82dxH26XIpmIwGCg2XBgaQPX2jLKOAhbgWTAjwHw6neL7Pp1OB9u2FasUTUPNZrPqIS2HVNDlM0klXJj4aNssAeTy3gJKo0yofG45X5EQCxCNst/nme4oOEqlUuTzeRVAJ2yVpNAKgy2tvYStliTyKKAWkBb1T0fBkGx8BERFga9saMQ3/klqhOj7REGxgDVhxmSDMp1OmU6n9Ho95amUllvyeucLFFGAG/2/817iaPJ39BAQKcnD0a8oY+95ngrGG4/HSh4shZ6oz/r8uUQBaPSQf0fVIlFge165IOci4yWsiwBdKXBIEST6GnK/RcdG5oIAewEOci1lTp8fr+h4C5MV9bH/QX+X+1Jk8N/No9FoAGFIWfRYWlpS/9doNFRwlRzi+5WfOX/8w3/4D/n7f//vf+L/SYjSYDDgq1/9KgcHB6TTaba2tjg8PGR3d5dXX32Vz33uc7iuy927d5nNZlQqFdLpNK1Wi3a7TbvdVinnct2lz7bv++RyOXRdV8W4R48ekU6nmUwmNJtNisUig8FAAQZpxeQ4Dnt7e3zlK1/hlVdeYXd3VxWbdF1/pj3f+vo6P/VTP8Vrr73G3bt3lZz31q1bykMtc6bX67G2tkahUKDdbpPNZnn48KEqTEmhaDQasbe3x4svvqi84cIqapqmwtREDi8tqSS0UAK+BoOB6oF87do1PM/j5s2b1Ot1FbLY6/UYDAYqsfvw8BDf9zk6OmI2m3F4eAjAiy++qJLKr127ps4jlUqxs7NDsVhU7RPv3r3LcDhUapDZbMbu7i6xWIx33nmH/f190uk0X/ziF5UaRQqS8nyQop/4paVYLfeYgMhGo6GKu3fv3mUymSipuKyXApAFCIu0WfzhjuOoNG4pjAt7K0B0a2uL1dVVpeSZzWYqlE3UA/LMkcRwUZE9fPiQk5MTVSCSsRdLwaVLl5S1Irp+pdPpZ+aagFV5NsvzRixlkskiFgFRTsm9LbkfMsZyzaI/L/kh4uM2TVM936UoKOtpIpGgUqmouZvL5ZjP5xwfH6vrUi6XlV3Ktm2VRi/Fq1qtRr/fV+Mcj8dVmKFI5aU48+DBg2eUdN+N409qfYQ/eI2M4YBtEnNzdBjzm0GCg+YK6cBlC5/Dic3llYBXlmZ89iK45T733of5I6h+BlKvQ9uG9jeg/RiOpwZdsnjoBHh0hil0dHwm5Mij6zPq10YULsGj9yHtekwSQ5oLi2KwxIAyHhY5d4y9gGTcxdF8HuyXOP1vYyqfconthkFU9ST4OsznYaJ0bwmG6zqpnww4eVUjdddnWNSgr1H61oTL7RiLyjHets1sAD0L1tYCCvEJ7QGsOPDSuxN+PePjaDqcBThjncQ9j/US+J+B2ecCKvUplV6YHu1qwBiyR2ELp2EWRhnYMYE+uJpB1t9Eb/TRj/ZZz4C1PuH0WoqFtwM3nyOoL2Mt5jB+QqJzytrAZV4Fbx6QPgzbeJUPwP5Q41bDQHNMXizb2K/A129UmF3bBq2JMd7DS6Vo77yMV1yB+fsURscYH2hUH2tovTx9DcblCY0LFbxYney3HpC9FTBfdVn80BDfHIaG6YUbokVtAvgwN8IqRWwLav8zTv4IjGlIs3IBgpWQyu23wGmgz3+V1bcfsvHWOiU/wayyRzPmMgp0LF0nyCdIBBa5rot1DFtrcJBucliO4zubDKsJjs375Cc1Sm6WafsQC4+VZJennSfYOx6ZNai3IPYkYOoEOGtw3IUn5QL+5vWwobVtQToVGq61BcRTaI8+ZPmkwaINo7OQ2J82IB6H9Ksz+hf7kFzibJLCbU8JurDIQboOs2k4DGYQtv6aOGFrsmwWfAfsQ/CLMC7DqBh6uQ0XMmkIRhBfg/ILYS0g1odUE3on4K1AUYdZLpSll/eh6IJWBIywt/dkFgoPPDsc6noCfA8GsfAjTgtQeA2MODhFyG6DdRuOfyvOkXUJmyQlElTJU2KMzQATnWUSXO1nSGNykwL3tDzfNFZ4073Ppn/K3dGMxXKaxwObirPGDjvkuc+H9P/Iaxx8j4PuT0rXFDApEq5YLKZkaCJ1FaAq/rqobGw2m6kvYTyiQVbCwMiGPRoSFpWtfpIUXeR0nU5HAWyREMoGQACOVLtFztztdrFtW7HGAmDlSyreUUmbVMvh45ZaUflwNKAsKruNgtcoQE0kEiqop1gsPjOuUem7+Cb7/b76M5owLWqBQqFApVJRDJt45qMAMNpmLCqNlusrfxfvoK7ramMhLLYAM/H6RwGbrocJ+JPJRPkZRbotifJyHlEQHQW6AgJlrGVOfZJsX1jiqNxcbBFRL3epVFJyfTlHGVspDEg/ZHkd13VVOq38TjSPIKoykEMAuvyufCZhwqLFDpGRRwsrUuCJfj5RjhiGodKdhfWOvr+MwSdZHqKhdCIzlw1q9B6R+S73nMyLaHFBvi/3jczB8wWI79Xjb//tv83f/Jt/U/17NBqxsbFBpVJRQVoyB4IgTC2uVCq/r6i3srKi7gMpDJ6cnChguLe3B4SFEc/znrmfRMGxs7OjClWWZdFsNvF9XyVsC1Ms/mdhfB89esTBwQE/8RM/Qa1Wo9VqKZmvqJEkAXx1dVWxqW+//TYnJycsLS2pzAWA2WzG/fv3qdfram2ZTCY8evSI5eVlNVaiftrb21MBUqenp3Q6Hc7OzpTnNZVKPZM+LQGc4ucW2e7zzz+velQbhqE82gJWB4MB4/GYR48eKa+xFEyHwyHr6+sUi0U8z+Pll1+mXC4zHA4VSCsUCjSbTT744AMFLofDIfP5nFqtxrVr1/jsZz/L+++/z4MHD5TnWlhdkbFHU7KBZ+xCwi7LuiXnJiDw6dOnjEYjxTbLWlooFLh48aLKATg4OKDf73N2dqbWpFqtptLnJX29WCyq9+p0OioxvFgsAqGiLZPJqN8Vhj6fzz8jk5dCxGw2Y39/n+FwqABzPB6n2WxydHTECy+8oOahzBcpEohaR1RhArzl35JCbhiGkrobRpjMHm09J8DcMAxVUJ9Op2ouOo7DysqKWj/FxiE/J2v/bDZTIXwiWZc5JM94KcIWi0XG47GyKEiRfTqdqsLbZDJhaWlJqTd832d5eZnJZMLJyQmu65LJZJTS6/vl+IPWyDWWaMzn2NTIYBMwxg8yVPGp0CYYgXUFnB8EfxtWt2ASh/ldKK1DfANOH4eb/6NDuDurMiNGgTgOLoUgRQYPjT4xisTrfXZ+wKfbgakPdhKa4zwBMaqMcUizoIZlz5hoI3pjg4mfZW6b+L9exv12h4v/tyFeDbJt2HZC2fFZAIUhnOYDTmspxqsZdHdATHfI/V6XS+8GLOsB03WbURFohADqvgf1LUg8F3rFU8dg7BXprabJG8eUrASeO+biLZ9FEppbMPgcjI5h/luQ+bLJdOHhLgL68VD2vfDAjodp03nDY5TeIz6rMn6nTOZTPVZvBHQuJVn46yELezYES8dw5qyN52QH0BpD5T6sWOBcDYO8nCOToZtgI74gtxnwu2vrtF7+f0DFgMFtvGAI2Rpu4QegeUr5w7dZvqfh/l6NoWfTLZ5Rrp4xvWay+Nw2vN8j/q7PqJsCf05x1qFnvQvBlbCp+cSCeQBJLaRWkwnQU2FD6dwFSBkQC0LTcteGXgt4BPF3qT55l523UyzFAiavPuXDWoZTO03M7eOk4mhFmzVzwdIBzI5h0IDdhIOtP+WsnsPPXONktYsTn5EKbNLLC/YDcIKAeveMdBaOkyHWv7AMB4dhYnw6B04mDUYp1GoXYmFomuGBqcNshjZ6TGnmcXYMYweyOngtk4SmU81anD03xn8hSWbms9iD0RjYgiAWtvPyjbD/diIGgQeTadgmLJGFwIaMBbWb8KAa9kC/mYCiBzMP0gnwrJChDm5D/wSMZcjmw/T8uRZKys3HkLSheiP82aQFVRPmPVh0YDb4KBfOAPcyLLaha4LxHOTqYY/wySk43wD7YIkBMU6ZUWWNTVrUeUSSNDEKQJY6SVKkeYTON3MLJrk8p2dprvkGqZHL4oUKvdiUWw/OWJ5WqXCJU34/IfSHOb6nQbf4qKIbBKninwfd4qX2vI97kEbBuTzAJCxGgsoA9bAVhgxQMlkB5tHN/3k/rJyPgNB8Pq+Yavl9AfdRJlRk4tPpVKXrSluqaGBalD08XxiIenyFVRYQEwWvwnhHPcdRH7Rsys6D7mjQlkizpa+qFAikhVZUoichYeVy+RlvXBQwyWZexjPqJZbPLNdNQLdsXiR0RzZMcv3hYzY3KhedTCZKZiebMQEpUbm/XJdoAN95f/x50Cffj6oK5DWFLZFwuGKxSCaTUaFR0esjagLZQEdBt2EYChSLt1Guy38PdAuQFhAsLcui1ooosy6vES1iybWQsZA5N51OVcEmWoyQcZXPL9dLvkRFInNd5q+8rxzR+07mhRQK5LUEWGmapkB39HW/W4eAvWazycrKivp+s9nkxRdfVD8joWZyuK5Lr9d7BixGD5Fnnz9kTTk6OqJcLnPjxg22t7cVaJDrVywW1bqzs7NDq9VSEuR8Pq9sN1KMlPt3Op1SqVRU8TIejzMajWi1WgogiCdY1hABGdVqVYVuXb16Fdd1SSQSqq2UruscHR0RBGFP7vX1dcrlMnt7e2xvb6v59K1vfYvxeKxY1LOzM2UvKhaLJBIJZrMZzWYTwzC4e/cuX/rSl/jUpz7F7du38TxPhZbV63Vu3rypVBC2bXN2dka9XlcFUlknABWsJWuBBJRBOP9lvZb2iFKkkqJUIpFQgZ3T6ZRiscilS5dYWVmhUCgof6qEmAF0u11+93d/l3a7rcLghDFeWlpS7dMgtM/IGijrnOd5itmUYqTYCKJrolwzkWFLkvjv/d7vKZVBoVBQfaHfeecdPvzwQzQtbDm1tramCp3JZJLBYKAC2u7evas82sJciuLI8zxlG5OioaZpSnEmn0nWj2gHh263qwobAqalWCuF3slkolRtsu7ncjmVLi4WpGgbsGgXiehzS/qcS9hdu92m0WgoSfh8PldBqKJ2k3Z7UjSS1nGmaaqCgRRMRQki6jhZL0VCL1azSqVCLpdTFo5MJqP8/aKukuKaZVkcHBwwGo3Y2tpiZWWFg4MDdnZ2ME2T09NTtra2yOVy33XQ/Se1PsIfvEZCwFU07mv7lIOAqyTYZsYyJkZhjrYWEBSguPyR7zUPF/8sNF+D2WrIuuUDGCahNTNoBiYDvUvXz5ImSZk8ZWb4DPD1LrHNGaMytD6ErAN6BvKTCmYQR9cPSfinBGRxTIdqHDq+jhXr8vymy8KOkewHZN+H1vXQapy9B8knkAngxg+AXw74tb05+9sumYSL7oHxLZ/kXoJF0sHpwtmxgZv0iDtQBBJG2La52QDzsUFtMeL0/1Lk6CfTZH9nQOLAZ/8wGwK2z/jcfxGcNKwPUmjNZU7NM1biFv4YAhOYwHgK6Rik1mGWHBPbi2MuknxgxRlpN7G0N8C8APMBjOewMMlMZ6zZYa5Zcgh5Owx5y3fD9lOtokN55HNx12P6RY2T1eeg/koIeldfBtsB3YbOU4rf+CVePOpgPTQIfJN4fEZxCdwtmOwkIDYDRiQqAb4+wy6GSd367DZ+aR+Sl0GbglkMtdWJeNj/Svuob5W3AF0LqdeRD/4BFG6hnX2N2lcfsPRWjDgu+pdOeW+nwlHudWLffg9uD4EkpeUxyQuhbdysg1cBfwhONyBWvYd+r0ssPkV/YczgTGPpAnhJkz4FrrpdNsaw54A5h5gNh8AgBXHdwM4WQZsBM9BrYHVCxttKQG+P8viIZBsGPUKaOgDfhJSTpDpYEJ+NsLwS+izs4T7RIOfDrAv9GRSKoCVh7oBjgTOE+DCUiMdXIV0LM9tGG5DOQyIAfwfQwb4F3TbkrwMWzE8hXwFjDlMLEgtwR+BOwTkJbehZLyxOmTUY34HZB2GrN8cJg+KTD0D/AtgX4dSEShW8Pdj/jzqzZoGF57OhPaJmWBhukjoJ0gwZozNkHYMUVUye4HDHMJikbEgf0DDnfGpR4LXBgq/ef4x9c5PTSop3fnPA571LxJkA7/7hF7iPju9p0B0FRNHWWgJ0hSWWSrIEmIlHWDbiwtzJhj3KfkfZZPi4TZH8XFQiHZX3Rv8UMCsP7ijDBKj3lQeDvGZURi4scBSIREHGeTmxsKey6RJgI0BRAubOy25lIy6fUz6zBHvJQ102ajJusqkTYBhtlyMASDanEiwkX9EWK/J5o0ArynJHCypR8CsbCtM0GQwGKmU2CiCjaee6riuWQHr6CpCNvr98Tjk/8ccL0BTAC6hzkmsk102uj1wvUUfI7wNK9iqMYbRAcj54TlQSAiBlTgsTdV6xEAWi8vMyptFxlbkoYyTjFQ0YknslWpiRzy2vK9deZJ1yb0bfT+5d6SAgrJCMl8gs5SsaPvRJiofzcvJoVkH0M8vvSz/f7+YhgPcrX/mK2kSORiPefvtt/upf/asAfOYzn2EwGPDOO+/wyiuvAPCbv/mb+L7P66+//kd6v263y9raGjdu3FDSU7mm1WqV5eVlxaYZhqF80pubm0oWC9Dv9/F9n9FopIKbfN9X3t9SqUQ+nycIAprNpspySCaTlMtlVbSUBGXTNFXCtYCIarXKxsYGmUxGtS/a399nNBqRSqVot9ssLS2p4s/u7q4C9jLnJexQ5NYiwdU0Ta1Ns9mMu3fv8vrrr5NIJLh165Zq6yTZFGInkYAqkbFLzke04JpIJKhWq0ynU6rVKtevX6dWq6n3E/AkXmmRFkfbmgkLvLq6ysbGhlIZdLtdqtWqum/n87mSk0vvckCphYRZ39vbIxaLcenSJUajkeoiIEGQcn+JF1iUA5LKHi1OyTPr3r17/Jf/8l/U2i7rbiaTUcn00kJuMBig6zrValVJnaWLx9OnT9nf31eFF1kHRGEkc7Hf79PtdpWXW+75YrH4+5Qt8uyT8K9er4fneUrNIvL2ZDKpsiakkCGqDVE1SWq/rMuyVgtbLM8AebbK3/P5PHt7e6qoLM8MuVaapqnCkBQ8BERPJhPl7z89PSWbzVKv11UvdSnKSNq6FLdnsxmTyUSF/kmxZDweM5lM1HMonU4/k0PQ7XaVJ/2VV17h61//Oo8fP6ZWq6mkeNkPfDeP7/b6CPCYERdZ4jNBkRIWBVLE6GMkmlQveyw/D7EMzPUwa8keQ2YNNi+GQNVfAH3oL8DHY54Y4xQLDDtDpl7A8UevWGJBXp8RaNA8gOEpLGxIVqE0bhB4AZmKRa/rYFk6pusybYNvBaR1sG2f6iWbjRwcL8NBGl4YQ/sRzH9TIzXRmTU8lvLwaSNg6/ML3CtwmIWBBrGYi276dLsGk/kKQwZosSm5ZMB8H/QA5g2d8eACK0en2LcP6X7mCu3kHXL/0cLeL2I4Dqm4ja9BbAKO7zGlTyZhhe2bWmGIVd2A+gJibkiyJhZQqfQYuhrttdcIrv3PYUL4fADWt8BqQPIMrefRawMzKAVQSkI3Du02ZI4NNFtnZcWh9Fl4b1PDj81g+ADSL4RpXolDsO+Tvfe/82p7D6cJzRWPbu2UjAmrRTg2IX42J7G3xySmcXpdRx+buEWDIDEnPj3DWvw2MAoN6mYMkjfCtls9BxZOaF4fanBqQdGBfA/0/4p2720q/1uLi+9kmS1SGC+cMKwFNLLbBK0eOydNgqmGPbVJLwIKDhSWoJENg+aqAZgjyD1ZcHXvGN0DqwYjAvIG+B0Xdz6iMg1J9mwfYu+Di8bznw944sM9igTFddDjITL2MmFDbyMGWgyzs8dGZ4R/Fsq4U2bILPeSkHAyFPQxhUkDK/YKp8UimjknKe295xBoIaOtz8OhCTyIJyGYhNc+uwHzJfiWDp24zg4+YwdmcaAcFqnSY8gFYGaAJAzPoLcXtisrPf9REFsXtHYIupOJsLWdXoLpAzi9lyHre9TxmCdc9HFAzIdqAjpr0LUgPgUr0JnpNhNvQTyIsYHBgqfEWWZCnQlpZphMsCiSxmbOKDZGGw7Q6DLNzFksDD7r2ej3e9weLOgbF2n7dR7hYfCdrY/f06Db9/1nQJwEpIkcdjKZkMlk1AYinU4r8CcPewEnwgZG/aTCuMmGNLpJj3rHTdNUIEkYxfNMs/jDo+ylMB4CwKPp2yKrlOJBtDIfDYyKsoYClgDFLAl4Em+abC6jGxbZcEVDtKLgXaSU6XT6mZZcMo5yjrKpEzYhOmZRVkWSYcUjKddMkl+jgEhaqkQBV1ShIKyOJJ4LwJVeuIlEAsdxlHQyKkcUz/ZgMKDVaqm+4FFfuTAwMheixRl5H9mYye9J0I6keQtrJEy0KC5kjkU91FJ4kc1ulNGPbrTkK3r9o5tmAeFRpcV50C3jKfeLjG2UhZcgNSk0iArkvHw+eshckjY4co9E5yygNu3Sekyus2xyo6qTaDEs+jpyv0a/H1VuyOeNHnKN/iRA92QyUTJsCMOBbt26RblcZnNzk7/+1/86/+Af/AN2d3dVS5zV1VXVq/batWv86I/+KH/lr/wV/uW//Jc4jsPP//zP87M/+7N/5GReYamXlpaUdLzdbuM4Do1Gg+PjY378x3+cfD6vPMkyx4WplXTuVCoFoHza/X5fhXDBx5kIIhv3fZ+NjQ21lhSLRVWQk9fN5/Mqbbvf71Or1fihH/ohNjY2+NVf/VXef/99hsMhFy9eVPLgWq3G48ePsSyL1157jZ2dHXUfDAYD4vE4lUpFtdSTNkuiYhL2WuS4ApxyuRwrKyuqC0MqlVKeZZnDlmWpZ4x40zOZDMlkktFoxObmJkEQ0Ov1yOVyCszN53N6vR6j0UgVsOR+GwwGqnCxvLysisClUkmtKScnJwA8fPiQhw8f0mw2mc/nXLp0ia2tLTRN4/Hjx8oeIyxtqVQil8sRj8eZz+fK5hPt5CEyZZFriz1EJPOdToenT5/yrW99Sz135L5tNpvqWSI5H1JElcK2SK6lIC5y7ahiQAojkqZdqVRot9sqh0Ok9dFWW8JIixrJtm0Gg4F6dkRtL8KEStiYbdtcuHCB4+Njksmk8udHA1Kjth74uDAeVTbIOi1ebylO7ezskMlkaDQaynYlahAJTc1kMuq8xHrT6/VU8VqKKolEgs3NTWUfkn2KpJO3Wi1VEBqPx/i+rwJOJc9Aih6SWSKF8/39fXq9HpVKhTfffJODgwOePHmirE2FQuE7XAX/4ONP0/oIkCbHE6a8xC4rrDKhS5t7OAuDsw90jmdDfuz/PCO/CsMZFBPgmODYYKZgbIQkojaFFKCbNlSSaOMJsVkPixo2KUDD9wPc07AbVa8NfgE2lsDw5mhNKGbA8lzmjThW4GLpDjk0jr0sH5ymWJ0MWXxpyukPg7EOs/8It78eZzz1uZj0iH8jRjPuUisGXOhB+8+A/gNQvAjVlzyCNvQnGgniVMgwdud0pwHWkwR518IO4CFFcoMZ9dMuvbHDsJyiW7MIOiOKGwu66xqjtEk67WDvLDBmDjUvVF2bSahaYSq1b4DegowG2nUo9gKaR3GCjUuAHxp5c0nwBmB9gDE7ItbziA9h1YMJofw+PYRpF7xpjlLSpfCKw3EBjt0ArdggCOah/3rwHsTeJ/nwd3nt3ce4DZ+nBni7MNxaY6IlWXn8mEs9qB/6OE9tpgYsLsKk7EDcIWWB35/RXXyNcaIDpoZmDgmyD0H7HCTqkFwJ9c5eL+wRN3qKdvIfyD9+m5XfmFG+m4b4DO9Sj8VFn6MuuNkTMt6IUsbDrcNE93DiYPphkrefh6QHWQvWtFAlUNPDzmMTN5Rmp8dQmsFG18EowfQCGIeQeVIkXZjhuwuCDJB2gCxkrkKhDroBixIEA7BPSQxOyc3DllyBBk4JWIA79ekxpZAKKC1smrbFZOcih+UzVnowANwcxGfgfNSyK6GBlgoLUejgOuD1NCbdgN4qzIwYw6RNLwE1C7I+HPZg0tTYtgMyJWgkwW/BrF1kphn4Wo9EImDahowRBvT1imGRxxtCr2my8GvMsekxxrFNEtM5mw+g4EL2f4JpEXozKF10KZgurYZJ383QdzcZE+CzoECNNAkqTHHRsTHQiUHcJTedkW9lOMvkecsIOPUCanj83ztP2TNb/HpwmW+ySvo7hM/f06BbWGH4mIWMMsICUKRlijAismEXMCwPz2i7qejPyiZJHryAYjyjyabRlGcBOwK6o68v5yxVa2EPZMMrmwV5raj0N+qzlf+HZ9tORQEVfCz7FTZR2FSpyEffM8qsRsFR9LVF3iebwqgHPCpJF8miyEqFwZXfk88vzIUALdlIRUOyomMgx3l2Uxj36XT6DBsl5xD1SOu6rvqxS+BbNKldPqt8hmgo2yeFjZ0PgxNmWF4zGkwULZacl6JHv3/+Gkd/L/rzYhc4L80/75OOvpacq7yGXG8BWTIfZfyieQVy/aMgNzrf5H2jUnr53NGfiY6ZyJkFKEcBtrDr51UG0fETZub8/SE/F/27/P+fRJDat7/9bb74xS+qf4uP8C/+xb/Iv/7X/5q/9bf+FtPplJ/7uZ9jMBjw5ptv8uUvf1kVdwB+6Zd+iZ//+Z/nh37oh9B1nZ/5mZ/hF3/xF//I55LP5+l0OozHY1XoibaX2tvb47333mN3d5dut6s26uLvFzlvpVIhHo9TrVZVYne0UOc4jgJ0su4ZhqFksxAmqadSKdbW1mi324rRbjQaKs/g4sWLbG1tcXZ2xv3795lOp8/490WhEAQBe3t71Go1KpWKkqoLuNZ1nUKhoOZJNGtCZN1nZ2eq/djS0hKmaVKtVkmn06rd1sHBgUqCrlarrK6uslgsFCAUdYp0jchms8/0hBcbiPjJoz7farWqpO2+7yt/8mAwUN5xCYQTwLa/v0+n06HVaqkOGNVqVa1fgFLr5HI5BdIEJIoSYTKZKNXXysqKKqItLS0Ri8XodDo4TtgO7N69eyojo1arKeVUtVp9huVtNBpKFp5MJlWBd3l5mVQqxfHxsWKXpUOIqFzkHEulkgKbcn9KKy9J3pYinRQPpEuGFHrl/pYCpuu6ivEW5ngwGLC1taUKA9K+TQC7FA6ia8VwOFSp+yLXlgKPrL+JRILxeEy/36dcLquigOQbtFotldIvc0fWWfkcMm7yeSQITgrU0oJvOBwym81UoePw8FAx6nJPTqdTdF1Xvb1zuZzKlYnH46orQTqd5s0332R7e5tms6kKHdFOE39cx5+m9RGgSpET2vTwuUqAxxSbgHRwmZ69Q+t+i9X/9BaXXp7Rm0LqZShcAG8eMnWLBGQqUN6F+Huw0fa4PzzFTyYxZy4uHpDDMWz6mo9zksaPWzi6j2GEvmrTBRLQykAyDWvTAW3dJ5OEdOBw4szIuGUMc8zZVTi6APUGdO5r9JpbZBITqJyinfr4FbDKENzS0U2f7Ao4FTBuQvAY8n0fe2qik6MQDPCCEHDOgoDFakCxc4JrxyDp8NzZh3i9AP1VaF8aMTBhUEtjpS8wzZ6ivTQkVwwI+qFyebsG9XU4WoDdgLwGsy3opSDfD0PfyMbAXAGzAAkbZj5MbQzHIzeBZA/mZ6AXQbsIODB9oqO5C8yLMw6KUB3Ap5cCftMf0JsfQv8BzO6DP2T98T7xD32OfIhdhmnSIKgW8CY+lg2xdphkPuuHCdkpHeLTgFQanDWYF2GlNeHB9AOchEaMBYOVAf78Lvg5WPo8xJag8xjcLubRHZZuP2DpjkvBhdyrU4w81LMwW/pIARFPYuUNTs9mVCY+i4/CyPxK2IN6awWKSbh7CE8LBtm5R/dxCL7Hq5BLhCA51oHKE432VoC/CtkJuL7NxHBYDKG7DH58FTI3Ib4cNrpOFGGxgMEjmBwTuDaLIAxCM3xI5EJgm3Y0fM1hrsGG7nJ/0MLZ2qGR+xorLszGkMmDNQXfD+c8Zqjmd7MQZGH4JEm3uQ7jU5ZemNG1bJw4DCqwFYSp5D0Hxo0YgwcLyhdCQn4RwAyNubtK655JQnOw9DnJ6hx9FooLnEH4c6NxnCyrGBwz0ae4fomF4zMKbDJPIPMeVK+DNQ696DMgv+KSDNocNhb0nBWsj3LMq0yYMsOkTJ46HQyS8zwWAwJjgZ/OcFCccTx0uTxJ8OZKj51lm+N3T7nnXeIkv4DRH33N+Z4G3dIvFVCgWDb3UXmu+GWlv3LUn22apqqAS8KuBNtEwaf4WeHZ/sIi6xMmW0BBVJas67qqHEeT04UVEoY42ptZks3lNaMSenlvkcgLwBWAJOcZBRWyAYOQSUgmk6raHvXByzieZz6j0mx5bwFDApRlgyIbdhkreWAKyyybZ5GxySHMcxTsi4RUfIkyVucBl7AQwmhF5dHSOila8IBnw7qirPx5lYCMpxR0oqoAmU/RgojISmWzLxssAYXn7QtREBm9FlGgfn7eyRGVWEdtBnIfwO9neuU85P+lYCUAWVrSSdFD7hPZbArojm6Oo/fKJ4F9OVeZswIEhGGSsUylUkp9EpXVS4CczLnoZ5R5F5X5n2fy5f2jLNifBNP9hS984fddo+ihaRq/8Au/wC/8wi/8gT9TLpf55V/+5f+/z+Xo6Ei1nhNPcqfTYWVlhYsXLypQJaCx0Wiwu7vL8vIypmmqBOXd3V1OTk5oNBq8++67ivmez+ecnZ2p6ylrgMz5Xq9HJpPh0qVLjMdjGo0GuVyO9fV1BX6kpWC1WuXGjRsUi0XOzs6UbDZacJH1UzIb3nvvPa5du6baOFWrVZ4+ffoMi5jNZlleXlZAUDzfkpgt0lsp0ErLpGq1yoULF+h0OipVWtd1xbbK/D07O1P+5mq1qoq2gPLxSnunZDLJ6ekp6XRaZY3UajV832d7e5tarcZ4PFYhV7ZtMxwOlbzesiyOj4/VGiTn0m63n1FVJZNJpWgwDIP19XW2t7eBjzMwhsOh8t+Xy2Usy6JarSqbgAS0GYbB2toauVyOSqWiEsnFvy5e9OvXr5NKpTg8PMQwDFZXV1XB0vd9VlZW2N3d5Zvf/Kay/0gRTQCyrJsybyUfJB6P02q12N3dVUUCCMMQ5T7WdZ1yuax6S0sxWebkdDplaWmJIAg4PT3lypUrLBYL5Q8WmwOglG2aFrbYk6wPOarVKs1mk4sXL6p5LwWG8XjM2dmZsotFAyqjnRh6vZ4qAkvWi7DltVpNyfKFiZdE/yAIVP6FbduK1W63288828SPnc/n1f0o7cwkNE2KHpPJhPv373PhwgW1TxiNRkph8cd5/GlaHwFuc0SBAhYpZjSJMaRNihWGXNa+xpF3gXvv7TAe3yXoazS+rXPJcVh+LgQhuRz4F2C1BrsDaPw/fVqtgKFhkMNgwZxTAgzNwcRk4WfxLA8nsSDpBPTOIGvCxR+BcRwaX4NcfcH6BugjGNiwaDv0Wl1mV6YsnoOgCEED9IFJMogT9wMcwCl55PMQX4F+2yf1PmyuwfgzIdmZz0M1H/AAC4NN0rj0tBOySYdlE/wVMJMtBns6uQVcHAZMfBikwZ/B0IL0ZIGdsHDzZdrVBe1NE7MLZXNCYAdMdYh/xHQHa+DHQ29uzITkjgbVIsTKYRKXNgiNvH6SeNZgs+iTzEHnOGR2dRMmRUiu+3i1Gfc+rWHV4XonwGzANBHDtP4LtdEpnaRGru2x6rgc6qEvODOD43QYo55od0kvQgu2OddIOhU6+gTbszCfaGwEcMEISFeh70JxtsA5geEQus02RqVN3IJF9QPa+TKjIENxdMLl4Zw8AflN0LfCekJiAo+H0OlDEkhNLebFa5w8l8VMPWTpgYdhQmEt/IxtDR4FMR6ul7F2C0y/eURpL8vC95ikewQO5BfgxMHKBThdsPahXgR7ac4QKPYh0dIJdl+E5edh7gGzj3pszUOa2HDxSnHsdthuK/ZRv21nAJ7pMTUtlixYbwRkTvtMr6RpJEqc0EfTIJkHx4cAcGNhgnhqAdkSTJrQmWaxKJM8nVFlxrUC7F2CbgzmdiiJX74O4wOHs/fCQkLiI4bcDExMDGaYaIFB4KXoTRukph6xBfT7YLsGnlWgR5ta/IxkoGP7OklHZ2hCeh2SGSAGqRXQnoJtQ2Ed0m5Au+liMscgxRCNMSnSJFghi0eDy4ypOhm+YmYZ5afgHEK9j5eqcHaQ4l5CYysWoAEpbDC639Ga8z0NugXUCuCIMq/CxIjsGFAtQUSyLOAw6lVOp9MKZESDoc4zkFEvrAAp+Lg9lWw25GejTPQfBKai0lhhe6MMoYAgYRuirKEAqejrynH+3AVASTCVAG9Jd5YgLgE+n8SaCiCK+uABtQGPsp/R85T3E4Yhes7RtHUpWggjIwAv6g8WoCWfN8q0C/MuTKpcl08KupMxj3qTo2MWvZbnxzc6JtHrEAXhUeZXFBHnswhksy5FFLluUcY4+n7y/fNjK3+PMsxiL4iqEaKfR14rymbL1/lzP6+2iI6d/BlVQ3zS/Jbz9n1fKR/k2kfb2kUVFtExl9eKvkd0DKIFB/l3dEyjBY/v50MKGrZt8+DBA7WBz+VyvPjii8pSEY/HGY/HWJZFp9NRkmkpqBSLRV544QUODw9ptVqcnZ2pECkpLgmrJ0BK3l/GWoKwLMtic3NTMXepVIpGo6HmTqFQUOBIfMciZZfXEIA0m81oNBpqnZZ080QioVK+fd9XVqPV1VUKhYJikMXT3Ww2FeO6sbHBjRs3iMfjbG5ucvXqVZrNpupoAGGYk6yRqVRKMfoyHqZpKp+z53nKRrS2tvbMOqppGpcvXyaRSChQLG3Ftre3aTQaWJZFKpWi1WopT30mk1FhlsLqS5J6KpViZWWF4+NjxbJ3u11KpRLZbBZArTlSeJNCZ6FQUBJtuZZLS0uq+CKS/WQyqSwCwrSvrq6iaZo6z9lspoof9XqdWq2m2FMB/lLolCA1YZpLpRL1el21p5NxlhRwsfUEQaAUZFKEWCwW6vk9GAxU8VSArGVZSlJ/6dIlTk9PVZFPAKr4rnVdVyB1PB6rZPdCoUC5XFZ93KUItbm5SbvdxvM8RqORKoDIeikBmTK2w+FQydmjBUFN05TKQwqgtVpN3SPFYpHl5WVlDZNiZCaTUT+fy+WeaUlWqVTIZrP0+331fSlkShH+7t27ao6LzeD7/bBwMYgzxmGAQ5kSAxaktSe8WDmgNe5h2ZvEWiZjT8PaT9N5u0/2MiR1MBYf+VqrcOlH4eirNs33szxxDMoYgIODzcwtoTNhgYVDBs9OQm+OG0CQdnEtn9QslGRbRdhMhmA8Y0JK92nMBnyYg24AFGBQBzfwyNJCcxwGTYN41SOphS22kpuweAiFx1DfhEkQpk/nswFryQGGtUOFqzSDAH/Ux54azFMDjNcDdvIe7kOw5mE6u/s1MB5mqWTnpHou9y43Gd+4ghNbg41NHM2g0fptZtNj+pMgDGdbhuwCDB30NAx16BqAb8PMhmwCWkNoN8Bzsd0UsbnDdhWCa2E/50HY7YzMdZgnoLNTRCfgw96As3kJO3mRwtktDNvBT2bItW2CMWhlKNvgZ4CiAXoBNz+hU1ig25BNa6yMS5xoDpO5zWKUpmvaFJsuuRRkiuFY6ekQKFa1AO0sLCRUCxZ2/5R79kde9QUkNsJe7WM/BNztLjxJQmDBug2ZaoP74wKL1WscaRPs1jHuUEefaxhpl64bY1a/BrXPgD9BW7Sx8mO8rhbOh6FOYaGTLLtYBnhAKQelZZgMwJuAlYROag2yF8HSQgo54YI/CvX+qQ1wWgRpC3sB5VlY9xgsID5KYFRt0hcCko2Q+S6N20xdi/Zzmwz2BpSsgKEGsXoIkhdO6ONeeJBLwWQME18jzRMK1SHZXWjUYVjXSGYCPB28IizdhPZxgHcfhk9D339yFEf3k3iMydKnoLksgiwLR2c48NAd8CYGgbOCRwnYR8s4TG0NwxmxQGPsQC0JXgrsMiTWYdkOC1fOKUwnMZzFZWwKpBkyoMejWJklJ8sKIzSOWCJHgRxbborHgxwz0yCYxohPpmzrQ1K6z91DmPhpXCZhgN93cHxPg27xa8vDXDbt0QeKbN6FMZaKsVSxpUKdyWRUANB5uWQUhMn3osnWrusqP7Z4laNBWuPxWIF88amJ303ONwp2hInRNE2FrEiBoFQqPbNxk03MeY+wHAKO4ePWSclkUiXPiidPmGJpGdTr9Z7x7p6XCAszGu0XLkBSfHxSvY+yi5KGK3+KlE82UVJYkNAnSauFsKCRz+fV+8o5yLhJIJFcK3n/KEiDj+XyIgU9D8Sj4ydgMMqER0G/jGtUUi/zSnqlyvkJcJCNongTM5kM9XpdeUkFiEaVDFF/cvS95P3PS95lTEVVoWmaYvSi10TuD1EF5HI5dX6yMZefifrjo/NOxua8rPs8qyzXwTCMZ4L4ohYA2SRH24zJdYkGx0XHIqoAiBYbZEyk6ADPejO/20Fq3+1DAFOz2XymwHJ2dsZwOGQwGADh/bC9va0AQ7vdJpfLUS6X1e+srKxw9epVzs7OOD09fWZN8P0w6EnYabGKiAro5OREhXblcjn1msViEdu2qVQqDIdDxQxnMhkuX76seopL0JqoXQQISdiZBENtbm7iui6dTkcxsalUin6/rzoSDAYDUqmUKszKHBMp+OHhIdevX2d9fZ1EIqHaVzUaDbVWapqmihOTyYRbt24p6W4mk8HzPLrdLpqm0ev11PkJqFxeXiadTiu/uMxnAby+7/Puu+9iWZZ6NgnjL/3ThZXsdDrE43GV7n5wcMDp6anq8+26YTtF8UCL7L1QKCgrQbRIIkFj8oyMKooEfAqDLGDy+PiY/f196vU6N27cUIoBuUbVahVd18lkMqytrdHv91WonABhed4lk0mVXC1rkWVZvPjii9RqNVXskDUJUOtJtIOFKJBkrZSWdZqmUavV6HQ6XLt2jXv37ilJuxQhJARQLEiyr8hms9RqNZaWltjd3VVqDlkDY7EYa2trnJ2dKYm/4ziqlaWsbdlsVnm3pZgshXtd1xXYlfA5sWfJvWGaJpVKhVgsptqxeZ7H6empajkprPfS0hJHR0dqTpimST6fV7kH5XKZ3d1dBoMBe3t7JBIJ+v2+UoF8vx8XqDMnzZneZK4FND0NG411PcHgIgyaNs7+LqZ3yPYX+rQfL/APoP0OZItQrgI6zHTobsHuD/qcHfY47RsEZIlhohPDJ80UjwmQwEAjzsyNk4sNMDSf04dg1KHwMmQD0Nywl3FRD9tvVRKwZYE9gYGvM89omM97GB/OKQ82WbCgsjIlbsLCD9smTdohw5g9A/dx2FJq+UUouSMGe7foL6rgOKTcGH1Nw9MCsl0YP9RJPY3jNjwCzSEZA29qYM9j1OoexX2L8bUN2HktpLWzcbxUmmHzv6InD4l5PmkNxh04TEN3ojF/F7yaB8NOGNlu+2GbLc3F7LXwuikeLXRyc5+nAbi1ECtOytA3QqV0QBxvYHBoDfD8Bdn37lO2JrSXE/iZJJo3wXPCJPD5KtS3Yd212O/0MBI+3XUYlaEe8+m/+4RM0mfbD/AWNmbFpaCBfgiJOTxYhrMNKGqw5ELGg5EGDReKc7iRgFkSbA16AXSCMOE7M4HGJMxXYwFPDIOC57F98oDGQYdpTef4+SWYFCDpoU0axGYzUtUGc20KhVex1p5y9NJtaHms9jWKrTRW4DHzXPAhsQWZTZgD2XWIu/C1fI7piz8MtedgYYIRAJmQzg4y4eRKGPgxcMegT8DchJQNJkn8vB2mfn+oo60EbFd7NDpN3Gsvc3jniOxJj9hH7LjhhT25k0bo5R9PwsJTLNvFuOoz3YVH6xqnlw2sRAyzNyfphcGBaRfWVuHsLEwuN2JhN7YxPjo2cdNDLy3I9kcs7BjzJjhkCYIkBisE6Gha2EoddGKYjMiQGPUJBi6BDkYGJlmIvQbLBWh9DZxjB792m26zQnZ2gSJJ1h2DNQZs8IQDXL5l1HF8kyAwKfkFjEWFpYMxP+Afcz0zYDCFB806drBCQA+S3xlp8z0NuqMba/j93k1hb0XWJbJj2WzJRlR83cJ4R4F5lA2LemAFdIkMOBq+JtVlOc6z2/Lv80nV0U2sAIIooIKPZY0C5iShNOofPg+6o+cgGxSR8sqGTt5HAIxIO6NsavSzR5nNKMstoEfY6fPjFZUMC2gWRl9YWTm3aJuvaGCdgF75rFEgGv3s8lmiG8voRvL89Yi+nvx+lMX9JK+wbIbF0iAbKDnP6GvKZ4iy2xLwJnNO5kH0/OU1omz0/5e8Pw2yLE3vOsHf2e6+L77vER5b7pVZuak2qoRSQj09mAQ93cPYDBj9DWQyxAdGHzHDDMz4AJghmWEMw2A9A5phptUgQJRUohaVqiorKzIzIjNjj/Ddr/vd93vPPh9OPm+ecCVmXWotKDlmbh7u4ffes7znPe//+S+PfMlCLc76XvQ4JxIJFeAXl7fL38T3LZ5rIMqA+BY/33H2Oj4O4sWIuCLiItstqgtAyTDj4DBeEIj7UuX8yCL5ohrjIiiX8xZn3ONqlc/y1m63VRFmOp0qkClsYKvV4ujoiFqtRjabVe2TRqMRi4uL6t7JZrMqWTufzytJrUiD4RNJqwCyer2ugJnjOFQqFdbW1hiPx6qIMx6Plee13++ruVp6EwdBoFKVZV+EWZ/NZnQ6HXzfp91us7KyQrlcVmNb2nVtbGxQrVbpdDoKJElhbGNjQzG4sr+6rqt2iFIUyOVyPHjwgGazqbzU+/v7vPvuu8oqBBFwFsnxRatIPJhOQJ08XzRNo9PpqLA1CeyyLEsVkA3DYH19ncXFRQW0DMNQ5z2Xy7G5uUk6nWYymaj7vlAoqBZQohRIp9PM53MFkEUKLdJq6UctLL7M6cK4QgTopJ+63F/lcpnxeMwHH3yg2GcBjzs7O1y5coVyucz5+Tm/+Zu/STqdVsyzPI/kPpdgv+XlZZaXl9XnCksu3mNRzIg8XJ7xxWJRqSREki4s8uHhIV/84hf5yle+wje/+U2l1JC5XsanWCS2trZYWVlhZWWFZDJJuVx+yrIloZny3JT7Q/ZNrGJS/I8/z0WhIB51KQDE7z2ZX6WIEg+5dF2XjY0NMpkMjUaDtbU18vm8Avhxv3/cDiefLx0M2u22Kszn83nW19d58ODBH9XU9F/EtoxDmzOmgckKISYt7lFnSoWkBwTwEUnqXo5X/R65tZCcDdMnML4KtaswAZhBJgvl16DyDZ9c38AOQ0LAZECSPpBhgknIBJcEpj6jvulipKN0aMeFyrOwsg39GRiPIfkExicak16G8GRGYhDANCRJlHztpsHv29SW5yysgOdBoEU9kfVk1Ga624DwdoJWQeP4sk3nCxr2tQFeOGE8KHH9foeXdcjcgOE5dJ+k8APIjUPMQ9h4EcbrA5qeRuISaJYJ+iYUb0S9new51K4Q5HT6D79OtfkEPQVnNTjfg/n3k3CQYmLNABsmXaLqQAc8jYLrU/F6YIQcu5EkeKrBMAWuAeHHS/CE1iXfCXluAFkmaOMJMwvOLI1w7tOfgGdAZz2Fv1Dh1B1iBhMKepPKx0F3bg70SzDP+xgTMDRIuR4FH/JjmEwiyXc2Ba00hLPo97MUZBOQ9WCYjK5VNgHFJbCnUDKhYoCnwWINkj58hE5rMU3yfMJzo4DVTIu7ITTLScLxhMwHLlnXJpMJKVhNToa/QXtnDldeYFp+Ds7aNP/Nt1gOFhnp57jZGWkTtDoMzciXndyFjxydvfrrsPwl8PMQhlFRw9aixtnBPAp+MwN8t0QY9tDMEBvQVmAcDMnWYdYCfZbEGjhs9HzeP3zM6Auf4/yrb5L/5m/xIg7hIHr7wIjUAFYGumdRb+7NGwGtn4IfrcBZMkVYyoDvEcxnhER+8HAAiTCSljsulOoQaB5W18DCJ132SO9CcD9A66QgDDGpMQRSWFjoOBkXV9cwRhk8NAJcsnaKYDjGNwE/OvQgC5XnYM0D9wewseaQfXLG27dWKYabfJkkWQ7JkadJgrvlNNZozqJdII2Bh4UfgEkaU9eY6nAS+ow4IccIY1TlD0Lb/KkG3bIAj8uwBTCI1E/8oMK+Sp9p13XJZrMAyr9YrVafCmObTCaqx3Q8AVrAvEikHcdRD01JiwVUixLxkgtQEsm0MEkCjCBaFMg+CKiTRYT0npV9FTZBJJ5xr7OADQEYIpWTNj7ValX195QHfbzgIIxCXKp7Ub4Pn7TwAhSzKgsGuTYCWOMydlmoyTHLArFarZJOp1lYWFCvFwYGUOyFSAovMvsXAZWw8nFWU4Bm3IcsADXem1rYVSloxCXoUjSQhau0oTEMQy2IpPAgYF1YMwE3hUKBhYUFcrkcy8vLanEm5zwOVOX8Skq/yGZlnMh5FgZFlBSWZamkW5GRiu9djlfS6ZPJpJJhxvMH4BMvqPhJ4+qKeFEjfg3i4YDx4pUAMSkAyH0jbHu8qHQxNE2SluPXeTabKRlqXJkS3+L+b3m/z/ombbnK5bLydBeLRZWgDFEidqfTYTKZsLKywtraGrZtK7bL8zxGo5GaL65du8ZoNOLOnTtPdRnIZrOq3R6gAsZknpQxkEwmVT9dUbwIoyisnbBxN27cYDQaqfAs+bt2u029XlftqrLZLNPplNu3b/PKK6/w5ptvsrq6immavP3225ydnaFpmhrjkhKdzWbpdDo8//zzyku7sLDA6uqqAr/yrBBPs7TGCsOQvb09BXrEsy0ebvERy+sHg4HaZ0n/3t/fx3Ec6vU6uq4rb68USCR7RHzji4uLlEoldnZ2nmqjt7e395QKaX19neFwqCTRUnCbz+dKiTUajRSYF6WC4zjkcjlVeJhMJoxGI/XslNyRUqmkGGthq13XVb2h9/b2mM1mLC8vKx+69Nze2tpSFoB0Oq2KIN1ul9XVVVZXVxXw1TSNjY0NXn/9dfL5PM1mUxXiJIRT5oJGo8HJyYnyQnueRzabpVKpMJlM6PV6tNtt9QzK5XJcv36d69evc35+zunpqfIyxxlv6ThSKpUolUoqAE9sBJZlKc+0FFWkkBoH+/FCl1gGZO4Uif5kMlHFA1HEibJOOmKUSiWlDBLVhnj+a7Ua3W5XBcfKWFtdXVVWDAmjk8+6c+cOjuNw48YNVldX6ff7FIvFp2x5n+XtlCkpXHIsYTMmh8kORXJ+j+kBGK7LEx5gzao4v+Wzsthh7QUb24XuOWz60PPBGUftjRLLcO0KjO6PuOP42Fh42giyc7K2z8QPsYMIGei4jMYaTscisH08w8c70zDeCglehEwSnDl4Rzp6UGPW7DA9HWO4YJsaegGuXx0RzifkigEJHfRCxDC3H0O9Atk0NB9AdhrgzwwevKcxeq1G+OYKrBbA3Ob+D37I0tF92lrIfAlSizbTRgmHkNx+lk7Y59lnAx5YIbcXLc4XrsPKizA0QPcjY7uThsIWftVm1DxjkpgxCkKWPoDMkzJ2esxsEUglIqq0WIJmCJMC80Kd5yYn6H3Yq8O1LPRMuJeFxAEs2NCugWO4bHYhP4+84t4Ipnko6DPshsmgVGK4OCEovQLbr9G2n4B/ghacYT05YcvwKYbQDiBYB2MI/TGEaWimYMEHupAvRcHq9REUZ5HvuRNAbgIJB/RclFp/osPKBPKjSGJ95ms8mpVwUxZhyWe6alPoTVichOhJaPjQHurkzmxSezZ6B1YXo9Zzg2NYmA+Yeb/DZOsrkP4zUHSZZO7SYYof5Om1BxjPe2Q2I8Ct+XBX0/lw4yW81//PkN+BZivqH65nwO3CpAmpEjCDszbhcZbzTIGlGwOYR3l2mXpIcgjzQ+gYM7wzqPwnKH/umNG1xwTX3mT//JTN0/dYC0IGHxcmQiequaRNSG1D6mr0UdUqdH0de17FtE7JmVH/9nQiYrvtIaS1qJ93MgOzrg7M8ZMjkhUfMwnzdEiaKb7m44UZqlQZ4zAhwPIsnMIcyxyTmYe4iahoNXah4kFNj/qOTwGnD1kg3YfWAdQCqGHTY8CYNjoeJpssUMSah6TCMy5hYpLlnj5hb8Gi645ha8q1Xbj8zQHN83Wq5Cj2bW7/AeacP9WgO85UCoCLM4VxTyGgeoDKAlQWeAIUJcBMAJGmaQpkyCL9IrMel9DGAVbcvxtnCuLsm4Aoab1zkS0UUBOXGcs+yKJFFidx9jIOuuW95Pjifva4ZzYIng5ri3ve4+yjbBdZwzjTHN/XT/vb+O/jsuM4CyMSOQHncr2ESZBz+2msazxUSIoWF8fNRXVEnFmN79vFY4j/HD/fAoKF4ZZCgrBZccZDroMsmITpljHyae8v1z0OlGXxL+zlRfWFHJfsj1z7uA0hLkWPtyqT8RFn+uP+/fh1k8+Jb7Lf8b+Xz5R/yz0q4y8+li6qEOIFkXhrMbm+8bF30SLwadvF6/lZ3ERKPBwOlU87mUyyvLyMYRgqJXxjY4NsNku73SadTlMul2k0GsxmMwUaIZJq37hxQxUlj4+Pf58vXwpQjuPQbrcVQJCCzfn5uWIKZdydn5+rYqOkNtdqNV544QUajYaarwU8yWfIvHt+fk6/31dJ7VIkWFxcpF6vq97Hm5ubqo2Y+ISr1Srb29tsbW0xn89ptVoKwMi8E+81Lwzn4eEh8AlTKG0Q0+k0/X6fQqHAzs4O+/v7KpyzUqkou4ymaZyenqrCw/LyMkEQ0Gg0lA2qVqvR6XQ4PT2lWCyiaRqrq6ssLCwo8K9pmiqUyPypadpTSfSi5oqDaNn3SqWiWmkOBgOV5G0YBq1WSyWUb21tsb29rQqgrVaLRqOh0t6F6ZfQ0lKpxMLCAqenp0qiLQU2z/Oo1+vkcjk8z6PValEsFlldXVXtwiSg7dKlS8rLLfNdXGEkRTeR81+9epVWq8Xp6amS3ku7S8uylIe73+9z+/ZtvvKVryhvtwSzyVwzmUyUh9swohaTw+FQJeNLqzoBzP1+XxWeZH4cDoeKrZZio8x5ksIehqFSeEh/dmG3JURNnnVi7TEMQ/Wzz2Qyyh++srKiCirixZewNmHze72eyjTwfZ9ms8mNGze4fPkyk8lEqTkePnz4JzBr/fFu7USWDaeNTh+TPFkM6oxZTT/EqMJ506PNPQq6zhOvTLtRJhWeUbbgzAT7fwe1Ahy6EcOcKsCVr4L9ZIT9QcCxrxEUp1hFYO5iD2A8N7AY4QQW7bMyFik0OthMsEcWbcshtxwyXYD8y5Cwfc5bfcwQ0i4YEw3HTeBWZ2y+AcYwYJ4GKw2TMfTOI6+vlY7aQnldaHo+vdCk9I5J8rxP989k8WuLUFphvLDLo8Zj+hkYbBVYOutS7ugYbpVUMKHqDalfD/hOWadhLxK2TOjsgzYDLQ+WEaVqJSqQWKVVzoI3I3cIlQB83SXQNHKZgFHOhHQGehMorMCOj7//iHHzhPwUvGWY5KJ2VAsa+CdRG+y5C0crGp0gRN8Dbx4Fw1Xr4HfAa0xIFzQ6WpLZ6puwsAqtHoRZQs2gs9blwJlwSQ8ZpTTmGhgZ6E9DTC9KVn9iQc6F5DySkreBuQmlCjgZeKxBMID1WfTzmRGloesO7CcMjrZ28bZeB78IMxNat/Abv8t+3qaT1ciPQ+qEFJJgpeD8EszqEDbAHEVp6pt+j0biu/TMK5C5SiY/pWi2aQUZChs+5cswqkHQAnsCe6Uy3qWfBX0nQp1JLaKhgwC8MThPIKzBNAkdB/QJwyuXuFU5oNDo4rRN3ESBdH7G5bUpiVOLxiCLcW/MouFwuHkXvnID5/LneHTygF19jG3AvBgBZ2cI5TVIl6GbBMZQGIJWzEGQIz/2qQbR7ydjmDZhsg/24OO2ZQON4RSCbIfcqh+pPo7BH4UYOCT0ENcfE5JhSgMIsewKnZ5GNjEmcDUGhGQMMIchWhMyE5gXABOySZiNovtm0DLQgxQ3COgyw9EOCFMd/PkCS2GeS+MCIy1FlgkWLQrBkFI3iWcYNDNwPQGXnSUm3GBPa3ElvPtfH+gWhloWFXEvqDB+8pCWRYkkfk6nU7VgkFTrUqmkXp/NZul2uxwdHTEej1XPzYvhYQLMZNEhTKT4AQ3DeCrdOi5vjsvahYkQ1k5YTkAtLgGVuiv7KudA+qzK58RBm+yjAGlJr/U8TzH58jcC4IUdkTAcYZuEDZfPlvMlCypZUMblcPFkcykYxFPBhaENw1CdP5HHCVsqDF0ymVSy9DgwEybWcRy1yBXf7qdJ5OOAK16QKJVKqogj7ISw2cKgCDsngFoWTuJpFZl4Op1W104WXpJiL8yJeDSFwZcFmxRh4uA0DD/xFooE37ZtJaMV1krOp1xT8WfL+BLlhBx33BsujFdcLh9fWIr3Va6r7BOgihtynj7tXF+8BvH9NQxDSYflnhSZ7sVClozr+L0v406OPV7Ekp+FcZX3/SxvlUqFy5cvc3x8zObmJplMhslkwuc+9zlc1+Xu3bvUajW+9rWvMRqNePDgAbVajeeee47RaMTx8bGSXMu4E/ZxOBxSLpdVEJuEsglDKN9Ho5HqPy1S8Ol0yqVLl5TqQzoULC0t4bou4/FYzTMCuGWTjAXxkAvTPJvNVMH04OCA8/NzKpUK3/jGN+h2u1y+fJkvf/nLzGYz9vb2VC9tkS1blsXe3h5Pnjzh5OSEv/AX/gKLi4vcvn2b2WzGc889pxhIaRsm7a8AFcQp42phYYHpdMq3vvUtIHpW9Xo9FhYWKBQKTKdTwjBUfbVFXSL/L/Pr2dmZ8t7LM0rXddVbXcLCROIvai1p7TYcDhVrKvs+HA7VMUvGQ6VSUVkokuot6pxqtcrq6iqZTEYxuYVCQRVfksmkKkLInJTL5ZS/WQCghM41m02uX79OJpPh6OiIVCrFtWvXKBQKar90XWd7e5vLly+r+V3C4iTnRKwG0s4sl8uxuLjI1tYWJycnyibgOA7vvPOOkrUPBgNWV1c5PT1lOByq/IJms6mKTNVqVZ3zIAg4OztTRZV4MUbmLrGiDYdDxZovLS2RSCTY3NxU41Q6eYjUX1hsKaCLGgFgMBio/uOlUonz83MVKCf30nA4VEUhkeKXSiXOzs6o1+uqd/21a9d48uQJyWRSgflKpaLm/LfffpvRaKTG2nQ6pVKp/JHOT/8lbJtOlhe1tzmmzkr4E5Q4Y1L6EZ/bHeMYcLtvsKjBW8aUsTnkvpOlembxfNZl1IHD88iXaphQSMAgB/M3YdEJufYvxpRPYLYMiSDKDZvPM4RkcIg8ty4WIyYskUDXZnQ0B/9IJ/cDn/TnIelCdhlyzw6wARbBdYCxh52De1VYrUC+TZSwZUVq79CCSRsmJhglcMOQ6TBFbpbh0lGL3t1D3n8mCeUa2X97h+Itk5P/psz8Sz/B6ew9irUnaK0OCT0ktRnywzzsmwnS9/qsPjjl6LjL/C/+j7CwCbffgdkjePZFcOZ4ZoWi0+JqK0oLP8/0YZZmmA8h24uixUMTittglbH2/xWlVBTslevBeAHMAqQnUXDc4BjSAwjTIdMiLOhQnoG1BF0Thmew1gmoBfC2UYViOUqTy29EL+738FPrPE4tsh96BNU8oV1AG8wIjSYMT8AKIJNAszoknBHWIMTzoW+BO41Su4eVJLoZMpg76A6kW5AOoJWHw+oC/upzkL4Cw1IUMb96iYkzYGIf002WuHL4kGfw2M8ANpCDw1UoHkLlCDJFuDKDaarFfygeMC3/BDNtiX7ymHR6xpXrIYMCdHzIWLCnpxlsfwl2Pw/TdGSONhfgfABGC8w9CI5g4kLqi1D7Kcj9CBbqDLevMjzZB60EpVV6bo/07/0n3ki5nM83GHqHrA77PGy06Q+bkF/nrLJL9+A9yn2Y1cCvR+Ne+7hpgncCmRyU0mAYgBWQtEOKXtQ+3AjB68PwGE5HOnZYY5EkiUKDjSs+VgrcEaRsolZxmOi+R6BNGIfHpA0b39SY+w45rwbeMgPa2J5Bnwwlrcf5gwHpZ6IiwHAIk1nUOsz2IaEbuEGVFQLKeJybIfXrU/p7x6R7Nd7ihIfhGlnq6DjMmWB4VTTPZ9yC7z3OsD/Y5H76MZO6xqSRis75j7n9qQbdgJKkCtCJh2pdZLrn87nywBmGoUJj4t5EAXrymsFgoJjiuIQv/l0WmNLyRICNsHYX223FWfM4Gy6gIf7eF5nPOKMugPKiR0sYATn+uG9QwKTIQOMMu7A28j7ys4AgAdgXPehxNlI+59M8v/J/FwsDceZUzod8rvw+DgAvsvSyoJlOp0pqDzzVZ/Qi2x7fNzkv4mmOs7zyXvGwsLhnGHiquBCX4wuYlesqi2Nhg0S6GLdECKiIZwTAJ6BRxlN8n8WDGLdAxBlo8ScKWycKD3l9fFwLYIqH0AFP5QbEpfbwdA9y+dv/XNbCf+56yLkV2b68V1zBER/Dov6Qz5ctft/EC1dxX35cQfJZ3mRc7O7uqsLOpUuXqNfr/Pqv/zq2batEb0B9l0KhtLwT1lrG2sLCAs8//zzHx8ccHh4qGTt8kpkg84swo5qmMRqNVC/icrmsQiG3traU/Fv2WWTauVxOtVeSe0c84DJnS8tHuQdFxv3+++8Dn8yzQRDw3HPPsbOzo8KyhI3c29tjb28Pz/M4OTnho48+4vDwkG9+85uKXb9x4waWZamimzD2ruuyvb1NpVJRXu10Os1wOFQeXLlHBLgHQaDAVavV4sMPP2RlZYWFhQUsy1LntNFo0Ol08DyP9fV1xWwKcJfzLV77OHjrdDqK2RaVgShkhsOhkkgLWBQFkfjJpZjreR57e3tUq1Wlkshms2xsbHBwcKDArcjgt7e3VStMKeqJigzg4cOHXL58WSXD7+zsPPX8tSyLF198keeee06BcCloiGVLzqdIwuVayJir1WosLy+rnta9Xo+3335bJb+vr6+rorMUFs7OzlRYZNxPH+8FLgVGue7ir5YiZrfbVay8FJzq9bp6HylSyvmW57XcdzJPSxFVQvlKpZKyiUgxStYpYkeToqsoGBzHYW9vT7Wm29jYUHN+t9tVRU5h+ieTCefn51SrVVXc/qxvHcAIi1xBJ80+Ob3Bpa0x9QX49dsmR4NVdkOdotsG3aWIjlb0MDYgm4X5ERRqEdF72IKxGQG09HPw7M9D5dtwaMF4CkGTKAiKNGBikyRkhkeCGSW00GOEx2CcJ/fhOdW1EDMFWge2VqC6DfcK4AdJUqZNzoewAKMroE0h04FkDZJpmJxF4NsogbkOuSpU783xplUc08Is+JAxSN78Aa/dPWI8yTLWixDmcJ57lUc7GgX7kCDtsB+YnAwLsD9i69Gccg8GfpP5R+/A4Rnav/sARg/hv32X8MYCJPKEwwy6PsVOQ2rLYzIfMbtUgkoVMiaQhZMcTEYkvAGpBAQW1DWYOjC1wA2j/s9eCpwzyHwAi8tQvwL4cKBFCvX5Eeh7cHgF5htm1L8qexUKizDrAhkINwnLL+MVypEcwSsQjgxon4N7D9IzmGcIz+/gWt+lmuiTGABzSJkw8GA0DMEPcfSI5PdMOMrCMJHD94qw14HSPGoy3rKgtgLrr8Fhi1CzOChl8RsDuiVIb0PYjZLH0wGkOybJjEe+B7kPYaH2bfYXXsN/5nPQfJvLlZBOAZ5kwNVhYFm0XvwiPPvnwMlD0oBcFpoOaCkwpmCcRYl883TU703bgOUa8ADcJlRXYTkV9f0afI69a0kyH/7P7IybFCtzlj4XuQEYANkQt1ah78PyJMoM8Myo7fp8AkEHnHak9ignoEqXaTmF74JpASmw7EjS353AXAtJhDZjw2Zx16P2fCQ7d4KoHpPQYdjy8LUQ0/dJzFKAhbHkkGKEde7gzAtMyeOj0dUGlNJjSlq0P+ku8DjKW/DtyCLg+DoTqgRkMTmgnGzjGPDIKZDmJTbN77Gdv4veL2KGlwg5oasZ1Kwmqzo8alp8YHkUnFNKjQqnZvG/TtAtgDOVSqnFTNzPKwt5+IQlHgwG+L5Pr9dTgFReI347ASHj8RjDMFTlXz7jIpssTPVwOFTAJg60gafAv7CawhaIH0yY3TgYjLO6cW+07/uKdRYQJyyEAEEB2JKILovo8XisCgqyKBWGGVAVeWnfI0y3LCwFUIlkP87kC8gU5jveS1U2WZjHWcd0Os14PEbTNPVdWNxut6taCMnCTBa4Am4FLMviLX794/Jo+AQcAE+1XZFFj6Qsi7RP/OMCEmU/4jJmAXPwiQUgXoio1WqK5S6Xy2SzWcrl8u9r6RU/Xjk3ssiKS7Xluol0WDyl8nnlcvmpRHRZcEuCvVwHSZKHT4pYpVJJpZhLAUTeX65bnGmOF1ouBr5dtE1clH4L2AdUqJL4fy+C/TgIj9sS5JxLUSYubZcxL4WZuBT/s7wtLy+rMbSwsKCUKicnJ/T7fRYWFtB1nffff590Os3q6ir1el3dk8PhUNlsxKYg561SqRAEgQKWkhchklspMonCIp1OU6lUVK6AzIFyv6ysrADQ6XTo9XoMBgMKhQLb29sq3EvmK4gC4kSOLEyfeGhd1+W3f/u3Fdv37LPP8swzz6BpGtvb208VxobDocrFePToEbPZjJ2dHSaTCd/61rdotVqqndLa2hqrq6u4rqtaYBWLRRXWtri4qObzSqXCbDZjaWlJ+bTlXhFGOZPJcOnSJdrttpL6NhoNnn32WdLpNLdv3+bk5ETda6IKEFB1584dldIu87zkQ0iYlqi5ZO4+ODhQ4Xq+7z+VfyKqHJFpV6tV+v0+w+GQdrvN6ekpBwcH7O7ucunSJeUXbzabqkOHqCJGo5GSJ9frdSWBFgXYe++9RyqVYmNjg62tLWWzSaVSXLlyhY2NDVWEuRi6KfPh/v4+N2/e5OTkhEQiwSuvvKLGtGma3L9/n2w2S71e59VXXyWdTvONb3yDra0tlaci2RfSE1wUB3K9pJguBZrHjx+rnt+VSkX5pkVpIPNWrVZ76lkoKoF42KmMfXk21mo15aWWv5MWaPKsd12XdrutnsGS/C7FZhlfi4uLnJ2dqWebKAcuKjF2d3dZWVnhyZMnah9EOi/78FneyqwzJEOax9QJSOoTsiacPtLpHS+yGZYpMOR9AtJBkVXTpb4U4oaRcnd8C4orYJfggKiXshlAD7j8Aiz3YPgIvADyRUiNp4ynCSCHi0WKNAmGzLHJkKQaZmgTENoh9hjCBfC1KExstQLLwFEHit2AwhAoQGYXiiPgIAoHD33A0WjpOivLPqklaMzBHMzJ7reYJ10mekDx3z9m5zsmJd1n/38Ywssl0DTYeo2J/gaT8D5n3CEcpmESkLZ/SHC/Qz8N7vYUJt+Cbxms/7BA0QwYfXifw7UZwcpLDJ0J9+oP2Al9VvtwzzEINrZh4QUYZaAfQi4N7hO8pTHftqFuwqoG5xYMTY3yLCSZAe8ZCNrwvA+lA/i9FZOj57IY3oTyLY/kzQpT12NcGBI8aEPu+6CvgLaNdq+JNTjAZYQVPCFlTwlyFpPlVcLVF6CWhCANiS9ArwiJV/AHz3MW/juS5gFWAMWESxAGGPOQSuiw5ETJ4cOr0Kok8QZFtGEbq32OdbqHm7uEU/4p4FkIbkDyLlrrPQqjIXkLCgYkEhD0YHAT0k2DYpAk0w4YFAOSY3hVbzA/+rvMskV2MiHrabi9Hp06O6nRv7JNuPEWZK/ANAO2BziABqkQbBfsGRw04Z0u6SffwspOmL6YByCFAAEAAElEQVS+jLcwB+0Y0wrhQQ4v8ywsZAlee5UPMxMG/+9v8cX6nIc3NHpmFoIZpAPCWYLpHKZL4NUiX7dJlNE2aELq4wy3zh1YsV1mC0eMqhq3sxpLRki/DqlL4L1jkgpCagsDKIC3Aec1KBUg8SRq8UUZtLUQ3wEG4M91dEOjpkcZcZO8jefNCL1VHM5J6VN8P0l2OMXdg44bhRBqiaj13WRsMNdcpgwww2uYnLOYtTk7BneWx0WjHdTYsc9wwhkeM95gwPP+EXqpyXIWPtBDDFtnkTpz0ydM9aKB8GNuf6pBd3yBLxXjuP86Ll8VkKvrupKwikxNPGwSdiYP0Pl8Tj6fVxI6kcDGAVecJZT+ngLU5YEslWwB0gL0hZ2JgwpZYAk4uQi6hRWMs9OpVIp8Pk+pVCKXy6kFsbyXMFatVksBfPmSar34j+NyffiE/crlck8FbsnnCyC76KuNy4BlAXOR/ZRrJccr+2ZZlkqFFVm3SO2kyCAMrlyPT2P9BWDKuYwD7vgmzBCgQsjEEiDnRd5LmKH48cbHWhz0XvTOl8tl5RGU4CX5HAGKMo6k3Y4swGTBFmf3Zd9kvMrCUD4/m80qKX9cUSGvjXu1RWYqSgRh6+LHKQyM7Kt8zkUv+sUxK19xoHzxPpbFvkiU45L3eJHpIkMu+xBXkchr4wBdCgWiJPisA26AjY0Ner0et2/fJp/Pc+3aNXzfZ39/n/X1dVZWVnj06JHyMK+srCj2LwgCVQjMZDKKmZbxd3p6+tQYF1tIXAUSV8OIdaRUKimQJ9JoGSulUonJZEK321Xz12QyUT5sYZkFNMSZXQGPrutyfHys7qtkMsnnP/95yuWyKjS5rqusP7Jf165dYzwec35+zvr6OvV6nb29Pc7Pz5+yIYRhSDqdplQqKUuRADt5DsWVTevr66TTaY6Ojmg0Guqc+H6UoL60tMT5+bm6r+LnvtFoAKh7//79+ywsLHDjxg0lkxe5tNiBSqXS73sGyvjf3t7m+vXrPHjwQLGwUkTr9/vs7+/TbrdVsVnUDtK7+fz8XM3H0tKxXq8ribMUGBuNhioynp2dcXp6yvLysnrWxVt2ilVBJN7pdJr19XU11oSplmssrPVwOOS73/0ud+7cwbKi1pL7+/uqYCpM++LiIisrKwwGA3Z2dvjpn/5pptMp9Xr9qSL1eDym0+kQBIGSpEsOgbSCq9VqzGYznjx5wtnZGS+88AKXLl1S9oDxeMzh4aHy6UuBZDKZqEBVGcNiI5O1SSqVUi1LpcAqCj7xmj969Ijl5WWy2Sz9fl/Nh2IJkjEv94jYgMRCJgUYQKkLxCIlBeb9/X1VJBkOh38Ms9Sf7PYzWMwpcZssBUKupmy8ps7+yRKb6Tlr1iPuD9Y5YYsVhqz4Gu6pRd/3CQON+aHPbAxOBTZKkKxAS4dzE45OIHcDjDaY70JqBJlAQ6OARxkDAxMXkyE6AQEpkiQpaVNCHebtKME7mf9YwpuAlRJUx3NqPcj70PWigC/rDJxRlCbtOeBnQup1n1QtkvuOPeguQiYYQg8yv6fzwhTCZMgHX4CzLxahtAmpdSADbhJyrxIaNyCcQPqE2TWd/dEHJJpnzNbXoXYF9o6w63t0TZ+OdpWAPwMUId1nUDpmNB6hAYNsAWrXwViHRBKqBpQ1cIeM15OM0gl6RzbJxoSEQcQme1Ha+GDJoHbuszgGy4eJb2CHFay5h3cQkJlnmZttEi1I+WOmC03YKYIzIXHwI9abHYaDDuU0eJ6GXQTbPcAN50AqotODIQxSkL8OuS/gOzmm2duwlGUQpMHuQG+f4cEHpFpj0gGsjMHLurSmkB1NeCaYYdzuceYfcvjFFt7afw/jLch/GXP0iCt2F8eIijP5BlyaQGkEZ2ONUxyWZyFeGB1zugdfHTUJak1qz0BnCo8Ng1Y5i5cuEa59DdIvg12OmrlPB4AXJcy1+hDcRRv9iMp3jkh+1yc/Msiuzhkv3mcvUSTIW1zttDDGBh8u7RCsAsMO4c7zHP2lKf9xdotxfRc7tQuZChSqaGMXewRnIZgdyDjANGKoB6eQSUFtHWZTSH4PNhYC7ryZ49GlIt1pi3Haof4CFN/xmR+CW4VcHjDAH0FvH7wDsIbg6TBLg+9HifSaOSHlwuAMnFDDdhM4fhadLilmpP1tXD/Ho84HLJ3MyepR0J4PhDpMgjROmCSrNbHCIS4FPEtjMjYIggQhx/SDAufTKjksoMclppiFA/Qv2HgOOGENJ53lsd7GeSYHfg5u/vhzzh856P57f+/v8cu//Mv84i/+Iv/wH/5DIAKzf/Nv/k1+7dd+Ddu2eeutt/jVX/1VFhcXf6z3FsZWHjTx5GlJ1hW/nzxcZBEprEAcbImPLr5YFymf9FGeTqeKLYvLhwVYCOsn4AlQ+xUHIvKz7G8cQMS/5HeymBNfmSyCRVaYy+XUIlSCcgTQSggZoBZH0rNZwr/EgywLU0DJkUX6KZLDeEscYZjiievyuYA6J7LAjRcNgKcAuTCycZZaqviy2JNzK4UTKVbYtq1YUul1K58TT9cWYB4vlsi4mM/nKnxHzptcYwHectxxBltAZpxNTiaTqkAh35eWltTCUs6jyLvlWsuiSxaW0mNYPlfGgbArct3i6ekydmQsxpP2L6opZCEs8nk5HkndFWAfL3CI2kPGcZyxEcAQt3fAJ97IuApFiiFxWbtIy+PXOv4eojL4NGuCfF68CBAH/fHwPQFp0hP3s7hJiBPAnTt31DWcz+e8+uqrNBoN9vb2FHA9ODig2WxSLBZZXFxkcXFRJVzHFQqGYah5SCSu0nXgyZMnCmDEx+h0OqXX66nXyLwtICIOsCSdX9j2ZrOJ4zjs7OyQzWZVGy+ZG3K5nAqxEjl0uVzmpZdeYnd3l3K5rOZ/QOU0xFsmir+70+mQSCQoFAqUy2V2d3exbZuf+ImfYGdnR0m0U6mU6tsseRoypkS2K0VKeQY9evSI+XzOxsaGAnBra2vAJ88fXde5c+eOum6iWsrn82SzWdbW1shkMuzt7SmFkyi2pHezeLQ7nQ4ffvghd+7codlssr6+zvPPP0+hUKBQKKhnncwrtVpNydblGGT+Ms2otVWr1eLOnTuKkZYxJcdTLpdVOJ7M09IKTu5VyRXRtKiDx2g0Ynt7W6kqarUapVKJwWCgZNjC2Mrz991331W904fDIel0WiWDS+9227Zpt9ssLi6qRHr5nCAI6Ha7zGYzNcd6nsfZ2Rndbpf19XW1r6lUSrVgk/CyyWTCu+++y+7urjpnpVKJtbU15cOXayrPriAIVNBaLpdT56NcLhOGkb9f16N+5jLHx+e34XBItVqlWCwyHA6fSpqXY5cCgFz/4XBIGIZ0u116vR5XrlxR7fAgUpi8//776LrOycmJmiNlHz/rW5D/f6KFBcJxnTt0MX0P46jGfHHIqy+OOb2VZG8wo2hM8H2dJ+EmZ4N1ypywyJDFj8bYt8G1oBTAClFP6bkO7TycXYW8CeUBVA4h3fF5fOIy9DN4TLCwSZLCZMoMnz466bCGPRwxHk0wOrBUhdwyTHNQT8HyMGSagWQANRvoQ/sAHA+2r0FmDLYFVQvGA/CTsD2L0q5txyDVr2IX54xfH9L6ks7plR388ldAXwMvA1oSkkRG2FQOcinw8pB7AXv5p7E7TUhsQn4NSnuc734zYlVf/e9gfReGN8F6QJAscpIb06xrzJM7kP0K+Dtg2GDo0JtBwiTIbYCXZTprMPjwMQs9yD0fYtTh0azGdHWHBHeY5ccYSXi+bZO6s08ziKzYeYZ4aRd7DfxsCdZ+EpJ1OHlAkLSZZyIredeDTqVCaIWEwQaU34TuHokPv0vq1r8jPNaYXrmK/9wNKHlQnIKZiaQGxgQsl2ktz37BJjN1ec6AtWlAN5nByHvsjmd0zk1aXZPVwm3Okx7zpf8LzBdwjRV61UOa85BuKUsuMUEPIJ2Cwvs+vZ7GdDEkSINvgpUFYw5rALvwzbHO0c42FK5B+CrkvwbWKvSH0BpB4EcNu7sT0PcxJr/D6s2HVA8iXD60XNwK+FZIat5ntQO739exQzh95oe0l67DyiUYNgl3nqOTfwGCBejuw2wOPQ9j3iEcQOuehTl1yV2HURCpMaw5TB5BIg2ZGoz2oXgM1XDG8ZVLtAtlOtMO5UqHn3rTwapANxPJzYuHwGOwz6MMuEkyIu5zaQg8IIRyPiCcQntWQqdAhjEmfayEg4+O7xQJ8RnqLtUgKgqMJpCbg+6C7pmYYY55OGdGn5Q2gWRAp1egQYosXbq49ChyhTXyLOFRRUufs7I14/0faGS8MpZ1il02SHVy1Np9jv8Ac84fKeh+5513+Cf/5J/w/PPPP/X7v/E3/gb//t//e/71v/7XFItF/vpf/+v83M/9HL/3e7/3Y72/MILCYgu4kwCmOOiWv5EgGOlFKiBUJIrx9xDQ7fu+Wlz1ej31UBLm/CIbCJ/IduNSxjgLLD/L38aZwzjglt/FU3Kz2aySKNfrdYrFogLbEuQVl7YJOytgWdej/t6j0UgtjoUxFdZUPlce7LJIi4Nkkb7JYjEu444fs7CqcS+wADwBcbKQjTNBwghMp1PVMkVAsFxTSeQV0B0vYMh5ju+PfF6cDRVpnownWezI4lsKARe97PHzFPeiC/AWYLKwsEA2m2VxcVHJyeXz4+dJ9lXYlW63q9glOXcSvieARmS7Yi8QtYYoKgS8xBmUuKIiXrSIFyakGCXXJM5cxhPQZZwLyyiqgTjovshEx8e7XAP5fBmfcV+3vO7ifROX48dBt1xnuSfl33Hgnc/nP/Oebtu2efnll5nNZty8eZMHDx7Q7XZ56aWX6Ha73Lx5k5WVFXRd59vf/raaE6XNkgBGYZuFiRZPdhiGLC0tKdnrxsaGkkULyybnXECZjOH5fM7i4qIaHzI3yTwmYE3TNJaWlpT8Wfp3CysoTJ+AXNd1uX79Ol/60pdYXFxUgFH+VtjvMAyfCmWU4pWEw9m2zebmJgsLCwRBoOTkMv7jbQ0rlQrlcvmpsShgS6S94n/3fZ9isaiCzQR0aZrG4eGhAmoCJB3HoVAocOXKFXZ2dnj99dfVPLixsfHUvQmoeSeXy3F+fk6n01EtpE5PTxmPx8oDLwopYWZN02RpaYnd3V1VtMtms5yfn3Pnzh3G4zH5fJ4wDDk5OaHb7fLiiy+Sy+VUkW4ymWCaJtVqlcFgQBAEbG9vq3kWUABf16M2abu7u6pFoVxfCcqT8RLPYdjb2+P+/fucnp5SKBSo1+tsbW2pNmyimJnNZrTbbR4+fMjW1hbFYpHRaMTp6SmNRkMVI3u9nhoXovwqFAqKMZYvsUSIJH02m/Hee++pYMJutwugALU8Y+V5IGsG8aDretRHO5VK4fu+KnINBgMMI+rckclkVMGiWq2qZ5M8Q0ajkVJuiKe7XC4ra5O0GRVf+sHBgQpGlZZtJycnak4VKfzKygqnp6d/ArPWH+82Lw145Zk+0/e6/Nb5ZR7ONrC0c9663KI7gXfbWVb0Fnpiym8HaXpBi0XXYJEZU2xybXDfgdEYjDXwVuHYjxK4/TJMQvBWoPY/wOIpbDyE9O+cc+tBnh4pPObo2gDTmFP10swZ4ZHHGlWYn81Z3PAJilFwlZ6AggvlFJyl4dEENgaw7IFfgrkPUxOCbSi2YPIEHAOofezBfWyS6FaYlB3mPz2i+2dSdJaeI8h9AczLEWoPZ1Hz6mQGwnnkFXYt0HJg5SD1LOQtcBwY+FB7Dr60FVGSyWUYAmTAqkFmm8nCDIwyZH4O7GejCHACMB2wvCh6fJIAvYh+9JDZB1nmXsj21pR5BgzLRgvGaKWQXADOfgTIdhMhhUHUlnqWHzNfDRhczWLv/BS8+t/C0Ac9j7vxOj2zS16bMjQ1EozIJnx6OZcgV4bmPZY6Z1hnAdO+TvmjD5j37xLUdDTbIMhY5Is+1mRO6IR4Vsh4OWS8q/FIMyhaPsnsKePzLG/vJainXQqGT/Y8pH58j1vdf4u7+zNoOZNwprEUhlSmEy6ZUFiA0wQ4xZBtG9waHFagloJyGew1ODLgXl/j4e4iFJ4B/2fBfAHGOQgmMBxHfgLdhN4csmOY/4jVJ3sUb8J5K0p5r9RBuwy9LKw8gcun4D5MM3dSrGhdOpvfJtzcgtIyDAMY99Eav0XSfg8nqBJ0z9GNU0wLLC9JaLl4RZh7UW94ayUCuvM5aAEEdcgcwOaeT/fdfeafq0Ym8C44WSjvgN8E5xRGHbBKkFgDu6NhtwoMgwnJrIfe1cjpIalSVDxaPE8yCyoMmGGQxiEgY7lMnT4BOlXdx8xCmALrCMw5DOfgamNyuQkT2yJwoJwakcyD2fQo0qXKBIcqQzTuYJPF4zXyFLppujfhZM8iG07Ymg7ouhmueSNq2n9hoHs8HvOX/tJf4p/+03/K3/k7f0f9fjAY8M/+2T/jX/7Lf8lXv/pVAP75P//nXL9+nR/84Ae8/vrr/6s/Q6SiwkICT3l8RVIsIVyAYvzCMKTf76tFl1SyBfwJcBUGplarqaq6gDxJoAWeqjhfDPmKA7E4YJP/lyCW+O8FNMvfC3sqjLaA7kKhoGTE8VZfcb+5gB4Ba8Ioit8yzowKWyNMphyPMLMCmuL+5riMP57mHfe7C7CSxZP44+Nt2orFIpVKRR2r+IjDMFSyyVKppEKVZPF+8XPjoEyuuSyY4wA57mf/NEAniy3Z4kUT+S4Fh7i0Xc6jeDBF9i8LrHixRfZPwKoAiIv9sOP7IudOjkX+T9gaOV4pPMl7CXMUT/YXpivuyQaU3FsAvxyTgHfxWcbPmexrnEmXcRSXnMvxyrHItbkogf8037xscSWJvE98YR6/rhfPl9zTn3XQfXJywubmJru7u9y/fx+IVDeNRoNCoaA83x9++KG6tmdnZ4RhSKFQ4OjoSIEzYbt1PerfLPdlIpFgeXlZKQYkHEskwXLOpd2WyLXFZyw+Xrn/hKkVH6vruup+F8uOKFoA1StaikzXrl3ja1/7GsViUfV+ly+5L4bDoZLCy/tIK6V4gKOEnpVKJbUvhUKBXq9HtVpVYHljY+OpYqMoqyR8S54bqVRKJY6vrKywuLhIr9ej1+txfn6uQsmEfTcMg83NTdbX16nVarz44ouqh3IymeTs7EztYxiGyt+dTCZpt9vKUiFSfF3/pM95uVxW3vl+v6+KDs1mE8uy2N3dVQURUQ3cuXOH6XSqzpWob5LJpPLby/y1tLSEYRjqs0R9Jl0XpBD7zDPPcOXKld8HKmXfJXFfinDn5+eKkRWVl+RO3Llzh8lkojJZpPOGpMyXy2XOzs548OCBaqOXzWaVtFyk38LyVyoVBoOBAsGS7SFBd5qmcefOHaUGOT09VTkdYnWTYoY8B1OpFI1Gg+PjY9bW1lRGisxPMheKDU6eL4AqgMu8NRqNVFFGikCe51EoFEilUrz44ou4rqsS1QX0z+dzjo6OFNEgAWtiS6tUKiSTSWWf+CxvpyeLtBfOubI75qa7R79/lVSQo/H9JQqBx7I2xA4svudu8uRyBsYznOMmBhp5Shw7PbyGR8qJ5OChHsm5sy5MU1E/5UkSmuvQKcL2Dlw2PM4b+wxHq/iAnpuhL7kkeg5l4Nye4Y3y5PqQsCFdiHpDT4wI01YScCWAdgo6XchpUL8KhQGMkhFZbQwjxh0fenswHYPWyWInHdp/rk//JwtMSm9C7vUITFte1PorKEMYwGgK6RxomSiFStPB1qPqAkkwdZh5MHUhlYblYkR7DpxIps4cKnko1SB4FvQvR82uJx7kiJLI0imYTGFyDikLszsj53j0Q49pG+rL8PziiEfdO6R60L4P5/fAX4z6YlsD0Aqw90WLycYKVD4P1//3YFUhM4erCeifMnFOmVgOhB5ar0NAQJBIQKcJs2t0vdssXd6jsBKQP4PRvsd4H8q2ybw+Y74Ko65G2Q4pOjA91bCtbeaXX6cf3qGm3WZezvPw1a/yKNcknW9QTQzIDHxwbbTUu6yGH7DaDxgBw4nG3anGs0sBQwPal+DypZBuEUbApgF2EfpJaIYat5/ZIrjyBjhfhdlLgAVjH0Y24MFKBlpj8GxIPyFx+AMuP7GZzIE65AxolTV6po75gU9+DzpDCL0ZWctFmwaY8xPc5mMoX4fz90k/+B65YY9E1uc8O8SYnLDVnpIrgLM4JqFHknCnHiWSe4eQ8sHMRbthpaK6gNGHGz8coE8H6B2YnUYFqdwUUmfgu5GU3LQgWAPPDEkd+pxNk7y/Z7BGkYo5ImXOsEzQck3CyQTDX8dgialzh4QzQKcODMllwChCkAOqMNKjRPSC7pEyYGGax6NDIdkh5cIL2TE3MmOGoySNaR4HgyM8RszJM+OKmyVx12AjcNDpUOEygT+jsn4XrWrDez/+nPNHBrr/2l/7a/zsz/4sP/mTP/kU6L558yau6/KTP/mT6nfXrl1jY2OD73//+58KuuVhIZt4jQT0ykMtzgjLolv8bPEgLWF4xUslUkORlxcKBcVGiHdNKs4ieZTkc2H34iBBWNE4gxsP/pKHqwAZaS0l7yHpqXJMAhJSqRTlclm1lpFgrrj3VgCLHG+c+ZMHu/QAlfNwERwJEIsDdZEuX2wHJQtZWZQKI3ARdPu+r0ChgK90Ok0+n6darbK0tEQul1MBNCITjvviwzCkXC4r+WkYhqqvr4BBQC1CLzLuF8Gx7KOcd+Apv72MPfmbOJCT8yxjTc6HFD/EvypMjBRHUqmUAqWySSFoMpkwHA7V+IpLweMAXMaXLIqFqZaMArlGcr5ljEoPY2HTL1od4qqMuFIkXmiIyx3joCoO8gWUyxY/R/FF48X3iBcs4in5cTVJ/HXCrsWLB/FrHlcUyDWJWwHiBZXP4vb++++rpOif+ZmfIZVKcXx8rFoLVSoVbt++jeu6agEfD+uS1lpXr15VklwBWsL2xVUiImu9dOkSZ2dnTxWOhJ0TllWuqzCnMsZkzMq8JIBN2iqNRiPVrktYSrFrzOdznnvuOcrlsgJjcQZTAKL8XpRKolySgl6321WWGgm2krEvBYA4gwmoIqbMFQIcpU+6tHoqFotKii6/n06nnJycKHAnPaolHEwk8uKzFSY1CAJWV1e5fv06gGoPJkqAXC7H9evXuXv3riqQiQVJ8iEsy1IqhFKpxNLSEpcvX2ZpaUn12JYQtq985SuKPXZdl3K5rHp7y+tFKTYYDJhOp+RyOdrttpLwC2tt2zb1ep319XWlKAOUwkhaWoqCSsaApLrP53PK5TLVapVcLker1eLw8FA9TxKJhOozv7a2huu6fOc73+HevXuMRiPFMu/u7irALIF34qdPpVLqmS/P52KxqI43DKP+2hIYJ68B1LN5NBqpZ7o8f6VjhSTRS4FFGOh4e0cB1RJsKc8tGcNiqxOAHJ+jRTVw9+5ddQ6Hw6HKI5Bn1draGpPJhPv377O5ucmVK1d47733nlpzfVa37wUWN28v8mJ+wH93eUjKeZfjx3lcR2M5N6MSONzuG4R+SO5kgB16oBfIBFVMSjzun9F5cMDVy3PyG6ANQbsP6SwslKN+xr05+A40HLiTgUuvws69OWff7TCfX8KdDbH8LsEyWG4UkuaOh5h6iJ6BQg7GQEODUx3Gs0j9vDKHRgC9ClR9oiTlLBQH0HwM8yH4U+hNIe0bZMIEraU+3ectZpXrkHsB0iEYI0iUwDWjqPBEOpKXm2YUyKXrYCZgnoJsGcI0NLuQ0KCaj8BffxJVHJIhhEWwPge1GiSfA38bGgkInSjZampHrKcNBD7JaQtnaOHn85iFIZtDg0wWjCT0hlBOw0obOrehY4HVA+cYigU4LVtMXvkybP8ZcK5DIh9JrlO5SG4dJmDl83D9OtAnHB7imKsfU6BHkEsxvv4SR3d1TKdDcmlMveaRC+F4FjBJZDGtGcmFkMEM3Dz014qEl38SCq/gDyzGowfkEx3G5SeEX1lg+upVph0nStUrpygMvs36rM+DmUmzlGFu5QkNk+ngiNo0oFaAswk4fXh2CgsGtDJw39Zo1NYI1l4H5zUY7Ubx4FYQHZc7iI5xpEXJYeUZTO9QHjfomdDIaVTK0K3qHORLeE2HykcT/BmkMwFWIaC56PFkaRV39UXwGui/+yPK925RGY0wdGjlNbzLJQqTIaX9EMcFcxG8BoSAmQWGEOxbTO0Qa9kjvwzGDBwXgscQvJcgce5ACIOGTjMRkqiE1LagaMLoQfT33hFYCdDKY5KeRqIAw5MxaTdHYWBj5AI8LSSrT0j4U2wmTAlwMcnjUtLmEXttRLL0VB30ZFQcsOYwPrXAN9ATBwTZOf4oukfNHNy9b+KQxGfKzJrQq5W50/Sp+1dJDSesXTpkku9z//yEzRtdrnzB5offsviDxJf/kYDuX/u1X+Pdd9/lnXfe+X3/d3Z2piRP8U3SNj9t+7t/9+/yt//23/7U/4uDAPiE6ZbvAnCFGYuDsHg/YlmQxRNYNU1TDIsAM/E5ycJH0nLj3lxZQMal4hcZVVlofpqU/OK/46BEFpgCwuO+a/m7i4ysgBX5LsctbI4whHEwKp8b9xDLQvXTmG0BhP859lAAfFzCX6lUFGMfl8RJ+JswssKaynkTwC2FAlnsyrUREPhpMnc5HlFBxAGtgNi4T1vAnLxHvBASzxCQ1wh7L1/xtmCfZisQWbbIKUejkWKXpfAgC1U5Xrku8r6y0BJ5/Xw+fwpsy2svsufxsRaX5cd/lmOPjyP5//gWB+1yDeOqiIs5BvK3cp/K+ZJjki8Ze/Iecs3i1y5+DS9e8ziLHt/3/xr6dAuQ3t/fp1ar8bM/+7Ps7u6q3tKmafLCCy+wuLjI8fExnuep/sbikT49PWU6nTIYDJTsv16vK5l03HIiLNvS0hLr6+scHR2pe1iKl5KAPxqNVG9lYQN1PWo9NZvNGI1GCuSbpqkKASIJnk6nZDIZFTiVyWRYXV19quuAFCvjhRth0eU+F+uNgFjx3wqgkflO/jburxbg7/u+CpeUgDS5n/f29hgOh0q147ouCwsLSk1VKpVUjsTKyoqS4K+srLCyssL169dZW1sjm80yHA6VKuvhw4e0Wi02NjaoVCr0ej1SqZSyC/R6PZrNJpqm8fnPf17NZScnJxwfH1Or1ZTH2PM8KpUKV69eZWFhgWKxyMnJiWojJaFiAv5EteD7UZ9o13XZ3NwEPgF9x8eR8M62bfb29tRcKfaEra0tLl++rOTwUmQDFItuWRb9fl9ZfgaDAYeHh5ydnal92dnZ4cGDB+zt7T1lgTIMg5dffpmXX34ZTdN49913uX//PpPJhF6vRz6fVwVgub5xq0P8HpAxXCgUyGQyyk4h98VoNKJYLLK8vKzmcxnn3W5XPXfEOrC4uEipVFLBarZtqzR7eSbLmI4/syTBXALupEglhXHpMy72uk6no1QXMkYgKs7I+RQlyfPPP08ul2N9fZ3xeEyj0VABep/lrWXNSVQ8vtW5QvZOh7/4xRMuP9ujNQTqETZ74QdTFg7POKl4eJd9Tm4l0doZ+vg8CUtYA53Z4wcMMz56A5wu1BdgpRJJen0LbBMsDQYu3F+ES1+Atbsjjk9GuF6O+dGAsORjFSClQRCmGDku9ZRHtgT9IJKOOzpMipEKnBEQgOZE/m6vBN0EZAbAvs50nCKNiav5GKFJRg9I7nho+RywBdkKGC6ki2Bkot7Wuh8hlmQSNMAgAtxeFuZJmAQwmcDEhurHoLxjQ96LwGAiFQFrtwjWM+DMIgbc9COgOA4iOXSQhWAKnk99zyU/eMiekePujQS7XYfqGrRSMElBqQReJUq5DgvQmZnUpz765ZDhxjVY+z/AeBfKWUgOoxZX9hi670H3CNafg+IGDMaQKsHyM9DOwvA70P1XoGWwP/9FbG3IJGhgnzwmcTKjX1sn4Xe4MpmQ8qLixuiqhr+wDsVV6N2E07eZTwPWbZc1+wF+4SHjss7MKuOXUnhBn53BmDNP43DjOqGWjKTggcn8uEWaKboDJx9CopEmo3k0dl3uL+oc7m7B7svAn4XT62AnoqbwaYBeJPG3LGj2wR5BZo9E+wfU96ccN3ValRJnpQW4tIl+/4DV9x+Q1wKsJOhFON3V+ejFNwle/gugtbHe+/9w/d5DiqOQ1hAqabAdnc7ly7jhEWbimGk+ym3TDNAzUDmJlPz76y7GHhSaoF8FtwzVdDReBx9ZjPZNStemLC8FhCcmrueRqkAQQNeKFB3mHGY9SAxhsRJSMmGuu1j6GDsMmc2iIELfM3CYoNMng0aCLKbWxywO8S3IFiFTgNkYjBT0E5A4hlJg0DQHFLIORhKcEnROk8zOkuiTBDkWuEubTm0AqRH5MKRHDsddIZU85fmfccmdHrK+AuMzOLlTB358C84fOug+OjriF3/xF/nt3/7tp0K5/rdsv/zLv8wv/dIvqZ+HwyHr6+sATy3uZQEfl/wKOyoLOJFbSWKzMOGyIIwnoAvbIosjy7KUVK/f75NOp+n1eoo1j4OS+EJPFv1x4CWMiCxYgd/3XTYB/5lMhlKpRLVapVQqUSwWlbQcngZCF8F2HBTJ8UtAmXh+5TME6BmGoc6JsIRyzuIBXNIfW4DiRQAn+yGstbBQi4uL1Go1JZeXRa4sGCRQTAoiskCOS6jjoU65XO4p6XscgMWviQBRGQPiGxcGVK6XsCxxkCrfZYzJeRDwL23XRC5fKBRU0F38vMQB5HQ6pdlsMhgMaDQaKu1Wguou+scB5T+V/fU8TzFQEvR3EeiKtFDAQZzZjp8nOX9ynkQKLudQijwXi0ZyfmXxHGfmL37F3088lKlUSkklZcEp4EQ28USKskGYVgEG8flAPjt+38mcIT7Wz/ImLLGEpH344YfkcjmVZv75z39esa9XrlwhkUjwwQcf0Gg0SCaTPHnyhMlkQrvdVmN0dXWVbDbLgwcPVJssUf0kk0mVyi/ts7rdrlIMSYiU2ChOTk7Y3t5WwZYyR4rXON5dIZ1O02q1ODs7U8yzruuKzUun09TrdWWFEeuJzBvy3lJkFBZV7nFN0+j3+4RhqGS85+fndLtdNb7Evz6ZTNQ9Fy/eSPcKCQFrt9uqkKxpmkq6dl1XyZDH47FSwwRBoJjUhYUFrl69qlQyAqAsy+KHP/wh3/zmN5XlR+Zx6c0sSfUiHa/VaqpIvLa2xtbWFkEQqH2TgoOAuOFwiGEYqn+5tBMsl8sMh0O1T9KTWtofSmFG3k+UAKlUCtu2efz4MfV6naWlJZaXl1WhtFQqqeeKPIssy1KBe77v0+/3uXfvnkoO13Wdzc1Nnn32WT788EM1lxWLRcbjMa+99hpvvfUWmUyGb3zjGzx48ADLitLWpegsgX+iWpCxI/OfruvU63VKpRJHR0eqg4Vce7E9SeDc1taWej9RLYisX55PUthxXVcVTOU45f339/eV51qK1JLKLvOhjHkB/lI0kCBBCU4T9l7UcMKkSyBcKpWi1+spcP/RRx/xwQcf/D514Wd12/Ay6LkD9mfL/GC4wo0ftcnWXW63kxSqAZ//yTnZ/wZK79tcWYkI4Q8f2DT0Y87SDp3pKr0wQScMmX4A526KtZJNJgx58ENYtSC1Bg99IAF6Cg5KUSD0UjHAPenRBTLpgGISJm7Ufmw+c5lOkhw/8Vh4AcIsWA5oZuRX7aWhn4PEHNIuHBYgMGHYgmkDJq6Jjo6OSTK8RAqdTP4+2UWwzWXIXAOzAPNBBJSTehRultLAnkTBXK4WGcn18OM4cR1GA3BCKOagrUcNtM2H0H8UVRsWX4b661Gz5LkJnh8Zfd0AOmEkR9dtCIqg96E/ZH4Gz4zAzI65d9mgNYvariUzUKvA/XEBt7aLtjnE85J4a6s0plPOF3XsrVdhuAF+AbQuDKeRVvnwu2R+8P/Ay7g4hhvtz6QNlSyMHehUIP0TkLsNo+9D7T3IJcHfYbJ2g8n5HvgDvHObx+QIAws/9HCNZfzZOgzfB+Mm2rCNv5emM50zBlKVkLWhT6LexivAw67Ow3kap2wSZtdgmIvOZ3DGZc8mZcJHCZ0aAZ7l8TAfkE1DK1+F5S9EPvjZZZiXwZ5C5uN2YIEbAfCRGwHu2gi63+byh48pfzvJ+LiAt9Bj8OXnCJ79WcwP/l9kjQAKUGgmOPZcHr24S/DWX4LsOsY3/g07D56wYoXMF6O6SOiAHyTAzpIcBaQ9cA0w82AVIi+3MYXMKhSqkPAh4UI4jRhw24SwDKXlKdOOhpWE9WfBPvCY3jEZ/I6FsTgj70fDLF2HXB+CEMYd8M6zJIMERqWHMzYY22kSK2M81+OgHZAJx6T1GYkwg6WHJPOQL0OqBulFMLuQXIdRA8Z3QCs7BPkgKlDloGvqnDRv0AgW2eQOWXpoQDjNkulb1IIkTxijUWPhwWWS6ccYjUVuTcp8ND9k6mf/QHPOHzrovnnzJs1mk8997nPqd77v853vfId//I//MV//+tdxHId+v/8U231+fs7S0tKnvufFgC/ZJKVbNlkExWXW8u9PAxUCEgUAxRdh8j4iX46DY1nICyCNg5I4CyvSL/lsAbOyMBEfpTzwxX8uC6CLxQQBPPGvePDYRfbxIjMpYFWkayJnFqArMve4/1WORbzvcm7ku3wJOL3IRMf3Ra6jMAYCSiV9W2SHs9lM9c6Ny8cFCMu1ERAc91jHvclyTi6y1/FWbXGAHQeQsu+yoL4YiifgMq6CEKuAsLXC3sQtBbIgleshxzuZTJ5qLSOA9eK4jTPd8SKCBAbGQ9EuBr7FAamMifh7y/e4FP/i3160b8RfG19sXywwXCwkxZUe8XN/cT/iyoS4LSMuX48fw0X2Xu5DAVZSKJEsgM/yVigUePToEfV6XQHCH/3oRzQaDZ577jk++ugjXnzxRUqlEt1ul8ePH3N2dqbsK+JbLZfLjEYjms2muh6u63JyckKr1eLJkydUKhUuX77MCy+8oKw44ocWr66wsQLsxuOxAie9Xk8V4ARY5HI5pc6wLIvz83PlP45LdkVe6zgO1WpV9XeWNmZSLBRFhaZpCvzLGJaio/iSJXTq6OiIx48fk0wmuX79ulJpxVUqYueQcS/vLeoB8XN3Oh3FYIZh+FQ/8p/5mZ9RAZnJZJJisahAksjf0+k0jx8/5utf/7piMN99910VwpVOp/nwww9V+zcpkGiaRq/Xo1gsqvTus7Mzcrmc2hcBgRJeJ951mVcKhQIQPaclmKvX6yn1khSnxWqg65F/fG1tTRV5BRhubm6q/ZVji3cgkGehXFOAx48f8+DBA/r9PoZhqDHp+z6bm5ucn58/1ebx0qVLFAoF3n77be7evauuTbxLAkTMO6AsPVIAksKKFBPEIibHIs8Vubc0TWNlZQVN03j//fexLEsx29IaUlLHxSoQ90xLgrpcM2HU5R4CVLCeMOme57G0tKTWAdJ7vNPpcOvWLQAymQzn5+eqpZ3I4qVgK+fl/fff55lnnlEqBbF5fda3ZLjEvcM+Cc9jWT9k3tH5XusKB+R5o5nnI/dtXvy/jiktQvc3NJ48LHLWTlA0+iwYHmMGZDAoZUJGPpwOypjOiJdrY9wTOPtmJJkd9qPgrOIr0HgdGjUolUKsVI+SEVBZCrHK0BtE/Y5nhsfgfoXR45DCcErKArsHWg16OThPG1RTPpdzkLah50Z5Z/op+O9VMO0kRqKB6ycZ+BZJTIa6w15Yx6/+uWhngiGkggjIGWHktzbNiDbX/Ci93CZC+to0+l09ARPgbAytAei/S6L9H8k83sNJ2kyvP4KXfChfjthxzYfMFHpGBOw1C5wgkpifO3DYwvY87s+hHsJqx+fEMLEzAZcJ8HvgDbLYudfh+lWYZCFbwk0noFiMvOV2FiwTunPIpMF5QOFb/xNXxod4C9B+719x6u8SLC5BegbaLagsw/I2pL8K2UXQzqFbiDzoWx4ULGgYBPkvMM4sQOiCO4/k3IMGaKdQ0Al7GxjeGfocenmdShhyfh5yVsqScDy0Xsg0WSdMbEZ++WQOZmMS7iETM+TBtM5orURwbZ+66+LrcBRmmG1ch9IX4XAH/DTMbJgHoHtgeBAaUWWiP4LSDBK3KT34IavvuTRHJlZyxpVhwJPebVr+CzhbG7iHN1lqeRh6wGzTwrt8A4pVePvrbNz9HlcMj74WjaVhCKYG88CDyR46XYbjyK6QSMPMh3kTcrVI2FBtRqF25gLMTwEH5kR1kHo5xK2E+EvQvwaN65ByfIrv1ZmNLBKlIakiZEMo1mC4DuUOZLwZY9cmNIEs9Owks5nNat4lk+qSsSBTBms+otTWoxbl1ahm5E4jp4NvQnoLzD8P80RAnYhJnw7g/a8bNIIURxmNPT/Ns3aHCjlOB3PqBEwo87BgkZ1brMxe4eQHRa7wKieM+EDvYGH9geacP3TQ/bWvfY0PPvjgqd/9lb/yV7h27Rp/62/9LdbX17Esi9/5nd/h53/+5wG4f/8+h4eHvPHGGz/WZ62tramHvO9/0l4qDvAkjVfYSVlkyd/LYjTuoZYFmgSsxKvM9XodiLxxAnZlERpnauOARlpGSWiQFAuE3RFmXcC3+FCFkRQwJ3028/m88p0LOBLgFQdNIocUACfp1WdnZ0r6KCzWbDZTvVJzuZxKFk6n00+pAmQhNBgM1OJUJIDi5ZZ9l4WWVOYl+GZlZeUpxl6Yp9FopEKYJMm32+0+tciR65DL5ZRHOp1OPxVqFg+lgU/akonMWvzScp4FyAsQBNSxXASwsviS6xH3d8uYq9Vq6loJwyALyngwmvQk7vV6HB8fq/Em6gFh1ePXNJ4TIKm3cv2E6Y4DcynwxJnrT5OGx0Fu3JoRvy/kWuZyOQW6ZcEeLygATxUBpBgi911cDRH/bLlmFwsbUpSRhay8TmwhF+0U8noB28L+wyfFJ0kE/ixvly5dUqqD9fV1er0ejx49YjabqR7QAjSOjo44PT1VvbklNV/TNOVxliKZ3AN7e3tMJhPu3LmjWNtMJkOtVlMsmUjABeBms1nFkAZBwP7+vrqPBDzI/CiZD0dHR8oeAdHc0u/3VYFUpLKZTIZqtaruUxk3gJq74p8lxy/5ANKGcDwec+vWLR4+fKiYbpGZJxIJrl69SjKZfKq3vciQhQnN5/MAyjcu8nPJ5Gi1WpyenjIYDLAsi9dff53XXnuNer3OdDpVqg9N0xQ4c12Xe/fuMZlMFCjt9XqqWCksquR8fOELX2BtbU3lSEiImu/7rK6uqueW3HcCoqX4IL2pTdNULbAWFhZYWFhQSdnj8Zhms6nmHSkcJhIJNjc3qVQqFAoFTk9P8TyPzc1NLl++TK1WU/dlPKBTrpMUVkRpIf2vJXQzkUioJHIpRheLRabTKTs7O1QqFYbDITdv3lTHFc8ukXMixWZN0xSgzefzTCYTms2mup4Xi+vSSk1YbwG1m5ubBEHA+++/r/ZLigFSkKzX6+oZZNu28mdLXoy0lZQCebfbVZYFyZeRordI7KvVqvL037p1i0ajge/71Go1lZxeKBSUykIC58R21+l06PV6nJycqAJMXB30Wd2eIUPCvYZLwKXcEV3L4UcDGAcdNsM5nCSZvj0m68Px/QSngyJzDWzf5HwYMMZEw6XXMdASATX6FLMuyatgJmH/hzA5Mbk7S1BKzNlsBARVOK6CswS5BY9MDlwb7C4YuUge23VhohXwTpKMH06pZcAwIGnBXctill6gzzmDtMc8B+YRkWfWgVRo4pgaAxMsPyRggEeV4XyJcW4HKpuga5DMQtoCSwdyEUU5nkYNl41E5I9Gj1pGeblop3oDmBow7aK3/x1re79F9dEAaz9ksADH4W2mCZvw6puQ3IDpNGLNWY76ck/mEQXqGJDIgWuQs0MmVpQHVgrguGyiF11SLUgews74nEPrNxjvpqH0JbDrUdCblYZU4ePEuBFkgEUH3v0u9eEJcxesMZQ7Dp3wHguzRxQDl/FYx8zrHOW2mV36HyH3FShZULBB/w/Q6YD3GqzWIzDvhqB3ovPTbUHCAHMr+tx0B73aoGxCohtQ6YC5HqV3a5OANyYu3dkJtwwf3zkCwyM5cdiedWglkow2n4FKhkHBZXbaIvRWcNdfhrWfgO4z0PSjlPKcCVYYhdzNw4i5LxtRSppxhHH4TbYOWgQT8Hc9Ku6Ywj7khhNaJx+CmcGwDYq2x3jTQ3vOgpIJgxbGzR+ydmrja2DlIR2Aq8M0CbrrojlNkuk5QRLcc5jPYFgBpwPN/ciXbbnRePeHwAmQBqsCxeWIkPfGsGRCx4d7uxq5Pwfp8x7pswyJPGSXoyEXfBx8Xw9h5gbY7ajuk7rsY96d4faKDL02lXSUmxAaMBun6GohOctmOo1S1LMp8BLgjiPvv/4SnFWiUDXLBPc2HE2TnCRbOCsh58My280eOSwM06DqZRimJsw+ZxI8SvPwWCdPjzXeB6NJJtmE6cIfaM75Qwfd+XyeZ5999qnfZbNZqtWq+v1f/at/lV/6pV9SD+Rf+IVf4I033vixkssB9WCSxVe8ZYss7KVqHmfj4mnQsuiIg9OLwCDO/sZ9tnHP6X+ONRPGOM5Sy0JQXitp3RcZRgHSF9ntuMf603y5F31qwsSITFL8htPpVC2SZrOZYh1E5iYsjrCDcQ97nN2Og63/3BYHWHF2WBYjcl3iCasCAOKBcFJIiJ+PuK1AZKRyreFpxl9+jgNZ2Y84qyv7FGecpbghixH53LjcTxb7AkzkGsXHkoy/uERavi6Gpl0Eqxf3Pw7m46+Jf6ac2/h1ushox4G6XKO4JUFeE2fY5dpdBPLy+/j3OPi/OF7j+ynvFw8CjCtFhGmVa39RTRK/b+VcxNUFck3jY+qzukmoWLvd5vr163z44Ycqkfng4IBkMkmz2VTyX0kzPzg4UCyi3OuGEbUNvHHjhkqmbjQa9Pt9er0eo9FIhWIJK9put1WKuEjCZZ6bz+dks1na7TaeF/XVjqtEpKgkAGE2m3H9+nV1navVKicnJ2o+MM2oDZWAKwkLE6AWL+xIQcv3fQVahXlPJBIcHh4q1l/CrMR33O12OTs7U90UBEi1220ePXpEpVLhmWeeUYVCSccG1DmUMDgpgGxsbPDRRx8BcPXqVUqlkioqSWikpmkcHR2xt7enxrIAVgFsokaQVl3PPvssOzs7WJZFp9Oh3+9TKBTY2NhQihpAqZgkRE/XozBGKe7eu3ePR48eYZomCwsL7O/vK0+xAGO5DvK7er3O8vKyklZLMUb6jMdDwORaxBnvbreLbdt0Oh0ODw9VYJ7IqSWZvNFo0Gg0CMOQg4MDJf/PZDK0222ePHlCoVBQYafxfdT1qDXi2dmZOpeWZVGpVJSNxbKitmmSLSDzuxR64zkc8r7Xr19XLcnknBqGoRRMUtQSdYD4waVn+Hw+p1AoMJlMVDFAVGjxlHxRj0hnASk8SJK5pLyHYcj29raSlafTafb398nn85TLZQXmu92u6uISb8/5Wd5ewqPENbrah1zPzLg1zaD5i3gMeVezMecrNH9jQro+x67aLG0c4JzoHLSuMqRMwAiXHiMnh+FkKDLhRnrG8iXQrsHZRxr9cZEeLsMwZNmARAAnRQjzMB9DcQnyFZieRJ25kluRT9vRJ6ScLLP7BtYNn2EJjtLQSlYgucksNWYvNSCRgfIEnDl0b8BMG+JiUbch/W6I3rMIsQkMnbBWj0LGgjSktUj+PdUilKIZkYRcT8IM8DQIxtA9B78IvQkMhpBzsFrfYPPoe+SO5zQmKayky1LC46o15173LtNGCkoH4KYgWAKrDoN78Og/Qel52HkJnrigzdGzIckxpCagpaGQn7M8gsJdePIRNLIG1UuHaOf/d0apAdhfjDT4aQ1mJixkYSEAR4PxA8zDH5DoORgjmBvQTEMq9Nlo+kwbBs4wRUqzsRabzLbaYF2OGHP9+zC4A+HrUHoTHPvjdHUNSETUb3Ad0KCjRQFyizbuaxWaD36DrDfh3ITEMpQPJhRnMHdgxfepJE7omZGHedGAtAHtmg9LfdBXYeXzOCkLEp+H1DYcZiO/thZAyoKMH/V9C73Ic2+FkDkHvweDdygf3aFyHJK1IevBbBIx0O2pAWcNso1TtKLN3hyywGSSgew6dEbkHx2RHUCQj+oWWhjhcUOP6ivGfEayAeEpGGmY5cCsQHoM2hhSQDYBzhBMG1KLYF6P2twlddBaEDyAiQOVFmykQ+4+q1P8ypxXvj4nm4dcPfJfz33wiHqLn+9ZBNMFUssnFKuwZNjMgd7UxCaBZ9tM0NAmmzjajPTokKADfg7cIaBHAHd8BuNN6AVROJ9fitQnKymbYX/EqLFA2Z5xJd0kaYeMvetAgePEEyjmcTMlusywyHIMdHwLpgUyuPT/AHPOn8is+g/+wT9A13V+/ud/Htu2eeutt/jVX/3VH/t9ZKEmUjcJ4JGHiHhFBURIEJgkrkqPSwFrIheXB1x84S4MuoCvXC5HMplUrIMAflnYycO6UCgoT52kqgrrKuChUCg85T0UeZv0njZNk3K5rPrjSpjNRWAFqIVyXFYrHlhpddZqtZhOp5ydndHv9xXQM01TLaZENSBpsbJQlU2KHPGgrXjglUjS5RwCKhxJAm9EmihBNcPhULW1ks+Ph4LJ50igjAB5WQxJsJN4gONp2rKok4W4FA/kPUUiGb+WcRmyjBEBnAJw0+m0Yv+k1Yq0lxP/3EXQLws68X1KT24pgjiOozzHFwtAMkbgEztFnImTsSfXIH7c8feQ4o2wMHLtLn7JJq+V18UVFvL/8EmRCVAFMQHqceY5Ls+VcwI8BYjiiz653yQB27IsptOpYhvlGIW5iSsa4i3MLobLfZa3x48fk8/nWV9fVy2AEokE3W6XdDpNv9/n1q1bGIbB9va28q7KHCeM2tnZmTpf0vJLQtNarRbr6+skEgm2trZYWVlheXmZzc1N7t+/r+5TeU2/3wci0FwoFLh27RpbW1uK1RZGUQoquq4rBU61WuWNN95A0zRu3rzJD3/4Q/b390kmk1SrVS5duqRAm3j8RZ4tzJ38XqTTsk8SKNZoNBTwWVlZ4cqVK7RaLVzXZWlpiVKppACj9Gq2bZt+v0+73VbZF9IdIJPJqJ7iMpdJQUvmfrmf9vf3MU2TK1euqLZXMr7T6bR6bqXTadWaK5/Pq4KB3O/D4VAFyolqBlAMvASoxQvOct/J3Cwqk3w+z+LiotofXdcVOBNAKKFqruuqNHEpekhw2ubmJtVqlWKxqF4nagN5Bstc7Xmeshi1222VoA5RoX04HDKdTqnX65ydnbG3t/dUcORgMMA0TcUQy7NFWrxJeJ8oK9rtNkEQtSyT+8J1XSqVCisrK6rjg+QfVKtVZWlIp9Oqr73MOf1+n52dHe7fv6+KyMLMi7JOAHcYhiqQT4oQMndLj3n5G1EzSOE3XnSWcWXbNpVKhS9/+cvcunWLZrNJvV7nlVdewfd9jo+P+eijj9S5kYKMrutK1bexsaEC4j7r2yOajHiJSniFROcRI79MkiSa3uO0nORub4HsWQJr9gHbrzmUinDU1AjIAAF5TnExOKFIggAfk6at4d0MCbtQuBzSGg5Y3ytjpWwWnrOZr0B3CYY7sO1rZE4hvB7ipsA7g34B8KBGl2J1QPU1n1vb8KNMglauhJ1YB08nTATMfbB88ApR0Ne4auC/uQ1aluzN96hOXLz3H5FKh3Su5uHSEvg6BE7kzXbMKHXKNCITtZGJPMPzKfQ/AOcwAnY9B6ZdDH9K6u4xP3F8TNjz+c7WMvZPraK1Dpi5HZJL4JYA8xT8ANKrkSzaGaH3H1BuP2KQKuAtjuCuBlOdoKYxH4Q4DtizqA6wpIE5g/ESjIo6nqVT0bs47f8Fey2E0k9EsvJ5CNlJJJMP0tDuk5r3SGUgbIIzhnICvNOoTZZnp3HDLP38HD+pQTaAtRloneg49ZfAex0Owyh4reKCD8xCyDSjY3JXI7q06EHRhjDDdHGNefaAIEgDr6B3HbrjdzjQZxTnIfUR6MCiDfkaHOSgk05FEofJGeSfh/wNOF0ErwihBlkHConohZ4DiUTUSz01h4U+2DfB3sdqv8Pl0ZxyCrR8JNMeOTDLQro8Z372mPwDB90FL4CgD/NBFswN6B6xnhswG8BwBIUs9PToe8qHrgYp08NpgjeA4mXoZSA3gNQU3N2Pi0SnEZudW4ku+XQNBgk4GUOlCrkrMJ1DJoA3WmBXA9znYH4fzAHYbUiY0X67jahYEgQhKc0lnMDsGIKUj5fw0JwrhKQIpo/ILwwxtX3CcZGZp+PMA/yDqC5hFCExigQRpgFZ/2PRhQ2LJfjKKy6l7/c4HJyxvHPOK29MCH4wJP8gzXthCm8+QrtXIAgn9HIdJuMsQ6BEFYscTa0XRbj/mNsfC+j+1re+9dTPqVSKX/mVX+FXfuVX/je9r4Al+CTESRby8hCT1iECumXRJaBKFnbAU4vxOMMWZ84FbMjDLu6tlkq6MLHC1sSTxkUSG2feZIEjfy/BbvG2TlKhFqAa9wnLFgfaAhhFshb/LsyRnIP4MctDXRYwAjol0CbubY/LgOPALc5exwsCwpxL+JUw2fFrcfHcX5QeX/T8XpTTy5dcq7i0Ws7NRZb+otxazmWcIb7IysaP6+L1i6fOCgCNM7lyHi4y+vHzEFdiSN6AHHv82sff9yJ7HT//F49BrpOw8aLkkC1+zmX/5ZzGr0H8/y5KxuPXRBiXeMDbxfMcZ7gBxQpJf18BVPF8AwFo8SKZnAthsy566j/ten8WNwlVKhQKKvlazs35+blSCtm2zWuvvUav1+Pdd999qqCWyWTwPE/1NL59+7YKC1xaWuLNN9/k7bfffiqhOZPJ8Oqrr/KjH/0Iz/NoNpsqMEsKlgBLS0u89NJLXLp0Sc17nU5HBU0BT/WE39jYUMXJq1evKmk2wEsvvcTS0hKj0YharabGqjCict0lP2E0GqnnQq/XU8D74OAAiIo8q6urqn2XFE5TqRSa9kmbvrhyyDSjdPVms6lC5drttgq9BFTLtPPzc3Z2dtR4FZ+ubdv87u/+LltbW3z1q199Kp1/NpuxtLREOp3myZMnyt5Uq9UU6yrzkKSDy32dz+eV5UXmRwHqUrCS30sf50ajged55PN5pYIQW08QBAwGA3U8vV6PpaUlldp9dnamWmiNx2Pl6/d9X4V/irQ/znJL0dxxHNrtNkdHRwyHQ6WQkPMq1/P09JRer0cYhiqMU/pN9/t9FhYW2Nvbo9frsbi4qNq1iepLPlsk9WKHEV+92Fviqqi48ib+XJL7q9FoKHuBjAd5JgrAlmel67qqdZjkIEwmE1WMmUwmJJNJpUBJp9MsLy+r54qEDsp9IQoS8bRPJhP199KLXGx3tm1zeHioitiiSnnw4AHFYpGdnR329vb++CasP4EtRQuDPaqsMPReIyBkTIATQGJ4jBaY3GWRhJ/ktbJD7wx+1CpxoKXomiHP+VPyoU4rzLCKTY4Et0c50t/UyP+uwdJP93jjv/f43g9aZDoRQJ7Owc3A4A1YejbEuwnN9yAXQikJeg9yQ6DskPtKSPtN+O6lFO30NZhXoKPDpE/oBhjA4hxWHRjZJv7GctQryaxzfHXKbPCYamHOQNdpvrwNSxUYjaBaiah2PYhYbgHioRf1357sw/DrMLsHpo/W9yn3h1wbuRQ+gMQYnqyBs+ljTE4plQZMazrtbA1SeuQDd4k0844Hk3uUx++waYbccRp480dQvATlFfqhSansspCHJyF4RZOx63G8qtE3NWq+zTSErmvgpVKgfR9j//v4xb8IWz8b+a31ORRncHyKtjjDT0JgRRbolA35PGh1aNtjisEYv6hztn0NFp6JdNTlLGSfj9qdNaoRqA5DGA+huAfhnQgZGnnIrYPRJHf8iPTvdUl4M7S8z3DZZzjfguAFgpVjNE0nPwgxS3DsQakb1Tw6KXgYgHNWQm/0yKX2GI88AvMZaJuQ9CGfhTAJvVmUUJYMogbYFR+qj8F5G5w99NYjVo7OsIYwTwM5GE0gH4LZg0vTkMmRQ++hzlgLKRFiV2FWLUbtx/r7FJemeH3oPYxaaGVXI7FDcQqOY2D7BuHIwZh9HJxmQ9qMmHG38nGo+iLk0tFwmuTgIXAI1A1I6DC0oDoFsx/t29VT2M/DdBsSvwvNUcRCBwHM2hqBY2JmPfSlJnYIYxvS2zCdWOCUGWoNSpkJFjAlIImH7WscOJAawgqgG0ASUpXISu8kYGiCNYvC9at/Fr607jCePmFlN+opfuZqJNmnyJRdZ5vDhza9lUPCpI85ybATFlkhw7d5gq7no4LMj7n9qdYPjUYjxWCIZE1kc7JIkYcloBaScXZXHoDywI2DoLj0ViSPAn7lNVKRltRZWURIKE4ul2NpaekpGbr0mW00GmrhKNLDSqXyVIFApInC1kj/8DjABRTzIfI78UPbtk2321WLxLhsVzy6ss9xFj7uG5RFlTyc42nTElQkvc7j8nhZ1AiLIlK8+XxOKpVieXmZhYUF1VorDEO1IK9Wq0qeF2clhfGUtj1xKbmABQFywhaL71/86CKtlwKMMMYXgXGc2Y/LmkXOLGBQQo6knUu5XH6KhZAixmg0Yjqd0u126XQ6DIdDWq2W6p8db+klgFtSzONFm0wmo1hfAbGyUBQrRHzMXwTK8QKBSB/jbZTkfMZBrJybeMCfgGVp4yR/J/JHOV8Xg+7knMRfI2PTNE3FhAPK0ygpweKRlBAteU2cRZfPBxQoA9T9Hgfmn+VNApmky8HGxgaNRoNEIqHkwsPhkFqthuM43L59m263q1Qj5+fnmKb5lLLGsiweP36sgM329jZf+tKXaDabCuicn5+zubnJW2+9xfe+9z2VmSGJzJlMhoWFBba3txVrKMBa+hcPh0MAxarKeJYi5QsvvECpVOLRo0fM53N2dnaUjFzuDQmOknkZUMnSrVaL4+NjlbAeV0eJmkiAeTKZZD6fU61WVVsyCZKTOVfaa1UqFcbjMdlslvX1dfL5POPxmH6/z+LioroHXnzxRWazmWLRxet7eHio2mKtr68r/6/InwXYSyiaSJ89z2N5eZnpdEo6nebFF19UIZWHh4ecnJywurqqwFe/31fzhXj3NU2j1WrR6XQ4OTlRkm5RIkl6ucxjAkZ932dpaYlCoaBY5v39fZrNJtvb25TL5aeC6uL3nzwr5vM5w+FQPSfOzs64f/++SgaX59dgMHgKNBpG1L1CmFlRPAiglc4jruuqPJR4Rogw6uVyWY0TeQbF53rJABGVg6Skt9ttVZiROV6yVpLJpMrokLE7n8+VZUAyDkTRI2uYbDZLp9Ph9PRUgf5KpaIS7oWZlx7bAAcHBxQKBVZWVpRCQdLSb968ya1bt9T5F799Lpfj0aNHSmXS6/VUoJzvR+F8n/Uti0Ha+gYlb5NseINL+HSxOOQGuB+RI2DGgLrp4DyC9x9luO2t0M0GhJkie+0FroenbGKRpIbGEM1d4TE6Fdci+EaOLeOEV38uYPRhlMWV60WtlaabcPp/hPQCFFvg+sAisAmGA7oZ8uQa3K0m6Vhr4BTByUAyAWMPc6hTAxY6sDGBR0aCpnYF/ApYSdznv8RZcYv2zkP8eQp2Ph/12SYfeaGtRARWZ0H05c8BC0b7MPg3ZNvvkjm2MR3Id2BtDPU5dDPw/csGvXKO5LjNpVnAThIGc3i3OmK8uhjphV0Pjp9gzGzK0wErpw5MIFUZMp81IXkVlnbxs2Wq4yanfWgugmtovKvVcF+2CGZzpq0EgasTWBbUdzAPD9g82OOoFuLsrkB5BYxHMG+BNWRqFmi4Dtm6T7kc9TrvOCYdP83IyMM0SZAuELywCctElZDWLWjMof4GrOvgNyJDeToL+iSK09bSGNo+q60fUu/Y+Cc+7Z5OMR1Qt2F/BqNyk9B9G8ZdCtMZ22lAizLpqkswzGt8NEjTNg2s/XMWjx2KuyGPKmfYOGAnI2Z77kcI1tUgp0fgbjSDzQdgfQ/6jymc32Pj7oiVccg8B0+8KLOuNYhaql9bg8x+JO92iwEDH3oW9FdyeJe+DFTR3TZ2KqRYg9oQ0rloeBgeaHNwjCLurIZ2fEQ6sJn1AxL3IFGFRjlqRV6zYBRGhaKMCxMdHnomnWKezVGP8gM416PE89kExmbkG1/TIZOPMuJsF3AhmGrM7QyZME0wH2JUHLJWlBmn9SBrh+QY4DOm48NhK4sT1KP7YD6mbvqEFWjPIfgAEkmNtddDcnlwRhDUwNqMhrm+AOvVyMrx7rfh3d+oY7UvYYQNksxYZY1BsMmk9wjXy+CSo0GXhjainZlizX78Ht3wpxx0i0RNmEb4xCctwFKAi/w7Lhm+KC+NL8hlkSaARYCwgC+RMOdyuack5QJIBHQLKyTvI9VuAVoS7iOLWgFXIu0UCZocW3xBCU8nR0vRQJgXCSzqdDq/T6Itr4vLiuOyYAEwInOXBZE87IV1Fzl3vOIfD425CCDjhQ45ljj7IscohQV5LzkHArQFeMqC5SJAjMuq498luV2Y/rhkT479IjN80fsdl3fHPd8yNkSNIPsmfyNST7k+UiiRfZFzE2dkP03CL2M8zuLGWZh4ivunScXjgWyyn3H1BPDUwjj+74vs9qepQ+KseBxwy77JdZZihHyepmkqGC3+nlIAE9WI+HYv+tFF6RH3mMczBOQ18nmf9a3b7VIulykUCkynU1W4ANjY2KDT6ajx/Zu/+ZucnJyQzWZVMCJEvmwJiZIwJvHNHh4eYts2GxsbCmTImDdNky984QuKkW6326qoZpqmaqsnRTu51hCNLQlqvH//vkoMd11XyZN1XVfFTPHwxq+zSHDj6p9+v8/R0RGTyYR79+7x+PFjVQDSdZ1iscji4iKrq6uq6FatVul2uwwGAwDVXUKk8AJoHzx4QDKZZG1tjU6nw+XLl3n++ec5PDxUXu/19XUlC+50OgRBoPzfe3t73LlzhwcPHqhi2MOHD5Wn3bZtisUixWIR3/dZX19XAVy5XI5KpYL46TVN4/T0lB/96Edks1lGo5EqFEsfcjlvogY4Pz9XhUDxhW9ubmIYBsfHx8qWs7y8rNLPpVgj51s+p9/vKyn1wcGBKhSKT1j+XmTm4q2X4ujx8bHypUtBUH5OJBKsr6+j6zqnp6dKDVYqlahUKnzhC1/gxo0bDAYDBTBN02RlZUUVZeRZK/NIMplUBQV5Tk2nUzY2NshkMgAKjGuaxvLysrILSBFH0zS2trZIJBKquCxqAFmbjEYjlSkQz2bRNE0VbCqVCqenpzx48EAVMKTP+9bWllq/7O3tMRgMuHz5MrlcjvPzc8rlMq+++qpqCef7Ph999BHf+MY3GA6HSmki7+O6LuVymX6/z8HBgQqcE3XCe++998c6X/1JbMe8wnPWOxRyD5j2fCrkeY6AdUK6eHSZYNHHGIX8h1s53tVX6FRzYPdhPKYT5miSZpEOOhUc+qwxIUOBCQZHoyr2t3qsLY8xa+AbMLei9td5A3pfhMNrsDqAkw50A3DyJgnDR8tDM19insmDMYdgDmEJSECYJtV3WZlC4gPwB1C47kW+5kIpQkz6Eiwv4ln5CAllalFzZSsTtZwKPDCd6H29BLhJGPTg8PuYk/cp3bepP4LCx0Sra8JeBUaLMFox8DyLmh9SqsK0E/UH32ZCwzpkEIxw82VIBBSPOmwdB4w+AJJwaXXK+9338Kt/FvLP4gZXePJoRqEywl0HV38OEivQfRuCAO+Zq+BaaPv3yd55j/SdKbkELOYecnTy/4X6T0VUqO1AsYRffIWW36S93qafOkXXNXr51wnLL0BoQXENtBmc/ABu/wvITmHUh/TnYXMGQQNmI8h0YdoGbRVSG9B+m3rnbTJDj3YrTXegMdrIcmy4mCcQejOYAkt1yJdwzh9hVX2GDgwDGPgm58MbzMxrMPkh9eE+hR5M93UcdwVy2ahPl2aBEQA+JDXw3KiAUW5B+H0Y3CRz0uLaYEghiMLEqhZ0Z5F8PJuAwXpk1U+cwGgh8kmXWjC6CtMvbcC1XeifkAofM0zAURLSNyKi39fhug8DW2NWqYO7TNo+pVyBURKcA7AbcHLFoL+ZIZceUyFk5sNKCm5rCVpLz5B025RnPdwPIoa8/QYEVyCTiLIMjHF0mN0MWB4Qwjg0ICwyJSThalgnFmbSR08EjOdQdqpUyNAIszyYh/Q0By3R5qGXx3DSbI0dvArMdXjS1miM6jzfHVH4tst5u0RpfULt/zRj7SqkvOh0f/g78I1/m+JokEPDY40Ul6ngo5HH5aVJhUf0GCQOmDpNRnqOQEuRCsbM/gBzzp9q0C3Vegkik/Ya4mWL988WQCqS1TAM1SIx3iM4zmTHJbaymAeUV0+kewLk4tVw8fSKdNfzPMVAn5+fMxwOaTQaDIdDBSCFwS0WiypQSBhgAarytwIyhKkdDAb0ej16vR5nZ2eMRiMajQbz+Zx+v/8U+yfV9YtgRRK7hXnyfV8Bwng7qrhUThYPojaIe7pns2hIxgGPLDBkgS39ZeMpvwJsBajGQXE8oCwuY5fzEPePSrsxORZZ1MVBbrwXaZzBlX8LgJVrIYu4T5O/CwCU94onCtu2TbPZpNfr0el0lNpBmP94sFfclw1RIUB64ZZKJbLZqD/gxeC0eCFGwKa8V/z34k1Mp9OUSqWnQLeAJmHP5FzJMcn7xosaUiwQQC6fG/eGxotVAlrkPeJS/XjSvkhedV1Xi/t8Pq/OjbynfF78HpcFe7xYJtdQ2HkBCn+Y23e+8x3+/t//+9y8eZNGo8Gv//qv8+f//J9X//+X//Jf5l/8i3/x1Gveeust/uN//I/q5263yy/8wi/wG7/xGyr74h/9o3+kGLj/tZvMJfV6nVu3bqm2XLVajc3NTR4/foxhGHS7XU5OTsjlcgp4yPkTn6n4dqWgKcW22WzGo0ePlGd3YWGBTCbDfD7Hsiw2NzfVvSjzpgRDWZal/M4yBoQtPDk5YTAYcHx8TLVapdlscuPGDRYWFtT1lntf5jPXdZ+al+VvHMdRc+1gMODevXvs7+8rKXE6nX6q1djZ2Zmau+MhavP5nNPTU9X7Wj5TugYkk0nVeq3ZbFKpVFhYWGBjY0OpfWq12lPBldITWxj3fD5PrVZjcXFR9aYWqfFsNqNarbK7u0sYhhwfH6PrOsvLy8pLXiqVFJieTqe0222WlpbY3t6m0WioxPSHDx+qtmHFYlFlUdTrdVZXV2m1Wur+XlhYIJVK4bou9XpdtTmL7//Kygqbm5vs7+9z69YtJpOJKpJtbW1RLpfV81HmCmGuRf0VhiHNZlP9W9QUEoYn4FtsUtJfWtjwzc1NXnjhBTzP486dO8q3LyoL6S0u+yDMvPSQlyKgsM1yTcfjsWrNpWkau7u7vP3226p47zgOp6enrK+vUy6XVY6K+PHFHiYJ5FKQFuVbIpFQsn1RjElPeLk/Bfx7XtTl4+joiEqlwv7+viok9Ho91YfdMAx1L8mcHbcpyNy3uLjIeDwmn89z+fJlVUwQpcsf9vZf0vwIcMhVXptWqBf+f9zKn9AbLVEzG9RCH89f57HVxlgZ0mlavK2tMloqRibUqQPTACc06M9yrFXPKKcH+Gc6pj/Fw8bUNFKJY2Y9kyf/s8X6T7ucfh7uLMA4HZHMvgVnW9B1NbxJiKNZhOlC5LVOpyKAPGiDPYCwFkmCPRdGbZZPXQoDmDyA4X0DexzCs04ULGZko1Qy34egEDHcVjmKpc6ko9Zgmh8lYQU6uAVotGDwHRi+T3jPJdyHjBMRwVYR9Bok81DxIHnuMM52KJghgQPTPIQJ8OZQOfUI+y06taiH1NTtMmjPoR/llWVaAQXrbfqp/xthNU24nGa6XmN5Ombg5WHpy5HkezYGcxg1HzccEk6H5daMXBIya+AvubT67zG/W4TijSjdazaHagEu7xC6Bv2zfTBmsLwaVQ4MC4ppmMxAH8L0FrSBpS/CxptwMoCzt0n2zzE/OiE8HeGV1qCYw8rdZV4LuV9/gXB1F1pdsB9iuEPChQRhMiB0C1BPYgwfUMu76CaMhxpHxgLBykuw8GV4ckjpbp/SEKwFaOULhMkXgDKENvBx4pqvgW/DrB8FqWU+gum7lJqPudLy0UM4q0I6jFp5ZbLQSEYFmEv9iPVuJmBSAGNfIwygv7lE+MLXIDglee/fcKl3St6FhqnjZkMWCiHjHoyAWcaA7Apmb0S1MmFihXhhVJsxSrCeDei6CT5IFbg2GfDGStTf+7a1ir97g+IP/xdSDgwugX0LBh9CeQfsRdh3oDCE5Meh8LoFqWfAzHl4H50TDsFK+pjNBP7EIpG2WcxB1psyTz3EemHI4ilkDi2M8px2B3JhBqrgmTB6ovMwSNBcW0M/neO0Q3p6gd29Q5ZOZqxcA9sCfxb9rTaokMQiwGGCy4R12hjonFFkEZMxSSdPnkv/f/L+LGaTM73vxn61PPu+v/vae7ObZJPDEalZqBlZM5KS6JPkAAIcwLEBGzkQcuADA/ZBAMEGDARGDmwgNvwBsR1HshMjgWJHsqUZSTOcnewmm2Sz93737dm3etbaclC87q5+PXI8k7HlGRfQaHbz7eepuuuuu+7/9V8uLrgzHGvCDing8Edec36qQbdIbwUIaZqmWlyFX2ryMg0DMHjeN1skj/JLXq5hACWfI8Aj3Dtc0kyFeZdf4pkUECAs9GAwoNfrqQ1E+OU+mUzUJu888ygsSZjdFaAhDOpwOFQysXa7zXQ6VRsbeM5yh9lYuT6R9QqzGma8pb2KMAsiVRN58g+TDwtQCrORgPos2Xj5vq/kzhIeI8Fm8hkCqKVQIqBY7qecoxRVZMMRZj7Pp4PL7/CiPznMrMv1hFnhMNiXQ34u7LWW75ZNttx38ZBKMUOu8TyrHp6DsmmUooucfxioi1TzPAgXdjlslZDikigKzrdbk2crrAgJf3bYgy0/I+ccng9hcHz+CGcGSLiQzNOwxUOuIZx8LYoC+U7ghXt6voAR/n4B+3Lvf5LHaDTi5Zdf5q//9b/Ob/zGb/zQn/nqV7/KP//n/1z9WdYROf7KX/krnJ6e8rWvfQ3btvlrf+2v8Tf/5t/k937v936kc7l37x6lUkn1vxa2WQoPGxsbLC4ucnx8rFqISXqxpBrH43EKhQKrq6sKzMkzVy6Xle+31WpRq9WIx+Pq5ySXYjgcqsKN53lqcyyMelixIAC01WrR6XRUyrNlWTx58oSXX35ZJUFL0QhQcz+dTqt1SoCnACnXdanX6xwcHLwQKiatlOr1uroXw+FQgV1Jb5d5L5+bzWZZWFhQzKgU2k5PT7l9+za5XI7PfvazqnAq1paFhQU2NjY4Ojri448/Vmqf5eVlXPd5C8rDw0MODw9ZXl5+Ic1d8kIEQEnxU9d1BcSl3ZcUouXaDw8POTs7U8WETqejJNEimzdNk3Q6rfqoy/pbKpXU98n9EwZYZM/1el09c47jsLS0xBtvvKHk25KxIsx5o9FQcypshRIlmbxH4XluS7PZxPM8tX55nkcul+PNN98klUrx8ccfMx6PVTBY+JxHo5GSf8taVywW6Xa7SoWRTCZZWFggFotRq9VUVoHjOCwvL9Nut+n3+1iWxdLSEoVCgaOjIw4ODkilUiwtLfH06dMX2plGo1FVHJGcgdFoRK1Wo1KpqEDMSCTCzZs3WVpa4r333iMajbK0tESlUmF7e5sHDx6ws7OjrFyNRoNkMkmhUODs7AzbtlVaeyQSYXt7m48++kgBf8kggOftEyWArdlsUiqVWFhY4OHDh0qF9JM8/ntaHwEO+IR9LrDYzpLBpsUivjcg4Y9xmbGRH7Nw0+e4P+fOoYVu5Un0x4yzMXy3QNweUSBDwemwemPKKOWh74OdH+PmoHwJTnddnE8u0frjY7xXB7gxGI+CBOtoBKZTGA3NgKWGIO0plQRi0JvAaICmGfhG4tN0cQtmZ5TqHtEjODjT0cdVpp8M4ckIbmbBMIMAs0Qc8mug1YJ/6zuQ9oKo6dkcDA1Gn/ZW0h+Bdx+jfkLxwGHFhNSntu9yFKbD4MfSZkDG9oY+yUzQ6smZByy+o0HTDbC9NvLwcwvMF+r0Jqcwgug0YBhLpx3Sx7/LOBdh+tkYfmLGKXGm9lbQj6q2DhtVOHoE976HHtkjl57grgUy/EkEdBvWD5t0D/+Q3vJt5vGLEF+CaBX2rwdtziqrwIcw2QvYc3Jw9C4YJ5CegrcBkSXIfgbOknD2FLP1XS4e1CndB3sOnb0OEU2Hmx6nGYOUfcrE9HHTGTRrRmUwBXeKlYRp6QSmf0BmMmAK3OuZjFwTL+2Adwijb4C1T5weMQOGHrSq1+HyW4Fe25mAHgXr04GKjSB/BqUp+A+Jjw+odl0SNvRjMNUC77KVAA0Ym9DXNDZPfJID2M8GYfWMfJ5Vqszf/C0wfh7z2f/M9miHUtujFAVj5NGYBAqMhAVWDvYjOkQc0toOxTWf3ghSJaAElOFaxceLdfikmuDAgMUpHDtRrKVXod2j2p8yt8C4BMnFQJGRuAu9FHjLEH0KswHMJ1GciYETnRBfg2LUJeMGQzH6tkMNk0olaLE3stvEl0B7GxZ2IPpvXeIeLC1YVBYstl+D+9/ReGhVaa3n8KMGe8YIx0xANMvJNIgYMLKB0COlw9brHh8/6jJtVUiSQSfOKUme4aDjMcEhgkGRARMOyeJRIs4Z1o+83sDPAOiWzU7YPwsotlmOcBss2aAJgMnn82SzWdLp9AtsrQBa2bCJdzkWi70gQxfQEGa7wz8joVnihQszhLIZlaAz6TcrUjwJihNgLCBNQnAkAKjdbtPpdFSKroB7eZmHQR28KFUPj4tsRuSFKxsuYQsFIPZ6PbWp8DxP+bvDygDxTYu3Wu6L/AozalIwEf/n+XT28yA0LFsXpky+VwCVgMawPDrMvoYBm4BsAdMC1OVcZc7I3wtrK21XxDcroTeiMJBkY+mjLd5DsTzAcwl0WL4tUkj5fglx0nVdXaNsXqVYIptIeRbkngtIl0KUpEGLV1BYy3AAmxRE5PmScZFzDAPysAVD1/UXugHIJlY+X8ZfChdSCOl2u2quyNyT8Zb7ff6ZkeKLFM/k1w+b68KGiqw9nF7/kzx++Zd/mV/+5V/+z/5MLBZjYWHhh/6/Bw8e8B//43/kvffe4/XXXwfgH//jf8yv/Mqv8A//4T9kaWnpv/hcfN/n4OBAsXnj8Zh6vc7Vq1dJp9Pq/n3+859nNBqplmJnZ2fqWUsmk6ysrJDP51lZWVEZCxL+lMlk+PrXv46uBz2al5aWVJ/uaDSq2oXJver3+ypVXMBop9NRjLOEk0kPaoBms0kqleLu3bt88YtfpFwu0+l0qFarZLNZVWwLM9zSD3x3dxfTNGk0Grz77rucnZ290KFC0zRarRbtdlsBoul0qoCkeLLlORTgLYoRWY9isRitVotEIsHp6akqAr///vtsbm6yurpKKpViMplwcnKi5rxhGMpHq2maCr9qNBrKk316eopt2+Tzea5cuUI6nVbyZXmu4vG4WnNN03zh/oiaI5FIqGRxWaPgeUeIbrdLJpN5oa+6AF55l4qaQHI/xKf+7NkzCoUCtVoN1w1SslOpFK+//jpLS0vKOiVrzHw+V4ofCfYUP7cU2GTeiJ1B2pj5vk+z2SSZTJLP51laWuLWrVssLy/z0UcfqbGRArqw8ZK1Ei7sJpNJZrMZpVJJgd9EIkGlUlGt72q1mgLrpVJJpZLLdWxsbKBpGgcHB9y9e5dr166p9+Hh4SHRaFR1CvF9n0ql8kL2h4ByUY2Jl1+C/+bzORcvXiQSidBsNtU8dJygP7gUtRKJhJL1yzusUChw5coVVYAO5w9cunQJwzDI5XK8/PLLak8kBcpKpcLOzs5/8XrzX3L897Q+AhTw2cXCwCOnmbSpcezNucExaSa4Ix2/A194DazJKXcPUsx9l2fzOkxtKtqc7GKdFdMh78LKL/kkT2FehZNlmBeh0nS5/X8awskFot+8S3bV46QCzMCLgp4Bf+Thm5/2xe5pMJ0FOuFECfDw250gzjseD3pcz006A4h8YqK3qjTRKMxnpN87xPpCH8px6Iygug7ZbZhHwG2CmQ5QmgakF6HTgt1vgrmD2Tgi/v09lk9HLCSCttp6JyDBWyfQPYThGszSYMwglw5wfTQDLQu6RpASndVAd+FM7zBNR/H0G/T8EWZsAC3IJiB6ClMTyppN/32b2Sb0Vkv4qU2YHMPZGRw1odsJ+lT1YySmEyJa4A2OjUBvQC0LK4kRz053adjHTPMX8Jb+J2gUIDkAYwCRBdDjEFsKWp+NPwSzAcOLYFyDbCzwS0/rUIzhTq/yJLPE0+0Z2uiI+GhIzfaIuVDsutSydRLzBu2JwdTw0OKB5dqIg8ackQ39ZIW+a2OM5ug1m6rRpvCsw6DwkHpVp+GaWEce81QJ/6UvQWopoJedxKetyTRIzKF6Av53obWDPnlK2p1gWjAwwIsHLbxPTBgnITcKWo07WZ8D/9M0cAymOZPe4gLzW78BC59Bv/f/YXnyDnHfo5UMnAVeH0omDF1wUkFIWsuMQrROMT1gVoOkFtQzLBsSCRhVIZ/xWWNMuwZ/Mkoxy72OV9pCe/xNEjOPtAuDOZxegAjgvwOuA6W3gvy+WA3GkQSGtcnsmwdMv2/RNz0q6w6pMRRsE3PFpvFzcLAazBk3Dq21wJO9qEFxGBRH8peD+9D8gzzdSBk3NkFrOmCX8Z0hyemMuJ9nclJHn3u4HkTaQbvzy4sTlqwHONMl6lzhlCZZhuhcIYnGZW2fy5ldKDokNI1I02RuVfhxVsefatAtwANQ8usw6A5v8MNhPQKcBHTncjkVeiYskIA2YXaFLZFNYdj7G/bryqZCNisCyKUN2HnQHZYIS4CQJMKe9+IKgA8zkeK/E/Z0OBzS6XRUQEzY0y4gT2SiItU+z9oKMBEgFfbiinxXNnJhsCUM1vkCgbCZcl/k52V8hVGXVFyR2cs9DH+HADxh0sOgG5630QqDwnBwTrgNVVi+HfYih1n/MDgPs+AiVU6lUoolEjmg3F9pzSbt7MSnKhtIOcLSdJmzwuKKDFdYdtksC0CVuRouKMjmNnwvxA8pQCifz5NIJCgUCspzKXLcsEoh/Hdhe0VYQSDfdV5OLmBbilnhpH9RMsizISGI4e8JKw7Og+6wJzOctRDuDiBH2JYhLJM8h38Rxze+8Q2q1SqFQoEvfelL/P2///cplUoAfO973yOfz6sNJcAv/uIvous6P/jBD/j1X//1/+TzpKgnh4SQSaFRQHK9XldZAsvLy0qaC7C8vKzSw1OpFIPBgFqtxs2bN9na2lLhXZJCfXBwwLvvvqv6FUvbu+vXr3Pr1q3/JCBL1qVWq6WsKEtLS+TzeQVgotEorVaLRqOhipilUkmB+Wazye7uLvF4XLGsIjcPZx1Ie63bt2/z+PFjLMui0WioNUbYdGF1JVhMmHqZJ7LGCtA7OzsDUFYkYYRzuZwKyJJ0dAHlBwcHbG5uKklxMpnk4cOH1Ot1FS4mwHs6nZLP59X3S2uwZrOpxkbGOZvNque41Wqxt7enisdy/2W9EPA6n89V0Nh8PlfzQcZZ+rYfHR0xHo+Vh1zWClHnGIahbDHtdlu9q8KWhGq1ys2bN7ly5Yp6h0mfbd/3GQwGSmEhc0LWLSkaSgE73KJQ13VqtZoa84WFBVZXV8lms+zu7qqiiqjHxK8ta4y8V0qlknqvA6qlp1xLoVBQ4Nx1XWKxGNVqlVwup95pMhbtdhvXDVqVSQ/xq1evKtl4+F0b7hwiafCXL18ml8up94aokD73uc/h+z7Hx8fUajX6/T62HbRXk6JDLBZ7gb2W1qCaptHv9zk+Psa2bZaWlpTkXdpcyrrx6quvKgtEtVrFdV1OT0+ViuS/9fGTXh/hz18j58SYMcNNuQwLQ+r7+5x4KcakWaNAdKwxvnsA0wGrhya216GdbZMt+wy8HrUI3LgCWyswycD4OtgFcGIwPICH70EhDsb1M46/U2H+TgX/s3WMVwNiW/MDSzUDn5g1It12SLd8bEOjkxozXZqi5UZoMxvP1iGSQGudUG6eEZ/4jPslit4io9RDVtZs6q0O1t4RJJLQOw3C0aq5AGyTDvplGynIVaB/jH779yg8/hbJwZDyPZ9S69OeyVGw7YAMnzgwGMOkEfRgnlbAiYOdgvYUFhxIZ+DQh9gZ1DTwezDMDpkZD/Azn8POv4k/+xatpE164lDo+pxFAhZ2cKgx3zTAG0OkBMkkPPwIrf4x5nyIHdvCM9aoDyZUpjNqeVgwYZAMuoTNRtBtgR6xqbUf0u/9W8bLp5DcgkEWljfA+hbsfxPyL0H2FgwvBenkWgImLkyfQMyBSQS/tMZsew0mMWh9l7n1LfSJhV3SmUezNJopiod9UqMRqYJPPgf5PPQScK8H1txEN+YU+iOqHQfHCCzZaXyinotruEwdg0E1CTdehs3LcEyAxrT4p33TCBL33K9B4x1irR5FY04yDgk9aMc11qEwC5wIkwhYGowMcAxoLcAsH8ObXoOFG1C9Gdzzg6+Raf0+l6ITBp+y5fNYkL1XmQX1mHEGnhka41IFtCma7dCsBD3ktRL057Csg1WA/Qx0zCCHbxZbDL4nnyMx77Le8dGagYQ+1oamDt04ZO9CrQj5WzD3NJLjBXxS5DSIEGM0c5kcOMyjYF2b0/oc7H4Rejkwp4H/20wGLonIFwNf+OgE+lVYG8As5qHNY2gHfRYmY3ziNJiT9UckcbDnPvYQZkD3IRz9OwP7qMLSPEqPRe5j4BGnTIoZUzLaJ1zP77N6yWGcgeoAPN9l33qxFfB/6fFTDbpFfiwvT/ELTyaTF0CMvITD7CWgNukiGZbNgQBVkWvLRkB8fWHpq7DbnU6HTqejwHqYTRFgNBgMXmC85ZzC7KFIrwXky+ZVPkdArwC5VqvFYDBQv0RqLmnQ54Ou5PrkM8MAFVDgbT6fq/ELS6eFHRdAJGA8DG7Py9LlXMJs9HmQK8UEaQ8j4O28v14AlYAHGe+w/x54gaWReyvMqxxS5JCCiZy3fAbwAtAX2aRpmuRyOYrFIoVCQfVQlyA92ZRJ/1zZoIZl5DJOcn/kGoQlFtm3gH4pBIiNIFxwkvMUQHvesy/XI/NdCgWpVEqlR4uET84zrFiQeylqCGEtRYUhv8v8EYAtQYICvgUcySZUPkPGSuZTuGAg437evx22Fsj8FJAZTguG54UYmQthu8l/6+OrX/0qv/Ebv8Hm5ibPnj3j7/7dv8sv//Iv873vfQ/DMDg7O6Narb7wb0zTVAz0Dzv+wT/4B/zO7/zOf/L30+lUJfZLP2cpzEkifiqVYnd3VwHwVqulGGTpcTyZTKhUKjSbTbrdLo1Gg/v373P37l3VhSCZTDIYDDg6OlJrFARy0m984xvcvn1bsYUSJDYej9na2uLChQu8/vrrRKNR9vb2aLfbAAp8iOxZchkE2PV6PaXa6PV67O3tqSCwBw8eUK/XFeMeziwQVU08HlcdEkSZYpqmCikT77rIoIVxX1lZYTwes7Ozg67rXLt2jVKppNK+TdNUifvxeJxisaiUBfl8nmvXrpFIJLhz5w6WZalgKwHHMpflWZf1YjgcYhgGx8fHXLhwAU3TVN/0wWBAPB5XNoBut8vR0ZGyJAk7LvPBNE0qlQpra2sKLI/HY1ZXV9na2lJsuxQsJK1brB2yFglDXyqVcJygz/lsNqNQKChPe1hNJezt48ePVTswx3GUbUgKvrJWdrtdNE1TGRStVgtN06hUKlQqFS5fvszTp0/56KOP0DSNRqOhrA5SzIDnRXl5ngTkythks1llJ3AcR6k8JLdAip+yN5AWXslkUr33l5eXefLkCYPBQPVBl8yMtbU1VeyR99LCwgKXLl1Sqgrp+y5rmigVZC4eHR0pNVi1WqVcLqu9xurqqrIuSFFD5n88HlfjIOs/BAoSSbyX7hl3797l7OyMdrv957LN/zWP/xrrI/z5a2SEPmMi1C2dbMJjrh/Q95Y5JoaPQ5wMydHLPPtgjOklGQCt4T6rI4dsbEza95l2Zwz+91Nyy2A9hSdp6HTB+hAef9cgHtFZStmUNIdmv8zoqE5iClMnwFb+WCPzTY/4D3TyFqwnQU/6NE4setYM7bpN+2qU/msLEO1S2n2PN9oTvBGMjCGJ7CMy1RG2CZrmwbgTNCl2Y9BrQ6YLpUXo3Yf930cbgFE3SN57n9WjPQpnLqkJxAzwCmBmQNPALIHhQ2QGpGG+CPM2OGmN5mqE/ZhBxp2waQZZZM4ZzJrQz4C+ArWxT3H3Gae6h3XtizjFL0DvNt1EG02HSB9mFsxjRZxiFdIRcPOQz8G1LfxEC+NOC9uyYKOA5gSS6YgJxAMmtzsGfRykYTd8g4WeQ9l9wsNkHrv0ZuCN7n4Tzf0a2tDBM29C9VpghO+/A6PvBqgt2oO0BsMeuuXgzReDQkXFxV27RttLgO7DzjbTyTV6sQEkLcz8u2xOv0+u4RLJQdWC2XRMPgKZCUwGoHmBnTwRhYoLCy1oRV0+rJTwUp8HNoJ+VpYD2DD2gDGMbhNrfpOFQRPfgXgMMAMv8tSFyRyKHix2g7y141yEaaIGLRdDa6BXTLzyF+DSV+DJB3D//4apvYfZ6NFog1kFywBzGNznQy8oZkSAA7OMn8vDrEM3qkPaw8oG/eBdM3AplAzoJzX6iST+ZA6pCUQnMLfJjafEnsDBHiS2IN+DyTLYV2B8rON/6FOr+BzvQdHoY64dUf3SiFYacjYs+3CWgPfW4PiyySwFvudjxF2MSZAzYGtBmzQnA4VEUBzqH0LKnVLwTLTRAi/j4NDhvl8jzSrL5j0W8j4+MO9C9xOYH6wTn3+GOgmOMbHo4JHGBmIckKXOWPewajDz4cP3Exz10+yySNAY7Uc7fupBt2zwBFhKOyhhVEVCFpYGy8ZLkjoFUMtmfjabKbAkEkBhdCS0JewRk3C0k5MTLMtSErkwSyvnKxK6MBgVYCF/J2y6nBM8918Jiy0blna7rUC8sAjhMDEBdGFvLjxn4MM/C8+ZawF/AjJlQyJtYmQTLNcWZodl0xTuRR0G+mGPMKA+SwC1pKH/sKR2KUr0+316vZ4aUxnv8LnLPZOkYQmok+8WD+JwOFTnHJaqw/Me5AIGZc4Ui0Xl56vVasojHy7YdDodBbzDgDsMBsXLLKybhLWl0+kXwKwAd7EgyCY2zBDJvxVgI2N3PlBMgIz0WpbNrmxy5VrlvOQeSuqxfLZ8rxReZA5J31iRaMrPy7hL26/wGIQ3hVJoko2y/ArnGYT9/gLKBchL0UkKTWG1xfmi0H/r47d+67fUf9+4cYObN2+yvb3NN77xDb785S//WJ/5d/7O3+Fv/a2/pf48GAxYXV1lfX2d4XDIs2fPyGQy7O/vo2ka6+vrdLtdHMdhbW1NFRDl3uq6rkCUyI4tyyKfzzMYDLh79y6Hh4fYtq16QxcKBeLxOLVaTcmBBew+efKE/f19FTA1HA4pFAoYhsF7773HvXv3aDQaLC8vs7+/rwqJlUqFQqHAkydPODk5IZVKUSwWVUCceKEBBbT39/cVUzudThVoAVTBQVhOmfPRaJS1tTXFNEsQnHjHhS03jKCnd7VaZXFxkWaziWVZuK7La6+9ptbOGzdu0G63FVNcqVTUOcj6VigUSCaTNBoNdnZ2OD4+Bp5nbsjzImvAcDik1WoxnU5ZWVlRihnxnCeTSWq1Gu12m2fPnqm8ENd1lUQ+HEAoLK6s6+PxmM3NTarVqmrFefv2bT766CP1Tp1MJur9KEBZChdScJTi2bVr15SKQQ7pZT4ajWi1WirPQwqW8r5pNBrM53MKhQKtVouzszO1nheLRWWdikajvP/++xweHqrnWwLRJpMJ2WxWhUFKWKppmgoIi689bOORd4iAbJHrZ7NZpXyQbgDxeJyHDx8qOXosFiOdTmPbtgovdV1XFaWkiJPJZNja2qJSqWCapirkyzNZKpXUsxMuBEsuiMwRaWcnhZNcLke5XMbzPAX8RXEhiga5jlarBaAsaWJxEIXc8vKyCm/7b3n811gf4c9fI19iizPGPHVS5E5j3E94jONDNq08XdpMMFhihZk3wyfBAJ+Gp1P10pScJD4WrnebwcMpk0+g8BA2q3C6B2f7MJ/F6WkmUfoUjD7FpEGxCrtJsEbgRg38aIzxY5f0n27i0qSZbzOcQ2FkUHPTNI/6JO7ZDBoHRJcHXNsbM2/BdAzVlTGFNXi6DydPMnS2JwESS1cglwlowXQV/DQ09uHBd0ju19l6BsUPTaZTj0QxUF5b1cBja8yD3LW4D0kHRh50k+Bch+EUzvJx3GQBpnN8Y0JvGvR4HnUBHRwnAHT+ImSbHpXuDvfcKINbPw9am77pY31mykp7xDAXw8l9AcoJiNcBF7xnEG9B4RKzZJtE45jZTpP44ZxoNwCcwyyQgJEZhNHF0qANHLpNGIw1nI04RBvg3QPew58u4g9+DgqfgUEdnn0Agz4MuuB2IDMHy0WPjDF0Hd/s4GeSYL4J6dfBqcFHOnx3BWJViA+hGsdZNDipf8iO5RMba2xPLKo+mDPwgFgC4m4AlMkEIV9nI41Dv4oX/TI824IDO4gaHwCREXgGZCw09zaVWYeSH/S+tiJBUnk6AuUGxOfQLkCsBZkzKBoup/E4fjGGO7JgkIbIIdz9v5A7+CaJWZOxC/FRwLxPJ596m6cwnwYtyInD1NTx88VP9fI6VlrH1Dz6hoFtRNAjNiPDpZ3QmUZq+KPlIPAuawRhBVGdVm6ds9gxccvn8bsGccenEPEoLcBwHsM+9Bg+nuHEfXovnxF9CdpLoDkB6D4owtEWHFWizMwkkekQY+pT60LFgUYJrFgQ3tf0YWIHxY3ODHTPo4DNmAgNEsRZJsoSJnPyhVPyK3DigtaByVMNbZ4hTQQbGxOXCFlsJiSpMyfKB/4F6r19Xnp3wGRSod6/yDNMJlSBH/zIa9FPNegOJ1mfD/wKg14BUmGvk/jYBHyKLFhkrgLmzwdshdOaw2FbwvSKnC/MDoelyeFCgYAUAbYCMs+z72FWVNgPAV9huVqYuRPWMOyZliPs+Q0z4OfPNwxShCkUICvgR1hpYXjle4S1DZ+HjJnclx8ma5dfwkRJcJAUIMIsZpjBl3MP+7XFnybpvLLRFZAf7s17PrxMPOXy/fK7WBBKpZJiuAXkC6MqBRABqjKOcl+kQHHejx4OOwvbFlzXVZsiYfjl/8s8CXu45VrC7FF4UylJuucZaGF4ZAzks+X/y/fJhlDaPcl8kUJUOERNCjThhGqZF8AL/nQpzshzJwUUUY0I8xn2hsqzHJ67cv7hIk84cE/mz18E033+2Nraolwu8/TpU7785S+zsLBAo9F44Wek2PbnMU/hUMfwIf2rJZ1ZAqPOzs5UKzBN07Asi8FgQKFQQNd15emOxWJks1lyuRztdpvFxUUikQhra2v4vq/C1+SZTqfTqqey3BMBKWGVhQBVx3HU/fzDP/xDUqkU6+vrqsjT6XRoNBr0ej0SiQTValUlM4u0WgqgUjwSBl2UM2Ebi4R0yfNbLBbVn9PptCpatlotNdc7nY6yvMgYu65LLpfj9PRUKZxGoxG3bt0im81y/fp1Go0GkUhEyeL7/T7b29vKU+u6rmqnJr3RwxYQKSTlcjkGgwGtVksVGiRQUNLWFxYW2NrawrZt1S+9WCyqtG8Juksmk1QqFQDFdEshcWFhgWq1qvI7BNQBSrIu9ikpTpRKJeWfXllZwfd9NjY2qFarvPrqqwogy/2Soou0IAPU/wNUocFxHNWBQ2w8YtMRq4NlWezu7irVhvydFAIkI0KKFlIMlUKNhPzJWGezWVKplForwwUJ+fNgMMDzPMrlsiq8Sis7y7LwfZ/FxUUVBLe+vq7GvNls8vTpUwaDARsbG7zyyivKfjEcDnn06BGnp6ek02l832dra4urV6/Sbrc5ODhQbLgoIMTf7fs+q6urTKdT3n77bSqVilIPiJ9d5kOr1VI2MFlrZb+zs7NDKpVShUsp0vxFHz+J9RH+/DXS55DXSNAhwQib2sznWQQeaSPGzMj7Hus4DGnRJcoKGaK4HNIhwZy4fkj2YouCAy0D4n8pwLlrKfBLcPChgxWBSRoq3SRpzQUDjmyI6eDqGmM3QSzXJ5McEnMdUjEY+eDFXKZuD33JZ8UB+988JJrSiWsas6zPzILOXKcR9eifVInPCswXjmF9AYxlSAN5A2LlIAm89lkwN5i1/jna8AHzdhotNsJdtnlSDMCXuR/kuPlZ0EtQzgeBU/sjnUk6QmY8I+1PmbfOmLs6jqkzantkxuAkYR6HMtBz4TQHqVNYPvZZaz3i4cjAeXUbP1vDudaj2/gQO1qGxVW05h38QR22bmGOnpI7fZeO+zn8y9sk+qekOiOiiQDMRt0ggG6sQycK7Vxg3145DS65G/Px431I3QatD6MvwJO3wLsKF+fgPAtSwospiNnQHxBzOqRbHlbSYFZZBtbA3IDkZ+FBJtBFD/KBPD/qBBruY8CMMIvF8LNjJoMYzTGU9UAGnctAKQftHhxX4Xg1wtirMNU/i9e7DsPXAtP/fASGHkTDzxzQBpB5RMX+iG1cJkbg+3cALwIZoDqH7g6Y+WBuxRKwPfZo9YbMN2Mwd8HySe59nYXhCMdxic0hZoEXAz8B9CBugxMJCiwJOwh1b0c0SCcDycP8iHjUZajpzDJlSObxIkG/L9tcguyrEN0CwwazGxQOfLDL19lZuMNrF6bkHrvYHkwfgHEAi6kpk5rP4CXYj+vcSa2hVWwWm8dcfT/IvPvoC1B/JYnrxYhPxtwcuJTfh9IDKM3gYAsevAy9K0FXt4UDWM1A04Phko1+1ET31vjY7BNxfMpkyKQ/Yuu3BnhXYDyE9DBgzIfM8JhQxcXD4BkLOKQp0uUQg2YsgjkzuXemMaEApPDoUcSi9WOsaT/VoFs2Xb7vvyC5DYMpAWZhWXN4M2bbNv1+X2244HmP4vCGPuxTlo1l2PcsAEn6Y5/3fIcZTpFyi5RQvMHy4hevVpj1k8+XnrGnp6cqoCssEZdrk88X/3MYmApQDvtyw2Fpcsj1CvByHEeBNQF0MrbC4AsDahiG2sSIBFHG/7zMOwwgZSwEIFer1RfC5KQaL6ApDDQFKArjWywWicfjlMtlkskk5XJZbfoF5HU6HbU5E/Agnm3ZmArDImnJwriJv1UYCQn2a7fbKvk3LAGXQ9iXcA6AbHCE1ZV70263lR9cgLyMZ5gRk3sYZoyEcZZrEQAuTLd4+8LgOKwWkH8rmxWZO5LWL+35wr7x84UAAXViBRCvZS6XU3NM5nVYOi9gQLythUKBUqlEMplUvYjDhS5hvOF5bkDY9hBuCSRFlXDB5y/qODo6UoAW4M0336TX63Hnzh1ee+01AP70T/8Uz/P47Gc/+yN9di6X4/LlyxwfH1Ov16lWq7zzzjvKCyssn4CysNInLGkWRu709JR6vY7v+9y6dQvfD0LQ4HkquWRLSKFEUsDX19eZTCYqeLDb7aoiZzKZVMoH6d4gcuwwUF5fX1fBU5KfIAVWKazJxrvX66kOBhcuXFAg3zSDNl/Sv7zb7ZJMJlldXaVer6s2lKKAkjkpcvzl5WXVy1yewXa7rZjqt956S61bmqapLhWGYTAajTg7O2M0GjGfz1lZWWF9fZ3Hjx+ruSvAR4qc0lawWCyqVHnx4NbrdUqlEhsbG8qj7TgO+XxeFbmi0egLdhEBYNVqFV3XFeMt3y3vUkCN8XA4pNFovPCcZzIZptMpxWKR9fV19ZwuLi6Sz+cpFArq/SO2j2g0Sr/fZ39/n9FohGVZ5HI5td6JSkUAuYy5tNoKr3GmaXJ2doZlWcTjcVXIFjbaNE01D8PMtoR6yropa5oUjGSdlIJTuKAq8vZms8nS0hInJycUCgUVVJlIJFhZWVFJ5fl8nlwup54TKVBIQF4kEuH09JS7d++q94TsISTAsNvtcnx8zGQyUan7vu8r9UKj0VDjfvnyZXzfV8GJ8nx0Oh21zgr5IJ0HRKouBIRYO2Q8/qKP/5rrI0COIy4T4YQhdTy+5JWxbIdDA9adGhXiRLFxcNnVmsx8jSw+FjNs4sSiM3pbPpVViEzhJAKtR+BrcOsL4LszOnc1OEviOSPS9ozOGYx6QBS8hIY2hM2sw/qtYzo+lDUoDKB7CrN6lLQzJ5HxKe8bMMgy1UakxmPSYxN3nqXTGjD3x7A4IrKlY0eT4PkBXW3kYO4FjZLzSxCzSS2M0ec6PXRsz6fX0xjUfNamoHcDYIsFgwuQy0G8C4mkRm81w7yeINkbYsTAja9iRW1G42My+GRscApBMrWbhFwPEho8zkWhrZP4wUOGuPDWLUjl6deiwAL0n5IdvM/QqOGNBkTrRxStOT27i7t8nf76IpXHhxS0wFMcz8M4Bx/bJl0NChOHhVMoWkEY+elGDl69CKvLsJeFj1+Fw00oz2DQgmQXclGwo+DrEDVx7Tm63sH0YeZFoHgVKtfhOA+NTzXVGhBNBb/HR+ADeglHr6CNHuE3oO5X6Hk2y06PSBGOojGay1kG6yn85EUYvwFnV6GZB70ANTMITotEA832LAq1Hsbkj7k46xIdQS8b9EifOOD4MBoH1oTIGJam0L0IB2lIjcDzDXBX0SN10mad3JlPxoJmHJJTWJpDfQKOC0kD7G7w1bE8+CZ488DugKODaQEWUy2CHVuD9BrEtaDBtulB7DpkX4JYLtCn23VITKA5hGaT/c0qk0iDJX/KQhscCxI1KLzhYxVhdxmOcxp2rkDEb1DpgLMDZl8jkQE3UUAzIyye9bj2/9Yo/GmSeW8CTpzc/TlXsw7fW9awu3DlmU/xSVBPiUxhmOyyaW0Rd6BNixQRClf7+D8HPaDWg1wBRhd97NMOnZmFS5omUTqMWWJCDZcZHRKzCHnWcfDJM2NEmwKwQYLHP8aa9lMNuuXlK6ArHEgVZr/OH2FgKgxtGJyH/40wrFL9F9l0mJE7/11hr7KwbOe/X172wjyKDzYs1w5Lw8N/Dv9duIgQ/uzz1xr+/Tw7Gma65aUu5y9APiy5Dv+snKts6OQ8BEiGvb9SQAi3eBPwJAmu0q9UPHwC3KXIIeMbvj54DrSECZL0WOkVK2Mt5xAOspPzFgAdlraL3FTChMQLLZvjMDMdDiGTOSWFm3DxIzzXzo9n+GcFAAljLl5/AZhhv3ZYSRG+p2G2WEC3SOHDlgo5Z5E6yriEffXy7yRsSsYqLPEOSzXDLLMwK/LsyH0TIC7y1bAFRELh5D7Kd8p8CoPm8PWHz+U8+y3KD5EW/6QPy7J4+vSp+vPu7i53796lWCxSLBb5nd/5HX7zN3+ThYUFnj17xt/+23+bCxcu8JWvfAWAq1ev8tWvfpW/8Tf+Bv/0n/5TbNvmt3/7t/mt3/qtHzmZ9/Lly3S7XSXZlnAoQFkLdF1XxSEJ6lpYWGA4HHJ6eko2m1XybykQCRv2cz/3c6prwng85vr16wyHQ05OTnjllVeAAPhfvHhRtTaSeSyHWAskETscMJVIJNjc3CQSCfp9C4snz4qolISRfvbsmfq3Dx8+pFAoAAFwlXmUz+dVEUYKbbIWVCoVyuWyav8ohboHDx6oRHMBMwJkLly4QC6X4+joSHUqkPGNRqM8evQICNRFAnLK5TKGYVAoFFhfX2dnZ4d2u626VsTjcZaWllSLLwFRtVqNt99+m3K5zGAwYGVlhVqthm3bjEYjJZ/X9aBftzzzAnBlbZUuCwJ0BRAD6v6Il313d5fpdKrug6xnvV6P69evs7i4qIpwokSRAoMU7oQ113Wd/f19Dg8PX5DPC0ssv+LxOPl8XtmfZH32PE/dv1arhWVZar6K6kUKDOHvDHeCkGKfhIxK0ULWUdlTyPjJ+1YKh7PZjGQyydWrV7l+/Tq7u7scHR0pK4xkfEhLr06no9rISW9xKXI0m02+853vqIA6YdwrlQqO4/Dw4UMcx+H4+JizszM1NmEmXp6Xra0tEokEnU5HhQVKcUEyFAaDgXr35/N5arWaek9J15Ner0cul1PPyE/6+O9pfQS4TJ8uUfYp0mJKnhE1L8XUMykTZw0dHZcGE1xGnNLijD4lFjhCJ1ptcbUEH9/VaL6XYDwD3YF4aoZvunzmLejVdTr7m4zzu1yvTjjahQ9PwXpZx8eEnMnZRYPluktxDH4b5mMgC7RM5rsJ6vqIhFvFZcg8HiRYp32NeLVPftvl6dKI2YaPV80EKdjGGPQEuNkgacz0odvDePp1Xp4fkvR8vp8ckll2SAOjiU4zbrK4PGdBg30/kEHPoj5bPtRsl449wKnE8coaWhywc/iJNEelPscJDSYascycWTZDzBjyUmfCzIXRhRh2LkH5qAWzHYa9PLAI6esQy5F99C+o+ROsaAbOfoA9PWWnfAHXfxu0a7iLcbo7/y+0TgcjEagATrwCw6XX0Or7GPvPGD3y0DNwupak8/avQOrn4PtpuLMQpIpl5oH5e9AFdwTeKiSLEOlCJIIzKtKynuCnVyFVhWQOSMOODl0vYMSHEZgQ9M7GDmKvXYvoXh93lsPdeAk/Emfq7nOqDzisbzHP/a9gOxn4xZsb8DALJwmYGVAZB15uNwpoQY9xXQfnMdv1R5SBg0RQGxhZQe5bzAfbD0LsWYeduc6+v8jMM3H0ffBMyN3Cd2YUW39GfgS9fhB85+oBXi7OwEuBYUB6DLoWhOJZevAzXtYAHBh1wLaZl96Ejc8Hcel0AtO3WQzS46LxoBJgWzCKwEiH2QMiiffwrpocX/8i9Yt1Luzf45WRQywJhyvwtABnCR1f91jrfERt7lE7gOlpjpOoxijWA2wiLZuVP/Lx/v0SZ8M4WnyPrO+zYGnUduBRyWfugf0MHrwP/tESCV3HuH5MpP8B3v46Jim84g7GG2OGyUBWbqSC/uXu58F8NsTcMTghwg4WEWYsMKeQ2GXhRod508TZm9Hza7SZ49EiT5IY7o+zBP50g27pES2yK2EsRXYe9rAJ2BF2UMChSHfDUmXpiSpV9nCYk/S8Fn9a2OMqoDksXQ+HhMn3CqArFouKuRPJrzBwlmUp9lkYZwFf4qkTACHXAs8Tn4Xhk/MOA5lwWxApJIQLA3LeYXAknx0OLgsnn4fDwKQIIoWEcBCXSDXDPmM5ZJObyWTY2NhQgBlQwXEC8uBFObzIneUzwj47YSxkHkjQkLTvEk+iAEy5N/F4XLVJEk+gtO6SDaWMk/wuQXnyuWHQLTJI2djKfAxLtkX6Ly2tpJexKBrCQF4KQfJLzmE6nao5YRhBu7FwGrywkDIfpH2PtDMStYht20rZIMUFAayyiRXQIuBZnh8puMh4SM94kZuKQkXmjchgBQjI3JFkePHHyj0Iqz9kTsgcCytIJOFcvkeY0Xg8roo4P8nj9u3b/MIv/IL6s/gI/+pf/av8k3/yT/joo4/4l//yX9Lr9VhaWuKXfumX+Ht/7++9wCr97u/+Lr/927/Nl7/8ZXRd5zd/8zf5R//oH/3I55JIJHj48CG+71OtVhmNRspHbNs2165dU+ufzO9Wq6WYwxs3blCr1XjnnXeUlUXXg/Tog4MDEomEAkTif7Usiz/4gz9gbW1N9UN+8803efr0KXfu3FHpy+IVl7CoXC6H6wa9haXFUywW47XXXmNzcxPDMJRPWUBFuMAo3QM6nY6SZS8uLipP84ULF3j06JEKrAq3DAsHgJmmyY0bN1TrLElKjkajDIdDxbhms1l6vR4nJyd4nseFCxeIx+M8evSI5eVltre3lb9Z3ku9Xg9d17l06ZIKWWs0GhSLReB53sH6+jqFQuGFwD8BzPKcLy0tsbm5qdLD5XmThGxJrQ7nN6ysrCjQJhJrQL3H6vW6KmScnZ3x5MkTVQRbXl5WPvJEIsH169d55ZVXVPp9eG0SlY2s05qmqedtd3eX8XisQsDkPRdWGsk7W9p49ft9APVnSTyXd8NoNFKt6GSd6na7+L5PrVZ7QUIuBSMp/pXLZUqlEr1eT9mZZI0UBQ0EhZtGo6H85o7jcPnyZd566y329vY4OjpS7xF590i+ixQU5f0jNoFnz55xdHREPp9nOByq/UU+n2cymagiUr/fV9kfCwsLLCwsEI/HeeeddzBNk5s3b3Ljxg1VGBB2XSTljUaD2WxGvV5X+QKe5/HSSy8pKfqzZ89oNBqUy2VVcBB2+Sd5/Pe0PgLE9SkPvev45KlwzBiNHHFMTqkz5VVSuDSZ0uOCb5CgzQEOC2hokWdcf8tiMQ7f+jjCoL+IpXcxcl1qM5+D98BZAfP6BP2wRSTrMM76aN/RSRQ9WI1CLga6zuTnoliPJsT+HdijoA2Xq0M3NiGZm5OemGRHK/jsYuZ69DUwijaNbY3Hn1mlu5HCMPfR+nYQNZ5KQiwZNLPGCWjMdAovdYFmJ8lWzCKfsVlaBm8CJ5kq/QsVjOgjUu6celLDTWjYvs9Ig5IDy6dz3Nmcmgmjl+BxpoVtZ3ELCXjdhEgFx3LASqHzjLPshF4PoidDTG9E92ICMzYl8ugT7OU5bG3B8Jg1v8Xc1nHdKPSOsbUKXPwqdN8MQGrklHkxh6F1KPiwF00zXP8SJG7g20WO5wb4bWK5FnZqHXZ+Dg4W4LAC7kYQnZ23g5SwNIHhfGhD7wG4+0Ev88wEP3MVln4RzFwAIPfy0IwEfmvHgEkU5uI7n4B3BrN32XabtPwszeUqjPow6jFObEHyfwP1N6AxCZBWP/CNY7igR4A0OF6gG49rQDy4Vwd7VHtDYoUgpTtlBcHqo2gAulNm0F+6Z8JhPs608jJa/4QZ+3iFa5B/Gf/sMdEWLMZgmIPxOEiUN2cQ1YJpMQrcYeQWQYsG5HYvozFPFIP5MuuDnYHym1B8DfpjiC8HvcPMKERnMP/UvI4ZGKvrT0g2v8XVaYuWF2H/0gbOz9/i6ZLN6PgRy3MHPwLDBIwrOlnLZc1yWZkErdPdGTTyU9o5wOyTe+KQ+5MkkWEVS9vDTHr0CxPyC2CfwMbvw9yC0yFMk+Bpcxa8VVbyJ/hvDvj464+JuhrJN6for0C5D9EOGBU488G9ANHPzdnb6XFCDDgjSpUzUqzGR9xa9xj6c+yTfXZmM5pkKDOlwJwonR9rzfmpBt3hTZcAijAIDr/Az3uH5e91XX/B632e+RWAISBDNu7hDX5Yuhtm2OQIh3CJ/Fnax4gUOgxghHEUye8PY0fDzPV55jfMCIevJyxvDwPW8L+V65Z/L5u5sL88zLgL2JK/kyJBmP0X0C/nE/YJyz0QkC5MjBQGwoFewsbK+IeVBjIG4UCoMIiV65cxPs8chwOMhHEXQCDnJEBbALycm3y2jIGcWxggh8ct7G8Pj/n5Aof8+/Dm9bySIDzvwgWYsAJCNpHhcZd7KWMh7ewkoVi85GFP+Pm5LfdTxl7mSFhFcd6/LhvjsDoirOiQ6zw/R8K5BDIe55+FMMMeVg7Iv5HPC6s0ftLH22+//cLzeP74oz/6o/+fn1EsFvm93/u9/7/P5dvf/jbZbFZJyR8/fqw2/7VajXw+rzzacq83NjZIpVLKkuG6rmIrhfmTNWt3d5d8Pk8mk1Ggrdvt0u12uXPnDr/6q79Ks9kkkUjw0ksvcefOHRVkJt0CxLcqCemtVoulpSUWFxfJZDL8wi/8Aqenp9y/f5/T01M0TWNra4ubN2+qAqVkehSLRVw36MV87do1dnd3uXDhAhsbG0QiERYXFxVgnk6niuEXUDYcDjk6OqLRaPDmm28Si8VeYDFd11UhWwIqhY3c2NhgMBjwwQcfMB6PlXRdimXZbFaBp6WlJSKRCEdHR5ydnane5wAbGxtKhp1Op1leXqZUKjGdTsnlckreLknXouw4Ojri4cOHqnuFsPOLi4tsbGyolkuyHsizLMqFaDSqCm2TyYR79+6pRO7T01MeP36sbB1LS0vcuHFDeaIBVdwA1Fop1gIBqZKOL/Ml/O6Q51bYbVkvz87OmM1mbGxscOnSJXWenve8faYocyToT+a4yPxlHQi3YTs5OSGdTlMoFFQxV2T9YXm7BLR1u10ODg744IMPmE6nqm2cqLLkemVtkcKWFNClGPn5z3+eK1euMJ1O2dvbU8WfWq2mglHlnSXvRLEk5PN5dF1XEvm33nqLYrHI6urqC8WqsDpga2uL999/n/F4rO6VvEPv37/PfD5X3Qo2NzeJxWJ0u10Gg4EqBv0kj/+e1keAr3mvEOMyG+ySocUTyswYkcWmQoZ84oBIqsVWp4brmZhMWGeFjFankjolfejj2RBL2GgMiHkJ7J5O3IfokUXzP0wp+D6ZaAOz4nN8AYZHPuk/MjC+qOP8CtCcM0+Y9G5C5h2YNqAUh3EX/ITH5S94dB7bTO+dUYkMeZo1OLkS4crilCfZbTq/8L+F0+9Rvv+EzKlLX/sDrM09xjd/DaIXAhm0ZsPUx099ln33Ghcn7/JKI87DzIz+yz76xhQiHp3FDVx/l5WMjTHzsftwNIGFKFzUoDEMJLycQORzXex4F47SaN4xhmnhuDF0w2Yen3CQzuB7DouPJji2T3N9EX9gsfhBncH4EcNsEq1bJz6Z0ZhnIZtAGzj4kyKka7Bjw/ApLNwlk2qx7kIbDWsjCZFeYBLONtFM0Cs2M6sEp5+HRxcCKjeSgPgEUh5c1qC6Ayf/AeZ9GMfgwUMS00PcRZhvVKC4CHYyQISPIrAXgbYeyL+1eMBI+yPw7CCpO3OHbOp7RBIOnHYxH38HP+vg+nlo/mUYvh70W59EwABcN0hEjwGkghSwkQXJTPCZtgPxEQn3mELGIZ6EJDC1YebC1ADXB3sauAdmJiTcMfGzr+PNXAYbZbyNm3CSRetGMDwYzgOSPd+H8RxmZRgPgmGJ2RArgF+FjgHoEE1qjBMpzFGD3MmAdupW0ADbSgIOxLIw/1RKrn0q0Z+2gjS7zn1ih3/I1rdb5I6hdcGH7ABSOk7uFocxk+nwARv6nJIOhYZDZv7pNQ2C3uuRa322Pgf+ZbCmM7Y/gXxdx9dPqZkjBho0qxCtgX4E+Wca2ijO7sxkpOXIMUaPPGPyvoGh+Vz5xRluGWKrkDYhfQqpk0/rBmlo5CH2tgt3HuF8EscnRrBjnDLvJ3nw7yPMbZ2K0SejN9j0TGLk6eIzRAdOf+Q156cadEuaMjwP9BLGO7zBFjmXAJHz0uYwCAqDcwkHCsuuRRoplXTZsEgPWwlzEf+xaZpKzifMq2w6BFQKsJK0dPH8ySZH0zRVmZfrkWTRMGMaZlNFahdOyD4vuwv71QVYywZFgFrYMxwuAjhO0Ks7zGCLB0/AupyjXKeMt9wXkYGLTziTyVCr1dR/A6oN2tHRkeo7Kj5JaaEjskf5PgHtIk2XDZqMQ6fTod1uv8DeCftZKpVIJBIqvVVYhfC4CAAMqxlEIi2sRjgYTKSDEvAk5wEvtiSDF1UGklorgEcKIDKmMn7CnEibMSkKyC8pHoTvt7DEwmrv7e1hWZaSycpnVCoVJZWNRqNqUy/XKwA3PH+kCCCsu4yLgPrzsvrw/Do/zuGcAdmghyWkYksA1OZXxl2ej3DhKfy5/7nN38/C0el0VIiasHjZbJZyuUylUqFUKjGfz1leXuajjz5S3tB0Oq3YNumhLBJeuUexWEyBQUkjj0ajKoH54OBAAeJ4PM7Nmze5evUqf/Znf6aSz8vlMul0mna7rYKwrl69yq1bt2g0GqyurgLw/vvv8/jxY87OzlhaWsIwgj7LtVpNFfqk/V+hUOD09JRarcb+/j7j8Zjj42PlZZYQKZHOyjotuQEPHz7k8PCQ2Wym+lkLMBeZuoSIpdNp1tfX1VyrVCqkUinOzs44Pj5mPp9zeHio5rQ8b6ISOD09Vc+LYRisra0RjUbZ399XagAJ+czn83zpS19icXGR6XT6wtq8s7PDnTt36HQ66h0VLiqHC1yiNMhkMi8UCMNrmuRHZLNZOp2OKtjNZjPy+TwvvfSSesel02k6nY7KXxDmW9a/bDaL67oqQG4ymZBMJlU/eCn8SLFPWmpJ2rdYTprNJnfv3lXtveLxOLZts7u7q947EoyYSCRU8SWXyylbAwRqKvHui0d+OByqd5QAcMMwsCxLAftut6tS5ieTCa+88grLy8uqlZq8x5rNJsfHx4xGIzKZDOl0WiW15/N5Njc3cRyHTz75hF6vp/rQy7gfHByws7NDNptlcXGRzc1NBfpl/u7s7FCr1ZR9otvtqkKH67qqVZjjOGxubvLqq6/yrW99i1wup4gCkbpLW0DJV5Dig7xbftaPHdIsYFBiRoI6SdpkWKTECpX4LqXXWswnPstdk48JuMhFo0l6/Yy87jF5BK0TMLo+C/TRtDKaX8WgR0xzKe3A1NWxTI287uKsQmfDJ/PII34ww/IiYHjY8SSHL0+4/obD9HGM+wd5oq5FdXmEnwGrDG7ukGbe5ennXmH2eopP6h9grV0Hf0Tlzl2ufOIyfQY3shZd+z2+WVrBq10OIrONaBA9PuwyzqcZmAaX0dnp6lQsl/Jxjx1vwrwYZyHlsjCD/ghGBJ2yrClEE4ENuT4H+1sGhfkI99IJs/kFopMulWgXaxIMUi+fwS+tYKaPMNYgYvuYdHEqK7RTDol6i/jxuzD36B36zIwx6M9ITPswnTE+eQLZAhTvYMT+jMxgyKFhcLJWJhKdU9v/NuOogeE6ZGdzmnqMfvc3of1roC0ESWbjaHDdm0DtY4zDf8Vy5z2mvk9rXsUzxugRF0c3Pu2DNQajGySNtaPQTsPw0zhtwwl6qsV16HlQHGBkH7OU6TLswjTqs2zUGcwMurOfh8lr4EUD73MmDXQDgGqngtj5tBb0UJ9PgybnEzeQOGRPiMXr+Do0JzBLwU4+SidSIGp1yU7naHYwxuNk4M3eGM8pzKDR7PFk8sfYpRv4zhqpuIFhuxzs6SRHPqR9bCdoBxdJgaeBW4FRDk6SMbQZoKUgUWax/jEXmh5/FluCwib0JxD5tPgwnYOhBb9GFkxPQHeJd7/PxYdNjHcTHERtTm6VYPllyGWDn4tfpxmN47fusXY8IjMKgK+eBmMf5rtgvg7WFgzcJIn7M6rv+xQnMFpp4JZ8+ocaRx9nePIQit6UpaU5m4sTvA+SdLppiuUm6dqMnUOT2l24mA6Y/lQXvHRQU9F60NiFqQZ2DWZvweavtukfPqU+eIkEE5bYx/HidKdXSTNn6j1jrvUxaKCxRZwMCbLA/R95zfmpBt3CIsLzCn6Y5ToPugHFZoaDZaRyHK4Qhz9DNukCjiW8SYJJ5DvCaernN6gCJEUeez6wLOxnlA2eMEvCGobZXAFUYSY07IsLs9zn2VI55/PsaliGLj8bZrjl+89LquW/BfzLuEjFXj5HQGMYdIf915JkLP/uPDAUqV7Y4yznfD5ULcyMhtll2XjK38l1hmXXAtjFSxzefIRZXvldPjfstw8z1fJz579XPu88wy2/hwsl55nZ80Fn51Pvw3P4/L0OS7El/E2kkLLRFHn3eQm2jLUw5AK2ZV6GQfQPmx9hNYnM4/O5A+d/hRUWYRtDeNyE+Q+rCc5/X1gVcT6j4GfxEEmyAOfl5WUymQzD4VCFZI3HYzY2NlRB79atWwDKsiP9tWu1GtVqVSUeS6K/BPuFg6j6/T6PHz+m0Whgmqb6/+vr60p+LMxoNBqlUqmQy+W4evUqv/qrv6paOb3yyiu8++67fO9731Oecimq3rx5k0QiQbfbVUnUe3t7ygpxdnbG6uoqnufRaDRYX18nkUiodVsKccJOCmCTRHMJqhSmdH9/X63NxWKR2WxGKpVSPYMdxyGVSvHaa6/x4MEDJXcWFv/o6Ehd5+npqVLUSAFO2O+DgwO1hgyHQ3zfZ2lpia985Susra0xHA5VcbXb7fLhhx/y/e9/X7WA8n1fBYnGYjEsy1IheYBiNGWdSaVS6vpF1SIMuW3bqud1Pp+n0+lw48YNZRkS5rVUKikLlLz/BMSFZefii5/P5/R6PVzXVS3gpEWnFJzL5TKLi4tomqaKNMfHx8o+MJlMKBaLLxSQpdgu7+rLly+ztLSkQLhYuD7++GNluXDdoItFKpVSoXWiepBwM9u2VYCpFBuFwZasC88LggSlt7lt23S7XTqdDvV6ndPTU65evaramO3v76vwQGmxd3h4qKwR0WiUZrPJSy+9pOaZ7/sqfE7WMQH8Evon7UtbrZY6xy984QsMBgPu3LmDpgX9v+WdKgWosJxeCiHD4fC/3WL1F3SkSZEkRY8SUS6yVHxIJn7I8HSbpBnFiPqMD3Q2XB+bJHpiwK032rAK3iFEl+D2PowHJarVLtXFE+z6KYYN0ZhPKgpTw2PsQzIGXQ36i2B9oMEnLjSmYMZh4jNKm5ytO4xTGs4gT9QcE10OgrOjNRj/gsO9q2Vmv/om2GMGqRK88iV47xtkvt6g+cRkZDkkczBOgf+ZGCRT0JuDGQOnDif/ES31gMamR641ZsME7xF0qnDp+oxkYsZ8HoR7L/lwNAVjGJDF80xQdMiXwJq4ZHYh2mtzuujhGjO0PVi0YJ6CeWmGPWtgpMYMqpAHSk6PejLP9LUKzoMhhf6M5Czw2OYnNs7RKWYFyLkweBdWOxB9hD+yaHom9lIeP5Imd7BHyXFxPZPpIEXLrTKI3ALnfw2JVUgMIa8FcdyFDhS/S/b+/5mF1lM8zcf3oWCd0DMjjKJxNGuG3qrjaS5oCRi/BmeXwfp0n5ZIQV6HsRP07DIjsDGCrQ64kGlDqQbjvM7J/itw/GWIxaBowzBPED9eDHqvaRPIRIIAN20GOSOIEJ84gew8MsFN24xHgeJhHIFRMYqbKWNbYxjOyY+gEAWvBicLKT7WIry032Oj73A2rNPJNsHKYY5TLGQH3K4l6OpJ0E00e0ze6GMZcJDS0V8CfSmGnbgKbgYib0K2SvreA3TfhMpmcP5jC9LRoApjnYDxFIZdmIxAG2LYT7jcfUp1D+qjNL1EH89zwRrDSgmisaCYkc3SbfbYtB6BDZ0eXGqC/QEctzW0hM9ZJsHE3qK6/4xyew6aTjIRKP4PJklak3XaRpqJG0FPfMi1v9RnfTimcv8R/jUfqwzZLQd9H4yva+SeQP5/8tEKYB9D9zE0HkJrlMSLRbGNPhtf9bm5c8RH37DQikOSTY1h9xUggoVG3H+JlN9kgovFBglW0PjxMoF+qkG3BIMIaBLpnwDdcNBVGFDLhhOeS6jDvlkBgcJQhzfrwh5LX+FaraZkayK1FMnYdDpV/VNTqRSrq6vKu+b7vvL9SjsWAd3w3KMohwCHsIQ+nIItG7VwQJi8RAVcyH/LRk/OQ8ZIPjvsbRb/pEgwhdUOt92S/q3C/ItvWySrwjiLZ12KE1JRlwJCOCSr1+sxm804ODjAsiyOj48ZDodKEirMv1yzbBpkkydtXIAX/PHC5sTjccX2yLmIHDGRSFAul9UcEvlqWOIv5xyWTUsxQMYiHBwWBoEy5uFDWG2xFQhwlLl9vhAkBQJhrcKMmfy9bMbEwyjjI4UMSfMdjUbU63VGo5FiHaUtjWzs5HpFii4KCmGohSERC4b8rMxReW7CxQp5FmXeha0SMv+kACNJ1MKew3OQL0Ar/LMCAsbj8QsFIfk3Avx+lo+lpSUla+73+xSLRba3t/n+97/PcDhUSoVKpcKVK1dIp9Nsbm6q1kK5XI7r168rcLq6uqoAUjgjQPzb0ss7l8vx7Nkz6vU629vbykt+8eJFtre36XQ6KmdBMjIuXbrEyy+/rJi3CxcuYNs27733nmJepagkYWmy5sm8EsYwm82yu7urVDPilxUW0/d9lfQtnSjkmqrVqvK9y7Ph+z5nZ2ckk0k0LUgrj0QiSg0j66S8XxYWFpQ9Q+TAMtbCsFuWpfyzUoTVtKCHujz/0WiUlZUVNjc3SSaTPH36VPVa1vUglOx73/sezWYTCNReEvYlhYFms6lyLCzLolqtcvXqVfWe03WdTz75hFgsxsWLF5XcXALkZH50Oh1eeeUVrl69qtRBrusq0CdAW8ZTgH/YHmTbNisrK0q9pGkajUaDer2u2HkpcoaL2bJmSjq3fKYolSKRiFI+tNttlUa+tLRErVZTa0IymVQFqHQ6zfb2Nq1WS32mPCeybsh3ix+63W7TbrfVn7/3ve+RSqWwbZtvfvObGIbB4uKiSre/d+8eJycnat2RHA1ZQ0XlkclklO1G8hTG4zGFQkGx//IOkLkmR7FYpFAoYNtBOzZZ4yU74/Hjx7z++uu8/PLLlMtlAD7++GM8z+Pg4IBoNEq5XFZFMMMIetM3m83/IUD3AUuUyDKkhItP0T9ke6XN9zsPGVppxt+r4s9nVLIdrsS7pFcmbF6GVjRgDHOrcP0qzP6VzdBKs1ockLF8rOM4mdQUPQHmGFY3IbcJFlDIAzEd454OdRO2YzCK4CZLHFwcsHjdYrN9hK5N0dOBGtpzoX3ZYPjKBUgvwaQPF2pgj+HbIwYfXmRg9ynQxHDmHDs6fmYpYFcdHZwojPPQL6HjMi35DJZhMQ2JQDCBb8B8AnMN4h6Mz6DjQCkWgPCIBV4GJtXAPxs9hXQfLma6gbv1KMjY0mKw1J6TjrRpLsNpMsY04hBPukS8fXw9grPgEJlBzQ0KEYNxkP2WA6yRj8Y+RWsXynPa+QTztPGpzNvCWivyib6MPb0IhTUYXYTWFsSTsPYUViaQyQIGuPeJPvwXXGw+w9F87kdTeGOPxGyGW1yCWQyttRsEkI0A6wB6S7DzSiDJN2PQ1yH1CRCH2AXwp1CM4pbXOHi4x0XfolTx2TlZwu7/OoyvgjMKIuznHmijIPnM1gNq2oyBb4M+AqIw08D1YORAbYa36jIfQHwW3Lp0Y4xb3yU1n5EwoBCDBQdiLuxrLl4kwsyDewnoblYDmbqj0/BTVNoDFoYjJrEpvVIUr+YQbQcYuJj26SyZTGs10K6CvQj6NfTWQzRjzINCHjYvwkkr6NOmmdDpwvgeTH6APjkgZY7BhdLMYuXEpXum0fQdpjOPi6dtTr77xwxSvxpMqm/eRjNsWOozS0G2B/2P4f1HJtGWjrswJ5uDuWmizRzKZzPynke7PCST8pntazApkiWN7U+I6A0SKZu2FqgwIhEfPQ0RE9JTIA1aBgplKNTAO4bet2F0CPORzsgpoztLDG5/iP7FCdd+0WO5EhRSPv53NRqscsQJI2JkKXGZEkOKTImSZE7nf0RPt2xswp5O2cALiBJAIEyZYRgKdMvLW6RssuEPpzuHGcIw2yYSP9n4yaZfQGtYGivsqWzQwi2+xL8tkl0BcecZ7LBEFp4DjvOMYlheHr4m+RwBg2EAGR4L+RnZBAIvAL8wqxxmPOXzhXGQ+xOWDQtzLMWMMKsdBpWe5ylZ52AwUAyIhIuFz11+D3uoBeDK94tXUe6LXF8sFlP3RJh2KaBIQUDuf9h3HL43MgZhH3e4yBH+d2EPspxHWJUQBodh1j4sFRXgIQx3eJ6eB+ZSiAqrM0QpIGyMbDCFJZFNnswTkYPLZ8l9kbkbvu8yT8L//oeNixyiOpEiglw38MJz9MP852GrSFhdEpb/h4tD5zsNnH+efhaPeDyuCnqaptFqtXj69Cm+75NIJHAcRyUxi4pEpKnCIl+6dInxeMyjR49UP+t+v/9C1oMoPM7Ozuj1emxvb7Ozs8PDhw+5cOGCYpFXVla4cOECd+7cUZLbwWCgpO6lUomTkxNVYHvy5Anf/va3qdVqqgApIWilUkmx7gIoNzc36ff7dLtdqtUqxWJR2Svk/ETy3u/3lURcrCbRaJRarYamaezv7yvWc2VlhcuXL6tiz2QyodPpYFmW8tSK3Bqed7yQALVisaiYVAF8UgST57darbK4uKjOV9oySnDjs2fPFICT8Xz69Cl7e3sqCE8KxeHvK5fL6j6JeiWcBXHnzh1+93d/l42NDWWnymazSoZsWRYnJydcu3aNN954A9/31ftTwiulsCiKIPk+Uc3ImqHrOisrK6pPvBQIfN9X4FH+jRR3Tk5OODg4UGqxfD7P1taWWt9HoxGxWEy9U2XdjkQi9Pv9F9QwkhIvxScJO5O5JTamer2ueqdLm8Jer6dsK3KdT58+ZWNjQ81TsSi8/fbbxGIxTk5OyGQyjMdjVlZWKBQKaJqmcgCk8C/rlFg/JEzt1q1bKntAfkYUWJI7Ih53eT+0Wi3q9TqNRoN4PE6/3+fjjz/m85//PJZlcXh4qNpmSuErmUwyHA6VCkUYfQmq+1k+RiR4Tx8wMie8PE9S6H6exx++hxbfJ+FHcSbbJBcPuPIbE0YtGD2D+kOYrUAiD/UcLF6FK3dmPL6TJWFqpEs+/X2DCIEF2DiO4CzYuHHgXWA3ypZVZLw75v1HUbyLcXCGQBF3FTKXLcxPRjT7kNqDaAOsbTgplfGLr8HJEE52YdDFfPqU1B8PidqvMKdACUjoJ0xLaSiWwbaDdk7WEKwBbF7FHbXo9b7G9YUhxQmYDiSi4LRhfx609o7a8LgfyNoLaTicA/3A1nxYS+PoGvb+kEQfSjpc3YbhdejPgvD0+AQSHYhaEC/OYBWGsUV8EsTZx49EaGkJknMrUGEXIJKE6VgjovvkMxO0ObgzLTiZSAoqW7C4gqtt4k5fhodLMEhAJwX9OKzsQPUUUoDpBj2j648x9/aoDz2GWR0n4eInfUYFDVI2TOZoZQ/Xz4GxBclIIEuvmkF4mhcB7w4c/c+wsA2FvwwP0/CoBPovMf54hXvD93g4mTBr/xq0fj6IGdeSMNAhFglS5PszmDuBPHtEcE8SBvhWgK7Ts6DikTYYrSzyXn1EpK2RGbfIz202Z2OWMtBdhCMrUMJncpAczZmcuJj3g2yzRPyYcbQN6esMGzmmz05JNyC15hLJTBg7QZJ5NgabEZ923+ZMq9PzP8DRDojs/AkrzSfEyg6t7TcgtQbtKZTjQeJ6f4TeeI9S/T0yHZdiAtJFqCRA24XT0xSO5pLHYeExzAY9JpvfQHvsUvp/TkjpLsfXZjz4pRRObIT7yOT46BZlrcfN1GO6ORhokH94xKUnHkbXgKKHVwLb9SkMpmzPUgx8i/z1Ha79us90BvOHcbwB2P0pKSBpQzQHqV/w0a5A14LUPdD2odWKUHeKHJEB4jiPsrQ/nLDwBTDb0Pm/pkieXWCEwZgsI2IMSWIxJILFIhEi9Jkz/rHWnJ9q0C0vc2HyBDzF43G1oYfn4WJSTQ57DeE5aAgHncmLDVDgYzab0e12AdTLTqR1AiyE2fU8T22yJESmXq8DKIZb2FzZtAjTK2DQNE0lZZOflRYksmGR4Jdw4nSYbYXnIV3yexh8wvP0WvnZcBjLeZmzbNjCG+4weJFNnUj8ZEMuoCgSiahEarlXYRl8OHRHUmkFIHqe90LyfBi4CggIt2WR7+71ejiO80KfZ0nDFvmosKrZbPYFr72E4EgIkoBSAbby/cIuSAEifMiYSZFB5or4YUXqKmBa5mB4TGX8ZX5IYSlc5JB7Kf12Ze4LK93r9VQPcWl5JEWe8PXJHBL/fzhMMBzcJomyYel2WF4eZteFVQ7LyYWtPy/5lnkmz6EEHEmokSg1whvXcEaCzMcw+x8uPoTn28/6cXJyokBMp9NRst6bN2+qJHDTNPnwww9pt9usra29oBqSNSwWizEejymVSmQyGbU+5HI55vM5jUZDZS3kcjk2Nzf55JNPuHTpkmLyxuOxYjH7/T7z+VxJrk3TZG9vj3fffZfbt2+r1mDyPeIxt22b69evs7q6qsD2wcEBDx8+VOcsXS2y2awqJEGw7orEWfy7UuBLpVIKzIa7TAiIk3ZeUoAScC8y8+FwqFhOkcfLOyKZTKprlwKA2I0kIX1tbU0xlgK45ZxlnsuzL9ctLeDEsy8BY67rqnsrXmFZ8yTELplM8uDBA77+9a8zGAzo9Xrcvn2bz3zmMypY69KlS5yenqLrOuvr66qgJknkUuSSwp0okUQ2f3Z2pvIXDMNgfX2dcrmsxva9995jOByqORGNRlleXlZBX41GA03TWF5e5uzsjHv37tHr9ahUKkpVlU6nsW1bZWak02n1fs9kMir7YzQaqeA/27ZZW1t7Qf0ka8be3p7qDS8Sbbl/wjL7vk+z2cR1XQ4PDzk+PlYt7gT0vvXWW+r65Prl3dLv9xVAlnVNlFeu61IqlZTEXBhxCcvzPE9ZJeT9J0WX8XjM6empul6ZAw8fPuTnf/7nOT09VYn6ruuq1nPyfPT7faX+sizrf4j10Qfa+gl2dMbxPEOMLI3Zq5S9D3kjccRgfkoyM8ScwYd3krQPDdYyQ8wxGK8HzK4zBr08J6pZjG0ovgSZ/gg/DV4Ssr6DbUOjBf1TGByWKXg3uDp/gHX7mKeXfJy0B7MJTBzMpI+fh/4Q7MMg38vMAeYcbe9bJH7QgNsjvHqU/NggM0wQwcMhT0T36dZ8rMtXYXUNRjMYteDgPjx8F8MY4Ccy9NIVTteHXD8AZxemMcAIArs6UdAnUJ6AnYCBB9F50KJ66kCWKboJmhFgSiMJjRiMkmDMIePD0ISDAfhdyMwChfbJUGO+uIadOkWfJ5mnt2lE7rMysjCSUB/HGMQvYiQ7GE6DeTILGSPQtec3YP0WpF+F7xbgURq6MZgDngWeA2M98GL7MdAtqFugLTPJLHE63sONXYdxH7wOvhuHwQxSY3wnAt0IpJPQWYfucnBTe0koPYD078PwGURHgSwg8YtwWoVhBqZXcXkLt6PBYD3whkfmMI8H7LCtg2FCaRJ4uc1hEALXiwa+84UTSPYhMoJUHhauQO43mA27zJYmjJ/9PjHrKa4JbUNnJxrhZPkCu7MCJfsRtUYTD4/EJiTf1TGaHXYvfw/n0gb9cZ5oElJZeBKDvqaRHPvk0wEB3zNgMwOX+xP2hvc5HBnk7rlsx+CDXI35yltBBSVqBJPDCp6YyG6fy3WX+DQIYIu5kNWh2YBockp6aOBZEVoDg7kx59rBEc6ORm9+hYhvUr1/wNHLEZ6+ZZJbGbN63CNidpmloJmDdHTEqw2P1BBauo/dNGgfOcQ3INNv4x98RDkxIrPpM8sB9yHdjaH5GkezKbM8bNUgFod+ATDBfARGHSZdjdN5hgFLtHDQqFMZL7D/foNXPudTf6QzfHYDlyUyuHyGDE0mnDJlAR+THhOy1HGY8+O1VPypBt1hv6iwnQIsBdyEA6oESISZQ3lxhSXqYVkxoECgMNLyopMNjbTACnu4BUQJ+BT5l+d5SqImcrAwOA73RBZZs0hrZ7MZlmUpiXCYeZWXd1iiDs/ZxLA/NgwWAQU4w3LzMAN7nqGVfyNgV4oT4TEMe+aFGZZ/LxtjSQgPM+aysZXrkVAyYe0FvMuGQACU3EeRvMsmTLx1IiPXNE1tVsPXJXNCpMpy/gJChTEUH1zYNx5m50UmLp8bLnYImx5ujSWgW65bxlvumXht5fPCqeyS3hzOIwiHAsoRDnqTDbbITuXfh5UW4WdKJLnyHEkoW1hJElabnFeFSBElDISl+BJO+z+vygjbDcQzKZ8r4yeS1PCzHi4myXwU2a8UbmTe/KxvKqW4J89sv99Xxaj79+9TKpXwfZ8//MM/5PHjx0q6b5pBG6JCocDx8TH9fh/f95XsXGwzmUxGzQ8BK8Ior6yskMlkODg44ObNmy/YIgQAyjw3TZNvfvObqpew7/vk83l13+X3UqmErutcv35dMdwiCZY2fbquUygUVKiVtMY6PT1VwC5cDBIALoUpYQ3X19dxHIdMJqOSv2WtE0XMZDJR/lcpyErxUvzuhUJBJU9vbGwAqGA3KQgNBgPu3bunGNetrS3V9lD6gtdqNcbjMY1Gg06no8a/UCjQ6XRYX19XKgTxJss7TBLP8/k8gFK1/PEf/zGPHj2iVCqhaRqPHj1ie3ubYrGoPOHSulFaVwGKde71euzv76vi99nZGScnJzQaDYbDIbFYjGKxqHzM3W6XV199Vd0bsWhlMhnK5TKrq6vUajWWlpY4PDzkn/2zf0YqlVJ2pEQiwdnZGWdnZ7z22mt897vfxfM8ptMp3W5Xsf3COMtcPTs748GDByqYVILwpCAQVk1NJhOazaZSEXW7Xer1ugoOFOl8NBoln8+r/udSzBRmO5VK8ZWvfIWvfe1rxONxtre3qVartFotFfonRUTbtllYWABQPbfj8TjtdlspBuQ9JPsWeX9KAUZsFbLmigpEMhw++eQT2u22arkmQW3i/5b3mYy3hOf9rB8uQ5acOX3LYAB06DMgSte+StL2qeDjH2T4D/93n0fDFRxOmM7jmJbJjYJFoQvHOzA41vG9Iq33LHRrwHTRJ7kBmRJMlnymu7B7GzouuKkOZ8Meyz78paZLdL/D/ZsxHDMNdoZJpMOy4ZCbmOAa6KkZrgmlP+lTvh9hfBin5VXIunFKRDFxyRBF148orrd4dDXF9NoNMBNBVHX/BPr3SQ/vcXMwRfc1npbjfBKPY1RmfCbhE2nBaRPwAmL2NAWROlTmYG9ARIesHch2l0cOERMGa6AtwSwDpyVwgVoEslEwEuCmApK0mzOoRFwiswbzrkEyYuPgYaeKWNMi04LFaATD/DqsfQF3puE2noH+BCJjMDIwmMO9XYj7sFeAyRWIlcGNQzwLlgGnC+BPAnTV6EA9CTeLaIUIWjcCKzcgm4ZBL/AiD+9CPI03fBU6G8FFu7mgktIaf5oe9x/B/QBKm6D14fhDSL4GbikwXBsxsNfBisNsBsYg6Os1iAeS8nIPVvZh0wqC7Ma70L0PvRmZRhd92qVfjkPWBScCB38pSGD3IjD8HprVp+NrHBbKeJUbQVuzwmWIXKDR38P90/8j190DJlseesljqQ/9/oc0Il9k/tLb3H3whGKkTWwG5a5PLgfLKXASMCyAp0NuCpUzaH7gUTiM4d+Y0clXIXcRTu2gzZqtg+5CYoA2HTDfgegQKotBvtp9wFqHUtmhcOgwGkN0anMpB5X3YbLv81g7Y+AXqUXmVNpDbicv0v1fjlm0nkDZ592bcca1NGvNFqU7Op1jk1l2jtOMYx/CAg70TGZYbC2NieWDtmeZFoy0GVM/gT2CSQxOKmCXAnn5tZPg51wLsjMNjwg2JklaGAzJei/hN5OMvjmi+Yc3yThfIMK3uEyTRVbZJ8cYFwOTY8OloaVYceKso7H/Y6w5P9WgWzZjAtLCslZhsoWZC/tphUUR8CSgDp4zg2HJtHga5TsAxZqL1FKY23w+r9J0hfGWX8LYCmstL10BxNJTOpvNKp+fvEQl2EU8t2FZdRg0CoiSQwCOFAPOA2rxiZ8PTxPG+rz/Xb5XAI0UCWR8w0xnuGWKMNDz+ZxMJqOY3zCrLvcq7JMOBx/J9YRVDALAxGcfthzI+Mq9DDOusskIn69svoV5dhxHMXKdTkexOZLQK6yXSOQF/AlolfEU9lo2hDKPwoUfAZfh1mQSShcGh2GwL+MWZm+BF+T38ufwMyLy8nBBRGTgMpfC6oWwRUA2v6lUSoGg8BH+TrmHMg/kM8IMtJynsI5h28T5sLQwQy7PqeQMhNUOMjelABS+hvA5npe7/6wdvV5PFVFSqRSVSkUlFouyoVwuc3x8jOM4VKtVTk5OAFRRajwev2DJENl0q9Wi3W4rNvnhw4fMZjMuXLhAr9ejWCwqFrzdbqu05QsXLqhOBMlkkqWlJZLJJHfv3uXatWscHx9zenqqWmaJjzwajSpwmMvlVMiYBL6JJFoKlc1mU6U1V6tV1tfXldojk8mocZF3g8z/yWRCLBajWq2qzgdShBVVVT6fV72MU6kUs9lMqaukf3QymaTb7So5eT6fVzkFrusq8HV8fKxUWmFG/8tf/jL5fP6F3IRcLqeKHMKqyp+Pj4/J5/MKhBYKBWq1Go1GQ60Nd+/exbIsBawePHjwglpKOjWEPfKAkmnLOhSJRJTcXd6d8o6S9VrWpPF4TD6fZzabcXR0xNraGr1ej0ajoQLMFhcXee2117hw4YJSZMTjcVZWVrh37x6FQkHZDzRNUwD29PSUvb09+v2+Wqtt22Z1dfWFEDTLslTxIWwPkneJrNHhImm/3yeVStHpdJQ0/OTkhAsXLhCNRpWvfz6fK4vG4eGh6njxySefcOXKFX7t136N6XTKpUuXSKfT/Ot//a/V9wnod12XdrutlAStVou1tTW1BsdiMZ4+fara6S0vL1MsFtXckKJELBajUCioAokw1i+99JJSwUmau+u6HB0dqXs6nU7VHJQ8B+kg8rN8FOkRx8bBIUqKORUcujjkOeAyaZqUp2mOp1M8PKpkOPaTDKZl0t+28OMHjMdgzJbxSWDOfLS7GebpMa1un/aiS3YBJgV4dF9jFvG5uDGlt/uIwjjB1gDeGPp02lNOFgZ4+SzHF5PorwyYGQ5bM5f8Ffg4Ccn7CV7ZeYP79DiKnuL6TbLenEW2yaATLTwh+cac3YUK5KowHAX6drcJ0SF61ic1g8Wxz3Jjwl1P506pzCBh8SvrE9aTMH0fpn1wroC3DFhgmjDyAxm66cDxBJwYxKugmzDxIR2DTByYQN8HPx/g13FUx0nHaU5tvEQRmJFruwwSDpOkjddNMTJ0xmkfP5+CmAmTMpR8GO1hDDtw3MOdmwFj6es4mSJs/jrUfx3ahSBZGx/GwFE2aErd04NQNO0UYzKmwITO2Tu40zXwPPxZGwpxqMUCaf/CFDCh/32IPYPINvTTGLE/w5/18OaA7YH58zCMw8AJJOKzEdh+ALYNLTDf2z7EI7D0DC4dQcECrQnxAYx30dyPSCWnbJz56BY8TESZ5ZMwG0N3F7LXoPQEffoHaNaAUdrEXbgG1b8MnUvgZcFpgZ+mu3yTk2+dUGo5FGse6RvwaCkKK2swXeFk47tYx++QO4KFOVg9sGawtRC0ghsD/hDsLqRHsIzGyAPHTQeFDE0HDXA0iEXBGVN2e8S6Jv1mjNR0xMkUrEtB+7G2A5cvBvaCzknQF9ze10jo8Mpil4PGjGR+wuUSND455fDKFo//hg6TDtNL65DOYv9Bj9QnVWbxEfO4i+lv404t2se7mOMo86RLfQvW0pBug1aHmJPgKTma+xaLpoO95DO9CLVp0KbdTUJkFWJjj/yex9SJMMDFIcrIPOP6xphRXafdWiZNhm0GOPFdjqc6FksMGLPHlDkRIr4H6Lhkf6w156cadIeZZAFUAkSlpUj4hSr/T9hl8ZmFmWYBXgJshYGVMC55UQrolpAe2XRlMhlVXRaZ3XlJuGxO5HyFgZWwMekLLecbDrwSwC4b4DCIFPAbZvvCAEfkyPCciQwDnTCglYJFIpF4AeCFwZwA+Ugkos5TPjvMcgNKwuw4jmJhBKQL+BI2TFjJcE/u8/5zAd3wnLUU37dsRsLsqciw5XzC/n8ZC/k3tm2r9OFWq6WYlMlkQq/XU4FNwlaJBFXYuzBTLMUUYcjC4yngWYCk+OvCgXJhLz28mHYu4yzXed4PHgbAYam/SH3DhSi5X+HvCH+GnKds7pLJpGLhZL7J+AqAlmdHNuByr2XsZf5KkUM8hfJ54bkq5yDzOazIkPkhktwwuA9bEMIA/n+EQ1Q1ovyQuS+tsFzXJZfLsb29rYop0+mUwWCA4zjU63U0TaNer3N0dMTVq1cVSybMrqgtZP5IW0Rhx0XNIX2NX375ZRYWFtjf3+fo6AjTNCmXyzx69IjZbKZYcJmj4p8W0FUoFNRaJnNdFD7RaFSxghL+BShLi6zBiUSCbDarwHRYNq9pGuVyGcdxaLVajMdjVaCQ4oWw8KK4EdmxgOBwkULm6mw2o9FoMBgMXvBLC4sqxbxMJsPh4SGtVkt5nNPpNJZlEYlE2N7eVlkX9+/fp91uq2dO5MSlUomVlRXVAlAY/3q9jq7rqu+zKI2kldytW7fUtYfXK0kUl2e40+lw+/ZthsOhknOHA9MEPIpaS1jhSqVCNpvl5OSEYrGolAGimLEsi/39fb7zne+wvx9wCOVymVqthmVZdLtdXn/9dcrlMo1Gg36/z2AwIB6PKxZZ3kGSVyCAe2FhgXw+T6PRUOuQrBuS61Gv1xVDL8+A+O+fPn3KbDZTqgdZ48NqnKWlJeB5oX48HvP2229zeHhItVrl448/ptvtqlZjpmnSaDRIpVKcnJxQqVS4dOmSCkqTvUM+n1efKSnl4XU2nU6rwtHKyoqa09KyTXqlj8djdnd3lTJD5oMoqHRdp9lsqsLJ/wgtw2w8DDpEGDFFw8HBA+ZsM2GMmzkkl+2zbelEBlUSfokZR4yYMZ68TsO10LIN6vMEh9k22a82OXucYf3Dt5h9OKHz4A7R1RFePsjV8pwI5Ys2kUqP/rei8CjGdn3Gwgo0ehPm2RmTlys8XtDIHIy5emhTNw0OKkUK7w2Z7d1m1RuwZo+ZmTDWTCZulw5dSrkJfg78AkGrqlgSKIP/Icb0kMX5jIoPkzOYWvDWmofR7PIgUiBfnfFWzmMWhbEP5TZEI3ByEfaSGv7Yp1CCfCbw3O6XA4C13oLFMTh9KE9hZsNRClp5GMZMHC0CXhwnUoNkAa19RH7iYxszBr4NZo5+JI7pj9Fnu3g2MCiC3QdzQMxy0Bo+o2gS3RljTGZ4l2287gdw/HkYF4JkbS0TyMy1KEwuQHsMuQHM3yfTblFxPdKTPZzBHr20xiB3Ffz/BRyfYDb/A9HYtyCdZG6NMXwHP/YxRhJSaY/BDOzUAJLX8EdvwKwEjh0klEcSgY45Mgo0+DMjoI9rHah9A6aPAgrYG4LeB8/GtzUmEZ3DqMeS4bNgzmlHbaz8Img3YZ6FWQevFMXvZclE+oyThziZUXDj4g8xD/4fGEcnzE0X/fqcBRNaGjyIVTjb/DJkFmB4QmR4RKoDbgy8hQCre1OIfGoxN5OgT4OQvMUFn7w5ZWjq+Ho+YN4dl8CEkQr+fNZmoWUTG5kMfR0nAuNS0LY8+/RT1fwK0APbDbrVmTcDu0QKWPpoDF0Ns+vzRnFAY+Iw/eJn4fAUaknMj/a5+AOXZKVD5HNT/KFGtzkkNalwMupTKXW5dMNn5zo4SVjch94M8nj4JBmOL7B5v4d+/ZTiDai1QR8GXdlcA+bXYWXSJX7cZUyKKQky2pjs1Gc+9Unq7+JySN2zmU1rnBFhjwkmGstE8V2dPk32jRlH2gicH7aq/OePn2rQLcwiPGey5CUoEmYJ7hLGLZyiHA6dCkvOw/5iSV6WTcd5eWwYXMiLSnyquq4rdltkYq7rKvArgOfPk9yGPbTSpkV+9jwgkuuQcxcQFv5c8ZTJZ0tiehjQyiZJGGwBtxKeJayzgCP5/rBE+nywnABJka0BilWSCrz40rvdrvIcC7sfLqiEiyey0RDAJlJaKbaEfehhxlMAqIC6cOCZ3Md2u810OlWgWwolAuwFwErBQXyaYWWB+OPCDKFIGGU8xZsnYyT9tAWsyuYuLN0Og5wwUJb7LHMofM1y3eFAs3CxIQxMw2yyfI7cSykIiUoh7JcOPzdhWfl5ECwA8IcVZ8Kb2HDBQX4mrBwIf6+MgYxReLzCY3Ze8v+zfnQ6HXRdp91u02g0uHz5snr2bt68ydbWFisrK2SzWRUMJptx6REtoOWXfumX0HWdf/Ev/oXyQLdaLSKRCBsbGzx9+pSTkxO2t7d59OgRh4eHZDIZms2mkrXn83mWl5cpl8sUCgVM02Rra4tGo8E777zDcDikWCyyuLionkXpIW9ZFrVaDUCxw7lcjp2dHZLJpFK2iPy6UqlwcnKC53mcnp5imqYqGISLpJcuXVI+aNsOem67rqt6MovPOryuy7OVTCaVIqDX66n1q1wuUy6XMQyDbrervPSSCSLhcJKAblkWsViM5eVlAAWCxO4ixYv5fE42m8X3fe7du6eKTiKrz+VyXLp0idXVVTqdjpJLS5q1AOp0Oq3sTuVymcuXL6tk8clkovzp8l5xXVf1IP/444+p1+sv9DsXpRQEAX7Srg1Qc+SLX/yiCrtzHIdcLqfWcLEH3LlzR1m3hMWVTIJbt26xubnJhx9+yNOnT9nZ2aHRaFCtVpVyKJfLqcIRoMC/vG/F7+95nrL6RKNRTNNUxYhwAGipVFKheSLrHg6HKsyvUqkAz9tSyhwql8uq53okEuHw8JDvfOc7SiUhxX3f9zk6OlKFZjnq9bqyfPV6PVWcEgLBsiy1Fo7HY46Ojl7ovLKysqLeHe+//z6VSoXl5WUqlQpnZ2fkcjnV4izcFcS2bRXEJ2P4s3wU8TilTQaDOE0GNIHLgEMx+ZArr/fYvO6z3PHIHpxh7bconvgU3QIJOkxxMaJgGE0WFsbovwY9Y8iD/8M9qo+u485Xae10iUQsNhyTZ2Q4uXfK9rLL46UOh57P5UdwcRlODIdTt42fL8NKGasC7+TBjixib16gdfY+fzZ/QLzjcGkMKx7MBzFm7oCdWotW1Sc3h0JkxAgLZgkwq5C9jjb/95hJ6PYh0YdOH6IX4Y20w7Tb4Sk+WRvMcoAjO1NYnkFhAkc1n8glaLgGp4MISdshi4PlQuwYkhMY20FGmJkC9OCXZySBxYD29KcwHmL0ptAFzbKh5EL5BlMjhd69Q7rXI+p+hN/V8TSfURWmqRj+UhGSWTxrwCw2g6UKNNeCRHZTD0LLbD0IMEsNQZ8F6eUFn9izO1weDRnY4KTBK5iMM9dA/xV4dhkySzjLXZKDr5Mf9Tg2o8ycEnrEx6vZ2IM+CVdjXt6G2C/Cw9VAV709gd4CWCmIGAHl77kQS0HyDKofgf0wkJOPG4AbFEKYgDbHjZnM1ufoHmQAu+Uzshfw/deCJPZJG7YG+LmnOO40SEPvDcF5hP7sXxEfPMDwPaIenJVNupEkw9gVppe+AtWL0H4HvfHvMXf3MO+blGsORgWSJpQzMAG0MzCAWRxievDf7gXwiwTty3QvmAyGC0TBN+G0jdF3mfgOvu+h6ZAuAw2YP0gT3RrjVD08DWJdKC1B4hXoEIgDZgnQ9nxOs/BJzmQeAfY7EM1jHJ7y0td3WKv6NN+aMslBsu1j/vIejXsNtGcpnGkWYn02Heg/DTIP/CONnj/F1E5ZJEUsaTHPgmkF0vloPgiGPz6F+RDi2w7J1FNWDqPYkwt49irvf7NFRZ+x7I+oVD7irLtF3P5NNjDYo0dLH5Kmz9yfMIjYuKkirpmG5o++5vxUg24J4QozY5LqLIyEBJRIOycJixJGWHzU4VRX2eAJexBuUyQ/J+ylsHTiPxawL0E54t0yDINer6de9iIzDDNw8plh0B0OnBJWJcykwot9pgWUhgG9AN5CoaCkaJqm0el0FIshgFWuTTZcYflluF2U9OUV8BL278qGWHzJUvwIBwSJx1gkgSJPPDs7w7Iszs7OVKq2sBcyTiItlnOSzYIoF8SPFmZaZEzDADsM2uS8ZfNxdnbGZDJRoFuYLikCyDmbpqnCmTKZzAvMTViFIZ5RYSiEERMQW6vV1HwUWWC41VaYAQ4DVhmPMAstwDV8b8KyyvN+7/OgO6yOEIAd7gcubX3C8nhAjWO4pdt5hlsAhGxSpVADzzMN5PPlGsKFEngOdEQmKQFSAuh/GPAOj5fMkZ91T7cUcIrFIvF4nHq9Tj6fp91uc+nSJa5cuUIikaBaraLrOk+fPlWp3fP5nEgkaMV07do1PC9oO/XKK69w/fp1/vRP/5Tl5WW63a5aW9LpNM1mk83NTS5duqR8v+GikQCpeDzO5cuX1XP08ssvo2kaBwcHL3htFxYW1L/NZDJKXdHr9YjFYmQyGZXC7HkezWZT9SEWdlyyPAQ0h7svhEPGbty4oTzTcg5ikZDiUVhlIfJ1SRX3PE9lfHQ6HQzDYGtri3q9rroAZLNZJTkX5ldAuxRXl5eXWV1dVdYJKdbJ+jidTqnX6yqYM5vNKqvAtWvXyOfzPH78WIHtRqMBoDz8kUiEfD7PgwcPAJQySPzBonowDEPlJvh+EH63v7/PkydPaLVaitUW9Y7cX7kX4v2XooXc+y984Qvcvn2bWCym3pnVapWjoyNOTk7odDrKz16tVnnjjTcUiK3X6zx69Eglzruuq0LuyuWysjuIlSmXy1GpVNQ7OJvNqqK3eOglQyWcGyFKuWQyqVrWCTstPyPvOFFOLC4uKmuBdN2w7aDH9+7urir6eJ7Hd7/7XWzbZnl5mc985jM8e/aM2WzG8fExL730kiIBstksz549wzRNVldXKZVKbG9vK2tNNBrl5OSE73znO/i+z/Xr17l27RrLy8vs7Ozw+PFjZSc6Pj6mUCgo6booM+Tey94EeOG/f5aPz/IRf8qQFFss0eJDxpTIU4485MbbT7m8HKSUl78A+ocez/6Ny767TocKSUbEfI1SCq5dauMuwIMhDF6D+a8eUz+OU7Wu4PgdkvNdCgxJRvo06rCpwYVXHKhBvwFr9+BWBN7TBrQ8BzcewU9sML68CbYG8w7uq0naRoncQYfT+ZyODoUnIy7f9dFnEbzkLAg7yxmgRwOJdawPyW3c9BdpR/4NhutQWoAkAVNtZ+Gq7jKcQSQWpIiXpzCOBV200k24mYKDrM5O7jreS1+B5jHRzte4PGtS0cCyA/Z04AWK5F4EdB8M3cPLVcE+gpMuaBES3gS3D07MR+/u4pnXYesX8eomrvUNyv6MWNbFM+A4HaFTvgbZNwKv9qQVnGR3Geo3YLYKlh70uE7YMHcDrfTGKaQ7YD9G//gu9gxSBWhOIzTTn8FPfhU6ZUh/AvETmBm4TQPXd/BKcfB1vEgBL6/hPxxQ1nyGkyleVAuk4lEriHEfJANmWwt6SRMFVgew8BQ634LOY5gPwBxBQgfNDSoTXhqiM3Tfx7EgmoSxreN7m4GfPBED40uQTsCFTxj35tDOQ+MCxPbxThpYnTixpEMq59LJfh7KvwZGFdYM4EOM/X9Lvr3HeBB0I0sY8GwWZViOMclYxKc+mXrQ8q1V+9SyfgTzFeikdYhlQTcgmwwmi28GzD42OB6+4ROLzemloJuGYhfmxpx4wmMeDUL1oiXQKzCKgp8IVPH9RYi+DScpeDjIYwybGPYRWifFZz6oc7nlcPYWDJNg/ZFG0tIwrnjEfm1M7J055nsvc3z/MS91hvgfxjBdl6wTZccAo9RlPdsl8So0XoXEHLBAX4DTHfjOB3H8Dlz7/JT1/51N7QObg397wJOpzmxSxGLOMQ6F8ZQ1D8bE6DDF08ZYNR9LH0HPD/qTJQkG9sc4fqpBNzxPmpWNfLgtlfy39M0Wn2dYbi3AQgBFGCiFU6GFZZNDPivMuMkGSTYx5wGSgKOw/DsMgM5LeoVVEfm6vAhFanYeMJ0HYj/MEysbRwE4YYZbrkfGQr4/LE8WwBlOMJcqfRjYyRiJ7FpkjOF+3wI8w6C71+thWdYLadphtlh+hT3fYSY8PJ7n/xz2cYelywK4pcgS/l2YD2Ge5fqFaZdxlXOQMRTFhKZpqiggMlhh9iVpPJVKqYRakQzK5wsIlTkano/C6IdtAVKgEaAcTj6XuRou0AgACV8L8J/MifOg2XVd1WtXAIdcp4xPmIEOj3tYyi7/X74nnFgucz787Apgln8nz+V5YBe+Fvm+cFEhmUy+cA4/i8f29rbqmpBKpdjc3FRezStXrhCLxVSa83vvvcfjx49V67DxeMz169dfYGylj+/29jZ/8id/osZ0NBqxtbXFW2+9xXg8plar4fv+CyBF2OZ4PE6xWCSfz9NsNul0OpycnLC7u8vx8bHqTb20tKQC36Svd1gRlEgkVMeHtbU1PvroIyaTyQv5EsIGSr6GsJyapqk8j36/z97eHpcuXWJtbY1bt27xgx/8gMlkwpUrV2g0GpydnSmmt1gsqmdbWEZheyUdXuag9EgulUoqdVxArHidNzc3lV9cwJtpmrTbbXUfJTROxmhnZ0fJw6UIapomn/nMZ5hOp7z77rucnJyoAqL09ZYQUFnvNE1T7bCePn1KqVSiWCxSrVZVkrYUs+bzOTs7O8qDDs/XTnmuRQElqdu6rr/Q03t3d5dSqcTq6iqXL18mkUioc7p//z77+/vqmZSC2+XLl7ly5Qq+79NoNGg2my+Em3meRyqV4uWXX6ZYLCqJeTabVcnh1WpVhfRls1lV7BCmWALTZKwEdIv6AYLCRrFYVAUZ6a8uEmwBr5KBIr70w8ND9vb2WFtbU+qRnZ0djo6OAJRkvFwuc+/ePS5cuKDWpuPjYw4ODrAsSykiNjY2FFsdi8WYTqc8fPhQ9UvXNI1arfZCEFu4wCjvqG63S6PRoNFoqP9XqVRUfslwOFRFiZ/l40L1IcNmlQPfIIXFFZZYwGe1+oArb0K8D/k1mCbg9tfiPNpdZ0CWLhNsvccrvk05B8Wvgl2EeB7GBswvwrx0hmZdwAFG+oAtY8zPp2D8MtTWwMkFuNHdhBiw4YJ75nMQH/GskGSan6KNb5Ps9Cgc2yR2Xcwjh1XLp3gRnl6E9mV4kJnAOwvkP3Jgu4mnRyFS+rQPmAtGAn/5S3QfvEdh+oh2DlIm5CZBNljSgEgbInlwqgFRm2nDNAV6HqL3wHnko92yYK0Er76G9+4eaaPJhSvQa8DxGYw8mKWAIox0DccrQSwXJIaPbMAj05lDF2Y65P1Txo//gOnrX4BSkXksjzeqM5nDUIfR2IB8GaqvwzgZUJeTDIzyAQiMtv+/5P1pjGVpWt+L/tZae57nHfOUc1ZmVmZlVWdVV/VIU23oxg0eONzri9G1ZUu4wQIsGYGwbGMbBJ+QdWwsLAtjXSF0fQCD4TTQ3aYHauyaK+fMiMgYd+x5Xntaw/2w6nlrRXTjA32bc6DPkkKRGbFj7zW8613v//kPj9e7O4aXsG2ZkHkIya+h771DdnBAKDXmIABxV6MzOIOb+z6YjNC13yFq32TxoEVjCpP0lJkOmAFwdbAOYKIzxUtwj3b3GUZeg2fnYbMAL5dgloCi7QWnhQ1YnsCpN9BGfwjTm7jYQNTTNRuB9wC3AcEZhLI4wwphfYxtQkRzMAK3sFfOQCoPLMPSRc8bvufCvoNmvk3Q/DI5t0XcsXGCLhVnAdyPgHnRY9Lb++B8jXjnAK3m9eN2510enopRv3YJJ3ee7eZXmJ/u4KRczA7UdYP8uksp7tAx4ZEehOwq6GlA84oAVgiaLbTREal5G6sNEdM7vHEPEjOYrU+xFmC7BdoEzi97Pd33I+C479VNHBjEYN/QCLZGrEZMgo9cCp/r8qTusvssDCyIfxGqb0Vpz7IUdnqUvqvP9JJF6/4jLh6miI0HOIbLwURnNzBmoLssxsD5ANSehnEJohUvj2Biwb2vafQrC0TdLlp/THQB8mXovtJDv98iSAqbCdDGHgYIuDNsXqONTte1YeB6aDlYQB9NiQ5aROw2zZMTyp9h+ysPuqUaKw9g8anJYlEWaMKCu66rwKa0dRFGXBb1skiQarJ/cQHvM2XCxkllfzQaKZZVvk76e4VFFKB6cuF/EjgLKy0+wk6nQzAYVGyUgDM/eyjAxh8UJvstxQaRjUvS+mQyOeZz9le8gWPedmF+hB33A2c/gBOVweLiokq8Fsm9tELzB/G0Wi329vYYDodUq9VjCgORuwuQlcWuFDlk8xca5LXyczn3UlwRsCZJ8sKwD4dDDg8PlXzSD7L9ifHyf5H9Czso8mcpLkg6uBQU5LqI/1JYL2H//QFk0uasUCioFkPye+m/LMciCyx/kUN8un7fuKgO/NdLrqmMF7+twS9Zl7ElxQN4P7hNCiTyXc6/v9ghRS1/McivNsnlcqpXsLQK859XCa+SwoFlWYTD4a8bf35PuBQx/GqYfD7/bQ+6/bLrRCKhgu9OnTql7qWlpSVee+01arWaUlcIaBZpc7FYVMXJ0WjEwcEBCwsLqtg0m804OjpSxURhJYUFj8ViCqwIKE4kErRaLe7cucP29jb1ep1IJMLc3Jx6vWVZFItFtra2qFQqzM/PH7O0yHheXFxUrK4ABQlwy2QyCjxJYW95eZlSqaRYbcMwePjwIaVSiYsXLx4D7oFAgGKxqIq48XhczZ1+ibkU7aRdk7SFCgQCXL9+HU3TlGoql8sp4CsFgfn5eQWOms0m7XabWCymgJ1t2xwdHbG5ucndu3dVD2/xqp85c4ZcLsfbb7/N0dERlmWRzWZVb+h2u63YdJm7BfTKfSdFQEl0lznMNE329vZ44403VLaJFNwE0AMK/Au4DAQCtFot5cm/c+cOCwsLRCKRYyFw9+/f586dOwpEplIpNjY2yOVyXL16lVAopM7tgwcPODo6otfrqX7bzz77LGfOnCEWi7Gzs8PR0RG5XE5ZuxKJBIBSRsix+vNQRHElY12C7oRBX15eJpvNqkwVUTXJM6DdbuM474ellstlQqEQb775JsVikclkQjqd5q233lJjVZ7vBwcHzM3NsbKyQjKZZHt7Wz3rW60W2WyWVCrF6uqqsh9I/oAUGHK5nLJAyHWWwkCn08EwDAqFApFIRPX+ljlf9kXGp67rSj3y7b5tDQKkom2M0QGum6WMTp6bnE41CR56IdVzT8Cbb0LtnQJDR2PKFhvBKc7ZPrEB6BGIXYBWFPIJuDKCwTbYgSGB0leYjB0m7oSjIBidKO6OTf4jUyYluN+BZhLqMUg34UYbzkbBsidsJiporSHJOxbpbYgcQcKA0waka5ALQN2C6gWX3VYD814KdwyabgAJ0DUPjEajwGkmnQ8yGu6Qi43RAa0N1hYkSjBxPGw8HkN9BGfKUIrAgyn0TJivB7GDW+yX/zvuxSdwAi3qDlSnnm/XLIIe93y2ZlxnEozichr064AFsUO0iYU7gkkXxhPQui5J/YBp4PM4T5xD0zQiPWjO4CgHrmXBZBfGu9C7ArMViIfhrA1n61DtwIM49BPQCHufk9sluvc5cn/ikjHjBM5OGCy67I5TTEsfhFwOjC8y1/9jTjemRAxwFmBTLzFsawTNNqHgAMeZMp2CFdXomDAJhaEQgIjmoUYzDkkdEgFwNFgy4dQ9IpX/D7nBQ9qWw2gcA82ClAt6AdwgWHueJF4vYYxdIgHYr4FdgbXMPfbTv8NkecUbVJFDmHYgF0VrvcLS7ufIhof0RxBJwmBDYxK+AcMnYBKCmeml3A3rZA9nzHrQywXpnroIH/woLFwBcwkreoa9zn+D3AByGszSHCQtgloVd9jFSpQgPgfjgNf2bIJXLJi0ic9qlBa8cdJseNb2XAWKSag/5gUGZhqQrnpvYYXAtsGyINOBsAPjIWzMXMzykGgI5v6/Bqs7IV7/9IjNEsz/HnTfjbKtp3B1iA9czC9B7XnIPdkm8cUyD2M6oUtTOn+i03I1sgGHZAKmj0NrBaKux6zbYdBcSKZc8uEGseCYWAQiBxDMQuasTXy/zcycw8CmwIywG2eERpchHRYw6XrR5xENgj206Yz0WKesd//vB7pFdutnuEQG65fD+ttYCTgBjr3uZGjISRkuvM+Y+X/nZ64FeMj+GIahvLvAMT+z33d9kp32e83l+GT/pAruDy3zy+LkffxAR34n3mNZTPpZQ79X0c9o+v3D/vf3gxth+f3y5ZMMs1/qKyztSb+u/2/9oFb+Ro7Lf4x+ebOAKv/n+V8n51O+y36LZ1tsBRLg5Ge4/Yzwn6Yo+EbnS867nwH2nxO/DF/YIpEu6rpOMplU0nXpSSuhUf7EeXg/HE6KQX5mG97vZS1fwiDL/vjPsxyDjDO/p1rOrb+g47/Wfrm5LCz9zLkcnzBjwjj571X/62WT9xKFihyjFGT8qgx/yNHJe1iCo77dQffm5ibpdFoxqPl8nkgkQrvdJplMKsuKHyTmcjnOnz9PqVTi4OBAFTdEHr21tcXm5ibJZJK5uTnFOjqOw+7urrJ1nD59+lgfcClESV/t8XisgEImk1EycinESVhUp9OhUCioayo9nU3TVOqHeDzO4uIilUqFcrmsZMeiUsnlcqqfsrDS6+vrCmDt7e2pvsjVahXLshgOhwyHQ0qlEuVyWY1hmYulxZ6EXUkRMRqNquKVruuq44SANX+XhUwmQ6PRUKBQgu/effdd1Y96ZWWFc+fOkUwmVcAXoJQq8jk7Oztq3uz3+wSDQTqdDpFIhPX1dcWWiyorFAqxv7+vwGsmk6FUKpFOp4/lJkynU3Z3d3nttddUuFk0GlXFw2QySbvdVrJyKVQK8yo2q0gkosCmWHKkaNhoNLAsi1qtpiTVApBFBm6aJm+//Ta3b99mOByqHIHnn3+eM2fOMB6PiUajPPHEE0p6LgVi8XqLhFrOt23bqsgp4FyY51KppPzkojSSIq2MO1FDRSIRVSSSAqaAXXn+S5aCpmkKgEshpN/vk06nWVlZUfehzGkrKytEIhHS6bTqqx2NRimXy8rydO3aNRUwOD8/r3IN8vk8165dUz3FJVANUIoL//pFWsIByt7w7b5tjmKkc12ikzZJO0SeJhGCtFsGCWZE1qEZh+4EukzRGZDT2pxbdCg9AQdVCAQhNYZdvODqlfuw+1sBtIHL3IUR7Yca1aHHaO/ci2DtLBL+ozusfNT2QrDjsGfAURgei0CqD08/skmaXd4shDFjDpmMw+4c5DSdlYlDfwpOG1K3YBSD1fKMWKzJflijE1339LzmAAJhCGsQT8Lcs9Qq/4Mz5R1ybQhNwGxAfwrmHHT2YPAmHOkwPAs3EpDIwr0nYXDfYZYNYoTuoFe3SFpNokNoDj1WsVEGOwgd3WBoZCFigTkEKwvjOMFWB0ybgQMkPA/xwNAwNXBGA2jtEe20SHRhbEC0B9bUQss8ZNL/IsznQSt5qK2/DXff9PqvpZZAX4f2ObBTMIzhmjGM6ZCQM0O3XHQN0KcwuQOzKWgm3WGeTqLGYBxi7/5Z3OxlyOyTdb9K2rDZckLYoQih/QHTPli5Ihjn4Z0F2Ep75zQVhmkAUlNY3SRS+Q3Obz2gr7t0YhAbmIz1EE4yhdZqAmPcoIU2cYiY2+iDKZ0olIIw6RqkNJt2dY/J3BDyAQ9Em1XQhgQaL7PyaEhtqrNTSqKnTdxwAje0DPsGxKOQHsLRa+i7WzSGYAc1pmun4Tt+EGI34P7M6x++9Ndg4TIM2xAawXgGhs5sbg8mX/HOY2QeZsDYgekI7Cm4I7T4FHPqKSLSWQjXoamDmfGKLlkNch0I9MBYhmkXciPIhsDdhFkAEjmwm17gXm0K+j6YZ8fc+WCKlhWnGKswCoZITtKgNTABc5DAGg2IrzsMz9fYvWITmofQpsNKVSOSgMBjYJYg3oNYBJpz8GAEczM483HIpHpoIVgqQPBdGGiQj8ITaZO62cJmRoogM2xcrcvUdYlisMqE0TTIxAJX73piBfrk422vj/mfc/srDbpN01QLcJF1iZ86nU6rwBK/N00WhcIey4JUKsB+FldaEfml4PLQ8kvvhOmWhFDx2omcVUCMLPSFmZNWWn5WRRa5kqgqIDsQCCh2Mx6PK7mghNLIJmBfAIsf6ErqtjDO/iRqv7dcAJeATWHkZT9k8wNRef1JAHoSSIuEWoLJ/ItHAWOyMBQ2SBaxwrwKYx2Lxb4ubEte519QyHmV3raSEC9Au9FoqLAmCQhqNptqUX2SPfW/t4B58YrK+fIXOWQhKsnq0WhUgUzxufvZIsdxVOu51dVVstms8lb7W6TJuRHGWUC0tDPy91sVRkPk66ZpHvt7f8ia676fwC7j3Q+0/cft986LgsLPponsW+4Tea28RkKL/Cy0vIeAZv948o9rYc3l3PstAHJP+FlL2Y9EIsHS0tKx++bbcYvH40ruLNdawrNu3LhBPp9Xi3vw5lORBDcaDbrdLqVSiX6/r0LQHj16RLPZJBKJ0Ov1aDQaaJqmAEGtVuPevXtMp1Pm5+fVWBV5eK1W4/DwkKOjIxYXF1lcXDwW2Njv91US9ebmJqZpKmA6mUxUmJTIscWrKwFV0+lU9cgWma9hGErNkkqlqFarJJNJ1tbW2NjYYHV1lV6vp4C2sPP+gpvMyTKWgsGgOk+dTkepbaSftqhfBKDKs0U+J5fLKeWQMMO9Xo96vc7LL7/M0dERjz/+OPPz82SzWQBWVlbY3t6mUqnQ6/VYXl5WYXbS1uvUqVNcvHhRebOfe+45Dg4OePDggSqcSB9zkZiLCsAfnhYMBun1erz88svcvHlTKZDkPAjjL/e5v3grhS0B+tI6Mx6Ps7CwoOY7x3HY39+n2Wyqa3twcEAqlaLb7VIul9VzuFKpYFkWp0+fVkWD06dPK3+yKFmi0SiLi4tEo1El+bYsSxU+bNtWRXYB3XKdxZIj7L4w8lIoAa9QXygUyOfzKjm+VquxtbWFpmkKNEsRxjAMNecXi0WuXLlCMplU7b9k/xYXF1lZWWF/f19lF0jCeCAQUC3CAJVPIOGHS0tLrK6uquvRbDaVnzyXy5HP51UYmzx/l5aWWFxcJJPJsLOzo6wawnIHg8FjIPzbdYtnu3QGITQ7xIQqLnn6hHDyDh/YgPRFaMe8jlDMQgzJomsNhskxjUPo7kLpEvQH0A/AYhjqX4H29iKRSJ3ezSmNdgYt3aIQdOgXBhyYY+69WWASrxK9AgkLHrM8uXk4C/U74LwB51zYfNomsehyyoBKKMo99wL3+hZa2STRaHHRbpF9A0Z3g7A+Y28axy487cmdR12ILMBo7LGryVOM0h/j9vTXKSenbMwgtQNHFpgLsD8BxrDgwsEhvJOCxwqQPw3uukamZ7EwbBEeQiDi5ZcNJtC3oGKFGIeCELPBToI1gWAdBneh0SLSsZiNYQzoZZiYQQKWRUx36UU1AoMGpwdT3CZoAciZ0MxDbDLFGtzD3rgPWgV6VejcJv7KGzgHLqPHnwB9EcIZD0Vtnmac/QR7hdcY2QcslCE+hfmDEVXzJcaRGpy6yvDUd/JObx+aJRh/HIx9QoOXCU4dui44uTwEzzEdbpHU9rB7Y6yXQnAw77HccQNmQYj1YOFPCHV/jbnDm4T6Lk7cI0VncQ0nkAU7QXC6hxGaMiJIUp8Rc6ARj7AXsFipWaQNGzMOw9hZaCzCfhgedyB8E23/Dm6zjdXSWexG6Nh9zKTLsJuEQhCCU49yjlQg9zZOqM/QiUIoASsfAfMa3MVLu0tF4GEcoqe9pLPxCCIOYHnXbVaBmQHThNdsfWaDa77XW8xhFg3Ri8BQg3gbFmqe99/JQ7YCWhBCZZhf9XatMYSoDZN92H0J0CC9AHrQE2CUZxCI2bQWoRtNYRdWcZ6t8pjdo90YEWCGu5NnFp2xvAiJNXDjNpMU9FOw8F2gPXSZhWB8GiYjWNA8An9/AsMU7A8gvQ5PnoJxEGImTH8f+ocwG0MuZpHL7NJ1bQzDQpvCKACLA5NFp0o+5JIeL2JSYEQYF4NFBl7Q3Dex/ZUG3QJQ/KyjnyGWh4gAA/E8AYqxEKDgD6nyM9Hyvn7Jsh+QngypEnZUgIR8toAUAa5+L7WfqT55PCeBzskvPyvoZ7X920kwLZ9xEpj7X+MPefMrBISZlM/3Az4/++9/L2F5ZV/8smM/mPtGwM7vGZZzfNK365f9C/PpPzd+1YNfWi4LRpGGysLYXwg5WTjw799J8PmNzvHJa+q/Hv7x5B8vUjTwKx38IFbGnfyt//3949b/eSeLMSKNlPEnn+G/P+QcycJQfi7vI/sswNifvA/v90X3e8qFnZZClZwDvzfUPx78Cgm/RePk9ZXzf7IA4j/Hck5FQutPC/523IbDIe12WyU69/t9DMPrVyz5ABIYtri4qPzBtVoNwzDI5/MquBGg3W7TbreVhLVarTIajZT/d25uTgHCRqOhGEgpDMo4kpCrw8NDarUa8/PzFItFNjY2VH9lCf0SgCVgRoo3kkotYWiaprGyskK1WsU0TRVgmU6nFSsuadPhcJj5+XmVG2FZXhtDYRFFASD3iYRGyjNFjlkYW13XFZMaDoc5c+YMlUqFw8ND5YMHFDucSCQol8sEAgFlpYlGo6q9WzabVaDy9OnTiiWWcyQgvtvtKluU2FeazSYLCwssLCxgmiYvv/wyd+/eVS2kZrMZCwsLqj3V9vY2juNweHhIpVJhY2NDyaSr1SqPHj2i0+ko6bgUsB3HUcUJf55CIBBQrHEmk8GyLOr1urLJCLstth0BpMIU+4H8eDzm6OgIQEnZpaguGQWWZanWcPV6HcdxlC9bAsQ0TVMWn+l0qsbGSbVVMpnENE2i0agqkESjUbrdrpq30uk0juMoAC9tPKPRKNPplOFwqIoF4v0WFUGpVOKxxx4jm82qtcbe3h7hcJiVlRXVhjQQCKh+4FKgTSaTjEYjCoUCrusq+4G/KC3nXeZbKYRISzEpRg4GA9LpNLqus7CwQCwWY39/n0KhAHiKKf/8+e28Dcc6nUmSFAtMaNBjhqG3ORubEumAO/W+jCEsRvoMxmMsd0ZtD4w65A1PpmoFPBUxTRg80InaMcxhmOowzUibkcw7ODEoXZtx6OzS2l0kNghSTsx4NPKC1QodmASBiWfNjVXgTNWi/jTcWzAYFM/AxmMwauFi08932HPfYq0/JrIfol2x0B+fgt6BkAazkMc460FoD8HRcFeeolL7Kpa5SX8K6zoUGxB/BDZgLkNJh9wStBagdwRX9mASnTEdQygEoxXYSYY4siMMAwFmQYtZPO35j4NDvDS3jGccD9TQx/sEdRinPTKWcIDZmVPolR7jwwZuMsiS0afcg72el6DuJmBSSuAExmjDEVT3IKqjNV8nMKxgZ3Vm3SvQfPK9yO0IzBowLMLyOm7+iPpkiVFri6uNA6iHqYZ1tE4Ht3kA4euQW4FMh1D8C8QPX2WuuYfb1Dkq2rgLBoRWIBZHn3aJOm361ha4Rx6zHnIh24AnKhja51itv0PIciEIZc0j1I/sCCRzEJ0ytSPoukVUmxEOeOFzVqKIlXHYmh6xYNmky2Akhl5SeU+DYQNNv0t8XMOKe3g/M7XJWA5ZB+rTCp3Ii7jXk7B7xQuVi+YhtQjRNMTOQPAGPLLBrcLpmedVbzhe77eg7iXL6z3oh2E2Rhsd4U5tSHRAK3uG6KgBuGC4jJM5TFOnEHWojiERhOQjja7p4pgagZxL4ikvA6Ey8YbibOgll0diMDU9e3854yWJ6yZkyrC5CJNSBIoL7FycYyV5yGNMiY7h4N0mVtGlvwKVKazgZbzVT8NCEObC0EqCnoLSGOYLMOdAsA1ODNoT6DvevTWYea/T14Go1xaP85Bggj2GWQ+s+zDsQMqYYbgzFpYgNt1mv72P3guDG8RIdRklgG+iLvlXGnTLQgKOgznxEudyOQVi5EEqAFDTNLVwkoeueOyGw6F6QAsAEJAg8l7p4ykLPwEnIq2T/0ciEQqFggKDgHrYS4K2n7n0Az+/3PikVBneLxwI6Dz5Wj+Y9y8uZIvFYkoh4GeX/UFy8lnyOvHOCyASOTagHtJ+dn06ndJut5lMJsfAkaS8JxKJY0nksrCVzztZ3BD2wA86BUgKay9yUCl2yO+z2eyx9x2NRnS7XbrdLp1OR/nET6bDw/stcfygUYo6fnAsxy3nwy/J9kujAdX/25/um8lklOxarn+/36derx8LcfOrA/zXVIoK0oJMPkuOQXzSopYQtssPogVIiz1CxoJfkigsvbDp0WhUeQYTiQSBQEDdF7LPJ9lqAf3COMmi3W8DOFnQ8CsLRCIvXlgZE/J5J8Pu/L53SXz+dt52dnbo9XrMzc0pD7sAHhljtu2lP589e5Z0Ok29XkfTNBWoJYVJ13XZ3NxUPbCPjo7odruKqRaWHLwxKIqRTCbDcDhUgFKu12QyIRaLcffuXS5fvszGxgabm5s0Gg16vZ6aSw3DIJ1Ok06ncV2XnZ0dtT/+AEVJmz48PGR3d1elmBuGl1g9NzenJNMitz48PFQybAFYN27cYG1tTc2lkpEgc6/Mk/5irbTEEi+0yML39vbQda8v9u7urmK4ZZ6RQoA/ZHF3d5f5+Xm+53u+h1KppI5zNptx//597t27pwLpTp8+zc2bN1XBq9lsKs91IpFQ0uZ0Oq3uYwmyS6VSXLx4kTfffJPNzU3FJp86dUoFWvb7fVUYkHPhf+ZJG0thmIFjYW2u+76/X1QJX/va11SrOFEDiJffH86o67pSG+3u7vLUU09x6tQpDg8PmZ+fVyF9IpGvVCrcuXMHw/AS4yXP5dGjR9RqtWNF82AwqLIjZI6X8yJFc5nfRJ4uxZnpdEqpVCKbzaq1gFzz8XhMvV5XRaBgMKgsDDIfrq2tEYlEqNVqqre3zP0PHz5URSQpigljL3kxcn8WCgVVGJAAQcMw1NyXyWTIZrM0m02SySTZbJZ2u814PFbXT7IykskkKysrKvldsg++3YuSAFtmkY5h8YydIUcGhxaak2fY6mInxkzSgA3xJTj74S7pQ6i3QDMgdxEKZ8BdgUbOa8NUvwdj26EY3ONoFqTLmKVIDwMvYM3VwMFlSpLKZoR5c8ZoHu6YcO7As466eOB2ugBru9Cfadz57DJsbMDWm8zXb+P0w8zcEJnhBDcLqUtD0kPQB1Pqu1/DiayAswTTkNdfeYwnLe5HCR9axHehWYdZBIbrUIjCesgLZ56mIbgBSQOm78DwHtwqB2mEoqTdHt1SlO7ax2H0JBgDiL0F6YP3gG8WjLHXqzqyCiGHoNEg1AA3GCKcmKLrGhTncVYuM97bIag/JHfgcvTAY1DTYeiZETAjRAMm/Twwa8K4S3xaIbTr0NI/Bit/H/ZKEHM9lNuawqm76JGvktl/g27gEsPEc2zf+zJ5rUFKnxDeMmm3B5hXGiTiDunRERvhAVEdqi3oTEIMYzFIbMB2HrrX6Do5iH4Zzh54dO7WKZjvwdUOnK/i7HcwH7kUJhAZw1iDRBoMW8MKah6d6tokow5RYDCCmANYdQZuHLeoEQrDQgSs6QNuJz+HeyMPJR23GWZghIlHJrQ2NPZX4+jjFEW9xWl9xl77FRr2Ppb118H6Dhh+L4S3YD0CuSyMwhDcBOM+HL1O6s4jpobO2JqDwgoETNh+ANU0Ac1iRbvJ2AlwyClIFsBMQFB7rzVbFBJLVCZBlicT0iGYXIZk0CWwD+NmEsscczg/ZWcpTDjrcH02I94B3YbiaWgbUO9BZNezuwdTUMjDdlh7r2fZmM76Bn8cnbJQaxINuXTXA7hxl4lrMX8fCtteaF87DGs9SL8L9nkYBr027WYN+i7ESmBOINeFYB96YS/mIBCCqQvZxyCxAtUGBJNQDEKvBvoKhLbArsF0AsF1SCRtVnSbVGvMaOrZ3FsPvrk556806Pb7fv3VdgGRsnAXoJhKpRTAk0qwSPvkISQV8JPhZ/4AH0C9Xh7K8vAWcCIAQ8CFACj4+rA0P7t8Mt3aD4T8LCq8H+gmIFJk4Cf94sKgnmTJ/aFfsp9y7P5quciWBWz7Zdb+xPc/jaGUxYlfieCXG8t7+hlM+Vz5vb+fuJwDAVSAKgiItUDk1X7mVACinHM5Xj9z/I1UBnKu/WNLjsPPvJ6U0X8jdtwvhxf/XzAYVEDa77/2M/wiDZfxIeBTxpPss7CAwhidZNhPSu7941O+5HyKIgCOs9H+45Vz47+eAvj96g8/Sy+vP2lpOGnlkO/+osJJVYv8TMagH5ifvJ5yfP454dt5E6Y3nU7z6NEjTNNkeXn5WJss8YHOZjMlWRVWTs6hv0WVhNlJQJcwyVJ8k2LG3NwcrVZLja1+v0+z2cR1XVZXV9F1nXq9Tjgcpl6vc/bsWd555x0ODg6UX1yKefl8ngcPHhAIBPjCF76gvK4igZb56Y033uC1116j2+2q4suNGzfIZDLs7+8r2wV4SeO1Wo1kMskHP/hBut0ulUqFWCzGwsKCkqrLfSfjRsLgstmsYttFkiye9VqtxsWLF8nn8+zs7FCr1ZSHezAY0Ov11JyWy+WU/F/XdVqtFh/5yEe4evUqzWbz2LzXbDbZ2dlhOp3S7XY5ffo0S0tL7O3tsbS0BKDAcCAQoFarqcCs6XTKaDTi0qVLXL9+nUKhwJkzZ7h+/TovvPCC6o+uaZqylEjBQ+T8UtyQnAC5v2VOlWeJFCZarZay8oA3p9VqNRVaJ6oYkeuXy2XVds40TSqVilJfXLt2jRs3bvDw4UNV2JZ9arfbbG5uUqlUVF9yP7iVZ7r05ZZUeb/dS7IHhI2XecofaikFxWw2y9zcnJKcyzkuFotqnIslCODo6Ii9vT3W1tYIBoPE43HW1tYoFAqK1Zfk9H6/r+4XSfaXOTSXy6nANrGbiUIrGAwqWb4Ud+Xnsu/lcll1DZHcEnh/TpWC72g0UqGi3+6byQQ7WCJmJ9ikxi4GZyhQWDRIPQNuycsiG1zygssir0GsDTwFw1V4GIaQA9YYtEOw/gTCDQjlBmRbQbSYTWrFwRzB4CEMazkC5jpJvc3yeEz4FuDApu6pfMN7QAdW1qG75vUizjdcAvUw1pko4XdbnNp2yKZHxBZGdEx4NWLgfsjhzJc0Up+PkJ/ep/G9n8Nd+RQElqE3BEOHcAD+5A1Crx7Qa+sYPYfmfJCDZ84STvcp71dIp2aMw9AGoi3ozuDwSpTehzag66JX7jKLh2DhKoyegc4EImdh+joEuxAYw3QXgmnIXYDpHuGwTSQMaC79AMSGNtRqcDGNkWtxaqdLZAdaATCKcGTCrD+jYLTQJhrdXApowKROUJ/h7meg+hHIXYNJE2ITD4UFgZU64cp95h9OsUM7dK9d5PDxy4SPvsSK6zLTwQ6NiATvsxwArQbNFjiHMHGhlTaY8WG4/THYKULwLISfgN55MNtg57yo+eIMFoB4ADddoh+OYFhjL28sAbE0JKITJs4A7AiEQhjamGDYZhwI4ho6C86Yg7bLOJ5Ej7cJ21CKOOyNX6IXvwLZBHQ3QDOJ2VMCIZdxNoiTyDOu90j2bTaGDmlzj63BV5gVPgzTG+AWIFiFwT6MquB2ofE6mc2bLG/NmLRBP9hlevYNehGXaG3GQh+M+0HSYzA3TA7Ht+DSd3mUsuFAIuw1Og8m6Md0qiaELK8tWOgJCMZh+qpGJKbRykAjWyYw59KK7lGsQXcLhlFwF2HkQv2WQX5iEMtNYQyZhy6ZCwd0jShu8DSDeJD7a1W0vI3rRmHSpzja4VzcIhzwAuHP9yH+EA6/puHuuKRuAGfek7LrYIQhMYJUFdz74MS9OsK057UfD815DPww5qnnLQNCy7CQgGzZO3WjPrh5rxCm6Z403ql53euG3yR6/isNuqVvtFRkBaD4pdCxWEz5uyXJVh6ijUZDPdzb7bZqlSEeL5ECygNYfiaVfHnAS89Yf0iUHywIi9ftdhVz4Qfg8mCXsB3xKKZSKcUgyGuECRemVQCOhICJf1iKAn5gJB5oSeLNZrOk02nFZsnD339+ZREiwTcC7AWQCUg/CZhFbRAOh9U5l9dJUI4/fVdki7L4kfdOpVLK/y6MkLCYfiVCMBikUCiQy+U4d+6cCmiS6r/rukomepINFY+cFEZE5ih+bLlW/lAwKejIJosnkTX6Q8wkLV+YIinM+L3jyWRSgVZ/UUDCgKTljYwBOdd+BleksSKvlMR7AbZ+ibf0EpcEekmRl0KGFAfkXoD3GfyTsn1/uz1hruR8CrMqY0fkkHJuO52O+rlcB7+awa9oED+mjB8pyMj95h+bJzd/EcVvF/l23iKRCEtLS+i6rtg3YRXD4bBi1MTjK6nuFy9eVECtWq3yxS9+kd3dXTWHDgYDwPMvSzss8ACf9GW+cOECh4eHCmj7VR6SvCzMb7VaZX9/X7XVms1mXLx4UTGp4/GYR48ecenSJWq1Gm+//TbLy8sKwAgTKYnTch/ncjmeeOIJ8vm8Cr6S34XDYYrFopoTpOvFYDCg1WoxNzen+kQL8yvS43w+TyqVotlsKvAqzwK5Rx49ekS9XlfPjvn5eWKxGJVKhXQ6zdLSkip6yP0s4HxxcVHNmdlsVrW+WlhYIBQKcXR0pFLapTgxHA4VuzudThkMBlQqFfW30kf6M5/5DNevX1eANR6P87GPfYzxeKwKdlKUkp9JsVqAtRRZRqMRmUxG9UUXxjcQCCgLgVxvKag1Gg2azSa5XE6peUT5IDLtTCajErelWC7vIcFj8qwyTVOdN3+hs9frcXh4qJ5dwjSPx2M2NjaO+ZcFgIrv3HVd1fJLEvFHoxGlUkk9W2WuE1WBgG2xZDiOo56dsViMo6MjisWiKmJIgcM0TdrtNru7u0pZcPbsWVzXVfaLhYUFdbyhUEhlkYhiRfzj8kyT+1v2odlsqlyFZrOpngEynguFgjrf2WxWPfsajcb/NRPX/4nbhDThyRIOIdr0mREiy5C58gw9D90uzMIwzMHsGkyznlw1dNH7fjSD8hGMfhPabxtk9oJkxkEGiT7EZpRXIH8Bwh3gCKa7aYpumfD8LS48OeOuC+MtmDc9j3QkAUYLkiEIJKG7AmdPQ7V6wIP9LMnQkPCrOnrBIHFpxjthnZ3ZHMa4wegoxnO9Zzj90quYa7cZLn3Sa/sU60EkAs0JWneHQM0h1E0yCfcw8xvYl/4hs7LBIPh7xHsvYOgD+k6UXHhEcM6ll3zPbJ4I0o9V0AcDqA1Aj8I0A8YcWKcgeuiBvUgfigYkF6EZpZ+/wOzMXdxRn0AdHMshyAOMR4cs13ucn9p0QpA67cmE2xWN1bQNSwab6dO4RgYmLdCzjGoDnG4MnEXoWt5F0DOeRCAFJBeZtlMcRZv043GIgbuisx8JUB+EmRUdrKCDOw1gDUzSOzaz3SBufEaiDMP2Kah+H9Huk7iuyTjowDjh9c2+O4Zp2Atl6xvghCFiQCiOnQoxscZYGtTD0DcjDAYRQuMaWjrCJLZEa7RAX69hFYtYAZdB+x7J6RTN0IkmPYAYAdKjPr3+HlhXIbiCrt8hHXKJTWDUaTKL9ihmJsxanrW854CTWAAjBbYLSRPGm2ANYDQC8wHUHjGYuhxGodSC9MBh1p0SqEB4CKMehI8KDF2HR4MOhM95DbYzmidVD5lgT8COYcQ1HNe7JEsR6BmwtQLFepeyBnXLACtBUO8S1z21fCIK/Qa4EziXgXHexsGme9ED4eUGfGhrxJeLe/RSeQgnILuEq/XBrJNtV7i4a7FoesqM8QVYdKF+S6PWD7EwtGHokkzZhA3Yd6DYhuiex0qPuuBUvH2xRjC3AdEAaBqsZqBeh4YFehL2p5Cdh1AGzBZEYxDsQee92lUGCAY9a/83s/2VBt1+9k0W5/D1ydayKBQAKMBVmJjBYKAkhiINl8W7MI5+5tHPuIos0C/JFYZIFvcitZPXyf8FXMp7yu+lT65I2v3eWgHRsmCRxaJIcoUd8vvVAAVO/LJdYYal1YgsXPySeunJ6pcSCuPtlwMLSPRLr6XdlPxOrhm8n7QtbdwkyMUPOmVxI2BKAKDfCyxgXwoswkQkEgllL5Aihyy0pOgi59TvfxPFgF/6fJJR/0YeejlG+RthxvxAV8Cx/1z4Zfy6rqvjl88VNmMwGNDv9xmPx2qBK6Bbjl/+fTJJXu6Jdx7YpQABAABJREFUk0z3SQm3n3k+CU79111+L3/nZ8jlPU56yGUBLZ8jx+dXdkihRc6JXy7pB+DRaFS9j+yL/3NP7rv8+0+T5H+7bnJdJC1Z5OT+AK1Op0M2m1VyW13X6XQ6KhzrzTff5I033lDnP5lMKu+yP7xSCiCDwYCFhQWy2Sy3bt3i4OCA1dVVAoEA5XJZBUTK2Bc7yRtvvAGg2uLt7Ozw1FNP8eDBA7761a8ymUw4OjoiEonw4MEDdnd31T7oupf2fOXKFW7duqXaLH3/938/GxsbWJbFpUuXODg4UP2vpfgnBScpUBQKBcXiCsiZm5sjm82qYoMUz3RdZ2Njg0QiwZtvvgmg5h6R/LquSz6fVwGWUnyNx+OcP39eBb2FQiFVVJP39quLisUivV6P+fl5TNPk8uXLnD59mna7zY0bNzAMQ80Puq5TqVSUf1325bu/+7u5cOECpmmSSCQUYJMio/QxB1RIp6SQA8eKh+LDlmu4tLREuVxG13UODg7UM862bbLZrGrFKHOWtOpstVpKvi7FArEdyb2/urpKOp2m0Wgo9jUYDDKZTOh2u2o8zs3NMRqNSKfT6vh0Xafdbqv74OzZs3z4wx9WQW8y98izShhxYf7lnORyOY6OjpifnyeZTKpxJPO2YRgq6VysU6dPn2ZjY4MvfelLPHr0SH3+6uqqKqJHo1Ha7TYHBwfk83kymQyBQIBHjx7R7/dpt9sACtiXSiVV4JfzEwwGlf1IwLbc61KYDgaDamxIEQHeV+5JWzyxFYia4Nt9mxBmzQWoUyBMmhwaIyauyzgIkw70q9CcBzMHk0uefHjQhcEU9BC03oCtPyzS7hc4S58kM4YDm7AxJWZbGBok8hDOgz7aY3DUJvKhMUePwYMXwb0V4HwzQHh5SvE7HEKPQTfmkYyJEeg6PK0PcN54nQAWqbiOu6tx96HG/rNJtAcWxd+1oZbmJiYbzSVSr99m+PgtsJ+CeA6CBmgB3AtPMn73JYLbXdprj+H8rR+E5UswmcHKDzLsXIDO1wCTtlEnkq5h6C3sURUi81hLKc/IHg5B0/aSq4wQdOYglIPAKiRdWJmBNQU7g7vxtxklXyf25n9niQGb2RBGAi6N2swFvDbU9UXQbGhHYKYZNLoG/ehFrLMfhs47YEwhtIjdaxGcOkxt26M7ZwHoOl5ymV2E7WVs4yztaBAn9hSkNiDfYDqXZWosQs+FiQF6mn7lHRbzFWZti2bW4FBLY2mfAe0CAdcE4lgzB8ce4Uxm0A96YDCmwxAwTajPoB9jHIlwF4dxNI89SeFUNyA8pGR+hUy/w4NYAqv8FLPYhyEwIVD7Y4ozh9IIEpERkSI0ezDugx22QTNhmoLI4zjx+9jDBhHXpjy1YGBhJmA3BcszaM4i2IuPg5mCSAPCd2G854UNjI/Qu3dxhyOckEZoHow0VNLQScKaC8UJbNowna/RtzQOz3wIrnyn1xotE3gv+X0GWhimy4z0NPGoidGHXMrr4vbmHNz8hM47exEGy0niyX0+UB1wxoJOBvSEl4EwaYPmQHQOAovwxgWNw40YT/y+yfIfuDxhdnj7iTdpr66iTUdokyFatMti2+TMHY/8f1iGRwFY2AT3SKeNBk6GRDVO751djCddhhHYMD0Lvp2B4DzUH8L0jlc/smMQiHp5g87Au8/iKQg0YFSBRArGA8DygDkGFHMQt6F94FkEzMk3N+f8hYDug4MDfvInf5LPfe5zmKbJ6dOn+dVf/VWefPJJwFuY//N//s/5j//xP9LpdHj22Wf55V/+Zc6cOfPn23mfRFbCVQRA+uXS0g9UwLmkgFcqFRqNBtvb2xwdHX0diywPYmGH/dJmAXLy4JPXCmsim4B8kQT6ZfDifZW/E2ApCx4B3dJzUxYlo9FIMYuyyJNqvRQQRqORCsARsAwcAxvS81i+ZKEtCz7Zb03TVGCOFDoExAiDJcBK/PPCWPgZYWE5k8mkCuaR/sySiCsJ3bL4lIT3SqWiwoJGoxHxeBzLstR1z+VyrKysqPZDsVhMMVwnA9HkOggojMfjlMtlxabOZjPlfxN5ovy9P5BNCgqy+c+HHJOAPAmy8vvvBIxLAcV1XZUwPB6PVUFIFmh+S4MfQAtQlwKKJLT708uF4ZMxLK2TZNEpx+cPvBI/uUgY/R0ApMjhTyGXpN1+v68krvK5AriFHRLlhCz6RaEiIUcyxkWS7j8GWTD7ixdyL/qLXf6igHwXICSL1W/nTQpwMlZEAn716lUcx6FWq1GtVtXvh8MhxWJRXav9/X3efPNNda5Go5EKKpPU6E6noxhSufdSqRSPHj1iZ2dHgXhRlVy7do319XWl3tje3lbgRoLeQqEQt27d4umnn1bXVMLbEokEzWaTo6Mj5b2WhOyrV6/Sbrc5PDzk6tWrXLt2jdlsxnA4VH2Qt7a2aLVaqvAm41oYTQFnvV5PKWX8xTBhREVqHo1Gj9lDCoXCsfEqXuFWq6VY21gsxuXLl1WCuMiQxSYh95vMJ7Ztq2C1z3zmM9i2TbFYxDRN7t+/j2VZijkWNYNlWQqoDgYDPvCBD/ChD30IQAXBxeNxBTCFwZXjF2+2SKoXFhYolUqKtb9z5w6madJqtXBdVzHBEjAG7xd65b38RdJAIMDi4qIKhPPbi2TeEDuD43jBbpubm8csDv5e2qLUkee2eNv9XnvHcbh8+bIK6RM1h2zJZJJut6uua7PZVCnea2trZDIZlQzut1+1Wi2ltBLVWzgcJp1OMzc3x8LCAq+99hr1ep379++zsLCg2rSZpsnDhw/V831tbQ3DMDg4OFDjUJ6/gLJPyTMS3i8Uy+fKc0SKDqJaEGZffi7vedJeJs+j/zuA7kxij9SghM4eujak5epMw02urFscAuY+DF8F7SNg6tA1wSiA43hy1MABNL9sUBsWaWpRFl2HGlOGwIrRxTEtOocQKkC7CNEPWJScDrVLcLgNsxcz1HpLTIlR2jxkOr9P/iPQXYfMFOI7sPeqB24+WpqxFQDjvI2u29y8naf/4QvEZm9QbMVpOyk6jDDcDNl6kKPKQ9ylLkxzHoJIxuGJGwyHWwwrdTj/PJy5DtoMhkMoLMHiOmxeAXMfJzHEnNyByT2vD/TwCGIN7wRYM6APWsbr4WzoMAgBSRiOPeNsPgGNCiTPQbDJugVBTWOUXydlVVkwpnR1eBiBWQ7CLZg5YKeCNMM3oPzdnsxgfAjxBSBKxoVQyMacjTzK0tC8fZs6Hvi/dQbC/w+cgAW1EuwPIT+CZBIKWa9KYiYgHsOexHiYfgu3MGT69hJ69yMEpx8CXcPCBJK4xNCdKM50ANoA3Jl3bMGp19LL0iGcxE6cox9agfEpqOhwfx5WbtIq3iO3s8cFc587mSRW/ioMq+ScFoszCA88EHhvBA8NAz1gM9Gjnn9aC4C+AbkPMe3eZur2qBsaacNlFoCpDoNdsFI6rLjAENJ3wfqqR8uGctDcx+1PYOoQHUN05p2uScRjuFMmhKaQC4MTt9m25rEKHwar4BVPwmMv+SziemhRW2E8fgLL+n1OhWBwCKEmbETg5UsGg2yWXLPPszs9lveAvJdP0Dryhk06DcM7Xr7f9AJUUgUGc6vcO3WTwNtjIr8Np9/tUr10EyfvEM5A0ITcLYgPoLUGt+dhonuBZ1bYphfU0WcJYq6LO4BgDOYzQM+T+jPxhuus7QW2hxeAmBeq5gxBH3r7M26DewDZqtd6XXO9+gqO1xYwoHtt8WZZT4WizYBbf/4551sOutvtNs8++ywf+9jH+NznPkexWOTBgweq7QnAL/7iL/Jv/+2/5dd+7ddYX1/nn/2zf8YnP/lJbt++/XX9sv9nm5+1E5bUH3AllXYBC/JgEfDS6/VotVo0Gg3VGkQkkn7PqMjqZBNWTd7HH6QmQFIWssJUCnMiCwE/syjHIL5XkR4L8y1MjoSe+FO4M5mM6rk7Go3U4lAWwsIgynH7vbMCniTZ3e9/lgevyM79n+kH7n6WFTgGuoWBh/dVCfIlD35huoBj/nQ5r7FYTIEwYSYAtRiT9irZbJZisaikiAI+/d5meU+R+wsTeLLntRQpRqMRvV5PnTsBcn7Q7R8Tcv3lNSKnFTZEQnr8Kgw/MJR9lGAxv5ze39bLz7zL9ZMFur/vvFwvf/CYfwEm1+UbfYkdYDweq7HoT4/3S+zl/ApQkPEirJYco7BAUrTy9y6Xe8F/vAKsBeTI/e1nvf1KEv/P/Nf3JMMv10rOwbfrJnOJSI+bzSarq6tcunRJXdetrS36/T5Xr15VhaF4PM7W1hZf/OIX6Xa7KpBJWDcBibZt0+v1iMViKkRPkpYFGCYSCWV5abfbaJpGPp/n8PCQcDhMJpNRjJ+Ar1KppDy++/v7OI7X6qxYLKrXCeCQOcB1XdLpNN/7vd+Lbdu0223q9Tq5XE71kk6n0ywvL5PNZul2u2pukULcaDRib2+PfD5PoVBQKhlAzeGSUi0+ZMMwVCtGmVPH47EqvEpxUdd1JTWW1lyO46j2U+L1dhyHRqNBu91WLS/9lpVz584pWXiz2VQtrwRo7+zs4DiOKn50u11OnTrFmTNn1HNALFO9Xk/ZUsQ+JZvfphQMBrlw4QJra2tK0pxOp5VM++joCMdx2NraUgU/SWSX4rL41s+ePUupVKLZbKoWYnfu3FGMsmF4wXRvvfUW/X6flZUVZUGS8y5gWK6JzC8iUZcQVL9aLJPJ8NRTT3Hp0iW1DgBUb3HwVAqVSoWjoyMCgQCNRkNJ7G/evKnmcP986k+5H41G6vnU7/dZW1vj3r17xONxHnvsMV566SUCgQBbW1vcunWLXC6n1iGnTp1S40L62Nu2zdLSEsFgkFKpRC6XU8UCmbsk0FWeRf6WjFLIBFSI3mw2o9/vq/WIWMtM01RriW63SyKRYHl5mbfffvsvboL6S7BNgg5b6IRxKbg5LM3l9NVHnH/GpTaB6RQO3vCCqq//dXg7BPfCXhJzdgvM39QwX19hoBfBbVKzOwTQiQdsuDDGtqD3lkb4gy7DAowWoRGC22mI3YelSZYIywwYMbIitA88Zu2gAA8P4XQKYgUYmZ5UNnoQwNQ0SsEZrhGH8nWs/Sbt3AMmvSY56yJRwgy7Bu50zQNvEdvrz+QCROB7f8hDXr196D/wUrrDKai3IZKCyAZMS9DpQmIZCs96CWGjr4K5DXsDyNUgN4WOAZUZxIHZCCY2FCLQmMLYhkAAdBcGW7j2hG23DIEwy6MugyS8RZCuFSIYGINu45gaxDJQPgWZuIcSs5chm4PxDmZPYxoHlmpwt/MejamjDV3cwAhtFiQ4OosVcQmMEsxuNnDNc1Beg6dDHup6tAPRJsyfZsJjsG8SbZzHts6ioxGwbSYk0JjhaBNcLQDTKEQ1cG0vzj4IDMYw7Hux7I0PwPYq7K1BdAh5G8JZJhur7BtVFjenlLWHVGe/hxV+gmZsg4eDd5kvWtRj8CBRxNJCXvDZ8ndC9oyXCDZYh/5VGrM57ESPjpEga/RZacCj1+CwotG+tAyBIpQnEK+gVR4QaPaZBbMwCuHaBrGAhWNAbwyZDiwM8FLyh9CNQMXQaacvYi19CtJXvDj+oP1ej7cQaCMvsT2WZVY/R736R1zpzajehkkVkmN4dnuGaxyiP3IJTKEa8TLYbBsCWxAaw1SDWRfcFrzxeJ7+2jUi97a5Ep+gfxcc/gGsvhEg/7Ug/YBGJjnDHkYY6jO2Pj7m5pJBLa7z/L0ZqVtQ78KSEyOoDymtN8muuTh1MA68YccYei2wOhCsAKsQugTkIBQGCy8UkQiMpxB9L2StXwPHglHivVtC94QN6Rik4tDrQvx4k6A/8/YtB92/8Au/wPLyMr/6q7+qfra+vq7+7bouv/RLv8TP/MzP8JnPfAaA//Jf/gvlcpn/9t/+Gz/wAz/wZ/6scrmsEnZlgVcul8nlcgosigQN3k84lwVFvV5XPm5hMOD91Gm/19QPIPzeXmHN/IwicAx0CVPqDzvzM3XSFkRAmd/7Kw95AXkCJIX5lIWRAAk5Bj/DLotCP0M9GAzU4jibzR5jT+U6yTkT9kmO8SToOQm6ZX8FzAqDLN9PFisEqMq/AfXe/jZvckyyeI3FYuRyOeW/lEW5LECGw6GSW8v5F/ZW2B1/grUspIQ9Fi+q+CRFCSABb+JN9QPYUCikegmLZ9MwDMXqisRSCkXxeFwVEBzHUUzLYDA4JhH3h9v5/ciyaE4kEhQKBRKJhCo6+ItGcg3hfQZUwL2MJT+oF9XHaDRSLfD8MnK5ln4fpXz5x7hfAu8vKPl7F/t92P7igh80SzHHX0zwWw38n++X1cs5kv3wq1W+3SXmfquC67osLCzwt/7W31KJ4uKdrdfr6p6pVCpcu3ZN3Sd+j69pmsr3LZLc2WxGq9VSnSAWFxfJ5XJcvXqVWq3G9va2GpvLy8usra3R7/cJBoOcP39e+V7r9TqAAu6hUIiDgwOee+45Hjx4wCuvvMKjR4+UF1zYYGExpW93IBDg3r17HB4eKhUNeN0XLMtSLOX+/j57e3tEIpFjPcT93QRErivFIWnl5ZeZt1otBoOBAtMC4qXwK4yjbXsp8alUCvDmJjlnUnCV1mZbW1tcunRJJWILSOx2u5imqYIiQ6EQS0tLjMdj7t69y5tvvsnDhw+Jx+MsLS1x48YNrl+/rmxCMuYTiYQ6L4BiTWUeF690v9/HcRwVrCdzaaPRUHOnXyEkYG19fZ3hcKgUAHJNC4UCly5dUl1CHMdhY2ODBw8eqHEYCHhp6TL3P/300ywsLDAcDkmlUti2TaPRUHYGKRYL0Gy1WurYpPVdJpPh8uXLPPvss2peFxuXKI1k7EgwoIB1Af5+S0Sj0VBqLblHcrkcnU5HFQGvXLlCOp3mpZdeYjgcMplM+MAHPkC73ebBgwdqrh8MBmQyGS5evMgTTzzBO++8w8OHD9XzMRqNqk4so9GIzc1NFfwmKeTCXhuGwdLSkvJlnyxM6boXDCfZBVKA8ee81Ot1arUajuMoJvzbeQt18yTQsDiFS4TVlbf4vn9kMV3wGLDlKNw6NKi/GCO63Sd+DQKXYPaEJ83dvB2gOo1iFjW0bpiOHWDdqJMPOswMD2jMZhqjjsvcPtRX4Y1FL+386nUIPjrE/dqMRdsilWkT+gBM1j2p8X7QYO+KQTZjUzJtZrdAe61I2IkRNg44Z9R4/eA202efpfrAJRZ8SG/bpTteYGQCo7hnmE3anjx7ZHltvQIZ2H4BvfKfcSNx3PlPQ3AFQlkI2TAcePLp3jYM34ZEHIwYGBbUQ9DuwextCJYhet1rZD6YQmgGVtZrP2UMPJBaCoH7EIZ7PIwVmM6vkhg9IIHLu0GdrpYCK8nMtpnZbS+JPFXyaMVQExITTw4+CcPERjNt9GAfAm+DcwX0AszGBG0DywHN7RBkRMBM4RJkZobhwRJ0J5C9A+6XiWy/hhODaf1ZuP8x9K2zWFYIhzFT3QXNQbfjaFoINw44LkFzhuVOcHNBjwbtjWB/BI0B1A14tAyDkhdPH5nCcgPSI+jn6C7MYWkHnHVmuIM3OYyewU5/mu3hDDd0k74dxAovgH4WGqvQu+o1mS73oOXC9ikmC89Ti+7hNGZ0A5AbQHYCj4pprPN/zQvMW6hB6IjQvkO+OaUZajLR4xAJMNFBM6ZMAi52C9IGmGF42ISABaN0Emv1w7D4IQ+NRlyYuR7SjIYgHIT5mCfvmKzTMfOM7x7h3INeGlaGOtlbLs6cS8uARgySQY9hbofATkPehe4eaMBwQae+eh4tnWDjq7ucfdulkoXSJ2GwY7H/lk6+FcY0YTvj0F2b4DwTYHRN49w7Nvk/BOsdsDSIBkckk0NyZx3MAWy9FiPUzROP9omkO1gDSHU1nJCLvg5zFyBe8AL2tRkYEa8wEHQhrHktzmIpGDQ8ZjuRBiMLsRDEOrDdh1oVHPt/MrH8T7ZvOej+3d/9XT75yU/yt//23+bLX/4yi4uL/KN/9I/4B//gHwAoKfcnPvEJ9TfpdJobN27w0ksvfUPQLWBUNkkNzefzyidYKpWUj1cWMwJaRbLrl9BKuyZZyPhblfhTlv1hXf7F+8kQLT+zJ4yHyBWl8u5PB/czxv7qtCzChBGW1wvzLNJaP2srC2M/iydspUgF5ZgA9X7CEMmiXJhIOQZ4X5oqQPokeDnpnxXWwX888rnyWX6G0w/chTWQfQSOKR/EGjAej5U0MpPJUC6XVVsUP2sthRR/ayGRKvrTwP1yZHg/Fd5/XWXcyH75PZACGGWxLQFm2WxWgUN5T3l/Ad1SJBCwKr5OkUf6E37918OvVhBvqzAV0spLALLfCiCfLefzJIstC2hhQkWG6wfA/msphSz/mJHr6peV++WLEoAo7JUAelmwync5Z3INZPEuxyHX1F+EkOPyj03x0/sLBP4MiG/V9vM///P81m/9Fnfv3iUajfLBD36QX/iFX+DcuXPqNePxmH/yT/4Jv/Ebv8FkMuGTn/wk//7f/3vK5bJ6ze7uLj/8wz/MH//xH5NIJPihH/ohfv7nf/7YnPNn2Z566iny+bxq5/Wxj31M9bKORCKq0Fav1/n85z9PJpMhGo0eS1mW1kH5fF7NweJ9DQS8lle1Wo39/X1V3Hn77beVlPfUqVNomhfkFQwGefnll7l37x7nz5/nox/9qJLTfuUrX+ELX/iCKgSWSiW++tWvUigU+IEf+AEuXLjASy+9xL1799RYljlSJLQSMnV4eIhlWRweHlKtVonH48p7LbL6O3fu0O12lZw2mUwqz7fMcSKtFlbctm1VMAiHw/R6PdUb+tKlS1iWdazv9cOHD0kkEszPzyuvsYAbUWzI/F6r1ZCgQEm7vnjxojpOKfgNh0NqtZqSbGezWe7evcuLL77I7u6uKi7s7e3xxBNPHJtX/c8zeT8BsYFAQCkC9vf3OTw8ZDgcKtDX7Xa5d+/esVyRYrFItVolmUyqcy7z/+XLlzk6OlIqhqWlJeLxuCpgSt9ugLNnz3Lz5k0ymYxSQ0j6+5UrV9RcKEURx/GS0WWOFem4FDxlHEiRQ+ZqySOIx+PKQiQ2HJnD8vm8GvdizxErk1gQpP+4vzAqcm0pyq6urnLr1i16vR6z2YyjoyM++MEP8oEPfIAbN26o1nhzc3Osr6+zuLjI9vY2u7u76v0ymQzj8ZhYLMZwOOTg4IB4PK7CRSUUTVjqxcVFEokEwWBQKRL84a5SNIHjCjV5jojVJ5fLqaLIt3r7yzZHfsgYkE++gTnNoOeHfPT/3SZ3He7UIRUBpwNa36Buxvn8lzNkXoHhd+wRX4e0BklsXLcBgzAuOSZ6Fy02JTgJMns3TGBjQv6SQ60OjYfQfgrKOhS+BvMjSD81YXR1H8OBlSQ0o7D5MjjvahQv2VQ/VqSzeo29wCbLsYeUvmaTaQex7QiPVfr0f+vL3PuH/y+m/8v/k9n5F+m9+AbpL76DbWgQrAM3wb4M0wSETQjmoTJBP3iFdecNhpUgR7UqxNdh7RMQOQMVB2YHaL3/jWzvJsNagOl+AjcRg4MoiZZJwLhDVzNxz7fg/AXYLkM4Bhkban1wQ5AKQrQHe2+BE2V66eNg7VPe7lFxoFmJE3zYx0lo2PMlGA0gPYF4HmIJCPfB6r3Xw2yGVrtNwe5ihl3o34LhLkQuYvQDBLBw3RmOFsaMDiFXx42PoObAOAvJu1D5QyKDF8hGx4ysANMHe1C3cIwgrmYT1APY6ATsKY6hYYdm6OMQTtxmttiEkYHWS6JP29izfZjbh/wRuEXYTkKyC6v3vEJHzPWC3apn0BJ9SsldnAqMbItA4AWsSB7r3CfYbXfQJgOIngHjO2CUhkHAk1jYeehHoaNB7Gmc9FvEMi/TbkNWh4WnYKewDqcvQrcDxqtEjr7MSrtDyAZaFna4SycbZaInCTtt9JDNpAD9ELT6MItBKgUENUZ2CqIJsEwvjtyZwaADuZjX8LrveAl/8UVq8XVa2hGRcZBQyCKedbDCYK5DzIbMxMPngwBQBdcAfQFim14havu0jruaIXR7m8v3JlgvRrBLNoXHZ9z6ADz6hEG7buJ0DUYLNsV1l8PFOPFHY668OCOwCVYKsmkYWVNiFgxrcHA/g9H/GHXmMIcm0cEfEJyvMsy4ZOahfAFmKagGvTZihb6Xaj4K4FUDip7nXJuCHoHABC/dLgZuEsyQ5yrIVcFpf3Nz4LccdG9tbfHLv/zL/MRP/AQ//dM/zde+9jX+8T/+x4RCIX7oh35IBaH4J1D5/5/WouLnf/7n+Zf/8l9+3c/X1tZYWVlRD1eRSgmIEdAqTLN/wSAPNgGHwkzIAs7fU1oArB8MnAxBExAJ74MOkdXJQsi/UJT3FDDhB60CVv1g7uT+y88FhMrfi4xTpPMC4PygW0CMMCCyP1INFzAlMmt/SJUsFKUNi2x+GbDso/Si9Rc85LoIcyzeePEvV6tVlVbul4X7A16E6fYn6cp5Fjm9yMMFyMrPxTcsfsRGo6GOUYCGv6ggSewCNPxKBmFHhAU52eZNQIjYFaQPqjDNwi6K+sIfquZnuGWThZJce/CkviLpFLAt16nf7wOo4B0Z33KsAvpl0SrXXe4B+Rx/YcVfdJFrJ+8tSgjxep8sxMh4HY1GDIdDVTiS9/UH1Pn/Vs65jGGRvvvvX/85OTneZMzKZlnWsevwrdq+/OUv89nPfpannnoKy7L46Z/+aZ5//nlu376tJNk//uM/zu///u/zX//rfyWdTvMjP/Ij/I2/8Td44YUX1DF+6lOfYm5ujhdffJFKpcLf/bt/l2AwyM/93M/9ufbn2Wef5ezZs1SrVYLBIKurq+zu7gJeMNPu7q4Cl8Le+u9xyaeQ8yugSjzWjuMoK4Ooie7fv6/YZOkFn0gkKBaLbG1t8cILLyiG8PDwkL/39/4ely9f5pVXXqHX66kxIePl3/27f8f169f59Kc/rTIWSqUSZ86cUen/S0tLJJNJwBsvc3NzVCoVLMvi4cOHqkf0qVOnsG2bO3fuKPA6m81U9oTcg6ZpUq1WcV1XJU5L0FkikVAScz/YKpVKKoG6VqvRaDSoVCrk83mm06li0+V+FnVSPB5XUnjpgW5ZFp1O55jdRLzeb7/9Nl/60pcwDIPnn3+eT37yk9RqNdW/+fDwUM03wrrX63XVIUHmeE3TqNVqvPLKKwwGAy5evMjS0hK1Wo2joyNarZbaz4cPH9Jut2k0GoRCIXK5HI7jsLCwQLfbVa3NxAIkIXEC8sQ/LkVwx3FUDki/32dhYYFer8fe3p5SBBUKBS5fvkw0GuXhw4e4rsv29rbaB39bRNM0yWazOI6jGPbxeKyON5FIKH++FJal/dry8rK6LlKMP336NK+//roKGRR7mdiSpKApz/BwOEytVlPZKHJ/PHjwgFgsxsHBgSoeN5tNlS8gTHYoFKLdbqvCieRljEYj9vf3mU6nrK+vq/eQoLnd3V0CgYAqtqZSKTWuLctSLfJERee/12We7XQ6SnYuc650OlhYWPgmZsH/+faXbo681OPMNai2+wRXYOVp2NuHgAaJGDx8BbSaRiTQZmClYBIlaIFlwWQM4YFBkgSaFgEHMu4IwwJnmiOqWTjxCaE4RNpe2Hb0xRClvRl902VUjeFuTImdtXAKEJgD4w6Mf7+A1g5TvttitN2j89k41tnvZPeVKVboAIc0FjpGwOb8Szbj7d/h4DM3mH3qWbTJmNThl6mGi3DqEowi0DRhKQWJJLg6xDWc+fNUj4oUrRqJh/eZRXeYjqu4iz8C4xha53cImLcZ1jQisxGBzIhZIEjWdEgMXBzTZVStMXHfhOImpD8EwUsQ6kPAhXHMS7sO1EHvQ+wxKCaJ7r1Ivj/jsAbBhknmwCZQaFKfDpmm3PdoRwMwwX7vmZ3MwHiXUONrtMZxesU5mJiQbsPAxXGmjA0b3dZx4iPctbfRpp9DJ4QT/R4YPw+DGoHkHQKMaRxCOG5hzI6wI2MIgevUmRZmMEriVFI4IR1tAgG9xnTjZVhowcFVtPtLGNSx5yswdxPCt2D+cVhzYNyC7A6k0hAvegFvvXlcymi6wWRiY48gqlfoGwfgfIJp5rshuAOjy/BGyvOK3xh5qoQ7CZgGgB7Ul2HhM0wzVVxziyPTwSwEmF5egdQYhrcx6l9hfXufdN2lGgZjBrkgFJwRdXPMLOsydsAdeplw1hjiSZgkdYaxRYjmIBLw0KYeAacO7lsexRs/4/Vhd1pgTBidWuWFxi0eu2OStUC76Hm39ZHHHkcCwJrHGkffMHDHAWqjCXEXMjlopCMQ1Sjd3WFlBIfJMaENSOugNcEph2is5sEqoEfrzIKHJDoDcn9sM/lSHLsH0egQswn7ZpypE2A92SUSg3Y/RJw0aywwsucxzlbhSXASUM3C0RDiFZjf8wQUgcsQi4I78sILw2EvKC2QACMAnZlXO9J10GeADd0RuJVvbg78loNux3F48skn1eR37do1bt68yX/4D/+BH/qhH/qm3vOnfuqn+Imf+An1/16vx/LyMufPn2d9fV0t8v1px/KAF6ZXFuDCaMqiXaSTIgWXB5Pfwy1VbuBYAqi/quoH0gICi8WiWnQKgBN5reM4KkFUwIPfMywABt5nFf3MpfxcwK8c92AwUKC7Xq9/Hej2y4RF4iZsiyS3+qvi/vPm97GLLPkkY+gPLuv1esdk+PJzAe3yJV65VqvF/v6+CteRRa34+Pr9vkqYFxai3+8rL6jI9AH1N6PRSIWhyXEJg9tsNhVTJRYBSXkWGajIEUVGKOfOHyQm/V9lUeYHsLIIFWbM71UWBlZk1/7ANH+BQs6rgGEBtOKXlEVXMplUCzN/CJ2AbvHa+4sJIkP3qzvEuyrjT77Lfsh97m8DJ2yhLMr9knk5HzL2TdNUXnlh4fzj/ht5rf3FGgmjO6lOkNf51R5ybYVRl/Enaodv5fYHf/AHx/7/n//zf6ZUKvH666/z4Q9/mG63y3/6T/+JX//1X+fjH/84AL/6q7/KhQsXePnll3n66af5oz/6I27fvs0XvvAFyuUyV69e5V/9q3/FT/7kT/Iv/sW/OCYL/j/acrmcUscsLCwoBiyXy3H//n2V8i3+YyngFAoFVazSdZ1er6c6HUguRSwWo91uK5vAdDpVgE7CuXZ3d5nNZhQKBWq1mso8EFBUrVZVi7CDgwN1XaXNkaZpZDIZ1b+7Wq2Sy+VYXFxkeXn5mB9bZLai2InH46rnc61WI5vN0mg02NvbUyFgu7u7ysojPtlgMEilUlEhcJcuXeL8+fOUSiVV1PIDYV3XKZVKKrxqd3eXbrerni1SgJDUaUnq9iu36vU69XpdJaV3Oh01/4qnOJlM8ujRI8X0m6bJl770JS5evEg6nVb90UXqnEwmWV5e5v79+zx48IBSqaRkyIVCgUAgwP3797l9+zYPHjzg1Vdf5Xu+53tIJpOqDebW1pYKFZN5MB6Ps7q6SjKZpFQqMZvNVIK4sOjlcpmNjQ1KpRKNRkPZZaQIKEVGCR+zbZvz588rVZQkeLdaLUzTVEWAarWq/OuiZpM5KBgMqjR06UqSz+c5e/Ysly9fVkFzIsmu1WocHBwo+bjYdJLJJJlMhitXrlCv15V9TWwGUrAUe4XI6uXzpIi5t7d3LIgsm82qYgqg5jmZW4WxlhA1eZ4Aqq3i2toaL7zwguoDPh6P1bXP5XJqfNu2TSqVOvZ8keeIFJhkjSK2B13XlddbpOWFQuHPM/39mba/bHNkdhWMNUg8AfNlCAYgPoFsHg7+CLr/NUkmMyGRmsJOk/g5GN6Ao4LXw7ptacQYE521ic3C5IkxHoWwcIi5E9oVGDRhPIPZVCMxSqHvdYmmZvTHCZq3glh3J+T1LLWVHUhPCQ6StEkSb5nEHnXpDpq4swtwUMSyHjHDJUac/bU2raDL5XtdzvzGH/LKo3tkH7TI2C7WpXUofgQOXa+NVHfk9YtORiAwBOcCg+jzhNZ+i7m6SbA+5ih7n3biLagaFO+/TKIzof3QIBuDmgXRqcWpuotZhV4AstaQsXGL4GWN+jkNShswKEIgAuEJ5Ice4B6fgeg6uC+QGuwz3AO9A0nDph3Sme875PQR1VION2x4DLZrwMQCht6/G0fk6h26oTWYuwKtW7Cgw90pAXfMLBNG68Uh/wg2XuAD+y8TOnJ4JRpiGrwATgYrmEEfV0jOXCJhjUmviB1fhvnbHoBeWYHdLM62C4d5Qv0Ak3N3YPW/ktzeZdh6HOfiZ5imUrD8AKYP4G6byPQLWKG3sFI5GI48KXY0CbOk1+g9OeBIm6M4PCAzgyPi4KzAW2dgfg7OHcCODrE+XN6D9K7X6HtpDTaDECh4vbJrH8A670Lpl+hnLPr6k7B9DjI1gs0XONvYwq25vDUNY0dnRBIOgwDkJxC3XUZBr8Ob1fLa0mFDK38KZ+F5mLsOo4Ln5c6HvP5Z1h7J1q+h34HuymkMw8IZ2rhJGzLz7F3/NMG9P+K77Abd81BPAnVP7GAAnQA0dTCv2MzuO7gNnfxpB+sCDDIpjL1Nzg+6TEJAGfI5CFow14ERPfZDLo4eIG20GOASCdg8XtPRG0scEGAyNemjEUKnExgzW+yy+lyHva/+d8J7Z+i4EcapR6RmUI7DuAC1OsRugvMGDCcQfxpibQgNvRqP63pii6DhtX7XAt4piRqg2zA4AqfnEf/hb9J98y0H3fPz81y8ePHYzy5cuMBv/uZvAl5fUYBqtcr8/Lx6TbVa5erVq9/wPYV5Prlls1ni8fgx+aiARz+LKkyNH7SKFNj/Jb8Xxs0vvfYzzQJ6/SFV/lAufyq4AFXxagvw8zPx/lRoAd/yXY5HfG4iiRYALaDC78Nrt9vHeiP706n9++33Xfv3CVBBLsIe+o/1pK/YzyjK37iu1ytVKu3y/n4/s/8zxXsuQTiNRkOBQ1mkCqsqXtXZbKYSzQXECtiTxdBoNKLRaKg0bAH4wp73er1j51HGmSyaJW1YFifCekt4nZ89FhAgLMzJYo74/IXFFyAI74NK//mWwoi/UCL/9is2xPcpMkwB/H5PrmG833NeFseidvD7xeX+kHvKX/gQCabsrx/UyvXwS1ilgOD3i/slwf57TYC3X+EBqL+TQCsZA36pvLDzcgwyzv3HdNLaIIWXv8hN2N9cLgfA66+/zmw2O2atOX/+PCsrK7z00ks8/fTTvPTSS1y+fPmYEuiTn/wkP/zDP8ytW7e4du3a133On2a/qdfrxwpEwl5Pp1NqtRq6rrO4uKiKctLnWcZ4s9nk9OnT7O3tKQZPPkvmFzm/UsSQjgHD4VCx5BK2ls1mVdq2pmk8/vjjlEolVYCU+1rUHs8++yyVSoXDw0NGoxGrq6t0u12i0SiDwUABfLnfRTmUzWbp9XpUq1WlhJKQsTfffJNOp0MikeDUqVOqS4FIj5PJJA8ePFAtxGzbVpJeuWflnjJNU6VQ1+t1KpWKal8lyiYp4rquq1pXyd9KQKSMb7GYAJRKpWP3jEiqRW5sGAb379/nN37jNzh37hzpdJrDw0PW1tawLIsPfehD7OzscO/ePZLJpArQSqfT6pmzu7ur0s2Pjo740pe+xLPPPovjOFQqFe7fv0+xWFRg+cyZM8q7LoFu4oWv1+vKTrO0tKQCLcU/3+l0GAwGHB4ekkgkmJubY3NzUwVuyliU3uIyD3e7XVWkHg6HnDt3Ts0z0tqt2+0qltz/vH3iiSc4e/YsgOptLi3ppPjabrfZ2toin8+Ty+V47LHHsG2bXC7H+fPnabfbyvPs9+xLR5SVlRWazSa9Xk/NS5qmqVBYyf8AVMFL7pednR1VsFxeXla2nnA4rMD53Nwc5XKZfD5PIpHg6aefVuFpKysrypve6XTY29sjk8ko+blt27RaLaX0EJWGjHmxTYnPG1DM+XQ6Vdf9L3L7v3qObIzB6ENwAeIJmL7H0oV3oP0F0LUZizemDIbg6A6574SDVa9F9UEI6lOXCwyITR0CbGCjMSPFhBhDY4DpgBYEUjBwXAajDgXXxujD0O2TSE0Jpl36fYfYzCG9BnbriPCjAI25Id2PZXBLJXDr6IMjsv0QmtZg6up0xhq9j7k8XLTI/gk8/Vs1VuwxW4+BGUl7FF0CyAXAtcDuwCToBWNl89D7EN32A5ZXXqEcg4rlwP7nid1uM9cYUGjA2tCmrcGRGcBMhuiMRuR7MQ62J7gFi4Ulm6adAP0amAWwXE9bHACiI2il4XAZLoExu0W0MqM2BCfigZxZSMfEYRLVcV2dcLuDrZtYgTCYHQLjOtboCOwA06mDyyHMojCdg2YZTAdXtyE4wzYcCDeJRh6S1CxCfUgHXqa++OuwegGmZ5m290iu9uk2VphNvwfm7xMo/29YhTgkMlAwPBNvf4bhTiG4Tbh/yFy9R2f4EvXVBDz2HOhHcLtK6E6P9cyYAW32g4u4ZzNguFCZ93pdGy4cGZih7+DI+UNimTqz4QaMzoKWgkYSxjpE9uGJu+C+Bne3IZ6GlateX6pHT3gIr6ND6zHIXQX3LrircDsGqTHRSJ1TpsvLgwDjC0EyswmaDt1okLY9h9E1Wdhrkh0COixO4fbYwHniSVi8BI7pRfFrMZikwJlC3KY4HnJ6d8TdzQZOHtw8jC5qdOw+TvZ72X/yPA+qL5IyHGYhCC7CdAwjB7pjqOreaSikXWZvuehJ2MvDROuwdKtOMWDTDXt1ChrQ7Xs2/ZTrsjboUXjY40wNavPw1jl4FHRYDrcJT5LsEGGCyxWtSXmtQ/6Sl0w+P2fyoPk2jRms56EPRHoQfxXsHTDeE2DM1sBqQusOxJa8gP9E2APY7aH3f0Pz8gdnQYg6wAgCfUjXvFaC38z2LQfdzz77LPfu3Tv2s/v377O6ugp4oWpzc3N88YtfVCC71+vxyiuv8MM//MN/rs9aWVlRjKQwvQJQhTUEFGsnLKAsziQsRxakAhYFiMpiRxbrfuAtINjf8kq8tRJ8UigU1ANaQJvs30nQJeE9AuQE4IrsS/qC+v3ZAnhmsxmdTke1UGk2m4otloUbvA/kpIghhQFZZAPqYSz7Jn8roUn+woDfI+tvZSVMjCw4hD0WcCVtvsQGIJLjZrPJ/v4+/X6f/f19XNdVvmk5934FwGg0UmA3mUwq/6Ccb/E+bm9vMxgM1D7Iol4SgwW0+c+DMNgiL5QEXQF3srjxM/jCLMs5FEawUCgowC6Jwv5kcgHAAmQFoEvR5aR3Xn4u41IWYSK9FMAs/nD522w2qxbGAnD9fkZ43zMuoWX+bAQB0/B+kJrcT7JglEKJLPKlSOTPHRAfLbxf3JBzL8UY/zjyX69IJKIKLMJwybgUIO73n/v3V9oHivrjWy0v92+O4/BjP/ZjPPvss1y6dAnwFv7i+fdvfmvN0dHRN7TeyO++0fan2W+Gw+Exn6sU0jqdjmrRJ0qTYrGovK8SHigAMJ1O4zheYnW/36fRaDA3N6d6WouaSPp+y7lOp9PH2uclEgm+8zu/k0ePHrG8vMynPvUpBZxkLi4UCirgbH9/n/X1dVW8E8DW7XY5PDxkYWFBFW/G4zEHBwd0Oh3i8bgqmEkhst/vs7e3R6/XU4oM8f1K2Fe1WiWbzVIoFDh79ixzc3MUi0Uef/xx4vG4CumSApDM98FgkHa7rULY5Fkjn7O0tKTuF8MwFBCS4oWwxplMRvnIz58/r55ffvWWgBS519955x1VdF1eXkbTNC5dukS/3+e1115jaWmJQCCgZPmj0UgVOJrNJoPBgEAgQCKR4K233sI0Tc6dO6faYElAnXit4/E4y8vLBINeK63FxUU+8YlPkM/nqdfrzM/Pk06nqVQq6jkqQZ31ep3hcKiUSfK8+PjHP06/31eKsps3b2IYBuVy+ZgkXdLuRS4vwZESaFev15VnXpL233zzTR49esR4PObChQs8+eSTGIbX07zVaqnn8f379zl37hzRaJTV1VVqtRr5fF4Vuuv1umLgpbA3mUzU+JFnggSxTSYTZUsQtZGoKoS9v337tnrdwcEBuVxOBdRJQVP2R4LaTp8+zfr6uvK0DwYDfvM3f5NGo4FheP3Epegv85DYOWT+k3EvnyMKmOl0yv7+viq8icXgL2r7yzBHDgxYTkE+C8EU9GwveDvwCKI2xE+PGelgLEPxIkweg0bBU/32g2BmIX9okGWGg4lBjB5J6oyZLxyQvw7hAlhDMGfQq6Zp9yM44UOs6Ij0JEAk7mBcaxFre5bZj3zPiO3NTV5eLzL51DMea2q72LFlRk6byBNdtitQeFTk7MM6kfMu1i5EbwfZyU/or4HR28HqPYT5VdDfA93jbdj/Q+jUIF6C2CVsnmRrvM1Rf8Cwb7O4d59C1yGYgVHWY/RiFhQSFruRAB1bYyHkoC9C9fFFWuUSTv4qFL4L7DiUmrA49iLa30lBLwyhAORqBHZrLDbhcAyHcUhEYNmx6IV0BosBgk6HjG0xNWw6rW2M6IjoxMIdPsJNQqscxU2nITKBwwtwdB7cMVYML7ErbkHKpNw5QB9BzYCy3qE7/V2mgVdhHGW8fIZDM4A7+jjM+ixM/jN2oEs18Bg0b0PhceiNMNpjrHAYqLHYHzBLwyDhkNz6EsPAEc5Fg0izS96aMGlBqpMinmozODeF3mU4WIJYAEY9z8ys/XUm5hKTpSOILcMgBZkKEIJuEC5kIN5E37xN0mzR705xuAmhO5AIQfg7PERaBfQCkbtHTIzP45Yeg5GBMR5ihqEXzUMmzbh+iD6bECxoTBI5wiGbpRbsNCAfhdIA3hkHQNtDv/+/Enu0izZO01//FJx7xgvfG3U5aq2z0rjDas+lrkPpMdiOQmu1A/UvMS2UeFOP8OmGSa4G0RXYD8A777Xc0ieQikE2DpMipBZhLw1R02Sj7w3DcdbzeYcjMA5Dw4bdESwcQfCPNbYfhkjNWZx93Ka6Bt2P1gi92CMxiBGLjomtjlj8qEtiGV7vwUtnPEdBpunlMuT6cO+/aFh/tEZoOiU3d0BoA+LXPO+2uw8zC/pdmIU83/Zg5tWMJh0vNy8Y8VrTTw7hoA/BEYSMr5tO/kzbtxx0//iP/zgf/OAH+bmf+zm+//u/n1dffZVf+ZVf4Vd+5VcAb1H/Yz/2Y/zrf/2vOXPmjGoZtrCwwPd+7/f+uT5LHoj+QLF+v3+M4fVLyCUkTLxg4u+KRCIKAAmQOClRlU3An3y+LPalYp9KpUilUscCWoT1OAkq/OywLMrk9cJeyrHI50paufxMAqkETPhDwwRkn0xcTyQSasEowAreDyoT4CXH6A/x8p/7k8BGzpmfifV70E8y7CeZbqlG+wO2/EytsHYnve7C3Mi+S2FC2Dj5kkKGXGcptMix+CXKcl1kn+V6yvGIjF72XaTysrDxy/Uk/E7As3/fhfX1n1s5V/7Cxkl1gb+YIp7+wWCgWBU/uy7XSxaLfs+6XDN5P384md+XLl7ek95u2RdApZz7v/vZbj8gloKLnHt/KJsfNAtg948lv+9bxo/cp/6ClYB8//H7z99fRFCQbJ/97Ge5efMmf/Inf/IX9hmy/Wn2GwHatVqNw8ND+v0+hUIBXddVyNV4PGZtbU1lAQi7G4lEuHz5Mu+8847ys8o8IsFNEq528+ZN6vW6CmaUe2Jzc/NY0UnTNK5cucJzzz1HNBqlXC5Tr9exbVu1lJSxMh6P2d3dpVQqcerUKY6Ojo6F7HU6HRYWFtA0z8csEuRut4thGIpx9wMIUTfIc2A4HFIul9WcJXP0mTNnuHz5MisrKwwGA/WeoiaSlHbx3Yq0XOYLwzDU30o4mrCG4rsFVOaEzMWrq6uMx2MymczX5YCIjFtsN2KZarVaLC0tkclkiMfjFAoFhsMhL774InNzc+q+kmOTwuXh4aEqrsk9KIF4Mi9LWriw9QCXLl1SzLLIqaPRKH/tr/01BU5FTSSFVznvAqylGFoul7l//z7r6+uqv/n+/j67u7uqICpzp4RniuJA3lvmfbEESZFbzrOE0oXDYb72ta+pzhKHh4eUy2Wq1SqJRELNU1KwHQwGCuzLz0Q5JGsGKbh3u111P4h9Rp5x4HUEkILW3NycCnET61O32+X69evk83my2Sy3bt0iGo1SKBRYW1tTrewAHj16pGwfiUSCN954g3fffVeNZb+H3rZtlfIfDAbV/ks+gSiy5LilyJPL5UgkEsdyMP4itr8Uc2TcW+jXanC4Bf0WJFc9Mrja15hspxnvjVj97gmBi3ArAZMlrzMWYZj7jhmtPY1w7yx9wCXHFJtpcItM2iKxAM04bL4Qpn4AyfAId5zAcmJMAiab4xix7TGF0BRHAz0L5ctw8GEHJ7IEc8tQa4CTwcmXaS84aCGXMQY9K4yzp/Nc2Sa2AJu5Fo9CXk/hlLVFvftVyC+CGYXhG1D5HFr7IdFuG1uPMs3PQTBAP1iiH8mx0rpPcexwfxYg69okIi4TA85okEtp7OpZ+tkOo7URgbkYXLqGs3IDehGItyCnecCwcQDdMuycg1AMLo0gZuAOEjCFnA1dA2YrGs1BHNPOEQw3SfeHTIBYysEZ9nGBxAialoYbDuDG5mD1IgyiMDnlsbJRCwjCwILkDGI99JpJtwNmDuyhBvsOkaUHuJkYk8DzuLsXITFgMfYbXJlr8YodBm3iNYTWHLjn4vSCOBcP4Wyf5OaMmQ7TXJBCa0TqnbepBqNk7ClpG+wBaKExelKD3Usw+gAsdWFuD+p5OIpAPQqz7/Jk/oGG1987OoU5EyZAvAnTA/T+mOLMJVjv0Dd7JMsWjegaWBswLoIzQzvaJ7U7ojl4hL5aQY/rZI0hszG48TCk1hk7KTA7Hk07TTObNNkNaTRSIQzXYs+2GcZDaMOHxKsNyg8dMuMhd4d/wGA5BPYeHA4xS1e56dY5k6yjdaFjQXMUBitOdHCH+GSTJWeE1gR7DE4UwjPQctCIQiLqWcInAchkIRPzOq0ZQ8jh3UNToHME4ShEz0M6A6szKBzCaDfAzniZzG6fp9JVildh+1lIumPO7IwpXIS1c9B1YXMfJi5Y2xDsQsIAKwGjl2DvqymaY4cNLGa6TvKsQ/AMjHswfhHGQ6/o1u9493eo4DHZk6AnPbdcD4xP4kAUcu/FD/C1P/9c9C0H3U899RS//du/zU/91E/xsz/7s6yvr/NLv/RL/J2/83fUa/7pP/2nDIdD/uE//Id0Oh2ee+45/uAP/uDP1aNbtoODAxXmIlViv39TwoDE8+pvvyUPYPE3iT8R3l/8nQTiJz3O4oMUpkK+0um06sMpi4NkMqkWSiL/kkqzMOvyoBcWRJhD8YW322210BCQLNV6AeCyOJUgI3l/8aGn02nFGgi7DhwDu+K1jcfjXyerl0WqLDAFjPkZWfm9P81cqv1yPfxtWISNGgwGx1hIuV7CjIsEVQCuyOHFe+rv83x0dKSCZaR9mB9g+1llWUDJglP89sI+ZbNZ5SEUICjjTfa30+monws4EJWFFEnk/AnoF9WFFBJkXPkZffkbGX8CjAXc9vt9lbYeiUSYn59Xi0L/+4pU3x/mJOdKxpEUIgRUi2XCX7zxX18Zq7KPAnKFSRQ5pt/OIWNCig5+ab6cJ2GtheWWay8KFT+glr+V6ymFJH/Iml/GLoUpGTvf6u1HfuRH+L3f+z2+8pWvsLS0pH4+NzenbA1+JqdarSrbzdzcHK+++uqx96tWq+p332j70+w3uq7TarXY3d1lb2+PQCBAuVxG0zQ2NzfV+TdNk2g0yuOPP66UBOFwmGeeeYbhcMitW7cYjUbMzc1hWZa6fyeTCXfv3sV1XQqFAslkkvF4zOLiogoqlAJJNptlbm6OSCSivOaiMnEch7W1NcrlMjs7O6o91/LyMvV6nVgsxsWLF1UP5WQyye7uLoZhUCqVODw85PDwkIODA9Uu6e7du3S7XTWHSScDYfcjkQj5fF7lICwtLXHu3DkF3gSwCuCrVqvcuXMHy7JIJpOYpsnc3Jx6b1FrLC8vq/twaWmJw8PDY8VEAapSkJMALMmmmM1mzM/Pk0gkjtlDer0eh4eHxyTUUvza3NxU+SbdbpeHDx8SiUTo9/vqPJ8+fVoVngeDAfV6nWKxyIMHDwgGg3Q6HQzDIJ1OqzZW8kycTCacO3eO5557jt3dXQ4PD1lcXDxWBJP7rFgsMplMVIiYKBb8lpZsNsvR0ZECxtLfW7zjiUSCVqtFpVJhY2NDKaW63S5vv/02muaFUop9S1QbUkzu9/tUq1X29vaOtetcWlpS9qNsNkuxWFTt8y5cuICmaeraylpEQLQoROR5XC6XVTCmgPZKpUI2m2U6napwwXq9rlQQYj2Yn58nEAhQLBbVZ4jqbDAYsLGxoVLSw+Ewb731Fq1WC03TeP311wkEAuo177zzzrFjkXlR1E5CSsi9KV0/AAqFglI6lEolFXwaDofZ2tqiUvkmk4L+DNtfljnSiEPrLdh5PcrBYQRjHKU810YrTbl/Z4PZdAG9t4X5hQbnTo1wn4R22GvXrIch/VEINtrs/vE+00aY8myZLg6hZJ9kHOw6HL0Wwd0+TWFlm2R5yPgNl8XZHOZslxYmhuPiziB2HmIX4d0YvJzNMdWL0K16yVS2A2t9zGWHyKs5gnaAo4tTgqdDLLVHGGmoXgenAtUjSCdnTPdeoGusQm4F6n9E6vA1RgcuZrZAJNjh0r1N9A7UNR0jAaWpQ9CGomGRO/CU1tYEEgWYlEKwso55rs3NwCH99NMw9/R7JmEXjB4MOmj3/wcB601msasQc8Ba9sAxFk5AZ5CA0hmoO7AXuYa7tI5x+DrrkyGxCWxNYJQHIwrRvqc2OEpkcVIp6FvQGUA3DsMYkACnD4EpuEGwemhWBRou446Xeh0cBigPYnTumQwXz0L4MQg00Zc+T2hcYWcMs+jEkzicPgP1HGxGcecG8HQNUi79RyEWrQmF/oSIBtmAw7g/xM2BM4ZeJ8REizOYXgeeh8wDSLwGpTisfQRuu9ALghbykshrBShOYP4tOO/AYBlaL6Bpr2BrEYLGkOuZKa8feUAQ4z7ENz2PuBHFNcJ0kwZGy2Zhf8jgjI6ecslNYW16wKN3+ug4TFIFnNhHQQsyizkcaDFIRNkP9xinH2FU+yT3+6yaMNOhGYNZceJ5K+wWZEsQvUEjFKfN/4BojZA2xE1OiJtHLEQsTjGmbL4Xtt73wLN9AGtL4DzruQsqI1hIgVaBg5bXPmx9AnEbJkfQe6jRuR+nE3BZck3Sz7vMFjxfeNEFGDNKDZk+7rHktSFcvwwL5yEzD+ExVF6Bzo7373VLx0jrLF+0CKdg+3Mh8u0F5qiTzbQxrjp0rsAoA0sRCCyCFYfEIvT6EFnw2s7bca9QMOjDKATxObCHcMqF7B7c+h9/3lnP277loBvg05/+NJ/+9Kf/1N9rmsbP/uzP8rM/+7P/f32OsJniY+73+wo8yCYPTwE+mqapxbuEo0i13u+V9u+rAAw/G+r3yUpCqgRmCWARwC5gS8C+fAmI9ftYBYQKIBDGQwCTAG4JIPpGrK0/4E3k5CLrFubHD+r8nkK/P9ufHO0/Fn9YlXzJZ8kCzP/l9+r62fFv5JX3g3U5N/4vOWcnQ+VkE+Dm9/ULuPSzx34GV1K8ZR+FYRXGxi9dlvcSJkcWZX6vvVxvkZrKgtsP+IUFcZz3+1nLtfCzsidl/P6Cj5+N/kbjVc69//r4peQnr6ewxX4lhx9k+/3T/nPvZyDlmOQc+EPR5HwLmPG/h3yuFKOksCPnU86Zv7OAFEj8YW1+JYKMcbkn/Mfmv5e/VZvruvzoj/4ov/3bv82XvvQl1tfXj/3++vXrBINBvvjFL/I3/+bfBODevXvs7u7yzDPPAPDMM8/wb/7Nv1FyYIDPf/7zpFKpr8vK+D/aLMtrmyWp2oZhsL29fSysTPrC67rOysoKgYDXOmo0GpHJZPi+7/s+1tbWFIgdDAYsLi4SiUSo1WpKXh0Oh7l37x7pdFoleQtQv3DhAvPz80qOLuNTGGRN01heXubxxx9X7J8AzWg0SrFYVHOR5DTI8QlwlwKTgCoJXJR7WuTc4mtdWlpSBatEIqFaTuq616pJCj7dbpft7W11X0rexNHREefPn+eJJ55QTKHIgaVw6LquAgP+7hjS1ULXdSXBF3a12+3ykY98RDHrMtb9tqd4PK785I1GA9u2uXbtGvF4nNu3byu5sCivZA6Q+VhsGcK+Oo6jfO4yb+TzeRX+ViwWOX36tGolJt5ssSnous5TTz1FuVzm8PCQu3fvKql+NptV/nspeIgfWs6BFIvj8Thnz55lNBrRarUUUJfnlqZpNBoNwPNES4q6tCATEC45F51Oh1AoxOrqKvl8nkKhoDqcSFFB5hC/kkf81K7rhXPOzc3RbDZVq7Fer8fu7i4LCwsqnV5yRQCV5VGtVmk2m8xmM6W22NzcJJvNkk6nVSu6dDrN4uIixWJRqUjq9bqSSouCSdpcin9fmOxsNqvaha2uriqriCTgy7PT3+pMnmuhUEix4TLepDj2F8F0/2WbI2chOHzbYOf+WQbuDIMeD/YW0PfCWCyyFWgTtwNMd+exX9kifQ00A0JJMMfQyELm77mkru4RexH4kxbjZoTFhE0kBbV7kNxMEklVCJ0ZcudBjMwsQil6yGba4sAAY80leAP2F3USBahGNXr6grc679wFIwRaFlYWMa4kKLw1ozl2iWp9Srs2VhmO5rzAJ0MHvetJa2Nam6H1u1jlBdDm6EeeI2a8Sizcp+8YVHuw0IVz2y7ptIt2BawRJAde26dlDewVuLsAu9kYlLPYifN0dR0ya6AtwSQCtGD7Adg3SWgvkjUHHDUaTAMt0P8G9K7D2IaRie6CFYXRQMcdRMBtEK1WPCASgpgONU0jEHdxNGjpEZx0GcIBD80N34UHIejPv9czegSFMEQMr7d0KQhbOulRmVG7Tj5sURu3GbVWcWZ/AwpxmPvfcYwDdpthgrEJ02TiPeRVgGEEzKDXrzwdhEAAchrxIJSOIJyCSUqjG87iFiy6ZZux/hzcvQy10zB3Hz31WzimCUcpiD2C/DpsnILKR2FWhtghLL6G3v/vuFtR3MwFmL0D+gw3HuFgHGAysuhqGpoGBNow3/YS0Y4SkP0Ak7VDQs0H9EY2Xc7Ri1pkA3fImTaNZpsQGq1BhElOB7sB0xrkDYhncTWDqLNDaexSb3vDq30KjvIxrELE6zMefhaC56ETh7iOvRKHwP/AdW6Tx4KOha3B1IVszEveb+5DfODdU727GiXdRXsKDgqefDw5AFuDi65nLUjmoXpLo30nydQJEpll6L1TYbRm8m4uRmZxxuPPzKC1Ty8Hn78EWhEuj7xw+Po+HP13HeIug4BLxIRhC6xRkPjeKt3tKna6z7g6RxaHxdiQxHWb7EdgZ9Gzh6QnEEl52X+BFGSS4OzB6F2wOhrWOZfwErSTXhi/OfFUMCvnIfruNzcH/oWA7v+zNtM0lbRwZ2eHdrt9jJmWKrhIv6Q6XiwWVVU/EokwGo0UOyaLLT9I8gegyetSqZSqWvsBt1TVxd/rl1tK6E82m1VyTllUiPdLpMqDwYBYLKYWI1K5FoAnLK5fdi2SNj87LQtOCf/yM4YinRPZnzCefpWAyDTlOPxMr7CQIh32MxWRSEQFM0nwjyyABVwJgJUFofTd9vtJRZ0ggWQCygS8yyJRAJkAZgHF4q8Tq4GfcRfmR/yXgAJuzWZTgT7xYovMVjzB4pMTdt3P6oofH1ALMmF+JJTHn6ot0m6RTco1OMmAy7/9En05JhlX0j5PGOGTQWby3ifVAnBc9i7XxV80kS9RWcgYguMJ4v7xIGNU9slf3JJCgIBm2ScBKPJ5cs5SqZSSBIs8V4pOch3k/SQEL5VKKfmynNtoNHqsuPat2D772c/y67/+6/zO7/wOyWRSLZrT6TTRaJR0Os3f//t/n5/4iZ8gl8uRSqX40R/9UZ555hmefvppAJ5//nkuXrzID/7gD/KLv/iLHB0d8TM/8zN89rOf/YZMzf9s63a77O/vq4V+Lpdje3ubUqmkWFBd16nX6zQaDc6dO8f8/Dy9Xk8FSCWTSZ566ik2NjZ46aWX2N/fJ51Os7CwoO6rVCqlUrWlMHPjxg2++7u/m0KhwMbGBvB+6J8Ui/b39zk6OsJxHB577DGefPJJ7t27RzweV3kd/X5fJY8L2JUWSFJ8/PjHP87p06f57d/+bZVwnUwmVctE8Vj3+33m5+dJJpPqfdfW1pQPWNhWKUbcvn2bra0tMpkMp06dwrIsbt68SaVSYXl5mV6vx9raGuPxWM2hMi9IeJykbUvqOaBUVslkklgspsbrcDgkEomwuLioVE7yd1IskLwIYVfL5TJXrlxhbW2Nd955R3nrRR4uc7/M56lUSqlxHjx4oLy8YtMB1H02Pz/P3Nwcy8vLqrAtKeZS7JbUdJFGv/DCCypLZDAYqGJkMBhUjLGwrSLVbzQatFotXNfl8ccfp1gsUiwWsW1bWR/kOuRyOQzDUMn3Mi/Jc0M875L4ns/n1VgSa0E+n1cqEJG9y3PTn98iawBRP0QiEaVuCofDqk1bKBSiWCwes0NlMhnV5tJ1XZUyvrq6imEY6hy3Wi0SiQRLS0vqfff29rh586ayevjDPOW5IfJwKXrIOqdUKh0L6hOJvuu6KiVfchzS6TTFYpHRaKS84J1Oh/n5eaXW+1Zvf9nmyN4I9icOd+gwF+yQC/e5OVilSJoxHTolHaMZoj6ZsfuOxuP3XBILUOmB2/FCl26nYfYUPL0BLLfY/7UUaVun9EGbXh1i5QbuaZd72xrsLqKnumx+csAbl6LUizm0wgA2crisodlD3MkOMAF3E23/iEh1guZUMR/7AKOnlnBeepfTb+ms7FqkUvD2uuctTzZAa0DqbhCrEWNc7LLg7tIY9jA/+nHcxQ8x/cN/yXrtZbYnQQbJAMM9h9BRDj3aIYbFTTvM6AmL81Gb8KGnan43H2AYz0OsBonHIXIF2lvQ2YSbB0S3X8LK7WOdGpOzZhg3IVLpkV/+KvWsjnVuDQYT3P6YvgX6ABIDB6P3Mk4MmhOdrYhBIWLTmoWwtQB2cMykUIRkGGJ4yWtuFIZ1mGbBWfR6XwVcT9M8mkIygatHMYGxGyXRjjNM9zh8uoSV+zgcrEH6VbC3oO0SwsJNBXCiZQjEPMa+E/b81vEpNIbo/T3ivTG9Jrgtr935lpHAKlyAVA17rgDd7wDrLKQHkNjDiVqgzaEPm4QGh4yTXUg/gugiGBm02R+QTf4u8cEQ09QIju4xmboMgzqO2aH//yPvP58sS+/8TuxzzPXe5c2btrKyfFV3o6sd0D09AxDAYDlczjLG7UiiglToxQb1n+gVpRdDhkKroERqJa2kFckdC8wAM41uoL2p7vImfea9N6/39x6rFwe/p08mMSIXoiR260RkVFVW5j3uOc95vr+v+bkR3JRHLOGxmELSbDKbvY+/tg1NH3Kvw8Ymlv453cwc3Mu4ls6d4v+BYvEO/VIBz1jBb2oweQymC0YS8kBkiDZokMWjGoVRBp6WYLJews9VYZGBxDJEnguo78QeLO2jdz4jH31CNukw8wI1f9SDtQVEfNAykL4WBLBPFjB/4JN5Evi0B88HJH/5EuBBzwkAb2oZzK7P6K6DQ54iERJrDt42YHh4NR8rB1oXImlIr8GNOdz24eiBxqO/ynLh5HncxBPS/0WDxN8D922o7Vo4iwGjSYHhZA2dMlrkMYkbM7SXwVoB04DJBA5cKGuQbwdiicE9aL0bYTawMRYVcp9ZVF7v4z4Hs0pgr6/3YW0Zshd+tTnwKw26BehI31/x0J1nC2OxmPKVyQIkvKg/DyrC4CYssxVvbyQSUQAnl8sp6bNpmgo0yMs7fKzh0Kiwb1XaQAmwFVAq4FFCo8IAJexlCwNa+dwwaDvPPMvPCegNg+iwVFgkzFLECDOhYYb7PBsqRYrzDPd537Rs8nvCwounVEDfeQ9vmLGU3w9fz7CMW7YwyyzXRBgJ+ZJFk1wXkefJdRQp7nw+V3J+KVaEPdayCZiWNldhhYOoDwTAigpD7vHftp2XdwtbIQxw+HPD1ywMpgXgyrmGGeLwsZ+/xmGJthyLjIvw9Q6rEeQZ+g9lls8rKMJjSkC8sHVhsC7XUMZz+HmRooScg/xfWL7/H2P75//8nwPw7W9/+8z3/8W/+Bf843/8jwH4p//0n6LrOr/7u7/LYrHgBz/4Af/sn/0z9bOGYfAnf/In/JN/8k/41re+RSqV4h/9o3/0K6mCer0elUpFARphySToTgo8IqGWOajX66n2RVI83Nvbw/M88vm8CuAS+4wUt/L5PBsbG7zxxhssLy+rIpiA58ePH6tWYNVqlXq9zr179ygUCuTzeS5fvkytVuPRo0eq9dPVq1eVV1bmJwl4knN68803KZfLfO973+Nv/uZvuHPnjurtLEqQTCbDc889x/b2Nrquq44GMmZFIp7JZBiPx/z4xz9WBYHLly9jWZbq3X10dKTsOVJ08jxPMdjhzxMmNJzYL/OcjFff99W9kNRyx3GUKsS2bQW6F4uFYmJXVlb4jd/4DarVqipEJJNJ1Xs5Ho8znU6VSgq+bPU3GAyUr1+S7CEA3JVKRRWoRQEk77zJZKLagJXLZcrlMtPplMlkQr1eV20qZY44ODhQ70dhvOX8JpMJuVwOTdPo9XpK/ZPP53nttdfUnJXNZmm32xwdHeF5HqVSSYF4XdfJZrNKlSQBYeJrLhaLqkguRUoJHvV9X8370WiUTqejOlhIurVpmsxmM5UAP5lMVCstKfqvr69TqVSULN/3fQWkhe0WoL2+vo6u62c6TUiAmeu6HBwcMJ1OVYq+sOtCEkhLucViQaFQYDAYsLS0RLFYVK3cpE2e5NskEgls22Z/f5/T01Msy8IwgtT58XhMLpfDcRwuX75Mq9Wi2+2qY/6Pvf0nN0eeQsXzWTXGeHaRuR2hpvfJ+nMafhF9roMFE7JYmokXsen6MO1Bchp0s4qMYWrB7j5cmEE+PqOzgIkDqQ2YRH0mIzAe6RQzbRq/OeLkH5SZ1pYgGsHXLkC2DCPQnzQptofM9BHjpRiJxoQr9zwyhUM+zPnML7/GzrUBxs4BCUPjfsXgcW2VWckkMT8ibVmYjk9X95nbUdbveESGLvxaG/Ir2G/+V+y+d0D20xP4xMBoxhlFZ3QKLi0ny/D5C+jbJ9T0NqV1aMxh4kUBC6YNMHoBQO1r6D/+E66+8wijMOXx1ThYSRLNAXkPTp/pZKIus/wxfcOB/oS4N2KehpQGWWA685maEbxSBt0a4zsujv4Li2k0BfEa2J0gYtpPBt50vwaFDdhzAzCpG2A5gcR8nobdNINEhoP0IZrl09tcZ/7mD+DpdSAKhRGGP0PrL0jHPWZxE6ZO0F9cX8AQIjMPOz6H3oBUu0FsEHj+9SlYLsw2s1Cxg5Su2DV4VoDjCGxGIFsNWrN1WmQWQ/xyhHn55YA9N6awdELizmcUJpMg6A0f48Cnk4JyxMUbg2E4ZJygr7s+gWjOwdbuYpufwSuvQMUFw4Lyi8E1uBOF3RxW7NcZeY+Iej6z4hJEOjB9EkTtZ6Oga7AYQ7KPNocVExZLcFoy8SNlyFyA8hqwHXjOtYeg/xQzeZcLtFiN2kw6oLlByndrCC4wMYNbkL4YyK/7TSjdAsYwjsLlz2DlEpSuBVLtbAL6wGEatrdh5a0YzVkKPXVI4YZFcwMu6XNqE6guwGjBtXYwbpIONH4O1ge3yE8K3Cs9JaMNWfoEzMtBy/LldZ9+ssn87kUyi20s7RnVUpvcNRhch14WzFNYbUK0DdNnkEnCOANPp9DrJLGYYuDQmpmMh5DpBnWY0jWwWvBFDxL/4Z0Jz2xfadAd7vUsX+EALHnBhtljYYulGiyLxnAQmQATYYmlah6LxahWq8oPKIyp+OakR7YscgHlkQJURXpra0sxgbLQFXa10+kopjfcxuw8EDsPgqTvsiyQBGDJz4aLEPJ9YSKkIBEGOvIZwmYJwJG/C9gLB4TJvuW6wJetsOTnw1JxAWLiKxdWVno4CwMjLJCAYlmIymJEgJ0AK1EnZDIZDMNgMpmcKTjIAlZ8dJKuHFZIyHkJsyGqApH4yf5lO1+EkGMVRkX8zSLhFNuDXFPxakrBRD7zfAFJrrPsRySiYWWBKBPkmkkhKFxQkH+Px+MzbeWkKBD2a8o+ZbzJmA0XMeRYRBGiaV/2h5Xjl32G7QxyHuf941I8SKfTJJNJxaTJszGfz9XiX4of50MVJYE5k8koJkV8j1L4+o+5/Ycw5/F4nD/6oz/ij/7oj/7Wn9nc3OTP/uzP/t8+HgEPEsbY7/e5ePGiYqNFAm3bNs899xyVSkUBsGQySbPZZD6f0+12eeedd5QPdTwe884776g+ypIf8Pzzz/Pbv/3bGIahEoaj0SiHh4c8ffqUTz75BF0PWjWJLPTw8FBlXORyOX7nd36HH/3oR4xGI1577TU2NzcZj8dks1lKpRKDwUCx4SIpF3/5hQsXWFlZ4a233qJYLKqMiHK5TLVaVX5l+b7v+ySTSfb29ojH42xtbZ0JLatUKqpndrPZxDCCRG1p4STtwqTtlqhZJLeiVqthWZYC7/F4XIFpGatSAJJxLh5jKYpKEruwwA8fPuTBgwfEYjHeeOMNNjc30bSgU0Gr1VI2AlFSSbFKihbyDMvzLscsz9/y8jKJREL5o+U5CecsyHwtdgFhYk9PT4Ev302iCCoWiwroJ5NJFTQW9k0L2ARU14fFYqGY9UQioeazvb091VVC1A6itsnlcqrAmc1mVfurYrFILBZTPd3D6wSZf0WuLQGcksEi4F4S+KUofOXKFY6Pj3Fdl06nQ7vd5sKFCywtLXF8fEy9XlehbsvLy6poIXO8hKlFIhFVUGi32+q6/cN/+A8ZjUb82Z/9GdFolFwuR6lUAuDo6AjTNFlfX+fatWtKmSCWiGazye7uLtFoVKktpFNJLpdTTLm0hrt//z6/93u/RzKZVEWt/08w3f/JzZGJoOf0RPNYUKSvT7h4qY3ZizBrrVPuzoji40QHXLptE6lAowlZHWapwJN6ewF2HXb+HxrtHZOKaTMeaLz7v4nSTcPU9om7Nk7a5eQfDmn8gyVsYwuaM6jOIBJHP9hl6ekTvvHzGetDqEfh7QsLPDysXfCeadQWLXZzc+a//zr3cz73RhG8116HzSswecIk8xGToo85qJN50KNi+iR8mEarkN0KDNoXa0wOahT/2xlbJ6sMYo/ZW44wrF3Er3qQi+GNrvJkHGc4XjDwx1hJC/aGQS+1rZ2g/9KpQWHQYnN1yucRDUsvozf7RA3wlsHaMDkp+8xzJYgWYWaTHds4LvSTQRJ0J72BU3shKGo0jtC8BxRiQzpOEt9cg9kYzengu2nQgXQ6MNwOVsGcgq2B5oCRDhLSxz5oLzK79m2c7F/jxaO4b7wOmRegEQFriD5usuLN8IyAPI9pHuOYB/EEzGzQLXzDANsEx8b1tKBPcxZ0HWZF8KoaxKeQNkFLwygBCQ1KLhg58DJEE3VKcZdp2WUYB3gBkkmIf0Te2CHvQ9cIFOP9MbSLBaILh+RwhpnQ8aY2pYhP5hcAtTZvMjj5PzEvvY1/1MFyypB8PWjT5uVgCYiu4LULXPRPON7/OYOCga/N0RcujHW0Geh42FkDexYIBE6KERaFlQB9l26AdhMONcjvQPzP0e27VI0xy47PYhaE4G3MIDkOEsZPMzC0IdYG14JEEqjALAskg1pJ6WcBYT7QoL0HhVfBXIfeMbQPYW5OKUT3qW1PGdbAHkNFh8seeMew2AtUHNYh9PPQuW8y9Rzu3ryH87/ooA3A+l/HiP1ZnuzVU7Tf87GHYBz1KDefkSo/4+qv20xegm4NEguoNWH0E9j9VCO60Fi86jGOwOgixN8xyE23GDFjobWpP4zw6F6KxJMB3/2f+eQLsN+FpPbL55R/3/aVBt1heXM4fVkAqrCesvgP+3yFLT4vkw57l8MgUhZ5+XxetZISBkEq8rIAEImb+KkkgTXsyQtX34UpFUZUPGACTMNspZzXeflt+EsYkjBQD3tf5fPC3udwu68wyAt7vMMe4LC3F77064YZVrn2ss/wcYeZaTluy7KUxE8KFRKEI4tEuVZSGAl7dM8zsdIvV0LGwqnWYTl+OBE9/Dly/uEChoDwsKLilzECclwiwxYGRQBfOGU87NMO/34Y/Mp9Dx8joIot8iWASu6vjMvz41z+LkqGMMgOH4fcz/D4CgPt8H08r2Q47xEP/ztcEApvYcuALMzl2RPmVMaBSFdFVh5OIJYxLYBBxrDIygWUfN23hw8fcnJyooKu2u22Ykyl6JfL5fjOd75DNptVIEnGxv7+Pru7u2QyGY6OjphOp6o1led5ZDIZVldXeemll/jWt75FLBZjd3cXCO7lfD7n8PBQHYMUlyTIaz6fUywWOT095dNPP+UP/uAP+K3f+i0gYHJd12U4HGLbNpcuXSKZTPKv//W/Vi2p3nzzTS5evIht2zx9+pSf/OQnCtTO53NeffVVvvnNb7Kzs0On0yGXy6kvYWgPDw9ZX19nNpvx5MkTNE1jeXmZVqul+pqLTcK2bd58803lEY7FYtTrdY6OjpR/utfrqaKs7/vK1yyFKcMwVHq4tDCr1WpnCofyjIQtOevr69y8eVMlnFcqFer1Ovfv31eFqNlspgCaKMHCFh1Jrhb5ebPZVAVoCbObTCZqTpCwsIODA3Uup6enys4i0vd+v0+9Xqfb7SorkCilJFxPLFLiexfAKa0FZWzkcjll84KALRe5vowrYZNlPpf3jMi7HcehXC6rhH0pqs5mM3UfB4OBsiNJkbLT6aj2n2JRkhA18X2LHS2Xy6l5uF6vq4JVqVTi5OSEw8NDWq0Wa2tryl7T7/dVDoHkKYjiQjzXtVqNS5cusb29TbPZVP7v4XBIqVRiZWVF9QUXf7oUIaRbwe7urlJbSPvQo6MjIFDAiFpICpfj8Zi9vT3l547H42f6Wn9ttzQ8HMOJ42LQxvFN0ic5kosUoLFCDA+NYuWIb/06PMrAYgKTQtCl6pIFifsw+CFUn8DxPMNUi7Hmd9FtD29kkirZWG/A0a9ptF5fwosuoe8d49PB1xwSc5/ikcM3jl02vSBReWkILxsujzdg1I+yubtKtH1EK/OA8R/8Xdzf+vuACSsr4OVh2AL7BlzaxkmdMP7v3sY8PqJR1bH/zvOwdRP8GTz5OdG/aFBpVpnqHfoRk+Gr38N/M05k50cYnQ6L3DXG2f+ScdaH2Z+SmjyieDQgtebTn31M7+h5mBQZ13TaBsQ0H90a4sXyPDNssBJY3/w7WGUb4lcC5ve0TeTIwc/CyIROz8AppSFWAt+Egsd03MTQjtEiNXz9JfTW+6T1KaOhiZ9ZQK0A/gZ04wHg9n2IOKCZ4OlgA5M1MF7C3mhDrgzcgHobjLuQnaJ5j8mOoagHgV5Nx6M3m+KlgVEcZnEcMwK6C3ONafwmh80BS/qYVsxguJbBX87AxAZ3ANk2LObAHKKH4ESA38CxPOrJQ5xCEsZJmCdB30E//husnoUXg2UdXB8sS4NFGWtlCSs6AW1OOrFHZTxnNg06j1VGUJ118Ccd9nWTVm4ddA/sNuRdSA1gto+djGEBBW3O0E/gp1N4ehzMJLpziud7aLZB3JzwFI2D8kX88hVY/EJSfpoD/wvw/pS4/TnJ/gxDh7EFKR+8Cex2YDkB8Tg0F6D34dJjGEYhejlIDZ8MIFoFZwXcNyBmBQC7+RAaFeivBHltzSdwml6w5gdFjUISqgNwBkEf99EcFkmYzWAegVwFZlcd2hcf4N6A6Tas1MFJRuh5awz6Myr2kOIaxC71MOMDzFsenV+DvWU4Bm5PwHoPdj+FWV/DNDRaSZiNYPFJhOx8iZ7eJaoPwLVojUp02SD9+Q6jP+mT/E3IJAL/96+yfaVBd6PRoNfrqXAdkejKwl0AiCzI+/2+Ck4T1tKyLFqtFoPBgG63q2Rl4k+Uhb+wibJoElmgMJgnJyeKqW6322d+X3qJFgoF5VuS9i6yAJY+3SLFlIq2LLpkAScso4B/AUGyGBAgISBDwI+u6+olHE61lsJB+LqFWWIBrLJACBc5wvJe+VMW9wKGZLEhEmhJsE4mk+pL9i3y6DAIFtYy3NNa7k8YNEkxQ5gdUTBEo1GlbAjLoGWRGl60hdlakR3KOQpbKIAzDDzDW7g4ImBUvi+e73BbLlkoSXKxLMCEVQorAsIFEdm3LP7CwXiyaBZALYUK8cGGfYsCfsPM2PnrKuNAWHBhmOBs4r3s/zwIPj9ewp8tC+lwWzz4sgeyeCFFoiqy1PF4rNLi5ZyEPRRJdLj4I8x8sVhU+/6P7en+T21rNpuqJ7RhGGr+aTQa1Ot1NjY2VO/gp0+fKnn16empGi+SWwAoGfTjx49ZW1tjY2ODS5cu8fLLLysgcP/+fRU+5bouzWZTyZ0zmQzPnj1jNpuxubnJbDajUqmoMK92u80777zDN77xDXK5nAK7lUpFAZWXXnqJtbU17t+/j6ZpvPjiiyoN/OHDh0rC3Gw2eemll/jd3/1dhsMhjUZDAZJsNkuv11NjVhhW8X9LarR4lcvlMtlsluFwSCQS4Xd+53dU4ce2be7fv0+v1ztjPUqlUhwfH9Nut1XoZaVSUeFf8r12u62Y81wuR6FQUIBTVB3SVkzeA5VKhVKpxNHREe+++y6dToelpSXK5bKSIctzK8znysqKyjUQUL65uYnjBD2ct7e3KRQKqjgdiURYLBZ8/vnnXLlyRSkmyuUyL774ogql0zSNWq2m3sVSPJZgTwHAojBpNBrKciCFXhmD0u5KVEaaplGv1+l0OiqkTooSkgEi7xB5ng8ODs5kYch7wXVdTk5O1D3sdDoqzVu8zJIXkMlkGA6HlMtlTNM804deVFqO49BqtVSAm8zhck3EP7+3t6eAs7Qek7Es75t2u43neUolUS6Xmc/n3L17V+XUSCigKC4cx1GScrEX6LpOr9djOBwyHA6Jx+OMx2OuXbumWrCJJaNSqXB4eMhgMOD69es4jkO73WZpaUkVE8bj8f9vJq7/L27NOnRbSXR/GRuDoV/kdJzFpUGPJ1wkiU4UZ+ww/BnkTcjnwHHgogsXFjBugL0HRHw8xozmSR6SZp0Y69UG9v/I4503onRW0hijBUv3HnEhOeegqtNwy0RPexT6LqMkjNbgdCdg91YLUChDK+mT9iIku1Fe3N/h05+9zfiF7wX9l6wpxItQ3oJRKWBeXypjr16h9eAY8OHF6wFVO2wSf/in3Nw9xfTm7GbHtG/+AP/v/jYa/x3V4z7rQ58n+bt0szq50wkxY4e0CaWxzwzoLEw4iUA2jh2L0LPAKYFfKkF2C2/UxeYi1P6roP0WNrgO2tPH5DoWRhqsiEa3UIZUFo6fQrtBdNJEsxeMKjpecQn8AsbEJe2A3R4zWzqG0jr01uBpAYYGRBYQiYBtg2+BHiPy1MQdxfFeuAleCR430J+9RWz4iEXNxCNNL6qzkfGIRMAzoGd16XYXMC7B0zzGGNxEFMjB+mU6xojeaA+vtAoFDcPZAWeG61XA34fsu9B+EYZDKE4gto7X/n1mSyNIdGG2BfllotM/Zbu7w8SBugZxO6gbYPiY9hAnfw1MnXxjF7Q5D7JJ3IVFRXM4jMLcMUk6ME5HwNDA64I+h/YX0DkBz8dJxNiJpdB0Cy8SDeLfk0lImnhmDrwyxsEhugfPDBOHC2BuQeQGnORh+gC8f018+Dn5jkNqDmYqaPtV7cNJI2ixt5yF4yHslzWynk9yBNMxtLYD8BzvQNyBfAKmS/BFCg51KL4GsyV4qkW4FLNZt2D/NErTi5AbTMiMYeZDogPzEejpoAVZ2wqy+LKdwNqfXYXSHOy7sLwHe8dpDkiyVN+g9pcPyD/vMjiF4nMeg9+EjzfBj8Fch1kHvAYMPY04WYaJKSsvuKTaGiefX2Tg5ZnFDqh4aQ58jzpRSlRIzC06jT5ZG5aLkJv/anPOVxp0j0YjJS0Lpxz/Mo9vGGSJX1EAnSzi5bMEUMnLW0BHWO4tIELaRfV6PTqdDt1ul16vp9g6kVnLolNkhul0WoFvkf4BCqT+srRlOR4BK2EQJPL482A7LFEOgzn53TBLINdMAI/8W0DTLwNQwvjK/gC14BGgI8cg/y9yeAFysoXZVAF+wrjJPQ6z1ee99wLaBaBJSJH4xMPATs5HVA9hBlxkzvBlarssJGVsyLnJdl4SLscVZn6laBBOYhemRSTgAnCErQ+D/PD5yj2UMDi5LmEFh4De8zkAYdVC+NxlnIdBt6gzzlsGwgyRFGbkXGWfImcPS9vD3nX5bJGehyXrYc+9WDxksSnnIYx2uKgg40VYbrneElQo91+83V/nLR6Ps7S0RL/fV6ykBI1JISmVSlGv13nvvfdUa6lqtUoikaDZbCof+N7eHqVSiVKpxO7urur8cOvWLTKZDI8ePaJer7NYLNjY2FCL9i+++EK1/ZK2gCKrlQJbq9XCNE1u3Lih2j0Jayxyadd1OT09VbLhV155Rc2xi8VCAVzJv3jxxRf5/d//fUzT5Cc/+QkPHjxA0zQKhYJKlBblUqlUUnOZhCVKkTCXy5HP55nNZuodcffuXdbX1ymXyzx79oxWq4VtB72XpYWkpK9LG8Pwu0LeSVIYlOde3hEyzwqAk0KeyIQ3NjaYTCZ8+OGHNJtN9UyMRiMVUHZ8fKwsSjdv3lSAFYJ5VsIFb9++rQCZMJ7RaFTJ858+fcrp6SlbW1t4nken0+H555+nWCzy6NEj5aWW+TUSiVAsFpVlYGlpSSkcRJ3Q7XapVCoqyV6k7OJRHg6H5PN55vM5nU6H4XDIYDCgXC4rFYZlWSr4ThLuJahPiuNiK5F5VsLuZBzK/NButzk+PgYglUrRaDRUSziZC2XOuXjxIqenpwqAd7tdZV8IW2DW19dxHIfl5eUz7xZ5D8icKWuT4+NjpTzZ2dmhWq2qkLl+v08kElH2gMePHzOfz1leXlZFRPmsdrutFFUyJ6fTaR48eKDOW2TjMt5EzSFjzPM8yuWyWpN8nbd4HZbyc3bHPmXKpFlg0SDCCB2fKQPSONQHJv6/ibHdGrP1XZ9pDTYSMK4HPX5zFdg7TlC2TUp0+JDLNNkkX/oLpi97jDIxso8XXKpPuL6AxQY8MjMwzpH6vEekFXTBGpzC5JFGrxtn9pFNbOAQcW1a+h7mis0LFUgM7vHTpss893eDILHhEzCWgkbJzacQMYMDeuU5MHwwo4GXt/5Dyp0H+DWH3WyP9oVX8L77h5DQ0P/shMQHPqM5JG5MuXX4HvknELkJ6TwQg09cGDqXoZoAz8LTX+TQ0HEyEfzCNbRpi+J4xmixz3DxLmjXIFcF6z7p/mdojo/Vg1jKh4wOZgKGTfThAan5gqwXALf2dISv7RH1ToktwJ94xO0+c7sLdhymGfAc8NxA428Bcx/wibhzvEUCYhugTdAP32bp4AFzXBZlHf+0RtNc42fRfYz6jPjcY27kwLgArSRaPYbuari6AdEsJAtw6028xRaM9sA+xW/NIBqF4iqMNDD/Em3jCD/9YiBxdzqgPw+DAtQfgGVCdYbBKZkFJCJwWIR61+Ci7bK6BI1IGme0Tqxxn+eiA77oRnEqEfTEgpZeQksPcWMZ+oVNGBzBcB/y1cDH3vmU/OiQ6SCBVc7jFjwStotujbAyJiRaAfiupMDtY85ntBIwiuQhcw2yl2FUDSoA/l+Tdz7HHzlERpDSIa4FhP78CBY6+Ck4bcDJFJxlHSflEqsE9Z9HbjBmMmko1aHUhMeGyWfly9jVBZeKu9hFjXFkmdOLp2y1FtTaLhpekIAeD0D3sg3ReHBrdQ9sB5ofm+TsOCnNJqYvqG2DpsPgETSdBD008pEORtvjyX+fYD6KkXu5T3cp+My4C2jg1iHaB3OSwnMvYhQesh6zuPt+lPY8xpQexuIKfWqMaJMkgk4EP9HFLwM+FMeQ/x/e4Rr4ioPug4MDut2u8qWGt3BwlICy4XB4xicni/TzUmUBhwLIPc9ToEP8yfJznU5HtZEZDAbKXxpmMsVvJuBAFngCDMItwoSJDsviw6FsAj7Ecy2fKaBbFiThcxFwMZ/PFchJJBKqR6280IWdlMCYsAdc2oyIokAWgmFvtYClMNAMA8/zoFu+L8csvWqFXRPmXNgQQKXECzgTUCYtbgSsCat/niWW/clXOKhOiiGyAJQFpfxsmMU+H/h1vsgR3uQ4wuFywszI74Q/A1CfIWMpbDWQcSDeynQ6rcarbduqv284qVyUEOGe1nJM4gENy9alkCJskjDOYWm3yHjDhRdZVIZBdxjgy/Mo90UKGTJWZDxms1my2azyuso4kM8I37/pdKqktCIvD4/J8PMYVq/8x/Z0/6e2DQYDbty4QbPZVPdtMpmQTqf/nXsznU55+vQpsViMCxcunHk2BoOBSr0WBrbf7ysG+t69ewqIb2xs4Ps+w+GQH/7wh3z22WcqQVkKeeVyWYFr8drKvS6VSmha0HViMBjw+PHjM8y5yHGFKZXjl7Zet27dQtM0tre3uX37Nv/yX/5L7ty5Q6/XU8+azC0XLlxA14MgLpEwDwYDEokE3/nOd/jWt75Ft9slmUyqoLDFYsH7779Pu93mpZdeotFoKIuQjEuZ0+v1OsPhUBWzxEOeTqfVeJV5QNQA169fV4VIAaXyXA4GA+UvlvlI5Nirq6tsbW1x+fJllewNgS93e3tb7d91gzab0tdaGNTBYKDmhF6vB0A6nVbgzXEcpU4Qy0c2m1X3Wt4dyWRSyemj0SilUknNqfJuWCwWdDodisWishhMJhPy+bwq+mUyGdUPW3IFAJU8PxqNVOidsO7Sgi6VSuF5HpcuXcIwDPU+kXlHEvTj8bg6N7nGUhQSwCljRhQU1WpVrQvE5x1mmguFgip2yPMixWVJExf7mRyD7wfp5qenp6oYLe/aSCSigvqy2aya03K5HNVqVXUGkfwGTdOUV10k548ePeLRo0dKwi/ztBQmbNvmG9/4hsqrEZWHKEC+ztvgAG6YMUrE8EhgA2Om6CRxWeDqdRzPxTdgukhy8J7GxgWf5a0guytaB0+DQdwgu9jG0kdY6X3KkwkxDjBXXUpD+LVPRxifQ7kMxUvwtgejoUH+z44o/7XPvGeSzjn0o6AnfMpEGfWq1J/sU4r6xDWb1KrPfBmyZZek1mOeTMDgCcbjt3DjV2E5D+4+un2CN1+H7O/Bog6uC16U7M6/pe8mOXr5CjHtKd76a7B6G374v8e8s0fTCXLJMh2wjqBJEB5etKDgQHzXgJFDqv+vsJMlrOf+EMv/zSCwK9HBH0/p1FMsWR18+3/JeOtN/NX/MVr9AwrRY2wXfAcStgZ6BiyHWP2I3HCBZwatrG1fx0/6kJ6TcgKm1TIzRP050f5jrPEh2LeBSKB37ifAMgCdqGuwiA5wb0zhqgXTGURtnLSHlwF/NQez13AXNxlGG+BP4QBY5DCdi0SsGDPdD3zi9hiyKbAyMBlDNo4+fIbmjnD1FYzeAFM7wEldxoiNyeb+hl5lCerfgEdzmMchmobTPJR8sLr4TodnjkE3eQG/0IHxmHEU3JLBLPU82HmIzDnWwVo4ZDsDpsU0dmUFYz7FmICbLwQMv5aAzOUgQryaxpxrVDtTjn2XSNpnbeTRGJlYmUyQXrbIQ9ojPTgiZ/r4KbDdy7D2mxCNQHsOuRHR2QF5zcGaQ0wLfO+OC7odKPgHZtCPO7cLxHQgz0Tr4xVdhqOAzaYKqxaUTsCNwl6yyKL6OsQaPNNt3HwanDLt6IId65SLcZcMYOWCZ6rYgPExjFOAB4kh+IMM6fl1TmkRTZwQO4CTDsxciLhgMyLJnHT+FCPpox9kyK2NmH4DGsmg5/w0BsURLD+A6Z6JYWUokEXrJjn6VzPu7+d4mp3geTOiUw3L6BLRolyzEixrd7l5pc5SEZJdSA9gUfnV5pyvNOiu1+tKWh4GOsIOhL8ncnKR9ol075f5g+V3hYGUhYVUqoXlE0nWdDpVSaHymfClvFgq1OcZRlmgCbMh4ErO4bxEV+RoYQAmLayELTz/sgz7Z6XdjCx+wxJ1YSMEsMzngXZCFiXnZd7y4g4zwLKAlEWjMJfngZXsL+xdlAWBsEHCSocBq0g/wyy8qAkk2Ch8bcIMcRh0h9lrAe5hb3k0GlVySDnvMJCV+3vetyyg8LwXW9QJ59Pc5ffOj73w2BXWP8wkw5fSbAHFUngR9ux8Cn2Y6ZZ9hYsA4pcOj39AtYATma2MSSl0hYtX4ZC0MLsd9reHJf4yrgXoS3FF1ArSUkmkted/T0COjBcBYWEwpuv6mf3KvZAiztd5e/jwocqNePr0qZLuSpBZeKEvqdlyfUejkZLahu+TLPg1LQjv2t3d5cGDBzQaDUqlErdv3yYSifDxxx9z584d5cfe2NhA13XVTgpgdXUVCBRL0os7bAMRS5DYJWzbVmBR5hXLslQq+rVr11hZWeG9995TLcOklZmMJZnfCoWCsvGMRiMajYbqQx6JRNjf3+e3f/u3Veq6bL1eD9u2OTk5UXLsMIgR5YnIqIvFItPplHQ6rdjdsMpCciekMCGgU+YlOd5oNMrOzg7Pnj1T747V1VU1/21sbHDjxg3W19dZXl4GUMXU8NwjrcZ2d3f57LPPlDrANE1VMAZUQJoEh0kiufRylwLWZDKhUqnw7NkzMpmMkqzbts3y8rKS6osn23VdZXNIJBKqsCpBf/l8/kwBUNpszWYzdX9Erh6LxTg4OFAKlvBWKpVUgUHS9eVdJooxmVfF8iVMucjRo9Eo4/FYJXpfu3aN4+NjHj58SKVSOcPkF4tFNRf3+31msxmpVIpCoaC6jEgQnKTKA+qcstksh4eHJJNJHMdRDLSocnK5HBcuXFAAvFwus729rZ5px3Go1+uqqCEF9UajwcHBgUrrLxaLKndGimuXL19W1h35U9LPv+7bvXmJuP0CBg4POUUnQ5kEFnsspbrkXJ/TeZYoUyqRCW4W5lFIOBAf/aITUxkc3cfRWhjmCD0D5ekIzYtj92BlF07fNmh9WkK73aL8TR8rCvmP+qz9tY7zrIqT6rFRc9CzMPxCwzGmaIkZ6+MoeCaj5ISSGeR7NU2YeAnwPZibGP0uEfN9LLdExumipRb0U9tB+Jjtw+IZ2SdfsNzpsHP1D6H2KtYH/1soZMBoEGm8Q0YbMMrDZhyMUdCvuxANUtrbF0FvwPjUxJzssfqkyTR/xNHK85D8n8JiBLOPABMNj2EPFpYVxEwXE+B10PzgUBIRsGJAYo7WOGBZG1DNw8kcTtIpvMovem4bURZuDA8bYnEs1ycxnGONB+BHQSOgOd0EaFMwHHA9vMoO1D4K5Na2gbeapWPeRDM0/Op1mD0Pjzbg7jJMQHNNfNcGy8QyTTAimIs0trOAwRcwfhutV8dItSibLWYTjZHbZNmfoCd8DjNTjNQU310Au5B+BeZLAbtdAjBhNIFyDZ0ykcwQf3MdzfHJ2X3Gy9DOSxDc+5jJFgeuSbLgBdLsRAzcMV7Ewbfn0H8QtP6iDJoFegQylxluNtDnPehrGGMPywErb6DF5sQOLAyrh+P5GPhEgSEJvPwtqJuQG0BkBPM+lmcwdHVSnsfCgKEWtAQzkoHiwfQgNQls5IfoENVJDH1aQzhOQqYMnEDkPUi14NnzOu3qLTCrUBzjJl6DRAz6AxbGJRrJMTeWp8wXwbiwJ4F3O1kMwgm1YxgOI0zmWbIk2I9PcK4uSO0myY4rxG8f4sd9dL/KJjMuRj3GSVjc6GB+0+XoBkx/EYKnu7DxFLIPdXpWngwp5pT5ZHIL49kDxr6Dr7cwvRKLxASifaz4FovmlC0vSqRr4t53iTQ8nCu/KDD8CttXGnRLn83zIDfMSEYikTOpnbKoCTPJYQ+4LPrkJS6SZkmZFcZZqufCMAuYDTOXckyyMEomk+pYYrEYruuqKr+AWWEwZJEZZvGAMywvoP4fOBMQFmZP4UsAHAahcs7hIDep4As7D5wpTMiC8DybK4skOQbZp+xLGKYwcBWQN5vNGA6HZ+wCArrlfolvTwoFAl7l2kpPWilWCHgIs9pynuFrEV58CaCUawKcAeMyPoR1DV9LWQgLQJF/y3UQSbrIseUYBFDKcctCNAzE5ZhlgXq+EBGWyocZnbDcW+6FnNN5cG9Z1pligVwbYdIl6V0KFWGJpDB34YKEPCvy3EjBKBzAJhaA8PUtlUoqrVwkxmFZuUhhZaxIeJTsO6yukPMLWyPCVomvu7zccRwODw9VYrcodTzPY21tTSXyLy8vk06nKRaLrK2tnVFbuK5LPp+n2+2qAoswtMJY3r9/H4CNjQ31DD58+FAV79bW1qhWqyq4arFYqHZOMo5kLM3nc2q1mpJDS3FkZ2cHXddV72LTNFleXuZHP/oRDx8+BODll1+mXC5z/fp14vE4d+7cUWNYLCcyl0jORKFQYDqdks1mOT09ZTabkc/n2dvbo9frqaKFjDuZhxuNBqlUiul0Sr/fP/OZ0+mUVqulCmvxeJxCoaAsSwLyNE07kzPiOA6DweBM60Q5tkajoa7pcDjE84L2bS+++CLFYlE9S4AC1oCag7LZ7Bm11kcffcTjx4+VnWp7e1u9b/L5PK7rqkR2GTPj8VhZn2zbVsBXjh2CNHoB9+l0ml6vx8WLF+l2u6roG26jJgx7uAgr81sqlVKJ3fl8nmfPnqkQS7FK9Ho9lc2yvb2tGN5yuaw+u9/vqyLC06dP1XM/Ho8plUqqDaTMY5lMRs0dvV6PnZ0dNjc3uXbtGp999pnqjFAul3nuueeUZU3XdeXVl/uayWSYTqeqqBSNRjk+Pub4+FhdAznP0WjE6uoq9+/fZzabsbKyQqvV4tq1a2q+yuVyPP/88wpUS0DfYrHg2bNnWJZFr9c788zLHBxWFkhOgBRQRHYuhdPRaPTv5JV8HbfTdIQ/nYG/mDFmjB6PcWi4bE1tthZ5Bk4CgyRVr0M62yX7sk98HbIuZHrQsMEdQ9736GabmIMEVttkbszRvQRDSyPVhgcPk/g6xJZ97iRgoUHtnkd0P8kkNmT1ypTSTei0gG4MK++QLLsUH27jGguiSxMiSdB86M8NFrUCJEyIFYlFomxoIxa7R6zosLMao+/GgmbE1XUS7/0VL717xG6piPPSNyB3E//6Pwh6np38rzDjH2ElfKIGDE0dS9coJVz0OcRSkCsF/uPN6QKtW8eeRkimp0RPPsC68lvQy8MogzYdkBrOcGag+Ro0XEi9T2rag0HgxfUSMIv6xKfHLFoRWnqCgW8wTkTwCvEAPPtAIs0sV2aqjUn0OxgW+IkEjBaw6Afx5/N4oDsuzGCWwS408Z//GFJ3iPSO0TwHq3AZ//rfxe+tQzcKzSS0NeiliU3nxD0Y6RaO7kMki+ZH8YiC68CjD0nHfkR86pD0YPtKcL93plMG+RiWm8IYL6i4c2wHNK2NXzyBZBz6ZhDylirAaRxiCXx/iQJP6R59RMqwWU3DQVpjdnwFvOcxon9NzbRoGAZWSQMLDHuAMRgS9WyGkRjocfCzYCRA70BiG/g+VrHGae4d2DmCeZ+xC6a1wG0uMPtwcWjTX8DgEkwN6BYKUM7BogvOo6D/ebIEGZPFU0i6wW3ojKFUgtkUjDkU0uDZkFmBmA84Dsmmz+4+PH7NYO2ay9L7kP0Qmnn4ILWEe+uVwJw9LYF2GlRynCW0/pzrlsu6C+9ZMFsDwwQ7AvYxxAF9qGGfFkiRI0+HdqlP7wocTRzWii1WVjza75e54t0kYn7IaMvnyW1IX3IhA4140A2uo0NuAdqHcLKTo8MmTRLsM+WglkObFSl2elTnaaJUGLpz+oaNb8eI+AYazzPaWya718C69BT3JY/Rr7h8/EqDbuklGQaRYaAJqHReSRw/D7J+GegOM5nhhboACc/zGA6HZ6St4j8VACEgAVDBKrIQkQWavOD6/T6j0UiBLQENi8VCtc8SuWyYDZHzlIVV2DMmRQUBIfKzYUAWDpvzPE8xmOEtzH6GPwO+lIvLZ4ZBd/j35E9hI8+zxbJwlbZrYY+7+Nxk0SigW9gZKTLIdQ0vEgXkh0G3sBxhH7MUEaS4Iem2YcY8DLjD4Df8PWGaw+nZch/C41TOX5LHRXYqi2xhGuX4wxYBYZj+faBbzk3ufXhchRl2GSPhpFqxH8hCPpPJqL634SBBUQiEiwTyvABq0R72cJ8H3WL1EAlmtVpVIYPpdPrMvROwLYtKGSvChIYZ8zDDHS6+yN/Dx/l13aLRqAppkjFWLBa5d+8erusqu8DW1hYrKytsbGyQz+eVckaAXxikDAYDUqmUAsC+75PJZCiVSrz44ousra2xv7/P3t4elmWplkYCSkSNomkaqVSKXq+nQsCy2SzVapULFy4oO5CMNUlclvtYq9XY39/nrbfeUr7zTqfD+vo6r776Knfu3OH+/fvEYjHW1tYYj8eqoDCZTFRxdW9vj3K5TCaTodPpUKlUWF5e5vLly4qVNgyDfr/PYDBQBVNJ2BZvbyaTIZ1O4/u+KlhKcU2eM3kmRaLt+74qHEkrrW63y4ULF5Q8WYIKDw4O1JgX+5AoTQRsyzMbLg4AFItFFeTl+z7tdlv105ZrJ1smk1EgT4CnyK+FbY7FYgrQLS8vK4tXPp9nOp2qQqIwtK+88gqFQoH79+8r9llYX/nccrnM2tqaKsDIvCX+eAlMq9frNJtN1aYtn8+rOUQyU2TMHB0dqSKIFAylDZkA1nAWhGSzSOJ3p9NRRZAf/OAH9Ho9Go2GslXcvn1bjQFRZcXjcRWmKgWqra0t1c5LQj2lQCNFhkgkwo0bNygWi0oJYFmWYspHoxG3b9/m0qVLKuU8FovR6/XU+7LRaDAcDul0OkolIfYr13VVMWFra4tut6uK1dL2r9lsqjA3Kdh93bdhNYo/aJGvu5Sx6WaTjJeKPH06ornYwifBNf0OF24NSPy6j38L8gXIjkDrQrwF7gxcHVikGFNgED8lpU/Rx49J3HBxPMjNdFI3+jRe1jlYS5HdG+F9EcNwiqw+d8S1FwJveNSA3ItzNA2Mhk5KG9NL9qksQbIGx1nYr2ZgcwuMFIx2yJtzqg44PShGYFhd0Bh3cWoLOHhM6o9bdJ4tcfxNH7oPYPUGXP0dePqXGA/+G/zYnPkaaOMSo9VvYPgPWJ6cEDch78DhHiwKkCrDYBZj9bpFctnAvnwh6LmGDikb/6TNaOCTSkA25tDJJTD1EdnhgpkBsXRwyHMgPnPx0JjGVpl6afAGQdNnMw0GMDvCilsMfMhNPNwFDJI+JE7B7oG5ibaIgm7jV+fgxfAL+1D9gvT4kPX5jL4GDdvCT04Dir0fgWk8kAv4I6zsHNcLArbwijDL4RtTLNMPAK22R8RyiQ2DzLeoB1kbyGQYX1sHJwv+lKF7j7Jr0dcPsZIPYKUAwxj0hpCOgnYB9rt4WRe3ANp0DDHoGRpjYwn05+DgNdzNGIvs56x5bQ4m0J2C4TkUdIjMYFiOw9omRMoQywUNs7UGFMswfxPym3Dzr7Gb7xFpjsi2fYwxODnQkkGquJOBuQe+4YN3F6wxdPdgWoHkdgD0LQ8vBtkYOBMouEGbrbgd+LZ7fRhPwNV9ot0ZqbbPs1yU7n9Wxe01qbzrkh/5fPiSQefV7cCUPeqAN4dIHGIl9HadS+13yVsL3o4YHF5y8WsQt8CdQjcCGzmo1nyoTzCnK0QY8cKKQ3cdTnMWz08t9I9iFE+vMDcP+fiFY4Z/H0aXIZuDjBvc21QP0gsozGH6KE5jvsYDTOpmFJweyWacqZ5Aw8UmSwqbb7kl7owt6mYUzc+yR4I425jGgNR1H68SBMf/KttXGnSHZWJSKT/PZIpfUHqgapqmWGVZUMjPh5lA+UyRwYX9VOHfFVAmiwJ5ocviXj5PFrzib5OFgQBdeXGHj10A3HkJ83lAIYsiCcoJs3rh3xGAKqylgGMBm7LAk3OSP+UcznuQw8ckPyN/nvfLnpcHC2MqHjv5Emm0/H+YkRWZu5xvGOgLYyPjQjzacq6AYkTOFwjk8+fzuVrEJBIJ1TpFzuu8rxpQYFIKI+GCR5hZDwfECXgQACyfEZZDS4FHWP+wt1xsBRIyJcBb2tuE2Xn5uzwr4SJD+B6FPc+GYai0fmG25NpLoUn+ft7rHr4vf9vnhxedkrQsXu5isaik5eHnaDKZ0O/3FYNzfv/h51b2Fy6+yffCz9J5SerXbctkMooFW1tbYzQa0Wq1zhQpVlZW+I3f+A0uXbqkAES9XlcKBhmD0kIpl8vhuq4CqNFoVLWyevXVV5lOp7z33nvKz7q0tKQKNhLsNhgMuHfvnurbXK1WyefzlMtlrly5QjQaZTKZqGyG09NTBeYmkwkbGxssFgv+/M//XMnXo9GoClorFos8ffqUjz/+mOXlZWq1mmJLd3d36ff7CnzNZjMFRiqVCp1Oh3Q6zaVLl0ilUozHYz7//HM++eQTHMdhbW0Ny7I4OTkBoFwuk8/n1XwuFp3ZbKZ8xzL3pVIpOp2OekaSySS1Wk1Jr0X2ffXqVfWMmqZJq9VS/nABqxLO9uzZM05OTsjlcnzrW99C14Pk9nq9zsnJCZZl8corr/Diiy+q51jUK6ZpUigUWFpaUsC92+3i+0FXDhkDmqYpwH50dMSdO3dU+vlLL72kAKcw7qJ0KhQKqsXYxsYG9Xqddrt9psAJQTFH7oV42+PxuCqoaZrG2toaFy9eZD6fq2DATqdDKpVSvePFytVqtZjNZuzv76uCjoDgtbU1NU9KgFgmk8F1XZXQLhkSnU4HTdOoVqvU63Xeeecd1tfX6ff7XL58WUnMpYCzvLzMvXv3eOedd0ilUqyvryspuVhnwjklUoAWm5Z44UWmLmGE8Xic3/7t32Z5eVmp0aQwIGNJggT7/b56VuRdP5lMlLpCVB9SmJH3oagNrly5onzfoiD5Om9+pgRGjFJrwCVnyuN2h97EY+rNaaU0Vice6xdPufFPHFq3oK9DZwiMIbcWBE05O0GL59g8yUJfkNMs3FGOjumQiEAxBu6LA/Z+HfZfKaLNXIo/B7O+yjg1p3rRwytC6RRYgeM3YDEE+x2PrlFncQn8bWjn4NNyjuHl1yC2BhMfoj7uDErHYHZhnIXhxMRdL8B8j8yf/TlLOxYTJ01hdEz39F0c5+/BZAk+6bH+sxGRDdhbT2PF/idoyzlu7r/Pah0i8wAEfRDV6W55eBpMlm9w3Bnhp8v4S9+DowwUh3D0Lrn3n2FoMCwY+BYk6iOSwKwMg3waz8iTdDrkJjNiM0jMHWbDI9yMgW1YzNmG1Dp0jkHfA91iltKI13y6wwJ2cg0yTVh5BoMrMDMg5UAhAqUWVB5TmD7gheaMuAVOAvDnsPsuJD6G5Dch+13QDEg28J87wNHuBWldke/D7ovQNvEjThDyRo6ZaRJbtlksBd20lnxIDmcsfBvGzzDcBUbaxZxAajbF8t+FXA820uDVwLsK09tge/iGh1UEN2LSi8TpEYXCZVhJgtcE4wZHsTfYmP33VFyfuh2Ek0c1sEYE1PLsAPqHEK9BLBkMlNQnYL8A+q9B+h9jexcZRt+CwlOKHZtYCiKVwKY+1mBsRaCVgOld4gfv4C95LMovwPFl0Gqwdg9nYmO5UIyCboGdAVwwh5D4RYv0RNSl1nFJAd4lDRoaxf82ysWnMRrrPXZvx/DLSXDiYIyDIkH1Gvr9R1z/0U+4sDThJ+sFBvEiTI9J63NKsSAfr2gGaen2Cb8gR1rYjCk8ShAf21zIWiSbMO+4jNfusffykPbf8+ktQ9SC/gRcE9LzIPxtXYPKE3jwpMxDPc5xZAZ6Ei0WITtNUfTHVBmQIUOeOFk0TM8Ed86TrMXDuE685/HKxi5XXvbp+sF1+VW2rzToFg+SsDJh+aRs6XSapaUl0uk0tVpNeZ8EFAnDF07MBs4A9kwmo3xy4/FYAUeRlQubLoyC+MPCTFo8HmdlZYV4PK7aZEkFW1qNwZeAVSR84qsK+24FkMsxSCCbLKSAM95uAVK5XI5YLKbAv3jnxLMsfmoJ1hKAJC92Aadh+bts5wG3AC/ZwuFz4g0HVEiNFB6kDVTYfy6sjrDxYbZY9pXL5ZjP50Sj0TMyQcMwVCVfAJcAQmkvJkBSQHc0GlXAe2lpSXnrJGAmDO5MM2hJE2ZS5d6HE9dFhSEFA7lPYhc4H2QmvytFAJFnykJJFq5yDcNstvSFlwKBFGgkfC/MnMvvy3URJq9cLiv/rAT7SBFI2DlZvMpxyDMUToEPS9ml4CAFqHg8rhbqouCo1WqqIKTr+pnuAMfHx0wmE2UrEfAYlrQL0Jf9yRgJB7mdl+9/Xbder8etW7doNBosLS2xvr7OyckJ2WxWKTPW19cVU93v9xX4fPjwocrAOD09PeN3FtAdjUZ58cUXeeGFF3j99dcpl8u8/fbbHB8fq+dJlDoy3mu1Gmtra8pzK2MjmUxy5coVcrkcw+GQdDqtgJMU5sRXHovF+OSTT1Tf7XB/53g8zpMnT9jd3aVQKKhAvhdffJH33nvvzDMhbGer1QICpdC3v/1tVldXVYG22Wxy584dfN8/0xoKUD3NV1ZWyGaz7O7ucnJyQrPZVEooCRwTj+50OlVzleM4qlXY0tKS8nZLYU081t1ul4ODAzX3CLAXxYAkj9+9e5d8Ps/Ozg71ep3ZbEa73abZbNJoNPj+979PIpFgZWWF73znO/zsZz9Tz6M8m6enp2oOlkA1QM07g8FAjYXZbMba2poK/xTvtkjoAdX+SiTWe3t7AGpMyDnH43GVeK5pmgpp8/2gV3i9Xmdzc5PXX3+d5eVl9vf3lYJBigMS6CaMuwBKKciE2x7Ke0TmCwHHkUiEfD6vitSmGfRd/+lPf8qFCxewLIt8Ps+1a9fUmBFV1p07d3jrrbeUimF5eZkf//jHWJbFtWvX1DjPZrM8efJE5RtIoWI4HKrrKMWR5eVlVRCTHuiy1pHC1Gg04u7du3Q6HXXNRDknirr19XUKhQLRaJTRaKRalck6Zzgc8sILLwAoi1Um8ys2ov0qbZ0+XH2OwbFHpd9hzT/mcOzwgBTewuWiccrSxSmTArRLMO0HAdXjJSh2oNQBDuH0SGNAjzEeEQtc36RjxyjtTqi8DK3vwdHrWexyjvQ7dWKHMHXGzCIWnTGkPUinYRSB3RV4sp5lWrqA7w7R/AGG7+Ml8ywuvwa5TRh6kHZhbpDZh3IfBsdBiHfLyOLH1uCTQ5baA/JxmDowII6bfQHiKzD+nGj3b7jcnVMoQiObx77xCulPf8i32mPaA7A0SPYh63tUy5By4bhgMPnmP4boJXALQbR1vEn6zsesLSzqJfDnPtmBT44gh2xUNPFWbkF2FXf3bVL1GeNmQG7HLI9pWsNPaZApQGwFprtBP6Z5gohjQ8nDzl2EpdtgPYbkEKZ2AI7dCVgupHpozj0uzgYkNRjpEJlC1Gyx0CYB8xypQuEOrBch84BC/k+5OK0zHsKh94jZyu/A9AekTxNMWMGL/xbzfJLTixZaYUxB+5ySOSHWt6E/AmtEqjdhGZgC07lPwWoRG3WwPB0nG2eUeRF/sgJ2BCfl0I2BP/TAA+KpIAp8NQ+RAXwaw5++yWj8M67QZupCzIS1ORz2COK3uxMMe0BUO2SeTeH7UfAHkG2Ao8Pxb4D3+/jZ5xgsvcNotYE+GVL3HkN6hD+EuOMyzeswNUlZY5K6zzD6EYP2HGJlJpEUvt5nMIWkDmUNkoAWC1qi53Uo6BAvwEkiCNu7+mzB2s4xLzyJMilOeP/vpBndeBG4CBEPFj5oZfTP7vGt//qPeWFvzL/9vRTDapLSj4+J2hb61V88kok486xDeeqgnURxrQu4zDGZMBxeIDGMoNcesbjiwXccBpcG7FyHvq7hdnwiCYjFgGjA1I/jQQ/u/Z+aPLUKnKx6wYPijvDjHlMrTsEZcKHYotBN4Pjf5HMcjstDvGideQqIxsj0jygXRzAC/QQiv2Is0FcadIc3YS7hy8Cm8KIu/BVuqXQ+cAo44y0Tplv82gJkzzPZshgUFuG8n1oCokS6LJ8lAEYY5vM+47AfVhZZYTZPQH+YhRegEw75kU0WIVIJF1At5xE+Brmm8nf4Usou+5PjCwP08CY/IxLicGq5AB8BTmHlQTjwSn5HwLYkcYfvnQQGhft+ix9UwHc4KCjM0IeLCLIYFulhNpv9pb5u+XdYNi7g9bycWb4vi0AZfxJqJT8j400WQpKKLIyHgMcwW3+esZUgOLmfcg/CIYDhzAL5OTknAQeSNi0suZyTFEQEhIs8M2xjkPEsRYCw/UMk9el0WrVsEkWJeFnD9gTxb4oUVtjtcNHglxV8wgU0CZwTeXvYi/913gS4ua7LYDDgzTffxPd91U+41+vxySefMJ/PFUC1LIt2u81HH32kgIOEmYVbSsm9SqfTLC8vK+uOpI6He7UXCgUlQT46OuLWrVtsbm4qkCQFRQH+EIC8n//856qfdr/fZ2trS4WhicxXeorfvn2ba9euYds2+/v7ah6QJOt4PM7R0ZEKkBPrh8jvt7e3GQ6HlEolrl27RrvdVs972IMugPTq1atcuHBB9fKWFG2xJ0lLSGGKBUzG43E1h4pMXJ7lbDbL8vIyhmEopnmxWDAYDFRK+ng8VmFukixfqVTwfZ979+6xsbGheqNLMTESifD2228zn8/5/ve/T6VS4bXXXuPixYtKtfLw4UP6/T7Ly8s4jqMKuOEuGfBlxw7x9YtsX4pkojwRVnc+nytlT6fT4fHjx2f87VIwEQWahHHatq0KPP1+n16vx/3797l16xavv/66Yr2lb/zJyQl7e3uquCqJ7pqmcXx8jGmaqk1YpVJRmSqiMJL3uzDXMh7n8zmVSgVd1zk8PCSTyfDtb3+bra0tANURotls8s4773Dx4kWGwyE3btzgZz/7Gbu7uywtLbGzs6PGabFYVL5qKWRIEWAymbC6usqlS5fOqAdEDi5tMaVl33Q65aOPPuLhw4dq3EmxVALcfN+n0Wgon7woAjRNU8FqN2/eZGVlhW63SyqVUvv7um+a2caf1Zm4Pv34hF9PTaCjc5cLmKSxvBaf7kDqJ1CogJsNWO1CE47/rUHrkUE1btGf6UzwsHyPsQ7ReJ/ILEN2pmEnfb5YiTMtlMDwGSdS7E0tdE9jNouyPodiAcadQCK+ODTp3/oWvHYbBg8CMBVJBGFbpRL0m6BVYa6T+PkXXD516E2gvwAjA1YyATODZPMB8arFwQvQmcDstefg6g+ABdro/8hy5g6lSz6pCmheBZJZzIMjUiOwErAAXAu8Nsw02FyCrF6nGytB7joM2oFvfGqSGI1JpmFSgVzPY6kP7otgXoD2vAClSzBuYy6GWEYQqO5noK8ncNIl0FpgW6AN0eIdNDuJxxqG9QzNXwT6aGMN9Bx0r8DchMQo0Eo7C9B7pFtHVMcuozGc2qCPoBSZ0Rhk8dy/A2kfjA/gyi0i82dcOTkk8TQ4x9u1XZ6m/hWN8gJr9APQyuC9BtGLeBdnsNWjs+fxUHsfe9lDdzp46ShTM8ogYjHygoTvLXx8z+Wo45Kc27jmYyaZPoy38PQSQz0Otgf+BKJl8PKB3j4J1BwYDNEfLkgWoBYNel1zGPx3XJsxn2/imqu4/kMMu48TiYDrovebpHr/Z9zp+0zjvwOx70H2Ot56D88c4ez+10RO3iW971KOeRx7J0xzVbQVWNZAO7aYmJ/jdDZw9QKTyhg/Dgs3jR2ZMU8sKCUh4UFhAqYdKMVXqlCxYKUPeszlzpUZH754gf73X4OLrwEWTKewiEHzPis/+SnfOxxz96LOya0qkZ+1eOneHG0D6juw5xlMb69ilfrU6VB2dSy9i+WBRRFNazMpzsl81yP5Ojw14EERjqIRvI5BLjonFgM9BrlYYKtPTsF5D/buZzguevhVHWYFyKdhtsDWI7SsOMfTHFO/wg7gYZCa2QxcnXSrRN7p8WrmlFXLp/cFpDSoF3+1OecrDbrDLJosAmVBLgt/+RIAJD7pyWSiWoMIqDufEC0+8FwuR7lcVr5SQDF+iURCLTIkjKharSowLKBIgKcsImTh2O/31aI2DOYEVIh3WSRvYd+67/tK/hwGYbKYFaZKFhHC3qTTaZXOHWZdwyxlWJ4mvy8/IwtqQFXpw+x2GGyJjFJ82cKcwpdgV+Tmcp+AM95JUTAIwBO/nSws5/O5CkLK5/Nsb2+rNmICOCWARzyVYcAunysLXJF2hostohIQn2tYoh4upMh1l8WsLB5lfIWDzgRMhosES0tLSoYbZuIl3V16ysv3pLh0vjAjvytBc7LgD9sDzhdZIpGI2r+07xGQK63cxLYQTkkXxiZc1AorIWSMSV/YQqHA6uoq6XSalZWVM8UfKUzJWJhOpwwGA/WcyHmfD02DLwtvMnblT1GXSCiWPFNfd6bb8zy63S79fl9lRIi8tNfrKfnxyckJS0tLfP/732c6nfLuu+9yeHioCiei8BDbQafTwbIslc4s4EYCmEajERsbG/T7fTY2NhRIF4Alsm2R8sp8ID2ns9ksP//5z5W8t16vUyqV2NraolgscnJywmw2wzAM3njjDTVuXNfl+PiY09NTNT7L5TKrq6sUCgU1T/d6Per1uvIyyziV33/llVeYzWZqrORyObrdLsfHxyo5XYCP67rKjy3KKPHJiqUpbJEQT7kkZEtBQJQuy8vL6j0hc8/p6SnZbJZisagAr0jVNzY2+M53vqNk867rqsA1CcUU1vTOnTucnJzwh3/4h2xtbankdkCBL5EthxlwCS0UdZTI6cXSkslklOxeZOpyX+fzOfl8nlwux/7+Pr1eT6W5y7wrxS8B4el0Wl1D+To5OcE0Td5//33W1tbY3t5WhcPpdMqjR484Pj6mWq2q7IDzXmX5eXlnZzIZisWimpvl/wqFgvLoi52l1+tx+fJlXnnlFaVYkIJJs9nkrbfeUiocySfY29tTthhRDbz99ttMJhOOjo7wPI9SqaSKkdVqFQiS1yuViipAyliSe+l5nmqP1mg0+PnPf66uYyaTIZvNAqh0eWm3F4lEVMCfqAEikQirq6tcuXJFFX2XlpZUoN7XfYv4Lta4wyKp0WrFWdgZEuRYJ8aUNnV/QmtnhcKoy4vLc/h+kN5s/QWcflhhYUfwC0fEMi4LK2i5lY5AZwq2Nkcr+zwqQ281DpoHngGjGKPDEpq3TSnyjEvxIBF9GAFNgwM9A6ktGAGzHCQTgdlbiwdo0jYhW8Z87+c81/mcqOnTOIBUCU63NeziMtrxIZdmJ3gGnPxGHk+PQCwLXg/aOxROf8KmteB+XmNYMxnXXoZMFd3vE/VhcAj1hkbW95nGNQamwcW0w1Wrz7uHJ7AUCZK1olFIRfAqBotjSB4HWKaThEXMIBnzcN0ViG3DxGEei9HNzvFz4E1MnKQJ+Rk4BtgGTAb4noc/SUCqyMw9IefNMOIW7rwKp0WwazA1IepCNAFTH6wT1jL7bCzg3lGgKo/HoNuI4dV/Hfj7kNmFSBfSLrHmPSbHEZrDJEZ5gDOAldkp1dK/4P7KUzzzfw7DLeiV4eEeZCL4hau0Jp+TMWfkF3PGEQsrGaOtaSTHPutjqKahH4dUDiYGzF0TJvPATB35BkQPIXkK2JCMQXQC8xPIXICtAtq7D8mejGm1QFsBbwKjNmhZiOAy92YwzWKn42jZGUwjRKY+q9M5mZM5jvkZ+5Ep07VtOL4CbRdue5jTMflHLvPjgPBP6BrTYpb4xOSWazPtAEmftLfPjBRuYhU8E7I1xkWXqX5I22uxwYLNBGSy4OQhnoFFDk5WdB730zysvIj9ymsQX4KJGbRlM5KYjU9Y+9GPuX444/QafHQ7jp9dIbLfYuACIyh0QcelPjwgMXbRnkLPcyjmWxjDGBFnhWq8j3vL4uPL0KlAO64xixiYE4dI0iGpB23pNB+cQTCsIg149lcZjqZlnIIH01wQRtcGFiaR2QT8Gk+mS6yRQ+eIC9FnpD2Hg3GcqJekZo65uuJjLkNiHZay0Jn9bbPK/+vtKw26w2yjLLLDnmtZyIfDbM4nGYvcVwCrLOIFxAj4E99W2BcaDqcKh3oJyJKFiexbPFzCBIlET0BKmBUUoB5m5aTIAF8CGZGch1nNsIT4fGAWnE3kPh8Sdp5Rl/OQhbGwD+FArDDrHb7eYfAt9yjMyofDweT/Jf1YZHYiNQ7LS8NSdwGAwnrIz8o5yLHLglsCiuRayv0Jf4VDisKhb2H2PXxesoVl3r/MOyzHKyy43C/53TDTcl5xcP7nwqqAcFgZoIC9MLtyf8+rJMLjS35OxrtcH7FgSEp4WKYtXzKuw8oFOWe5/lIEkOwDYdIliT58bGFm/fy4DStBwtdCrqU8t7I/KZQI033eZ/513mzb5vT0VAEc6de9urpKvV7HcRyWlpYUeyr38+TkRFlW2u22AoRy/UQRkU6nlWxWGM5PP/2UyWRCuVxWfn1N07hw4YIKixJJrhSUpEg6Go1IpVLs7e3x8ccfo+u6SliPxWIkk0nm8zn3798/o4iRbANJUxfZbbFY5ObNm2SzWRWQdXJyQr1eV6DHdV3a7TYnJyfEYjGVbi0BVrquc/XqVQaDAbu7u5RKJW7cuKHeNfLeWF5eVlL6UqmkAsBE8i6F02azqWwZYaAnYzX87FuWRSwWo16vk0wm6fV6Z3o8ZzIZ3nzzTa5cuaKe27/5m79RDK4oUAaDAb7vc+vWLQ4ODrh//z6rq6tqX3Lv5F6IJ1vmVLEcCTMvwYrCqvq+r1QAYhuQYxQFhUjdJcMk/F6Rd/ZisaDdbqte6WHvuhQHJARsZWVFFYXEby5FQGGIRT4thUBRD0g4pNiQpDCdzWZVGGq4DWImk+HixYtKMdXtdjEMg2KxyIcffsiHH36oilCeF6SlP378mOXlZcbjMaenp0CgjtvZ2VHFVpF+A+o6DQYDLl++TLFYVAVbKWSE1Vnyzvvkk09UwVf+fPbsmbInLS0tqayCVCql7B3VapVGo8F4PCaVSrGyskIul1Pv4VqtdqaDydd1K09mnIwW+PE8I2+VUzJ49LjBkDo2p1ikvTViI5d+b07ShpIDracRxlYZE5NWf0w810PLQjQWdOoy+gXSWpKjyiEH1yK4fgrsKfgGfDonfprB0wxW7ChmV2Mfn+MtGF3RGN4ogjkIvMZxHxYzcNIBIzruQdKG/XfY/vgnrGkOOzPIGoGU+0kqjjfXyTz4nE3H4XM0PMOAkQXGDKx3oX2f5KRDPQ67xQLuzS1Ib8KkhxP3OarDSQOOhjorukvU8Rm3fJoOmJEZeuwZ3useXE2D04eZy+J6Dn3llOQuzEowu2EwjlUYanPQotCpQaaEm91h7N4NTLvpCphZyBkQj4JxHRIptNYB5vQE222C5xID9AS40wQ8S/wiCE2DuQZY6IcxyByTe27CQQKeZCCuAznommtoh99FG1/BS8QhEoPUW5QSPaKGj+knYTFhYDjk+vBKdsK8/FMeFV6DL9bQGgZ+VIOaC6spFos8hjsnEvXx0NHmHuYU8lNY88GcwNgELwNaRsNNlWGSCeTVi3WIXwk88F4S8IM072IR4skAxXVOcXs6Xdcjl/cDibwNEQuStou/2CXZ9ogMXNwEdHwbfQ5JDwYjmOCjXTiE5X3orcHAhk4UpiniPuiDIFxdLyWg+Dxuu4fZPWDdhoXpMh/B3PMgmYTMVtAnzBnheQVmRoP97GO8+JiCAX3LYNFLM7MKdMubONc3IL0MZgm6DTA8KJaIvP8TLv3p22x/7pJegtELMBgZaI+PqC5PibbB/jCCtfCJaB5L8wgL3WFi6cTdPFbPAn1KoXxEtmjzcRXuX9axih6m7RONOESCKZK5D0UNsj5MLYjOwX9Pw9qp4Rg+0faMdMPDd+/juEMs3+ASWTJs0OaYbY4pRgesfbNOdRMapzD2DkmZUFuB/GpwWmYClo1fNqP8+7evNOgWBkvCc3K5nAJJ4luSF5ZU5UUWK8ymLDTCoFtk4tJiQxhDAUvhtlcCFEVOmEqlFAMiny++XGGIhGGX3s/nPabyZ1i+fN6bKuBUXvRyTv1+/4z3F1AgPuy/lfOMRqNkMhnVwkYWs/AlsI9EImf6gYpPWhY44RTwsFxcFg3CDsl1EgZSjkmOQRbW4pEX9YCmaWckeJFIhPF4rOTictziSe31eriuq3qohhPQ5f4JCy3X7Xyi+nkpuIAOOX45dlm4Amdk22EAHmaApcgDqAKAjE9hgsUacF4mHv5cAdrh78sCcjwen0mlTyaTKt1dkqelIBXOMggDXwlwk5Y88hUuJgnrLONYFvkyFmR8iVpEwrLy+bzKN8hkMkqW6nmeKq5MJhMF9gGl1BAgEg6qm8/nar8CCFOpFPl8nkwmo0B4+HkKFz6+rluxWFTgOgxuhKWtVCosFgs2Nze5fv26ApulUolGo0E2m1XsmFhmOp2OAs1vvPEG165d49mzZ6RSKR49esTe3h6rq6tYlkU6nVageWtri2q1qgBUuGjVarX45JNP6Pf7SkorxbPRaEQ6nSYSidDr9RTrKnNGt9tVSdp7e3sqCXtzc1OlVovvuVwuqwRt8ZsnEgmV5r2+vs69e/fY29tjY2ODbrdLsVjk4sWLNBoNCoUCrutSqVSAL3MX6vU6V69eVcFaMi9K6JXv+wqgimpEnqNkMqkkxtevX1fhdZlMRhXPyuUyn3zyCaVSiddee416va5Y2o2NDaUKSafTai6XopUci6Zp9Ho9JZMeDAaqB3u4YCcBkhD0kBYZu3ivZc6TOVTm3HK5rHIWpHiTSCRUQUSeP9d11dxuWRbxeFzJ4103SNiezWZKyi3+9XCooxQnAFUML5VKKqRuMpnw9OlTRqMRg8FAtV2TayHvY3kHScBYsVhUgFve5TJ3SqaG2CGSySSHh4f89Kc/VeMglUopBVWz2WR1dZXpdMrx8TFHR0eqeGEYhmqLJ8/c9evXVbFA5Oe+7yuFmRRF5d0+m814/Pixes4GgwG1Wg2AtbU1lY0QlvxD8M5ZWVlR/m4JGByNRuzv7zMej1Ux9P8f+nQv5XxGTyb4fop8YRet7OLvRYnZaWLakA0/zyx6ivZah9z1QBY9KIJ+2cF40CTnJoh4cVrDNOnUOGizZGlEfZNeaUDjTZ/h1QTsRImlu8QeLpi+v0rOXSOCRZYlJvMmpmFxshVjulQI/L6j/UBCrqVBt9Hb94h/sk+q2ySPT67lsK3ZjLUgICu1AlYJvJ6HNnzG0qSHHYVZ2ifS6ZEc+yyiDzF275KZT2mVU9gbJbxZDJIroGswGTCtrvDo6R3wYB51GbkaubnOZOhykoJLOY/ig/doP9mDV9dgfAKFJSZbr7Jo7pIoOBy5oJVdwMKcu0S8+8xGH0Lh21B+PSg+LAZgOkFC2KQGvg7pHqSzmCcG2cGCrt4lalhBq7TFEA77cHwT3DREbCALvg0LDa9Z49P4RfzcBaxvFjEGn0EG3OmvoR1t4JsWmm2jWRm8aoZuPkvBbJIYD1mMTUzPCRLFJ5BIzdG0R/h8E8PJ4mhOkKzuFYECfuKURdzDRSc/WLBigx6FngOZUVB0OY1EsC0PQ+/gFttwBBzW4NLtoPjhHgW2gUQ0MKA/ncPIAD2C7UM+DukRWD2IF6GyDrmMz9C1iWaCPurdQ4hmLKJT0GdAHPw4WJFMAOIrkeBgFlFMp8ClDPQ9iA9goz+m87TNdBTnqA7OHNYuwt4CTHNBrPeEydxAM9to/ile9hokNpkXijw1TLRFBi9/MYi0T5aCQLvuXZiPwNbBtCBhoB98wMq/+SnVT2IMXJdM2cIZw1pshNuc0l+F5VNIf5zlaJJmxhgTB6Myoxb1SPhzHMOhsO1w5ZvQLcIXeZN5KYo5m+ITeM19DUwdsmYQADhZgDmHS3ch+amGlhhi6X1qkzzJ6AmRV58QW3dZjCB1N4Zz4AIdTCZE8wtW3oDU5cCikClDLg/uHhy8C+MHkFwH96Vfbc75SoPu8xJS6RcaXnCIP1TYGFmoh8FQ2PcsEmtZmIrEK+zXDQPTMIMrslWRWAsQkpekMNyymAnLtIEzDLIAQAFx8nPhllBhZllAeVhyL1sYTIWBWlhWLGxkGAyHfz8sHz/vmYWzrcHkmIXpDoP4MMN+XqUQZttF/i6hNMIOhRn18DHJ9ZN7Hw7M+mWscbgQEfY3yxYuUoRT4GVfYb+87Cv8WWGlwHnPd1hxIZ8X/v555v1vC/0KMx/h78m9Ox8yJuyvsPXhaye/K8+HPD8iaw/3ow/7vM8fs4Df8HMk0u5sNqt8rhIGJPsPM/1hu4Hcv7DCQPYpxRYpNsi1Do+LsGUjfM/D1+bruonc2DAMXnzxRd544w1++MMf0u/3qdVqSsp/+/ZtJWeNRqNcvXpVFUAkWNB1XRWwt1gsuHnzJq+88ooC1Y7j8JOf/ER5gY+Pj8+oGoRFCyuLotEoT5484YMPPuDZs2dMJpMz7LiMuVwup7zcEGQ0SAFL5vROp8Pe3h7JZFKFAAoggwBMlstlZY8R4J3P57l48aKy3oh/ent7WyliarUaH3/8MaZp0ul0aLVayu8r85Yw69KK6+nTp+r/S6WSkjHLfCeFUpGfi+0nLC2X4tDLL79MpVLhwoULeJ7Ho0ePFGAql8vKZiS2ou3tbbrdrvrcSCRCoVAgHo//O4ULuaZS7BS/rzz78n+5XE616ZJU/F6vx7vvvsvq6ipbW1uqyDwajVThWuaoUqnE5uYmjUaDWCymijeVSkUFP4okXs692WyqYq8UWST0T/zPT548YWdnh2w2y+rqqpLIf/bZZ8RiMarVKisrK4xGI0qlkgq4FHtCuVxmMpkQiURYWVkhk8mo8wVUFohI1gXsS2jaYDBQ9gfx0F+4cEEpiWq1Gk+fPj0TOgdBT3vpzrCxscHy8rIK3BOZfiKRUEy/pmkqnNCyLOr1OovFglqtpoC0FC1eeeUVms2mshx0u101h/d6PcrlskqLl8Lm7u4ujx8/xnEcKpWKKnR93bf6AmKGRdkZ8tJvTPm1W/DD/12Efh1qyQmx2BzjlkvxB3BchkUCjCiUbvlUjlvMp9A7iRBtb+DaHjF/SrmfYZYcMv+tKdNXwZ/MwHAwbJ/UX0F87yoLEiQ4Jo9OMqLRS4GTjYNpBmZqwwLDhmgU7fEOGx98wManNvpBhNxcxzRtWA9aImWcgCjOxaEwW2CxIJmBUwvGroY+91m1fTaafWY78CitYZdLeOlvBAjA84EJZFyccpp+GmK+wcxKMdXmFPIWxjY0ixqrrk+0eQzTOtQvwuMoXIjgZ7/LySdvcdE8ItEJfOBOsY8+1yjEXGaZ96HyLehdhfbnsDgi8nREYu4yj5/glnQoxHD1y7jGjGkUfDfGwlpg5Wdotg8NDcZp0COBtNxNgKnhGTbMXmPRWYbZBfBd3PXLkNbgiwv40RJ4PtFxHDczgE2HUXWDZ4MeG9qERAsiehCCHs+C7gB9C4wpLjHQZkFyeKIAkTS2phO1XLILi/QMIgT9zHsxsE9BPwV/CXKax0b3kHvun2CnLsBgC7oLWPbA/wKiLUhUAlpcNyBTxl/dJH7LpzLz6TwxiPo+lS2PVAEiuUA63ZjAOBkE3S034EIEJjpMozDPRLDTL4K9EfyAOYbBB1SffsTqAJKbMHFh5WDO6cE7NItRrBisZeHEhcslWHJtTuaQnz0kbvjYZY/mZMQieg1q1/CzF/ETm5DPA05gZp8+C3qsF4uBeoEc+ufvsPlv/5ra0zkHnkvZ95k3dIbHHvEKeJ5JX0vQuNyHvS7OkynrjoWJC0nYqEIsN2aah+oWTC7AWzmNdjoKCw0nGUVLOCQWHhk36DTnT6G3gLIFzx/B2jFo1z385xvUhsDjUxaXmlR+0ydWh8EdGJsOdVwOWGYfj61Zh/ywQc0G9zRQEVjAwV8ZPPnhEs5iTtnqYVz41eacrzToLhaLlMtl4vG4SpwVWVgqlVIMp0iiu92ukmUJwyqgFb6Up0qgTbVapVwu47ruGW+XyPWEkZXWKNlsVrXGAc74YYfDIfv7+wrEyGI4DGSBfwe0hYO6pAovi19hu8PgQ0CPACxhwyXAKhxKJgtA8WbKolhYDGHG5M8woJafk8VjeDEZllWHGcmwt1eKGcKIZLNZ9X+SCO77vmI8e72eChYSP50UW2SBI4t1+RnxIIt/V66NALjzfa3l/wVwSACV7/uKxRLwKucv+5IFoxR6ZEEVtg2EwbMsiOX+nh8DwvBKCq8oIv42SXQY4AsIlc+QexdunyfKBjgLeAU0CIMoeQOiEJF9hYtQcg5h77i0I0omk2xubrK6uqryDsLjXM5rMplg27bqQyy2C8dx1BiVeytMt4QRhQsfYZWCFMvOy+tFyvt1Z7o1TWNra4ulpSXlrU4mk3Q6HTX/3Lhxg3K5rAD6s2fPGI/H3Lx5k8VicSYVWTzh+Xye7373u7hukICeSCS4e/cuX3zxhVLAyPOYSqUolUoKgMl9EbA6HA559uwZnU6HbDZLv9/Htm3K5TKz2Uy1/JPnU1oDSrcF6b8sgVgiqxYftDyftVqNXC6n7C2bm5ssFgs110ciESaTCdvb2wDqOIQRTqfTnJycKAAmoE0k17PZjFarxXg8VhJky7JYW1tTyo3zBTUB9bFYTIEcUdGI/FiY7rW1NZLJJKPRiEKhoLIx5LgPDw/57LPPaLfbaJqmVAWWZalzljEhf49Go6RSKXUuYkOQOVNYY3mWpWDR7/fpdDpkMhna7TaffvqpelcKK+15npL+7+7uKtb4+vXrnJ6eqkT9ZDKpWGIB6PL7on4pFApqHhAlwGAwoNVq0Wq12N7eVq3GROlVrVZVT/lcLqfeQYlEgkqlgmmaTKdThsOhYvB/67d+C0D5qGVum81mCgQPh0M++OADfvSjH6kxLnYCKUo+efJEva+EMX/99dfJ5/O0Wi21xpDUevGhS8ifZBmMRiNms5nKI5AxLxYDkadvbGywtraG7wdJ7+12m6dPn6qe3QL+5d329ttvs7+/rywKojIrFAo0Gg1VMJO5+uu8pZpJKosqS0t1aq+BXoZkbULn1MG1IhjrNjc2Ybke2EBPPYg9hKU2VG4GeUyff2Hj/DjPYp5lYT8lqRkMf22E/1sBSDKmNk7CZH4vSeFTG88+YoFPhCkRTSNRtHFLQGISmHi1EkSKQWNo04LhDJ65LD6PkhtuM2CBVd2lbPr0PbDSQRC2Gw26iDGLkNZtFiPwx7CU9Kn0YWUBrTycFvJ4iyicNiGbBusUZklYvo6fNbCSEHeLLLFCLPoE84LF/KLBIqJzPLEZXs9BzYZ8B6qjwF+dLjJJV4nXj9gIsuiYzgwWRoaGNQtSuq3TABGNF2DE0LtDkjOwNy0M28WYzBi7LTxPw3FB8/rotsVQg0U0C+MMaBFIxwE30A8b8UBPPC8Hcup+Eloj6BZAT8NBDMYm2mKCnTjEv/JziD+ERYtRtUjLPeXWkkdiAUYPiMPUAN+OBl5xPQrpFBSnkPQhncZx0+jOgJjp0ddhMoWiEfQydzWoLCDfsTFPIDeBbO4BnZUP4GgZ7lcgOYOqAdox6CbaeIdI/y6W+zLkfKznNIxDcA5cqgVImoFs2koEDLetwWkcTA+SIyAD89ovigURHTIRSMxh0YfIHrX+/43/7EID+yEkbBgOYD6A6/ERvqsxrQXqjeMebNqQTkCpDK/0HWZ9aETgWqvD+8ZdBv95AvwiRDZgegy2DWYsiG9PVCCRhGEf44MPKP9f32VtZ4YehbLmk/ELLLQBcdui9wASbRsDh34Jqhmfb74yI+/D6Qj0FGQ3wVgGuwo7y7Cnw5OlBF42Cd0R6BrGKGC2p3lwgHILbo3hhWOoPQoy3KbrUCuC7sLkGx5eFrQDaP+5xvhJjI6bBPLUKDJBZzBa4Wd/7LN+copxP0J2ECNTmhN7VqYwf4MGh5wc3sF8Mv+V5pyvNOgWubKk6ErFXMCULP7gSyATlobLAiTMXAt4ENAuvTzDUmQBH+EFZDgM6rx3Nixplmq1BBSF5b3y8/Jn+HMgqLpLkJcspsKsbdhHG2Z1z7Pwck0EqAlTI2y3LI5/mW/2vDogDATD8vfzrO555lzk/GEGORaLKS+kSO/kfsk9lEXheT99+FqFw77CTK4c4y9j68Ms6fmCgRyDLCTDrKmEfYUZ9jCjFR4P8hnh6yifef5en2fEfxnYPs9ynwfR5738Mhakf3n4OKQIAJyRjoeTygWknlc1nFdBCJueTqdVaF+pVKJQKCivooCQcMChgG1RgYRTysNFHWHkzhdKwtdU7r/48sNeWbENfN1B96uvvkoqlWJ7e5uLFy8Si8XY2NhgZ2eHVqulwOJkMmF3d5cHDx4wHA7Z2NhgdXX1DFspTF632+Xb3/42ly5dUrJuz/MUSyaeXUl3FmvJcDhULbfC87Lsaz6fq17V6XRaPRNiD5C5SLznEigoBR7pGy5y3IODA+W1Nk1TMdnSpk56Ywsoms1m1Go1BX4PDw/VPhKJBLVaTbH+kuovXxJG1+12FTgrl8scHx+TyWQYDof0ej2Wl5eV5DmRSKiQLfiyTVO4k8VkMlHtwEzTVK3NRJUgXuS9vT3+4i/+QmUuiKx4e3ubRqOh5ifHcVThQe6DXBNN05TUXZ4ZKVAVCgXlv5dx0Gg0VGeFer1Oo9Hg4sWLOE7Q4kyCQj/99FMls7927ZoqrEirNLGG6XrQEkvAsLDPEr4nY0haXUm4nxTjms2mYu9931dzkLwDlpaW6PV6quA7HA5pNpsq/FSKBRKcJ2NNFBdyz9977z3+8i//Ut2jTCajFDvVahXXdXny5ImyRrRaLdbW1rh27RrFYlEVgvr9PplMRs2NYdWP2BDk3SHBa6KQkwR9mS+TySSlUgmAp0+fcnx8zGKxoFKpKBCfy+UYjUbM53Pi8TgPHjwgm81SqVTUeJHn7uTkRM3rX/ftm0mXpD1h+3mL9a1Azb3+qs/OU5PW8BJ+6wmz4YL5DCIPoNPSsLvgF33MrSDfLDOGhu/g+9sYTpxW7XO8H/jEtkEbgRfTwO1hPp5RHrjMY48xF1mqVCHdRNv2cA3Qhj6kkoFX2RqB5oCWw9/YprO2w3puSHLYYYFN2vMxZjDNQCIDkSSMtICQpedRmMB4CPmZz3MtSDyN0k3bZN7wScUNRuTQDx5g+AvsZQ9MH3JvousJih4UsIjSJZadM66BmXLJzTzGNZ1JahPMOIyeQuKzgG7Xa7jLSxz2NDIRn3FSxzHKYETxDMDy4eQz6LUhEYfESzjlnzE+njHLXEEfNYj0BkGU9shBH4CeHJMdQ6EPPXeAxQISJngzcG2IAUkXkoOgafLABK8VgOXxUhBhbXtoVgRN38er/N8xCh/izqJopxP0TYPepRiD+oxkK1B721HQsz6aNcbXFpjeAlsDUolAl51MgFXBMqNYjg/aAj0xZlZw0RJQXkApDdpTOG4a9HSPTHRMJ/MZ3HwZmttwsBL0tCoWof+E1KcfcmV6ytPFHYbXlrAzHosUFC9CahmmBdCKEDFA7wYS6sIUtEmAcetAYwy6DvGhxTRyH5aeQPYbsDhiyW6QS8JxBiaPA1zurkO2DVd9ny/sKB9GC6SrHbI9h1wCntdB34HxCMpjqAKHlRmDmBX0B88XwIsERRRcmM0gWQTDI/L+X7Lx33xO4ZnJoqqRTfk4Ax+j3GVp2cUzoPeFwUpjnR4uhmZTznfJ/j0L/SIsW78g6AcBQJ0U4MOixmk0imPGgiT71AxscGJRRvqY6NRn9RB+/RSqbVg8g2MdFnGY34NkJfBjaxMYfAQnHyRZdKNU/Bk5orSIkCTDiA4zWkQOtvmr4wq2kecFK8daYxeDCCZpHC7R6jewHuz/SnPOVxp0r62tsbq6qtiXRCKh/NICCOUFJynLApLCclQBJgI8xT8qzLWEn3W7XQaDgWI7JHBKfIqtVksBFVncC0sn/mZh3YWVCYNCAWVhsBQOrhJwISyx7Oc8iyo+dmEwpJKdzWZVoFQYgAsoFzm9XBPZt3h7ZQEQZogF9IZBvpyHgCpZOA2HQyUhB9TnyM/KfRPGVPYtDKgsXiX9XYoX8KWnWe6zeN1E2ixsp8hUZVEj+xbAKT1SAeWHm8/nTCYT4vG4CkaSBYnjOGpRK22IwtL/8+PsPHA/H2QmhQ9hsc5LpcNp5FIgCLPncFYlEb634YA/kTkC6h6J/FCutaSky+eGg+Vk/8I+ie9fCiaRSIRSqUQ6nT4D4sJ+UOk/Lp7WMNMdDmcLg2g5VmG6w5L2sFRdPKjiKZVxKgoQUSt8nbcXXniBbDbLtWvX1FwFAYu7urqqxlGz2aTdbjOfzzk6OuLg4IB8Pq8sHtPplEQiocCIyLTDVhTxeYsySDIwRFHwxRdfEI/HlZdV7lEikeDq1atYlkWr1VJy7GazyWw2UwxiMplUDKmomxzHodVqUalUaLfbRKNRlVjuui4nJyeqmCcMZzweZ3l5mfl8Ti6Xo1qtksvlODw8JJvNUigU1PWT/sXNZhPf9xV7ej77Qcav4ziqKFosFnEcR/WSPj09VcGQojySUDfJ+5hMJgDquog6SPy1lmWRy+UYDAY0m001tz9+/Jhms6kY0kqlQq/Xo1QqqU4K+XxetXM7Ojri4cOHqigmz5mkXosvWawhqVRKqYYA1cdaZO1SPNjb2yOTyXDhwgVarRZPnjyh2+0qkCzvWCl8SEHFtm1lRZBrLYVfyXyQHBN5v8izLhYtUSBVq1Vs21YFEAlTk77fcp3b7baaN0ulErdv36ZWq6niqMxFyWRSjePhcMhf//VfKxXY8vKyOm5pLSmFEXneRJVQqVTUtex0OmeKh1K8kIKJvF96vd4Z1tr3fVqtFr1eT11H2STVXoqYki0j76KTkxOVcyHXXwpmom7a3t5WRTPJ/vi6b8//5oLs9JSrvwbaMviRwEpd15dZYpOyv4emLzjtQP/9Is70Mvf0Yx71u1T2PSqOgTFb4LpHRFkiRRGr6tGvwEwHLarhuXHw5piRBU43RdnK4DEigouVttgvwtiC1bsug9iE4YqLHTcDat3RIVHGuVog1+5j99rELJ+SBs0WeFFIOjC3Ie/BtVOYPnXJz2CyDNO4RvehRq2foz1yqN7vs86E++VVPDeKf3IX3ZiTjD5jbDTxKq8Qif5fWN4YMG8NySz5WCtQyEH/0GCQLeMXlkH3gATESjB6D05/jI/OcbWKPpjjugZgB1S7ZYNVh+EYXA/iW+AW8IpRFq4Ba9t4Y4tFy4VYHlITFmkDIhrO2MHbA7Paw9Lbvwij84NeWsMEOB5MdZgmwB0G+9SzMBug6TP8tIFPFj/5iFj5IdreHM3Psrrco9/JMsi+wNPpXaLagGoFUjYsWz67szvMtr6BnUoFQWgjB5asIKGLYoDmmEKsh5fMMUt5aKMhY8ejYwRSdSPq4mUgF3cY2nfp/tq7QZr4vTIcbsGiBeM7eN0RozqY6S6m38eN+UwSkFsNQunGUXAdyEeBJLhNyPig+2DFIZYOguN6HjgJH00f4jsT0AxYJGjNY9QXC3QPIiuQWYGpCzML8hOIHjtEdJuLaYeUD7F6AE6Pp+AfgzeHz79ncHirBrVXQV8N2rRZLoztgG63vaDH+nCP2J/sktsDvzKnkvVJViH7LZdCBlILaB2CP4kSJUtB61JOOPhbHkdXIJKGrBew+cNREKB+TzNoOIWgeOOB5g4gNgfNID902Or4rNyB5TuBYv/xCHoLjeiWj1GG6DFwP0I3oTPrgD0q4TpVUujE6GKSZU6SLodU6JCjRwybhbvNMy9PE49TlgCLbXxi2IyIEzuIE6Qb/g/bvtKgO5/PUywWVSpyOHkbvmSZJ5OJAhSyeAfOtAoTuTKggENYji0+MGEiwn5Y3/dVZRvO+mdF6h1O7ZaXmYAfAdjCaobZXGE7pWIf7hceBm1hRlWAozDpch7iUw8zq/K7AlrEBynFgfNhVQJYBeyGQaEE5fwy2bLI+sVHFolEFLsZLjLI/kVmGWatwyEy5+XWYYYzLM2WhaFc7zCglcVOmC0N+8MFKIcTvCXYTb5k4X1e3h9WCpxXI5wHzOf96eF7Eb6/4f8L71+uQzhnIAzkz4fdyVdYGXDewy1MWNjPHt6n/F0KGdFolHw+rwCOhAIJ053NZs9cEylmDIdDlXMgjJgcS5jhD/v1JfxQijRwVl4PKGmtXG+5FjIWpPD2dd7W1tZU+yJhCiU8TJ4NYVqlyLK0tIRt24oBl6Cn8XisPjeRSKhnRZ5jAdKiopB2UbKwH41G3L17l/X1da5cuaLkzKZpsr6+zocffngmA0L6gcucp2maKvyJTDgajbKzs6OKMP1+X7VJqtVq6nxlbn/ppZeUpUXmxNlsRi6Xo1arnWkxCKhQwydPnuB5nmIORTosntter6fOv9VqKTuGMNfSa1kKHZ1OR3mFbdtWsmNJ95bfFYXGYrHg0aNHtNtt8vk8m5ub1Go1NT+IckBYXPHfd7tdjo6O1JyqaRr9fp9ms3mm9Va73VYFWpHnAwrghpVFMp+LFF3mmtPTU3Q96EhRLpcplUqqwNBoNFTmiswPohCTwt7q6qoCveGxJiFnEqAoygYpLuzt7anCRL/fZzweK+AJQUHx2bNnqoC6vr6uEtbr9Tq2bXP16lVu3ryJ53nq3SIFDbkmx8fHvP/++xwfH5PNZllfXz/zfh0MBkpFJEF26+vrLC0tsba2pvrdS7HT8zyWl5dVQKEUWCAoJOzs7LC/v6888qJGEYZ9PB6r9zQE81m73aZarap1kDDkMjZknpZwUXl3yVwp71dp8VYs/oqNaL9C2+o3oKJDpga9DNh9GN6HzEzDo80iYtM/AHZMhtMEbWwmxiqWv4TdneGTIMIRpUiHmX1IgxV0U8NIwMQDw/CJxhY4lk4yDp6XxvWvEmeHKDO6yTm9VBBS/t0OdB55PLwxZXDFomGauKk0ROLM1q6wbx2x5rpoKz7eBnT7oJmwMAKr84UJTE4gMgl6T7dzMPF1DnwXSxvjukWSJ2Oi2RlcHEItjT+8hDZssuLXeWy14YXvMM+W0RKHxGM+cQ/cKZzmksxqS1CKBWgvaYLhQmoDGGI8eR+8CW65hJtLQndC1BviJ3XseekXCWWLwOzc2oXJY2KLITnTpTV/gFd0IFKG1Q2IpqHjkTVOmU81nvlF3KUkDNsQaUNtASzANwPf+yIC2TksPYZpG7QclDbxYyvQMeFQh9QCP6KxEbUo2MdMrCjH45dgWMK27tOJBFh+kIfFEazs1Nm9+lO8m2vwdBsO21AdgHEaILvFgig9YvqCiZPAczTwfBYadA2Ir0GiCuNIUBjZpMNi8G+YrI5g9j04KMGkCPky81SajjbD0cCJZxjHHBKJCYUITGJBUF59AaNVWK6BoQdJ5T6QA1ZzQZo2FhCDUTwe/E9DA+saLesKtv8xWcun40FzBn0bsglIn8DGqUfhtIvuQEuHxAokt4IuZ/UOPCpEad66jXvz++BvBPaARR+MGGQzYGgQm8LxZ/D+FyQeJMGcs161iHV+8WPFIDsPNxAM5PIznMRD1nM2qZd9nr4G/RWwBvD5L2IN4h4sahonqSyenwRvBLpD3BuhLSC94/Ldx7C0D84dmOxqPFnEsL0UYDLuGHgJl4gzwJ9dpEmBMR3WKaITwwTGlDmii0ufAjOSzImSIEqb68Sp+FkeoHGExhoLktRxOSVPhyS/2vrxKw26pS2NLM7C8lFhBcOBO+LTDftJZSEBqAWiADjLshiPx8rPLYskWQwBigGwLItOp6MYolwux/LysnoxCtgLB7kJgAoz2mEpe1guK0BXFlhhNl3AjwB7YRwFkAjgEgApPXdlMSZAOMzwCisq+xegI0ykVNUF0IX91QJ+gTPAcDabKbZfAJ54LqWNjFwr8RwLIyYhdGE5NpwNbhMgKABtOp0CnJG2S5ElHMIUlpCH/c8ynoSBkP3I7wirLSnA5wsIsoXB6vnjlGsoYCWfz5NKpRQrJ4m4IoUOS23DYyMMuMXvuby8TCaTUWm1Mi7FOhGW70t/5U6no8a8tOI5X6CRhZuwKaVS6Qx7IgtjSXoPj3u5l6enp0wmE8WyiIxWnrFwqn+4+CLnK/dezlkWluGxcV5CLtdZGN6v+yZjU4pm9XodwzC4efMm3W4XXdep1+tKWdDtdhXbGZ4LEokEEIBtScaXZzqZTPLgwQPu3LmDaZrMZjOy2Szz+VzJZ4U939nZYTabkU6ngaAocPnyZQ4PD5V/W/a7tLR0Zv+WZSmlTq/X4/r16+zt7dHv91WwWbFYVEoYKZpJGvr+/v4ZSb2wwOfPWcaP4wTdEMRPPh6P1fsjnU4r/26pVGJ/fx/XdVW7s/MFo3Dhq1AoKDC6tLSEYRikUim63S6PHz/mwYMHOE7Qq1yk6O12+0wXhQsXLnDz5k3S6TQvvPAC169f5969e+zu7qpixNbWFj/+8Y9VAUXUOAL46/U6f/zHf8wf/MEfKG+wPIfyOzLXy3ws70Fd1xWwlOKVgHvXdWk0GuRyOTY2Nnj8+DHXrl1TSglJcwdUir2Els1mM1ZXV9W+BdTKtZYe88IEl8tlKpUKz549U89zo9FQ7wiZP+XeSRq/AOvl5WVu377N888/TyQSYTAYKBWZ/L5kFLz11lu8//771Go1kskkpmkyGAyU7FzY9PF4rI6rUqmwtLRENptVIWeFQoGlpSU2NzeVxUfUGDLfHR0dsbOzoxh5KYqIAkJaYiaTScbjMXt7e+TzearVqrJajMdjstmsGqMia5exK+8oUa6JNaNYLCqWW6waX+fNHEDmRtDByRnByRHoJ/AN/5RupInmL6jvgdVPY6EzoIlrV8k5PhkshiRJ8/8k70+DLEvPu170t4Y9z0PuvXPOrKypq7qrq7vV3ZJakmXLlsDC2AFx7iXwBRlHYIcQcA0RYENIYAxG1/7gUMAHc+CGwYRtzuGAsS/CFrJkWbasltRTdVd1jVmV87znee813Q+rn7feSrcB6UjnyGJFZGQNmXuv/a53vev9P//hyZOI1YEmUecs41GauDXE8sF1wUp6RG551L4G5tDnAQ5pVhiaDUbLe0TyUNgG9zXo3oZlE+YyLl8Otrm1YMK5x2A7Tf6BQTLts3cpzN6aZsNQ7YkZZorN3odsP2yJfb0ND2oGmS2Pcc/gnjFlJphQHJk06klo14l693GMZ/GtAovNffamGwx6r+JYPUZJKM1CZwz3WzZuzsKih+d2wUqD70AnCZ0A8k/g2eeh/0ZoPva7kDGYTvJgBVDKENs6xPR6jJIprM1D0pMxnhtQDKDDHmP7WbBTYeR0YRFSQ2qpE7qVgEOykPKg1YDUXYjdCqnftSzEu7DfITLZIxPcJmGNGVsm7dJ5vPPvhe0F8J+GySWmzfcwyn6efKHH/cE7cVOPUXrt1ymYXTbzBke5AN8xoRtlqe1wZv1FHszF8Z0fhsM49ByIdDC6+1iOC6OwzXZ0MqIXBScXyqILLZjG4N6cycANqA4DFnw4t7vPuv1Z+rMZGKXhfgGG5wiil5i7+PuMExG6ucdheEIxuEvED3Fm2gA3B5sYdIYG0bkAZxTg9aEbC2XnzgQGlkk9sUgQez90KmEa+qSGE/9uvjZc5/loG2sDJo0w8yzYN5gODVKGT78HPTdGJu3hrbm8HImyN83SfCHF5Jl3wJUPgV2B7gRiHkQDsKyQYh8EMNnE/L3/wsJ/DFgcFEhHjolsQScGyV2w1g2sUkA2Cn0LYs9AYWFKtgQb8/BmPkbXM3DTJsNCkWAmgrE0CoslxMNo8qgL/oSxb7O46/KOO1C5Ac07UN+KMnKSuOSIk2AMeG6BVC/ClPs8YIBHlTIr2HRp0qGHTRYXmzZVo0U24jJJdkm7JpNBHD/YJ0+cCDNUGXORPdL2bVLxMamcj1MN4NVvYM355i1f/9cf+Xxe+ZB0FlGX1uogTPeI6mBbZ9MEyAjY03uVyoNPr0pLiJYASgGSEMrWBHTrX3IeOvOoS7kF1MohzKD8v7AfeqEBHvqVhWHXmXL5vCKDFhZGApJOj43eckpnm+Xzyfno4UjS4goeAlMZWwHuo9Hoj0iMJZhHgKQE1AmQBxR79Has62n/u24tEPZF/xn5f5kX8tn0sZKig7yesGnCLOiycAGwMuZSMNHVB3Ju+nfxTQoYlIwCYYeTyaTaEOtFB10FofvE5bUymYyS0+ZyOWZmZtS9IoBbD4OTIDNdVi7XWQ8h01l3sXRI4M7bgW6xMcicl3ktgYQiSxU2R1QpMnfkXpMvfT7J2EuBTTaJpxN39fwBYa2kYPZ2PvnvpEOsGoPBgMPDQ+7fv4/neaysrFAqlRiNRty7d0+B1mq1Sr1eV6AjmUw+wsJJMJqsG3KdNzc32d3dVfN0dnZWMZPHx8dcu3aNo6Mj+v0+CwsLtFotKpWK2tRvbW1RLBaZTqfMzs6q1koCjnO5HIeHh8rzbds2R0dH7O/vqzm5srKi/l+utwCco6MjPC/sxy3hiPPz86pwNBqN2N3dVeDn5OSEJ554gkQigeM4ZLNZVWAT4JvJZB5p6yQtqKSoJGoA8XcD6p4qFArYts3MzIxiSEUKLL3IJcX69u3bGEaYbC5p4q+//jr7+/tkMhm2t7e5ePEiV69epVAo0Ol0SKfTbG1tqfT0SCSi/Nq1Wo3NzU3OnTvH3t4et2/f5n3ve58CfDpIl2fnycmJAtgyF2ZmZlSone+Hval3d3eVGkGUAY899phKVRfGWD6HrFeSyyJFcFn3RdUF4bN0YWFBsfny7Dt37hyO4yh/tgQtyjraarWUF9+ywoT0SqXC2toaMzMzzM3NKWAugWWyzosaxHVd3nzzTRYWFlSLzmazqdRY4tcPgoCjoyNWV1c5c+YMpmmqIoHci6ZpUigUyGQyak4J259MJjk8POTBgwcKTDebTTWeMifk3pPnWz6fV1aPTqej5ov4zBOJBJVKhclkoogF2StNJhMqlYpSYYgM/4/LEflOO4K3kquHY+h9Ho43wo5dK+c6lEowAu5dNzgJYpRwWGFEjxTRIIKJRZskSWy8cQIzGJI1tojZfQ4mIRNpx2FsQWoTrFcNxm6UPofkmaVnJBhZBvnjAOf34ParSRrVIc9GIdqCYAaIFQCT3PYNFu0pw8vQXYPWEKZv2ZudEmSy4E8gGYVGFranBtaRQX4/oJkKcCYm84PHSE03INXACtosBAP2CwnG5auY916kEr/DRjPNnufTSaaYWx0ScQLcnM/5UY/OLhxacXKxN2md/Br++f8nWAVwOpDNgV+ASD6UepsuZOwwsSsYYkRdMhMHJ7KH77qMOwFBEpoeOEkLyikggNFdmKxCoUDLNklWXCKdXZxIBnLRkLnuJsP0LCcDkymR/h+wNnhAzgjoDUyyfg7r4B7O8X0GiVmmhW0ILoPxNLu5ArvxOtgFOLqBnTgm2shRCybYMwM2h7P4sVWayZd5PDOmO32FY+MZaL4P2haUegSORzAKcIYmHgEJL5xHlmtgDQPsCfTicDiToDgac8b3CExItGFt94j7qU/TP5ODwtNwrUKQuspk8WVGbgxiC9j7B0xHYUFlasCRDa1UgmnMZuTEwIiQiRyTiXnUUxD4YADHpRzu/Ieg/R5YTwFWyEKnn2ar8D5y0d/mzNQhuwXxHUjZBqnHfdodaG1DpDChVzFYj83TLr8H3vE0zMVhbgGSNei3w15mwQB8N9SCD1tADNwyqa9NuFrPkLKP8IsTGgmwVsFvQesm1OoQJOD+PNxegvQ5MAyTrcwi41gVcMOb0YpA1iXIjsAbgO1B34eJAUmbyKHLxbsw/wC2HkDr0ASniI9NliETXAJy5BjjcIxJihI+ER7gc4YjAiIMSFPBok3VqJMod6gs+kyiEJ34+Ht9vKCPMRiwNnwBhwxnTIdoZUC2BoEVqhi+keNPNOiWhGp5mHqepyr6gGLkdHku8LbADVAgSwds4gsVb5wAOD14Sh5meoskXf58Wt4rDz15T10urHu6AXXOOjgXsCTnq/uF9aAfwwjbv/R6PTzPUyyFSAiDIFBMqvy+jI08nEViKIUEPYhNNml6/2xdBi1sschNxf8Wj8eV11PYYSloiLRP5I7yGgLydaCqy8IF5OlFF/Gd9/v9R3yYAvbFKqC3ktMLKjrQlOvZarXUxk4KAiLplLkj112XcuuvqUviT3u5hc0RP7oAVmkNJFYKHXRLgUbmu/SWn5ubI51Oq3RdsUzoQXBSCJGNtsjo9cKQ7lMXUJ1KpZS1I5fL/ZEEZt3jL+8lhRa5l0ThIP19ZcN/ugiiS/L1L/2cTrPY+uZd7ikpeukWlO/kQ5KnNzY2ePDgAcfHx9i2zerqKuVymbt376rgKcdxqNVqHB8fq3klDJiMbTKZpN1us7+/z9mzZxXTJj5nuXclOXtnZ4ff/d3fVe2h5BrKfSkAXq6PsHTtdlsVSa9cuUIqleL4+Fil69+9e1fdf8LaZ7NZYrGYai82NzdHt9slGo3S6XRU27P3v//9NJtNJpOJYn3X19c5OTlRtojRaEQ0GuXZZ59V6exyjgLERaIun7ff79NsNsnlcup+sm2ber2u+j8LOByPx5TLZcUqird8bm6OXC6H7/usrKywsbHBSy+9RDKZ5MGDBwRBwIULF9jf31ep1K+//jo3btwgn89jWRb5fF4x0slkkm63qzzFi4uLnDlzhs9//vMKXN2/f5/3v//9GEboRxaPti5blgKtPBMty1Jjm81mVQr4wcGBKmpcvXqVfD5PpVJRIXnC1gtoFNuD3I+SHyB/l7R4sRTVajX1HJHOBIVCgbW1NbUOyDNSVA+Hh4f0ej2q1SpPP/00jz/+OMvLy4+sA47jKAZZVAZSYAmCgL29PQaDAYuLi0SjUXq9Hrlcjnw+T71eV8/yXq/HzMwMS0tLyn9eKBQeKWKJbUMsbsJwC6u+ublJv9/n5OSEXq+nCjGnrTNShJQQWZlrUnCv1WoMBgNKpRLJZPIR1lpySWS/JCoNUYEAjyi7vpOP4X2IPAYbt+DBb5scDwLsasDKuyH7NKzfhdhuQNDt4XoGs7jcsXs0Ynn6Qw+CKTlmiLNI4pnbJJM3cMYBkT3IrIGbAqMPhW7YWrqDSQWTy9i4Xo3dl8p4Bw16RxDpW5gzIannTGFoWpDKwmSPvLcLBUhlYPYAdjqQdcJ8su4VSCfDxOdJDA7qkLkG+UnAdB4KT0Lq1SQ5I0ZqsceZ1THHyT4zszDu3WQ/doH6QYSCu8OG+310n/0HdFeGHMZ+i5nGy5Qsl9h6qKquJMas2bAz+jKb0Si84/thdBh6rLMJTH+bIA6BmwUngNgQ2x6TqvnE+mA2Tdz8DM64S7U1Iu9C/3jIoPB6yJw6HThyYVKiVUrgFnrYSQcnmwanBu1ZIBd6uf0VMB9QMD/NTCLgZtsk0o9z0T2D2z9hkt6mML+OY2zhehm8YpGeMcsoMYfh/QFp/y6NOQ/XHVIwLOrVPL75Xti4Svtsn8nqNSr9NidHbxCM3w/XZ4hccsgkfOiDG/GJAZkhFGzojwOGEzDjkLah0B2yFg1I5aA9AaML1gGUvR3GnX+H+/gRLLwHhmtsROfxklOYtkhO90PBQByGWdg2U0ztWTC7IQAdxpnYFjOmR3cfugOwJjAd2VA1IBYBMwnYIcLrF/Aqf4bXKzbb8S9QKLZZPhtQTPocjW3WIxl2iDGezeK/4yL+8vdB4gKUI5CzwybYbgCJPIzb4dhnq2+1tzMBE3ZvUOpNyFRbRG2fXhpSFyFWhukd8K0ALGitwe5lOFzOESRKYOYI8jWIAtYYEiaMXOi74LhAEKYV+l2I+1gjOLc15UwHmnvQ2wNrYJJkgkkLw/IIvFl8Yri4dEjhUWKZIbH0NQ4GHpPgMkWOqXHAwOhRXG2TOh8QSwJNIAXZfNgRwG8MGX5thONlSSW6BEkYeUAH2q1vbM35Ew+6BUCIpE/AgmEYj4RHnQbd8BDQwkOABQ9Bt7De4g2UB5QOivXqvL45lQf4aem3bAp0Vvk0OJFNrw7I9f/XQbA8GOW85BwEoIlUT6ThAgblQS6VfdlUyv8LqBVvoQA7HXTLZn00Gqnxls9qGIbaAMiGWICkMK0C8IRpFXkxoACVXD/9Osp56MBJQop0VYBIp0W6rKsTTvuWdWm4XBe5NjK/RBVg27bqOy2gU35P5qBIHHVwqG+adKAhoFvAbDqdJpPJqAA+kQdLWJlszIWll2Af8UzWajXFdKdSKXWeMkf1wo4AhMFgoLIPZO6eLkKIhFt6bUvbukKhoProymfR54hunej3+4pVHwwG9Ho9Fd4j81oAnF7A0NlAeX2ZE7r3V7eayGeQsRL1i37ffycfe3t7PPfcc1iWxY0bNxQLJ72WdYtKq9V6RMIqthkZ62q1yvb2Nt1ul2vXrvHud7+bIAhUQU/YXct62A1ieXlZtS0SifJ4PCaRSKj7RNaBbrdLtVrl4OBABW8lk8lHlCeHh4dsbGwQj8dVOOTs7KyaP6KOqdVq6jXr9TrtdlsBzO///u/H8zzVO1nk6ALKm80m/X6f9fV1zp49q5jYaDTKjRs3cByHubk5tbYL8BYQGI1G2dnZUWu1SJuFHZUWfBICKqnuYsMQhYAwqlLIlcKqKK7m5ubU/SDAqtFocHR0pJKsY7GYkjg//fTTqn/5uXPnVMHh6OiI+/fvc+7cOe7evUsQBHS7XWWZkfWx1+sRBIFq8SX+crGOyDXodDqqt7qAZCl41et1LMtS0vTBYKCuo4yn2KB8P+w2cvv2bcbjMXt7e1QqFSXNd11XrQlLS0vk83k2NjZYWlpS4W3VapUrV66oMSoUCqyurhIEARsbG0qJJqnnEsIn42LbNi+99BIvvvgiTz/9NNPplHa7rRhweVZJYS+bzTI7O8vMzIwqtEjBUFLW5UvUURIiJ1YPkev3ej2VveC6LqVSiXq9DoTPxm63S6lUUnNX+rZLt5VkMqkUBNI6VIC2qLNEpQFhfoHkahQKBaVA+04/9m5HefZdU6wW3NjNceQHrARtBg2Ie6EP1fDAtIc0vQgjDBzbxM9E8Cd9Zl2PLFHsiEs1B9tHKbp3lzEWb5N6wWPPB7phcNWxG8MgRxITjyMM2qy2a3TbPjvRJjF8ss0ITtshtwwpNwBnBJEZTqZp2v0BSzE4uWuR3koRK/Xw1gJsLyQI7RzU78JoG2aOIROFm2kLf94kuzOkO/uHdK+OeTN9Bqe6Smb0Od55uM+v17/ClhNhdcfFXj/Afe7PgRHDjww5GW1Sah3iNiFvhG2Xug1wBxPM9fv4Zw/DXlvpCEQr8OYJhmMRzC2Ba4DZIREbkk+BG7GZei8AZXKb/5l8PxzbXM9lOG4S+BloBtA+hEGLYH4M8+B0I5DMwkk0NDlPnLBZejkJMZ9EfEzUgOYkT2oyYdS/RyM7pl9JEYkFXPKHnPWbRDJNbo3u80qjBiUXFxs/lqZzzqdZWSS48i547XGIpBhdqfJgbHPGcCmmXqLh3YfGJfzuKikaDHsGw0yWkWtgTLrkXZ9eH6a+gZMIwINpPca9vMdR1MFxID8NSeJYK+DCcJOd7G/TLZbAnMd1z0BiF7N+n6o1IZKDPReOBgbjjA2xTuhVMDwMax/bc/B9yIxhcg2s4zjmyhh/pgPFadi02vFC078Tg+ZZ/NJforFSobX0Bxw3erxxkqWZfhZv9Syko6E5PJOH6PmQOnfvgVkCJx4ay6NWmAxfLoOVDCs/SRvj5c9z4Xd+iXdf6tO2oFGH4BCCDZi+acB+krg3wb3k0nkWWstR/PIylNbCfADfASKQNMFwwn8zfUgAngmuAwkXTJ/kwYTHhmF3vf0+JAIYWi6uO6aETT1wABcLm10sfGYwjSPc2i0SvkOtn8Ciix/bJ2lOSRkGiYWAxAwYBsTM8HTMVOht5wjir24R90pkEj6dNky7kLcg0rII9Qhf3/EnHnTLJltnauGh/Fcq6rqsW2SqOggS1lEPixGwIAygADPdRyy/I6BJ70GtP2R1pk6XQesBWLq0/bQsWf5fzl1n9HWwLn5pYVBlYyJgWvd1iyRezkH3qwswkT/rfXClKKB/fngYPiYbKF1hoH/JWAmjpKsA5H119v80KynjLQUN+ZJEY7luUigQ0C0MrG4jOF1wkC/5fPJZdJm8fH79d0+/jsxBAYc686u/h2y2s9msAtoCXvQxFAAi81mXxkvRQ5heSfTXgbZcF9lIj0Yjer2ekv1KP3C5PuKFlvPQJZ8CuqVdjny+03Ndt2lI6riAbVEaiNpAz14QkCzzSa6zgAzZKJ62GMihB9HJvJTrKT/7rWgZ9slPfpJf//Vf5/bt2yQSCd797nfzcz/3c1y4cEH9zPvf/36++MUvPvJ7P/7jP86/+Bf/Qv19e3ubj370o3zhC18gnU7zkY98hE9+8pPq8/yPHvfv3+f69euq+CLFFJkD+XxeeWB1ECuHtHczDIONjQ2CIOxXf3x8TKfTUeMs6ox8Pq8KWiLJjkajLC8vqyKgMKzZbFYVwpaXl7l3794jigdJhJY1W0K3JJm53+8zMzPDmTNnFEsoTO/GxoZKkW42mywvL3P//n2uXbuGYRh8+MMfJplMkslkFFuohw9K72tZR6UVl/Tcnpubw/f9R1QB/X6fYrFIPp8HHj5TYrEYvV7vkeeG53kK2AowKpVKnD17luFwqFpC5fN5MpmMOtdKpUK9XqdcLqufFb+vMMTymk8//bQ6r4WFBbLZLMlkkvX1dYbDIXt7ewBks1n+y3/5L/zoj/4otVqNvb09lQsBKP+zPJNE1RKLxTg8PCQIAuVb3tzcVIVuYYPFRzwcDhU7L2uB5LHIOIvkWgLHZOylF7sEWUpxDVDFZNMMW6RNp1POnTunFASSFq4nkbuuq1Q58hnlWomNp9vtcufOHf7wD/+QhYUFut0utVpN3TMi75exWVtbI5/PMzs7q+4b13VVYUI88+LHFjm4KMmkOASocElRYEUiERUuJwVgAfGmaar8A9/3WVpaUgomCWmT8DopfIpf3fM8dT/Cw0wDsReJ5/ybeXzbrZHHHjf+EGbOQWphzGB7Aa8ZwX2xgT/2KTbCts+Bb5MhS5QUs+MaxolNzDOoUCDKGGeUYv13L9Hyl0gFOcYb98h3PHImNCyoJ2xsf5EMNeL0GUb3yM038Y6jxAZZ5qbncYhTjN8ma0MHCLJ+CLrNGYZLCwxzJ0ybPoORjxsZEykHuCWIOWGwdrIdtoQKWgUSxpRGckinfB7vjE0l9iaDkcPNeIFR/nGszRbT1yC4a2JduYV72cXYhUuf/wz3TBit/V1wa/jpGC0nxkxsQqYADQNSQAYwBwb+ZATJPYzxDQIviz//DnBnYL4E3j4c36LnW4wmcay+B6UcJFfAzeImhhzEIJuEVG9C31+GYELK3wRvzKAbp52JEKQzYap5vgzFs3A4hG4LYlOIFhh486TidYqGTeOpi7xychcvXiFYu4Az2qV38DqDKOz0DLZiMfyMD+kFRk+vgpvGP/GhuAS7JdhJweJtTG7S2gvwJnA1dcIfNH+Daf7H8QbP4dq3MC0XN30JiHA0usbxdEgQxEgbIzby0IkWGMeWiRxuE/cbnFSj1LMuS5s+yUjY2pq+A/PbYRs0u4QxvEe5sUXaDOg6cDCEbtbGiPYJJkaYyp6xwZsw6Vjs2xa2ZZNqGRTHAYmRSW+zFibokQA7CgkjZIw7fXBsWPnT+Ll3040mIJ2FbCHsOzZsgNuHcRJsB2IuWNkQaONDfwiBGUaltx1o16Fbx9z5Amu/+h95b6fHjctxXruU59ziMeff9Dn+skF2lGYcNTl8ZoDzLjgsJmjUVqC4ClMTjAnkkxCdwtQNE9QmQ7AHEPFD774xBM/Cqo853/ZYdKC/E4a/TwcxXN8ggkmfJAZjMPv0fIMEKUr0GcfXqaTGsJPHZ8qifY0gP2JiQtoMW8jHciGA9zLgnISii0QSXA+y0QMCt0kw8XC9MMhuEIVxEOF/OtAtskEBjvohACedTiuJm4AJXSYuYFMqwAJOBMiIdE42YTr7Bg9BaSqVIpPJkM1m1UbqtExZB7P6BkyO07JzAaHCRuv+a13yK8BOwJWwydI6TNJ/xVsnCeTCiEshQOTe+rmKT1FCyeR39CKFAB85L33zKiBOwLXI5WQjJWyXXiSQcdWZZgHeMpZ6gUPfgOg9pYWFk81/NpslHo8rsHXaF60Da73ookuadXvBaVm6bLT0ayggUTzvUozR30da1EnPWJFPymcSkCIBN8J6CYCS4oIUWJaXl1UfYL0AIsnI3W6Xk5MTut0uu7u7j3iqZfx1ubD4pdPpNIVCQbXKETZH5qFeOJGxkuLHcDhUbfd05YgoHEajkRpDffxlXsv7y59lYyn3ku71lnkkX/q10t9HJJ7frOOLX/wiH/vYx3j22WdxXZe///f/Ph/84Ae5efPmIxvYv/pX/yo/8zM/o/4u96mM+4c//GFqtRpf/vKXOTg44C//5b9MJBLhn/7Tf/p1nY9pmjx48ADLsnj3u9+t1i9hmw3DYG5uDsuyaDabSrUwGo0UYxaJRCgUCsovKp7dRqNBuVzm6OiIa9euKUZNChoCAiORCHNzczSbTc6fP8/s7KwCctLOUdp2ScCjrKOiumg2mwRBmLQuPmzxJ0+nU7rdLrdv38bzPCWBl9cYj8cUCgUKhQLxeJwXX3yRSqXC4uIiuVxOAe9+v6/8xplMBsMw6HQ66nML2BcG3vf9R8B6t9tlb28P27aZm5vj9u3b5HI5LMvi9u3brK2tqSA63/dpNBpks1n1M4lEgp2dHZX4L372arWqwrBqtRrz8/MMBgMSiQSdTkf9vMjd5f6TAoH0TJf5PhqNOD4+VvejML03btzg7Nmz7OzsqIR2y7KUb10KbCKJ/8pXvqLatxmGwfz8PJVKRdmC5Bkoa8Pm5iaAKlzrCdq+71MoFDBNU9nF4KGPu9PpcObMGS5cuKCuo4BGWSv0cDdZkyQcst1uP+LXFwZegLOAe9u2aTab+L7P5uYmL774IrVajZs3b/L000/z/PPP89JLL6kxEen+hQsXWFtbU9dTnoFi85Kfl7VL1mw9HFUyLvr9vlKdiHpM5o2sbaIQSKfTmKZJvV5XaeNyzwVBQKfTUUogufZSDJN2eqJoE2IhlUop+4/ekuybdXzbrZFFjwcHYM7Cu86PmBx38MYZxvUO8a9NMeIwdx7MhEtjr0uyOeap7pSuk6GLSUADgxJJLuJ70KGHQ4N0LyDdCDtqRY7Bf9nE7M7QJUERn6lbYuA1sb0oNhGW7WOOCwH575lgnIXDEXhTH2PcJGgPoTbDQc1m7s4Uq2uQOT8lU4SjIQRjiB0Dd6BlGdgUSBBjfeY+Xq0IU4Nu12Zyw8FgSDn1exhbI/pdMCdxVg861M5DvJgidyvO1P0cdz70PoKzJcilcDNFNpwBjX6X6R7Mt6CYgITRoNd+A8O/Q7q9x9CL4ad6BHEfkhHw+5AwMC1wjSR+d0B6/3MM7W06KyVGt/p48QEJM2B0Jw5nliGxSaQPvg80EgTZMuTiYC7ApQT429AuQi8NwxFkSrQji8TnX2dxMKSRWMB9sgYdB+wCEecW1Qr0s3DLLTKOz4PZCn3DC/PgWuF/ttfgcBpWMLJtSieHFIceuy2YmwTU+BrbnReg/xxO5NOs5LbptA6ZWjbFyYis7xLNuEQjcK+UZJyaw/zKCeWtNtUSBJZDew4aFWhkDPpWhkl6HuINsFbAOENi84vM4dJ24GAceoatpEPgWwR+HPIBWEmCcRnP6uORZVqaZ3xpj0G9wWTxKniXYFyETAwiccB7yyPtvIUwc3BUCk3Jlg3jHkS6MG1DzApDCJp1mKuCUYbNA5iLhj3PR2OwG7DrgT/GPP5tzvwfn+a9d9Jcixi8cv6d+M8/yfZL/4Gi+YAgHtDM9umcDai/A1rn4jjZc5CdDZPnjQgkh6FSYjyGYBpWI2KTEO2OXHDDnuzmdMJsa8paH8xdaO7DsGNi+HmiDEkwok8Uw89hk2BKnyxjSrQYMqC+lSDnFCjSIRIfY1dCL3xn28S8A5GEz9SB4RCyEfAD2O+BtQ+24RLMuIziMBmFmX6DnsWQBP/TtQwToCxVYwF+eksvkXYJ8BFZm+4b1dtgCcCVB6XIyATI6WBdlyCfZrpFlinASTYZArLgoYdcXk+XHev/poNueaALu633tJZKtjywdeAifkRdWiuyQBkrnSU+XcTQP7MuP5fPoBcA9IKCaZoK3Mh5Scsw2YhIOzM5JxkbXZqtKwT+OPWAgD1dhi5jpzPRcugs6el/P31dpAgh32UcZa4ICBaJqWy6hH2S+aEHfQmjq3tRdV+yDiR1C4Je6ICHieYC6k8XDeR6CgvZ6XRoNBpK+ivMp14s0IsgelFJNntyP51WYkhBQhgtnVkXOf/b+ehPA2ddrivnIZ9frsnpAofc3zLnZYOrz8fT99o38/jMZz7zyN//zb/5N1QqFV555RXe9773qX9PJpPUarW3fY3Pfvaz3Lx5k8997nNUq1WuXr3KP/7H/5if/Mmf5Kd/+qcfCSuUQ4opcnS7XQDFjkrLpvPnz7O+vk69XscwDMbjMdVqlXe9612K3ZP18+joiK2tLRX+JdJi8Vevr6+zvLzM9evXuXPnjvJQix+40+lQKpUYj8csLy/zwgsvcOHCBVV0EZvDdDolHo9z5swZ1tfXSSQSdLtd1ZdbioNbW1vs7+/z2GOP0el0uHTpEqlUihs3brCxsUE+n2d/f1/Ni263SywWU/NQwOVwOOQ3fuM3+NjHPkY8HqfRaCjWWE/NloKrKJ06nY5KiS6Xy4qxjEajiqGUdlXnz59XAW66isDzPDWXO50O3W5XFTReffVVDg4OeO6553juueeUj7pcLrOxsaEKYrlcTrHGUjyaTCYsLy8/EpIlcn8pjoqHX56NpmkqtVOlUuH111/nqaeeUgoEnf0VCbPYAgwjbBEmoKxer2PbNisrK2qcZV2U1HMJjBMftozX4uKistHI80nUMNlslj/1p/6UUu8sLCyoDAL9Hs7lcgp4A8qXLCoNvdAthXcZB1lrxXolrbneeOMNPM9ja2tLfdaZmRnW1tZ44403VDjZ4uKiGmMpesjzTLqnwEMSQACwKNZE3SHKI8mQGY1GKthN5qQof2ZmZh6x1QwGA6VCGgwGSnFycHBAEARsb28rFUG/38eyLOU/l7GQtVIICVFjfLOPb7s1sgSVd4dtlOI5OH+xzvq1FHV3GaOxxTg1pfo+uPBDcN93iDUc0hsDePOIo5uwfWIzmlRx/WUCpuSoMWKOSKPK4PYu7WWIXofkSzFGrs3U6OIGAyZ+Fmd7lRJpRpk94h9qcfKsweZjUW40A4Zdj5FlEAQ2TJsQL7P/WI1L29skvhKh25iQjsLUh7gD6SZs7Zjsj1M8RoFG7JjO0z5m6h7RGxOiLwcsHK1hJPeIlTtMm3G6aYNYpUPeAtuFQdYlsr1I8dYdIsZ/ZHru/w2Jx6D+KqO1GUbDHSKjNpNqQNyCiNGB0SZG0GU8tDC7UxY2tznOdxmVKzCeAXseIiPMToeAKPF+H9t5nfb5xxlXrpA9fpWhP6WVng/bTnk92nYSMzLE7HTwuwYU1sBLQfc3YNCF2Ich+XwI3CJj3Ow8G14SRgHmZhS/WAgTzrt7pL09Wg6s1xcZLz8XthwLmiGq77TDwav2YXoWIrMQuQvRHsYoIAFsOSEur11qc7T/JSa9p2nH34mZ32Z+tEk3gKt2ADthhlysAA/cFBhZUkf3iCY96jGo7QVETdhbjeD4KawB5Ly7jMb7TGPPhwFx7T4nUWgGJuPCWyHPfZNgMQ8pM0zMS7wzlHb334SBB5lZ/O8/w9CZhfFFcOdhHAGTMDne88H2oZgL079tI/w/dxTGoicciBhgvoULrAAiURi6YE7AfstTbRgw6EEwAr9DbPOzLP7hH3D+ls22H3C36OInIlC+Smctxebrn2LxsRYHKwHeIgwwcawsxGNg5sPggpgTstlTG0iDdQLmEMwpTMfgEF6niUN1MOHqGMpNGDyA3r7BaJiigEtgjOgHJjGieMQxmKFKFJMjovSxRjkG5IgTJYHNoGqQXwsY3jM46M3h9ypsH90nExnidxMM8lMsc0pvYFPGw014TAsh+e/2Q6uI50bwyQJfv7H7TzTolup+Op1WG3ipFssGPZ1Oq1YawpBJK5RWq8V4PKbRaChAIhKwZrOpgLm0UDqdFK0zmdIOpFgsqnRSAd7y0C+Xy8RiMSUH1AG1zlyelsr7vq82QQJ8RQau++Bk03BycqJ8iJI4LAy1BKuJxFzS0PVE59Pya/1LB8KyOT0NxHXJtch6ZcMl7JD8jPgX8/m8+ozy2UVWrQNOkSGflpzL+wujrP+MbE5lXOXn5dCBonw2OXRPqQTA6Z7l0w/zSCRCNptVzLqwQxIip7eGkc+q/6wEIp0G3adbhekFED2oRzatujpApOPtdptOp8PJyQlbW1t0Oh0lM5UNr75xlLkTjUapVCoqBV3YN7neUijRVQCAko4LwGi328rTKhLz063aZFzl/aWQIIy33PfCTgojLyBJrpMUuYRtk2KEnvyuq0y+FUen0wH4I/1uf/VXf5Vf+ZVfoVar8QM/8AN84hOfUEzOiy++yBNPPEG1WlU//6EPfYiPfvSjvPnmmzz11FN/5H0++clP8o/+0T/6I/8uydsCakSFYxhhv2aR66fTaZXm3Wg06HQ6SlUxHA6VtLxcLqui3+uvv878/LxqPSaFHgm6EjAYj8dZXl7m+eefVwFOs7OzKuRN1rKLFy9yeHiowqekGCVr0+HhoZoTwshJsUtAYrPZJBqNqh7Sk8lEjX00GmV7e5toNEq/3+f+/ftUq1WGw6FSBZVKJcU6yrhIurmkYAuI1xlFKTRkMhn29vZwXVcx22Lhkc4EkUhEnfP+/r5ad27dusVwOKRQKLC4uMjS0hKe57GwsMDrr7+u5q4UNeU+6ff7PP7445RKJU5OTlThqdvtksvl6PV63Llzh6efflqpCAqFAs1mk5mZGYIgUOzmvXv3OHv2LHfu3CESiajP2+v1HrEpyfk1m00cx1FtDiW8TIDx+vq6ehbLui/rlRSBy+WyUtQsLi6q57IUMFZXV6nVamqN061IcsgzS669KGvk36SriEi5Dw4O1Os1Gg31TJC2epIA3u12abVadLtdPvvZz+J5HrOzsxQKBZaWltS5x+Nx8vm8KrAKeBXbQ6/XAx4+o2TdlOevrOfSPlNsGPp6p3fxsG2bfD5PLBZTifyWZT3CVMvYR6PRR1rdidJC9hQSgiiBid1u948UQb+Vx//ta+QoQuaMQ+otbJuN+aRftzCCJVq0iE/G2MM+VgoylTB0bXwRck8GrNwA68sOwwf7bBw6BP4CJSzqGHitGu7vHZBd9ggaYHXj9PExbZekEyVDHIcBk/gGxpN97j4Fm+9K4WRLEEtAzYfhBKwFMHrgugwuXuD1nSZnN/oUIyFWiUbhrAFpH45MiAYRbNoMCifkUi7Z8TFxD8bDGMMgRvMtsjLPBDcaMChCvARtwKtN6NxfJ25PyfTv0Di+C7Mz4XkkAkjm8UtTmAzotmBkpyCdxE+WCEYumdYIWuCbFkwzYQuwSBqfGRiMIGLTzJgU9nok3A1Ga2v0EzUGo3YIvhJdSC9BpE3g3Q/lx/s58CJg3MK8dR2GLv7qAqQXobMEKR8ya2wfZlkw6xjGFCwLg1sEVoo+Udb7BsPHn4XSDJxsQSQLbhS6B5BzQx/x/gy4z0HJghnoWkkqrS5LpbALmpuGdPUVJsd3ceefY8v8bVKRHv1WlDumR9z3KA6hkgT6NiyWiS9aJE/geAoLBZimbJxiFrvVIxp1WQwCvPtj7nZ+h8D0SaW6NCybsR+HyAR8CxJ+mOw+ugTdZyF5GdJTSOQgvQFOAhbeAeOzcBANPdCmHeqjY2YIXG0gFoR9wlIJiKfBG0MwDH3iQRQiERiNwDTC/usHBzBvQK4NzaO3fNceTDwSh5/m3cdfJr3t0ohNaWcGRNsGmc/8Pn3PJJhdwS3azFyFVhm2JhbDRA7y2TB4IFMArw+jKQRxGDSg3wvPx7TC87XjQATGBmm3y5MBXAlg1ILGMSQGBlnAZgJ4uKSIkwEyDEgRISBHlJg5oW5E8L0MFg7TaJdU3GewBeubKXrM4FHAHawwT5sUZfpNH58jfHzGuHTsJl47YKZtYTkBXT+D5ycI+Maygf5Eg2546N/UpVoihQaU7My2bdVv1rZtBcLkgSybRnkd8T+K3/Q0EAYeAU56wJr+XUC3tG0RWaJsCk//PDwa6naarTwts9a9wgK0dPAuAEoHySKxlfeTooAuaYeHYFRnTeW9ZUOgM826pFgvJsi/CxMj8lU9aEweqLJB0AG+7hvXWd7TwF5PwRXwLUUJ+Uy6ikAOnUkW0K0nXAvolY2nbD51xkV/X/EcCiMsQWYCunWQGQSPhoTJuOuBbvo46/NAV1rozL6AYBknKQzogWl6aJrum9ZVAjJ35Nzl/GXjLwBWig6n/e+yqdR927piRJ9PYqOQuaSH8umFEBkz/b6RsdJbiunnIszH2xWRvlWH7/v8xE/8BC+88AKPP/64+ve/+Bf/IsvLy8zNzfHGG2/wkz/5k9y5c4df//VfB8I+w/pmElB/Pzw8fNv3+nt/7+/xt//231Z/73a7LC4uKvZMwIwUJYTNk37CUmyULADZoEsLt/39/UfYZ2lXdPPmTaVekWRmCWQaDofUajXi8TjNZpNf+qVfolAo8OSTTyqfrdxH4hV+6qmnVIJ2u91mcXGRSCSiwtNmZmbY2tpSahnJCBAZ8ezsrLqmsn5nMhkANQaSefGVr3yFP/Nn/gyWZXFycsL8/DyFQoHj42NlZeh0OipcSiS+IoOWe0h/ZgwGA6UeCYKAUqmkwtnK5bKS0AvbKW2p5LMMBgMODg545ZVXGA6HLC4u8thjj/HKK6+wvb2twFqr1VIAvlAoPLIeSTheq9VSzLrch3Nzc8piUalUcF1XtV1bW1vjxo0bPPnkk3Q6HfWMWFhYUMnYspZIyFcul6PZbNJqtahWq2QyGUajEfl8nlarxZ07d2g2mywuLnL27FnK5bLKpZDwMN/3KZfLzM7OKlWUJMBLIJs8GyS3Qwp1oo6SZ5MUG/S2ceL1F0ZYCiYiO9czNsT+IgVBmdNSxP3t3/5tFQg4OzurmPxyuUw2myWfz6t1SQC3vIee6+E4DvV6ncFgQCqVUsnuMu5SkJDrJ6n9UgCV1zPNsHXbycmJmoMHBwcqK0OutRTc5NnuOI4qwEKoiJHAPJmb+jPoW3V8W6yRLYNeHRafh2k1TCaOJIcMBrBBkbJrMHN/neSOh2dAdh66Cbhfg2oF8kXIv+yz/1KT7tYKWXxGHDPxytjXcyxcb7I7Ai+Ig5HEiI5IOmn6xiGT9Do1wyEehdkGdP+/fUbFEc6TBfrpFWhMILYF1MDI4OdzPHj+KpGjl3jnxoSjCcydg+UANncgPusz02yx1fTxklMem0J0BL1jaLpThuY95kwH1wZnJsCfAmPI5OAe0F01WRn1mXkAiVGTV772q4z/zGNgp6HuwnwMrxDl5HjAMAbTdAQ6A8xOG3PqkEvCqG8xKSyD5UP/BAYDcHohOPRd/MGESTeg1mhzGKwzKi2A14TmCMprkLVgbGNE97GmHg6XYdAhMnkJbzjFH0bBvAYrJbg5gtYCzD5Gq7TETHAYEo97CTLuiGHWZRpJMS30IdYLwWWQgnEqZFRbG+CNwtCxyRloX4XsHFiP4WVfJ1nssgI86EPXhPJjHRq9r0LvnfQjZYxRn6mXZ3chTcw+Irs/YOCDP3agXmMYm6V6cB97EOHwosPx3FnI1AhGNxjm17jXarP05j1K3ZdgEWIzAd2yD14QVkKScTDLMHwWDp6B0TKMjdBzPVuA0uNhg+5xBfpJiBMC7kQCvAkYLqRi4b/H3mK88WDSBSZhb7xRAM4QkhakrVBf7U5h0YVgD7buhrHrQQFIEel8lSutr7DQc9kvQiIVMH5gkRokqK736Bx9mla2QD7Xwq9Bd2zRzy1AOQ2ZGuTnQtuBM4V4i8jgPpn2HrbpMYxaGFYE37QJXINI3cUdeCwmHR5PQmIER7sw6oCf8knYPbxoaF13TmxOgigpfKL0MGkQMXuYq0NmcnDyxhaOG8F3phzcjTD2TUZehSZxBnRJ4DEhIEMbiywOedpM6eBBzyDTqzIhhUeTKLNMiWPQBx583even2jQLZVvae8xHA45Pj5md3dXARtptVQqlZidnVUAIggCJcOKRCK0223llZWNhe79PC29FqAiib/dbvcRsCIMQiKRUKnO4scTn/jJyYnq8y1gUw+BEkZEBwh6e6RIJKLYGB30ClAW5jiTyTzi25ZNiXw2HVDq7Ul0/7d8F3Cmh3TpDLd4hkUhoEuzZQNjWZYK0pFgnIWFBVWZFzYeUMyrzn7L55BrLBJUAWfCqAnY04Hr6eKKHqAk3kq98CDjLoyhAE8BsjInhOmSVl3C4sTjcQqFgkoWl+AguQbCpOvMOTxM2JfihPyuFFPkd3VWXIC8zFVd/TGZTDg5OaFer9NsNmk0GmouCmAQRkrS2YXBKRaLzMzMKFmjHowmrM7bWSHku4DtXq/3SA9wUWtIkUP/vNK+ScZB997LtdfBs2ywdXuBpBLr+Qa6NP2bHaSmHx/72Me4ceMGX/rSlx759x/7sR9Tf37iiSeYnZ3lAx/4APfv32dtbe0bei8pBJ0+ZG0SRrLX6ykm+9atWwocvfe97+XixYsqG0DUQ9K66Ny5c7zyyisqzEnWv+3tbQX+RGnRbrfVOnFycqKA6N7eHrVaDd/3qdVq6h6LRqMsLS1Rr9ep1Wq84x3v4NatWyqUTK6rrFcSaCVp5gBzc3P0+32VZA4P7/VUKqXSxqVgIHNTelqLD1nmufhy7969S7vdZmlpiZWVFRKJBCsrK0Sj0Ud80YPBQIFhCNln27ZVUJhkNIikdzQasbm5qZQDm5ubyl/ueR77+/s4jkO1WqVSqfD444/Tbrcpl8ssLCzw2muvqefN7OysyswQL7ZYAYbDIaVSiel0SqPRYHV1lXQ6TSKRYHZ2lmazydmzZ6lUKqr9287ODicnJ6pw6HmeCoOT9HPf91leXubWrVskk0nVbi2RSDA/P68yRETFJHNGfleyGWSNFEWK67rKkiP3qzxjRLItaie9uKxnXOj2Kyl2y3NcLA0iv6/X6+r5oluDotGoArOJRIJSqaR+X561N27c4LnnnqNUKj2i2Oj1esruNRwOSafT6rk4Ho/Z3d3l/v37dLtdgiDg6aefxjAMlVyeSCQ4OTnB8zzK5bJao9LptCreyjND9haFQkEVexqNhup0IcBc7EEyXjmAJ84AAQAASURBVGL5keKaXGcZG5G5v92a8s08vi3WSCeCezylsQ/DXNh+qT41OWHK9cgAM5LhaDPL93ypxcwPvUUGArE4OCmIrUHahXMph5f/8y7t5hlggEWdoO+RuAe5CpzMdrB2bbLjJD57EBxgTGKcTJMkd7pEJgHFGwlK5THBpM7NxdDrbFpjdqNZvKUM1FtQnWH3hUWGu+tUxlDIQ2of6t2wB7IzTdKxbMyiTytiwG5A4Wac+VGSfqTDbCGgU4N2BuZGMASupWK05yL4rkk/1+NCPiAbCzjmHuttgyB9EUZlsO5gFjdwZqCVs/F8i9TdfUrtCTtLZY6WfYJ4ACsLYTDWwIdRFrszxB+MCQKLWGvCEIt2PyBjd5nm1jGjU5xkAiIj6I+hnCcYZchvHnBS2odRhOiWxzQbwc8uhYFe9pdD9n1cgUiF6dkXuOPewnOL4J7FGMVZoMmBaTKdSxJEMqEsIGdAy4agB8kTGPqYpQl+6R6M6nDnDBzO4j47S3thnWrEx56DYRViSQ977QZupIJVnzKXDEjH6jT9Hu2YS7sN0TIYSQd204xK7+Z4YYvM/YD1dhw39hgkruDNPg7GGSbODhupz2F4+1i08YI4XjITFgbS82DWYPIU1C/CcTyUZk9dMBKhH7uVgrgRAm3sMK4+iIXNvZ1pKCWPvNV6K2qA74Veadt7S2ZuvOXjjoY/N3UhbkF8CpFdOLkO9esQj4CxBO4BleAllqJTJnngIvh7EBt5FLMDnEZA8SjO8pFNNJrgQXzA8XvisJoGKwNmOmw31uuDeUDCv838qEstHeAHYI5dikOX9jb07xtkjgN2kxA8Az0DxvdheAKJGpzUQ+V8uRJ2pqM+Jh20yeKQMHy8RA+jNiXxBGQmUIj36A4MGrZPwzWZBFFsLGLAgAhJGqSMY9wgiksPF4sJcXxGpCgS5TwePj4FfLL06HDCN9Z29k806NbZRnmwik9NNvqyYRB2WXxqIj03TVNtdnq9ngIS+ob+tPfztK9WgI6EA41GI8UGCXAQz61U6AVc6K+hgw95iMsGVg4Bh3rBQYCL7vU+fb76a8tGRmeUdXm2/n6nGW55Hz2s6rSsXJhX+buAPwGawnRLoqqALM/zFOg93aJMxkk2ETrLLNdVl7qLlF1nSPU/n/Zw6z7m02w/PPQ5v90XhMUQKbLIxlZv2SJebT0tXmcT9M+jM/GnJX6nGX/932TTKYUaKRYJoy3twcRXrbPteiiRPibiRRfmWQCrFLkEfOvXQb7LIfeTbPh0xYhcX7l+epFB5qhe7Ho7ef3pcTi9NpweT32cvxXHX//rf51Pf/rT/P7v/z4LCwv/zZ99/vnnAVhfX2dtbY1arcbXvva1R37m6OgI4I/1OP63DgEh4/GYzc1NHjx4oEBLOp1mf3+f3/zN36TdbvP8889TLpdVu6FsNku9XmdlZUUBRSnKiDUnlUpx5swZXNdVyeYSbvjgwQPm5ubUzwZBwPXr10mlUszOzrK5uakyAgSsLy4usru7Szwep9vtqj7ZR0dHSnp+5coVarUar7/++iOgAlCKmgsXLhCPx1lZWVGtlubn55V0XGS41WpVBbNNp1MymYxKqL5+/Tqj0Yhiscjy8jJLS0sqnEyk41LYkERssWlIoVO8w8LwAgrYSTDccDgklUpx+fJlBoOBCvPqdrusrKxQrVZVG6parYbruhSLRZU1IkU8kVRLEQEedm7Y2NhQ1icJkxTwa5omnU6HTCZDo9F4xActYaUCzgRQC8Mr/ZyFHV5YWGAwGOD7PhcvXlQp8hJsJ0x2NptV97uAZrl+ss6YpqlsDjLG8FAZo3cTEfCthyeOx2O1nkh2yWg0Ym9vT7HKoqAwTZPj42NVfBTLwNLSEoPBgHa7rcZWijmAKk6I7UH2D51Oh6OjI2XngZCp39zcfMQvP51OqdfriqGX7hDCTsuclLBD0zRZXFxUvyut3ESVkUql1DO9UCiocc1kMqoNoBRrpQAln1WsE7KP0hWD3+zj22WNDIYVgvoG5hhcYOumyetOnD27wzBrwXKe3z2KcfybBn9q2Gb+f/ExF8Jk43EGWgUwZqBSgssn+2z+1xvEvFkiNGgxJHUTljLQfWpAvO6wNK4wML8G/gyd6WP0rTdYPTRobSaZOFHsrsX08wO++8+PqM7BH2zATtaD9ABaPrhRpksFhmdgdRQGeTe/apBoGRylfcxBHKvWZ+9Kle3aAvlXb5EaxYAaCScFnRYRb0zuvIv1NNyLrzBceYxo/UUMTPZWMpxLdAniMMl4ZIfr9KsWXuoMTOcxJ6/hZFJM8+fh0CR2vU52ZECxynR5BZassJ92vw5JG8ZJoiODiDuk69nY6ZD0bll57MyYwPRxpomwkuE5EIuC0SKIBphRn1T3JoNhDmPgQzIJl98B/TFm63fwZ2MQvAs6K1A6izNzBnolGNSIDSKslH0aI5hMIjAZwHQYpnR7URg1MK0uYJLq+oz8W7i11yBZgt0iwdFTbFT3GBXuM7WhbsbxOhPKM3dp9BvEjDqOBRF8ltsjMlFIFyFvQjLtM2w5+OMZ9s8XOV89JtP2GA13ofc8xN8DuwOYHuFeXIL6OASO0e+C0TMQTMCuQK8CJya4sbDQ4HthKy/8cLI6YWsy0ikwTZi4YZswM4CUAbbFW8boUF5uuKHkPB2BIBIGlQWjkA2PmtCZQMKDyU3Y+QNob4S0cnwBKjdJm+sMTzxeG1icNz2OB9BIwdozMFsP6L8C3shgbI7wkxNiBljCtkcKoT98OoDhAVnvDc53RhQOIbMN7gOTlOcTH5r07xSI91NMjQbpZweUn4DEfeh9CSYWJBcgf9/G6UTJ2kOmY8gEUyyzSyPl4J+fsHAp7JU+rUNvCMGMT3cSoWObpGIuXr+ISZkFBsxiYRotMvkx/Z6H407xrDGWHyMBBMGUAa8RwcBkkSk5HCaM+caCeL/poNvzPH76p3+aX/mVX+Hw8JC5uTl+5Ed+hI9//ONqUxwEAf/wH/5D/tW/+le0221eeOEFfvEXf5Fz5859Xe8lG35ASQy73a5iH0R6KFLHbDZLsVgkl8uRSCSoVqvqASpSr3Q6rVrByENdmEwdgEp1W5hbeQCKd7bdbqvkXHkoy8+L5LHT6Sjm2XEcFVYlG0nxlst5AIo1Ec+4MMUCnAVIC1DSg7ukn6i0fen1empjIoBQpLgCSETOdlqSe1r+K4BV5I0im5TPJ5X/yWTyiHRONnJSxY9Go2rTqDPRAr7Evy7gTYoOsVjskZ65skETybG8vwTb6Iyx7o0W+fRp9lj3qeublmQyqZjsmZkZtYkTEC7nJ5tY3eMu43zalgAPW3XpSeAi+5NrI5tTGQ/x6ksglrDJ0iu43W7TarUUWJY5oRch5B4VH6qAEJGwikpDWFAB3zrjLK9xOjhOT+yVgoVYAGT+ypjJPSNqBZG26kUQOXfxkMqYyXjrxY7Tlo5vhXQyCAL+xt/4G/yn//Sf+L3f+z1WV1f/u79z7do1ANWq613vehc/+7M/y/HxsWoF9Du/8ztks1kuXbr0dZ8PoACBzhoHQaA88aZpcv36dTKZDFevXlXFomq1qgKmLly4oNZVATbRaJSTkxMymQy7u7vq3hQWT9pU6Wnokt3w2muv8eDBA+XllHVkOBwqUDcajdjZ2VEKnNFoxLlz53jhhReUfFxULoVCgXK5TK/XYzAYsLy8zOzsLA8ePGBzc5MzZ84o0J1MJjl//jzj8Zh6vU6lUiEWi9FqtSiXy+Tzeba3t9V9IpkeS0tLbG9v0+l01Foja6ysD91uVxU0ZPz19nq9Xo9YLEatVmN3d1c9d4R5FanxYDDg6OhI5T0sLCzw+OOPq/7cAEtLSxiGoQCzaZpKgSSBnTp7KwBNnj8QKmtkzZe1UWwxUiTWbT5yj9+5c4etrS08z6NeryvVgGEY3Llzh+3tbaVWqdVqPPXUUywvL9Pr9dTaKH53KVTLecl7y/NCirrypdvDBGjL+i5rt6wx0mpM1jt55olEXyTxh4eHbG9vU6vVVDFDPr+MLYTAL5VKqTZpssYJeJUiyN7eHru7u+r+EYm+rHG+73PhwgWCIODo6IjpdIpt20r9A6jAV9d11X5lcXGR2dlZ1S5udnaWbrfL/fv3CYJAqd/EeiDedHnOim0AUOumbgmKRCLk83mSySQHBwdf13rzP7omfTutkVO/BN1NIsmAaRuC44B+ZMJwxoJeAEcD/JjH/ckSL/9WjnSwxfIP+/TWYDsOrQoM+iEeXvq+gNzeLUZvdrBdn6jlEdlJ04tMmbk6ZZrYIzqGrjXhyIdW8oDVaJdkN8XQCohaExw/QT45pNYK6L1sMj0Jwr7LBBCJhd8HUyhAZiEM6d6rR4gNYiRHA4bZNt57TNwXnoPxKp67xQBwSVAhx8wkTs/Z5+7U5cFSjNHcCsYDh8vrA8bnfA7mTUatkEQ9Om+SGAdE6vt4lQCiT+K69dAbna/C9pdgFNBzAui3oP8kLJ2D7S3o3ID4LFhZJrEofsQg8KsM/CFBtw9GBDedDxOr8SC9DJmrEO1D7z7EooxqJtbumMhkSirlQ8fBqR+HfmYnEUrvI/sweQf4eSg/BxtPwWievjvLgXHEaKka9pru9iHzFrhPPMCOdAkciMd8jAD8aALyE7jUg6MATmo4ke9lN2PBZEQQjdNhh8p0RNk4wkvDvVgCJxqn6naYMX1iQGYAJcejXmrDzQ7msM2BaxEcGCSadxilXoGzDsbJNaJHL+En2zjWDOQ/COaH4GAVzB50I2F4XGQEySj0xmCOIJ0JAbcVh2QM/GEI0t0IGAFEgvC7aYc+7IQLMQPMSAjGnSGMzBBk2wHEbLCmocIgcIA2Rv8l8qMX6bUN3FQNM9ugNKqzcuCwvp3k/lyZ4/4h06mDEzXpuj7xCjx+IaB4bcK6NSR5BmILYGTjEC9DpAgBMNgn5dzhzGTE+XWwP2cxub1AZBjHMOqcBD4WJdLmBHdpwuNPQnkMgzswicNoEYYZiKx6GL0J7Uxo/T+JODgZh+gsmKvgzBIGFQxhNg3dKNw/LOGP4kTSO6SJESFGIXoLw5vStV2iWUi4DgxdvAxgTojEIUhPMOwWwRDY7xOdeuRI45P7utYaOb7poPvnfu7n+MVf/EV++Zd/mcuXL/Pyyy/zV/7KXyGXy/E3/+bfBODnf/7n+Wf/7J/xy7/8y6yurvKJT3yCD33oQ9y8efPralMhrJtsvnQvs1RrpYqfSCQeYbwBtXkRGWAul1NePT1NW9/QC6DQZbG6FFmAjvTW1D1SwiLLhlUPhRHQp3u/5Gfl/YFH2GX9Z3VZrQBPnUXUpdm6TE/Ar/ye7iUXIC2/owMr/fV1lliAq85YyCZIlxvrKdaA2vgJkyLAXM5fmHMZZ2E/dLZfxlOq9sJyyIZ4Mpk8UviRQwd9umpA2Bb5risc5Hekb3YymSSfzz/SF16Ydv09dZCvn4cOAvXX13/37dhZYZb1/AEpLggwEUm3+LjluuvzSl5Xl2XKPJXCizDhEjooIF+YLSko6GOlKxB0lls+12l5v/6+lmU9kk1weuz119DvUZmbArr1cD2dhdeZ8W/G8bGPfYxf+7Vf4zd/8zfJZDJK/ixFvvv37/Nrv/ZrfP/3fz+lUok33niDv/W3/hbve9/7uHLlCgAf/OAHuXTpEn/pL/0lfv7nf57Dw0M+/vGP87GPfezrlnvqFgDxa0rYniRui/w8Go3y0ksvKRuOgIVisfhI27A7d+4on6wUn1zXVZJYCNlVeZ1Wq8X8/LxqyXTu3DnW19dVwvWbb77J888/rwotAopFZSF+cQGy73znO1lcXFTebmHe2+22yuwQdnRnZ4evfOUr5HI5jo+PyWazlMtlarUalUpF2R2EsV9dXVVhYNK+r9PpUC6XFUuq20pmZ2cplUqqKNtqtTg+PlbARrckSeCYFCul+NNoNJSPXXzumUxGsfzT6ZRkMsnFixdZXFwkGo3y4Q9/mDt37pBOpxVLK2ynqIXEWiHnls/nVdHNdV0lp5d5IlYjAYhyL0nRWsLH4vG4ek7KWjk7O6t8x71ej6OjIxXqdeHCBZ599lmKxaIq+MqaL2BWnhe6tUnUCPJsl/VB1kEp3sl1kfMRhdlpO1g8Hlfy+YODAwzDUHavBw8e0Gw2OTw85OTkREn2bdtWCeVSoJG1U9q3SWHDdV1V0Lx9+zb37t1T0vvpdKrmUCqVUkqIdDpNo9FQgNuyLGVNgodFS13JI5YGkeZLcULWBn0PIfNI97sbhkG1WlXp6Pl8/hH1kjybxZf+zT6+3dbIKQHDdqisdVoQqUexElmo2jBqgFEAa8owNuD2YJbk7zYpPtUhuwqJXohxKMK+DYMC5P6qS/T3twm+FuZR+Yc21kZAZnXKG9FNTkgROAUsjrmQ61Ir+OxUeuTWwGpCrDXk3DLc+7JN982LzNDm/tkG0+dHYdhVNIbZdLBL0MpAvwFEbJL+HAa7DK4MqL9nBhbWYDvG2EwQJU8Um76xyzBzhFubcliKM7ISZHaukf3CiOVtl+gwYO2CR6oM9arBtHKGSe8J6I9gvA2pIax8AOJPwXAb0n+AWXjLIlx2wOzDaBMmLxKd3GPqZ2D2abyijxdEITJP0HoFjrdgFA0ZZzcOfhv8DjhJyJ+FaB6sfboTE7xdaETpnIxZjA85aXyZ9txz+OlFaPWBafi1m4H0C+AvQyXK8PE/x51JBlJZmKmELa+CLnQmGN4J6YTPdADTaALfj+Fbz4H/GLzcgcIhzNwCO0+QfQKCE3DHOE6fg6lLMXBI2tC0DALDI+gF9IbQOoTMGJK2C5f3SST3uHDTYdy+zDQwqPo3udf4GpPlJpnOy1yedNhIWxyu/mkw/h9wUoRJEPbPjrwFliNZwAgTxS0fIokwbCxmhEFrdhJiXliIMS1IvRVEZnjgOmHvK8eA8QiCAUQjIVh3xoAX9r/y/bA/dt4F96sUtl/i8t6E25bFYK7F7KDH0m2f2HUYHo0wzzYorriY0YB922NUiTFcMBmfG3Gh4uG8ErYEb86CM5+BaC4MTHNcEq1N3jNsE7kGrc/YJHdnqPsZJvQoG0OM2JhU0MGa8XHfBce5sF6SrIQh67E49FbAeiwgG3hM4qFVvwykgaoR1hWcNpCE3DOQqsOwDjG7D8aUSMYjEt/GMvbJrPbp7oRT0DWgCxjVgOoijCKQn4HCEvhmgLsBU/OY6abHxF/CoPINrYHfdND95S9/mR/8wR/kwx/+MAArKyv8u3/375QcKAgCPvWpT/Hxj3+cH/zBHwTg3/7bf0u1WuU3fuM3+At/4S/8D7+XsIOy4RafmLTHkFRUCRQ6OTnB931OTk4Yj8dKXicSYGlfks/nKZVKSurX7/fZ399/hMkT75kAPNksyINL0nQBWq2WklPLpkZ8prJ5kE2GsAWmGabGihdMNrTCdAvDIiBWzkGYdPkZQCXISgW8UqlgWZbqlayz+TqIFn+0bCrk4az/XWTLApgAxVYK2yqMvvyuSMe73e4j7LrIUieTidqICVDVw4p0xlfAtoBdXbJ92gKgy+z1lm56sSCfz6vfkUAbCHvG6q3nZBNYKBSYm5sjlUpRrVZV+y9946pLuXX5va4CkOKObLL0IDdheXVJvO5LljFpNBrKuy2taIQ1k78LKy0FCz0bQOalbdvMzMyoQkIikVBzut1uU6/X6ff7tNtttVnTwbUuu5f7VObMaeAr3+U+lg0zoMZZ3/zJ55b3EZB92vogvyfAzTAMxfbKn0/bMP7PHr/4i78IwPvf//5H/v1f/+t/zY/8yI8QjUb53Oc+x6c+9SkGgwGLi4v8+T//5/n4xz+uftayLD796U/z0Y9+lHe9612kUik+8pGPPNKz9n/0kPlaKpVUT2aRxUoK89HRkWIUDw4O2NjY4Mknn1QBkwKsstksV69eZWlpifX1dU5OTnBdVymKBKBL3sH8/DwzMzPMzc1RLBZVhkCz2eTg4IBsNqsYwX6/T7VaVddeAJqw2Ol0WmVX5PN5otGoCoG7e/euAm5SuCyXy+rziORXAqTEcyxjc3BwoM5neXmZUqlELBZjbW1N3T9ra2vqnpZ7JJVKqW4Ukj8hxUHLstSY1Ot19vf3OTw85NKlS5RKJRUoJlJlUWtJaJzjOKrn9PXr1+l0OqoDh+d5XL16VfVIz2azFAoFFYol4K/f7yvPuEiNJYTs5OTkjzDekvguxRDx48u6LTko8qwQRljAXD6fJ51OA4/66WdmZlTHDj1kMhaLKfCdz+cfeT7oiiLgkfVKiq0y3lIwEEa+1+upNbbf76sgv5s3b6r1T3+W7O7uqtZas7OzGIahks6r1SqGYXDt2jVqtRrVapVut0sikVBeeAnYG4/HCsAfHR0phYS+fonaI51Oq2C9WCxGp9NRCo2TkxPy+TwzMzNkMhllBZF5LIXeSqWCbdsqtG95eZlms4lhGKysrAAoObqox+R5PjMzg+d5KqMEUAWewWCgCtXfisyLb7c1Mo9FLAozAfT2IOjmSHh56Jswa0C2iLF1BNMJB7kJO8MiWzc6LH5v2P7YGMPEhogFThYaT8PiCuSfgNED4F6H/gBOytBNTvGoECVBKvVVCmd9dpbBisFjBXAPYHwbmrcMNjdKOF6FFAHsjUMmuZqDSZa412Zcgt/1TCzHZ8WxSGOQPjfm+CmDaWERoiUogztToBl/gJn2iffGGGWfzgUYV2qkxx2ubreZ3ooxmljY+y65FIzPwW5qliD5FyCawdz/DS4c/D79rMXO4o+HAMrMw9oztPo9cAKCtRnIHoN1F+w9vIQJqQBKixBbDDW+RhT8e2CeBXMe+gPAwDp5g5n9u7QOx0we+14oLUG5Bn4BRr8P/i6TockASEWGdDfexHfSEJsFPAiuw1EX9iowsCDrQvZZqM7AyTFEU1DMh8grSBJ4JXqtOwT9CX75LEzzMFyBShVKMYj0wbkL0yxkngFSoTQ7HcH3pjiDJnHPJ3cyJDGEmWHYrTlhhuHhTuBCsI0759IvQ3JQZxid4K8YuPECTM8yoMGd4Ca9VAXij8F+LATGmWgoo0/5EIvBwAkl5aU8TJ3Qn53wQ8Z+6obNpt0gBNmOG05G6y0puguYfsh4m1PwXJiYMO6HFaG0BY0BpKIYwV1iX/7PVDuvcnW7Q2Edkk94eLUOqbsw+GIE57jIqu9yZtyEUUB/GcwqJPwJka9CZDmc/3YUgjx0zpo4M4XQi9G3MMb3OdfbZ+2/mDReLNDoBPSJYmIRJ4D0GGslYBQJyC5Cew42smGb8MccmG5CsGvgL5tMVz0iFSjFYdowiDUMgj5MJwGWFxDPQXwxtJE3J6HVfbnapzkJhQAr58YQh+YAzAFEbRgZ4c/nVqB8HtxMWP9IukAPxj6hlz02wBo5mDS/7vUGvgWg+93vfjf/8l/+S+7evcv58+d5/fXX+dKXvsQv/MIvALCxscHh4SHf+73fq34nl8vx/PPP8+KLL74t6P7jeiyeZitFriohWgLmRJor/SzlwSKgVYBULpd7hEmTUBTbtlULMdlYvZ10WN5LAIZ4/sTDJUBKZ4WFSfR9X8msdW+2tDkTKZjOdEvlXzYcsvkUqbhs0oThFUAlLcTk5yXtVECMbF71DYMurxawrUuYdRAsvyOsmiRk668hFXW9bYqEMYk8XMZS94XrjD3wiLxcxkpA/enjtHdbDj2oR8ZFB/zCsun+Pbl+4n2V75J8rKsGdDZbv/4CNGVMTjPuuqxeDw2S19K91RL+Nx6P6XQ66u866JYCiX7ItRZJqRRmhLWXOSNzRFgl6Wssm2MdBOtfp6X58mdRQOhyeZ0N1wtAcn3k92Vs5Gd0RYHcrzK35R7Xf1fPMfhmHv89j/ji4iJf/OIX/7uvs7y8zG/91m/9nz4fCX+SIojIaY+PjxmPx+zs7BCPx1lYWFDJyNPplN3dXdbW1lTIoshhfd+nWq2qwl2/31fz6vbt2wwGA3q9HqZp8uSTT7K0tMSbb76pZO2TyUQpEGRjLwUTUWTIfBEpbKlUwrIsJecVibTkcczPz6t1SAK4VlZW6Ha77OzsYJqmWlfr9Tr5fJ5nnnmG+fl5/sN/+A+88soreJ73iOVIUrNfeOEF1ftYCqgSMpjP54GHCh2xEgm47Xa7yhcrEuLBYMCTTz7J6uoqpVJJsavCVguLOhwOSSaTvPrqq3z2s58lGo3yzne+k1wuR6VSUcXJ1dVV5b+XfAz5LFIIFTZZPM1iG5H7Dx6CV1ljYrEYw+FQBUPKZ4jFYszNzZFMJlU69/7+PplMhuXlZb7ru76L2dlZIpEIu7u7VCoVarWaKnDK/JP3lDVX1jF5nsm6IPMBHq7depiinJPc/1JQTCaTqiC0tbXF+vr6I2Gh8llbrRaDweCRHtayPti2zfHxsXrPg4MDzp49y5UrV0in0ywsLChFgcjTb968qX6nUCiovu+iMrl8+bIKrNMtUMPhUAXv7ezsqNfU9zJSoBFFnhTXZc2Wzy3qHskayGQyylYmCeaRSEQVqNvtNqlUShXZgiBQ33Vr0Dfr+HZbIz1G2NEwwNpKQ7raZOXgAYP1GVp5l3F7l5njGJ4xTyOeItFL43ylhXO3TeQJSEzAjkAsGap1j304rELnOWANFp4LMCcwdsG6F3C82yfm9okUpxy+F4ZLUH4zBAKjQ4Ppa2UsH9JkmGDjkiCI5t/qrRyF/hGZ4ITrfoaD1ByXeuuUpw5WfI/c8x6pVQN6PpCAVIBpTZg/02digNfMYXdHTNJTvNUUQaeP9zWLSCdO8r1dsguw3YF7gwidp38YKh/G/M3/D+VXX6bkOvh5AyPeJMgOQmY0exXvhUrIlg52oHETGGPaHmQikE+FHyy6BN4QnEMoPA7uBfAKUG3CtEcwqGMFW6wdb7A3+N/pPPnnYfUZKK1Cs4l5dESkMuTAiGBPIyS8E4xRg348BvbvEW//7wRRm0nsT4fFgOkMvBaDK1moZOEgAVsZSOfCdPTcPF76HWEqnpeAoyLsG+CP4bwJRhs6SfBrwCwYFgR1cHbDpt2uQToG8SEUU5AvwHgCQRKOk7C/GoHkBCe+wN2nAjLVE8ZukkH5AwTlH4KDOTxzieby61CpwfBCSNfGTYilIZZBZXRlo2FVZurCeAopOxxT1wiD5Ab9EA3GCFF/ynwLfPsh090PIBOHQhxcE/rDEIhnEhD1oHeCsX2N87d+k+9+c490PQx37yeh6EJ2B1ovW5iHa/gk6EfvYRcCPCfMoisdQXUbgvtw7Xssvnp2BvNdUbKpJp2FBEFyFoYOjI8pHb7B0ssTTn63gDnNUKDBiAR9fJx0j/qFgO53hzly5/pQi4SAN2mEbbvtKBRGcXqvZHCuteknAqbTFPFpgi4mI2x8psSMNtnyiGg/tK/HgtBW7mUhmQkV93EvFLK4m5AxIV4NL3d2BpgDsxiGFFpj6NyBtAcRD0ZDIDFlNGkQ+N8mTPdP/dRP0e12uXjxopIg/uzP/iw//MM/DDxs6fB2LR/+uHYPf1yPxVwuR6lUIpPJKIZUwLMksEpSZyKRUGyfpPkCKjVVHjCymZP0V+lpqrc7godeZx2YwR8N/tJlwfJ/wsqIFE6Ap4BwAYbit9PBlh6iJuyNyAX1ACo5N9nECVtlGIbyjgsrJTJLHZDqzBE8fFie9ljLz8nGQMBsEAQKpAJK7q9LjIVVkWq8sPyASonV/Yau66pNiIAA3f97us2KntYqjI8AEd1zKRtRYbp18CjFC/FtC+CWQ/rTir9bL4jI68gGU0/Bl/MTtlWX9etsvd5eS/c1ylwWr/Z4PFZgSuarHnSm98PWCz6SOiyMtjBTEpwkYEA2kP1+X72uXuiRuaJLtqWwIu+r988V/6gc8nll7spmUcLpZNOsM+kiQZfwPTn0Ao2MtV7k0QOZvpMP6eawuLhIJpNRIUSvvvoqm5ubNJtN1TlA1ibLstjd3VVzWBhMKX5I+6zl5WXFILfbbSqVCltbW6qN0uLiopofwgzLnJ+bm1NSbfEoyzoAUC6XVcCYMKqe59FutxkOhzz33HOKPZY1T/rct9tt7t69S7/fJ5VKKWDR6/WUGmVubo52u60SyCV7RBLT4WHxVIpUsVhMSYFFUiz3pazjUjTMZDKKrZf7RtKlT05OWFlZwXVdqtWqSpQXMD+dTpUHt9PpcHx8TC6X4/XXX+fMmTNK5hyJRCgWi+r+kLVW+k4Xi0Vc12V2dpZ4PK5aSYncWFrCQajE2tjYeMTiIYVgPWxzeXlZ9TYX2XWj0SCZTHL27Fl1zdPptPKuS0szWX91xZGeFyJFSDkkl0SKqLIG6Hkfsg4LowwPn0/Hx8fcuXNHFSGCIFDJ3rIvESY4mUyqQn40GsVxHA4ODtjd3VXp98899xznz59Xvbklr0Tmh+M4NJtNFdqn99OuVqucO3eO1dVVVQiQ7Be5J/Tisaz1rVbrkVA4KWrDww4DiUQCx3GIRqOsrq6qIrfMJykCTSYTVQyWNVb2Qe12G9u2H+nbLTaE7/RjyJjjASz0IX0G1jIutdYBtS+02NiJ0OyNiXsX6BkLNHsWk8DF2lvG/50utZiPlYRBHgZpMMwQE42mUE+ESufOEIYWtNrQq0YwY23KbptpKWC8CHMmZE0YJcMgac+3cXFZpsWAI25ExrjzydCD6wVgjagHCablKwSRJJGDddKex3BhQlCAcjPAHneYPpuDg2OM/R6TBxnifpmE7xN1hsR3oWzcZ27fobJlMbRc2p2AngvNEtSrVYK5y9DZxzq5QWTosLUP9YUkQTEBszFoBGGKdlCDYT9EYLElaI4JpjZBdBWCx9+SODuhpLlbDysU9RJ0irBUhq6Pb3U5KNWJd+8x1+jSO27gL8TB3YJqBL/3XUwa98Ee4mQXMKb3KHYPGUW38bsHzN3rksrBjaRNkD4LgzHE6zCIwHEeTlIhGo4loBiDbCMEnJYFAxf6szCIwbUDOBnDvBcWDFJVaFlhRWbUJLJxm7JVB8ujHwEnatL0bQLDwvENpvEkg+VncPKrULfBXGIyEzApnIQUqXsRWATfhCANiceBKEQLMBMLAbJphgA6ADwjlJM7bzHXMTuM7LYJz2noh4A84YM5DtPNjUiIUAMb8CFhQwLo9yFqQZ7wc8cNaK9Tvv/LvL9/g9XGEDMKjRm4PwtOGiq70HvNxNwrk8SiG9mCfJ9oPLRi7LUMpuWApm/SfibC8btWcM+/B8oLDKfbMDkOdeajOvHgdZ5xmtgN2H6sS2B1GXZ9hokN/IrLZMHj5EIcdzVJftAhuumxUA+z76bRMM/NtsAuj4hZU/xxQNBP0SJBhAAXizERwGYYWASdJvHmkHQ+/PhOHCJpWJ0Nh248E9ris4UQXMfLMCiDORcKMjI2xCfQ3AJnA1oB2O1wqncTPp5/RLv9jQVNftNB97//9/+eX/3VX+XXfu3XuHz5MteuXeMnfuInmJub4yMf+cg39Jp/XI9FYRfFUysPCfH5yQNbNjEC/GTjIQ91YVwEgAgAFK9fLBajXq8rYClsK6CkanLoUnPgj4BuvZqv+69kU6tLl3VWVTYs8n/yNR6P1YZPNjC6l1tnuuU85YEtY3LaeyvePd17DDzioZRDQnCErZDNlWyGBTRLYcN13UfapElhIZlM4nkPW5jI+wgQF/AmQFw2gzroln8XYCYFFQG3wqiJzFFXR0grsHw+/8iYC5AWJkzGXd5fQoGEtdE99rpEXMZe5sNpmbUOuuHhpl/YL/11ZDMvvs9Wq8VoNFLycpHzC8AU6aBeONE31zIfRDIrDLdYM/R0ZLlmci1k8yzjaBiGuifk50QCKq8jhTC9KKWrSGTuSoFE5pFcZxlnmSPiBZXXE2ZfT2mXP+uhhN/px/z8POVymUqlQqvVwjAMzp07p8CiAMNEIqECFXu9HoeHhwoUJhIJjo+P1Too4XXT6VQV78RfurW1RSwW49KlS5TLZa5fv87+/j4HBwfqunmep7pF5PN5zp49q4K/bNtW1hgBiZIX4Ps+6+vrKljs7t27eJ6n5OJS7BqPxyq34+TkhKOjI3Z2dkin06ysrCg/tSRKB0HA/Py8YtIF4Emq9GQyUe0CG40G6XRatT4TybWosI6OjlT6tFgbnnnmGfV+7XZbtfra3d1lOBxy4cIFTNPkwYMHSnIPKIZZCkjj8Zi9vT263S6u67K0tEQmk1Fy6EQioeTOkoYuEmopjkqC+P7+/iPhghJiJixvqVRSBU4pXBQKBS5fvkw+n1dzRdZ66fMshbN8Pq/YY3lWyJhKXopI0AG1RotNSiw58mwSQK2voXoxWXIL5DPdvXuXmzdvsrKygmEYvP7662rOyWeUc5CCsWRgNJtNUqkUjz/+OOVymUwmw+XLl1lbW1PPUJkn4psXFVytVuPcuXPqtaS1nTyX3nzzTbVHkb1Eo9FQ46YXOfRnthTARDEm/n25H0WNIgWPYrGorGt6AR8eFiQPDg5UkUwKEbFYTPm+5V76Tj/m48eU5gIqBWhbYM7A2Vnw/DH+/+ZR8mK4JIgGCTqDMTYpmixjfe4+waSP+adD0rB1DON0KGMlDkmgNwnTnf0MDJIQlKEwhpTtMroKzTIMrkP1Jky7YO8FxMwjvKhPJgNesoE3Z8PFmdDT607AKjHOPgeRGez9N4nueQyCPEG1gXUAk9vgX0pANg53B+TaE2rjCySYJ8abWH2L2qHDk86YwX2o2z6HxpTdG6H9eXI5wsC+BNMpNH4HOCbtQK4MrWoOskmYbIbsqdOF+mZo6s5mIJWHRpwg/RxUn4PgbMi+BidharXRhSMXJkcQlKCRACcK/gfwYz5H6f+VYucEDqKwH4HRBoxfhfN/Fsz3wN11SOSYMkeDL0CiSTBMsGOmmLf6RMwG08IuZDuwOoX4CryZgeZbnuZxHJyZ8HtqGFKqBJDoQ8EPDcORDBjvhXQNSkBkNmyzxTUWMh0esz1e8QzuFmfAK4c945IL0EzCaA68x2EjD80x2PGQHk1bIcVqTMB1w3ZdhTwEWTjwQ4SXAsw4+NPQxCyJ4pPgLfm4G8rDp295t23CgkbUCfttGxb4BozfClIjAMcPx7xnhiFsGQcmb/no619ibf1X+H9F75EdwG8FwOMQHcPtAGbHkHrTwDrIYWIwjt1nWh0zPrE4bhnsPRaj9USCoByEiX6XLsPachha5wPZSzApwOABjA+pNVqUHDg6B4OnPPxpCGrnaxNGdhh0ZvkO3Ojzjq7HWgPcHZi0wnb13gSoR/HHBTzA8z0mWBi4BMSxiWDhvPVvEYJpgc69OLHMkHhlQmQ+IF0N7+9UBvIXwVkOmexUN5wKnh12U4v1w2HbvwFbLxqMDyNMRjFMY0osNqEbASPqY0eHfCMB5t900P13/s7f4ad+6qeUTPyJJ55ga2uLT37yk3zkIx9RLR2Ojo5UGqX8/erVq2/7mn9cj8W5uTlqtZqSV8kDSny44qvSJcme5ynfly63kge7gDodXMrmTm/L0u/3FZDQWTsBd6elsXoglS7Hlg2E3ntYQKHruuTzeSKRiNo8yebyjwP3ck4CqoTZFkZQ2O1ut6vGTMZYHtC6hFmKDDI2Ag6FeSgWixiG8UiFXt9EwMOEbGFPxNumS6YFvMtmQs5BLzzIZkTGCx7Ky6Vgof+sfBcQeLrfulwTGW+RWQuAFDWCDvD0sRYJnpyjfg10VkfGWcCnfMnYCKgWyfhpMCrzQt+UDYdDJfPu9XoKhOtFED0sTQ/uS6VSFAoFksmk2qDNzMyoNmd6VoB4DdvtNp1OR0mK9VC909/l/0+Pt84w6wF3b6cKkQ243F96SJ5cCwH7utdT7BbCQkmhQPyneh6AHl73nXi88MILisGVYki73VZrn8xtaSknoFvGUHyjcv8PBgMFQIX9lLlXrVZVBsB3fdd3EY/HVcI1hH3ul5aWFOOdTCapVqtsb2/z1FNPKZZXrq3Ia3u9nlLb7O3t8eyzz6p1sFQqKYWGMO6WZTEYDACYmZlhY2ODIAjI5XLU63UODw/Z2dlR81iyPJ566ikSiQRbW1tq/oiMvdfrKaCWSCRU8U78trJWSUHPtm0lby4Wi7z73e+m2+2ytbXF/Pw8APv7+4zHY2ZmZlTLNf1+kJ7fohgTxl7WtWazqVRe0kmg0+mo9U8KTIeHh+q6DAYDJY2WXs5iw0qn06qQks/nVTEtn89TqVSUAkjAm+SMZDIZVSCT54u0ppIx0Qtyp2XLeraFrJf6uEpRKAgCpQjT13/5fbFP3bp1i9u3bzM/P8/u7i7Hx8dEo1EODw8feY9qtUoQBMqSI2qKq1ev8oEPfED530V1IcVs6d0ta3Cn02F3d5dWq0U0GlUZB5ZlKUAtgFjm0+HhoSrQCLAVkkCepfJ8nU6naq7qRS95nkhBtVgsKqWFrP2pVEoV28Qm0e12abVa7O/vs7+/rwgJUaSIwsg0TfL5PF/96le/dQvUt8Hx7vd2mHsKigshJnKOoNMGPw7ZIEM8WMDCJ80hPjFixDgkjnV8Dvf1WyQ/OGYSgWQQ7r/bfYhnIZ6EthsSl1YfUiO4UhszOnubzqxL6/3gxcG7DvUvF6kPs+QCgyU6pKpNpk9CIgJPNlwmGyccPbUImSRMA4hlIZInNh5TcKFvGkRM4Abs3Y7iva8YBpNFfWIVyO/uk/BdLALaps20CjeLNterMUiMSXzVI2hCtgabDQsORpjb/xFjcJulUZ9KFHbPxBk+/Qwkkhjb/wHDnRI4EfA7BOkS9BLgJiF+BRKLYFRg6oM9AmM3NL8H09BnXLJDJrjpQGoAiQKMvpfB7BGj5O/ix5ZgEBA7uE3C2aI904AzF6F7HjaARBGn5EH3FWCCd3lEw7KY+imItsO2VxELpi0wSkAG3AFEjiHWhbwFMxEYTsGeQmwfFjIhGz11Qp9B90J47pG3vNbMspc4Q93tMUhXILUKVGA0C/tlOKmEIBMLrAlYRhhW5njgp0MAHJ1CJBn2C5/2wHgrM8ENwI+BFQXDAIIwbdwj/IpaMHLAmUCUMBzNn0LRAIxQXm7EQ393MIWJA1MPHOetgDQL3CnsGZBLYDVe5OqDf873Bw2OOzb/zs7xoJDiwv4eiy2PaTpU3sdGAZhder7FOPDpR2H/gs/OlTTu9y1CnDDIoPxOsGdCBp9JmCgXd8Jk9WGXeHuf6t6UkxYcRSExgGQ3lI8XjqHpw6UYJKYextCjuA2H90ObfrJlMcaAvEvEieH7cxhAjCEJxkSwmJKgz5gJJlEM4gwIiOH7izgdg1F/wDS5TvF/CTAjkOrBMBZ2HJjLhBZ314eKC9MN6NyH1jbsvxljvztLNwjFBwYjEm6PjDUhnvDwpjHClmxf3/FNB91SfdYP2WADrK6uUqvV+PznP69Adrfb5atf/Sof/ehHv673kvYZwloCirUElBRQZ/k8z1MtlYrF4iNhUoCSy4ofVICmbP5FqntwcKAeYqdBty7VlA2HvKZpmgrI6pt/HVwJw+r7vmJeJSlafKy6fBkeJmOLFE1+TvzIAiwl1Oa0xFY24LpPXIoLAk50SaAwjNLXV1cSyMZdPovek1zeS8ChJMzrnkNhiXSPvoC8fr//yHgLGBMQJtdL5O0CtuW7rgTQZZmycdf7RMv56N5suU7ydz1MT98MyYZR97ILeyNf8ll1r7oUCORLTxYWMCDstSQLy3eRK54ONtPD5kTyWavVlDQ+kUhQKpWUT9A0TTXOvV5PtcCT3rYidZQx0IsKUqgRUKIz4nLoxR3dw6kz0HqAkNzHArrlWslclPtUz1MQVq3f7z8S9qUXxb7TQbdsxMVXKpkDg8GATqejxr7RaFCv11X+hEhyDcMgk8kopYBcH2HW5H4fj8ecP39eeY4fe+wxbty4odKepRA6mUxUGrr0FH799df5s3/2z1Iul+l0Oure0uXmUuxyXZdyuYzrupRKJZ555hlee+01zp49S71eZ3t7m3e+8508//zzxONxXnrpJV599VVVXBqPxzQaDba2tuj3+yq34MqVK5w9e5a9vT3lpxVQJ2FOso7KIcBY7BcC2qbTKa1WS63bwjo/++yzzM7Oks1mlS3ENMPe0LIuC/sr66tpmqqbxtzcHIVCQRUWpO+yKISkZaZ06JiZmXlEPSKqG3k+ybkFQRggJkUTQBUkJcdCLwhKUUEvjMprCoCUdU2el1IE0IG4bo+S+1AvPsr9LcUPWRel4CGvub29TSQSttD8zGc+o3rD3759m1wux8rKCl/84hep1+vKhy3rmiSaG0aYZH7p0iVmZ2fVPSNFWTl3CTp1XZd6va7W3uPjY2XxkeK4aT7MffF9n0KhoBQPcj8KUy7PXHm+6lYpuY9lPogCLZFI4LoujUZDFb+lQ4uspzIXxX4jexYJlZUihMjRxQMu4F5CF7+Tj9IZsDIwqIeW16wTKo/7ZejELYJBDINDTDocskifGENGpIiS70VI+GOaGSg4EIyBILTjtiNgpUIisj4IGe65C3DwIxNaVehfNCm+GTBzP2A4yOJRpkaCSbRPcQWCBWjfhuKXk5gHBvzQCszMQ3sSMpUYGK6DnQFSTewxsBnFCWyYAdwhFLMcvO8ib9Rf4V0HTepTi5dmHY6ezjN+rkQ60eLiV4a0P28yivgUSxBMx7Sbf0B8O8wTu1yA4zhsX30Mf+0Z2LvDzPAPyI1GuA4MsTkavB+WLoTS5rQBJEKNrtkO0Yt5CNN2GLXuJSE/B8kZ2J0BzwpZWD9FkPwQ3uo5GJWgNyQ+OaJs+3SOjwmSu5AthslZ2wGceRJmHDAH+IMRvaYHyacgVQCzDgMTrCzQC4sBURfKfaj1wOoBcVgrh22y+tNQbt2yYceAtg8HdiiFrw1DSbd3hWnyMtNaMgTCt4OQpZ+kYJCCiRGGk+WdMGXei4TqBNMMgXTED9no0QjSQZjCZyWgPA1VAK4NTENGO0LIiFsRsM1Qnh/zQl+/44U9uJN+yHibkTDp3A1Cz7fnh2nleCGD7kzhZBv6NsSyxO//b1zc/XWeznf4/U6G36/+EEEtTvyL/4nxpoc/C/NpGFnQy0NiEND3TQzLJ38WOu8MYM4C+wwMZsNk8sgMTJuhEiOdCVl6dwr1Pgy3qfUa5I/BaofDn9gFJjAuhp3R4m6onM+b0HNhew8GB+COTYaOTRQbq2URGAOM3HVicQ8rE5B0we1GYRShOMpik8YkIE4KgxgJori4NDyfSNOkOPRIVqE3CAPbc0NwR9BuQWIEXgcO7sLgHvT24SSwmBhjgiDPCB8bAxeLjDch1h8TN8chq/91Ht900P0DP/AD/OzP/ixLS0tcvnyZ1157jV/4hV/gR3/0R4Fws/ITP/ET/JN/8k+Uz+kTn/gEc3Nz/NAP/dDX9V7ygBA2RkCQPDRENinyLt1PK1V7efDorLFU0uUhKpsJeSgKkJGHpS4T1oNCZJOvh03pLPjbhU4J2AWUrNm2bRWOJV4yOR+dVRZJrzzM5TwlKEU2LwJaZQMlMne9ACCSO2FX5P1kcyXvLZ9L3scwDKUGEPApzOZpWbAu6ReJtshYZfMhn01/r9MSfdkcyYZErqN8JrERyPUX0C2/q7eoEtXDaTWBzja/3TXWAZ0cAjh19lYKAPp5yqEDV5Fhy3UXRkPeU/eE6yyxfo76ZxEWJJFIqOA3KW4IcJBrD6j3rdfr9Ho9ut3uI0y6zAd9Duqycn28BUzo4FuuoZzzaaZf7kM9k0FXXOhAXd5f9/Cf/pLNu34e3+mexfF4TLFYfETdI6oGAdmDweARn3wikaDT6WBZlmLJDCNsHSWspgBBYaJv3ryJYRicP3+eUqn0SNJyKpVSm3e5DjKHZC1pNBosLy8/wm7KPK5UKmo9EsVOs9kkCAK+53u+B8uyeO2111Rv7kQiwYMHD9jb26PRaFCr1SgUCipEazKZcOfOHVzXVUnOKysrWJbFK6+8otYsuUdSqRSlUkkVoeR1DCPsfywp35IRIUVZKWpIgVHk83Kf6QGSEmQnCplkMkm73aZcLvPUU08pkCVe236/Dzya7yFKBgFQlmU9ko7tui4zMzNq7RXlh6iB4vH4H+l7L/dyv99XLLY8X+Uz6UoUuV91Objc+5L3IT55uQcln0PAqSTBw8OQR8/z1DyVQpwUr6Ug/YUvfEH5lk3T5PLly1y5coX/+l//q1r3RMnTbrfZ3t5W9ovRaKTWQ2Gac7mcKqSKikvUBFIolST4nZ0dNTfkuw6kRSEk11eUBJ1ORz23HMdRDLeA+263q6wyIteXMZVnrhRJxYM9Ho9V2J70eU+n0+qeFaLAtm2q1Sq7u7vKpiSfv9FoqLyc7/RjfAzF2ZAI7XkQBKEHdGYG6pUuo60NhtEWxqRMPHAYYjIiQZMD1pw+7jYk3gFRA7xeKF11A8gNwB5AJwqRHhTegL4Fty5ArwjViU9sGHbNylhumJhuHuIWm0xtcG/D5FqcyHSJoLMPDReWs2AaITALJniegTeFcuDjtmA88InPuBhWk6DZAGYIPvCneNMq0vnSHzIc+9TXqsQTTZYe7LC0NaX8Zch2A8bVt3BpFrITiNyB9DRsf/2gmsJb+QBYq8Rf/f9xcTSiGIBfhNtZk6NUGUrL0OuBsw92F6JZoA2dAzi5EyaHp+0w+Xz8GiwmIPoYdCKQjoUA1nHCvlCjCXge3jhPxjshGtxksrAMuSzMOdCLhoOYmYOSBeXH3/JJJyDjwWAfBp0wOd2zIbBCdj1ngO2EDHbcDEHwYQ7acaALLQfcSigLN6wwdKzrhn/ueeAn4DAG8QDGsVD6bXohsx3rh+27zBhgh8Fo7ltMOlOYTCAeCcH0xAXHCkF06i3wHPVDrbNjhf203VH496gJ00n4PjE7PP9IL5xkQyOUqruRUHruDUOGPWpAdxL24x4NwzEoNEg/+CW+u/0Vpukp/0dxmd6FP0dQ+wD26/8r7+o16BoQK8HZGLzowfU0XHYilCMe3bMud2tx1uM1XOM5iD4FWTssmDAKW5gFETjeh24L4iamt0V1usvacUCwAVYL8v1wKth2+EUirJF0HRgE4JxYmIM0OSeHwZhOpE7U8Ih7UdyYQ7TmkqhBag3SKeicTBk2pkxuj8kcd/EdCx8L03YwMLGnkGaK1YHWGzB+AVoJWJtA7Ag2MxCJv8V+92HQgEEvbB1mV4dUc0P21ie0prMM8EiGfQJo0CIZG8DobZeV/+bxTQfd//yf/3M+8YlP8Nf+2l/j+PiYubk5fvzHf5x/8A/+gfqZv/t3/y6DwYAf+7Efo91u8573vIfPfOYzX3dfSKnuSpVWPLaS6JrNZpXsTZe6ClMnKeaSkCuAQDbq/X6fVqulNoCyIdIfrLofVfekAgooCpAS0CrnK++pS9/1NPBYLEalUlFJ0f1+n729PQWIBXjAw1ZK4vHVE8R10D2ZTGi1WmqDIhuRdDr9CHCXB/Hx8fEjYFc8k8KcyWYsHo9TKBSwLEt55gWciSRSlwXrYFSul+7PFgZaNuC6L1tn5EVFINf9NJCFPxpSJoBaDgHbOsN0OhRMl4TDQ6n9adm0zAP9/eTQN996WJscMvYiKZxOpxwfH6sAM5HcyvgJU6QrJnTLgBQ2ZEMp11mCnqToAajWcTL/xCcu4VV6u53T9gX53DpLf7owobPbOlMm5y2BgeLPlH/XU6nls+kMm4ANuUbCcp/+0j3kcq2+05luAYjCaPq+z87ODpFIhMXFRXZ3dxkMBoq51mWo+rWQgpm0R5LNvGEY/NZv/Ra7u7skEgkKhQIrKysMBgNyuRzLy8tcv35dJT9XKhU1N3RQfnx8rApMgGJYZX2UsEcJfHvppZdYWlpidnaW9773vVy+fJn79+/z0ksv8fLLL3N8fEyn08EwDJWivr29rYqFkhUh8uh8Pk+z2VShhJIjkclkmJ2dfUTO3Ol0FIO/v7+vZODCQrbb7UcCMaUfsyhRxL6UTCap1+vU63WOjo4UeJLnRBAErK+vY9s23/d930cQBKo1VbPZVC2l9EwFWaeljaC0PxPvvd6OUM+fkDVE91brNhlh4eX5IgUDYYmlWCrstjwrxSqlF1Dl2Sv+fgHbso5K0UDWE1nDZE3T7//JZML29jY3btxQcupKpcK5c+dIp9M8ePCA3d1dotEoxWJRJbJfvnyZr371qwpI12o1nnvuOVZWVlRR4Pj4WHV/0Ds/DIdDlV5/eHio8g9kfZFnu2EYqk2aFG0l8V3UY5FIRNl6pAglBRt5Fso+QywOUqAQFYA8xyeTiSpYi89drEQQPuOkNZvc75Zlkc1mVYFV9kYyN/5nOOxEiBcGAWCBH4XdPkQGsLg6YW84Ydg3iQQ2eYYEBEzJAHFcz2DcDkKi0XpL4ZsA+jB7DMdRGAL8Oow+m8RdGRMr+UyWQ0A+yYJzBSbtQ44HPS6lelQiPsEGBMc2w/4sFjMURl0OTyYhsOo4ITubjuOnYnhxMAcWE8+jV3WJvxPm7bscvmzgLH0QZh/H+64yW09cgPWbFL/2Nc791zaDvsHNkzSpvstTq2MWV2D7ANwTSA5C4jeThMMM1DM1yKWgdY3EeJPYNiQ6YeevdjYFs3nwTkJtfrAJnR7UA5j24WCbSOs+ESaMzDRBPAHtIJRYR+owU4NkHrLzIUDv/VbYTiz3OKPUDG7zHkuNA9aPvkKQiUBiDi7a0E5BNw57XwOrDLEPQieA7R7kroLZhEE1lIp7Vlj9sKwQlKddGIzgwRAapdBL4KfDnzXeirKfs8PfccwQFEeckK12XBi5wDSU+ltOyEZ7sTBm23JgMgxZcssl7GNF6KW27dBrzzQE7hEj7L0dtyEeBcsOA9TccSiXiEdCk3HKfkt27oPvhkFxAyuUmSedkO0O7BCYO4SBbB6QCaDQh/bL1O79Dk/t38eegT88m6O9+kPQeQb2HsDhBpFiQC4DJw40IwbHlxMYxxN8DNbnA26+4yyt578bVs6GwQWjFpzcgt4mTAaY04D42CE9amAPR5hZi1K+T/UQUreAB2+1vbfCIXJj4Uf0vLAuYRhh4SveKTIMCvQZ4WMS8WLMFEYk4i6jMVijcFp1DsCehVgZomWwFj269wb410Nru7UEsR44mwmmfo10d8xk/wjDCohbYGyE2XnTAhQtIAnmOcgnQ8V85A1INW2shEsm06HdMJgQYUKGMVMSdKl+A35u+BaA7kwmw6c+9Sk+9alP/bE/YxgGP/MzP/MN9VXUD5H16SFKwvDF43HV51JC0YSRPi3J1v8sm1OdNZaNCKBCf/RgJt2DprM1emqygArgEWCkM+wiexPGST6HvK88wE+DB91rrANxHdTJJkbkvwJm5Ofkc8tnlQ2e+HMFZMp4yENfen3KOOjSa92jKPJq+SyyoRa2WgfOIq/Tg+YEhL1deyg9YEveWx8PfYzl8+pMvc5W67JwnZk9LZHWr7Uccl0EfOqyceARFYMOSh3HUSyyFERkwyf9jcWbLJJ53dsv8nEJrZPrKqF00g5MZKyy0RVgJXNdl4a32+1H2pDpfsrTDLMOgnXm/fS46P8u7JxeeNKv6+lrpR+nX182iFI4kQ29sIOu66p/E0Av5/qdfLRaLeWPFiuFbKiF5XTdsN1gqVSi2+1ydHSk5PvCwAk4ls4BMvbXrl3j/v372LZNq9Xii1/8IhcvXsTzPHZ2dhQgiMfjzM3Nkcvl6HQ6qtAjEl7XddV7ptNptT6Vy2Ul4TZNk9XVVfb39xWTLd7b2dlZ3njjDdXnWFh4HdSIhUiKrYVCgUqlQjqdZn19nevXr2PbtipGRaNRut0u9+7dY25uDkDJ7+U+3draYjgcqrlVLpfpdrtsb2+zvLzM3Nyc6mkv4yzFXEkBr9fr3Lp1SxUwpQgpWR4vv/wyly5d4sqVK2QyGWq1Gr1eT93vQRCQSCRUWnkmkyGXy1GtVlVhpFAoKGm4tIgUpZckX8t8kGeBnIsUy+Q5Ksy92JH0sC7dTqUXb6QgIMGO+vosgB9QgFIAoTD68nyR4qMUO6TfuOd5rK+v0+12qVar9Pt9rly5AoS5LxsbG8RiMcrlMs888wz37t3DMAwODg744Ac/yHve8x7i8TiNRoOdnR11H4ifXIpW+lq7ubnJxsYGgCpsSOFCirG64mg8HtNqtRSLLIVrySCQnAUZEwHxApxFSi72Bz3DRFLsfT8MRxR7hARMSjigFFz39vY4PDxUeQnFYpFischgMGBnZ0epS46Pj/+vW6z+bzraU4jswCgFiaUwZDs2CpONnQ+ECmDn81FMoEQHm00mpMmQxZqkSVpdhk5ItNqpkDULxtALQvty7lXofs7G38vh1iFYGmJdDFXC7m5oIe4tu0SdDrNRyE2hsw2JQQyDET2GJLxiGJoVn4YAKz2C0RB3EqH1Dqg3fSL3kviPD6lcgdzOhJ3bN3j5sRjuB+YhVoTZFXjjOssbLdr7Buv/f/L+NMiyNL3rBH9nu/u++u4RHltGRO5VlapULZKqRBdCCAEaa9poQDbWM2YjjC+A2WB8wcAwIeYjZmPoA8Zg0G0aaKlbI3ZKVahKqqpMspRrRGRmbO4evt3rd9+3s82Hk8+bbzhJ06qRelSpY+bm4eF+7z3Le97z/p//8pibFEYW6UKD0iuRYjnxjoMzsoAFYwtStyGsWSzTVzAe7XP13X/FGgOWu5D8KAB8YzRk8Oi3WW00owNfNDFmU8KVidHvk3jSIz73cGJg+SP8ypjkqMv8+Amznedg8xXoz6OTHm/BpB15wAnx1+oczYtc7fQpffAB3VwSki9CmIXyAlImtA/h8NehdAvC56GXAdaAMQQOzGIROJ6lIFWMVAKtLAxzYNSjKsvYAKcAcS/62Y1BbBnFyU+X0WviDiz8qKGzZUSAt5yIdMqOBaEJxgqSWVgmIvY7kYCVGXkMklbEWpsfgeNiPOozt5hE8vClDVMf4ksIvUhukQzBDaMiix3C1ICRD0sr8i54FnQnUWpfPBUpBVYTMAcY2Q+JL96jePweL/faOO8vOTxxaJZg2jRhMICrA3DAq73K765OKDLmuLKF+5kqyQ8esrG/5J16hid/8bN4P/aFqC96tw/HbxMbvUup9ZBbqzn1VIA7j3bXMiCwo5D0yR04/R2TeQ8SsYD0ODpNXgHMXPR3YSciyJ0aLBowYEonNSQf80gM4nhBDKvvMU35BEZIzg0Jk9H9s+xEIfBWCOkUeBPoTlLMLJ/ZE7AndZzAwDZ7lAhInxtkByHlXZg7UYJ5IQ7xJ1FNZLED8V3IPgPWNnS+GTA+tom5JiWGlEgwxeaYMSnCyML+A/A2v++g+//ITXxUwngKIyOsqyzAxVsmix5hLfTFt/5v8d4Oh8OnKtniAxZQIq1gpD2KsBvwsZTStm0VXiSVb2HkdK8doPzhw+GQ0WhELpdja2tLPfz10ClhEwRw6p8nQEWXwHuep4CcnDepvkt/UgHcwjAKmyGfJQ9wCS2SnqEi6ZOFnO5HFhme/F4WKHq4nPTRFY/xRb8ufBw0I0UInS0WsCbKAx0YAk+1mhKwLUDzouxYWApZTMp+6MUN4D8D2/JdvHq6pFnAsYwzkbACipWQ9kUSsDQej5W8W2/5Jb2AhQ0UtlqYOT3xV/z2ksh/UYoqIEJAv1xv/bsUCvTChF6c0s+Fvni+eF6koKHbA3RLgn6NdCuGLo/X71k5dzJGZGzJZwnIEgm9YRhqHhAA8GlnuhuNhppn5Jiz2aw6lxsbG6qNkgQoSYFQgKc+V4mCZW9vj06no1hEkaM/evSIo6Mjut0uv/Ebv6GYa4ByuazaRI7HY+VtlnlWxoeMDdk/aYNnWRbNZpN3332X1WrF4eEhpmnyta99TYERKSwtFgsqlQo7Ozvs7u7y5MkTpVQRr3M2m1UMqPRrHg6HTzGuIkWWdlKDwUCxtJKbIOdSJPxSuNrf31cqk8FgoBKtZ7MZiUSCWq2mzmcsFuPw8JDt7W01p1mWxebmJkEQ8OGHH3Ljxg3G4zGFQoFqtap6ect8La25dH+4BHvpbbYkCE0+wzAMNafKXKqrT+R+k0KJPnfK3+rXTe41UebIe4nXWDJFZD4V0A9RUUOesWIJWywWHB4e8u677z4loZbnG0QhrNIirtFo4DgOe3t7VCoVdnd31TP3lVdeodlsqpZdX/3qV/njf/yP02q1aLVadLtdut2uGvMSNihrB7FFzGYzjo+PcV1XFYmk1ZycEzk/uhJO5mJ5BsRiMVVIkDlOxrr05c7n82pulCK4ZG44jsPa2ppae4gaTEgA2R95hiaTSTY3N7lx44YqNLXbbUqlEmEYPiUnF/n7p31rfMvA3QixquCNYV6EbAGcYhRcvZGD7tmS5Xs9sr5BghYrcsTJ4NghsXiUcWX7kSfcCqJQtf4e9NuQvg+JscfQaGEvk8zegcUxZLrg/UqaJ+cpZqFFdQbn19uUftJnvgHhfEa25TANl/j+JGJdw48k0VYI4QqfJGe7DpVLLukHKYzRgsxxwP634viHReoP7nJu/ge8r/1p6HZg2mJeD0nNQmrnA3atGOu3PewbMH4b3FnIYHfJ9LmIjD5eh0m8DOXnsXuPuNQZkDyDYREaPrQ6YBDwzPB9eqOHjLHIDpZYQch5Io6zcimFAXMryvOa+waMTeq+R20+5vHBh6xiDmR2YJ4AtxMBytkEEg+g9jLD0WcZB/+RazGX8eEDVtsxMJ8HIwN2HDb3MIIPCafvADfAHcOgEPXq9ueQSEJyFYWN9UvwIB6FmXnxKFXcciJP9XwR9aRK+uAsI6CeNiL2eeFDLAFzA8ZA3AQnBDuAZTwKMMuEQCpKDo8H0TUyZuCYkUc7NCLGPP0Ry28R7as1j2Tm5kex2RmiNmDuIjpphh0Fo7mxyD/szyPm3koBTnRc/hymh9B+C3hMKnHMteEDNrpzSsNoN47mMPFtao06sXaX08R38K9tQP4aWDv0Uj9Cz13BK7ewTt/lhX87YuYmefwLPwl/4gvQWkKrDd23qXe/yXNul60xrH3UfawVRKr4VSdStM8MOLtj4J1kyIYxZs6QQtGFdQi3IdaLOooZ8ShDzgPCJSSNFVt5j9AE158TM+dMFiaTSRYbC8sesVh4URe3cVSPyMbAboOxn2ThbbH0XMxlmglxYhxST42JJ0KcAMIjCGuwSoARQLIN1hlYG9HptjPRcFx/FrafC/jwdwLab9iUegFhsKIcWBhUgBWm3wemv+c554cadE+nUyVnEwYPPu71K4uQXC6HZVlKHisPd2FSpXqts8g6Gy2LEZ1R12XjF0G7MKjyO/muAzod0OgydFmQyIJoNpup/dKl1bK/cgw6MJRjEpCp77P+mQIMJbhG/1kWczprDh+3shLQLgsLkRvrXmN53UXwpZ8n3Xd70TuuS/V10AYf+xl1wHyRUb3ImOr7oP+NLn2+qA64uM8XgefF99LP3UVAf3GsyGfooWiiMBDQLYtmuWZ6GJsut5bxLudF5K4X+7brBSeRi+o9vfUQNP0zZLvIMuvnVv/5oupCf60Uvy5KvPVrIddejke/Jv8lxYqMFVE86F5vWcxe9Hh/mjc9mCyTyVAsFoGPgy2LxSK7u7tqDg3DkEKh8NQ8I55aGbN6KzbdLhCLxdja2qJer/P9738fiFqWiXonFotRLBaZTCZ0u10loQ3DkGw2q7ymetFSLAj9fl/N361WSxVUvvWtb/HSSy9RLBa5fv26UhVZlsXW1pZqXXZ8fEwqleLy5ctUq1VVvBM2WJLQHz9+rBQfIt8ej8ecn5/jeZ5qDSVeWoB6va6UP4ZhqKLFeDzmwYMHKv1aVwQFQUA2m2VjY0MpTUajEZPJhFQqpRhK6T9+eHhIo9GgWq3SbDbJ5/NPKafkvhFfubyPeMhFMgwom4/kJADqfIi1RELWBLjLJsUHYW5FWh6GUbI6oMCy+Jt125aeo2LbUes2+Tt5JpumyeHhIQ8ePOD8/JzBYECn03mqg4k8c3w/agsnxSXJMHAch8FgwPb2tgqNzOVynJ6e8ujRIzKZDHt7e/zMz/wMZ2dnap9EJXF2dqaeqVKYlpBKsdxIoVOKm1KkEA+2qAV0RZfMWZ7nKQuDKCWkeC7+bAly1Z9Luvc7n8+rrBkpvkoBS+Z+eRbLNRbPfLFY5OWXX+by5cs8fvyY/f19pSiZTCb0ej0VLvpp3wadLN5gAjGDzJFP8SoYL4BVjUBA5hnY+dkQdzInaEM4NSm4Bkasg1VbYWYj3EYQ2WxtP2q7NE9EslnLAc8wsMMSsdiY4i04qcHw+2A9vsrMqhBaS1j1MLY7GLvgLGC4FjLsOtheAi/7GDtTxpstYNyPAJoRB2/KKhbQSkHBTGIdpVn4Y/YP0oz8CtePxsx/4zv0XnwViiZcd2gs4lw7nZPdmnD4LCxehGkVKIP/ZY/kdVjUYBUYNBO7hPWvQiyJ63R4ZydG9cmK/DvQycCDy2WCbJr18Rm75y4Dz6V0Bok2FDeXzPNwisWqZpDxPGKxENfwmS4hH4ONSY/mg+8RVN4CJ4aXhiCViuTYQRey57BR53h2DYJ9SuMBrcldglQGyEVgNX4Dco8wgm8SLr/8UYp2E6x85K9OedH7eUakYR5kIEvEMC9SEfCOuVFvazsGGJEHPExE6eZuInptLIh2erKMJN5LB2bTiA03ncjfnQ+BUcR+JpwIODtmJFmfheANYGFA2oHQjz4vtYoauSediCr2bDCXUd9t04FgCelYNJjGC8ibkeS9fwCt9zGXp8T8U0rTt6hlRiziLhtTn9ohBH0IctAuwL5vYBoOhj0ic2NCPmbS683gaiJqUr3zZyEbEjv9t3zp+2+RD+Hrf/6z8DM/Bo0JLKcYy2M22t/ic+MuznGE/QflqKZgZWB2BN6DCHQPPUieGRjhEhOLipfBL/SJXYqSwud2JFhIJqL6gzmMhnWY8jB88HKRZ9tow5yAOEViZLHNMeYE+uOPOrzlo+5rpg1GcklivsDFIp4+Jl+dssh64EcKFtuIIgdGb0U1m0Q3ai8/bwMtyKajXLzFGPwiVL8C6Rdg8j2Po29A/6GL2ZkzDdfpssQJbP7IgW5pByOV+Fgsxvr6ulroSFqveBFFWicBQcIY5vN51cdTwJJUi6UXKzwdmqWHW8lCXkCEPHSBp/yp8vfSAkTaMYl0WA+sarfbiq2XsBVh8ADFXAqTJ6BVFsqSVi4BN7pfWH6+2L/5YqEAPmZEZFEpxypAUBbE8pDWGWcd9OvMu86kyzkToCcLR/HqC5MkixadvRfwLwtX+UxZrMuCRQ9hg497lcqi8eICQ9gCHTjK/oq8VAe+chy6x1nOpw7KZ7PZUwFE+nHrzLbIV8U+ofevnc1maiGsB6WJTFCYOBkbupRc/Jh6wUjGr7DzersveZ0oHXSf30X2Wq7Rxd/J+dTPgw584ek0cxnX8qUXDkQ9IYBAimX6eJexGIZRm6jlcqkWydPpVAERkcx+mrdGo0GhUGA+n6u5QHyf4tMvlUpUKhU6nQ6AOq96gUikszKG2+02q9VKJZvPZjMAvvrVr7K7u0s6nVYKCpF6X7lyhZOTE05PT+n3+wo8S7CfjENhj4WBk3GfSCSU9UZkxN1ul0ajQT6fV62/hH0U/7fruuzu7qr3mk6npNNpqtWq6l8uqeqXLl3i6OhItWcSNcl4PFYsq0iCy+WyYqzlHtW7EgA8efKEZrNJrVZTXTZEoi/dM5599ln6/T7Hx8c0m00uX74MfOx9dl2XbrfLv/7X/5q/8Bf+AtlsViWCy9zmOM5TuSKiNhKFjMxZoiKSuV0KFLqlRp4honLQPdoSLgbR80dsJ3Ivy9wt3Sv057KASOkiIBkl8jyTXt+//du/zYcffqju1Xq9zu7uLhDNL1KgXC6X6v5OpVKqTVelUlGAXiTXlmUpO4CA8p/6qZ9iNBqpsfvo0SMajYZid8vlsiriy/mVed62bTVmJYRN7EEyfkXRJVkpUpCR8ytqsclkQrVafYoVlzWLPIfEHiJFoEqlQiwWYz6fk8/n1fEJk64reTzPU2oiXdkkKqjbt2+Tz+c5OjpiPp9zdHT0FDv+ad+aGBS8NAsvIHkyxZ5GYWiJ2zDKRmHhuWeh8mXofA/oBZj+CDsD/iWYZCO8FUsR+XFDsGZAOwqTXtXALJnMRtC45bH4k7DahVXawoiPic9NEqsJme0jas95zN6C0TcyDAZLmn4MG4/Ytkcqt2K0dMCdRvJju4zTXlAu+bhxMMIsiaXP5HRC0s+yoEvMS2GcGdBoQT4LiRXD3TJvfiEkkTknuenRtqPE9s3LMKvAfdPkbFpmnN4grHwGaregfwZLk3Z5k9kzZ1y2liwDsONTzIzPJBVyNgb6YHuRVzc7gWIV+gmDaS3BdDrBXEHGhaQbhXsXQ+DIxWu6BDUYrJvMUk4UcrYYweoDKFWZP/sVHvQ3qBx/i0xjwGjvHhidCDSHZQw3RX76Jv3JP4fk/y1qjJ6Zw8qJKNSUH2mYDSO6RgSRVD8WgjmD+ArCWeSlNksRI43/Uf/rZSQNd40oGTxmQOBHrHgiFgF2VtGFtw1w8xEQj4dALALP/jKyB8y9yDueA1LjiNUO/SgIwItF/cN9O+obnghhMofWBLLxSG7uZaPm1if/kczp77DX/4CUPyP7DBjr8IgoPL4ygFUBlqsooXsRQiOfxAl8dv0x6fUQK7YC7xRqLZi4YMSw+t/nS/e/wQvhjF/7So3Jn/ksjBYw7YHxIZuPvsfnDluYnUhdn92N6h7OBOIZGAeRpdwgApZZJ2Tl+8zjQzJJg1EqypNj9FGWQhFSPcjMIqm5cQuWA/APDewwxLJhuICx51Alh8mMoObhzSE+NEmuAoI0rFIwz0LyUkB21mSc9qm86BNLwzwOeT+y1w/GkGxE1ohgMxIp+G3wziA9BNxI4dJPRjWOWBXMNGx8JWrF3vp1WLzW52hgYVLDJgMc/p7nnB9q0C2JvLIYj8fjFAoFtagWJkUWA9IvU9hkqZ5LhVn3YMvC6KJ0WQCQzlbKpku/5Wd9k8WOLM50xvvil8iOpRWNvljSGVnZPx3cyu8EPIvHWGeUL7Kt/yXmVpf5yqJMf2/5WfZNBz0Xvz6J5RXmX/fIy7mWBZN+fi8CO12+p4ftXPQBX3yNnFP9fOnMrM7GAyq8TgokuoddxoRI0XXJqc6SC+iW8SXXRoCLjD29kHNRbSCgVRgsGeNy7gW46soMeS8pUOhjQrcTyCLtf4vNvzjeL6oD9PP8Sf8n10hXW+hsmHyXe/Iiy60rRuS8CsiQhaK8nxSKBNz5vv8U4/dp93QLi9bpdNQ91ev1lB9XANva2hqJREIlRDuOQ6VSoVKpKJ9tGIacnZ0poGQYBjs7O/i+T7fb5caNG1y+fJnRaEQ+n1d5DxKw1u12efToEel0mpOTk6dY2Ha7rSS1EMlgG40GrVaLZrOp2nvJPSvhkFKssm1bSYSDIFCBk6ZpUqvV1P1w+fJl9T5BEKjUabkPhImX8yC2ofF4TKfTYW1tDduOemTLuZW/EWZRxt54PH4K7IiSRZ5FAgANw6BcLqvwQpFmi29avN/vv/8+/+yf/TP+8l/+y6RSKUajkSoUiq9XCqEC8PRip/5/erFK7i0B4JJ/IkUr3/eVDUAPWRO5s4BQXcFwcnJCr9fDMAxlPRIwKVkryWQS13XJ5XI4jsOTJ094/fXXabVaKjVemHGxMUlBQ1Q50hv79u3bah/G4zHlchnDMHjrrbdot9vKzw7RvPPqq6+qY/R9n+985zsKyEtLRQlOk6KdsMlhGKpe2LK20AuCEvom7DVE86RYqnT7WiaTUeNF7rHVaqXWKbrSR2TpsjaQeV6YbAHxYgu5WIQRWX+pVFIBeKJikZZkzWaTvb09Dg8Pn5Kof5q3GXXihHRoY813COY1eu++TfxLPvMSGH6k5C38WMSsTR8B0wivVW5BYz0C3Y4DswCMsyiIzE1AF5hcght/2qfQbdO+BZ09WIzipPNLUqkTdoc5YtYc59KSRgdG/2qLVPcqRzzgkAoOBqUWLDvJSHY8twEDEgsSjT7VFjS6MDEWFHwfbxWSYkwcjzR1sp5FdzwCJ4fRHhNvdcDLcKkXcNkD14HLa1CLwXdN2L+0zqrwYkT1hSYcn8DqCDt4jL2cYRRDVutR0NwVY0FqvGASjwLL/Q4M16KAuFQ/6rb1UtzjbDyhH4dWIsHANVhYc/omlMdQS0HDgOY8STgOI9Y341AMGwRPBszLR5hGi2X5Ml3vOkb/BMNowKRJuCxCfJOgdp1gNuGZ0a/wuBni7vzfIUiDO/oomvojGLgoAYuotZdhRC2u3BAwIxm5YYK5iiQLjhWFoS2dyLBvhpFP27YiDbK1iCTkTj7yFATTiAHHi9p0SZiZu4gAu+F81JO8DbEWVniXRHufwLTxU3lMw8B0l/hxB9+J45kbYFcir4JdBTcN3QMyT77JM0e/TSm+IDGJdne6DW/GbYb5DF9cDqnZIecWuOcWfc/Cu7HCubagaMPVs5AnK+itZzGMO2Tf/h2CdojhJnghPOfycMm/LeY5/vEvwzIL4QDD32ftt7/Ny60eXgBmAWpJWJ1B2IDBLFL0pz5KAg/DSKXvJUJYmGQzHvYl8PMRcR8bQNCOClWxEAjAKEB6E2JjCBYxVosAN+eSXgezDeZ4ip09JyyHrE4h7Scwpz5mZ4WVCrGKkNyCMFjhzSLmHB9iE3CHwEaUozfsQmxgEusGeFsQ9iNf+WLqEP92Gms1ZeNPubgB+MZHgoYA7B2o/hxMA4+9by458HLMif9Ac84PNeg+OTlRjJ2kXcuColwuP5XOLQFUkgANqGqvPCh7vR69Xk89vKViLWA+CAIlM5MHmvhGRfKo9ybWZb/yGcIWzedz1UpE74Gst4UyDINms0kikVCeMZH/yoJKFsU6SJUHuSSYymJBXiuA76KcF1BgRlhI+RsdUMpxiM9NZImy6NQliToAE+ZJQtJk8aAH4rVaLdXfVPzeOvCS/ZLjFdAIH3t8Ly4W5Pj0hYjOQstr5WdZ0AlTJ0zwfw10C8MuDImuKtDZcrn+Aup1wC+LKN1LfrFAIIz1YDBQyd7xePypfq6GYaiCjTA6oqq4WAjRmX19u1iM0OWsOhst4FZ/jX7tLyop9IKCyL51RcVFibluRRAWXh9XEhgmLZKk/7IANAEJEnglBY5P+6JSrqsUNpbLJQ8ePODGjRusra2p/5eevM1mE9M0FaiV8ynzpgBgAT7VapUvfelLTCYTJV/v9/ucnp6Sz+eBaBzv7u6qeVWAhYR7yXyo38ODwYDpdEoYhmr+63Q6KqxMgLaA5Fgsxr179zg9PcUwonZfMndIYVPmv3a7Tb/fV2MikUgoEC1KHsmpgGi+kb7XwlQDdLtdtf/dbhfLspSKQPpddzodJdf2PE9JyB3HYblc0mq1lGpnY2OD9fV1NcZlvioUCjz33HM4jsPJyQn/6B/9I772ta9Rq9WUlFiS2oXhlftV2nFJIU1A4Wq1IpVKUSwW1TwmeR0yZkQmLfOXqHz05Gzp93xyckK321Vzi3RKAJRU2vOi3tbi5ZfC5P7+Pt1ul1arpdQ6jx494vz8nEqlwtbWlpLOx+Nx2u22ylGp1+uqDVqpVOLhw4cUi0W2t7fpdDo8fvyYdrtNrVZjc3OT6XTKCy+8QKFQUOP9O9/5DsfHxypsLJVKMZvNlDVD2mzJ73K5HKlUSrXY0lVmwnpLdwiZ9wH1LNbHnVwPsStI+Jk8U2T8SRaBbmGQgslgMFBjzjAMhsOh+mwp4A6HQ+X9FnZcAknlGSHtAIfDIa1Wi16v91SGyad1C6gypcaIIQVSzKjSne9z3euRT8HMj7CYsw3xZMTQWeeQSkBqDxbFKAV55kMwh9opJFuwkY9Y8pMqlH4cclM4T0OjCLmey9YxJF0X2zrEvjzGvAnNtoHbzTPHYkoGmzxFpuT6RCv/YAzGRx7g4YLcYEy5A90HBcLAoYOHv0pSsfuM4yH2NMNWEOfJuEcY2yR+N+T2dzxSwym5TMj6LqTWo8TmeTLKBMvN+0w6v0usD24QMjdqkBiw3TtjcxJif4RLc8nI2/0+kHdhOw69CoxSUcEha0SyXdeDzRDWu1CzFnTTBos49FMWxySId6bkPTi205HueNSDSZ60A/Wlx6DtkbQe8CQ8Y7zxGcL1S+A9idhjMwH+BIq3GWX/BHXnf+Va71/w0PVwY/89xOuwGkaBY/4gAtoxG2ZL8D/yZfvzCPnF3AiAx1dRu6/gI1bcKkUtuxwXsmbkHUgGUeuuxRTSy4itngRguMA8qmTMHDA9cEaQOsfw3iPu3Sc+GrHOObXEgEQ2JATa06gD2co3GPVC6h4kPJuOlcPFYdwv4vWS1FoNrvjn5KyQR6fQmEItA7U+XI57mJkB2QS8N4S+AfGKz+a6T3EbSO/SLRV4Z/aQnpnC3y5R6Rzw3AdLJh+YrFkB2zfh6/k8j1/4ScLiy5AqQfNNqr/zbW6822MIjGsRED0lKqoYj2A2dpg4HqmYTcqA7LpLyoT53CSOieNHlyAEpqeQOYuS8UvlSJQQ9oAwuixWHILiEmMV9e92p+CsDGy7SbY2xR1FIgHP8FiFRRi4uMYA1wmoXoHYbTBeh+UdCyflYywMhsuQ+Dwa60YOhj2TUi8kMEOWbYvVKmQYJlmb/wjx32mxcN8j90Wf+PMRUPenUco6G1D9AozeWXJ+HnKA+wkzyn99+6GeVfUKvFSXBdAIOBPgHASBejDJQlyq0QI05/O5eqBLyq4e1AT/eV9m3RsuwPqTAK0utdXltbLouZgMrS90ZCGjy7t1lvuip1yXCkqIEjwNAnU2/uJ+6osF+b0OkoVV1L3UOuN8kWWWv5NrIu8FH/vzRNosi189IE8ke/q+ybmSBY8OoOS49f27yHLrbC6gAoZk0SmstITbXZRqynUTECgFCJ3pluKGfJYAIOmPLJ+vs1EyxuR9LqZ8yz7Kceivk+slmyzedMAtckr5nIvX7qK3XQfdF9nrT/o7uaYXz7v+mfpxytiUa6WDbf19dNWBXjiRcS3nyvM8ZU3Qcw704L6L7PqndROprEh3ZY7r9XqKpc7n82ouEAAjmzDhIhkWO8xoNKLVain2eH19XYHot99+m+9+97v4fpQeX61W+ZEf+REePXqk7iHxjYsFSAqK4nOVgkg2m+XKlSucn5/z+PFjcrmcSkEXpr7f73N0dMTZ2RmJRILRaKRsR3t7e0ynU7rdrurf3el01OvX19eZTqe89957mKbJ2tqaOgfC9IrsXlqHSSiZyIeTyaSS29dqNeVPz+VyLJdL1VO82+0qSbS0jBJvs23b7O/vUywWqVarFItFXNdlMBjgeR43btygVCrx4MEDFVL3x/7YH2NjY0OFwumFXglBlEJTPp9XNqnJZKJS0wWs6+yozG3y3BDmVRLggyBqsyVe4OVySblcVlYukZ1LITgMo5wAkUALOy5ycFGUVSoVPM/j+PgYz4sCI+v1OhsbGwpgClucTqc5Pz9XBe/bt2+ztrbGxsYGhmFweHiorAy1Wo1yuYxpmnzhC19QdoBOp8M3vvENBa4FpAp7LsUQAb1S3BG1jCiFRHEgqgYB9FI8HI/Hah2hd/eQOVACDAFViJX5WlQbYsEoFApKri7rkzAM1d9KsVrWCRK8NhgMVOFCQL6MEbmP2u226j8u50PS4z/N2zkJ5piErGOyII7JbFilN+1Rj8FoDok8pAKYh1B6EeJtIAa4sLGEjg3NMApiSx2B/w2DYBQjbwXY110yNyF1GXJFWPMg/07A6t85BN0yVmLA8hmf4PNQ+SDEKR+znAwIXIdasCDutOGKT7ywZBn6kT7bWMLSpjANyd8rsTN+lTY97tMjwwaXOKcQm2BNB5ihAYMcHBVxHs4pnpUZ4tOexgk7AXsvj5hWoNOEa0DuvRnd3oxCBk6L8GS9Q3oaEnszhDZUtqF4OWpZve9AkIdcB06A802TuW9hzKFquqQSsJ+GVdIi0w7ZnAR8Zj1kUID3pz6dHDQWJoV+QJoRy66Jv1oS5mL0Jg4b/gprCU9sMO0J5v4DguINqJahYEfG38ETcM8In/lTPCzmqT/4/3C1+z9z6j1hFPvLkdRg5YGfjVquxYyIwhxNIpn+1AAnBk4O/DQQwHwKTCExA2MYtQJznMibHfqRbjtcRohs4kf9uGMZWCVhmYx6b9ttmN8n7v0uG+ZrvFgfU8YjmEc27yMfHtsGVmDQCAtM8rcI7E3oH7O+eI1nPY/BoodpQtA6J5iCW4HHRpS/lgii8PTaJUjvwsKJCP1RBu7HDUa5BH4xyz3HIUw5LG7/NKzd5HT9DIwuzuFvsna8pPemTa1dY22zx92yz/4Xfoaw9hWY3cPpvEbt3/0nbt1rYRjRoSXHH4W921H9ItiF1ZnLNA79VUC6l6HeGBPPBrieQYDDaOWRyHgkP2qHXlh+lCcXgLkB41VUqDJnsMqBtwVMgD4wh6wXEk/OoArz00jaPot5TJcWQVhl0suTHE3InY8pvLwgUwJ/32K4zJDEJLDGTGcewRmk62DXPIymhdeExSrNkhwDKqzYoOxWcV6bYp8ckfQWmM9FFvyVD502ZPPgb3i45z4BP9j68YcadJ+fnz/lTxYZmoTjFAoFFUwjoTQSAiOLQlkkeJ7H4eEhjx8/ZjQaMRwOyWQyVCoV0um08g1LmrQk3opcTtK3RSIsQEEeqrJ41QHEYrFgOp0+1ZrrIuMqsjfZpP2MHmKkv0aYbd1DrQdLCejRGXph83VJsgA//b0EyAdBoFpJyUJcB2U6kBYQK58vbLd8rixkBCCKf02YBPGvyf4JgBOwLVJtAWFyvPJdPwZ9fy7KqOXfUgzp9XqsVivl+RQ2/2KBQwd/slCTfZNrdZH5lTEi50rfR9lnPZ1dwLV+/FKkkfOqF2yE2dOvkc7Qy6YXL/RCkf5dZI86cBZwrI8J+Di1/GJavHyWXugRMK3fvzI29PA0UYnA0wFKOjsv7zebzRSLKH5KYR2lpVw2m1Xv+2mXlwuIknEpqoJ3332Xvb09xfyLfNX3fZXgLS2zYrGYYtkODg44Pz9XHRCCIODx48c8//zzmKbJ3bt3+frXv85gMCCfz6u5LZ/Pc+XKFcWqCTNaKpW4du0aly9fVtdR7jO5pt1uVzHw+jWXayxFMdM0VQK/ML7JZJLFYqEYYQGxIt8dj8e0Wi0VcNbr9SiVSooRPD09ZbVaKTAehiHtdpvhcEgul6NarVIulykUCnS7XVXIlXsvm80qT/hqtSKZTKrfS3FI2HPJcxiNRly9epW1tTUFfBqNBltbWzz77LMcHBwQBAHf+973WF9fZ319ne3t7adAX61WU4oOkaqLHF7Os7Dyeo6DzMl6EVkk651Oh8PDQ+7fv0+z2VTPtq2tLRaLBaPRSD3rpE3hcrmkXq9TKBSUZziVSqlixHA4VAxzsVhUBdZKpaIKAoVCgXw+z/n5Oaenp5TLZXZ3d7l16xamaXJ+fq6KHpubm0rZI73ipYBRq9V45plnePLkCW+99ZZqiSjzVyaTUUVuGU+1Wk3ZIAzDoNfrqeNcLBYqnd73fQqFggrXk8JqLBZThRbDMFRQoMzvAsZlvIgqQNYkpmmqYsZyueTRo0fcunVLdSCIx+MMh0Pl5RbVijD1Ujiez+cqlX1tbU3dVyKNFyAvChOxV/xRYLof4+OzJElUKJ+zIj28zHvfPOLSc3PMbORVTVqQTkY+z/EcwnOItSMpbToV/f8oBvefwPy9IoPFHkNmxD9Y0Pv2mGt/ps0tC+y70P23BmePN0mGZWpLl8liQZCPMsEu/+yI3HxE48yge97E3lnQeRGml2JR6pMxj5K1/TNyrgHjy3To02GfCUlcLDYsD1KwGAUkMYkPz1kst/FjISPDpBfWcAlZxk9JrMNyBKP3oRjA0ojyvbIFmKRgNba41HRx8nDmRN2zClYUpOYuoHwK3RWcrlmsKgWgDO0xD4YNknmDdjWDW67QKdg0unPyQZ8w7jENITuekcyFkIbL4xWjJZwmYvjxOMtwydiLwsdXKRM3YVFdNEh12/RGMUZXNwjXXopk8JN70LAIN3+M5nP/A4OD3+Bq8J847/do238OVleALWhmoGNGB5eogedHBvxgCrkF2POoZVgCIjlBKjIFzz2Yr6Jzn0lEdOzMidqIGQ74s8jnbfYgdojZf5v88l224k12rQ7X8+AG0B1HrbJOk/Bm6NDJFGBpQv0SFG7C0YDC/AlmKuTuErw+OD0YDj5Sy/twGo+TNz22DZ/eChqxyL99nK+TOJ9SO53SK1/G3fpxuHw90vmffwfavwvLIWx+BbwCydH/SrwN6Z5FodRl/7Mrvn/1VYJn/luMJ2+x+9b/yJXHbfL3Q1wXZtnIL+6No9Pk+JHCo3YJ2IR+DDYWPv4bE0aLyFK/SPg4qzmZ0GDmQCYFOR/wTDzPZD6LWqPNcpA7BeMoar1uzsAcgxOH5AJM34QsjF3oj6LTHrMDFsslJiZ5Noh5DsvjFY9GH3Ir2SNLwAqfGEmG4YxU2iOxAGsCCUymQYXRymJGniUZ5hiMGRJgse1dwjjYoPe/vEV2OcK7BslSFFbf82BiuczpYrP2A805P9SzqlR4dSA2nU5Vu5LVaqVAjO41Fm+VABmpCg+HQ7WoGgwGKlF1tVqpKr88zKRCL/1rs9ms6gsurJLneSrASGfKdXB0sS3TRRZQFpnid9Sl4TqwkfcUVk/At3yuzvzK/gjDIeBbZxcFeOn/Dx+3jAnDUAUu6bJhnfHUZcFyjeRzdYZdZ1uFaZGigPSWFfZSzp8w/uIL1f3BepCY/nm6VFLOuXzpvneRl69WK8VQCcjVVQs6Cys/C2MiclI9F0C+5PN1mbb8W95H9+jLedMB7EXWV//SQameNi3HrO+rDrp1i4E+BuRzZNOLBXKdZWzIWNPHnQ6M9fe4+Fr93zrjLcyNfo2k4KIXe0SBIYBaX+AKwyNstzCMn+bNsizlnw3DUElRXdfl+PiYF198UUnDU6mUkpTK/SVgrF6v47ou77//Po8fP2Z9fZ3hcKgKl2+//TbFYpFer0en06FSqSjZeKPR4OzsjL29PSVnnk6ntFotlssl1WqV9fV1AHXdxA98dnbGcDhUgFIUP8PhkOl0+pSkVnrYJ5NJlssluVyOTqejwKEci6gh6vW68u2KvF7uTWEN5/M5Ozs7KkBM5s+dnR3W19dVVwy9f7XM/WdnZ7TbbVUAS6fTqvBaqVSYzWaMRiM6nQ61Wk0lUc9mM5rNpioYS69ksbfohcR3332XN954Q4UCSnEkm81i27Zq3zYej5nP5+RyOSW9X19fZ2trSxWVdfvAYDBQ854oeKRYkc/neeGFF9T+S5s0uV+F/ZUE7H6/z4MHD2g2m4RhqECzKMzkWKbTKAVWZOC1Wo0bN26oezUMQ0ajEZ/73Od44YUXaLVavPbaa5ycnCgWt9FoKBY/k8ko0Hv9+nVefPFF7t69y9tvv62eKzLvS49zUR7kcjlVCEyn08pmJAB7tVop0CzBeDKf6OobYYrlmi6XSxWOGoah8vCvr69zfn6uimLlclkVD+U5K2Nf79EuwYhSuJF2ZlKo931f3dOyFtBtYLPZTP0sBIRY7hqNxqe+KAlgYrMgi0GSIiEzBoQUWP6nZzh+823KPwOzMTjZKLfLOQfnFMJ51HVq0YPlCeTq0HDhd5om3YSDn4nBfM7O1MLqreO+1uUL9YCNIfTet/BYp2WGpII8i8aQ9VOP/B54fwpGKzBmIaXWgvESzqo2/kYG6ET9rP0E9KZMMy7NxBH+0qLgtEiudgCDROAyXMLU9EgaFgljymLUwunncMIaKbLkOCeXGdBtRHgxux5hMn8JwUaUeO0VwVwYuHNwklHKeXwZ9UMOCnA1De/MTU534tj5+UdztIlhDBlsF+lt3IRsBewiZJIsEytayyBK8A5XLM7usmw/IutOyYcQS0PC8ZiFBn7lFsezJ9wYdYl34ixrFeLLE6qhhzPzKDf3OSvMWKQ2MNs2lvFdmN7FWV1mES/y2KzxcuYB10//Hq1ZgrmZpz24zLJzJWqoHstB3MYYPyG1PMaZdAn8OWGiRJAs4I5yuIktwsRWlDCXSENsBrNzIu19j1SvSTw5JHBCYsM5MRqk8i1eKS+57PrMLRiPYdYCPwM4cGTDnTBBf1Qi3ptjxeZ4/Q+wHj4k3RyzE7p4JejuRJ3FkgakqnDkRGC0wBJ7C2ZpOLdNus8UIGZj2hZ26HI8yuN97mfh8h+D8zPse/8zayfvElohvfQHzJs9ktNznv2gR+GBQyIGrUsu37v9FdwX/xLOvd/i1nf+R77c6LAI4LAeZdHlspFNvTeD7AoKRmRhX7iRgmOrFXV8S+z5+MBqEHV0SwYeiWnExIfxKHDN74UQ81ilonNjN6K+2c0lLJ8YFBdhlGRuGgxiIebVJWtX4PyexWJ4GSt3Sjk5xxl6LOkQ0scmTkiFxPBlxsPH2JwRM6c4xpR0NiRVjIQL8zOT2SzDmAwLaizYYESTGKfkqeKQwSPE5QrWQYzp//Lb+D++wH0OUjWwklAphqScAS038wPNOT/Uq07xSelSVpETplIpVW2XVG1Z9EivbQEmsnjo9/sqPVxkZ7JgEnAlFXLxvwmDJiExkoQtQEYHtPKQl9RXATzyHgIwRHauS9svSnXluw5UdOCus5F6j2ZZJIrsUNgXWQTpclx5qOvAUMCbeND7/b76t/T0lv2Q4oZ81/ddD43TE8kluEcWNt1u96mWbvI+egCd7vGFj0GjsMcCvmUTAK1L03WpseyDAGddln/RN64fr+yfLNzFQy/bRSWBPnZ1QCnnW4CLMDLAUzYG3VctxSM5v3KeTNNU518vcsjiUF4j40zO1Sd54+X4dLZfLwzJe0pquox92UdZFOos/UXgqyea68UKfcwIsJH3kOssnklhFuV8ygJcFsoCqi4e36dtk8JgNptV80+/3yeXy3Hv3j0FakRCnEgkKJfLyp4jqoDVasWTJ0+YzWasra3R7/dVrkA6nVZyWgEtpmlSLBbJ5/M0m01arRaGEflYc7kc9XqdMAzZ39/H8zyldpF5cDweAx/7qQ3DeConQsK1PM9je3ubx48fK7DSaDTUONBbZ0nRUp4Ro9FIJd6L/FvmQ5krhfUWACkFHWGXddBoGAbValUB70KhwIcffsjp6any6YqMuF6vk0qleO+994AIoIm8d21tjcViwZMnT9je3n6qrZi0EJSgsHQ6zaVLl9T16HQ6PHnyRAV0DYdDisWiSt8WBUCn02F/f58gCCgUChQKBVXAFoVDEASUSiVyuZxicOXZoKe1S2FPnq3pdFp55EViLkGGEkgnuQuSLq579CW8z7IsCoWCei5LkafX6/HgwQNGoxGnp6ecnJwAkE6n1ZyeTCYpl8tKEv7iiy/ywQcf8PDhQ5VtUK/XyWaztFotpQC4du0ak8mEfr+vOp5ItstqtVIyfSl+6IoLeWb6vq/WCBKGJ0VDGcOu66pncrFYpFAo0Gq1aLfbqjihh9zp64kwDOn1euqZLYUqOTfCwMuYkfMiKga9MCvrEVkryBiX9ZHcM5/mzWFOGpcUWWqYtPCZ08eZX+LDb93ncz8+I4hFtt5EGvwklAowWYNmLgraPo9FbK9zBN15guXNPHTbMPWYzvpsUCSTDknHwR6CM7fJBwYGZSBPptfmC8djci6ssjDIw6AesaP9Axh5FsTiEcqxfYj7MA7x47DKTIgv6hh5g8KsD9MauCbLTooYIfNLEya7OcyH51zbz1GiwoInmPHHBKWQyQhSH3nVF48cWAX0d3xmM6iNYMdescpEmWG1ViQrdtaidtot26RTKhLEiwS9HsSSkfc5XiNY+wzsPAfYYGUjatTwoLoZge5FSJB/gZn5H5mfvoWXamF7kE8EJBnTqT/PNPV5Gu/9TzgsYOXTaMfpJHziay5XFwG5J2d8sG2wrP8JgvmYDF/nxvK7mFOHO+Vd3jSf57Ppe/zZS0OOB0O+nz9iOHqd7EHIuhVizA0W5ytKAYSDiMzO+iZWYDFyLQZJi/5ainaxgOekSKxW5MwJa8YIsz8hFviR3DgPlVjE7gYO2GakjvaXkad9bkF3AssEnAPDdAmz5/H8oI/jwMBaEEvAOAnTURTs1YpncAsZzHSb657Pcgq2DZcLEK9ECfgDO6Bf8PDHsN1vUxuGvOdbeL03ohZkgwbZ07sUjn0CD7LZIb7/dWoDn923tkgtF/Sea/HOMy/ivvTTxD74Nb5w5z9y43TKNAmDl2GxhLAVJX03QxjlIrbYP4ZCFyYTmI4hfQLncQiei2TvVicKcQ99WADpGqTcKGzNT4UMfFh2YdWCeAuMrSjAPTY3IB7iGhAbG1gbIYUvQj4FyfdN2lg0lwahZ+LgYtjn4JskwzghI3yuEbJDj5B42CFmBsSXS/yxjz+H7iTPkhoOIXMGrCiQpkBIjxRLUuQJgIABhBn80yu4334ImRVOHtJ2VK9J2Atwez/QnPNDDbollVMq7PIQFE+2VHnlQaQz3TqAmE6nSiYtX/LQkkWnLCqEvdQ94/LenxQgJiBJHrwCEgUUyHtcDJCCj2W8OlC7uOngRwCkDhB1xlsq/MViUYWzyYJBJLwCVoWZEQmagF6R4ouMTRaoo9FI7cNFCbMuDb0ozxaWRP5W3kMW3rKIl+2/xFbrn6ezuaZpqoW3zprqiw696CGgVJgCkYjrIFYHgxeZfJ1plveQ38n7XwT5Oluue5tlX3VGVwo4+r7oMnR5D70AoYed6eBc/u6i+kE/V7JdPF79uw5w9WMTubzcA4Bi/nRWH55urSf7pMvsdWWI5BzorxcGUwoVcl0FsMl5EEntHwV5uYQSplIpZWWRczidTtnf3+eLX/wivV5PgWxpryZhahLYJ/3jZR4Rhk96IAvgEIAg1+H69euEYcj9+/cxDIO1tTV8P0o8F++0MKkyzzx8+JA7d+6ogt/GxoYaM8LSlUolyuUyt2/f5q233sKyojZj1WpVyeVzuZwCbaJOEjAqLcmSySSXLl2i0+mwWCyUzFk+U2+dJQFrAsalICaBfWJlkCJZuVxWHQNEVi32pu3tbW7evMm7777LarXi6tWrAEpRJcXNWCzG1atXmUwmCigHQaB8yoeHhwyHQ3Z3d7EsS8mGJTVcQhSlh7TjOEqVJTJwCSITpZhYn2azmbJMidxbmHqRp4tSQMbDcDhUoE/OmUj5Pc9jbW1Npa5ns1na7TamaSqQKyy9FH5EcdZsNlWxRJQMuqJH/MidToeNjQ1VVHv22Wd5+PChal0XBAG5XA5AWcK63S6GYbC5ucnZ2RkHBweK5ZbC0tbWlip0SBFDiijCmssz0PM8VRgdDAaE4ccp5/F4XNmxxNLheR7VapV+v6/uB9M0Fcsuc6JcO2mZKEVheb6Nx2NVaBJrgL6mEID9SXk3ujpvbW1NFWc+7duMFuuk2SCFx5gVQzxCvLDE9M09xm/eI/dnQoweFNwoCG1Vh8QIliUYpGG0hPkA1sewOQ3ZtxMQM8E0sAybjTBFLmaQnIQYDyDlrdhgTI48dvoR16/NyE9h+C+Bc5PtmwGpHWiMYTMDXtXj3eUYXDsyBFsmsYcTRt9N43d3ycSGbF4OCPsTrEfgZjzshUUxjDO7PiG8BbE3O8SqHYatFVs+WJk5yQTkeiaDUkDXgmDisAgD4p6P1QEeQcYEYwcyt8A6hZELBxvwZnyXwfpPEIbbEEvheb1I9p6LE2ZKULoBMScKGJsEEJ9AKgX2OoQTaE0BB0rPEi6WjGYuhWSf+QpMZ445f5Ng+y/SuPlzpN79dRKrBourVVzKzBN9DoJzNlYhe26Tw/ghc/u/YxLc5u7s17kS3GfHP+S0vM1r5nW+/2RMYnhMfdcnYS0xO2AnIhV5vAvDhsnMDokZIWPDhqRPpe5STUB1d8pz5TY5C9KZKM9u1oWzHNz/KIctmYGFmyQ5NrhuzWiEMKyY/EQmIBnAfQPuxwyCRIi1MAiGKSxngjsGqwVrl6GXgt7IYGcVYm6Am0wREKOfhe+3o+F00wb7PlQ7sLoEKxdK7ojkAEozcB5BiRn+6DXayxZB7llcz8FsrwjOoVSH9YpL94GDMS+Rqj3m7s0ko1e2Wb///+JPdt4nuQjw65BYh2wYBbWZKeh24dyAxAaYDeguIVhBehHZL9JF2ElH4frZ1Edt5N2oUEUiKkQEnehe8VORDd5xo2D4YSJyTmQ8sLMB8fhHxYd8QGIryhYIClC57dIfPiYcpVlSwmRI2svgsobPjBAXhyVZasywMcMUnhdj5PVIPTnFDw0mxJmSIkkXhxYeMUyqgIFJiMsAgxkeWcDDok781CT85oeEJZfpZhQlsJ6dMJ1nefcHmHN+qEE3fAysZPEtMj2pVluWpcJxdOAr4Fd807IoEIAiCduyCRBIpVIKKApokdY1OtMoIEUkaML2CQDW91kHO/rny/HpknSRmumyXx3Yynvqslp5CEsa8draGul0mlwup3xlOggUllIe8rpEW9hbWSiJPE33VcvvL7ZnktAWnb3Uwawu2xYlgJ7yrfvEdT+2vumyYxkbUnSR83uxTZte9JDiiix2RIKns9N62Ji0O9MBoy6B18eCHLO+EBIALefl4vHJGNWvs16EkTEBHys/9GupH5u+j8KsCxiVcamH3Mm10L/LNZD7R1ca6J8pY08KUpKarDPz8rcyXnW1wEVLgx5aJ1JUAWkyzuRzZSzpBRD9XEDEjH3aN2F7pedxsVhkMBjQarUol8u8//77vPLKK2ohbxjGU4FrUtzo9/v4vs/GxgZ3795VzN/Ozo6SrAq7KPfLeDzmpZdeolqtKn+qAMBCocBgMGB9fZ3JZEK73Vay1vF4zNnZmQJzAp4FBI1GI9VS6ubNm4xGI9rttpIyAxSLRcIwCg0TRltAijCdg8GAWCym+m1vbm6qYLft7W12d3dVsVXmVpnHZDynUimliBIAJv29p9OpUj8JmD05OSGVSnHp0iXu3LnDzZs3uXHjBg8fPlQgUZhsy7LUvo/HY1588UVVWDg5OVGJ/cVikfF4TKPR4P79+wyHQ6rVKtevX2c0GtFoNMjlcgp05fN5NV+Mx2O63a7KP5A5QBjdbrfLdDqlWCxSLpeVN1xnSPP5PIPB4Kn5rFAoKGZaxka9Xmc6nVKpVDAMg9PTUwX+SqUS/X5fybGFwZXiUDabVT3VM5mMmkcymQxXr17l4OCAyWTCw4cPAVhbW+Po6IjLly/z3nvvEY/HqVQqSokhSi0ZR7ZtMxwOefjwoSrUS1FWinRSDJDnL3ysNtOLzHIupQAlawUZd7IeCMPwqRZqjuOwvb2txvBFJZbM9TIPytwmMnQJ5xRLhXjUs9ksu7u7ak6MxWKMx2NVKJH5fzKZqCJUMplU6odP+2YTABNiTDAZUGdOhwTHDFifVnj0H2P8+J9Y4mZhPI1Crwc2FNtQ8KG7AZkA4n3ITOAZa0H70RlTO4fjumwFRSwzYFgI6dahcAXWzkK8aYtxocmNn2xTuQqzBZgtk9G9deaPhxRSc1KmxfqNFT+S8HlcaTGp5KLY9DEYZx6TQZFZaFG02uRmMF8FpPMjRnFIr+Ykt2ZYr0B11CHWAe+ZkNPCA/xBksogJLy3xzRccL5xxioJqeycVRhiAokmjE4huQvZHJwmYH0v8tO+lS3R3/7zsPU1WFgQN8FZRHRo6IDpQzwVNV92AoiPwE1GYWYDE6YpcAyYGcAVSPRxvQHBdETixGeaCrl06S6nd36V5TP/Z6bXQ4xH34qSwowE4bRMvzwisGZcG/t8YfFtXlummFb+Istajvfd75E/+S6XBgc8tjdZFF9ifdBi7+GMt46jDLWDSg7jus3Geh/fCygmwVxCr7IiUwbTACyYLGC8D/0UTAsGJ/Eq03gGO31C2l1hdyNb+KiQYVjNsLU8IDMz+dBf45uxCXuVEdMASoOQlAUN0wFrFz81p1Fqc7XrsxhDZxtm9SiR3KpAwuhQOw0oL+GhCUYJlqcwPY/6YPupCOxnXZhMIcxCrQwdF/qZAFYrsLIkkzbXU3BgwsSD/f9kYHTybNDm/eKMd9drJN56mx87OGWtEtLywZ5A+jwKa8tcgdQaJAdRD+59D2KdyALvmxDEIW5EQDSTjfpa+w4k4sAYwo/amLur6DupKBsh433UkjwZ+dWtUdR5bWlCwo1eH9bAKYGXhtMK3PwibLse/deXME3gY+JRxcfBwCckTYDHih4+JiE+Pn0c5iwDizkxpsQ5JCQkQZUKHi5ZTtnFwfzofWIUGJMnTp8sPkaYwzrYYPlbR5T+eMjKgWQuJN/yPnlS+a/OOT/k20WvqEgqdRAxGo0UuyUPM3mgCzM+Ho+V/1YkVvK+OuAROaIASEBJ1GWRKn8rD28JUpEF/0WJsoA4ASkX/bICPnWJvM6Eih/3InDV226JdDSVSrG5uUkul1MyczlG2eS8CejWmXBZRIqCQKT2Ii0XRlIHuTqgErCng0Y5J/LZsqAQX5wAWwF7AhZ1NlQHuiKVlPcVhkm83nofbCkQyHiRaySfI8y+nB894EzeW1+IftKY1OXz8nv9eunnQsagAO2LoPvi2NfBgF7Y0VlwkVbrrPTFlnByvQS06iz4xftAL7To8nI5Tt3WIDJIAd2yH3K9dXm5HJ+AbvlcKaRIcrz0mRVbh7Qn0i0UepFBjkWAkjBWfxS2Xq9HEARKxgpw79499vb2lBRWPMVSpLx//75ifcvlMsfHx8xmM3Z2dlTbpul0ysbGBuVymXK5zM7ODoVCQYWs7e7uUq1W2d/fVx5lWdyL4khY99FoRLFYVAynAItms8nt27dVQrSwmfl8nrW1Nba3t/kP/+E/cHBwoGS+pVKJ09NTdnd3VeKztPTK5XLUajWazSa+76s0aAFYIlGvVqtKWiv2BOmNLcVEAVpy78k8LUULed9+v6+87uPxmPPzczV/CZhOJpMcHh6q/ZhMJqpIsbe3h+M43Lt3T9mXEokE3W6XbDZLs9lktVqRy+Uol8sqyfz8/Jx0Oq3m/DAMFVOvF4qz2axq7yZe6wcPHnB6eqrmd0lgr1Qq5PN5xXwXCgVM01RFHfhY6XP58mVc16XT6agwsXq9rhRlIisXP7FhGGpMApTLZUajERsbG2QyGY6OjtQcIAWBIAgUix+GURhZLpfj8ePHTyXX7+3tMZlMlHVCrk8mk1Hzv23bqs+7pOhLL3HPi9LUpa2XKNU6nY5ShQgj7jiOUlbE43H1nJQ5WIoSnueRy+WUekhyBaSII2odkYfL/TIej58KuRMvt4SgyZwvLLUoAkTZIEUyKcTKXCtjUqwiYsX5tG8JQuZ0aLIiRok1stg84S5zJuwRfBDHaUU+2vkCSklopOHDd8C9b5D570MSl2D4Oszvwe48JBn2aXUtxlTYxaaceMTyZsjhNaAOi3RI9o1zdq9C9TbsvwXNDw0KRyks1pgsPGKLJCFp3MQh6T7ERx6TggEWGLMuhcUCK9XEG09IzSuM7ndIlpckMhG2zT2zZP4y7F82cP+9TfnfbDEylsyfbTK8PmP2us3Vlk282qe0CYM+WIuQ1DNgbkM4jTzrwTUYlODch4ZvMrI26VT+GFRfjFK83RiMvcism0xEBng72k/GKwgNSFkwsWAcguvCeAl+CLEs+FsQa8HqPQoduNSEwRwSfkjcfIsH4wD/hR8jTP1pOPgednCHwE/ij0v0rYDT0YKv7q14JfPv+M7Cw01egviAYfISs25ALHuO0fw+nhdSSMLNGKw2oOVNedLKcpa32fRd8l4kE79UgdIUaMAq+Kj3+iUwK/AIG28nThgL8B6YZE9huYgY32q3zSrsEFSjPuWssvSHaZKpEc8Z0JxBzYYyKz4M7xJYK1647LMTg/Y5pDpwtR4VZp6MwZ8GJAKIn8KaDYMkzE24cRnmZWinYKsMd0ZxOhsVrEyT0xg02ilG8wSkYiS632bXGzObGcQDi9D1mMwNsj7cS4348PkE4XjMl/6lzca4xHSnSxmYz8DPQaYEmVHU7su0odYBrwGzDCSzkdw9WYjaenkGpC7BrBgFnmWBxBl0ppB8NhoCi2YEuJ049JswG0C8FLU/X0wgZkXuCcuETDnKFChaYC9h34deISoCDE8WeI9dZl4elwlpTvCBkDouM8YExMjhYDIHEhSYk6VPlkPSPCbAJEmTGGlCrlHFZ06WY2IUsdjGY0mcNhZdAsD0cwT34xg3o3T02CbYh9PI8P573H6oQbcOhuBpr7CAQfkSFkGq3AIUZREvD2MBLbpkWcCNLOoBBTTku4AWWYAJgBGwKpJHeahLpVsq+lJVl8AwKRBI4rQwyQJW5KEpXk0BKbrcXR7k4lWUBZgszmQRJ/uss+RyrHoCunyeAFLxCwuglAWJLGT08yfvqxcT5LsUQuRvZfGpAyb5t3wXYCX7qXt85X10FYRcQxk3srAXkCssmEik5ZzozIL+dTFLQBhgfZN9lPMoixkdHErBQJQEMr50i4AAVblGOhN8kTGX/Zb7QY5XgLbe7kzGi/46uXZyXPq5k2ss95h+ffRN3k+/hnI+hF2RayXj4aJE/+K/L4YOykJRrqUUoOS6yHcZY3Kd9fOoj9FP4ybAUqTFElAlicxSnJHzGYZRYGOr1VIdGkTOL4UrAYEPHjxQbKG0aLpy5QrXr19nOBwShiGNRoPj42POzs44Ozvj2rVrSl4r11I+X66hzImFQkGFfy0WC7LZLL7vk8vluH79upqP+v0+xWKR2WzG+fk5jUYD27a5deuWAjXC1IsUXHzKAkLFW3zz5k12d3fVfCIsp17oFCAmfllAFa30cSY9rYvFIu+++y7NZpPz83Ns2+bJkydsbm7ieR77+/vs7e1RqVRot9sqDE56Xvd6PdWrWvpFi5TZtm3W19eZzWa0Wi11XbPZLKPRiHq9/lRbNvF9t9ttAPL5vApRSyaTDAYDRqMRlmWxtrbGZDIhkUioQkkikSCfz9Nqtfjggw+o1WqKGZW5M5/PE4ZRUr5YmEajkWovJudTGGdRYel9qEulEqlUilqtpq7t3t4em5ubSn59fn4OfNwWT0LxyuUy6XSaYrHI48ePVT9z6a8NH8//8uyXlnLr6+sqQE7uDcMwFDiXoqG0YUyn06ooLf+nq0U6nY6aP2ezGfl8XmUhSGBbMplUHvHVaqWyEWKxmFIodLtdADX2AKU6k/eX6yxFYAH1MufL8cjaQOY+6fEtNrtKpaJyBI6Pj/+Pm6z+/7QFeGSJYePxPgsGLLhhNEiEBl0CbgRRC2fLj/zbcyCcQefAZH4vRuw/LVh3YfkEln2IVWAv7eO8P+LeLM8Qh4zpM7wD+y0wrkDqJbAuRW2dzx7C8XctGt0cZ+S5Ro44RabMcUnhxUyMfMDKT8AqBgZY8ZCSBaYZsjBMsuE1Fl5ItnCG70N2Aza+Cv+qGOcDa5fwbMnm/Ao2E5Lvdzg7CMhPDJKFh8RfDmltgXVqEI7y+J0x6yWfZRLMLXALUQhYmDZ4ElzBf+bPwe7L4KSiQDc7F8WYL5LghZCwIu321IsYb9KR7LxoRmlawwBybmR0ns4jyby1jt2ZQNPnww5Ul7B6AMMrPmnvHUYHKdj7KlQ3oH0fIzWBZAxrZhEP4bAHztaKy8bX2Z9dxkvOyfk9FmMb7ABrfUlzVuHw/jGZDqzWYDfuMx6NMGsGl2KRjDpxHVoraB/DyIGJAWEdcnlYzKGYdLnWPGYygreScQ7XEuQnC/IJMCewGwtJxuFB3oDWOaW35/gWTCrgrUPHgroHa/lzRiFkZxBPQNEA8xSGZxHwLDswiUWnZpmAUioC3tW1qF3WQRaWZbBSMKyVCAubPJknebJ3k2AzBcFrxFanXD2fc6kX0uzHCN0Ci8GAGT4lZ8DitodXSVN9Z8L6KsHQCMkd2SQTHuxGgHdVgOUcJk3oFiHZgd1zaN6AJWAvolbkxhwyU7AK4KShbEcd1WYupInam9teFK42WwNysNyHYAgdH4yRiTGzmNkueTNqzbfwwbYgtwZFL2LWRwmwhhAbwNJP4FAmh4uJQfejtPkEu1h4hAyBFHMKQAaDGHMSnOHi0KbGmCkuIXkWBCzp4zDDpIvDgBi1jxqCJYkTkiJGMK4wvXNC5fOwUYK+Hf7RBN0XWVMBBCLvE5+TgKnVasX5+bnqyS0stfhvdf+rDgbldwIa5MEqwF0WEvIaHWQJCygLElnYSBsPkTzLQzyZTKrE3cFgoJJi4WNWXMKqdBCkA7lUKqXY7Hq9TjqdZnNzUzHdIhvX5dY6KNYf5rZtq3AeKRzoigBZpIr0XBbQOrMrIEfkxPAxKyJgXfcc6/3XdWCuA34BqbI4vihTF2ZBgKmAQD3NW16nFxF0ZldYZgHeOsjUga4ch17AEKZD5Prib5bzIUUZ3Zct7ydMm1xPHagKGJb3lt/r4FkHrrJfsjAVv6bs18WChV6okPfQvfQXz50u5b94TnTQIsF8+n0hfyv3nw6U5bsUP0R1INdC7k0pmOnefbkXZN+l7Z4Us3Qlwqd1k+KDLNZ1P6coKETubVmWGhuxWIxGo6HkpZIILvektBEDOD4+5uTkhOFwSCKR4KWXXuLnf/7naTabfOtb36LVanF2dkahUGAymSiwJfOnAFfp3Z3L5djb21MBWXpApYR8DQYDtre31Rhqt9uMRiPy+bwC5qenp2QyGWq1mlIZzedz2u02QRCwsbGh0sfj8Th7e3sUCgUV3iaFCAnRFMAr40e80HqxSrzdUmiVrIuTkxOOj4+fSldPpVJKai0yYD0jQ45dnhPiBS+Xy6pQcHh4yMbGBsvlkmazqUBjLpfj2WefVequXC6nfMRyn+i9wMvlsvJU63kXUgwUOXKn06Hb7WKapnpP8VBLiJzco4CSMsdiMQVuhRUOgoB8Pq/C+iQLIJPJkM/n6ff7FAoF9ewpFAqEYcjx8bFKt08kEur95HpsbGyo4LrhcMiNGzeYTqfKFy7FFNM0lU98MpkQhqFKERcWX3JdRHWQz+eV9132WcayzIWimJLQOv31Mqb0nJKrV68qFZa0NNRl7MKyy7WR56/MueJ9l+J/Npslk8kwmUxIp9PU63Vs2+bk5ATHcdjY2FBjS7czxWIxVWgTRYP+TPi0bmMsqpiksdkGsixxQwcPBw8XNwxwR5ALIjavM4OwD/EVNIMEs2+CcbAgWYPVVXAt8FoQs5es08KgwPGkzslvjhjgs0pbxH98SPb/4nLYgN6/hG7f4gSXPA4Tkthk8XBZESMYJam2piR3AsYFA4wlfs5mcMMgdxoSPxkR7xyRDOvEzkc4mxMelOB3V3DXKeJblyjYr2FkX2c89ShNPTKTDQoUOY09obM9IleE9FmOWPgc1uMjhk8aeNdXJK9FwVlNK0Ejfh3/8p+E4nVwDUjEIm2xRcRwJ22YziLAbSRgNo3oUCcO8wDMIEoVw4JUGjIO2CEMMuB3SZ/MmB8YtHIJqtk54yU0U2msygLLeIS/ugTZHN5sD8wh2Ak8kozix9y3fCbdJOvOHGfRwyv/N5B5gx9NPqJ3aPDeRgFzmWRxD6pLm+7KI/UCXLsWYK/gsgmFJJwCx2HE6npVsGsQW8FgAE4FdhNQ6kB2CFcqS85C2PFhZw4PBlGPbLMLXjekao7IVANe920KI4/LaWhUoL2CZxaQ8yAxjdq9n2/BiQ2jxxDcNcjaYOdDfCNSLZSSUZ/4g6LB/TCOlVnxSj7gtA9ewQJnTGBVIf8ShDmc4zfZ6s8wDfAqkMy7LGcr0v5lQgw2cgd0NwLwsqRO5hSTS6bZkHk7FoWhVSLhglmG5gSmXZj0IOzCetOhNfCYV0LiRA6BMACzDaNF5OGup2CyD0YAyVTU+mw5Bq8HYSUqFljlKLxvNYBgZmDgM3ZtfKJmbfaqiDlfQnnElStQcOA4AeUMZAMDKxaB59By8cIFxfkaEyp4GCSZEtAmxMIgz4I4YwocA3FCrpMmi0ELnzxLdmhgk+eANVI8YYMTYEWMPRzW8Gjg4+N4RWb3evRzMyo1yGW8KCXu97j9UINuWeQLSNDZP917K4siYWykb/FwOFSSNWE0daApQOoiUNQ/W/9/nd2TxZTOCMo+SnVZwnVkn+XBK3JcXTZ+kdnUH8y6Z1gkvblcTknipP2MSDTh4z7X8m9ZNOrSaf0YpY+ybALYRF4nC1I5bp0tvgjo4OPigbyXLmPWGV9dPi2LOSkQ6Metnx9dXaAfhx5qpgM+/bssqC5eV/3vpAAjx6OrH3RW+CJbLO+n+9PlvOv+OiloyLm8yLDrnmk9H+AiUJYFlb6I/iSGXN83AbtyHS6Cbvm9zpLrNomLsm69mCFt4MSTKedAwPlFVcMnqQuA/yywUC+oCeMm9+/F+1hv/aaP59+P7Zd/+Zf55V/+ZQ4PDwG4ffs2f+tv/S1+6qd+CojYuL/+1/86//yf/3OWyyVf+9rX+If/8B9Sr9fVexwdHfELv/AL/NZv/RaZTIaf//mf55d+6ZeekuH/791kUW5ZFjs7O2QyGe7evasYuzAMVeCV+K5d16XRaNButxVbmc1mOT4+Vt7rSqXCzs6OkpKL1zqfz/P48WN1Te7fv6/alMn+G4ahfOYCnGXOlbH+2c9+Ftu2VRK5yL7b7TZ7e3vUajXG4zGGYXDr1i0+/PBDdW3lHpB59eDgAIB2u61Y0lKphGEY1Go11tfXqdVqVKtVBoOB8iKL1FZeI/J7Kd7Iscs5E7+uAB8pRgLKeiRMpBQRxuMx6XSak5MTVUSVIqL8W7pYwMeBXZI6L97gXC7HaDQil8uRz+dV+JsoqsQOIPerqAfk+pZKJWWXyufztNtt5auXvu3dbpfT01Py+bxSUCWTSQVkx+Ox8nanUimVii6gMAgCtb/CwlYqFZVCv7m5SRAENJtNdT57vZ56Zsu9LAF/2WxWtSsTtl2u23Q65dq1a+zv7xOPx1U4oDDI8HHhUkCsgG0pCIqfXsC+PL/FFy7/lqA5GY8y38l5kPZd8gwT37oo3K5du0Y2m1Xe+cFggOu6pFIppeaRuUOer8PhUKmVJC9GxquMJwngC8OQk5MTta6QcEVdxSZFVECx56VSiUql8nuec/5r2x+2OdLCZADYjLiBSYYCdxkzZsUuPpgBwwBSq6gdcxiLwrMa5wka7LEaTYnfOyHbnHEU2LRXKaqLBBV3yu7mCNec0j/dJR1sMLL2qYzXab/n4gRDpj68e2YzM0zm+Rj2xAZ/gUGbCT2mmGwNHFINyDKjFQvAWxGGFu3PZlhzxtz83ZDE6ydYkyTl/m3O83cYX59xUgN3PAOzgf28T7Y/x76bxg3jOPY5pjVitLGgHIPityy8s0u0mRCwYhmziNfhxDA5qD7DYuNlqH0WqtVI+z2cRcbdEEiasIjBdBKZokmCsYx6XbkraA8ig/TUhcEq6j3WDSGRibTGExumJsuRTWocslees1yZ7GfWIOZRH8/IpM85Ov0Ws8SliF616xCrgz2hY6+w3Bme+TxPOCDptJivqoyv/F85i/0/SCUnsPgsQcnBf+4+ScMjuYjqBQPX5Dh7iYN0n8vjPk/6EQF/rQ+FdhSO502hXASuRb87WYfNTbj1AJJHMEnA/Xh0iMs2PDqBfD7ATsJZBpxESOEYknMojqE7gLEBJSdKws5WoAfsjwzyXkjKCmFq4hshuTJUY2BacCeEw800XpBgt9njGResBez32nizDuHSguAY37qFm75EO3XOIjvleJwiuedyyxwRP93BDh2MMOCRnyfYqrAWTIl36gyy+yQLK5ZrENsGYpEzwFhEEvJBGd5NwqDtEF/4WLmQUTfqI17cilLKg34kbnBHYB+D4cNyLwpZW02jwDWjCck0mBtgDSA5gXHMxwvBXiUIcRhjE1IjvlziNqdcy/oUc/B4BrObUHJDVvsrks4Ky4PgFMLDKYvglDghBjEG5FhisSCNQ54ucSxWvAKkMDg2xuSMU26HS8Iwz4cUGVNlmxw2h6QZYNPFYoXNDBcLlwBjnmT+4RxyIcW1FfwAWZM/1KBb77erezkBFRQibLCwabPZjNPTUyaTCb1eT4Vgwcf+VnmtsLa6rPmitPciM6cHoIg0UxY3ApYKhQLxeJzRaKQWX1Ktl/ZGwqLoBQT4mP2QRZ0sxGQfRU5eKpW4evUqmUyGra0txRgJk3yR1ZBQFj1QTICqLGQMw1BsohQOxCc3GAwUOyDg82Jva13+/knFEtmE3dDDaGSRMhqNVArxxcKAMAg6CNSlxhdZYPlZwJ9U/nXpsQBP3Usu4FXOVSqVeqoNmc7Q6yBVAKWEVMm+x2Ix8vm88hzrsnP4OA1ZvPLy9Um91WUsCqDSwawwGrIfOuuiA269SCL7IONLLzpJHoBs8vm6B1H2OZfLqfElYWjyXdrryDgU5kbGnryvtLzRE3dFEi0STWHW5brr0k8p4EjR5AdZpP1vbVtbW/z9v//3uXbtGmEY8k//6T/lZ3/2Z3n77be5ffs2f/Wv/lX+zb/5N/zqr/4q+Xyev/JX/gp/9s/+Wb773e+q8/bTP/3TrK2t8b3vfY9Go8Ff+kt/Ccdx+Ht/7+/9nvenWCyqFkeipBG1QSqVYm1tjWKx+FRxpt1u0+12FVg6OTkhmUwyHA7VfBCPx3n++edZrVYcHh4qcCY2ljAMFSOqtysU5lXUJAJYhPmUgsn29rZSK/X7fRUy1u12+dznPkexWOT8/JxSqcSXvvQl7t27pwqW/X6f69evKy+3AGYpPpTLZa5cucLa2hrPP/+8SrIWf7HMr1KwkG4V4m8VVUUYRtYi8SPrzwK9w0M2m+WFF15QqiPTNNne3lap3JKNIGokYbWlOBWGIbVaTSkNzs/PVT6HnL+1tTXi8bhiuQWgbm1tqc/Z2NhQ8mXJ39jc3FSAq1QqqeC5Vqv1lLIpn89zdnam/OhyTUVu7nked+7codvtsr6+TiaTUedAlFa9Xk/J6yW0TdRYehaFYRgcHh7S6/We6opw5coVNYfW63UFakUJ9uDBA1WsWF9fJ5VKkc1mOTo6UtkkYRiq3ufD4VA9Pzc2Nrh69SpvvvkmjuNQLpc5Ozt7KntCslHElqa3kBN1hBT0K5WKGr+AylQRVd1qtaJUKrG1taXY8VQqRSwWo16vqzEn6xXLslSqvhTD5PmhZ3WI2uD69etcvXqVXq/HnTt3FJCWIowUi3RyQeZ+ke7n83nK5fL/bxPiJ2x/2ObILWJMqNBmzjpT0iywWZInQ5kVtWdWWBsw8aOkZW8Fkw/gfFjljpHDC5P4LmSbXVrU6ZMlx4L4lQ+59vMByzCg9av7zD8oMfQd1ulQqc4IQjA6kHU83HxIuDJIB+AxJ47xkds0S9obsxqAufTAn0S9u7wQbzvHwJthPfJZFVekg4cYsy3OUyHFLUiXYHoeMCqu0fnyFX73zhu8ENRYkWCZfofP/OiI7HXovQ/udzKMvQEzs4mVW+I8D91nDR6vXWP13P8JclvAFMZvgzuDWBXsNSARsdfuGFwTkhtgrkf058qITNErN9JQrwwILcCIUIe1gKkP0zgk8yxeeIZp7phYZsWpuYa3fZntwe/y0jzEckMSi2Peq80JMnnoDjCdc6zEGNfN4IUvQO0Gq6VD3D3H7nwTb/E/8KDwFdLp34TGJlSu80HyEQ+7S5aDEDs4wbUrsPVFRoNjWHyLnbJHfwXujehw4n2oV2GShLc8g2Yxgz++TGbocXm6T4kFpgOtCqznIHYE5+eQnxm4qZD6Juw6Pp0SNADrbVg8thhkYHLF541Nk5xr0MgadJMlJr0BW/MVxU5APQ5OIgK89gYYDsStCUlnQsyA9kOwnhCBRgt6FtSuThkYLe7zOcZrX2FsHkDKZzhskit26RmPWD9OMFz5NIuXMVNLimmPI2OOUwjIViDcglQmktkPT8C+A2YJjr8IH3zWpnS2Ij4LOb0BzgMo9SBMAiubmOGRSsF8CFMiFt8Jow53rhkloi99GA+hUgRvFqWUs7RJxT2S8RXLZZURWeZYVJix5UI4AjsWSdU7Rdhah/wwquOknkRksz0aU+xYxKjQosQJBdosSWGyRYw4E9ZpUY+fsMx3ubE248o8pH+Y4l03TwuDKOmtTEicAR9gMsAmwGGIB4SUgDUWLY/z/SGJ/A82B/5Qg+6LYV06+BCQqfe7FEAkVWLxS+tSapGXS0q5gFrxYcnnyXtLeNpFJlP+fZFplP0Ow6inqc44SwVdZLwCPoTB0T3MuqxYZ+xEnpfP51VLFFmM6FJdWTTqTKOAIp1tgaflxsJG6TJeYR+EGZJzrgNcYa91oKeD24uqAR08S6FAmHydjb3Iqgow1sH8f4kR18E38J/9nf5dmCA51/p1ln28eL4ubjqo1b15ci3CMFSMtw765b31cS3XSJeR6+dEP56L3mVZ5Orn5uI+62BbH8f68ernS3+tfs4+qSh2UQWhS9F1H7gAMf266fui/2wYH9tBxJ4g7Lbsh7CSMr5+v5nun/mZn3nq51/8xV/kl3/5l3n99dfZ2triH//jf8yv/Mqv8JWvfAWAf/JP/gk3b97k9ddf5/Of/zxf//rXef/99/nGN75BvV7nxRdf5O/+3b/L3/gbf4O//bf/9lMM//+erVQqKSax1+uRzWYplUrM53Mcx+HFF18knU4rwCnJyYCSkUtIoBRr0uk0e3t71Ot1JZN2XZeDgwPG4zG3bt1SLbe+/OUvc3Z2plp5SQsmz/NIp9Mq+EmArlhyDMNQoHI6nSpWVkKqJMCt0WhwcHCgAs7kntDbLwJPWXdu3LjBjRs3WFtbw7aj8CwZc3KPyXNBCj8Q3Q9S6NSLkoAqCiwWC+WPlfGfTqd59dVXqVQqypt+cnKi5N7Stms8HpNMJhVLLUVaAVRSxDBNk7fffpvNzU0FxiqVCtvb2zz33HPs7+/z7rvv0mg0eOutt4jH49y8eVMVB6Tg0m63VZCm3E+bm5tcv36dIAg4PT1V0mvxSEtRRZK2q9UqnufRbDZV5ojYVqSw7DgOm5ubbG9v8/DhQxqNBoPBQAW1SYK8zI2TyYQHDx4oK0Imk1F9yLe2tuh2u2xtbbG2tsZbb71Fp9NRbdxc16Xb7fKlL30Jy7JYX1/n7OyMVCr1VMcDmccle0CUYVJAFlWIpKX3+311TcVSFY/HWS6XtFotNc+IP14KPKVS6Sl1klxXuWbFYpHRaEShUKBcLqsiQKlUot1uK5Zc1FDD4ZBOp6MKvIlEgkwmowoI8h4SyHbnzh1Go5Ean8BTzy9plQbRPC/edSEDfr+LkvCHb44sY5ImQ4MUx0CWBUWK9DFI1J/w4lc8ihmYjKHvgncK1l0IPY+h4xO6MUZhAjBI4RFjQn7jkI0/tWB6IyJmr/90wCreZf9xnFZhwuYLLos4pDbgcz8K/X2f9v0xVdKkKTLlMlNWOGSZMsSfGhiTEMMeE9rJiGE2Ak7KeQ53elx5w2SxslnYRzhxj8MB2JuwKMehWcZ44OA3KgxJYGIRDyziPjjDqH326qURy+WIdDvE2YKzl+D4Ro3V2ouRd7vdAv8AvPfBmQEbsExFzctXfqQfNoYQrkepWdZa9DdBBSw7MiKHmSix3J9HyeZGEEnT61b0u8/9BKNyh8nyiCCbI3d8n2dPl/gJGMdgPQNPJlP6qSyx2AFJd4mXMPAtj8AvwyoB3TmeCRvGhzQP/gWrzR2msS0oliG+gbf5J/H21uDwEcHDf4F5OsF+45tUY0OuPO9RSMLAgGYKZinINCFfhkUGelh4QRHqX2Rc2eWu+x0y9vdJjdpMWwbDVAqjOsduueSaCSxjibMZcFqzOfJqeOdL6vMu8b2QSTMSAzQKNkeJLIYzwdgY4Wx7ZB/A2nswPofTFiymsJGHwmYU6tYH2hN4/13wPshh2x6Z9RlmHFYz2NhecdJ9wmTr87DmsfPWb5Foz2llwNuZ4SxnnNo2wfVLJIx3WF+f056ektqNbPjYYI8/qu9MYLgC34iC9eK5gOx6wPQUmptw04HyCSw2wVr3YRiBbMuPWnzFl7CcQasftbS2XEjHYT6BuQ9WG0oTh9AOsSyw3JAVY+L4FNilAhQSBk8WMFlCrgKHFswc+IwDpyMgDa5v4I0LWFxiSEALg0NWTPC5SYI1TCbGY4y9h5SvLrCtqGf48K7N990teuQoEyPAwAJMStjsEWLQI8BgCCwICMmQw/PyjNtjgtwP1nL2hxp06y2v9KAQeehXq1VyuZzy4QnrPJ/Pmc1mimUTgClyaXkoyoJ+sVjQ7/eVl02Xdl8MBpIKtCz85XOFOder7hJ01G63lYxPmDup4Hc6HeUXEwm6MCG6P1hk5YVCQQXQSBqtLKwGg4GSwq1WK8W0CNMoD30JwEkmk9RqNdXCzDRNFRYjC/FEIsHa2hqz2Yxer0e3230q/A0+ZqDlQS77rgNGHTjK8Qi4l+8CwsQSIEn1wojoCyN5DwG1cv5EyaAXIS4CSnkPAQQC1nzfV715ZVwIQyOLroueSDm2ix5kSfAV5lAAt5wbva+2sOmmaVIsFikWi+q6y/UUwKnL2S8qCgSIAopFlt8Lay37rXu4dbZcP155f7m+Fwslwu6JFFXeT8a3HtIl2QgyduS66C3HpBe07JNcE9lnYb5FxSHMnvSUF6ZRmKWLxYrfz833fX71V3+V6XTKq6++yptvvonruvzkT/6k+ptnnnmGnZ0dXnvtNT7/+c/z2muv8dxzzz0lpfza177GL/zCL3Dv3j1eeumlT/wsuX9lk/wHAViO4yjwm8vlqNfrfOYzn+HKlSvKYiPzQaFQUOdRxmc2m1Xg+kd/9EdVqy6RGb/44osUCgUcx+HWrVukUin29vaYz+ccHBw8lWC9Wq1oNpsqyFFApVwvmRdKpRI3btzg7OyMXC5Hr9dTDOp0OuWb3/wmd+/eVcU+uc+3trYUS1upVJREWNKrBXTbdpSULiFzArJlPMr9Op1OVViXtDUTVl3PZJCUaUAVzuQ5dOvWLTKZjGKLJ5PJU63vZH6eTCbKjyvnQQCi3I8iMW61WhSLRQX6JE/j5OSE2WymJNW7u7tKwSD3fjKZpFKpqPecTCYMBgOOjo7UvHjr1i31PLt27ZrqVLBcLimXy3zpS19SigOZwxKJBM1mUwHMg4MDJRm/dOkS6+vrLJdL5f8X5QVEhZFYLKaete12G9u2qVarqhgihbvFYsHx8bGykTx58gTLstjd3cVxHJ555hn6/T47OztKRSbXTOZJmVNkbp7NZiqdXNrTjcdjVUSeTCYMh0NKpZK67lLMApTUO5lMMh6PlQ8dUGuCzc1N5VOfzWbMZjM+85nPKDuU53mqbdnZ2Zm6HyQpX4pjopzb3t5Wc83t27cV6D8+Pub9999/qrCrEwWyRhKrx/n5uQpJjMViSrH2B90y7A/FHEmRKmm2MHmAzwfY1MixbT7kM7dGXLkKgyFMFxCbQfABFEyYJwYswgAjFtCdOFTJkmaIuzHn1b84wfwivDOG3SQcvwLx3ZD/5nDB23EY3QQjCYs92P4S5DaAqyvyb59Sul/H5zJndFmnQIINAvcJnusTeg4sXXByEIxwy2Xu3g5Z+3WPuneLnvmIwrhLbAZnU/C/OSb77feoHtRJBRUyQJwF2blB+kFks85dBasaMu+B0YdxDRrPFJhf/yLY16LI9lgPpocY7kNC14V5D2s5xgiWWL5NOFnhjTxCHmJW3sFPbUDsGsRuweQ2eAmomxBPR+y2ASwSkQS96sCoAKUvQt4laHyX5PlrvNDqEjuAXhXGcajHYTeYM5mcQybGZFLHd4oQnoPfBStOzH9E3V9SToBpv8Fh9wAKcQzze1Gw1rIJ4RPivd/ls49OmD9K4XhxdosTWIOeCWkXUsA8CYdr8CQEsAkmATuDI2LeP2OS3KNnxRm9uM7Is6NY8es3YD4j6b9HUBqz2IDTL1dZFT8DZ7fBewsn9tusJXz6jUhVX3FXxB90SXrQ3YLuborzDYP0YorhQbIdBZQRQs+AhpvAcFzSC5/+GMbBEntpUg4BBxJzyPvgpD1YPCB5/Ca73gzbguBhZK/PfwGexEuEz1wh3X+X7WuwGMAiHrWDixvgLyNZfSwLzjWw83DDh/k8YPkiZGOwNo/6ltshzEJwLoXwfRjfhVIleo09Am8EvS7QjXjkRAKSKxinINMzKTgB4WWfxamJOUuymexTmNvYZJmZA85eCFh8HlYOVIiOr3cX3vz3Jo1uitU4hnOWZ+luY5BiyILFR+PcJUGBbUymrK4d8vzPLsh8YLD43SwnU3h7WuADqpQJWANsLFIksHCIUcbGwWBFjxd5yIwSK26SjBziS5Ph7I8g6JYH5yd5nQVsyu+lkv5JC21d+qy/XpcgX5Qzy+JHwMRFX+tF5lYHmPKQFcmitP2QhZ88WHUAIvupS/Hk4WmapvK1ZbNZ5SnUj10CX5bLpSo2yGdKaxg5fmFFPC/qTyqyXJ3JlcULoM6X7IMk+cpCWD/Hcq2EaRYwd/E86edev2YXQZ4u59a93rqHVL7r0mjdfyyWAf0zdBm/gG4dUH/SWJLPFHAo100+6+Kx6Punn6OLLLkcj7As0iJL9lXS+S+eS1mk6my3HK9+fvTxqp97vWDxSV/6mNTPqfxbFrqyD6IYkS89TV1XfFxUJehfuqrk4naxiHKxhZu+gP2D2u7cucOrr76q7CK//uu/zq1bt3jnnXfUglbf6vU6zWYTgGaz+dRiUn4vv/svbb/0S7/E3/k7f+c/+//5fK6ktmEYtVQS2fH6+rpi62Qs5HI5giCgXq8zGAzUuRaGfGdnh52dHQaDAcvlkvX1dRaLBe12W7XEEiavVCpx8+ZN9vb2OD4+5t69eyqMLJ/Pq3uu0+lQKBTU9ZJxZds2165d4xvf+IZqEyWZFG+99Rbf/va3KRaLSoI7m83I5XLcvn1bpXdLASGbzVKv1ymVStTrdQwjSjSXsSDAXyw04nMVW8JgMGA8HjMcDkkmk6ytrXHlypWnOkjoxTzdwiH3kty3vV5PXXMpfAnjOxqNuHz58lNtHAX8i81G5N3T6VTNwc1mk0qlQhAEZLNZ1tfXVTCaFAld16XZbKrzf/v2bVWMms1mKkwtCKIU616vh+M4SgqeSCR45ZVX1LiW1nsyBh48eEAQBOzt7bG2tsajR4/U80asJj/xEz/BbDaj2+0qX7u0YovH49TrdfXs0gt/W1tbAIphtyyL4+Nj+v2+Klavr6+zt7dHLpdjfX1dWahu3rxJo9FQKiF59kk/drGlSLK4tP0ajUYEQUC/31fqN71943w+V9dP1G6TyQTLitLxJchNiqV6iKYw42L/kPXAG2+8wcOHD5WqQxLsJbBNvPC2bZPNZkmn0+zv7/Piiy+Sy+VUgn2321XKsIttQeVLjkWsBlJkAKjVakqS/gex/WGaI2fEWGdOkgwj1mgwIY7PuumxVodYHjwX8l6UMD01IXgWtg98yg2fTsbGxiBn+ZRunbP1J0K2b0OnAyUvYgEPluA3ofghJD3wY1EbLrcI2WfgfA+CI9hc+HiPz6l4t/HIYRJgUqE5dpjhR5SjawBJYAy2Rf/6De7svUP2qEvKr5LwRlyOuZy8BcVfy1EfpeiwZMKMuXNO0Q94zsuQ6S04Lnm0tsFYgZ2BVg3uljKMa5+JNMWDFiwnGMZ9kt59iqspqWlInBFLO2S1hJIL4xkcDOIkxh5rwx7z5Ij2WgNvrw25BMxuAyYEFqQTUbz1PA69EEZ+JEO3A0hWIF0n68y4XISFGeW1fWAY9BYGt2IBT0YF+pd/BuJJYAThk4j5947JJQbs+DAKYBoLMKZD1nyXW+4JZ43vcFizmYdFUtkW9XyAa/lM3BSzforFO6csiwHdgUk6bsC6z+pl6Ca2YHaN8uwtftQeUh5P8E/eo9eCxpbN+WU4yMVw7U0obDB/Jcb+okGQsfGTV8H7UUhtwnaGkwOXTnAf90qdVe0ahf3vsjtowQJSNvTcKo2f+Cn6szd4vvs29TAkHoNUBYKRgR9zKNVX5LIwzMMssyQ9jtM3YbQdYxLYuOk5q10DzCPWj1sYvchHnhlFY210Dca5LVi/wsjbpbG3z41VyPl7YAxN4v2A6SZMK0ABwgTEvUhIMMlDYw4ba7DngNuE4MFH7HYqYrhXLXB3IYzDvA9+G4yhzcL0CWIhk7aJRUBuBZ4ZMKxD0gdzFRJPzLA9G4M8rvUAa/eExfUALwmmE/nmi//GoPUvSxyc7zIM1piyiu4/0qRZ4hKjiEOIyxk5LNI006/x7M+NyQL971SxBi9zxopDFgQY1EkTx8FiQoIkBnkCZqzo4JLnHXI8IuB51jnFJme9STXmEfwAIWrwQw660+m08oTJAkeAaCqVUosD3acsD3rxhAobJlI2WdiJDEsANzwdNCXea5FcSp9MYWx0WZkurxVQK0BEFncSViOtfaRdjwAqYVakmCBSP2GhstmsYvXFFyyLAb2v6GKxUEEswi7Kly7NF3+5hMXU63W1YNPPt85IlstlwjBUATo6wJOFh34uROary4yFjZVzKX58HeTJtZSFmRQNRK4q8j8BfLLY0duZfRLYlO+2HbVzkbYtsgAS+aLI/uTaCBslCcsSGCRjRRZycmzSukY/3xKAJNdOl+bLwkv8kZJAG4ahOublcqkWigKW5PjleGezmVII6IBaL1LIWJfj0hl7Xfot41fUHnrOgPSELRaLis2SpOTz83OVeqxbL/TuAfo10QsHAjJEcin78kmedn1cSPsmKSyJx1JA+e/nduPGDd555x2GwyG/9mu/xs///M/z7W9/+/f9c/Ttb/7Nv8lf+2t/Tf08Go3Y3t5WYFV8oTLGbNum3+8rwC3nURi4tbU1ms2mYqSr1Sr1ep0rV64wGo1ot9tKCn1wcMD777/PBx98AESMpbDNopj58MMPlUJGfNWz2UzJxQUUyL6JBD0Wi/HKK6/w+uuvs7m5qdKzp9OpYt5jsRj9fl/Jnev1Og8fPuTKlSvUajVmsxkQSe1F+TQYDFQ7LJkbRUqvs4nC9smYGwwGGEbkOT46OqJer1MoFLh586Yav1KklP3X5wgZq3LP2LbNzs4OsViMo6MjDMNQLd2kQCJqJHmGSTHBNE2Oj4+VdH65XJLJZJR3/vz8XM3pMjeKnFp6rlerVbLZLN1uV9kQZJ+SyaQKIhOp88bGhgo/k44d0g1DCieVSoWtrS06nQ6j0YhOp4NlWer67+zs0Ol0lDVLfOHpdFo9jyqViupFfu3aNb70pS+pZ4NIr4fDoVJV5XI5dnZ2VBE8n88zm8148uQJiUSCra0tWq2WUqvl83mq1SrValXZKtLptMpREeAqbLww5YCSd0s+gcxfeuFcxnA+n1dqKNu26fV6+L6vxqkA5d3dXc7Oznj33XeVYkIKUo7jKI+4XnSv1Wo0Gg2KxSLXrl3j9ddf5/z8HNd16fV6yq6Qy+XUWgSiQpy0yzs8PHwqYFae5TJP/kEEqcEfsjmSLik6TCkT4xI3iJFlgB1k6DfB7UD5o0TyZS8imacLWA89nnfb3OtnWcejao6o50OuBTD5Bozvw+5tmP44rL8N7X8W5+2uA/aS7YGLuw1+OvLtposQfgjBCdjhkDgNtqkxBmwcWtMEi/gcM5wQxBKR/nduRHHq8QSHfypP2X/MV3/7Kq1WmX63yY05DDwYsSJLjJFzhPEjPTY+jFPv7PFmvc+92x6xOmzNYAjcKeaZVr8CuUsweASTFmbijMryjOzKpxqD2zPIjUMaLgw/Yv/7U0h7S1JLSAzA8TzaD7scHr3BtH7CKv9l2PzvIHDA8oi6OAdRBSIWg9UCAiNqDB7mmZtVZsYRyRxMqzDcSzCIQfx4ztS4DuUvg9WCyWmkUZ6Pwa0xj9dJmke4I5gWoGwuqB9DfALPOxMqC3gj5zNwHF7fNXHGK3KPzyFIszy3mDVNeuTxKOGNTplfW0Hlc5C+Qar7fRKZKEwt0YPrc4MXTI/vAYfxCrTbMG7DRgK3vA7OZ6CzG+msE3GoXsKvvMQ0iEPxK1D8IovugMlmi9E+7DTghjXkbrjNYqfEWecB55sTzAVczYAfCzEzY1ZTmC+j+sQsAaPOEvMWLL+0yyy4xbn7LkapBW1wh5A6guk+pLZgYw8ODVglU5BPsJq/yq8dPeS/3Tlh53cNzg/q9LMdzKRLORnl3E2vAS486UdOg/U42OuwsiHogGFBKYxaqll7gAGdBrhn0T2T2Abvioc3h0QH5pMYq9DH9lwWeciHsDwFKxFi+wb9VRI/f0J1c079M+DV4LfbEOxA7RT2f6NG0PxRznBZ4TCjyxiHLda4zpwcD7GwWLKHQ50eBzz3ymOu34J3/t8mrUGdARbv4DFlyiUS1MlhMsVkgoHJgpDsR8nmj5hyTAaHOTZpjvHZNDyWQRRL8INsP9SgW0C0yNlkUaN7nz/J0yusod7K6KLPVWckdfAj/ip5H/EYX5TYftKX/F73heuScWGXpYeo3h5Lf60EuAjolvA0aQMmTLNIAoUxl0WNsB9S9ZeFJ6Aq8QIapdVJNpsFeAoUyrmR14nyQKR3uiT8ovz4k6TlAqLlHMhiV/9bvde1yJzlPeXa6AtcAcM6S6pLpS8yvDqA1nMBhNWQYxTwfvEcCICVz5FxqsvZdVmqFCNkDFxk4PUig1xzabMk+ywLQgFQcpxyLWS/hC2RrIKLn6FfG1mkyT7qhQ95jQ7w9ftBClfCTsp7ygJPvvTCgvz7okJEvx91yfNF1YDOyuj7Kd/FDqEnCevZAL9fm6QGA3zmM5/h+9//Pv/gH/wD/tyf+3Mq8Vpncs7Pz1lbWwNgbW2NN95446n3k37E8jeftMn4+aR9keNdLBZUKhUFoprNJp1ORwWJmWbUB3o2mynLiKQ9ZzIZ5vO5Sq/Wg8akICe/W19fZzgcKrDYbDYV4yqsYhhGgVaTyUS1wRL1jF4cdV2Xvb09JpOJSjxvNBqqn/bBwQHXrl1TbZGuX79Oq9ViZ2eHq1evMp/PKRaL5HI51tbWnho30+lUecFl7Agwlc+WYpDIjGOxGIPBgG63y8OHD5UV6cGDB7z88susra3R6/VUT2gpNokkXWwUUgiQn7e2tlR692g04uHDh+p+FxBqGAYHBwcKxIlFqN/vM51OyefzNJtNqtUqa2trZLNZ7ty5owC/pLbLtRuNRqr4Icy5bdvKx727u8u1a9ewLIu7d+/y5MkTzs7OSCaTXLlyhZdffplKpcJ8Pldj1HEcDg8PabfbFItFms2m6vNdq9W4c+eOei6sr6+rkEVJo+/3+6pY98ILLzxlgRHA7Xke7XZbhci5rqs80dIeVAode3t7nJ+fKwWGjDG5Bu12W6W3CxifTCa0Wi263a4Kt5Piq2EYnJycqHEvxy/FbAHnrVZLFXIgUrKJmuHKlSvKJqQrxx49eqTYcrFuyJcUT4rF4lNFz0ajwSuvvMJoNGIymahnvRQ/0um0mk9lfSJhhTKOpKjQ6/XUPaIHHv5BbH+Y5sg4S5bMcYgRY0gFnxgLOkGc8wdZuu+PyV4j6o9dheExzA4gkffYbZ8RLrLEzCkZz2f+psNpyyVngtUBawy1JKT6YAchDWdJvu6yEY8kvYM5DFzYbMLWMZydw8xfEucxIXEc1plyTL+8YFq2CK0ovRxnBbEkxANwhywu55l9tcXyoMH8qET8+yafvRXwwfNdHryb5pX5daZ+A+PRnFuDLZr1AYc/u6JxFbJzMIomT3JFpvXb4K9B4AENrMljNodDtqyApQFbQLUPqyFsx6G8hKEf1QAybeil4UHCwBqGpB5D/Z0VYfqQ5dY57WfuMHvxy4T1l6ATglmMUFzSAtMFLwVGHJanGJMF7gScLDwJTdzpGslCm9mGw6p3BY5HmOf/ntD2CeNjWDagUmVqvMiDgw75xQzfyhKOfYrzGe0BHCUhY0O2M6FbcThb34TEy2SsB8STH7IYh6z2YT3oY4ZzvMSS7mgNEq/C0KMZ2+LfBaeU0h6pGz7ruy7FK/BetcLKeg7unJI5fsj6iccklaJxJQ3Xb4FbgdkMpm9hxL4Bdg/nqIfXGrIs7jI8T1MKp0zPoX55wNm9/ydzL0lgz+htmIRuyNixGFTzMJ7iDBYkY5AsAi9E539oJMGcgtsnLFbZcJ8Qay84TYcU6lCegbMDmQrkRmCMLVjMgBydvT/Pv2j+On/+5QdkO12sboD/TobJvZDU3pR8D+zLkCrCJRMqKXhrDPdasN6H/BVIX4LYGHI3wDiBk7swX0F6HUovgGMBd2AxNVgEceLYtBYDXNsnZgJZSPgwHzvE1qfsvexjrkH+KizjYKaiNu/Gd8HvXuYhLgNGVEmSJMGKBDEWOLTJ0cTHwuQ6YLJIvU+1MmX1EKaHJivKLPAp43GFEjVCbPrAFBsLkxQWIR4TFrjEMEiQZ8QCkzY2m6y8Z/C7ExxmP8j098MNugVwX5TOyoPDdd2nmBypFIvnTwe38iCSv5UHnWmaKp1XFmsXW37J6wXQ6DLmiyBf/xKAKKyH+L/15GaRLAqzXiqVSKVSbG1tqbYrwsaKLE58g+K30/3I4lOUHr16kJwUKvTFpr6QEI+3sK4CFGWxJiBGL3rIYlVAmjAWwFPXRRZWUiAYj8d4nqdSp+V9JcW1UCgodko8aJlMRgHjRCLB5uamKkzIAlj3kMomi1/5XJFY6ooF+VnOoYBaPbxLFjJSmNALMJ8ETvXwKLnOsiiWooFIg4vFIoVCQX0XoCDpubLQvKi0kPtCH5NijbgIuvVNiljCEMtYkU23CghA0HMABJAIIyleSVn86Sy7nBP4OLhNTy7Wi2AiSReGSfd6Xgxt04s58l4SiChs1R/0JnOJeDe/+c1v8nM/93MA3L9/n6OjI1599VUAXn31VX7xF3+RVqtFrVYD4Dd/8zfJ5XLcunXr9/zZV65ceWo+kbAlYXpFfjqdTslms/T7feWBTqVSPPPMM+p+sSyL/f19FZaYzWafGssSenZ6eoppRgnd8n8QeV4bjYaS04qtZX19nVKppJQHolbSMwYymQyj0eip/sv1ep3VasXZ2Rnb29uKXU2n0zz77LNq7s1ms2xsbGBZFpPJhPl8zjvvvMPbb7/NcDhUgDyXy6kxJ/e1MJj/X/L+M0a29bzvBX9r1aqcU3dX57BzOpk8iRQpJlG6NiXzzlxifG3C8liwxhJg6IMBATIMGwYMyAZsy5BtjOGB7RnJ8HhsySYvRYpRJE9Oe5+zc+rcXTnXqqoV50Pxec/arXMDORrbOl5Ao/furq5a4V3vev/PPzzCbq6urrKwsKCAnORY7O3tEYlE2NnZ4ejoiMuXL/P8888DqOeFrut0Oh2VMN7r9dQ9I8VC8dTeuHGDcDjM6uqq8hNL2zaR9cfjcZXg3uv1mJubo9PpqKC506dPK3WApmm89NJLmKaprp9I7UV+Hw6HFbtfrVbxfZ9yuayug+M4vPrqq+oZWK1WVY9pGePvvPOOOucf+chHSKVSlMtlVYiTQDMpopRKJZWoLdddVGhSJBPmXtM0Go0G3W5XFWUWFhaUdz2XyzEYDEin08rfLh0hms0muq5TKBTodDpo2swTXywWGY1GKnfCNE1lPyiXy4q9Fn+2/FsUXYPBgGazqcaVrBXkegrrLfO5FEMkPK7f7zM3N6fea25uTqXHS4s3aXkmiiFZL9TrdfXcv3v3rmKnJdNFrFcyj4uNQXrRSyGp3++rQshoNKJYLKrifbfb/f9p7vs/uv1XnSMZMybKhCxjQugYlAjTY8hwGgIdUhsw2ofUGNpjCFch50JCtzkf6uNmJli9PKFxjoe7+yQjHr6nka67lF8D4wJEXrRIvgqjbpTqtoN+yyW3BnZiBs4zVdjpGBzjkKBGmBwWAwbRd4lcGuMWUvhRbQauiIGRnsVC+1NwNeyUjrM5JLGbpfR6iXGvQe6iTyq1y+GdDpuH8yxXP0KtsMPdLxzTeArGoRimHuU4tQpLV0DXYejDZErk6iFrr3fIViGRhcV5WNZgWgM/D6nCzJptG7OstK4Fd/QInfUs0YUOpZJDcgBmH2K1MR/T3mE3/B61vTXGR4uMz38Gzv0MTEJgjGAQAzcO7QGrrRZrUWgkwIzmILdC2W1RCoU5XD0DXozFd69CpMPxehzNGOIMtyH9Efb2FylN72PPP0PLWebo7n9gczDi+iK0KhDq+WQ6Fv3FFP78iwy3LvPu0n8gpB3haUnKe30Ws0MauRjT1HMwXQNvin3hr1JLTKkNx2B20Ic3INnHyz0LzcdheRvT+3/S/dYREc2maH6LTrWDt/DTEG+Tjv5/KHRrdN6B03aNg8IetWf/Rw5SZ1lYeIeFBZ9IFp5JHNMZzcLG9CFUSwmaqVM/Sn7fwQ1PsBMzCb3lgh4BjAw4S6BNMJpVTnd9NjWfbybg3kKMoxWXuZhNNg+1QRQ3U4RxC9w+ZJO0jE/wlVaHnx83mPt+iE4zjjaO0Lgzpdh2sK9C8nmYK0PDBrcCW3XITSHWgXEaUknIRWbB9alVKKwDQ+jXoF2F4QONyTD9o77ZFrYXQZ+MsRZ+1Nr9APyyzcJPeyROwaQCrXm41YfxHKz4YNVgxTXQ0HmVCX1GJAkRIUqIOg67GMRxOE2DeaYccya0T/gm3HtbZ3qYwSJHCZ0NQkAaj0NsJniEZ1EDuOSIYDNkwBGQJEKfHA4OUYaMWKJI2q1gTR78RPPdn2rQHWQp4FE/6gd9ySJfPLfCUgc9wfCoD1hk2iK/EsAmAEtAdtDDJ38bZLiD0jD5Cv5MgEUQuAcBuzCvkhQuPVmFyZHP7Pf7jEYjJeUNynDlASzAURbkUgAIyr0FvMl5kgWosFSWZSmZrgC/D5KBw/utu4KtieRYBVwKEBL/YTC9Pch4yD5Go1GSyeQjHnd5nUidxR8oIU/yecLuBxlvAXInQZ+AZwGdsj/yd0FAGwRxJxnvk+MiqMg4OSZOvof4RYVBlqAmeW9hNEQCDzzymScZYV3XH8ksOHkvyTmWgs1Jz/vJ9woG8AkTn0wmlb0jaOMIfs7Je0P2+2QeQJARlwJH8LyfPKdB/ze8Hw4n41qu85800/3rv/7rfP7zn1cBTr/7u7/L9773Pb7xjW+QzWb5y3/5L/Nrv/ZrFAoFMpkMv/qrv8pzzz3Hs88+C8BnP/tZLly4wF/4C3+B3/zN36RarfIbv/Eb/LW/9tc+kKX539sWFxe5c+eO6q8tPmJZ8IscdzAYKEWLFNp0XceyLCVTlpRkKVpGo1EsyyKbzSqQvr+/r9Q0hUKBF154QbVGlPFt2zbZ7KzXhoydarXK2tqa8q7C+2oKkakfHBwwmUyU7DocDvOJT3yChw8f4nmztO1MJsOzzz6rxm+lUiGfzxOLxZQ0/Pj4mO9+97tUq1UFZgaDAfPz88zPz+P7vkqDFsuQzI/yMwkzlHP38OFDdF2nVCoxHA75zne+g2VZbGxsUCwWVcFjdXVVpXYbhkE2m1XhcAIw33nnHXWdTNPkzJkzqkWVtLr0PI8vfelLqlVXJBKh1WopJluKXmtra+r4l5aWePDgAfV6na2tLR5//HHF/hUKBVXEDIYayhxYLpdZXFwkk8ko7/7x8TF37twhk8moYL27d++qNmmuO0tDz2az9Ho9+v2+ClmTootcD2FZZe6KxWI8fPiQdDqtQGA6nVatvvL5vPLwS2HIdV0ymQxzc3Pq2SGFvPX1dR48eKC83fl8nk6nozzFjUZD2S1EJi/J4PI86vf7qlAiiea6rqvrF4/HlX1HihiiCpGfLS0tqWK9KNOkWLC+vs79+/fV/CQBr5ZlkcvlWFhYUP563/fZ2dnhwoULHBwccHR0pIqN8swTEC6kgNxrweet67qqCCQFg/X1dfW8F0XVn+T239wcSYzrlLmLRh6Dd3GZUKGARd+4g+bPVNCDAQwegHsMg12NSctAd8DyM9R6BYbeChnSjKYhtGmCBFES40OsSZ1s1CG3Dom0xoPGAtFhksr/ssd8dkjrU2DHoT+A0DRCCBebEFm6oO2gp9qsu9A8Njle1dHiHpYzBlLgOqBbkDLoxUNsT3U0SgzsHsadBKGMyRM/62PGBlCd4zD9gJ0/e8TNz0ZoMI+nVaBSgfzqLEGrN5z1pjp6SOIbbcLv6FTHBn3dRUt4xBZ85pfBqc4Yf6MAoySYnVkKuheLg1Eh2R1SyTtM8hCKz5Lft+/C6WsOT8QfMHn4gBv3rvHAexNn7ecgcRbSLvSSsPhJ6kdv0KJBMw7TTAKSSZhqjCJhmLfQrr1B4l6PiOkQHvYYn4fq0IWIjb7nk9/V6V6eMH3mczwYQuSN32HjdhhLm+Jv+NwOafhzOthjaG9iLf0s5HtQKXNw/4DacR3n/Cb+2SehHYVUFEIF0HJQiUBvijf/WVg0Zw2oHQfmwmhOlNGCh3EzxeZrE6qFV6mVbpNNTDl1aYgxgOnrObqDOAurxzjO79NaLfEgGybdtdDbEDqGA0OjHTbwrTCuViZy3CDZ7qIvTLFsqDGzJaQeQj4NfmFAL62hp/uk6lW8HiTTsGbCUSZP56zFitdi7MBBJglzBbA7s/ZvIQvIsLv2c/x762u8qNUpbTfI3YnRHaaYHE5IHYZpNky6F1zMedjKw3Qbhh1ITWHqg30a+nXoRcG9CIkI9JuzgPpU7Ef+fGDMFBObtO4SrkB2HkI9GK5B/1kP81k4TM6KUW4GGikI5eB4CNrHIdt7m8Sba8zbEcL0gBQ2CQpoLJAjRYouF9nWMiS5zappsXunwHvOBhoZcthk8YijMaWNhskUFwcfnSweKRzC6MQwWMSlwCr7FPGpsYrJhNMkCVNmOnnILFDgx9v+VINuWSQKGJYqcLBqDyhwHWS3RHYnLKF4dAWQCBMpCxFhwQWEdrtdVSEOSpcFSAUBTzAQLej1FuAg+yCp6nIsAi4jkYjybpfLZcUgBGWMso/idZO+qEGQIluwyCAgWDYpHsgCSNqfSJuh4XCoFmrShieZTCoQI8BPWGW5TiJbl8WkvEYWBFLACAbHycJFNk3TlEc/KGXPZDLYtq0S58UyIF5qOa6g5UAkpMLiAWqMyD7C+x7nk35w2Qc5vmBBRkCkMFzBwowA+iBrHLQoCIAWAB708stX0A4BKNAT9E5LSrD0QD5ZfJJzIudVQLUAYlmwyjUM9hUXBr5YLKqewcLaBcML5b1koZ1IJMjn86pAcLJIBajWQ8Fx+UFFgw8CzEGFhcjqZbxLeNFJ+8ef5Fav1/mLf/Evcnx8TDab5cqVK3zjG9/gM5/5DAD/8B/+Q3Rd54tf/CLT6ZTPfe5z/NN/+k/V34dCIb761a/yy7/8yzz33HMkk0m+/OUv83f+zt/5ifZne3ub4+Nj5Zt9+PAhpmmyubmpxqYswPf29lS4mCgSarUajUZDzW3SgUEAhwSsBcezAJObN2/y9NNPK9VHoVDA8zzF9LVaLcXUvvfee5TLZc6ePavuA7nm6XSahYUFGo2G6t0MqMKf+G4FuORyOfVzAWDST7vVatFsNonH46rfcjweV8cci8UYDAa0Wi0lxRfvsmmaaozv7u4yGAzIZDJKfSIqAQHStVpNFcUkOE6Yzmazqc6dACvxl9+9e1exu1IAEWWSyMgfPnzI3bt3+cxnPkO/38c0TcViLi8vq+AxKdolk0kWFxc5e/asUnfFYjHVtiwej6tigHh5fd+nWq0q9tyyLJ5//nnFwssYsSyL1157TYWfiQVGLCTCNO/u7iqQefHiRVKpFM1mk3q9rq6rSLhFJu04Drdv32Z+fp7NzU0FKgHlp65Wq4/kRshzS+Z7UUU9++yz3L17l1u3bnF0dKSe2b1eT4HobreruioEx2o4HFasryTNix9cALcw1MEwUwmZm5+f5+mnn1ZyfnkOBNuNPv7446yurvL1r39drUNEZn7mzBlisRj9fl+tEUqlEpZlKcZX0zT17JAWo6IcCYVmie/B8+Q4sz7yTz75JLVajXa7rULfJAtCivl/ktt/c3MkWY7QSBFmmSwv85BjEnycComIRkif4dqwDftXoXMfpn2diatj+CGqLLDrJbHw0RkTI8eUBFXCxLw46WGMQn2bac7HGhroGDRxyBzM0fvBBOtFh2l8liReCJt4GqRtiPhVWvqImudTeAee1D2uznkcndHAd38ElrQZ0502qC3EeF2fUELDYwx2hMS1OJlJj8zOPHE3wuHl+9x/IkwtfwasEkSXobwCjj8Dj7EwtOrozfcoJS2mGgxdl5gbwhpEGBfHxAowmELrHpQOIL4MThq8AcxHBvSiI7q5LJOdMfkHkPcNvPMO+2Xo34a0A2UDPuH2catf574WgnQO5opgupA8xzC1RrXVoJ7WMQunIbbCxNboxGPg7pDb/kNy4wnT4yxzuom3adMZVZna99D6Y+aPKvT9Gxyt3MB55meoRl5l9bsPmdRCHF7xMNfysNwB3oBcBczHgCSc8eH8PPYUsIYQq86oXN0HPTurNHA0Q7SRy+Cb0Pq3zHffYr09IGFNSb4AveGQ2IMKE7/GQqRF5BD2emEGmTCxqUPC9iiMdbR+g844jBmOsNOy8HagYoBR0ZlcXIJ0hnjziI8eNjFaYFmQy8BLmsHI1VnvWWT6YN4yKcy9TvYUbBvwMK1RCfmUw7DuVtGqcDEFeghsWwc7DETAm87at2Hi5zIcvvA8/6n8Dou5IYtai8p7UZjm6CW6pBoROt/X6eVGpE0de5jCM2zSkSkRwyMchW4b/PQs/M63oZwAew76pyA+9elfm3DbHxNDIx1zSD8OlTwM63BwGY6eB7c4k8NHvRmYtyYQ6c4Y9OgzkNgwmfyrW5z61iquu8o9YAmPx8kTI0yXEFUg79c5zxjbXeV1ltnVV3jCg9NMMACLKBo2Nh4+TUJEaJDCJU6CFAmyOCSI0eZF7lEjzzvMUSSBjsGYCGErzCyT/cfb/lSD7iDQkQelbLIQFJlXkFkNsoQC9ILtJIT9FfY0CCKlcmyapgIfAuzg/YV/0PcaTNgOvkbAsOxDUO4ui04BXFIhz2Qy6ksWBQJYBbgPBgOVthssNAjzCu+DawE4Ag7lnAS91JqmKW9osAIvVX6pquu6/oj0N+j7Dvq1ZT9l34JASoCtHJd48YKebpG0B73XQa9vUP4d9AQHveVBv2/wNTKWgmBVfi6LyuDnB8dVsKAjoFlkfieLHsEkdFkkBVtwSTiZANbgZwal1L7vK9+hnH9hkdrt9iMMvuybjEH5/0kQGmTpRSEg504+WxifRCKhWDK5F+Rvg58lRQhpqyZpzEHgHWS4g+z2ye2DWPfgscg+BosJwev8/w/ADfAv/+W//N/8fSwW47d/+7f57d/+7f/V16ytrfG1r33tT2R/dnZ2mE6nLC4uMhqN1CJ/f3+fjY0NSqUS0+mUdrvN8fExe3t7VCoVVlZWGAwGqkd2pVJhcXFRtZ2SwlG/3+f4+Fh9Xig06yVcr9dJJBIcHR2ptoXinS0UCsDsejQaDeUtfvvtt9nY2Hjkeo3HY4rForL6SMbDgwcP2NjYYGFhgVwux/7+PhcuXFBhWhKCKIUdmb8kpfv8+fPs7e2ptGnPm/UoFgVQJpNRAWriLRV/+tbWltrvg4MDarUaGxsb6t7M5/M0m00A2u02nudx+fJl1V5qb29PpVsLmJPU5ccff5ylpSXl7ZXiXyaTYWdnRwFCXdf53ve+x9raGk8++SQ//OEPWVxc5IUXXlDAXe6xQqGg7rVMJsN0OuXw8FCpeIbDoWJkPW+WjC6+aLHb5HI5fN/n+PiYeDyObdtEo1GVyxAOh1leXlYMqeu6LCwscPbsWR4+fKgKA2JLEO95tVpVhdrBYKAKzBJo1mw22d7eVkURYbZjsRgA2WyW0WikCu+NRoNLly6psFK552Tueeqppzh37hwvv/wyV69eZX9/X/mYb968ST6fV/kA0uO+VqspBlsS5kVFIQFs8XicO3fuMBqNVAcACZRzHEdZLQaDgbKqCaifTqfq+VYsFnn22Wf5wQ9+wPHxMaZpsr6+roB0uVxW53NlZUUVh2zbVu1Tu92uAs5Bu5w8pyTcT5QWiUSCVqulil31ep2lpSXlxf+T3v6bmyMxcfAos8qQEXkm9PDZZpfHM32KCzAdQ3sHjq9H2KsmqJS7LK+5DLbTmJMYPm02tDpL/sxVauMQY4SHQZ8sx/UUfmgA/RgRoM+EB4RIHIZYP3AYbYCbg5gfoqD7FDJTsKZ4kziNHvS7LsWhT3rdJrzuY+kADrhRmLhQcLCmUY4MGxMwSHPMhJXRJs+8DflQkxtn9rj+GZ2D1RXQViBtQCQ80zG73ozhnnRhdAOjVMe+DJN9Hf9hCN+O4+GS6oN5A9z1Waux0b1ZsFhoEco25Ooe9uEeh2dijOqQnmjcq0UZRnXOnLPIzIFZguL6jBVN6xbZznfp2adg/mOzft6NFomdGqs+dKI6GDZ07+JVR4wowOMWoaUhhX2YaAO6Cx4NE9xMC3auET4yqJIjH60zuf4faedP0bzwZ3il9//CLK4z/fhFfGsH4+4rxJxvYsZHeInPgH1qlg42Nw+RQ7j9Lvi7REKH6EMPJ1uBkAlmEzeyjD99D3om2E0igykfj03RE3CjDbGig3/QIjaKY237mEmblh5jvJyk4FfJ7I+ozfnsryfwzp7FeVgl2rnBcAh9C9Y1l1ZxgOm5nDlssdCG2gSyA8hHIBQN4cUiaF2Lzm6YzjDGyvyISM/DnIuSPGczjvlkgY9nfQ5GkOxAwZx1f+PiBIwkxA1gAjFrVvWJZpk89QkenjXoVL6GoR3TfWfIwjmXcVbjlZ0QiTmNp3Me0etTSsdZImaW2q02Zstm7PpEokASugmomBrthE/osZkH/Q46QwwyuHghh5IOlQ1453ForIObgGEflidwugV1oJ8BcwojbWZn6Jag9AUI3Wuy97BAGItTpNDpYWOQ5goeDU5xmxUS3KNCjSKLnsV59kjSo0sJnSXGuEwIY1FkgEETnyUcIsRwiBCmSoYWCSwOiNHFZx6DGrCCRpwE/92BbgkEC0qyT4JleBT0ibxYQLSAJVnMwKOhTAJGg9LfIAgCHgE0AppkXwQQB4GWACkBtOKRTqVSpNNptT/CrCQSCebm5hTAEZ9vsPekLAwAFdIi7yOLI3n4yvcgGJPjEHbxpMxZfifnVFrWCFMvDEcwpEsk+UF5eDC9PbgwONmbWWTrxWJRAb8gcJZKflBZIOdY2rkEiy1yPYKS7iDjIGMiaFGQ4w2y1HIs4tcLXvsgaJVxJ1vw33KcAiKCXlYZXyJJlfHX7/fxff8RCXc2m30kD0BSjGXfxL8pWzBMRo5F7h+5DnJ9g1JwUVpIkUM+f25uToFvWbRblkW73UbTNBXKJedbQB+gzn+wMCOfJb+TMRwE5vK3wfMcVFQEwXqwaAF/vOj0QYD+w7Q1Gg1VCNnb22MwGKjCzObmJqFQiAcPHnD37l329/ep1+uUSiW2tra4deuWAhWbm5tomsb+/r5Kq5bFuzBt58+fV62K5Nq1222y2Sy6rtPr9VTBSxKmy+WyStw/PDxkd3eX5eVlxaoLe3d4eEi9XkfTtEcCI8UbfPHiRZ566ikKhYJiSCUFWsBuu91WoO7MmTMUi0Xu37+vZMWdTkeBQmGd5fUiI5a8DEkPF4/83t6e8vuKX1a6PQwGA27duvWISkYKeu12W3mCi8UinuepDgDFYpFMJqPsQ3fv3lVS9fF4rObaK1euUCqVOHXqFKlUildffZXj42P29/fJZrNsbW3hebP+3sIuptNp7t+/j2maNJtN1QpN5tRKpaISxCORiOr93el0iMfjqqWcnLNcLsfh4aFiUofDIa1Wi+PjY6UEkJR5CdCTz5PCh0j35+bmVOhnOBxmfn5eKXbS6TT5fJ5KpYKmacpqUK/XCYfDVKtVFd4o9ieZQ6RFoVizJpMJx8fHhEIhnnjiCT7+8Y+r6yPFFCl4SwFD5jjTNFUGiOd5SlWXSCSU2m59ff2RjiKeN8sJEdAshQnHcVhdXSUajdLr9ZRlTMLfUqkUrjsLMpVidTabVQVVgE6no6wRkpoezCWQ7AJAFbBSqRSDwYA7d+4otZi8v4wx6WX9Yd7qdNFYwCBMlX0M+rjk0EKHbFQcQhF4+EO4+wewX81R9+YolbqcOge3W1MakylJPDYTPbSIx8NuhJC/wGl0orSYAPXeKnPmQ86FTGqYxCgQo0tEt1ncB68Awzz0Q2n0YQrdaxDTpmQNjbKdoY+LN+mQ24fwLmgrJr7OrJ/Z2IUkcDghdhRihI5jFCg7aXQcRuE9Di4d8M4veBx/ZBm/cAom4Vn7sYgDzhRsC9rH0LkL0QZWJMXumUUoxODBhF6nT9McEjoCvwvpHsRXoP4R2InDJAKL52C9As9jc6tmc5SH28/6dI0IFAvE9vZZj0M0DUZ15vXVNyAd69If/xB/+93ZvmhFHH1I04G2pUOnid5sYw4dvGIJvEW6icvsL7+MsebwoBhhnHcwMjbu3Q5royt4hNgPG1j5JBRd/NOfpr20CmtnwcjBe/8B//g62f06iez3aW21cAtfhk5+xmZnE5DJErv/kEtmg/gRtA6PoAxGCLpWA3f1GnYpQju2xH74Mv+PxpC0eYDeaXPZh/yqyeFE556jMTeFhdYA82DAKA33rvjEh7B0PGY/f5tRbolJIcYZe0L31qwf9cp8i8PEkEXfp2+DG4OkDrd64MxNyVtTBgNIdxdJk6R12GLa6lI+O2U9BwsFSNnghCAZgckNmL6uk1x3aP0PNsSjYGmQGIIxnSWsj3tgu5Ccw8pEaGXg0I9BZ8Lm51y6/5NBW0tS0XukH5+if7vB3MM4kU4cZ6AR1yxCfhIPDVNzGPpx7NwAP24zPAYTlyQZHDSixQbrOdDmwVya7Y7rQWEEazcgfXNmXzibg2YMti+CEZ1lBGQKkNkwKT48JMs6aeZxqZPGYcwBRQ6JMaJOkVvECOFQZpsMe/hoTDDIUiGMy4QIR4Q5pE2IDHP4hDDx8UhRYEiCu0QxWSfGHD0m9AHvR07wn2T7Uw26RcIW9NKK5zWYgD2ZzLLdg6AzyDQKWJNFoTCXAgTg/V7LIl0VplHeF95nOE9KmoPBbsIaymuELf8g0C2y0FQqpUC3AC3gEWZcwJt41iR127Iser2eOh9Bb3cQ/AWLAnIswU2OUQCiSB4FuCWTSSUNFNAdlG3LscrPJIBHzokAZFmwi2x0YWFB9UgNhsLJOQ2Cbvm9hJ5J2zVhraQIIoBerqWcv6BXOHjNguoIYdGD4WUnwXbw3yfBXRDUy9gUYB1klwWEy2cKsJZe6BIqJwtDYR8lAE8AizBaoVBIqSPkuot/U5J3RS0RvA6yP8lkUmUKiNWhVCo98vlyL8r30Wj0SJp5UE4ZvGbBTd4LUMoKGRtyHeS+C7LiMvaChaTgeAv6xuU6fNi3YCK1fEWjUS5dusQTTzzB7u4u7733Hu12WwVSSdEjuDiHmWw8eM/GYjF1v+3u7rK+vs7S0hLT6ZTV1VXFcIvVQeYI0zRVuJm0NvI8j1wu9whDmU6nFfhKJBJUKhW2t7dpNBoqzyKdTvPEE09w5cqVR8aygCTf91Wyc9CysrGxwXPPPacSzHu9Hu+++y5HR0cqNFF80SKRFquPzKWS+vzw4UOGw6GyuIxGI2KxGLu7uxQKBarVqgoty+fzXLp0iePjY4rFIrlcTsmW19bW2NraUvM2zMaoaZrKjyxJ44lEgk9+8pPMz89Tr9eJRqMcHBxgWZbKf5D7rNvtqmfV22+/rfz5AqK73S6pVIrj42MVeNnv9xkMBmSzWXzf59lnn1X9oyVdenNzk0qlwoMHDxTQ7na7rKysYJomvV5P2RDW1tZUq7bBYEC5XMb3Z0FtmqapcSlzXiqVIpPJcHx8jO/PgjglkK1er6u5SaxPAlAnkwnf/OY3+fKXv6yORYByMplUvaclrVyAfrvd5qmnniKRSNDr9Xj88cfZ3d1VBRYJ/dM0jVwupwC87LvI9+VaP/XUU6yurj6ixAuHw9y/f587d+6ocElpIWaaJqdPn1ZJ8KImExAv82Cr1VI+a8lHsG1beeclYX4wGJBKpVTxVc6B67oqLE2eK2IPk3EjagUZAx/2bYBJlAk+QxoMCTOijM6p4h5PrsLeG/De/xKmfaDRdV3iOkTmIbQKUy1KhyhLxMDboxefEutG0GjgMCFOBpcuNmn2yLC2WGO12cGypmzM9Vg77ZFOQrQJ0y5M0UhyGdM6IFW8QeWKSbs1ofcgwajsMC7DMBzHj/mguZC2ZrLwYRoSIQpLfSJHt+lrIRJuGjfT5t6lKbc+kWbw2CK+VZo1Gp+4YAOxIfgJ6LcJj97AcLuM/QKET8FGAZ6Lw8iH3h16/TCvXHOZ7DS5rHuMNMjMw7koHFjQiUCpDEtT8HtguNBMQnzUI3ajT6k7A3+x+zA5gGwM3ruvcTyfJle9xvn8hOMFg+388/Quf5xvVu9iFc9CNkWm+/vEAXO1CBsXcNw1butzoHdw6bBovkPygc+D4whDxuSAcSyP/dGfnzHXw92ZdL66M4v7DsXwY0nGPqQ0h2T3Jv3QDTDCJN/594TGKby0zuqwRbQKgztJCoN5RpFjIoUxsRhoI4/M0gQnu81rZGh95K/QevANypOv0k8CIYgve6xMIfx9jURTI+N5VFOgb0GsB/F3fC7cPmRnoUX9rE0+C14D2hHYTMK8OyVXgcMw+CNIAOEIlMKzvuq9DfBqA2JmCE/XKbshjDDE78O0AW4ezARELejtali1OMtti6Ov7eL8XzcgEgItMgPd/hiSBowBvU4438HVdHwvQ7Xt4bbHWE/OYycWeaW3jf5siOJ8l0+/N6J8debzn4w1tLFPTnMZRy0cx0aLuIzuQfI4ymLY57DcIrcEj3/MY+5xaMVmKfiOA9MwRK6D+c1ZOJ99oDG8tYxj+Gz9hUOGH/FpjiGyA5MHMcIsEWEdiyQGBlOO6KR/n2zShdo5PD+Hi0+UKRdxybLKfcrc1jr4DMj7KUZMOSSERwgTjxt4LDNkhQIa8zjUSZFHZ5kqOjoxogxx6TLB/aAp5X93+1MNuvv9/iNhX0EmK5h8HQTluq6rxaMsvIMSXwEZQVAMj0pXw+Gw6gUti375HGljEmTwgpJlWRQKGNJ1XSXnysNcAsVisZhKgBa/rIAVYUskDC0YDCX7LgvkoE9OwFaw2CD7Jw/iIFiR45eCRNBjLA/04Hk9GWAlxyUyaAFwwfAwYQ2CYEuUBQLg5JwGFQpB8CoAVmSvwjjJeQ8yx+LzlJZgQXb0JIgWhj4oSw4C/KBVwfffb3El5z8IsmU8nCz2BF8v+yrFGhnTUjiSlkaAAsLicwx6b4UdEam+JOAL6Jb9l8WqSHCDabYnQ88ABbpF1i9jURZqIgWV6yH3irCHMl6D5xfeD9uTQoMcg8iig0Wj4DmT+yt4PYIFteCCU4olJzMHPqybzC3iU5YQtIsXL5JIJHjjjTfY2dlRTF2xWFT3higlhIWuVquKZUwkEtTrdabTKeVymaOjIw4ODrhy5QoLCwssLi6qMSvjXYqZAsgSiQRnz55VKp4zZ86oApgEQcm9mc1m+bN/9s9y48YNBawLhQIbGxucOXPmkdwNAZitVovhcEi1WlUMebBoIGOp2WziOA6PPfYYCwsL3L9/X+2vFOtkbElBS0CUrs9S2uVZIH8ngFbuIzkPlUqFZDKpWOnbt2/T7/fpdDq8/PLLxONxzp07p1jL69evc/v2bXq9npK+FwoF2u22Os7Dw0MajQaO45BKpVhYWFBKoUgkojzAw+GQTqejUtcBdX8cHR2pzIPFxUW63S6TyYTHHnuM6XTK8fGxkkM3m006nQ7ZbJZYLEYmk1FgMJFIKLBWr9dZXFykWCzSaDSIRCKq8CCFObn2ItkW5Zo89yS0TUIZhRlvt9sASl0lc4CoF772ta/x2c9+Vs27UoSQOS2fz7O+vs7BwQGrq6usr6+ruTgcDpNOp3nyySd577332N7eVtcyODfJe8uYSqfTXLhwgc3NTcrl8iMtGcfjMe+++y4PHjyg3W4ry4Ts/507dxgMBqytralMFmG0u90uR0dHSkWwvr5OvV7HMAxyuRy9Xo/V1VVc1+XBgwfK7iX2t1QqpQIKhRmfm5tTMnhRGfi+z9rammqJ5nnef7H08v+aWwSdCseESQJtsrhUtD4XnxgRN+CNryTZ2a8wZcQInyJj7NDMEm3EdWIkcLE5nJSpHU/J+3MsckCCIXWWmDJgDjh0ljjQ2zx2asJCYULuaUi0wd4FvQccg25HcEhhUqTnRElmx2w97XFQG3J9DuJnIGdM6Tk6djwEU3uWTuWNIBtj+D+FOHfeZGkM25MBO4UIo4081pl5iEZgasJEm6Vdh7xZFPvwkHD1GnmtQzuThvD6LBvKmsJ0AdzpjGp0l5g+nuHthR2qDw65Mp1yzgW2oQy4BuhTGEUBB7b6cDYEetebMeNpiEbBjcwYbtOCQgRCzpCzeDRNOPZPwcJP4Z9aZDL8aUgaaHe+wtmGSWTHZzB+j2F8DZZ+Djf8Zcg6aDtfJ3n7HSJ9DW9UwNempOkQ7oewSUAU2Psm6eabxG2TUTrOaOEMXriAFjsgFrGxxikYXycxfMhau0W62SITAzyYPACjB4fpOg4TNAfS8+AOwL8HZ57wyNl3MGtfBe8W3bTG21OfTR+KFixHob7sU+v5pBKwpkHkAJpDeAisNuGsNqGZAx0obsJhZZYhcGkb4qeAeSh2ITyA7BQm0x8FqZVgutJm1GmTTEE6CiTAHM4Y8X4UklMoN2Gw4GNvjFh7O8PT/+9jXlt4Bf9zZ8GPg6tD1Ac/A4YFegMt75Dc8nD3GtQ2w7TWNWwnDm4IP2wzTZc4euosfxB9nfXMkPEu4PpE9RFrHpQzs/R17xaED8AzXEJPOax+FD66Oeszvh2FZR/mPRiMYeH70PnPOu2ahpbSmfbnGZov4pEk+6/+iEztHnPPgr8HraMcR8yTw2DCiHuMKZAjmfZZ/9SU+pt3iN7JsuKdZkibVWK4hHk91OdB3oZpm9JgwjikM9ZS5Jw405CDF5rStxxCpMkwh0cXjSghwqzhU2ONQ95jjj7mf4+gu9lsKjCTzWYfYcAEfAWZPwHM+XxegSd4vw2RbAKe5HtQkiyLmWQyqYCELMyE0RHGQQCyAE+RzMnfiPS2XC4Tj8dV2NR0OmU8Hj8STiUBVAKupce2LEJlESa+WamUO46jvgelYwJGZQEqUm0BInLcwhjI/4O9pIOso7DTshAR2fl4PKbb7aqfi5dMZJzC2kprIXi/FzfAcDh8JIzspHdfQO1kMlGgTxbGsng46eUXNklAxUn/cRBkC2gL+ohlPwTIfRDTDe8HyAX94/JzWeSJ/1oWwMLAwPv9veUYxWcvxQWRdgs7KZss0KbTqZJbyrgQ2a3sg2QJiD+/0Wg8EmYnxydSW5FnynkQJYX8rSz4RGYZLFDJ3wSLYHLO5Rgk+VfGea/XU15IQKkRgkUXOYdSVAoqSgRwn8xJkMLTh3nzPI+lpSVVgMlms2xsbHD+/HneffddXnvtNZrNpgITkUiEvb09tre32djYYG9vT/lthXVtNBqkUimGwyGxWEz5VSW5XBKns9ksN2/eVF7V6XSq2HbpuZ1MJjl79ixra2vcunWLr371q7z44ot8/vOffyRXYzqd8uKLL3Lp0iU158uYkvtcpOGJRIJarca9e/eUBzqVSpHNZnFdl3a7reY06Q0t1gdhAK9fv06n06Hf79Pv95U8Wtd11eIrGPInYFZAVCQSYXFxkV6vh6ZprK2tcebMGQV0isUiBwcH/PCHP1TtpjqdDr/zO7/DL/7iL7K0tEQ0GmV5eZlWq4Xrupw9e5bd3V1c11UtA69fv879+/fVs0zUR6lUSvW03tra4uDggJs3b6rQL3k+irRbnnXi987n88qaIs/KoF1HWjBq2qy1lii1EomESomX56Ow6qZpqmKtPBOazaZ6htq2rZ6NkqYv826QgbcsS/WgTqfTaJpGOp2mXC5z/fp1CoUCb775Jq7r8tM//dOqQCsFbwmjfPLJJzl37twjye0yz0nx7/z581y6dEn1rw+FQkpxIAoBKeA988wzKgjO930lfZfWndL7W9h8eTamUikWFxdxXZdarabyBaR3vbRJC4VCrKyssLKywvz8PDdu3CCbzapCpnjF5Rkk/c5lTIitxHEclcAPMzWMjO/hcMjR0RGxWIyFhQX1HPowbw4ay9oI259QIcUCOlvpPc5nfN67pvHyUZkODmES+ISJeD32r4bZLttszPfZ2BtgejkGfokpITw0wiRIEWLIhBgRlkmT8Ivs720zWO6SSvr4yzC+BM63wXsIxSRMjTGj6S4jLIa9NUZ/2CSxN+DCp6ZYF2HnJhT+k0/4pxzaP+Ng2Ta+EUKPOHgTjd6LaW5fGkBDp+9l8RJFiMZnKdVmGyhCOgnxFNQicG+XRO8GJavNOK3jZFfBLUPnDoTDMxZ0UIXudNYs2RxgFZ9iRz9H/fo1fjiyCNkucz2LSs4iYdgYhs8wBa2ExsSJks7AXMjHssLs92MMEgaRpEO8MCSXmVDswS0jz87GFZyzn4PsAnhjKMTh8HssfuslUj80mIxDnLrZ4N7DrzP6q+dBXwcrjr94hf5hnqLbhXMFBoMp7mEEP5+AzE30wz+i8uD7nNO6aD5MRnBsHbOXXqFTKDB2TCabFzAOuyzfaHBo6UTysBny2LFm7dJK1gg9C147hNdM0zN6pMo+VgGONfByJhG+Q8G1sS3I+7NUcceY+ZBLS6DNzQLnpjHQa1BqzRK+40XIz0P4Huj7Yewtm/Qq0INGHSwfrOysw9d2F0JzkHdmygj3mobdN9C9EJGxD8Up/WMYJMF4DMKp2VfTh2YOwiXw9RHrL4H9Lx7yrtXE/uwZcMPghWDqwcSByBzdyPNce/IuztkQfjGHnWtCeArafZaibbpM6YWTNM7P07yYBzOENmpgGBP6xy7PjWDpDqRfASsG7U85GD8NsTQc6+BpkBmAroEzAY7AfQ1au2UmzmnKwyI6FhojXPIk258l9R9DGPE7WPikyLHOEgMi1GhwzIA4BstaiMp5iJ+bsP/P7vD0wWPUmTAhgkmEfugYX9fAgSERPC9PjhEFbIa6jhOacozGCm1yzOMzR48uoBMhzKE25CjUIed4FA0HfoKus3+qZ1UBt0FALcBUKr4CTOVBKvI8WZDD+8AiuJiXLcioCYAT1ia4kA8y3SJ7k88Q5lYq+oPBQC12BFiJz1EWN6ZpPsIKC1iR5G9hI4Jtv8S/JvsUlNzKwz4oN5MKuIAUAfqyCbMdBJWy2Ap+RtBbK8WH4PkXpicYnCbXK5hCLu8p51fOq7CXQX+2fHZQKi2MqFxXYU+DNgG5lsHrKe8l+yfn6+Qxyn4HCzHB3wULEyel5rIPQTb8pPz55PsEk7iD58iyLEajkUoVDioDBJRLaI54aAU0n2SXRT2RyWT+mC0jeA6C10mutVxjCdwSpkqYb7l+ci8Ej1HGotyz0qc86MMMfoawjQIQZDzL/S77GVQhyLUKMttS3JAC1Id5cxxHgTYBpMvLyxiGwTe+8Q3u3LmDbdtKSi3z5M2bNzl9+jSrq6sqjE1sL91uV3mARQIu4+/tt98ml8sxGo145pln2Nraot1uq24SmqYpplsArW3bvP766+zt7an2XB/72MeYm5tjNBqpYoBt2+RyObLZrMqKkEwIsZ9IInqj0WB3d1dZXCT8a3d3l9u3bxOJRLhw4YLyT0v6dLvdZn19na2tLaU0Ed9yv99XagHp3iDMq6ZpSgFimqZin23b5vz581y5coV0Os1gMKDRaGCaJm+//bZqwSb9xTudDrdu3Xqkf3Q8HqfRaChv97Vr1zh79qwCY9FoVBUIJEBL7o+lpSUlkZd5Xop4ErwlHS6kHZVI+ROJxCPXTkLhBOjBLInatm2KxSLFYlF1tNjf31cAO1jgE/m2KAAcx1EsuoTQiS1ICqa6/n7rOphZysRyZJqmAv3hcJjTp0/zxhtvcPnyZa5fv04ymeTcuXOqUKxpmsopuHLliirgypwihex4PE6n0wF45N6QMFFREnQ6HQzDoFKpkMlk1Bwv4FV801evXlXz9dbWliICxLohc7DYQZaWlkgmk9TrdQBlLzt37pwKVC0UCvi+r/qKe55HPp9X2R+iKhOFgMyjck3ENpHJZNT/JcH+8PBQdQn5sG8uI5p+CJcRMSroWpjluS5GG/7gvRjvYBJnSIkF4sAQE60e4+bXIpwqjdiKPWTHPIeFTgEThx5dbHrEiaOTJopFFcN4QMi2efPhGvmdGHPuPoVfHBH+GES3IVGFQthCY4jJkC5lts0C+ts2F/bbpJf3GVRzDI5jpMIHRD7m4c55uEMPdDAiIxxbp5tdhKwL0ym4Y5jEYGLMWoJNbWi1ZiinESWzd51nvDYY8G5CA1tHb+yRu33AOALjC6NZFHUoC3Fv1gOqnYSNJzC3nsTUNfBGNDo9bnhtQoNtcq0dQqEJ3eg6VuECEJ31FdPKM7o7k4dRC46uE2q08G0X78IKXH4GMiXoH0DjAYzvUHjjHVbfGKENUxyTIuWGKT+oM7pzF56oQN+E0jzj6Cr+wzba43V6P+1x9a0O0zMu4ebXOd2p8ZznMDShPoT8CCr7Nun0DrcjScylRYi7ZMaHlMZguR5RfxYOHytqhJM+bgi8OqRDoC1PmC5AenHWyazVnlnk5yc2K22YeKBlYWJByIfWXfBrOuU1D2cVbhahlYacA5EBhDLQjUK7AGbUxl2BtTYUGtBdgr4GxgEcuUACloD4BHptsDsGnpVCI8t0CjVvD6Ie1gCKi1CIQmMMu3PQTEAoDI0XXdz7NT55+CSRf3eVG5lD+ueXIWxAKARaDDoWfqKAdfkFsIfg66Ctgb+PNrpDe+JjxW3oHAAe/lwI4iH8aBJralA3hvhhlxhQL4K2CvolIAOGDyaQ60PkPjTKMB5A9wdQ34Gal8NhnQweLnuksMkSJcsKsfEpzFceEMvaLLslkmTZpYuLSZoOq8kaZ88MicTByEN+s4V/0CROBQ0LF4+4NUHr9InZkCbJgh9hCRuNOFPHYS815b4f4cJEZ8IxHlk8dBq4HOHSTR9hLcAPd+f5pNUHfvywyT/VoFsSRcPhsGLygjLGIBss4EP8vBI0IkBKWmkEF/ACgIBHFg8CeoK+ZZFvDYdDtZgSkCLgWB7ChUJBMXeSPC3hVAsLCwq4AAo0tNtt9UA0TVP9X8BJsKWUtP4Q8CfHIWEwJ5lReQ9JPhd2MMgynAyzkqp5kPURkC3p6dLiRAJZMpnMI55ukRCLNDEo8RagHpQUB+XaAkyD3mvx7MkCS1Jug5L0IGst1+ykx1ped3IcBMGifAUBtBQk5LsA1yCIl8KBeLSDyffBvIDgtUwkEo+MWUk2FuYqKDeVQkkoFHpkbEkgULCYISBX5LeO45DNZrFtW8lZ5foGw+cE8DSbTcbjMa1WS6VgC8AVxjm4cAuCbBmLYlcQ9kxaWYkvP/j5UhiRcx0smgTVBOJHDtoRJItAfi9j78O8zc3NcXBwwGg04vz580qe+sYbb/D6669jmqby7TqOw8HBgepBLe3dtre3FZAT4CSKB/HVptNp5ufn1ZzbbDb5wz/8Q1544QU2Nzfp9/vs7e0pRYQwc0G7zMLCgmJADw4O1FwhYF0k5zLvBMeG3HP3799XcnlhLWVs6rquepZrmqbYUsdxKJVK5PN5dZwC6JaWllheXlb3Qr/fV4ocafOXz+fxPE/JqiORCBcvXmQwGHDjxg3G4zFXr14llUop5YbcXxIk5/uzrghLS0uMRqNHAuEE5Nq2zfr6Oqurq9i2zd27dwEU+JJibbPZVPORaZrs7e0RiUSUhUnudVH7FAoF5UNfWVkhGo2q6zgajZQEXzzelUqF3d1ddnZ2VBZAMEthNBpRqVRUcURUOaJoEnuMKBiEPTcMQ51neRaLhWU4HKp2a8HnjrC3uVwOz/NYWVnhzp077O7ukkgk2NvbU0UXUUW0Wi0mkwmXL19WYF0As8wpYhWQMS/7KPOW2Fik8BQOh+n3+ySTSUajkfKuyzFNJhOazSbRaFQpy+RaBW1bkosyGo1U+FmpVFJ5CeJFF5WctLkbjUa0Wi2i0Sjz8/OqtZw8y+QZI7YACdyURPlut6ssGlKorFarqijwYd7mIiYHmoZpH3LaWyZmHLF+yubNfZ1vO1km4QFFNwLouHjsE6KATb5TJmF75DMddsyHjCng0cBBJ0GBCHmSlDHoM2aPtDFmzqnQYoMdL0r41RV6ndc49X/r4z8N3hFMXnbpdaNMCGHispeaYEVyhBsbTBtbuDkfLzeh32kS2zcJpyEcAmMCNj5OfALTEVjeLBzNsmffnRDoLhgWkQeHXLg/QhtDKWyz5c6SsRNTh5R+i9V3XCqveRychr1SnWmyhOfEoZSHfB4mrVl/sHgaRlVY0mBpGcZXcO2naA1qMHLAn4dodhbYlo+D14fBBAZdiOiw8X/CzQwJH/4HkuOX0K+9hZHycNwRkX6HNXvEYtUl5sFgaYDRNEg6Hpm5CXvdDl4kP5O+jy28ikHKhZzTZLKuMV3VyNk9Hnu5S74DXAEPiExhNIGjIwh7HkulAXVzh9TDHc7EpqQjwG2IZKCQh7WaTzgO7inorUIo41LYcgnHwDXBHEF0BOsOJGvQ6oJegHoFGrtQ+VaIUT1FK2Th9SxSrkvlIjwcwYNTUMnOaiP2ZMZ4L8Whq8N+D3pLkIvAUh8mIdCSs9PW+1GnuLAGZsEm6naJTfuMQpAueaSNWT5aaAL1BLR1MCfgZsHxdaYrUe4+ZbJ+bLJ+nKLw8JADo00sAUZUg6lG8cDjOnG2n7iCH89A2IJMGvwkfrjEwKtARAPXmlkRnB9lCzBBC40ZxTRet+FwFbqpWd6fFoNkH/IJKA0h+R6YO9D7KGg74L5apDmMEPHTuNjcxyJOlhRNfHoY2LixN0iGbLQjGPq7OHjMM0bLPSD1xIjFDZfcFaAAhSlM0x6m1iDhRxhF3qLtDTCcx4jY8yxjUiFLjAEeDiZxln2L7rgDXpYkSSZMqTPkiBBNuuwbESbzU8iH2K3mqU6T/HcHugEFBmRBD+97tOWBL4y4ACQBWvC+7/YkExrcgr5tAaTygBKQcJLxDr6nyOakSCAPS/F1CVgKtsM66R2Wh2Sv11OhNQLM4f1exLIwFbm3gOyg9F62oHRYzqUAWVmgBVO+g6D35HsFPdUCdAQkysNb2qsEvfcfdL7lZ/9rn/tB10X2P+gLPunT/qAvuWZBRYAAc1m8SnElWKARll7GVZD5DvrchcUJHkcw7Csol5bzH2TTP2h/ZZ+FzZX+ukFLg8i65ToF3yu4BX3bcmwCyIPjJHie5N4KdgGQY5IiiPxblApSgAqeMwH94qMMZgQIcJdiQvCcyHEKgJfPkWMJ7sdJtUfwGD5o3H2YNpFQh8Nh1tbWWFpaIp1O85WvfEWpbaQgI+dF5LCSlC3naDqdqjmnXC4rNVEmk1EgTUKtut0u5XK3AlT7AAEAAElEQVSZ3d1dMpkMq6urPHz4UIFamZvk74ThDBaopFAqtgd4PxhPWEZh7VqtFpqmcXR0xPb2Nq1Wi3a7zcbGhrJgHB8fq8AzXddVa6VweNaDO5VKkcvlcF1Xpb5LH2Qp4GUyGRKJhPJFS/6BFHKlGOu6Ljdu3KDdbivJcavVwrIscrmcsjjJMWqappjHzc1N9W9RtqRSKTXOE4mE6rYgUmxRIei6zurqqnoOSuHvxo0beJ7H1tYWMMtlME0Ty7IoFouq53Sr1VKBeblcjmQyyXA4fMSiJGFz8gxbXFzE82ZJ7JLNISxrKBRS50uK1MJID4dD6vU6qVRKFUZEeSXPJCkMiBpBitIyTyUSiUeuS7lcZmFhgZs3bzIcDnnsscdUkF+hUKDRaKhi4crKimqLJfssQaXhcFhdR/kMKSaKAk3604tCYDAYMJ1OqdfreJ6nbDyWZTE/P69AtxSzRdkwGo3QdZ3l5WVV8JDAQQmU29raUnkHgOq5Lb3OBcBL4r+0FpXWZAKs4f3n6u7uLo4za4kn87kUlmCWlxMsCH9YN02HoeGDXWCNBVZjN0g78PsHMeq+TtqxiZEhgoGPjUucIUnqTCg6U9zeLITJx8EiQRePKWNKRH+UcNwjg4452cQkR4ohQyzueBNWH8D0W6B/EbSLEPqIy/iGzoRVxozRp1PcsElbG+P5ZfyYBV4H34sR9k30IVj6TC2uT2CiuaCPQY9ACuhYM1To6tAuAT7RwzGVl1y6zSjbuocRdhlvQDEHF3ZtwtchVtXILvuUOhYt/QgzXOPAXMZLLkA2DN4EGm8TTlzFt8BpfBS0J2a+8cxZiPdh0IRxH/ouOGGIpSBSAKsDIxOMHcK7X+dc57skMw7LGpR3YKjP/L79MFRXwNCBgY9Dh9E0xKASxT87N2vgHApDJkTI1cmFIavByPUJJyA19knVwdyFTgGiRaj7cJABfW2Wq+YAL1pT8rfhVt2gZ3lspD1aG/BWWSdb9Shpsw5rvQT0bci1wejODnUtB2sxaHbhLV/DSvtcGs3I+t0QpKYQT43JbVh49w1G2xAdwFojzXRjxPwTHo4BocSsjmGMIG7BKAKVc5DuwKgJWgEmtVmYmlYBTDCOIBaDWN4n3HcxXIjHwViAcBk0YxZGFk3MJO1mBuy4BuUIzrJDSxsy8nymGuR7Lo9bsJiDwbtgvwqT9SHHGzcYRy/BKAF2DxIOJEqQCUF4BKMBuD4kJhCzwbHQLAfHhP0INPLg2RBNgR+GYh9i01kQWvytmXTfdsG5AfPDFC0/RIwYDi730fEpEEVjlQTnQy3Wn64TOQvjlyCV2ccctUi5cTKX+qz/JdDSMAXiPQjXoTeAFDWaqXtY53ep3U/S68SIojNHgjAZuvQZ/6hjd4omuqWT82zi7HMPneuk8MgxwKafmEDIpXi9R2XkMuInmx9/bND9/e9/n7//9/8+b731FsfHx/ze7/0eP//zP69+7/s+f+tv/S3+xb/4F3S7XV544QX+2T/7Z5w+fVq9pt1u86u/+qt85StfQdd1vvjFL/KP//E//rErq8HAGEl1Frm1VJwFiEqF2LZttWATFjfoEQ4eh3wJyBYGXeSwk8mEfD6vQGvQ+yaAS5gYQLECEnwjQVfCbAoTL2Bcgq1EXtftdrlz5w69Xo9er6c8u8GezgL6Jfk8FotRLpfVIkbYAUAx3qlUSnn4BJCcTKKWh7IE18kmxxjslyqvyefziiEIhUIUi0Xl8wuC+yCLHQTL8n9hpoNe8pNAS/q7CmsQDCULBncF/fnyvsKoC1CTc3MS7MrnCKAVm0KwiHBSbi/nKAi2ZXEpTLWcbym8BJnuYEEH3gcess+AWijJgi6dTitmXBawJy0TQSB+ctzD++215HXiiZRsAlF1BOX4Am5lzMiCOZhNIIUAz5v1BC4UCiqzQBiuYNFKGE4ZV4AqNkiBIJikLUUYuZ4nQwYBlbHwQff9h2kTn+fq6iqFQoErV65weHjIzZs31Rwg59GyLJXALVJl13WJxWL0ej1Go5FiK+WelSyKbrer2sNFIhEODw/V6+r1Oqurq8pDKmNFWLtcLkc6nabT6RAOz/pWNxoNzp07R6/XU3OTeGplDhcgpOuz7g/Xrl3jpZdeUqyzSM8F4NdqNfr9PqlUilKpRLfbVeoaAb2TyUSlPgswyWQyqsggzwB4X6GUyWQwDINqtUqr1eLu3buqCCDtDmOxGN1uV81z3W6X5eVljo6OqNVqPPXUU4TDYVZWVnjmmWfUM0zyEgQAFYtFpQaQIK1MJkMqlVKANpVKPdIC8d69e6rHdTKZJJfLsbq6imma1Ot1YrEYiURCzUUCtMUqsrS0RCg0ay23s7OD789SxwH1etlHXZ+FlIVCITVGEokECwsLqnAp8vZIJKLeW1LM5bMFoMvzTzIeZG6XgLHDw0MqlQq2bStFwPb2NoVCAdM0efrpp4nFYrz77rsAysOfy+XU8WcyGTqdDu12W7V5C1qNpKASzAiR54/M2zIndjod6vW6Yqxl7rZtW12nVqul/P+SgdLv98nlcpTLZTV2AFVskOeNAH8pPtRqNRKJhOoLbxgG+/v7VCoVFTYYjUZVjoHcM/1+X7WPk+etjBf5PAnD+7Bv40mEXsJimTgl+lyeH3M4hDedGH7UJDQKESKCgYmNQxaTCXl66Og+uI5BjCR9XIZAjAgaHhNSxOhQjt0mzpTuJIWJRYwkK+Q4pIZujHH3YHAIoy3InPEg2qI5nedeSGOs59FHOjE/h0GaxmDmLuc4idtsEz4Hbg+s1KztsmH6OHpohiYdbYbKbCA0RY83iV9zmHwryevXLxD2+vh0mGgGRrRO4TGI7kB/BM7TPgsaJO5DLgFt38XU9hlOGkwma5DyWbTf4Yxvcm2coZM2YM4Az5w1NXcGgAvJFERikD4LRhaqh9B6SPbWDyjU7jCJOTwobeCGoRXb5iN9h/JDyI7hZlLj9Y3T6FEH756B81NzaMYEb/Ux/I8+D21r9nncZdqt0rkBC6mZQn1h6JOpgTsP+XXQlqGam3GSXhhKSdAms/7PoRE0bsC4nSKdGzG85HFrPUZzbZ7k6Rqt+oRxDKw4mNM4xGIYiSmVkUnUhPvTKPtLK3ihAXN3G+xf9bCiEFqH/VW4aFksZuFgw8FtQfw4Qt6NERubjKxZjWQpDu4C4EGuDpEGGLfAngfn3AywliuzznC5JIx3Z2FpPrOiSy89a2c+Ss7YbS0G61koHcNgD86uQ2YK7ZxLyuoTvgZlbcBxpc/9jywQiQ7ovTdi1YeSDmQhvwKL5pAHjT6kLSKjA+x2CH++CPExYIGtg+uAmYbohJDjEh57RD0XT5sF38ftWaTAWIPUEPQWcA3GR6CVQBvOstzs9CHp/jJJkoxpkWFInwi9cIyh7TFIHhD9mE9+ESJ7oEWBQxOj5xEPz9qJualZy/HQBJIDqBQ8audvEr/o0RzD6No5HMLY2gG7WgXNm3CJHDk09ujxUE/Syxgs9fv0PJvXQgYDLcKzjs8+PsfGFL1mszmKsE6Nzk/AcsNPALpHoxGPPfYYv/iLv8if+3N/7o/9/jd/8zf5rd/6Lf71v/7XbGxs8Df/5t/kc5/7HDdv3lRy3z//5/88x8fHfPOb38S2bf7SX/pL/NIv/RK/+7u/++PtfIAFE4AgoDPoVQ5KxWQxCO+HZgXBnSwMgu8Lj/ZWFrZc2nbIQuIkOxlkauUhLQv+4MIoGMoTZNSDjJ20gwqCH8uyHmGx4X3GWyTamqYp1lq8scFAL1kUyvmQYw56nYMyOwFAcpwfxCQHA8GCkuxUKqWYfTleWYjKYkY+U66LAOMgGyv7GbweQYZYwJgAh5PsfnALAssgo30yvVteG2RspdgRbPET/C7nJwicZYwK4ycA+iSTe5K1FUB9kvUPSuEFhMj1F7+tMIVBNlqYXjm/wZ/LfRP8bBm7oqQIWjFO7vPJsSD2D1loCkCXcyhfQTXGyfMs91nQgxk8v8ExLccj10Luq5NzxIcddC8vL2NZFpVKhYWFBQqFAi+//LI6l7KoF/lrqVQC3m91KIUbAYqFQoFSqaQYuNXVVRWe5vu+auckHum9vT10Xefs2bMkk0lVDBXWVFhFGYsSTPWVr3yFlZUVyuUytVqNUqmkijkyzqXo6TiztPO7d+8yHA5Vn+disahUE6ZpqrEovxcQnE6nOXXqFMlkUrG1t2/fplqtksvleOGFFxToEkY0FAqpLIN79+5x48YNFZIlraI2Nzf51Kc+xf7+vgoVFLVSvV7n1KlTnD17lo9//OOqmCGBZI7jUK1WlTxaVCWNRgNd18lms+RyOXx/5ttOpVKqMCLHEAw+FE/51taWkty3222Oj4+VRUBk4QLqE4kEFy5c4PTp07z00kv0ej2Oj49ZW1tTfaFlrDz11FNUq1U1FjKZDAsLC2q+yOfzqpuEhJJJAKSmaaysrACz4qHYYuB9pl7uf03TqNVqVKvVR57dMq7kNYZhcOHCBZWYXigUcF2XcrlMNptVxaVqtUo4HFbnrlwuY5qmsj6IHH4ymajcilarpQoeYhGrVquq1VfwOSbtSzVNY3NzE9d1GQwGZDIZxaRL/3GR9gsrLXO1tFCUeVA88bFYjEKhQDqdptFoqNZmkilweHjIqVOnWFtbU/Ov4zj0ej3a7bZi6OU4otGoaq8nxZmDg4P/ovPVf41tmXmsaZ0l32CBHoWQxStd6MSiRIw+8XGYuOsx1es0fIOSH/tRH1+DkBMmErUIOx0c8rQxKdGnSJkkGXL6LVYrY4ZtjfRk1ryozhRoYTBPy4wS3t0lsj8k34dKDuxSk53jPr1iFiyHRD9LiDBRbJZGPlNSGNun8H+3i7E8wJ4DqwaREiQdj7E1wPJTYCcgNiE0sfAdFy3uod/zSd+dQ/fy5GlRSLTRI2FiI41022eaAWcL7DMwacDoIVgZsHKwuuXhJ02ut/Zxhk3W3jWJ3AXrlAcvjiE6BacDlgPJOISSYBVnUvO7PyB743Uq71bJ1ts8mRlwFIE/+MzPY33if4bD93jo/1uK4fucO/Lo78FOcR5r8/8CpwvwcW/Wp81wIJGHVB7cA6heg3t/QCxywCgHaz1YPZxJr3M6GCvQyMDuCmynwOprLI98tA4cDGEcDfNHiTxcHvLRzS5WDl4+V8SKOlxuHbJQd+jUZsyzO4b2aExyfkK06xPbg/4i7Dwxh3N6i7XvfI+Nmx53urCWB20b7p6Jcc8b4WtRupdgqzol27Po5xpUMzNWetECprChg1uHYR/6iRmQTqZnbdZCGoRWZqFjzR6MSmBnIDOGyCEkxjPm3TRmtRatBqP7oNfBGMKqBasFqBsQc3x6OnjPH1BchXvhFJP5BO8d2uy7Dl9Y91hNgbkMXdulevyQlOGy2Jtwy4wzKRVmpmxzSCbaRQ/5eH2D0nhKybSpjCHWhLfCUM/Pigp9H/I1uLIN+TtgXQ1hZl2IQGwy6/muPYDNfhGXELsYOGSYxof4EZdQb0x4qUbuAkQNiF6C7l1wu+CFJ0TmQLMhFYGIAaMwuBmIPQH5Ky6pKDS/D4u+honHrcyIg/Q+scYB4ekqa0RIMWafMrrlk/Jc3ibDcSzE4+MwVwhjY3BzkCPp9UmyT5QDslg/0ZzzY4Puz3/+83z+85//wN/5vs8/+kf/iN/4jd/gC1/4AgD/5t/8G+bn5/n93/99vvSlL3Hr1i2+/vWv88Ybb/D0008D8E/+yT/hZ3/2Z/kH/+AfsLi4+H94X6RntQAwCXOSB7swnUGZqeM4DIdDJamUv5VKuzC/wsbKg10W6sKCSEsaAd7ygBTmQECR/L3ruqpVS7PZxLZtlQwrD+dgSy8JTBMGWY4n2JJMAEcwbMu2bYBHZPTtdptQKKTCYYT9S6VSxGIxKpUKgHo4C1CVBY34dqVYILI7WdgJYAombQfB98mQLGFyRK4ni+dgsFewF3kQMAXl+EFQKpuwm7KQP8kSB8eqnCdRGQQ9wkEWPPj9ZBK4sNLBAkKQXQ3KyoM+8SBTH7QpiCVAzr8kzAf9diKxlb+R44AZ2JRzKn6+k4nzwfMRZLTlb6VoFZSICwMlRSP5W9kfkSgGvdbpdJp0Oq3AWrD3rIT/BX3nApJCoRDZbPaRoKter6e83lJEkGOSsTIYDJTkVo4/WFCTfRYA92EH3ZIOvrS0xGAw4ObNmyo4S5QAQbuAaZpqfE+nUzVuQqEQ6+vr+L7PqVOnFEMtvtzJZKJSq2W8iSro9u3bPPfcc2pMi5cZUJ8hrexisRhzc3Ps7+/zgx/8gM9+9rOPqIvE5ytjU+ZwGXOapqne0EHFiIDQzc1NxcIGg/wk+GoymXB0dMQbb7xBtVqlWCwqj28+n6fb7argNE3T2NnZ4erVq0QiETY2Nshms/T7fTKZDD/3cz9HOp3GdV16vR67u7tsb28Tj8d5/vnnKZfLjyiwlpaW6PV6bG9vK/AsTL+0eBIVVDweV1YAKQCIT16KHCK9X15eVvJ9YaRFZeP7Ps1mU8nc5Tkh7K0EormuS6FQUMUTAXwbGxtMJhN6vZ7qSrG4uIiu60qGLcoBuRfD4bBivqVPdb/fV2oD8X+L7F+eYb7vqxR96cstxRgpMG5sbACzuTCVSrG/v4+uz9rmSRq6SMAlgG0wGFCtVjFNk52dHZWRIWsHeT5IoKioR0TVJTJzOV8yhoOqHVGUyTgURYhYEs6ePcvKyopKspdnZS6XU/OmjEOZw2Tum0wmVCoVdF3n/v37qvglz/fTp09z+vRpHjx4oJRPMv41TWNvbw/LsigUCsrbLrL3/x6C1JJscdYtsMQpBjjc2olR86KENI1xUmPsu7hMsb0QE8AkToIIMaZM3Bhh0ybEhAlFXCokjHc4ndpB1+rkNvuE4zCtZhmTp0sIDQcDny5xJoRJt6N0rt4g/ZkpXgjAxtWGoC+im5D1piz8KA89SxqLGHm3iPHaPtVvD2j/GcCBsAkTHWzbIBQ1iY2HTD0gApoHmqHjeh7L/hBooJElYpcw0h0iEx/9Bgweg8l5mNcg5MyytRYtWA6DPYLGEcyNhxjHQ0Yvaxw+jFDqjzD879OLxmcx3F0PhvugdUDXiW7fZ/3aPpc6U1amkMvAQVnjB+tPYf0P/zNEl2ASxp2GuLr7nxiEDmjMZ2l85FNQWoPpO2j6Dr73CZi7BN0GbDdnaewtD60Xp5j0mC+DsQQHaXjXSpBfcFh2La6PooyMImFrQnrch7FDTYfWmTn8yHnwYswvv8w4r3PDKmP14HK/zbrjM3ZA0yBeB+5AxoScY2DYC7RcB7tVZzFXo2pMQLdIV+CMBsnoLIR9f9GitbFEaDJmtdFlxYSsAUtZiKYhYsLpMNgpaPchaYM1B2YW8hXIWWA9AKMzs8Z7uRnePdbATkI1DcnwjBkPT8AwoXg8a7k96IIThfnSzM+uDSE0hugmpD8GQw0KKSgcNBmGfOIZF6MPvgN2HfQ+fGQV0vERgyHkjkE3x9zPbjOJJym12nykbREbQVSH5QkkfQg1YHwL8hvQvgLVGPRKcKYH2Zfg4EGYmB1iruCix0G3wbkFkVqSkN5kQJeIt4GuJXASYVKTKEVtl62np4TXYDCC3BoYNUjkIFeA0pWZqCPizFqp6VkgPmO8tSFMfKg8Bnr7GsN3uzxwQ4ydQ6ZGiOvTFBdY5wxZ6l6SiZnhrq4xDFkkxjpxT+N7eotdHJJ2gQIZIpTYxmNED7j7Y885f6Ke7u3tbarVKp/+9KfVz7LZLB/96Ed55ZVX+NKXvsQrr7xCLpdTgBvg05/+NLqu89prr/ELv/ALf+x9hV2TTeS0IvUNAlsBDEEGNQi+ZJEjLKhsslAT4Cz9P2UxF5SaixxLQGmQNTwZOCUgJ7h/H8RYBwNWBHTL4ugkQ31SJh0E3fB+4reAHwFJJ8PJTkrLhCU4ybQHfeUCugUgBYFXMPk8yCALkA4yu8FrFfSOyt8IgD/pbxb2Leg/D+5vkOkP7kNQtfBBbKwA55Pe95Pj5yQ7K2ysMHAnpeRBsB0cg0F5dxDABhdUcn2CSg05LydDwILFBflsAezyXjJeTp4b+Z3v++r6yrHIe0m/32AKcjCoTwpYwmzLYlXOlxQJpKgD77dE+yDPtoxlKYZYlqXS1eUayTgISkI1TVNhV7L/MlblfHqe98daz30YN5GAp1IpqtUqBwcHCrRJWzcBNkF7ifikJfhRmM1YLMbm5qZiZgWcSNq0FNSCthj5LN/3VU/ndrutALikJ49GIxWaJWOxWq2yvLys9lPGnQA/KQSFw2FWV1e5ceOGkt9KqCLMPLCnTp1iOp1ydHSEpmmsrq6i6zo7OzsqbMw0TWX/KJVKLCwsqKKQKHWCuSGaprG4uMjGxgbj8Zh6vU632yWZTPKd73wHgPn5eebn53niiSd4+umnlVKgWq3y8OFDVSQK9neW8S6sqzCS0ucb3i9G3rt3TxUAxcIhRdzDw0P1PJtOp6rNVCQSUd5okbqn02nq9bryGMv1GQ6HrK6usr+/r4pg8/Pzql3X/fv3AdS5a7Vaaj8cZ9Y723Ec2u02yWSSwWCg2pwFi4tyjkX+LM94GZOiUCsWi5w+fVrZTjRNU6oKaat5dHTE1tYWmqap1nZBhZkExIlCRhQM1WoVz/NUYUpaSkr7LXm+ZLNZVQS6e/euKvT3ej01D0vLNgl6syxL2ZGk6J5IJFhbW2N9fV0Ba1ELyNwpRY/gMx14pEA7Pz+vks339vbU9ZdMAGHmXXfWxUCOs9/vKya+3++ruTgSidDtdlVi/Id5c0hQJkYSgyoDjqYFptgsaEPuRXz68TDmCMakCBPGZ4pDCIci7dCAdNhnMNE4YkiWRYqpEJs/axMr9dDz0LkKEy9BlywmSQwMpvQJM2XAgC4jwg1gNAMHGR9Ou0PuNNu4rk6BHots4eNiMyJGFI8u4USHC2MYV+HhMow9SI8hY7m0DR8nqUHMwxvpZE2fubCLuQq9hSb53RhRMoztDFotBtEWO4kJ11YyxKZjivsWpMB5HlpRcLYhem0mYV/pQKoNtuajn51SqsBBsk8/cohvFCDZg0gVqBF2qizqXaaLOj98Psnq0GTzwOf6OEQ7ZcB3vgkMYK4C85eYPPFXufFUB8pZSM5DtYW2/QpnrLep9t+h1/wfZwhLT4HXQbMbxEdVym2IDyGWgcayzjBZwvQ7dG2LqO9z8VqDStTGrMD9rEYzmsCPXYb4R+HgjxhFTd6KPs5kOsfyje8wl/V5IwKhBVjWwb0HcyFIPQm1tsuo2kQPWeiay1bLxa602F/Lo2k9VnHZTcNwzWCc3gQtwam3b/D4y0XMfgxLH5Fa6HDhUz6jArRtqBU1xknIRCFhzHqAm/eh5wC+T8oH/xCiR7Oe1llv1qu76oKfBc0FxwNdn4WoxZZh/nnQ47NCgVGD/jWN3iEsJnxyY3hvDMVTcEVzuDmAhRisTSE9AdMH81XIvQNrl2FQhNgOrNnwpD6gFRvgXIfU1TSpYRpPH9PzhuiGjeeB48KiCcsD2CxAvQfegcag7tPDwQ85kIH0CnjDmUsgNz/ASvdI+hpn91skh6skWiWWmXChtMviRZdRFLI+RPOQOguRyMy9EKqAFQbfn6kBPBfozc5HPD8LGpyrwLk/b5OIPuTGa0uMQxlwY4TQgTohImwRpUOc1/U0nl8l5nm8Gx7QXY7hd2Gj08fE4PVoirERwU7o0Pjx55w/UdBdrVYBlPRMtvn5efW7arXK3NzcozthGBQKBfWak9vf+3t/j7/9t//2H/t5Lpd7ZEEtgFX6UJ/0BMsWBJTCNBuGofrLygNvMpkwGAyA92XbQRAikrkg4A6mcgfBX1CiLVXyZrOp9iGYGCseMQFqAkzlPMlCVhYAEvYSTEeVha9t26otiywIJLxKgBGggHfQBx2U6Mu/RW4nAU3ix4vFYsrDLX8vTIYsGKRSL4yGqAWCcv8gAyXXNSjFFgZUzqsspqTvbLDgIh75YP9UeD+JPgjwBEgI8ytjJsjSAKr1kkhsRR0QBN1yDoPFhCBrPRgMVH/1YEFHpJWyH7KvsjAU0CFjXhboQbl+cJNFqYzb/zX7gzCUwYKMFHqCPm0BMifvJ/lcGf+JRALP81SLp3w+/4inOwiGhQU6aS2Q6yBeVMlskHEXlLWLZF2kuHL+g8UPue+DY/rDDrqLxSLLy8tqDpFxNzc3p1g1mas0bZZqbRiGCk2rVCoq7Cqfz1MoFFQ7LQHccs8JgyzJ8MJ+D4dDrl27xpUrV1hZWVESVmkBFo1GGY1G6r4dDmc+qXA4TL1eV2qInZ0dhsMhxWKRjY0NvvnNb9JoNBRgfOyxxzAMg9/7vd8jEolQLpfVOHjiiSd44YUXePPNN5VMfnNzk3a7zQ9/+EMVcCnFM13X2draolgsUiqVsG1bsYfRaJRbt27R6XRIp9O88MILPPvss7z55pu88sorPHz4UIGafD5PpVLhmWee4ad+6qfU+wczER4+fKhanX3hC1/Atm3ee+89NSdJUU+YUsMwODw8xPM81aas3W6j6zoLCwsqY0TUXHL/Sxq2SKklROvs2bNqnhZmHh4t3Mo4OXv2LHNzcywtLdFut3n77bdVt4perwfM1CaO47C+vs7y8rKaz+fn57EsS/ntZT4SybYw7kFVkygmBESGQiEqlQqpVEoVcRuNhrpm29vbpFIparUa5XKZubk52u02gFJsSchYt9t9ZA4RhYcUeAaDgSrQi6RbALjYG6ToL3PW/Py8asWWTCaVMiOXy6kCUfD9MpkMlUqFUqmkiomZTEapFKRIKc/mbrer1h0y74miKJvNcubMGVZWVnjvvffU50q/b3nWF4tFWq2WKpJ1Oh2V3SDrona7rYpyH/atSJpl0vi0cdHossGQBou+Q6/boedHCFPAYYBJlBRponSZ4tHVdCoJn+okjE6Oc8Dimsnmz8+8wp3bcHwQYmiXsakQYoxNnyk95tAJ41NFJ16LwVtTypdh8sSUfqdGehzHIkGUHDpxJgxw8HBx0BmR8DQqh/CJQ4iGZ528nrgHK3seL5+G7dM+sW9CquGxvALDNBw+BmPDwf6/dzk7mDB3pk7fgXbcZ/dTEYYfu8z0zUNq3W2sAhgbMGpD49sQuwuRKET7i5ieBheOmDvjMylCqxjFt9NQaxDz/4j1aJvIdR+r59HI6LRf2ML/aI7hW+9h/9DCezdOaniNiXOXckRH2xhT/eTH8T7+RYgUZ8br0QSsOgwtFu545OsHvF5/De/PngXfJPvuv+Pjw7dZ6lsc+BDZmgGy2NCjYOyzcOhjeHAmbLHahOt6gjdz83Q2tvBzlyB6CkY3IfKQIU+C8xz0btDMhNnv2Wzt+UQmsGTN/NIHFY3b8wnqZYiXJkRMD9OAcQaano4/0eglYO9JOJxbxF56gVB7xNlXX+LCWz6tUZRWYsgoOqQ7n8MZpxlG4njzWTyjiB9Oos2F0Wwd+n0Yj9FcE/QB+niMsTAh1ZuS6ExJNaYkhzbZforovsbEhTBxYrEBzvMjOlvQSUExBGEfRgfg7xaJ+g5dvUtKm3miw3OwOgfXOzAA1g8gPJgpBjIO9O6DvwfxxowlT0YgP5i9rv66waBVQKOAx4SesYsTt/GAMBp2D2IPfGI3QmT7q/S9FDqHzIc7ZNI+sTx4adDCkNqAvOYxDMMIHyfdpXfV47Q1YKFcJ/vzIxqnIOZAyoDBPIQzkD8zY7j9FFjWDFyPezAegTOdhSTGwuCOIG1DNgenz3k8fveQSSdB2ktxKV6nlOwS6ixjuGXWCNNzitzQ2gwY4+gh/Gwbhi42MfoJj3HZg04LQuZPNOf8qUgv//Vf/3V+7dd+Tf2/3++r9NEgGxj8Ci6og5Ja2YLMo1R3k8mkCsYR2bm89qRcWMKeBAzJ4kLAtzzQg6yi/K14bcVLJUnC0mpLHvrwqMxZwK28nwTVBEG3BFhpmqbAvQB0WVwHQ8Sk2h/0cEtxIMggy1ewH3YoFFLJufJQlwW+MONSBPB9X4FuAZ/CigU/OygFDh6/XBNhcuS18H5BJMjMClCX/QqOgWBYF6BUAsGWVXINhWmQ8y+skkinpcgioFt88rIvQSAsbVmCv5NzA4/2zZbjDgJE2efgZwXB40nQLddMxmgQMMt1D0oo5fOCoFvGjVwrAdbB+ysI3oMFgyDrJgtI+ZygBSFYAAgegyy8ZREqxy+smnyejDuRnQeVEB90v8u+f9gXlRJIJV+JRIKrV68qQC0e4UKhoFo5iUR6MBhQq9WYTCYsLCwQi8VYXV2lWCxSq9UUYy3zrRQuZV5YWFhgMBgwHo+5efMmKysrKtNB7hEpksj4E5Y7k8lQrVYVEEmn0zSbTVWYvHfvHn/wB3+A4zi8+OKLXLhwgVOnTvGxj32MaDTKnTt3VK/pZDKpmGhJWO/1ety+fVuBqOFwqIoHAJVKhc3NTVZWVhSwcl2X4+Njms0m7777LvF4nHPnzpHL5fj2t7/Nq6++Sr1eZ35+XhUUlpaWqNfr7O3tMRgMlH1pOBxy9epVvvvd7ypmN5PJcO/ePV5//XX6/T5PPvkksViM06dPK5Y/nU4r65T4lAEee+wxSqUS6XSaSqVCq9Wi0Wio+6LT6agiy87ODisrK0olJK3KFhYWlJRf/NHj8VgV+GRsrKysYNs2R0dHql1VOBxmfX2d9fV1Lly4QC6XU9alIPCXwD4pIAfnNilCNJtNjo6OVGtMKZ4HGf5ggV1S6IXVFpvEgwcPmJubQ9M0dnd3VbFXQG5QUSDPrGCgp0jEW62WYo2lYBAKzXq412o1BcCbzSa+76uihxSDpcgq86eE1Mlcf/r0aRUCJwVcmbcTiYTK2BBFnzxrZH0h86sUZD7zmc+wuLhIMplkdXWVbDb7x+bucDisOl5IxkLwPhQpfqFQ+K8zcf0X3Bq4LJBEx8THJUGO1/U6A2zWp1mO8ekQJ0cajQZxpmSJMsBn4MSp9ft0COGQI8yY1SWPYg5qt6D1hxrtm1u43joex8Tp42DgEkfHJoaFwzyjQYq977zD+XmP5DxEYyapcZ0Jy+wQZQcLjxAdwsQYcoooueFT1F59i3yhyYtROMpAdhcivw8fX4VTa/D69yN4U5/iZ2ymT86AqfEx6ER73L/eZW4RBhm4m9QwNzwYDzBG5ozV7ULsFiw64HvQt3SGhkdPH4JnEMr5bG9G6aycZRLJQTiOplXZqDb5SM2n/jJ0S1D7dBiyIZLf2WfrBxbRlwvEu5c4jNQw9AIrwzkM59uYW9fpDh+HRByMHAwPMa7+R8LfPsJ8d5W+28Iv1+DeV4i9ep9Lb29zIWITOgWxx8BswHQAq2sQG/kYJswXoOtovHxqherWp/FKS5DxoHJxZo5uvjPrX+6l0TsvkxjcwRwbNB+Gefq6RWg6axdWv6Lzw+UtBgsfA6cN5gMwI2AN0SfbxEIuedqkIj61TAZ75SmwXTaPXuWpWI9bFzXuhI8hk2C6fhr3wscge2nmTY/Ff9RTq4fvtGZeePtH/njD/VG8t43lWZhWF4YNaPbRj/aY27nHmZpFoqbj7zkk+xG822OmKx71NBxa0HChHJpJvzUPhiOYjMHrxemXxhQ+AxUN9Idgvj7L3bMXYflpyGzNeo3bA6A/a+9uR8DPgb/oMMchRr9JS4Po+phIedY/3N3WMCwDd+zRdmI4vkGMDE3GEOuRX3EJL0PfglgPqMMwBOMwTFswbGuYTpoQNtpHTEafhEgecjbYBvhR0P3ZvqTiMz+3b4MbhVAcYi5MTPCnEGpDODI7zcMDCCfhsxc9lh4OSeaHrKZmkv/xO0MOez7vYBMjTIwwHmOS0xD2wYjwMMGECbanwSQCfh+GP1n3mz9R0L2wsABArVZTPmH5/+OPP65eczIVU+Rn8vcnN1mwn9yE8RRAIuFMslAP+noFDEiabVDWKu1CcrmcCn0RqbcsVsR3LA/4IOMYZAdEZiufI5v4cOVz4f2AH1kADIdDxRrUarVHigKSdC5gT0BXMPBNwKd8BeXhsqiQ1zmOw2g0UgsY6Rcb/BIWWFhJWSjLIuoksJbvsoitVqvKYw7vFz/EcyvS+SDQFgZEFsCyKBIALAs1uQ4SaCQ+yCCYC4LioGQ7uM9SAJHFiPi0g2NLrp94WdPptALesrmuqwB10G4QLHKIekB6mMt1liAg+RxhgE/6kOXYgtJ3+TzZ12CRJzjWpIgUlPEHCxEnGW8Zk1IUEeWGAFlZoMuCVV4r+/RBha6gjF3G5Ulm/WQiugB2ud/l3ATv+WDhRqSqcv3kuIP3wkkG/MO69ft9Dg4OKBaLKj1c5Mb1el2pOzRNU8FWYgfRdZ1Go8FkMlE9iEVWfPv2bQ4PD1UoUxC8iN9WAsHE972zs0On03mENfQ8T4E2ASO5XE7NkwKUo9Eo5XKZer2OZVncu3dPFRRee+01lpaW1LX8uZ/7OZ5++mn29/dV4Fg4HFaeapGIi399ZWUF0zSVb1zXdcrlMk8//TTz8/McHR1x9epVxXRns1kuX74MzO75V199le3tbeXdFUY5nU6r4pCwtdlsFtM0eeedd/jud7/LYDAgkUgAUCqVuHv3rgLL3/3ud/E8j7W1NaVsKhaLmKapZMlShN3b2+Pll19WEvTFxUV1j8i82Gg0uH//vmJapXB98eLFR/ZVCiy9Xo+33noLy7IUA67rOru7u+zt7eG6LplMhjNnzqgMFJkXZfzIsyN4rWWeEauT+NrFEz43N8f6+jq1Wo2joyN2dnZoNpuMx2NyuZwav6KkiUajVKtV9RycTCZKvSF96A3DULJ53/c5ODhgOBwqJY48V4IFXvHBi5Ko0+mo8x3sdCGBaDLfC4Pt+/4jY11sAv1+X82T4vGWQkE2m1WdGeSekPmy3++rzgOO4zA3N8fCwoLabwkeTCaTrK+vq2sohQtJLh+NRkrm7zizHvVSKAKU0k8sJx/27YguLjHOYZNnCkRx4xGOFmJ4+xPSVhoHHQOXGBDBRsclgoUONBwDmwhZOujGPvMrDukE3NmHw1un6E4fo0kHFxOHApBiSp0kNklc0hwQ97NYexl2rnXp3odefxmXJCN0qprFQB8Rc8OEQiNi7oAECaJoGN001ntNSqugxcE/Bc7PgLMDox9otI4XGIRBf3WP3BaEPRgBhZ/16T+l8ZX9CE4uhp8NEY90Ce3eI/HAYmUACQ+cODgViFwCo+PhjcCPmuAk2S+HGD69CnNX0I8ekLz6PRIHA6Kaz9cLBt0XdBY1i1V3ytard1i655OtwUF0zLFWJexlCftJoAu+he8AsQjkSmDa8M41lr+yR+zmEgNnjuO5GH4pT/ruy1x6a4K3/wT/nhGZ0T5bR1PizSntVZ/xFsRMMBLQWYM3tSVGsU/BnkXkla+Ryu1jVhaZLG5BJA3uBph7bB1v8/i2y942DA3opaAZ0nj34jqjj1zGTVVmDa/9ASzkIbYOvRbJt/bZsiwmadh144z1OcK7d0jt7WO5Bv+5cI7RpQJ+qgip05DOzKTzkTToYYjEwd0H3wQ3BMMdIDajaSejmWZ6Opr1FQttQLYIZQdv/TLVzT+iePQWlQcOk+KI8Z0RuWqcM2+OORuH2wWIL8DqFvRuDjD6c4R2NSa+RczPYNxySD5rcykP2hisY9DnZn7+W0czf3gxB+kiJGpgHYHuzFpzGZuQTzhYPQd3Dow0dLdB9yDyKY9Rx8J9N4qrTRm5bVx3HZ9F9EkHZ9Qh0/ZIvAGNDkysmSR8bEL4WKM7nmdH2yDNkPikSibqYExgas5OX8oBIwS6AaMRREIze8WgD51bcO+VMHbTZ+6Uw0IZ7Pei6FON5VMTSnOQPAdraxA3ZhJ+8xAsK8MeWXaAFUaE/AQx+qRxcJsllpknhs10CgM/ixaNEBu4jH+COedPFHRvbGywsLDAt7/9bQWy+/0+r732Gr/8y78MwHPPPUe32+Wtt97iqaeeAuA73/kOnufx0Y9+9Mf6PJH1yoIrCDSC3mp4n0UUgCW/l58LKxLsYSrpotITVXxg8n4Cuk96eIMp2rIFw31koStVe6l8C4vR6/VoNptqsRIMF8vlco/4vIKAQkCIfD/JUgurKf+WBY8AZTmXAoIFhMr+B/c9CMSCCgN5LykeyCJCzpMwL0H2XSr8J/3kAuhkQQOo45NzLL45WaCLjD0YNiYBbrL/IkcPyqWlUCI+bZEwCjgViackxgrjLedAAIacW0CxEwJmZAEmvXVlISTnQsaXgF9ho2VcCyAOStblXMn/5T4QABH0WMs1+t/agsccHLsn09wFKAdB9wcBWXl90M8e3F8p3ogHWL7L9Rd5uUjTpSAi1z1of5BNlCvyOfL7oBc+WID4sG6lUkmlWZ8/f55oNMrc3Byu6yogJ32wg+3rEomE8nmmUikqlQrz8/OkUinlXZU5QBhySRYXdrrX6ykJthRLBERIWysZ/54362tcLBaV9UVAu8wduVyO5eVlptMph4eHwKwgt7u7yx/90R9x8eJFyuUy1WqVRCLB5uYmrVaLw8NDcrkcx8fHqp2T3Of5fJ5UKoVpmuzt7TGZTJQ14j//5/+sJLgCuMfjMc8++ywrKys8ePBAtaUcj8esrq6SyWR4+PChYnUFyD7++OOqtdbOzg7f+ta3FEhfWVnhc5/7HMvLy3z/+98nkUgwGo3UHDMajZS/vtvtKrWAnLOvfvWrtFotpVDodDqsrKwoZl7k28K8CjA1DIM/82f+DPF4nDt37nB0dKSArBQTFxYWaDQa1Ot1CoUCmqbRbreJxWJcuHCBSqWink/S21oYVfHCj0Yj5YeXcytKLilICCMftH/I81D83TK3CDufSCSIRCLMzc0RDoeV/1jUFnIMAuZlP2A2H8j4F1uZzEUSwChzZSaTUdYamIUTLi4usrOzo+ZVuU8Mw1AZB6KogPfVY7quK8+/FNwF1EvhS8JWpTCk6zqHh4e8/fbbyibQbDZ5++23CYVCnDlzRvm1NzY2cF1XjTV55olyQbIURE0CswK4686CUeWcRKNRMpnMh74oCbBAnnfpYeHyPDpRHCpmid2xx/HZCb0jm1PtFIbfp02UCAuE6ZLABQp0iGNQ4iJp5rMDUotgHkP3bgRtso6LQYsJHUp0cIlhModDBoseMTpUSdMn7joYbRh2NXR3DZc5aozx/Tjzrs0GDiV3TI4hCZqEYzVSpT5udNb7OOdBIwfe56E2hdp/9In8RxNNi3C0F6L/LQ/zoo9eAr8GVkJD39Qpt4eMDn30vEfx2GT+1kxKbJwCbQlGcxDJwWIVqi8bTA2X6KkZYx/5vQbLx39AJtbH2HNI7hZoZqf0vjghftpj+R68+BCGXZ9vWjoLj3ucnRsRf/0uy4cpjHEYMz3mzlqI/uOXIZGBngfb7xH6wxuUrq1zFE9y9NkoPPkZWMpjfO+QtD2kTY8YFUrHawyP27T0myQWe1gdGKQhEYUHXpZR8gKhr15jo3aLXGlMZgcaR3XuL+9guVnC1TFL4w5X7rrEdmaBZKUJTIZw/cI6/S/8ZUgk4M53iR29SsQbMsplcdMDYIS7YOM3wKiDW3CJ6/uk2zbd2CKd8z8Li5fBG83AdbgIoz5MozPEmHQhbIEdhlAMkjokkjPa1uzN0tC8ELhDCPVmjbo9fWaatjUwLrBr7pAxa9jajDD3WhbZWzlKBzGeK3dIXZlCAbqfmVJ7vQ6HaQzNxy41SGw6+BoYYUgWYJQDw4PyDcg1ILSjYeV97HMQ2gGjAU4LJmHwSrM2Z64xS1GftGF83wBDx/2kRetzYGxOWdwGrdqlv3+HlHUawz7PZKdK58gn5EE/cgSLE7SujzMGPepzNPZ5mIqwMhhxuu8T82Y9x03ASIFmAhrkdeiboI2g80ONqy/l6N5/jLcGYXrhJvk7dQqJEZutx8j5Om79FTaWJrirkMxAb/qjWkY9Sn98hhE6KdroaCQIsUyGKGAwZA6XHgl8P06yY1JxoyS8BO/+BHPOjw26h8OhCk+BWXja1atXKRQKrK6u8tf/+l/n7/7dv8vp06dVy7DFxUXVy/v8+fP8zM/8DH/lr/wV/vk//+fYts2v/Mqv8KUvfenHSi4HVJU3CFaEOQhKxOXBJgsuWVSeBCCyEBfmUYJspDIt73syHCwIUILgPtjrORQKKfAXXPjJgzsoz5WHsQBDCT+Kx+PKnyygUwoEEjYn0nBhtWV/JPjFdV0lYZeE2SB7H2R8ReKm67pKK19cXHwkGbpUKlEsFlWwjRQNZPEgC64g8JZ9E/ArygSReAcBovgyBVALYJDXC8sd9LoJeBeAKouoIPMsMmc5j0E/skgppRggv5fFigQ5SYpwUFkgC0cBzsHxIAtHGYPy3mIlEACpaZoCmCInlPMrxySez6CiQgC6XNOghz54PmULFlmC/kZd10kmk4TDYcVyyVgNWg/Eiy9/m8lkHjlXIjOVokPQVw8o1l9kotLKSRQIrjtLNo7H46RSKXK5nLq+8reSHSDBUyLFlDEXCoXUeQvuq4yRD/MmORmTyYRqtUqlUlG+alF42LatfLDCIgJ0Oh1s21YAb3FxEcMwuHfvniqo+b5PLpdT0l7xBUuRKp/PE4vFWFpaUj3Zg+yZqBEAtra2FEAQb+tkMiGbzaouFfL1wgsvUK/XuXHjhkqm/va3v80v/MIvPJI7Ua/XCYVCHBwc8O677+I4Dtvb2ywvLytprqiHzp8/rxLy7927Ry6X48qVKxwfH9Ptdul2u8RiMV566SWOjo5YXFyk1+uRTCb5whe+wOHhIQcHB6ytrSmJrqZpfOITn2B1dVXt087OjpLt9vt9Pvaxj3Hu3DnC4TCNRoPt7W0ABXz6/T7tdlv1/F5ZWVGJ4bdv36bZbLK5uclwOKTVapFIJHjw4AHNZpNYLEYymWQymbC7u8vR0ZGSpX/uc59jPB5z9epV9WwKhUJKVm1ZFrlcTrXnksyOcrlMqVQimUwq/34oNOufXigUVNCj+NEF/HY6HTU3Oo6jUs2lOCrFSSlMS8p5UHp/eHhIs9mk2+2yubmp5mcJmOt0Ovi+z8LCgspnEfuEqI+Cc5iAYbFRyPNXnn3yPJHCgBR8nn/+ec6ePcvt27eVsuHo6IjhcKik2/J3UlxPp9OkUimy2az6rKWlJdU+z/d99YyTbAMpXMGM0JhOp7TbbcVWC0s+mUy4e/culmWptmfpdJrxeMy9e/c4Pj6m3W6rDBiZHwuFgvr9/Py8Uh7Mz88rqf+Hfdsgyrt6m6u+zrKfZo065/w+7SrcjiYwVxq8V+qimUUi1SbLtsmP+oVQI0WXGAl0tNAOi6sDQkO4+29h+F6IHl08iuRJk8KjhI2JT5I5NOpEiJNjjUTmNkunLSJtKDTCJIAaaSw0LhFnEZskNbaYYoRrjNaO8T/qYmyBY81aT4VysBODYXT2FfkEnL/f5v7VJJpbpPiGR/zrTfz/M/RsSHQ9IpMx0cYMx4UPYO0HEL8eYSdnsTw/A+e1NIx1WDQg7xn0dJ9Q2sV82SXfjPC4n+FY89k1uhzYPtFhntP/rkr74zbeAuxa8NLSHLtXTlM9fJepNcL5JFT8PlZD40a2TPOnPwOrG9Ctw6RB6sE3eOZ+hxQJ7p87gk+fhfNRMLJ0m5/m3VtfYX1ylzWzR0GLM3AmdDSbQhSahsb15SyhqYfdm0e/3eLs7jUun3LpWDA8hvQcfORel8zDLku5WdjW/gTuaVBvaRR6UR6u6XQ/8zRMjslc+0PyoYcsJlziIdgpjzkM15laBcxsmVq1xpruko55tPMFJuUV/OInIXkBpvaMwQ+FZv3LC8asp5lnQjwK4TCkK0AdOjXwxuCaYP/IwDy1Zz3DYhZo3VlyWCQxiyo3kpgLlxj1m8xnXPZcsIcuzcGYnhNho6YTPoboMlTOQaI0pfPOFMKQvwiNTajlIK1BegkiL84Y73BrtgvtFR93cRZYVhvDZBBCj7voC5AsgqeB/SCM1g7jbJpEKi7T/Qjb2zbtn/XRzwI3YOO+S+a9PY7uVRlaccKjDOPJRVzy+NYe+r0aFi3SuQ6pMMyhMRhMyMXaLF52ycVn4ocQYIzA+FF78GEfzA50vgP+7z3FqvUCHikW6NDRPcxhidwwyi4ROmRxt4dYwzcox8HUIZWAyTtR7t16gh0KdNlmikOZLEXCFEmxRJ63eECVY461eca6zxl7yhLz7NH9ieacHxt0v/nmm3zyk59U/xev9Ze//GX+1b/6V/yNv/E3GI1G/NIv/RLdbpcXX3yRr3/9649IrX/nd36HX/mVX+FTn/oUuq7zxS9+kd/6rd/6sXc+yITIol5YFQHdAorC4bCSkkkyuUjD4NF+vuJnk68gCylA6qRUXDb5bFnABllUqYYLWDrp9z7pcRU/mMhlg6FkQT+zJEsH06XlvQRgyt8I6IZH+2GLlFfY/qCXXBZEspiWc6Zps6CrVCqlzpvIUQWQyXHL34v3VkCQSOSDCgX5uRybLJKEqRTAG4vF1LEHk7pF1hi8plLICAJLAcRBNlvAsMjsBHzKa4JeRTkX4XBYyetFTRBkx2WsBL21QR9st9tVLJEUK2TRKtchHo+rcxC0MEjxRs6ZfG6QYRcpvbDDsgWZcXlPKXxIVkCwaKRps5Y5EtAnC1f5ncj5pSAlIX9yjoP3meyv2De63a4C38EwRPEs5nI55cGVc9Hv95lMJgp0yzUXS0HwOINMuBQkPuygWwCLXDdN0zhz5gy+77Ozs8P29vb/l7w/DbYsPe96wd9aa8/zdPbeZz55cp6zUjVKskbLki104dpAX7iB3RG3gXAQ3R3wxeEIQ4AJY4JPENFxDR/oG3Cx4V6M3TS2rNGlsqQaVFmVVVk5Z5552PM8r7E/7HreWpmSDFbLIJkVcSIzT56z9lrvetf7Pv/n/3/+D2tra5TLZdrtNs888wxnzpzh3r17PHr0SElwS6US6+vrxGIxGo0GiUSC4XDI4eGhMqHK5XKqZZWskel0mnw+z8LCgroW0zQ5Pj7Gsizy+bxiLWOxGKZpUigUKBQKKmGaTCYJh8Mkk0kCgQD9fp+NjQ1OnTpFvV6n1+uRz+fZ3t7m4OBAtUcTeW6n03linZhMJqTTabUmibxdSnbu37+vANaNGzfIZrNks1kqlYpKdF26dImXXnqJZrPJxsYG3W6XUCjE888/j23bdDodTNPk4sWLnDp1iuPjY6LRKN1ul2azydWrV9nZ2WFjY4OjoyOq1Spra2ucP3+eaDTKq6++SqPRUMkNMfnKZrMKTPX7fdWfeTAYcHh4qEy83nvvPQXypBY8m82qvbFQKBCNRlXyXMxAhU2X99Y0TbLZLIZhsLq6yunTp9V7JOuLgHVZx/37D3yQhPaXPkm5kpxDEqSS3JZ98+zZsyphtLGxoUqgXNelWq3iOA6FQkElj6UVnX9ddF1XqQMkAdHr9VhbW0PT5i3m9vb2aDabqnxiNBrR6XSeaBUm63coFFLP8PLly1QqFVUSAKjkRzKZVOB6c3PziUR/s9kkHA5z4sQJVabjOA7ValW5pIuiQCT54q4v5n7SDs2fhJaErmHM24O+++671Go1pUKRZBagfAckwZBKpZSRnSQ7hd3/s3z0GZN1U7hoNHDYYMRZmnhuhsRujnupGr0PDfGyZ0h9ZZ+PJXc4s+ZwbyvCzbFDLzRmbRLFiXVYP2sTb0Hj9QiJzkmGuByxj8aMKGFiFIlgEcYjTBaDHmmtQ37BZiEE/XsaqW6CMDNadDiBw2lSxOkQ44hYqMP0SovBn3Pob8LUgJELoyQQhlkKwgZ0BzDZgM1LLsV7Lt3xkKIZhG8btF9ysJdh0g/ghmwyAyh3IBCdm7+N7QSTwZj0zpR4ELgAyT5Em5AOm1iDFA/uTQiXTSxzwA13RHZxRrbvUql3CWpDYgGH2qUIzRejvNWKMV1fgW6DbijBa89vojkBYp0hnpllfPE5OLkBFSB6hN69ybXbFT7SDXLnzDZLL1msHHVp1+5SWbuCd+7TVP/an6f/ra+T2D0mH3UINl1SI49RHrbyadzkNdxph1h/h7X6Lqtph3EL6kfAEhTTYHwDYhpUCxp7jgYnXBIhONnz0Fam3LpYhtiYzKPf5kVqlHrgAftJGPQ07HQEYjkwC7SyM0xjRHf1Kt6pi+CEgBzoPQhbcwY/MAXbmg+03Z+Daj0KXhUMd150bE/A6s7/zzUAfc6AayY4Omh5MB1wIxDJgN7HPXuVx9MjYtWHZE+4pJIQHM44CjfYiWicK8HZ+HxOhPNQ+Cj0UmAnYRaAehhwwEjD5BkoxGEwgG8PoL4JWQ1iLYguQfF1h5UZJIIw3pt7iYUaCcJBDW19TED38GouK8cQqsPWNXj3KsyKsLwGxQOTSNtkfNCneWtCrv8JZqyheTYnjD7xddBS4Nht8uaE0IeG5D8EQWfOZuNCvQoLWYh40OlD1IJRXcO1k8Q4ZokBSyxSmqW5TRUHnSYOe1qUtLeIEwwQyNkYM+jcDXDjvdPsmWWgyxQPtAALXgobCGC9b2QYo4XLMJzCCQ0Z913GmEQ4/oHWnD8x6P7EJz7xx8oyNU3jV3/1V/nVX/3V7/szuVyO3/qt3/qTfvR3HRJIep6n2ETDMFStomTgZ7MZoVBIuU0L2yL/7zciE9AhAMTfg1oY36fltn45r2TpBbBJ0BEMBpVJmzCQAkAEnIlk1++SLkBTmClhlOTw9yT39971M4t+YC9Bi8jgnzav8n+eMOmhUIhkMqmYXj/oF0AqLrYiB5TPeLrGWICrv8ZexsuvThDW3i8N9h9+KaJ8SRLme0nv4YOe6f7yAnmOch0SoMlckfuTZwJzV3D5eTn8z8svpfYnYfzjL/NUxnNpaUlJQAE1d+R3JKkg//aP6dOt2vxz0/M8JVOU63y6dl/eBX9dvchEZW4K4JBzCNstvyvqgEgk8kQtvQSr4sovQaR8hrDV8oz9LZlkPsrPyZwVhlZcsEXG61eh+M3eBHT7SxP8yaM/q8fh4aGScIshlATYzzzzDNlslr29Pe7du6fqjl966SUcx+GNN94AUGurBPUCXgWUiRJBPDyCwaBq3SSy3mazqd4rqYsVgCYO38Jqnz59WsnYo9GocnyeTCYcHR0pNnU4HJLL5dS7pGkah4eHrK6u0m63mc1m7O/vs7+/z5UrVxQ4XVhYoNfrkc1maTQaql2UeGgkk0nK5TKtVovxeMzy8jKdTkc5cUvf67fffptarcYbb7xBIpHg2WefZXl5mX6/z8rKiupCUKvVmM1m1Go13nrrLRzHYX9/X7n6i2JAHNHL5TKf/exn1Vq+vb3N8fGx6tnsOI5iO5eXl9na2mI6nbK5uUmhUKDX6+E4Dul0mpMnT6rae5FZC/Mq8mhhtf0qIVHERKNRnn/+eQASiYRSJ4mCQfZV/3spCiR/okv8UCSJKPt2IpF4ojzHdT/o/DCZTIjH47zwwgvcunULz/PUmJ44cYKlpSVlUCbruV/uLeMn+758Vr/fVwZ4lUpFge/Dw0O63e4TRnJS6iCJV5ivy9vb20ravrm5SalUUuaCmUyGTCbD8fGxSv4KuBVV0unTp5UKSBINAspFsSPt2kT1I63mPM9jfX0dwzBotVoq+bu2tsZwOORLX/qS6pAi865cLrO8vKziBGHcxUQtn88TCoXUGrG6usry8jJvvvnmf4NV67/u8S16tENRZlGTO+MpJSvFCiHSTPiYp7HQe44vv1vFXHyAMQ0S1hO8eK2H49j84V0PM+zgTGKENZtgfIKbhGnaYVxJEPZOUGWXKlPSaGxiEWRClDZZHPTIHul8n+FAo9nQSJge4VQHzb1N1nxI0gwBBWLBNuVcg9GHbGqfmAOZcQKCIyD6fo9ue96fOX40NxALGBDY08jNwA1MMJwY5UYKa69Dd0Uj1IarJmzcgsYjOPoMDE7AxncirI1z9MY7ZMMOq++B/laU4G6MWrCHp4+Ipz3Cz3hYOxNmM1g6D90bOiuECC5Pab0IblbHvpmAmk34jfeIxccEnzUYLGtM+hcZrfwExNdA86BWh6mDUb/B6Vdvs3TPZado0vqoh56FS50pQXfKl0bfodEJQ2mN8c/8ecazGXXnJtrOIZmjIVoO2vmr4C4QaB/wbK/PhRDsGjDxIHsZKqV5CysvBW+fjNO8eArvuMu1/X1SeESzgAOlWQtn96tcD5osBiA8gX0XHhjQM0JocQ9tUsGLhLCev0bbS0DyIuiFOQWbNSDqwsyA0JyAIhSbNz/XonNNtzcCx52j+ckE7OH8/w17TuESgnh8DritKTjtuZ7bHoMbm9t0xwKMn/8Yb94KkfF2CMehp8UZbxZgKciD/iFXpm3OBx0WjHm9+js61PsQsyDkwGEQ7qWhHdcouB7hONy/rDHJwHElgrEGF40J2ZfjdHd1xtqM0TSB5c2IESKoecQ7c/U8RpjMdpToNzqYYdgvQeMkOCVwViDTgpULHitnmrT+4w0CrY/iAtlQj/giBK5D5KrJetxE34RACqIzcF3wovOe4KYFgQpMX4PRnsZsL4jlvUuMPAl0PI45zXkqbHCPNuN4mFUzxElrhVH1Iv/p6/v0RkEq3gLbCyno36EwKDNmmUVvjM2UGAmKJOkzJkQMjzxOJERm1OI0Y64wYUjyv468/EfpkEBcgiVhTcQ1WSRsUqdUKBTUJiyZX5F+CXMqm5h8SR0aoGR4krH2M2USdESjUQXipd+mSMEkYBQ2VwINCTok2PADTgEGAsakhlAOcWz19wuHD4yxhKmWvwsIfRoQyyFgViS5YowkQEoCLvk9kbeNx2Oq1SrD4VC1sEkkEuq8fuZXgpBIJKKSGDImwBMGbWKwJYBQEhx+0C019yLx9o+dAC0/EPZL6EV9IEDNLy83DEOBbXkuwhr4QbuAXmGM/eUOAvDEf8APvOWeZM5KAAo84forQbCoB+Q5CeDwS+BlfGQcRYYtz99fG+mvB5fn6brud9Xyyz3IWOm6/oRkW65BekIvLCyodjZSw97tdp+Ye1LGIfWa8n1Jvog6QcomhNH2A2hh/v3SfwH7fiM1eddkLggw/7MOuhOJBO12m1wuRzAYpNvtcnR0RCAQ4Nq1a6ysrHB4eKjY66OjI/b39ykUCiqwz2QynDp1SiXd1tfXuXfvHuPxmGw2q8p5BFCn02kWFhaUxPrRo0domsbly5dJp9Osra1x4cIFVV8s6oxMJqOMoKQmOBwOK1DV6XT4t//23zIej7l06ZJilOv1ulJCDAYDtre3+eY3v0mn03nC1O3kyZP0ej2Wl5dVOy2/4kFqk5PJJFtbW+pd6HQ6qrWTKHn+4A/+gL29PcXu5vN5APb395WE37ZtWq0Wruuys7PDl770JVVrO5vNePHFF9V6Iutio9Hg/v37Kknw1ltvYVkWL730EqVSCdd12draYn9/n0ajoerkY7EY2WxWmV9tbm5SLpfpdDo8ePCAVqtFr9dTDLYkwuSQ9UPWQ1njRKUg+106nX4CgMqeJIkxQNWPyz4oCTJ538RHREqG/OuR7L8wb80o9cbXr19nfX2dcDisxloAdr1ep1arKYAtvysAXnxQpN2g7GmdTofRaEStVuPdd99VIFT2FFkXBfBKjbbsLVIGIHOpVCqRz+fpdrtKVn54eKjM86Rf+fr6ukpwiKLOcRz29vao1Wr0ej0l85dkWaFQUHGMPGtJFLXbbZLJJJ7n8ejRI/XsZN+XsjRZ1+V7Mr5Sq99sNonH41y7dg3Xdbl9+/YT6qA/q8eIBIN8G+9SjsadIEfHBlWG6Nhcx+UULnfbHtt6m6GeYm+8xMFBj3zB4Zw+JdpfIIvBqdiAVAyMZVj/cxb3lt5m8p02+cEqHSLkGZMPPER3J6TdGQvxPqGMSX8U5HEvj+aNuLw4IL3isWaNuHA4YtIJYIQ7OBdM+DB0LkNrBbT4HNMFE6CHIDKBaQCCHdj9f8O4n+DqmSmBu0F23Dj7uk7YS5DW2sz6EN7xWPmaTeihxm4LnGUPOwnVmE7u2QaXqzrDiEPIBuOGjrddwPWWcO06Yf2YVMei8iboM3CB3jEkT7gshqdYAzA7UPz9CebbDu44RFIrkC30udTrsnvmmO8sprFXN8F6CK0jcINoOzus/uYhpx6dpTPd5/HFPpVcDmYjSrMZxRA4mgP1A7g/gSsnIDMheOMAw5rQ+fAmlNbAKaNtvcvq1j7cha0JDIMQK0M5N693fxDXcDezzMofhq7HiTsPSb6pUx2GSDEl5npcSlmUcnOzc10HMwFYUIxDJDGjPgkyJgW5NCxcBeLgmJDSIB6bM9swt35HAzcxB86zCrRaaGYVL6pBbHWum7YnEI7OAbZpgxaau4uNGuDacz2124Rwaq73pgvJIAx64Dg418/TWl+cSx3yMcCGkM1YW+Ct2j4H9W0WHBsr6HIMdJeCZF2L5enc9fsordGPxej2J4Rcl8kQvK6ONvJYq5uc+I9hio9eYuR0sdnDQmO+gyxhem0KVTD2g/QmSWzPJfKdHsubLkPAGs6dxiPluaP9pANLJyAW22f0v++Q7J1n7D0gdzzD3oTFn4BjD6b6nMl2JvNa++47cPAgwGAAwS4Ut5NYg0WaXpY8GjOGjDkmpvcouCmu81FMMnSnbV50YgRJ8J/CqzyOLWJpYCdMKNloe1Gmgygr2GwyIE+QHFmyROhjUiPHIKARmzZ5yerxaZo4JNii8AOtOT/WoFs2dD+YEYAggEYkqn7JsN912rIsUqmU6ucs2WcJKPyATeplPc9TsmcJGuRzpe2YsJjCEPqleH6WWMCHnwnwS3r935PrlYBQgh1/kCCAzv/lB6TwAeMrrISfpRe5vIBdydYLu/s0Wy7MQL/fVzJpac0jdW0inxMW9mmjNzn8YEyYXblukSxLMkSAltyLgG055LMEFPtLDvzydGHd5JxyPnFVlzrhdrv9RG20Xx4psk2/jNoPhgXsCQj21ywLMJWAUZI6ElQ+LZv3g2N/yYM8P7+qQQ5JMsiXAFz4wMdAQK68T5LYkechcwhQdZz++eYvH/Cb6onDr0jS/S3T/A7o/jnon/v+eSwBr5zD71vgf95+1t6vNpBn872STX8WD6m7FVOvSqWiSkJ2d3d55plnOH36tKpRzufzjEYj1tfX+dmf/Vn29vYIh8O88MILZLNZRqMR5XKZcrnMxsYGN2/eZHt7m3w+z/nz5+l2u8qRu16v884773B0dKTe/eeffx7XdVV7I5Gbi4lTKBRS7tMwl8eLGglQAKLRaNBsNgmFQiwtLTGbzRRj98orr1Cv158o8RFX6AsXLjAYDFSSLBaL0Ww2VblNq9Wi0+kos6tMJkMqlWJlZUUBxEAgoBzbZ7MZ6+vrrK2tqaTSysoK4XBYMZ+GYfDqq69y+fJlEokEX/3qV6nX64xGIxKJhHIkF7m7sJuvvfYaN2/eJJvNkkqllKP3V77yFUKhEEdHRwoQzmYzDg4OSCQSXLlyhY2NDSzL4pVXXqHb7RIIBCgWi4pllj7q4izfarWUykQY6BMnTqjktDwDeR7wgWFZu93m6OiIGzduUKlUsCyLUqlEJpOhVqvRbDbJ5/M8++yzrK6uqnVbALacRwxLZY1IJpOkUin1LpfLZdWKS/pta5qm3LqlHZew6P7EKqDM40ROLetEu90mHo8rsCprkNRXi6GZPB9JrLdaLVVLX6/X6XQ6zGYz1tbWWFpa4vr164xGIyU9l7VJFAJS8z+bzWg2mzx8+FDNQ8/zlOmZ9LXvdruq/lviiPX1dVKpFKPRiNu3byvFT61WI5lM0u/3VZs32aekDZlt24TDYfV3QPm13LhxA13XOXfuHG+99dZ/vQXrv8GRJ85gOGM6CDALjLmjtwi44FIiRpAXecBPGPu0JmnyziIFp8PwEDZOefzFjTZ71Rnh5IznX7LJpGDchXIGyn/FZH3tITe/fMSiGaWw3OPcZYveQxjc1oitedQHGje7RQ7Q0QBtYPB828EJwSQPwVM2qRPQvgaDUzCLQSgIpSk4EdAAfQBaAOL2nDAdBgLE3/kEnXcset4RD0pxXGyGzQPs5/o4JSj9AWReCRLoL4ARYHhmn/U0JE2Xwk+46N+B8FsRmE2JRV2aqWMGPYAiLTdIZzalX6sRK83IAIk4uM9B5TYUX4YTb2gYVp7WOMI+LhnO8uzQI/y1P8JJzHBXUhBahnoD2g10o8nyV474wlt/hYazQY3/yHj7DuYLAdaTHpciULWhnyhCqAijBMx6RF57hRNfapHOehwnTfbXV6DepPQ777G563LYNzDdGAuay6wypb3nkH4G9A9FmKy/BPYGiW/8R9bemxCqZFhw4+h6nYnmEr0NRsChewEemnDYTjP1ojgBj4EWx45fgo0TkI7Mi5sDI7B7MKjO67e9JATDYGvQ1uH428Ru3EU/7hG0e2RLY5yMxqAWYVQP4SzECDybwF4NYOuleZF+JAHh0Jz59mbznmjTJlgGzFxIxSAVnMvTDR3KQQgHwLJgbINmgBbDSpzgKJrlaNaGURMmU9A1+gEwghbBBEw1A6YaTsDDS0DA9bAMnYI+5YU2FMcuE2MHzwGdIgHijHBJUCToTBkfR4jbi4SIEyBM9NEi7ddvkj/j0h9C6RgSj6HrgXkVmktw4jMubvVNuv+fMNHpeQJ37xPMdUm84BHT5ubtMx2MDvRe0Xn0R4v0hydwidAjyB4WScZUMYAip7HI4GG7S8SIsUqbNBuMnBg673JT07i9puOttOHOGO0gC8c9Ilaai6xyliZJpkRIMgaOMbhLiEdxi+DM5vLU5DIjpmi8hsEP1qX7xxx0S+sLv6xXGLlYLKYkZeKoK2ytyJuLxaJygZUAzc9yT6dT5WwKKFbasizVTkfqqGVDz+fzlMtl1YLML9GVWjVh2AQsCLMtwagEBLLB+6XZfrM0P7ARgCG14H7wIwDa/7nCREvtsIAxYVv7/b4K0uReJIkRDAbVZt1qtWi1WlSrVfb29pQUWJxcheGVgEnkiIAaSz+QlABMWAUBev7EhTw/v0mYjAl8wPKL8kHaBMm4yn0/fS45HMdRn99qtZhMJhwfH6t2LwKCNU1TrEE0GlVmR/4xFUDquq4ymBMJvt+8TVQYwiZLgkOYMflc+b+nn6coCeT+RR0gJnz+oFbGyc/qyLn8LL0w9BKMCysv9dXimiuBrjBifpWEBJXioi3j6mfKZS4Gg0HVFkgSQnJeURqIZwB8kFjxG8rJO+yveZf78Cdm/rgSmT8rR71eV6BBkocXLlxQTKXIhyeTiWJzJSF17do1Tp06peanvPfiObC4uEg0GuW5555jYWGBZDLJ7du32d7exnVdZUAm66K09hsOhyQSCcrlsnKhl+ScZVlKATMcDun3+0qqnkgk+OxnP8urr76q2utJacHq6qoygur3+0+Am1KpxHg85pvf/CbVapVEIsHS0pIyLmu322qeRqNR9R4K620YBsvLy6RSKba2tqjVapw4cYJWq8Xjx4/Z2dlhNBpx6dIlNjc31bVLomo0Gqk17+WXX6ZerxMKhXjzzTfJ5/Osra0pdUY6nWZpaYlYLMarr75Kr9ejUChQqVS4e/euYiUFXJVKJZX4K5VKpFIpBcoGg4Haa+T97vV6ylRMGPy1tTUuXbqkWspNJhOSySSlUglN0+j1eqo0JBKJkMvl1HOcTCbcu3ePhw8fUq1WFWicTqccHR0ptYGsnVeuXFF9vpPJJLlcjlwup5INg8GA/f197ty5g+u6XL9+nQsXLqh9T1qESUJTEpJ+IzZZf2Rdk3VYykrEpyUcDisjuOXlZXZ2dlQdtiTNYV6+ValUKBaLCpRvbGwwmUx48OABmUyG7e1t6vW6Si6tr6+TzWa5du0aN27c4PHjx0o9JYk+6RZimia1Wg1N+6CVpzDbo9FI7Rt+BZB4oki5mqZpSjG2u7urVAmyT/n3N1FrSOJUzOzy+TyapvHee+/heR5Xr14lEonwm7/5m//1Fqz/BsdQq2O5QWiNcVcs6iOXzdYl8kCUB8T0Os8vTBm1gyTsMauJHaK5OQN39TycOj0iEJ4TlrY2b608fr/+d/EsRJMjnndHLFyExBrc+X3YHni4ZahMdNqkCdImSpTZMMUofszwox7a8xBen9ff1rT3FcbOvCdxMA6zKDAErwej7LzdtBWHlZ+zof06w1tnGThZvMGQnFZhOdHDWpvLiRMPAuj9NGEMhlGHygbERhD/jwHubS1Q6xW5MLUJzh7QMDw6tkZfazDzQkSJUiBCyDII1zsks10OMnBzJYyXcSilbMw/DHCi8iwpWsy097D1KbcKU6bXXR6fWsQNL8BwH23WJGYe8XzriIV7i0ydJO/wDeoMWWivk/ziNqWTFtM4TEvgRRxID2EpBtFlzNfyTOtt1k2P/MMxBws1vGyJiDVibGl4BpTcDLoXJTQ6pBQbU8zAth1nFD8Lg10KThWtFscKO5jrFYZVg1x3iand5F3DZiu0SH95E+fyEmRy82bX4xgkM1AKgj6F3jb0RzCJQGQK+SCMAjCcwmRI9N5NTtzcIv6Wjd3V8aI2sXUPXfMY7YQYDYO4oQbZh1Win3Spb25xbIWwklGs3Ap29gSEXBj1YFgjvt+gcMfDcXU614NMLmTRNB1mY5xMaZ7QCLgQNmFigzWe15brUQiX5qz6+zii5Y7QAh5OMAy2iR3UGU80vKkLYR3ThMMEOD9jkfC2SL4VYWpukvDOEEFDo82IHFV7ygJJHJLMWOWEdwLjrSnJi3dZLHh4X9Rp3Mxia1OWxiOi/xfoZCH0F0yM8Dd5/HunCfY+RubWt+DtFrGTMKzNjd+th1D95ioML2BTwcIB1uhhMsIjgEOFPlMKXOE6DYKMMViiQ4Q2JgYxmqS8APndNVrtCl7Qw0ulYGiiuQYuOjoWkKRDliEWXSz2MdBckxVb5zoaGgHepYiGyYsUePkHWHN+7EG3AGExuEqlUsooR2RmsuFKcC49ryUAj0QiT4AykT2LlFYAvQAMkSXCB3JsMQOSL2FS/eyd/Ly/ptoPqCXYE3m8HwjKtflZXb+MWq7RD6Qk0PYbsMn1SOAi9y6BiQB2v1TZL02Xn/Ebcz1dTw4fMKD+OloBe3L/Ik2Xz5Dzy7nlvr5X7byfpfx+zKV8T2rGpT5f/pRAR67XP1aSEBA5vzAOEujJueW+/TXQ4nYrNbSS0JB6WAGf/lpvMdARJuhpRklAuABJuVe/CsP/pz/YEpZD5oUEWiLPFrbdr2DwK0jk+cn9yfyQ+xK1gj9pIgkhfy380/PCr06R5IpfQu+fK/7nKe+k/x79c8T/8/4yAL+M3V/P/mf1EGMkgGw2S7FYpFgsksvl2NjYUIZ5f+kv/SUFtqS8QsC2vCOSnNR1Xcn8paQgEokwHo+Jx+NKPvv48WNKpZL6XQH1V65cwTAMpVYQDwdASca73a56xySB4jgOp0+fRtd1bt26pfp3P/vss2SzWfUep9NpVastbY/+w3/4D6oWWdd1BR53dnZUDbSUEU0mE3K5nGo/try8rJzwV1ZWFFM8HA5ZWlpSDP6HP/xhTp48Sa1W4/79+8C8s4coqUTG71cUVSoVXNdVYFs+v1KpqA4TtVqNbrdLsVhkeXlZmXdJQrFSqSiTOkmKiow9lUrhOI5KukipSTab5Sd/8ic5derUE++F1F7LviAsrmmaCuDfunWLRqNBNptF0zT29/efMPEUQzpJDMg1NZtNDg8PVR92KT8YDAbk83nVIk5UUbZtc+vWLer1OhsbG6oER2Ta0vVC1kWZS4BqLyhSdsMwVEJAfFoikYiqkQdot9uq5EFaick6mU6naTabah3Z2dkhFAqxtbVFLpdja2uLyWTCmTNnCAQCSgWXTCb5K3/lr/C7v/u7HB4eKj+DUCik1uJ6va7KfzRt3pItk8mQz+fV+Mn99no9IpGIqiEfDofk83na7TaLi4tq37l//z6VSoVoNKrKDmQfkuSmJIzlGkRx0el0WFxcZDgcKgn9n+WjXRrglCfQD6P1c2yM8vwELmsccZIGAWNENAp/uTRgymskFyEah5A2B7/REOjOvKuTa0E8M+8G1e6Cl4bwGVjQ5qTleDYH52s/DXYOHv++Rmk3jUsEtCPSpT7Fv+Sx/HmohaFuMlcmA8P3BYFxG5wORLrg2SDtrUMG1F3Qz8L5/2uT3pda2I8jGCGL5EdsginoMm//rJ22cWpDrHCb2PMucQ1u/5so1oOTjAMFolMIB7bJJW22mxs03QU0HhJjigtMiJP1TlOc1biT6PP2uQRuIsjVQIfFDRhHHWLaFsPkgKXUlGqpxq2PJzA/fAFOnoBaFx78Lgu0ufjA4+rXI1jbp3mTBl0auATw8CjvFBnt6OxnusyeHxA8UcF12wQnUahsYQ96DCIetY4GWx7a6Sr60ojlj0Ip7RF+DNF6hkN0BhmTVBaiA6AehBgEettciVgYRZvjskc/CoGdLH1D4/ZzeUY/+1E4dQqM8PsS7z5MAvO660gfIgEYelAvvq+pPwCjQuZWm1jDpJFNoWlTrj84JvdqkGp3FRuT5GyKNu5hugbYafRwAywN7WaRZbvOcz83Y5SeUQgMuNVr8LVBi3H+BMTDYOuExzM2bI+ABY1bE8x6n9j6PBewFRpi5Wyww3M2PBiHYHLulu7NQAsD78dYsSjuNAz6BIwZ+mBCQHOxQ4G5Oj0ywyjAQxt2inC5CWe9KUb7AeNqj0CviMkMgyQpNqgSoEIKAw+dI5KtZ/H+N5PQ8mMe7iSYjDOcCRySrEBsCFYaRim4+v+wuJ9+zM7/eoXN3nNE3voSoX1w3zFwhgEavTTN2VVsYuhU6NHiBCFSZPg2CVxMktjUsXgXMNBok6PPFIM2e+S5SJhTNPmJ6TW+ZV6ksX4fklUIRpiOM1T6M06QIUwCgxwJZhygYxDlxMRliSM06vSJUMVjkxAjRj/QmvNjDbrX19eV6UkulyMWi1EsFpUkT4CMP9AW0C1GWP6AXcCjbNR+qbZsfGLS45fdSv1bKpWiUCiwsLCggiL4AGjI5icAQ4JKCQTS6bQC9QJsJXjxs/liLOTvZyznE0bJz14KSPPXdElLHwmyJciQMRBwI2AVUGy8tCiz7Xmf3l6vpxhnSSL45ccyRvJ/AqqHw6HqUS7Bt4yPyPv9oOlpgzC/XF5AoMjj/f+fSCRUX22RQQNqfP1ydpGR+u9PWln52WI5hKUKh8PK2EZaHEnfXwEI/X5fSQ5rtZpKAORyOVKplEoGyX3K+WXs/AkTATMyXv6abjlkTOQ5ZzIZptOp6mk+Ho/VfPYrCzzvg/Y1Mt5ipqXrumL2hfEWd2Jho6UHrR/cys9IMsk/d/018zJf/c/56dIRYaHkffaz4v7yB39yAlDP1C/3/2Eev/Ebv8Fv/MZvsLu7C8DFixf5e3/v7/HTP/3TwNyE8pVXXnnid/7m3/yb/PN//s/Vv/f39/nFX/xFXn75ZRKJBL/wC7/Ar//6r6t5/Sc5RLFSLpdZWFjg7NmzqjZ2ZWVFSf/F5EwAqahdBBzDB07zwqoJcJAxdd15W7FyucxgMOD8+fMMh0Ns22ZxcZFLly5x+fJlpYDxr72S4BKw4n+esh5KKUEul+OZZ57h+vXrJBIJVldXGQ6H3LhxQ0mF/WUm+/v7CpBtb28r0CMu0rLmCjhpt9vKH6BQKChZd7VapdVqKQfss2fPKrAYi8XY3d1lOBySzWYJBAI0m03eeecdlQAW1l1KdqS9lHge6LrOvXv3ODw8VNfnT+rt7Owot/ZisUihUFDXIz29BUDLGibvqYB3aaH1kz/5kySTSdXHW5IO4tUh71+1WuXw8FCVJ9y6dYvZbKbaXonSS1zF5fdlHRLlmUjCa7WaYtfhg17UzWaTcrmsVCtSn1+r1VQbsEuXLql9WBh9mTeSBJeEnXh+yF4jxmpS/iXz2+/5curUKbUGSs2367pKgbC1tUWn0yGTyaj1RZQHUo8uCgu/0shxHD73uc/x27/92yqhIASAJLJk3sn6KKarUqoldeNiiijqNylJk2Tu6uqqShR0Oh31TOW+xVNmNpupsXccR5VFybVJb/Y/Dc+LH7U1Mt8dEraqnOzlWfZSPOPYbHKTMDWWmWBHLUYOJAsQzsyNpCMeuB7YNTBCMIsA+rz11rAPegxi0TkQtoBZ6H1QHoLl61DyoG3BuYHNaPwuJh7lk1NOP+9x4jkYhuYKYCMwL9ENaXNAz2ROnnoWpEPghWCszftqmzpgQV2D6jLkfs4jxIR0EsZrUBmAcwMCHdCLkF6eQk/DuxegVF9hzywwLbkY/R0GhDh0LVw7SAWdGeukmJKnwhSHNj0C8R0Sl2eYH3ExTox5seKwec/D/GqSZDvA8XOPuft8gOZSiHE8iBcPE97dxx62cLJJMDYZtCIcv3ZE6b11EozJsYNJlpjeJZHeZhS20etnmQ7j7PUfYOoayXtjNh+NyISadKx5csLsJdBqE64+PiC4pxHd0clMXAq2TpMJqVyH4YdsXluAM1EIOj0YvUPWOSBaBO8nPYoDyHxTZ+S53PpQh9Hnr0MyBsfvoE2H4EbxohGIFuf11oEU6AbUanAQRg8ekRy+wdIbA07ddymc8ni8WmdkQtqCXtTC7Y2JeAZacIyRdtBcF29wRChsY7kwmbZpND3S34bVk7B8GcIZj8l4n1vNBs1SAsfwGERDdLIzlnuQ2obw7hxfH1wKYHtxsA1Ix8HywDLB7swzQ2ELzAl4DgT1eSIhyLyGfDDBm83nVCBu44YgbM8xu2vOW4lZl6BeBqYO6doR9oMKelsndm+F9PQ6U47R6JNgjSAmFmnS3RfQ+jYOx0S0BkbRZnYNRvo8aRTWwHHg2b9o8tZ3Xmb89hpOFfSmRnQnh+ulibNBlgIVevTJEsQkqN8j62Y4yTnewabNkIEepuu65LAYEeU+OovYWAS5QYYlHvAsLY7dMo2aAenO3NTOjmATwiNDjDwTDOpAgwALjLlIA4N9DMJMyDJkyBEORxz9idcb+DEH3QJuLMtSwELqsqX1ld80SjYVP+Ppl17563X99cvyfT+LJkGhSHoTicQTcm0/Sy6HX74NKGmlf7Pwm4X5JeP+c0jw4U8mPM18+s/nd+iWDV/YX7lWka7JnwJOxRlWrtvfwsv/pwAgAX8SCMlYyn3I70hSQZIcT2+Y8m+/07icw3/f8rN+UC7PWoILGSsZV3+tu4Bu+VOAgr8/uFyr3/DOf8jY+0sNJKkgdaB+IO+vY/9+x/djY5+ekzKeT88b/7UJ+JT6b/+YitJAEjXyGaKMkHP43yFx0vcrEfxGePJ9PzMtSS5J4Iixkl9pIAkE/+/679t/DzIuEuD7Abcc/mSOPDd5/n8ax8rKCv/4H/9jTp8+jed5/Kt/9a/483/+z3Pz5k0uXrwIwF//63/9ic4OkpiTcfv85z9PuVzm1VdfpVKp8PM///MEg0H+0T/6R3/i6/nCF76AYRicPn1avR9ilCXP0K8ycRznu9YGmfv+mns/iBG5uaZpqrbVMAzOnj2rmNRUKqWAUr/fJxaLqf7vUjLhl78+XXsv776maarO2rIstra2+MY3vsHR0ZFihHVdV+ZfYjAVCoUol8tcuHBBrVc7OztMp1NV85tMJhXTv7y8zPnz5zEMg9u3bzOZTIhGoywsLDCZTLh48SKf/vSnSafTvP7663z5y1+mVqth2zaXL19mfX1dJWIDgQC5XO4JZZQwidKz+9y5c4TDYbrdLoZhqJZSi4uLeJ6nnpmUUtXrdRKJhAJaxWKRxcVF5a/RaDQYDodPqIvi8TiapnHixAneeecddnZ20HWd5eVlFhYWePHFF8nn88oI7d133+X+/fsqsVKtVlUZSbVaJRaLqQStKAOk04Uw1pJYy+Vyqo58d3dX9R5fXFxU+8TBwYFqPVepVOj1eqq2fmNjg+eee04l7vzvsZSaiOrGb/ImiTz5vhhuSrmP/N22bXUPgGpFKC7v3W6XcrlMsVhUiZtkMqlKEp555hn1Lqyvr6sytoWFBQ4PD1lYWODatWvcv39fJVH8z8SfXFleXqZYLBIMBjl16hTRaJRqtYpt26pc7uDggMXFRfXenj17lgcPHnD+/HmWlpZYXV1VTLYkyTRNU8otSaz1ej3lZJ5IJNjb2yOTyRAMBlU50A/7+FFbI/+X6SLGdInTOAToEaBPnC4TJpiBGYEE6EFgOPeyIvA+5vLm7ZaDUbADMNPAiIMemQfVfW9eehsymZtS2aCPoP4OdPbAWICzp2Hzl8Y4YQimwE0DNnj9ebluJAEzZw64YwHo6XPWOzInIhl44Glg6/NrcHVIaPPkgJ2CjgmTLZh9BUZ7ASZ7KZyuRt/UKA8iBNwRScMEV8OLhAi0F1kaXUDHZN+12Wo30ZmxhIUe6BPPNEn0EsTwWH5xxMJfhtMJSN60ufhagNS9ONYowuBDbe79hSDbn34JMjqh199k5T81WbwPjXCH5oth9I0FcG1SaxC5XSfXtwjHasRKJpOCRWJzjmlv7T1msJKD82W0kM2JWoON16CTgtIKhMrgBYYkLAg/Bns3gjPJUU9XSegek6U9CpctnDOQWZqTutZoSqT5FsvDHpMQRHtQeBeGtsvj5zoMrmeJvf0Oife+ySDjkV/2sBeCVF/8EOQy0B6DOYVbh4Tv3yFtDVgedSm+CcF3o2DD4SObXBxiUYtxyiMfdFmINxgHIRTxcKIwwsPUbbweZMMQPmkyCcPeHRjszRMzmVNwLuoRD4+5czhmO1rAysYxKzPcY5g8gINNjcpGFvP59XnRvz19PyPkgOlCz5xP3GBg3gc8aIBnzIumpx7Momi2SyQ4hJmGY0I67KE5MDQhE4aUA70s1AvzRM9CHxauuyzOXCJfPKD76oilwYiy7fCIGS2usEQUB42A+zGe4U1Ci/cYftQjcw1yCTgOgb4A/UPQFmD9L9VoPPQwe1GiZyd4+S6xVoQFL4BGFY97RPUhiXifYmFG8FjnymyBFvA2VSzdxgznmXkOkekBBouM0Ujg8kC7zm0ecMEbUqRAaLaKqWkQiBKZafSI8QCdADYdejSJkMbhDHsUeQ8dmyQXeZMYdYKsYGAy+IHWwB9r0H3x4kW1+YrbrdSgSuDoZ6sl0BSZud9wDT5we/aDOwFL0ntVDHMkI+1vkyQGJxJE+sGhtDgSSTagggGRUI5GIyaTiWIR/Ey3gDXZnAX8SkDqN0HzB63iBCxSUn+NuYAvOSQhIeytH8wPBgMGg4EyeBGWUgL4YDBIoVBQslQ/kBbAJqBT6uqE6RZAJjXbkUhESUGfBvLCNPtBmQQ5kv2Xa5JATmqFAcU6CQPS7XZV/Zyf8fX3Ege+C+TJ9/x1zBI0C4s1Ho+JRCLKlVkUBf66bXHTF/bQDzxlzPwybQlkxThIAlxho/3PWQ5poSdAyl8bLb4I4qQsagw/4PHPrel0SrPZfMKMSYI7mU9+6bC8X8KUC1sjUlYxqpMEhRir+eu9/UoGuQc5/EkFAY7+Wm/pdSt1o6KgEDXHD/P4whe+8MS/f+3Xfo3f+I3f4PXXX1cBZSwWo1wuf8/f/8pXvsLdu3f52te+RqlU4tq1a/zDf/gP+aVf+iX+/t//+yrB9196nD9/nlKphGVZik3VNO0JJYYkxgScapqmynb6/b5KqEnQLnOw2+0qcymYtyd79OiRkuhubGxw/vz5JxQYuq4rGbTfm0LWbUnCifpFjNbk82/fvs3+/j4wB0YCEKXtl5R4SJCeyWQYj8dKPivqI8dxFLDSNI2Pf/zjxGIxdnZ2MAxDmcZtb28zm81YXFx8Yl1sNBq8+eabPHr0iDfeeEONn2VZCrg4jqPk6Hfu3CGRSLC5uUk0GqVYLNLtdrl+/Tpra2vKeC0QCKh3IxqN8uyzz9Ltdnn06BHValUlMEQdk81mmUwmyvFaVAXj8Zjd3V1lHqZpmlIh7O7u8vjxYyX5FrXLiRMnKJfL2LbN1tYWlUoFQEnjDcNQ0nFhdgGViPUnuPzJOFnrBMxNJhOVFPC7i8fjcSWNl/ZWhUKBF154gRdffBFd15+QYcv54/G4Yttl7ZA1U5Kmnuc9kXxdWFhQfgKu66r2d5PJRI1xoVBQz6FWq/Hqq68Sj8fV3Egmk0pZlkqlKJfLNBoNXn/9dQKBeXu2crlMPp9Xnh2SvHZdVyWEbNsmGo1y4cKFJ/Y22X/S6TSu63J0dEQqlSKXy/Gd73xHJVhEDl6v16lUKiwuLrKysoJlWU904YAPeqvLc8zn80+4l0sLRqnx/pOuN/8lx4/cGkmKIgls2gxoo79ft5khTMjWmfXHhB0PIwReAMLjeV11fAncKPQjYOngeYA1JxedIMxs6A0gHoJwAbw4HHwLHn0tzXRcxEjVWP9Cn1N/ce48rhkQYi7/TiRhYszdwUP2vEVSMAShMCTMORirTebdqPQU2Oa881Zch/Q7EHxbx0249Hc0Jm+vow0yTM0gD0jRoY1OAJMcSR6Tye8wyu+SORoRG8ZZ0i2yboQBBi3NIRDsUGCfF9J1opfhveKQRgCsc3M5e/wrGpe+VGS5fp2wNyR4+lUCH3N4z9Y5vlHBve2S//005coZAtMhhcARm8kRZ+KHuI35PVmXu7z7eIR2xSRyAe6konRKSYxul9DzE4KrE6zwi3j1IbPQa8ziM6YziBpw+aW5d9n2qzq1oUfA80hqHtNzHu9dgnYwAVOD6KDD1bqD6UBm0eXaqMfCG6DvaESmHpMUHH4CKqsa8b0+J96EwNYyx8aMQqnJ6LRF9YQL5QjYByS33uH0cYMSM5JJiN+GyV0dLTbF0jyckUFk5oGrYWlRJlETztgEPHBr86SJZ8xVEQkNAknQzkEyDMF9aBzD6Nuw0oHpJugZWItB3RzSSyQ5Wg7SGzr0VmHy4STei4X5xBweAt6cwcUDLQKJINrYhL4NYx2NKcZ0TNqakbNdrLFBwHM5GXQJz+atwNfz0E3Aa877Pm3ROXbXpvNkyDAJswIwhc99wqFHg2+/GiDeKVKgxZAtPGLo2EzRSBhRygVo9OHgXxvUIy6hEiTOedir0ItB9AxwroN9M4IDpC5beDdqWAOIkuB8oMlsdYCdmfftnjo6Oh4FMsRx6TlHeIUUdixHZucNyt6YY0Ys0WaBJR56eSq4nCPBe84KB30L1wihu2lMDEZAG50mIRIkOU2DRe118voWmhui4S2yS5BOyGFm6uRJfs815T93/FiDbnEjF2mbBP3+ml8J9uDJXsRPG4zAkyyibNCS6RcgJ8yBgABh1IXl9jOUktGW8wh4Enm6BClPBwV++au/PltA99PMHXzAaPvrm+V7ArrlTz/D5b9v+Xm5tqcTFvJ3+R34wN1dxkMSEDK2YvzyvWq9/ZJ5P6iV80gg5wf5ohLwlwX4Qbt8htQoAk8kMSSoFRn0aDRSgb58T35G7uvpemH/n/7PkzGUYEpAsYAAP4iVZIDUHz6dqPEnfGQeyJjJmEpwKQyUqDT8yQp/XbNIsyUpJSyaSAwl4eRnzP1JJPmM6XSq6g0lkeAfI//7JPftv3f5P5EWy3OXe/N/Pf0+f6/PeVqK7mfERQbtV588/ft/GofjOPz7f//vGY1GvPTSS+r7v/mbv8m/+Tf/hnK5zBe+8AX+7t/9u2p+vPbaa1y+fJlSqaR+/rOf/Sy/+Iu/yJ07d3jmmWe+52eJ0Z4cwv4NBgOSyaTqx1ssFtV7KAaHruuqPu7CzEr9r9+kURIiwWCQ6XSqkpALCwuqXrfb7aq+3WIKKe0aw+Eww+FQnUtkwY7jMBgMVPJG5NAiXZZabM/zeOONN3jw4IFK8vjbUO3u7qoeyAKQB4MBp0+f5ty5c0pC7roujUaDhYUFTp06pVqKBQIBPvrRj6rezHfv3lXu5NKaScYrFApRr9c5Pj5mcXGRSqVCs9lkYWGBYrHI8fGx6jNdKpU4efKkSkw+++yzFItFtra2aDabPH78mGg0ytLSEqdOneL1119/wu1aHOGlLGoymfCZz3yGj33sYxwfH7O/v8/W1pZKdE0mEx4/fkyv11OJxtOnTyvDssePH5NOp5XcXMCnrJ31ep16va7Y1wcPHtBoNHBdl4WFBZaWllQSB1AlCrI2pVIpJfH3r9tSgiP7miSvl5eX0XVdMee6rnP58mWuXbumzOx6vd4TUnrbtrl37x6VSkXtfyKRlqSfGIH6gbXszzJPZf7I+icxhOwTkhxOJpO02222t7dVQmo2m3HixAllHCpJhP39fba3t0kkEqRSKU6ePMkXvvAFSqUS6+vrVKtVBXj9+42w7qKMgrmJmyT2B4OBei8lYSaJzna7rfrPS+nBdDpVRob+Fm4SW4iPQD6fZzqdcnh4SCQSUQqDUqn0fYHvD+v4kVgjiZOgzxiXKKcp0sfhCA2I0IehjmM6TKKg9SFvQKAIdh3syFyZa3ug58Cdzk2jg0vzzlCd22CuQ6EIrW04/Faabm+FPhbRVphCBaLj99nrwhyAtofzFlVhB3QTMu93kPJMmAbnBmqhGOTG81ZK9hg6UxhmIe5B5VvQ+v8miAVNZk6Knr5G3HSJMKCt3yXsRVjyThEnQpxlBuYxyx+esBSsE7r/VTIWeCGNxtBgIWJjnYB8DxJbYJ+G8U/BLA6jEGi3IfctgxO1INXMFu1yg/aCQ+8hlIou//Ojh3R/L4PZeIFdhoyNKvHNKbkNaFQg8AbEC+B80iP1jIndh7txOHjuObziGjx+j5XWHU5stbkd3WW6tMH980v0mods3LcwphC0YbCl02quEPF0EphUltt0Pxei+xPreJXnYT+EsfXbLPV6TAyITyD2UGP6pSwZ22by0T7jT0M/D9NwgqVHExabGvuORtLJkToy6az351Jsb0aydocvHB6yOoNhFOpvw9Eb4CZdFpZgKQBWymbQBrbBjk4YrngMohCYQeY0RLNgH8/nlBsGNwiZIEQDMEuCnYBuHewGRBbmKoaVKBizKa8bLv3LZQbXrHkD8UQUen1o2RAPQDICjo5+r0+20iSvzwjgYYTn3cncAOSmUBhAVoeQbRMwoezMx8Yegf462BswOAf3UnOmezMMowiMgvOEUNCay84n/XkyqOkEeIccRUboHOIAG1i4kT0Gmy2GCx7TWxrHx0u8i00KWIy65P9yjWs/B/FF4M9ZjG5FsR+HyX9uxsw0mdyoY83CmF6QUGwuRze6gDtmTJsoC2haGl0fEO/ZOGObnBemzBQHjTIeCa/FfdY4Is1FYI08o+EUjS4uAVKYLBGlSwwDm4vUWNdfZSn/kPxQZzZZ5T4FKsSxnRq7dIkT/oHWvR9r0L26uqoyxn5zLj8j4wehT2fjBUDLxisBTqPRoFqtKjbRbwwjm6Jk7sW4LR6Pq4DRXyfsr1GuVqsKJHmep1gLcUv114oLC9xut9VG6Qd3ck/C/EmPVQFyAjrEGE5YbL9UWIJqP8CBJ5MPUqstzLr86ZebCmMragNpNSNg8eme28JGCQMq9yJt1vxt3YQRlVpyuXYJkCSYEIAonyFsrQSiAjolSBJDM2Hz5Fr9DOzTEmv4wNDOf8jz8EvgZYwkkJTzAYoxEedzeWaapqlgdDAYqJpcmRd+5t2fxPGzw7quP9HCTJg7SbhEo1HF+AmzHovFlFGcgBi5F6n/lyTPeDxW/W41bW4MJO18xE1XgK2MqzwPf8swv3mbPHt5PvI5/rnuZ2uEZfOPv1/C7k+CyTn9P+tPJv2wj/fee4+XXnqJ6XRKIpHgd3/3d7lw4QIAf/Wv/lXW19dZWlri1q1b/NIv/RIPHjzgd37ndwCoVqtPBJOA+ne1Wv2+n/nrv/7r/IN/8A++6/tPv1fyfvjZSUn2yVwQlllMAMUITPwJQqEQX//613nw4IGal5ZlsbKyQiwWY21tTfVqdxxHrQuyXkgds7SkE8BjGAZ3797l7t276l2Jx+OsrKyocqEXXniBVCrF22+/rVQd0jpMAF8oFKLVaqHrOqVSiRMnTih1SyqVYn19nU6nw3g8Znl5mYODAxqNBqVSSTGx0t4uHo8rl++zZ8+q93owGNDv95Wp12g0Ynl5meXlZTzPY3t7m3a7TblcfmIdGg6HFArz3p5S276zs8PR0RHBYJDNzU0+9alP8fbbbyvVTSaTUaC93W7zkY98hCtXrtBsNlWNtNRkHx0d0Wg0uHv3Luvr64RCIRYXF4nFYsqMTWqFc7mcei6Li4sUCgWq1aoyeKzVasroTPaxXq+nFCvtdhvTNFUts2VZZDIZYrGYauEm7DWg1EPCHotSRpzEu92uqqsfj8eUy2W1HgtjblkW3/zmN3nw4IEyk0un0yqhLOZufoWYgHLTNOl0OupZSG93qUMXECvrsuwnogZYXV2l3++zv79PPB6nUChg27ZihCUWkL3YNE12dnZot9sUi0U++9nPUi6XaTabOI5Dp9Mhn8+r+EISUtFolHg8ruIAWb+SySSRSES1q5P3W5K6y8vLBAIBOp2OUvBJ4txv2GkYBqVSSf28lIR0Oh16vZ5KTkpy4E/j+JFaI4mgYxMhRoogBgNmBLBxGONgkCJojrEtk5AXxMubjG0ItCGyPAfaVg9SAZhaEE1BKABfuxXk9q0S5k4DHthMdktsDK+QosY6FeLGlIUpuHWI5CAVmde5BnSIBuHIhP4UkoDmQCQ8Z9Sr78HRe0Gapothe5SmHsXzHpFnoBsH5xNgZQc0XjboHp2kUYoSr9WIm0GmIZeFWQINjb7xHkNvQDFmciYFtZMw2YREDJInPbyezd0JmCvAHry6B6M12AnNcV68D5YN+sdsDi4dcnweqqfgbS3KxIpxcdBCb0Pmo3306h9RD9rcL+uEVw1ytoN3CwYNjbLjEbutkToIoDVtZp/X8fJx8KZowQnmVGflvo3x+DG3UkfMzkH1s0mCyS7lr+lMK5BNO5yLzDAnJ9lZvEv1L+hMrpxDaxlQq0MywXLbpvhOgIdnbLY6YH+tyJlRntDGI5wLMEhAu6fhFk9QTY9IL+1RzB2SqYYh4LB7QYOCAbV9zveO2RhBozF/RuN3YGqCdQL0OIQTYJSh3QMzCaGzHsE+hBsQPjlXP1hT8IqQL84V37gQbM1LEabm3BwvnJyb75nT+fygBwtZuDgzeXc8ZFxOg+nNszGGBZEAhhUg+3KdzTdNYjd0ci2dfFbDyHlE1ueAfxaHsQeM5kmL4BS0NgyOoN+ek+TuCCIVuBaD6GmIalCYwq42l5k7UQjpc2XGvSyUzsN6xaJzp8OdsAtanOhEww7ukD/fILQAwQyknvcI/tGASXeN6jK0G11KX0yRK/VJfB4Sp2C27OLsL9Kp7pO76DLct7AObIZOHv2RRzQ2IKHboM+YuR1WMDnpeYydJC9OXMaTPQ7w6AEuGu+hYxAkRYEtAkQZc5oQFjq7GFh4pAgwJMQQjxcYcF7/Q5ZyDwnoHo3ZJg0+wTu4tI0WSSeIQYBjvv9688cdP9agW3p5isxLMsF+dthfb+qvHfQz0QI+JSgYjUYKmPX7fQVEAHUuAQJiNCaZfD+oEAAnQFtkvAKSABW0COsn1yWgyt8PXMCC3Iv/WqRGXZgbv4xcQLgw4f4WYiLH9X89zT772X9JavjBlYB7f6snv0za73YugZAwVX6g72/XJkycPxHhr4mWa5Xz+V1s5fNlbOTaxc1WDGrETEySKX6TLf+Yy3nkOv0st3xP/u0PsmUuSEDnZw7FIV9UASI9FFAkc0UM3J6uc/WrISaTiZpz8jkCnCQxIcBE5rC00BJjoUQiged5KoEhz8g/r0XtIIBYTH2ERYrH40/I7+WaZCzlGT7NZvvfTXknZR7KePrH3V//7/++JNX8JRvyvstn+ee2P4nxwzrOnj3LO++8Q6/X47d/+7f5hV/4BV555RUuXLjA3/gbf0P93OXLl1lcXOTTn/40W1tbnDx58gf+zF/+5V/m7/ydv6P+3e/3lcFYu91WCT1pryTmfjLf5N2TwD+RSNBqtWg0GqrN0XA4JJVK0ev1ePvtt1WSZjKZsLa2xnA4pFwus7q6iuM4qmxB2G5h2xOJhGKxJSk6GAy4e/cur776qlp3dV1naWmJbrdLMpnk6tWrfO5zn+Pzn/88//pf/2vefPNNNa+SySRra2uKqV9ZWVHz5vHjx8pZenV1lWg0+oQRWLFYZGNjQ3mDjMdjqtUq4/GYdDqtElayTrmuqzpjSDJgY2ODkydP8sorr3Dnzh3lYF2tVtF1nXQ6zc7ODp/73OfQNI179+6xu7vL7u4uR0dH5HI5ms0mX/3qV/n85z/P5z//eb74xS8qqfX+/j43b97kU5/6FBcvXuStt95iMpmwsrKCYRhqj5L+5aVSSUn/o9GoSiweHR3heZ5qEyfry/nz5wmFQuzs7KhkscwPeaekE8jh4SGz2Yx4PM5oNFKMsazzjUaD2WzGxsYG2WyW4XDIaDRS64CsfZFIRM0hSdJKWzAxD/ObSN64cYP79+/jui6FQkH1lJ9MJgSDQZUgEJ8KKVWSPVjmmd+ZXdy8xWkc5i3TFhYWVCL08uXLyniy0WjQ6XSUGWS1WiUSiah5KNJu6c8+HA4ZDoc8fPiQq1evkk6nVQKr1Wop9YkY9Ym0ezQaqXp3TdMUmBdTTDFQ6/V6imGXMjK5V0mQyTwulUq0220lnQ8EAgwGA3Z2dnjw4AH7+/uYpqnUD7JP/mkcP1JrJC1ahIniMqOKTZ8wDjGCjCjgEmKEjeuZBLEZevPa7FAKWsG5XDbtgj6E0QySK9Afw2sdg1eXF3C8JByYBK1VLC/CJxiyGhvirljEN+adpgIRiAxgMAM7Pgdb6UPQtueeWE4UvC7svB7ga19b4nGzRMeYUrZdLmsDOj9xgFb28K5A8bMQ/xmP3qJD/p+MSB9EeGQ4WFqeE9MJp2kS0XeJZga4wxBaK8X+/2lxfHZE9eMetzegkAArD+9M5yZtl0owOAHV8JzJN0bzkuHsGOrnoJ2Zg9aQDstM6LsTaok54Px02OXcyoTaIjgnc0xeMRl8GTiIMzITHDdg5UGANGHeWt6nslkGPYh27w4ndx+Ru+/R+6MF0tVnOItJ8833OPpfLGr/Y5DeLpQfaJz+pM3WSp0vHnQZ/g8zJheLxG7UeWZ0xP31GK1Ajty7DpW9Ag+WazSPNc72NkjoR3hnLbw0JPsQsDyMoyqOF+LeZxfZGNfZuDfhARrHl05AOImxs01hNmPSnXfwcnZBbxgYGw7xJPAwxOE0hLk4JDaCkQ3tOsR3DTTDRS97dHZhChSuwHIAJt68w5jdmrf61m2ITCBigRGEaQNySTA8qM/gVBrcYYc3h+AGQkAP0EjdmHL+D2dcumGwWA0RdLKMiDNpVglrY6bvebROuujLMM3NS7ujE5i1wd6fn2aoQzg3b/c9PIbFV+ETYbizAo8S0GfecSywAE4IBmEYPgONc5ANOaxU23RbCQKEMYDa4oiIq2F/K4uzPGLxJ2asnOyz+rbNYBqjnjPQKwlafzhCv+IQzkBqY8R0+yqtbweI/eQWCxdc6q021fF5RuZpwmaNUeAeZUdHZ4hGlb/IGhUmxHiHKGOCnKPDAlF6uIzoojHEAOKsYrMC5IlxRwvhemNCpJlQYokaZ7lFIf+QQMRmcLzBY/c6rzDibQ6xMDHJoBPB4Acrv/mxBt0S+Asoexqc+s2zhOWTf8vv+GuNB4OBkrIJ0z0ajdTvC5CRgB5QQQqg6uSkZk1qDqVOW9qvCHMgdb4LCwuk02lgDiIECPoZbT8AlHuXa/c8TwUTAj790l9/+zFhuOW6/OyxHH5JvpxDsupyzwJa/PJoYSgloJYe051OR7FpwnKLdFDG1W/2BSiGfTAYPGF0JoeMjYyBgDo/c5ZMJgmHwxSLRTUGAoIHg4F6LnIvAmL97L/Mke8lxZfPl0BHQJ4/seA3HvOzu3Iu+RwJSuV+BWwL0yKHsLkyvwU4iezbL68WdkQcluU+BORLPaVIsCeTiQIkYpblvye5br+zvjCCpmkqqbqMkTwzURH4EyfCogjYlhZ9wBPJne/FSvuZbb+KRWqVJckwmUzodru0223q9TrT6fQJo7w/DSYnFApx6tQpAD70oQ/x5ptv8s/+2T/jX/yLf/FdP/vCCy8A8PjxY06ePEm5XOY73/nOEz9Tq9UA/lipp8i3nz78CYzZbKbeNXnvxQxK5qiUhoxGI7rdLqlUikgkohhCwzC4efMm9Xpd1f9KDXgmk1FmZGJmaVmWui5J7Ny/f5/33nuPcDis6pHFL0IYT03TlDP+/fv3ldRVTLjC4TDr6+s8fvxYmVEtLi4SCoXUOyPJnUQiga7rbG1t4TgODx48YHFxUc1nYSwdxyGVStHv93n48KFaN3O5HA8fPlQtnzRt3ocZUJ4Q0rppa2tLrRfS2imTyVCv1zl//jzPPvss3/zmN/nqV7+qkh+5XE49I13X+YM/+APK5TIf//jHuXnzJq1Wi3PnznH27FkikQi7u7vs7e1x8uRJBQbFWE1UPIVCAcuyiMViLC0tqX7Z0k+6UChw/vx5XNdlZWVFtY8bDAbKUFHeV0l6RKNRKpUKjuOod8h1XfV8pcuDAFnHcZ7Y74QNl9+RxLOfrZV317+mionb1tYWCwsLZDIZtW77PUlk3fYn7yRRKIyvMMx+Hxj53EuXLhGNRhkMBkqxJkZpuq5z9uxZde3S5iybzaoE9Gw2o9FosLy8zOHhofpZaYEn70w4HFbGaLdv3+bDH/6w2iNns5nyNhC1wWw24+rVqxQKBYbDIeFwmFKppOrCpR672Wwq40NJIsi7Ih0FbNvm9OnTpNNpDg8POT4+Zm9vj8PDQ8bjMfl8XqlhRN30p3H8SK2RgMYUjQAzdAIE0dGZoGPhkMBkho5DAAswTJdkFIYGdJuQsueMd8edG6wZMbj5AHYi4KwO0fYCGI0orp4gRJpk2CP1MZPkRyERn0vTQ2nwgvOLSUah/ZrGzv8aJlw1maY1uqMEnXaW2uAsR45OO1/Hm3lkh3k8L8mDBzVSWzPiJXD3INSFtbBH9NN32fp2ktnwNBks1jAx0Bi4aSrdMg0jSY8A68cRFtr75OK7dC3gXdgowex9OfLqAjzow8iBSAoGAyjdhHNt2D0JzSys35vXk0ctaJSgfQY2ZxD+DyGOGgF6/8MYI98ldN9D392g45QxMVghSYY6h+lH3PlCltmzJVIvv8HC/zHg1H6O1KTIaHqWGiGGNIjVl0n9H7to/08T+//m0f8qVPLw2nMRGoQpR2ak91qcf8flI55HJWPSGrl0WxArtgi7HqmdAnFvgJVu0lmBhSVYaMPGEDJ3G3AnzONzMXavl2k812caTWOvn4BAh+TgiGwdrF2wanMz8M6yQ3IZ4iZUBkGc4RqjXgVbG+CiEQ9boLn0einM18cEMxbG+bnUvNWcKxgmo7mzvDUAtzs3Gh9HwKtDYKbhlTzcZdDD4EVBd0G3x7iai9Efc6ricO2rHme/AxnbZZKcMdOqBIcBDEuHgIvleNh7EBjP56lnzb0HzMk8uUJpDqS7BwG0Ebi6TTwK4R1oF6B+aa5cjw8hHgNnBNMZZKMw06H7DGzqE7gxY1zts+pBtjTDqkHACTLbTtJwTZbzLiuhAZXWJvXlKK1cm+b9MbPbXXKfBeuEx3FQp9//Sdqvt/jIz3aYVWY0bhkcYhBlnRU7gkGPbTJ0mfFp+ixRZcg+YRKsEiZCmh5JNoEeDb5JG50gWfq4uETIc9brEydMmjImXS7zBmcT3yGdMTncL3DsXOEeUW5p+wzCY3DzmJ5OwJ0Rxfiu9eS/5PixBt2yOQtgkuDJz6JJgC5MrB/A+hk4CcT9smO/uUoikVCsrph2AYrJ9ksIu90uvV5PyclHo5EKBv0SW2EiBTgKSyygFj5gWJ8G4QJCxHjFf/9yCJiV9jyyiUqyQgIrAW+AkqD5Hc/9wdFsNlN/d133CUM6eR4SFEnSQXrhCgiWZIMwpMIqyPnlHCIv9Eupn67X9wNWAeVyTZK1Fxm/H/AJ0yPAyz8f/Iyof0yFZfWPiT9A9MsZDcNQoFGu73sxrX65s8wN8RAQdYSYAQFPqADkWuX8TzPe8kwECDxdYy2JKGHZhTGRGnH5XJEoynn9ygHP8xQjIi7Xcohhm3+uCfMkslGZ81JXK4kBYcy/11jJPfjr1w3DULJVSe6IYkDqFP0truSa/rQPebe/1/HOO+8AsLi4CMBLL73Er/3ar1Gv1ykWiwB89atfJZVKKfnln+RIJpOqJZaMld+ZWeasfEmtrW3bqoexsIciNz84OFCmg7quqzpmSbo5jsPDhw9pNBqcPXuWK1euqOTMG2+8wZtvvqnYU5GDCvCWz9c0jfF4rMDbu+++i+M47O3tsbu7SzQa5dKlS6r91HQ6pdfrKfWMJArF8E/WjmazST6fVyUc5XJZ1YqK8dRrr73GeDxmbW2NYDDI9vY2jx8/ptls4nkeuVyOXC6H67qKBa/X63iex/r6OoeHhziOQ7vdJpFIUKvVyGQyfOYzn+HWrVt8+9vfVsmlXq+H53nqmch78e/+3b/jZ3/2Zzl//jzNZlP18Bb5uBilZTIZTpw4gW3blEoltre3n3hfFxcXcZx5a7R2u83e3h7lcpnJZMLrr7/Oz//8z7OysqLeRSlXGg6Hao8SJZmsDyIdl3kt+5U/CSnu8a1W64lEsDiMCysuCgsBm5lM5oluA7JOSSLBb4QnPg2yp8nvybN8OllnmqaqVZfrXlhYUOBb9l8pW5BEpJTHLCwskM/nuXr1Ku12W6k3ut2uUklIy7hYLKZagIn8/O7du6ysrACoXul7e3vYtq3GSJIowWCQ27dvq0TYu+++yzPPPEM+n6der7O9vU2r1SIQCKg+8vDB3lAqlVR7P/FDGI1GytgtFApRq9XY3t5mf39frY1irCmf63cN/9M8/puukeikMRhjEEDHxaTPgCkWFhpg4WLhajauZ2DZ0PXAcqHA3DV86IHuQSQ9b690sA21RgFmSyzsTcjbcUYsEAGc8AA7Cg93oXkIZy/D5YvQn0GkA7Wvwpv/ZgPjKI0Rus/Rfomado3HKZNpcEjGsdCdLk4ODqxjOmaCeHOR1NcPido2tR2Y3ojRzlucv2aRSjk8N7wA1GiQ4VbiPEM9hO24eBtj8Op02yEWG2XOvzyg+E6f/ChIKhrg+saA3CWP+HMQi4BtQT8My1+G879dpBTvUgqbLHegfQua70HPg+w6nMxCtKuRv/cMcT1NaPcr6M9F8E5B8vUB7rhEL7RLLuCyHxrync+aTH8mSvrWHZ7536do9y4xo0wDhyOmRDgkvnyLYdxh4VEW9/8VIv43Zix8Evaa0FpaIuyZfGK7S/gNh+47BruaQ3dNh3NJpoEhpYHLqG7Rn4JrNNFOThmtQ8SBcAtSbRjcibG4f4Xy0S636h1q//drsBqBiQO6Q0qbkh2BbcOsB24MgqdhGoJwFKZLI8zHLaIeOG4QE51g1MJ0PYyBgT4LYccsiovzEvFBf84qB/qA877BuA1eBKwUeI0oIVOnOxphhyGQgZ4Bex7YlgPajAwuH616rO9DeBFiIQ9328OKQDBoYrd0iHoYBrh9DSY6VsTBi4PrvP95hXnf7Pp+AK2zzsybEkxUWHBdPAdWo1CfghWcm/rpBoRCc6O/gD03W9MWIPQpePZZF6s9I3sE3jvQsyC8WsM6hmELsjNI2CZp12JYt5kaBbqTEttfe4PCMyPsIrSDLjWzgDMsYQU7RE5ahN+bEPYcujjorLJDjPuaxxiLpLfDS1jkOUONIHfpcFuv0dMCbDjLXCbFZXR6hIi/3wQvQoizRHFZp4dLghssG2+Sz4wJ9zVq5glukeUNqrSiPbyMBYM+hhnHxERj/P2WlT/2+LEG3cJWSlbbX0MqWW4JCgTc+kGbBInCGgrIEcDnuq4KEOX35PvNZlNJ+2SjDgQCtFotms2mchb1A0k/ayqgwLZt6vW6Oo+/flbcWW3b/i5nWLkOuV/5fwE5Ii0LhUIqmIH5BicSzl6v94SRi8iKQ6GQqg/310v7a7AloBG3cQGy0ndVWBcBrHIuSTTIGMj3hXXz1+QBirWWe5VDzJL8YF+AhAR5EoRIrblfti8mTRJwCvB8ek7Ifcr9y3yAJ6Xr8KS5m/yOH+D6TezkGcp9+j8XPkiYyJdf+i4/L9+TOeDvzy4MpAT4/hp8/z1Ina0kRIRlaTabCvwIWJaklFynv17SMAzFXj3dM9uv0PC/f/6EwGg0esJMTZJp8rvyszI24oQugF1qKf01w+12m2azSavVUsDoaSXMD/P45V/+ZX76p3+atbU1BoMBv/Vbv8U3vvENvvzlL7O1tcVv/dZv8TM/8zPk83lu3brF3/7bf5uPfexjXLlyBYCf+qmf4sKFC/y1v/bX+Cf/5J9QrVb5lV/5Ff7W3/pb35Ol+c8dOzs7AMr3QhJ0sl5Jwk3+T1hMKUUQZi2bzWKapmL4xFV8aWmJRCKh2Fph+V5++WVarRaPHj1ie3tbqX9Mc95e6vLlyzx8+JCjoyPlkSE1wZ7nPbGmR6NRut0uL7/8sgJGzWaT4+NjMpmMSlBKUC7rkPQZlnNlMhlmsxnHx8f0+32KxSK9Xg/LspQSRu45l8tRq9WIx+Ps7u4qMzHpUCGqnWAwqOqxC4UCV65cod1u0+v1uHLlCidOnGA4HHLu3Dlu377Nyy+/TK/XU0oDAZDdbpdPfepTLC4u8pWvfIXRaMR3vvMdnn/+eaUYkCRwNpvFMAwePXrEhQsXmE6nLC4uKu8Gaf8k74XU60o7tXa7zenTp4lGo9y9e5eTJ0+qfSMej9NsNpXJlOd5dDodxfaKE7bIwyVB43meMhPL5/NPMMme59Hr9QiFQkoaLQlBf6mQAGhZj+S973Q6HB8fP+Hs7nmeci2Xz5cSHP+6K4lG2e/8yrbJZMLBwQGFQoGTJ09+V/Jd1gqpF5fPEuWQJJVFip9Op2m32wwGA6WuEDWdSPH39vbI5/Pq/gxj3jv+zJkztNttVQoh+6Z4goiJXCKR4Pj4mFqtxnA4JJ1OKwl7Op1W77IoCaQPua7rbG5uKuPZra0t7t69S7PZpFqtqs4GMv9t22Z9fZ1UKvX/95r49PEjt0ZyjMcySTw8pliYaASJECdIGosBDh6el8XExrZaDIc2oeCccRyMIVyDbBnMxBxU5Adwttsl0N1lhSEp8uRYIaC/wfKZOod3Nb6+t0TNDvL4dp3tV3Uars1OK8LR0QVOj2J81Hibe16Ib4SW6OQa2CtB4lsmJ6ZBjGGSrZRLv2wxa09JDVL039ugsVXDtAIMpstEqgPy20dkJiVGTNCJkeQSuqsT9izS0wnNbg2yFk5yQn0A68MX0IZbHGvH9NtrFCtTYu9V0W6Nufhhl95VeMeFwrsGucEqNX1E/Ns2XdPjwcRjZ5Qi5qW4/rhPotAn5OoEvTiHoR79Etj5ItMrLublA7R2n+RLJqll+PYsQPvKAkvv7rPwf3ocPThNnRlJtogQo42NFj7gyqdMgsuw8zsjlg5CWH804/jj0EkYOHaYcr/F6jtgvJInPlnkveIOwxM6odkxG3YKY2KQywxIr7dItKFVhmYSwh1IPwLjEQSOA7SZccaB1aMhv3/nPWqnNsEJw9QkFofZAEaHGkQ9PGfelk1fh2kU0p0gBjMihR6RbpCuFcN2xniGx1AbMAjZ5EOQHnxQShCoQ6sGQROyLtjRea20roOtebiujq3NJegzCyY6DIMaeDEMb8JS18V4D0a7OnbGZRYArwSJTRjVwZ65eEOdqaejuQFc18EIOWiZeb95bwIjC8YHYNYCuJ6FSZ+J43JwZFA4cDgThF0HDk2I2fOa9DCQdGBgzN35gyNoOxCNQiIB3TxYYzBvRxh92CT9rEv7DzUGhzES7ip58vRmHhksMmQY3VugeWdEbA1i8SpLI4vaKMf2twKc+YhN+9J9WrfzjDyPGW2aBMh6LjGm3KVLlGU0ijymyZbRop0c4k7TOM6QDAPSpLFwMBgSZkwKmzFFhpis0SRPi0x0QtjU2Gos8JaX52067IVq2Ln+vLf5xAGGjLHR+MGMJn+sQfdwOFQBo1+OKvVhYkQiQRJ84I7t35QFRIj8VEA38ATgFJAlAMfzPBqNhgI0hmHQ6/WUrFpAkAQGAqj8YEUYBAmGBUwKKy+BmUjm5HfknH4gKuMgbXim06mSVfsZWqlnliBB2FX5Ob/JmRjNyO9KfbgERWLMJcFKv99XDL8AWpGRS/2vH3TL91OplKpf94O0p+Xtflm7AEoBUE8zLn53cGkdJeMubLywgFLj/L0At1+y7Qesci0C3uQ5yb35/+03+vIz5BLg+RlHmafyzAzDeOJ5++u5/cGiAGL5XJkHfrWHzFV5hnJ9EtzLM/O3CJO6QfEjkOBOwLPUIso8lvv3s+vwgYTWD8jlesXAS8b16ZIHf9LFfx+iQhHlhDD1lmXR6/VoNBq0Wi1arZb6fP/9/zCPer3Oz//8z1OpVEin01y5coUvf/nLfOYzn+Hg4ICvfe1r/NN/+k8ZjUasrq7ycz/3c/zKr/yK+n3DMPi93/s9fvEXf5GXXnqJeDzOL/zCLzzRs/ZPcgh75LourVZLMXeSWOt0Ogrs+n0p5GcEvO3u7iqn7KOjI65evcr6+jq2bXN8fKyktNPpVNWQi4P5zs4Ox8fHlMtltcYdHx9zcHBAMpmkVqupeZ9Kpcjn80reXSgUVBIuGAzSarWA+ZpTLpdZWlpiMBgoBlP6CkvNteM4qgVgNptV61Oz2VRqjnw+T7VaVTXwAjo8z6PVainTLkmSNptNer2eMmGr1+u89NJLaJrGZDIhFouxurrKhQsX8DyPzc1Ner0ed+/eZTgcPlGqIokikcdfvHhR1S9Lm6lYLMbi4iIHBweqr7dI9U+fPs03vvEN1tfXVf9zMeeSpIU4WIskv9PpMJ1OWV5ept/vq/IpSUxI/27DMNQaLs9AxlaAoSQ9JQkmkmfZf+UcIuGWz5K6ZWGTo9EohUJBJezk/R+Px+zv7zMYDMjlciqRIOeTuSPrk7S5jMViT0jQ5XzhcFgZxQmju7u7y6VLlxgOh2ovkySB67q02+0nEu+O4yhZuyRM2+02Dx8+pNVqKdM9kaeLA/3q6iqj0QjLskgmk2pcxBjswoULVKtVZUgoyY9qtaoc03d2dqjVapRKJWKxmDIrlENKIlqtFr1eTwHpcrlMMBhkbW0Ny7J4/PixSkDJWuVPtBUKBZLJJM1m8wdad/6440dtjZyyjMZpPGY0CWETwWSMgUuIDG3KWJwhC4TZI+IECfUnWLMpuqGR0EcElz12h1B5HfYaUY67Bs/pI9aNIbYX5chZxPI84gSZDT061TDR6SoxTOqHy4wOszwItDlYXiEamvCh0escO/By8hKN1Qxaq0b8rkdu2iWntSnZUWK9NoGgyeLgDFOWedtzGY3PEXdaBICsq1EedVkizACTOn3SNPjI2KZNmT5pWlYaz3bguI9lWNwNZjlhZfC0bZrelLGbRetHyL/eYJat0bw0b4OWDbg0tBlur0yr1+MBAypBm6kXxQwEaZgRlh72Wdl02L/4Om8tmnRfgLjewBtD7IxHKm/iXIS2B8QdTvdqXP4djQe3VznQY6zRfF9jkOYs0Fgc82BFo3Mhjq1rLP3RgHYa3i5odGIlvHIY7XBIZwAnLAs3UOfxJQPzTJqTXzzkvGUzyDoYi7B4wmV0CLspsGdQ3oPoLlh1WLejdGgzo8uy5rI+7FMb9UHT0Zw6btpj6oLe0DGWHEwdzP0g0bHFKA94LonMkNGixyBqEzqeotfA0CHoRXGnGsl2D60GVm7Odtt9iOoQDsKoAfpUwwh7jCYQcl2s2IxKGgaFeWu6SQgmng6ORnTiUNoH550AWj9LMNQiccEldm7eqs5+F9z7GiMnxRSIoOFpA2Lu+6Zti3N23duZl1qEo1N640MCLsQnCUwW2K0fcnpqsTKEfgzS4Xk9ux6etwIPtMEJQESfe80lHMgHITmAR3tB6J2i/UqPB8kpBy2DvJvkEkU0RrSTM8J2AGtyTMFpMnsL7AGknQom95g6i9TeuUJ56Rbnn59QebTDmekqcSY8Yo0DLBpUqZPh2+ToUSPJNtccnUY3xyErbGBTYEqLubIljkWLCQekOWRE8f3Si6A2ZTVkYQ5DPPbOsUuOfW0LK3oMgTQQgoCLZwwpOylS/z26l+/t7T1RfyZZdECBEtmIhL31y6EBBUJN06RWq9FoNOh2u4xGIwUgBMzLvyWz7pciC4MpjKAwkHIIQyBgVtc/6FUrMme/NNnvoCpBrYB9YTifrvUW8CbjIHJjMY0R1+en68Phg+SCgDy5Fv+m7gePAoj8AErOI8DSX2vrd4uVMRNJtIBRYe9F5iiBrjxjCSJkjKRfszxzYb0EyAnIeFpW/TTb6lcw+MGePCthViToi0QiCvgKuPUnV+RckrCQsfcnVeReRMbpZ2D9YN8/Vn4Xcz/TLXNfkjwyPsIMSsmDONP6W9v5P1fk1/46bH//brlPf/JB13XFoMrn+9kqGXM/EBdzN/l8fwJM2C8ZQ3mv/D265UvGU+asPyEmfeBFKiufI/cqdZ4/zONf/st/+X3/b3V1lVdeeeU/e4719XW++MUv/lCux/M8dnd31XogxlfBYFBJxNPptDIMk3kXiURUR4VKpcLdu3dptVoKyArDJ+7U7XZbeVjUajW1fgLqT3kWmUyGN954A0A5OKfTaS5fvkwmk8GyLC5cuEAoFOLg4IDHjx8rRdFgMKBUKpHL5dR1Sz25yLS73a6Syw4GA1VmIoy2uDiLIsK2bSVt7vV6yg1bQLeoZHq9nupQ0Wg02NjY4MKFC2xsbBCPx2m1Wuzs7Kj3udVqUalUVAJCQH+v1yOXy6mk5/r6Oro+d61OJBJcv34dy7IYjUY8fvyY4+NjwuEwZ86cUb4HwWCQn/qpn1L7mRiG+Y1C5VkBynPj4OBA7VFbW1sUCoUn9pxMJqOkybI3CdAUUJ5MJhWLqmka/X6fUCj0XZL7UCikunAUCgWi0SjtdlvJu6XmXJhgf99vf3mJgFwxAcxms6oUQUoHJKkej8fp9/tMJhMF6CVB22g0lHP6eDxWY3l8fKzKn8bjsUpqZDIZFStICzJJzE6nU/b29lTCWuaM7Ln1el29X/l8XqkUZC2W9V8Mzba2tjh16hRra2vK32V7e/uJ8hkxUSsWi5w5c4bRaKQM2+TaRO0ln23bNsViUa3VjuNw79492u22uq90Ok0mk1GO/o7jsLGxwXA45Ojo6IeyDvmPH7U1cpdlWriM8IhTwiDOET1GWoCJMabh2CS9DB/GYIVVXIo4TDBmBhmCJDhib6vLW1qcihvl0Cjj2h6n3SoVEkwpcy9gMIwbPNNb5/xDgz1Po47LkDFbgSCO18SwIVofct66QVDr8rvhUxwszaB/h3h9mWtug5dWdsjaNpapc+GcS2iicTAa8+rERHPDRLUmaf0R626QAidJ8hOkSBHTa6RjNyA5IjPR6AwL7NrniA4sxuYQtCCk0sRnFqsUGLnXmJIgyAwXD8uLEMpoZDIei30oJSGm5fG8Ii1eJm7YBK0MAa1HOdwkbidoBjSyH/cwlseszqAcgyvNEd7roL0LiU9ArDU36zoT8VgJeARdjXeDHXQ8UoEureAIa6gT02KEEg5HEYNJMgLXbSqWRnnkkXzs4ezVscMN3Is2zSuwSZ9Bps/w00ni8RGnpx7JzJjpMoxLMLHmPddTaVg056DbWYDAeTj4ww56K8EEjcemzhB33gSdGFrAIp6FzEUY3naYNQxsQ0MP27j1CE7PJXPWJMnccMw77xLcHGEeQ+gIcgEHt2CS2gRtZc52W/dgHIRCHKJDaMdAGxuYEw/LNIjZOSbJGv0s7EchhIZleVgaaIEBWVwKY4g0IljECJdaZJZhoIEFRItgFj3sWZ+QGSHupem7YyZDh9AIrLCHF4GwDo2xzszQiboxxoSJkcKgwHGvyuRdi+UluH8SZtl5S7tsZm7G5oYhOoXJAKwQ5G2IVWHv94P0t89g4pEaL3E4Xmc32+bInhAeaESpEwu69DPLVI9nTK0I4Zsjhm8ECbYvoAEFdALWc2y9UuXUpWPWvRkFMmTYI8AhMdZIssgOQRaBFzFJ4nIGnSEmVdqEiXJHS3JTj3DdMTFJc0SJtwgQYsAV4hgMMLQ6rgH3zQh7LNMlyiw0g3Aa7AxMOuCOCOASY5Ua5vddV/6448cadN+/f/+7zK9kgxEg469rFsZVwK8EHL1ej+l0yvHxMc1mk+FwqCRXEsj4WSORaAszKDI0v7zY/yWgIJlMqnZY0jLGsixldCPXI4GUuM8KyBfXUtlQBSyK5FhAjAAWAWp+JkKCKD/A84NpvwTaD0b9bK8fJMmYyP8LaywgSYzihM2Qfr0SeH2/emMB535THAGUkuQQxsEP/vwmWQI6/cysX7Ug5/Ibp/l/VgCzSDclMI5EIk+oA0Si7wfK/rpvqUWUGnZJ+sjzkWcm4+tneuV8/npoPxsvYyMgQ8ZGGF9hWvxmQiIb9H+evEfC/sv9iceBjK2UOgAKWEtwKyZw8n3/3PLXevtVFzL28nxFDuxP4vgd7f0u/cJMSYJGxkZqhDudjgrC/XX5TyeK/qweu7u7ag75kxjpdFolMsRdWn5OSjRknfI8j+XlZdV2UMBdLBZTpomOM28NJu3tpERBwM7S0hKTyYRarabYaj9Duri4qObBqVOn1DMUMC1KjHK5zNraGqlUilarxc2bNymXy5w5c0bNM5GY7u7uMhqNyGazyhBOrtnz5rXZ8u4OBgP29/fV+z4ej0kmkywuLrK+vk4sFmN7e5vV1VVSqRSZTIZsNkuv1+P4+FiVAfkVFCK9Fvf2WCzGyZMnuX37tkqoirt7uVxWYD6bzbK8vMy7777Lt771LXq9HtFolGazySc/+UlM0ySfz5NMJqlWq4TDYer1OtVqVfW8BigWi8qRW97F4XCo9jqRpcsaKzXxIsWWll7+Wm9J3AhLDPN2TaIaWFlZIZ1Ok0wm1bgISB+PxwpwdzqdJ5Rfso6J74bIs/0eEZKA9SeQpRe8yL11fd5rXvYVmc8CnoUFFym8n4EX4zEx+pQEgUjq5fobjQb37t1je3tbvT/S0kvc7CV54brzOnxN03jw4AHNZpMrV67gOA7RaFStSdlsln6/r1rVwby3ejabpd1us7W1RSQSYWlpiQcPHvCtb32L5eVlNjc3aTabvP322wCsrKyoRO9kMlEtKcUwTub6eDzm8PAQ27ZZWVlRCQG5P1HAyB75Z/n43av7BHouWguyA5MELh0CdEoZvHgU49AmOhthoXGWRQJ4jLDpoBEhRIgr7DgaDcNkHGjhrBgwmFKpRzkgTSM0wYqPSVoOCSzq7iI3NejTxtMjmIth9EGD1e4S3mTMMNrhNS/KcUjH8zpo/TCn7BFnkvvYtoPb1zl1ycV+Fuoxj+Sz2xS+dEx+b4OA1yEZmLDqniXIR2ky4J3Ua5Sv3+V0doa+P++rHB5V0A4tGpMMj6YeQX2V4ijJRc8hwxgTHZ0+eVx0okzIEn67yplTMxZzMIp6TMKPSE5sFsOwvuQQ6wzYHjmsWRpJHTInPKJL0BhA7g0IuhBZh/EjaPXmzO+kO5ckXxuAZQDPeFxN9NCP+8SyHsYQBgcVAnmP9FmHXAz6jRaDTBFrOcypb0/pfBn6FQgbGoefhbc+Bf0lSGlwNTkgWIWTHtSnOseOSwFIHULNA60I+QQsLL/fKzsCw7hFrwUzYkyMGZmQS9RrM9ES0PNwtHnbrGgKItUMMzOKHq2A4RKZhdCrJuPEHFCbzQBuzqYYgEkExpdHRK/Cbg56STj3CPIVSBZhPIRxZZ7/mIVcutMIrlvAJY+uN8jaDttOkEk4CDMTLW7j6Rq2BeiABwZj7IzLaBGCeYgk5o76gQ2IB11mOzraNE6eGZYVw9SmeNMJZgYCJQjtxfCsLDFcBgQZUCTGjLBhM9qf9/a+lIJ9fS6Nt9uQ0CGQAoy5QZunQ+sQHv8WPH57Hds9jcceU3pYaKSHSRJeghFp1lnmubbLzd4Rx3qU/+Se44XuDa4HPRyviM11LDpEaZPtJem/maUxu8Q+KzzDhLM8Jk+SJc4R4y6bdCmQ5wbLPKTLJaacJkqFHPvaHcIBDcdZ5YAiXQwMJpwkSJ4+cR4Sp8t4BD1nlfvE2Ykd4AQtSK+AbYJhQMRG65ncpU+jNIban3zN+bEG3ZVK5bvYSWHzJKj2g0kBDAJ6JECSjdMvoxVA5a+nFrApknCpHxQw7JcE+4GGyH0FKEuw76/hFubT8zzF6Mm55JBMtsj2JBAR0O+X+/nBkMja/FJlYRz9Zin+BIVf0i3jK4AF+C52XQKzWCz2BGsmjLSAZ//5BMj5gaowHsLsy7UKoytjJFJC+CCA95vp+IGkBHX+OSH36HcC9wMxAecih8/lciQSCdX/WYzOBIg83Utb7ltqj4XxEtAtTIMErxKAyfN+mtH2qzn8Y+YH33IP/rkngaf0H4YPFAHyvPwMsDDcfgM5GQuZq3Id8IHsWySl8j75He79CQR/8gZ44p2S+/Lfi78UQZI5ohrwz1O5lqel9/7P/F5//7N8CICRBIS0GEqn00+0dBIjJn8ttZTjSLnKdDql0WiQSqWwbZv9/X329/dxHIfV1VUWFhaoVCpqDsj7AfM5vb29zdLSkgJiwWCQg4MDstks9Xqd27dvE4vF+PSnP02pVGJzc5Pl5WXS6TTValUxqsLYBgIBfvqnf1rVrdbrdcXgh0Ihzp8/r1p2CSgU47XBYKBAqOwVUosrLK2oc2Q9W19fV5LdS5cuEQgE2N3dVfW3/iSjSOGHwyELCwtqDRDwPxqNnmhLlUgkWFxcVIorcRLvdrvs7u6qtlbSL1o8CqTl4WQyoVKpKMlxLpdTcnmZ6zIuuq6r5Mjm5iZ7e3sUi0Vc11U+F1LWJMkHeb+k5t9fbiTv+kc+8hFWVlYUq+1583rwYrGoSlQODg5U5w65Lmk/trCwoPZUaXEnMnBptWUYBrlcDsMw1Hz2Jx2F8RY/EUmuC1CHueJCVGcAJ0+eVC3qotEotVqN1dVVtUYJmy17p/Ryl7Vbxtm2bQVwJbEgyaq9vT2SySS3bt1SHiuWZSkPBPkd8REQlj+VSjEejzl//jzBYJBvfOMbSsVx+/ZtpRI5f/485XJZuffPZjNWV1dV9wpAMeHdbpdWq6W6BcjaLeVd4iFTq9XI5/P/Vder/xaHtzDAyuYgNKBhduhpfexAFy+VhuRJHC/LaDbikRdn29bRrTHBkcO6OQNCPAZa+hQzas6bdusNuJ6gecMl3TrATuyheQ7nh8uESHKDHl1M8ri0wyMI9HDNEIfhADH7MSfsODXvHHapCAsBAt0dVvN3qU9dfqd7jpNWj7+wX6N03aHwSViqQ/bbJjWG9FlDt07RZIlJeIfUJ36fj/1PY9yshzsE8w8gdBfGGoSMIFedddKexcxxiGfeAxoEenk2PI8BY1xiDEkQIIP3YIXg/7ZDfN0lYIJ15Zh0vU4k6uL9JGxmTRLbYG7DJNbnmY9BeQD1l2H4qoGjBQium4R6EIp5JIZQM2E6hHIS7CwcFCC/AR96zWNsgXYdUtqM9BTurIOzOO8fjZlmbNgM21P6Rzo70wAJXcPbnbdr+/aqxsmWx3M1yPXBfACT3llqd/oktCPsEtw9DzsrYA1BPwXLbbC/AeGjMDoOPWCmweYEzux1eG9hhuHOGI/n172RgFhoyHgSJzkpoNGF5Ag7DZMUBMYageNVvOMMQ+OI6pk6Rz8VoL8awyxE8CImA3fIR1I2awY4DRhacPAYZrMENjEGlImQxnHDjONjtIILU3uewYiCNoORAaMcbMRnZIY6Rh5yy6DHoDOB7gTcEJhTHWtWwCFHGI0ZJgNjTNgAvQ/DkUbQjQFphnQIoBEgB9o2Jws2Y8A4hnNT0C+BdQGizFuMuQPQZ7ASmJc9W0GYdIJYtofHbVYJMcJkgMkZK8YFhgzoMgn1OW2vc+hEeLC4y76WojMsEju7T+b4W9zbL7LLKTZpc8FbYjZb4yER9hjgcIIX9Puk4q8yHgR4jmNCbPN7+gneWolgR8a8W+2xODPJzIp8yrVZnGXocIE+I07wJh+iRRqDKGM86oSMEdY0ScNbY8foMYkO5hbyIxsyHmSiMJ0xisWZjB2YVX6gNefHGnTfunXrCXZY13UlJfezzv6aa790TQ5/yzAxA5PMtvyubNowDz5EMiaAVgC0ACy/+7KADjE2k76b/l6qfsdqYUSFLRK2VECsAGh/32oBzH6nb7kHv5GcuAxL1l+AoGTIBQRJ7fhkMlFATq7DbyQmhzAOsVhMMVR+kyb4oB+6vwZZ6gOFLVpYWCAcDpNKpRRbL5I+v3zaLy2We/Ib8Ah7KoZR/j7VAu4FtMp4+UG5gLqFhQVVpynySulzPBgMFHMnAPxpE7xEIqGYsWw2SyaTUfJo8Q+QsfEnNQR4CuCReSnP18/Y+oGmMFf+JI7fjbxer5NMJlXPVun1K/NKHHQlqPQzzSLZlMBOkjIyjgICBDg8zSrLOyjy8qcTJQLU5R6F/QJUeYgkCvyt6uQz5PeEyZPx8M9VuZb/HkB3r9cjGAxSKpVUsmdjY0OBGAGZ/sSRvGu6rlOpVBTAkuSjmCa2Wi1V37u/v6/8GuQ5C9trGIZiPc+ePUu73VbPKpvNcvLkSb797W+TSqWo1Wp8/etf5+Mf/7hSqMg6IXXboVCIkydP8slPfpJEIqGAtaynUje9tLSkGEuZ435AJgab4pwt4C0SiSjpurB9n/rUp3j22Wc5OjpSxm43b95UfgGBQEAZzMk6KmzwbDajVCopACTv2crKCpPJREnsA4EAOzs72LbN2tqa6q+8vLxMu90mFoupuvC1tTUikQhHR0dqLRDVhyRO7t27x8LCAgsLCxwcHChJuJhcxmIxZrMZ29vbSkotCZina8F7vZ5KGkjiTWqN2+02Z86c4aWXXlIJDpj3Yq5UKqqVVTQaVS3IxuOx2nM8z1PzSFQTohCQFnYyv0QBISy4uKFLD3jP81SbLekJL90fZJ+WOmyp95b3olKpKA+CUqnEpUuXWFxc5MKFC6qNqJgK+tvllctlRqMRW1tbar+RdpiSxDBNk2azSaFQ4PDwUPVtF98DUeRIzb6sq6VSSe1F8m6KsiGVSqkk2sWLF8nlciSTSQaDASsrK2oPhnkdtZQ8tFotQqEQxWJRJQckBpEki7D9/z0w3eyPYVOHK0XcbJSp7kE2C+kixBMQTuLV4rBtYJtTiMwwBx6zrSllW0engu5oc71y1oaIAUaI8YbH1G3jZRIQ6rM9OuDQPEdNi+MFNdp5DStWJdwfMJuVcbLHRPsGZ8yPMDECYAXI35pyIbzP2edmfO2NLL2FMu8wI7ZV4lO/M2Ij1WO8CPaCxzjXpt4zsIwxwbPf5PxHalz6Hy2CSZhVoR8F+8W5wdXwW2BbF8lxmRg3aJffYvELY0K7EHx5BdOOMaBLEBuTHjMMwt4U5whmxwkiuSnpj9qkV2wsD97cgIcfhmIf9ENoxzxudeDg3xr03irSHOuEvDS5Oy4pBkQidfRti4UVOIrAzUWYlaCehFQYimGImpBbheAUDjtwJx+iYQRZ2B6BXWG8ZvDIhBPWEkt4tCMVTg0h/i3YuepRW4M/jMCFHVivBMENEbENwq5GN+nRGkL6HvSL8HtlODmBa3GI56Y0BhNmtk7ccUnuQCbtEcqMSAegNISlOGTK0GvPCFbqhMeL9DSTyOKM5FnQUqCXPWrfqRGrF6kGkjz4UJPRh0ugZWDSB8Icnwvz1VSHs02TZ3QoWGA2oNsJ0iKHR5SkNqCZmtFIgjkJwNhGd108G8IBDz0ClRQspRzizRnOELqPQM/OW5GFBjDtw6iSJOZt4OJQxcLUGsSicyn8oKEx6hUYeTksdMbkMQlh0kOL1YgWPcIFqNyFwbdSbH0zQPbFNhdPgXYRuAzhHmgtCITnkvb/H3l/GitZdp7ngs/esSNixzxHnDjzkHNWVWYNLA5FSiRF0qRIW7LlVrdloHHtBowGDF+7DRiGAfuHf1mA/aPdNmC4+wLXFw3odsMt2ZZoiWRJLJGUOFVlVWVVzifPPEScODHPscf+EfpW7Twq3dtkQ+5maQOBk3lOxI6911p7rfV+3/u+X+WajVPfQwt5VJJRRkDrJEvYX8At/BHZrRnFzRnWO2nCj18lNLBxtSbOZI3jeotMpc/Z0Y/Z8ws0NGj7FSz6nGjbdKI5Hsw2qVKi6nXRiBAnwlSbcG5ksTQXZvv01mIMrIdUdydctV8jS44yGSbssBH9IzKajT810dBp4ON7Gg2vzA5FNNcj3y4z9GdY0Q4sRsFMwSSFV9XxGzqhcQaPzk885fxMg27ZcMAHpa4E4F4E3fKe4GZbfkpWLJiNu7gpD2qbg5nFoAY3uMEPao5FTyoLtYAZMdERjbQAJ9m0BvXZAiyCwEWoxBfBgwBbAUYCzGSjcVGHLouutJlkMSULG8xmX2wbyS4Gqedy30FAKJvaYHtLdkI+K1lcyYzLuUQmIO+Rcwk4CLrByqbnYsY+mBmWPpK2/LDxEWznoJY46EguLAoBCPK9cr2ysZSAjFyPgE25XmE6yBFstz/rFWQ0XJQzXBzDMq4ERAQpxyJjkAxHMBMdZD5IOwTHv4yXIF0/OCY+7AgGbIJ0fwnmxGIx9XcxaAsGI+RvF8ee3KcEAWR8Bvsq2P9/EUD31atXFRgTJ3KpX97r9YBn3eRljCwuLpLL5RiPxyq4MZlMnmGXSHZcxr2mac9k1jqdjspU6rpOpVJhZ2dHBeAWFhZUiZ9OZ75wSQBNjKA+97nPcenSJTY3N1XWXjLQtVqNN954Q40d13UpFotkMhmePHmiSiRtbm6i6zr7+/u0222VWbVtm/39fXzfV1rf5eVlRU++e/cu/X5fXdNzzz3H5uYmlmVx//59JpOJmktFuyy+DxJYXV5eVm1vWRaZTIatrS0SiYTK1C4vLxOLxfj93/99jo6O6Ha7vP/++6q9L1++rM4tjIWbN2+yvLxMp9Ph/Pxc1WLWNI2joyPOzs4wTZPV1VVlOCfsgna7zeLiItVqVdVulnVG5CuyJmWzWbrdrnq2zs/PCYfDyjVesqevvvoqkUhEZW1lbtjY2GBlZYXz83NOT08plUpKR1wsFpU5mtRKD861cg1Bg01hMkjADubPsYBSkZXIsy2gUsZIu91Wa4tlWZTLZRUs6vf7HB4eqv49OjoimUzy8Y9/nOeee06tM6lUSoHuVqtFtVplOBzy6NEjVSrtpZde4unTp5ycnBCNRlVbS112KWN49+5dQqGQOkdwz5BKpRgOh6pSQCaTYXV1lVarxfHxsXp2q9UqvV5PBVHFc2F3d5dOp0M6nWZxcVGxQUqlkgq+1Ot1NbdLW3c6HSVBkn3AR/p4LQYJB6KzeR2ovRSGFidsd9Fqh4THWWLHEGlaFN0Zuj5lJ5Ngv7LFQSeHq4/xcxEIx4EJet2k/NhnGprRrSTmemA/RjMXYuVM4zN+jMdelFpOh9ExMy8OhRSUPJrLFb5zf0LROeUTzQOWvBSXrrTRElCP+Pi5Ou5sQoerNOpxen/8Op/6P9lc+u99NvfGTCMHhLOQKkE/CY9qMPiPkNzTiJR9XBNKlyGZh8feDxkfPWIhds7mp2dowMH9KG0nxYw8CTxs6mwTxyGKrU+J+Vk2vCKF9B7WDO6+GaM/TdJqdAhHHXrPw2QTsMH9ATjvXmE4ukmNOoXQmGj2nARtwhUH77m5w3Y2B6cmjIZQsiCahuQWTJLwXzs6434IbcmlESuQ/MaYa78bo2lFGF/rU2oYRMJhriRaDA2PxE4Yo+NSWvMY3tQ4WM4yOR+w4BuY4QOqN3toaZ/WW1A4D2HmPJJXfA424WADnv9FWF/w6bwJizOPagoOHNjx5iWxkg6kpxBx5yXijAokrk8ZvFnHb5g4XY3mj0OE0z7ZFZdZYkaEBu10i9EnsvNaWyfnkJgSm7gUtSmzTY3HKyHcc5eNBCzoMOtPSLYyVPGo5O7jfdLlqAhhx8YP+0R1mIbB1+bma9MU9Jc87KMZ4fM5kyFWgJAB7IB/AtFZhBkWPcYMcPD9EH4IZovQiWjo3SpRinQ4RSeBSwyLOgvFDuaNuWY7fBBjt3eVg16evaMGdaNFamXIwv++Q+VjPp4O6TDEc6Bvgvv7IVoxneprM0ZTeNyqU5yso63OuPzfzdh/DG3HZxGPfr/KuT5gzTVZOE0w7EwZ+Tomdyn5IaCKxZChoeOUwnROdSbuF2mOPkaKFRy9QSYKW9M0Jx2DSSYHgzThdoGhvcIdYJljLtFjxiktK80OSc5YoIDGMkMsd0KdF5iwxSYzpn6TJ9SxjPC8MSMTSPvg9vFXwzgu8OAnn3J+pkG3ZPAARUUVSplEsS9mBIOZ5+AG/c/ahAc/F/y/gD/Z6AvYkmyMlBa5mDUW6qZpmsqkR8CcnDuoT5bAQhCsyGZW7lXTNJUNdRxHuacPBgMFXAWYBk3OhCotTrkCsMSFWLLLQVqugO8g7VtAprR/UN8o2QXR48mmWzZyQcAutP6gmZuUvYrFYupcosucTCZkMhngA9OzoPY3l8upGqjwQTBC7kGuObi5kOuRv8XjcdXWEgCQzSmg+iJIC4c5uJQseTabJZ1Oq5JpQT2rjFGhXcoYkKBCkEIq/SvjTfpRAi9Bg7sg9VyyJNK+cn+ijU2lUqytramss1C5hSYqgQVxqJbzy5gVszl5FoNsCbnWILskCITFVDCZTCrKuxgXTadTpdeWvpGXZNyDz7cwPyR4IEEReU7lHBcDMB/Vw/d9Dg8PmU6nz9QS3traUv4S6+vrSjaRTCZ58803eeeddzg6OlJ9OJlMyOfzlEolDMNQOnnbthUIy2azlMtlJpMJzWZTBfSy2azKmjUaDarVKl/96lfVWBTjtmCN4Z2dHb7whS8oALy0tKTmCtd1aTQa6pmIRqMcHh4C8xKSly5d4rOf/azSx5qmqTSqEmgQgHh8fIxpmozHY3K5nJp779+/z+HhIQsLC2SzWeXiLCabYg65s7NDNBqlWCxy9epVRcuW+dyyLPb29mg2m5TLZR48eEC/32dpaYkvfOELCvR1u11FoZf66GKoJUG54+NjtSZ0u12VHe92u6pWuui1AWU8J+NfanYLMJM5X74vGFyTOU0CcgL2YQ4Gz8/PgQ/kSKVSSYHz8XjMu+++SzKZVJrjbrergj2u67K6ukqv18OyLG7evEm1WlVlrmTeleofYoAnPgKiuQ/OA/Ls9/t9Wq2WYpWJl4bMA8KacV1XsTwkmBGLxVRZuUKhoEwHv/nNb7K/v8/nP/95FUSVDLquz0uwvffee5yenqrya+PxmEePHin6uzCcQqEQa2tryl1eAmGGYVCpVJSbvAQ+CoWC+q58Pq8c5wU4b25uKlZYJpPh7t27ymxQghBnZ2fEYjHlQxNMFui6rvw9pMSeruuKOSBr60f7iMH+AAan0MtiPHG4PWnxEjYZJhjAOjmSePOXq/HjZoPfjXica1nMaRfL8TkMR3CdEulJkSIGZ9EBJCbg2dAxiYwyrJDhFjnyjs07DzoMyNLJd3FXUpAK4flTDtNDljoDfjk2ZRqaYiV9PA8iKRdME6x1js0l7lj3+N980iFWgnMLyi/NnbgPDei70G3AaALWYx37j69wGPbx8Rmsn7HxN3p89q8MGXxriJ0AcwM6D8DuuPQ4AAwiOBxrbR77ISYMsfIJ4pMsSyMffeLzYAcOOyYLzhZL3x+ysXifqxs+PxpBtwvrJ9DXa5ytdlgJTSisjMh/xiHbhfwETm7ADyOwasHCHUgcQXkVzmtw1jCxbk3RfgnGZZ2RaRDrDVjaGzJobDDzb7L6w0Myl99n9tf3SPfBeQuO2wlmbegedOGmDwWXXiRM1zMomVPK1316u2DVwbB1xocJSkdZPvFmj8EXejRuQ/gG+BGY9GC7Ag9KOuOiT97157grDNEIYEJiAOPboEcn8J8SdM6zoI9ItT3OR0ArQYgY3YoFxTh0xxh+j+p4xur34WYIki/BdgtCXciFYWyAO4twnQidxC47nxhy8iJ4C5CJethjcEMQCoNpQWIIFQeqa2D4kKhAuDsv/+VOwamB1QPfN5nh0mdEGxuXKOOxS9QcE9vwCe2A4SeI4AEeMYbEQy0SCz6JDAwfgHlepEiEPhq+u0LPzdF9GqL9rw7p/9Jjtn4ZtBgkojBZh0E0jN7R6PzI471RmJrfYos6XruEd37M7hsp3tl5gYhmUfJzXHET5LRdVheajHydSU9nZgzxHZMqGhk04o7H4fmAsOewi8lNrpEljOO7FFIeL7lvofXj1CZdNGeZmH+TECbPoVFgyLuc0CLLiv81ehi8iUcRmy+j4QEdMiRxCONwhAfo4P1J6cTmLvNfRQiPDrCjyZ9qxvmZBt1BwH1R2xo0CQvqqOVzQbq5nCNosnURgF8EM0Eg+r/2CmbZRGMbzNoGwdaHXXuQEi8Z0SBg0DRNbUAkwx10cw8yAIKZ3g/LzkvWVsBoEEzKe+R8wQBEEGwGM7HBwIRk0oJ9J20uG7iLWc1gtlUAmLRn8JwXtfTBDWQQZAUDKEH5gLALLo6R4N+kfwAFGuR+ZGMXzLgLdV+CARfBp7SrfD74O7nm4E+5rotjK+hbEAwoyLkkkCBjI9ifvV5PbZYlyyLtJ5ksCdYEs9oXryHYp8E2/LD3BrPxF69XKLjBsXsRdAuADpr9SOZenqmLffkXgip54dje3ubo6Ih4PE46nabRaKjs3SuvvKKqGziOQ6PRYDabcfv2bZ577jkFGAAODw/Z29tTOmgxkRR2DMwBr1CXhQabTCZV9qzT6ShDKqHUWpZFKpViaWmJp0+fsr6+rq5FnKnPzs54+vQpd+7cwbZtLl26RCQSUfrhBw/moWaZH3Z2dp6ZLzzPo9frKSC1vb2ttL+xWIx+v68y+CcnJ3Q6HXZ2dp4x+ZKgkEgXxIzuq1/9qhqLhUKBVqulvtdxHB4/fszh4SEHBwfKSDGRSFCv1/n6179OLBYjk8mo4PHZ2Rnj8ZhSqUSlUmFtbU2VehPn83q9TqPRYGlpiclkogKTmUwGTZtLSIQaPp1OFejc3t7mypUrXL9+XckE5NkWeQ2ggp8CbiXTKsBwcXGR/f19FVhdXV1VRmaTyYQf//jHqq627/tK2y705VKppII4r732mgKjQYaN6P4lYFgsFtVY6na7ShIgJeA6nY5azyTwO51OlSmd0Mur1Sr7+/tomkY2myWTyRAOh5WRaaFQUO3huq4ypzs+PlYaZ8uyqFQqrK+vK58MTdO4ceOGcnCXsnJSrs5xHLa2trhx44YKkiaTSRVUOD4+5urVq7z66qsqUy/3lU6nqVQqGIbBjRs3uH79ujKCkwC7bdvcuXOHWq3G5cuXyefzig4v8qpms6naWQK4sh6KrEj6XoIQuVzuv/WU9d/+eKOD1jrGj8fQKj0o1WnWS2Ssl/kkY6Z0sakyxWPAmDQ+L9LieatGj208dPwpHMyG7PhbHJHhrfCM3tUelI5h5sKsiNaAA0ac08JghoNHhii2laSX0qDXhKbLNOsy7kUYnH+ejjbBbjZJVY95Ljyg86DFYPUa3Rcn1LbrxC2f2RAeduGdd+Hhf04wDWtc2hoSiUP2RXBf8Xn6rkZ3cIs4YSKP+xz8X76HUekQHoFxDXoL0LkLBddkiMl9hsCUmJ+miMERA4rtCAl/xO7WIY2Iw+GTDEQmaN5DXErcGMBz7XmmdicMP3wOZltdPrUCvgWODl4JjBNI7kJJh1wEnLfh/Btw0NQ4ymjEhykSsy0S7zf5xJNzTq9NOKxAdjI/9/10je44TtWZZ6K1azBpQOkIpk2LvlXCu9cn9IpHc8lGm/l42QHxdUivg3YPxrZGJ6Jh2HmmuCQHHsU3dLZnHq9/AqxPQicE46iB6ybR/QnJ2YycDQUfyi6caRCbgL0DtWvgLjpEzlJUXuywGIL9XUjYMTRs7C0XkhP0qcfKZMal39PRv1XhtHTGixOPlfdg9CCKlgTLdigNTUbpuzz4lR57Pz9npLsh8HyNhOajhyAfgnQSHA/yh3P2c/YXILEKgzswewTRMfgpGLjQmaTQiOPRxcAhSYgpMXLRMUsDjREpRoyporHHBJ0a2VKfyMugh+YxqYEbpcgS0MXimA5wjEW5v8rwd0b4Lx/jFGFiQekKrH16zPSPoN+IoM3iXGdEXjvEq0H/96DfsWnmhtgxl37X4efGC9z2F9CGp4RTbdZo0jBX2PMsiuNd1tnhs7QYTOcVB94K9bHcc5I8YCH3NkYOnos1uNnRGPZTDDlnxmN6VHFJ811cHmDxMgnymDg4VIhQIM6UIhN0YoyoonGfKV0mgIc2cvHPHLDi4IfQ4m2MsYMdyQLtn3jK+ZkG3fF4XFGVg1payWgGta8CJGTDIcAoqH0V8CqZXPlcEPgEwaYALE3TnjF3gmcz5HIN8v+g42kQIPT7feUiK4BDqJsXabkXX7KxHQwGtNtttZkWbVzQ5E0Aj2y0xuOxqqEqGXEpRxME70HwL+cQ/az8XzKVAq5c11UbbMl0CICTTHtQnytgT8CYZJgLhYKikUr2R7LOUqNW3ivlYOSnBBwEKAuYCIJV0SsHXcTl76J5leyEZPkkyxKk64dCIcVgKJfLJBIJRXuV6wludkR7HAwWSHvLOIIPjNmkjeT/0q9Boz8ZJ7LJkuyX6Hbl+RDtdjqdVlmhfD6vSgBJCZ5geTx5Xi5+hzAqggA3GIARGYNoXoPBpmCWTTSNUstWNJFB4ysBAfJ8X2SwyGcEVAQDFsHrDgY6PopHKBRieXlZBVXkufnud7/LvXv3lH5TzKLEj+LatWusrq6Sy+VYXFzk5s2b3L17l93dXfb39xXtWpgKo9GIWq2mWDGlUolQKKScw4UePZvNKJfLjEYjTk5OFBV5ZWWFdrvN4eEh7Xab8/Nzvv71r9Ptdrly5YrS204mE773ve8xm81YXl5W2VsJAEhQQTKaks2cTCZYlsXp6amqUy3SHsn+VqtVbt++TbvdZjQaKY2zPPP37t0jl8sRj8e5fPmymj8FIHW7XRXUKhaLwNy0S5gt4/FYzWHNZpOHDx/iOI4yGguHw7z44otKc5tOpzk4OKBaraJpmjLQunnzJrquq5rQV65cIZ/PA3B8fMxoNFIlDSWL3mw2SafT2LZNsVhU1ynPXlDiEpSkaNrczbxYLCrmwOHhIa1Wi2KxyHQ6ZWNjg2w2y8HBAQ8ePODx48e0222SySRHR0domqb6Ix6PK0f8F154geXlZRzHUdcv873ML0InF4AYZHcF5Ury/EsAQtpAssrByhLpdFqZ2GUyGTUXSyZf1+fmmUG3dE3TODk5YX19XQH+zc1NZUh36dIlRqMRZ2dnSgN/cnKi5lrDmJcmK5fLSnu+ubnJkydPyOVyKuicy+VIJpOcnJxwfn7OYDBgfX1dyRry+bzKQIsM51vf+pYKiEn7iBu6yCaC12GapvLtkH2O7APEv0V+H/Sx+cgenoF/dQEi5ySmT7BN2K8U+B+be3xvEiJMmpOkxmxhhGtMCdtR1o8SfN4qs8WIHBMWjQE30bnraGxj03U93vaa+KFzcIvgRJnFRpxOa8TcETMdfK2I6YeYLcUgO4bJGaQrhAceVTfFkC3e8fvgXGX9uMFq5D0uWwbvhHfxl3rUZz6//T8t8OlGna3Pw/d/qDF4cp2JP+E7D2t0onD9j12WVsZ4Lz8h/KZLcvQxGnRItbV5heEt8G+Ak4RxI4xjXeEpBg/pEGdKgTQWYTz6VL0Iy9EeS79s0+lp9J+u404SuBzhZg7pVX1+fwbLSciZEL8+p2SPLRgA6TYUd8EyYJSFpAFLPnROwWxr6PiM21EKhkX08n3qlsnBvSThBxYrfpqxnaOv1flEdEyz+oB4I0b2/TKNYpPGay7lVyExnWJ1znh52WPowH7bxku5aF+BShTsDJxegkEdzGYWlxAx7YSODs5YpzD1eGRpHBZ0EraHOQPNG2OEXYoGXHUgFgKtA6FjcOKQaYLfhv6NHovNKPZRksP0mHY7QdHTmMVO0ZdcyGoYhw6l+zB8y6A7MUhO4egMdB2idgyaEI/2SYXazC7b8DEfbVkj44CXZ15KTQPXhIgPFqAbkDoD+13oDyCeBjMB+hK4OZgNgSfgNnv4voZOh4RmMYpA5KUxaysw/Hoe28/gcYRPm2y8TzE8I7QMkSVwB/Na4h0/AsTQOSaOR4g1HJpMGDDthZg+Ae0KDCwwDdj8NPR9sBoWW8c2o9oGZ2SIWjX676TYi9vYyX1wQnSWVvherYcxvMpye4VE511uMqU2CtHWy4SZEMIhh0GSIWMe00uGeM9pcnt8j03HwToNkUt7JDZ9Jo0BMXsA1gHf7F3hTa5QR8cmRQabPCE66MAMDZ0WGhMcypg4hKlTY8K8aoHvOWjHFhoaIX+KHTaZxAvQCP1UU87PNOgWsBHMdAtoCm7+L2b+gkAmmKH8sEzkxaxkMMMdNFiTMkYCKOGDUloXs5ZBzXRQNy2gUK5PsswXs/JB8CuH0JEvmoIFQX9QBxykiweDFn/WZ+S7JBstbR/UQ8tGTSjMgNocBcu6BbX2AsQkIxP8vuB9yvtEvxds06DTtlxbUMsdzIzKNch75fuC1OqLLxkfci/j8fhPaauD3ysmb6ZpqjFxcVxIm0tWJTimgoyLi9pquedg0Ej6QoIVwXNdDBgFv1tAv7jeyngTxoNkx6UN5X4vZriD1xrUCMv5Lv4tmH0PPhOyQQ8Gf4I6dBnXMoblMxcDYRf9GT7skO/+KB+3b9+m0+nw+PFjFbgQKrXMPcJ0kPaUeu6ifxW381KpxMrKCvv7+zSbTfL5PNPplHQ6rSjn8szJ2KpWq5ydnSlzLSkPVq/XVaCwVCqRzWZZXV2lVqvRarVUYOfJkydKPyslx2KxmKql3O12lWO3GL1J/WuZz2UMCYCWexLnaTHnq1QqlMtlTNOk3Z5Hr23bVvrvp0+fcvnyZZXhFTqzmFlJhnBjY0OxhQqFgtI29/t9HMdhbW2Nz3zmM1iWxd27d9nZ2VGZ90KhwMbGBtvb23Q6HWXctba2pujj8kxJ4On27dsMh0Pq9bpysj46OqLdbqv55+TkhFdffZV8Pq8A93A4VOwGkeGI4WQul1NGaZPJhI2NDe7evavA2+rqKtlsluPjY1VyqtfrcXBwoMZZIpFQIFe0/tIH8tnV1dVnfE1krpN5ut1uc3x8rPpoPB4/wxiTa5V5UXTpsViMtbW1ZyQ5lmVhmia3bt1SBqLC9JHvk7rsqVRK/V6eGQHiYlYq7SUBEwn26vrczFUCCYPBQNHYT05OVPnMeDzOjRs3lIQgHo+rTH2lUmF3d1f5Kty5cwfP87hx4wbVahWYr/e1Wo3t7W1gTvu3bZtut0u73abX66lgtMyLlmXR7/dpNBoAis0QrDYhkgIpqfdRP7TJbSq1Dp424jyRxfccsEc0MwUcL07UinFWPUVf3wW/h6/HONY2ON69xJe8FRIc03UOqaBTxmCdR1zzfO4OxzizEuHDKLm6ydAP4/t9UhhYUQ3XsBlnWrDShbM09BfAilJqzVjMHlIfRNlxLuMwYOovszW7zhaPqDXu0rD6ZCYhmF3i6ZsjFj4+wHagg869Yh87U8LvlXGOIsyONZZL77KQ3MOZmuiuz4gwZ8MiRnPEWnNCYgxePUIPiGCxgEEXjz1TI2wtsOYlSMXuUblpc8OF/rmP7nXxyOCSJqE1cLvw1j7sX4FPmvDzRzDdg/4xdLMwHkDtic4g47P+ok/VgWIUZusQSftseNA3pthxKH0FYlszsMB/F3rv9tAGY8yOSz4G6ys+2z3o9IrEGh2MrMvjNQhf9nC6U0YGPI3AcBYiHPZ4+Emfy03I/AhmS5D43/mk3jmn3WgS26kSda7QXvxjbnwGjss+Y9vlhRmkhg7dBuhjWEvDmgE9D0JJyE2grs2p1KtH0HvBZ7/T4/Kbr+DUB6z4FlltwnvrdaZrYbDDhHoD/Ifgtlw8GiQmHliQzEA60sfMeAwXwa1ZFEewsgfjNZ9IAtAgHp6X5PIN8CcwdmCtBZEfgnXXIDJxGC+BHwJPAy8HYWPOKAhrQzzfwMk1mW55mEuwvAaT70eYnF3FIYSFgxka8UJ2hvk8aK9C9BhGb4Rxah6OP6TFHgmipFimyYgJYRx0nHKPcBUiIdAMGLuQvgHmDKbfgEjIJxyySLhJNDzMWYqIUYZSH/pT9PMU1izJNi0cSqT9TxOjyUt+giM3zzVcimTx/B5hjlnjlFf6eZ6wzEP/C9T7c/38q8MGi7MjSE6Y9dKcjiv8kALvhXSW3BQGNnU8mpQ5pk+fM1LEOcMDfKJ4nNGhSWPuYB+KgNlEm4wwXAs35KFbcWKzKFM9hcv2Tzzn/EyD7nQ6rQCdRLTFvVYAEHxQ11k0YeIeLlpc+b1QDqfTqdICS31PAWuyqQhmU0RXFY/H1WbWtu1n6t+6rqsWNvjAXTsYTR6NRkrrJhF1cbuWzclFoCCZ/n6/rxbPICiSdpBzCOVMNseyWRkOh+rcsnkRSqNotkOheckWAZS+7xOLxZTru1DjZHMlgDKowfN9/xlGgGS5pTSNXLNk52VDJUZAQSduqUMNzwI76S+pBysvKckjgQ65p2CAQDLuUvqmWCyq7IR8T1AzHI1GVd/IplE2ialUSpn+SH87jqN06ULJlWuRjSegaJJCgRRWh4BfOSTDLGMxCD7lFaTFS3Zc6O7y/+B5JdsjtPKgZCEYVJFgx8WMv7Sp9HOQ2i/Pp3xG2ClCiU0mk88EFyQ7L9cgZm7CALkYyPgwjwa5NnkF2S0f5aNSqfClL32JJ0+e8Nu//ducnJxQLBbxfZ9yucz5+TkHBwfKKVvmz2w2q4ynLMviyZMniv7abrfJZrPKqGxjY4PxeKx8JGSsm6apdMri3n379m0+/elP85u/+ZuqWsPjx48VXdf3fe7cuaOCKZIZrVar/OhHP1JA4Pz8HMeZl2haXV3Fsixu3LjBYDDg8ePHlEol6vU68Xhc0bMFDMmYzufz5HI5CoUClUqFhYUFJpOJql8tenXLstjf36dcLj/jaB4Kheh2uzx8+JB+v08+n1cAVeaZa9eu8fDhQwDl9C3XPhwOVfAinU5Tq9XY29ujWCzS6XTwPI/r16+roMfW1pZqMwGMp6enSsIi2dp4PM4rr7xCp9PhnXfewXEcBUx93yeRSDAcDnn//fd57733SKVS5PN5FhYWyGQySvcLqPm81WqxsbHByckJy8vLqn50tVpVNHdZK2W+kkCZzO8CSGUuOzg4UHIoCRgASno1nU55+vQpo9FI+QbI/C7riUgYhAUjtdxlvvB9n0wmQ7fbRdM0ZdiWy+WoVCo8efJErdUy90rbe56nAGgul2N1dVWxiSSoGY/HqdfrSiMPqL3D1taWquWdTqfJ5/MUCgUVqMnn8ywuLqq1RNhihmEwmUxUxYG9vT1V8uzw8JBcLsdgMFD7DWFGnZ+fk8/ncRyHu3fv4rou5XKZ9fV1NedKQCNo8CpyEHH+l2BPUHLwUT7K3Qp/z/4SPi/yP8T+C4fFHbx1n/C+xaVZmf1IA5wHmI9rTDNJsMf4pzYnWolvayV6ay7tjTzVtwd8rTfmk7ToaG285VWMY51Pn2TZZJH3sXlAj2Z8hltxIXUC4RlaHTJHfZYMj2zR4ROvzXitAr/5B0+xTpcJMeMRbTqU+QprvOyE+KZ1D03r4zEgbkxJRaH6KZ/+vX0cYwXf0zD655zlh4zcNM7Zy5TNt3ghd59+e5lvhm5SN1ZYP3ib+Dfv83CUotO4ToQEY1zglCQzZu4imp5jyUtwnRrVZJ2pBlOgap5gew3CUQ9roHFwR8Mt+lgZ2DsF8wHo2xq9owIPw2P6uk9+uMpk8ZSFnxtQByZTyL8Chz5sD+blpuId6LQh7sHyWGN8rpFehWpmRuMh7NU1ivdi1AerjEnx4m6S6w/aWK9B+xLMpvD6FNqxECXNoXzqocVgYELyXohiPUd4s8PmVZfOls87xzaTcYysAVEPhj7E47DWh+l34eCOQWaWoBexqV8ak1qEzhg8D3BgYEP0CJYSML08JfR+nWU7RbZyQD3hcvQiuEseTCyMkEc4BHHPw9BsNA+8EzBbBrFxnHi+jz4Bw55rtY/qULPnmn3qkMqCC4Rnc8p3fgqL90C/azCbmWQHQ0It8PNgnYBrQbQ4B/VebMQwNCP5ksfCJsxaYH0jgr/zPBm/QpcJGhGKmoZVhsjPw2YKjn/LxHq8ju33MZjvl84J4dEhRI80BmFcJptDwusQ8yHC3MpAj0D8GtTfAa8HcaeOdmYywSdGh1ujVc73Q0z1CaVeipt+hpvoNOjwbUIsUOAGRdK4tHDxWcfFJc1lNPYp+lXeixb5TnoPzbMIJYu8c2JwuVlk2mng+qv0/TXuRUcMVhym3XMizTxToMMhfVyuU+Z5ltljSgePLiFG2MQIYwIT16HmzPAiLlYkBeEhsVaHmB/FcU0+3C74f/n4mQbdsjmHDzJXspAHtaASQZYNl4ANybQGgWgQpAZBt2wm5Xyy8KbTaaXNE2qbLHICaoOAQD5/8XfwrOv4aDRSIND3fUWrk/cLYAiW4RIAHgTdwZcEFqSkWtAQTM4hvwsCHaF0BzOhko0NAkGh/cnvJMsQNAkDngGXwcBAMLsdfEk/eZ6n+kvuNxiND2ZZhWYcbGcBvcE2kj4X8BncGAbLqck5goEPuVZpT7leaeNgmwXHQ9AgTWrEyviU/pXzBan24XBYjW95r7Sf3If0pdzvh/kPSJtdBPpBEBqUEQS18kFneMnoyf0Fg0rB8ScbSxkbF38KgJfrD9LUJUgSlIsI9THYhxezMsF7uQiuL4Lyj+pxfHxMPB7HcRw+9alP8d5775FIJDg6OlJmZJVKhV6vx8bGBvV6HUAFhsShu9/vc3R0xM2bNxVo0TSNjY0NNjc3OTs7e8awSeauRCLBL/7iL/KlL31Jme1Fo1HW1tZ44403sCyLVqvF3t4evV6PlZUVLl++rGQYEuC8efMmvu/z+uuvK58ICRQ9efKE9fV1BRAk4CeMk16vx+rqKs1mU2VZr169ytHREYeHh/i+r8zSguNbwJZIY65evUqr1aLf75PNZplOp2xvb1Ov15Vju5QHFDp2IpHgYx/7GLVajbOzMxWQ7HQ6HB8fK8f++/fvY9s2pVKJfr9PLBZTtbNlzmo0GorCL1r4QqHAcDikWCwq4y/TNNnd3VVa4+l0yvLyMkdHRzz33HPYts0777zD06dPVWBZnvEgCAvKkILB0F6vx7Vr16hWq6oMolRB2NjYUIHYYEnAYBlLGRehUIhGo0E+n1djTXwwTNNke3tbgVYxwsvn84p+LqW+ZA4UBkJwnhWALuut4zgsLS2pNn/w4IGi+AsolUCPlIYEKJVKigEhtG5dn5uQraysKPPR4XCormF1dVUZVUrpSE3Tnin5KOuraKplPmw2mypI0Gg0OD8/VzT0XC6nAt3BsQ7zoL24vafTaSWH8Lx5uTCRkORyObXHEF8GkRKIE38ymfwLUadbt4/5IXEqOFybvEZDizFe38YZT3g4bjC6VINUl3EvARsbcOyBZWMtOWxHx7DQh1yXesllt+fyPOv0tDheOkti1+YGOS7TocSAAjaPJquctl0sd0h06rLZPOUvl8/44s97RLPg+/OqY+vxDlkesx2N4/ptPGuXH3KNOKtozDi/Fuf9e7BUm+C/V+fmC/Br/4cGv/H/gKfjKzjlJnriDNc45c7YYX12i2uzA/BDDMMOfuiQ/MIx0ZjHzuMyR/4NHFpAj81UnbX0iDdPh/T9AzqMsCbXaL4Zxls6IlwGY9khknXIpaDzSMe64nN9C/rf1mi/kSerTZi6FttWkrrlYBIBkiQTFsMFqC/CsA92Eqafg1IN8k8h8hTs72awJ2n6xBn7WTw0HhiHOEzZsEy6pBmyyCoLeKMu9NuYDsQbcxm9PYb4zOUTGmytwPtD2C3A/qsu5v9cZvGPr7L7zg6DtIU2tXF4l2zX4fABdKuQtaH7R3D+zQrGZBMw8bU9jNw+/hSsezqe72NEfHx7nk3eeAc0Q6ce3mf3pkf1lzwOjXkN7XTOZWwPMRI+pecg/NgndhwmNooTejQmhIYdm2CtzuuGu80QSSNM+XjKZh2Wi7DUmtc93zfhMAazGCxvQ/a3NIzjMJ3YCPtMI/86mEs+bgviUwi74MdBf84hkXfQC+A9BOduGm+whU6eMUd4DPDDTZwXRlS/CNoYdv+zxsMHWYZ+hUU20ekQZkKaOkmGpKgSx8QvP2b4cw6HMYi1YdkETZu7vcdNWP0EGGmYnjmM7u+iH+fwSXCVBJP2JkM6rJIgQgILjQY9WrpF19cYYjPxZ3R0Gzc2wTNcIo5DeOIxitWYPmfPRf1n51DJcH8W4mFzC/fFVQhNYbeHH3ZhxWBagulwRJ80e5EphWGK216ODCGWMOnRoccMA5NFcoSYscsIjDi4OsQ0tGEf3bNpRYekZjFmP8Wc8zMNuoMZrIs07g/LdEkGUHTT7XYbXdcplUokEgngA12ZROyF7ioZVNncyYaiUCiojUI4HFZ1RDVNe4baFqTQSQRd6j7L+wXsioOpBAYEHAWp4UGqrlxP8DvkvoM6aXGkDZZnCtYYD4Ic0VB2u121yTUMQ7EEhOot7w9muYLUZcl4Sz/BB6BbMrDiRi4ZUGkb+SkZb9m0S8ZT3islryQDJKC/0+n8KWOti5R5AenSpgLqFxcXicViqm64bI4ymcwzmWTJ+gfPKZn2Xq+narWKCZyYSUmdb9nsy33IdUjwQ4C3tJdkRGQ8Bz0KZBM6GAzUhl0CUPIdQbAqDv9BGrxsuoMGdwJEZMMpfSsb6mD9cOnni6Bbrl10g9Lm0v5yrZL5lr9f1M4DCtwFzeOCGX75rPw7KCG5OBd8lI+joyMePHigyhVJHwTLT8ViMQqFAu12G9d1uXTpEvF4nGazyd7enqo/f+PGDRzH4fnnn+fp06dkMhl2d3d54YUX+PSnP02pVOL4+JharaakCh/72Me4cuWKGovi9ZDNZhVbRTThjx8/VnRkyWLbts3Z2RnFYpEvfvGL9Ho9fuu3fotkMsl4PFZlkiKRCO12m1wux9WrVzk/P+e1117DMAxOTk5U4K9cLivK98nJiZqvDw8Ple9CNptVQdpsNotpmqyvr6tMdtCIUPwP+v0+7XZbZRoF9Amz48mTJyoo1e/31bjudruk02kKhYJikEgt8KWlJbrdLgsLCyrj+eTJE87OzlRm9fLly7z22muk02k+8YlPMJlMODk5AebPyOLiopqvisUiy8vLtFqtZ0Bp0DG90WgoV/vhcEg8HlfzjWTqb9++reqIi/P1YDBQXhZybeLVETS4NE2TwWAAzPXdT548UZ8zTZONjQ1SqZSiTosMJp/PM5vNOD09VfWog2uhBD1lbZZ5UALBslatra2Ry+VoNpu0Wi1FoZfgtsyPwroS2vja2ppycR8MBmq+lCCjzCPZbJbxeEyr1VJ09mq1qubV09PTZ9YAKQsmz2Wz2VRtqes6tVpNuf+LLETTNLU2C7NNghzBOV2AvtyPMOh831dssVBo7rAvwV8B4dIWOzs7/62nrP/mx1nmiK/n7mHOBoS1MLNsC9oN/IUsI70DrT7oLhRD0OxAvYDOGp4RB7uF8c4hTqZLqmOwSBKXFq96Bdo/SPDY1PlB6IgX3SmfwaVCjnV/lXu9PpNejCLn/EKkz5WENy/f1IbZeK7HzWo6cTzc0Ghe7kkb84P8fWJTcKZpcvsWV70otulz5kFpAl/8IvTqDf797/pMcyG8cQy/4+BqNid6mkP3UyyT4LWZy1j/fT79qx3CIXjyfpi+4zBlysskWQtF0PN9Hp5NiDlZXNoc4FEeFUnvn1Dc8ua64iRkL4N502NlDUoeuH2wvBj+rIBPnwIJIvj0GdCmQd6fUbIg48C+BzsuxIaw9PuQ+HGRbteg55TwSGDTp0MDA4O4VWZImBlNGpwTYUok/pT6SzV2boNnQvUJGF83KNSKuHaaFh28v37O9ItwmobMX4K4/Yiz38ngN65ijhZZ5C6ZxAH2ukftCsSXId8CwwUPnQgeIx6zQBP3DBoLkMr4RCwYahC3YFoG34PEXpzT1SEnX4OdTWAMkdQ886sPXMIhmKSAfoK4s0KMEVF9hrE6wUiAHoWoA0MjCrMV8u/XmRb76J0wldMI4c8OKXxurkYwplB+DOGnESZJj/y6z2xf5/QoTL4/I1WCkA/+A/ALEEmAfj43fvOPkoQni7iARw2dMabWJrrRY/WLc5O25jeg/Z7BkW/SwyCLSTFUJ5KoEx77pFzQfJ0wOuHrHTI34CwyL0HePYZoApzs3DndywK3gRPIJjzG/TGtfgqLE0qsM6RKjTA+M6a0OCEEXohRbszjSoro4RDfcbE2ppBtMG0PMZ4YGI4Ordr8i9w47I2hk8PTNXxrCPEJFIeg9aGbh2EMQho4YWKzGKt+ghxJwthkCRMlhI2Hg8+YCT4aFiFwZ3ONwWxMdNYhRpyIlcUkQv+nmHN+pkE3fACog0D7IuC++D7Z+AsYloy5lK4R8CNgVUAffFBSSjKZYm4iC6VkeEVzF8zwyntE8yu0O/m9LOiS9QtmGC8aPwVBtlxTMHsMPJMJFaAsr2BWVv4uIFhAVbAMmWRjJVsRBHHBa5XvlQ1TcBN6ERwFgbYAVQGoAvLS6bS6f/muoNY6CByl38ScbDweKyAIqM9KMCMIuuUexNxNNjtCa5dNiujP5X6CQDboG+C6rhoHQaaAmLLJpkk2WVLSSfpG9ITSf9KvF/X30odB0B1kfUgmWdpOjMyk/yQII20iffFh7QyorJaM9aCHgNx7MDAkY0KuW6jpQVYCoBgXkjmXsXGRmXBR1y7PhbTVh2XtpW8k4/4XBXQPh0NOT0/xPI+FhQVOTk5ot9tsbm7i+3P9ppQtMk2Tq1evKu2plIDyPI/Lly+zvLxMKpXiF37hF9jY2OD73/8+s9mM7e1tpV8tFAqq/FMkEmFlZQVN02g2mypbuLu7y2AwYHFxUdGl5RmRbNzly5e5efOmAg5CExfQMBqNiEQi3Lp1S5Uxs21bmWGVSiWuXLmiymnJoWka9Xqd7e1tFVgKzilbW1usrKywvb2tdN0LCwvAvKSSsAaePn2qJCq1Wk09O67rks/n6ff7CkxKEGs0GnF6eqrKqQlQFNAlY3NhYYFer0cmk+H27dssLS2xvb3Nt7/9bWX6pmkatVqN9fV1JRdwXZdKpaK+p9VqKdp4JBJhcXFR9fnVq1dpt9sMBgNletdsNvE8T4FzAYDiDC768q2tLbWGiRGotK24zksALwhO+/0+CwsLSleuaRrn5+fKVf7dd9/lypUrpFIptre3qdVqz9CbJRAsgRBpc5lTZD6W+UXmJdM0lfGeOJHv7e0pRoEEc5eWllRwNbhOw9xgrNPpcO/ePYbDIfl8nuvXr1OtVtUaIGwoGVPhcJh6va4CqI1G4095xkggvNPp0Gg0VGk1qTYgZmf5fJ5KpYLneXS7XWVyure3p/pQDNI6nQ4bGxtKKy6BdVnbNU1TensJkIhpIMznYdHhj0ajP7e56f9fDu9mHw7qTCI9zOfPyJ1A8ygCmy3wMjAozIW04wx0s4TPqqy6Scb7J9SyXZy0DZMQK5NLLAMp3uRLVFjrXOb/nEnwtFDhXuOEPPMA1QrvsEWHKH3CyT6rl22IQfMISjGIhWHvfZ1BbZVVVqiPu9iMsbCYhGEcb7N8MuQvDTo8v3VI8nMDEluQyEDrAKx9jaRzznQUJd1Y5uZsiRIpdHyinNAmTxidSqnH4idh1IQ1PYJGhLfwsYlR6xZ46A85c1NUcDFIoqOjm3UWP+WxuAWnPzBo/ygB0z6V6z7aATSGEL/t4xgnPP3OEpa/BpgckkRjlZjuM944wq/A+QAmOhTiEJmB0YdRa4ma3+WMfRqsoGGS0Xr40Rr6NIOh+fToMvGfp5VoMfjfHtL9JLSWYPkpbP+egXP/Epa3ygyNZMSiqZ9DEUY+xBzIr3r4z3U4vfsube+EZKlG5jmHwRZsr0HHh60EXN2AabrOwOpQ0W0MO0LzPIyHTfGKz/IKNE9gsAedrobWKxDVYXR1SOPSnCqfiUAsDSEXuoANdE8hP1wkhk84eYKZ9DCr84BL/wcmFc8jP4tgkUBvbjL5zQEJ/+do+jEepP4d5S956EnQt8HeBstyIeuABlbYY6TZZIca5oJPOA3aqY478plFfLyBgefqWGTQ0LBpYRPFJMKsOGb54z5LFTi5A3uPIvStFGkM0nSJx++zeK1BtOxhDSDUBm23ThQNLe1h9iFUh6PfD/Hk3Ry59IDJL81YXAJvBixAzPyTilsbE8KPphhOH8dd4Y3oLerJGVdbDXIYuIQw0ZiaQCGC20yA04HYGbiHkMqiR9IUxmlauyOmSQ2KeRhX0DyPkNvFfpzCT0bQ7V00v4mb1SFtwuKE0GGHa7MNbpAmhUGMGQZDItj0cRmjAQl8fDTcuWNewkCbDAnbNpbmkPJTrBGj9lPMOT/ToFuo17IZl41LMEodpCyLHjSoZRaAIMBIXLBlEx/MiAapz0KfE6An5lpSazNoiCaHfF42kuLuG9SQJZPJZwCxZMIF0AnACVLGAQW8gvpdaYsgHViCCMF7EuBq27batAidWt4bpKYHDYok0y1APGg8FizxFcw0C+1N6pcGwZs4VGua9gy9WzaqwkgQ+miwLJcELISqFwT60h5BuqSALwk0COhOJBKKxiebOwkKSB/KZ4V+L78PAkn5Xsn4iKZe7vViiSuhnks/BqnxQUlCcJwH6e1yT0FZgEgT5LtlvAaz2cFAhVD2hW4vpYiCjAKh1wp9VQCI9HuQPQA8A54lQy3MiiBbI5jNDko4LrbpxcCa3Lu0g2zChQ0hgEj6UPo7KO34KB6pVIpyuczZ2ZkC3KFQiNlspjSci4uLrK6uKiAD84wdoAy3xuMxBwcH5HI5VlZWuHbtGvv7++zv73NycsKTJ09UeapUKsXKyooqmyXzwng85hvf+Ab7+/tsbW1RKBQ4PT1lOp2qGuFCZ19ZWeHq1avqWYnH42xvb9NsNtVzWa1Weemll6hWq7Tbber1uvJJuHbtGolEgm63S7FY5PT0VGnT4QM2kzhCS9BrY2ODSqXC/v4+tm1zdHSkmFAyZ4jng2Ra5XdSBiuZTJLP5xWQETq+OIhvbm7S7XbVmN3b21OMoNlsxubmJjs7O5RKJarVKpZlKQZBtVql0+koze/NmzeV/ETYH6ZpsrKygu/7LC8vq8BuMplUpaz6/b7SBAubSYKm8kx0u1263a4ywWu1WhQKBRYWFhiPx8B8/T0/PyeRSNBsNqnVamo9E/27zBOj0UgFHITF5fs+p6enZDIZtYbKnCL0fM/zaDQaSio0GAzUGiaMsaDkynEcRb2WeUvmLNFst9ttlalfXFxUOnWZe4WVIfO/YRicn5+rAIuUDxOwG2SCybxTLBaZzWZ0Oh1VOcDzPOWfYJomtm1TKBTUcya0bglABs1ZZV2W8mHiz5DL5QiF5hUIRHqwuLiosuBSw7tQKHB8fEwkEmFhYUG55Ofzec7OzlSwUtM0Vd5P6PUf6cNPQdhFmzkMjtP4XW2OkmYJKKbmgHuwRuh8FaNvknbDFICQn6GWBLJdOO7TwGKbFDmKrIRPeM7r8Zd6t/jtcJrvskaIDZIcEMclSZIVjog6M5ypg+uA3oVR0ef3Rjp/uH+Vl61XKRAizpiaNmFaiENZh9aIit9ivXTItb9kE3kebBviKdj+Qzh/d5F+Tkcrhrl+fIMvobPEkDYZ6tQZc4odmrL1cod0Zs7MLRYPaZ8uMQhbvO3skvDjHFpXiYbCRJ1TCoSJaH0i19oYL8FwAUJrBtb2x9j74Rj9/XsUq32ogLYxd642SBFiEZ+nhHDw2MKO1DHWYDcFowIkDCgM/6SceRL2jCNSts0GYeqkaVMi5a9xMN3BYEyODkNSlNmiwYSdVRgszmt9V4/gRzsFRoUS/rhHbtJj6/kTos/DcQRMD6wYnPmwGoPl21OOVo/YXYcTE8Jx6KQg2YT1Q3DegHTXIO7D1K7QJUrIr6NPbLwpEIbuGLpnCSY24KdpxYZoqxBdgMwYMgmwTdCbc9zmt8D4sYFpG3jREzIhD7unMa350ILROEELFwNwOCPMKp6XoUabDDFiYxNjNGamzZOvZgMSdgpv2Kdx6DEdRPFCMwauT7QOelgj4cUJTxzcqY/vmRhoOPgMaDBkgkaGcGhE/IpF9groeehYGu3xMmMKpGmwGH7C8qcG5F6a6/CNHsyOwGo6xEbzoElyCt27cPa9VbrTG4yaT8nf2aac94ga4PUhpEMoC+5liIx9ip0pk1aTJdtjNBwTx2CAh8eYEJm5EH/fwUkWYHEKXhOGA/CThB0HH4h5UTJ9k7YTxjZmpHydtF/BmRp07FMcr4IfKsyZKtYQukM83+KMRWKMMLApUqDMhE08OvRJEyHLAg9p0SWCb+Qh3MB3NUZODC8RYTzrkJv8NIrun3HQLZkH2cjLwhcECUGtrSz0ssmRDb8AGonOX8zCwQdZY8lECjgO6nTFCVSyNx8GuoVenkql1IIo1FrJogooEfMz4JlodRBwBPW8F0F3MIsroDlo3BYE3RLVF2AZzCZK1D+Y2ZYNjgC1YLZd/h7USQfvXzRzmUxGRfSFvj0ajVSAwbIsstmsop0GHWKlP4NsAbm3IEgNAqs/C3QHTcRisRjJZJJMJqM2tEHACx8wCYKA/SLolqCEbMKC9OYgA0C+V9pbMi1BJkBwjAbvSb4z6Iwe1A0GjeuEaijBqWCZMmlr2fAC6pql3wXUCvtAmBGy4RMQH8xKSztczM7L83nxPcH7uwiqP4yxIoeMl+B1uq77jGt8UB4ifX/xGf+oHUGnbdd1iUQitFotRqMRly5dUpm2SqWC7/sqUyy/dxxHyWxE531wcEA0GuUzn/kMlUqF999/n2azSSQS4ezsDEAZm02nU775zW/y5MkTXNel3W6TyWQ4ODhQYyKZTFIulxVQKhQKmKapsqC+79NoNKjX63iex9bWltIuG8a8FrVk81utFmdnZ8qRW4DrnTt3ODo6UkwPydAKxTeVSvHiiy+qexXX7slkwvHxsXLfjkQinJycMBgMVCYfoF6vk8vlWF9fV22RSCQ4PT3lyZMnikYuc1c2m1UluDKZDGtra3iex8OHDzk5OSEej7O7u8vS0hLxeJyjoyNVvk/G7cc//nGWlpZ49OgRmqaRTCZVsKPb7VIoFLh69SqNRkPp0pvNpipXtr+/r8wSBZQnEgkikQjHx8c0m01831eaX2EkScBPnM4lMyosBWFISQZd6OmdTkeVjBNmjWi7FxYWME2TTqejjONyuZyaW4NeG0LLF4q5rLOSFReWTqFQUO7zshc4Pz/nyZMn6jpFUlCtVp9hJ3W7XZU5lvlT2F4ScO12u9y/f58rV64o4C+lFweDAZo2N1qT+VyC2gKOxaQvGCwdDAZks1kKhYJiBMgzfHR0pAI3ErReW1ujXq8rx3bDMJQh3XQ6VXO7YRgsLi7iuq5aXxOJBOl0mqOjI87OzlSwW4JQEpj5qB+peym8kMFyb8qomaEZHeA7NbzBGqHQFuFJj/w4wSetHElc3mLCLjDERG85+K0wvlZiRJgRGcZ8nH27TpQuv0iXS3aP32KNt7F5hQi7rDAkwedY4ua0wfThKb+tOfxYc4kcjXiUyBFJ5Nm1GnTRaeEyjaZwyiVCgzZmx6Li5zBbFufvH5NP+fgpaPSg/mODwXgRJ7NE4qjPgtYjsvouU2PG6d51PC/KOS7vh+IMH7TIfX1AqQzVpTY/rt/DtA3SeJyTRrNTRB2XPiYbeKQWH3L112YkcuBGIPrSlNNvQ9PLE6naRH5uruE134PTQ42BrxMxnrJy/SEMfOr7TRKLXRbWwTuHfBQSCeAAzl+H/n1IldvEYuCGdMqhd4jXi7jdAqtmi6w7w5tVeJ8hmfh7FPUG3i64yzCIw9GOTn6YZKr1yEx9ivEe5b9kk1iC3EPI+TDLgL42p3sPe9BYgt0rkD2H5zrw/AwWj8H8Jtw/1NmLmCRnFSBFHJtEyCD+MTBW4PgQmrs6vpUhRhfd2MULQdiGvA26BzNr3lY4EEpBogmp0wpTP8U0NKM41QnNYkyOJ5D06MTbzMZ5yhhEGRPGJkkIgzarFMn0Ymi1MY3FObOhGNHw/Ty2NiY01tGddcL6PrYxodtNkyLOjBAWM3w/jIMHRPGIYdCjQBQbl0RhSKQEkRw06vDk7TgzL8uUEUUSZKJnVK+Ctwi2DrMD6L4F5lhn4nn45xDdA7cFumvgEGPmr9P7gcb97j6XvzIlmp0D75QB5p+UFYs8hGSvw0u2TmRWYEyMMyya5hCXEfhhwjULP6XjbIZgBJx6YEUpWgUWyONhESHBPU+nVzmilzqDRo5rdo6wG+MgtUqIOtpkhm+YMArh2xm6+OwwxUFngTiLZFjGpkaCGSNsQkCCBGns2RF27Jhw9Bg3FAUtj+OFOGf8U805P9OgW2jasjBKVsV1XQVgg0A8SEMNZheDoAVQoFcO2XAEs8MCIqTGreh3ZbMWBKyScZfzFgoFle2Wck3BrGeQDhzUSTuOo0yKgsZTwJ/K2stiLt8vWW6h0MmmUyLoQmkOAqNghl0CF3J+MfiRTZYYugUzqAKCJYgh1yM1oHO5nKrbKoGHoBmY1JKW/pXrkE2QXKtkYwBlShO8HgGpci+iMxd6a/CQzLlkfqRvxEVbgLT0gRxB0CvfI98tfSvtKxvnixlcee+HeRQEM8XyHTKepM2CpnaySQz2fzBjL1kdydaJG7iAWdnsiju/OOUGNduSfZLghABp6W8JQgQlGwLUpU+CJnfBgJK0T/C5lGdK2k3uUZ6T4BgRQCHtLptxuVaRZXS73f/lSeZn+IjH47z00kvKtK/dbnP37l2KxSJXr15V7V0ul5ULt5hCSdZZHKqj0ajSgKfTaSqVCi+++CKdTgdd12m327z//vtUq1UFHD3Po9lsquyegNRIJEKtVnsmsLi8vMxoNGJxcfEZWYgEQs/PzwEU5TWRSLCxscFgMFDZ8qOjI6WTvXPnDp/97GcV0Or1esrgDOZjRGi9pVKJYrGo2CCNRkMBPjF3kxJSAtJFgzwcDtna2mJ5eZl0Oq0AOcwp6Y8fPyYSiXD58mXy+TyZTEa5vYu2NhwOU6vVuHbtGpubm0wmE2W8JW19dHRErVZTID2dTrO9vc1wOCSXy9Hr9QiFQly6dIlut4vjzEtuPXjwgFqtpgKJk8mE9fV1EokE9+/fJ5vNkkwmFesonU6rigoyt8ozJHp3oZvL8ydUcfFG6fV69Ho9VSM6Ho9TqVRot9uqzJv0vWigg54XElCRAHAqlaLT6aggblBCE2QGWZal5nMZx1JJQrLyvj83s5M+ms1mGIahTMRE3yy6a5mH4vG4MmGTuev8/JxoNMrzzz+v5mfRg8uzJFlyz/MUm8MwDOWWL9ci3iWxWOwZQzZxO+90OgwGA54+fcrS0hJXrlxB0zRKpZKqHNLv98lkMs9o2uVvmqaRyWTUnC1rgWmapNNpJYmQ7L1o/T/qx8YgToiXuMoQx57wA6fN6cK7aHqB8ulVLvsu1/C5CdzTtjlNunS0MLHBlMhkwsw0ILRAniVcovwYgw2e4zptKnyHl2jRJAbMGNDi93SNor/IFX9MnAYeG7yHziOzxdVxmssjg4VRixg2R0xYwcGYhRltx6nYyySpscGIsa5j+eDvgVEELQrnp3E8cqye9cn7PfLZXdZ/qc9gAtPfaJMcldgzajy9doPhzsvk/+M2P//LJ5zH4FGog6OB4ZrEcNEcDUcLUTcmLNgpSrpLKQMkIB2FO50IT/0seqTByqcmVL4KgyaEmpB6ZJJiRPRjJ1R/1aH/X3W2jlos5z3iHRjbYBYgOYH9d2D7DkQGcPkqRD8P3TUPYzRjeeeE2eEJk5U/oWj/eMhCwcZ5wcUeQLwIKf5E47zosZyt49se+VWN1Y0pmyaEvwHe9px9PFuAH27Bvecg0oOGA+EOXHkfUj/WiaUgF/MYpWDxlz2inQFPfi9CblgiwZBcdkpyAYxLMO0CUx+fHlNSWM4CFsd0oxaWDxEN7CiYDlg6oEFhH6qDEAlC9Mar9Dkjpg+Z6R7xS1Dxfdr3fLoznbgbJUKEMHHGRGnRJxIegg7hEKRMCEV8bDJooTaptS6dswPClkXIAg8DDQMPhykuIXRcDCzSTEjgYxEhzNRoksx6RBJz+vf5G+AfrDBkQAQbWGMWOyAUh3EHnBMYPTQYb+cJWTEI19AOHIYDjXjMZSnSZMEOM2WTlrXG4L1NotbrPPeLNm4IvAmkMkAWBiGI+PNAT54+OjANJXALU0Jtg/CkQsmbQn/I6W6E2KjCSjvGkRFnxhADnbbmMdYHjCJdiJ7jhw/pWg47zauM9SvEZho3rRLj0ZSdWB/HGZD0M2SI0sfjGJtzptQwiGGwQYJdJrTxiKJj4OFFTEjkYHqKbnh4sSLYMfxZB9j7ieecn2nQLWWUAFUORhbrZDKpasgGN/wCDmTzLxmgoBZUqMByfBi4EnDUarWUI62UWJHNooA3oReLfrZarT6jFw6CzouacYnui3ZtMBgoGnhQJyztEMzICnC8WDdaALNQ2oKU6SDFVwIFwXNdBJwSaBDKdDDrLhT8oJOtUJbF7EUkAgLchYYXdCN2HId4PP4M2JRNjmyU5N/yMwhABVwEdclicjQYDFQfAaqmapCqLCwGAeAX2yDIDLioKw5q1kUvLp8JZnqDAF3GqfRnEHTL+BC9nmxehW0RvG9pb+n7YGZeMh5Cq5eNbJDWLayEoLGdtL+u6yq4FCwfF2Q2yIZc9OoX71euRQJAwWCEjKFg4CcYyApmrWWTLplK2ezLc3Ixsy2BBXlOPqqHGGSdnp6qNhdTvvfee4+VlRU8z2N/f59Wq4VhGCrLJ/OgUGKD88XW1haTyYSlpSVu3LiB67q88847CljEYjH6/T7NZpODgwNOTk64fv060+lUgVLPm2vFV1ZWVHCsUqlQKpUol8tUKhXC4TALCwuK6izgR6jVAriWl5cByOVyCpxblsWPfvQj5eQs86kwleRZ9X2fZrPJ+fk5lUqFwWBAu91maWmJ8/Nztre3lXxFQIjQ9nd2dphOp6qMk2TjNzc36ff71Ot1Vdrw8ePHfOxjH+P4+Jh79+6xsbHB7du3SSQSqqyVzNVSLlKqSTz33HNKt14qlRiNRjx69AhAUaDFVFJ0xp43r3P+/vvvK5mFuFvncjkFjgE1NwWBmMyL7XabZrPJaDTixRdfVPW25fkPhUIcHh6yv7+vsqmu63J8fKzmjFKpxNraGqenp7TbbdVvElxxHIdisajYY8E1WrK4uVyObrerTPpE2yxSouDcJoE7yeiKKFVWwwAAklJJREFU1GA2m7G0tKQMw8QwVWj2YrA2mUwUtbrZbCo21erqKpPJhPF4TK1Ww/M8CoUCrus+U9VB2lLWRQn+t1otdnd3WVlZUeuWjMtSqaSqA5ycnPD06VOy2axqS1mPxMk+Go1SqVRYXl5WtdglYBEMDEgfF4tFJTMClGGrrCO5XA7DMFQW/SJL76N67OSKhC2XU7eGZ/q0fRd9uYlXrjOwogzPN3gn5PPtQoeD1S52KgzHXSYVc241PjRg4jFmzH0cTsI+a84M/GUmLLJKlxdI4wDvcErSK7KJSYwDBkxpEmPo75OxdljgCn3iPIra+M6ItDvjeSas+Cls28HT9gglDiiVzii/ZFFZhnAfKlnoWnPdcIwIL3h1Fsx73BymmX7bxLg+ZTlexx9FKHhxcFq0kx47Z1libzSYaDa+s0DE1zGYkiZB3wwxyXmEBiGadpZGp8TwvRNim2B1oPPHOUL+ZVqzGI9ezxBv9PBehcxfBroTUjvnlCs2x/8lgfWDK+S0Y/r7Ler/twW8So+NXx0xDcPZMYwcjek4xpPOhBfwib6l8+RejM3kmFvXfDqfhEYZ9C9OmYagFoXIdF7nu25DdgqXbkE6MuKmBUsmTO9r1P99EuoascQAswL2U2jmoP5JyPhzIF99DNp/iWHvL2H4GmflE9KfGFOaQH4CY9OCoYkfH5K8ZhNxIXHKvFyYpmEQponHE6LMNJNc2sIzYeSAqYM9mWeHS4dQ/k6U9MTBNR/jTlc5ZpFsaJtIDkpXYG0BTjfbtE9heqdEaBRnQgubGA42hcgMMw4nxtyVPOYDRJgOFohN++SeG9MdwfRBGENz6IQbpKwwE6K4THFJ45LAJopPDhgTSg5ILEM8A509mD3UWbQdRsQJc4koNpmYS2IGk0ONk68vUx9dxiJOHA3sBM22Q7xdIh7aZ1VrM+GAAUm+w5iQn2Rxdwn3vX2ir4ARAsOZlz/TSzDZg4rTwGLCIzbIuOdUT79DxH+BMAus0WXqJ4juR1gjwouUeGiv8UNOeWDs0K1k8HMOTA9hHIdeBaZNzs0G5Eyibhm9ucw118QandDSDDYxMQgxxKOBxvfoMQBeJE+ZDiuMiZKnzYxHjHHDBoRj2GZlbrcfzkMyzmTw05VU/IlB93e/+13+5b/8l9y5c4darcZ/+k//iV/+5V8G5mDmn/7Tf8rv/u7vsru7SyaT4Qtf+AK//uu/zuLiojpHu93m7/29v8fv/M7voOs6v/Irv8K//tf/mmQy+RNdi+gNhS4uG0VZSGSxC0Z+gxRt2YzL32QzENS0Bk2q4AOqa1CD3O/3VdY4+HnRh8vmQwCMOGIDCnCPRiOVTQ1mmYPXJhuUi3rloHY2mCkUg5d4PK6yOEFDONnUyStIw70IGCU7KJl2AVTBzKzcD3wA2KUdgiYywexssE+CoF/+L2BMdITSH/JeMUyToIRcg4AsYTUEjyBoFi1/kDovhmKapqmggvRvsA/+rI2JgLs/K5sd/N1FICpAMmj6FQTdwQ3lxay5jBkZ70GAKtcdzNoHwWwwE36x/4OmbvIz+JJnLgjeJUAioDjIMAnq0oPeAcGstvSTXFNQUiD9FBxvgJJJyPmEEiwZs2Dm/C8CvdyyLL773e8qbbLQu6XO9t7eHgsLC2p8iZmSBKFKpZIC2qlUCpiXIXMch83NTTXPzWYzXnrpJbLZLMPhUFGhv/e973F6eoqmaezv7z8TKCsWi5ydnXHt2jVWV1cVIBYDKKG27+/v8/Wvf513331XgbNqtcpgMODevXvE43GKxSL1eh3btkmn00ynU05OTnBdl1KpxPLyMrZtc3x8TCwWU2NvfX1dySfy+bxiPmSzWWV61uv1SCQSqoTUlStXFN1XXOF3d3eVHjsUCvHkyRPW1tYolUoUCgUajQa2bbO/v6+0zZFIhPX1dVX+qVwuK73weDym3+8/IwtZX1+n3+9zeHjI2dkZvV6PUqlEJBJRVHBdn5txSi1vCag2m00sy2JhYQHP8xSFOihr8n2fVCpFNBpV2uLDw0NqtZpiPUjWWObHVCrF/v4+3/nOd5TTfLVaVc9do9FQVSCkHfP5PI1GQ81HpVKJZDKpgpvdbhfb/qCWdL/fp1arKfOv6XSq1s7RaKSAuKwxcriuqwJAIosQDf/q6irT6VTJZI6Pj5UvgABoCdj1ej3lPyLj0/M8ZexmGAb9fl+BX5n35DxLS0vKa6BSqVAoFBRAL5VKKtu/uLiopDFShhTme6VEIsHCwgKOMy9v1uv1aLfbFAoFzs7OlOnn0tKS+rxIEaQsnwS4L126hGmaqm9brdYza4phGGqfcnE+/igeo4/NoPdttOYuuuYQPetRanc4WwgzvH3Muwcavr6AEfcJ6y4cjrFDQMUg/NQkfl6iHxtynh6S7qXIuXDiH/N1HL7GTVbJEsZixhEvo5EmyZgmSbK0eY7/rD/gKPcAJzLlB9pDbDeN7WvoPZuiW+AUi2vGU1byE4xLU8wFn2wJQiY4DciE4aAD/+X7Id5qmMzYp0iERWuFrneJO/en5Ho/pDiOUqNAFw2iGvZqi/2Gi3ZoUk7YrPpV2pgMOaSeTDMrWpBz8cJreMMw0XSf/DKkXOh1oJDus6r/iIYX4e7xJqlTnczjbaL/fZ/E/9GHH444ft1gsL1FzL3OI1KMmjMuc4PY8Anb3/k+5S/7FK5A4R2dhgFW0uf0Wxqjp0nakzzREKwf1aiUZgxisFeGThj0M0hPgMGcpn4zCYsamAsw3YHTb6U5PVylO41Q5ZywNqQZ9fHHoDUg2p9nXGMmZNtg1hdo+Cn6OKyfX8f78X0m61O6U5j1dCztEHP9HL8CqQ5ED2BYg+QsxSFxTmgzA6Yxl1AC9PDcJDtlwTgJyX3I/79CRJ6scRZtUb3UxjxwiAxWaThpFgsdYhnomZCoQi4C5w9nWKMwNmmKf+KLb1l3KPQc0l0IWRCeAozo+1lqe5skhvv4IZhOKkTSDbScxeiwSNfLMGVGnBQGUSABhHG1JolrNuYrMD6Fwx+A1fQoGCfMnKuMMclQI9z1OP79EO26yenoEhMqpHCxyOKT4ZwpQ3JsuVfI80PSnOGwQR+LMH2M2QL9p2esvDDBTAOzeUEALwXR5AmLswOGlAkBn6DAqg8R8w202QOi/jUmvMolzkmY34dZgT7X6S2kcSImJDXQ2hBOQmQRxg5EyuD2IH7M7GqHd44sHu8tMKnGsb1F3L0IFTfFCQP6eOwYFiOnhU+C18hyhQHPkUAnw30aDKMt8AF/BloCNANCKayfcs75iUH3aDTi1q1b/O2//bf5a3/trz3zt/F4zNtvv80/+2f/jFu3btHpdPj7f//v81f+yl/hrbfeUu/7m3/zb1Kr1Xj99dexbZu/9bf+Fn/n7/wdfuM3fuMnuhapNRukRUtWQjaXQYMTyX5JhlJAg2hggWdqOQeBalAv7DiOMrQ5Pz9XmjnHcRQ9ORaLKTrhxsaG+r/o/TRt7qQrZUharZb6N/BMxk8i/kK5FtAY1LoGgaosoJLtLxQKpFIp5XoaBKuS0ZCMaNDZVN4TNAoD1EZVTGeCFO5gEEBKteRyuWccw4O0edn4Ben1QouTRV8y9aLRE2qj0B+ljqtkXiRLISA/aDymaR8428p4ME1TBWkkUyDt3W63VXkv0T3Ds+yHi+D7zwJz0kcC/uSapM3kvuEDJsVFcBr0GxCgG9TSS7YxaFTmeZ7SzQsFU/rdcRzVvkHqtgRbZDP8Z4FtAboiAQgGGoLZH8mQXWR1SDvK9cr4DWb1pS+FqSFU94usDOlDyZJ1u136/b7Sasr7pK3lsx/V4w/+4A9UiSrJiAoVWCjS4XCY5eVlVldX6Xa7HB0d4Xkey8vLyh1Z5i0BHKenp5TLZd566y3C4bCiThcKBQ4ODhgMBs/UFx6NRsTjcSUVKZfLFItFNE2jWq1y9epVAAX8go7f/+E//Ae2t7fRdZ1er4dpmjx+/Jj33nuPaDSqAAugsutSguvy5csUCgWVgRbH7larRTgcJp/PMxqN+PSnP83GxgbNZpN4PM6tW7eYTqccHh4yHA6p1WqqhNbP/dzP8fDhQ3Z3d2m1WgrYG4ZBq9VSVG9dnxuwCSAqFouKCWVZFr1ej6OjI8UiaTabCvAKVVyYWqIt393dVZ9tt9vqvuWZl+CpMD9k/pV5UiQhmUyGZDKp5pRqtaqembOzM+r1OpZlKedyAf1bW1vPmFpqmsYbb7zB7u6uCnBXKhU2NjaIRqM8ePBAOWHv7Owo+UCwdJg868K8kQCdBEOlpJxom8VzQjTXwt6QwIF4TNi2TbVaJZPJKK8BkTWl02nq9TqRSATLstje3qbVagGwsbGhKPYStB6Px4o9IwFjGb9CERfGkNyTVHmQahzRaJTj42OOj4956aWXePXVVzk8PFQBBtM0efr0KbVaTQV7xDNmZWWFQqGgTOl0XVf6fAlkyJwmAQlhRIi0JBaLsbGxQTweV14JnU6Hfr9PPp9X870kEprN5k+cBPmZPE5/D314TLk3JDcymOEyifrY9SzJZoIrZy4LY49VchQo8DYWb2vH+NseGX+JAXv0GaKRp0CElJfhCR4zTnlAiRoVLnPIDQrk6VHglANSDFjiEJft7BHu4gx3lIZkArqgnRmkZjkMCrj6faprba6uADnwDUg5MBuBF4NxE/6vfxjmm51L6K6JThuXMm96GxxnJnRCUa4dLbFBgj2q1PxjwmfH2KUFZukal6+OKEwh2oGIV+Ato41l9ok1mkwnOloIjGiL618dsfQadFqQScOtX5gwefpjhs0KZ0TZ8S6zsOdg3LnL2n8HDR129tc5dT1mPKChLzCJp6lNHW47l9Ee7LB+q07agdOIS3xtQjEJg/eT+JMYM+r03MscHg1x+jNqFkRasB6FznAOnDM6pFNwxQXnD+Hge2me1ouMZpdpMGNIk1UKaPYAL98lGYJsCDpTME2wDYiaEI04uBONCTN832Rqh8iEIXls4NpJ/MQp1asOkRi4j+DsWKc+jGB5OQ4IcaZVSfgO+a022S1wzbmZnB8BTQfvWyGa37lEzy1R9PpU4rBxqU/0rsVDP0y6DKkT2Hk9xKgXproxxbw8YNC7D9YWPjouU0YRn3waDBMcd550NTSLqN9lRJvE0EWfVJj6q1A+wwzD2L+ER4IoM0wKzHeqCwzo4un3qa5BZh0abwJPIX8d4hGL9LFNnTtE9B6z/gLbDxKck0ZHYwOLFEXOgCh5dCymTDmlgMPLLPOUECFiFIjhM2HCsGZiP5xg3ADfBjrz9o8VZkxbLUxy3KLLj3Wb9+NFvup2+Ux8n6PxjJl/hQInmHaUt/1l3ss+xck0odmb6xJ0B+qr4BUgNp1HYM70OQ1icR+76tNbWATLJ/7IIeNFSaORooTNkL4zpq2NOfVjHLHOBpdYYF4CMKr1odiHbI6IbWNqj+mn1qAzZFZrwE9BlvyJQfdXvvIVvvKVr3zo3zKZDK+//vozv/u3//bfqgVmdXWVhw8f8o1vfIM333yTV155BYB/82/+Db/4i7/Iv/pX/+qZjPj/2iEAVDLcYlImm28xgZHIs2y0g9ps+NN0V9H7GoahMoIfZkAm/w5mxoM1MsUoLZ1OP2OSJsBXQNVsNlNaMtkcXaQpy3cJ2BDwKUGBoF4WUNltiXDLYizZy4tZ8w/L2spCHgxSiDGOfJd8LtjOQaqfBDWCh4A7aUNhKkjgJGhOJu0u/SFATkCfbIzkPUFQGqQ5B/v5IgVfyrQI4L7IgJBsb9DU52I7XcxoB4MPwWztxT6Vf180IAuC7iCrITjuguZ5QSmAgN/gvUrWI5itl02q9IG0qwQqgGco+gJSJZAlL/lMsH2DVHDpx6C2OyhbkJ/BTLsEYYI68+BzEfw+CYZYlvVMSTEZk3K9f1Fo5XIcHR2RTCYplUq0Wi2l9a1Wq3z5y1/m0qVLpNNpZrMZjx49UqA2FovR6XR49OiR0sMWCgUcx1EZ7263q9g5njcvNbW0tKQMw2AOcrrdruoTMWnKZDJcvXqVa9euUa1WVUZWAjciM+l0OtRqNUzTZDqdks1mFT1+OByqsmYS2Lt8+bIaO5/73Of4yle+oupSiya51+tRKBQIh8N0Oh0++9nP8sorr9Dv9xkMBozHY+7evcvOzo5inIzHYzXfAur34tr95MkTqtUqq6urymBQyoqZpqno75IxFvpus9nk6tWrlEoler0ejx8/5tvf/jaxWIznnnuOg4MD9Vycnp4+48zd7XZV/yQSCV588UWq1arKzIZCIdbW1jg/P0fTNJaXl9Wc2W636ff7Sm/teZ4ClScnJ5ycnKh67mLM9Qu/8AusrKwonXMsFqNer3N8fKzmlEQiQblcZnNzk06nQzabVVlTmVuFhVYul9H1uau9BECCxmuRyLwuthhuhsNhlQUfDAYquy/tKYFU8XYZDAY8evRIrS3JZJL19XVGoxGe56ngyGg04vj4mOl0ysrKimoXWVMlUCUBQ6Hoy1iSc5yfn7O+vq7m4YWFBc7OzvB9n9XVVd5++23u379PoVBQUgyprX5wcADA8vKy+k7DMJRZnejtdV1XtPpUKkWz2eTk5IRIJMLt27dZX19H13XVZ8lkUmWyQ6EQw+GQdrutnjc532AwoFqtYhiGot9///vfV+P9o3zoJ4fk+2mWPGiGJrRCBrGjFDfs5/kr0y/zKlkyaMyweZ8WjnZG0jfxidGjTTv5AD9jEDuLsUSBHja2kUJ3oEaP76ZGlByPr042uI7NCk3SVIjTxWfC5f4y9/MeGDoc5tCcOHrUYGGW4OexuY1FdQDDc9DOgQREF8GywchDpw9750Vmy0mwJoQ6GVL9KLZm0Cg0wHdptg0yDAkzJu1fonA6wfe3+fRrE772ikfzGOynTabjaziRLOagj+kUmEQipJ1DPvXzHV75eZ9xDwZtmB3C3e8bPB6mcSmgcwps42kD4nEwfHBiMItoHFsl+qEmPk9wNxZ46K8wexTj5XaBnf94hjUzMDMOy6/5uEmYNMaEd5cwWMIhRCvpUFoHowRrHQj9EJ78TpQksHLdYRKBx02P8DshdpvPc0CJCE10zjjTLL6rZ1kYl0k/HfLilsPLIch34DQJoRBcvgTeSzW0P0qwbpfQo48wsiPa9yL0RjGm+XNSYRuvCbF1mI1CnPSznOAzxMQnyTXfwlzaIf4ll9kqeGOIazCJQfQMmichTvwIKTokkxOKvwCbJrR36mQGOilnThc3+yFCzQTh9JRYxaesj9CZMsQnRYr8LE5yNsCYQtIDIwFDXSflpsj4TcKOTtc3sUkxqMc4Tzr4jDCI/4mKe4ZNjDARbGKM3UUe/XGbqWvh6pB8BdZvweiHPt5xm5zRoeenmfEcBwyZ4LFOng46DTxMooTx0QmzgMYRQ+4R41WWKREiQxabDj22GU8jNO4arC846CEI+7CgQ33m4dNglSpvU+ft5Xdpb1UYvXUVf3TIJ/02E+0POPQ1fPdT+LyIq5/O6QRhY04ncMPkhjkssoxKOvppl1A7ia2l0O4n8IstSB2jH91mvbHGZ/wZUZLcI86UJLrewtY9ek6IdxgxYsZzlLiPwzCmQ6IDoQ52qYwXykB/C+JTNHMb/6eoqvjnrunu9XpomqbK0PzgBz8gm80qwA3whS98AV3X+dGPfsRf/at/9U+dQ0p4yCFmOKItE7MV0zTJ5XLKiTUYqQ3Wa76YiRRgIlluQP1fNN/ilioZ26Dpi7iwyoKXzWbJ5/MsLy+TyWTUZixosCWUcdGDn5+f0+/36ff7z9CdRR8WNMUSHaNQHsWZVUqrDAYDkskk1WpVuQML2JnNZvT7fZWpD9ZYDh4CBINMApiDMAFPEmSQ7Ie4yUoGot/vq/eJA/KHgbJgoEM2yGKYJN8n+v0g3V/cgIX2LkeQZhhkCwRNuyzLIhQKkUqlyOVyLC4uKsdy0TqL7k6yBbKJlra8eASz4EEAKvcp7RYMMATHAqACGTL2LgaK5LPhcFjpVUWzKiwFAaCygZSMftAMLljPVjLekpWWZ0p0iWJKJNkcyZ4JeAhS8kX/7rouuVwO+ID2LfcgcgDRnQMKTElAJpiZD2rng8ZpEgyQ65LNt4wR0cgGS6HJ56Q/P8pHPp9nNpvRbreZzWZ8/OMf55d+6ZdYXl5W1NTd3V2VPRb36H6/j2VZFAoFNQakTyVzJ8FCAUeymV9cXCSXyxGNRtnc3OTx48dqMy+u3RsbG3zqU58iGo0ymUzU86RpmiqzJFUkcrkcT5484fLly9TrdWUIVavVVM3xcDhMqVTi7OyM5eVlrl+/zuc//3kABd739vZUNQShxK+trfHlL3+ZcrnMyckJ6XSad999l3fffVfND8PhkIWFBa5fv06xWGQ8HnPr1i0ODw95+vSpAnnCAFhZWWE0GtFut7Esi3K5zOrqKqurq5RKJeVmHgx6tVot3n//fRqNhvKR2NnZUXTi0WjE/v4++XxerQkS8JDxL87WUnd9NBoRjUa5ffs2vu8riUEqleLg4IDRaMTLL7+sMrXtdvuZbKk8L7lcjlu3bnHr1q1n5ETy3fJd6XSalZUVwuEw/X5fBe4mkwnRaFTVHzdNk4cPHyrmiWSsU6kUZ2dnaJqm5o1ut0s+n2cymajrk9Jo5+fnFItFJScJzqcy94nJ6c2bNxXt3fd9+v0+0+lUGZSJLt80TRqNBrFYTJmOSZvMZjNSqRSe5ynmm8xZkUhEyY+SyaTKXsscGQqFODk5UTKyyWTCD3/4QxYXF3nhhRfwfZ92u60yz/KMLS4u4nkei4uLaJpGt9tVfihHR0csLi7S7/fZ29sjkUhQKpXQdV0xTmQdk6y9jA+Zy8WcToLVEuAQirkwBD7Kx0JuzNAO0/Jn1I04a6NP8muDX2aTJbaIc8Y+e9QwyPKfIzW+v96B5pBEe8A4McO9kgdHx21N6DpjLFwITakRYeLYuNMZzXCM38fgkFU+xSLLWOTZIUqILWeVp0OfWRLC0w2q0wwr1Pk0bT5Fl6hnMBlohCM+fhz0JFgh6DYhaoNuwZLd5/H4FOt2Cu/Iw3g/w8RPQ+uIzKhDgS2M1ENevP6HPHiwRWxY4GPr23zukx5aGEKr0F3YZbRboTq1OYhnmKTDmOMZz4VtvnzbpxKD4wHkm/Cd30jxmwdXaKQ09LROdOTw8qjN9dCYogf04fInofOH++z/uErHjOK7HkzA82qM/BXOfJNeJ8zUukLZarMSOyX9CSibLk//74ekz6/iEgHPJ9eAUBFOvw/D/xInWd8A4uw/0PEYUgntMUpNODROiTt5ooTRKWOlOhylXazjBEvNOK1Mn/R78HwBnBugjeCFKDh/2cGNPuXku330mU7qJMOBFeLk+S4vvephvgvDA2g3wW+EcYgTxeScFBFCrJiHXP7ciKNbcABknLlmPDYFHOhEfJKezhYuG+kBkTEM63OHc8ePMGmCeQsqz1v0/6BF9L7Bg90ydecyJikMTEwg34rSfXNAogD5LLST0A055N11JhRoW018CkRJ4w2u0Bw0KOBiYuHh4DL/O/TwsehTZnD8PLPXH3HzqyMWbkEU8Ise/WiH6axCjw1qxKnTp0qeCCnqNJjiUSRDnymn+IxwONVmtCIpzJnBi8RoYDPG5DaLRJgxabvMdpokc3NfgLALeJDQJuj+jB10huaMiPs+x2tlvv54gUWvyK3kPbDDtKcGFWZsDqI8iTlMyxFILBJ/4PFJd5EmGg/PuqQmGWZ+DEs/Yqm1yuF0yHj1h3hZk914le0j2HIW6WjH9GL6vM55scX2XpTTQQqHETly2EzQQh3IAKMu/ngLx89h3s9jh0e4xdjcUf0nPP5cQfd0OuUf/+N/zN/4G39DlZ+o1+uUy+VnL+JPSlXU6/UPPc+/+Bf/gn/+z//5h/5NQJJkdKXmazweV1F8eV3MkF3MoAkokIVWKMti7CKbfcmiycIrm36hNstLjK4EWEjtbgFaQTq1vCQrHDSsCoIRoXlLRkruWwCKZCISiYS6BjmPnF++S+7jYtb/z8rcyr+DtGcJZMh1Bmnvkq0WKnHQhCwY0Q8GQ+R75Xfy/mA7yecFUEsfSEYteM0Xrz34UyiYwgqQ/hJw+2FMiKCePniN8jNIFw9mp4Pt/GGvi9cpYPvDQLdkgKUvg98TfF1kb0j7BfXMEkwJyioE2AqQDr6CASfpv2CfCZNCNqpynqBHgmTWghR9AclBwB9kFVxkKQTvV4D/eDxWY0/GgowR+f4g00Sey4/qkclk0HWdVqvF1772Nb7yla8ogzDJAAubR+r9SrksoSkPh0MajQaHh4dsbW0pAy4BLQIy9/b21BiS4FShUFCmkQsLCywsLFAsFikWi88ESCKRiJLqOM68rrWUjNrc3OTRo0cMh0POz8+VREYAhqZprK6u8mu/9muK6izyCnEBF0d0TdPY29tTJbWef/55otEovV4PwzDY39/n/v37yrRMyhVKKTNN03jzzTe5du0a+XyeSqWixp8EKsrlsgKY9XqdbrfLzs4O1WpVsT3i8TiNRoNQKKSo/q1WS5XdEgO2XC6ngJt8VzgcVi7kEjyqVqtomkatVlNykOXlZeUU/qlPfYof/OAHtFotstksnU5HSZ+kn4XOXSgUVJ3mbrdLLpfj5ZdfJhwOK32xtGu32+Xs7Ew5rg8GAx4+fKiy0t1ul2azqajenucp+YGU+kqlUmpeEh8BoUD3ej21jkjgVNY2AfQSjBewLTR70VkHpS9i/AgoavhkMqFQKKjMsuxThKIeZNLJHCrXL0Fay7JUrfZ0Oq0Cz7JewNygs1AoqP3DeDzmjTfeYDwec+PGDTRNU0aCR0dHbG9vs7e3x/Ly8jOBztlspsqJSeb+8PCQvb09er2e2mPMZjNVyq3RaKBpGouLiyQSCcUUkFrkEsQRhooYiUqm/KN8eDkNKz+g+STP7d5f5TN8hVdYYkKDHUYYGIQweIzJ40QOb0EHEgynE/zkFDQTpgNmCw0e9g7Q+pdwwgko9jjPTDAP+hTGKxzmhpy4+8z6q7xEkcuUiWGxTpirZ1XOmgk2nTI/j8sWLcqcEiePRYFIqEck5jANQf0ohPs4Qs5wyF2zcXNwOT7jznDK+TBBpNbhDJ2zbBj8BeKOhql1WduY8Gt/3eKN/3mXnXcMkiZECjBtQ8qGxWsTxidP+PLsRd4ej5lM65Q548UrIyLJuUmbMYK9NzTePCjQqsSgOMCzCzinywwj71HctNHuwF4XVv4yFOI6m16ZxqTHzPCJ7HfIejMueyU2SDExfGqWRW+2wPbhKddeZV66KuOSPndpYKMPFun+0YTCVYunZzrtRoZZ5Cl1P0nKvkwl0sK9NsVY9Vl5/xjtIIJPmDQLRCIu4/wY/WRCRbPRfKi/D/muhhn1GV+Cx12IFuC5X3EItWq03rpMdnqZjr5LKt5mWYNWHMwpuLUQhq1RYMAZSXpE0GnRfLlN5WswNcDrzFUC7mSeiba70NtLUGEFnS79+gaP/ocOYW9CZ7JGixDZww72PZvq58BbhcM3yxy7t3mCyTozrnCIRh0n3CVrQrEIszjYi5COTPCtMDZxdC4xJoJBkwRJHBaYEsPCAgZ4uFhMSOIxxKPNlHWKRMc5/NQIMz/XxHtT8L0kGjcYk6CBjU8BH4MpFmHSRACXAefYnOIxxWeqGZC22Os5JK0JrUiPbiLDQefjbNDFnGhMnvZJ37CwejBpgdvVcPwkEMIhgxe6ghl9i3iuzk4xz39oZPnVcZmbfgiNDmXqLNlVdk8MHp53eDN8RmhyhaFukPCiXBp56MwYk6fiTvgcPf5omuTbkW38+O8yTd3gv44TXDvTGDIDMwWLDci/xYxb6E8XiY7jtBnQpEl8NKN7msZNVTDu2GyMfK5Y0NYTvBfXfhrM/ecHum3b5ld/9VfxfZ9/9+/+3f9X5/on/+Sf8A//4T9U/+/3+6ysrJDNZimXy5imqdxPg6W4TNNUQNQwDKW1C5poCaAObvoBRVeTmprD4RDTNCmXy884kbuuqwxZRIcnlHL5/Wg0wrIszs7OnqHMijN3kPYqGUgB+alUSi26cm0SpEin0xSLxWeytVKORkrxBPXTEvkPmr4J0JTssADkIH1bAB58UDrsIgAKGqbJOWRTJOD+Io08CHRFpy1tepEeLZkn2TwLkAuHw6TTaZVBlTJjQSfboAFZ8LPZbJZisUilUmF9fV0Z5nieR6/Xe8YwTsBEMCgTPO9F8Cn9KaAvCFalbS3LUpspmANLYWQIu0CAjFxHkL7veR6maSrwJIdca1CyIH0i9yTtLOcXozq5RtFNS3ao0+nQbrcV1RHmEga5Ntkci8O+6HInk4lyxhVncceZ1/a1bVvVKxbDvCALIsgKEN2nbGLlWZXvlX+Ld4KAOvEqkD4XgyLZpH/Uj0wmw9e+9jU++clPksvlVDY7Ho+rPjg9PVW05SAAE2Mt27Y5Pz9Xc5wwYAzDUKC80+lw8+ZNRqOR6pvFxUVlFLWyssLm5iaJREKZUOVyOTVWZ7MZ7733Ho1Gg3K5zAsvvMDS0pIKBohZFqACddVqlY997GOsrKyws7PDwcEB4/GYe/fu8dJLLymtq+ipLcvixRdfVEyojY0NRXHudru89dZbCuiJP4RpmmxubqJpGqenpyorLOUGJYgkY6vX67GxsaHWDZh7nYiz+ttvv00sFlNjend3l7W1NV544QV+53d+R+moY7EYa2trVCoVxSiRahfHx8eEw2E1RwkzpNvt4routVqN9fV1Re/3vLnLtswBwvCR2s+Li4vPVCYQs7JoNKoy/Ofn5yoIIWvm3bt3mU6n7O3tqee1WCwqLbGMt2azyXA45OnTp5yenirPFV3XVVZZaOgSaEwkEqpEmQTxZAyIvl/K1cl6HGRajUYjFUwRJpqsB71eTzHMxCle5isJTovj+3A4VPct872Y9mUyGbU2CNPI8zw1d0rpPZnjJWgiXgAiTRCW1qVLl9jY2KBSqfDaa6/x4MED3nzzTU5PT5XBXzgcptFoqIDlCy+8wP7+vgLOEjQROYgEOeLxOKenp4TDYQ4PD4lGo6yurqp+H41GyvdlYWGBz3/+83zzm9/8/82k9d/wqNsbJI7KXB98hY/zSS6T44Q2A0aYxKhSIUaCCW1CowE8GWHMTKKei90xsMYpWIjCFQv/kUV0GMFe0OFSG3yYdWOc5gf4i4fE7o/Z5yYOYa7wRTQ8lpnxad+i6zR5kRaXaJKghYXLiDA5FrFnNezxgFk7w93JOu+yzFUGfNK9w+LWiLzpEhp5MEnj6Dq1TAgnHyJR07hMm9fiDVaOTJ7++0V+fFriYWKF8eEeLz2xyJXAN6FwE/qjE2Zv6XxxVCSpt0m80GLjyz5aHCZn0H0Ib/1xim27hJubQG9M+ThE1h2z9dcstAzU/p9RJgceTslm1vfw6bHmhNEciwgD4kCZtymHjzmehoAMrm9wrsONHAyO4K16jBEVRowp+TfZeRJiYXiPmy96fOMPBzR7GUakWWbMerGD+QWP+hIkpzbFk2PCToZdqjhuGEZDDC2E5qQZTSb0COG+n6K/1CN6zaebh1AXygMomD6W0cW1C4T8c9KnUKtrNDtRFocGESeMzpiw0aPrpHGoUk2M4CWHnTKY55DMgeuD4UI4AufvQagVY8ge54Touy4lx2ZkafSJ4lGhNehxfueAYd9jp6Vx6paIEufjaMS1U+L5HTLmkFTBIxoBzQPPhXgKsqERHiGGZJnPCOfEaaGTpodNBwMdE4MhcTxCtJlh0sDklDHZPykkFk+CroFdA7+m0bcTDIhSZ8IZLjGiaMwY4NFHx8IhSQQXGxjik8U2fKi49JI+53t1jLCNeynDOw9M1kZX+TgZEo0h3toe8eLcgX468XEGHiYuEcZoMY1xOILWcnELLo+mHt/o/BxdHKI8ZIsemxyzQIHPWXEeWhb/o9bmu88ZaG6T7H6F1DiMpZ0z1WZo3oSPuSm+O0xhV/owthinVuicdSj7BYa+i+tuow328MvrWOenHIzDPOaQKVEWvFXSjyLspAxcb4RppSiS4Ja3QGT4Jb7D9k885/y52FMK4D44OOD1119X0WOAhYUFGo3GM+8Xw6qFhYUPPV80GlUgVl4wL5cilCgBukK5Fh2z0LSDJlEfBsCC75UNvIC9i1pYyaBJtk8+F6ytLaBRNgviSCs6MMmMBLN2FzOk8IFWWs4f/I4gMJZNtIB+yfYE9exBJ+rguYNg8aIjdlC7K69gBjKon77YDnJOybQG21HAnlyLgDLJfMl5BARKv8kmXYIiQTOsIL07yCK4yGgIasGFESBBlGD/yRHsl4uZ92DmO/i+D/v9xXEn93axD4KvD8vyB3X4fxYL4aIWPZgVl/4KfueH9dHF3wktUdoyOBYuZqQl6HFRQx4Ev2KMJqA4+NlgO8m5pR3kmoL3GQwyCI0++JwGx5cYBgqI+/M6fv3Xfx1N0/gH/+AfqN9Np1P+7t/9uxQKBZLJJL/yK7/yp2ich4eHfPWrXyUej1Mul/lH/+gfPcMK+P/0uHr1Kr/2a7/GF77wBUKhkMr0iaGUUMnj8TjLy8skEgkVwHRdV2WrY7EYt27dYnV1lZOTE2UeWS6XmU6ntFotKpXKMwFLKQ2WTqdVHexut8vBwQE7OzvcuXOHd955B13XyWazbG9v8/7773NwcMD+/j737t3Dtm2uX79OoVAgn89TKpVYWlrC8zzOzs5U7Wkp27iwsEC1WqVWq/Gtb31LZXej0SgrKyssLy+TzWbZ2Njg0qVLdDoddnd3OTo6wrZtkskk+XyecrnM4uIi2WyWl19+meeff57j42NOTk6wrP93e38eZdl51ffDn3Pneao71FzVVdXzoHlozyDhARMSMG+I8Rs7QEwgcmICi2XIBCEJ9gprwQoJcVgJsX/rxcTE/mGbyDZGsjVYUktqdavVc3V1dc3Dnef5nnPeP4r9+FRbtiVbUrul813rru6643Oe55x9nr33d393j5WVFdLpNIlEYpfGQiqVIpVKKSqz2Jp6vY7P52N4eFg97/f7yeVyZLNZvva1r6m+1qlUiv379zM2NkYoFMIwDFWzbi0RGhoaUqJgmqapa2ljY4OtrS1FVbe2ORwMBmxvb6va5MXFRVV+IjXLsBOokWz41NQUW1tbqqRL6sCdTidLS0v0+31WV1dVGdZgMKDZbKoAuKZpytkWcTEpEZiammLfvn2k02mVvZags1UjRQLlyWRSlY9Zbab0UBftFF3Xd3XMuL7ftDi9UgIlAT8J0sl8SQa80+mwtbVFNptVJVli25rNprrHC/tDrrGxsTFlY2KxGIPBQOkTaJqmerUvLi6ytbVFv98nl8uxvb1Np9NRAQ+pKy+XyxSLRZ588kmWlpZ46qmniEajjIyMKLsqgaZYLMbZs2cpFos0m01yuRwrKyuUy2Wlv9ButwkGgxw4cIBIJKJKDcrlMvv27eMtb3nLy7Y5Lwc32j4CxC/fy1vLH+ZO8z5CONBp08QkTIIRQnRpUaLHHAHu640zlgsyXvaRHiR3FM3GfGiDIYafCfDOjcP8w/4Qe7dWobSBNl9G66UxhzqQLxFqjbAPOEyHHn62SbJNGhdh9jEgjYcKM6zyo1zlzZzEzfN0cegeYkU3C+0pThDhpKPFSdKc3Zyjf03jABpRwwcJH/pskMHIKAQNNF+WiBYm2h6mWJ6lufguvL23sjk6yRPZfXzlTzOc+Asfxec1vG2YeKvJ+I+uEj1wlum3bjP7dpNSAZY+42Htc076XQhFYYgQzvIoo7lp3jqo8OM/usjh+2G9CRtdD73CBCtfcZKO9plOPM0kmzjQMAmQpkNm/Byj92Tx+jWKRNk0ohiFIKM+GB0Bf3RACJ0EJhXWWCmkeeRPorSeBb/uIWYeJWkeJcABQvk5Ahc1Em5w7APXVAvTU6fNgP2VKMeWHKQME8304YuA8806GwEv5bNh9DwMnNDoQl0HXYOBs8o2pzG1LM2ai6urYbqVWbqDWRrMAIdgMMWYBgn/Cr5btsjMQm0L+jUYB2JdCAfBdML2NaBvkHdcpYaBS+vTd5qUzT0EGSZMkC3muFLbz+YLQ/RXwgSo4mOFDFmmItfY99YaqeMGgRnoxiHf/VvHLQHO4Q5+upTx0qbPMF1i+AiSwUkfjS1MDKo46RMhwhA+Kmi0GBDEJIDTr5MaAa0FXAaWXBQZpU+KCg62HDU0WrQxKNIDnOQZMKDPPtyM4KRPB13fgloWrdsmQJOo1oehLrWhJmfQWGSWTv8+qpeGMNsQH4GxcQh660CeKVoEqn0MXwi95YeOm76vyrMe+JxrRzlggJucViHLMh3WOECdvZg4Qh7MfU3KdxRYO1gkO/RNluaW+UtfhRhhDhenMQiCu4sxE8WMmLyDKCO9F/CYzxNqttBa8+iZa1RcZQ6S5BhjxGhzzAwyWj/AwB2hTpsqTfqUSTH3fdmcVzzTLQ73wsICjzzyCENDQ7teP378OJVKhVOnTnHHHXcA8I1vfAPDMLjnnnte1m8dPnyYiYkJRbOWrCx8i6os0Wur+JVshsLhMA6HQ92sJbsom3drTa1k06RNiDiVVmdGBLharRZer5disagc5m63y9bW1q7actm8yIZFsqWSvRNnB3YCDNaggdTrSmsPr9erVMqFfmhV9bY6cuL0WOtlrbXdkk10u92K/ifjEHqnNdMqWe5YLKZUknu9nqpdlPmx1szLsQilVSLzMnbZPMk6SjBEsijNZlNtYMWhqFQqasMvTp/Ms8vlUoEIEZ8bGhoinU6rcYsauzAchKFgda6tG1ipSZa1k02xBGysARrJ3kgGSRR3rT1dZc2t2R2r2r71vL6+nh5QdeDValUxHqy9cK3aAFZ6vpxv1wdbhI2h6zr5fF5liSORiNrkyTHIRlfYCjJHklmTDWcwGFTnn4zD2ipI6r2tWgCSwRIH3lrXDd9qlSfHK79nDQiJwy3zJSUZrxZOnjzJn/zJn3Ds2LFdz/+Lf/Ev+PKXv8znPvc5otEoH/nIR/jpn/5pnnzySWDn2nvve9/L8PAwTz31FFtbW3zwgx/E7Xbze7/3ey9rDG9/+9tVhlUciHK5rGxGIpFQ2g5zc3Nks1nW1tZUS0PJ0r3zne9kampKCdU9/PDDqvVRq9UiFosp1lEsFlPU2nq9rvp+r66uEovFCAaDrK2tsbi4yNDQkMp+P/fcc0o5XZyY8fFxlf27cuWKOnez2ayqvz179izhcJhbb72VqakpPv/5z2OaJpubm2xvb1OtVpmbmyMejzMyMqLqj5vNJo8++ijNZhOPx8Phw4c5fPiwot3Pzc3RbrdVnbIEl7LZLL1ejze/+c2kUil1ncn9QbRFksmkcnxzuRyVSoWJiQkOHjzIlStXmJiYwOfzkc/nqVarPPnkkxQKBfbs2YPT6aRcLisBMLfbzbFjx2g2m4oZUiqVFH3YMAwl4vXII4+g67pqPSZienL9i5MtdefiuA8PD6s6/3g8ztjYmAo8CFW/2WwyPj6ugsXDw8Nsbm6qemKpPRZVeGG0DAYD3G63yqgL20rq2UUMLBqNkkwm6ff7+P1+1fpK7htiB6rVqqpTlnt+p9OhXC6rbK0EoYXtVSqVlBK8CGJeX3YmZRFCYReGmXUfIbYylUoptXu5h2cyGSUsKGy1UCjE9vY24+PjrKysKLZbJpNRzJ1er8f8/Lw6F/fv368CC8lkUnVgKJVK+Hy+XVopTqeT2267jZMnT6rzQmrtQ6EQ9Xpd3T/q9Tp79uzhrrvu4ty5c6ytrTEyMsLExIRiA9TrdcrlMnv37uXAgQOvjDF8Efww2EeAt/XezgRxTAq4SFDFjZcuQTzoOBgiTo0yHSr8KFNskeXE+BrtAyEYKUPLIPVomI9Vb+MIbXrkSDcn+O9nm7j7MdyGl7V+B1MfJmpEeStuoiS4iMZlOiy46sSMMncZafLEmCTCEA6+yTrntC53mjp7jD6hzgbfBM5qFYaNPiUGPGP4mah7mfP0ubUdZP1Ci2Zcg34PilkaGR/f9GZwbcdJ0+c2NvgxPcDC0joFI8Qjxts5fbbKj13cYO+BeWI/0WdkBlrBAZFpaHbh0a/6Ka/dQsib47DjGkfuqpFrPo9r7c3MMEc4/E0mjnVxtsG5AQ4MsmaYfsvP8WSDdKxBu7RFEy89/DjcVcIzPXyHIJXVCSx02SJEruTlaqXJ+Bzse0eTa189S6Zm4DNbbOn3ULowx5MLZ1jpxZghTggnF+ji6adJnVnGf0eT4bdCbI+J88E6e0+cY8iMMRjfIBfr0Os5mb4X9CA8/HiIQSvCwdUazSZsrMNIE1zXPDg6Lros0TGmKJUPsk6HOB4iRBnGyxBRctoaQ/tOE7irS3kO/DFIe3Z6crubEBwHowceHXwjsO2M4+jH8ZDEaR6l3BqwSogeLYbQaZIka2YY6VcY5TweWnRx0qSM02hRPKuxYTjwOE3CDoOxA+AL7qiX60MDahTR8OOkgxMXfdxUMCjQwkMND3UgQAcPZSqE6RHBRYYxhukQHxngjEDpPDjXod0J0WcEndBONbhm0MfJAI0efVoYhIEpBngw8eIhjRNNN6hUHOhh6DtMRpppli8VaPsCvBBykmykOMI9mOVLmJtPocVMPHUI0iNLmQn2MrUe4exQDepN8CbQtAZoOhvJHifKTSrdEbzmEEdoEcLARYC9ZgzXko9eLQauAuZwEG29jjbwsDkSwbkU5pbqcV4o5Qn7r1IbilGdihM7d5jkIEjR28ffhZZzBT2ZwOOa4+DgLp51n+Nseo3G1jAxYxJ3LYgbJyXqnKZMionvy/a9bKdbaGKCpaUlzpw5QyKRYGRkhJ/5mZ/h9OnTPPjgg+i6ruq0pe3MwYMHefe7382HP/xh/vt//+/0+30+8pGP8A/+wT94Wcrl8p3JZFJly0QQykr7FVj/lgya3LhEuVo29VaqMHwr+yjOp7We1+qQCf1XMnESOZfWJEJxFGdQas2sN/7rs87XU4cF4pzJJkrmQG7EkhG1Unfle8QJsVLdrXN2PQtANhumaaostDiU4vyIUwMoCqCVmm6lCVuP01qjbhWpEefLmsUV+rXVAbZSIiWrI3NjdbxkHUTZ3uv1Eg6HFcVd5kYcXWtbKyvrwDoWwzB2ZaulXu/6rLUchzjQ4vRYGQxCmZX1+E7Zcmtm2ZqVl3NPxi4Pazs2K/vAeh1YqfzyvPX8kaCGCMp1Oh3FDrFmka9nQ8h3ynUgzjx8K4hknTeZK6tGghynBILkXLUG0eR5CRxYW/vItWxlFkiA5NVCo9HgAx/4AP/jf/wP/sN/+A/q+Wq1yp/+6Z/y53/+50ro61Of+hQHDx7k6aef5t577+Vv/uZvuHjxIg8//DCZTIZbb72Vf//v/z0f+9jH+J3f+Z2XNW5RhBaarNiTcDisMm1ut5t0Os0TTzzBc889RzAYRNd15aR7PB7VG/jSpUtomsbdd99NOBwmn89TKpVIpVJMTk4qiquu62xubrK1taUyfy6Xi3g8TjAYVIrKpVKJ5eVlxVSKRqNsb28rQUnJoItatPRalpIBuc7Hx8fRdZ0rV64o1Ww5n8Qxmp2dVYEZh8PB1atXuXLlilKqDgQCvPOd7+Snf/qneeaZZzh37hyVSoWzZ88yNze3i4IsKt6lUgmPx8Pk5KSiFcfj8W/rWCGOvM/nU3R4cToDgQDVapWLFy9SLpeV8rTQnDudDvv27WNkZEQFI0X9W1TYRYSxUCiogPHly5fp9/tcuHCBaDRKKpVS15YI1e3fv18FCqXtZTQa5e6771ZrLpntUCiEaZrk83kWFxfxer2Mj49z5coVAKUKLjXffr9fUd6lRAB2nCYpmSoWiywuLqrATCgUUmwEUc62dr5oNptq/PK8BGrFBkmAVu49k5OTVKtVKpWK6onu8/moVqv0ej3FihEHvVarKRHWWq2mgh5WZXQJJmSzWSqVigqwl0olNjc3CYVCHDp0SJ0LrVaLXC7H/v37VbBVmBFzc3PMz8/j9XrJZrM4HA5KpRKZTEa126vVaruy+IlEQtmzcrlMJpNRDAMJ9BcKBe69916+8pWvqJKFTqfDwsICpmmyurqq7KqU5bRaLQqFAmNjY4r2/2rgh8U+AkSJ08ZJiz4tGrgxiDLARYgEDvJUcOJmhCmecD3C+dnP054aoDkmMXt7cF4LcqzsZA8lqhR4ni5dxjneuZsKYXLkcQyKeHtpbmWSEFGexsvX3TpF3xa9kW02OmWWsya+vpsjWpyo08c30hUafpPogpMl4sRoEyRG26WzZW7TTteoN4qUHD0aCYN4RWdkPc5iawXTkYOqB4I+at4+eSIcI82Ai1xmHX1QZC9u+vS5RpTnB1MEVhvMdJZhDKoO0ExYfB6e3x5mwWtwsOsneD7Ij723yd+frfD0qcs8qxV5QnfwxKfj3OLUCVaidHs7FcPjvQ7tc15KG0E8uJjAh0GUYHiT6FEI3QGRrQGhhR5eohi6C9cAHD6YebfJ2L4Cg5M7TmBg/hyV9jSXejFKNAhRoIeTdc1BynSjuTXGYuAaBi0CqS3w1wqk5grE7oV8EpY7AwJ1GHwDau0aOSPEzP8M0feZbLR12s04iXYGgyoG25QoUmMWDzN48aDTphS8TGXPNs47e8Tf1MM7utMOmg74g5AOQcYEzzY4zkI8AP4kfNPTpqfH0JxZEn0fw/gY0GIVL27qTDrniXoKuAwDQiX0rodQw4WLAIX6OIv1EFfx4cfDVPkFJo41cA2xk+7WoU+bGDUG9Gli0MfDGg06eP5WF0AnjhMXDty00RgQxuQITrzRU0y+rUZ1CypnwF9xUjdi+OhRpESbPm69y7aWpW1GCBGkRZURggQI0mKJNCGSDLFNlwtdP7Wgjq4ZeIwI3q0svYkKnTEvq4tFrg3G6TJBrOTnoNYi7oBowKDVM8maQW7v7qF+OsyKP48RdhDNT5Psz7HSuciVY02uaS6cxXGyqwY/1w8T5yh1rYOxvwqVMI5lH0ZigDkUhq6Lui9AFg9pcxx/MUE4vkS7uEIp0GVFKxDovYluaZWe4zK6PwPePvnwFb7aMdnyrNIYdbGeM7jVMHB7fFwbblFfKTBjjNHC933Zv5ftdD/33HP8yI/8iPpbaq0/9KEP8Tu/8zv81V/9FQC33nrrrs898sgjvOMd7wDgM5/5DB/5yEe47777cDgcvO997+OP/uiPXvbgZ2ZmVG2YOB5Cg5Ubarvdplar7VLqlho5yXrJzbrT6dBsNmk0GjQaDeBbjom1x7c14ywb/euz6XLjlxpTyfhpmqZEWsR5kb8B5SSIAyKbWMkQSnZXqNai4C7ZO3GWJCMgGW9gV99yqVuUul5AOYHyfRJQsGbzrcclGxyrOrU4txJQAHY5g5IRsmZdANVSRlgBUvMsgkHSC1WcPmvGVzKbVhaB1PK53W4l3JRMJhWt2Ov1KoaEZECsSs+SNRcWwvXifxJUkbkQUTZr0Mea7ZXsiQSHZB2t6ymZalG1v144zhoMsdaKWzPrkhEWh/t6KrY4uNe3wLP+X9ZfzpPBYKC6EIg4nqjii6K8bJqF6SFrIteGnEONRkMpXgvk3JBsnJznEuAR588afJIskqy1VStAWCpSYiIbXaGpyrX+atV0P/DAA7z3ve/l/vvv37WpPHXqFP1+n/vvv189d+DAASYnJzlx4gT33nsvJ06c4OjRo2QyGfWed73rXfzKr/wKFy5c4Lbbbvu23/tO3R0Gg4HqPy01uXKdRSIRVSObzWY5ffo0e/bsYWNjg6mpKRwOB6FQiH379tHtdvnSl75EtVpVzkm73WZtbU3ZKjlPstksm5ubnD9/XrGIpIZcal5dLpequZV13b9/P/Pz8yozJxT4ZrPJxYsX1fnvcOy0OSqVSoTDYUVrX1paYn19XWUgRURrMBiwtrZGtVolmUySSCRUjW0+nycajbK5ucnMzIwSQnO5XErEShx3cVz7/b4SxJJM6ObmpuqHvrq6yvDwsFL1rtVqSnFbdBHS6bSyZwCbm5uKLaDruqL8SytEyTSLOFm/31eOq6z/s88+qzKawWCQUqmkaOciGibXlzhw+/fvJ5vNcvnyZe68807e9a53MTIyokTOpP4YdgJ1jz32GCdPnmQw2FFVT6VSHDlyhFarhcfjYXh4mFAoxOrqqnIQR0ZG2Lt3L7FYTOkGiO2RtRaat7XVp2T0RVRNApBCw5a+3aK/Ic6niJqNj4+zvb2tHEdrmYvYCtEksAaBhanVarWIRqPKjoVCIRqNBu12m7GxMcWqkbnt9XpcvHiReDzO8vIy4+PjRCIRnE6nUmCvVquqT7mce5qmkU6nVYmDsE+uXLlCKBRiaWlJ3cvi8Ti9Xo+RkRFqtRrJZFIxqFKplLp/iF0bHx9n//796LrO2NgY9Xqda9eu4fV6uf3227l06ZJitojAWjgcVuUNwmx6pfFa20f4zjaygs4EozQosEGBI0SJ4KOHEycRNmjjIci8M8cn7/gi/f1r7P+rO/BXb6MY0hhtB/kpI0qfNv+PVuAbM+BtbbJ/O0BWa7M8tYwZGODe0PFWdKo4eNKfZ2vfGlTPgcODsadPfahJPTfGI5kQZPoQMKHWor6Sx9sL4cLkDipc1rtc9JQJNetkOlWCTmhmPTzvqLKyp4+pV/A6S3R7QVgvgRbBSQwvPZYZcIIRrhEHLnO3VmTaPEILB8vdAMeuQjICidGdLK3Zgy1fl+Zcj/VL2xwomvRXIO0Ct2uZBV+B/IEjFJaOYOQ8HMbBCCYDthkqDeMsTeFCw8NVtshSI4JRm2Nt5TzpA328TgNncB53M0i05GGkBf4yVOZhDGgmoW8CnTKb8ymi5iy3s4rOFQoEmDEniLPTo8znAVcb2tUdVW99L3huh+IQ+DRIN+G5L2u4TvvwD1zUyXAht4ckA4IU0fEyT4IBYWboE6NHixBB9uEjy8LIE4z+nW1m32viGYVWD1omBNzgKO4sVxjIfwNWHw6hL7vIxKqkkib3jK/QHF3FEzAZuXqFUNOJKz/NePcttLRVkrecZ2/aJLqyk+Btmn082jyauZ86U/Rpkfvb+unR8AB/DAJBaG5Av20SoEKKNjomBgnWcJNHx0sUNw6cGJRoUqZFBgddooTQGMNLNtAnOmJi5qCzDr1mkgGT6HgpAT2caFqDSgjqfY1MR8ODjwpuNnAwTYIELgZ4iTJJodvFmW0zZoxRo0pXa0FXg2SbK3t6fH7pEvsGB4nVlhnzPE0kCE4XJDQXbVMjR5PEYIxiw4/ezuMbRMk7wV0fgZUhzLlVOvsmOG0GuOOahpcUpzznGMSdoMcwiEO7CxNDsNlHryXJEWEPIXyFcRrps7j0Mnp5lIRpMso459bvpB4MAWPg26KbeZatio+J5u2sPH+JgbHGMCnu7od4tt4gbYa5h/1ofH9ByZftdL/jHe/YlUG+Ht/tNUEikeDP//zPX+5Pv+j3SIbU+hBKtbTnaDQayoECVBRcqGHArs9J1vTFspdiuK2OlWQg5b2S2RFhmEgkojaM4myKwyuUOcmGWhWVxSGWrIc18yfvF8fUmgGWDbC0+mk2m8pRsmZJZcNspWJbnW4rzVg2JtaaaMlGWqm+VkdYxmv9DSvNWRxBQG1gRQRPnEWHw6Hqda3He32mWdZefl/qJr1er6K1Cv3eSssWlWv5jVKppNRvrd8nmzGZX3Fuxem2Mhrk98UZlkCA1AJaa5Yl4HO9eJj1s9fXhAuur8u20tFf7CFzJll1K64vy5BMiny3tPgRgT7J9ohTLYEXqS2VtbEyHGQcog4tv2EtQbCen1IKINkLa+Zffg++Vesvm04Jrsk6WNugybzKWrzS+OxnP8vp06c5efLkt722vb2Nx+NRQnSCTCajGEHb29u7NpTyurz2YvhO3R16vR65XI7NzU1lK+v1OolEgrW1NZaXl9ne3ub06dPMzMywtrbG+9//fsUkkDKA+fl5stksTqeT1dVVJVYo1GSZ61wuRy6Xo1Qq4fV6yWQyuN07fatjsdguPY9EIqGuy62tLSYmJviZn/kZEomECjo9+OCDzM7O4vP5iMViqt0hsMu+ynWuaRper5e5uTkOHz6srkUJpg4PDyv7Mzs7y9DQkGqJJw6qtPo6cOCA6pMdDocV3bparQI794FUKqVqaPP5vMpS5nI5gsEgb3rTmyiXy0o47OrVq5w5c0YJYXq9XhYXF1lbW6Ner+N0Ojl06BDj4+Pk83kVHCyXy0xNTRGNRlWwVPRByuUy58+fB1C11JqmkcvllH2T8hlx2jqdDn6/n4WFBer1Oj/3cz+nAi3Sd1rsvmTrz549y5e//GUAVY8+GAx405vepOrKJdAgwnuJRIIjR47gcDjI5/PqfBF6u6ydBEenp6cxTZNisah6ZwsLQRxVCaCLwzs6OqrKrSTwJwE1cWyPHDmy655pDcQLRV3sroxfmAkiyCg6LICiyfv9fgqFghKeW1paIp1Ok0wmuXDhAg6Hg3Q6rY5RHG9R5y+VSmSzWTKZDEePHuXpp59Wfe5rtRqnT5/GMAxVmpFOpwmHwxw4cIBr166pNnSapjE8PKxKDTKZDMlkkkajwZ49e/D7/XQ6HVX6I5n/VqtFo9HA6XSq+vFOp8Pa2hpOp/Pb7NQrgRthH+E728htenjIUWCTDAnC+OlTJ0Cc86xxkmW62hYb+/+c2h1bzP3l7fx85Zep0yNR7xPEIIyTM1qTb063aE24aeVXOOlpYrQ6mKkaBOLEVw2iaDznrLNxaANS8+BxQGwcwhXQG+CLovUyOEo59IoLZyXJSM9BiDZblJmkyS8YMb7RCdLqZFh3uviMM8+hcpr1qI/+oSRkV9EaBZxdEz3UgYiBvtLFxyoeloiyl1sxmBrPcTjWpzsfRevvp6dHaeXAtQ7dKDgSMBODccrkBhHqUQ9adoB31UFp2KBnpjjSPMjTCzmMjpuwo8tUcpWxHlSqQcBF17tMctBmaOAET5ucvkx38A6Kj5YptZcJBOHtt1YonXkS77BJ3A/XnoKLf+LD1faTMJN4DVg086yZBmVaOHFzlAjj9MlTIoaBr+rFtdpkZA4CMdAnoduCah5yfejnYfFzMQrZO3EZTXTc+HDTZBs3Ltw4SGHiIkiVKTxM4KVFkAgl5zyDo08x9vMFmIKcE7wV6Dch7N4JCpg+2BOElbPwtf/rpbAxhab5ObRiMmgtcvuHKvRmTNwGTOR06lWdZPUqlW+uE4z0OPhzJpoTCp+FwEKGiB6ma5o0iWLgxYmTAEPMUueo4aSnQy8P1fPQaQ5w++cJJMBnQj47Sl6fooCbAS3SaIwwSheTAXU8JPETo8sGPVrkczGi39jgSNLEXXbtKIjjo0WAOi2gg4YHnG7o7+T8DZqU6RMjwvhO2IM2BhfpsE2NiAEaozjw4NX99KJ5iHXoBr2cay3R37ibA+aPcLFxBadeItUCv9kiRJcSDS67q3gHcaKDONlQiV4qR2ItQyL3Vrb8X4egidZLUCbNZx0dXtijwdoidMbAk4bVMNx+B46VJW4pTOIkQw4nzs4YdV8GvdfAl5ugSwqDBo7eDGgBCHXAbEPYTT1ZZD1foTXeoO9uUF1wcOfgAO5CkhYdzmqrmGTge7u734ZXvU/3qwkr3Vs27fV6nXq9rjYlcoO3OjkSwbWKqXQ6HQqFgqKdWanh4njBtwcVrndG5TmruJkIuQQCAdVz1OqIWLOzohYtjrt8bzAYJBgMkslkdlEdxZGwtgsTB+PFRLpkIwXsUn2WMVhr1yQQYQ0SSIZbnCFxbKSGU5SJ5V9rllzGJo5Tp9NRQkOS6ZCspTXIIZtmyUZLtlXm2pqht9bvJhIJ/H4/mUyGYDCoVK0lOy9rJ2MVSqtsTGFHVMjj8ShBKVk3eb9VVM5KyZbjttLprbR0mW8JWoiqs8Ph2KXCLhkqa2mE/GsVEJN5lbm2Zr+ttdDyPpk3K8XQei6Lwyvnj7AuZG4l2yavy7Ui54UwQuT8lfNKIMErGY8EpSSAIf1orfXysnEWJoS1Lt1KURfbYD0uCczIZl+u8VcSa2trfPSjH+Whhx5S19hrge/U3aFWq6kaZlE1lt7dn/rUp1hbW8Pj8XDbbbexvLzMO9/5TtLpNOvr62QyGUzT5JlnnuHBBx8kGo1SqVSoVqtEo1F1XTocDg4fPky322VjY0MFCkX7QTb7YkOk9RbsbJbFbrhcLvU9Dz/8sDpXrl69Sjwep1qtKnskzqSsdzabZXZ2Fr/fr+zbzMyMEo5Kp9NKO0KuEUDpR0iLK1HaNk2TgwcPqus8mUxy5MgRJcomzJl6vU61WsXpdDI8PKwce6Gd79u3j+3tbQKBAIVCgTNnzrC0tES73ebAgQOK0huJRFQLJwkoSl/qWCxGoVBQZU9WpoDYT0AJyIljmEwmlUBapVJRbAPpHiDO4o/8yI8wPT29K9gr8ytlS36/n9XVVVqtlgo+SlmOsLj6/T4+n494PM709LSqfZduEBLwKZVK5PN5ZXfFMZVgnRyX3G/kWERFX5x2q9K5ruuMjo6qe5Omaep+IuJjiURCtS+LRCKsr6/TarUU00yc3UajoTL3ku2XfYXcZyRznEqllLaI/ObGxgaTk5NcvXqVI0eO4Pf76ff7DA8Ps7S0RKlUAlBidtINolarKV2TWCzG1NQUV69eVbbU6XQSj8fpdDpEo1FuueUW9u3bp9ZNNAtEPV66Ekj5RD6fV+dJsVjk85//PNFolNnZWVU3vrW1xdraGvPz80qf4ZXEjbKP8J1tZJUqKzTxEcHFEOuUcRCnQJcT/v9GLn6WdLjBgXfUaTwzxt25DzBDmG3WGSNKFw9f5SKP+D9Pa6yAYzmNttZGP9QCtxdWHLhML1P1aVYxeHRkkd7Ixo4ceH8WrrrAHYZGmnC+T7zfJsQQdafGsDHgzQzQWaCGhps0h6nRJc1nHBEuzLUxhsJcu+DGXY+SerJOuJfEGDTI9TRa0QEmGmuan3XTwUFflUD6aUzdgS+uM3M3rDjPUXrhFjL6PhzdkwQjA4we6BWgA+m2nz2XfLQ1qOChsjhGYaODOfBxOymaFQ9VauyZWOToB5sUz4Hvq2GGHE0CM1UaWR/V4m04e15GKNBhkUjDQ+m5IJ6farLvVtjydAmOQekZuPilCEvFIUqEmeAWRunRpIALNzWWKeNklBkS1CixTp84yfI4jeeraG/W6bnAZYA7Ae1HIdgBkmDUQriNafpsYVJjmiYpanRdVRpmgIo+jIMF9lLCxzg6bWKOebp3rDDxEy2C09B0QsKEFFB1AS6I98Dlg5Af9GVgJYhXA83wEDLd+Ie7OGahBHjMHeEw116YihnsOdxiUIGhAQz6ELwb6ptNSmtj5BmiySR9DDZxoZFiGg9+3UmvCWYR2pugFzSIDkgeAG8b+oN1hvOwbM6w6fQQ1g0cDHAyYIhpQmjANRzaPDV6+PUk5QtuiqM94q0wRUL0CRJhCBeL1GniNF14GnX6vggNLYDLbFCmRRAPZZL4iFCgwlXq9HGi42YZnShjxPUkdWcdYh7Iuxh4aiw6N+nrE3i70xzxVwg4DXr0GKZPzOmjmWlj5MAwTXp7mtCN0zNjO03aypO0590c3PQxQ4CL3hL6sBvqOcgkIR2HKx3oRdF8t5Ax9+LFiY5G2kyQDR2CaY1OKcYTlT5V7yb1eBcibojloeWGzAxe30l07XmM8DjOyj5MktSoU2eLS6E1auELGK4UrL18W3RTO92SqZKbvoigiYBPsVhUNG4r3TgcDgM7hlcor7VajVKppDZ3srmxUnqBXc6POPHWDLQ8L1HyUChEPB5H0zRV5yYKplbKnzgPUuMtmULJBko/TYmcW2nXQs2VDaRkBuXzVodP6rIl2yiUfKEUWh1C2eSKEyrUNTlOq6MrLAGhs1szj1an21qzbFWcFjq/iHLJxtzq9EurM2u23Oo8ipMomQtxsq1Kv0IztgYWJMMhG1Q5l4Ri7ff7icViu3rKAkpp9/o6fDlmCepYM9JyDkk2UcYrtbTidFcqFTVOq3Mov2Gt4RbnR64FWcPrKefWscqcCQ1UIO+R+RRYRdFko1etVpU4mjjqVkq4lSEi142Mz3pMVuqwZC2j0eguBWIJQEnbNqsDb61Vt9oC67kszAphhUj3gFcSp06dIpfLcfvtt6vndF3n8ccf57/+1//K1772NSUwaN3QZrNZ1blheHiYZ599dtf3inrvd+vuYF0rQalUYmJignQ6rZyQwWDAZz7zGdbX14lEIoyOjqoMXTqdZmtri0qlgsvlolAo8Pjjj6vsuGTLpaZa1IMbjYai8kobJqfTSSaTUdePZHblcz6fj8OHD6vAiOgciNMu69TpdFSt7+zsLP1+n4cffljZwHa7TbFYZGJigvvuu49yuayELMPhMIuLi6qFXSqVUo5ZJBJRqtnNZpONjQ3Onj2rWgi2221mZ2dpt9uMjo5SKpX467/+axwOBwcOHMDj8ZDNZpWtlexsvV6n1WqRz+cVnd3lcjE/P8/m5iZXr15VpRXSJqvb7SqVarme+/2+ohbv3btX1WGLEx8IBFRwLh6PA6h+3aa5I064f/9+IpEIq6urjI2NMTIyoijSfr+f/fv3k8lkKBaLjI2Nsb29zebmJul0mqmpKcLhMM1mk3w+T7fbJZPJKHvscDhUYEfuEyJmKo6bsGNisZjKyOZyOZrN5i6qvgS+pZd5q9VSJWBy7/Z6vUxNTRGLxTh37hy5XE7dP6SVWjweJ5lMsrW1haZpKjgkwSa530mw2eVysb29rfRWOp0OsVhMBWG73a7KHktPcwnC9no9gsEgyWRS9ef2eDyKJedwOCiXy0xPT6PrOtFoVJ3rg8GAy5cv72qx6XA42Lt3L06nk/HxcWZmZsjlcipgINoMEgAVET9ptzY9Pc3a2pqiUcu5KfZXGG/JZJJYLEan0yEYDHLrrbeSyWRYWVlRegr5fJ719XWCweDLtoHfDTfKPsJ3tpENyriZQCfFGnUmCGCgs+z+H3QOfJ10bMCBFFyc9zG4/KMMGWk2KHOKLpPoVFjnQdfjNFPXiLsHFKZAH0qBpwteJ9SncRfTXAw0ODm0Td8Xhc0A+Ls46h3uWc4wajp4SvNjmAl8eIng4Zge5ADXuJUCBl1MwM0QGlX66GxFNbTIEu5uh248zt2tS4yVJ3ByJ04m+BvHYyzHUlDuo5tdVhllxh3lR0cKlMM6rTh4OxBOdlgc/3+pbx6is5QhdXCDQBIoQVSDtLuHuz3GKgan2CRtHGdPq04m/AXa2jXurA3R9jcYe2udYhW+eCaJYY5ye6+L9yrk+i5MMqxrITY9Gh1jkZQ+wlD1CDPPPcH9h3IEfw48blj6goP1rWHOaHXaWoGe4afDAC9VBkSJMsQ44KDNGn6qJFgmj9PUuWvRxcyqTisNjiwE3eDfA62vQm9BI93r4MCkzghD9HGh0QH2v7VGeF+NS9k8e8IGU6dcNC5O0MakML1K8qd0+sPgLMAd4+Bdhd4S7M9A8yA4wzBRAq7B0pbGzMBPW+uD7xqx8TITd3fxnYOJTQf6HgPHvh3/c2sF1r+h0cm5IOckVvaTnO3giDXIb66wpc+yTQwvdeIMkWaA0/8MgTfV8QShvQiBq2A2/HS0Dq5lA28TpoIGsWYOb3MEp56mi0GHLENo+BgQD58jqRXZrE0DIWI46VadlJ3rxA03PcZwkKaJSR0nOi6a2jZOvY+706Di6GLoURzOHiW9yZNan7DZwESjo0Vxmx0aROnjIUwPkxB00ztRgukoNDy0sx2u9roEB4d4W2WbadcWuhkgSp0xfRt/NoJ7MKCVugwTOhRTNMM93DUn8dpe4nUn+8w0k2jsby9zKjugPxoDbwut1Gc0r1E7PaAxnGJVa7HfjJIiQmcwxfLFJerxFoNkh+XlLP0hD8xp4ATcNWhWoDeMEQmgjRdxXIpwe+M2biXDIqtc2LNF7dBZwhfOoW2mqL18M3hzO90Oh0PV50l2UWoFhUIlsFJ+RVhMap6FUic3NavgmNUxkwyvlbJ6PV1bHDVR85abotXhDIfD6vuECmt1xOR3JSsvdGhR3RYHBFAZUdhxjMQ5FwVTXddV9lzmQOplYaeW2lq/LPRfK91eslrinMp3WrPpokjb6XSUerhkaMXhknFbBcbkc5JJEOdLgg+ySbEGKSQgIRkZoYrL2lip0XJuSJ229XlxhkVMR+q3rbXLkpGtVqu76NulUkllxeBbtdCDwU7Pa1lXYT3IOWF9yDkhVEWZF8msS+bYWjpgpWjDzqZFegpLVsbqpFop1fJ7cq3IOXE9hV3OfStVX+ZM5lMceXGUhZkhDAL4VsBE/hbnXhx0gayxNWt9/UPo5HJtXD9eWU/r9W5lNEjASNgDwmh4JXHfffdx7ty5Xc/9/M//PAcOHOBjH/uYUsL++te/zvve9z4A5ufnWV1d5fjx48BOd4f/+B//o+pXDai2i4cOHXpZ4xkMBkqtXDKEX/7ylzl16pRyQIXdcccddyhhK7E1zz//PPPz8zidThqNhqr5jMfjSvxKnGMrFTeXy6nM8sTEhFLxHgwGLCwsMDExwf79+9Way/W7vLxMs9lUQZelpSXi8Tjvfve7uXLlCteuXVMtITOZDKurq8Tj8V10axE0W1paolgscvToUZaXl1lZWVHq2OJETU1Nce7cOSUAtrKyQiwW49ixY+RyOWKxmHKennnmGXWdZLNZJWJWr9fZ2NhQLKRgMMj4+DitVovTp08zNjammBpS3ysBRkApdYvTmkgkVNBNAr+bm5s8/vjj3HXXXapEaP/+/eTzeZ599lnldMqY5FpJJBKqX7dk2yUzL+yiPXv24HK5OH36NM888wy6rjM7O6vWYGFhgUAgwOTkpFLXjsfj6pq9evUqw8PD1Ot1xW44d+4czz//vHIQR0dHWV5eVvcEQDEVkskkmqbRaDQIBoPqeyWA53A4lL30+Xz0ej1uueUW1VbO5XIxPT2Nw+Hg9ttvZ2lpSQmtSS22zLPcy0VsTJTVxTZL4FUYV+12m3q9jtvtpt1us7GxoUQDO50OpmmqGmwJYktAMR6Ps729TblcVhT5/fv3c/HiRXXNSIBicXFRBVyGhoaIRqP0ej1VzqBpGvl8nuHhYVKplCohkOCW6DXce++9nD59GkCx+8TBNk1TBSHE2RbdkO3tbSUKJzZb9lWvJH7Y7CNAmQEGZSJ4GCeCmy4n+TL9xFdIxAZsBOFUB9YujTLTnqZNkc86r3HV4WO672PNfYZi8ByDaoRGdghXM4fDC4OZKci3wOejPd6mPdoGjx/mA1CPQWYIZ89gjxnkdkZ5wVHgWsRB0d1nu7tAujqJHzc6PSCMlzIuDFaI0KaMv5FCN+7BqFzlluIVfjLc50pZ46SZJkaYWjIJ4+DfNskQo02LmqtFFTAKECzD0oaP4sDFkUNlVvTnWd0aI/a0i+TEAB2IGjCl6ZSpMiBAmwhXWWLCvcixo21yXZPY+S0csyblBpz46jDn3Xvo7ofQhXFmexncbFGgzanYGt3xEJT2sN0KM1zdx9DFAKf+7P9l/K42zhi4xw3cQyWG8hny1PFg0iSIxgIxCmhEiNImSQI3c2RxM8DAJMTK2hin/s8Sx/6Oic8Hrj7MvBPWdXj2Uyn8+jRFipgMEcKHkwgBNBLNLaYTA/wjOjEPVK7qVIniYIh6K8+g1iAwC9Mu6J+A85/xo2/7mD1YZv//FxxTsP01CG3AnpRJ574NPDrEY2B6YbAFiyemGS5N0Jg7g+sf1wkGYfFpOPNInEF7mD5OhhnHf6aNy3uJgWmwToMyFUYx2U+SOHX64TKBEROTnX7ang0HHgO0gYG/AAEPeHXo6X3uoUScYf6CASVC3MoEbu1pbpvOsbzlYZkDNPESx0nKmMEsPsYAHxBAp0+JMi6cjBPhqjagrzlJDvxAiwENorqfHi42tTa6WceBm1asjTnYxNVMkjQm0enQNg3CawkaYTDv8ECvDX0Tw9GjxSQrxiR7ehXceAjQ4BaGONkPcyndpj/eBTzgWcMMXaUc8lDr9okWh1gwU+wlyDQ6iYqT7PAcrBehPmCyn8JRCnIirNGhRwcXV8kRJ86PLb2Fx0unKUy36CebgAnpGJgdaJdhdAU2Y/S4nd4dW2DGME4NWDSzPO3OUsts4nYu4KzrBHqeN57TLdljQGWuhMImojVWh0Y2/+JgF4tFtcER8SWr4yzOtjg71my50GAF4qRIpjkUCqkbqGxSZMwi7iI3TisV2apGLf2ERfxL6LbWOmBxcoVGL+2cpCYNdmjt1sy5bJDFKe/3+4oaLpkFcTCbzaZyjHVdV+3A5LvFwZNstbVXqRyHVblanDb4Vrs1yTALpU+cbuvci9NtpSJLlljalsmYrFRmCR5omrYrGDAYDNRaWZ+TjZ44dJJ1kmOUMRcKBXK5nPqsBGLkuKzZW4myh0Ih1dLGmkWQTLdk/IQWKhROqVGUNZHNnTVLL+emrIm1jlneJ+ecZIzF6bZqE8i8WSnj8h7J1Ag1WwTt5HfFuZDvkPNGzgNrrbgEDWSe5Fq6XgVdggdybsjfck7IuOUatAZchOougQap1Ze+ta+00x0Ohzly5Miu50RLQJ7/xV/8RX7t136NRCJBJBLhn/2zf8bx48e59957AXjnO9/JoUOH+If/8B/yn/7Tf2J7e5t//a//NQ888MCLZmq+G+T8Hh0dJRqNsri4qHoziw0rlUrceeedZDIZFhYW0DSN9fV1VUe6d+9elQkVJ7TZbComgthbQGVhp6amlKN3/vx5RRuWeuhIJEI4HN4lRCWvjYyMKBs7NjbGO97xDur1OhcvXlQBJlHyjsViiu4uQlDdbpeFhQU2Nzfxer0UCgWVeb127Ro/8RM/wfDwMO12W5UweL1epqenVd9isSkiCHjy5EkuX76sFJ0Nw1A15pLxFKGtarWqrjVhWwllXH5PnKBGo6Hadd1xxx2qnlnssZW1c+HCBSKRiHqf2+1W9tbr9bKxsaFaaY2OjjIyMsL6+rpqUyWBVmFNGYbB5uamahf1+OOPq5Kqp59+ml6vx/j4uAp8TExMcPToUXUPKJVKKiB75swZ1QlifHyc1dVVxRoLBoOK0i3t5KTMIB6Pq4CdMARisZiyo1ILbS2HEabLyMiImiO5zqTtp7ChJDgsa+10OlXtt7TGmpycpNvtqtZn4jwPDw+rIGahUFC6FmLv5Xydnp5W93Bhkmiaxvj4uFLvlwDGnj17ePrpp3E4HIyPj1MsFslms3Q6HUUjNwyD9fV1dF1ncnKSQqGg5sPhcKjMt9xHGo0GGxsbFAoFjhw5wt69e7lw4YKyw2tra+o8keCZJAIALl68qAJqFy5cUH26RXj0lcQPm30EMHHjxYOLEfzEGLDIqm+RhKdHtLEjxLW4PsZs4d3sNTJ8JXWFpTcNMDay5JZW0edi0D4ChTwYh0muRzFwkNcaBDecdCIBBrduQXUTXBkc3m32rAZI54+QMeIM4ecL/ksszfoxRuoYzlVq2x4unQlzJ2O06KHRpYOPCi2gzQghZvodcoUgU6UUP9tapK5pPGoOU6bDCj3KoSm09Rrxpo5LW2QoeI3QeItGCrqXYGFpnE1jCi9uCqcvs+Yqc9bZ5MJqkv/PukFmvEDniEF0uEto9RqpwZtIsodR7UmCo9dwj5r4WtDSDBxRePYFJyerGq3ZNRzeCD1SxEnSIcKS5qQb6sIghFZqglFFM3T6DjeVpk7xLwPUWxM4D14laprcSoKz5iZVDLrUiYSbDDcj3E4TvE2K7Sn6aDSpU9ac7DUHaEaG5542iLhWuP0tJuYQuD1QcDh5TpvC6Ymhmyv4zCo5vcCkOcooU6ydWmXlbIusw4PPV8PTclEjRZ8k6VwK/+MNIpMw5IKH/n8hGou3EqTG0xf69P6iwZjuYfn8MHFaTLyzwJEDYLwArgKU+hrt03NU2neywjap1Riei3WGZ2DtspNLnQRdV4HYIILOBhHCaN27GdBkiyZd+owTZxgdD2sUHW3aLfDkwV3cyXIHzBSBRhtD66B52zjLbnqDMBouJgmQZpgSbgoMmDO7+Fbc9BsZqjjJ08eBTgI/HXOaGCZOutTw4CBGmAKblEkak0RpkGcJJwkmCFOgz4Bh3mzoRChxIujAzAClFoZp4G4MGKbAKH0CrYM8vN6lNNrHse7HOxjQ8Wi0HGNUjCkqbOBFI0qXOZzEnVn6bzHAOQQLbWAVwn3Aix5rUYroXFxf597uEHcR4HA2QS7uxky7MA8abDSK3JJP4G+FKPjDfL3TYGlik9lckePtIww19lJwX4A3u6DmAH0VWjWou8DXA3MNLtwOwWmYbXBq4SLnaw2aWh3H+QUCQ3U6LSdVRwOM72ZdXhw3tdMt2WVx5MQxExqyVcRJHEjDMFTNsShVS92htZZVaLdWBW+hSlpVxOVGaXVarHWz19NrxUmR94tjIjXa4ngL9ddKswXU5qRSqSgHV2oiZcNgrR221nCLwy7/ynisDqoEHmS81g2QbLgkICEbIGBXyy6rk3U9/do6Vy/2Hut4rJlLgdUplHm10oiBb6tll42QjE8cZwkgWOufr8+ettttNT6rkycbO3GExbmVz1kz3LIhlM25ONNWur8IQcnaSIZGGAZW59JKLZfjE2dY5lnmyip0J/MhGWnJiFnHbXVcZdNvrZ8VCrBkuyVAY3WqxdmX7LKsj3yvXD/yf6tDL5kwq+ic/Ka1Dt46Zjl++d3rj0HW5vpgjZXy/1rhD//wD3E4djo2dLtd3vWud/Hf/tt/U687nU4efPBBfuVXfoXjx48TDAb50Ic+xO/+7u++7N8SGqoIXAkdWbKp0j94amqKzc1NTHOnpdbVq1dVvb70UxdhK4/Hw8zMDBMTE6yurpLL5QgEAipzPjU1pZStT5w4wcbGBuPj40pBXVpCiXPa7XZ3qYFLyyan08mxY8c4ePAgDz74oFov0ZVwOBzEYjHGx8dVNtfv91MsFpmfn1cZy0AgoCjvpVKJF154AdM0OXLkCG9/+9txOp089NBDaJqmnJlut6sUsJeXl8nlcsTjccUe8vv99Ho91tfXVRBHMstipxuNBocPH+bpp5+mWCxy7do15VwcP35cBSFmZmaIx+OkUikl7lUoFAB20YetTB2n08nm5iarq6tqLJqm0Wq1ABSTo9VqqZIkCbbKdSilONlsVgVB1tfXgZ1r7/z589TrdRUgljZhtVpNBZeFIWStL7/llltUhlYYVGJDRaFdmFG1Wo14PK5UysUWS6291H0Li0nXdRUwMU2TiYkJut0uhUJBHUsmk2F0dJRcLkc2m8XlchGJRFRLNGv/6kqlQiKRYGxsTImlicZFKpVieHhYCZnJfV/O0YmJCdWCTO7fo6OjbG5uUigUSKVSmKbJ1taW0gAYGhoimUyqcYntkyRAoVAgEomQz+dxuVyMjIwoSn80GqVQKBAKhbh27Zpqr3rx4kUVUL5y5YpitcDOPXtzcxOPx8PevXtZXFxUTBRpZyYK+1NTUxw5coQzZ87g8XhIJpNMT09z4cKF79PSfX94Le0jgIcBDVKAlzpNClqLpq/NgXaf9ipstqKklo6wtzfNhdgGS++oYAbP48huot8yDIFDkHXjiGYxdDfZiXG0nofg6ixva4+zMljjQqULAQ0ScfyrQ9xjTvIWvUuGAA+R59TBc+hHh6Gqw3oetg6z4YpxatAnwCEcLDNEG9ffyn5VCTBGlZ9aucIB3Bzy6PwVXi77hwkOXET6OsE1PzFD44C+xVzwCtPHuiRS4GtBUYNL+NgiRgqTcOMYJXJseetsm0MM9xK8eesFjma2eNucgTO8yf+9eB5Pfz8x7zbhhEG3B34XjBmwcl5jozCE1xjGvzWga8bR8NPFZJ0VuqYbd91g0Pbga8cxcBEHgv4rHLyzx5PPejldHqN6ucBs380R8rwJFxWGqGkrzAwbxLc6pBp7qLfj1BhjjZ1Ab0irEnNvEe0dZslIU2lu4Gr1cU5D4RIU/8aPwxmgldhhLHbNNq0KjHXatClR1VOE9C4pwNmK48NFGJ0uEDZiOHMa5qZJywnRpkmROh38NJt7OfdMgfogRpR9mJRYfOIE3rEOtYsBNNON223QaY+gUULnFPmeA9dJN3fc3mfUcDBOkqu+PFl3m35NA71PkRQ1d5rBoIbf7BKgiJ8WPcc5/Okm3Q6YZYi2oWP2gSY9/LhNH55ODB0/Gbx0yGDg5kcJc5YgObJk2Eeu5iWNlxkibNKlsiN9Rp1pPAzoEcYkhgM/rr/NtuskmCWNwTY5yhRwse0wGDFS3EoNBy/wHCkwRwAPpsOFkyr7KBKkTpsIe7Jdype7GCMjOCtbBPUCm4kUL1Sm2TeokmKbIBpDNNmjB3iqMaCfGUDIuSMV36xBNQSuTdgXou3KszEPdxLkzUaQZ/MGjekolHOsRxPohWsYnVFKkxql2kW4CxYW66TOXKGDB8wIJHqQ9OL4WotA1k/TM45ZMyG+Cp4NOBuHA0N0D2zSvVzDV5li4LyVtnsbl6uJaSShm3/ZNud143QLFUxu9kJFlgyrtZ5TRGSq1equFlbiDIXDYUU9E2qvbCqkJ6hsAuWGae3rLNlV2fBbqbAOh4N4PK5a6MhmsF6vq3FY+0mn02nllMFO/ZLQm6WNjGy2YCdyXC6XVVZGRKmup76L02OlKltrbSVoEAgEVOZG6NfW+lhxjsQJg29l/a/PZlrbtViVql/sId8jn4dvZV+t2UxxACU7LRlnOTcA5byJYJ5kjWXjI999PW1ZRJ4kG2/NvkrgxprxlbGJoyrOtmT9pMZTSgYkyOHxeAiHw7tquKW1ljW7L+e8UBHl2Kw13dZghJynkkURSFBJmBTisMt4ZA4lAy8BJmBXjbicd0IzlzUTB0rOEakztAaTZJ6s9E9x0vv9vqI3yvFYnXlhTMh52u12d5VPCD1UHnKeyHvkd18N9fLr8eijj+762+fz8cd//Mf88R//8Xf8zNTUFF/5yld+4N+WAJ/Urj7++OPk83kymYwql5idneXkyZPqmsnn8/j9flKpFAsLC+RyOVWP7Xa7WV9f5+jRo8zMzNBqtbhw4YKi5SaTSWXfwuEwm5ubNBoNrl27phyG1dVVVbeq67pyVOX6DIfD3HrrrarrgNDYJUvndDpVffO9995LKpVSGblr167tqmW1Zi9DoRCbm5tomsbKygqnTp3i7rvvZnZ2VtUax2IxRYnWdZ1SqUSlUiGdTjM+Pk6tVqPb7SrV6EQiQS6XI5/Ps7GxQavVIpVKqV7gUut+7do15VTWajUOHjxIvV5X53A+n+fKlSuq9EGOT8Yjis5ix/v9nV7VkUhEiYWKFsTc3JyiQ2cyGXw+HxMTE7vaRU1OTqo6WBE/O3z4sOpK4HQ6Vc9nuVeI/snS0pLKgsv1Ew6HqVQqbG9v88wzz3D06FGVvZYae8MwlKq91EZLttXr9aryB8liSzBb7Kxc51bNj2AwyMbGhrJ1zz77LHv37iWTybC2tqaCccJSEgHGer1OMBjk0KFDXLlyRfXaFiV6sd+SoT506BCXL19WayK12+Pj46pPvYxX7PXy8rI636WdmmEY7N+/n62tLRXsrNVqqhxDhB4dDgf1el3d6wWlUkmJk0oP9Pn5eTweD0eOHGFtbY09e/YwOzur2CdHjhxR93lN07h69SrFYpEzZ87s6tMOOzXRBw4c4MqVK2iaxtjY2A9sg74XbqR9BGijoWtBDpkuKo51LvgeI6OdJxAyyLrAt5JiqL2f06nHyL/9Cl5/g5nsNrmAk/yIE9+1/0s438KT0ml463Til+kvJLl16xg/ySwLnRa5S9BM+Qme1zmY8zNDhSRNIqTYZJ2+6zKRjeeoX5rB7KfBvEor7uJcaYLDOkzixo2LJn5qFAhT41YSeNGJMaDcm8BPlKTHRTbUptZ34OmX2a/P8w53iWSyRyoFNOHaORe5YgSnMcw6DtYpMEcHNzpzXScL3jU+d0Dn4docb3khyI9lrjE7Z/CTt82TXb5KvKKjlWDgA33FSTkXoOxtEidMlTvo63UihQ4TjDHBMkMsMeqrMxk1WW26abgn8fVn2EuWgO8KzQHk221yofO0UxqLW0nGdJ3DaEQYsIkBLcjrJlfwsI2XKllKlKnjY8KYYtALYzBBSssSHR2gDUGvD+VtSBRDHOyabGz3MTQNjSpTxn7SuHFQJUYGv+MU44ksjXKCa6YXr6PE9MBL1tXBmIFIENwpOPSOJoG/usygNYKTKZoDL0XXAn6jSsK4hXphgkFvgaWBg5Y+zVTPx4BFoEeYNFX6ZBcdPPvlMkf39mFzHkfexzUTqs4eHt1BhxKtkBd/o8Pxvo+DNDFZxuNeJdKF7hI49sFIGgZ7e5jdPPW6Rq+tYfS89HQPQdOF0R/g8C0wbQRZ6h5jgRgat7CEyV0sMYFJ291lNWawUvVye2+KEVwU6NHDhUEdnSBDHCLPFc5Twc0YCUwc6KQND/uAEF0ieHlnM8KDKx2KUS/xRpQEbrqcY5IyeYaZNI9yJW9Qv8PE3G6TKBisRZc46Q+TXJvgPdQYxolJlDsY4suXs+SndYiVINvCl9vC7AQg0GDQX6eXOcjSYovswE0dD7oDQIO1Bka0x8bePrSaMFuBymXo9Oj/6DTP9LuwsBccs9AtQRe01hEcuhN8A8jeAl03DF2Fdge6hyHjgaZJxwT8IzB5Dz3XeaibsPHybc5N7XTLjVhuQhJxt7ZlkmyKOH1WdW1xkq30LdmUCyXb6tRZqdKSabNmw8VJeDEH0poJlHpWyW5bHRapDxdnyUqnlZuyCMhYPy+OWb/fV86Q0NGlNZrQC630dNnAyCZDMsDWHtvWh1U0Tn7X2pbKWu8uDo9k319MYEycO9nUW2vfATWWQCAAfKs2X+ZU5sha2y2bdGsJwPUZcev6yDrLGK3HZGVKyGdljOL8yRxKFkrmPRKJqOCHUCWt/aeF8i/0c2tAQRxja2s2a2BBYGVVWGu4ZTzWrLbMg7Vu2hp0kOOWtZPPy3jlveKYWxkVVqbC9fRwq0if9VyScV4f6BDHRzaK1mtTxmZlSMh3y1rLsYuNsD6s83sjMt2vJcbGxpidnaVarfLUU09x6tQp0uk0oVCIbrfLoUOH2NraUllFyTqL8nGtVsPlclGtVpUQVaFQoFKpKAd0bm4O+Ba7olAooGkayWRSKYIDSmFfsoPhcFjVIudyOfW6BGk8Ho8SJJPgj7wmFFgRR/P5fFy+fJnLly8rpyWVSmEYBgsLCypIJLXM0sP505/+NO9+97uV4Jtoe0hpT6fTYe/evWiaxqVLl1RbK9FjkPuM0KQTicQuZfROp6MU3cX5v3DhAvF4nMFgoIIFV65coVqtKuaVlCM5HA4VAJ6eniYej1MsFlWQz+XaaWcmtdztdpvh4WFarRaDwU4v7U6nQ6vVUm2XBoMBly5dUjXosKNXsb29jd/v5+jRo4oanslklLCWiHOVy2U6nY5y5h0Oh1qvdrvNk08+ydzcHHfffTeRSIQzZ85w5coVHA4HQ0NDyq5Ihl9q/61MnGKxSCQSUcwyycYmk0lMc0eTJR6Pk8vl2NraQtd1isWicuqlxCqVSuFyuSiXy0q4TRxjCUp0Oh3F7MhkMoohJ861YRiqV30ul1MMOFHMHx4eplAokEgkyGazyiY1m00lRCe2LJvNKqE46cnu9/uJRCK0Wi18Pp9iahw9epR4PE4+n6dcLrO9va3uGcFgUJ2fcp1ZywzS6TSJREL99tLSkhI6vPXWW1leXiabzdJut1X7MtFjmZiYUOeE3HNfz+i5xogPZhhoVV6YOkGvdpJ9LZ3erdBZT5Bp3cXVkWsYR04w5Cgx1IShIWj1B9Q3s8QrAyJ96GXBM2ow6INerRAxK1SoAl3eWt6Lt6xhYuABitQ5T5Q4CZo0GKo2cLcHNCsd9GQBxjbQ1jOMGfsZoYCHEXIkabGIAzdtgnRx4qFHkxE2eStOutzSK/CM0aMS7dJN1ljPF+l6+qQ84LsK8yteLjfGaDJBlXGG8dJBZ4nzDCjRxU28b1IvVMgf2cOXCmEW5qu8r1wiE9Bx+wdU6xqNbSf4dLw1F23Tw76ROpRz1IvLjLeDHG4bDHMBB+v0iaD3IJmHUKBJYmSB/oYXdDfRRINOBzZqBr1gGaJuKrqXM1vLDDnK6MYzJFNdaDm53B6mRo8cF6hh4iVOF5MiDkIkSLFOOrhKPGRSLEFnAzQD3K4Gw7gYMyP4zQ5drjFCiRYGTdbJsI+OkaZdjpDRZ9mOPcFgX5VLa0WCQx1GZ01MbafcN1eDgKPPEbqU2aASzzHsrVErV8h3/XQNF7nKKAvEKAMB2kzRx0GFLiE8JGj2JnjosXWOvXOZu/9RmfCjDl446WN+AG6mGGaIXtlFFCfHyJBkAadvjWCwi6MIDi+Qh2IQorPgNCHQM2m1TGrdNsn+jnhlq1skNgr5rIPeC256THIaH5rWJWOClyoew0WolaRtutmiQpIUeQZcxWCgtQmaHRJkGKHDsrYIppcDJHBRokmAaXx4CGByiAPEaHS6nO53CBg+ttDxkGGOUUYZUKKNazAO2RztgUZ2SIOhFr1BhPlNJ/frPgaE2WaIAA2Gy1XyRgq6FShG6DmHcNNm0IujF9q4mCczuJUYKU4yoOdagvY1SLuhaoARhJAXtA6MJqGxDv0SndtGYGsDAmmYjEOuhf6OPrXyC1DagqUJ2LwbfHFw5mCtDdE4+OMw0gSjA8Z+CPthUPy+bM5N7XRb+21ubW2Ry+V2RdZhx7G1trIaDAaqthe+5STIZl7UzVOplHJKhPJnpfmKw2sVzZKNkjiRUlMqDop8n9w0xXmxCreJkykOmjg6EijI5XIqcygK2+IsS1BBNhUOh4NIJMLExIRq/SJOmjhAshmV/tVSTymUdGttnJXiK8crzr8EMSRLLxsmCQRIPaZkLUzTVBtvqXsPh8PKoRIHX56TbKw4lhJskTULhUIkk0mVjbA6XbJG8rvi3IsjKQJbkpkVpoIEdawOmzi3QhsfDAbKgZP1i8fj+Hw+xsfHCQaD6m9Zd3FGZYNmHbOUCJRKJRwOxy5RIKtqu6Df7+8SJYNvBUqsgRPJpIhQmwQ7xIGwOsWapqnAgZwT4iBLNspKzxYHWs5hyeKHQiEV2JLAlzBAZO2sVH7JdJumqcYuc2QNIMg1JQ9rSYBcz0LdlDIAuUat1NrXItN9IyH12Y8++ijPPPOMUmMuFouqL++lS5fY2NgJ1+7Zs0exXSqVimoRJ2yaUqlEIBBgcXFRUaKnp6fZ3Nzk8uXLyqG6cOGCalMk9cuZTIZWq0W73VbOpqy1x+OhXC7TaDRYXFxE0zTe8pa3MD8/r5zutbU1pWQuY3ziiScYGhpStdCGsdM+zO/3c9ttt3Hbbbdx6NAhNjc3lYCY9FAWevLGxoZ6RKNRDhw4oPpfCwspFAqxb98+IpEI4+PjdDodlpaWWFhYUA7P0NCQKlMaGRlRmXJA9Ve2tj0bHR0lHA6TzWaV/ZZgkFx70WiUO++8U2X+i8WiUloXJ1+6HEhLQ2HWSBBa7g/tdlsJnS0sLDA8PIzL5eLatWtKtVw0LNLptGIyDAYDwuGwCswkk0lVamAYhhI329zcJJ/PMxgMlPr00aNH6ff7LC8vq+t4bGxM1bVLMLtcLitbIjoshw4dUiVNEkiZm5tTNlDq9YWuvbS0xPj4OOFwGNM0mZqaUgr3wsASwTPREZAx7dmzh0wmo3QGRMBOVOUNw+Dw4cMcO3aMjY0NFhYW8Pl8XLhwQfWflx7vwpQrFAq7tFHm5+d3BXmLxSKjo6Ok02kKhYLKLheLRVVHbxgGXq93V6s2UeWXYKasuSQVyuUyzWZT9bcXGyvXUCKRUArvx44dYzAYKB0BWYtkMsm+fftIJBI3wGq9xghr1KobnPE8Siv6JIF8mw0jQmVRo7X5I/QzQ+iHniCwUWKwAeGZv21J1QNHRUdvgqFDtumj3QzjHIQYaB6edi8y6Me5jRS3Mc0LbHJCm6dhxkjhI80Wo+SpO67i6+hsZUfRgxPgqBC8Ns5s3svdZp8eQUyCeNAo46BOl6vkcJHlzcxwlghPawX2mG6KrOIdGBwr+sk2B1zxz/BIbYOh6hCG6aVodjDIkKVLlzJ3c5hZqqwxyiZJatQoGfvQCyNsPnGBjmYy0r+Hzf4LbNZybLjcRJ0GB7pxqgseKoZGh2HKy0uEvWXeRY0ITiZYp02JZdosOAdUIj2a7QmchbsoO66gGz6iZAitTlBuLdEfhNDjCQiBI9unO/AwMJOMRiuE9/TJPhfBT4CSaxPfwMSFCzde3Pg4gIc3UeXWxGV8Ez2KDWheho0c+EchPt6kMngW18BDytDwByr4nMuYXWh2nDT7Plz08OpDtIgScui4EjDvr5OcBa8P8ufh2jMu1q+NMRi4aRMmE11h9vYazQ0YtHXCgw3a+gwme4kQoMEmPbIY6PhcBj3nOhv+LGtOL7Wul86zLqIjA479uMHAbLF4KsCgDwm6jDCKlzAdrtD3nMaxp0VJAy0LWhNK8+AZgkOj4B+AbkKjvCPAvXca+iFw6OABClkYx0UTE41r7DHjhJlAx8Xb9QnMZpDLtBmixwxZepTIEidrahi0CAADHHSD0/h6Gfy9AAlcaDjx4qFLhDj76OBlH33G9QA5NnjIscBpd4JQ18MMdfyEiXb9VFdKuHp+eneFwVHAeclFUNfpcQunceMjDhg42zl4qgee/eDVMYwCpuMKgYGGvrVB2PUCTRJ0uIsoLRyeBnqkCw4PkIJCFEwXVHpQCeA+N8fgTBgzpuNs5tGNJviSOw3W3Y4dR327B80tUpfuoHb1XgbmNppxlME+HXxFGOlDSod8FSopaEwDT75sk3NTOt2ywRaRr3a7rWoWre2vZJMvDqFQV69vYWV1Qq0P4NucVKGsiSMp1GqBvEco506nk1arpTY04hjLv9YxXf/7VmdBaNFSgy7HCDvZX3GI5XNCexb1a8lsWrPm7XZ7FzNAnCdr5vf6TKE4rtbM5PW0cQkmXD9v1t+QdbTOu8yZzKO1bvr6rKr17+vnTH5DXrcGBazlBAJ5Tebb+j0yV+J0Sv22dfzWTK/1mK1MCdnEAbucZzkWcQTFGZTAigQX5ByRz1gdXusYrNl662vX16q/2Oes82tlL8jcWB9yXUl2Us5BcZytTAH5feu/VlE4mRN5iFN1fR26taZb5sN67YgDbi3tkO+W68i6RtYA0usJ1uO8cuUKW1tb31ZWIY6orKM4xTLvgKoTllZNMzMzypGR2ttms8n6+jrhcJjJyUlqtRqrq6uqt/Tw8LBqNSZ9iUOhkGorKEHF1dVV5bTpus7FixdZXl6mVCoRDoep1WpKLDMajaprZGNjg+HhYVVCIcFFoVofOnSIq1evUq1WOXXqFBsbG+p6DIfDKig0MjKigmGdTofNzc1drQzHxsZUa0mHw8Hm5ibZbJbR0VFFT+50OmxtbSlnK5/PE4/HcblcyiGbm5vD4/GQyWQoFAqKJi5B1NHRURVgHBkZIR6PK7q5BH7FgZbAiZQTydg9Hg+VSoVsNqvahG1ubqrMpdTrN5tN1tbWKBaLilm1srJCPB5XNeviRC4tLaljT6VSqnWWBGNisZhqjelyudjY2MDr9bK0tIRhGExMTDAyMqLmQcqgstmsaqFWr9fx+/0MDQ2pQG+z2aRQKBCLxVTrLHlvtVolFAqpAICIn0kgVQLPmrbTQ1vqryWALDRxv9+vnFwJTooAngjn9Xo90um0UjmXIGy73abRaDA1NaXstzi/4hhvbm6qe69cC7IO5XJZfU6CC4ZhkMvluHbtmmI2yDUg5WwSUPT5fMzNzVEoFFhdXVW2rt1uMzY2pvqPJ5NJ1QatVqupfUmtVmN9fV21cms2m2p9pOXb680+guWY3Abt6BXwbuG4MqDXgaujAehEwJ2FySXQK3T7EE5DrQnNHtSc0MJFkD7VgUZr8hDkEoSKM9Sdfmq0yWHSIEaRBpfYQDPDjDGJgxqLrDLvLtBO+2ll7oFABpo+PPk4RxtxDuNjwDYVYrjRAINVDLbokCNKECcX8XKCHPOhGs16mLrWJeerEm77mOl48HYiVAmxwQzDOPBwlgF1fJjE6ePEwRxbHKbAVUwqxPgmGotsEBz0ceEmSoweaXSajAz24R54cOKmZUxwkQ5dDLoDH77BJmO0aHKNOm0c7GWTPrngFUbu6uNc3GRl8RhXjVtoskWKOr7uIaobLjTcOLd86N0yzoIXl3kvA8qkOxco5POU+wYRsnTTFfIFHyM9J326rBFmlAQJAlT6i/gqPQoFGHih7YDQBBw7ZJKKNCjnwP+3PbU7DvAEoLxpkt0aMEKfhvMsm8wTMBqwAtE+eN3QasDWs1BazqAxShAnK1wlES3RLcO6AwJRCDcMlqhTp80Qw4RJECePJ5alFYSSXyc23ScYauGpgmceNh8D32FYzjuoD2LcSoj9lKlTwUkKB0uUvQW229Asa5h1P/VWG78BQ1sOBtd0/H1omFBs+Ig5TBLuLs5RoANGCWpFgxAFxhkhRIwpArjRCeDES4sSPVwE6AF11jDZYogMDYIM0BnCw5ajzSDtp9GO89yWwR7STNKkR4MiQXTCFNGpM8BDmDIBBt4m1TmDx646udKO4SQLPR+xnpO+5qS3NsBdLxMrutDo8RxRLuHgNuqEiLOiBQle1tD8ERqJMmhO+k4nptHENL0MPCVKzS2eY5lLFBlkShDcwFlro3umYGLfDv3b24V1P1p1DrQCdFahN4BCHy6WYCwNkTj490JyJ8QQNrp0elV6ISdmqAVjdXCsQ3cLWktgdsE9Af3x3bbkJUIzb0KLur6+rmhQNmzYsPGDYG1tjfHx8Rs9jFcMtn20YcPGK4XXm32EHf2H2dnZGz0MGzZs3OR4ufbxpnS6DcNgfn6eQ4cOsba2ptQ6Xw8QZdTX03HZx3Tz4PV4XN/pmETsaXR0dBfz4WbH69k+vhy8Hs/l7wf2POzAnocdvNR5eL3aR9hp5xePx1ldXVUK/W9E2NeEPQcCex528Grbx5uSXu5wOJSyZiQSeV2eIK/H47KP6ebB6/G4XuyYXo8brjeCfXw5sOdgB/Y87MCehx28lHl4PdpH+FZnlGg0ap8L2NcE2HMgsOdhB6+WfXx9hS9t2LBhw4YNGzZs2LBhw4aNHyLYTrcNGzZs2LBhw4YNGzZs2LDxKuGmdbq9Xi+//du/rVoLvV7wejwu+5huHrwej+v1eEzfC2/EY74e9hzswJ6HHdjzsAN7Huw5ENjzYM+BwJ6HHbza83BTCqnZsGHDhg0bNmzYsGHDhg0bNwNu2ky3DRs2bNiwYcOGDRs2bNiw8cMO2+m2YcOGDRs2bNiwYcOGDRs2XiXYTrcNGzZs2LBhw4YNGzZs2LDxKsF2um3YsGHDhg0bNmzYsGHDho1XCbbTbcOGDRs2bNiwYcOGDRs2bLxKuGmd7j/+4z9menoan8/HPffcw7PPPnujh/SS8fGPf5y77rqLcDhMOp3m7/29v8f8/Pyu97zjHe9A07Rdj1/+5V++QSP+3vid3/mdbxvvgQMH1OudTocHHniAoaEhQqEQ73vf+8hmszdwxC8N09PT33ZcmqbxwAMPADfHOj3++OP8nb/zdxgdHUXTNL74xS/uet00Tf7tv/23jIyM4Pf7uf/++1lYWNj1nlKpxAc+8AEikQixWIxf/MVfpNFovIZH8e34bsfV7/f52Mc+xtGjRwkGg4yOjvLBD36Qzc3NXd/xYuv7iU984jU+klcWN7NtfCl4vZ7PLwcv5R7yUmzu6uoq733vewkEAqTTaX7jN36DwWDwWh7KD4RPfvKTHDt2jEgkQiQS4fjx43z1q19Vr78R5uB6fOITn0DTNH71V39VPfdGnIfvBNs+2vYR3hjXhG0fvx033D6aNyE++9nPmh6Px/xf/+t/mRcuXDA//OEPm7FYzMxmszd6aC8J73rXu8xPfepT5vnz580zZ86YP/7jP25OTk6ajUZDveftb3+7+eEPf9jc2tpSj2q1egNH/d3x27/92+bhw4d3jTefz6vXf/mXf9mcmJgwv/71r5vPPfecee+995pvetObbuCIXxpyudyuY3rooYdMwHzkkUdM07w51ukrX/mK+a/+1b8y//Iv/9IEzC984Qu7Xv/EJz5hRqNR84tf/KL5wgsvmD/5kz9p7tmzx2y32+o97373u81bbrnFfPrpp81vfvOb5tzcnPn+97//NT6S3fhux1WpVMz777/f/Iu/+Avz8uXL5okTJ8y7777bvOOOO3Z9x9TUlPm7v/u7u9bPeh3ebLjZbeNLwev1fH45eCn3kO9lcweDgXnkyBHz/vvvN59//nnzK1/5iplMJs3f+q3fuhGH9H3hr/7qr8wvf/nL5pUrV8z5+XnzX/7Lf2m63W7z/Pnzpmm+MebAimeffdacnp42jx07Zn70ox9Vz7/R5uE7wbaPtn0UvBGuCds+7sYPg328KZ3uu+++23zggQfU37qum6Ojo+bHP/7xGziq7x+5XM4EzMcee0w99/a3v33XSfHDjt/+7d82b7nllhd9rVKpmG632/zc5z6nnrt06ZIJmCdOnHiNRvjK4KMf/ag5OztrGoZhmubNt07X34QNwzCHh4fN3//931fPVSoV0+v1mv/7f/9v0zRN8+LFiyZgnjx5Ur3nq1/9qqlpmrmxsfGajf274cU2F9fj2WefNQFzZWVFPTc1NWX+4R/+4as7uNcQrzfb+L3wej2fXy6uv4e8FJv7la98xXQ4HOb29rZ6zyc/+UkzEomY3W73tT2AVxDxeNz8n//zf77h5qBer5t79+41H3rooV33pTfaPHw32PbRto+m+ca+Jmz7eGPt401HL+/1epw6dYr7779fPedwOLj//vs5ceLEDRzZ949qtQpAIpHY9fxnPvMZkskkR44c4bd+67dotVo3YngvGQsLC4yOjjIzM8MHPvABVldXATh16hT9fn/Xmh04cIDJycmbas16vR5/9md/xi/8wi+gaZp6/mZbJyuWlpbY3t7etTbRaJR77rlHrc2JEyeIxWLceeed6j33338/DoeDZ5555jUf8/eLarWKpmnEYrFdz3/iE59gaGiI2267jd///d+/aalTr0fb+HLxRjqfrbj+HvJSbO6JEyc4evQomUxGvedd73oXtVqNCxcuvIajf2Wg6zqf/exnaTabHD9+/A03Bw888ADvfe97dx0vvDHPhReDbR9t+2jbR9s+3mj76PoBjuGGoFAooOv6roMHyGQyXL58+QaN6vuHYRj86q/+Km9+85s5cuSIev7nfu7nmJqaYnR0lLNnz/Kxj32M+fl5/vIv//IGjvY745577uHTn/40+/fvZ2tri3/37/4db33rWzl//jzb29t4PJ5vc3YymQzb29s3ZsDfB774xS9SqVT4R//oH6nnbrZ1uh4y/y92Pclr29vbpNPpXa+7XC4SicRNs36dToePfexjvP/97ycSiajn//k//+fcfvvtJBIJnnrqKX7rt36Lra0t/uAP/uAGjvb7w+vNNn4/eKOcz1a82D3kpdjc7e3tF50nee1mwblz5zh+/DidTodQKMQXvvAFDh06xJkzZ94wc/DZz36W06dPc/LkyW977Y10Lnw32PbRto+2fbTt4/V4rc+Fm87pfr3hgQce4Pz58zzxxBO7nv+lX/ol9f+jR48yMjLCfffdx+LiIrOzs6/1ML8n3vOe96j/Hzt2jHvuuYepqSn+z//5P/j9/hs4slcOf/qnf8p73vMeRkdH1XM32zq9EdHv9/n7f//vY5omn/zkJ3e99mu/9mvq/8eOHcPj8fBP/sk/4eMf/zher/e1HqoNGy8b3+ke8kbB/v37OXPmDNVqlc9//vN86EMf4rHHHrvRw3rNsLa2xkc/+lEeeughfD7fjR6ODRs/VLDto20ff5js401HL08mkzidzm9TlstmswwPD9+gUX1/+MhHPsKDDz7II488wvj4+Hd97z333APA1atXX4uh/cCIxWLs27ePq1evMjw8TK/Xo1Kp7HrPzbRmKysrPPzww/zjf/yPv+v7brZ1kvn/btfT8PAwuVxu1+uDwYBSqfRDv37icK+srPDQQw/tynK/GO655x4GgwHLy8uvzQBfQbyebOP3i9f7+Xw9vtM95KXY3OHh4RedJ3ntZoHH42Fubo477riDj3/849xyyy385//8n98wc3Dq1ClyuRy33347LpcLl8vFY489xh/90R/hcrnIZDJviHn4XrDto20fBW8U2wC2ffxhs483ndPt8Xi44447+PrXv66eMwyDr3/96xw/fvwGjuylwzRNPvKRj/CFL3yBb3zjG+zZs+d7fubMmTMAjIyMvMqje2XQaDRYXFxkZGSEO+64A7fbvWvN5ufnWV1dvWnW7FOf+hTpdJr3vve93/V9N9s67dmzh+Hh4V1rU6vVeOaZZ9TaHD9+nEqlwqlTp9R7vvGNb2AYhgoy/DBCHO6FhQUefvhhhoaGvudnzpw5g8Ph+DZ63c2A14Nt/EHxej6frfhe95CXYnOPHz/OuXPndm2wJTB16NCh1+ZAXgUYhkG3233DzMF9993HuXPnOHPmjHrceeedfOADH1D/fyPMw/eCbR9t+yh4o9iGF4NtH2+wffzB9OBuDD772c+aXq/X/PSnP21evHjR/KVf+iUzFovtUpb7Ycav/MqvmNFo1Hz00Ud3tSpqtVqmaZrm1atXzd/93d81n3vuOXNpacn80pe+ZM7MzJhve9vbbvDIvzN+/dd/3Xz00UfNpaUl88knnzTvv/9+M5lMmrlczjTNHUn+yclJ8xvf+Ib53HPPmcePHzePHz9+g0f90qDrujk5OWl+7GMf2/X8zbJO9XrdfP75583nn3/eBMw/+IM/MJ9//nml4v2JT3zCjMVi5pe+9CXz7Nmz5t/9u3/3RVuI3HbbbeYzzzxjPvHEE+bevXtveAuR73ZcvV7P/Mmf/ElzfHzcPHPmzK7rTNQmn3rqKfMP//APzTNnzpiLi4vmn/3Zn5mpVMr84Ac/eEOP6wfBzW4bXwper+fzy8H3uoeY5ve2udIG5Z3vfKd55swZ86//+q/NVCp1U7WD+c3f/E3zscceM5eWlsyzZ8+av/mbv2lqmmb+zd/8jWmab4w5eDFc31XjjToP18O2j7Z9FLwRrgnbPr44bqR9vCmdbtM0zf/yX/6LOTk5aXo8HvPuu+82n3766Rs9pJcM4EUfn/rUp0zTNM3V1VXzbW97m5lIJEyv12vOzc2Zv/Ebv/FD1//Zip/92Z81R0ZGTI/HY46NjZk/+7M/a169elW93m63zX/6T/+pGY/HzUAgYP7UT/2UubW1dQNH/NLxta99zQTM+fn5Xc/fLOv0yCOPvOj59qEPfcg0zZ02Iv/m3/wbM5PJmF6v17zvvvu+7ViLxaL5/ve/3wyFQmYkEjF//ud/3qzX6zfgaL6F73ZcS0tL3/E6kx7rp06dMu+55x4zGo2aPp/PPHjwoPl7v/d7ZqfTuaHH9YPiZraNLwWv1/P55eB73UNM86XZ3OXlZfM973mP6ff7zWQyaf76r/+62e/3X+Oj+f7xC7/wC+bU1JTp8XjMVCpl3nfffWpDaZpvjDl4MVy/qXyjzsOLwbaPtn00zTfGNWHbxxfHjbSPmmma5svLjduwYcOGDRs2bNiwYcOGDRs2XgpuuppuGzZs2LBhw4YNGzZs2LBh42aB7XTbsGHDhg0bNmzYsGHDhg0brxJsp9uGDRs2bNiwYcOGDRs2bNh4lWA73TZs2LBhw4YNGzZs2LBhw8arBNvptmHDhg0bNmzYsGHDhg0bNl4l2E63DRs2bNiwYcOGDRs2bNiw8SrBdrpt2LBhw4YNGzZs2LBhw4aNVwm2023Dhg0bNmzYsGHDhg0bNmy8SrCdbhs2bNiwYcOGDRs2bNiwYeNVgu1027Bhw4YNGzZs2LBhw4YNG68SbKfbhg0bNmzYsGHDhg0bNmzYeJXw/wd0pxlLYYi1mgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], "source": [ "from PtyLab.utils.utils import fft2c, ifft2c\n", "from PtyLab.utils.visualisation import modeTile, complex2rgb\n", - "plt.rcParams['figure.figsize'] = [12, 12]\n", - "plt.rcParams['figure.dpi'] = 100 \n", + "\n", + "plt.rcParams[\"figure.figsize\"] = [12, 12]\n", + "plt.rcParams[\"figure.dpi\"] = 100\n", "\n", "plt.subplot(131)\n", - "plt.title('raw data')\n", - "plt.imshow(abs(mean_img),cmap='gray')\n", + "plt.title(\"raw data\")\n", + "plt.imshow(abs(mean_img), cmap=\"gray\")\n", "plt.subplot(132)\n", - "plt.title('reconstructed amplitude')\n", - "plt.imshow(abs(modeTile(fft2c(reconstruction.object))),cmap='gray')\n", + "plt.title(\"reconstructed amplitude\")\n", + "plt.imshow(abs(modeTile(fft2c(reconstruction.object))), cmap=\"gray\")\n", "plt.subplot(133)\n", - "plt.title('complex reconstruction')\n", + "plt.title(\"complex reconstruction\")\n", "plt.imshow(complex2rgb(modeTile(fft2c(reconstruction.object))))" ] }, @@ -380,29 +401,27 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 11, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -411,24 +430,24 @@ "Np = reconstruction.Np\n", "No = reconstruction.No\n", "dxp = reconstruction.dxp\n", - "z=120e-3 # illumination to sample distance\n", - "u=60e-3 # sample to lens distance\n", + "z = 120e-3 # illumination to sample distance\n", + "u = 60e-3 # sample to lens distance\n", "\n", "# create the coordinate grid\n", - "x = np.linspace(-Np / 2 , Np / 2, No) \n", + "x = np.linspace(-Np / 2, Np / 2, No)\n", "Yp, Xp = np.meshgrid(x, x)\n", - "Yp = Yp*dxp\n", - "Xp = Xp*dxp\n", + "Yp = Yp * dxp\n", + "Xp = Xp * dxp\n", "\n", "# illumination phase curvature\n", - "ill_curvature = np.exp(1j*np.pi/wavelength * (1/z) * (Xp**2 + Yp**2))\n", + "ill_curvature = np.exp(1j * np.pi / wavelength * (1 / z) * (Xp**2 + Yp**2))\n", "# non-telecentricity induced phase curvature\n", - "tele_curvature = np.exp(1j*np.pi/wavelength * (1/u) * (Xp**2 + Yp**2))\n", + "tele_curvature = np.exp(1j * np.pi / wavelength * (1 / u) * (Xp**2 + Yp**2))\n", "# combined curvature\n", "total_curvature = ill_curvature * tele_curvature\n", "\n", "plt.subplot(132)\n", - "plt.title('Phase curvature')\n", + "plt.title(\"Phase curvature\")\n", "plt.imshow(complex2rgb(total_curvature))" ] }, @@ -441,14 +460,24 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 22, "metadata": {}, "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA8AAAAEjCAYAAAD9mWieAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xe8H1Wd+P/XzHzm0+v93N5Leg8BQu9SpIqAAUEQEFRsi2VFXRFU3BVX/elXRV1FFkVZBMFVpIQuLZCQ3m6S2/vnfu6nfz5Tz++Pu7nLJTfJDS2smefj8XmEOXNm5syQeeecmTPnSEIIgcPhcDgcDofD4XA4HP/g5INdAIfD4XA4HA6Hw+FwON4NTgPY4XA4HA6Hw+FwOByHBKcB7HA4HA6Hw+FwOByOQ4LTAHY4HA6Hw+FwOBwOxyHBaQA7HA6Hw+FwOBwOh+OQ4DSAHQ6Hw+FwOBwOh8NxSHAawA6Hw+FwOBwOh8PhOCQ4DWCHw+FwOBwOh8PhcBwSnAaww+FwOBwOh8PhcDgOCU4D+P+ob3zjG0iSRCKR2G/e5uZmrrrqqne+UO8hV111Fc3NzQe7GA6H4xAgSRKf+tSnDnYx3ha/+c1vkCSJzs7Og10Uh8Ph+D/npJNO4qSTTnrb9mfbNgsWLODb3/72RNr/9Tj9yCOPEAwGGRkZOWhlcBrA7yGbNm3i8ssvp66uDo/HQ21tLR/+8IfZtGnTwS7aPt122208+OCD7/px+/v7+cY3vsHatWvf9WPvyz333MMPf/jDg10Mh+OQtruCsPvn9XqZNWsWn/rUpxgaGjrYxTvoDlbc3pcXXniBb3zjG6RSqYNdFIfjH94bY+Qbfy+99NLBLuJB9V6pY/7+97+np6dnvw9Zf/rTn/Kb3/xm2vu99957ufzyy5k5cyaSJO2z0b569WrOPPNMwuEwoVCI008/fcrr8thjj3HNNdewYMECFEXZ64uoM888kxkzZvCd73xn2uV9u7kO2pEdkzzwwANceumllJWVcc0119DS0kJnZye/+tWv+OMf/8gf/vAHPvCBD7ypfW/btg1Zfueeddx2221cdNFFXHDBBe/YMabS39/PLbfcQnNzM0uWLJm07pe//CW2bb+r5dntnnvuYePGjXzuc587KMd3OBz/69Zbb6WlpYVSqcTf//53fvazn/Hwww+zceNG/H7/wS7eQbO3uH3FFVewYsUKPB7Pu16mF154gVtuuYWrrrqKaDT6rh/f4TgU7Y6RbzRjxoyDUJr3jn3VMfflsccee1vLcfvtt7NixQoikchE2lRx+qc//Snl5eXT7vH5s5/9jNWrV3PEEUcwOjq613xr1qzhuOOOo6GhgZtvvhnbtvnpT3/KiSeeyKpVq5g9e/ZE3nvuuYd7772Xww47jNra2n0e//rrr+cLX/gCt9xyC6FQaFplfjs5DeD3gJ07d3LFFVfQ2trKs88+S0VFxcS6z372sxx//PFcccUVrF+/ntbW1gPe/8GoyBxsqqoe7CI4HI73gLPOOovDDz8cgGuvvZZ4PM73v/99HnroIS699NIpt8nn8wQCgXezmO8ZiqKgKMrBLobD4XiXvD5GTpdpmti2jdvt3mPdW42fQghKpRI+n+9N7+NgKBQK+P3+Ka/Jm/Xaa6+xbt06/v3f/31S+tsRp++++27q6uqQZZkFCxbsNd+//Mu/4PP5ePHFF4nH4wBcfvnlzJo1i6985Svcf//9E3lvu+02fvnLX6KqKueccw4bN27c634/+MEP8ulPf5r77ruPq6+++i2dy5vhdIF+D7j99tspFAr84he/mNT4BSgvL+fnP/85+Xye7373u3tsm0gkuOSSSwiHw8TjcT772c9SKpUm5ZnqG+BUKsXnPvc5Ghoa8Hg8zJgxg3/7t3/b462pbdv8f//f/8fChQvxer1UVFRw5pln8uqrrwLj377l83nuuuuuiW4z+3v6pGkaN998MzNmzMDj8dDQ0MCXvvQlNE2blO/xxx/nuOOOIxqNEgwGmT17Nl/5ylcAePrppzniiCMA+OhHPzpx7N3dP974DXBnZyeSJPG9732Pn/zkJ7S2tuL3+zn99NPp6elBCME3v/lN6uvr8fl8nH/++SSTyUnleeihhzj77LOpra3F4/HQ1tbGN7/5TSzLmshz0kkn8de//pWurq6JMr2+HNM9d4fD8c445ZRTAOjo6ADGY0UwGGTnzp28//3vJxQK8eEPfxgYr8h9/vOfn4iTs2fP5nvf+x5CiCn3/bvf/Y7Zs2fj9XpZtmwZzz777B55+vr6uPrqq6mqqsLj8TB//nx+/etfT7v8v/3tb1m2bBk+n4+ysjJWrFhBT0/PpDzt7e188IMfpLq6Gq/XS319PStWrCCdTgP7jttTfVvW3NzMOeecw9NPP83hhx+Oz+dj4cKFPP3008B4D6bd/0YsW7aM1157bVJ51q9fz1VXXUVrayter5fq6mquvvrqSW8dvvGNb/DFL34RgJaWlolyvb4c0zl3h8Px9np9/emHP/whbW1teDweNm/ePDEezebNm7nsssuIxWIcd9xxwHgj+Zvf/OZE/ubmZr7yla/sUd/ZHV8effTRifjy85//fK/lOemkk1iwYAHr16/nxBNPxO/3M2PGDP74xz8C8Mwzz7B8+XJ8Ph+zZ89m5cqVe+xjf3F4f3XM3WVYvXo1J5xwAn6/f6J+OtU3wKVSiW984xvMmjULr9dLTU0NF154ITt37tzntX/wwQdxu92ccMIJk9LfGKebm5vZtGkTzzzzzERZ9/cdckNDw7R6hz733HOcdtppE41fgJqaGk488UT+8pe/kMvlJtJra2un/QKqsrKSRYsW8dBDD00r/9vNeQP8HvDf//3fNDc3c/zxx0+5/oQTTqC5uZm//vWve6y75JJLaG5u5jvf+Q4vvfQSP/rRjxgbG+M///M/93q8QqHAiSeeSF9fH9dffz2NjY288MIL3HTTTQwMDEz6fvWaa67hN7/5DWeddRbXXnstpmny3HPP8dJLL3H44Ydz9913c+2113LkkUdy3XXXAdDW1rbXY9u2zXnnncff//53rrvuOubOncuGDRv4wQ9+wPbt2ye+Sdu0aRPnnHMOixYt4tZbb8Xj8bBjxw6ef/55AObOncutt97K17/+da677rqJa3fMMcfs81r/7ne/Q9d1Pv3pT5NMJvnud7/LJZdcwimnnMLTTz/NP//zP7Njxw5+/OMf84UvfGFSQPzNb35DMBjkxhtvJBgM8uSTT/L1r3+dTCbD7bffDsBXv/pV0uk0vb29/OAHPwAgGAwe0Lk7HI53zu4Kx+v/MTdNkzPOOIPjjjuO733ve/j9foQQnHfeeTz11FNcc801LFmyhEcffZQvfvGL9PX1Tdzfuz3zzDPce++9fOYzn8Hj8fDTn/6UM888k1WrVk08XR8aGuKoo46aGDSroqKCv/3tb1xzzTVkMpn9fjbx7W9/m3/5l3/hkksu4dprr2VkZIQf//jHnHDCCbz22mtEo1F0XeeMM85A0zQ+/elPU11dTV9fH3/5y19IpVJEIpEDjtsAO3bs4LLLLuP666/n8ssv53vf+x7nnnsud9xxB1/5ylf45Cc/CcB3vvMdLrnkkkmf3jz++OPs2rWLj370o1RXV7Np0yZ+8YtfsGnTJl566SUkSeLCCy9k+/bt/P73v+cHP/gB5eXlABMPhadz7g6H48Cl0+k9BlSVJGlSjAS48847KZVKXHfddXg8HsrKyibWXXzxxcycOZPbbrtt4gHhtddey1133cVFF13E5z//eV5++WW+853vsGXLFv70pz9N2ve2bdu49NJLuf766/nYxz42qVvtVMbGxjjnnHNYsWIFF198MT/72c9YsWIFv/vd7/jc5z7Hxz/+cS677DJuv/12LrroInp6eia62U4nDk+njjk6OspZZ53FihUruPzyy6mqqpqyrJZlcc455/DEE0+wYsUKPvvZz5LNZnn88cfZuHHjPmPvCy+8wIIFC/bbqPzhD3/Ipz/9aYLBIF/96lcB9lqeA6Vp2pRv4/1+P7qus3HjRo466qg3te9ly5YdvLqvcBxUqVRKAOL888/fZ77zzjtPACKTyQghhLj55psFIM4777xJ+T75yU8KQKxbt24irampSVx55ZUTy9/85jdFIBAQ27dvn7Ttl7/8ZaEoiuju7hZCCPHkk08KQHzmM5/Zozy2bU/8dyAQmLT/fbn77ruFLMviueeem5R+xx13CEA8//zzQgghfvCDHwhAjIyM7HVfr7zyigDEnXfeuce6K6+8UjQ1NU0sd3R0CEBUVFSIVCo1kX7TTTcJQCxevFgYhjGRfumllwq32y1KpdJEWqFQ2OM4119/vfD7/ZPynX322ZOOfaDn7nA43ro777xTAGLlypViZGRE9PT0iD/84Q8iHo8Ln88nent7hRDjsQIQX/7ylydt/+CDDwpAfOtb35qUftFFFwlJksSOHTsm0gABiFdffXUiraurS3i9XvGBD3xgIu2aa64RNTU1IpFITNrnihUrRCQSmTLG7NbZ2SkURRHf/va3J6Vv2LBBuFyuifTXXntNAOK+++7b5/XZW9zefd06Ojom0pqamgQgXnjhhYm0Rx99VADC5/OJrq6uifSf//znAhBPPfXURNpU5/X73/9eAOLZZ5+dSLv99tv3OPaBnLvD4Zi+3ff6VD+PxzORb3f9KRwOi+Hh4Un72F0XvfTSSyelr127VgDi2muvnZT+hS98QQDiySefnEjbHV8eeeSRaZX7xBNPFIC45557JtK2bt0qACHLsnjppZcm0nfHqdfXE6cbh/dVx9xdhjvuuGPKdSeeeOLE8q9//WsBiO9///t75H19XXoq9fX14oMf/OAe6VPF6fnz50867oHY17YLFy4Us2bNEqZpTqRpmiYaGxsFIP74xz9Oud3e6sKvd9tttwlADA0NvalyvxVOF+iDLJvNAuz3A/Dd6zOZzKT0G264YdLypz/9aQAefvjhve7rvvvu4/jjjycWi5FIJCZ+p512GpZlTXTbu//++5EkiZtvvnmPfUiStJ8z2/ux586dy5w5cyYde3e3xKeeegpg4mn+Qw899LYOZnXxxRdPGkhg+fLlwPj3DC6Xa1K6ruv09fVNpL3+CVg2myWRSHD88cdTKBTYunXrfo893XN3OBxvn9NOO42KigoaGhpYsWIFwWCQP/3pT9TV1U3K94lPfGLS8sMPP4yiKHzmM5+ZlP75z38eIQR/+9vfJqUfffTRLFu2bGK5sbGR888/n0cffRTLshBCcP/993PuuecihJgUA8444wzS6TRr1qzZ63k88MAD2LbNJZdcMmnb6upqZs6cORE/dse3Rx99lEKhcOAXbC/mzZvH0UcfPbG8O3aecsopNDY27pG+a9euibTXx85SqUQikZh4Y7Cvc95tuufucDgO3E9+8hMef/zxSb83xjcY/2bzjZ/p7fbxj3980vLuOuiNN944Kf3zn/88wB49GltaWjjjjDOmXeZgMMiKFSsmlmfPnk00GmXu3LkTMQj2jEdvNQ6/nsfj4aMf/eh+891///2Ul5dP1M9fb3916dHRUWKx2LTK80755Cc/yfbt27nmmmvYvHkzGzdu5CMf+QgDAwMAFIvFN73v3ec2nSld325OF+iDbHfDdndDeG/21lCeOXPmpOW2tjZkWd7n3GDt7e2sX79+r4FseHgYGO8qWFtbO6mby1vV3t7Oli1b9nvsD33oQ/zHf/wH1157LV/+8pc59dRTufDCC7nooove0ojWr6+owf9WFhsaGqZMHxsbm0jbtGkTX/va13jyySf3eBCx+9u6fZnuuTscjrfPT37yE2bNmoXL5aKqqorZs2fvEUNcLhf19fWT0rq6uqitrd0j5s6dO3di/eu9MRYDzJo1i0KhwMjICLIsk0ql+MUvfsEvfvGLKcu6rxjQ3t6OEGLK48D/DvzX0tLCjTfeyPe//31+97vfcfzxx3Peeedx+eWXT3r4d6DeSuxMJpPccsst/OEPf9jjHKcbO6dz7g6H48AdeeSR0xoEa6qRove2rqurC1mW9xhJurq6mmg0ukf83Ne+p1JfX79H4zESiew3Ho2MjLylOPx6dXV10xrwaufOncyePXvSS5YDIfYy5sS75eMf/zg9PT3cfvvt3HXXXQAcfvjhfOlLX+Lb3/72xGd+b8buc3uzL9XeCqcBfJBFIhFqampYv379PvOtX7+euro6wuHwPvNN5y+Rbdu8733v40tf+tKU62fNmrXffbxZtm2zcOFCvv/970+5fnfw8vl8PPvsszz11FP89a9/5ZFHHuHee+/llFNO4bHHHnvTo9/tbbu9pe++OVOpFCeeeCLhcJhbb72VtrY2vF4va9as4Z//+Z+n9ZZ6uufucDjePtOp3Hk8nnd0qjhgIkZcfvnlXHnllVPmWbRo0T63lySJv/3tb1PGq9dXQv793/+dq666ioceeojHHnuMz3zmMxPjRLyxoT9dbzZ2wvhYFS+88AJf/OIXWbJkCcFgENu2OfPMM6cdO6d77g6H452xr1GZ97Zuug2bAx3x+c3Go7cah1/v3RilOh6PT3qYeLB8+9vf5gtf+AKbNm0iEomwcOHCiUG/3kqbYfe57R7z4d3kNIDfA8455xx++ctf8ve//31i9LzXe+655+js7OT666/fY117e/ukJ2c7duzAtu29Tj4N42+Jc7kcp5122j7L1dbWxqOPPkoymdznW+ADeXLT1tbGunXrOPXUU/e7nSzLnHrqqZx66ql8//vf57bbbuOrX/0qTz31FKeddtq7+sTo6aefZnR0lAceeGDSaHy7R5J9vb2V60DO3eFwHFxNTU2sXLmSbDY76S3w7s8dmpqaJuVvb2/fYx/bt2/H7/dP9PoIhUJYlrXf2DuVtrY2hBC0tLRMq8KxcOFCFi5cyNe+9jVeeOEFjj32WO644w6+9a1vAe/eE/exsTGeeOIJbrnlFr7+9a9PpE91vfYVOw/k3B0Ox8HV1NSEbdu0t7dP9JqB8QGoUqnUHvHz3VJRUTHtOPx2xci2tjZefvllDMM44N4qc+bMmbKeOZV3Oqa/foRvgJUrV1JfX8+cOXPe9D47OjooLy/fa8/Id5LzDfB7wBe/+EV8Ph/XX3/9HpNRJ5NJPv7xj+P3+yemiHi9n/zkJ5OWf/zjHwPj87rtzSWXXMKLL77Io48+use6VCqFaZrA+PceQghuueWWPfK9/ul+IBAglUrt/QTfcOy+vj5++ctf7rGuWCySz+cB9piCCJiYiHz3EPq755mb7rHfit1PFV9/3rqu89Of/nSPvIFAYMpufdM9d4fDcfC9//3vx7Is/t//+3+T0n/wgx8gSdIeMfbFF1+c9O1YT08PDz30EKeffvrEnI0f/OAHuf/++6ecG3FkZGSf5bnwwgtRFIVbbrlljy5xQoiJfzsymcxEDN9t4cKFyLI8afqRA4nbb8VUsROYNNvA68sEe8b06Z67w+F4b3j/+98P7Hmf7+4Bd/bZZ7/bRQI4oDj8dtUxP/jBD5JIJPb4twT237356KOPZuPGjdOaKvPdiukA9957L6+88gqf+9zn3lLvqdWrV08aW+Ld5LwBfg+YOXMmd911Fx/+8IdZuHAh11xzDS0tLXR2dvKrX/2KRCLB73//+ymHSu/o6OC8887jzDPP5MUXX+S3v/0tl112GYsXL97r8b74xS/y5z//mXPOOYerrrqKZcuWkc/n2bBhA3/84x/p7OykvLyck08+mSuuuIIf/ehHtLe3T3RXe+655zj55JP51Kc+BYwPY75y5Uq+//3vU1tbS0tLy6RBCF7viiuu4L/+67/4+Mc/zlNPPcWxxx6LZVls3bqV//qv/5qYB+7WW2/l2Wef5eyzz6apqYnh4WF++tOfUl9fP/EEqq2tjWg0yh133EEoFCIQCLB8+fID/pZkOo455hhisRhXXnkln/nMZ5AkibvvvnvK4LVs2TLuvfdebrzxRo444giCwSDnnnvutM/d4XAcfOeeey4nn3wyX/3qV+ns7GTx4sU89thjPPTQQ3zuc5/bIx4vWLCAM844Y9I0SMCkB4j/+q//ylNPPcXy5cv52Mc+xrx580gmk6xZs4aVK1dO+eBvt7a2Nr71rW9x00030dnZyQUXXEAoFKKjo4M//elPXHfddXzhC1/gySef5FOf+hQXX3wxs2bNwjRN7r777omK324HErffinA4zAknnMB3v/tdDMOgrq6Oxx57bMq3GrsHEfvqV7/KihUrUFWVc889d9rn7nA4Dtzf/va3KQfyPOaYY2htbX1T+1y8eDFXXnklv/jFLyY+IVu1ahV33XUXF1xwASeffPJbLfabNt04/HbVMT/ykY/wn//5n9x4442sWrWK448/nnw+z8qVK/nkJz/J+eefv9dtzz//fL75zW/yzDPPcPrpp+/zOMuWLeNnP/sZ3/rWt5gxYwaVlZUTg6xO5dlnn50Y9HZkZIR8Pj/RQ+iEE06Y6O347LPPcuutt3L66acTj8d56aWXuPPOOznzzDP57Gc/O2mf69ev589//jMw3iM1nU5P7HPx4sWce+65E3mHh4dZv379HoP5vmvevQGnHfuzfv16cemll4qamhqhqqqorq4Wl156qdiwYcMeeXcPPb9582Zx0UUXiVAoJGKxmPjUpz4lisXipLxvnAZJCCGy2ay46aabxIwZM4Tb7Rbl5eXimGOOEd/73veErusT+UzTFLfffruYM2eOcLvdoqKiQpx11lli9erVE3m2bt0qTjjhBOHz+QSw3ymRdF0X//Zv/ybmz58vPB6PiMViYtmyZeKWW24R6XRaCCHEE088Ic4//3xRW1sr3G63qK2tFZdeeukeUzc99NBDYt68ecLlck0arn5v0yDdfvvtk7Z/6qmnppwyZPcQ86+88spE2vPPPy+OOuoo4fP5RG1trfjSl740McT+66f8yOVy4rLLLhPRaFQAk8oxnXN3OBxv3VT38FSuvPJKEQgEplyXzWbFP/3TP4na2lqhqqqYOXOmuP322/eYugIQN9xwg/jtb38rZs6cKTwej1i6dOmkuLDb0NCQuOGGG0RDQ8NEnD/11FPFL37xi2md1/333y+OO+44EQgERCAQEHPmzBE33HCD2LZtmxBCiF27domrr75atLW1Ca/XK8rKysTJJ58sVq5cOWk/e4vbe5sG6eyzz96jLLvP+/WmirW9vb3iAx/4gIhGoyISiYiLL75Y9Pf3C0DcfPPNk7b/5je/Kerq6oQsy3uUY3/n7nA4pm9f0yC9vj61t/qTEP9bF51qykrDMMQtt9wiWlpahKqqoqGhQdx0002Tpo0UYu/xZW9OPPFEMX/+/D3SDyROTTcO762Oubcy7F73ximFCoWC+OpXvzpxLaqrq8VFF10kdu7cud/zXbRokbjmmmsmpU0VpwcHB8XZZ58tQqGQAPY7JdLu/3dT/V4fl3fs2CFOP/10UV5eLjwej5gzZ474zne+IzRN22Of+/o79ca2wc9+9jPh9/snpnd9t0lCHOThxRzvuIaGBs444wz+4z/+42AXxeFwOBwOh8PhcEzD3XffzQ033EB3d/fEFKH/CJYuXcpJJ53ED37wg4NyfOcb4H9whmEwOjp6UEZYczgcDofD4XA4HG/Ohz/8YRobG/cY8+f/skceeYT29nZuuummg1YG5xvgf2CPPvoof/jDHygWi5x66qkHuzgOh8PhcDgcDodjmmRZnnLArv/LzjzzTHK53EEtg9MF+h/YySefzI4dO/jEJz4xMV+Xw+FwOBwOh8PhcByq3hNdoH/yk5/Q3NyM1+tl+fLlrFq1ap/577vvPubMmYPX62XhwoU8/PDD71JJ/2956qmn6OnpcRq/Dsc/gLc7Tgoh+PrXv05NTQ0+n4/TTjttyrlZHQ6Hw+FwOP6RHPQG8O7pYm6++WbWrFnD4sWLOeOMMxgeHp4y/wsvvMCll17KNddcw2uvvcYFF1zABRdc8A/XPcDhcDh2eyfi5He/+11+9KMfcccdd/Dyyy8TCAQ444wzKJVK79ZpORwOh8PhcLzrDnoX6OXLl3PEEUdMTBBt2zYNDQ18+tOf5stf/vIe+T/0oQ+Rz+f5y1/+MpF21FFHsWTJEu644453rdwOh+OdM3fu3CnnJQT48Y9/PDEH9aHi7Y6TQghqa2v5/Oc/PzF/ajqdpqqqit/85jesWLHi3Tkxh8PxjnJiqcPhcOzpoA6Cpes6q1evnjQKmCzLnHbaabz44otTbvPiiy9y4403Tko744wzePDBB6fMr2kamqZNLNu2TTKZJB6PI0nSWz8Jh+MfkBCCbDZLbW0tsrzvjiKlUgld16e1zzfecx6PB4/Hs0fe+++/n/nz5/PEE08wb948NE2jtbWVe++9d9JE6oeCdyJOdnR0MDg4yGmnnTaxPhKJsHz5cl588cUpG8BOLHU4Dsw7EUd379eJpYce27bp7+8nFAo5MdfhmMKBxNyD2gBOJBJYlkVVVdWk9Kqqqr0+sRwcHJwy/+Dg4JT5v/Od73DLLbe8PQV2OA4xPT091NfX73V9qVSixRdgEHu/+woGg3uM+nfzzTfzjW98Y4+8Q0NDuFwujj32WDweD6tXr8a2bY4//vgpK3n/yN6JOLn7TyeWOhzvvLczjoITSw9V/f39NDQ0HOxiOBzvefuLuXAITIN00003TXoTkk6naWxshA8sg0ANkAbFBfnNuNQUQoAlJBC1wAkwYIPbC5kd4Ini6migvN/LaJWMMScLhcchUA5mHnJ1qBtrsG2BT0rhNTUKpAhRRgkLWSlgBzKk63Xc/UnMYiVBw02rXUcLblSaGSZPNzoKebJ4iWKzCBWNEWIIlrifIS9luVevQYhGPDRThkWJ1ZyHh1aiDONhFSkM6niZAgrV+EhRSRU+2lHR2UwjfZhU0YUmb6XebuQo4jyITi1hvLhQyGNRZCF9yFKW+phNWXOe8lpwRcBtQCIJa58pQxUCtzfPgCZRY0ShZYhsEuQKSI4qjGkKVVGd4pibXHEhOWJYyDwtraZGKCxxaRxXlyF2mCBXDek0yHkIRqHoAr0brCSEhl0MJEIM+lXW42agAEWihIrlLMBLFTomJfKkyaBToAD4cRFiCzpRNFrlfja5JNz+Ip5UgHkonHT0GM0nQc8W6HnGT2nsCDQkUrhQ0PFTg4ccg3jw4EHHIomLV33biEk1XFhYxK/cO8lRxOXNsyjjYX2khFWEqG5T8kr4zbmMNVp4BsYouTNE8mFOMSPMpoyHGEQnjo+tjGKjSF5kUU0LwxQRvBBzYddlkMwN+LKDzO6bQ5U8nxdmvYwWGMYjdHJ2Bbb7RBAyUrvMjNQSkoERRpf0gMcFZTXgMcCTA2UT7OjANZLCnDcTWo6B3gpoLkFSgi1PwdOvEgqF9nl/6brOIDY9NBPex5ACGWwacp309PQQDocn0vdWAduwYQOzZs2aWL9u3ToqKyv3aLA53j17jaUOh2Of3q44Ck4s/UfygQ98gKeffppTTz2VP/7xj/vNv/vv0eIv3sMTN53Fxr40V/xqFb++8giObC17W8u2u4dPWVnZft+kvZVtp5N3X3n2tm6q9DemvXHZMAwee+wxTj/9dFRVPaBzPlCHwvWdKu2dvsaZTIaGhob9xlw4yA3g8vJyFEVhaGhoUvrQ0BDV1dVTblNdXX1A+ffWLYgEoA2BlQelgEuMEcMk6/dgaRWgt8FoBAYMcBWgIgNGBnOeyqAvDFEPuIYg7IWQG1xe5LURvPYYsojgtQRZJIoeQVHuJVCqJRvyQMyHavgwm1PYOxJIRjVH0MZcJEZI4cNDHwVUBDPQGSVAED+tWKgMk9dn86h3ANSlXKQvZZR+ZtBHjGqCVLAKnb+SIolKKzFmEWQGgjEqCaARoMQoM6kghIdOFjKXHruCI6Qe2uilTZRRQKOAwRzK6WOILfhxC0Ek6ccb68U4TCNWMX4JpDRkepLMk6HCBzVuyKaG6VHAOyITsGxG8h4q3DbxAAzlVVzFasK42AnUikbmsosj6jLMOE0gtYKkQXIEXBmJ8rigVIDskBe2NrFTj/MsFYwVVfrCJUylE9tSCJCjnzw+dCQGKaKhIuFDIUSYIgYtuDjC20e/4SeiB6nWBf0IMqhgZ4i5LQoGCNNgiHYGqcVFHSV0BBYqfVQwCwuDcsYoUE3RdDHLMmkgx0l6iFelAsNePxUUOTZdZB01uBlAt1tYZEfw7xJIzMBfVKihxGwsxpBRURhwSYwFi9j5ISSvheWVCCTiHC9MdhoSA2oBOa9TMRAgyRhn2eVEO0/hgcO7yVhZIAoJG9RhpPAuutVh5NRhUCqHZBDpFRuxeBDiAqIBqKzDDDZCy4mQi0OhHkZM8LtAKQCvTrubVRgPYZR95LDG84XDkypte7N+/XoWLlw4sbxu3bpJy4eSdyJO7v5zaGiImpqaSXmWLFky5T73GksdDsc+vX1xFJxY+o/js5/9LFdffTV33XXXtPLv/nuUNFy83FvggTXDNNXEOXlRE4r89naJtm0bwzAIh8NvqoE23W2nk3dfefa2bqr0N6a9cdkwDPx+P+Fw+F1pAP+jX9+p0t6tazydmHtQR4F2u90sW7aMJ554YiLNtm2eeOIJjj766Cm3OfrooyflB3j88cf3mn+vfAvBnAGZWuiVMXMhRoo1lMbqoCQg74dkDnI+MAMgzUDqqwc7DZW58Tdl4WGIBmG0A3b1InohO9NHpt5ijAhFyYuQBcKTJxfRkQsBop1Lad11OHgWQ+1c0i0Sz/tXI/N3GtE5iiRHEyJGiEUI5uBijAJ/J0k1bnZQpFOuY4WxlQX8hQU8Sxmr6UPnPgL8Th7jCAwupcQRrGcpoyjEMQnhQuZRTxWvyVCJjcUQNv1Uk6HCuxMR6GchPhTJxUafwi4yDDHCFlJsxOIFfKQ75zKQkFFqIF0FlYuh8TDoTkiMWRBshKVXCRacDcHjbQaiYFQWqTu6hKcCSkUvWTR2UaKSGGcSZJFPp+k4QfwDEDgBsmGJ1c/VsPqZJjY/4Kf3z/Vs2NDC3/Usf6aLEhpzcbMoU8ac3EwqixXEsKnDpoCGV00SDafxuTLIqAhk8ljU1HVRc9QYvUqQAUlQIES9ZNAaHmXWTBvdC3IWzKBBzDuKhk4/aWwUysgjEcVPFS4KFAE/RSJ2HCHqUIlyCl5OES7mZ1xAnBbquYAGjuNw3q/PotpOso2NdCibKKdADA/dwBgWBkWyPh3D34DHrqA668VVTGOQJAHE8yHUnhiUBwmV5fGVjbJK3cbZpVlc+/wxzFk7g5nrNebvUggMBJF8boz4AJIwUNs13Kk/IlX+HoafhvQm0GQIRMG3GJINsGsxbI/BMxH472Hoqzyw+wn3NH7Tt379ehYtWjSxvG7duknLh5J3Ik62tLRQXV09KU8mk+Hll18+8FjqcDjeJtOJo04s/Udx0kknTetN1VS+9uAmntg6zFffP/dtb/w6HIeCgz4N0o033sgvf/lL7rrrLrZs2cInPvEJ8vk8H/3oRwH4yEc+Mmnwl89+9rM88sgj/Pu//ztbt27lG9/4Bq+++uqBj2Q4NAyFBJgWBDyQL0HCBZkIZBTkTVlQBZJUAn830lAaJRUEfKDpuFeXYCiKtE2AXYVciuE2CkipHFI+T1gS1IgoknDhytWilvyYMYVk5SjdShp1awwGqsHTwICngh7chHmOBlZTjkqaDFuBFtIcg0qEMAZNNGLzmUKUZmGxizJ2UU0Xh7GLOTwlmZxqR6jBzXo5Qz8VvEYNCipe8jxCgi5JYrlQqccggpsI/fiAjGwzppsk6SEj95P1DJBEppEcx+DGi0I/efqsXob6BHITWLOgVA/LzwelVVCqB3UBuI4Y7/pszwDPTJh5rsBXDV39KkXdxygGJgoe8mhSCf9cDfUI2G7Bq+1w353ldAw14bJ1MCyGih4skcWLRZQAszGw2YiLXbSisByoIoJBDlBQFYirgpjwEFZNfDWdzFywhZMPHyPkgmbbxzxRyzxJcGTVEEecN4b/KEH/ZhjshExJRq7SGaKABLSRALJ04GcnCQJIuLApw6bactEsTHpJ0UeSGhSWEGMLedYQoZI4Gn7KWcMWtrBT2c7aue08GFxJO0OM0oePMc4gyDnZZrzDcdx2HWmqCOcCJITFA/5tbAm/iGWmsfINbHU30eEJ8WK5wQb6OEb4+KfiEXwsupUvvu9BPupaxQm7FGbtOJK4VYfk91FWM4ivqYDULJAkAf5jcW28CPfLy2FNATZuxL1zO66eofF+Idpe75y9UKfxmx7bttm0adOkStrOnTtpbm4+0EL9w3i746QkSXzuc5/jW9/6Fn/+85/ZsGEDH/nIR6itreWCCy44GKfocDimFUedWLovzc3NSJK0x++GG254247x7LPPcu6551JbW4skSXsdhPVA524/EMm8zq3nzefMBTX7z+xwOPZw0L8B/tCHPsTIyAhf//rXGRwcZMmSJTzyyCMT36d0d3dPeu1+zDHHcM899/C1r32Nr3zlK8ycOZMHH3yQBQsWHNiBQ0EwDPC4wcqCMCFQhGwnWFFEMQIFBRFYDWUSQqvEGkuirJLx2nGOzdfQ2ddBl+TDLOvHqshghCTkvItoNkYtITQlS38sipWTcOkRAokkxYjEIrONcFriJWkQdghU04OLYSrVbgzLzwy7k1GqyAJFNqGhUs1ivLiZ4x3DH9/KCyNB1uoteKilEYVeRjheVFIO/FLpJSkPUGmHOZdGRijyOIPkEZxcirGcMGN0sIoCWQxicg5fmUF3X5idKIzKYSRDQ6KIhIZPznOUYrHLCJDFJJ6SyCoC0wW6CSUd5lwIOQGiCgYLINdAYBbEbdAHYeBlUAer0akjT5Amhqks+zuVjQUqFtuYZVAUsPFRDxs319DEGG41R8hrs7lYwufOkjP8GEKjgyImHqppRGUIlUHyyIQIocsu5NkWvgAERws01RWoawFPA6RyoAhQuzqItVdS7R7Cn47hDY8y5hIUFRhxuSjlIwTaRqkcKtJbKpBHYicaLiza6MOFTR6dUdwUCRIhzl/oJkKWHEWq0Cli0cAwrzILj/IYh0dW0Ts2g1cjBsrYGCEthkSeDnIo5KkjSydghUysvEK5HmdY6sRwdSCXqvEXY2T9GlJvE6YSQ87kUV1z6aSG+ZThxkUpeRbdg48xu3YEdayCnPDQ7X0Fvd4kaQQgqSPitXiSh7F4dTUV2UpsIVjfn2dYmLjsPMUWAWUpMHLQcSA3VIB9hxNz2nvauXMnhUJhUqVt4cKF3HzzzSxbtoxjjz32QAr2D+GdiJNf+tKXyOfzXHfddaRSKY477jgeeeQRvF7vu35+DocD9h9HwYml+/bKK69gWdbE8saNG3nf+97HxRdfPGX+559/niOPPHKP7pibN28mHo9P+a10Pp9n8eLFXH311Vx44YVT7nf33O133HEHy5cv54c//CFnnHEG27Zto7LyQHtYTTa3JsS2pEXPWAHbnt7AaQfKtm2EEG9q/wey7XTy7ivP3tZNlf7GtH0tv1PXdX/lfru3PZjXd6q0d/oaH8g+D3oDGOBTn/rUXt/gPv3003ukXXzxxXsNZtPmBUwDqnXoTSH5vIhcGFwJ0AcRrjnjPY1qJCiqkLNwGSH8mp86whyGQq2xgJ1z/o7l16DMj21JUDQokiGZLdBXmQBPDFeuRNQMkEejIefjBDvECCmOEhWEdJsukmynidlWH16RxEc7i8mhMIcEYZJ4KWMIDRf9QsdMhzH1GVRTxRYMMgwxJJmk3B28qntIxAwUK87cMR9jUjePuQqEDItZVDOPDCm68FFkGXFGEIzYBaz+Fp7FIiGVGHPb+JFRKGFRzTY7T1QUqfKNUWPLuOICTQJdBVWGQgGaZ4NRBh3PQOdTkDIh3wjz5oDPBXYOOrUqXJTTiERMShGryuBpAP9CGKyGvk5Y/0ItJVGOiwyGMPDp/fgkC3dNhhYtg0jF2GqW4y3bhZLwY9gjlOOhizBpCjR7drHoKBufF7be60YvCaS0garBti0ylSHoHQ4QwcdObSZuSSK4K4ndIDA12DUaHm9OemGpL4OvVEdCEsx09dDmWU+uVEGXuRwfNsNYLMHCIouFzBAmKjZFPMjYjBIgQT83KD1Ut+ks2WSwOtOIlLSJUk6GXlajAVEUKklIYwgMAkaYAdcQHtuNGVCgqKFoHmrzcSKE0KUaVOFiqdXIAgqAyTAe7nU1MLzzPCqyfQwpMZKLLIRrFLoD6P7DIN5AeafM+R1Hc6Rdz1aSjKCx2PDzGikGYimoGIYaC4zpV7LGudl3OJl+Z5OZM2fyxunJH3744QMszz+etztOSpLErbfeyq233vp2FdHhcLwl+4uj4MTSfauoqJi0/K//+q+0tbVx4okn7pHXtm1uuOEGZs6cyR/+8AcUZfz7623btnHKKadw44038qUvfWmP7c466yzOOuusfZbj+9//Ph/72Mcmeunccccd/PWvf+XXv/71lHO378tPfvITfvKTn0w07D+0OM6tTw1z3ys9XLk0jtv19nfmFEKQSqWA6X/D/ma2nU7efeXZ27qp0t+Y9sZl0zQxTZNkMonL9c42jw6F6ztV2jt9jbPZ7LTzvicawAeFpEFlDDxAfCbCDoIUBjkEuQyEW0AeHf/+16gFe5ga3U8VUWYj04hBSCjUD0l0z8oh8mWgqpA10Ix6kqoHIXlQB3ViJQ+z0KiknMVWPX7AIkozeWxUPFj0o9Jpn009w9TQR5BBEsQp4WOYEH5KJNAoanNYawuEIlOUehjwaDTkTXQM8lIUXfLjYS71RYuj5U08p9RR9Ou0puMEKTCGhQ8TL9tRiFGiDosK2i2dXtcQws4QydfRhoSNxShjKKjUqAazj9RRC2A3Q7oItg/iEpgSbPw7VF4IIgrD6+ClTWEqlxVZNstgrAAiIVEh/LgwSNKPLbwMj8lIeRs7AgEVghJUp91kcGMjoXiHSNaViGhDmF3NROoGmdE2Rq21mlI6StYuYwALD/14cOEmglmqYfTJMVRhYw7FKbpTSH0SqU1ReksxBrBQcSMzwBo81OJhvgBFhVQG/JqgqBZwC/CU5Tjc3IEn7ybsH2XEbWBpBUzcpLE5njBRTAaJU0MRDz6CRMhRxnw0OqhhKV20+FMUPZA2q6k1WxiQRulVLEJmEUXy8LRrkEHD5jDhZ3s6gl9olFsFFopF+FKzsCnRSwUBwkQx8AgX1QSpxEWYAGOUeIkhenyjyCUPQebQaFXwytDLjM42oAXoqKaleyEftxpZQJguRghg0I/BPFx0E2DAGwZPCUwNEgMHeEPtr2ue842Sw+Fw7Nt0ujg7sXS6dF3nt7/9LTfeeOOUlX9Zlnn44Yc54YQT+MhHPsLdd99NR0cHp5xyChdccMGUjd/pHvdA527flxtuuIEbbriBTCZDJBLhrMWN/Hx1mqGMxquDBucurn1T5dyX3W/S3uwoxdPddjp595Vnb+umSn9j2huXDcPA5XJRVlb2rgyCtbdzeju3PZjXd6q0d/oaH8g+D90G8FgeQhEwxfh8PkkV5CgIPwRbYSwEUhKkCqQBDVFukfWk0cw81aabBDNYJW3DP1ZEssoQ1UHYaIFLASmL15ZQByMIWzALD8cySjlJoESeMHWE8CN4jmFWyyY5yaDR6mamNExWJAhKGTLCS5HZFBnFRQCJJO3yENvKBGJMwSUkagtzmI3NqIDDSwYhVPJJF82+HVRFElSNzWRZuoY2YgRIUoFOlAw2GoIakvgAgcwgh5kFdhKjQIYuvFgUiBFiMT3UeQfRR1SKYYPYAjAjEEqBboC/Dko944NlqzUwlvYSbily1AcNsh4QWyC5PUgHCgHaKSdNSXJRt8Am8inYHIdiCUpAa2MPwc0e3OU9VDfmKVkw43jBrrUjjOwET368kZ20bGTXRsrMWmpoJo5CGgmX8GO2N1GggM+dQg7rpEbLyZcOo4IiKpuRVRnZVGgVLupCSdS5NiMbQB6CkLdEKe9BSoLsEXiXJ8mtrmJ0rB5ZTmHaFcQpYlPFapK48dGKwlHUE8ZiGwpxBhilFlvKskAMEKnKoBsyQq9jEIsRbxG9LERVX4hMYAxDG6NHcnGqkDndDlBkJjOFRYBu6imQIUQ1FUTxM4LENoqYJNGQceOhhEDg4oThenS8NGFiIDG7fx47UynSXg3DF+M4q0AbSZKkeUlN83DzdvSSwoJ+L5Jdg1QjI1r84BXQvb+RSN8oyL4rbsabuk0dDofj0LG/OApOLJ2+Bx98kFQqxVVXXbXXPLW1tTz55JMcf/zxXHbZZbz44oucdtpp/OxnP3vTx53u3O2nnXYa69atI5/PU19fz3333TetQQjdqosPHdHIj55o5/ev9HD+0n3Pd/pmSZKELMsH3EA70G2nk3dfefa2bqr0N6a9flmW5bd0zgfqULi+b0x7p6/xgezz0G0A5xUo+EASEG8Cowh2GLpV3D0RLFPGikswFkCEBN7RIhIGfuFiMwY2uyiIUeqR8W7zs1nvRSuFkZIz8FpRWqw4naTxYHEEKU6TXuI1MZMi82nGJoVGN6BhMqDYRCkjbK3DJXVQEtUUxBK2UkU3XmZTRg8qYSxkBURDGoIJwj2VLBV+bJLMoosZUoKyshSjimA0F2VregZN5JhDigQdBBgj5h3FMm1SZhCBxCK2U6CJkqebqC2TMprJM8qAfxgXRVL+GLFkiGBmPnSVqP7EdtxLIL8Ftt7p5/DjC5SdCv4Txl+Ub/2rm2zvHBacv4FIKwyvh+xDQbYP1JMmQkxWydgWhqJgeaDDglQWpCIETag8tUDMuwFRJghGIJ+CvlGoWpwnfTKURUCPQFsuQ/6pDP07etB7qojo1aieHAQ6yWcCDJl11OgxrJEsQbx45T7K67ponJ/GCkCmR6JtTMHlMZH6ILkFRBIkbxE7YzDSLVHeJlAsCJQPoaXLMOyZSLSgMsoweTajUY4bPxIeahgkhkI3IHg6pFFRzOCVdcxmQcktkP3b0YtLyJMCl2B11IVVyhE0/DSi4iXGHDJY5GnDRKMTkwybWcIrFDHoRQXihEjiZZACffTQGepHUElbVqO7tpsXyvK4uhvxGrXES3VIJYVirkQNMh1IrFTW8fTSl9Cqg+BZSOJvKkqhgFAFKDbyGg2pS2Dt6/7Zg8qBjk7qcDgcjtdz4ujb6Ve/+hVnnXUWtbX7fkPa2NjI3XffzYknnkhrayu/+tWvDrhb6puxcuXKN73tiiMa+H9PtvPSriQ7hnPMqAy+jSVzOP7xHboNYBvQ3CBnoGjAkApmJf4OmVg+RErpJD9axJWtJCZbLNOP4FgamAHItFODhocwNoKRTD93bfXzp9YMruEIZbqPIBbVWMwkydGsxyeS7KCIic4mNNKUmEOMUUAYBeagUE0l3XY5w/hQaKQdi2pUwujkSLIdQYNhsWxTGbqookKvpAEZNyWC8i6Stodczs+gXs8OUUYONwtwsYRuqkmSw8MGrZo6kuSoQGChyGPUxUYozC7g6wqxqM9mh2QgKcPoIS+UZdikz0I1Blh4egdVMnT9BV57IkZ+Rz0lrZ1li0q4ZoJigOQyaatrp3KGRc866LkrwnB3MwOoNIT6mfmhnaQeiKJW5Sh7H2SawB6BUAGKyvhUtO56gW1CXzcM7nIjp1RSbqg5vkDd5YJdFshxCJ8B/uUlBh7pwjvcS6DGwp2FfDpASenFrsgQLDORcwLdBfEVNr45oEchNChQe02Sr4FWAFcVFDXweyAUNgnHwTShMAS5YbBdaVTdQ548KoI6ElgY9FOLD4W1JNmo5qg1QJICJOydeM1ytvn7me8DVzV4anagdZWDsKFYwgxmcWsy82hhCXUoSGQoUCBFkghjHEWeNAmCVCKTI88gLlRy6PgYUix63cOYoQQB1yj+XA2Zyk4MXw7f7M2kfPMYVGYgdZZR0RvCQ4BVSidPtT6CIm2D3FKqNsmcnG9hrUhRtkYQ3FDAW4pg2gl2HdANdeDTczgcDofj9Zw4+nbp6upi5cqVPPDAA/vNOzQ0xHXXXce5557LK6+8wj/90z/x4x//+E0f+83M3X6gaqM+TplTxcotQ9zzcjdfP3fe27Jfh+NQceg2gFU3GCUwYyDnYMyPq9+iquBBkpLka3fiKQhazRBzqWQ2Hpbi+p93smNYpMmTx8KmggKXanWs6a4ma+sESBLAzWHAMYzSLI/SY9cwQh0djNHlTlFyJxjI1ZDEQ1EapF3sYhZ+bFp4RPJhIzEUHKJRl7G0egRJAhSpIMTSogedVookqUXGlrJU+HU6c7NJaEHKyTCLUUbw0EMjfprI04CLMgyxgxGSVMmjjEglYmIOZbNfZcY8GzmeJh98nkVpN7IxRjENfcMBWiwf4VAP7h0Sux4LsUUL86qoZIYYYdW2GJ77Esy/wSBrQWymTXFhnlI5pHdAR0+crXhYqBosOWUDmZBAMv14F2cYbYLtCah5Adq2Q0YFLQs962Vsw0UmYZPRvHirslhJL7GdMlraIlADniIkTbBGIVAGbtMmuSGErhsUrXJyskylmgC/QDGhtxUCIfD3gMcLUQWyFggD9CHw1IN7Ifj6wLMAgnNBdEBhA3jDUCxJ5MlQRpEBBGkqKZJBxcsO0nTJOSylSMiIsElYhAtuRuUcWrGGgU0D1JeVqJ2dpbVnkIS/CiWrYc3240vo2EhspcQqxqjCSy0mnaQYo4QHHzlsZHKUkBHIGPgoIlNy5bEiCvhyFMMFOhMeLMNAChi44jr0pKFqK0pZG3N63Gx0DfLorFdRPbswPFGUkXIW7yonLjw0ESRtaLQaFUCGjgOeIc2puDkcDsdb48TRt8udd95JZWUlZ5999j7zJRIJTj31VObOnct9993H9u3bOemkk/B4PHzve997U8d+/dztu6eV2z13+wFP2bkPH17eyMotQ9y/ppcvnTkbr3qgny45HIeuQ7cB7MuMD2GslUMHlPW5aCqGkJEoCAv3iJ/mUjlN1LIUF1FcBBlFZRRBEhcmIWxkLAQ6ZfRxSX4OqyhSjo96VFrYiItu+kQj3SxlvZqlM7AdKefGthQEFjMoMOLposdjsypbA4pNZ8NaxEgegjLtFRae9l5ai/VIeMkisxoFiRGGSCHho8U9hB2B0ZxKCQsvcQZIYuHBR5Yoxf95S2lRh02EWmJqB6YoMqDH0V9ZQPfaYZojWU6+PMORR8Han8LO512Mmm50DEqZGAMb6nGTJoSbsGSxQVUImYLks3WUFnVSVMEagtFtUNUMuuxmTLQQxk3M1446ZDD2WBuxliGql+ps1kDKg38ddPbDS9vKGNZM/JabeqsJD72YRMgm3KhWmLQ2SEkp0FWEhjwEOyD/FGT73YwVqlDMIioKOWQKIkSpCWJHg5SFuji4wpAOQ2Vk/HtjfXD8k+30ILhdEA5BLg9WASobwKiApA6jg+CyBaHwLuxwCaN/Lp22Sjd+QpQoYeO1PcwpFYkSZTZRPCKAIXIMEOCVznlEG9fStsTm5K4ddO2IM1TpQxrV8RvgIkA/aWCMMjyUUNCwSAC6NErKJ9DsIrKuoooo3R6FgKTRWLTIZQPkmoPYKYO+CgHeVjC9ZEcTUOVFioU5+jU3LVaGe1sHKVWNIlmzIL+I6I6ZLBExbCnJy7511BaaqKFIPwP0+NZB8UBuKD/jI8rtzaEbahwOh2N69hdHwYml+2fbNnfeeSdXXnnlPkeatW2bs846i6amJu69915cLhfz5s3j8ccf55RTTqGuro5/+qd/2mO7XC7Hjh07JpY7OjpYu3YtZWVlNDY2AuNzt1955ZUcfvjhHHnkkfzwhz+cNHf72+GEWRXURX30pYr8df0AH1z2znwL7HD8Izp0I6kbUBSQA7iTfmYVK6nCi06aAkG6S+VI1BMnRwgZhQI5MlSQRaOARh5BCRWNMCZ1ZDiZNA34ENThRSNKkCytWCJAkn6EksOKFZF1m9pCNeUozGeMbf4Ig26bZMYEVyeiKkBgNE/5sIJdDNHvDhApehhGw0Yw4BpFVXrIBP2oyV5adYMtQzVslxXm2Fn85AlQhhcbPx4Efky2MkaQLkyyNFDU6vAB9VIXpjvLM/lK1haCvO/5HBXHCnI+hf5SgHIMQnKCkCeNbrhxm1Fq5DEWSwXWWjX4RJqS4SK7UaKkC3zDEC2DpkqQ+g2a/e3IhXlUZcNo6900zOuk5oMG+ThYEihJkNbC2KjMQCnGiFtivmngq9yGLx1DSCUiVhFJ6BQSGv2/kfAeJchVgNIFLg0CqiBjKhQIIgiQQlBw5SmfJ7BPgtxK2PqrIGpDicqPmRQVUOMQmQkeP5TrMJYCu2d8ggmlHMZ6QLfA2gXKcISk5aF+2TByDDJ/yRHWS5TjR8XAj4IfDYMoNgbLkMnSgYbCRmClGSa+uorjGgdYdFSB0zo72NS/BLftwS0MYt4tnCwPoRaW0EUeF3my8gi95SHUhIkeTIGZxI660cwMiu2jpEXpkmwW5sMMbQ7QGYtgKwKpq0BZajYFdz3anCJHrFM5fWwW9wVfpuTtBs2NL7mUmTvn0mCEgDEeqPkTQw0dJNfPIlmcQ15OkwunDrABvL83F2If6xwOh8MxvTfATizdn5UrV9Ld3c3VV1+9z3yyLHPbbbdx/PHH43b/73VfvHgxK1eu3GNKpd1effVVTj755InlG2+8EYArr7yS3/zmN8D+525/OyiyxKVHNvC9x7bzu5e7nAaww3EADt0GsKlCSUEaiVE5FqKSEE1YDKOQIovuKpE3x9/uKYTIImNikqOIhI0HCQMTDyoaeWRyxEmgSia2SLGDpdyLjwIp2tjCXLmDmVqQDr0C4ZHRi0mGRZh51LI06eZRbxKJABWik5bufo4MWlT5LYxUnA6jElNSsYWHPooU4hmEWgDZRSal0m21sc6EnX4DT8FNPX7cVNPNGFXEqZW3oge6OTy3kIQIUiKHhYKLOkw0vPIItjxGyvbSs1Uh/rLJvFMtRjcWGOh301qWJSgLtg/KZJQEYcmkQVZxmV7yUp6I18SqFAz3y/RtLSO2OElzlY0ZEsw8vhvWaKjhEpVnlaieBekNMPZ3UM8FoYJUDqnFNg1Py1SXPMyKJIlW53CH8+SzMvKYF8WvIwNDa9y41lcyFDIJpgRhqUDBdiHjQvEY2HaajBHCtgtoA+BJj39y25NWKY16CWxIQCt4SxBqgGIQYnXAekivlPAC6k7B4BAotWAOBBg1mkiSZkCB1rngfWaYw0ZNhmminygpJILkSRIhziBReslTwE0lMVxsDw2zMzOfpqdMKk4ZoVIKELGiWPTgD7az7NQeBjaGeHmnycv4qKLEGCaCIQyPBGk/xEywelDsCPPSPuqsKCVkYsgcnWnkOUPntWiGskw5EbMWl1CZsb6Xy8xyBsixpSIDkV7kYoxj2uuZa9XgYZDH3F30BPuosBP0xRbS7q4DrRG8AaDjAG6o/Q3e8s5OKu9wOBz/901nECwnlu7P6aefvsf8x3vzvve9b8r0pUuX7nWbk046aVr739fc7W+XSw5v4Icr21nTnWLLQIa5NeF39HgOxz+KQ7cBrJZBXkZJWLgE5EhRQwMFNApksD0Gg8owj3jzrHL1Y5olLsk28yHbiyCHTQ43Ojo6bgQ6Fi65QN6uYJAjeZkAf/W9CEaBbjPHHFtmNtX8vRQg3+gmpeeJ5W2epsColGWWpXNu21re974cAZ/AF4BMGoqZPuZp/SR3bMG/YRYbSrNJpS2KoogPDWF7KWDhRiFYLIE0ioQLd7CbRYE8ZtGHPnOYwLEa6h92UBqqRSJCTmmnxjYZERZGtgofKibD9Odd1K00KV8Iy482GNpooI3A8GgQ3VaxlSIpWUVtKuFnF9qAhLsSSgbkX4sBfkKRUTLS+FvUUDkUPziEXQ9SEDpflhh8qIrg7AQej4ldBP8CyFRA8+Y+mmfalFWU2P6ASqbkJyAiRGcOIB9nYKyD4hYX2XwrRkGQoZthIuhIxOQs0dn99AwrbB3UiMk6+RhEVVCOhNmvpCltcVMpQcEEjwlKCFx+CPoh6wZ3h6A2BLoN+io3hXQVttHCMBY2Q2zZoBKsNHDV5/GnNCqtckpUY1LATRlxgsjSa1ikiYoq+iiSIIjlT7FLr2JBoore51M8mo+QcLcz1xB89OgBXFXw34838aq3iG3k8VphNFFCLlrEtSguSac4pqCIGuYazRwlqhlA8CJ5Vsk6M4TFCUUPnmID5ahESdNsWVRQSQyLXSRAUsHbSmhHlPlWGQaj3B/bSNfsNLbUSHp7NXPHFpPw6pQ0m8yYfYDvGfb35sKptDkcDse+TecNsBNLHf+rMuzl9PlVPLxhkHte7uabFyw42EVyOP5POHQbwLkcyH5MuUSSBHF8JChRh491uLHjClZgECM8SLHYDj1e/iLXsdyuZybDGPjJMUKGZnxsw4UHxQ6R4kR6mcsuXkEXeWpNlTAy+AxcRRkpp0LSwgzHGSloCDnN2couLlveT91SC1EFeRPaXxvv6OSLQ9XxgsbTS5Sv3ojr/jzBwQZyopwgGbx00xwbxCO8lKXqiEYHqVQNgsugtglMHWKHwVAztKZS9P1Zx2MHqShP0Uc7mZ2HUa9sJmZF8BHAa9p0dRtIHTaBakGVDSMlhYjmQpGzFK0KtMoEIy6ZVzsqQDNp7vSwuFcjWplFnpXEnRWMPgX5dpniFj/KnAJ1tTbd7WC+pDBcMlFli0ETojrIYThqDJS2AnKTzOr/biRXTKPaMtL8fma+32SkB4q9IAp+ZHoQ8iAVQiOvqCTNOLKdQt6uMibbFOQQzeFB7BnQHYWwCUdfZZN/pYRuQmAHFOtBT4/PZ1xygdsPDReDPAZaN5jrXXj1AF14GcCNoJLGERdjnX2ElwispMxITytFKvCQoww/LrmbYLyPXMFALmr02iqdIQNRVo8y4iMnjaEl/aRQCUvdVLYlqD3JYN2LbgYLXiK0I2ijApvFooWOXJJlooxq/OStHBIxAsTZRQevSV3khUKL3Uw/UbqQWUQDEVLU8SoxomRIYGFRQR1HD3nZXCznmNH5FOQMD8xYy2jdJmhuwPvqDI5O1tEobDKFEI/LGYR2oDdUAPDtY70zOIfD4XDs2/7iKDix1PFGlx3ZxMMbBvnTa318+aw5BDyHbtXe4ZiuQ/cuERIoMZCHyPohVGplnl1kGBsVgVQ0EA0piMjYfRUgeclaMi8RIUo1cV5BJUOaPIOUEceHjiBPHc8wyBYpQ0zzkZFLeO0oFqMokoUrIEG9F7s/Bbi4MNjF1ScM4ZknKLkgsx76h2HXLsgMeKg9SiM0H7JBqLrC5sgZO6l8pJuh9SG0rIa3ukDVMkHcLpLdmiVcY6IBkdmQcEGkAoZmwQigfsDmeDVHxJWDHAznxyjm15ESJcoSoFthPJbB0FAdbm+JZvcwpQGIlFuk8hJ500dcTpBXDdZ1VpCUW/CSZlD4aPLvxHOkxq6X4uQCWarbdV5dW43Hklngz9EVhVS7jDnqRokkCVSNz7Hrs6FvlUQ4BuWNgnVPBBAD5RS9abAMQhUmw12gPQVKEDzlKYq5HHbRzTBBwuTxymlKdpwx3wh11ToLuztZdrRNuhb6LKjVwReA4OFgrAVpOyT84ClBmQ75Apj/87pzsBNymyAXLmKO5FCEjoTORgKkbQ/+4QSST2M4LxhglBhx5mAiY9GubqWhtoQyz2bHC6B3RYkVbZQOmQZrI69pEtHSEZwe3MrskweYf7aFyIGnwmCWzyZbnAGEmeXdyDF2P7pcJOB9Dc1U0IseVGsJ/yWl+LtnDSVVUJWPU2aXyGNSIEgck/n04EahSBEfEllmkCTHx/Mzac+7SVLGH8o2kfYVcY1WYY1VYNmjjKgF0GUaCREhTNJfhANqBO/vzcWBzSrscDgch57pvAF2YqljsmPa4jTH/XSOFvjvdf2sOLLxYBfJ4XjPO3QbwIUSWCPgDtCkRbjcrmMWIwhKaOE0dpsOxRAMhlFGarDiKVK6xQP6BnboLi6jigVSP41qN72mF90OkuNYxoiw0bWJjGLRplVTKxJoGDxZbKMWD14ZEB1IOY05AY2Ljh8jdCyYCvjckB4aH7XYCkM4alB5Jgy9CN4o6PWgzoX6OQbRV5KMPQ+BsyE0f3w05Yq0ieUCPQemGxQVMn6wA6DpYARAORZKYxDuA7FD0HLWCD1/VUnZKjJVhElRRR5LCzC6NYxeUrGjOQxsiopJr12Fb6REk1KiS3cTEF4ayVLQdXpfdNGeq6ag6lgDBsMUaBXVBGohtwuSDzSzKy+xID6MdWyWvBuUAhQTfuROmag7i9EdQ43tZPncNCUfaBEY3gDlCtg5UDwCt2xg21AyXBTMKgKuBIptIFUZjEUU7FI5pfUZXI0llJig3AZvFvxFyAagNAKhF0E9BoZN0GwoeMBqh/x6yObAUEFpHqbYVUnUjqFKRXowWeSR0BSFnWMLKDKITYAQKTbioVuLYG9ZyJzDN9N6eIFSt4ZpesA0cBFiu6+ClpLNkUtGmXehhTYCugnVlYIjTtjI8N9rCVQnOGFhlmo/WCaYHkiugdGtTQzSxAa5B40M8XwlS+1WXMSppJwabMIMorEZnTgFLNIU0fESxscIAdIE6SDFeckI+lgRH808FNrGwGGDrHXBsZvqiJuzSFUnoM0Dzx3IDeU0gB0Oh+OtcRrAjgMnyxKXLW/ktoe38ruXu50GsMMxDYduAzjiRclWsCDr5/r8DGaRI80Ifw0MsG7JEK6OCHYmhlBciJgCsTS6NUxvzE1hW4nG0mzCQuCxNqNTRCVGHxX8J2tIWXmaTJkmYBQ3RdzICFJSH6PVESQSeGUfJ5aniM2CtBssF4TiUH4SBCxQe8EXt/G1QMIAYYEhwajxP59zLoFoOajN0KdCOA5m0/j3q6kUKDZoAnQDfFkYUSBnQawN1NT4CMxuH2gm6LkycpRwkaOTSpox8dFBqRAlT4BQ0oPXN4CkeSnaEp5iDY3lWzna6mWEGvyAX/fTrmsUIll6B2KEKdEoFLyuLMIFegYkPUwNScqbCsjVYA9AZABEeZ5SXiIdgZnLByiUbETTeKO/sAv8FqgtUNg6Pn1RsBzsoIGZTZMbNVBMFZek4y9a9HbFSFtedvaZzPmzRbFBp7MGFAP0jSCFIauNX8OECmYYBi2IjkD/Zoi2gbTKh5FwUf6hLNIL2xjeuAhN9qPgIZXVmP/+HYRHO5HXNKEIFwVlM312FRo5XHqMnfc10NbaSYwcKYLUSgnaFI3y/DK0UCeKT+PF7wR4bdhHuCnHqWeUWHiEhqZ2EEhAMQ87MjJmUcLqriY35MKyJEYYpNwCrGWkXSV67QzH4aOBJEV0DLKMUYXAh0U/O6mjS0mx2CrgohU/CY5lCzPJYQsbQYw/iz6k4STC5SWlBOk3I+jyIMi9B3hDBRifwmNvDnReYYfD4TjU7C+OghNLHVO5aFkD33t0Oxv60qzvTbGoPnqwi+RwvKcdsg3g+K56zkjP4SQryDz8jLCFPyhrebhmALOvGc9wDVZNBhFPIYw8HmsNLlknX1hIss3Do7v6UIqzCFlxLAapoZUnybFT7ka1o8Qpx4tgWE7TX1+idtTL4ryGZzCLyxXmsDGJ+dVQ8IFpQHYQkgMQOgyi1VBWB7YGuh/GhmFYB28BDBm8gK2AvXi8gYuARAl0N6heyErj+9Qs8GShPAHRMKT8kPXDmAR1M6GvBmQLahemsFdVksXEYJA8YWRZR7YEPqlAVWSAzqKCbUcpyCP47QAel8qJy3fSmexD2xXHqssSC0q4O0L4rALeeSbVmQK+pEVUh9ggZOVOKqMGM+dbpPtBk6HHB5Em6NrsJv+qwcJWg4pF4NJh53bYstqPz5Zom5HHbhqfqihfBKGDXISQqmFZlRguA3W+oN6Torw3S+MsA58X6rdCpgpyKtgZMJ+VseZLRI+y2CGB34ZwHkQA9EXjDW5xVJHQDtBHwTc7T9UWneOsSrZhUOxbgLati/kfS9L5iwLG1n480RTzciZbMnOQpW7qapI0Vtn43TmONDqJNe6grNwmJg2i1BdQdrjp3XYYNjLDqRTbKjZSfoJF7y43XduibBUBeoTKEuHjSCoAgY9OZrOVUcrYhEy9HWMhFSykhEaeNCE6KWJRi4WgghxP+AbZ1baNdYPl3JDQaEUnT4kSEiYwQgOGpOGvfBx12wxma/P5S8M69EwvdBzoVA3q//z2td7hcDgce7e/OMo01jsORWUBN2ctrOahtf3c83K30wB2OPbjkG0AX5tcyjGUY5KlnT5+7H2SDnUVuqgExYden8U95kezQQpvwe9JY9VJSIU0wmimzyvzC3krQh2kLKcw06yl3dWHFYLWsTAJ/GwhQcFnYAfDBBN+5lNDJmERxmKJe5RwuaAwCtoobP+bl2zepvUKHf9FIMIgjPHOTt29Mj3r/Cw6KodUDUoA9AKoGozaYLjGf5IKuoAxF5gZ8FkQ3gL2WhjxjA98XV0OkUbABRVRWO+F2cdrVA0PoPR6yZgqRSWFZvpQkfGSJo8gXW7RN6BTtGO4yNIiaZTFwLe4hL60j2QdWP0ShZ0JxLw8848UmJuLpJQiqSe92EWdBleK6PzxaY/yOhgeCPtgdECiqxDB3urnma4h6vo0ZkZsBjsU0qly3M1DGLPB6JPJZxQ8RQOXDFkBVsmDF5WoYiA1QmPKZnTUJtgEBTckV3rJuzUqZgoidWA+H6TnRR/WYUOIIJCHaG58OiTTB+luaDgHRmNQeBTklAvZv5kqaStGtp5RazZd9wWpj42xcH6Jrl4P6nxBxWoVjSgZJBqrRvEvg/TqHoxRGW04StIu0npJGikHpTUSsdh2yiUNr2EwT9hI22BwV4Q1ViNr3CqKoVBPEIssAj8jhBgkRCU7mcsxeNQevK71hHQ/7cZ5JPCzlQJeQoQwGWMeObOPaG+OkO5nABe/U0YwhM2RdpyLCPAcccaUR7CkcgKlal7wJhmLrEdUlqjc1sbwAd1R+5u+w3izt6rD4XAcIqYzDZITSx1T+/DyJh5a289Da/v5ytlzCXudhyUOx94csg3g5ZQBNkVi3OG6hzWVnUiaG+GPgaIQGIxzbLKOdVo7+WIVec8wQpWpGA2TkQNUpmLkJI1UJM9ohUJwIEleKlKT8zELNxtJ4cLCpfvRuwPUFOoISymO82zGq7kJNWRQ6iGjgm1DIm+STcqoG6H+vPFPlH0BMIfBl5JZ19mEfFOWeVf1wIWCoAQlC3ydQAZEEGQvqDbUZ8FOQsQF+Zdh+0YYHAzhVxX8bp0ZiwuolaAdA5nlMFgBVW0m1fU5Qv3gtSHf60cN5xBejVRSxl9tEx/WUMmg2TFyJYnRdRJDT5XjacyQW6xR5hcsuGgIMRfyj4GyQ4K8G8MnE58hSLeCdw5IGiQNaHSBW4y/sY57FGxdRi7GSHamGTwvj6fWRnllhOCxGokgZIoKw0aMKtcolS6LSFYij0WMQeSAIBGHQC34X4NCD+RckB2oxPOAzPD7evAdYaGclCWYytLbAGNVUDsMdhWkdIjslOhbW0k6M0ZjpU6qCcqbLTwFk2IXuDNZ3CToTUiE/yBTOEYwkDmBfO8rBDwWWYogKkkORhjelWAkW0VSeMkXBMWhCFFzF7EjIOTVWdA3RHSbgmZaxMT4CNded5FcyabOjIAwaZNGMUQDMiMUWcgTqBxGDW2RV2hd1oG3IEh3uAgP2UQ4gxoqqUEhj42fEguMMeRUiDjdbEZlwArSiAcJG4s0GglQC6iZFLbcTtYvEO5efMkgH8rF+PEB3VH7+3bNqbQ5HA7Hvk3nG2AnljqmdkRzjBmVQXYM53jotT6uOLr5YBfJ4XjPOmQbwDp+KtD5o/IKr0a6wFdExD2Qmwc1NkafQSUSn8hXY+Xb+b1SRVqYvN9W2SZv4uXmELaL8desspu+0X5sy0XECpNEo9+jo5VpUFFCyqko+QLCN0JtUx5fukDwWIEehewukOeAXWUTTwfw+3RKAmQ/IINhgjtuUq4OY2U8SAJCxfHpjUaTMPQLGc+Ija8GyqrA5QEpCZkayIagY4PM6CCELJOCGcGlFRF6gbEd0D8oI82wGa6B6iZID4NShLGdEpHaAtUtkJfA6LIpU0BpKpAJ2chdKeywxbaCoCTnqR2zaEjDhudk8psCeJ+w6O8J4PYVGbkwhzpDosUWDFZDnwyxjTC4C3x5hfLlFvb7BG1LBsj1QTHrojTP5MU2iKgCbUmRdgkWPQIjmkHKJaHEPURPLyA/KvD06+iyxGCFjSqNd3PO+SGUh5IuURQSudEwlY+6UfJFUq0C1xjoveCJjl9fjwbyTrB3SaiWQanDhzFbp/xoELIgdT94LHCrOQxrJ7qaI5ORaFhkIw1spOK5Y3E3/xV7OI9QOgmVkhRKUFafJL+rBb+QyYX68Bqw9jdRipua8eS9VGtuouogxYFhAmUpmosS51JAsd0MeraAcFHS6/FhYqJzLgqSbysVszsZ0AQb1lezsdDAfARN9DCTGdjYdBDCokgDXlSKtDFED+UEqKCSIK3kEYwy6NqAGi/hkhWq7GaWjdk8rYWpLiwiccADrQSA4Nt9mzocDschxImjjjdPkiQ+vLyRW/57M797uZvLj2pCkqSDXSyH4z3pkG0Ar+Rl3LLJX2a8ghW3of4YWDMAaS9U7USLZnkqU2SB5ifKCHmpi1TI5rX8GEG7HBEYAU8OzEbYIbCFC5ftoZcQwyg06wodUgbdn4GiQklyQ7CAuwJc8wTxo+Cp+9yI1W7MTQWClk3laWm8R4KcgyED/EHIy5CxIEgJX3kaKS7Y9VNQVejZEEbf4cbbmiAnMd4A7AFPK2gu0IFSykdI1QhIJQqmge12426BzDoJ91YF+RWb7pPAn4LUCzJlKvSMxZkXH6N8nolLB6KgeUBfbmOqEH9ZZ8fDXlKmxZzWArYBvaskNm53Ua9qBHuCVNTmWHV+iZGTPaB5aOjLUK+DsUpm+5BAQkF5+ihM5WW2XOSmuNREMzzYtoVRFkdkUrhcBkZjmEi3QUtvAWtUYlFwmHybQAuC3Ar+wRoMJOSqPmp6Qdsgoac8DKW9GEImJnyoZVuIhwzMl8BVhEAAJBuMYQir0P3fKsNP1KPkApQFtxAKW5QC4w8SoiEoa4PRdQoxqUjOZaLGdBQJ9B0gzuwkvrGFfO8i5ta8htu06Ogv57WhGM1l3TTO3EpRdlMpNDbc1cyu3EK2hVzIYogW/LQYC6gbG6Yh1U5cBGgkRsnzCqMuSOWPxZY3UJTGsKxltCp9VLRuIifZbOtS+U+rkeHyGM9rFRyZjVLNAM100UCAfpYySJxWhhAoHIZJOeX4iVEgwp2KxbOVr6DJJZSURGXKZkxyc2z+Wjaxme10H+Adtb83F/t7q+FwOByHuum8AXZiqWPvLlxaz7/+bStbB7Os6U6xrCl2sIvkcLwnHbIN4NekbtrnDJCp3wiGG2wZRhugLAeYSEYHg/U7+eWYizOSPvy0YXh6GCpVE7DCuMw0BhGkdBy1YIPLjaaaRHSJMmLkZAlLTkM6RFVXhLjtwRfQqGwCaQkkTHhsdSO78jXMzHThdmvooRSzxiTOrCthtY0PdFXQobQDVFlHM2RyWyHzhERsqSC9I4CvMU3akkms9zHgMqhxw6wjdFIJ0JIgGzJqmYU0KqNQBMWLzw2FoKCYNMg8B8EaSK/3k0wpJFXBAFV4e0Ben6BuiWCwE7IuSBwDg2WQV2E0E8QSWfo7ICBJ9GyrImNGcUV3UgyN0XmexPApYWLDBeJalqb1MPpcBcWBEG1Xd9Abs8is7efFnI+BqgpE3oacQBlOYPcWqdoqiOk2yboshaUKO08S1D0C4RqBPA/COoRy4FMNhuNFqiSwuiCnS1hWORDC6+6jVN5JVchAGnBhSgpitkaxEvxrwRuEvBu2PVnLWC5AnCy2LpNMKJT+bFDuV/GdYWAfLoh1WEgpi8KoARpEouAdBneLQL3oBbx3Hk2BMDFvinazjH5TZmi4mvcHe5i9rMDOF8vozR3JTpLYWpa5hgykGaFIA2HyYgEClQIa27XD2aWZlJMkL6eoVEtIWifZ1qfp7K+hP11B0VYIu1rIFnNo+hBPhHeAq0RVOsoVVpL5rntQ3f1EZA3NtjAL3VQR41E5zUsRDyONXSgVeQLtJXKu+axqUBEZN/HMdix7kITTAHY4HI53mdMAdrw1Eb/KuYtr+ePqXn73cpfTAHY49uKQbQDvrOsjMzcIYzEISJAX0FYCSYaUjY8uyqM6veVeMmsWcpnRzAMj1eh2hAoMZnRUUqKIpXuxEASNAgYVLEWnU8owIhmUD8vUDblYajQTIUssXMRoAE8YNvynm74cZMnyajCKVV3ANkPsWltG6GdbWXxrhn4FMv2QGJZoUixGin4C7hKiQmBqEFsyhFKy2bbLTSbbAIyi+9PUZECaA8HXQNgyWlIlZSiUoSKassSWQFUluFZCygOj/ZAcElTIGulSK2UIxrQo6zfkCfkLJJKQSUuUXhVo7wfRBrFIgUwigCtrkMHFmKViyb3kUx4SswWdR0D8fptzOiV6zhR0F8HV6yEQThCtFGwuA/XMXSQP8yF0Fff6NIE1GVyvxPFnfdTpORSGKZPL0VeN4joXKt4naLFAHoPUKgj2K4iGEeZGIdMF+ZkgxxTU0Qqynm7C1RnmzoVEDrbvDDIkSTT+xcex16YY6JMo9ksM5/0MZl14ySPJBnKdiZ1WGUl5KeYiVG7IEjs9j34h1O0AJQGeOlDSwDywfaCdUMKfeIHsazLuuRbV2TF2JcsJCj/u0RCaNIadVWkhjUfdhkspMc+bI1cIYJvlyHjJUcMAXtrxspUSRyGoosCQOQNhVtKotPNEWuZZYsgqBMxazjZr0U3BekZYrw6C3k/Q8tIrD3JmXRehgEAblOhM1bOJ43hVtVirrqLQXI7cUMCvZsmW10AogDmiwtgYhliPS4ogi0pg+wHcUfsbvMUZjMPhcDj2bTqDYDmx1LFvH17eyB9X9/KX9QN8/Zx5RP3OQxOH440O2QZwOj8E3WmIl4PphoY8hAuQ9kHfCIawGEqAXtnIKs9s5hluZtlVPKV2UZKqeL8usZ0w60mR9xgkRAq/YZBTO7hIKvCqNo9u3CwhygxWoUkCpczG1QrJZ6HzlSpG/WVYaEQ1lVTOjW3mMc0iY70yagFSgfF5entLFXQWFPKuDBWvQNQPSgyWttjsfBxEzkLFwpBMlKCOFYKhClDKwVDcJA1BAROvbDJ6lMZr5WCvAncFZDLjjTnLCKMqGaqtJMIuR3GPoIaKjBYgbakMpMOEO0aJpsEdgZqFRRKbNbxlNmafzEjGg2LX4HNZlBZ24MkLTnisgnDOxl/fiVkL1fEEdkAQlaCpD+os6JANfIOdNKw0GVizFNkMMYMxMuholOFVkkSHDJpfgtgCcFWAngbhBn2ZRWGbSneXTMkKU9GUwIzI+PBiqQWyQ0G2NOXp8ivkRICAZ5Cc7sPSQct5yPaF0MNjVPm6cWshyss0AqcIEiWd6ofDuOJJRo800FLgVce/1U65oCsMrRlIhGDUBdkwNHxUo/F4yIWh8fAh9N+niCgC38kG6kyY1zFMdv4TzAuZSApgQKhQRM4k8bklRtZl0AsWASRUFmPgIUsnNs0MMoJteVg/0oqk5skFAjSkPGxnjBqiLMNDvzmL4VCRIVnFXQpjWC7yLgPbJbPVns/vQ3FG6v+OW+5HSRaxXSqaz4WdCUOZDHIIKiVychLkAqeNzedvB3RHBdn3t2viLdytDofDcSjYXxwFJ5Y69mdJQ5S5NWG2DGS4f00f1xzXcrCL5HC85xyyDWDhd0FdCbaXQ7UbUinQh6EggWcUQw1BwYbRCJ3+HBtzFQySpeCJ0los4sGkF9AookgamiKRdm1jjVRiUTBHYaiDTV4PsZLEAkapiEDkZJMiMLDVhVFqpUXOUpLGWGQJ+gZ9dOChiWqi8X6oAKMAUQ+MKhZZQkRNnR09BWZXCNQBKCVgSEBDxGJAdJIpQewooBH6vSB7QHXniNVqSBmVfFqhSxUYBrR1QXcS/BbUBKDUWCCzPYpPZAlKo1j1WSIVAn81JEZUKgiys3wUlwtqxsB1gqBlkUVZFWx/VCPo7iSckWgRgu6jBfFNCt5ELQXfNppGwArA8PIS8ebxUa9bh2G9pJJw+Tl6XZq+nW6yZp5l+AgTI0mJAm500yBr2XjbLVwxm3w/ICDfBq5KSO/wMCAEmrAxizJ11SYZfwdWvYY+FKDYJhgbBRM3JU3myNoc2QrobtSoNg0qFliU74TSSBJPOQT7ofYw6LgiQ70MRg9Iv4GqJkjOhU3NkIjAsB8sBUwBHnN8GqX8TAhY4KqHubUaqg52aHze5tBpgqAwKVZCOjw+x7Nbg4CwCcZh9Oej5J9ZTDXrcTMAhBmhgiA2EjbrmYcquvDrChVmhF53kSGjj3Y7QgMKIcPPsG8OJcWmWKhjtNBHQ3AUU4BKkYKrDwo+9EgLFH24R9sxvG6QU5CpoWynhtsQDEcXsCAfZCbuA2wAO2+AHQ6H461x3gA73rrdg2F97cGN/O7lLq4+ttkZDMvheINDtgGMbEFSBn8GaZMFQR+isRwyCdDjIBkQrkfSa5F0mX5JoSTiHJmzWMwQNjVUkkKlk0jJxeoAlGtBMMMklSyHudL0ag0ocgbZncN/uIl1GOgbQBvwEpRKnODuxh9N01iy6U010kYIQYKqqhwJCUQJlBHw6T56kCniQ0qqREwdfwCi1SA0kCSI1htU+8B93HijK5KCXAqGJBMzoxKKaxSyNvUDAisEpaUwewg6I7DLD4cfmaXCXSDR7cKMDROtE1gGDPVBPluizD9ANCkhb4N8QKBVQFsMzCzI1YLo4SZpG1bZLrrKy5j/a4N+O04kX02ybwQpDqmjoC8Eh3VAIQhbDg+g9rlQH/IhjdbQQBQ53E+6rRd3ycLYUotRkyFp2QSGI1SvSWOZKkXNRXFuAbUgGMtE0EyBlxye7So+UcJz7CCSG0qHZdm0FKRBk/pXR5AKNr4GKNegflSgNlgEPWBXQ2FEwuyRkGWbqhFQM+MNdVIg9UFvJcSSUHKDPwLCD4O+8VGzvUHQZND844NqKRL454MvDdE0KB5Izxjvad8HWP9TfwkAlg+KMXCflaHnlX7aC348JNCwgSZaCZNHUEM5i0gjU8QUu3jBaKZXhJEosguDsMgRSFUh5BwylRhRnVIcvEGLbLEPV74GsMdfYWsKctGFHTaRW1IIeSvF4DCB4SaaRqKsQMM8wO/MBC7EPsLJvtY5HA6HY/9xdHceh2N/Llhax3ce3sKukTwvdyQ5qjV+sIvkcLynHLKR1D0qMOaMIYs+rGIE5FrodIM+Aq4IhAVkYizs8bDEVpGw2UqIVhJkiKOhEWeMMF6GsWjNe6mkjXa2UtQVjqrP4kvvwh/TqSq3iZ8D/X4Y3gSWyDP/qFdRmizqaqDUCdbGHgKWzEBHnEKTMT6KswFj/eArVRPCRELDZ9uMpEJUFIrkigIj68OwLPzeItSA9gposyC8FuQMDJhukgUP+XQYVc5Rsd2g8TmI1IOnHAoucAWg2ATROgs7b6G0j4+WXOyG9HCIhBXAEx+i7qU6lLVB7Gu2kasW5IpgpyHxZICK7hJzLrR4JmhT9VSeaIdCgREyko98ScG7EVzzLUaqoS8F2/wyyUoVOVXitSUlzJfSLM7E6Ij2w4wSTV4oDQ2QS4FPqyJcMUbZKTZeQ2Pnw16UXgXLZ1GnBwlLBYSooRjsxz6sRGGTxKYX3YTmaOQyEDgWpHNyNFlgtsCIB9y1YK6FoX5QSpAZqqNk+QkYHaSSJsmiQlERGGYAJSfwDhaQ3RZlebBaIB2AkgxKGCwXCHP8ZpLz4FHACkIpCEULRqXxHsYBAYYLWv9/9v47WLLrvu9FPzuHzuHkOGdywMwAGESCBEmAJCiJEhUoiaIVn+26cslPLr7Sk6VyyXLp+kmybF25bF2pLF/JfL6iIq3MBIJEIAlikDE5nDMnhz6dw857r/fHPsCTRBKBBAmJ6M9UV013r+5e58ys1eu7f7/f97cJjb/UWL5YRjvRpPhPQko3CbIndwnPHmY7gXUp4bgwUelTla5QFHfxPCoRc0zp5/kOqcdicAhHzBLg0iQBt8nquILfv4apesgqNAZwhB1Ohbs8F47hyAZRVkVtHCIYHYC7A7Ucbs5mqy9xj6OwwUGusPWa1lOESYT5Ms8HX/tiHTJkyJA3Aa+0j6ZjhnvpkFcma6h85+kp/uDsKr//xOpQAA8Z8veQ3+gJvFEccMfJLAGNCDQBSQOiJBXCjgS1HIgefa3JGC5ZdtlHjxImXQQWEhNUKTPPKDbvpsRhQt7GCMfGBdZhOP4Wj7kjCdrbQLkJ+s203+zItKD8vTG590N4H4jbwHwgovLhgKDkM14WxBHYCuzeUAmSIjNUmKZFFo08EX4S43c0BqGJUCIA3DbsfFKm8RwYNly+CmMzA+buaBLIBss3x/RjDfEJBWsTep00ZXdyCew1GLSgkQX9DLh5WO9Bu9zHUnpoOQlKdbr9NtFlKLbTtkvOdYm1dp6OJxhchTt2EhY+PkPgjJKVVuiKkNbyTQRbBQwHNB+uZWC5CiLqkGv2mViTseQeNlluX72ThQeLONdBHw2R3QJ2XMSNoLEOtXUoVTtYoxGDo4Lr77/Gzneus3PXdYIP9LhyAj63TxDM+7gDUL+kMnUORrdgfBNWgYfHYfcmCH4UgvtAmgBNVzCZ4FlN4VlTwhuUGGyP0O9KxEGJ8NIcrTqUbkCnD9cFBGbabkrPg2QCAmQTEj2t0vJNaGRgNw+NEmxr0FVgqQfPf2GUz92Y48FPHebcZxQSC+75lx0W3n2B/JFFDp28xJH5h7Aqn2N65AJXeJJPs8lfahv8VTSLqnq8deZJ3mI8ho3DBnVadg2RjRHCoNfVcRVImhKiL7hP1PmJvsk7eyWOtXVOiFns+hxJ9naIjyK3Moz7GaaYRgX2Yb+m9ZSgvuJtyNfHb/7mbzI/P49pmtxxxx2cPXv2Zcf/yZ/8CUeOHME0TW666SY+/vGP/53nf+zHfgxJkv7O7YEHHvhG/ghDhgx5GV7NPjrcS4e8Wj50xywAnzy/Rb3vv8GzGTLkHxZv2p3UFDpvWV5gMxPTdDTq2gaR3iQ/uknXqyA1LCK7yY4YcJ0yY9iM0KFOiR4wxjrjrOGS5Q5UivIzNISJNr2DXI04vw5jI2CchPxboK1DcBFWrtlURzyKZkJzEoQG7jq4l6CyD8r6gEgTOBEUn4X25QSZdRSqWJJGRh8g+SNEQiNUInrxGKVIw/W3MFVQSgmSCe5bgCczbG8pzEQ92pPbNN4e0fkfI3jZHoEeE5tQvwiyA74LehPko1CbBkMFyZYJ2wYT1QGVg5DteXSNbVQF+q20xnj3ukI/8YlEQqBDewt6jo8mxyhqg5xfok+EHwYU1uGACY+WICgp0JGw2zJTN4ok+1vsOIt4QcJaewx5yWf0oMvIakgSN4k1n/4AbAFJEUZuhaXTsKQl1KdtFLfACX+bjg/Nd6kcCkLsBvh3R5hTUHgYOqugVaBdSaO//UkIJkCbhNaFNi13ja4UsO9wQv6WOp3PSUgdgwZ1Cp5J55xG6XTImpBoZ2TMJEZk0n/bTB/sCHwPFBvwQNLA8SBrQCcBPQFDh1wO1ojYMLeAUZK/qjJ/eoeZE3DqJwYc6wywLbDCAdEV0J4E69EulXCKvrJNw1JY7R5iybWRE5VzJNSkhEDtIHoZHrFHSDoVfjgeYJsCjSwGNhIKp0WWd0YZ/hoVrbeGFOqYquBQM8MkGm/hM2gofIL8a1pPETLRy1xPe7nnhrwyf/RHf8SHP/xhfvu3f5s77riD3/iN3+A973kPV65cYXR09MvGf/GLX+SDH/wgv/zLv8x3fMd38NGPfpT3v//9PPPMM5w4ceKlcQ888AC/93u/99J9wzC+KT/PkCFDvpxX2kdfHDNkyKvhxFSBU9MFnl/v8KdPr/O/3bv/jZ7SkCH/YHjTCuA6dW6LT/GD3TabWHxCEZyf/iIzasCSEtGXxpF0gdxPaCAzTxsTBY0GIzhkEBRQmWOTvOwRVGuMmxJiXvD4OZ3IT8hPRVSOQV2Cwefh07+b41zD5iY/IPt0glwBZxR0E5wI1v4EukZMLguZELpXobadJUsThxa7aow6JvDWxxjEIGIdRRKgexSL4DQldA2yZwSXp2H0NofwSYmiJ/AfiCgMoNKGZl+gvwDOQfDXIQkglKBggn4ZZi1ozUJlJkG66jIqQ30FOnULfdwjDAUWYJ8FrpTJYaCONakDnUWwAhc7yZCEoKGTp01O9UguQ3MJwnsNgvkqstunNm/QyDdQ5QQp43ItmEfQJzsSYCswmOiiL3QZkdKotr8AmgX7p8D0IFODL11WWL1zBrlR45gWUxMhvRPQ9SCagPLz4F+VmD0j2J6DjA9hDdQNsOah4cAVK8bpBYx5gvZDGVaO+sjVmLhtIlA4T4HyQCHM7NKa0hAG+HaCpggkFxQfXAWEAkqcRscNH3Q1TYPGgZEwFcIDHcYNm1a/hC8LqrtjKC/soh1NCC1oD2C3ARMFmD2dpliPnfU4GkrUY5tRJ0SjzE6cJabASWI8scpq7EBOoqU3Obeh0RlIOAN4GokORQRFsjhM0UWwiZHYaDsx/qFJbl83uTVpkkflL5UBn9SWwXv16ynYu73c80O+dn7913+df/bP/hk//uM/DsBv//Zv8zd/8zf87u/+Lv/6X//rLxv/n//zf+aBBx7gZ37mZwD4pV/6JR588EH+63/9r/z2b//2S+MMw2B8fPyb80MMGTLkZXmlfZRX8fyQIX+bD90xx/PrL/DRJ1b5529dQJaHZlhDhsCbOAV6jlGeZJUmBge4zDvDJeSGTRBCmLEgpzCyXWQqMdGokSHEYwebLQqsoZLDU2LC6gaK1MHUYWxOYNmwbyzg5F0RUw/AQIX+I/D0b2d4bmWGhtrmWt/i8tMSShuiFdh6BuqLGu6zVabfG+G8BZwYsnOg6WUiylgUyZYE/qRED4VFsjQpoY29QLbSoieg37MoTQr6RdhRYGNesHAiofF+qJ+Cm7dgLLeLM+kzqENRSR2LSSBfAL8A1jh0IqgMYCyC+RsSoyFonkmvtp/GFRsxACmX+ojZWhuEj4gkzBYkF2E38ghEBifR6ePR19rgQm1FYiuAjiFjdHsUhEuYH6O/IFHckNF6JmXFJT9+g0w7Rq6nGenZLPg69LYhWIXGw7D8udS4u2/DXQ/3OHT2abYVgZqBKJNhJwvnqxM8M7qf2rKEEcisjMPzZYh1aDpQU6E5DZtlmdmDfewDG8ToXLQO8syVY3i2jPcdLSrHmyhqlrwyQntCws9mIZQBFcmDoAe9JmiPQvZhUNbBaUKtDZ1diG7AybNwyyKIJuRH4d5713irscGdkctkXOGRP5rgb/6jxrU/06n/NwPx6zrWFYgy0O4CScR+JO4LdY5EGh45CvicwmMan4Qctm+gBBEoAYokIwv4QmLxu+Ucf1a4wuPKItuEmFznTi4jlIBI18kvtRlLzjHHCzwsOTxU3ESUOq9pPQ2A/svcBq/Dmn2zEgQBTz/9NPfff/9Lj8myzP3338/jjz/+FV/z+OOP/53xAO95z3u+bPzDDz/M6Ogohw8f5id/8idpNBpfdR6+79Ptdv/ObciQIa8fr7SPDvfSIa+V7zg1Qc5UWW06fP56/Y2ezpAh/2B400aAJVT2McUmHuvkuSW5wbF6lrOGRWCZIGk4icIkFQ4gUUOhTwEHjRwGeUpMaecYORQjdmKMgyDNQdaEAzdB5hB0HGh/SuaPHi7xeTNLaFloThFJdpF00GMIXoD6CzpBcxRNKqC7TbRMwrkYzpRgtNBgw51AI8CSNOy5hP4LfUqOyrwckDcFkgTNLZWqMCkccWgWIA4gXIbgc2NcP9XGHPXJjgBFKMXgx3tRUAmiAJrbkFVBPQBKAu7l1CDLmxJs90BqB5Ruv4Q8FtM4DfkRGCuBpkRUjR69SYEfyChdg6l4DEEWlTlCaUBvss9oFeSDMpcXMnQrFpWwhRzpMFBRPAWlVSUrTGZLq4SjAddaMttTCUYd5CnQx6EwBdvPgliGNQn0JVi+F3o/ZLI9eZRQE/QGl+jqx4nK63j2NHFmhMBaJXtHyPIMjC9DuQe1tomxrrF1fMC1d+4j31pl1Amx/lqwfUVm0ttP7nKfxdEVVt8dc3Bnh/F+gRuTclqcncQkoUbYSKi4MYc+C3OPgD0FtQcl8jOCcAJEAXgOmo/ZiP0h4/8ipOnD8ZMRd83s0Hp+l+0v1VntKlz65DQeZUaVOlO3bBDtg8YWNJ+GutSlTptVFErssINBHZNp1tBYZYxTLPgajU2F86daOM2A1o7ChXYFb8RBsV2CtS4zAwNLaXLaCPlikMOvTfJA6xoWGn8szfK/Jp/HdSSspoxL/KrX0zAC/I2jXq8TxzFjY2N/5/GxsTEuX778FV+zvb39Fcdvb2+/dP+BBx7ge77ne9i3bx+Li4v8/M//PO9973t5/PHHURTly97zl3/5l/l3/+7fvQ4/0ZAhQ74SwwjwkNcbW1f5npun+MjjK3z0iVXedmjkjZ7SkCH/IHjTCuBr2iWs0OY8X6LLGI8oFiejY3Q2trhgKkh+SBmDU9I2qjjMBSJqOBTooZIQMWAuyRMYMDqZGikZh9OoqKyB14CNP5f56+eneWQ8ISgJJENl7voI+6qXmTwoCByIliF0MghkVOHTPptl5HqX+CAETTCkHpZs0ktkwrZgqgCd+RbqpQR15mm2PBm9XsWIPOzxHmYOLrmwswPZR1Q2FRd7SZDZSaOSUgKqgKwCSg70Psh5iD1IYgg7YAwg9CCIQByH4Asy+nhC711wqQCrszZHA5eJsiCXS5AOuKw7EiOfmqfpFPAoILFJCYucyMFAYfBWjcV3niDQmsjeOlUnou6aaEvr2Nc0+kKnjODGeMzy3RPUi3lmGzeoZgMev3MfcaPMXRefQ9lOaBmCwATVB2fN5sb9b4VkDMQKDVNB+BID6y4olcDZong8xknAXob40xLJSYGuGMRuFvO6C29RoCjYHdVJftCER1fZ/6k6g57JzQ8e51nlEuZUA7vXpT1lQ8cAswBuhCwEp7Zc7u6C+SH47C44v6Mgb0bYA4OciNjpaix745TdDqevNvBOQmsUzJugejphenaX+WfhRkOikFsmVxCM/FCaor76XyWU8zJuZNEAGtSZY56YEBWJXfkqY6i0lDFassqpYI3r3Sny8RhX1yusSyWURpeZ2ibv83ocpMVYpoaUD/mh7S5LjQynaPMxyeAL2efoiRgKEX5QAb/2qtdTyMsfzMKvb7kO+Qbwgz/4gy/9/aabbuLkyZPs37+fhx9+mPvuu+/Lxv/cz/0cH/7wh1+63+12mZmZ+abMdciQNwOvtI++OGbIkNfCD90xx0ceX+HBSzvsdD3G8i/vND5kyJuBN60A7ipZvhRucgKZWOrznK7TCNrcHJWpb01g+i2+O4HDlQtcaCVUkwU6JGSx8FGw2UGyVjEnwJIgMKDZAWrgXYVuW+KFC5OcxSTQ2gizgLbTwMIkq8pUF8DrQ9wCE4kQCOkSXi2x9pkuyT64fhQmjsDOLnhJjOsndJ/WmD/RRFk22a4ZxN4cqvA5mO9SOhMSrkM5hMY5jXJXwi95dFWBpoNzGZQuaAcgeyesquALGDigt8DSINODwhysrKamUd1FA9UpId27w9WDEluujhdNcC1pc7PXQNYgOwv20xp+v0+aVT9BwAQSTWKrRu19WVr3vwVRgszV85AE2B4c6PRpxn38EZkJB+oT8Mz3v5Po0BT4fRpPNbHmmvQK+1BDjaoBBV9QnwCrCMkhma2j8xBWwG1ieOcp9RyMlbMkL1xg5+7TBO8+xQ23SC5pIkugyal+decGZLeyiGs6lc0l2rNFIvMAnMmQsa6iXNlgcGUBNRjl5k+3ME6s8cw/gcHCKMQJ6BYMZDS3weQaZMuwvQm9p4HRiEYGNld0psYiuqpED4v9xU1sAyIP2hlQdbBGYOSdML4Pep8S5E/A7F1QG0vrs70nc7Q6OWImmSSLh0EGjTUcFumxP6nSYQ4rkakrEnkxz9hixFSUYxvoiSr3DHIcYoNzVFmWHCYNcEOoTp0lFyuEXZXGoMQgNpEcE4MspWiUDV69AB5GgL9xVKtVFEVhZ2fn7zy+s7PzVet3x8fHX9N4gIWFBarVKtevX/+KAtgwjKFJ1pAh30CGEeAh3wgOj+e4bb7Ek8st/vjJNf7lfQff6CkNGfKG86YVwBVPYduIcMIZ9iUul4OYVUNl0rG5tetSQ7BBmXrrVrRkgRiZDh5FcuToMY5KZcrH3g89H7gKa5+UcXczSE7COlU2xD4U+Rpq1yeu7UK7SIuYUg7yRyG8CIN1GSmIyUpNAgK0QgP/KhTW4fxhGHsA8s9JNFtZhLaGdFVFuSVk5rZ1tGsqfi1GRAJ5NGZkGmpPw5QG7asZ9CDE3bGo7HewvBC5AvlWWgObhGDaaXqx2oLM58DbD+o+6I5BfAWYgWxNYB/ssPX9gvVWGa3joSQ+g/I4/aiJXRZobZDXc/iMoCExTpMAF0l2ee5une4P/yjIHvqN/0mx51Gx0wsG+x6FEQNGsglXFgTP/vh9REfuIvPFv2Bm6VnipyPG74hZmfsCWV+QGYvpvQeuFPNcNjKEB44QlA9Av4cqlqg2m1gJ5B4VREsDMvLTXL5rnvrcKPVaE20L7BlBrQzRrRHG3AbzksTF/BjShYBy8yLdsSnsTI9rmkoNEwWXhQCkUZnz9x4iiaS02W8/Acki14xQQlirgLMI+4DrEiQ7MppIKEQx/VCiRI/qEZ/dUeiq6WWC6g40DdB98LqADeFb4NoMxBGIL4Da8GlnQrbcKvcnHtM4OFRZxmSaEIsCl8mzVOmQ8wOMfoGpUKaJyzWpRKwqVMMuMhFtTEpihKfqeSR5iYnCNscmXCQ/4H8LPH43MHDdPPPtt7LFgI3XsJ4c4OWsNZyveaUO0XWdW2+9lYceeoj3v//9ACRJwkMPPcRP/dRPfcXX3HXXXTz00EP8q3/1r1567MEHH+Suu+76qp+zvr5Oo9FgYmLi9Zz+kCFDXiWvtI++OGbIkNfKD90xy5PLLf7g7Cr/4h0HUIZmWEPe5PyDMMF6Lf0tf+d3foe3vvWtlEolSqUS999//yv2w/xKFJhgPtLoUSbkMAfjKTKuh4u3V/uoYZHBSk4wgs8R7RzfK+/yg/T4duU8d+eeZOyAi2yDF0FPgWZTY3lgcUXkOCeOAB43JxaVnQjhK0SSSl8a4KkRdQXcAbTXRwmTIroxIKuFjOZius8U8D+uopnwyHFIjnUo2m0OvSOiOOnRfBQuXJVwRiIY3cKjipIVrKylc5FDyIgePRLMUhvjdoeKAfY4DLLgtIEEXAf6OXBOQubb017FWjG9whzeCkKG9j0B1/6ZyzOKRPHPmkz+pkPlozsU1xYZbApqVdiNQFGadIvXCNQtnjtxmaffI3H2O0fo/sR9qcPW5hOI7TYFH6w8tBQYCKjK4FRlnvt/3EZ4+H7kpeeZP/s0xjM+pgudxxTyqwG1bIk/vsPmwXda+O8IGBybJpg8A7EGukZxUON0XXBqGSpNGbltoK1EsLSDOzPNamCQPKayekFBbMHOhM61d+l89t4M/fIYY4/3mPuDiMN/fhnrbJtksYhNnSq7BOMtLry1TFyYgMSAfBESCXJZ/LpNNwNBDraPgH0HTO8D0xUYtoMbSNR9CzCpr9v0GrAawaAP1TXIbUJ4CTpnYWokTU0fSBB1QTSgcpPPu25zOVO9jCZfY1ZapszzjCE4TIaY61ylD65OP9FoEzNFhEdAT3ToS20e1Ip8XDvKsr3DF4pNnqDC9fhurnWm2ULCn4eRKcGPiBJvFxNM02IU/TWtp+BV3IZ87Xz4wx/md37nd/jIRz7CpUuX+Mmf/EkGg8FLrtA/8iM/ws/93M+9NP6nf/qn+eQnP8l/+k//icuXL/OLv/iLPPXUUy8J5n6/z8/8zM/wpS99ieXlZR566CG+67u+iwMHDvCe97znDfkZhwx5s/Nq9tHhXjrka+G9JyYo2hqbHY+Hr7z67K4hQ75VecMjwK+1v+XDDz/MBz/4Qe6++25M0+RXf/VXefe7382FCxeYmpp61Z87wRgLscQIW1ymQIUJDgiZbRTGcLmKjaDNfgqMGZeYOXwRPQF7Auw25CegHUP/Wdi8Cj1fYcMtYyHYJoPLCtP4XJVkeihMewl9acCoSBgpCVZkUGsKm+EMTRSmvV1MO2BcjXCccfgLF+v0Kkv3wehtPoXFEGMcjF2IOrDdU/DaKqdMB8m6Qj1JMLchF4Heg5wSo5x0KR4HexR6XYh88CzQTHB6IF0HYcPFIqjH4ch6+nzHhr4G4ii052Htc5B9QkK0ZIhjSmpI2wvxq1DIQ9KBhiUhNzWcmxya//S9iOlZsEtQnALqqME2C+uCm0fg+QRm+6AfgzCBs5l9OEfeA71LJMZlur2YYh+kOGb0AFjnQf1Ym+Rm2L1lgijrIeU2EMKF0ggoBTreYW5U2lS8iGo1wZR9Fm+xYHQWaNMeyRK9o4H9BEzZUO9ZCCmmeHFA9rkLWBcVnDDArgtuqUL9LTUmFqGj1OjcK+gcXQAnBDQIQpB1EANiTybXgX4hra8eKFAIIUw0NN8ko3UpSTFdkdC4VmXyqQEjBSg4MOKDtQ1tF1oxLJyCXR1cAZkkbUulzoOtQvWaT/mmVawYKlcalEIfi330tBtkwgnqcZlYVniBiIAMR+ljYLAdeHQVlQ17jEISIjSbpyyfoqMjcZBz123epq8yk++B4tCKl5jHIH6NW0OQ/mZe9vkhXzs/8AM/wO7uLr/wC7/A9vY2p0+f5pOf/ORLRlerq6vI8v//eubdd9/NRz/6Uf7Nv/k3/PzP/zwHDx7kz//8z1/qAawoCi+88AIf+chHaLfbTE5O8u53v5tf+qVfGqY5DxnyBvFK++iLY4YMea2YmsIHbp3mdx67wUefWOW+o2Ov/KIhQ76FecMF8Gvtb/n7v//7f+f+f//v/52PfexjPPTQQ/zIj/zIq/7cK7QYZz8RGY4CNXRMVCKaPEOZnqzyjFRjOeljhRrdxRK7SZl3z9yg+t6E9g1wL4Cigd+CxloVDQny21S9PDNJRCHr8Ew/TynOcLLQxtJ6aIHO/BnBRQOSQMYVBVxphXUJcCep1ddpJH2K9Zjq/6HTzgdceLvKPeciLv/JCELqU32ry7SZcO7iDF1jgwOne6z5EDRAFiCPQrEK+kFwxiHxYKsJ6jmoHEhF1dYmrHw+R6XucODbYtYM6KvgH4XyLgQ+NC4o9B+SUdsqeqKQ1xX6swOW32qQf8ojWE6wHhB0dAhkMPeFLL3/GOLwSRh4wAQ0QxB1DtyoM+PAigTjizCyC093QTdUVs68CyQNDBPyRTbfpxI/HFIxBU/NahSiEOOqxMjnZI6vr+DeKrMUGGx8uwR2AZI1QqXMtUwJ3dpl7g6wZMFT+QyoCUr7KbxciecOjnDYv4I/I/Atg5m1JlNXBZfPCyRfZX8ikXcjpq5B/m6Bfi/82USO5pkDiKkpSHowZqbpzzkdApUIWP5Llfl7Y0bGBM4L0HxCxXMyyFg4dBmRPBC76IqOnUAZSGRYLIKpgFqHkSrEOVjXAA8iE+ybQN0FKQazCNW7U5fpzY8HlK7cwJbXkWSJ2Z1JapKLEXssELMIDFA4Tg4Nk8txHyOok9dU3rk7wVk5YJYMz2oGnz1V4QvhBIXlAbcF4zSps4tB9zUeswaAeJnnh2l7Xz8/9VM/9VVTnh9++OEve+wDH/gAH/jAB77ieMuy+NSnPvV6Tm/INwkz/aYhIUFBASQSQgQqIJPg742UEXurUkImQuzdT96YiQ95RV5pH4XhXjrka+eDt8/yO4/d4LNXaqy3HKZL9hs9pSFD3jDeUAH8Yn/Lv52690r9Lf8+juMQhiHlcvkrPu/7Pr7vv3T/xd6VqgwLSR4F6NOhRUiTKguMUqXNk3qbgdlhVw14qp1QHeRZpE/pBZ1yyWPwHLQETE5AeQA31Ba9QKWQg/n7Ong1sI/D6U9E9Ds+d9/torZBViMKt0N3FGoNBSFU+qUaeSvE2Syz3m8Ryz2SRGN+WeXmXw946kdiNn4Myl6LUlcgzsDgkGBqOcSdlLhxGDp/oTJhRER6ahAV7YBYA6kNygzMV8A7DsUToEhQlGHTgsENHXvXZbWQYfFGiJBjbo5i7ACaoUKvVcDW2hTGQvR7I5QFSJYF4w9WKN7W4NnxDFcas+y7+SLerRCcmAAKQA5MC1pdMpsPsXBugLILORvcS3AhBOkwtIwKycRCOlY/irR5ldlsRP4dgpXQplfMMv65GrHp0XkrFDKg5xO8iXyailyegJ1lUBysHYEkS3z6mMrb1kNubTX4XOOT+C6oW02kbA53AP0NCeY7uE5ELYFKKWa8DuWoQO+wT7susK7Ak99ZoHHvfaBpECQg++AMQFKRaz1UL2K21cZtmNQ+7TE9G8E2ZOUY0+4iBwMUIRMlOWZKTYyDMdU5UHZAV2GpDIMcnAohC7Rk2FRAVqBahPZBODgDtedg+q1g3grWJMwsQPxwDFpM4+FJxnYOcNy7QUvSWZccZoRKC5cKJodpUZf6rBR6LBcl/mLnYUr+FPu8LLYv8bGdLmZTkPGylAEZm+fQabDy2tYyL7+ZDKMWQ4Z8/UhAHgMZCInQsZCQiOgTY5OgERMgUACNmIhU/moIYiJihqvxHy6vtI++OGbIkK+FhZEsd++v8MXFBn/05Br/r3cffqOnNGTIG8YbKoC/lv6Wf5+f/dmfZXJykvvvv/8rPv/Veldu2B2+1H8KmzFOYTBKjhxditJZrolRggLg+hBJhHGOTVQ6NLm6rXDbF7cIGzIbnk1Y79FqWwjZR9YiAkMwMg+F28C9CaYPDpi5NCDswvnzEvYURLpgUAT3YIT4ooPw96Eef56+2MCecdlcUbF3sihaiyxQCgXPHTbJfjjk4G6M3QF/XpB7/wr9qsArgoaMooBkQesajB4CNwKnDquSQVIS3GoH7DiQlcEuQvl9PUYeh7VYpV99G0K/jv7MMnYjJqlA70TIhNthfCHEv03m2bunGHtqh5nnIuRii7NHKmzN/hjJaJad3n/DtVRQDoCtpb2V3BXYfhyjdwW5CVUXFv8SNkegUQVdktmduwdG56EHGBb6oE21nbCtglyMUFt9vAhaXZmFZsIzI2PUbzlKMnkLZA/BIMJ+8iyCDbrjd/K83CfJuHzCv8p0t83M9RqruRFEGDB7eRN7EcwxGH3BJ7RBm4LyGkihTkZKkGOBPAbPntY5f/etkKmAEgM9SFTAILP6AlMXdinUBeMtyN3cxzZBFzC6D3oXBGIzRsQJcVcnV20SnYzRiuDugtaByIK8BT0P6pOpqbTSBFGGrgWyBEoZrBiyZyAH1C3wVFBGYOReiB3IbTfIXP4cxHCtLIhDhULvMAo98kJQpsioyBDXMmy0O9Tnc/TlPvrly8yLEMOZx9FCsv1djhETU+YpdqlSoPvqljEwbIM0ZMjrhYGBgoRKREiM2Hssjd0KYgxiBDEJEQoKKhoVDBRApkcOCRkFDZ8IsRfxTSPHEiYqfSnElSLMREEmQsIHdGIE3jDG+IYxbIM05BvND90x+5IA/n/edxBN+QdhBTRkyDedNzwF+uvhV37lV/jDP/xDHn74YUzzK/c1+2q9K3VH4qy8RSVxeZ42ZSY4g0m1cIn1jocljRKJHKrvkxVZJqUubynUOHAgwJoUJE8I5J5Eu27iihESpUE5N6DdgxvnYPoMZHegchr6Fmz8Jjy3pTLWNnEbPRzAeWeEeOo5is/dwrPbYxz59m1yMWxeyuCpHYSScOUwLJ1QiFox7YLMihEzIkNTBvPtgrwJgYDS/QHuJzTMJCY8lLA1DZtNMGS4WiygRSFHw4BpHzoJ1Jbh+n5ozMDsNsjqNFLDZKx/HbZAysgMFvJEP9RmNwu7RRMvGUPN7TI+B1fuitgu5tAffgLv6Clab/9XoG1BsQxNH+n8Y2ibf0E4LzHRCpidS9sq+Q4E+2VCUyXryiQTtwJVyEhQu0rkNriqSoS2xJFeQC0O8PZBdUawUpigdsuHYPw4hAa4JlJ3laMb59nNZ1k9c4SkFSI1ruCOmTgKnH48Zl9pm8dO6NQ9hZKI8S/C/A74Y1BqwLYEuWKLXWQKbegel7h06jDx+CkIAkCA40DURGl4nH5sF21TUOhDXgK7DLTT/s/xFmR0UFVwLYE+EmDcJjAS0AegVsCrpxF6aQBHjkHdhMdKcGsAo2twrgiaB4oOiQulmdRozIzSMuS8DrsjUNiA0ZM+0YUvsH3lELabpaNFdNQNYqvB406dW6NxDlFEImRLLREbEnY3ZpQDbLHLWD3HtrrFQAxoSn22RQYXCKTcK+fi/S0CQHmF54cMGfJ3kUidKOO9v6ukNaAKEgoKEhICCR2NNKVZAnRAoCGhYiCjICHvOVoKlPRyKBoaAomEBAHIyEjIqChoSERIaChIgEREjIa09/oX/WFT0R2/JKKHfGN5pX30xTFDhnytvPvYONWsTq3n89ClHR44MXT9H/Lm5A0VwF9Lf8sX+Y//8T/yK7/yK3zmM5/h5MmTX3XcV+tdmU8E24bKjB8wylEcHK4wwVL3XcRC4u3bDTaoMoLBXXhUZlc5/D0u0izsnoeekmDIPaSkhKCAYJdBX6FpKtTOKlx9IaA6A/vfErO8rrC4lGcz9JArHnIe4gCcg+D9RJf4/3yB8PrNPPdXFmPegPLAY6owQJ2Dy/eodOQs1qrHPjzsGPwG9McUWpKCEwVkRqDw3WAEMc7jEEowOAu+AWJd4fhTHZSTPoNx0HJQAwZbCoUllZ3jASsdi9jYAbHAICkSxy3sXIJZ8llaKKA6PuOyizHYZHVkH+7oKpHhMvfH62jtdVbfvYT7w/87lErgP4n6+SWmnn2YhhRxsAXH7YTyEbg0rbC+bNAwbOScS6N3GPadAdkGApCyaGZMYV3gmiL1mrIkNmbnEdZbSYpnIF+FvgDnInJjC3P1GtVtB2nDw4k+ynSuy5jmsduMGX9c0O9CVoLD/YCLowqqAcUQamsQrel0A5tgvoOaF4yLhGQMHj0+hzN7B/TldIUIL53fwKCydI1cUxBJII+DtQC5VQh3Ie6CpIAbp+I1a0GuJGACRJCKXmcFkkJaRhw1gatg2YACNQmmOmnq+upEeqFCyafvJUdpNNgcQMeDREBxGpQ66JMes81rvLU2Q08axxMFLqCQjz36BIyRoYLJ1fgaTVshciVkHHxKdIwMmjeJTgdNmES0uJUZlqQMjdcggB1evrLQe/VvNWTImwYdCR2JPqAjyEoCVaQpzDEWFjIKMqCiYqJhMiBGRsFER0dCAAMSEtJ9ykZHRkVFxySNGod7klgg4RKgCRVNKEjEpMJaIUAhQcHEQEUgI4gBHwd/GBX+pvBK+ygM99IhXx+6KvP9Z2b4Px9e5PefWB0K4CFvWt5QAfy19LcE+A//4T/w7//9v+dTn/oUZ86c+Zo+u6tW2edrnGaVg9oOPaET2+d5YnCca0oGsk3u6+gcqzxNodBi8r4upbfC9hasPSnj7GrIIgRCQgKQYCM2uNTPMk2RQbePs2vQuNAnDifJxBqjgO+uI69uExwHJQDrdqjnmgz+x9OoFyoYvYOUEoeCeZEb7/JpHbcpXB9w8x/EHDHAG4NGTcI9LbP03hHCtR02HZlOP2TinQmGDNKnCwhPIT/dRPgQy4I4hp6RRoSDPhhagnZdRq3AC2UbBstgjzJgBO1UC8sGU9MZxCWm5VX2I/DDiB31IHphi4UrLpu7CetCIPWa0FuB3C1wJaD6v55F2lZZyAdkTsO1FgxCePLmGfon3gJuF+nyY4iJd6euTt0uqDYYE0TaaYrxItpqwmoW+uOjJOPfA/Z7gCC1s+6sM7b5BxzfXUa5mKA0BZKfcNLZZOuownXV4NTTDqYHwa0g78LYeSgdjFm5A3YPKqhfiinu5IiyEYWiIL6qoB2KuXqnTvvkW0CdAr8NcgbCPvRK7Dv7IPtXm7QLEOyDc7LBfj3kXjchfi6N6HoKWAKiEqgKeDbofbBHoN2HwIWgBwgYDMBYB2kSTkxBT4WaCVMx9OrQKoKvQE8CoUMYpq7dVgRJBI0IRkbSlLhK3kUeLJJVm/STHbI9HY9pLEpYRDg0GE9smolL6PZYw2IgV+jMl5DXOhzp22jolNhhHJubkhl+4zWsp4CX76k2jFoMGZKikkb5dGTSGKvAQkVBQQgNkPYisAkqBupeXa+KjIoGhCioZMhiEiKICImQMZGx8ImRXxqt70WAEwQKAgmBjkSIRISKvBdjBofkpbFprXBCREKEDsgYJCRE6ffdkG8Ir7SPvjhmyJCvhw/ePstvPbLIY9fqrDQGzFUyb/SUhgz5pvOGp0B/+MMf5kd/9Ec5c+YMt99+O7/xG7/xZf0tp6am+OVf/mUAfvVXf5Vf+IVf4KMf/Sjz8/Nsb28DkM1myWazr/pzJbFDT9smDk1Ojl6ingmZzsDt7ip/sLifi4rEgnqBu+5ZQZQhmYJmC248AlcvVfDCElVjnQIagZ+nF9kIYg4XG+C7qO4ollCRvQIqbRpGHyXJQ18jcwnkORBjqetv5iQ4v9bBuNpm9aFNeLhEPtBZvCUkKhvkPu0x9/kZrCPrKGsxwfUchx5XkPp1Fr9tAu35DhOfC0CB7ttgpNHHfjwHGxbqURfnppiaAtkQck1Qc6AYgo7iE/swH9e4seqRZDv42WnO39kja+zQLI6TkQdMBwm7QOwNKLlPcG+nS1uFVjlk1oVVvQDyDWh3qTz+SSprMV5F4EzBzgCmr9oshwGxUkc6cxWpGZK4eahOQceBWICug2USTX0nlwZ1bPeLJGqEMMZBnwHXhawK7Rhl91Hmrq/Q+1QRuymxmnFYKiloSwmlnIt/ROETc2Nkqz7jYZvKJai3JeZNATMWrTsWmN28SrXl4vkR9qpE/s6Y1km4Wl1AjJyETABuFqIQ4hJTV/6Guy426SRg5OFCYrAzdStm93lUY0CShZYHiZM6cSstqIxBbKQuz2IEokZ6y53ZixjXQc2A0QCtAGYMtg+9Rmo2LYVppDcJUlfoSIPBXohAxGDr0JoA7RjULgNGTOb9dUa1Op3/WcV3RtkmYJc2FXzGEo9LURbDieniMJLssH8t5vqoRuBqhHGOKi5tetS5/prW8VAADxny1ZH+Vk6xCqhI6Mh7Nb0CHRkJDTD3UpUTJAIUdBR0IEZB3fujoO3Fgw1AIGMByl7kV0Mg9tKdDbS9FOaYaK/aV0UCfCSCl9KnJRQkvL3E6JgECUFCTPhSsrWyZ6gFES8K9yGvL0MBPOSbwUzZ5m0HR3jk6i4fPbvKz7336Bs9pSFDvum84QL4tfa3/K3f+i2CIOD7vu/7/s77/Nt/+2/5xV/8xVf9uUKuU9c7PBS2cLeL2HLAcTvk7Wcc/nnrPMxArS7R2IWJQxCMws4zsHFBZicq4GMgRxaBHDIgQiXHwuwG1ljM5qUefdUliCqYlEjkGlahi602adUyXF1TKG3GqDpURsBLoBIK/Fuhf7tH432biGfAKWooqzD9mIZSaCCsmJ4D40e6iLbM2z6X4JVq9D2BfklC8wWSDcE7Yip0qG5BbSK9qWswnoPNLBRkGKjg+ZOo2wEHp2o42oCdQwrJ6E1s33E30rW/BLfJTK1BPQPrHRmr4zK96LJ0TqLflDk0ErN0r4l3SwGp/QkIfLyZAle+x2BEb6IvwdhTGaT+Pnpji4QUKD70AplLAVt3jxBrEey0oWBAHEOogDpJeOwn6AyOgNwCbQz6Y2m/oEYd+l+k+tTjFD49jhaGdI0BItJJHJlIhIw8Ldg30uPTZ7LsGkdxmivEzV36N8a4Etewj3io4YD4HpmpOQfzKkQqiGl4jCz9Q7cDRmoTLkJQDOQbT3F4fZH+lVSvT6+CdFyFuTJdv0KjMSB0QClBbEEiQVCDZhNMHQwHpBogUudwMZ32DC71Qa5CdRrqHhhLEMZQnIRBFg7W91pe6KAWwA1BEqk3mwXsWGBloHoCphbB06EyD7tnZVp+ARmXUVQkPAZ4TMYxs+dVjkcqPUpclLIc6y+zOpnnelHjycYcd7FFhR3WmXtN6zjk5Q9uQ+OWIW9mLAsUAcJNk5llFEJkNLS9+t4EGQUFDRMNDQ0TC38vViuRwUQng0mWIioCmxiHMhI6B9BQUJHRKGASEDDAJcYlJiFExkUlRCIkYMAAB4dgL9YbI2MSI5ABCZ+YhASdaO8nEHi0kVDRKRHiIogYyrHXl1faR18cM2TI18uH7pjlkau7/OlT63z4XYcw1FeqPh8y5FuLN1wAw2vrb7m8vPy6fOZYaLIeVpAZsBEbHI8ltGATV4PMA4LRU1BeEbSeh7FTsAJ0d+G5lSzXhE0eHS220OMElQ7ZvMPRd4QsXQVfg9ogS54ADZ9BMkrfG9CRJNpxhuTRIs7VDrP/skdBgdP9VJBu7sByVWLjYJ5azkeNfaY+3uBgTyU4FtBUoNUFpwD2qQTZg8oTMZt3z9Nhk0IjZt+XfCILuvcIvBaEn1FQr0vEXkTnXujkIK+lTtC9XBOxW6V/3mTmRwJaN4/hmTPQ7yKiDNXOEiMbCTUPDlxLMOZAuyixuWQwnonxDyhcfMs/JZ6tQOsyqDaDmZNY+p8w9sgq8eNlmlqb7IFL1O8tE2XKKH+9jdPQKBxp0PKeRoh9oAqI5DSgoFnAAhSmU4cpXYATwe4S8CTFlY9z7GFBcarH80dh1ZUg6iFVNeYlD/MqxGtw2Nri3EGVQek4a+UnKK+5UAjZlGVKjVUyRkLtAByYhSs7EFagUyqBPQo5FUwJXAtCH3vnEtJ6wlYDMj4kmzqjnsvy7V0kVMKrMAjAmoNBLf3/pY+AH6TZ0xkd5AYURuDZI7A7CTdnQPIgk0kD4JyDwSbkjqevGUQgbkCuC4U50HogFHA3wKlB1gcxCcFJqI9B5btBXYfOM1B/tMx6nMFBZoEeUyyiUaTKCEfCLDJFHsk7eHKZifYNCj2H2ulRnr/QZXZ7AYUau7ivaT31efmDmf8yzw0Z8q2I/pKUSdBDkIVMgoa6F+PVX7LASiO1ChoKNjoJKgo6OuxFbDVsbEyyWBSoIEjw6ZGQIdl7xYsmVwkGCSFgIsggI2Ptyds03tzGJosGBAzw8HBwABVBjExIsieLQ1lCEoAQCKy9quAE6aXqYnXvfowYSrOvm1faR2G4lw55fXjnkVHG8ybbXY9PXdjhO09NvtFTGjLkm8o/CAH8RjCBgcIqs4QcQWJO9agc8VEnwZwAKQNT90P2HvArYG+DL8NGILFidtF8i1AUGUVCZwdtxKGupyImm4FyN4Op9FHEJmqYISslbAcyVrbOwj6BHYCzCOE0WI9C9mwqtO/Yn/DJUg/vsMDxBJmnZIQa0VrUqEcKquKxTwEE1NZkCpsG1v4e6x8sUPrkNlvn8miPDOh8e0zDgrmdPLuDmLzdxWuBYkPUgUwetDEHa9BkO9BZLr2HqPgeiHzorSBFAdVOiOvASBvQQNoGepDN+uy7S/DU20YJJ06AuR8m74VkE/P5P+fmp87iLwv6lkd1NMI9KAhzEdKgRjSTEBcFspqgDM4Sjd4CiQ1xKW1YbOggotQWNfRJq+Wug/pxyp/4AjOflshWXFbfq3I9fyelz5wlvmBgj3jk9qf61c2kc1VGN6istrFnHLwoJjMNrq8z4YVMDxJ2PMi2oDcJNUnFKYwCDshZ0qsHMmwvM7G7ir8OQoZEgxCd0Y7A6DWJbQOvv3flvgPtAVTKEEkQ+6A0oN+Cig3hAuzMwIQFgQHJTeA/SOp64oFfB3MbAhm0LAx2wOuC5oAcgMjB7mclpG2JSCRkRlITrMFdEORAqcHSp20GTsI+eRFJMsnHC8i4bDJGgEkWmcdkj4bSQ7J7RB2Vd+64fLK4RuPQMZ5t6JwKD+Oy/ZrWUwgvOcd+teeHDHmzIAEaCvJeqrAWSkgoJOh7Ds9gAhHyXvRVR8VCJYeKj4KEgY6MTIJChgoWFlkyTLGPgIgd6mgYRKgEpF8KMuCj7zVQMohJ9qR0HoUAGR+ZCJMMNvZeVLeDRw3Q9lKve6jEJMQ4CkixQBIJgtSsMMZFxkBG2nOOTuuJU3E8TI3+enilffTFMUOGfL2oiswP3DbDf37oGr//pZWhAB7ypuNNK4DXSbiJw0yRxWWFhrRG3LeZywzQJwShlLZ9zc6mHXfqjbSFj6w5RKPjJBttmkGeJgVmaSM5gq2zsNuE0n4YjTfJIOgh0drKMnBklFii69lcX084/q4+a2+HwgDOPaoglgUj18HICO7Yl9B9Hzx7CxQPxGh9qC1nUP0CHXmHXSchlwh6oc5Kf47p5xa5+gOHqJ2sU1gEbUzgVGUkR9Ard8h7adpz2ElNlAsSGF0oFyF7oM+SuUC0714wxsFYhe5zqNEifg1GmyBFoEXQaECulmf8ZI/eKcFW0Qf3GiRzEDyDVn+QU088hl+L2D4BO1M2+9oBE20f8/Mtei2JwT7wZlUsK8TYvUEj+X1ipQpaAqPvBfUgSMXU9ng3AfsF9MbvM/LnF5n+vIGXE7gHPFacAlp0iYWoi1OCWIFCDaJpCCMYV6C2mXBit0e/DwMbcg4UnnMxJBCjkH1Cw3YkDn5fQM1WEZkJsOdAz4IXgtxFa1xjrO4TDFIBGviw3RNUdUGh22T3wGnq5euUnBBHTb28KIDaS9Ob6YMXpK2ErxuwYWrkzJDdAHIG7O6kBlnZIuzG0H5EJ5BVJk86OJugS2lfYK0DkQc7N/Ionk6ZPj3fY+pBwbQM7WMw8CA34xCuBPS8ChoF6nTwGMdApUefmCy+2iM7aICncllVuD2E77y8TmOpzTPhCfrkyWC/pvX0SomQw0TJId/qpKIX9L06XV8JkIWCkVgo2MjIaHsevy+2PCqSxyZLj5gsecYZJ9mrydWx8ckQYjJAw0HHxWAVlQiFgFEkLAQSMc5Ln9tHQiJGxd5LjFbRMRggE5NgkUMgkyDTJkfIGCozyHtxZYc6AxwCAtTQ3zPQSkBpgwiQEnVP5qbNlYQuIRQ59UyQIpACSPq8sp/xkL/Pq9knh3vpkNeLH7x9hv/y2Ws8caPJ9VqfA6Ov3kdnyJB/7LxpBbCBTBuDo9i0EEjhEZauTRD5z3DrPcskKuz/7tTZV+TBKEPlKEw9Cld7u0SqAYFPQIaB5tPbsQhbAZ4R40Vg64Iwm5pNTXpdmlaC6QhqjkD4GRaP9anNgPExie3r84wWdkhiBycrkLdB+UMoViF7C0gx2K2IsJYnn3RwcLB9QTjpYze7hFHI6RsXia2Y1veFbGvQqEwiaTHSu3YwFsGV4cgkJEXob0AmB70iZK5AkjfAGAW5CNEadNpYrk+pBdJlYBzEFHgrMlrRpX80YcqBw/GAJ73r0LxOEtxg6sJ1tLM+zQp4VY1of5nBCz3yNehdlyj2JSaCBLscYE2DlwtZ33yWXaERKwndhetIapl47B6SQCB3lihefYbZJzepepB7W0BsQ3sEeqogHLXZndTI+SGhAWI8Ffh2AZ7pqrgWtK4KWkqCXBTIfZhYT52a/SwYvYSBLOi1YDBVgPwZUCchzoDnQ/sckt8gFKnplJZNOyIpSUhfiZnuN9nJFlmt2mSvdRBa2v9XmGkGgTRI05m7GwZPPT5J3F1j7K6QdglCHRYCaDsyrRcEuVsEQoZBoNJ3Z4g/3yDCZ3S8R1gDrwP9AUT+CKbk06ILfga73yf3BZgwYaMPuwJy4xF6VOf6hkpHjJPDokwTjTwZSlQim01ZR2gJS2MRG72EbwsF33t4nf6FHE9JtxAqfV5L55MBL38wG0Ythnwro8BeAnJqJ6UCidBRhLJXm5umMptpXzUkJHLkMDEx0fdSkrPIZFGwSNAYYOBjEaDTwyBEJUTFkTRiSSDkECmxQcjEkooqCxRJ4EgWsohRRIgqK6nwjlR8kZpumQiEJJFIEgNJJyZCYCFLEYkU4skykXBI8JEkfy9tOkq/iGIHghghi9TIIBFp7zcJkNOUblmoJOikZlnRy/zWhvx9XmkfheFeOuT1Y6Jg8c4jY3zm0g4ffWKVX3jfsTd6SkOGfNN40wrgbRygwA2aOOQoSLvcpC+yuDrNpc+uE3VNuo7L0R+NKQrQRmHue+HUCzErn5bYFjoZEnZoYsQKUaLjezLgIa0lUBYcvhsWHwF9MuTYOPQGoN9wuJ51aR6GpAr+QMKOY4Sb0ComVHMgshCeh0OfhfAUKEUoZ302ayYFDtGSLpHzQoJ8iHbvOjRhahs6BkhrMgM1Ic53aMxMsXmLjXRTkexgCa/XYVSkvWULZWAXRAHiWSNN+5UUaO2CK2OrKvsrAbUSJArUsqAcT9jOhewctxjbctnZLaNln6HU3qQbyUy0Q+pqGmndzGkQtdBiF9+Asp+lm5hsDHbRtzWO+SELRSgmCcGuT6MPXusGhriBPP0c1+UsxmDAISeieASiIhgaLLWh1oIp2+EGOdZvP81+niW7ExFUoaHDhjlGc/oIcm2R3oaDKzuEHQ/LlQgtge8AXSjtj+lvgdKRiNWjUDwKbgKJn/YZIiEppjVXuRg8F5KWRDgaoAIjKz5qr8/6+DhjeoeCAYaVpj9HYerqLFuw1rVIIpnRDZmDLXjWgK4EugUTdybUHoSd82D4oAcmEglRHKBi0e47GLUYpwGuU8YRIZnMJpKvoEUJTQVGp1I36cwRMK+mYl0ECqoooJOwQ8QGVY4hU+QS70tM/lLKspL0QN0hLKrsdhKuJRAlAkXr4CpLr2k9Bbx84uPw0DbkWxl9z09Z7KU3qwjUJEsqi0EjwUAih4kgREVlnJm9Wt2IefbjolNDxqRKhMEaKgFpmvSAAn2gByRKBtQEdAe8HCR66qOg9kD10tSTOILYBUNKA7GuDHECQoAkgyKDoqQlyFIMBGmdhRKDXoZ4AMIjVrzUDBA/NSvwO4gwSEPdUgzhi1FeGdQQOQYlURBkEAR7Mx7yanmlfRSGe+mQ15cP3TnLZy7t8LFn1vl/P3AYUxuaYQ15c/CmFcB5KqxIXbaIEEJB0mL2HanRuTBPLi4QH27hXxXsXoXCPBR0iG04/N0Jx57u4dRsMmhIKAySCl2ctA+jl0cJ25iKx+YlgVlMDadyMmRLQCdGSKmb8CArszOfUM21ibslkkmHxAA9l0YztW3I7I2tnk5IekuovWnUoECvF+M06pizCcqihltLkI/GJE/ZGLrPnBjQGB9FHHwbolii23qBcOMvCdwOYxpsd2BjRGJwA8JyN7Wi7iew20NuNGjtmvTDgP4IuCOpeZZ7Ggamjh+VeTLYxmnpFOoN+mUdOYG4FyLPQaYKI3aIF0g0p2Uu6jGTbRerFnJYloh0gRaBcgmYhtVpsCWYDsEVYDgx98QdejKEKlwvgBqDtAWNGNQIYjNmeuciO9o01+aKCNsCLUAZNJAmc4jqHSSDEhunPoO+HTO6riMCiSD2ESOpW7LegawOj42PEx18V3qQ1OT0MKlUwBkjMUPCNlgJJDkgssgcdDCXJAxVkO9eo3XyJnZfWMEIPOxCqp2VEGQdBjFEah/rcJfWyYSlmxUGGRWj4xNpMD0P7hz0FiETgR8rSPTJ2gOM2MHvK+y4GiLMgNiHYAcnjkEGDwu5rxIFEXEe4nGYeB80HoLmjYRuqYvTGsMiwZNkRsQNtohoyxWs2KTsTiBtjHF7vMitI+s8fyNLPyqTWA2EzWs6u77SoWx4aBvyrYi81yBI2YvwKqjoWGiY6Ci8WNGZWlPJ2OhkyGFiU2IMgUKExBoQYhAyyiJV+ii0GRDldBJbJR5RiU2DxDQgEHv51hmQlVTgdv30KpiaBdMGz4GegGoeFC01L8BPRasigy/S95HjNJIrmXv924CsAD+f1pKESdqAPAjSLyWvBd21NCUl9kFxIHIg8AAJWchpwyTFRRIKWmIS0tkTw0NeiVezTw730iGvJ287OMJU0WKj7fI3L2zxvbdOv9FTGjLkm8KbVgCPUicSNuP47BLTExW0ZImraFT8IsdzLQqqoHMewjvBGwXZh9JpmD0RcflzCb4QGLSw5D79JEOMS4RNfsxDzwuaTSgfhdEzELbBfgp62xpSoqHvOOBCZhK0UowZD5jeD5IBTpieRwY++E/L1Noaz/9AQPMHAiI2iLdt3n19m/IBQf2iRKtlYHYDqiMJ04f6bAPxjArGUSjdAqIHo7fh2gbe839ElO1xw4P2Zw2Mqxr+XJIebDQJ3AHZIGI+7LKTpAbMLRMcA5QIpDBgpLnDyWaMxTqOAl8atQh7Mku2THffKCulLIa/RTGpMZnEKKPgvyVCNCIKEeSTiKoPQR9sG3ZsKDpAmN6PY9jeaw1sF8CLwJKhpUDRhOtCJZZkblv0qJjXuVBRiAcDcucjckaEFV1ns/dHdA68k/Z3/HPks88xtrSEJ/cIMj76LPQMyIzD1ekM68d/AHI3pdl6rkiNwBQX6JL4eSIUYi1GmoDAchAyuE2N0m7I9NI6zfvextV33cHoC4+R6yaIGFDS6G/UgxNHIla/F740pjLIldG8AUQ+4QDUPqgSOAloVZAGApuQzEKM0peJly3C2MaliIYFqsA3JbSuSSyH5B2VwI1ABl8FDsIMEH02omKt88nPZxkNjnFYDMiR4wtahiUL5rsKZWy6QseQaxgZiR1fsMs2eRf61gxw+VWvp2EEeMibCwlpr9tu2tQojQDrKKh/65YmICsoxJgoZLHJksXERsHeiwvrdImJsEiwaEo2XVnBNxPigorIKTChQNaAjAVuKjZRlbRdWwK01FTYqnLqYt9X08eqOmgaoKR9mOQEVC3dcNw4zXZRFTBk9kLX6Wbr66kAjmTwo9TIYGCCo0LsgdAg9NKLhrGSWtSTJncLpFSYCyntCSepQIwk0t7Cw9rgr84wAjzkm40iS/zQHbP82qeu8PtPrAwF8JA3DW9aAdwhwgQCVPaTYZptBg3YFNd4sJul//kpbjuyiZ3EtNbBmIbGACQbbrk7ofdsk2daWWKri5IJMPo+Tc/EwKPZMFB2bcKki7MCuhqRuxe0GOI1ifBGlnjbRfJkwqzEzXf1EM+AbYKrwM4V0BUoqFBfT+h7gtpnZbrvHCN+52HQ5nnmoT9CdjskN8lkb6hEbhX/YpsT72uzPq1ywZqFyj5o9CBvQmJB/r10sk/guhfItRIOLxkMMhFSVQXLAM0AbZQgv48Dyy1qJuT3gZGFrd20fnZlv0jrkXfAj0GpwkTXY2Ng0z1kEhz8boKyycC5juRcpLyzyFEJdgC5DKvN9MxkapBrgJ5Js/YIoKnAegzaAGwDdhRY2E2Dsi+UR6gfOoZQNIR3nYmlZTpZqEdg1gTF6y6xgKIFnXWY8FcJ5EdwM/8UUTiCpz2N8E3CPBiHQPNgXZE5f/RdJCe+Mz3giTC1eh6spI07OwNY91mbn0BVN1GChHBCR22FDOSQ4JxCMe6jzlzAP/V2ru1eZTbZouvt1QL7MHIYGIeMAcWMzCCuUgg7mGk3Efo7QCcV/r4DoTRAHwnQdAiSBEsaEBFSEEV22UKNBU6sU8gOiBOINfB6kAvTM2igguqCsQWtmsKBMKLDOn15CS0ZZzYy2XFhgYSAgC3d5bOWz9HbY24+B6K9gB01Ee01tl7Dehrw8pvJsBJwyLcKEvJLhlYKacTTxEBFRgcUAhR8FLJYe4K3QIKFRYkpVLIIDOpoBBQIyNPAwgdCBC1VxcuacMCCgg/ZGGayUDTSnululO5VkgciA0KHwE7d8+UYJnRoC9gCDCON7Mpu+gWja6DoacaPF0HLh5wO43nIh2kdb2Sl6dMiTK9ChlHahPzpNjTUVNRqM+B70N+CuAPJAMKttO+w7KSfISKC2AFNR0LDCDQiBkSvscXam4lX2kdhuJcOef35wJlp/o8Hr/LMaptLW12OTuTf6CkNGfIN500rgPfRI5baTImbUY0XuPnQMmsCurs93iI3WY114isqd+zELF+DfbeCaqbnAb4NTtRd+F8+nXKCGsJGV8XDAFRcf5IEjwI+Pddl/Qsyk9MJ2Txkbg5Q5Tp6WSDaEqGa0DwGU0ugCWh54Djp2cQZgLCh6RrMXFRRklXO77OIyjmUBwW790zSeds+9jtnKW75FPM+2wdhKWtQeqKGt/R/0/+BfwE7EdSegyOH8c0yhgPTNWjlBriOTlL20gOSH8L8PSgPPYZKWsNaz4KaB3sdwktgedBakDjQFJQDiKehvio45Qy4YY9TG50H1Qd3DMFVlsZPsyMUgokCdCUis4bc2yHJqKh6B2MwIAigZYAdQr2gYQQJY72YpAdBDJensjRvehvk74RWGfxltvz/i5qmcnx7g4IU48/CbhmCBoxehMmO4Kh+g0+O38CzZhBWQK7oMH8aFm0QAVzJ7ie66btSRyzZT3/hrIO4Av0SKCegvIFzKM/F2jI0QkRxjvLW89xzZZXG5iSF1RsUL96gfvgetsduZnBpB1skBPOpaWrGhrYLuQ0wMwrkNEq9hLybZg72lmFnGbphkSqC0v4OdhVEG4wOOEJClnzarKMqLolsQW+ULjEeDkgGbtyivRxgj0HoQL+bZjrKTpaDKHQJkCe2wd3mWLNAJiyiMk2PDhlXJQ4Srl2VaNyY54odIrSYkY75mtZTwMvHdYaHtiHfCqh74ldGRkVCgr32PyCjYmAhkSCTUEKhhMkoRQyKe47NBRw0fAwGVGlh08ZiS9KJLEgKCWFGpFe0ZlQoK5CXYcqCkgpFCfr6nvmUk9bxKnpqPx8kEAnQTMioUJZSY0MZULw9h+YkjQLvOTijjgJ7EVybvdriEFwfkhiKJeg60PZhn5IKcDsDDQUGuTSaPGiD10Fp9xCyTqJl0g0sSUBYEIcIKSbGI5EkwEzdBId8Ga+0j8JwLx3y+jOaM3n38TE+fm6bjz6xyi+9/8QbPaUhQ77hvGkFsEeRm0SHIosUx9apjMT8wVNVClGJstgkllS0YoAyD/E2RDvQMWHXhUiDwrfB3UnCxQ3YrgGbIGERYePudXn0UfCTNs1NHflcg8JNkPHgprclXB+REIFMIQjxR6B/FArLYBTSTLReXSIzK9CPQfmyR1QbQc90kfwe8x97kImaz5I5hRg7zsqHCrSDZ6mrXbbbRaxnt5m7EbKdWaT/1F+hPJNgX79C8OOfwJ8fI6FEbDQw90d04wT/0FQaHfCzsK2hB218GwoW1GLoqhAZ4GVALMJMLMgegm0jdR32n1cIgoTOhAStDZi8A0QLnCxx5gzd3CjYZaiOp+pMrEJUIFo9h6J/nLLWQO+lqcCtjkBBEPoQZeFyUWegVuHqFlS64IxD4TRi8jRR8yrLlkHRcZAWQN0BrQ+5bZWcGjH6nGDf3Ce4eMsPkizkOJypsViFmgG9iTEGt/04aPNpsa7PXgRlF2hCzYZGC0buAnEFkdFhqgqZPM2Jf8JTS/+Dkw/Vmbkt4XxeQDsgKlZoRwoTSULThIqeRnjDVuovNil7rM1tECIIzbStkdeFViihqz5eNWLy7rR+2L0G6gSEWgwxqO0E1ZLRJgZINR+nWyEUZRrSLo4e4jXBXIVoBfwOuD0YSBa+mMSSr6CaPlf6Y1gcZKHwJaRemZ1kBkGLEbuGXJd4ypcpsE03zrKhJOyd618VIS9/cHsNbzVkyD9I9jyO99KdZeQ02Rf2UqEVZDSsvdTohByCIhYV8siMEmHRx8RBxkGjS4UmOnVJo2VpJHmgKqAUQ17AuAxVKe1bN6al4rcImPJeanGS9knT5DRt2VXAkyDWSQVuDLINkpRGdsPBnkEBqQhWBBSz6d7XTUAnvQpr+2n9TZykIloCojhNw7a0tLZD0tPxscKLudOykiORw9RIK+inAlhS09+cCIgJEajpawlBvCjEh7zIK+2jMNxLh3xj+NAdc3z83DZ/9uwG//q9R7A0+Y2e0pAh31DetAL4EHewxQtUpD5ZQq4/m2fW08kQ8TRl5kTEmOow2JLwnxS4bwHvaHpBPVZg04PpOyD3Ceg2IatHeC4ITFRM1NReizIF2nKfsJtm2WKBbcG8IdjcCBndBrcA+ihE1yDspgaeYTFtSRsXoe+EFMId/E7Mof9rm0pTY+2fhCR3GFCcJszcSd14B3V/E7pdkuAxNuuLDMZ1CFbInKsx7sRsLxXwDx6kX4blmSc5pEesGkWYvB3ESHpwmuzR323zUGJyZNenI0Hdg4om6N8J49twoAePhzbbR3JUH62TuzrCILOL/OQulJ8F+Z3oT10ku3Eeomtk44jemErr6M2QHwdlPzgjoL2fQXgc1/o4iipQA59osEulvkqxBdY+WC6byJtdpmobKM+cY/3gnYTjHwL3XtRkkX2BQ2yA3If5G9C9LJOECsFWTDMvOK2vk+/9JhMzPnoEW+MK9byNt+89ULg7/QdtuukB0XcgWEO7fB7zY49TbntEb5HZujmPYbQpbyRsjH8fTFtsfv/7CEf/nNUpmc3Rw2CriK5Bz4HMaGrapXrQvUFa21wG9UnBgfU6i3dleCyvsFXwqdwM2WUFe9xFn4a6DbkmRIsQ2RCW0mzEqB9hRglyG7pRQoiKIMAQWQZtm+61HSIJ2IRAh45nEcpdlFhHUXQkH4KuQUhAv7dALkmoUudDymU4WGO3rxKJDI6eMFiIYCVI8/FeJQHpMfirMTy0DfnHzIuR35AICRUNOXV6RseigI6LSrzX1EjBRGGcIjIVakyiEBGh0iNHF4UOOs+jE8kSQo8R9+upB4OXwL4ilHWYMmBEhpwA00nTVuIwrd+QQ9AjsPpp9krQANVI64RLpTRCHBlQtIEQBv3UGAugWIHOLvSaafqyLmA0Tq+8JXup0S9GixsdiGXIyLC/CK6eplhfUVNHQtOHRgG6NqFigtsEZxfiIN0A8z4EMkQyCdk9i/oE7FLqteAPXaL/Nq+0j8JwLx3yjeGuhQr7qhlu1Af81fObfP+ZYS3wkG9t3rQCuJL/BGu9IhekXaLdHG5R8PYD2zz67BibiaCdZLhYO8YIm+z3WngvRCRVOGHDpgnLObh8APS3w9gu6JLg4kCnHWVQ6WMjgIg+JlZcxmt1aawnTI+CqMJEDka7CYadnmc6q+Cuw+StoIzAtCSIfZh0IVEhUFXUtRzK6R6XPgS7J+9D2DenfYwkBcIqWFXQ+gR3nGJrYS1Vz+YcPeMRBrUV4nt/GGwBcZ9ONsNVtUevdBzMd6QOoooKoUc4OknojLPx1AUmlh0yt0AjttidmqdsXUMm4kDTJbgQIjcTbByCQoJk5KFwBgZ9JH+NbN9H9Hxq5TzhQINkGmp9rKd+D/VciLP/JuLD8yTlIklpnDAMoHGJbb9NS2tzLBZU+xFNo8yZdpPNJyGqP0ytGOFnf5BEO0BYvcoNWWPUCZmeECithN3VgE5Z4JtQUeEm16V0HP7K09mYPYHQ74Hy90E4As3+ntlLAO4VrM2/ZvaxVSQXfC11f853OxxaFowsS3TvfJLe+FEwqux+x7exq2eh50CgIve7BLWE2g2FqhrTlyEqgXc+LcUzHRi5ANumxtZ3LtAIdjl4epeTGxFN0q4mxgsw2EzNV10XjFyaBp7LhSR9me7uKBohQm5g6RGxP0U3Dqk7MLmVZiNmQhChjRTHDNhFVSOSRGNH2Ghs0E0sjmBTZpKcvcHIzVusfiKPpnk0yglFz2bW7fH8a1hPA9JMy6/G0PZmyD9G0hZGqdtz+kdFfanyV0JBQ0bCwMJEp0IGY++PSpWIAj4ZHHxcNFpk6CoqfUUhtGOEradW9KYGppS2C6joUFQgK4Edg52kBhLRIHVTlEm/uU1AC9J6BxGBIu2ZUe3VQCh75lVSAvIgNQcQAqIa0E7bJum9tL2RJ8BI0rFanEZxkyQ1wZJ1kA1QfJC1tO54SgIrSuuPdQMyMbgDoAiKCUqSzkOu7/09jQKThECcRqUlOY0Gi5BhJDjllfZRGO6l30p893d/Nw8//DD33Xcff/qnf/qGzkWWJT54+wz/n49f5v/+0gqzZYulzQYLk3DHQhVFlt7Q+Q0Z8nrzphXAxQPL3Orp/H8vHeMJd453zDyFtK6jxn1KRsSDtkS27bGQuCSOQPsixD1YOw67JQiKacbw4AhU/iWcvgHZP9nksbMmHhGx2SInJehhj36SJd7Ioh3tEo+CKEMhhnIBVi2Y34IRDaIpcPJgHYfoPMTd1HQzuq5DP0frvW3q7xuhM/UesE6loWhJSmvAtD1X0MgGqwATt6dnikaAuO0HiHUZojxE26AvEI3UaCQOZH4M1ibSq/FGCHoTuoCrI54TtDZtDkw5JBMhnaiFZgvc5yGOBEeTkJ4Orbk+rRM53DMfgJPvhY0G/sG30ki2SPo+IvIw7ZiBlUVqe0xt1AiaCeONz9FbVNCFglSR0IwItZcQ6YKtEwqXRyrYdoc47PKFjQkK2QajzZDy+c9zbt8M6pSD1YSFMKACaPtgpQ8LiaA2B60sFEehMQFfCjWunDyBsL4fkrdDMwODHqhB2g6ELqr4HIefXKdzLTWlysxAPwezZ2OK12Sc3SyT6iWu3PQCHHgHbG+jrH0R232BvjaB7nsYWoIcKcQ2eFZ6ttQqaV13mE3/mebPdkjmZSRbItkQaNNQuAHu1dQgzDgCYc+g01ExhE/WlbArISig1U0awgBhIUk7IPUxJBcrC1igrqbZi5LewtZl2p2IXK5HaCZMqdtYscauKPMMAZPI3DkoUH8c3HrMUb9Lb0fjuLFOs7wF9Ve/ngKGAnjItx4yYO45G4u9lkdp9a+Kir4XGRaYZMhjM0YegwwqGWJGibHwyLCDTBedHbL0NJXAkKASQkWBigWaApYCRQ1GVMhJqfC1AjCiVMzShXgHZDOtvbUNkHxASiO2Qk/dmeNBel8OoFdLs1syeipgkzh1zRM+6D6YLgwS6JO+jybA2EufFiLtQxdZaeGp4uy1WioAe3XKoQkZLZ3vVh1UKy2nkWOId9M5qyL9noqDdC4v+RgrqbCOI4YCOOWV9lEY7qXfSvz0T/80P/ETP8FHPvKRN3oqAHzfrTP8h09e4fxmlx/672f3Hl1kumTxb779KA+cmHhD5zdkyOvJm1YA/68LJW6Z7vP+Ixfpr4+gL40wbXTIKD5/HE/jmhAoLpPJBNu+RHJ1hQOqj1+GfAMKIzBxPDXFHBTg4nGYCEOm11ZY2ppHaArSlEcxBBo+qidjJJDPp+7Gq3JqulkKoZXA7jiMR+BnQOqmF9PDHvRugNm32T7ZYefbywQT3w7Z2TT9TZggcnu1VNn0XKGItIVFpKU9jF6MYehqKnKlMpj3w8JE+vfGYWhE6dV4JwQrQemuEbslTC2hkoRoMYybEbGzTeZLcPkcxLm0b20wIrPxXbcST78HRm5PbYgnJ6Axy+DYB0DJQWcF38iDiBHmDBvTR8hLN1CbLlk3xvUFPRSSvCDTF+iWhJucJKl+D0Hvz7H089TeeojasYOo2y3kWILsMvsGT+F6MuuWyZJmsD9u4Y8Lwmx6iJgNoKfC5Uhl5cjNJBPvh95b0x5TDtB3oGxDtwXVZQq1p1F7CdYkSFWZxWIG7SmH7EpMoCREE10auSokHaQrj5F/9pMU69s4GRjMJsze6GPqAsoRwXWIb4J4HdiQsY4lZGzoj0B+DU5+rIWqCXY3Jep5KGdATIHUSIMuxkiAcGKWIolJN4dV72BlYpTMGrn+HI4Ywfc6ZMhSMB3MAogsKAfSc2/peoK/a1FWN9G1LmOSYOZwmwuLo7Q8nabisKY3KbkFJpcrHBttcWG7wsJcm+rRGp3HykDjVa+noQAe8q1IKnx1QmIEMRYSadWrQpYsKgIJjzGylCiRZxKJAglZNlDpYdAlQ50SfUmmrQmSqgkFE0YtqERQiSGbTWt+Dwkw1fSbWXch64Dhp1FSU4PCOAy2U+ErSL8kEtK6XLm7176tl0aDNQX8Whq11Sch6aYR2ERP31MNwJXSdOlskApUSU6d+3w/rfu1RiAKIXQhclOzRIs0rVlS4FAV1vw0untiHtwgTV3Z2OtfF1RAdCHx9r6bPAh8iCWQwjTanEhD/bvHUAC/uXj729/Oww8//EZP4yXO3mgQJelivO/ICL/wrlnqocZvPbLET/7+M/zWh24ZiuAh3zK8aQXwJTNhdX2eHxmr857719nsgzECo4vwQ+c22JkI2TU1oqUMqyLDhe199JRrTBkxsQuT+6CaTYOtkQSbArybYO4uj+af93F6OcLtAWoJcoqgH6uERkymCN29nrYdE6oOaAkgg1SEng7qEvSXTZREwwFMWYGjEVFm315fIgXsYqqUwiSN/Mrs9V3MgGtBV4JekBqo9CNwu2AARgniGbBGYbDXNiPQ0xClsCAMKC87ZFoNdvbJZE2BNAG7Oug5iDMy7gJ0Yg1Ti9g9MU+88M9BO5FGK7oeeGuwtQIHbgNbhkIWSnfCtevQ/z3cfRO4BxeQww1KSyu05QJW3OSA36Y7Aq2jGZKp0zBYI1yvU3AC9gdPElVVnNEcYT6DMbhK0gm5NHGcRGggabReeIbxOGDlokR2yyAY8bhcNVg9fQpR/h5YuydtF2LKQDc9+O32QbRQ/EepLNa45hkMRscQRw5iPHGO8Z0eugLBvMS5e07Ru+uDyLufZ//ZP6Sw7aYtgwsG9bnDqO5zuHaEbaV1WpUN2NagrQoKHnAEyrn0jLh10cKed6hKEkFdYCyAcMBvgtaEpCOo2hGGKUHfIYjTwI6RSAi6pJ09TSy5jVlwMXJQGEtrhgceZNYhSmLUXANygnao0N3OoQcFXIrsVmpYcYuuW8T15rjtVIsjty9RKsKlszY32uO8FgH84qWWr8bwfDvkHxsv2jsJBOpeErS2V/2btj6S0ZHRUMiSwyKHIEtIhgCTOoIeGj10eraFp0vEVgwjEhQE5KU03XkUyCqp4VUZQKQpzGqYilTZS6O2mkjTiV9s1yZiIEzbHKmA9GLkdi+RNlHTLxd5L3osh+nr5b0a3zhKI7rCSwWqvNcLWIpSga3E6XsrEeCnvX3xAS/tLSxIX+MqqcjWFBjI0ANcE5wM9KoQShCp6ecqIk2DiV5Me96LDguJ4S7xyvsoDH9Lr4aNjQ1+9md/lk984hM4jsOBAwf4vd/7Pc6cOfO6vP+jjz7Kr/3ar/H000+ztbXFn/3Zn/H+97//y8b95m/+Jr/2a7/G9vY2p06d4r/8l//C7bff/rrM4fUmTgT/+99c4ta5Ek+vtPjiYpPk/hluni3x3374DP/8fz7Fv//4Jd51bHyYDj3kW4I3rQAuCcGuGvLMeo7iIORpr8SRGZdT37PL/BGfmwZwpRnT0FeQFY0rboW6Lzj/WZOyJTA9n74KhaOwLkCbgMU5ODwNU3qTeiwxWk4vlIcT0HclblxVKb4tQijpGaVThWYeRnrQ06A7mdaLhmtmepbBQhUHMbMXiSpFktydoOX3DEbUVPQaMUR98FXASHNuiSD00tqsFQ/kLyA3HyORAzj5w6AeTlPbhAt+AB0gCSAehXYdfz3iYNMnmpZYPybSAEEZLrgTeMfvRmQESX6Sa5pEvG8eBsfSiIPjQLBF8bP/CV3ZoNlbJbLnoayBswHGHFTuBO/zUMqSmLfSOH4Uti/h7EhciGdIooi4WIX6MmjXYMend0PF1SNG2z5j1YDQbLDczFErjZHYR6BnoCZXmQgjFjWbjOXhjwY0ShJbowuI4nfDzm3QLaapf8TpLUpSE5jKRWaffpjyZ1SCmo50e0z74D1oX1rEyIG1o3Fhrkzvu34UWh7zzz3KbOTSrEC0BeFAReomGI5AEmBUwBuAFkJ+AXRPoCqQtCAIQSkIJqZcogpU3pnQ+YKE80gOSj1sRZCtpKV9W6vgtSwkOyRSJBpulrHJPhsbLhnJJ6sK7FCQqUKmAupk2skkNNMgEbMeZgyOBMvnJrnevokFcRUDB6mjMxaabEgycTJP6fMeOdXiS/0sLwRLaK+xV6e3l43/1RB7Z/MhQ/6xYAIygpiALBnMtOgWCRkFhRwJGUzylCkyhk4RhxJ9TLpoLOHTR2VAhmRMT9sZFSWYiCC7l7o8U4bZImS76cXKkgoDN92PlSBNO5b70FsFQ9pze/b26nKjtG2RGqUGA2E2Nb4SnfSqbKSljotSDMkGKEVQjFRU9/20n/BINm1/F3XTK8Cykl5p0wd7tcVeOl7fq/9NAggcsDKp+3TGh6wGvgGrLnQ0aGdAa0NHgu0sdGzwWkAAhgZmAIN66jId/f/Ye/Ngy676vvez533m6Z47Dz1PGlpSax5ACGSBbcAPY5ME28R24bxnU6mgpBwTp1yxX2KSik3I8/NDsWNshzgxsXEIZkZCYAlJaGipWz1Pt/vO95553uNa7491JIIRarUAC3Xfb9Ut6Zy7p7Nv73XWd/2+v+9XgD50ihbhd/9jXCG42DgKm2PpxdBoNLjjjjt405vexBe+8AXK5TKnT5+mUCi85Pbf+MY3uPnmm7Es69veP3bsGKVSibGxse/Yp9frsX//fn7hF36Bd73rXS953E9+8pPcf//9PPDAA9xyyy189KMf5b777uPkyZOMjo5+7x/0+4wn5+ssNQb8P3/vOv75p57n9EaXLxyv8X9OjqHrGv/X3Tv4yY89xpPzdW7bXnqtL3cTm/ieceUS4PY2TGK2ZE7xcKvEsThD6mSO8ukqUyXJwU/nuNAuYNFhEAoKeAgfkBBFOqkR2DgO81/Ume/qbLkuIvxlODMJ+fE+xWFrbuRANg/n12168yUmVpZxClBw4Fk7gRdrjGT7xF0Iu+CtGriNUTr2KlHYR8QBa1Ga9ex+KO5UkrFUEhwbWiEQKYclwxnK2WLo9ZWbaKWKtfjXjJ37HNnna9SmdSpxD7H/XjCmlCQuUYSyAQMBVRcqoHd9ljSY9CSHEg79ZEDhpGRko8lSXiK2/iQwTezqYBYUyzerkNawjn2e6cUT2CVJ8htfoZopkLMDotilNz5Fd+YfQOYq9UcwDoKtw9ibEbN5BJHKj2yuQKcG+lVQXCG7XiXqSRIVuDCbwO7F7K33OWmX8Rvn0ALBePsMZ9089dnraeeOkaq06Sd2Ee54BzRug1Ud7GBYERHDnucYrFXc5c8y9XyTdlEyavhkmn1arWcJS3nKZ8GfC4mvTYNlknrwr9ix1iJ01PyxY0EsBujRGUI7Rl+CQQYaXdBaKo4zaYIwIDwKWg5yBshpiVuCMzvg3Bjs/0OB3UiQ3dEnYYE7A2MBpPp91vqgTUDrnIFetRjNDkhlIAoMRF0jcFScEnXwMqq4n/iHUE0oFeXS1zUefwyqEw3WWwmu7fkkAo2ChOPbQOtamBsT7EZSN2rUdEFaZC7peRLmJgHexOUBjWGrqlSxRzYONjYGBho6DiYuNmXKZMiTZRJJkYAkMUnqSNaJaBpZgoSLyAGzGmRMSCdhVkAWkCZMmzAZQ9qFFJBDGUREgYoXGDRADCCTVhJox1LOy2EIXgsC438LhvWUrNh2lTIoECr2SDMgLipDLBmoa7BTqtrrtyD2wUoPK7GAdJQfhO5DfUGZWlkJde5IKDIbNQEb3FHQkmqfglAqo6QGzoQKtZd1SA1UPFN7oJRIHipTD0NJrkUXNDUsC67sfuCLjaOwOZZeDP/u3/07ZmZm+OM//uMX39u6detLbiuE4Fd+5VfYuXMnf/7nf45hKA/ukydPcs8993D//ffzq7/6q9+x39ve9jbe9ra3vex1fOQjH+H9738/P//zPw/AAw88wOc+9zk+/vGP82u/9muv9uO9eN1CfH/F8Otttei9czTN3795ht/67HE+fbjCL71JDN9Pvbjdxc4thEBK+Yqu8ZVs+3LbfLffvdT7f/u9l3v9/b6/r/S6v9/7vpb396Xe+0Hf40s55hVLgN/IDBtalWk35MlekSYmT2uCia+MIabWYK7NZLvHmfO7qWEhqNFqFzAx2FOsMHUAgvNw4YkMC1FEphlhRDA/AZMajI6ouYhvQH4GonMRWt0gnNdwZiWrWYNOco5YDDhVukBGgr0ElRsl3kiPjA/Fb0iCpkdgWYiJOdCyyinUl0BCZTxGPni6Irz9dehI2OhB0CbZfpy50w/TXdFpCosp6SNrB9lYEpCbhHAU2AnrD4GvwZZfg3WB6QqsCNIeZLM+0xWInoROHDK686+pJAZE5k8qV2eRgImkmtANzuEuPoG5IelL6KRiZtaquOsWja5AK5ym+5MVyN4B1iFonYPST4ExAf4A+gFY4xDvg4EFrQB2rtFye6SOzLOaMbB6gvxGQGEguU07S1NopJFkdfib2QKMJIhKb6RVLoN7G6yXwUioiI9EpCaEcTDsr1tCazzK1Okj5OuSWANPl7Ri4NxRMoMV1lJK7Re6E9D2GTl+Ds0DZwyyAmIHOgjsWhd9ETChn1HEVyyrOa2U6nTuPvC2Kw4enlVz2OllOHq1xvx9PW7+iiQzDm4O+i0QeWjXkxhCJzfZZXKxT6un0/aziLDLwCvgRTbZ+gpBQf1z0H1V2G9vhW4S3ClI5yRFu0mvOcq01uOazICws58aFr1yF00vs76hk6RDKw5IYJO6xBnWKyLA/qt7VjehcClyuqNHj/Ibv/EbPPPMM1y4cIH/8B/+A//kn/yT7+mYVwY0NMB4kYRpGJgYGC/+18YggUGWDCnyOBRpk8bHpo9BE6hrOn4ihciaUNKhMHR4zllQQhFdDMjpyuwqKZT5lI6quBqeigeIAyBUBNS0lPLH0pWUOPBVlVfow57aobJF6qq6KmJliiUNFXEXB6rtQ+qq0qtpSj2kSbWgiq6kyNJQv9c1VQHWDNVjTKSOLwQgQAuUx4OhK6OrtK6UQAYgkmq/tq8GJjNUwe5xqAY+3VGDghaphQANNENDExIpY65UEvyKCfDmWPpd8ZnPfIb77ruPn/qpn+LrX/86U1NT/PIv/zLvf//7v2NbXdf5/Oc/zxve8AZ+7ud+jk984hPMz89zzz338BM/8RMvSX5fCYIg4JlnnuFDH/rQt53rLW95C48//vglH+/3f//3+f3f/33iWH0vNxqNV3VdLwdXqn9UT51a5q5ZF1PXOFXp88TJJXaPpji80nlxu1rt5dujpJQ0m00AtIv8g34l277cNt/tdy/1/t9+72+/jqKIKIqo1+uY5g+WHl3KPfpe9n0t7+9LvfeDvsedziuP1rtiCXCdLiNyN161SiCLxOZ5LlgWTzb3UDK6vOHNXU49rVMhTaitU5JtjpNjBJ+zHYtt/yNG3ymYurdD9ymH6e0wX4aFAuhTkD+lonVFFTppGIkHuLtX6N8j+dKeLOv2NMIvQXyOAEWYOkXo3JBHJq4mOn0W11shMX+U5WvGYaasJjyhC1oC3CRoJggHOk2ofB7Ck9D0cBvrlFfaXHOyyqJlsnjvdsx4nbYjCUoOWOsQJ1ScRfs4I9Wn8bUMnfwahCaBYxH6MdgQ6jpZS3C2DGFSgh2RaD5CZzvgvAHsN0IiVr2+lSqu20QvQDCAUQFmHfqhjkxGDMppKGWh1FT5QtG9sLYF2l3IdUBUoH8etBSkJ9CD8xjNJTA02gcc4sEBiLbQan+GddEh04NCJNmSh9NFjU6cRt84gXDuhPA2WB+DRELpgl1TVVV0HZJNyB+C9jfJrDzJ1k6AM6pUfn4EmXRE+eQ57JMQD2MrA20C6jUmiy2WjysPG68MUxacCMEMJMEG5OegKyHjQbwbjIKaiyay0N8GFzJAF0bnVK/vRAduXxac2QX9w2AvQlCBTge8hoYmAlxdo70MshwiFrbjhxnyzlGKhRpiI0Mr1IjOSwqxUplbDiRsZW4tPNiyE95xb4eTp09x7e09ptcF6c9pfEWYJI5P0yussuH2cbwEk+Q5r1WIiC5pDioTal79XSG4pFzhTXw7LlVO1+/32bZtGz/1Uz/FBz/4we/LMa8E6NhYgCMjBBoCjYgYHQeHFM7QCCsNjDKCRokmKZaIqeOzjEWLUXpGHrabUIxhJFRGV3kBsyaUBaSkIrKmVKQwWoeBDoELrCozq7SErK0IaVsbbjcAI6cIaipScmlpKKt5L1Jy5nZF9eO6jvp+QIDng5ZW7wuhytyaVAocy1K+CKENSJXf2wdCHfIZsGywgWBVEWorN3RqioGukmk7JmRGYeBAx1HvuTrYY3B2aNjVHHa4atpQiaMpSbVIgBERpwN1D8IYIu+1+PO/5rjoOAqbY+lFcO7cOT72sY9x//338y/+xb/gqaee4h//43+Mbdu8733v+47tJycn+epXv8pdd93FP/gH/4DHH3+ct7zlLXzsYx971ddQrVaJ4/g75NNjY2OcOHHixddvectbOHToEL1ej+npaf7iL/6C22677TuO9yu/8iv8yq/8Cu12m1wuR6FQoFT6/sqQ31woMv2VC/zZs1X+08/cwJv3jvKlo+s8dLbLrbtn+G+fO89MIcGbr91y0R7gF6pwxWIRXX/5f9CvZNuX2+a7/e6l3v/b7/3t12EYYpomxWLxOyTx329cyj36XvZ9Le/vS733g77Hl3LMK5YAj+vPUpZtpNzHFIJGtJVUdJYmPVK6oHdG4+HFcU6lTFxZ4sBgnZS0SQGV7iR/c8xieilg97sWyf/SgHgJFitgTMPaz0HpE5DvQGkbmNsgOyapXhNxeFeSteIO6E9AAHpdoxjCriqsDGyWzatBG6V1/SzHzWNY59YZbLkNUnmwkmDlVWl5oIHXVxOb2pdJrPw1zkaTZAN2VgXFNhzL6ixMmpTrp9hjhKyaJuecHCTL0GuhVZbJN2tM11us5AM6wSKMjTIojLOte56aAV5e5xvpHN2SxKppDEKNKD+DtXqc7OpT1N6agPw2cObBPE+/ZFHfopMxBGYCerFLhTT4Lt1du2HbNGgDaHUhuR/MGMwVsD0Ivw6DJo5eY6LWxJ5vETZgzI1ZLGgsJ3oQLlLCYyqp5nvFNCy4JqfbNva5BpNmj5XpNF74I4CmJnje0LxFF+BuQPERtNo3KJ85zvazHbomNA1oRGAVYLoNqUVJxdfoa9CeKCHGrkFrncYYjXCXIGOBMwLpHgRRlkHFJdGoEyci8hp4JfDS0EuqeGYtgnk0DlpJ7hz06K1B3oG+B9keTJZUxXfjaaUmDHoGupeGdA9nPEQTSgGZlYJI22BDCtYrRfLSZcLrEqYlYh2MmsbYtZLEuFJPWnMQlGHbu2Bfv8PhRwy++MhWTOEzQZ9Be4oTcp04zmIS09EEoe2xw9/K4UtJAh4WkL4rNq1Lvydcqpzupptu4qabbgL4rnK7H6RE7/UKA1V9jBFo2OjoOEhMInQCLGySpMmSR5BC4BBi0kHSxKBNliBnKXlIsQtFA0YsKOoq4mjcVAuGdqQycm0HbFupUzSpJMoyVOaERgjdgQoCtwpKqtzrKkd/PQZzKPkQEjRPPX8GkM1ArENoDHtsY2U8FQeq2hq5qjqrAWZPuTBHCfC76tzO0CArlhBJtb8MwbDUcRJddexYB7+niLWWhKgCJMBOQtJW1eR+CKNZdc29SM04Eq6qYHtSfYfZgSprCnv4V7gyq7/AxcdR2BxLLwIhBDfeeCO//du/DcD111/PkSNHeOCBB16SAAPMzs7yiU98gje+8Y1s27aNP/qjP7rkqtyrwYMPPviq9tN1/ZJJ08WPCf/yx/byf/3ZQf7PPzvIjVsKfOnoOp86uMyF+oCHT27wsffegGUar+h4mqa94ut8Jdu+3Dbf7Xcv9f7ffu9/f63r+iVd9/eK7+Vcr5f7+7ff+0Hf40s55hVLgCP2MJI/SK3V5hphMEHMBpKGsUjYEPxZe4IThVHioEbsWSzLNNvMBlqskZcBFhlW2gnkF5JMvLuLsQ16FqQE1O+AM7ugUIWn+hpBxsayBc1Cjn7CUXa/sQGag9OQzKyC/hRkRgXsT6sJTGKMaN8kUfk8mDvBzqnJkvRVdcALoW3A6vPoS1+mdLjO9KKS3EYpWByD6pQO0mAyOcDow2QlItBX2Ij7eMkREvU1po/0GRyB2dt7NOrPEG5/D5F+DWdP18jmO/iFG/CCJFQOE+/dCV2fzNF58sf7FMshneU/JZh8F7QEJFP0Rm6nn62RMs4h7DT98TerPuH8LKw/DSf+ExgdcK6BrXMg1iA6B/UA7BvQ2wcpNg8RNLJUaiX645LFRois+pDWoFjEWDGwMiEbnkHVHKUm74Tms0yun8GONAJtUk3AkiEQq2qJiED0IXUQrflFxuYX2NHoYRlgmbAUqPldfxyiM9Arg9WUyFGd9v+xH9IOybVnWTehtV0jykkcDUYC8JxJjMCgaNUJgfB5qGzTWd6WIpHsMlqTGA6cKGxDcyBbP0vvUahfDZ1b1Z/UbCuz1EFS+dv0PAdDc3AHffRFCzsZEg4stskEVSfk9CBDzxxQjQ2KfRdT79MI4OC5DOMXTApfjRiELtf/7AbTt4JtwLFvaHz+f+aoDVJMYrKdHDaCGzpFDusVejRoGzapGBY4dmkP1CYB/oHh+y2ne7XH9H0f3/+W9rLdbr+qc/+wQgN0YjRAIDHRMNBxAAOBToyNiUuGFKPEJAmx8THpAB0sBmYakbWU/CU3gLyrfnIa5A0oGGohThPK78BIDPtrY5CRqvKKSP2eEDwP+rFyhxaxUgHhDXPfnWGzcqQWRTVTyZGdtOqzDYFQKqMsQw4l0UBogTHclqHkOXYhaKhjG1LJVmI5VD0L5Tit2coZ2h4oCXMgld+EKdXNi2NF4I0InKKSZSdjKKXAtGGlrSTSjgNxV+W1RW1F3oVUqQYyVlJuTRtqfa8wbBLg7xkTExPs27fv297bu3cvn/rUp77rPuvr6/zSL/0Sb3/723nqqaf44Ac/yO/93u+96msYGRnBMAzW19e/4zzj4+Ov+rg/aLz16gk+9t4b+NefO86DxzcAaHsRh5eamxFIm7jscMUS4DVxPXeE81ywWjiBwQ69wbgs4O1dZ7FrcCIag7gDCYkUGpGfpTh+gUwiRlzQCOw+qZJg0LNZ/as89i81OTOqqpKaAStjGisZAxEBqQyYGTVBaS1BNFwdD+uUlxpkT0LlWQvftOH2AKYmQCbVRCS9E6zJ4cTGgthTk6R+Cionof5FrOdrZFchYUE2ATILoxIKqxGNTJekAcJS5kyyKnC8Jl55Dt8pUZd9EjGYVcnIs5+lGR0hvDEmHNfwghzSegOkCipHcuUQJgvkRYfSJFhjUG4cpfI4BBP7lX6rNIc03kJ3sAbuOUj11GRIroJdAW0VtF1QvBOOniG99Ckmn6oRrYf0nRzGjjbN3S6D2f2IMQNz5SnSepdBUiIKHWzjaZIJn/W+zqpRIp65CcIcpSMbZGOolXKI8bthkFaTQ88HBMTrUG4Df0N54RQ7GjE1B+xx5bg8KECzpbF/RdKIwC9C3NFZu24/cvuPkTj939i7cJSsD/1h8pTXgQ1XI3QLjKXPEBYiRALCGdg6K2joksNZhx+Z8DgZp6hOXc/shYeJDYivB/88uC1YmILkCrABcd/EuSliJNXHOtsHD8zjNiMuWKMRoThL/k0+O5/V8M9BGIeMTmnYRTj2TIpzU5OsrmrENQdXg4mVCjsSEl9X82A3SpIngQAWGGOdOmVKJISJzVauiQQ1PE6ydmkPlMpl+u7YNG151Xilcrof9DE//OEP85u/+Zuv6nw/7DDRsNCQaMNuX5MEERY6NiPo6GiY5BgnRRGDHOtkaeGwhM4SObpugnhvDkoB5COYzCoH/HFbVTnTUildVE6QqrLqTfUjXaAHWlURVKGrTHUrB/kYxKqq+NpTKlc3DKARQDanVC5+A8y0Mrfyh9Vj11dxRJqm+otJqS8CXyhDLjcxDA6X6rvGGOb8JnXlyIivtkNTHhGGowiq0FQ/sqG6pQklxMMYvchXY27QBScHO+ZgpacIenqYN6+7MDqrvpASCaieVrb5UagqxZqm5NeBp9pWriRcbByFzbH0Irjjjjs4efLkt7136tQp5ubmXnL7arXKm9/8Zvbu3ctf/MVfcOrUKe6++24cx+F3fud3XtU12LbNgQMHeOihh16MRxJC8NBDD/GBD3zgVR3z7wpvvXqCe/eN881zVf7fh07y2HyLA7OFTfK7icsOVywBXqXCQd9CEwkuyEl2xSfI6z3QNW64J6LxpQVq63nOZ7ok+pLxYpU5R1K6TZLaK+mPCzZmwd4IOPMH29G+GpG8uUulMPQXsSRx3VJ61oqETAhuGkRa9VclHAi6RM2Y3lMW9XqZhN0h8fgygwNAqwrFLWBvh6inTEo0H3BgrQK1r2FWjpF79BhbmgGThlLQRT2on4HetFpUT2ZBH4VOCI2hx0nKEHS1AfH4PqrXt3BSbbIGZFd7JDlK/3Ho7DSojd8I3kCtyA988JO43RA3BeSBJmzrBUz3nuXk2jHaqd2IkZ+GxgTsGih2qQOyCNUvKUvs9E9DNgXVLhARB3lqGQdNrJBtVUm3JemqT6H1MG0rQagNMDVBQ4OGPEssM5z3kugyJp2rkTn1BWpli850gNBNWjtuhy03wKKtJmiBB8kWZJ+C4BBu83lyjZieruaYG5oivzkPZFGyEkJP14nzNvXrriW4/X1YZ55krn2EUEiEBbORZDBQrdjLtklkVCiW66CBOwYB4E7AjtEup8vwYMKhm78dpEOu2sXxoXkNxCXoPwSJt0DGhjip0erPMXiiipvuUxwJSQeQTsUYt8KF3ZLA8aleDfo+ycQzYMYhW66D83+d4Lw2TaTrDAKbWIQkZRavaqIbIU4EW6Yk+8ZX8ZckVbmHRarEFIiR3GOdIV+sUdA1upUM6WiMSxJnDU1dvys2J22ve3zoQx/i/vvvf/F1u91mZmbmNbyi7zc0TEB/0fgKTCwsTNKkSJIgSQYdlwCDOi5NXJo4+AmHOGMrM8CcUE7OaVNZvhdtZQJlRyA6YHTVWK4DxtAJGX1oJqWpZyWKlTTkhWBYS1PkMx7m9eq2yoO3XPVa5lSeu5RqYNNccBLKjErXVc+ttIcGWMP+2zBEMa4IGKg4otiGxjDyyB32Heu6qhibKEl0MMwoBvWFYmjqyyfsquNrOiCGBlwdcHTIOjBXhvU+1AfQ80GzhgaFCbU655iAp6rUwr8yK8AXG0dhcyy9CD74wQ9y++2389u//dv89E//NE8++SR/8Ad/wB/8wR98x7ZCCN72trcxNzfHJz/5SUzTZN++fXzlK1/hnnvuYWpq6iU9FLrdLmfOnHnx9fz8PM899xzFYpHZ2VkA7r//ft73vvdx4403cvPNN/PRj36UXq/3YsvJDzMMXePWbSUIZnhsvsVXT27Q6AUUUvbFd97EJl4nuGIJcJeATiIiSqxwYn2EdQpsFWUSx7r0OxtcU7U5b69TzvQRuXWunYW52xWxrEzAIITjXwXZFrRGl2k8M8fg2FHEPhVnKHrgnA3IrXmUW5KWaVLJ9tCnPTwng9QtMgvzTLR9wvoYBUMnP9thdXGFwcoFEDWV9zhRUNrcSIB00VZPUXjwDymdP0f5VExRKLIVGGqRvtWHziroY9AuQC8BmRbk07DchmwT9Bx4g/O0Rqfwy3cQht9gye9RPBEzGIN+xaC/2wbSUMrA8cewlp8hYoaeMUFn4zzTGUnRgJYBgxb4vYBxcYRec0Br609AZxZGQ1j9POQiSN0HG8tqwtRYVJVgCYMdVzHYMwGdJ+h1nkfLakTBFJWzJulahXwpZK4YMMjAwaZG34kYbXikfYHfhKIZkwlDGlJnfccs8s43w7qrzF4CAVEEzpNY658guVGlkIxI6FB1VOU3HUM/DRXbJBYa57dHBOHVMPcOZfW88SSlxb9kTPosmdAxwM6Ca0AtCxW3CGbIQMR4ZWV8FgkVk7lQgo6h4SVHYPYGrLUzbFn2iSsqKeRCDE0fJv4Gpu6DSi9JRsuQT23gmwZxJ6KRlpz+qZizb9No5SXWQM1rc1kw9oJdhTAL0cMSbeBSOt+lGElWkIwi0ENJ1AZvHjY+lSK9OkdaFjlFAps8DjCuP86BratYOySpBTjTsdnWHQeef+UPlMXLjybRy/xuEy+LH4Sc7tUc03EcHMd5Ved7PUAihym/GjomOiYGJi4GJfLkKeKSJ8TGw2CdJC2SNHEJci6yYH2L/OYjZWBVMKCcAL0HBBD1lUGUEStzKd1G6V6HrRqOo0yqjAj8tlpNE7qKNopDle/uZpX8+QUCLE0gBYMBBMOsXScFiQzEaUVInaEEGqF8FwJPyavRVMySXgdtmCO/3oFJB1IO1GrqPKYBrlTZb16gcoKRykzRMpQMutcELBWbJOWwR7gG7ghYKVXtNWqqWt1pqmw43VWVa6mBE6i+4EBAGA3dpq8wXGwchc2x9CK46aab+J//83/yoQ99iN/6rd9i69atfPSjH+W9733vd2yr6zq//du/zV133YVtf4vc7d+/nwcffJByufyS53j66ad505ve9OLrFxYG3/e+9/Enf/InALznPe+hUqnwG7/xG6ytrXHdddfxxS9+8SVzhX9YsbOc5OrJLEdW2nzm0Arvu33La31Jm9jE9w1XLAHOYXKiY2P4BkvWElaY5ww90tEO4vmdRCRZZIPdSxJbjwhqS9RvWSXxpJLAPjsPC0cMvMBlyvHIxTpyoOYZA6Gh9Uzc/88medYgU2iTGESM1gPa2z0u3K3DNSe4+vh5shtglSs4OclyzWAQhWDHwJSyHzbTUD2MduhPyZ7ymfpmi2y1R8EGOaYSkHRXzS8cHwYS5C5YD3Rq2RzCiNmnt9GWYWIJWhqILEwPPMYPP8rZnXfjj99Ow/sG4UyflCbolvcixkfBGVd5kFfPENeXMS6sIZM66WWJKEGUhb6JmlPpEK4LkuEyrR0CjGXofh6tbSHNrRAZsHYcqgtgdaAQYYgWoBOPZGBsH4PtPwuLLhzcS5089ZkBa/k/YG39cVxPZ6wbEmt9HF8VUlIDSKcgex4C14X87bC0FxomNAPVU+dUsapfYmtzjdhW6sK+DVZbLRpkujAi4MJMicjPoLMM4xNQ0HGP/iGafwptyaMeKddnMVACxvEM+IaLl5uEqEUlq6MlBYOCgWYJ+rqk5ebxZEZFoMRtZGTiVQzqB2Pi5zSyWyRiDOLnXNxRDyP2SN9yBO2OCCzIWnB6Er65JUFkCkw/IhXGhAbUDAgzUNah1YREL2JM6MRilEn6xMxQMhrMjAvaIfSPQLQ4jRPdyHkMPHxiBphUqQmTE32D/LLJ+VOzHAtGKXGJX9I2Lz+a/OD9JC5b/CDkdK9nid73ExoaDg4QoxHDkPi66CSxSGBTJEmaBA4JYgo0sVnH4QJJBukE0ZSDGDFUtNFsNOz5TcN1BWV45XRUZi8B2FKN6yJUXgiRpnLULaGIZbWvHnxDqsZ9mVBVWSmVuZSbUtVRUL27PVOZB/gCoowilb1A9cHYI9DvqWfPSsGgqUhwdkxVng2AxrDX11bk27WUsUEMtGLwYhVR1/VVFVeLIBMN3aR1aDtKHRR5EFtgC7BDQFdV4bQJ/a4i5w0diq6KuksJ6LWh7ULcUq7GXgeCviLmtqOIvRyS9SulGnyxcRQ2x9JXgB//8R/nx3/8x1/Rtvfee+9Lvn/99dd/133uvvtu5Cv4N/mBD3zgdT+evuuGKY6stPnLZ5Y2CfAmLitcsQR4B30CmaLim4iEZCny8WWPa4CILhEwgsMKMTuFgzvWRl+COAlbXNhIw2IaKn1J3taYjiTpDGzoENkakZMiEUkyPZvIgF4PEtEAuy+Z+B/niT9nktYlLVRrWG1g0luboXtbF0anwJ+BjKPYrTOLzP8I2eX/Qv64ARmdym5BH+AUZLfCaAHKJXi6rVGbM9EHEdagRxRDx4fEMrR0ZTg6iGE1B1NHfaZXH+HczbcS7riN9hvXoLVIPH4ArXsE6RQxvSO4S8foTl1FdmkZbc3DEaD3Ic4orrlRhOyKJNmHal5C6iRkA6jciTz/FiinoPkZQEAygdZdIbPaZZCyCEfmILEbtDfCkRFYLUJ9HBJtWI4JrVFqWRPaDnN+SCaEfA5SLpxMwMacS0fuo9e5E5pvgsMmEIBhQ9hDKx1mS3Scogb1HDR1NScbb0ClCZ0CjFnQq/RY21ZArFtYi4cZO/o3mIFiuxJVkHDqikAnUerBlmNBLg+tFnFC0kvlEKkRsNsMrMQw73ganAZ0DaLkVk7PlLjq/AbnL0DyuHKxtkdCqpNwdK/DymSJicYSOx+VPLEVzt2UJsZgT73N9OOS2XNQmYbDd0LXgpFFKGqwkY1ImE3OxGWWiBmRfUave47k7YJGG5wa+HGMQ485Yk4zjkUVnQTHzAzBUh5rKYtHAY+Q9KU6rWwS4B8oLian+7mf+zmmpqb48Ic/DCiTq2PHjr34/8vLyzz33HOk02l27Njxio55pcD431yHle2Vjo4c9gJbJEjgksEiSxuXPg5dEniWTZAwoWjCiAFZTQ3meRNKDmQMMCOVpasHKAKM6v3VIlSYq7LeQtPVgl0QqugiHdXDglSGWAJFWHVNLSZqmlIGMZRQG5oy09ItCHpAEoQL+rBcGGmq/1eaiuwappI2i66SKuMqF2ZNgOuq6mscqwq1jL4VnaQPY4x0Y5gZ/MI1SlUpNlDnNN0h8Y6Vi7Smq/7kxHC/TEq11kgfUmmV1xYaQ3fq4eeR2vAeXEHYJMCb+CHDO/ZP8uEvnOD55RYn1zrsHs+81pe0iU18X3DFEuA5TuIR4KBxwyDNE7rOHjlJnpjzDDijdRmXDhIVwWhs90inlXKre8LAKcTce1/M/F9Br56kkFqlugheF+KMjh7Czqtb2GXIDKCzBu1zFq4XY/R1orUEgRVRNiRxlKSSHjDYvYy5p0QkLHCSoI0rl8zkCNaIoOxEbAgDT0pqsUZZSPJtZSa6fDWkXSXpPT+XQa/4WKFP5O6l1l3EqbbRQ4G/RccvSiYakqURh96STurrT9LN30k8uo9Gfj9Ga5ls8xgNu4xZO4HdHUBhivbuq5l88hlEThIX4VjGZVk6TNRaTJ6HeKvG4p17YffVcLQET92kZHWN0+D0IDMLsog0MsTdZ9F0B5JboHwnHBmFtRyEJhh5NTGyB0g5StzSoZPgvDFCUV+klzCpbN1OZ2sWoV0P8wegMq7MxrK6qm54ElJdir3PMdcfUElAX4eegG5PzdsKLQhTBidtHdkC2InjVhhdWyW5oXzGprtQ91TBQxuojF1GlQeNCHXlLC079JJbECP7FTu2fEjOQuFa5X4a1ZXJy+opFvYU6No6256rMNGKyWyH6tUxz4/BasFAs2JGVsE/asGuiCBRpNBsct1/sSg8nABvwHQJovGAx6XOzmcExt/oULHo5CpcUy9zQbZJJjtk3tanPgJzXbCugfCpGvWaxwYpmrS5lgGWu0xOWDjsICYgZo3tlJhl8dIeqBRKvvfdEF76M7qJb+FicrqFhYVvs/9fWVn5tgrG7/zO7/A7v/M7vPGNb+RrX/vaKzrmlQANiYmP6vzVhh2/GtrQB1onQYYSGaYwGWUeqJOgQ5o4m1BEd9SGWVs5PadDmHVg0lKGUlEfoo6KK7ICSAWKAIshATZM1XtrJVVl2IhBphVh7bdB6w6JqqvIoAjATylDKjuhnA+lCTIDYQpiB7yGcmyOXEi66lxeV0Xo6aaSDRmoc2GqCCMNJbc2Y0gMnaXl0I067qmentTQEMtzVI9yNHSqtg1Fxt2ESifoemAUlWxa7wx7Vm0YGVNkOI4glVLmW2YA3RHV4xy2wZfKLJJhFnB8hTW8Xmwchc2xdBN/pyimbO7ZMzqMRFriX/zo3tf6kjaxie8LrlgCLIlZYic+VVwcisLDQTBKm4NUmZDQxGOSWZrTS2ydiXnqywnqi3kit8poImbb22HrtTG1pyzGtqxhf01Dv1PDv9mFcZuVm3V2fFLQWVGVw0FCIOsmicEEaa2PyET0dGBfj41bC9TnBsSGgDaQ1sHyVEUgjjEXVpkQEbVixMQWiS9cVrcUyeqrVFxJNdbJCUE5lIxUmzgCjO2SBdOgJ0Y5XXbRRAoZ2CTlBvlWDc+MCMd1DCvCWHqWWL8eJm9gvP8wSJNGewnf6+Lteg9cuBuhj1FLncLy2hwzUlSnfgw6Aasrj9G0G4Qzo3iZn4bPbYGzu4AQZnxVAQlHIBTgdKEwSq98AEZvBasErRmYT0LXAM+Gfk3FZIxUcGtHyNZ0Nm66CdFfp2a1qa79JHh3wGIE6w6sJ5QMMCWgrynzFh9gge3n56GgfFbcJozriiPnU3BqTuNU8Xr0uILtBFC+C6oLbPFrLEgVwdluQyoazjE7kN4F9QTUHIgyWTXZDEzEnvdCZrtyaE3aqkQtIyV17BqwvkKh8yCWEbBx71to33CB8MwhRrSIc6NwYdSi3O9wbb1D+pTOcj/HgluHqMXYFwaYX55mNa6TzIdMFWDycdj1vKAxD52KTmF9G1vvOs1K73mcsynMWxvo2yWplpoXb+wD444+q5/RuEAdGxc0j5tvXoSORuPQgOfFCGlqlGhgm5VL6zWzefmJ2w8+UvGyx8vJ6V4gtS9gy5YtV4xE79VCRxUaYx0MAZrUhm7QBjY6CQwSuFiMU8fAZ4BHjq6WoGomicdMGNEgI2BUV3m/pQRk+yrqztbUgXUHQkdVTl+ooqIph2ZHUz+Bryqf2ZIiyzIEI1AyZ02DZAJVpXXByiplEEnwQxU3JEzlziyBREmNgw1d9dWiqf0GoPpVTEWATR1y48o50atDOlCV6j7qGjQftACIVTXW6w9NDS0l2baGxl1BqFYEa8MsOddW5D0aqCB0oatKeN5X0m5HKpOETgR1C9pJ9R0RuODbyvlZhGpxAE3JouUVQoQvNo7C5li6ib9z/OQN03zp6Dp/dXCZX71vN6axKUPYxOsfVywBfobr2UGIScBhkmTxGDU0JguLzNVzSBFToEDRXGPCqZCqQRRECHSiKI/VCll/sEUx5ZNJbVDfBo0nNVL/Vad9gwm+oL3fpPXZgKimvEoCO2Tv7SFrj3TIRQEntrmk9gWsz11F9a67KTz3X8mfr9BZ+hS1Az+BnDmgZGIYDDL3stL5Ote2fU5FIcHVGmEpxyk7ZC5VYToSVBsqfnJfT9A6C+EpsO9Zxu+W0fo9dDNCoDFIeJyeyZI50iETRzSunqHw5AJ+/zn6UY/M+hqr+jhEIbJSAn0nnO5C4RQjZZ+0p7E0kwXDg8yA6KosrTkf2XoDfOEaEBlwHRjzYV8Fmg+C34Gz6zj1Y4Q7LMTcLeBsV1XfQ1lYMVX/WZBQFQdzAOmvUywexBYDrLWDxIkI0ftR6L9V2TcLXU2WLFdVUCIHkKq8KyPMwQXKhodpQdtXBQfNUvO11Ri6pqTgnSCMIzr77oLWHEbLgRCyBqQrKpe334dkW81T4zEYGEDOQNpJcmsrdI09xJn9KrYkN6IaheO+qqj4fahfIHv4f7HrkSq1EYuNn+gSjO7nOUcy1z1MyojY0gnJBsogNtEVpO6skr0J7GaLrU+aWFGPEafLSlEit4NxHrYvmSz1XXyZQrPXECc1CncMEHcOSOyErAdT82BNgJeF+K0+zadPEK5MYyIYSEHtuSyEGhljnSmhoZOhiY4ZTQOtV/5AWajJ2yY28TqBrmnoGghNqv+XxtAAS8fAwMbBJoFGlgEWHcDDYmDZDBKukjznpKra5STkJYyYqrKq94fuyahvWTnMykUbkkhUJe+F3Nc4VvJfO6HkwHGsNtK14XEMJY0mCbjK0TlSY5WqsA4rwRhKdRNK6MVKOq0PjSIG0TAaYOg0LTR1LE2i8n+FkmZHcvj/w0xeXVMfQkRD2fPwM2gSXF3lBAfh0IAroVQvuqcWACPUhzR0lR/svrDi4KhqtG9C0oHAUYuGrg2BBcFgeGO0by0cXAlq6M1xdBM/hHjTnlFKKZtq1+dvTle4Z8+VoxLaxOWLK5YAV0hTpMq4ts64XaPg72Nu9hDJWY9tj5Y4gs6OXIXSnhbJmmT5abCasCNbRwY5TPqU2pJBW8NLSlIjsLJFkD4n0SoBMqtTm0oycndA/5E8g4bL7Nw63qgk3F5jvpBk4e+9Dd0/QTx3K+6pI+z6XJP4lOTaXaf4Wv4JWltuU5XMfh/8BTaKJntNj2IFiucGXOidwhrRmIghHEA3VnxLSyse2XxCZ3xQZWUqiYbLuF/Bj6A2liUezaJv6ZAKIzp2QHtuC4mVeTJOBe9cjKZtYBd0HKHRqR+GbQZm/GW8KOTk2BiJsMPWyudpCxVtuRzdQ7zxC0q+7EhIa7BznsTG7zNVe4JmbNAIbaTlI30NvAoE81DdDSvjquqQ1VQchqeB2cWePELR6FNtway7wmJzP0HvTWAmlEmKGKi+ttBU2ZXBQDmg+oDWwHTO48eSVhsWR23WsuNk15ZJ92KMJLRzGgnfZ28nZOnoU5yfeRt4ExQzcHjVAQwEMa7tIwrQy8Ng3GTDLqPrZTSzzA0bZ/nm6Fb6zijENSVB7DchbkOvBmKBXOUb7HmiQeNIksW3ZWBsDyRA6jexkM6y9flvMNkMsfKQOgfdC+C9G5p2kfEnOsyctdAnq3TygsVTBZ5cyDJudrnlrhr7ToU01wOy+xosNTRmDkJJgFsAqwzBKqw8DF3dIHhnzI53z9P+Tw5CQiGqstbeSw4Q2gU0rYsuZykxQYIp4Ogrf6DSvPzE7QqL89zEDz9MaWNKAyH6GFhYJBDYRBjoGCSZIckYERkC0gxwWcKlM5KDLSUor0FZg+1ZGO1CQarcXzpAXxlTeQPVZ5tGEVEMVV0lUO0tngu4kLYUOe0JSBcVEfVDyNvKcr4dDhf6JqDZhjhQkUlWWrkuOyOKZAKs+dANlDlV31J9G/kstHvqmHqsjK+EgLipzK1GZyE+OTQORJlvYaprdZxhNTZW5DzqqGNrAhJDsysdKARKxi1DSDsQ++C3wJ5Q/cW1c+q4ZkLF6CGhl4JSB4wkBGMQRIoktz1lwOVF30pquhLcjy82jsLmWLqJv3NYhs47r5vi49+Y51PPLG8S4E1cFrhiCbDGJB1cHH0f1+/8JkfO1GluZOk3I2btHrlUzJ47OgRjkByA60P9MylSs21KwRpRxSA3ChtSkpqBbgLEBOhfN+BoDLcZiMBhfmdIebbP5HGBPS7pxyAOSM7ftQNx/VWIygSkphG/9zQr3xgjFVdYT8X0ZVkFzQYC+iEsHcOf6LK6O2SrA20dksmYQCjPkVQDGgG4AZBVCRidqwTJddgaLFDPaBhnYCQLdquDFnXZGNEJMxLHWmcwlcUXGls7EVofjLWAjANiXMPofo7EpEc/FVLJpsE20GOTleIOvO5OhLgK4d0KM8DUKuSSYB0lM///sqN6kLOaBd0IQ3cJ7AmMlXXiYBFaj8OJMViLwHFVVIjdgPwoFAXRrgStUxZ7JkJOBZME1Z+FfhHyMfSk2ieU4EZqAmb6YFoq+ijyETMBXgPkOuiNGHPQw+xKRgKYjKFZMlgdS1P0GnQcA0SP2M8TRTqZZETTNfEKNm7bp+9otHeYBFu3ILVbibkRq3KYpvko/txuWG2ozM96C7qPoXkHsUUTK+pw1dIqctGkERnkN+rUn/sm4f4DcOgc0hoQxhpEsPqYxuCoQc+JCHIGviwxudTBMHxkUtBZN+n5E3h6ikHk0E01GZ/1mdB8BlugOC4Rx2DspEbhRol/GurPwMYZi2a4jUFykRve3+dHmscZ9CTnvrib070MfSKm5AFcLPqU0IAFli/tgTJ5eeneFZhosokfXqiOXwkIJDoGFg4OFkkS2GRJkiWNjUsPgw0sNjSbdt4gKAooerAzBUUdyja4fdBDRQDtQMmXiRUJxFdOziJUC2OOqSqarqGkxKb/reqwBrQ7qtdXD0CmVE9w2lXkUUTKgEo3VTSSbkFsQMVX1VPTVGYHnqVy8QTgx9BvqfiCWEBTqIijpKUk0sKAlgQnryrNVjzsUTbByKhqtB+r65dD8vxC/q/UVAXXtRTv14bXJnX1WQxzSF5jJfN2HdUb3Gqq7YouDFJABD0bOiYMdBUR5Q/UdQh9eC18qzJ+ueJi4yhsjqWbeE3wkwcUAf7KsXWa/YB8clOqsInXN65YAnwayUk75OZgK/7pAaFzgmQ/Q2hk2fX3VqmegWBD9U8OZmB8K+x8PqTTtyhOBmysGNhajLlsYO6K0Zcg9UySq+sFVr/Zpn2bDX6MN1siv38BuRDQWwYnhpU3JPFHr4Hjq7B0Afvol8g/aRJEe9iiCQapBuHkNAQxhD7UWjB2Ld34LMbsKcpdyCdUxOJ8oERxJ9sQjcO6ANmA9bJJfdKltNQlvybZm5V0dqpkC8uXZC9I2k0IthkMEjOYcg2RdqgPDPKuj1GEuKdjtCGd2UBv6pBzID8GW6/GYw+sHoDjI9DMofp9D8GYhNiFlWfQTx9jSRh0R01kRiDTJsQRUrOAuaFLqQ3pYVVk44+hHEDqPbCURuTfztKhceqFE/TbPw7VA2CFUNdVJMhg2Hum6+r8VgDWmjKi6Q8I5sY5mN6BO+iSq69xQ1gjPwHnMjp1TyNDRPN0F3kUtJk+mlElSkxTO6xTXolwt/doFIEMTLqSKRGyUqlQ4zjm0gm2106wOLOVeHSfmuCRgOoqyQtfYmz5PDlbUC5D4QwcX3NA89lyOkQmDtHurJH9L31szWPtRy2sUkT7iSK1dplrbzzJ8Qxk5zfYdjJCxBpxCTQh2VHV2UKfmTefprxbEv1XF28QYfciRoHEVWDtkAx6YH8TqgsWS+EYa+QwD/XorPWZuVNQ+X9yGP2t1DGpARskyCEoM0DQpHWpQ8MLcabfDZfxnHUTry8o32VldKUhkRjomFjYuCTJkGSUHElSCGya6FQwWTUswpIJRaGqndvSUNCV2sUMQfOGbs2+IpZRBAzj2IStIoj8lgpit2xFGo1Y7SsNlHwZ6HaUCWAyUP22IgWpHPiGMpkyTWVy5STUcUNd9d+mTFW97WswMMEzQQYQhapiizUcK6U6t5tSZEugvhgKWUVKzb4i4JhKCh31VR9uFKrPgqb6lUER3YShqtHdeOhObai+ZF0b5uNJtUqr+ypL2NWVBb+ehEJKhdWLANrWMHNYB8tSMmox7D/GUIRbiMs7Euli4yhsjqWbeE1w1WSOvRNZjq+2+etDK/zsbVte60vaxCa+J1yxBNijhi/7nMRl2Z/DjAQ36WcBweJRi0cPjzCqVSg2BDtGBcEpiLUBfjOBf62Pc02ANgvFQky7BqsDaK7lmRFz3PP8Uzx8XNAaV6YeVkYjcqCzqlMajTHigNynv4z5WIi4kKbop0mFCUwskkWfc1dNwJ5rodOGhW9iPfNZRgd1mukkp2ccdp/30dfB81UMZN+AQgVaplosT5pQCiNG7R5+Qb1eyauiQAnlglyvgdaAYk2wOtCg6KKl0jSKebL9w5iuTsW9QcVVtM4iCxL0IqR3g3MHfGMazoyAbwGhmoStZkHrwOoyJKZoZ/JIMQGJIvh1aDQh0UI0d8NgG8R7oONCNYKJz4H1uJIwU4Top+DgVUhxLb1KAP2MmliGlqqA2H3Y0gSvCdo5WOmhi4zSbagAAQAASURBVCoisQ6pPuS3gbyNvnYN/fQTUPufiLTOhcQ4G3PXcZYtlI5+nt3VMxjjMPuER7DzQdrXvJtaokC+VKGigdWDyTwENsxkYW+lyeGlpxHP6mSnJCdvexN4CUhpSsYtBuSPttixJhhkIdVV9zo13SO5rtNqWkxUPK568gLnGtPYUZby8VUu/MIE5d0dRueXWZxWcusbnm8R16AaaQRndNJzMYF1mqmMJLFFIrtg1U1iXVJNRszuAa84bPl7DLRVWO+naVCmwSoTzRLVw6vkkxat43dhSJ870aigsYbAwWMdkxQxzqXq7DYJ8CZeJ5AGxCmB6GvokY5OghgbDw0XA5MECUp0ydAlyXksGpYkTMWwLQHbXNiZgB2uyvlloPLltBh6a8q/wAhU3pxmKOmyIxXRlIlh/6sFmMp12RBK6msOW0dAVXWNnDpm1IGOpcifiMGdBG0Y/t7XIdAgkGrw72pwPlAu+D6KmGo2SBccfUhKTehGEDUhYynSCsrEy0pCWATH+1ZlWgwryWFPOTQ7wz5lhCLZYagk245UPckDqVpShID2ANyMOqcZAJ2hm3V3eIxQGSyEfXUvMwb4DtRs1doiNWXBj0A5Q8vLeyzZJMCb+CHGuw9M839/9hh/eXB5kwBv4nWPHwoC/Pu///v8+3//71lbW2P//v383u/9HjfffPNF9/vzP/9z/v7f//u8853v5NOf/vQlnbNIhzCMAIseNr14G8dji6vCJk89FdCTNhcIOXU6T7q/Dt0eUXMcgUXzQZdgwkOW+zg7JPXn4fg5mJ5aZ33R4EBbQ672+Eo5pJ8vsLwtQW5bn/K6JDkH1nHJHQ9v52joUzXaJKM+M4zjJs+i3dqmeu3NytXTr4J/HseusL/Sxmk3OGSY/GUhw9uyXTIrkvRpaM4BQ/NRr6B6chNd6CUk9h7o6RCmIWsqFZudhWgMWmmXgSYRTo9ct42XcOgnc7SSJgPHRo5uA383WCW08Gtoy8uIC1V08yDCnIapX4BzN4CHkq3Nl6HZg0oJ9jdJ6BFSVPESE0g9D9YAylMQXAVyBnoLkDkGvS0Y/l8R632VUekZEPlqAhTFSvomWmpSqSdgogV7z0NpDfpVWH2MhLXMlpWQDV+nti0B3XnYmIJiHX3jIdqRpL71Tsi8R5FvPaJq2eSefYCRfI+JrZLKlhbt2e2cs+6jcOq/MdoUODoUJSSnVJ6y0QD7FBQXbRoTMbExoRyohXJE1ewm2U6X9vM2bjngdAjhHBSSkhu2xvRXY5w22GchlVtluZ3ghkKfb9TSbLx3gmB5hcbVO7F6PbJfbhN4EV3bJq5nEf4ysbAJd3QY00GbhyDUORWlME+FrO0TiEnYP6+UjskS5Fc0KgG4dMBwyYeC81+cIRtfw9X6n9CRFn15CxV8OkOznHI0Sgn3UjqAlRGQ+zK//6EYaTaxCQUZK8MrA4bGV0NnZmIMdJJk6ODgYzPAIUoMc35HbCg6kLNVXJArUAOgr6qtplCDbOiDbao+WSNAxQpJ1IMQq8oplqqOhsPXkQYD8a2sXTHM3wVFIPWh5DgaVkRJqD7ZQaxaZbxIyZNDofqP+5IXc4JN1H6WNhxPhzm/tq4IpmmosTYUyqk5FoBUfcXxUL6MVE6CVqwM/yRDA60hKY119Tn0IXEd/op4oAiyGQ/dpTXVqxNLYOgQbQtICMjYECTB6qr7F1nqvgq4IrS/FxtHYXMs3cRrhndeN8mHP3+cQ4tNTq932Dm2mQm8idcvXvOh9JOf/CT3338/DzzwALfccgsf/ehHue+++zh58iSjo6Pfdb/z58/zz/7ZP+Ouu+56VeeN6WBRY4CPRojPNgb2PMXZCyR6Giu1cQahxlrssrq4j0TxaTa0BM27FunYDhMP38zi+XlGJxcJDUHgO4zs8WhaG3gLNtcsBDw3HXDB6LP+xjL1bU2uPdFjKZmjetYifPQ0e+IONgF93aUlLDq5FbJTkjgPGDakZ9DCBmXRJRtC9wzcPBXxpB/ztZzNm4s+ngluR0XgnpmCugG5vFK4LZUg9mD7BsiWWuBfMWF5HNpuAqEl8bQc4JBd3wB9QD/n0kmU0MMqRucJZHsBGTcw5ABzPcazdPReFbm9hawdhfZ1ihliqomU2AkdD63314w22xh6heD8Mhv5Er71TlgbYAefxS3AQPggYoyShmv6tG0HkToAvVvUpNC0wUiBJVWOcJCAkRaM/y+IqipCgwaEfQInouEKRqyYyIxppa5W8UrBGcSIjSs1yNeJXBO8wzjn/4y43iTc6ZPU4VhmlNW9b1V9ed4yVlOiZ4fKxJ5SBXolVeAumDA27VGzUt/K7AQQCcy1KqPVmF7g4ukBQQKKhzTijCSdV1NlkYNwNySNmJmnuyTacHWjxpevvoranlmwYyY+/ixFx0O8McR7XkM/mqHaS7Frb4f2TbCuKzJuCWhHIxSPprCuX6K0XZKogyxAsA0m+m2CUy28eISsbmBUQe8ug/kpGlGaBkkuIHHQcIWkLlc47ISkAy6t0nCxysUVMHfdxOsEQlfKnFjgwDDxlyEJ9rCAHAVWcfBxCUgTp4GyDlNJGE1A3gVHgB2C3oVBTxlTJXTVJ+v5UHCUIVQ0UC6FkQnkFUHWY1UN9kLVX5u1VSXXCyE/JKmhByKpyKmdVGZXmg29ENBVf263q3p6+5Ey0PJ15YcQxdCJVRVYH5JLXVcVYRkr4u5KSIVDMy0DBgEQQNofEt5QkXwvgF572K88JMCRoxZpjaH/gtSH5zaVfFlEymla1yFqKdJrO2D2FAnOowyv/BAsE2wJaQEjSSWhvtBQrtd6Qjn9xyjSfrlHAL2SCvDmWLqJ1wgjaYe7d4/y4PF1/vLgEh9622Ym8CZev3jNCfBHPvIR3v/+9/PzP//zADzwwAN87nOf4+Mf/zi/9mu/9pL7xHHMe9/7Xn7zN3+TRx55hGazecnnTbNCgEmOeSoUGDE2uP76E+y9JcQegfNPLrL0UApzoOPLLtiSqeISuf0B53804PnG82Sf2kN4wcHV1injsHgwYvuMz8a4z74TsL8MLVmlWSoSbi/z7Nh+hDUB+wZ8zXuc0tmQqwaS/AWB0VphfYunPEgSPaKuDfYo0r2BMPdNVpM+9kAtvF9b6HNSwAUdMpNQ11TVd6wD8gAcsWaR/RLG4BTFdg9rQRVUgzQMckNVmz0CTgq6NfSOh14VyO4AyimCXe/GWPhrRtcXSHqLeC6sZQt4I1eBJohEB5xZOLZHmbvEQk147DaM1GE6ILHyN0z2fVbS0MxO4OfeDQtbIV0lym0hVXmOnpsmjktEJZ3k0iKuk6GfukvlQk6vQWUL9AwlETRMmBlA/lHoPAWtOtiW+l08IE4YRNMRTgxWzYT4auhdpSaQcwJPnEHWJsDy0Db+O7J2jJQVsDo2wXL6VqItt0LZxjz2EZz557BO6WR3xqyXDQrFmFod0l0Vi1R0QO6CoDx0QE2l1MRQT0C1hejHCL2P56o56uBxl+RVHv0piVGFiZ0w2AINE9ozKirz0FgKWV9Fs7LMnFjkwEaDlXdCfx0ye3u0th0n8XCRViPP3GKD7gkNZ02nEgWMpBcojkv6M5LJOiQKsOTD81/XGZuMmNozj/O1PCuN3Rx8cJRZKZjLn8Fr3YMrbuGwtsRKbh19UMF3LGSmjFfrKLb+SnGx+I4rJMZzEz/c0DBV3m8cqWIpOi4WNgIbjxwj2Ni0iIAcGgm6QPSC03EKyEplxBdWVXXzBVdnwwfZVW0jiTy01oB4mOZjqtYNI1ZGUJapiKwUwwptEdwY8h4Mssr/AQHpMXCK4PeGUmUHKKoqaTuGVQeaplr5ZCiz7gs1qHQdRbSjCHxPyalNlAlXLCGO1HEMTeX9TqVUdnFrUfUzawEMOpAApkegswEYECVUVVuLoO996/99T43JNqqyLYf3zBr2NgfDCrWIwOspgmuklTTaipWE2hqo9pa8DugQ6UoJFA6r0oamxtzL1RH6lcQgbY6lm3gN8e4D0zx4fJ1PP7vMr963B0O/3FelNnG54jUlwEEQ8Mwzz/ChD33oxfd0Xectb3kLjz/++Hfd77d+67cYHR3lF3/xF3nkkUde9hy+7+P7/ouv2+02AG9InuZw/3ry1JlgB9fMHGL/WzxyCQi3w4lP5Dk7mGYDSUFvcnMBZt/qs7wVDmWge2cd/9k+RpTD0C9wvdOiu0UyuQO87WoOsiuGcC3gaGedxVEDyQbphZPkzng4vR7b8wLvTrjg+eQ/7ZI+VUa7oULk5kBLKhfM8hupVh4ll3ia1HbIh+pz7B6oVjJRhulliFzFPdtf1Fm4a4b4DT+PeeJ/cEB8mdHtsLQEDU2lTniGgXRKKh6j1sEa9LCqIDSflP8Ivat/hLi8G7m+gq1FdCXI1CRsfTf0bWWyslCGIA9RXU3qDAnp8zD1NRLLT5O2llhLQM8v0Yl/FgIf1/lvlNbP0RADQldDxjaEA2SgWt6SYYO+/xzcugWeKkOloAxnHA1m+7D1IbSVzyLrVQgMFdYrHfWTEMjeOnoYoUcCPbuMKC+Btg+uAlFdh7NgdJ8l0zlHuh0wKDmEzjuRqbeD7KDV/oz0wiFkLyaa0JnfPUZt783U+08z3l4lV4cF12DmekHQkCzl8uCOq8pG2oaWwIhrJEoSvSVppdUc0poY4BXhbAdmZqE2ChVLzf+6O6AxotFdFGxdPUXyEY1bGzFL10F4DFa/nqKu2Yy/pUF4c5v44XFy32yj1SwWopA1O2R2V0z4NujvA/uCUpE/94zF/Olxkpkltr9fUrRbLP2PZXSRo806QcskLzaY5yAtAgLDh0QWI5Ak64uUPJ/zl/IwX6xysTlp28QPAbSh3FmX4oWuUjQMdHRMdEyUGVWIhkSRsAgQpq56aE2pKqGWBDlQBDgOhs7PoXrgjRSYLrwoq9Z40YDK1JSsWNMVobUstbinu0oi7MTg26pPVk+rnlxrWCkWlurljV2VldsRynm5q8PAUpVdKdTr3vDHGhJsOez1lRoMGMqxhxVjU1fEV+jqJ0S9ZwxJtT7cRreH0maTof5ZVbjlMK9XHzo/a7GSSjMk8fpwW31oYhUD+IrISgNkT22ra8N7qw0XPYcEenh4BMP7p6le4MsRr6QCvDmWbuI1xD17RikkLdbbPo+crnD37u+u1NzEJn6Y8ZoS4Gq1ShzHjI19e6bY2NgYJ06ceMl9Hn30Uf7oj/6I55577hWd48Mf/jC/+Zu/+R3vB3pAwlgiHeeZYpEdzgpGF/K3w5GjsHauRI9ldhX6JHZ4uA5kDqi5yP4WNOYFxtRhwp5Gm5DIs9E2bEZ+rMtpDVZzUNHhwHmYsSWfN2qsywqZ5wJyZ6Ek4SoJ8TJs+DB/o0/0mEk60kDLqkmRZcLYFF77PsLKEVIFD7sKXAA9D50+VCtK/rylAMeroD+rk0s9S326hNSWqYTKV6o7A1EaukmDgZsG7To1CTLPoHl9/Bb4HXDWapj9LxDdMIvb0xh0oFIEOVgH7yz4b4JkCvb2YeoInLRgbQSWC5A7T+7kF5h40sHZKqnMalTEPigUsby/ZF/tSZKxpJ0pURXjpHqLaFrIwANPl3jCUjrtyIZ6QcV6JDSYaKHNfo2x83/CwG/R7jvIlKVuQgSICppRwPKVH4t5KmZm+qtcuGkblIqgVyDr4+gPsnPtcRpBjFWW1LZtRXbvVFmc66vo7fOkliIaKYfVe+9BHngbBDvpcpiz3YdhPECGKeZTTbTMOaLMLpD5YVazBl6HtFxjdDtUDFUcyXVAXgOdLIycVvL0vq7mzLmqUlznlyX58S72Bdj3TZuD74JGX5L9us2iXyQTd8l93aDxowETk1XOJ0zknEflKYOkFWPvhOpViof3JyGMoDgSEZSrFIuS1CK4E4KxUoNKtUyRHo7I06FDg5CAQEk0nQDdj5n0WoymFjnfe6VPMqoylnyZ3+uXcKxNbOIHBJP4xX7fGIlADrt+XWxsBDoCnRhn6BIdE2EoifKIqZzmdXOYfTsA0VPPTqqn5NAiVJVVX0AipV6LCCJDEURXB4SqypoZyDhqnOslUBVcR5FAQ1Pjm5FG9fGOQViAoAidENrARgTVWBlf+aZadfVQY1HXh1ZPkSnHhkxeVVpFBPUY3BCSkXKO1iwoGCpHzwxAc8BMKol0QoOoB60+xIWhm3OgzAiFAXakqsxI9VmIlKOzPawKx+HQuEqDhKPaZfqhGivCCPoDCCqqh1kmIJlXbSXx0rCnOoJ0DIPhsUx96Ap9mZaALzaOwmU3loZhyFvf+lYeeOABdu7c+VpfziYuAttUmcB/8th5/vKZpU0CvInXLV5zCfSloNPp8LM/+7P84R/+ISMjI69onw996EPcf//9L75ut9vMzMywqAsMemTRKJClInR27QBvBnpPQUdquHrI3BYPraQW0UVbOSmXH9aoP5ijNN6iHTiExQi/KFk8O43+v87h3B7gZKCfBG0Kkmfg7i97fOlqi8SkRpCF5+MR1gYhhvTZ/viA9IZEn+pxwi4R5vZBvwFOWZmojN/BWv6zjMlDZGKITkN1EhZqED0PC5Pg5FQEzolpcPWAnZUvkdYDCp5KDVoc1ekkNTyjiDR0CCvQHSGx0ibqhLSKgKkx0EBoA9z185QqIf0eZD2I3Qr9zpeI90ypnrXl57C+8gRhcTtk3gHmLKxN0RM7aDtnGEsL3AiSlUP0kxFhYZxT+d2IWob+yr3o5afI6/N0NZPYnkWbX0XLGbCwHc5sAy8FhQRYTbSJLzJ+7r8wttbiQhEScUBfFjGadTS9jzQ0st4ynUgjL2BqAO1BDA1D5QLnatB+FGv5OfIHJUslm7W8IGZW5U6mDTAPIlqnWC3YiLmr4MZfhKUydIHCjyKdO8CqgxkQJ/pgfxFkCWQG2hJ6LQi6xGlBDTU3nD4JVVMVsMe6Kh55JA+NuioYN59WRfiUA+4O6M1Dfzbg7HVTmJWYma11ti30MIMAEebIFeqYP9JnyVVz6eIgxrDAuwrSPdU6uDABkQdbfkKy5+4BGRO0xyDuwvXZPp32BULNAymResSk53GjppPsTOF3IqQeMWvV0NIRXAoBvljl4jKdr27i9QULHR2NiAgDGx0bJYy2cEmSpYBNmgAYIPD0CFKDYauFo8alaEjC9GG/quUqoqZLtXCpSRC+qqbqqWFPbE9VZ2MN9IyqyIahGt+FgJ6PivpxlIEWuqr+xhl1jMgFkQESUBlAS6jxzZPgS+W23EKRXy2tqoS2UKtwHsoMIhmr9yKhXKR1B3qaMu6yNHV9aRsKW6FoQ0IqQ0LTU5FEvaoyxBJJwFIVWtsFr6Y8GwRgG4pwR6jKsDlsWI0l9LwhiY1UBZ0YrAjKBVWVDgfQidS9zWTAj9Q+hqYWg11dnSeOuGwHlFdSAb7MPrplWRw+fPi1voxNXALefWCaP3nsPF8+tk6rH5JLXiy8ehOb+OHDa0qAR0ZGMAyD9fX1b3t/fX2d8fHx79j+7NmznD9/nre//e0vvieGLpmmaXLy5Em2b9/+bfs4joPjON9xrJbnkIgn6dBBo8tEziNnwMBRDspFq816HLK8DKPrkLtdzTNyEVQOmohugZWzEBoGhS0e6ZmQC91lTp7NsueOKn4Pbvcg6cNyB/pfhe3Ph9Tuhvr0OM0dd9AMVfxDYD7NdX8V0Tyl4x/QIWUrN87EcGITW7Qn7+X5jZNU8djZg9J56GjKTHm6DNUMbD0Nd4cRcQBWO2JlwuaEyNCxBV3bRToGOA74acj00eZPYscx0gXTMPB3bME5X0XLxuwMOjgVZe6sl0x6roHe2iBuH0Zrn8BsnsAMc4Qb06DPqQni2hTRnptZydr0++vsO75Cpx0wSJ5FZst0J34MrdQlvXiIkZUnMKqS6i4DRq5BOGNktWdoLi1A3QcrD/kGXP9Nyq0/oNSp4WpQiGDRTkM6jxh4GAhShkAInV55nLODBrOTA+SEjoaDnNeheAan+TjCiqmmTUa7ITkvZi0+jX/1c7ByAJwIefUYMl2C9NvhTArMNRgdQH0eEmmwfZBN6NhoUYAUdRUV4luqfy2I6WfyxLpq70t3ILOi5rrOGCSuVfM8dw2aAxg0wA9Am4bkCmQG0N0GvbE8zBbQ9ce5o18nvKBRjwZ0ZqHZUPHJ1V1wnaXmu5YLExKmfVjrgaeBmYJyThVztCWgDU5ZkAlrNHoQnYJBHcr9VbLjUOo36DZcNGFiFPo0L/X7zBr+vNzvN7GJ1xgq/5dh+q+BiTmUReuYmCRIYeAgkIRAqEtwfNW/K0xVyRXGUE5sKoMpQ1dxR2jKuE9DVX6lBpiKKGu+ytCVmqrySlsRuRfITCCUHFizlPxZ01UbTJxU/yWhHvzQhJZUBLinKXIbCFVV7WnQNVQfrtCUwseLFMnWwyExl4p86qb66Uv1GTQBSaGIpp5RxNYRKr7OSCh5t+yqGCZMtbCoSyUJ13qq6hsPZdUmQ8OvoUzZGF6LH6oKsjWMfhKhGj+dYXZbwldmXpoGKVflAmuo1/rQrTrgW87YlyMuNo7yCn7/OsTP/MzP8Ed/9Ef823/7b1/rS9nEK8BVk1l2j2U4ud7hs8+v8N5b5l7rS9rEJi4ZrykBtm2bAwcO8NBDD/ETP/ETgCK0Dz30EB/4wAe+Y/s9e/bw/PPPf9t7//Jf/ks6nQ7/8T/+R2ZmZl7xuU/GKW5mBEGOJjodvwpTHTQbClfBLT+2zvJZiEowepMqcK6WoLsA/UbImLvKBd9mLNtGRNDvaMS+g9/OEM5XqY2DvwFj5yDugTEHU2uwetCm9ub9WCePsX35JEI65LsBg6sl5fmYXedqVM98HTmVgDCrVuD7CViMcI/EVJegN6IzNmlQ9kMGKWWoZERQOQMLI2katkUi1aFy7Y8hB28C8wxknx5OzPqAA7mt2PbXcGoSP2niOsD0Fry5HaTWn8J9rstGG6wydJsuyapPfyvQPIXjncI5Z9Aq/BNYv12t4tdDGD1Jyv8q7kqb+sTdXPAeo+Cukruwwar2VRJ7v8mo12RC86lXYSW0CdL74dxuROtHafqTcE0b3CYEBbh9HabXGDwVku2rIkRmREVuhnqMJCafFkQB6EhycZ1OxsTaAbOWRz3+NM1bdkHSwa9nyaabnL3FItLLTPkr7Gmd5bz2AK3wZ6B1LzhzcFUEWh4SB9Haj1B69CCRD97uCeIRF/PcIs6Gy1S0QiudZmnvzSD2w6hyag0TM9R6BqNWTHQAkieh/nyaTujz1BbwZhO8wW9jViC7BSoJqJyC3DmN8WmJMDW0eECYnOEb1+7mRHUB9msEjoHba/HmUxLDgtRemD4EaxkVmxn40NbVvDXRBXcd/OQwVjQJYzcoqb2RVsavyZOQPQL9DTAnYTzTJxn0GbShuQyd5Ut8mFPDn++GTZ+MTfwQwCcENAJMMhgk0YnQEHj4xJhMk8DERtAggSFNVZmMU4q0mkMiZluwUVGDUt5QubZODPk8hAFEoZJB6wPlAu1ZYCQh6UA7VIZQZp4Xs4KMnDJCEDpYE4p06qnhrzVFKJsB1ANo2kO5cwxNoGtBLweDvlpR69oqTqkXDk2pYjBDpWbRUAZTKUvJmI0WND1gAOa46gkOWkpCndUhlx6Se119JtkHY6Aqycawom2VwSgBHmhtiBuqEhwFyqXaGj78hoR0pKTXbaG8I9KaWtWLTChbap8oVnKWjgFNYyghF8r3QUZc1k2wFxtH4bIcS6Mo4uMf/zgPPvggBw4cIJX69pvwkY985DW6sk28FDRN490Hpvk3nz/OXz6ztEmAN/G6xGsugb7//vt53/vex4033sjNN9/MRz/6UXq93ouu0D/3cz/H1NQUH/7wh3Fdl6uvvvrb9s/n8wDf8f7FEIkSJlme5SwjjHJgZ4yzQy3wy+shm4HOGQgOwHETnA6IhyH6G53UcQuZ8BjPepSvhWYdWs/myXX2MT73FIkuBEegGoHbVtW9LW+As1th5yBiZaFN+kKTma/AxFsGHE0afHVHivKaz/6vbGfcfozVn98OhZvBaoMtsJ59ivighowMVnZcx8K9d5A4+RDFwQmahka2F9Gfc2jdtgutFSG940iRB+daENfC4EZwz4FcGmZZ7iRKn8CfWUYEAV5ToteP4iZMrm82YACJPbDYhkmtS5cMkZiAsIYcCIKlCRjcomR46aHEb1pHO9+B+gC5TWPt1gnGFzaI0hoy72MOBvjHY44v6biOoGnuQDvyy5jNSUI7C9EuuLAKg3EoBJC3IJvGLxSJs216BWgldMQgwgwbRKki3chB5iPiRJKJ1gqeMDGykI9gKrxAMzoEiVk0o0RJbzAwAmpjA5y+oLQMyAZHjAqxOaUcSL1noT8P/fNoCwexN5qMLUDK36BRBLcB6XMO6bU0/WsiGIlgVFcTW0IkKbpFlegx4ai5atQYMJoSHHcKdAolIr+N60FdgJtWUZdC12hPS1I1yVVnFjicKRDa21nbWwazi1NbZd9Gi1IeqmWYW4HFZw3cgSTjCZI7YUnASAyJGnjzwzm1DuU55Y+TyEC9D2EGzO1QLIGzrpJV9I4qZJm66gX3zlzig3wx6V54icfbxCZ+INDQ0FCaIIFA4GBgIIEIGxsLBw2HCEEoJYi0MoCyDGWEpQ0JrM3QlVgMpRbDPN4oULb7ujGUOMeq2gpDZ3VDPWiurR5QXwfPhNiE2FK54qZU0UWhrqqe1QA6Uple9XRVuW3HEDiqIi2kak3pR0ru7A/3k+bQiypQcm1zaCAVRKry20B9pqSlSLU1NDSMA2Wm5SQATcmb3YK6xmDo4qzHqleYoWO0jJSRleko0q8Brqm2E8MIJfThZ+yp+2O5wFAGHhmAPaxIR0PpswFOUkmnB+HQ6OsyJsCvRAJ9GY6lR44c4YYbbgDg1KlT3/Y7TbsMGf9lgHdeP8m//eIJnl1ocrbSZXs5/Vpf0iY2cUl4VQTY8zx+7/d+j4cffpiNjY0XZcgv4ODBg6/4WO95z3uoVCr8xm/8Bmtra1x33XV88YtffNEYa2FhAV3//rs+ZGUWixbjJMhjoDsxXaD+PFRGoXsV1PdArwddCZ1vwtk/msBo21yPh++1KY56pPISZwRMq03q/POk3jHg6Dp0H7HZ4WuU7vFJ7oVBCdKLkM8Kbjj0NG0Zk62ZLB4LOf2uLMbXBfLZAsvRGJNP1Ni484TqNU3lYSCJdu1GHnqW1uhuone8H0a3MtD2s1z5CvTPEuhr6P4GDOrI7BjdUlZNMGpSrcYP9oO9E9w+zKgKRTz9HlraCDMHP0c/rZO2alzfDBkYsL4VfAO6eQPDy9PYex+SCjgB8aqB1tPU5KynKUdSw4X13fTcq+jlTSjsIp5ZYvmqXTBIQZTGa66zzTmO5mjUckWC+t/D6u3AjVxkJIl0AxZmwMkoQ5luCxoGkZXmeLqI55YJlmZAdtkxeJI1W6c7dickR3B6jzLmL7Mn7pKegvoSCBFD1AZxDTJ9DaY7T7kfk+pU8FPQSEFLJomL1yupefIIDBbAC9DXn0H2unjjqs13YRRyfch5sKqHtMo9Lux7F5R2Q85QkzJNIsMZZCpBZq3LhAmtLJx8q+TERo7BiM4N1QtMDqA9Dk4DxBJksyB2Cx57k8vouZidnwvxxRFOXtuHKEKLmsxsVLn+OYk3DmfLMPYkbLQNXD9D8nFBMNlgUIStSxC2IMzB4hnIJKG4V/FzKwLDU0rIcEm1GIrhHDQrVCt0axnq0aswWd0kwN+B7+c4uYnvF1QPsDO0FY6JSWNgEqMhcLCxcBG4BMQE6CCKYFhgD92SCcD3VeavbihZr+EoshvEqoc3HgzJXazIpJFU1dwBw75hS/XK9m1VHfaEWgmLE+oBtSJVtR3Yaoxd8If9vkDPUv35jViRSWkqN+Yghn6s3KkDW/1OGBBIRYYzwxWuMFSSaIA+kDEhpUFPKhKvAe1AGWCNF4bkNIZSQY35gy5ETUVUk0NjLM0D6at9zQQEA0BCwlQLALFULtfSgkCHsA2WrXLiaCsCH74gL5fqXhrDarubUpnIyvGQyzoI9wolwA8//PBrfQmbuESMZlzeuKvMV09s8KlnlvjVt+55rS9pE5u4JLwqAvyLv/iLfPnLX+bd7343N9988/e8QveBD3zgJSXPAF/72tdedt8/+ZM/eVXndPU6iBqOJqm4HaxrfOZ70PwacBXEW1VEoqaBvQKVv06y3B0nSZ8lNBw9ZMTxqJ4E7WrwbooZu63BmQxEf1VgfXkvPj7tZ55n9B8G9LbA6AZUnoCrCiGrBpizAcvrWdqJmxnvPYLllRigMd4uYF5YJ76uB4ELORN5349TnZ2A3A4ozSn3zPwsZP4RrMwTOhXgKJg18E4PJ08BWB4EWcCEmqsmcUcFZAcg5rC0MhOxxnOFOebiFTQ35JimI/ICvQJxNkVt/N3gXgv9o2BncMPP4Sb6eGYTGFWTOGI4vgOsf4rEhRN9JW/bGULagbaBSFSZL08gvxGiH78PN7wNSUQAQAItcJBWR03mnFBVGaSFSF5DO7gPVmZhMQ1Tz1HNn2L74jqnxk8zENtIRH2yA7BTcDC2WU3oEI2CW1LyxdS99O2/oaM3MByJEUlq89BzbZjSoTgP0RdhowcDA9kcYHkxdl8tBNhdSNdVYUIr6iwk9yJyb1aaY9uHQQypGIyd1Js7mNafo3UcCuuQ3wXNhOCmw3V2VARyVkWI6gnVbjd4HmrbbDZGr0JwjtzzDcofC0htP0V/TJBKQWpexx+NeXKvjqEJ4jMQOILYdyiaLZI6jCYU3/cC1d8br4F1A0RJ8Dw1L3Zi8Nchdw68gZoPiymV2iIc0MdUYUouAdVLeKAull8ZvIqH9HWO7/c4uYlXDw0dA4MICZjopBk6L2HQJU2GHFk0InQEFg4ROoHUFZmzpZKmdjvKIMpJgjUGegvMxWFkjwaJpOJpfqiqsMawL9h8IXRJqj5fHGXAZ+Ugl4N+AJEGAwNyDqDDgqYIbRCpgc2TStq85Cs5MBnV19D3VXRSlAEnDeuecmq2ItASSqbsmeqatOF16I4i9ZPxsEIcq+NnYpiIlKon0uG5JhRM9bMRq0q4Nq56gM1QrazFA2X6FQ3JdiiGLtGmun5DqOqwP/hWDJR0lalG0ARhq5xkw0Ax/AiygXK6ds2h7FpAOqEq6GGgVqa51FW61wFeSQ7wZT6WLi0tATA9Pf0aX8kmLoZ3H5jmqyc2+KuDy/zTH9m9mQm8idcVXhUB/uxnP8vnP/957rjjju/39fydoS9cmmSZ0EzueNtBttyqDCgbSxqdz1jsfVfA4lUg9sLkk3Dy4Bi9dJqo08ajSiEXwJikdULH3iaQW+HrM6r9ausun6jSJak3MMsx9TE4jEZqq85YLNA3JMZDBQhhctzjrJ2mdut1ZI4dYnw+ixcIgs4kBCaMDh1Fs2XI3oN25s+RvcOQuhOqUk2s4jFoNMEYgfw0BDWYPw+to7DlLDRn1aRERCpGozrsyyr0idfOcCw5juZALu7zbM6hQxFNDtDoIxPjkEtBvgX2JFhFgq4G6TZoR2D+rWgywvA0hNbD9RJIrUhwLkHcvAnaVRh9DOvMU4RjW4jXfgzz9Ba0IEughSAlGoIo0UMPLfANpCuV2+hyF+o9mN8H81vAy8CWVSjbtMrTXBBt5qJjnA0zNPP38rz3aYrpGgvZLchwKwR3gF+GTgfO7GHdvRlpfZV8FLFlMWZh2aB+412QGYXJC9gn1nCXN2hbebBMZDqiowmydZj04HxVFSkqk1cTX/3LkJ1Wsr5+oOJE8g5YCbr13fTOHKL9jET4cMtxici3qXRgLaHmvO0OZLrQaikvmcOFfRiGy22HWsTboJOWGE8blJ9NERsx58dDTr0VvBGdH/mcQDwD+UAjXaiz5YDHxmGT5kMpwnSPcBBhV4BRyN8KiWkwTRUjGsVqTh7WVApJN1DzbTOvWvNaPnRqMHqxPrS/jfTwZxMv4nIYJy8faKjqrxjGykq+RUn1oQ2WjjW0yQrRiNERmqkkvdIaGmCZqK9NCwhUf6ymD3tThXpPDqOPhD38vTHM0LWH2w4fRj0JOOq1oQ8PqyniGeuKn3ciVR3WpSJ/njYkmS/k+IaKuPZtZRQlNVVtjaUywtIjFcXrawhDU7fBMNVAhqFWywxUDnFSB4eh7FpT5xxEkNQU4Q6F2tYZ9jMTqDgnbVgJl/owX3hITDVdnUMOpxmGp17H+re2FUK9Ftow9sgAS0d9WH2YE6yrv5Qeqs8sUSt3sRie7zLCFTqOCiH41//6X/O7v/u7dLtdADKZDP/0n/5Tfv3Xf/0HogLcxPeON+8dJZewWGt7fONMlTfsKr/Wl7SJTbxivCoCPDU1RSaT+X5fy98pfiy/hCGz5Pe1ecMv9Vk1IB+C2NA5czLH8n9IEt+4Rvpf+YwGEMcdYs3H14vozgXcjoVY1sltF9SfhcESZN8MpVXYsqvPYNdhxhxFdg49rOE2YfXtBS78H9cysnSQLU8aFFdTTK722PWphznxsz9D44Oz+J/5GlOPNZFmGcRJiK5SWYuyBPPPMlH57/S6Nq3kUzD3YxDvg94aZv2PSTTP0F/MECcc7FMaqfIhmu4fI7feA2u7wS4ot9DIhYIG/UMILUX3hluZmP8yy32dzvMGlu8RjhaQWgD5MchpYKyo5tF2RKa9hHC6sP5NsN+M4bkYUiIBL99CFlvIZhL8AtQ/i7v6STJ2l/rxHvHym4jCAqYZItAxhCS2Q/TYQoxVIRAYrSTCX0LOnINsDXp7INGCLachKSEDsnoAt3AWNnpY5hFCbS/VHffSbX8Jmbge9DdDNaccStNpWLGJxt+JMXqMTm0BPwWJt+SR19wOYhXL+2tm61XoCJKiTmskiW8k0BM9vDFoayoKM5ME3SkRZ2fU05MwoL0OpZQqtWZ0wtK1LPifYbQRQj4imZG05mDEV4WOhoAg0IimJMl56EzoBNtHmDt0jPKDGrWiQeIfxTx1n4a75jOQOpl9AdWpLDf/rw65b0CUAD8fkopDqhc0qqdupRPtI6ufwp15BHMuZmS/cphet2GkqQzAA0cVrTUB1iiYFWWMZZQUGQgakGqBXr/EB+pilYvL0Ln0YrgcxsnLCRo6FhITiYZPRDxM+nWJMYgRJLGIMGkAATqxbkOypAhnVwMto0iZ0EF0hoZELsjeMPPXU34IIoA4rYiaMaz0CksZY0WWqsCmS8rV2QfshCKXtoCaUJVeX4dWAN1QVUw9Xdm+C6mIZziAYNjv20ERR11TpDIYklgnRJNgBhqRayBsQxHYvqn26zWU7DosQMlDSbZN5R4tI2VmEEollRaxyijWACuliG2vouTTtjO8P3KYFTx0sjYSKtddRpAIVbtMYP5vCwZS3YNIqHvolpUUJewrkh5b6rUYulAHQ3LvGqqCHF5mBPiVVIAvw7H013/91190gX5hwfDRRx/lX/2rf4Xnefybf/NvXuMr3MRLwTEN3rF/kk88cYFPHVzaJMCbeF3hVRHg3/3d3+Wf//N/zgMPPMDc3OvT/e1tP9qG8Ta5PWqekBDQflpj8JxJMVNHH4TomUh9Xw8gHbsYhkZRhJiBjh7lIKqoxfYIjOcTbFkN6Qw0NuIs9qyHNhOjWR7Rl7aQiDxKi01WPjJOJXM3hvklBAUGKcHYow2cI/+VE//oDSQm8rg3dODA3VDNq17Y8ZSaHBWnqXb2M9J5DPOZx+h1q3jlD2KtfApn7QRyQZAZ2UDP6kxUBb4G3tMnidY3iHbcjky/HRIWhC5YDdD7kL8VM/EYI5UOtfOS1HqfHH1qQZf+9pSSmwVryhXUymAufo1wAO2ZG0A0oOEj2pLYsdBSffQd/4Ox2tdZS/0Uce89aL3zGFqXwSo4dpN+SofRJaKpBjRGiBbGMNoacuxptL1/hVzdj6gcQE6fg/Lj4C3C6CpkNUg1ILsX2mnwthIYOXy/h13vMXCayPaPM5gahfVpWLXg9gtqMvdsRpnSVPYQT/1DRPFjnNX7RBNXQcnHPPsgM+eeRS7GNJMqDWR70KfhQHMSWg1wPNCzDrXibsLSbcPGWRP6bXTv00gcJFvBayHyPZ685VpuOnmIXWMRg11K8pxJgF4GKmDVTar1iOkpycpUAim67FutEGdisjvBbEOiCLVrJ9AcF804zdiZDrnPJFlZzKHZbVZim5Zmcu0tGwSFCqmqR5k84ZhG4h3QLEBzHUqPQiIC842QM9Wf1DXUHDiRVd43yZ5qIQx86PRgS/cSH6iL9a5dbFJ3GeJyGCcvG2gCoftEMchhFJKDhYWJRgjYSDR6QxG0h46BiSVM1aPb66rFw1waEFCJYaQPib6SAkdy2KPbVwTZSELUUItig7wid0YKkmUldQ4NWOtDrqAk0JGh5MK1UJFZT0IjUrJmNOjoSsosdUWsPal6gENTkU3bA89XX2aRrq7R8tBCB11KIEAGDnpokPMCgljgS5OonVTH0AL1mTxN9Q+7HiQCsIYLONowwsgAbHNI7AEtB1pNEX4xrM6iqUVbA7CyIDeUKVaoFDI4NtS6qlptmEqqjQHhCPiu6jnJjqje5CTD+yjUAoIGEKsv5fgyI7/wynqAL8Ox9E//9E/5z//5P/OOd7zjxfeuvfZapqam+OVf/uVNAvxDjHcfmOYTT1zgi0fWaHshWfcyXKHZxGWJV0WAb7zxRjzPY9u2bSSTSSzr2//B1+uXWj76u0dTH7bTTkErhmQdnvzvOqNTgkIqxoqbBPfCmRE4pcOE6HD1oE6CMmGUIUDSHEj8FvRd8ESM0ROIUP//2fvzeNuuu7oT/c7V7r47fX9u36jvJVuWjDuMDQYCxuUQTPJJkQAFyYtxPs+EKhK/OJACys8v4IeTVx8XVVQAG+yYBNuysS136nvp9v059/TN7vfq15zvj7muFGOwfIXMla7O0Gfr3rP3OmvPte9Z88wxf+M3BoM0xFmFcKlA8cYAWR7Q7xv0dzuQMxHNPsWeQoge7ZzF9psSdj3V5KZ//0WmZMKTt9fA3Q1mQ+/2d7u6j9auE1k/jlc5z7XjKxz3l4nO/AGTR48wuRwTNeG8MohTi8q6ZHkT6sN9XCdgcUqR2lkPcH0A+R6cvgZGJYXWUdrLiiSGKGfg+wohBUaiEO1TpCpBbCxDcAaztYWRhHqBI6YgBGFGyHwOKuvURh/j1pU1HjI+y8aBYdToLGq5TKURsLVxN4y2MfZ9Ejl/C2xJqJWwvukSTT7KyNb9JCuP0bzVg70Szp2m8twGteoFLrozqOoweMNg3gRxTCu8F1n4HIltobZugs1DEI2CcQFufgK8h/Sic/9d8MxdQB3WfwC16wR+7his3wGLPSbNo1TOJjw3kqdgevRzBuuyTr7Xo+ZGmIaWK5/ddTNy/3shdTPTlwqoLhPdB6h/dYvVcQs1BoNdOYK5d3HqrQNmkiOsj+uEkXwEgwiWHCi9ISb3NMhZWB9LGTtylFock1a1T5kXwC4vpNK+yMwiqELKxVEgNvBkiVNBlSEGVGe3qL8eRm8/yfHzF/AsRWMoodQH61lBuqRQK+BfDxwFfxSIdWtdPADhaZ8ZGwjb4HQ0GbYud5H1fcgB/tjHPsZv//Zvs7a2xg033MDv/u7vcvvtt1/+ia4QroZ58uqBysyMtROxQmXZv2Ym2NVdwhGCBEGKicLQJhBmnFU0hSZ1ZFVIU+reXzOryiqlewyMTPZ8yd04VTpCSKRahpEqTWRjkcmBs4pyoiAUmsSGEnylLdqVCXGqzY8SMrdolaUBZRm+IssYTsXzGcCCFEMpDKWr3kgt/jbSFIGp/bADG2UaL1R5BZpgxdm5Qlu7S4cZoc2JTNIttAmWFC94UwkDLVu+JH0WL8Q4ZVsOCEtLtZ+XTNuZ6ZXQf0+z81mO7lEWpj5eXDpvRrKzduqrDt+nHOBX+lzabDY5ePA7TZQOHjy4M0++wnH9dJV9oyVOb/T53LOrvPf22Ss9pB3s4HvCSyLA733ve1leXuY3fuM3GBsbe1Wau3g5mK1qLtNOQJ2FopGSNFLMXVDeBSf3aBPOVgNKDkyFKQKDPnNs2hvMXyOp7oXtBdhetaHbIMmv4RJQGEuxxgfUSnDPezf5VrfIyo/eC5aLcitElkvvxnW841Vm2xGlmyTmfYLmiCKtDGD9WThwt1439I7D2acgisC8jq57HSeHA6K1AfNnHqZoKNJ5bao5UpScsQ1CQ2GOCZZedxAxeYh0/CfAqsBkB3o2PDamS4H7zlE72abU1R5ZtaokKNkEY1AedLEsQat5nILwUO0NkqJJZ2gMXAWLr4PAJM0lQIiqdhjrrbIZwVBuiW3n46T5Gt7UAYK1OVQ4w5zxMTbyEt8rw9gQnOqj3AJWvMCwSlgY7lA+9Sf0G3MUNrao9UKKm3lK9Q16Y0OwOqc1vH0Htf2TtOO9sCuAYAZqG7Blwq15EMeoLD3NIBxGjmyiKn1IfgbWPahOkDvxeYLKN0BUccwBbatIOj5D1FxBFQKi6gQjqyG57Yi6BfmBgXT7OGf+P1QutGkP30ty69vA2qDVnmHfwjriSEz+WjhehNB4mM3pCosbBofPSswZOOZC29Lr4OExsKfBnABZDDhwPsCYAMa0F4xvwFoI4ydT1J+75B2L2btDWvf2KIcR5abL2LzH/BsTehV4sAKbbw2Z8iAfwlO/78IDU+wdXqBwY4q9C8KzEDW1IZZXgigGtrSCoV8C1Ya1FhQ96LqXeUMV+e69a5dp3PrJT36S97///Xz84x/njjvu4KMf/Sg/+IM/yMmTJxkdHb3MwV0ZXA3z5NUCQ5lYiUVC9DzhVRikmEQ4WOQpUqSHgcLExCbAxLdTGF+FiTEYqWpjpjIwAgznMzIiIRfqP1Mrk1KkoKqAoaurianjgEQWeRQ5MDKi+3yXehAUtaTXVlkPcdb3GypNfKUL7RC2AhBFTQpHcjpD14t0Rdm0NEH1UgypMJWBIMLBpEqRNDMBayIBG0ER4YdgGKiCCYNMmpzvQ5oDVdJqoSCEfqqdq21DZ/ZaSuf4dpu63xkXSuUs7kno74sGMFjSDntmURtmhX39KLhapu1nsUiphMjL5NCmfi2IdQ9ypag/W6+v/TBkqony1YgXm0fhqpxLb7jhBn7v936P//Af/sO3Pf97v/d73HDDDVdoVDv4XiCE4Cdumebff+EEf/bE0g4B3sGrBi+JAD/44IM89NBDr+qJKTXhuS8LNhdsijlFdSzhudMTJIFgV2GV+K2SjRkdPdi4A+I7I8IH60QxKEq41SPUG3C2a3HhyWGckU1YruGEZdoywj8PU05Cfgzar1O0G8NQHoGuB4U8zXlFuJKj79gkvs2biiEbP+xxIQCpEgrN/4bXPAidJs65/x9yeQ3LgLL7JZLYoVvIs7vdJk4U7UBgG4oCUB8xSYfnWGssEo0MI697J6STUOpAzocz3wQ1CetvhAMW5A2iyKVR7rFVNNmamEcOTMbTcyQthRpXVD2PioR1kSMqFVG1veDNQTit5XBSwiBF2GvIixHbNkjPIn9ygGz08XI/hcwXGZv7UyZqG6xGVa3B7dpw3iW6bQF7vE/5SYVTEIxubNN+toVZlBQFRHZMYk3D4ttg4gwcPAYrd8ATBYjfCss9cEO4YQNqDphHoHuGki+Y7myyGW7QcyFQt0Iyj2huYi31KUSP4+6Baj7FF2BEJlFuDOWOgBxlw+rDRIG25ZGzPez+WcZWPcqnQHrfpHm9Cd0lvOnbecroUgjOIAsJXmRRFRfYEyZM9CT+JqimNljduF47P4cCGjVop2D1dZxw7MHmMZNQwdB8yt7dUF6G1laVTdvgVtZ44hBUjZBrvJD5w3BxEVYfgaIC6ymY2g3e4wbbDw9jyTZJQ2HcCv1JEOvaHDZ1YNAAxwG/CnQhqkM6B8OBdojuLwHnL+OGepkl0B/5yEf4uZ/7uefzwD/+8Y/zuc99jk984hN88IMfvLyTXSFcDfPk1QKFRJJktPeSCVZKSoJBkvUC25RwiZA0aSOoY0kHwryuwhoKVJbzG4bgW9oUy0l0n6tUmpwlqa4G27kXwrVFVr2MwucrsZimft1AV0ZVquXRpqHNDRMPDFsT2yDVFWIhdH8uWWU0zUy1DBN8oaXRSqGUhcSmQISNicIBAgxSKhQIcQgBsPW4Iwmu0JVfX+lduhhNQC2pq9wlR5tkCTK5s4LQ0kTYSGAQviCTTiJ9vUblBVMuQr0J4BoZGc4q6qap37Nn6spvLiPz5iDLLY51dFOQbQyIS+aPXH1V4O+DBPrVMJf+1m/9Fu985zv58pe/zF133QXAQw89xMWLF/n85z9/hUe3gxfDj980xW/dd4InFlqc3xow18hf6SHtYAcvipdEgA8ePIjv+y/3WP5O0dqAU/fN0w1MElIiy2QrmaJjrHDN18e5/o0rxAf1hrdfhfI/8+ld+zRjf1li/VyNkaGYtAniWIXphk931IAlm+lyykY+pr9L4t9t0NotOJO3aeZnoXMSKMDQPOqGIo1nU5LxHvU45qyA7ZksfuY87NpY4ET0n0grY6T+OPn+OuGQib08YHbRo+53cA4o4giMrmLOgvZueGAmD4f3sepch6ruAvuQLnFvXMCIHmK4/RAdf4hQbEP/RyGISVWCNQZpkCdlLznvcYaThIEJS4ZuA+tGFlF1Ujs090/AqRoEY3oxVs6cScs+xnkHM7DJ5Qb0uor1Z38QRvfB2B/QVFsMIkFilMDYBds1vQjaG6JyDvawYHpD4gxBq+iyPWXQHq8QbN6LXLkRdj0Bxv3Qq8LYs7DvEFx8o16Ijj6BkX4e5e7V45NN2kWXYjig6wuS4gbsWYLtWZR7LYPde6geXSJIJliqBBxwVhleOEasHFqzB6FoERcL0JigbbTY7Z2gccGjIWDxBovOjAOFGCpvA38XHXeYzuhfkucxhmUPN4AxE6YqOmI4XYdiE2a6cOF1cLEAVR+SAdyUg0YRLn7LpHW+QiQKGPevcm7YpDYjmbx+i3ZR8ZXbdFbvxDwY5wSrjxm0ohTzWSi0LcrpKOb0Fp2tCtOxw9TsOkPvkpw+CNUUZibBqYJdg3gD1NNQaAjSOUVzTJvWlgwoFqB15DJvKDPVj+/2OtDtdr/tadd1cd1vLzdHUcQTTzzBr/7qrz7/nGEYvOUtb+Ghhx66zIFdOVwN8+TVApUR3kykm6UA6/8MFCCQWOSwSYCAAVDBUCIjtwBJ5lwcQRpAWNYk1EVXRVOlK8CZBBk7c2YWZBJetIpHZj/vhpGR4Iz0CqUJrZFmZPtS4KvQEmiZEeBYalmxcclB2QQyi/fwkjOyQGFjkWBikGJk3c0JBcpITF1YxtCkMpa6qpoKTXzTVF9zmOiqtCWyXolMfywVoLLKdiYVDxM9djMbu6F0z2+c6spy4uvKsS10PrCZGXbJTIKtjKz3wtKVZNPW/1hpqk2/kkvviz63VFcfAX6xefTSMVxdc+m9997LqVOn+NjHPsaJEycA+Ht/7+/xi7/4i0xOTl7h0e3gxTBWyXHP/hG+dnKTTz+xxPvfuu9KD2kHO3hRvCRv+X//7/89v/Irv8LXvvY1tre36Xa73/Z4NWC9A2diD2Gt0xF9BnGVTbfPdsnhwsDl6w8BAWy3dMzh+THovDNl4p90sMY2qVUFtTdD7U0tjLs7tM/Wiea7PP7zCcc/PMnpfzXFM3//Tr563Z0s5aqQLGMsHmP4aw+SO/4M4e0zmBNt7t4MuWFDsjliEQcCZxVyj5boP2kw8eDTmJ5Heu+vYkxcz/C6Ry8yCJbzDJo52tLkqfEyG++E9o1w7kbByp4aFFuo0TdDOIZ4/FHK//nj5J76GG7/W9TPBxS+sszI+T9CyJPQHpAEIW0Pqu0+40tfIfV6XDQMtvMWoVmkXy7Rmp1CThuZzM2HcFjn65qhLilKC0WZLiaGV6Rj2Gy95UbUxL1QvQjhRcxAklYcZH5EL3q2CwgvD9s+ubPLJB2F2oKWNNgc3Us4Oot36C1Ifky7UdeXIJfD3t7E2noChr4K156DG55huP77jKw/xcSZz9DYOEq+6xMHEVs5gSkVubCFMB/Ucsbh61Gv/xXa7/pl/IO/xLr5Czw7MUR7X532vsOQrkB8EYouVHzMdItxA0ZLcGqPTet1u5Hze6FyAJID4CwgKk8x7J1kPIkQgY5pjn2tGiwdhOHrILcbJhZh+ijkBjC8D2bq4Njg7wajohioIgXTwNmjUAWF2qew3i4p362YqMMPeBA87nLiM3tZ+ss9mJag9DqYKCcUbZ+Nc7vwuvvIVzuU7k2ID+s14uYANhOQW+AdgZP/u83j9zmc+KNhet/UucFWDpZDiOahuudy76j+9/CAmZkZqtXq84/f/M3f/I4zbW1tkaYpY2Nj3/b82NgYa2trlzuwK4aXe5782Mc+xvz8PLlcjjvuuINHH330bzz26NGj/MRP/ATz8/MIIfjoRz/6Hcf8m3/zbxBCfNvjr+vDu1ogABsTGweLAiY2JgY5cuRxyeMgyGHiksOgjaIppCYcaQ/CppbgunmoTWhzJjyojUAuArOrnZUVmuhV8zovdyCho7PQ8QYvkENp6B5Xy9IB3Y7UvbXhQFeKc+PaEGujDzl0FrGQmVNwDPmuNs7qmuDVdGtI3cAFLAIU2wxI6BEzoEMCKFwCJBYRJQKwUpQywS9pwulkTtIOeky+B90UWo6+dgLtyGymmgzbJrimNhUoF7XDtJJ6p64gQIW6mgw60z4Rmsx2A/CzinEYa3JbEHoMytF91yqrescZ0c0ZmjQL/S/5Epcvr3B8L/Po1TWXxnHMm9/8ZgaDAf/u3/07Pv3pT/PpT3+aD3/4wzvk91WEn7hZ5zZ/5sklpLzadqZ2cDXiJVWA3/72twPwpje96dv62pRSCCFI0xfZwXwlwIchK6YTzFAqLVDkNE1vD1EcMrAtpsYEm5FCRfr39Ng2BCuw9AXBKD6rC9B70mC1p4jXwJ5oceLni7T2HtYLlXwDs+cz9c0z7F7e5uhwG0/G7Hlc0t39DCfe8DbO/Mgh2g+cpXfrQXrX7kIMnsbd2MKpDCBVDB81UDe6UKjQffvPYPyn48x+PUeadjmx36LbmCTdPw7uGfL5ARfjFNUJIV7TfVybDpNf/TQTG5s8s7dBbs1ixIlZGxiINAAHjO6AnBnRK4NhGWyZU8SFGtb2Eo7V1uu0/AhECQw6kJTA3QNDu8Ho6UUbqV6UrO1ibWaCdn6Bwe23IXf/CHx5CNHYop56iJwidm38JNEVFC/BjCVJt0fR7xB4erO/Z5qocandr9t7YCkPuxXkxzA6TzMWB2zOzJPk3gC5EKfzLYYWW2xbMLGScmrYIR+k1KKEfKRIFPhSYoYPMJgqIqt5lMxB/QCcLUBvjH7vEEPhE2xVOqSFLUSqtLRwK0W5HgUBxqQgatQhvxfG74T2BDhPIdK/YKpwhvkwxmzDZKKV7p4N7UAnhlDSnln5/VBJYPY5KN0E/QAKM5p4jpUUVTOlvmuTYLdi1kk42AF3CfYvgbMBnQWB98ABludbrNy6zNg3TeaFYOKWmG27TfiFeQxzlX03tgjvgvYQjByF7gOwcRrE62BlCNpeASKXlkponzUQqeDwP0qRQ3D8ItiNy72hYiB6kdfh4sWLVCqV55/9qxWLqwkv5zx5uX18nuexe/du3v3ud/Mv/sW/+BvPe8011/DlL3/5+a8t6yX9SnhVQCuPFUpJQpngYGFgECOJiYkIgBCFRUJOx/IaijBnallu3oSireW7bk4bSBBoUivRst280MRNpeB5mhDHpu43MJws89fWkud+nBlFZcZXkYQ01v2wqQTp6d/QOXQEksoMt0JDf08stDtyKnT0kkhAW1thkmIQYONiYWIjMDP/axMTdek/I4suSiOdw0uSGTEp/d7CALKKbpBooyw3kyw7ho6Yi0Pwo6w6jn7EmWNXpLKKttQP09bnvFQpl+jzhkr3JcWXqtHZeZTQ1WND6vdLDX3Nibj6qr/Ai8+jl465euZS27Z59tlnr/QwdvC3xFsPj1HOWax0Ah46t83B+lXap7+DqwYvabVz//33v9zj+DvHpgFnk5QUn7rKY6cODWmTp8DY/HkOvF7xdFf3axb6MHccmp+FzjGX1bTEsOpx4T5BPJbS+YGY8z+SJ5iewFraJK11ySfnmD/lcef5FM5AxQl57jD0jpeZec5gNX+G9o+8keW7boe5vZBaqK6Bv3+M0H6axgPP0N7nIO96ozbPPPkclccrFALBhalhWj/2Ouze17FaG2yV307TkhjqCwyd38adarF5/n7i5huJJyRhDpRM8M0Sx3KC3t130xlzwZnDWDtKfl3RKUKQ5ognDoI5iZeWENHjmOYwMtxPfvsbRJZLOgzUDoA/pCsBVgzC1Tv4wUHiXW8jnnsaZu6BjQ1wHsEKjrErUFg1WJcJPStG+S7EDolhQwjbxm5KRhuvbtA5VANXQrcNfheIobgM6X4Qy3Rqp0gKJegNI+Qx7OXHsRPFiKGLFIGcwhupI3o9asEiY56OP5nc7pL6n2Erb7Jae4OuzuSqMK4LPAUiqvEFmoUCysyBACvxMFKLnhNzfGiSdOJmKNwC/mGIHsay/oxSa4GcUiQhuH0YdKFWhHMSagtQ24TaIe2FExV1r60zCusb2uusPw3yLJxfU1BYo9JQVE3gDLgDLaEerIFsQJpXXHjHEdbeKJmfBOvJEuunx4necIbSbsnksWfJT0rCH1McmYRpD+KvwtK3BDlp0L0rpbdskg+HUGYHIXssLgzRXqwxap9l5EcleSeLa7osRHz3hZt+rVKpfNui7a/D8PAwpmmyvr7+bc+vr68zPj5+uQO7Yng558nL7eO77bbbuO222wC+a5+fZVmvqs/0pUIJNNkzJalUhFIhKGJiEpEQEGSyZw+FS4SLiyBvCPpFC4o5TX6rDhQdyDk64ogIui1NGk0HSiojdEC7A2kBZEX3zxp6zsPKAQ60Ii0ttgwYCAikJqKp1MZSsg15V5PGrtAM3jQ0GY6ySm2c5fXSzsykrIzippj45KhjZTQ4JkICDhYxKQlSy5dJIQ31e6qswmxLvTowbS1pFlkesWHqGCNbQsGE0RpsNqHnA4muUJtAGOlxRYAb6eMdoTcBsPQ1Xqru+oGWbqdSO04HZpb3K9Cu0lkEk2voiKesnVi7S19teLF5FK7GufQf/IN/8HwO8A5encjZOhP4Pz+yyMe/fo4fOlBj9yTcsXsY07ga79UdvNrxkgjwvffeSxAEPPvss2xsbCDlZdoSvgKwtSoI02EkZTYG87TYIOU00xTxNmPCLwom7lH4A9gfAEuQXoTEiYkGcIYJZgt9gv9xi6deX0FEimuePoMzkfC0PUrpdBO3m9JpwPaKwInhxoaiZ6Xktx3uvHCGh4+Wad94LxixJmLmDeAnyJ96O1t33KurqvsPQnCBiaf/gpFBk3PTZZo/9oswu8r0Z5qUwoQLIylD6yn5Ro/6QLE6KZCdPEQOPbOM6fRQY9OQN4k3NpGTPwNUQRRwTh+l1pHEFdgeGgF/gFi+n0JnDdyYuFoH36bUTvA2Q7yDmyjeBmdGwE91VSSJgBR7wSEV48hb7oKjixSO/iVJpUVcbNByXGbMkFqiWF3vEYYNjFM1UAJpNEh238y5KigXKHax/AUScxrE41AHPBekQvZ+jJ6KQHSgMEG19xnm+i02TDB7UDfAUTHB0BRDyUMkccqpRoF8HNLPS5RZILbIDGY2YOtJzM0LpFaJhUoBIWJdsShbUFYkzizuuRXWTIOWsxfKN8PgGugcwZJ/RNlbZainKJZgaABbGxBXoBfCwohgv6WwL8DyQa0qzK/qKNFjcxaLdZPJUsipvMNkMWXUl6x6eSLPQ3iQa+moIhNohhBtQCM2qN0oeUMTSkuwtFzhQjLMTV9bxl71MSwF71I8uAviPDQuAssQxhVkI2F+ekD/D4fZimoYto8np1jCYVzN0F5dZDoJGWmA/30iwN8LHMfhlltu4Stf+Qo/9mM/BoCUkq985Sv80i/90uUO7Irh5Zonv599fKdPn2ZycpJcLsddd93Fb/7mbzI7+9e7eIZhSBiGz3/9aml3eR5SkaRgIijg4mAhEHjE5EnxkPQQKEyGsFnFJlWm7u8lq2L6UmeZDXpQ6OoNQLsMaV+76id+1sebg4bUbsqJo0lkKjVxMxOwI2gInW2bGsC27n8t1/T3mKmuBvct/bpt6iqxFFAxtdmVl2T5uwkQ68gkwwICTGxcqsQoEmIkeoPPQiEJ8bCIsbTU2kjBSl6IewqyKrMjoFIGewCWp8l3zoSGAbYFRHqT0wihaoLXfaEHOJ/XY7IjTWrTRG8imIl24vNTbfBl5MBJdcU3zeu8YSK9iSBDbXZlCYiszKCrr3utc4aeUl4FYrPLw/dOgL8XvFrm0iRJ+MQnPsGXv/xlbrnlForF4re9/pGPfOQKjWwHl4Opmja/euDsNg+c3QbOMl3P8z+/8xBvv3biyg5uBzv4K3hJBPi+++7jfe97H1tbW9/x2qtFAj0V6bVETtVpsw1ItjCIWKXdMzn1p3l2SY+Jd0JhGzptMMsOVnOaMXuZM/Ec7aEIYwp2P+IxtZawaxS+OupgnYKhT0nSAWwbEG8IBp0hFgYtGngkYx775mCQPsO35EFU3IKFB2BoWutUrQjGflAvSHoLuOf/K1HqceqHTPpzb0QdeAPGf/1/MXgmwc8pZteWcNswdguMCLiwVkCWfMz4Yfzpn8bf2IC6gbn6IKXNTWL/fyPY/T+AYdMIn8Hr6RY23Dxs9yisLpFXCSbgpx6YF6mFMb3IwQ03CPrr4Bd1n1uYB9/ESEAYPnI8D+MJ1vlnqQQbbI+7KP82zuVHOd+8iHUyIZEHsQbTSN9C2CEUy2DPovZVEWufQ/WbJEkFw3CRQY/8zB/gN34K1oag24DBDNTOQLWHStdZDwp05hRqLWJ8OEVW9iKaVeqqydrAxK1FDEYnMY1N0uq8rpwECRRmEZxmqLNOt98h3SNp9EI2CgXUoANBHquwSoEB2+USTPwglA+Cb2NZDzHaW0F09B5AKQS1Cl0F9ibIliAaLZA0BqQNeDYH5Rtg/6NgduDJAzfjNUp09j5BLzeJLG0ysb3FvgUPax68GFiDxAYCSAcOrQcncUUHJ2pRnIWgC1uRJDSaOI7P5rdq5G/uszQWYWfqwvIp4KJFLpqhYqwR3B9wdKVA193GjuaJTZvp1GK4dIrR+YhCH6oWGJdt4ujx3XvyvMs62/vf/35+9md/lltvvZXbb7+dj370owwGg+croK8GvFzz5Hfr47tkGPNScMcdd/AHf/AHHDhwgNXVVT70oQ/xhje8gSNHjlAul7/j+N/8zd/kQx/60Et+vyuKTC6bKoGBgYmZGWKp58XBKZfEpQqJIhKKyCDLrRX6QWZwlSjdryGyLODME0rHDGfHm6n+U2R2xVK9IAU2MmMoIXVzMok2gZJZdjAK3Iz0SbTNO6Z2o/azbGHD1NXjVOi+WZVVR7FRGEiE9t9CaX6JRCCRKCRaLo3Qp9WNw5YmwGYW1yTMLO5I6VvbynpwDaW/R2SfgVL6PEZ2PqT+XqHAifQGghLaMdtIsmvMTLakQLNYoavPisyVOtLuz+rSPZJJwDH0ccgX/lGvKrzYPHrpmO8dr4a59MiRI9x8880AnDp16tte24mPe3XgviOr/PaXTlJwTLwo5f/5pjlu3z/B73/9HL/wn5/k93/65h0SvINXFF4SAf7lX/5l3v3ud/Prv/7r37Eoe7VgYekAQwxxih5liljiHHO5NkmQp2BE5C2PfgyzKdgejNdhyYTY6BFUYqaa20QyYPIoiC84hIZF8gsBfjNm7o+2SR9q0JhrMrI3peMIVKFHvWMjpY066OOVYMsVKNOGXpfCxa8Q90coqRaDaoVIhBA1yS19iYlzz7Jwx8+jti+gGlPQOUl56Sm8hmLKgnBRr5U2EqgISE4o6v43KSeShXf8Syi8F6KHkTxJ0FTQew7KPsKZx8LTBQZbIERAsbnCHjfhYmKy1ShCxYE4h0oMZK6I4Q8w4iVkamupnF8AESEMQTJ6Hua+BYMtkuk8m851pOPjIN4MJ2ZRHY9kYCN8iVA5MB3M1CYdHEdc/BpmtMKQe5q+LzATg7zYZLNRwy208CunYf1GaNVg2oKBCbUahlGiM10lKpuUm2c4NeoSFRtYvWdZyoNbSXFdE98xkCqF7joM5aB2Ldg2auQAnlzAOO5h9BUiEVAU5NZ9zLZENELyQtG15yHYB30fxCap9IgTQQ7FhqUVjFZNt9GVN2AwEBiWS9wfcK4EZgU4AYWz8NSdFbyRWyHXp1Mcgjihk1To7G0zUkkYOBB3dEthuABiwaTfbVCQwxydW6a0nKe4kKN+bQtDVrjG7mFWJX6jQ+9dKWuT2otmaBWmnjBZ6AyRZ4inNoeJ14/StDokoka3uAD5UcxmicPEFJdM8g8lNG+CjRfLovwOvHwVYID3vOc9bG5u8uu//uusra1x4403ct99972q5ptX+jz5Qz/0Q8///frrr+eOO+5gbm6OT33qU/zjf/yPv+P4X/3VX+X973//8193u11mZmb+Tsb6skAZpFkXrIGBRYKFwqaCmbk/pygSUjpEtG2bvmtrgyfXylyQxQsxQJ7Sm5SJrw2jjMw3wDa1u3PoATFYKZDXZJcAcrGWAgexrn66WbRPHOm2j56vCWO5oiOWIqVNpQY2dHPQb+m+YrsARamJa7esW1KURKoaCSGKPmWdM0SESV+zSwAkPpJYW8LnLe3k77r6OgodyNk64o5BJrG2dB+zmY2zoMBONakN0GMUBVADiAOQOf37wQIoaJIeGvp7DSDwQAaQdCFBO1mrASRliEwYNCH09WeboImyQE+KSkE6uDr578tcAYZX/lyapikf+tCHuO6666jX61d6ODt4CUil4sOfO86bD45y02yN3/7iKb50ssk/fcth/tPP3Mo/+cPH+XefP85bD4/vyKF38IrBSyLA6+vrvP/973/FTKAvBY82LJy2T2j4iOFJpps248FBYqWYLlxk6M6I2q0wEkK0qfs6i2ZEyxwQ9xxSu0dsw+aGYHU5T/kNbR4YNrBPSUrPFlDjXWZvTElNMJTAngmpn50myvVwR31CEzbdKtSrCC9lwkkpXlxmCHjSrBBFAiybuT86iV8sIW/fA+O3Q/8ZjIv/b5JGF1GwWM5VqVabDCuFW9ZFgV2dPotbgmINzOQUaf0HIKxgtrYRfYnlGLC9QbG3gOylmDUYOIpcexEvLnLSHicsCO3KKYBSiWbFphy1QUHkeBA0wWno3q2hgDS24KZvYIuHKDW3adf2kt7w03BhEk65sOFgdlLyCQwsSSxKCOGQpgIWHqXu3E++k7DvACyEgqV6jUFuCjvYppQoesYC6cQanC4CKSSTcEGhchWq4XGibUGlKlgc7IaFN+BUlxgtKjbKAjOIKbWWsOOU1kgBzFlwSlraV72XfmMO6l8mv/4cYVNRXBtg92EqCFgrQq9qEE7UQa6AfxLiOqpoEJ3XfjgDH0pF8HtQyenkj1wN7EFE/xwcO5Bncjhg8rOKFQRH9t0AY2PQN0D2IS5S2Yo4mKYsm7Axpwso9iYMKbCXLUppg4KzSXBjzGpfMqsi3IURDka76R76Oo+/HazDKXENlA+yq82vLjw7xDl2sYhgueggwhp1X5KnTmylrBolbFlj0L+X0jPnGJSfJCykBNuXe0d9byZYl4Nf+qVfekXJ9C4XL9c8+XfVx1er1di/fz9nzpz5a1//62JWXi0QBpimRCUWSkEPSUKKTYrLgDz5zPtZokiJkCjl6WqjKEHiQuRoRzs7q5JaRV3dTVu6N9U2oWjoymUSQ76O/hVr60quaemdsBT9eqmWyXpDqFWgYujsND+TO/fzWm4tE+in+u++0Hm9aUZEFZoc1iLoCoRnYjNAIggpEgsfUyXkAPm8NVaMyoixUtlOWzEHKtCV3emCNrpy0DLoqgE1E4ZcKAK5VD+MFDpdPeFYMQhbbwAoIPC1u7Pt6Wq5yq7fGOgUARP9nDD0JoBKdT/zJRm2AUQp9KPMHExXzs00QcQxwshOe0V+mr6f+N5NsC4Hr+S51DRN3va2t3H8+PEdAvwqxaPnmyy1fP7De29isprnf/vSKZ5a7nFhe8DukTK/8Ma9/MTvP8ij55vctWfoSg93BzsAXmKOwE/+5E/yta997WUeyt8tkimDuulxSPZxpMWSU+Qp9yD5csJN/1OP2j8DeZ1OsLAKUJAgEoGI60gnoaBC3PEWBVcxfKjDyo9aXCiXMB5xGfhDTNweUh+G4TKU/2GCc0jhj63h3dLBPAxPTxXYPnQjGA1E3Kc+kOxZy9rKohRy2xQ/+9/g8RLdDR+x9lUoXYs4U2Xs8QWYtBjsfwfJzXcxO6m9SKJNeMwRrE3naF0/Q2vfLOns6zSbCk+TO7aKb0PqKAp+D5eAzekcy2NF/BSKgaQYhKgkxoj7YI/pXrP2EXrlFLuh6NsNZK0L5YsQljFsBXMJ3HWOfOMhrl/bYE8vQbQG0HkQ8kd0pSKJSXddoH/T11DXn4BxA2VB6iZg9klRuKMQlHSLWdKokRZMUtfGyEMxWYDi/bD7AUgf1y6kmzlSmZKMpHQrJkuVIeTENWBN4xd+jNQtUPIkvQ6UN1Nyq0K7j0ahltj1zoP8OvSHYeznCBpvJSjVGIphaAycA2CVYJA60FrFPPP7GBe+AJ0AOjVETUAeJlwdCWzZWt7stSCJJSOrA1TeoHPtMMnnC1SXcxy7LUewbwx8H5QHtYPUTp3j+o1n+fJInQcOlbg4BO08dC3IS7CdGIMeBdXh5nWbNxVSrllPGd806Nz6II/8/ICzd8LCMHg5sBPY1QH3CYenvEketlMW8pDvQClwGCLPNILrkjpO32TRibkv5/FIvUNwZ0pPwJEnL/eOir6Hx2sLL9c8+d/38V3CpT6+u+666299/kvo9/ucPXuWiYmrT6Ym0JYKWhRM5vwsSTIHaC0MBi0U1s8jU4RMtKxDSl08vSTHVFI7OQuhK68yk++aWe4v6CqvmdMPI6sKO/YL3+8aWmIsUijYULKhZsGQA3Vbm0xZWWpxJDVBTGJNSl2hiaOZSbPdzCEagSBGoUgwCTAJhSBFkiBIMIkwiA2D2BK6wuykOrkgl+gJp+Jo0lsR+vkCmpznlZZK20LLuEl1zJGRakJr2WCZmvPLRPcwx6k29pJB5jIdAfELGb4q22Q1MrdoInSjdNY3HMaZOVcKSiJkglApqBc+5qsL38s8evXNpddeey3nzp270sPYwUvERi8A4MBYmfFqjrv3DgPwZ08s6+fHy9923A528ErAS6oA/97v/R7vfve7+eY3v8l1112Hbdvf9vo/+2f/7GUZ3PcVZZeoUeCWzU32b57kMVUkR5e5XWvI66A9B50V3XI6egyKa7C9LuiJDWScMkjyNNdidt0acurvC9ZuH6XyjS3sc9ATA7YSmCjo9cPJWwzOHtpH8kaFoINpOwwO3wGlWUgVogfD56G0AOenoZOfg/OrzC4ukbdyuMKE8gEItskv/iV3LEac2FPlxI1vYt+j/wcHthR9DwqbkM8pqjnFwrVvZHXorRBPQrVP6YGvMzHwWSwKSk0oRQmtukmw/xZCmVA7+SjRmqLYjRDlHrLqkFbmIDgGhT6GaSPHJWHldXpBVN8GTyLjvs4CHj7BfPMc9UjRSiAvthi0HwfVh5EqHC5QHvoTdg+O0OzmWZs6R+r9fZxmg2DwTjqTLv1rArrm4+wRW5jNNmkppuH3sSoQ92PGkm+S8BDxcJme+Aeo3uvwyylxTpCEFhSGYGwUiuuoE7NsRddyKH0EJWE6gtUtAZs9RLiFI54jLJYh50HpFKy/BxX/Av7I67g48yiWt4kjniX1PaxYETkGha3zVPIhW94nCZP9eG6R0O/hIhgXClHQXjE1AaUhKLqK4VRx158uc/CUwzO3WCz8wE1gTaOjRSrU73uAd/3RI3z9HQVajsHIsyFyLwwcm37DprvloVaHMDHoxzHWw7uozJwnvjmm88PrHLtJ0BUG+UBiOXodPjAg2IK1xxocGzWIkxgcD79pMiO3uE7ERMEP8JidEgytEORb5LwIp34eEYC1nHnpXBYGfPd6zOX1rV0NeDnnyRfr43vf+97H1NTU81mgURRx7Nix5/++vLzM008/TalUYu/evQB84AMf4Ed+5EeYm5tjZWWFf/2v/zWmafLe97735bj8VxSk1H5RFkYWFBRjYGJgoTAYEGLQoUpISIhPiJXWcaK8VjJLRzfGyxjCEHoBVAMwAx1XJLUDM4ELZlZBDRLd82qinfEME/KR7teVCqwuNMraPbqZZFFI6GqnJWAs0c93U20GZcSaLDdK2in5khtyhL5hCxIlJHHbJFUpCh+hGkgUPQZAhEIADSi2oNSFoWEdZZcLYW9Gem0DxhVUUhiEOtrJFiBbWR+zgH4XRAAVQGWZvK4JSaDJupW5OCe2rvoS677fVAA56GQ9vKbKDK6kvpB0oEmzUhD3IeiB6umKt2+glP4Mkle+zchLxIvNo3A1zqUf/vCH+cAHPsC//bf/9q81wXoxt+sdXFmMlnMAnFzvcfNsnZ+6dZpvnN7i008u8f637ufkWu/bjtvBDl4JeEkE+I//+I/50pe+RC6X42tf+9q3mRQIIV4dBDhZpZdWiXMeh2LJkXgcQcITiwZn/lgwP6wIE4gehGf+rxpTVpdeCr4Rk1gQqDYlCc0GnN1dQ1kWHVEm6KaINM+NBqQV6F2E7fVhBrf+MAw2syqABTkXun0wqsw88jjFdcVGF5IJg9SqUl9+Drk75dhMSjBzCCauw+h8kjn3ITgEfn4cCsOUV7cohNDtgN+C5lnBzXtCTnQ6DPYdgo0m4OJGPsqBoqEoD0DcDrh1aOyHxYfxXYWywB+x8Mp1XZ0MWwh7CxWOo9IIMViBch2Sg9Dao3f2LQVJgOOdYk8nZHMNPB9qwyGD+B4o3AjWGRjNM372FMY5yUi5Q7n2pywObePJnwV1M1jzpPNbbKcuIv1v5NodvLxDp2ARqIRKHw7YkoUgwg+36Q+fR/FWEms3CWs6xsMo6CiRkoCJAPsbWzjAdBnMBShaEis2SNQ1xNZzIFqIUFFtHaHUOs+69SPEQ/8UWb2D6NAi6tkPUTjlMZwLWRQdrCGLfYOQXmuZGI/IKUJF4RtDBIUB3UqLCSNlWoA5AnOTmgxX2oqv7hlh8e33Ivffrnvden3yT36VO778FOEuxfLBacY+fZb9bkzrKJytO6TDNptdn4rZJTFCzKRMcfQCiz8U03kdHC0abFomjq8o5CSmrYs0pQDWPudy3C8Q73FBNMCyiM2IlcEUJ5su20TUkiZ+q09hY4KDzjEOj8cEi+CU4a9wte8BEd99Orn6qhYvhpdznnyxPr7FxUUM4wVBz8rKCjfddNPzX//O7/wOv/M7v8O99977fFV6aWmJ9773vWxvbzMyMsLdd9/Nww8/zMjIZVuAv4qgDZ6UKXRRUWlzqQSJR0QXn5R8Zo5lIUwbyjbkE3A8raYxI3B83dOrDDBKmbGVyvpw08wIy9Hy5MTIjKMEWnSVVTXDzPzJNnS1M40h9SFfBlwIhZYep6a+IY1QV1ItR4+jbuj+WyG0OZYhwU2JBxYiEZjSIDUjlKFQJpfaf7XjYdmGUia7dm3IFyEf6J7iEakJd5JmUm9LV3fLQleICyrL4c2crdNERxWZBpgSShb4WZ6xITJZdLYDkSr9sLLrTUJIEn2+xNVRT9LSAempCXYOZEaAybKc1X93LVcdXmwevXTM1YV3vOMdALzrXe/6W2em7+DvHrfvajBdz/P/vf8M/+lnbuXNh0ap5izWuyH3n9zgk49dZKaR5/ZdjSs91B3s4Hm8JAL8a7/2a3zoQx/igx/84Lctul5NsJf7RPkCG9t7mFAmNxFxhhZnBxNED1uUfmiLygQ0v5pjszVLal+kUGmhbCia4K1WCWo9Hj1gExUsiEPEsymyOcmYiGgEghNVRbsoWD80qhc2KnP1jEuw0QdHUnv8LzjYv8jKQCfvnJ0uITZbHNhaZNG1CfblAQWd+ygtfQUhA760bxh//61g24RGxMUFOL1k4NiSZs4gaKZUwrMM7ohhj4TUI9ooYp+EnITmDRZerkRqNiC8FlWPafoXYVQg4yGo58GZhcJuCJYwOgNSy8VNJIZlI89NQlDRvWqGQiwaVCePk2tIts4KXKXo+ZOIc38fZQ5DoYNT+GPcfkB7UMUsNbE3Q35g+ot8+aCJv/orcNaFJwPUjZO0kxJF1cVMYmJMyn04GIJZ1EZTSd5Eihr4Dhi3Q/08OB1wYnBXoXEXrLdxlzZZGwiqc4q4CbkyuGmL3PpRnJKHXxCogclEO6S31MGd+wpx5R1wdgQci/xGSm4Z8kNgzE0gojq7O8dZSxVt0WTDGELa18DIFEHeY8VcI1CnKI74yLyBZ+Vp7WqwXtyLN3kTFBqwtg45i/r993Hdf32WkbGEp/fkSNsJlXxC75RBzoNdMsSLfLymhSMdCobPSC3B3hPxwA2C1rhCmQo3ivXaWEE51b47zrOCzUcn8YSicMFGpKvEScx4bGPJBqgWNzlHOXjbAr40aAeLTFd8pq+BYl23PE5vXu4dtUOA/ype7nnyu/Xx/VWp9fz8fEbu/mb8yZ/8yd96TK82KDLXZctCSoVUChCZCDqiS4BBnMlrzaw/1gI30aZPIqf7VO2ITLsLoghGoCN8VPyCu7GVuTYnSkuUDf1eKG1WpQ2hMqcoGepeWtWBPNoUK3Gh7mSRQ0JLiKOs5GtaejO1h2aFianNtJKU1HV1bTsySM0QZWUZvEl23nKsSWrJ1u7SeQdKJU1u8zE00szlWurqsC30e5Us3fvrRprMpwqCrHdXxpnpVaqjkqLMEttEj01agA9J5mBtxpkJVh/SQDtFxzWQeX09XlYtthz9p8w+AsHVqn3O8NokwC9nZvoO/u5hGoL/+Z2H+IX//CT/5A8f5+fv3c3bDtb506c3+VefeY6tQcTv//TNOwZYO3hF4SUR4CiKeM973vOqJb8Aw/6AoBdT271EOhCU10oMGz7SrmC/ro07DF4R1FxM6cQGVmKz1S1SrQ3ohSa2ZbDwuoT1G4qIDahsrxN9YzeVpMgEecKBTXM45cyBIZRKwDsD1ij0O5SffpDa2WXqg4SZvk9iKqQAewbCZkxp+zh5kTAoCMpLLazySewTxwjykhM370GqOlRHwe+xUK3jhps0hWQkNCh1Ui7WYSw6z+pzz8I9h0B1GRx+Pab7DL6XEtVTUgGFwRJe/xhq8i7k4DwMFmCQwCCnd/xLEsvL424tEdlFnAKIzjacquvFim1o58+2onluH38xMUtwVx5bnCT270Ss7EL4fUQwRDxRx69CsecRtAyMYgqBpNg4iW+uYXhDyEhCNEQiakSlLlIJproRDbRfVH4TmpbJICcwrVVSK4SlgzB1D1iPaXMZacLpFFopiTApm2Ct60LCzDxUjJBYhIRtaCvIyQSzD1EZwnxR996lCgYWjdRlxgbRheELLVqlOqsLMFkBiuBbXfy1CySmj8iFpCMHaI5N8k2jALndqOoklMrgnYAg0s5Upk/x4YfY/YdHUU2HtBRTDgJKqxfoHxIMPeWwdq4CBBi1PlOlFCdOqexKmL4n5i8bBhszOcwkwLQkpqnXm26izVcnlmDuIThVaFPyQoZSRemei6R2Sv5Ins6ZaSQb1Id9dv14SuSklBoxVQMW7oONRwTVuxUd83LvqAHfvSzjv4S79NWNq2GevNqg60ia0EVC9/rqnlkDgUWHzPsJCIuSoJSA6ess38iBkbLeRUx7Oq6ORJ80dLKK5SAjwVITP6egnfF6bZ2vK0paTo2t3fISH2IPilVQeYiLYGd5viM2DJm6glwUULB0NTYS+uEJKPu66lrNQVNCF5hXpN2AdDvQBWfT1A7PlqWl1WWpTQvyKcQO1BKYHkDFhpKh+4Krlq4MD+ch6IC/AaoAUReCC1AsaDMw4YMINQkmAT8AL/NYcCTULeiQkenk+T0DbFvLn5HQCbWZ4kBCX8JA6Z28oA1eG6IIIVNMM9apS4ngarS/0nixeRSuxrn03nvv5Zvf/Cb/8T/+R86ePcuf/dmfMTU1xR/+4R+ya9euKz28HXwPePu1E/z+T9/Mhz93nJ/8+MPPP7/Zj/hff+K6nQikHbzi8JII8M/+7M/yyU9+kn/1r/7Vyz2evzOkgc2BfJO73uvhP21y8fM2s5Ueczd3mboNns5pFfDYgRTXWOPcson1xD4Sf5HhwGL9zibej6bgBWBUsL8ocBZGCRlQI6ZYkiTDoJxQ7/S7CTiQe/Q419x3lvxzQzipwtyn8MpQyEEtB/mBjyUFPUsbLU8kilubPS5KwRPXjiLNvXphEq5D6SD90Rw9w4VkGFFdx7hJsVwTTG4HYC1B63rYSJHV17O99ieMtTbZXlXEIwOEVDB1Akp3ghqBznNUj3RJaquko4LIXCQRBspWqFjQt0F2XNgug5PXCxxVQOGSbv5DUq8Go13i+XVYG0cZRYx0AFNHULtaXMgPscvZYLSlyEe6Iit7CqIAaUoopVAuo/IVkoFBLUpIEkgd6I+CXATHk1RakBt8i5OFW2D9B6F9KwzZYKyBWQXOQ2Uc444ytfMt2kdNpnel2GUoV2FxC1aq0OjAAQlbVVg2DeKh63R13mhT3f4/uaF5kVwDNrtw8OgCTw+tY85r5+dZE0pmTJKuU9/cYLMuWGz36N5+D2r0DqhMAKHuD4wNKI9CPyD3+a9w7X99knCgkGmB9pKB3C0xutAsm5jX+ky6IaMDiV+A2QOQTnuoeXh0DI5MFiBSpAWLfBhRFJk/TA8Ob8L1R0HuUZRubOGvQ1i/QGkY2n9hsNEUbFChyTC95gD72DFGjITiQNCMBCtfOEw76lCuXaR86HLvqAhd7vlur7+2cDXMk1cdRGa6lCQoZWT5vzofl4wMp4R4eKSJrxU7kYLUyBQ8MTgGGEUQfXS+r63NqUg10RNZrJGy9NdRkEUJGbrqKSz9fUGoK6aW0uTZcCCXA78JZPFLRk5XQWsFCG1NtLdt3XfrOlBOtEzZs7X7nSMhinU1uGzq9xSGJr45U1dpixKKKRRSfUxVQTEzwCoKTbrz6HMUlJZeiwHIgf6lqGLw+/p97X6Wg6z0tclIV3llViEOg6xCnGUmk/1dGlr+nHroRubs68TW86Xn6U3DVIHQ1mWGVKRZMfzqnU5ebB69dMzVhU9/+tP8zM/8DD/90z/NU089RRiGAHQ6HX7jN36Dz3/+81d4hDv4XvD2ayd46+FxHjm3xbmVbf7gsTXObA5oeZfvXL6DHXy/8ZIIcJqm/NZv/RZf/OIXuf7667/D3OUjH/nIyzK47yfuSvNce1OPkevAt1PktyRb3jhTapX6USg+LVhdFtQcycgeGA4kW6JG2h+lM/Ys6d9PMMsgYols+xSeTDGNJzHSBq4rEXsT3f8URdo0RTSBOlFjnG50gSHPpmuGuBK6NowMQZgDYkFlC6pdGOsqrtkwkB4U71JIewhx/ijC8ZGVOkzejJOzaQgL2xDYUymr0wpLwfJEQ5cqneegdgHsUTpDIzSCTVTOJBUj9O1QZ1ku3a/zGEcOkKinCPITmM1tRDFCWjaGF2FHTVwXhBujLFtXQZJIL7oKPWhXoGlAqwoXdoNvIAYpsvINjF3/GbY9qEasXesytxyQb0JUAOmmsB5iCkVayUOlD9U6kT1MK43BDujlA4yaouLDnmcUqwsGdjHAvu2bxJXb4OyclinWVzFPfpG5xT9lyd1NNNUj9aAuU8wZSMaBBPKG9q4pRtAyYcOAXCwRg3OoySUQffaoR5idTVh4Qq/XcgXF9crnqXyOwbBgb9enUYKpLRgcV0yNK+rmOg8YG0jX0m/SkfrfXw1B4lH9kz9m5rNL2GVJriywh2OGZyXRacH46TodJalU+hx+S4A5ptecUQrJLnj0gOBcziWqVLQ5TCQIpUSohP0LcMeK9vLyE+ilkFNQnYDuimDtz/Ooi9BQZSyqTJBnEMQ8/kcHWbNSDntDTIklnPQAASFLz2wxX7vcKkPMd59OXnu/AK+GefKqg3HJPCpC4aIwSFBYSEwkFj4JAzp0SMI8eImWAqU2YMNgoJ2ciw0Q/10MkUwApftmLamrnMrRfb5+V1d1BZokmnlNGLvdjHwK6Ma6SlsqwdayJoE1C+yq7v0YqgE5TT4Hrj63KEAj0bLkIKelyWkMQaB9Jho5bcyl0JLrsg05oBho4lxKYa+duUnHUPShasJsDdwYzExWYvUh14Ooqa/RtPXYhQ9DPTBdXbEOB7qfN5W6BzqR2pwiVECqK87K10Q3IDPM6vE86UstvdsZm9DuZDJoCwxTV4AjSHJ6w+8q5IAZXmwevXTM1YUPf/jDfPzjH+d973vft7VmvP71r+fDH/7wFRzZDi4XpiG4c/cQ+6pgunl+9b8c4VOPXeSf3rP72/q7d7CDK42XRICfe+655w1Wjhw58m2vvVp+wO/+8W1uvB2YgrUurFvjDMkSZrTK8mlB95k9HJMWT5c3mHsaSkGIlAvkuZVoDIJJrbaVqYWhuoiOzVgyTEBIko85NwblZcXeYwEru1r41SLKADkxg7jrSdT5dWoo4i7Iit4cz0u49qLCPQXJCPSVIDzn0kuKVE83yQ9bDEr7Yek5ShMXGYgmafl6JieeZCXysCYVxVHYbBXxp2Z1pVjY4LRg+XN45YQT4yPIQYph9JEyhsEi+NtgjoJTJZ5wSKfnSSMFhSrYAXHBwezFJKcFYmod6OhNaiHBt7R8LYpAdICarmzkBAqFOfUwueU1Cm4OIQUb+Vs46z/GwXpE0YDx7gqdycdJiyOwXQOxDA0TjDFk0EaUJf1aDqPfYduU7HNgOicRDZg0nmXxDV9Enb4HLuzROunVLeLTfezp55B7BEENGkXYKGuuXy8ATah6uo3Oquv1XGKCMLZQiQ++y5ZfYBB2MapQOwi9DaheAOOcpBHouM/Spjb86i/CwDU49eNzyOk7wSxrJ9RA6QUfI3DsPEOfW6FUihiugnNQURiOyA1ALBmUwwJj+R7OvGLpenAcoAv+Gqy5BqdUgxSB6HsYro/rwaGlhLnHYOgR2GwZnAwN7N0Sp6+oPFykrQxUswbxGDVCJAYrpBQ5zyTbiGAMXxxkQZmcRrIPyCMJtsuIZ18KAf5ulYurb9H2Yrga5smrDSJVCAQmFqkhUKQgO0hKJFis0cPBoUCi/aUSi6hZ1VJg34Gtoq6wel7mlZDXPbJ5G2xf9/oGod65qjvaKTm41OuLljN7fV1NLQldmU0EOJGupKYuVDJTqHQArqWrtnRecJSeKMCmgpNNCE3dP+v4mnx6qSbVytRk0vO0c3ReaemKK7R7dcWFShFcX1d/KzHMxro/2NrWPb2kmiT7Xb1B2qjoPmfZh1ysN3hLIxD0IexD2Nba8aKhpd0qAEItfVap3jANE71LZ3S1o3SYuUILU/co9wbQUdpgMZba1DBMs0QkE5mamUL4amXALzaPXjrm6sLJkye55557vuP5arVKu93+ux/QDl4WvPP6Cf7t545zbmvAYxdaOyZYO3hF4SUR4KvBsGDXHVCagnVg6wjM93oEZoutJVCrRTaSmLYoI705NuIEH4+p3CL9YAvIYeX0Zn8uF+A2BUWvQFPNUaNNp3GWdhkOrYNzv2LtZo/tPRc4Omwjx99AKxhlngtE10PP1Jv9W3kY8WBoHQZ5ODkEYROOy5BCmsdcEqjlDuK6FOVey+jaI6wmK6R7a4QFQbUs2ejCelAiHKlDLoC8qdVlxVsw+o+iwhXSkRwUQqw4RuYamFtdZDGFlT5Oq81Q7NGJjjCozcPwKBRKuC2PWmGNZX9Sm7WYZ2Gqr4mvkUA7xHROkRNnidwK8aEfgM09cGwcyRRTZYMKMc/03krhm2sM7JTnqpBrCKyTMcP5z7E1OY5avg2222AuYsh1nMQn5ysGqUnqSF04GIL+BPgpTBo9os1PsrYvQR35CTg9TJo/AMMnsepFBrlxGrnT5LVHGctAuwilXdDqarXecEmbqTZtB1XeC50KrI2wYdxFM/pz6EiWE0h6kF8TzC9HNI8ZtAyTxutTmlMmZ2WOi2+4lfiWn4CorqswQsJQBdoteOazNP7gHI1OhYkxD9UE91ntEm4IaAyl1PcsMLlH8cytgnNlg6606Y/lsUdj/DGL1CyB2UQon8p2zO2Pwr7HoPWUwYWtAr5soLDxt2vAKm05TI8GU0SEKAaU2KbJCBfJWR1yJBjJMjerKo8yjGBAhacp2m3GKh0apcu9o/roFezfhNde/t/VME9efZCAgZFJn/UzL0igExJMYgwCHBKkTImCjIj5CrpCy6hNoSuqJprEGo52YZYFwNLV00ubHBLdEywyU604BpSuJFu6wvl8zFE6yM5n6d5iM9ESZCL929oRuvfWSrnU0Qxogy5LahKdMzJJcpYTLESm1Il1jm8uhrKrHaZLqSbiNVO7PBckWJkhl8hil4SfGX/JzM051e8j0PJmlTlgq0R/BrbQk6tMNMkVqX4tivXxaQoi0fLmWGQycyBKdA9wN5OSy+zPJIVEIqXIqtl/Jz8oVwgvNo/C1TiXjo+Pc+bMGebn57/t+W9961vs3r37ygxqB39rlFyLH75+gk89vsQnH7u4Q4B38IrCSyLAVwMK2WZ06wvQPAU37FmjN6RYuginoxxl+pSUgLhAhE3AMIZcpWZvIkREN9brlkhA8QGFueCwwhYFRohKFuU12P4Li1ZPctMeSa4dcXwEVOozu7yJdRgW9kPY0y3CwTCEi1B1NfndTA0aG5JWAUa6U4hAoUTEhH+Ojam7cI4tM7r0OEuTwzxVKjNxS591lTIWevSXA0K1Rbr1WYL5/wFMF1mZgdYmRDaYOWJbgZHgGiGW79HvGbAVEQiQbgzDk8A6yIR0aATXXMWRW0SlOrQHMFgHywA7oZDcx57BedJAEakKm/ERwpF5wukfRqXXcraqEIUBiS8YWjhKYa1M5HZZ6M7iWIIb1QWi9mfppNfAuglDHUR/QDwwqESKdDMhqAjy24okhZN7cuxrhVQSxczFDsT/hbXddZR7J2y8AfPGr0FuHMNrgH8aT0HbhnatwIYyMdwcldo2XiJZtCBKBJuzt6GS98D5OiiXoPh2HnROcnv3OJXTivK6oDIBaRc6bUkybfON0l7ae99M+tZJ2H8NmCWwYmAATk47nOKS//oJ7joSkC+2GVggdkPnOAytaS+xI68HdbvgyXKRhaE5EsNEuQ4UBP5EHwxPywiVQkQWh5+NmXkKzjwrCDbrCGWRJ8WjRF7GhBQx6TOKSY8CJj0UCWPmMo3JFoWRFCOCZNXASJ5kT+cOSsB04wLVqZS0oKOdLw8xWvf53V7fwQ6uLBRpRnZNDJmi1bQODgKLFAcDi4gkm8st6TAYbEB3SLd42LHuBy4UsnDhRDszJwbggp+HioRCos2jErR8up9qWXKtBKKtN8kKtnbnMwtaaiw9SLZBjYJdgqGcJstpqtso8gY0DG1KoAwYNaHjZ30SFtRSTUDNAhDrtpvamCaRrSY0BlqGLBJtsDXtaLVNOQc1B2jqirUbAG1tLOD5QCZPYgtipUmqZWhS21yBWhHyLvRN7YZtDjRJTZWWh6N0VFKrl12L3oQgTsCPoBuCZ0C3ACsxrKX6fdJUS76jWJ9LCV6cHL7a8WLz6KVjri783M/9HP/8n/9zPvGJTyCEYGVlhYceeogPfOAD/C//y/9ypYe3g78F3nPbDJ96fInPP7fKv37XYSq5y85Y3MEOvi94zRJgdQ4unoYn/otL1w256+0K+zCsfhrkcg8nVpQtuJDP4fZCJpigVBhm6K6zrK7a5BYhtxvYglIbwsRmHNiLw+bJGQat06xtCsyqwpIQS4HKFRDeefKuT1lB+aRADMCsKcSEVir3Ym0avGcZOodhcs6kcUpSu84jP2wxMZKiomdo9wsML5wjfee7Of+G93BRfIr61tcZW5LYK5KSTPAGX+d0vgYHb9C7/7GB1V8nEUNAiu1uUZ1OCTddZGkGU1xkeCOkNeTjjz2lydyKRZzm2BoyMEQEzgisTWoNuFEFw2PM+TRhIGn1iuzxR+kZi1QKz1A2j2GWK6zZI2wWhygGT9CcCEgFRLMzJOqHSVNFd/Z/Z7R7nu7mGdRz0xRukpQUeCYYhmBWKNpdhZKQs6HeCakXFF4ItKHWauFV/y+6h7dR/utZLO5H5hJq6+cIDPALcD6XI3RHQHRJI5PUMHD6ku4yxJ6BLDkwXADyOnbEn2Nj6J/w1Wv/mMbEM+zvpWwGJc60p2k6ddJb9yOnf0i7ao2Z2vDGzHq+3Yomw1EO4+Iys1sdavs2iRKFNQ92EQJDQF6xeiucu75MMLIHVahDuQi5UBvj9Pt6IWiYQB8MmLwYcXgdNs9BsgVFFWEbHUJZw8ahi8BnnFlnBWGeRPm30xBNqiKlsGebyrUKEer1d32XJMeA+Et9jNSnUEoJY4gXoNe2uLzF5qVYmO/2+g52cOUhUcSkmIbCEhCnZM9AygCBgSSPoA+phd3PkW54SIWuzroOlB2tsCkaULV1T66SWiocWbqvAhuMrKJrJbpK6rUzI6w0I81Ck8POQJPXnKnl0VECLQVWHkReE+0gBS+GSlW/l5fqCmtiaMm0cKFgQpQDIn07lrJ7OJ/Xplo5YCKvj0tNTWQdoeOQLHRF28nOqwDhQORBNMgMqUwoOLo6nMa6at3vgi+0sRYG+K4mwkYCQRYLlWaSbBFp86wo1PFGpqMJug+sAV6k5Tqd7HrD9AXjsheJ9bo68GLz6KVjri588IMfRErJm9/8ZjzP45577sF1XT7wgQ/wy7/8y1d6eDv4W+Dm2Tp7R0uc2ejz355Z4afvmLvSQ9rBDoDXMAE+9TjMXgOnggppWzJ4ookpFea6rhIMKCFkAystMIKkgQGBxfITcwTNfZhPfY3c62JaESySo6ymGUHhFZ6ijoF9sc4WORp2G+F3sfIKIwmI63tYMnLMdT3UaZucCelkRDHUsYxnHxM4Gy65XMjJqWmqbouhmWM8NzlCa+z1HHr2i8yePsJTkw2GVz3qj95P67oPkiR30hw8Qb3fZSSvN+7VdoKxsI6cXwd7E9whks1xnQcUnUexSiAs/NIU7P4Rqkf/DyIjxJIpltcjiRvYvRWkUkT7DRK7CEkVxDhsGfqnpxBh2A62bdOameB0e4XWvmmMesrs5nmGcpsEhRabYhxvZA8qX2XzcAHGboNHplC7H2AhMrkxHdAyPstW91+StA9hqYcZFPfjyYCBsUjQs6k7IRcKDhtqAq+7gnJTiq6isazYm2xyovkAg9kZpDmL6T/GmLdJnIdTgaCXV2Bsgsgjii2iXopnmNjHLMpbBtuVFHnQ1r1zlglJHjYO4c3+It70c6xsWCjjMKoyBdYAii6UJ4A1cA1dhYn7OidUWnBmG2P9Ca77v/8jBytbPHbIZddqQPSEIN8s4hcTFt4ccPaGHMHuQ6jyrF4w2qYmv0EIBNqFNYzBTHGaEdc1U5x1CFogpUlMiiVzpIZPJC0iyuTsFapTF2BpmDnjNKK+QkkprBkoDus2wKgF7oj23ynnTmAHirijk5qMRCCCBrBxGXfUDgHewasHEoVpZCrlVKGQSGJSAgwcJCkGAUIF2GGC7MZailwLoK90Wk3XBgxNhqWpSakaaLKXZK7OQoLla+doEgh9MFJNhtOs2ieAwMvIqAtpqOW/kQmuCbarSXIa697YfCYdzmduy7HQ74+tN+8GDqA0SXUzM8a8qefrnAHDFd3jK7M+XlNqibOT6jmISFeJkZq8R4nOscfUBNkmc6JKtBQ6zpyfK0oT8dDUMm2V6nEnInO5tvW1I3TOcCJ0JVuauqjZJ3uvWBPfMNVeCliZvPzF4oGuBrw2CbAQgl/7tV/jX/7Lf8mZM2fo9/scPnyYUumye3F28AqDEIL33DrDv/v8cT712MUdAryDVwxeswR4sQlDPty5r80zz0zhH/cor/kMj8KBN6QMlkImtjrs7yu62DgMsIMbGQQxCT7FFUHdg801UKcqdNUkdXp4psC0fApBiX1VH/l6j2gWtmM0a0lcmoeH6T2ziDBiagcUWxJqW5B7BrYHFrV0NxdHFojG5xl4ko3lgGjVY2jwVfrLAU7icnh+maFykYk/f4pvDD5DeOc+0qkqF1Ob9noT97hi2oClcJmgMyDfeY4oLaHG9yJHTPAlad+kpYq43hp28lW2JkYwVnxGcyHO2SrJ/CSuXCbxFEF/HGoNsGbh+i50JqGVwKBBqzDP3bPLnIh3s33wANh5nPRZ3Al4wimxnJ8Fx0fNXA/mMJyegsVhMDo4HGV03WOtBZPmczS9J0hbb6Qx9ijtwEfGIQ0k+VqIXzJYHJ3BesRjtJkQzUJzChJD4IkSg3wBqsuQztG4+JfYacrJPgwKCsNOkMqBqo0K5gnMAUFxCnO/jzvkI927YXMCyiW9iDSTzOV1NzR3IS0X3FA/ghhUDtqbMD4C6+swaumKjNGGMwFG+2Gu+T8/ye7jks/96C0M7roR66ufYtjssDU1YO02xcbr8gTj10Ixc1Qr9LOIET9zjPXBDyEeYEY+e9Yi5jdg8xQMmnmsNIfDgD4lHOkQ4zOFhyUu4i0XGY4d6qUV7BlFZ00QXrBwSjH9AeSF7mseeOCaXdQoDGKwI2j5edSLLsL+KgZ8d2ne1bdo28GrFELnAMcqRaS6qpgC2h6riy5ZOuQZxiKgTB/VyuEPLB0RlIu14dVAwEgJGtPaAIoEiqNaJm3EOibJlJoI50u6Lzbd1LFESIgHGVF2NWE00F8HgR6R7YAKtRNyvAVuXptx9dAuy0YeVqSuvpoFnUuci6FU1FXhVIHp6UgmIaBsaQJsSFBd/UiL2lBhK4JiW5N1mnoiMBNwlD4u6YJTBCLdt3Mpw7dSfMEQMerqjbvBQH8GKtHzWZLTRHva0f293RSiGvQT6MS6MmwpKClYVdo80HLAiLJ/GRPDEFhOShxf7YXgF5tH4WqeSx3H4fDhw1d6GDt4mfHjN0/xv953gmeWOhxf7XJoonKlh7SDHbx2CfDozdAfg1EzZmSpR2trD3LjNKU9IXf/T4oVx6d40cd5coPFbwlWF1fwvHmK1JFMIU416J1dI/80OKcKbIs+UnnEvTkC0UXtXWHjfT4X7irz1IZBmEQkoghxi/a+3WwcXMP9RkLBV0gDRkJYWxT0u0PUzJTWdQEl+QzlRwOGj84RVpaw45SBo3AnfJwY+rUU59k6tW/cx/pt10IyhT/Zwq/AUKeJ1VEYtMBPiHyD8mIbyzzKVmM3xLOo3DJiu4vEpLRxhPZ1hzCmZuj1F/EqDTB79AsNjGALNrrgTkF0HrH5l6jaT0L0ZnAFvfpuNtoPYW1apFMFiI7hxiscC8us734rOJug1qDX1U5fwwrMPWCtI/MhtgHrCqYmIsq9r9Lp/iLbY3NMhmeJQ8FsR6sOW67JgjVCzX+GflEx2oaoYbA2X8DupUxFx1nfapB0IQl9ziiLoCa1krdY0Y6l8k4Y3gP24+CZpG/fixcdgu681kpbhl6IOkC1qk1jDKXJcD4C29A5nhZ6HdLqQDUzvUp7MOiS2/oaB+7/PMOnUo66iiDyUKXrWKgvMHTjl9g4oGjnTIJCDXJ1yFV0n69lgG9q91RTalfXREAome0H3DFQqLPgLQhUlMPBI8CkRImIIUbIU+ICZuQSMkqBgHhMoeqwcKpBuLYPa/kslURQcBSpGlBMIK14CFf77wSBRZyWCBlFW8R9r3ixRdnVu2jbwasMSulqogKlBCBBGCghsKSBicIgQtEHLAQFDFXCTHOknqONsHJo+a5jwkoIvtQy4jF0zA++7qU1Msmvl+qqbpJl5iLALWV5uFHW32prBYmZmRyZTlb59bLIAXSrRd7UhDJOYdhB93lI3SphG9Dua9MrV+m+YZFdb0Hp+LpCBINIZxcXsvxfK8vpVZmDtLT0e8isAmtamXmVAmJduTWENvESkX5OGFr6ncvpXuJL12tkjvKeocl7F/BLEEa68t1J9GMzhJ7S1xNlMmwMEClKSVJ5tZNf+N7myZ25dAevLgyXXN56eIwvHFnjk49d5N+865orPaQd7OC1S4C9ARy6FfwWVJ6LCLeGOK0GHF7bwO0OyO+HcBT6czB6SFH+UocnHr5IrTOOSY/BhWnGvrBObIGMyyhXUg5qJOYisnCB/MGEgTKIjyi82WGSpKLNPMI26cgoT9xzgDs3jmIoGBuH0S4s5RSlQocNBsy7KZV2j00PVtQ2YpCg8pJIgKxDUoDtfQEjrSVmIovm0S8QH3Kh24NqFX+0x3IQEeTzIA0EgrIPW24Z0gLIDoQWKqgS2yGRN2Ckd5rNiTnacRXCAKbnYLOICDrgzcOGjdm9H7UUoua+AYVJ8HcTl26i6f0pwgowOgrbuEDXLtItu6jhAmwoEMMQXwR7AJ11WLkOhkZIx+Ywmqe4RqasxFDfd4zO2fNsh/uQ8QU2k2E2Gx6Ht3pEoYJgBGOoysjTIdGcol2ZR5QDpGEgtvuMPf0g3sij2HsiWnYeCnlwc1DeB1s/BMk1UARGZ6GxDs4u6M7o53IuoDQRzTl6cWhnPbhprPvUpNTRJ2miGaPZh/4ZaPdAVLA7J7lt9S8Y7ni0pkAs28zcf5Lm+m9hliTVQ3B2yKFbGYfxSaiPZW6oPlbnHLnOKpElwHJQlonRlbhhyBscxUwfLiyAlSrKTg/hpqhBnVBWsLCxaFHKeUTjPdKLBRLZY7ANnbUcF71JegjKwTB5UpKkTJ82XWLSTodap46bxEQMk2IjKV/mHZXw3aV7V7t5zQ5eVZCZERMgkCgByjAwpYGFwiRE0cuUEEVMPCzlknqWlj7btp4jDBOWAi3XrQF1pQmw7OsKqJNoOfFAaEmwgb7fDQOKZe0ZkESaUApLZ+pe+q1sOpkJVkYuUwtkTrs1m+j3tC0tld4KdMXYNqDb1BtobububCgtJXYVuCkUQu0AGaZ6jsspfYyRsUtlaUKuUi2TFllPc5ro3mUrQuugDU2AZaCr2wiwbH0eqXSMERkBlgr6ZU1+uwLiIgSWljw3U9hWsBZpghwY+nOR6M+JFCUV6X9nen314sXm0UvH7GAHry781G0zfOHIGp99epkP/tBBcvaLxX3tYAffX7x2CfCGoLup6OegFcEJAk4U4ejWMD/8RY+xYUVnSCu17FugmsLuYpuLfzHAjFycJKL8nKB2vWS13qfe2o3gDAlNWoMy6ek2tWMmI6FP/K5zbM7nMUTAQv5OlC3x9s9z/q41fuCrmxTroJ6GOAcSm81KTLVo0TueMnyhRtP0GBmWrE9B1YBmyWVl3CFWMLneZ76bsNn+GgvqOrDeBLkjpKMJa6aDDFImv3WRreE6m4dKhNY+yCXQNDCbAXT6GEGivZuaMfn8ecKGJLUqwACG8jirOVS3RWDauOsDvLFZ7WRa/Qz03gflw5wvXUscDmN0Rpkwvsi6HeDPzeoFTNnShi75i7DtY5aapLkFeO42VHCY7ty3mMj3CSvgVAMs8XXoJYyKlLzVZL1k0j4L5kQCq3latTvYVfkcZ5oWvnsHjEwjy0MsD45i219HqDXS3DgM1aEwC8l+2L4TlofBdfVYoiq4M/prw4WKo3vXUl8vCEl07Ecaa8mgK7IePUNXPFKg3AT/aVh+SFdzsBiPHmTC9OgdAOXCkJngrSpqj7QoGTbLHdj80Qo0xsAe0REf3hLl9Ai7vSZlE0wfctuw/pyBs67Y2K/gIKwdAQR4daCfUBwCeT4kJzcpmzFmvY+9N2K4AVFzlZan2Oqb+EmRHDZdoCiaGPQYqCIBNn2gmIwDB4gJUZTYZgv/RbMo/yr6ZIGlfwOuPufSHby6IRAIDJ0FjJb0dpFYCFxiHJpYhOTIIzFABYTdAMIS9KrQiPTGWSwgtMA3dK6dmde9s8IF5YHqZHFEDuQdnZErgMIYyDaEHcgXsmM8cKp6PGlLq0NEXr+nVdCtF/0NLRs2ShB7Wt5cT6Dva2J8yNKy5l4MBUvHEpmZt4CR6KrsiICZHPieriTnYr2ZZ8Y6Uinq6X5lqwVkxNeIdJVYSD03CgMCoRUrKta3uAx1xTpydX+ySiF0dY9wHOnxu0XYbukM4CQP7VRn/0pb9zjLWI81IXORtvV7vibmkBebR+G18Tns4GrDPftGmKjmWO0EfOnYOu+6YfJKD2kHr3G8Zgmw3K5gRR1663Bsw+XJQpe46tAql+n+N/h70SpT74sQc7DpwOIMjFYkQxeeovfUQRy2SBZhclzQ2ddk5mGXvrlGN93NwFlg37kcg9hmCJPK4x1e1xjwyLJgYTKEEb0o8GbzNK6B7R4MnnNQdoylEvzX5Vm75k2MPfh1jLRGiUnKmxsMnG16Pyy4MHc3+fWzOM4mq4dtyr0Ib8qnEhylW9sP4QESe5Nw3yHE04vkVjfAqhK8+XbN6LvnIFfADG1sGRKYLmJI0XSqGEWJjBVYRXAbkKyTFg3Kapl4o4njgz87j7JLGK0HkbvfCP1DxDM3QnEcVitU64LtQlaZaK1B0ATZxvDaWK7E9gIGE0/B5H5Y3s2KeQ+9oW/g2Ta5yGOo+hBhKGgZBoSS+SSmXNUGqWfcgGizyOpBQW41xFg8jZy6E9YHqKBNtCsPxiGQPwVbo7r3rluG0EAbw0gt3Usyl2PT1neBH2h5X8nSeZqO0hUTJSEnQLq6KlE0dPXEHiC6X8K48E3SIEUMVRmyLtJbkzyc5nH6Pu26YG5YURPAqYRuLaRQASNnQGUELBcG69R6z3DTSof6wyY8U8ANQwbdErV2g2RkiRt2B9SOwNZxiOahtG0iYwO3ExOVfLqFiPCamEM3QXEDglWIpxWbp+q4TheVTFEjZYoVRKGNbUf0OjGxm5BXBspqEap18uEYKt2LiU2HwWXeUVm26d+InarFDl5p0OZXCoVAuw0rzMwQK0H/zMZIfGwChHLxAkmaKFSsdDXTUVpCHCqduT4AXEu7Qqc5PacYGakz0fONNNH6a4lmwlbWFwyQzU8S7Y4skiwfOAIC7cIskswwL6e/PxH6fXJZbq9TyHJ5VZYZjN64MyO9mWcYepPPyUy0bLQBlpCasCZZ7rAZZ+7LZNJoqb8WhpY3q0TPiSrUf4/Rn5ky9GaitPUuYGxp0p1KHXofCh0NFUroSvATPacGMot0SjOtc+ZSlqrXiAEWvPg8Cjtz6Q5ejTANwbtvmeY/fPUMn3rs4g4B3sEVx2uWAEddl1hBtAZmYhHPAGse5A0WVY4H/mKOH5s6w8g/VGyY0J2CzXEY/R8H5D/1LPIoWJ5L+KTJ7msGbIuTSGkSuufYN9XEj02qwwHWhsXuYcnZP6pjbDuYM22SqUkoSgwrRu6DdAOCsErNi2jf1cV753XgXk8on8KkgcDHzfv0q4JzQ0Xc1lkOf2WF4UMR4Rh4RWjunUG0JrV0uTxHWv5/gOFi2h8hNEHZXYhdSJYwO4+QFu8lmruGKNkLqgirT0NoIVVex16UR6B4O6jzRBOCbu851JrElora2jO0pm9AqpLOAzYEeLeAsQs5Jjk+8XriWgLVqayvtYttnMFJUhLDJlBjOkOqtwG7LiCdcTr260C2SQYLqO4mtZxk3SpiupDrDuhuQDUE56Y1zF6f6rEcg94w49vHWN13H4X100xtnuXczH6S2i9Aa7/uZUtT7axaNCCI9OLUyulIEFHUvW9hChVT9/sKCWTOqV6iF69GTsv4ykpXN9IEnBOMLN1PfmuL1Yk6U4Nz7HoqYeGcw9Yhh7IZ0HcET0+6XDMXct1XQ+hCtAvS8SFwhiAxaGw/zA0rHar/1YTHJ+jEJUrGConhUa0O4A0hjRIMNkDshc4MWAdS8mlKuwgDW1LNSWo2DGwo1mG8DqsDgaFyOE4H11ilWvMRUZ9+AsoGoxFTmwS7mlKf9yH2kU/0MM6GVNR+trhc980IvWr/m7CzaNvBKwvqv/t5FSLBFAmQxyBFEmLgYpAQ06dICUsV6A1MImGQmApWDR3l4yZ6k0wATfQmWsHQvbDS0HwmaWf9s66ed5SCsKXjjUw763clI8JKPxIBaQDEmiCKQFdpbVOfg7zOJE4t6AtNlHOh3qyzpO73TbLAesfUrtBmAmU3M6gKshYRBUWZVWQlBH0oBlq+TZZRnGTElsy5OQq1W3Ww9fxwtbTbATMHXpaNLEy9OSCzzUcv0MZXqqyjClY62onPC6Ebgx9DlGSpRwZgQhK8Fpp/M7zYPAo7c+kOXq14960z/O79Z/jWmS0uNj1mGoUrPaQdvIZxxQnwxz72MX77t3+btbU1brjhBn73d3+X22+//W88vt1u82u/9mt85jOfodlsMjc3x0c/+lHe8Y53XNb75gxopLC+aJILhjC9KulsGWMgkbLFMavEoUfzXPuTHo7SBUOVh41bYXw+pvYoyKMx3ragVVEsWgb5eBcT048xuFvhugnXmdB5JKH5jM3ZlV3khYQzbXhLB6hTyPf5RtlErKRcIx2K8x6LdzvEQ3vBrRIOF/B6J6AfkuxK2LquQSExuO7BRZwzFkUXSnl45NAE6fDPI7on2Hv8zxkMVVk98GEQBZIb7mKtVCKdrkD+CMhFVMGHeg7G3ga9AYSr4EqQE+B7mNtHGDn2AFvdlGTf62F+jtgvIpJH6UcGNbuFfeE54qSuKwnyIThmwqAEIwbRdT8P0SKUKtpMqj9EHDaQ28ukpTnYmgBxQLuKmg9AuAjVWyGNUOTxgoDhsMPQ5oDGAHIRoHShALFIOm9jXpBYtJEzOVQyTpgGrLotkqE7oDWlpcu1gia2ZtZrNlrRLqU58YLJVJrqqkmEJsdxwiU5JEaoqxJ+XxPoyAfXp3jmz5lb+DI3ntokAPzSNuYjBsGjoxyIIg522oTXwMZeRWk5gBJsvx3MJdi+0SIZHwXlYvZOc+uxNSb/qM76koFSZVJiopE+yR6JNQJbe+FMAW4YgHoYzCMO0f6E0QnJ0IaBtWWS9HVUSaEhKezSRahcQTLVWCEE5g9v0kthcEqvT5Mi1Gdg6BDYDSjFoDZgMJTSXd5C+MMULlsCvUOAd/BqhY3CJMFAWCFSSkxp4DHAJMZBZP8XlBllYObp26aWCPdNaGWqkTSBUqpJbawgn8sIqo0mjoBvZ/2ysZZJ2za4tlaqiASk90L2bTHH8722dlZ9xYAAMEPIbUHU1z27rqXj2LB1j640IXG1RFqhK7FOUcusLylfjAIQaoI5CPU1mCnYPcDKop06ECR6M7ARaRKfkhH7TO4dBfraC3U9ltTU2cIq1iTXQled+66WiQcxtBPohOABm1JHS0nQvzAMjCBCqVRX6F8z5Bd2CPAOrmbMNAq8fs8w3zqzxZ8+fpH3v+3AlR7SDl7DuKIE+JOf/CTvf//7+fjHP84dd9zBRz/6UX7wB3+QkydPMjo6+h3HR1HEW9/6VkZHR/mzP/szpqamWFhYoFarXfZ7e0QkCZQPpNzUP4N3cogLWylGUkCxF992MY/EqIeOMXwrbDkQV7Vx5doQrNwNteshCRSDkzD4Vh+jJdm+RpK7B8pHdCE1OTWM3TeYArYMG1mugLQx/A26SM7Xb+em5hNUjW2cmwKqNRO6BszksJMBdTdBtuqYgxaqkJJflhSfyiEmQxiHE5HJ0syPgLGX0rd+F/NMl2C3C9d4IMow8XrSmWshOA/NZxFxAvk6FKogKvpht8D+KeiMQHlA6hdJOc+eY9/gjFkhve4tML0PVjcIpy6wZtUouE1c32Pg3Mfo0v9NvzrHoP4rMNgFRy04sA9O1LWia9SF2n7ScaVNTjYm4WIPDnngeuBOgz8BeIiNZ3G9GBcdr1ly9HoyKNkc3TVFUB5HFXdx5J4V6AniylsgfD1JskRv/iJYe/X12SYUyroCYaN774JAm9CYaJMXkeoqhptCJZ+ZlGXE2Hb04lQEevFZEJibj7P3yGe598gxyhdTlseAHIw+Cd4Tw7jhMO3aWdwShEuQ9yC3DifuLLF2461Yt0pkqQnUYHCO3etPYH8zZaUPadGjaXfpj7To3GXg3WlyeC3m2j7EPd1KmC9BtGTSWYIeOcykRIhFgI1Jl0ajST5IqStwchCPgtMD0wC1DfVxaMyCvRuMCShUwPFh+2nIhzrpJCx5DKIlzLR+mXfUIPtg/ya8JhxsdvCqhkCiMEiBlJQEhcAkIMYHPEx8DApABLEJganbNkum9gnwM+m0UnouAT0HWTagdFsIaCKphK74Wpmrs0A/0lRzINvh+SetzHVZCC0TJtVEWsZa0mG6usfYsLTsObWzuKdLhlRRljGeVXFNQx+bDvR4pXzB5Mok60dWeiNRXTKzQv8pE+0SrUBPron+u7AyB2mhCbI09HFS6Edk6bGHCQyUJr8B2iE7SLT0WQJS6Nhfpb6tSv/awIvNo7Azl+7g1Yyfum1GE+Anlvjnb9l/2YGLO9jBy4UrSoA/8pGP8HM/93P8o3/0jwD4+Mc/zuc+9zk+8YlP8MEP/v/Z+/Noya76vB/+7DPVPN956r6355bUrVkIiVlMBmI8JAQIOLZfOyY4ccxK7LCWY2y/tvGU/HjtOHiKjU3gBx4BmykgkACheW611OO9t+9869Y8nHnv949dapCRkFogy6jrYdVS16lzTp0q7tm1n/19vs/zX79l/z/90z+lXq/z9a9/HdvWRhG7d+9+Vu+dyLpkkzB2GKZv9Cn97Tr3/X2CjkpTVSNsR5Ku2k/j/yxRCfuMXA3LBqj0oH0pDctJbai8IwWJZMxo2qN5mY5ezC1CVINk1ISkYibTYGXCQe0fBQnSKlMtXo1QDollfb5kApwvSnhLEvyI3FpMZfM6UlRhu8lLjrWwN6Ebm5xejRE9qL2iSJybg60v4fh1EoBbHIGCB5anV+DrW1qO54yjej5q/EWQPApGB4we9KtQm4T2AvjjEP5LasUG6c6nMM5FxGMS2g+hjt6Iat4IbogrzuF0vwadDYJ+QDZ3gt7II9o0ZT4Fi/tgwwbPhsYBKO/oPrRYaKfSlg3LEex5GUx3oT0GcomJ3llm6HM8nSbMjBMnFpDBCKo/C8aLYckClSFMRTCVhcDWkrzcIQj2Qt3UhlauqSsTtqMrGW4IxHoCZkhdfYlCHWdim7rEH8d6UmrEEPRA9CBtQmSQXPw0b9z6KAfqDR4qwcYoHHPgkhOg7sySDgwalVOEYcxOw2LxUBpvzkS9dA/hSy6DkQMEGROCdWidIhM+xuGwS+0INK5q6L+Z8TXCPKikw+Q2XLIJuTPQHKgE/Y0EQZQEGeNKB0WEgYNPDGRJNQxqj3bIjXvYByWlglZjiiOQL0C2B3EeWglNeI0WLH0Zdh62CVwTG4+OI5HZLXqtxAXeUQFDAjzE9yZCTEIswI+Mb9qm3fNDPELaGAgSrKMiFzNyifslbXRlKMgn9PhWM7T8ORVDztXjhzIhPaL38yL9X1NowyiSujrb3tTjjiWg09VEMJsZZOGaoArgONoIgTa4AdR9vYBpJMFKaaWLYepzxqbuw03nBn29LbB6ulKcr+iPqGItPRaRvnXbbSCEbAWSfe3G11K6KOsYulUmHlSM44EkOkqDSOtFwsDTzs+BoZ0lYwPMInQdCAT0PGh5UA+g6kEzhLrQsuh+Xxt3RRIRKxxDG1fHF1PxF3j6cRSGY+kQ38t4zeFximmbjZbHV09Veem+kef7koa4SPG8EeAgCLj33nt573vfe36bYRjcdNNN3H777U96zKc+9Smuv/563v3ud/PJT36S0dFR3va2t/HzP//zmOaT/2j4vo/v++eft9ttAF78Sp/x3eB40PYgVYFJJhlTBcqsk1BltnBIH99L+Ogj+NfHpGNou1o55qTAHcQ9TiYUU1ecYy2v6FwnSH9Gsfm5MRpenj10KR/ZpHMALlkNqJ4TNK+ZAOlAfgxrZ5VCoGgmBKWTgvXlLPyECaZPYkIxsr2CLeFc0qA+63D6khTOVpvwq1rR664a2It/T6p/ln0qoHo0jf+S6xE7d2K3TyB9QewkUPJKiHZB/rCuuEZAsAKyAX4X8r529Gz1IT+CzP5bVuZ9pDoIm1Uq1Qep759F7bkRHg6R4R68ooLeGdqHaxgyD+kOFLThFlFPl8zVOiRqUDYgndCy4tka+FO60u0egq2uzqvsV9jJXUXT8HCT08AMdGZ1xbhf1tUL09C//54DYU5HeiQy35Q7OcietJPoHU09ETPQ0kLl64mbFeo4kSDWzqShpyeVYaQnhiKGVgC5BIX1v+T7a39F3LL40/w+/P4Wl9fb9AogquCoPg0R0kuHrO0XLL58FLlvGhiDkas1wQ492KqC6kJ7g6n1Kr01rQocacKoAZkGWB0oxgF2HXoPwcYW0LZxsyFWO00Yj2EbfXIiRKk0XQAEGXyEyhA0pum0XDKVk4z9cIzdgHYJjFGQVUBAaRXqD8DGMcGZpUnqcRKHEIc2FatPylCkRYs7L2jyOVhgeEpcbJWcIb6XIKUeNrQxVkwkJKYyEUBgeJiyh4EgpoYkxkQiQwPVz+megvygiipj7QydEmD2oJwCy4HOoDIcepA39A+IMHSMUcrQBPFx360g0tVbw9EVXgKw2oA9qOx62rQqB+Dp9/UMXak1LE2kpTkw+BtUZ020E7RpaKmHCABfk1xTavmzPbh+hV4MRAxUQtoMDLemX4+FHiejgX/CoKhMP0JPKUzA0YuJngFtX/cBKwbSaQM2O9DxtfS6L7WBmJCgBEoJfCXPt0VfXHi6cRSGY+kQ38tI2iZvvnyaD319iY/fvTIkwEM8b3jeCPDOzg5xHDM+Pv6E7ePj4zz22GNPeszZs2f50pe+xNvf/nY+85nPcPr0af79v//3hGHI+973vic95v3vfz+//Mu//C3bE1lwqxAoqCRhYQb6aR+/v4ZUdSyVooYiJ/vM1BWhDaMmJFzoZaAhtOKt7cJcFza+P6I7qduwyufA8nNkmSbIHsecgbAGqftGUWkL3j6vJ0ChBVs+IhmRt0PkWRORE+D0IJFg6W2vJCO/SHqzx0NX51E3wFzYZtfDijUEo0VFOl2FE1VyASTnBfcdvA6VWmDsvv/FQbVOlIAHkgfoX3L5IJbCh2QGuudg8yR0V0EF2s300Cgsz4HThV4eOfODemKz8hBlL6K7dhq/eBBmR+F4CkrXwq5J4l6FeD2tNbbRMd03Kz09eZoMYKILRhMmZsFPQjelKwWdImwmoJ6ACQ/CfYQcJKykdG5m19YSOt/XPWQlB0hqKaAZ6T44JcFrgbB1tdcZRHLQG+RfepCydMXCHvSwOb6eQPqmnpAFEYSunpBGgTaIOVcHq8/sQ3/J/vAO7q1M8dilP4GzeTu77juDmIQFE1ZzkBYGhiOx9gm8V2RRk5eDeY3OCbUVxN3BhDGE3g4jzVNMnQtJLcHsJlCDeER72dh9PQdu7BiwngY/JhAR2VYamWmSn22QntMGru11A2c5Q6KTwcDEFAGWauLKFmxIwho0U7p1L6pBs60L8duPwPYDsNUCWd6B+jiNOI2JhRPlSBs1SmNN2LqQOzrg8VzVJ8dw0jbEP1/Ix32aUCBAiscdojUZVsLDUAJFexCeZECYHoxPSi+WCYBImz9FpuaBlq3zgR93iooD3W5hDoiigSagauDmLNGE1hjkAqtAS44Tse6vDS09hj3+y60iXSbtD+TSkoGRn6nPa/p6jDOSuupsCN1nLAL9MAMtkzYHyhcV6zE1ftyJOQkM4o/CQZ4vCb1aEMoBAR4w1S6DzyO0LFuiZc69QWuJYWl+FxnQcHX1OQjB05FHwlIoDFCCSF2s48XTjaMwHEuH+F7HW66Z5UNfX+KLj26x0/WHMughnhc87yZYFwIpJWNjY/zRH/0Rpmly1VVXsba2xm//9m8/JQF+73vfy3ve857zz9vtNrOzsyRjzXsCU7dtmSbMzm+ytAR2d4oyLj4j+CLCr0vsPsi8ns+YfZipwbkEJP9B4H/Fpv0DARyBTBW8BbBnN+lHdeazTaJT4K8W8P1dZLa3aHXkoGcqQCUcpClI1AQ72Zj8NR2K575Ks5dDXn0Tx8q7ECfvZ+z+exj7aJPGWpJay+LIoYhqF7IuJHuQz8GDe5MEs4cxqmcZP7HDZBW6ByG+egxSEbTXtTlVR0FrC/PcQ1hxA388rx2SkzZMH4bUGJQr0Llbx1zkRvBWU0ytP8bi/DQUr4aDWV1arD4M8nJIXAf1DmRC8G0gr6sVoQOEulJ71oWNCQgyOiLDyEIhCST1RCgGEFo6bQ56xMxA99Cl7UEmZKgfcQ9aFlSy+hgjGJjKKEjZWgooAyDSLqdGpCd4KF3xrhq6suGYgz61cKC5iyHVxnYeYNfpv+dSf4nbL5tka+bHoTtBqnqKuSlJNw3Vks2OhMmHDHYusXnkhpfQO3QNmAXoncOon8Jc6mN7EZnWBmYckCv3mDvXI3cfBMtgD2I51SABxAqh0RUYjQl8ZRHTJ51qUMq6hEphmHpumZkCe17C4Q6d+7rILYExoXCqJqJZxl7P09hooQ6BvQrNcUhm9ZzX3g9GF+yHoZwOicIttpslXNL0gIoKueSCqy99+LY/YxdlOWeI7zEoC7RhlYVnDByZpYdSxuAvuEVMTEgEbRNsF3IRrFvQcGC2ouN+VKQ9BGoDF+exgh5fnYTmOG40WLzraFWIMeiVjUMoFDSp9Fv6XAziidwIPAtGHE2Wu+ixCwPsrh7DpA2u1ONlXmqlkVRgdQcxSKYm0ImEXoT1+lrW7HrQaWnlSyalzQLjEGxft4LIDiSSmpjbNrQYVGxN/dsRxVAsaPmzh/4N6ISw3tXHhApWqlrm7Eba3TpwoeXq35goRvgCdb4R+mLF042jMBxLh/hex6HJPEdnCjy42uL/98VTHBpxWJiC6xZGMI2L+f4f4p8SzxsBHhkZwTRNtraeWGba2tpiYmLiSY+ZnJzEtu0nyJ0PHTrE5uYmQRDgOM63HJNIJEgkvrWfcXNFc8L0gm7XsrIg/6VC/IWJ1YmYYQVJl6zK48Q2cRTiA2YabA96FiRPQfwJE28lQ6RijOtiwhXorhn0x10Oiz6VkqJ9RpD0oIFLwk1p2Rl5SPSIeyZbLxKMLpuQV8wuhCT+4Rz3ZD9D/W1zqNkF1NlHmVpscmYrS84tULxsg8ql0Pl7m54hacoYMQOd8iTGdp+rv/4xEtkAYUC2A2OLD7EhAmLhY3d3CANBYqNGesMFW2Eon6zYIVheo3WgA/FhMLfAOAfxCchcx+b4Pg4s3U/h+NdoHbLAXIDxPLS34OQnIH0dtKe0tDl2wUvpiVijDCOzUJ8BOQZuWveVJeUgMkPonjk30v1pLgMVnYKyow2pEoPcTCetSW3ShjilpYZJS0ujC6aWE8qulhN6fR1Pkoh1nEcU6YlfO4aOACuvJ2O2r8v2vW2EuUomvo3JrYe5dG2D+sMR94cZupvAa2owPkJj4loeENu0p2YJZgUHP/QoD+2fZu1nvw81cQCq2yTP/QOz28e43O+QtRQy0Fw7kQD3BGze4hCGESkpibNgDubMUQuMcQh9aNk1jFyA3XAwfRM3FlhCYtkS34Depm4/LJngdxJU3QT9NQvbHSFlbhApn/IyzFyhZdZGDnLrWkku9kPpckjeqjh3s0GiC7PUiIAVfMBiy7owp1FBhPg2EzeFGk7bhvgegK5ACsn5bF6lTJQhkYSguuddiYXKQixQvq0NB8NBP2vS1G0Phqv7e80UJDzdYuIAjqWNr0yp5cxYmniClj574TeyfjE0H3JDbXKVsgYyZUMv3rmDXlzb0eObGOTIKjGQQVv6uecNeJMzyOP1NGF2uwMzLV/3+aJ0lB4DMywbTbYjU68YK8BV4Aq9FukD0UCa7Yc6SslFP3ypi5WhoavkPbTkued+U4PvwNhLDL53nhhPdbHh6cZRGI6lLyT8wA/8ALfccguvetWr+Ou//uvn+3L+SXHJVJ4HV1t85K6VwZYzzJRS/MIbDvG6Syef12sb4uLA80aAHcfhqquu4uabb+bNb34zoCu8N998Mz/90z/9pMfccMMNfPSjH0VKiWHoycnJkyeZnJx8UvL77bD8JYPcqCS3F/KXQmkfZBdg11tj+n9YJd2qEvt1sAycYkQgwPT0Qnwmgu4oRHeD40p6BDg98JpgfjLNzi0HCUxBK7NC+OptggmFW/ex6yCNKrh79Kq6FaJUzMaUSbYA+a0M4stNjt8/w4jVxE3+He6/eQtk27T3mOxu9vBmPZxXx6x70JsJ6VwBm2V4ODeKN3Ej0MGXPtZxWLTg5GiO7KLHkd6ddALB6KZiIy/wLUUvI8CCEAPpxUy6LcJHb8XddQqMJMrqa/lxdolw1yVsuxtM+hv0qncSFdNg52H0MLi3Qute8K/XlYEgBTkb0jGEGTgxpyduyoBECoKarvYmfVCOjswwU3oilEpALwLD1lI9w9JkOGeDamvduXL1JNK3B3Eghp6IhVKXUK0Ich3t/Bx5uqxjoqsfdl+r+twudFcw/HPk3TtJyBOMWDUOnOuT6CgaBqwbJpluDrNV49zW/UQLR1AHLmX78C6M7A6Xf/JvQOZ49L/8K1RpFLaqFFf/nmurDzG+LSnnAFPPif3HoOaCtywwGw4JMpi7mtiXKrxAe2MligMjVldRTgYEeYWZ8jG60GuNkFQJZH+N7g64SXSObwdEIwXRCGnh4VXWMRMdsmkwO9A/pa8hfRrUKphzwCQk5mDmJ2DyFZKVTwZs3g7xToQhp1Cqh9xqAO1nfD8Zz4AAD61bhvjnD933a6hBP+rANl6ZCmUE3+jzlRKTLEpKYh/d5xvb0O/pMc4wtJFeBIiUHncSQkuIsjYknEFf7kCGLFy0ksXQZlHKh0ysx0EM6IfaaTqHdlFW5mDBMNISZzOnc4DjUMuclaFbLhI2EEPU1dIRDD1OxjUQTV1wVFIT56Slr8Ft6THVNsAW2iAwdPR7RUr3DUXoXuBAaZKvTF2x9tFE/3GHZyU0Ke4bmjR3BpVmLx6k+XwTAYZBv7G8aIucTzeOwnAsfSHhZ37mZ/ixH/sx/vzP//z5vpR/Unzu2Ab/710ruiNDwe//8AEmRkp88NazvOsj9/HBt185JMFDPOd4XiXQ73nPe/iRH/kRrr76aq699lo+8IEP0Ov1zrtCv/Od72R6epr3v//9ALzrXe/if/7P/8nP/MzP8B/+w3/g1KlT/Pqv/zr/8T/+xwt+77VeBqMfU2r67A8kI5cpWgZkroTx10lqXwO708LMKcIFbWZsZgChVW9sQScHzqhJW1n0fijG2wehMklEkI+blG+sEzcE3VuzrPUErjBI7u5hxBEy6EPaxGiH5PyQtp2i1B2hcbyPHwpKoY1zTwP3zXUYiTl7eJRUuU1moYdRgMMxpF8FZ1MZqokZgpkboLALVr7Gw/OjzGxvk2ooghJ0ciZOG4y6giZMuwp3NzwymsSIPZxIkgh1AXV2s0Wn2sKfEjTG88hkFhEso0oR2wdfRmfzbrLVszQzt0O8ArKEDdjdP6Mv9oFZhlygJzQZBb6B/jMLNDE1PEi7WvIsi3r08wGUnggpCamB7C9p6CouSpPkKK3NZSJTTxh7faiG0MlCvg2ZQLufmkX9vm4AGQ9qgZ5sZS2QDmbrbspLn2dq+1Gyu32ikZCGpTjQHPi7hNDIwPJYkhl7h9y+CCuuEhXWIbYQluSqhz/NXtHgkz/1WtTkKGwtU1q/leuOHyO9I7FLEMbabZlA+85IDwqRoiZcnKyHV1CIQG9PV6DQgEQA7n4IVhW0BbalqHuCtCpiJXqQBrVtYBYksgx+BfLTLZp1l+KlPkZJ6fWECFo7kLgV7FmtUuwsQup+PT+vH4BuBdJ74ei/g/F90Pp4i9pKipBxEnEeePgZ308W376PRzH0Lh3iewBRiBJ6GBFGD5TAjCxiqXQkUgRShCjDJ0rsAJ7uaXUHapVkRsuHt0OYLaAdnANI5CAZg93Wcum+AXuy2ufAM2A8oautthqYTaFVKoajq7j5QfxQL9R9wDLWbSCiCI4Ndk/f5EEEifwg2zyGoKFl0RT1OCtDsJQmsrHQlWACXa2OEoNejB7YGb1g2O7p/WRKt6IIA6wEtBsDdU5qUCEGqoPPa9h6zHU9TebbPej2YWMD2i29SBCjF1f7PV3htkAi9ALDRZX7+0Q83TgKw7H0hYSXv/zl3HLLLc/3ZfyTIpaKX/30o7zq0Bj5pM3f3r/G5x+r8YG3LfBH77ian/zwPfzaZx7l1YcnhnLoIZ5TPK8E+C1veQvVapVf/MVfZHNzk8svv5zPfe5z542xzp07d77SCzA7O8vnP/95fvZnf5YjR44wPT3Nz/zMz/DzP//zF/zeXebpqS7t5hidhzZJNZdQE1oNO/IGyBYgcVphm+AchY6t5xHhDmTXtXHwegn2/9uQot9i8VqI+hbjhQ6jUZVsuYM9GnH3309irOzmLHVCHDJrAhUm9Cq5pUjsVBl/TLHRNJAyQLqSCWOHgixS6iZoxX3MDZfKqSaldswlEtJjMDcJX0kL1vfMIIM5RHcHtdMh7R8j57awRyFnwkE6uB5kepovbu2CShNGe3BN2qWagJWkQ8MIaSmY7imyCjbcHKqqICmYYh23vY1ILtMo7cIzFxByG9Vogz1OOH0Jk727cFd+herY/xfikl4lyJqgUoPe3YHLjOdrx1GkdknFBDOpq8YyhkSopX2OAAJIp7SkOuprc6vO4DyxB8JF5FYxrRWy4QPk6ut4RhLlWKg4JkzaRPYYoTFKLCrQLJE9fTeXrXwFy+0hm2Dk4WTRZjIpyVgxmxEYHRNjIcbcBSN1xbqfJBjtM33ff4dVxawdMil9Pnf0KP2FK6FTI/forRy562GihMSvaF8u/w5YCsEoQ1pCMq1VjI4hSE5HdEd0IcauQbakFyCEBckJcFYFQdOAQky+JBCbHZKjNXoGJCMb6iYq5aLKivxlkpEzHqqq/cuiHQimdfTnzmMGuZokykC0Dq1+keyfpSi+dQPjMEQVaESQfilkgoh9fxJwvF/Ew+ZCCPDjiaVPBcVgnWOIIf65Y+BXpZREYKCE1H/catCjqmJdMVU9TdakoyugKN1jIC1NFkce9yUY9MNGCjKmdku2Au0MHRsgE9oBzxic1zQGJliDBUEZ6Zzf867Ljn6vOPyGA3MU6ms3Bz/pSg2MrKSWRpsDl2iptDxboYmr0KZfGMYgf/hx53ypq7GR0AQ4Uujpghj0JTtoV+qENvgLYn2DqwE9a3eg60G3B7WG/m+vo1tTfG9AvgP9XWIMvnN1UZNfePpxFIZj6dPhl37pl77F+PTAgQNPaa76bPCVr3yF3/7t3+bee+9lY2ODv/u7vzuvZPxm/P7v/z6//du/zebmJkePHuX3fu/3uPbaa79r1/G9iLsW66w2XH73rVcQS8Xf3r/GF07U6foR+ZTDu16+lx/64Ne5a7HO9Xsqz/flDvECxvNugvXTP/3TTyl5frKVseuvv5477rjjO37fDSbxKDCJxbZv0/KXmMxotVeqCPbLwBodKNDyIJNwOoTCOmQ/BzM9k/6IZPJqhTcHJ0egcm9E6t4EaauGuqGPfxiSt/j4ZoPROEPKdAlSkjXVRSWTEEpyjR5jdxSINy/hrFrGiSuMZXbAb1L0fWhukLjP5bLPpunio/IGoy/2aPdhKlQcOX0SOqeoFQ1qlQSjZ3rs24bSNCQrcFdRt2zlFLQrAhfBeCypd6BREuS34HojoD8Oj2QsVmYtptY9LAlR1UU5YCrBrB+xo7ZJOC7u2DVgTkDKhG4bMjnWbvg3zD76Mcyd/8h2+j1I9xD0FIQ9TYRbg0qDP+j1jQYVhcDTZNlMa2KcToDj6sZsGaJluKbuZ5ODHrdokaT9Nfak72JcbZELI4QTs1WATsdmw5qjL/KMtU9yTfwgNWkQtQyCbYGVieglFK0VcDIwl4PDhKQy8HUBrb0OmSmHaDKHe+kPck+7hYq2KWzezfTdbQqP5pm82uOzr72axsEfRIgG+btu4eiXjkEoaZagkYQ9MdiBoFYXuA2DvG8zN+mi+gZmbNMlwjAhXNYJVOUpiMZBLWpPmnhaIRMxiSaoliKTrGGPRHhnoGtFuOEkm2sBG/0Wk1e42BVJdLuDii0CQvphSGYMKElUVeBtW/T8LA32MLV2APvPvszkazZJvV6ScKAVQfEA5Kc9olOSbS6sB3ggrnxKXLxdfd89XMhk6o//+I/5i7/4C44dOwbAVVddxa//+q8/YX+lFO973/v44z/+Y5rNJjfccAMf/OAH2bdv3z/J5/lnDQlIU1eDLanJo1JIDASh7hH2PJRubB30+/ZgJw/kdEtHqwbkdSTbVgPSFkwWoR8AXTgnoGho06sg1ot8Rl+Pj4bU41/U0yQ1Pabd9dsxVIyBAdVAuqyUrgwnU5BJDPpyQ93bayTBHLjRi0FkUcYGhDamsoRelTMdvWonpTYMCF3tiC9yWq0TBNrAS8W6fcQsAI5+r15HL2yGA7dnV8LGoh7zaxLWqzrnNxkOsoID6Pr6WiyhTcEed7++yPF04ygMx9JngksuuYQvfvGL559b1lNPdW+77TauvfZabNt+wvbjx49TqVS+JakEoNfrcfToUX7sx36MH/zBH3zS83784x/nPe95D3/wB3/Addddxwc+8AFe+9rXcuLECcbGxp7lJ9OQUiKf4/tFSolS6lm9z7c7dqvtArBvNEPaMVkYyXB2p8ff3rfKO6/fzb6xzPn9Hj/+253vqV57su3/eNu3e/69+v0+m32fq+/3ybY919/xhZzzeSfAzxceJcZGEBFScMd56IsFxi9v0S9oE+HEGKiOduo1H4N8HsQsrGzDiS8UqbV2E9Om+3877HtHlStqcOZjFitn9zFBE9/qkz0I+/9lndxGg9VFhygfcfbFBjIbDBw9QzJhC3N7Dy1Vp4okQZqyo3BVgBPGGNtnUX5AOy5SJUM2WsVMeGw8AIkm5ISiNKOoVxS5NZdRF5ZNyAfQr2jFsdmDh0dM+qNj0LZ4zF1HzCapT48hJpLk2x0SiS6RiskYXcIp2Ntss+obdBI2ddemZPg0EyYkPXZXv0KrmaJ1yUFkvgztO4kLL2XpyNsprn6aBe99rNT+Fb5/CTAHtYwOWg7QWmCjAfkOkNSkV5h64hRFerKVtQdmWKbuITN8YBtHHqfSv4MZ6wwHUjsUkoqGr4sud5FgM5VFpQuowpUkFtdJmiGLHrAu8bclbhoaeYPQNjhsxVRzgpPTJhvFEiNLdeqVQ3hXvoadhINRvRmj+Rhy8lUIv8zIfbeSPGORnerz1at2Ub3mx8ie+hpH7v87yg/2iQOFyoLVgmxXF28Klym6UmFEEnWvot6GhCNJyJDIFGRyilIIom/guZKwBKmzYJ+DvgDLA8eBhC+wSpK6J+hFBnY6RrUiLDmJqu3mzFc6jJZOMR5HCGkRWAInEWK1IG0adLwxGmTpUqBNkpCI+dol9D8xDsHDJG6MSFSgGUE37RLTo0P+gu4nhyEBfi5xoZOpW265hbe+9a28+MUvJplM8pu/+Zu85jWv4ZFHHmF6ehqA3/qt3+J3f/d3+fM//3Pm5+f5b//tv/Ha176W48ePk0wm/6k/4j9DxIN4okGVFO1CryvCEZZ0EAgUPsgWCklMDRsXixRuq6wlw46le3BTgZYrC3vg+mxqIylP6UE6MTCiEmntWyDjbyz8NU2tGgqVljo/Th5lqKXKuQnAGMQU1QdxRgzMpRSEAwWNYUKvoPtxg1i/Ll0IO9oIy0Bb0ytj0DPsDqq0oc6I94CuqXuLlQn9+kA6XYG+q8lxv6UXP3uxrvyGru7z8KQ2ygpCzEGVXUhFJNVwgBjg6cZRGH5VzwSWZT2lmeo3Q0rJu9/9bvbt28fHPvax8warJ06c4JWvfCXvec97+Lmf+7lvOe71r389r3/967/tuf/H//gf/MRP/MT5lr4/+IM/4NOf/jR/+qd/yn/9r//1gj7P7//+7/P7v//7xLEWvzcajQs6/tlAKUWz2QRAiAuTIn+7Y5NK6xfuPrnGZVNZfuCyCv/9yz3+7GuLvH5flmMb3fP71Wq1pz3fU732ZNv/8bZ//DyKIqIool6vf9tFk+8Gnqvv99ns+1x9v0+27bn+jjudzjPe96IlwAIbRY4RQtrU6d9xGRsnbyNxtcKMdaxioqHnIW4aOg1wpuHYmuB4OYtMQaHqM75ZoHJsh+lIsXIyhUeFlkyRWdrhUN0jcyP0hSLR8XFXYGsmqxtDpQ+eILBCdnLncDqSOctE+AlUD9oKksUQ4W6TX0yRYJoRamQzbdZPQrIAnimQlmKlAE5GYfYH5p8ZrSD2JJTScFc2j8r6CGUCLo29+1Dz14BdQqVTNBNKS5D9Hu7Zr+GvPYRj90mWJaEp6c68gvr6HSTrIe04jdHboZjqMLZ2P2d37SYKK1ibn6XSt+mZWdoOvMT8X6RyBsf7JVbas9jrKWw7gWhUGTF3UIYLRpogytES47ilXQSZWQwnxOmu4oQrFIJtsqMuth1TpMVIocvBtKTna4VdJ4ZeGu6RCbaaZSb6dSK7jYjWSDcCbKFY3WuSGYXZVMxpCaVIktqtDak3JlK4+Txl2aXfsfAOXQ2Tl2Hf92fsevRefBtqo2cZ7/S59G4HYXncf2SGpWt/jJH7P8fLvv4ZSlbA2X06XkgmYDOCGRfKba0MHIuhugHOlTGOC04IiSjCKIKVgmwevEDSVeA9rE1hazHYqwILRRgLgj2SmUth/ZYi3SjFeHqDAh1COiRIkg5mibcuo81J8laXTFpi5UBtGWw2KvQp0GM3PXxS7JBlmhiTyL2U3qe7dFqnyb1O4WRhpBwhxLb+Q7oApNGePk+FYc/ad4YLnUx95CMfecLzP/mTP+Fv/uZvuPnmm3nnO9+JUooPfOAD/MIv/ALf//3fD8Bf/MVfMD4+zic+8Qn+9b/+18/9h/qegEKoxz2Z1EAyHIOQCMyBYVE0cHM2EaqFQYQhI0Q/i3KCQd6tr+XOXQ8yhq7yhko71gdA6vE3EdpNWpmDzF6hGY8ndZ+tsjRxNYXO7kPoe9UcZPPGgx5aMTDUEgNzyDgckGKlF1+DGCKpb9o41iSVAWk2lO73UYM7OpL63F6kSbhv6uozsb6xI6Gdnt1BJbrrarfnvq/dp+XgvaNYGyOE8ry5tRgotC9u4fM38HTjKAzH0meCU6dOMTU1RTKZ5Prrr+f9738/c3Nz37KfYRh85jOf4aUvfSnvfOc7+fCHP8zi4iKvfOUrefOb3/yk5PeZIAgC7r33Xt773vc+4b1uuukmbr/99gs+37vf/W7e/e530263KRQKlEolKpXnVh78eCWtXC4/oRXxOz32VaUyM19Y5iP37/CHl8zxjhtz/MFtayw3PI7VJB+9v8ZsKcWrjuw+3wP87c73VK892fZ/vO0fPw/DEMuyKJfL36II+G7jufp+n82+z9X3+2Tbnuvv+ELOedES4AQ7zDJCgh4BTaL+GGc/UebojdqhOJMA5oAOrM7ADtCpQWVTIItZlB0R9hJMd2E8B84KpHshu6RAWg6HUpJ9d4K3Lpg8pDibBqsP+UmJG/g6AiOSRA8L6m6RTKFJZawNJ6ElbIpRkfY1O6i8y3SvTUqkyTvLJEYikgG0UtDbShIUQtxOxMj9kHcU9gKMbWqDo5P5EoulawmMXRB39Wr/eAYmroR0CboCEi5kKhAlYb2HnB6l45vg3osjPTJGB29snPXRHyJz/18jgz5ni1M4+S573Ba7uissT95A6L+BOPhL9sRnWcxNcFe0i8nNbczRTabGNxk/A5M2eA3obwsCFDYdEok1RO44XkEgK4KCA5ap8BuKRaXnjKJg4jYNum3JZzKCyzOKdgj3oNV27UYa01fsWvQxLehNaW+sRBIa/gidXIzd3yHrwV4Bk31oTMNiwiXbCJivR9TOgZz4WzreKkbrHM5pSaYLh65aRCxlGWtMsvGSJVZfcpRLz36EF506gZNRtBdgIq1jMpddCKehdwoydUhs6XlmJQXRBJQkyLb2kHEKYDW1uaqfgLCmCzs1A5ICkhml2/CEwroM3H1QPtFlpxmzUy+TxyUhspgKFNtYHMTnEH5URbRd1OImnp9iQ46RoknESdLsxcTCok+AR0SX0JvF+lqAN36O4DqFqCgmrTpuWLyg+8lhSICfK3w3JlP9fp8wDCmXywAsLi6yubnJTTfddH6fQqHAddddx+233/6kBNj3fXz/G92H7fYzdwl/QUCgiadSCBkP/qZjXZGzLTBchLdMRIVIFVFNIKhDsAaprO6j2RqcJ5T619d3IHagXAbVh24dmh0ghlKFb1geNcHMgjMO3R1dyU1mtbwaAc1tUGkgoWXLttAmEOEgY03WBtXgGBqrWlUj5KCcKMGOdSxRKLV0OUaTbXtKS5uDAGRaD2hhCOubgAPTC9DcgnoVtrb0tdc7sLKiTQjDgbGVEBD3dYVaGcRCYkiBGRsMR4dv4OnGURh+W0+H6667jg996EMcOHCAjY0NfvmXf5mXvOQlHDt2jFwu9y37T01N8aUvfYmXvOQlvO1tb+P222/npptu4oMf/OCzvoadnR3iOP4W+fT4+PgTepFvuukmHnzwQXq9HjMzM/zVX/0V119//dOe3zCMCyZNzwZCiGf9Xk91rGHAL7zhEO/6yH381Efu46detsD3HS7zVw9U+S9//TCNfsAH334ltmU+o/N9u9eebPs/3vbNzw3D+I4+84Xiufh+n+2+z9X3+4+3Pdff8YWc86IlwNAjTQ2LHhVilmkh7x/n8OkamSN6QbybgszDupXKGYXxFUgGkjNnN6nLEjM9h7wlaYwpJtIwPRYwKo8z+vI6Ywcjeieg+3/HML/UpZRQTM+7RJkunx7bRhayiNM+/lmHTd/kqlyXdBCTLDcIlYFVaiCuixk7WyWeVizmWyxUBeKxXXQKDXYOtLEzHnFekatBewmyV0K9DCNjcDaX4eTCO5HTb4bA0D21YUqv3KfTEJiQ7OuYIDcHtUjvFy5A9kpcf4vS1ml6fsRu4y85V/m3tA/9S8TSVyEJgZticcJloe9zffx33GH9FNXKv6PW/79MLd1GK5likT3csH4/i6twum9w38ECI9MtUrakoqA+EjCR0aveoatgR7FcNlnNzxBUOpS6DYw2dBIOfirPdXKLU1GFaj5mZqKB3YS0gGZcJMpXaBW3Gd2QtBLQH4WNLCRFlflVSdMHStA/AVUb+haMpBXdnsJJQSULjWQfwg52IsGCCSseVB8SJLczrGU3uX0hz/SXbufV3jZhUmF0YGIT0vM6yzdR135d6W09SRFJrXTMjkGU07GeVlUX/4Wh1yTMEuRzWgnpOOBVtfRZ2pBWYE6BKsHSBOx/Y8SC38M/XSAiTaRKQBtJkogmMQ4hEgdJz03SIM9pLBQZ8sQU2GCeFCYBNgU6pClQx/TGiD7bJlNqYGRhNBvQaVxYD/CQAD93eKaTqW+Hn//5n2dqauo84d3c3Dx/jn98zsdf+8d4//vf/y3mMhcDvrk6KZAoAcowdOVVSQxcpBQgI5QhUVIi6AFNRJDHaFaIcfRN73ahZ2jC2Q3Bymiy2lHaGAuAjHZqtjPg9bRvQh9IKsjIgXxaQdvX7SKWDSoDIqFJqxfrqrIvtJM+EXgu2Al9rGBQwVUQtkFFmoRHoY5UEkl9/ghwe/oYI6nNveSgyoyrB631JjRa0G7DdgNqHai2oO3qlpZ48F5KaqMvYjAlFloaFyOH1d9vwpAAf+f4ZmnykSNHuO6669i1axd/+Zd/yY//+I8/6TFzc3N8+MMf5mUvexkLCwv87//9vy9Ylvps8M19yhcTXnfpJB98+5X86qcf5Yf/4BuePvVewPvedHgYgTTEPwkuWgJs4FFljTUq7GaTJeqo3jTxEmSOasVY14HjXzbxpaT8rxX1z0NiBV6ba7G4kiSWJcYLp6kn4aG9YLxNMnd2m4kJOPZ/DZpn00yEU9jhFnY/TSJzjpQbIvoGlBRpt8m40yMyLIydeWLzFHYe9h6SbF8TcnumQOKzFcRmAffgQ5wpxBztNihd1qGtQPVNipdEpBTUCtDbDXUHHhETdGZ/EDl9IwNNG3TSg54xX8vp3BgsSzuU+kqv8PsGqCLYe7HrMSPndDUZ16VT/j/UDr0etecmzOW/AtHH6xeot3c4MNPmQOoPOR5dhbS32PTLWGKNOIrpWDb7CfEmJCe2enQLJrtiSbGk5dnqDLTa0C5DZgq2bUUh12CnFeM1TMw4Jr/pksGlswtCYeA/BNMFSNraX6tkrtAy1zm6W+JEUDgHnVE42wIjkBgujLTAK8DoFEQF6IxAlHFYy+zCi3fwrXE6Zg8nXOKSWo1u0ybhGzRUgCm63HlphNePeM2XU4TCppwLcLNgjkGqNZiLerBvCdoTkElCpqBTSDJ56I0BfXAiPe8tz4O7oQmwW4fuKqgcBDsCRyjS6BQUK6Vl1H0f2kWwRyW95R5eME6STXxCoISPwiDGIINFGckuVsizSJ8kBlV89lFGUaVIC5M5BD42NUwkRmOE+KEW+SOSwmiA0wie4s55cth8+8Hkwuj0EN9N/MZv/AYf+9jHuOWWW76j3t73vve9vOc97zn/vN1uMzs7+924xO8JCIGu/gqBEjojWAiJUCEiNlEiBiNGqUgbYhktRORjhTYykdddBYkI+qYmwD1P9/wmLOhGOsPcUOAkBxJnW984XgytgfuyFel83lhCL9DnUY4mqMLWJDuwBjJowFG6Auv739hHxcDA8Tn0tAQ6srU8WQhNvKXS0udeHxJpnVscDXqWI3RguR9BvQmdtjbC2mnrR7WlDbRUjLbTHsiypaWfG0p7fAHxkP4+AU83jsJwLL1QFItF9u/fz+nTp59yn62tLX7yJ3+SN73pTdx999387M/+LL/3e7/3rN9zZGQE0zTZ2tr6lvd5Jr3JFwNed+kkrz48wZ1ndzi7XuMTj9S5Z7nB6e3u831pQ1wkuGgJsMAkj8UGPpIOJoIOEcKFYgxdBVEd/B3B4lKaQPVw0hDPQbqtKG032HGTLDVyLP2hopU3yL2hS+ZNMTt/CUuP2WxHGSyK5JGExPhBSpuA2DZYEXLcRExDpumRbWcwgiJyssnSLnh4Ik/NO8wucRKXLsXjFlJN0q/U2LpckX7EwW4fILj9HPFki9z1sFE02MhO0Zx/C0xdB7mSZlUJC0J7MOHKQyOAbAYCCQl0DmUhDTkBG20Qo2RO9zhVtZlJRnTrgs4+D7NzD/HMa4kL8xCtgpkkVG3u6YfYVo9c8DDtwiF2i9OIcyGnpwtsHPOonIkJdksW9gcYNhy2IZqCh3zwy9CfBsuAah92lSW7T3U4KQRnywaX9iHs6v7aXh1ss06mG3Fb02B6XLJdgVkVMRFFOANz0noIOw9Dti6wygrfgvFxmHXgVNFkIwX7x2JqgYMaT7Ijr4WZm3DW/pSpc49SVhCYNkZYRIRpJiZW2Zq3sB5VFLJ13J5BxzWQByXWCGxJaDyiW90mVwy6NYlv6SxeowndBiQykGnr9rhCAtQ2yC2IL9Ouz04GGlWwegYtIELR6aVJRBG5fR6jwLYN4z2QSlByfKTwafsFPCZJApJVJA4uWdqMsoVkF5IiPj3SjLGBT4otQiZ5AJgHdiGok1Qh3ftzBMUW00XFMdwLup+yDAnwc4XvZDL1O7/zO/zGb/wGX/ziFzly5Mj57Y8ft7W1xeTkN1bbt7a2uPzyy5/0XIlEgkQi8Sw/xfc41IDPmfYgridG36UCiY2y4oFzs0SZEqUCsFIY8TZm1MFoBMheEhWawBgEWT3oRZ6WG/lAXsCoqclq14f2pu7hFSbkfDADXZHt5geZfApaCR1VIAHT1wQ6kQekjk/qe7rCK7OalMZ96NXASGgy7Cm9nwoG0XOm7un1c5pIy5o2pAh7ukLc68NOEzZbuudX5aC+A60m1Dc0oba8Qb+xGPQso0mwE+qelsgiiIcjwpPh6cZRGI6lF4put8uZM2d4xzve8aSv7+zs8KpXvYpDhw7xV3/1V5w8eZKXv/zlJBIJfud3fudZvafjOFx11VXcfPPN5+ORpJTcfPPNT5l6cjHCNAQvWqiwrwALUxXe9id38bf3rfFfXnuAYtp5vi9viBc4LloCHGDSpc81WNQp06XHnBHQNbV/h+drieq57TJn+jO4d6ySL7Y4GeUoeClmUjtMXLbC+sNTGK0i+bYkuBt4bYv7zwnWTQPh2IT9AEmVKoJi06GwpbCcPnFk4Y6l6P+rPlf+vUvi9iUqjT2s7n6UlUN9al4AmTbWizzy/+Dg+hnK+S2CPRHlbYF11zQbMkCFYI0KVvJ5Vg+/Cjl5PZSK0GjoFXdTQJjW0jvLgMjQVYFmW5uhWNEgrsjSK/3pLHSTuC2HUSPEcxzWxqYZd9cYM5c4sfwFvEQCjFmwc9RTgkasUM4M2fBepHUtW4dLTGW/gIpeibv3FqLSKfqxIHIsViYPsZNfxuy06EdwoAFqSxchgkPQyMOZpMHcjiTxQEwtC3Za98g2QyiXIhoVKIdawR1vaeXdroJO72hPwaNNi7wRke1pdeHIBOQScL8tWNmTYXLD5ZJ+zE69j+yeII4XwVqllx2nMbrJ10uKTCdk/8M9SlvTBPEq1ZE59hk7GLVRzJEV/Elw9ug5aLQG5gg8lIP6qo3l+7RsiJpQdiA4B0lfRx7ZmyCPaP+ajgSxAokpMGNwGuDZMU6YoqfS9NQI6VqPSneV0QqcdWHyX0Bmt09SbMMKiOM9DPc0Fimq5OhjkyZHC4c9dCjhUk1ts1/uYPglHmYXeXLAMgV2yOBg0sPFQHaydB7oMnkoZjzZ046vzxD24PFUeO7FZC9cPNvJ1G/91m/xa7/2a3z+85/n6quvfsJr8/PzTExMcPPNN58nvO12mzvvvJN3vetdz9VH+d7H49JhFCARalAJlhKUQClDuy0jMWMDIWMkIYoVlMpAVNTS5H4PugWdz0ukpdCWpUkl6EpsCKRNPVgEBsSmzgAWmUH51Nc9u2asiXLweDTSIN9XxdCVwEB+rAZuU66hjzFi8PS1Ypq6Ck0EtoSgrw2vooFayI01Ke92YacB9Z6uTPs9LX/ud3XGr4oG5xNaqxuGj39x2khLyqHj1bfB042jMBxLnw7/+T//Z970pjexa9cu1tfXed/73odpmrz1rW/9ln2llLz+9a9n165dfPzjH8eyLA4fPswXvvAFXvnKVzI9Pc3P/uzPfstx3W73CRXlxcVFHnjgAcrl8nmzrfe85z38yI/8CFdffTXXXnstH/jAB+j1eueNDId4Iq6bL3NoMs+jG20+dvcKP/WyPc/3JQ3xAsdFS4DHyVMnRYcmWVxKpJic22D6Cq0sa4Xg3g/b7SzHzAJeHFOqGbhMkU/XGf8Bn9xLJCOfXqX1hQzbgcXsfAcvhPkJhb3twXpEkgCfERxSGOEOXq2KGXbAzEDCoHooQ/u+FuVsG+mfpJn1yRUhJU26ySOcHR3DlA1QktG9x9h7hWTzDtixqsh8Hw5I1l/qsHrgxciJGyBqwNZtYDsQz2pZc7MDsguJA2AuQFCEIKmNVEIbRKRX/w1PE+Rigd5rXoTY/DxudoSiG3DFdoAIITTP8ujkDEZ3h2SijZfKEFuvA8MmlA+SXf8UnfRrODU1A94h6tMVvtRvopZPQngKsVWmGW5xdLrFegTbaSgvwUQJ7ssJTuQnkbya0/UlJhN3IXFpF0xMQ8IjArsJe66VeCMGj3UcMic8EhsWp3dFrFyZJHYUvUNJSHaZysSIhl7MMFOQzyhKRptYwmNfEWSXLA6XAmr5gLGFR7ivd5jW0X9BovN1jPwKj1zhkb/jGP1EAm9yitHCWTbKXWZnITGh1YcbNfCOQX8/LL3IYPx0SCMN7f2wsAKBDWJFkEwouoa+DsvTivN0aVCA6YBZB7NjUbQkth2xHeTwSDGKS7oLjQgSI9CchmsuhWYd5JehsxhTcB22yHOcEi4hl+NQEEsUJh6jNNXmYDKi9VCWe/wRIsDAAQ7S4TQ2Aps2EhuTCaINj9RkjWKlBWvP/H5yGBLg5xJPN5l65zvfyfT0NO9///sB+M3f/E1+8Rd/kY9+9KPs3r37fF9vNpslm80ihOA//af/xK/+6q+yb9++8zFIU1NT50n2EE8CGQ/si8FQj3tDxxixQiCIMBDECCJsKZD4hEikWdMmVnIveG0gAYl5iHzw25CaAcsZrIoJ3XdrJyDl6IXLpgkipX830iUg0uTUiPTFJFJ6MPFiTX4NqTOC3YHdsmNp8ikt7bpneWC6urfCFJB0oO7pqm0hhH5bS5zDtO7Z6ASw7mq5c6MBrq/Jc72jSW4c6aglgXa5scQ3pNfWwK06eNzQa8iAnwpPN47CcCx9OqyurvLWt76VWq3G6OgoN954I3fccQejo6Pfsq9hGPz6r/86L3nJS3Ccb1Qcjx49yhe/+MUnPQbgnnvu4RWveMX554+3hvzIj/wIH/rQhwB4y1veQrVa5Rd/8RfZ3Nzk8ssv53Of+9yT5goPoY2SfvSG3fzcXz/EX3x9if/PjfNY5nNvRDXExYuLlgBPUmCKAquYjDLLnLXCi17WpJjXPh7RCmSWwbVaeAnY6TqMK4fJ9AZX/PA21msl2woyb1bs39cl2oHui6A/ApNvhNykwj9WZezeClvhIQICTBw8d4k4FDojx3RwcwkeOpLjpk/maCLI9zuc7ENnNST/qbOUz2TIBnlSNCmvCYwKFK8D70VdzG1Y3WuyfO2VyMIR6Neg+wjCuwNl2hjbYEQuhqeI2j0w0qjKLlTqMjCuhd40lCt6shWjHUlHLJ3rOPZ2uqsmyc2vcfTYOlEbGvtgYlSy2trBy9r4agqZ8iDqI9w2paBLxWhxZrOFO5pDJI+jrBSqIBjtLjN5RxWj3mL+QBs/A0mp+ffZvbBiC2qGyejKDrZxN83MBKeu3oPobiLHZ8CUjHuPYTsRp181Rs+5EfVYm1L2FtJ7I1qxIBWFJE9AclebYCFF4PjYd8aEZyCcgv5uQTuyyPRCziyBv+5QJgQU+W3ITrZwgy12u8tUegFrOzB2ZcCpqd1Yc6Ms7Avp1qFf0AkhsgVmCHIWUiXY3ZCII5BsgJiEdBvcCphnFOEiFNNg5KG+Ce0uyB6kHfBrkGwKJvOSwFKImsmcvUUUTiPTbdauhFYG8ikdu7n5BYO1tTTqdBq3sYuIHFVCXFwSlCmRxr/kUfZc14Cvp1hfTnNrd46YDPOY5LCxyeFwAIligzzr9DhEglzUJG7W6GcvzGplSICfWzzdZOrcuXNPcD/84Ac/SBAE/PAP//ATzvO+972PX/qlXwLg537u5+j1evzkT/4kzWaTG2+8kc997nPDDOCnw6AALEH/YVsmMtJxSSZgE2Mg8UwFykRIGxElUCgwV6CBllIHLmSz+mG40EhALaEjCJI2VDI6V02gs/iMlO7j9VsDUjuoDlsWZEyoSV3FHe1rAqwk1BuaEGcTA4l0hA7htbRrtASUp6XN0tafrdoHbD04r7Wg5UPT1729gQuBBzvrOuIotgZV3xjMQbSTK8EIQCkME2Q8tG16phgS4O8cH/vYxy5o/1e/+tVPuv2KK654ymNe/vKXo9TTL+T89E//9FDyfAH4F0en+M3PPsZ6y+Pzj2zxhiNDM6whnjtctAQ4ScgEEpdJTHrstmBiWkEM+RakN8DfB3vuC3moHmAJyWjGZe8PV9lzBWychWAezgTgnxSYSwbJQkxtAdKHYWcPjBdj7BObzDQuZweBpUbZ6Nra9zIUug/LCFk9sp/j+05y5f1TpL0k5S2P3l+kyS7HNKgTF1Y51DeYaOY4W25Sn4dkF1Z3Wzw6eykytx8a5xDxMvnwYca9DqM9rbTzXUj04VTdIt9tkss2WZ84S+vQOsp5M5ijgA1jJriOlkPHEVhZKB0gV7+VubRix4WlhMm4lJRaWZb3vxM6ACch8rCMNRaSEc0IpLnDro0dDviLnCklWCwWyRV3mHYk/ahA76RFv1Gn5ibIZKH78oBq5QoSOyHfz0OMbB5HnTrO5rjJg/sEZwtlSO1h+405dkxBnD0E6nqYb7FkG5gzVcLJ65i8528Z29hm1INjztXcd9l+Lt3+c3KFEGcWgq4BvqCQgu6owm24RFnoHR0hMEO6CyFO42HGFgNaGzBlgrgMWnsXiKYu5dSez/GKTpvmV21wJL1DMeEuMK8CO4CgoM20D2dgswE8Cs4B3aLXr4K5B9x1CDfB9Q0wJWHNpJSMiRIKt6gwdyCZDAi8Iiq5SOrKLWq7IcqCswmd/z7OrWf2UI1LeHQpU6ZMmxwW8zh0GKddeZDL/2WT3mfTeI++mAcI2STgMjKkiMlQR0+1anQJuIMxXNKkKDGXeIBiNCgsXQAygzM+FS7MUmuIJ8O3m0zdcsstT3i+tLT0tOcTQvArv/Ir/Mqv/Mp34eouZqjzsdlCqfP1TYUEhM4NNmxAQtTXRlVE4Df0a3EMCQk9B3opKOQgndT9G8oEDN1LS6wDxz2pq8IZeyB3luD2oR2AG4LdAwO9vR9q6XMktcmWKbW9fBwP8nml/nfsA6Y2v3I9XSkOFWxWoRNCJ9JtM6Gvre57ns42NpWWfCupr1OqwfspBOobavEhnhGebhyF4Vg6xAsXSdvk7dfN8btfOs2f3bY4JMBDPKe4aAkwrBDjUmaeEfq4fob1B0zG98TQ0v4fbhcm7T5XectECkbDHqnj4J0GcxNmXgepBjz26TRdy2OhDOGLIC7Cbg/yZ8Ht9SlylhH2A302bIFKDsxKTANEBpkWnHinydXdTeprRWZWNylXuqysRlwZJ3DHmly2OsXJ/R63vQjKWWDC5sT4QaLsjeAtYfQfYsbcIB+G7LVgX0vPhZp96Dah0IjomeBtwq572jRuvYXu3EnaR3+IaP5a8PZA5EDe0b1nIguxwA2z+EBrBBrlInG5TX9pN0Rz4N2rozuiGlHlEI3aMnguTtJgfC2k24Bd7T6N7ZClosP61WOMiA6zqklnW6BCk6CXwK+lYM+rka17WEzatKZjSp5ibk/MPbOj4DkkHv0amYpNc+yl4N8AYQlEg3hviDQLqORhWpUHKRa3ySzB3MQJTo9PsDFlcmZ/zIRUNEdtDNcnCrQLc/VQTCtlEV06zhJjZK07EKcVDRdKIZQv0ekgEhvSI3xt5Ptx5j/JtbcFtM6ZGKHJSCPEebEiGod9CZgIYTGExmkoTUI5BeIoiDps3At4UHoZJFuS4BEIGmm6nkeQDLGa2ozV9k3ETIfZw3XGr4FHgLMGeLcmOXXqMjaVQZqQJhE2NvNskGIDj+uo4lI4/DBFFMdPF6lisE7AXmCMAIM2NkUiOmQJCAjokCRDkz5pmkGJ2VaVcnxhs9an610bzoGHeEFCKe2ebIIyII4UEgMDCxGDMiTSDgYSZAF9CVlHE17V1OSy0YfGGiQSkMlCaRxyKei2BvFGSShkBmZZUjvqpRI6/ihQmojWN3Ql2DSh3dKyZscEx9aO0Y22Jqs2ULYg6mp3wdDXj6CnjbjCEPpNaPc1yd3ehlho86puqKONAl/7RyAgFWlzrCjWXNgwkKaBGSlt/Cyf1/93vufwTHqAh2PpEC9k/JsX7eKDt57hnuUGD602OTJTfL4vaYgXKC5aApwipkkCSUwZm3UlqW3aJEoxvqnTKqJFKFkR+4wdomSI6ldYvc+hlu5iAOM3RxSOQv7SHpmTNt66IHM6IroSKhuQWRI8FEbYnEWRopM8S3yJT5TLguWCSOveq8AlqDi4l1VJncqS+EyK4hUujcQJig+PcvTMEeoL65x4e4faVJId8sSTR5HZMegqzNOr7PriKuNdSWUC5oCwA4UxXSiwDOg34Hg5gzcvGd90STZirEdWOND4n6x0Z2g1D9Dd90bU3IvB8aBjQjdkYnuTUhIeIkmU2M2UfYyzk3sQNY/ZO/+O7TmLMB8SGwucWd1Dtn2GbuUNtJZuodSscjIHiXqIkzDxDr6eNUw6s39NdLdi9ESPZKmDn345xJcSjo1xT+ZaTLeHPbaIVdiiW3k5bKZRif9N6vObGHtvpnFAEleuIJP8JLmNY9iPKqLyWTb3Xo+7/BC7FnqMZ7bIVf+KrqfwR0zOlGZRZgo7OItIB7QlWGVQVh6CBEJuc2k9IKdibj9oU58GSiGGayHNHHS3iMfnudV8JambPseVnw9orVRorbsU1rok9sO1V0ND6Zilcl97yZgmjI2B60J8SLdmd3vQPw3drQwGeWQM9EO8KUi2QE7EzL1JYu2B7Wk4hzbTMk5bTCubRZqYRCRI47CFwQYm4zQYIWE8RmXHZen/tQkbo+TJcCMOBjExWyggHIQl9dganMUniUEPn7RcINvZoGe2L+h+cnj6ysUQQ7xgMSB6AoVAxwmpx1N/IoG0pW7NJUR6AQRgGAJp91F2Upf1IhP8JrgtSKahXQFM7dVQyugeYcPRhFiZWkUUDWTvDppgS0C6mvwmbU1cZaTdmQ2pSXDVQq9yhhB0wPeg5+pqdBhAuwleoBMLmuHAuEoN3Jxj/XAMvc0PMaWWf8eWrclZrM4fMsSFYTiODnGxYyyf5I1Hpvi7+9f4s9uW+H/ecvnzfUlDvEBx0RJgg1EeI0EBh68iOcJuHOtBnBjcJrTuh84pA3/FwohTbPV30VZj5KOAsC1xMGn1F5lPb1GsQNMrsfVohb0fXUbO9XFtcFqClBIoQlIcI0jtcGhH0t3oUd+rCGIfcMDyCEo2jwiTnCxjr3qMWIojb/AIz/rUs2vc+2/rPHZwjpAFmNkL6TT0dXk386VlxOcES56F6Sia+2PGpqF2D9gF6CbB6EM0mUcA5ZyLmdAJFq2zEdd+folMY4kTJ27nvje+iWj8bTqXJ38ltfwCm/FD7KSzUBjHlY8QTUiSd95C6e4+mWVov1Sw1mqjliWjD5vUXz/F6et+gstv/n84cG9E98aQ2oQD822Uejmt6SIczNBbXccIFfLgAS3/s+dQwaVEI5KoB0x3oP4QdmGR9GSIWYb5u01yy58lKH+R0TmXoCPo3jbN5PgGsfdF1g6mqGz2KK1BvwhnRwrEMkN+q0eluoYaj6jrAErmT0Cy2GVHNEmmNom6MdNJyEQ2vb0GWSvksWoSVc6DVwdpEmT38rlrXsGG82UO3lMj9UCa7mIBuRLROePS2yXZF0PzjCAdKaIcdE2dO5weBbEMmTTksoCSVOnhGCH5PTBagMYYLL1asnVEt9T5eegOkkTSb+mSjb7OrvunUErQwmaOFGNMs8Mh1khxRG6ydnKCe+ODTJNljpAUgpA+ERERCQJKpEiToIxBhqOcJKLCGQzmKRGFOfKhx4WI7TLoRK2ngv8s79MhhviegPrH/1AoAwwpMFEoqWOBDGJUFKFQGIAyYpQd6eghhHZ7Dl3op3Q+O0pXc4MMJJM6I1gmIBA6nkgZepWtmNQuy7HSZlQJA1KW7oNREm3pLrXyqCV0s7IhdT+x5+tqrx3qam6zravakYR+pI2/kJpgC6ndo82BXNqPESgMoQ3AdNlXDcnvs8TTjaMwHEuHeOHjR2/Yzd/dv8Y/PLTOe19/kJHscFloiO8+LloCfJKIEXI4SI5RI0uO3eUQU4C7CSdudoh6EblyiL9TYFulKbJCFoc2GRr4ONEMI+sdWj0PK0qwrFySp3MsnOrDIcgkJTPJkIJo0AkMFnsmuVsM5rMRnXcJAmcQqRGFhBM29+ctxgRYymR0eYHL/7fCMQIeePMyJ/bPEeb2QGJSu4n2FUQuon0/ufkWXgVYs1CBg9XuEE9AWAC1DOlLIZmCyze3uWdPiW7dYOorBu4IjO+PCFaheAD2JNqsbH6ajc4czN8IHRu6KYQP/fEKIGhsK4KUy5S4h7Kl6LoCrxchNu7DWDGw63nGjn2SrVf8HIsvvoLiYyfZvHQPQamK432ecDqFim+AYgFeNorcOgntL2GKOkpmIWGiZBWVvw7qEYn6Z/kX7bOMpCXnLgPvXAK5lcBs9zjrJWnvcjg8sonIRQQFiOxp6ut1qsuSiaLCKGWxOjHXr+4QNGDcgvuTNptYlE677FThyPwia3OC9XmDXbbkhnyfRgP2G7BcBRaUzm6ODEi5BLumuWfqtTy8sM3RxD2k7rQYXfDYaSToL/ksRDapjQy2GeGud9neUZgZbZpVccErwdhh6J6M6fouRTtmbC9M7IcTM7B+UBdqLmlBd0d70YQWWIeh9K4W+35NcGppP5P47CODzV7aFNnPKSaZ5tZ4DEWSw2whsQkZxQV8JC0SeBhUyBORIcMmR1njk6QRjNFCkpcZLHP9gu6np6tcDOfDQ1wMON/yqoAATFuRyIDs94ljk1AkMUyJIWJCZWji21cQD/p2bUMbJPruwOrd1jnArYwmrIYEMrpa7FmQSWmX5XqgK762qYPQjVC3p0hH/8qnIh2ZFMeaINtCb+8HOh84cnUkXgy0xcAQS2inPsPWj7ALpsRwBolKCh0bjA0YWko9xHeEZ1IBHo6lQ7zQcWSmyNW7Styz3OD/3LHMf7pp3/N9SUO8AHHREuANWkyQoMoKJjEyscHcTMTGI/DA3wnObMxSmN3g6kv7fPWLIXbgcyi/ylk/zY5/gD0ECPqc25xhrLnEuNnlXDSKMOvMrUJyHmo5G+WNk0zsYCRC8kGedjcifaJF4hz05ruQsrWULWPAjqAqwGaOHAm6yWUefeM2j7x5nGBqH3gOODH4XWhvwc4xlFFn49Au1E+mEKe69NpVkouC+aoiuxfOzsB6DopTcLgdYzd2OFuGh14m6BdGOFir4kxIbBu2O5C3Wmy3P4O5cg8hGaS3RS0wCd0Qs3of/W4C5qapjx6icdUdrBQFvRGJ7W0ztrlAR0A/HUFeUr/0J6m/LoTyLNz3v8g+/GmM1Eeo7e+iWq+A9jlISFJr93FoZ5n4lIWfkihL0ivcSzSXoG5P80X3GiqtRUq1bfbNdFj1LLb7UOp6WH2PraMKx4VSo0d3TKGKSSa3++RXYffcJrIiSLgQJKDXgY4dkpERnbUsdnuKarOGXW0wmZSMFvRXjA3eLYJ8T8FLfXDKYHchEUAQoEzwDk2z/fB9+PcKGBEsv0NSyxdIeW1KX2hTuD+BOp5C4CJUmr4RY2DjzvUxR2OaUpEwipilFgujEf1LQY1od+zKWZi7GybSQNLg7KUSWQS3AKWDLSaWapRZQNHHJiInemRUjTPM0SLJZZwhxxZrlEhQIAZWKLJGh1HAwsPBwaDCI0DIbjxs6rhME9O7wBKOzbefuA1bAYe46DDwmgoGvNAwJFIGKCkHVr6D6qwMMVAoCcpXOqOXQWSQQlda++1BvFKMxNOyaNPWzv2BqSXPwaCKLMUgligA5WtiHUc6cknGOt7IQj/CgelhOMjulQriEEPFCAxiw9LXqkIwBAgDhUI97kWspJZED2nZdwVPN47CcCwd4uLAj94wf54AXzVXZGW7wcIUXLcwgmkMvdCH+M5x0RLgmD6SKlvUmcbkir3nKPvw+T/Jsr0kcJVirALGPPSMDIoCnSiFr9KMUMcmwiNJpBSLdpbdU03i2GXffo9KBpLnYKcLkgP0/QKjVx9nfqrO7SdN2kfBS9uQRBMqGUCUIX0kYubMo7iRjZeUfPV6WHvVLmSiAt0YghjMDngxyZ27QDbx0gvIiWm4ehTV2KFds/naWYm/tMKsH7FQgbIPNQvsNOxzIelCy46xTm0z5itGkmBvQsGBnSWb3d3jjJUf5r6Fq2ld+0a+Wt9BlsvM3fsRwsBgo1LEy/8oD45cA/5p9iz/A41FgR+HFESfztwrYGoGOrdhBU3k2j1IxyHEoaL6tLbuJvZ6TN37JSw3wQhNrFOCYG0Ew2ziTLikR33KDR93wufr8++gkbSZaW6THIHSRER6GfwTgvSywhsDMwD1gMfhh4+xdTVEC9BMw7QdMyqgNQ+JGqQNKJugRhSd3R7i5A4pO2AsqTBPatPTYAwSLVjsCUoNRfmjJ6n/dFk38Jp9SAmwk5A4R2IspJtweCQ06BUL9Gf28tVghcSPp3jJ188ycVdMvwqOG1BJxoSGT+wpxDGT8aKie0WVa69V5I/oQs90H8a3IfprqNUhaBVR60eovPghwh9qYrXBO54DdhMyRpM+TfM4mUOnCZbmSXZTpJAcxaTFQe6w+0jZJhc7rGIhMDljSvbHXS5hNz5N8kwwTYlV0kjO0aVDzRhMhp8hnq5yMZy0DXExQj4+bFsghAIZas4ImlBKLUs2ASkFcYwmlUJpqbGK9c3j+ggVY6hIE2DHhLwN/YFDtJmFfqxNsXKOPi6OviFbDmNQfe387JlaYmIN4pBipYmwYQ7eL8IADCGIjQyaiIfavVooFDGclzvDoPH4+fmCX2B4JhXg4Tc9xMWA114yTiltU++H/MiH7hlsPcNMKcUvvOEQr7t06BA9xHeGi5YAj9NhjHXqCPZaHlfucbn37iRfXZwgJiYJZDYVdRd2ZXqc9iY515+jS4ZZWijAJcEBkqz1clgj93HFEQ/7+8B9GHgU8jHUaFPHoX6qglVsMfPWkHtKMPrVgIYh6O7pIhMGiBatN2XIHenQqykayRFkpQiGrx07naKOJjq1Q3r7bgrxNlu79mg3ZHcd7BRs1aBTxB/N8PX8biaOHWO85pLaiJhMRbStiH4WAgQpLMbGFIYwOR04qH0KM+FxNBngBikerlyFv+sHIFtE7g5J3/phdn+ph7dj4J77S5rv/C+o4isgMU/8pS+DMonKSdKbLYTTg/4XmXrsL9kV79C1DJbGpnDLZZp+kyhXZvSRm4mafUbp4sZgeRDmt2hLQdxMkC/4iB6kHR/H/TipwKPrgJuFQqSNpdZNhcxCNgK5CJ0UjGYkxeNgtwzcF0k6LuQegf4C5BvQ96ESQ9SBqCGpJ9vkswrTUtRj2JgFswzJMWjNSiqnAl702W2+nv4yzXdcqp27DUNPIsUYG3tm8H/cx9tVgckIw9ygmK5Szx/li6+axrrCxWj1yYo+V9cVB9fB+VvoTseIH9Lt3H4WVoDdESR2IPXXgsWvTGGoCWJZoMkco7fOUul8FvvldTbaFRRT7CC5jxqXqBSXXy3xr1+EP9+NFUySIsUx0WW56CI6PglZwTQiMrGkbffZiiMOUybNKDXqlEhwlix3ii5F5eGlFVyAD1YGSH2b181nf6sOMcT3POJvihUTg/9JYWnjKRRhMqkXnIJYZ5ApAYGJUCGCEFOaSMMmsgxtciUl9GJEYIKSKFUFEjrTvVvX45RlY7gRihhlBuA4gIkIPVQkdIu/jDBQWEoSJmwwFM75y1LYUY9YCKQAM7ZQsUJGCrjAnLQhnhGebhyF4Vg6xMWBLz66RaMfArC7kuZDbz1ILXL44K1neddH7uODb79ySIKH+I5w0RLggJAmXQosMFE+gVmDj59OcVpsM6VGkESsbRg89Mkse51tOqJMW5lkqVNDYpKjgoMpNimLNo8tTpNayzOTXqbw6h6JdRjdjAgebbCBYrG9QOtWOHSihnDabGxnSDnL2AcjwlDPW+KsxbkDk1ozFwCuqTMfRYjY2MRu9iifOcGVwTanU4LNHuQfPoNVq1G/sglWDhJZ6G4gy1ex/obrWBcxwusivCbJ+gnSvTU6iTmC0iEMP4WSZVSqgCLC2DiNtbFDuNtGHb0WbIlYuY1M9X72fOoxrOUEzbjC1IM7dI4fI76sDGKUTjyNLc5QvQm6p3ok0vdw4MEvcWXksdGEUksyfuIcD2VTbM1NkFQ1djdd6n2FY0NUENiHFJyRlEMTMSlJzOpEkI0OTBU6TNWhnwBRBL8O3UdMygVJsFdxOq+V5LkeeDlo9cHNSzIRTLagWoFoGVohZBJQ7MD2EsQbCZQs0OwGRGEd34HJWd1z+9gU1CuwNhlx5ESb7/vbBF8t/D1bL5vVfXpGArOvaO++HLVX6WqO0Ybug3iRQHVXiB2T+FAGuhZuR7BBj0vrivo8yGtB7QVsrWhPnIadUejcKth5xKEa70cxgcNjTBAxIg+TeGQWI1lnzisyT5KTrOIk1jm0e52JOUVrIib47CLl1UPENBHKxazHZGKDCdLsigNcsnSEy8mUwbVulyQl+hRYIWQ1u0hvDEaWyhzuuWin2GeGp6tcxM/+Vh1iiBcYBlnB56XDg5xeBVrC/Lj5lfENB2ZDE2dDCl0dRg4ONwfHxAgRABFK6ogioSRiYGClRKzjjDAGxw/+bQ1Mq+JBZpHQ3Fth6H8w8Kng8Vzjx69ziOcCz6QCPBxLh3ihI5aKX/30o7xs/wh3nK2xVOvz2Haf11w+zh+942p+8sP38GufeZRXH55gKIYe4tnioiXAMh1wLuhwbWRwYHqHL605PIzFCDECkzaSDg7FWoJ0qY9hrOLFZXq0SVIgT44EWQK1SErmSKoZlv0Uwd847BUPkn6LQsSK5u0WfbdCzQxZzjuIlSvoZHyCbBOqGyTrPk4azAjaCR9FGxAQu0APAgdUnsn7H+PggyGRkhQNyIwpDvqnmf0shJbi5PgW7UyPXm4aOZoDqwVRC2GeQE2No9yj9KeO0Pd9cBX4lp4PEYLvgwiRM6/EbP0Ns8GXKT1wC4YRYRke5XZIIgXu/hB7ySQ76mFYEXEiD/iY4xYTgU9r1CfebXD0wW0m74LWdRD7sBHqGKBc5FIKlym1FYke5LYg3gsjXUU2Bd5LoGfHjJZjDA9MqXN1/Q3YciFbgVMxzPzfBLVY4DcjSkbEaMlgI6/IHVC4EeSaMGrApgftfTDagrgLjYGSr9oB04d41iUXuAQmFEegXITQ0FVmaUGUhHAiy/Ere4x8coL9iy32jDXZVQTREsiH4TNHR9k5dFjnfGZMZGqGnmGC0QIVgeiB7SLSLifz0N8PwSwkclCQUPQgfw+IDehfAonbivSqJXIkOEmIyQijuBgsMjX/GJYHsTiFpMOBkW1K/7pN+QAkSlrG3rO7YD5KfeRuWrVJUtE+9gMZLDr0iIBxv0UgJAYBJ9nhHBnWRIfWiMSJYzZUhjE5BSw/4/tpSICHGOKZ4XE6iRz01YJ2YhamdleOlOanSQlRrAmxFWNEEiOywI5RKOIoRqL7clEGhvIwiAmFhYgkhgzOtxojhB7cMFDmgPxiQkoiI4Xso/uABUQW6KmBCYQoJUFJ5LDq+5xjSICHGALuWqyz2nD53bdewcy9q3zkznN89N5NXnP5PIYheNfL9/JDH/w6dy3WuW6+9Hxf7hDfo7hoCXAthqwscdjxmXEi/rReRCqXhEqTIETgEpGlSsiePphxDokkIIsiwiMmb57AMXvUgxKCFmM4NON15P2Kxg2QPQpGpc3G6jw1YkTXBDLYUQbhBahqCkf5uH1IlMEOJL4aTIgcA+iD7ZE42aP12QxnHyniqTpWOqDwgz1mTys8H6YLMLoUUT3U5FG3S80fIRRpip3PMJVc4cTWFcSVA8AgEzJo6YZgewqSU7CzSvL4lyisfRRlNGmPZtllrHPwrKRYgH/Ip9h4SQVxXNDZk0ONjBLeeCV0OpDfIax1yHRgdg+M9iXFPjizEOehNgGrlo74CVw4VJfU73aoewaj13ncc6SIMHxKTRevDO3QQfRs8j2XK4VkkRznCikqnR0mb5H4s7A6HnIwI2m5sLUFhTM59s/0EaWQogV2BmwP9jQhl4BeAWojUN6BfBKMLvS3IcpBJwI31tVeZmA2Ddk1SKRhqQfKdSntmPSTDb6+P0c561GqBYxuK+IN2HWoSr1V1TbbjTpyLD9wXI0hDiFrIByJ44FIKc7ZkMyATIPXhV2L0L8TUjMQ7kBS9MhRxgAiNtnCpi5yVDJr7P9BH+scZHpdvOVlChXJ9HUQj4KzDYkq+JU61amv0jIktdumiWlTF2NIZTFJkRWabDsJdkV9ljnLV80KB2KHwPYQ/YDLdmLGVY/aBQ4NFtrA5anwzGvJQwxxEeGb++wfz9h93EY6jiE2QQoiJEKCIBoUiLXZlRAhIFDKJlYCqcBQMUpAbAuEMjGEImXFBGGfOBZYKCQRUsQYPRulzAEp19VmGaFXCon4Jl/rIf4J8HTjKAzH0iFe+NjueAAcGM/xozfM89G7zvGVM00eXmtxdLbEgYncE/YbYohng4uWAE/744yIDNO0aTRhzbBxEi4p36RvbNKVSQoIFApLCRJGE1dO0aXGYZEkT8T85BqyA/kgogdIOlTlAsvLCdInVjk4q2C6zulqn3YuS7aRJonFrB/T8yskbjlEdPmdhK+W+DuQyijifpc4zoIJphcRpxTGacg9No+QBntTK9ipmOI6BKPgXwlhAoLTYCVhYU9ExdjkRNVn9r4W5nEwXtUlvrENeIP8Rgv8JNaZ+5i77w+Zu2+LPU6Dh2bGuPsnfhX8gDu6f8j4xmP4ZwVnL72R7rVvhOs9SM9D0tT9yOFjcPwTOM45iOHwOkgTxsdgY15w8oDDdhgzW4votmHbynDzWIWZ168zloq4fb7CpNdl74rPzgb45yCxE5DPx9grDtsjPqdeO0dxq8bCcUm1DQcUPHDA5iEL3DHBwS0PW7RYLkOqDCUPFiKIdqCZgPUsFPJQDIEF8CVUGxBeB4U6pDfAkTr5I1qB1g5k63BJHebnwE3EuIUY8QMr2NMF1mdSfLYn+b6ZiEsyIIqKnY3TZEZiuutwLrkA3ZjRaIeUGZNpCWbaHlN12KzBI3OacFstuPwuSN5h0m9Igt2KjAGMSPZU86ypmJg0Qd4l40Wk5tfIXgHpErTbQDckOa9v4EIGwiQE41B8c4gtoPplmz0iZiPb5HSmyoHtMi9XU2QxOSPnEPE2X7MylHC4BIOVMEVQsynKdXJ02LrAOkMWSH+b141nd5sOMcRFBPVErhlreTLKQEmBUmqQuTswhwbE48cMHkp9k8JZPJ7HKxDn5cx8U1TxNx34zS+cz3EaEt9/ajzdOArDsXSIFz7GckkATmx1uHKuxPcfneITD6zzP75wij//sWs5sdl5wn5DDPFscNES4AkOMKPGOBVs0D9VImtINrIWXQKETBNiEpHAwKQXNZEypkGRnCG45NIT5MbXyVRizv39GFUqBCRQSGrYJNwRcse2CV7pY0aSfNym36tQjpsskMHFJKBMrttF3SboXw7tMogArFhgG21iSxEnDAqBwslCwdnACCeR/jSCKv5Sl5MHLLIiwtwCewbGTFBnYHsDzJ0GqePQaBvse+wUJ/bfSzx6GfQ2wV4mGW4wu7LOeAH2HonZsQwePHCdjsKwU/RLP8En5u9CHk3h73sxrD5Irv05evk3IEePaBbW6GJ2DSaFojQCK3MGDyZHGEnW6NdsMqs2s45LbMD6eB6/8kpEu4G7UOV+Z57i8XPM4LOVBjsBuYdhWoE6laDrpYibPvtmH2Nl3MHfKxhdU4TzYOwu0stbHP3qDqUzaUoFn9GrYwwfRBZOxFCcBNeGrANmE4w1UE0wMnqF3bN0ZTqTAcuFZBXMJMRjYM2BCiBYhOQuSF0KOwnY57VYasNYDlJdaJ/RcUVv3OfT7IFxDk7FZ2kJgwMPxVS2bDJEjEoQTZjx4dJrYG0cVAecr8HSimB3BQoj4FfB3hJEpZMkgk1menvw/CwHZZMD1zSJJkGEkN4FVh/KV+tqt6HAzIA9AllfE/oDLw8pcjvHbpug78dsmCnCSHKYHGvBCPdYAqlaZKTP3+a38Xo2hTjNujHFw3aCSrgGsvmM76eni+8YVi2GGOICMPCZUsTadfmbuGvW0dy4q0BIQ5PbWCKRA2IsQCmMCISMURj0I0v3lFiSKPwGsZUEz8enG+Ip8ExikIZj6RAvdFw7X2amlOJ/ffk0f/SOq/mPr9rL3z+4zq0nq9y1WOOPvnKW2XKKa+fLDBfqhni2uGgJ8BTTFAhokmRbzrFLrdEKJVJkMVSETZoUfbqk6aYl266BEVscyIVc8qOStAmrXxO0glE8JlF4+FSZok8Nj3jJJrHqM7M35MjD60y5FilyZBC4tJCY9ESVg31BYRG+bsPkMswtRXztCvCqUFqVjI3ByYOw/LoGBz6TpjhZwxeSjetNHnvFYUbvXiI/28bcCzv3QvwpSBkmhcYYcvc2c9fFbMyYKFNB8xSTyXvInugRND1WLx3h9IsrrH/qFOm/SWLe9TUyf3EfmXlJ9U0/iHv16yGtJXj01jh8/1nW6h9m9V/8DKSKzJ/8GFfunMTzJYVR2DIkRbtJfjPmKDGzp3zu2T3CyYML+OVrgRyq/nFWwpdCkCTZX8bd0e7Mcy1wHdi+JMmmH5Ou1vEMRUdJXMvhzHiIvUewNX81Rt/hyi/cxcidRapmzDkM/E6WzlQWv1wmcAqYkxZmN0A0u5jlLna+h7Pqkqt7ZDd90lsh5W4KqcA2bIyFFp1rJWpEu0pHtwjkvSXCeoNsVsECXHI1nNuBhQ5MbIM1DfF9YLVhJAM5Fw5aEd1l2PraCIlwko6oEqU3wYCkIUjfrtgbJNiuT9ORdUqJJukRcCbBMmD0ihAvFZLp9xB3dqn0x1i4fB1xQ4wH5CrgvBjyR8CugGuB2QW3CX5Dm4EbEiazsOsVPg+d3OArW3n2iBqVwiJW+xD71RzVqMJZUWPDVPRnW+TOJOgaBitlE6KYqrSg8czvp6frXRtO2oYY4ruDvj8o3kqFVHJgAiMft9bi8VLw+QrxQNpMPKzq/nPHM+kBHo6lQ7zQYRqCX3jDId71kfv4yQ/fw0+9bIHXHarw6eM1/t2H76Xphnzw7VdiGgJ5AXGNQwzxzbhoCXANkyJJUuRpGAGnk4qFXpoqSUpkMKlSxqCPYrPnsKVsBBmmKj1mZuHcZwRrn9uNG+4CVnGwcLEZxcUkR2N5ns1bjjFdUiStLpWgyWkqnBIBfeWQpMlVchL//gOMTB/ndY7Ca0Ppr+FNX4NbzqSIfEXhX3nYr4LEv5WcPbJK0lWsjzlUpwVSdsi7ARMu2Mcg24NTkaCJREmfoAg7N8zQHT2EjGKyzeNcul6j+yA0DwAVg12f32TyUybBg5chnJBSNM3u2n30Dt9Ob/8EiDTmqVvIf+pWwtv20J+sIy75NKN3bHD0kQ6V+QD7IHQ3YcIEoxFQMKGZdLjtxpfSLR2BTAfG98LKVyBpYgQNxuuP0a8qrIcEu9YVO0ctjn3fHCtzr4B4Hdw2tPukGw8zQRuSgq3ZQ2ClObhxJ2Ii5pYf8AlGJggvuwamXgzZEe2CLVoQtrQeO+6AEUIQ6P5nvw7tHczl0+w5dT/7z0aYjyYpLDpYBzyWxuBeA/ba4MQWwZZNsK4IVk3EPo8FC5zboLYN4Q/D2E067kp0QWyCbwIjMDlXw6h2aFRiEtPQrILcNDC3DBpREpMSHinS+TaFBYnrQbQFGw3oN8FfN6l5BexUn/j7XbqzkOtDYEEyD+S0mt1zIUhBEEK/BWkXEpF+eH144zUBlyztMF7aIR3Bxh097vQEBjYGFukP3mQXAAB/cElEQVQoJlz2SAUZ+kYXpA1Rm3yvTPMC7qcMWr43xBBDPLcIn+BF9TjtVU/Y9vh/vvGaGnLf7wEMx9EhhtB43aWTfPDtV/Krn36UH/6DO85vb/RD/tOr9g0jkIb4jnHREuBHaSEwOEJMmSz1kTL9fo+pWpaUivDJEhGSIaKv8vhk2S3ajOzaIWnA1rE87fZVrLFDgywBSQpsU9EBShSkTfcxizPZCLd/KW1S1LBQqss0ERPUGSGiYDQQ5xTlNtQnwf8p2HgAGndkqCqT+Gse/jXAGIiXwz2tNI4HJD1Kp5aZekAykYFwATr7oLSlqN0jINPh/8/ef0dLdpYHvv93x8q56pw6OfXpHNStVpaQhJAQYDAm2AYMxjM2177jub7X964Z7MHp54A9wRd7xgbjMR6bYGwDg8ECSSgLxQ7qHE+OlXPt2vm9fxzgt7CRmgbb8rjrs9ZZ6lN7V9XutfQ+vZ/9Pu/zrudkzFaA9OYiyYsrJC4rnLxepXuvzA1lmxuOlChsQnoKNtfPsb08QIAujWgTM3tgq7XwxjrhvzjF4JEcc2NpOndfT6Rzhp0XG5yv7GOxaTF0voIcX6Uz6SMHoZ6ROTmwB3HMY2jtUwyoDVZ2p2jsH0N2FCYKp7jxjMlGAYIuHM0nuPj2d+AnYyiLzyJJZdz0KMRVkl3BQFdwLhxGb2+gzS8zN3gDvet2QzQM4fGtGWo9BqoHXg38FmgCrAZ4NnTaYJug6iClIR3BC42wGjDIu2dQnB7aGYWhJ4JMFUHsNolPCTbXmzjLKXqiRyRgE2zBzsmtUnXZgdg81BfA1WBgBAJnwEuCFIbwNoE/YKEHoXBZQg1LeD/hUXjJJ7rUolWsoJszaDUT86UKwTOCst5GkgR2A7oNnZPSCENuhZEuaB70ulvl15oMQbHVvLu1DEefi3Pi2SzVbo/xbXUGC1nSjszh61fIDMDIDdDzoXtBpWFPUMYnSpe4iDCEQaSTZpwcl3ywex4ZK8Sgq3PiKsbTlWYurjSr0dfX13et+25mgPuxtO9acf/eIe7dneeFhQoLG1WeXurw0LkiT1wq83Ovm0WS+psg9X3vrtkEOAE8I/XICY1Rv8L2YoiLUyqLqQ5qJ0e0uEJKyMhCYo08Ao2BQInhIZfFL0LrooaJS4AgMTzamOgkkWihMUAkfYFcyMFa18iQZIMUEyiMYzBFh5S+gbFnA/VmBzcM4SxcjEFhBFoDMLVYx3sigvJShvgDdZz3+jS7goRjEC6CpcLUk6C9pFLe6yKb0AxCOg1ZW6c3asNFicwTHfK+YFH2aZlpMsU2AbdLLAXzoShH7hhnW+EyqaTBaHOetW6YC3e9Bm/ffuhcJnr6IW4+0WUlG6b9/gDi8HaMSymWh0uMtc+Tdwfp9nx6CRkfwcmxOF5XxzsD159+mtywS+sC7MgX0Z8tMYJAt2G1DOU1iZCnMf/u6yHsM7jw14y4mxDwuayv05YT1JIxBtYbhDMO3Uwac/x2RO5OQIKADMKHkAKyCxF1qy5YAjolCFjgGhCytxbPBrqg9CAYBtmil91HIb5IZrTLQsWjUdAZPRlmsmkRfZ0g9qMWpSdLuJKgeQhq2yCuQfx6cNchsgr1BrTzW2uIxbqE3xUoExAcAveshucK5LCPWdBYyViY/7dgxxEYOr5C6aUaVjdMtTAL/giuPIeQC4TjVUK6T9RwiaVr5PNbFYwqoErfqGZsQO00dP5kL3bhdnw0FtXzNF7wyRElRxBaXaZuqhIeB60ls3JyDwt+GIdlsoQZJMB20pxjlQ0qNJQs0x2HNHmWKF/VeOonwH19fX3fn34C3Nf37RRZ4ubpDLMJuPfABE9eLnNitcFjF0rcs2vw1b68vv+FXbMJsI2MJ0Ks0OU2Wtxj6WQvpXhxukBvZ5CDdZsfPlDgpfkwTxttcqaMnmszkhQsPRQm0NzOKiVqdEiQZoAkQQwiqGT0VdIZG60I6oaGT4EcHYbIMcga2egi3bsbrLzVo5PY2p5xNAC18NbuR24IUvs8Rp520V0H5akAq/f1MCMKKddn4rJAqOAbMmYvS2m+ymDeIZaGxGUZXXW5tBpF39mmm6xRzQoyLY/yWpV0zGNhf5gHZxO4xFDMGuczecShCfRGEDe+E39mFCoOWuMZbnj+EruCEu37S9zeWGPtqXMszbyF5Q/8EMVnnidhbxJaazIse1wcHMCI7CVaPs0NldPEgy7NFWhPQK4KVAWXbopQDzqMz9jMmoL5EYGXrLBr4XmuNw0cE44nwTQUSEQws0kuhoqYEzchBsbBS0OwC7IKAQV8H2R9a9uOngGdFdB1sBvgdcH3QNMg7G/tu+mHwZRBT8NwiKXrb0M+9RRxyaTdtHgqK3MqpXFr3CaqQ/w+wWoYmhJsBsFQYGM/RG8EqwPP5SCgykSrMBP2mT4HcklmcU4mWIihjxtoB0xiD8tMnZM4c4vgyJ2wd6cgcbhNfr1N52QD/6UEpjvFEHXSu8EIWMQ2zhC60yYxulXe7AE1ARmguQrWPLSqgkHOkSRB1k1whBrLiktJaOywxmg5NernFU5fGOViO41PA58AA4SRkQiSQKVJUdFwwh5S2yFBlRwlNq5iPF2pecuVtvbo6+vru9Z9N02w+rG071qViwV4/61TfOzJef7Lw5e4e8fAq31Jff8Lu2YT4HN6B2OHyulFmURnCJkKt/kRWouTnGjPU3fSqGqNmXGH/GmdoAiTDxjIOQjd0qNtbSDWp1kREjP0GJLqJEWdbKSOEutyaSVGVu4yMW2Qd08zuqkg+WHC2w3cux1WboPlcQgI0BWo1cDpgvE5iXROIfuiRMXV6AiZsbaCut4j43tsPw7aeSi/BlZ2wS0XbOIyRHoQ+WwIbX2aTXmDtNrCksCWHZTAVpfhGcOlNSoIn3WwPqsQtaoMTHQYeKvDi5kw1rb7tsqJV8+hXF5k1/+cI3JO59GDFsVsgINNi2mlwsqFZ/CUnZj33IW9+TzSyCrrg1mc9HaUwipTZ6sMljzKArIzUE/CKVumvWcaMznK7GPP4y6oOF2XIclhtHCaiYggqMGKCrYGYWHTbjXxh7bRy7wGiEMgszWDq/rgOCBpIMvgtbbKnR0fggnolkDyv7H07Rv7xEk2+B0QFshh8NvgO9jjI1yM3YFaruBlkvjpAAS6rBUusbtdQlMFZ2XouhJjQlAPw0pWRXEEiupRj8rIjQDTwiF8YZTGoo4kaphCECFDsGmTmZcRVoL0U7Bje49zB6CUgebNUGjAyHUWDBwh+ODrkVSFqAqpeyGesbAiELRAtqBThc2CTGkTgs9FqJWzBByfIAVk6Syz4jBr7OSiXGWvm6DnHuDjZwLUPJnmsI4IV8hsjDONS5QGw0xgI9Mjg60pbDcW+AGKKESZJwMsfNfjKfKNn5fjf4/jtK+vr+9acaU4Cv1Y2ndt+99eM82nnl/m3GaLr54p8Ia9/Vngvu/NNZsAB/0QXU2hGG7wXKeLTJbX0+Ue6SIbHZ2sP0FrdYk9Owx+MlvFkurcerhHQMDUDkFu9xKJz5XJFcJM7miT1GxqL0Aw73NsKc15K0hadYg7JgMxn+Ben8RMk9ot0JzeysGGbCAAsgmKDvEumPMxvM/cxKpX5FxWJ92sEt6zitSBib+R0S5l6cQckgN1tLBP6O4G8Ud0tCUXCYuyVMPzxmh6TWrnKwSzXQIOiLug+4Jg9AzIJ5KstFRcprluXiAix5HfomztIbR+Fs28wN7P9Lju+fdwWnqKtdI5VA/GZYtTUgAvnoayQFp7idHPvUQ26nH5nSkcGSY+f5bgZcHpXpS05tEr9ogfhku3jeBk7iT14GOMHvWQq2k8uYZUkxhIOVT3S1xwItTsBL2YTMeZxJ/cDYno1v+lTgH8AqhhECHogFxYJfL8GeRilWS6hhtRaK7GcBIBlJujWNk4njoA4SjoAnwTjCI4IJkSIh0CTULkAzhjIyCpWx1mQmlKQ/uopIvIRhmv14GIz7rfQ40KDHRk1UYPgGTIpG2TW+cF4ZaL4evIjCFQkUlCq4V3NobkpQlvjBN57DzZ2TbBVchd3Cpbrx6Ekfe06Gy+SPfEGMrxLuEDNcQYGN9Yvtz+usKFRyZptwdpiwAJz8VCYJFhBy3iIkgYibuIsseJonCGx2JweacGl02kFUHISXCQDDMsESWNjcw8Qc4FbXK2we1+Ew2Hl1DZxyiXOPJdj6f+DHBfX1/f96c/A9zX98pSEZ1/ffsUv/foZf7LwxdIBBWWCjWmh+Gm6SyK3F8X3PfduWYT4Ha8BR0NcwTU6gj7PY1BjjGRqqJbYYLRiwwNGaQVeO1rLHwJ1IGtKlrbAQJw8G1dbvC7pHZCYRXO+VBTobaYJYlL0MvQC5Twf9jG3Q2VOJQFWD6oLuga9Cxw2qBmt7Y3mPyJNpr5EhdODRBxqkxPVVFnXAIGBNdDqLKLM2vSNCTkz2Z4Zn2C20yfQPMMRTtBTTTxCRImzpSTI1JZZX1HmdM7I0yNdVH/FmaenEVXVlgLn+GF6yTqd4/Ry4wgFb9OqrXCa06vkTx7O2e4yCVRZ/TcAKHOJq28jHXIg0QRxlTEYgxjTSKpeWRf3KB79zCJqIEf9BnsZuhZEpHOMhlNcEpM4IRtxntrYGq09lXwFqOE7BBP5VQ2t+3Hzk9APAymAn4QRjQw21BeA9mDWBulCp4ZIrw+z56/vYj0kobreARyJr4TIFUDTykweMIn8g6XlZiKkw6zkNyFHUmBVyE6N8e2ow6tpEzlxjBKQsII6ViD27cW2QJIHn5Yxw8MQjwCtkndDiMFt/bl9D0LU9IRvo8tC87ugPG3bZD/goZV307a3oZLnbI3Sg1BjxxxMUn8aIbBkUfRSx6lr2dJJuuMjdnUDkLo/1qm+akOF792J6OPPkEyWkdZht6GzOoLO3C6o3RZQWMbTVQMDExMTjLKENtoEmSaEjWyDFBisjPA2qkw3ayNEAF8R8VBIBGjxQAdPOaRCTguB/weCWROk2YbQVKM8/mrGE/9NcB9fX1935/+GuC+viv713dM8cdPL7BQMfixT3zzQf08o6kQH3rTrn6H6L7vyjWbACuhNcaLOpPWEPd5NUZZZkypYmqC1w53UWJdQhooPogueDrYLZA8UGNbVbhSGOQIGB2ITMD+n4TlIsyvVeh0ZIZ31rnu7R7qDqiboMigS+BYW9vVmE1I69DTthoY1yRYHxIk319heKOKyAicGeheBL0KqX1dtBWDYVfjyJ9PUpLiBGnTkhwyQZmqsQOJNjlK1LHQdY3YToPLd8qM2hb7zgjClyM0po9TvMGnlof2dALiARBlpEKb5NlNgp/M4bbBpsWEFCYZWaa3lqe2AfWpJQLlZUZfXEZvKtSDDsVCAHWuxXT8GYZUQS4BjZrC6kCd83sFgxrI3Rohv8t03sG/38FdlOm5Ki/dF6T7g3dD2NtKduttUFIQEqD7MO9AKUw49hijXy2wrWezOKMQLbsk1mRqRgZNMlHaFr7nIetVHMnDmNOZfcbmlsM28azNFytHedEcpJNQsRWJYMwjUfYY/nIT+2aJc7NBLKUKoeTWfpkhBYS0VWotPAhIoIYQTgt6BqrvISIeignBKKzYIB+CRMRBrZxDnFrAK+qMbOyjJAKsIZigQbg3RPRzN1NRjtF2bCbSLj1AtSAwAIf/zyrn5udor8VJfK1B4GQSyxnA8/fRw8IixIh0jrgY5mniGHRYlrqUhE2PIFV8eghS6LxOFGh3D/NcsIgIODj6Npq2jsZOdNJsYCIhc7tXJcM8HRJU8AhgsMiLVzWeVH/r55WO9/X19fW9vCvF0W+e09d3LXt2roJhewAMxAL8xXt30/ADfPTJBX7m08f56HsOcd/ufml03yu7ZhPg/2t9ku0IgtSJU0VQRdVNNB3UHigSqBHQVVAEtFXoyVsVuBpgSaC50KtvNSLuXoLqgkJw0uOt/2cNJwraAGhBaHchF99aXus6ENGg4W9V5Xa+8Vmuv7W2J+SDNwTttMA9rWA8odCcS27t7tMOEu91CRcdJCIE5CmGegE2cFipDRFFZVSzGEiXCXZCJA91ib9HcH0Bpv4yQuZ0AmvC4IV3SVy671bUixeY/usasYUahcMK2u4MIUlGjxjE25fZM9qgPGITmPFYK/c4mcvhHphk9MI6O79qY2Q9MkPgKzaBokD8tU+vlaadrdGZWiN5wMHctTWzrSgLjGz4oEO8CVrd54U7mjh5GPyDz9GLOGQmfJZvP4A/uBfMBtqJDeLzFxkx6uSfNgmeDeJoCrNxQTsqCAiX0fQmnioQIUFHeFh1SKugjfVYWoJeAca6cGDUQbfWOGIEqSVjdAM9xDxsphUKs0PY+3IgbJDKW2uHGw6gbk35ywIcD6VrIgyNADIBSQIbYpqg7UJKBycLxzMgPMHw7T0mqj20vz5B6qzMgZ5KkcMIBvDcnYy4CtuGvo55p89gBpo+KCHoAsM/cg77IwlcBHq8R7YcwKOOIp0nE20ymGoTXE+w19vNQxQwVI+eniRqbFAXaeK4XJL2caN4ihmR5lh7FCvURbc0Noiwho5LnTph9rHCFMcIEWaONEU8RjDoULqq8aR+Y5epVzre19fX1/fyrhRHv3lOX9+1yvMFv/HAee7ekePUWpNS2+KRS3V+6rW7+Ph7D/OBTx7lN79ynnt29htk9b2yVz0B/oM/+AP+03/6TxQKBQ4cOMB//a//lRtvvPFlz//IRz7CRz/6UVZWVshms7zjHe/gwx/+MMFg8Kq+9xAZAhgIHMKY6Jiopg9VEz8Kirm1a05wGDoBMAXgg90GOwrtBpgWZPdBYxlO/lmWajNHbGKJ2z7UQw9DMACeDNEoeB4oHlg2xFQIBGETkHpbk52dJkRCwOdl3KMaYQfE/H7StkIHD4ceGsNEKRMaP8l05iJioctQOIhp6zSCNWKJFndYbeS7fJ7e3aE5APFV2P/HaZLF/ZixBaK7y0w0JaT/fgb1b/IEStsQygL70xts0zeRl8G73eRisY3YIzi+fZRWNk20fJFUskUpfg+NKhSzS4R7gu23QPGixPmTUWIukLG5/BM6hehOWLW5vnKemA7Xx03yX1MJnNXxZ20KPwLlLGz7UgPt+Agt4ZOc2mR5uw95j5GFx7ilUiCo+LjnwFqQSAwZ2O5W4ikWFboZgbvDI9AANQSSAUEJtAjE9kCwBeUL0PkaJG6D0AjsiVsciWpcui4BExbWjjCM6lDf2Jr1JYhctwhYNorhIBsCWThkOiajro/ckxhAMOKB6EE0CQ8PQiMOWgg8E4QKjTykInD45g5fLWg01yYIs0CHIAnADFbID/p0n9Z48qEAoaRH5pCNeLNH4noPe6JDt6YTPWTSfe4SaqvN9lgFe1sPrwaWb5EkSIQhTKmCSI6RN+uEvTYBCrgizmny3E2YcXuW1dIauhNHQdBCw0BhDzbbtScYledpWFM8jEtZ7eG4GuPErmo8ye7Wzysd7+vr6+t7eVeKo988p6/vWvXiYo21eo/ff9dBTq42+LUvn+OPnl3jh2/ZRioS4Gfu2sbbP/osR5ZqzCZe7avt++fsVU2A//Iv/5Kf//mf52Mf+xg33XQTH/nIR3j961/PxYsXGRj4+09vPvOZz/DBD36QT3ziE9x6661cunSJ97///UiSxO/+7u9e1XfbqOhESBNHw6VHA1coqO0QbcMkqEhIoz7WBkij4NS29nY1HVAScOyZIKslDXXewDo/TroxQIRFUoZLoAiB+FZCW3UgLMOGAUFnaymrLEFtDUqXFTqWIGP5RHZDfRqWcj5Vzad9forNeJB8zaCsbjLpDhOiTVeqk4rBzW91MM1FhpPQDsFZG0QcLhyHzi7YGIWcC2IFpJk6l+58mkt7fM6KKDu9LodKFaQBnxODK8xP2ewdhflToC1C+maJSVvm8qpP7c3ToEXxaqsceK7B+eozbIyrnHlLjOv+to3zpILmS4z0Jmkka8z/UJfejbsQ6+PoZpuZRy9hJz0uzqn4T4wzPFTAuN2mmpGwQ1N01CIjg0XytTD1tASDECxd4t7NTcKbgkoFqkfAnBCoSUgNCwoXwcu4KCkwLAht+8YeudbW1r+yD5ES9NoQCm81kSq2IBaDyZDANjscH89j74yADBgdJF0jcbbH8NdrpF8UjMdstEFBYjs4ya1m0kEDgqZALYCysbUfr2zDLffChZ0w7kBRhc0QBAW4KixGIZLzOb5uUQ8Idpub3BidJ7y/hhgEZVli4eIQq02N0bkaN2glDv+IT/QOj/Ync4hDJfz9Fs4zNu1uCn3VJy4sLKlGXBiMEGXcjjG4sUZTbD2laRJERqHFHkp47BUJfKtCC4khZGpobKfCDfrDDKbmsGuTrPMa5qQeuiuxRocAvasaT5K7tdXyKx3v6+vr63t5V4qj3zynr+9aVWpvlUDsGIyxZzjOp59fZq7c5cNfvcB/fMcBduRj3zjPYjYReDUvte+fuVc1Af7d3/1dfuqnfoqf+ImfAOBjH/sYDzzwAJ/4xCf44Ac/+PfOf/bZZ7ntttt497vfDcDk5CTvete7eOGFF172OyzLwrKsb/3earUAaGCio9GjjIeNjo5JFocuwrPwFEHP2NouttgDxQGvCt44NAz4shnmUnoUzpik2tO8nTo7BuuEDjt4AhwTurWt2eKQBPqJrW1qbQWa58J85ZExzjQiBD2X65UW4XcuIU1C7kchcpOD+f8YqMs9NiSNSSfHdlZRwy1cT6VxcYDOpzqsv7nD6VFIZeGkDQM9sN4AKwGwXbBXwRdw4e2CdtQjZMGw1KWgC5Ia3C1qrExLnIrFaX5cQp5P47gRIp+HnmZw+v0eSDKpJ4+y83wb/8kJJsp70aOXWH1fh823S+z4Hwqzt1osj11i8aCDM5nh+q9eojQ9T72u4xyNc35/k+5imhlXxdpjEApCsC4IbdTYmIhg75S57lKLuX05/ESM+PmzhOuCxhrYl4CYRCIqaJ2Os7lkEXQsmiHQL8sgS1i+R0dAfifEutB0wS6AV4OoAWEF2quQHgDDhsmooN0scjaQBdUk3PTY9SWTw49DrhjEdZKYNJC1HtaIjzYLdgI0C8wCiA0w2JpppgcDT8DtEXhxBhrfWDosElALwYl7IZnymKpVcItJAqpNY6KFNh+ms6YwdEOb8cU2q4yzpFvkHwxy/Y0GqR0eZdIUn4ozfuslrKEGixsHcco7GVDOMOQrCAq8g1mq1EmKOVbYQ40sCg0K2BSxqGAxgsJFskj0UBkkQI/rlecZHLhErzrESecwn6NERWoSF3FUNJpXO5g7wCs1X+xc7Qf2/V1XUy3zx3/8x/z5n/85Z86cAeD666/nt37rt77t/Pe///382Z/92be97/Wvfz0PPvjgP95foq+v7+VdKY5+85y+vmvUQGyr2vNisc2h8RS/+UN7+ZGPv8BfHV3jhw6OoqvyN87rJ799r+xVS4Bt2+bYsWP8wi/8wrdek2WZ173udTz33HPf8T233norn/rUp3jxxRe58cYbWVhY4Ctf+Qrvfe97X/Z7PvzhD/Nrv/Zrf+/1EAIJCQsZD58GHgo+AXwcZGxXEBJbiVWkCv4QtCWIxeHJOVhRQ8iORKKdJugNEtZaxO90YHarydXgALS/MRN57I/S9J4QGIrPhr2dBS9G0fXoDmyiN1SKZgrxQomRnQbdKgSWFbbdtoZe9xirHyLECvPqKA07SCuj4XoW0xdhWLwEL1mM6QrJKZfMdtjMwaoPmg3Zv9I4IFzmbxdYx4BnQGQF3AGjZwJ4j8/gvPUi6q4u4VIG2xkjqTioSotn725Sv3eUbZ8+wvDnhkkbs1RFhpZcRIg2uc/KhP93H/ETFk96Mqd+cJDdhTUyR8rsOAWPK0GcboyWVCPc8pGrIbzMOo2dMBWAsU1QnzCR1kKcf02Ih980gT+YgkCLwWYddRXMOejFwJ8QaA6suwryagaLOnLChoiPsZlAGG3Ct7t4BlQscA2Q2mBXoOeBHZDQT2t0dti4M+BFoIsPdoew6fCGIw57X4BsEFqJLo5voDcU3KCPVAC5DV4QLAGuBUoOOrJE73IaT7TRgjbpCnQPgjwMcRcCHjgeBDUwdsPuD/bIn++RLxcIVQS2AKukYZyAKbXLxUqc1ZzCxmaY+jMXyN7jUI3LrBbuQG6tEL/epr6hsEGIjncTyzQ4JUm8XmwwQwkbGQ2fqmSSEFnGsDiBSYoWKaIcIopKHBeFIR5jX+YYwtI50ruOJ3FZiBTxpQhu1ycgbGSucqGZ842fVzre9z272mqZJ554gne9613ceuutBINBfud3fof77ruPs2fPMjIy8q3z7r//fv70T//0W78HAv2bhr6+V82V4ijfxfG+vn/BbpxKM5oK8YePz/Hx9x7mhsk0bz8wwOdPlviFL5xiKhthLB3ihsk0jXrt1b7cvn/GXrUEuFKp4Hkeg4Pf3qltcHCQCxcufMf3vPvd76ZSqXD77bcjhMB1XX76p3+aX/zFX3zZ7/mFX/gFfv7nf/5bv7daLcbGxqhhEkBHxcLDwieORwSPTXw0bNGlZHTRwgJJBbcGqdGtJEhZh9Ell6zbZNiRidFhYOQUC2cUHnlokHSqzU1nfFYMn4sXxhlbSTOinuVhaYrFbBBPtzi07GH1AlQGHOyKydTcOBv/tUDXVOi2UojMKrn2ICZRTPawFgmDadLVF/FjFhcIETt7A/FzF9gkQj7gkNheZvxem/aNUD0HO56aws0tkys4HKn5zJeTbF+FGyNNIqtx8EewAvO4O8ZwDywT2+ySvqHLRU1m7YYU01+eQ/urES73gsTo0WCF5Ogc+R/osPJQlNhfapjvdWgEdVRf45YzgtgDA6zYgs039YgaJgPmMIq0gEhvIiYcKoOQXAH1CDAXJWumeONzl3jw9iDNXBSp6ZAM+BibEh4CYUPPBD0KSSwCMYOQKVOTVETIwpO62CGXMRn8AOgmdCoQsiGqgywDkoTfDNLx7K313EBZUcGFEcNh6CXw2xLtmIBR0MIC47SLbypIjoxn+yh5DyLgytC0obqp4dphTK1FoKIw2fGYFXDKgKgPChAVWx2+tRgY22BbDtx1gfkpGSsE4Xt6rD2uIFXTDIoY7ZJDhAk2HqkxdPM6ymCLYCFA+XKSsdcXGBpepLyxiwoSZUJYwuZZKsA4a/icVEpshFaJd8e4VYQYI0aILsN46OTpEiPFAoPaJaJ4HK1O8Tg6xwLLOJkWGAZ0AxhoDDMLnP3uB7QD2Fc43vc9u9pqmU9/+tPf9vt//+//nc9//vM8+uijvO997/vW64FAgHw+/4978X19fd+dK8XRb57T13eNUmSJD71pFz/z6eN84JNH+ek7p/lXNw3x2OU6S1WDparBx37sUH8/4L4retWbYF2NJ554gt/6rd/iD//wD7npppuYm5vj537u5/j1X/91fumXfuk7vicQCHzHWY02OwiiUyKEQRQHB5cIDWYYB2LiEoF2jaBpE5EslFyT512VyyfDLNVD3Oo3yUk+c/IQXQGmEWCzFkLqjrDchI2lFBfiProqsU0c4dHAOJdGU2gFg+lqix16kSlLoim1iZu7OSdGOFeeIe5tkAHy5UF2kKBIFUstcU9LpihmOdoNY3kCz2sxFxhk1s5QFTY9cwjtVAw7fpnWDR52D1qyQqcwzUphlSXZoSnrVB1B7YJM5LoqLxx4AvNmh9H2OskBh/wNDvo4IHvcsVzF+0KSI1aCCcrUiTGNTmGbwcnrI3h5yB11eCoqUUqk0CNN2o5gSu3y4g4J40CMGz9RJJXo0pqFgRmbUzLIXcieA7MCw66gxyZpzyFXLtIUMSSxjp8SiI6M5AksU8I/JdPO+iQSFl7co+Er6EUJtwIBP0TUFARqDra9VaYeFVtbRVgdCU0TmJJMMGCxOgDtzNb9gylkdNdjdBHESzFk0yO+20DfA70W2Bdk2q0wKiq+1CbQg3Zqq5GZswayamNLBWKOhl0fYn1tiZmax0oYQjIgQcDfKsPWgYwMWcAtwfn5DG4zw/k5j8s9n+v8YRSpQysjYzQapBpN6l+FULPBIEs0Vm6g9NLX2b53k8DGMBngBGMs0qJAmkcIonGaWzyPxc4YOho6HlVkYnis0uYcSYawGKPNUMCg3Q1x2t/PBalBL1wAKQmSgyqbDHnTVKhe3eC0eeUbtyvd1PW9rO+lWubvMgwDx3FIp9Pf9voTTzzBwMAAqVSK1772tfzGb/wGmUzmO37Gyy0n6evr+wdypTjKd3G8r+9fuPv3DvHR9xziNx44zzs+9vy3HZMlGE2FeX6hysJGlelhuGk620+I+/6eVy0BzmazKIpCsVj8tteLxeLLzkj80i/9Eu9973v5yZ/8SQD27dtHt9vlAx/4AP/hP/wHZFn+rr//z5MlMFRytqBHiI1oBlMxUJoSh1HZzvX0sDAciTQq6+tdTsuCYkzGDyhMNtuYUppC1CHudpGq13EKjwp1mjEdyS2QaQ2S0E5zSoaXUj7UF9nejHHP4DzDOMRmwJmGcxfmUU/a7LFlctoSk84NBLmJRugyQ5MvEpNbbHYkUoUCm40cy6pPSBtiu6syIoap4BDHwiWKbOjsa/doK6AHPDQnz0RsnrajEfKrjIsgTh7sN/oMFXxGlkGt96g/BZG3gDQPh7oQE4KVbU1iK5eJxU16pTq6GkYd8hHCwd4RxmhJTD0qiF8qYk8LLt4B8XwXJiS2qzYz+LRzFmoOxCKEx2BWhYEA+PfC3JcbWOsxlnwVWXNABsXdajLmbffxn4zhSx5INspmkNC2Ho4FUtonkBK486DtaBM84FPMw9BFMG0IREDpAEFodALIYhA3U8MNWqzpOsLy8HSHkCyIOyB3g/ipFvL41pptPQzarI8muoRqeVzXRtRVdNXEGgRZU7C7MSIiiE2CCBGqmxI7n4HcIWgObJXKJwIQiYBbBFuAfQIufDpNubYXhU3M5gHqsS6X3QDTvsxgz6Uo9zhhjHDrE3Pojd34jJEVLr0To0jJFTRGyFLmNpYZYx8nabCHKhBHosNuWlgk+aLawRKCspdmkwBVetyARpBFhDC5ZI1xRorTCK5DbHRrv2OtjgKc07oUwm2uaiFw9/s83veyvpdqmb/r3//7f8/w8DCve93rvvXa/fffz9ve9jampqaYn5/nF3/xF3nDG97Ac889h6Iof+8zXm45SV9f3z+Q7yZO9mNpXx/37x3i3t15XliofCPRzfA/nl3i4XMl3vaHz2J739wwe57RVIgPvWlXf2/gvm/zqiXAuq5z/fXX8+ijj/LWt74VAN/3efTRR/nZn/3Z7/gewzD+XpL7zRs1IcRVff/CgQ5sCtZWyshKHXM4CoFtyDV4ypV50dVRDJ+Rno2PzoocphvuQbAM2yVKJyRM9zy+0mFne4hLCJYki4DkY8cbSPUAda3LIDYFbSdeLkOwUmA2dY5H2hnSnuCtdpn4HT43XNchs7RCqTwNzn3Y8iDewceYed8cWtqHJyD8kiDa7XBjZYaUDQG1TD5aINmModNBIkiTNP6JUSL/bY54UmDMXiZdWUU74KDN2mxcAKfRY/I1PpFFKH5OxjcUQgMumiQIdGCzBTM6tIcg9EM+r3nBwJRhJNEj4/VoHoCgcDDtJL7owXMO7UqAQMNh5SaXlT1wU1tw4JKNvxRmYTVP+tQirWHB2V3Q1SFzHYSPQrSi0kDQkGGm41IqzdMzPSpNiOmQCHgY3RS61ECK9mjLIPkS0tFRPE2lPrbCyo8oNKei2AmXneEut816yBWoGdAuB+iINIJJYsJBhDt4MRC+hBQR2LZMN+GTDPQIJlwiMyAnobgKXgJ8OYTHIFGC1GkiySaKBRI6UTFIlzYSaZBbDEZdumtw2IELN0JYA0sBVYWcAkGgsihRXI6gUCSKTZ0uN7UjDGJj6SY3GwN8OV7m0WCGRmCdO9IXOTt/iA5hDjtZKuUcL6Cxh23cFfwy445GyjNoU+SvUiPUol2mak1yPY2bXYMku2kSY4Yj3IxBFpOgtAi2TMGd4VywiqPa4MUgJ4EqaLVUmn4Rd7B7dQmwzdYG2a90vO9V8du//dt89rOf5Yknnvi27eJ+9Ed/9Ft/3rdvH/v372dmZoYnnniCe+655+99zsstJ+nr6/sHcqU4+s1z+vr6UGSJm6czzCYgk8mwUuvx8LkStufzr26b5McPZag4Gh99coGf+fRx/uBdB7lh6EoDrO9a8aqWQP/8z/88P/7jP87hw4e58cYb+chHPkK32/3WOrf3ve99jIyM8OEPfxiAN7/5zfzu7/4uBw8e/FYJ9C/90i/x5je/+TvOWLwiuQG3jGEPszXlN5gBXcOv6YgzHo5boJuGyGaAgGHgBCQIqxBXUboSzZyN78pIIZ8zRg3ZHsYLybTGDbTmMo4YxMn4ZEsHsWWf3GKHmyLLpHabLCxOczHeI30izS1/sUz2Bw2SN/coXV5GxMuM39Zk9M4efhf8Jlj7IBmB5b+KE2GIw9EXCf/AKvKShnhhAkfoQJsGbWzfon06SDioMnBnGylicikrOH4vJO+HTs/nxEVI/94YK5txAiLAcLlBLLyJVuqRnYBTI9DMgJ+A0SEIC/AcuNSDi9kkmSNtlFqRRtRnqJtnRHYQfpkDD8PlN8BzOxXK64KDFQ1ddtB9WDYg9AI0d8Fnc3D3AIyM9Vhe75GWIHwBglMGkTSMGTA0AJ1pg8i6TLceQx3sEhiCcFhQNOs4hUnO3BygfdsAdAQEbM4flqgUO9xW8hhwgKJE2c4yiIcy2KIalxBdUHwXIUCP+mzmoBY3GTB96udAz4NUAb8Abm0YlxgrlFC0Bokw9Io6RmeSFipdhtARiMQ6sRlor8PcXwyz+DXYc6BC4Hab9J2gmRAPQHSvwMqtIQKQy8u0z2oIO07+npeQxlxWvzxJvDFMzTFpNqdpj59hST7Kmr+LFgN0KbAWuYhj7WbKnSEkEkRklzI+DTmDpS5xYcqnuOAyYNzBYTLABiPBr+PaIVQ/gC0ENXeIS0wxYLrIpkRdL0MyBE4MZ8RErgZBeFc3nvoJ8D+a76Va5pv+83/+z/z2b/82jzzyCPv373/Fc6enp8lms8zNzX3HBPjllpP09fX9A+knwH193xPPF/y3x+fYmY9xodDms0dW+aHdCQ5ODfDx9x7mA588yoe/eoG/fv/eV/tS+/6ZeFUT4B/5kR+hXC7zy7/8yxQKBa677joefPDBb5X6raysfNuM74c+9CEkSeJDH/oQ6+vr5HI53vzmN/Obv/mbV//lEwHolqGhklmEXeoCYc9iyMySNS0GsZhTLB6KTNLWQiT0Hg0phrKZZOyySinWoDmqIdphfCXN68myYvqcWfPoKgMwncLN6TwvN7mjssoPqlXUCY81HZychetHmRMzDJpFtu8yGN/jc73XohJq0XXhQgW6v6+jriTohT3Gbm8z894NGg/+DZGsgx6EuQsyNdEjRoQN1niJMFbIZ8Cd5E65ymapzdKpYcLHohyS5oj8qMdlG6ZOSXSbcayEQyS/SWBPi4TlUjoMlRjkahA+BeEo9DoKy4c8zowE6emgXxAMfTaO3dxGOnURZVeVId+lfEmjciKAe7iDeUjjfF5mlxDk96xjBQXeMzJxR2Pg6QC5g126d3ioMYgd39oy6OikhK0LMgIiAiRl6/vFGzt0vizRXAkjr/qEh0zsroQVrNI9EIK2RdCuMb7oslvzqGQkaiZEd4F63mdHPY6anaP0+i7aGMR0G18FKwBBb6tRlrLDReuAKIFZBKcA/ooMvkSROlV8VDdMM93GD0vEm8PUKaIhIVMnPdImMATiiShmZ4xuJ8PxpTahRzvk33iBbW/vMRoCbRI2AzqWK3Akl6ZSYFZkiO+CCxdDXKqlGXUSjBBhVp8n0JTpCJeYNE9eTOMRoIFMT5LYcN7EDmIElC+yPdLlUKPMvC2hbewnYuXRUDA5xwYKZfMuLhFHAV6LQV0kkBlmhg4mXRpyFOEZILoQ6CGGOqDrVzee+k2w/tF8L9UyAP/xP/5HfvM3f5OHHnqIw4cPX/F71tbWqFarDA0N/UNdel9f39XoN8Hq6/ueHFmqsVbv8fmfvoXffvACR5bq/NpDi3zmp/LomsrP3LWNt3/0WU6st7kvl321L7fvn4FXvQnWz/7sz77sTdwTTzzxbb+rqsqv/Mqv8Cu/8ivf/xd/rQSSgxLzkYTN9dXDHKaNSRQPBUnq8XqvzV2tS7RoIlkw13K5JO7gRT1Na1sT4lXoZRGWwgmqyL5BsmOjhWJUsxJslukEBZKXRq/NUn+pSjy/xKhZZ2lgnEuzNW5PNDEMOFuC5c+FaJgyQ0NdwtshNA5Lx/Yi3Bzx1RW07ccIOA7sg0oLopbOIl3msVEJ4NFDclSEZjA/XWPzYgxHqjPR0zm4qnBf3eOCBc9vE+j/9iz3JkDoIMdg4Cx4aVivQeevYaUgkVR1tMY4gw82CN5VY3FMMFiwMHSdIl22mSFyd7SwDEgWYa0YI3SqS+xGh7at4w51GL7Op3kCggKaXhKpqrH3KZuC5/Gl10JzFhoBlZ4cJie3yfUEeQkEIDehI0Flp0PwZJLJfQWMAoQ6MRaGLcSQje6a7D1pk/rzFLGpBtuGfarPBtACPvJGAH/wHE++v07t8Nb2R4q/9YA9oUEgAAMWTExDdh9Yl6B9EmQXmppCizgWJgIbXwTxNIMxS6ODwiA+C1QZimwQPuRBB2qVIHkGUajTwWSjo2B8cQ+diWM4bxDEsjDyGpvGV2D1VJi8Y5P3izgPKmxaMqcTHlG7zGvbQ+wngaMrZKUGZ8IBap0V7pAuMtP1KTHBC0qTuHeG3YkTJFNt/rV+gmYtTE9UqBPDROeLWAyQ4zBDSIBAo0wGC4c8Hut0sHGRugpizQMzihy0UYSJM7kD2Pjux1MH8F/huPF9jNW+q66W+Z3f+R1++Zd/mc985jNMTk5SKBQAiEajRKNROp0Ov/Zrv8bb3/528vk88/Pz/Lt/9+/Ytm0br3/961+1v2df3zXtSnEU+rG0r+87KLW3GjTuHIrz4bft5y3/7escXWnxnx++xC++aTc78jEAKp3+E6S+La96AvyqiQ4hx+bRrRUqyTR/LK/xlWaUVkyhu7OCUEySaxHuXZviJrHCgFwkLxRG6OC6El8VmwjXQ+kGaWt1NqwKhiojSCImfAg1IOQS7IbI+QFeEmMsGxPsWdzNIVYp9S7TS9Z55rExEvImQ/stlp4cZxmHx4Iegw/q7B1qEJh+Ae3ybTTsDrHL4O6F6DS4TypUrWnm8SjTICjHcH2NQb/FoYkmY29wOfbxPGYnjxw4Tytn80AbdsZhejuYVbA80KugzUEnCkMqbPTAL0qELZBMSN26wJlQgOJphbEHgnSNELtDJfbMnid0eQD5iTDFHzUIvMkjcqHETdOCr1UFnYSN8+M+cRvOC6AlE1oThKwWq26QlGriBySMNAx2PXyzw4AuOOyDKoA1aKmQWIK5bSbqokN5IY/Z8cgJgTVdh0yM8LxJ4FFYLfqIkCCYgUhHQjJBDXeQpn3UPZBIgZaFkAGIrQpfS4b4HJhPQy8MgTDEt0FnBNQjHkq1TFDu4sc7OLMek9s8Ol+YwqKDJBXYlW0QmvYJDYF1ElqmTAOfIDYSeeK0qDp18ksSniHouDB+jyBpw9jZLp1LE6yLCPKlCCsJFT+9QssZ5EnXRhg3M706w0FKdLsDpNGIiU3SdJE5yTNBicu9NSY6SRRDZnKkyXC8TaB5jq/WDJ4S+zBJMYpPBA2bDgqwgkwYBQOfNWoYksD3TJQVGxkHV03iBVwwUlc3nvozwP+orrZa5qMf/Si2bfOOd7zj2z7nV37lV/jVX/1VFEXh1KlT/Nmf/RmNRoPh4WHuu+8+fv3Xf71f5tzX92rpzwD39X1PBmJb/25dLLY5NJ7iP759Hz/7Fyf4+NOL7B1Nko9v9b9YrPV4fqHKTdNZ+n2hr23XbAJ8y/x9bJfX+Z+ph+klK7iOQG5mqIUvI3XO40YVun6cv5Xv5JI6yOroKtvWLN5qlYjLl5C0LEPnE+ytDXKBCBWljTdgI2KrEOsQPaWTUWR2Jarsn3D59ItRSk6GptC5mQMcaoZ40T1H1PHpliT0LLRyDebkAXxbodVxsJe3sYcik7HnaLVGeEjcQfLCGge/eJn1c8PYfpgoDgYOFTVH3slzUD/F7DaDYBl2sYYVbCH5PSonJYwpgZaBgRMQPqIx31VYBORmlNF3VgjlITEKtfsEVh1cxyI6BfkJA3lVIjDkkOu16cwJsq0gi36GPeuC4Y7BhXuhd7vHwz3YjMmkWh5rM7D7qxLRsyHGDveQDpVY/MoUvh1ncGeDWFKQkWD6Aiy9qJBxAjDaQx4A193qnKy2IV+C2vVNIg8dZjy8SivXonyTQPigGx5qERKig9YRBNclBhwIDDv0HBiowKVVWBwBUYOADoith+yJVYg8JuMuqEgLNv42sMqgBiEb9dH1Gu5Uj8AhF9eQcB8ZQetO4lMnLXuEZn3ybwP7axrdx3MIx6FFDYMU0EHFx491iBzyiaugeqBkQTkMjcsQSJTJVkN4wma6PcFa0iRYyTBrJInT4hliZBlij0gSRNBhAJkWCRY41M1xMpzhnFwhLXW4ZamErJexrN18XYmymIZUXXDGUbCwaOFxiBxFvK19kKnh4RASCh25g6/Z+EGNYNtBsyO0PZ+raivn8MrRpH/T9n27mmqZpaWlV/ysUCjEQw899A90ZX19ff8grhRHv3lOX1/ft7lhMs1oKsQfPj7Hx997mDfuG+J9c0X+/MgmP/+XL6F84wHxnzy/wZ88v8FoKsQvvmFnvynWNeyaTYBNr4LtpZho3MLpfc/hVbusUMKZXkWyNURqDC54VEYsqmGBmLDodi1uK8ToyEEkPcJsK8x99JilyfN+nosGeKLNxEqJHx1c5ZbbfWQVJB/yL13ivDSO49U55mfIiO148TCX1BB7C8+S7hR4x08Vqf4PjTk1gzu4xLrn01o7yJAdwUGloskM55o01lSOla6ni09EXuKGfIVjhSSIZYQ5Rv2Eg/KGIsGJHolYD60tUR4Q7JWg9F9jUJGomTIX3QAgkwxqOHm4PAI1B1pvgcQFSL4o4X05geilaHsRXEnnkrpJxhQU3BgBxpE7KsFqmYApiC9AtyZxneVz/bjgYhhe3CXQHx4gcjpEL93A7XUJSXXqc9A6AJNrsPFXaazCDDYmbvsMLAiMJRlF88GDyTJMSD5rwy9h/5DN+oDAn4Ww1yaQ8cnNglVQiVYiKM0uftRD5MA/IxN2Asws9AhPwHh9q8nV2Rj0FBj7CmgnNKqajXhWIrYhkGsQSYCIg3p9G28YxGWZ5pkRZHMKizUkuYq2r0vuNWA+D6efStOzdzGISYAOGutECDMqRXBu2KA+AcUGZFWIyJAZg+Cd4M0ZmC8uIZXDXOfGsJf2kBSQIoaLzbzUYU5KksaljokbN5El0NtxWpkqvWEPCqusJoNcmp/F3T4LpoPb9hDTEsWlNuVSjjm1w83GAGPE8TFZoY1EgCmSVOlRkXT8IEhKGUQbS7WJGTu4ql1eu8Ar9c0yv4/B2tfX13ctuFIchX4s7ev7DhRZ4kNv2sXPfPo4H/jkUX76zml+/MYhnlposlQ1cH2fn717hnfuTX6rM/S/+YuX+O03b+Odmcyrffl9r4JrNgF+aeoJTvklwpkuSqOFl4vSa6mwLiMGI3BRI2zsxNU9nPYqUqnARCtDggr32Elax5OcTLq8qXKZ16KTEwPsb7SQGjYHU2XGkz5mG0IuuKpExg8T8B10X2MhusS8rpMrJrhdKZHe06Urwf5dcOfOdZaPN/G8IMlKHJUgBX+EYXLca53l8HtKVC6pbM6FWKTFbSKLkCEgCUJobOChtQPs0AENhCuTu8NnaASkAhhxh+bKEI4fJolGgw51vcmeAPQMWFHAcmHkb0LY50dZ8myaxGlRQ1INdHMAgyZVeoynj1J6Q4OLNwuSS+D9WZLY5jS28DjxQ6foXSewsrDvfctU/jyKU9hPJjxHdleDy4dBHYBcHSqajS4V0KUSvXUJf0wwOu1jmOC2oa0qxDdDnHhHh5UbIGhDLAJux0fSoNsLkXYmCenrBMdcpCh4FYmgpyJ3Zsg+sIn+VIJ4PUz3354hcieE1iF6TMEMeuSGBJsXVTzDY3BcIC+CFAJNBzEn4dRyaF6MHiU0TFLjG0y/0cVdhMKDGoVeCA/BRHSNbH4NuQnBRhBNV1AOmhQFbB6TaG5IiOt8IhpIu0AdhIxs0viaTNBcIC1mOaPHSdtNevSwhUp7zKKh6ejrHczZEkgl9LNRgg2PnqSDMgPrAstT8KtdCNVBX4LyICgpkD3GezlmyRLBJYPEKgIXQQcPGw08H7QueqdIVESIuTk8lq8uAbaBV9qGu9+5tK+vr++VXSmOfvOcvr6+v+f+vUN89D2H+I0HzvOOjz3/946fWG3wY9elOTiU4uPvPcxP/flRfu/JVd524zbkK427vn9xrtkEmJCOXxe4tBElGRISpENQnkZZGUOvJZhwA3TrJVZmg1AXuF6GFnCrfJEfMzsUxS4eZJK7yKBziVvpMqysI2csXCHhzQvO6DKPXJplwryeEdZZUUv4qSCS1+BAY5UfvG2N7Bs9pDi0F2DzxQxeVmFyfZp3uEkSBCixRJMFQuOLDO4RuFWfCaXIMSSOeD0KpWkEQbJUiUgDxA+WCb8R3M0AC39zHebiImOjJewRSO8w2byoYVuDNChhMIOaP8PGJHTjkJchVAZX96j4bYbp4TJKijx1d5EQHSy5S9i/hdKOF7He7JJVwHhK41R9BoHORHyF0G5BOwaSAe2AYGC2zea+57m4w2MzB6sjW+uPx5ZA7fXoyB6el6FuNAg3DOK3gbkuUV8J0LKS+HEXa3+HQArSLsgSlFVw1kGfi6NrVWLBFsIBe1OmWUqQFD4VeviFHdQLWVpI2KVzOAEfpwhmUSVoeVSKCh1ZEDEFdhMiPZ1gEwwho/gaJgpdChjoRMImmVtd0uNw9BmV9c4sKXoMJ48y/YYWUgy8EpjHu0S6oPfAOQLP/+k0dJLYqyc5+AYXxQMtAep2SC4ZqKsOhWaVphok6RjYwieATqer4kejmNt6IJbAFahygpAVRy4KuvEQwvVIewreRoyW0gXiOKMSKA0k2UQTg7Tp0SPBADYhBDYaGfJsUkEoWVBNPKFRi0CwZzDsx1m+mvHUT4D7+vr6vj/9BLiv7/ty/94h7t2d54WFCo+cXuMTL2zwX965nw998Sxfn6vy+0+p/PrbMiiKzM/cNc07PvY8R5Zq3Lot92pfet8/sWs2AU6sjTDa0ejUhtiQl/DNScLeNjKGw53mEBXR5ahk0hFh5LUAPlkaBKmyj0V/lBRVftFc5NOMcxkZhSzHmeIt3hCp+Q0+qdhcEgYVNYAup6nRooyDHU6hyymSlS5jXhpzs4S32cM3Ye1ZlUZrFk1PMGk3GD74NJXVBG4lz4Lq0ewmGP/bNhMZh+ORl1BbCQxUDC9NyPNxkBnILrD9nT2UKIgDNgtfGKImF8jeBLEGNJ+RMByIjZ9jZ67C6ul18rubBA3IShCyYeOLYJRshnYWcZISCeckxtwAKa1LoidxyY6jJc+j2R2MIrQiIK2EUVyDJC1GbyozNQnTRyEUh+4I+K+BRsDjwnaYXYRtDRjZgNqTcEHTkfwRdCKkA10iN0MdKMwpuL0oQbmOqTqEJXAlcL2tsnI0iC/KhOvDtOUlUoaGbYCdcagEDehliNIhSJ4wLQbRsQoKS02fdBzCbgzXt/G7MoqrYqlVGhtJIiKIjYOPioeKT5AwHWRUYoNNYqNQr8PS+Rw9JBKEGBnukd4PbQXaZbCbKqrvos2BHwDZiGB4E1Sflznvnmf23g5OHWJR6F0PvuUy2WpxgzFLEcGmbmGoPaSOINy26OZU5LYPmyqpbpwRkkgCLjoKjZHLdEou25p5bGUQW5PQugaOC8IMsYGLg8Eww9xEkm0kWKWOh4fKIKpr4SmrEHPwxAjVniB3xc0o/w6HV75x669b6+vr63tlV4qj3zynr6/vZSmyxM3TGRY2qsBWUhzQFH72My/xmWNFopGL/LvX76TZ2xpMz8xvNcXqu7ZcswlwujNLQsyiuD3W83GkbJOxM8PsdVXQa5wb2KCi6KgNF6E4SH6OIHmekhTmxChvxGCGr/ADNOnS4M+okpZ2sipWaIgcp4WHI9rMWMMgNajTYjcG2VYcpTVMRFlmJL2CMmWhlCCjwYmSRsJNcmNxjn3hAkP7u7RUm0glSiFqshQZ55kvaah3Xua85OJIJiGhEfW7tEKwYcO0HSLk1AmpcGkuxjIjRMNHieXB3wGBRZlMtcrgfTWKF6NsV02S6xLmQyqDt7m0lmHuGAQaKjte4yL2CVrzBrt3L9DeCV0HvKpEYZsgYIGWhGoYtt3aInGxw8igIKUI1N9XCBoeiWF45LWweQtYpa2uzoOfCRKphFCGW4Sv97jF6XHiy12i7SSZ0S7RLGgyWI6Pi8OaP0FXWseMdPEk8HVQDdBcmDihM+h3qbljFKR1IuEqqetg0rcpXmpibyTQHAUXaEpFskGHoAaxACDreCJOZvsihgliXcaywaaHAfgIemToEUVFhUCZzLAgHIbG8zKBcpoOAoUsgcRlaELz8QiF80OEWxlkZR7/aQk90mOPVKTHIebt66g/l2JUf4zMjS6KDMkUEJOIIzFBGZMIktwm5fpE7RRDNJg7F2LSmSbsalzGpqIsU0nqdLRN8JoYepmL+iiuvpsDxjiRnscpeZ6EDwE0NvA5RZM4GYYJYOBTRUGigxsIIaIpsCTQR/B6HlUzdnUDqsMr35hZ39Mw7evr67t2XCmOQj+W9vV9l7LRrQf5F4ttfmD/MJW2xa9++Rwff2qRz7ywSsdyAfiDx+f5mxMbfPD121/Ny+37J3bNJsCLhxZYKZ1F8UwS3irGsGBOBFmqTCFnHaSAi9zo4m2PELqcwnLaLAdrxMwoK9IlbDHMu7iFHAZR5nknGm1hoDPOI7LLZvwoQnUo+xW6PkQaAQaExI2BAomR44SmDXITPqoEEQ8urMOTSwEqlJjCJ2Vs47HPdxlKLWKhgR3FzjU5u+6ivqgR6w4wIMZoKVWa2SBe1sZcHsZWV4n6IJVBK3sMSBucmRth8LcijL5hidT7LZJfr7LytTju6u2s+xWko0FGTkJPeYbwjEdEkSnJKmtzLvKjEVaqaXLDDaYn2py8HsyYQK1CqgsusN2H0YMCEfcoPZnh4oUBEnaH9NAaphBY6+BeB4oGQ4vgnp1h3pUxqiaD7hymLNBNn25yFXWHS2IF5DJIZoRVFJao0AtBPgZC3loDbEsw/IBC+GgeY2AJxYhQbWUwow3GJj0iCUFqvEv1y1HaJZ0wAWJCIebCQBe8HgQ9l6qZpTHXJjRUpeOk0XJ1Wt0wDSOHCwSJ4RPHwSE43iZ8CCrHoHLKZ0IuInsHSVFH2hBUvxRg5cJBDH8YjSBNb4R5Q2HAUBngeSKs8AyDRIWEcSrL0N4C4QxIDgRyPtnAAjO9CJtkeJPZIacdQZdW0MVB9hoyKe0ERXEXx1I6m5E5yHTBdsGeAvJY8SZMnOO8PUVydRQjPcPIqkfWibBJl6/LBk1f4QfIcQCFKXJcRmFVN0FVEHISpBiuFqFmXqkTy9/hwCvuKdCftejr6+t7ZVeKo988p6+v74quG4l9W2fo990ywYmlMl88XaZjuQzEAsiS4PffdYiPP7XAv/3Lk/zErMQbX+0L7/sncc0mwFLhIYYadYImdLIO0tI41xWyXNeMMrIRpUmer7KGIQkkX2YzuoZKjnGRYB6JIhX+QhplByvcIvLcyDzr1CgzwvnAPO1BC99LgimhlIKkxCBRZZ7pyQL5USAEMQdMBdbX4cMn8iyZwwSlFohhXkjaNGWNG1aH6TBGwy4RKLXR820O7nHYfE5APc9zwRaBdpGekAloTfa8sUhmLzSrMHmwy+zTz2F1E1zqDeM+2yb1tg3MhMzptSnW/TVqegopluLGepbxFy6SDRbJqT7ZvSZUVBrFBAYeKxs59EablgkTPdhYgIQNmQEYL0Djk1FOLkzSMHKsUWGGNLpbJzzUYUgG096auU3FQNMcXDewtV7XlJBbOrLnkRyrEk6A+YzExkaAppNhAQ1ki8GDDeLDoAEiBtoLUPniOF0rTSCyyf49Tfwnk/QSEF2Dxb8NEoq5JCfLdKsbyN4uBA5mUELVBX4IRMAlSBfb7sFqGMOdIJKr4XYH8JkhgIxEFJU8DWzCGQ85Be2vQmYEQpZJtDCPKdcpLG/nIiEChJhAp0cYmSQePVYJ0uMwo3QJk0anQ6MRpHdcIniLQKqDpEEwUibS67CNAg+kbXZaAX5IOUXbDJAhi+8N8VDAp5tZg3YXPB9lYxRfZBB5C6kaRBRW6c1coJceILAaZMSDJGESRGn6dZYpcoEME0ySJ05MlmHgEiSjRJRzdLTdeEaJtueBcRUD6krr0vrr1vr6+vpe2XcTJ/uxtK/vu6LIEr/4hp38m794iQ988ig/dccUzy83GU+HWakZlNoWt00luH48yUffcz0//EfP8lcLDe6cr3L79kEUub9T8L9k12wCHKn1iNgBNgMyu0t3ctvmnbyWHXiU6OHxB8HzlFULpQON9CZuxiaxFCSAiqOpVF2FDbXCMV1jozvD7eiMIJPmMjf3cixa02CFiZRGGKbL27C4wbMJlMBwQc5vPejt2dCuyfR6GvbuHvJGkMhajIa8jmrXaUsqA6kzuM3dXNde581vrzA7BacrJRpHuqi+jqcMoBkur5k9y733OrSq0HxO4rP/c5CL/gC+bnKjfYm83iIqQXq7D3GD9V4GV91ATEZ4yQ6jrSUo/6VJIiaz84frOD0X9888As0Z2toGgQQM2OB9Wab71VECuowbNemZVYqNMOv2JEFq9BSbx6MaY5U8163Osz8nyFZhPQk374Ti65YIPjKFTBlnPcBCEPI3VdAK4KxCtxqh4CRZJ0EehZ3bNjF/0KcYgKQBngrtOizZMhNyldx+m+GdgrXn60g9mWDaIz7pEbosaDYi2H4EA40oaULLGmbBJqnARkigMYTqSpiSixA5ivMD6I5LGBsZjx4yCg4Gac4dm6JtLzJ6m8fQJBh/28Mu1aiKEZaYpkyTGbKcp0OEEAG6NBFsUuVZOcT9fgAI0cLD9n0q5+LkxptgQdqEVc9ghApPqzbz28+xXBskMBfk3fI5CqpMw76LqJdAFQpuPoTsqexsZygEg/Q2beSuilDCeOYqZvYsSvs+xiSXKDGaiokZDuNoPZ6vm7SFwz5CVHQTEg3QJTqp25AXduGHjqKUT11xN45v058B7uvr6/v+9GeA+/r+Qd2/N/+tztA/8vEXvvGqTSqsUTccnlls8raPPke5Y7HRMAGJH/8fxxhNhfjQm3Zx/96hV/Py+/4RXbMJsDTbobgywKH6u3i3+AHS2LToYWNwlghHR0MYoTTyfBs/kwM9SD2/yKlSFEsdpDdkoJo9ktUMj6QbbNZD3CuS7GaTSTRmV7dhSRle60Y5zIuM00EmBVIVWfUpVjTEhs7QYI9E1GenW2MVHdVqMqeHsfw0+Y5NNtngPT+2yTNfcJBln9kpkGyY2dGhffYMVncH84ESw8oat824CBXEBpz6SpSj1hSdWRe5nkJ0jrMt26X8VxC7H3YmBPOtFDXJIXxmmQkrSUoOU0bGak2SqteZOAip8Qax0zbCjOM9GyKT6vHi4zEcq8Hl7igjHY3Q7graVIXRoxdRvAQVdZCVoQZyy0exofS0RMSH4FsFdQcG3mmDM0fx4VkivRwDk88xNQP1EvSOKGimTwiZNhG02DLKezr4GQgYW0268KG6qTBgD5Hwe9QeNXjhiQ4b3VFsr4BUqTB9h8Pl+TgnC7dQJMg+GrjSGk7XZVQBLw2NnI2zGKNHAlOE0GiAtRODKD4CaGHTIYBFFYeQM4G1Vif1o1WEATI+npiiKSZYxUMjjYME6Di0WMdmFZ+2LNFJapxoaNSVEh19jFu7GbzWKcxzp9FiPsYm+D0VB5U6KRBxtPwcD9X2E6mr3E+DEC/ybjfCvoU4x+I9Fp0ZUqSIGgo9uthEuM436TWifGXkGMauBv9zaZypld2Yuo871cZNnWf1bJbJSpJNSqh2CbUZx/U7DL2UZkdbYzGUoZxuYRSuYkB1eeWZif5NW19fX98ru1IchX4s7eu7St/sDP3/fu0i/+3xeT7x49dz545B/ufxNf79F05xcq1JSFP49bfs5pe+dI7/47UznN1o8dOfOs6/vm2S1+3Oc+NUuj8j/C/MNZsAi/U7ub7+Dm4Vu/GRWaVNigAhJpGoEV23EapGyE7QXI/i5WPI2RqZcohqysbYvoK7kqaaaqG4czRrBzlPnB28jRQ297pNYqyznxZBoE6AOCmi1iq9dY0nOzs5zQBvLF7m8OxFBlUXyYlhRMJ0IxrBluBGpcxNlkHj0/s4Yk7Riq2x7+kqO3Z4pEZg+t5lxNMWr3E8Bu6sktwmqJ+FzctwanGM7qRMfFOwrd1l7zu7VDYElYcTSH4LmTqTnkmuZxPBYEw7wlhkk3IjR1eO0ZRkAhGfU7UwRRLEhczZkyqved1LhAct5isjqCQZDy0SudPFCsDQpWWoj3LOyxKtbhIWGm5PZyPsEvhaBPeGFqVJ8KuQCHi0tTaONUWyILG8EURvxQjZKrrUwaeLED6ZXQ1Wd0KkB7EYqF3wgc7xAF1/hQtESJomvhvAZoCGmWDpaRPlksFcNU4EjRtpkRo7SirTITws8GUQEiTTJiaCGmlkmkRp4JKgRY8ucXQgioVJgTUcUpgM6i6RKPTOQ29NpyEyrONRxmSMAHW6tJBQkdCwkHCw5AB+3mfDbhERLtVdO3nxxBgTbh5luYVycJFcCoymB6ZFTOriR4J0uwH8tMXftsdoW/vYyTEOsEZKJLi/GeYvqfDXB9eQ/Cqx+TzCLTDvO9xvB/m6maCq1mkm92KvdRn2Qqz5x8FexxtZYq6aZkVUifmjHL4ww/FYBLXjMC7C7DZew19bVQwe+e4HlA2IVzjev2nr6+vre2VXiqPQj6V9fd8DRZa4dSbDf3t8nkRIQ5ElfvC6YX77q+fpWB49x+P/98B5YKsI42KxA8CfPLPEnzyz1J8R/hfomt36+a7yO9kjZtFR6eGQIkQCHQmFnYR4a287KdfBmpXw7mgSFRH+txN7+RVzkndtOkRP2WSXE0gtE7WQ5Hoi3IjGKTQelDSWkVAYZINDrPGDfIGdfIUAqpFjrpPlazisUeIpY5jKWoD9vk68JeNnQghVwoqVWdAnmO9dh1mdYa8VoWSk+NQDt/G5T2yn8GiQzKzPttdtMPGDRQITgkc/m+bZPxoBF7YNFxlbi3FrdZp7Dl9mz60+tRpUzSznj8eYnqkyo54hQI8AMkNTSwzd3kEPyqz6MZrrIcKDMHldl1FtkxH5DPVqmMf+S5bSYoQh9qAzSr25C//ZIJkRiP2ITXCswB6vxl1Wh2iuQGzKY/Buj1VzEC7qOA0oVcFtyDhujTpnKdTyXKgM0bKncdlJWNxOKhxi280nSd3bJeqB34G8C7E0KAo0bI2W5OOTxnH3suLfSoc0HYY537kLZ34Pk47NMJuk1EWGsm3MMLQ8sA0IShCd9NG0Bh1cYtiEieEQpkcRG4s2cVwyBGgTJUKKPKkRH1mAdxKMchqDSVooNGUDB0EdGxOZMBZTKCRRCLg1qLSQfJMBS0Pyq5yM1HmGBPXmW2jOhUGHwbCHJxXY7sqEign8dgzcCNWgyQNxj9OyyovkWMXEpsleFML1MG6oR/1gkUb8OCemKnSVIAcKB9GwYKxMYMDmZs8npFwg2qsgkkdQwnAXN2GG2oQliZQxDkKmTJUODfZ7d17dgHLYunl7uZ/+TVtfX1/fK7tSHO3H0r6+79kNk2mG4zp/+MQCvi84slSj0nX42I8d4s7tWRxv6+nT7z02z0Q6zId/aB8Av/rm3QzEAvz0p47ze49cwvOv9JSq738F1+wMcJYsNboY+MQwUYiiIwCFDGnKmS9T3nUELzoDTLCvpPA64TPPJmEvzy2lYcqotFvLDJlj7CHHaSnCI8E61cwSml/huYrEtF8iGgjy9LDD7uUot9tj2NhUVRlfq/FCuM5rZJdYTGZiIcjpXAFhuviRGGdjOvt7+1BZw3JXGG05WEzyeGOM2KkM9x9+nvB2gWvC159R+OLGCHEP3ni+wg8cqpL9yjkeU0f53KUkC7+jENtM0hMquZ5Dez6G5qnMoCApguQ+l/gtkDnVIbASo9tVsXTY/cM24+PnkI9D7ZzHSjXLAiUyNNhEpYuMbKtMDEFkGjKGQXLhRfR7YX0A5A4EH4cl10b72wSxZyzmWxKb1SHwupjUKbo7cRnBBjrx87jXldHvbjJ5wKPRAhGAcAJyNkhnYMaDTt5jaSmBLrdJOqPIhNlEJycvEQutE5G7SGqLbH2KthvmxZe2cZIYWb3JmyYWCA2Dr0JFapGijoNND41FuijECOCQJoFLHQ2bWUKEI5cZuanD5nEQyyo9P41Pjx4Wrt9lXYKYiCEwGCSJzzo7GCCNzHFDx5VrRN00gbkq7SE4a6tc6E0gKoOgLzIgQ1y1STsZbrgwy/OhFHYIhtoT1KNNHthf42vWFIcXQ/wbM4fOON5AD2ktj8i5EAnjCY2CHGbCGOelyvM4qXMsR322F96CU9+PGb0MqqAcW+brXVgYqWKs6wz1wpzL66jlGpKXZYyJqxtQHV45mrjf81Dt6+vruzZcKY5CP5b29X2PFFni5+4a54NfnuMDnzzK3uH41uuKhCp/cz5QABJHl2scnkwD8PuPzVHrbq1N+H8fucwnn1/mBw8M90uj/xd3zSbAXcJ4+Di0mSSCh0YZmVUM5tNP8PA9D3Prk7cQL90Misv9boLLUpXfmW5gaA6DS4L1gTrOQA/9rI3ZU3h8eJny4HFwHKwhk/K6QjmYhWEDhI9VqKDaPpOUuN+TeV7qkGjp1IiwpkS5sEdFktoojQZeqQ5KhiAJCtQ4yRhd9QI3BY4gd++h5sSoX5QYiQsCGdCET3W4S8M2MdYkIsMQChVZ1VXKoUHE8gh30yOLRaqWx6nlyLHBqrJO3dvL4pk8g6Ob5DJlRjeOMWX4pOpQfARidQUPDSVZo9UeYoIEURYIkCRBHg2IeqBZ0JsAPQPVAdAqcP6rCazjYVQ/xdnyOONljyANNsjTQ2cbK4QYxJdy1GYfg3cvMH67wNLAdSGoQFQCavDkR8O0zmaZUJtsG2+x8z1nCeiQv3SG5bUsw6s7CF13jO07TILPSPSqIZBWMcVuPHpUCRFTGoTjoAnolQVB1hnSqwg3zll/hAKCODEkAqxTJo5NkjSD+PQkiQAC9zI0G1lsRqkDPQSu1mUjKDHUltCJsYzgADlSBAiSZL7TYpA8Lmw9PQy3ubAbPnNGY595H9n6pwgFusQliR4ebU8Q70zjdzs0AxpKL09gdQhjT5MTIs+ZCwM8F/QxwhsQzEM9AWOTaJcFbXeYuBjAbA2hxucI1sPsJE5287VsRCcg5tMdOEq9OkVyOU9PW+QGxvAaeTK+yjbGkRm8ugHlsFWb/nKuclelvr6+vmvOleIo9GNpX9/34bWzaf7gXQf5ra9e4JHzJQDe+ydHGEuH+D/unuH3H59n91CMc5ttfu/RywDEgip/9GOH+Ppcld979DKVjv2t0uhsVO8nw/+LumYT4EU2CKOzjWE2sQji8vXQH9GMzJO85zT5k4d4V/HHgAYjbpSTFPl84uvU001YdFmaMqDjoVUHmbByPBrZoLj7ApgN6GyHpoHSaBFrqIQuKXhKjBs7ChYnAYd3CYm0M8aXkzH+eLBNdnEAraUTd1LYTZN2RMUO2lQNiW3aRe6OXiYY6rLroE3hubME6zeitHTCbRPLgyEZxgs2RT2C3YHyKQ/DjPLa1j6eqRXYllniwOs2qH8tSryjoQ2uYa2N0hOjdDCQL2WpSVV23WUzol8muh0WPqdw7PM5TGuMWcYosk4VWKbBzWwjSxmHLvJSGm2xQ+4ASCNQOw7uY1CtqRSfvRUbCGCQooiitJD8OCHRQyNOiH0k5SLF/V9i5ieLuBPgm6BboEsgCxhKwsUn4cLJNLY8RKo+hPqGY6i3uwQ9iFznMx0oYR0vkRkCPQKddQV/eZyiGKDNBA0axMlyo9fC7yxSWYTmHEjJIoPbwFpTkddsyn6epmSyVwyiEiRAFJcaG9JRrE6ExQdVxm3QvBQWCQRg0UZ1NWxPw5cCdESTTTxmGCOCxjFKNLCIESPAFFE/QT23jucJLsSXEOUbiHemGec0Id9kAItK2KZDiICfoTNZJbY0Q6xxAGNzgaFilBpxXhxvQ2cJBhKwFgVtH/muwqCYwUCgKjvoDAfRL47zsNSgEdIhmQe/BANDtKwHsJ00UX8MfynNpGlzKrjAicgppN7U1W+DpLzC8f5NW19fX98ru1IchX4s7ev7Pt2/N8/r9w7x3FyZn/2Ll5jORfnLD9zCl0+uAfDpf3WYRy9W+X8+dwqA5arBz3z6ONXO1izwz92zjUfOFzm/2f57yfCb9w8xmgqTjgYYiAZAgkrHYiAW7CfI/8xcswlwjRY+O9jEIk2A5fAf09r3BcazHhubSfLz99PD4Rw9NlD4K/Vx1jMvooUVrPFhCLhg51HWJngxU6cVVxA1QDLYfj7KNivPC7SIiTDDBDiAzR000GmjkiNEFVuWKAxVEHoFKVLk7Wsx8G9hnVM8PlBFagZYIsIhPcU7dy5RS4Icgvr0WTYuCtTlNPm9G9CDuC/YbUeImjM8RZ1MeTfp+JfQA0+SMAOkbi4xb+o87YxyyFXRSqs0/FGWlEHWQwtEHMH6wl3cffBpht7TAwfO/16co7aOJW1iCp0odSTijDOIg0SJHBWqzLV10sdklDEfqhAYBPlZUIsSaXzqjJBlGYHK+G2beONFhAtTRwN05qYpDy+Q+VEDKQxTHijnIGSCfBNEdMiuQHFFZpcr44VXGN3XIB110b+qIm1zCe3f2hZp9ZLK3FM66VqU9GCLanSVy6191EmiobOdHqGZywQHwDwHkWUVw/aJbPqkJZe7I2v47UFeEjkcKuQJkovMkZI3WW3PEEejuWxj63U8hhFk6NHGAhypQcCSqEkygiiu6PGE5JEQEgUphCygQIQgEoqXB6cBY0HcFYcLjRYxZz9v6Czj+T6DNBi2wlSlIO2xczCaolvx0OpRcnPb2SeG2IVHulGlNRIE3SbTkfDOqTTDGZS2ygwxdhd2cLQnqOV6PN8r4u2VIeiCvwZSFnnmMsoZnQNr15EiwNcGl1jf/QSJk5u0/KucAe4nwH19fX3fn34C3Nf3T0KRJW7dluUX7p3kg1+e42c+fYzbprdKnh84XeQLJzYAuHN7jtNrDSqd/3979icvlTm30UYAv/qW3fz10dVvJcN/+uzyy35nKqxyz85BbpnJUu9aqL6FK7fIxILk4/0E+Z/aNZsA1+kQxCBDlsvSI1TSD5BOeJxUVPzTNzDhhPiTwdOseBA2JcrJFTxjCn0+SdwK0pqWkaww5l4LM1KGYp7wXIJgeIgdTpyslKQ71KGWrlMrV9hf2I9PAEEKD59lAsT8NlpvH5HmIu+wT9CRbJ5ijVYkgZ93GSjIBCnTi1SoS2Cf1Ziv5bB0n9DAWZ5ZGsR9KMBoxkaNCnJqk03bRyFNXXua6w9UKLQFOQvmqxIPnhxjYWeE6JlhDpg5LAKcGFrHCqahInCa1zH4txXaC6cgpRLM95hYmWSJDeqoqHKBKb+GrlqE3HF65GkgkfGzPPugw2tCK0ztEKRn4fJ9Eo9+ZDcOPSTqAGTYSWhlA6Id7KDLgqNgsg272UGsLzG7Haqf11j9wijRYJnD9Q6OL7PwlMauQxaZt60Qt6HjQOFvppEL29G3v0B4Z52zT8t8/Ykh8KIMkCO6KZDlEks0gCy3kmCAOnqmiyTAX4B4M0xOctBKNomwj2UJXk+HJnkqRDmEyf74EudbA5xlhigyO6wxXOskEKJDFw+HQULYIojqCwLYhHBwiOKKDrZk0c56eHaRTFsn6HcYsALIp0cpZQ2URgMfk6Y0y6IzSogyCbrc4YU4PtvCHVHArOEnH6GW1tEaGicr09zkx9nXslhqyqDbRBWd8XKGo6kga8hc0FfY091J+2GFc3uW8CYMGAyC2wJtHQoKRvxuuFlQ+FKJByyf9cA5Aq3LOK0QknulvTj+DoNXbql3pbK+vr6+vmvdleIo9GNpX98/oO9UEv2hL50jHdEA+MP3HOLIUo33/+kRdEXC9gQnVpvfev+XXtr4VjIMkInomI5H1956UjUYD1BsWQDUDZfPHV/nc8fXv+O1xIIKt81kOTieomU6CAGJkPZtf270bDYbJgnNZyjToGm6bNR73/oMSZIYSgZJhnRqhsXp1Sadnkk0FCAbDSJ9I78WQlDp2JiuR1CViag+XVem53jYrvjW31VTJAzTJhzUsV0f2/UwHA+EhK4IQrqG4/kYjofvCUzXRQgZRQZdkbG9rfcgSchIeMLHdmQ+eORhZAl8H1zxzWuCb/YX21qJvfXfq2k55lvffeniNZsAy8SwGaKJx3KgSs62cVZkDHs71zdu48xUmf+vvXuPjqK8Hz/+nr1lN8nmHnIjJATCLYWAVfhJtUSgAl6jaLW1Ch6rbY/owWpbe1oFtd8jVk+lSFtbq0VPK1AsSA+tSkXwBoJCQghyDblfyXWzu9lLdp/fH5StIQESyCYk+3mdMyfZZ56ZeT7PZJ7JZ2d2tvKqo6iSMmxhY8CVgdZUjM81Go8/mhHFqYz0hlOYsQd/mBNjrIl5R0bzjbbxtGFi1ZTduLLjoPEY7Y3j2afFM0ZNJZJ6DHSioYjDQl5lBZOVjrFGPf+nS6cDAx6PiZiDyUxwVTF55C5SxnvQ/FDYHEmRPYd4NNpaa/jE4KSsYQr3tJxk0hXlfONrDdQcqiC+I4sR8RX4oxWxEWCvhMIDUTS5jWitPpQy0YmZVpzg1mNoM6O3a1hVB7Fp9dS0mdm9dxxm8zEm4iYOCzbcpCY7yGowY/WlU0wmdlrwaQ7iddX4HOMp2dfAxJEddHqg+rNwTlgS8Ibb0HXWYLe5iPRFcLwsi7AyLzqtkzClx4EOqz0Rc2EFhrF+7LsttDniaXBYsf+lltGeNMK90Xg6d+MzuGmotODXG/E3TaKcQ1hK/Yw5BObmMBxEcNJaj9PZSbwvnkZyadfsJCkv8ZzEaCxEmTx01kJkM/j9Bgy+aAweHzh1WJUVHYlcTiK7sdLACex1mcSpaPRYaKaRdiy0MhGIwE00EXho4SjxahQRlNGAEwcKrxZJvmrihK6Mo9ZR0K7hN3gZ7zlOIhpfNo9la3EH6BOI8DupjkjniGMaiaqIVBQTaCcs1o073gDldqAOWvR443VURZRiKx3JVS4rn9Sl0PL1Gmo6mjG2GPGGZfH+iCo8X2ujca8DHNFgtcD/C0O3uxZ9jYY3NhtiyuFwBoxL4lh2A/ojFnR1iSgMuDQ93vhUaDre+wPKgyTAQghxMc43joKMpUL0s//dEt3AK+/s5qNaPZlxETQ7WimsPDUBeHyK/KmpvF1YE0jO9v13HkCMxcitl6XyysdlTE2PxudXHKi2YTUbaHd1Bj5bfHrZCJMOh8ePXgc+P7S7fLx7sJ53D9b3suV1fYiyL59p64nrLOU9XSzxnfETuqayOry9eJhfsJ+1HbIJsJ0oxmLkSFghXuPHWKM81LRHEF8/hUOZH2ObeZzR7XW0RkObvoG4Shv6aA+2zHq8VQnkHXqEy1UkzQcLcFmjyGiykoOHMRjYQT0ey27CjxlxNoxFGY5wJCKWGruFSVjw46EdP3G4mefTEY9GoyeHOH0SB6wuQMdkx1GuDa8jPc2LyQuHiyJodo6iHAtVNBDv9zHC4+dgXANPJYzmqmI9N6SeYMGkQ9SWHSfW5cVdB/5SM60uPzGdURh9VxBzspWMzkQy2YvZUEycsZMqbxQwgSwNwmMbOFKvKI0pBy2eeLuPaSjqdB1YOhXHlI5aFU09zdTjIEaNQPNHEUckMYmdqHCwNUDEiQjGO73YXSY02hnjG4eRNqKJJ87yGRZfGCXKQCLgN3SiT1MoE4y/wkZk+RE091jaHak4TBXEqAm0HE3FFlbJCedIMglHYzdRRNDuieWLf/iZNM3OnLR6Pmww0KRzofO5aDW1EdXp4+rOVqwcIcx8Al0jkAAjU8A3qRmnoxWPXYfbZSbc58Ttc5NlPsrR1q9zhCQaVS5XcZw4TfGfGA8n7Ym4vCNx0Ukr4MdNBGNo4jA2rMShx4efEUpjBC7ifSZqqnwcs0QwwhOFYj9JtGPzpxJbm8TJse2EN7XTNKKKLS0jGdnSQDKdJBHFmLIOCibaQGvHWFuH5tTjD1e4kmyUlNkZp2IAHbR78frbKMlsQFk9dMbVQqyNw9elY/q3AfRZ4LGj2a3oPB5oSQSXEWILoX0KpFrwtSt8jpF4R10JHIOEUdDUhwPKy6m3685GvjVACCHO7XzjKMhYKkQQ6HUaM0bH0ZSpuH1WLs++ewSAu/68O1Dnp/PGkxZr4e3CGmaOiaeouo12V+epK5kKWju8vPJxGQD7K9sCtzN7fafetaptczE1PZrCyjaiLQY0depg9vkh3KTH6en++QajTsM77L526fT13cEVsgmwMqRQpztB1dh/M+6ojWaLEXfdLNoyWtBSPyGlwc3I+FO7yXv0JFYntNn0dHYYUE1eGiihltHkt86ktrWFMtrYg4sGImnQ6klstFPfNgIi2tBHOhlb7yMF8JKDjRqcQCkuUtFoJYvjagSjOquptnXgirFxPE5R7VRklFg5YTNy2JNFDSOYwEgMOKigDh0uMlrTqTfr2GZOw3/IxxRTFTVmHw57GP7jepQ9Ap3Zz9URjYS7a5nYriOKT2iiiRplxtsQyZgIN5GGBgy+SMLaobpFh3eED2UwUdzezOhOG4mjKvE2W9jvi6KR47Si0JEKeBitvEyP/QwtykvDl2D3gTmijVFaM/F+E0ZjDVE6G+0+Gxb/aHwdacQwibj092nOOIDeojEyRdF6EKr2hRPdaWaS3oY2tgJjm5fqk8V0+NKpdk7jKD6iaGQsHXRqHuy6OD6vGEWp9Rj5d7WQuE3Hlr0W9KQywZVKDBGkU0dEbBlhkR70reAuh7JESJsAJo+f5mY/yQY7Fgt06prR3GDZFovNb6OJTsZhxqJ8fK0ti2blR4cDP24OYMKLjWTCCSOZk/pOpvriCaOBeCIxoieWHOZ7YLQHKnCxU0smXaWQhJMo93gaKxtpTDbjT7XT6LBiZwR1WPART0rbIQobolAtCq/eSBi1aI1uIm17iFWjgCQ8+qMQ1gDRSai2aPD5wByNdsKLL02Py1IJMSMgMxxfnAtf3R444MX05Ry8vhQ0ZwT+pGSI00NaG2ijISwO7H38sncPg5YAT5w4kcOHD/c476WXXmLJkiXB27gQQvSX842jIGOpEEE2LyeJBVPSWP3BcVa+f5Sp6TFUtXawp6yZPFMiAJ+WNHHfNzJ59dMyspOsHKlr576rMtl6sJ7Klg4U0PnfxNXlPZUAtzi9tDhP3T7d6fPj8PgDV4M7/5skJ0YaOWn3/q/crwK/G3WnbnH2/Pf7ik+XA4TpTw0cbl/PA8RX64pTQi4BVv99x8UTXkG5cT/68lpKzGY6azJRYR5U+hHCatz4U6C1FuwKPD49HX5FU/QkTCXpKH8ShZqPZGUmEgv7KMdFAq10cphi3NF1NFq+hs+bgb69k8srrOQqDzY68RJOE3Ecx0MdDiZhpEhrpcJQR4zXjcPQxPjmCBr0SRT4Eklpz8TLcTx4MFHFKPTMpYkq9FSSzAf+VLSaRjQMRJNDucsGrlGAAXvrKIrw47Z3YKKEFGrxUkMbIziOwvm1FhyNRg5XfxM7FaQTzaSDU3ArO1jC0TweDK5czDQQ6ztIqVtPnKUWp+Ym2RlFKwbSiSeXNuIj2mk6BA4dnEyEnK+5iQovhmYNS5iiM6wRvQPKK2JIo5VjuiY0VzuGFoXZrHCUwdEd4dhaJnAShS76KFMivdT6IcbWQbWzAyNhZBNJhFaJL8ZBi1Xhz2gjWa8RXqI4+AmEW/04tUhy8ZPICcJIwKH7nGZrOy12HV6njs6WTpItGq1mhcsLjS0mGOUhYQLgBFs1JCsnTnTEYCICM9mYSPSb+QITFhrROEwSKVQBZqA23IcrNotjNWGMVyY8+KgkkQSyacJJItFU6T7jeLqHv1VFM8KnQYedmA4vbckWDCeqia93Uk4Me4ng68RywhuNebsPT3QGPn0YPq0FfUcnRn0tRzlBExF0JjZAVAX4nQQCqNZhKs7GXVGL1taEqq+GlpEQnwDR46GpnhEFipO1sXgjRkKcF7QTYD0ObTZwTQDN1OV4OR+b4zzzT/+02bqUh4WFERYW1sujt2f/+Mc/yMnJYdu2bUyaNAm3201WVhbr16/nxhtvvKh1i7Pr7d+GEKGuv8ZRkLE0lJ3+O2pvb8doNAZ1W36/P7Adne589+Vf+LK9qXuuOmeb11P5mWVnvvZ6vTidTmw2G0ajkXunJzEyUvH8e0eob3VR39jCB0Xl6DQYl2wlIcyH3+3kUPmp24u/mRHBniOdlLud3DUjnb/trjxr3O3urq9P32Bc7+5WNeAcs+g4x7xQcvozwL0ac1WIKSkpOX0jukwyyXSeqbKy8pzHU0dHh0pOTu7VuiIjI7uVLVu27KKP6Q8++EAZDAblcrmUUkp98cUXClB1dXUXvW5xdjKWyiRT76b+HEdBxtJQJWOuTDL1bjrfmKuUUiF3BTgu7tRjzisqKoiOjh7k1vQfm81Geno6lZWVREVFDXZz+s1wjGsoxKSUor29ndTU1HPWM5vNlJaW4vGc/6nRSik0rev9fWe7YvH444/z3HPPnXN9hw4dYsKECRw4cIBx48YF1rV//35GjBhBUlIfv8pJ9MlwHUsv1lA4vgdDKPZLMMbR0+uVsTT0DPSYe8UVV/D5558Hfdne1D1XnbPN66n8zLKvvh7oMSoU+vfMsmD3cW/HXAjBW6BP3woRHR09LE/CUVFREtcQcanH1NsTrNlsxmw29+u2H330URYvXnzOOllZWQAUFRUxefLkQPn+/fu7vBbBMdzH0ot1qR/fgyXU+mUwx1GQsXQ4GegxV6/XX/B2+rJsb+qeq87Z5vVUfmZZT3UGaowKhf49W1kw+7i3Y27IJcBCiEtfYmIiiYmJvapbVFREfn5+4PX+/fu57LLLgtQyIYQYOmQsFRfqwQcfHJBle1P3XHXONq+n8jPLLibGixUK/dvb7Q8GTanQepKJzWYjOjqatra2YfUutMQ1dAzHmAaL3+/HarWyfv16brjhBgDS09P5yU9+wsMPPzzIrRve5O+4Z9IvPZN+ubTJWHrpk2MouKR/g+9S6uO+PdptGAgLC2PZsmUX/bTES43ENXQMx5gGS0lJCU6nkylTpgTKJk+ezLJly/j0008HsWXDn/wd90z6pWfSL5c2GUsvfXIMBZf0b/BdSn0ccleAhRBCCCGEEEKEppC7AiyEEEIIIYQQIjRJAiyEEEIIIYQQIiRIAiyEEEIIIYQQIiRIAiyEEEIIIYQQIiQMiwT4d7/7HZmZmZjNZmbMmMGePXvOWX/Dhg1MmDABs9nM5MmT+fe//91lvlKKJ598kpSUFCwWC3PnzuXYsWPBDKGbvsT0yiuvcPXVVxMbG0tsbCxz587tVn/x4sVomtZlmj9/frDD6KYvca1Zs6Zbm81mc5c6l8K+gr7FlZeX1y0uTdO4/vrrA3Uulf0lQlt/j63DRV/65eDBgyxcuJDMzEw0TWPlypUD19AB1t/nLSGEECIYhnwCvH79en784x+zbNky9u3bR25uLvPmzaOhoaHH+jt37uQ73/kO9913HwUFBeTn55Ofn09xcXGgzq9//WtWrVrFyy+/zO7du4mIiGDevHm4XK5LMqYdO3bwne98h+3bt7Nr1y7S09O59tprqa6u7lJv/vz51NbWBqa1a9cORDgBfY0LICoqqkuby8vLu8wf7H0FfY9r48aNXWIqLi5Gr9dz++23d6k32PtLhLZgjK3DQV/7xel0kpWVxYoVK0hOTh7g1g6cYJ23hBDnt2XLFsaPH092djZ//vOfB7s5w9Itt9xCbGwst91222A3ZdiprKwkLy+PSZMmMWXKFDZs2BD8jaohbvr06erBBx8MvPb5fCo1NVU9++yzPdb/9re/ra6//vouZTNmzFA/+MEPlFJK+f1+lZycrJ5//vnA/NbWVhUWFqbWrl0bhAi662tMZ+rs7FRWq1W9/vrrgbJFixapm2++ub+b2id9jesvf/mLio6OPuv6LoV9pdTF768XX3xRWa1WZbfbA2WXwv4Soa2/x9bh4mKO94yMDPXiiy8GsXWDJxjnLSHE+Xm9XpWdna2qqqpUe3u7GjdunGpsbBzsZg0727dvV//85z/VwoULB7spw05NTY0qKChQSilVW1urUlNTu/xPHAxD+gqwx+Nh7969zJ07N1Cm0+mYO3cuu3bt6nGZXbt2dakPMG/evED90tJS6urqutSJjo5mxowZZ11nf7qQmM7kdDrxer3ExcV1Kd+xYwcjRoxg/Pjx/OhHP6Kpqalf234uFxqX3W4nIyOD9PR0br75Zg4ePBiYN9j7Cvpnf7366qvceeedREREdCkfzP0lQlswxtbhoD+O9+EomOctIcS57dmzh5ycHNLS0oiMjGTBggVs3bp1sJs17OTl5WG1Wge7GcNSSkoKU6dOBSA5OZmEhASam5uDus0hnQA3Njbi8/lISkrqUp6UlERdXV2Py9TV1Z2z/umffVlnf7qQmM70s5/9jNTU1C7/jMyfP5833niDbdu28dxzz/Hhhx+yYMECfD5fv7b/bC4krvHjx/Paa6+xefNm/vrXv+L3+5k5cyZVVVXA4O8ruPj9tWfPHoqLi/n+97/fpXyw95cIbcEYW4eD/hifh6NgnbeECAUfffQRN954I6mpqWiaxttvv92tzrk+X19TU0NaWlrgdVpamnyU4AwX28fi3Pqzf/fu3YvP5yM9PT2obR7SCbDobsWKFaxbt45NmzZ1eWDUnXfeyU033cTkyZPJz89ny5YtfP755+zYsWPwGnseV155Jffccw9Tp05l1qxZbNy4kcTERP74xz8OdtP6zauvvsrkyZOZPn16l/KhuL+EEOJCnO28JUQocDgc5Obm8rvf/a7H+Rfy/BTRlfRxcPVX/zY3N3PPPffwpz/9KehtHtIJcEJCAnq9nvr6+i7l9fX1Z33YSHJy8jnrn/7Zl3X2pwuJ6bQXXniBFStWsHXrVqZMmXLOullZWSQkJHD8+PGLbnNvXExcpxmNRqZNmxZo82DvK7i4uBwOB+vWreO+++4773YGen+J0BaMsXU46I9xbDgaqPOWEMPRggUL+NWvfsUtt9zS4/zf/OY33H///dx7771MmjSJl19+mfDwcF577TUAUlNTu1zxra6uJjU1dUDaPlRcbB+Lc+uP/nW73eTn5/P4448zc+bMoLd5SCfAJpOJr3/962zbti1Q5vf72bZtG1deeWWPy1x55ZVd6gP85z//CdQfPXo0ycnJXerYbDZ279591nX2pwuJCU49DfmZZ57h3Xff5fLLLz/vdqqqqmhqaiIlJaVf2n0+FxrXV/l8Pg4cOBBo82DvK7i4uDZs2IDb7eZ73/veebcz0PtLhLZgjK3DQX+MY8PRQJ23hAg1vfl8/fTp0ykuLqa6uhq73c4777zDvHnzBqvJQ4482yG4etO/SikWL17M7NmzufvuuwemYUF9xNYAWLdunQoLC1Nr1qxRX375pXrggQdUTEyMqqurU0opdffdd6vHH388UP/TTz9VBoNBvfDCC+rQoUNq2bJlymg0qgMHDgTqrFixQsXExKjNmzeroqIidfPNN6vRo0erjo6OSzKmFStWKJPJpN566y1VW1sbmNrb25VSSrW3t6vHHntM7dq1S5WWlqr3339fXXbZZSo7O1u5XK4BielC4nrqqafUe++9p0pKStTevXvVnXfeqcxmszp48GCX2AdzX11IXKddddVV6o477uhWfqnsLxHagjG2Dgd97Re3260KCgpUQUGBSklJUY899pgqKChQx44dG6wQgqK/z1tChCJAbdq0KfC6urpaAWrnzp1d6v3kJz9R06dPD7zevHmzys7OVmPGjFF//OMfB6q5Q9KF9vGcOXNUQkKCslgsKi0trVt9ccqF9O/HH3+sNE1Tubm5gamoqCi47Qzq2gfISy+9pEaNGqVMJpOaPn26+uyzzwLzZs2apRYtWtSl/t///nc1btw4ZTKZVE5OjvrXv/7VZb7f71dPPPGESkpKUmFhYWrOnDnqyJEjAxFKQF9iysjIUEC3admyZUoppZxOp7r22mtVYmKiMhqNKiMjQ91///2Bf0wGUl/iWrp0aaBuUlKSuu6669S+ffu6rO9S2FdK9f1v8PDhwwpQW7du7bauS2l/idDW32PrcNGXfiktLe1xfJ41a9bANzzI+vO8JUQoutDkTPSe9HFwDZX+1ZRSamCuNQshhBBCCCF6omkamzZtIj8/Hzh1+2h4eDhvvfVWoAxg0aJFtLa2snnz5sFp6BAmfRxcQ6V/h/RngIUQQgghhBiO5LkDwSd9HFyXav8aBm3LQgghhBBChDC73d7lGx5KS0spLCwkLi6OUaNG8eMf/5hFixZx+eWXM336dFauXInD4eDee+8dxFYPLdLHwTUU+1dugRZCCCGEEGIQ7Nixg2uuuaZb+aJFi1izZg0Aq1ev5vnnn6euro6pU6eyatUqZsyYMcAtHbqkj4NrKPavJMBCCCGEEEIIIUKCfAZYCCGEEEIIIURIkARYCCGEEEIIIURIkARYCCGEEEIIIURIkARYCCGEEEIIIURIkARYCCGEEEIIIURIkARYCCGEEEIIIURIkARYCCGEEEIIIURIkARYBEVeXh4PPfQQS5cuJTY2lqSkJF555RUcDgf33nsvVquVsWPH8s477wCnvkRb0zTee+89pk2bhsViYfbs2TQ0NPDOO+8wceJEoqKi+O53v4vT6Rzk6IQQYmDIWCqEEEL0L0mARdC8/vrrJCQksGfPHh566CF+9KMfcfvttzNz5kz27dvHtddey913393ln7Dly5ezevVqdu7cSWVlJd/+9rdZuXIlb775Jv/617/YunUrL7300iBGJYQQA0vGUiGEEKL/aEopNdiNEMNPXl4ePp+Pjz/+GACfz0d0dDS33norb7zxBgB1dXWkpKSwa9cuXC4X11xzDe+//z5z5swBYMWKFfz85z+npKSErKwsAH74wx9SVlbGu+++OziBCSHEAJKxVAghzi4vL4+pU6eycuXKwW5KgKZpbNq0ifz8/MFuijgLuQIsgmbKlCmB3/V6PfHx8UyePDlQlpSUBEBDQ0OPyyQlJREeHh74h+102VfrCyHEcCdjqRBC9Gzjxo0888wzAGRmZg5oIrx8+XKmTp3arby2tpYFCxYMWDtE3xkGuwFi+DIajV1ea5rWpUzTNAD8fn+Py5xZ/3TZV+sLIcRwJ2OpEEL0LC4urt/X6fF4MJlMF7x8cnJyP7ZGBINcARZCCCGEEEIMOXl5eSxdupS8vDzKy8t55JFH0DQt8MYgwCeffMLVV1+NxWIhPT2dhx9+GIfDEZifmZnJM888wz333ENUVBQPPPAAAD/72c8YN25c4A6aJ554Aq/XC8CaNWt46qmn2L9/f2B7a9asAU69wfj2228H1n/gwAFmz56NxWIhPj6eBx54ALvdHpi/ePFi8vPzeeGFF0hJSSE+Pp4HH3wwsC2A3//+92RnZ2M2m0lKSuK2224LRneGDEmAhRBCCCGEEEPWxo0bGTlyJE8//TS1tbXU1tYCUFJSwvz581m4cCFFRUWsX7+eTz75hCVLlnRZ/oUXXiA3N5eCggKeeOIJAKxWK2vWrOHLL7/kt7/9La+88govvvgiAHfccQePPvooOTk5ge3dcccd3drlcDiYN28esbGxfP7552zYsIH333+/2/a3b99OSUkJ27dv5/XXX2fNmjWBhPqLL77g4Ycf5umnn+bIkSO8++67fPOb3+zvLgwpcgu0EEIIIYQQYsiKi4tDr9djtVq73IL87LPPctddd7F06VIAsrOzWbVqFbNmzeIPf/gDZrMZgNmzZ/Poo492Wecvf/nLwO+ZmZk89thjrFu3jp/+9KdYLBYiIyMxGAznvOX5zTffxOVy8cYbbxAREQHA6tWrufHGG3nuuecCz3CIjY1l9erV6PV6JkyYwPXXX8+2bdu4//77qaioICIightuuAGr1UpGRgbTpk3rl34LVZIAi6DYsWNHt7KysrJuZV99CPmZDyRfvHgxixcv7lK2fPlyli9f3g8tFEKIS5+MpUIIceH2799PUVERf/vb3wJlSin8fj+lpaVMnDgRgMsvv7zbsuvXr2fVqlWUlJRgt9vp7OwkKiqqT9s/dOgQubm5geQX4Bvf+AZ+v58jR44EEuCcnBz0en2gTkpKCgcOHADgW9/6FhkZGWRlZTF//nzmz5/PLbfcQnh4eJ/aIv5HboEWQgghhBBCDDt2u50f/OAHFBYWBqb9+/dz7NgxxowZE6j31QQVYNeuXdx1111cd911bNmyhYKCAn7xi1/g8XiC0s5zPajQarWyb98+1q5dS0pKCk8++SS5ubm0trYGpS2hQK4ACyGEEEIIIYY0k8mEz+frUnbZZZfx5ZdfMnbs2D6ta+fOnWRkZPCLX/wiUFZeXn7e7Z1p4sSJrFmzBofDEUiyP/30U3Q6HePHj+91ewwGA3PnzmXu3LksW7aMmJgYPvjgA2699dY+RCVOkyvAQgghhBBCiCEtMzOTjz76iOrqahobG4FTT3LeuXMnS5YsobCwkGPHjrF58+ZuD6E6U3Z2NhUVFaxbt46SkhJWrVrFpk2bum2vtLSUwsJCGhsbcbvd3dZz1113YTabWbRoEcXFxWzfvp2HHnqIu+++O3D78/ls2bKFVatWUVhYSHl5OW+88QZ+v79PCbToShJgIYQQQgghxJD29NNPU1ZWxpgxY0hMTARgypQpfPjhhxw9epSrr76aadOm8eSTT5KamnrOdd1000088sgjLFmyhKlTp7Jz587A06FPW7hwIfPnz+eaa64hMTGRtWvXdltPeHg47733Hs3NzVxxxRXcdtttzJkzh9WrV/c6rpiYGDZu3Mjs2bOZOHEiL7/8MmvXriUnJ6fX6xBdaerMp2UIIYQQQgghhBDDkFwBFkIIIYQQQggREiQBFkIIIYQQQggREiQBFkIIIYQQQggREiQBFkIIIYQQQggREiQBFkIIIYQQQggREiQBFkIIIYQQQggREiQBFkIIIYQQQggREiQBFkIIIYQQQggREiQBFkIIIYQQQggREiQBFkIIIYQQQggREiQBFkIIIYQQQggREv4/A2AowiJyuosAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { "name": "stdout", "output_type": "stream", "text": [ - "qNewton: 100%|███████████████████████████████| 200/200 [01:09<00:00, 2.86it/s]\n" + "qNewton: 100%|██████████| 200/200 [00:16<00:00, 12.45it/s]\n" ] } ], @@ -475,55 +504,46 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 15, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.subplot(131)\n", - "plt.title('raw data')\n", - "plt.imshow(abs(mean_img),cmap='gray')\n", + "plt.title(\"raw data\")\n", + "plt.imshow(abs(mean_img), cmap=\"gray\")\n", "plt.subplot(132)\n", - "plt.title('reconstructed amplitude')\n", - "plt.imshow(abs(fixed_object),cmap='gray')\n", + "plt.title(\"reconstructed amplitude\")\n", + "plt.imshow(abs(fixed_object), cmap=\"gray\")\n", "plt.subplot(133)\n", - "plt.title('complex reconstruction')\n", + "plt.title(\"complex reconstruction\")\n", "plt.imshow(complex2rgb(fixed_object))" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "ptylab", "language": "python", "name": "python3" }, @@ -537,7 +557,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.12" + "version": "3.13.12" } }, "nbformat": 4, diff --git a/jupyter_tutorials/jupyter_tutorials_tutorial_LateralPositionCorrection.ipynb b/jupyter_tutorials/jupyter_tutorials_tutorial_LateralPositionCorrection.ipynb index 653c3353..4a82d395 100644 --- a/jupyter_tutorials/jupyter_tutorials_tutorial_LateralPositionCorrection.ipynb +++ b/jupyter_tutorials/jupyter_tutorials_tutorial_LateralPositionCorrection.ipynb @@ -4,7 +4,21 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# #5: CP Lateral position correction" + "# 04 – CPM Position Correction\n", + "\n", + "This tutorial demonstrates lateral scan position correction using the `pcPIE` engine. Position errors — caused by mechanical stage imperfections or thermal drift — are estimated and corrected jointly with the object and probe during reconstruction.\n", + "\n", + "**What you'll learn:**\n", + "\n", + "- How to enable and configure position correction with `pcPIE`\n", + "- How to visualize corrected vs. original scan positions\n", + "- How position correction improves reconstruction quality\n", + "\n", + "!!! note \"Dataset\"\n", + " The dataset (`simu.hdf5`) is generated automatically into the `example_data/` folder at the project root the first time you run the notebook. If the file already exists it is not re-generated.\n", + "\n", + "!!! tip \"Prerequisites\"\n", + " Complete [01 – CPM Simulation](tutorial_CPM_sim.ipynb) before this tutorial." ] }, { @@ -61,25 +75,33 @@ } }, "source": [ - "# exampleReconstruction_pcPIE.py\n", + "# Setup\n", "\n", - "In exampleReconstruction_pcPIE.py you find an example of position correction carried out in ptyLab. We used the simulation code explained in Tutorial #1 to generate an artificial data set. The data set is saved as 'simu.hdf5'.\n", + "The dataset (`simu.hdf5`) is generated automatically into the `example_data/` folder the first time the next cell is run. The file contains a synthetic CPM dataset produced by the same simulation as Tutorial 01.\n", "\n", - "First, we import the libraries and initialize the objects exampleData and reconstruction. " + "First, we import the libraries and generate (or load) the dataset." ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "simu.hdf5 found, skipping generation.\n" + ] + } + ], "source": [ - "%matplotlib notebook\n", "import matplotlib\n", - "# matplotlib.use('tkagg')\n", + "\n", "import PtyLab\n", - "from PtyLab.io import getExampleDataFolder\n", + "from PtyLab.io import getExampleDataFolder, generate_simu_hdf5\n", "import logging\n", + "\n", "logging.basicConfig(level=logging.INFO)\n", "import numpy as np\n", "from PtyLab import Params\n", @@ -88,41 +110,57 @@ "from PtyLab import ExperimentalData\n", "from PtyLab import Engines\n", "\n", - "\"\"\" \n", - "ptycho data reconstructor \n", - "change data visualization and initialization options manually for now\n", - "\"\"\"\n", + "fileName = \"simu.hdf5\"\n", + "filePath = getExampleDataFolder() / fileName\n", "\n", - "\n", - "fileName = 'simu.hdf5' # generate the simu.hdf5 from the simulation tutorial\n", - "filePath = getExampleDataFolder() / fileName\n" + "if not filePath.exists():\n", + " print(\"Generating simu.hdf5...\")\n", + " generate_simu_hdf5(filePath)\n", + " print(\"Done.\")\n", + "else:\n", + " print(f\"{fileName} found, skipping generation.\")" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "ERROR:Reconstruction:Copying attribute wavelength\n", - "ERROR:Reconstruction:Copying attribute dxd\n", - "ERROR:Reconstruction:Copying attribute theta\n", - "ERROR:Reconstruction:Copying attribute spectralDensity\n", - "ERROR:Reconstruction:Copying attribute entrancePupilDiameter\n", - "INFO:Reconstruction:Changing sample-detector distance to 0.05000000074505806\n", + "INFO:GPU:cupy and CUDA available, switching to GPU\n", + "INFO:Reconstruction:Copying attribute wavelength\n", + "INFO:Reconstruction:Copying attribute dxd\n", + "INFO:Reconstruction:Copying attribute theta\n", + "INFO:Reconstruction:Copying attribute spectralDensity\n", + "INFO:Reconstruction:Copying attribute entrancePupilDiameter\n", "INFO:Reconstruction:Initial object set to ones\n", "INFO:Reconstruction:Initial probe set to circ\n", - "INFO:ePIE:Sucesfully created ePIE ePIE_engine\n", + "INFO:ePIE:Sucesfully created ePIE ePIE_engine\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ "INFO:ePIE:Wavelength attribute: 6.327999813038332e-07\n" ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found encoder with shape (100, 2)\n" + ] } ], "source": [ "# easy initialization\n", - "exampleData, reconstruction, params, monitor, ePIE_engine = PtyLab.easyInitialize(filePath)" + "exampleData, reconstruction, params, monitor, ePIE_engine = PtyLab.easyInitialize(\n", + " filePath\n", + ")" ] }, { @@ -135,974 +173,14 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "/* global mpl */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function () {\n", - " if (typeof WebSocket !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof MozWebSocket !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert(\n", - " 'Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.'\n", - " );\n", - " }\n", - "};\n", - "\n", - "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = this.ws.binaryType !== undefined;\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById('mpl-warnings');\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent =\n", - " 'This browser does not support binary websocket messages. ' +\n", - " 'Performance may be slow.';\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = document.createElement('div');\n", - " this.root.setAttribute('style', 'display: inline-block');\n", - " this._root_extra_style(this.root);\n", - "\n", - " parent_element.appendChild(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message('supports_binary', { value: fig.supports_binary });\n", - " fig.send_message('send_image_mode', {});\n", - " if (fig.ratio !== 1) {\n", - " fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });\n", - " }\n", - " fig.send_message('refresh', {});\n", - " };\n", - "\n", - " this.imageObj.onload = function () {\n", - " if (fig.image_mode === 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function () {\n", - " fig.ws.close();\n", - " };\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "};\n", - "\n", - "mpl.figure.prototype._init_header = function () {\n", - " var titlebar = document.createElement('div');\n", - " titlebar.classList =\n", - " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", - " var titletext = document.createElement('div');\n", - " titletext.classList = 'ui-dialog-title';\n", - " titletext.setAttribute(\n", - " 'style',\n", - " 'width: 100%; text-align: center; padding: 3px;'\n", - " );\n", - " titlebar.appendChild(titletext);\n", - " this.root.appendChild(titlebar);\n", - " this.header = titletext;\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._init_canvas = function () {\n", - " var fig = this;\n", - "\n", - " var canvas_div = (this.canvas_div = document.createElement('div'));\n", - " canvas_div.setAttribute(\n", - " 'style',\n", - " 'border: 1px solid #ddd;' +\n", - " 'box-sizing: content-box;' +\n", - " 'clear: both;' +\n", - " 'min-height: 1px;' +\n", - " 'min-width: 1px;' +\n", - " 'outline: 0;' +\n", - " 'overflow: hidden;' +\n", - " 'position: relative;' +\n", - " 'resize: both;'\n", - " );\n", - "\n", - " function on_keyboard_event_closure(name) {\n", - " return function (event) {\n", - " return fig.key_event(event, name);\n", - " };\n", - " }\n", - "\n", - " canvas_div.addEventListener(\n", - " 'keydown',\n", - " on_keyboard_event_closure('key_press')\n", - " );\n", - " canvas_div.addEventListener(\n", - " 'keyup',\n", - " on_keyboard_event_closure('key_release')\n", - " );\n", - "\n", - " this._canvas_extra_style(canvas_div);\n", - " this.root.appendChild(canvas_div);\n", - "\n", - " var canvas = (this.canvas = document.createElement('canvas'));\n", - " canvas.classList.add('mpl-canvas');\n", - " canvas.setAttribute('style', 'box-sizing: content-box;');\n", - "\n", - " this.context = canvas.getContext('2d');\n", - "\n", - " var backingStore =\n", - " this.context.backingStorePixelRatio ||\n", - " this.context.webkitBackingStorePixelRatio ||\n", - " this.context.mozBackingStorePixelRatio ||\n", - " this.context.msBackingStorePixelRatio ||\n", - " this.context.oBackingStorePixelRatio ||\n", - " this.context.backingStorePixelRatio ||\n", - " 1;\n", - "\n", - " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", - " 'canvas'\n", - " ));\n", - " rubberband_canvas.setAttribute(\n", - " 'style',\n", - " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", - " );\n", - "\n", - " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", - " if (this.ResizeObserver === undefined) {\n", - " if (window.ResizeObserver !== undefined) {\n", - " this.ResizeObserver = window.ResizeObserver;\n", - " } else {\n", - " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", - " this.ResizeObserver = obs.ResizeObserver;\n", - " }\n", - " }\n", - "\n", - " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", - " var nentries = entries.length;\n", - " for (var i = 0; i < nentries; i++) {\n", - " var entry = entries[i];\n", - " var width, height;\n", - " if (entry.contentBoxSize) {\n", - " if (entry.contentBoxSize instanceof Array) {\n", - " // Chrome 84 implements new version of spec.\n", - " width = entry.contentBoxSize[0].inlineSize;\n", - " height = entry.contentBoxSize[0].blockSize;\n", - " } else {\n", - " // Firefox implements old version of spec.\n", - " width = entry.contentBoxSize.inlineSize;\n", - " height = entry.contentBoxSize.blockSize;\n", - " }\n", - " } else {\n", - " // Chrome <84 implements even older version of spec.\n", - " width = entry.contentRect.width;\n", - " height = entry.contentRect.height;\n", - " }\n", - "\n", - " // Keep the size of the canvas and rubber band canvas in sync with\n", - " // the canvas container.\n", - " if (entry.devicePixelContentBoxSize) {\n", - " // Chrome 84 implements new version of spec.\n", - " canvas.setAttribute(\n", - " 'width',\n", - " entry.devicePixelContentBoxSize[0].inlineSize\n", - " );\n", - " canvas.setAttribute(\n", - " 'height',\n", - " entry.devicePixelContentBoxSize[0].blockSize\n", - " );\n", - " } else {\n", - " canvas.setAttribute('width', width * fig.ratio);\n", - " canvas.setAttribute('height', height * fig.ratio);\n", - " }\n", - " canvas.setAttribute(\n", - " 'style',\n", - " 'width: ' + width + 'px; height: ' + height + 'px;'\n", - " );\n", - "\n", - " rubberband_canvas.setAttribute('width', width);\n", - " rubberband_canvas.setAttribute('height', height);\n", - "\n", - " // And update the size in Python. We ignore the initial 0/0 size\n", - " // that occurs as the element is placed into the DOM, which should\n", - " // otherwise not happen due to the minimum size styling.\n", - " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", - " fig.request_resize(width, height);\n", - " }\n", - " }\n", - " });\n", - " this.resizeObserverInstance.observe(canvas_div);\n", - "\n", - " function on_mouse_event_closure(name) {\n", - " return function (event) {\n", - " return fig.mouse_event(event, name);\n", - " };\n", - " }\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mousedown',\n", - " on_mouse_event_closure('button_press')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseup',\n", - " on_mouse_event_closure('button_release')\n", - " );\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband_canvas.addEventListener(\n", - " 'mousemove',\n", - " on_mouse_event_closure('motion_notify')\n", - " );\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseenter',\n", - " on_mouse_event_closure('figure_enter')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseleave',\n", - " on_mouse_event_closure('figure_leave')\n", - " );\n", - "\n", - " canvas_div.addEventListener('wheel', function (event) {\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " on_mouse_event_closure('scroll')(event);\n", - " });\n", - "\n", - " canvas_div.appendChild(canvas);\n", - " canvas_div.appendChild(rubberband_canvas);\n", - "\n", - " this.rubberband_context = rubberband_canvas.getContext('2d');\n", - " this.rubberband_context.strokeStyle = '#000000';\n", - "\n", - " this._resize_canvas = function (width, height, forward) {\n", - " if (forward) {\n", - " canvas_div.style.width = width + 'px';\n", - " canvas_div.style.height = height + 'px';\n", - " }\n", - " };\n", - "\n", - " // Disable right mouse context menu.\n", - " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", - " event.preventDefault();\n", - " return false;\n", - " });\n", - "\n", - " function set_focus() {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'mpl-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " continue;\n", - " }\n", - "\n", - " var button = (fig.buttons[name] = document.createElement('button'));\n", - " button.classList = 'mpl-widget';\n", - " button.setAttribute('role', 'button');\n", - " button.setAttribute('aria-disabled', 'false');\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - "\n", - " var icon_img = document.createElement('img');\n", - " icon_img.src = '_images/' + image + '.png';\n", - " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", - " icon_img.alt = tooltip;\n", - " button.appendChild(icon_img);\n", - "\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " var fmt_picker = document.createElement('select');\n", - " fmt_picker.classList = 'mpl-widget';\n", - " toolbar.appendChild(fmt_picker);\n", - " this.format_dropdown = fmt_picker;\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = document.createElement('option');\n", - " option.selected = fmt === mpl.default_extension;\n", - " option.innerHTML = fmt;\n", - " fmt_picker.appendChild(option);\n", - " }\n", - "\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "};\n", - "\n", - "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", - "};\n", - "\n", - "mpl.figure.prototype.send_message = function (type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "};\n", - "\n", - "mpl.figure.prototype.send_draw_message = function () {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1], msg['forward']);\n", - " fig.send_message('refresh', {});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", - " var x0 = msg['x0'] / fig.ratio;\n", - " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", - " var x1 = msg['x1'] / fig.ratio;\n", - " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0,\n", - " 0,\n", - " fig.canvas.width / fig.ratio,\n", - " fig.canvas.height / fig.ratio\n", - " );\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", - " var cursor = msg['cursor'];\n", - " switch (cursor) {\n", - " case 0:\n", - " cursor = 'pointer';\n", - " break;\n", - " case 1:\n", - " cursor = 'default';\n", - " break;\n", - " case 2:\n", - " cursor = 'crosshair';\n", - " break;\n", - " case 3:\n", - " cursor = 'move';\n", - " break;\n", - " }\n", - " fig.rubberband_canvas.style.cursor = cursor;\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_message = function (fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", - " for (var key in msg) {\n", - " if (!(key in fig.buttons)) {\n", - " continue;\n", - " }\n", - " fig.buttons[key].disabled = !msg[key];\n", - " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", - " if (msg['mode'] === 'PAN') {\n", - " fig.buttons['Pan'].classList.add('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " } else if (msg['mode'] === 'ZOOM') {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.add('active');\n", - " } else {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message('ack', {});\n", - "};\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function (fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " evt.data.type = 'image/png';\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src\n", - " );\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " evt.data\n", - " );\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " } else if (\n", - " typeof evt.data === 'string' &&\n", - " evt.data.slice(0, 21) === 'data:image/png;base64'\n", - " ) {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig['handle_' + msg_type];\n", - " } catch (e) {\n", - " console.log(\n", - " \"No handler for the '\" + msg_type + \"' message type: \",\n", - " msg\n", - " );\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\n", - " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", - " e,\n", - " e.stack,\n", - " msg\n", - " );\n", - " }\n", - " }\n", - " };\n", - "};\n", - "\n", - "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function (e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e) {\n", - " e = window.event;\n", - " }\n", - " if (e.target) {\n", - " targ = e.target;\n", - " } else if (e.srcElement) {\n", - " targ = e.srcElement;\n", - " }\n", - " if (targ.nodeType === 3) {\n", - " // defeat Safari bug\n", - " targ = targ.parentNode;\n", - " }\n", - "\n", - " // pageX,Y are the mouse positions relative to the document\n", - " var boundingRect = targ.getBoundingClientRect();\n", - " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", - " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n", - "\n", - " return { x: x, y: y };\n", - "};\n", - "\n", - "/*\n", - " * return a copy of an object with only non-object keys\n", - " * we need this to avoid circular references\n", - " * http://stackoverflow.com/a/24161582/3208463\n", - " */\n", - "function simpleKeys(original) {\n", - " return Object.keys(original).reduce(function (obj, key) {\n", - " if (typeof original[key] !== 'object') {\n", - " obj[key] = original[key];\n", - " }\n", - " return obj;\n", - " }, {});\n", - "}\n", - "\n", - "mpl.figure.prototype.mouse_event = function (event, name) {\n", - " var canvas_pos = mpl.findpos(event);\n", - "\n", - " if (name === 'button_press') {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x * this.ratio;\n", - " var y = canvas_pos.y * this.ratio;\n", - "\n", - " this.send_message(name, {\n", - " x: x,\n", - " y: y,\n", - " button: event.button,\n", - " step: event.step,\n", - " guiEvent: simpleKeys(event),\n", - " });\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "};\n", - "\n", - "mpl.figure.prototype.key_event = function (event, name) {\n", - " // Prevent repeat events\n", - " if (name === 'key_press') {\n", - " if (event.which === this._key) {\n", - " return;\n", - " } else {\n", - " this._key = event.which;\n", - " }\n", - " }\n", - " if (name === 'key_release') {\n", - " this._key = null;\n", - " }\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.which !== 17) {\n", - " value += 'ctrl+';\n", - " }\n", - " if (event.altKey && event.which !== 18) {\n", - " value += 'alt+';\n", - " }\n", - " if (event.shiftKey && event.which !== 16) {\n", - " value += 'shift+';\n", - " }\n", - "\n", - " value += 'k';\n", - " value += event.which.toString();\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", - " if (name === 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message('toolbar_button', { name: name });\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "\n", - "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", - "// prettier-ignore\n", - "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", - "\n", - "mpl.default_extension = \"png\";/* global mpl */\n", - "\n", - "var comm_websocket_adapter = function (comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.close = function () {\n", - " comm.close();\n", - " };\n", - " ws.send = function (m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function (msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", - " ws.onmessage(msg['content']['data']);\n", - " });\n", - " return ws;\n", - "};\n", - "\n", - "mpl.mpl_figure_comm = function (comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = document.getElementById(id);\n", - " var ws_proxy = comm_websocket_adapter(comm);\n", - "\n", - " function ondownload(figure, _format) {\n", - " window.open(figure.canvas.toDataURL());\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element;\n", - " fig.cell_info = mpl.find_output_cell(\"
\");\n", - " if (!fig.cell_info) {\n", - " console.error('Failed to find cell for figure', id, fig);\n", - " return;\n", - " }\n", - " fig.cell_info[0].output_area.element.on(\n", - " 'cleared',\n", - " { fig: fig },\n", - " fig._remove_fig_handler\n", - " );\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function (fig, msg) {\n", - " var width = fig.canvas.width / fig.ratio;\n", - " fig.cell_info[0].output_area.element.off(\n", - " 'cleared',\n", - " fig._remove_fig_handler\n", - " );\n", - " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", - "\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable();\n", - " fig.parent_element.innerHTML =\n", - " '';\n", - " fig.close_ws(fig, msg);\n", - "};\n", - "\n", - "mpl.figure.prototype.close_ws = function (fig, msg) {\n", - " fig.send_message('closing', msg);\n", - " // fig.ws.close()\n", - "};\n", - "\n", - "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var width = this.canvas.width / this.ratio;\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] =\n", - " '';\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message('ack', {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () {\n", - " fig.push_to_output();\n", - " }, 1000);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'btn-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " var button;\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " continue;\n", - " }\n", - "\n", - " button = fig.buttons[name] = document.createElement('button');\n", - " button.classList = 'btn btn-default';\n", - " button.href = '#';\n", - " button.title = name;\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message pull-right';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = document.createElement('div');\n", - " buttongrp.classList = 'btn-group inline pull-right';\n", - " button = document.createElement('button');\n", - " button.classList = 'btn btn-mini btn-primary';\n", - " button.href = '#';\n", - " button.title = 'Stop Interaction';\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', function (_evt) {\n", - " fig.handle_close(fig, {});\n", - " });\n", - " button.addEventListener(\n", - " 'mouseover',\n", - " on_mouseover_closure('Stop Interaction')\n", - " );\n", - " buttongrp.appendChild(button);\n", - " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", - " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", - "};\n", - "\n", - "mpl.figure.prototype._remove_fig_handler = function (event) {\n", - " var fig = event.data.fig;\n", - " if (event.target !== this) {\n", - " // Ignore bubbled events from children.\n", - " return;\n", - " }\n", - " fig.close_ws(fig, {});\n", - "};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (el) {\n", - " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (el) {\n", - " // this is important to make the div 'focusable\n", - " el.setAttribute('tabindex', 0);\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " } else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", - " var manager = IPython.notebook.keyboard_manager;\n", - " if (!manager) {\n", - " manager = IPython.keyboard_manager;\n", - " }\n", - "\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which === 13) {\n", - " this.canvas_div.blur();\n", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " fig.ondownload(fig, null);\n", - "};\n", - "\n", - "mpl.find_output_cell = function (html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i = 0; i < ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code') {\n", - " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] === html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "};\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel !== null) {\n", - " IPython.notebook.kernel.comm_manager.register_target(\n", - " 'matplotlib',\n", - " mpl.mpl_figure_comm\n", - " );\n", - "}\n" - ], + "image/png": "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", "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "" - ], - "text/plain": [ - "" + "
" ] }, "metadata": {}, @@ -1113,16 +191,22 @@ "# perturb encoder positions\n", "maxPosError = 10\n", "encoder0 = exampleData.encoder.copy()\n", - "exampleData.encoder = encoder0 + maxPosError * reconstruction.dxo * (2*np.random.rand(encoder0.shape[0], encoder0.shape[1]) - 1)\n", + "exampleData.encoder = encoder0 + maxPosError * reconstruction.dxo * (\n", + " 2 * np.random.rand(encoder0.shape[0], encoder0.shape[1]) - 1\n", + ")\n", "import matplotlib.pyplot as plt\n", + "\n", "figure, ax = plt.subplots(1, 1, num=112, squeeze=True, clear=True, figsize=(5, 5))\n", - "ax.set_title('Original and perturbed scan grid positions')\n", - "ax.set_xlabel('(um)')\n", - "ax.set_ylabel('(um)')\n", - "line1, = plt.plot(encoder0[:, 1] * 1e6,\n", - " encoder0[:, 0] * 1e6, 'bo', label='correct')\n", - "line2, = plt.plot(exampleData.encoder[:, 1] * 1e6,\n", - " exampleData.encoder[:, 0] * 1e6, 'yo', label='false')\n", + "ax.set_title(\"Original and perturbed scan grid positions\")\n", + "ax.set_xlabel(\"(um)\")\n", + "ax.set_ylabel(\"(um)\")\n", + "(line1,) = plt.plot(encoder0[:, 1] * 1e6, encoder0[:, 0] * 1e6, \"bo\", label=\"correct\")\n", + "(line2,) = plt.plot(\n", + " exampleData.encoder[:, 1] * 1e6,\n", + " exampleData.encoder[:, 0] * 1e6,\n", + " \"yo\",\n", + " label=\"false\",\n", + ")\n", "plt.legend(handles=[line1, line2])\n", "plt.tight_layout()\n", "plt.show(block=False)" @@ -1137,24 +221,23 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "ERROR:Reconstruction:Copying attribute wavelength\n", - "ERROR:Reconstruction:Copying attribute dxd\n", - "ERROR:Reconstruction:Copying attribute theta\n", - "ERROR:Reconstruction:Copying attribute spectralDensity\n", - "ERROR:Reconstruction:Copying attribute entrancePupilDiameter\n", - "INFO:Reconstruction:Changing sample-detector distance to 0.05000000074505806\n" + "INFO:Reconstruction:Copying attribute wavelength\n", + "INFO:Reconstruction:Copying attribute dxd\n", + "INFO:Reconstruction:Copying attribute theta\n", + "INFO:Reconstruction:Copying attribute spectralDensity\n", + "INFO:Reconstruction:Copying attribute entrancePupilDiameter\n" ] } ], "source": [ - "#initialize again reconstruction with the wrong encoder data\n", + "# initialize again reconstruction with the wrong encoder data\n", "reconstruction = Reconstruction(exampleData, params)" ] }, @@ -1167,17 +250,31 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Min max ptychogram: 2.462452171423518e-14, 32837.0\n", - "Min max ptychogram: 1.0704034878741355e-14, 4.516376698526149\n", - "1.0704034878741355e-14 4.516376698526149\n" + "Min max ptychogram: 2.462452171423518e-14, 32774.45703125\n", + "Min max ptychogram: 0.0, 4.5155487060546875\n", + "0.0 4.5155487\n" ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0c27ce9d18de47b3966e1ff70e6bb694", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(IntSlider(value=0, description='Frame', max=99), Output()))" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -1186,7 +283,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -1194,44 +291,59 @@ "output_type": "stream", "text": [ "INFO:Reconstruction:Initial object set to ones\n", - "INFO:Reconstruction:Initial probe set to circ\n" + "INFO:Reconstruction:Initial probe set to circ\n", + "/mnt/home/shantanu/projects/PtyLab.py/PtyLab/Monitor/Monitor.py:178: UserWarning: For faster update of the reconstruction plot, set `monitor.figureUpdateFrequency = 5` or higher.\n", + " warnings.warn(\n", + "/mnt/home/shantanu/projects/PtyLab.py/PtyLab/Monitor/Monitor.py:191: UserWarning: For diffraction data plot, preferably use an interactive matplotlib backend or set `monitor.verboseLevel = \"low\"`. \n", + " warnings.warn(\n", + "INFO:GPU:cupy and CUDA available, switching to GPU\n" ] } ], "source": [ "# now, all our experimental data is loaded into experimental_data and we don't have to worry about it anymore.\n", "# now create an object to hold everything we're eventually interested in\n", - "reconstruction.npsm = 1 # Number of probe modes to reconstruct\n", - "reconstruction.nosm = 1 # Number of object modes to reconstruct\n", - "reconstruction.nlambda = 1 # len(exampleData.spectralDensity) # Number of wavelength\n", - "reconstruction.nslice = 1 # Number of object slice\n", + "reconstruction.npsm = 1 # Number of probe modes to reconstruct\n", + "reconstruction.nosm = 1 # Number of object modes to reconstruct\n", + "reconstruction.nlambda = 1 # len(exampleData.spectralDensity) # Number of wavelength\n", + "reconstruction.nslice = 1 # Number of object slice\n", "\n", "\n", - "reconstruction.initialProbe = 'circ'\n", - "exampleData.entrancePupilDiameter = reconstruction.Np / 3 * reconstruction.dxp # initial estimate of beam diameter\n", - "reconstruction.initialObject = 'ones'\n", + "reconstruction.initialProbe = \"circ\"\n", + "exampleData.entrancePupilDiameter = (\n", + " reconstruction.Np / 3 * reconstruction.dxp\n", + ") # initial estimate of beam diameter\n", + "reconstruction.initialObject = \"ones\"\n", "# initialize probe and object and related params\n", "reconstruction.initializeObjectProbe()\n", "\n", "# customize initial probe quadratic phase\n", - "reconstruction.probe = reconstruction.probe*np.exp(1.j*2*np.pi/reconstruction.wavelength *\n", - " (reconstruction.Xp**2+reconstruction.Yp**2)/(2*6e-3))\n", + "reconstruction.probe = reconstruction.probe * np.exp(\n", + " 1.0j\n", + " * 2\n", + " * np.pi\n", + " / reconstruction.wavelength\n", + " * (reconstruction.Xp**2 + reconstruction.Yp**2)\n", + " / (2 * 6e-3)\n", + ")\n", "\n", "# this will copy any attributes from experimental data that we might care to optimize\n", "# # Set monitor properties\n", "monitor = Monitor()\n", "monitor.figureUpdateFrequency = 1\n", - "monitor.objectPlot = 'complex' # complex abs angle\n", - "monitor.verboseLevel = 'high' # high: plot two figures, low: plot only one figure\n", - "monitor.objectPlotZoom = 1.5 # control object plot FoV\n", - "monitor.probePlotZoom = 0.5 # control probe plot FoV\n", + "monitor.objectPlot = \"complex\" # complex abs angle\n", + "monitor.verboseLevel = \"high\" # high: plot two figures, low: plot only one figure\n", + "monitor.objectZoom = 1.5 # control object plot FoV\n", + "monitor.probeZoom = 0.5 # control probe plot FoV\n", "\n", "# Run the reconstruction\n", "\n", "params = Params()\n", "## main parameters\n", - "params.positionOrder = 'random' # 'sequential' or 'random'\n", - "params.propagator = 'Fresnel' # Fraunhofer Fresnel ASP scaledASP polychromeASP scaledPolychromeASP\n", + "params.positionOrder = \"random\" # 'sequential' or 'random'\n", + "params.propagator = (\n", + " \"Fresnel\" # Fraunhofer Fresnel ASP scaledASP polychromeASP scaledPolychromeASP\n", + ")\n", "\n", "\n", "## how do we want to reconstruct?\n", @@ -1242,14 +354,14 @@ "params.orthogonalizationSwitch = False\n", "params.orthogonalizationFrequency = 10\n", "params.fftshiftSwitch = False\n", - "params.intensityConstraint = 'standard' # standard fluctuation exponential poission\n", + "params.intensityConstraint = \"standard\" # standard fluctuation exponential poission\n", "params.absorbingProbeBoundary = False\n", "params.objectContrastSwitch = False\n", "params.absObjectSwitch = False\n", "params.backgroundModeSwitch = False\n", "params.couplingSwitch = True\n", "params.couplingAleph = 1\n", - "params.positionCorrectionSwitch = False\n" + "params.positionCorrectionSwitch = False" ] }, { @@ -1261,7 +373,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -1277,10 +389,10 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 18, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -1289,7 +401,7 @@ "ePIE_engine = Engines.ePIE(reconstruction, exampleData, params, monitor)\n", "## choose engine\n", "# ePIE\n", - "engine_ePIE = Engines.ePIE(reconstruction, exampleData, params,monitor)\n", + "engine_ePIE = Engines.ePIE(reconstruction, exampleData, params, monitor)\n", "engine_ePIE.numIterations = 50\n", "engine_ePIE.betaProbe = 0.25\n", "engine_ePIE.betaObject = 0.25\n", @@ -1305,4369 +417,110 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 8, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Reconstruction:Initial object set to ones\n", - "INFO:Reconstruction:Initial probe set to circ\n", - "INFO:pcPIE:Successfully created pcPIE pcPIE_engine\n", - "INFO:pcPIE:Wavelength attribute: 6.327999813038332e-07\n", - "d:\\du\\ptylab\\PtyLab\\Engines\\BaseEngine.py:376: UserWarning: fftshiftSwitch set to false, this may lead to reduced performance\n", - " warnings.warn(\n" - ] - }, - { - "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "/* global mpl */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function () {\n", - " if (typeof WebSocket !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof MozWebSocket !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert(\n", - " 'Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.'\n", - " );\n", - " }\n", - "};\n", - "\n", - "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = this.ws.binaryType !== undefined;\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById('mpl-warnings');\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent =\n", - " 'This browser does not support binary websocket messages. ' +\n", - " 'Performance may be slow.';\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = document.createElement('div');\n", - " this.root.setAttribute('style', 'display: inline-block');\n", - " this._root_extra_style(this.root);\n", - "\n", - " parent_element.appendChild(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message('supports_binary', { value: fig.supports_binary });\n", - " fig.send_message('send_image_mode', {});\n", - " if (fig.ratio !== 1) {\n", - " fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });\n", - " }\n", - " fig.send_message('refresh', {});\n", - " };\n", - "\n", - " this.imageObj.onload = function () {\n", - " if (fig.image_mode === 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function () {\n", - " fig.ws.close();\n", - " };\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "};\n", - "\n", - "mpl.figure.prototype._init_header = function () {\n", - " var titlebar = document.createElement('div');\n", - " titlebar.classList =\n", - " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", - " var titletext = document.createElement('div');\n", - " titletext.classList = 'ui-dialog-title';\n", - " titletext.setAttribute(\n", - " 'style',\n", - " 'width: 100%; text-align: center; padding: 3px;'\n", - " );\n", - " titlebar.appendChild(titletext);\n", - " this.root.appendChild(titlebar);\n", - " this.header = titletext;\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._init_canvas = function () {\n", - " var fig = this;\n", - "\n", - " var canvas_div = (this.canvas_div = document.createElement('div'));\n", - " canvas_div.setAttribute(\n", - " 'style',\n", - " 'border: 1px solid #ddd;' +\n", - " 'box-sizing: content-box;' +\n", - " 'clear: both;' +\n", - " 'min-height: 1px;' +\n", - " 'min-width: 1px;' +\n", - " 'outline: 0;' +\n", - " 'overflow: hidden;' +\n", - " 'position: relative;' +\n", - " 'resize: both;'\n", - " );\n", - "\n", - " function on_keyboard_event_closure(name) {\n", - " return function (event) {\n", - " return fig.key_event(event, name);\n", - " };\n", - " }\n", - "\n", - " canvas_div.addEventListener(\n", - " 'keydown',\n", - " on_keyboard_event_closure('key_press')\n", - " );\n", - " canvas_div.addEventListener(\n", - " 'keyup',\n", - " on_keyboard_event_closure('key_release')\n", - " );\n", - "\n", - " this._canvas_extra_style(canvas_div);\n", - " this.root.appendChild(canvas_div);\n", - "\n", - " var canvas = (this.canvas = document.createElement('canvas'));\n", - " canvas.classList.add('mpl-canvas');\n", - " canvas.setAttribute('style', 'box-sizing: content-box;');\n", - "\n", - " this.context = canvas.getContext('2d');\n", - "\n", - " var backingStore =\n", - " this.context.backingStorePixelRatio ||\n", - " this.context.webkitBackingStorePixelRatio ||\n", - " this.context.mozBackingStorePixelRatio ||\n", - " this.context.msBackingStorePixelRatio ||\n", - " this.context.oBackingStorePixelRatio ||\n", - " this.context.backingStorePixelRatio ||\n", - " 1;\n", - "\n", - " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", - " 'canvas'\n", - " ));\n", - " rubberband_canvas.setAttribute(\n", - " 'style',\n", - " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", - " );\n", - "\n", - " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", - " if (this.ResizeObserver === undefined) {\n", - " if (window.ResizeObserver !== undefined) {\n", - " this.ResizeObserver = window.ResizeObserver;\n", - " } else {\n", - " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", - " this.ResizeObserver = obs.ResizeObserver;\n", - " }\n", - " }\n", - "\n", - " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", - " var nentries = entries.length;\n", - " for (var i = 0; i < nentries; i++) {\n", - " var entry = entries[i];\n", - " var width, height;\n", - " if (entry.contentBoxSize) {\n", - " if (entry.contentBoxSize instanceof Array) {\n", - " // Chrome 84 implements new version of spec.\n", - " width = entry.contentBoxSize[0].inlineSize;\n", - " height = entry.contentBoxSize[0].blockSize;\n", - " } else {\n", - " // Firefox implements old version of spec.\n", - " width = entry.contentBoxSize.inlineSize;\n", - " height = entry.contentBoxSize.blockSize;\n", - " }\n", - " } else {\n", - " // Chrome <84 implements even older version of spec.\n", - " width = entry.contentRect.width;\n", - " height = entry.contentRect.height;\n", - " }\n", - "\n", - " // Keep the size of the canvas and rubber band canvas in sync with\n", - " // the canvas container.\n", - " if (entry.devicePixelContentBoxSize) {\n", - " // Chrome 84 implements new version of spec.\n", - " canvas.setAttribute(\n", - " 'width',\n", - " entry.devicePixelContentBoxSize[0].inlineSize\n", - " );\n", - " canvas.setAttribute(\n", - " 'height',\n", - " entry.devicePixelContentBoxSize[0].blockSize\n", - " );\n", - " } else {\n", - " canvas.setAttribute('width', width * fig.ratio);\n", - " canvas.setAttribute('height', height * fig.ratio);\n", - " }\n", - " canvas.setAttribute(\n", - " 'style',\n", - " 'width: ' + width + 'px; height: ' + height + 'px;'\n", - " );\n", - "\n", - " rubberband_canvas.setAttribute('width', width);\n", - " rubberband_canvas.setAttribute('height', height);\n", - "\n", - " // And update the size in Python. We ignore the initial 0/0 size\n", - " // that occurs as the element is placed into the DOM, which should\n", - " // otherwise not happen due to the minimum size styling.\n", - " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", - " fig.request_resize(width, height);\n", - " }\n", - " }\n", - " });\n", - " this.resizeObserverInstance.observe(canvas_div);\n", - "\n", - " function on_mouse_event_closure(name) {\n", - " return function (event) {\n", - " return fig.mouse_event(event, name);\n", - " };\n", - " }\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mousedown',\n", - " on_mouse_event_closure('button_press')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseup',\n", - " on_mouse_event_closure('button_release')\n", - " );\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband_canvas.addEventListener(\n", - " 'mousemove',\n", - " on_mouse_event_closure('motion_notify')\n", - " );\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseenter',\n", - " on_mouse_event_closure('figure_enter')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseleave',\n", - " on_mouse_event_closure('figure_leave')\n", - " );\n", - "\n", - " canvas_div.addEventListener('wheel', function (event) {\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " on_mouse_event_closure('scroll')(event);\n", - " });\n", - "\n", - " canvas_div.appendChild(canvas);\n", - " canvas_div.appendChild(rubberband_canvas);\n", - "\n", - " this.rubberband_context = rubberband_canvas.getContext('2d');\n", - " this.rubberband_context.strokeStyle = '#000000';\n", - "\n", - " this._resize_canvas = function (width, height, forward) {\n", - " if (forward) {\n", - " canvas_div.style.width = width + 'px';\n", - " canvas_div.style.height = height + 'px';\n", - " }\n", - " };\n", - "\n", - " // Disable right mouse context menu.\n", - " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", - " event.preventDefault();\n", - " return false;\n", - " });\n", - "\n", - " function set_focus() {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'mpl-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " continue;\n", - " }\n", - "\n", - " var button = (fig.buttons[name] = document.createElement('button'));\n", - " button.classList = 'mpl-widget';\n", - " button.setAttribute('role', 'button');\n", - " button.setAttribute('aria-disabled', 'false');\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - "\n", - " var icon_img = document.createElement('img');\n", - " icon_img.src = '_images/' + image + '.png';\n", - " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", - " icon_img.alt = tooltip;\n", - " button.appendChild(icon_img);\n", - "\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " var fmt_picker = document.createElement('select');\n", - " fmt_picker.classList = 'mpl-widget';\n", - " toolbar.appendChild(fmt_picker);\n", - " this.format_dropdown = fmt_picker;\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = document.createElement('option');\n", - " option.selected = fmt === mpl.default_extension;\n", - " option.innerHTML = fmt;\n", - " fmt_picker.appendChild(option);\n", - " }\n", - "\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "};\n", - "\n", - "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", - "};\n", - "\n", - "mpl.figure.prototype.send_message = function (type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "};\n", - "\n", - "mpl.figure.prototype.send_draw_message = function () {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1], msg['forward']);\n", - " fig.send_message('refresh', {});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", - " var x0 = msg['x0'] / fig.ratio;\n", - " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", - " var x1 = msg['x1'] / fig.ratio;\n", - " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0,\n", - " 0,\n", - " fig.canvas.width / fig.ratio,\n", - " fig.canvas.height / fig.ratio\n", - " );\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", - " var cursor = msg['cursor'];\n", - " switch (cursor) {\n", - " case 0:\n", - " cursor = 'pointer';\n", - " break;\n", - " case 1:\n", - " cursor = 'default';\n", - " break;\n", - " case 2:\n", - " cursor = 'crosshair';\n", - " break;\n", - " case 3:\n", - " cursor = 'move';\n", - " break;\n", - " }\n", - " fig.rubberband_canvas.style.cursor = cursor;\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_message = function (fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", - " for (var key in msg) {\n", - " if (!(key in fig.buttons)) {\n", - " continue;\n", - " }\n", - " fig.buttons[key].disabled = !msg[key];\n", - " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", - " if (msg['mode'] === 'PAN') {\n", - " fig.buttons['Pan'].classList.add('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " } else if (msg['mode'] === 'ZOOM') {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.add('active');\n", - " } else {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message('ack', {});\n", - "};\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function (fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " evt.data.type = 'image/png';\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src\n", - " );\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " evt.data\n", - " );\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " } else if (\n", - " typeof evt.data === 'string' &&\n", - " evt.data.slice(0, 21) === 'data:image/png;base64'\n", - " ) {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig['handle_' + msg_type];\n", - " } catch (e) {\n", - " console.log(\n", - " \"No handler for the '\" + msg_type + \"' message type: \",\n", - " msg\n", - " );\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\n", - " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", - " e,\n", - " e.stack,\n", - " msg\n", - " );\n", - " }\n", - " }\n", - " };\n", - "};\n", - "\n", - "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function (e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e) {\n", - " e = window.event;\n", - " }\n", - " if (e.target) {\n", - " targ = e.target;\n", - " } else if (e.srcElement) {\n", - " targ = e.srcElement;\n", - " }\n", - " if (targ.nodeType === 3) {\n", - " // defeat Safari bug\n", - " targ = targ.parentNode;\n", - " }\n", - "\n", - " // pageX,Y are the mouse positions relative to the document\n", - " var boundingRect = targ.getBoundingClientRect();\n", - " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", - " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n", - "\n", - " return { x: x, y: y };\n", - "};\n", - "\n", - "/*\n", - " * return a copy of an object with only non-object keys\n", - " * we need this to avoid circular references\n", - " * http://stackoverflow.com/a/24161582/3208463\n", - " */\n", - "function simpleKeys(original) {\n", - " return Object.keys(original).reduce(function (obj, key) {\n", - " if (typeof original[key] !== 'object') {\n", - " obj[key] = original[key];\n", - " }\n", - " return obj;\n", - " }, {});\n", - "}\n", - "\n", - "mpl.figure.prototype.mouse_event = function (event, name) {\n", - " var canvas_pos = mpl.findpos(event);\n", - "\n", - " if (name === 'button_press') {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x * this.ratio;\n", - " var y = canvas_pos.y * this.ratio;\n", - "\n", - " this.send_message(name, {\n", - " x: x,\n", - " y: y,\n", - " button: event.button,\n", - " step: event.step,\n", - " guiEvent: simpleKeys(event),\n", - " });\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "};\n", - "\n", - "mpl.figure.prototype.key_event = function (event, name) {\n", - " // Prevent repeat events\n", - " if (name === 'key_press') {\n", - " if (event.which === this._key) {\n", - " return;\n", - " } else {\n", - " this._key = event.which;\n", - " }\n", - " }\n", - " if (name === 'key_release') {\n", - " this._key = null;\n", - " }\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.which !== 17) {\n", - " value += 'ctrl+';\n", - " }\n", - " if (event.altKey && event.which !== 18) {\n", - " value += 'alt+';\n", - " }\n", - " if (event.shiftKey && event.which !== 16) {\n", - " value += 'shift+';\n", - " }\n", - "\n", - " value += 'k';\n", - " value += event.which.toString();\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", - " if (name === 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message('toolbar_button', { name: name });\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "\n", - "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", - "// prettier-ignore\n", - "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", - "\n", - "mpl.default_extension = \"png\";/* global mpl */\n", - "\n", - "var comm_websocket_adapter = function (comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.close = function () {\n", - " comm.close();\n", - " };\n", - " ws.send = function (m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function (msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", - " ws.onmessage(msg['content']['data']);\n", - " });\n", - " return ws;\n", - "};\n", - "\n", - "mpl.mpl_figure_comm = function (comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = document.getElementById(id);\n", - " var ws_proxy = comm_websocket_adapter(comm);\n", - "\n", - " function ondownload(figure, _format) {\n", - " window.open(figure.canvas.toDataURL());\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element;\n", - " fig.cell_info = mpl.find_output_cell(\"
\");\n", - " if (!fig.cell_info) {\n", - " console.error('Failed to find cell for figure', id, fig);\n", - " return;\n", - " }\n", - " fig.cell_info[0].output_area.element.on(\n", - " 'cleared',\n", - " { fig: fig },\n", - " fig._remove_fig_handler\n", - " );\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function (fig, msg) {\n", - " var width = fig.canvas.width / fig.ratio;\n", - " fig.cell_info[0].output_area.element.off(\n", - " 'cleared',\n", - " fig._remove_fig_handler\n", - " );\n", - " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", - "\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable();\n", - " fig.parent_element.innerHTML =\n", - " '';\n", - " fig.close_ws(fig, msg);\n", - "};\n", - "\n", - "mpl.figure.prototype.close_ws = function (fig, msg) {\n", - " fig.send_message('closing', msg);\n", - " // fig.ws.close()\n", - "};\n", - "\n", - "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var width = this.canvas.width / this.ratio;\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] =\n", - " '';\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message('ack', {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () {\n", - " fig.push_to_output();\n", - " }, 1000);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'btn-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " var button;\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " continue;\n", - " }\n", - "\n", - " button = fig.buttons[name] = document.createElement('button');\n", - " button.classList = 'btn btn-default';\n", - " button.href = '#';\n", - " button.title = name;\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message pull-right';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = document.createElement('div');\n", - " buttongrp.classList = 'btn-group inline pull-right';\n", - " button = document.createElement('button');\n", - " button.classList = 'btn btn-mini btn-primary';\n", - " button.href = '#';\n", - " button.title = 'Stop Interaction';\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', function (_evt) {\n", - " fig.handle_close(fig, {});\n", - " });\n", - " button.addEventListener(\n", - " 'mouseover',\n", - " on_mouseover_closure('Stop Interaction')\n", - " );\n", - " buttongrp.appendChild(button);\n", - " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", - " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", - "};\n", - "\n", - "mpl.figure.prototype._remove_fig_handler = function (event) {\n", - " var fig = event.data.fig;\n", - " if (event.target !== this) {\n", - " // Ignore bubbled events from children.\n", - " return;\n", - " }\n", - " fig.close_ws(fig, {});\n", - "};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (el) {\n", - " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (el) {\n", - " // this is important to make the div 'focusable\n", - " el.setAttribute('tabindex', 0);\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " } else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", - " var manager = IPython.notebook.keyboard_manager;\n", - " if (!manager) {\n", - " manager = IPython.keyboard_manager;\n", - " }\n", - "\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which === 13) {\n", - " this.canvas_div.blur();\n", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " fig.ondownload(fig, null);\n", - "};\n", - "\n", - "mpl.find_output_cell = function (html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i = 0; i < ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code') {\n", - " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] === html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "};\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel !== null) {\n", - " IPython.notebook.kernel.comm_manager.register_target(\n", - " 'matplotlib',\n", - " mpl.mpl_figure_comm\n", - " );\n", - "}\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "/* global mpl */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function () {\n", - " if (typeof WebSocket !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof MozWebSocket !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert(\n", - " 'Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.'\n", - " );\n", - " }\n", - "};\n", - "\n", - "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = this.ws.binaryType !== undefined;\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById('mpl-warnings');\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent =\n", - " 'This browser does not support binary websocket messages. ' +\n", - " 'Performance may be slow.';\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = document.createElement('div');\n", - " this.root.setAttribute('style', 'display: inline-block');\n", - " this._root_extra_style(this.root);\n", - "\n", - " parent_element.appendChild(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message('supports_binary', { value: fig.supports_binary });\n", - " fig.send_message('send_image_mode', {});\n", - " if (fig.ratio !== 1) {\n", - " fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });\n", - " }\n", - " fig.send_message('refresh', {});\n", - " };\n", - "\n", - " this.imageObj.onload = function () {\n", - " if (fig.image_mode === 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function () {\n", - " fig.ws.close();\n", - " };\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "};\n", - "\n", - "mpl.figure.prototype._init_header = function () {\n", - " var titlebar = document.createElement('div');\n", - " titlebar.classList =\n", - " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", - " var titletext = document.createElement('div');\n", - " titletext.classList = 'ui-dialog-title';\n", - " titletext.setAttribute(\n", - " 'style',\n", - " 'width: 100%; text-align: center; padding: 3px;'\n", - " );\n", - " titlebar.appendChild(titletext);\n", - " this.root.appendChild(titlebar);\n", - " this.header = titletext;\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._init_canvas = function () {\n", - " var fig = this;\n", - "\n", - " var canvas_div = (this.canvas_div = document.createElement('div'));\n", - " canvas_div.setAttribute(\n", - " 'style',\n", - " 'border: 1px solid #ddd;' +\n", - " 'box-sizing: content-box;' +\n", - " 'clear: both;' +\n", - " 'min-height: 1px;' +\n", - " 'min-width: 1px;' +\n", - " 'outline: 0;' +\n", - " 'overflow: hidden;' +\n", - " 'position: relative;' +\n", - " 'resize: both;'\n", - " );\n", - "\n", - " function on_keyboard_event_closure(name) {\n", - " return function (event) {\n", - " return fig.key_event(event, name);\n", - " };\n", - " }\n", - "\n", - " canvas_div.addEventListener(\n", - " 'keydown',\n", - " on_keyboard_event_closure('key_press')\n", - " );\n", - " canvas_div.addEventListener(\n", - " 'keyup',\n", - " on_keyboard_event_closure('key_release')\n", - " );\n", - "\n", - " this._canvas_extra_style(canvas_div);\n", - " this.root.appendChild(canvas_div);\n", - "\n", - " var canvas = (this.canvas = document.createElement('canvas'));\n", - " canvas.classList.add('mpl-canvas');\n", - " canvas.setAttribute('style', 'box-sizing: content-box;');\n", - "\n", - " this.context = canvas.getContext('2d');\n", - "\n", - " var backingStore =\n", - " this.context.backingStorePixelRatio ||\n", - " this.context.webkitBackingStorePixelRatio ||\n", - " this.context.mozBackingStorePixelRatio ||\n", - " this.context.msBackingStorePixelRatio ||\n", - " this.context.oBackingStorePixelRatio ||\n", - " this.context.backingStorePixelRatio ||\n", - " 1;\n", - "\n", - " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", - " 'canvas'\n", - " ));\n", - " rubberband_canvas.setAttribute(\n", - " 'style',\n", - " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", - " );\n", - "\n", - " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", - " if (this.ResizeObserver === undefined) {\n", - " if (window.ResizeObserver !== undefined) {\n", - " this.ResizeObserver = window.ResizeObserver;\n", - " } else {\n", - " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", - " this.ResizeObserver = obs.ResizeObserver;\n", - " }\n", - " }\n", - "\n", - " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", - " var nentries = entries.length;\n", - " for (var i = 0; i < nentries; i++) {\n", - " var entry = entries[i];\n", - " var width, height;\n", - " if (entry.contentBoxSize) {\n", - " if (entry.contentBoxSize instanceof Array) {\n", - " // Chrome 84 implements new version of spec.\n", - " width = entry.contentBoxSize[0].inlineSize;\n", - " height = entry.contentBoxSize[0].blockSize;\n", - " } else {\n", - " // Firefox implements old version of spec.\n", - " width = entry.contentBoxSize.inlineSize;\n", - " height = entry.contentBoxSize.blockSize;\n", - " }\n", - " } else {\n", - " // Chrome <84 implements even older version of spec.\n", - " width = entry.contentRect.width;\n", - " height = entry.contentRect.height;\n", - " }\n", - "\n", - " // Keep the size of the canvas and rubber band canvas in sync with\n", - " // the canvas container.\n", - " if (entry.devicePixelContentBoxSize) {\n", - " // Chrome 84 implements new version of spec.\n", - " canvas.setAttribute(\n", - " 'width',\n", - " entry.devicePixelContentBoxSize[0].inlineSize\n", - " );\n", - " canvas.setAttribute(\n", - " 'height',\n", - " entry.devicePixelContentBoxSize[0].blockSize\n", - " );\n", - " } else {\n", - " canvas.setAttribute('width', width * fig.ratio);\n", - " canvas.setAttribute('height', height * fig.ratio);\n", - " }\n", - " canvas.setAttribute(\n", - " 'style',\n", - " 'width: ' + width + 'px; height: ' + height + 'px;'\n", - " );\n", - "\n", - " rubberband_canvas.setAttribute('width', width);\n", - " rubberband_canvas.setAttribute('height', height);\n", - "\n", - " // And update the size in Python. We ignore the initial 0/0 size\n", - " // that occurs as the element is placed into the DOM, which should\n", - " // otherwise not happen due to the minimum size styling.\n", - " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", - " fig.request_resize(width, height);\n", - " }\n", - " }\n", - " });\n", - " this.resizeObserverInstance.observe(canvas_div);\n", - "\n", - " function on_mouse_event_closure(name) {\n", - " return function (event) {\n", - " return fig.mouse_event(event, name);\n", - " };\n", - " }\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mousedown',\n", - " on_mouse_event_closure('button_press')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseup',\n", - " on_mouse_event_closure('button_release')\n", - " );\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband_canvas.addEventListener(\n", - " 'mousemove',\n", - " on_mouse_event_closure('motion_notify')\n", - " );\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseenter',\n", - " on_mouse_event_closure('figure_enter')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseleave',\n", - " on_mouse_event_closure('figure_leave')\n", - " );\n", - "\n", - " canvas_div.addEventListener('wheel', function (event) {\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " on_mouse_event_closure('scroll')(event);\n", - " });\n", - "\n", - " canvas_div.appendChild(canvas);\n", - " canvas_div.appendChild(rubberband_canvas);\n", - "\n", - " this.rubberband_context = rubberband_canvas.getContext('2d');\n", - " this.rubberband_context.strokeStyle = '#000000';\n", - "\n", - " this._resize_canvas = function (width, height, forward) {\n", - " if (forward) {\n", - " canvas_div.style.width = width + 'px';\n", - " canvas_div.style.height = height + 'px';\n", - " }\n", - " };\n", - "\n", - " // Disable right mouse context menu.\n", - " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", - " event.preventDefault();\n", - " return false;\n", - " });\n", - "\n", - " function set_focus() {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'mpl-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " continue;\n", - " }\n", - "\n", - " var button = (fig.buttons[name] = document.createElement('button'));\n", - " button.classList = 'mpl-widget';\n", - " button.setAttribute('role', 'button');\n", - " button.setAttribute('aria-disabled', 'false');\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - "\n", - " var icon_img = document.createElement('img');\n", - " icon_img.src = '_images/' + image + '.png';\n", - " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", - " icon_img.alt = tooltip;\n", - " button.appendChild(icon_img);\n", - "\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " var fmt_picker = document.createElement('select');\n", - " fmt_picker.classList = 'mpl-widget';\n", - " toolbar.appendChild(fmt_picker);\n", - " this.format_dropdown = fmt_picker;\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = document.createElement('option');\n", - " option.selected = fmt === mpl.default_extension;\n", - " option.innerHTML = fmt;\n", - " fmt_picker.appendChild(option);\n", - " }\n", - "\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "};\n", - "\n", - "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", - "};\n", - "\n", - "mpl.figure.prototype.send_message = function (type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "};\n", - "\n", - "mpl.figure.prototype.send_draw_message = function () {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1], msg['forward']);\n", - " fig.send_message('refresh', {});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", - " var x0 = msg['x0'] / fig.ratio;\n", - " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", - " var x1 = msg['x1'] / fig.ratio;\n", - " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0,\n", - " 0,\n", - " fig.canvas.width / fig.ratio,\n", - " fig.canvas.height / fig.ratio\n", - " );\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", - " var cursor = msg['cursor'];\n", - " switch (cursor) {\n", - " case 0:\n", - " cursor = 'pointer';\n", - " break;\n", - " case 1:\n", - " cursor = 'default';\n", - " break;\n", - " case 2:\n", - " cursor = 'crosshair';\n", - " break;\n", - " case 3:\n", - " cursor = 'move';\n", - " break;\n", - " }\n", - " fig.rubberband_canvas.style.cursor = cursor;\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_message = function (fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", - " for (var key in msg) {\n", - " if (!(key in fig.buttons)) {\n", - " continue;\n", - " }\n", - " fig.buttons[key].disabled = !msg[key];\n", - " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", - " if (msg['mode'] === 'PAN') {\n", - " fig.buttons['Pan'].classList.add('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " } else if (msg['mode'] === 'ZOOM') {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.add('active');\n", - " } else {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message('ack', {});\n", - "};\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function (fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " evt.data.type = 'image/png';\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src\n", - " );\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " evt.data\n", - " );\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " } else if (\n", - " typeof evt.data === 'string' &&\n", - " evt.data.slice(0, 21) === 'data:image/png;base64'\n", - " ) {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig['handle_' + msg_type];\n", - " } catch (e) {\n", - " console.log(\n", - " \"No handler for the '\" + msg_type + \"' message type: \",\n", - " msg\n", - " );\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\n", - " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", - " e,\n", - " e.stack,\n", - " msg\n", - " );\n", - " }\n", - " }\n", - " };\n", - "};\n", - "\n", - "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function (e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e) {\n", - " e = window.event;\n", - " }\n", - " if (e.target) {\n", - " targ = e.target;\n", - " } else if (e.srcElement) {\n", - " targ = e.srcElement;\n", - " }\n", - " if (targ.nodeType === 3) {\n", - " // defeat Safari bug\n", - " targ = targ.parentNode;\n", - " }\n", - "\n", - " // pageX,Y are the mouse positions relative to the document\n", - " var boundingRect = targ.getBoundingClientRect();\n", - " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", - " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n", - "\n", - " return { x: x, y: y };\n", - "};\n", - "\n", - "/*\n", - " * return a copy of an object with only non-object keys\n", - " * we need this to avoid circular references\n", - " * http://stackoverflow.com/a/24161582/3208463\n", - " */\n", - "function simpleKeys(original) {\n", - " return Object.keys(original).reduce(function (obj, key) {\n", - " if (typeof original[key] !== 'object') {\n", - " obj[key] = original[key];\n", - " }\n", - " return obj;\n", - " }, {});\n", - "}\n", - "\n", - "mpl.figure.prototype.mouse_event = function (event, name) {\n", - " var canvas_pos = mpl.findpos(event);\n", - "\n", - " if (name === 'button_press') {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x * this.ratio;\n", - " var y = canvas_pos.y * this.ratio;\n", - "\n", - " this.send_message(name, {\n", - " x: x,\n", - " y: y,\n", - " button: event.button,\n", - " step: event.step,\n", - " guiEvent: simpleKeys(event),\n", - " });\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "};\n", - "\n", - "mpl.figure.prototype.key_event = function (event, name) {\n", - " // Prevent repeat events\n", - " if (name === 'key_press') {\n", - " if (event.which === this._key) {\n", - " return;\n", - " } else {\n", - " this._key = event.which;\n", - " }\n", - " }\n", - " if (name === 'key_release') {\n", - " this._key = null;\n", - " }\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.which !== 17) {\n", - " value += 'ctrl+';\n", - " }\n", - " if (event.altKey && event.which !== 18) {\n", - " value += 'alt+';\n", - " }\n", - " if (event.shiftKey && event.which !== 16) {\n", - " value += 'shift+';\n", - " }\n", - "\n", - " value += 'k';\n", - " value += event.which.toString();\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", - " if (name === 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message('toolbar_button', { name: name });\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "\n", - "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", - "// prettier-ignore\n", - "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", - "\n", - "mpl.default_extension = \"png\";/* global mpl */\n", - "\n", - "var comm_websocket_adapter = function (comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.close = function () {\n", - " comm.close();\n", - " };\n", - " ws.send = function (m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function (msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", - " ws.onmessage(msg['content']['data']);\n", - " });\n", - " return ws;\n", - "};\n", - "\n", - "mpl.mpl_figure_comm = function (comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = document.getElementById(id);\n", - " var ws_proxy = comm_websocket_adapter(comm);\n", - "\n", - " function ondownload(figure, _format) {\n", - " window.open(figure.canvas.toDataURL());\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element;\n", - " fig.cell_info = mpl.find_output_cell(\"
\");\n", - " if (!fig.cell_info) {\n", - " console.error('Failed to find cell for figure', id, fig);\n", - " return;\n", - " }\n", - " fig.cell_info[0].output_area.element.on(\n", - " 'cleared',\n", - " { fig: fig },\n", - " fig._remove_fig_handler\n", - " );\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function (fig, msg) {\n", - " var width = fig.canvas.width / fig.ratio;\n", - " fig.cell_info[0].output_area.element.off(\n", - " 'cleared',\n", - " fig._remove_fig_handler\n", - " );\n", - " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", - "\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable();\n", - " fig.parent_element.innerHTML =\n", - " '';\n", - " fig.close_ws(fig, msg);\n", - "};\n", - "\n", - "mpl.figure.prototype.close_ws = function (fig, msg) {\n", - " fig.send_message('closing', msg);\n", - " // fig.ws.close()\n", - "};\n", - "\n", - "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var width = this.canvas.width / this.ratio;\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] =\n", - " '';\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message('ack', {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () {\n", - " fig.push_to_output();\n", - " }, 1000);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'btn-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " var button;\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " continue;\n", - " }\n", - "\n", - " button = fig.buttons[name] = document.createElement('button');\n", - " button.classList = 'btn btn-default';\n", - " button.href = '#';\n", - " button.title = name;\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message pull-right';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = document.createElement('div');\n", - " buttongrp.classList = 'btn-group inline pull-right';\n", - " button = document.createElement('button');\n", - " button.classList = 'btn btn-mini btn-primary';\n", - " button.href = '#';\n", - " button.title = 'Stop Interaction';\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', function (_evt) {\n", - " fig.handle_close(fig, {});\n", - " });\n", - " button.addEventListener(\n", - " 'mouseover',\n", - " on_mouseover_closure('Stop Interaction')\n", - " );\n", - " buttongrp.appendChild(button);\n", - " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", - " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", - "};\n", - "\n", - "mpl.figure.prototype._remove_fig_handler = function (event) {\n", - " var fig = event.data.fig;\n", - " if (event.target !== this) {\n", - " // Ignore bubbled events from children.\n", - " return;\n", - " }\n", - " fig.close_ws(fig, {});\n", - "};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (el) {\n", - " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (el) {\n", - " // this is important to make the div 'focusable\n", - " el.setAttribute('tabindex', 0);\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " } else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", - " var manager = IPython.notebook.keyboard_manager;\n", - " if (!manager) {\n", - " manager = IPython.keyboard_manager;\n", - " }\n", - "\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which === 13) {\n", - " this.canvas_div.blur();\n", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " fig.ondownload(fig, null);\n", - "};\n", - "\n", - "mpl.find_output_cell = function (html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i = 0; i < ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code') {\n", - " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] === html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "};\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel !== null) {\n", - " IPython.notebook.kernel.comm_manager.register_target(\n", - " 'matplotlib',\n", - " mpl.mpl_figure_comm\n", - " );\n", - "}\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "data": { - "text/html": [ - "" - ], + "image/png": "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", "text/plain": [ - "" + "
" ] }, "metadata": {}, "output_type": "display_data" }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:switch to gpu\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\r", - "pcPIE: 0%| | 0/70 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 11 \n", - "error: 52.6 \n", - "estimated linear overlap: 7.7 % \n", - "estimated area overlap: 49.3 % \n", - "pcPIE: 17%|████████████▊ | 12/70 [00:05<00:23, 2.45it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 12 \n", - "error: 52.1 \n", - "estimated linear overlap: 5.0 % \n", - "estimated area overlap: 50.1 % \n", - "pcPIE: 19%|█████████████▉ | 13/70 [00:05<00:22, 2.48it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 13 \n", - "error: 51.3 \n", - "estimated linear overlap: 1.8 % \n", - "estimated area overlap: 50.7 % \n", - "pcPIE: 20%|███████████████ | 14/70 [00:06<00:22, 2.51it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 14 \n", - "error: 51.3 \n", - "estimated linear overlap: 1.3 % \n", - "estimated area overlap: 47.4 % \n", - "pcPIE: 21%|████████████████ | 15/70 [00:06<00:22, 2.47it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 15 \n", - "error: 51.1 \n", - "estimated linear overlap: 3.1 % \n", - "estimated area overlap: 46.4 % \n", - "pcPIE: 23%|█████████████████▏ | 16/70 [00:06<00:22, 2.40it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 16 \n", - "error: 50.2 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 48.6 % \n", - "pcPIE: 24%|██████████████████▏ | 17/70 [00:07<00:22, 2.40it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 17 \n", - "error: 50.1 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 49.7 % \n", - "pcPIE: 26%|███████████████████▎ | 18/70 [00:07<00:21, 2.40it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 18 \n", - "error: 50.4 \n", - "estimated linear overlap: 2.0 % \n", - "estimated area overlap: 45.4 % \n", - "pcPIE: 27%|████████████████████▎ | 19/70 [00:08<00:21, 2.37it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 19 \n", - "error: 49.9 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 52.1 % \n", - "pcPIE: 29%|█████████████████████▍ | 20/70 [00:08<00:22, 2.24it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 20 \n", - "error: 49.6 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 50.4 % \n", - "pcPIE: 30%|██████████████████████▌ | 21/70 [00:09<00:22, 2.21it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "d:\\du\\ptylab\\PtyLab\\Engines\\BaseEngine.py:1237: ComplexWarning: Casting complex values to real discards the imaginary part\n", - " cc[shifts] = xp.squeeze(\n", - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 21 \n", - "error: 49.4 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 44.9 % \n", - "pcPIE: 31%|███████████████████████▌ | 22/70 [00:11<00:41, 1.15it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 22 \n", - "error: 49.7 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 50.3 % \n", - "pcPIE: 33%|████████████████████████▋ | 23/70 [00:11<00:38, 1.23it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 23 \n", - "error: 48.7 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 46.4 % \n", - "pcPIE: 34%|█████████████████████████▋ | 24/70 [00:12<00:35, 1.31it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 24 \n", - "error: 48.6 \n", - "estimated linear overlap: 2.0 % \n", - "estimated area overlap: 45.8 % \n", - "pcPIE: 36%|██████████████████████████▊ | 25/70 [00:13<00:32, 1.37it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 25 \n", - "error: 48.1 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 47.0 % \n", - "pcPIE: 37%|███████████████████████████▊ | 26/70 [00:13<00:31, 1.40it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 26 \n", - "error: 48.1 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 44.1 % \n", - "pcPIE: 39%|████████████████████████████▉ | 27/70 [00:14<00:30, 1.43it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 27 \n", - "error: 47.9 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 46.7 % \n", - "pcPIE: 40%|██████████████████████████████ | 28/70 [00:15<00:29, 1.45it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 28 \n", - "error: 47.5 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 42.2 % \n", - "pcPIE: 41%|███████████████████████████████ | 29/70 [00:15<00:27, 1.48it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 29 \n", - "error: 47.6 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 43.7 % \n", - "pcPIE: 43%|████████████████████████████████▏ | 30/70 [00:16<00:26, 1.50it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 30 \n", - "error: 46.6 \n", - "estimated linear overlap: 0.7 % \n", - "estimated area overlap: 48.6 % \n", - "pcPIE: 44%|█████████████████████████████████▏ | 31/70 [00:17<00:25, 1.50it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 31 \n", - "error: 46.9 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 44.6 % \n", - "pcPIE: 46%|██████████████████████████████████▎ | 32/70 [00:17<00:25, 1.51it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 32 \n", - "error: 46.7 \n", - "estimated linear overlap: 2.0 % \n", - "estimated area overlap: 45.9 % \n", - "pcPIE: 47%|███████████████████████████████████▎ | 33/70 [00:18<00:24, 1.51it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 33 \n", - "error: 46.5 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 46.5 % \n", - "pcPIE: 49%|████████████████████████████████████▍ | 34/70 [00:19<00:24, 1.49it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 34 \n", - "error: 46.0 \n", - "estimated linear overlap: 2.5 % \n", - "estimated area overlap: 48.5 % \n", - "pcPIE: 50%|█████████████████████████████████████▌ | 35/70 [00:19<00:23, 1.48it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 35 \n", - "error: 46.5 \n", - "estimated linear overlap: 3.6 % \n", - "estimated area overlap: 48.5 % \n", - "pcPIE: 51%|██████████████████████████████████████▌ | 36/70 [00:20<00:22, 1.49it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 36 \n", - "error: 46.4 \n", - "estimated linear overlap: 0.9 % \n", - "estimated area overlap: 43.5 % \n", - "pcPIE: 53%|███████████████████████████████████████▋ | 37/70 [00:21<00:22, 1.49it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 37 \n", - "error: 45.9 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 47.2 % \n", - "pcPIE: 54%|████████████████████████████████████████▋ | 38/70 [00:21<00:21, 1.49it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 38 \n", - "error: 45.4 \n", - "estimated linear overlap: 2.9 % \n", - "estimated area overlap: 48.5 % \n", - "pcPIE: 56%|█████████████████████████████████████████▊ | 39/70 [00:22<00:20, 1.50it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 39 \n", - "error: 46.8 \n", - "estimated linear overlap: 8.2 % \n", - "estimated area overlap: 52.1 % \n", - "pcPIE: 57%|██████████████████████████████████████████▊ | 40/70 [00:23<00:20, 1.50it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 40 \n", - "error: 46.3 \n", - "estimated linear overlap: 0.4 % \n", - "estimated area overlap: 48.2 % \n", - "pcPIE: 59%|███████████████████████████████████████████▉ | 41/70 [00:23<00:19, 1.49it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 41 \n", - "error: 46.0 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 42.5 % \n", - "pcPIE: 60%|█████████████████████████████████████████████ | 42/70 [00:24<00:18, 1.48it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 42 \n", - "error: 45.8 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 44.0 % \n", - "pcPIE: 61%|██████████████████████████████████████████████ | 43/70 [00:25<00:18, 1.49it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 43 \n", - "error: 46.0 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 45.5 % \n", - "pcPIE: 63%|███████████████████████████████████████████████▏ | 44/70 [00:25<00:17, 1.49it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 44 \n", - "error: 45.5 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 44.5 % \n", - "pcPIE: 64%|████████████████████████████████████████████████▏ | 45/70 [00:26<00:16, 1.50it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 45 \n", - "error: 45.9 \n", - "estimated linear overlap: 5.2 % \n", - "estimated area overlap: 46.9 % \n", - "pcPIE: 66%|█████████████████████████████████████████████████▎ | 46/70 [00:27<00:15, 1.51it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 46 \n", - "error: 46.0 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 48.2 % \n", - "pcPIE: 67%|██████████████████████████████████████████████████▎ | 47/70 [00:27<00:15, 1.52it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 47 \n", - "error: 45.4 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 46.3 % \n", - "pcPIE: 69%|███████████████████████████████████████████████████▍ | 48/70 [00:28<00:14, 1.52it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 48 \n", - "error: 45.9 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 45.0 % \n", - "pcPIE: 70%|████████████████████████████████████████████████████▌ | 49/70 [00:29<00:14, 1.50it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 49 \n", - "error: 45.2 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 43.0 % \n", - "pcPIE: 71%|█████████████████████████████████████████████████████▌ | 50/70 [00:29<00:13, 1.50it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 50 \n", - "error: 46.2 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 31.2 % \n", - "pcPIE: 73%|██████████████████████████████████████████████████████▋ | 51/70 [00:30<00:12, 1.51it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 51 \n", - "error: 45.4 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 31.7 % \n", - "pcPIE: 74%|███████████████████████████████████████████████████████▋ | 52/70 [00:30<00:11, 1.52it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 52 \n", - "error: 45.8 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 33.7 % \n", - "pcPIE: 76%|████████████████████████████████████████████████████████▊ | 53/70 [00:31<00:11, 1.52it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 53 \n", - "error: 45.8 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 31.6 % \n", - "pcPIE: 77%|█████████████████████████████████████████████████████████▊ | 54/70 [00:32<00:11, 1.45it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 54 \n", - "error: 45.7 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 36.4 % \n", - "pcPIE: 79%|██████████████████████████████████████████████████████████▉ | 55/70 [00:33<00:10, 1.40it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 55 \n", - "error: 45.1 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 38.8 % \n", - "pcPIE: 80%|████████████████████████████████████████████████████████████ | 56/70 [00:33<00:09, 1.40it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 56 \n", - "error: 45.5 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 38.5 % \n", - "pcPIE: 81%|█████████████████████████████████████████████████████████████ | 57/70 [00:34<00:09, 1.41it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 57 \n", - "error: 45.0 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 37.7 % \n", - "pcPIE: 83%|██████████████████████████████████████████████████████████████▏ | 58/70 [00:35<00:08, 1.44it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 58 \n", - "error: 45.2 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 37.7 % \n", - "pcPIE: 84%|███████████████████████████████████████████████████████████████▏ | 59/70 [00:35<00:07, 1.47it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 59 \n", - "error: 45.1 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 33.7 % \n", - "pcPIE: 86%|████████████████████████████████████████████████████████████████▎ | 60/70 [00:36<00:06, 1.49it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 60 \n", - "error: 45.7 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 34.7 % \n", - "pcPIE: 87%|█████████████████████████████████████████████████████████████████▎ | 61/70 [00:37<00:05, 1.50it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 61 \n", - "error: 45.2 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 39.6 % \n", - "pcPIE: 89%|██████████████████████████████████████████████████████████████████▍ | 62/70 [00:37<00:05, 1.51it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 62 \n", - "error: 44.9 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 29.6 % \n", - "pcPIE: 90%|███████████████████████████████████████████████████████████████████▌ | 63/70 [00:38<00:04, 1.51it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 63 \n", - "error: 44.9 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 28.3 % \n", - "pcPIE: 91%|████████████████████████████████████████████████████████████████████▌ | 64/70 [00:39<00:04, 1.48it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 64 \n", - "error: 44.2 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 28.4 % \n", - "pcPIE: 93%|█████████████████████████████████████████████████████████████████████▋ | 65/70 [00:39<00:03, 1.50it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 65 \n", - "error: 45.2 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 30.1 % \n", - "pcPIE: 94%|██████████████████████████████████████████████████████████████████████▋ | 66/70 [00:40<00:02, 1.51it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 66 \n", - "error: 45.0 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 30.6 % \n", - "pcPIE: 96%|███████████████████████████████████████████████████████████████████████▊ | 67/70 [00:41<00:01, 1.52it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 67 \n", - "error: 44.7 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 30.2 % \n", - "pcPIE: 97%|████████████████████████████████████████████████████████████████████████▊ | 68/70 [00:41<00:01, 1.52it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 68 \n", - "error: 44.5 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 33.5 % \n", - "pcPIE: 99%|█████████████████████████████████████████████████████████████████████████▉ | 69/70 [00:42<00:00, 1.51it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:Doing probe com stabilization\n", - "INFO:pcPIE:Updating positions\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 69 \n", - "error: 44.2 \n", - "estimated linear overlap: 0.0 % \n", - "estimated area overlap: 31.8 % \n", - "pcPIE: 100%|███████████████████████████████████████████████████████████████████████████| 70/70 [00:43<00:00, 1.62it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pcPIE:switch to cpu\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "#reset object and probe to initial guesses\n", - "reconstruction.initialProbe = 'circ'\n", - "exampleData.entrancePupilDiameter = reconstruction.Np / 3 * reconstruction.dxp # initial estimate of beam diameter\n", - "reconstruction.initialObject = 'ones'\n", - "# initialize probe and object and related params\n", - "reconstruction.initializeObjectProbe()\n", - "\n", - "# customize initial probe quadratic phase\n", - "reconstruction.probe = reconstruction.probe*np.exp(1.j*2*np.pi/reconstruction.wavelength *\n", - " (reconstruction.Xp**2+reconstruction.Yp**2)/(2*6e-3))\n", - "reconstruction.error = []\n", - "params.positionCorrectionSwitch = True\n", - "\n", - "engine_pcPIE = Engines.pcPIE(reconstruction, exampleData, params,monitor)\n", - "engine_pcPIE.numIterations = 70\n", - "engine_pcPIE.reconstruct()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The estimated scan grid (obtained from pcPIE) is shown by the yellow points in the following plot." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "/* global mpl */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function () {\n", - " if (typeof WebSocket !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof MozWebSocket !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert(\n", - " 'Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.'\n", - " );\n", - " }\n", - "};\n", - "\n", - "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = this.ws.binaryType !== undefined;\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById('mpl-warnings');\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent =\n", - " 'This browser does not support binary websocket messages. ' +\n", - " 'Performance may be slow.';\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = document.createElement('div');\n", - " this.root.setAttribute('style', 'display: inline-block');\n", - " this._root_extra_style(this.root);\n", - "\n", - " parent_element.appendChild(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message('supports_binary', { value: fig.supports_binary });\n", - " fig.send_message('send_image_mode', {});\n", - " if (fig.ratio !== 1) {\n", - " fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });\n", - " }\n", - " fig.send_message('refresh', {});\n", - " };\n", - "\n", - " this.imageObj.onload = function () {\n", - " if (fig.image_mode === 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function () {\n", - " fig.ws.close();\n", - " };\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "};\n", - "\n", - "mpl.figure.prototype._init_header = function () {\n", - " var titlebar = document.createElement('div');\n", - " titlebar.classList =\n", - " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", - " var titletext = document.createElement('div');\n", - " titletext.classList = 'ui-dialog-title';\n", - " titletext.setAttribute(\n", - " 'style',\n", - " 'width: 100%; text-align: center; padding: 3px;'\n", - " );\n", - " titlebar.appendChild(titletext);\n", - " this.root.appendChild(titlebar);\n", - " this.header = titletext;\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._init_canvas = function () {\n", - " var fig = this;\n", - "\n", - " var canvas_div = (this.canvas_div = document.createElement('div'));\n", - " canvas_div.setAttribute(\n", - " 'style',\n", - " 'border: 1px solid #ddd;' +\n", - " 'box-sizing: content-box;' +\n", - " 'clear: both;' +\n", - " 'min-height: 1px;' +\n", - " 'min-width: 1px;' +\n", - " 'outline: 0;' +\n", - " 'overflow: hidden;' +\n", - " 'position: relative;' +\n", - " 'resize: both;'\n", - " );\n", - "\n", - " function on_keyboard_event_closure(name) {\n", - " return function (event) {\n", - " return fig.key_event(event, name);\n", - " };\n", - " }\n", - "\n", - " canvas_div.addEventListener(\n", - " 'keydown',\n", - " on_keyboard_event_closure('key_press')\n", - " );\n", - " canvas_div.addEventListener(\n", - " 'keyup',\n", - " on_keyboard_event_closure('key_release')\n", - " );\n", - "\n", - " this._canvas_extra_style(canvas_div);\n", - " this.root.appendChild(canvas_div);\n", - "\n", - " var canvas = (this.canvas = document.createElement('canvas'));\n", - " canvas.classList.add('mpl-canvas');\n", - " canvas.setAttribute('style', 'box-sizing: content-box;');\n", - "\n", - " this.context = canvas.getContext('2d');\n", - "\n", - " var backingStore =\n", - " this.context.backingStorePixelRatio ||\n", - " this.context.webkitBackingStorePixelRatio ||\n", - " this.context.mozBackingStorePixelRatio ||\n", - " this.context.msBackingStorePixelRatio ||\n", - " this.context.oBackingStorePixelRatio ||\n", - " this.context.backingStorePixelRatio ||\n", - " 1;\n", - "\n", - " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", - " 'canvas'\n", - " ));\n", - " rubberband_canvas.setAttribute(\n", - " 'style',\n", - " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", - " );\n", - "\n", - " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", - " if (this.ResizeObserver === undefined) {\n", - " if (window.ResizeObserver !== undefined) {\n", - " this.ResizeObserver = window.ResizeObserver;\n", - " } else {\n", - " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", - " this.ResizeObserver = obs.ResizeObserver;\n", - " }\n", - " }\n", - "\n", - " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", - " var nentries = entries.length;\n", - " for (var i = 0; i < nentries; i++) {\n", - " var entry = entries[i];\n", - " var width, height;\n", - " if (entry.contentBoxSize) {\n", - " if (entry.contentBoxSize instanceof Array) {\n", - " // Chrome 84 implements new version of spec.\n", - " width = entry.contentBoxSize[0].inlineSize;\n", - " height = entry.contentBoxSize[0].blockSize;\n", - " } else {\n", - " // Firefox implements old version of spec.\n", - " width = entry.contentBoxSize.inlineSize;\n", - " height = entry.contentBoxSize.blockSize;\n", - " }\n", - " } else {\n", - " // Chrome <84 implements even older version of spec.\n", - " width = entry.contentRect.width;\n", - " height = entry.contentRect.height;\n", - " }\n", - "\n", - " // Keep the size of the canvas and rubber band canvas in sync with\n", - " // the canvas container.\n", - " if (entry.devicePixelContentBoxSize) {\n", - " // Chrome 84 implements new version of spec.\n", - " canvas.setAttribute(\n", - " 'width',\n", - " entry.devicePixelContentBoxSize[0].inlineSize\n", - " );\n", - " canvas.setAttribute(\n", - " 'height',\n", - " entry.devicePixelContentBoxSize[0].blockSize\n", - " );\n", - " } else {\n", - " canvas.setAttribute('width', width * fig.ratio);\n", - " canvas.setAttribute('height', height * fig.ratio);\n", - " }\n", - " canvas.setAttribute(\n", - " 'style',\n", - " 'width: ' + width + 'px; height: ' + height + 'px;'\n", - " );\n", - "\n", - " rubberband_canvas.setAttribute('width', width);\n", - " rubberband_canvas.setAttribute('height', height);\n", - "\n", - " // And update the size in Python. We ignore the initial 0/0 size\n", - " // that occurs as the element is placed into the DOM, which should\n", - " // otherwise not happen due to the minimum size styling.\n", - " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", - " fig.request_resize(width, height);\n", - " }\n", - " }\n", - " });\n", - " this.resizeObserverInstance.observe(canvas_div);\n", - "\n", - " function on_mouse_event_closure(name) {\n", - " return function (event) {\n", - " return fig.mouse_event(event, name);\n", - " };\n", - " }\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mousedown',\n", - " on_mouse_event_closure('button_press')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseup',\n", - " on_mouse_event_closure('button_release')\n", - " );\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband_canvas.addEventListener(\n", - " 'mousemove',\n", - " on_mouse_event_closure('motion_notify')\n", - " );\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseenter',\n", - " on_mouse_event_closure('figure_enter')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseleave',\n", - " on_mouse_event_closure('figure_leave')\n", - " );\n", - "\n", - " canvas_div.addEventListener('wheel', function (event) {\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " on_mouse_event_closure('scroll')(event);\n", - " });\n", - "\n", - " canvas_div.appendChild(canvas);\n", - " canvas_div.appendChild(rubberband_canvas);\n", - "\n", - " this.rubberband_context = rubberband_canvas.getContext('2d');\n", - " this.rubberband_context.strokeStyle = '#000000';\n", - "\n", - " this._resize_canvas = function (width, height, forward) {\n", - " if (forward) {\n", - " canvas_div.style.width = width + 'px';\n", - " canvas_div.style.height = height + 'px';\n", - " }\n", - " };\n", - "\n", - " // Disable right mouse context menu.\n", - " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", - " event.preventDefault();\n", - " return false;\n", - " });\n", - "\n", - " function set_focus() {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'mpl-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " continue;\n", - " }\n", - "\n", - " var button = (fig.buttons[name] = document.createElement('button'));\n", - " button.classList = 'mpl-widget';\n", - " button.setAttribute('role', 'button');\n", - " button.setAttribute('aria-disabled', 'false');\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - "\n", - " var icon_img = document.createElement('img');\n", - " icon_img.src = '_images/' + image + '.png';\n", - " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", - " icon_img.alt = tooltip;\n", - " button.appendChild(icon_img);\n", - "\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " var fmt_picker = document.createElement('select');\n", - " fmt_picker.classList = 'mpl-widget';\n", - " toolbar.appendChild(fmt_picker);\n", - " this.format_dropdown = fmt_picker;\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = document.createElement('option');\n", - " option.selected = fmt === mpl.default_extension;\n", - " option.innerHTML = fmt;\n", - " fmt_picker.appendChild(option);\n", - " }\n", - "\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "};\n", - "\n", - "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", - "};\n", - "\n", - "mpl.figure.prototype.send_message = function (type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "};\n", - "\n", - "mpl.figure.prototype.send_draw_message = function () {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1], msg['forward']);\n", - " fig.send_message('refresh', {});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", - " var x0 = msg['x0'] / fig.ratio;\n", - " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", - " var x1 = msg['x1'] / fig.ratio;\n", - " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0,\n", - " 0,\n", - " fig.canvas.width / fig.ratio,\n", - " fig.canvas.height / fig.ratio\n", - " );\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", - " var cursor = msg['cursor'];\n", - " switch (cursor) {\n", - " case 0:\n", - " cursor = 'pointer';\n", - " break;\n", - " case 1:\n", - " cursor = 'default';\n", - " break;\n", - " case 2:\n", - " cursor = 'crosshair';\n", - " break;\n", - " case 3:\n", - " cursor = 'move';\n", - " break;\n", - " }\n", - " fig.rubberband_canvas.style.cursor = cursor;\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_message = function (fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", - " for (var key in msg) {\n", - " if (!(key in fig.buttons)) {\n", - " continue;\n", - " }\n", - " fig.buttons[key].disabled = !msg[key];\n", - " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", - " if (msg['mode'] === 'PAN') {\n", - " fig.buttons['Pan'].classList.add('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " } else if (msg['mode'] === 'ZOOM') {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.add('active');\n", - " } else {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message('ack', {});\n", - "};\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function (fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " evt.data.type = 'image/png';\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src\n", - " );\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " evt.data\n", - " );\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " } else if (\n", - " typeof evt.data === 'string' &&\n", - " evt.data.slice(0, 21) === 'data:image/png;base64'\n", - " ) {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig['handle_' + msg_type];\n", - " } catch (e) {\n", - " console.log(\n", - " \"No handler for the '\" + msg_type + \"' message type: \",\n", - " msg\n", - " );\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\n", - " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", - " e,\n", - " e.stack,\n", - " msg\n", - " );\n", - " }\n", - " }\n", - " };\n", - "};\n", - "\n", - "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function (e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e) {\n", - " e = window.event;\n", - " }\n", - " if (e.target) {\n", - " targ = e.target;\n", - " } else if (e.srcElement) {\n", - " targ = e.srcElement;\n", - " }\n", - " if (targ.nodeType === 3) {\n", - " // defeat Safari bug\n", - " targ = targ.parentNode;\n", - " }\n", - "\n", - " // pageX,Y are the mouse positions relative to the document\n", - " var boundingRect = targ.getBoundingClientRect();\n", - " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", - " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n", - "\n", - " return { x: x, y: y };\n", - "};\n", - "\n", - "/*\n", - " * return a copy of an object with only non-object keys\n", - " * we need this to avoid circular references\n", - " * http://stackoverflow.com/a/24161582/3208463\n", - " */\n", - "function simpleKeys(original) {\n", - " return Object.keys(original).reduce(function (obj, key) {\n", - " if (typeof original[key] !== 'object') {\n", - " obj[key] = original[key];\n", - " }\n", - " return obj;\n", - " }, {});\n", - "}\n", - "\n", - "mpl.figure.prototype.mouse_event = function (event, name) {\n", - " var canvas_pos = mpl.findpos(event);\n", - "\n", - " if (name === 'button_press') {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x * this.ratio;\n", - " var y = canvas_pos.y * this.ratio;\n", - "\n", - " this.send_message(name, {\n", - " x: x,\n", - " y: y,\n", - " button: event.button,\n", - " step: event.step,\n", - " guiEvent: simpleKeys(event),\n", - " });\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "};\n", - "\n", - "mpl.figure.prototype.key_event = function (event, name) {\n", - " // Prevent repeat events\n", - " if (name === 'key_press') {\n", - " if (event.which === this._key) {\n", - " return;\n", - " } else {\n", - " this._key = event.which;\n", - " }\n", - " }\n", - " if (name === 'key_release') {\n", - " this._key = null;\n", - " }\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.which !== 17) {\n", - " value += 'ctrl+';\n", - " }\n", - " if (event.altKey && event.which !== 18) {\n", - " value += 'alt+';\n", - " }\n", - " if (event.shiftKey && event.which !== 16) {\n", - " value += 'shift+';\n", - " }\n", - "\n", - " value += 'k';\n", - " value += event.which.toString();\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", - " if (name === 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message('toolbar_button', { name: name });\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "\n", - "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", - "// prettier-ignore\n", - "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", - "\n", - "mpl.default_extension = \"png\";/* global mpl */\n", - "\n", - "var comm_websocket_adapter = function (comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.close = function () {\n", - " comm.close();\n", - " };\n", - " ws.send = function (m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function (msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", - " ws.onmessage(msg['content']['data']);\n", - " });\n", - " return ws;\n", - "};\n", - "\n", - "mpl.mpl_figure_comm = function (comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = document.getElementById(id);\n", - " var ws_proxy = comm_websocket_adapter(comm);\n", - "\n", - " function ondownload(figure, _format) {\n", - " window.open(figure.canvas.toDataURL());\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element;\n", - " fig.cell_info = mpl.find_output_cell(\"
\");\n", - " if (!fig.cell_info) {\n", - " console.error('Failed to find cell for figure', id, fig);\n", - " return;\n", - " }\n", - " fig.cell_info[0].output_area.element.on(\n", - " 'cleared',\n", - " { fig: fig },\n", - " fig._remove_fig_handler\n", - " );\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function (fig, msg) {\n", - " var width = fig.canvas.width / fig.ratio;\n", - " fig.cell_info[0].output_area.element.off(\n", - " 'cleared',\n", - " fig._remove_fig_handler\n", - " );\n", - " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", - "\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable();\n", - " fig.parent_element.innerHTML =\n", - " '';\n", - " fig.close_ws(fig, msg);\n", - "};\n", - "\n", - "mpl.figure.prototype.close_ws = function (fig, msg) {\n", - " fig.send_message('closing', msg);\n", - " // fig.ws.close()\n", - "};\n", - "\n", - "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var width = this.canvas.width / this.ratio;\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] =\n", - " '';\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message('ack', {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () {\n", - " fig.push_to_output();\n", - " }, 1000);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'btn-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " var button;\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " continue;\n", - " }\n", - "\n", - " button = fig.buttons[name] = document.createElement('button');\n", - " button.classList = 'btn btn-default';\n", - " button.href = '#';\n", - " button.title = name;\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message pull-right';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = document.createElement('div');\n", - " buttongrp.classList = 'btn-group inline pull-right';\n", - " button = document.createElement('button');\n", - " button.classList = 'btn btn-mini btn-primary';\n", - " button.href = '#';\n", - " button.title = 'Stop Interaction';\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', function (_evt) {\n", - " fig.handle_close(fig, {});\n", - " });\n", - " button.addEventListener(\n", - " 'mouseover',\n", - " on_mouseover_closure('Stop Interaction')\n", - " );\n", - " buttongrp.appendChild(button);\n", - " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", - " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", - "};\n", - "\n", - "mpl.figure.prototype._remove_fig_handler = function (event) {\n", - " var fig = event.data.fig;\n", - " if (event.target !== this) {\n", - " // Ignore bubbled events from children.\n", - " return;\n", - " }\n", - " fig.close_ws(fig, {});\n", - "};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (el) {\n", - " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (el) {\n", - " // this is important to make the div 'focusable\n", - " el.setAttribute('tabindex', 0);\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " } else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", - " var manager = IPython.notebook.keyboard_manager;\n", - " if (!manager) {\n", - " manager = IPython.keyboard_manager;\n", - " }\n", - "\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which === 13) {\n", - " this.canvas_div.blur();\n", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " fig.ondownload(fig, null);\n", - "};\n", - "\n", - "mpl.find_output_cell = function (html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i = 0; i < ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code') {\n", - " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] === html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "};\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel !== null) {\n", - " IPython.notebook.kernel.comm_manager.register_target(\n", - " 'matplotlib',\n", - " mpl.mpl_figure_comm\n", - " );\n", - "}\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# reset object and probe to initial guesses\n", + "reconstruction.initialProbe = \"circ\"\n", + "exampleData.entrancePupilDiameter = (\n", + " reconstruction.Np / 3 * reconstruction.dxp\n", + ") # initial estimate of beam diameter\n", + "reconstruction.initialObject = \"ones\"\n", + "# initialize probe and object and related params\n", + "reconstruction.initializeObjectProbe()\n", + "\n", + "# customize initial probe quadratic phase\n", + "reconstruction.probe = reconstruction.probe * np.exp(\n", + " 1.0j\n", + " * 2\n", + " * np.pi\n", + " / reconstruction.wavelength\n", + " * (reconstruction.Xp**2 + reconstruction.Yp**2)\n", + " / (2 * 6e-3)\n", + ")\n", + "reconstruction.error = []\n", + "params.positionCorrectionSwitch = True\n", + "\n", + "engine_pcPIE = Engines.pcPIE(reconstruction, exampleData, params, monitor)\n", + "engine_pcPIE.numIterations = 70\n", + "engine_pcPIE.reconstruct()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The estimated scan grid (obtained from pcPIE) is shown by the yellow points in the following plot." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ { "data": { - "text/html": [ - "" - ], + "image/png": "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", "text/plain": [ - "" + "
" ] }, "metadata": {}, @@ -5675,15 +528,22 @@ } ], "source": [ - "#compare original encoder and result from pcPIE\n", + "# compare original encoder and result from pcPIE\n", "figure, ax = plt.subplots(1, 1, num=113, squeeze=True, clear=True, figsize=(5, 5))\n", - "ax.set_title('Original and corrected after perturbation scan grid positions')\n", - "ax.set_xlabel('(um)')\n", - "ax.set_ylabel('(um)')\n", - "line1, = plt.plot(encoder0[:, 1] * 1e6,\n", - " encoder0[:, 0] * 1e6, 'bo', label='correct')\n", - "line2, = plt.plot((reconstruction.positions[:, 1] - reconstruction.No // 2 + reconstruction.Np // 2) * reconstruction.dxo * 1e6,\n", - " (reconstruction.positions[:, 0] - reconstruction.No // 2 + reconstruction.Np // 2) * reconstruction.dxo * 1e6, 'yo', label='estimated')\n", + "ax.set_title(\"Original and corrected after perturbation scan grid positions\")\n", + "ax.set_xlabel(\"(um)\")\n", + "ax.set_ylabel(\"(um)\")\n", + "(line1,) = plt.plot(encoder0[:, 1] * 1e6, encoder0[:, 0] * 1e6, \"bo\", label=\"correct\")\n", + "(line2,) = plt.plot(\n", + " (reconstruction.positions[:, 1] - reconstruction.No // 2 + reconstruction.Np // 2)\n", + " * reconstruction.dxo\n", + " * 1e6,\n", + " (reconstruction.positions[:, 0] - reconstruction.No // 2 + reconstruction.Np // 2)\n", + " * reconstruction.dxo\n", + " * 1e6,\n", + " \"yo\",\n", + " label=\"estimated\",\n", + ")\n", "plt.legend(handles=[line1, line2])\n", "plt.tight_layout()\n", "plt.show(block=False)" @@ -5698,25 +558,18 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "# now save the data\n", "# reconstruction.saveResults('simulation_ePIE_comparison_pcPIE.hdf5')" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "ptylab", "language": "python", "name": "python3" }, @@ -5730,7 +583,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.13.12" } }, "nbformat": 4, diff --git a/jupyter_tutorials/jupyter_tutorials_tutorial_interferometricIntensityConstraint.ipynb b/jupyter_tutorials/jupyter_tutorials_tutorial_interferometricIntensityConstraint.ipynb index bbe5dec1..b8ef6e5d 100644 --- a/jupyter_tutorials/jupyter_tutorials_tutorial_interferometricIntensityConstraint.ipynb +++ b/jupyter_tutorials/jupyter_tutorials_tutorial_interferometricIntensityConstraint.ipynb @@ -4,19 +4,29 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Interferometric intensity constraint\n", - " - This tutorial shows a reconstruction with a reflection dataset measusred with a positive USAF resolution target at 700 nm. The USAF target contains effectively two layers: the front and the back sides of the glass substrate. This tutorial shows by adjusting the forward model in ptychography which takes into account the reflection from the plane glass side, the reconstruction results can be improved significantly. \n", - " - This result has been published in the thesis: 'DU, Mengqi. Computational Depth-resolved Imaging and Metrology. 2021. PhD Thesis'. The preprocessed dataset can be downloaded from Figshare: https://figshare.com/articles/dataset/USAF_speckle_bin4_hdf5/14912262\n", - " - A kind suggestion: check out general tutorials for CPM (conventional ptychographic microscopy) before diving into this one." + "# 06 – CPM Interferometric Intensity Constraint\n", + "\n", + "This tutorial demonstrates an extended forward model for reflection ptychography that accounts for interferometric contributions from a reference plane. It shows how the modified intensity constraint improves reconstruction of multi-layer samples.\n", + "\n", + "**What you'll learn:**\n", + "\n", + "- How to apply an interferometric intensity constraint in the forward model\n", + "- How to reconstruct a two-layer reflection dataset (USAF target at 700 nm)\n", + "- How the extended model compares to the standard intensity constraint\n", + "\n", + "!!! note \"Dataset\"\n", + " The dataset (`USAF_speckle_bin4.hdf5`) is downloaded automatically into the `example_data/` folder at the project root the first time you run the notebook. If the file already exists it is not re-downloaded.\n", + "\n", + "!!! tip \"Prerequisites\"\n", + " Complete [05 – CPM Reflection](tutorial_reflectionPtychography.ipynb) before this tutorial." ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ - "%matplotlib notebook\n", "import matplotlib\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", @@ -26,7 +36,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -44,76 +54,129 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Step 1: Download the preprocessed data from figshare: https://figshare.com/articles/dataset/USAF_speckle_bin4_hdf5/14912262" + "The dataset (`USAF_speckle_bin4.hdf5`) is downloaded automatically into the `example_data/` folder at the project root the first time you run the next cell. If the file already exists it is not re-downloaded." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 33, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "USAF_speckle_bin4.hdf5 found, skipping download.\n" + ] + } + ], "source": [ - "# set your data folder as fileFolder \n", - "fileFolder = Path(r\"D:\\Du\\FigshareData\")\n", + "from PtyLab.io import getExampleDataFolder\n", + "import urllib.request\n", "\n", "fileName = \"USAF_speckle_bin4.hdf5\"\n", - "filePath = Path.joinpath(fileFolder,fileName)" + "filePath = getExampleDataFolder() / fileName\n", + "\n", + "if not filePath.exists():\n", + " print(f\"Downloading {fileName}...\")\n", + " urllib.request.urlretrieve(\n", + " \"https://ndownloader.figshare.com/files/28713885\",\n", + " filePath,\n", + " )\n", + " print(\"Download complete.\")\n", + "else:\n", + " print(f\"{fileName} found, skipping download.\")" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\"Unable to open object (object 'orientation' doesn't exist)\"\n", - "Min max ptychogram: 0.0, 16202.2021484375\n", - "Min max ptychogram: 0.0, 4.209600850219908\n", - "0.0 4.209600850219908\n" + "Found encoder with shape (102, 2)\n", + "Min max ptychogram: 0.9099568724632263, 16222.2021484375\n", + "Min max ptychogram: 0.2810235917568207, 4.210136890411377\n", + "0.2810236 4.210137\n" ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fc5c83cc789d41bfbed39c46707993e0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(IntSlider(value=0, description='Frame', max=101), Output()))" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "experimentalData = ExperimentalData(filePath, operationMode='CPM')\n", + "experimentalData = ExperimentalData(filePath, operationMode=\"CPM\")\n", + "experimentalData.showPtychogram()" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ "experimentalData.zo = 25.02e-3\n", - "experimentalData.entrancePupilDiameter = 0.4e-3 #exampleData.Np / 3 * exampleData.dxp # initial estimate of beam size\n", + "experimentalData.entrancePupilDiameter = (\n", + " 0.4e-3 # exampleData.Np / 3 * exampleData.dxp # initial estimate of beam size\n", + ")\n", "backgroundOffset = 20\n", - "experimentalData.ptychogram = posit(experimentalData.ptychogram-backgroundOffset)\n", - "experimentalData.showPtychogram()" + "experimentalData.ptychogram = posit(experimentalData.ptychogram - backgroundOffset)\n", + "# experimentalData.showPtychogram()" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 36, "metadata": {}, "outputs": [], "source": [ "# Set monitor properties\n", "monitor = Monitor()\n", - "monitor.figureUpdateFrequency = 1\n", - "monitor.objectPlot = 'complex' # complex abs angle\n", - "monitor.verboseLevel = 'high' # high: plot two figures, low: plot only one figure\n", + "monitor.figureUpdateFrequency = 5\n", + "monitor.objectPlot = \"complex\" # complex abs angle\n", + "monitor.verboseLevel = \"low\" # high: plot two figures, low: plot only one figure\n", "monitor.probeZoom = 1 # control probe plot FoV\n", - "monitor.objectZoom = 2 # control object plot FoV\n", - "monitor.objectContrast = 0.8\n", - "monitor.probeContrast = 0.5" + "monitor.objectZoom = 2 # control object plot FoV\n", + "monitor.objectPlotContrast = 0.8\n", + "monitor.probePlotContrast = 0.5" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 37, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:GPU:cupy and CUDA available, switching to GPU\n" + ] + } + ], "source": [ "# Set the reconstruction parameters\n", "params = Params()\n", "## switches\n", - "params.gpuSwitch = True\n", - "params.positionOrder = 'random' # 'sequential' or 'random'\n", - "params.propagator = 'Fraunhofer' # Fraunhofer Fresnel ASP scaledASP polychromeASP scaledPolychromeASP\n", + "params.gpuSwitch = True # this is also autodetected by default, but you can set it to False to force CPU usage\n", + "params.positionOrder = \"random\" # 'sequential' or 'random'\n", + "params.propagator = (\n", + " \"Fraunhofer\" # Fraunhofer Fresnel ASP scaledASP polychromeASP scaledPolychromeASP\n", + ")\n", "params.probePowerCorrectionSwitch = True\n", "params.comStabilizationSwitch = True\n", "params.fftshiftSwitch = False\n", @@ -122,32 +185,40 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 38, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "Copying attribute wavelength\n", - "Copying attribute dxd\n", - "Copying attribute theta\n", - "Copying attribute spectralDensity\n", - "Copying attribute entrancePupilDiameter\n" + "INFO:Reconstruction:Copying attribute wavelength\n", + "INFO:Reconstruction:Copying attribute dxd\n", + "INFO:Reconstruction:Copying attribute theta\n", + "INFO:Reconstruction:Copying attribute spectralDensity\n", + "INFO:Reconstruction:Copying attribute entrancePupilDiameter\n", + "INFO:Reconstruction:Initial object set to ones\n", + "INFO:Reconstruction:Initial probe set to circ\n" ] } ], "source": [ "reconstruction = Reconstruction(experimentalData, params)\n", "reconstruction.No = 2**11\n", - "reconstruction.initialProbe = 'circ'\n", - "reconstruction.initialObject = 'ones'\n", + "reconstruction.initialProbe = \"circ\"\n", + "reconstruction.initialObject = \"ones\"\n", "# initialize probe and object and related params\n", "reconstruction.initializeObjectProbe()\n", "\n", "# customize initial probe quadratic phase\n", - "reconstruction.probe = reconstruction.probe*np.exp(1.j*2*np.pi/reconstruction.wavelength *\n", - " (reconstruction.Xp**2+reconstruction.Yp**2)/(3*6e-3))" + "reconstruction.probe = reconstruction.probe * np.exp(\n", + " 1.0j\n", + " * 2\n", + " * np.pi\n", + " / reconstruction.wavelength\n", + " * (reconstruction.Xp**2 + reconstruction.Yp**2)\n", + " / (3 * 6e-3)\n", + ")" ] }, { @@ -159,1954 +230,16 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 39, "metadata": { "scrolled": true }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "d:\\du\\ptylab\\PtyLab\\Engines\\BaseEngine.py:376: UserWarning: fftshiftSwitch set to false, this may lead to reduced performance\n", - " warnings.warn(\n" - ] - }, - { - "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "/* global mpl */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function () {\n", - " if (typeof WebSocket !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof MozWebSocket !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert(\n", - " 'Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.'\n", - " );\n", - " }\n", - "};\n", - "\n", - "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = this.ws.binaryType !== undefined;\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById('mpl-warnings');\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent =\n", - " 'This browser does not support binary websocket messages. ' +\n", - " 'Performance may be slow.';\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = document.createElement('div');\n", - " this.root.setAttribute('style', 'display: inline-block');\n", - " this._root_extra_style(this.root);\n", - "\n", - " parent_element.appendChild(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message('supports_binary', { value: fig.supports_binary });\n", - " fig.send_message('send_image_mode', {});\n", - " if (fig.ratio !== 1) {\n", - " fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });\n", - " }\n", - " fig.send_message('refresh', {});\n", - " };\n", - "\n", - " this.imageObj.onload = function () {\n", - " if (fig.image_mode === 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function () {\n", - " fig.ws.close();\n", - " };\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "};\n", - "\n", - "mpl.figure.prototype._init_header = function () {\n", - " var titlebar = document.createElement('div');\n", - " titlebar.classList =\n", - " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", - " var titletext = document.createElement('div');\n", - " titletext.classList = 'ui-dialog-title';\n", - " titletext.setAttribute(\n", - " 'style',\n", - " 'width: 100%; text-align: center; padding: 3px;'\n", - " );\n", - " titlebar.appendChild(titletext);\n", - " this.root.appendChild(titlebar);\n", - " this.header = titletext;\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._init_canvas = function () {\n", - " var fig = this;\n", - "\n", - " var canvas_div = (this.canvas_div = document.createElement('div'));\n", - " canvas_div.setAttribute(\n", - " 'style',\n", - " 'border: 1px solid #ddd;' +\n", - " 'box-sizing: content-box;' +\n", - " 'clear: both;' +\n", - " 'min-height: 1px;' +\n", - " 'min-width: 1px;' +\n", - " 'outline: 0;' +\n", - " 'overflow: hidden;' +\n", - " 'position: relative;' +\n", - " 'resize: both;'\n", - " );\n", - "\n", - " function on_keyboard_event_closure(name) {\n", - " return function (event) {\n", - " return fig.key_event(event, name);\n", - " };\n", - " }\n", - "\n", - " canvas_div.addEventListener(\n", - " 'keydown',\n", - " on_keyboard_event_closure('key_press')\n", - " );\n", - " canvas_div.addEventListener(\n", - " 'keyup',\n", - " on_keyboard_event_closure('key_release')\n", - " );\n", - "\n", - " this._canvas_extra_style(canvas_div);\n", - " this.root.appendChild(canvas_div);\n", - "\n", - " var canvas = (this.canvas = document.createElement('canvas'));\n", - " canvas.classList.add('mpl-canvas');\n", - " canvas.setAttribute('style', 'box-sizing: content-box;');\n", - "\n", - " this.context = canvas.getContext('2d');\n", - "\n", - " var backingStore =\n", - " this.context.backingStorePixelRatio ||\n", - " this.context.webkitBackingStorePixelRatio ||\n", - " this.context.mozBackingStorePixelRatio ||\n", - " this.context.msBackingStorePixelRatio ||\n", - " this.context.oBackingStorePixelRatio ||\n", - " this.context.backingStorePixelRatio ||\n", - " 1;\n", - "\n", - " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", - " 'canvas'\n", - " ));\n", - " rubberband_canvas.setAttribute(\n", - " 'style',\n", - " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", - " );\n", - "\n", - " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", - " if (this.ResizeObserver === undefined) {\n", - " if (window.ResizeObserver !== undefined) {\n", - " this.ResizeObserver = window.ResizeObserver;\n", - " } else {\n", - " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", - " this.ResizeObserver = obs.ResizeObserver;\n", - " }\n", - " }\n", - "\n", - " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", - " var nentries = entries.length;\n", - " for (var i = 0; i < nentries; i++) {\n", - " var entry = entries[i];\n", - " var width, height;\n", - " if (entry.contentBoxSize) {\n", - " if (entry.contentBoxSize instanceof Array) {\n", - " // Chrome 84 implements new version of spec.\n", - " width = entry.contentBoxSize[0].inlineSize;\n", - " height = entry.contentBoxSize[0].blockSize;\n", - " } else {\n", - " // Firefox implements old version of spec.\n", - " width = entry.contentBoxSize.inlineSize;\n", - " height = entry.contentBoxSize.blockSize;\n", - " }\n", - " } else {\n", - " // Chrome <84 implements even older version of spec.\n", - " width = entry.contentRect.width;\n", - " height = entry.contentRect.height;\n", - " }\n", - "\n", - " // Keep the size of the canvas and rubber band canvas in sync with\n", - " // the canvas container.\n", - " if (entry.devicePixelContentBoxSize) {\n", - " // Chrome 84 implements new version of spec.\n", - " canvas.setAttribute(\n", - " 'width',\n", - " entry.devicePixelContentBoxSize[0].inlineSize\n", - " );\n", - " canvas.setAttribute(\n", - " 'height',\n", - " entry.devicePixelContentBoxSize[0].blockSize\n", - " );\n", - " } else {\n", - " canvas.setAttribute('width', width * fig.ratio);\n", - " canvas.setAttribute('height', height * fig.ratio);\n", - " }\n", - " canvas.setAttribute(\n", - " 'style',\n", - " 'width: ' + width + 'px; height: ' + height + 'px;'\n", - " );\n", - "\n", - " rubberband_canvas.setAttribute('width', width);\n", - " rubberband_canvas.setAttribute('height', height);\n", - "\n", - " // And update the size in Python. We ignore the initial 0/0 size\n", - " // that occurs as the element is placed into the DOM, which should\n", - " // otherwise not happen due to the minimum size styling.\n", - " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", - " fig.request_resize(width, height);\n", - " }\n", - " }\n", - " });\n", - " this.resizeObserverInstance.observe(canvas_div);\n", - "\n", - " function on_mouse_event_closure(name) {\n", - " return function (event) {\n", - " return fig.mouse_event(event, name);\n", - " };\n", - " }\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mousedown',\n", - " on_mouse_event_closure('button_press')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseup',\n", - " on_mouse_event_closure('button_release')\n", - " );\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband_canvas.addEventListener(\n", - " 'mousemove',\n", - " on_mouse_event_closure('motion_notify')\n", - " );\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseenter',\n", - " on_mouse_event_closure('figure_enter')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseleave',\n", - " on_mouse_event_closure('figure_leave')\n", - " );\n", - "\n", - " canvas_div.addEventListener('wheel', function (event) {\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " on_mouse_event_closure('scroll')(event);\n", - " });\n", - "\n", - " canvas_div.appendChild(canvas);\n", - " canvas_div.appendChild(rubberband_canvas);\n", - "\n", - " this.rubberband_context = rubberband_canvas.getContext('2d');\n", - " this.rubberband_context.strokeStyle = '#000000';\n", - "\n", - " this._resize_canvas = function (width, height, forward) {\n", - " if (forward) {\n", - " canvas_div.style.width = width + 'px';\n", - " canvas_div.style.height = height + 'px';\n", - " }\n", - " };\n", - "\n", - " // Disable right mouse context menu.\n", - " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", - " event.preventDefault();\n", - " return false;\n", - " });\n", - "\n", - " function set_focus() {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'mpl-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " continue;\n", - " }\n", - "\n", - " var button = (fig.buttons[name] = document.createElement('button'));\n", - " button.classList = 'mpl-widget';\n", - " button.setAttribute('role', 'button');\n", - " button.setAttribute('aria-disabled', 'false');\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - "\n", - " var icon_img = document.createElement('img');\n", - " icon_img.src = '_images/' + image + '.png';\n", - " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", - " icon_img.alt = tooltip;\n", - " button.appendChild(icon_img);\n", - "\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " var fmt_picker = document.createElement('select');\n", - " fmt_picker.classList = 'mpl-widget';\n", - " toolbar.appendChild(fmt_picker);\n", - " this.format_dropdown = fmt_picker;\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = document.createElement('option');\n", - " option.selected = fmt === mpl.default_extension;\n", - " option.innerHTML = fmt;\n", - " fmt_picker.appendChild(option);\n", - " }\n", - "\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "};\n", - "\n", - "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", - "};\n", - "\n", - "mpl.figure.prototype.send_message = function (type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "};\n", - "\n", - "mpl.figure.prototype.send_draw_message = function () {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1], msg['forward']);\n", - " fig.send_message('refresh', {});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", - " var x0 = msg['x0'] / fig.ratio;\n", - " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", - " var x1 = msg['x1'] / fig.ratio;\n", - " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0,\n", - " 0,\n", - " fig.canvas.width / fig.ratio,\n", - " fig.canvas.height / fig.ratio\n", - " );\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", - " var cursor = msg['cursor'];\n", - " switch (cursor) {\n", - " case 0:\n", - " cursor = 'pointer';\n", - " break;\n", - " case 1:\n", - " cursor = 'default';\n", - " break;\n", - " case 2:\n", - " cursor = 'crosshair';\n", - " break;\n", - " case 3:\n", - " cursor = 'move';\n", - " break;\n", - " }\n", - " fig.rubberband_canvas.style.cursor = cursor;\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_message = function (fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", - " for (var key in msg) {\n", - " if (!(key in fig.buttons)) {\n", - " continue;\n", - " }\n", - " fig.buttons[key].disabled = !msg[key];\n", - " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", - " if (msg['mode'] === 'PAN') {\n", - " fig.buttons['Pan'].classList.add('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " } else if (msg['mode'] === 'ZOOM') {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.add('active');\n", - " } else {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message('ack', {});\n", - "};\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function (fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " evt.data.type = 'image/png';\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src\n", - " );\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " evt.data\n", - " );\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " } else if (\n", - " typeof evt.data === 'string' &&\n", - " evt.data.slice(0, 21) === 'data:image/png;base64'\n", - " ) {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig['handle_' + msg_type];\n", - " } catch (e) {\n", - " console.log(\n", - " \"No handler for the '\" + msg_type + \"' message type: \",\n", - " msg\n", - " );\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\n", - " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", - " e,\n", - " e.stack,\n", - " msg\n", - " );\n", - " }\n", - " }\n", - " };\n", - "};\n", - "\n", - "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function (e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e) {\n", - " e = window.event;\n", - " }\n", - " if (e.target) {\n", - " targ = e.target;\n", - " } else if (e.srcElement) {\n", - " targ = e.srcElement;\n", - " }\n", - " if (targ.nodeType === 3) {\n", - " // defeat Safari bug\n", - " targ = targ.parentNode;\n", - " }\n", - "\n", - " // pageX,Y are the mouse positions relative to the document\n", - " var boundingRect = targ.getBoundingClientRect();\n", - " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", - " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n", - "\n", - " return { x: x, y: y };\n", - "};\n", - "\n", - "/*\n", - " * return a copy of an object with only non-object keys\n", - " * we need this to avoid circular references\n", - " * http://stackoverflow.com/a/24161582/3208463\n", - " */\n", - "function simpleKeys(original) {\n", - " return Object.keys(original).reduce(function (obj, key) {\n", - " if (typeof original[key] !== 'object') {\n", - " obj[key] = original[key];\n", - " }\n", - " return obj;\n", - " }, {});\n", - "}\n", - "\n", - "mpl.figure.prototype.mouse_event = function (event, name) {\n", - " var canvas_pos = mpl.findpos(event);\n", - "\n", - " if (name === 'button_press') {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x * this.ratio;\n", - " var y = canvas_pos.y * this.ratio;\n", - "\n", - " this.send_message(name, {\n", - " x: x,\n", - " y: y,\n", - " button: event.button,\n", - " step: event.step,\n", - " guiEvent: simpleKeys(event),\n", - " });\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "};\n", - "\n", - "mpl.figure.prototype.key_event = function (event, name) {\n", - " // Prevent repeat events\n", - " if (name === 'key_press') {\n", - " if (event.which === this._key) {\n", - " return;\n", - " } else {\n", - " this._key = event.which;\n", - " }\n", - " }\n", - " if (name === 'key_release') {\n", - " this._key = null;\n", - " }\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.which !== 17) {\n", - " value += 'ctrl+';\n", - " }\n", - " if (event.altKey && event.which !== 18) {\n", - " value += 'alt+';\n", - " }\n", - " if (event.shiftKey && event.which !== 16) {\n", - " value += 'shift+';\n", - " }\n", - "\n", - " value += 'k';\n", - " value += event.which.toString();\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", - " if (name === 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message('toolbar_button', { name: name });\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "\n", - "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", - "// prettier-ignore\n", - "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", - "\n", - "mpl.default_extension = \"png\";/* global mpl */\n", - "\n", - "var comm_websocket_adapter = function (comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.close = function () {\n", - " comm.close();\n", - " };\n", - " ws.send = function (m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function (msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", - " ws.onmessage(msg['content']['data']);\n", - " });\n", - " return ws;\n", - "};\n", - "\n", - "mpl.mpl_figure_comm = function (comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = document.getElementById(id);\n", - " var ws_proxy = comm_websocket_adapter(comm);\n", - "\n", - " function ondownload(figure, _format) {\n", - " window.open(figure.canvas.toDataURL());\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element;\n", - " fig.cell_info = mpl.find_output_cell(\"
\");\n", - " if (!fig.cell_info) {\n", - " console.error('Failed to find cell for figure', id, fig);\n", - " return;\n", - " }\n", - " fig.cell_info[0].output_area.element.on(\n", - " 'cleared',\n", - " { fig: fig },\n", - " fig._remove_fig_handler\n", - " );\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function (fig, msg) {\n", - " var width = fig.canvas.width / fig.ratio;\n", - " fig.cell_info[0].output_area.element.off(\n", - " 'cleared',\n", - " fig._remove_fig_handler\n", - " );\n", - " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", - "\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable();\n", - " fig.parent_element.innerHTML =\n", - " '';\n", - " fig.close_ws(fig, msg);\n", - "};\n", - "\n", - "mpl.figure.prototype.close_ws = function (fig, msg) {\n", - " fig.send_message('closing', msg);\n", - " // fig.ws.close()\n", - "};\n", - "\n", - "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var width = this.canvas.width / this.ratio;\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] =\n", - " '';\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message('ack', {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () {\n", - " fig.push_to_output();\n", - " }, 1000);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'btn-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " var button;\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " continue;\n", - " }\n", - "\n", - " button = fig.buttons[name] = document.createElement('button');\n", - " button.classList = 'btn btn-default';\n", - " button.href = '#';\n", - " button.title = name;\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message pull-right';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = document.createElement('div');\n", - " buttongrp.classList = 'btn-group inline pull-right';\n", - " button = document.createElement('button');\n", - " button.classList = 'btn btn-mini btn-primary';\n", - " button.href = '#';\n", - " button.title = 'Stop Interaction';\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', function (_evt) {\n", - " fig.handle_close(fig, {});\n", - " });\n", - " button.addEventListener(\n", - " 'mouseover',\n", - " on_mouseover_closure('Stop Interaction')\n", - " );\n", - " buttongrp.appendChild(button);\n", - " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", - " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", - "};\n", - "\n", - "mpl.figure.prototype._remove_fig_handler = function (event) {\n", - " var fig = event.data.fig;\n", - " if (event.target !== this) {\n", - " // Ignore bubbled events from children.\n", - " return;\n", - " }\n", - " fig.close_ws(fig, {});\n", - "};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (el) {\n", - " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (el) {\n", - " // this is important to make the div 'focusable\n", - " el.setAttribute('tabindex', 0);\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " } else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", - " var manager = IPython.notebook.keyboard_manager;\n", - " if (!manager) {\n", - " manager = IPython.keyboard_manager;\n", - " }\n", - "\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which === 13) {\n", - " this.canvas_div.blur();\n", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " fig.ondownload(fig, null);\n", - "};\n", - "\n", - "mpl.find_output_cell = function (html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i = 0; i < ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code') {\n", - " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] === html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "};\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel !== null) {\n", - " IPython.notebook.kernel.comm_manager.register_target(\n", - " 'matplotlib',\n", - " mpl.mpl_figure_comm\n", - " );\n", - "}\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "/* global mpl */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function () {\n", - " if (typeof WebSocket !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof MozWebSocket !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert(\n", - " 'Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.'\n", - " );\n", - " }\n", - "};\n", - "\n", - "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = this.ws.binaryType !== undefined;\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById('mpl-warnings');\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent =\n", - " 'This browser does not support binary websocket messages. ' +\n", - " 'Performance may be slow.';\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = document.createElement('div');\n", - " this.root.setAttribute('style', 'display: inline-block');\n", - " this._root_extra_style(this.root);\n", - "\n", - " parent_element.appendChild(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message('supports_binary', { value: fig.supports_binary });\n", - " fig.send_message('send_image_mode', {});\n", - " if (fig.ratio !== 1) {\n", - " fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });\n", - " }\n", - " fig.send_message('refresh', {});\n", - " };\n", - "\n", - " this.imageObj.onload = function () {\n", - " if (fig.image_mode === 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function () {\n", - " fig.ws.close();\n", - " };\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "};\n", - "\n", - "mpl.figure.prototype._init_header = function () {\n", - " var titlebar = document.createElement('div');\n", - " titlebar.classList =\n", - " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", - " var titletext = document.createElement('div');\n", - " titletext.classList = 'ui-dialog-title';\n", - " titletext.setAttribute(\n", - " 'style',\n", - " 'width: 100%; text-align: center; padding: 3px;'\n", - " );\n", - " titlebar.appendChild(titletext);\n", - " this.root.appendChild(titlebar);\n", - " this.header = titletext;\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._init_canvas = function () {\n", - " var fig = this;\n", - "\n", - " var canvas_div = (this.canvas_div = document.createElement('div'));\n", - " canvas_div.setAttribute(\n", - " 'style',\n", - " 'border: 1px solid #ddd;' +\n", - " 'box-sizing: content-box;' +\n", - " 'clear: both;' +\n", - " 'min-height: 1px;' +\n", - " 'min-width: 1px;' +\n", - " 'outline: 0;' +\n", - " 'overflow: hidden;' +\n", - " 'position: relative;' +\n", - " 'resize: both;'\n", - " );\n", - "\n", - " function on_keyboard_event_closure(name) {\n", - " return function (event) {\n", - " return fig.key_event(event, name);\n", - " };\n", - " }\n", - "\n", - " canvas_div.addEventListener(\n", - " 'keydown',\n", - " on_keyboard_event_closure('key_press')\n", - " );\n", - " canvas_div.addEventListener(\n", - " 'keyup',\n", - " on_keyboard_event_closure('key_release')\n", - " );\n", - "\n", - " this._canvas_extra_style(canvas_div);\n", - " this.root.appendChild(canvas_div);\n", - "\n", - " var canvas = (this.canvas = document.createElement('canvas'));\n", - " canvas.classList.add('mpl-canvas');\n", - " canvas.setAttribute('style', 'box-sizing: content-box;');\n", - "\n", - " this.context = canvas.getContext('2d');\n", - "\n", - " var backingStore =\n", - " this.context.backingStorePixelRatio ||\n", - " this.context.webkitBackingStorePixelRatio ||\n", - " this.context.mozBackingStorePixelRatio ||\n", - " this.context.msBackingStorePixelRatio ||\n", - " this.context.oBackingStorePixelRatio ||\n", - " this.context.backingStorePixelRatio ||\n", - " 1;\n", - "\n", - " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", - " 'canvas'\n", - " ));\n", - " rubberband_canvas.setAttribute(\n", - " 'style',\n", - " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", - " );\n", - "\n", - " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", - " if (this.ResizeObserver === undefined) {\n", - " if (window.ResizeObserver !== undefined) {\n", - " this.ResizeObserver = window.ResizeObserver;\n", - " } else {\n", - " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", - " this.ResizeObserver = obs.ResizeObserver;\n", - " }\n", - " }\n", - "\n", - " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", - " var nentries = entries.length;\n", - " for (var i = 0; i < nentries; i++) {\n", - " var entry = entries[i];\n", - " var width, height;\n", - " if (entry.contentBoxSize) {\n", - " if (entry.contentBoxSize instanceof Array) {\n", - " // Chrome 84 implements new version of spec.\n", - " width = entry.contentBoxSize[0].inlineSize;\n", - " height = entry.contentBoxSize[0].blockSize;\n", - " } else {\n", - " // Firefox implements old version of spec.\n", - " width = entry.contentBoxSize.inlineSize;\n", - " height = entry.contentBoxSize.blockSize;\n", - " }\n", - " } else {\n", - " // Chrome <84 implements even older version of spec.\n", - " width = entry.contentRect.width;\n", - " height = entry.contentRect.height;\n", - " }\n", - "\n", - " // Keep the size of the canvas and rubber band canvas in sync with\n", - " // the canvas container.\n", - " if (entry.devicePixelContentBoxSize) {\n", - " // Chrome 84 implements new version of spec.\n", - " canvas.setAttribute(\n", - " 'width',\n", - " entry.devicePixelContentBoxSize[0].inlineSize\n", - " );\n", - " canvas.setAttribute(\n", - " 'height',\n", - " entry.devicePixelContentBoxSize[0].blockSize\n", - " );\n", - " } else {\n", - " canvas.setAttribute('width', width * fig.ratio);\n", - " canvas.setAttribute('height', height * fig.ratio);\n", - " }\n", - " canvas.setAttribute(\n", - " 'style',\n", - " 'width: ' + width + 'px; height: ' + height + 'px;'\n", - " );\n", - "\n", - " rubberband_canvas.setAttribute('width', width);\n", - " rubberband_canvas.setAttribute('height', height);\n", - "\n", - " // And update the size in Python. We ignore the initial 0/0 size\n", - " // that occurs as the element is placed into the DOM, which should\n", - " // otherwise not happen due to the minimum size styling.\n", - " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", - " fig.request_resize(width, height);\n", - " }\n", - " }\n", - " });\n", - " this.resizeObserverInstance.observe(canvas_div);\n", - "\n", - " function on_mouse_event_closure(name) {\n", - " return function (event) {\n", - " return fig.mouse_event(event, name);\n", - " };\n", - " }\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mousedown',\n", - " on_mouse_event_closure('button_press')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseup',\n", - " on_mouse_event_closure('button_release')\n", - " );\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband_canvas.addEventListener(\n", - " 'mousemove',\n", - " on_mouse_event_closure('motion_notify')\n", - " );\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseenter',\n", - " on_mouse_event_closure('figure_enter')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseleave',\n", - " on_mouse_event_closure('figure_leave')\n", - " );\n", - "\n", - " canvas_div.addEventListener('wheel', function (event) {\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " on_mouse_event_closure('scroll')(event);\n", - " });\n", - "\n", - " canvas_div.appendChild(canvas);\n", - " canvas_div.appendChild(rubberband_canvas);\n", - "\n", - " this.rubberband_context = rubberband_canvas.getContext('2d');\n", - " this.rubberband_context.strokeStyle = '#000000';\n", - "\n", - " this._resize_canvas = function (width, height, forward) {\n", - " if (forward) {\n", - " canvas_div.style.width = width + 'px';\n", - " canvas_div.style.height = height + 'px';\n", - " }\n", - " };\n", - "\n", - " // Disable right mouse context menu.\n", - " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", - " event.preventDefault();\n", - " return false;\n", - " });\n", - "\n", - " function set_focus() {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'mpl-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " continue;\n", - " }\n", - "\n", - " var button = (fig.buttons[name] = document.createElement('button'));\n", - " button.classList = 'mpl-widget';\n", - " button.setAttribute('role', 'button');\n", - " button.setAttribute('aria-disabled', 'false');\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - "\n", - " var icon_img = document.createElement('img');\n", - " icon_img.src = '_images/' + image + '.png';\n", - " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", - " icon_img.alt = tooltip;\n", - " button.appendChild(icon_img);\n", - "\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " var fmt_picker = document.createElement('select');\n", - " fmt_picker.classList = 'mpl-widget';\n", - " toolbar.appendChild(fmt_picker);\n", - " this.format_dropdown = fmt_picker;\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = document.createElement('option');\n", - " option.selected = fmt === mpl.default_extension;\n", - " option.innerHTML = fmt;\n", - " fmt_picker.appendChild(option);\n", - " }\n", - "\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "};\n", - "\n", - "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", - "};\n", - "\n", - "mpl.figure.prototype.send_message = function (type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "};\n", - "\n", - "mpl.figure.prototype.send_draw_message = function () {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1], msg['forward']);\n", - " fig.send_message('refresh', {});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", - " var x0 = msg['x0'] / fig.ratio;\n", - " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", - " var x1 = msg['x1'] / fig.ratio;\n", - " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0,\n", - " 0,\n", - " fig.canvas.width / fig.ratio,\n", - " fig.canvas.height / fig.ratio\n", - " );\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", - " var cursor = msg['cursor'];\n", - " switch (cursor) {\n", - " case 0:\n", - " cursor = 'pointer';\n", - " break;\n", - " case 1:\n", - " cursor = 'default';\n", - " break;\n", - " case 2:\n", - " cursor = 'crosshair';\n", - " break;\n", - " case 3:\n", - " cursor = 'move';\n", - " break;\n", - " }\n", - " fig.rubberband_canvas.style.cursor = cursor;\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_message = function (fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", - " for (var key in msg) {\n", - " if (!(key in fig.buttons)) {\n", - " continue;\n", - " }\n", - " fig.buttons[key].disabled = !msg[key];\n", - " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", - " if (msg['mode'] === 'PAN') {\n", - " fig.buttons['Pan'].classList.add('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " } else if (msg['mode'] === 'ZOOM') {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.add('active');\n", - " } else {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message('ack', {});\n", - "};\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function (fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " evt.data.type = 'image/png';\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src\n", - " );\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " evt.data\n", - " );\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " } else if (\n", - " typeof evt.data === 'string' &&\n", - " evt.data.slice(0, 21) === 'data:image/png;base64'\n", - " ) {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig['handle_' + msg_type];\n", - " } catch (e) {\n", - " console.log(\n", - " \"No handler for the '\" + msg_type + \"' message type: \",\n", - " msg\n", - " );\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\n", - " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", - " e,\n", - " e.stack,\n", - " msg\n", - " );\n", - " }\n", - " }\n", - " };\n", - "};\n", - "\n", - "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function (e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e) {\n", - " e = window.event;\n", - " }\n", - " if (e.target) {\n", - " targ = e.target;\n", - " } else if (e.srcElement) {\n", - " targ = e.srcElement;\n", - " }\n", - " if (targ.nodeType === 3) {\n", - " // defeat Safari bug\n", - " targ = targ.parentNode;\n", - " }\n", - "\n", - " // pageX,Y are the mouse positions relative to the document\n", - " var boundingRect = targ.getBoundingClientRect();\n", - " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", - " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n", - "\n", - " return { x: x, y: y };\n", - "};\n", - "\n", - "/*\n", - " * return a copy of an object with only non-object keys\n", - " * we need this to avoid circular references\n", - " * http://stackoverflow.com/a/24161582/3208463\n", - " */\n", - "function simpleKeys(original) {\n", - " return Object.keys(original).reduce(function (obj, key) {\n", - " if (typeof original[key] !== 'object') {\n", - " obj[key] = original[key];\n", - " }\n", - " return obj;\n", - " }, {});\n", - "}\n", - "\n", - "mpl.figure.prototype.mouse_event = function (event, name) {\n", - " var canvas_pos = mpl.findpos(event);\n", - "\n", - " if (name === 'button_press') {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x * this.ratio;\n", - " var y = canvas_pos.y * this.ratio;\n", - "\n", - " this.send_message(name, {\n", - " x: x,\n", - " y: y,\n", - " button: event.button,\n", - " step: event.step,\n", - " guiEvent: simpleKeys(event),\n", - " });\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "};\n", - "\n", - "mpl.figure.prototype.key_event = function (event, name) {\n", - " // Prevent repeat events\n", - " if (name === 'key_press') {\n", - " if (event.which === this._key) {\n", - " return;\n", - " } else {\n", - " this._key = event.which;\n", - " }\n", - " }\n", - " if (name === 'key_release') {\n", - " this._key = null;\n", - " }\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.which !== 17) {\n", - " value += 'ctrl+';\n", - " }\n", - " if (event.altKey && event.which !== 18) {\n", - " value += 'alt+';\n", - " }\n", - " if (event.shiftKey && event.which !== 16) {\n", - " value += 'shift+';\n", - " }\n", - "\n", - " value += 'k';\n", - " value += event.which.toString();\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", - " if (name === 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message('toolbar_button', { name: name });\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "\n", - "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", - "// prettier-ignore\n", - "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", - "\n", - "mpl.default_extension = \"png\";/* global mpl */\n", - "\n", - "var comm_websocket_adapter = function (comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.close = function () {\n", - " comm.close();\n", - " };\n", - " ws.send = function (m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function (msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", - " ws.onmessage(msg['content']['data']);\n", - " });\n", - " return ws;\n", - "};\n", - "\n", - "mpl.mpl_figure_comm = function (comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = document.getElementById(id);\n", - " var ws_proxy = comm_websocket_adapter(comm);\n", - "\n", - " function ondownload(figure, _format) {\n", - " window.open(figure.canvas.toDataURL());\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element;\n", - " fig.cell_info = mpl.find_output_cell(\"
\");\n", - " if (!fig.cell_info) {\n", - " console.error('Failed to find cell for figure', id, fig);\n", - " return;\n", - " }\n", - " fig.cell_info[0].output_area.element.on(\n", - " 'cleared',\n", - " { fig: fig },\n", - " fig._remove_fig_handler\n", - " );\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function (fig, msg) {\n", - " var width = fig.canvas.width / fig.ratio;\n", - " fig.cell_info[0].output_area.element.off(\n", - " 'cleared',\n", - " fig._remove_fig_handler\n", - " );\n", - " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", - "\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable();\n", - " fig.parent_element.innerHTML =\n", - " '';\n", - " fig.close_ws(fig, msg);\n", - "};\n", - "\n", - "mpl.figure.prototype.close_ws = function (fig, msg) {\n", - " fig.send_message('closing', msg);\n", - " // fig.ws.close()\n", - "};\n", - "\n", - "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var width = this.canvas.width / this.ratio;\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] =\n", - " '';\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message('ack', {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () {\n", - " fig.push_to_output();\n", - " }, 1000);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'btn-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " var button;\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " continue;\n", - " }\n", - "\n", - " button = fig.buttons[name] = document.createElement('button');\n", - " button.classList = 'btn btn-default';\n", - " button.href = '#';\n", - " button.title = name;\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message pull-right';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = document.createElement('div');\n", - " buttongrp.classList = 'btn-group inline pull-right';\n", - " button = document.createElement('button');\n", - " button.classList = 'btn btn-mini btn-primary';\n", - " button.href = '#';\n", - " button.title = 'Stop Interaction';\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', function (_evt) {\n", - " fig.handle_close(fig, {});\n", - " });\n", - " button.addEventListener(\n", - " 'mouseover',\n", - " on_mouseover_closure('Stop Interaction')\n", - " );\n", - " buttongrp.appendChild(button);\n", - " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", - " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", - "};\n", - "\n", - "mpl.figure.prototype._remove_fig_handler = function (event) {\n", - " var fig = event.data.fig;\n", - " if (event.target !== this) {\n", - " // Ignore bubbled events from children.\n", - " return;\n", - " }\n", - " fig.close_ws(fig, {});\n", - "};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (el) {\n", - " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (el) {\n", - " // this is important to make the div 'focusable\n", - " el.setAttribute('tabindex', 0);\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " } else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", - " var manager = IPython.notebook.keyboard_manager;\n", - " if (!manager) {\n", - " manager = IPython.keyboard_manager;\n", - " }\n", - "\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which === 13) {\n", - " this.canvas_div.blur();\n", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " fig.ondownload(fig, null);\n", - "};\n", - "\n", - "mpl.find_output_cell = function (html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i = 0; i < ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code') {\n", - " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] === html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "};\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel !== null) {\n", - " IPython.notebook.kernel.comm_manager.register_target(\n", - " 'matplotlib',\n", - " mpl.mpl_figure_comm\n", - " );\n", - "}\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "data": { - "text/html": [ - "" - ], + "image/png": "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", "text/plain": [ - "" + "
" ] }, "metadata": {}, @@ -2115,5206 +248,195 @@ { "name": "stdout", "output_type": "stream", - "text": [ - "\r", - "mPIE: 0%| | 0/100 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "params.intensityConstraint = \"standard\"\n", + "\n", + "mPIE = Engines.mPIE(reconstruction, experimentalData, params, monitor)\n", + "mPIE.numIterations = 100\n", + "mPIE.betaProbe = 0.05\n", + "mPIE.betaObject = 0.25\n", + "mPIE.reconstruct()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we switch to interferometric constraint, which takes into account the extra reflection from the plane side of the USAF glass substrate, and treats it as an external 'reference'. The results show that the noise in object reconstruction is significantly cleaned up." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - " 0%| | 0/102 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", - "text": [ - " \n", - "iteration: 16 \n", - "error: 31.7 \n", - "estimated linear overlap: 79.1 % \n", - "estimated area overlap: 81.6 % \n", - "mPIE: 17%|████████████▊ | 17/100 [00:10<00:47, 1.74it/s]" - ] + "text": [] }, { "name": "stderr", "output_type": "stream", "text": [ - "\n", - " 0%| | 0/102 [00:00open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element;\n", - " fig.cell_info = mpl.find_output_cell(\"
\");\n", - " if (!fig.cell_info) {\n", - " console.error('Failed to find cell for figure', id, fig);\n", - " return;\n", - " }\n", - " fig.cell_info[0].output_area.element.on(\n", - " 'cleared',\n", - " { fig: fig },\n", - " fig._remove_fig_handler\n", - " );\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function (fig, msg) {\n", - " var width = fig.canvas.width / fig.ratio;\n", - " fig.cell_info[0].output_area.element.off(\n", - " 'cleared',\n", - " fig._remove_fig_handler\n", - " );\n", - " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", - "\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable();\n", - " fig.parent_element.innerHTML =\n", - " '';\n", - " fig.close_ws(fig, msg);\n", - "};\n", - "\n", - "mpl.figure.prototype.close_ws = function (fig, msg) {\n", - " fig.send_message('closing', msg);\n", - " // fig.ws.close()\n", - "};\n", - "\n", - "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var width = this.canvas.width / this.ratio;\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] =\n", - " '';\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message('ack', {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () {\n", - " fig.push_to_output();\n", - " }, 1000);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'btn-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " var button;\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " continue;\n", - " }\n", - "\n", - " button = fig.buttons[name] = document.createElement('button');\n", - " button.classList = 'btn btn-default';\n", - " button.href = '#';\n", - " button.title = name;\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message pull-right';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = document.createElement('div');\n", - " buttongrp.classList = 'btn-group inline pull-right';\n", - " button = document.createElement('button');\n", - " button.classList = 'btn btn-mini btn-primary';\n", - " button.href = '#';\n", - " button.title = 'Stop Interaction';\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', function (_evt) {\n", - " fig.handle_close(fig, {});\n", - " });\n", - " button.addEventListener(\n", - " 'mouseover',\n", - " on_mouseover_closure('Stop Interaction')\n", - " );\n", - " buttongrp.appendChild(button);\n", - " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", - " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", - "};\n", - "\n", - "mpl.figure.prototype._remove_fig_handler = function (event) {\n", - " var fig = event.data.fig;\n", - " if (event.target !== this) {\n", - " // Ignore bubbled events from children.\n", - " return;\n", - " }\n", - " fig.close_ws(fig, {});\n", - "};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (el) {\n", - " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (el) {\n", - " // this is important to make the div 'focusable\n", - " el.setAttribute('tabindex', 0);\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " } else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", - " var manager = IPython.notebook.keyboard_manager;\n", - " if (!manager) {\n", - " manager = IPython.keyboard_manager;\n", - " }\n", - "\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which === 13) {\n", - " this.canvas_div.blur();\n", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " fig.ondownload(fig, null);\n", - "};\n", - "\n", - "mpl.find_output_cell = function (html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i = 0; i < ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code') {\n", - " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] === html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "};\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel !== null) {\n", - " IPython.notebook.kernel.comm_manager.register_target(\n", - " 'matplotlib',\n", - " mpl.mpl_figure_comm\n", - " );\n", - "}\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "/* global mpl */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function () {\n", - " if (typeof WebSocket !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof MozWebSocket !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert(\n", - " 'Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.'\n", - " );\n", - " }\n", - "};\n", - "\n", - "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = this.ws.binaryType !== undefined;\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById('mpl-warnings');\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent =\n", - " 'This browser does not support binary websocket messages. ' +\n", - " 'Performance may be slow.';\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = document.createElement('div');\n", - " this.root.setAttribute('style', 'display: inline-block');\n", - " this._root_extra_style(this.root);\n", - "\n", - " parent_element.appendChild(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message('supports_binary', { value: fig.supports_binary });\n", - " fig.send_message('send_image_mode', {});\n", - " if (fig.ratio !== 1) {\n", - " fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });\n", - " }\n", - " fig.send_message('refresh', {});\n", - " };\n", - "\n", - " this.imageObj.onload = function () {\n", - " if (fig.image_mode === 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function () {\n", - " fig.ws.close();\n", - " };\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "};\n", - "\n", - "mpl.figure.prototype._init_header = function () {\n", - " var titlebar = document.createElement('div');\n", - " titlebar.classList =\n", - " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", - " var titletext = document.createElement('div');\n", - " titletext.classList = 'ui-dialog-title';\n", - " titletext.setAttribute(\n", - " 'style',\n", - " 'width: 100%; text-align: center; padding: 3px;'\n", - " );\n", - " titlebar.appendChild(titletext);\n", - " this.root.appendChild(titlebar);\n", - " this.header = titletext;\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._init_canvas = function () {\n", - " var fig = this;\n", - "\n", - " var canvas_div = (this.canvas_div = document.createElement('div'));\n", - " canvas_div.setAttribute(\n", - " 'style',\n", - " 'border: 1px solid #ddd;' +\n", - " 'box-sizing: content-box;' +\n", - " 'clear: both;' +\n", - " 'min-height: 1px;' +\n", - " 'min-width: 1px;' +\n", - " 'outline: 0;' +\n", - " 'overflow: hidden;' +\n", - " 'position: relative;' +\n", - " 'resize: both;'\n", - " );\n", - "\n", - " function on_keyboard_event_closure(name) {\n", - " return function (event) {\n", - " return fig.key_event(event, name);\n", - " };\n", - " }\n", - "\n", - " canvas_div.addEventListener(\n", - " 'keydown',\n", - " on_keyboard_event_closure('key_press')\n", - " );\n", - " canvas_div.addEventListener(\n", - " 'keyup',\n", - " on_keyboard_event_closure('key_release')\n", - " );\n", - "\n", - " this._canvas_extra_style(canvas_div);\n", - " this.root.appendChild(canvas_div);\n", - "\n", - " var canvas = (this.canvas = document.createElement('canvas'));\n", - " canvas.classList.add('mpl-canvas');\n", - " canvas.setAttribute('style', 'box-sizing: content-box;');\n", - "\n", - " this.context = canvas.getContext('2d');\n", - "\n", - " var backingStore =\n", - " this.context.backingStorePixelRatio ||\n", - " this.context.webkitBackingStorePixelRatio ||\n", - " this.context.mozBackingStorePixelRatio ||\n", - " this.context.msBackingStorePixelRatio ||\n", - " this.context.oBackingStorePixelRatio ||\n", - " this.context.backingStorePixelRatio ||\n", - " 1;\n", - "\n", - " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", - " 'canvas'\n", - " ));\n", - " rubberband_canvas.setAttribute(\n", - " 'style',\n", - " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", - " );\n", - "\n", - " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", - " if (this.ResizeObserver === undefined) {\n", - " if (window.ResizeObserver !== undefined) {\n", - " this.ResizeObserver = window.ResizeObserver;\n", - " } else {\n", - " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", - " this.ResizeObserver = obs.ResizeObserver;\n", - " }\n", - " }\n", - "\n", - " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", - " var nentries = entries.length;\n", - " for (var i = 0; i < nentries; i++) {\n", - " var entry = entries[i];\n", - " var width, height;\n", - " if (entry.contentBoxSize) {\n", - " if (entry.contentBoxSize instanceof Array) {\n", - " // Chrome 84 implements new version of spec.\n", - " width = entry.contentBoxSize[0].inlineSize;\n", - " height = entry.contentBoxSize[0].blockSize;\n", - " } else {\n", - " // Firefox implements old version of spec.\n", - " width = entry.contentBoxSize.inlineSize;\n", - " height = entry.contentBoxSize.blockSize;\n", - " }\n", - " } else {\n", - " // Chrome <84 implements even older version of spec.\n", - " width = entry.contentRect.width;\n", - " height = entry.contentRect.height;\n", - " }\n", - "\n", - " // Keep the size of the canvas and rubber band canvas in sync with\n", - " // the canvas container.\n", - " if (entry.devicePixelContentBoxSize) {\n", - " // Chrome 84 implements new version of spec.\n", - " canvas.setAttribute(\n", - " 'width',\n", - " entry.devicePixelContentBoxSize[0].inlineSize\n", - " );\n", - " canvas.setAttribute(\n", - " 'height',\n", - " entry.devicePixelContentBoxSize[0].blockSize\n", - " );\n", - " } else {\n", - " canvas.setAttribute('width', width * fig.ratio);\n", - " canvas.setAttribute('height', height * fig.ratio);\n", - " }\n", - " canvas.setAttribute(\n", - " 'style',\n", - " 'width: ' + width + 'px; height: ' + height + 'px;'\n", - " );\n", - "\n", - " rubberband_canvas.setAttribute('width', width);\n", - " rubberband_canvas.setAttribute('height', height);\n", - "\n", - " // And update the size in Python. We ignore the initial 0/0 size\n", - " // that occurs as the element is placed into the DOM, which should\n", - " // otherwise not happen due to the minimum size styling.\n", - " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", - " fig.request_resize(width, height);\n", - " }\n", - " }\n", - " });\n", - " this.resizeObserverInstance.observe(canvas_div);\n", - "\n", - " function on_mouse_event_closure(name) {\n", - " return function (event) {\n", - " return fig.mouse_event(event, name);\n", - " };\n", - " }\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mousedown',\n", - " on_mouse_event_closure('button_press')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseup',\n", - " on_mouse_event_closure('button_release')\n", - " );\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband_canvas.addEventListener(\n", - " 'mousemove',\n", - " on_mouse_event_closure('motion_notify')\n", - " );\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseenter',\n", - " on_mouse_event_closure('figure_enter')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseleave',\n", - " on_mouse_event_closure('figure_leave')\n", - " );\n", - "\n", - " canvas_div.addEventListener('wheel', function (event) {\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " on_mouse_event_closure('scroll')(event);\n", - " });\n", - "\n", - " canvas_div.appendChild(canvas);\n", - " canvas_div.appendChild(rubberband_canvas);\n", - "\n", - " this.rubberband_context = rubberband_canvas.getContext('2d');\n", - " this.rubberband_context.strokeStyle = '#000000';\n", - "\n", - " this._resize_canvas = function (width, height, forward) {\n", - " if (forward) {\n", - " canvas_div.style.width = width + 'px';\n", - " canvas_div.style.height = height + 'px';\n", - " }\n", - " };\n", - "\n", - " // Disable right mouse context menu.\n", - " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", - " event.preventDefault();\n", - " return false;\n", - " });\n", - "\n", - " function set_focus() {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'mpl-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " continue;\n", - " }\n", - "\n", - " var button = (fig.buttons[name] = document.createElement('button'));\n", - " button.classList = 'mpl-widget';\n", - " button.setAttribute('role', 'button');\n", - " button.setAttribute('aria-disabled', 'false');\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - "\n", - " var icon_img = document.createElement('img');\n", - " icon_img.src = '_images/' + image + '.png';\n", - " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", - " icon_img.alt = tooltip;\n", - " button.appendChild(icon_img);\n", - "\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " var fmt_picker = document.createElement('select');\n", - " fmt_picker.classList = 'mpl-widget';\n", - " toolbar.appendChild(fmt_picker);\n", - " this.format_dropdown = fmt_picker;\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = document.createElement('option');\n", - " option.selected = fmt === mpl.default_extension;\n", - " option.innerHTML = fmt;\n", - " fmt_picker.appendChild(option);\n", - " }\n", - "\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "};\n", - "\n", - "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", - "};\n", - "\n", - "mpl.figure.prototype.send_message = function (type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "};\n", - "\n", - "mpl.figure.prototype.send_draw_message = function () {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1], msg['forward']);\n", - " fig.send_message('refresh', {});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", - " var x0 = msg['x0'] / fig.ratio;\n", - " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", - " var x1 = msg['x1'] / fig.ratio;\n", - " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0,\n", - " 0,\n", - " fig.canvas.width / fig.ratio,\n", - " fig.canvas.height / fig.ratio\n", - " );\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", - " var cursor = msg['cursor'];\n", - " switch (cursor) {\n", - " case 0:\n", - " cursor = 'pointer';\n", - " break;\n", - " case 1:\n", - " cursor = 'default';\n", - " break;\n", - " case 2:\n", - " cursor = 'crosshair';\n", - " break;\n", - " case 3:\n", - " cursor = 'move';\n", - " break;\n", - " }\n", - " fig.rubberband_canvas.style.cursor = cursor;\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_message = function (fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", - " for (var key in msg) {\n", - " if (!(key in fig.buttons)) {\n", - " continue;\n", - " }\n", - " fig.buttons[key].disabled = !msg[key];\n", - " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", - " if (msg['mode'] === 'PAN') {\n", - " fig.buttons['Pan'].classList.add('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " } else if (msg['mode'] === 'ZOOM') {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.add('active');\n", - " } else {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message('ack', {});\n", - "};\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function (fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " evt.data.type = 'image/png';\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src\n", - " );\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " evt.data\n", - " );\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " } else if (\n", - " typeof evt.data === 'string' &&\n", - " evt.data.slice(0, 21) === 'data:image/png;base64'\n", - " ) {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig['handle_' + msg_type];\n", - " } catch (e) {\n", - " console.log(\n", - " \"No handler for the '\" + msg_type + \"' message type: \",\n", - " msg\n", - " );\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\n", - " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", - " e,\n", - " e.stack,\n", - " msg\n", - " );\n", - " }\n", - " }\n", - " };\n", - "};\n", - "\n", - "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function (e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e) {\n", - " e = window.event;\n", - " }\n", - " if (e.target) {\n", - " targ = e.target;\n", - " } else if (e.srcElement) {\n", - " targ = e.srcElement;\n", - " }\n", - " if (targ.nodeType === 3) {\n", - " // defeat Safari bug\n", - " targ = targ.parentNode;\n", - " }\n", - "\n", - " // pageX,Y are the mouse positions relative to the document\n", - " var boundingRect = targ.getBoundingClientRect();\n", - " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", - " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n", - "\n", - " return { x: x, y: y };\n", - "};\n", - "\n", - "/*\n", - " * return a copy of an object with only non-object keys\n", - " * we need this to avoid circular references\n", - " * http://stackoverflow.com/a/24161582/3208463\n", - " */\n", - "function simpleKeys(original) {\n", - " return Object.keys(original).reduce(function (obj, key) {\n", - " if (typeof original[key] !== 'object') {\n", - " obj[key] = original[key];\n", - " }\n", - " return obj;\n", - " }, {});\n", - "}\n", - "\n", - "mpl.figure.prototype.mouse_event = function (event, name) {\n", - " var canvas_pos = mpl.findpos(event);\n", - "\n", - " if (name === 'button_press') {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x * this.ratio;\n", - " var y = canvas_pos.y * this.ratio;\n", - "\n", - " this.send_message(name, {\n", - " x: x,\n", - " y: y,\n", - " button: event.button,\n", - " step: event.step,\n", - " guiEvent: simpleKeys(event),\n", - " });\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "};\n", - "\n", - "mpl.figure.prototype.key_event = function (event, name) {\n", - " // Prevent repeat events\n", - " if (name === 'key_press') {\n", - " if (event.which === this._key) {\n", - " return;\n", - " } else {\n", - " this._key = event.which;\n", - " }\n", - " }\n", - " if (name === 'key_release') {\n", - " this._key = null;\n", - " }\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.which !== 17) {\n", - " value += 'ctrl+';\n", - " }\n", - " if (event.altKey && event.which !== 18) {\n", - " value += 'alt+';\n", - " }\n", - " if (event.shiftKey && event.which !== 16) {\n", - " value += 'shift+';\n", - " }\n", - "\n", - " value += 'k';\n", - " value += event.which.toString();\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", - " if (name === 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message('toolbar_button', { name: name });\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "\n", - "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", - "// prettier-ignore\n", - "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", - "\n", - "mpl.default_extension = \"png\";/* global mpl */\n", - "\n", - "var comm_websocket_adapter = function (comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.close = function () {\n", - " comm.close();\n", - " };\n", - " ws.send = function (m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function (msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", - " ws.onmessage(msg['content']['data']);\n", - " });\n", - " return ws;\n", - "};\n", - "\n", - "mpl.mpl_figure_comm = function (comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = document.getElementById(id);\n", - " var ws_proxy = comm_websocket_adapter(comm);\n", - "\n", - " function ondownload(figure, _format) {\n", - " window.open(figure.canvas.toDataURL());\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element;\n", - " fig.cell_info = mpl.find_output_cell(\"
\");\n", - " if (!fig.cell_info) {\n", - " console.error('Failed to find cell for figure', id, fig);\n", - " return;\n", - " }\n", - " fig.cell_info[0].output_area.element.on(\n", - " 'cleared',\n", - " { fig: fig },\n", - " fig._remove_fig_handler\n", - " );\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function (fig, msg) {\n", - " var width = fig.canvas.width / fig.ratio;\n", - " fig.cell_info[0].output_area.element.off(\n", - " 'cleared',\n", - " fig._remove_fig_handler\n", - " );\n", - " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", - "\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable();\n", - " fig.parent_element.innerHTML =\n", - " '';\n", - " fig.close_ws(fig, msg);\n", - "};\n", - "\n", - "mpl.figure.prototype.close_ws = function (fig, msg) {\n", - " fig.send_message('closing', msg);\n", - " // fig.ws.close()\n", - "};\n", - "\n", - "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var width = this.canvas.width / this.ratio;\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] =\n", - " '';\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message('ack', {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () {\n", - " fig.push_to_output();\n", - " }, 1000);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'btn-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " var button;\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " continue;\n", - " }\n", - "\n", - " button = fig.buttons[name] = document.createElement('button');\n", - " button.classList = 'btn btn-default';\n", - " button.href = '#';\n", - " button.title = name;\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message pull-right';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = document.createElement('div');\n", - " buttongrp.classList = 'btn-group inline pull-right';\n", - " button = document.createElement('button');\n", - " button.classList = 'btn btn-mini btn-primary';\n", - " button.href = '#';\n", - " button.title = 'Stop Interaction';\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', function (_evt) {\n", - " fig.handle_close(fig, {});\n", - " });\n", - " button.addEventListener(\n", - " 'mouseover',\n", - " on_mouseover_closure('Stop Interaction')\n", - " );\n", - " buttongrp.appendChild(button);\n", - " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", - " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", - "};\n", - "\n", - "mpl.figure.prototype._remove_fig_handler = function (event) {\n", - " var fig = event.data.fig;\n", - " if (event.target !== this) {\n", - " // Ignore bubbled events from children.\n", - " return;\n", - " }\n", - " fig.close_ws(fig, {});\n", - "};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (el) {\n", - " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (el) {\n", - " // this is important to make the div 'focusable\n", - " el.setAttribute('tabindex', 0);\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " } else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", - " var manager = IPython.notebook.keyboard_manager;\n", - " if (!manager) {\n", - " manager = IPython.keyboard_manager;\n", - " }\n", - "\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which === 13) {\n", - " this.canvas_div.blur();\n", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " fig.ondownload(fig, null);\n", - "};\n", - "\n", - "mpl.find_output_cell = function (html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i = 0; i < ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code') {\n", - " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] === html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "};\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel !== null) {\n", - " IPython.notebook.kernel.comm_manager.register_target(\n", - " 'matplotlib',\n", - " mpl.mpl_figure_comm\n", - " );\n", - "}\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 0 \n", - "error: 35.7 \n", - "estimated linear overlap: 75.0 % \n", - "estimated area overlap: 74.9 % \n", - " \n", - "iteration: 1 \n", - "error: 35.0 \n", - "estimated linear overlap: 75.0 % \n", - "estimated area overlap: 74.1 % \n", - " \n", - "iteration: 2 \n", - "error: 35.6 \n", - "estimated linear overlap: 75.5 % \n", - "estimated area overlap: 73.9 % \n", - " \n", - "iteration: 3 \n", - "error: 36.3 \n", - "estimated linear overlap: 75.3 % \n", - "estimated area overlap: 74.6 % \n", - " \n", - "iteration: 4 \n", - "error: 36.0 \n", - "estimated linear overlap: 75.7 % \n", - "estimated area overlap: 74.0 % \n", - " \n", - "iteration: 5 \n", - "error: 35.6 \n", - "estimated linear overlap: 75.3 % \n", - "estimated area overlap: 74.1 % \n", - " \n", - "iteration: 6 \n", - "error: 36.1 \n", - "estimated linear overlap: 75.3 % \n", - "estimated area overlap: 74.3 % \n", - " \n", - "iteration: 7 \n", - "error: 35.6 \n", - "estimated linear overlap: 75.3 % \n", - "estimated area overlap: 74.3 % \n", - " \n", - "iteration: 8 \n", - "error: 34.9 \n", - "estimated linear overlap: 75.4 % \n", - "estimated area overlap: 75.0 % \n", - " \n", - "iteration: 9 \n", - "error: 34.9 \n", - "estimated linear overlap: 75.3 % \n", - "estimated area overlap: 74.6 % \n", - " \n", - "iteration: 10 \n", - "error: 35.1 \n", - "estimated linear overlap: 75.5 % \n", - "estimated area overlap: 74.4 % \n", - " \n", - "iteration: 11 \n", - "error: 34.4 \n", - "estimated linear overlap: 75.5 % \n", - "estimated area overlap: 74.9 % \n", - " \n", - "iteration: 12 \n", - "error: 35.1 \n", - "estimated linear overlap: 75.5 % \n", - "estimated area overlap: 74.5 % \n", - " \n", - "iteration: 13 \n", - "error: 34.0 \n", - "estimated linear overlap: 75.2 % \n", - "estimated area overlap: 74.6 % \n", - " \n", - "iteration: 14 \n", - "error: 33.6 \n", - "estimated linear overlap: 75.5 % \n", - "estimated area overlap: 75.2 % \n", - " \n", - "iteration: 15 \n", - "error: 33.4 \n", - "estimated linear overlap: 75.4 % \n", - "estimated area overlap: 75.2 % \n", - " \n", - "iteration: 16 \n", - "error: 32.1 \n", - "estimated linear overlap: 75.1 % \n", - "estimated area overlap: 75.9 % \n", - " \n", - "iteration: 17 \n", - "error: 33.5 \n", - "estimated linear overlap: 75.1 % \n", - "estimated area overlap: 74.9 % \n", - " \n", - "iteration: 18 \n", - "error: 34.3 \n", - "estimated linear overlap: 75.7 % \n", - "estimated area overlap: 75.2 % \n", - " \n", - "iteration: 19 \n", - "error: 32.6 \n", - "estimated linear overlap: 75.0 % \n", - "estimated area overlap: 75.0 % \n", - " \n", - "iteration: 20 \n", - "error: 32.4 \n", - "estimated linear overlap: 74.9 % \n", - "estimated area overlap: 75.0 % \n", - " \n", - "iteration: 21 \n", - "error: 33.0 \n", - "estimated linear overlap: 75.5 % \n", - "estimated area overlap: 75.0 % \n", - " \n", - "iteration: 22 \n", - "error: 32.5 \n", - "estimated linear overlap: 75.4 % \n", - "estimated area overlap: 74.8 % \n", - " \n", - "iteration: 23 \n", - "error: 31.9 \n", - "estimated linear overlap: 75.5 % \n", - "estimated area overlap: 75.4 % \n", - " \n", - "iteration: 24 \n", - "error: 32.0 \n", - "estimated linear overlap: 75.6 % \n", - "estimated area overlap: 75.4 % \n", - " \n", - "iteration: 25 \n", - "error: 31.7 \n", - "estimated linear overlap: 75.3 % \n", - "estimated area overlap: 76.2 % \n", - " \n", - "iteration: 26 \n", - "error: 31.7 \n", - "estimated linear overlap: 75.4 % \n", - "estimated area overlap: 75.2 % \n", - " \n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "iteration: 27 \n", - "error: 32.7 \n", - "estimated linear overlap: 75.3 % \n", - "estimated area overlap: 74.9 % \n", - " \n", - "iteration: 28 \n", - "error: 30.6 \n", - "estimated linear overlap: 74.6 % \n", - "estimated area overlap: 74.6 % \n", - " \n", - "iteration: 29 \n", - "error: 30.4 \n", - "estimated linear overlap: 75.5 % \n", - "estimated area overlap: 75.4 % \n", - " \n", - "iteration: 30 \n", - "error: 30.4 \n", - "estimated linear overlap: 75.0 % \n", - "estimated area overlap: 74.9 % \n", - " \n", - "iteration: 31 \n", - "error: 29.6 \n", - "estimated linear overlap: 75.1 % \n", - "estimated area overlap: 75.0 % \n", - " \n", - "iteration: 32 \n", - "error: 29.2 \n", - "estimated linear overlap: 75.1 % \n", - "estimated area overlap: 74.3 % \n", - " \n", - "iteration: 33 \n", - "error: 29.1 \n", - "estimated linear overlap: 74.9 % \n", - "estimated area overlap: 74.4 % \n", - " \n", - "iteration: 34 \n", - "error: 29.0 \n", - "estimated linear overlap: 74.6 % \n", - "estimated area overlap: 75.3 % \n", - " \n", - "iteration: 35 \n", - "error: 29.0 \n", - "estimated linear overlap: 74.9 % \n", - "estimated area overlap: 75.1 % \n", - " \n", - "iteration: 36 \n", - "error: 29.9 \n", - "estimated linear overlap: 74.8 % \n", - "estimated area overlap: 74.9 % \n", - " \n", - "iteration: 37 \n", - "error: 28.2 \n", - "estimated linear overlap: 74.6 % \n", - "estimated area overlap: 74.9 % \n", - " \n", - "iteration: 38 \n", - "error: 27.7 \n", - "estimated linear overlap: 74.5 % \n", - "estimated area overlap: 74.6 % \n", - " \n", - "iteration: 39 \n", - "error: 27.3 \n", - "estimated linear overlap: 74.6 % \n", - "estimated area overlap: 74.7 % \n", - " \n", - "iteration: 40 \n", - "error: 27.8 \n", - "estimated linear overlap: 74.8 % \n", - "estimated area overlap: 75.1 % \n", - " \n", - "iteration: 41 \n", - "error: 27.6 \n", - "estimated linear overlap: 75.1 % \n", - "estimated area overlap: 75.0 % \n", - " \n", - "iteration: 42 \n", - "error: 26.9 \n", - "estimated linear overlap: 74.7 % \n", - "estimated area overlap: 74.8 % \n", - " \n", - "iteration: 43 \n", - "error: 26.0 \n", - "estimated linear overlap: 74.4 % \n", - "estimated area overlap: 74.6 % \n", - " \n", - "iteration: 44 \n", - "error: 26.1 \n", - "estimated linear overlap: 74.3 % \n", - "estimated area overlap: 74.8 % \n", - " \n", - "iteration: 45 \n", - "error: 25.5 \n", - "estimated linear overlap: 74.6 % \n", - "estimated area overlap: 74.9 % \n", - " \n", - "iteration: 46 \n", - "error: 26.6 \n", - "estimated linear overlap: 74.9 % \n", - "estimated area overlap: 75.0 % \n", - " \n", - "iteration: 47 \n", - "error: 26.3 \n", - "estimated linear overlap: 75.0 % \n", - "estimated area overlap: 74.9 % \n", - " \n", - "iteration: 48 \n", - "error: 26.4 \n", - "estimated linear overlap: 74.5 % \n", - "estimated area overlap: 74.7 % \n", - " \n", - "iteration: 49 \n", - "error: 26.0 \n", - "estimated linear overlap: 74.5 % \n", - "estimated area overlap: 74.7 % \n", - " \n", - "iteration: 50 \n", - "error: 24.9 \n", - "estimated linear overlap: 74.6 % \n", - "estimated area overlap: 74.9 % \n", - " \n", - "iteration: 51 \n", - "error: 25.4 \n", - "estimated linear overlap: 74.4 % \n", - "estimated area overlap: 74.9 % \n", - " \n", - "iteration: 52 \n", - "error: 24.7 \n", - "estimated linear overlap: 74.3 % \n", - "estimated area overlap: 74.2 % \n", - " \n", - "iteration: 53 \n", - "error: 26.1 \n", - "estimated linear overlap: 74.4 % \n", - "estimated area overlap: 74.1 % \n", - " \n", - "iteration: 54 \n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "error: 25.1 \n", - "estimated linear overlap: 74.5 % \n", - "estimated area overlap: 73.7 % \n", - " \n", - "iteration: 55 \n", - "error: 24.2 \n", - "estimated linear overlap: 74.4 % \n", - "estimated area overlap: 73.8 % \n", - " \n", - "iteration: 56 \n", - "error: 24.7 \n", - "estimated linear overlap: 74.7 % \n", - "estimated area overlap: 74.1 % \n", - " \n", - "iteration: 57 \n", - "error: 25.1 \n", - "estimated linear overlap: 74.4 % \n", - "estimated area overlap: 73.7 % \n", - " \n", - "iteration: 58 \n", - "error: 24.1 \n", - "estimated linear overlap: 74.6 % \n", - "estimated area overlap: 73.8 % \n", - " \n", - "iteration: 59 \n", - "error: 24.6 \n", - "estimated linear overlap: 74.4 % \n", - "estimated area overlap: 73.8 % \n", - " \n", - "iteration: 60 \n", - "error: 24.5 \n", - "estimated linear overlap: 74.5 % \n", - "estimated area overlap: 74.1 % \n", - " \n", - "iteration: 61 \n", - "error: 23.4 \n", - "estimated linear overlap: 74.2 % \n", - "estimated area overlap: 73.7 % \n", - " \n", - "iteration: 62 \n", - "error: 24.3 \n", - "estimated linear overlap: 74.4 % \n", - "estimated area overlap: 74.1 % \n", - " \n", - "iteration: 63 \n", - "error: 24.2 \n", - "estimated linear overlap: 74.5 % \n", - "estimated area overlap: 74.2 % \n", - " \n", - "iteration: 64 \n", - "error: 23.7 \n", - "estimated linear overlap: 74.4 % \n", - "estimated area overlap: 73.8 % \n", - " \n", - "iteration: 65 \n", - "error: 23.9 \n", - "estimated linear overlap: 74.5 % \n", - "estimated area overlap: 73.7 % \n", - " \n", - "iteration: 66 \n", - "error: 23.4 \n", - "estimated linear overlap: 74.6 % \n", - "estimated area overlap: 73.8 % \n", - " \n", - "iteration: 67 \n", - "error: 23.2 \n", - "estimated linear overlap: 74.2 % \n", - "estimated area overlap: 73.7 % \n", - " \n", - "iteration: 68 \n", - "error: 23.0 \n", - "estimated linear overlap: 74.2 % \n", - "estimated area overlap: 73.8 % \n", - " \n", - "iteration: 69 \n", - "error: 23.6 \n", - "estimated linear overlap: 74.4 % \n", - "estimated area overlap: 75.4 % \n", - " \n", - "iteration: 70 \n", - "error: 25.2 \n", - "estimated linear overlap: 74.5 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 71 \n", - "error: 23.3 \n", - "estimated linear overlap: 74.6 % \n", - "estimated area overlap: 75.6 % \n", - " \n", - "iteration: 72 \n", - "error: 22.7 \n", - "estimated linear overlap: 74.2 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 73 \n", - "error: 22.6 \n", - "estimated linear overlap: 74.4 % \n", - "estimated area overlap: 75.6 % \n", - " \n", - "iteration: 74 \n", - "error: 22.2 \n", - "estimated linear overlap: 74.2 % \n", - "estimated area overlap: 75.9 % \n", - " \n", - "iteration: 75 \n", - "error: 22.6 \n", - "estimated linear overlap: 74.5 % \n", - "estimated area overlap: 75.6 % \n", - " \n", - "iteration: 76 \n", - "error: 22.8 \n", - "estimated linear overlap: 74.2 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 77 \n", - "error: 22.7 \n", - "estimated linear overlap: 74.5 % \n", - "estimated area overlap: 75.3 % \n", - " \n", - "iteration: 78 \n", - "error: 22.7 \n", - "estimated linear overlap: 74.4 % \n", - "estimated area overlap: 75.8 % \n", - " \n", - "iteration: 79 \n", - "error: 22.5 \n", - "estimated linear overlap: 74.2 % \n", - "estimated area overlap: 75.6 % \n", - " \n", - "iteration: 80 \n", - "error: 22.2 \n", - "estimated linear overlap: 74.3 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 81 \n", - "error: 22.1 \n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "estimated linear overlap: 74.2 % \n", - "estimated area overlap: 75.4 % \n", - " \n", - "iteration: 82 \n", - "error: 21.7 \n", - "estimated linear overlap: 74.3 % \n", - "estimated area overlap: 75.6 % \n", - " \n", - "iteration: 83 \n", - "error: 22.0 \n", - "estimated linear overlap: 74.3 % \n", - "estimated area overlap: 75.8 % \n", - " \n", - "iteration: 84 \n", - "error: 22.3 \n", - "estimated linear overlap: 74.2 % \n", - "estimated area overlap: 75.3 % \n", - " \n", - "iteration: 85 \n", - "error: 21.9 \n", - "estimated linear overlap: 74.3 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 86 \n", - "error: 21.5 \n", - "estimated linear overlap: 74.4 % \n", - "estimated area overlap: 75.7 % \n", - " \n", - "iteration: 87 \n", - "error: 22.0 \n", - "estimated linear overlap: 74.4 % \n", - "estimated area overlap: 75.4 % \n", - " \n", - "iteration: 88 \n", - "error: 21.5 \n", - "estimated linear overlap: 74.1 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 89 \n", - "error: 20.9 \n", - "estimated linear overlap: 74.1 % \n", - "estimated area overlap: 75.6 % \n", - " \n", - "iteration: 90 \n", - "error: 21.2 \n", - "estimated linear overlap: 74.3 % \n", - "estimated area overlap: 75.6 % \n", - " \n", - "iteration: 91 \n", - "error: 21.3 \n", - "estimated linear overlap: 74.2 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 92 \n", - "error: 21.5 \n", - "estimated linear overlap: 74.3 % \n", - "estimated area overlap: 75.7 % \n", - " \n", - "iteration: 93 \n", - "error: 21.1 \n", - "estimated linear overlap: 74.1 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 94 \n", - "error: 21.4 \n", - "estimated linear overlap: 74.2 % \n", - "estimated area overlap: 75.3 % \n", - " \n", - "iteration: 95 \n", - "error: 21.5 \n", - "estimated linear overlap: 74.4 % \n", - "estimated area overlap: 75.3 % \n", - " \n", - "iteration: 96 \n", - "error: 21.1 \n", - "estimated linear overlap: 74.2 % \n", - "estimated area overlap: 75.2 % \n", - " \n", - "iteration: 97 \n", - "error: 20.9 \n", - "estimated linear overlap: 74.3 % \n", - "estimated area overlap: 75.7 % \n", - " \n", - "iteration: 98 \n", - "error: 20.9 \n", - "estimated linear overlap: 74.4 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 99 \n", - "error: 21.3 \n", - "estimated linear overlap: 74.5 % \n", - "estimated area overlap: 75.3 % \n", - " \n", - "iteration: 100 \n", - "error: 20.6 \n", - "estimated linear overlap: 74.4 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 101 \n", - "error: 20.6 \n", - "estimated linear overlap: 74.1 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 102 \n", - "error: 20.5 \n", - "estimated linear overlap: 74.2 % \n", - "estimated area overlap: 75.6 % \n", - " \n", - "iteration: 103 \n", - "error: 20.3 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 104 \n", - "error: 20.1 \n", - "estimated linear overlap: 74.2 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 105 \n", - "error: 20.5 \n", - "estimated linear overlap: 74.4 % \n", - "estimated area overlap: 75.7 % \n", - " \n", - "iteration: 106 \n", - "error: 20.2 \n", - "estimated linear overlap: 74.2 % \n", - "estimated area overlap: 75.4 % \n", - " \n", - "iteration: 107 \n", - "error: 20.7 \n", - "estimated linear overlap: 74.2 % \n", - "estimated area overlap: 75.6 % \n", - " \n", - "iteration: 108 \n", - "error: 19.9 \n", - "estimated linear overlap: 74.2 % \n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 109 \n", - "error: 20.1 \n", - "estimated linear overlap: 74.2 % \n", - "estimated area overlap: 75.4 % \n", - " \n", - "iteration: 110 \n", - "error: 20.1 \n", - "estimated linear overlap: 74.4 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 111 \n", - "error: 20.0 \n", - "estimated linear overlap: 74.1 % \n", - "estimated area overlap: 75.3 % \n", - " \n", - "iteration: 112 \n", - "error: 19.9 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 113 \n", - "error: 19.7 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 114 \n", - "error: 20.1 \n", - "estimated linear overlap: 74.4 % \n", - "estimated area overlap: 75.3 % \n", - " \n", - "iteration: 115 \n", - "error: 20.2 \n", - "estimated linear overlap: 74.1 % \n", - "estimated area overlap: 75.6 % \n", - " \n", - "iteration: 116 \n", - "error: 19.5 \n", - "estimated linear overlap: 74.1 % \n", - "estimated area overlap: 75.7 % \n", - " \n", - "iteration: 117 \n", - "error: 18.9 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 75.6 % \n", - " \n", - "iteration: 118 \n", - "error: 19.5 \n", - "estimated linear overlap: 74.1 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 119 \n", - "error: 19.8 \n", - "estimated linear overlap: 74.2 % \n", - "estimated area overlap: 75.6 % \n", - " \n", - "iteration: 120 \n", - "error: 19.5 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 121 \n", - "error: 19.7 \n", - "estimated linear overlap: 74.1 % \n", - "estimated area overlap: 75.7 % \n", - " \n", - "iteration: 122 \n", - "error: 19.5 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 123 \n", - "error: 18.8 \n", - "estimated linear overlap: 73.9 % \n", - "estimated area overlap: 75.6 % \n", - " \n", - "iteration: 124 \n", - "error: 19.4 \n", - "estimated linear overlap: 74.2 % \n", - "estimated area overlap: 75.3 % \n", - " \n", - "iteration: 125 \n", - "error: 19.4 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 126 \n", - "error: 18.7 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 75.7 % \n", - " \n", - "iteration: 127 \n", - "error: 19.1 \n", - "estimated linear overlap: 74.1 % \n", - "estimated area overlap: 75.6 % \n", - " \n", - "iteration: 128 \n", - "error: 19.0 \n", - "estimated linear overlap: 74.1 % \n", - "estimated area overlap: 74.2 % \n", - " \n", - "iteration: 129 \n", - "error: 20.4 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 75.3 % \n", - " \n", - "iteration: 130 \n", - "error: 20.1 \n", - "estimated linear overlap: 74.1 % \n", - "estimated area overlap: 75.6 % \n", - " \n", - "iteration: 131 \n", - "error: 18.9 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 132 \n", - "error: 18.8 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 133 \n", - "error: 18.9 \n", - "estimated linear overlap: 74.1 % \n", - "estimated area overlap: 75.4 % \n", - " \n", - "iteration: 134 \n", - "error: 18.9 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 75.7 % \n", - " \n", - "iteration: 135 \n", - "error: 18.7 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 75.5 % \n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 136 \n", - "error: 18.7 \n", - "estimated linear overlap: 74.1 % \n", - "estimated area overlap: 75.4 % \n", - " \n", - "iteration: 137 \n", - "error: 18.5 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 75.6 % \n", - " \n", - "iteration: 138 \n", - "error: 18.3 \n", - "estimated linear overlap: 74.2 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 139 \n", - "error: 18.6 \n", - "estimated linear overlap: 74.1 % \n", - "estimated area overlap: 75.4 % \n", - " \n", - "iteration: 140 \n", - "error: 18.3 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 75.3 % \n", - " \n", - "iteration: 141 \n", - "error: 18.5 \n", - "estimated linear overlap: 74.1 % \n", - "estimated area overlap: 75.4 % \n", - " \n", - "iteration: 142 \n", - "error: 18.3 \n", - "estimated linear overlap: 74.1 % \n", - "estimated area overlap: 75.7 % \n", - " \n", - "iteration: 143 \n", - "error: 18.5 \n", - "estimated linear overlap: 74.1 % \n", - "estimated area overlap: 75.4 % \n", - " \n", - "iteration: 144 \n", - "error: 18.2 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 145 \n", - "error: 18.0 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 146 \n", - "error: 18.2 \n", - "estimated linear overlap: 73.9 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 147 \n", - "error: 18.1 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 75.6 % \n", - " \n", - "iteration: 148 \n", - "error: 17.8 \n", - "estimated linear overlap: 73.9 % \n", - "estimated area overlap: 75.7 % \n", - " \n", - "iteration: 149 \n", - "error: 17.7 \n", - "estimated linear overlap: 73.9 % \n", - "estimated area overlap: 75.6 % \n", - " \n", - "iteration: 150 \n", - "error: 17.9 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 75.4 % \n", - " \n", - "iteration: 151 \n", - "error: 18.3 \n", - "estimated linear overlap: 74.2 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 152 \n", - "error: 18.3 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 153 \n", - "error: 18.1 \n", - "estimated linear overlap: 73.9 % \n", - "estimated area overlap: 75.6 % \n", - " \n", - "iteration: 154 \n", - "error: 17.8 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 75.7 % \n", - " \n", - "iteration: 155 \n", - "error: 17.6 \n", - "estimated linear overlap: 73.9 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 156 \n", - "error: 17.9 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 75.4 % \n", - " \n", - "iteration: 157 \n", - "error: 17.8 \n", - "estimated linear overlap: 74.1 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 158 \n", - "error: 17.7 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 75.5 % \n", - " \n", - "iteration: 159 \n", - "error: 17.6 \n", - "estimated linear overlap: 74.1 % \n", - "estimated area overlap: 74.2 % \n", - " \n", - "iteration: 160 \n", - "error: 18.9 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 74.1 % \n", - " \n", - "iteration: 161 \n", - "error: 18.0 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 74.0 % \n", - " \n", - "iteration: 162 \n", - "error: 17.3 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 74.2 % \n", - " \n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "iteration: 163 \n", - "error: 17.2 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 74.2 % \n", - " \n", - "iteration: 164 \n", - "error: 17.5 \n", - "estimated linear overlap: 74.1 % \n", - "estimated area overlap: 74.1 % \n", - " \n", - "iteration: 165 \n", - "error: 17.3 \n", - "estimated linear overlap: 74.1 % \n", - "estimated area overlap: 74.2 % \n", - " \n", - "iteration: 166 \n", - "error: 17.4 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 74.1 % \n", - " \n", - "iteration: 167 \n", - "error: 17.1 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 74.2 % \n", - " \n", - "iteration: 168 \n", - "error: 17.1 \n", - "estimated linear overlap: 73.9 % \n", - "estimated area overlap: 74.1 % \n", - " \n", - "iteration: 169 \n", - "error: 17.3 \n", - "estimated linear overlap: 74.2 % \n", - "estimated area overlap: 74.4 % \n", - " \n", - "iteration: 170 \n", - "error: 17.6 \n", - "estimated linear overlap: 73.9 % \n", - "estimated area overlap: 74.3 % \n", - " \n", - "iteration: 171 \n", - "error: 17.0 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 74.4 % \n", - " \n", - "iteration: 172 \n", - "error: 17.2 \n", - "estimated linear overlap: 73.9 % \n", - "estimated area overlap: 74.1 % \n", - " \n", - "iteration: 173 \n", - "error: 17.3 \n", - "estimated linear overlap: 73.9 % \n", - "estimated area overlap: 74.1 % \n", - " \n", - "iteration: 174 \n", - "error: 17.0 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 74.1 % \n", - " \n", - "iteration: 175 \n", - "error: 17.2 \n", - "estimated linear overlap: 73.9 % \n", - "estimated area overlap: 74.2 % \n", - " \n", - "iteration: 176 \n", - "error: 17.2 \n", - "estimated linear overlap: 73.9 % \n", - "estimated area overlap: 74.2 % \n", - " \n", - "iteration: 177 \n", - "error: 16.9 \n", - "estimated linear overlap: 73.9 % \n", - "estimated area overlap: 74.2 % \n", - " \n", - "iteration: 178 \n", - "error: 17.3 \n", - "estimated linear overlap: 73.8 % \n", - "estimated area overlap: 74.1 % \n", - " \n", - "iteration: 179 \n", - "error: 16.5 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 74.1 % \n", - " \n", - "iteration: 180 \n", - "error: 16.8 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 74.3 % \n", - " \n", - "iteration: 181 \n", - "error: 16.8 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 74.3 % \n", - " \n", - "iteration: 182 \n", - "error: 16.3 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 74.4 % \n", - " \n", - "iteration: 183 \n", - "error: 16.7 \n", - "estimated linear overlap: 74.2 % \n", - "estimated area overlap: 74.2 % \n", - " \n", - "iteration: 184 \n", - "error: 17.0 \n", - "estimated linear overlap: 73.9 % \n", - "estimated area overlap: 74.1 % \n", - " \n", - "iteration: 185 \n", - "error: 17.0 \n", - "estimated linear overlap: 74.1 % \n", - "estimated area overlap: 74.3 % \n", - " \n", - "iteration: 186 \n", - "error: 16.8 \n", - "estimated linear overlap: 73.9 % \n", - "estimated area overlap: 74.4 % \n", - " \n", - "iteration: 187 \n", - "error: 16.5 \n", - "estimated linear overlap: 73.8 % \n", - "estimated area overlap: 74.3 % \n", - " \n", - "iteration: 188 \n", - "error: 17.0 \n", - "estimated linear overlap: 73.9 % \n", - "estimated area overlap: 74.2 % \n", - " \n", - "iteration: 189 \n", - "error: 16.9 \n", - "estimated linear overlap: 73.9 % \n", - "estimated area overlap: 74.3 % \n", - " \n", - "iteration: 190 \n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "error: 16.4 \n", - "estimated linear overlap: 73.9 % \n", - "estimated area overlap: 74.2 % \n", - " \n", - "iteration: 191 \n", - "error: 16.4 \n", - "estimated linear overlap: 73.8 % \n", - "estimated area overlap: 74.4 % \n", - " \n", - "iteration: 192 \n", - "error: 16.6 \n", - "estimated linear overlap: 73.9 % \n", - "estimated area overlap: 74.2 % \n", - " \n", - "iteration: 193 \n", - "error: 16.8 \n", - "estimated linear overlap: 73.8 % \n", - "estimated area overlap: 74.1 % \n", - " \n", - "iteration: 194 \n", - "error: 16.3 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 74.5 % \n", - " \n", - "iteration: 195 \n", - "error: 16.4 \n", - "estimated linear overlap: 73.8 % \n", - "estimated area overlap: 74.3 % \n", - " \n", - "iteration: 196 \n", - "error: 15.9 \n", - "estimated linear overlap: 74.1 % \n", - "estimated area overlap: 74.4 % \n", - " \n", - "iteration: 197 \n", - "error: 16.4 \n", - "estimated linear overlap: 73.9 % \n", - "estimated area overlap: 74.2 % \n", - " \n", - "iteration: 198 \n", - "error: 16.3 \n", - "estimated linear overlap: 74.0 % \n", - "estimated area overlap: 74.2 % \n", - " \n", - "iteration: 199 \n", - "error: 16.2 \n", - "estimated linear overlap: 73.8 % \n", - "estimated area overlap: 74.3 % \n", - "mPIE: 100%|██████████████████████████████████████████████████████████████████████████| 200/200 [01:35<00:00, 2.10it/s]\n" + "\n" ] } ], "source": [ - "params.intensityConstraint = 'interferometric' \n", + "params.intensityConstraint = \"interferometric\"\n", "\n", "mPIE = Engines.mPIE(reconstruction, experimentalData, params, monitor)\n", "mPIE.numIterations = 200\n", @@ -7325,25 +447,18 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 41, "metadata": {}, "outputs": [], "source": [ "## now save the data\n", "# reconstruction.saveResults('reconstruction.hdf5')" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "ptylab", "language": "python", "name": "python3" }, @@ -7357,7 +472,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.13.12" } }, "nbformat": 4, diff --git a/jupyter_tutorials/jupyter_tutorials_tutorial_reflectionPtychography.ipynb b/jupyter_tutorials/jupyter_tutorials_tutorial_reflectionPtychography.ipynb index e163d45d..69b7fce6 100644 --- a/jupyter_tutorials/jupyter_tutorials_tutorial_reflectionPtychography.ipynb +++ b/jupyter_tutorials/jupyter_tutorials_tutorial_reflectionPtychography.ipynb @@ -4,19 +4,29 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Reflection ptychography\n", - " - This tutorial shows a reconstruction with a reflection dataset measusred with a two-layer sample at 708 nm, which is used in the publication: \"Mengqi Du, Lars Loetgering, Kjeld S.E. Eikema, and Stefan Witte. \"Ptychographic optical coherence tomography.\" Optics Letters 46, no. 6 (2021): 1337-1340.\" \n", - " - Download the dataset from figshare: https://figshare.com/articles/dataset/ptyLab_example_data/14915628\n", - " - A kind suggestion: check out general tutorials for CPM (conventional ptychographic microscopy) before diving into this one." + "# 05 – CPM Reflection\n", + "\n", + "This tutorial demonstrates ptychographic reconstruction in reflection geometry using a two-layer sample measured at 708 nm. It shows how to set up the `aPIE` engine for datasets acquired at a tilt angle.\n", + "\n", + "**What you'll learn:**\n", + "\n", + "- How to configure ptychography for reflection geometry\n", + "- How to use the tilt angle parameter (`theta`) in the data\n", + "- How to run `aPIE` for angle-correcting reconstruction\n", + "\n", + "!!! note \"Dataset\"\n", + " The dataset (`TwoLayer_bin4.hdf5`) is downloaded automatically into the `example_data/` folder at the project root the first time you run the notebook. If the file already exists it is not re-downloaded.\n", + "\n", + "!!! tip \"Prerequisites\"\n", + " Complete [01 – CPM Simulation](tutorial_CPM_sim.ipynb) before this tutorial." ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ - "%matplotlib notebook\n", "import matplotlib\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", @@ -26,7 +36,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -43,21 +53,38 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Step 1: Download the preprocessed data from figshare: https://figshare.com/articles/dataset/ptyLab_example_data/14915628" + "The dataset (`TwoLayer_bin4.hdf5`) is downloaded automatically into the `example_data/` folder at the project root the first time you run the next cell. If the file already exists it is not re-downloaded." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TwoLayer_bin4.hdf5 found, skipping download.\n" + ] + } + ], "source": [ - "# set your data folder as fileFolder \n", - "fileFolder = Path(r\"D:\\Du\\FigshareData\")\n", - "# select the hdf5 file\n", + "from PtyLab.io import getExampleDataFolder\n", + "import urllib.request\n", + "\n", "fileName = \"TwoLayer_bin4.hdf5\"\n", - "# create the complete filePath\n", - "filePath = Path.joinpath(fileFolder,fileName)" + "filePath = getExampleDataFolder() / fileName\n", + "\n", + "if not filePath.exists():\n", + " print(f\"Downloading {fileName}...\")\n", + " urllib.request.urlretrieve(\n", + " \"https://ndownloader.figshare.com/files/28720086\",\n", + " filePath,\n", + " )\n", + " print(\"Download complete.\")\n", + "else:\n", + " print(f\"{fileName} found, skipping download.\")" ] }, { @@ -69,25 +96,22 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\"Unable to open object (object 'orientation' doesn't exist)\"\n", - "Min max ptychogram: 0.0, 12029.697265625\n", - "Min max ptychogram: 0.0, 4.080290798564943\n", - "0.0 4.080290798564943\n" + "Found encoder with shape (202, 2)\n" ] } ], "source": [ "# Initialize the ExperimentalData using the filePath, and choose the operation Mode (default is 'CPM')\n", - "experimentalData = ExperimentalData(filePath, operationMode='CPM')\n", + "experimentalData = ExperimentalData(filePath, operationMode=\"CPM\")\n", "# show measured ptychogram in log scale. Need to close the window to continue\n", - "experimentalData.showPtychogram()" + "# experimentalData.showPtychogram()" ] }, { @@ -99,20 +123,33 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/mnt/home/shantanu/projects/PtyLab.py/PtyLab/Monitor/Monitor.py:191: UserWarning: For diffraction data plot, preferably use an interactive matplotlib backend or set `monitor.verboseLevel = \"low\"`. \n", + " warnings.warn(\n" + ] + } + ], "source": [ "# Initialize the Monitor class\n", "monitor = Monitor()\n", "# Set monitor properties\n", - "monitor.figureUpdateFrequency = 1 \n", - "monitor.objectPlot = 'complex' # complex abs angle\n", - "monitor.verboseLevel = 'high' # high: plot two figures, low: plot only one figure\n", + "monitor.figureUpdateFrequency = 5\n", + "monitor.objectPlot = \"complex\" # complex abs angle\n", + "monitor.verboseLevel = \"high\" # high: plot two figures, low: plot only one figure\n", "monitor.probeZoom = 1 # control probe plot FoV\n", - "monitor.objectZoom = 2 # control object plot FoV\n", - "monitor.objectContrast = 0.8 # control object plot contrast, 0-1, higher constrast with smaller number\n", - "monitor.probeContrast = 0.5 # control probe plot contrast, 0-1, higher constrast with smaller number" + "monitor.objectZoom = 2 # control object plot FoV\n", + "monitor.objectPlotContrast = (\n", + " 0.8 # control object plot contrast, 0-1, higher constrast with smaller number\n", + ")\n", + "monitor.probePlotContrast = (\n", + " 0.5 # control probe plot contrast, 0-1, higher constrast with smaller number\n", + ")" ] }, { @@ -124,21 +161,31 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:GPU:cupy and CUDA available, switching to GPU\n" + ] + } + ], "source": [ "# Initialize the Params class\n", "params = Params()\n", "# Set params properties\n", "params.gpuSwitch = True\n", - "params.positionOrder = 'random' # 'sequential' or 'random'\n", - "params.propagator = 'Fraunhofer' # Fraunhofer Fresnel ASP scaledASP polychromeASP scaledPolychromeASP\n", + "params.positionOrder = \"random\" # 'sequential' or 'random'\n", + "params.propagator = (\n", + " \"Fraunhofer\" # Fraunhofer Fresnel ASP scaledASP polychromeASP scaledPolychromeASP\n", + ")\n", "params.probePowerCorrectionSwitch = True\n", "params.comStabilizationSwitch = True\n", "params.fftshiftSwitch = False\n", "params.backgroundModeSwitch = True\n", - "params.intensityConstraint = 'standard' " + "params.intensityConstraint = \"standard\"" ] }, { @@ -150,18 +197,20 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "Copying attribute wavelength\n", - "Copying attribute dxd\n", - "Copying attribute theta\n", - "Copying attribute spectralDensity\n", - "Copying attribute entrancePupilDiameter\n" + "INFO:Reconstruction:Copying attribute wavelength\n", + "INFO:Reconstruction:Copying attribute dxd\n", + "INFO:Reconstruction:Copying attribute theta\n", + "INFO:Reconstruction:Copying attribute spectralDensity\n", + "INFO:Reconstruction:Copying attribute entrancePupilDiameter\n", + "INFO:Reconstruction:Initial object set to ones\n", + "INFO:Reconstruction:Initial probe set to circ\n" ] } ], @@ -171,14 +220,20 @@ "# reconstruction.No = 2**11\n", "\n", "# choose the inital format of the probe and object, and initialize them\n", - "reconstruction.initialProbe = 'circ'\n", - "reconstruction.initialObject = 'ones'\n", + "reconstruction.initialProbe = \"circ\"\n", + "reconstruction.initialObject = \"ones\"\n", "reconstruction.initializeObjectProbe()\n", "\n", - "# Optional: customize initial probe quadratic phase: \n", + "# Optional: customize initial probe quadratic phase:\n", "# since we know our beam is divergent, we add a diverging wavefront to the initial beam\n", - "reconstruction.probe = reconstruction.probe*np.exp(1.j*2*np.pi/reconstruction.wavelength *\n", - " (reconstruction.Xp**2+reconstruction.Yp**2)/(3*6e-3))" + "reconstruction.probe = reconstruction.probe * np.exp(\n", + " 1.0j\n", + " * 2\n", + " * np.pi\n", + " / reconstruction.wavelength\n", + " * (reconstruction.Xp**2 + reconstruction.Yp**2)\n", + " / (3 * 6e-3)\n", + ")" ] }, { @@ -190,1954 +245,16 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "metadata": { "scrolled": true }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "d:\\du\\ptylab\\PtyLab\\Engines\\BaseEngine.py:376: UserWarning: fftshiftSwitch set to false, this may lead to reduced performance\n", - " warnings.warn(\n" - ] - }, - { - "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "/* global mpl */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function () {\n", - " if (typeof WebSocket !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof MozWebSocket !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert(\n", - " 'Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.'\n", - " );\n", - " }\n", - "};\n", - "\n", - "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = this.ws.binaryType !== undefined;\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById('mpl-warnings');\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent =\n", - " 'This browser does not support binary websocket messages. ' +\n", - " 'Performance may be slow.';\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = document.createElement('div');\n", - " this.root.setAttribute('style', 'display: inline-block');\n", - " this._root_extra_style(this.root);\n", - "\n", - " parent_element.appendChild(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message('supports_binary', { value: fig.supports_binary });\n", - " fig.send_message('send_image_mode', {});\n", - " if (fig.ratio !== 1) {\n", - " fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });\n", - " }\n", - " fig.send_message('refresh', {});\n", - " };\n", - "\n", - " this.imageObj.onload = function () {\n", - " if (fig.image_mode === 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function () {\n", - " fig.ws.close();\n", - " };\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "};\n", - "\n", - "mpl.figure.prototype._init_header = function () {\n", - " var titlebar = document.createElement('div');\n", - " titlebar.classList =\n", - " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", - " var titletext = document.createElement('div');\n", - " titletext.classList = 'ui-dialog-title';\n", - " titletext.setAttribute(\n", - " 'style',\n", - " 'width: 100%; text-align: center; padding: 3px;'\n", - " );\n", - " titlebar.appendChild(titletext);\n", - " this.root.appendChild(titlebar);\n", - " this.header = titletext;\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._init_canvas = function () {\n", - " var fig = this;\n", - "\n", - " var canvas_div = (this.canvas_div = document.createElement('div'));\n", - " canvas_div.setAttribute(\n", - " 'style',\n", - " 'border: 1px solid #ddd;' +\n", - " 'box-sizing: content-box;' +\n", - " 'clear: both;' +\n", - " 'min-height: 1px;' +\n", - " 'min-width: 1px;' +\n", - " 'outline: 0;' +\n", - " 'overflow: hidden;' +\n", - " 'position: relative;' +\n", - " 'resize: both;'\n", - " );\n", - "\n", - " function on_keyboard_event_closure(name) {\n", - " return function (event) {\n", - " return fig.key_event(event, name);\n", - " };\n", - " }\n", - "\n", - " canvas_div.addEventListener(\n", - " 'keydown',\n", - " on_keyboard_event_closure('key_press')\n", - " );\n", - " canvas_div.addEventListener(\n", - " 'keyup',\n", - " on_keyboard_event_closure('key_release')\n", - " );\n", - "\n", - " this._canvas_extra_style(canvas_div);\n", - " this.root.appendChild(canvas_div);\n", - "\n", - " var canvas = (this.canvas = document.createElement('canvas'));\n", - " canvas.classList.add('mpl-canvas');\n", - " canvas.setAttribute('style', 'box-sizing: content-box;');\n", - "\n", - " this.context = canvas.getContext('2d');\n", - "\n", - " var backingStore =\n", - " this.context.backingStorePixelRatio ||\n", - " this.context.webkitBackingStorePixelRatio ||\n", - " this.context.mozBackingStorePixelRatio ||\n", - " this.context.msBackingStorePixelRatio ||\n", - " this.context.oBackingStorePixelRatio ||\n", - " this.context.backingStorePixelRatio ||\n", - " 1;\n", - "\n", - " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", - " 'canvas'\n", - " ));\n", - " rubberband_canvas.setAttribute(\n", - " 'style',\n", - " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", - " );\n", - "\n", - " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", - " if (this.ResizeObserver === undefined) {\n", - " if (window.ResizeObserver !== undefined) {\n", - " this.ResizeObserver = window.ResizeObserver;\n", - " } else {\n", - " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", - " this.ResizeObserver = obs.ResizeObserver;\n", - " }\n", - " }\n", - "\n", - " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", - " var nentries = entries.length;\n", - " for (var i = 0; i < nentries; i++) {\n", - " var entry = entries[i];\n", - " var width, height;\n", - " if (entry.contentBoxSize) {\n", - " if (entry.contentBoxSize instanceof Array) {\n", - " // Chrome 84 implements new version of spec.\n", - " width = entry.contentBoxSize[0].inlineSize;\n", - " height = entry.contentBoxSize[0].blockSize;\n", - " } else {\n", - " // Firefox implements old version of spec.\n", - " width = entry.contentBoxSize.inlineSize;\n", - " height = entry.contentBoxSize.blockSize;\n", - " }\n", - " } else {\n", - " // Chrome <84 implements even older version of spec.\n", - " width = entry.contentRect.width;\n", - " height = entry.contentRect.height;\n", - " }\n", - "\n", - " // Keep the size of the canvas and rubber band canvas in sync with\n", - " // the canvas container.\n", - " if (entry.devicePixelContentBoxSize) {\n", - " // Chrome 84 implements new version of spec.\n", - " canvas.setAttribute(\n", - " 'width',\n", - " entry.devicePixelContentBoxSize[0].inlineSize\n", - " );\n", - " canvas.setAttribute(\n", - " 'height',\n", - " entry.devicePixelContentBoxSize[0].blockSize\n", - " );\n", - " } else {\n", - " canvas.setAttribute('width', width * fig.ratio);\n", - " canvas.setAttribute('height', height * fig.ratio);\n", - " }\n", - " canvas.setAttribute(\n", - " 'style',\n", - " 'width: ' + width + 'px; height: ' + height + 'px;'\n", - " );\n", - "\n", - " rubberband_canvas.setAttribute('width', width);\n", - " rubberband_canvas.setAttribute('height', height);\n", - "\n", - " // And update the size in Python. We ignore the initial 0/0 size\n", - " // that occurs as the element is placed into the DOM, which should\n", - " // otherwise not happen due to the minimum size styling.\n", - " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", - " fig.request_resize(width, height);\n", - " }\n", - " }\n", - " });\n", - " this.resizeObserverInstance.observe(canvas_div);\n", - "\n", - " function on_mouse_event_closure(name) {\n", - " return function (event) {\n", - " return fig.mouse_event(event, name);\n", - " };\n", - " }\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mousedown',\n", - " on_mouse_event_closure('button_press')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseup',\n", - " on_mouse_event_closure('button_release')\n", - " );\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband_canvas.addEventListener(\n", - " 'mousemove',\n", - " on_mouse_event_closure('motion_notify')\n", - " );\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseenter',\n", - " on_mouse_event_closure('figure_enter')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseleave',\n", - " on_mouse_event_closure('figure_leave')\n", - " );\n", - "\n", - " canvas_div.addEventListener('wheel', function (event) {\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " on_mouse_event_closure('scroll')(event);\n", - " });\n", - "\n", - " canvas_div.appendChild(canvas);\n", - " canvas_div.appendChild(rubberband_canvas);\n", - "\n", - " this.rubberband_context = rubberband_canvas.getContext('2d');\n", - " this.rubberband_context.strokeStyle = '#000000';\n", - "\n", - " this._resize_canvas = function (width, height, forward) {\n", - " if (forward) {\n", - " canvas_div.style.width = width + 'px';\n", - " canvas_div.style.height = height + 'px';\n", - " }\n", - " };\n", - "\n", - " // Disable right mouse context menu.\n", - " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", - " event.preventDefault();\n", - " return false;\n", - " });\n", - "\n", - " function set_focus() {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'mpl-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " continue;\n", - " }\n", - "\n", - " var button = (fig.buttons[name] = document.createElement('button'));\n", - " button.classList = 'mpl-widget';\n", - " button.setAttribute('role', 'button');\n", - " button.setAttribute('aria-disabled', 'false');\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - "\n", - " var icon_img = document.createElement('img');\n", - " icon_img.src = '_images/' + image + '.png';\n", - " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", - " icon_img.alt = tooltip;\n", - " button.appendChild(icon_img);\n", - "\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " var fmt_picker = document.createElement('select');\n", - " fmt_picker.classList = 'mpl-widget';\n", - " toolbar.appendChild(fmt_picker);\n", - " this.format_dropdown = fmt_picker;\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = document.createElement('option');\n", - " option.selected = fmt === mpl.default_extension;\n", - " option.innerHTML = fmt;\n", - " fmt_picker.appendChild(option);\n", - " }\n", - "\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "};\n", - "\n", - "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", - "};\n", - "\n", - "mpl.figure.prototype.send_message = function (type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "};\n", - "\n", - "mpl.figure.prototype.send_draw_message = function () {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1], msg['forward']);\n", - " fig.send_message('refresh', {});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", - " var x0 = msg['x0'] / fig.ratio;\n", - " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", - " var x1 = msg['x1'] / fig.ratio;\n", - " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0,\n", - " 0,\n", - " fig.canvas.width / fig.ratio,\n", - " fig.canvas.height / fig.ratio\n", - " );\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", - " var cursor = msg['cursor'];\n", - " switch (cursor) {\n", - " case 0:\n", - " cursor = 'pointer';\n", - " break;\n", - " case 1:\n", - " cursor = 'default';\n", - " break;\n", - " case 2:\n", - " cursor = 'crosshair';\n", - " break;\n", - " case 3:\n", - " cursor = 'move';\n", - " break;\n", - " }\n", - " fig.rubberband_canvas.style.cursor = cursor;\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_message = function (fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", - " for (var key in msg) {\n", - " if (!(key in fig.buttons)) {\n", - " continue;\n", - " }\n", - " fig.buttons[key].disabled = !msg[key];\n", - " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", - " if (msg['mode'] === 'PAN') {\n", - " fig.buttons['Pan'].classList.add('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " } else if (msg['mode'] === 'ZOOM') {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.add('active');\n", - " } else {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message('ack', {});\n", - "};\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function (fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " evt.data.type = 'image/png';\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src\n", - " );\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " evt.data\n", - " );\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " } else if (\n", - " typeof evt.data === 'string' &&\n", - " evt.data.slice(0, 21) === 'data:image/png;base64'\n", - " ) {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig['handle_' + msg_type];\n", - " } catch (e) {\n", - " console.log(\n", - " \"No handler for the '\" + msg_type + \"' message type: \",\n", - " msg\n", - " );\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\n", - " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", - " e,\n", - " e.stack,\n", - " msg\n", - " );\n", - " }\n", - " }\n", - " };\n", - "};\n", - "\n", - "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function (e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e) {\n", - " e = window.event;\n", - " }\n", - " if (e.target) {\n", - " targ = e.target;\n", - " } else if (e.srcElement) {\n", - " targ = e.srcElement;\n", - " }\n", - " if (targ.nodeType === 3) {\n", - " // defeat Safari bug\n", - " targ = targ.parentNode;\n", - " }\n", - "\n", - " // pageX,Y are the mouse positions relative to the document\n", - " var boundingRect = targ.getBoundingClientRect();\n", - " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", - " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n", - "\n", - " return { x: x, y: y };\n", - "};\n", - "\n", - "/*\n", - " * return a copy of an object with only non-object keys\n", - " * we need this to avoid circular references\n", - " * http://stackoverflow.com/a/24161582/3208463\n", - " */\n", - "function simpleKeys(original) {\n", - " return Object.keys(original).reduce(function (obj, key) {\n", - " if (typeof original[key] !== 'object') {\n", - " obj[key] = original[key];\n", - " }\n", - " return obj;\n", - " }, {});\n", - "}\n", - "\n", - "mpl.figure.prototype.mouse_event = function (event, name) {\n", - " var canvas_pos = mpl.findpos(event);\n", - "\n", - " if (name === 'button_press') {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x * this.ratio;\n", - " var y = canvas_pos.y * this.ratio;\n", - "\n", - " this.send_message(name, {\n", - " x: x,\n", - " y: y,\n", - " button: event.button,\n", - " step: event.step,\n", - " guiEvent: simpleKeys(event),\n", - " });\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "};\n", - "\n", - "mpl.figure.prototype.key_event = function (event, name) {\n", - " // Prevent repeat events\n", - " if (name === 'key_press') {\n", - " if (event.which === this._key) {\n", - " return;\n", - " } else {\n", - " this._key = event.which;\n", - " }\n", - " }\n", - " if (name === 'key_release') {\n", - " this._key = null;\n", - " }\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.which !== 17) {\n", - " value += 'ctrl+';\n", - " }\n", - " if (event.altKey && event.which !== 18) {\n", - " value += 'alt+';\n", - " }\n", - " if (event.shiftKey && event.which !== 16) {\n", - " value += 'shift+';\n", - " }\n", - "\n", - " value += 'k';\n", - " value += event.which.toString();\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", - " if (name === 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message('toolbar_button', { name: name });\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "\n", - "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", - "// prettier-ignore\n", - "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", - "\n", - "mpl.default_extension = \"png\";/* global mpl */\n", - "\n", - "var comm_websocket_adapter = function (comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.close = function () {\n", - " comm.close();\n", - " };\n", - " ws.send = function (m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function (msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", - " ws.onmessage(msg['content']['data']);\n", - " });\n", - " return ws;\n", - "};\n", - "\n", - "mpl.mpl_figure_comm = function (comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = document.getElementById(id);\n", - " var ws_proxy = comm_websocket_adapter(comm);\n", - "\n", - " function ondownload(figure, _format) {\n", - " window.open(figure.canvas.toDataURL());\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element;\n", - " fig.cell_info = mpl.find_output_cell(\"
\");\n", - " if (!fig.cell_info) {\n", - " console.error('Failed to find cell for figure', id, fig);\n", - " return;\n", - " }\n", - " fig.cell_info[0].output_area.element.on(\n", - " 'cleared',\n", - " { fig: fig },\n", - " fig._remove_fig_handler\n", - " );\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function (fig, msg) {\n", - " var width = fig.canvas.width / fig.ratio;\n", - " fig.cell_info[0].output_area.element.off(\n", - " 'cleared',\n", - " fig._remove_fig_handler\n", - " );\n", - " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", - "\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable();\n", - " fig.parent_element.innerHTML =\n", - " '';\n", - " fig.close_ws(fig, msg);\n", - "};\n", - "\n", - "mpl.figure.prototype.close_ws = function (fig, msg) {\n", - " fig.send_message('closing', msg);\n", - " // fig.ws.close()\n", - "};\n", - "\n", - "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var width = this.canvas.width / this.ratio;\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] =\n", - " '';\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message('ack', {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () {\n", - " fig.push_to_output();\n", - " }, 1000);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'btn-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " var button;\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " continue;\n", - " }\n", - "\n", - " button = fig.buttons[name] = document.createElement('button');\n", - " button.classList = 'btn btn-default';\n", - " button.href = '#';\n", - " button.title = name;\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message pull-right';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = document.createElement('div');\n", - " buttongrp.classList = 'btn-group inline pull-right';\n", - " button = document.createElement('button');\n", - " button.classList = 'btn btn-mini btn-primary';\n", - " button.href = '#';\n", - " button.title = 'Stop Interaction';\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', function (_evt) {\n", - " fig.handle_close(fig, {});\n", - " });\n", - " button.addEventListener(\n", - " 'mouseover',\n", - " on_mouseover_closure('Stop Interaction')\n", - " );\n", - " buttongrp.appendChild(button);\n", - " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", - " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", - "};\n", - "\n", - "mpl.figure.prototype._remove_fig_handler = function (event) {\n", - " var fig = event.data.fig;\n", - " if (event.target !== this) {\n", - " // Ignore bubbled events from children.\n", - " return;\n", - " }\n", - " fig.close_ws(fig, {});\n", - "};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (el) {\n", - " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (el) {\n", - " // this is important to make the div 'focusable\n", - " el.setAttribute('tabindex', 0);\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " } else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", - " var manager = IPython.notebook.keyboard_manager;\n", - " if (!manager) {\n", - " manager = IPython.keyboard_manager;\n", - " }\n", - "\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which === 13) {\n", - " this.canvas_div.blur();\n", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " fig.ondownload(fig, null);\n", - "};\n", - "\n", - "mpl.find_output_cell = function (html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i = 0; i < ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code') {\n", - " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] === html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "};\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel !== null) {\n", - " IPython.notebook.kernel.comm_manager.register_target(\n", - " 'matplotlib',\n", - " mpl.mpl_figure_comm\n", - " );\n", - "}\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/javascript": [ - "/* Put everything inside the global mpl namespace */\n", - "/* global mpl */\n", - "window.mpl = {};\n", - "\n", - "mpl.get_websocket_type = function () {\n", - " if (typeof WebSocket !== 'undefined') {\n", - " return WebSocket;\n", - " } else if (typeof MozWebSocket !== 'undefined') {\n", - " return MozWebSocket;\n", - " } else {\n", - " alert(\n", - " 'Your browser does not have WebSocket support. ' +\n", - " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", - " 'Firefox 4 and 5 are also supported but you ' +\n", - " 'have to enable WebSockets in about:config.'\n", - " );\n", - " }\n", - "};\n", - "\n", - "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", - " this.id = figure_id;\n", - "\n", - " this.ws = websocket;\n", - "\n", - " this.supports_binary = this.ws.binaryType !== undefined;\n", - "\n", - " if (!this.supports_binary) {\n", - " var warnings = document.getElementById('mpl-warnings');\n", - " if (warnings) {\n", - " warnings.style.display = 'block';\n", - " warnings.textContent =\n", - " 'This browser does not support binary websocket messages. ' +\n", - " 'Performance may be slow.';\n", - " }\n", - " }\n", - "\n", - " this.imageObj = new Image();\n", - "\n", - " this.context = undefined;\n", - " this.message = undefined;\n", - " this.canvas = undefined;\n", - " this.rubberband_canvas = undefined;\n", - " this.rubberband_context = undefined;\n", - " this.format_dropdown = undefined;\n", - "\n", - " this.image_mode = 'full';\n", - "\n", - " this.root = document.createElement('div');\n", - " this.root.setAttribute('style', 'display: inline-block');\n", - " this._root_extra_style(this.root);\n", - "\n", - " parent_element.appendChild(this.root);\n", - "\n", - " this._init_header(this);\n", - " this._init_canvas(this);\n", - " this._init_toolbar(this);\n", - "\n", - " var fig = this;\n", - "\n", - " this.waiting = false;\n", - "\n", - " this.ws.onopen = function () {\n", - " fig.send_message('supports_binary', { value: fig.supports_binary });\n", - " fig.send_message('send_image_mode', {});\n", - " if (fig.ratio !== 1) {\n", - " fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });\n", - " }\n", - " fig.send_message('refresh', {});\n", - " };\n", - "\n", - " this.imageObj.onload = function () {\n", - " if (fig.image_mode === 'full') {\n", - " // Full images could contain transparency (where diff images\n", - " // almost always do), so we need to clear the canvas so that\n", - " // there is no ghosting.\n", - " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", - " }\n", - " fig.context.drawImage(fig.imageObj, 0, 0);\n", - " };\n", - "\n", - " this.imageObj.onunload = function () {\n", - " fig.ws.close();\n", - " };\n", - "\n", - " this.ws.onmessage = this._make_on_message_function(this);\n", - "\n", - " this.ondownload = ondownload;\n", - "};\n", - "\n", - "mpl.figure.prototype._init_header = function () {\n", - " var titlebar = document.createElement('div');\n", - " titlebar.classList =\n", - " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", - " var titletext = document.createElement('div');\n", - " titletext.classList = 'ui-dialog-title';\n", - " titletext.setAttribute(\n", - " 'style',\n", - " 'width: 100%; text-align: center; padding: 3px;'\n", - " );\n", - " titlebar.appendChild(titletext);\n", - " this.root.appendChild(titlebar);\n", - " this.header = titletext;\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", - "\n", - "mpl.figure.prototype._init_canvas = function () {\n", - " var fig = this;\n", - "\n", - " var canvas_div = (this.canvas_div = document.createElement('div'));\n", - " canvas_div.setAttribute(\n", - " 'style',\n", - " 'border: 1px solid #ddd;' +\n", - " 'box-sizing: content-box;' +\n", - " 'clear: both;' +\n", - " 'min-height: 1px;' +\n", - " 'min-width: 1px;' +\n", - " 'outline: 0;' +\n", - " 'overflow: hidden;' +\n", - " 'position: relative;' +\n", - " 'resize: both;'\n", - " );\n", - "\n", - " function on_keyboard_event_closure(name) {\n", - " return function (event) {\n", - " return fig.key_event(event, name);\n", - " };\n", - " }\n", - "\n", - " canvas_div.addEventListener(\n", - " 'keydown',\n", - " on_keyboard_event_closure('key_press')\n", - " );\n", - " canvas_div.addEventListener(\n", - " 'keyup',\n", - " on_keyboard_event_closure('key_release')\n", - " );\n", - "\n", - " this._canvas_extra_style(canvas_div);\n", - " this.root.appendChild(canvas_div);\n", - "\n", - " var canvas = (this.canvas = document.createElement('canvas'));\n", - " canvas.classList.add('mpl-canvas');\n", - " canvas.setAttribute('style', 'box-sizing: content-box;');\n", - "\n", - " this.context = canvas.getContext('2d');\n", - "\n", - " var backingStore =\n", - " this.context.backingStorePixelRatio ||\n", - " this.context.webkitBackingStorePixelRatio ||\n", - " this.context.mozBackingStorePixelRatio ||\n", - " this.context.msBackingStorePixelRatio ||\n", - " this.context.oBackingStorePixelRatio ||\n", - " this.context.backingStorePixelRatio ||\n", - " 1;\n", - "\n", - " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", - "\n", - " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", - " 'canvas'\n", - " ));\n", - " rubberband_canvas.setAttribute(\n", - " 'style',\n", - " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", - " );\n", - "\n", - " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", - " if (this.ResizeObserver === undefined) {\n", - " if (window.ResizeObserver !== undefined) {\n", - " this.ResizeObserver = window.ResizeObserver;\n", - " } else {\n", - " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", - " this.ResizeObserver = obs.ResizeObserver;\n", - " }\n", - " }\n", - "\n", - " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", - " var nentries = entries.length;\n", - " for (var i = 0; i < nentries; i++) {\n", - " var entry = entries[i];\n", - " var width, height;\n", - " if (entry.contentBoxSize) {\n", - " if (entry.contentBoxSize instanceof Array) {\n", - " // Chrome 84 implements new version of spec.\n", - " width = entry.contentBoxSize[0].inlineSize;\n", - " height = entry.contentBoxSize[0].blockSize;\n", - " } else {\n", - " // Firefox implements old version of spec.\n", - " width = entry.contentBoxSize.inlineSize;\n", - " height = entry.contentBoxSize.blockSize;\n", - " }\n", - " } else {\n", - " // Chrome <84 implements even older version of spec.\n", - " width = entry.contentRect.width;\n", - " height = entry.contentRect.height;\n", - " }\n", - "\n", - " // Keep the size of the canvas and rubber band canvas in sync with\n", - " // the canvas container.\n", - " if (entry.devicePixelContentBoxSize) {\n", - " // Chrome 84 implements new version of spec.\n", - " canvas.setAttribute(\n", - " 'width',\n", - " entry.devicePixelContentBoxSize[0].inlineSize\n", - " );\n", - " canvas.setAttribute(\n", - " 'height',\n", - " entry.devicePixelContentBoxSize[0].blockSize\n", - " );\n", - " } else {\n", - " canvas.setAttribute('width', width * fig.ratio);\n", - " canvas.setAttribute('height', height * fig.ratio);\n", - " }\n", - " canvas.setAttribute(\n", - " 'style',\n", - " 'width: ' + width + 'px; height: ' + height + 'px;'\n", - " );\n", - "\n", - " rubberband_canvas.setAttribute('width', width);\n", - " rubberband_canvas.setAttribute('height', height);\n", - "\n", - " // And update the size in Python. We ignore the initial 0/0 size\n", - " // that occurs as the element is placed into the DOM, which should\n", - " // otherwise not happen due to the minimum size styling.\n", - " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", - " fig.request_resize(width, height);\n", - " }\n", - " }\n", - " });\n", - " this.resizeObserverInstance.observe(canvas_div);\n", - "\n", - " function on_mouse_event_closure(name) {\n", - " return function (event) {\n", - " return fig.mouse_event(event, name);\n", - " };\n", - " }\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mousedown',\n", - " on_mouse_event_closure('button_press')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseup',\n", - " on_mouse_event_closure('button_release')\n", - " );\n", - " // Throttle sequential mouse events to 1 every 20ms.\n", - " rubberband_canvas.addEventListener(\n", - " 'mousemove',\n", - " on_mouse_event_closure('motion_notify')\n", - " );\n", - "\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseenter',\n", - " on_mouse_event_closure('figure_enter')\n", - " );\n", - " rubberband_canvas.addEventListener(\n", - " 'mouseleave',\n", - " on_mouse_event_closure('figure_leave')\n", - " );\n", - "\n", - " canvas_div.addEventListener('wheel', function (event) {\n", - " if (event.deltaY < 0) {\n", - " event.step = 1;\n", - " } else {\n", - " event.step = -1;\n", - " }\n", - " on_mouse_event_closure('scroll')(event);\n", - " });\n", - "\n", - " canvas_div.appendChild(canvas);\n", - " canvas_div.appendChild(rubberband_canvas);\n", - "\n", - " this.rubberband_context = rubberband_canvas.getContext('2d');\n", - " this.rubberband_context.strokeStyle = '#000000';\n", - "\n", - " this._resize_canvas = function (width, height, forward) {\n", - " if (forward) {\n", - " canvas_div.style.width = width + 'px';\n", - " canvas_div.style.height = height + 'px';\n", - " }\n", - " };\n", - "\n", - " // Disable right mouse context menu.\n", - " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", - " event.preventDefault();\n", - " return false;\n", - " });\n", - "\n", - " function set_focus() {\n", - " canvas.focus();\n", - " canvas_div.focus();\n", - " }\n", - "\n", - " window.setTimeout(set_focus, 100);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'mpl-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'mpl-button-group';\n", - " continue;\n", - " }\n", - "\n", - " var button = (fig.buttons[name] = document.createElement('button'));\n", - " button.classList = 'mpl-widget';\n", - " button.setAttribute('role', 'button');\n", - " button.setAttribute('aria-disabled', 'false');\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - "\n", - " var icon_img = document.createElement('img');\n", - " icon_img.src = '_images/' + image + '.png';\n", - " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", - " icon_img.alt = tooltip;\n", - " button.appendChild(icon_img);\n", - "\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " var fmt_picker = document.createElement('select');\n", - " fmt_picker.classList = 'mpl-widget';\n", - " toolbar.appendChild(fmt_picker);\n", - " this.format_dropdown = fmt_picker;\n", - "\n", - " for (var ind in mpl.extensions) {\n", - " var fmt = mpl.extensions[ind];\n", - " var option = document.createElement('option');\n", - " option.selected = fmt === mpl.default_extension;\n", - " option.innerHTML = fmt;\n", - " fmt_picker.appendChild(option);\n", - " }\n", - "\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "};\n", - "\n", - "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", - " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", - " // which will in turn request a refresh of the image.\n", - " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", - "};\n", - "\n", - "mpl.figure.prototype.send_message = function (type, properties) {\n", - " properties['type'] = type;\n", - " properties['figure_id'] = this.id;\n", - " this.ws.send(JSON.stringify(properties));\n", - "};\n", - "\n", - "mpl.figure.prototype.send_draw_message = function () {\n", - " if (!this.waiting) {\n", - " this.waiting = true;\n", - " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " var format_dropdown = fig.format_dropdown;\n", - " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", - " fig.ondownload(fig, format);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", - " var size = msg['size'];\n", - " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", - " fig._resize_canvas(size[0], size[1], msg['forward']);\n", - " fig.send_message('refresh', {});\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", - " var x0 = msg['x0'] / fig.ratio;\n", - " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", - " var x1 = msg['x1'] / fig.ratio;\n", - " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", - " x0 = Math.floor(x0) + 0.5;\n", - " y0 = Math.floor(y0) + 0.5;\n", - " x1 = Math.floor(x1) + 0.5;\n", - " y1 = Math.floor(y1) + 0.5;\n", - " var min_x = Math.min(x0, x1);\n", - " var min_y = Math.min(y0, y1);\n", - " var width = Math.abs(x1 - x0);\n", - " var height = Math.abs(y1 - y0);\n", - "\n", - " fig.rubberband_context.clearRect(\n", - " 0,\n", - " 0,\n", - " fig.canvas.width / fig.ratio,\n", - " fig.canvas.height / fig.ratio\n", - " );\n", - "\n", - " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", - " // Updates the figure title.\n", - " fig.header.textContent = msg['label'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", - " var cursor = msg['cursor'];\n", - " switch (cursor) {\n", - " case 0:\n", - " cursor = 'pointer';\n", - " break;\n", - " case 1:\n", - " cursor = 'default';\n", - " break;\n", - " case 2:\n", - " cursor = 'crosshair';\n", - " break;\n", - " case 3:\n", - " cursor = 'move';\n", - " break;\n", - " }\n", - " fig.rubberband_canvas.style.cursor = cursor;\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_message = function (fig, msg) {\n", - " fig.message.textContent = msg['message'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", - " // Request the server to send over a new figure.\n", - " fig.send_draw_message();\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", - " fig.image_mode = msg['mode'];\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", - " for (var key in msg) {\n", - " if (!(key in fig.buttons)) {\n", - " continue;\n", - " }\n", - " fig.buttons[key].disabled = !msg[key];\n", - " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", - " if (msg['mode'] === 'PAN') {\n", - " fig.buttons['Pan'].classList.add('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " } else if (msg['mode'] === 'ZOOM') {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.add('active');\n", - " } else {\n", - " fig.buttons['Pan'].classList.remove('active');\n", - " fig.buttons['Zoom'].classList.remove('active');\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Called whenever the canvas gets updated.\n", - " this.send_message('ack', {});\n", - "};\n", - "\n", - "// A function to construct a web socket function for onmessage handling.\n", - "// Called in the figure constructor.\n", - "mpl.figure.prototype._make_on_message_function = function (fig) {\n", - " return function socket_on_message(evt) {\n", - " if (evt.data instanceof Blob) {\n", - " /* FIXME: We get \"Resource interpreted as Image but\n", - " * transferred with MIME type text/plain:\" errors on\n", - " * Chrome. But how to set the MIME type? It doesn't seem\n", - " * to be part of the websocket stream */\n", - " evt.data.type = 'image/png';\n", - "\n", - " /* Free the memory for the previous frames */\n", - " if (fig.imageObj.src) {\n", - " (window.URL || window.webkitURL).revokeObjectURL(\n", - " fig.imageObj.src\n", - " );\n", - " }\n", - "\n", - " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", - " evt.data\n", - " );\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " } else if (\n", - " typeof evt.data === 'string' &&\n", - " evt.data.slice(0, 21) === 'data:image/png;base64'\n", - " ) {\n", - " fig.imageObj.src = evt.data;\n", - " fig.updated_canvas_event();\n", - " fig.waiting = false;\n", - " return;\n", - " }\n", - "\n", - " var msg = JSON.parse(evt.data);\n", - " var msg_type = msg['type'];\n", - "\n", - " // Call the \"handle_{type}\" callback, which takes\n", - " // the figure and JSON message as its only arguments.\n", - " try {\n", - " var callback = fig['handle_' + msg_type];\n", - " } catch (e) {\n", - " console.log(\n", - " \"No handler for the '\" + msg_type + \"' message type: \",\n", - " msg\n", - " );\n", - " return;\n", - " }\n", - "\n", - " if (callback) {\n", - " try {\n", - " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", - " callback(fig, msg);\n", - " } catch (e) {\n", - " console.log(\n", - " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", - " e,\n", - " e.stack,\n", - " msg\n", - " );\n", - " }\n", - " }\n", - " };\n", - "};\n", - "\n", - "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", - "mpl.findpos = function (e) {\n", - " //this section is from http://www.quirksmode.org/js/events_properties.html\n", - " var targ;\n", - " if (!e) {\n", - " e = window.event;\n", - " }\n", - " if (e.target) {\n", - " targ = e.target;\n", - " } else if (e.srcElement) {\n", - " targ = e.srcElement;\n", - " }\n", - " if (targ.nodeType === 3) {\n", - " // defeat Safari bug\n", - " targ = targ.parentNode;\n", - " }\n", - "\n", - " // pageX,Y are the mouse positions relative to the document\n", - " var boundingRect = targ.getBoundingClientRect();\n", - " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", - " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n", - "\n", - " return { x: x, y: y };\n", - "};\n", - "\n", - "/*\n", - " * return a copy of an object with only non-object keys\n", - " * we need this to avoid circular references\n", - " * http://stackoverflow.com/a/24161582/3208463\n", - " */\n", - "function simpleKeys(original) {\n", - " return Object.keys(original).reduce(function (obj, key) {\n", - " if (typeof original[key] !== 'object') {\n", - " obj[key] = original[key];\n", - " }\n", - " return obj;\n", - " }, {});\n", - "}\n", - "\n", - "mpl.figure.prototype.mouse_event = function (event, name) {\n", - " var canvas_pos = mpl.findpos(event);\n", - "\n", - " if (name === 'button_press') {\n", - " this.canvas.focus();\n", - " this.canvas_div.focus();\n", - " }\n", - "\n", - " var x = canvas_pos.x * this.ratio;\n", - " var y = canvas_pos.y * this.ratio;\n", - "\n", - " this.send_message(name, {\n", - " x: x,\n", - " y: y,\n", - " button: event.button,\n", - " step: event.step,\n", - " guiEvent: simpleKeys(event),\n", - " });\n", - "\n", - " /* This prevents the web browser from automatically changing to\n", - " * the text insertion cursor when the button is pressed. We want\n", - " * to control all of the cursor setting manually through the\n", - " * 'cursor' event from matplotlib */\n", - " event.preventDefault();\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", - " // Handle any extra behaviour associated with a key event\n", - "};\n", - "\n", - "mpl.figure.prototype.key_event = function (event, name) {\n", - " // Prevent repeat events\n", - " if (name === 'key_press') {\n", - " if (event.which === this._key) {\n", - " return;\n", - " } else {\n", - " this._key = event.which;\n", - " }\n", - " }\n", - " if (name === 'key_release') {\n", - " this._key = null;\n", - " }\n", - "\n", - " var value = '';\n", - " if (event.ctrlKey && event.which !== 17) {\n", - " value += 'ctrl+';\n", - " }\n", - " if (event.altKey && event.which !== 18) {\n", - " value += 'alt+';\n", - " }\n", - " if (event.shiftKey && event.which !== 16) {\n", - " value += 'shift+';\n", - " }\n", - "\n", - " value += 'k';\n", - " value += event.which.toString();\n", - "\n", - " this._key_event_extra(event, name);\n", - "\n", - " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", - " return false;\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", - " if (name === 'download') {\n", - " this.handle_save(this, null);\n", - " } else {\n", - " this.send_message('toolbar_button', { name: name });\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", - " this.message.textContent = tooltip;\n", - "};\n", - "\n", - "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", - "// prettier-ignore\n", - "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n", - "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", - "\n", - "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", - "\n", - "mpl.default_extension = \"png\";/* global mpl */\n", - "\n", - "var comm_websocket_adapter = function (comm) {\n", - " // Create a \"websocket\"-like object which calls the given IPython comm\n", - " // object with the appropriate methods. Currently this is a non binary\n", - " // socket, so there is still some room for performance tuning.\n", - " var ws = {};\n", - "\n", - " ws.close = function () {\n", - " comm.close();\n", - " };\n", - " ws.send = function (m) {\n", - " //console.log('sending', m);\n", - " comm.send(m);\n", - " };\n", - " // Register the callback with on_msg.\n", - " comm.on_msg(function (msg) {\n", - " //console.log('receiving', msg['content']['data'], msg);\n", - " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", - " ws.onmessage(msg['content']['data']);\n", - " });\n", - " return ws;\n", - "};\n", - "\n", - "mpl.mpl_figure_comm = function (comm, msg) {\n", - " // This is the function which gets called when the mpl process\n", - " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", - "\n", - " var id = msg.content.data.id;\n", - " // Get hold of the div created by the display call when the Comm\n", - " // socket was opened in Python.\n", - " var element = document.getElementById(id);\n", - " var ws_proxy = comm_websocket_adapter(comm);\n", - "\n", - " function ondownload(figure, _format) {\n", - " window.open(figure.canvas.toDataURL());\n", - " }\n", - "\n", - " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", - "\n", - " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", - " // web socket which is closed, not our websocket->open comm proxy.\n", - " ws_proxy.onopen();\n", - "\n", - " fig.parent_element = element;\n", - " fig.cell_info = mpl.find_output_cell(\"
\");\n", - " if (!fig.cell_info) {\n", - " console.error('Failed to find cell for figure', id, fig);\n", - " return;\n", - " }\n", - " fig.cell_info[0].output_area.element.on(\n", - " 'cleared',\n", - " { fig: fig },\n", - " fig._remove_fig_handler\n", - " );\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_close = function (fig, msg) {\n", - " var width = fig.canvas.width / fig.ratio;\n", - " fig.cell_info[0].output_area.element.off(\n", - " 'cleared',\n", - " fig._remove_fig_handler\n", - " );\n", - " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", - "\n", - " // Update the output cell to use the data from the current canvas.\n", - " fig.push_to_output();\n", - " var dataURL = fig.canvas.toDataURL();\n", - " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", - " // the notebook keyboard shortcuts fail.\n", - " IPython.keyboard_manager.enable();\n", - " fig.parent_element.innerHTML =\n", - " '';\n", - " fig.close_ws(fig, msg);\n", - "};\n", - "\n", - "mpl.figure.prototype.close_ws = function (fig, msg) {\n", - " fig.send_message('closing', msg);\n", - " // fig.ws.close()\n", - "};\n", - "\n", - "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", - " // Turn the data on the canvas into data in the output cell.\n", - " var width = this.canvas.width / this.ratio;\n", - " var dataURL = this.canvas.toDataURL();\n", - " this.cell_info[1]['text/html'] =\n", - " '';\n", - "};\n", - "\n", - "mpl.figure.prototype.updated_canvas_event = function () {\n", - " // Tell IPython that the notebook contents must change.\n", - " IPython.notebook.set_dirty(true);\n", - " this.send_message('ack', {});\n", - " var fig = this;\n", - " // Wait a second, then push the new image to the DOM so\n", - " // that it is saved nicely (might be nice to debounce this).\n", - " setTimeout(function () {\n", - " fig.push_to_output();\n", - " }, 1000);\n", - "};\n", - "\n", - "mpl.figure.prototype._init_toolbar = function () {\n", - " var fig = this;\n", - "\n", - " var toolbar = document.createElement('div');\n", - " toolbar.classList = 'btn-toolbar';\n", - " this.root.appendChild(toolbar);\n", - "\n", - " function on_click_closure(name) {\n", - " return function (_event) {\n", - " return fig.toolbar_button_onclick(name);\n", - " };\n", - " }\n", - "\n", - " function on_mouseover_closure(tooltip) {\n", - " return function (event) {\n", - " if (!event.currentTarget.disabled) {\n", - " return fig.toolbar_button_onmouseover(tooltip);\n", - " }\n", - " };\n", - " }\n", - "\n", - " fig.buttons = {};\n", - " var buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " var button;\n", - " for (var toolbar_ind in mpl.toolbar_items) {\n", - " var name = mpl.toolbar_items[toolbar_ind][0];\n", - " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", - " var image = mpl.toolbar_items[toolbar_ind][2];\n", - " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", - "\n", - " if (!name) {\n", - " /* Instead of a spacer, we start a new button group. */\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - " buttonGroup = document.createElement('div');\n", - " buttonGroup.classList = 'btn-group';\n", - " continue;\n", - " }\n", - "\n", - " button = fig.buttons[name] = document.createElement('button');\n", - " button.classList = 'btn btn-default';\n", - " button.href = '#';\n", - " button.title = name;\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', on_click_closure(method_name));\n", - " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", - " buttonGroup.appendChild(button);\n", - " }\n", - "\n", - " if (buttonGroup.hasChildNodes()) {\n", - " toolbar.appendChild(buttonGroup);\n", - " }\n", - "\n", - " // Add the status bar.\n", - " var status_bar = document.createElement('span');\n", - " status_bar.classList = 'mpl-message pull-right';\n", - " toolbar.appendChild(status_bar);\n", - " this.message = status_bar;\n", - "\n", - " // Add the close button to the window.\n", - " var buttongrp = document.createElement('div');\n", - " buttongrp.classList = 'btn-group inline pull-right';\n", - " button = document.createElement('button');\n", - " button.classList = 'btn btn-mini btn-primary';\n", - " button.href = '#';\n", - " button.title = 'Stop Interaction';\n", - " button.innerHTML = '';\n", - " button.addEventListener('click', function (_evt) {\n", - " fig.handle_close(fig, {});\n", - " });\n", - " button.addEventListener(\n", - " 'mouseover',\n", - " on_mouseover_closure('Stop Interaction')\n", - " );\n", - " buttongrp.appendChild(button);\n", - " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", - " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", - "};\n", - "\n", - "mpl.figure.prototype._remove_fig_handler = function (event) {\n", - " var fig = event.data.fig;\n", - " if (event.target !== this) {\n", - " // Ignore bubbled events from children.\n", - " return;\n", - " }\n", - " fig.close_ws(fig, {});\n", - "};\n", - "\n", - "mpl.figure.prototype._root_extra_style = function (el) {\n", - " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", - "};\n", - "\n", - "mpl.figure.prototype._canvas_extra_style = function (el) {\n", - " // this is important to make the div 'focusable\n", - " el.setAttribute('tabindex', 0);\n", - " // reach out to IPython and tell the keyboard manager to turn it's self\n", - " // off when our div gets focus\n", - "\n", - " // location in version 3\n", - " if (IPython.notebook.keyboard_manager) {\n", - " IPython.notebook.keyboard_manager.register_events(el);\n", - " } else {\n", - " // location in version 2\n", - " IPython.keyboard_manager.register_events(el);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", - " var manager = IPython.notebook.keyboard_manager;\n", - " if (!manager) {\n", - " manager = IPython.keyboard_manager;\n", - " }\n", - "\n", - " // Check for shift+enter\n", - " if (event.shiftKey && event.which === 13) {\n", - " this.canvas_div.blur();\n", - " // select the cell after this one\n", - " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", - " IPython.notebook.select(index + 1);\n", - " }\n", - "};\n", - "\n", - "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", - " fig.ondownload(fig, null);\n", - "};\n", - "\n", - "mpl.find_output_cell = function (html_output) {\n", - " // Return the cell and output element which can be found *uniquely* in the notebook.\n", - " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", - " // IPython event is triggered only after the cells have been serialised, which for\n", - " // our purposes (turning an active figure into a static one), is too late.\n", - " var cells = IPython.notebook.get_cells();\n", - " var ncells = cells.length;\n", - " for (var i = 0; i < ncells; i++) {\n", - " var cell = cells[i];\n", - " if (cell.cell_type === 'code') {\n", - " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", - " var data = cell.output_area.outputs[j];\n", - " if (data.data) {\n", - " // IPython >= 3 moved mimebundle to data attribute of output\n", - " data = data.data;\n", - " }\n", - " if (data['text/html'] === html_output) {\n", - " return [cell, data, j];\n", - " }\n", - " }\n", - " }\n", - " }\n", - "};\n", - "\n", - "// Register the function which deals with the matplotlib target/channel.\n", - "// The kernel may be null if the page has been refreshed.\n", - "if (IPython.notebook.kernel !== null) {\n", - " IPython.notebook.kernel.comm_manager.register_target(\n", - " 'matplotlib',\n", - " mpl.mpl_figure_comm\n", - " );\n", - "}\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "data": { - "text/html": [ - "" - ], + "image/png": "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", "text/plain": [ - "" + "
" ] }, "metadata": {}, @@ -2147,7074 +264,103 @@ "name": "stdout", "output_type": "stream", "text": [ - "\r", - "mPIE: 0%| | 0/300 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - " \n", - "iteration: 19 \n", - "error: 101.7 \n", - "estimated linear overlap: 87.3 % \n", - "estimated area overlap: 83.6 % \n", - "mPIE: 7%|█████ | 20/300 [00:15<03:39, 1.28it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - " 0%| | 0/202 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -9228,7 +374,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -9239,7 +385,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "ptylab", "language": "python", "name": "python3" }, @@ -9253,7 +399,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.13.12" } }, "nbformat": 4, diff --git a/mkdocs.yml b/mkdocs.yml new file mode 100644 index 00000000..ca05977c --- /dev/null +++ b/mkdocs.yml @@ -0,0 +1,85 @@ +site_name: PtyLab.py +site_description: Cross-platform, open-source inverse modeling toolbox for conventional and Fourier ptychography +site_url: https://ptylab.github.io/PtyLab.py/ +repo_url: https://github.com/PtyLab/PtyLab.py +repo_name: PtyLab/PtyLab.py +dev_addr: '127.0.0.1:8000' + +theme: + name: material + logo: assets/ptylab_logo.svg + favicon: assets/ptylab_logo.svg + palette: + - scheme: default + primary: indigo + accent: indigo + toggle: + icon: material/brightness-7 + name: Switch to dark mode + - scheme: slate + primary: black + accent: indigo + toggle: + icon: material/brightness-4 + name: Switch to light mode + features: + - navigation.sections + - navigation.expand + - navigation.indexes + - navigation.top + - content.code.copy + - toc.integrate + +nav: + - Home: index.md + - Getting Started: + - getting-started/index.md + - Installation: getting-started/installation.md + - Quick Start: getting-started/quickstart.md + - CPM Workflow: + - cpm/index.md + - Overview: cpm/overview.md + - Data Format: cpm/data-format.md + - Engines: cpm/engines.md + - Configuration Reference: cpm/configuration.md + - FPM Workflow: + - fpm/index.md + - Overview: fpm/overview.md + - LED Calibration: fpm/calibration.md + - Advanced Topics: + - advanced/index.md + - GPU Acceleration: advanced/gpu.md + - Multislice: advanced/multislice.md + - Position Correction: advanced/position-correction.md + - Tutorials: + - tutorials/index.md + - "01 – CPM Simulation": tutorials/tutorial_CPM_sim.ipynb + - "02 – CPM Example Data": tutorials/tutorial_CPM.ipynb + - "03 – CPM Multi-Wavelength": tutorials/tutorial_CPM_multiWavelength.ipynb + - "04 – CPM Position Correction": tutorials/tutorial_LateralPositionCorrection.ipynb + - "05 – CPM Reflection": tutorials/tutorial_reflectionPtychography.ipynb + - "06 – CPM Interferometric Intensity": tutorials/tutorial_interferometricIntensityConstraint.ipynb + - "07 – FPM": tutorials/tutorial_FPM.ipynb + +extra_css: + - stylesheets/extra.css + +markdown_extensions: + - admonition + - pymdownx.details + - pymdownx.superfences + - pymdownx.highlight: + anchor_linenums: true + - pymdownx.inlinehilite + - pymdownx.tabbed: + alternate_style: true + - tables + - toc: + permalink: true + +plugins: + - search + - mkdocs-jupyter: + include: ["*.ipynb"] + execute: false + allow_errors: true diff --git a/pyproject.toml b/pyproject.toml index 13dadb29..6f11ffa7 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "ptylab" -version = "0.2.4" +version = "0.2.5" description = "A cross-platform, open-source inverse modeling toolbox for conventional and Fourier ptychography" authors = [ { name = "Lars Loetgering", email = "lars.loetgering@fulbrightmail.org" }, @@ -21,6 +21,7 @@ dependencies = [ "bokeh~=3.2", "PyQt5~=5.15", "ipython~=8.18", + "ipywidgets>=8.1.8", ] [project.optional-dependencies] @@ -30,9 +31,13 @@ dev = [ "pytest~=9.0", "imageio~=2.0", ] -cuda12 = ["cupy-cuda12x"] -cuda13 = ["cupy-cuda13x"] +gpu = ["cupy-cuda12x[ctk]"] tensorflow = ["tensorflow~=2.14"] +docs = [ + "mkdocs>=1.6.1", + "mkdocs-material>=9.7.6", + "mkdocs-jupyter>=0.24", +] [project.scripts] ptylab = "PtyLab.utils.cli:main"