{ "cells": [ { "cell_type": "markdown", "id": "6f63d086", "metadata": {}, "source": [ "# Inverse beamforming on an in-vivo carotid scan\n", "\n", "This tutorial applies [`zea.inverse`](../../_autosummary/zea.inverse.rst) to an\n", "**in-vivo carotid acquisition** (149 single-element transmits, 128 elements, from the\n", "[off-grid-ultrasound dataset](https://zenodo.org/records/14925758) of\n", "[van de Schaft et al., arXiv:2407.02285](https://arxiv.org/abs/2407.02285)) and\n", "reproduces the in-vivo result of the standalone\n", "[DAS-inversion study](https://github.com/sankethvedula/das-inverse): a scatterer-prior\n", "inversion with 30,000 scatterers, reference pre-BF corr 0.06 and post-BF corr 0.95 (the study ran 70 CGLS\n", "iterations; we stop at 40, which captures nearly all of the attainable correlation).\n", "\n", "That pre-BF correlation of ≈0.06 is the honest headline: a compounded image constrains\n", "speckle *statistics*, not the specific channel-data realization, so recovering diffuse\n", "in-vivo channel data from one image is fundamentally limited. Compare the\n", "[CIRS phantom tutorial](cirs_example.ipynb) (0.84 on point targets)\n", "and the [introductory tutorial](fish_example.ipynb), which sits between\n", "the two regimes with bright points over speckle." ] }, { "cell_type": "markdown", "id": "2a0e0773", "metadata": {}, "source": [ "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/tue-bmd/zea/blob/main/docs/source/notebooks/inverse/carotid_example.ipynb)\n", "[![View on GitHub](https://img.shields.io/badge/GitHub-View%20Source-blue?logo=github)](https://github.com/tue-bmd/zea/blob/main/docs/source/notebooks/inverse/carotid_example.ipynb)" ] }, { "cell_type": "markdown", "id": "8f0fada9", "metadata": {}, "source": [ "‼️ **Important:** This notebook is optimized for **GPU/TPU**. Code execution on a **CPU** may be very slow.\n", "\n", "If you are running in Colab, please enable a hardware accelerator via:\n", "\n", "**Runtime → Change runtime type → Hardware accelerator → GPU/TPU** 🚀." ] }, { "cell_type": "code", "execution_count": 1, "id": "94a1226a", "metadata": { "execution": { "iopub.execute_input": "2026-07-21T15:54:52.675006Z", "iopub.status.busy": "2026-07-21T15:54:52.674909Z", "iopub.status.idle": "2026-07-21T15:54:53.566558Z", "shell.execute_reply": "2026-07-21T15:54:53.565880Z" } }, "outputs": [], "source": [ "%%capture\n", "%pip install zea" ] }, { "cell_type": "code", "execution_count": 2, "id": "afe1889f", "metadata": { "execution": { "iopub.execute_input": "2026-07-21T15:54:53.568763Z", "iopub.status.busy": "2026-07-21T15:54:53.568628Z", "iopub.status.idle": "2026-07-21T15:54:56.799563Z", "shell.execute_reply": "2026-07-21T15:54:56.799007Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[1m\u001b[38;5;36mzea\u001b[0m\u001b[0m: Using backend 'jax'\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "-------------------GPU settings-------------------\n", "0/1 GPUs were disabled\n", " memory\n", "GPU \n", "0 81072\n", "Selecting 1 GPU based on available memory.\n", "Selected GPU 0 with Free Memory: 81072.00 MiB\n", "--------------------------------------------------\n" ] }, { "data": { "text/plain": [ "'gpu:0'" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import os\n", "\n", "os.environ[\"KERAS_BACKEND\"] = \"jax\"\n", "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"3\"\n", "\n", "import time\n", "import urllib.request\n", "from pathlib import Path\n", "\n", "import h5py\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "from keras import ops\n", "from matplotlib.animation import FuncAnimation, PillowWriter\n", "\n", "import zea\n", "from zea.inverse import DASOperator, ScattererSimulator, invert_scatterers\n", "\n", "zea.init_device()" ] }, { "cell_type": "code", "execution_count": 3, "id": "1901c0d7", "metadata": { "execution": { "iopub.execute_input": "2026-07-21T15:54:56.801245Z", "iopub.status.busy": "2026-07-21T15:54:56.800975Z", "iopub.status.idle": "2026-07-21T15:54:56.803319Z", "shell.execute_reply": "2026-07-21T15:54:56.802953Z" }, "tags": [ "parameters" ] }, "outputs": [], "source": [ "# Parameters (overridden for fast CI runs, see tests/test_notebooks.py)\n", "# CGLS is stopped early: on ill-posed problems the iteration count doubles as\n", "# the regularization parameter, and 40 iterations capture nearly all of the\n", "# attainable correlation at a fraction of the runtime.\n", "n_iter = 40\n", "n_scatterers = 30000\n", "# The scan is a 411 MB download and the inversion runs for hours; CI skips it.\n", "run_inversion = True" ] }, { "cell_type": "markdown", "id": "31063fac", "metadata": {}, "source": [ "## Download the scan\n", "\n", "The in-vivo carotid scan (411 MB) comes from the off-grid-ultrasound dataset on Zenodo.\n", "It is in the (legacy) `zea` HDF5 format and loads directly with\n", "[`zea.File`](../../_autosummary/zea.data.file.rst). We use this specific scan so the\n", "results are directly comparable with the original study; for more zea-native carotid\n", "data see the\n", "[`zeahub/zea-carotid-2023`](https://huggingface.co/datasets/zeahub/zea-carotid-2023)\n", "dataset, which `zea.File` opens straight from `hf://` URLs." ] }, { "cell_type": "code", "execution_count": 4, "id": "42af5985", "metadata": { "execution": { "iopub.execute_input": "2026-07-21T15:54:56.804702Z", "iopub.status.busy": "2026-07-21T15:54:56.804601Z", "iopub.status.idle": "2026-07-21T15:54:56.807447Z", "shell.execute_reply": "2026-07-21T15:54:56.807000Z" } }, "outputs": [], "source": [ "DATA_DIR = Path(os.environ.get(\"ZEA_INVERSE_DATA_DIR\", \"~/zea-inverse-data\")).expanduser()\n", "DATA_DIR.mkdir(parents=True, exist_ok=True)\n", "\n", "SCAN_PATH = DATA_DIR / \"L11-5v_carotid1.hdf5\"\n", "SCAN_URL = \"https://zenodo.org/records/14925758/files/L11-5v_carotid1.hdf5?download=1\"\n", "\n", "if run_inversion and not SCAN_PATH.exists():\n", " print(f\"downloading {SCAN_PATH.name} (411 MB) ...\")\n", " urllib.request.urlretrieve(SCAN_URL, SCAN_PATH)\n", " print(f\" -> {SCAN_PATH} ({SCAN_PATH.stat().st_size / 1e6:.0f} MB)\")" ] }, { "cell_type": "markdown", "id": "14c6f32d", "metadata": {}, "source": [ "## Loading a scan for inversion\n", "\n", "We load the acquisition into [`zea.Parameters`](../../parameters_doc.rst) with a few\n", "overrides that match the conventions of the original study:\n", "\n", "- **`t_peak`**: the original beamformer used the two-way waveform's time-to-peak,\n", " *doubled* (a jaxus convention). We override `t_peak` accordingly so the delay model\n", " matches exactly.\n", "- **`element_width`**: these legacy files store the element width under `scan/`, which\n", " the legacy loader drops — we read it directly and pass it as an override (it drives\n", " the element directivity model in the simulator).\n", "- **grid**: a 0.6-wavelength pixel grid over the imaging region, and a receive\n", " f-number of 1.5 (the original configuration)." ] }, { "cell_type": "code", "execution_count": 5, "id": "fbe48a53", "metadata": { "execution": { "iopub.execute_input": "2026-07-21T15:54:56.808661Z", "iopub.status.busy": "2026-07-21T15:54:56.808553Z", "iopub.status.idle": "2026-07-21T15:54:56.814903Z", "shell.execute_reply": "2026-07-21T15:54:56.814418Z" } }, "outputs": [], "source": [ "def load_scan(path, region, pixels_per_wavelength=1 / 0.6, f_number=1.5, frame=0):\n", " \"\"\"Load a scan and its raw RF data with the original study's conventions.\"\"\"\n", " with h5py.File(path, \"r\") as h:\n", " element_width = float(h[\"scan/element_width\"][()])\n", " with zea.File(path) as file:\n", " parameters = file.load_parameters()\n", " raw_data = np.asarray(file[\"data/raw_data\"][frame, ..., 0], dtype=np.float32)\n", "\n", " # t_peak: two-way waveform peak time, doubled (jaxus/original-study convention)\n", " waveform = np.asarray(parameters.waveforms_two_way[0])\n", " t_peak = np.full(parameters.n_tx, 2.0 * np.argmax(waveform) / 250e6, dtype=np.float32)\n", "\n", " # 0.6-wavelength pixel grid over the requested region\n", " spacing = parameters.sound_speed / float(np.mean(parameters.center_frequency))\n", " spacing = spacing / pixels_per_wavelength\n", " grid_size_x = int((region[1] - region[0]) / spacing) + 1\n", " grid_size_z = int((region[3] - region[2]) / spacing) + 1\n", "\n", " with zea.File(path) as file:\n", " parameters = file.load_parameters(\n", " t_peak=t_peak,\n", " element_width=element_width,\n", " f_number=f_number,\n", " xlims=(region[0], region[1]),\n", " zlims=(region[2], region[3]),\n", " grid_size_x=grid_size_x,\n", " grid_size_z=grid_size_z,\n", " )\n", " print(\n", " f\"{Path(path).name}: n_tx={parameters.n_tx} n_el={parameters.n_el} \"\n", " f\"n_ax={parameters.n_ax} grid=({grid_size_z}, {grid_size_x})\"\n", " )\n", " return parameters, raw_data\n", "\n", "\n", "def correlation(a, b):\n", " \"\"\"Absolute normalized correlation between two arrays.\"\"\"\n", " a = np.asarray(ops.convert_to_numpy(a)).ravel()\n", " b = np.asarray(ops.convert_to_numpy(b)).ravel()\n", " a, b = a - a.mean(), b - b.mean()\n", " return abs(np.vdot(a, b)) / (np.linalg.norm(a) * np.linalg.norm(b) + 1e-30)\n", "\n", "\n", "def report(label, result, raw_data, image, reference):\n", " \"\"\"Print pre/post-beamforming correlations next to the reference values.\"\"\"\n", " pre = correlation(result.channel_data, raw_data)\n", " post = correlation(result.image, image)\n", " print(\n", " f\"{label:28s} pre-BF corr {pre:.3f} (reference {reference[0]:.3f}) \"\n", " f\"post-BF corr {post:.3f} (reference {reference[1]:.3f})\"\n", " )\n", " return pre, post" ] }, { "cell_type": "markdown", "id": "c792b58a", "metadata": {}, "source": [ "## Rendering helpers\n", "\n", "`show_images` compares the measured image with the re-beamformed reconstruction\n", "(log-compressed `|RF|`, as in the original study). `render_prebf_gif` animates the\n", "recovered pre-beamformed channel data across transmits next to the recorded ground\n", "truth — this is the quantity being recovered, which the inversion never observes." ] }, { "cell_type": "code", "execution_count": 6, "id": "c0652134", "metadata": { "execution": { "iopub.execute_input": "2026-07-21T15:54:56.816110Z", "iopub.status.busy": "2026-07-21T15:54:56.815995Z", "iopub.status.idle": "2026-07-21T15:54:56.821560Z", "shell.execute_reply": "2026-07-21T15:54:56.821080Z" } }, "outputs": [], "source": [ "def to_db(image_2d):\n", " magnitude = np.abs(image_2d)\n", " return 20 * np.log10(magnitude / (magnitude.max() + 1e-12) + 1e-6)\n", "\n", "\n", "def show_images(operator, image, result, region, scatterers=None, title=\"\"):\n", " extent = [region[0] * 1e3, region[1] * 1e3, region[3] * 1e3, region[2] * 1e3]\n", " fig, axes = plt.subplots(1, 2, figsize=(10, 4.5))\n", " panels = [(image, \"measured image\"), (result.image, \"re-beamformed reconstruction\")]\n", " for ax, (flat, label) in zip(axes, panels):\n", " ax.imshow(\n", " to_db(ops.convert_to_numpy(operator.to_grid(flat))),\n", " cmap=\"gray\",\n", " vmin=-50,\n", " vmax=0,\n", " extent=extent,\n", " aspect=\"equal\",\n", " )\n", " if scatterers is not None:\n", " ax.scatter(\n", " scatterers[:, 0] * 1e3,\n", " scatterers[:, 2] * 1e3,\n", " s=16,\n", " facecolors=\"none\",\n", " edgecolors=\"r\",\n", " linewidths=0.8,\n", " )\n", " ax.set(title=label, xlabel=\"x [mm]\", ylabel=\"z [mm]\")\n", " fig.suptitle(title)\n", " plt.tight_layout()\n", " plt.show()\n", "\n", "\n", "def render_prebf_gif(filename, channel_data_true, channel_data_recon, transmits, fps=10):\n", " \"\"\"Animate ground-truth vs recovered channel data across transmits.\"\"\"\n", " gt = np.asarray(ops.convert_to_numpy(channel_data_true))\n", " recon = np.asarray(ops.convert_to_numpy(channel_data_recon))\n", " fig, axes = plt.subplots(1, 2, figsize=(7, 4.5))\n", "\n", " def draw(tx):\n", " for ax in axes:\n", " ax.clear()\n", " for ax, cube, label in zip(axes, [gt, recon], [\"recorded pre-BF\", \"recovered pre-BF\"]):\n", " ax.imshow(\n", " np.abs(cube[tx]),\n", " aspect=\"auto\",\n", " cmap=\"viridis\",\n", " vmax=np.percentile(np.abs(cube[tx]), 99.5) + 1e-12,\n", " )\n", " ax.set(title=label, xlabel=\"element\", ylabel=\"sample\")\n", " tx_corr = correlation(recon[tx], gt[tx])\n", " fig.suptitle(f\"transmit {tx + 1}/{gt.shape[0]} corr {tx_corr:.3f}\")\n", " fig.tight_layout()\n", "\n", " animation = FuncAnimation(fig, draw, frames=list(transmits), interval=1000 / fps)\n", " animation.save(filename, writer=PillowWriter(fps=fps))\n", " plt.close(fig)\n", " print(f\"saved {filename} ({Path(filename).stat().st_size / 1e6:.1f} MB)\")" ] }, { "cell_type": "markdown", "id": "0e3ba3a5", "metadata": {}, "source": [ "## Scatterer-prior inversion\n", "\n", "We beamform the recorded channel data once to get the *measured image* — from here on,\n", "the inversion sees only that image. 30,000 scatterers are seeded from the image\n", "envelope and their magnitudes solved with CGLS." ] }, { "cell_type": "code", "execution_count": 7, "id": "6faa44c2", "metadata": { "execution": { "iopub.execute_input": "2026-07-21T15:54:56.822719Z", "iopub.status.busy": "2026-07-21T15:54:56.822605Z", "iopub.status.idle": "2026-07-21T16:16:51.132224Z", "shell.execute_reply": "2026-07-21T16:16:51.131637Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[1m\u001b[38;5;36mzea\u001b[0m\u001b[0m: \u001b[38;5;214mWARNING\u001b[0m This ``zea.File`` '/nfs/scistore20/bronsgrp/svedula/das-inversion/data/L11-5v_carotid1.hdf5' was created with a legacy version of zea (<0.1.0), while you are using zea v0.1.2. It may behave in unexpected ways. Install an earlier version of zea<0.1.0 for full compatibility or re-save the file with zea v0.1.0 or later (e.g. via File.create).\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\u001b[1m\u001b[38;5;36mzea\u001b[0m\u001b[0m: \u001b[38;5;214mWARNING\u001b[0m The waveforms_one_way parameter is stored as a dictionary in the file. Converting to array. This will be deprecated in future versions of zea. Please update your files to store waveforms as arrays of shape `(n_tx, n_samples)`.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\u001b[1m\u001b[38;5;36mzea\u001b[0m\u001b[0m: \u001b[38;5;214mWARNING\u001b[0m The waveforms_two_way parameter is stored as a dictionary in the file. Converting to array. This will be deprecated in future versions of zea. Please update your files to store waveforms as arrays of shape `(n_tx, n_samples)`.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\u001b[1m\u001b[38;5;36mzea\u001b[0m\u001b[0m: \u001b[38;5;214mWARNING\u001b[0m The waveforms_one_way parameter is stored as a dictionary in the file. Converting to array. This will be deprecated in future versions of zea. Please update your files to store waveforms as arrays of shape `(n_tx, n_samples)`.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\u001b[1m\u001b[38;5;36mzea\u001b[0m\u001b[0m: \u001b[38;5;214mWARNING\u001b[0m The waveforms_two_way parameter is stored as a dictionary in the file. Converting to array. This will be deprecated in future versions of zea. Please update your files to store waveforms as arrays of shape `(n_tx, n_samples)`.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "L11-5v_carotid1.hdf5: n_tx=149 n_el=128 n_ax=2688 grid=(305, 297)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\u001b[1m\u001b[38;5;36mzea\u001b[0m\u001b[0m: \u001b[38;5;214mWARNING\u001b[0m width/grid_size_x = 0.0001212 > wavelength/2 = 0.0001013. Consider increasing grid_size_x to 356 or more, or unsetting it to size the grid automatically.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\u001b[1m\u001b[38;5;36mzea\u001b[0m\u001b[0m: \u001b[38;5;214mWARNING\u001b[0m depth/grid_size_z = 0.0001213 > wavelength/2 = 0.0001013. Consider increasing grid_size_z to 366 or more, or unsetting it to size the grid automatically.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "scatterer-prior inversion: 1307s\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "carotid scatterer prior (30k) pre-BF corr 0.060 (reference 0.057) post-BF corr 0.931 (reference 0.946)\n" ] } ], "source": [ "REGION_CAROTID = (-0.018, 0.018, 0.003, 0.04)\n", "\n", "if run_inversion:\n", " parameters, raw_data = load_scan(SCAN_PATH, REGION_CAROTID)\n", " operator = DASOperator(parameters)\n", " image = operator.forward(raw_data)\n", "\n", " start = time.time()\n", " simulator = ScattererSimulator(parameters, chunk_size=4096)\n", " result_carotid = invert_scatterers(\n", " operator,\n", " image,\n", " n_scatterers=n_scatterers,\n", " n_iter=n_iter,\n", " seed=0,\n", " simulator=simulator,\n", " )\n", " print(f\"scatterer-prior inversion: {time.time() - start:.0f}s\")\n", " report(\"carotid scatterer prior (30k)\", result_carotid, raw_data, image, (0.057, 0.946))" ] }, { "cell_type": "code", "execution_count": 8, "id": "ec1206db", "metadata": { "execution": { "iopub.execute_input": "2026-07-21T16:16:51.133849Z", "iopub.status.busy": "2026-07-21T16:16:51.133713Z", "iopub.status.idle": "2026-07-21T16:17:03.780327Z", "shell.execute_reply": "2026-07-21T16:17:03.779683Z" } }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2YAAAG+CAYAAAD4JxeVAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsvXmcXGWV//+5te97dVXvndBZICEJJAEhYQBBhEHABRAVZxTXkUFn8auIy0tcUGfRGcaFcZTF7eWMg8ugiMoWFgkEQoDsnfS+Vde+7/X8/sjvHG5VV29Jh07I83698oKuvn3r3qdu3ft8nnPO5yhCCAGJRCKRSCQSiUQikSwZmqU+AIlEIpFIJBKJRCI51ZHCTCKRSCQSiUQikUiWGCnMJBKJRCKRSCQSiWSJkcJMIpFIJBKJRCKRSJYYKcwkEolEIpFIJBKJZImRwkwikUgkEolEIpFIlhgpzCQSiUQikUgkEolkiZHCTCKRSCQSiUQikUiWGCnMJBKJRCKRSCQSiWSJkcJMIpFIThEuvfRSvOENb5jXtu973/sQDAaP8xFJTnQmJyehKAq+/e1vL/WhSCQSyeseKcwkEonkdcTWrVuxdevWpT6Mk47Zxk2OqUQikUheC3RLfQASiUQieW14+OGHl/oQJCcZwWAQQoilPgyJRCI5JZARM4lEIpFIJBKJRCJZYqQwk0gkkmNkbGwMH/nIR9DV1QWTyYQzzjgD//RP/4RisQgAeOihh6AoCv+zWCzYtGkT7rnnnrr9/Nu//RsURcHIyAg+9alPobW1FYqi8O/vvvtunHXWWTCbzXC5XLjiiiuwY8cO/n1HRweefvppPP300/xePp+Pf9+sxkwIgX/+53/GsmXLYDab8YY3vAHbt28/HsO0IJ5++mlcdtll8Pv9cDgcOOecc3DfffehVqvVbfenP/0Jl112GdxuNxwOBy6++GI8+uij/Psbb7yRx0Kj0cDn8+Gaa67B7t27eZvZxm2uMQWAP/7xj7jkkkvgcDhgNptx7rnn4oEHHqjbZtOmTbj00ktx8OBBXH755bDZbLjxxhsBAOVyGV/96ldx+umnw2g0wuv14l3veheGh4f57/fv3w9FUXDvvffipz/9Kc444wzodDo89NBDTcdPvf29996L3t5emEwmnH322fj9738/47aN+56pxiwej+OWW25BZ2cnDAYDOjs78YlPfALJZPKoj1kikUhOdaQwk0gkkmNgaGgIGzduxLPPPouf/OQnCIfD+OUvf4l4PI7HHnsMAHD55ZdDCAEhBGq1GgYGBnDDDTfggx/8IH7xi19M2+ett96K1atXY8+ePfjP//xPAMCXvvQlfOhDH8L111+P4eFhPP/88zAYDLjgggvwzDPPAABGR0exZcsWbNmyhd8vEonMevyf+9zncNttt+Ef//EfMT4+jrvvvhtf+tKXMDo6usgjNX/Gxsbw5je/GT09Pdi1axcmJydx1113Ydu2bdizZw9v94Mf/ABvfvObsWLFCjz33HMYGxvD7bffjjvvvJO3+clPfsJjUSwWsW3bNlSrVVx22WWIxWIAZh+3ucb03nvvxeWXX46zzz4be/bswdjYGK6//nq87W1vm/bZplIpfOITn8CXv/xlDAwM4C1veQuq1Squuuoq/Pu//zu+/OUvY2pqCtu3b0csFsOWLVumfX6/+c1vsH37dvzhD3/Ac889B7fbPetY/vrXv8bOnTvxxBNPoK+vD2eddRauuuqqpmmt8913Pp/HRRddhF/96le45557EIlEcPfdd+MXv/gFLr74YhQKhWM6ZolEIjllERKJRCI5am644QZhtVrF+Pj4gv/28ssvF5deein//K1vfUsAEJ/5zGfqtguHw8JoNIp3v/vdda/n83kRDAbFli1b+LUtW7bU/azmkksuEeeeey7/PDU1JQwGg/jIRz5St93ExIQwmUwiEAgs+JwWg1//+tcCgHjppZdm3CaRSAibzSauvvrqBe8/EokIAOLee+/l12Ybt5l+l0qlhMPhEO94xzum/e6GG24QPT09/PPGjRsFALF79+667X76058KAOJXv/pV3euxWEw4HA7x2c9+VgghxL59+wQAcdZZZ83rHGn7jRs31r1erVbFqlWrxNlnnz1t22b7npiYEADEf/zHf/Br3/3udwUA8eCDD9Zt+8ADDwgA4nvf+95RHbNEIpGc6siImUQikRwDDz74IC6++GK0trbOuE2tVsM3v/lNnH322bBarZwS99BDD+HQoUPTtr/66qvrfn7qqadQLBbx9re/ve51k8mEK6+8Es888wxyudyCj/2pp55CqVSa9n7BYHDetvrHA0p5+9jHPobf/va3yGQy07Z54oknkMlk8O53v3vWfY2NjeGDH/wgurq6YDAY6lIRm439QnjiiSeQSqVw3XXXTfvdpZdeisHBQQwNDfFrp512GtasWVO33QMPPACz2Yy3vOUtda+73W6cffbZ2LZtW93rjZ/VXDRur9FocNVVV2Hnzp1IJBJHte9HHnkEZrMZV1xxRd3rV155JUwmEx555JFjOmaJRCI5VZHCTCKRSI6SYrGIVCqF9vb2Wbe77bbb8OlPfxof+9jHcPjwYVQqFQghcO2116JcLk/bvnF/0WgUAJr2FQsGg6jVaojH4ws+ftpvIBCY9rtmrzXyuc99rq52biH/1q5dO+N+V6xYgf/7v/9DrVbDNddcA5fLhfPOOw933303OwROTU0BmD5WaorFIi688EJs374dP/vZzxCNRlGr1TjVrtnYL4TJyUkAwHve8x7odDpotVpoNBpoNBp88IMfBPDqGM90rJOTk8jn8zCZTHX7UBQFjz/+eN3fz3W+zZjtsz3afUej0ab7VRQFgUBgWvrlQo9ZIpFITlWkMJNIJJKjxGg0wm63Y2xsbNbtfvSjH+Ftb3sbPvjBDyIYDEKr1QIABgYGmm6v1+vrfvZ4PACAUCg0bdtQKASNRnNUdTter3fW/c7FV77yFa67Wug/tflGM6644gr8+c9/Rjwex29/+1t0dHTgAx/4ANfc+f1+AJh17J9++mkcPnwYd9xxB7Zu3Qq73Q5FUWYc94VCkbff/OY3qFQqqFarqNVqqNVqfJ5nn302b9/4udI+3G43yuVy3T7o7/fu3Vu3fbN9zMZsny19/gvdt8fjmfH6mJqammaOstBjlkgkklMVKcwkEonkGHjLW96Cxx57DBMTE7NuZzQa637es2cPdu7cOa/32Lp1KwwGA371q1/VvV4sFvG73/0O5513HiwWCwDAarWyG+R89qvX66c5CJIBxYmAw+HA5Zdfjv/5n/+B3W7HE088AQC48MILYbPZ8LOf/WzOfTSO/Y9+9KNp28w2bjP97sILL4Tdbsd///d/z+dUmnLVVVchHo/jT3/601HvYzYaP9tarYbf/va3OPvss+FyuY5qn5dccgny+Tz+8Ic/1L3+4IMPIp/P45JLLjnaw5VIJJJTGinMJBKJ5Bj42te+BpvNhiuuuAJPPvkkMpkMDhw4gM985jNsC3711Vfj/vvvx4MPPohsNounn34aH/jAB3DxxRfP6z38fj9uvfVW/OxnP8M//dM/IRKJoL+/H+9617sQjUbxjW98g7ddu3Yt9u/fjwMHDszZGNjv9+Mf//Ef8cMf/hDf/e53EY/HsW/fPtx0003YsmXL0Q/KMXLPPffg5ptvxrPPPotkMolkMonvf//7SKfTPGZOpxPf/OY38cADD+Dmm2/GoUOHkE6n8cQTT+Ctb30rAGDz5s0IBoO4/fbbcfjwYcRiMXznO9+pq/siZhu3mX7ncrlw55134qc//Sn+/u//Hn19fcjn8zh06BDuvvtuPo7ZeM973oPLL78c733ve/GTn/wEoVAI6XQaO3fuxKc+9Sl861vfOvqBxJE0wr/7u7/D+Pg4t3U4ePAg7rjjjqPe5/vf/36sXbsWH/rQh/Doo48inU7jkUcewYc//GGsX78e73vf+47pmCUSieSU5TU0GpFIJJLXJSMjI+Kmm24SbW1twmg0ijPOOEN84xvfEIVCQQghRDqdFh/72MdEMBgUVqtVXHzxxWLXrl3iPe95j2hvb+f9kCvjxMRE0/f5/ve/L9avXy+MRqOw2+3isssuE9u3b6/bZmpqSvzlX/6lsNvtAoDwer38u0ZXRiGEqNVq4mtf+5ro6uoSRqNRbN68WTz99NPir//6r5fMlTGbzYrvfe974rzzzhMOh0O43W7xhje8Qdx3333Ttv39738vLr74YmG324XT6RQXX3yxePTRR/n3O3fuFBdddJGw2WyipaVF3HzzzSKXywkA4tOf/jRvN9u4zfY7IYTYtm2buPLKK4XH4xFGo1GsXLlSfPjDHxZ79+7lbTZu3CguueSSpudbLpfFN7/5TXHWWWcJi8UinE6n2Lx5s/jXf/1XkUwmhRCvOhzec8898xpD9fY/+MEPxPLly4XBYBAbNmwQv/3tb2fctpFmroxCCBGNRsXHPvYx0d7eLnQ6nWhvbxc333yziMfj89qvRCKRSKajCDHHkqpEIpFIJJKTiv379+P000/HPffcIyNYEolEcpIgUxklEolEIpFIJBKJZImRwkwikUgkEolEIpFIlhgpzCQSiUQikUgkEolkiZE1ZhKJRCKRSCQSiUSyxMiImUQikUgkEolEIpEsMVKYSSQSiUQikUgkEskSI4WZRCKRSCQSiUQikSwxUphJJBKJRCKRSCQSyRIjhZlEIpFIJBKJRCKRLDFSmEkkEolEIpFIJBLJEiOFmUQikUgkEolEIpEsMVKYSSQSiUQikUgkEskSI4WZRCKRSCQSiUQikSwxUphJJBKJRCKRSCQSyRIjhZlEIpFIJBKJRCKRLDFSmEkkEolEIpFIJBLJEiOFmUQikUgkEolEIpEsMVKYSSQSiUQikUgkEskSI4WZRCKRSCQSiUQikSwxUphJJBKJRCKRSCQSyRIjhZlEIpFIJBKJRCKRLDFSmEkkEolEIpFIJBLJEiOFmUQikUgkEolEIpEsMVKYSSQSiUQikUgkEskSI4WZRLKEHDp0CIqi4Ac/+MGs2z3++ONQFAUPP/zwa3RkEolEIjkatm7diq1bty71YRwTP/nJT3D66afDYDBAUZSlPpxFpaOjAzfeeONSH4ZkDn7yk59AURTs379/qQ/lNUUKM4lEIpFIJBIJAODAgQN43/veh5tuugnZbBZCiKU+JMki84Mf/ACKouDQoUPyOE4wdEt9ABKJZG4uuugi+XCUSCQSyXHnqaeeQrVaxQ033AC9Xr/UhyM5RbnxxhtPycimjJhJJBKJRCKRSAAAkUgEAGA2m5f4SCSSUw8pzCTHjM1mw9/+7d/iySefxObNm2GxWLBp0ybs2LEDALBt2zacc845MJvNWL16Nf7whz803c+Pf/xjnHPOObBYLLDZbHjTm96E5557rm6bTZs2QVEUKIoCnU6HtrY2/NVf/RXGxsbqtvvVr36F8847Dy6XCx6PBxdddBF+//vf8+8TiQQURcHXv/71acexadMmXHrppU3P8emnn8b5558Ps9mMr3zlK7yvf/iHf8CyZctgMBjQ1taGm2++Gclksm4fe/fuxeWXXw6LxYJAIIBPf/rTqFar8xrjZjVmv/71r6EoCp555hnccccdaG9vh8PhwI033sjpJ1/96lfR0dEBs9mMq666ClNTU3X73b9/P4+noigwmUxYu3Yt/uVf/gW1Wq1u2927d+PNb35z3fEfOHCgaY3cfMdEIpFIloK77rqLU6g++9nPoq2tDYqioFAoAAAee+wxvOlNb4LT6YTJZMKmTZvwy1/+ckHv0dfXhze96U2wWq1oa2vDpz/9aZRKpWnbzee9PvjBD/J9WqPRwOv14qqrrsKLL75Ytx3Vtx0+fBiXXXYZrFYrent7eX8HDx7E5ZdfDpvNho6ODnzve9+r+3ufz4dbb70VAOD3+6EoCj760Y/y73/84x9j48aNMJvNcDgcuOyyy/DMM880PYb+/n5ceeWVsNvtuPbaa+ueu7/5zW+wdu1aWCwWXHjhhTh48CCAI8+1M888EyaTCWefffa0OQAA1Go13HnnnVi/fj3MZjNcLheuueYa7Nu3r267RCKBD33oQ/B6vXA4HHjHO94x7Rk4E+pj/e1vf4uzzjoLBoMB9957LwBgYmICH/7wh9HR0QGDwYDu7m7ceuutKBaLdfsZHx/H3/zN36C7uxsmkwmnn346vv71r9dtt3v3brztbW+Dx+PhZ/Cdd95ZlyXz7W9/G4qiYHh4GJ/73OcQDAZhsVhwxRVXYHBwsO494/E4brnlFvT09MBsNmPFihX4+Mc/jnA4DAD43Oc+hw996EMAgBUrVvB19dvf/rbuvQYHB3Hrrbfyd6NSqeDWW29tWnP48MMPN62Dn+385zqOmWrMFnu8TjiERHKMWK1Wcfnll4sbbrhBHD58WIRCIfHWt75V+Hw+8dRTT4l3vOMdoq+vT0xNTYl3vOMdwmq1img0WrePW2+9VRgMBvHNb35TTE5OivHxcXHLLbcIo9EoduzY0fR9c7mceOaZZ8TGjRvFxo0bRblcFkII8ec//1loNBrx1a9+VUQiEZFKpcSTTz4prrzySlEoFIQQQsTjcQFAfO1rX5u2340bN4pLLrlk2jm++c1vFldffbXYu3evGB4eFv/3f/8nksmkOOOMM8TKlSvFI488ItLptHj++efFunXrxObNm0WpVBJCCDEyMiK8Xq8477zzxCuvvCJisZj47ne/K6677joBQPzXf/3XrGP82GOPCQDiT3/6E7/2q1/9SgAQ119/vbjzzjtFLBYTzz77rGhpaREf+MAHxO233y6+9a1viWg0Knbs2CGCwaC49tprZ32faDQq7rnnHmE2m8U///M/8+vDw8PC7XaLLVu2iN27d4tYLCa+//3vi+uvv37a8c93TCQSiWSp+N73vicAiBtuuEHcddddIhKJiHvvvVcUCgXxs5/9TGg0GvHxj39cDA4OilgsJv793/9daLVa8aMf/WjOfW/ZskVs2LBBXH755eLZZ58VyWRS/PznPxc2m028+93vrtv2aN6rVCqJPXv2iLe+9a3C7/eLUCg07b3f+ta3ip07d4p4PC4+/elPC51OJ5544gnx5je/WTz//PMikUiIz372swKA2L59e93+v/a1rwkAIhwO173+jW98QyiKIr74xS+KUCgkDh8+LK699lqh1+vFY489Nu0YrrjiCvHnP/9ZhMNh8bOf/Yyfu9dcc4348Ic/LEZGRsTIyIjYsmWLWLlypfj9738vbrrpJjE0NCRGR0fFX/zFX4j29nZRLBbrjuPGG28Udrtd3H333SIajYqhoSHxzne+U7hcLtHf3y+EEKJSqYjzzz9fBINB8Yc//EEkk0nxxz/+UVxzzTWitbVVvOc975n1M6Rjvfrqq8WNN94oDh8+LA4cOCAeeeQRMTY2Jtrb28WmTZvE9u3bRTqdFtu2bRM9PT3iyiuv5H0MDw+L1tZWceaZZ4rHH39cpFIpsX//fnHbbbeJBx54QAghxJ49e4TNZhMXXnih2Lt3r4hGo+Lb3/620Ov14pZbbuF9/cd//IcAIN7//veLH/7whyIej4udO3eKnp4ecf7559cd+1vf+lbR29srduzYIfL5vBgYGBDf+c53xB133MHb/Nd//ZcAIPr6+qadO73Xu971LvFf//VfIhqNih/+8IeiUqmIT3/606KZdPjTn/40bY4yn/Of7Th+/OMfCwBi3759/NrxGK8TDSnMJMeM1WoVPp9PZDIZfu3gwYMCgOjs7BSpVIpfP3z4sAAgvvOd7/Br+/btE4qiiM9+9rN1+63VauLss88Wb37zm2d9/6eeeqru4fL1r39dKIrCIqwZRyPMbDabSCQSda9//vOfFxqNRuzevbvu9d27dwsA4sc//rEQQohbbrlFGAwGMTo6Wrfd3/7t3x6zMPvgBz9Yt+0XvvAFYTAYxIc//OG612+//Xah0WhEPB6f9b2EEOKjH/2o6O3t5Z9vvvlmYTQaxfj4eN12f/d3fzft+Oc7JhKJRLJUkDD7+7//+7rXc7mc8Hq94i//8i+n/c373vc+0draKqrV6qz73rJliwAgXnzxxbrXv/71rwsAYufOnYvyXqlUSmg0GnHXXXfVvbeiKGLv3r38WrFYFC6XS9jtdvHKK6/w66VSSXg8HvGhD32obr/NhFk8HhcWi0W8/e1vr9u2WCyKzs5OsXHjxmnn//zzz9dtS8/dVatW1Z3Xo48+KgCI9evXi0qlwq9v27ZNABC/+c1v+LVHHnlEABDf+9736vZdKBRER0eH+MAHPiCEEOL+++8XAMQvfvGLuu3+93//VwCYtzDr7OzkRV/i/e9/v7DZbNOehw899JAAwCL1xhtvFGazedpzX83b3/52YbPZpi1Wf+ITnxCKooiDBw8KIV4VGl/4whfqtvvP//xPAUDs2bOHX3O5XNOu60bmI8z+3//7f9N+txBhNp/zX6gwOx7jdaIhUxkli8IFF1wAq9XKP/f29kKn02HDhg2w2+38+vLly2E0GtHf38+v/e53v4MQAtddd13dPhVFwRvf+EZs27aNX9u9ezeuu+46tLa2QqfTQVEUtiUmV5/169dDCIF3vetd2LZt27TUgqPlwgsvhNPprHvtgQcewBlnnIE1a9bUvb5mzRoEg0E+9kceeQQbN25Ee3t73XZvfetbj/m4rrjiirqfV69ejVKphEsuuaTu9dNPPx21Wm1aGP/ee+/F+eefD4fDwakEd911F/r7+zmd8bHHHsPGjRvR2tpa97dXX331tOOZ75hIJBLJUtN4D/vzn/+MaDSK66+/ftq2l156KSYmJtDX14evfOUrdWngOl29l1pnZyc2bNhQ9xrd7x999NEFvRcATE5O4qMf/Sh6enrYwt7hcKBWq01ztOvp6cHpp5/OPxsMBixfvhwulwtr167l1/V6PXp7e+uexzOxfft25HI5vP3tb6973WAw4Oqrr8YLL7yARCLBr7e3t2Pjxo1N93XZZZdBo3l1+rl69WoAwPnnnw+tVsuv0zmoj++BBx4AAFx77bV1+zQajdi6dWvdM1dRFFx11VV121199dV17z0Xf/mXfznts33ggQewdevWac/Diy++GFqtlo/hwQcfxIUXXjjtua/mkUcewUUXXQSPx1P3+rXXXgshBF8rxJVXXln3M32e6jFav3497r33Xtx5553HlLbX7Pm+EOZz/gvleIzXiYYUZpJFofEGpSgKrFbrtNeBI/Va6hv45OQkAGDjxo3Q6XTQarXQaDTQaDT4l3/5FxQKBeRyOYyPj2PLli1IJBL4/e9/j1QqBSEEdu3aBQAol8sAgMsvvxw//OEP0dfXh4suughOpxOXXnopHnzwwXmdi5jB/bDZzWVychJ79uyBTqerO3ZFUTA5OYloNAoAiEajCAQC0/6+2WsLpXGMSQjP9Lp67O+66y68//3vx1ve8hbs2bMH5XIZQgh88pOfRK1WY2EWjUbR0tIy7b2bvTbfMZFIJJKlpvG+Ts+jm266adrziBzi5nMPm+1+T+Ya832vSqWCiy++GI899hjuu+8+RCIR1Go1VCoVaLVafvYRzZ67drt9xtfVz4SZoHMOBoPTfkevqcdltsn4sTyzaMyCweC0Mfv5z39e98x1Op0wGo11+9Tr9XC73TOfaAON51GtVhGJRPCHP/yB35+OwWg0olqtIhqNolqtIhaLzToO1WoVyWRy1jGla4VoHCOHwwGgfox+9rOf4aqrrsIXvvAFLFu2DD09Pfi7v/s7rjE72nOfjcZ503zOf6Ecr/E60ZDCTLIozNSAcj6NKX0+H4AjvVMqlQqq1SqLAnEk3RYWiwW//vWvkUql8J3vfAcbNmyAxWIBAAwMDEzb50033YRXXnkFU1NT+OlPf4pyuYwrr7wSjz32GIAj4lCr1SKdTk/720YjEaKZbbDP58O5556LSqVSd+x03FRw7fV6EQqFpv19s9cWyrGM/Y9+9CNs3rwZt912Gzo7O3llsHFMvV5v06LpZq/Nd0wkEolkqWm8r9Pz6H/+539mfB6df/75+NznPsc/CyFQqVTq9jPb/d7r9S7ovZ577jns378fX/7yl3HhhRdydsPIyEhTA6ljeSbMBEUo5nNeQPPn5WIcn8/ng1arRTKZbDpmsViMjyWZTE7LmCmXy4jH43O+z0znodVq4XK58I53vIPfv/EZd+edd0Kr1cLtds84n6B9ORyOWceUrhFiPmPU1taG++67D9FoFC+++CI+/OEP4wc/+MG06OFcNPsMKWuoce7UeJ7zOf+FcrzG60RDCjPJknPllVdCURT893//97y2b1wB+9GPfjTjtn6/H+94xzvw05/+FADw5JNPAgB0Oh26urqwe/fuuu2ff/75BYmlq666Cjt37pyzOeIb3/hGvPDCC5iYmKh7/Te/+c283+t40TiekUgEDz30UN1rF198MV544QVerSTIPUnNfMdEIpFITjS2bt0Kl8s17+fRTIyMjOCll16qe43u95RmvtD3Wsizb7E577zzYDab8atf/aru9XK5jAceeAAbN26Ey+U67sdx1VVXoVqt4v777591uze+8Y0QQkx7Rj3wwAPTHIeP5hgeffTRadGZRt7ylrdg27Zts4qTSy65BI8//vi0CM79998PRVFw8cUXH/VxarVabNiwAbfddhve97734dlnn2VXUCo9WWipx2mnnQYA0+ZOzeYC8zn/hR7H8RyvEwUpzCRLztq1a3Hrrbfi9ttvxze+8Q0MDw8jn89j7969+Nd//Vd87GMfA3AkL91kMuH//b//h1AohImJCdx2223T8r+/+MUv4gtf+AJeeukl5HI5hMNhfOc734GiKLjwwgt5uw996EN48MEH8fOf/xzpdBpPP/007rjjjroc/Ln49Kc/jZUrV+Itb3kLfve73yEejyMWi+Hpp5/GBz/4QX6IfepTn4LVasV1112HPXv2IJFI4D//8z8XJWJ2LFx99dV4+umncd999yGTyWDXrl14+9vfPq0+7VOf+hQsFgve+c53Yt++fUgkEvjhD3+I8fHxafuc75hIJBLJiYbVasV3v/td3H///bj55ptx4MAB5PN5HD58GPfdd9+0mpWZoAnxjh07kEql8D//8z/4yle+gne+850466yzFvReZ511Fjo7O/GVr3wFBw8eRDwex/e//328/PLL08Ta8cLlcuHzn/887r//fnz1q19FOBzG4OAgbrzxRoyNjeGf/umfXpPjuOyyy/De974Xt9xyC+666y6Mj48jm83i5Zdfxu23347Pf/7zAI7U85177rn4+Mc/jocffhjpdBoPP/wwfvzjHzdN6VwIX/va12C1WnHFFVfg8ccfRyqVwtTUFB599FG8853vxPbt2wEAX/3qV+FyuXDFFVdg27ZtyGQyOHjwID772c+ykPnSl76EWq2Gd7zjHdi/fz/i8TjuuusufOc738Hf/M3fYOXKlQs6tmw2i4suugi//OUvMTo6imKxiBdeeAF/+MMfcP7558NgMAB4tdbqwQcfbNrCYSauuuoqBAIBfOpTn8LQ0BCmpqbw5S9/mferZj7nv9DjWOzxOhGRwkxyQnDHHXfgpz/9KX7/+9/jzDPPhM/nwzvf+U5MTU3htttuA3DEUOTXv/41Dh8+jGXLluHcc8+F2WzGF7/4xbp93XLLLTCZTHj/+98Pv9+PNWvW4Pnnn+dCVOKTn/wkPvaxj+GWW25Ba2srvvGNb+Db3/72gh50TqcTzzzzDK699lp88pOfRGtrK1atWoXbbrsNW7du5QdrZ2cnnnjiCVgsFmzevBkrV65EX18fbr/99mMfvGPgk5/8JD772c/i85//PFpaWvCRj3wEt99+O84888y67bq6uvDEE0/AaDRi48aNWLlyJQ4ePMj9btRjNt8xkUgkkhORd73rXXjyyScxOjqKrVu3wu1244orrsCTTz7ZtPdlM6xWK771rW/h1ltvRTAYxMc//nF85CMfwX333bfg9zKbzfjd734Hp9OJTZs2YeXKlXjhhRem7et485nPfAZ333037r//fnR2duLMM89ENBrFY489hje+8Y2v2XHcd999+Nd//Vfce++9WLlyJYLBIN73vvdBo9HgE5/4BIAj0aLf//73uPzyy3H99dejra0N3/nOd3DXXXctyPyjGe3t7XjhhRdw/vnn4wMf+AD8fj/Wr1+Pr3/967juuuuwefNmAEee+zt27MC5556Ld7/73fD5fLjmmmtgt9vxpje9CcARYfLnP/8ZNpsN5513HoLBIO68806ejywUq9WKL33pS/j5z3/OvVzf+c534uqrr8b//d//8XZnnnkmvvKVr+DOO++E2Wyu6x82G2azGb/5zW9QLpexcuVKnHPOOfB6vbjpppumbTuf81/ocSz2eJ2IKGImpwOJRCKZgz/84Q+4/PLL8cc//pFvtBKJRCKRSCSShSMjZhKJ5Ki5//77YTKZcM455yz1oUgkEolEIpGc1EhhJpFI5sXNN9+Mhx56CIlEAqOjo/j617+Oe+65B//4j/84rb+bRCKRSCQSiWRhyFRGiUQyL3bs2IHbb78dzz//PBKJBHp7e/HhD38Yt9xyy0lpSSuRSCQSiURyIiGFmUQikUgkEolEIpEsMTKVUSKRSCQSiUQikUiWGCnMJBKJRCKRSCQSiWSJ0c29yclPrVbD+Pg47Ha7rIWRSCSvS4QQSKfTaGtrO+Y+PRLJa4V8PkskklOB+T6jTwlhNj4+js7OzqU+DIlEIjnujIyMoKOjY6kPQyKZF/L5LJFITiXmekafEsLMbrcDAK688kpUKhVotVrUajUIIVAul5HNZvHKK69g2bJlcDqd3H28XC4jk8mgUqnAbrfD4/HAbDZDp9OhVCphbGwMf/7zn2GxWFAqlaDX6+Hz+eB2u1Eul1EsFtHW1gar1YpIJIKpqSk4nU709vbCbDajXC7zdsViEVqtFgDQ09ODTCaD/fv3I5VKoVwuo1qtwmAwwOv1wmw2o1arQaPRQKPRIJ1OI5vNwmKxoKurC5VKBePj4xgdHYXRaIRGo4EQAoqioFKpQFEUGI1GAIDRaITL5YLJZIIQAslkEpVKBZlMBplMBi6XC1qtFhaLhVczM5kMarUaisUiTCYTLBYLyuUycrkcarUaKpUKJicn0dLSApvNhra2NhgMBpTLZcTjcVSrVZhMJmg0GiiKgmg0CkVR4HA4eEVBCAEhBKLRKAKBAAKBABwOB0qlEsrlMiwWCzQaDSKRCH8mlUoF+XweqVQK2WwWJpMJgUAABoMB1WoVPp8PiqLw+7tcLlitVtRqNWSzWYyPj+PgwYNIpVIwGo1wu93w+Xyw2+3QaDSo1WpIp9OYmppCJBJBMplEsViE0+mEzWZDtVpFS0sLWltb+fhoPOgzrFarPA6Dg4NIJpOw2WwwGAzQ6XR8DdRqNb4+dDodfD4fLBYLIpEIRkdHoSgKv6+iKDAYDCiVSigWi6jVashkMlAUBXq9Hn6/H0IIOJ1OWCwWaLVaVKtV5PN5lMtlaLVaGAwGKIoCnU6HarWKSCSCVCrF17RGo8HIyAgikQgURUFPTw+WLVsGt9sNIQQymQwikQjC4TByuRwsFgtaWlrgdruh1Wr5vYrFIqrVKl9jlUoFfr8fDocDuVwOExMTCIVC6O7uhsPhQLVaRbFYhMViQaFQQKVSgc1mgxAC3d3dcDqdUBQFmUwGsViMv0eVSgW1Wg1arRYtLS1wOp3Q6/XQaDTQ6XTQaDSoVCpIJpPYt28fMpkMjEYjv180GkWlUkFraytsNhuKxSJGR0eh0WjQ1taGlpYWGAwGpNNpmEwm6PV6xGIxaDQaaLVaRCIRjI2NoVKpwO12w+FwwG63w2w28/mXy2Xs2rULy5YtQ3d3N/R6PYQQKBQKePHFF+H3+2GxWDAxMcFjWiqVkM1mAQBarRZarRalUqnp/U4iORmQ16tkLugZVywWj2kfwWAQgUAAiqIglUphamoK6XR6EY9UIpmbue55p4QwI0HR2dkJo9GIdDqNF154AZ2dnTAYDLBYLDjzzDPR2dnJoqxarSKbzSKZTGJiYgLRaJQn4TTRz2az8Hg8OO200/imkcvlMDg4yMIrm81Cr9dDURSUSiVUKhVUKpW649PpdNDpdEgkEojFYiiVSjAYDDyRKxaLSCQS0Gq1LGTK5TK8Xi9P5rRaLTQaDfr6+lAul1EqlRCJRAAcEV9WqxV6vR6pVIqFJYnUcrkMm80GnU4HvV6ParWKUqnE+9BoNAgEArBYLNDr9bBarcjn8wiHwyiVSsjn80gkEshkMtDpdLBYLNDpdJicnAQARKNR+Hw+GI1GjI2NQQgBh8MBvV7PgsBsNrP402g0qFarfF4tLS1wOBw8ISdxlkwmUSgUEI/HWcgUCgVks1lUq1U4nU5YrVb+b7VaRa1W47+h49NoNJiamkI0GkU4HEaxWITBYEAikUAkEoHL5YLL5UK1Wq37jEqlEjweDwKBAKrVKsLhMPr7+zE+Pg6DwcCCWAjBCwEAePKfy+VQqVSQSCRgNBpZoJEAzOfz/DfZbBZWqxXlcpmvz0wmA61Wy2I9k8kgn88jHo+jVCrBZDLxdgaDAZOTk6hWqwDAY2s2m6HRaFjQOJ1OFqX0GSeTSVitVlQqFf6M8vk8xsbGMDY2xuMNgK95EscTExO8IOBwOPja1Gg0KBQKMBgM0Gq1MJlMsNlsfD3ncjlUq1XodDo4HA5oNBrk83lkMhmkUin4fD5otVoWWzabjc+FhBddx0StVgMAFq/FYhFTU1OIx+MsqmjBgoR0NptFrVaDTqdDa2srTCYTTjvtNFitVgBg4W80GlGpVJDNZrF//364XC643W6USiXkcjkUi0XodDq43W4AR6IEU1NTAIBcLge73Y6Ojg6+b5Doa21tRXd3N8bHx5FKpXgczWYzzGYzACAUCiGfz6NaraJQKMh0MMlJhbxeJXMhhDgmUUb7iMfjfK8sFovTFrUkkteCue55p4QwI8bGxqAoCsLhMA4ePIh0Os2RCoPBgOHhYY4OkWChCWcikUAul+PJn0ajgV6vRzAYRDAYhMPhQKVS4ahBqVSCVqtFNptFuVyG2+2G2WzmFe5KpQKd7sjw08/VahWpVAqZTAZutxtWqxUGg4EjZCQSS6US7HY7jEYjdDodnE4nSqUSYrEYJicnkUwmYTKZAIDFD4lDEgwk1gqFAiKRCKLRKE+EK5UKT4wBcISRJtEkLmkbmtiTYKDoFEX1CoUCYrEYACCdTsNms0Gj0fCE1ul0ctQBAEcuKAqZSCQwNjbGETaKAtKxJ5NJnnQD4M8ml8thZGQEExMTLH4BoFKpQK/Xs5g1GAy8D6/Xy9GWWq2GaDSKRCIBi8XCAqtQKKBWq/HNPRaLwWQywWg08rlSZKyxG4WiKBwVaxToahHXSD6f5zHWarV8bWg0GiSTSeTzeRgMBjidTlQqFUSjUb6W1RHIQqHAn6vBYIDNZoNWq+VoZzqd5vGjY1fvn84hnU4jnU6jVCqhUCjwMdHflctlhMNhPn76PtE1SOOv1+tZyNGYF4tFhMNhCCGg1+vhcrmg0+mQz+f5u6IoCvbt2wev1wuNRoNSqcTXBokr+gxoexJr+Xwe+XyeRXE0GuVIF4lhvV7PIomO0+FwoFgs4vDhwzAajby4YDKZ+HtB399AIIC2tjYIITA2Nob+/n4MDQ0hm83C5/NBCFF3PWYyGezcuRN6vR5erxcOhwOZTIYXTfR6PUffrFYrC+TR0VF0dHRAq9WiUChgz549870dSiQSySlFoVBAoVBY6sOQSGbllBJmu3btQq1W47SgZDIJnU7HE2GavNJktVar1UW5MpkMgCMTU6vVipaWFgBHVqyTySQURUGhUIDFYuG0J5qAkshQFAXFYhGZTAZms5kngCRyarUa74duIJQGWCqVEI1GYTabYTQakclkOH2NVpRosqe++ZTLZV5tp4hYrVbjFXfg1Yl/MyhS1IxyucxjQmNYLpdZ+AHgtEgStg6Hg8VVrVZDPp/n6FGlUmFBQP+llFISypR2qdPp+NzV0OS+8Xyo2JIigC6XiyOFVquVx5LES7VahV6vr0tpJSFP10YsFmNhptPpIISA0Wjkz5COWX2MzVZLaPVutraCFHUjEQGA0/soqkMRNwAssrPZLAwGA38e+XyehWW1WoXZbOZ0xGQy2XQVkSKEiqI0PUZaVKDzo8UEug6r1Sri8ThHfGghgv7R507XsfqzVws8gtJJx8fH+XqmiC99zupxoUWHarWKXC6HXC7HiwFWq5XFV6VS4UUVvV5fJ7wSiQRSqRR/Ti6Xi4Uy7btarcJut/PCgEajgdVqhc/n40UCSk+lxROfzweHw4FIJIJIJIL+/n5OgU6n04jH4xz1pGuevq/j4+PYsGEDWlpaUCqVpDCTSCQSieQk5pQSZuFwmFN9HA4H2tvbYTabObUKOBLRSaVSHA2glC+KuFQqFU6XSqfTiMVidZMzAJz+RCv2wJF0JZrEp1IpWCwWWK1WGI1GFhG5XA5CCBaBRqORhQ5N9Kk2JR6PIxqNIpfLIZvNzjihpzol9c/AESGQTCYXbWzV71+pVBCLxZDL5VAul1Gr1TjCIITgCAnwanoZiTL1hJhEq9FoZHGaTCZZxFGK3Hx7pFNqoVarRbFY5Po9IQRH6EgQ03GpIzAUaWmGWghTRIPS/0jU0LGqPw+Crq9mQrNxfEkQziSSqH6PPl8SgvS+JIhJONF13SzNdrbjmGsbiiCqz7FSqSCdTteNBYltu93OKam0QDHT+1G0kCJtlLZJ+yYoitZslZTSmNXpseoUF3pvg8HANWVGoxEmkwmFQoG/fwaDgdMt9Xo9CoUCCzCKTlJNYLFYRCgU4nRZs9nM6cVbt27FwMAAtm3bBqfTCb/fj8nJSX4PRVEQCoWQy+U4hdhut/PPEolEIpFITm5OKWGmjowlk0lotVoYjUau6aCUPDKoIGgyViwWeaV/pgjSXGSzWWSzWTZaoNozEoZk0kFpgGRgQGl+FNmg6N18oX29FlDapVr42e12ngST6G3EYrHA7Xaz2Qb9K5fLyOfzHD0AjnwmZrOZjRDofWeDJuw0+ab9zJa7Tp/3fEQLAL6GKHpF6ab0mc50jDTxnkv4qCOTzbalCI06J59qE9W1YLSPZpHFxvebr/BVk8vl6n6mSC0dj8FggMlk4pRYSgMksxStVjvjOQKvRv0IEnPq86NznCl1JZVK8QKBGhovdU1gIpFggd0I1dURc42ZTqdDIBCAzWbjOrxdu3ZhxYoVLDLD4TC0Wi0mJyd5YYMWlSwWC2w2Gxu0jI2N8b1MIpFIJBLJyYsijmbWdZKRSqXYAKJUKtUJNKqLWkzmO5mluheaTFMqFNX8LPZxLTV6vZ6jQo0ChRzmTCYTDAYDR1Qa0zoJ9RhTRK1YLDat63qtIDMNen9Kdzzaz7HZdUSiYSaRaDKZYDKZkE6nT6jrJxAIQKPRIBwOo1KpwOl0wufzceSZirKBI9eJ0WjkujfiWBYX1IJ2KVEUhSOa2WwWTqeTXTQprTIQCGBoaIjHw+FwoK2tDR6Ph9NlC4UCJicnMTIyAgDsfnrw4EEkk0k4HI6lPE2JZN7Q81kikUhOBeZ6Rp9SETNynaNJWqlUgk6nQzQaXdT3mY+tq0ajYat5SmmkGh5yZYzFYks6kaSoBUV7jvVYSHg2m1yrUzgbIyXNGvGpx5jSwqxWK7LZ7ILTuo42KtQImZiUSqW6VNijgSJtJGJpTOYSWydqcTM5O1LdFNVkmkwmdi0EjogyajRL9vrEsUR8ybhkoZ+Joih8/S8GlPZMEW+KKlM6ZFtbW11qMpnTlEolTE1NcY1mtVqtq1XMZDI4dOjQohyjRCKRSCSSpeGUipgBizcJXyw0Gg08Hg8bYtRqNYRCoaNOlVysYyLTBLfbzXU/zdK+1Mw1tuRGR/b2BLkJUlppOp2elgp3PHG5XJxG91qmfM4E1eOpj0Vtr0/1jMdqH3wiQI6D+Xx+TkG5GL1s5sNS3SPou5ZKpWasHfT5fLBarRgfH+d6Tdp22bJlGBgYkBEzyUmFjJhJJJJTibme0aeUMOvu7ubeRcd78k0r9BQJms8wBwIBWK1WaDQaDA0NoVwuw2w2o1AonFBishm0sq/RaGYUVXPVc80HdfuAxWgMSREacl48nuPcbMLfTAgutTgkJ0rgyGdmsVjqHDMp6rkYUVRgfmmG9DnNZsBCqB0WZ6vra0Sj0cBisXA96fG+HkwmU51ByGxQawe6j0WjUZhMJuTzeUSj0TqBJoWZ5GRCCjOJRHIqIYUZXr3xOxyOaQYIkqXFarXCZrOhVCqxJf5Codq1Y6nnOl6QyQX17gLADbmBhU3O1fukHlu5XI7T49R1Z0cj7hRFgc1m41YMFMFyuVwshI/2dkGOjJIjaDQauN1u6HQ6hEKhef0NRQwptXHVqlXo7u7mhvYOhwMPP/ywFGaSkwopzCQSyamEFGY4+hu/wWCAy+ViM4VkMgmz2Qyr1YpkMjlr9IeMIMjinjCZTLDZbABebSw9n7Q9nU7HaUxCiLq+YxQZ0Ov17Fp4omO327mtAEF91WaLiJCjH/UqW2zoOiGrf4ImxWS80WjJrv4aUU+r2b5aGo0GXq+Xo3VTU1OLcj4OhwM+nw8AWPBRi4FT4Kt+XGgmfOeC6jPnK46pp5nRaEQ6nZ7176gJtdlsRiwWq2uLQI6zUphJThakMJNIJKcSJ70w++QnP4l777237rXTTz8dTz755Lz3ob7xkwOiTqdbkIihVKKZIjrt7e1oaWmByWRCR0cHnE4nKpUKkskkEokEstls3d+mUikMDw8vKEJEYk+j0aBQKMxqcuFwOOa0Ql9q7HY7N/el2ppsNgubzYbW1laOslBfKWoroNFouI8ZACQSidckUjaXIyKhNmyYz8S8McWTxuNovppUh6TT6ZDNZpHL5aZZyy8FiqIgGAyyRXw4HOZrnxonN/bcmy/U8LvRwZGiqLRNs8+NPqdmrxuNRlQqlaYLBRaLBS6XC8Vicd7mQdQi42jOcSFIYSZ5LTn77LMxPDxc99rNN9+M22+/fV5/vxTCTFEUXHDBBeju7sb+/fvx/PPPy4UriUTymnDSuzJmMhmcf/75uPvuu/k1auR8NNRqtWmRGjVms5n7K9Fk2Ww2Q1GUusiWTqdDZ2cnR6qy2SxeeuklrFu3DlqtFt3d3fD7/dBqtUgmk+jr68Po6Cj0ej1cLhfGxsYQj8dxzTXXwOv1QqvVcmpasVhEOBxGX18fenp6EA6HsX//fuRyuXn3L8tms9zg+ERL7yPS6XTd+ej1erS2tsLr9QIA4vE4pqameELd7MGp1+vr3OkWgsfjQbVaRTab5fdQpwBS/zF1bVUzKIpHNubUuFl9jABmnJCrRZnFYmEr9aOhUChgbGwMwPys4SkS2HgcRwvVd6kbZbvdbm4UrtFoYLfbUalUEI/HUS6XZ+wPNl+aCS7qh6bRaKDVamGz2VjAkaMhfS6FQgGZTKauZyC5QlLfsMaoNi0kUFQ9mUzOqwedwWBgcTrXOZvNZmi12mlR92b4/X7k8/kF9zeUSI6VWCyGz33uc7jxxhv5NYvFsoRHND/y+TxSqRRWrVqF0047DU899RTGx8enzQ0oC4Ga2EejUUQikSU6aolE8nrnhBdmwJHVa0rPWgxmix6o3eGEECyYgPoJYKVSqVslpLSlVCqFZDKJUCjE0blKpYKhoSEUCgUUi0X09fXhoosuQktLCyKRCJYtWwar1cp1PBMTExgdHUVvby9WrVqFUqmEYDAIu92O0dFRhEIhJJNJpNNpOJ1OtlLP5XI8oa9Wq0in00ctWuaLXq9ng5NmUG3VTEKDJrM2mw0OhwN6vR4TExNIJBLTUsG0Wu00caQoClwuF2w2GwuaRCIxL8t4qk2bqUn1fFPXhBAc+aMedOpJejNB1uxcAHDN2LGs3qr/1uv1srEJnRulzZGpzLEKMrWlPLVEUJNIJDjdzmw2c3pwS0sLN5aey9DjaKDzrdVqSCQS0yKTJJTUkU0yNqEIebPzAcDNnunamWnRgMQgNcCmKOZ8Pt98Pj/rtUDpsAC4RlMiWQpsNtuiPqOPN0IIvPjii9DpdJw943Q6uaE74XK50NnZyVkIwJF7t1qYuVwurhmWtbQSieRYOeFTGT/60Y/iF7/4BaxWK5xOJy644ALcfvvt8Pv9895Hs1QJu90+715hzVzjFEWB3W6H2+2GXq/n4nuPxwOr1coRlMnJSWQyGU59yuVyCIVC0Ol0sFgs2Lt3L9773vfC6XSiWq1ifHwc//3f/41LLrkEdrsdhUIB+/fvR1dXF3p6etitsVarIZ/PY9WqVUgmk3j66afR0dGBRCKBgwcP8nHabDYWbereSI29wo6F2SaPJpMJWq12zgiQ1WqFxWJhN7xG8Uzj2Uzk2Gw2NlLI5XJIJBKzig2Kimm1WgDgiTdFUOZy0Ww2frQvdQqi1WplK/jZjkfdY2uxoR5wNJ4Gg4EXGxZzArHQpurq71Rj2iYJJhI0c3Es1/OxiGCKxs12jMfa2LpZrZpWq4XVauUaQqpnpG1kKqPktaSnp4evwc7OTlx77bX4xCc+Me/MlqWsMevq6uLFtGbPDUpLt9vt3OA9EonUGfYstYuuRCI5uTjpUxlbW1vxL//yL7jwwgsxNjaGT33qU9iyZQt27do1Y7pEY21Vs/5blUqFJ/tz0WwbdQ8hnU4Hs9mMfD6PZDKJSqWCaDQKv98Pn8/HPakGBwcRDof5Rp5Op+FyubBr1y4WiYcPH0Z3dzdyuRzGxsYwPj6OFStWwO12I5vNYmBgAOVymXuf+f1+6HQ6eDwenHvuuQiFQtBqtXC5XHjmmWfQ2tqKUqmEiYkJlEol6PV6nkwuNMVxpgnwbGNYLBbnFbUj8UK9xOx2O09KafI5k0lKLpdDrVZjs5W5JvMU5WsUQvRwneuaaPYQbjaWFH2d7aGtKAqq1WrTJtpHg8ViYWt5qnkslUpIJpMYHR3l8aFzXKyeXfPdx3yaZDf7bObanq7NhU6QjuXc51MHOJ/9zxQ9BV5NCcvn85yaabPZ0NHRwT3dBgcHX9O+fxKJmvPPPx9/9Vd/hdWrV+PZZ5/Fxz/+cezduxc//OEPm24/n+fza8XExAQAcLS/EUpLL5VKSKVSTWuMpSiTSCSLyQkfMWtkamoKnZ2d+N73voebbrqp6TZf/OIX5yw8ns9q93yg1X/aH6V0UaqW0+mETqfD1NQU133p9XrEYjFEIhHYbDYEAgG0tLQAODIBM5lMCIVCyGaz6OjoQEdHB4QQXKdWq9XQ2tqKlStXwmQyYXR0FK2trVixYgUikQhefPFFnHbaafjlL3+J8847DwcPHuSmzoqiwGw2w+l0QqPRIJlMHvcUKKPRyD2X5ppwU7SEmk2rowGzTejJOW8+favU/aoURUE+n6/rA3U053cs6YDUn6pWq3HK30IhW/5sNouenh7uJ9fS0oLJyUkAYDEPHKnvi0ajSCQSxyWNUE1j1O54cLybQtN1SemNixXdtFgsdSmRjVDUQe3yqdfrYbPZ4HK5YDAYkEqlEIlE+F4mI2aSpeTnP/853vWud2F0dBTt7e3Tfj+f57NEIpG8XjnpI2aNtLS0oKurC/v3759xm8985jP4h3/4B/45lUqhs7Ozbhta7Xa5XDzRolS4ZhM8nU4HrVY7bQKurk1pFHmhUIhz0WnyS39PP6v/3mg0QqfTob+/H8lkEgaDAfl8Hvv27UM2m0UymUShUGAzktHRUeRyOQQCARgMBvT19WHPnj3wer2IxWK833Q6zdEkamBNBghzRWqoX1bjKuF8LOGBI+l8ZrN5RhOSxv1QvZo6RUvNTGkj9HdUGzSbCCCrfdpmvg3AZ2K2lECKphqNRgBHonuN0Q1qf6CGrPlLpdK0Y1N/bjSmWq0WHo8HqVQKXV1dvAjQ3t4Oj8fDdZqULjo2NgYhBPx+P6xWK4Aj35MDBw6wQQXVnx3rirZer58mmA0GA7d5WAyO9/oSXV/zTVtqFl1utngw18JQ47VFC0AUBdfr9dDr9SeswY/k1GPz5s0AgAMHDjQVZvN5PkskEsmpykknzHK5HMbHx2etMTMajTwRng802VILgcaJlTpNihzdyLa+Gep0DZ1OVxf1UfdEIlGYyWSQTqcRDocRiUR4+5GRkWlW8VqtllfJjUYjWlpa0N/fj1AohHK5DKPRiIGBAQDA4OAgR1OKxWJdM+fZTDuImcSX2slvtklhtVrlVJBm2zXb92z7a7Y9NXCu1WrcG24uyHGvsQWC0WhkAT7fye5M2+l0OthsNnb6pOgqCTO9Xs9phY3XEUU3m9E44ScTiM7OTo6gFgoFLF++HHa7HaVSiaM9xWIRw8PDSCaTaG1tRSAQ4AbS0WiUo6jFYhEtLS0oFArQarVsxnI0kKFG4/mdZMH6GY1AmjHbual/t9BFAa1WC5PJxKnUhUKBha9EciLQ19cHADM+oxf6fJZIJJJTicUpbDlOFItFfOhDH0J/fz8AIBwO433vex90Oh3e9a53HdU+dTod22FrNBpkMhluJkyTY1rZVk+Mm0XE1DRu34h6Mk0udnSO0WgUExMTGBsbY1EGHDGDSKfTPHmnKFexWEQsFmM3u/7+fhw6dAjRaBQ6nQ6jo6OYmpoCcCT1U23jTpO5YrHIdSuzMZOgajbZbgZZkc+U+jVb1E1RFJhMJtjtdn6QN9vWaDTCZrOx2+B8J6kzvW+zKN3Rtmggw5JMJsMue2QUMhN6vR6VSqWuFkyNTqfj6CpFT6vVKiwWC3p7e1Gr1TA5OYlyuYxisYhCoYBEIoGJiQlMTk4im83CYrGgtbUVLpeLI3Plchl2ux3VapWFmF6vh9FoPCp3T4rqNYuMHWuU8kRnplrMma53as0wF7T4oBbyx7svmkQyE48++ij+7d/+jTM0XnrpJfz93/89zj//fJx55plLfHQSiURy8nFCR8yMRiO2bt2Kt7zlLRgaGgIAbN26FU8++SQ6OjqOap/qSTZFjGhSRBMmmjjPNnFvFBqNqWVq6D0areXJfCSbzc5YY0LHpT5mdRoe2eYLIWA2mxGJRKalW6r3ra5hIoFIjW+1Wi2n1NGYzCTA6D0oincsLo8z1QeRiDGbzXXjajQaeSyLxSLK5TKbh9DY0t82szyn9MlmDY0pzUx9zvNJ+Ww8buDI557NZnl89Ho9LBYLrFbrtIbjauZ6L/q86FwKhQJCoRBGR0fR0dGB3t5e5HI5hMNhtvIn8aXT6RAIBDiCOjg4iFQqxeYqsVgM4XAYpVIJoVAIiqLM6JJJkRr19dh4HtQMfL7jRtFr9SIGsHipirNda/S6Tqfj417sSNRMxjl0X6pUKk3Hiz7zxn6KEslSsnnzZjz88MM4/fTTkU6nYbFYcP311+MrX/nKUh+aRHJSQRk0EslJY/5RKBQ4IrJQGu14G+3JzWYzTy5pQj+f+qlGZqs/MZvNLMRIKJAAnE8zYTIJUIsP4NVIXeNkjlKeKH1NLSTVk1BKyzSZTDCbzQiHw3C73ewkmc1mkUqlZpwMqsXPTOeu7nM10+9mE3bUa4q2t9vtsFgs7GxJ/bgaj8tsNnPdoPr8yamwsZF0rVaD0Whk4a0WcwsRn9TPTJ0eqygKjEYjLBYLi3H1MTVa9zcbJ2B2gWI2m9HV1QWLxYJCoYDh4WEYDAb+PNURRRKm6XSae/jo9Xqk02m2gqa02cbollarhcPhgNVqRaFQQDKZbPpA0Wg0MBqN8zYXofdTG71Q+qd6XNQR54UKp2bfUfoOkBCzWCwwGAwoFArTUkwXw2RkJhdG6kmYy+Wa1pZRmi2J/ZmuFWn+IVkK8vk8zGbzgv9uKe3yJZITBXL2lrz+mesZfdIIs2PhRLnxq6N1C12NJzMI6mFG+5vJWdJsNiMYDMJgMGBqaqquRogiHdVqle3zhRAsGs455xz4fD4IIRCPxzEwMIADBw7MenzqqJK6Hk+r1XKN3fHo0zUTWq2WBfhcNztqDk1W8urIzdFGTOx2Ozs+lstlaDQaFsrNHCDpd7lcjqOX1Wq1afSkmVhphBwYi8Ui0uk015lRaqUQgvu/qUVnLpdjF0eDwQCz2cypvgQ5WlIvvZkcKWdaNFgojeKdIlq06HCstzCKwObzeVSrVY4GViqVaec2m7X9fM+FHEobsdlsHAFtdl4k+AHwgkMzpDCTnEycKM9niUQieS143bkynsxQfchcUNROPaFt9nezCYd8Po+BgYGm4XF15Icm6RaLBTqdDl6vFwaDgfsnkfkDRTJmmgRT1I0EHx2vuj0AMHOKZLOI0FxRpNmoVqvTJr8zRTsaI5YWi4Xt+guFwoLroUhIqCNONHZGo7HOzIXGQF3f6Ha7YTabkclkkEwmubYQODI+JJgoBbEZsViM9+XxeJBMJjE1NYVSqQSTyQSHwwG9Xs+psKVSaVqNEzlCUm854FVHy3w+P+OYkNBrdmxHk5pIxiUkdOl7QfV1xyrMyCFSXds5W01ks6jbfCOqzRw4aX/qthXqz4LGnprUp1Kpo26rIJFIJBKJ5MRFCrNFpHGSeLSTRqPRCIPBwLVjx0KzaFqztEcSDAcOHMD4+Dg2b94Mq9WKTCaDarUKp9OJXC43owtls8msWpwQgUAAZrMZsVgMiUQCtVqtzmmOIgUmkwlerxeKonDd3EwihCbtQL3bn3r8NRoNp6fR75qlV+p0OpRKJRSLRRabamOYuVAUBVarle3mSaBQHRxNyunYGq8RIQQLMhpP6utGx6XVamGz2WAwGDjtsBnRaBTAEdEcjUb5WpgpRc9sNk8TDvQ3FM1Jp9PTPge12KIeW7lcrmkkjaJRJHjnQ7FYZDGqrgtsFnWiY1ELm7kEE/UOnK8VfrNtHA4HKpUKNztfCM22J7ObSqUCq9XK0cxarQa9Xl+X3iuRSCQSieT1gRRmi0jj5I/EzEInUBQhaWxcvJhZpwaDgaM5xWIR4XCYf1coFLiQu1gsoq+vD1arlY9lIYKTatBcLhcSiQTGxsY4xZJEEEXPaILq8/mwbNkyeL1eTvs6dOgQ+vr6mkbuWltbYbfbIYRAKBRCMpmEyWSCXq9HJpOBTqeD1WpFKpVikUhRqZGRkbrjVYuFSqXCAk5tCDPbxJvq33K5HDKZzIypiBaLhU1NKJqoHn+1EYXf72dxRbWQVKPYLC9dHd0icUavzyRSyLlzJvfJZg6RlJZnsVhQqVSQTCZZnMzVQsBisSCRSKBUKtVFZGcSa7NFsQgSLOQkSQYetKAw0zFVKhVkMhlOvTya7xnVfy6WWYjT6UQgEEAmk+HUUrvdzjV9czl7SiQSyamA+nknkbwekDVmc7AYqVLHgsfjgdvtZse8mep5FoJGo+HaskqlwmlsVAO3ceNGeDweDA4OIpvNIhAIIJfLsa3/Qm+Aer2ex58abs+G2WxGS0sL/H4/fD4fTCYTkskkHnvsMfT09AAA4vE4KpUKDAYDC7hYLIZIJIJSqQSr1YrW1lYEg0HY7XauGapUKvz/w8PD2LdvHx8jGbRQSwGK3JHToU6nQyQSwSuvvDKjYUsgEEC5XOYURMJkMsFqtXLLgmOJdlC9Ggn3xlqjxbhm51uIrNFouIk49T9TM1cK7GJC0VlqukxOlAvpSaeGBONMn5U6yns86Orqgl6vx9TUFNLp9Lz/TtaYSU4mZI2Z5GhxOBxYsWIF9Ho9Dhw4gHg8vtSHJJHMiawxO0aWQpSR410ymUQsFuNeXmR7TnbvJEQamSvNieqEKEJAE3lyENy3bx+SySS2bNmCVatWoVAoIJfLcbpbLperi+hQdKqZSACORFsSiQTXrTVDbQGfz+cxNDTELRLUDA4Ooq2tDTabDfF4vE6gNeuXVqvVUCgUkM1mUalUYLfbodFokM/n66KEGo0GbW1t8Pl8qNVq6OvrQzgchsfjQW9vLzo6OiCEgFarRTweb2qGotPpmqYWUsokpWnWajW0tbXB4/GgUChgYGBgXsKB+onROM9k/kARo4VM5hsh05bGCFajcyA5Y9J7KYoCi8UCu93OaYcUtVJD1/B8vl9qkdWIx+Ph96LPWW2gMptoosjmTMzVUFqj0cDj8aBYLPJ1OF/mk4oYDofZwEZaKUskEkk96kwL6u15rGZTEslSI4XZIqKePNlsNm7auxBxp45kke35+Pg4gCOCzW63Q6fTIZPJIB6Pw2AwwG63s4EDRVG8Xi/cbjeKxSIikUjT6EezSWetVkMqlcLatWvhcDi4v1UkEsHExMS0cyFRZLfb62z1tVotLBYLT9grlQpSqdSs520ymbixstFoRDAYZGv7kZERHhPajs6JXA8pkkfRJLLSp58ptbFWq3EzZYfDASEEhoeHEYlEuLZHURS4XC4eg3g8ztERt9uN7u7uacJR/UAgcUI96igVT6fTwe12sxtisxQ7ivqQkKN9abVaPqfZoJ52JpMJ0WiU65IWYmKSyWTgdruhKEpdqmUz0wl1o+t8Pj+tL5/dbkdHRwc3vqYHqV6v5zTW2VoqzCRIbDYbVq9eDZ/Ph3w+j4mJCYTDYW4poTbTaKSlpYUNYo528WU2cQwcuQbcbjebrKhXc+cTMVXXJEokEomknng8jmKxCIvFMmPpgERysiFTGY8j8zUTOBYo0kSTV5PJxBP3o7H2pojH8uXLYbPZUCwWEY1GMTw8POME1mQy8aT8aCFzidns1wmn0wmNRsMTXYPBwHVroVAI+XyehSlN2MkFkWzsq9UqC7NSqYShoSEIIeD3+3k88/k8arUarFYrvF4v19mNjo7OmTLhcrnQ0tICnU7HkU9yRKQ+WRqNhsU7pScaDAauDctkMhBCwOl0cs+wVCrFtW+z9bIiTCYTix+73Q6j0YhMJlMnnBpFNNHS0gK73Y5MJoOpqalpn7/VagUwvz58C4Wuw9n2bbfb4XK52NGQoqLz4bX4bh4L1A7gaPopylRGycmETGWUnMiQ2ZbRaMTU1NRSH47kdYDsY4ZXb/wej2ea0QJhtVqPywTzZIHqy0jAeL1elEoldobU6/V1q/xWqxUOhwOZTIYFxEw4nU4YDAbE43FoNBr+mYwMjEYjHA4H9xIjEwVKU5gt8gEcSWfz+XzcIDkSiXB0TQhRF+WxWq0svGw2G4AjdW80SW9086PXyACEhE0z2tvbAYDHQ6/Xs/FEo1tnI3a7nZt8p9Npdqyk+rlSqYRUKjVNtCqKwnbvc4m0QCDAQpSEnxqNRoP29nbUajWMjY1BURQ4nU7YbDbk83kkEolpjZ5fy9uH2+2eJohJ4JbL5WPqL0ZQTz+1aNPr9fB6vXx9JRKJWfdBzaCBVyNjer0eAJpGO10u17Tr9FiQwkxyMiGFmeRkYKn9BiSvH2SNmYpAIACLxYLR0dFpv1vqlKHF+tIfzX50Oh3sdjvcbjdbopMTnLrfmRp1k+u53jOVSqGtrQ1dXV0sckicUPqjevyNRiOngFFa2mzpe/F4HMlkko+DzCYaj5lEDNVIFQoFuFwumEwmTkkjww86Zzovco2crc4nFotx+l82m62LdpCooxx4Ml1RjycZrNDx22w2mM1mAEeiUmpXTKrHK5fL8zafCIfDXJOobgButVphMBjgcrnYKTIcDrNjYiqV4vOhvyHr+rneuzFqS7VV6oghpVparVY21DAYDDAYDOjv70cwGITRaMTExETdvnU6HYxGY9MUTXJ/NJvNqNVqTSN+jdjtdm6araZcLvNK6Wz7oHNttg8aA3Lk1Gg0SKVS3FqhWq3yIgX1j5NIJBLJiYG8J0teK04pYXb48OEZ05eWOq1psb70QghYrVa4XC6USqW6flgzQVbnmUyG63yo/ocmlI0Rn0KhgHA4PGuTa/Ux5fN5mM1mlEolhEIhtm3X6XRsd0tRO41Gg0QigXK5XCdSXC4XstnstKjJTM2MaX8kqCgqoe55lkgk6oxMKEqnPneDwcDRtZkirsCRaMjU1BTXp5HIoH0VCoVp0UWKFhoMBuTz+booVi6XY8OUarUKl8sFt9vNNW/pdJojkFarlev4Zqp7avY5VatV/txTqRSLWxKgND5qIW40Gme1tm/cv5pyuYyVK1fC4/Egl8thaGgIOp0ODocD+XweqVQKer2eLfiBI9cbifTG88lms3XXEokjqjGjyGuztE+bzQa73c6fGUW1qIWEOl10PveH+UTsqMm82+1GKpWC3W6Hz+dDLpfD5OSkFGUSiUTyOkLd51MimQ+nlDA7ng1Z1bVdx4JWq0V3dzd0Oh0mJyfnbDJNUQOKLAFHon9Uh0Tpic2Ol9LastksXC4XPB4PNBoNMpkMRkdHm/Zls1gs7LJIookEULMoFZFMJnkSrT4etfCj2i+ylgfAZhdk0tAsQjNTxK5arXKEwmKxsFA1GAx87iS0rFYrnE4narUakslk3XmUy+VpxiUWi4WPUVGUur5liqKwADObzWy8QeLQbDZzE+ZsNotEIsGmIOp021qtxv9PTb5dLhc3W6baOZPJBJvNxqJpdHS0qUigHl/VapUjVfQ+JEysVmtdz7BGQw5yuaT/b/ZZkABvJtzsdjuCwSDcbjfC4TBHXMm5kfraTU5OcrpsOBxGPB6fFn1rfH/q7UZ1eiTO1KJMURSuPczn8/x+dP0CqLueyYL/aO4dFPWjejaKMJbLZcTjcdjtdhbYZrMZ7e3tGB8flw9wiUQiaQI952YzElND/WCdTie7GTfey61Wa53T9GJzMt7PjUYjPB7PtCwVyWvDKSXMjgdarRZOp5PtugEctWWrXq9HMBiEw+HgVDdK65rJ3ZGiBY0TVvWKf7Njstls8Hg8SKfTSKVSLCTUAqIRmsjWajU4nU6YzWZuRq3uIeVyudhJkt6XokYGgwFWq5WNNdSTaxJ26uMngVStVtm5kY5PCMFir9lYmkwm6HQ6bmZN4oMEmvq9XS4XN/AtFovQ6/UsBGu1GgwGA0diSPDa7XY+L3WUiv6O7NrV56/eJ6Xgka283+9nF8hUKsWfB5FIJKDX6+F2u9m6v1Qq1UXPKB2vGdTom2rWEokEG37QcVCUSX2dUE+zVCrF0UOKmhWLRR4zOj8SO2qoJxjZv6vFYblc5gUCilYSTqcTlUoF2WyWVx6NRiNMJhOKxSI7V6rPgcaMhJxWq0UwGITH44HVamXHzlAoxO0NKHKovl6BV0Xr0UDnqE47VeN2u7lP344dO2C324/qfSQSieRUoFAo1PVcnWvBjJ6XtDDbbF6mfoYsFid7PRplLUmWBinM5kCj0bAIaAbVk6i/8EebFknpbqlUit366HU1FCUDMG1yqoaiUM2OiWqGaHJMboiN21HvNBIC1PuMjDXUNzu9Xg+73Q6v14t8Po+Wlha4XC4UCgU2m1CLPookkVMhcCSqSRN9NRqNBg6HAxqNBpFIpE6cqceDokYUqSLTCnIetFqtSCQS02qAKKJHwpSEGUXd1FETIQQf40wW9mS1T0KMBAOdX+NnarFY6tInXS4XgCM1ePRaqVRCOBzmKCp9Xur31mq1sNvtyOfz04QApU1StJAiSSQq6f1tNhv/bT6f595pJBTpNXXqX61Wg0ajYXfNQqHAaYQkuABwNNbhcCAUCiGXy/Hv1FEturaKxSI3/abrplqtsuBtvO5phZR61dH22WwWZrOZV0dDoVCd2Q+JOhKX6v0e7QOWrh3gVVFmMpnq0nP1ej3a2trQ0tJSZ0IjkUgkrxVkbnWi282r09vnkzperVaRTqeRzWb5mTTTPheTk1mUAWi6uCp57ZDCbA7IpU19Q1DfwKh+Ss3RTq5qtRri8ThPVsmIgiaN6looo9HIfZhmez+1eYUaSuVSN5hu3Eaj0XBqG6UYUg0WRTjUE2sai3g8jra2NqxatQp+vx+FQgFjY2MYGBjAyMgIT/51Oh1SqRRHTehm2+x8hBBcf0RCAQDMZjMsFguPR6VSYcFBESA6z2q1CrPZzJNlNY0OheqbNZlUqG9UFHHSaDTI5XLTbmLqKA8dy0znRpGdZDLJ50DNpEkQ0/WgTjNsRi6X4zTJRkj4qxcbSMhSFK1QKLDDJdXyqcWhOspHx92Y9kgNrul86PMj4Tc+Po5oNIpcLjermQpd342QeQqhds00m81wuVw8BuFwGNlslvv8UU+5mVYD6fOhNMSFmKs0QlFVivxSv7f29naYTCZoNBr09/dzr71CocBpyRKJRPJacjKJiZnqyhuhTAjJwpCibGk5pYSZ0WhEuVyGy+ViK/PG3k0ERVwoXYsmfeTyFo1GOe2JGiEDr0YdaBJeLBY5OkW9iWa7qTSbdDbeMClqoZ7oU1SncaI7U0oZbU/W8eqJvPo9G9PUaJ8kEhrrj7LZLDQaDTo7O2GxWKDX66HT6eDz+dhxsFqtwmg0cmobRaDU4rMxVUEIwal8FKmhz4k+V4oy0vE1mpfQmDWOSbOeVmoHwmZ/Q3VlZIuv0+nqJtTq96L0zGaQRX4ikaj7e/XnqNVqm/5tMygFVH0N0RjT70mYUsTNbrdzu4hisciiOR6Pw2azNTU8ofEmow4ALHxIxFM0VW0dT5/1bPWYFOm12WywWCxNbeRnShUhIUwphOqxKxaLSCaT/F1WR4jV4hc4Es2lNgSETqfjaGAj6muIjk1dM+l2uzlFsqWlBW1tbRgYGECpVMLo6Cgqlcop37JDIpEsDfMVOicSR9OndbGg2uHF8BWQSBo5pYRZS0sLEokEgsEgN84dGRlhNzqaJFPdmMlkQjQa5RQtr9cLo9HIaXkejwf5fB5WqxVdXV1wu91se57NZhGJRJBOp7n+TF3zBcxvVWI+EQPgyMSQTA9m2y8dg1po5nI55HI5aDQaFp4UiVMX2c628kT71Gq1XP8TDofZWIHEnVoUUPSKjqnR6Y8iISQsKLJGooUm3jThbhwTSl9UW9M3RpsockEOiJSySCKimSCjVEmayNPfqM9Vo9FAr9ezEG9Wt0fnpr4mrFYrHwfwqnOk2WzmZtH5fJ4fCHTd0nWiFg4UuTKZTHU1WnRcxWKR658o9VEIwdcsvT8JDY/Hw58ZOUxShAwAR/soGqseY7XQpGbaJKAocmcwGKAoCr9mNBrnJVYo+kcLA7lcDpVKhesKbTYbp36SUDQajbBYLLxwQtefupVD4/eMFgvUUK0dvb/FYuHPgK4Jl8sFl8uFcDiMkZERDA0NIZfLIRKJsGiNRqN1daqN1wmdp0QikSwm9Kwit+UTHVoQJyfjY0GdaTMfFEWBw+FgF+STYbwkJx+nlDCjAtB0Og2j0QifzwdFUbB79244HA74fD60tbXBarVCo9HwCrfBYEAgEOC0PKqfam1tRalUwtDQEP+tzWZDNpvFwMAAR1TU9UM00TcajXXGHhSxslqtTfsgzVXrVqlUWBipbd4bhYh6skkmFjQhpchWtXqkj9V8U6rob9V289FoFPl8HtlsFsFgkFPgyPxBr9ezaUoymeQ0L+BVS/FSqcSTc4q+qA1DyGFQXbOlnsSSyyBNknU6HdedkYB0OBwoFovI5/NwOBwwmUws8qrV6rRJMQkhp9PJjbJTqRSGh4eh0+k4UkTRRBKeOp1uWiojmZeoxZ/H48Fpp50Gs9nMImnPnj1wuVx8/YXDYbax12q1XMdH40ufr81mg9vt5ubUahdC6pdFwk/9YJqYmOBjonRGg8GAVatWoaWlBTqdDpFIBP39/QiFQmxUMht0fVOtoNvtRi6XQzwe58+GRB8JNkp3bEzLJMfEZgsQ6vOgWsGWlhYIITA5OckmJi6Xiz8/dT0efV702atFc2MaKZmtqI/RarXy99BiscDn8yEYDPL7KIqCw4cPY3h4mFOkyd1zpjYH6mNSX4dSqEkkR4der581jfpUwmg0wu/3Q6PRYHx8/Li6Vy8GVJu+GPc/l8vFC7vz2Z9Wq+UF+nA4fMzvv9jI58Lrg1NKmB08eBAOhwOJRAKZTAatra2o1Wqw2WxYuXIlbDYbWlpaWBxRA9hEIoFYLAan0wm9Xo9AIACn0wngiNiz2+0QQiAajXJt0eDgIOx2O0wmEzKZDEeLqIFzrVZDe3s7rFYryuUy+vv7USwW4ff7AQCDg4NsvJHL5Ti6QjcliiqoIxpA/ao6CRpCnUqpbsJMxg70MzUbJsc6da8xmgyrJ8WNtU8kKtPpNCYmJuByuRAMBuF0OiGEwMTEBHp6emCz2eBwODA8PMzn7nK5kM/nMTk5iWQyyTU6JMzUDnnlcpnfiyJP6khTpVJBLBZjMWW1WmG1WjEyMgK73Y729nYuCFYUpc6aXy1aG9M1E4kEUqkUzjjjDHY5zGazmJiY4BU0ij7S+FLaqPrzoJRStQCgVESKBCYSCU5NjMVinCJJY9kYjaOIkDp1kX5Poj0ej7NIVNvh03WkNpYhcWm32+uuHZ1OB7/fz9d9M+MY9XlSNFer1cLj8fA507kKIaY5ZdK5mUymugUFaoKdz+c5gqVemFB//mSOYjQakc/nOTKWSqU4iq1OY2w0IpkN+i7SNWixWBCNRvkeEQgEkEwm0dfXh5aWFv7cIpEIR/ESicS80hfp+lDXtkokpwrN0s2PFoqiN/bDXGrIcIru/a8VJpMJPp8PWq0W+Xyen/snKnS/XYxoFWVrzBd6/lsslll7ms4GPadmcr8+FoxGo4zivQ44pYSZ0WjkWo/R0VE2b7jgggvg8/n4C6ruL0VW8pR6Bxy5sZPtNkVsgCNCpL+/nxtZU1PiUqkEj8eDzs5OOBwOTE5OYnBwEEII9Pf3Y9myZXC73YjH4wiFQpyCtnbtWmg0GuzatQv5fB7Lli3D8uXLEYlEEAqFoCgKGyxotVoEAgFUKhVeycnn8zx5pCa+FEXLZrOcrkhih2zayQafcDgcPJGkXl3NDC+ISqWCSCTCPz/zzDNYs2YN/xyPx+FyuWC1WtnCvL+/nz8jWg2jyFkwGITNZkMkEqlLrXQ4HIjH4zAYDOjq6uJaJwCcSknREYpAURST+qFQSiKZLuRyOZjNZjgcDh5DEsHkSEmT/t27d2NkZATZbBYmk6kutaJWq3H9IkU71Fb7ZAxBdYwkhgqFAg4ePMg37FKpBK/XC5PJxAsEpVKJhQ3VQtHPNpsNra2tKBQKGBoa4skHRXDIKIVSEel6B8D1hul0Gh6Ph01mdDodxsfH0dfXx5FFGjuHw8EphLTg0IiiKGhpaeHrYmhoqM4wxu12w2QyIZVK1YkUjUbDacehUIjTitV1oTTu2WwWTqeTv9+pVAqRSITNRgiLxYJMJgOz2Yy2tjZeKAmFQgteQSe3R7pvnHHGGRgcHITP5+N7RaFQQC6XQywWw+TkJEf7qH5vvu9zstV/SCSLhTpdezEmspSJcDxRtwZpXLRSp23T70wmEzo7OyGEgMPhwMGDB+sWO9XZMIt9L8hms5icnITb7V5QPfNCaBahVIvtuTKCjhdTU1NzbqNeRCRDNuolutCaYK1Wy/OpiYmJRXeEpMV46e57cnNKCTOPx4OxsTF4vV7+orW2tsJut8NisSCXy7Fd/UsvvVRnOqAoCteiCSE4ekYT0sYG0xaLhSfsgUAAGo0GY2NjmJqa4ohDuVxGd3c3du/eDQDYvHkznE4n/vSnP2Hz5s3I5/OYmppiBzy73Q6bzYZKpYKuri6cfvrpOHToEJ588kmsX78er7zyCjZs2MCiIpFIYGRkBKOjo1ixYgWncubzeUSj0Tq3PavVykYVJpOJBQRFaua7OtSsHiabzeLw4cMYGxvj1w4fPoxCoQCHwwGXy4XVq1cjFAphaGgIwKsmFZQyoK5Ro8gLpfOtWLECXV1dLB7T6TSn+5EjXqVSgcPhYPFGdUjJZJIFIkVt8vk8RyntdjtaW1s5/U6n0yGTyWBsbAxjY2PQ6XTo7OxEoVBgpz91nRI9dLVaLXK5HIxGI9rb2/lzpBs7RdeGh4dZLNOEn/ZlMpk49YKs70mUFItFOBwOdHR0oLW1lS2C6cHj9/s5tVSn0/H1qxbQ6gdnLBaDyWSCyWRCOBxGrVZDJBJBJBLhZuRUT2c0GmG322EwGNjgBXi1FiAajQIAvF4vizA6PnVd1UzW97SCTPn9ZJ1P9ZyUmkr7ICeuZg8ntRg9dOgQv76QCQEJ646ODq5DpejXunXr2PZ+ZGQEk5OTsNls3NhavRqdzWaPKS2HFgpOxsJ9iWS+kGGQupb2WDnetvBerxcbNmyAEAK7du2qS3tzOp1YvXo17HY7Xn75ZcTjcWzatAmrV6+Gz+eD2+3Gyy+/jH379vEiXWtrK7xeL8bHxxEKhdhciGrK6eejuY+USiWMj4/XLWAtBLWz80zv39vbi3379vHPOp0ObrcbiUQC5XKZe4KeiA6KRqMRXq8XOp0Ow8PDCxqnxrR7ylg5XtFaetZKTm5OKWHmdrthtVoRCAQ4etLT08PpRn19fZzSpL7ZAOB6EKLxC9AYPlb3hgqHw037QiSTSVgsFng8HsRiMWSzWXR0dAAAVq9ejaGhIV55p6bT27ZtQ2dnJ1avXs035UqlAp/Ph1WrVqFaraK1tRUejwcajQahUAjj4+N4wxvegJaWFhY0jz76KEwmEzZv3swGICMjI3jxxRfx1FNPwWQyoaWlZdpDYKa+aADYMbGxVobs8gmqtxobG0MikcChQ4fYThyo71USiUSg0+mwbt06KIqCiYkJjI6OYu3atYjH45wqqe6fFY1GMTAwgHK5jNbWVmSzWa7FEkJgZGSEhabX60UsFmt6PlRHSCmkZBISi8X4fKLRKKLRKNasWQOTyYTh4WF4PB4kEgk4HA4UCoW6VbVyucyC0Wq1wuVycVSqWCyitbUV4+PjcLvd6OjoQLlcxtTUFIaGhiCE4IbZFH0ih0O/3w+PxwOLxcJtAkistLa2wmw2I5VKIZfLIZPJ1AmemSgWi5iYmIDT6USpVEJnZyeAI/b5g4ODdamFbrebU1MPHz7M+1DXOarNNVpaWpDL5RCNRjl9tBmUTkx/a7VasWHDBmQyGYRCIW50Ts2iZ0vDUX+fXS4XR5Ip8kWRZ3UdV2OdoVarxYYNG6DT6RCNRrkp+I4dOxAMBtHf38/HTOeUyWSQy+WmrUbbbDY2RiFRTz3YZksNpXHt6emB2+1GMpnEwYMH5Sqp5HVLY7/GE51sNovx8XHOKCD0ej20Wi2mpqZQLBaxceNGjI+P8yJuV1cXtFot1q1bB4vFgnPOOQerV6+G0+nE1NQUnnnmGYyOjnKNczwex+7du5FMJuFwOGZ8lh1PqAQhHo8jEolME2darRbxeLxuTqXX6+syLJo5774WmM1m7l06E2SURs+fmcRjs0Xp+SwALKW75GvFYqYinwqcUsJs3759vGpNKW5UmxSLxTji0NfXh97eXmi1WgwPD3Ok7GhW2Wab+JL5A03c9+zZgz179gAAfve73yGTyaCzsxM2mw3Dw8MoFApoa2uDXq/H888/z6YZmzZtQn9/P55//nlccMEFPDmlm/fTTz+NtrY2Fp0/+9nPsHbtWlx22WXweDwc+SsWi9Dr9fjkJz8Jr9eLSqWCffv2YXx8HD6fDzt27GBnvl27diGZTNa5WVLEjYpjgSOTUnX6oc/ng9VqhRAC4+PjyOVycLvdnPJFKQIA0N3djUAgAJPJBJ1Oh2w2C7fbjdHRUUxNTXHd0uTkJLRaLaxWK4rFIiYnJwEAHR0dyGQyiMVicLvd7Dy1fPlyTExMsDCgsSHLerqxZrNZxGIxvnmn02mOQDWuTg4PD/PNh1ZHTSYTPB4PR+8AcASJDEZI9Pb09EBRFBZ8FElyu91oaWnhdDuyezeZTNzzDjiSkiGEgM/nQyqVwsTEBCYmJiDEkf5vk5OTbPpBDZoboTpGStttaWnB0NAQjxtFMwGwsYrahdFgMMDj8fA21WqVa9Mo/ZUioW1tbTAYDAgGg1x8Td8DrVYLt9uN1tZWDA4O8nmed955eOaZZ7BhwwYAwKFDhzA6OjrnKrFGo4Hf74fRaMTw8DAA1K1YUlppoxmLWjxTxLulpQVutxuBQACZTAbxeBwvvfQSOjo6sHv3bixbtgylUmlahLmxVhF4tb5B/aAvFotwOp3skDbTw4zqOrVaLZsO7du3T9rtS163LEaaGznCzvbdWgyy2SxnwqghZ2Gq8R0cHMTevXuhKApOO+00NqM6cOAALrjgApx22mmw2+3cYzIQCMDtdsPr9UJRFOTzeTidTqxcuRI6nQ7bt2/HY489BuDV8aKyC3VfycXCarXC6XQiGAwiEAhgcHAQIyMjddvQ4hZlc4TDYQwPD/OxNKvlboTqAtPpNGdiLAZ2ux2pVGpWYZbNZuuyK2aivb0dGo0GExMTM+6PjMPUC4gnoyhbaHRWirKFoYhToIo8lUrB6XTCbrcjn8/zl7pRxbe0tMBgMLCddjKZ5BV9NcdT/dvtdqTT6aarKHa7HcFgEKlUCgaDAWeccQY0Gg0ikQgOHTqEUqnEN2hFURCLxXDo0CGsXbsWXV1d2L59O974xjfi3HPP5XQ6Gp/+/n5MTExg8+bN0Ov1SKVSGBgYwOHDh3HRRRfBaDRi586dcDqdsNlsOHDgANLpNFuOHzx4EH19fSiXyzAajejs7IRer0c0Gq3L4960aRMCgQDC4TBefvnlurGlnmSUHrdp0yasWrWKoz0vv/wytm/fDpfLhUQiwcKT+oiRm18qlUI6na4bP41GA6fTCa/Xi0KhgMnJyWk3966uLpjNZoyOjvIEV6/Xw263c18vv98PvV6P4eFhBAIBTE5Osrtns9VCAHVmGoRWq0UwGGQBnEgkMD4+Pm3VrbOzE21tbTAajdwwmWqnyG1wZGQEiqIgEAigvb0d4+PjmJiYQG9vL4rFIgwGA7RaLV/Latt4SnslcVgqlTA4ODitAbO6ZooiR5ROSKmMtVqNzVbsdju7YTaDUhqpTjKXy8FqtbIwXLduHex2O4aHh7F//34YDAasXbsWL7/8MtxuN6rVKqeyUjNuSlnVaDRwuVzo6OiATqdjkapu3jxTdBcAp56q3T4tFgvOOussVKtVPPvss1i/fj0GBgaQzWb5OgoEAojFYtyAXh35pc9gJufFZphMJp7Iqa8rvV4Pj8fDUXi/3w+3242JiQmMjY3x6rlEcjJAz+fjBS320SLViYiiKFi1ahX2798PALjtttuwbt06FmpTU1N47rnn4HA40Nraing8jtHRUSSTSRQKBWzevBm5XA7/8R//gc9//vMIh8N47rnnOGskEolgz549x2Xhxu128z05lUo1TdPr6enB5OQkLwIv5vyJ5iBLLXD8fj+cTmddCcp8UBQFHo9n3mmIJ4rzIpVaSNG1cOZ6Rp9SEbPGgt/GC8rtdqO9vR25XI5vYjabDTabjetzXqtj9Hq9XKsCgFfW+/r6YLVa0dbWhkQigWQyicOHD7Pj28GDB/k4e3t7sXbtWuzduxfBYBDXXXcdAoEAAGB8fJwjFS+++CL6+vpw4403Ip1OQwiBgYEBFItFvOlNb+LIocfjwfLly1GpVPDwww+jp6cHHo8HAwMDAI6ICI1Gg2g0yitMiqKgvb0dy5Ytg9VqxbZt27Bnzx4UCgV4vV5Uq1V2nyTDFeCImMlmsxzhSCQSeOmllwC8KnDobylqRqkRgUAA3d3dKBaLCIVCLB6mpqaQSCTQ2tqKzs5ONmABgLa2Nng8HpTLZa5toh5d1MCaah0mJia4QTEATnUkLBZL3Yosbdfa2oqzzjoLBoMBY2NjeP755/l4XC4XxsfHp91wR0dHudeW1+uF3++HzWZj84rx8XEWZi0tLWxsQWPY0dEBvV6PvXv3IplMwmw2w+l0IpfLwWazobe3l+sqJyYmeLWTzGgCgQCq1SpsNhuq1SomJyc5556EBpmQUKSQTENSqRS6u7uRyWQQjUbR3t4Op9PJK8XxeJx7tlHtHgA2OkmlUhx5KpVK2LdvH/x+PyYnJyGEQCAQgMfjQaVSYUdMSrlV10UqisJinlamKX1Wjbr9gtlsxrJly6DX67Fv3z6un4hGo+jo6ECpVILZbObV3kQiwaugjfsVQhyVy5q6Hx2lRNFiCNUqAEcmth0dHfM2E5FITgWoBrOxzcWJiBCCRZnL5cKhQ4cghODnwoEDB2CxWDhjhmq/x8bGYDab8cc//hF79uzBl770JQQCARSLRQwODsLhcCCVSkGj0WDjxo14+eWX2Qk6Ho8vSsuA+dRMDQ4OAlgcJ8VGqHYbWNrok8FggNvthtFoRCwWqxtbo9HIvXGpZRPN07xeL7xeb50wo8yTZlHO+YoyqmNXZwEtJlKQHT9OqYjZfPB4PEilUujt7UUwGEStVkMoFMLY2NhxKUydK2+5EWpuWCwWkU6nmxoH0AST6nKCwSDWr1/PEcFMJoPnnnsOGo0Gp59+Ot9MKL3w8ccfx/XXX49AIACtVovJyUlMTU3h3HPPhcViweHDhzkq8sILL8Dj8WDdunUYHBxEf38/enp68Pzzz+PMM8/E+Pg4u0qSfflFF10En8/Hk/FoNIr9+/cjEonA7XbDbDZjYmICJpMJra2tyGQyCIfDEELAarXCbDbD5/NhfHwc3d3daGtrQzwex/79+5FKpViYKYqC0dFRRCIRdHd3s8EGjQHVSRkMBk4Hy2QymJyc5NRMEqokNsiwYcOGDTCbzXjqqafgcrk4IkU3K6vVivb2dhiNRkxMTCASicDn82HlypXQ6/WIxWIYHx/nmzGZrbjdbnaqrFar6OvrY0crqomi5si0jRACZrMZBoOB2zrk83kcOnQI559/PjweDyYnJ1m02Ww2fjArioK2tjZYLBaOnI6MjOCcc85BKpXC/v37OSpF7pQmkwnLly9nwxSqaSOTEJ1Oh1QqBbvdztFSqnu0WCyYmprC+Pg4XC4XWlpaoNFoMDk5iXA4zL3lKPJJRi9tbW0sGimKOjk5iWg0CqfTCa1Wy73a1FCkdMWKFRBCYMeOHbjgggvw0ksvIZVKcY2XOq3mjDPOwBlnnMGRWrp/7NixgydG5XIZzzzzzKzfa2DmhygJaSp6p8WNZlC7CbJoJoMYjUZTFz0kZMRMcjJxrBEzq9XKbruvF+x2Oz/jqBdjV1cXAoEAdDod9u/fj7GxMZxxxhmIx+PYu3cv1q5di4svvpifOffccw9nN1xyySVobW3Fjh07YLPZ+HmvKAri8TgSiQRWrVqFlStXYnBwEA899BB6enoQDAaRzWYRCoU4Xf54QrXc1WoVZrOZF6qpZtdisXDLGNr+aMWl3+/nGnJFUZBIJLh1D7n70vtT6r7BYEAymZxxoW2u+/5MNEbBenp62K2anmm0+Dvf8/X5fLxAfLxTdyULY65ntBRmDSiKAq/Xi2AwiGAwyH3PDhw4gFQqhfb2dmSz2Wl51IuB1WqdV1Su0YyAQvkzrQq6XC60tbUBOBKB8Xq96O7uRktLC6/gRCIRbpK8evVqFn8vvPACli1bhq6uLpRKJTz11FM499xz4ff7uYl0S0sLXC4X/7xs2TL09/fjzDPPhMFgQH9/P7RaLc444wzodDo899xz8Pl8sNvtLBAGBwexc+dO5HI5dHR0IJfL4eDBg01vdFRETJNTqhswm82wWq2cekhtBchFkPYzMTFR59pnNBrhcrm4j5lWq+UomfoGTHb03d3dcDqdCIfDOHDgAB8j1QMeOnQImzZtQm9vL5xOJz8Ec7kcR4GoifPatWshhEA4HMbU1BQ/NGu1GorFIjKZDIaGhqDRaODz+WAymViMVSoVdpkMh8MsXjdt2oRMJoP9+/dj48aNsNvtLOA1Gg03UB8eHsahQ4fgcrmwZs0axGIxvPjiiwCAc889F8lkkscglUpxupzJZMKKFSvgcrlQKpX4OMfGxliAu91uGAwGdrBSFAV+v5+dMClFlFwVqSCc0gvJVlgd9RJC8OREr9djamoKw8PD6O3thdVqxdDQEHK5HH/Xa7UaR7UoPXn37t11QqwRo9GI8847DytXrsT+/fuxf/9+rF27FhaLBS+99BL3TgsEAtwe42hQFAVdXV3weDzc709RFGQyGXg8HnR3d/M5FgoF2O12GI1GZDIZJJPJulpM+mypPlEKM8nJxLEKM5qsv96mMurJemO/S3oGqHtL6vV6dHd3Y2xsbJqhxZo1a7hNRyKRQFtbGzZu3IhAIIBIJIJcLodNmzZxb8+dO3fyc31sbAwPP/ww9u3bN+vknlq3kNlWMBgEgDrjr7nOF2guajQaDSwWCyqVyqJE3ei91q9fj/b2dqxcuZLrzfbs2cMuldTap7e3lx28U6kUEokEL8Y2qyVcjOOjOQ4tKC+krk69kCo58ZCpjAuEognhcJhNDWq1GjweD3p6elCtVrlOZCG5vgaDgW+g9HfqvlfAqyH52dKeHA4Hu8gBYIvZ2Y4jmUwik8nAYDDUmRmEw2Ekk0lMTU0hFovBbrdj+fLlCIfD2LNnD0KhENatWweDwYADBw4gGo1i/fr10Gg02LZtG4AjdTWFQgE7duxAsVhER0cH129RgTLVBa1evZpvOGeeeSZMJhPGxsawa9cuvPLKKyiVSmzSYbFY2DGRGkPXajWsXLkSq1atgtfrBXBEaP72t7+F0+mETqdDLBbD6Ogo10BRGpm6eFcdZfL7/VyfVCqVYDAYYDKZOD3P4/FwGl8qlWJb9OHhYY6elctlTisEwIYYhUKB0xfI4Y9qhqxWK9enORwOBINBHD58GOFwGBaLBTqdDn19fRgeHubrjaz7ScDHYjEkk0mEw2EsX74cHR0deOGFF7Br1y6+viYmJrB3715UKhVuJEoPTEq3qFQqGBsb4/QZAHjhhRcghEAwGIROp4PL5YLX6+X0iFqtxuYtVBtot9uRTCa5IfXw8DCnRK5fvx6lUglTU1Pwer2wWCyIx+P8/aLvXm9vLwwGA+LxOC9+UL2l3W7H2NgYi5hqtYrly5fD6XQiFouhUqlwSwkqOCcXNOrtEgwGOa2Gvk9r1qyBXq/HoUOHEI/HEY1GEQqF2JBm7969MJlMnF5MkU5137zZoJ5GVANJaDQa5PN5jI+PswuqoigIh8OYnJxEa2srTCYTf84ajYZXPmlBhsafRJpEcqrxehRlQL1AoXskRZTILEO9wFQulzE0NNQ0onLgwAF2yKX619HRUYyMjCCRSMBoNKK7uxsWi4VNRTZt2gRFUabVa1MqJXDEoIuyUSglnTJHNm7cCLfbjQMHDuCBBx6Ys752pkVYo9EIq9XKDsTHgqIoWLFiBYrFIoaHh7F37150dnbys5kWDEl8GY1GtLa2ore3lxexTSYTLBYLwuHwUbcYmAt16wGq654LcvcGZjedk5z4nFLCzGg0YsWKFahUKhgaGmpq0U2Ch9z8qFE0Na2Nx+PIZDJYvnw593ZqTEOkBs3qL1O5XIbFYoHBYOAbjLp5JIkFeo1uvjOJP6p9y2azyOVynEtON9BgMAi9Xo+RkRGORhgMBu6vRlEjmphrtVqOosTjcRiNRphMJq77IqfKUCiEw4cPw2Qywe/3o6+vD5VKhdPndu/ejdWrV0On0+HBBx/EmWeeidbWVrz88suo1WrI5/N405veBABs5b98+XLodDrs2bOHb94tLS1YtWoVXC4XXC4X9Ho9MpkMstks/H4/fD4fPwi8Xi+3AgDADlbqCbEQAl6vl1PryNyBUjKpho76hJEVfTqd5igMTZJTqRSMRiNOP/106HQ6vPjii+jo6EBvby/XoVGaHzXkFv9/f7WhoSG8/PLLLPr6+vrQ3t4ORVFYTBYKBf5sKSJItXsmkwnt7e1IJBIYHR3lSQmlEPb29iKbzSISiUCj0XDEy263w+PxwGQycX0XffaxWAyZTAY2m41rBejhPjk5CZPJBLfbzY1RyXmSetD4fD4WrmvWrEE+n8fY2BjWrl2LlpYWPPXUUzAajYhEIjCbzZiammKhRSKT0lRzuRz30uvt7WWBTNdhV1cXp9xSvRzZy+fzeaTTacTjca4rpLFNJpP8uppMJoOWlha0tbXBarXi+eefRzgc5olHS0sLC0hacKBJEaW5zGUGpG5CT5D4pPOlOsIzzjgDK1euRCQSQX9/P/fba7wXUJoNXWMLMRWRSF5PvB5F2UzQhHumc54pza1SqfBz0O12I5PJ4OWXX+bXqbXO8uXLUSqVcPnllyOfzyORSGDPnj18fzaZTFi9ejWq1SoMBgNWrFiBnp4eWCwW1Go1ZDIZnkP4fD54vV7UajW0tbVxQ21qOdN4z2x2D6V0beovChx9+iJlbbS3t/PCVjqd5rlRoVDA8PAw9uzZg3A4DEVRuFXMk08+yWnskUgEJpOJm4Afb+Z7fc/WcoAW0DOZzDRTNL1eL4XcCcYpJcycTiebKFCz6UbUNwe6gDOZDH8B6Qal1+thNpvhcDgQjUYxNjYGo9HI7muNEzFKPSPxRSv+lE+t3k59HGTLTakJNImllC+KBDSuasViMbhcLtjtdmQyGRSLRZTLZeTzeY4Qqbev1Wq80kUTQY/Hg1wuh8HBQQQCAeRyOQwNDbELHrUSMBqNHPlwuVycbkUW6VSXlE6n61Ijent74Xa7AYB7Qi1btowt+cmF0u/3Q6fTIZlM4sCBA+jv7+fGyENDQ2xpT9FMGkO1LTxF6vx+Pz+EyMAjEokgn89zxIzOyeVysfAl10eKWKgFGAB2A6RCc9ouFotxY2bqTaXX65FIJJDP5xGJRHg8aSWzvb2d+985nU74/X7EYjFOXU0kEshkMtwLRqPRYGhoiIUN9baj/1JqLtX12e12jjKFQiFUq1Xk83k2PqHtcrkcOyaWSiU2A6EaPafTiZaWFthsNvh8PmzcuBHFYhGPPfYYCoUCBgYGEAwGsW7dOuzbtw+FQgGrVq2CzWbDyMgI3G43LBYLLBYLt1WIx+MwGAzs7tnT08NmKRTZDQaDaG1t5UgYNarW6XSc8kMTgPHxcf7umM1mlEolrh2NxWLYsmULp1F5vV60trayfTKJQRoXs9kMr9fL1wx9R00mEwsjEvCU3kkCT/1wpZo5+ttEIoFly5ahtbUVer0eu3btgt/vR2dnJ4aHh/mzJkFIro+0TyFEXfN1iUTy+uRYRCj9LWXYNKbGhUIh5PN5eDweHDhwAGNjY4jFYti2bRsvJC9btgxtbW2cgdHd3Y2VK1dyrWs0GuVo1M6dO9llemxsjDNmFiJmaJ/q+93RWuULIZBMJpFKpeDz+dDW1sauv/39/ewnkEgkOA2Qnn/ULoV6gGYymabRu2aL8q8VM6Xn05jP1BvzVFrYOFk4pYQZFfLH4/FZbw6UGqReiafVGsr7rVarWLFiBUwmE8bHx9nEIBaLca8K9QQdOLKaRRMr+hLRl4LSkhqhIthUKsV/V6vVUCqVeDJKaX0kVmiCGo/H2bWOhBPd1ChCRv9trFErlUoIhUKc2hmNRrlINpvNslitVqt8LlRLRWYXlBKhro0aHx/n/lw0wd+xYwebOEQiEUSjUcRiMaxcuZJt/al3CYnr/fv3s3AslUpsiED/KLqgvhElEgmOVNHnEYvF+LwLhQLC4TCPK4lZMrggoxYytyBHPgAsHMg+nfpd5fN5Tjcjg41MJsMCkXqukSU+WfGr3ZSoxxw95KjpNn2WVNxrs9ng9XpZZJFTp9/vh8lkghCCC6fpGlFTq9XQ0tLCNWCUHkdim8Qy2e3HYjEUCgU2RVm+fDnK5TI3fdZqtRgbG0N3dzebcIyOjqK1tRU+n49dEik1plQqQafTIZ1Oo1wu8/eBPi+bzYZkMsmmL3T8dK4k9IrFIsLhMDKZDAvXFStWcD+2/v5+XHTRRZiYmIDf70cul8OhQ4f48yQxTumthFarZVFE31kS5AaDgZs+WywWJBIJTE5OIplMci2k+homl0WqfXO5XNyugKK8VD9C6UulUmnaQg6tHut0Olit1iVr1CqRSE4OZoo21Wo1pFIplEolPP7445xxoXZcjMfj2LNnD/R6PTo6Ovj+R6096B43NjaGUCjEC5r5fJ5dIqkl0XwFTONc7ViERLFYRH9/Py800iIcpQ421mXRvIgW2+n+3PhcoHtyqVSqa28Tj8eXPBpF2TqUBUXzNuDVvnrHE+obeCw4nc5T6tl2SgkzujjmukiowJQmUzabjdMP6ctL6Vy0qmIymbBs2TK43W4MDQ0hGAwiFApNyxOntDSa0JPjHX2RG6GGwjT5IlMK9c1EnYdNPUKo2TM5N9IqPgnLWq3Gzn4kAoBX6+bMZjOnOpItOqUHNtqvkmshAO7lRcImHA4jm82yTTrV2pF5xsGDBzE6Osq57waDgd36DAYDdu3ahWKxCIfDgUwmg6mpKRw4cIDFcqVSQSAQgNfr5To0SjujujmarNMkORaLwefz8f/TOMRiMR4HEnd0Q6ZIo8Fg4Mm8oigYHBxEZ2cnXC4XIpEIv4fJZOI2ADTu9HOpVOKaOODIQkA2m0VPTw8CgQCnbbS2tk5LQ6UFg0KhwEXeRqMR8XicRaG6gam6zxZFael3dK5arZYNUqgXVzgc5lQ96hGTz+eRyWS4T14+n+c6PTJP6e/vRyaT4dSV/v5+OBwOdHZ2olQqYWJigvu1kdmKTqebtvBB1znZ6cfjcY4M0fVvNBrZTCSTyfACAJmIkOtnKpVCV1cXIpEIent74XA4eNxeeOEF7nVGk4pCocCLKGqKxSKvCNN9olarwWq1wufzIRwO17mh0vfTYDCwIQ1Frymi7PV6eQGhVCohkUiwQKTrmxYFKFLbrPaExLlEIpEcLbVaDblcbsbU6KmpKa61jsfj0Gq1qNVq6OjoYJt4auGibk8UDAbR3t7OmQJDQ0M4cOAAL9iqnRYXEzLyUp8PWdDTXKlR6NFzRb14ro7SqUUZ1VdT1gYtqKlLUhaDY+1dVqlUptXwUSnI8RaOi9EMfKnF7WvNCSHMRkdHcejQIWzYsAEul6vpNgMDAwiFQli1ahWnvx0vaOIHHHFKdDgcbN1K9WTVapVXhCilzOPxsJOc2WxGpVJhd0OaLFLUqnFyRRNTs9lcV/umvgnQZJIiODqdjiMMJLToZkMTNkrDs1gsdZNNmjCqLWlJ4NHNlrajm5d6XCgtjPLWSbBSvZrL5eIICUW1KKWR0sRKpRLGxsb4pkP55GazGS0tLdDpdBgfH+dzS6fT2LNnDzd3zufzsNvtWLduHYtiqvt77rnnkM1mOS2PDCOsViunCNJn4Ha74XA46uq4Gj8rmhyTLTuZrjidTnR3d3P6HdWwke2+yWRCJpNBPp+HzWaDyWRCMBjkFUZqDF0qlTA5OcnHIYTg2ka1cPJ4PDAYDNyTjYSS+nqhOsnW1lb+XOnhohY21WoVRqMRgUCAPy+KdpGAo/59NpuNRRKZyFitVvj9fvj9fng8Hr7OyRmTomFOpxM+n49XTHU6HadlknCk+rpisVh3/dE5pdNptLe3c48e+s7Qgxc4UrdFRiUulws2m437mWk0GoyOjkIIgdWrV2N4eBiDg4OIRCIIBAIcHaQFD/q+kiCiei61a6o60kqCe3R0lK8FSoGx2+280JBIJHgVVf29S6VSdQsHtCpLtRw6nQ7lcnma+KLJA0W+JZLjwcsvv4xEIoG/+Iu/aPr7Wq2GV155BZVKBevWravr6yh5/UD3XipToPpfWuBNpVKYnJzkZ6/L5eKU9GXLlsHv9/M9vr+/n2vTZnPKPRZo4dput8NsNvP8YK5G4xRZKpfLXIelKMq0+2+z+RyZalHEkSBXzfmep9Fo5IjjYoxP47FQQOB4uzeqhZnP50M8Hl/wuZxqi45LKsyee+453HHHHdi+fTtCoRAee+wxXHTRRXXb5PN53HDDDXjkkUewbNkyHDp0CHfccQf+/u///jU5xlKpxDcgqlOiLxf11aCVCMo/7urqAvBqSqHNZuNanEKhwEYENMlTC57ZoC8P2alrtVrYbDZuVuh2u+tS3AiqKaNIFk3yqFcUCUGtVstCUh3BIPFFaVNk6U790uhcqYg0m81yahkVnBYKBXR0dLBQSyQSsFqtvNoEHBGRExMT7C5lNBrrhAo12KYeL1arFV1dXejq6oLf7+eHg9VqZVc9dc431XCZTCYkk0n+3MiUxWq1spUwmalQDRalAlJjX0oHPO2001g0VqtVjhRRVFVtU68WLVTvB4CFSbVa5eMicUR9ZgqFAv891Y7RTVUdiVWLNKfTyVFIdWqmOp2WIn8UEYzFYiw6HQ4HR3ry+Tw3JlWbjZBAymazMBgM3NibfkepnxQt0uv1CAaDLNbVJjf0+VCEmNJdKFWGmnTG43Ekk0nYbDZ28bTZbHA6nXC73fB6vXzd0DlTwTnVfZE5C9Wp6XQ6FjdUB0hirVQqcVPnZit3yWSSXRPV/cR0Oh2LUjJPKRQKcDgccDqdnApJArtUKvEikDpaTwsFlFJM/dcaV7UbXV4lkmPlxz/+Mb71rW9xrWOzCdL+/ftx9dVXI5PJwGQyIZ/P43//93+xZcuWJTjiY8NqtcLpdHKLkOOd5nUyQmNC6eyU0UHp22QIRcZfDocDHR0d8Hq9dS0/VqxYwbXdtAi1kOgK9cVMJpO8IK2GeoOSY7DD4UChUOCSj5mg55I6RZHux43Xf7FYnPZMmE/Lo7mg9HUqCWjWaPpYcLvdvHBL87ZkMtl0/ng0NKZ7EtT0XTI7SyrMDhw4gL/+67/Gv//7v6Onp6fpNl/84hfx4osv4vDhwwgEAnjggQdw9dVX47zzzsMb3vCG436M5XK5Lre1cdVDPTk6fPgwIpEIli1bxiKoUCigq6uLG/JSHncoFMLo6Cjf5CgqoHYearTDBcBpcjTpJ2v3qakpXolq/GKphZ/BYOA0L4pyNb4HTcKFEHXnZzKZuEYmk8mwCYq6pxIJMbKIp5zyyclJthen1+x2OwsmMq2YnJzkSKROp2MXJTqefD6Pjo4OtLS0oLOzE21tbdxvhW4w5XIZ69atg8/nQzQa5foocrmjCCdBk/FkMgmr1co1UJRSWCgUONJXLBbhdDqRy+Vgt9v5wTIyMoJIJIK2tjauySIBTGKDHA3pZh6Px7lurFQq4cwzz2QrfYfDwRHGaDSKiYkJFAoFrpOj89Tr9dxbS52SSi6WdFOnOi6bzYZAIAC/38+Rt7GxMY6gRqNRromz2Wzo6uqC3W7H/v37MTU1xXWLQgjEYjEoisLWwSQ4qOaRGh/HYjF+aPv9fuTzeUxMTHCKJ60uGgwG/i5Q3xqn08kLGvRAzWaznCJKQrGlpYVNYug6IlfNoaEhmEwmrgN75ZVXsGbNGni9XmQyGXaopL8loUg1BVQ3VygUUCwWp0W11d9N+p6Yzea6tEoAPBaUrkupprSoQtFEq9XKgrFarfICjMFggEajQTabZeFOq53qmjyJZLEYGBjAD37wA+zcuRN/+7d/23SbG264AWvWrMH9998PjUaDm2++Gddddx0OHz580rVx6O7uRkdHByKRCPr6+qQwmwNy86XoC2UKUbsbs9kMn8+H9vZ2+P1+VKtV6PV6LFu2DDabDUNDQ5iamuLFZkqTnAtFUdDe3g6fz4ehoaG6Gnn1xF9d/kEOy/PZN5VtqOd6FouFF4iPxmiJFnYbsdlsLE6J7u5uNpOjZ8Ri4XQ6sXLlSvT09PCzhxY7m80fFwLVklssFoyPj0/7LEOh0LEe/inBkgqz9773vQCOpDLOxL333oubb74ZgUAAAHDVVVdh3bp1uOeee14TYdYMtYGG+otGkTBKHazVajyxBMAW81Qz09nZyS6LY2NjGB4eBgCecKvznAFwKpXagS2fz/NNjXpYzAbVypE1PKVpkeECTfpaWlrY2Y6gGx7lg1MULRAIcM2d0+lEW1sbuxlRnZfL5cLU1BQMBgO8Xi9bzzscDlgsFk6DBI58uSk9bXh4GKFQCH6/HzabDeFwmG+0ADiCZbPZ2M1Rr9ejs7MTLS0tCIVCOHjwINv3lsvlpjeHQqGAVCqF1atXw2g0IhQKsU06iXNK2bTb7dxKIB6Pc08yIQSGhobYcdHv97MwIyt3p9MJj8fDzpynnXYaALCVO7knUaEuLQRUKhWEw2GkUikWeJT+R9ekukCW6tECgQD279+PyclJvh7b2trYVGXZsmV1K8N+vx8DAwPwer110UG73Y6BgQHodDpeDKAc9VwuxxE0suUnG/u2tjYMDg6ir6+PPxuKNlOENxKJQK/Xw+fzsdU/CQ6KnimKwo0+bTYb8vk8Hn/8ceRyOSxbtgynn3467HY7RkZGMDY2hnQ6jWg0Co1Gw/3QDAYDN6/es2cPWlpaYLfbYbfb+T0JetDTNZ/NZjll0efzIRQK8fb0OdG129LSgkAgwP0Qs9ksdDodQqFQ3edH9RhdXV1cj5fL5Xhc6P3o/+l1ijJT3WU+n5+WNiORLAZf+MIXAAA7d+5s+vudO3fipZdewve//31Opb3tttvwve99Dw899BDe9ra3vWbHuhgEAgG+v8mVffBzeKYan2KxyM9KqrmlHmmUxt3d3V2XBUHZNH6/H8FgEPv370ehUEA0Gp23MKAekGTW1fg7AJwRQinv8xUcNK+jRUfKRqFSgr6+Pk5xbwYtAqpbIjVDURTYbDb09PQgk8lgYGCAf7dmzRqsXr0a+XweTz/99KK67dLziRb21Nf5sdRy6XQ6tLS04Iwzzqir/6YoI7UAokXk45U+qW7OfbJyQtSYzQQ53W3cuLHu9Y0bN+LFF1+c8e8aw8tz5RPPF3WvKbVrGl0ABoOBXX+oUaFWq8Xk5CQ7Fa5fvx5tbW2cZkb9uFKpFNatW4dKpYKRkRGEQiG2Em9soEmGCVqtlh36FgpFVyjXWG1iQl8qirgA4DxnjUaDdDqNQCCAeDwOl8sFs9nMVrKBQAChUAjDw8Nspz48PIw1a9bAaDTi0KFDCIfDAI4UBFMkjOzFaWwpsqXVajl9jSago6OjXHs2NjbGRgqrVq1Ca2srm4Hk83kMDw/j8OHDGBoagsViQUtLS52NP6W7kQChdLHBwUG+YVFz4Wq1inQ6zWOSSqUQiUSwfPly7mGmKApCoRCLMCqkJndNmkyXy2Vs2rQJFouFG1GTayNFStQ1ewaDgR8sFD2ZmJioEwe5XA4+nw9TU1O8UklNw+k4qCE1RS/1ej2EEJiamkKlUsHAwAC3QSAjF3Lm1Ov1MBqNLFIpZVOdnjgxMQG32821CJQWeO655/JDm0QqOUXR9aXVauHz+Xihgow7KFLr8XhwzjnnwOPxYGRkBLt27UKtVsP+/fvhcrlw9tlnIxAIQKPR8PWzY8cOAKgTLna7nSOPwWAQ5XKZLZLVqM111MY15XKZa0mFENwfjtzGzGYzp27abDaO5JGZB/WS8Xq9mJiY4JVKmkDE43EoisJtAUqlEqLRKBKJBLcJOHToEAv4fD7P18dipKFIJPOFnsNnn302v9be3o5gMIgXX3yxqTA7Xs/nxYCs2edybgbA2SKUovx6WxihxTB6PsyE2oadxqxSqaC/vx8ajQb79u1DpVKBy+XiOU1raysvsE1OTiIajfL9cT5Uq1UcOnRoxt+pUZt3GI3GuiiY2qlaDZl89fb2QqfTYWhoCBqNBq2trSiXy9yGpVFcmM1mdHV1IRAIYGRkBJOTk01t6qnubc2aNXA4HKhWqxgcHKxraUDuzOR8uVikUikMDAzUuVCrF/sp00OdVdQMWpil9ESj0Yizzz4bGzZs4BT8l19+medSvb296O/vh9vtRiwWa5p+uhjQovFr0WPueHFCCzOyaSW7bIIKCGfia1/7Gm6//fZFP55Gd57GG7F6ZcBoNHKKmjqqYbVa6xoGUx2V2WzGypUrEY/HMTExAYPBgK1bt6JcLuOll17iHGOaLFK6lToVrNGxDXg1yqV+nfKl1RN/is5RjQx9SV0uF9c5UYoj9Syhol1yMySxMDk5ieXLl3PDxhUrVrDwCofDuPTSS6HVavHcc89hZGSkLgVBHSGi1EyNRoN169YhkUhwKqBer2dXzOXLl/OEfvv27dDr9Vi+fDkmJycxMjKCs846C3q9Hs8++yx0Oh2Gh4dhNBpRLBZhsVj4oUCiipz5bDYbG1iQ2UUgEOD3pZpCim7q9Xr+LCltkBwmKR2RIkVr165FV1cXgsEg3G43nE4ntFototEonnrqKYyMjHB/r46ODr5R0g3Q7/dz3xWNRoPTTz+da7FyuRxWrlyJzs5OVKtVTE1NsdV7OBxGLBbDvn370NPTg/b2dsRiMbz88ss466yzEA6Hodfr0drayk6a1F+Laq3IMn/37t0YGBhALBZDf38/APC1QVHD008/nZ2ryBmKok65XI6dDE0mE/ePy2QynMbY1dWFjo4O+Hw+/PSnP+XIaTKZxKZNmyCEwHPPPYdt27Zxg+tMJoO9e/dicHCQryty/xJCwOFwcFohfXcodZa+K2q3LoPBwGOQSqX4mM1mM4Q40uza6/WyCQw1uabI4OHDh3mCE4/HodFo8MILL6CnpwdCCIyOjvLnY7fbkcvlYDKZWBhTLRqlzZrNZgSDQT4/9b1HInkticfjnIKrZrZn9PF6Pi8G0WiUF5xmW9HXarUIBALo6emBy+XC3r17+R7YDIrANXMBPFERQswr9YxKIpphsVig0+m4Jxo56La3t7Pr8HPPPceLtcfiPjjX32q1WnR3d8PhcHBqYCqVmpZyFwgEYLPZYLfb4Xa70dvbi2uuuYZr1MbHx/HII49wg251CUFnZye6urpgs9l4LjA8PMyZUYTRaMT69evR29uLqakpDA8P1/3++eefZ1O3hUL18DNFv7LZLNf60wJhIBDA4cOHkc1m0dXVBYfDgZ07d874/vRM9Pl8nLE1NjaG0dFRbNiwAVarFb29vZiYmEAul2NDrJUrV3Kd/cDAwIwpmkdzHaiDCMfDSOa15IQWZlRz0ljPQR/0THzmM5/BP/zDP/DPqVQKnZ2dx+cgm0DRgEbIeY9Wzfv7+7FmzRrO86WVt7/4i7/AxMQE1q5dC5fLheXLl2P79u2YmppCOp1GsViE2+2G2+1GIpHgxs25XI5vAPSFIot2ikYBr/a1oOgUmUMQiqLA4/EgEonUmRkA4Hxnu93OkadEIgEhBNvIO51OGAwGHDhwAOeeey6y2SyvrJJtP/W9stls2LNnD09CafWFvpjUdywUCmFgYACnnXYap56Njo4iHA6zu5+iKGwGUS6XOa89HA5jaGgIlUoFfX19LPw0Gg3brFNaJwkTqhGiHnJU47hy5Up0dXVBr9djYmICf/7znxGJRBAOh9HW1obly5fD7XZj5cqV2L9/P/bt28cRFVolW7ZsGYuXYDBY5wBI6R/t7e3Q6XTYtWsXXC4X1qxZg87OTvh8Pu5zFQ6HsXfvXkSjUY4EDg4OcgpcKBRCLBbD/8fee8dIep/34Z/pvfe2M9vL7e5VHnksR1KkSIqWZVqwHTtSECNKEARwYCOIjVj/JHESOP8kQQDDQYwYTmTZiRzZjmRBhRQpkXen4/W73du9rbNleu+9/f643/Pwnb3dvc4jxX0Agnd7szPvvOX7fcqnLCwswO12o9u9bSLearWYp7i0tIRoNIqhoSE4HA4cPnwYZ86cwfz8PGZnZ6HT6fqOjRILqVQKt9uNSqXCME4SipFIJBgeHuZC/Sc/+QnGx8f5HMfjceZXklUBSemTL99TTz3FnLt33nkHtVoNf//v/33mYZKwyLVr15gfNjc3h1gsxh5+ND0EwMXOwMAAc9iE/oTEuySxFILeUIJG0FGLxQK5XI5wONy3LpGap1KpZD4gPWvCBIcaJfSdaWPyeDxcjI2NjTH/Ip/P8z2Ry+WwvLwMp9PJ3jok/ALsbTB6EAfxuIIgWztjvz36Se/P+0UkEkEkEtnz32lf6nQ6yGazCAQCsNvt6PV6+xZmNpuNbU3uNon4uIKKxce5bgj3V5FIhO3tbcRiMYaX32vspI3sFnq9nr1jgY/WWsqF6NqVy2U4nU62BIrH433vTWgRaqzKZDKo1WpWrDabzZicnESr1cLo6ChCoRDef/99btKRPgBNlOhzhEF8+Y2NDTQaDdy6dauvub5TBIymc3crVuRyOV566SWUSiV8+OGHu54zQs/QeYnH4+ynCgArKyv8ZxoiCGkmYrEYx44dwwsvvACbzYZLly7h+9//PmQyGQqFAmKxGO/rhH6hoKYuccN3Czpn9/uc/Dztf5/owszr9bLjujDItHavICLqJy3I4FqhUMDpdPIY2+12Q6vV8hSKRChIjt3hcGBwcBCJRAJ6vZ69rtbW1qDT6XD8+HEWoiAuDHUjdi4ItFgJx/AEnSPYJPBR53Cvh4ceGuJGEaSK/EGIW6ZSqfo80ur1Oq5cuYJarYaZmRmWMHc4HGzsq1QqGdrl9XrR6/WwsbHBUMidcfPmTf6zVCpFIBCA3+9nkZVYLMYFpkgkwujoKJvxEkHdYDBge3uboX1CLxca89PPjEYjT9AsFgsn11arlYu9fD6PtbU1vub0Ge12G7FYDG63G8VikTuJJALy/e9/n49fJBLB7/czBIQKbyqiCW5RKpVw48YNnuQoFAp8+OGHaDabcLlcbO0wMDDARV2lUkE+n8fIyAiGh4cRj8dx7do1GAwGOJ1ONmgWcse0Wi0XvcRV7Ha70Ov1sFqtvKFdvHgRExMTmJ6exqFDh2Cz2XDmzBksLCyg1+uxd5fZbIZGo0GxWIRGo8GhQ4d4cjU1NYXx8XF0Oh1otVpsbm5icXER165dw/DwMBs0Ax9BaXq9Xt8G02q1+szXSZ3T6/Wi0+kgEonwPU8COVarlZMo8uEjk2qtVssm26VSiQ2y6ZnK5/NQKpXQ6/VwOp08aSYZfBLxUCqVGB0dhdVqhUqlwurqKsxmMzweD6amplAsFnHp0iVYrVZWLkulUmg2mzAajchms0in0xCLxczT6PV6mJ+fv/sidBAH8QjD7/ej2WwilUrBZrMB+MhKZq89+pO6P98tCCJFSJl6vY5wOMx+XvsFwQIJYkWNwcfJtblbfFwcnHQ6jffff/+h3uNuSbdGo2FkFXGLnU4nOp0ON2O1Wi1WV1cB3G4w0xq+MwhaS3vE5uYmNxpyuRzW1tawvLyM4eHhO7jJ5XIZa2trfRNXamoKC6tms4mbN2/2NTV8Ph8KhQIfk81mw+joKDdxCfa+X9jtdkb07HVf7aVeuRMBJhKJMDU1BZvNhosXL6JWq2FgYADj4+Pw+/1wOp2w2Ww4efIkKpUKvv/970OpVGJpaYkFxaLRaN973q3YkslkMJlMUCqVj7SBsVcuSxZK9XqdETWfhPhEF2ZqtRrPPfccvvvd77JQSLlcxo9//GP8wR/8wRM+ugcPkm8lcihNabrdLlZWVvjhO3LkCMuXz8zM4NVXX2WuGnVyYrEYEokEzp07B6lUisnJSZjNZlQqlT7MMgAu8lQqFQsTEA+GxBqazSYUCgUnrKFQ6I5xM0EBaDpChN5KpcIqgSQ3XCgUkMlkMDAwAKvVilu3bqHX62F6ehrdbhfRaBQGgwHNZpMnIYQ9Ju7d9PQ0FArFvoknyfyrVCpEo1Eu4HY+kL1eD8vLy32/GwqFEAqFuIgg2fpwOIxutwuPxwOdTgcAPOmUSqWYn59Ho9FgzyyaZGQyGYTDYS6KJRIJlEoldDodn6dwOIxMJoNKpYIrV67AYDBgYmICr7zyCnOUWq0WZmZmkEwmce3aNfZPI8l1p9OJwcFBTE9P8yL4wQcfYGxsjOX+Cd9vs9mQTqdZ5KVWqyGfzyORSMDn80GtViOXy2F1dRUymQzPPvss1Go1IpEIrl27hkOHDsFut6Pb7eLGjRt93jAkZuF0OqHX67G+vo5bt25BoVDAbDYzpNfv9yMUCrEq1+HDh2G327lrS4WwzWbD9vY2F4LFYhG5XA5nzpyByWTCpUuXmKNAtghKpRLAR2bYAPhcUwHUbrdRqVSQyWT42lcqFVgsFuYpCoVkSIWLJmn5fJ4hxbQZP/PMMywqk81mGR5CPLLh4WG4XC7kcjnuwpKxdjwex8rKCiYnJ2EwGHDmzBno9XpkMhk4HA6YTCak02kkEgmoVCr4/X6oVCoUCgVks1l0u13kcjlWjDyIg/i44/Tp01AoFPjud7+Lr33tawCAH//4xyiXy/j85z//hI/u0YbQH5T+LoQT7xc0lZDJZPB6vTh06BA0Gg3C4TDOnTt3X8ehUCh29dR61OF0Otlz8ZMelUqlTzyDFIcJTdDtdvuKsJ0TO2EzmK5xq9XC4uIiFhcXIZfLYbVaYTabMT4+juPHj2NpaalvukQhPF9OpxNjY2MwGo3Y3NzE3NwcgNt5yM7rt7W1dcf7UKOxWq3eE4cxHA73iem53W6229mr6CBFZLLgoeM6duwYnnnmGebYb29vsxryysoKWq0WXC4XEokEkskktFoter3efd/PwhB6wd5L3E0dUyKRwGazYWBgADdu3LjjXp6YmOCcjyaY+9Gk7iXIKuhhGh9PtDCLx+NYWlpifPH169cBAIFAgOXz/8N/+A945ZVX8Lu/+7s4deoU/uiP/ghOpxP/5J/8kyd01A8fxWKxb8pD4fF4MD4+DqVSyRMJn8/HvJpKpYL19XUkk0kMDw9jYmKCpX1fe+01+Hw+lkLvdDpYX1/Hf//v/51heX6/H51OB8FgkOEYBOeiayCXyzEzMwOj0YhIJAKlUgmv19tXzFBHiXykaDJQrVbZhJjw2PQw0JSKTKCpMCWOXL1eZw6e1WpFp9PhbmQikYDH48HMzAyuX7+OQCDAhFKa4FDxaDKZ4HQ6ubDJZDJ3QEzo/O58qMl7gyYwxDXI5/OoVqs8CQsEAhCLxezLRkIasVgMWq0W5XIZZrO5T8gjl8vxA0+iJtFoFMFgEKOjoxgfH+euK3VvSAFxcHAQHo+nz1hZCFMUbkgAMD8/jxdffBFDQ0NMvu50OrDZbLDb7QynNZvNDOEjBSoATG6moml6epohnZ1OBw6HA+FwGNlsFl6vF0ajkf3UbDYbDAYDarUa0uk0NBoNpqamMDU1hUqlgs9//vMQi8XQaDSw2+24desWMpkMn69MJsP3+7/7d/8OX/7yl9FoNHDt2jVMTEywVH8sFkMwGGSIhbCoo+KGeG60CRPMMBaLwWKxsEywXC7H4OAgZDIZIpEIq4sBtzd0sikQhtFoxIkTJ2A0GlkUhPiaJH7idDoxOTkJo9EIn8+HfD6P9fV1LC0tQSwWY3p6GtPT0wBuT1tPnDiBM2fOoNVq8WSzWCyyWEK9XofL5eKidHNzkzupB/5lB/E4YnFxEclkEsvLy+h2u/jpT38K4HbSptfrYTKZGJpI0OSvf/3r+M3f/E1MTk4+2YN/xEH7GjWsdouhoSH2GtwtESYT5kQiAZFItOvEBgAjLEhKXiggQZBp8p98XCFEH3xS4qmnnkK328XVq1f3nW40m80+lWqpVAqXy7UnhHKvIpdoDVarFdPT09BoNMhmszh//vw9idbQXqvX6+867QLA+QPwkT/mwwRBK91uN6xWK/PlyT7A5/Ph6NGj6PV6uHnzJtbX17G8vMxeq9Vqle9lanpXq1VGoly5coW5aU8i7lb8kHXOXvcyFZrNZhNra2v3PaXbbRL3KAS4RL0nOLv74Q9/iP/4H//jHT//zd/8Tfzmb/4m//3DDz/EH//xHyORSGBmZga/93u/B7vdfs+fUywWYTAYHsUh31PsZa53tzAajXC5XAwLJEENUpSLx+MYGRlhyIjNZoNKpWJ1OBIoIFgXdfMI1veDH/wA7XYbL7zwAnw+Hy5evIhCoYBDhw4hEongypUrAG7fbBaLhQsLANyxD4VCrGgIAMPDw/B4PIhGo0gmkzAajUin0xgfH0cul0M0GoXJZEIikcD4+DjDDMiIeG1tjQslEkAgJcZoNAqPx4NQKITnn38eMpkMP/rRj+Dz+foWWPLOIglzkkCv1+ssjkHndLcgGKgQR03wSofDwSpGRqMRL7/8MvR6PReF1WqVpx/5fJ5NNNVqNYLBIILBIPPfnE4nPB4PNjY2mJM0PDwMhUIBn8/HBTQVugD4fIjFYoYKxmIx9hMjWOT29jasVitSqRTGx8exubkJl8uFfD6PYrEIp9PJhGaz2QyxWIzNzU3mlwEf8QdjsRgnXjQNq9VqbKKsUqn4+6pUKmg0GqhUKni9Xuh0Oty8eRMDAwOw2+04ffo0RCIRzp07xxOsw4cP48KFC7BarQy1/NnPfoZgMIiBgQHk83kMDg6iVqvdMwRGq9WyZQDBq6hw2S3kcjnsdjvEYjFPuoSLPCmwEr9up23Ea6+9xo2OYrGIYDCI+fl5NJtNHD58GAaDAWtrawzzjcVi8Hg8eOqpp6BQKHDmzBl4vV5cuXIFDocDer0eqVQK8XgcDoeDhULIq5AKdZvNxoVePB7HlStXMDk5iUajgUwmw9BJvV5/T+ftIA5iv/iDP/gDvPfee3f8/I//+I8xNTXFf//zP/9z/PVf/zXa7TZef/11/LN/9s/uWS34496fHzZImflxQQGHhoYYzdLr9eD3+5HL5Rha/lkOUiSmomunavXY2Bh7mBYKBczNzWFhYWHP93O73YjFYvsWeSRpPzg4CJvNhnK5jKWlJZ5+Abcbaz6fD8ViEdvb2w+k0EnNwWg02icW4nQ6+TvvpKbcaxgMBhYQGx0dZaTLW2+9BbPZjHK5jIWFBfzFX/wFe3eqVCoEAgGYzWbE43H+XiR8Q0iTWCz2c6dICjxe2f277dFPtDD7uOLTtPDv5Z1CMvBSqRThcBiJRAJGoxHDw8MMj7p16xa++tWvwmq1olwu44/+6I/wD/7BP4BKpUIymcTKygrLbNOEhAyaiZeWz+cxMDAAtVqN9fX1vmJGSATV6/Ww2+3IZrMs2FGpVKDRaNivbGRkBFarFel0GouLi9xd0Gg0CAQCDMmSSCRMCCXCK3HsRkZGWMjBbDZjcXER8XgcBoOhL+l2u9382XfrMhFHiMJisTBXTqVSodlsQqlUsvR6MplEs9nE0NAQZmdnGW7p9/sZCz0/P4/Lly/D6/WiUqnwJNJms7Ecv8vlwtTUFOr1OtbW1pDJZHD06FEWdxCJRFhcXEQikUC324VarUaj0YDZbIbNZmMCMsHqSCyGOGhnz56FzWaDRqPBxsYG/H4/HA4Hfx75i2k0Gk720+k0G3RS6PV6zMzM8GJOEsOpVAoXL15EqVTiic74+DhOnz4Nu92OQqGA69ev46233kIul2OxjVKphAsXLnCXrdvtIp1Oo91u4+bNm7DZbHA4HFhYWMDi4iLz/MbGxrhIpWkdyec7HA60220kk0neRKxWa586VqFQQDQaZU6HWq2GyWRCJBLhYpgEdfZaBoWLs1QqxaFDhxAIBGAymaDVaiGVSpHL5fCtb30Ln/vc51Aul/keXlpaQrlcxtTUFAKBAE+HSVSE4DYffvghcwWtVmvfxk6KVy6XC4FAgGGdx48fRzKZxLlz5zAwMMDvm0qlDgqzg/hUxadpf76fIPuPYrHI+6jX62VO705IPYXP54NIJEIoFPrEcF4eRezXsKY1f79pg8Vi6YOh7wZjGxsb66MkbGxs4Pz58/c9WSQoe6lUQqFQYIl/qVSKRqPBPpkU5MX6MDwlkUgEt9vNOQTxvbPZLJLJJPR6PVwuF+r1OtbX1xk2b7PZ0Ov1sLCwsCsX78UXX0Sz2cTi4iIOHz7M8ONyucwicsS3f+eddxAMBjE9PY1ardaHNtpN8fvTeH8SX18YZrMZFouFRcFI/ZtE6R513G2P/kRzzD4toVKp7vvBp5FyuVzuW4zIW0u44JCPVa1W48SMPLnUajWTS1utFhse63Q6/N7v/R4r8c3NzbHs+NzcHJRKJaampmC1WrGxsYH19XW43W6USiXYbDYe0zscDt4oSBqdjoe8xIhLZLVaEY/HoVQqMTk5CZ/Px1BD+m7A7QWapluNRgMOh4MnFDRapgWGDBDn5+cxOjrKSfTO4ovU+EwmE5smCxdOChLnED6cNHEEPlIArVQqSKVSEIlEKBaL7Bm3vr6O7e1tlMtlfPnLX2YS7+XLlzE5OYlqtQqpVMqCDOQBRipMxWIRbrcbFouFhTLo/hkeHkYsFoPT6UQ6ne4zkaZilcjIJD3f6/WgVCoxPT2N4eFhrK+vcwFE6pjkNRaPxxGNRrlwIHn2X/3VX4VKpcLm5iZmZmbg8/lYhIauERGKn3vuOSiVSmxtbUGj0WB2dhYejwf1eh2VSoUnpYlEAu+//z5sNhsOHz4Mj8eDDz74AEePHmWxCzJbvnnzJtbW1mA0GhmGCHwk6kJqnXa7nYtvSlqE143EO/L5PObn55loT/cSmY0CYL9Bes6kUikX4uSxQp9Nz6TRaMTg4CAX9tTR/vDDD1lBcn5+Hh6PB3K5nMV7TCYTK7US5+Hs2bP46le/CrVajQ8//BCxWIzN3sngncR7iBtKPnfFYpEnfAqFgs/Fg/gZHsRBHMTjCbIq2clxlkgkDBvfLYjjWqvVkMlk7qtjfzfOzf2GcP82Go3sYfmo414mLkJoIrA7jC2RSLCac71eR6PR2DU3m5mZwfDwMBKJBBYWFvqac2NjYxgcHAQArK6uotfrwePxQCwWQ61WM2qIIKYA7kj0STF3v3MlEokY7ZNOp7mRSIrDfr8farUarVaLhfBarRb8fj9eeeUV1Ot13Lx5E3/1V38FYHeBlEAgwEUvCZiR4FqlUoHRaITb7UahUMDGxgZTWm7dugWTybSvMfensSgD7rxWAJiKQ1L7QgXzJxEHO/kjiAch4VLX/NChQwBuJ6FC00NhdDodhEIh7tzTdECpVCKfzyOfzyOZTLLpM8ECCdInFothtVphsVjgdrsxPj6ObDaLZrPJULxms8kS3HNzc+zPIlTzs1qtLL9P/mupVIonN6lUCtVqFWKxGNFolKci5LulUqlYlY5UuW7evIl2u81dm2KxyMkrddBIHKJQKPQlzMIgzlyv1+Nzu1vQuSWImJAUu3NTE8IGaMpD/lQikQjRaJSlYUdHRyGXy+FwOFCr1eD3+9FqtXD58mWEw2GYTCZYLBZIJBJ4vV4+nyKRCIVCAVqtFtFoFDqdDt1uF9PT05BKpVhcXGTRiGw2y9L0xJFKp9NoNBrMner1elhdXYXJZMLS0hKbZL7xxhvQaDSQSCQol8vMgZqamuJiqNfr4cSJEwyPTSaTWFpaYn6D1WqFVqtFt9tFMplEuVzmKSth+kOhEPx+P1wuF2ZmZlhVdWFhAU6nE++//z6GhobwwQcfwGazIR6PczG+ubkJmUzWd98Lz388HodCoYDD4WBrA+FryAqA+GsEIaWFmDhldC2q1Sri8TibjBIOne4Bul8Jj0+8QBIDyeVy7NtCU2eVSoX19XXm8A0MDMBisbAqG8FgxWIxrl+/DqfTiSNHjuDChQt44YUX+PcjkQg0Gg0GBwfZ367VajGM+dy5c2xcXa/XYbfbIZFIEIvFdr3vD+IgDuLRBMHY70ZX0Ov1qFarfYltPB5HpVKBSqW64/V2ux1HjhxhBAaJYOn1emg0Gt7bhUGehplMhmH8lFw/ihAWTELLnQeJhzX8vZfPLhaLdzTVdguyLCIF5l6vx+eZKAcWiwWzs7NIp9O4efMmlpeXMTo6yrL8s7Oz6PV6uHr16h3cJOG+NDAwgEAggHw+z1xNmpw2Gg1WlDx69ChqtRouXryIzc1NnDhxAseOHYPJZGJxE6VSiZmZGchkMiQSCfZZE05f7XY7C2iEw2G2mKnX65ifn2fFxGq1yl5rRHkgJAft53sV+VarFc1m87Gbwz9Io4GuoVQqxcrKCkMvqfjaLXYTY9kZEokEgUAApVLpvgRKHiQOCrNHEPe7WO30hCJOUqlUgtfrZYPAjY0NdmIHwAILJEhRLpeZG0WeW0tLSwzxI34SSXGLxWJWn1tbW0MymYTJZILb7cbAwAAb9HY6HZw9exZf+tKXeAHLZrPI5/MYHR2Fx+NBs9nEpUuX0G63odPpYLfbEQgE2GyxUCgwQdput8PtdqPRaCCZTKLdbsPtdjOHSS6Xw2g0smAHKT5KpVKWtLVYLOyXtl/QJIOmCb3e7uaXu3Xodi4AOz9rp9LOhQsX4HK5UCwWmfNGUu/NZhPlchlyuRw+nw9OpxN+v5/9xggGODw8jGQyiT/7sz/Dl770JTZjJi8uMoJsNBoYGhrC1NQU3zcajYYnpiKRCKVSic2zx8fHedGVy+V991w6nUar1YLb7WaSLy1a9D1CoRD+z//5P5iZmYFIJEI6nUYkEoFer+dFiaZeiUQCuVyOr1MymUQ8HofT6US5XGafuevXr3OhPjAwgO3tbWQyGUgkErjdbkxOTkKtVqNer6NcLiORSDBP0ul0QiwWI51Oo1qt8iRR2Jmk70Gbxc6OZbFYZMNTaiIIr6fBYGBuYj6fZzEPj8fDPm1k6TA5OQmHw8Hf2Wg0olKpMKSlWCzCZDJBp9PxBI74omq1mk08t7e3WY1LrVbDaDTC7/fzVNpisUAqlWJzcxOJRAJarZY9YsLhMEOfC4UCvF7vvs/GQRzEQTxcSCQSGI1GGAwG3hP3CtrHhEENxt1sbMhio9Vq9fHJCBpvNpvx1FNPweFwIJFIIBQKwWKxwOfzIRaL4eLFi3tON4h28DDCBI9C1OBxx93gkBTBYBChUIibcsDt80xoEBLiIi8usjiZnZ2FSqWCWCyG2Wzmydk777wDj8eDw4cPQyaTYW1tDRqNBsPDwzCbzWg2m4hEIigWi9zMpZzJ6XSiUqlAIpGgWq0ylD2bzbJAmkgkwubmJudvWq0WuVwO29vbdxQbwskiNRCF1jI0xaWpmdAzlvZRYG9hDZfLBa/Xi1KpxLxxYTzKqe2DvA+pIstkMhZNSyaT9+RzRpx6pVIJqVTKzzddb0IaicXixyqOc1CYPYEg4nCz2cT6+jqPmIHbnh9msxlarZYnLJQYrq+vo1AocAdfKpVCLBYz9I9kUulBK5VKrJylVCpx69YtFItFVv3TarUMUxsYGIBYLGb1vB/+8Ic8HSEZfIImGo1GXswGBwd5XE4PQCaTQSaT4WmXQqHgBS6fz8NoNGJra4uPnbr+UqmUjbar1SpUKhW63S4bIu9cgIQLAH1nKsKE/lJ7XYP7vWY7o1wuIxwOQ6vV9hkVB4NBbG9vo91uMxQkm82iVCphamqKscsajQYGgwF2ux1f/OIXEYlE2LCUTC1ff/11noCSjD4pRqpUKjagLBQKbJQ5OjoKh8MBrVbL00YhpE+j0aBareLmzZs4f/48/H4/m2kuLy/j0qVLSKVSSKVSWFlZ4ffRaDSQSqVoNpssVEKiJHTvGQwGVuSMxWIMS6SCWSwWY2FhATKZDJVKhXmFYrEYHo+HzVppgpfP56HT6dhY22azsRKh2WxGp9NBqVRiDpler2ebBWEXUyqVsioVnSej0chJEAD2KNNoNFAoFAzlpIKJGgcrKyswGAzweDywWq3IZrNIpVJsni4s1FZWVlhlstPpYGtrC16vlzmDzWaTi+FLly7B6XSiUChAKpWyz5tYLGYhF/K9I56o3W7n5sUnxbj2IA7i5zW63S5zxnY29wYHB9mSBNjbe2uv4oH4tDRVoSB4ldVqxeDgIBwOB/N/STmP9kaj0chrp9vtRjQaxbPPPouRkREu8BqNBrLZLDfGgNvrI3l7/jyFVCqFQqFgQQsKUroVhlA9OZ/Po9vt4ujRo8xtC4VC2NzchNVq5aZcMpnkRiVRBmQyGcNRLRYLI1BCoRD7noXDYWg0GthsNm40FgoFpFIp1Go1DA4OQqvV4p133sHw8DAMBgPvJ3QMlH/sLIx23lu7IbDILFuYU90rfM9sNsPn87FSMH0+obS63S5kMtmuVJL9QqFQcJ5H10oIpaUYHBxEJBLhXM9isbA3KnGs2+02JicnMTY2hmq1iitXruDWrVv7fr5er+epqdlsRrfbxfr6OtNKCoUCarXax/KcHBRmTyiEHQth1Ot1pNNpFjvw+XxsTCw0sSQzaoL90RRG6P0E3L5pCafcbreRSqWYi0PQKnoYqNCRy+V47rnnsLCwwFyiZDKJqakpyGQyXL16FVarFTqdDkNDQxgfH2dSrNfr5QkPcaqKxSKWl5c5edbpdJyYk3liuVxm02aa4pCoA3VxZDJZXzEmXEC0Wi0A8ARxJ4yBChmhgtP9hlDdUSKRsN1Au91mNUEy16aJllwuR6PR4E5YpVKB1+uFVqtFLBbD8vIyVldX0Ww22Q+k0+nA5XJBp9NxIURTS1ITlMvlvJBRskB+XhsbG9ja2kI6neYN3Ww28wSNlAaVSmWfyTb532k0Gu4GJZNJ5hXa7XY+FuE9KJVKWXyFCjzyqCPyLHWZTCYTXzuDwcDHA9zGtScSCajVauTzeYYuUkFDFgU6nY4nZ8IppkKhgMFgYBNYYaFCfD3qSNNkkgp4tVoNpVLJ9xj5BAmtC9RqNQt+CH1tVlZWsLGxwQ2FbrcLu90Ok8nEcElqxrhcLly8eJE9nqjRQQUXQZ+kUinzywwGA9RqNSt+1ut1FAoFSCQS5HI53rge1n/lIA7iIPYP2ot2Q1xkMpkH9hYjFWVCPuwWZCtDTbitrS3mRtG+Rmp+VqsVNpsNsVgMNpsNHo+HvSKpiSg0/yXl3Z+3oAb4vUxLgI+sdAqFAhKJBGKxGBtLx2Ix5PN5RicBt/M1ugaU0xDaJZ1OI5/PQ6FQ8O/T9aGciNS0iQ9eKpUQj8cRDocRCATQ6XTwwQcfsIgMcb3Js1XoqalWqyGXy/ed4gJg4bZWq4VwOLwrhYa8bndrIFQqFUZDCdFIdK5p/7/foOml8Frtdt2o6U9BKsVklE26BJTvkJjb3YJQODKZjNWxDQYD0uk0f1fi3D9uFcqDwuwTEkKFG7oB6M/RaBTlcvmOIo54VcL3oOkNJXdutxsKhQJLS0s8gdPr9XC73TCbzTwZiEQi0Ol0+OEPfwipVAqfz8eQw1qtxt5pdMOurKwwjKtSqTCXTaFQQC6XQyqVolarodlsYnV1lbsnk5OT3B1qtVqsfkOQtFKpxJ0s8j0DwDBPg8GAXC7Hi6FOp2PVvf0kjKlLKSzKaBG+nxDy3yharRaMRiMUCgWCwSCUSiV/dzIkpskVbYD5fB7BYJCnRSqVCoODg2g2m1hZWUG324VWq4VEImEFqFqtxj4nxDc0Go2s6KhSqVg+uNPp8PerVCrMT6BpEBVRdJ02NjZw69Yt6HQ67gzR/We32xGNRrmoJlgMmRvTgkzHQZj9naaYtKEA4CKJihyhXxh1F6kA1Gg06HQ6yGazPP1VKBQs10/Fer1eR7FYhFarZW4YFStkxkzcRpqqyeVytg8gjiMVaeRRZjKZuGlAcIYf//jH8Hq97LHmcDjQaDT4+aCJKN0fCoWCoY25XA7Xr1/nYlwo2kHm87lcDplMBlKplPmFYrGYp3FkVttqtdBoNKBWq+85+TiIgziIRx8Pw7eh9We/IEN6skkJhUKchKrValZABsCIBeLOEOwsGo2iVCohkUj0ITpoDReG0Wi8a5L/SYud6o73a/RL5wIAK/rSPuxyudgmZmeQYjXBRZPJJCqVCpLJJAtoNBqNvqkUqStubW1xo5C408QJUygUzC2n3EEqlTKXTri/0t52t5BKpbwX78fB2+u8JZNJPgfC/Im+U7PZfKDmNxVlO03cd8bO5yyTybBdz/j4OHPXV1dXAQCpVArb29t9vyPk4VGQNgFN3ShP3RkfhzXAZ64wk0gkUCqVT8wQb68Qi8V7dgc6nQ7q9fpdFxjqnNHkhBLDarWKWCwGr9cLv98PmUwGp9MJtVqNdDrNvC/yyLLZbCzRrlAokE6nMTExAZlMho2NDZ5YkIcFQd1Ida5cLvMEa319Hd1uF4ODg1Cr1QgEAnyMhUKBJwA0GSBYHgl50JSFOn3CBYMWYVoQdlsMKPnfrcspnEDe7doIF1c61xTUuaJJFEEfaHIoFou5WCXTa7rWcrmcoXpqtRq5XA6RSIRNrUnWXqFQQKvV8gSpXC6jUCggnU7DZDIxdJESebFYDKfTySqe29vbXIhQV8jlcsHj8UAikaBWq2FtbY2FXgiOSF0z8vQipatyuYxms8nEYlI0GhwcRLvdRrVa7evIUjeqXC6zqAaJaBCfgu4jKtAI6kfTXJVKhWq1ikKhwNdbKNRB0AxhkU7dLzr3VOwR/JcU0igxockeXWOpVNpnwk0TZYlEgnfffRc2mw2VSgVSqZQ980jsg6CepVIJMpkMgUCAIUYkupNOpxlySxNSUoAsFAowGAyw2WwsxiLseNP3pg2W7BUO4iAO4tMTUqkUKpXqrlDkYrHI3CVq/AG39yfa79PpNO8ZlHiurKzwe0ciEUYPEFVh56SdJgVWqxVSqZSLPQDweDwsOPVJjP0EP+4lhIUGQVZtNhsCgQCLuezVzCU+FzUlhQ32nSHcz+j99Ho9QwxFIlEfV0x4vmn/3znNInTHfkF5CMHf98op9ys+hNDZnUHoHdpD7yfu59qpVCrOAfL5PCQSCU+GjUYj+7Sura2x76twCkiNWxooRKNRPn9UIO6Vk38c8ZkrzEQiEeRyOZMtSYKUYE10YT5umcy9ior74Y3QTQqA5Xg3NzfR6/V49E5JqFQqZV+obrfLak4EbySvNI1GA71ej4mJCWQyGcTjcdTrdcZQm0wmFmsgoQfizFARQFMammSQjxYVKJ1OB2q1msfOJFFPXQuSMidzQ/LzIt4aJesEOaPEmRLeTqfDXCY6z0Kp27sFwd2EnTiCKFIRQ7LGlOBTUi/sAFHRWi6XMTQ0BK1Wi3Q6jY2NDebYicViVhAiLhkVZNTpokW5Xq9zkdtoNOByuVh1kaZMdD+XSiUWksjn82i1WjzJo+kqTdzILyubzUKv1/M9FYlE+FoLJ38kMlMoFJDL5VjsQ7gp0TmkjYF+R5hg0MRq5zmj80LTUVLTomkfJRK0yLZarb6psd1u5wlbJpPhApqU1YjTRfcmTW6JlyCXyxGPxyGVSmGxWNBsNuHz+XDlyhUkk0k2HSUosVarxcDAAAwGA1qtFoLBIBKJBMMca7UadDodTCYTOp0Od/xMJhPK5TJyuRyTxmkNINgsQUxJOctoNLLR525KbwdxEAfx8xPlchnVarWPP03TD0JQ0HpEDZyNjQ2e3BC6hSDkOxNoiUQCn88Ht9vNvPK1tTXE43Ho9XoMDw+zCbJwfaf1k4q9YrHYJ3BCxaOQSmAymXh9e1RTiPsRKKHGLNEwdgtarwmxsNf7d7tdlMtl5oPfLaGn/UypVPKabjQamb9EqJPdgvZq2hPos+4FiioSiXhfe1iVzL3iUb0vNW53BqGMaNpLOSBxx0lrQCKRsK8tIWvIcobQMxaLBZ1Oh+2bhJ8n1C+gfO/jis9cYUbdfOB2kaJWq5FIJCCXywF8NGG5H1zyo4hH6T0CgKcYADihjMfjnAQKvZ2oayaTyWAymZDP55kbNDMzg0AgAOB24jw+Ps6KhxKJhDk9arUaTqeTk2EquiiZzuVyWF9fh9lsZtVJnU4HrVbLgg31eh2ZTAYKhYKl5Ani6PV6udgkuKNSqWTLgGg0yokxCSZUq1Xk83keRwvPMYmV7IydCpjAR+RrYdDklSZp2WyWIWnxeJx9x4hs3Wq12LaASMLpdJoLulqthkQiAZFIhJGREebW0dSNFjsSY2m32yyRDtwumrxeL+r1OneHcrkcarUaT9lI3ILUKvV6PRd/nU4HcrmcBT6IZ0VTHJKIJXVCIddPeH5Itpe8uEg5kLqCwvtBLBaj2WyyuiRx8agwy+fzEIlEGB0d7Sv2rFYr37PURKEFWiaTMf+u1+txwd5utyGXy2EwGLj4p8+j60lTPVrc6V4IhUKo1WrsD5fL5WA2mzE6Oort7W3uYAqhJEqlkgszkumPxWKQyWQ8adbr9bBYLLBardyhI3iKy+WCWq3G0tISkskkQ37p2dPpdPyMuVyuOyZpB3EQB/HpCGqc3WvQ2izkBlFTdHJyEgaDgfc2Uvilz1EoFAzRpiSdYHgEbRwZGYHFYmF0Q6fTQSqVgtvthlarxfDwMDdPqVlJKByLxYJ6vc5enxRklpzJZJBKpSCTyeD1etHr9bC1tfWxwMN2Bu2d1OTayUknzlar1WI+GP2bTqfjf6P8Yuc1lMvle+YOFosFfr+fm9GkwLgb+kej0fQVYiTUQhM52jvuJYfcTfTk44r7MaSmPHy3woyQYdSsJ7EPEp0jhE2v12NuvUQi6VPbpMKMeJf7UVqoCDwozB5z0AmmRBRAn8ohwawoSXxS8TAiFcLujlwuRzqdRiKRAAAuvEhBiD7L6XSiXq8jm80yR4kgdXa7HSMjI6ySWKlUsLi4CIlEAr/fD+CjTsnIyAgrHN24cYNJrJcuXeIJi1DMhIoHmUzGhot0LdrtNhMu0+k0c6oouW42m1AoFDh06BCTPYHbENBwOAyZTAaVSsXcJ5qW7BzF06JBhUg+n9830aUiMJPJMJSNVPmazSb7VQkfeJlMxiIZRA6Wy+U4fPgwC1csLS1xMVoulznxJ14VTQKdTicmJyehVCqRSCSQSCTg8XiQyWTgdDrZb+PKlSvY2NhgxaJ6vc6qmlQIUqFD55zk7w0GA/L5PJxOJ7RabZ9Z6l7QUeAjhS+htCwlAFKplCEbRISuVCrsE0bFtxBeQ9NEmnKROXur1YJUKkWlUkGj0eAil4o1un82NzehVCpZuWlnIkLJBU2Ph4aG4PV6UavVsLq6imKxiOnpaRw9ehRGoxGNRgPRaBS1Wg1jY2NMoo7FYtjc3MTRo0d5EkbHRs+gx+OBw+HA1atXEYvFcOTIEf7O5C9HG0an08HAwAAXnnK5HJubm7wJU7dZoVCg3W4/keTmIA7iID7e2G8qRPA44uGQZ6NMJuPmzfT0NEZGRiCRSHDr1i1cvXqVJ1m0T8hkMrYMIeg4oYycTifMZjMKhQJPx0gplsyXd3JzHA4HC5llMhneK2k9p1yA1mVhEfSgedDdflfI498Zer0eQ0NDrAIcCoW4wddsNjE2NgaTyYRarYZr165x44+mZQqFgr00E4lEXx4gl8sRCAQwPDzMyJ0zZ870URyEYbVa4XK50Gq1kEgkkMlkeO8mIRKVSsX76Cct6Drcz3WkAnWvkEqlcLlckEqlWF9fR6vVgl6vZ9pBtVqFXC7H+Pg4nE4n4vE4C6tQkCL5vRwLNaQ/LiTdZ7Iwo6AKm0Kr1UIul7P/lEwmu8ML6UnE/d4QpBxIsRse2Gg0svpdvV6HTqdDPB7nBV0ul0OpVCIcDjMBlZSAgNvkyeeff55Jq2RuG4vFcOzYMRiNRtRqNbjdbpw7dw7ZbBYTExPI5XKwWCyw2WxIJBJIpVLIZDLs2eR2u9kckPDARF6em5vDyZMnIZfLsba2xrCydruNsbExlpPP5XLY2NhArVbDkSNH2Jx4bW0NarWaDbFpKkZeIaRaaTQa9z2/xAES3jvEJaKgIpi6LbTQ5PN5npz5fD7YbDbodDr0ej2YTCZEo1HeNJPJJOr1Or/e7XbDYDAwf4omJ9TdI++Ozc1N5h55vV4UCgXI5XJ4PB42hCZcdaVSgcViwdGjR1mOPRwOo91u49ChQzzhpCKSitpUKnVHgkBdKlIFTafTfQ0ClUqFgYEBVt0k2CJNOBuNBv+M3k8kEiGfz8PtdsPtdqNer+PDDz/Ec889h0AggEKhgJs3b0Kj0cBisaDRaCCRSPC0jaJeryOZTHLxQtNCm83GCo56vR6jo6MYGBiAWq1GpVKB2WxGNpvlKSGJ2zgcDr42YrEYbrcbwO2CkmBDRCSmSVe328XU1BQ0Gg1mZ2cRj8fhcrmgUCgQCoVw/fp1LtLi8Tirl9IEHwBvOlT8y+VyRKNR7t4exEEcxM9HPIgfFMH5iUNvsVhw/Phx9Ho9bG9v49atW1AoFPD5fDAajXC73VCpVLh06RImJiZ4Xff5fBgYGMDKygoymQx0Oh0XTFQMKBQKVktOp9MIBoN7Hle320U2m8Xm5iYLLxWLRZaFJ6VjmUyGcrnMjShqwgqb5LTW7ZcTUZPxQWB1IpEIAwMDmJ2dhc1mQ71eZ459oVDAwsICc5kIVREOh+HxeGAymVAoFGC1WmG325HL5XDp0iVsbGzw+5MqYyqVYtsD4ghTDkENWGrwdbtdLtCA2/uD1WrF8PAwo3Pi8TguXLhw39/3cQc14h9lNJtNLvBJM4JywtHRURbQEhZ4pHsgDJlM1tfIJeQcicAoFAq2B1hcXHxok/V7jc90YbYzhGo7pGAnVJL7OCtmYZAPx70u0vcCaSIxEVJ1o+9IQhc+n48nEsFgEOvr6zAYDBgdHcXGxgbUajW8Xi/0ev0dJElaKAAwrOyFF15gY1xadOLxOCv3zc3NseADwfpSqRR3lVqtFp5++mkEAgEYDAYMDg7i3LlzUCqVaLVabN7Y7XYZPudyubC1tQWTyYSpqSn4fD424H7qqadY4XBhYYEniHRuyINtt+tNXULhYrNzA6CigrzKiBh8/fp1TsxJeINk2iuVCm+aZKj8zDPPYG1tDUtLS6hWq3A4HAxnpO8rkUjw9NNPY35+Hh6PB06nkzeEqakpmEwmNiYmrLTBYIDL5UIikcC5c+cwOTnJ95nZbMbQ0BDD6YgMGw6HWQ2Qpl903alYpHtheHgYa2trkMvlfD+SMSudL/KwI0gxAFZlJP878m8j4Q7C3pNnmVgshsFgQLFY5MKE/i+8JgSdITPnYrEIi8UCp9OJZDLJ2P5wOIxerwej0chG7qVSCcFgEFarFYVCgRORRqOBXC6HVCqFoaEh6PV6HD58GNeuXeNrSoqaSqUSAwMDfL3ocwcGBviZ1el0/OyRbwoAnjoKoZhKpZL5HFqtFn6/H7du3fpUmMAexEEcxN3jQYqyq1ev9v3s2LFjGBsbg1KpZLsTv9/PMPhCocD7jdFoRDKZRC6XY+44ABw+fBgSiYRtQWhNJE7VbibDwhCJRAwHB24Xi8Sh3tjY6ONw036rVCrh9/tx/Phx1Go1XLhwAYVCASKRCH6/H9FotK+JtzMImv4ghRl5dJIgWqPRgF6vh8PhgE6nQzgcxuDgIIaHhwHchhqGQiHodDq2ucnlciy6Uq/XmQ8lFotZbbrT6SAYDOLy5csA+qGQ5KdJ0Dy1Ws2FWr1eh0qlwtDQECYnJx+L2fH9NAVo2rnXtXjUexJNJZPJJBdWQkQO5bAkVheLxSAWixEKhTj3JISQw+FgJJFer4ff7+ccstFoYGRkBEeOHOFm/vr6+h3m8I8jDgqzPYLkzyk5opE7YXo/zgJtJxxOKELxoFGpVLj6p4WRPJVoikRQA4JT2Ww2WCwWyOVyXrQIztBoNBCJRFAul7GysgKpVIrt7W1MT0/jq1/9KnK5HD788EN2vC8Wi5DJZDh69CgUCgX8fj+uXbuGfD4PmUyGwcFBTE5OMheIoBbpdJr9z+RyObLZLCwWC4LBIEKhECwWC8RiMTKZDLLZLGw2GxwOR18B0ev1GOftdDqh1+tZMIMKCTJypE4eTXTod8kTjaYyu90PJNRB0v7C67m0tMTmoMS5u379OgYGBlAul9n/hI6bDKopQafXUFLudDqRTqdx8eJFjI+PY3Z2Fr/wC7+Ac+fOoVKpYHJykmFyxWIRoVAIJpMJR48eRblcxq1bt5jTNjExwVBDEhhJJpNIJBKwWCws1dvtdqHRaLiTCICneyKRCGazGYlEgj3QqJuYTCZZzZFULG02GxdjYrGYJYMJrhGJRPrsBYrFIgudEEeDCL+kcklQHLoW1WoVNpsNYrGYlZpEIhGmp6dZIKTRaGB5eRnhcJghrRqNBj6fD/F4HG+//TY8Hg9SqRSOHDmCo0ePMt/ru9/9LsrlMqxWK0NzhVPp7e1tiMVijIyMsBolibAUCgXk83l4PB6+PtQsIRNynU4HnU7H0BhSgEwkEmg0Gpidnb0jMTuIgziIz26sr6+j2WzC5XKxbcra2hqAj8QV9Ho9XC4XMpkMoxbW1tbQ6XTgdrvx0ksvodFowGQy4a/+6q8Ylp3JZPZtGFNeodVq+1A7hJChqRd5cVIRJZPJ4PF42Ny5Vqvh6aefhsvlgkqlQjKZhMPhwOLiIvNvgY+aoQC44Sw8FuDe6CHkOUqNwEajAZvNBr1ezwgTgvlHo1HcuHED8XgcRqMR2WwWtVqNueWBQADPPvssgsEg5ufnGRoaDAYxOjoKg8EAj8dzh5w77V1kR0P5llDZmBqpxNOPRqMPNGXdLe7nPR6U7nM/10QYbrcbkUiEczO6B4mS8eGHH0IulzPPXvh5Q0NDUCgUTMsQqnUTj4wQKe12m3NNsi5wuVwsw/84Q9R70ji9jyGKxSJ36h80xGIxk/Xr9Tob7H3ag/yaCCK3vr4OvV4PrVbL6oqE3c3lctBqtfD5fNja2mI3eq1WyyN/6ubMzs7ixIkTXOhRB+l//+//jXq9jtOnT+PYsWNwOByQSqXIZrP44IMPUCqVMDExwVMaUg+q1WpYXl5GMpnkB3pychIajYbJzCQhT8p85Nlit9tht9u5gKDunVarxfPPP4/JyUn2dCO/rLm5OUSjUZ40keFxPB5nz6pMJgOr1coy7dQ5VKlUXPDRd6fOl9CniiTRO50Ojhw5AofDwaqZZ86cweTkJH+3TqeD1dVVdDodTE1NsY2Bw+FgX7FvfOMbAG53OOm71+t1+Hw+hkUKgzpEIpEIS0tLGBgY4K4qkW81Gg2CwSA2NzcxODgIqVTKPALgNv5dr9cjlUqhUqkwkdrtdqPdbnMnjzZpvV7Pkz6SzXc4HOxXR9daOPVaX18HAJjNZvj9fojFYqTTaUQiES68yAOGJHA9Hg8bq9O/x2IxRCIR2O12pFIpzMzMwGKxwGQysXBHo9FAPp/H6uoqstks35+xWAwvvfQS5HI5/vZv/xZSqRRPP/00/H4/e5cRzDMYDLLhNAnayGQyWCwW+Hw+KBQKLC4u4sSJE3A4HMhms3j33XdRr9dx6NAhVKtVRCKRO7q9tBnTZF8mk+HYsWNMzne5XPjwww9RKBSg1+sf0QpxEAfxeONR7M8HsXuMj49jc3MTjUajT0yr2+1icnISX/jCF3Ds2DGIRCJEo1HcvHkT77zzDlQqFTweD06ePMkT/JWVFWSzWZ6QlMtlbGxsYHNz8w5uE3moSqVShvEJm8D7cY5o8tTtdhGLxfDFL34RIyMjcDqdKJVKuHnzJt5//31Eo1F+D7lcjomJCRbXisfjnLwrFArYbDbUajVkMhmeuOh0OpRKJc4ndh6XVquF1WrlYmpsbIwtfbrdLra2thAOh3HixAkcOnQIKpUKN27cwJUrV1Cv12E2m3Hs2DG43W6kUimsrKywhcHDcMHIE9NgMMBsNvPkc35+HqOjo1hbW3tkgwParx9HmEwm6PV6bko+bAQCAdjtdr7OQrse4tK//PLLkEgkWF5exvb2NjefheeLxEJKpRJUKhUcDgfW1tYeWdEL4K579EFhdh8hlUphMBhgMpl4lP9J80PbGXvJwpPMu1B0gwoaKl4oRkZGGJJHcAm/38/TKZIKp+kUjdaJi0OTDLlcjnfffRenT59GsVhEtVrFyMgITxio2BFOxejYy+UyUqkUgsEgnn76achkMl5YCVrXbrextLTERFwSuiCPr06nA4PBwAbCtVoN3/rWt/A7v/M7GBgYQKPRwK1bt7C+vg61Wg2j0YhqtYpEIoFer4eBgQGe4JFvmVwuR6lUwubmJhtDC4O+N+HRc7kcyuUy86wIQ5/JZPDmm29ifHwcGo0GN27cYF6ZUqlEsVjEmTNn0Ol08NRTT6HZbGJjYwPVahUDAwOo1Wq8AVORSSRwggJubm72jeFVKhXcbjccDgdj50lxamJiAmazGdVqFblcDouLi3fAVemakVKUWq1Gr9e7Y9OhiRNNjYirRteGJOqpCM/n89je3u5TZSLRFlJlNBqNvPDKZLK+Yo6WNLVajYmJCfh8PiiVSqRSKVy6dAmNRgNHjx6FXC7HlStXUK1WceTIEV7UI5EI+891u104HA4upr7whS+w2Ad1K81mM1wuF5RKJSuBUud5dXUV9XqdIYukYkpmpJcvX2bfO3omqdin5gJJ/eZyub5ijTz+CGojFosRDocPCrOD+FTF4y7MnhQF4XGEsAG1W1BjbGdoNBpeC7PZLBYXF6HVanH48GE4HA4At6/DhQsXsLGxAblcjsHBQTgcDjz77LPsjUYKvcFgkBPaYrGIjY0NXo9pbT9x4gRUKhUXSORvOjY2xmufcJJGEO+ZmRkMDg6iUCjg2rVrcLvdeOaZZ+DxeFCtVnHx4kV8+9vfvmOvHRgYwOjoKMLhMLa2tiCXyyGXy3Ho0CG+v65cuYJIJMJN0V6vhxMnTsDtdkMsFmN9fR3BYBCVSgUGgwFerxcSiQT5fB5erxderxc+nw/NZhPnz5+H1+tFJpPhAvDmzZusVklCVyKRiIWdHjZonyV0j1qthtvtRjabxerqat/+TrSQh7n3qYn5sM+P0PycghBapCEgDOLNE8qmVCrBarUik8mw/RM1xOk+sFgscLlckMlkSCaTfcMTsViMmZkZzMzMoNlsYm1tDclkEtFo9JErot9LHBRm+Gx35GhT2k16lCYFQll74ZRDGNQBI8jX3NwczGZzn2iI3+/HkSNHoNPpGJqgVCqZvPs3f/M3+NznPoe1tTVMTU3h6NGjsNvtnKi3Wi3GrNMEgwyXSSnw/PnzOHHiBJNg5+bmEIlEcPToUVZKIrGEfD6P5eVlXLt2jcUxxGIxpqen4ff7efqQTCYxOTmJ999/H7Ozs8zv6nQ6bMh5+vRpBAIBKBQKlMtlRCIRrK+vo91us39WPB7Hj370I4yNjXH3hoqVRqPB5tiUvJN5pcfjQSKRgMvlQiAQQKvVwk9+8hNYrVaWXN/a2sLc3BxisRjUajVj2UlkhKCAN2/eRK/Xg8/nw/b2NlQqFaxWKxsqkn1As9lkMY6pqSmeKJLYSqvVYqGXXC6HM2fO4Omnn0aj0cDS0hKcTiereAaDQaytrbHfBxUfsVis7x6i6Z9EIkE6nUar1YLX6+V7oFKpMFfQarXC4/Hw+Z6bm9v1/iZuHBXQtODRxG57exujo6Mwm83odDrs50bJSDqdxrlz5zA8PIyhoSHIZDLcuHEDjUYDfr8fmUwGS0tLu3728PAwms0mpFIpnnnmGTidTgBg9bNUKoXFxUWk02moVCremEQiEW84BoMB2WyWmwwOhwP5fB7j4+M8cSMfnVKpxBCN3VTP6F44KMwO4tMUj2N/JuuSTzvn0mq1IpfL3RNcTCwWw+/3s2qsMJxOJ4aGhljNtlqtspBQJpNh30uCaRHs66233sLx48chl8uZX0NTN7KLyWQyCAaDiMViSKfTWF5ehkQigdfrxcjICNvFZLNZmEwmTE9Po1Kp4OrVq9ja2rrD79JkMsHr9aJSqWB9fR1SqRTPP/88i2S9++67+PznP4+trS0sLCywUNWbb76JqakphsKHw2GkUilWMZZIJFhbW8OZM2fgcDgwNTWFRCIBu93OwlFCtWcyKCZp9ampKbz44oss2JRIJPCDH/wA0WgUo6OjUKlUWFlZYfEs4XUBPoIHqtVqTE5Oot1u48aNG/y6vYpqqVSKbreL6elpnDx5kvMWKlCIG/jNb34Tv/Zrv4Zer4cLFy7g+PHjsFqtqFarWFpawtLS0n3xo3ZCTIlT/nGUDHK5HDMzM5iamkKr1cL3vvc9nDx5EpVKhWkVO33Hdgsq8Gq1Go4dOwan04mtrS3Mz8/fk9/c44qDwgy7L/y08Pw8wRL3i503oZCrJpVKeeqwW9DIvNfrIRQKYWJiglWeZDIZFAoF+5jp9Xq0222W7w4EAlCpVMjn87h27RqCwSBeeukl5PN5nDhxgj2qyGOFzC8BcKJ+69Ytxm6LxWLUajVcvnwZvV6PicCvvPIKZmZmGCZ448YNRCIRmEwmpFIprK+vsxgHTaxsNhuLTiQSCTgcDpbqJ/NHMir2er2Ynp7mAiedTmN9fR2FQgETExMwmUxotVpIpVL48Y9/DJfLBbPZjHQ6jbW1NTQaDQwPD2NqaorhsMFgEBKJBIODg1hfX0e320UgEIBEIkEkEmFz72aziZWVFcRiMT7XyWQSm5ubsFqtiEQiEIvFmJiYQLlcxsDAAI4dOwaTycRY/kwmg7m5OR7JOxwOli7e2NjAyZMnoVar8YMf/AD/6B/9I/YXO3ToEEQiEXK5HE9B/X4/bDYbJBIJstkswuEwMpkMRCIRwwjOnDkDp9OJRCLBXC0qwoSTJJvNBo1GA5FIhEqlgmw2C4PBwNM0gn8SR6xcLmNra4tVLKVSKReaSqUSer2e4ag0sSWyOpk4z87OcmetWCzi7NmzOHnyJBfF165dw8rKCstDu1wuNJtNDA4OYmBgANVqlQVmms0mrl+/jueee479fWhiVi6Xsba2hmw2yyIqL774Ik+nM5kMvvOd7wAAXn/9dZ4qvvPOO3jmmWcgkUhw+fJlFItFPk8EoyGzd4JoBAIBzM/Po16vHxRmB/Gpik9D43Snd9inLYxGI4xGI+8FwG2o3tDQEHw+HzY3N3HlypU7fu/FF1/ExMQEKx47HA7YbDZuhqVSKbYJoT1sbGyM+bMGgwEffPABN7Fu3rwJrVbLnLWdKIDdgvjKhw8fZm73wsICVCoVQqEQi5c899xzGB0d5aleNBrF+vo6isUiJiYm4PV6US6X8Td/8ze8ZlYqFczPzyMcDsPr9eLIkSMYGRkBACwuLuLixYtc5Op0Oua60bkkn8psNou//du/hVgsRj6f3/M+kUqlGBgYwBtvvME0gYWFBTzzzDOIxWJ4++23WQTq6NGjGBwcRKvVwtmzZ1kpXCwW48UXX2QrG8qhisUiSqUS2u02RkZGYDab0Wg0EIvFsLKywoJga2trfRNXmUwGu93OghrT09O89164cIHFYqgpu5vK96MMpVKJ8fFxjI2NQSqVIplM4t133wUATExMsOryTq+38fFxDA4OQiKRIB6P48qVKx8Loo3uybuFcHJ/tz36My3+0e12P7UL7f3Gzu/ZarVYpa9are7beSBFIRJn2NjYgNlsxsTEBHt1pdNpFvegB1mj0WBlZYUnXt1uF2+99Ra8Xi8ajQa2trYQDAah1WqZa+T3+yGXy9HtdpFOp7G6usowwG9+85s4ffo0Tpw4gS984QssQlIqlbCxsYG5uTmGmz711FN48803kU6nceHCBeYpEZyAoKgUg4ODyOfziMVivLgRrM9ut2N7exvvvPMOUqkUjh8/DrfbjWAwiEuXLuHv/b2/h6GhIcjlcvbXKJfLaDabWFpagsvl4q5jKBTCt7/9beTzeVbom5mZwcbGBk6fPo1Go4GNjQ2Uy2UMDw/3wQhtNht6vR6y2SxPnLLZLGQyGXfHYrEYe34RaZVk26kzSl0kKpRcLhdGRkZQLpfxjW98A2azGbFYDFeuXOFilSA0NE2jTYLkfoXiFiStfPjwYQSDQTidTqhUKiwsLKDb7eLo0aN4+eWX0Wg0UCgUmJ/X6XS44A2Hw9BoNDCbzVzYU1E2MjKCYDDIhs90HSnpoHudOsc7zbo7nQ7efvttzM7OQqfTwe/3I5/P48KFC1hZWUE6nWYfG5PJdIdELhHBycRdq9ViYWEBZ8+eZZsHt9vNkvtKpRI2mw25XA7Ly8vsB3jp0iW89NJLAID33nsPX/ziFyGXy/k6khANTTllMhlL5GezWVZ2dLlcMJlM8Pv9bPB9EAdxEI8ungTcCcAdIka7hVgsZhj1XkFrCK1jRqMRQ0NDkEgk+MlPftInkiCM5eVlhu9rtVo8++yzLO5EnmfXrl3DwsICisUivF4vjEYjJiYmWFlwdnYW0WgU3/72txnqfuTIEYyPj6NYLGJhYQGxWGxPeCbteVevXsXg4CByuRzkcjnC4TA6nQ62trawvb2NjY0NOJ1OtvbR6/XI5/MwGAyYnp5mOOarr76KDz/8EH/xF3/BnDKaPmUyGVy9epXzCqElTqVSwcWLF2GxWNBut9mihSZ5Go0GsVhs35ySkDhzc3Pc2Dt06BA8Hg/D7W7evInR0VH4/X7o9XrE43G88cYbKBQKMJlMOH36NGQyGba2trC+vs57NDVh6/U6JBIJNzQVCgXq9ToXwcK9TKFQwOPxwOfzIZ1OI5VKsVE4FeFnz57F5uYmtFotF9FutxtmsxmZTOYOZIwwNBrNfRdHlLtcv34d7XYbW1tb8Hg8iEQivL/tnCdJJBKmIdTrdcTj8Y+NZnSvs637mYF9Zguz3v/vOP/zPjAkCONuOPv76XxEo1EMDAzw+FgkEjF3S6FQoFQqsSkyCR9MT0/D6XRyETM/P49isYhcLofNzU1WfWq32wiFQmxkabVambtF5spSqRS//Mu/3GdyrdVqGf9dLBZx/fp1FAoFOJ1OnDhxAsDtSdjm5iYAsAqPWq1m2XUKeo1IJOLJCombxONxjI+P48SJEwz9jMViSCQS6HQ6kEgkmJubg9frhc1mg8vlQiqVgs1mg9/vx5UrV3Du3DnMzs7CaDTiy1/+MuRyORKJBG7cuIFarYZAIIDLly/jxRdfhFwux7Vr11gYJBQKQaPRsHEnCZcQtp2Iqm63G4FAAMViEX/yJ3+CQ4cOQalU4ubNm1CpVKwmRRLvarUaAwMDeOGFFyASibCxscFiFrS5/NEf/RGsViuef/55DAwMoNPp4Ny5c3C5XDxJq9frSCQSLFqh1+tx/PhxKBQKXLp0CV/72tegUqlQr9e54CK4o9VqZfNSEvSoVqvweDzcOaSCTKFQ4KmnnoJEIsHW1hY2NjZgt9v5OnY6HajVavaGa7fbyGazfXCWWCyGt956C2azmbH/iUQCc3NzGB0dxRtvvMHFYTAYhEKhYKPRdrvNlg56vZ7FRcRiMY4fP868sGw2i7W1NfapCQQCrAZVq9UQDoexsbGBwcFBhnG+9dZbKJfLePvtt+H3+9mThWDBtFkVi0VW4yLoYiaTgUKh6EsiDuIgDuLTFUJxAYK1EadmvyB4/N1C+D5qtRpSqRRyuZy9GoUhlUrx3HPPwefzQaPRoFQqMfqDlAlrtRqWlpa4eJudnYXZbEa5XEY2m+XGJIkhEY/IaDRieXkZk5OTCAQC3PAjYYydQTY2hUIBc3NzrIwsVNwVGgC73W5u0pGY1Ntvv42RkRFMTEzA7Xbj+PHjuHjxIivt9Xo9LC8vY2lpCVKpFB6PBxMTE8jn89jc3GQV4lKpxLwmkUiEVCrFk7+dkzKCfArPe7PZRCgU6kNpbW1tYWVlBSaTCfF4HGazGcFgENlsFq+99hqOHj0KjUaD7e1tFpACbhfb6+vr+J//839CqVTi3//7fw+v18uIlKGhIczPz6PRaODy5ctYWFhgFe3BwUGMj48jkUggGAwyCsZsNuPSpUv4yle+Ao/HA4PBgEQigUuXLjF3Drg91RJ6lO4VexVHarWam6Q7g4y8n3vuOdhsNmxubiKbzSISieCFF17A5uYmq37T55NZdCwW40YteZDFYrF7nmrtFuRFuxdHcD8j7AeNz2xhBnz8XTAi/RMc6eMI4eL1oJHNZnnxpPdpNBosmUvS32q1GmazmX22aNRPCeTMzAx+9rOfwWq1YnJyEh6PB16vFwqFgo1519bW8N577yGXy8Fms8Fms7HfycjICJLJJH7605/iqaee4mlGMpmEWq3Gm2++CeD2BIVkbIkz5fF4EIvFEAgEUK/X79jIhNeD+G7kkyGTyRgCSOqTFy9ehFgsxksvvQSTyQSVSsWKllKplH1UlEoljhw5gkqlgmaziUgkgq2tLbzyyitQqVSw2+0M93O73VhbW8Pi4iIqlQqWlpbQ6/Vgt9vZ6JmIraVSCSMjI4jFYqhUKizvTwURdSyJr3f48GEMDw9zB65UKnHhEwqFIJfLUSgUuPtFpuCnTp3CxMQEk5jlcjleffVVhoCWSiUkk0koFAqsr69jaGiI4RoWiwW//uu/ju9+97uYmJhANpvlzSSdTsNsNrPiJ22+O6WPSQ00kUhgdHSUN0S73Y5YLNYnl6xQKGCxWBiOWqlU2PSaeAd+vx/tdpshISKRCNvb2yxAQ9wJs9kM4PYGQn5h7XYb0WgUH374Yd93FIvFOHv2LKanp3kyR5NommhSYUzFMHHnSqUSQzdp2kZTR/I2o6KLfAVVKhVzJqlxkEqlHvj5PoiDOIgnH8I9iCYTj6txnEgkGH6+W3JN5szk7UgwuVKphFwuh1wuh62tLYZtazQa5HI5lorPZDIolUpYXl7GoUOHuFGZTCZZlTcWi7E0/X4qhe12GxKJBL1ejxP53fIngrMTUoGaxiqVir2rfvazn+G5555DtVrF6OgoXnvtNUgkEly/fh06nQ7r6+uoVqtIp9Not9vQarWYnp5GsVhk6wHh+crlctxA3Xmt9pqckSomRSqVgt1ux9jYGJ566ilsb2/j/Pnz8Pv96HQ6iMfjLDgnEokQDoeRy+UwNzeHQ4cOIRAI4PDhw/B4PJBKpTCZTDh16hQ0Gg08Hg8jZcLhMFqtFkZGRnDixAmMjIxwLvPBBx8w9cLhcLAYlUajwZEjR/haEve82Wzy9X6Q2E+UhDxRyUdVqVQiGo2ysvLExARrDxACx+v1otfrIZFIcH5B5tJ+vx8qlWpPrrgwdvLq6HrtBbclWsJOaOXDxmeOY0awPOD2Sd1Jon/c8WlWiNopIELJND1I9BpKLInfpdVq4XK5WNFxcHCQBTyoeNjY2OBOkkwmw7PPPgudTodqtYqVlRUma77++us8sahUKmz2KBaLcebMGVSrVfYcI84S+WhNTk5CqVRia2urj3S7Myhhp4QeALvAy2QyLjzFYjGef/552Gw2FAoFtNttDA0NIZlMsqcadfJIRYg4jZlMBqOjo2xwTY7zLpcLpVKJoZ90npVKJRwOB5RKJW+qBOUkoRSn04l2u80G0jabDT6fDxcuXMAv/MIvIBAIoFqtolQqQaFQsJITKVltb2/jzTffhMPh4OliuVzGuXPn8Prrr8PpdEKr1fJ1p42bYCTNZpM9Qj73uc9BpVIhHo8jGAzCaDRCJBLh6tWrmJ2dhclk4u7h4uIiYrEYi9R0Oh1Uq1Uu2pPJJMvparVaVmAkVUSySiCsvE6nQ6FQQCaTgV6vh9lshlgsxsrKCn7xF38RKpUK2WwW4+PjaDabWF1dxfXr12EymdjMk1QOSXGx1+uhUChgfX0dFosFfr+fizdqKNy6dQtGo5G5ffl8HpFIBK1Wq8/SgZKh4eFhaLVafl2324XH44FWq8XKygqrLgJgZSraIGiCRmbYQijSAcfsID5N8WngmH3WgvYsg8GAkydPol6vs1nv8ePHYTabIZPJWOFRCKFXKpUwGAxIp9MwGAwsutDtdjE3N4dr166h2+1Cq9VyAUiTIOKfJRIJrKys3PPxknEwiUvR2kgQw/HxcSgUChYbof1lYmICcrmc4ZH1eh2XL19GNpuFVCplBEy1WsX6+vojnY5IJBJMT0/D5/Ph7Nmz+KVf+iWYTCbEYjF8//vfR6/Xg0wmY59SkvWnfV2tVkMikSAcDsNkMiEQCECr1TIfsNvtolarIRaL4YMPPsBPf/pT1Ot1TE5O4tSpU5icnAQAbG9vI5lMQqVSsfhbIBCA3+9HLpfDN7/5TcTjcRadIgoGgEc+ZJBIJOztZjAYGMp7/vx5NJtNyGQyaDQavoYTExOYnJyEVqvlfDAYDDKVglTC2+02zp49uy/skmxvyKt4r9Dr9dDr9QiHw3c1194rDjhmgjCZTLDb7dxBqVarLDRBELGHDYVCwTLrO7kpwL13wB7GM2E/JcaHiZ3vRd0TmiYAH3X6Op0O+1mRaZ9IJMLAwAC8Xi/m5uZQqVRYPITkfAcHB6FSqeDz+dDr9bCxsYGFhQU4nU4sLy8jHo9jaGgIpVKJFRUrlQpL2YbDYYTDYTZ1Jul8j8fDBFea9uwMOuc7p2fUrSMvGFrw5XI5MpkMK0MFAgEkEgnE43F+j3q9jmg0ypLytKgRhprMuRuNBnPQqNDVaDTc9anVaojH49BoNOxwT4bXNMkj4YuVlRUUCgVMTU1BLpfj5MmTMBqNuHHjBnPVDAYDHA4HKpUKNjY20Gq1WGziyJEjvGg0m03o9Xr86Z/+KV5++WVWw6RFkDZkh8MBkUiEYDCIkZERLoo7nQ5GR0chk8mYQ0YbCxleUxEYDocBfOSbFwqFGL9PJpLUVDly5AgXl9FolH3v4vE4kskkH5PVamXFzNOnT7PBNFlCEMeOOHOFQoG96CqVCoLBIOx2O/R6PYvBkAcdTcWA28VztVpl3zLaDMgkm6C31L2rVCoM6aRmEUFUtVotBgYGEA6HkU6n+X4VPmfkq2iz2QBgT47IQRzEQRzEvQY1o8xmM1ZWVhhuRg1GiUTCXqZyuRxisZiRBrT3E3yQ1uxLly7hS1/6EqxWK2ZmZlCpVPqk3d1uNzweD1wuFwwGwx3cLuGxEVycwmw2c7FA+/3OaLVaWFxcBHB7P6Z989SpU9jY2EAkEkGn02GhKEItkIgUvf/dREruN7rdLkKhEAKBAF555RUYjUZkMhlcunQJUqkUo6OjUKvVLNzV6/WYwtBoNDA1NcW2NUtLS/jRj36E1157DQaDgb3XNjc32diachDKeZPJJHPp8vk8c6HT6TScTid8Ph9kMhlMJhO2t7fRarX4XriX3FSlUsHv97P/6t1CqVSy+JvJZEKtVsMHH3zQZ5vUbDb7rkO5XMatW7cgk8lQqVSQyWR4WkrXjJRINRoNgL3VL+lnd/tuIpGI78/HpVHxmSrMyHNJq9Uyj4acw/cint5vkL8VkXEf9MLd71SNigoycCRC8P3Io95vyGQy5tnQzUznkRJNIfnUYDDA6XTC4XCwIl6xWITdbodSqUSv10MkEkEymWTJ81wuB5VKBY1GA6fTiZs3bzJmOJVKcaFHoiHETbp16xbS6TSbS5KPRjKZZM7R3YpmsVjMCTtJ/rZaLd6kzGYzY++9Xi/EYjGq1SqcTierOqbTaYRCIaRSKb5GMpmM8efUgaNEvtls8pROIpHwJkLm1QRnE0InyBqgVqvxJOq5555j6wIAXLjkcjlUKhWkUimYzWZYLBY0m01Eo1E25/7pT38KnU7HkDuj0QiPx8PFIXGd0uk06vU6Q+2I80Z4+3Q6jZGREeYR1ut1uFwurK2tMber2+1Cp9NhdnaWJYgNBgPkcjl7fxFc0WKx8H1DU6lGo4Fut8sJAk0MbTYbhoaGWD1Lp9PB5/MhFosxdPL8+fN9kI9er4dyuQy5XM7ml+12G2tra5idnYVEIoFUKsXy8jJDO9fX17nYOnr0KPL5PLa2ttgagRIZ2jhIUIYK0Xw+z4Rs4mqSyIfD4UA8Hkcul2OVUwrqDpMPzJOY/h/EQRzEz1fIZDKMjY3BbDYjGo2iXC7jypUrUCqVXBDU63Xk83nU63UsLy8jnU737afUSANuF0JqtRrFYhFut5uVaxUKBba3t1EsFhl+2O12kUwm+XOAjxpQVDgIJ1bU8NrNrFqj0UAmkzHva6eBsRD6t7S0hEqlglKphHq9zvt0r9d7aB+w3UIikcBkMsHpdOLQoUOYmZlhaHoqlUI2m4XRaITX64XZbIbH42HDbBLoEIpBEe95ZGQEhUKBERmpVArFYpEF0crlMpRKJYtpFQoFppBotVq43W5uFFO+Eo/HodVqcfr0aWxubrJ/592CmvA0bdze3t7ztWazmZufWq2Wryvx7PYLyucof6L7odFoMG3EZDJBrVYzpWY/iOm9RLVaZTG8x4V++0wVZtVqFclkkpOvdrvNxdOjmixptVrmi+j1ep7o3O/0a68Lvt/NQBwk6s4/jLv8brFbp6Fer6PdbvPkRjjpE4olEMa7Xq+j2+3ywh+PxyGVSqFQKBgCoVQqeZrQ7XZht9sZqhaPx5HP52E0GmG1WvsmRzqdjuFinU4Hhw4dgslkYqngWq3GmOVMJsPTDp1Ot+d0kxJsKoQIOtjpdPhzAPBEUKfTweVyQaPR8KSQkn4qXGjTIUggAF5g6XMJVkELDQUdi0QiYVVCjUYDlUrFFgBWqxVWqxVqtZr96VqtFux2O3tjUVFsNpuh1Wr5eEnBsFQqYX5+HtPT01w4EVyEzJc7nQ4KhQLK5TLDJrrdLvL5PEvp53I5+P1+LthIwpeUs0j+nzhbJPyytLSEsbExPu+ZTAYejwdyuRxzc3NYXl5m6wQqzuhaSaVS9Ho9BINBVsqcmZmBXq/n14nFYi78qCCmDaTX6zG5mRZ84YZNBbdCoYBEIuEOn9vtRiqV4omdVCpFuVxGvV7n54Q4CSTaQlM4gtyazWb2zaFGEhXV1HihiWu5XEYsFmMuxUEcxEHsHwTRe9yS35+GoCausLAhYSua6NMaQ2qxs7OzCAQC0Ol0XPTcLVFvNpssMKHX6xEIBBhqPjg4iNHRUdjtdgC3kUvkvQkAGxsb/D60vlOQZL/wZ7T2U3Na+F3p54FAAJOTkygWi8wdJ1n6ZDL5SOCKlM/Q5JAmkW63m1WMCWJJvHxSUabiN5FIQKPRsJ+pUqlEpVJBKBTi19EeNDo62ndNhMJXlJs0m000Gg2srKxgY2ODKQP1eh1erxdut5sRHktLS4xqcjgcGB8fZypFJpNhbuF+Qa8RCoBIpVLOTSl3Im7g4OAg9Ho929HIZDK43e47PPmA2/mSQqGAWCxmnz86F4RAIu472fVQPkyfS/DHeymuhLkANUgfJyXpM1WYAeAkSavVshHxo4T7UcGg1+v5pqRpy4NcyJ2Qxr3egzo89H+6QZVKJRQKBU+wyET4QWCSOz+b/MpowRO+p0QigU6nY3M/pVKJQqHAyouUjJPcPk0yadoEfMSroYeMxvbAR4bXSqUSjUYD169fx9TUFI/gaWI4NjbGJte1Wo3FOZaXl3mB3I+EunOSSjhv4hxRZLNZ2Gw2yGQy7vi0Wi0olUoEAgGo1WosLy8z9G/nlHZnF4egqPR96f3otVQQ6HQ6mM1mOJ1O2Gw2aLVapNNprKys4Kc//Sl7lhEcE/iIQ1etVhGLxWA0GmE2m+FwOBCLxXDo0CGGYK6urkIsFsNqtUImk7HgBJHAqXNKRSupYRFEMZVKcSEbjUYhkUhgNBpRLBbZisBgMKBWq/H0TVikGgwG2O123Lp1i0VKqLFCojTAbZEO6owJv9v4+DgMBgNPqTY2NjAwMIB2u42xsTE+3+VyGaFQiBVH4/E4d36VSiXm5uY4WSCiMRXmoVCI73fqYgK3C37iQrZaLbZooOdQJpNBp9NBKpVia2sLer2ecfx0nul9qImkVqsZNtlsNhGPx3mtOYiDOIj9g7wNKWnbmTg+qRBy3z/O2G1P39jYgEKhYN4zcDt59nq9mJychN1uZ3Err9eLVCqFeDy+6/tTA291dRVutxsajQZqtZpVeScmJjA7O8vKjyScJRKJYDQaWemZjkEY+9kdUVOTijPh9yS0VCQSwebmJiwWCyYnJ5HP53k/u5ewWCyoVCq7vp6ae5Rber1ezMzMwOv1sgXO1tYWrl+/DpfLBYlEwj+n5jU1CYlOQLkcfT9SkqZcinh79PsE7aPX096TTqf5OKlRUS6XcenSJUgkEng8HpRKJd77jx071sd9tlqtnNtYrVZWTi6XyygWi/z9E4nEHYOEgYEBOBwOJBIJRCIR5vC5XC5otVoUi0WEw2GUy2WMjY1x3rKTG0awzk6nw/cYIVPIgqdSqXCOKfzOwvcAbhfRlCNTk/dJx2euMAM+uhkJevYoo1qtsu9IvV6HTCaD2WxGsVi878+iBPpegzoFAPrEEhwOB0vvikSiPhGB+4mdG4fwgdsJJxCJRAy5Iy4ZPbTxeBztdhsWiwVGoxEAkE6neZRvMBjY3X51dZUx3iQsQsVlOBzG2NgYdDodFhYWoNPpoNVqYbFYkE6nefJAhRmNvZPJJJRKJYxGI7LZLJLJ5H15Uey1cKdSKaytrfEUw2azsQeY0WhEs9lEsVjctRFA3RwiXLfbbV5wa7Uae6tRIUxwQlIgJDVC2qwymQxPlYaHhxnWSpMbUhskKObo6ChsNhvC4TA2NzehUChgMplYAYpk3QuFAi9eNM0h6eJOpwONRsPwYBJdIdhftVpFPB7nQnxgYIBFYqhYy+fzUCgUGB4eRjgcxtDQEBepq6urXNBotVruIpKR6eDgIKxWK3PZ0uk0m06StH8qlWKD70wmg/HxcYaRRKNRFqOhqRd9BklAk3BKLpdjqEs0GkUul4PX6+WpL8FN6LqQrx2dN51Oh2w2y4baJN8vk8lYnbHX60GtVrO9A3WBxWIxQ4hLpdIBhPEgDuIeQ8i/Jt7rkw7ai1Kp1Md6PIRy2c04W5hLUNB+HIlEmJ5QLBbvmqMQpzcWizHUjvYKQrCIRCIUi0VkMhleaymZ3qtxvlsOQ68VinftbGxHIhFG4UxPT8Pr9WJoaIjhgiQuJRT+2hkikYiFmXbLB5rNJptsa7VajI2NsWIyTbsSiQTOnTvHPGgSWKGmOqF6SESl0WjcAcmkPSEajaLRaEAqlUKtVvP+BnzkJbbbeRTuccQFq9frjIxRq9W8zwmpFjT5M5vNjO6h75RIJFAul9lShgy/dTodRkdH+dqk02mYTCZMT0/D5XKxH66QliGTyeDz+frE0ABwEd9oNHhfbTQaTDeQSqV99+duzRf6GTVVSTl7t9ipPfC44zNbmNEolYqN3Twndvs96ugIf1cYyWSSTWd7vR6cTicLGVAnAwDLeO/3effiEyEMOi4ALCZB8DaC2ZFqIcEr6SYmKBd9z7udh50TMjpegufRwkLTAeL/0AMYiUQQiUQY5lcoFNBqtZhbZrfb2ci4WCyyuARhvqmI6/V6MBgMjEmmRYOKD5rIpVIpXjBIyQ4ATzToPAuv0f1GNptFu91mOODJkyfh9Xo5OQduT2bI7JpCJpMxx4gw5QQTJLgeTUEBcJeo1+sx/47+T3BClUoFp9PJRSlNizKZDLrdLoxGIxwOB7rdLuPQe70eBgcHsb29jUqlwkaTRO4GwCpHNJEiuEKn0+FNge6zdDrNHU+CTiaTSUQiEeh0Ouh0OmxtbSGVSjHHUC6X8/UJh8MMIfR4PLDZbKjVagiFQhCJRKzaRJwwj8cDo9HIU8JYLIZwOAyVSgWlUol8Po+XXnqJz2ckEoHVakWhUECxWOR7lfhzWq0WJpMJ4+PjkEqlCIVCWF5e5kWcoJeJRIKx8MSVEE7K6bgrlQrfdyaTCfV6HbFYDGKxGHa7nUVYKCkguWIqRmliCdxuuJCkPj13n4TO/0EcxOOOvcj7FNR03Y07Xq/XEQqFeH190kHNGKGa4KOIexUPI0GNe/nclZUVhEIhdLtdRsLcTQiC1kIAvGdks1mUy2XmANMetL29jXw+zx5p1IyiQlqn03FTb7+gc0pcK6HgFgCGgROfbmJigoXhyuUyxGIxIpEI5wT0+6QbQM1HEtOgoAkj3Zv0vWnqRTYq9FmlUgnZbJZNkynoWKvVKqrV6r7+lMStJvSIRCLB1NQU4vE4stkser0eKpXKnnsDFeblcpnF4tbW1gDcRn/JZDJcvXoV0WiUG8CtVovNyWnfoyY0ye9fvXoVWq0Wx44dQ6vVQjwex9TUFEvfUzOC7F4oRxwYGIDRaGSlyHK5zM/zzvtsp+AVIayEGgvdbveuPDXa9z8p0zLgM1iYEeaUblQSFKAEnjoFlOBSiMVinsZQB4I6GjuLJxKhoCSREmwq/oQFjFBpbmfcT1FGi5FwgVWpVLDZbJzsEp+IsMgEjdJqtexLQqPf/TY+UgUk0Q/q4svlcubxkEz+wMAAqwsSvyaXy7HqYDweh1wu5ySUBClIEpVG9LFYjCWVhR2qSCSCWCyGWq0GuVzO4ho2mw0SiQSbm5uo1WrY3t6GXC6Hz+djvs7169cZSkfTvXg8/lDqSw6HA8PDw7h58yYajQbK5TIkEgkUCgUcDgeOHTuGZrPJKlEAWGCEFj3yeUmlUnA6nTCZTAzZpMJRrVb3ccsajQY3G9RqNaanpxGLxbC0tMReWRKJBDKZjGXuy+UyDAYDS/TS1MdisSCVSuHWrVvweDz8mSTfLpVKeSJJJqXUUctms3x/0CJPEzSyDKAN0WAwIBqNYmNjA+12G0ajEXa7HX6/Hy6XC06nE/l8HiMjI3j55ZfR7Xaxvr6OH/3oR/B6vYhGoyiVSpicnMTw8DAfG2285PcVj8chFosxNzeHyclJNtN84YUXsLW1hYWFBZRKJTgcDl4fSHGRrAmoOHU4HJDL5WzRsL6+jkKhALvdzhNBum/tdjukUilDOmjDJWVYs9mMarWKaDQKjUYDrVYLtVqNoaEhhmJQEa7X69lMnYo8KhxJMOQgDuLnOagZ43A47khmKcRiMcOiaEK+c6LxSZiSURCfdzc+OCFEHoQGQbnG3eJ+5c6pKHoQ6PTa2hrDxgh+L/TPDIfD3KCkZiEVDmq1Gh6Ph/2r9gpqnlPeICzG6N/NZjNLol+7do1FnrRaLUZGRgDcvi7hcJib17Q/A2A/yng8zrBLOkZSau50On3q36urq8wp02g0OHz4MOx2Oy5cuHCHMMb95B+kHEnfVy6XY21tjYUu7haNRmNXDhcAhnaGQiFuGAPA5OQkJiYmoNFoGPpJsH2iM5B/5/j4ODY2NjA6Oorp6WmIRCIMDg6i0WjAbDYzzYUalOQn6na7USqVsLCwcM/nQjjVUigUMBgMqNfrdz2fO2kpn4T4TBVmEomEeSI0kn311VfhdDqxubmJRqMBk8mEaDSKxcVFFpUgkuXQ0BBGR0eh0WiYoEhmdvTgUxJFyjbNZpNhTcIODGFid6qtPWhQd0jYGSoUCmg2mzwdI3iZXC6HUqlk6Fir1UK9XodKpWKHdCq8dju2TqfTt7nJ5XIoFAqeotHnOBwOqFQqhtaR9xb5ZdB0CfgIAlosFtFsNnnSSAk9jfopSJxhcHAQBoOBOTqBQAAqlYoVeejaEIeNxDHC4TAOHz6MfD7P3lKUCO8Xd+tErq2t8SSnXC4zl40gaeVy+Q6hhkqlApvNhlwux4tsu93G1NQUTzupoKWEXq/X90HpyACUiqRkMol0Os1S8sLuEkFP2u02Q0eMRiPK5TKWlpZgNBqhVqvRaDRY+p9w3Pl8HiaTieVo8/l83/nodrsM86PrKpFI4Pf7GTdP70PHoVKpmK9G0Agq9NVqNaxWKxuNb29v47d+67e4e0qbInEIqZAhvLnP52P8uNFoxHe+8x32o6NELxAIIBwOw2KxsNqjWq1mywWCgGYyGSQSCUxMTKDX6yGbzSISibAPDnmm0bSMEotiscjWEmQYXSgUmMdG0zyC8+h0OrZFIKEQMnEncjZwGzrr8/mgUqmQyWSeGE/lIA7i4wi5XI5nn30WIyMjvKcC/YUWPdsmk4kbNUIBiScde6FNdguCgiUSift+ru/19buhdu7HqofWaZKx35kEkwKjSCSC2+1GvV5HtVplKXefz8f8c+Lzki9kIpHgtVwsFjPMb7+ggnQv2kiv10M0GoVer+fmKMn/UyFFeWC1WuX1tlAoIJFIwOFwYHt7mznLjUaDpz35fB4ej4evscfjYf5WrVbDysoKWq0WFAoF54V3m/LCUdwAAQAASURBVObc6zWg600G3486CHYvFotx6NAhhijqdDoYjUb29qIi7Xd+53fYx9XlcvE5KpfL0Gg0/Azk83luMNZqNdy6dQu3bt0CABaGEw4ohCIc+0Wz2ezLyz9t8ZkqzOgGJj8hjUYDk8kEm82Ger0Ot9sNm83GggiUfF67do275sQVo0qcjJMpGaWEMRaL9XWV6IYS4p6FeGEav9JIlRbLe5HkpAeEyKYkH0qLmdls5rEzFQ2kaEMYXIPBAI1Gw74adrudixsakQO7dxtJUEUYhDteWVnpk82nxQz4CMdO/hX0PrSQ0cTp5MmT0Ov1SCQSWFhYQLPZZHl1MrQcHR3F4uIi1tbWGKcsl8sxPj6Oer3Of240Grh58yZkMlnfNLPT6fQpBdF5BT6aXJL0+X7dFaVSiStXrvRBNJVKJTweD8RiMbLZLDQaDTQaDU9Lu90uQwzlcjncbjeSySTW19exvr7O0B2SUCflRxLouHbtGhQKBVsGlMtlbGxsoFgs7rqRCQ2iCUdPUx2CKVLyTwRn8k8hnxkS0CEzZwqhVDIFTesKhQILqiwvLzO81mq1Ynp6ms2iE4kE5HI5m2S3222EQiHk83m8/fbb+I3f+A1+Puv1OiqVCpLJJHdZaTJHSQFd20ajgVOnTrFSFh2nSqWC1+uFXC7vE+kgwY2VlRWMjY1hZGQEIyMjWF5extLSEk8QR0dHUSgUkEwmYTQamRhPhZLJZGIYbjAY7BOQIXNySkqy2SwymQxPQ3u9HjcrKFkiI+1arcbP5+joKJrN5icqCT2Ig3hUQc+ax+PBwMAAvva1r+FP//RPIZFIkE6neY+s1WpYXl5mT8THpb64H/9ov6CJ/L3Y2JBy68cJrxKJRCzCcC9hMBgwPj4Ok8mEzc1NrK6u9iXNhI5Qq9UMWysUCrBarchms1haWkK328X4+DieeeYZuN1uxGIxJJNJLswajQaefvppqNVqvP322/sez72gjDqdDoLBIP/9ww8/RDqdRiQSYSPsYrHYJyCiVqtZKI7oLIcOHcLNmzdRKpXYtoSuFa3lpDKYzWYRj8exsrJyz4X5vcbHWXwQIiqfzzMEl2wMqIG5vb0Ng8HAyontdhuJRAL1ep33ReKyUdOSvgdBjCORCJRKJQYGBhAKhfg1RqMRSqWyzyt2NxoS8fDvNR70eX5c8ZkqzBwOB5u2EkZ2dXUVuVwOCwsL+MVf/EX2JyBpdaFXBKn47DYmHhkZwdraGk8u6OEVqiWSqzlxQ1KpFIDbi6FGo2H+TjweZxlYwnLvdcMQ9plU8qgg83g8MJlMmJ+fx+joKHfGkskk+x+53W4A4IVQLBZDpVJhdXUVa2tr8Hq9bDg4PDwMANja2oJMJuPjoURbuCAqFAou7gg2Wq/XEQwG+0yaAfBUjL5jq9VCLBZDLBZjkRalUgm73Q6LxcJCKuFwGJFIhNWbarUaAoEA+5Kk02kWnzh58iQsFgvDC8g3ZG5uDi+99BLL0F65coWNFIE7F/l74SVQtyocDmN8fBwejweZTAbJZBJ+vx9f+MIXGFefSqVw8eJFniRGIhEMDQ0xpIK4Z81mE5ubmwyfJRGRcDgMtVqNU6dOQSaTYXNzExsbG4xNp/O3UxJWWDgJJ5zESyO1yo2NDSSTSYyNjaFSqUCpVPLUzmAwoFKp3PV8iEQi7rYJgzrbZMRORSvx8ahgpvufhDeOHz+O73//+xgdHYXb7WYp/ffffx8qlYrv9Wg0img0ytLMS0tLLJVM96fL5WICMZ0LSuS63S7S6TRP4ZaXl3mKduvWLbz88suw2+1Qq9XI5/P4zne+g8HBQdTrdSSTyT4fHvKsISEXmhLTlMxisaBUKqFarfKaQIpS7XabuX6pVArb29ss5DM8PAyHw8Hct7t1kw/iID6tQQ04WgeJV+N2u3dtXj5OviX5UAHYVe1tr6B9c7+ijKB7JBJ0v9OPu/Hv7hbUCLrXUCqVPDEjFIswms0mFhYWWHnvxIkTKBQKuHLlCgKBAItYkWQ8FW7ED5fL5QwvbDabsFqtDPV/GCXaned1fX0dIpEIXq+XLWISiQSuX7+O5eVlVCoV/p6BQACrq6s4f/48f992u43JyUksLi4yGoj2aYLYSSQSaDQangp+GqNareLChQtIJpM4dOgQ59EEXyQLJDIJJ/oFNUy8Xi8MBgPm5uaQy+VQKpVgs9lgNptRLpdZtEutVuPFF19kasulS5cAgPMpYTxsYUoQSmrg0vMjbKB+3PGZKsyomOh2u1hbW+NFbHp6GpOTkwiFQrh69SpDhBqNBubn5xEMBvftvFF3m0z1lEol1tfXMTQ0xDcouaZTF4ySf+pQORwOTvRGRkZQLpdx+fLlPslsggrslKUn1TiJRIKZmZk+MQbgtiCB0+lkWBn5XOyEJNJiNzg4yPLhSqUSTz/9NAwGA1QqFUZGRlCpVJBOp7G1tdW3yZD/GL0XTeHohg+Hw9Dr9ZDJZAiHw1wo0WSCFPpImc9isTBPiaTJL1y4gNdffx1ms5n9qVwuFxQKBZLJJM6dO4dGo8EGkjQdog3U7/dDq9UiFovhV3/1V6HT6ZBOpxGPxxGLxR4ZFIymP8Qtkslk7M8yMjICiUSCUCiEjY0NPoedTgdLS0tQqVQYHBxk4Q6CHFIR1Gw2YbPZ8Nxzz/WpEJFM/9LSEoDbxo2dToc3OLrmwiDYj0ajwfb2NnMACE4A3CZ9C2FyKpWKJ1NUzOzVqSQT6J1B01LqeNNGFYvFeGEktSi6j41GY58wyMWLFxEMBlEoFDAzM4PDhw+z1wrdc6To+fLLL6NUKiGVSuF73/se1Go1YrEYrl+/zhsxwTNUKhVarRYKhQIUCgVPBc+cOYPBwUF8/vOfh9vthk6nY3I1FcDUGKHz73a7IZfLkUwmeYpL340K9lOnTkGtVnNh3e12MTk5CYfDgc3NTZ7uCU3FG40GQqEQTzCB29PNT+uGfxAHsV+QLUWlUmH+JYA9+TGP+1jupyCjuNveIhKJcOLECRiNRty6dQuJROK+i6z7ef1eaJz7Mc6lJioJjen1+r5zIxaL8fLLL2NkZAQDAwPIZrP4v//3/8JgMMDtdjMqgASjFhcXsbi4yA3XV199Fe12Gzdv3mSo+b3yp+4nrFYrAoEAPB4PBgcH4XK5WM24Wq1ia2sLLpcLVqu1T7qdvCV3Nh+NRiOOHz8Og8GAW7duYXV1lT28hIIhn7YgagzJ3FMhL5PJYDQaWSGZUGarq6twOBzQaDRYWFjAyMgI/H4/c8i0Wi2azSYSiQTS6TTa7TbS6TRarRbW19extrbWV0QvLi4yXHS32HnvkuokCaHsFt1ud9d980kUZBRP/A4pFAr48z//cywtLeG3f/u3MTo62vfv3/rWt3DmzJm+n7ndbnz961+/78/auYjTIkbJ/9zcHJ5//nkMDAww3vVuybpIJGIPqRdeeAELCwvY3t5m1Z2d8LidsD8h+XdjYwPT09MMhxoeHsbS0hInmaQ0Q7w3mnbQQkgiGSqVij0u/H4/J5nVahVKpZIxveTpQgUC8d22trYwNTWFU6dOMXmVijqVSgW73Y7h4WE4nU7Mzc2xh9fw8DBsNhtKpRJu3LiBlZUVqFQqlEolRCIRDA8PY3R0FKVSCbFYjLtlAJhDRhNGUm4EbsPsgsEg3G43Xn31VWg0GoafEkxSqVTC4XAwZDCVSiEUCrEC5eHDh+F2uxEOhxGNRrnTGo1G8c1vfhMmk6mvgCB1PSGs9H6CuF7dbpdVJsViMdLpNPx+fx/Xj8RYyEslHo9jc3OTFxWbzYbJyUlsbW0x7PT69etcEDz77LNcrFBRBoAhcXS/2O12vv+Iw0TcP5qq5XI5XqTGx8eZZC98BsRiMd+zuz0bBFEsFot37WrSs0H+cgQRJr8VwqQTHDKVSuHdd9/FxsYGfuVXfgVHjx5FLpfr49ORmhR5ppF0cSqVwt/93d/h13/912E0GrG5uYmnn34agUCAJ5PUQKHGBnmgyOVyBAIB2Gw2rKysIJfLYWRkBL1ej6fLbrcbnU4HDoeDn5disYhgMMjm0YlEghVLgdtNHfIyIwEf2pxMJhP8fj+2t7exvr7eNwUguE2324XJZOq7bgdxEI8y1tbW8I1vfAOlUgn/5b/8lzv+/V//6399Rxf71VdfxVtvvfVIj6PT6fBE+ectRCIRjhw5ArVajVAoxEIYjyMIEkr0AFIJlkqlcLlcsNvtWFhYuC+jZVo7CdFCuVWv18P6+jqr0XY6HXi9Xly6dAk/+clP+t6Dkm29Xo/x8XHMzMzA4/HwXh4Ohx9qGrhXOBwOjI2Nwefzsa0J7c9msxlWq5U9OHdL8I8fP46FhYW+AiKfz2NpaQk2m42REVqtlhvXNpvtE3MvE0/wXq93Op3G8vIy2u02bDYb578kzkYwxlqthiNHjmBoaAgAMDExwQIu2WyWefdKpZItZYDbDc18Po9kMsmvp+h0Otje3mZxNxp66HQ6FtyrVCoIh8NotVo4duwYzGYzQqEQrly58ojP3OOLJ1qY/cmf/An+zb/5N3j55Zfxl3/5l/iVX/mVOwqzn/zkJ7hw4QK+9rWv8c9IHedRBSWzw8PDLPNNkLC7BRn8kv/R2NgYw7OEsDgKpVLJOF1hZ4m8im7cuME/GxkZwezsLGq1GqsLCo9JrVYzHGtra4v5SvV6HYcPH+bxLBFNybyQjtvtdkOv17MQCZk85vN5VtKjDkQ2m8XNmzd5AkYypL1ej/lapKxoMpn4s3U6HRdHAJhDR4uw1+uF3W5HPp9n+CKRROn1g4ODbMD4zjvv4OjRo3C5XHC73dBqtVAqlQzjMpvN2NzcZJUfnU7H3CCZTIa3334bX/jCFyCTybC9vY3/9//+H06dOsWwg0OHDvUZW5KIxv1uCDabDV6vlz0yrFYr485/+MMfIhAIwOl04vnnn8cHH3wAm82GCxcu8PV1Op1sA6DVauHxeHDo0CEA4IkrWQ6QvOzVq1f7jkEikfQl88LEXfh9hF5zwuaFEB4nbC7crQC4XzgMTYxlMhlyuRwqlQpu3LiBv/7rv4ZEIsEbb7yB2dlZ9jV59tln8fTTT8NutzNnQ6/XcxFULBbhdDoxMDDAps00eZyamuLpH3EYC4UCTwEJVkzTXyFXUKvVQq/XY3p6GtevX8f58+dhsVhw/PhxDAwMcCdUq9Vie3ublUlnZmaQSqX6eA3A7URkdnaWuXLBYBDT09Oo1+ssSmM0GuF0OplcTsbSxNkjiDEpahK35iAO4lHEV77yFVy4cAHDw8N4//33dy3M/tf/+l947rnncOrUKf6ZzWb7OA9zz6CmTq1Wu0NeW6vV3hPX60GD4N5ClMpeQfYd165de6TH4HA42KaGchWShZ+bm7tDERAAK1TvFrSvF4vFO9AXZIkiDIKVv/nmmxgcHMTm5ia2trb6zgWhFfx+P1QqFarVKgYHB6HRaDA/P49Lly7BYDD0rW0jIyMIBoOPhBOUSCTQ6/Xg8Xjgcrlw4cIFBINBnpz90i/9EsbHxxEKhdBoNHD27FmIRCKMj48jFovh8uXLOHbsGDfnCCVDXqLU0CaY3ictKGe8n1hZWUE0GmWhti984QvQarVMWyEO+ec+9znY7XYeIBAC5OrVq9yMPnHiBHPZ19fX0Wq1mJvo9XphNBrvOG87i1qZTAalUtmndl4ul3HmzBn2/Nwr3G4389YehJNKRvWPMp5oYXbq1CnmeP3lX/7lnq8bHh7Gb/3Wbz324yGxhXsNwr0Dt7sIdHFarRaSyeQdC7HJZILX64Ver0cul2OyJHAbu7tTbCKbzTLnarfCoNVqsfJjs9nkzjtw24BPrVbz62hMDIDHx7RoEK6d/ut0OlhfX4dEImGFyYWFBajVaigUCthsNi4KI5EIMpkMqy2RJ4RQ3U4mk6FUKmF7exsbGxuYn5/nc0VS8DRdou9ARshkJE0QOwC4du0arl+/jl6vhy996UusCgl89JCRmhOdD3poT506hf/xP/4Hfu3Xfg1Hjx7FzMwMQqEQT7JIMXBzcxPxePy+oI3k+ZVMJrnY2dzc5AR8fHwcbrcbCoWCCwbiEZ0+fRovvvgiVlZW8KMf/QgbGxsM8SBi8cbGBqRSKcbGxtBoNJBOp5lDdeXKFfYg2ykRfK/R6XTgdDoRj8e5IN/rPUht81F0MIkwTIqKZJXwxhtvwGQyIRQK4Yc//CGmp6chk8m4aCE/IjIqJ6+3RCKBCxcuALg9uRwYGIDD4QBwGwpx5MgRGAwGzM7OIhKJ4Ic//CEOHz4Mo9GIXC7Htg6lUomVu+g6EdZdrVbj9OnT8Hq9POUSQg7JvJsEVYTQC6lUiuHhYbTbbcRiMe7oHTp0iOXvy+Uyrl27xsbTuVyODeuJEwmACdj0XQ/iIB5l/PZv/zaeeuop/Omf/inef//9PV/38ssv4x//43/8MR7ZvQVBH3ebPj3OogwAK9TtZe67M+534k1qgiKRqM9+RRgE+yO7j1qthlgs1ucdSkEiS6FQaM/PfFAIZzgcZvg1CTc4nU62OXE6nXA6nWi1Wrh06RIuXLiA3/iN38Crr76Kqakp3Lp1C2NjY5BIJFhfX8eNGzfue6JIKs4mk6lvwiUWi/HMM8+w4japJnY6HUgkEobqv/baa8hms1Aqlbh48SKLh/3CL/wCfD4fNBoN/u7v/g7Dw8OwWCwoFouIx+NPBG77qIPseuic1+t1WCwWprlcv36d929COvV6Pbz33nsolUqYmJhgkbz19XUkk0m0Wi2+DoSAokL7qaeeQqfTwY0bN5DNZuFyufogpMDtpku9XmfLgN0ULolqsF+QOvK93k8ajQY+n48HOo+6KAOecGE2MzMD4E6juJ2xtraG3/u934PBYMALL7yA06dPfxyHd9cQiUQMwaILWyqVEI/Hd130pVIpFxg0whU6urfb7b4ELpvN9kmPCz9XqVRypU7FHRnlUhBhNZlMotls8vsIj03IMxNuDCRyYDabEY1GGTJFhRQVCqS0RwpLzWYTPp8PFouFJ2Wk/vid73wHJ06cYKlynU7H32doaIgVmWjjAG4/WEIxCwpSuLx69SrK5TJ7k9y8eRPlchmBQIA7cN1ut8/A+nd/93dht9uh0WhQLpfhdDpZ2p9UoEZHR3H27FnE43EoFArE4/F97wWJRIJ2uw2dTseTi2AwyNDTlZUVnsCk02mcO3cOTqcTLpcLr776KifktVoNr7zyCiYnJ+F0Oln2neCs0WgUS0tL2N7eZpGMixcvotvtIhKJ8LUkKGa9XmeuGqk+drvdXROFbrfLGzkV1nt9b+H99LBBZHc6pmazCblcjnA4DLlcDpfLhWazyZ53pHpKG7pEImFuIYmKnDp1CiMjIwyhSafTOHv2LABgY2MDSqWSzbBPnjyJy5cv89SN7p9Tp071+fJduHABhw8fRqVSwerqKoCPxG9KpRIrthKfkCZna2trzD3TarXQarVIpVK87pFwj9fr5ebHyMgI3G43UqkUUqkUT5lJnIjMPK9evQqv1wuHw3HHRO4gDuJh4+TJk/f0uh/84AdYWlqCz+fDF7/4RZ7kPumg5+luOcbjCOLRPo6QSqW8D98LOoH2VZvNxl6XO42X9wpC8zxIkN3J9773vTuafUNDQ1zoiUQiJJNJzp80Gg3DvlUqFU+izGYzpqen8cwzzyAej2N9fZ2nM2RjtN/0h5rhQpES0hwg0QnyQv3JT34Cu92OX/qlX8KLL77I6opbW1v4yle+gqGhIebFE8IoEAggEongZz/7GW7cuHFfyJFPcux2TknMigr+lZUVFIvFOzhely9fxvr6OtvCkB2T2WzGsWPHMD09DblcjvX1dVSrVczMzLAdULlc5iHBzhgaGkK9Xkc4HO6DkSoUCuZ830tj/UGmro+bNvDEOWZ3C5FIBIfDAaPRiEgkgjfeeAP/8B/+Q/y3//bf9vydnQvi43o4yDGdbpp8Po90On2HdCcFmfLK5XJIpVLuqO+U+RTGbu9DixsZYe/1+mQy+VDSrLTIUbeEzJwpdi7olUoFy8vL2NzcxOzsLHNsKJEWTlkMBgPEYjEXLH6/n42l5XI5qz+S4qTBYGB7AVLwoSkhqSeR7LrP54NarUa9Xmf/OFLX7HQ6+NnPfsbTwFgsBq/Xi0AgAIPBwFNGuVyOU6dOsXn1yMgIstksgsHgHYsU8Yd0Oh0fs1QqRSQS4Q0tkUiwElGn08Hi4iK++tWvwmazcedne3sb586dw6/+6q+ylxgVZQRhUygU8Hg8faIZNLUSTq+E3af7gSnQ/UN+dnvFo5TopcWTTDwtFguy2Sz71hCshYRibty4wcpdwuJqc3OT7R+y2SyuXLmCiYkJFhEZHx/H9vY2SqUSq23ZbDYMDg5ibGwMnU4HQ0NDKJfLyGazCIfDGB4eZjW1VqvF6ooWiwXnz5/HiRMnmHtAzzb5AZIoh9VqhdFoZAXIzc1NTExMIBAIYGFhgSHB4XCYpfYp8SJri0QiweIvVHCT7x5xKR8mgTqIg3jQIH8+q9WKn/70p/hX/+pf4c/+7M/w67/+67u+/uPan4HbDbyfR7VSEoTajfNEDSZh0GtSqRTkcjmcTiesVitCodBdGzpGoxEajabPluBeg/xed+YgR48exdNPPw2NRoNIJIKzZ89ia2uLFaxlMhkymQyKxSIUCgWr4PZ6PZjNZmg0Gk7un3rqKYRCIaysrOw7BaUGm/B8UCwvLzNSo9PpwGQy4fjx4zh58iT/nFBNsViM8xe9Xs8NaCFH3uPxYHV19RNnXPyoQqfTQS6XI5VKQSaTweFw4NSpU1hcXMTW1ha/jvZ28kCjvKHZbDLXLJfLsYUEWQDVajW4XC7WStgt37h16xbbTwm99zQaDQYHB9n3NJfLsQXRo0D40BT+ccYnvjD7+te/Dp/Px3//tV/7Nbz00kv48pe/jM9//vO7/s4f/uEf4t/+23/72I9NLBajVqshn8/z5Gm/IqjX67Ey3v0YTe4WxP/aL3aOZ+/HOJKCuiH0PrRottvtOxY3uVzOSoqXLl2C0WhkoQsqLubn59FsNnljdjgcPKUwGo1sku3z+WAymVCpVFgAghbxfD7PvmiJRAKVSoXVmgKBAEwmE/OzZDIZIpEIEokEtFotC0LQAm+32/Hee+8hEAhwok/njThK5XIZ1WqVO3IET/R4PNBqtWg0GgzjJOGSVCqFer3OapbkOUU4ealUing8Dq1Wy0bRpERF6mPCpIIUnejc1+t1xONxhg3sdt12C+HCtJ/6Fo337xYEhX1YNUsqZovFIpRKJU+6bt26hbW1tb57fXR0FH6/Hzdv3oTBYGCD8Y2NDej1ekxNTbESlFQqRTKZxPnz53Hs2DEcOXIEUqmU+QPvvfcexsbG4HK5cP36dQC34bBut5sNwsmzrdvtolQqQSKRQKFQwOfzMSeEnn2yKCAebKfT4U6w3W7nqXOj0YBOp2OfFtrUE4kET3llMhlkMhnK5TKL/xBsVwgjJTlmj8fTtykexEF8HPH222/37dFf//rX8U//6T/FF7/4RWi12jte/3Htz8DHk0Q9qdgLfrVfcUJCUKurq3dwvfYKQlE888wzbEeTzWZZ0KLVat0BF5NIJHA6nRCJRLvyXkdGRiCXyxGNRhGLxbjRSqFQKOB2u/H666+j0+nge9/7Hv75P//nDO3WaDQwGo3odDpsf0J7UTQa3XNSude+SIgUOkfpdBqrq6vMDSffUbFYjImJCWxvb6NWq/XROMh7k8QsRkZGOD/8eQshTQMAQqEQrFYrWxhZrVaIxWK+d+g+JRVh4pa53W7UajXMzc3h+vXrLJZHRZVer0c2m2UfWhL/oEbBTmVxKpbJ59NsNiOTySAej9/TvX6v8bgVGz/xhZlwwQeAF198ET6fD2fPnt2zMPv93/99/It/8S/478Vikd/nQYqTvYI4UJ1O574SU6ryhVyRBwnhzSHku+016aDXE958r2MWLrj1ev2Om3C3ogy4PZkhA2XifJF6ZKlU6vMeIdPddrsNi8UClUqFWCyGYrEItVqNgYEBaDQaFjSJRCIYGBiATqdDqVSC0+lkwQ4SBiGT6s3NTeYixWIxhhleuXKFi7HR0VHI5XL0ej288cYb7OmWTCZRqVS4IA2Hw4yPp4LyyJEjyGazSCQSMBqNSKVSKBaLrLhEBYFIJIJUKmWYHqlJEpyt0+kgEokglUqxIqbH42HPMPpey8vLkEqlXGwQD65UKkGhUOx6D90LRGXnNSQeFXDvEzGhPPzDBD1H7XabFbAAsB+f0WhkA2itVguxWIzh4WHMz8/DarUycVskEjFMmApxg8EAs9mMdDoNu92Ora0tJBIJ2O12TE1N4dq1a7DZbLzR0u8SZ0yhUMBoNLLSqlQq5W6f0L5Co9GgVqvBarXCZrOhWq3yZI9sIBKJBHPQer0e5HI5TCYT80CJo0k+htS8oc8g9bPdYicG/yAO4uOInXv0V7/6VfzhH/4h5ufn+wRBKPbbnx913A935NMSRAXYq/t/L/mNWq2GwWDo47nvDJFIxIlzNptFKBSCQqHg5JkQQ7t9XrfbRS6X4zxgZ7z33ns84SI/KwqFQgGtVotcLodms4nR0VH88i//MtRqNeRyOYrFInK5HDKZDKLRKAusNBoN5twKCzNSu73btIRoCLVaDYlEAplMBmtra1z8EbROq9VibW0N7733Hl599VVWDlxYWIDP52POvNAKZ6+4l336kxjCPQm4rQDd6/Vw+vRpph6sr69zYXb06FGMjIyw8IdMJkOtVkOr1YJKpYLP50MikejjiVF+B9yevBWLRaRSKZw8eRIGgwGbm5vcOBUGNc+FBfqjLMo+jvjEF2a7BSms7RVCoQhhkOHzbiFMSu81aDpC76nX66HVatlYb78gqfsHCZooEHeIIIcEkSQjYACsUkPETPJCksvlPOnYeU52fq/dvjcZQBL5kr4TTY1IlYgWXOHio1armctFnmvEE5uYmGCoAhE3C4UCgsEgP2hqtZq5b9RdIYsBSk7Jw4t4YxKJBNPT0zCbzTCZTCzUQWITYrGYfVRqtRqKxSKi0ShSqRSq1SoUCgUcDgecTicbDTcaDYaYuVyuPmU/6iRR4q7RaBAIBGA2m9k4Wui1JRaLYbPZEIlEMD4+zkUYvZ44a9T9lUgkDLvcGXK5nAs/EiG5l+TkQTaInbzIBw3hs0fPBYnH6HQ6OJ1OvsYkbU82FxsbG0zIzeVyiMfjLNmcSqXgdDqxvb2NXq8HqVTK6qE6nQ5TU1MwmUzIZrNcUFmtVtRqNZ5qmUwmVkqkjl80GuXCHgCbRHe7XeaSUnMgn8+zeXsul4NSqUQsFmNOIUFn7HY789T2UnOlZ4eKSDpXxDl7HHLSB3EQ9xN3S4b22p8/S3GvxcJu8SgMdUlcay+7E5vNhlwuh0ajwa9JJBIQi8V9UvgDAwOMLtja2uK8g1Age+VBlCORNysJInk8Hs5Ner0ey7CTCm08Hkc8HsfFixfZcJr2+EqlwuupMAipdLfweDwYGRlBu91mA/NUKgWxWAyFQoFWq4V8Po9IJMK2LHS+lEolW89IJBLOIfb7XGoiqtVqpFKpRzYweBJBhZrT6YTdbkc6ne4rsnq9HjfJi8UiHA4HarUaFhYWkEgkuLm9M+j89Xo9xONxeL1eVkAuFAp3eMJRQ4D21k9rfKILs3a7jffffx+vvPIK/+wb3/gGEokEXn/99ft+P8L/7jY1ownWTgPnuwUtAqS4qNFooFarsbGxse8CSqIBDxJarRYulwt6vR7NZhP5fB7ZbJbl9IUTDPq+1HmnRUosFvM0Z7fve7djowJvZ8JP/BdSd9y5MNPPqWBTKBQMDSNPDIPBwKIftMABYJ4YqdlRwUHTpUqlwmIs7XaboQdUfLlcLuYqUQFFuPNoNAq1Wg29Xg+r1Yrt7W04nU4EAgHuTlI3jiTWzWYzcrkcT3toQyEPKyoi6DhIGZJ4Rq1Wi2Xg4/E4crkc9Ho95ufnuViUSqUsDBKNRhkWQYv/bgs/wUbp/Aqx3fvFfsXbXpPmR9GRpmuxcxJLipzEzWy32/D5fKxE1uv1uNtms9mgVCq5sCKIKRV2U1NTiEQibPxOkFCCXVCRZbFYoFarmReh0WgYtmGz2WCxWGA2m6FSqbC6usqQWr/fj2azyfBVkUiETCaDdrsNu90OlUrFxGhKiLrdLk+vc7kcnwObzYZ2u82G1GSPUKlUGMJMx6bVapHNZnk6+DAT+IM4iPsNMp8fHBwEcHv9/8//+T/DYrHgxIkTT/joPgqJRAKtVnvH/vMk417FN3b7vYcJgjPuNSmjhmin00GhUODPMxgMrFxMqBS32w2j0cgiEDvfZ7/vRqgA4La9Aq3jNBEkiwOlUsl+qu+++y5efvllvPjii0gkEiyERN/H7XYjl8thc3MT6XQaSqUSKpWK1RUJ8bBz36T9IBKJ8F5NSoHBYJB56m63Gy6XC9vb2ygUCpifn0c0GkU2m0U+n+e8ifKje7kOJFDzsIUEoYkeR5AU/n7fqVwu49KlS6zWLRQOo6k4WSMQJ79QKHBOc7fimSaiZFtARtQ7o9VqPTS14knHEy3MLly4gD//8z/nZOK//tf/im9/+9t488038eabb0IkEuE//af/hN///d/HoUOHsL29jfPnz+MP//APH0iZca+binDwD3MxaTK1F8zvUQZN20ipkGCJ1DEXTjCIsyUUJKHf32+CeLfYTZWPpMF3W4zlcnmfSAUl1eRDJZfLmdBMePNMJoNEIoFcLscLZ7vdZvNCum9ooyUeWqPR4A6MVCqF3W7ve2+73Q6/388YdeqyhUIhjI+Pw2azcZJuMBggk8lYxISmIQAwOTnJvnfVapV92AhuplKpIJfL2deOfDLK5TISiQQUCgUWFhYwPDyMYDCIw4cPY2RkhKFyKysrLH7SaDR4IttsNu9Q4BSGEHe9V+FNBesnacRP961wskuKmgaDgaGi58+fx/T0NN9ver0eBoMBOp2Oi3T6/l6vl0256R4jXyNawBOJBAwGA+x2O/++QqHgjZqEetxuN8xmMz9vrVYLVqsV1WoVxWIRbrebi0wyvabCkSbZVHwBYHNMAFxIi8ViWCwWnnQKGygA+N4rFAo8QSNI5c8rl+Ygnlz82Z/9Ga5cuYLFxUW02222rfmX//JfIhAIoNvt4pd/+Zdht9vh8Xhw6dIl5PN5fOtb34JKpXrCR/9RCKcmn4TJhLBB+iQ++25Be6vwXHk8Hvj9flQqFYaokRptMplkZAkpP+4FrdbpdKhWq315AnGwo9EoDAYDvF4vF1TUlKNmLKEjiEdutVoZkklrda1WQ6FQgNPphM/ng1gsRigUQqlU2lNQjaZxYrEYMpkMUqmUG2KdTgdutxsDAwMwGAywWq0IBoPY2trC1tYW6vX6viJb1BzfmRvRXr5fAbszf9srHudeLnxvYUNfIpHwnknwxWQy2afOaLfbodVqYTabWWiN1Bk7nQ5kMtk956LxeJxtKEjJ/FGGMBd9kuiTJ1qYGQwGTExMALjtnk5htVoB3L4hv//972Nubg7Xrl2DyWTCN7/5Tbhcrof63N1uAOKJSSSSXR+gu0WpVEKr1YJCoXjsCVKlUuGEkQqBcrnMx7ybsuNuk62H2aDutfhUKpXodDp9XSr63Ha7zXCHarWKSqXCCj3U3crn81CpVAwX0Gq1sFqtqFQqzGcj7hpB0NLpNMrlMmq1GlQqFZxOJyqVCtbW1lhBz2q1ctGl1+uh0Wh4gej1erDb7XzcyWQS4XAYPp8PtVoN29vbLPyhUql4qhKPx5HJZKDX63lhV6vVDMPIZDIQiUSM0adzQTBUUnScnJzkhYs2HBKVoAXwXuNurxWK0AjFQKRSaR9s5XEmM8RX2OueIrGLXq/HBQ/B+GhKKZFI+M90LQqFAqtt0nTK6XSyZQDdK6urqxgYGODrSUU/wVlpGpVMJhl2QtMsl8vFnMRwOAyZTMYqXnq9HsBt7qXL5YJCoYBOp2NhDzKhLpVKfOw0sVer1dBqtSgWi1y8EQmdno9arcaJHd0vB3EQjzKI8zoxMYEvf/nL/HMquiYmJnD58mWcOXMGm5ub+MpXvoJnn312T5j1k4put/uJnCZ/EopEWj/v1lQuFossaV4ul3n/FjY3TSYTfD4f2u02c6eFQfx1+h36PPKPBMDqzEJYeTabZTn7arXKEHOVSgWlUonFxUW28qHJisVigUQi4dcRtI5QJEL+V7vdZmEnYRFEBRUhYOg7kNBFIpF46AT+fs2d94rHuf7vx0OUy+XM7yehKzp/brcbg4ODXKiTDU8+n8fKygoKhQL7DDqdTt6T9yq48vk8XwvK1/cqWonuIRSb2y+o4CYq0G5exB9XPNHCbGJigguz/WJ2dhazs7OP7TiED6iQI3Q/k69arYZarcYP7+OcmrXbbe7i3G1hp4S11Wo9lpuMFi6abuwsaKnQIf8l4e/sHDmTsS4VH1QsECfL6/VCqVSiWCyi0WhAq9WyUuJOLykhdJE6amKxGCaTiYm5jUaDDb/b7Ta8Xi8X5iQRTP5Z3W4XVquVE36n0wmNRgORSMR+aaFQCO+99x58Ph86nQ4SiQRDaFqtFjQaDXf5crkcNBoNnnrqKUilUhgMBk62pVIpVCoVRkdHWWSCCmkqYMmT7EE3BXo/ofmx8J6nxOvj6BrtbBwIGwxklB6JRFgxU6fTsReZ1+uF2+2GRqNBu93mIpo6a41GAxKJBDqdDuVyGa1Wi4se4lqYTCZ0Oh1Eo1GGR+RyORSLRTY8J58dpVLJsrska+/z+VCv13H9+nWe6Ho8HvYhS6fTzI8jGC2ZQVO3lJoCBIHU6/UMrW40Gmi32zwhp+dDKDt+UJQdxOOI1157Da+99tq+r5FKpXj55Zc/piP6dMS9ctapsfIkCzSayt8NfrexsXEHpF247hDSoVQqccNyp1w8QRTpc4gPTQ1WKvhojydvUFJqTiaTbEdCayShR1wuF3Q6HWKxGNRqNQKBABdoVDg0Gg0kk8k9zzeJktHn0+u63S7S6TTW1tYgk8nQarXw/7H35kGWnld5+HP3fd/33rfpnlUz0kgajWTJkmUbYyBgCBTGATvEZSAxIYkJJD9XQagKEJakWEJRApLgijHYqGxHIFmy9mWkmelZel/vvu/7+vujc46+vtPd0zPTksZxP1Uua2a6b9/+7ve973vOeZZIJLLv/fFOPt+7zRxEeF9TcU5TNLLOF4vFyOVysFqtkEqlSKVSCIfDzH4pl8scJyASieByuWC321EoFJDNZiGRSDhbtl6vb3Ofpulpu93meBraD4XXmSQs+71+dE8Ji/IPCne1xuyDwJ0eROmQRQtdq9U60CKNbjYKl9zNFYkglUo5AHs/vOebgQotKl6lUilTx/r1eSKRaFuXkkS69H6E71048SDzECo8i8UibDYbut0u0wYcDgdcLhdKpRKazSaHWJOxiU6ng8vl4kN3u92Gw+FAu92G2WzG2toaC3UJdNgGwE6SnU4HNpuNbfgtFgu0Wi2WlpbgcDgwNTUFlUrFVMPZ2VnO26IMMgBs5EE0TIvFguPHj8NoNLJomYK0pVIprFYrdzEp38rhcMBut6PVajE3e7/297tB+HkJ/5s2n7sBFOQ+Pj6ORqPB7p1SqZQ1ia1WC8lkEuvr6yxSp0I6GAwyNabdbsNqtcJsNjO9gjR+QkdOKnype0uhpFQMptNpnpC2Wi3uGNN01Gw288/J5XKIRCJQKpXodrtQqVSQyWRMuaGislKpcOB8JpNhSg0VkM1mE6VSaUejlEMc4hB3D2jtv9l6fDcUZkTN3s972I0WT1KOYrGIlZUVDl/uL8y63S5rimQyGex2O7xeL6xWKxqNBlPhKGi6Xq9zdiS5GUulUjYvIcbJuXPn4HA42NFRq9WiVCohEAjA7/dDJpPB7/fD5/PhK1/5CrvvUt5prVaDQqGA1+uFVqvFxsbGNot10t1RHAmt+QTh3vteOS1SA/VucxklGqdYLIbZbMbMzAy0Wi2uXbvGWjOasqbTaZYDUNOUNNbUaGy1WtDpdJienobFYkEqlUIul2MmGklayDSGmqz993Cn0+FGPXDzbNZsNssymg96Xz0szA4YMpkMTqeThZiUZ3VQIDof8XqFTmw7db3oBr6dQ7vQvEL48wFwUUZ6MeHkRfj9wkMkjbGp6BFCLpfDaDTyQ9ZoNNgSHtg6gCYSCeTzedxzzz0Qi8VIJpOIxWIcNEnTJDJgqdfr7JpIep+jR4/C4XBw1li5XEYkEuH32u12mX7Z6/XgcDgwODjILphEnZDL5fjud7+LgYEB3ihqtRqOHz+OQqEAlUqF4eFh1h+Rqx91ZSwWCyqVClvqBoNBWCwWpl0Iw7nlcjkKhQK7BNKkrL8je5ALNhXfHzTEYjH8fj9GR0dhNpuhUCgwMzODeDyOd955hxf0fD7PYZSBQADVapWpCGq1mq3yC4UCRkZGUK1WYbfbuetKFvuk62q1WkilUgiFQhwCTjl75CQGgC2kqfgntFqtbdOsZDLJz6vH44HFYkG324Xf70elUmH6B5n6kNmL0OmRGhp3SkM+xCEO8d6i/wAobLII2Su362p7kIf0O11PaOoFbDEAyNX5Zu+N8h5JU02NKqVSyU2sdruNdDqNfD6PxcVFOJ1OdpgGtq7zyMgIbDbbNgmBRCLB2toaUqkU7HY7H/pJY5xMJmEwGODxeJBKpRCJRHiPp8YuadsIdNCn/Zl+d6Ltkm6OpjwHzVC62woyISiWxu/389TRYDBgfn5+29cZjUZ21O71euwdQIwzei2VSrUtYmloaAjXr1/nAplAzeydQAwjANyoDYVCu/4OwoJsN03g+4XDwuz/giY1wmmNEPtdCM1mM+tVhHbYB2UKQnkdws65MHCRwpppoe3XnRFdimiC9G87LczkbCcsLNvtNnPE6c87dReEJgeEaDTK/9ZfyNF1ovdO0yuiIFCxY7fbWT9WrVZhNpvh8/k4iJcEvrVajfVoKpUKBoMBkUgE6XQaHo8HHo8HNpsN0WgUc3NzzGEXi8U4ceIE7rvvPgwODvI0I5/Ps86L6HD33XcflEol8vk8VldXsbm5ybonhUKBYrGIdDrNPHSVSoVerwetVotyuYxYLIZWq8UFA9E1VSoVkskklpaW4PV6MTw8jGQyyeLk/ussvK9upVu31+JDXdQPGsJChDZsEpnfe++9bOqSz+eh1+uh1+uhUql4gzx58iRrzoaHh6FQKBCNRnHx4kU89thjkMvlqFQq7MxZq9Ugl8u3NT5isRgMBgMAsE7BZDIBePdwIZPJEI/HmaZDGkmaPDYaDUilUshkMg4hLZVK3BnudDpwuVyQy+VMiXY6nayNMRqNsFqtTK09NPo4xCHuXgjNI4jlYrPZIJFIbshrup1zARUfB9n0vV3QxIT29Xa7jbW1tT2/RyKRoFQq4fr160wVb7VasNlsuO+++zA0NMRfQ1miKysrKBaLEIvF2NzcxCc+8QnMzMxApVJxHhrZ2jebTZjNZng8Hg46XllZQSaTYVoc2bSTs26pVMLc3Bz7BPSvsWQKNTo6CqPRiFdffRU+nw8zMzO8f6RSKQDbJR7fD1Cr1RgbG8ORI0egUCj43NMPOsNQ1i0ZiAg/N2JJzc/Pw+v1Ynx8HAqFAuvr67etEyVG1X5B+/8H5d56WJj9XxgMBjSbTdRqNdjtduTz+W1dn/0+YPV6nTOUstks651u5tqzX5TLZZhMJgwODsJkMqFQKCASieDUqVOcd7W6unoDxZE6TBSWqFKpoFarIZVK2f59p5/Vf2g3mUzcxehPXSeQILR/tEwLFYXqUtZZvV5njY1EIoFer+ccqHK5jHw+zyG90WiUux4DAwMYHBxkilqr1WIKmU6nYyt+ooZR/ptCoeD3R5MLYEtYOjMzg5mZGaZAFotFxONxzM7OYmNjAwqFAmq1Gp/5zGdw+vRp1Go1zM7OIhaLwW63I5lM4o033oDL5UK1WkUul4NcLofX64VCoeACS2jikUgkOP9udnaWrfCnpqZ47C+RSLggFdJf+sM0TSYT0un0Te8jKtCFxT3w7n2+0/3wQaDX62FxcZELTqfTyQJyALyI6/V67nh2Oh2YzWacPn0aCoUC+XweqVQK8/PzGB0dhdfrhdfrRTQaxYULF3gzIBEx3YPkXEk6QbKjJ2plNpuFx+PBxMQEZDIZNjc3OfCy1WqhWq1yMU7/0+v16HQ6SKfTWF1dhVar5bD0brfLgaYmk4n1bQA44FyhUMBkMh0WZoc4xAHgvaKdUSbX0tIS9Ho9HA4HGo0GgsHgLR0Qd8PdODFXKpWsH7pZsDK52RLzg7Szwkwy+m+z2cyMF6K0Ud5YNBqFWCxGOp1GOp2GRCJBMBiE1WrFxz/+cVgsFpTLZUSjUXzzm9/E8ePHmV1D77der2N6epo/o5WVFZTL5W1nPtKqaTQaNg8jqjrR22ld7//eg8LdXOiVSiUsLi7C7/dzg303V06FQoFHHnkEVquVp2IAsLm5idnZWTaGETpwk/HL7RZm7XabzzS7Rf8I8UHvr4eF2f8FjVNVKhU79oXDYS4u9js9oGwLkUgEt9uNgYEBDiK+XZCGibKLKDw5lUphYGAA58+f564RZWl4PB6k02keD5MVeDKZRK1WY73UXr/bThsWWdJT12+nr6F8jp3+XiQSodFoMKWPTBXIYr5Wq3Egr7Do2KmDVSwW2XaeMk9KpRJbo9NhuFAooFQq4YknnsDg4CBTxZ566in8wi/8ArxeL2eoUcFGE8lOp8PF1MrKCsxmM375l38ZHo+HqW8ikQjlchnPPfcc7rvvPkxNTUEul0Ov17PBhk6nY4oDTeno91EqlSiXyzh58iREIhHW1tZQKpXw8ssvw+FwMC22WCwyTZM42/3XeT9FWf9nS4UH6QQ/aH71Tpifn8fc3Bw++tGPwmg0olqtsqPT/Pw83G43Z9jZbDYYjUa+B+RyOU6ePIm1tTV861vfgsFgYP76hz/8YabEFovFbTa/ZNSRyWRYWyASieB0OrnJsry8zNl4lUoFfr8fKpUK4XAYm5ub3AARmr6USiWYTCYMDw/DbDZzGCs1hsh+OpFI8HuhyASDwbCjKPlu3rQPcYi7ETKZDF6v95ZMHPYL2jeArX0vm80il8txtuFBvP5+C0qNRsNrzJ2uEbQ/7vQ6QjrazdBqtZiCSM1Lt9sNAGxB73K5sLy8jB/90R/F5OQkzpw5g2vXrqHVaiGbzeLNN9/E2NgYRCIRLl26hM3NTbTbbZw/fx4PP/wwnE4nSwLEYjFGR0dhs9l4fT5z5gwUCgU0Gg0kEgk0Gg035EjiQKBmNBl4LS8v87lgfn4eQ0ND/DXvxTosl8vZxv1umJLuhFwuh69+9as3/Tq/38/5cMQ4oeZ1tVrFwsICAHB2XbfbxeXLlw/sfdrt9huYR3cbDguz/wvKKVIqlYjFYkyNoonSrcJqtcJisfAY/U4qcFrsiOYUDochEongcDjgdrvZEjQWiyGVSuH8+fNIJpPo9XoIh8PQarUIBAIQi8XciSDBZaFQuKUuBMUC5PN5dLtd6PX6G4Swu4HckQqFAjY2NvZcwEjU2w+z2cw0kGw2y/9tNBrhdDrhcrkQi8WwvLzM10ulUuHMmTPodDoIh8PY2NjAqVOn8J//839mG92rV69iYmIC165dw7Vr1+BwOBAIBDgs+OjRozh27BgajQauXbsGlUoFrVaLWq3GVLRPfepTEIlEqNfrCIfDuHjxIjKZDFvBEq2iXq9Do9EgnU6zOx+wtSENDAygWCzi/vvvh8vlglgsRj6fx/LyMuvLgIN1DKJMHTJg6TcU6dcK3ilup4igbubCwgIGBwfRaDTwzjvvMIVmcXERCwsL0Gq1GBkZwcTEBBebuVwO0WgUGxsbTI199dVX8fDDD7OrVywW23a/UcENbHeh6vV62zqBIpEIs7OzALYKXJfLxaJ2agC0222e5gFb06/NzU04nU6mVxaLRdaZUVwI5fHVajWebhYKBY5gEB7MbDYbKpXKXWkJfohD3I1otVoIhULviVvx8vLygb/m7YL20oMoGA6qgM1msyiVSnA4HMhmswgEAnA6nbxGJhIJ3HPPPfjoRz/KESVXrlzB9PQ0ZmdnEQwGcerUKXi9Xta6k/Nup9PB+vo6x9XQ3w0NDcFmsyEcDnNze2FhgffydrvNzU4h1RQA7yP5fJ6dnk+cOIGNjQ1kMhlcuXLlQK7LbujPp/2gIZPJdnThJlCkQKfTueFakh681WohEAjwnkyUf2KYWa1WeL1eZkL1v877DXLrpliH9/Rn9b4P2qzFYpE1InvBaDQyBcnhcKDVam3LEfqgQE5twm6MXq+Hz+eD3W5nOt358+ehVqsRjUbxxhtvbHuN/dr37hd6vR5yuZxztg4SRGkUbgJyuRxDQ0PQarVIpVI8wRgZGeFsqH7LfKlUytkmWq0WFosFwNYDdvbsWchkMvzFX/wFfv7nfx4OhwPJZBLf/va3IZFIsLy8jFAohKGhIZw+fRoWiwWNRgPhcBiXLl3Cz//8z8Pj8aDT6eDChQtMncxms0zVVKvVrE+j7CuiRq6vr2NgYAAWiwWhUAjRaBQTExOYnp5Gp9NhFz8AuHbtGi9K5Fx50Nec6Kf7yft4L0GmMmQAQzAajcjn8xgYGMDAwAAX3bSgU1eUsuny+TwSiQR0Oh1GR0e5GKNpVz6fZzqj2WyGxWJBrVbjQkitVkOn07ET4k7WzwDw2GOP8UYSj8d54yadIW1gjUYD6XQa4XCY83m0Wi3C4TBPQimb7VawEy2DwqcPcYjvBex3f/4gIHQ0FoL0xvttuPr9fng8HtTrdYRCoX0zG75fQNfZZrNhaGgIVqsVk5OTUKvVmJ+fx9mzZ2Gz2RAKhfCP//iPPAUUuk2r1WreB4aHhzExMcHsiuXlZTSbTRiNRkQiEWg0GtjtdsjlckilUgSDQXznO9/BysrKtn2nn+JPearfz/EkpJ/bLT9MJBLBbDbjiSeeQKVSwaVLlxAMBm/4Orvdzs1EkpkYjUaIRKIbTEP6cSdRQbcD+txlMtmBUJFvtkd/XxVm++GWUjYVCfApS+h2DsLEjyUtE3UQUqnUvjU8FCorLBBJY0MWtadPn4Zer0ez2cTCwgIWFxcBbPHciRp3kJx0Cu6jTtytcPTpgL0fCD8vooZSOGQ+n0cmk4FGo+HCjG5ljUazzVY3k8nAbDZjcnISgUCAtWdGoxEOhwNKpRKpVAqvvPIKxsfHodVqkc1m8fLLL+PKlSvQaDQYGBiAQqHA6uoqfuRHfoR/1kMPPcSFczKZxMWLF7lQ8/l8MBgMHA1AB/NIJMJTF5FIBJ/PB6PRiCtXruDJJ5/kXDQyenj99dc5S+3/NVARtl9qjtlsxsjICAeCy2QyNJtNFAoFzoMjITEV8ESDPXPmDOsU1tbWUCgUIBaLodfroVarkclkeFNWKBSsR0yn09sOYBKJBNPT04jH4xgfH4fT6USj0UAoFML8/Dza7TZsNhscDgdMJhPEYjE7fxEtOZPJ8MRueXkZS0tLN/yufr8fcrkc2WyW8872M8E8LMwO8b2Eu7kwu1O43W4UCgVotVpMTk7CaDRiZWUF165d+6Df2l0HrVaLsbExHD16lIsmr9fLe2gymcSrr76KRx55BNFoFC+99BKazSY2Nja4IRcOhzE2NoZ77rkHwNZZ4Ny5c2xkFgqFcPHiRbz++uuwWq04cuQISzxmZ2exsLDARZdYLIZarb5l44jvd4jFYtjtdtZHi0SiPd0QCTqdDm63G51OBysrKwfyXihmiJhadwuF8bAww7sLv1QqhdfrBQC21haCLFqJQ63RaLZZY98qqLCYnJyE3++HVCrF2toaU6rK5fIdURy1Wi0GBgbgdDqRz+fxzjvvsHnBkSNH0Ol0MDc3t+0gRzxlOuRrtVooFApkMpltry10SjpI7JUlIZFIeMKw1zXfSbBN2jetVgu5XM52tpTgbjabYTQa8dhjj8FqtXLIMHVAfuM3fgOf/exn4fP5AGxp2jY3N5HNZrcFYFLnMxaLYXh4mIvfQqGAtbU1fPvb30az2YRWq8Xy8jJTJaj4E4lEGBsbQyAQQKfTwfLyMoaGhhAIBFAsFvHXf/3X+Lmf+znodDpks1nOWwsGg/wwq9VqNqf5fsROlA6n04mJiQl4vV7I5XIUi0VsbGygXC7DbDazxlOn07GRh0gkQqlUYlpuv9shmYA4nU4A4IX91KlT8Pl8TFN+66230Gw2IZPJMDY2BoVCgbW1NZhMJkxMTECv16NYLCIcDvNzODc3B41GwxbOO4EoNpVKZZsekcTr/Q0OerYOC7NDfC/hgy7M7HY7bDYber0elpaWDoRZQsZaOp0Oer2eozvI/KdSqdw1Bku3ArPZDGDrM7vd60RB0TuxM7xeL6ampuB0OjE4OAitVsvr9P/4H/8DX/jCF9hka2lpCTKZDKurqyw9OXHiBEZGRphNMT4+Dr/fj263i0KhgJWVFTz11FPQ6XS4cuUKN29LpRJOnz6NbreL69ev3zZdzWQyoVgs3nWh0B8UFArFjp+zXC5HIBDg2KJ6vc6RMBQRNDw8zGc94QSN/k6v16NSqdz0WkskEng8nh2ndh8UbrZHf19pzMgYoNfr7ViY9R9071Sv0e124fV6eTxLxgoKhYI5zuTAls1mb6kApCKEbElJywRs6U1KpRI2Nzd5EaNstXA4vO3nkIOSVCrl7AhgS1dDHY+DxF4UAJqeiEQi6HQ6tFqtHYuPnR5EOrymUinOpiJnSqvVikwmg2w2i+985zuoVqtwOp2YnJyEQqHAN77xDXzsYx9Dt9vF4uIiO0JRLko2m4VYLOYAS8ose+uttzjXpNPpoNFo4OTJk4hEIvja174Gi8WCc+fOwWKxsAi5UChwkKVcLofNZsObb74JhUIBvV6Pe+65B8899xwn2efzeQwNDWFmZgb5fB6RSGTbZy3Ebovg3YzdqEJ7gZoPgUCAO3NLS0uIRCJcuOZyOSQSCWg0GiwsLMBoNMLv96PRaOC1117jLMBMJnNDpIRcLofP54Pf7wewZfG7trYGt9uNkZERXLp0CVarFU6nE2q1mp2/yOil2+3CbrcjEomg0+lgeHgYUqkURqMR5XIZEokEDzzwAHK5HObm5nDfffeh2WzyvUdTsXq9fgOPnxyrdmqY/L84UT3EId5rpFIppNNp2Gy2A3uGqtUqxsbGUC6XEY/HUalU0Gw2USwWObje5XJhYWFhX0yeuwX5fJ4phLeLRCKxa8OXzI9o3QbATszj4+NYXV1FMBhEo9FAtVqFTCaD0WjE22+/jQceeAAmk4mNwHK5HIrFIjKZDDN8Wq0Wpqam0Gg0cPbsWXzjG9/AE088AbvdDrFYjGq1ikajgaWlpV0LZ7lcjsHBQayurt5QnL4f+qO7HZQZtlvxDWxNkh0OxzaNJwVHi8ViKBQKjh7qv1doP9zPFFMqlcLlckGn0+35dbTXk5Thg8b31cSMEuEzmQy63S4MBsN7Ligkql273eaHnuzPpVIp0/Oy2ewtOTeSDkuYj0YTvlartc1gQSaTse16NpvlQqJWq3F4LU0LhRMDcv97vyDkc+9mECGTyaDT6TgUmPJiiOZVKBSYkiaXy2G1WtlCPpPJYGJiAnK5HKFQCMViEffeey/TzorFIp5//nlkMhncd999uOeee6BSqbCysoJIJIJz586h1+shnU6zo5BarcYzzzyDn/qpn4LZbObg66997WsYHR3F9PQ0rFYrJBIJm56k02lMTk5Cp9MhmUziq1/9Ks6cOcPTsUceeQSDg4NQKBTI5XLY3NzEwsICMpkM28JTbgsV/LcLug/JgXKnf+90OgeuUQS2NrhbcRcDtpoONMXWarXcaacIAr/fD7PZjEqlwlNGhULB1FYq3kUiESYnJ+FwOCCVStkNtNVqQaPRwO12w2q1suNmPB7H6uoq33Nra2s4cuQIRCIRcrkc0un0Ng1op9NBt9vlaAbazMm4g0xlgsEgZmdn4fP5sLGxwREIFPOw04HtZpmKhxOzQ3wv4YOemBEOukCi/aFSqdzQYKQoDuGaSpP1/YByzD6IRhyZKu22Pu2EkZERhEKhm75fymQlDdlDDz0Ej8eDZrMJsViMUCiESCTCzs5LS0s4cuQIG4mQgUi9XkelUuHzwfXr1/HII49Aq9UiGAzi61//OlqtFh588EE4nU4EAgHI5XLOOSuXyxCJRBCJRIjH41haWoJGo+EszYGBAcTj8ffc9ON7FTd7lvR6PdrtNscu9YOak6R7388ZYad9kbRhwlD3nSCXy7kJqlar4XA4ePBB+bsHicOJmQDVapWDjIGDy2rqvwmFlrLVapUt94XdAHLvC4VCeyaMk4kAWZlT8F2j0eBOglQqZQofuTEKYTKZeDKgUqnYjEAYQr2T60+tVuMblEJ832vc7NBpt9u5A0Jaomw2y10xKsBpqqDVauFwOOD3+1mw2mg0oNVqYTKZYLfbodFoAGy5dJFFerFYRDQahUqlQjQaxdraGr9GvV6H1+uFVqtFq9XCI488wgYfVDS4XC4uFGlE32w2OSKAArT1ej20Wi08Hg8CgQDroSj/RqlUwuVycWA5Ue/oXrrdokytVkOtVnNhtNv9JwwSP2jsZLtMmyEFoJtMJmi1WhSLRf696bqEQiG0Wi2ekpFhSC6XQ7vdZp1epVLhmIRWqwW32435+XnU63W+72k6WSqVYDabOVi8Wq1yUZ/P52EwGGA0GjE1NYVarYa1tTUYjUa2y/d6vfz+KpUKYrEYO15evXoVYrEYUqkU09PTnKfW6XSwtLTEzyM1V5RKJf9O/c6QhzjEIQ4Wwj1coVDs2qzaDSdOnODmG+mvd7NPp9xEIW7F/bndbm+zmC+Xy++bDoryGfc6fItEIqjVagwODrJkQyqV3rQw6/V6zH4xGo0wmUycRfnyyy9zTlm32+UzQDwe54Bnm80Gj8cDq9XKTrj1eh1utxuzs7NQqVS4evUqM4M2NzdhMBjYrZoyYK1WKxwOB2QyGZ8ziFpZLBY5CoUYSYfYjpsV7ORADGzR8+12OwwGA/L5PMLhMDtFk7HLfkBfp1Ao2GCr2WxyjMJeEJ6jKO6JDNF8Ph+/p/cL31eFWf/N0ul0DqRLJvx+ygcj+3qhRk2lUvFUq1QqcRddp9Oh0+kgn89jbW1t22trNBp4PB7IZDJ0Oh0OYq5UKsjn80yN7Ha7uwYb9tMkKdSRIJVKIZPJePEcGhqC2Wxm58V4PP6+8HN7vR5PwqjjBYADfWn6QRTHdruN5eVl/gzFYjGMRiMAIJlMolAosI0uddIymQwuXryIEydOwO12syiUDtAjIyMYHh6GUqlENptFPB5HMplEvV7H888/D7vdjmPHjsFut29LhqdcsmQyCYvFguHhYaY+0mSSpm3BYBAnTpyAwWCAy+XCz/zMz2BzcxODg4Ps/phMJnm6ZjQa2fY3nU4jmUxyMXW7iwV1pIiWQtrD9xpEUdiNDiP8e3I+o6kVAObvkwU9RVKUy2WUSiXkcjkoFAqOuaBrVK/XodfruYvt9/sRDoc59y6dTvNnlEgkkEqlIBaLeXpG2kKit9IEWiQSIRaLsUi91WohHA7DYrHAaDTC7XazvmRiYoKF7IVCAc8//zxGR0ehUqkwODjIEzuKsqCp791kk3yIQ/y/DoVCwZNucmbNZrNQq9UwGo2IxWI7nh0ikQhnJwJbutdsNruvKZHBYIDBYGC34ZtBq9WyK3O320WtVsPq6ur7QqWjn7fX3iOVSjEwMACv14tsNovr16/vmyJGe0C1WsWFCxe46SyTybbR4/L5PCQSCa+b1NRzuVywWCwwGAys50ulUkwbrVarcLlcmJqagt1u5zW7XC4jkUhAq9Uil8vBYDDA4/HAZrPB7/cjkUhgbGwMSqUS4+Pj6HQ6sNvt+Na3voWHHnoIpVIJV69efV/20bsdN5NV9E+1KFaGziTA3uHvpL222WzczKZn0WAwYGxsDBaLhSU5tzLZrNfrSCaT0Ov1sFqtHMlzWJi9j+gvyu60UKtUKlAoFKhUKjc8oFREORwOTE1NQalUQiqVcg6YRCKB2WxmSlylUmGqodFohEwm44BBsVjMBheNRoPzxYRQKBTcccpmsyiXy1wkCEG0BNLu2O12DA4Owm63Q6FQwOPxwGAwIB6Ps5nGe7X4UFxBt9vliU6j0eBFPZPJ8KGZ3JI8Hg8HAZNLpFQqhd/vR6FQYP2Ry+XCxsYGB2E+99xzbE9fLpd58kF29OTc53K5mOZJXwO8O4HVaDQIBAIol8sIh8OcMUYmJolEArVaDS6XiwOIAWzbwMni3+fzsctkMBjE4uIiT3ksFgvGx8dZPH0rzkVEWaT/1mg07E7ZarV4wxJCJpPdkvnLfhYvIfV2r9cht0UypaH7TfhZORwODmgmw49kMsmWyZT1R5EJmUwGiUQCJpMJlUoFarUaLpcLUqkUkUiEdZjVapULbr1ezw0KuoZCV9JGo4GNjQ0Eg0GMjo5Cp9MxFbdSqXBoNd1TVquVA6nJoXF9fR0jIyP853a7DbVajXg8zkXsIQ5xiPcHgUCA8wgpmDkejyOdTqNWq0Emk0EkEnEGU7FYZBq6SqXi51UsFm+LctkNNEnaLy1Ro9FgcHAQ09PTzMyo1+vQ6XR44YUXdvz6arV6oOvIzc5I3W4X6XQa2WyWXa5v9VzVaDSwuLjIjWM6J7lcLkxMTKBcLuPy5cvcdCatMmn5qYGbTCaxvLzMzT2tVotCocANa3Lspiau2WzG8vIy1Go1RkZGIJPJoNfrkclkmJ1EkzpqWFO27EFdY7Vava/il8wy7jbsdb+bTCYA4GKs0Wgws0UmkzGrbK/fi3L5yISGivJer4dSqYT5+XnWf0ejUR5+0Blnr+tLhj2tVot14u+3BvT7vjDrB31QFNpMVbxEImE64l6g7lp/SC/puCgI2W63o91uY21tjcNlm80mTCYTbDYbNBoNKpUKlpaWWOxKnRyadpBQlt4XdfM7nQ40Gg0sFgvUajWy2SzfvP0dCIlEArFYzA9St9tFpVLhIk0qlXKgolgshtfr5ekE6bTI4Y4O+DqdDiKRiPV7/W6LVPwSh5j4vzQto+JMrVbDZDJtW4CIX26z2digo1QqcVeNxMlOp5OLXKKU5PN5yGQyTE9PsxOl8KFeWVnhQsVgMMBqtcLn88FkMrF7UDabxSuvvIKpqSno9XrE43G2cCd6IW1CtVqND/TEj2+327Db7bwYEbVULBZjfX0dWq0Wer0e1WoVi4uLcLlcUKlUvFjQZPNWBKpkK6/X67dNyOh+qFarfF9IpVKm2dzqYrSfTWk/1CCZTAaLxYJCoXBDsWgymSCTybggJodFo9HI9wU9S71ejzdaqVTKTmipVIr1aU6nk2ml5IIIbC381WoVuVwOvV6P6cdksT80NMTRDR6PB/l8HqFQCGNjY3A6nTyxI1pEsVjkSWi5XObpKBWe6+vrcLlcALaeFyrw8vn8vpynDnGIQxwMKB6n1+shk8nwOkQNPdrv8vn8tqah8OAHgPe/mz27xAAQrsF7nTNof6xUKrzHUBOXIJRT7EQZ74dIJOLYkoNAp9Ph/ZX2lFtFr9dDt9vF1NQUVCoV1tfXsbm5yVovhUKBkydPYmVlBfl8nt97NBqFXC7H5OQkgK31dGJiAj6fj9dzarRevXoVPp8PpVIJer2eG6e1Wg3pdJqp7WKxGL1eD9euXYPT6WRmy+rqKiYnJ1m7fBDXj86AlI25m1xhLxMWah68X1lf/UXpbp/32NgYs5+I9UTDB2LHkPznZkVpp9Ph4k3IKiFHToqpqVQqsFqtXJgHAgGMjIzwmW59fX1bIUnyF8pI7Xcsfz9wWJj1QSjepwOZ2WyGUqnkAoqClQkk6CeesvBhkMlkUKvVUCgUnElWr9exvr7O3TfiOGcyGS5alEol2u02HzKbzSasVivkcjlndgi7DWKxGDKZDCaTCZ1OB3K5nA/i+XweLpeLFxsa+0ulUqjVag7rJepXMBiESCRiB8ehoSHmfU9OTkIul3M3jExUyHa+UChwsUMQThlI49dsNmG325l6SAJPetAcDgfUajXMZjPbzQtd6ux2O1QqFXfFiF9P36PT6VAqlVinVCwWYbVa4ff7EQqFIJVKOWeM6HGkU6JJI11vWjwouJg0RDT5Wl1dhVwux8bGBt8rrVYLwWCQD/z0gIvFYoyOjsLpdLJtPx28M5kMXn/9dZw4cQK9Xg8Gg4EXh0KhwNS9ZrO5a2G2UxyBRCLhwoLucXpd6ixSfABRaukZ+CBAFEYS/pbLZTSbTUilUi7EidJLG0Kn04FEIoHVaoXVauWsMCrGLRYL5HI5Z9YAgMVi4bBpepboGRYWVEKnROquRqNR1Ot1+Hw+OJ1OGAwGRKNRrK+vo16vcwhpoVBAq9XijafRaGBzcxONRgNKpRKNRoObDjRtJQG8QqFgS/3DwuwQh3h/QDR4aq70r6dEec5kMnseSPfbPKPvIUYNFWW7MRaazSai0SiazSaWl5e3Wb4TaA+ir78Z9uO06HA40G63txVBu4GYNwqFAqlUilkOnU4HpVIJXq8XIpEIiUSC3x8VW7S/KRQKDA8Ps2kb5bZKpVJ2MbbZbMhmsyiVStsMSYj6SOs2ySLMZjM32+m8YrFYUCwW+UzVarUwOTkJj8cDh8MBuVzOE8fr168jHA7j+PHjaDQa8Pl8OHr0KBKJBMLh8LZrIGRV3Mokrd1uc8O9v8ChQGw6R+32uu83y0I4Jd6tKKPzF92bMpmMGyD0edEzc7Oszv6f0f/70pmA2CoAeCJN2n6NRsNnZyEqlQpLGz4oWuphYbYLGo0Ga0wsFguUSiWPNA0GA6rVKluzAu+aFuwEoekEmVVQITUwMMAaGbKtp3EsmQAA4Dwmq9XK/FrSuNDrkxV3r9djMwISMDqdTi6m6PBHxRlNbWhKRdbdtLAODg5CqVQiFothcHCQM5/IIZGoZ2QfTtQNek+0gBCVTvhQ6fV6WCwWAGCqmVqtZlEzFbo0gVKpVKhWqygWi3y9yIVPJpPB5XLxNHJzcxPxeJytzP1+PxQKBb773e9ieHgYFouFD8t6vZ4dMnU6HU8syKUpHo/zZnTkyBG4XC7I5XL4/X6mTpLLFhWStHkSV1qr1WJiYoKnbcStDoVCPIXJZDJIp9OQSqU4evQoH/SJK09RAlarFQMDA8jlcttMbHa6B+kaCqkytAHRdIYiHXaz4n8/ICyySE9IhSsALlYymQxTHSh8mRZY0mqUy2VEo1Fks1kUi0XkcjmethmNRrauJhpws9nkxVir1cJisbAjF3Xf6F5TKpVYX19HKpXie560j2R5bzQa0e12USwWUa/XWYhOBjPpdJqnekqlkg8FwNazTpEN/TQKYXFNz9OhpuEQhzg4kGZlN1BhBtz8AExMm1tZU/fThKnVanuG9u5EGTeZTJyjls1mb/gdbzbVonPDfkBueAaDAY1GAzqdDoFAAM1mE6urq3zOEb4enUmomDKbzRgcHES9Xkcmk2G2kF6vh8/ng8PhQD6fh8fj4bNSoVCARqNhTTmwZc1Oeyc1YqvVKhePRqORsy6Jejk4OMjU9Fwuxw0+j8eDUqmECxcuwOv1YmxsjI25+q81nZWCweAtuX+TyVc/qJFOtHia/O2ED2JPoPNkfyOAzqTEzKLzolKpRLVaZVkOPXdyuZzPcLFYbMefdSuTwF6vh3K5zNckHo/zBLRard5wragZe6sxPgeJw8JsD1DBQ5on6tSIRCJYLBbY7XbutheLxR27W61Wi6c5dDMoFAq43W4YDAbkcjmellH4Lbko1ut1pjTSIkvW3OVyGdlslidM1KmgPxuNRuh0OuZnx+PxbW5+RCukaQ117o1GI1O49Ho9BgcHWetTLBZx9epVmEwmhMNhvhaZTAblchkejwfDw8NcaCYSCV48arUaP0xU0FUqFTayUKlUvNgolcptfGFga9MolUrodruIxWJMb1QoFExJIwdJYGtzpbwxkUiE8fFxXhgCgQDGx8f5Z+r1eqyvr0MkEiGdTmN8fBwGg4HjBSjMUi6Xs5uhTCbjTt7AwABTA00mE9MX7Xb7NsMSokiSOQTpkGKxGOsaaOOq1+tQq9WYmppiw4hr166xCJ1omtevX99WmO10oKB8EGF3VywW8wTXaDSyIYXQ2Wsv8e17AXpv7Xabu9H9Ie96vR5isRirq6toNpvodDpYX19nqjAVWkS3JYt8ovoaDAaOr6DniGgTNAVXKpXbpqVEaW61WkyDbDabUKvVaDQazIunw1CxWIRer2dtGzUUKNLBarUil8vx70QFutls5oMJ0aaEoPuPdHZk+nNYmB3iEDdCqPW9HeykGRJqWXaDWq0GsFU80Z6/HyohTekJt6Lv7cdO+4DFYoHP5+M1gxq45IR4s8PubofkndDpdBCLxVAsFiESiTA8PAyv14tms4lSqYRIJHKDxke45tG0K5/Pw2q1MnOpVCpxBJFGo0Gn04HVauX9XiwWc6OMGnl2ux0jIyNoNBrcXKbGHNEU1Wo1rl69il6vh1gsxowjkotUq1U4HA5MT08jGAzi2WefhcvlQqfTQTQaRTAY3KYZHx0dhdvt5ky1W41l2mlaStfkVmIK3m/03+dKpRJOpxPVahXlcpnZWPSMAO9Ox4T7He3ne4GeGaFT+U57Id3fhGq1uqc+/3ZkHAeNw8JsD9ABiDKTKOuLxt/VapWDIi9durQrdYE+ZOH/EzWQBJC1Wo0Xgmq1inw+D5FIBLPZzJM2Cs2laR5p34B3BcSEfD7P06xQKLTrxlCv17mYo9EyBTxWKhWsrKxAKpUiFovBaDRiZWUFHo8HRqMRmUwGEokEWq2W7eLVajVPAHQ6HdMAhN09rVYLs9nMlMhEIgG5XI5ms8lWvIVCATKZjAsbOoTSBJC0b8RjF16nYrGIYDCIdDrNQt1CocCL8AMPPIBgMAir1YparYZsNotLly5hbGwMiUQCRqMRRqORO4REISyXy1Cr1dzxIbodsNXlmpubwz//5/8cHo+H9YPkrNdqtRAKhTA7O4tisciOUBqNBkeOHIFOp4NKpYJEIsHAwADTTsmFig7/SqVyW7eWdGpUgNLf94PuF6KCymQyNqGgzZI6krTgkV7x/QZ1TMmunsLGaXPW6/UIhUKQy+UwGo1MpSUXJtKB+f1+tFotlMtlaLVaLsyp4WGz2diKmSZudN273S6L7MvlMk8uyQDG7XazdlBIf1YoFNxpo8KSDASq1Spf23a7zQYnRPHdbfMm/YfBYODNniyjD41BDnGInSEWizmfaDdntd30XPTM9T9j+ynKKH6lX9awG2h6dLtrrUgk4v1xr59Xq9WQSCTY6IK0NK1WC7FYbNv3UvaiMF5IiL0KTrFYzHsSaeBqtRozEzQaDVwuF/L5/A0NbdqXyG1xfX0dwBYF0eFwIJFIcBFWKpW4SCH9rslkgsPhYL06UcGpUTw7O4vHH3+c9/PLly9DrVZDKpVifHwczz77LMsxiGUik8l4skYu2efPn2dGRDqdZq290WjEmTNnYLfbkU6nsbGxsW+nTLoX6YzTz5YQRjDcjSA9oxAWiwVut5sbrZlMBpVKhVkt1DQGwFM0mjLe7Hmgc4LVamXzt50mjULQubb/dWiit58myvuBw8LsJqAbp91u84RIKpUiGo1CoVBgcnKSu+3U5aBJw26LeL1e37H7RNOKQqGAgYEB1q3RawhvOjKMIBriTtiL6rATSAdFVDma5p0+fRo+n49pWdQdosMwTd5IwEz0z06nww489MBRbhRNAamAo++lyQM9yDSNNJvNbCCi1+t5uqHT6TA2NgabzcaH8mQyyZa4w8PDaLfbnDGlUCgQi8Xw3HPP4ejRoxwmabPZIBaLeVpWr9dZm+XxeNDtdpHJZKDRaFg7VCgUIJfLoVKpkM1m8cQTT/DUrdPpYHl5GXa7nTe/cDgMmUyG8+fPc6FAXR4SclPQMVn12u12Hq3r9Xoe+VcqFcTjccTjcXg8HmxsbDAHv39zpkKSDF2E/GsStlKRITSIeS/dnvY64FAHk/jh1WqVowWoY6jValGtVqHRaOBwOJDJZLa5ZtI0jQ4jlUqFHdKuX7/O2YD0rFKTQ6FQANhy2aIME5oyGwwG2Gw2zsqTy+VcLFPBS8J8vV4PhUKBarXKBgJKpZJpudR0oX8Tmq70Xx86eJF9b6vVQqPRQDgc/sA7e4c4xN2KdrvN1GbKIeo/OKpUKpRKJS7C6DncbX0SFmw7mWnZbDbE43HWld6skKNnu/+weCuQSqVwOBwQiUS89+0EYqjQNaD1iDTfwvdEzJ1YLHbD65EzIWnCd5rs2O12xGIxdLtdZguQKYNarWYb8pWVFaTTaS5IbDYbpqamIBaLsbCwgOHhYZjNZqytreHq1atwOp1IJBIoFovcBB4eHub9i1ggJGWgvDOZTAa5XI4Pf/jDaDQaiEaj6HQ6uHr1Kp588kmoVCqmLB45cgTT09OsDSeNeS6XY4MP0vyPjo6iUCiwI+bIyAjUajUKhQLC4TCCweBNiwWC8F7c6X6ga3S3rPlUGO01YVIqlbh06RKArcLN5/NhY2NjxyakVquF1+vlnLibge4tMuGihj1pCMmngWQ1arUao6OjuHz5MoB3TdHo86T/vhsYKIeF2T5BBhzAuwsXLRLpdJqNAWKxGFvoChPHb6UKJ2HqTnQm4VSEpiBU0PTjduxbiYpFh+KjR4+iWq0im82yVT6wFfRcq9UQjUa5wKKRcalUQq1WQzKZxMDAAJRKJYaGhpjCQA8lFblCsxClUsn25GRxTp2QZrPJnSTidttsNjZ2qNVqPN1rNBpsaJHJZDA3N4dAIACNRoNoNIoTJ05gfHwcx48fR6FQwN/+7d/C4XBgdnYWnU4H09PTvHHJZDJ4vV62ZKfgwrfffhu9Xg9jY2Nwu91QKpWYn59HPB6Hw+FgAbHBYAAAplm+8sorOHXqFMbGxgCArxdZ67/44ou455572N1PSAfd2NhAKpWC2WxGPp9nUxS6djt1TIn33X8v0EYGgPPcbrcbdyv3Gn0tLezUqaLihopGYOt+tFqtMBgMaLfbiMfjWFtb4/Bl0lVKJBLEYjEOWM/n83yAoEOEkE9OTQOtVotwOMydVrLIJfry+vo6xGIxxsbG+KAyOzsLu93Ony0dUEgbQNe7Wq1yIUa8eeBdUwBqYtA1KBQKfOATbng0+abXV6vVsNlsrJ07xCEOcSOoiCIzp0QiccPX0KGZciLJNIqeWWFHH3g3+1SlUkEqlaJYLG5b9zY3N2Gz2bjRtteaSAXenRRlAHhiNDAwAKPRyAfPflDuF62/NH3pP+z3ej1ks9ldJ/gGg4G1tnT+EX4/RYCQbnp6epqZK2RoRpQ2h8PBmnEyLzOZTOwkPTo6yvpsWkNXVlY4gsbr9aLb7cLlcnGzm7IqNzY28N3vfhcajQbHjh3DxMQE1Go1Zmdnsbq6iunpafzQD/0QbDYbF4s/+7M/i6eeegqtVgsPPPAAG4PQ/jk3N4dcLgefzwepVIp4PM5a9kqlgrfffhurq6uoVCpoNBr8XkgnvhfoXtzt6+42AyjSgBMrZad7vdFoYGhoiOUZy8vL2/5dOKWi88+tBHZXKhWEQiFMT0/DZDJhY2MDmUwGWq0WQ0NDnP1aKpUQCATYsA3Ymubp9XouAmmo8n5LOHaCqHc3zO3eYxSLRT4cHwSoy0WuTcAWr5hCYany9vl8aDQa/PfvFYTULyF2cui7ldejLn0ikeARsNBSV9jRJ8c8cpiMx+NcPDocDshkMpTLZbarpWtIExB6IKg7pdPp4HA40Gw2sbGxwe/t1KlTLN6cnp6G3W5nvjkdiF977TU0Gg2cPHkSlUoFm5ubuHz5MnPVrVYrstkszGYzNBoN8vk8ZmdncfbsWTidTqbHSaVSXLhwAalUCufOnUMmk8Hg4CBGRka2BTKXSiW88sorePLJJ6FUKtm8gbRzZOleqVRQr9dhNpths9lY/Eph0pFIBK+++iobkZCOrtFoYGVlBZ1OB16vl6l8S0tLePjhh5HP5/Hiiy9ynAJ9PlS09RdNcrkcGo2G3USJvvp+5aHQRkU6AJVKxTEAmUxmm9sUNTnoPvP7/XA4HDAYDNuiCGjDT6VS/PVU6NGBjKZUhUIBbrcbrVaLdZD02kS3IOcm+n+r1cqaTWBrw7ly5QpisRh6vR7UajXGxsYgkUg4GJyuLxVrlI1EhzvarKm5QaDIBKL/aDQajmwol8scXl0qlbC+vn7DhlgoFKDX69/zz/EQhzgIHPT+fBAgQ6m99m1q0O53IiIEUfZIH3ynxzCKpFEqlSyD2M9rajQayOXyW27wUCN4LzqjWCzG+fPnMTg4CLlcztE39XodTz31FB566CFIpVK89dZbiEQiaLfb0Ol0vAcD4IIolUqh1+vh8ccfh1arRTabZYnBU089hR/8wR+ERCJBJpOB1+tlDTk5ImazWbzwwgv4oR/6IZY2kCSEKPHAloZfpVLB4XCwq3WhUEA0GkUsFkMikcDrr7+ObreLEydOQCwWI5vNYn19HQsLC5DL5SyZSKVS8Pl80Ov1iEajiMfjvCf9vwIysROJRDueHzweDyKRyK7fr9frWbKwH+x0X586dQp+vx+pVIqLsFgsBolEApfLBY/Hg4WFBY5SArCjcRbJV0i+9F7iZnv0YWF2h9htAZTJZHyovt3R8+1wXnd6PyTw3Y9tK9n7K5VKNijwer0wGo3bJglEJyTHJZFoK3+CNDZUoNAi2g8y/9jt2tACJ5fLOcQRAE6ePMldP3LQi0ajyOVysFqtOHXqFCYmJmA0Gvn6JxIJXL9+Hel0Gjabjfnm09PTiEajeO211/igfvbsWQwODkKv13M3U6vVwu/3IxgM4lvf+hY+/elP82dDejo65F+6dAnPPvssKpUKHn74YYyPj7OjJ2WSfPSjH4Xdbke320UqlcLy8jJefPFFPPLII2wXXK/XuZCj97G0tMSd3Gw2i5mZGTQaDaytreHRRx9FvV7H22+/jYWFBf6MSqUSX2thTo5Go2GNE9FR6M/vJyhPjJoc9XodDoeDaSXUPQW27HbJbZScNgcHB5mqQi6NZIpDn02hUECv14NWq8X09DS63S7efvttpgOTSQdFJphMpm1B4tSRrlarUCqVUCqVrC2kz4tcyKrVKtbW1rC+vs5OYMJnmCbDVAhKJBIWh5POEtjasIgSQ+YhZBhDcQ8OhwOlUmmbYQtwWJgd4nsLd2NhdjOQflQYmwPsL8yZmC53Yu4hhFwuh8Ph2CZdIGOyg17Phfpj+h12KzSkUinuv/9+yGQyvPzyyzh16hTW19fxYz/2YxgcHGRdXLlcxjvvvIO1tTXW21MWbP+h3eFwYGJiAvfffz/MZjM2NzdhNBpZ+vGXf/mXsFgsePLJJ3liSjpDirD5kz/5E3YfPnXqFEZHR1mPvLa2hunpaRw5cgRarZabzG+88Qaef/55fPrTn4Zarcbm5ibcbje63S7eeustPPvss/D7/UgkEjh58iQXu4FAAKFQCPV6HSMjI9jY2MDi4uJdqxO7U1DDnc6ae+ned/t+4ff0f5/BYNhmdiaTyXDy5Ek+zxAddH19HaVSCffccw+zYObn5/n7JiYmoNPpcOnSpQ+EunhYmOG9WfjpBvygUtdpYRT+fLFYDLfbjXg8vuPNRh0kKmp2orYRZSCdTm/7N5PJxJ04tVrNE8KdMk3Igr1SqWB0dBRzc3M3vBdhACaBRNP7oXZ84hOfwPT0NLtbUjFJZiitVguVSgX5fB7JZBILCwv4m7/5G564jY6OwuFwYGNjgznJ0WgUJ0+ehM1mw8LCAhwOB+677z7Y7fZt7pNerxdvvPEGzpw5A7Vajaeeego//dM/DavVina7jUQigZWVFWSzWY4DoC5dOBxmy/TLly9jeXkZk5OTmJychNls5jE6mUXQ9Ig2COLXk77th3/4h3lTWl9fx9NPP42ZmRlcvnyZp0FkxS7UmO1UEBOtlHR07yWXnUTZQhqrSLQVBUA0vWQyyfb2qVSK3+PY2BgHb1cqFVy+fJnvGdKVUFAouW+trKxAqVTi1KlTMJlMiMfjCIVCGBwcxOXLl1Gv17kA93q93N0lV6319XWEw2H4fD4MDAxArVZzs4NMP6jbRlb4Wq0WarUaqVQKwWCQnTTlcjkSiQRisRjrL3Y6QNF0Tfg5kG2/sBjsn4ofFmaH+F7C92JhRtgpt8nhcAAAG1P1gyhgB0FDpnxQKpIqlcpNA6pvFzqdDl6vl02tdns/JCtQKpX4pV/6JQwPD7P2i3S5pK8uFArI5XJYWVnB4uIiUqkUUqkUT1nEYjH0ej1nawLA8PAwHnzwQUilUuRyOTz88MPwer0oFArIZDK87pfLZQwMDKDZbOL111/Hxz72MT6XxONxXL9+nRkI5FZ56dIlprS2223Mzs4ik8nggQcewPDwMDe5qVgsl8u4fv06rl27xgVJLpfD9PQ056kODg7C6XSiVCrh0qVLeOmll/Y9Ifpeg0QigcPhgNFoRDab5fihVCrFMoPdoNFoMDAwgIGBAbTbbczNzd3UJ2F8fByFQoGN2YSOqGR0s9M5xmq1fqDRQDfbow81ZrcJ4mi/3yCzj50W3m63e0PIoRA3ozUKTSL6QY591OHa3NzkCQPZ7ZMYWhhSvLS0tOPP6j+IarVafn0qIGUy2Q0bgN1uh9/vRzwex8zMDE9/DAYD2+w3Gg2enrz++uv4u7/7O/R6PQQCAfR6PWxsbMDj8WBxcRGlUgkjIyMIhUJQq9XI5/N4+eWXcfToUUxMTEAsFiMej3OY9szMDGq1GoaGhjAwMAAAeOCBBwC8e08kEglEIhEYDAaEQiGsrKzAZDIxt56KqHPnziGbzeKhhx6CTCZDMplEMBhEJBLB5cuXt33GwoLK5/Phox/9KDweDzsWptNpvPrqq5iZmUE2m91GBRTGLVDmmtCcgqg49PNIAP9egvQF5KhYKBSQSCTYVEUqlWJgYAC9Xo8XZ6/XC4/Hw5MsKjYpO89kMjHldnNzE61WiztjarWaqZJk1pFKpaDX66HVajlfhQ4LwFbzoFQqYWNjA5ubm9s0a0SPIS1bNpvlrDufz4dAIACTycQiZOrakV2+2WxGr9dDPB7fdl1IO0gdXgqMpwkh/T1N12q1GtN4hZ3EQxziEO89+tdJWudVKhW7EhcKhW1nBWLRGI3GbQXH7YACm4V4ryYApVIJa2trkEqlaLVarFEmMyJ6P8JzBmm0dTod79HUaCyVSojH47h48SIuXryIUCiEbrfLzVWNRoMzZ84gEAhgfX0dL774IgAgnU7jL//yLwEAY2NjMBqNWFpagkqlwtDQENPfTSYTAoEAyuUypqen0Wg0OF8yHo/jrbfewtmzZ3H58mUUCgWoVCqsr68jnU4jk8kwK+HBBx/EsWPHuHm7uLgIsViMZDKJd955B0NDQ5icnMTrr7/OTeorV65wY1en06HRaCAYDGJ9fZ3dfq9fv/6efE4Hgf3KYIR0fWDr7ODz+eD3+5FOp/HCCy/s+2cSKyiTycBisbAxWT9EIhGmpqYwMzODXC6HjY0N2O12pFIpZLNZyGQy/t7dzjHpdJqz6sLhMDY2Nu6qYvmwMLsL0N/hosPcTpMj4cMinFSJxWJYrVaYTCYeye+E3QIv1Wo1i4fz+fyOD4XQcIQOxTRpkEqlN2wQIpGIR8u7/a4EYQK8QqGARCJh+/her8c6IaI2zM/PY2xsjClldFilWIGVlRWEQiEoFAr8s3/2zzhcOxqNwufz4fLlyzh//jzuvfdelMtlXLhwAY1GA4uLi3C73ahWq7h48SK79+n1ekxNTWFpaQnBYBAf/vCHOfcrkUjg13/91/FTP/VTsFqtfEAmowZhCHer1cKrr77Km/ZP/uRPwuVyQaFQwGazwePxoFKp4L777mMxKtm8Ey9eqVRCq9WiUChgY2MDFy9e5MBN+r18Ph++8Y1vwOfzcYYdLVI09u8/MBDo/b8XItjR0VFotVosLi5yBEUoFEIqleJrRNEA5XIZxWKR3zc5ZZZKJQ7iJmqtz+eDzWZjJ7RyucyUGIlEgqmpKXS7XVy8eBGJRAJHjhzB448/jkQigUQiAafTCbFYzCYztVoNJpMJKpUKIyMjcDqd6Ha73CyoVCqsfaRJJyEUCjE1sd1uo9Fo8IQrnU7vmgdEXVq5XM5UkFwud4OxDwmlCXdqHnCIQ3y/gjQyB0ktq9VqrCmmNaN/LW21WndclL3foMaV0+lEMplErVa7gcrZj1QqxU0yagpSJMnf/M3fwGw2s2lT/15EbteLi4ssk6DGmcvl4v1/dnYWKysrOHHiBEqlEi5evAibzYbPfvazKBaLiMfjmJubw1e+8hV22rXb7Th9+jRkMhlOnTrF9vhutxtLS0tIJBI4deoUHn74YQQCARgMBt6PiR0hlUoxOjrKGuTBwUF861vfYh29x+NBs9nEs88+i/X1dWQyGZhMJv55uxVmJpOJM9w+KAdGk8nE9/FuZwCFQsHmYXS2abfb2NjYwLVr1255X1Kr1VCpVOw2vRuIIrm0tISFhQX4/X4+DwjjhG4GlUrFzBzhvUe/0wfFhgNugco4MTFxSy+8sLBwW2/ovcDNqBIajYbdmyiE+aBBehfKxjhoED2Awoiz2SwMBgPnb1y+fJk1WdVqdRu/XSwWw2634+jRo1AqlSgUCtydEr7/3W5UISeYFi7KbLJarUxDOwgIOfzT09PweDywWCyQSqW4ePEij8NpslipVJDL5aBQKGCxWLC2toZQKASTyQSXywWv14tSqYSnn34a9Xqd/44MJRKJBHPlG40Grl69ijNnzsDlcrE5h8lkgtPpZPONv/7rv8YDDzwAq9WKaDQKj8eDyclJdDodPP/883jqqafwMz/zMyxU1el0UCgUWF1dRS6Xg1qtRqVSgdPp5KyzZrOJZDKJK1euIBgM8sZkt9shk8mQSqXwrW99Cz/yIz8Ci8WCWq2GS5cuYW5ubpvgmKzoKROFCpmd7kmh5qn/78nAgizohYeMncIxgS36wPj4OEQiES5fvoxyuQy3281TvWw2u61rJZFI4PF4IBKJ2Dmpn7PudDohl8uRyWS2Ze+oVCq215fL5VhdXeWvsVqtmJqaYjol6ezonpVKpdyAUCqVXERTdzoWi+HatWvsGDk8PMy0mmQyyTbL+XyeqRwUei0MNSd6K/3OFouF6Rjkgko8+1vZoA+pjN9/eOWVV/BzP/dz+/76c+fO4c/+7M/ew3e0f3xQVMadDp07Uez7QZOier2OoaGhPcNqbwa5XI6ZmRk2l7jbQesvsLNuiIKByS13amoKMpkMgUAAWq0W//t//288+uij8Pv9qFQqqFQqWF5eRrvdht1uR7PZZAt9AHwuIw37bu9FLpdjcnISDocDlUoFNpsNMzMz3NQymUzw+XwQi8XY3NzEn//5n+MLX/gCFAoFrl69ikcffZQpk7/7u78Lu92OsbExhMNhFItF+Hw+ZDIZ/P3f/z2efPJJpNNp3jcHBwfhdrtRKBTw2muvYW5uDs1mEzqdDmazGaOjo7DZbNywe/DBB9FqtXDx4kXMzs7ueb2pMfxeTUF1Oh0mJibgdruxvr6Oa9eu4b777oNcLsd3v/tdAFuNR9qLgHcZNfvdk8jxsj9PV0jVJ22Z8DV3M9eRSqWsNRNKV44cOYKhoSEUi0VsbGxwBt5u2E3/JjQG6Y+tEZqR3QkOjMq4uLiI//pf/+u+vvYXfuEX9vuyHzios6VWq+F2u+F0OrG8vHzT4ulWedzCIOf3AvSg9BttlMtlnrCIxeIdAx2tVisXM7RYms1mDr1OJBJ7vnfhjU0ZWfTf/Vo1Ak1yKFyXzBd2Cv8Tavno38mMo9VqQa1Ww+Px4BOf+AQXE9FoFKurqyiVShgbG4PH44FMJkMul8PRo0dRq9WwsrKCcDiMF198EfV6HUajEX6/Hx6Phx0bKbft4sWLyOfzbFBBmVX/+I//yG6MlE83MTEBk8kEsVgMi8XCxXGn04HdbsfAwAB8Ph88Hg9TQur1OtLpNC5evIh0Oo1erwe9Xo/x8XE4nU60220sLS1BLpfjk5/8JLRaLRf6wWAQL774Ik6cOIGNjQ184xvfgM1m25ZZQ0UITcvoOpJAeieYzWbE43EMDw/D4/FAqVQilUrxwWRzc5O53TTtpIBvl8sFnU6H0dFRdmFsNptIpVKYn5/HkSNH2NgjFosxtZGKF8qfu3bt2raiz+VyQaPRoNvtYnNzkx0MKcOHIgTIudBsNnPUQDqdht1uh81mY9MM6uKSdTRlGdGiTc8DPe/lchnz8/MIBAIcCUFNAJpak5tXt9vljB6FQsFFo06n4zBsqVTKBw4yLnG5XPzMlsvl/6dcvA7x3qBcLkMsFuPzn//8Tb92fn4eq6ur78O7urshfK5oGiNsRKlUKt7jRSIRms3mDWwWiu4g1+Fb1awIMwqFhdntRN3s1hDb62cDuxsz0Pqj1+u3xZfsBVojga3re/36dS6q7r//fvzH//gfoVarsba2ho2NDVy4cAH1eh3nzp3DiRMn2CmRzg20du8Eei8DAwPw+/3Y2NhglkwkEsH6+jo3u7xeL/++sVgMH/7whzm31W63w2Aw8EF5ZmYGBoMBg4ODsFgsSCQSHKEwPT2Nr3/965zTKnyfZBBF76tUKkGpVGJ5eRnXr19HpVLhhl0ul+Nm+JUrV6DT6WC32294LomtA2BXt0CpVMpTuFarhVAohKNHj6LT6eDNN99Eq9WC1+tl52I6v9CZV6VSIRKJcDRPKBSCRCLBAw88gJWVFXbEFH7GwFYj0Ww2o1wu79lUqFarNxRlALbdq3R+sFqtsNlsrJms1Wrbnku6F0muQV9HZ1/K1N3rvDo8PAy5XI6FhYUd72fhMy98Dnv/N0rq/cAtURm/8IUv7OvrvpcKM1qca7Ua27UKA4/7QToT4QL0XoEMN25lgRZ+bbFYZAtx4luTAQUtdnq9HmazGdVqFZubm1hZWcHAwABOnz6NZDLJU6P9ghYoAtGyhL8T0btIT0Ni2n5qJlFM6Ptp8wTAgk+z2Qyj0cgGF2SSEY1GoVKpMDo6ynzpzc1N/nzT6TTGx8ehUCgQjUYxPz/P7k31eh21Wo2FoxR8aDAY2NSDcm+WlpYwOTmJXC6HSqWC119/HYODg2g2mzAYDHjhhRcwMDCAD33oQ6jX63jnnXewubmJp59+GhMTEzCbzWi321heXsazzz6LbDYLn8/H2VrRaJQ7cOQElkqlUK1WIZfL2ab2yJEjrEN69NFHmetfKpVw9uxZ2Gw2xGIxBINB/syJZrLbIqbX63mTPHnyJOx2OwKBAJaWllhzSOYa5FBJGT5+vx/j4+Ow2WyQy+W8GdFnTBRVCtP2+/2Qy+WIRCJYWVlhzaLb7eb3Q7Q+cuV0uVyIRCIcJErFUbvdRi6Xg9FoRK1W482QMuykUikv/ul0GtFoFIFAAHa7HXK5HJVKBcFgEPl8Hnq9HjKZjEPFe70ea7o8Hg+vBRKJBPl8HolEAgMDA+w0SRM7t9sNmUyGfD6PjY0NlMtldnUjm2vqDMbjcYhEIhiNRtbM3Q2hl4e4u+H3+/e1Rz/zzDP4/d///ff+Db0PuN1ImH70N2JJO02Ufblczj9LOLmh/WI/jse7/dx33nkHOp0OY2NjHOVSKpVuiNEgSKVSdjQUi8VsSX6r1DE62BJVHgBbjEciEWYrLC4u8veIxWLWku8mixCCJiArKysIBAJsMJbNZvHOO+/wJOb111/H/Pw8r917gUKc1Wo1RCIRKpUK5ufneS8ky3vKl6zValhYWMDq6ipEIhFee+01TE5OYnV1len/pLtOp9OoVCq4cOECR6AYDAZm6lBANlHtut0u3njjDVy8eBEikYjPkYRMJsNFhEgkgsFggNfrxcTEBCqVCgqFAsbGxnDs2DEulNLpNIxGI6rVKpaXl7kxuZthl8fjQbvd5py2++67D9/+9rdx9uxZnDp1CpcvX4bH44Hb7UavtxWynkqlIJfLcerUKZTLZVy9ehWzs7Po9XqshY5GoxxftBPI8brVakGn0+3ZmNjJaM5qtXLjk16P9Pw2mw1erxcqlWpbXFL/6wmf21gsxmc2g8GA06dPo91uc8C18JpRzu1ez8ytOqIfJPZdmN2Kg9D3YugpVcMSiQTVahUjIyPsJiOcGFHX4f34wPYzYaOJx05FpJAGRZ14ck2i8EONRsM8W41Gg+npaaZuiUQiFItFuN1uRKNRAFu5FIlEghefm1n693d4isUiHA4H0uk0W9K3Wi3Os2o0GtydomJEpVJxWC+BviadTiORSCCbzSKVSiEajUIul8PlcjGtMxgMYnFxEefOnWO6wosvvojHH38c5XKZg33r9Tq7TFLgpVQq5f9XKBRwuVxYWFhg572JiQkEg0EsLy9jdHQURqORA66dTieOHj0Kl8uFQqGAYDCIXC6Hz3zmM9xpev311xGLxeD3+5HNZvGJT3wCCoUCzz33HNM/4vE4lpeXUSgUYDabEQgEWEe1srKCer3OBffDDz8Mm82GZrOJc+fOwel0wu/3c1FAv5dYLEY0GoVIJGLasVgsZkomGYpQJzgSiUCr1cJoNGJqaooNTpRKJVMDASAcDvP/DAYDFAoFcrkcYrEYTylpAri4uIhisQiNRoOFhQUYDAZ4PB62GqYF2eVysakNOSmVSiUMDg6yC5NSqWQKYrFYRDgcxsrKCk/NGo0GarUaDAYD01tnZmYQCAS4UQCAQ1Cpy9vr9Vgw3m634Xa7OShdp9MxjZH0YJubm4hEIggGg1ywEXeenqler8dND6JyCDcIp9OJVCrFgbAflM7gEN87eOyxx3Du3LkD/9q7Df306veKhUKaZ9rXWq0WFy877XW3ex4gd0LSTpMV+06vSdM1Ms9Qq9W8z7VaLaZuCSdcN4PQ9ZVo3KlUCna7HRsbG3A4HPw+iP6/trYGnU7H04z9oN1u45VXXuG9h2jh9NrUQCP2BkUAOJ1OhMPhbROZYDCIkZERDA0NAQDW19dRq9XYSZgavTR9o98vEolApVLB6XSiWCxicXERP/ETP4GPf/zjnGe6uroKs9mMT3ziEwC2NHKkgZ6dnYXL5cKpU6cgl8uxvLyM5eVlNJvNbfek8GfS/8vlclgsFlgsFtaJm81mNopyOp0QiUTsdq3T6VCv12EwGHD58mVmIonFYthsNjYw0Wg06PV6mJ+fh8lkYp+B06dPIxgMwmAwQCwWY2BgAENDQ6hWq3jjjTewtLTEBh2kFSQDLJvNxvvfXvcR7Vm0797KM0Bn0v69jRrK0WiUJTDCpsFewxAhvbLT6bC0gBrE0WiUo2yEzC4h9nKtfj+x78KMAvgO+ms/aJD+AwBbY7vdboyMjLBWql8f1v+BGgwGNgw4CNDhjTaHvbDbDdYPCrKlhZSs9slSvdlsQiwW82SArHfJxY469+SaRIXZzW7gfkqGUqlEJpNBs9nkIkgikaDZbG5Lkhf+7lRECq+vcLEl4wiif8nlcsRiMSwtLaHT6UAmk2FwcBDtdhvhcBivvvoq/H4/Ll++jHg8vq0QpC5bo9FAPp+HWCyGRqPhkHDSJZDbpN1uB7DlDqVWq7GysoIjR46wONhms0Gv1/PmazQaYbfb2RlwZGSEc9MkEglWVlbg9XpRq9WYr0/TrmKxyIYXZHpSq9X4d//BH/xBDtakTcpkMjG1jnR2VEhQgXPs2DHuKkokEvj9fp62lctl+P1+XL9+nTcRnU4Hl8uFBx98EIlEAtVqFRMTEzxNeumll/ADP/ADkEgk+NrXvgadTod4PI4PfehDsFgsWF5ehtlshlQqhd1uZ0fOarXKAl6hpbTBYEC1WuV8Mrp/qFjzer2w2+3cJRWJRMhms0in0+zO2W63MTIyAqvVCrlczl3CiYkJOBwOZDIZzM/Po9Pp8PMeCASYnknNGirMKpUK05pobaACS0hnoakiFX+UoddsNqFUKmG329Hr9djZUagHJIfTQxziZiC960F/7d2G/snxe9Ug7d/X3uufQwfSpaUlXtMJwixEClymyQe5wQppYTu5y1EEChVFO00waA+kJlOz2eTpPe0VVqsVYrH4tqb4e00n2u32tugUjUYDj8cDk8mEbre7rTAjK/zNzU0+d9H7F9LOiCpuMpmg0+mQTCaRy+VQr9fh8/mYyWEymZDL5VAoFJDNZmG1WmEwGNhtutvtQq1WQyaTIZFI8O+x29pMnyk1dRUKBWvcKBPWZDKhXC5DLpezjISKZMrQrNVqWFxcxPnz59mUrVgsQq1WQy6Xo1gsQqfTQavVIhKJ4NKlS/jxH/9x+P1+2Gw2nDhxAk6nk92J7XY7M10CgQDOnTvH8gmPx4OxsbFtbJib7T10rXdjl90Mu0U6UVxNq9XC6uoqn/tu5WdUKhV2c1ar1Wg0GlAoFABuHBYQKOap2Wzu6tAoZG29l7jj1XmnjhW5mnwvgN6/XC7nTlSvt5VPRN0CGuknEoltRhbEiZXJZHva1N8qhIvL7WAnege5/FDXhboCwpudworpQEjTrHa7DZfLxRsBdVbo/VGXi8b1wk2t/3cgKh7w7oNJxU6pVIJUKuX3SHlNFKpst9u5m0hQKBQcLEgH7mQyCblczrkp3W4Xy8vLCIVCcLvdcDgc0Ol06HQ60Gg0XDhQSDRdH6KvdDodLuDJxt/j8cBqtfLvW6/XkUqleIpDeqZiscg2rlQoraysIJPJ8LWnwtPhcPBU57777mNaAdExNBoNF3lERTAajaxHu3TpEnPJr169irNnz0Imk6FarSKfz6NWq8HhcMBkMrFBDE31CoUCBgcHYbVauSv7kY98hM1cVlZWMDw8jNHRUaaXkgYjn88jnU4jl8thbW0Nn/zkJzn82uv1wuv1YmhoCLOzszCbzSycrtVqGBwchM1mQ6PRYM5/MBiESqWCQqHA6OgoqtUqW+iTnoxMerRaLWKxGOr1OhfJRAWSyWT8WRsMBhiNRsjlci54Nzc3sbS0xJ1oclckrjppDZvNJoxGI9Nnut0uEokE4vE4IpHItiB0En0L70eiQJJDKR0k6vU6NBoN59zJZDJEo1GmwVKD5BCHuF2QFlYIiUQCmUz2Ab2jO8NejUDSBH+vNjOEgdX9um2ype93diwUCjcccHc68FKBsRO7Rfh39P90eBUeYtvtNiKRyI7NadqDqYATgrRI1WqV88kIdI6gIoZ0UtSYIxaLEEajkemLrVYLZrOZKYD95m0UNUJ7FjXPIpEITxmpKCRTJqIykhkUsNV8n5mZgVarxaVLl5hBsheIbkoyjWq1ilQqhfHxcej1eqyvr+PkyZN8bWOxGHK5HMbHx6HValGpVHhIQMwmiUTCZnWkYVepVMjn83jnnXcwMzOD8fFxZLNZjgeYmJhAt9tFJpNBPB6Hy+WC3W5nVlgmk8HAwAAikQiWlpb4M1er1TveS/3N9ptR/oQT3J1yxSQSCbRaLRwOBxwOB+/99NrJZJIZW/sFnWHFYjHW1tb2RUsUfla7QXg9ZDLZDWfom2G/2tHbKsyWl5fx+c9/Hq+++uqOU6L9FhRzc3P4vd/7Pbz22muQSqV48MEH8eu//utwOp3bvu6v//qv8Qd/8AdIJBKYmZnBb/3Wb2F6evp23voNoE2LjCfo0FWpVHhSpNFoUCqVbqii6Xv2O7U6aOz2Ie/2MLXbbXbCIa2OkMrQ7XZRKpWYLqLRaFhYSUYJQo0QLfQ0vdmpSO9/fzvxkMlOmA7ntBiKxWIYjUamGlKnVyQSodVqQalUQqVSQalUstugSCRiq32NRsOTGJqqkXEELeh6vZ6vR7PZhFQq5cJOaGZBX2M0GiGRSJgrXqvVWOAci8WgVCqxtraGer0OnU6HYDAIhULBU7dQKISRkRFIpVIYjUaIRCIUCgVsbm6iUChwmHW5XIZCoUClUkEsFkOlUmEtABUoRGMwGo0YHByEw+HgzYK6ThS2WavVOKuNwpn1ej0KhQIbkVQqFW5InD59Gh6Ph7tNi4uLTDmljisVMLRR9no9aLVapFIp1Ot1KJVKnD59GqlUCsVikRdJWsxarRY2NzeRTCahVqs5kJmmkySIJl2YxWKBVqtFrVZDPp+H3++H0Wjka0KTV7oH6H0qFAouNuk+p02LJrbZbBZGoxE2mw1KpRLJZBLhcJjt9gEgkUhwYLjNZmOaD5maNBoN7s6SbS/p4YgKValUIBKJeJJJ00CNRgOXywWr1YqlpSW2ZD7EIW4HTz/9NL70pS9hcXHxhr3piSeewDPPPLOv1/n2t7+NP/3TP8X169dhs9nwoz/6o/iFX/iFbYVds9nEl7/8Zfzd3/0d2u02nnjiCfzmb/7m++60eDM3xQ8CFJlBawGw8/5M2WC7gdYy2q/orEJ2/CqVCmKxeFcLfvqZ+70+u50tdpskEFtlJ+obUe2FRZ7JZILD4WAGjZDWRjp+kjD009eIgUCfN020iCVCkMlkfAYgUyi6xlQ8Li4u8l6ztrYGk8mEtbU1OBwOuN1udpiMxWKIxWIcGJ3P56FWqzE3N4fx8XH0ej1uTgqLW2IY0cTG4/HA6/Wy7piYHrR/xmIxjI2NcfYmUSBdLheq1SpyuRxarRY8Hg8HV8vlclSrVTidTjazop+7sLDA4duFQoGpkBqNBu12GwaDAW63G/Pz8zypHRgYYFON/kY4AC6k93JmJDMvCu9OpVKIxWJwuVzMOKJ7qdvtQqfTcSxBpVJh4xSPx8Nsor3CpoV5ukJQQLnVakWpVNrWNBA6fNPvJbxHFQoFHA4HrFYr8vk8F3j0ujfTV+6E/X79bRVmn/70p2GxWPDVr371tmmLnU4Hn/rUp/Av/+W/xL/6V/8K1WoVv/zLv4xHH30Ub7/9NofIfu1rX8PP/MzP4I/+6I9w9uxZ/M7v/A4efvhhzM3NcYf8ICAsOsrlMiqVCnO38/k805f6v4duduBdjvZ73eWmomq3an2nn083BNHY+h2ZaEJFh1xh4SK0JN3p5xF9jF5vt7R14EZaIh1caWrR6XT44Wi1WpDJZFxUCt2BaORMroAGg4FperRwF4tFRKNRdkPUarXQaDSIx+Oo1Wrw+/1sx0rcd9oo1Go1d6los6NpE01VSURL3PB6vY54PM7TNaLQKZVKNJtNpuWJxeJtBSWFS7daLTY0sdlsXKhQYUibscvlArB1n1arVd7gSEMIbE15aTJFroAWi4WLVKI10MSHqBv5fB75fB7RaBTj4+OwWCzsclkqlfDWW2/B5XLx9dVqtUz5tdvtsNvtuHDhAubm5uByuWCz2VCr1dBsNtlB02KxwGAwIB6PM92Qgq5pwaf8t0ajwZpB0o8R3YMoJ9RBpAKUOq8bGxtIp9PcLdVqtcjn8xgYGECn04FWq+XvJ90k5fPQYarVajHFFQBr6mjy1mg0WFNrMpmgVCohkUiQyWS4Q0tTVTICqdfrUCgUOHLkCGw2G9LpNAqFAue6FQoFdnM8xCFuFclkEp/61KfwxS9+EY888sgNDBaTybSv13nmmWfwR3/0R/jc5z6HI0eOYH5+Hp/97GexvLyMP/7jP+av+/znP49nn30Wf/mXfwm1Wo3Pfe5z+Cf/5J/g2WefPdDf62bYjaL0QUGou7lZx55YOrtB2EDeaeJgs9kgk8l2dX++HZfH/YDOE9R02qlRTwYPDocDJ0+ehEgkQiaT4SYsFVlCN7xSqYTV1VWmfwvRXxxWKhVez8nFkZqofr+fiyav14twOIxgMMjfm8/n0Ww2ueCl90RRMJRBGgwGEQ6HMTY2xtR5g8HAEzjafwqFAu8Vcrkcer0eOp0OrVYLWq0Ww8PDPHgQMmqoOPR4PIjFYnz+2NzcxMzMDNxuN6RSKfL5PDf3QqEQBgcHYTAYuLFZq9XwyiuvYHx8nI3VHA4Hn+tIdhOPx7GwsMC/I7E5SEcOYNeAZ2Cr6KX82nq9jkqlws8f2crr9XoEAgH4/X420aKpqjD3s9frMTWV9u5mswm73Q6TycSslVwut6PGjJoCtG8LzWzo/ewU97RXYaVUKuH3+zE5OQmdToelpaVtUiDg1qiVt4rbKswuXbqEWCx2R1oyiUSCK1eubONS//mf/zlGR0fx5ptv4uGHHwYA/MZv/AY+/elPc0bLn/3Zn8HtduOP//iP8R//43+87Z8vxG6LVq1WYy41HapoISEOrlBLQhOMnQojuVzOhzbSrNyuwPBmNrf9EBZK5LLTT12gokS4QKpUKj640ihe6D5F14OK2t2uY3+0AFm3Cyd1nU4HCoWCCysATG8kpz0h75loH9SJstlsXORQiKVSqWRRLXXOjEYj6vU65ufnIZFIYLFY2KacCgIqesViMR+2u90ulEolbxoUdLy+vo6RkRE4HA6IxWI2dajX6ygWi9Dr9SiVSlzcUQG3ubnJ/xYIBLhgabVa0Ov1cLlcPHVqt9vIZDJIJBLQ6XTwer1oNBqsuUomkygUCpDL5RgaGuKJEdEB5ufncfbsWQwMDHAxR9o6onpqNBpotVp4PB40Gg28/fbbqFQqePvtt3H8+HG0Wi1Eo1FsbGxgc3OTLfF9Ph9vTvR3R44cwdWrV7G8vIyjR4+yKDkWi2FkZAQWiwUAmKJIC2m5XOZih6aJlUqF74t4PI5EIsGbQj6f5+eKwi6FJjLJZJKDSekei0Qi3GUGwOYhTqcTpVKJKa1kJkL3Ad2T9IyTJkEqlXImCblYtlothMNhNu8g0NQV2Fr/arUaT98WFhb456tUKt5MqKC9WTPmEIcgzM/P49ixY/jN3/zNO3qdxx9/HB/5yEf4z8PDw/j3//7f49/+23+L//bf/hskEgmi0SieeuopfPWrX+U9+7//9/+Oe++9F2+++SbuvffeO3oPBwmxWMyNkd3+3WAwsKnFQRQywrMA7ZE7NS73+0z3N4dJF0P7z04TDoVCccvTxFv93fcTB2Q0GjE+Pg6pVIp//Md/5AbqTvSxTCazY2FAB2yHwwFgy5yDml7kMEkutzStpMas1WpFrVbbVpgBW+ePQqHA75EadYVCgV2ky+Uyf3a031itVtxzzz345je/yQwXYlcJWREAWLu+vLzMxUUul8PExARnjn7yk5/E9PQ0MzUoB5Ma/uRU2Ol0EI/Hsb6+jmQyiWeffRYPPvggGo0GSzYogsZqtXLhRQ1Gui40Tff7/Xz2MBgMiMViNxhS9YOuORl/yOVy6HQ6njqpVCo2w6IGOjGGRKIbc1OpISx8Tdr7iNkirBWEoNfrZ8uQYRcx4Pp/5l6eEHK5nBvkxBoj+uhOzZGDxm0VZoFAgC097wT9F5ouHFHjisUiZmdn8au/+qv8NVKpFI8++iheeumlO/rZBLlcznoPIfo7WHQwInc+pVLJY3bqABCPmm4oIWgBJYtOOvz1evvLRqCfTQsN3aj9IZlCigm9B7rOZNpBh8N+LRhNCegQSgsMAO5iEIR2tdSlonE80Rvp68npht630H2J/o4mZWTH278x0LSFPrNqtcp6Kxp90zVVq9VsI0yue9FoFJubm6w1arfbPE0pl8vsVkiFEU2zjEYjPB4P8vk84vE4isUiW8SKxWJks1me9JHT0vr6Olv9CzcdcgekBcvpdGJ1dRXFYhE2m40/ByoeyB2SFhCVSsWmLUTXpNejIqLT6XBBTZbtV65cwalTp5i+SL/H8PAwjh07xtbMZEShVCpx7tw51Go1vPXWW3xNMpkMdDodZmdnueggvVoikcDi4iKmp6chkUig1+uxtrbGBWkqlYLb7YZWq2XKKlEPKpUK6/lokthsNtnkg/RXtLFQY4OeRTroCKmsZFCSSqWg1+u58FMoFGx1LHx2ZDIZSqUSjEYj3G43Wq0Wkskk6yEpA48sfel5IXE1rSMkHCYacK1WY5MQ+iylUik0Gg3C4TB3RokyGovF+NkmK366h2hj6O8IHuIQQgQCAXYv3e0wsx/sRKUljS392yuvvIJut4sPf/jD/DVnzpyByWTCSy+9dFcVZjKZDBaL5QadE4GeOdqL7rQwo32QXpMmPbSGC3/u7f4sorWTtmu3nKvbmSb2O2DuhFuZ6tMaS9Mjq9WKeDy+zdBESD1vNpuo1+uQSqW859NU0OFwsAyAzgYUb0AH+3w+j2QyCWCr8UbGWUKo1Wp+VmjilkgkEAqF2KCJ9iZaj4lxs76+zjTNUqkEj8fDJmlEXycaP72veDzOuabNZhMDAwOoVqvsjKxSqTAwMIC3334bLpcLjz/+OGw2GzKZDEQiEZ9trFYrPB4P4vE4XnzxRdZPR6NRGAwGfOc734HRaITX62Wn4WAwyDREcsQkc6xischTLxpG7DXBpcYngc4+RC2tVCool8tIpVIIh8O8ZxOIrkqMFOGggPa2WCzGTCkycdspP5gcOYl91e12oVAo+NxEjBmpVAqn08l7LZ3/9vr9yBmaqLi7OaAfNG6rMPvyl7+Mz3zmM/jt3/5tDA8P37D4W63WW37NXq+Hf/fv/h3GxsZw+vRpAOAFlLojBMqe2A3C7CsAexY+9F5jsdieiyO5JpGNK2lb6OYkDRQJkIW8cipcSJjabrehUqng9/shEomwsbFxU1dHOtzV63Xu+JMNN3X3yCSDHA2F9AcAfLilcbHwYRBuHATiVZMItJ9/K5PJ+CAvFP0SVY++nuho9D5oukM/mz4rshcnUSUtbnTwpvenUChQKpUwNDTEockWi4UPxxqNBgaDgTVWFCZMFrTUGaUHlIpeyiYjowa6llRsk6Uu0SjD4TBzuavVKtP9KOeK3JioQALAC5ROp4NMJoPZbMaVK1eYhlmr1WA0GpljXa/XWZ8kk8mYEqDX65mzrlar4ff7OZD5+PHj8Hg8WF9fZwoJHfDlcjkHM589exZqtRqxWAwXLlzA9PQ02u02T+xkMhl+4Ad+AP/zf/5PfPzjH+estPPnzzOdkz43uVwOhUKB5eVlyGQyuN1ufPzjH0e73cb6+jpSqRQMBgNvCHS/U2El1AVS4RGPx7lrRxM9Ks5pgkkNAYVCAZVKxeYxNG0kTnuhUOAMIpfLhVKphEKhsM2pMpfLcfOC9AkajQaxWIz1jbS22Gw2HDt2jClE1FWNRCJctJrNZp5mEo2Wnk0y1Jmbm2NBt1wuh8fjwdraGgdt63Q6AGDjGbFYzBvt3aanOcTdgYGBATz00EP4whe+gF/8xV/kCTWBKFa3ilQqhd/93d/FT/zET/CeT5EZ/a9H2tCdsNf+/F5R7gBw17sf1KAh5+L9HLz28z41Gg3MZjMGBgbYYa5SqUCtVm/b9+7kd+50tmzBacJCGnIhbjXfjEANsoOASqWCx+PhouC+++7j9TSVSm1rOCmVSphMJhSLRW4EaLVaprsDW/cdHcRlMhn8fj/EYjHW19eRzWa3naVI/71TEUn6IbvdDq/Xi0QigZWVFf45VBhSo432DcruJLhcLqYyEiMpkUiwVo6msKRZP378OEZHR5FKpbC2toapqSneo1utFv7P//k/+JVf+RVMT0+j0WhgdXUVqVQKZrMZYrEYZrOZpSY//dM/jWeeeQYf/vCHce7cObz66qv4+Mc/jqtXr7Lch5g1sViMJ0s+n4+Dqa9du4bV1VWk02kMDg4ypR4Am4ftdY/W63VEIhFmlAgph/Q6QshkMtaT7ebqSEUy4ciRI+xuvRPojLXbc65SqXD69GnY7XakUim8/PLLuzZgGo0Gs16oyKfz6M1wEGvYbRVmDoeDXd92wu28qX/zb/4NXnrpJbz44os89RHqooSgw9du+K3f+i18+ctfvuHvhfQkygwJBAK8ONxKF5oc9vx+P5rNJrLZLAqFAhdJNEWhYqjdbnMiuVqthtVqhUQigUQiwfDwMMrlMpaXl7nLSYuO0PGwWCwyLc9ms8HlcsFkMjE9slgsIhQKoVQqsQhUeBPTpIXeI/2Mm3W9hFQu0nxRWDBR5oTTN3JCoht0p5/RbDZ5kia8kUmjplarIZVKt2ltqDCiRTOdTnPWCWkSaZIHbB1mM5kMwuEwrly5gvvvvx/Ly8sQi8WYmZlBNBplCiMFOhJtktwQ6b3JZDK4XC54PB4+GC8uLvKBvl6vIxqNwmq1IhQKodVqYWRkBHK5nB2SaNMsFouIxWIYGBjgQwnRNsgimLJK6NqHQiGUy2XmvGcyGZRKJZjNZszPz8PtdrMejWzYfT4fisUii4IzmQwsFgtvgnS9qch0Op08Nez1etz9Ix2Y1WrFgw8+iBdffJENO2gjUSqV8Hq9mJubY/qBcKql1+vZ6ZCaIYVCgfn1Go0GMpkMkUgEq6urzC8nlzWaiHm9Xo51IB0ZFXtEFSbNIrBlguLxeLhY29jYYAoosKXHcTgc0Ov1OHLkCPL5PEKhEPL5PBfRtPnrdDrYbDb0ej1sbGzwtSSdHdFlPB4PVlZWsLm5yc0EmhzSITAcDnPxViqVcP36dXQ6HVitVqYUU9dRSNPZqYFyiEP0Y2RkBL/6q7+KP/qjP7rh327F/INQLpfxiU98Ai6XC7/zO7/Df08d+H7stUfvtj8L5QJknHAQIP10u92+wUCA9i96pmjPpgbNbkZapMMmqjKtp8IzBBlcED0+lUqhWq0yVVnY1BW+11v5vdvtNrLZLP/5IHV2e2VG3Sp8Ph+AretNphrkvkj3D+0nZFRBoImIEP00R9L/VCoVbhgLs1Zpb+wHabvIij6bzW4zhAC2rnH/e+qH0M6fIJVKOaCasti63S6sVisGBwcxPDyMyclJ+P1+vPLKK0gmk+j1etxkpukPGW3RfUyNa2JqlEolhMNhNJtNWK1WPProo/i93/s9BAIBxGIxprImk0ksLS1xjhoxemiiSpM5jUaDs2fP8tRyZWUFb775JjOigHefAeF11mq1LHu4ePHintTWWq226+R6N6ysrGxz8u7XiAmbPbv5LPR6PaRSKdZ171Wr0Ln+VkBr2O1GCBBuqzD7F//iX+Dxxx/H5z//+QPJLPu1X/s1/Omf/in+4R/+AcePH+e/J3pXOp3e9vVkXrAbvvSlL+GLX/wi/7lYLMLn82F4eBh+vx+lUgmXLl3C1NQUXC4XYrHYtikNPRDCD54eCrFYjFQqhVQqxe52lFVB3Ga328024mTYQBsYWXfLZDI2daCJEy1M1NGkIoOmX/F4HFKpFH6/H16vl6cmpMUhW1EySqAuidCQg/JMdjPy2AlCeqTQ2px4vXR4FRZYwtemQ3P/4kqWsEKKJo3Xm80mT8BooxI6TkmlUrjdbp6w1Ot1zgAbGxuDSCRCKpXC5uYmstksJiYmUCqVkEqlcOzYMbZ2HxwcRKPRYHc82miTySQbPVDCfblcZhokmcOo1WosLi5iaGgI9957L8rlMqLRKNrtNmefRKNR5HI5Ht1ns1n0ej0UCgXuxBDtpdFo4MqVK3wdTSYTNBoNAHCxQkHQR44cQaVSwcDAANMQp6en8Vd/9Vf4sR/7MdhsNrb+BYDx8XFedMmdkq7/xMQEZ3MR3bVYLEIqleL06dNYX19nasfk5CSuX78OrVaLY8eOodVqcSD08vIynnjiCQDA9evXIZfL2eF0c3MTk5OT22i9YrF4G+2KisirV6/C6/XCarUinU5jamqKn3kqHIlS0u12Of/EYrGw62I+n8fKygoajQYsFgv0ej3Gx8dRLpexuLjI9+3Vq1eRzWb559ntduTzeSwvL/PXULfUarVCrVbj6NGjPK1Op9OIx+MYGxvjz9hisXDXkWI2aDINbDVJFhcXmVrrdDo56qF/sxBufoc4xM2wsbGBX/u1X8N/+k//aUfzj1udllUqFXzsYx9DrVbDd77zHV6PgK39oFwu84SasNcevdv+rFarWSdKLIc7OdxQc0alUsFsNiOTydzQ1CBqnBA2mw0WiwXpdBrpdPqGQx7txyKRiCcY9NzTYZMmWUJzCaJT71XwCClYHzQOojAmrSwxIxqNBvR6PZxOJ+bn57G0tMQFExVVOzF0bgaarKhUKtYFUbFEzdCdkMlkcPz4cUilUt4TbmZgtl9QlJJKpcLx48cxPDyMa9euIRwO49KlSygUCtBoNEin03jzzTc5quczn/kMvvzlL/O9UK/XeSJHGauNRmOb5n5mZgaLi4vw+/2QSqX4oR/6IXz9619n10eZTIaZmRlkMhmEQiHU63Wsr69jfX0dKpWKJR8kT1AoFJBIJBxF43K5sLGxwc8C6fO73S4zTfR6Pcs1hoaGMDc3d0fXrx/Cwou0oPvJ+iWUy2VcuXIFiUSCG7gHDaHNP4BtLuK3gtsqzDY3N/HGG28ciB3uf/gP/wF/+Id/iGeeeeaGCZzNZsPAwABeeeUV/OAP/iD//csvv4xPfvKTu74mcZT7kUgkcObMGdhsNjidTi6Wrl+/jpmZGWxsbECv17PtazQa5UXSYDBw5hIFFcdiMdaY5HI5Hs8C7xob0EZAeVlSqRTVapXNEoQwGAzcyajVahweKBaLmXZFeWtEzSI7+Gg0ilgsBo/HwzoeYUeAFhn6mVSA7GfjI9c5uobAVkdWLBYjFovdtPMAvCu0pI4CTe5oGkITGjLXIA5yf1FOGBsbw+DgIFwuF5RKJWZnZ/Hwww9jamoKZrOZueCtVosdle69916YTCYsLi7i2rVrAID19XV+TXJLCgaDPDKn60WTpOXlZe6ckR4OAFZXV2E0GrmAJz0X2cDSFNHn88FoNGJ1dZU7pkT7pIwvIY+ZDjtqtZqnUFSMAVvF2tTUFHq9Hl577TW89dZbeOKJJzjsenFxESdPntyWB2az2fggRKGauVyO3RnJIOVP/uRP8LnPfQ733HMP6vU6Ll++zBSOtbU1dsJsNBrY3NzE5cuXIRaLUSqV2FaY7sVKpYKRkRGeIrndbojFYiwtLSGRSLD+ilwrAXATgjp6Qg480TRJW0CGHKThomJXqVQiGAxCLBYjGAzyJKzb7cJgMLDmjsJHR0dH4XA4mL5KsQZOp5M3nYsXL8Jms3GouNFohMvlQqFQwNLSEvL5PFKpFL8Xg8GAoaEh1Go1ZDIZpiMDuKETu5s5wCEOsV8Eg0GcOXMGX/rSl+74tarVKj72sY8hn8/j+eefv4EWeebMGQDAq6++ikcffRQAsLS0hGQyyf/Wj932ZzqIG41GDAwMIJ/PY2NjY9vespM+erefQZ1rWjN3AkkShBMYalABYDbKThCLxTz90Wg0iEQisFqt/Fo07QbA7r03ozl9EEUZUfnpsH+QVFK9Xo/HH38cIpEIb731Fj7xiU/gyJEjaDabbN5E78Hv92Nqaoozvt58881bfi8i0VbUDNHrSdu1W5E3NjYGp9PJrJexsTEoFAqsr6/v6Uq4H2QyGdhsNhw5cgR+v5/X/eeff56jphQKBXw+Hz796U9z4zgSiWBoaIjdl+msQAwLo9EIpVKJUCiE5557Dj/5kz+JM2fOoFar4fXXX0etVkOxWMTLL7+M8+fP8/lUaCJFOma5XA6ZTIbV1VU4HA54PB5cvXoVU1NTrMtKJpNIJpN8JqGCMB6PQyaTwWq1QqPRYGNjA//wD//AuWQEOjsdFEjbT+fF/dwj9HWhUAi9Xg8ej4ddmA/yfhc2eUj+cDvNpdsqzEZGRhCLxe64MPvyl7+M3//938czzzyD+++/f8ev+cIXvoDf+I3fwI//+I/j+PHj+IM/+AOEw2F87nOfu+Wf96EPfYidBWnSEo/H2Y50dnYW999/P4+eKZRXKCZNpVJIJpMwmUyYmppCpVLB1atXucM2OTnJjkKkP6LNjA5lQggdFguFAjsHOhwOFh/SSJk2o0QiwTcTZS2YzWYoFAo2ubgZbudmEYlEmJiYAADW1dB73+3r+/+dsrPGx8e5KKIRs7CTSGPknWxO5XI5nE4nT0hogyRNGAlZ19bWsL6+DrPZjJGREX4Yy+Uyrl27tq1jYrVaIZVKMT8/D6vVCq/Xi1QqhXw+zxpB4UItEong9XphNBqhUCi2WcQfOXKEO4TpdJqnOr1eD5VKBWazGZOTk1wcKhQKjIyMIJlM4vTp0yiVSlhYWNhGUyFXRKfTybkjCoUCTz75JNMl1Wo1vvCFL+C73/0uGo0GvvnNb+Ls2bNYWVmB2WyG1WrF3/7t32JiYoKL13A4jMXFRQwMDHDsALk4/fAP/zC/P5FIhEAggMuXL+O5554DsDXBfOmll2AwGFibZrfb2a3twoULuPfee1k7Rq6Rc3NzuHr1Kk+IHQ4HJicnufu2tLSEXq+HarUKq9W6bcotNJgB3rVOFupWaIJNz4zT6UQqlUK5XMaxY8d4Qc5ms5yTQhk2q6urmJ+f56445dmR45bJZML58+cRDAbx3e9+FyKRiIOwrVYrO2eR22U0GkUkEmGjEIfDgXQ6jc3NTc5WE3YCHQ4HFAoFawEOcYhbxcjICBKJxK5ai/2iVqvh4x//+K5FGbA1hX/sscfwa7/2azh+/DiUSiV+5Vd+BZOTk/jQhz50Sz+PtLSRSAQikYhtvsPhMB8oBwcH0ev1sLKywsyWndCvY9sNZAREIEOJvWhrhE6ng9nZWf4+4Ma9kPZlcnAVi8XbGp13A4RRQf3vfyezBWB/ztAKhQI//MM/jJmZGXQ6HaTTaVQqFYTDYdTrdc77BIATJ05gZmYGEomENbo6nW5fxmiUN0p7Rv9UdK911OPxQCQSsWSCzJ5I071XUU4GX7tBq9ViYmICo6OjAMDxOaQTXlpaQqFQwEc/+lHWR5fLZVy/fh2jo6NsRkKxAW63m91/aQr20Y9+lKeSEokEk5OTeOaZZ/Dcc8+xprtYLOKdd96BTCbjswidS/1+P6rVKjKZDGZmZjA1NYVsNou33noLly9fxszMDNbW1radF10uF6RSKbLZLGQyGex2OzO71tbWALybE0fX8iBBz/x+tZPUHC2VSjAYDHyGv1kOmVAScTuN0t2o0Pt6z7fzTZ/+9KfxUz/1U/jt3/5tjIyM3DAS9Hq9N32NbDaL/+//+/+gVCr5AEj4L//lv+Cf/tN/CgD44he/iEQigYceegjdbhc2mw1f+9rXuEC4FWi1WhQKBSwsLEAikWBkZIQtywcHB/GZz3wGV65cgVqtZv0YabcKhQJUKhUmJydx7733Mmf36tWrGB8f50M4uf05nU6edggNCYRFhkKhQCAQgFwu5yJgbGwMJpOJcylWV1dRKBSgVqs5i6vZbG6jQZL2aj8F2Z2AikdyQSTbe+DdDCeiD0ilUng8HgSDQbjdbhaC04ZXKpXQ7XYxMDDAvN9utwuLxYJer8fcaMrJAN7V59DkgiZrtJmurKxgfX2dTRZCoRBWVlag1WoxPT2NcrmMTCaDf/iHfwAATE1NsU5gbm4OBoMB4+Pj0Gq1iEQiHKBMBYtws+71eggGgzdY766vr+OBBx6ARqNBKBTC8vIyisUiAoEATpw4gUQigUuXLrGpg1wuZ6tYu92ORqOxTYNI+WZ6vZ6jDjKZDMrlMh544AHUajWsrq7inXfewalTpyCRSHD06FE899xzPEWamJhAtVpFLBbD8ePHsb6+jr/4i7/A8ePHsbKyghdeeAG/+Iu/iFqthlgshs3NTVy8eBFnzpyBw+HYxpleWFiAz+djXQB9RuSYFQqF4PP5cPToUaYb/tVf/RU+8pGPMA1wYmIC0WiUCzYSTDscDv4MqBtHmkqNRgOn04lut4t8Po8rV65wTpqQK09h0clkkilGRBuemZlhygaB6KpWqxWbm5tM5wDAjlHxeByFQoHpqLVaDYVCAW63Gy6Xi62GE4kE1tbWmNIh7BrGYjHOBkylUpicnOTQy0uXLvHXUV7doSX+IW4XFosFR44cwc/+7M/il37pl24w46J7/mb4+te/jhdeeAEGgwFHjhzZ9m+XLl3ijv7/+l//C5/5zGc4muT06dN4+umnd9Se7QdkJNDpdGAymdDpdHDixAmoVCq8+eabOH78OB9YyTiHdKZ3itt5DbFYzPvG5cuXtx1Ehc08mg4B71/m6W7Y76Rhp4MlmU7JZDJeG3dCt9tlg6x8Po9gMIg333wTJ0+eZMYHAPj9fpYSkA5QSHG8GW6lgUXNQMKVK1d4T+12uzcU6gTS+dIE7vTp0yw72O3wTTmpmUwGi4uLSKVSOHLkCJRKJVKpFBYWFlgyQ/f5+Pg45ufn8fTTT2NqagpyuRxvvPEG7HY7dDodF/mZTAbRaBSnTp2C3W5nL4NqtYoXXngBZ8+ehUql4iYfmVl1Oh0EAgE8+OCD8Hq9SKfTuHTpErNxgsEgbDYbyx1eeeWVbfeJw+FgqQiZ5dC+ODw8jAcffBDA1pRvN/OfnUAGL2SUclDNC4oZIGdHg8HArJm9YDab4fP5YLVaIRKJsLS0xCyY9wOi3m2sRDfjZu7nJcm1ZicYDAY2cyC02222s75VbmixWITBYMCP/diPoVgs4rnnnsO9996LV199FY899hhkMhkeeughiMViXLp0iUexc3Nz6Ha70Ov1TIO6//772aTgpZdegt1uh0KhQDAY5A0xm80iGo2i2+1Cq9VCq9UikUhsu9kUCgWcTidTrCYnJyGXy3Hx4kXO25DJZCgUChgZGYHZbIZSqUSn0+Fxdz9Xnex+hd0KYIsqdytc3L1A157CEelGpfyPQqEAmUyGfD7PujJaDIeHh7G6usqvRRotl8vFboHZbBYulwt2u50njMKsMZ1Ox1zs6elpnljRIYCyQsLh8Lbff3R0FFKpFOFweJtxxeTkJOx2OzQaDRQKBRqNBjKZDJuEUMgxORORAxRpjyiR3mw2Y2xsjG1V7XY7FhcXYbPZoFar2XiFip92u42hoSEsLCxAoVDA7/djeXkZw8PDbGyhUCiQSCTYSZOMSTqdDnQ6HSYmJqDT6bC5uYmpqSnOsslms3j99ddx/vx5Fp4Xi0W88MILaLfbsNvtbO27uLiIzc1NbrCcPXsWMzMz8Hg87D5KnbxgMIiXX34Z8/PzyGQyWF9fh0gkwsDAABQKBWu6HnvsMfj9fr4f5ufnUavVcPr0aVitVjSbTVy9ehWxWIwNcLLZLEqlEmsribJI06ZOp4OjR48y9YgcpKiTpVKpmBZL4dNk8iORSBAIBLizV6vVsLi4iKtXr6LX62FiYoLNVnK5HMLhMGQyGU8RyamLwjkrlQpr+lKpFE6dOgWTyQSZTMZd1nq9znz+XC4Ho9GImZkZWCwWdmo8cuQIpFIpTxdv1z2tH5SrdojvTzzzzDN48sknd/33/Zp/1Ov1bbpeIex2+w3TOMrmFDYk9gPan3cC5Qk1m0185CMfQTgcxtraGkQi0Q1GHu83qCBbW1uD1+uF0+nE5uYmIpHIXeeYqlQqYTAYkMvlbmsST3ujwWCA2+0GsFV0EkVuN2i1WtbWKhQKdhA2mUy4fv06YrEYm6RQXmg6nb6h4flBg+zgU6kUG4GpVCo2EBOCqOjkblypVGAymXD69Gno9XouVN98800sLy/jkUcegdvtRjweZwbLY489xhlqr776Ku9bEokEjz76KM6fPw+Xy8XyA7FYzCyhp59+Gt/4xje4YCaDEaVSiUuXLsFqteK+++6DRqNBKpXCxYsXOVPYYrHg4YcfxtjYGHK5HL7yla9sWwOIEUL30ubmJp/1vF4v+xsQc2u3e83lcsHpdCIUCiGdTsNkMsFkMrG3gFKpRD6fv6XibjdIJBIMDQ1hYmICxWIRL7744k2/R6VSMUUzk8nwJPWgcLM9+rZaWvPz87f9hggk9N8vpFIpTCbTHf3MxcVFDr2lhfPNN9/EY489xhkXs7Oz8Pv9yOfz3LEzmUycEUIOPQsLC+j1thLlKXuJKIxKpRKlUokpTm63G6VSCVeuXOFcBKJjWa1WHDlyhAP5AGBoaAgXLlzA448/zvRJomDmcjnmq3s8nm2W/ULLeiH6q/ydHG36sdsYf2pqClqtlu3vQ6EQ4vE48vk8BwTT/1NmjMViQbVaxerqKjweDzKZDGQyGcbHx2E2m/kAbbfbecrY6XTgcrlQLBZx5coV/vnU7ep2u9v+fmxsDCMjIzzBIBvaVCoFi8WCWCyGbDaL8fFxKBQKpNNpzMzMwGg0coJ9JpPBpUuXYDAY4PP52PRDWFCTZq3dbmNgYIAXZZfLBYPBALPZjBdffBGrq6sYGBhgM4tkMol4PA6JRMJ2taFQCCMjI1hZWcHy8jLMZjNWV1dhtVrZLZIKBvrdaZJSKpVw4cIFKJVKnDp1Cnq9ngO533jjDVQqFXzlK1/B6Ogo7HY76vU67r//fhiNRuRyOc5WmZqagsFgwNzcHD75yU8yxVHoCEi8fSq6yep/YGAAKpWKJ2Nra2vodrv49re/jaNHj8Ln86FareLq1at46KGH2L2THDlTqRSsViucTifsdjvS6TSWl5exuroKs9mMeDzOFEoS7gJgnSdBp9Px1Euv17OGUZiZRxEGZCxDDYZ77rkHIpEI77zzDkQiEU8qSeei1Wo5c4aeXQD8zFFBStM5olwJHbVkMhmboLhcLnbLos6mVCqFz+fD4uLiXXegO8T3Hs6dO7fnHr3fwkmpVN7SHk1uuAcJmlgDwFe+8hUOsvV4PNDpdEw7vlPcjg6G9n9q3BErgd4PvU9igOx3ArQT7lT7tZ8A6L1AzJh+mudu2VIEah77fD74/X6OHun1evB6vcjlcmyyQgXGrTrh7QaaptJ57P7772eW062CXJcBcGNwNwj1/PSZE12SCs9Lly6xUcx3vvMd/t5jx47hYx/7GORyOWq1Gjf8yOpdr9fDYDCgXq+jXC5vczAn2iLpvAGwvrxQKOCVV17heJnl5eUbzooymQz33HMPPB4P6vU6KpUKS0/o3qOzKDUp6fMl87WVlZUbrofH40EkEoHX62VndDLKIoMglUqFdDqNhYWFbU31gwBl2up0OhQKBVgslpvqB2u12gfa+Lmtwux2aIR3A5aWljAxMYFcLodgMIjTp09jYWEBKysrWFpawtLSEo+oL1y4wCYAs7OzTLUip79SqYTjx49DrVazffrFixdRKpXgcrnw4IMP8ohaJBJxiLDP50MqleJD3sbGBuLxOLrdLmKxGM6fPw+9Xo9jx47h+eef37bg0WiaqI4AdizEbobdaFJCegVtUjRaJqyvr2NwcJCd8KxWK4cUki0+2azTAyacBEQiERgMBgwPD8PhcEAqlaJSqbBNebFYhMlkgsViQaFQYB2WEP2h2gCYEkChvqQzk0gkkMvlKBaLmJyc5EWNNGPBYJAzoyhDzOfzQSwWI5lMsr2x8BqQ9igUCvHnQ1MdMpBYWlpiB898Po9sNrtt0kXRCES9PHHiBFqtFjY3N1nXSJMyoiTW63XOaCM7daIaRqNRdu8zm83cTZNKpVhYWGDKJzURNBoNlpaW+PqOjY2hUqngypUrSKVSOHr0KP7iL/4C//pf/2tYLBaUy2XW29lsNtRqNQ7mBsDObCMjI6hUKkgkEnC73TCZTLj//vvx9NNP4+zZs0wdjkajSCQSnBNjsVig1WpZq1kulyEWi+FyufjPhFQqBblcDqvVCpPJxJ2nYDCIZrMJp9PJPHylUgmZTIZqtYr19XWefJMAWKVS8f128eJFbsZks1m89tprGBoa4sndTqBQaGpGkGmNTCbjyRhRUIRrjE6nw+joKL75zW9CLpfzxPZODk+HOASwZTT1vbpH7wVy9SNNK615dwq/34/BwUHEYjGsra3tSxdCWZLUSY/FYhw8TyiVSlhcXARwexRJIej7yfwLuDGo+nZBhlW3MklzuVzw+XzI5XLMatgLGo0GDocDEokEFy5c4L1aqN3ZbTq7E8xmM3K5HHq9HuvLab8mkBtjo9Fg6uR7bapE0SmFQmHbNaGGZLlcRjweRzQa5ezUEydOoNfrYXV1FcFgENPT0/B6vYhEInjuuecQi8V4L0+n01hfX+drde3aNTzxxBPs/hyNRhEIBPBLv/RLWF5ehlqt5lBlhUJxgzOpSqXC4OAgN5ntdjvkcjmCwSDeeecddhMWolKpbHMjJxfxUqm0I+uD7qtwOMz5aWTQQpo3kufcLApGoVDAaDQik8nsW7/Vbrdx+fJlZvp8LzQ/b4vKKMROC0O/Pe8HDaJKeDweNiYgN7/l5WXMzMxgbm4OJ06c4MVmaWmJaVV08KKCo9VqcQcIAE8Xrl+/zvQ3sginrI7p6WmmqSWTSdbPbG5uYnl5mScDY2NjrN0Kh8MIh8OspSEzgVgsxlQ6YGsBoo79nXTlyCGI8qXIqlyn00GpVCKdTrOVLPBuIUeLLE0L+juPwm4fmTKQax9NemKxGBKJBBdAwpwtvV7PCxG5efUHA1I2l1CsKZxYULRAMpmExWJBIpHgqS3lwTWbTXbV6/V6HOJIcQbhcJg3YlqY6vU6U0XJVfHYsWPY2NhAt9vlIpDeq0ajYZfGxcVFiEQi3uSKxSLb51OxLhKJWF9GGjMKKKcJozATxGw2w+v1wu12o9lscrHTbDa5u2yz2XjSRZ+hzWaDVqvljWFgYAClUgnlcplzZMLhMN544w0MDQ3xFC6ZTHIxefr0abb1XVpags/nw+DgIEQiEVvGf+c738HExARTHoj+SAUamZgMDAzwlJPy4NLpNFKpFC/ISqUS7XYbNpuNrwW5sOVyOZRKJQQCATgcDvR6PczPz7P2kfj4NBUg7SZNWuv1OoxGIzqdDhKJBD9jFosFNpuN4zGq1Srm5ubQ6/XgcrmgVqu32fj3ej2mRuv1enZLHRgYgMlkQq1WQzqd5miN/ufldnBIZTwEgabGQkgkkm0RKB809qIyCkH29G63GxsbGyiXy3s+J7QWSqVSfiY1Gs0NHXmxWAyv14vJyUm022288cYbHMHSf+0MBgMbCL3++usAgKNHj7IenKZ7dAY46ELAbDaj0+nsy5zkTkAH6J0ohSqVis02yNka2NqTKbOyn/pFZ4ODiv5wuVyIx+O47777WJNI5ho7gc4HdC64XRBTpFQq7alH678vhdm0UqmUYxaOHTsGr9fL75ua+4FAAFqtFslkEnK5HAMDAzAajVhfX0ehUMDZs2cxODjI+m6SfaysrKBWq8HlciGTyfD+TBEQ5XIZKysrSKVS0Ov1GB4eZndrejb+7u/+jl+XrpVWq4VGo0E2m0Wr1YJarWZXRHI9pb2O6Pq7XQ86c4VCISiVSoyOjjKrKpFIIBKJ7HptdTodxsbGMDc3t6feiyjQJJnaj1nN+4n3hMq4vLyMz3/+82z52Y+75ZfvRzabZX60z+dDIBDAzMwMgsEgu+Ikk0lcv36dM87q9TrnkRBlgcwmLl68yONY2iTIaICoVTRVIqE/BQ8bjUYkEgksLy/jQx/6EBqNBur1Oqeu08+x2WwcKhwKhbjip68hhx/hgtT/IBiNxn1Z2lP+EznXAGBqokgkwvDwMNbX17n4op9Lm5fwINqfY0Z0B6JElEolzM3NQSwWMwedvl+pVMJms8FgMLC2iUDvD9iiztDnRgWcVqvdtlBTPl2xWES322WNHn0/OQwFg0HEYjFotVqMjo5CqVTy1E14TckBSa1WI5fLYWxsjA08KL9sbm6O3ydtXiaTCV6vlwWzIyMj0Ol0vBgR9ZUKRLPZzJo6chij60ixC4VCAcPDw5BKpbBarXjnnXeQTqcxPT0Nt9sNnU7H9MZ6vY5AIIBebytQulAooFQqQS6XY2pqigsNl8uFP/zDP8RnP/tZzmGjYlomk2FqagrVahVvv/02OxaSHs5isXCuYbfbxXPPPQePx8O6BK1Wi3PnzmFzc5ONOqj4q1QqPAUbHh5mA42VlRV2QW21Wmyk0+tt5d3Re1tdXYXL5YLX6+Xw9Vgshnw+z/ltCoUCzz33HMcTULxELBZDrVbD0NAQh78ajUYMDQ3xs+92uyGVSrG8vAxgy42ONAaDg4OQyWTY2NjgwlH4rNHmRg2OUqmE1dXVbc0HoTHAXs/p7XS3D/H9h6effhpf+tKXsLi4eAO74HYCpt9PkFEBsH2K0uv1kM/nodPpUC6Xb+raR/R6ohXvlmfV7XYRiUSQTCa5kUPPWT+VnZpg4+PjePzxx1EoFBCPx3nyTm5vNysabxfUNLwTUDN1twKF9GS7sQSEenW1Ws3mR/F4nDXa/bjTgqgfyWSSXTuJwrdXwUdr+m7xOzqdjvcjYraQDl3ISiK33r2GD8LPh0zkjEYjyuUyQqEQ8vk8FAoF3G4367QGBwdhMBhgMBh4n37llVeg0+kwPT3NevxAIID19XW8+uqraDabCAQCzJ5ZX1/HysoKotEoNwWoMUODgUKhgHQ6jWw2C4fDgaNHj8JisfB+TFmf5DZKqFQq7BdAmnmSpFDodbPZZPfN3a4HsFVUDw4OwmKx4Pr167h8+TKGhoYwMjICh8MBk8nEsp1+BAIBADub0gihVqsxNDTEEQMHIb96P3HbrowWiwVf/epXDyRg+v0CTU08Hg9rb4rFIp555hmcPn2acw6mp6fZ7W1xcRHdbhdDQ0NseTs4OMgCx1gsBrlcjkgkApfLhXw+j5GREfh8PrTbbSwsLCCfz2Nubg52u50fBAqbJH1NLpfjfCRy7APANqQUfki0KFosaAwMYFfr1r0cq4SB2rS40oExl8vxey0Wi5DL5VCr1dwdqdfrHJxJI2gqsigjg6iK/Q8S6euI/td/eKDX6ac7AFu0ObfbDbvdDqlUynQFuh4AuFCgKZlOp0Mmk4FWq+XpI01X5HI5SqUSBxYWCgWeoBCfmiIJKP+LulR6vZ4NXChUmiZc5XIZEomEA8WpcCfnP+roEMWj0+mgWq2yQyUFQFMhQlNWOmz0ej1cuHABWq0WZrMZwFanaHl5GW63G71eD8vLy1zkrK2tQafTwWazcZYaFanUdNBoNPiRH/kRPqxcuXIFp06dQqPRYAcucrHK5/OwWq2spWs0GohGo7zB1Wo1XLx4EUNDQ2zoQYUpda+NRiNOnTrFHP5MJsMOqFqtFmNjY4jH4wiFQtzB6/V68Pl83MGjz79SqaBer/O1FjY2SGP20EMPIZvNotFowOVyscaQTD0ymQxfI7rewFZBZDKZMDExwVRmuVwOlUqFSCQCu91+gz2uUqnkqTkFsqtUKlgslm1dewpUvRnomlA4/KFz4yF2QjKZxKc+9Sl88Ytf3DFg+k612u819Ho9bDYbU9yF6HQ6iEQiUKlUcDgce+5tQj0rxZdQ08vj8fBzuLKygqGhIZjNZi7K3nzzTeRyuRueS5qqDwwMwOPxMAvn0qVL3FwE3rvm9EG8Lv1OtH5RxiaBzhO7rS/C91Cv19nEjfawgyrAaM0dHh5GtVrdJmvodDq8V/RPhR0OB1wuFzfACOS2uxMqlcq2wGbaS/p/l3a7zXEO+wE1jSuVChdEKpUKw8PDsFqtiMViWFxcZNMwosSfOHECY2NjmJ+f5yYqNUeJplytVvH3f//3GB4eZmv9er3Oxl7kBimTydhRUnhGzOfzWFpagkwmY1dIMuHqB53HKpUKxxORFIC0+KQx3+3zHx8fh0gkQq1Ww7Vr1/isVa/XkUqlYDKZkM/nueDbCSsrKxCLxVCr1RwfQDRiYbOSmvMymeyWNGt6vR4ikWjHM+v7idsqzC5duoRYLPY9VZQBWzdyvV7H6OgoZ1Zcu3aNLepDoRAHQZP4Lx6PQ6FQcHFC0xoSrBqNRjQaDbRaLWSzWfR6PVgsFqbf0UTR6/ViYGCArdxjsRgikQjT2oi3u7GxwUJip9PJHRuLxcK8aqKXEWihpE2of0Hd6wBHEx3gXcdFeng7nQ7y+TzbmKpUKkxMTLCTDplECEW2AHiqRwfIfotaAl0vegCoIGw0Gkgmk8hkMju+d4oJoOJYpVIxNZU2BqJ7iMVi7ihZLBZYrVamuQ0NDcFkMkEikSCXy0EkErF+i4KUpVIpb2A2m42L+0QiAalUysHirVaL7xvivrdaLXb2KZfLPCkCtug7tBgR1W52dhbtdnvbArPT4kBFGtEPFQoFj/5JLP/8889jbGwMSqWS37NWq0U+n2c+dyQSgVwux6uvvgqtVssHmGPHjkEikbBjVjKZxIULF5DNZjmI1G63w2azodfrQaFQcDMhHo9jdnYWg4ODcDqdePvttzE3N8eL+OrqKsrlMt/fdN8QBaZcLmNjYwOVSgWBQIBjIvL5PEqlEmQyGRfldA+QYJxyciiLjYpJo9EIi8UCiUTC7lZqtZodE81mM0QiEbLZLGq1GofPk17SbrcjFouh0+nAbrcjEAggEolgc3OTp6cAMDAwgG63u21zI4cp2ph9Ph/fR6VSCaFQCFqtll2o9jpoCgPZDwOoD7Eb5ufncezYMfzmb/7mB/1WbgvFYpHdWoGtfUGlUjF7gZp1+3U/pKgaAq3rJpOJdTt0sCPdayaT2dEMhA7voVAIqVSK85Fupo3ZCbdjmU8H8H4tj1gshtlsxvDwMIAtU7Obga5j/zW8leJP2Bi+XWg0Gm6EpdNpnpTQ504hxkQFp8a0UAvf/3putxuNRgO1Wg3RaJQbwHv9Hv1/3m2NvZXPK5/PM/uJzOPa7TZisRiCwSAXXLS/dLtdBAIB1oMbDAbMz8+jXC5zwaXX62G1Wnla1ev12JyrUCggEonw/T00NIRQKMT6Zyp4yMk6HA6jVCrx/k/nur2uEzXxFQoFDAYDkskkM5L2Ak1ghXsYsUuIGkombLt9VvQcky6OJCadTofzRjudDrtfi0SibcVoIBBAsVjc9fXpOf6gm563VZgFAgEuSr6XUK/XOZcgGAxic3MTdrudXVoojDiRSDBvVqfTod1uc/ZBtVrF8vIy6vU6h+oSlaxerzO1K5fLYWVlhd0UbTYbWq0WUqkUUqkUQqEQF16JRIIPo8FgkA96G/8/e28eI2l634V/6r7vs7uq73Om59xj1mt7vWuvdxNbDiGJIQLZBIMRBCIihEQShCAgOcAvIIIiQgiChAiJBOw4ETnWZxx7vfbOXrNz9vTd1VVdVV33fVf9/mg+332rprqne3ZmZ9burxRlPd1dx/s+7/N8j8+xtSVyqPQ6Y/I47CHo9Xp9/041uXs5NBjNZlMSWQp+2Gw26Sa2220Z+zebTely5XK5vs3NbrdLAcSg0bfL5RIYJbtUhHYNg8pyElYqlZBKpTA9PQ2LxQKTyYRCoSBCG4FAQOBu4+PjMJlMUlAR1sLNnhAGQgCU8MxisQiDwSC8rHK5LJt9JpNBs9kUu4ByuYx0Oi08OovFIsUyJ11qtRqxWAxGoxEqlUpIy8Puk8FgEB5Zq9WSSRnXJDd9QiGtVivMZjNsNpt8D/6eTqdDIBAQ2AGLBqfTCYfDIXCG3d1dXLt2DWNjYzh16pRYBQQCAezs7MBgMKBYLMJms8HhcAiWnfxMeo8B+4IcWq0WW1tbuHDhguDzWTwlEglsbW1JIVur1cQYmkbiarVain4S/7e2tvqaH4Sx6vV6+X7klVy9elWuNa9Jq9USxUWXywW9Xi8d+FqthkgkIgkBD8Ferydm3SMjI1JEU4SAojHtdlsOTSpBcl3v7u4KrJOHEEnPg7zJwbgfSdBJ/ODHxMSENMeOay3zKASbnMoJx7Bm43HONeW5WKlUUCgUJJkkqqLRaMjv8d+Bd4SdAAhSJBqNCgT5XpokRJRYLBZpGB8liAjQ6/WyF5DXroT1G43GA1+TMuwPaipAuD/pAHdLcpvNJur1Ojqdzh2CGTwXO52OTH2UzeTBIM+8UqkImkL5Pu918KxRmhU3Gg1sbm72oYGYbzz77LOYnp5GJpPBlStXJN/jOT8/Py9CccwxKBpFGCmROzzjO52OyNpzKud2u2VAoeR0LS4uwmQy4caNGzKtZs6hROVotVqsr6/LlO4o2gaD9k4Ms9ksdBBlrn1YUACMDXhlg4H/Pex+VyqVA/eNu0F838u4p8LsX/7Lf4nPfe5z+NVf/VXMzMzcsfkfxbzyYQXFJnZ3d0U6c2VlRbhkzWZTZE39fj/8fr/4SnGD4YIlPI7y4eVyGd1uF5ubm1Cr1chkMiKhzpFrr9cTeW+VSoVr165J4qnX64VvMzk5KWo3nO6l0+m7GtwpNyx2aIDhi26QEHkQMZcdh93dXTlQgH1oFR8CbgwkifLachLRarWGvna73ZYDqtlsIpPJSDeMRQwLsXa7LTj2RCKBTqcj/03YYKPR6CuKVCoVbDYbnE4n9vb2UC6X5TClwAqnkvweg5+PcMJ6vQ6r1YpqtYpisQi/3y9QCr4mu0EGg0GKMvrLEYbYbDZRKpUEBkAoHbuv3W5XOHmdTkcKFR5IlM+lAiA7azs7O7DZbOKxwumTUqI2FApJQaBWq0WFia9rMBiEwMvuk8lkwvj4OAKBAPx+P1qtFnK5nMjSZ7NZlMtlGAwG9Ho9IfOazWaxV+h0OhgfH5fvlEgkpIClObTX60UoFJLvXKvVsLKygmAwKBPbWq0mqoelUknUr1QqlUzdHA4HOp1O3zWkUiTwTnHHNctra7FY+ngFnCxSCMRisUi38/z58zKp0+v1Asew2+3Q6XSoVCrCvyAEk/DPbrcr093BCelJnMS7jcnJSXzkIx/Bz/3cz+Ef/sN/CI/H0/dzniuPcihhwQc1JJTFyXGCkzE21NjIMplMSKVSmJ2dlUZrNBodypli87RQKNyTSTShYSxIjhpM5pnoU9Ci2WyKci/wTiE7MTEhEu3c6wgpf5BwS+5rR3kPnicqlarvWna7XZRKJaEJ1Gq1u0K4e719b0n6htKH8ziKjw8iaPOg0+lQq9UErk+qRKFQwPz8PKanp+F0OkXpkuuDZz7zDNIu2u22KDzHYjGcOXNGfP8SiYTkEzRjByCNzFqtBofDgbm5OTmzTp06JT695HM6HA7s7u7KgIAKkclkEnt7e/f0DPKs1Wg0UlxSRO8oTQrmNgD6hGju9lmG0WYYyuKOnqTKHPpe417EvO6pMAsEArh27RqefvrpoT9/VMU/WEgQqtbtdgWWxyiXyzAajSLDTaELJnhUxCPfgwUTVZwA9FXklF/nKNtut8tmubm5KQqRSmy20+lEMBiE2+1GpVKRz3jcB4DiIMB+EVkqlfr8lfR6PVQq1R0wD8LDuCCJCyY+n4UmE192TdjpsNvtIj5Bs11lR4VGks1mU0iehHWw40VREJPJJEa/jUYD7Xa7T06919uXkld6n5hMJjFcbDQaMBqN2NraQiaTkakaVYfYReKGN2zt9no92Qh1Op0k/WazWSCMFONg14ebDSc/NMJm0dHr9aQLxmReWXSr1WqBVSqx7rxO5Ptx4svrys07l8uJSTk33Xg8LlNKrVaL2dlZGe3H43F0u/vGl/Pz8zhz5oxwu6xWq0AVCZWpVCpiO5HJZGQtscgmjIQbOQu9RqOB6elpKXDYlOB38fv90ind29vD7du3YbFY+tZDMBgUiwCqWFItlWsHgBxmvGalUknEcjgdbLfbAqllwkNbCpKcOZklx5CwVGLdg8EgcrkcMpmMcAw5AaTyo9vtRrVaRa1Wk8/8qO6TJ/H+j9nZWfzTf/pP8Ru/8Rt3/OxRF/8YFgd1sXmuKYP77GEJFTlEhOJ3u13Zx6empjA2NiYcN6XCIJP9mZkZGI1GscS4FyPcQU7qUYOJpbI4q9VqglQgAqLRaOCxxx5Dt9vF9vY2Njc3ZQJ1P/ceJYeJCfJBMMNhQcl1FozA/vmn0+kOFBM5KHq9HorFouQhzCcO81p70KHT6eBwOOD3+wVlFo/HEY/H4fF4MDk5ia2tLbRaLVy9elXskC5duoRYLCboDq/XKyJgbPQx1+QZv7S0JCqPZrMZ0WhUuNL0UGURv7OzI+vZ6XSiVquJvYNSw4D3sVgsQqfTyYSLud9h+gUH/YyTXdIn+L+P06TgwID0kIP2CCWCZ9jUTq1Wy/pTft7DJrPHiXt5jXsqzH72Z38WL774Iv7+3//77ys4o9FoFP8E8rS4AJmoUU3P5XJJssdOFAsydh4I3TtoRAvsL4R4PA6j0YhAICCeG8TRcrqxuroqk4DR0VFoNBoRGSCGd9iiHYZTp9pfp9OBxWJBqVQSmB2T43a7Ld+ZXDDla5IXw42eDzZVqwgtYxKdTqdhMBhko/B4PDKWJgSSQiBMsjmxow8aN3fCICgzTyglMefAOx0NHkhOp1OmEBTm4HciX4zfoVqtwmw2y30j9wjYf0j5GoMHCw8cbiQ0IacaIf838A6Gm+uMhR+hdnxtfj/y4PgZOMHhAUdeBCWHqfpFhSybzYbz58+LiEUymUS5XBb+WqlUwsrKihDfg8GgTG2BfQiDwWAQYQx2wkqlEtbW1qDRaFAoFGCxWBAOh+H3+2W6RDET3l9C/1iAU7yGgjhcl1yLwDvQJKqfshB2OBzodrsiDx0Oh0XGntMx5fNL1cNcLif+aDSFpwccpZudTidarRYKhYJAjolJJzzI7/fDZDIhGo1id3dX+KMbGxsAIJwxdnubzSZarZb48BUKBZmkk9PCa8X3fphJw0n84MXW1hb+2T/7Z/iVX/mVoeIfj/q07KjRbDZhNpvvSAC5R94tlLwjJq/hcFjsPZjgK89Xno3kot+tAHyQwURWq9XCYDBgZGQEc3NzMJvN8tmpSkyxKavVKvvdQYnsYZNI5d6lbBay4cXm93FMogetbpSvea9BqgIbp4Tc388gfYKmzcNCr9djdHQU4XAYFotFptVUaWQD0GKxYHNzE1tbW5iYmMAzzzwjPO7d3V14vV4EAgFR/IzFYtjc3ITL5UIoFBJ1bErDs7Cl1Q+Lj1qtJgrMbJgqrXhu3LjR1yCuVCry3Xj9+HM26xlKXhzzvIO4Z8x5+BoajUaQaUoFbKVYWyKRuGOa5nA4YLFYhK5xUAyur8FQ2j4dt7HwIOKeCrPt7W18//vfP5L3yKMULCIGCxyOmTUaDfL5vMhRUyGHmxEfIKq3cUPmQdDtdqV7VK/XZWLEhI4cJUKg8vk8FhcXJenkaJdwvr29PZlwcbPkoqWvEosYcqPa7ba4shOXTeNnAKIKSKgB4Wi8Jsr/poJcOByGy+USvhNNe9mZbDQa0Ov1mJiYEMwyuVu5XE4Iq0zgeS84ZQH2u4dqtVrgh4QtNJtN7OzsSGGj5PXxulssFkxOTsJqtaJcLiMajd4xBeR3YyGgfIh5qAQCAYEXRCIRtFotkVbnulGpVDCbzQLPy2azcLvdcDqd6Ha7cDqdUnw0Gg1pBHBj4Ahf6UMzCLNQKlpqtVopUHndlZwlp9MpEEutViubf6VSwe7urnCrWPiMjY3B6/Wi3W5jbW0NpVIJWq0WH//4x+H1elEoFPDd734Xm5ubmJychMFgQCwWk7XMdTQ2NibKZuSYxWIxNJtNjI6Owuv1wmAwiLz066+/LmbLALCzs4NarSbrgesum81KF5rkYjZQlPBUeoONjY3JWuSUlJBFCuZQNptrhkWlXq+XYozPltVqBQCRvZ6YmIDdboder8fKyoqsOeLtCTfh/UmlUiIowiYOi12XyyUwZgrFrK2t3Re4xEmcBCMSieDSpUv4pV/6pYf9UR54DIOoKblidwuVSiV80EajgWKxKI0UepGOjY0Jl5U+hJubmyLYQ8THw5iAMxew2+04deoURkdHUavVBIK9vr6ORqOBeDyOxcVFmM1mbG5uimfo4L6j0Wjg9XrlOgyG0+mE2+1GuVwWfjVzDXJvacdy1OkHfTKVQQGHew0WDLR0USblFBR5N56vAERYi6qLw4KIEa/XKyghNnfHxsawsrIilAc2d8kZZ1Nzb28Pc3NzePzxxwVmmEgkkM1mBfpfLpeRzWYRiURknWo0GhSLRXktlUoFl8uFU6dOYX5+Xux8eD6lUikRxzoslLkLKQTMT/V6vai+2mw2yVWUweYGEWFEWpH+wXOcn/f8+fPCC+VrsblNKscwJUkGp6gHBRFfD5qPe5w94p4Ks9nZWcTj8fddYcYFxwKD/lhKWWt+J/qPUTGHeGfl4mAQ3tbtdgX+yASVniu5XA7Ly8uwWq0IBAJwOp3wer1Qq9WyqMhR4YIj5ItTl0HhDI1GIxsPcd3swg/y4Qj9UxKGlbw54J3pG3/f6/XKFIBFEeGBlPjOZrNIpVIyWctkMpiamkIoFMLOzg58Ph/GxsbEU2p2dlamVixAeAhQaKFQKCCZTMJkMiGdTsPhcEhRQkhaNpuVKcjY2Jj4WR0kosANZJgHFCeG7GRRVp9qfoT0sZui1+vh8XikG8UJZD6fx/nz50Wmngk3/cD48Cs9q5QPK4toFtwU5KAcsFJ5CIAUitwoi8UirFYrer1eH6RubGxMJnMs+ClxazQa8cwzz8jPO50ORkZGYLPZYLfbYTQaMTExIeqksVhMGhM0VCbcT6vVCqeM98psNiMcDuNjH/sYvva1r8n96/V6mJqaEkw5u7nlchnFYlEw+NlsVjZ+FsNsniibAzSDJcw1GAxicnJSxGoqlYrARer1uhhuckpbLpflGhNWQWin1WqFWq0WX0O/34+xsTERhmGyRo6qxWLB3t6e7Al8Lfodud1uaDQa6Xa+3zxWTuLRjtnZWSSTSXS73Xc1dXhYMch9PizYVFOq3h0HDmU0GuHxeASWDew3SGdnZzE/Py+w7HQ6jVgshng8LpxjwqOO+lkfRLBxWywWEYlEoFarxQsqmUzC5/Mhn88jFApJc5V7UKPRQD6fl3xGo9HIxEOj0fQVZhaLBb3evuL02NiY0BA4GSO0npMHnlvv9rtxf77XIJ9Q+ZojIyOw2+24devWgRZDR4lMJoNMJiPNz2FroFqtYnNzUxAcpFkwD9DpdLBarZiZmUEymcTrr78uzUU28efm5qQA478ZjUZpgq+trckzk0gkxAeQXDal+fPi4qIIagEQykUmk8E3vvGNvtzkKKHX68VzlrxxFpdGo3GoRQFzW5fLJddnb29PEC9qtVoa52yQpFKpvuKXmgMU3nq38V40Ro/zOe/Zx+wzn/kMfvVXfxWzs7N3VJrhcPheXvaBB5NUs9ksBQtxzJyIzM3NIRAIwGKxiOoeYQKESQ0aLyoLNRZwFIJg0lav1xEOhzE/Pw+32y0S/IPS2k8++aQ4tEejURSLRZEPZlGhxMQqlXNUKhUmJyeRSCRkobEYASAjZiX8AXhHhhvYL1L4UBNaxo6MWq2G1WqVjbvRaGBjY0MMhjc2NsQ8OZ1OY3t7G0tLS9DpdEgmkwgGg0JELpfLcLlcIhIRiURkYkEBkVQqBaPRKCN0p9MpGHni/ukVx0LGZrOJGTHhfsoNflj3Rq1Wo1AoCFeqVCphZGQEgUCgb5phNptRKpVE8cxutwsXikqZVD8kSZkwPL4P7x03cuXDajAY5H7Ry4MNAxae5Mzx+1SrVUSjUWi1WqhUKjGuDofDeO655/Cd73xHoH86nU4mQZT/P336NObm5qS7Su4FVSfZtDAajVhcXIRGo8GNGzfw8ssvw263IxgMCpdqbm5OpkD0buPz0Ww2cfbsWaRSKRQKBfh8Pik0WYxRNp5qS7lcDuFwWKC9hHBGIhHhhJBH6XK5BGLkcDiEd0eCtJL4vL29je3tbUxMTMBisWB7ext2ux1zc3PQarXY3t6WQvXVV18V6W6ae3PNclLGJokSzkobAKUKZLPZhMFgkC4pVUNP4iTuZ3g8HiwtLeFv/+2/jZ//+Z+/Q4zLaDQ+0gJd3MvuxqlWq9XCx+52uwI/PE5BwEKEnF8ljKlarUpiSxVHYD9nGB8fx8LCAjQaDV577bVjeSUNC0K72QBl8j7IMR4WhBZeu3YNe3t7CIVCGBkZwaVLl2A2m5FOp3Hz5k289dZbaLfbKJVKYtNiNBqFa2SxWGCxWLC7uytc5Gq1CoPBgKWlJVQqFeE8DXLTa7WaIHxYnL3bYL6Rz+eFBziY3A6zB1LGsIKJxZHX6z3QRPuwGHxNn88n1g0UY1GiqHK5nDTVKQDC/X90dFR8WZUKjSzOSJMwGAzY3d1FLpdDsVgUXYRB8Q29Xo+xsTFotVq8/vrrd/hqZjIZXL9+HW63W2xbiLAZ1rRmKIsmNkEB9CHEBvlZm5ubd7wOTbIpyKb0LhtUpmbeRkqA8rMdRh+611Cish52qHr3UG7ebeT3qJHa6T8WCoVE9po8lPHxccEf7+7uYmlpSWB3lNZkd6PVaomy2mAM2wAGYXkjIyNYWlrC5OSkkHO3trZw+fJl5PN5jI+P47HHHgMARKNRvPXWW1IE8cEg6ZNCHtwMCBs7deoU1Gq1dOHPnj0Lj8cjxUKhUEA8HodWqxWFSvJgWIB1u13xFWk2m/LA5nI5+fwjIyMC++LGWK/Xsbq6imvXruHZZ58FsA975Yh6Y2MDW1tbgp3m9ykUClLY0DOMghAU6eCDz41uZ2dHrvHCwoJABehBk0wmUSgUBGLm9/tht9v7OjpMvkOhEIxGo3iilUolzM7OIhgMIhKJyKSDPDriylkks8AiXMBoNAqchv4y9DwjdG6QF8gNffC/gf1Ei9Mdikzw/Wj2OD09LdC5nZ0dXLhwAefOnROO4cbGBr7+9a9jZGQEk5OTMsFrNpuYnZ1FKBSCWq3GtWvX8J//83/G7Owser0eHnvsMej1emxvb8NqtcLv90OtVuPtt99GpVKB3++XiWa73cbOzg5isRiWlpYEUrO5uQmHw4GxsTE4HA5YrVYUi0Xs7OyIJD0AKY4TiYQc/jzAeP+o4sQEig0J8tKYXJEzSBgjD4nBhI9/Pzo6irGxMVitVrGtYNeScCYKDdy6dQunTp2CVqsV8R+HwwGTySR8tnq9DpfLBZfLJQU513MqlcL29rYkQ+RA3q8oFAo/MDyikzh+vPTSS/jEJz5x4M8fNfEPpT/occJqtWJychJGo1Hg64SOv5ugCNXExIQkxErOFJNfcsyuXbvW9/dsAh21QDQajXj66adx+vRpsd/gfhGPx3HlypUD/Q31er3kLzw/Q6EQxsbGMDU1JWc0Ie9ra2u4deuWQMmJKCDHjmIRi4uLsNvteP311zE/P4+xsTFsbm4iEokcKB5it9sxPT0Ns9ksPo/HuebMzQY573q9HiMjI9KkVoqfEKo+7Fozbzqo2DgMWnbQz5SFyLCgarPH4xFxGeVZbrPZMDc3Jw3kp59+WsS61tfX8cd//Md47rnnYLPZBOlhMpkQCoVgt9uRy+Vw/fp1LC8vSwF/+/ZteY/Z2Vm88MILsFgs+OY3vymqosrrY7PZRAnaarXigx/8IEqlEl5//XWRzR8Mn8+HCxcuwGq14u233xYE0d2C1Bley6eeekrM41lsR6NRWY8PK3Q6HcLhsNgsKG0zHkTc7Yy+p4nZ+xV6QxM+ZaFjMpnE84HYXk5kKpWKECQpiEDs6+BD63A47sDT8ncZlHylf0gymcSrr76KpaUl1Ot1vPnmm7BarTKepaISH25C+AwGA+bm5mA0GmWK0uv1kEgkUCwWpSvh9/sRDAalK8IRscfjwcbGBtbX16Ubx009HA6jWCzKA6ok5obDYSlK6JvFLl+1WpWOzsWLF1Gv1/H222/LJpPL5fDyyy/jwoULMBqNyGazsNlsCAaDMolaXl7GxsaGFDxUsCR3ijAV5bi9Wq0iHo9LEUbxkHA4LOaH5CKZzWZMTU2JUEipVMLXvvY1XLx4Ufh0y8vL6PV62NnZwdbWlrw3p14ApPvl9XplbZRKJdlEOSUhB0xZNColoJXdPuUGoCzQgH3IhEajQSAQwMTEBEZHRwU7ns1mxQj9ox/9KBYWFvD444/ja1/7Gs6cOSMHgMfjwfj4OK5cuYJ4PC5kYp1Oh0gkgj/7sz/D4uIi/uAP/gBGoxEf+tCHsLq6KgnT7du3Ybfb0e12MT4+jgsXLuC1117Dq6++CrvdjpmZGYyNjeHJJ5/Es88+K42MWq2Gxx9/XMwrv/71r2NhYUEmfZwe+nw+jI6OCgzn1q1b8vdOpxM+nw/lchl//ud/jo997GPiWcbrure3h0gkgnq9LoVsq9XCxsYG9Ho9lpaWoFKpkMvlZCIG7B9SRqMRyWRSPg+VLdl8qNfruHXrFjQajRSHq6urQrKfnp6G3++X5geNo0lIZnea0s2DRGaz2XwgR+EkTuK48cwzzxx6RjNZf79HuVxGMpmE0+m8qzHuQTEMNmkymTA3N4dgMCjcHTa9KFqwtbUFn8+HVColBQXff3R0VAzsa7WaFHpKmCUbehqNBuFwGK1WC6VSCU6nE4FAAH/+53+O06dPQ6fTSVHFHEUZ5HONjIwgk8ng/Pnz8Hg8UrCFQiGZ9nF/ojeW8vs6HA5Rl7ZarYjH49ja2oJarRZBiVQqJWJbg9cM2C+wr1y5AuCd4pS5wyBlQlm89no9LCws4NSpU2g2m7hx4wbW19cB7CfMCwsL+NCHPoRms4lvfOMb2NnZQbfbFfn2gwYFR5HWPyh4jg8WYJymHiTYxEnOYYV0OBzGyMgIvvSlL+FjH/sY/H6/IHSmp6fxO7/zO5ienobH44HP50Ov18P29jbq9Tpu3ryJ9fV1MdwmH5DQZVIUTCYTAoFAH4yTUalU4HA4cPbsWdhsNqRSKSQSCaFSHFSQEvJP4TWKy1BAjtecoVarcfr0afFQA/Zrh62tLWSzWSksgQdXAB01er2eWGiQQ65Wq7G3t/dQPs89Tczeb6HsyOn1epw+fRqdTgcrKysA9l3EM5mMbEyEv1ksFgSDQYHVJRIJWK1WGAyGvgV/0ENKaACVmyiZSrU+k8mE+fl5ABDiZjKZFEU4JoadTgfr6+tilMypRT6fx9bWFlZWVqQ4A945bJxOp2DLqUb33e9+F48//jjOnj0Li8WCer2OeDyOW7duIRaLIRQKYXt7G7lcDr1eD/Pz8xgfH5ekUknKpaUAp16clhDm8Nhjj8Fms2FjYwMvv/yyQNRUKhU+/OEPCy+LfmC1Wk2k+Hu9HgqFAra2tpBIJDA1NSUEbcIHAUgnjV08j8cjGPJqtYpYLIZut4vJyUmBL/j9fqhU+x5yp06dwsTEBPL5PF5++WWB5qbTaeRyOSQSCTGlpqonY/BAsFqtmJqaQq/XQzqdRjqd7uM46XQ6TE9Po1wu48aNGweuV3LSfD4fTCYTtre3EQqFZIoViUSQzWbh8Xhw48YN+Hw+hEIhZDIZfOYzn8H4+DhUKhVWV1dRLBYRDoelOCcv8Hvf+x729vZw6dIlwWuTCE+yuBISmEgksL6+Ln5mwH6Bms/nZapEIq7SiDudTqPX6wkPZGdnB2+99Zb4fHESxmvNg5rPIJUTP/nJT4ph+s2bNxGNRjE2NgaPx4Nms4nt7W3EYrE+KAR91MbHx0UgJxqNinUCAJneki8wrAvICWcwGEQwGJR1WC6Xsba21kes9vl8cLlc4mtYKBTQaDRE3YqqjuRRGo1GORzvV5xMzE7i/RT3OjG7H8HzeJjcPc9uv98vaoelUgmrq6uIxWLQaDS4ePEi5ubmZE8tFot46qmnMDk5iXw+jzfeeEOmPExa7XY7AoGA+GFWq1X4/X6USiWMj4/j5s2bePHFFxEOh6FWq5FOp3Ht2jVEo1GB+tPLqlKpIBgMYmZmRvb49fV1xONxjI2NIRAICG+bxeNbb72FWCwm56HP55PmIqF9yrOt1+vhox/9KJxOJ1566SWMj48jlUqJ4vJBodFohMrwxhtvyL8HAgFBBn3ve99Dp9PB5OQk/H6/oC6oems2m/GJT3wCCwsLkuesrKyIrPuDCCUKZliwkVgul4cqAQ4WrkRlqFQqzMzM4K//9b+OkZERNBoNrK+vo1arYXFxUYqcZrOJjY0N/O7v/i6effZZzMzMiAFzqVQSLjwnO1qtFtFoFLdv38bq6qpoF9jtdmxubt6Rm547dw4f+tCHZM3dvn0biURC8olBeKeyWBtWuHm9XiwsLKDb7eL69euC5pqdnYVWqz2wSTQ+Po7p6WnxWTsurPRBCe5Q+ftBTvDu28TsL//lv4w//MM/vO+/+14GjXNLpRKSyaQQP5eXlwFAhDqsVquIEdC9npunz+e7Q+HloE4dPZ2AfWGPSCSCSCQCs9ksxQ5hTSsrKxgZGUE4HMaVK1ewt7eHiYkJ4ZsVi0VkMhmkUimMj48jGAzC4/Hg2Wefxcc//nGkUim88cYbaLfbeOyxx0RiNJlMYnV1FZ1OB8FgEJ/+9KeF/1Ov15FIJHD9+nWsrKzIZOWFF15AIBAQURH6Nr311luIRCLQ6XTIZDJwuVw4c+YMJicnEQqFMD4+LlBCHgTlclnG99vb2wIR9Pv92NrawtjYGPx+P6xWK1ZXVxGPx0VVKJfLCayj1+uJqTCLMr/fj/HxcSlqKXPOCR5VoxYWFsSQkIISzz77LM6cOQOn04lisYjf/u3fxk/91E/B4XDgj//4j0VEhJ0eTuHYRaPcLLkB+Xwer732Gq5duyZTxN7/k7NnETIyMiJiFQd1s4D9RgGhnFS72tvbw8bGhkylaCi9tbWFT33qU8I502g0UthfuHAByWQSr732GvR6PSYnJ2VaSFL48vKyHMiVSgVzc3MIh8MyUWSjgKqber1eiuhisYhKpYJarSaNCwpuVKtV3L59Gz6fDxcvXhSI387ODhqNBgwGA+r1uthITE1NibRzOp3G1atX0W63MT8/j0ajgf/9v/83fuzHfqwPErm8vIw33nhDuHBUTa1Wq0J4pmk5lZ7W1tb6VKUKhQJSqZQUl4TwUj7fZDIJZ3FjY0Mm7kohnomJCUmWNjc3sb6+LjxVJi6U9S0UCn1wkWGqVSdxEseNt956C//3//5f/PN//s/v6+/+oMdgR5yQZDa+/H4/arWaTPAHZbeJ3mCBUyqV8Oqrr+LVV1/FhQsX8NM//dOw2+1YXV3Fq6++ina7jfPnz2N0dFSgz9FoFF/5ylfQbrdx8+ZNAO9MwgAId5vCU4uLi3jyyScxOjoqTeFMJoNbt25hbW0NWq0WMzMzeOWVV2CxWPDUU0/BZDLh5s2bmJiYwEc/+lGxQSFssdvt4urVq4jFYoLImZqaQiwWw5tvvgmv1wur1QqVSiVKtTw7Dgqef4PB9yYigmgkKgdzf6TEv9/vh0ajQTQaxY/+6I+KQu6DmikcVGwajUaEQiGsr68fOElxu924ePEiOp0Orl69Cp1Oh0uXLiEcDiOZTIrxtclkEjRNLBbDf/2v/xVPPPEEHn/8cdjtdlgsFng8HvzJn/yJeOdyIsbiPJPJwO12I5fLiWfb6dOnZSpHtcf19XVpOIZCIfj9fmxvb+O73/0uOp0OpqenMTc3h0gkIo115bW9ePEiUqmU8M6VYmYUxlF6AQMQAbRhQdRJPB5HsViUSdxxYm5uDm63Gzdu3LjvfLOHCalkHHliRpjfUYIckEcljtKRY7eJXQh2JSgp63Q6YbFYkMlkEI/HAbyj8GM0GvsgSsMWCo2AOdYn2ZjJLACsra31/c1zzz0HnU6HV155BaFQCE6nUyY8FA5hArq7u4uXX34Zzz//PJaWluB2u9FqtfDaa68hnU7jzTffxAc+8AHBjY+MjEiXgx09Kua122288MILGB8fh81mE15bLBZDOp1GIpEQJ3iLxYLbt29Dp9Phueeeg9/vh9FoFDz7n/3Zn4lH2Y/+6I8iGAzi2rVrGBsbw5UrV/D444+LgESpVBIoKQ2MlVjk7e1tmEwm+P1+uFwuGaGvrKzIhkdsNhNyk8mE6elpsQygDcKTTz4pHLvvfe97OHv2LKxWK7761a9ibm4Oer0eOzs7AkfVaDQYGRlBq9XC+vq6jODtdrtI6nc6HZhMJlkDg8+AzWbD6OioiI2k02m0Wi1RQaQQRSaTwdmzZ2XqEo1GUa1WMT4+jjNnzshm/vbbb+PHf/zHZapFuGUgEOgrDAqFAra3t/H222/D5/PB6XRic3MTb731FsrlMsbHxxEOh+HxeGCz2aBWq9FqtUTwolQq4Utf+hJeeOEFuN1utNtt4Y5tbW2J3x3hKORWZrNZ/J//83/w8Y9/HCaTCSsrK1hbW8OZM2dgNBqxvr6ObDYLp9MpEvvEvnMSrFKppKtdKpWg1+vlEOB0k3AbJjLkK9AGg2pkvV5PpsyDzZSpqSmxtAAgXjF7e3si/uPz+fqEW1KplLyv3W4X0aPt7W1UKhX5Xap5Au8N//ZkYvbDFy+99BL+/b//9/jyl79819/9+te/jt/8zd98ZHhmD3NiNhiEj3GaPTY2hlarhe3t7UO9uex2O4rFoiAWeK7mcjmUSiW8/fbbiMfj8Pl8WFpawunTp+FwOFAul/Ebv/Eb+Bt/42/g9u3b+Pa3vy2vOTIyAr1ej93dXZjNZszMzAjU8PTp05iZmYHNZhPrj2Qyib29PdTrdbz22mv4i7/4C3zsYx9DKBTCF7/4RTz55JM4e/YsRkdHoVKpEIlE8Morr+Dtt98GsI/4OH/+PDY2NpBIJHDu3Dns7Owgm83KmT4sAoGAeFqyeBvMZe41LBYLlpaWcPPmTRgMBly6dAnb29tSwLJpdpgv23GDHELmc/T+CgQCcDgciMfjdxQijKeffhqPP/44Op0Ovvvd78Lr9eLChQt9OgZmsxnT09OCSNFoNMJl//a3vy3NyK9//euSSzIPs9vtGBsbE55bIpFAPB6Xc/+pp57C7Ows2u22TK/efvttGUKcPn1avluhUBB6ztNPP41Go4HNzU1BkjHm5uawsbEhzf3R0VHY7XZUKhVRYiTElboEzI1HR0dhMBhw+fLl++oL9thjj0Gr1WJ9ff1AjuGjHHc7o49VmB0n3m+F2WFBY9hsNiviDtVqVaBmVE6iIS8AUdGz2Wxwu93SWWNSR6laKjjyZ1arFY1GA81mE+Pj49jd3cXCwoJ0TKgkl8/nodPpEAgEUCgUpHOwvb2NT37ykxgZGcHly5fx7LPPwu12I5FI4Pd+7/dEnp6Tm0qlgsnJSbzwwguYmZkRGXxOS7a3t9HtdgXGl0gkkM/nkUgk8MQTT2BpaQkGgwFvvvkm8vk8fuqnfko4Za+++qooCkWjUSwvLyOVSuGTn/wkpqenkUqlZPMh/t5ut0s3kZMwTkGeffZZgXHW63WBH2q1WrjdboECkEtEsQ6/3y+wTSUMkvCzp556Cm63G/F4HNvb231CE2q1WvxtcrmcWBdUKhUhFfO+DSvGDgquI5pPA+94r8zPz8NqtQpxl6bXnOpQLvfixYvCbVxdXcXq6qpMb9bW1vC5z31ONnGqPK2urmJ9fR2pVAoGg0EgMNFoFI1GAxcuXBD4LkVMeN9mZ2cFZsrCbGVlBdlsVowguS6mpqbQaDTw+7//+3juuefQaDTw5ptvIhwOi71BtVqV16a8f7vdRjqdFpVDt9uNnZ0d1Ot1nDt3DmNjY0L2v3LlCkZGRsQ3BYBMKnu9nhyEWq0Wp06dgtlsRi6Xw8rKihT4FHvh/aQKVrPZFGN3yudPT0/D6/UKLJjTwkajIfeKzQJCMZUd9vdK7emkMPvhi7sJfgzGoyQA8igVZsNiUMJ7MHw+H2w2G2KxGD760Y9iZGREpuc0m6dqIXksi4uLMJlMeO211/CTP/mTCAQC2NzcxBe/+EXhcRNi3e128WM/9mM4e/YsfD4fDAaDCBq98cYbuHXrFsrlMvR6PT7xiU8ID+kjH/kIut0uXnzxRZTLZbzyyisYGxuT5loymcTVq1eRzWYxMzODRqMhDblBQRMKH5E7TM4RcwN6QrbbbTk7HhY/536Ey+WS4ppcQMLh7xaE4LOZSvh7vV7H9va2FFIulws/8zM/IwMAolCSySS+8Y1vHFgIk/dPjpbZbJYCzmKx4G/+zb8pOdkrr7wieQUnfvRaLZVKQjV48sknYTKZsLOzg6tXr/a9n8fjQTabveecnlPddwM9JC+dom/v97hvhdn3v//9Y73xBz7wgWP9/oMMbvyUqGeXgiPzgxYM5bdpokizX5VKJa/H11D+PRXhaAzMxMzj8WBiYgJer1e4PJSVH9aNI+6YiSa79wsLCxgbGxNndfJmOEniFOjzn/+8bO5bW1sYHx8XOXZyuVqtFm7cuCFTrJWVFTz11FMA9qcGH/rQh+BwOGSTSqfTfZLrlOLX6/UwGo3Ch/v2t7+N8+fPC2/v4sWLfYa+AMScs9lsolKpYHNzE71eD3Nzc8Jfo3T81772NVy6dAnBYBAajQalUgmJREIgb+QAmUwmeV2j0YjR0VERcNjc3JQx9eTkJEZHR2VKVCqV8K1vfUvG+jSbLhQKuHLlCq5evSoHJjtS5GI1Go0+tSav1yuTVqVwCSc6er1e1hFhf1w3nO5EIhGB1RDW0mg04Ha7EQ6HoVKpRPSEsNZWqyWbfjAYBABsbW2hXq9DrVbLIWEwGFAsFpFKpcRweX19XXy7PvzhD4sHX6lUwpUrVzA3NydKilTNpPKk2WwWP7WtrS186EMfEljP5cuXRS3N4XAIR5KFGfkQNKekPQDvE59NTq2cTid0Oh1u3rwJj8cjippKw3FyN/jMKv32SOylGilNQrPZrKg8Mgb3BPIEDAYDzp8/D4PBINeA67FQKDx0IvNJYfbDF4VC4ViiXE6nE4uLiw/wEx09HuXCjAk5G60HwaaYjKvVaoRCIWSzWVSrVSwsLGBmZgatVgvRaBQbGxuIx+OwWq0IBoPC7fF4PLh69So++9nPIhAIiOx9MBhEsVjEN77xDeh0OqyvryMUCuGJJ55ArVaDRqPB6OioQOrL5TKuXLkisHRCzylqRNjjysqKNHPp+Ugkxuuvv44f//Efh9VqxeXLl/uKtPHxcXzkIx+BwWDA1772NfF+Y5jNZpFr39nZedcmzsPi7NmzeOyxx1AqlfCnf/qnDwwKTrNjWindS7AAIyVmcP3o9XqcOnUKOp0OKysrGBsbw+3bt4/cxKPPqEqlwvLyMhYWFmCxWHDt2jWx6wHe8f0aPJt4xhEBNMits9vtmJ2dxc7OjjQJjhOBQAAejwdra2s4ffq0eJfu7u4KmiSZTA5VOmfYbDaMjY2JqfYPQty3wuz9HIMb/0GqQsOCMDbC6TQaDbxeL6rVqghkHBZK6fOxsTHMz8/D6XQC2OedXblyRaB3gwIA8/Pz4lWVy+UwPT2NhYUFUQLc2tpCLpeTRUvlvVQqhXg8jnPnzmFzcxNTU1OSzF+/fh2FQkHc3zkJTCQSYk4ZCATEBDoWi+Gll17CRz/6UXGSr1Qqgo9mUt5oNLC9vY2dnR3Mz89DrVYL5HFpaUk8pwi/pEkx5UkNBgPm5+cxNzcnEwnyuSKRCP70T/9U+H2NRkNgHDTvpvSvkrhZLpfRbDYFpqokl6rV6j4rgevXr0txR8I0pynLy8uIxWLw+/24ffu2eJ1Rsl4ZTqdTplQsBnhw3G2tKKFvFJQgPIDwQsIlyWtTq9VikDoxMSFTrXa7LTK6k5OTsFgsKJfLuH79OoD9jiCnttlsFjqdDktLS+IbUygUsLCwgMuXL4tkfjKZFKuHUqmEt956CwBw5swZgWNcv34dly5dgsPhEDgjzcWJJff7/aJcViqV+hoTBoMBLpdLVMCUB9Tk5CRarZb4rlgsFpjNZjidTsG9UxGxVquJR8zW1ha8Xi/y+bwIzDDh2d3dhcfjEdVEqkcmEgm5B1yfCwsL0t0k34zB4tFut8vnKJVKd6iRKT3uHlScFGYn8X6KR6kwo4fn4L5+lJyBv8Ozy263iygXVRI5scrlctjb28Pa2hrUajVMJhPOnDkjqrfBYFCU+tjsrFQqwsmlxUgmk8Hq6ioajQbGx8fRbDZx5coVZLNZhMNhXLhwAW63Wyxkbt68ib29PWkijY6OCvytVCrh29/+NprNJp577jmYzWbcvHkTX/va1+Q7fvKTn5SCjwiiVquFq1evynlA/00iSLRaLUKhkCga0vLmXhtYTzzxBFwuF8bHx+Wc/eY3v3mspH16elp4+Ddu3DhwGno/BCaUa8ftduOpp57C+Pg4EokE/uiP/qhPofIgXza9Xo/Z2Vl4vV7s7OwgmUwiHA7L9eX5vrq6iueff17Ml1dXVzE2NiZeoMlkUvjkyqD+gkqlusOQm5/pKNeB9kA2mw3pdFrWPZFQVOSm5gIhqHd7rvhM/aCUKw9ELv/9Hse5uZwKcczfbreRSCQkERvs1hgMBjgcDpEDVUqfUwGn2WzK5G5hYUHkUAdjc3NTkka/349ms4nNzU2Rvs1ms9jd3YVOp0OhUBCj3eXlZZw/fx5GoxEulwtvvvmmLGx6R5XLZeFgKTdLdgUdDgfMZjO8Xi9efPFFZDIZ/Nmf/RmKxaIoAZnNZthsNvFsWlpawsTEhIzsS6USgsGg8HpWV1fF44n+VFqtFlarVQpCKlbSbDCTyeDy5csYHx9HPp+HVqvFpUuX4PP5AEDgo4lEArFYDOVyWUxHCT1IJpNIJBJQqVQiTa7VauW7kHzs9/tFjIFTpnw+D6PRiA9/+MOwWCwYGRkRiMqgEz2vFwvvZDLZxy+ib5XZbJZJizK553prNBoIBoNizM0pI1+HkyDivKmWyUkUp5lLS0tIp9O4fPmydNKo8pXJZAQ+yg0vkUhgZmYGTqcT8XgcKysrUszUajXodDpRHvT7/XA6ndjd3cXt27dFFGZxcRFer1e4agaDQSZvW1tbKBaLKBQKolxot9tx+vRpsRLQarVing5A+JycfhqNRuTzeeTzecRiMVitVmxvb8v1qNfryGazck2oHKbT6cR6gRBVQhZZ/FksFpkGUkFSyaulMqdOpxMZahKz2RFNpVJwuVywWCzQ6XSoVCqSnHW73bua5p7ESZzEwwmn0ylqd+VyWRo4RCLcbfpjt9sxOTmJXq+HW7duwWQyiXdmqVQSLhhh+vF4HIuLiwiHw8hkMtje3saZM2fQarWk6UthI55TnU4HqVQK5XJZeLO0/KhUKrhy5Qq+//3vo9Pp4ObNm/j2t7/dBzMkF5qJdjKZxHe+8x3cuHFDEDFqtRrf/OY30W6374AjxuNxxONxQdyw0URxLhZf9K5Sq9V45plnEAgEsLu7i2QyKZ5pSr+o4wRFL5jkr62tHVuwIRKJYHd3FyMjI0eW1OcZc1ABSFRHOp0W7v/ga9Trdezs7IgwCrl5jIM+i5L73G630W63sbm5Kc0+rVYLl8uFc+fO4QMf+AD0er0U7PF4XJBdVAhn2Gw2nDp1CuFwGPV6XdQzbTYbZmdnoVarkclkBD22vLx8KJyTcEmXyyU5BWGTbMymUik5d4+Si/M5OGqYzWaEw2EEg0FUKhVsbGz0iXW9H+KHsjA7ahDHy40GgCRY9BADIMRQwheazeYdG0632xUPCOLE6S2WTCaHLhxOB1hE8dBQqVRYWFgQCfLl5WV0u13ZMPb29hCNRqHRaLC3tyeFgsFgwIULF6DX66HX65FIJLC8vIxsNisPIadUGxsb2NzclIecHBsWhRaLRawDKCeu1WqFmHvq1CkYDAZ861vfwsWLFwU+SUGPiYkJuFwuISvfvn0b8Xhc4GgkjarValy4cEG8Y5588kn4/X6BA9ZqNSQSCUQiEVHQYwHM70NvCkIDqf5HIRd6ohCqShf6dDoNo9GIM2fOCIeM06Snn35aCt3V1VVYrVYUCgUpzGlQPghJ4EbKezN4v0ulkvx9Pp8Xwixl2PP5PFKpFDqdjphZGgwGOJ1ORKNR9Ho9bG5uotlsCsF8dnYWe3t7fcI29XodrVZLIA6hUAijo6MoFApYX18XvDlVEqnCRJ88cqdoEO10OqHX6wVOw4KEZt6dTkcgsIQwWq1W6Q7TiygSiQiun1yGyclJqFQqXL16VZ5JANJxorl1u90WOGS324Xb7cb8/Lw8v8S5U6iHqqFsTmxsbKBYLArvj0IyrVYLxWIRy8vLMBgMIgPMQ5pGnaFQSCZlSr9ETmw5xX3YUMeTOImTuDMoPMVmVb1el8bMURJIPtszMzNYXFwU4QXu4ZlMBm+88Yb4QIXDYUmga7UaLl26hPn5eTSbTdk38vm8wMy3t7eFj0veusFgwMTEBGw2G1QqFWw2mxQpFGEwm83CCx5McAltpIAC96ZIJIJut3vH7/P92ehstVpC9VCedcqihPY7qVQKmUymDxVyLxGLxWCz2bC3t4dyuYzZ2VlMTk5ibW0Nm5ubMBqNmJyclGnj7du3sbW1dcf3piLmUWGDLCy8Xi9KpZIIagD7Rf34+Di8Xq/kG16vF/V6XRrewD6SZ3V1Fdvb22K3QDrL2NgYKpWKiOexAQzsr62NjQ0RMeMUlucpX3tiYkJg+W63Gx/84AfxyiuvIBqNYmJiQqZsNAunkFexWESr1RIbmUqlgkgkIoqYs7OzQlVZXV09sDgj391kMgliieuQ64/XOxQKwe12I5lMolgsisAMhx1arVZsBQ7jK9Lnj39HC6hKpYJ8Pv++VD0+Kcz+X5A/xLBYLELYHOxyK7tXwH6FrtFohHNC3g7NoTUajWyiFotFfK646Ws0GoGQDQYXZKPRELWgsbExqFQq1Go1WK1WXLx4UWRHLRYLRkdHkc/n4fP54HA4BFaWSqWQSqUwMTGBUCgEh8MhkDZOqmq1GjqdjiTuX/rSl+ByuYTAymSYsDv6kjWbTSSTSVFxqtVqsikRtrC1tSWTn52dHVH6pJ8KE37aDND3jFMQTniY9GezWdy8eVMmGG63WyZhLESoqGQymfq6dCywmcBzqpPJZKQQdbvdAg+5desWtre3MTIyglOnTiEQCKBcLiMejyMUConZcCaTET7C4IbQ6XRQLpdlgsJNV6/XS2d1ZGQEfr8fa2trCIVCsNvtiMfjMsVcWFiQaSgLQ0oPE65Zr9dFROaNN94QrgL921qtlqhNNZtN6HQ6WK1WmcryszscDiHc8l7zepXLZWg0Gun4dTodjI+PCzxwaWkJdrtdJniNRkNsC/L5vDxf9JlzOp3odDoIh8PCCSRfy+v1wmKxwO/3993/aDQq15AEdErdq1QqsaRgwZvJZIRgXSqVUK/XhQdarVaF49fpdKQ49Pl8Ah/ioXj79m3Mzc1hdnZWzNjJH+CBT88gPhsUcHkQRZkSLn0SJ3ESd8bdIGm06+BeCwDValX2l6Mk79ybONEhxJ9/S7Nookyy2SwmJydFfp5CXt/97nfxYz/2Y1Cr1SJExTOazat4PC4QyGKxKFzkSqXSl8vQvobWMuREU+k2l8sNVTQcpqAXDAYxNjaGXC4nnGc2+ihkNRi9Xk+axMoGtzIo3lQul4+k3NdsNqVYnZ2dhdVqlWJ3ZmYGHo9HpOLvZkdyXKXAZrMpBUYgEIDVasXo6Cji8TgikQgWFxfx3HPPoVqtCqrp5s2bgvzQ6/UiGlcoFERR2mg0olAoiPl7MpnsK4oH4e9EGhHaWCqVJAfjBM3pdCKRSMhkTqfTIRKJiNgVAJmoWSwWgb6+/vrrgqBi0UfOOs/LwTCbzaJsnE6nZVgAvFOkM1ekcIxer0e1WoXD4cDU1BRMJlNfQ5cq4IedbbQF4PcE3hmCkOf/fox7Ksy++MUv4vHHH8fU1NTQn336059+1x/sQcRB+F3ib6PRqJjjssg66MFVvg6nZO12Gy6XS4yPmB9hAAEAAElEQVQSKWrgdDolwaOxLIA+0YLD8NGNRgMulwuhUAihUEimLZRaJ/wL2J+sqNVqKVaYJNL02el0CmyQ/DD6UMViMYEbut1u8QZLp9N9suSdTkdgapxqEVdutVoFykHOGgsAs9ksxSm5Yx6PRzhD5XJZEljCzYD9SR8NQNPptEDyIpGIdKa8Xq90dPiA0nODEuzs4AxGrVYTZU1y+nq9nqj4EYJBGXaTyYRYLCb8ACblhHSwqOWGQul2lUolUBYAMrFyuVyw2WxiPzAyMoJ4PA6bzQa9Xo8LFy6I2Ijb7UYgEECpVMLGxobwzLhOyT/jRmy32+XAoLQwO3j8jMoCmP5szWYTRqNReILcXIlP52bPgqhQKEjXlXwGn88nFgY0vLx586Y0L3w+n6gwUhVROWEC9hsTuVwOMzMzYgHR6XSQTCb7uCCchPJ5qtVqkmTxniYSCfE7Y1eSfmXkPQKQ+8dmB+8Z1T2piHbmzBkpMCm8oIQ+s5FBeCqhj/c7flBw9ydxfyKZTOLll1/GJz7xCRGiUv5sdXUVH/7whx/Sp3s4oYSTBwIBkUJnsHnicDgkoWND6ThBgYTd3d2+iRuwv9/TA5K+kHNzc5KME7pOIQ7u5YS8s8FWqVQEIs9cgHuVsuEHQDjJXq9XxL6SyaQgBdiwPIraIADZK5V8Z3Jz+X6VSqUvP1KqF1PYRLlnsaA7DlyNn1en00lDNBqNigo0fbKi0Sh0Op00Xu9H8PuUy2WZen7wgx8U6XqtViv5FWF7AOQsZH6otNUxGo3weDyYnp6W6dhhBUmn0xEOs3KNssjS6XQi1EbKAwtw/jfwznPBMzEUCkmD3WAwyL25desWut2uqHYStsowmUwYGxsTzv7GxsbQgpiwRIrZkSNXLpf71E/Z7L0bRLVQKPQZfZtMJin41Gq1+KoWCoU7hGoe5binwuyv/JW/AqfTid/7vd/Dj/zIj9zxs0c1UbDb7ZKIMVwuF+r1uoxNLRaLiElwsnG3YBLGhJNS3ey4WSwW6aBlMhk0Gg34fD7x/Gg2mweST7lZ8Xf4MGezWcH/8r1ZYJ0+fVqmLclkEtFoFIFAQHhLt2/fRiqV6jugNjc3AUCKEMKxRkdHBQLIKZxarZbJCrsvJpMJwWAQNptN4GzZbBbz8/PSzWIR1ul0EI1GkcvlBEpHvhe/M6cxVP/j9Ukmk9IhY8GXSqXQarVgs9n6+IAqlQoej0c8ZtgJNZvNAlUB9g8GQjGVU41SqSQeYuVyGXa7XSTY+f2VCoIMfhdlx4jFsbIwZIHL4pFQOPKUkskknnjiCfE029vbE3NmbmI2mw07OzviPaJWq0Whi35wKpVKupHZbBbZbFYmsITqJhIJ6YAyfD4fUqmUKEfa7Xa4XC44nU6oVCqxeyCnam9vT56b7e1tJJNJOBwO6c7S+mBiYkIEbci7YOHMTZn3hUVSu90WNcx6vS4HQavVkq40YTJ87gid5DPJKSwbKSwECVGhAmu9Xu+Tu6e9BcVIKE6Sy+VQLBbh8XgQDAaFt6ecyNJ3iGb1hIPeT3jFo7rfnsTDibfeeguf/vSnceHCBfzhH/4hJiYm+n72a7/2a4+MVP57HWycDT4z6XRamjr3GkSAkMpASBt/xoSUyroUAiOyhNzY06dPS7PKZrOhUqlgeXlZXovcdqIf2BAlJ+zUqVNwu93IZrO4deuWnJFsODJZzWQy6HQ6fXCywyKfz6PRaPShhVgYsDl4mEBDOBzG6OioIDt41gzuhUo5+LvFzs6OCFgRBdFoNGA0GkUOntfmfgh5KIP8bkLmw+Ewvv3tbwsfW6vVynfh96KQV6/X6+OhMXfMZrNIp9N3TMcsFov4tQH765hUDmVQgEqv1+PGjRuSe2azWeRyOVmHymi1WqLQvLu7i2AwKMrFFAtTDg7cbje63W4fR6xarWJ1dRWRSESK9oOC9535BhW/6ZuqfG7uFkoaDZu6bDRwcqa8bncL5goPG4Fyz1DGn//5n8enPvUp/Jt/82/wj//xP76fn+mBBR8IZZCgarVahTPCh8put6PZbEqyedBi4zSAMCl6bCmJmeyUNRoNeDweuN1uUXrkdKbT6fQZFdNzjFwuJogsBtjlNxgMshA7nY5IwEejUUlMb9y4gQ9+8INSiDIhJl+O0xkAsgnMzs5ifHwcHo8Hly9fhtfrRTgcFlwzCzNyoZrNpmwwhITV63XpoI2NjYnSIfH4jUYDJpNJlCb5/ZgYd7vdvs2HMFAlX4iEWsrfm0wmWK1W2bgGRRcG14DJZILP54NOp0MsFhOPN15nTiR5cJnNZpjNZuGCDW6O/N+clHHaRSgcO2fchKLRKFKpFNxuN6xWK7rdLjweD/L5vExpuCYo32y326U7tbKy0ndveN3ovTY2Nia+ZUr4IieXtBeoVCoCa6QnV6/XE/Urertx8sN1wEOZEBcWRzT9ZhOh0+mISXOz2RQvPsrpE3bC4ofPDn3ECFEkpFfJe9vZ2UGhUJDf5drihBNAn3cfVSKZiLGBwqK93W7LM8f/zWet2+0KlJXJCjuByi4iLRL4jLEAJyTpRAjkJB5UfOADH4DD4cCTTz6JL33pS3jmmWce9kd6JELJxVYGzx7g+J6tDJ1OJ2IhyWQSer0ebrdb9lyKcU1NTeHMmTOyD7TbbZmssKnK6QZ9wywWCwBIU3JjY0MKKwCCXJmfn8e5c+eE+w1AYF0+nw+jo6OynxMBw4LtoCB9YVhDqdlsSsJPUaqDoNVEU3g8HpjNZikWhhVg3Jd5zjudTlitVqRSKfnfhUIB6XRarFHIGeZ34/8dZHHwbsNkMsFisYhND+GDGxsbiEQiUKvV0kwFIHkIzz7lNeIEiWbefr9fuOT8+d2KFZ6NPIOoW6CkJyjFyPi6tVoNOzs7qFariEajuHTpEiYmJrC+vj70fer1unjOkspAbjoAmaYRdXZQsLGs1+slBzjo9wcndMrrr7yObNJyTSmn4u+nuOfC7Jd/+Zdx7tw5/MzP/Azefvtt/NZv/RaMRuP9/Gz3PdjNUkY+nxe1tnw+j0qlIr4TTOoJ11J25wej0+lAq9X2QaI4pi0UCjKaNRqNfeN2Lir6gRGO53A4xK+LSbHX65XuD//P5XKh3W7D6XRiZGQEIyMj8Hg8UsQxed/a2hJlu8XFRSnCOIGgqAQ3y3g8Dr1eL3y1ZrOJkZER5HI5GZW3223Y7XbBwLfbbYEr0nA4Ho9jZ2dHJmCDGzFhBkz0+f/ZXRqcJnKClslkJJHmBI/iH9ygk8kkUqmUwC55ren/opQ1Jpx1b28PDocDnU5HTBWVvnSlUkmgJ8T20/x7cFPhxEVZgAOQ+8mpX6lUwt7eHkqlkkiyR6NRuN1upFIp6UgS7kfhlV6vh1wuB61Wi5mZGZEwJgSgWCxKlzCTycDlcvV9VmWjgXwFEsXp/aXVauFwODA6OopUKiWCNbxu7EAT/sMmBaGC/O6U7WexU6vVxMKBNgY8SLVarUzZWq0WzGazTEBZeBGWwo7t4ISLE9F8Pi9JDjvZxLrz7xntdluEWZRqkixYvV4vRkdH+7rhWq1WiPDs2ilfkwkfYaW8/uyiApAk6v1IUj6JRzMcDgf+9E//FL/wC7+A559/Hr/+67+Ov/t3/+7D/ljvi7DZbNIMu9t022KxSGHj8/lw6tQpabBqNBopzKjYR1437WOq1arsGS6XS9TkWIjxTDx37pxM6OPxuOzPysl8t9vF6OgoWq0WVldXRT0a2N/nbDabNFrz+Tw0Gg2azaYgDQjZbjQafd/Z7/dLgTOs4OK5x4kH4WiDv0s6QigUgtfrFXj/YPA76/V6MU+mrylRFE6ns48nxaDIl9frRSaT6WvupdPpI93/owatVdbW1iT/icfjWF9fx9bWFtRqtTQa2Zjj3wz7LOReM/fjtSGiiOrV5F8PBs96UiyImAH20S/0V81ms333t9frodlswmAwYGZmBr1eDxsbG5I7Dd5H5mNjY2MIhUKiWMq1xrzU4XAI5WBYEDpMZc/DGiLK8xLYF/ygaFehUJCi7d2eoQ/SxuY48a7EP37yJ38Sc3Nz+PEf/3E8++yz+PKXv3y/PtcDiYM61Ol0WoowpbAGCxKbzQaz2YxarSYdLmV0u90DDfLYHRkdHYXf7wcA6S4pi5F8Pi8FDTdbTiPomWUymeRB4WcgXO+jH/0opqenZbFWq1XYbDY0Gg1sbm4iHA7Ld1KpVMKNIf+mUCggm80ik8kI7pn/XiwWcenSJZjNZnz/+9/HE0880UcsdbvdospnsVjEGLpUKkGlUmFtbU34QZQhHh0dlWS6UqlIgUIlPsLmCoVCHzachxyAviLYarXK61PsQXmNKJbBB085PSVOnVOdUqkkQhLc7DhJogIgeWmEkvB1KVDCe8+pDKdP/DlV+9hJJQxFq9XCZDIhkUjA7XZjfX1dVLi4/vh9Op0ORkdHcfr0aVFPJHmWHEQA4o9HSCD5COyy8rWCwaD4mLCINhqNwpuIRCI4c+YMzp07h263KypmLO4J36VCWD6fR7lcFnUsm80Gn8+HXq8nHcXR0VFRFUun0ygUCuh0OqhWqzAajXC73cLV4KHfaDT6kgQK9HAiqbwXhIUoOX9UL3M6naLQyHvVaDSk+B0ZGZHGBK0oaLa+u7uLWCwmB6RGoxECvrIIZ1JAqKUyuC6sVqscxPfCazmJkxgWarUav/qrv4rz58/j7/ydv4O3334bn/jEJx72x3rkg4IOALC1tXVgsqdSqWAymWSCwEYOC4pGoyFc2wsXLgjPl41Es9kMi8UiNjD0FGXDi/wvnmeEufMMt1qtsFgsGB8fx8jICDKZDNbX10UQajDK5bKcC41GA8ViEdVqVZRsDQYDpqamRIKeBaMSWXBYsEnGz31QxGKxPk/RYUHVQVJAiCwh7Hx3d3co9NJiscBms0Gj0UhTjJx05e8Q4XPcUDbeyuUyrl69itXVVTgcDvR6PaRSqaHFq91ux/j4OMrlMlZWVmTCRgsDRqVSOXBSxbyJOdpgEdHtdmE2m7G6uiqCc41GA06nE2fPnhWRDBa3ymCRNDc3h0QigRs3bogGgTLIX9dqtTIR63Q60qjnv1EQZlBUTxlE1jD3OywGz0R6/yrzvB+keNeqjGfPnsVrr72Gv/pX/yqefPLJ+/GZHngwGeMDxOReKWHOrpbRaBR1Hya9w4IdMnKoBh8aCk+wq09IFf8O2N8wWBSSjMxpAcUenE6nGNhymveRj3wECwsLAscjH2ZtbU1G5mtra1J0EOrIgiCTySASiWBjY0MeXHLGHA4HQqGQjJJZMCoVpwhrJESPxRWnhCxwfD4fxsfHZRoVCASkAGIxSCgC8cGVSkU6a9wkqtUqtFptn/k3AGxvb/cVJITqsRDiZqJMgjkJ3dzclIlNsVgUFU12czQaDcLhsHh0GAwG5HI5rKysIBqNSoHMIpOfgdM1pUIQPw/XHNeFVquVrqLP50MymYTL5ZLDiRNJSq/H43ERkHG73Th79iySySSuXbsmBTrXnsPhENGObrcrJGRyB5PJJFQqFbxeL1wul/AOqRaaTqcxOjoqsrfAO9AdKm6x+I9EItja2pLDj8/a2NiYTFvPnz+P27dvIxaLyT1gp5NwI5o87+3toVqtwuPxyLUNhULS1aasMK8FvyOhJVxvfN71ej2mp6cxMjICs9ksBdzu7i7i8bjARtrtNsLhMCYnJ5HP57G8vIxyuSzXgPYIhI/ykFVCRQi3UMKOlTBLo9Eo94nG4O9GSvokTmIwPvOZz2BhYQE/8RM/gT/8wz/EuXPnHvZHeqSDwh0Wi+XA855NonQ6LefPxsYGNjY2ALyj4uh2uzE2NoaJiQkRRwAgjVCKgXFS9corrwgflkgdQrUzmQw2NzfFuHdyclIsPVhAxWIxEeSg8BEjlUqhVqvJPkn6A2kcrVarD9LP4nJQal4ZPH/ZLKby8GFBhMwwrh9Dr9fD6XSi1+thZGREYIsAJMcZFuTvud1uqNVqpFKpPsNkrVaLcDiMQqFwJJibEglBWsgw6gJROAft20qaCq0SdDqdWPYcJSqVChKJhCg+DuaYbFoC+1NOm82GeDwuFBK+1zC+FRWeCbX3+/2ylpXBRoDNZsP29jaWl5elIc9p5fb29lBf3sEYxpFThkqlkokaxdmIjtnZ2Tn07+7VkJo5/MNukN5TYfbTP/3Tff/b4/HgK1/5Cn7hF34B3/jGN+7LB3tQQSdypTIN8E7HgAuMi4a8nKMo+hACUS6X+0a7Sn8I4B03dXbbuJCU2He+FgCRDGXyycVqtVrxgQ98AG63G5VKBcViUSAS29vb+MpXvoJSqYQXXngBn/3sZ2UDJ0nWYDAgGAxienoaFy9eFInSt99+G9/85jehVqvh8/lk9G00GrG0tISbN28KFI3k5UQigUKhIBuq8jpSCp4HBv1M/H4/HA4HAPQRkXlv3G43XC6XiGmQOEv+kl6vlwKasEAWwCym6bdlNpvhdDqFT0jRB7VaLWp9o6OjMJlM4qWlVFqk7xxhgrVaTb7v5OSkbJSETXIiRs5bPp8X4RflOqCkPD3UiAtPpVKwWq3odDpIp9NizFitVgWy6XA4kMlksLi4KPDHvb09XLp0CbFYDJcvX0a73RYrAqXxJw9Gg8EgMMFyudw3lQL2cer8XtVqFfl8Hk6nE36/X64XPxsPJ5pG07bg4sWLqFariMViGB0dFTJzKBRCNBrF6uoqms2m2DL4fD4Eg0HxI+FBwSKKvn5U5VRi65UCJs1mE4lEQrhxhEESck2IKLB/cOZyObRaLXi9Xmg0GsRiMWi1WkxNTYkiWiqVwssvvyzFqdfrFWitsvPJRgKnf3x+Jicn0Wq1sL29faiU8/0mqp/ED0+MjIzgueee6/u3J598Eq+//jo+//nP94mBnMTwoEjSsKDAEpENSoQEYX/5fB56vR4f+chHsLS0BIfDIWiOXq+H3d1drKys4Pbt27h16xaWlpawtLSE559/XqCGmUwG4XAYs7OzWFhYQKVSQTabRTQaxY0bN7C5uYl6vY5YLCbFk0qlwuLiItxuN15//fW+5Jc2J2zq2u12OBwOFItF5PN5WK1WbGxsoFqtitl2u93G6uoqgHd4X/y+5Hrxux3mNcXQ6/U4deoUarUa1tfXDxU94/mUy+XkvVUqFUKhEGw2G1ZXV+/YP0lh4BnAfIN/Sw7xMNrNsD2Xxs1WqxXZbPZAZBSwX7QQ3TQYmUxGckAiVdjIPWooX2NY6PV65HI5mEwmzM3NweFwwGg0CrSSiBBl8UjEDLCfZ/7FX/wFxsfH5ZoNBnNBKl1TeMbhcMi6H4x7tXPR6XS4dOkSvF4vkslkn/faYaHVaoXyctypqNlshsfjQb1eF/GwhxGq3g/B6V8sFgW36/V6RZZWSSYkZpXj/cHLwgT/MAEQm80Gk8kkHRp2WwhZZLAwAyCQBcLp+PrBYFCgYvws4+PjcqgygRwfHxfi6J//+Z/jJ3/yJ+FwOFCv15FOp2Uice7cOXi9XqhUKhEiId+Nm1WxWJSNf2trC7du3YLFYkEmk4HD4cDp06flGq2vr8Pj8cDv90On0wnvJxqNolwuC4+tUChgbW0NgUAAIyMjqNfr0mXhJIrXhxwcHhxUcCoWi0in07Kp8Hq4XC4EAgFR4lEqBVEWljh8KgmxS9dutxEMBoWPF4lEkEwmMTU1BZfLJXA1OtcTVhEMBgVKRxgnRUB2d3ext7cnnR5CYNvttghjsLPJdUDOIAsMeqApDTvZifP7/QiHw+h09s2aCbfjxDESieDixYtot9t4/fXXBTvO60TOlVKG1mazIZPJwGQySQFNLzsAQkImP8HpdKLZbKJQKIgnTzKZxMbGhhwyStNTp9MJo9GIYrGIV155BR//+MdFrIbQR4qUNBoNmM1m6S4TchKNRnH9+nW57/Sq4TXPZrMwmUyixDXYRNFqtVhYWBA+Jjd5ALLmarWaeJnZbDbZN3q9Hubm5jAxMSF2F2+99dZdu61UFOVkmc/bxMSEqFyurKwcimm/1+KsUCgIYf8kTuJRD57PPyhBONfc3BwWFhZkOrKxsYFarYb5+XkYjUasrq7ia1/7GkZGRuDz+TAzM4NTp07B4XCISqPH45GGIouOzc1N3L59G4lEQppNbOipVCppFK6srODSpUu4du0aGo2GeLVRTddut8NisSCbzaLZbIrq7fr6ep+AFc8fn88n6AMm5WNjY3C5XEilUtje3r5rIjs7O4twOAyNRiPf4ahQNBYRzzzzDPR6PW7fvo319fW+PVRps8P/Hiz+lFxlvreS067ccykNzzzlMMVAIm7YzB0WD7LhptVq8fTTT6PT6eDtt98GAOEwUpxqMFwuF86ePYter4ebN28eWvgdFESFUMBj2Hsc1aNOGTqdDo899hgASDNfya076FpyintYUfawvT/vdkY/9MKs0+lgZWVFOtMUwWCsr6/fMeq1WCy4ePHikd/jKBt/MBgUQq2Si8JQyt4qR6XDbi4Tc0LOCOkbDK1WK15P5OMAEC+1wW5QIBCAz+eTAoNToFqtBq/XKxt+vV7H7du38Z3vfAdjY2NwOp19BwQheNevX0cymRRiaqfTwdLSkiz+xcVF1Go1vPTSS/D7/YjH4/D5fAiHwyKbzqkeeW3b29tYWVnBE088AY1Gg42NDajVaiwuLqLdbmNtbQ2FQgGzs7MClVAq+FEKeG9vT7o2hBHqdDqkUqm+h5PiIfw/pSpUNptFMpmU6Q83dovFIq89OzsLlUqF7e1tzM/PY3x8XCZeKysrSKVS4kNH+EcikRAeAlUU6/U6rl27BpvNhrGxMXQ6HZHy5do57FGjupHD4RBZ/kEzR06UqPaUzWZFffL06dNQqVRYX18Xaf9isShkYlpAEHanVJUkt43m1qVSCaurq+j1egiHw2LUvbi4CL/fLxYHfD0qZfJee71e4TuSH9BqtXD16lWEQiHs7OyI4XWv10M+nxe4IqGbVPJcXFxEt7tvdsmJnsFgED4ikwtCZ2lKqXx2yWUbGRlBrVbD1taWPGu8vhRUAfZFgnjtWSzb7XaMjY2hVqvh5s2bd9w/qm8SBsnJKZWrgP19iPL6LpcLzWZTDMHvZ5wUZidxP4NNBJ/Ph1AodMfPX3/99TvWMCHAR4kftMKMQS6r0WiUaVowGIRer4fdbsfe3h5efvll6PV6hMNhPPnkk5icnBQYVS6XQywWE3RDPB5HKpU61n7BhuzNmzdx+vRpBAIBXLlyBSaTSQSdVlZWRFmRBQjjiSeewMTEBJLJpBR/tO1hk5MQ9EajgWg0eujnYX5yr9dTq9Vibm4O5XIZOzs7d5ypZrMZo6OjcLlcyOVyMilShsViwZkzZ1CpVEQO3ufzCV1lMKdjzne3RN7v98PlconX53uZWnNS6nA4sLm5KcMB2i+Ql/cgBKZ41j6o73vQmuEEmGqgB+XjwyIcDiMWiz00VMrdzuh3zTF7N/GFL3wBv/7rvy7CBq1WC7/5m7+JT33qU/I7v/qrv4ovfvGLWFxclH+bnp7G7/7u797Xz8LCYjBRUyrnAZApQbvdPhBHy6kc/bWUofTo6HQ6QuRlV4cJ9bBIJpN9eGkGN/YrV64gEAjg/PnzmJ+fx9TUlCT45GnpdDoEAgHx3ohEIiIisbW1ha9//euw2+148cUXoVKp5DsUi0UEg0GEw2HE43Fcv34djUYDfr9flB8pYsLpW6fTwdbWFs6fPy/FLOX0WahSUp5CGsCduG6KnpDXowyNRiMTF6oAslhSTk50Oh1mZ2fhdruFg6dWq7G2toaxsTE89thjMv3LZrO4ceMGrFYrnnnmGajVauRyOZmqabVaTE9Pw263y2ZO2fSRkRFZT4OwgcOC979YLB7ou5HL5eRwZNTrdZw5cwY6nQ6vvvoq5ufnodFocOvWLczOzgokMJfLQa/XQ6vVwmw2i6fd1taWHMgej0f8SEZGRrC7uysHLaeqFALR6/V9SQe96ljoUcGR72W1WnHhwgWZ4BFzT5hvsVgUTgU/Szabxbe+9S1MTU0J94Ey/4FAQCwIuE4o2sHCiAqS+XweOzs7gkv3+XxwuVwikkLSM7l8xWJRpp80KVer1bh169bQ+8LCj8quXMeNRkO6y5wum0wmRKNRmbgNNqJO4iQelUgmk/ilX/ol/MEf/AGmpqYQiUSwsLCA//k//yemp6fl9z796U/LucL4a3/tr+Ef/IN/cN8+CxskR00s7Xa78JQfVvR6PTkHJycn4XA4pGnb6/WwvLwM4B1JeIo6mUwmUV3e3d3F+vr6sacNwP41i8fjAjW/desWkskkdnd34Xa7YTKZ0Ol0RExLOUFiUMyiUqlgdXUV3W4XCwsLOH/+PHZ2drC3t4dCoTBUJZCfwel0in/s3e7fYUl+MBjExYsXMTo6ip2dHcRisTsa3kRgEHky+H1UKpWgQJRr4yDoHj/LURL4vb29I8E5322Qlz8Ig6Q/qTLneOaZZ+D3+5FMJvvUGHnOHqaYeJTcxWAwwOFwCArmIPjvsDhqQXfQmlG+13EFQIY1ECgI9yiACB9aVkA41c2bN+F2uwHsS/D/9E//NNbX1xEMBuV3n3vuOXzxi1+8b+9Nbg83TgB9I1y9Xg+r1SocMMplM7Gi8MJgsMjodrtIJpNDp2TKqp4cLOX73s3kcViQS/Piiy9idHRUVPZIlCSkMJ/Pi9IdZe4tFgu2traEDPvxj38c3W4Xr7zyCgBgYWEBH/7wh/H9738fxWIRsVgMZ8+exeLiIprNJm7duoW9vT34fD45PE0mE65cuSJJMjlcFPfgFMnv94tMOL+3RqMRjh6jXC7LJsqiWAm18Pl8AhujahWnHcpJJ/l5/FsKbGSzWZGyBSATXJpp5/N5bGxsoFgswuVyidok/b/a7bY86CRz8z0IVbzbgeR0OuVzH8UMkeqN9XpdZJdpkL2ysgKHwwGtVotcLicFSy6XQ71el8KcptKTk5OIRCKIRCLI5/O4dOkSOp2OCJEAEOiN2WwWY+fr16/fUSgSLhwKhdDpdLC9vY1bt24B2J9OTk9Py3SQ4i6U2KftQjqdxtTUlNy7ZrOJV1999a7XBNifKo6NjQm+nhCg1dVVlEolgfm0Wi2BqdBGg/wzj8cjzYOdnR0xkCf2nM8vDalbrdZQgjybISyo6amm9Hf5QVSUOokfjNjZ2cFHPvIR/NZv/ZagBf7SX/pL+MxnPiPnA+MXfuEX8PnPf/6BfZZhCJLDgvzRQfuKhxGVSgU3btwAsF8wzs3NIRQKYXJyUqb7ZrMZsVgMuVwOX/nKV/Diiy9icXERU1NT2NnZkcKM3HRO6KmKOyx6vR6y2axQBeLxuOQthUJB4NyHxTAhh9u3bx/pe6tUKgQCAeFK301MwWq1Ynx8HIFAAKlUCtevXxf+cKPRQDweF8ueQT8uxujoqEjlZzIZOVcZvV7vSN+bwUb6caYxDzKcTidCoRC0Wi1SqZSc0b1eb2jT/vLly9L45+f3er2YmJiAWq3G9va2qI8D+/dsenoai4uLWF5ePlAhksHm5nHCarXC6/WKn10sFkMkEgEAEe86blD1+yhaEAfFo3B/GQ8dyqiMZDKJYDCIP/mTP8EnP/lJAMDf+3t/D9FoFP/qX/0rOBwOTE1N3eFpcLdQQiUoFc8En0azSul0p9Mp0utUSKK8PCXLqZj4XnbkfD6fKBlms1nE43HZ7PR6Pc6fPw+/3w+9Xo9erwebzQaPxwODwYDNzU0YDAaEw2EYjUZUKhUUCgVREYxEIlhbW8MnPvEJKVq56edyOVy5cgXJZBIjIyMYHx+HXq9HuVyWoo6fja+lfLio9NdsNkXSXRns2N1NjY5qipTvZUHPThy7joRjcDpnNpsFwsnNIBKJiHjFxsaGqD/p9Xrs7e3BaDQKFn53dxf5fF74WMD+5jI1NYVKpTJUvYjfm11bg8EAj8cjHL/BzhJl2Ifxo+iRB0DWKiF9lUpFZJtZ0C0sLECr1eLWrVsy3eLPybUsFovS5S6VSkgkEtBoNFhYWIDX68Xm5iZ2dnbgdrvls2o0GszOzgrxl8qh7LxlMhlYrVacO3dOOtbRaBSvvPIKnnrqKahUKrz++uvweDzSZVOr1djd3ZVDnIqeMzMzKJfL+OY3v4mFhQUYjUaBLdRqNTHMdrvdMglkF5BFKxMYKqBms1mk02nxt+GzYzabpeAaHx9HKBSSSWChUMDe3p4oWxKaWKlUsLKy0nev+J4U9eC0l+pu7+bQOE6cQBlP4kHF//gf/wN/62/9LWlWAMDk5CR+9md/Fs8//zzGxsb6JmdHiXuFMh4mxX2vQU74cYKNnpmZGbjdbmxubvZRIgaD55TBYMD58+extLSEsbEx5HI5/Mf/+B8xPz+PD3/4w9Dr9dje3sbLL78se8fExAQuXLiA6elptNttvPXWW3j55Zff9fd+EKFWq4UqEIlE7ule0UeT524gEOibzhyUvjocDszPzyMUCmF3dxeXL18e+nuhUEjyoPciFWZe4fP5sLq6emxvNRoy83potVqxHorFYnA4HMJJPAgmbzKZAOyrIirzJY1Gg/n5eVSrVRgMBoE/KiMUCsHj8SAWix2bj0ZBEqKVKIqTTCYRjUb74LI/6PFIQxkH47XXXgOwT+5Xxle+8hVEIhEkEgkYDAb8l//yX6RwGxb0r2Aopy+Uw6Tp82Bws6cAAmF2xWJRElDC5Y463aJSnV6vFwf2YZuU0t18UAHJaDSKOhAVGpXfsd1uY3NzUzyqNjY2cObMGSwtLUGv1+NP/uRP8KlPfUqkTa1WK5xOJ3K5HKLRqMjK01OlVqvhtddeQyqVwvj4OCwWixjhslio1+sIhUI4c+aMKB2SG7S5uQmbzSYiD4cdVAd10mh63O12+wQp1Go1pqamBNoSiUSg1WpFjlb59+SCeb1eKUiTySTm5+dFOn9xcRGpVArNZlMUBVnINRoNTE9Pi/9Wr9eTSSMnoySl8t85AeSm63K5xFCzXC7fAfugLP+wTZpJghLKwkkPf6acsrHw5ARofHwc8Xhc3rNQKGBkZATT09NIp9NIJpMiu7yxsYF2u40bN26g0Wjg8ccfR6VSEZhop9Pp65ZSvMTr9Yq/yd7eHiKRCEKhkBTRwD4cYWRkBC+++KKYQi4vL8NmsyEQCCCdTovMfzgcRrlchlqtxtzcHJaXlzE9PS0FNINrI5vNShOBUE1CEsmds9lsIshCk+hOp4O1tTW5TjabDWq1GhsbGyiVSnA4HH2+gNVqFclkErOzs7Db7Th37pw0NqjOVqlU+hoMxL9TGl95ULJw5L3hGjlo2n4SJ/Gw47XXXsPExMQdENwvfOEL+F//639hbW0Njz32GH7nd36nD+6ojMPO5+PEYYk+BamOW2TRS3RQav6waLVacLlcsFgsohRMSL9are5TaqTa8MLCAsrlMt566y3h6LLR9fTTT+P8+fPwer2YmppCMpnEzZs3Ua/XxStxc3NTzsVh4ff7cfbsWYG4K7nOyuAZabfb0Ww27ysUr9vt3tG8YoRCIbG2OXfuHHw+n6gHMiwWCx577DGoVCp85zvfwfj4uDR+n332WfERGwbzZM5mtVoPVT68m5/agwie1+QeHycGm3sUAuO5QgVL2i8MC+WaUT4jWq0WZ86cgclkQjweH4pS4Tk4bCBhMBhEQXHYs0PEDXmJ3/jGNyQvGB8fFxEZ5npHsTO4H0F6BM/uRyEemYlZOp3Gk08+iUuXLuH3f//35d+//OUv40Mf+hD8fj86nQ5+6Zd+Cf/pP/0nXL169Y4CjvHLv/zL+Jf/8l/e8e/sJlBu+6jB6QSwf6iw2z/ooD4sKDtL/yImuoMb6t0wvRSaaDabyGQyoggYDoelIGBCWq1WRcWm0WiISfTIyIjAKAixy+VywiXKZDKYmpoSDPbe3h5mZ2fFOHFvbw9WqxXz8/MCu2y1WjIp6HQ6SKVSWF9fv+O6HAYpGfR+YzeRnmiEIgxCExmcDtbrdbRaLeE+UXafXSpCz7rdrphOvvXWW7h06ZIIUaRSKSwvL6NQKGBychILCwuw2+2itER/s1qthsuXL8sE85VXXsHi4qIUKZR1z+VySCQSkuiPj4/LhObq1asIh8NQq9VyIBHmx+tCwRIWkeVyGbVaTURXBuVptVotJiYm0Gg0EIvFMDs7K7CHQqEgUJFWq4VYLIZ8Pi+wRhous1ir1WpHkozlvWBRRLNuEqbpKdbr9XDq1Cnh4dGbh7DhTCYjfmo6nQ5ut1vW3PT0NJLJ5B0Q4mAwKGRvTuCoRknYLM1IB80ylXhyQl0nJib6FB+j0egdCY3SU08p7OL1emGz2bC3t3dgMsD3GYTiko/G+01hlXuJk4nZSTyI+Na3voUXXngBv/Vbv4XPfe5z8u+//du/jc985jPiy/QTP/ETqFQquHz58lBj4oPO5/dzUOGYnCzuC1Rb1Ov12NnZQaFQwOjoKKamptDpdHDjxg3s7OzIfmIymSTfYYH40ksvIZ1Oi4Kzz+eD3W5HrVYTCXcqCgL7U6WpqSkYjUZsbW0hEokceQ9/r9JBZT7ARnGlUulL+AkfZ8Pt0qVLsFqtiMVieOWVV+4KL/T5fDh79izMZjOWl5f7TLdNJhMuXrwofp3vtVAHc5nB96UoCbn/yiAvsFAooFwuy9lBG5vB9zjud1Kr1ZiYmBBrl8MgnxqNBj6fD1arVVS0x8bG0Ov1sL6+fmCzJRgM4syZM3C73cjlcpKjUdhGSUGhNcJhnmXv13jkVRmB/Q/5/PPPQ6fT4atf/arIVQ+LTqcDj8eDf/Ev/gX+0T/6R0N/Z1hHjrKurVbrnsbW9DfgxST86zBJTofDIS7pKpVKMLCD3YbBZG0wTCYTvF5vHxfLYrGIWiDVCHu9nviZFYtF+Tvidqny1Gw24XQ6BeaYy+Wws7MDrVaL2dlZTExMyCibE6bt7W0sLS0hmUzKhkA1PeW1VvJv6DRPPPNBkD92jugir7wuQL9yHpXutFotMpnMHXwynU4nEsNU86MQBQ18S6USpqam4Ha7sbq6irNnzwr3qFgs4vbt24hGoyKPn8vlsL6+LpYI7XYbc3NzmJ6ehsFgQCKRwEsvvSSjeYqVUL0qHo+j1WohGAxiYmICFosF7XZbhFXcbrcoVCYSCaysrPTZM4yMjIhMPUnLnBAeJBdLy4DFxUVotVpsbGwIf0qr1SKbzUoSwYKKhyM92AhJokklcexc84TMKkVblPdLGWws0IuNEzin0yl/Fw6HZRJaLpeRSCQEYulyuYbyIihzHAwG4XK5oNPp5DNQEIQS+oVCQYRBAoGATB2pOknxGMKxWq0WkskkYrEY1Gq1rAdOSmk9oFyvg8aW5JkpnxEqh/I6DpKO362k8klhdhL3O9544w08//zz+PznP49/9+/+3aG/+/LLL+OZZ57BzZs3cerUqTt+ftD5/H6Pweaq0WjE9PS0QP83NjawtrYm/pkAhlrpGAwGTE1NAQAikUifKJnVasXc3JxwcIlGYdHHz0FUj91uF7/H9zKoSBkIBMQH7W6/D/SfHVqtVrzUpqencerUKdnT19fXcfXq1QMLM4PBgOnpaTzxxBNSZHz961/v+x2dTifn3+B0SXmGUjvgOJ5j9xp2u13Ug3d3d/smT8MKuvshWEG6R6lUkte7mwqlz+fD5OQkjEYj4vG4FE9arXao3RRjdHQUp06dEmGaeDyOUqnURycC9u8NPT8PMzgH9p8JclCPijRR8rwfRjzyUMZisYgXX3wRGo0GL7300qFFGQBRbDtsBG0wGGTCpQx2FY67iCkHq9Vqpeip1Wp3Na9jEabcdLjYNRqNQJsICxwWfGjIeSOpudlsIpvNStKoxArTn0utVoukLUVMGo0GRkdHMTo6KoqTlPau1WrY3NwUlUfKnZdKJfEEYSGSTCZldG0wGJBOp5HP58UsWavVykFBtT12AAeDBanyvgxLTmmuDEC+j3JiAUAKbxaq1WpVrj8L4263i3w+j2w2i0KhgFu3bsk07ObNm8hms2i1WsKJa7fbUjjlcjmEw2GRmo/H43j77bdx/vx5qNVqKbYoS0/uGq/jW2+9JWqfZrNZJkVvvvkmXC4XPB4PxsfHEY1GYbFYxDuLxpVcL/SAs1qtIkTCUEI+W60WarWa8CkJheh0OrIWycejiTP5Yc1mE7lcThQZaXROM22uf4PBAKfTKUpRw3Die3t7IqXfbDZlMkZfN8J0xsbGxJPMbDbDYDDI8zbIy5uenhYlRR5O/C6lUkmUMtlZ7Xa7AmckbIcFIrlp9E2Lx+NCPA+Hw9Dr9SIbzu/sdrv71Lz4GWh4TmgED1t+Th5+5XJZrimhYTqd7oFIGp/ESdxrvPnmm3jhhRfwuc997q5FGQBp6MRisaGF2UHn8/s9ut0ugsEgarUaisUiGo0G1tbWsLW1JXvx3ZJB7vGc7gxTdSaSgZxajUbTB3HjXsf9vtfrYXJyUoS43ouElPvbUeGgB+VkPDcprqXT6bC8vNwnwjQsKIh25cqVPtVrZfDa8nU49WRh0Wq1YDabMT4+jk6ng/X1dZw+fRr1el1k9u93lEolOVsHr91gAcZG4FGusdPpxPj4ONrtNmKxWB+dghB84J1rcbccOZvNCjKm3W7LtRxsFgcCASwtLaHT6eDKlSvC1w6FQsLFPgiKurW1ddfPYbfb4Xa70el0kMlk0Gq1xKrqMETbYbm7yWSSnHtw8vdu7B6OEw+1MGNRBgBf/epX7yAAc5NiMg7s41S3t7dx5syZY78fu+nHdQOvVCp9C46Fx2GvcxiJmIWCEq5E5aHB6HQ6KBQKwtchlMHlconinFIdEIAIVaTTaZkSaDQaNBoNWcjczMmRMpvNOH36tEAub9++LWbJ5Nncvn1bNg16raVSKcHCt9ttEVeg31qxWBQvsWHfj+aN3AgHNwZOqSj6wKmNcjMA3il0eS05pVBust1uF263WyCcLJSz2SzefPNN6TTyMyg7MDwIer0ednd3xfdldHRU/ON2d3dl8kjIpMFgEH8TQjMpiWw0GmG1WmGxWLC0tIR8Po/vfe97MJlMmJycFHNmFoRK7DY7q1S8Ghb8bgaDQb7rQYdZs9mUw48HAE2/qbxkMpng8XjQaDRQLBZl/et0OoH3UoVQGfyuFosFHo9H/j2ZTEriQP7llStXpOCmoWen04HJZJLJmdlsFrVEet/xu3FqStEVZcKiNCRvt9vigxKPx2EymRAMBqFSqZBIJGTirNFokE6nodPpMDo6ikAggGaziUajgWazKZ51iUQC3W5XNm7ltWOCQgNsBpsYrVZL7qHJZILNZjtUbe0kTuK9iitXruCFF17AZz/7WfyH//Af7vh5pVIRWDXjq1/9KtRq9dCi7Ac9stlsn8EwRZKOG/Pz87BarUgkEuJlBuxf762tLezt7ck+RwufQe4y91CiCiwWC9Lp9AMtzNRqdd/5927EWTqdDnK5nCTdpVIJbrcbVqv1QHl+Rq/X69MROCzB588CgYDkCLTNKRQKWF1dlSbi6uoqnE4npqamhFt8P4PN5KMMD9hUPEpUq1Wk0+kDTaCPA5u3Wq2iQzB4fwc/N/PgVquF2dlZOes45OC6JnXB4XAIEqvVagmc8aBBDIcNXOs2mw0ul0vUvg8qog67vo1G40DVz3t5lu8lHhqUsdVq4bnnnsPa2hr++3//731F2dzcnCRAFy5cwOc//3ksLS0hEongV37lV+Dz+fCd73znyF03qj4p1deUQeGCu7mTa7VaWCwWKWqG/a7VapWE/iCYGbsMyp8fxjHjxsqfc7QOvJOgEw7Ig4C+Ia1WC9PT06I0WalU+hJc+qmZzeY+lUM+HMvLy/D7/XA6ndBoNEilUshms+Lh5XQ6pYjY29vD1tYWvF6vGF+vr6/fAVFUBrs+ymni4HcnmbrT6fQJpDB4Pcix47SH3njK96JEfyqVukMoJBAIwGw2C1xQaTR+0Gifps+0DKAgBf2sWOyRa1Gv1wVKOjo6KlDUQqGAeDwOg8GAarWKjY0NdLtd+P3+PtESZWJPEZBer9d32A6KyDidThQKhUMTfUo2K6e3VqsVgUBAEgOfzwdgfwzPjYvTJvIE2Eigd16z2ZTvr9frodfrxUCa01pOJ3u9nkzfjEajFND5fF6+x/j4OJxOpzx/xWIR5XK573njtS6Xy30bM6e2PICr1apMIzmZBiDkY4fDIdBPYH+ymMlkoFarhedBmHAymUQikUAwGJQCjF1ISkWTV2E2m+FyuWQKqNwHDtofjhMnUMaTuB+xsrKCD37wg1haWsIXvvCFvp9dunQJer0eX//61/GFL3wBn/3sZxEKhfD9738f//bf/lv83M/9HP6//+//O9L7/KAaTA8LelDdjUPqcDhgsVhQLBbvoF64XC5MTU3B4/Egk8lgc3MTY2NjgmYZ5OSwuUrLgwctLDQslzEYDLLn3a2oOizu5r/1boLIEHK5stlsX5OR3OezZ88KkmN5efk9a6BptVpYrVYAEGETu91+V1NvBpEudyvClDA/rVYLl8sl/qV8HQ4KjvJaRF45HA7x9WPOwnOfQm/Mf5TnNtf5sGGH1+uF3+8X2gHzDgBiZfMoxiMLZSTEbG5uDv/6X//rvp/94i/+oigIfuMb38Cv//qv49d+7dfgcrnwT/7JP8HnP/95mX4dJw4y/OWU5LBFxuSfnaCDbjh/PiypopjDMG7Q3WTiWZgppeE5baH8PxPyTCYjku9MegnxKhQKcLvdIqXPRcwkW9kp4OZHKBavEztRNMakqXA8HpdEvVwu93F3Doq7dX0IieDvDLvunOLxGhJGSDd4pZk1p4+D19tms4n0er1elwmf2WyGw+EQzhjx0PwbJts036aUOjdBwkzph0L/PuLkt7a2pOB3uVzw+XyIRCLirdVoNOS1lJsVDwnlulBeD+V/Ex4BQCCe/GzKImBwXTKJ4HTJYDCI8AxtJwgTKZVK8u+8Pp1Op48nR6UoFkSdTkc2J0IaKDHPIpCfx2AwoNPpIBqNygHF66OcslIxihwHm80mRTLl7wmf5FSV3bZutyvwUhaJer1eJrF8n0ajIVPTQCAghxffn40ZdgcJYeR1abfbAudqt9t3wEoO2j9O4iTey9ja2sLi4iI6nQ5+8Rd/se9nX/7yl+Hz+fDxj38cdrsd/+2//TdsbW1hbGwMf/RHf4QXXnjhIX3qRzN0Op14N5XL5Tu8wZSh0WgwMTEBn8+HUqmEa9eu3aGkp0SDkEt+UDOH+9J7FcNyGYphvdtE+UFNLEZGRjAxMSHIot3d3TsmSwaDAQsLCwgEAohGo9jd3b0ngaZ74RCTl8wcgGugUqnA5XIJguew1z3s2pNDHQgERNWbQmpOp1MaqUQfEXVFyC7PZLVa3Uc5YB7FPOGgaS0bpWxYkLJkMBiELnBQ455rS6/Xw2aziZDWo+RLdtx4aIWZw+E4kv/GyMgIfuVXfuW+vOdBBYDSk4n+RsO62Ey0DAaDyKXzYeFrH7Rx8MFiwkcuybDfHyTCKs0ZWXQoCw4m5kzqyAPiwkylUiiVSvB6vQgEArDZbFI0+Xw+GAwGkQQvFotIJBJiXExFQHY3KAPM9+b0hJ/XbDaLatDdirKjxOA0CIB4yrFI5YNMPh1/h1wpju9ZULPIVqlUUtANYqWp2kgYKD3JSqUSisWiGHfy97xer9zTUqkk0yBKpRsMBjE8brVaSKfTonhImWVuXr1eT7xbDjpQCd1k8d1oNCTxH9yQms2mmBuTo0A4Ae8toXcsFvb29kTdk6pYLMgJ2WNhyutCLh6vA6+lw+GA3+8XSdp0Oi0FbaVS6VtPhFFSMIfFLO81nzXCm9lIoIAOp1iclnKSyuKHBSm9z5RKpny2uAfwPrIw5uSMUE7+NzklzWYTxWJR1uNBzR5yF+/FM+kkTuK9ihdffFGoBofFpUuXcOnSpffgEz3YYOP1fgTtMarVqpzLhDXfDarW6/VQKpUEjjWYt1C1Lx6PQ6vVCnpld3f32N5S71V0Op1jeb4ShUHfz6MEURZ321P1ej0CgUCfObLVahV1YHL4BoVIvF4vQqGQ5ArKAmQYkueguJeciLmDEgXUbDahUqngdDrlO9zNK5Nn/mCjl41ZFs/KJmQmk+kr+p1OJ8LhsOShw8Tfhn3no/Ar+R48z5WUoWGvzYky1dKH5e+M+/l8P+h46OIfj0KQu3WYUovS1JheDLVa7UidKCbRTPyZIB81BhM8vje7ZuSqMFEmhIqLkF2LqakphEIhaDQaKb44ASE0jCa+yg2Owh6UZVUueh489Inq9XrI5/P37E0zLMjpa7VaAsMkHFH5O1S+VE7heK84NWLxTZx0uVyWw3Jvb0/G7DabTaRps9msdISoykjLA27STOBVKpVA6DiRoq+IxWIRWWOKitjt9j6YKZU22V1Sq9VSvLBI4XrgdJIcrWHwWYPBIOuAUD1uyN1uV9a1zWaD3+8X8056o/B3uT64Dtlc4DrhdeX3HcR2cw0RZsvpFItKHsRKIRsW0OVyGSaTqc9vZ3d3F71eT6woWLgZjUa5D4VCQYo1Fnks5Hkt+XkBSCPBbrfL61DFs16vw2azyRSNEveEEvPfCZdmgQa8M/HmtSf/gcGJrLILfhIncRLvbTC51mg0Mvm/X89ip9MRaftB247B6Ha7h0qVt1otSc6JCqHh8sNUmrufwTPgqFMPcrlZMNXrdYHPD/qbDgs2qolqajQagvBQFgblclmQGO9lDDvbeY0GhTsOCtIVrFbrHXDBXq8nRY7yWpGOMXj9KKLGa8PC+349L6SDHERxYSi/A3Omgwqz91P8UBVmh416jUajiI0M/g675RzrAvsLot1uo1qt3rXIUkqacmR7mBwpFeLu1v3ha1Wr1b7kn6ITPGSUMEBOwbxerzxMqVQKOzs7oroYDAZlc9PpdEgmkwf6kPFvKJTQarX6PjN5RcrvfdyHhpMnFgDEsCtx0Eo+GLsz+XweRqNRJkacmLXb7T5FK0La+HrK6QuhoTs7O7IhKwVpVCqVQBMJK2FnVHm9OLFiAcniz+l0Qq1WI5lMCues1WphZWUFVqtVlKIASGHMKV+1WhVoIr//oHwuiw4WflyrLCg5DeNUiGbNg9efG7QSQlmr1aRopI9duVyWdcB7wwkWPxe7dVw7XB/8b5qSj4yMiD8ff5fdvmKxKNebap88XHndlAc7i2KaW/Pa8Pd0Op0UfSqVSjxa6vU6EokEcrmcFF60YohEInIIOJ1OOBwOgfEmk0l5hgirVV5zrglOcPndldPxkziJk3jvQjl9V0qTDwueHQd14AfPQcb9hldRcOsHLVh0HHUv5DnH8wZ4xzZgsBBuNpt38PDIHVY2Ht1uN7xer+RYPG99Pl9f0UdP2AfJZxrGqSOsUCkMMyyUuZuS26UMUmPI32YDQYki42vk8/k7fNOUUP17DeYWbOyyue9yuYRCc1jcjXfYbDaFs0+P2Ue1gPuhKsyGVf6MarXax7EZ9CTSarWCqeUkgWawnGAc9PqDD60ycWYoBSZo2KzkMyl/T5lc83Px3wjzYrKq1WrlMyUSCZGA5aSESTl5NA6HA61WC7lcDh6PBzabDfF4vG+DVD7oTDYJcyNEjK9HSCE3tnt5EJTKVpR956RICT1TCm0Qwlir1aDVauFwOEQMhZDMTqfTV4QoTZGZ+KvVapHKZ5fIaDTC7XbLtWWnjb9PQYjBzhOFHwiJYDHDgoJ8pXQ6Ld5rTqcTExMTaLfb2N7eFul7TsxyuZwUGIQhcp1wssprXiqVBIZrsVhk6trpdJDP51GpVARCw3XN4p7Kjpwkco3wO5GQPdjh0mq1CIVCUvyS31Wr1VAqlUSMo9frSeGo0Wiwvb0Nk8mEZrMJi8Ui0EreS5PJJI0RwjCUcvSBQAAGgwGlUgl7e3solUrQ6/Uy5STc0Gw2i2Ikr70SdkPiPEVCCPWwWCwy2aSlAJUXjUYjRkZGhJOnFDpRPo96vV5grbwvnKg+qgfGSZzED2rwjLlbgs2igU2/w37vXp9jel3erTB5t56HDyqGfS6l1yibUgdNJZlbHSR1PxjVahWRSATAOxZDhIIetWBgDsczTKvVIhAIQK1WIxaLoVarSQOajTSr1YqZmRnk83msra3dl3vB1z8KP/+g9afM0di4JnJoWFD9mtwxTquUZ/aDDuY7Op1OEDEqlQoej0f44e8mjEYjfD4fRkZGsL29fQf661GKH6rCTCkCQVEC/hs3QCbnTPi5eQxKb/ImU4aUyemwhT9485UFgHKywQ4RJxTDpD4J79JqtdLBZ9Kcy+UkyWO3QXnIlMtlBINB2Gw2JBIJFAoFGd3zgSCUzeFwSHJL6BiD0v6EwvGhJfmSfCq+N5Pwu8Uwk8lhoYRJsvigpxdVCpvNpnD4lKIp/Jthn4eQUBYsnMjw33O5HMrlsnCUWNDU63VJuBuNRh98UBl6vR5+vx/j4+NS7HEaZ7fbBf4WiUQwNTWFeDyOQCAAvV6PRCIhkFF2vFikGwwGeDwe1Ot17O3tCSyQhYsy7HY7fD6fCKEQ0srmASevXq8XrVZLCjaqe1qtVhSLRezs7MhnUPrQKcVFOIFmUZPNZmXtcs2wUKZ5O3l1Op0O6XS6z7uPik0qlQqBQEAKYpfLBb1ej0KhgFQqJRM7erjxc9GcnIU+oSnpdFrMUAOBgBRzkUhEntVer4fR0VF0u11Eo1GZgjmdToyNjUGn02FjY0MUN6neSjXTYrEoHXmub3Y4CZ05KchO4iTuXyibdMdJLDllOUhZeZhQ0rA4aDqmRCgclFhTOTYWix1YKDIHGOZ59TBD6amqDF4vwunYCBzWzG40GkdWGxwMvV4varpUWD4olFMyjUYDu90uwk1M3PV6PXK5HEqlEr7zne9genoaer0e7XYbi4uLOHPmDBKJBDY2Ng5EFQFHn5babDaMjo4iEoncoch5lKCycS6XE4Gsu0Wn08Hu7m5fnsegKvT9PJuUzwDPRdrusEhkHkFrnHcTFosFXq8Xt2/fFnG8R1kc5IeqMAMgRQiLFyb5LMSMRqMQLJUPmbJoYBHAiYtKpUIwGBxqrMv3ZELGbgjFK7jglAXOYZ0Bmt4SFkfhBbVaDYvFgtHRUajVamxvbyObzcJkMkkCOD4+Dq/XKwufHTmqylGEQqfTyWsPww0fNDKm6TWT74MkgQ/q8t3rg8/vw4KbhRN9sLrdrgheHPYZONHgvR7mQUPsM0f5Go0G4+PjItaxu7sr0FelqIXyGqXTaTHOTCaTUjjU63V4PB586EMfgkajQTabxY0bNxCLxcSkO5vNSkFEaF+lUkE0GpVrrYT6DX5Xirfw71hU0tur1+vB4/EIX9BkMiESiYjhs9FoFK8eFkvkrtFLj4Uhr7nSdNrj8YipMrB/SFOWeHR0FBMTExgbG0OxWMTGxgYMBgMmJycRiURk6kQuIe8ZYRgOhwM+nw/5fB6pVEqebZvNhunpaXi9XphMJhFaqdVqiEQiuHHjBkqlknDkrFarTNsoGqMU+3G73WLUWqlUkEqlMD4+jqmpKZnGMqGyWq0Cs+G14iSc90QpQ/x+ISefxEk86kFF3Xq9fiy4n81mE67wYdOze4Gu8azyer3ioTgs0uk0JiYmBAWhbOCyaOS+TZ/LRyXuBmsrFAoH5jhHbc4eFrVa7Q6o4kGhzI9MJhP8fr/whOPxeF9xaDAYMDExgdOnT0OtVmNvbw+3b9/GxMSE2BANnvdUL+71encVP+Hf09rJ5/Pd1QePiClloyAQCCAYDIqWwLstQO72uZXoMuAdBeXDng+n0ykKpfTWI9c9GAxienoaarUamUwGr7766rv6/MzRKI5yv73nHkT80BVm3W63TzQCeIdTZLPZpNjiOJwLjAkgu/cApCvEB49iAINqPhaLpU9BkP4KgwuXkzp+zmGhlB/lA6GctM3MzIiaDfBOV54FBwnIzWZTpidU0gMg00Em2NwUDuKYDQavw2EdDprw3q8ODKd0hULhQEPBQc8yi8Vyx9SsUqkciNMeFhqNRuCHTMYJf+DnUfqZtdttJBIJpFIp+P1+hEIhTE9Po1wu4/Lly3IvKYhB/Hq9XsfW1tYdk8JutwuXyyXdMf6cBVOtVhP/EE69yJlTBsUoeI3K5bIoNJrNZoTDYWxvb8vnpnqhzWZDt9uV1xtURrTZbEgmk8jlciLeQphtoVBAt9uVhEKr1cqkzGq1imLmxMSEcCNtNpscmr3evrppNptFNBpFOBwWH7pQKIRQKCRF8MrKCvL5PKxWq3ThyH10uVzSiCgWi8jn8zLtorE8BViU110ZzWYTa2trovTV6/Xgdrtlkuv3+xEMBsV83ev1DiXqnxRlJ3ES9y9oOcKz8KgxyJ9hHBU2eFhxwcYe5c2HBSfsNDZWBm1LiGR4FDv/B03MjhLkft8Pef+D7pfSukZ53pfLZdy+fVuK38Hr2mg0cO3aNdy8eVPOgXPnzonQiNvtFjVHvi/VHsk1Pmz9BINB7O7uYnt7+1A7BYZOp8Po6ChcLhfW1takgIpEIgLrfNDBPIBeqY1GA+fPn0cul8PKysqBn5tiNcprrNPp5LXI/Wb+wkbzQY1+4OBivtPp4NatW/fh27538dAMpt/LOMzAkpMyynJ2Oh243W5R/qvVasjlcqhUKpJ0EsrHAi8YDKLT6SCVSgm3i6GUdj9ILYYLy+FwyCSOCoEMToCIfbbZbAJXU5o2DoNJ8j1UKhVmZmbg8XhQKpUQjUbFq4JiGUoo56lTp0QAY29vD9vb2wcufuUBMmxSc9xgkTJs6nSvQb4Qx+SUyj3K3ylD+Z28Xq/wz7RarXjDtVotmW4pg4UOhSKoqMUDwev1ijk2eXLKzUi5CSkLsGE/5+fzer0oFotIp9NDSb9KbiQ5dUroQiAQkMnp7OwsgP3NnwUnBUAGX7fX62FkZEQ6ur1eD1artc9QmmEwGGSaPDs7i3q9jps3b2J2dhYqlQrLy8vQarU4e/ZsH1SwUqlgfX0du7u7sFqt8Hq90pjgxk71UWV32mKxYHp6Wnhg0WhU1BuLxaJcU4PBIM0LAH1TzsG1zX0jmUxiYmIC4XAYvV4P29vb2NzcFPjrgzBHVcaJwfRJvJ/ifhtM34+py+DrUIX2KJLvHo9H/Jy4T5Avo7Q4IWriOGG324WzrZRrP853+WEIUhAGoZIqlQqjo6Pwer3Y3Nwcqh49PT0Nh8OBeDx+4HRFKb1OKgn/t9VqFbSI2+0WZd+7XfvJyUns7u4eq0FHlNB73dRjjkiPW4vFgnQ6jVgshsnJSezt7R2bE6bVakVUDdjPldiwDYfDKBQKQwtOn8+Her3ep14NDNdyeFTibmf0D21hdhA5dWxsTDhCLMjUajVcLhccDgfK5fIdRdNBodVq4ff7ZZNWdoEIh6QiHFXbut2ujHYBCAGW0MrDbpfBYMC5c+dgNpuRSCRw+/Zt+dnMzAzC4bAshkKhgNXV1b5k1Ww248yZM3C73Wg0Grh+/TpSqRSCwSCKxeKBXSyHwyHQN3phHGfypAwlPI4cLn63d0tCNRqNQiQdnJoe9PsOh0OEMCi3nkwm+37vqH5UJpMJgUAATqdTTCyVm5fRaMTp06cFf0+jaRb0BoNB+EjDOkcajQaTk5Po9XqIxWLCdxsfHxcIonJtHRRUgVSpVDLR4sR0ZGREYDjJZPKONcHOoV6vRzweR7fbRTAYhEqlQiaT6TtAaBJNsQ6aSpOXpoSj0OSy1Wrh7NmzUtiys1yr1WTN8DNptVq43W5MTEzA4XAIrl2l2pfSv3LlilwzFmTZbFb4YAydTge/3w+/3y8cte3t7T48PveMqakp+P1+rK+vw2QyYXx8XERHWAA+aLPXk8LsJN5PcdTCTKVSSaL7boUAjhJWq1Vg8GwaDfo/HTXIi52ZmYHVakUymcTy8vI9vda9xNjYGPR6PWKx2Hv2nvcSFFUhlPReghPSh8W7oyL24BlN6sH9tBJ6GMHmqcPhwM7OzpFhowxOVO+Wz/J3p6amEAwGkUqlsLq6eujv+3w+zMzMCAVjfX196O9xwvewyp+TwgxH2/h1Oh1GRkZEulwJtXM6nXC73ahWq0M7KJzADNtIPB6PeENwvH/QhnFYgs9JD7tsVKijkluxWMS5c+fg8/lQq9XwxhtvoFQqwWw2o1qtwu/3IxAIoNlsIhqNSuFE7hL5TYuLi/B4PAD2ce5vvvnmXTcS+ntRWe84XUDCPA/bRJX4ZaXi5HEmD+xW1ut1+Hw+KS4ikQgmJyelkFBOf7xeL9xut5C0q9XqkQ08LRaL8AMIIWSBT6NlZYHndDoFB12r1bCystKnYulwOOSzUOlPrVYLRl6lUknR1Gw2sbm52VeAjY2NyTNA7h1FWYatW7PZLNPhRCIhBRX5Z4T9HXTflHy04wT5YCaTCbFYDNFoFKFQCPF4XJohExMTIjKSSqX67hlVHoknj0ajmJ+fh9vtFpVJduI4CV5dXUWn08HExATcbrfwC5SfndyypaUlOBwOdDodFAoFrK+vS3PD4/GgUChgYmICLpcL+Xxe1hRhGmxcPMg4KcxO4v0Ux5mYmUwmeDyeO4QhyI0eZsj8KAXVV9vt9rET9Pn5eQQCAWSzWWxvbx9rH6En43uZ7qnVatjt9gOhofcaTOpHR0fvmUNF8+rj7sVarRajo6MwGo0HQvV+GMLv90On0wmk9lGJYDCIU6dOwe12o1Qq4fbt20NhoTMzM+h0Oncojr9XcVKY4Z2NX6VSCUwLgCTIg2G328WbgnLrfIiVstwqlQp+vx+dTufYXiLsGiiFDIYF/ZE44qXgACcNVN7z+XyYnp6GSqVCLBbD5uamcK8ymQx6vR4sFgtarRZmZ2dhsVgQiUSQTqdFBRLY38DD4TB0Oh2q1eo9KyMN+773Y6mNjo5Cq9UimUwe+4HSarV47LHHYDKZUC6XcfPmTSnuWPxR/EFpekypVpJTlQeNyWQ6sEC02+2w2WwCZaXxNIsZZcE5NTUlRdn6+vodMFSfzwe73Y5CoYB0Ot1HBqdaIYnlw7rJhPlZrVYA+5C8dDp9x/onHJMdP5fLhV6vh0gkIiIYwWBQitx0On1o99poNMLlckkhc9g9s1gscn3Z1VWpVAJt3NnZgd/vh9vthsViAQCZ3FF6f2RkRCR/M5kMVlZWMDIyIqqJDodDPu/U1JTg2TudDpaXl2EymeByucTfj5+XypeJRAILCwsYGRmBVqsVGCqfMeW9NxqNqFarD7wQG4yTwuwk3k9xv6GMDyMOOwfuR3Bf9vv9grZ4r/eVhxVqtRqjo6P3lIuYTCaMjIyg0+kcibd1t6D9i1qtPtQE/EGF2WzGyMiIKBgD+01bNmObzaaIZ+zu7sq5/aCCgmnAe8+RJr9+b29P8hiPx4PZ2Vm43W7kcjnE43FUq1W02+07BHL49zs7O+/5dPWkMEN/YXa3r3tY541qf+S2HLfYoKT+ME4OcPDmTon8wyZLgxwvZdLP70VZUmC/4+Hz+dDpdJBMJlEoFIRnN+z9lcUjoYbk3VSrVYGZ8f3vZyjx3EzKaYJ4lGDnbm5uTuBza2trSCaTUKlUePLJJ2EwGLCxsYFyuQy9Xi+KXMRRz87OotFo4OrVqyJ+MTk5iU6nI/L2BoMB5XIZiURC7hONKCnZb7FYMDMzI+IQr732Gh5//HHx0IrFYkOhbvQ8G7w/VNRUThA57SJv8KiEdbvdjoWFBeh0OhETocDH2tqaPA+Tk5NSIO/t7SEajd6XJMFsNsPv9wu5PZlMQqfTIRAI9HEqlO+fTCYRiUTgdrvh8/mgVquRz+fFXsDn84maZT6fx9mzZ2VDrFQquH79OgwGA0KhEDQaDXZ3d1EsFkVymPsGhUs4Bdzc3MTc3BzMZjOKxSK2traG8uyA957XcVKYncT7KX4QCrPB8/ZRCqfTCavV2ncuPYpht9sxNTUFt9uNaDSK1dVVUdF2u91ihzI5OQmNRoONjY1D91Y2LdVq9X0rYikcRm74exnkczkcDtRqNezt7SGfz4tVD5uZHo9HFEnb7bbYuAAQYa1qtXqHINpR1m8oFEKv10M2m0W9XhdbJY1Gg1wu99AVD/V6PbxeL/R6Pba3t2EwGLC0tIRut4vl5eUHzu8+atztjP6hUmU8SoLUbDah1+sRDofRbrfF/BfY7/57vV4hGlL+fmxsTHhkLBYoyQ1Apg9345YMLhoWfsMUHAGIKzuAPk7aoGAEvxcjHA4jFAqJl1az2ZQpHMNoNGJ0dLTvOwEQXyZlB4KFCk2l7/fiV34uKiAdBS5JnxedTgen0ynTKrq+W61WTE5OQq1WY2NjA8lkEm63W1Qz2+02zGYzXC4XGo0GIpEIwuEwUqkUarUatre38fzzz2N+fl66NpSS93q9ovKZy+VQr9dFDp6Kh/TW4jVbX1/HuXPn4Pf7kclkcP36dbmvw64pvbQKhULfxms2m1Gr1eTfvF4vLBaLTF0LhcIdqoA8cAhFjUaj6PV6CIfDggVn0UZzRk6fy+UyjEYj/H6/yP6Tf6XRaEQ8g1MoesO43W4pAsvlMqrVKlKpFEZHRxEMBkVURwm3DIfDMBqNWFtbE4PrbrcrkvutVgsGgwEjIyNwOp1otVpIJBKyhhOJBGq1mtyD+fl5bG9vY319XeCiNpsNuVxOjKk5NSwWixgZGUEoFILT6cT6+rqsw2GH2g9Bz+skTuIkcHSPqvc6RkZGUCwWsbu7+9A/490a2UQAUXUaQN/eziCHvdfr9TXZBhvpVqsV09PTsFgs2NnZueeJmUajgcfjweTkJEql0pEV/ugNq2yacsJ02HSJ5/fgtSLqJJPJoFAoCDR1EIWSzWaRzWahVqsFJcNGM427Sb1h8UpbobsFz3V+tkKhIFYB7/XEzG6333HfqbrscDjwxBNPIBaL4a233gLw6D6jw+KHamJ2lKDJIA2eCWlstVrweDzQ6XTY2dmRm0w4Y6vVEuU54B21HCopHjcGp1QHfVa+B2Ow8zE6Ogqn0ymTPv4+k/NqtXqH8qFGo8G5c+cEVnb16lX52TD1Rb6vyWQS4+JhHmGEdr3bOGp3h4qbhGoqJxidTgeBQAC9Xg/5fF5kiMvlcp/4g8FgkImdUoRFrVbj2WefxcjICF566SXMzc0BgJhc02y6Wq0imUwilUqh2WxCo9GIahA3TofDgeXlZYHpzc3N4bvf/S7m5+eh1+uRSqUQj8eF08XNlKqN5D+ZTCZkMhnU63VREK3VanKIKQ+7brcLk8kk3KtMJoN2uy0YeqoJKs0xfT6fiJFMTEwIJ47XN5/PY3NzE7lcDn6/X6ZWarUap0+fhsPhEF7X7u6u8O0ymQxarZZAbSuVivi4tFotRKNRWZ+cXmo0GuTzeUQikb6DifBT8i4psavkoNHzrlKpoFgsygFntVrlWaFlAf8/5Y41Gg0WFxfhdDpRq9UQi8UQj8ePVIRptVopXB9knEzMTuL9FO+3iZmS2/swQ6/Xi/LgQaH0UH0Ug9Mfnq9KqfrBQsvr9aLVaqFUKvXlX8DwJhj9LYPBIAAcKBwRCoUQCARQLBYPNDOmSvSgR9u5c+fQ6XRw48aNO/7GZrNJ3qHT6e5qIwS8QzmIRqNot9ui4NnpdEQJ8aj388knn8TMzIzkMtVqFVevXpXz6ijq2WNjY3C5XLh58ybC4TASicQDPb9YBM/OzqJcLvflngyn04mxsTGk02mkUqk7psA+nw/z8/PQaDSIxWIHCoA8zDiBMuL4Gz+7GjRhZkdAr9ej1+vB5XJJJx6APLAHyZrrdLojyb6/Gx4WCbEsFLVaLbLZrGDTCc2il1OtVhMjbU569Ho9fD4fcrkc8vk8HA6HwOGUoYRFKr871SUPmpgN+36UjD/u9z6IH3jQ+wKQ+8nikMa/NOskB5G+bhSL4Ger1+t9huSnT59GvV6HXq9HKBSC3W6HRqPBt7/9bXg8Hni9Xvj9fhFXqdVqqFaryOfz2N3dRSqVgl6vx+nTpxEOh6HX6/HGG2/A7Xbjxo0beO6552C32wUiEI1GhR+lXF+EIdL2gB51LJjoD8aOZK/Xg9FoFCsH8rQ4zeM9JHSQKlNKXp9Op4Pb7RahmGw2K5YSnL62222YTCZ537m5OeHDbW5uCjyQ15h2EbzOlNRvt9sikd9qteQe8P6wCcL7QCXESqWCdDqNtbU1NJtNLC4uCpyYZPhMJoONjQ202+2+xECn04k0tVK0p9lsSjEHQCarwyIYDApcuFgsStH8oLfck8LsJN5P8X4rzID3Dro4NTWFbrcrhvbKYPPtuP6b70VQAfdu6JnjFI6DeRaRFdVqFVtbW0MLBqJKgHcMwW02G0qlEk6fPo3t7W18/OMfl0T/zTffxPb29h3X2u124/HHH4dGo8G1a9cQi8UAAM8++yzMZjNWVlbugFYqm9hHLaiUXqZTU1Ow2+1SgBx3IkVht16vh4sXL8JiseDq1atyzikbngeF3W4XpWOK0z3o88toNIoEPnn5yvdkg1MppEchPNrR6PV6AJChyqMWJ1DGewgmfMViUeRbOTLmhECZtA7rglDenBydcrnc5xVlNBrvwD5z8Q3jmh0k7282mxEMBmEymSTh5YbIDg0/d6/XQ71el3/T6/Vi2gsA8XhcJMadTieKxSKKxWKf1xWN//iAdjod6HQ62UwGk1QmuYO+VXcLXiMmw4OhfB/6iCiLqMF7AaDPmwvoN51ut9syHaNyFvHptVpNZOZdLhdKpZIUQZyqXL9+He12Gx/5yEfwIz/yI9jb24PX64XL5UK1WkUsFkMmk8HIyAhmZmYwMTEhGw4nR+l0Gk6nE6FQSLzRKO2+t7eHZrMpk1Tl9yAsgRBWCk/wGtHzjubSnJKyYFQKV6TTaTF+7Ha7mJmZgVqtxvb2tuC3M5kMwuEwlpaWEAqFBLfOIpGFfjKZxJtvvinF18bGhnRD+X9K5UlCPi0Wi0hKM+ijBuCOA5hdSfrFkMPJqXe73Ybf7xfvM64vKjsC+4c8n20WkoVCAclkUlQYeV1YUDqdTpmAUdik9/+820wmE0qlEgqFAtxutxySjwrG/SRO4gc13osp0VGKMp1OB6/Xi0Kh0IcUYV5QrVaH0g4YTqdT9hKv14u9vT2kUinZ/+gPea8FIpEFSn74/Qgm/oMem8NC+dmHIYCUwfNao9FIE7FeryOXyx34N8wLgP378YEPfADNZhOvvvoqMpkMzpw5I8q8uVyujxbAIOXB6XSiWq2KBcvly5eFikDqyuC5POy/lWGz2TAxMYFSqYTt7e0+dEcmk5HzjJ/jOD6Y9Xpdik6fzweTyYRLly6h2WwikUjgrbfewvLyMtrtNhwOx1DF6XK5LJ/nfq0Rm80monl7e3t3oKgajYaobQ57jgeVzbVaLYLBICwWC7LZ7LEVux/F+KEtzCjIMHiDKfyhhEBxpExSJZNxm80GAAeOpy0Wi0ynlGIQJpMJGo0GtVoNJpMJDodDlOgILRtcWJwoGAwGVCoV1Go12Gw2BINBuN3uvmkIeUJTU1NSNLGI4jSs0WiIoASLM7fbLZ9jdHRU4HLAO1A2yu83Gg3pGg6SSJmI6/V68Wqjj9Ng8LMNKzq5UQ8rzJT/ZjKZZIrHz8b7aTabRRDioO6QkstXLBZlQkrYIf3H6AdGHzEWuSzaAoGATNqoiLm1tSVKl36/HyqVSooW+nBZLBZ4vV6YzWaMjo6iWCz2Jf4siunjwwMvlUr1Fb5OpxPdbhelUknWcKfTgcFgQKFQkCKasu2JREK851QqFeLxOLxeL3w+n/j1UXSmWq2K0IXL5UI4HEYgEBD4JSdRnCjp9XqR0qW0LrlihPwO3nceOlxbyjVFbqAyqKCo1+tRrVaFHM771+12ZZ3k8/m+Z8put8PhcEhhqNPpBIrLya/T6UQ+n0c2mxX4DA8nJkW8NyyW9Xo9SqUSNBoNtFqt2AoME24ZjIO4BSdxEidx9HhUoHtarRY+nw/BYBCRSETOP+5lWq0W8/PzB4onVatV3L59W5rDbK6l02k5WzktIyzeZrMJN/ZuQZEwq9UKvV4vAlTvVj6cZ+ndCkaVSgWv1yvX46jCJN1uF6lUShBBo6OjsNlsiMViqNVqCAQCGB0dFRg8ET/tdlt43KdOnUKn04HJZBIxJ56ZOp1OIIQsnEulEjY2NpDNZrG0tIROp4NwOAy32w1gX3BDOSE7atTrdcRisaFFT7lchkqlks/JsNvt0Ol0yGQyUKlUsFgscLvd2N3d7buG1D+Yn5+HxWKBXq+XYUC1WpVmOhukpPAoz8lh9/DdesoyrzpsfRynCGTT9G6qz++n+KEtzChoQGIksF+sMRHlxk4/Jo5Gc7mcGPdSLpswQuCdJJ8JW71e75sWKcU8VCqVwAwpt3+QD4vNZpMOEScXLpdLeFvpdBo2mw3j4+MiD0roIid+9K3iGJjJIxPvWq0Go9HYNzkgv4oQPybf3W63r4PDh4zfjw8uO2cHPTAHmQyy8DkolH9Tr9dlgxnkyun1+qHXk2IlykRYWajzc1ssFjgcDrhcLvnuLN5brZb4gfV6+3YEb775Jqanp+F2uwVCpxSPaLfb8Pl80Gq1kvSbTCaB/K2trcHpdMLj8cBisaBWq8nUh9edXTom8hqNpi+pbzabImLDUT7vF73JSqVSH7+K3EoWOlarVSZGlUpFIKAulwsjIyMwGAzSvS0Wi30FYzQaxfe+9z0A+wX03t6eXE9yHQc3XhaYfM6U64X3Z/A+8l7pdDoYDAa5P/xOzWYT9XpdnlWSn9VqNRKJhEy+yJ2jiInJZEK32xV4RLVaRS6Xg9frlfXOazJs3XY6Hek01mo14dkdxgXl9+E0+iRO4iTuLR6FogzYTy53d3fvgPRRsEiv10tjdrAwYwM0k8kgGAxKM41NPk7fWXT0ej1R2jsq5I0qz8wD1Gr1PRUXw0I5+TkoWHSQh3/U+0Y0ArCPdGAelEqlAOzz1ohoMZlMfdcoHo8LlN3r9UoeQPSIWq3GwsICwuEwqtWqqDfHYjGk02nodDrhf01MTEiDk9Mu4B3oPxvwzAGHBbUJDrqGyt9rtVrCr+K9SqfT0lBW/v7k5CQ8Hg8ymQxu374Nn88nXrPKBibP1FarBb/ff0cDczA4vOC9O8o9I5xUyXXjREx5zrM5ehQuHsNoNIrHLLCft3EYoESpvd/ih7owU/5/AHdsEIREcPPi/1HcoVqtCpxwWIeKBZJy8XIxUqSAOFomYweJY1CdTqPRwOVySaeGDxgl0tkBAvYVdKhKyMSXxQ6nZGq1WmBzhOiRtMqik587n8+LvxkTVyb/fJCUDxsTU77+YfdhMJQQhMOMt4F3oG0Gg0ESdMIqufkMwgzISRo2mWRy3Ww2pUhNp9PCbWLBRKUjTh5brZbg2ZPJpJCNC4WCQFe5aTQaDRQKBdRqNTE83tnZQS6Xg16vF+GKZrMpU0wSg7lulBDRSqWCQqEgm7PNZpO1wGvHgoFTSK51wkY1Gg1SqRRsNhv0ej0CgQDUarV8Po1Gg5GREVitVqRSKTidTjidTqhUKlnH6XQaOzs7KJVKohjKNZLJZGSSNawwYWF8GCREGTzUlNBFAJJosFBtt9vCGWN3OJfLiTJnIBAQAjqf72azKVBETvCobMnJrFLCnwUcFaEoGsR1xGtx2Drm+5/ESZzE/QklNPm9DKfTKV6RB0Wj0UA0Gh2atPOM6fV6MJvNIpJEZAT3XP4t4ezHkYXvdDpyNjKfeS/5OL1eD6VSSQrVo4byd8kva7fbkgdQ1IxNyVAoBACIxWLo9XrY2dmB3W4XBAjPcYbBYJBGKc92wk7JJ6OnaTKZxM2bN2VKOzMzA7PZLNQDJS/u3axB/i0RKcr8SFnIkD/n8Xgkl1T63VYqFaytrYknnMvlEjgshb0OC+Ykx7lfgxNsNo6H/d5xxfIGf5foI9IahgULxfHxcbHm2dvbe6Qaoj+0hRlDmZgPLhZ2oZSbI/AO/4kbyrAk8m4dIz5YNAYeVnywK6JSqUQ4wuv1yrSFvCKj0SgS3zS0NRgM0v1iZ4x8GE78mHDzoSUXjlAJQjZ5nWq1Wp9aJDtSBoNBklAl10gpn3+vSj5H7eCxU8KpDTdbFjCc2iknl4ObEPlPZrNZNmROlTqdDiqVioiEVCoV6HQ6maQp4a7JZBKtVku6nqlUqk8tkGIj9BlJJBLY3d1FJpOBy+XC7u6uCHPw3hDnHggE0Gq1kEqlpOvX6/XuKHo4pSPcg8Ug+YY0c+a9slgsUKlUIkwSCoUwMTEh/EMKerATVSgUEAwGEQqF4Ha7oVKphI9I83NujGazWQ5hrgMlVBF4pxN3EKfwoODa0mq16Ha7fZNO5cSQa9NgMMBoNAp0s9lsCqeSz3upVJK1w26r2WyWKS4VPXlYV6tVOBwOScYsFgsCgQD0ej3S6bRI9CvX8kF7w/u1w3cSJ3ES7wT9D4vF4tBnmudPOp2Gw+GQ6Us8HgfQjxigZ1ShUBCV2LtJrh8nlCiLw4JNx/uVwCqLi8NCpVKJ3c1gLpHP52WPppVPpVIR2KjdbhcKAc+6XC6HWq2GXC4ndkjkiHW7XRSLReRyOUHDMJgfMdbX1yUX83g8mJmZwcLCgjTsisUinE4nfD4fms0mUqkUisWiNDuJgGJz7yjBQpLFBb00SZfRarUolUpIJBJIJpP40Ic+hImJiT4fVBaJvB68F4OWScOCxfxx4yhrZpA7dpQY/LxKionyjKWNFLD/bFYqFTmjB8/mRyF+6Auzw4KLhLBEEkNNJpMkzpVKRW44p1JKvslBghScJilVgxgsqtjJAt5J2Mgt4uJjMUJiMGGObrcb4XAYarVaNiL6cynVBRnkdKnVamQyGRELUareKD8PACla2ZWknxkfeKvVKuaH9+M+HBYkDQ9aFCi5aoMFNO8b7yU3J71eD7PZjHa7LfBPo9EIs9mMVquFQqEgwimcRrIoKhaLSKfTGB0d/f/Z++8YyfPzPBB/Kuecq7s6d093z8zuzs7sLnfJZRJNUqSDRNO2JMs+n+3z0XA4GD7cQTj6zsLh4DvAgA3cAZYcANm+ky2btiTIEiVZpFbkkruzaXYn9UxP5+qu1JVzrt8f/Xve/VZNdZrpSat6AEHc6e4K3/rW5/N53/cJiEQistnG43GUy2WhrkxPT6NcLuPatWvY2trC/v6+vI5sNiudN052vF6vUC8YoNxoNNDpdIT+p9frYTQa5R7k4qR0MeKkkHlnvH9ocgJAiotGowG/3y/cc76Wdrst4vVUKgWXywWTySTBlQaDAbFYTK4vw8t5mBh2T2i1WlitVrmGpzl0cGrN+5DURavVKpz5RqMh01NOxDhZ5QQbgGT+lMtleSw6Wiq1bryX+Jrb7TYWFhaE1ss8tUAgAJVKhVgsJp/HqPgaYYTHg5NQ6h4F2MTj2eEwkEURDodRqVSkMFPuz/l8XqYkyj35cYPTn8cNNg6PM77g3scGLM8C6XRa3KmV8gOfzyexKpw0sfBh042fo8VigVqt7iu0U6mUPHe5XMbMzAzy+TzS6bQ48DocDqFKKh2d9Xo97HZ7X0FAVs1xkUK8n00mE8bHx+V9sNm4traGvb09aaI2Gg0ZKgAHTUbu0WRB9Xo9eL1euQaPEhxqDHN4pHyGhnOndRsdNjVWnrHZEM/n89jb25P742lzbhwVZieAUu9EmhTH/ryBlIdCduepVTlqIR2c3BgMBng8HtHHNJtNeTx+aSuVihRuvHF1Oh18Ph/sdjsCgYAcppmzxL/hIdRsNvflWrHAIgWMuU3UaHHqohxjc8Iw+H4IamtO2hUb/PvTgC56ysfiezvOotxmswlXmSNwZSad8rBPWlwoFJLrSxqFSqXCxMQE5ubmpMgCINNW2rnXajVEo1Go1Wokk0kEg0HhSfM9RKNR6HQ65PN5MbFgMUbhM4A+zWCn0xG7e3ZVbTabXA8uwLVaDYVCATabDcvLyzJ1Y1d2aWkJOp0ON27cQK/XQzAYFAqgTqcTemcsFhOnS6fTKVMlr9eLxcVFpFKpPudKpSaMxiQEGwYshJSFmbKoHuZOyvuXAulSqSS6NjYbuFGT7kkqCq9Hs9mU4k2n00nHm0UZPwefzwe3242PPvpITF68Xq88xtjYGFqtFtbW1sSgh06npK4OdvNGGGGETxaOojAC/bmf5XIZ6+vrRzajWOTxPPEk1o8nZazQ7XaFGngUGF9kNBrhcDjQbDb7zFGcTqewibxeLy5evIharYYbN26Is3O1WkU8HpcJVLlc7mNAcGpHKM8aH374oew5fK3JZFI0ZIMSj729vb7zk8PhEGbLSZp3zWYTGxsbyOfz8Pv9CIfDMjQgRfTOnTvo9XqYmpoSd+XV1VXJ/4xEImIkQu36oyzMVCoVbDabSHOUZ0Put0ajURq5StfmQTgcDmkoK9lQgyDNF4AYcgF44MDxx4FRjtkpwZtH2UFh14siTN5YnFAddol5YFTSugKBAAwGA5LJpGjYWBQNZqMBkOyoyclJseXmDZ1KpXD37l2Z9PD5rFarBCGTTsAQXVq0h8Nh6T5Rf3YcX1+tVvdpaTitedBuBAvF01I2lLo4vmdO847qYDKomdRRvk9SBLg4a7Va4aCzOE6lUlCr1fD5fNKdYoePhjF0AmRH7otf/CJMJhPS6TQ+/PBDbG1t9b0eOjMCEAtYpYUsi38+JqmDKpUKU1NTUpT1er0+PSAdF7vdLmZmZjA2NiYi6Wg0CqPRiFAohF6vh62tLbHgZ4g0HUmtVisAiM4uEonAZDLJvzMm4Pvf//595jj838oA68O+J0qe/nF6Q047Kaw3Go3iLsouKItrdlTpwJXJZGA2mzE2NiZ0h729PZRKJWmgkPaYTCblvoxEIggGg4jFYrDZbPD5fNBoNCgUCtjb20MikZB7iN+PR2nnO8oxG+FZwrOYY6bMwHwQGAwGjI+PC3X9JCH13JtKpdKZ0Rg/ieB6nEql5PCtVqul2ZbNZqV52Gg08MEHH/R9joPNPzoZa7VaZDKZvt81Go197r+DoGZZ6VTJxq7JZMLGxoacjxigzbPYcdDr9YhEIvB6vbhz5w4mJydF5sDGgMlkwuTkJM6fPw8AWFtbw8bGBjqdDmZmZjA/P492u421tTWsrKwMzQg7a1AqwmkeQUfk4yaGwMF1f+mll2A0GrG9vY3d3d0T/d3TglHANM524efEgIYDPp8PRqNRCqnB31VyeZXdFR6U6doGQGhlHKEDBwu43++Xzo/X6xVb9HK5jGKxCK/Xi4mJCZl28UDMHCij0Qi32y2cZh4UWaSwOKSBAXBg/8osrEwmI9b+JpNJpg6Dtw6NFICDDI7BYOrTgovESRapYRM36ug4BSO97bDXxfwsLqacwGQyGcmjomuQ8jPitAqAdMyUJiIMTGQGWiaTwWuvvQar1YpisYj19XVsb2/LhnDYgkgbd2VoIkfzjUajb4Q/WMzbbDYRjbMw5FRWo9HA4XCgUChgcXFRXMA4Vc1ms7h27Zp87iwums0mbDYbwuGwUDVarRYuXrwIk8kkjow3b94UygSneXQlow5x0LnqLAJc2Ujgc/IzVt7DOp0OwWAQBoNBmhKBQKCvQI9Go9ja2pKutUajgcfjkaI/kUhI2PbOzg4MBoM4hXU6HWQymT7ay3HF5cNiVJiN8CzhSRdmygYRv9NHOc5xryTV6kG/y5QdJJPJx0Zv5voFfOwO+SxB+dqVbthKeDweuFwuVCoVpNPpU9M/T2MH73a7ReZyUnBa2mg0ZC9l4/i0BZFGo8HY2BhmZmZQq9Vw9erVvp+fP38ebrcblUoF9+7du88Qg7IGSlj8fj9cLheKxeIjNcRgM5TvWymlOYm5yLlz5zA9PY1er4d8Po+trS2k0+lnRiYwKszwcAv/MOoUjRyUB6/jYDKZxEiBkxwWUUfB5/NJoDVd8IADQTBH0ZFIBMABF/2jjz6Cw+FAr9cT+1i/3w+n0wmDwYBisYhkMimLAl8TdVT1eh1jY2NQq9X3TXCAjw/MPHgPdo88Hg+AA1oBf6a0y6e+aFB4+jDgeJzXlC54PIQz94TGHqR1Dj43N2fqA5kbVyqV+oo5tVoNv9+PiYkJAMDOzo7QKNgFbbfbyGazyOVyQp2gA1A+n8fk5CTK5TKSySQmJiakgOh2u9je3h5KG1EW94NOR0oYDAZMTExINhodvIrFooz8KQTme2NHkVb+RqNRgqpJWZycnIROp8P+/j42NjaE1ttqtRAKhRCJRCRCgY+dTqdx+/Zt4fgz065UKt236PP9ncVhgTROTrKTyaQIrh0OB/R6PcrlMnZ2djA+Po6JiQl4PB7R+K2traFcLsPhcCCXy6FcLiMSicBms4mzlTIIngJ1OmaySKU286jJ+VljVJiN8CzhSRdmnPKr1WrYbDZ0u90+jewnCQ6HA8FgEL1eD8lk8lQFxWE4zT7+sGt8IBAQsyufzyfMDyU0Go1kbPLQfhpwH+bjkhlzEkv/0/yu2WzGZz/7WaES6nQ6bG1tYWdnZ+jfKrX8yvesUqnEhCyXy4n0hXsz8z6z2axklg47g/FxPB6PmMnt7Ow80mKHGbSUinDY8EnHcXv0SGM2AGUXhgHFytA90vWKxaLcQMoD2iDYCaDeiFoi5XMc1ZVgccX/zf+2Wq0IBoOw2+3I5XKIx+OYmJjAN77xDTSbTUSjUWSzWSnQ2LHnF5HBl8BBEaXX6+FyuZBKpeQAPZjKTqofzUQGwbBE5WTQYDDAbrfL61a+V5vNJpxqBjk+CLxeL+x2u1jWNxoNcZkqlUoidqU+j9ePRReLoGAwCKPRiEqlglwuJ9eMeWhKsSr1ekypJzglymazMtWiAYvS5Wl1dRVqtRpzc3MSWs57gRMe5cSVUy3SJOn8NGwBZ8HNXDBOz3K5HPb29qQwZaYY3QpDoRCq1Sru3buHxcVFmM1mZLNZMT7hBNBut8Pr9YrjI4O0o9EoXnjhBbHbdzqdshG88sorcl9xShiLxeTnLDQH3w87a4dtDvxuKaeWwMc0UmokaexSqVRQLBYRCoXknt/Z2ZFrwILb6/WKkDqXy4nRj5IKy8enyxaF44yzoK7uOI3jCCOM8ORATTWLlceBk9K4zxqFQkHcc8/qOU/zOA6HQ+zkH2Qao2QBKfddJahrL5VKD0RvU+4jer0ePp9P6OvHaQfD4TA8Hg+i0ajokofBYDDg+eefh9PplMnl+++/f6jZhU6nw8TEBNxuN5LJJHZ2duRnvV4PuVxOpkibm5sicdjZ2RHjmG63i4WFBZjNZuzu7qJUKgn7KpFIiItzNpuVJoXJZJLXpNTcH9UYPgzDWDB0+35YnKQ5cJaN30eN0cTsEJC2R13K0wSLxQKn0ynWqLVaDRcvXsTk5CS63S7effddjI+PIxwOS+GwurqKTqcDn8/XR1NMJBLY3d0VQ4Rer4fp6Wm0Wq37Ok1OpxNGoxHpdLpvUaUrIB0rg8GgTH6UCAQCKBaL8kUMBoMyYaBt7WlhMBhkQkjXzIeBcqLH/7bb7WKnTlendDp9qi+4wWCA2+2G2+2WwiuRSCCfz8Pr9UKn04lgd9h1sNvt8Pl8kk0Wi8X6fq5c9EhbpBCYxcnq6qoYdTQaDWSzWahUKvh8PszOzgrV9datW9BoNJifn5dC6qOPPpIiipMxTsQYzEmTmHA4jEAgALPZLNPZ1157TaiUpVIJe3t7eP/994VKQeviswJpqzR14WMHg0FUKpX7KB02m02cuoLBIDQaDeLxOGKxmFBRgQNaKzcqvp98Pi/FHDV8DH9lHMago+mjxGhiNsKzhCc9MXsUoONtPp+/b08yGo2YmprChQsXoNFocPv2bdy4ceOxvC6j0SgH/Ewmg2g0+tjPN4dREE8Dp9P50FKJYXC5XKKv39vbQ6FQgNfrFSc/umYehqmpKdjtdiSTyb7m7DCwGUpn71KphOnpaZhMJqyurp6qcFWr1Xj++edhMpmws7MjOWVKMMdTp9PB6XQiFArBaDRib28P7733nmjDB/fGYDAIk8mETCaDcrn81BU24+PjCAaDaLVa2N3dHcpgU6vVuHjxIoxGI27evHlqt8ezxojKiNMv/Eq3todZQKg10Wq1EoR7WtAKnMHNdrsddrsd5XJZphkTExNy2L5x4wZ+6qd+CoFAQPRZPCBy+tJut8XWtdFoiK3/YR2oQTCziTROdv50Oh3m5ubgcrnEdahUKmF8fBw2mw2NRgMrKyvybxqNBvV6XaZJDwKj0XifI4/JZBLnHxYfzDdT5rCdFLT+D4fDYovfbDbFGOMkMBgM4lxIPdhpEu5JR6VlvdFolCmQEpOTk9Dr9UI/HEQ4HJbCg3lvSkMY8txTqVRfV45wuVzwer0wmUzye+l0GiaTSRb6bDaLVCqFV155BW63G6VSCT/4wQ/w2c9+Vu5LThZv374tr2FQY0bzmcMwWEQPguYoDIA/6rGoG6NzY6vVkgwaulGSGstp6crKCorFIoLBYF9QLJ0ajUYjarUa0un0qYJfHxajwmyEZwmftMKMk4ZsNjs0m9Tj8eDixYvi3ru5uYnf+I3feGyvjzqzh9GYWa3WvpzThwFp7s1mUxwMh+EsdMdHQa1Wi6wglUqdas2mXKHT6WB/fx+dTkfceo869w0akrlcLslaexRHc51OB7/fL94BZCyRDUWzt0EcFf30JGGxWHDu3Dmx/6dz9TAoJTVPGqPCDMcv/AwCJthlf5hFYHJyElqtFqlUSoxChoFOfiqV6r5J1DDQYa7VakmwdKVSQavVwsLCAiKRCDwejwREsys22IGhzqZSqQhtTqVSYW5uDs1mE3fv3h36/LROp0NfuVyWRYVOR9Qh3bx5EyqVCgsLC3A6neKSdPnyZQlFTKVSiMfj0Gq1CAaDcjjOZrNi6apSqeB2u2WiV6lUTkRR0Ol0MqUqFAqIx+OwWCySJ6bX64Vj73a70e12ZWoFQCZlpA1arVYpgEmpGKSEcDpF5yGahBxX4HNyqPw9h8PRxyenyycpioMLPm3/SRt97rnnoNfrUSqVhMJiNpsliJP2/EpOt1qtxvz8vBwuGKx969YthEIhBAIB2Gw2AAedtWg0Kjlr4XBYmgjZbBYrKyv4/Oc/j/HxcRFUZ7NZ3Lt3D+vr68cukiqVSsKgT0NJoSPjYEAoYTKZxKSFk79yuQy32w2DwSATNW62bCDwv5lNUygUcPXq1SMPJ2elozwNRoXZCM8SPmmF2VGg4+38/DxCoZBouf/wD//wSb+0E4PN5kGGCgu+BynWlLTOw/AgTdWzApvsdFge9nObzYZsNotutyvnhmENZ+qfS6USLl++jEqlgps3b/b9jtPphN/vRzQalT3MarWK83a1Wh06FYtEIvjCF74AALh+/Tpu3rx535nS7XbLvndUIXwcaFzyJD4TnkN2d3fvm/iaTCZpqO7t7T1SB+QHxagww/EL/1l0YtxuN5rNpqSyA/cbSwzyco1GIwKBgFAKjwuiVP69Ughqs9kwNjYm1q2lUgmbm5twOBwywaLDYL1eF3pmvV5HMpnsc4wjD9fj8UCn091HmTtqSmGxWMQBqFwuY2pqCo1Go89xcGFhAVqtFslkEvl8Hp1OBzabDTabTYwZrFarXBNlgThMj0eHI2WqPV8LDTeGLWLhcFhiAIDh9AryrDUazZF88UEwt4y0tuMO7n6/X95brVY7sfj1sKnS+Pg4xsbGoNfrkc/nsbq6CqPRiGAwCLPZLJ/7YdRBlUoFh8MBl8uFTqeD3d1dMchgdki73UalUkEmk0E8HpfJJLVwpJdubW3hpZdewuTkJMxmM5rNJgqFghhqpFIp5PN5mU4Vi8Whk7phMBgMaDabQ8152MA4iqYzNTWFUCgE4GATm5+fx8TEhNBKY7EYotFon0CexaLX68Xu7i56vd5T1YkDRoXZCM8WntbCjKyAhz14BoNBBINBNBoNscUnHbzb7WJ1dfWBaXlqtVp0uGd1QNZoNNJg/fDDDwEcFAUzMzPCPmFjdX19XXRXBoNBYleGvU66ED9LUEYAneUar9frce7cOczMzCCdTuNHP/qR/MxsNkvj9LSMLeaoVioVZLNZscY/DmQFzc/PIx6PH0vZfBzQarW4cOECFhYWUCwW8eMf/xjFYhFf/OIXMT8/j0qlgpWVFdy5c6evSR0IBDA/P49isYjr168/wXdwOEaFGc5u4T9MMMsQ2sO+uEqXH2YZkUbAL82DfgxMpWdoYSAQEBML2qHT3lej0SCbzSIajUow8GEiTh7Ou93uqRZTFqUajQbj4+Po9XpIpVKwWCzi2Li1tQWTySR86mq1iu3tbRQKBXFY9Pv9qNfr9x3SuTEoDSGsVitMJhNarZZMJ7VardA2dTodPB6PiFz5+gYXLAZvUxOkzBNRXiMuYsD9fGwAIqitVqtSbJI+qswaoxsYNUmDz/OgYLHH0G26VHk8HrlXyuUyCoWCFKfKnDtl8U/qrN1ul6mqMvuO/9ftdmEwGMQBkhRXm82GYrEIt9uNSCQijmf5fF6otaRS2u12mfLycz6qsHrYhoparcarr74qzZF33nkHgUAAs7Ozot9MJpPY3d1FPp/H9PR0n16t1Wo9ldkpo8JshGcJT2thdhagVr3RaECj0Uh+1d7enqwjJzUCe5Sv0Ww2S6MU+NhdULlH8t8CgQBMJpPQ/Qb3xmF7GJkag43epx104KZb7yDoZH1asMHH88nk5CQKhcKprw/PS+FwGHt7exKIDRwYhJ10fzQajfjUpz6FYDCIvb09/PCHPzz2b8jc4dnzrKHVanH58mXJpLt37x7S6TQWFhYQDodRqVSws7ODTCZzn+eBXq8/1ft/3BgVZnjwhV+n08lhk05/DwOLxQKdTifUNoZBKwsfWpWflN9MW9R2uw2NRoOFhQVYLBbk83lsb29jamoKwMGNUKvVRPxJEwMGJQ97PlqAc9x92EGYdqzU0imnUMDHGR2kK7TbbUQiEfj9frRaLezs7KBarcJkMokujjavNFcAPp5KsqgkGPycyWTuOygbDAaxgKcL4FGUCDoQMs+M9EFuUplMRgKbB21rldeNr9flcgGAWOfzdev1erHzHXw/g9eW+isatFDrdNh0zWw2i8ap0+kgnU6jWq3CZrPJoq0MDWf+HfBxEKfZbJZ8Fpp+WK1WoVsqCzilUyX/m9fF4/Gg1+vJBs6f8ecmkwl2u12KRWXGGXWCj0LkTQSDQSwvL8Pv9wM42Mzu3LmDcrkMr9cLtVqNfD6PRCKBixcvwmKxIJfLYX9/Xww+gIPPWq/XI51On7pzbTAYJOrhLDAqzEZ4lvC0FmZnMTFTOsHp9XrY7XaJv3kSRdgwKF+jWq2G0+mEy+WCz+dDNpvF6upq3++fxhIegDg5P25HvJNOu9h4pOZ+8D09Djc/NpJPOiFTFsBkqiiZTBaL5VSeBnRp5hnvpNNBSgIAPJLQc+VrarfbcgZi5tlhjs1n6Tr6KDAqzPDgC/9Jc6MGodFoZBKkzMIYzKA47AvP31OGWB6lUVPS2XjIa7fb8Pv9EqZbLpf7NgLa2DPbrFKpiClEKpWS4opUL+amKf+eYYCkKQCQQoFfGuBgYeakhpRNnU4nGh8e3FkAccEfLFKVwc0EQ6GpOxu8TixcAfRNKA+Dko5HPZtyqtnpdE4U0mm324UKSDOJXq8n15AUzGq1OvS+oo09r8UgLXZYnonymrhcLlitVuj1ejHoGBsbg9vtBgDkcjkkEgnU6/X7FnmHw4HJyUkReO/u7iKVSmF8fBytVguZTObQRZiTQLvdLq+/1WpJmDSptsViEZ1ORw4ADLikPo6fA0PPH+ZwpIwFoGlKPp8XGqLD4UCr1cK5c+cQCATQarUkgoLmHvV6Hfv7+5ibm5PvDK+r8vN6kMPWWevQRoXZCM8SntbC7FHoQx/GoZXuvdyvzwImk0keE/h4/ebafJimiuD5Y9C8SYmzcGF8UJzkM+T75T4weFY6a2i1WtF5P0g8g9lsRiQSQTAYRC6XG0rXe5DCRK/XY3FxEb1eD2traydqFDKDjDKMRwW73S73qMvlgtPpRLFY7JvyPkt46nPMPvroI/z+7/8+yuUyzp8/j5/+6Z+WLgeRTCbxq7/6q0gmk7h48SL+wl/4C3LYfpR4kKwG4OMMJeWhedgh+rDH5+/x0MyJ0+DhXOkQSCgX0XQ6LYdFJe2PU0DmdfV6PVgsFtjtdmg0mj7tVSaTgcPhEA1Yp9MR+hqLDSXdkc/D7hsP4nxcauJYmKlUKtHlcbFikdVut/smYMO+gPV6Xd7/sGvJRVCn00l4ocPhgFar7bNVZRFTLBaFAsjQRYYfdjodtNtt6aqxcB4moGWR2G63hdLHv+X1Oawos1qt8vekD7Ko5HXl1Iz3QKFQkGtVq9WkgGKBTPfKeDze9/kNXjcWyZ1OR9wIHQ4H9vf3odVqJXR7f3+/77Pp9Xryumg+U61WkU6n0ev15N/YjNDpdDJdZSCmkhJCGirteRkAy0xBFvUqlUpCxfkaBru57XZbNtrB92yz2fpy+7LZLLxer+glq9UqEokExsfHpdu9sbGBSqXS9717mM3hj0FvbIRnFL1eD7/7u7+Lq1evwmAw4PXXX8dnPvOZ+37vww8/xG/+5m+i3W7jy1/+Ml5//fUn8GqH40G754/ie0mavcvlEgOIkxgwGI1GcfUFDvZ5ZfGgVqtl6n8Sd2WDwSCNQmXTq9frSaYojcGOez/HufU9iYOz0WiU5qpSQz8MND/jHn8SPIwRSafTeSCtHRlHjUYDqVRKznDD8CD3bqvVwubmJoCDzzUSiYir8FF/c5Qz8llBpVJhcXERd+7cwfz8PFqt1tBwcWYP0135WYX6ST75//g//o/41re+JXSg//V//V/x0ksv9d209+7dw8WLF/G7v/u70Ol0+N/+t/8NX/3qVx/bl12j0UgRQfCwfhQGX59Wq5XO/UnBQgC4/4umHHsrH1Ov12NsbAwLCwsYHx8XShqLwHq9LgUKD702m02EyJzU8f01m03RRrGAUtLR+LidTqePn86pjc1mEwdHTtYajYYYhFBXZjabxUZdeeBlUToMJpMJgUAAkUgEkUgEgUAAdrtdzDfoBMgNhteSQdSD11N5jTk2N5vN8Hg8cLvdQq1jwUaDDOXrUf4980k4eh+8Jw5bzEjnY4aaxWLpm6yyGFeGTw/eVyyKWUAwJ6XT6cjkcfD16HQ62Gw2yaC7efMm7ty5I0UqAzYrlUqfPoyvwWw2y/3GOAaGLOfzecRiMdGXdbtduV5sBAw7BPB6U+/He4O8dmUMBK/pIMWG9yoPEcrPvlQqSV5ZPB5HNBpFKpVCvV6HxWIRGmw0GpXrx3tqsIF0GpxmHRhhhCeBbreLK1eu4Jd/+ZfFsOlP/sk/ib/5N/9m3+/96q/+Kl555RXE43FUKhV89atfxf/5f/6fT+hV34+nrfHBfd1isSASiYjWehjIPrDb7XJ+oBZ4EKScnxQmk0l0Tkpw7zluAkI2yoMUvoFAAF6v99QNdmamEmyoDr7vTqeDer0urs5HgQ1UZaNwEMMe/0HB6eJpqX/Ks1ahUMD29jZSqZTQ/h8WvV5P9mLeS8d9rnw9D0rzNBqNsNvtMBqNR/5epVKR6eLGxgY2NzdRq9X6Xh+b8JQVPMt4olTGO3fuYHFxUf47nU4jEAjg//1//1/87M/+LADgG9/4BtLpNN544w2o1Wrs7Oxgbm4O/+pf/Sv8pb/0l070PA9DlTiMT30aoS6LHN7AJ7mJlXouml0o/46cYBok8ItEahhzu4rFIgqFwn0W+5xW6fV66RQpaZGciCipmOTJc5oxTFukfG06nU6oYyqVCsViEUajUWzkOUFjt4oTD+q3huneOCUql8vQ6XSiB6OtOqeDdOQrl8toNpvyHslR5udBcMNTvi8aq7AwYhA2X6fH44FWqxUHo8O6aHx/LFJYuKrVailMmXlFmiI1g6T/sVhTfv40neEkic/NopGFKYsbvV4Pi8WCTqcjm5BOp5PXzc9CybPn58HHYTHSbrflXjIYDFJ4Uid2lEuYWq0WS3sWXKdd2P1+P/R6PWq1GgqFgnwXNRoNbDZbnxNprVYTZ1Cj0Xhfl9HtdouWjwcmm80m2ktSew0GAywWC2q1mujwkskkyuXyqek6bNSwwD5LjKiMI5wFer0eVldXce7cOfm3f/fv/h1+7ud+Dul0Gh6PB/V6HWNjY/h7f+/v4dvf/jYA4Fd+5VfwN/7G38Dm5ibGxsaOfZ6nlcr4sDCZTHA6nWi32ygWi32NJ41GI8WWku6uhNFolOYqqf5kpwwznaKx2EkoZVyDBxk3ytdnNBphtVqPpNspDaO4pp3EIZJZsac1aOCaSYRCIWn8ch1lscjHPYsm/qPULHm9Xuj1euzv7z/QFE6r1UKr1Qrb6DC43W6YzWYUi8UTTewsFgtardYj0Y4RfO3DmuWnBR1KdTrdoVE5p328B41/OA5PNZVRWZQBkAqYU4hWq4Xf+Z3fwT/9p/9UxrgTExP4/Oc/j9/4jd84cWH2MDhs0TjNYYpd/Ac5gB12c+h0OukW0VFPaVbBiRGLQjrfcfLDw3+1WkU+n5fH5009+HwOhwPValU6UEctUjzgKo0cVCoVWq0WQqEQXC6XUO+UUwwWDnQ6GlaYsRBQqVSSz1WtVuULySJROW1U6t34MyVYZA/+O6cyXJiUI/tB0xYAUvjSqIPum4NFk9FolCDJQqEgReygMyMnM4dd41ardZ/olwV0r9cTyiYnZvV6XbRdPCSwwCMlcNBhihs3i3Z+jtyM2+02DAaDFHcniQdgoUlDGBatJ934HA6HxEPE43GZYLNg1+v1GB8fh9frhUqlEifS2dlZ2Gw2Me8oFotSkPV6PfnsOFEGDqaXpJzyGgIf5/nRjOa0ICWVTpTKx+B3md3Ip63jP8IfD6hUqr6iDDjoXCsZFT/84Q+RzWbx8z//8/I7f/7P/3l861vfwu/8zu/gv/vv/rvH+pqfJnB9JPtCCTbHjvt77pHKZtdhB2UlZfs4sHF5GNjEPO7xlO9rGFvhMAwrLE+Cwb2Fa/MgHX8YI2QYTkpJfBRrMBuooVBI7ocHKQL4uR82dSWGafSPwoPsa9QoHuVWzIxRntFOcy5mITfs3qU85KQ4yWf/pPbeJ64xu3PnDn7pl35Jcgr+j//j/8BXv/pVAJCA4dnZ2b6/mZ2d7ct9GAQ1NMTDZGco3QRPc1MrcdqOA6d0fP7BrCZOcsxmsxQ/pBWwy0WLdjoc0s5c+XoqlQpqtZoYLXC8rqR+EXTz42uhtmmYMYXSNIWbSafTEVpGq9W6b0qi0WhkUkbnRKfTKZbkfA4+PwscFj6cmLHQ40am/PwGQXMJnU4nOVzk8NfrdbTb7b7PTjmlpB6t1Wr16fZMJhOy2Syq1apch8HwTB7y+Z4YBq78naPuDRa6jEJg4c7Xz9fBLhoAEefyM1NqAVnYsBAddp2UHVZOFVmolEolocQMW+iU0yQW9fx7UlmOKvYHp1FsSPC9sbjkxlMul5FOp6WDS9fLsbExWK1WsfAHDqbRjA2wWq2iD1UW9bTfZdFLd07eI8MOAcNyC5XgwchkMt2nPzzueowwwuPEr//6r+ONN97A3t4eVldX8Z3vfEfMnlZXV6HRaDA5OSm/bzabEQqFcO/evaGPd5b785PEcXEdykbOg6DRaCAWi0GtVsuec1LGzYOCzaJms4lqtXrk1GFwjVLKGc4K3OcNBoMYNikxTEd0mtfAw/lZZNk+CKg/P66heRIcNyEqFAr3fUY8n5zV58b98qgC6TR020GwAT84YVMWnWx0D+owT/s6hn3XHtd98sQLM5PJhKmpKaTTaXS7XfzoRz9CuVwWAwQA9/Fn7Xb7kR/8P/pH/wi/+Iu/eGavUUlnfBwfivLLMviFIZ9YGWCsPNQ7HA4xViCXWUl545SJ74UdG5pwsKCo1+tIJBJyw1PLo7wmgwdPZRFCyp7SMp8GC41GQ3RLLPA4wePr5XvkSJrPQ61at9sVKmEulxNxtFqtRrVaRTablSmM8hqyqOHjcWLCw73dbpcCY9iXmq+NhhXAweHeZrOJ2xbvFz7/oMNirVbrW0TZEeXhf3AzV061gIPFiRQYZVHKwlxJbyTXnt8XOmjx3uKmr9Vq5T6iqyg/Y94DLLKV9Fb+O2mONBkBPu42cSHleyX4t8ctkIMbB/nmnJBRz8bHVKvViMVick0ZcRCLxfoovgCEtqmc4rH45ibDa6rU1eXzedRqtUM3tOPcwHgPFwoFibBg0+EwetEIIzwJuN1uTE5OotPp4Ac/+AHefvttaZ5Wq1Ux4VHiqD36rPfnJ4WHOaQpaVfFYvHYdWJwz1DiLJs4KpWqLwfrJL8/+Nxn3VQi7Z1nhrMETa4MBsOR7tePAr1eD7lcDoVCQZp8w8Cm42HW8CeFRqOBwWC4L/rpYQqlQfB8cxSq1apIOZRN0JM+Ps+SStkJvydsthuNRuRyuSMfe3CPPcl9+7gKs6fKLr9QKGBhYQF/5+/8HXz729/G1tYWpqen8d3vflc2AgD4G3/jb+Ddd9/FtWvXhj7OsI5cJBJ5qNfG6cej/FCG6VSUNwIzRlg8sNOvBAW9rVZLbOprtZrQBCuVCnZ3dyX8eGxsTPQ6nIYw++rOnTuwWq0ygRqksh03FThMd8NChYYRSnoGixMWAEptllLjptPpRP+Vy+Xky84xeaVS6euEsZCi8yRpgoMRAgaD4b4ilOBkiTotLuSdTmeo5pDvU+mqyMchD165OFAMnUwm+64pdVN6vV5yxPgZK22O2VnkYscss0ajgXQ6fWih6XA4hPLX6XRgMBgQCASkm0gjE2oC+XzAx4WHXq+H2+2GRqORwEf+jlp9ePj6g0A5iRzWLNHr9WLY0ul0JFCdxiaD0yngYAptMplgMBjExITBq5yQZTIZtFotmfJ1Oh2hiZ4Wyu+b8n2dxXI80piN8Kjwxhtv4Atf+ALeffddXLlyBb/0S7+Ev/W3/pastcTExAT+4l/8i/hH/+gf3fcYj2J/ftag0+kQDAYRCASwtbWFbDY79GxhMpmkUTNsbTjriQdwOv38MHrck5o+PShsNhtMJhMymYwUasDHBmCPGseFVNPFWikleZDXxWDwbDb7yKfUOp2ur3AaxMTEBIxGoxjLkdp4EtAdGUCfIzOfl9P8k7idKsEhAfEoS6OnWmM2CIfDIZaYwMGHZ7VacefOnb7C7M6dO1heXj70cZTaqrPCUQXIWYCdKuUXhoUAaW86nQ7dbleClIfdyLVaDU6nExMTEzCbzTLW5YRlf39fqHOkFHKjpBFBs9nsS6Dn89jtduh0Ojnkm81moWQNWygO+6JRk8TJD/VN7Bw6HA6o1WoUi0VUq1UEAgFUKhVks1mEQiHEYjGEQiEUi0Xs7OzAZDJBr9ejVCrJRI35VOQj87FZTHW73fscqdiRUhqBKGmiLCap7bLb7ajX6/cVePzs+Lp6vZ5cX2rP+B6V1sbMhRu8zzj1ohUs388gFRT4uLtYLBZPlJHSarXus8NV2vEqu19KnRk3Y04BlcWSzWZDs9kUeueDZLUcBfLMOeUb1KfRSZTPDxx8HmxAZLPZ+16T0kWTpjJ+v1+yg5rNJjKZDGKxGPb39+XvH3RNGDYRe4p6ZCOMMBSvvPIKgIM9+MqVK1heXka328Xq6qpoxguFAhKJxKF79KPYn581cN80GAx4/vnn8eGHH8r6o4RKpYLNZhN33WHOvmdNHzxpUcbziVKzDBxPxwcernijU/bD0EQJmokoG9xk3hQKhUeazUUc9z6Ur02r1co54aRgI5rxOY/a0VylUkm27GGvM5/Pw2q1wm63S1E8zFNgGAwGA86dO4du98A9mi7PZDqdtiAjeF1ocPYoTD9OiidWmDWbTbzzzjt9mSibm5u4du0afuqnfgrAwZf3z/7ZP4tf+ZVfwbe+9S0YjUZcv34dP/rRj/Cf//N/fkKv/NGAJh5KaDSavoWh2WxCo9GI5mVw0VBSy3j4pKaGZhWxWKyPjtdsNpFOp2WkDvQv9sovCznzLFboVgigj26ohHKywgkSKRLD+OFKIwRS+LxeLxwOB/L5PPx+PxqNBhKJhDh5KX8f+DjzhdMi5XVSbjrKBZF0T5/PJ4UFreHp/EijFNrTc+ox2GGktomPyYKONEIW2IOf31F5K7z2BoNBpqYMWAQ+Njs5zUZymOPo4LUhLBYLnE6n3KvlcllcL5vN5n35OX6//1gb3AfBSVy/arUatra2+v5tc3MTVqu1b8qofN9msxkulwutVgsrKyuIx+NYWlqCw+GQYt1oNIqOk3TQszggjDDC04bV1VWYzWaMj4/Lv33nO9+BSqXCpUuXAACvvfYaxsfH8Uu/9Ev4p//0nwIA/sW/+BfQ6/X42te+9iRe9jMBHpRXVlYwOzuLc+fOIZ/P4/bt232/R2aM2+1Gu92W6cLTAEocHgRWq1Xiek4DjUYDv98Pn8+Hmzdvyr89qFFSKBSC0WjE+vq67OGFQuG+4ofN2eP2nbOmcSq1/MDpTOcIatgeZWi2EqRoHoWTOkMOQ6vVQqFQkLNHJBKB2WxGIpFAMpl86MLzSRZkxBOjMrZaLXzta19DrVbD8vIy8vk8vvvd7+Inf/In8W//7b+VjloikcDnPvc56PV6XLp0Cb/zO7+Dr3/96/jX//pfn/i5HrUd7+Ma3dvtdrhcLrTbbWSz2fumGRTt9no9WcjZ2Z+cnITH45EJRrlcFvtU/ncoFBKLcB6yOQkhN5kmIpyY0CWRVLfB68KD+WkXcOqlKpWKTIHy+TwcDocUdMrCgsXqIH/6MAwuoBcvXoTf75ep2sbGBrrdrkxMSqUSMpkMGo0GgsEgXC6XaPiSyaQUSMDB5FfpkETetZIiOUgFPG38AimgzJYzm82nclFifgiDt08SxsgQcjo91mo1uSeUOkalm+RpvhvUJB5FgTgrUEOmNGEBPqa1tFotVCoVdDodOBwO+P1+aDQaaW7w/jebzQ98OCHOev0YURlHOAvcvHkTf/Ev/kWMj48jEolgbW0Nb7/9Nn7xF38Rf//v/335vf/6X/8rfvqnfxqf+cxnYDab8d3vfhe//Mu/jL/8l//yiZ7nk2qXPwxs0gHDzQWAjwsNnU6H8+fPo9vt4t69e3A4HOh0OhLZwrWSj6WklR+2Bx4nP3hceNCA5unpaYyPjyOXy+H27duw2+0Ih8Oo1+uIx+OnnnBRn02t8WHXheeRk051zgJGoxFerxe5XO6BHBJPi8ch1zlr6PV6TExMIJPJIJfLyRnkcflBPCiO26OfuMbsgw8+wLVr12CxWPDCCy/cZ6EPHHS/v/vd7yKZTOLixYt9U7aT4JOy8FutVhFNlstllEolmdzUajVoNBrMzc3BarWi3W5ja2sLxWIRarUa586dg9lsRjabRSwWg9frhc/nQ61WQzKZRC6X6ysW+CV1uVwIBoMAgEwmI2nrHo8HHo8HOp0O+XxeihbeThqNBsFgsK84HASd9ZQFHzcVUiO0Wq0UfkqoVCpMTU3B4XAgFoshm81KcXOYPkz53vx+P1KpFHq9A5v0CxcuwGAwYHV1FZ1OB8FgEHa7HeVyGbFYDOVyWYoSPgf1RsOKGh78lUYgLJq1Wi0cDgf0er1koB2Vg0W3Sk4qlZb4h4Eui8M2P7VaDbPZLHq0wwoLs9kMjUZzImtjFuEs4PmYDodDil1ODekOOQidTgeTyXRkTMBZgVNQun4epuEg2DH1er0IBAIyVVNu5sMKyyex2Y0KsxHOCq1WC3/0R3+E9fV1BINBfPrTn4bX673v9+LxOH7v934P7XYbX/ziFzEzM3Pi5/ik7M8ngdfrxfz8PKxWK2KxGG7dutX3c71eL9lv29vb0hwsFov3FVt2ux3T09PQ6XS4d+8eCoWCrL+HYXx8XMKUz0r3S5r/45g0TE9Pw+FwIB6PI5VK9Zl1nSZyhaAkwmKxyKTnqHPE44TH4xHq/VlqtMlcGjRzc7vd8Pl8WFtbO/VneZb00gcF91qGTCcSicdaSJ8GT31h9jhw0oX/qE4T8GQ7Cnq9/j4xqsFggMvlgkajQTabRbPZxLlz56DT6bCxsSEGIPF4/MgFS6/Xw+fzwev1otVq4e7du1hYWEAgEECn08Hm5iZ2d3cBHEwUGIZMVzqn0wm/3y8OiYlEQgS0ygXFbrfDYrEgkUhArVYjFAqJccdhr4+mFspOGCcYZrMZarUaKysrYrdfq9VkUVF2ECORCDweD+7duwej0YhgMIhyuYx79+4JZ5l/Oz4+DrvdjlKphI2NDZnU5XI5eR3DBLuDUzjeL8rDu06nk0llLpdDPp+HyWQa2unzeDxiyc8AbppzUFP3qMBrRP59uVw+lqqq/Df+N7WO3LgrlQoqlYrQWAavGQvZR82DPwo096CBicViwdTUFFwuF+x2u0QqlEolRKNR7OzsHHp9ngRGhdkIzxL+OBVmbIox6PekB1m3241KpdK3n5pMJgQCARgMBtGd+3w+pFKpIydHZrP5viiYh4Ferxea39NAAyN0Op2YZjwsGLj9OCZXZw2fzycSkaNchLmvPWvvkR4KoVAIs7OzcDgcyGazuHv3LqLR6JN+eUMxKsxwNgv/sC6D8menPUhqNBpYrVax/D7tIkmDAq1WO1Q0PDk5CaPRiLt37/b9u8fjEWONRqNx30HYZDLhueeeg8fjQavVwvb2NlZXV/seg/lp/JtwOIyJiQl5LclkUsxDON0xGAxiq0z7ciUoaj3OCclqtfblgSk3oMFDvtFoFGdKrVaLdDqNdDqNhYUFcThUZu1cvHgRs7Oz0Ol0wv9vNBqwWCzY399HvV6HRqNBKBSCx+NBr9dDqVRCPB5HvV6HzWYTUxZSOGn4oVarJbPKaDQKP39/f1+en7RJFrbhcBi1Wk2K7sHP32q1Dg2FBj6m5KXTaTgcDrhcLjF/aTabsFgsomHkxHIQbrf7vvDjwc+MeWknCVpmN4tTKlIgKSA/7DDxqKnC1A8q3U8BCEWWaweD2E0mEyYnJ8V8RDm9zOfzKBaLT7TbOirMRniW8MepMDspuP+WSqW+PY3GXiaTCbFY7Kk9eD4s9Ho9/H4/DAYD1tfXT/33FosF4XAYHo8H+XxeDOWOg1qthsvlkn3vcR6PbTYbQqEQ9vb2RNvu9/tRqVRk73kQWCwWcXP+JMNkMiEUCsFmsyGTySCZTD5VjQIlRoUZns6Fn2YCvV7v2EOcksoGfOyGxIO18tCqUqlw/vx52Gw25HK5vgVpcXERbrdbCkxmlSWTSZhMJoyNjYm+hkUMRbpHgR0L2pCTjqHX65FIJFAoFGA0GsVR8LgOll6vF8pYpVLB9vb20FH+xMQE1Go1MpmMuC2azWYEg0FYrVak02kpEHU6HcbHx9HpdMR2Vplbcu7cOczNzaHb7eK9996TQopTMr1ej3K5DK1Wi6mpKXi9Xuzt7SEajUrGz97e3n16JWZgUY/GwO9hi6TFYhHK49jYGJrN5tAsDtIZHQ4H3G43stksstksAIjmSa1Ww+PxIJPJwOv1wmaziZbQ6XSK0xf/TglqGfi5D6PH0FBmsDDUaDTweDywWCzIZDIi8HU6nXA6nWKkkU6nkUgkYDQaZeMoFotD4yI4OXxYOsdp9RUs9HU6HQKBAMbGxiRTkY6mpVIJd+7c6XPbBDCUevS4MCrMRniW8DTtzwaD4Vha86N63qmpKVgsFly/fv2RxGgcBtK0NRrNJ8bISKvVwmq1wul0SjP4JGYTbBRSd/ao1vBhTKAHeYxhsTsjPP0YFWZ4uhb+Rwm1Wo1wOCxFSSaTgcPhQLfbRalUksWXGhir1Sqh08rcKWC4dbdWq4Xb7RbbVY/HI858Ho8HU1NT8Hg8YvGfSqXw0Ucf3fc4Xq9XJifxeFwWFYPBAKPRKEXBoC5sbm4O5XJZdFl2ux0TExMAgFgsJsn2/Du6J/JAP2yDs1qt8Pl8mJ2dhUajwTvvvCOOQiqVShwha7UaHA4H2u220CHn5+eFovfCCy9Ihtrm5iYSiQT8fr8EY25vb8t0TKPR9DkrZjIZeT1utxsejweFQgGZTAahUAjZbBZ6vR5Op1OogE6nU4oZn8+HXq8nhi3hcFiKa147TnUZmMyp1WEYGxtDt9tFKpU6daeNUQGDj09q58zMjExdGa7Jiekweo/ZbO6bjjLM+7SuXoxRGNwMlfcFTWSY3WexWDA+Pi5GIXTqBA70CRaLBYVCQfSKACQPjY6Nj7trNyrMRniW8LTvz0dpqI7LoDoMzPBUrg/ct8bHx7G7uyvridfrFd3uw0w9lpeXEQqFUCqVsLa2NrQpdxx8Ph8APNQEZxiUVP2zhlarhd/vx6c//WkEAgEUi0Vsbm7i7t27+PSnPy1a8O3tbdy6devUVL65uTmsra2d+LW4XC5YrVbs7OzI+z1//jza7fZ9DKejoNPp4PP50Gq1+pg3TxIajQaBQAAA+iKXHjVobpdKpe5rkD+NGBVmePoX/pNCWaiQYmUymdBoNJBMJqFSqeDxeMS1iYdy4OCwGAwGoVarkc/nUSgUpCtntVoxPj4umq1KpdJn22uz2eD3+4WKyAywbreLzc1NZDIZseCnOUmz2bzvUO/3++F2uyVEedg0iBMU5pD5/X6o1WrcunUL586dg91ux4cffiimIFtbW+h0Ouh2uzCZTBgfH4fb7Ua9XkcsFkMqlZIFTKfTYXt7G8DHujOaWzCPzGKxSCHAQzwzvaxWKxYWFuB2u7G3twfgwC7a5/OhWCzizp07ePnll4UuWqvVsLGxga2tLaH6bW5uio6NOWGdTgetVguxWAyRSARjY2NIpVIoFAoIBALY3d1FIBDAzMwMtFotUqmUPA5pl7wveJ/Mzc3BZDKJe2Cn00E+n0culxvaEeYUllNChplns9m+iZnf74fFYkGj0UA+nz8Rf9/v9yMSiYixR7FYxNbWlkQskN/ODmKz2RQqTzabFc1fpVIRC3xOAWl8Q43FWS1npBkXCgUx2LHZbDCbzTLZvHfv3n0aQuX1ZIbd4+5mjgqzEZ4lfFL259NiWKPQ4XAgEomgVCphZ2enbw9Xru8OhwMGgwHFYhHhcBjdbheFQgHLy8vQ6XR4991372O6TE9Pw+/3C5PkQaY1fC02mw3j4+MwGAzY29vri3rR6XTw+/0oFouPTAdtNpvhdDqRSCT6mnNWqxUejwf1eh25XA7BYFD2bK1Wi+9///v47//7/16K3Xq9jjt37qDX6yGbzeKtt94Sh2WtVgubzQaPxwOXy4Vut4v19XX5ORurarUaWq0Wr7/+OqrVKq5duybFOiNylG7MtMBXvm6dTifnmNNgmMb7YaBWqzE/P49qtXofTdblcsFgMBxrHHPWr+kwKKfblPXU6/W+/VatVovJ1+PIpDspRoUZnv2F3+12o9froVwuQ6PRwO12y9SgVCohkUig1+vJF2dYlsOgTS9pXRRNBoNBaDQaVCoV7O3tiZMi9TRutxt6vR65XA67u7tCA6QmzGKxYGJiApFIRGzrS6USisWiFHmBQEAKFGqw+L9J4QMOFl2PxwONRoN8Po+XXnoJ+XweN27cwGuvvYZYLIZqtSrUxHK5LM6Q1HfRIYiFAzWCnU4Hi4uLsFgsyGaziEajuHDhAqrVKnK5HKanp1Gr1USkTUonCyCXy4VQKAS9Xg+3243nnnsO6XQaNptNAtErlQp+9Vd/FS+99BKWlpbERTMWiyEej8skLxaL4e2338Zrr70mzpPJZBI7Oztot9sYGxuD0+nE5uYmwuGwFFvVahU7OzviIEnNGjt9fK/8jAla5DM8k66ewMdGF0pzm2FW8Ha7HRqN5lAnQ1435aHgi1/8omziDHLO5/Oix2JgN01NWq0WUqmUOIBSI8dNeG5uTjLqstmsbBRnuZRRD6hSqWSqp3TZBA6op263G61WC3t7e5JpZ7PZ0O12Ua1WD+0qP0p60qgwG+FZwrO+P58l6Ox6nMRBuQ6ZzWY0m01p1Cnt35XgvsNG3cOsP2wCM0Jk8NA7mL91EtApuF6vH3qIvnz5MmZmZnDjxg1EIhFhltjtdmxubkojjc87Pj6OP/En/gScTidSqRSee+452O125HI5/Jt/82/wcz/3c2J6tru7izfffBO1Wg02mw2NRgM7OztQqVR48cUXRe/2wQcfyDXg83CPWlpagt1ux97eHlZXV5HNZuVzNJlMsl8MZpaSdplIJB5an3wSzwOyR9iI59/Nzc3hwoULMBqN2N/fRyKRwM2bN4Wqz7MeHauVMUGPE8wRZdyN2WyW0PZBGI1GeDwexOPxp8ZC/7g9+okFTI9wctCOnSYaDKfk4bjT6UCr1SKfz/cZeSj1YcqFnguXSqWC3W6X38vlctjf35fDJE0Rtra2EI1GodFoMDk5iZmZGTSbTWxsbKDT6ch0aH9/Hw6HA8FgEBaLRSYrADA1NQWbzYZWq4XV1VVZ0Ehp43MyuyMUCsm0YW9vD1arFTqdDlevXkWn04HFYkGz2ZQpH/nx+Xwe5XJZihIuQHwdtCre2dlBpVKB2+3G3bt3ceXKFUxNTWF1dRXj4+OYmpqC1WqVQrJWqyGfz4tu7Pd///fxMz/zM6jX6/jN3/xNfP3rX8cf/dEf4Stf+QrC4TC++c1vSk5YqVTCrVu38OMf/xharRZXrlwRfd+FCxeQTqdx4cIFmEwm7O3tyaba7XZlwsXClfx3pRmNsniKRCLwer1imEGTEHbk4vE49vb2UC6XYbFYpCBPpVJC4QwGg/B6vSiVSjJhJHg/Wa1WuFwuVKtV1Ot1OBwOaLVayZKx2WxYXFyE2WxGp9PBD37wA5TLZQSDQTidTvnMONUrl8tIJpNi22symeQ+tdls0Gg0mJqagslkEtOTnZ0d1Ot1+X02KvL5/Ik3N5PJdF+WGQAxerFarVLol0qlvoW9UqnAarWKiyMAcTujBvSwwmzYgeWoDfVxdSFHGGGEs8dJqXqDk5TDNG/K31E6wh41yeh0Ooc+v8ViwdzcnBQVGxsbR75OWssPvhblcynByB42FYetY/V6/VAjKuXjfu9738Prr78On8+HarWK+fl5WavL5XIfXX1xcREqlQo3btxAOBzGhx9+iAsXLsBiseDP/tk/C5/PJ5rnX//1X8fe3h5effVVORfkcjmYzWZZ+5UFIxvbzWZT9rZut4tyuYz19XWZsqXTaQAHn42S8q4Ede9nQeU8yWPwbMX4HpvNhkKhgEajgQ8++ACf+9znEAqFsLGxIa+XDVSeN51OJ9rtNsrlsrCuKpXKYzGkITum1+vB6XTCYDAcOp3ldX9airKTYFSYPQNQftHoojfYUVN2wHQ6HdrtNjqdzn1BjgwnpilFu91GNBoVbVa9XodKpUIoFILT6USj0UAul4PRaBSNmtlslskJ9WnkwK+vr6Pb7cJqtaJQKGBzcxPPPfccvF4vVCoVYrEYdDqduCVVKhVotVo53DocDjgcDlSrVdFfMVukVquJzq3T6WB1dVUKMF4jdrFYMFosFthsNuTzedRqNcRiMTQaDYyNjUkEQCgUwu3bt/Hqq6/i05/+NDwej3QhGbZdKBSgUqmwtraG6elpfPWrX4XD4ZAg6p2dHVy8eBEGgwGJRAI/+MEPJGTabDbDZDLhxRdfhNPplPdOwxG73Q6HwyHXg/q8RqMBl8slIdCkLNKoBQCSySSef/55oZZyAlYoFHDt2jU899xzsNlsyGazSKfTci9wk0kkEjIB4/3BCINWqwW/3w+j0Yh0Ot1nNKPcSJg/RjHy+Pi4TAQbjQamp6dF2M5rywW9WCzKc9GMpNvtIhKJwOl0YnV1FRaLBT6fT6iQtVoNa2tr0Gg0GB8fh1arlcB1Tv6onywWi9BqtbDb7RLxoMRgZ1mv18skmI2PwxZ0FsvUpbFbx9fB78pJbaT5+Q3bWEcF2QgjPLs4yQTD7XbLIZ44LpvLYDAgEAjAZDLJPuX1ehEMBpFIJO57vMPQ7XbRbDYlq/G4wuwk72nw8SuVylBHZuXvHIexsTFcuHBBdL/5fB5ra2uIx+NIJpNoNBpwOp2YnJyUZnAymUQ8HodOp8PExIRos+/cuYPvfOc74ow9Pz+P1157DV6vV85WY2NjCAQCmJ2dhVarFUOynZ0dAAdNzEajAYfDgb29Pfh8PmQyGSwtLcHpdGJrawtjY2OiR261WohGo7h7967suXa7HQaDYahOjOeFdDo9NC/1QcEzkk6ng9PplPieRCIhZ5F2u93XdAQ+PjdoNBr4/X4p5PP5PHZ3dx+b8+Ngg/Qo/WWv1zty/z1L9spZBbiPCrNHCHbNz6oTYjKZ+oKNWRxVKhW0220pWIrFInq9Xl/3jHo00t4ajYZ02lg40BCi1WqJCQN1R6S/qVQqoU5qNBqhH+r1eqhUKpkueTweBAIBcWtcWVnB1NQUzGazZILxuZhnxcwRWryzq2MymeByuTAxMSHW9/v7+8hms7JwqdVq7O3todPpwOFwwGazod1uw2AwCHVhdnYWrVYLiURCDDSy2SzsdrtM+Uhf3Nvbk2vMiU21WsXY2BgmJiYQDocRjUaRTCYlKNvpdCKdTmNra0t0dqFQCGNjYxJO3ev1xMrV4XCgXq9jenoa3W4X0WgUbrcb58+fx+LiIiKRCOx2O1KpFGKxGHw+H2ZmZoRil8lksLW1hWAwiFAohG63K8UsCwaz2QyfzyeTH1LuaHrCiWU6nZbFuN1uy2TLbrfL4SAWi8l9rAzg7PV6SKfTYvHv9XpRrVaxu7srurF4PI6LFy/CZrPJ5JSmNJwIsiAqFApSGDebTVSrVVl89/b20Gq1UCgU4HA4pHHA5+aUqlKpSGi6yWSSe0JpNgN8TOvl5EwZDs3DyiCMRiMcDgfUarUI6CnCTqfTMjUj3eiknTpOSUcYYYRPFo47qB12eDzJekB9sE6nAwBp7ilNLKxWqzBTBl2e+Tzdbhd2u/3Mm0B+v18YB6cx1qC7M2n3s7OzAIBsNiu5aZubm/D7/ZienpYmmMPhwNjYGNxutxzYw+GwnH+oiWu1WrDb7VhYWIBOp5MzAKnxdrtdKO2k9Xc6HbTbbajVarzyyiu4fPkyVCoVotEoLBYLFhYWJOA4k8kgn89Dp9NhcXERDodDpBHNZhMqlQo2mw2zs7NYXl5GJpPBf/2v/1UKMZ6LgH5mB6mqpwUdkZV5eJ1OR/LN2Kwny4YNR6PRiNXV1T5Tr3K5LFTCarUqOmxO00qlkmjwBsFzrHKvfRg8rAnNWd7vZ1GUAaPC7NRgAXGcoJ9FGSdZZ1GVU8+lVqthNBrF+ICd9kajAZPJBI/Hg0aj0fel4Osl9ZFWsNTNAOibiND9j9MQFoR+vx82mw06nU7s+vlFBQ46TOykAAc0i3a7jYmJCQQCAZmu3blzB+12Ww7q3W5XMqLcbrdoxNRqNex2O7rdrtAUPR6P0Nf0ej329/dlQqHT6WA0GsXBMJfLodPpYHx8HB6PB+vr6xgfHxfDj3A4LLqrnZ0dWCwWubacNpJDz8P/+Pg4er0eUqkU1tbWMDU1hUAggFarhbfffhtLS0s4f/488vk89Hq98KGZIeZyuRCJRAAA3//+9+FyuRCPx1EulyVWYHl5WaZiXPT8fj8CgYBsrJ1OB263G+12WxbFWq2Gd999Vxy/dnZ20O12kclkYDAYZOzPe5RGLly0qYeLx+MyjWLANKdCLpcLXq9XHDQpuKXBjEajQS6XQ6vVkqks3Snfe+89tNttWK1WeL1eCWzudDpoNpsSpMp7e2JiQgr2RCIh3clIJCLPT4qvTqeT+77T6UgxzPfE789gkHyv14PFYoHJZLrP5p73lHKyxvccCAREdJzP51Gv1/sy9h6kGTNMs8fF/mkI3x5hhBEeHtQA87us1AifBtSykkIHQJghwMf6Gu67DEpm0wuAxHxwcuN2uxEKhcT92GazSYj1ac4wKpVKHkvpQAhA9r9CoSB7BI2wjEYjfD6f6A5LpRKWlpYQDoexu7sruvhmsykZqx6PB9VqVVwP3W63MCu63S68Xq9E3ty5cwfLy8uw2WyIRqPw+/1wOp0oFAp455134PV6MT4+DpPJ1DeJu337NiYmJiQ25fOf/zzm5ubQaDSwvr6OF198EYFAQJqZpC1ms1nE43HZu5vNpjA7TCaT0CQbjYacbcgcqVQqaLVakhXLxjtdq5XSEyX0ej0A9O1lrVZLmFRKKUS324XP54NWq8W9e/dQq9Wwt7eH2dlZ2O12PP/88xgbG5OzLJkkzHlzuVwADtgn3Ot55mMTfX9/X6acyWTyiURSPA6c1XsaFWYPgOMuPg9T/CIo/20wc4yCypNoYpS2uqRa0aiCC7tOpxN9Ea3yqTUi9bDZbEKn0wnlke5Jww58nASxeLPb7VIUNZtNxONx4VrzEBuPx5FOp2WiwIM0X1fv/58NxXG41+tFvV6XLyy/+IVCQaZ7ZrNZLIs3Nzdx8eJFWK1WbG9vo1wuy+/QrdFms6HZbKJWq8HtdmNsbEwW7V6vJ5llpDtS70TLfq1W27d4arVadDodbG5uyuSFxihzc3MyXTp//jxeffVVmM1mvP/++3K/7O/vY2dnRzR9tVoN9+7dw+bmJu7duweDwSCB0mtra+j1eojH46InC4VCKJfL2NnZ6bteLKZ2d3exsrIiG4/D4UChUECz2ZQi3Ov1iqaLFD0WfS6XSz7n/f193Lx5UyamBoNBhN6lUglGoxGRSEQ2fBp16PV66bgFAgEYDAYUCgXo9XpMTk4CAPb29nDz5k2xbia1kdeX1NGdnR3Jh6vVasjlcigUCnA6nXC5XGISwnukVCqJSUe9XheKhtFoRLvdlgKdlEtuWDSeIYX3MO0XXRpZBGq1Wuj1elSrVen+0TxlGJSRBaddvJWPyeJs2HrxoNbdI4wwwtmDbJFhUy+lwyIjbJTfaTZEBwOmleDfWiyW+9aearUq7Bhmd5K6Rtr7YHOZ+wsZNMBBUTY1NSUU95M0hUiHNBqNYsbBZnAwGBTmiV6vx8rKCux2OzqdDlKplGiHuI/QaMzn8yEUCkGlUknzNJ1OC0uIOWX1eh1Wq1XYIyxQOp0OzGazMFJeeukltFotbGxsSNH69ttvo1QqwePxoNvtivlFoVBAPB4X232VSoV4PA69Xo9oNIpqtYpAIIDx8XG8/fbbWF5elt/htQCAtbU1rKysIJFIwGq1wuFwwOPxIJFI4O233xYjjVwuJ/eMkjXCx2EjVmnupdfrodVqUa1WYTabMTU1Jc16Uu7T6TQMBgNCoRAcDoewWdhsNZvNwgC5ceMGgsEgbDYbnE6nsHoqlYrQQJvNJiKRiBRryWQS2WwWKpUKgUAA5XIZXq8XLpdLzq681qPm4tEYFWanxHF8VRYwg5ad/FtCGep42m44X4NymsXno6MR7WQ5pqZrjcFgEDv6drsthRoLE9Ih2NGz2WxS1JRKJeRyOZnscCyu1Wol4yudTsviyOeIx+OoVCpyHQDINMbr9YotOTPR6FhEy/FCodBnCMEgaU6EZmZmoFarxRKVPOher4fp6WmMjY1JAbq4uCg6uNnZWaHNFQoF0VNR/1Sr1cTKPRgMIh6P4+7duwiHwyiXy3juuedw/vx5tFot6PV6jI+P48qVK9BoNIjH47Db7TIV6vV6UkSTn67X6/G1r30NgUAAwWAQnU5HCllONo1GI/x+PxqNBmKxmEx3SqWSCJ/1ej1SqRTK5TLq9TqcTifC4TAmJyfR6/WkE0p6S6FQQKVSgd1ux/T0tNAWKpUKYrGYfE7pdFoK3rGxMZlilstlZLNZ2fzpxGg0GmEymWC322XaRzqh1+sVjaDJZMKlS5cQCoXk71hobWxsIJVKIRwO4/z58wCA/f19fPjhhzAYDJicnITf7xfNIbPbWMTSlITdaNI2qB1T5trRCZJdyGHgAcZsNovjJosybv5cD5h3dNi6cJxb1rCfs6kCHDRm+L1UghPAwX8fYYQRhkOpveb3TlkknQUsFkufJnwY2AxTZlkCkAJEaewBQPZv7r2k1g1bF9ik2d/f75vMtVqtvnWGeyPzsMgc8Pl8Ej/TaDSkmQvgUO0tzwyTk5NwOBz48MMPkUgkYLfbZdrVbDaRyWSEHcJstWazCaPRiGq1Kgf8drsNp9MpRRBjV3K5HKLRqGjXSU0sl8vY2NhAIpGA0WjExYsX5b0ya5URPOvr65idncX09DR6vYNc10gkIqYmJpMJPp9PmD5TU1PCVGGRwkbz+fPnkUgkpLhqNpuw2Wzw+XyStbq+vi7NTqPRiOeee0404aurq/c11distVqtaLfbyOfzsqfRoZv3LY04tFotIpEIJiYmkEwmJWBbpVLB5XLBbrfD5/PBZrOJfIWPq9frMTc3h2QyCbfbLbm0LISBAwfVH/7wh1CpVJifn0cwGES73UYsFhPpiMlkwsWLF7G5uQmDwQCv1ytShEwm81DUw0cdtv60YFSYPQJwweJiOcjnJti5pzMOcDJBLTnAdGxSWpOT42s0GoXKB0CmAm63G36/X76QAMRhx+PxSDeNAbs6nQ65XE4mV3w80gWDwaB0XuiqNz09LaHH+/v7uHv3rkxvyBun4LTVaonmimNxHm7ZNaOTIEN+P/OZz0iG1djYGILBIIADIwzSNHZ2diQEmqLmZrMJu92OpaUlrK6uygE7EAiIUQW7nCwWCoUCisWiFLYMhxwfH5fFioUOJ5TckF9++WW4XC6hmOr1eqytrcFoNOLy5cuYnZ2FyWRCPp9HNptFqVSCxWLBpUuXxASFdMP9/X2EQiFUq1WUSiWYTCbMzs6KtqzX6+HixYtCN7106ZKYbHCj+/DDD6FSqTA1NSVFMJsCdLIslUoIhUKyWXKqSz2j1WqFzWYTV1Cj0YhQKITp6WnZGEOhkEwdJyYmZHJaLBbhdDrx8ssvS/g2NVikGlosFgQCAfzcz/0cTCYTKpUKtre3sbKyAp1Oh+npaXnPrVYLwWAQqVQKZrMZAGRKptVqUSgUcO/ePfR6PUxOTqLZbKJYLIo2kjpA5VSb7pVK/Vyr1ZLOdbFYFE2H8jt4WGdbGUEwOC1TbjIsWAcPYgAkD40HKuUawWKUhfoII4xwPLRarVCklQ0RTu6B4bTi01CJdTqd0M6HSR/Ixhj2eNzXB1+D2WyG1+uV/Zha3qOgpEwqKYwEGRTcd+m0y9zQUqmERqMhFHiuRUajURpb1OfyzMPX7nA4kMlkMD4+Lo1Uh8OBZDKJcrmM5eVlaVpNT0/DYDCI0UW328X09DS8Xi/cbjeuXr2KcDgsZk/UKDUaDdRqNaTTaXFYNJvNGB8fx/r6OvR6PYLBIOr1uhSAbH5++ctfliL3G9/4Bt566y3Jznz11Vfh9/sBHOzxzAG12+2iRw+FQtBqtdI4/fKXv4z9/X2oVCosLCwgEAjI+WhsbAxGoxGpVAo7OzsS08P9lNmowIEuz+/3Y25uDjqdTiiN/N+bm5sol8vCApqfn5eJ4cLCgljH+3w++ZxCoRB0Op0UWjRdC4VCACC6NqPRiJ/8yZ+UiCQAMpWkxv9LX/oSXnjhBYmTuXPnDhqNBtxuN8xmM2ZmZjA7O4t0Oi0yBt4nxWLxgbXUJ5ERfRIwKszOGMobjsGDw5yVuBgyW2RwEsdCbVj3joJU8nyVB0ubzSbhiuzGAAe8c34pGf5Me1FOOpRhiHQGJM2y1+uJoQftwykOpVV+rVaTBYX0sna7LY4/AISKqOS+0xKd3RnS0YADfjldIOl8tLOzI5qiixcvyuJAqgSzVdRqNVKpFGq1Gl577TVcunQJAHDz5k3hhl+/fh3nz5/HT/3UT8nIPxqNolAowGq1YnFxUWgWuVwOfr8f9XpdKBYejwe3b99GKpWSz/uFF17AwsICbDabOAFqNBoxEzl//jwCgQDUarWEW1LL5na7xUmQNMJmsykW9uvr66hWq1haWgJwIITe3d1FPB7HrVu3cOXKFbz00kti2MKskmQyiW63i2AwiLGxMfR6Pezu7mJ3d1cKyy984QvSYfT5fIjH43C73TJFrFQqaDab8Pv9fcUXKayJRAKxWAzPP/+8FPkqlQrVahWpVApOpxNTU1MwGo2IRqOSuUNNhMFgwKc//Wm89tprQrkk3fb111+Xxb1UKskmwq4kNzfecyzcGHxOI5pqtYr9/X3pEA9+5ziJHfzecToGQKif1GAcBSX1cPAxlQcmHuIOAwu8YcWfXq+H3W6XzucII4xwNGq1mtDqeNDr9Xqy7yhzuDiJYpOK3zEWFEpqNEEGh9lsln14sLDjpOEwDLP/brVayOVyUmQQ3F+47gGQ5mWn0xHK92EYtIKnoQUpexMTE6Id5uOQVk6aHPVLmUxGJoAqlQrLy8vSiNNoNJiZmUG5XMbq6iqSySSSySQWFxclXqVUKuHOnTu4c+cOJiYmxFjp9ddfx3PPPQcA2N3dRSgUQiAQgE6nQzqdxttvvy06p1KphK2tLSnAi8Uitra2sLS0hE6ng8997nN46aWXoNfrkc1mpQndarXwJ/7EnxATj3q9Lo6/vK7cG0kf5H3w4osvol6vY21tDS+88II4ODK/lI9jtVrxpS99SeJqnE4n7ty5I4WZWq3Gq6++ikgkgkwmg7W1NZlCulwuaDQaLC4uYnV1FdeuXcPc3BwuXryIer2Oq1evyufw5S9/GW63G7lcTiiEzWYTVqsVoVBIznw03EqlUvD5fPjsZz8LALh37x5MJpMUeSsrK3j11Vfxsz/7s3A6nfK3Wq0WMzMz0sBMp9MyHdvc3MTMzAwuX76M27dv951JlZEytOKniZxSr63EYYyUpwFnOc0bFWaPEEflhgAQfvhgWjkA4UmzE6+kQzKXgVlLHP9zAkARsdls7qNo0WSD7nvcZOr1OqLRKKLRqBiVkDPNKQinSbVaDaVSSaZ2RqNRDBOoGWq1WojFYrh79650WJxOp7yPXC6HyclJjI+Pi8MgKXGFQgHb29uIRqN9+ipuDDqdDjdv3hRLV7oajY+PC2WRU6J6vS4FDjcyattWVlaws7ODr33tayiVSmLMEQ6H4Xa74fF4AEBcItfX17GzswOdTiedw83NTbz88stoNpt4+eWX4fV64fF40Ol0sLOzI5bxvV4P4XAY8/PzmJqaQqFQQCwWQzabxb/8l/8S/8P/8D+g1+vhV37lV/D3/t7fE1dNTlESiQT0ej0ikQi++MUviukKp1a5XE6cHxmKSdobU+9//OMfY3FxETMzM6KRYu4KN0weGjqdDlwuF3K5HN544w2hzywvL0vQ8+7urhROY2Nj+MxnPoNPfepT+MIXviBB1qQN5nI5TE1NSUevWq3i/fffx4ULF3Du3Dk4HA5cvnxZDhV0f+RhgZSOTqeDP/iDP8Crr76KqakpOYiwkN/d3ZXpGSexnGDGYjHZ9OlMqQT1i2wgDIKTb35vhwWgKn9HuQYoJ+fDfkaa62GhqvzeKGlWyk2AuX4qlerE9tgjjPDHHaRBDwPjVtis4bRcGcvCSQQNDpTQ6XQyYSHYqHoQkw+C+7DygMvX4nQ6ZT8AgHPnziESiaBWq+HHP/7xoVN9NvA4HWGemJKJwyJPue4oC7DDoFKpcPfuXdy6dQsTExP4/Oc/j06ng5s3b0Kr1SKdTuP555/H+Pi45FBWq1VYLBaMjY2JCy8nRdwHr1y5gkwmI+YhLpcLgUAA0WhUstCU8Sm5XA5qtRrLy8u4cOGCaKm63S5u3LgBt9uNmZkZ/Kk/9aeQSCRE07y6uopMJoPnnnsOqVQKV69exc/8zM8gk8mIqzMbjeFwGFNTU/jWt74lxQ5NoRjKXK1WUa1W8d577wEAJicnYTQaxUADOGi02Ww2WK1WmM1mkSsAH09xeebb399HPp9HPp/H5uamSC7ef/999Ho9+P1+RKNRzM/PY35+XmQNNLtiU8Fiscg9y/v29u3b+NKXvoTJyUmYzWa88sorYq7FQp/NWpPJhEAggG63i9/+7d/G1NQUqtUqJicnxYiFhRyLKzbis9msRDIFAgGoVCrs7u4OdZ58EDfKZxGq3h8DwmaxWBSHn6cFdFY0Go1oNBr3LdZK5zgesDldeBiOrkajEUEnANGMDXbbaEqi0WjgcrmQTCblMcbGxuRLRU4xJzQs9KjHunLlCsLhsFAM9/f38eabb2J+fl4Kv5WVFUxMTGB6eloOyAyLjsfjEmTN68YRPDNGWHAmEgn5rJvNJnK5HHw+n2wO09PTWFxclEyrGzduYGVlBa+88oqEStZqNfzWb/0WJicnhWbBzikpd+S/c7OqVCp46623cO7cOTEksdlsWFhYEMt7Fs10cgwGg3C73QAONACNRkNy0D744APodDpsbGzg8uXLOHfunFA8SUFlwceu7/r6Oq5evSouXTabDS+88AJ0Op04ZzYaDdTrdWQyGdGb1et1vPLKK5idnZVYAHYcr1+/DoPBgPPnz8Pr9YrO8Ic//CEmJiZw+fJl0XvV63Xs7+9jc3MT3W4Xy8vLMulk0fTGG28gk8nA4XCIuyU7gJzUplIpbG1tATjQaFy7dg0vvviiGJc0m02hRVKjwNfMpkG9XhcufjQaxdraGs6fPy+UpUwmc19wNid/tO1/msBOO+/BYc6wFG/v7e2hUCiIK+oIIzzteFz787CO9rCGCUHtLVkmyj1wEDSL4vMAjz57kI7Kh2niwuEwXn75ZRgMBty9exdra2vipKeEzWbD0tIS5ufn0el0cP36ddy+ffvY5x+cXgyjYNPRMRaLYWpqSrTHH3zwAfx+P5LJJFQqlZiB9Ho9iZhJJBJ44403ZJ/803/6TyMQCKBWq2FjYwO/93u/h2azieXlZVy5cgU+nw+pVArvvPMOcrkcDAYD9vb2+twnP/e5z4kx16VLl7C0tIRQKCTOz8ViEb/2a7+GQCCAhYUF0a2Tfvfaa6+h0+ngxz/+MZ5//nlcvXoVP/ETP4Hp6WlpjLZaLezu7iKbzYq5VSKRwO3bt7G/vy/sEp6j9Ho9VldX8eabb4qxx2uvvYZer4doNIqFhQXMzs7C5XLJlInmIm+99RYmJiZw6dIl2Gw2AAfN5P/9f//f8b/8L/8L5ufnJToom81idXUV2WwWwWBQ4odoRra+vo7f//3fFxfJF198EZ///OeF2UQt9tbWFmq1Gkwmk4Rwf+UrXxFn50KhgLW1NfzH//gf8eqrr+Kll14CcHDW3NnZwbvvvnukqc1h95rSMOco9+InBerkT/IajtujR4XZE8IwPcswcLzLLtBxi+FxGBsbk0M2p0GcoA3qX0KhEMbHx8WFh697dnYWY2Nj8kVUTi3o/ESb2Nu3b2N2dhYej0e6M61WC7dv38bly5cxNTUl2po7d+5gfX0dvV5PXKCYYcYxfygUwrlz52A0GsXEw+v1Cke70WjA5/PJaz1//jza7TZu3LiBv/JX/go8Hg+azSa2trbw9ttvY21tDZ/97GcxPT0t3aLp6Wn4/f77xuyc6lGzxWmkzWaToiWfzwt9goV3u93GrVu3kMvl8NJLL4ngm2Lra9euiR7sp3/6p+F2uyVMcnJyUq7P9evX0ev1cOnSJSmISqUSdnZ28Oabb+KP/uiP8LWvfU2mSXRcojkMFw06QtlsNjgcDlitVqFxsLiJxWL4l//yX+Jv/+2/Db/fL4HNnCr9+q//Ovx+P770pS9J+PNgYf5f/st/wZ/7c38OBoMB+Xwe77zzDrRardAc+Xh3796VYi4YDIqujoVkPp/HD3/4QynkaGLj8/nEobHRaCCRSGBtbU1ya5h7tr29LbTbbreLVCol+kre64P3/km+XwaDoc9IhAX8WYOFGf//YRx7i8Ui5i6jwmyEZwVPw/6s/C6fFpzirK+vAzhokpD6/SSbPKFQCOFwWCh3nU4HKysryOfzwoxh43V6eloarVtbW7LfHwWn09m3Fik1rgaDQfapW7duybXh1GhsbAyVSkXOHqFQCK+88ooYPu3t7WFzcxOrq6uIx+NQq9V47bXXYLFYsLu7C41GA7fbjVgshnA4jJmZGTGoYqxOvV7H6uoq3n77bQCQZio18JRkaLVa7O3tYW1tDc899xyWl5dFW5/JZJBIJPokBLVaDQsLC6Kjf/311wEcmHu88cYb+NznPoelpSUJlM5ms/jud78rjo2Ue9AQ5Xd/93exsLCAcrmMZDKJF198EbOzs7BYLLJPU89Oh+JYLIatrS2kUimcO3dOGqE6nQ7lchnXrl1DrVbD0tKSMJMoHaBs4oc//CFWVlbwrW99CwCwsbGB733vexJ/ZLVa5eyWSqWERcXnUcpeEokE7t69i3Q6jQsXLiCXy2FjYwNf//rXMTExIc32bDaLGzdu4P3337+PqstGA/fRw/TYZJmxUUm6LqfcwMny/54kRoUZno6F/7Qg7YE3IADRy5BKRxtVugcqNSs0ryiXy303qdvtFpokdVkcY9M5h25QnE4pJ3fz8/MyvePB12AwIBKJwGKxiOFCt9vFuXPn4Ha7hWaVy+Xw1ltvYXl5Gd1uF3t7e9KxYresVqshlUphe3sbiUTivu5jKBTCiy++KM5K8XgcV69eRSgUwt7eHsbHx8VOniHKpGJyUclkMvit3/otfOUrX8Hu7i7a7Ta8Xi9+9KMfYXFxUSgbXBD5peeCVCqV8NFHHyEajWJsbAxXrlyByWRCLBbD22+/jfHxcTidTni9XgSDQXg8HhF5JxIJscfnQZqdumvXruHSpUu4fv06/tpf+2uYmZmBVqsVfrrT6YTP5xPzinw+j/X1dTSbTQnJbDQawt0nz51FF520+Ny0Re71esjlcrh16xaMRiPGx8cBQLps7777roRb0wSFnUlujHNzc5icnBRbeVJ/NjY2JBslFApJF5r6uqmpKTz//POSCcb7ijQVq9UqOXCZTAbr6+u4du2aOGy+8MILCIfDsFgsQiFNJBISfRCNRvHBBx/gxRdfRLvdxt7eXp+uw2KxQK/XC03J6XRKeHShUBDKy1Ewm82o1Wqw2+0SvPkwoH6TjQ6C3XvqPg+jRI0KsxGeJTyL+/Nh0Ol0mJubQ7lcRiaTEXfgYRg2+R4Gg8Hw0JP8iYkJqFQqyYIEIM63LpcLOzs7UsCcBNyXHQ6HxJzwfarValitViwvL8NqtWJrawuxWAzVahUejwfnz59HMpmUpnCn08H09DRmZ2fhdruh0Wiwv7+PGzduDJ1SXr58GRcuXECr1cLq6iqKxSKCwaBkcQEQC/etrS3cvHnzvseYnJzE9vY2/syf+TO4dOmSNGsLhQL29vaEpqdWq+H3+5HL5bC6uopgMAiXyyU5al//+tehVqsRjUZx8+ZNvPjii/D5fNDr9Uin07h+/TreffddaDQaLC8vw+FwoFKp4OrVq3j++ecRiUQwPj4u6z09A+x2u8gp6NBcLBaxv78PtVoNn8+HbDaLtbU1bG9vo1KpYH9/H9/85jdl0vbuu++i2+3iwoUL6Ha7OH/+vBSvzKWll8D777+PdDqNb37zm9DpdLh69SpWVlbw4osv4vnnn4fRaEQwGJSpYDwel6mkw+EQCcXdu3dl2qpWq/HVr35VmD0+n0+clK9duya0U4JN20AggP39/T4Nt9/vF7duspBarRa2t7efSXrjqDDDk1n4h401z6KaJ6+dGV18XLPZLJxwFgXdbhfRaLSP+hgMBqHT6ZDNZu872KnValkgBuF2uzE/P49er4d8Po+dnR0JgGZeCu3gHQ6HUOM4Ys7n8/jggw8wNzcHvV6PUqmEZDIp10kZOMgMKp/PB6fTKdMilUqFr3/965ienoZarcbKygoajYY4RtlsNqTTaXGpazQa+NKXvoRKpYKVlRVx/COtMB6P4969e5icnMRbb72Fn/iJn4DH4+k7EN+7dw/5fB6vvPIKTCYT0uk0rl27hnQ6jddffx2BQAAajQbJZBJvvPEGXn75ZbTbbdy+fRuhUAhLS0uSfUKb21KpJHbBpE+urq7C6XRiaWkJLpdLCuLd3V3cvHkTgUAAs7OzErzJwp1hkbzO7GBtb2/ju9/9Ln7yJ38SHo9HivZarYZ4PI7NzU3R1JnNZkxOTiIQCKDX62Fvbw//5b/8F3zta1/rs9Tl9LBcLqPVamF6ehrnzp0TCiS7XL1eD+VyGZubm3jzzTdF6EwBcrfbFWt50nj39/eRzWZhsViwsLAgble5XA4ffPABEomEFNzdbldCPmu1Gt555x0sLS3hwoULEoS6tbWFdrsNv9+PfD6PN998E1NTUwAOOoPULpLWqfye6vV6iaFgsLhWq+3TXFDXQRMBoN+W+mGh1+tl4kpaJr+XjJEgvWQQo8JshGcJD7o/Ky3vHxRn8RgEg4GPA/dru90Os9kMtVotQcnH/Z3dbpc4l4eF0+kU5gv1VMprMSy+w+FwwO/3C2Oh3W5jfX1dml06nU4od7FYDAsLC9Dr9fjoo4/kMS5cuICxsTHcvXtXNGTUWbEJVywWh+plJycn8fLLL0tTs1qtYnt7G/F4XM4Wa2triMfjsr/2er1DjZo+9alPSRalx+MRKmK1WpUMM0Kr1SIQCOD5558Xhksmk8GNGzdkurS4uChSC+V0ig7SDodDHKzv3r0r0UbxeFzyT1dXV2ViReYIPQQYcJ3L5bC2tobbt29LPtnXvvY1jI2NIRqN4kc/+hGWl5fx6quvwuPxCDuL+3O1WsXGxgbef/99xONxceWenp6W98qzSTwex/e+9z0EAgFcuXIFbrdbikO1Wo2rV6/i6tWr8Hq9fXFKn/70p7G8vIxMJoM//MM/xPnz5zE3N4dqtYrf+I3fEPkMBwR8XmWkzTAwEiCZTB7Z+GAEVKVSgcVigcViGVros1B9nKXQqDDD4y3MjuJ9K9PWHyXMZvNQ62xOrxqNhnwZdDodPB5P30F4e3v7vgV6aWkJWq0W29vbYmU7CJvNhkgkIgUZ8zoASMGwt7eHra2tvi+BxWLB9PS0TFy2trZw7949PPfcc+IGFIlEcP78eeEmnzt3Dvv7+6jX6/B4PPjN3/xNvPDCC5JxNjExgf39fdy7dw8WiwWpVApzc3Pw+/0ol8v4D//hP+Anf/InYTAYpAihbSyLBfLEmf1BbrterxdKAgXLsVgM6XQa5XJZJj87OztiPc+DPF2YKA5mh4zFml6vl8Bl3is3btwQm+RisShZZ6FQCMlkEp/61KcwOTkpkyhOnZLJpBh5cApEHWGn00Gz2cS9e/dw7do1nDt3TqZ2SloPp1nUEpKe8eabb8Lj8eBTn/qUTLtITSRFJRqN4gc/+IFo3ICDzu3U1BRCoRCcTqeI53u9nmwcdAnlxDiTyWBnZwe3b98WLV4kEoHD4ZDfSaVSWF1dhdlsxrlz5yQTbW1tDUtLS2IxzOni2NhYn9X93t6eUGE5bWbRT7tldiKHfc8eZb4K3VSZIzfMrU2JUWE2wrOEJz0xU+q5Hxe4P9IxkDAajbDZbPD7/djd3RUjKJvNBrfbjWAwKNOdw4yKDoNGo5HmFO3qj3uNgUBALOrfe+89hMNheL1esYrf3d3FysqKFDAOh0M0wfl8Hqurq/fpeQHgc5/7HKanp9FoNLC2tobV1dW+IugwBAIBRCIRaUSura2hUCjg0qVLmJmZgUqlwvr6OlZXV1EqlUQKcpixkkajkfdXKBRQKBSg1+vh8/kkKiCfzwvLxOv1IhQKodPp4Ld/+7cxPz8Pt9uNd955By+//DIcDgei0ai4ETIUmrmypIuWy2VsbW0hnU5jamoK4XC4b0LGfbHdbuM//+f/LIykjY0NaYgnEgnMzc3Ja7NarUilUn172Llz56TJ22q1RMYAAFtbW7h69Sp2dnYwPj6OXC6HbDYr+nhq5HlNY7EYJiYm5F602WwoFAq4efMmrl271memo1arceHCBfmMbTYb3nvvPWmKGwwGybcdBqPRiJdffhnhcFheVz6fx9bW1pk1Uk6Dk063T4rj9uiRK+MZ47DMMuBkGWVngcPyjNjNI10rnU5LECJNFHgQVd78DJjmIZZOfjRjqNVqfd0YWveyYwQcFDv5fB5GoxGf/exnMTY2Jt2xVColnOlcLgetVouvfOUr8Pl8SCQSeO+996DT6XD37l28/PLLKBaL+L//7/8bi4uLCAQCko1FLRgNIqhX+uijj3Dv3j3kcjksLy8jn8/DZDIJdeFP/ak/JcUbp0HMnTIajcjn81hbW5ONUK1Wo1KpYHl5Wex2WZB5vV7pwNCy9969ewAOCuOlpSX4fD40m03EYjGhKVSrVXzlK1/p+/tqtYqdnR3hwCeTSZlO7ezsYGdnRzLCaPM+OzuLZrOJQCAg4dc//OEP8frrr0tODDWBNOJ4/vnnceHCBahUKiwtLeHf/bt/h5/5mZ+B1+sV+uUbb7whQdtutxuXL1+WoM933nkHKysrcLlcyOfz+MpXviLdYJfLhYsXL8Lv96NWq2FlZQW3bt2Se4VTp+3tbaRSKVitVjETsdlsCAaDMsXd3d3FCy+8IJozdiZrtRrcbjcCgYCEQOv1eim033rrrb5g1M3NTajVaphMJjQaDdy6dUsyWJhtREonN8d8Pn+fAxm7mIdNmc8KnFjq9Xqh5ypzCEcYYYQHx5PIRaJroLJgUKvVGBsbw/r6Ovb39xEOh1Eul+Hz+RCJRNBut3Hv3r0TTeWGgdmYjA2pVqtDzyparRYvvfQSFhcXYTAY0G63sbKyAuDAiTEQCMBut8PpdMLpdKJSqeDGjRvyHrh+Z7PZoaH3ly5dQjKZxNzcHGZmZqTIOElhRnt9rvNshpVKJSmIOBVh3miv18Pdu3f7HofmHrdv38bu7i4MBgOmp6cxPT2NdDot0yOdTod79+5hc3MTi4uLmJubE2fDixcv4s6dO/iN3/gNLC0toVwuC8OGETVbW1t9zTtCrVbD7Xbj/PnzsNvteOONN/Df/rf/rQRmk6p+69YtdDodbGxsCGOH0TxkSWm1WvzBH/yBuGnv7+/jG9/4Bmw2G6rVqrBcrl69KmyLQCCAixcv4ktf+hJWV1fx4Ycf4vOf/zwqlQree+89vP/++9jZ2cGVK1fEtG1vbw/RaBShUAg7Ozuw2Ww4d+6c6Lz4Hs1mMywWC4rFIu7du4dUKoWxsTFsb29jbGwMbrcb6XT6yAKLVFI24imReVJgvNVJYDab+/JRHwSjidkZ4aw75hSmDguZBCD5GafdVBwOB1wuFyqVihxo/X4/KpUKtra20Ol0ZBNgp2vQDMFsNiMSiYhNLIsS6or4+9Rpsehj92pjYwNf+MIXJOuLRcp7772HSqWCCxcuIBKJwGq1olqt4vbt27h+/Tqq1Sp+4id+AlarVQqT+fl5mTCZzWbR1W1tbaHZbErHhpb+5J1PTk5iZ2dHpnR3796F2+1GtVpFp9NBKBRCMBiExWKRCSgDuxlKqlarsb6+jvHxcQQCgT5TE5/PJ1OrSqUi+VtarVYcIFngra2tySJtMBiE2re1tYV8Pi9dqkqlgkwmI9RN2qhHIhERYrMLR31ZvV7Hb/3Wb+HixYuYmZmBzWYT2ikFurdv35YMukAgIEHgHo8HTqcTdrsdRqMRVqtVJlnZbBZ/+Id/iGKxiKmpKQnADAaD8Pv9cDgc6PUOAsZ/7dd+Dc8//7xY6NPA4vbt21JQOhwOXLp0SQTVtOGlYLlarUpA9uLiotA5SX0gPePu3buIRqNCkRgbG5PA8eXlZfh8Pni9XjgcDolyYJF679496bTy/jUYDH1BmzRUYWeVOTGNRgOBQACNRkM2k8Ncorh5PYhtNjt3DFvnvymfZzQxG+FZwpOemJ0Wwyh+Z4Vh7nMLCwtwu93odDrY3NwUip9er5frNmjXf9TjM/D+MKjVaoyPj4tzrsPhQLvdFjOMDz/8EL1eD3NzczKR2d7exr1798R1kC6x29vbfWuTyWTC8vIyGo0GNjY2MDExAa1Wi93d3SMbTXq9HpcuXUK1WpUikJicnMS5c+dgMpkQjUaxvr4uRd4wh0yz2YyFhQU0Gg3RaAMfZ0kyX9Zms0kubKfTwec//3lMTEzIhDUWi+H73/++6L5UKhV8Ph+sVityuRzy+bxQ891ud5+pil6vx4ULF0T6sL29ja2tLXzmM58Rl2kamCSTSdy6dQv7+/vyPgwGA+bm5vC5z30Oer0esVhMppvNZlNCvr/zne9I9mo+n0cqlUK1WsXExITkySWTSYkC8vl8fRrsYDAIk8mEYrGIfD4PnU6HpaUl8Q9gZi4pm9euXUO1WsX09DRef/11YQ9pNBrk83l0u13R61EOo4RGo0EwGMRnPvMZBINB7O/vI5PJiKNkoVDA8vKysJRIRX7W8jtHVEY8ews/MazY42ERwNAuPXnoXOR8Pl/fYZELs16vF3dGHir9fr9YvW5ubspiRy41s6sASI4KHXSUCyBfw9zcXJ8DJEN9qY+6c+eOCFKBg4ne+vo6crkcZmdnMTc3B5PJhHw+jx/96EfyeGtra7BarXC73djc3BQBaiaTQbPZhM/ng8fjgUajkanTxsYGgI/dt5hwT8ExN57NzU3o9Xr4/X54vV7YbDaYTCah29XrdZTLZayvr6PVamFxcVEyRd555x185jOfkRBlZSFHo5RKpYIrV67AaDQik8ngvffew+XLlxEIBCQP5+rVq2JCYrFYJOS52WyKXX8+n4fD4cDk5KQUxMwuy2Qy0Gq18Pv9cDqdKBQKePvttzEzMyNujnw/hUIBOzs72NzcxNLSEkwmE9577z1cuXIF4+PjaDab+N73voef+qmfwtTUlHRcaT6SyWSQTqeRSCTEqZK5cdlsVnRvvHdVKhUWFhYwPj4OtVqNYrEofPqxsTE4nU50Oh3kcjns7+9Do9HA7/fL9cxms3jrrbcwMzMDp9Mpxjec0JVKJWxsbCAWi8Fms+Gll14S+u729jbW19exvLwMg8Eg9zwNNcrlMvb395FKpRCNRkUzxi4wp2nAAW2XeoTp6Wm0Wi3E43ExYHmSG8WoMBvhWcKzuj+fFVQqFdxu96GZYGxmARBmis1mw9TUFLxeLxKJhEy0zgqUZHBvdTgcuHDhAur1uuSIms1mmYAkEgl88MEHiEaj0Gq1sFgsMq0ZBKdwXFv5/o1GIwqFQh+1k68lHA4jFAqh3W7jo48+6issPR6PGKQAkCzXdrsNq9UqdD9GsZw/fx6vvvoqrFYrNjY28Nu//dtDpxvcr3i9JyYmEIvFMDY2hnw+j2QyKT4Cn/nMZ+D1eqUZl0qlsLKygmKxKK8hEolIA1qn02F5eRmvvPIKSqUSvvOd7/QFmU9OTsJischjMWdVCY1GI/lzfr8fly9fxvz8PLxeLzQajdD3C4WCZM5Ro+12u2G328Wwg03KTCZznxsirwH/3e12Y25uTpqDfr8foVAIxWIRd+/exZ07d8TUhJNRmrxQ5sAG8zDYbDYxeKNrdDKZxAcffACfzydunJubm/K4zxpGVMZnGMNq5l6vd6Qwkg5/AITmpvxS8X9TlzM2NobnnntO3JV2dnYQjUZx/vx5ofFtbW3BZDJhYWFBvsCcPJXLZdjtdjH0YNhgKBSSxZLUwpWVFYyPj0vnb3JyEiqVCj/+8Y9hMBgkSNpqtSKTycBsNiMcDkuIsVarlWkHKR1OpxMrKyvw+/1Ip9PQaDQoFou4ffs2LBaLOD5GIhEYDAYRWpNKUq1WodVqpahoNpuiLWJWGPBx542c9Oeee06mgdSLeb1e7O3tiZbr7t27MJvNcLvdUihlMhlxbnQ4HOJQde3aNVy+fFlshjudjujjgsGgdNFoVEHreBaanN5YLBYJ42Yxd/PmTdHEkTaZzWbFJWtpaQlTU1OSM9Jut5FIJEQ79tJLL+H73/8+Pv3pT8vnysehJvHevXsyMZudnRWaIKmum5ubqNfrkiNXKpXE7CMcDsPhcIhFMTNj9Ho98vm8FIparRabm5uIRCLSBSyVSpiYmJAClF24paUlGI1GiXHg9aBj1szMjPxvZrBxulmr1fo2ftKT3W53XxOB37OdnR0pQJUiYpVKJRPGhwmVHWGEET65oCvuYRh28OQhl1TuswbXPBogVSoVBAIB6PV6uFwuybNKJBKYmZmB1WqVCUe73Ra98TAozy9cZ+kePWyS1+12EY/HZWI0+Du5XA4qlUrMJDqdjvyO2WyWPScajYq+/Xvf+x6y2Symp6fR7XbxqU99StgrvJ7Kc1OpVMLdu3dFosCpYDKZFNZGOp0WA5Xp6Wl86UtfksY28DF9kcYVarVamDeD12V9fV3+na7Qg+AeXKvVUC6XEY/H8ZWvfEWCpOPxONLpNKrVKlKpFJrNJur1umShMVj6/Pnz2Nvbu68oAwCv1yvmIo1GA71eD61WC1qtFuFwWJyhf/zjH8vP6Lidz+dRqVQwMzODcDgs7CpKaJRgtm6tVpOp7OXLlxEMBuFwOCTi4f333xfTs6cxc/SsMCrMHjNOQiUYBgYRlkqloSGRStD17jiOq8vlEmel7e1tyQcJh8PIZrPIZrPiLEj78Xa7jWKxiL29PaH01et10eXw4F6v13H9+nWxa69UKgiHw5iYmIDdbkcwGEQymZSuEq8JNUXtdht37tyRjWB8fFzcCb1eL8LhMP7gD/4Aly5dwtTUFHZ2dmC328VxkofidDqNbDaLVqslCx3tW5kwzwlfOBxGJBKRjg6nOMq8tm63K/S6fD4vlv46nQ6BQEDs5dvtNtxut1DumGeyv78Po9EonHpa6wNANBoVbRM1U4lEQmx7WXSm02m0222MjY1hYWFBKIeJRAIbGxuYnJyEwWBAsVjEm2++icnJSTidTrGb73Q6CAQCmJ6eRiAQEKpCNpsVndfe3h5yuRz0er10TWkBzdgA4GPjFpvNhmg0inQ6LZRM0gk3NzdFB0e3QZ1OJ90+u90uIdwscm/duiXuS0tLS7IBsMgix558ftIDmQdTq9Vko+t2u3LtO52O/A1woENoNpuyqbL45zVLJpMoFAqSy9fpdKBSqeDxeGC1WkWTSPB7ycy0s9aeabVaKSY/qZvSCCM8KTyMJMHj8aDT6ch6cRqc9rtcq9Wwu7uLeDzed2gnbeyk+han0ynmVGQ9DHttpVIJ7733nuiIG40GNBoN4vE4UqmUZEkxkmVw6nUc6vU6ms1mH1VbWagcVpwABxM4s9ks+uRsNiuFLh2Zx8bGxEgllUrB5XKJHmtqago2m01+PgwsOvhafD6fNGvZQCStj5rke/fu4dy5c5ienkaz2cT169fx3nvvoV6vo9Vq4c6dO4hGo0PN4pT/ff78eUxPT6PT6eDu3bvC/lG+NhaMH330EWw2m5yhfvjDH8rkkkWtWq3Gzs4OrFarMHXa7fbQe/D555+H0+mUeBxa+n/00UfY3NwUdstgEc5zYq/Xw9bWFpxOp0glvF4vVlZWxMWbMgTq7Tk44N6ZzWYllsnlciEejz9WB8UngVFh9phxmO7kOJRKJfkCH/f3NDGgLkp5OGQQMM04Go0GTCYTbDYbXC6XULFisZi4+HDiQ4oA3QcZeN3r9aDX68Vhigus3+/vM29gUQNA0uZrtZp0urggezwe0WixCB0fH8f58+exsrKCxcVFyYu5c+cOxsfHMTExgUQiAbVajWAwiGKxiFKpBJfLBbfbjd3dXbhcLqE4Mk+Diz+t5GlYYjKZMDY2JhO3SqWCVColz+HxeNBqtWSyRJe/TCYDp9MpVAEGUvN62Ww2yYizWq3I5/OIxWJy4G+32zLdAYDd3V3purXbbXEdZKYdnZ5ounLjxg1sbGxIjEG320W1WsUHH3wAj8eDsbExoUDwtVUqFbHv5QKt0+lQKBQkF+by5cvweDxCG6EOLJvNYmNjQ7ptpVIJV69ehdvthtPpFM64Xq9HIpHAjRs3pLCNRCLw+XwolUp9eXKRSARjY2My1Xz33XcxOzsLv9+Pvb09iQNQ5rDRcZGfN3Vn7AzS0ZAi3kqlIveqVquVvDluCltbW0JV4feWh4ZSqYR0Og2VSgWv1ytTNiX4PT1MH8rfOSlYfHY6HaHijjDCCGeLhznwKbWlp8GgKyTdGo9yTRxmRqBWq7GwsACHw4G7d+8eaw5EO/lgMAij0Si6pOnpaXg8HmQyGTHNINWb038e8Pl+GadDtsudO3f6CqnZ2VkYjUaZpAyCjwUcNPtoXHESoxMe6HnQVxZ0tVoN9+7dQzQalddDeQHdEbnXhcNhzM7OYnt7+1jHSoPBILo+OkvS8RgAYrEYFhcX0e12sbOzI4UHTTE44eM+ctQ9YzAY5Fxy3LpfKpVQq9VQKpVQr9f7vAgGC1tSNCnVGIaPPvpIGu18rImJCSwvL8Pj8YgxGqdhg48PHDBKYrEYLBYL7HY7ut0uJicnxegkFoshFov17aGtVgsrKyuoVqtieR+Pxw/1XPikYVSYPQWgbuwoEeNpTD4MBgMMBgNqtVrf4Y+TCR5W+WVlHojSSZGLG+ldpPjV6/W+x2VRpkym5wKZzWZF80WXmnw+L++FLoqcuiWTSeTzeXi9XszPz8PlcskheGdnB2NjY4hEImi1Wrh79y5cLhfGxsbky+t2u1EqlSQjhnonmohQ0MsJidlsFoc7nU4nU8F8Pi8Ha1I+Y7EYKpUKNBqNZJGx08NuFR0GfT4fXC4XLBYLAEgxyi6QwWBAOByWjDaz2YxisSjulsoJ5NjYmIRzF4tF2UwZfs2CI5fL4d1334Ver0cymRSt1uLiooQ6s/Bj1ghwYAbDa8BNo9FowOVywW63I5VKodvtYn19HWazWTpvu7u70Gq1koXj8Xhk8ymXy0J3ZOZOo9GQe4bXgMUmp5GtVkssjl0ulxwGMpmMFCXUetXrddjtdjgcDnEHZfB1sViEz+eDzWaTe9pqtcLpdCKXyyEUCiGdTov5jdVqhdfrhcvlEmvlZrMpYaMAJE+GXVJaFvM+HsRRG+iDFFVKM5FnkVM/wgifdDyou2On04HJZJImJdeuZDKJXC534oMozZaKxSLq9TpcLteRFEmyOKi3rtVqYqik1WpFy66E0smRDTytVisaW6VZhhLZbFaMloaBj0ljqqMmZIPg79Jhmvs9G1jVahX1el2o6GShWCwW0WKRSt9ut/vMzoaB7IxIJIJeryfmKAxWBoBQKITp6WmhfZKRQko7JSnUXNO1+Pr16/fdR5ubm4jH49JoP6yQo7bvzp07uHbtmkTq0EREeT0ZrROPx4/MDaPOm3tvIBBAIBCAxWKRSBwWuWyiD7K16vW6GL2l02lkMhmEQiGZ7B5GX83lclIQsiEweE9otVqZsn2SMCrMnhLQROMsUCwWodFo0Gq1+r4gnCKw8GIHht0bLhbKzsf+/r50uLj4AQfdNrPZLFllzHhgrhRzrzjl0+l0fSGHzWZTqHIMUqQhCQsWOg2Re7y2tiZTKIPBIK5O5FdbrVY0Gg0kk0lZZNmFsVgswpXnImMymWC322UT0mq1Upj0ej0kk0nhtSst9NvttlwHxgYkk0m43W6Ew2FYrVYUCgWhmXS7XYkaYMHFDZebBq8P6QWkZXa7XWxubqJarcr1I02k0WgIpYWLYbPZxPj4OGw2GzKZDDwejxQoDLRkUUmnr3g83lecWiwWcd0kxSWdTmNjYwO5XE7y13w+nxSzNPtgsU9nqEQiIZM+BjHzGsdiMVSrVaF70qExGo0iGo1K9w84WNzHx8flXikWi2i329JRZUOBnHsai3Bzpt6Nj0VaB51CaWaSSCRkcyEdkxgswDjRG4SykzwMhxVmOp1OoioGw+k/aRvPCCOMcABlEUIaGhkmPLzSEZdGUofpz5UGIjToGoSyaca1nL/b6/Wwt7c31M48FArB5XKhXC4jkUig2WzC6XQiEAhAo9Egm80imUzC6/WKJToAWd+z2eyhBYBOp5P9hs29k0Kj0cj5gwf9YWss13xeO+6nwMGekEgkpPF82Gv0+XzodDrwer2ic1Zqv5XXmEVIt9sVR2VlBiX1+HNzcwgEAn2adiVyuRzMZrNcH+DjzFhOnKiz8/l8yOVyuHv3LiYnJ0WqQjkF3+/gnkhQHz943QBIw7ter2NtbQ3pdFrORzqdTphC1Wq1L9CbLCHeb8rwbp6NlO7LShynn/ykMkdGhdljwHGj6mG0hIcB85UGF2Z+EZVccLVaDYvFArPZLF9WAEJX4++RWgAc0BDZmSLtQq1Wo9PpyEbCxYC5WyqVSgoJhihbrVaUSiVYrVZYrVbRhblcLjnoFwoFsYuv1WpotVpi2kGuMfnU7EhxQ+Fhv9PpyKGXh23qqkhLrNVqfbx4Po9GoxFNFbVLDIrmhsCOIQvffD6ParWKQqEg14FTStIBGB7Ka8JQ7m63i0wmg2q1Cr1e3zfx4QRvY2NDCgcWoyaTCVNTU7h9+7Z8bly0qRGIRqMSkunz+eD3+9FsNrG9vS0hk2NjYzCbzXA4HNjf34fT6ZSCqVgsQq/XSxeNBjC8t5UZcLwvqEUAIIWtyWQCAHHgslqtEqlAgTJDvqklY5EKHGgjrVYrstks0ul0n+aSFE7SbprNJoxGo1AvSWPl1I0HGWXHlOYvp80LYn4f7x92JQcbJEdB+T6O6xgP20RHGGGEZw/c/7mPKRunbF5ynxs2kRqGYYZDpNCrVCqUSiV5HmURxjOAzWaDw+FAoVAQl+JBYw3Su5lvGY1GRRJADDPsUMLtdsPlcsn+ybMCmRZarfZIWib3qFwuJ4YoNptNnCGz2azok5RFG6nswMFE7yQxCGy4JZNJKeLIFFEWnZlMRgwrQqGQ6MjJniGjiSZYuVwOiUQCJpOp77NgnA/3Xhbf1AZy2hcMBtFqtWQ/BCD/rSzayO45ykBuEMppJs3kWOSRhdNut6W5T5AJ1uv1+iz4gQPKJYtUp9MJl8sl1/I0+KTuf6PC7DFgWJbGWTwmD2aDj0uDkcGRvJJnrHSO47ifVEW9Xi+LpPJ3WKQ4nU4Zq/PwzAkUBbgUQHPRpzsfp0N83dS6MfeqUCgIJ7rb7SKfzwvH2u/3w2AwoFAoYGtrS35OPVOhUJAigBuQ2WyWw73JZJI8DS6KAIROx0W01Wphe3tbilZOqUj3pDEHx+3dbheRSAQ6nQ75fB6lUkkMJhjEyW6RyWQSWiHpiBaLRfI46LDEAoaLOgsFiozb7Tb0er04KpIKu7S0hP39fTGJoH6NnT2r1Sp6LQDI5/Ow2WyS21ar1fpoJ8z9SqfTuHHjBsrlskxC6Z5ot9uFCqjVapFKpWQaCBxsRqSr0uyDFFqlcJmbHjdPk8mETqcjm1g6nZaDAYM1ST3kPch7tVKpSHHITl+v15PvDOmqAMRRS6/Xw2azwW63i8byNNBqtfB4PJJPxwKVtsJKQfMwKA9Iw4JZqTPjNTqOcjPCCCM8W1BOVAiyUCgpGIaTmH1RNgBA8ilJax+21tFtEIA0NJnPRf15s9lENBpFvV6XJihNxAhS+QwGgxR3XMOYnxkMBiVvFIA06nK5nLBJ2Ggbdn14QOc+YLfb4fP5UCwWUalU4Ha7+2JNlPs/cVRRxrMPJ41ra2tHXm+eRdiI9Xg8EjFQqVREq5zJZLCysiJsHavV2vc4ZPUUi0VxgmQjmO9BrVZL43x1dVWuEa9lpVLB+Pi4mJAwwHwYlIUOte28N5TFFPBx1i7vk2aziY2NDSk++dmcRK9HHf9heJTZgU8jRoXZY8CjqOpZmAEQap6yoKHVrRLkTysLOk7JSPlSq9VSOHBhofbH4XDA7Xaj1Wohl8vdt0haLBZ4PB4YjUYEAgFZSEnL0mg0MuFJp9N9nSsAovFhLhbDrmu1GtbX17G4uAi32y2FAydKpC9Qe8WOonKaR60TKWtKo49kMomJiQlxM1TSQThq7/V6wklXqVRSeEajUczOzor9PUOeOamhwJVZPfwdq9Uq5hy8Np1OR8St1MTl83mxnWU2i/JzYb4JCz6fzye6u+vXrwsvPJfLSaHYaDSQSCQAHEy5NBoNlpaWUCgUkM/nkc1mYbPZsLCwIGHSpCmmUikEg0GYzWZUq1XY7XahPbL7msvlEI1GARws3h6PRzqBLCDZFeYGyn9XahhJv+AUi4Hf7XYb8XhcrgHvPW5qlUoFhUIBtVoNBoNBAkNdLpe8PuV3g+6OuVxO8tAYQXBS8F5jMDe7lZw2s/OcTCZP1KAZtmaQcszidHCjehhHuRFGGOHpBI0tlNID5bSc68JxhRkbotRhezweKfq4jirXEKU+bXd3V2JN6HhLWj4NwQZfsxJk5bhcLnQ6HXGY5rrJxm0mk0GhUJDDPc8GJpMJZrNZJAFK8LkNBgNsNps4AirZEcqAY+rpgH5TpaPAs4vVakWlUhFGxmHrrfJsFI1GZd9m45XnokajAZ1Oh3A4DLVajVQqBQBixrK1tYWNjQ2RGHBKxc+T1MKPPvpI9kw+t7Ig4t54mrOoyWTquzcGQWYLm8+UaigNs04S5cDJ6GG/q2QsParijJO9wzRvjxujwuwZhXIkT83VoLvTMLAA4PSACyPpjQx9ZAAwHQU5qt/f35dJh16vF1vwVquFSqWCRqMhdDJmnrH4y+VyQk3gYslFhgUSD7dcLPP5vBREdBpiCLTdbpc8KYfDAZfLJbQ1JZ+bmiQWolwUgYPFha6G6XRaOlksJnu9Hsxms7yXdruNvb09oQSSxkG6X7VaRafTEQt7rVaLnZ0dqNVqyVOpVCrY3t7G9evXYTQa4ff7odfrkclkkMvlhILBwoAbMruQtP7vdDqIRqPy+AaDAfPz87I483PqdDpIJpPC808mkzCZTJicnEQ4HBaKwubmJnK5HGZmZiTDjqHfvGf42LVaTeIP6OZFIxSPxyPdL5vNJhOvVqsFr9eLZrOJRCIhky/SdGi4waKaRjXMK9va2oJer5dct2Qy2TcBVh5UeAhxOp3Q6XSIxWJ9n7sS6XRadBGNRgObm5un0jgAEKOXaDSKZrMpDpb7+/tIJBJCRR20sj5NfAa1KMrQT+Djw8VR2UEjjDDCswmj0SgOgqSGK9cMUtyPA6c9arVaKG40ASMOKzZoUJXL5VCr1eQ5T7reUC6wuroqeZJsiGq1WkSjUaRSKaHYDRZOtVpNmnh37twZ+hxkblAKkMvlhI5eKpWws7PT9z6VUouj9G/AQaFFIyglSC89av3e39+XCZVGo4HdbofFYkG9XodKpYLD4bhPekIHaTZruZ9nMhlpWJO1xOklWU/DsLKycmQI+SAtniZnRxX7nGQ2m01xVX4QHDUpU6lUQgPlueNRgNp1umc/aah6fwxarDy4Pw48Kd3HsIT2wZ8r/12tVotxA7/0AISLDUBoAABEJ3WY8JgdJX6JOH1RgvobOv7x0M7CjR2zfD4vxRnw8UiddDx2hpjNpez2Kf+/w+HA5OSkFFU0h6C4mXx2Zqqxm8ZCiFNIPqbFYoHRaEQqlYLH40G9XhcLejoVNhoNTE9Pw2KxyHSO06NIJAKLxSITo3g8LlbFjUYDe3t7fbq+cDgsdA5OAVkQc6PW6/VoNBowGo19xiOkUtKhMx6Py0TU6/ViYmJCpnmlUqnPeZL3LzcKZRdOrVbD7/dLmDUdI2OxmNgAA5DPiVTCyclJoYJUq1XJJAM+1ixyMjkzMwOLxSJFErPLstksAoGAdD6PcykkhZU0Rk6xBu9HoN/1cPB7oqQGs2HABgY72Cy6+HN2h/V6vThLDnudnPyelluvBD9jdpcLhQLsdvsDP94IIzxOPM79+WkFGyvD1gi61p7VUc1mswHAfa7NRyESiWBiYgLFYhGrq6un0igdBrVaDZ/PBwDiJDm49lJWQfqfy+WSqdIglM3p416f3W7H1NSUOEavrq4KVV6pFW6320dOaQKBAAqFwqnzKg87J6rVajEBe+GFF2Cz2bC5uYn19XWREWi1Wtn7qafma2TO3KDWS2lIdZL7yGKxwOFwiAHXsPvE7/eLZb7S7GOE43HcHv1EC7NcLod/8k/+CX7v934P5XIZ58+fx//0P/1PuHLlivzOL/zCL+Df/tt/2/d3i4uL+IM/+IMTP88nbeHnAVBJTWRXjVObk4J/TxfH426HozaQQSgnPrQB5qSOX3yO2KvVKtLpNFKpFLRaLWZmZmAymZDP53Hr1i24XC6EQiGUSiVxEeSIu1QqiZ5HWUwpJ3ccVe/v7yObzUpBA0AsbXu9nlAt6cDkdDrlQJ/JZMSkgyN8t9uNzc1NmT61221Uq1UUi0XJ3eBiy8mi0+lEJBKBRqNBoVDA9vY25ufnYTab0W63sbOzI50+ZmxRB0W7XCW42PJ3afqh/DkAjI2NSWFJDrxSs2SxWOByuUQ36Ha7ZWpKjZ/dbke73cb6+joKhQJsNpsYx/CzVavVyGQyyGazmJqaQjAYRLd7EPJMbSCLYuX9y2tL2iQfOx6Py3sOhULisEmN4mDA5aDGcnDCxOf2+XwyBaUTJ4XcLLRoIMNAbArR9/f3YbVa+w4TFLDTJIaifU4MB81E+Jp0Op3QKM4Co8JshLPCysoK/vE//se4evUqDAYDXn/9dfzCL/wCAoGA/M6rr74qzSfiW9/6Fr797W+f6Dk+afvzg8BisUCv1x9pb3+Wz6XVaiUWhDiqqRwKhYTtwMzIswT3DTKBlPTMR3FEvXjxIhwOB5LJJNbX1/vet9vtFsbQ3t7eoXosJc6KRu5wODAxMYFkMilnJLoin3R/YPSC8r/ZEFbGJCmhjEpSwuVywWAwSGyOclrLPea4vLzDMCjHAU5OLT1LPAnL/ae6MPtv/pv/BhcvXsRP/MRPQKvV4pd+6ZfwK7/yK/jwww8xPz8P4GCBj0aj+OVf/mX5O51O17cxHIdP6sLPqRdFpRTiDjMDMRgMcvjkv7FbT3OI40BOM3nqpFUN68Ko1Wo4HA6ZnBgMhvsyWTQaDbxer0xkqNtyu90y3qebYDAYRDgcBnBAPVMGRvL5lFQ22qCzsNBoNHC73eLGSMEzXw9DuemuyOkYH5fCZG6cPNxTm0Y+9tbWloz1NRoNnE6nHMwrlYrkrTWbTSSTSQQCAUxMTKDb7eLq1avwer0y4XI6nZiZmYHdbkepVML29rbo0/j4fH+5XA5LS0vw+XyoVCpyrcnzZnHCcE1SKD0eD0qlEjY2Nvo+x8HihpNBk8mEcrmMra0toWLQ7tZoNIqJhxLKjYLWySzW7Xa7ZL71ej0kEglEo1HppO7u7sLn88n3t9vtYn9/X+4VJZTUWGoojEajhJ+z4KJer9PpoFAoPBT9LxKJCDVIOU1mg+CoPB46jXLD5f33sBgVZiOcBTqdDl577TX8nb/zd3DlyhWk02n8z//z/4xSqYTr16/L701NTeFv/a2/hZ/92Z+Vf6Ou8iT4pO7PD4OTyBJOCh5+j2LyUBowqBU7DR7G5Mzr9cLr9aJYLCIWiwkDR6vV9mm+jwIP9SedLnJ/H9bIdjqdMo06Ca3d6XTKpO6kz3/c9QqHw31mZErXaP794Gd61GM+SPFI+3ueD2dmZmA2m1EoFJDNZlGr1R6YIWa32xEKhUS73ul04Ha7odfrJbrgk4qnujAjtYrodDowGo345V/+ZfzVv/pXARwUZul0Gt/5znce+Hk+iQs/x/x0faPjIXC8QxODgVlg8ZBMHvlx0Gg0oqHiJId5HYfBZrOJfTrpkRyvq1Qq6PV6mEwmGI3GPtqkcvITCAREzzTMvQo4OJCzsOPETpk9Vq/X0Ww2ZfpB7RELIADyexSyko7Hv6Eej6+XZia07+dXipMWimRJ9SQ1LxAIwGw2o1arIRqNIpvNYmJiAnt7e6KzYvE4OTmJqakpmEwmVCoVxGIxbG9v33eQd7vdQruknXGj0RAnKhqOsMCzWCzI5XIIBoPQ6/VYW1uDSqXC1NSUFDa9Xk+yazKZzH3GGcyCI12QVsdHdb0Gu1R+vx/z8/NC7aTIO5FIYGVlRcI4lcsVM7+U/8b7mHbJyskyheDcOEmdHdZUAE4mlHa5XGIqwhBQgkVouVw+lEfPLjS/d2fReR0VZiOcFQb36N///d/HV77yFezt7UmjbGpqCt/+9rfx1//6X3+g5/gk7s9PE5aWltDpdMSU6lGANEObzYZ8Po9CoQAAp2IBcH89TAt8HBYXF+HxeLCzs4Pd3d2HWkfZaFRmoR6F1157DXa7XRgwqVQKJpMJOp2ur7ABPnaM5jQqk8kcWnxyb6nVanA6neLQDBzsL/fu3ev7TKenp6FWq6XRShgMBjgcDlSr1b54mdPA4XBgcXFR8kQLhQLu3r0rcoPTghELvMZ09mYMz8OCDfqzYqKcJZ7qwmwQv/qrv4q/+lf/Kq5du4alpSUAB4XZf/pP/wkulwsOhwOvv/46/sE/+AeigzoJRgv/AQ6zHCWV8TS0AbPZLMGSnGCcFsyNUpoYMJODExSaUhyHwVBfj8eDiYkJGeHH43ER/3JCs7u7K4HOarUa+/v7MgkcBha0Go0GyWQSwEFxMDMzA7/fLzQ3Oh6yGCA1knb9XGiPKoKNRiPsdjvC4TDcbnefO2YsFkOhUBD3RWXANABMTEwAwH3T08FDP21u2akCDoTKpAvSBUqpLwMOhNTpdHroYswpIW3sh9EcHA4HbDYbWq0W8vm8WAJz4kRufa/XQyqVwltvvYWFhQXYbDYRiZ816LhFN8dBUK/GwlMJv98voeipVApWq7Uv9+44MCriJE2Rk2BUmI3wKFCv1/F3/+7fxZtvvokbN26IBnVqakqoaJFIBN/85jfxN//m3xwa+TAMo/350WPk2DocNP9QmlYpo1ROik996lNwOBzY3d29r1gC0CcbsNls0qDlWeE0cDgcCIVCqNVqSCQSffvR8vKymH2dhmKoVqvhdDqPze4cHx/H3NycNPGj0WhftAzPcKVS6aksiJ4WPPWF2RtvvIGf//mfF3vTX/u1X8OXv/xl+fk/+Af/AOFwGJ/73Oewt7eHX/iFX0C1WsUHH3wAo9E49DFp/04Ui0VEIpFH/l6eNOhg0+12H6hQYg4TD8QPCnY+ON1S0uOGFT20wj0sYFClOghYpt3sSYTHdF3S6/Vivzs9PY1yuSxTuEgkgl6vh729PVy4cAFerxcAkEqlsLOzg1KpBK1WK1Omwddmt9sxNzcHo9Eov8d8rmKxiO3tbZmU6PX6vulKNBqFTqeTDt8wBAIBeUxOgZrNJmKxmHTYuKCyaAMOpjAajQapVApqtVqcF4vFotBKDQaDOD6xeFCpVHC5XGI3TCgL+sP0CQT1YoxLKBQK4tY5uNQ4HA7JznO5XPD7/Wi1WkJjcDgc0lEc7KCSOsrHpGCbXPlBtzElBifKZrMZWq1WXCWVUKkOQs+VWkM+J+2ZOXWjhvJB6JEUcg+jgp4Wo8JshLPEP/yH/xD/4l/8C2QyGZw7dw6//du/jfHxcfn5N7/5Tfz8z/88FhcXcfXqVfz9v//38ef+3J/DP/tn/2zo4/1x3J+Zk/k4jMFOYp2vZE48LOjONxhUfVZgnEu9Xsfa2tqxv08JQ6/XkynTzs7OkU0yrVYr2uXTXJOlpSWYzWasrq7ex+Ihm4T76aOaVh4FGpPt7+/f99mwMTvsPHUUlVYZQfTHKVvsLPHUF2a0mE7LBAAAPaBJREFUYE+n0/jn//yf49//+3+PN998E8vLywA+1vIQ8Xgck5OT+Of//J/jr/yVvzL0Mf/hP/yH+MVf/MXH8fKfGvAAyZyR0woyWcgwJ+qov2eXiVatjwI0zFAuGqTpcUNR0sMOEy5zwVWr1YcKqy9dugSv1ysTr42NDXFoIveej8H8lkGNE+9Rn8/XZ2ChfB3MmePvcyrG6ZsSNB6hvTGpoJVKBYlEAtlsFjqdDm63W4ouq9Uq1vu7u7uiF6BGi7lnLDAHrdqV15CW9NQIMjeLCzwNXCwWi8QRKCdoKpVKKKWc9m1tbcHhcMDv90tuGB3HLBaLUCSYOZfJZPoaBKQhDm4Gg9PSQfB90bXLZrMJzVUZXO3z+YQqWiwW7zMUYbaO8nNluDepnk/DRjUqzEY4SxQKBRQKBWxsbODb3/42Go0GfvzjH8v3YXCP/v/+v/8PP//zP49YLIZQKHTf4/1x3J9HeDBoNBqEQiHMzc2h2Wzi7bffPrK4JbOBWmL+G/cgm80mBlhnhYWFBezv7w89X5B1wr3xcdPrHtWk1O/3w+fzIZ/PD40RGOFoPPWF2SAuXLiAz3/+8/h//p//59DfmZ+fxze+8Q38X//X/zX054+iI/e0UQF0Op3kezHfBBj+OpmdQSfC4/IphuFBxcg6nU4mGIfhuIM1cFDYTE9PS6evXq8jm82KNSwnPcwRs1qtkgPCg3ckEoHVahWHvHK5DIvFIm6A8XhcDCIGXwstbLkp6PV60ZABB180pXB62HthNhcpfMDH00C+bsJkMmF8fBxarRa7u7tSnAEQQXK73YZWq4XL5YJWq0U8Hodarcb8/Dy0Wi0ajYY4MNFcJRgMwu/3y1R1f3+/T99kNpuFitdqtSSfTPm+VCoVPB6PXI9hhQx59LTHt9vtMJlM4rpJK/1wOAyTySS5Opy0cuJ73HfuJPEUbFrQLIWaQ3b8aEJC+uXg94MmOxqNRvSHyscG0Bd2/aQxKsxGeFTY3d1FJBLBb/3Wb+FP/sk/OfR31tfXMTc3h+9///v4whe+cN/P/zhNzBj78azRug6TPTwoVCoVIpEIEonEic4R1J2T8me1WqFWq+9z/wQ+lmJ0Op2+vYCRJfV6vW9/OouznMFgwPj4uNDXj3o8l8sFr9crUT1klTxMRMpROOlZjZRKZX7cScH9hSZaxz0PTVaelj3ySeO4PfqpC5g2m81H3rC1Wg3xeFw0McNAqtZZ4nEWZTRSOOqGp6nDYPbHsNfJoOajcs6AjztLyi81HfWazWafDT0PtGazWcw6lNanjUYD2WwW7XYb4XAY3W4XtVpNJmHUXx1mEqG08AcORMQbGxt9i6pGo5FJULFY7HNDYh6X1+vF4uJiny16pVKRwzcXsf39fbTbbbGIL5VKfYsViyk6XLIgYDE4zERCCY1GI5q6arUq1va93kFQp1arhcFgEFvcQCAAk8kkYdoOh0NcIfk+9Xo9wuEwnE6n3C/ZbFboHoMhpL3eQUYan59GKdRNWa1WscxVFmntdhu7u7t9Yc60w1c+tvLetFqtQqlkxhkpgcwhazQaQuPsdrsSLk5XzJO4YSk34sNMO/heeF8ovzNer1cMUAqFgriDVatV5PN5VKtVobGyQFOCj/M4N5ynrUk0wh8f8Ht01B69sbEB4P/X3pkHyVVd9//br/d9ejbNaGUJKCWEkU0sGckswVZMERZZki0UkIwoFySG4IANSIKEyHFiCCoTIiBAKqiIbQI2cSEBZZFSEAIhWUQwYCQBMpYEmn2knullel9+f+h3LrffvF6ne173zPlUqWC6X793333d995zzznfg7xzdC3m53qmqakJo6OjNSuOmw+KDPD7/Whvb0drayv8fj9OnjypOV5RFEdTU1PV61Jls6frfJYaykmlUGSp+nypKySxr/U6zZOyR7caY2c8Hsfx48eLbigDp+cGKnpN7arUKCO1aQpB1HqOpRhlNFeWmhqihsI2S+nLcDhcspeQoohqkUfeSOjmMYtEIrj33ntxzz33oKOjA6lUCk899RRuu+02vPzyy7jyyisRj8fxwx/+EBs2bMD06dMRCARw66234sUXX8ShQ4cwZ86ckq41WZOLjUajiF2nH+h4azLQAEaFotXFCoHTE67L5crxIpDyXDabhcPhEDlAQ0NDYhDweDwwm83CiCkUc0+hclSUWDZ82trahNFGSabq85AnqaOjA3a7XUjC0yBOqoder1cYkG63G/F4XOy8FTJgqSgy1VCjBbwak8mUU+srkUgIFSJKBCYjW5bRp1wp4LS3jkoTkFFL/0+5VRSad/ToUSFSomUs0sAuqxUCpycaMhZlOVwAov9k1SRZ4l2WoifhD1LBpGOz2az4DVKfqZHrmpRbUJVy30gB02g0wm63C6OTfiv0XSFDnfrP4XAgHA4jk8nA4XDkeJfVbdRqFylgkndSjyLzBHvMmGrw2muv4ejRo1i9erXYvLj99tvxyiuv4Pe//z1aWlqwe/dufPjhh7jhhhvgcrnw8ccfY+XKlbDb7di/f/+YmotaTNb5Gfh8TKtmgehSoeiIoaEhnDp1SoxPhRbIpYbaGQwGeL1esdFY6/GukvpW5HWj8MXu7u4atrBwO7Sk7fU+X7XbVQ3KqZNb7Dz1qsgI1LHHzG63Y+7cuVi8eLHYmT7nnHPw3HPP4corrwRwemdt/vz5+OpXv4rh4WFEo1EsWrQIu3fvLtkom6zQIplC1sgwUxtllKhZ6q4IfTbfjgiFT8ZiMfGPwuXo2rFYTNQ8mzZtGtLpNAYHBxEMBoVBQFDhZzISKCSBQuDkEgB0j+S5IgOrkJeQCjKTF48gzxAZZcDpzYK2tjbhRSPDIhaLifIE5E0ym80IBoMijj3f4EZeNQorJMl28oiR942u5ff7cwxt8tBRMWMyfqkgs8FgEM/A4XBgxowZ4n4olJCMQOoXCoukOl7A6Zhxh8Mh6reR8hMVpbTb7QgEAohEIrBYLMJwoYGUBlOaDKkUA3nCAAgjJ5PJwGKxwGQyCaOTvsOVDshUq42eAxlIVMScQjcphDSbzQq1y2AwKNQ4qTQAhdeqybe4ou8plX0oJ3zJ4XCI3xSHejD1wpe+9CW89NJLolbf6OgoLrvsMuzatQstLS0AgAULFmDbtm2YPXu2GMe/9a1v4cEHHyzJKJvsFIt8qSXBYBAOh0PkgpdiGNIzLOU4EvaqdGFPoYqhUKioN7GSa5DXjeY8vcjnVSOjsdQ6bSRmRsrHbrcbw8PDY8I7jUYj2traMDAwoHld2citt8iLUn4vLpdLrEvytb/U73G9Uhc5ZoFAICdfJ98xpMxXLo22I1eKqhIZMbKBIqMoilAEikaj454c7Ha7uI6cE1box015WCSGoXUPTU1NiEQiiMfjOXU6hoeHRWghLbLJWDMYDGhtbUUymRQiHGpPIQmZJJNJEQddKG6eClrSOajKPYV2Up0Ni8WCbDYrjN1CC2mTyYRMJpOza0r9RwWQydOSzWYRCoUQCATGqDtRbhmFPFKNNwoHojabTCbMnDlTeLh6enpgsVjQ3t4Oq9Uq6mXRgEafo1w1GuwpbHP69OlwOp2IxWIYGBgQOXQul0v0CRll9H0lZURZZp/quchKjzQ50HcpXziKjPpaxZBDc5xOJ06dOpWToE0huLFYTHhQ7Xa7CLOtpDaLbKTKvwt1aK4MeTGpOOl4YY8ZU21OnTolxJe0yGazGBkZKauMDdFI8zNt0JUyNtBCOhqN1nTDheau0dHRnLGRNvXGs+FVS2iNUmk4XSGsVquY//PVPK0WFOKer1alFjQ32e32ohL1BKWLkMIzhRUHAoEcATFKfZAVhOVzAOVHpIwXl8tVUmpCMSwWC9ra2oSjpg7Ml4qoW4+ZTCmDcqMM3NWglMWZekdALYJAnivyPqmRQ+HkRXQ+ZGW+UiFjKt9uVTabFQmhNpsNDodD/CNjjsIk5HpntJCnwTCZTOYMNDabTRgi8oSYzWbF/apFSSickDx3tFC3Wq0iXJT6u1gYJkFtUvcbCWZQnh4tdigHTA09Rzof/T95iUhtMBQKYWBgIMfjJ3vlKL+K1A1lbyS9Rgps0WhU5OBRqCZ5xOg9MijlPtaSTFYvDNSerVKhvqQwGpLtj0ajmnll9KxJ6EU9+dPfsjcxmUyK/qxkQUPqm+qdv0I7geQxrKeQEoaRIQ9ZPqjUxmSnnJ14mrMqNYqsVmtJBguFyGuVAaG5o1zsdrtYQ9SKTCajmWNONT8pEqRcaH7RmhdqgXoOLPUztD4qFVrL0T85b10mlUqNUY0m5JzzSrFarWVL5VerVABFQmWzWXg8nrwaBY1OXRhmk5lKEvUrddur/y40qMqL3Gw2K3KFyP1PbSAvUSKREAtikjgvRd0xn2FI0MSTTqeF4AZ5RcjbR+2QrxUKhYTRQN5WGsjJ6KDEX5L2z2QyOTlM5N0gw4mk6WWDgz5HfZZMJmE0GoXhV+j+Cz3HbDY7Jnwjn8Kg2rhUy9tT+9VeKQCiiCUZg9SX1OeyQUt9QDlowWBQ5AXS/ZJoB12fDEv1QC0/L3UfVRpDbrFYRAmFVColPHypVEoIutAEIBvPNAlq/UZkaPOBjM5KQrHoN0X/5M0ErXGAvN70WYZh6pdyDbPxhFPJ44G8CFefk+YSGteJ8YSq5ftsvmieSnLAAAh1Xnnzkvq40vGQ5sWJElvJt6FaDLl8TjnIm6pa68tC9enUIl2VfD8q8bZV0zAbHR0V3sNG9ZgVgw2zSQKF11mt1pzFcz7IC0R5QvnCSKuZJ0BheJlMRtOrQv8lz0U+vF4vDAaDyBciDxl9hgYBmqjkH6/sqZG9eXSMbLCpE6Wp7AB5oSKRiCiKTcdZLBZNY1SdaEuhDPS8SFVSC7vdPqZPyCNEg3Aikch5hrLqGRnQlJtG8dnURtnLZTAYxE4U8LmohlY4CH3nCiXZahWxpL7Op5RFg658v/Kig+ro0TFkDKmh+ysn/Jl+O5V+78lAtVqtOQupyTqBMMxUp9QFLo1DpRov6jmw2JikHoNL9XbJcwnNQeNZSBuNRlEDU94opHSIYmuT8Rq0lL9MkR31SjXWVtWaV8ox0irdtKwmZKBNVtgwqzGFvuzVlr02GAwiv6cYtNtgsViEDK26RhMwNjSNxCIqaRvV71CHGMptIuNC/b48wJKsO7nrY7GYUAGU+5MKFRcinzqg2uNBk01ra6vY6SJZd9nT5PP5RGgo/ZO9KDIk4KIoipjASD2QvFmyd072cKnVlCh/iXYuaRFA90D9T0aSrExIgh30nYhEIkLOl0JJKdFbvh6QG14hQ3/TNWkjQJ785RBO+bwkhiGHY5BYCykoUl2UYDAodlcpz46uL3sCy6XS36X8nSEDvxCTMQyDYZix0BxQyW+eRJxqgZzrW4x8ho48F9GmI0VdEHJEjkwt8u+KbRjWA9XyIlVKpXOcVqh+I1GKhoPesGE2iaBwQDVaggQ0GHq9XrS1tYlBNB6P12R3n9z9sjGgNi5IubDYbgzVwaJ2Uo0ptTElI4dq0gSnJQZCu210HgpXNJvNcLvdopgyTS6yJ4e8JJT0TcnYWsIWJPYh1w8jw4I8ZCT2EYvFhGEYj8dF0iu1Xd7xJMGSZDKZ4yVzuVywWCwIBAJIpVJwOp0wm80iRpsSkTOZTE6hbFnaXp7sZCEUGuTIcDQYDMLgpLBU9Y4skN8oJmOG+oSeE4mmUN26eDwuhEXoXmUPaL6JQysPrJpSxrXOzWAYpn4odb7MtxhUh/JNNIVC3yohlUrh5MmTY6JwSO221lDeca2x2+1IpVJIJpM5c1AjUk67qz235as/Wivq3WAH2DDTlfH+iPPVoVB/0WkRHYlExsQYk2oRGUyV5v9oeT+0IE8M5SepY8nz5eKoz6E+hvKitBJqSTXJ5/Mhk8ngxIkTMJlMcDqdYzyAVFSZ2kYqiel0Okcen2q4yJ8naX3KQyOFQsrB0rov8qrRe/F4XBRajsViiEajQonIZrPB7/drFhWniZWEVCgXiwwbm80m2kNiH5TgPTIyglgsBqfTOabf5GdDRiPl3ZFgSzweF2GdZJhRnTdSJevu7s47GJIBR0Ye9SkZnHI9sqGhIXg8Hng8HiHfr/5OU5/kuw8SdSHjl4z8akyqnCfGMEyp0CYW1QOTyZdz3AhohSOWoryrBySCVk79SVKUJvExh8MhhMxKId+zrXYUVTkUujZtQNfCoCEDvtrKnPmYqOuMh7qQy681jSTHWw2cTqfwDBULpaQfYzlfAwpjKyZsAFR/N4QMC/WujSzhLwt4yN4eKh8QDoeF9DPlqalD70wmkxD7kN8zmUxCqZHEQahPmpub4XQ60dPTA5fLJcIeg8Eg/H7/mAFBK7yR7kF2t5PhQqGe9GxlqXmZtrY2DA0Nwev1wuFw4NSpU0IoIxwOY3h4OGeH1Gg0wufzwefzIRaLCePPZrMVVPUym80idJYMTzn0E4DIx8tkMjlS9TJUPy2VSomC4RReSWGc6uedbxIhA11r8C1ULmEywXL5TCMx1eZnLdTlXoDT4+JESYJPtNeiXq4NnK7h6Xa70dfXV/X+LnXDmnC73UgkEhNuPNDahtYF6nzI1tZWsTmtzt2eCnNqtWkIuXymdCgMSw61U1NqUiSF3RVLpFQbD6QASGFk5DHRkix3Op0irK9cF7h68W02m9He3o5sNove3t6cY2UDjIokx+NxhEIhYbyQEQYAfr8fBoMB06ZNQzabxdDQEDKZDDweD9rb2+F0OpFIJET9LvLcJBIJzXDR9vZ2zJkzB4lEAn19fTmTjewVlHO+7Ha7KH5MAzHVRpN3ppxOJ5qamuBwOJBOp3Hq1ClkMhk0NzcLQ0ruKwpFJOn7pqYmuFwuAND0KJKkfCwWEzl5BoNB8zshTzRUtFT2nJHB2NzcLGqEqQtokhKhXDOOwjApPJLCDbQmKPIAk7dLhkJhtQw3nkAYhqknaJzS8kSoPWiVnLcU5LxdeY6cKPT2DYyMjIhoF622aKWCFDK45L632WwlCZ4Ap5/DrFmzkEgkcOzYsYrmq0o3H9XhrK2trchkMhgaGgKAnPQGopTrlGuYMqdhj1kDYTab4XA4hPIfDSZaaKnhVeomd7vdOXK4tGDOZDJwOp1iAZ5IJMbsvAAQi3T6kZd6r263G6FQqGB4QL74/FLutbW1FUajEYODg2OOVQ8ohc5nsVgwZ84cmEwm/P73v8+ZZOWCy5QUTeInra2twovV398vPkNFt6kPSSaeQjUpV4/CJ9LpNJqamoRHivqNoKLRpeYPUrHp4eHhnH612+0i/43y5xwOB9xut3iNYvsVRRGFqOV6abIkcjGo1AEZgHJbvF6v8EbKr5OYDQmWTEXYY8Y0EhM1P5P6sN6iCwCEEJaiKDUZp5qbmzULF/NCuXxsNpvwZAUCAVE2CMAYQ5Zyt2lDmELmC33n7Hb7hEn71xKtNVJTUxOy2WzFonGTlWJzNBtmkwQ5vFArJIAW0OQVKXVXpa2tTXhDBgYGCsYgUz0xEmfQA7vdLgzJUChU1HtYigFns9ng9XpzdpAKQfHjRqNRGCcWiwUzZswQoYXHjh0b8zmPx6MZtkceKJIfLiXOu6mpCZlMRkwQWlBYJvB5P1B/ycadz+cT4YFy0U4S6pDzwwrR0dEhjMTe3t6CkxV5FL1eLywWC4aHh8d8p+S8wmLP0Gw2w+VyiXCMyQwbZkwjMRXm53qBRJ6i0eikESiizWG5bE2tGW9YPG1cRqPRmqhS1oJC92y1WuHz+YTwC0HrQSYXDmXUEYPBIOpr1TqMSuv8cp6SLIFeDsUMEZfLBbPZjGg0OmbBO57By2QywePxwGg0IhqNlryrKMuzU7gb5ZdZrVYR+kcUy8EjhUW/349MJoPW1lZYrVb09PQAAKZNm4aRkZEczyQZLhaLRXg3KayQ7s3n84kQUABoaWlBS0uLCJ+Ud9Cy2SyGh4c1jW6tJGK73V40JIUMdcpXI9ESQva4BQIBTWOfvFhaz1jr2ZNYh7oEAyHv5tK90oA/bdo0BAIBfPzxx7BarTCZTJoiMPmg8EabzaaZaM8wDFMLaMypByW4WCw2aQwyYqLrWRkMBjgcDs2UhmKYzWY4nU6MjIwU3CBsa2tDU1MTent7y5rnaok8n7vdbqRSKUSjUTgcDsyYMUPktsuGGRtllcEes0mI1WqFoihVdY+TOINsgJhMJlEDjXKj6g0aRJuampBKpTAwMFDweLPZLGTffT6f8FSdPHmyooG4FEhkQwvZoyfvDJpMJrS2tiKRSGBwcDDnMx0dHbDb7fD7/QgGg2MGdcoJI0XOSmhubkZTUxMURUEsFhPqlcXugXL/yh123G43zGazMKrJu1jt8g56qmJVC/aYMY3EVJufa0W+scvj8RSMnGh0KKKjUNpDIytcjodZs2YhGo2OSUtg9IU9ZlOQWij6aMVJl1LAOR9USDiTyeRV/qvGYErhefKumlrx0OFwYHR0VIhOuFwuRCIRDA8PCwPN6/XC5XKJWmXRaBSDg4OiT6hWGHnWZEj+nuTZ7XY7Zs6cCYPBgCNHjiCZTKK5uRnBYFDIzVNtMZ/Ph0QikSPV73Q60dnZCa/Xi1AoNMYwC4fDwiCl+5f7t5RdUwpTzDeY+/1+zRyGfM+A+t3j8SAajQrJ/ULXl/NB1Eaf1m6jXFi70t3pybp4YRhm4rHZbEIoqZaGgaIoaGlpgclkQl9fX8574/HUWSwWOBwOXURBSsXtdsPr9aK/vx9+v19zzpoIo4zKw4yMjNSNETQ8PFxQWZmpT9hj1gDkq1dWTUh1kAQV6gVSWazEs6MoCqxWK1wulyieHIlESjYogNNGEOWXUU0xi8WCeDw+RqnIYDDA5/PB6XQiGo1iZGRETIpk0JHwh8PhQGdnJwKBAIaGhvLudlJNMPKAKooirhEOhzE4OJi3HgqQK15COVZaaobjpVRPU77j5FprJCwyGSAFyom8H/aYMY1Eo8/P9cJUFfagTUiDwYBYLAaHw4GWlhYkk0kMDAxUHMlDBl8ikcDJkydLmjOpLalUqqTcZ2Zqwh6zBsdms8FqtYp43loZZ8Uk8/NB9aYURRFKjVpYrVbY7XYhIFEqpK5HC3o5tllGDkEkSFYdgJCop0KJ+e6ltbUVyWQS4XBY5CLRtegciqIIVUCS2Pd4PMhkMhgcHEQgEMjJBzMajchkMsIrB5zO+Tt27FhOLbjOzk4oioLe3l7YbDYRix4Oh2EymZDJZOByueD1ekU9sunTpwuhju7ubnEvVAvNarWKGHXZu+l0OoXBR4Iw5UxgdrsdFosFyWRS1H6h70Iqlcq7Q5dvoqLYe+qrWoWNTjRUV49+w7xzyTBMLShFAInygvPJwjudTqH4rEWloei1hKJCqNQKiX7lE0IrlXA4LObOUs/jdrsxbdo0xGIxDA4OwuVyoaWlRZTrCQQCdZnywdQXbJjVOfF4XOy81HowrOT8srFSKPSQPEWVXoMgA1BNMpmEzWYTKn3pdFrUA5MLORe6fjabRTweRzweFx4Odb/LNdHoXkdHR0UhZK1Jj+p0qc+jXqSfPHlSXI/KD6TTadjtdrGoTyaTGB4eRjgcFmUCyGB3uVw5xhfVT5ONPyIajSKRSIhaag6HAwByVA7J20OiHTKxWExM0PL5K90lpPxFWjyMVziGjEa9J0F69pMhd41hmMYllUoVHIPUm4daVMMos9vtRWuGVRJhIKdaVGMDTGuOLkY4HBb3lkqlMDIyglAoJDYc9Z6PmMaADbM6R20Y0GKZduLpB1/N2izlSpzStYsZPVq1wtSvKYoianbFYjGhbGmxWBAMBoVBoobk+k0mE0KhEKLRqMhTomLFyWQyp5aWFurcJ6fTCY/Hg1gsJuqEAbkDfzqdFvlodD9au5NUlJu8TGpmz54Ns9mMSCSC7u5uZDIZUT+FJiqqFUbXP3nyZMFFPxkFHo8HJpMpx1ghbyT1M0HPil7TmiTzbRTIr7ndbrGxUAzKV6Rrqp+R2WyGyWQqydtK4ZoTaQiRUiT1r/rabJQxDKMnpYxBxTxD4xnHKEKjkPGn3sBsNNRrMVm1WJ5jGx3KneRwzdrAhlmDIQ+c5L2p9g+jnF0iCrXMZ2wAp3fIqNCiHKKm1W7aVVIPYnTufG1Lp9NiYU+GRCaTEZ4m6icq7JlIJDQnIfX54/E4AoFA0T5RGy9GoxFms1nkc1EIpRz2J9+/1+sVssokjU+eM3mnUy5Mqq6BYjAY0NTUpNnP0WhUeKHkIs/qiUQWKjEajWIHU6u2WjEvLgmdWK1WsRtbiEJ9TM+Q1CTl+6YNCtkQnujJgkpiNPrCgmGYyYXJZBJzkZ5jE20AFptL9WojRVnU6vrFzkupB9WQ/691hAbNv4WuIUe9eDyeMSJkTH7YMGsw1OFwxajkB1puXLaiKAV3g2RDqdzr066M1mfdbrcQi0gkEsLAMBqNcDqdMJlMSCQSOQZjMpkURkU+5D4rt/4MKQOmUikYjUbhRSGDId/uWTweR09PjzAk6fpqzyWFxpFaFt2fwWDIUWokw4zy4chTSEZNPpUwk8kk2k+Gm3owpVwEqjGnFVpKCdA0GZeyW6goirhHNdQWCs9Uv6f3biQ9F4ZhmHqCxk29N4zqXdBpIowGs9kMn88naqPKKQIdHR2w2Ww4evRoVdSoawVtghZqozoyKd8ajtGGDbMGhbwZasELGZPJBIPBUNO4Zlrgk6fAZDIJg4jaVU6uD+3updNppFIpEZ6YT+JdK6eLlBi1ct7UC2gt7xkt9B0OR443kCYWClPMN9HIBhiFuKnbrm6zfH8kWKKFXF6ADBkSlzCZTBgZGckxROl5yDl3hQZIMiJlgzSdTgtRD3rONNHL9yFL7NNzoedezHCSQ1Ypf02rv7TCIqk9slHJMAxTr1CYvTxG1op63jSqp9zbiTDM5OetfiYUAVMv/ZEPs9lcdB2hXhtMtqLmtYYNs0nMRAx6tYihJg+Loiiw2+0i30xNvlpYco6RljeH8s7UuVVa7TCZTFAUReR5kUdMzvMjw4fep/4gr1m5z4BEOaiNqVRK5N4pioJkMol4PD5GZfLUqVMYHR2FzWYTeYKkcEi5ZvJ9qWXcZUO+WL6gbPzRs5INM7nfS03olsNN6VxmsxlA8YFdFtmYqsVEGYZpLPT29NcjlAZQK/VHg8EAu92eV3myllCqghanTp2q+vVIlKya/ZhP1VN9DFM5bJg1KLJBlA/K1ZILKtcS8lyM51ry50nsgULi1OSb1EhZMR9k8FFtMi2y2dPy8tFoVEjV02fJcCAjwOl0IpFIIBKJiHpzNHCVU+xbfk5ms1kMqnSv5BFSP3f5Pug4dSgmlSug17S8XYVqbhUT8JBr7ak3BKifCiErYlKoaT7DLF9+GxmwvNhhGKaeoRD9qU4+ZUaKuqmVYUbzSrmfo9SERsFoNFb9nFoaAJVAwnX17iHUAzbMJjm0uC1ll6MSalXUks4ry7+r369UUj0ej8NoNOYYPvlQewQtFgvsdrvwoKVSKdhsNlEgGYAIXSw1j42QDbNgMChCBqgd6qRgrTAYMii17pmMlng8Pqbf8nkXS4EMchLhoBAdyk9T92Gx70qxEFg6v9azY08ZwzBM41LrMieZTAaBQKDsz5FBV2rbyo1YqkWEk5ZXkNZOQOV5f8XaWWxtJjsM2Ls2FjbMJjlU56pW6LXbMd4dR3nAKmdApOPkEMJAIIC2tjZMnz5diJH09fUJL496V0gWCJGJxWIid5Dk/bWQQxjLmcDG8z0oJTyQShbQoExeRPV5ig3Y5HnLB52/nvITGIZhmMkL5XeXGipPx5W7tqg1JpMJdrsd2Ww2R725GOXMt1artWCo6Hg2gqcCbJgxdUkhcQ0ttMLbinnz5ByyUgeJVCqFQCAwJmTPYrGI61mtVrS0tCASiQjDWA7FK3RvDocDTqcTfr8/r+FJ4iZUtHsiKKVIMiljFjqukFGmKIrox3g8rjn5GQwGXXIDGIZhmPqGokKKqQZWem6n05k3KkVNvXqCKvVIUoRRKf1KaR28cVoZbJgxdUUloZFWq1XUSSPFQqPRCIvFImqBaWGxWOD1ehGJRIrGs9Og7PP5kM1mEYlEEIlEhBeqp6cHoVBICHRQG6hdNKDJgxXlrskDXSgUQiwWKzhwkoIjeZcKhURqoZavL2WgJcGUYgnZpGZZTi0Wyj+jXTT1+amtFC5ayqTIMAzDTC28Xi8sFgtCoVDVjQMS0iIqPTdtCBdS1K5HaC1TSpsp7YO9YpVhyE4BkzYYDMLr9erdjCmPnBdGNb7UC3EK5auVJ0gWosgndFEIdQkCrZoesuoh5VcZjUbY7XbYbDbE43ExwGsZUQ6HQxhz+X6ecq02v99f1j243W40NzfDYrEgGo3i5MmTJcnZOp1ORKPRqk0mZLgaDIaC3r+mpiYoipK30LeWgTuVCQQC8Hg8ejeDYUqC52dGDc0N5UZHyJEzVqsVDocDkUik6gaC0WhEU1NTTZQUJyuslvw5xeZoNsyYolgslqoqSDU1NcFisWBkZKRulKmsVivMZrMwEErxCpF3Tqajo0MYG8Dp0MdwOIxwOIxUKgWz2QyXyyWOz5eIrE4yrubOHxl1JGISCoVqotrp9XrH7DIWQ1bk0jpfPB4XRiTtOk6BIaws2DBjGgmen6tDtRe+LpdLlGbRC0VR4PV6kc1mMTIyUpNr+Hw+ABApCqVgs9m4NhdTMWyYgQf+eqRahobZbIbZbEYsFqv5bozRaITH4xEFoMldrygKIpEIhoaGxD2ROqHNZoPVakUmk0EkEskJ8TMYDPB4PDkFlT0eT47cP4VkUnFoGVKJKmTcUmhlraSH82EwGNDR0QG32w2j0YiRkRH09/cjm83C5XIJSf9YLFZx27S8lQwbZkxjwfPz+FAUBS6XC8FgsKrnpU3EfHW3SoXGokrbR/OtXpu4pDbcSDL5Ew3nk5UHG2bggb8SnE4nDAZDXebzyN4kRVHgcDgQjUYnNNnWYrEglUoJo8Dlcmn2ldfrhcfjgdlsRiaTERL7yWQSgUCgYk8V5VuRSEYpxgmFPsqGoPqc1epDeUfR7XbDZrONMUzNZjMcDoeoKRcOh/OGrrS1tcFut8Pv99fld7KeYMOMaSR4fi4fitpwOp0IBAJ1nctjsVhgsVgm3bjtdrtzokFaW1uRSCQQDocbbrNQURS43e6yywi43W44HA4Eg8Gaqn9PNtgww9Qa+HnnYnw4HA4RahgKhTQHG4PBkHOMGrfbDZPJhHA4jGQyKYzcSCRS9oBNuWkkbzs6OjqmTbUoIK4OX63UaFN/joxUktJPp9NCSYukhckT6Xa7EYvFJt2EXmvYMGMaiak0PzOTCzLOKCcuGo2OWX+5XC6RL1dN40VRFNhstprXfWOqDxtm4IG/EahVoWr5/BQSUWx3sRptyaeW6HQ6hVpRJBLJMajMZjMA7dpkte4fQlEUtLa2wmg0IpPJYHh4uGgIicFggNVqhdvtht1uB3DaYM0XAkN9QyIs+WTxrVYr1zupADbMmEaC52emFBpZPKLeNsztdrvwYtarrP9kptgcXTdy+YFAAB988AFmzJiBM888c8z7J06cwMDAAM4991xedNQ5lQxC8kJd67MWiwVms7ksGXb1+Utd4Beqe0YeHZfLBZfLhXQ6PSaUhHLCZJxOp5DypVBGWbIeOG2QGY1GoViZTqeF4VbtQZ0MVWorhR0qioJwOIxsNisUJQuhKAoURRG5YmoD0uFwiMKcBL1HkywJfgCf5xEUKnPAMMzEc/z4cXR3d2P+/PloamrKeS+bzeLw4cNIpVI477zzxO+ZmVwUis5QFEVsLtZiM61Uo0zvnDQtKp2/ayVwRSV36slY1Jt6Mp4VvRsAnP7SXn/99bj00kvxyCOP5LwXi8WwYsUKzJ07F2vWrEFHRwe2bNmiU0uZUqj0y02hbPneG6+73mQywefzVbw7S22jOmZkUKjbrKXqmEwmEQwGMTAwgIGBAQSDQc37odC/RCKhOQFSyITRaKzoHuR7SSQSGB0dzZlEU6mUKIidSCSKGmaUN0c4nU40NzeLzZN8+Wzqc1A4BoVn0ATPMIz+DA4OYsmSJbj44ovx29/+Nue9I0eOYN68ebj88stx9dVX44wzzsC+fft0ailTS1KplCgFo4Y28/Q2iCoJ7SNRL6370pNUKlUTY4FKCjCfU0/9UReG2cMPP4x0Oo358+ePeW/Tpk14++238Yc//AEffvghnn32Wdx+++3Yv3+/Di1l9IK8TJVAqlUdHR1obW2FzWYbd3vS6TSGhoZw8uTJMe2iGirkAQROTxaRSASxWEzI5mtB5ypmoJa6e+h2u9Ha2opp06ahra0NVqs1p51axnA5g7bJZILH40FrayvcbjcikQgCgYDICytkbGtdM5PJ5DVKGYaZeLLZLL7zne9gzZo1mu9fd911OOecc9Db24vPPvsMV111FVauXDmlPd71tsCvJvk8ONlsVozb8jxTKnKN0fFQidERiUSKlsmpNRaLpa6jwca7GcyUju6G2TvvvIOf/vSn2Lp1q+ZgtnXrVnz3u99FZ2cnAGDZsmWYP38+tm7dOtFNZXRmPJ64eDyO4eFh9Pf3C+UhRVFKmkCoMLbJZMqZOBKJRF6pd/VOl2wEyROYmmL3mM+YUmO1WuFyuUSx7mw2C7PZLHLcxoPFYhGGJ/VtMpkUgh1Op7OkfiXRD/lvym2rp90rhpnKPPTQQ0in0/j+978/5r2uri50dXXh3nvvFQu3++67D319fdixY8dEN7VumMzjVylzVCUbazQ36mHU1sozVSpWqxXt7e1wOBx1a9Q3an5fI6JrIHgoFMJ1112Hxx57DB0dHWPe7+3txcDAAC688MKc1xcuXIiurq6855XrQAEoWwK00amnWNl6gcLk5LwtdRgeoU4ylmtlqfvVbDaLuHvZc1YsBLAaCbckmWw0GsdI9NJEQ1L6qVRK1GKp1BtF90ltz2QyMBgMooi22WzOKaxdDPVAT+djxgf/9plq8fbbb+Phhx/GO++8o/nbpHn4S1/6knht5syZ6OzsRFdXF5YtWzbmM1N9fp4KVDq/TdWxK5VKIRgM6m4gFqJe29WIFOtLXT1mf/VXf4Wvfe1ruPbaazXf9/v9AICWlpac11taWsR7WvzkJz+B1+sV/2bPnl29RjcA/APSJh6PjzEYtCYQrZ2hfOERyWQS0WhUF7laks8PBoNj2iznqWUyGXFcNBqteOeL+k4WBZFFQmKxGKLR6Lj6g7+740erhAPDlEswGMTq1avx+OOPY/r06ZrH+P1+UQJDptAcPdXnZ4ZRk06nEQwG89bxZCYXxeZo3Txm27dvx8svv4xf/vKX2LNnDwBgdHQUvb292LNnD7761a+KwV4dqx6NRguGY23YsAF33nmn+DuTycDv96OlpYV35P8/wWAQs2bNwokTJ+o6rrlR4f6tHdy32mSzWYRCobyLaIYph/Xr12P69Oloa2vDnj17hKF16NAhzJw5E/Pnz4fZbNbMJSs0R/P8XBo8ztUW7t/awX2rTalztG6GWSqVwvz58/GjH/1IvNbX14dIJILe3l7s3r0bs2bNgqIo6OnpyflsT09PwV02q9U6JsdFLe/LnMbj8fAPp4Zw/9YO7tuxcD0oplq43W5ks1msX78ewOfCRFu3bkV3dzcefvhhzJkzB4lEAidPnkRrayuA07v/AwMDeedonp/Lg8e52sL9Wzu4b8dSyhytm2G2fPlyLF++POe1BQsW4LLLLsO//Mu/ADhdA2nx4sXYvn07brjhBgCnvWo7d+7E3//9309wixmGYRhmavDggw/m/N3f34/Ozk5s3rwZV1xxBQDgkksugcViwfbt23HTTTcBAF577TWEQiEsXbp0wtvMMAzT6NR9Fcgf//jHWLp0KTZs2ICLLroIW7ZsQXt7O26++Wa9m8YwDMMwU5bm5mbcc889+MEPfoBMJgOHw4F77rkHa9euxbx58/RuHsMwTMNRV4bZF7/4RZx11lk5r1166aXYtWsXHnvsMbz99ts4//zz8bOf/Qwul0unVk4OrFYr7r///orqjTDF4f6tHdy3DDPxWCwWLFmyBD6fL+f1TZs24cwzz8R///d/I5VK4c4778Rtt92mUysnDzzO1Rbu39rBfTs+DFmWQWMYhmEYhmEYhtEV3QtMMwzDMAzDMAzDTHXYMGMYhmEYhmEYhtEZNswYhmEYhmEYhmF0hg2zKU5XVxfefffdvO+nUim8//77OHToEDgdsTSi0SjeeecdfPLJJ3o3peGJRqPYu3cvPv3007zHjIyM4MCBA+ju7p7AljEMw9SWWCyGvXv34tixY3mPCQQCOHDgAE6cODGBLWtsBgcH8X//938YHBzUuykNT19fH/bs2YNAIJD3mBMnTuDAgQMIBoMT2LLGhQ2zKcqWLVswb948XH755fiLv/gLzWP27duHM844A1dffTUuv/xyzJs3D0eOHJngljYWL7zwAjo7O7F69WpceOGFuPjii+H3+/VuVsMxODiIO+64A2effTa+9rWv4d/+7d80j9u8eTM6Ozuxdu1anHvuubjuuuuQSCQmuLUMwzDV49SpU7jrrrtw9tln4+tf/zoeeeQRzeO2bNkixr+5c+dixYoViMfjE9zaxuKOO+7A7NmzceONN2L27Nm444479G5SQ3LgwAGsXLkSF1xwAS6++GJ0dXWNOSYWi2HFihWYO3cu1qxZg46ODmzZskWH1jYWbJhNUY4dO4YXXngBt956q+b70WgUK1euxLXXXovPPvsMvb29OOuss7B69eoJbmnj8Nlnn+GGG27AP/zDP+DIkSPo7u7GyMgIS0dXwKeffopZs2bh4MGDOPvsszWP2b17N+6++25s27YNhw8fxkcffYRdu3bhgQcemODWMgzDVI8TJ06gvb0d77//ft56cPv378f3v/99PP/88zh8+DA++eQT/Pa3v8WmTZsmuLWNwzPPPIOnnnoK+/fvx6FDh7Bv3z48+eST+M///E+9m9ZwHDx4EKtWrcL+/fvzHrNp0ya8/fbb+MMf/oAPP/wQzz77LG6//faCn2HYMJuy/PSnPy1YAHTHjh3o6+vDfffdBwAwGo3YuHEj3n33Xbz33nsT1MrG4he/+AVcLhe+973vAQDcbjf+5m/+Bi+88AK78Mvky1/+Mu688040NzfnPebpp5/GokWL8Gd/9mcAgNmzZ2Pt2rV4+umnJ6qZDMMwVWfBggW466670NramveYp59+GhdccAGuvvpqAMD06dNx00038fhXgKeffhrXXHMNLrjgAgCna+f++Z//OfdZBdx444341re+BbPZnPeYrVu34rvf/S46OzsBAMuWLcP8+fOxdevWiWpmQ8KGGaNJV1cXpk+fLn5QALBw4ULxHjOWrq4uLFiwAEajUby2cOFCJJNJHDp0SMeWTU66urpw4YUX5ry2cOFCfPrppxgeHtapVQzDMLUn3/g3MDCAvr4+nVpV3+TrM17TVJ/e3l4MDAxwf1eASe8GMOMnm83irbfeKnhMU1MT5s+fX/I5/X4/Wlpacl4zm81wu92cM5UHrT6jv7nPqk+x/vb5fHo0i2EYJge/34/Dhw8XPObMM8/EjBkzyjpnofFP3lRlTguZhUIhzT4LBoNIp9M5m6rM+KA1j1Z/83qoMGyYTQKSySTWr19f8Jgvf/nLePjhh0s+p9lsRiwWG/N6LBaDxWIpu41TAa0+i0ajAMB9VgO4vxmGaQQOHTqEDRs2FDzmtttuw3XXXVfyOXn8Kw+j0QhFUTT7TFEUNsqqDIU4avU3fz8Lw4bZJMBisWDPnj1VPeecOXPQ39+PTCYDRTkd8To4OIhkMonZs2dX9VqThTlz5uDAgQM5r/X09AAA91kNmDNnjuhfoqenB2azGR0dHTq1imEYJpeLL764JnO01vinKApmzpxZ1WtNBgwGA2bNmqXZZzw/V59Zs2ZBURTu7wrgHDNGk6VLlyIYDOL1118Xr23btg0WiwWXXHKJfg2rY5YuXYqurq6celrbtm3D7Nmzce655+rYssnJ0qVL8T//8z858tDbtm3DZZddVjAhmWEYptFZunQpdu7ciUgkIl7btm0blixZArvdrmPL6pelS5fi5ZdfFjVZs9ksXnrpJSxdulTnlk0+HA4HFi9ejO3bt4vXRkdHsXPnTu7vIrDHbIryu9/9DsFgECdOnEA0GhW7eYsWLYLZbMZ5552HNWvWYN26dfjJT36CSCSCu+66C+vXr+fcnTwsW7YMCxcuxLJly7Bx40Z88skn+Nd//Vc888wzMBgMejevoUgmk0JSNxKJoLu7G3v27IHH48EXvvAFAMD3vvc9PPXUU1i+fDn+8i//Eq+//jp27tyJ3bt369l0hmGYcZFOp7Fv3z4AQDgcRm9vL/bs2QOXy4UFCxYAAG6++WY8/vjj+OY3v4lbb70Ve/fuxfbt2/G///u/Ora8vtmwYQMuvPBC3HjjjVi5ciV+9atfobu7u2gqCDOWwcFBHDlyBENDQwCADz74ACaTCbNnzxYesR//+MdYunQpNmzYgIsuughbtmxBe3s7br75Zj2bXvcYsrR1wEwpbrnlFk2lwO3btwuJ8mQyiUcffRSvvvoqTCYTVqxYgRtvvJGNjAIEg0E89NBD2LdvH7xeL9atW4errrpK72Y1HH6/H9dcc82Y18877zw8+eST4u+enh48+OCDOHToEDo7O/HXf/3XWLRo0UQ2lWEYpqqEw2FcccUVY14/55xzcqTG+/v78cADD+CDDz7AtGnTcOutt2LJkiUT2dSG46OPPsLmzZtx9OhRnHXWWfjhD3+IP/7jP9a7WQ3Hb37zG/zjP/7jmNdvuukm3HTTTeLvt956C4899hgGBgZw/vnnY/369ZxqUAQ2zBiGYRiGYRiGYXSGc8wYhmEYhmEYhmF0hg0zhmEYhmEYhmEYnWHDjGEYhmEYhmEYRmfYMGMYhmEYhmEYhtEZNswYhmEYhmEYhmF0hg0zhmEYhmEYhmEYnWHDjGEYhmEYhmEYRmdMejeAYRqFX/3qV0in07BYLFi+fLkubXj11VcxPDwMAFi2bBlsNpsu7WAYhmGYemFwcBCvvfYaAGDOnDm46KKLJrwNsVgML774IgDA5/PhG9/4xoS3gWl82DBjmBJZs2YNFi5ciHPOOUc3w2zXrl14//33sWPHDvT19aGjo0OXdjAMwzBMvXD48GGsXr0a3/72t7FkyRJdDLN4PI4XX3wRH3/8MbLZLBtmTEUYstlsVu9GMEwjYLPZ8MILL+Cqq67StR0HDx7E+eefz4YZwzAMwwB4/fXX8ad/+qdIJpMwmfT1OWzevBk///nP8d577+naDqYx4RwzZkpy9OhRPP/884jFYuK1WCyG559/HkePHi35PNu2bcOnn36K/v5+7NixA2+88QYymQwA4LPPPsO2bdtw4MCBqn2OYRiGYSY7b731Fl599dWc144fP47nn38e0Wi0pHOMjIzgueeeQzwex0cffYSXXnoJhw4dEu+/++672L59O44fP16VzzFMNeBQRmZK0tbWho0bN2Lv3r145JFHAAB33303XnnllbJ2uW655Rb80R/9EXp6ejB//nzs3bsXX/jCF/CNb3wD//7v/4558+bhzTffxA033IBHH3103J9jGIZhmMmOyWTC1VdfjRdffBFXXnkl4vE4rrnmGixYsACrVq0q6RzHjx/H6tWrcemllyIYDKK9vR07d+7Evffei3fffRf9/f3w+Xx444038F//9V/45je/Oa7PMUw1YMOMmZK43W784he/wCWXXIIrrrgC2WwWTzzxBN544w243e6yzhWPx3H48GHY7Xa89957+OIXv4hkMonDhw/DarViz549uOSSS7B+/XrMnDlz3J9jGIZhmMnMokWL8Hd/93dYt24dfve73+Gf/umfEA6HK9qo/JM/+RNs3rwZAPDAAw9gw4YNuPfee/HSSy8BAO677z7cf//9YwysSj/HMOOBQxmZKctXvvIV/O3f/i3WrVuHdevW4b777sNXvvKVss+zdu1a2O12AMCCBQtgt9vxne98B1arVVwHAD755JOqfI5hGIZhJjsbN27E3Llz8fWvfx2PP/44fv7zn8Pj8ZR9nltuuUX8P4mCqF87cuRI1T7HMOOBDTNmSnPXXXeJePWNGzdWdA6fz5fzt8ViyXnNZDJBUZScfLbxfI5hGIZhJjuKomDTpk04ePAgvv3tb2Px4sUVnUeeV2njU/1aPB6v2ucYZjywYcZMaTZt2gSPx4NYLIYnnnhC7+YwDMMwDAMglUrhnnvuwbx58/DrX/8aBw8e1LtJDFNz2DBjpiy7d+/G5s2b8bOf/QyPPvoo7r77bhw+fFjvZjEMwzDMlOf+++9HX18f9uzZg+XLl+P6669nDxUz6WHDjJmSjIyMYO3atfjBD36Ayy67DGvWrMG1116L66+/HolEQu/mMQzDMMyU5c0338Q///M/45lnnoHP58Pjjz+OYDCIDRs26N00hqkpbJgxU5Lf/OY3uOKKK/CjH/1IvPbEE0/g/PPPx65du/J+7s0338Svf/1r8feyZctwxhln5ByzYsUKzJo1K+e1VatWobOzc9yfe/XVV7Fjx46i98cwDMMwjcorr7yChx56CJdffjkAwOv14tlnn0V/fz/6+vryfu6Xv/wl9u3bB+B0PtiqVatEfhgAtLa2YtWqVTCbzeK1jo6OHAn+Sj8Xi8Xw3HPPcWFpZlwYstlsVu9GMEwjsHbtWiQSCTidTvzHf/yHLm1Yv369KGr55JNPwuv16tIOhmEYhqkXDh8+LDZaFy9ejNtvv33C2xAIBIRq4xlnnIEHHnhgwtvAND5smDEMwzAMwzAMw+gMhzIyDMMwDMMwDMPoDBtmDMMwDMMwDMMwOsOGGcMwDMMwDMMwjM6wYcYwDMMwDMMwDKMzbJgxDMMwDMMwDMPoDBtmDMMwDMMwDMMwOsOGGcMwDMMwDMMwjM6wYcYwDMMwDMMwDKMzbJgxDMMwDMMwDMPoDBtmDMMwDMMwDMMwOsOGGcMwDMMwDMMwjM78P3tKOv0JaBEIAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "saved carotid_prebf.gif (4.1 MB)\n" ] } ], "source": [ "if run_inversion:\n", " show_images(operator, image, result_carotid, REGION_CAROTID, title=\"carotid — scatterer prior\")\n", " render_prebf_gif(\n", " \"carotid_prebf.gif\",\n", " raw_data,\n", " result_carotid.channel_data,\n", " transmits=range(0, parameters.n_tx, 4), # subsample transmits to keep the GIF small\n", " fps=10,\n", " )" ] }, { "cell_type": "markdown", "id": "ebd495c8", "metadata": {}, "source": [ "![carotid pre-beamformed channel data: recorded vs recovered](carotid_prebf.gif)\n", "\n", "## Takeaways\n", "\n", "- The inversion reproduces the reference result of the\n", " [original study](https://github.com/sankethvedula/das-inverse).\n", "- The re-beamformed image matches the measured image well (post-BF corr ≈0.95), yet the\n", " channel data itself stays unrecoverable (pre-BF corr ≈0.06): in-vivo **speckle** lives\n", " almost entirely in the nullspace of the compounded DAS operator.\n", "- This ceiling is fundamental, not a tuning issue — the image simply does not carry the\n", " channel-data micro-realization. Bright point targets are a different story: see the\n", " [CIRS phantom tutorial](cirs_example.ipynb)." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.12.8" } }, "nbformat": 4, "nbformat_minor": 5 }