{ "cells": [ { "cell_type": "markdown", "id": "community-00", "metadata": {}, "source": [ "# Repeated phase encoding in an inverse-designed photonic classifier\n", "\n", "**Authors: Azka Maula Iskandar Muda & Uğur Teğin, Koç University**\n", "\n", "This example builds a three-stage photonic classifier with six optical channels and four class outputs. A balanced 1 × 8 splitter feeds the six central input branches, and terminators absorb the two unused outer branches. Two 6 × 6 optical transformations process the encoded fields before a 4 × 6 transformation directs the optical power to four class detectors.\n", "\n", "The input phase is applied before every optical stage. We compare this repeated-encoding architecture with an otherwise identical classifier that applies the phase only once. This controlled comparison follows the method introduced in [*Deep Inverse-Designed Nanophotonic Processors with Structural Nonlinearity from Repeated Phase Encoding*](https://arxiv.org/abs/2608.02094).\n", "\n", "We train the complex target matrices, construct the routed circuit in PhotonForge, and inverse-design the three silicon devices in Tidy3D. The final analysis compares the trained optical model with the realized transmission matrices.\n", "\n", "**What this notebook demonstrates:**\n", "\n", "- [Prepare six optical features for a four-class MNIST classifier](#mnist).\n", "- [Apply the image phase either once or before each of three passive stages](#compare-encoding).\n", "- [Connect a balanced SiEPIC splitter to the optical network in PhotonForge](#photonforge-circuit).\n", "- [Train the three passive transformations before electromagnetic realization](#train-target).\n", "- [Inverse-design the corresponding silicon devices using Tidy3D](#inverse-design).\n", "- [Compare the trained classifier with the realized optical response](#analyze-realized).\n", "\n", "\n", "\"schematic\"" ] }, { "cell_type": "markdown", "id": "community-02", "metadata": {}, "source": [ "## Setup\n", "\n", "First, we prepare the Python environment and load the libraries used for data processing, optical training, circuit layout, and electromagnetic simulation. Local data, layouts, figures, and the realization progress cache are stored under `output/deep`. The cloud controls remain off until they are enabled in the cost-estimation and inverse-design sections.\n" ] }, { "cell_type": "code", "execution_count": null, "id": "community-03", "metadata": {}, "outputs": [], "source": [ "%pip install --quiet --upgrade \\\n", " \"numpy==2.4.4\" \"scipy==1.17.0\" \"matplotlib==3.10.9\" \"scikit-learn==1.8.0\" \\\n", " \"jax==0.10.0\" \"optax==0.2.8\" \"autograd==1.8.0\" \"gdstk==1.0.0\" \"klayout==0.30.10\" \\\n", " \"photonforge==1.4.7\" \"siepic-forge==1.1.2\" \\\n", " \"siepic_ebeam_pdk==0.4.53\" \"tidy3d[design,extras]==2.12.0\"" ] }, { "cell_type": "code", "execution_count": null, "id": "community-imports", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
04:22:40 KST WARNING: The material-library variant 'Palik_Lossless' is          \n",
       "             deprecated and maps to 'Palik_LowLoss' because it contains a tiny  \n",
       "             fitted loss despite its name. Use 'Palik_NoLoss' where available   \n",
       "             for a zero-loss Palik model.                                       \n",
       "
\n" ], "text/plain": [ "\u001b[2;36m04:22:40 KST\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING: The material-library variant \u001b[0m\u001b[32m'Palik_Lossless'\u001b[0m\u001b[31m is \u001b[0m\n", "\u001b[2;36m \u001b[0m\u001b[31mdeprecated and maps to \u001b[0m\u001b[32m'Palik_LowLoss'\u001b[0m\u001b[31m because it contains a tiny \u001b[0m\n", "\u001b[2;36m \u001b[0m\u001b[31mfitted loss despite its name. Use \u001b[0m\u001b[32m'Palik_NoLoss'\u001b[0m\u001b[31m where available \u001b[0m\n", "\u001b[2;36m \u001b[0m\u001b[31mfor a zero-loss Palik model. \u001b[0m\n" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import gzip\n", "import inspect\n", "import io\n", "import json\n", "import pickle\n", "import struct\n", "import time\n", "import urllib.request\n", "from contextlib import contextmanager\n", "from importlib import resources\n", "from importlib.metadata import version\n", "from pathlib import Path\n", "\n", "import autograd.numpy as anp\n", "import gdstk\n", "import jax\n", "import jax.numpy as jnp\n", "import klayout.db as kdb\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import optax\n", "import photonforge as pf\n", "import scipy.interpolate\n", "import siepic_forge\n", "import tidy3d as td\n", "import tidy3d.plugins.invdes as tdi\n", "from autograd.tracer import getval\n", "from IPython.display import display\n", "from matplotlib_inline.backend_inline import set_matplotlib_formats\n", "from requests.exceptions import ConnectionError as RequestsConnectionError\n", "from requests.exceptions import ReadTimeout\n", "from sklearn.decomposition import PCA\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.preprocessing import StandardScaler\n", "from tidy3d import web\n", "from tidy3d.exceptions import WebError\n", "from tidy3d.plugins.mode import ModeSolver\n", "from tidy3d.plugins.smatrix import ModalComponentModeler, Port\n", "from tidy3d.plugins.smatrix.run import compose_modeler_data_from_batch_data\n", "from tidy3d.web.api import states as web_states\n", "from tidy3d.web.api.autograd import engine as autograd_engine\n", "from tidy3d.web.api.autograd import hooks as autograd_hooks\n", "from tidy3d.web.api.autograd.io_utils import (\n", " get_cached_vjp_traced_fields,\n", " get_vjp_traced_fields,\n", ")\n", "from urllib3.exceptions import NewConnectionError\n", "\n", "jax.config.update(\"jax_enable_x64\", True)\n", "td.config.simulation.use_local_subpixel = True\n", "set_matplotlib_formats(\"png\")\n", "plt.rcParams.update({\"figure.dpi\": 110, \"font.size\": 9, \"axes.titlesize\": 10})" ] }, { "cell_type": "code", "execution_count": 3, "id": "community-run-configuration", "metadata": {}, "outputs": [], "source": [ "ESTIMATE_COST = False\n", "RUN_CLOUD = False\n", "COST_APPROVED = False\n", "AUTOGRAD_SOURCE_CHUNK_SIZE = 1\n", "QUEUE_TIMEOUT_SECONDS = 600.0\n", "QUEUE_RETRY_DELAY_SECONDS = 30.0\n", "QUEUE_POLL_SECONDS = 5.0\n", "QUEUE_RETRY_POLICY = \"native_source_queue600_retry_forever_v1\"\n", "\n", "SEED = 7\n", "WAVELENGTH_UM = 1.55\n", "FREQ0_HZ = td.C_0 / WAVELENGTH_UM\n", "N_CLASSES, N_LAYERS, MNIST_CLASSES = 4, 3, 10\n", "if N_CLASSES < 2 or N_CLASSES > MNIST_CLASSES:\n", " raise ValueError(f\"N_CLASSES must be between 2 and {MNIST_CLASSES}.\")\n", "\n", "\n", "def channels_for_classes(n_classes):\n", " channels = (3 * int(n_classes) + 1) // 2\n", " return channels + ((channels - int(n_classes)) % 2)\n", "\n", "\n", "def next_power_of_two(value):\n", " return 1 << (int(value) - 1).bit_length()\n", "\n", "\n", "N_CHANNELS = channels_for_classes(N_CLASSES)\n", "N_SPLITTER_LEAVES = next_power_of_two(N_CHANNELS)\n", "FINAL_OUTPUT_INDICES = tuple(\n", " range(\n", " (N_CHANNELS - N_CLASSES) // 2,\n", " (N_CHANNELS + N_CLASSES) // 2,\n", " )\n", ")\n", "LAYER_INPUT_COUNTS = (N_CHANNELS,) * N_LAYERS\n", "LAYER_OUTPUT_COUNTS = (N_CHANNELS,) * (N_LAYERS - 1) + (N_CLASSES,)\n", "REALIZATION_TARGET_TAG = (\n", " f\"outputs{'-'.join(map(str, LAYER_OUTPUT_COUNTS))}_centered_final_rows_v1\"\n", ")\n", "if N_CHANNELS > 784:\n", " raise ValueError(\"N_CHANNELS exceeds the 784-dimensional PCA limit.\")\n", "if channels_for_classes(4) != 6:\n", " raise ValueError(\"Class-to-channel parity rule changed unexpectedly.\")\n", "CLASS_LABELS = tuple(range(N_CLASSES))\n", "MIN_SELECTION_ACCURACY = 1 / N_CLASSES\n", "FEATURE_ORDER = tuple(range(N_CHANNELS))\n", "DESIGN_UM_PER_CHANNEL = 2.1\n", "DESIGN_EDGE_UM = DESIGN_UM_PER_CHANNEL * N_CHANNELS\n", "FANOUT_RULE = \"balanced_next_power_of_two_centered_active_v1\"\n", "TERMINATOR_MODEL = \"ebeam_terminator_te1550\"\n", "PREPROCESSING_TAG = \"trainonly_pca_scaler_v1\"\n", "\n", "ROBUST_EPOCHS, ROBUST_REPLICAS, ROBUST_BATCH_SIZE, ROBUST_LR = 300, 16, 1_000, 0.001\n", "MATRIX_TRAINING_SEED = 17\n", "ROBUST_TARGET_ERROR, ROBUST_TARGET_MEAN_ACCURACY = 0.10, 0.92\n", "ROBUST_WINDOW_MIN, ROBUST_WINDOW_MAX = 0.08, 0.12\n", "ROBUST_MARGIN_TARGET, ROBUST_MARGIN_WEIGHT = 0.10, 1.0\n", "ROBUST_VALIDATION_SAMPLES, ROBUST_AUDIT_SAMPLES = 256, 512\n", "ROBUST_VALIDATION_INTERVAL = 10\n", "PHASE_SCALE, GAMMA_TARGET, GAMMA_WEIGHT = 0.5, 240.0, 2.0\n", "SIGMA_MIN, SIGMA_MAX = 10 ** (-6 / 20), 10 ** (-3 / 20)\n", "TIDY3D_LR_MAX, TIDY3D_LR_WARMUP_UPDATES = 0.05, 5\n", "TIDY3D_BETA1, TIDY3D_BETA2, TIDY3D_EPS = 0.9, 0.999, 1e-8\n", "FABRICATION_MIN_FEATURE_UM = 0.2\n", "FABRICATION_WEIGHT_MAX = 0.8\n", "FABRICATION_START_UPDATE, FABRICATION_FULL_UPDATE = 6, 15\n", "FABRICATION_BETA, FABRICATION_ETA0, FABRICATION_DELTA_ETA = 100.0, 0.5, 0.01\n", "SIMULATION_ARCHITECTURE = \"native_modal_component_smatrix_v2\"\n", "CLADDING_MODEL = \"silica_pdk_n14447002763\"\n", "OPTIMIZER_DIRECTION = \"gradient_ascent_on_negative_constrained_loss\"\n", "ACTIVE_MASK_RULE = \"square_filter_field_physical_silica_corner_mask_v3\"\n", "REFLECTION_WEIGHT = 1.0\n", "REALIZATION_OBJECTIVE = \"frobenius\"\n", "REALIZATION_MODE = \"synchronized\" # \"synchronized\" or \"sequential\"\n", "COST_ESTIMATE_MODES = (\"synchronized\", \"sequential\")\n", "REALIZATION_STEPS = 40\n", "CALIBRATION_STEPS, CALIBRATION_LR = 150, 0.002\n", "\n", "\n", "def tidy3d_learning_rate(update_number):\n", " update_number = int(update_number)\n", " if update_number < 1:\n", " raise ValueError(\"Adam update numbers are one-based.\")\n", " return TIDY3D_LR_MAX * min(update_number / TIDY3D_LR_WARMUP_UPDATES, 1.0)\n", "\n", "\n", "def fabrication_penalty_weight(update_number):\n", " update_number = int(update_number)\n", " if update_number < 1:\n", " raise ValueError(\"Fabrication update numbers are one-based.\")\n", " if update_number < FABRICATION_START_UPDATE:\n", " return 0.0\n", " if update_number >= FABRICATION_FULL_UPDATE:\n", " return FABRICATION_WEIGHT_MAX\n", " ramp_updates = FABRICATION_FULL_UPDATE - (FABRICATION_START_UPDATE - 1)\n", " return (\n", " FABRICATION_WEIGHT_MAX\n", " * (update_number - (FABRICATION_START_UPDATE - 1))\n", " / ramp_updates\n", " )" ] }, { "cell_type": "code", "execution_count": null, "id": "community-output-folders", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "versions: numpy=2.4.4, jax=0.10.0, optax=0.2.8, scikit-learn=1.8.0, photonforge=1.4.7, tidy3d=2.12.0, klayout=0.30.10\n", "configuration: 4 classes, 6 channels; design=12.6 um square\n", "output folder: output/deep\n", "cloud flags: ESTIMATE_COST=False, COST_APPROVED=False, RUN_CLOUD=False\n" ] } ], "source": [ "REPOSITORY_ROOT = Path.cwd().resolve()\n", "EXPECTED_NOTEBOOK = (\n", " REPOSITORY_ROOT / \"deep_inverse_designed_photonic_neural_network.ipynb\"\n", ")\n", "if (\n", " not (REPOSITORY_ROOT / \"pyproject.toml\").is_file()\n", " or not EXPECTED_NOTEBOOK.is_file()\n", "):\n", " raise RuntimeError(\n", " \"Start Jupyter from the repository root before running this notebook.\"\n", " )\n", "\n", "OUTPUT_DIR = REPOSITORY_ROOT / \"output\" / \"deep\"\n", "DATA_DIR = OUTPUT_DIR / \"data\"\n", "FIGURE_DIR = OUTPUT_DIR / \"figures\"\n", "CHECKPOINT_DIR = OUTPUT_DIR / \"checkpoints\"\n", "LAYOUT_DIR = OUTPUT_DIR / \"layouts\"\n", "MNIST_DIR = DATA_DIR / \"mnist\"\n", "for directory in (MNIST_DIR, FIGURE_DIR, CHECKPOINT_DIR, LAYOUT_DIR):\n", " directory.mkdir(parents=True, exist_ok=True)\n", "\n", "PROGRESS_PATH = OUTPUT_DIR / \"progress.npz\"\n", "optimizer_state_paths = {\n", " layer: CHECKPOINT_DIR / f\"progress_layer_{layer + 1}.hdf5\"\n", " for layer in range(N_LAYERS)\n", "}\n", "AUTOGRAD_CACHE_DIR = CHECKPOINT_DIR / \"autograd_source_cache\"\n", "AUTOGRAD_CACHE_DIR.mkdir(parents=True, exist_ok=True)\n", "QUEUE_RETRY_LOG_PATH = CHECKPOINT_DIR / \"queue_retries.json\"\n", "\n", "REPEATED_CHECKPOINT_PATH = CHECKPOINT_DIR / \"repeated_encoding__matrix_training.pkl\"\n", "MATRIX_TRAINING_CONFIGURATION = {\n", " \"n_channels\": N_CHANNELS,\n", " \"n_splitter_leaves\": N_SPLITTER_LEAVES,\n", " \"class_labels\": CLASS_LABELS,\n", " \"feature_order\": FEATURE_ORDER,\n", " \"preprocessing\": PREPROCESSING_TAG,\n", " \"fanout_rule\": FANOUT_RULE,\n", " \"terminator_model\": TERMINATOR_MODEL,\n", " \"physical_layer_inputs\": LAYER_INPUT_COUNTS,\n", " \"physical_layer_outputs\": LAYER_OUTPUT_COUNTS,\n", " \"physical_target\": REALIZATION_TARGET_TAG,\n", "}\n", "\n", "PACKAGE_VERSIONS = {\n", " \"numpy\": np.__version__,\n", " \"jax\": jax.__version__,\n", " \"optax\": version(\"optax\"),\n", " \"scikit-learn\": version(\"scikit-learn\"),\n", " \"photonforge\": pf.__version__,\n", " \"tidy3d\": td.__version__,\n", " \"klayout\": version(\"klayout\"),\n", "}\n", "print(\n", " \"versions:\",\n", " \", \".join(f\"{name}={value}\" for name, value in PACKAGE_VERSIONS.items()),\n", ")\n", "print(\n", " f\"configuration: {N_CLASSES} classes, {N_CHANNELS} channels; design={DESIGN_EDGE_UM:g} um square\"\n", ")\n", "print(f\"output folder: {OUTPUT_DIR.relative_to(REPOSITORY_ROOT)}\")\n", "print(\n", " f\"cloud flags: ESTIMATE_COST={ESTIMATE_COST}, \"\n", " f\"COST_APPROVED={COST_APPROVED}, RUN_CLOUD={RUN_CLOUD}\"\n", ")" ] }, { "cell_type": "markdown", "id": "community-06", "metadata": {}, "source": [ "## Photonic Classifier Concept\n", "\n", "The classifier alternates image-dependent phase encoding with passive optical transformations. This approach follows the repeated-data principle demonstrated experimentally by [Yildirim *et al.*](https://doi.org/10.1038/s41566-024-01494-z), where multiple linear optical interactions produce a nonlinear mapping of the encoded data. If $D(z)=\\operatorname{diag}[\\exp(i\\alpha z)]$ denotes the phase encoder, the three-stage optical mapping is\n", "\n", "$$\n", "a_{\\mathrm{out}}=M_3D(z)M_2D(z)M_1D(z)a_{\\mathrm{in}}.\n", "$$\n", "\n", "The matrices $M_1$ and $M_2$ are 6 × 6, while $M_3$ maps the six internal channels to four class outputs. Square-law detection converts the final optical fields into class scores.\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "community-deep-system-schematic", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from matplotlib.patches import FancyBboxPatch\n", "\n", "fig, ax = plt.subplots(figsize=(11.5, 2.4), constrained_layout=True)\n", "ax.set_xlim(-0.5, 7.5)\n", "ax.set_ylim(-0.8, 0.8)\n", "ax.axis(\"off\")\n", "\n", "blocks = [\n", " (0, \"8-way splitter\\n6 active leaves\", \"#DDEBF7\"),\n", " (1, r\"phase $z$\", \"#FFF2CC\"),\n", " (2, \"device 1\\n$6\\\\times6$\", \"#E2F0D9\"),\n", " (3, r\"phase $z$\", \"#FFF2CC\"),\n", " (4, \"device 2\\n$6\\\\times6$\", \"#E2F0D9\"),\n", " (5, r\"phase $z$\", \"#FFF2CC\"),\n", " (6, \"device 3\\n$4\\\\times6$\", \"#E2F0D9\"),\n", " (7, \"4 class\\ndetectors\", \"#FCE4D6\"),\n", "]\n", "for x, label, color in blocks:\n", " width = 0.72 if \"phase\" in label else 0.94\n", " patch = FancyBboxPatch(\n", " (x - width / 2, -0.33),\n", " width,\n", " 0.66,\n", " boxstyle=\"round,pad=0.04\",\n", " facecolor=color,\n", " edgecolor=\"0.25\",\n", " )\n", " ax.add_patch(patch)\n", " ax.text(x, 0, label, ha=\"center\", va=\"center\", fontsize=9)\n", "for left, right in zip(range(7), range(1, 8)):\n", " ax.annotate(\n", " \"\",\n", " xy=(right - 0.48, 0),\n", " xytext=(left + 0.48, 0),\n", " arrowprops={\"arrowstyle\": \"->\", \"lw\": 1.3, \"color\": \"0.25\"},\n", " )\n", "ax.set_title(\"Repeated phase encoding across three passive optical stages\")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "community-07", "metadata": {}, "source": [ "\n", "## Generate and Preprocess MNIST\n", "\n", "First, we select the images labeled 0–3 and create a stratified validation set. We flatten each image and reduce its 784 pixel values to six features using principal component analysis. Both the PCA basis and the subsequent standardization are fitted on the training partition only.\n", "\n", "We then apply the same transformations to the validation and test images and inspect the resulting feature coordinates.\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "community-08", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "active classes: (0, 1, 2, 3)\n", "(24754, 28, 28) (24754,) (4157, 28, 28) (4157,)\n" ] } ], "source": [ "MNIST_URL = \"https://storage.googleapis.com/cvdf-datasets/mnist/\"\n", "MNIST_FILES = {\n", " \"train_images\": \"train-images-idx3-ubyte.gz\",\n", " \"train_labels\": \"train-labels-idx1-ubyte.gz\",\n", " \"test_images\": \"t10k-images-idx3-ubyte.gz\",\n", " \"test_labels\": \"t10k-labels-idx1-ubyte.gz\",\n", "}\n", "\n", "archives = {}\n", "for name, filename in MNIST_FILES.items():\n", " path = MNIST_DIR / filename\n", " if not path.exists():\n", " urllib.request.urlretrieve(MNIST_URL + filename, path)\n", " archives[name] = path\n", "\n", "\n", "def read_idx(path):\n", " raw = gzip.decompress(path.read_bytes())\n", " magic = struct.unpack(\">I\", raw[:4])[0]\n", " dimensions = magic & 0xFF\n", " shape = struct.unpack(\">\" + \"I\" * dimensions, raw[4 : 4 + 4 * dimensions])\n", " offset = 4 + 4 * dimensions\n", " return np.frombuffer(raw[offset:], dtype=np.uint8).reshape(shape).copy()\n", "\n", "\n", "train_images = read_idx(archives[\"train_images\"])\n", "train_labels_all = read_idx(archives[\"train_labels\"])\n", "test_images = read_idx(archives[\"test_images\"])\n", "test_labels = read_idx(archives[\"test_labels\"])\n", "train_mask = np.isin(train_labels_all, CLASS_LABELS)\n", "test_mask = np.isin(test_labels, CLASS_LABELS)\n", "train_images, train_labels_all = train_images[train_mask], train_labels_all[train_mask]\n", "test_images, test_labels = test_images[test_mask], test_labels[test_mask]\n", "print(\"active classes:\", CLASS_LABELS)\n", "print(train_images.shape, train_labels_all.shape, test_images.shape, test_labels.shape)" ] }, { "cell_type": "code", "execution_count": 7, "id": "community-10", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(19754, 6) (5000, 6) (4157, 6)\n", "preprocessing: trainonly_pca_scaler_v1; PCA/scaler fit on training split only\n", "explained variance: 46.04%\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fit_images, val_images, train_labels, val_labels = train_test_split(\n", " train_images,\n", " train_labels_all,\n", " test_size=5_000,\n", " random_state=SEED,\n", " stratify=train_labels_all,\n", ")\n", "train_flat = fit_images.reshape(len(fit_images), -1).astype(np.float32) / 255.0\n", "val_flat = val_images.reshape(len(val_images), -1).astype(np.float32) / 255.0\n", "test_flat = test_images.reshape(len(test_images), -1).astype(np.float32) / 255.0\n", "\n", "pca = PCA(n_components=N_CHANNELS, svd_solver=\"covariance_eigh\")\n", "scaler = StandardScaler()\n", "train_scores = pca.fit_transform(train_flat)\n", "val_scores = pca.transform(val_flat)\n", "test_scores = pca.transform(test_flat)\n", "train_scaled = scaler.fit_transform(train_scores)\n", "val_scaled = scaler.transform(val_scores)\n", "test_scaled = scaler.transform(test_scores)\n", "\n", "train_features = train_scaled[:, FEATURE_ORDER].astype(np.float32)\n", "val_features = val_scaled[:, FEATURE_ORDER].astype(np.float32)\n", "test_features = test_scaled[:, FEATURE_ORDER].astype(np.float32)\n", "print(train_features.shape, val_features.shape, test_features.shape)\n", "print(f\"preprocessing: {PREPROCESSING_TAG}; PCA/scaler fit on training split only\")\n", "print(f\"explained variance: {pca.explained_variance_ratio_.sum():.2%}\")\n", "\n", "fig, axes = plt.subplots(1, 2, figsize=(8.4, 3.0), constrained_layout=True)\n", "axes[0].imshow(train_images[0], cmap=\"gray\", vmin=0, vmax=255)\n", "axes[0].set(title=f\"MNIST label {train_labels_all[0]}\", xticks=[], yticks=[])\n", "axes[1].bar(np.arange(N_CHANNELS), pca.explained_variance_ratio_)\n", "axes[1].set(\n", " xlabel=\"principal component\", ylabel=\"variance fraction\", title=\"Train-fitted PCA\"\n", ")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "community-12", "metadata": {}, "source": [ "\n", "## Build the PhotonForge Circuit\n", "\n", "Next, we assemble the complete optical circuit in PhotonForge using components from the SiEPIC library. A balanced eight-way splitter supplies the six active channels, and packaged terminators close the two unused branches. We then connect the three passive stages and place 18 phase encoders along the optical paths.\n", "\n", "At the output, four waveguides fan out from the detector pitch to grating couplers spaced by 127 µm. The electrical pads use a 150 µm pitch, and noncrossing S-bends separate the optical routes. Finally, we calculate the routed circuit response and check the layout for unintended optical, metal, and pad overlaps.\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "community-13", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "SiEPIC-EBeam-PDK Python module: siepic_ebeam_pdk, KLayout technology: EBeam\n", "KLayout SiEPIC-Tools version 0.5.31\n", "SiEPIC-Tools is up to date (0.5.31 vs 0.5.31).\n", "Version check, time: 0.07045769691467285 seconds\n", "SiEPIC-EBeam-PDK Python module: pymacros, v0.4.53\n", "Libraries associated with Technology EBeam: ['EBeam', 'EBeam-ANT', 'EBeam-Dream', 'EBeam-SiN', 'EBeam_Beta']\n", "SiEPIC 500-nm strip effective index at 1.55 um: (2.446947831912+1.280455805859e-09j)\n", "PDK checks: grating={'shape': (100, 2, 2), 'ports': ['P0', 'P1'], 'finite': True, 'frequency in band': True, 'passive': True, 'maximum singular value': 0.7884114662993124, 'forward/reverse magnitude residual': 0.09337928989945549, 'complex phase-reference residual': 0.12567391014347995}, splitter={'shape': (51, 3, 3), 'ports': ['P0', 'P1', 'P2'], 'finite': True, 'frequency in band': True, 'passive': True, 'maximum singular value': 0.9956460637429584, 'forward/reverse magnitude residual': 0.005365000000000064, 'complex phase-reference residual': 0.0054007801290508126}, terminator={'shape': (101, 1, 1), 'ports': ['P0'], 'finite': True, 'frequency in band': True, 'passive': True, 'maximum singular value': 0.04896530000000001, 'forward/reverse magnitude residual': 0.0, 'complex phase-reference residual': 0.0, 'return loss dB at 1.55 um': 27.556735372370103}\n" ] } ], "source": [ "PDK_ROOT = resources.files(\"siepic_ebeam_pdk\")\n", "\n", "\n", "def pdk_file(relative_path):\n", " node = PDK_ROOT\n", " for part in relative_path.split(\"/\"):\n", " node = node.joinpath(part)\n", " return node\n", "\n", "\n", "waveguide_node = pdk_file(\"CML/EBeam/source_data/strip_waveguide.txt\")\n", "with resources.as_file(waveguide_node) as waveguide_path:\n", " waveguide_table = np.genfromtxt(waveguide_path, names=True, delimiter=\",\")\n", "\n", "names = waveguide_table.dtype.names\n", "neff_real = next(\n", " name for name in names if \"neff\" in name.lower() and \"real\" in name.lower()\n", ")\n", "neff_imag = next(\n", " (name for name in names if \"neff\" in name.lower() and \"imag\" in name.lower()), None\n", ")\n", "frequency_index = int(np.argmin(np.abs(waveguide_table[\"f\"] - FREQ0_HZ)))\n", "PDK_NEFF = complex(\n", " waveguide_table[neff_real][frequency_index],\n", " waveguide_table[neff_imag][frequency_index] if neff_imag else 1e-10,\n", ")\n", "print(f\"SiEPIC 500-nm strip effective index at 1.55 um: {PDK_NEFF}\")\n", "\n", "\n", "def load_sparameters(relative_path, ports):\n", " node = pdk_file(relative_path)\n", " with resources.as_file(node) as path, np.load(path) as archive:\n", " f = np.asarray(archive[\"f\" if \"f\" in archive.files else \"frequencies\"])\n", " s = np.asarray(archive[\"s\" if \"s\" in archive.files else \"s_array\"])\n", " return (s[None] if s.ndim == 2 else s), f, list(ports)\n", "\n", "\n", "PDK_MODELS = {\n", " \"grating\": load_sparameters(\n", " \"pymacros/opics_ebeam/data/gc_source/GC_TE1550_thickness=220 deltaw=0.npz\",\n", " (\"P0\", \"P1\"),\n", " ),\n", " \"splitter\": load_sparameters(\n", " \"pymacros/opics_ebeam/data/y_branch_source/Ybranch_Thickness =220 width=500.npz\",\n", " (\"P0\", \"P1\", \"P2\"),\n", " ),\n", " \"terminator\": load_sparameters(\n", " \"pymacros/opics_ebeam/data/ebeam_terminator_te1550/ebeam_terminator_te1550.npz\",\n", " (\"P0\",),\n", " ),\n", "}\n", "\n", "pdk_model_checks = {}\n", "for name, (s, f, ports) in PDK_MODELS.items():\n", " maximum_singular_value = float(np.max(np.linalg.svd(s, compute_uv=False)))\n", " pdk_model_checks[name] = {\n", " \"shape\": s.shape,\n", " \"ports\": ports,\n", " \"finite\": bool(np.isfinite(s).all()),\n", " \"frequency in band\": bool(f.min() <= FREQ0_HZ <= f.max()),\n", " \"passive\": maximum_singular_value <= 1 + 1e-6,\n", " \"maximum singular value\": maximum_singular_value,\n", " \"forward/reverse magnitude residual\": float(\n", " np.max(np.abs(np.abs(s) - np.abs(s.swapaxes(-1, -2))))\n", " ),\n", " \"complex phase-reference residual\": float(\n", " np.max(np.abs(s - s.swapaxes(-1, -2)))\n", " ),\n", " }\n", "terminator_s, terminator_f, _ = PDK_MODELS[\"terminator\"]\n", "terminator_frequency_index = int(np.argmin(np.abs(terminator_f - FREQ0_HZ)))\n", "TERMINATOR_REFLECTION = complex(terminator_s[terminator_frequency_index, 0, 0])\n", "TERMINATOR_RETURN_LOSS_DB = float(\n", " -20 * np.log10(max(abs(TERMINATOR_REFLECTION), 1e-12))\n", ")\n", "pdk_model_checks[\"terminator\"][\"return loss dB at 1.55 um\"] = TERMINATOR_RETURN_LOSS_DB\n", "print(\n", " \"PDK checks:\",\n", " \", \".join(f\"{name}={value}\" for name, value in pdk_model_checks.items()),\n", ")" ] }, { "cell_type": "code", "execution_count": 9, "id": "community-15", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "fanout: 8 leaves, active=(1, 2, 3, 4, 5, 6), terminated=(0, 7), active power=75.0%\n" ] } ], "source": [ "CHANNEL_PITCH, GRATING_PITCH = 250.0, 250.0\n", "GRATING_LENGTH, SPLITTER_LENGTH = 392.0, 91.8\n", "SPLITTER_GAP, MODULATOR_LENGTH, BLOCK_GAP = 80.0, 260.0, 1_500.0\n", "ID_TAPER_LENGTH, ID_TAPER_MOUTH, ID_TAPER_OVERLAP = 3.1, 1.15, 0.0\n", "ID_PORT_PITCH, OUTPUT_FIBER_PITCH, ROUTE_RADIUS = 1.75, 127.0, 5.0\n", "BOND_PAD_PITCH, BOND_PAD_SIZE = 150.0, 100.0\n", "BOND_PAD_OPEN_SIZE, BOND_PAD_EDGE_CLEARANCE = 95.0, 100.0\n", "BOND_PAD_BANK_INNER_OFFSET = 225.0\n", "N_SPLITTER_STAGES = int(np.log2(N_SPLITTER_LEAVES))\n", "ID_LENGTH = DESIGN_EDGE_UM + 2 * ID_TAPER_LENGTH\n", "CHIP_WIDTH = max(4_900.0, (N_SPLITTER_LEAVES - 1) * CHANNEL_PITCH + 1_150.0)\n", "BOND_PAD_Y = CHIP_WIDTH / 2 - BOND_PAD_SIZE / 2 - BOND_PAD_EDGE_CLEARANCE\n", "SPLITTER_LEAF_Y = (\n", " np.arange(N_SPLITTER_LEAVES) - (N_SPLITTER_LEAVES - 1) / 2\n", ") * CHANNEL_PITCH\n", "active_leaf_start = (N_SPLITTER_LEAVES - N_CHANNELS) // 2\n", "ACTIVE_LEAF_INDICES = tuple(range(active_leaf_start, active_leaf_start + N_CHANNELS))\n", "DUMP_LEAF_INDICES = tuple(\n", " leaf for leaf in range(N_SPLITTER_LEAVES) if leaf not in ACTIVE_LEAF_INDICES\n", ")\n", "LEAF_Y = SPLITTER_LEAF_Y[np.asarray(ACTIVE_LEAF_INDICES)]\n", "IDEAL_ACTIVE_POWER_FRACTION = N_CHANNELS / N_SPLITTER_LEAVES\n", "SPLITTER_X0 = GRATING_LENGTH + 320.0\n", "SPLITTER_PITCH = SPLITTER_LENGTH + SPLITTER_GAP\n", "PHASE_X0 = (\n", " SPLITTER_X0 + (N_SPLITTER_STAGES - 1) * SPLITTER_PITCH + SPLITTER_LENGTH + 100.0\n", ")\n", "BANK_PITCH = MODULATOR_LENGTH + ID_LENGTH + 2 * BLOCK_GAP\n", "PHASE_X = tuple(PHASE_X0 + layer * BANK_PITCH for layer in range(N_LAYERS))\n", "ID_X = tuple(x + MODULATOR_LENGTH + BLOCK_GAP for x in PHASE_X)\n", "OUTPUT_X = ID_X[-1] + ID_LENGTH + 320.0\n", "CHIP_LENGTH = OUTPUT_X + 1_370.0\n", "\n", "SPLITTER_Y = {}\n", "for stage in range(N_SPLITTER_STAGES):\n", " group_size = N_SPLITTER_LEAVES // 2**stage\n", " SPLITTER_Y[stage] = np.asarray(\n", " [\n", " np.mean(SPLITTER_LEAF_Y[node * group_size : (node + 1) * group_size])\n", " for node in range(2**stage)\n", " ]\n", " )\n", "print(\n", " f\"fanout: {N_SPLITTER_LEAVES} leaves, active={ACTIVE_LEAF_INDICES}, \"\n", " f\"terminated={DUMP_LEAF_INDICES}, active power={IDEAL_ACTIVE_POWER_FRACTION:.1%}\"\n", ")" ] }, { "cell_type": "code", "execution_count": 10, "id": "community-16", "metadata": {}, "outputs": [], "source": [ "def pdk_port_spec(technology):\n", " return next(\n", " technology.ports[name]\n", " for name in (\"TE_1550_500\", \"strip_1550nm\", \"Strip\")\n", " if name in technology.ports\n", " )\n", "\n", "\n", "def data_model(model_name, ports=None):\n", " s, f, default_ports = PDK_MODELS[model_name]\n", " return pf.DataModel(\n", " s_array=s,\n", " frequencies=f,\n", " ports=list(ports or default_ports),\n", " interpolation_coords=\"real_imag\",\n", " )\n", "\n", "\n", "def pdk_component(cell_name, model_name, aliases, technology):\n", " base = siepic_forge.component(cell_name, technology=technology).copy()\n", " for registered_model in tuple(base.models):\n", " base.remove_model(registered_model)\n", " component = pf.Component(f\"SiEPIC {cell_name}\", technology=technology)\n", " reference = component.add_reference(base)\n", " for alias, original in aliases.items():\n", " component.add_port(reference[original], port_name=alias)\n", " component.add_model(\n", " data_model(model_name, aliases), f\"Packaged {model_name}\", set_active=True\n", " )\n", " return component\n", "\n", "\n", "def splitter_component(technology):\n", " aliases = {\"P0\": \"P0\", \"P_LO\": \"P1\", \"P_HI\": \"P2\"}\n", " return pdk_component(\"ebeam_y_1550\", \"splitter\", aliases, technology)\n", "\n", "\n", "def terminator_component(technology):\n", " base = siepic_forge.component(TERMINATOR_MODEL, technology=technology).copy()\n", " for registered_model in tuple(base.models):\n", " base.remove_model(registered_model)\n", " component = pf.Component(\n", " f\"SiEPIC {TERMINATOR_MODEL} east-facing\", technology=technology\n", " )\n", " reference = component.add_reference(pf.Reference(base, rotation=180))\n", " component.add_port(reference[\"P0\"], port_name=\"P0\")\n", " component.add_model(\n", " data_model(\"terminator\"), \"Packaged terminator\", set_active=True\n", " )\n", " return component\n", "\n", "\n", "def phase_component(technology, name):\n", " component = pf.Component(name, technology=technology)\n", " spec = pdk_port_spec(technology)\n", " component.add(\"Si\", pf.Rectangle(corner1=(-5, -0.25), corner2=(265, 0.25)))\n", " component.add(\"Si slab\", pf.Rectangle(corner1=(0, -12), corner2=(260, 12)))\n", " component.add(\"Si N\", pf.Rectangle(corner1=(0, 0.5), corner2=(260, 2.25)))\n", " component.add(\"Si N++\", pf.Rectangle(corner1=(0, -2.25), corner2=(260, -0.5)))\n", " component.add(\"M1_heater\", pf.Rectangle(corner1=(0, 5.75), corner2=(260, 9.75)))\n", " component.add(\"M1_heater\", pf.Rectangle(corner1=(0, -9.75), corner2=(260, -5.75)))\n", " signal_contact, signal_escape = (120, 7.75), (120, 17.75)\n", " ground_contact, ground_escape = (140, -7.75), (-30, -37)\n", " component.add(\n", " \"M1_heater\",\n", " pf.Path(signal_contact, 6).segment(signal_escape, join_limit=\"round\"),\n", " )\n", " component.add(\"M1_heater\", pf.Rectangle(center=ground_contact, size=(12, 12)))\n", " component.add(\"VC\", pf.Rectangle(center=ground_contact, size=(6, 6)))\n", " component.add(\n", " \"M2_router\",\n", " pf.Path(ground_contact, 6).segment(\n", " ((ground_contact[0], ground_escape[1]), ground_escape), join_limit=-1.0\n", " ),\n", " )\n", " component.add_terminal(\n", " pf.Terminal(\"M1_heater\", pf.Rectangle(center=signal_escape, size=(6, 6))), \"SIG\"\n", " )\n", " component.add_terminal(\n", " pf.Terminal(\"M2_router\", pf.Rectangle(center=ground_escape, size=(6, 6))), \"GND\"\n", " )\n", " component.add_port(pf.Port((0, 0), 0, spec), \"P0\")\n", " component.add_port(pf.Port((260, 0), 180, spec), \"P1\")\n", " component.add_model(\n", " pf.WaveguideModel(n_complex=PDK_NEFF, length=260, verbose=False),\n", " \"PDK waveguide\",\n", " set_active=True,\n", " )\n", " return component\n", "\n", "\n", "def taper_polygon(x0, x1, y, w0, w1):\n", " xs = np.linspace(x0, x1, 101)\n", " widths = np.linspace(w0, w1, 101)\n", " lower = [(x, y - width / 2) for x, width in zip(xs, widths)]\n", " upper = [(x, y + width / 2) for x, width in zip(xs[::-1], widths[::-1])]\n", " return pf.Polygon(lower + upper)\n", "\n", "\n", "def matched_transfer_component(response, technology, name):\n", " response = np.asarray(response)\n", " n_outputs, n_inputs = response.shape\n", " input_y = (np.arange(n_inputs) - (n_inputs - 1) / 2) * ID_PORT_PITCH\n", " output_y = (np.arange(n_outputs) - (n_outputs - 1) / 2) * ID_PORT_PITCH\n", " component = pf.Component(name, technology=technology)\n", " spec = pdk_port_spec(technology)\n", " for channel, y in enumerate(input_y):\n", " component.add(\n", " \"Si\",\n", " taper_polygon(\n", " 0, ID_TAPER_LENGTH + ID_TAPER_OVERLAP, y, 0.5, ID_TAPER_MOUTH\n", " ),\n", " )\n", " component.add_port(pf.Port((0, float(y)), 0, spec), f\"W{channel:02d}\")\n", " for channel, y in enumerate(output_y):\n", " component.add(\n", " \"Si\",\n", " taper_polygon(\n", " ID_TAPER_LENGTH + DESIGN_EDGE_UM - ID_TAPER_OVERLAP,\n", " ID_LENGTH,\n", " y,\n", " ID_TAPER_MOUTH,\n", " 0.5,\n", " ),\n", " )\n", " component.add_port(pf.Port((ID_LENGTH, float(y)), 180, spec), f\"E{channel:02d}\")\n", " component.add(\n", " \"Si\",\n", " pf.Rectangle(\n", " corner1=(ID_TAPER_LENGTH, -DESIGN_EDGE_UM / 2),\n", " corner2=(ID_TAPER_LENGTH + DESIGN_EDGE_UM, DESIGN_EDGE_UM / 2),\n", " ),\n", " )\n", " ports = [f\"W{i:02d}\" for i in range(n_inputs)] + [\n", " f\"E{i:02d}\" for i in range(n_outputs)\n", " ]\n", " s = np.zeros((1, n_inputs + n_outputs, n_inputs + n_outputs), dtype=complex)\n", " s[0, n_inputs:, :n_inputs] = response\n", " s[0, :n_inputs, n_inputs:] = response.T\n", " component.add_model(\n", " pf.DataModel(\n", " s_array=s,\n", " frequencies=[FREQ0_HZ],\n", " ports=ports,\n", " interpolation_coords=\"real_imag\",\n", " ),\n", " \"matched route-calibration response\",\n", " set_active=True,\n", " )\n", " return component\n", "\n", "\n", "def route_probe_component(technology, name, n_inputs, n_outputs):\n", " component = pf.Component(name, technology=technology)\n", " spec = pdk_port_spec(technology)\n", " input_y = (np.arange(n_inputs) - (n_inputs - 1) / 2) * ID_PORT_PITCH\n", " output_y = (np.arange(n_outputs) - (n_outputs - 1) / 2) * ID_PORT_PITCH\n", " ports, pairs = [], []\n", " for side, x, link_angle, probe_angle, positions in (\n", " (\"W\", 0, 0, 180, input_y),\n", " (\"E\", ID_LENGTH, 180, 0, output_y),\n", " ):\n", " for channel, y in enumerate(positions):\n", " link, probe = f\"{side}{channel:02d}\", f\"{side}_PROBE{channel:02d}\"\n", " component.add_port(pf.Port((x, float(y)), link_angle, spec), link)\n", " component.add_port(pf.Port((x, float(y)), probe_angle, spec), probe)\n", " pairs.append((len(ports), len(ports) + 1))\n", " ports += [link, probe]\n", " s = np.zeros((1, len(ports), len(ports)), dtype=complex)\n", " for link, probe in pairs:\n", " s[0, link, probe] = s[0, probe, link] = 1\n", " component.add_model(\n", " pf.DataModel(\n", " s_array=s,\n", " frequencies=[FREQ0_HZ],\n", " ports=ports,\n", " interpolation_coords=\"real_imag\",\n", " ),\n", " \"matched route probe\",\n", " set_active=True,\n", " )\n", " return component\n", "\n", "\n", "def noncrossing_reference_length_route(port1=None, port2=None, model=None):\n", " reference = pf.parametric.route(\n", " port1=port1, port2=port2, radius=ROUTE_RADIUS, model=model\n", " )\n", " reference_length = pf.route_length(reference)\n", " length_matched_model = pf.WaveguideModel(\n", " n_complex=PDK_NEFF, length=reference_length, verbose=False\n", " )\n", " return pf.parametric.route_s_bend(\n", " port1=port1, port2=port2, model=length_matched_model\n", " )\n", "\n", "\n", "def optical_route(first, second, waypoints=None, s_bend=False):\n", " kwargs = {\"model\": pf.WaveguideModel(n_complex=PDK_NEFF, verbose=False)}\n", " route_function = (\n", " noncrossing_reference_length_route if s_bend else pf.parametric.route\n", " )\n", " if not s_bend:\n", " kwargs[\"radius\"] = ROUTE_RADIUS\n", " if waypoints:\n", " kwargs[\"waypoints\"] = waypoints\n", " return first, second, route_function, kwargs" ] }, { "cell_type": "code", "execution_count": 11, "id": "community-19", "metadata": {}, "outputs": [], "source": [ "def add_optical_instances(instances, responses, technology, route_calibration=False):\n", " grating = pdk_component(\n", " \"ebeam_gc_te1550\", \"grating\", {\"P0\": \"P0\", \"Fiber\": \"P1\"}, technology\n", " )\n", " splitter = splitter_component(technology)\n", " terminator = terminator_component(technology)\n", " instances[\"gc_in\"] = {\"component\": grating, \"origin\": (0, 0)}\n", " for stage, y_values in SPLITTER_Y.items():\n", " for node, y in enumerate(y_values):\n", " instances[f\"split_{stage}_{node}\"] = {\n", " \"component\": splitter,\n", " \"origin\": (SPLITTER_X0 + stage * SPLITTER_PITCH, float(y)),\n", " }\n", " for leaf in DUMP_LEAF_INDICES:\n", " instances[f\"dump_{leaf}\"] = {\n", " \"component\": terminator,\n", " \"origin\": (PHASE_X0, float(SPLITTER_LEAF_Y[leaf])),\n", " }\n", " for layer in range(N_LAYERS):\n", " phase = phase_component(technology, f\"phase cell {layer + 1}\")\n", " inverse = (\n", " route_probe_component(\n", " technology,\n", " f\"route probe {layer + 1}\",\n", " LAYER_INPUT_COUNTS[layer],\n", " LAYER_OUTPUT_COUNTS[layer],\n", " )\n", " if route_calibration\n", " else matched_transfer_component(\n", " responses[layer], technology, f\"inverse region {layer + 1}\"\n", " )\n", " )\n", " instances[f\"id_{layer}\"] = {\"component\": inverse, \"origin\": (ID_X[layer], 0)}\n", " for channel, y in enumerate(LEAF_Y):\n", " instances[f\"phase_{layer}_{channel}\"] = {\n", " \"component\": phase,\n", " \"origin\": (PHASE_X[layer], float(y)),\n", " }\n", " final_output_y = (np.arange(N_CLASSES) - (N_CLASSES - 1) / 2) * OUTPUT_FIBER_PITCH\n", " for output, y in enumerate(final_output_y):\n", " instances[f\"gc_out_{output}\"] = {\n", " \"component\": grating,\n", " \"origin\": (OUTPUT_X, float(y)),\n", " \"rotation\": 180,\n", " }\n", " return grating\n", "\n", "\n", "def m1_bond_pad(technology, bond_pad):\n", " component = pf.Component(\"M1-to-M2 bond pad\", technology=technology)\n", " component.add_reference(bond_pad)\n", " component.add(\"M1_heater\", pf.Rectangle(center=(0, 0), size=(20, 20)))\n", " component.add(\"VC\", pf.Rectangle(center=(0, 0), size=(6, 6)))\n", " component.add_terminal(\n", " pf.Terminal(\"M1_heater\", pf.Rectangle(center=(0, 0), size=(6, 6))), \"T0\"\n", " )\n", " return component\n", "\n", "\n", "def bond_pad_x_positions(x):\n", " channel = np.arange(N_CHANNELS)\n", " signal = (\n", " x + BOND_PAD_BANK_INNER_OFFSET + (N_CHANNELS - 1 - channel) * BOND_PAD_PITCH\n", " )\n", " ground = x - BOND_PAD_BANK_INNER_OFFSET - channel * BOND_PAD_PITCH\n", " return signal, ground\n", "\n", "\n", "def add_edge_pads(instances, technology):\n", " ground_pad = siepic_forge.component(\"ebeam_BondPad\", technology=technology)\n", " signal_pad = m1_bond_pad(technology, ground_pad)\n", " for layer, x in enumerate(PHASE_X):\n", " signal_pad_x, ground_pad_x = bond_pad_x_positions(x)\n", " for channel in range(N_CHANNELS):\n", " instances[f\"sig_pad_{layer}_{channel}\"] = {\n", " \"component\": signal_pad,\n", " \"origin\": (signal_pad_x[channel], BOND_PAD_Y),\n", " }\n", " instances[f\"gnd_pad_{layer}_{channel}\"] = {\n", " \"component\": ground_pad,\n", " \"origin\": (ground_pad_x[channel], -BOND_PAD_Y),\n", " }\n", "\n", "\n", "def optical_routes():\n", " routes = [optical_route((\"gc_in\", \"P0\"), (\"split_0_0\", \"P0\"))]\n", " for stage in range(N_SPLITTER_STAGES - 1):\n", " for parent in range(len(SPLITTER_Y[stage])):\n", " for branch, child in enumerate((2 * parent, 2 * parent + 1)):\n", " routes.append(\n", " optical_route(\n", " (f\"split_{stage}_{parent}\", (\"P_LO\", \"P_HI\")[branch]),\n", " (f\"split_{stage + 1}_{child}\", \"P0\"),\n", " )\n", " )\n", " leaf_stage = N_SPLITTER_STAGES - 1\n", " for channel, leaf in enumerate(ACTIVE_LEAF_INDICES):\n", " routes.append(\n", " optical_route(\n", " (f\"split_{leaf_stage}_{leaf // 2}\", (\"P_LO\", \"P_HI\")[leaf % 2]),\n", " (f\"phase_0_{channel}\", \"P0\"),\n", " )\n", " )\n", " for layer in range(N_LAYERS):\n", " routes.append(\n", " optical_route(\n", " (f\"phase_{layer}_{channel}\", \"P1\"),\n", " (f\"id_{layer}\", f\"W{channel:02d}\"),\n", " s_bend=True,\n", " )\n", " )\n", " if layer + 1 < N_LAYERS:\n", " routes.append(\n", " optical_route(\n", " (f\"id_{layer}\", f\"E{channel:02d}\"),\n", " (f\"phase_{layer + 1}_{channel}\", \"P0\"),\n", " s_bend=True,\n", " )\n", " )\n", " elif channel < N_CLASSES:\n", " routes.append(\n", " optical_route(\n", " (f\"id_{layer}\", f\"E{channel:02d}\"),\n", " (f\"gc_out_{channel}\", \"P0\"),\n", " s_bend=True,\n", " )\n", " )\n", " for leaf in DUMP_LEAF_INDICES:\n", " routes.append(\n", " optical_route(\n", " (f\"split_{leaf_stage}_{leaf // 2}\", (\"P_LO\", \"P_HI\")[leaf % 2]),\n", " (f\"dump_{leaf}\", \"P0\"),\n", " )\n", " )\n", " return routes\n", "\n", "\n", "def electrical_routes():\n", " routes, terminals = [], []\n", " for layer, x in enumerate(PHASE_X):\n", " signal_pad_x, ground_pad_x = bond_pad_x_positions(x)\n", " for channel, y in enumerate(LEAF_Y):\n", " signal_waypoints = [(signal_pad_x[channel], y + 17.75)]\n", " ground_waypoints = [(ground_pad_x[channel], y - 37)]\n", " routes.append(\n", " (\n", " (f\"phase_{layer}_{channel}\", \"SIG\"),\n", " (f\"sig_pad_{layer}_{channel}\", \"T0\"),\n", " pf.parametric.route_manhattan,\n", " {\n", " \"waypoints\": signal_waypoints,\n", " \"width\": 6.0,\n", " \"join_limit\": \"round\",\n", " },\n", " )\n", " )\n", " routes.append(\n", " (\n", " (f\"phase_{layer}_{channel}\", \"GND\"),\n", " (f\"gnd_pad_{layer}_{channel}\", \"T0\"),\n", " pf.parametric.route_manhattan,\n", " {\"waypoints\": ground_waypoints, \"width\": 6.0, \"join_limit\": -1.0},\n", " )\n", " )\n", " terminals += [\n", " (f\"sig_pad_{layer}_{channel}\", \"T0\", f\"signal_{layer}_{channel}\"),\n", " (f\"gnd_pad_{layer}_{channel}\", \"T0\", f\"ground_{layer}_{channel}\"),\n", " ]\n", " return routes, terminals" ] }, { "cell_type": "code", "execution_count": 50, "id": "community-22", "metadata": {}, "outputs": [ { "data": { "image/svg+xml": [ "fiber_infiber_out_00fiber_out_01fiber_out_02fiber_out_03ground_0_0ground_0_1ground_0_2ground_0_3ground_0_4ground_0_5ground_1_0ground_1_1ground_1_2ground_1_3ground_1_4ground_1_5ground_2_0ground_2_1ground_2_2ground_2_3ground_2_4ground_2_5signal_0_0signal_0_1signal_0_2signal_0_3signal_0_4signal_0_5signal_1_0signal_1_1signal_1_2signal_1_3signal_1_4signal_1_5signal_2_0signal_2_1signal_2_2signal_2_3signal_2_4signal_2_5" ], "text/plain": [ "Component(name=\"deep_inverse_designed_pnn_full_chip\", technology=Technology(name=\"SiEPIC EBeam\", version=\"0.4.32\", layers={\"BlackBox\": LayerSpec(layer=(998, 0), description=\"SiEPIC\", color=\"#00408018\", pattern=\"solid\"), \"Chip design area\": LayerSpec(layer=(290, 0), description=\"Misc\", color=\"#80005718\", pattern=\"hollow\"), \"Deep Trench\": LayerSpec(layer=(201, 0), description=\"Misc\", color=\"#c0c0c018\", pattern=\"solid\"), \"DevRec\": LayerSpec(layer=(68, 0), description=\"SiEPIC\", color=\"#00408018\", pattern=\"hollow\"), \"Dicing\": LayerSpec(layer=(210, 0), description=\"Misc\", color=\"#a0a0c018\", pattern=\"solid\"), \"Errors\": LayerSpec(layer=(999, 0), description=\"SiEPIC\", color=\"#00008018\", pattern=\"/\"), \"FDTD\": LayerSpec(layer=(733, 0), description=\"SiEPIC\", color=\"#80005718\", pattern=\"hollow\"), \"FbrTgt\": LayerSpec(layer=(81, 0), description=\"SiEPIC\", color=\"#00408018\", pattern=\"/\"), \"FloorPlan\": LayerSpec(layer=(99, 0), description=\"Misc\", color=\"#8000ff18\", pattern=\"hollow\"), \"Isolation Trench\": LayerSpec(layer=(203, 0), description=\"Misc\", color=\"#c0c0c018\", pattern=\"solid\"), \"Keep out\": LayerSpec(layer=(202, 0), description=\"Misc\", color=\"#a0a0c018\", pattern=\"//\"), \"M1_heater\": LayerSpec(layer=(11, 0), description=\"Metal\", color=\"#ebc63418\", pattern=\"xx\"), \"M2_router\": LayerSpec(layer=(12, 0), description=\"Metal\", color=\"#90857018\", pattern=\"xx\"), \"M_Open\": LayerSpec(layer=(13, 0), description=\"Metal\", color=\"#3471eb18\", pattern=\"xx\"), \"Oxide open (to BOX)\": LayerSpec(layer=(6, 0), description=\"Waveguides\", color=\"#ffae0018\", pattern=\"\\\"), \"PinRec\": LayerSpec(layer=(1, 10), description=\"SiEPIC\", color=\"#00408018\", pattern=\"/\"), \"PinRecM\": LayerSpec(layer=(1, 11), description=\"SiEPIC\", color=\"#00408018\", pattern=\"/\"), \"SEM\": LayerSpec(layer=(200, 0), description=\"Misc\", color=\"#ff00ff18\", pattern=\"\\\"), \"Si\": LayerSpec(layer=(1, 0), description=\"Waveguides\", color=\"#ff80a818\", pattern=\"\\\\\"), \"Si N\": LayerSpec(layer=(20, 0), description=\"Doping\", color=\"#7000ff18\", pattern=\"\\\\\"), \"Si N++\": LayerSpec(layer=(24, 0), description=\"Doping\", color=\"#0000ff18\", pattern=\":\"), \"Si slab\": LayerSpec(layer=(2, 0), description=\"Waveguides\", color=\"#80a8ff18\", pattern=\"/\"), \"SiN\": LayerSpec(layer=(4, 0), description=\"Waveguides\", color=\"#a6cee318\", pattern=\"\\\\\"), \"Si_Litho193nm\": LayerSpec(layer=(1, 69), description=\"Waveguides\", color=\"#cc80a818\", pattern=\"\\\"), \"Text\": LayerSpec(layer=(10, 0), description=\"\", color=\"#0000ff18\", pattern=\"\\\"), \"VC\": LayerSpec(layer=(40, 0), description=\"Metal\", color=\"#3a027f18\", pattern=\"xx\"), \"Waveguide\": LayerSpec(layer=(1, 99), description=\"Waveguides\", color=\"#ff80a818\", pattern=\"\\\")}, extrusion_specs=[ExtrusionSpec(mask_spec=MaskSpec((6, 0)), medium=Medium(permittivity=1.0), limits=(0, 2e+07), sidewall_angle=0, reference=\"top\"), ExtrusionSpec(mask_spec=MaskSpec((1, 0)), medium={\"optical\": cSi_Li1993_293K, \"electrical\": Si}, limits=(0, 0.22), sidewall_angle=0, reference=\"top\"), ExtrusionSpec(mask_spec=MaskSpec((2, 0)), medium={\"optical\": cSi_Li1993_293K, \"electrical\": Si}, limits=(0, 0.09), sidewall_angle=0, reference=\"top\"), ExtrusionSpec(mask_spec=MaskSpec((4, 0)), medium={\"optical\": Si3N4_Luke2015_PMLStable, \"electrical\": Si3N4}, limits=(0, 0.4), sidewall_angle=0, reference=\"top\"), ExtrusionSpec(mask_spec=MaskSpec(operand1=[MaskSpec((12, 0)), MaskSpec((11, 0))], operand2=[], operation='+'), medium={\"optical\": W_Werner2009, \"electrical\": LossyMetalMedium(frequency_range=(100000000.0, 200000000000.0), conductivity=1.6, fit_param={'max_num_poles': 16})}, limits=(2.42, 2.62), sidewall_angle=0, reference=\"top\"), ExtrusionSpec(mask_spec=MaskSpec((12, 0)), medium={\"optical\": Au_Olmon2012evaporated, \"electrical\": LossyMetalMedium(frequency_range=(100000000.0, 200000000000.0), conductivity=17.0, fit_param={'max_num_poles': 16})}, limits=(2.62, 3.02), sidewall_angle=0, reference=\"top\"), ExtrusionSpec(mask_spec=MaskSpec((13, 0)), medium=Medium(permittivity=1.0), limits=(3.02, 2e+07), sidewall_angle=0, reference=\"top\"), ExtrusionSpec(mask_spec=MaskSpec(operand1=[MaskSpec((201, 0)), MaskSpec((203, 0)), MaskSpec((210, 0))], operand2=[], operation='+'), medium=Medium(permittivity=1.0), limits=(-2e+07, 2e+07), sidewall_angle=0, reference=\"top\")], ports={\"MM_SiN_TE_1550_3000\": PortSpec(description=\"Multimode SiN Strip TE 1550 nm, w=3000 nm\", width=8, limits=(-2.5, 2.9), num_modes=7, added_solver_modes=0, polarization=\"\", target_neff=2.1, default_radius=0, path_profiles=[(3, 0, (4, 0))]), \"MM_TE_1550_2000\": PortSpec(description=\"Multimode Strip TE 1550 nm, w=2000 nm\", width=6, limits=(-2, 2.22), num_modes=12, added_solver_modes=0, polarization=\"\", target_neff=3.5, default_radius=0, path_profiles=[(2, 0, (1, 0))]), \"MM_TE_1550_3000\": PortSpec(description=\"Multimode Strip TE 1550 nm, w=3000 nm\", width=6, limits=(-2, 2.22), num_modes=17, added_solver_modes=0, polarization=\"\", target_neff=3.5, default_radius=0, path_profiles=[(3, 0, (1, 0))]), \"Rib_TE_1310_350\": PortSpec(description=\"Rib (90 nm slab) TE 1310 nm, w=350 nm\", width=2.35, limits=(-1, 1.22), num_modes=1, added_solver_modes=0, polarization=\"\", target_neff=3.5, default_radius=0, path_profiles=[(0.35, 0, (1, 0)), (3, 0, (2, 0))]), \"Rib_TE_1550_500\": PortSpec(description=\"Rib (90 nm slab) TE 1550 nm, w=500 nm\", width=2.5, limits=(-1, 1.22), num_modes=1, added_solver_modes=0, polarization=\"\", target_neff=3.5, default_radius=0, path_profiles=[(0.5, 0, (1, 0)), (3, 0, (2, 0))]), \"SiN_TE-TM_1550_1000\": PortSpec(description=\"SiN Strip TM 1550 nm, w=1000 nm\", width=3, limits=(-1.5, 1.9), num_modes=2, added_solver_modes=0, polarization=\"\", target_neff=2.1, default_radius=0, path_profiles=[(1, 0, (4, 0))]), \"SiN_TE_1310_750\": PortSpec(description=\"SiN Strip TE 1310 nm, w=750 nm\", width=3, limits=(-1, 1.4), num_modes=1, added_solver_modes=0, polarization=\"\", target_neff=2.1, default_radius=0, path_profiles=[(0.75, 0, (4, 0))]), \"SiN_TE_1310_800\": PortSpec(description=\"SiN Strip TE 1310 nm, w=800 nm\", width=3, limits=(-1, 1.4), num_modes=1, added_solver_modes=0, polarization=\"\", target_neff=2.1, default_radius=0, path_profiles=[(0.8, 0, (4, 0))]), \"SiN_TE_1550_1000\": PortSpec(description=\"SiN Strip TE 1550 nm, w=1000 nm\", width=3, limits=(-1, 1.4), num_modes=1, added_solver_modes=0, polarization=\"\", target_neff=2.1, default_radius=0, path_profiles=[(1, 0, (4, 0))]), \"SiN_TE_1550_750\": PortSpec(description=\"SiN Strip TE 1550 nm, w=750 nm\", width=3, limits=(-1, 1.4), num_modes=1, added_solver_modes=0, polarization=\"\", target_neff=2.1, default_radius=0, path_profiles=[(0.75, 0, (4, 0))]), \"SiN_TE_1550_800\": PortSpec(description=\"SiN Strip TE 1550 nm, w=800 nm\", width=3, limits=(-1, 1.4), num_modes=1, added_solver_modes=0, polarization=\"\", target_neff=2.1, default_radius=0, path_profiles=[(0.8, 0, (4, 0))]), \"SiN_TE_895_450\": PortSpec(description=\"SiN Strip TE 895 nm, w=450 nm\", width=2, limits=(-1, 1.4), num_modes=1, added_solver_modes=0, polarization=\"\", target_neff=2.1, default_radius=0, path_profiles=[(0.45, 0, (4, 0))]), \"SiN_TM_1310_750\": PortSpec(description=\"SiN Strip TM 1310 nm, w=750 nm\", width=3, limits=(-1.5, 1.9), num_modes=1, added_solver_modes=1, polarization=\"TM\", target_neff=2.1, default_radius=0, path_profiles=[(0.75, 0, (4, 0))]), \"SiN_TM_1550_1000\": PortSpec(description=\"SiN Strip TM 1550 nm, w=1000 nm\", width=3, limits=(-1.5, 1.9), num_modes=1, added_solver_modes=1, polarization=\"TM\", target_neff=2.1, default_radius=0, path_profiles=[(1, 0, (4, 0))]), \"Slot_TE_1550_500\": PortSpec(description=\"Slot TE 1550 nm, w=500 nm, gap=100nm\", width=2, limits=(-1, 1.22), num_modes=1, added_solver_modes=0, polarization=\"\", target_neff=3.5, default_radius=0, path_profiles=[(0.2, -0.15, (1, 0)), (0.2, 0.15, (1, 0))]), \"TE-TM_1550_450\": PortSpec(description=\"Strip TE-TM 1550, w=450 nm\", width=2, limits=(-1, 1.22), num_modes=2, added_solver_modes=0, polarization=\"\", target_neff=3.5, default_radius=0, path_profiles=[(0.45, 0, (1, 0))]), \"TE_1310_350\": PortSpec(description=\"Strip TE 1310 nm, w=350 nm\", width=2, limits=(-1, 1.22), num_modes=1, added_solver_modes=0, polarization=\"\", target_neff=3.5, default_radius=0, path_profiles=[(0.35, 0, (1, 0))]), \"TE_1310_410\": PortSpec(description=\"Strip TE 1310 nm, w=410 nm\", width=2, limits=(-1, 1.22), num_modes=1, added_solver_modes=0, polarization=\"\", target_neff=3.5, default_radius=0, path_profiles=[(0.41, 0, (1, 0))]), \"TE_1550_500\": PortSpec(description=\"Strip TE 1550 nm, w=500 nm\", width=2, limits=(-1, 1.22), num_modes=1, added_solver_modes=0, polarization=\"\", target_neff=3.5, default_radius=0, path_profiles=[(0.5, 0, (1, 0))]), \"TM_1310_350\": PortSpec(description=\"Strip TM 1310 nm, w=350 nm\", width=2, limits=(-1, 1.22), num_modes=1, added_solver_modes=1, polarization=\"TM\", target_neff=3.5, default_radius=0, path_profiles=[(0.35, 0, (1, 0))]), \"TM_1550_500\": PortSpec(description=\"Strip TM 1550 nm, w=500 nm\", width=2.5, limits=(-1, 1.22), num_modes=1, added_solver_modes=1, polarization=\"TM\", target_neff=3.5, default_radius=0, path_profiles=[(0.5, 0, (1, 0))]), \"eskid_TE_1550\": PortSpec(description=\"eskid TE 1550\", width=3.31, limits=(-1, 1.22), num_modes=1, added_solver_modes=0, polarization=\"\", target_neff=3.5, default_radius=0, path_profiles=[(0.35, 0, (1, 0)), (0.06, 0.265, (1, 0)), (0.06, -0.265, (1, 0)), (0.06, 0.385, (1, 0)), (0.06, -0.385, (1, 0)), (0.06, 0.505, (1, 0)), (0.06, -0.505, (1, 0)), (0.06, 0.625, (1, 0)), (0.06, -0.625, (1, 0))])}, connections={}, background_medium={\"optical\": SiO2_Palik_LowLoss, \"electrical\": SiO2}))" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "def build_chip(responses, tag, route_calibration=False):\n", " technology = siepic_forge.ebeam()\n", " pf.config.default_technology = technology\n", " instances = {}\n", " add_optical_instances(instances, responses, technology, route_calibration)\n", " add_edge_pads(instances, technology)\n", " terminal_routes, terminals = electrical_routes()\n", " ports = [(\"gc_in\", \"Fiber\", \"fiber_in\")]\n", " ports += [(f\"gc_out_{i}\", \"Fiber\", f\"fiber_out_{i:02d}\") for i in range(N_CLASSES)]\n", " if route_calibration:\n", " for layer in range(N_LAYERS):\n", " ports += [\n", " (f\"id_{layer}\", f\"W_PROBE{i:02d}\", f\"id{layer}_in_{i:02d}\")\n", " for i in range(LAYER_INPUT_COUNTS[layer])\n", " ]\n", " ports += [\n", " (f\"id_{layer}\", f\"E_PROBE{i:02d}\", f\"id{layer}_out_{i:02d}\")\n", " for i in range(LAYER_OUTPUT_COUNTS[layer])\n", " ]\n", " chip = pf.component_from_netlist(\n", " {\n", " \"name\": f\"deep_inverse_designed_pnn_{tag}\",\n", " \"instances\": instances,\n", " \"routes\": optical_routes(),\n", " \"terminal routes\": terminal_routes,\n", " \"terminals\": terminals,\n", " \"ports\": ports,\n", " \"models\": [(pf.CircuitModel(verbose=False), \"Circuit\")],\n", " \"active models\": {\"optical\": \"Circuit\"},\n", " }\n", " )\n", " # chip.add(\n", " # \"FloorPlan\",\n", " # pf.Rectangle(\n", " # corner1=(-500, -CHIP_WIDTH / 2), corner2=(CHIP_LENGTH - 500, CHIP_WIDTH / 2)\n", " # ),\n", " # )\n", " pf.set_unique_names(chip)\n", " chip.write_gds(LAYOUT_DIR / f\"deep_inverse_designed_pnn__{tag}.gds\")\n", " chip.write_oas(LAYOUT_DIR / f\"deep_inverse_designed_pnn__{tag}.oas\")\n", " return chip\n", "\n", "\n", "identity_responses = [\n", " np.eye(N_CHANNELS, dtype=complex),\n", " np.eye(N_CHANNELS, dtype=complex),\n", " np.eye(N_CHANNELS, dtype=complex)[np.asarray(FINAL_OUTPUT_INDICES)],\n", "]\n", "full_chip = build_chip(identity_responses, \"full_chip\")\n", "route_calibration_chip = build_chip(\n", " identity_responses, \"route_calibration\", route_calibration=True\n", ")\n", "display(full_chip)" ] }, { "cell_type": "code", "execution_count": 13, "id": "community-24", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "circuit: 7 splitters, 18 phase cells, 3 inverse-designed regions, 4 output fibers\n", "route response shapes: (3, 6) (4,)\n", "finite circuit response: True\n", "fixed routed power reference: 0.034648\n", "output fibers: 4 on 127.0 µm pitch\n" ] } ], "source": [ "def nested_model_types(component, seen=None):\n", " seen = set() if seen is None else seen\n", " if id(component) in seen:\n", " return []\n", " seen.add(id(component))\n", " model_types = [type(model).__name__ for model in component.models.values()]\n", " for reference in component.references:\n", " model_types.extend(nested_model_types(reference.component, seen))\n", " return model_types\n", "\n", "\n", "registered_model_types = nested_model_types(full_chip)\n", "netlist = full_chip.get_netlist()\n", "physical_netlist = full_chip.get_netlist(include_virtual_connections=False)\n", "virtual_links = netlist.get(\n", " \"virtual connections\", netlist.get(\"virtual_connections\", ())\n", ")\n", "layout_counts = {\n", " \"channels\": N_CHANNELS,\n", " \"classes\": N_CLASSES,\n", " \"splitter leaves\": N_SPLITTER_LEAVES,\n", " \"active splitter leaves\": list(ACTIVE_LEAF_INDICES),\n", " \"terminated splitter leaves\": list(DUMP_LEAF_INDICES),\n", " \"ideal active fanout power fraction\": IDEAL_ACTIVE_POWER_FRACTION,\n", " \"input gratings\": 1,\n", " \"output gratings\": N_CLASSES,\n", " \"layer input counts\": list(LAYER_INPUT_COUNTS),\n", " \"layer output counts\": list(LAYER_OUTPUT_COUNTS),\n", " \"splitters\": N_SPLITTER_LEAVES - 1,\n", " \"terminators\": len(DUMP_LEAF_INDICES),\n", " \"terminator model\": TERMINATOR_MODEL,\n", " \"terminator return loss dB at 1.55 um\": TERMINATOR_RETURN_LOSS_DB,\n", " \"phase cells\": N_LAYERS * N_CHANNELS,\n", " \"inverse-designed regions\": N_LAYERS,\n", " \"optical routes\": len(optical_routes()),\n", " \"electrical routes\": len(electrical_routes()[0]),\n", " \"bond pads\": len(electrical_routes()[1]),\n", " \"virtual links\": len(virtual_links),\n", " \"netlist instances\": len(netlist.get(\"instances\", {})),\n", " \"physical connections\": len(physical_netlist.get(\"connections\", ())),\n", " \"top-level optical ports\": len(full_chip.ports),\n", " \"top-level electrical terminals\": len(full_chip.terminals),\n", " \"component model types\": sorted(set(registered_model_types)),\n", " \"component Tidy3D models\": registered_model_types.count(\"Tidy3DModel\"),\n", " \"route radius um\": ROUTE_RADIUS,\n", " \"design edge um\": DESIGN_EDGE_UM,\n", "}\n", "print(\n", " f\"circuit: {layout_counts['splitters']} splitters, \"\n", " f\"{layout_counts['phase cells']} phase cells, \"\n", " f\"{layout_counts['inverse-designed regions']} inverse-designed regions, \"\n", " f\"{layout_counts['output gratings']} output fibers\"\n", ")\n", "\n", "\n", "def s_value(s_matrix, source, destination):\n", " candidates = (\n", " (f\"{source}@0\", f\"{destination}@0\"),\n", " (destination, source),\n", " (f\"{destination}@0\", f\"{source}@0\"),\n", " )\n", " key = next(key for key in candidates if key in s_matrix.elements)\n", " return complex(np.asarray(s_matrix.elements[key]).reshape(-1)[0])\n", "\n", "\n", "chip_s = route_calibration_chip.s_matrix([FREQ0_HZ], show_progress=False)\n", "route_inputs = np.asarray(\n", " [\n", " [\n", " s_value(\n", " chip_s,\n", " \"fiber_in\" if layer == 0 else f\"id{layer - 1}_out_{channel:02d}\",\n", " f\"id{layer}_in_{channel:02d}\",\n", " )\n", " for channel in range(N_CHANNELS)\n", " ]\n", " for layer in range(N_LAYERS)\n", " ]\n", ")\n", "route_output = np.asarray(\n", " [\n", " s_value(chip_s, f\"id{N_LAYERS - 1}_out_{output:02d}\", f\"fiber_out_{output:02d}\")\n", " for output in range(N_CLASSES)\n", " ]\n", ")\n", "route_loss_db = -20 * np.log10(np.maximum(np.abs(route_inputs), 1e-12))\n", "ROUTE_POWER_REFERENCE = float(\n", " np.prod(np.mean(np.abs(route_inputs) ** 2, axis=1))\n", " * np.mean(np.abs(route_output) ** 2)\n", ")\n", "print(\"route response shapes:\", route_inputs.shape, route_output.shape)\n", "print(\n", " \"finite circuit response:\",\n", " bool(np.isfinite(route_inputs).all() and np.isfinite(route_output).all()),\n", ")\n", "print(f\"fixed routed power reference: {ROUTE_POWER_REFERENCE:.6f}\")\n", "print(f\"output fibers: {N_CLASSES} on {OUTPUT_FIBER_PITCH:.1f} µm pitch\")" ] }, { "cell_type": "code", "execution_count": 14, "id": "community-layout-verification-code", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "layout checks: rule markers=0, route overlaps=0, electrical isolation=True\n" ] } ], "source": [ "route_gds = LAYOUT_DIR / \"deep_inverse_designed_pnn__full_chip.gds\"\n", "layout = kdb.Layout()\n", "layout.read(str(route_gds))\n", "top_cell = layout.top_cell()\n", "\n", "\n", "def layout_region(layer, datatype=0):\n", " return kdb.Region(top_cell.begin_shapes_rec(layout.layer(layer, datatype)))\n", "\n", "\n", "dbu = layout.dbu\n", "silicon_region = layout_region(1).merged()\n", "m1_region, m2_region = layout_region(11).merged(), layout_region(12).merged()\n", "mlopen_region = layout_region(13).merged()\n", "floorplan_region = layout_region(99).merged()\n", "optical_route_regions = []\n", "for instance in top_cell.each_inst():\n", " if instance.cell.name.startswith(\"route_s_bend__\") or instance.cell.name.startswith(\n", " \"route__\"\n", " ):\n", " region = kdb.Region(instance.cell.begin_shapes_rec(layout.layer(1, 0)))\n", " region.transform(instance.cplx_trans)\n", " optical_route_regions.append(region)\n", "optical_route_intersections = sum(\n", " not (first & second).is_empty()\n", " for index, first in enumerate(optical_route_regions)\n", " for second in optical_route_regions[index + 1 :]\n", ")\n", "tolerance = 0.002\n", "rule_checks = {\n", " \"merged Si width markers < 60 nm\": silicon_region.width_check(\n", " round((0.060 - tolerance) / dbu), False, kdb.Metrics.Euclidian, 80\n", " ).size(),\n", " \"merged Si spacing markers < 70 nm\": silicon_region.space_check(\n", " round((0.070 - tolerance) / dbu), False, kdb.Metrics.Euclidian, 80\n", " ).size(),\n", " \"Si outside floor plan\": (silicon_region - floorplan_region).count(),\n", " \"M1 width markers < 3 um\": m1_region.width_check(\n", " round((3.0 - tolerance) / dbu), False, kdb.Metrics.Euclidian, 70\n", " ).size(),\n", " \"M1 spacing markers < 3 um\": m1_region.space_check(\n", " round((3.0 - tolerance) / dbu)\n", " ).size(),\n", " \"M2 width markers < 5 um\": m2_region.width_check(\n", " round((5.0 - tolerance) / dbu), False, kdb.Metrics.Euclidian, 70\n", " ).size(),\n", " \"M2 spacing markers < 8 um\": m2_region.space_check(\n", " round((8.0 - tolerance) / dbu)\n", " ).size(),\n", " \"MLOpen width markers < 10 um\": mlopen_region.width_check(\n", " round((10.0 - tolerance) / dbu)\n", " ).size(),\n", " \"MLOpen spacing markers < 10 um\": mlopen_region.space_check(\n", " round((10.0 - tolerance) / dbu)\n", " ).size(),\n", "}\n", "expected_metal_components = 2 * N_LAYERS * N_CHANNELS\n", "interface_checks = {\n", " \"taper-mouth clearance um\": ID_PORT_PITCH - ID_TAPER_MOUTH,\n", " \"taper-to-region overlap um\": ID_TAPER_OVERLAP,\n", " \"pad M2 edge clearance um\": BOND_PAD_PITCH - BOND_PAD_SIZE,\n", " \"pad opening edge clearance um\": BOND_PAD_PITCH - BOND_PAD_OPEN_SIZE,\n", " \"pad-to-chip-edge clearance um\": (CHIP_WIDTH / 2 - BOND_PAD_Y - BOND_PAD_SIZE / 2),\n", " \"M1 connected components\": m1_region.count(),\n", " \"M2 connected components\": m2_region.count(),\n", " \"MLOpen connected components\": mlopen_region.count(),\n", " \"optical route-route intersections\": optical_route_intersections,\n", " \"electrical nets remain isolated\": bool(\n", " m1_region.count() == expected_metal_components\n", " and m2_region.count() == expected_metal_components\n", " and mlopen_region.count() == expected_metal_components\n", " ),\n", " \"optical routes remain separate\": bool(optical_route_intersections == 0),\n", " \"taper mouths do not touch\": bool(ID_PORT_PITCH - ID_TAPER_MOUTH > 0),\n", " \"tapers meet the fixed rail without intrusion\": bool(ID_TAPER_OVERLAP == 0),\n", "}\n", "electrical_terminal_names = [terminal[2] for terminal in electrical_routes()[1]]\n", "layout_verification = {\n", " \"KLayout rule screen\": rule_checks,\n", " \"custom interface and layer checks\": interface_checks,\n", " \"virtual links\": len(virtual_links),\n", " \"electrical terminals\": len(electrical_terminal_names),\n", " \"unique electrical terminals\": len(set(electrical_terminal_names)),\n", " \"active splitter leaves\": list(ACTIVE_LEAF_INDICES),\n", " \"terminated splitter leaves\": list(DUMP_LEAF_INDICES),\n", " \"all splitter leaves assigned\": len(ACTIVE_LEAF_INDICES) + len(DUMP_LEAF_INDICES)\n", " == N_SPLITTER_LEAVES,\n", " \"terminator return loss above 20 dB\": TERMINATOR_RETURN_LOSS_DB > 20.0,\n", " \"packaged DRC deck\": \"siepic_ebeam_pdk/drc/SiEPIC_EBeam_DRC.lydrc\",\n", "}\n", "print(\n", " \"layout checks:\",\n", " f\"rule markers={sum(rule_checks.values())}, \"\n", " f\"route overlaps={optical_route_intersections}, \"\n", " f\"electrical isolation={interface_checks['electrical nets remain isolated']}\",\n", ")" ] }, { "cell_type": "code", "execution_count": 15, "id": "community-25", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, axes = plt.subplots(1, 3, figsize=(11.2, 3.0), constrained_layout=True)\n", "for layer in range(N_LAYERS):\n", " axes[0].plot(\n", " np.arange(N_CHANNELS),\n", " np.abs(route_inputs[layer]),\n", " marker=\".\",\n", " label=f\"path {layer + 1}\",\n", " )\n", " axes[1].plot(\n", " np.arange(N_CHANNELS), np.unwrap(np.angle(route_inputs[layer])), marker=\".\"\n", " )\n", " centered = route_loss_db[layer] - route_loss_db[layer].mean()\n", " axes[2].plot(np.arange(N_CHANNELS), centered, marker=\".\")\n", "axes[0].set(xlabel=\"channel\", ylabel=\"amplitude\", title=\"Routed amplitude\")\n", "axes[1].set(xlabel=\"channel\", ylabel=\"phase (rad)\", title=\"Routed phase\")\n", "axes[2].set(\n", " xlabel=\"channel\",\n", " ylabel=\"loss relative to mean (dB)\",\n", " title=\"Propagation-loss spread\",\n", ")\n", "axes[0].legend(frameon=False)\n", "fig.suptitle(\n", " f\"{N_SPLITTER_LEAVES}-leaf fanout: active {ACTIVE_LEAF_INDICES}, \"\n", " f\"terminated {DUMP_LEAF_INDICES}, ideal active power {IDEAL_ACTIVE_POWER_FRACTION:.0%}\"\n", ")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "community-26", "metadata": {}, "source": [ "\n", "## Train the Optical Target\n", "\n", "Before optimizing the device geometry, we train the three optical transformations directly as complex matrices. Each matrix is written as\n", "\n", "$$\n", "M_\\ell=U_\\ell\\,\\operatorname{diag}(\\sigma_\\ell)\\,V_\\ell^\\dagger,\n", "$$\n", "\n", "where $U_\\ell$ and $V_\\ell$ are unitary matrices. We constrain each singular amplitude to\n", "\n", "$$\n", "10^{-6/20}\\leq \\sigma_{\\ell,j}\\leq10^{-3/20},\n", "$$\n", "\n", "which keeps every transformation passive and gives each singular channel an insertion loss between 3 and 6 dB.\n", "\n", "The detected powers are $p=|a_{\\mathrm{out}}|^2$, and the class logits are $\\gamma p/P_{\\mathrm{ref}}$, where $\\gamma$ is a learned positive scale. We minimize cross-entropy together with penalties on the optical margin, long-range channel coupling, and excessive $\\gamma$.\n", "\n", "During training, 16 perturbed copies of the three matrices are generated with 8–12% relative transmission error. This teaches the classifier to tolerate the difference between the target matrices and their later electromagnetic realizations.\n" ] }, { "cell_type": "code", "execution_count": 16, "id": "community-27", "metadata": {}, "outputs": [], "source": [ "def unitary(raw):\n", " return jax.scipy.linalg.expm(raw - jnp.conj(raw.T))\n", "\n", "\n", "def passive_matrix(left_raw, right_raw, singular_raw):\n", " left, right = unitary(left_raw), unitary(right_raw)\n", " singular = SIGMA_MIN + (SIGMA_MAX - SIGMA_MIN) * jax.nn.sigmoid(singular_raw)\n", " return left @ jnp.diag(singular.astype(jnp.complex64)) @ jnp.conj(right.T)\n", "\n", "\n", "batched_passive_matrix = jax.vmap(passive_matrix)\n", "\n", "\n", "def layer_matrices(params):\n", " left = params[\"left_re\"] + 1j * params[\"left_im\"]\n", " right = params[\"right_re\"] + 1j * params[\"right_im\"]\n", " return batched_passive_matrix(left, right, params[\"singular_raw\"])\n", "\n", "\n", "route_inputs_jax = jnp.asarray(route_inputs)\n", "route_output_jax = jnp.asarray(route_output)\n", "readout_slice = slice((N_CHANNELS - N_CLASSES) // 2, (N_CHANNELS + N_CLASSES) // 2)\n", "channel_rows, channel_columns = jnp.indices((N_CHANNELS, N_CHANNELS))\n", "normalized_channel_distance = jnp.abs(channel_rows - channel_columns) / (N_CHANNELS - 1)\n", "\n", "\n", "def optical_forward(matrices, features):\n", " phase = jnp.exp(1j * PHASE_SCALE * features)\n", " fields = jnp.ones_like(features, dtype=jnp.complex64)\n", " for layer in range(N_LAYERS):\n", " fields = fields * route_inputs_jax[layer] * phase\n", " fields = fields @ matrices[layer].T\n", " return fields[:, readout_slice] * route_output_jax\n", "\n", "\n", "def routing_transport(matrices):\n", " power = jnp.abs(matrices) ** 2\n", " layer_power = jnp.sum(power, axis=(1, 2))\n", " layer_cost = jnp.sum(\n", " power * normalized_channel_distance**2, axis=(1, 2)\n", " ) / jnp.maximum(layer_power, 1e-12)\n", " return jnp.mean(layer_cost)\n", "\n", "\n", "def routing_distance_statistics(matrices):\n", " power = np.abs(np.asarray(matrices)) ** 2\n", " distance = np.abs(np.arange(N_CHANNELS)[:, None] - np.arange(N_CHANNELS)[None, :])\n", " layer_power = power.sum(axis=(1, 2))\n", " mean_distance = (power * distance).sum(axis=(1, 2)) / layer_power\n", " rms_distance = np.sqrt((power * distance**2).sum(axis=(1, 2)) / layer_power)\n", " percentile_90 = []\n", " for layer_power_map in power:\n", " weights = np.bincount(\n", " distance.ravel(), weights=layer_power_map.ravel(), minlength=N_CHANNELS\n", " )\n", " percentile_90.append(np.searchsorted(np.cumsum(weights) / weights.sum(), 0.9))\n", " return mean_distance, rms_distance, np.asarray(percentile_90)\n", "\n", "\n", "def logits_and_scores(params, features):\n", " matrices = layer_matrices(params)\n", " intensities = jnp.abs(optical_forward(matrices, features)) ** 2\n", " scores = intensities\n", " gamma = jnp.exp(params[\"log_gamma\"])\n", " return gamma * scores / ROUTE_POWER_REFERENCE, scores, matrices, gamma\n", "\n", "\n", "def initialize_parameters(key):\n", " keys = jax.random.split(key, 4)\n", " shape = (N_LAYERS, N_CHANNELS, N_CHANNELS)\n", " return {\n", " \"left_re\": 1e-2 * jax.random.normal(keys[0], shape),\n", " \"left_im\": 1e-2 * jax.random.normal(keys[1], shape),\n", " \"right_re\": 1e-2 * jax.random.normal(keys[2], shape),\n", " \"right_im\": 1e-2 * jax.random.normal(keys[3], shape),\n", " \"singular_raw\": jnp.full((N_LAYERS, N_CHANNELS), 3.0),\n", " \"log_gamma\": jnp.asarray(np.log(10.0), dtype=jnp.float32),\n", " }\n", "\n", "\n", "def host_tree(tree):\n", " return jax.tree.map(lambda value: np.asarray(value), tree)\n", "\n", "\n", "@jax.jit\n", "def evaluate(params, features, labels):\n", " logits, _, matrices, gamma = logits_and_scores(params, features)\n", " loss = optax.softmax_cross_entropy_with_integer_labels(logits, labels).mean()\n", " accuracy = jnp.mean(jnp.argmax(logits, axis=-1) == labels)\n", " return loss, accuracy, routing_transport(matrices), gamma" ] }, { "cell_type": "code", "execution_count": 17, "id": "community-robust-perturbations", "metadata": {}, "outputs": [], "source": [ "def adjacent_unitary(angles, phases):\n", " unitary_matrix = jnp.eye(N_CHANNELS, dtype=jnp.complex128)\n", " for offset in (0, 1):\n", " for channel in range(offset, N_CHANNELS - 1, 2):\n", " first_row = unitary_matrix[channel]\n", " second_row = unitary_matrix[channel + 1]\n", " cosine, sine = jnp.cos(angles[channel]), jnp.sin(angles[channel])\n", " phase = jnp.exp(1j * phases[channel])\n", " unitary_matrix = unitary_matrix.at[channel].set(\n", " cosine * first_row + phase * sine * second_row\n", " )\n", " unitary_matrix = unitary_matrix.at[channel + 1].set(\n", " -jnp.conj(phase) * sine * first_row + cosine * second_row\n", " )\n", " return unitary_matrix\n", "\n", "\n", "def sample_layer_perturbation(key):\n", " keys = jax.random.split(key, 8)\n", " return {\n", " \"input_loss\": jax.random.normal(keys[0], (N_CHANNELS,)),\n", " \"output_loss\": jax.random.normal(keys[1], (N_CHANNELS,)),\n", " \"input_phase\": jax.random.normal(keys[2], (N_CHANNELS,)),\n", " \"output_phase\": jax.random.normal(keys[3], (N_CHANNELS,)),\n", " \"input_angles\": jax.random.normal(keys[4], (N_CHANNELS - 1,)),\n", " \"output_angles\": jax.random.normal(keys[5], (N_CHANNELS - 1,)),\n", " \"input_mixing_phase\": jax.random.normal(keys[6], (N_CHANNELS - 1,)),\n", " \"output_mixing_phase\": jax.random.normal(keys[7], (N_CHANNELS - 1,)),\n", " }\n", "\n", "\n", "def structured_perturb_layer(matrix, perturbation, target_error, pair_sign):\n", " input_loss = jax.nn.sigmoid(pair_sign * perturbation[\"input_loss\"])\n", " output_loss = jax.nn.sigmoid(pair_sign * perturbation[\"output_loss\"])\n", " input_phase = 0.15 * pair_sign * perturbation[\"input_phase\"]\n", " output_phase = 0.15 * pair_sign * perturbation[\"output_phase\"]\n", " input_phase = input_phase - jnp.mean(input_phase)\n", " output_phase = output_phase - jnp.mean(output_phase)\n", " input_angles = 0.05 * pair_sign * perturbation[\"input_angles\"]\n", " output_angles = 0.05 * pair_sign * perturbation[\"output_angles\"]\n", " input_mixing_phase = jnp.pi * jnp.tanh(\n", " pair_sign * perturbation[\"input_mixing_phase\"]\n", " )\n", " output_mixing_phase = jnp.pi * jnp.tanh(\n", " pair_sign * perturbation[\"output_mixing_phase\"]\n", " )\n", " input_diagonal = 10 ** (-input_loss / 20) * jnp.exp(1j * input_phase)\n", " output_diagonal = 10 ** (-output_loss / 20) * jnp.exp(1j * output_phase)\n", " input_mixing = adjacent_unitary(input_angles, input_mixing_phase)\n", " output_mixing = adjacent_unitary(output_angles, output_mixing_phase)\n", " full_matrix = output_diagonal[:, None] * (output_mixing @ matrix @ input_mixing)\n", " full_matrix = full_matrix * input_diagonal[None, :]\n", " difference = full_matrix - matrix\n", " matrix_norm = jnp.maximum(jnp.linalg.norm(matrix), 1e-12)\n", " full_error = jnp.linalg.norm(difference) / matrix_norm\n", " interpolation = jnp.minimum(1.0, target_error / jnp.maximum(full_error, 1e-12))\n", " perturbed = matrix + interpolation * difference\n", " actual_error = jnp.linalg.norm(perturbed - matrix) / matrix_norm\n", " return perturbed, actual_error\n", "\n", "\n", "def sample_chip_perturbation(key):\n", " return jax.vmap(sample_layer_perturbation)(jax.random.split(key, N_LAYERS))\n", "\n", "\n", "def perturb_chip(matrices, perturbations, target_errors, pair_sign):\n", " return jax.vmap(structured_perturb_layer, in_axes=(0, 0, 0, None))(\n", " matrices, perturbations, target_errors, pair_sign\n", " )\n", "\n", "\n", "def perturb_replicas(matrices, perturbations, target_errors, pair_signs):\n", " return jax.vmap(perturb_chip, in_axes=(None, 0, 0, 0))(\n", " matrices, perturbations, target_errors, pair_signs\n", " )\n", "\n", "\n", "def optical_scores(matrices, features):\n", " return jnp.abs(optical_forward(matrices, features)) ** 2\n", "\n", "\n", "def normalized_optical_margin(scores, labels):\n", " label_mask = jax.nn.one_hot(labels, N_CLASSES, dtype=scores.dtype)\n", " label_mask = label_mask.reshape((1,) * (scores.ndim - 2) + label_mask.shape)\n", " correct = jnp.sum(scores * label_mask, axis=-1)\n", " competitor = jnp.max(jnp.where(label_mask.astype(bool), -jnp.inf, scores), axis=-1)\n", " return (correct - competitor) / (jnp.sum(scores, axis=-1) + 1e-12)" ] }, { "cell_type": "code", "execution_count": 18, "id": "deep-robust-objective", "metadata": {}, "outputs": [], "source": [ "def robust_objective(params, key, features, labels):\n", " matrices = layer_matrices(params)\n", " clean_scores = optical_scores(matrices, features)\n", " gamma = jnp.exp(params[\"log_gamma\"])\n", " clean_logits = gamma * clean_scores / ROUTE_POWER_REFERENCE\n", " clean_loss = optax.softmax_cross_entropy_with_integer_labels(\n", " clean_logits, labels\n", " ).mean()\n", "\n", " structure_key, error_key = jax.random.split(key)\n", " perturbations = jax.vmap(sample_chip_perturbation)(\n", " jax.random.split(structure_key, ROBUST_REPLICAS)\n", " )\n", " pair_signs = jnp.ones((ROBUST_REPLICAS,))\n", " target_errors = jax.random.uniform(\n", " error_key,\n", " (ROBUST_REPLICAS, N_LAYERS),\n", " minval=ROBUST_WINDOW_MIN,\n", " maxval=ROBUST_WINDOW_MAX,\n", " )\n", " perturbed_matrices, actual_errors = perturb_replicas(\n", " matrices, perturbations, target_errors, pair_signs\n", " )\n", " perturbed_scores = jax.vmap(lambda values: optical_scores(values, features))(\n", " perturbed_matrices\n", " )\n", " perturbed_logits = gamma * perturbed_scores / ROUTE_POWER_REFERENCE\n", " replica_labels = jnp.broadcast_to(labels, (ROBUST_REPLICAS, labels.shape[0]))\n", " perturbed_losses = optax.softmax_cross_entropy_with_integer_labels(\n", " perturbed_logits, replica_labels\n", " ).mean(axis=1)\n", " perturbed_accuracies = jnp.mean(\n", " jnp.argmax(perturbed_scores, axis=-1) == replica_labels, axis=1\n", " )\n", " margins = normalized_optical_margin(perturbed_scores, labels)\n", " margin_penalty = jnp.maximum(ROBUST_MARGIN_TARGET - margins, 0).mean()\n", "\n", " gamma_term = GAMMA_WEIGHT * jnp.square(\n", " jnp.maximum(gamma - GAMMA_TARGET, 0.0) / GAMMA_TARGET\n", " )\n", " mean_perturbed_loss = jnp.mean(perturbed_losses)\n", " loss = (\n", " 0.35 * clean_loss\n", " + 0.65 * mean_perturbed_loss\n", " + ROBUST_MARGIN_WEIGHT * margin_penalty\n", " + routing_transport(matrices)\n", " + gamma_term\n", " )\n", " clean_accuracy = jnp.mean(jnp.argmax(clean_scores, axis=-1) == labels)\n", " metrics = jnp.asarray(\n", " (\n", " clean_loss,\n", " mean_perturbed_loss,\n", " margin_penalty,\n", " clean_accuracy,\n", " jnp.mean(perturbed_accuracies),\n", " jnp.min(perturbed_accuracies),\n", " jnp.mean(actual_errors),\n", " )\n", " )\n", " return loss, metrics\n", "\n", "\n", "robust_steps = ROBUST_EPOCHS * int(np.ceil(len(train_features) / ROBUST_BATCH_SIZE))\n", "robust_schedule = optax.cosine_decay_schedule(ROBUST_LR, robust_steps, alpha=0.1)\n", "robust_optimizer = optax.adam(robust_schedule)\n", "\n", "\n", "@jax.jit\n", "def robust_update(params, optimizer_state, key, features, labels):\n", " (loss, metrics), gradients = jax.value_and_grad(robust_objective, has_aux=True)(\n", " params, key, features, labels\n", " )\n", " updates, optimizer_state = robust_optimizer.update(\n", " gradients, optimizer_state, params\n", " )\n", " return optax.apply_updates(params, updates), optimizer_state, loss, metrics" ] }, { "cell_type": "code", "execution_count": 19, "id": "deep-robust-evaluation", "metadata": {}, "outputs": [], "source": [ "def perturbation_batch_metrics(params, features, labels, keys, target_errors):\n", " matrices = layer_matrices(params)\n", " perturbations = jax.vmap(sample_chip_perturbation)(keys)\n", " pair_signs = jnp.ones((len(keys),))\n", " perturbed_matrices, actual_errors = perturb_replicas(\n", " matrices, perturbations, target_errors, pair_signs\n", " )\n", " scores = jax.vmap(lambda values: optical_scores(values, features))(\n", " perturbed_matrices\n", " )\n", " replica_labels = jnp.broadcast_to(labels, (len(keys), labels.shape[0]))\n", " accuracies = jnp.mean(jnp.argmax(scores, axis=-1) == replica_labels, axis=1)\n", " mean_margins = jnp.mean(normalized_optical_margin(scores, labels), axis=1)\n", " maximum_singular = jnp.max(\n", " jnp.linalg.svd(perturbed_matrices, compute_uv=False), axis=(1, 2)\n", " )\n", " return accuracies, mean_margins, jnp.mean(actual_errors, axis=1), maximum_singular\n", "\n", "\n", "def evaluate_perturbation_bank(\n", " params, features, labels, keys, severities, chunk_size=8\n", "):\n", " feature_array, label_array = jnp.asarray(features), jnp.asarray(labels)\n", " severities = np.asarray(severities, dtype=float)\n", " target_errors = (\n", " np.repeat(severities[:, None], N_LAYERS, axis=1)\n", " if severities.ndim == 1\n", " else severities\n", " )\n", " collected = [[], [], [], []]\n", " for start in range(0, len(keys), chunk_size):\n", " stop = min(start + chunk_size, len(keys))\n", " values = perturbation_batch_metrics(\n", " params,\n", " feature_array,\n", " label_array,\n", " jnp.asarray(keys[start:stop]),\n", " jnp.asarray(target_errors[start:stop]),\n", " )\n", " for destination, value in zip(collected, values):\n", " destination.append(np.asarray(value))\n", " accuracy, margin, actual_error, maximum_singular = (\n", " np.concatenate(values) for values in collected\n", " )\n", " return {\n", " \"accuracy\": accuracy,\n", " \"margin\": margin,\n", " \"actual_error\": actual_error,\n", " \"maximum_singular\": maximum_singular,\n", " }\n", "\n", "\n", "def fixed_error_bank(seed, size, minimum, maximum):\n", " rng = np.random.default_rng(seed)\n", " severities = rng.uniform(minimum, maximum, (size, N_LAYERS))\n", " keys = np.asarray(jax.random.split(jax.random.PRNGKey(seed), size))\n", " return keys, severities\n", "\n", "\n", "validation_keys, validation_severities = fixed_error_bank(\n", " SEED + 1_000, ROBUST_VALIDATION_SAMPLES, ROBUST_WINDOW_MIN, ROBUST_WINDOW_MAX\n", ")\n", "audit_keys, audit_severities = fixed_error_bank(\n", " SEED + 2_000, ROBUST_AUDIT_SAMPLES, ROBUST_WINDOW_MIN, ROBUST_WINDOW_MAX\n", ")\n", "exact_keys, exact_severities = fixed_error_bank(\n", " SEED + 3_000, ROBUST_AUDIT_SAMPLES, ROBUST_TARGET_ERROR, ROBUST_TARGET_ERROR\n", ")\n", "\n", "\n", "def save_repeated_checkpoint(state):\n", " temporary_path = REPEATED_CHECKPOINT_PATH.with_suffix(\".tmp\")\n", " with temporary_path.open(\"wb\") as handle:\n", " pickle.dump(state, handle, protocol=pickle.HIGHEST_PROTOCOL)\n", " temporary_path.replace(REPEATED_CHECKPOINT_PATH)" ] }, { "cell_type": "code", "execution_count": 20, "id": "community-robust-training", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "loaded N=6 trained matrices at epoch 300\n", "selected trained matrices: N=6, seed 17, epoch 290; 8-12% mean validation accuracy 89.636%\n", "physical target shapes: [(6, 6), (6, 6), (4, 6)]\n", "maximum rectangular-target field difference: 0.0\n" ] } ], "source": [ "def validate_repeated_checkpoint(state):\n", " expected_shape = (N_LAYERS, N_CHANNELS, N_CHANNELS)\n", " actual_shape = np.asarray(state[\"params\"][\"left_re\"]).shape\n", " if actual_shape != expected_shape:\n", " raise ValueError(\n", " f\"Surrogate checkpoint shape {actual_shape} does not match {expected_shape}.\"\n", " )\n", " configuration = state.get(\"configuration\")\n", " if configuration is None:\n", " raise ValueError(\"Checkpoint is missing preprocessing metadata.\")\n", " if configuration != MATRIX_TRAINING_CONFIGURATION:\n", " raise ValueError(\n", " f\"Surrogate checkpoint configuration {configuration} does not match \"\n", " f\"{MATRIX_TRAINING_CONFIGURATION}.\"\n", " )\n", "\n", "\n", "training_rng = np.random.default_rng(MATRIX_TRAINING_SEED)\n", "if REPEATED_CHECKPOINT_PATH.exists():\n", " with REPEATED_CHECKPOINT_PATH.open(\"rb\") as handle:\n", " run = pickle.load(handle)\n", " validate_repeated_checkpoint(run)\n", " training_rng.bit_generator.state = run[\"rng_state\"]\n", " print(f\"loaded N={N_CHANNELS} trained matrices at epoch {run['completed_epoch']}\")\n", "else:\n", " initial_params = host_tree(\n", " initialize_parameters(jax.random.PRNGKey(MATRIX_TRAINING_SEED))\n", " )\n", " run = {\n", " \"params\": initial_params,\n", " \"optimizer_state\": host_tree(robust_optimizer.init(initial_params)),\n", " \"jax_key\": np.asarray(jax.random.PRNGKey(MATRIX_TRAINING_SEED + 10_000)),\n", " \"rng_state\": training_rng.bit_generator.state,\n", " \"history\": [],\n", " \"best_score\": -np.inf,\n", " \"best_clean_accuracy\": -np.inf,\n", " \"best_params\": initial_params,\n", " \"best_epoch\": 0,\n", " \"completed_epoch\": 0,\n", " \"seed\": MATRIX_TRAINING_SEED,\n", " \"configuration\": MATRIX_TRAINING_CONFIGURATION,\n", " }\n", "\n", "training_params = run[\"params\"]\n", "training_optimizer_state = run[\"optimizer_state\"]\n", "training_key = jnp.asarray(run[\"jax_key\"])\n", "training_history = list(run[\"history\"])\n", "best_score = run[\"best_score\"]\n", "best_clean_accuracy = run[\"best_clean_accuracy\"]\n", "best_params = run[\"best_params\"]\n", "best_epoch = run[\"best_epoch\"]\n", "completed_epoch = run[\"completed_epoch\"]\n", "\n", "for epoch in range(completed_epoch + 1, ROBUST_EPOCHS + 1):\n", " epoch_metrics, epoch_sizes = [], []\n", " epoch_indices = training_rng.permutation(len(train_features))\n", " for start in range(0, len(train_features), ROBUST_BATCH_SIZE):\n", " indices = epoch_indices[start : start + ROBUST_BATCH_SIZE]\n", " training_key, batch_key = jax.random.split(training_key)\n", " training_params, training_optimizer_state, batch_loss, batch_metrics = (\n", " robust_update(\n", " training_params,\n", " training_optimizer_state,\n", " batch_key,\n", " jnp.asarray(train_features[indices]),\n", " jnp.asarray(train_labels[indices]),\n", " )\n", " )\n", " epoch_metrics.append(\n", " np.concatenate(([float(batch_loss)], np.asarray(batch_metrics)))\n", " )\n", " epoch_sizes.append(len(indices))\n", " training_metrics = np.average(np.vstack(epoch_metrics), axis=0, weights=epoch_sizes)\n", "\n", " validation_metrics = np.full(4, np.nan)\n", " if epoch % ROBUST_VALIDATION_INTERVAL == 0 or epoch == ROBUST_EPOCHS:\n", " _, clean_accuracy, _, _ = evaluate(\n", " training_params, jnp.asarray(val_features), jnp.asarray(val_labels)\n", " )\n", " perturbed_validation = evaluate_perturbation_bank(\n", " training_params,\n", " val_features,\n", " val_labels,\n", " validation_keys,\n", " validation_severities,\n", " )\n", " mean_accuracy = float(np.mean(perturbed_validation[\"accuracy\"]))\n", " fifth_accuracy = float(np.quantile(perturbed_validation[\"accuracy\"], 0.05))\n", " mean_margin = float(np.mean(perturbed_validation[\"margin\"]))\n", " validation_metrics = np.asarray(\n", " (float(clean_accuracy), mean_accuracy, fifth_accuracy, mean_margin)\n", " )\n", " if (\n", " float(clean_accuracy) >= MIN_SELECTION_ACCURACY\n", " and mean_accuracy > best_score\n", " ):\n", " best_score = mean_accuracy\n", " best_clean_accuracy = float(clean_accuracy)\n", " best_params = host_tree(training_params)\n", " best_epoch = epoch\n", " print(\n", " f\"epoch {epoch:4d}: clean={float(clean_accuracy):.3%}, \"\n", " f\"8-12% mean={mean_accuracy:.3%}\"\n", " )\n", "\n", " training_history.append(\n", " tuple(np.concatenate((training_metrics, validation_metrics)))\n", " )\n", " completed_epoch = epoch\n", " run = {\n", " \"params\": host_tree(training_params),\n", " \"optimizer_state\": host_tree(training_optimizer_state),\n", " \"jax_key\": np.asarray(training_key),\n", " \"rng_state\": training_rng.bit_generator.state,\n", " \"history\": training_history,\n", " \"best_score\": best_score,\n", " \"best_clean_accuracy\": best_clean_accuracy,\n", " \"best_params\": host_tree(best_params),\n", " \"best_epoch\": best_epoch,\n", " \"completed_epoch\": completed_epoch,\n", " \"seed\": MATRIX_TRAINING_SEED,\n", " \"configuration\": MATRIX_TRAINING_CONFIGURATION,\n", " }\n", " save_repeated_checkpoint(run)\n", "\n", "params = best_params\n", "trained_matrices = np.asarray(layer_matrices(params))\n", "print(\n", " f\"selected trained matrices: N={N_CHANNELS}, seed {MATRIX_TRAINING_SEED}, epoch {best_epoch}; \"\n", " f\"8-12% mean validation accuracy {best_score:.3%}\"\n", ")\n", "\n", "\n", "REALIZATION_TARGETS = (\n", " trained_matrices[0],\n", " trained_matrices[1],\n", " trained_matrices[2, np.asarray(FINAL_OUTPUT_INDICES), :],\n", ")\n", "print(\"physical target shapes:\", [target.shape for target in REALIZATION_TARGETS])\n", "\n", "\n", "def physical_forward(matrices, features):\n", " phase = jnp.exp(1j * PHASE_SCALE * features)\n", " fields = jnp.ones_like(features, dtype=jnp.complex64)\n", " for layer in range(N_LAYERS):\n", " fields = fields * route_inputs_jax[layer] * phase\n", " fields = fields @ jnp.asarray(matrices[layer]).T\n", " return fields * route_output_jax\n", "\n", "\n", "square_target_fields = optical_forward(\n", " jnp.asarray(trained_matrices), jnp.asarray(test_features)\n", ")\n", "rectangular_target_fields = physical_forward(\n", " REALIZATION_TARGETS, jnp.asarray(test_features)\n", ")\n", "rectangular_target_error = float(\n", " np.max(\n", " np.abs(np.asarray(square_target_fields) - np.asarray(rectangular_target_fields))\n", " )\n", ")\n", "if rectangular_target_error > 1e-10:\n", " raise ValueError(\"The 6-input/4-output target changed the trained detector fields.\")\n", "print(\"maximum rectangular-target field difference:\", rectangular_target_error)" ] }, { "cell_type": "code", "execution_count": 21, "id": "community-robust-results", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "trained target: accuracy=90.52%, cross-entropy=0.270203, 10% perturbation mean=89.12%, fifth percentile=87.65%\n", "matrix-training requirement for a cost estimate: satisfied\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "test_loss, test_accuracy, test_transport, trained_gamma = evaluate(\n", " params, jnp.asarray(test_features), jnp.asarray(test_labels)\n", ")\n", "singular_amplitudes = np.linalg.svd(trained_matrices, compute_uv=False)\n", "mean_distance, rms_distance, percentile_90_distance = routing_distance_statistics(\n", " trained_matrices\n", ")\n", "selected_validation = evaluate_perturbation_bank(\n", " params, val_features, val_labels, validation_keys, validation_severities\n", ")\n", "selected_audit = evaluate_perturbation_bank(\n", " params, test_features, test_labels, audit_keys, audit_severities\n", ")\n", "selected_exact = evaluate_perturbation_bank(\n", " params, test_features, test_labels, exact_keys, exact_severities\n", ")\n", "selected_validation_mean = float(np.mean(selected_validation[\"accuracy\"]))\n", "selected_validation_fifth = float(np.quantile(selected_validation[\"accuracy\"], 0.05))\n", "selected_audit_mean = float(np.mean(selected_audit[\"accuracy\"]))\n", "selected_audit_fifth = float(np.quantile(selected_audit[\"accuracy\"], 0.05))\n", "selected_exact_mean = float(np.mean(selected_exact[\"accuracy\"]))\n", "selected_exact_fifth = float(np.quantile(selected_exact[\"accuracy\"], 0.05))\n", "matrix_training_metrics = {\n", " \"test accuracy\": float(test_accuracy),\n", " \"test cross-entropy\": float(test_loss),\n", " \"routing transport cost\": float(test_transport),\n", " \"mean coupling distance by layer\": mean_distance.tolist(),\n", " \"rms coupling distance by layer\": rms_distance.tolist(),\n", " \"90th-percentile coupling distance by layer\": percentile_90_distance.tolist(),\n", " \"training-only inverse temperature\": float(trained_gamma),\n", " \"minimum singular amplitude\": float(singular_amplitudes.min()),\n", " \"maximum singular amplitude\": float(singular_amplitudes.max()),\n", " \"validation mean over 8-12%\": selected_validation_mean,\n", " \"validation fifth percentile over 8-12%\": selected_validation_fifth,\n", " \"test mean over 8-12%\": selected_audit_mean,\n", " \"test fifth percentile over 8-12%\": selected_audit_fifth,\n", " \"test mean at 10%\": selected_exact_mean,\n", " \"test fifth percentile at 10%\": selected_exact_fifth,\n", " \"selected seed\": MATRIX_TRAINING_SEED,\n", " \"selected epoch\": best_epoch,\n", " \"selection clean-accuracy floor\": MIN_SELECTION_ACCURACY,\n", " \"92% mean-accuracy target reached\": selected_exact_mean\n", " >= ROBUST_TARGET_MEAN_ACCURACY,\n", "}\n", "performance_ready = (\n", " best_epoch > 0\n", " and float(test_accuracy) > 1 / N_CLASSES\n", " and selected_exact_mean > 1 / N_CLASSES\n", ")\n", "matrix_training_ready = (\n", " performance_ready\n", " and np.isfinite(float(test_transport))\n", " and singular_amplitudes.min() >= SIGMA_MIN - 1e-5\n", " and singular_amplitudes.max() <= SIGMA_MAX + 1e-5\n", ")\n", "np.savez_compressed(\n", " CHECKPOINT_DIR / \"repeated_encoding__trained_matrices.npz\",\n", " matrices=trained_matrices,\n", " history=np.asarray(training_history),\n", ")\n", "print(\n", " f\"trained target: accuracy={test_accuracy:.2%}, \"\n", " f\"cross-entropy={test_loss:.6f}, \"\n", " f\"10% perturbation mean={selected_exact_mean:.2%}, \"\n", " f\"fifth percentile={selected_exact_fifth:.2%}\"\n", ")\n", "print(\n", " \"matrix-training requirement for a cost estimate:\",\n", " \"satisfied\" if matrix_training_ready else \"not satisfied\",\n", ")\n", "\n", "history_array = np.asarray(training_history, dtype=float)\n", "epochs = np.arange(1, len(history_array) + 1)\n", "validation_mask = np.isfinite(history_array[:, 8])\n", "fig, axes = plt.subplots(2, 2, figsize=(9.0, 6.0), constrained_layout=True)\n", "axes[0, 0].plot(epochs, history_array[:, 0])\n", "axes[0, 1].plot(epochs, 100 * history_array[:, 4], label=\"clean training\")\n", "axes[0, 1].plot(epochs, 100 * history_array[:, 5], label=\"perturbed mean\")\n", "axes[1, 0].plot(\n", " epochs[validation_mask], 100 * history_array[validation_mask, 9], label=\"mean\"\n", ")\n", "axes[1, 0].plot(\n", " epochs[validation_mask],\n", " 100 * history_array[validation_mask, 10],\n", " label=\"fifth percentile\",\n", ")\n", "axes[1, 1].plot(epochs, 100 * history_array[:, 7])\n", "axes[0, 0].set(xlabel=\"epoch\", ylabel=\"objective\", title=\"Robust objective\")\n", "axes[0, 1].set(xlabel=\"epoch\", ylabel=\"accuracy (%)\", title=\"Online accuracy\")\n", "axes[1, 0].set(\n", " xlabel=\"epoch\", ylabel=\"accuracy (%)\", title=\"Validation over 8-12% error\"\n", ")\n", "axes[1, 1].set(\n", " xlabel=\"epoch\", ylabel=\"relative error (%)\", title=\"Sampled transmission error\"\n", ")\n", "axes[0, 1].legend(frameon=False)\n", "axes[1, 0].legend(frameon=False)\n", "fig.savefig(FIGURE_DIR / \"repeated_encoding_training.png\", dpi=180, bbox_inches=\"tight\")\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 22, "id": "community-robust-robustness-plot", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "robustness_levels = np.asarray((0.00, 0.03, 0.06, 0.09, 0.12, 0.15, 0.20))\n", "robustness_keys = np.asarray(jax.random.split(jax.random.PRNGKey(SEED + 2_000), 100))\n", "robustness_curve = []\n", "for error_level in robustness_levels:\n", " severities = np.full(len(robustness_keys), error_level)\n", " robustness_curve.append(\n", " evaluate_perturbation_bank(\n", " params,\n", " test_features,\n", " test_labels,\n", " robustness_keys,\n", " severities,\n", " chunk_size=10,\n", " )\n", " )\n", "\n", "actual_error = np.asarray(\n", " [np.median(values[\"actual_error\"]) for values in robustness_curve]\n", ")\n", "median_accuracy = np.asarray(\n", " [np.median(values[\"accuracy\"]) for values in robustness_curve]\n", ")\n", "lower_accuracy = np.asarray(\n", " [np.quantile(values[\"accuracy\"], 0.05) for values in robustness_curve]\n", ")\n", "upper_accuracy = np.asarray(\n", " [np.quantile(values[\"accuracy\"], 0.95) for values in robustness_curve]\n", ")\n", "fig, axes = plt.subplots(1, 2, figsize=(9.4, 3.8), constrained_layout=True)\n", "axes[0].plot(100 * actual_error, 100 * median_accuracy, marker=\"o\")\n", "axes[0].fill_between(\n", " 100 * actual_error, 100 * lower_accuracy, 100 * upper_accuracy, alpha=0.18\n", ")\n", "axes[0].set(\n", " xlabel=\"actual relative transmission error (%)\",\n", " ylabel=\"test accuracy (%)\",\n", " title=\"Accuracy under matrix error\",\n", ")\n", "axes[1].boxplot(\n", " (robustness_curve[0][\"margin\"], robustness_curve[5][\"margin\"]),\n", " tick_labels=(\"nominal\", \"15% error\"),\n", " showfliers=False,\n", ")\n", "axes[1].axhline(\n", " ROBUST_MARGIN_TARGET, color=\"black\", linestyle=\":\", label=\"training target\"\n", ")\n", "axes[1].set(ylabel=\"mean normalized optical margin\", title=\"Optical decision margin\")\n", "axes[1].legend(frameon=False)\n", "fig.savefig(\n", " FIGURE_DIR / \"repeated_encoding_matrix_error.png\", dpi=180, bbox_inches=\"tight\"\n", ")\n", "plt.show()\n", "\n", "fig, ax = plt.subplots(figsize=(6.2, 3.0), constrained_layout=True)\n", "for layer in range(N_LAYERS):\n", " ax.plot(\n", " np.arange(1, N_CHANNELS + 1),\n", " singular_amplitudes[layer],\n", " marker=\".\",\n", " label=f\"layer {layer + 1}\",\n", " )\n", "ax.axhline(SIGMA_MIN, color=\"black\", linestyle=\":\", label=\"6 dB bound\")\n", "ax.axhline(SIGMA_MAX, color=\"black\", linestyle=\"--\", label=\"3 dB bound\")\n", "ax.set(\n", " xlabel=\"singular channel\",\n", " ylabel=\"singular amplitude\",\n", " title=\"Trained target matrices\",\n", ")\n", "ax.legend(frameon=False, ncol=2)\n", "fig.savefig(\n", " FIGURE_DIR / \"repeated_encoding_singular_amplitudes.png\",\n", " dpi=180,\n", " bbox_inches=\"tight\",\n", ")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "encoding-baseline", "metadata": {}, "source": [ "\n", "## Compare Single and Repeated Encoding\n", "\n", "To isolate the effect of re-encoding, we train a second classifier that applies the image phase only at the input. Its optical mapping is\n", "\n", "$$\n", "a_{\\mathrm{single}}\n", "=\n", "M_3M_2M_1D(z)a_{\\mathrm{in}},\n", "$$\n", "\n", "whereas repeated encoding gives\n", "\n", "$$\n", "a_{\\mathrm{repeated}}\n", "=\n", "M_3D(z)M_2D(z)M_1D(z)a_{\\mathrm{in}}.\n", "$$\n", "\n", "Both classifiers use three passive matrices, the same data split, initialization seeds, readout, perturbation levels, and training procedure. The comparison therefore changes only the position and number of phase encoders.\n", "\n", "We compare their clean and perturbed classification results. The matrices from the repeated-encoding model are then used as fixed transmission targets for three silicon photonic devices optimized using Tidy3D.\n" ] }, { "cell_type": "code", "execution_count": 23, "id": "encoding-baseline-functions", "metadata": {}, "outputs": [], "source": [ "def single_encoding_forward(matrices, features):\n", " fields = jnp.ones_like(features, dtype=jnp.complex64)\n", " image_phase = jnp.exp(1j * PHASE_SCALE * features)\n", " for layer in range(N_LAYERS):\n", " fields = fields * route_inputs_jax[layer]\n", " if layer == 0:\n", " fields = fields * image_phase\n", " fields = fields @ matrices[layer].T\n", " return fields[:, readout_slice] * route_output_jax\n", "\n", "\n", "def single_encoding_scores(matrices, features):\n", " return jnp.abs(single_encoding_forward(matrices, features)) ** 2\n", "\n", "\n", "def single_encoding_objective(parameters, key, features, labels):\n", " matrices = layer_matrices(parameters)\n", " clean_scores = single_encoding_scores(matrices, features)\n", " gamma = jnp.exp(parameters[\"log_gamma\"])\n", " clean_logits = gamma * clean_scores / ROUTE_POWER_REFERENCE\n", " clean_loss = optax.softmax_cross_entropy_with_integer_labels(\n", " clean_logits, labels\n", " ).mean()\n", "\n", " structure_key, error_key = jax.random.split(key)\n", " perturbations = jax.vmap(sample_chip_perturbation)(\n", " jax.random.split(structure_key, ROBUST_REPLICAS)\n", " )\n", " target_errors = jax.random.uniform(\n", " error_key,\n", " (ROBUST_REPLICAS, N_LAYERS),\n", " minval=ROBUST_WINDOW_MIN,\n", " maxval=ROBUST_WINDOW_MAX,\n", " )\n", " perturbed_matrices, actual_errors = perturb_replicas(\n", " matrices, perturbations, target_errors, jnp.ones((ROBUST_REPLICAS,))\n", " )\n", " perturbed_scores = jax.vmap(\n", " lambda values: single_encoding_scores(values, features)\n", " )(perturbed_matrices)\n", " perturbed_logits = gamma * perturbed_scores / ROUTE_POWER_REFERENCE\n", " replica_labels = jnp.broadcast_to(labels, (ROBUST_REPLICAS, labels.shape[0]))\n", " perturbed_losses = optax.softmax_cross_entropy_with_integer_labels(\n", " perturbed_logits, replica_labels\n", " ).mean(axis=1)\n", " perturbed_accuracies = jnp.mean(\n", " jnp.argmax(perturbed_scores, axis=-1) == replica_labels, axis=1\n", " )\n", " margin_penalty = jnp.maximum(\n", " ROBUST_MARGIN_TARGET - normalized_optical_margin(perturbed_scores, labels), 0\n", " ).mean()\n", " gamma_term = GAMMA_WEIGHT * jnp.square(\n", " jnp.maximum(gamma - GAMMA_TARGET, 0.0) / GAMMA_TARGET\n", " )\n", " loss = (\n", " 0.35 * clean_loss\n", " + 0.65 * jnp.mean(perturbed_losses)\n", " + ROBUST_MARGIN_WEIGHT * margin_penalty\n", " + routing_transport(matrices)\n", " + gamma_term\n", " )\n", " metrics = jnp.asarray(\n", " (\n", " clean_loss,\n", " jnp.mean(perturbed_losses),\n", " margin_penalty,\n", " jnp.mean(jnp.argmax(clean_scores, axis=-1) == labels),\n", " jnp.mean(perturbed_accuracies),\n", " jnp.min(perturbed_accuracies),\n", " jnp.mean(actual_errors),\n", " )\n", " )\n", " return loss, metrics\n", "\n", "\n", "@jax.jit\n", "def single_encoding_update(parameters, optimizer_state, key, features, labels):\n", " (loss, metrics), gradients = jax.value_and_grad(\n", " single_encoding_objective, has_aux=True\n", " )(parameters, key, features, labels)\n", " updates, optimizer_state = robust_optimizer.update(\n", " gradients, optimizer_state, parameters\n", " )\n", " return optax.apply_updates(parameters, updates), optimizer_state, loss, metrics\n", "\n", "\n", "@jax.jit\n", "def single_encoding_clean_metrics(parameters, features, labels):\n", " matrices = layer_matrices(parameters)\n", " scores = single_encoding_scores(matrices, features)\n", " logits = jnp.exp(parameters[\"log_gamma\"]) * scores / ROUTE_POWER_REFERENCE\n", " loss = optax.softmax_cross_entropy_with_integer_labels(logits, labels).mean()\n", " accuracy = jnp.mean(jnp.argmax(scores, axis=-1) == labels)\n", " return loss, accuracy\n", "\n", "\n", "@jax.jit\n", "def single_encoding_perturbation_metrics(\n", " parameters, features, labels, keys, target_errors\n", "):\n", " matrices = layer_matrices(parameters)\n", " perturbations = jax.vmap(sample_chip_perturbation)(keys)\n", " perturbed, actual_errors = perturb_replicas(\n", " matrices, perturbations, target_errors, jnp.ones((len(keys),))\n", " )\n", " scores = jax.vmap(lambda values: single_encoding_scores(values, features))(\n", " perturbed\n", " )\n", " replica_labels = jnp.broadcast_to(labels, (len(keys), labels.shape[0]))\n", " accuracies = jnp.mean(jnp.argmax(scores, axis=-1) == replica_labels, axis=1)\n", " margins = jnp.mean(normalized_optical_margin(scores, labels), axis=1)\n", " return accuracies, margins, jnp.mean(actual_errors, axis=1)\n", "\n", "\n", "def evaluate_single_encoding_bank(\n", " parameters, features, labels, keys, severities, chunk_size=8\n", "):\n", " feature_array, label_array = jnp.asarray(features), jnp.asarray(labels)\n", " target_errors = np.asarray(severities, dtype=float)\n", " if target_errors.ndim == 1:\n", " target_errors = np.repeat(target_errors[:, None], N_LAYERS, axis=1)\n", " collected = [[], [], []]\n", " for start in range(0, len(keys), chunk_size):\n", " stop = min(start + chunk_size, len(keys))\n", " values = single_encoding_perturbation_metrics(\n", " parameters,\n", " feature_array,\n", " label_array,\n", " jnp.asarray(keys[start:stop]),\n", " jnp.asarray(target_errors[start:stop]),\n", " )\n", " for destination, value in zip(collected, values):\n", " destination.append(np.asarray(value))\n", " accuracy, margin, actual_error = (np.concatenate(values) for values in collected)\n", " return {\"accuracy\": accuracy, \"margin\": margin, \"actual_error\": actual_error}" ] }, { "cell_type": "code", "execution_count": 24, "id": "deep-single-encoding-state", "metadata": {}, "outputs": [], "source": [ "single_encoding_configuration = {\n", " **MATRIX_TRAINING_CONFIGURATION,\n", " \"encoding\": \"input phase before first stage only\",\n", " \"training seed\": MATRIX_TRAINING_SEED,\n", " \"epochs\": ROBUST_EPOCHS,\n", " \"batch size\": ROBUST_BATCH_SIZE,\n", " \"perturbation replicas\": ROBUST_REPLICAS,\n", " \"learning rate\": ROBUST_LR,\n", " \"robust error window\": (ROBUST_WINDOW_MIN, ROBUST_WINDOW_MAX),\n", " \"margin target\": ROBUST_MARGIN_TARGET,\n", " \"margin weight\": ROBUST_MARGIN_WEIGHT,\n", " \"selection interval\": ROBUST_VALIDATION_INTERVAL,\n", "}\n", "single_encoding_checkpoint = CHECKPOINT_DIR / (\"single_encoding__matrix_training.pkl\")\n", "\n", "if single_encoding_checkpoint.exists():\n", " with single_encoding_checkpoint.open(\"rb\") as handle:\n", " single_run = pickle.load(handle)\n", " if single_run.get(\"configuration\") != single_encoding_configuration:\n", " raise ValueError(\n", " \"The single-encoding checkpoint uses a different configuration.\"\n", " )\n", "else:\n", " single_initial = host_tree(\n", " initialize_parameters(jax.random.PRNGKey(MATRIX_TRAINING_SEED))\n", " )\n", " single_rng = np.random.default_rng(MATRIX_TRAINING_SEED)\n", " single_run = {\n", " \"params\": single_initial,\n", " \"optimizer_state\": host_tree(robust_optimizer.init(single_initial)),\n", " \"jax_key\": np.asarray(jax.random.PRNGKey(MATRIX_TRAINING_SEED + 10_000)),\n", " \"rng_state\": single_rng.bit_generator.state,\n", " \"best_score\": -np.inf,\n", " \"best_clean_accuracy\": -np.inf,\n", " \"best_params\": single_initial,\n", " \"best_epoch\": 0,\n", " \"completed_epoch\": 0,\n", " \"configuration\": single_encoding_configuration,\n", " }\n", "\n", "single_rng = np.random.default_rng(MATRIX_TRAINING_SEED)\n", "single_rng.bit_generator.state = single_run[\"rng_state\"]\n", "single_params = single_run[\"params\"]\n", "single_optimizer_state = single_run[\"optimizer_state\"]\n", "single_key = jnp.asarray(single_run[\"jax_key\"])\n", "single_best_score = single_run[\"best_score\"]\n", "single_best_clean = single_run[\"best_clean_accuracy\"]\n", "single_best_params = single_run[\"best_params\"]\n", "single_best_epoch = single_run[\"best_epoch\"]" ] }, { "cell_type": "code", "execution_count": 25, "id": "deep-single-encoding-training", "metadata": {}, "outputs": [], "source": [ "for epoch in range(single_run[\"completed_epoch\"] + 1, ROBUST_EPOCHS + 1):\n", " epoch_indices = single_rng.permutation(len(train_features))\n", " for start in range(0, len(train_features), ROBUST_BATCH_SIZE):\n", " indices = epoch_indices[start : start + ROBUST_BATCH_SIZE]\n", " single_key, batch_key = jax.random.split(single_key)\n", " single_params, single_optimizer_state, _, _ = single_encoding_update(\n", " single_params,\n", " single_optimizer_state,\n", " batch_key,\n", " jnp.asarray(train_features[indices]),\n", " jnp.asarray(train_labels[indices]),\n", " )\n", " if epoch % ROBUST_VALIDATION_INTERVAL == 0 or epoch == ROBUST_EPOCHS:\n", " _, clean_accuracy = single_encoding_clean_metrics(\n", " single_params, jnp.asarray(val_features), jnp.asarray(val_labels)\n", " )\n", " validation = evaluate_single_encoding_bank(\n", " single_params,\n", " val_features,\n", " val_labels,\n", " validation_keys,\n", " validation_severities,\n", " )\n", " mean_accuracy = float(np.mean(validation[\"accuracy\"]))\n", " if (\n", " float(clean_accuracy) >= MIN_SELECTION_ACCURACY\n", " and mean_accuracy > single_best_score\n", " ):\n", " single_best_score = mean_accuracy\n", " single_best_clean = float(clean_accuracy)\n", " single_best_params = host_tree(single_params)\n", " single_best_epoch = epoch\n", " single_run = {\n", " \"params\": host_tree(single_params),\n", " \"optimizer_state\": host_tree(single_optimizer_state),\n", " \"jax_key\": np.asarray(single_key),\n", " \"rng_state\": single_rng.bit_generator.state,\n", " \"best_score\": single_best_score,\n", " \"best_clean_accuracy\": single_best_clean,\n", " \"best_params\": host_tree(single_best_params),\n", " \"best_epoch\": single_best_epoch,\n", " \"completed_epoch\": epoch,\n", " \"configuration\": single_encoding_configuration,\n", " }\n", " temporary_path = single_encoding_checkpoint.with_suffix(\".tmp\")\n", " with temporary_path.open(\"wb\") as handle:\n", " pickle.dump(single_run, handle, protocol=pickle.HIGHEST_PROTOCOL)\n", " temporary_path.replace(single_encoding_checkpoint)" ] }, { "cell_type": "code", "execution_count": 26, "id": "encoding-baseline-results", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "single encoding: clean=86.89%, 8-12% mean=85.79%; repeated encoding: clean=90.52%, 8-12% mean=89.64%\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "single_params = single_best_params\n", "single_test_loss, single_test_accuracy = single_encoding_clean_metrics(\n", " single_params, jnp.asarray(test_features), jnp.asarray(test_labels)\n", ")\n", "single_validation = evaluate_single_encoding_bank(\n", " single_params, val_features, val_labels, validation_keys, validation_severities\n", ")\n", "single_validation_mean = float(np.mean(single_validation[\"accuracy\"]))\n", "single_validation_fifth = float(np.quantile(single_validation[\"accuracy\"], 0.05))\n", "\n", "encoding_comparison = {\n", " \"controlled difference\": \"image phase once or before every stage\",\n", " \"single encoding\": {\n", " \"selected epoch\": int(single_best_epoch),\n", " \"clean test accuracy\": float(single_test_accuracy),\n", " \"validation mean over 8-12%\": single_validation_mean,\n", " \"validation fifth percentile over 8-12%\": single_validation_fifth,\n", " },\n", " \"repeated encoding\": {\n", " \"selected epoch\": int(best_epoch),\n", " \"clean test accuracy\": float(test_accuracy),\n", " \"validation mean over 8-12%\": selected_validation_mean,\n", " \"validation fifth percentile over 8-12%\": selected_validation_fifth,\n", " },\n", "}\n", "matrix_training_metrics[\"encoding comparison\"] = encoding_comparison\n", "print(\n", " f\"single encoding: clean={single_test_accuracy:.2%}, \"\n", " f\"8-12% mean={single_validation_mean:.2%}; \"\n", " f\"repeated encoding: clean={test_accuracy:.2%}, \"\n", " f\"8-12% mean={selected_validation_mean:.2%}\"\n", ")\n", "\n", "comparison_labels = (\"clean test\", \"8-12% validation mean\", \"8-12% validation fifth\")\n", "single_values = 100 * np.asarray(\n", " (float(single_test_accuracy), single_validation_mean, single_validation_fifth)\n", ")\n", "repeated_values = 100 * np.asarray(\n", " (float(test_accuracy), selected_validation_mean, selected_validation_fifth)\n", ")\n", "positions = np.arange(len(comparison_labels))\n", "fig, ax = plt.subplots(figsize=(7.4, 3.8), constrained_layout=True)\n", "width = 0.36\n", "ax.bar(positions - width / 2, single_values, width, label=\"encode once\")\n", "ax.bar(positions + width / 2, repeated_values, width, label=\"encode every stage\")\n", "for x, value in zip(positions - width / 2, single_values):\n", " ax.text(x, value + 0.35, f\"{value:.1f}\", ha=\"center\", va=\"bottom\", fontsize=8)\n", "for x, value in zip(positions + width / 2, repeated_values):\n", " ax.text(x, value + 0.35, f\"{value:.1f}\", ha=\"center\", va=\"bottom\", fontsize=8)\n", "ax.set_xticks(positions, comparison_labels)\n", "ax.set(ylabel=\"accuracy (%)\", title=\"Effect of repeated phase encoding\")\n", "ax.set_ylim(max(0, min(single_values.min(), repeated_values.min()) - 5), 100)\n", "ax.legend(frameon=False)\n", "fig.savefig(FIGURE_DIR / \"encoding_comparison.png\", dpi=180, bbox_inches=\"tight\")\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 27, "id": "repeated-target-matrices-plot", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "target_amplitude = np.abs(trained_matrices)\n", "target_phase = np.angle(trained_matrices)\n", "channel_ticks = np.unique(np.linspace(0, N_CHANNELS - 1, min(5, N_CHANNELS), dtype=int))\n", "fig, axes = plt.subplots(\n", " 2, N_LAYERS, figsize=(3.2 * N_LAYERS, 6.0), constrained_layout=True\n", ")\n", "for layer in range(N_LAYERS):\n", " amplitude_image = axes[0, layer].imshow(\n", " target_amplitude[layer], cmap=\"magma\", vmin=0, vmax=target_amplitude.max()\n", " )\n", " phase_image = axes[1, layer].imshow(\n", " target_phase[layer], cmap=\"twilight_shifted\", vmin=-np.pi, vmax=np.pi\n", " )\n", " axes[0, layer].set(\n", " title=f\"Layer {layer + 1}\", xticks=channel_ticks, yticks=channel_ticks\n", " )\n", " axes[1, layer].set(\n", " xticks=channel_ticks, yticks=channel_ticks, xlabel=\"input channel\"\n", " )\n", "axes[0, 0].set_ylabel(\"output channel\")\n", "axes[1, 0].set_ylabel(\"output channel\")\n", "fig.colorbar(amplitude_image, ax=axes[0, :], label=\"amplitude\", shrink=0.85)\n", "fig.colorbar(\n", " phase_image,\n", " ax=axes[1, :],\n", " label=\"phase (rad)\",\n", " shrink=0.85,\n", " ticks=(-np.pi, 0, np.pi),\n", " format=plt.FuncFormatter(\n", " lambda value, _: {-np.pi: r\"$-\\pi$\", 0: \"0\", np.pi: r\"$\\pi$\"}.get(value, \"\")\n", " ),\n", ")\n", "fig.savefig(\n", " FIGURE_DIR / \"repeated_encoding_target_matrices.png\", dpi=180, bbox_inches=\"tight\"\n", ")\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "community-31", "metadata": {}, "source": [ "## Set Up the Silicon Photonic Devices\n", "\n", "We now convert the three target matrices into three inverse-design models. To reduce the computational cost, the silicon slab is represented by a two-dimensional effective-index model at 1.55 µm. Separate effective indices describe the 150 nm and 220 nm silicon thicknesses, while the surrounding region retains the SiEPIC silica index.\n", "\n", "All three devices use a 12.6 µm square design region with 50 nm pixels and a 200 nm spatial filter. Six waveguides enter each device on a 1.75 µm pitch. The first two devices also have six outputs, while the final device has four outputs aligned with the class detectors.\n", "\n", "We excite each input separately to recover the complete transmission and reflection matrices. Before running the inverse design, the following cells inspect the geometry, solve the quasi-TE port mode, and validate the 18 source simulations.\n" ] }, { "cell_type": "code", "execution_count": 28, "id": "community-32", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "effective-index calibration: grid=5.0 nm, n150=2.436998, n220=2.848820\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "N_CLAD = 1.4447002763\n", "N_EFF_TE_150_SLAB, N_EFF_TE_220_SLAB = 2.5443521652, 2.8493681982\n", "PDK_MODE_NEFF = float(np.real(PDK_NEFF))\n", "EIM_GRID_STEPS_UM = (0.02, 0.01, 0.005)\n", "SI_3D = td.material_library[\"cSi\"][\"Palik_NoLoss\"]\n", "SIO2_3D = td.material_library[\"SiO2\"][\"Palik_NoLoss\"]\n", "td.config.simulation.use_local_subpixel = True\n", "\n", "\n", "def vertical_profile_simulation(grid_step):\n", " profiles = (\n", " td.Structure(\n", " geometry=td.Box(center=(-1, 0, 0), size=(0.8, td.inf, 0.22)), medium=SI_3D\n", " ),\n", " td.Structure(\n", " geometry=td.Box(center=(0, 0, -0.035), size=(0.8, td.inf, 0.15)),\n", " medium=SI_3D,\n", " ),\n", " )\n", " return td.Simulation(\n", " center=(0, 0, 0),\n", " size=(3, 3, 3),\n", " medium=SIO2_3D,\n", " structures=profiles,\n", " sources=[],\n", " monitors=[],\n", " run_time=1e-12,\n", " boundary_spec=td.BoundarySpec.all_sides(td.Periodic()),\n", " grid_spec=td.GridSpec.uniform(dl=grid_step),\n", " )\n", "\n", "\n", "def variational_permittivity(simulation, point, reference=(-1, 0)):\n", " vertical_simulation = simulation.updated_copy(\n", " center=(reference[0], reference[1], 0),\n", " size=(0, 3, 3),\n", " sources=[],\n", " monitors=[],\n", " symmetry=(0, 0, 0),\n", " boundary_spec=simulation.boundary_spec.updated_copy(x=td.Boundary.periodic()),\n", " )\n", " solver = ModeSolver(\n", " simulation=vertical_simulation,\n", " plane=td.Box(center=vertical_simulation.center, size=(3, 0, 3)),\n", " mode_spec=td.ModeSpec(num_modes=1, target_neff=N_EFF_TE_220_SLAB),\n", " freqs=[FREQ0_HZ],\n", " direction=\"+\",\n", " )\n", " mode_data = solver.solve()\n", " reference_index = float(np.real(np.asarray(mode_data.n_eff).reshape(-1)[0]))\n", " if point == reference:\n", " return reference_index**2, reference_index\n", "\n", " reference_eps = simulation.epsilon(\n", " box=td.Box(center=(*reference, 0), size=(0, 0, td.inf)), freq=FREQ0_HZ\n", " )\n", " point_eps = simulation.epsilon(\n", " box=td.Box(center=(*point, 0), size=(0, 0, td.inf)), freq=FREQ0_HZ\n", " )\n", " z = np.asarray(reference_eps.z)\n", " delta_eps = np.squeeze(point_eps.values) - np.squeeze(reference_eps.values)\n", " field_interpolator = scipy.interpolate.interp1d(\n", " np.asarray(mode_data.Ex.z),\n", " np.abs(np.squeeze(mode_data.Ex.values)) ** 2,\n", " bounds_error=False,\n", " fill_value=0.0,\n", " )\n", " field_intensity = field_interpolator(z)\n", " correction = np.trapezoid(delta_eps * field_intensity, x=z) / np.trapezoid(\n", " field_intensity, x=z\n", " )\n", " return max(1.0, float(np.real(reference_index**2 + correction))), reference_index\n", "\n", "\n", "previous_log_level = td.config.logging.level\n", "td.config.logging.level = \"ERROR\"\n", "eim_convergence = []\n", "for grid_step in EIM_GRID_STEPS_UM:\n", " profile_simulation = vertical_profile_simulation(grid_step)\n", " eps_220, reference_index = variational_permittivity(profile_simulation, (-1, 0))\n", " eps_150, _ = variational_permittivity(profile_simulation, (0, 0))\n", " eps_background = N_CLAD**2\n", " eim_convergence.append(\n", " {\n", " \"grid nm\": 1e3 * grid_step,\n", " \"220 nm variational index\": float(np.sqrt(eps_220)),\n", " \"150 nm variational index\": float(np.sqrt(eps_150)),\n", " \"silica background index\": float(np.sqrt(eps_background)),\n", " }\n", " )\n", "td.config.logging.level = previous_log_level\n", "print(\n", " \"effective-index calibration:\",\n", " f\"grid={eim_convergence[-1]['grid nm']} nm, \"\n", " f\"n150={eim_convergence[-1]['150 nm variational index']:.6f}, \"\n", " f\"n220={eim_convergence[-1]['220 nm variational index']:.6f}\",\n", ")\n", "\n", "eim_calibration = eim_convergence[-1]\n", "N_EFF_TE_150 = eim_calibration[\"150 nm variational index\"]\n", "N_EFF_TE_220 = eim_calibration[\"220 nm variational index\"]\n", "N_EFF_TE_BACKGROUND = eim_calibration[\"silica background index\"]\n", "EPS_CLAD = N_EFF_TE_BACKGROUND**2\n", "EPS_CORE = N_EFF_TE_220**2\n", "EPS_DESIGN = (N_EFF_TE_150**2, N_EFF_TE_220**2)\n", "\n", "grid_nm = np.asarray([record[\"grid nm\"] for record in eim_convergence])\n", "fig, axes = plt.subplots(1, 2, figsize=(7.4, 2.8), constrained_layout=True)\n", "axes[0].plot(\n", " grid_nm,\n", " [record[\"220 nm variational index\"] for record in eim_convergence],\n", " \"o-\",\n", " label=\"220 nm\",\n", ")\n", "axes[0].plot(\n", " grid_nm,\n", " [record[\"150 nm variational index\"] for record in eim_convergence],\n", " \"o-\",\n", " label=\"150 nm\",\n", ")\n", "axes[0].invert_xaxis()\n", "axes[0].set(xlabel=\"calibration grid (nm)\", ylabel=\"variational index\")\n", "axes[0].legend()\n", "axes[1].plot(\n", " grid_nm,\n", " [record[\"220 nm variational index\"] - N_EFF_TE_220 for record in eim_convergence],\n", " \"o-\",\n", " label=\"220 nm\",\n", ")\n", "axes[1].plot(\n", " grid_nm,\n", " [record[\"150 nm variational index\"] - N_EFF_TE_150 for record in eim_convergence],\n", " \"o-\",\n", " label=\"150 nm\",\n", ")\n", "axes[1].axhline(0, color=\"black\", lw=0.8, ls=\"--\")\n", "axes[1].invert_xaxis()\n", "axes[1].set(\n", " xlabel=\"calibration grid (nm)\", ylabel=r\"$n_{\\mathrm{2D}}-n_{\\mathrm{finest}}$\"\n", ")\n", "axes[1].legend()\n", "plt.show()\n", "\n", "CORE_THICKNESS, PORT_PITCH, WG_WIDTH, MODE_WINDOW = 0.22, ID_PORT_PITCH, 0.5, 1.75\n", "DESIGN_SIZE, PIXEL, FILTER_RADIUS, FILTER_BETA = (\n", " (DESIGN_EDGE_UM, DESIGN_EDGE_UM, CORE_THICKNESS),\n", " 0.05,\n", " 0.2,\n", " 50.0,\n", ")\n", "TAPER_LENGTH, TAPER_MOUTH, TAPER_OVERLAP = (\n", " ID_TAPER_LENGTH,\n", " ID_TAPER_MOUTH,\n", " ID_TAPER_OVERLAP,\n", ")\n", "CORNER_RADIUS, RAIL_THICKNESS, RAIL_INNER_OVERLAP = 0.8, 0.30, 0.0\n", "PML_EXTENSION = 2.0\n", "DESIGN_HALF = DESIGN_EDGE_UM / 2\n", "DOMAIN_X = (-DESIGN_HALF - TAPER_LENGTH - 4.65, DESIGN_HALF + TAPER_LENGTH + 4.65)\n", "DOMAIN_Y = (-DESIGN_HALF - 1.55, DESIGN_HALF + 1.55)\n", "INPUT_MONITOR_X = -DESIGN_HALF - TAPER_LENGTH - 1.55\n", "OUTPUT_MONITOR_X = DOMAIN_X[1] - 1.55\n", "INPUT_PORT_Y = (np.arange(N_CHANNELS) - (N_CHANNELS - 1) / 2) * PORT_PITCH\n", "OUTPUT_PORT_Y = {\n", " n_outputs: (np.arange(n_outputs) - (n_outputs - 1) / 2) * PORT_PITCH\n", " for n_outputs in set(LAYER_OUTPUT_COUNTS)\n", "}\n", "CLAD = td.Medium(permittivity=EPS_CLAD)\n", "CORE = td.Medium(permittivity=EPS_CORE)\n", "MODE_SPEC = td.ModeSpec(num_modes=1, target_neff=float(np.real(PDK_MODE_NEFF)))\n", "\n", "\n", "def vertices(xs, widths, y):\n", " xs, widths = np.asarray(xs), np.asarray(widths)\n", " lower = np.c_[xs, y - widths / 2]\n", " upper = np.c_[xs[::-1], (y + widths / 2)[::-1]]\n", " return np.r_[lower, upper]\n", "\n", "\n", "def rounded_box(length, width, radius, layer):\n", " polygon = gdstk.rectangle(\n", " (-length / 2, -width / 2), (length / 2, width / 2), layer=layer\n", " )\n", " polygon.fillet(radius)\n", " return polygon\n", "\n", "\n", "def geometry_from_gds(polygons, layer):\n", " library = gdstk.Library()\n", " cell = library.new_cell(f\"GEOMETRY_{layer}\")\n", " cell.add(*polygons)\n", " return td.Geometry.from_gds(\n", " cell,\n", " axis=2,\n", " slab_bounds=(-CORE_THICKNESS / 2, CORE_THICKNESS / 2),\n", " gds_layer=layer,\n", " gds_dtype=0,\n", " reference_plane=\"middle\",\n", " )" ] }, { "cell_type": "code", "execution_count": 29, "id": "community-33", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "square filter grid: (253, 253, 1)\n" ] }, { "data": { "text/html": [ "
04:23:41 KST WARNING: 'ModalComponentModeler' was refactored (tidy3d 'v2.10.0').\n",
       "             Existing functionality is available differently. Please consult the\n",
       "             migration documentation:                                           \n",
       "             https://docs.flexcompute.com/projects/tidy3d/en/latest/api/microwav\n",
       "             e/microwave_migration.html                                         \n",
       "
\n" ], "text/plain": [ "\u001b[2;36m04:23:41 KST\u001b[0m\u001b[2;36m \u001b[0m\u001b[31mWARNING: \u001b[0m\u001b[32m'ModalComponentModeler'\u001b[0m\u001b[31m was refactored \u001b[0m\u001b[1;31m(\u001b[0m\u001b[31mtidy3d \u001b[0m\u001b[32m'v2.10.0'\u001b[0m\u001b[1;31m)\u001b[0m\u001b[31m.\u001b[0m\n", "\u001b[2;36m \u001b[0m\u001b[31mExisting functionality is available differently. Please consult the\u001b[0m\n", "\u001b[2;36m \u001b[0m\u001b[31mmigration documentation: \u001b[0m\n", "\u001b[2;36m \u001b[0m\u001b[4;94mhttps://docs.flexcompute.com/projects/tidy3d/en/latest/api/microwav\u001b[0m\n", "\u001b[2;36m \u001b[0m\u001b[4;94me/microwave_migration.html\u001b[0m\u001b[31m \u001b[0m\n" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "layer 1: 6 inputs, 6 outputs, 6 source simulations\n", "layer 2: 6 inputs, 6 outputs, 6 source simulations\n", "layer 3: 6 inputs, 4 outputs, 6 source simulations\n" ] } ], "source": [ "def fixed_polygons(n_outputs):\n", " layer, polygons = 3, []\n", " left, right = -DESIGN_HALF, DESIGN_HALF\n", " taper_left, taper_right = left - TAPER_LENGTH, right + TAPER_LENGTH\n", " output_y = OUTPUT_PORT_Y[n_outputs]\n", " for y in INPUT_PORT_Y:\n", " polygons.extend(\n", " [\n", " gdstk.rectangle(\n", " (DOMAIN_X[0] - PML_EXTENSION, y - WG_WIDTH / 2),\n", " (taper_left, y + WG_WIDTH / 2),\n", " layer=layer,\n", " ),\n", " gdstk.Polygon(\n", " vertices(\n", " np.linspace(taper_left, left, 101),\n", " np.linspace(WG_WIDTH, TAPER_MOUTH, 101),\n", " y,\n", " ),\n", " layer=layer,\n", " ),\n", " ]\n", " )\n", " for y in output_y:\n", " polygons.extend(\n", " [\n", " gdstk.Polygon(\n", " vertices(\n", " np.linspace(right, taper_right, 101),\n", " np.linspace(TAPER_MOUTH, WG_WIDTH, 101),\n", " y,\n", " ),\n", " layer=layer,\n", " ),\n", " gdstk.rectangle(\n", " (taper_right, y - WG_WIDTH / 2),\n", " (DOMAIN_X[1] + PML_EXTENSION, y + WG_WIDTH / 2),\n", " layer=layer,\n", " ),\n", " ]\n", " )\n", " rail = RAIL_THICKNESS\n", " outer = rounded_box(\n", " DESIGN_EDGE_UM + 2 * rail,\n", " DESIGN_EDGE_UM + 2 * rail,\n", " CORNER_RADIUS + rail,\n", " layer,\n", " )\n", " inner = rounded_box(DESIGN_EDGE_UM, DESIGN_EDGE_UM, CORNER_RADIUS, layer)\n", " ring = gdstk.boolean([outer], [inner], \"not\", layer=layer, precision=1e-9) or []\n", " mask_bound = DESIGN_HALF + 0.5\n", " side_masks, bridges = [], []\n", " for x0, x1, positions, bridge_x0, bridge_x1 in (\n", " (-mask_bound, 0, INPUT_PORT_Y, -mask_bound, left),\n", " (0, mask_bound, output_y, right, mask_bound),\n", " ):\n", " lower = positions[0] - TAPER_MOUTH / 2\n", " upper = positions[-1] + TAPER_MOUTH / 2\n", " side_masks.extend(\n", " [\n", " gdstk.rectangle((x0, -mask_bound), (x1, lower), layer=layer),\n", " gdstk.rectangle((x0, upper), (x1, mask_bound), layer=layer),\n", " ]\n", " )\n", " bridges.extend(\n", " [\n", " gdstk.rectangle(\n", " (bridge_x0, lower - rail), (bridge_x1, positions[0]), layer=layer\n", " ),\n", " gdstk.rectangle(\n", " (bridge_x0, positions[-1]), (bridge_x1, upper + rail), layer=layer\n", " ),\n", " ]\n", " )\n", " polygons.extend(\n", " gdstk.boolean(ring, side_masks, \"and\", layer=layer, precision=1e-9) or []\n", " )\n", " polygons.extend(\n", " gdstk.boolean(ring, bridges, \"and\", layer=layer, precision=1e-9) or []\n", " )\n", " return gdstk.boolean(polygons, [], \"or\", layer=layer, precision=1e-9) or []\n", "\n", "\n", "def corner_mask_polygons():\n", " rectangle = gdstk.rectangle(\n", " (-DESIGN_HALF, -DESIGN_HALF), (DESIGN_HALF, DESIGN_HALF), layer=4\n", " )\n", " rounded = rounded_box(DESIGN_EDGE_UM, DESIGN_EDGE_UM, CORNER_RADIUS, 4)\n", " return gdstk.boolean([rectangle], [rounded], \"not\", layer=4, precision=1e-9) or []\n", "\n", "\n", "FIXED_GEOMETRY = {\n", " n_outputs: geometry_from_gds(fixed_polygons(n_outputs), 3)\n", " for n_outputs in set(LAYER_OUTPUT_COUNTS)\n", "}\n", "CORNER_MASK_GEOMETRY = geometry_from_gds(corner_mask_polygons(), 4)\n", "\n", "\n", "def fabrication_penalty(weight=1.0):\n", " return tdi.ErosionDilationPenalty(\n", " weight=weight,\n", " length_scale=FABRICATION_MIN_FEATURE_UM,\n", " beta=FABRICATION_BETA,\n", " eta0=FABRICATION_ETA0,\n", " delta_eta=FABRICATION_DELTA_ETA,\n", " )\n", "\n", "\n", "def design_region(fabrication_weight=0.0):\n", " penalties = (\n", " (fabrication_penalty(fabrication_weight),) if fabrication_weight > 0 else ()\n", " )\n", " return tdi.TopologyDesignRegion(\n", " size=DESIGN_SIZE,\n", " center=(0, 0, 0),\n", " eps_bounds=EPS_DESIGN,\n", " transformations=(\n", " tdi.FilterProject(radius=FILTER_RADIUS, beta=FILTER_BETA, eta=0.5),\n", " ),\n", " penalties=penalties,\n", " pixel_size=PIXEL,\n", " uniform=(False, False, True),\n", " priority=0,\n", " )\n", "\n", "\n", "print(\"square filter grid:\", design_region().params_shape)\n", "\n", "INPUT_NAMES = tuple(f\"input_{index:02d}\" for index in range(N_CHANNELS))\n", "\n", "\n", "def output_names(n_outputs):\n", " return tuple(f\"output_{index:02d}\" for index in range(n_outputs))\n", "\n", "\n", "def modal_ports(n_outputs):\n", " return tuple(\n", " Port(\n", " center=(INPUT_MONITOR_X, float(y), 0),\n", " size=(0, MODE_WINDOW, td.inf),\n", " name=name,\n", " direction=\"+\",\n", " mode_spec=MODE_SPEC,\n", " )\n", " for name, y in zip(INPUT_NAMES, INPUT_PORT_Y)\n", " ) + tuple(\n", " Port(\n", " center=(OUTPUT_MONITOR_X, float(y), 0),\n", " size=(0, MODE_WINDOW, td.inf),\n", " name=name,\n", " direction=\"-\",\n", " mode_spec=MODE_SPEC,\n", " )\n", " for name, y in zip(output_names(n_outputs), OUTPUT_PORT_Y[n_outputs])\n", " )\n", "\n", "\n", "def device_base_simulation(n_outputs):\n", " return td.Simulation(\n", " center=(0, 0, 0),\n", " size=(np.ptp(DOMAIN_X), np.ptp(DOMAIN_Y), 0),\n", " medium=CLAD,\n", " structures=[\n", " td.Structure(\n", " geometry=FIXED_GEOMETRY[n_outputs],\n", " medium=CORE,\n", " name=\"fixed_rails_tapers\",\n", " priority=2,\n", " ),\n", " td.Structure(\n", " geometry=CORNER_MASK_GEOMETRY,\n", " medium=CLAD,\n", " name=\"rounded_corner_mask\",\n", " priority=1,\n", " ),\n", " ],\n", " sources=[],\n", " monitors=[],\n", " run_time=15e-12,\n", " shutoff=1e-4,\n", " grid_spec=td.GridSpec.auto(wavelength=WAVELENGTH_UM, min_steps_per_wvl=13),\n", " boundary_spec=td.BoundarySpec(\n", " x=td.Boundary.pml(), y=td.Boundary.pml(), z=td.Boundary.periodic()\n", " ),\n", " subpixel=True,\n", " )\n", "\n", "\n", "def native_modal_modeler(layer):\n", " n_outputs = LAYER_OUTPUT_COUNTS[layer]\n", " return ModalComponentModeler(\n", " name=f\"deep_pnn_modal_layer_{layer + 1}\",\n", " simulation=device_base_simulation(n_outputs),\n", " ports=modal_ports(n_outputs),\n", " freqs=(FREQ0_HZ,),\n", " run_only=tuple((name, 0) for name in INPUT_NAMES),\n", " )\n", "\n", "\n", "class InverseDesignMulti(tdi.InverseDesignMulti):\n", " def run_async(self, simulations, **kwargs):\n", " from tidy3d.web import run_async\n", "\n", " simulation_data = {}\n", " kwargs.setdefault(\"path_dir\", AUTOGRAD_CACHE_DIR)\n", " simulation_items = list(simulations.items())\n", " for start in range(0, len(simulation_items), AUTOGRAD_SOURCE_CHUNK_SIZE):\n", " chunk = dict(simulation_items[start : start + AUTOGRAD_SOURCE_CHUNK_SIZE])\n", " batch_data = run_async(chunk, verbose=self.verbose, **kwargs)\n", " for task_name in chunk:\n", " simulation_data[task_name] = batch_data[task_name]\n", " return simulation_data\n", "\n", "\n", "NATIVE_MODELERS = {layer: native_modal_modeler(layer) for layer in range(N_LAYERS)}\n", "NATIVE_TASK_NAMES = {\n", " layer: tuple(modeler.sim_dict) for layer, modeler in NATIVE_MODELERS.items()\n", "}\n", "NATIVE_SIMULATIONS = {\n", " layer: tuple(modeler.sim_dict.values())\n", " for layer, modeler in NATIVE_MODELERS.items()\n", "}\n", "NATIVE_MONITOR_NAMES = {\n", " layer: tuple(\n", " tuple(monitor.name for monitor in simulation.monitors)\n", " for simulation in NATIVE_SIMULATIONS[layer]\n", " )\n", " for layer in range(N_LAYERS)\n", "}\n", "\n", "\n", "def make_design(layer, target):\n", " return InverseDesignMulti(\n", " design_region=design_region(),\n", " task_name=f\"deep_id_pnn_layer_{layer + 1}\",\n", " simulations=NATIVE_SIMULATIONS[layer],\n", " output_monitor_names=NATIVE_MONITOR_NAMES[layer],\n", " verbose=False,\n", " ), np.asarray(target)\n", "\n", "\n", "designs, targets = {}, {}\n", "for layer in range(N_LAYERS):\n", " designs[layer], targets[layer] = make_design(layer, REALIZATION_TARGETS[layer])\n", " print(\n", " f\"layer {layer + 1}: {LAYER_INPUT_COUNTS[layer]} inputs, \"\n", " f\"{LAYER_OUTPUT_COUNTS[layer]} outputs, \"\n", " f\"{len(designs[layer].simulations)} source simulations\"\n", " )" ] }, { "cell_type": "code", "execution_count": 30, "id": "community-37", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "port modes: 6 checked, minimum TE fraction=1.0000, n_eff range=2.483866-2.487522\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "layer 1: 6 local simulations, 6 inputs, 6 outputs\n", "layer 2: 6 local simulations, 6 inputs, 6 outputs\n", "layer 3: 6 local simulations, 6 inputs, 4 outputs\n" ] } ], "source": [ "initial_parameters = designs[N_LAYERS - 1].design_region.initial_parameters\n", "preview_batch = designs[N_LAYERS - 1].to_simulation(initial_parameters)\n", "preview_simulation = next(iter(preview_batch.values()))\n", "fig, axes = plt.subplots(1, 2, figsize=(12.0, 4.8), constrained_layout=True)\n", "preview_simulation.plot(z=0, source_alpha=0.9, monitor_alpha=0.65, ax=axes[0])\n", "preview_simulation.plot_pml(z=0, ax=axes[0])\n", "preview_simulation.plot_eps(\n", " z=0,\n", " freq=FREQ0_HZ,\n", " source_alpha=0,\n", " monitor_alpha=0,\n", " eps_lim=(EPS_CLAD, EPS_CORE),\n", " ax=axes[1],\n", ")\n", "axes[0].set(\n", " xlim=DOMAIN_X,\n", " ylim=DOMAIN_Y,\n", " title=f\"Device 3: {N_CHANNELS} inputs, {N_CLASSES} outputs\",\n", ")\n", "axes[1].set(\n", " xlim=DOMAIN_X, ylim=DOMAIN_Y, title=r\"Relative permittivity $\\varepsilon_r(x,y)$\"\n", ")\n", "fig.savefig(\n", " FIGURE_DIR / \"tidy3d_preflight_domain_permittivity.png\",\n", " dpi=180,\n", " bbox_inches=\"tight\",\n", ")\n", "plt.show()\n", "\n", "port_mode_indices, port_te_fractions = [], []\n", "for port_y in INPUT_PORT_Y:\n", " port_plane = td.Box(\n", " center=(INPUT_MONITOR_X, float(port_y), 0), size=(0, MODE_WINDOW, td.inf)\n", " )\n", " port_mode = ModeSolver(\n", " simulation=preview_simulation,\n", " plane=port_plane,\n", " mode_spec=MODE_SPEC,\n", " freqs=[FREQ0_HZ],\n", " direction=\"+\",\n", " ).solve()\n", " port_mode_indices.append(float(np.real(np.asarray(port_mode.n_eff).reshape(-1)[0])))\n", " port_te_fractions.append(float(np.asarray(port_mode.TE_fraction).reshape(-1)[0]))\n", "port_mode_indices = np.asarray(port_mode_indices)\n", "port_te_fractions = np.asarray(port_te_fractions)\n", "port_mode_report = {\n", " \"polarization\": \"fundamental quasi-TE\",\n", " \"ports checked\": len(INPUT_PORT_Y),\n", " \"minimum TE fraction\": float(port_te_fractions.min()),\n", " \"maximum TE fraction\": float(port_te_fractions.max()),\n", " \"minimum 2D rail effective index\": float(port_mode_indices.min()),\n", " \"maximum 2D rail effective index\": float(port_mode_indices.max()),\n", " \"PDK strip effective index\": PDK_MODE_NEFF,\n", " \"maximum absolute effective-index difference\": float(\n", " np.max(np.abs(port_mode_indices - PDK_MODE_NEFF))\n", " ),\n", "}\n", "print(\n", " f\"port modes: {port_mode_report['ports checked']} checked, \"\n", " f\"minimum TE fraction={port_mode_report['minimum TE fraction']:.4f}, \"\n", " f\"n_eff range={port_mode_report['minimum 2D rail effective index']:.6f}-\"\n", " f\"{port_mode_report['maximum 2D rail effective index']:.6f}\"\n", ")\n", "fig, axes = plt.subplots(1, 2, figsize=(8.4, 3.0), constrained_layout=True)\n", "channels = np.arange(1, N_CHANNELS + 1)\n", "axes[0].plot(channels, port_mode_indices, marker=\"o\", label=\"2D port mode\")\n", "axes[0].axhline(PDK_MODE_NEFF, color=\"0.25\", linestyle=\"--\", label=\"SiEPIC PDK value\")\n", "axes[1].plot(channels, port_te_fractions, marker=\"o\")\n", "axes[0].set(xlabel=\"port\", ylabel=r\"$n_{\\mathrm{eff}}$\", title=\"Port effective index\")\n", "axes[1].set(\n", " xlabel=\"port\", ylabel=\"TE fraction\", title=\"Polarization selection\", ylim=(0, 1.02)\n", ")\n", "axes[0].legend(frameon=False)\n", "plt.show()\n", "\n", "preflight = {}\n", "for layer, design in designs.items():\n", " finalized = design.to_simulation(design.design_region.initial_parameters)\n", " task_names = []\n", " for task_name, simulation in finalized.items():\n", " simulation.validate_pre_upload()\n", " task_names.append(task_name)\n", " native_source_x = float(next(iter(finalized.values())).sources[0].center[0])\n", " preflight[layer] = {\n", " \"simulations\": len(finalized),\n", " \"task names\": task_names,\n", " \"sources per simulation\": 1,\n", " \"input ports\": LAYER_INPUT_COUNTS[layer],\n", " \"output ports\": LAYER_OUTPUT_COUNTS[layer],\n", " \"monitors per simulation\": (\n", " LAYER_INPUT_COUNTS[layer] + LAYER_OUTPUT_COUNTS[layer]\n", " ),\n", " \"polarization\": \"fundamental quasi-TE\",\n", " \"minimum port TE fraction\": port_mode_report[\"minimum TE fraction\"],\n", " \"port effective-index range\": [\n", " port_mode_report[\"minimum 2D rail effective index\"],\n", " port_mode_report[\"maximum 2D rail effective index\"],\n", " ],\n", " \"variational TE index, 150 nm\": N_EFF_TE_150,\n", " \"variational TE index, 220 nm\": N_EFF_TE_220,\n", " \"silica background index\": N_EFF_TE_BACKGROUND,\n", " \"variational calibration grid nm\": eim_calibration[\"grid nm\"],\n", " \"simulation architecture\": \"native ModalComponentModeler S matrix\",\n", " \"incident normalization\": True,\n", " \"mode window um\": MODE_WINDOW,\n", " \"source-to-input-monitor um\": INPUT_MONITOR_X - native_source_x,\n", " \"input-monitor-to-taper um\": (-DESIGN_HALF - TAPER_LENGTH) - INPUT_MONITOR_X,\n", " \"taper mouth clearance um\": PORT_PITCH - TAPER_MOUTH,\n", " \"taper rail overlap um\": TAPER_OVERLAP,\n", " }\n", "for layer, report in preflight.items():\n", " print(\n", " f\"layer {layer + 1}: {report['simulations']} local simulations, \"\n", " f\"{report['input ports']} inputs, {report['output ports']} outputs\"\n", " )" ] }, { "cell_type": "markdown", "id": "community-realization-response-heading", "metadata": {}, "source": [ "## Define the Realization Objective\n", "\n", "For each device, the six source simulations are combined into an incident-normalized transmission matrix $T$ and reflection matrix $R$. The first two transmission matrices are 6 × 6, and the final transmission matrix is 4 × 6. Reflection remains 6 × 6 for all three devices.\n", "\n", "$$\n", "L_k=\n", "\\left\\|T-T_{\\mathrm{target}}\\right\\|_F\n", "+\\left\\|R\\right\\|_F\n", "+w_kL_{\\mathrm{fab}}.\n", "$$\n", "\n", "The first term matches both the amplitude and phase of the target transmission matrix. The second suppresses light reflected toward the input ports. The fabrication term penalizes solid and void features below 200 nm.\n", "\n", "The fabrication weight $w_k$ is zero for updates 1–5, increases from 0.08 at update 6 to 0.8 at update 15, and remains at 0.8 afterward.\n" ] }, { "cell_type": "code", "execution_count": 31, "id": "community-realization-response", "metadata": {}, "outputs": [], "source": [ "def smatrix_element(smatrix, port_out, port_in):\n", " value = (\n", " smatrix.sel(\n", " port_out=port_out,\n", " mode_index_out=0,\n", " port_in=port_in,\n", " mode_index_in=0,\n", " )\n", " .sel(f=FREQ0_HZ, method=\"nearest\")\n", " .data\n", " )\n", " return value.item() if np.ndim(value) == 0 else anp.squeeze(value)\n", "\n", "\n", "def response_from_batch(batch_data, layer):\n", " modeler = NATIVE_MODELERS[layer]\n", " native_batch = {\n", " native_name: batch_data[actual_name]\n", " for native_name, actual_name in zip(NATIVE_TASK_NAMES[layer], batch_data)\n", " }\n", " modeler_data = compose_modeler_data_from_batch_data(\n", " modeler=modeler, batch_data=native_batch\n", " )\n", " smatrix = modeler_data.smatrix()\n", " transmissions, reflections = [], []\n", " for input_name in INPUT_NAMES:\n", " port = modeler.get_port_by_name(port_name=input_name)\n", " task_name = modeler.get_task_name(port=port, mode_index=0)\n", " incident = modeler._normalization_factor(port, modeler_data.data[task_name])\n", " incident_value = np.asarray(getval(incident))\n", " if not np.all(np.isfinite(incident_value)) or np.any(\n", " np.abs(incident_value) == 0\n", " ):\n", " raise ValueError(\n", " f\"Invalid incident amplitude for {input_name}: {incident_value}\"\n", " )\n", " transmissions.append(\n", " anp.stack(\n", " [\n", " smatrix_element(smatrix, output_name, input_name)\n", " for output_name in output_names(LAYER_OUTPUT_COUNTS[layer])\n", " ]\n", " )\n", " )\n", " reflections.append(\n", " anp.stack(\n", " [\n", " smatrix_element(smatrix, reflected_name, input_name)\n", " for reflected_name in INPUT_NAMES\n", " ]\n", " )\n", " )\n", " return anp.stack(transmissions, axis=1), anp.stack(reflections, axis=1)\n", "\n", "\n", "def frobenius_norm(values):\n", " return anp.sqrt(anp.sum(anp.real(values * anp.conj(values))) + 1e-30)\n", "\n", "\n", "def postprocess(layer, target):\n", " target = anp.asarray(target)\n", "\n", " def realization_score(batch_data):\n", " transmission, reflection = response_from_batch(batch_data, layer)\n", " transmission_error = frobenius_norm(transmission - target)\n", " reflection_error = frobenius_norm(reflection)\n", " constrained_optical_loss = (\n", " transmission_error + REFLECTION_WEIGHT * reflection_error\n", " )\n", " return -constrained_optical_loss\n", "\n", " return realization_score" ] }, { "cell_type": "markdown", "id": "community-39", "metadata": {}, "source": [ "## Estimate Cloud Cost\n", "\n", "Before starting the inverse design, we estimate the cost of all six source simulations for each device. The cell uploads each simulation for pricing, records its estimated forward cost, and then deletes the estimate-only task.\n", "\n", "An optimization update requires both forward and adjoint simulations, so the projected cost is twice the forward cost multiplied by the requested number of updates. The notebook reports the estimate for each layer and for the complete realization schedule.\n", "\n", "Set `ESTIMATE_COST=True` in a fresh kernel to calculate the estimate. Running the optimization also requires explicit approval through `COST_APPROVED=True` and `RUN_CLOUD=True`.\n" ] }, { "cell_type": "code", "execution_count": 32, "id": "community-40", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Cost estimation is disabled.\n" ] } ], "source": [ "cost_report = None\n", "if ESTIMATE_COST and matrix_training_ready:\n", " layers = []\n", " for layer, design in designs.items():\n", " simulations = design.to_simulation(design.design_region.initial_parameters)\n", " forward_costs = []\n", " for task_name, simulation in sorted(simulations.items()):\n", " task_id = web.upload(\n", " simulation,\n", " task_name=f\"layer_{layer + 1}_{task_name}_cost\",\n", " folder_name=\"deep_inverse_designed_pnn_cost\",\n", " )\n", " forward_costs.append(float(web.estimate_cost(task_id)))\n", " web.delete(task_id)\n", " forward_batch = sum(forward_costs)\n", " layers.append(\n", " {\n", " \"layer\": layer + 1,\n", " \"sources\": len(simulations),\n", " \"forward FlexCredits\": forward_batch,\n", " \"projected FlexCredits\": 2 * forward_batch * REALIZATION_STEPS,\n", " }\n", " )\n", " projected_per_mode = sum(layer[\"projected FlexCredits\"] for layer in layers)\n", " cost_report = {\n", " \"mode\": REALIZATION_MODE,\n", " \"validation modes\": COST_ESTIMATE_MODES,\n", " \"steps per layer\": REALIZATION_STEPS,\n", " \"layers\": layers,\n", " \"projected FlexCredits per mode\": projected_per_mode,\n", " \"projected FlexCredits\": len(COST_ESTIMATE_MODES) * projected_per_mode,\n", " }\n", " cost_lines = [\n", " f\"Layer {layer['layer']}: {layer['forward FlexCredits']:.4f} forward, \"\n", " f\"{layer['projected FlexCredits']:.4f} projected FlexCredits\"\n", " for layer in layers\n", " ]\n", " cost_lines.append(f\"Projected per mode: {projected_per_mode:.4f} FlexCredits\")\n", " cost_lines.append(\n", " f\"Projected {len(COST_ESTIMATE_MODES)}-mode total: \"\n", " f\"{cost_report['projected FlexCredits']:.4f} FlexCredits\"\n", " )\n", " print(\"\\n\".join(cost_lines))\n", "elif ESTIMATE_COST:\n", " print(\n", " \"Cost estimation is closed until the trained matrices pass the required checks.\"\n", " )\n", "else:\n", " print(\"Cost estimation is disabled.\")" ] }, { "cell_type": "markdown", "id": "community-41", "metadata": {}, "source": [ "\n", "## Run the Inverse Design\n", "\n", "Adam updates the continuous material parameters by maximizing $-L_k$. The learning rate follows\n", "\n", "$$\n", "\\eta_k=0.05\\min\\left(\\frac{k}{5},1\\right),\n", "$$\n", "\n", "so it increases from 0.01 to 0.05 over the first five updates. After each update, the parameters are clipped to $[0,1]$ before the next filtered device is constructed.\n", "\n", "Each forward or adjoint batch submits one source simulation at a time. If a source remains queued for 600 seconds, the task is aborted and retried after 30 seconds without advancing Adam.\n", "\n", "The notebook saves the current parameters, transmission and reflection matrices, and Adam state after every update. This allows the optimization to continue from the same point after interruption. The displayed analysis uses a completed 40-update response for each of the three devices.\n" ] }, { "cell_type": "code", "execution_count": 33, "id": "community-queue-monitoring", "metadata": {}, "outputs": [], "source": [ "CLOUD_RUN_LABEL = \"deep_classifier\"\n", "optimizer_designs = {\n", " layer: designs[layer].updated_copy(task_name=f\"{CLOUD_RUN_LABEL}_layer_{layer + 1}\")\n", " for layer in range(N_LAYERS)\n", "}\n", "\n", "EXPECTED_TIDY3D_RETRY_VERSION = \"2.12.0\"\n", "ACTIVE_QUEUE_CONTEXT = {\"layer\": None, \"update\": None, \"job\": None}\n", "queue_retry_records = []\n", "if QUEUE_RETRY_LOG_PATH.exists():\n", " saved_retry_log = json.loads(QUEUE_RETRY_LOG_PATH.read_text())\n", " if saved_retry_log.get(\"policy\") != QUEUE_RETRY_POLICY:\n", " raise ValueError(\"Saved queue-retry policy does not match this notebook.\")\n", " queue_retry_records = list(saved_retry_log.get(\"records\", []))\n", "\n", "\n", "class SourceQueueTimeout(RuntimeError):\n", " def __init__(self, queued_seconds):\n", " self.queued_seconds = float(queued_seconds)\n", " super().__init__(f\"source remained queued for {queued_seconds:.1f} seconds\")\n", "\n", "\n", "def validate_native_retry_hooks():\n", " if td.__version__ != EXPECTED_TIDY3D_RETRY_VERSION:\n", " raise RuntimeError(\n", " f\"Per-source retry requires Tidy3D {EXPECTED_TIDY3D_RETRY_VERSION}; \"\n", " f\"found {td.__version__}.\"\n", " )\n", " for name in (\"_run_async_tidy3d\", \"_run_async_tidy3d_bwd\"):\n", " function = getattr(autograd_hooks, name, None)\n", " parameters = inspect.signature(function).parameters if function else {}\n", " accepts_keywords = any(\n", " parameter.kind == inspect.Parameter.VAR_KEYWORD\n", " for parameter in parameters.values()\n", " )\n", " if \"simulations\" not in parameters or not accepts_keywords:\n", " raise RuntimeError(\n", " f\"Tidy3D autograd hook {name} has an unsupported signature.\"\n", " )\n", "\n", "\n", "def save_queue_retry_log():\n", " payload = {\n", " \"policy\": QUEUE_RETRY_POLICY,\n", " \"source chunk size\": AUTOGRAD_SOURCE_CHUNK_SIZE,\n", " \"queue timeout seconds\": QUEUE_TIMEOUT_SECONDS,\n", " \"retry delay seconds\": QUEUE_RETRY_DELAY_SECONDS,\n", " \"records\": queue_retry_records,\n", " }\n", " temporary_path = QUEUE_RETRY_LOG_PATH.with_suffix(\".tmp\")\n", " temporary_path.write_text(json.dumps(payload, indent=2))\n", " temporary_path.replace(QUEUE_RETRY_LOG_PATH)\n", "\n", "\n", "def record_queue_wait(phase, source, queued_seconds, retried):\n", " identity = {\n", " \"layer\": int(ACTIVE_QUEUE_CONTEXT[\"layer\"]),\n", " \"update\": int(ACTIVE_QUEUE_CONTEXT[\"update\"]),\n", " \"source\": str(source),\n", " \"phase\": str(phase),\n", " }\n", " record = next(\n", " (\n", " item\n", " for item in queue_retry_records\n", " if all(item.get(key) == value for key, value in identity.items())\n", " ),\n", " None,\n", " )\n", " if record is None:\n", " record = {**identity, \"retry count\": 0, \"accumulated queue seconds\": 0.0}\n", " queue_retry_records.append(record)\n", " record[\"accumulated queue seconds\"] += float(queued_seconds)\n", " if retried:\n", " record[\"retry count\"] += 1\n", " save_queue_retry_log()\n", "\n", "\n", "def monitor_single_source(job, clock=time.monotonic, sleep=time.sleep):\n", " queued_started = None\n", " queued_seconds = 0.0\n", " while True:\n", " status = str(job.get_info().status).lower()\n", " now = float(clock())\n", " if status in web_states.QUEUED_STATES:\n", " if queued_started is None:\n", " queued_started = now\n", " current_queue_seconds = queued_seconds + now - queued_started\n", " if current_queue_seconds >= QUEUE_TIMEOUT_SECONDS:\n", " raise SourceQueueTimeout(current_queue_seconds)\n", " elif queued_started is not None:\n", " queued_seconds += now - queued_started\n", " queued_started = None\n", " if status in web_states.SUCCESS_STATES:\n", " return queued_seconds\n", " if status in web_states.ERROR_STATES or status in web_states.DIVERGED_STATES:\n", " raise RuntimeError(f\"Tidy3D source task ended with status {status!r}.\")\n", " sleep(QUEUE_POLL_SECONDS)\n", "\n", "\n", "def transient_web_error(error):\n", " text = str(error).lower()\n", " return any(\n", " fragment in text\n", " for fragment in (\n", " \"connection\",\n", " \"timeout\",\n", " \"timed out\",\n", " \"bad gateway\",\n", " \"service unavailable\",\n", " \"gateway timeout\",\n", " \"502\",\n", " \"503\",\n", " \"504\",\n", " )\n", " )\n", "\n", "\n", "def abort_source_job(job, wait):\n", " task_id = getattr(job, \"task_id\", None)\n", " if task_id is None:\n", " return\n", " while True:\n", " try:\n", " web.abort(task_id)\n", " break\n", " except (RequestsConnectionError, ReadTimeout, NewConnectionError):\n", " if not wait:\n", " return\n", " time.sleep(QUEUE_RETRY_DELAY_SECONDS)\n", " except WebError as error:\n", " if not transient_web_error(error):\n", " raise\n", " if not wait:\n", " return\n", " time.sleep(QUEUE_RETRY_DELAY_SECONDS)\n", " if wait:\n", " while True:\n", " try:\n", " if str(job.get_info().status).lower() in web_states.END_STATES:\n", " return\n", " time.sleep(QUEUE_POLL_SECONDS)\n", " except (RequestsConnectionError, ReadTimeout, NewConnectionError):\n", " time.sleep(QUEUE_RETRY_DELAY_SECONDS)\n", " except WebError as error:\n", " if not transient_web_error(error):\n", " raise\n", " time.sleep(QUEUE_RETRY_DELAY_SECONDS)\n", "\n", "\n", "def run_one_source_with_queue_retry(\n", " phase, source, make_batch, finish_batch, start_kwargs\n", "):\n", " while True:\n", " batch = None\n", " job = None\n", " try:\n", " batch = make_batch()\n", " job = next(iter(batch.jobs.values()))\n", " ACTIVE_QUEUE_CONTEXT[\"job\"] = job\n", " if not job.load_if_cached:\n", " batch.start(**start_kwargs)\n", " queued_seconds = monitor_single_source(job)\n", " else:\n", " queued_seconds = 0.0\n", " result = finish_batch(batch, job)\n", " record_queue_wait(phase, source, queued_seconds, retried=False)\n", " ACTIVE_QUEUE_CONTEXT[\"job\"] = None\n", " return result\n", " except SourceQueueTimeout as error:\n", " abort_source_job(job, wait=True)\n", " record_queue_wait(phase, source, error.queued_seconds, retried=True)\n", " print(\n", " f\"{phase} source {source} exceeded {QUEUE_TIMEOUT_SECONDS:g} queued \"\n", " f\"seconds; retrying only this source after {QUEUE_RETRY_DELAY_SECONDS:g} seconds.\"\n", " )\n", " time.sleep(QUEUE_RETRY_DELAY_SECONDS)\n", " except (RequestsConnectionError, ReadTimeout, NewConnectionError) as error:\n", " abort_source_job(job, wait=True)\n", " record_queue_wait(phase, source, 0.0, retried=True)\n", " print(f\"Temporary connection failure for {phase} source {source}: {error}\")\n", " time.sleep(QUEUE_RETRY_DELAY_SECONDS)\n", " except WebError as error:\n", " if not transient_web_error(error):\n", " raise\n", " abort_source_job(job, wait=True)\n", " record_queue_wait(phase, source, 0.0, retried=True)\n", " print(f\"Temporary web failure for {phase} source {source}: {error}\")\n", " time.sleep(QUEUE_RETRY_DELAY_SECONDS)\n", " except KeyboardInterrupt:\n", " abort_source_job(job, wait=False)\n", " raise\n", " finally:\n", " ACTIVE_QUEUE_CONTEXT[\"job\"] = None" ] }, { "cell_type": "code", "execution_count": 34, "id": "community-autograd-hooks", "metadata": {}, "outputs": [], "source": [ "def queue_aware_forward_hook(simulations, **run_kwargs):\n", " if len(simulations) != 1:\n", " raise RuntimeError(\"Per-source retry received more than one forward source.\")\n", " source = next(iter(simulations))\n", " base_kwargs = dict(run_kwargs)\n", " disable_result_cache = base_kwargs.pop(\"disable_result_cache\", False)\n", " path_dir = Path(base_kwargs.pop(\"path_dir\", \".\"))\n", " path_dir.mkdir(parents=True, exist_ok=True)\n", " priority = base_kwargs.get(\"priority\")\n", " vgpu_allocation = base_kwargs.get(\"vgpu_allocation\")\n", " ignore_memory_limit = base_kwargs.get(\"ignore_memory_limit\")\n", " start_kwargs = {\n", " \"priority\": priority,\n", " \"vgpu_allocation\": vgpu_allocation,\n", " \"ignore_memory_limit\": ignore_memory_limit,\n", " }\n", "\n", " def make_batch():\n", " batch_kwargs = autograd_engine.parse_run_kwargs(**base_kwargs)\n", " batch = autograd_engine._build_batch(\n", " simulations=simulations,\n", " num_workers=base_kwargs.get(\"num_workers\"),\n", " **batch_kwargs,\n", " )\n", " if disable_result_cache:\n", " batch = autograd_engine._with_result_cache_disabled(batch)\n", " if batch.simulation_type == \"autograd_fwd\":\n", " prepared = {\n", " name: simulation.updated_copy(\n", " simulation_type=\"autograd_fwd\", deep=False\n", " )\n", " for name, simulation in batch.simulations.items()\n", " }\n", " batch = batch.updated_copy(simulations=prepared)\n", " artifacts = {\n", " name: autograd_engine._sim_fields_keys_artifacts(keys)\n", " for name, keys in base_kwargs[\"sim_fields_keys_dict\"].items()\n", " }\n", " batch._upload_jobs(_sidecar_artifacts_by_task=artifacts)\n", " else:\n", " batch.upload()\n", " return batch\n", "\n", " def finish_batch(batch, job):\n", " batch.download(path_dir=path_dir)\n", " batch_data = batch.load(path_dir=path_dir, skip_download=True)\n", " task_ids = getattr(batch_data, \"task_ids\", None)\n", " return batch_data, (\n", " dict(task_ids) if task_ids is not None else {source: job.task_id}\n", " )\n", "\n", " return run_one_source_with_queue_retry(\n", " \"forward\",\n", " source,\n", " make_batch,\n", " finish_batch,\n", " start_kwargs,\n", " )\n", "\n", "\n", "def queue_aware_backward_hook(simulations, **run_kwargs):\n", " verbose = run_kwargs.get(\"verbose\", True)\n", " cached = {\n", " name: value\n", " for name, simulation in simulations.items()\n", " if (value := get_cached_vjp_traced_fields(simulation, verbose=verbose))\n", " is not None\n", " }\n", " remaining = {\n", " name: simulation\n", " for name, simulation in simulations.items()\n", " if name not in cached\n", " }\n", " if not remaining:\n", " return cached\n", " if len(remaining) != 1:\n", " raise RuntimeError(\"Per-source retry received more than one adjoint source.\")\n", " source = next(iter(remaining))\n", " base_kwargs = dict(run_kwargs)\n", " base_kwargs.pop(\"path_dir\", None)\n", " priority = base_kwargs.get(\"priority\")\n", " vgpu_allocation = base_kwargs.get(\"vgpu_allocation\")\n", " ignore_memory_limit = base_kwargs.get(\"ignore_memory_limit\")\n", " start_kwargs = {\n", " \"priority\": priority,\n", " \"vgpu_allocation\": vgpu_allocation,\n", " \"ignore_memory_limit\": ignore_memory_limit,\n", " }\n", "\n", " def make_batch():\n", " batch_kwargs = autograd_engine.parse_run_kwargs(**base_kwargs)\n", " batch = autograd_engine._build_batch(\n", " simulations=remaining,\n", " num_workers=base_kwargs.get(\"num_workers\"),\n", " **batch_kwargs,\n", " )\n", " return autograd_engine._with_result_cache_disabled(batch)\n", "\n", " def finish_batch(batch, job):\n", " return {\n", " **cached,\n", " source: get_vjp_traced_fields(\n", " task_id_adj=job.task_id,\n", " verbose=batch.verbose,\n", " cache_simulation=job.simulation,\n", " ),\n", " }\n", "\n", " return run_one_source_with_queue_retry(\n", " \"adjoint\",\n", " source,\n", " make_batch,\n", " finish_batch,\n", " start_kwargs,\n", " )\n", "\n", "\n", "@contextmanager\n", "def native_source_queue_retry(layer, update_number):\n", " validate_native_retry_hooks()\n", " original_forward = autograd_hooks._run_async_tidy3d\n", " original_backward = autograd_hooks._run_async_tidy3d_bwd\n", " ACTIVE_QUEUE_CONTEXT.update(\n", " layer=int(layer) + 1,\n", " update=int(update_number),\n", " job=None,\n", " )\n", " autograd_hooks._run_async_tidy3d = queue_aware_forward_hook\n", " autograd_hooks._run_async_tidy3d_bwd = queue_aware_backward_hook\n", " try:\n", " yield\n", " finally:\n", " active_job = ACTIVE_QUEUE_CONTEXT.get(\"job\")\n", " if active_job is not None:\n", " abort_source_job(active_job, wait=False)\n", " autograd_hooks._run_async_tidy3d = original_forward\n", " autograd_hooks._run_async_tidy3d_bwd = original_backward\n", " ACTIVE_QUEUE_CONTEXT.update(layer=None, update=None, job=None)\n", "\n", "\n", "if RUN_CLOUD:\n", " validate_native_retry_hooks()" ] }, { "cell_type": "code", "execution_count": 35, "id": "community-realization-optimizer", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "optimizer direction: gradient_ascent_on_negative_constrained_loss alignment: 640.0899935992227\n" ] } ], "source": [ "class ClippedAdamAscentOptimizer(tdi.AdamOptimizer):\n", " def initial_state(self, parameters):\n", " return super().initial_state(anp.clip(parameters, 0.0, 1.0))\n", "\n", " def update(self, parameters, gradient, state=None):\n", " parameters = anp.clip(parameters, 0.0, 1.0)\n", " updated, new_state = super().update(parameters, gradient, state)\n", " return anp.clip(updated, 0.0, 1.0), new_state\n", "\n", "\n", "def optimizer_for_update(layer, update_number):\n", " penalty_weight = fabrication_penalty_weight(update_number)\n", " penalties = (fabrication_penalty(penalty_weight),) if penalty_weight > 0 else ()\n", " scheduled_region = optimizer_designs[layer].design_region.updated_copy(\n", " penalties=penalties\n", " )\n", " scheduled_design = optimizer_designs[layer].updated_copy(\n", " design_region=scheduled_region\n", " )\n", " return ClippedAdamAscentOptimizer(\n", " design=scheduled_design,\n", " learning_rate=tidy3d_learning_rate(update_number),\n", " maximize=True,\n", " beta1=TIDY3D_BETA1,\n", " beta2=TIDY3D_BETA2,\n", " eps=TIDY3D_EPS,\n", " num_steps=REALIZATION_STEPS,\n", " store_full_results=True,\n", " results_cache_fname=None,\n", " )\n", "\n", "\n", "optimizers = {layer: optimizer_for_update(layer, 1) for layer in range(N_LAYERS)}\n", "ascent_probe = np.full(designs[0].design_region.params_shape, 0.5)\n", "ascent_gradient = np.ones_like(ascent_probe)\n", "ascent_state = optimizers[0].initial_state(ascent_probe)\n", "ascent_updated, ascent_state = optimizers[0].update(\n", " ascent_probe, gradient=-ascent_gradient, state=ascent_state\n", ")\n", "ascent_alignment = float(\n", " np.vdot(ascent_gradient.ravel(), (ascent_updated - ascent_probe).ravel()).real\n", ")\n", "if ascent_alignment <= 0:\n", " raise ValueError(\"Adam update is not aligned with score-gradient ascent.\")\n", "print(\"optimizer direction:\", OPTIMIZER_DIRECTION, \"alignment:\", ascent_alignment)\n", "unit_fabrication_penalty = fabrication_penalty(weight=1.0)\n", "\n", "max_realization_steps = max(REALIZATION_STEPS, 1)\n", "matrix_history_shape = (\n", " max_realization_steps,\n", " N_LAYERS,\n", " max(LAYER_OUTPUT_COUNTS),\n", " N_CHANNELS,\n", ")\n", "metric_history_shape = (max_realization_steps, N_LAYERS)" ] }, { "cell_type": "code", "execution_count": 36, "id": "community-progress-state", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "loaded cache: [40, 40, 40] updates\n" ] } ], "source": [ "transmission_history = np.full(matrix_history_shape, np.nan + 0j)\n", "reflection_history = np.full(matrix_history_shape, np.nan + 0j)\n", "transmission_error_history = np.full(metric_history_shape, np.nan)\n", "reflection_error_history = np.full(metric_history_shape, np.nan)\n", "realization_loss_history = np.full(metric_history_shape, np.nan)\n", "learning_rate_history = np.full(metric_history_shape, np.nan)\n", "fabrication_weight_history = np.full(metric_history_shape, np.nan)\n", "fabrication_penalty_history = np.full(metric_history_shape, np.nan)\n", "weighted_fabrication_penalty_history = np.full(metric_history_shape, np.nan)\n", "scheduled_constrained_loss_history = np.full(metric_history_shape, np.nan)\n", "fixed_reference_loss_history = np.full(metric_history_shape, np.nan)\n", "test_accuracy_history = np.full(metric_history_shape, np.nan)\n", "latest_parameters = np.stack(\n", " [\n", " np.asarray(designs[layer].design_region.initial_parameters)\n", " for layer in range(N_LAYERS)\n", " ]\n", ")\n", "latest_adam_m = np.zeros_like(latest_parameters)\n", "latest_adam_v = np.zeros_like(latest_parameters)\n", "latest_adam_t = np.zeros(N_LAYERS, dtype=int)\n", "response_steps = np.full(N_LAYERS, -1, dtype=int)\n", "completed_steps = np.zeros(N_LAYERS, dtype=int)\n", "optimization_run_summary = {}\n", "CACHE_CAN_CONTINUE = True\n", "\n", "history_names = (\n", " \"transmission_history\",\n", " \"reflection_history\",\n", " \"transmission_error_history\",\n", " \"reflection_error_history\",\n", " \"realization_loss_history\",\n", " \"learning_rate_history\",\n", " \"fabrication_weight_history\",\n", " \"fabrication_penalty_history\",\n", " \"weighted_fabrication_penalty_history\",\n", " \"scheduled_constrained_loss_history\",\n", " \"fixed_reference_loss_history\",\n", " \"test_accuracy_history\",\n", ")\n", "\n", "if PROGRESS_PATH.exists():\n", " with np.load(PROGRESS_PATH, allow_pickle=False) as progress:\n", " required = set(history_names) | {\n", " \"latest_parameters\",\n", " \"latest_adam_m\",\n", " \"latest_adam_v\",\n", " \"latest_adam_t\",\n", " \"response_steps\",\n", " \"completed_steps\",\n", " \"n_channels\",\n", " \"n_splitter_leaves\",\n", " \"class_labels\",\n", " \"preprocessing_tag\",\n", " \"realization_target_tag\",\n", " \"layer_input_counts\",\n", " \"layer_output_counts\",\n", " }\n", " missing = required.difference(progress.files)\n", " if missing:\n", " raise ValueError(f\"Progress cache is missing {sorted(missing)}.\")\n", " identity_checks = (\n", " int(progress[\"n_channels\"]) == N_CHANNELS,\n", " int(progress[\"n_splitter_leaves\"]) == N_SPLITTER_LEAVES,\n", " np.array_equal(progress[\"class_labels\"], CLASS_LABELS),\n", " str(progress[\"preprocessing_tag\"]) == PREPROCESSING_TAG,\n", " str(progress[\"realization_target_tag\"]) == REALIZATION_TARGET_TAG,\n", " np.array_equal(progress[\"layer_input_counts\"], LAYER_INPUT_COUNTS),\n", " np.array_equal(progress[\"layer_output_counts\"], LAYER_OUTPUT_COUNTS),\n", " )\n", " if not all(identity_checks):\n", " raise ValueError(\"Progress cache does not match this classifier.\")\n", "\n", " for name in history_names:\n", " globals()[name] = np.asarray(progress[name])\n", " latest_parameters = np.asarray(progress[\"latest_parameters\"])\n", " latest_adam_m = np.asarray(progress[\"latest_adam_m\"])\n", " latest_adam_v = np.asarray(progress[\"latest_adam_v\"])\n", " latest_adam_t = np.asarray(progress[\"latest_adam_t\"], dtype=int)\n", " response_steps = np.asarray(progress[\"response_steps\"], dtype=int)\n", " completed_steps = np.asarray(progress[\"completed_steps\"], dtype=int)\n", " CACHE_CAN_CONTINUE = (\n", " bool(progress[\"continuation_allowed\"])\n", " if \"continuation_allowed\" in progress.files\n", " else True\n", " )\n", "\n", " if completed_steps.shape != (N_LAYERS,) or not np.array_equal(\n", " completed_steps, latest_adam_t\n", " ):\n", " raise ValueError(\"Cached Adam steps do not match completed updates.\")\n", " if (\n", " RUN_CLOUD\n", " and np.any(completed_steps < REALIZATION_STEPS)\n", " and not CACHE_CAN_CONTINUE\n", " ):\n", " raise ValueError(\n", " \"This completed-data cache is analysis-only and cannot be resumed.\"\n", " )\n", " print(f\"loaded cache: {completed_steps.tolist()} updates\")\n", "\n", "history_extension = max(0, REALIZATION_STEPS - len(test_accuracy_history))\n", "if history_extension:\n", " matrix_padding = ((0, history_extension), (0, 0), (0, 0), (0, 0))\n", " metric_padding = ((0, history_extension), (0, 0))\n", " transmission_history = np.pad(\n", " transmission_history, matrix_padding, constant_values=np.nan\n", " )\n", " reflection_history = np.pad(\n", " reflection_history, matrix_padding, constant_values=np.nan\n", " )\n", " for name in history_names[2:-1]:\n", " globals()[name] = np.pad(\n", " globals()[name], metric_padding, constant_values=np.nan\n", " )\n", " test_accuracy_history = np.pad(\n", " test_accuracy_history,\n", " ((0, history_extension), (0, 0)),\n", " constant_values=np.nan,\n", " )\n", "max_realization_steps = len(test_accuracy_history)" ] }, { "cell_type": "code", "execution_count": 37, "id": "community-checkpoint-load", "metadata": {}, "outputs": [], "source": [ "def result_from_progress(layer):\n", " base = optimizers[layer].initialize_result()\n", " steps = int(latest_adam_t[layer])\n", " parameters = np.asarray(latest_parameters[layer])\n", " state = {\n", " \"m\": np.asarray(latest_adam_m[layer]),\n", " \"v\": np.asarray(latest_adam_v[layer]),\n", " \"t\": steps,\n", " }\n", " history = {key: list(value) for key, value in base.history.items()}\n", " history[\"params\"] = [base.get_last(\"params\")] + [parameters] * steps\n", " history[\"opt_state\"] = [base.get_last(\"opt_state\")] + [state] * steps\n", " history[\"grad\"] = [np.zeros_like(parameters)] * steps\n", " history[\"objective_fn_val\"] = list(\n", " -scheduled_constrained_loss_history[:steps, layer]\n", " )\n", " history[\"penalty\"] = list(weighted_fabrication_penalty_history[:steps, layer])\n", " history[\"post_process_val\"] = list(-realization_loss_history[:steps, layer])\n", " return tdi.InverseDesignResult(design=base.design, **history)\n", "\n", "\n", "cloud_results = {}\n", "for layer in range(N_LAYERS):\n", " if optimizer_state_paths[layer].exists():\n", " try:\n", " cloud_results[layer] = tdi.InverseDesignResult.from_file(\n", " str(optimizer_state_paths[layer])\n", " )\n", " except OSError:\n", " if latest_adam_t[layer] == 0:\n", " raise\n", " cloud_results[layer] = result_from_progress(layer)\n", " elif latest_adam_t[layer] > 0:\n", " cloud_results[layer] = result_from_progress(layer)\n", " else:\n", " cloud_results[layer] = optimizers[layer].initialize_result()\n", " completed_steps[layer] = len(cloud_results[layer].objective_fn_val)\n", " adam_update = int(cloud_results[layer].get_last(\"opt_state\")[\"t\"])\n", " if adam_update != completed_steps[layer]:\n", " raise ValueError(\n", " f\"Layer {layer + 1} Adam state t={adam_update} does not match \"\n", " f\"its {completed_steps[layer]} completed objective evaluations.\"\n", " )\n", "optimizer_forward = {\n", " layer: {\n", " \"transmission\": transmission_history[\n", " response_steps[layer], layer, : LAYER_OUTPUT_COUNTS[layer]\n", " ],\n", " \"reflection\": reflection_history[response_steps[layer], layer],\n", " \"params\": latest_parameters[layer],\n", " \"step\": int(response_steps[layer]),\n", " }\n", " for layer in range(N_LAYERS)\n", " if response_steps[layer] >= 0\n", "}" ] }, { "cell_type": "code", "execution_count": 38, "id": "community-realization-progress", "metadata": {}, "outputs": [], "source": [ "def save_realization_progress():\n", " buffer = io.BytesIO()\n", " np.savez_compressed(\n", " buffer,\n", " transmission_history=transmission_history,\n", " reflection_history=reflection_history,\n", " transmission_error_history=transmission_error_history,\n", " reflection_error_history=reflection_error_history,\n", " realization_loss_history=realization_loss_history,\n", " learning_rate_history=learning_rate_history,\n", " fabrication_weight_history=fabrication_weight_history,\n", " fabrication_penalty_history=fabrication_penalty_history,\n", " weighted_fabrication_penalty_history=weighted_fabrication_penalty_history,\n", " scheduled_constrained_loss_history=scheduled_constrained_loss_history,\n", " fixed_reference_loss_history=fixed_reference_loss_history,\n", " test_accuracy_history=test_accuracy_history,\n", " latest_parameters=latest_parameters,\n", " latest_adam_m=latest_adam_m,\n", " latest_adam_v=latest_adam_v,\n", " latest_adam_t=latest_adam_t,\n", " response_steps=response_steps,\n", " completed_steps=completed_steps,\n", " realization_objective=np.asarray(REALIZATION_OBJECTIVE),\n", " realization_mode=np.asarray(REALIZATION_MODE),\n", " requested_steps_per_layer=np.asarray(REALIZATION_STEPS),\n", " n_channels=np.asarray(N_CHANNELS),\n", " n_splitter_leaves=np.asarray(N_SPLITTER_LEAVES),\n", " active_leaf_indices=np.asarray(ACTIVE_LEAF_INDICES),\n", " dump_leaf_indices=np.asarray(DUMP_LEAF_INDICES),\n", " class_labels=np.asarray(CLASS_LABELS),\n", " preprocessing_tag=np.asarray(PREPROCESSING_TAG),\n", " fanout_rule=np.asarray(FANOUT_RULE),\n", " terminator_model=np.asarray(TERMINATOR_MODEL),\n", " ideal_active_power_fraction=np.asarray(IDEAL_ACTIVE_POWER_FRACTION),\n", " terminator_reflection=np.asarray(TERMINATOR_REFLECTION),\n", " design_um_per_channel=np.asarray(DESIGN_UM_PER_CHANNEL),\n", " design_edge_um=np.asarray(DESIGN_EDGE_UM),\n", " port_pitch_um=np.asarray(PORT_PITCH),\n", " mode_window_um=np.asarray(MODE_WINDOW),\n", " rail_thickness_um=np.asarray(RAIL_THICKNESS),\n", " rail_inner_overlap_um=np.asarray(RAIL_INNER_OVERLAP),\n", " taper_overlap_um=np.asarray(TAPER_OVERLAP),\n", " simulation_architecture=np.asarray(SIMULATION_ARCHITECTURE),\n", " cladding_model=np.asarray(CLADDING_MODEL),\n", " background_index=np.asarray(N_EFF_TE_BACKGROUND),\n", " optimizer_direction=np.asarray(OPTIMIZER_DIRECTION),\n", " active_mask_rule=np.asarray(ACTIVE_MASK_RULE),\n", " realization_target_tag=np.asarray(REALIZATION_TARGET_TAG),\n", " layer_input_counts=np.asarray(LAYER_INPUT_COUNTS),\n", " layer_output_counts=np.asarray(LAYER_OUTPUT_COUNTS),\n", " queue_retry_policy=np.asarray(QUEUE_RETRY_POLICY),\n", " autograd_source_chunk_size=np.asarray(AUTOGRAD_SOURCE_CHUNK_SIZE),\n", " queue_timeout_seconds=np.asarray(QUEUE_TIMEOUT_SECONDS),\n", " queue_retry_delay_seconds=np.asarray(QUEUE_RETRY_DELAY_SECONDS),\n", " tidy3d_lr_max=np.asarray(TIDY3D_LR_MAX),\n", " tidy3d_lr_warmup_updates=np.asarray(TIDY3D_LR_WARMUP_UPDATES),\n", " fabrication_min_feature_um=np.asarray(FABRICATION_MIN_FEATURE_UM),\n", " fabrication_weight_max=np.asarray(FABRICATION_WEIGHT_MAX),\n", " fabrication_start_update=np.asarray(FABRICATION_START_UPDATE),\n", " fabrication_full_update=np.asarray(FABRICATION_FULL_UPDATE),\n", " fabrication_beta=np.asarray(FABRICATION_BETA),\n", " fabrication_eta0=np.asarray(FABRICATION_ETA0),\n", " fabrication_delta_eta=np.asarray(FABRICATION_DELTA_ETA),\n", " continuation_allowed=np.asarray(True),\n", " )\n", " temporary_path = PROGRESS_PATH.with_suffix(\".tmp\")\n", " temporary_path.write_bytes(buffer.getvalue())\n", " temporary_path.replace(PROGRESS_PATH)" ] }, { "cell_type": "code", "execution_count": 39, "id": "deep-realization-update", "metadata": {}, "outputs": [], "source": [ "def keep_optimizer_forward(layer):\n", " def callback(result, step_index, aux_data):\n", " transmission, reflection = response_from_batch(aux_data[\"sim_data\"], layer)\n", " transmission, reflection = np.asarray(transmission), np.asarray(reflection)\n", " step_index = int(step_index)\n", " update_number = step_index + 1\n", " transmission_history[step_index, layer] = np.nan + 0j\n", " transmission_history[step_index, layer, : LAYER_OUTPUT_COUNTS[layer]] = (\n", " transmission\n", " )\n", " reflection_history[step_index, layer] = reflection\n", " transmission_error_history[step_index, layer] = np.linalg.norm(\n", " transmission - targets[layer]\n", " )\n", " reflection_error_history[step_index, layer] = np.linalg.norm(reflection)\n", " realization_loss_history[step_index, layer] = (\n", " transmission_error_history[step_index, layer]\n", " + REFLECTION_WEIGHT * reflection_error_history[step_index, layer]\n", " )\n", " learning_rate_history[step_index, layer] = tidy3d_learning_rate(update_number)\n", " fabrication_weight_history[step_index, layer] = fabrication_penalty_weight(\n", " update_number\n", " )\n", " latest_parameters[layer] = np.asarray(getval(aux_data[\"params\"]))\n", " material_density = np.asarray(\n", " designs[layer].design_region.material_density(latest_parameters[layer])\n", " )\n", " fabrication_penalty_history[step_index, layer] = float(\n", " unit_fabrication_penalty.evaluate(material_density, PIXEL)\n", " )\n", " weighted_fabrication_penalty_history[step_index, layer] = float(\n", " result.penalty[-1]\n", " )\n", " scheduled_constrained_loss_history[step_index, layer] = (\n", " realization_loss_history[step_index, layer]\n", " + weighted_fabrication_penalty_history[step_index, layer]\n", " )\n", " fixed_reference_loss_history[step_index, layer] = (\n", " realization_loss_history[step_index, layer]\n", " + FABRICATION_WEIGHT_MAX * fabrication_penalty_history[step_index, layer]\n", " )\n", " response_steps[layer] = step_index\n", " optimizer_forward[layer] = {\n", " \"transmission\": transmission,\n", " \"reflection\": reflection,\n", " \"params\": latest_parameters[layer],\n", " \"step\": step_index,\n", " \"learning_rate\": learning_rate_history[step_index, layer],\n", " \"fabrication_weight\": fabrication_weight_history[step_index, layer],\n", " }\n", " completed_steps[layer] = len(result.objective_fn_val)\n", " latest_state = result.get_last(\"opt_state\")\n", " latest_adam_m[layer] = np.asarray(latest_state[\"m\"])\n", " latest_adam_v[layer] = np.asarray(latest_state[\"v\"])\n", " latest_adam_t[layer] = int(latest_state[\"t\"])\n", " save_realization_progress()\n", " checkpoint_path = optimizer_state_paths[layer]\n", " temporary_checkpoint = checkpoint_path.with_name(\n", " checkpoint_path.stem + \".tmp.hdf5\"\n", " )\n", " result.to_file(str(temporary_checkpoint))\n", " temporary_checkpoint.replace(checkpoint_path)\n", "\n", " return callback\n", "\n", "\n", "def uncalibrated_test_accuracy(matrices):\n", " fields = physical_forward(matrices, jnp.asarray(test_features))\n", " scores = jnp.abs(fields) ** 2\n", " return float(jnp.mean(jnp.argmax(scores, axis=-1) == jnp.asarray(test_labels)))\n", "\n", "\n", "def latest_network_matrices():\n", " return tuple(\n", " optimizer_forward[layer][\"transmission\"]\n", " if layer in optimizer_forward\n", " else targets[layer]\n", " for layer in range(N_LAYERS)\n", " )\n", "\n", "\n", "def advance_layer(layer, local_step):\n", " done_steps = len(cloud_results[layer].objective_fn_val)\n", " if done_steps <= local_step and done_steps < REALIZATION_STEPS:\n", " update_number = done_steps + 1\n", " step_optimizer = optimizer_for_update(layer, update_number)\n", " cloud_results[layer] = cloud_results[layer].updated_copy(\n", " design=step_optimizer.design\n", " )\n", " with native_source_queue_retry(layer, update_number):\n", " cloud_results[layer] = step_optimizer.continue_run(\n", " result=cloud_results[layer],\n", " num_steps=1,\n", " post_process_fn=postprocess(layer, targets[layer]),\n", " callback=keep_optimizer_forward(layer),\n", " )\n", " completed_steps[layer] = len(cloud_results[layer].objective_fn_val)\n", " adam_update = int(cloud_results[layer].get_last(\"opt_state\")[\"t\"])\n", " if adam_update != completed_steps[layer]:\n", " raise ValueError(\n", " f\"Layer {layer + 1} Adam state reset at update {update_number}.\"\n", " )\n", " save_realization_progress()" ] }, { "cell_type": "code", "execution_count": 40, "id": "deep-cloud-loop", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Cloud optimization is disabled.\n" ] } ], "source": [ "needs_cloud_updates = bool(np.any(completed_steps < REALIZATION_STEPS))\n", "if (\n", " RUN_CLOUD\n", " and needs_cloud_updates\n", " and COST_APPROVED\n", " and matrix_training_ready\n", " and cost_report is not None\n", "):\n", " if REALIZATION_MODE == \"sequential\":\n", " for layer in range(N_LAYERS):\n", " for local_step in range(REALIZATION_STEPS):\n", " advance_layer(layer, local_step)\n", " if response_steps[layer] >= local_step and not np.isfinite(\n", " test_accuracy_history[local_step, layer]\n", " ):\n", " test_accuracy_history[local_step, layer] = (\n", " uncalibrated_test_accuracy(latest_network_matrices())\n", " )\n", " print(\n", " f\"layer {layer + 1}, iteration {local_step + 1:2d}: \"\n", " f\"optical loss={realization_loss_history[local_step, layer]:.6e}, \"\n", " f\"fabrication={fabrication_penalty_history[local_step, layer]:.6e}, \"\n", " f\"constrained={scheduled_constrained_loss_history[local_step, layer]:.6e}, \"\n", " f\"test accuracy={test_accuracy_history[local_step, layer]:.3%}\"\n", " )\n", " save_realization_progress()\n", " else:\n", " for global_step in range(REALIZATION_STEPS):\n", " for layer in range(N_LAYERS):\n", " advance_layer(layer, global_step)\n", " available = np.all(np.isfinite(transmission_error_history[global_step]))\n", " if available and not np.isfinite(test_accuracy_history[global_step, 0]):\n", " synchronized_matrices = tuple(\n", " transmission_history[\n", " global_step, layer, : LAYER_OUTPUT_COUNTS[layer]\n", " ]\n", " for layer in range(N_LAYERS)\n", " )\n", " test_accuracy_history[global_step, 0] = uncalibrated_test_accuracy(\n", " synchronized_matrices\n", " )\n", " print(\n", " f\"iteration {global_step + 1:2d}: optical loss=\"\n", " f\"{np.mean(realization_loss_history[global_step]):.6e}, \"\n", " f\"fabrication=\"\n", " f\"{np.mean(fabrication_penalty_history[global_step]):.6e}, \"\n", " f\"constrained=\"\n", " f\"{np.mean(scheduled_constrained_loss_history[global_step]):.6e}, \"\n", " f\"test accuracy={test_accuracy_history[global_step, 0]:.3%}\"\n", " )\n", " save_realization_progress()\n", " matched_tasks = [\n", " task\n", " for task in web.get_tasks(folder=\"default\")\n", " if CLOUD_RUN_LABEL in task.get(\"task_name\", task.get(\"taskName\", \"\"))\n", " ]\n", " completed_costs = [\n", " float(web.real_cost(task.get(\"task_id\", task.get(\"taskId\")), verbose=False))\n", " for task in matched_tasks\n", " if task.get(\"status\", \"\") in (\"success\", \"completed\")\n", " ]\n", " optimization_run_summary = {\n", " \"mode\": REALIZATION_MODE,\n", " \"task count\": len(matched_tasks),\n", " \"completed task count\": len(completed_costs),\n", " \"actual FlexCredits\": float(sum(completed_costs)),\n", " }\n", " save_realization_progress()\n", "elif RUN_CLOUD and not needs_cloud_updates:\n", " print(\"The cached inverse design already contains all requested updates.\")\n", "elif RUN_CLOUD:\n", " print(\n", " \"Cloud optimization is closed: estimate cost in this kernel and \"\n", " \"enable explicit approval.\"\n", " )\n", "else:\n", " print(\"Cloud optimization is disabled.\")" ] }, { "cell_type": "code", "execution_count": 41, "id": "deep-realization-status", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "device update order: synchronized\n", "completed device-optimization steps: [40, 40, 40]\n", "device optimization complete: True\n" ] } ], "source": [ "realization_complete = bool(np.all(completed_steps >= REALIZATION_STEPS))\n", "realization_progress = {\n", " \"mode\": REALIZATION_MODE,\n", " \"iterations\": np.arange(1, max_realization_steps + 1),\n", " \"transmission_history\": transmission_history,\n", " \"reflection_history\": reflection_history,\n", " \"transmission_error_history\": transmission_error_history,\n", " \"reflection_error_history\": reflection_error_history,\n", " \"realization_loss_history\": realization_loss_history,\n", " \"learning_rate_history\": learning_rate_history,\n", " \"fabrication_weight_history\": fabrication_weight_history,\n", " \"fabrication_penalty_history\": fabrication_penalty_history,\n", " \"weighted_fabrication_penalty_history\": weighted_fabrication_penalty_history,\n", " \"scheduled_constrained_loss_history\": scheduled_constrained_loss_history,\n", " \"fixed_reference_loss_history\": fixed_reference_loss_history,\n", " \"test_accuracy_history\": test_accuracy_history,\n", "}\n", "print(\"device update order:\", REALIZATION_MODE)\n", "print(\"completed device-optimization steps:\", completed_steps.tolist())\n", "print(\"device optimization complete:\", realization_complete)" ] }, { "cell_type": "code", "execution_count": 42, "id": "community-46", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "analysis results: available\n" ] } ], "source": [ "def padded_layer_matrices(matrices):\n", " padded = np.full((N_LAYERS, max(LAYER_OUTPUT_COUNTS), N_CHANNELS), np.nan + 0j)\n", " for layer, matrix in enumerate(matrices):\n", " padded[layer, : LAYER_OUTPUT_COUNTS[layer]] = matrix\n", " return padded\n", "\n", "\n", "def cloud_payload():\n", " transmissions, reflections, parameters, densities = [], [], [], []\n", " for layer in range(N_LAYERS):\n", " transmissions.append(np.asarray(optimizer_forward[layer][\"transmission\"]))\n", " reflections.append(np.asarray(optimizer_forward[layer][\"reflection\"]))\n", " layer_parameters = np.asarray(optimizer_forward[layer][\"params\"])\n", " parameters.append(layer_parameters)\n", " densities.append(\n", " np.asarray(designs[layer].design_region.material_density(layer_parameters))\n", " )\n", " return {\n", " \"realization_objective\": REALIZATION_OBJECTIVE,\n", " \"realization_target_tag\": REALIZATION_TARGET_TAG,\n", " \"layer_input_counts\": np.asarray(LAYER_INPUT_COUNTS),\n", " \"layer_output_counts\": np.asarray(LAYER_OUTPUT_COUNTS),\n", " \"n_splitter_leaves\": N_SPLITTER_LEAVES,\n", " \"active_leaf_indices\": np.asarray(ACTIVE_LEAF_INDICES),\n", " \"dump_leaf_indices\": np.asarray(DUMP_LEAF_INDICES),\n", " \"fanout_rule\": FANOUT_RULE,\n", " \"terminator_model\": TERMINATOR_MODEL,\n", " \"terminator_reflection\": TERMINATOR_REFLECTION,\n", " \"cladding_model\": CLADDING_MODEL,\n", " \"background_index\": N_EFF_TE_BACKGROUND,\n", " \"optimizer_direction\": OPTIMIZER_DIRECTION,\n", " \"active_mask_rule\": ACTIVE_MASK_RULE,\n", " \"realization_mode\": REALIZATION_MODE,\n", " \"transmission\": padded_layer_matrices(transmissions),\n", " \"reflection\": np.stack(reflections),\n", " \"target\": padded_layer_matrices(targets.values()),\n", " \"parameters\": np.stack(parameters),\n", " \"density\": np.stack(densities),\n", " \"iterations\": realization_progress[\"iterations\"],\n", " \"transmission_history\": transmission_history,\n", " \"reflection_history\": reflection_history,\n", " \"transmission_error_history\": transmission_error_history,\n", " \"reflection_error_history\": reflection_error_history,\n", " \"realization_loss_history\": realization_loss_history,\n", " \"learning_rate_history\": learning_rate_history,\n", " \"fabrication_weight_history\": fabrication_weight_history,\n", " \"fabrication_penalty_history\": fabrication_penalty_history,\n", " \"weighted_fabrication_penalty_history\": weighted_fabrication_penalty_history,\n", " \"scheduled_constrained_loss_history\": scheduled_constrained_loss_history,\n", " \"fixed_reference_loss_history\": fixed_reference_loss_history,\n", " \"test_accuracy_history\": test_accuracy_history,\n", " \"completed_steps\": np.asarray(completed_steps),\n", " \"actual_cloud_cost_flexcredits\": np.asarray(\n", " optimization_run_summary.get(\"actual FlexCredits\", np.nan)\n", " ),\n", " }\n", "\n", "\n", "result_data = (\n", " cloud_payload()\n", " if realization_complete and len(optimizer_forward) == N_LAYERS\n", " else None\n", ")\n", "print(\n", " \"analysis results:\",\n", " \"available\" if result_data is not None else \"awaiting saved device simulations\",\n", ")" ] }, { "cell_type": "markdown", "id": "community-47", "metadata": {}, "source": [ "\n", "## Analyze the Realized Classifier\n", "\n", "After optimization, each layer provides a complex transmission matrix $T_\\ell$, a 6 × 6 reflection matrix $R_\\ell$, and a material-density pattern. We first compare the electromagnetic response with the trained target:\n", "\n", "$$\n", "E_{T,\\ell}=\\|T_\\ell-T_{\\ell,\\mathrm{target}}\\|_F,\n", "\\qquad\n", "P_{\\mathrm{refl},\\ell j}=\\sum_i|R_{\\ell,ij}|^2.\n", "$$\n", "\n", "The transmission error includes both amplitude and phase differences. The reflected power measures how much of each incident channel returns toward the six input ports. We also calculate the insertion loss of the realized singular channels from $-20\\log_{10}(\\sigma)$.\n", "\n", "Next, we replace the trained matrices with the realized matrices:\n", "\n", "$$\n", "a_{\\mathrm{out}}=\n", "T_3D(z)T_2D(z)T_1D(z)a_{\\mathrm{in}},\n", "\\qquad\n", "p=|a_{\\mathrm{out}}|^2.\n", "$$\n", "\n", "The propagation includes the routed PhotonForge input and output responses. We use the training partition to refit one positive detector scale $\\gamma$ and one common output phase. The phase leaves $p$ unchanged, while $\\gamma$ adjusts the confidence of the class logits. The held-out images are used only for the final comparison.\n", "\n", "The figures show the optimization histories, target and realized matrices, reflection, insertion loss, device patterns, confusion matrices, and channel fields for representative images.\n" ] }, { "cell_type": "code", "execution_count": 43, "id": "community-48", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "single-encoding ideal matrix: cross-entropy=0.333241, accuracy=86.89%\n", "repeated-encoding ideal matrix: cross-entropy=0.270203, accuracy=90.52%\n", "repeated-encoding realized, uncalibrated: cross-entropy=0.324838, accuracy=89.05%\n", "repeated-encoding realized, calibrated: cross-entropy=0.319369, accuracy=89.05%\n" ] } ], "source": [ "def fixed_logits(matrices, features, final_phase, log_gamma):\n", " fields = physical_forward(matrices, features)\n", " fields = fields * jnp.exp(1j * final_phase)\n", " scores = jnp.abs(fields) ** 2\n", " return jnp.exp(log_gamma) * scores / ROUTE_POWER_REFERENCE, scores\n", "\n", "\n", "def metric_pair(logits, labels):\n", " loss = optax.softmax_cross_entropy_with_integer_labels(logits, labels).mean()\n", " accuracy = jnp.mean(jnp.argmax(logits, axis=-1) == labels)\n", " return float(loss), float(accuracy)\n", "\n", "\n", "reconstruction = None\n", "if result_data is not None:\n", " realized_matrices = tuple(\n", " np.asarray(result_data[\"transmission\"])[layer, : LAYER_OUTPUT_COUNTS[layer]]\n", " for layer in range(N_LAYERS)\n", " )\n", " realized_reflections = np.asarray(result_data[\"reflection\"])\n", " calibration = {\n", " \"final_phase\": jnp.asarray(0.0),\n", " \"log_gamma\": params[\"log_gamma\"],\n", " }\n", " calibration_optimizer = optax.adam(CALIBRATION_LR)\n", " calibration_state = calibration_optimizer.init(calibration)\n", "if result_data is not None:\n", "\n", " @jax.jit\n", " def calibrate(calibration, state):\n", " def loss_fn(values):\n", " logits, _ = fixed_logits(\n", " realized_matrices,\n", " jnp.asarray(train_features),\n", " values[\"final_phase\"],\n", " values[\"log_gamma\"],\n", " )\n", " return optax.softmax_cross_entropy_with_integer_labels(\n", " logits, jnp.asarray(train_labels)\n", " ).mean()\n", "\n", " loss, gradient = jax.value_and_grad(loss_fn)(calibration)\n", " updates, state = calibration_optimizer.update(gradient, state, calibration)\n", " return optax.apply_updates(calibration, updates), state, loss\n", "\n", " calibration_history = []\n", " for _ in range(CALIBRATION_STEPS):\n", " calibration, calibration_state, loss = calibrate(calibration, calibration_state)\n", " calibration_history.append(float(loss))\n", "\n", "if result_data is not None:\n", " repeated_logits, _, _, _ = logits_and_scores(params, jnp.asarray(test_features))\n", " uncalibrated_logits, _ = fixed_logits(\n", " realized_matrices,\n", " jnp.asarray(test_features),\n", " jnp.asarray(0.0),\n", " params[\"log_gamma\"],\n", " )\n", " calibrated_logits, calibrated_scores = fixed_logits(\n", " realized_matrices,\n", " jnp.asarray(test_features),\n", " calibration[\"final_phase\"],\n", " calibration[\"log_gamma\"],\n", " )\n", " reconstruction = {\n", " \"single-encoding ideal matrix\": (\n", " float(single_test_loss),\n", " float(single_test_accuracy),\n", " ),\n", " \"repeated-encoding ideal matrix\": metric_pair(repeated_logits, test_labels),\n", " \"repeated-encoding realized, uncalibrated\": metric_pair(\n", " uncalibrated_logits, test_labels\n", " ),\n", " \"repeated-encoding realized, calibrated\": metric_pair(\n", " calibrated_logits, test_labels\n", " ),\n", " }\n", " for name, (loss, accuracy) in reconstruction.items():\n", " print(f\"{name}: cross-entropy={loss:.6f}, accuracy={accuracy:.2%}\")" ] }, { "cell_type": "code", "execution_count": 44, "id": "community-51", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAABJYAAAFsCAYAAACepjOrAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAQ6wAAEOsBUJTofAABAABJREFUeJzsnXd8VEX3/z93s5VN2YRUkpCAVOmIEB8pghQRGwoqigooKnZ8bIgFRAXFjtiwwqNSVFQEQVSaUkQRRHpPAiG97Wbbvff8/uC3+yWkbW8579frvJTNvTPnzs7OuXNm5hyBiAgMwzAMwzAMwzAMwzAM4yaKYCvAMAzDMAzDMAzDMAzDhCfsWGIYhmEYhmEYhmEYhmE8gh1LDMMwDMMwDMMwDMMwjEewY4lhGIZhGIZhGIZhGIbxCHYsMQzDMAzDMAzDMAzDMB7BjiWGYRiGYRiGYRiGYRjGI9ixxDAMwzAMwzAMwzAMw3gEO5YYhmEYhmEYhmEYhmEYj2DHEsMwDMMwDMMwDMMwDOMR7FhiGIZhGIZhGIZhGIZhPIIdS0zYMmPGDERHRwdbDY9ZsmQJrrvuOmRkZEAQBLzyyivBVolhGIaph3C2N1VVVZgxYwb69u0Lg8GAlJQUXHnlldi9e3ewVWMYhmHqIZxtDgA88sgj6NKlC2JiYhAbG4sLL7wQixcvDrZajJ9hxxLDBImvvvoKR48exRVXXBFsVRiGYZgIJTc3F++//z6GDx+OpUuXYsGCBaisrEROTg727dsXbPUYhmGYCMNoNGLy5MlYtmwZli1bhp49e2LcuHH44osvgq0a40eUwVaAYSIZs9kMnU5X79+WLFkCheKMb/f9998PpFoMwzBMhNGQvWnTpg2OHDmCFi1aOD8bMmQIsrKy8M4772DevHmBVJNhGIaJABqb47z33nu1/j1ixAjs3bsXn376KW666aZAqMcEAd6xxEQ0TzzxBLp164bo6Gikp6dj3LhxKCgocP593rx5aNGiBaqqqmrdt2/fPgiCgFWrVjk/W7lyJfr16wedToekpCRMmTIFJpPJ+ff169dDEASsXLkSY8aMQWxsLMaOHdugbg6nEsMwDBP+hKq90ev1tZxKABAdHY127drh1KlTvnh0hmEYJsCEqs1piJYtW8Jms3n4tEw4wDNbJqIpKirCk08+iZUrV+LNN9/E8ePHMWjQIIiiCAAYP348iAhffvllrfs+/vhjpKenY8SIEQDOHFu76qqr0K1bNyxfvhwvv/wyvvnmG9x+++116rzzzjtx3nnnYfny5XjkkUf8/5AMwzBM0Akne1NRUYF///0XnTt39uKJGYZhmGAR6jaHiCCKIioqKrBo0SL89NNPuO+++3z09ExIQgwTpjz77LOk1+tdvl4URcrPzycAtGbNGufn48ePp759+zr/bbfbKSUlhZ588kkiIpJlmbKysmjcuHG1yvvxxx9JEAT6999/iYho3bp1BIDuvvtut58FAM2dO9ft+xiGYRj/E0n2hoho8uTJpNfrKS8vz6P7GYZhGP8RCTZn7dq1BIAAkFKppPfee8/le5nwhHcsMRHNjz/+iP/85z+Ii4uDUqlERkYGAODgwYPOayZPnow//vgDe/bsAQCsWrUKRUVFmDRpkvPaEydO4Prrr4coik4ZNGgQFAoF/vzzz1p1jho1KkBPxzAMw4QK4WJvPvnkEyxYsADz58936sgwDMOEF6Fuc/r164ft27fj559/xkMPPYT7778fH330kbePzYQw7FhiIpbt27fjqquuQqtWrbBo0SJs2bIFW7duBQBYLBbndQMHDkTHjh2dg93HH3+MgQMH4rzzzgMAlJSUAABGjx4NlUrllBYtWkCSJOTl5dWqNyUlJRCPxzAMw4QI4WJvfvzxR9x55514+umncdttt3n8vAzDMEzwCAebExMTgz59+uDSSy/F3Llzce+99+Lhhx+GJElePTsTunBWOCZiWb58OeLi4rB06VJnoOwTJ07Ue+0dd9yBl19+GQ8//DBWrlyJjz/+2Pm3hIQEAMDbb7+Nfv361bm3VatWtf4tCIKvHoFhGIYJA8LB3mzduhVjxozBbbfdhueee87l+xiGYZjQIhxszrlccMEFeOONN1BcXIzU1FSPy2FCF3YsMRGL2WyGSqWqNQh+/vnn9V572223Yfr06bj55pvRokULjBkzxvm3Tp06ISMjA0ePHsW9997rd70ZhmGY8CLU7c3evXsxatQoDBkypE4aaIZhGCa8CHWbUx+//fYbYmNjkZiY6Nd6mODBjiUmrJEkCV999VWdz/v27Ythw4bhjTfewP3334/Ro0djy5YtWLRoUb3lJCUl4eqrr8ayZctw1113QafTOf8mCAJee+013HTTTTCZTBg1ahT0ej1OnDiBlStX4sUXX0SHDh3c1n3v3r3Yu3ev89+7d+/GV199Bb1ej5EjR7pdHsMwDOM/wtXeFBUVYcSIEdDpdJg6dWqtmBmxsbE4//zz3SqPYRiG8T/hanP++ecfPP744xg7diyys7NhNBrxww8/4MMPP8Ts2bOhVLL7IVLhb5YJaywWC8aOHVvn80WLFmH8+PF46aWXMG/ePHzyySe4+OKL8cMPPzQ4QI4ePRrLli1zBrQ7m7Fjx8JgMOCFF17A//73PwBAdnY2LrvsMo9jKi1duhQzZ850/nvhwoVYuHAhsrKycPz4cY/KZBiGYfxDuNqbvXv3Ij8/HwBw6aWX1vrboEGDsH79erfLZBiGYfxLuNqclJQUGAwGPPfcczh9+jTi4uLQqVMnLF++HFdffbXb5THhg0BEFGwlGCYUuPXWW/H3339j9+7dwVaFYRiGiWDY3jAMwzCBgm0OEwh4xxLT7Nm9ezd27tyJxYsX45133gm2OgzDMEyEwvaGYRiGCRRsc5hAwjuWmGZPdnY2iouLcdNNN+H99993ZldgGIZhGF/C9oZhGIYJFGxzmEDCjiWGYRiGYRiGYRiGYRjGI9htyTAMwzAMwzAMwzAMw3gEO5YYhmEYhmEYhmEYhmEYj2DHEsMwDMMwDMMwDMMwDOMRnBUOgMViwe7du5GUlASlkpuEYRj3EEURxcXF6NatG7RabbDVYUIctjkMw3gK2xvGHdjeMAzjDe7YHB5hcCYVY9++fYOtBsMwYc4ff/yBCy+8MNhqMCEO2xyGYbyF7Q3jCmxvGIbxBa7YHHYsAUhKSqr3c41Gg0OHDgEABEFAVVUVunTpEkjVQoa3334bV199dbDVYMIAq9UKABgzZgx27twZXGUCTENjCcOcjaOf/PHHH0hLS/N7fZmZmX6vgwF69uyJFStWeHx/eXk5LrroIphMJgBAVFQUfv/9d6Snp/tKxZCBiCAIQoN/X7BgAbZt24b33nvPo10WkiQhOzvbCw1rc+LECZ+m6e7duzeKi4u9KoPtDeMKzb2fHD9+HFFRUcFWA0SE1q1bN3ldRkYGtmzZ4lbZsiyDiGCz2fDJJ59g9uzZnqoJ4Iwz0mAwNHmdr8bZI0eOQK1We11OY/z999+YNGkSSkpKXL5Hq9U6/QBNYbVa0a5dO0/VCwtcGUvYsQQ0+NIiSZLzpV+pVKKqqiqQaoUMU6ZMwb333htsNZgw46+//sKaNWtw3XXXwWw2B1udgMDbzBlXcPSTtLQ0ZGRk+LWuESNG+LV85v/YtWsXUlJSoFKpPLo/PT0dQ4YMcTqn0tLScMEFFzTLcWXmzJle3S9Jko80OUPLli2h1+t9Vt6ePXuQnJzsVRnNsV8w7tPc+0l0dDRatmwZbDVQVlbm0nX5+fkwmUzo2LFjo9dZLBa88sorePvtt1FeXg5ZliFJEojIa13PP/98nzrSG2P48OFo27atX+vo27cvtm/f7vZ9FosFrVq1ClhbhDqujCUR0VL5+fm46aabkJCQAJ1Oh169emHfvn1elyuKIg4ePIiDBw9ClmWflBksBEHAhg0bnF7tpkQURdjtdhAR3nnnnWCrz4QhCoUCI0eOhNFoxGOPPRZsdRjGJ/jL3viDyy+/HD/99JNf6+jbty+uueYaREdHOz9Tq9X49ddfa9kUSZIgSRJGjhzpV30UCkWjO2H8CREhJSXFY6eGIAi47777oNPpoNfr8cEHHzT7SaGnCILg035w+PBhn5UFnFn5TU1N9WmZTGQSTjYnFFmzZk1A62vIsdOrVy+Xy+jcuTNsNludzysrKxEbG4vY2FjodDo8/fTTKCwshM1mgyiKPnEq9e7d2y1HSmxsrMd1xcfH+/X7sVqtiIqK8sip5KBdu3aQZdmla++++26P64kUwt6xVF5ejv79+0Or1WLNmjXYs2cPXnzxRcTExPik/AsuuAAXXHABbr31VgwePNgnZfoKvV6PV199FSaTCSaTCaIooqKiAlOmTIFWq4VSqURaWhry8/MhyzIGDhzo8otWVFQUv9AyPkGhUOCll16CJEkoKCjAnj17sHPnTjzyyCNBmwAyjCf42974CrvdDpVKhR9//NEv5T/++ON4/PHHQUTYtm0bli9fjurqaqcTyWq11rGXCoUCCoUCq1atgiiKtRxR3iIIAh544AGn80qSJIwYMSIou7XKy8sRHR2Nmpoaj+5XKpVISEjA4MGDMWzYMLfv98XEIhIQBAGJiYk+K6+wsNBnZTkoKCjA1KlT+V2LaZBwsTmhzPr16/1ex9q1a7F27VpERUU5FzcEQUBycjImTpyI1NRU5ObmulweEUGj0WD58uWw2Ww4evQodDodDAYDqqurUV1d7fNnUKvVGDp0qNuOnmPHjrldV1paGvLy8lzexVUfRITy8nKMGzcO48aNg1arhSAIUCgU0Gq1iIqKglarddkp1BDHjh1DVFQUYmNjMWHCBOc7Rn288cYbGDRokFf1hT0U5jz++OPUv39/r8rIy8sjACEvKSkptGfPHqqoqCCz2UyyLPuoFRl34bb3HQsWLCCFQkEKhSLovzFvJS8vL9jNyfgRX9gbov+zOb7sL7IskyzLdNlll/m1jx8+fNhnOh88eJC0Wm2t8rOysmj79u1ks9lIkiSn2O12stlsZLfba33e1Fh8bvmBEpVKRcXFxW61h81moz59+lBMTAw988wzbtkZSZJo2rRp1KFDB/r+++/dqjdSWbp0qc++z1OnTvlVV1mW6cSJE5SRkeGsUxAEEgSBMjMzqXXr1mxvmiHNaY7jL5k1a5aPvo36GTJkSNCf0RuJi4ujw4cPkyiKJIoiSZLkdhucPn2aDAaDc9xSKpWkVCrr1DVz5kyv27uqqipodv1smTZtWh3dRFGk8vJymjx5stvlCYJAaWlpIT0XcsXmhL1jqXPnzvTQQw/RtddeS0lJSdS7d29atGhRo/dUVlZSXl6eU/7444+gf1lNyUsvvRSgFo0sZFmuM/lwTMDcpaCggFJSUpzfSWpqqnNyw/gGu91ORqORNm/eTBqNJui/O38Mukz44om9IWrY5njaX2RZpt27d9Ndd91FHTt2JLVaHZD+/c4773ikbzCprq5u8rlUKpXzpdiXIggCTZ06lU6dOkXV1dVkMpnIZrPVa39KSkooPj7eeW/Pnj1JFEWXnlEURcrMzKxV99q1a33dlGGHKIqUmprqk+8yFBaTbDYb6fV6tjfNiOYyx/GnnDhxwm/fz1VXXRX05/NW9uzZU+uZLBYLnThxgmpqauo8ryiKZDQaGxwP65sPybLssi1rCqPRGPT2Old0Oh1lZ2fTVVddRevWraPy8nL6888/3XovUygUVFNTQ7IsU2lpacDe6dwVV2xO2B+FO3r0KN555x2cf/75+OmnnzBp0iRMmjQJ3333XYP3vPbaa8jMzHQKp+FkGIZhmsITewOwzWEYhmHch+c4DMOEFT5xIQYRlUpFF198ca3PJk6cSJdddlmD9wTLm69Wq+nFF1+ka6+9ts7fMjIyyGQykclkIkmSqKioiO644w667bbbyGQy+bsZwxZZlslut5PdbidRFKm6upqmT59O06dPJ5VK1eR3IggC6XQ6MhgMpNfrSa/Xk1qtJrVaTTqdjuLj42utEDYk9Xn2Ge9YtGhR0L3z7gqvIEc2ntgbIt/tWNq7d2/QVrJSU1Pdbq9QobKyst6dKwqFggoLC+tc/9JLL5EgCH5rS4VCQbGxsZScnEzJyckN2qpZs2aR3W4nWZbJYrHQ7t276fvvv6fvv/+e9u3bR2VlZbRr1y6KjY1lu9QA1dXVXh+buPHGG4P9GE5kWaYbbriB7U0zIZzmOKEq/tptOHv27KA/my/kjz/+cD6TJEl05ZVX1rlGrVbXOqLVpk2bgO/irKysDHpbNSWCINCtt95K48ePd+sdYtOmTbWe9fvvvw/6s9QnzeIoXGZmJt1+++21Pnv55Zfp/PPPd7mMQJw/1mq1dX6EK1eupN69e9PmzZt90hbNAccL9i+//OKzLe6+kuHDh9Odd95JCQkJpFQqKSEhgQoKCoLdZGGL2WwOu+Nw/KIf2fjC3hC5H2Pp559/DlqfVqlUNHny5JA4CuQtoijS4cOH6YsvvmjyeIQsy1RcXEzLli2rdQQ60KJUKl1aJKlPtFot7dq1i8xms3MBpjlSU1NDI0eOdNueqFQqGj16dMj1fX/EaGNCk3CZ43gj6enpNGTIEMrMzKw3Lo838sADD/j6KyGiM869YLebryQ6Opq2b99ORUVFNGzYMJfv++STT/zStueyffv2Oke9I02sVmutZ7bZbD7/LfhCXLE5YZ+K4j//+Q8OHTpU67ODBw+idevWQdKofqqrq+tkwLr88stx+eWXB0mj0Ofo0aMAgGnTpmHdunWorKyE3W4P2aw356b1LisrQ1paGvR6PTZv3ozzzz/f4+wvoijCYrH4NJNSqKPVavHKK6/g4Ycfht1uD7Y6DBMUe9O5c2fs37/fb+WfzfXXX4/FixdHbLbGqKgonHfeeTjvvPOavNaRVWzMmDEYNmwYUlJSYLVaA6BlbURR9Phei8WCHj161PosLi4Ox48fh8Fg8FKz8EGn02HVqlUgIoiiiK+//hrjxo2r91pBEPDqq69i0qRJ0Ov1nLGNCSrhMsdpCJVKhdmzZ0OWZbzyyisAgJKSEiiVSsydOxf3339/vfaGiCDLMqqrqzFr1iwAZzJunZvhS6PR4IknnkCLFi3w3HPPwWQyAQAuueQSAMCbb77psq5msxn5+fkAzoyTcXFxiIqKgiiKOHr0KN58800sXboUFRUV7jZDSGM0GnHhhRe6fd+dd96JCRMm+F6h/48sy9Dr9bBYLH6rI1QwGo1ISEhw/lupVCIlJQUnT54MolYe4hf3YgDZunUrRUVF0Zw5c+jQoUP06aefkkajcSsrir+9+UVFRX5sgchDFEVKT08PumfWX6LT6Wjx4sW0ePFiZyBXURTJYrHUG/jul19+IZVKRYIg0IQJE2jChAlB+FaCgyzLVF1dTSUlJVRRUUFFRUX0yy+/UP/+/d1axR8wYACZTCYSRZGOHDlCiYmJlJiYGBRvPhO++MLeELm+4yA7O9uvY5Hj+O+nn34acrsyQgmbzeaX4N7BEqVS6bNgquFKdXU1VVdX1zrqrtfrqbS0NNiqNQnvWGo+hMMcpzHxdeBsWZapvLycioqKfJo4Z9CgQUEfl8NR/PXeIIqixzt1w1FycnLqJJnq06dP0PU6V5rFUTgiom+//Za6dOlCGo2Gzj//fFq4cKFb9/tj0DUYDGQwGMhms/npqSOXAQMGBP3HE0xp27Yt7dixg3Jzc2ngwIH1XnPhhRc2mpmhueDIymez2aiyspK2bt1KjzzyCOXk5NCAAQPqnFs+F1mWqaqqin7++Wfq2rVrQAZdJrzx1t4QNT4xdGStdCW2mycSGxtLubm5vmiKZoEsy/TTTz8F3S74Wnr37t3s7QfRGRuyd+9eOnHiRNi0BzuWmhehOMdxVcKB7777LujjcbiKr5x7NpuNjEYj/fTTT/TTTz+F5DEwf8v111/v3GBQU1Pj94VFT8QVmyMQhei5ogCSn5+PzMxMl69v27Yt3nnnHQDA5MmTkZeX5/ybIAjYuHEj+vfv73M9mwOSJPHWcxdRKBTQ6XRQqVQwGAwYOnQopkyZgvPPPx8ajSZij7P4EyLCoUOH8Prrr0Or1eL6669HSkoKnnzySSxZsqTee4YNG4ann34aAwcORF5eHjIyMgKsNRNuOGzOuf3lo48+wh133OG3enfv3o2uXbv6rfxIgohw4sQJ3H///Vi1alWdIxiRwIgRI/D2228jOTkZLVq0YNsbJjQ0fjBMfbg7x/EloT7FFEURKpUq2GqEJSqVCjabzasyjEYjWrVqherqah9pFd4kJCRg5syZEEURjz/+uNft62tcsTnsWILrg64gCHj33Xdx11131fpclmWUlpZCp9M1qxg4/uDIkSNo165dsNWICBITE/Hzzz/XibHBeMbatWsBAMOHDwdwZjwoLS1FfHw8v+gzbnF2f0lPT8eCBQtw9913+/UlvKamBjqdzm/lhyqiKOLnn3/G8uXLcckll+Caa65psh3MZjMuuOAC7Nu3L0BahgapqanYsGEDzjvvPAiCAJvN5uyTWq2WFytCBLY3jDsEy7GUk5ODLVu2BLxeV5EkCYmJiREXMykQCIKAkydPIi0tzaXrzWYzioqKkJKSAo1GAwD4/PPPccstt/hTzbBEEASo1eqgxHRsCldsDi9PucHChQsxfvz4Op8rFAokJSUFQaPIwzF5Z7ynpKQEPXv2RPv27QEAe/bs8Xhlxmw2Y/To0RAEAcuXL4dWq/WlqmHBsGHDAACVlZX45ZdfcOWVV/IKP+MVHTt2RE1NjV/rEAQBVqs1YldlLRYLrr/+eqftyMjIwIUXXuh0Cv3zzz/O3UYffPABACA2NhbPPfccbr/9duj1egiCACLCgQMHAAC9e/eG2Wz2WCeFQgGNRgOtVgutVut0ZJWUlKCqqsrjcv3N6dOn0bFjR+e4dnbgcI1Gg9tuuw2zZs1CQkICoqKi2NHEMEyDbN68OdgqNIjNZkNsbGxITt5DEb1ej927dyMjIwOCILg8/p88eRLt2rVrFgG4fQURhXW/5B1LcM2bn5WVhePHjwdGoWbMa6+9hv/+97/BViMiMRgMWLduHbp27VrHIeIYBs42FI7J2NVXX40ffvih1vWTJk3CRx995GeNwwdeQWbcwVcryFqtFocPH0Z6errzM1EU8csvv+DTTz/F5MmTMWTIEK/rCQWICJIkQZIkAIDJZMLs2bPx6quverXTKyEhAT169EBZWRn27NkDwPVMbIIgIC4uzul0fvnll9G6dWsoFIpG7yspKcErr7yCVatWAQCKi4tRWVnZoDNLEAS0aNECQ4YMcWZIateuHRQKBaqrq7F161Z8+umn+OOPP1BaWgqr1er3IyhKpRJdu3bFhg0bEBsb69e6mNqwvWHcIdA7ljIyMnDixIkmx8FgYbfbodVqI/J4s69ZunQpAGDs2LFu3bd+/XoAwODBg32tEhNE+Cici7gy6J48eRKtWrUKkEbNl0OHDqFr164hd640UhAEAXq9HomJiUhKSkJNTQ1OnjyJmpoaEBE0Gg3S09MhyzIOHz4MoOEz8vHx8SgsLIzYnRDuwC/6jDt486KvVCoxduxYLFy4MOJ3zImiiNWrVwMAHnzwQZw6dQqSJDnTxgcDhUKByZMnY+7cuYiOjvbprh1ZlmEymXD69GmoVCokJiZCp9MhKirKrXJEUcTChQtx9913w263+0y/+hAEAffddx8eeughlJaW4ssvv3QeLXniiSfQvn17ZxtVVVXhkUceweHDhzF37lz07t2bdz15ANsbxh0C4ViaPn06nnnmGajVar/VQUQwGo2wWq1ISEio13FlMpkwYcIEHDp0CAAwbdo0XHvttc731IMHD6Jjx45+0zFSaNeuHfbv3++27QH+z3EHgJ13EQY7llyksUHX8dLDP47AQET4448/MH78eOcOsWBNIJimSUxMxKlTp5q9c4lf9Bl3cOdF/+OPP8Ztt90Wsqu//kAURfz0008YP348ysvLg62Ok/Hjx+Ozzz4Lm++isrIS6enpMJlMQdMhKSkJI0aMwIYNG2olOgGAuLg4fP3118jJyYFKpXIuYjj+q1AooFQqw6a9AwXbG8Yd/OlYUigUsFgsPnkHrKmpgdFohFKpRFRUFEwmE37//Xe88MILAM6Eczh7PtCvXz/89NNPiI6ORlVVFTp27IiioiKv9YgUNBoNDAYDioqKXN7BqtFoUFFR4VW4i759+2L79u0e38+ELhxjyQc4trgzgUEQBPTr1w8HDx50rrSePHkSc+fOxddff42qqioolUqo1WrU1NS4dW7X4SRkX6rvKCkpwV9//YWcnJxgq8IwEUdzGqtkWUZlZSWWLVuGZ599FqdPnw62SrV46KGH8PrrrwdbDbeIi4tDbm4usrKyYDQag6JDcXEx/ve//9X7t8rKSgwdOrTR+wVBgFarRXZ2NoYMGYKLL74Y/fr1Q+vWrSN+xx7DhDqvvvqq104lm82Gjh07uh1uZNu2bYiLi/Oq7kihe/fu2L59O1QqFURRhCiK0Gg0UCgUkGUZDz74IN5++23n9QqFAmvXrnUeVSMinzjwjx49yk6lZg4vAzEMwzAMwzAMwzAMwzAewUfh0Pg2UceOGEd6RCa4EJFzFb+mpgYzZ87EG2+84dJxOUfmH8Z3xMTE4MSJE4iPjw+2KkGFjyYw7uDK0QRJkiL2CJAjRlJxcTG++eYbfPbZZzh48CCMRmNIHjvX6/UoKSkJ22yYv/32m3P3daRk5xEEAUOHDsWyZcua3a4FtjeMO/jzKNyvv/7qVYBmi8WCxMTEoB7XDXe0Wi1MJlOT7wuOxBc1NTWIiYnxuR6yLHsUk4kJH/gonJe8/vrr7FAKMQRBcB5pi46Oxssvv4yUlBRMmzatSecSO5V8S0pKCnbs2BGRTiWr1YqDBw8iKyuLMx4xAcVxrCAUnEpEBFmWnWK1WlFVVeXMXhYTEwODwQCVSgVBECBJEqqrq3HkyBHs378fhYWFqKioQHFxMU6cOAEAOHbsGAoLC2EymcImfl5sbKxXxz3sdjuUSqXTdtntdsyZMwdffvklAKBbt254/PHH0blzZ+fxBV/SpUsX/Oc//wEArFu3LiJsIRFh7dq1SExMxIABAwAAH330Edq0aRNkzRim+TBp0iQcO3bMo3tPnz6NNm3aRIyzO1iMGzfOJZvhcPr4w6kEnFmAYSKP++67D3feeSe6d+/u0vXsWKoHvV6P5cuXc3ylMEAQBNx///149913cfTo0WCr0yxo27Yt1q9fj4yMjIjJ6FNTU4N3330X//vf/7B3795aWQnj4uKwZ88epKWlATizKmM0GqHVasN2BwMTuqxZsyZoddtsNhw+fBjz5s3D119/jfLy8rBx/viTiooKVFVVue1EJyIkJyejpKQEgiAgPj4ekiShsrKy1nX79u1zpnUWBAFdunTB77//7hOndmVlJZYsWYLc3Fxn+ZHgWHIgiiLWrVsHAOjUqRO++uorXHnllUHWqmkkSYLVaoVOp4sYO8o0P44fPw5Zlt12ht93332YP3++n7SKbM6NF+vIwhksJElCXFwcOwiDiFKp9Mu7WseOHTFv3jzk5+e7fhMxlJeXRwDo2LFjZLfbSZblYKvEuIEsyzRy5EgCwOInUSgUlJOTQ0ajMdhft0+RZZkuueQSj9tFEARasWIFHTx4kABQXl5esB+JCQMcNqc+KS8vp/Ly8oDqY7FYqH379iQIQtDHmlCVK664wu13gzZt2nhVZ/fu3enAgQNkMpnIYrGQKIoky7JTD1mWSRRFMpvNZLVaSZIkkiSJKioq6KGHHqLo6Ohm952mpKSQJEn++Jn4jPfff7+WzhqNhrp06UJTpkyh4uLiJu93jB9sbxhXaMze+ELS09NrjY2FhYX00UcfUW5ubi09RFEkURQpNTU16ONEJIlCoaCSkpI637s/57KiKNKmTZsoJSUl6M8fSNFqtaRSqUilUtX5WzBs7UcffVTre9myZUu9unnarywWCxG5Z3N4x9JZKJVKzjLiQ2RZhtlsRmVlpXMHSFRUFDQaDXQ6HXQ6nc/a+9SpUz4phzlDbGwsZs+eDQC44oorkJaW5pN0sudit9tx6NAhrFy5EgCg0+lw2WWX1cr4Y7fbYTQaUVFRAbPZDFEUoVAonH0I+D9vvdVqhUKhQHR0NHQ6HaKiopwxW9RqtbNMR8ap8847z3msxxOIKCxWx5nwYe3atQCAsWPH+r0ux7gcGxtba5ceU5eVK1di+vTpePHFF+v8zRG7QhRFqFQqyLKMxx57zOMjIg7++ecfdOzY0asymhuVlZUhFZ/MarXWWkl+55138Nhjj9W5Zs+ePdizZw/effddjBo1Cj/88EOgVWUYjzh58iQyMzMxfvx4fP311zh8+LDzb3q9HjfddBOqq6uduzJDMY5eOCPLMhITE/Hee+/hpptuwqpVqzBhwgRYLBYolUrcfffdmDNnjldH1UwmE6ZOnYpFixY1y51J0dHRqKysrGVX6P/Hijz7mDtw5n2gT58+2Llzp9/0iYmJQWlpaZ15WU5ODmw2m/Od5IknnnA5DvHZYRh0Oh2+/vprz8IB+cGRGXaEyuqPY7XRsSoZbsiyTBaLhbZv306DBg0irVbbqCdUp9NRTk4Obdu2jWw2m8f1lpWVkUajCbonO5Lkr7/+8mHPqB+LxULz5s2jmJiYWnULgkBarZYMBgPp9XpSKBRu6y8IAikUClIoFCQIAgmCQCqVimJjY0mv1/ut3YI9hjDhQWMryI7VsJqaGuf1sixTfn4+zZs3z2e/TUmSyGAwkMFgCPp4E04yfvx4stvtzu9l37591KtXL+rVqxclJSVRVlYWxcfHB13P5irx8fEkiqJbvwOTyVTvPee+h4miSIcPH6bDhw/TxIkTKS0tjQwGAw0fPrzObl6z2VzrveRse+TKc8TFxTl3eJxLqLyzMuGBv3cssYSHON4tJkyYUOv9gojo0KFD1KlTJ9Lr9RQbG0sGg4HUanXQdQ4VsVqtbv3mZFkmpVLpF13uvPNOt8cAu91ORqORrFYrVVRU0NNPP006nY6USiV17dqVjh8/TlarlaxWK5nN5jr9wx2bw1nh4P8MG/T/M5lJkgSz2YyKigoYjUZYLBacOnUKq1evxsqVK1FcXOy857zzzsP8+fORk5Pjs109Z68SnH1G19EFHDqWlJRg4cKF+Oyzz1BRUYH09HTcfvvtGDZsmNN7mZubi7Vr12LHjh2orKyExWJBYWEhCgsLYbVa3dZNpVIhOTkZo0aNwsMPP4z27ds3ueJIRKisrES/fv1w8OBBt+tkGqakpAQtW7b0ax1GoxHXXXcd1q5dGzExPzhLD+MKrmbpiY6Oht1urzOmGgwGFBUVebyLUBRFdOvWDfv37/fo/uZObGwsevfujZMnT+LIkSO8Ah9C9OjRA3/99Vet7EQmkwlFRUVIT0+HWq0GcCauHgBMmDABa9asgU6nw8CBA9GzZ0/8+++/2L59O0wmE1q2bImkpCQUFBTg+PHjDa7WKxQKvPnmm5g4cSK2b9/uVaascxEEAUqlEnFxcVi1ahXS0tI4KxzjMv7MCseEL4IgICoqiuMoNoFSqYTdbnf7vujoaJ9nO1SpVDCbzT7JvifLMioqKmAwGJqcb7vjJ2HHEnzrWJJlGadPn8Y333wD4EwqzlOnTqGoqAhlZWVuZcJRKBRo3749Jk6ciN69e0Ov1yMmJgapqanOTDyNQUQwGo1YvXo1XnvtNRw4cAA2mw2yLNdyJjn+7fhvKHSJ2NhYPProowCAO+64A3q9HuXl5fj++++xdOlS5ObmorKyElVVVfxS7wfGjRuHRYsWAYDf0odKkoTZs2dj5syZEWPY+EWfcQVfvOjHxcXh0KFDSExMrBWQ2TGOR0VF1QkKbLPZsHHjRtx00021FjIYJhIQBAGDBw/GqlWrnItg+fn5GDRoEIqLizFw4EDMmTMHkiRh3LhxAM4ETvclGo3Go8U1T2B7w7gCO5YYxjsqKioQFxfn8vVWq9UvyX3UanXA7MvZsGPJTXzlWJJlGZs3b8aYMWNQWFjoM/0EQXBOEBQKBVQqFTIzM3HzzTfjhhtuQHp6OoAzHc7hTPr999/xwgsvYOfOnRw7g/EIR/yibt26oUePHhgzZgwGDhzo08GyqqoK9957r/Psfbj3VX7RZ1zBVy/6arUa2dnZ0Ol0yMvLAwBUV1dDkiRERUWhRYsWSE5Odjrmi4qKvIopxjChjGMxbsmSJWjfvj0OHz6MQYMGObMmNZaZLxxhe8O4AjuWGMY7lEoljh8/7pxvA2d2vRYUFKBVq1bO+RJwJs5ffHy83zZpVFdXIzo62i9lNwQ7ltzEV44lm82GRx55BG+//XbAdv0IguDc2q1SqZwpbHkXD+NPHH3OEbju4osvxrfffutRemxJkpypLKdOnYpVq1YFxSPvC/hFn3EFftFnGO85d0cecGbHUOfOnZGVlYVff/0VVVVVQdAsMLC9YVyB7Q3D+AaFQuE8xXHu8TiVSuXRkTl3SU5OxuHDhxETE+P3uhy44ycJjbQZEYJSqUT//v0DmlmOiGC1WmG1WmE0GmE2m9mpxPgdm83mPFZps9mwbt06xMXFISUlBS+99BJeeukl/Pvvv844Fo0RFRWFrKwsZGVl4ZtvvkFJSQkWLFiAAQMGID093S/bSRmGYZjIwHGEn4hgsViwa9cufP/99xHtVGIYhmECiyzLsNvt9TqQAuFUAoCioiLExsZCEARnBrcePXqgqKgoIPU3BTuWfIhCocC1116LiRMnQqlU1nEwOTqB42jbueK4R6/Xo1OnTrjiiivQrVu3gDqqGMYbioqK8MQTT+CJJ55At27dEB8fj+eff94tZ2d0dDTuuOMObNy4Efn5+TCZTCgtLcWoUaPqXaFmGIZhmh8NxYSUZZkX2BiGYZiIxrGY8s8//yAlJSUk7B57LHyMUqnEe++9h3vuuQcA8MYbb6C8vBzdunVDv3790KpVK6jVaqhUKmi1WqjVaqezybEzo0WLFs7Aq7Is49dff8WIESNCosM0JxQKBTQaDeLi4pCdnY2LLroIKSkpWL9+PX799dewjwcUCGw2G55++mn89ttv+OKLL6DX6yGKIqKiolzeiaRQKJCQkIAffvgBxcXFuPfee7FmzRpUV1eHRKB5hmEYhmEYhmGYYFFdXe1WkHF/wDuWGIZhGIZhGIZhGIZhGI/g4N3wXfBuf3Lfffdh/vz5wVYjIoiOjsaMGTMwdOhQ/P7775g1axZKSkqcx6w6d+6M//3vf+jUqVOtlN1nH8OqqanBBRdcgP3799cpX6fTQZIk3tF0DtHR0TAYDLDb7Tj//PPx448/OlNCu4vNZsP+/fsxefJkAMD27dvr3b2kVCohiqJXertDKI8hTOjAwVQZhvEWtjeMK7C9YZjmgc1mg0ql8nm57vhJ+ChcmPDSSy+xY8kLlEolDAYD7rnnHjzxxBPO1JDdunVD//79MWPGDHTq1AkA8MwzzzR5TKtFixbYsmUL0tLSAAAWiwUAEBsbi+eeew56vR6PPvqoM80xAxiNRhiNRgBAYWEhVq1ahdGjR3tUllqtRvfu3fHbb78BAJYvX44nnngCZWVlSEpKwn//+19ce+210Ol0KCgowLx587B69WrIsoxLL70Ud911FwAgIyMDRqMRP/30ExYvXozjx4+jpqYGJpOJ07IzDBMSKJVKjhvEMAzDMM2U+Ph4FBQUQBRFJCYmOuedDtq2besXp5K7sGMpTGjRogUUCgW/WLpJSkoKPv74Y/To0QMxMTHQ6/XOVJHAmfg9SUlJaNmyJc4//3wAcHkXTWxsrNMB5fiBW61WxMXFoU+fPmjfvj22b9/u4yeKHF5++WWPHUsOHIPo2LFjce211wJArV1mABATE4N58+Y5fzsKRe0TwCkpKZgyZQruvvtuSJIEu92OiooKfPHFF5gzZw5KS0tBRM4y1Wo1gDPfNcMwTFM4YihmZWWhZ8+eUKlUyM3NRUFBAYAzO2BFUXQ6jzQaDXr27Inp06ejd+/eUKlUICIUFxfj4YcfBgCsXLkSFovFGYsxUBlpGIZhGIYJLKWlpRAEARqNBmazGbfffjs+/vhjAMA111yD5cuXB1nDM/BROITHUTgA0Gq1PJl1gzfffBP33Xef05Hg6OpnOx0kScJDDz2EDz/8EElJSQCAvXv3Ijo6ulZZJ0+ehFqtdl4DAGazGXq9vlbZwJkjXxdccAG2bdtWx6PM/B8pKSkoKCgI2UxvVqsVy5cvx4wZM1BZWYkePXoAAB566CG0bt0aa9aswcyZM1FZWem8J9THECY04KMJkUFMTAxeeeUVDB8+HMAZO2A0GqHVatGyZUvodDpn1leFQlHL6U1ETmf32RljXYWIIEkSRFHEsWPH0L9/f5SVlfn+IZmQhe0N4wpsb5hAca4NO3tu5LCFUVFREEWRk++4wbFjx5CdnR3QOmVZBhFBoVDg5MmTfBQuEtFoNOxYagKtVosTJ04AAJKTk2v9zWw2499//4VSqUR6ejpMJhNuv/12rF+/HsCZlzTgzHbC48ePQ6fToaqqCq1bt0ZVVRWAMxOJ/fv3Iz4+HsOGDat3YDQajdiwYYMfnzIyEAQBkiRBqQzNYUilUqFDhw5ITEyEJEnOHW29e/dGQkIC2rdvj9GjR+Oll17C5s2b8c8//wRZY4Zh/IFSqUSfPn0QExODvXv3QpIkPPbYY3jggQdq7YB1B4czyVMEQYBSqYRSqUTnzp3xwgsvYMqUKR6XxzAMwzSMSqXClClTsHHjRuzcuTPY6tRi586dzsVPWZZhNpudma0VCkW9cxWr1YrLLrus1nxFrVajV69e+Pfff2EymeqtS6FQoFWrVujSpQuuuOIK3HjjjWjZsmUtp9K59dW3aCJJEoqKivD+++/jww8/xKlTp9jZdA4DBw4EgIA6lWRZRvfu3bFv3z7odDpMmjQJ/fv3d70AYigvL48AUF5eXrBVaZTevXsTABaALrzwQrJarSRJElksFiorKyOLxdJg2xmNRkpKSnKrDrVa3eDfBEEIehvMnDmT7HY7ybJMVquV1q5dS23atAkJ3VyRUaNGkdVqDeAvyD1qampoxowZFBsbSyqVilJSUiglJYWWLl1KFouFJEkiURSpurqadu7cSUDojyFMaOCwOSyhLzExMXTy5Mlgd5kmKSkpCXpbsQRW2N4wrhDJ9kahUFBsbCwlJSWRRqNx6Z6EhAQaOXIkde/enRQKRYPlOv5fEAR64IEHarWp3W5v8N5AicFgoK+//trr/iGKIq1bt45OnTpV63OTyUTp6emUnp5OSqXSOe/yJ2azmcxmMw0cODDofSvYolAoaNOmTbRp0ya/trkDu91Odru93jlkTEwMAa7ZHD4Kh/A5Crdp0yYMGjQoIjy6jnOinhwVO3r0KNq0aePy9WazGXFxcREVg6KyshKxsbH1/o2IUFBQgFtuuQUbN24MaFY0V2nXrh1+/vlnZGZmerVqT/Ucb/QWURRRWVmJRYsW4dlnn3XuVnOg0+nw/PPPY9KkSWjRogWAM7vd2rVrF/JjCBMa8NEE35GZmYkVK1agXbt2AM5kRbHZbJAkCQBQXV2NvXv3YsWKFfj999+Rl5dXJzC/IAi4+OKL8eyzzwI4E9PwxIkT6Ny5M3r06OHT8cVkMuHEiROwWq3o3LkzADSZLMIVbDYbtFqt1+8HY8aMwYUXXohPPvkEBw8e5LiOIQzbG8YVzrY3CQkJeO2115Cbm4tnnnkmyJp5xgsvvIDHH3+8wd2iROTMyuw4etXYUWMigsVigUqlqrODnoicx4HOxW63Q6vVBnSMfPnll/HII48A8O17byhitVpx991348svv2y2p3XGjRsHAPjiiy/8Wk9ubi6ysrKavM4lm+M311cYES47liRJooULF5JOp6vj1VQoFDRnzhwSRdF5vSzLZLfbyWKxUFVVFf3555/Ur18/UiqVAfW6qlQquvDCC+nCCy+kI0eOkCzLdZ7rkksuIUEQSKFQ0LRp00iSpFrXmM1mMhqNbreZ2WwOmx08TUlSUhJJklSnbVzpN5IkUVFREb3//vvUuXNn0mq1pFarqXXr1rR169Za34nZbKbWrVt77GF3yNntLggCaTQaat++vXPHj7dUVlbS559/Tp9//jn9+uuvZLPZvCqvpqaGli1bRsOHD6f09PRGd6wpFAq65JJLaM2aNXT8+HH666+/wmIMYUKDSF5BDpRotVras2ePx9+BLMtksVi8Hjfc4d13361lvxMTEykxMZHMZrPXZVssFq9tu8lkqlOuw35UVVXRjBkz6rWn8fHxdODAAaedLioqoqKiIiopKSGTyUQ1NTV08OBBysnJCXq/iSRhe8O4gsPeHD582PmZLMs0cuTIoPdhd6WioiKILVmXkydP1pmT+Uvi4+OD/bhBQZZlqq6upscffzzou8SCJXa73eft+s8//1B8fLxberhic9ixRP836Hbt2jWgL5meIkkSlZaW0rZt2yg3N5dkWa7jrPGEmpoauu2225xOh7S0NLrzzjtpxowZdMkll1BycjJlZmZSZmYmffjhh7WcWOfiC328RZbliHAqxcXFUXV1dcDbLzc3l3JzcykuLq5R/RITE+mTTz6hyspK51ZKu91OZrOZKioqqLS0lKqrq53H9nyB0WikTp06kSAIzu84Pj6elixZQkajkex2O9lsNjKbzVRVVUUlJSV0/Phx+ueff+jAgQNUVlZGZWVlZDabqbq6mtauXUuZmZlu95fY2FjKycmhyy67zOVBl2HYseS6aDQa0mg0tGzZMqqqqiKLxdKo7QlVHnvssQafMSEhwevyT5486ZVjqbS01OW6JEmikydPemyXjEYjH+33gbC9YVyhocVzu90e9D7sisTGxlJsbCyVl5cHpwGbwGQy0RVXXEFXXHGFX9vh3XffDfajBh1Jkqh///6NtpNOp6OJEyfSd999RzfeeGOD1ymVSp9vtEhNTfXLd69SqXzajlqt1iM92LHkIue+5IeaR5zxjK5duwbdIHojSUlJQXEonYskSZSbm0uff/45TZkyha644goaN24cffbZZ1RWVhZwJ6LVam105VuhUJBWqyWdTkdarZZUKlWd8/JarZa0Wi2lp6dTRkYGqVQqn3xn/KLPuAI7lpqWuLg42rt3b7C/Kp8wderUJp/3wQcf9Lh8SZLojjvu8LitX3jhBd89rJtMmzYt6H0tXIXtDeMKjZ3KcMRwCXZfPleefvppOnHiBFVWVnq0Uz9Y5Ofnk16vdz6HRqOhN954gzZv3kxDhw4llUpFSqWS2rVrR4sWLaJFixbRggULnDFsGpOhQ4cG+/FChnbt2tVpn8TERKqqqqpzrd1up0GDBjmvGzRoENXU1Dj71erVq33SZx2OT0mS/LKLTaFQ0Lx582jFihX07LPP0qeffurRZhhv5jvsWHKR+l7yQ9UzzjSNzWYjm80WdMPoqVx22WV+2fYYroiiSFarlYxGI+3ZsyekHYb8os+4AjuW6kpMTAz9/vvvYbkbqT5kWabS0lLq2LGjy23g6dG+b775xuOXxbi4uKBP2mRZpsGDBwe9D4absL1hXMGVcB8VFRW1EtycG87gbBEEgeLi4iguLo6efvpp5271EydOkMFgqHO9O2NTu3btIsIGlJSUUHFxsVv31NTU0A033FDLMXWuTJo0iSorK6myspLMZrPTQdLcOHjwYK3+KAgClZWVNXqP4yRDfRQVFbncRx27qFUqFQmCQAaDoV6HVocOHercq9frKSEhwad2ICEhgWpqappsM0mSvF5Eb3aOpbvvvpsA0Lx589y6r6GX/IULF/pJU8afOGL8BPulzxN56KGHgt18IYMsy/TXX3/RgAEDKCEhgbRabcgfbeQX/eaFr21OcxCdTkcvvfQSFRYWUnV1NZnN5pA4Ou0JVVVV9Nlnn9HAgQNp4MCBlJ2dTa1bt6asrCyKi4tze7xSKpVUWVnplg779+/3anU0JycnpNu/Id1kWaYhQ4YEvT8HU9jeNC+8tTeB6i8mk4k++ugj2rNnT63fr2OHSGVlpTP+mslkolOnTtHBgwd9EnszEjh16lSTx73OFoVCQTk5OVRQUECiKPplPLdYLHTq1CkqKysjm80WdJtx9uYBh6PHF2U25nhRq9Vu7xCy2WxUVVVVJ2TNL7/84nN7oNFoaODAgbRlyxayWq21MqdPmTIlYDandvj7MOaHH37Ali1b0KpVK5+Veeutt+LWW28FAMTExKBLly4YPHgwLrroInTo0AGZmZnOrFBM8JEkKeAZGnzNc889F2wVAACyLGPnzp0AgN9//x3dunVD3759A9rff/zxR4wePdqZ3YNhQgl/2JxwxWAw4MMPP8Sll16KmJiYBrP1RAq5ubkYPHgwjh496tNyRVFEmzZtUFBQALVa3eT1FRUVGDBgQJ0sd+6wc+dOrFixAldeeWVIZhlqSCdBEPDLL78AgDMDIIBafc9XmfIYJtiEk71p0aIFJk2aVOdzR2a1czMa8zyqNi1btkTv3r3x22+/uXS9LMvYunUr0tLSoFKpoNVqkZWVhSVLluD88893u35ZlmGz2bB582ZMmDABwJlsYGejVCoRExODgQMH4sknn0T37t2h0WgCZkPOztLnqzmfSqWCxWJBYmIiysvLa/1NEARUV1dDpVK5XWZ99wwZMgSzZs3C008/7ZXOZ2O1WrFx40ZcdNFFPivTQWpqKk6fPu3StZ7n+Q4hCgsLMWXKFCxatMjtL51hGIZh3IFtDsMwDBMI2N4wDBM2uLtVLBQZOXIkvfzyy0RElJWV1eQ20crKSsrLy3PKH3/84fX2sJiYGOrUqRNNmzYtLDLLRRpz5swJ+rZ0X8ju3buD2o52u53eeuutereD6nQ6+v777wOyBXbnzp0+z9YQCOGjCc2DULA5oSAqlYrMZnMgmjwoyLJMoiiSxWKh4uJiWrBggc/jI9QnrVu3psLCwnrHWsdxkr///tunugiCQDqdjvr27UtfffUVVVdXB/24g68IR1viirC9aR74yt5wfwkPtm7d6rOx/dprr3XGYaqqqqKqqip655136JprrqGPPvqIKioqyG63k9FopBUrVlCfPn0oJibGo7ATKpWKRo8eTSaTye9tVFFRUad+X1FdXV0ra5pKpaJ9+/b5rPyzKS0tpejo6KDbksZk0aJFzphWzSLG0rx582jgwIHO4GWuDLrPPvus378Is9kc0S/coUQkBf3UarUBd0yaTCZ64IEHKCUlxaUX8Pfee8+t8h0GzWq1unT9hg0bwnYiwC9ukU+o2pxAiiOOXajZuHPjGLhCZWUl3XHHHc44blqtltRqdaPBawPVxgaDgbKysqh9+/bUvn17SktLc+oYKD0cgVF1Oh2lpqZSVlYW9e3bl5YvX14nyK7ZbKZHH32UevXqRb169aJp06bR6dOnyWKxUHV1NZ06dapeh5XVavVrwgpZloP+m/GHsL2JfHxpb7i/hD6PPPKIz99/FQoFqdXqgI5N48aNo3HjxrkUVNoTunfvXqdOo9Hok7JlWaacnBxSqVQUExNDX331lU/KbQxJkhoN2h4sGT16NMmy7FactrB2LO3bt4+Sk5Pp2LFjzs9CZfVYrVaTWq32cwtEDo1NBnbu3EkajYaAMxH1t27dSpIkkd1up3HjxgX9h+drEQSBRo0aRQUFBXWyPTgmTg6prq6mW265xRmsXKVS0cqVK+u9x2631wmkeOWVV3qk30cffeQsz2Kx0KpVq+iWW26hWbNm0YEDB+jAgQNUUlJCGzZsoE6dOpFarabo6Gj65JNP6v2uy8rKqKysjIYPHx709vdG+MUtsgllmxNIycjIoIyMDD+3dtOYTCZauHAhpaam1tJPqVRSnz59qE+fPjRlyhTq27cvRUdHk0qlIq1WS/Hx8R4F12apK4IgOO2zO6JWq+s4yJYvX07Lly/3S195//33g95Wvha2N5GNr+0N95fQRRRFSktLC/qY4g/7kJaWRq+99prPFg+2bt1ab12JiYnO+YUkSbRixQp688033a5XkiRKSUlxZj/csWOHT/R2haysrHqfLTo6ulbWxkCIUql0ZtprNo6lTz75hARBoKioKKcAZ7yzHTt2dLkcf2bo2bx5sx9bIPw590fUs2dPOnDgAO3atYuSkpIa/CEJghBwD3y4iUajqTc7XnR0tNPZ42nZgiBQu3btaMCAARQXF1fnb419PwMHDqRjx45RSUkJrV69mjp37hzWmfzOFn5xi2zCweYEQhy7ZoKB2WymBx54IGx3NbI0LX/++afP+83+/fuD/lzeiiAIVFNTE/AsX0xw8LW94f7iPxwLuDabjY4dO0ZLliyhJUuW0KFDh6i6upqMRiPl5+fTH3/8Qfv373dmRDWbzbRp0yav08CHg2i1Wtq7d2+ddquoqGhw93NZWRn17NmT9Ho96fX6JheDHIvYZ3+m1+vdci79/vvvte7PyMigkydPBuxo+JdffklarZY6d+7szO7mwGq11llI85colUpnpsZm41gqLy+n3bt315JWrVrRk08+SQcPHnS5HH+/5D/22GMRE6vAFzjSyAd7kGMJnjicT8HWw9fCL26RTbjYnEDJ119/7fM2FkWR9u3bR3379iWtVut0OkeC45nFdZk9e7ZP+1V9RyfCSQwGg/NZ2FHQPPC1veH+4lskSaJvv/2W0tPTSalU8mKHi6LVaikjI6POTleVSkXDhw+n4cOH09ixY326eUCj0dDOnTupurqaiouLGzw2J8tyg9+jwWCgl156iURRrHMMPNBIkkQWi4XKysroxhtv9Nt35Ygt1WwcS/XhyjbRcwnkS74gCJSSkkIrV66kmpoaMhqN9NlnnzmDpQmCQEqlknr16kWHDh0iq9VKZrOZ9uzZQ3PmzKGPP/7YZ+dI/U15eTl16tQpLB0ISqWy3kFNqVSG5DlYltAQfnFrfoS6zfG3nDhxwqv2s9vt9MEHH1BiYmJY2goW/0pCQgK98MILVF1d7VH/MplM1K5du6A/hycSFxdHcXFxdOTIkXrHD7Y3zQ9v7E1ubq6ftHIPm81GZrOZysvLaeXKlTR69Gh65ZVXfLoAf3YICJPJRAUFBfT999/T1KlT6eWXX6aCggKP6hNFkcrLy+mRRx5pFruMIlkcu6A2bNhANpuNysrKKDY2tsn7VCoVqVSqoDuXzmb69Ol+aaPU1FQiYsdSs3jJFwSBsrOzadCgQZSdnU3Z2dnUoUMH2rBhQ73PKEkStW/f3nlE6eGHH6aHH37YJ2deJUmiBx98sNbqcjDbxvEy1rlzZ5cGCYc4dN+2bZvT4MiyTOXl5bRt2zY6deqUcyCRJIkWL14c9H7A4l+Jj4+n3bt3U3FxMQ0YMIAGDBjQ6PX8ot/8aC42pzEZNmxYk0kHHFu6169fT9dffz2lpqYG3VawhKc4FuBiY2Np4sSJdPz4cTp+/DhVV1fT/v37aciQIWG/e6Cx3xM7lpovvrA3CoWCunTpQt9++23Adl8UFBQ0mXhApVJ5VYckSVRaWkpPPfUUJSYmUmJiYqPjQGpqKr3wwgv0119/UXFxcYPzoerqarr11ltdOorF0nwkFOJMns3rr7/ul+d09/h1xDmWPCHSXvINBkOtSPzLli1r9HqVSkWLFy+uY1xEUaSioiL6559/6OjRo86UlZIkOdMwf/XVVyE1OWjfvj39/PPP9PPPP9OpU6do1apVdc6jqlQq6tixI/Xv359at25N8fHxNHToUDKZTG6nyXSckeZ4T5EncXFxtc59O/p+Y/fwiz7jCpFmc84Vx8RfrVaH/QSfhSXQUlVV5dL4wfaGcQVX7I2/MnzKskyTJ092ue937drV7TpeeOEFn2TK1Gg01LNnT+rZsyfNnz+fPvnkE+revTs7k1galEBn8W6K8vJySkhI8OkzLlq0iHJzcwlwzeYowUQcFRUVaNGiBZRKJURRbPJ6u92OG2+8EQCgUCgQFRUFURRBRA3eo1AoIMuyz3T2BYIgQKfTQaPRAACioqJgMBiQmJiIoqIiyLIMpVKJESNG4IMPPkBiYiIEQQARQalUQhAEt+vUarUAgMrKSsTExLjU3kzoo9PpcPToUef3C5zp847/hlrfZ5hQgoh4LGQYD1AqlYiJiQm2GkwzIzY2FjabzWfliaKIhx56CO+++65b70v//vsvysrKkJCQ4NL1l19+OX788UdP1ayF1WrFzp07AQD33nuvT8pkIpv+/ftj27ZtXpVBRDh06BBOnDiBSy65BCqVyuOyDAYDiouL8dRTTwEAZs+e7ZVuALB3714MGDDA5evZsRTBePJiL8uyS0YgFCfWRIS9e/di0qRJAIAePXrgyJEjOHTokFNfWZZBRE7HmyfOpPrQarX47rvvMGrUKJ+UFywUCgXozE7GYKsSNKKjo3Hq1Kk6L/f5+fkAQrPvMwzDMOGHSqWq5YjdtGlTkDVimiN2ux2yLDsX0Lzhr7/+Qp8+fTy+v2XLlrBarVCr1Y1et3fvXp85lRjGE/744w8YjUZER0e7fE9NTQ3y8/Px559/Ytq0acjNza3198zMTKxbtw5ZWVlQKt130ygUCtx0000AgDlz5ng9n7vhhhsQFRXl8vXsWGIiClEUcejQIQBw/vdsZFnGzz//jFdffRVTp05FTEwMFAqFT4zp0KFDoVKpYLfbvS4rWLDTBDh+/Hgdp9KOHTtwwQUXBEkjhmEYJtL47LPPcOuttwI4szAmSZJHEwmG8QX9+/fH5s2bvSpjzZo1uOyyy7zWRavVYsuWLejXr1+9fy8tLUWXLl28rqe5otFoIMtyWM9XQoXU1FTk5+fDYDDU+3ciwv79+wEAAwcORElJSaPl5eXloV27drU+i4mJwY4dO+p83lB9jzzyiPP/vaVr164oKChw+Xq2YEyzw2q14vnnn8f8+fPRo0cPdOnSBT169MAll1wCAMjOzvbo5U6WZURFRfFAHcao1Wq0bNmy1mfXXnstli9fHiSNGIZhmEjklltucf6/IAjsVGKCypYtWyCKosf9cObMmZgxY4ZPdCEi5OTkQKVS4Y477gAAPPjggzCbzRg3bpxzos64T79+/fDzzz/j9OnTaN++fbDVCXtMJhMSEhIQFxcHWZZRU1MDSZIgCALUajVkWfb6mGl1dTXat2+P1q1bY926dcjOzq53QwQR4b///S/WrFnjVX0OBEFwa7cSAHi/TYNhGIZhGIZhGIZhGIZplvDyCNMsISKUlZVh3bp1WLduXa2/KZVKtGnTBvPnz8fAgQOd57wlSYLZbIYoitDr9VCpVM4YTbIs45tvvoHFYgn4szC+49wVgN9++413KzEMwzA+x1cxHhnGVyQmJuKbb75B586dYTAYoNPpmrzn6NGj6N69O0wmk8/1sdvtePfddwHA+V/GMxyJjVavXo3o6Gi0adMGOp0OZrM5yJqFP0SEioqKOp/5ek6Ym5uL8847D8CZuWpGRgbmzp2Liy++GHl5ebjhhhtw/Phxn9bpbogUdiwxzDk44jQNHz4cwJngmkql0nke2RHg0GAwoEePHgAAm82G7du3B1NtxgdYLBYUFBQgNTUV1dXVGDhwYLBVYhiGYSIQq9XqnOwxTChQWVmJSy+91PnvxMRE7Nu3D4mJibWu27VrFwDgoosuYsdEAFEoFLUWu5vK4H028fHxAOA86ihJEiRJ8o+ijN8RRRHHjx/H2LFj/VYHEeGpp55yxgJ0BT4KxzBNYLfbYTabYbVaa2WXO3vH0++//+7TVK1M8MjKykLbtm0RHx/frLPjMYFFrVajZ8+e0Ol0Lq0SMwwT3pwdY4lhQpGSkhIkJSXh/PPPx4wZM3DVVVdBo9GgZ8+e6NmzJzuV/IhOp0NcXBwSEhIwePBg7N+/3zkfMZvNsFgsOHr0KIYPH+6Sg7qkpAQlJSV44YUXkJubixkzZrg8bxEEgXdYNlNmz56Nzp07u3y9QDxzQn5+PjIzM4OtBsMwYU5eXh4yMjKCrQYT4pxrc5RKJcrLyxEdHe1cQWzXrp3PtzQzDBM6CIIAURTdzkrrGD/Y3jCuwHOc8EKv12PdunXo2bOnc2xoLIDy8ePH8Z///MetzF2uZLA2GAyYNWsWAGD06NGorKzENddcU2/GbaZ54IrN4aNwDMM0G5RKJQYOHIglS5YAOLM1uKysDB06dKhzPpphAkWrVq0QHR0N4P9eINeuXcsZWxgmgiEiPPnkk5gzZ06T18qyDLPZDK1WGwDNGIbxJ4mJiRgzZgyAMxm/1q5di6qqKnTq1AkbN25ETEyMy2UlJSW5faStMadSmzZt8OeffyIhIaHW5+np6Thw4AAuvvhibNmyxa36mOYDO5ZCFL1ej/bt2yM2Nha5ubkoKSmBzWaDKIpuB9JimOaKIAjYt28fOnTo0OA23qSkJOTn5zsn9gwTaIqKiup85m3QR61Wi8zMTBiNRpSUlDS5OskwkYRer8d7772HMWPGOJ0xRISZM2di5syZQdbu/3jttdfw6KOPomXLlnX+5jhQsGfPHgwbNgyFhYUA4HE6eIZhAktCQgImTZqElJQU7NixA7Is47777kNOTk6t37EoijCbzdDr9W7vYFSpVBBF0Sf63n///Xjrrbca/LsgCNi8eTMyMzORn5/vkzqZyIKtU4ig1+udk4sWLVo0eT0R4YYbbsCyZcv8rRrDhC0Wi8UZ6LAx9Hp9ALRhmPqxWCz4/vvvceWVV8JqtQIABgwY4HF5rVu3xs6dO2EwGJzl7927F/Pnz8cXX3zhrINhIo2+ffti69at9S4kCIKAGTNm4NixY1i4cGEQtKuL3W7Heeedh48//hgXXHABSkpKsGHDBqxduxbbtm0DAJSXl9e5h2GY0MGxMOl432zVqhXefPNNDBo0qNFjbA6USqVbu5TORqVSoUOHDti6datH9zvQ6/V48803Xbr2xIkT6NGjB/7991+v6mQiD46xhOCfP27KQ9wYx44dQ9u2bX2sEcMEBq1WCyLyy0TXMVF3Rxdv9eCYF4wrNGRzzu6DnppmhUKBvXv3omPHjvX+vbq6GsnJyT5Pg8swwebgwYMuHR+VZdmlyV6ow/aGcYVgz3EiFUEQcOONN2LBggW1NgQQUcCDXR8/fhwXXHABysrKPC4jJyfHrSNuRITTp0/jo48+wltvvYXi4uI61ygUChARJ8KJEFyxOZwVLshotVqPnUrAmbOwt956q1upABnGFwiCgISEBPz000+QJAmyLKO6utqZLcRhWLOzs7F9+3ZUVlaisLAQ+/fvR1FRESRJcma2cBgeURRhtVpRXl6O+++/32Pdpk2b5pZTCQCGDx/ucX0M4wvO/i14yqBBgxqdXMfExKCqqsrj8hkm1Ni2bRu2bdvmckwyd4+aMEwkwlm+3Eer1aJNmzaYOXMmqqur8cUXX0Cv1zvfdwVBgEKhCHjbZmdn49ChQ+jQoYPHZZw8edKt6wVBQFpaGp566ikUFBRg586dmD59Oj7//HNUVFSgoqICNpsNVqsVmzdvRseOHaFWq4PSPkzg4B1LCK43f8SIEVi9erVXZTi+wub+suQYqJpLl1apVFAoFJAkyWfnq5siNTUV+/fvR2xsbJOGQZZlyLLsVTyIqqoqxMXFuXx9u3btsHv3bo8CnDrS6tZHQkIC3n//fQDAZZddBoVCgT/++ANjx45FSUmJ8zpeQWZcwRubk5KSgh49eiApKQlWqxVlZWUgIowYMQIA8MADD0Cn0zVZjiiKUKlUHunAMKHC1KlT8dprr7l1DxFFxPsS2xvGFRz2pm/fvigoKEBJSQmsVivHa3UBrVaL9u3b45lnnsHw4cOdMZBC1TFitVrRvXt3HDx40KP7d+7ciR49ejR5nWNX1tnY7XaYzWZER0fXO77Ksgyj0eicrxw5cgQPP/wwtm/fDpvNFlFzN4VCgZSUFMTFxeHgwYMR81tzyeYQQ3l5eQQgKJKenu6z5zAYDEF7joZEo9HQiBEjaPbs2TR79mzq2bOnV+UpFApKTk6m1q1bU3x8PCUlJdHkyZOpvLycZFkmSZLowIEDdODAAerTpw/FxsZSSkoKDRw4kC655JKQbCNXRKlU0mWXXUa5ubmUm5tLdrudZFkmWZZJFEWqrq6mhQsXUnx8fK37VCoVabVa0mq1JAiCV/WfOHHCZ33VHSwWCyUnJzep46ZNm7yqR5ZluuKKK5xtNnz4cDpw4ABJktTkvY4xJC8vzysdmOaBpzbnscceI6PRSJIkkSzLPtPngw8+IIVCEfRxjoXFHXn22Wc96u/79u0Luu6+ELY3jCs47E1ubi6VlZXRqFGjeLxvQOLj4yk+Pp7eeecdKiwsJLvdHuyvz21KS0tJr9d73AZXXXUVFRcXk91uJ1EUSRRFMhqNtGjRIkpNTSWVSkV6vZ5mzJhBFouFZFkmq9VKO3bsoB9//JFsNptb+hYWFtLq1atp06ZNtHXrVtq6dSvdcsstXs1ZgiVarZamTJlCp0+fJlEUSZIk2r17d9D18pW4YnPYsUTBdSwBoPLycp88R1ZWVtA7HXDG+dOtWzdav359g5Nyi8VCGzdupNGjR1NCQgKpVCpSq9XUvXt3OnTokHMwczhN8vPzqaamxus2kmWZSkpK6OabbyaVSuXT5xYEgdRqtdv3ORwZsbGx1KVLF3rjjTfo6NGjVF5eTiaTiURRdOsZHUagPoNoMpkoJyfHJb0uuugiuuiii8hisXjd7r7g7Im0LMtkMpmovLzc6VT0BVarlaxWq9v3sWOJcQdPbM4zzzwTEN1kWabCwkLKzs4Oui1hYWlI9u/f71H/ttvtFBMTE3T9fSFsbxhXOPv9RJZleuqpp4Led0NNFAoFzZ8/nyRJcmkxMdSZOXNmwNotOzub4uLinI6gCy+80CftWF1dTWlpaS7rIgiCR84oXzlZ586d26AjcuzYsTR27Nig93NvhR1LLhJsxxIAmjJlCplMJjKZTB5PkjUaTdCfQ6FQ0IIFC9z28kuS5LYDxVtOnTrlkSPobHEMZA8//DBZrVaSJInKy8vpxhtvdO4SOls0Gg3l5OTQsWPH6NixY0EzYKIo0lVXXVXvM+n1+ogwrGdTWVlJbdq0qfOsI0eOpIqKChJFkex2u8fPzY4lxh3ctTkGgyFoulosFpo3b17ETMZZwlvi4uI8WmSSZZm2bNlC0dHRQX8GXwnbG8YVznUsDRo0yOu+59gJ3759exo3bhw99NBDNH78eOrXrx9lZmZSbGwsKZXKoP9GGhPHYvCFF15IlZWVwf6afMqRI0dIp9MFrW1jYmIoJiaGSktLvVr4lWWZfv/9d/r0009p8+bNtHLlSuratavTgaRQKGj8+PE0fvx4Ki0tJaPRSB999FG982FBEMhgMND06dPrtSE1NTV05MgROnr0KBUUFNDq1atdfu85fvx4o89RUVFBFRUVQe/z3oorNif8D5kzDMMwDMMwDMMwDMMwwcFjN2IEEQo7ls4VhUJBOTk5Lh2TW758OS1fvjzoOgOg2NhYqqio8P+X5iOeeOIJj7+fSy65hIxGIxmNxnrLdsR8csRC8mVMFF/hWMXt378/DRkyhIqLi4Otks/ZuXNnk1tdtVot9evXj3bv3u1RHbxjiXEHd21OU6thgUKWZfrwww+DbmdYmp8olUpasGCBR3a0uLjYpTh94SZsbxhXOPv9pLi42OOdRFdffTVVVVW5XK8sy7R79+6Q2u2q1+vpqaeeon379lFxcXHIhHrwNRs3bvQqzpIvRafTUa9evejHH3/0yTxIkiRasmQJDRgwgBYtWlTv/EoURdq4cSPNnTuXNm3aREaj0aO67XZ7k7tc33nnnSbLceh4bhzccBNXbA5nhUNws8K5ilqthk6nQ3x8PC6++GLcc889SEpKwrPPPosvv/wy2Oo5UalU2Lt3L9q1axdsVVyipqYGer3erXuSk5OxZ88eJCYm+kkrxlfYbDa0bt0ahYWFLl2vUCjw119/oWfPnm7V4xhDOEsP4wru2BxBECBJUkhmodmxYweGDRuGsrKyYKviE7KzswEAmzZtQnp6eq02t9lsiImJgc1mC5J2zRNBEPDQQw9h7ty5iIqKcvv+H374AVdddVVEZRxywPaGcQWHvZk/fz7++9//wmKxuHV/TEwMTp06hejoaI/qt1gsaN26NYqLi92+V6vV4pZbbgEAPP7440hKSoLNZsP+/fuxYMECrFq1CmVlZY1m3VIoFEhOTsaXX36JgQMHBiUjpGP8qc+O19TU4Oeff8bff/+Ntm3bonv37oiLi4Msy7BarbDb7bBYLDh58iT27dvnfNaRI0eiR48etTIv19TUYPr06fjwww9hNBoD83BukJqaigMHDiA2NhYAnFmtNRqNW+VYrVZs374d3bp1cytztCe8/vrrePjhhxv8u9lsdjkT9bXXXovly5f7SrWA44rNYccSwsOxFE60b98ea9euRWZmZlik9HV3wlZeXg6DweAfZRifUl5ejrS0NFitVrfu27hxIwYMGODy9exYYtzBHZujUqlC3plhNBrRuXNn5Ofn1/t3jUYDu90OACGRdlcQBPTr1w+zZs1C165d0bJlS6hUKpfu3bdvH7p27RoSz9EcmDJlCubPn++RY3Xz5s3o379/RDqVAHYsMa7hzRzHYDCguLi4lvPCE+x2O66//noAwHfffdfgb1KhUKB79+6YOXMmLr30UrRo0aLJ374oirBarbBYLCAiKBQKpxNaqVRCq9V65JRuDEmSYDabYbPZIEkSampqAABFRUXIz8/Hnj17sGLFCuzatavO+6djXuRLG6JUKiGKos/K8zcajQZKpRI2mw1RUVF46623MHnyZJfvLykpwUsvvYT//Oc/uPrqqwHAb/PNhQsX4rbbbmvw71arFWq12qWy3n//fdx9992+Ui3guGRz3N4XFoGE4lG4cBetVks9evSgmTNnUmFhYcgeBSMiSk1Ndfm5hg4dGmx1GTcQRZF69+7tUR9u164d7dixg2pqahrtu9XV1fTjjz+6vE2UYdyxOYIgBFtdl/nuu++cCRG0Wi19+eWXJIoiybLszPJZUlJCO3bsoK1bt9J3331HI0eOJL1e32A2F41GQxqNhmbNmkX//PMP9erVq97rzj3u6ggu+8EHH1BhYSGVlpZSZWWlzxITOFIsb9y40VlXsO2uO/Z53759znTIkiSR3W4nq9VKlZWVtGTJEoqNjQ26noIg0KZNmzz+fi688MKgP4M/he0N4wrezHGKiop8ro/dbqe9e/fS5MmTqU2bNpSenk5jx46l3NzckJ0nEBHZbDb65ptvyGAwBP23H4nSr18/stlsZLPZiOjM+/uuXbvogw8+oN27d5PZbHba3LO/g9TUVEpNTaW//vqL7Ha7z/tQU3NEd34jW7duDXo7eyOcFc5FmptjaeLEic4I9RaLhUpKSmjlypV099130zXXXENTp06lzz//nN5//31q3bq11/UJgkBZWVmUlZVFu3fvbvBHH6xMZIcPH3bpOZRKJZlMpqDoyHiO3W6nqVOnep01MTo6mqKjo2nq1Km0YcMGevzxx+tkFeQXfcYV3LU5p0+fDrbKLiOKokdxKxyZGW02G1VWVtKePXvoyJEj9aYtNhqNNHDgQBo0aFCdmH7BzGhpNpvp6aefpoyMjKDb+frsl1KppNdee83lNqqpqaFevXo16MwLhDz99NMefx8DBgwIerv7U9jeMK7g6RwnOTk5pB09/kSWZTp+/DjdeeedlJaWFvIZ7lhqS1JSEh04cMDrfmC1Wpusa+/evS6XF4zMcHfddRetWLGi3szY7grHWHKR5nQUbvr06Xj++efdumfHjh244IILfKZDp06d8Mknn6Bnz56IioqC0WjEu+++iy+++AL9+vXD+++/7/W2W3cgIqjV6jrbSFUqFVJSUhAVFYXU1FR88cUXaNu2bcD0YnyPJEmQJMm5NfmXX37BDTfc4LOjRnw0gXEFd21ObGwsKisr/agR42tkWcbgwYOxcePGoOqhUChw9OhRZGVleV2W3W5HUVERXnnlFbz11lsBOQ6o0+lQVlbmcgyLs1m/fj0GDx7sB61CA7Y3jCt4OsdJS0tDfn5+WIS08AUmk8k5Xmzfvj3I2jC+4N5778Xbb7/t8f0ajabR+YFKpUJBQQFatmzpcplardbt8Bzu4ohZVV1d7TzmL4oioqOjvaqbj8K5SHPZsaRQKMhut3vURvv37/e5PoIg1Juty2AwUHV1tY+/5YaRZZm6dOlSS4f09HTKz8+vldWNiUw2bdrksz7NK8iMK3hic7KzsyM2g02kIopig0f8AiVbtmzx2/Pl5eU5Mz4JgkAXX3wxFRQUUE1NDdXU1NCvv/7aZEYdV6RHjx4evbvY7fY6tj2ShO0N4wrezHFmzZpFRUVFVFJSQqWlpRH3LizLMm3bti1kMqix+F5iY2MpPz+/Vt+VZZnsdrvzCLgoirX6hc1mc6lP9O/f3+1d0kuWLPHr8+r1+np3ehMRjRw50quyeceSizSXHUsGgwHl5eUe3//JJ59g0qRJPtSoYVQqFT788EMAwHXXXYeoqChYLBaIogiDweDTHU0mkwkDBgzAv//+CwCIj4/Hjh07kJ6e7rM6mNDFZrNBq9X6JMArryAzruCwOW+88QaWLFmCAwcOwGg0urRzbuDAgfjpp5/czqLiKVarFTt37kRGRgaSk5MhCIIzq9DJkydRU1ODjIwMREdHQ5ZlEBFatGgRsavcoiiisLAQGo0GcXFxUCqVDQaXlWUZ0dHRMJvNHtX1xBNP4IUXXnC2ZVlZGa677joAwJYtW2Cz2ZoctywWS8D6SkPIsozTp0/jww8/xOzZs93OSgUASUlJ+Pfff5GcnOzWfb/99htuueUWlJWVQa/Xo2/fvujTp48zU+j333+PvLy8kArwrVKpkJGR4QwIe+LEiXrbjO0N4wq+nOMIgoD8/Hy0atXKJ+UFAyLC77//jlGjRqGqqirY6jBhiiAIWLlyJUaOHOn2vdHR0TCZTD7XKTk5GadOnWowWP1HH32EO+64w60ylUolWrRogaqqKt6x5CrNZceSXq/3erVh6tSpNHXq1IDqrVAoau1s0mq1NGfOnDoe5qaQJInmzZtH6enplJ6eTqNGjaL777+fcnJyKC4ujgwGAxkMBnrnnXciblWGaRiLxeKzXQW8gsy4gsPmnN1fZFmm3NxciomJce4CaUjUajXl5ub6Xc/KykpSqVTOelUqFWm12jpjcn22pqSkxO/6eYssy7WCV+fl5VFeXh6NGjWKoqOjKS4ujkaPHk3r1q2jlStXUocOHeqMFUql0hm8u1OnTrRp0yay2Wxkt9tp0aJFHo8ljzzySKO6S5JEP//8M+l0ukbLqampCVBrukZxcbHH461CoaBDhw65Vd/x48dp6tSpdP/999O2bdvIarU6dyHLskylpaXUr1+/oLyT1ScdOnRocGeiI9h6feMHwzSEP+Y4ZWVlVFZWFuxHcxlJkmjdunU+2UHJwgKcsUcrV670qD+uW7fOp7oIgkBt2rQho9HYaL2OREOuyrRp09y2OexYoubjWAJA+/fv96qtHC9jS5cuDXrWGI1GQ9dffz2tWLGCNm3aRCtWrKDPP/+c1q5dS2vXrqXc3Fyqrq6miooK+uijjxoN3qxUKqlnz57Us2dPqqqq8lHPYsKBHTt2+KxP8os+4wqNGenKykqqrKxscvItCAI99dRTfjseJ0lSo84jV8SR3SUUkGWZzGYzrVixgjp06ODXYKxqtbpJh09T4krg0crKyiYnSv7I6uQNsixTXFycV23j6rG46upqmjZtGvXq1YtGjx5Nu3btqvfIw8033+y3vuBuv2lqYkDU+PjBMOfizzlOqCa0MRqNZDQaaejQoUH/XbNErrRu3dqj30B1dbVP9dDr9bRo0aIm612/fr1L5SkUCjp+/LjzPndsTuAiJDMhwUUXXYR///3X422sji3/Y8eOxVVXXYVPP/0UDz30kEdb273FarVi6dKlWLp0qU/Ke+yxxwAAMTExPimPCX1EUcSoUaOCrQbDOImNjQUADBgwoNHAz0SE559/Hs8//zwUCoVz3Grbti0uvfRSDB48GJ06dUJqaip0Ol2t41pEhP3792Pu3LkAgMzMTDz66KOIjo4GcCZIc1xcnNfBmZOSklBRUeFVGe4iyzJ27dqF2bNnAzhzFKqsrMylY2O+whfJAF555RV88MEHjV7z9ddfw2g0NnqNI3BnqEBEHh8NdBAdHd3kO8f+/ftxySWXoKioCESEXbt2YceOHfjggw/Qv39/5+9h/fr1+Prrr73Sx1e0bdsWer0+2GowjMvo9XpIkhTUo892ux133XUXFi9e7PXYwjDukJubi1atWqGgoAA6nc7l+44dO+ZTPURRdGnumpaW1uQ12dnZ2L9/v+dH6N12s0UgzWnHEgCKi4tzbvn3BaIo0iuvvFIn9Xo4SXx8PFmtVrJarT5pEyb4SJJE1dXV9e7oMJvNZDabfR7YlVeQGVdwZfXn888/9+n4Nm3aNFqzZg1Nmzat3t2mSqWSMjMzKTU11ae/iUAdl6ipqaHx48cHPVi2L2X06NFUVVVV62i2w049/fTTLj2ru4FF/Y2v+nV8fHyDdcyZM6fRe5VKJalUqlrHPENBpk+f7lIb8o4lxh0c/eXIkSN08cUX+7zftmnTxme6mkwmMhqNDYajcBxftlqttHbt2pD7DbM0TxEEgfLz813q43a73S/B4keNGtVkGBej0Vjvbm2VSkXr16+n9evX13sf71hiGqWyshIPPPAAAOCbb77xuryoqCj897//xf33348JEyZg8eLFIRUI0xUef/xxZ6BMJryRJAkrVqzAxIkTnSnaY2Njceutt+Lyyy/HunXr8NZbbwFAUHbaMYwrHD582GdllZeXY/bs2c5dPPUhiiLy8vJ8VqeDtm3bepU0oinMZjOGDx+O3377zW91BIvly5dj+fLlUCgUUKvVICK3UgVfc801IRVE/cCBA7j55pt9UlZ5eTkEQcCaNWswaNAgAEBJSQkuvvhinDhxotF7RVH0iQ6+5uqrrw62CkwEo1ar8dtvv8FkMjl3p/qCY8eOwWQy1bvb7u+//8add94J4MwuXADo3bs3ZFlGfn4+/vnnH6xfv94ZTP9ctFqtcweotztoGcZfEBEyMjIwZswYzJ8/H1qtFiaTCXa7HVqtFna7HQDw2Wef4dlnn/WLDVq7di3y8vLQunXrBq/R6XRo3bo1jh496vxMqVQiLy8PKSkpPtEjdN44GIZhGIZhGIZhGIZhmPDCpX1bIcyLL75Iffr0oejoaEpKSqLRo0fTwYMH3SojnI/CtW7dmj799FP69NNPacyYMS5v2Xvuuefoueee88t3UlpaSn369HFu0xcEgQYPHkyDBw+miooK51bW/Px8mjhxIqWlpZFer/drMNWmxJWAmZFAfn4+9erVi6Kjo8lgMFDr1q0pIyODtFqtsy00Gg1dfPHFNH/+fJo/fz7NmTOHRo8eTd9//32w1W8QURTp0KFD9PDDD/v8KE9TolAonNux+WhCZOMLe0PU+LZiR4KEYCdH8KU89thjvmj+OpSWlobUEWyVSkXTpk2jtWvX0kUXXRRUXdRqtduZU/2F2WymRx55JOjfTyiLIAhUXV3tUnvyUbjmgy/nOGf3l4KCAp/337PDDowdOzbovykWluYm6enpTSZ0mTt3bq175s+f79EY0hBh71gaMWIEffLJJ/Tvv//Szp076fLLL6fs7Gy3UuyGq2Opvol+WVlZk3EXxo4dS6Io+v2l0+FAcuf6yspKuuaaawLajtnZ2X5sheBjsVjIYrFQRkaG1201bNiwYD+Ok8rKShozZgyNGTMmKE7JIUOG0OnTpzn9czPCF/aGqHEjPWXKFJoyZUrQ7YuvZfHixbR48WJffRVkNBq9zlrnidRnX2NjYyk2NrbOAkVFRQVlZWWRIAikVCqpb9++tGnTJtqyZQtlZ2f7TUeFQkH79u3zWVufjSzLVFRUREuWLKHx48dT9+7dKTU1leLj48lgMJDBYKCEhASn6PX6iIp75S/JyMhoMj6GA7Y3zQdfznHO7S/nTjBZWFjCXwwGA61atYpWrVpFFoulll2RJImWLFniXJCLjo52KXtvs3IsnUtRUREBoN9//73BayorK53Bq/Py8uiPP/4Iekc4VxQKBT3xxBO0bds2evjhh0mj0Tj/ptfrGw2IWlZW1mC51157rcsvL8GktLSU4uPjKT4+3q/trNPpqKCgINiP6zdkWaYOHTpQhw4dfNZmrq6qEp1JqenrdLRms5muv/76oEwqHTJy5MhavyN+0W+euGJviBq2OWf3F0mSaOTIkUG3Pf4WXwTzLi4uDrjeCQkJ9Pfff1NlZSXt3LmThgwZQomJiXTZZZeRzWZr9OVMFMU6iyyyLNP1119P119/vU/1NBgM9Ouvv3rdxvVx5MgRSk1NZUeRH+SXX35x+Xtge9N88WaOU19/ueaaawK+mMvCwhI4USgU1KFDB3rnnXdo4cKF1LlzZ6cN79q1q0vjTrN2LB06dIgANLpa9+yzzwb9i25M0tPTyWw219JZFEUqKyujyspKlxxDO3bsqFNuZmZmWDiVHDiOhMybN89nToS4uDh68MEH6ZdffqEDBw64vdMg3LDb7aRQKHzqhImLi2uwPlmWacaMGTRjxow697Vt25amTZtGr7/+Oi1btszjts/JyQn6b/Sff/6ppRO/6DdPXLE3RA3bnJiYGIqJiWlWmW0EQXBphawhFixYEHCdr7nmmnp33/rKnvpiTIuOjqbly5c3uQ3eU6qqqmodmWbxnbh7bJHtTfPFmzlOY/2Ff9ssLM1PevTo4dK4447NEYjCLH1XIxARrrrqKlRXV2P9+vUNXldVVYWqqirnvwsKCtC3b98AaNg4o0aNAgD88MMPPimvvLwcl1xyCY4fP44rr7wSCxcuDKkMMe4gyzJ27tyJDz74AC1atMD48ePRrl07VFRUYMyYMdi+fbvzWkEQAABXXHEFZsyYgeTkZGg0GhgMBqhUqmA9QlAgIrRo0QKAbzOgvfDCC3jiiSegUCic2T3uu+8+/PDDDy5nBNTpdCgrK4NWq3W5Xrvd7nL2vsGDB+Ott95CSkoKrFYrCgsLUVRUBEmSnBkZ/v33X3zwwQduZ8OqqKhAXFyc89/5+fnIzMxEXl4eMjIy3CqLCU9ctTdA6NqcYLJo0SLccMMNUCqVzjH7bKxWK4xGo/Pfhw8fxqWXXgqTyRQQ/WJiYjB69Gi8/vrrSEhI8Ht9ycnJKC4u9ujemJgYnD592jnW+4P//Oc/2LJli9/Kb850794du3btcvl6tjfNE2/nOI31l+LiYiQnJ/taZYZhQpj4+HiUlZU1eZ1bNsclV1WYcM8991B2djadPHnSrftCIcZSenq6n1qleWC32+nAgQNUWFjo3OnEnOHbb7+lb7/91qf9VaFQ0Lhx42jWrFnUtm1bj8sZNGiQW8+yevVql8t1tQ9YrVa3Y9qcuyuAV5CbH57aG6LQsDmhJIIgkFarpejo6KAecXXIH3/84Yce0zhWq9WjWHGdO3f2a7xER4w+Pv7mP5k4caJb3wnbm+aJt3OcxvqLJElB/x2wsLAEVhQKhc/GEAfhuX2lHu6//358//33+PXXX9GqVatgq+M2+/btC7YKYY1SqUSHDh2QnJwMQRDqXQFvrlx99dW4+uqrcfr0aYwYMcKtHUINIcsyli9fjldeeQVHjx71uJwNGzbggw8+gCiKEEWxyd1OY8eObbJMQRCwdOlSl/uAWq3G9OnTYTAYXLpeo9FAqVS6dC0TmQTT3tx1113Izc1FWVkZSkpKUFZWBqPR6Fyl3rJlC1JTUwOqk7cQESwWC4xGI2RZDpoen376KT799FNceOGFAa9brVbjv//9b5PXOHR0tNXevXsRFRXlN70uvfRSXHrppS7vRGXcJz8/P9gqMCGOv21OQUGBz8tkGCa08cv7lmv+7tBFlmW69957qVWrVh6lfSYK/uqxu7uVRFEku93u0bMyjCzLdPr0aWrfvr1X/dZgMFBmZqbXK9mCIDgDtWdkZFBqair17duXduzYUWvX0ZtvvulSeTExMW7FGbHb7fTdd981md5dEAQSBIEGDx5cZzcUryA3D3xhb4g8szmdO3d2ayfm1KlTg74aFm4SiGypjbFly5YGd2y1bt3arSyrriBJEu3evZu6dOlCsbGxNHToUCouLiZZlslut9P48eOD/p00B4mOjq6TUbAx2N40H3w5x6mvvzh2+Acjsy4LC0vwxdsx5FzCftn93nvvxRdffIHvvvvOGWcAAOLi4qDT6YKsnWu8/fbbLl9bXV2Nxx9/HDU1NXj55Zf5TDTjNoIgICUlBQcOHMCePXtw2WWX4eTJk26VYTAY8O6776JDhw64/fbbsXPnTo/1ISKUl5cDgPO/p0+fRu/evQEA0dHREEXR5RhRNpsNx44dQ6dOnRqsz2azAQD279+PRx99FBs2bHB+5kCv1yMjIwPx8fGorq6GJEkAgGuuucbtZ2Qig2DZm5iYGOzdu9ete1599VV8/fXXyM3N9ZNWkUewd7rOmTOn3hXE6Oho/P333z6LkZifn4/zzjuvzpj3888/IykpySd1RDparRZ33nknMjIy8Pnnn2PPnj3O2H3uYjQa0bVrV7z44ou46qqroNfrfawtE6742ubIsoySkhL8/PPPmDVrFvbv3+9rlRmGac646fgOOdCAB+6TTz5xuYxg7liKj4+vkwGuMZYvX05xcXFkMBjom2++8aDFGKYusiyT2WymwsJCOn36NFVWVpLJZCKTyURlZWW0evVquuSSS6h169Z07bXXOmNZERGVlZWF3GpXXFwcrVu3zrn7wPF8K1eupL59+5JWq20yC4pWq6VOnTrRwIEDqVu3bpSZmUmZmZk0bNiwOqvLvILcPPCFvSFy3+YsWbLEI31XrFgRkN+aRqMJ+m/eF7Jx40bauHGjR23tLfv27WtQr4SEBK8y6Z2Nqzs/WeqX3bt30+7duxts30ceecTrOtLS0qikpKTBOtjeNB8a6iPhMsdhYWEJbXFnDGkWO5YojM/963Q67Nq1y62YN2lpaTAYDNDpdDj//PP9qB1DRKipqYEkSdDpdFAoFBBFEcePH0dxcTH69u3rcoayUEcQBGi12nr7YosWLTBixAiMGDHC+Xs7e2U/Pj4eXbt29WrXkq+prKzE4MGDIQgCNBoNJEmC3W53qwyLxYL9+/fXWdHLy8vDNddcg7Vr1/pSZSYMCJa9sVqtHt3Xrl07H2tSm9TUVBw5cgRRUVFYsGABHn30UYiiiO7du+OHH35AYmIiSktLcdttt2Hjxo0A/u9M/7m7ZUKBgQMHAgDWr1+PQYMGeVQGEcFqtcJutyM6OrrOLii73Q673Q6lUunc4XL33Xdj0aJFDZZZVlaGTZs2YciQIR7pBMDZ/g8++KDHZTRnFAoFiouLm8wQOHfuXIwbNw4XXHCBx3UVFBQgMTERd955JwDg3XffDduMvox3hPMch2GY0MbV2LLuEPaOpXAlOzsb//77r9tbnnv37o2vvvoK8fHxaNOmjZ+0a95UVlZi1KhR+P3335u81uGI2bdvH7KysgAAZrMZf/75J/bv34/WrVujQ4cOiImJgUKhgFKphEajgUqlAgC/Bl31Bw0dFZk2bRpuuOGGAGvTNPT/gwL7mp9//hmFhYVISUnxedkMcy4PPPAAbrnlFrfvW7VqlR+0+T+uu+466HQ6CIKAe+65B9dffz1atGiB6Oho5zWpqalYs2ZNrfuICPn5+cjOzg5qsO6GuOSSS2AwGJCbm4uYmJg6f7dYLNi9eze++uorrF+/HgcPHgRwxnacOxF0HD2WJAklJSUeTxSHDh2KwsJCj46qbd++3WNHGXPGqfT333836VRy0Lt3b8TExKC6utqrej/44AMAQOfOnfHQQw95VRbDMAzDnM2sWbN8XiYvgTAMwzAMwzAMwzAMwzCe4fIh3QgmkOePY2NjafHixW5l9wkV7HY71dTUUE1Njc+z0wQTR9YNR9Yvf/cBhULhjPGTlZVFc+bMcSsjjENnSZLq9CNHho9AU1lZGfRzwoGWiy66yPn8HPOCcQdPbM6NN97oVh2FhYVNxhHzVtq3b0/V1dUkiiJZLBYymUxujT8bNmwI+u+4KYmNjaVx48bRyJEjSa/XB12ffv36Ub9+/aimpsalNh48eHDQdQ53ufHGG922qy+++KLP6tdqtbXqZ3vDuAPHWGJhYalPCgsL3RpDmkWMpXBAEAQMHz4cn376KVJSUoKeecZdiAjbt2/HpEmTnNnDLrzwQixbtgxxcXFB1s572rZti+PHjwesPlmWncezTpw4gSeeeAJPPPEEkpOTcf311+O8887D3r17sX37dlRUVEClUkGr1cJoNKKkpATAmaMYRASVSoXExEQkJSXBarWiqqoKLVq0wFNPPYWbb745YH0tNjYW2dnZAW3HYLNv375gq8A0IxYvXoydO3di7969jf6ubTYbXn75ZTz33HNuxxVzl0OHDqFNmzbIyMgAAAwbNgwvvPCC86hvUwwYMMCf6vmEqqoqfPnll8FWw8m2bdsAnIl9BwBdunTB9u3b62SI+uyzzzBhwoRAqxdxqNVq3HbbbW7bUm+PwZ2NxWJBfn4+MjMzfVYmwzAM07zxSygC7/zgkYE/vPmOHSmPPfYYWSyWYD+iR4iiSIWFhTR+/Ph6s3516tSJrFar3+p37L4xmUw+y4hzLqIoBt1j7C+5+eab/dJmDWEymah169YB2/kFIKB1nSt9+vRxPjuvIDPu4K3NmTBhAhUXF5PJZKJjx47RpEmTSK/Xh8SOmjvvvNOttoiLiwu6zpEggiCQwWCImAx9oSJarZZeffVVt3dp+3q3YNu2beuMH2xvGFfgHUssLCz1ycSJE90aQ1yxOexYIvcH3djYWIqOjq7zeceOHWn79u1+c4J4g+PolEMa4+TJkzRhwgRKSUkhlUrVaFvMmDHDL/q+8cYb9danVqupR48edNttt9G1115L3bt3p5SUFEpNTaWhQ4fS3r173aonkh1L7gwavkIURTpw4AAdOHCAli9fTm+88QZdccUVFB8fTyqVipRKJWm1WoqOjq7XWdmUCIJAaWlpNG3aNNq/fz8VFxdTcXEx/fzzzwGfVJ+dDppf9Bl3iPQX/RMnTrjcFqmpqUHXl4WlMUlMTKR58+aRKIou9emRI0f6RY8ff/yx1vjB9oZxhUi3NywsLJ5LZWWly2OIKzZHIOJclo4txp06dULnzp2RmpqKo0ePYteuXTCZTACAtLQ0fPHFF+jdu7dzSzQRoaKiAkajESkpKSGZer6oqAhvv/021q5di1OnTqGqqgqSJDlTDN5xxx2YPHkyYmJicPDgQVx33XVuHWdSqVQ4deoUEhMTfaZzSUmJR5lvHMTHxwMAdu7cidatWzd5vVar9TiddzjgyAa0bt26oBzDJCJIkgSr1QoiglKphCAIqKysxP/+9z+88sorKC4uBgBn+u366NmzJxYvXox27drVm02vurraeSTQn6hUKuzYsQNdu3Z1fuYYQ/Ly8pzHghimISL9WItCoUBZWZlLR6VVKlWjv3uGcRelUonJkyfjnnvucb7rGI1GfPfdd5g5cybMZrNH5Wq1Wjz++OMAgCeffNL5zidJEo4dO4YJEyZgy5Ytfs10eM011+DVV1/Feeedx/aGcYlItzcMw3iHzWZrNISBW3McLx3hEUGkrv4cO3bM78FbAdC1117rU73/+usvn+n2yiuvNFmfxWIhhUJR7/3BOmblD4mJiam1yyZUkGWZ7HY72e12slgsVFpaSr/88gvddtttNHToUJo3b57Lwc2rqqqoV69eFB8fT506daJhw4aRwWCo1Q4Gg4F2795Nu3fvJqPRSH/99Rd16NCBlEplo0frOnXqRJ06dSK73V6n3kgdQxj/0FxWkB955JFGd/CGQ/BulvCTCRMmNBhs+/jx4xFj19neMK7QXOwNCwuL53L48GE6fPhwo2MI71hykUjdbdC3b19s377d7/WoVCqYTCaXA7Y2hdlsRmxsbJOr2CqVChqNBjabDTabrd5rFAoFKisrER0d3WS9NTU1AAC73Y6YmBgoFArn34gIVqsVUVFRzh03sizj119/BQBceeWVzoDcoU5OTg4+//xzZGZmOp8l0pFlGWVlZdDr9XWC3J59jSzLkCQJ+/fvx6hRo3Dq1CkIgoD7778fb7zxRoPlR+oYwviH5raCrNPpnIG6b7/9dsTFxWHGjBnYunVrkDULfeLj45GRkYGysjIUFBT4dTdMpHDttdfi66+/rvdvRIRWrVrh9OnTAdbK97C9YVyhudkbhmE8R61W44EHHsD1118PhUKBgoICnDhxAvfddx/vWHKVSN1tEMggnl999ZVPdZ81axap1WpSq9XOOgRBIK1WS1deeSWdOHHCGStKlmXasmVLg6uQJ0+e9KluDXH48OEmY1KFkiiVSkpISKArr7ySdu7c6XZw0uaAYydVU0TqGML4B15BZmlMLrroIqqqqqq379hsNrLZbHTxxRcHXc9QlsbSKPfr1y/o+vlC2N4wrhBJ9kahUFCbNm3C6l07UO3CbcLib3HF5vzflgwm4pAkKWB1jRs3zqcrqQ888ABWr16N1atXY926dTh27BiqqqpgMpnw/fffo3Xr1s4dRYIgICcnp97YUIIgICEhwWd6NcZ5552HoqKigNTlC0RRRFlZGVasWIGePXtCpVJh5MiRYbPzKhAolUoolcpgq8EwTBjy+uuvY/fu3bj33nsRExMDlUqFpKQkPPPMM9izZw8KCgpQUFCAsrIy2Gw20JmEKti8eTNiYmLqLVOlUkGlUuG3337Dxo0bA/xEocHZu4kbIiUlBc8880yd9yCTyYT8/Hx/qcYwjJ+45ZZbIEkSjh49CqvV6lIM1Ujiueeew9GjR7F06VIsXboUQ4YMwZgxY5CXlwdRFGGz2SDLMgoLCzF//nyMHTsWqampwVbbLQwGAwwGAyZOnIhHH3200Z12MTExeOaZZ5Cfn4/8/HwUFRXhwQcfDKC2TH3wUThE7jEWnU4XUCdBmzZtcPjwYedLnyRJzmDN7iDLMkpKSpyOqpYtW7p8zO7XX3/FZZddBuCM4+S6667DsmXL3KrfWy644ALs2LEjoHX6EoVCgf3796N9+/bBViVsiNQxhPEPfDQhslEoFBBFMSDHjDMzM5uNo0ShUKCoqAhxcXF4/PHH8dprr7l8X0xMDFJSUmC1WpGXlxcRRwrZ3jCuEM72RqFQ4KeffgIAXHrppbX+ZjQaG3TARxr//PMPunXr5tG9K1aswFVXXeVjjTxHpVLhtttuw5NPPokWLVogNzcXJ06cQK9evdCmTRsAtRcPysrKcOmll2Lfvn1QqVS4/vrr8dZbb0Gv19dbfm5uLrKysgLyLM0NV2wOO5YQuZPCXr16YefOnQGtU6lUIjMzE0VFRc6Mem3btsWWLVsAAElJSRAEAY5ud+6Lt8lkwpw5c7BixQqcf/75AIDnn38ebdq0cfkl3ZEVzGw2Iy4uLuAxhHbt2oWePXsGtE5fo1KpUF1dDQDQaDRB1ib0idQxhPEP4fyizzSNJEku7arxBVOmTMF7770XkLqCiSAIkCTJac8lSWp2u0kFQcBbb72F4cOHo2PHjmxvGJcIB3ujVCoxZ84c3HPPPdBqtc7PG3t/l2W53gzBkYZOp3PGgPWUhIQElJeXN3ldWloaDhw4AL1ej9LSUlx33XUAgL///htarRYDBgxAVFQUvvvuO9jtdpfrV6vVeOihh/Dss8+iRYsWHj2DKIqIiopyaU738MMP4/XXX/eoHqZhOMaSi0RqfJQ///wz6OcxzxWNRkOxsbGk1WpJo9FQUlISDR06lMaMGUOpqan1xklSKpU0YcKERrMLhRI2my3o7ewLmTJlCk2ZMiXYzRkWROoYwviHSIp5wVJbcnNzA9qXsrKygvasarWaUlJSSKlU1vrckV1z6tSpdODAAbr33nu9rmvNmjV1nj1Ssru5Ij179nQ+N9sbxh1C3d5MnDjRo+cqLCwMuu6BkO3bt3vdB2bMmNFkPV26dGkwm2Z9VFVVUadOnUilUpFGo6GEhARKTEykmJgYSkpKoqSkJHrmmWdcilPqDxrK9s3iuXBWOBeJ1N0GRAS1Wt1kdrVwQa1Wo7i4GLGxscFWpUlycnKwbdu2YKtRC5VK5dYKQ2JiIgDg2LFjLmXVa85E6hjC+IdwWEFmXCcpKQkAsG/fPrRs2TJg9X755Ze46aab/Fa+IAg4ceIEACAjIwNEhOLiYhQVFaFDhw61drOKooiNGzfCYDCgV69ezvvPZseOHcjJyXHLDjmorq6uY4dUKlXEvN/Uh6P9Nm/ejJycHOfnbG8Ydwhle/PSSy/hscce8+je1NRUFBYW+lij0MJgMKCsrMzrkxevvPIKHn300Qb/rtVqsX37dnTt2tWrekKJkpISp21mfIMrNsfrfcSSJKGoqAg1NTVISkoKi0k/wzAME56wzWEYhmECAdsbhmEY1/EoCIDRaMQHH3yASy+9FLGxscjIyECHDh0QHx+P8847D1OmTMGff/7pa10ZNxEEARUVFTAYDMFWxSfYbDbExcWhtLQ0oPUSEWRZdgYjd4XffvsNY8aMcQYdFwQBGo0GSUlJSE5Odmb2cQeNRtPgfYIgoGfPnhg/fjyys7Oh0WigVquRnZ2NxYsXY/HixTh48CA+/PBDl2Mm6XQ66HQ6nD592pltgjc4MsGAbQ4Tqtxyyy3O7G7+3q0kyzLmzp2LuXPnIioqyq+7lQBg7969yMzMRGZmJgRBgEKhQEpKCrp161bHjiiVSgwZMgS9e/eGIAj1rrD37t0bVqsVHTp0cFuXcxNiWCyWgMX/EwQB119/PVJSUgJSX8eOHbFr1y5IkgRJkmrtVmL8D9sb/+AYFwRBQExMDI4ePerxbqWbbroponcraTQa5OTk4K+//vJJnNj58+c3+ndZlp3xaSOFxMREdgQHA3fPLL722mvUsmVL+s9//kMvvPACrVmzhv755x86dOgQbdu2jT755BO6/fbbKSEhgUaMGEEHDx50t4qA0xzOq0uSRKtXryaVShX0M5q+kMcff5xMJhNJkuTWmeDGkGWZZFkmk8lEf/31F915552UnJxc65yuIAh08cUXkyiKLpdpt9tJFMVaejrqys3Npb59+5JOp6O4uDgaOXIkff755zRv3jzq3r076XQ60uv1NHjwYPrjjz/o2LFjdOzYMZozZw4ZDAZSKpUUFxdHS5YsqaWTo/z6sNvtdNtttzXavtHR0bRu3Tpat24dGY1GMpvNZDKZyGq1+qy9I4nmMIYEi0i2OSzhL/n5+X7pI5Ik0cSJE+vELwqUpKWl+W2st1qtbuujVCrp2LFjJEkSWSwWWrNmDfXp04e0Wq3f22LAgAFks9mosrKSYmJiKCYmxm91tW3btsn3C7Y3/oPtjW9FoVBQSUmJz56lpqaGUlJSgvY8gZJx48bRrl27yGq1et1moii6VGf79u1JkiQffEuhw8KFC4P+XUaSuGJz3HYsjR8/nvbv39/kdTabjRYsWECffPKJu1UEnHAx0rt376YRI0bQc889R2az2aMyJEmibt26Bb1z+lJUKhW1adOGtmzZ4nHbWiwWmj59Ok2fPp3i4+ObDAqq1+t9OgBbLBayWCx1Pq+pqaHS0tJ6XzRlWSabzeaxHrIs05o1ayg2Ntb5XFqtlj788MN665MkKeKMjq8IlzEkHIlkm8MS/jJt2jQyGo1kNBobdcSIolhn/BRFkURRpJKSEiouLqbKykr6+++/KT4+PijP4rB7giDQlVde6dffgE6n80hHpVJJBoOBBgwYQN9++y3l5ubSP//8Q//88w+NHj2aNBqNV21Q3/1qtZry8vIoNzeXoqOjKTo62m/fwZEjR5psO7Y3/oPtje9k6tSpPn2Or776KijPEQzp1q0bvfPOO7Rv3z6XF7Ib4q677nK53lGjRkXU4nEoJrEKZ/GLYykSCQcjPW/evFpfrlqtpl27dnlU1t9//00qlSpidi+dLQkJCQ06aRrCZrNR+/bt3a7r008/9aj9Q5VIMiaBJhzGECZ0YMdSZIkjC5pCoSCNRkN9+/alffv20bFjx6h3795B188VUSqVtZwqBoOBTp065bffgLfZ7LRaLeXm5tayW6IoUm5uLm3dupV++uknGjFihEffZX2fKxQKv++O0mq1LmW/ZXvDuEMg7E1OTg5VVlb6ZfFx06ZNtGnTpqCPkYEWpVJJOp2O2rRpQwsWLCCj0eg8peHq+3pxcbHb9Xbq1MmtOVQoM23atKB/j96IRqMhjUZDd999Nx0+fJhOnjxJ7777LhkMhqDow44lFwl1I11QUNDglzxlyhSy2+1upXMcM2ZM0H8sgZA77rijycFXkiRKTEz0qPxOnTp5+9UyEUKojyFMaMGOJZZwEKVSSR07dqSOHTtSt27dKCYmhnQ6HT311FNe/wbGjh3rtX4//vhjLRsvSRLZ7XbnZ7Is04oVK4Lejq5KcnKyS+9ybG8Yd/C1vREEwTnhnThxotc7ahrj4MGDQf9deisKhaJWSA1ffg/t27enY8eO1ZnryLJMhw8fJr1e77HOL774YlifVJBl2a+7S/0tXbt2bXCjxIYNGxpd6FAqlaRUKqlXr1704IMPUp8+fXzSB12xOQKR99F4T506haKiIsiyXOvz3r17e1t0QAjl1K1EhJSUFBQXFzd4jVJ5Jrnf9OnT8dRTTzn/fS6yLOPqq6/GDz/84BddQ5X27dujVatW0Gq1ePjhhzFkyBBERUWhuroarVq1gslk8qjc+Ph4lJWV+VhbJhwJ5TEkEokUm8Mw4cqwYcPw008/eXz/Tz/9hBEjRnilg1arxdy5c5GVlQUAMJvNGDhwIFJTU2tdN3DgQGzatMmrugKBWq3GwYMHnc/TEGxvAktztjcKhQJXX301PvzwQ8THx/skkHRDPPXUU3j77beh1WrRpUsX5OXl4dChQ36rLxCoVCqcd955iI+Px969e1FZWemXepRKJbKzs9GrVy+Iooi///4bubm5dfqsJ+UCQP/+/XH55ZfDaDQiPz8f3bp1w4QJEwKaHEqWZZjNZmciJ4Wi8fxjb731Fh588MEAaedbBEHAP//8g65du9b7d5vNhuzsbBQUFNT6XKlUonv37lizZg2AMwHMHVitVkyZMgWLFi2CKIoe6eWSzfHGG7ht2zbq1KkTKRQK51bws7eEhwuhvPpjs9nc9ig6tk9qNBpSq9Wk0Wgi8tibN+KLgKhardatLalM5BLKY0gkEWk2h4UlnOXpp5/2+DdQWlrqF52ys7Pr2OTNmzcHva1cFYPB0KQdYXsTGJqzvVGr1fT+++8HZLeKJElBiyvnb1Gr1TRo0CB64IEHqFevXhE3F4uNjaV58+ZRTU2NW9+53W6nNWvWUFJSkvP4sUKhcMawy8jIoHbt2lHr1q0pPj6etFptnWPKOTk5DfbPsrIyUqvVQW8fb+T48eON/mbS09NrXa/VamnSpElNHmO0WCy0aNEi6t27NyUnJ1NKSgp17NiR+vbtS3379qW2bds22HZ+PwrXpUsXGjt2LP3555+Ul5dH+fn5tSRcONtIh5qjwG63B71zs9QvgiBQWVkZlZWVBbubNFsc23RPnjxJFRUVQduyyy/6gSHSbA4LS7jLiBEjPMpcZDKZ/KZTUVFRrbrKy8uD3k7uyoYNG5ocP9je+Jfmam9SU1P9HmNHkiQymUy0cOFCvxwTCyUxGAzUuXPnOlmmI020Wi3NnDmzTpw4u91Oy5Ytow4dOlBMTIxPnWsajYYKCgqooKDAWV9FRQW1bt066O3hrUybNq3B34/ZbK6VAEOpVNKYMWPcdvA15POwWCy0ePFiys7OJo1GQ1FRUQQEwLEUHR1Nhw8f9qaIkKC+QVelUlFOTg79/fff9Pfff5PNZguawymSB6Jwl8GDB9PgwYM9ztLHeE5RUVGD30tMTAx99tlnAfvN8ot+YIhkm8PCEq6SnZ3ttnPpxIkTftPn5ptvrlWX3W4Py/eocydM544fbG/8S3O0N4IgUGlpqU/rlySJtm3bRgaDIWhBh4MtTWWajjSJiYmhmJiYWlmn/S2dO3emIUOGUFxcXNCf3xei0Wga3Lzw8ccf17o2ISGh0R1O3v5+HfbaFZtTfzAeFxk5ciS2b9+O8847z5tiQhK73Y6tW7eiV69eAM6cW2zVqhV69uyJ9PR0AGfOHnft2hWXXXYZ0tPTnWdRRVGExWIBAERFRUGr1TrPgkqShCNHjuDYsWMYNGgQtFptk7pcffXVWL58uT8ek/GSdevWAQCysrJw0UUX4fzzz8fll1+OPn36QKPRAPi/c8EAoNPpEBUVFTR9I4mUlJQG/1ZdXY3bbrsNkydPhtlsbvIsNhMeRLLNYZhw5fjx4xg6dCjWr1/v0lhLRLjnnnv8ps/SpUuxaNEiZzwYpVKJ9PR05OXl+a1Of5CWlgbgzDuEP2PbMPXTHO1NdHQ04uPjvSpDkiQsWLAAzz//PAoLCz2O5xJJkPfhjMOK6urqgNe5b98+7Nu3L+D1+gur1eqMF7h06VJcccUVAICNGzfi7rvvrnVtjx49/BZvT6FQuDWH8ip4d0VFBcaPH4+OHTvi/PPPh0qlqvX3W2+91dOiA4ovAqlqtVpotVpIkuR0KgFAixYtkJOTg/79+2PXrl348ccfYTKZIAgChg0bhtWrVzf5wlBaWoqkpKRmNzCFMwqFAjExMVCpVDAajbDZbFAoFIiOjkabNm2czkmDwYDBgwfjmmuugcFggCAIICKYTCZYrVYYDIYGg7E3Z/766y/06dPHpWsNBgPKy8v9qg8HUw0MbHMYJnQZO3YsPvzwQ+h0OgBAWVkZPvjgA2zZsgV9+/bFddddB41Gg9mzZ+Ozzz7z6zvN4sWLccMNNzj//c477+Dee+/1W33+JDk5GYWFhc5/s70JDM3R3mg0GhiNRo/fO1999VU88sgjHt3LMM0dxxzQnb8LgoD3338fkydP9ptebtkcb7ZHffHFF6TVakmpVFLLli0pMTHRKUlJSd4UHVCCeSzhiy++aFI/q9VKmZmZQd+Wx+I/EQSBUlNTqVevXhQfH18rVaTRaAzAryC8SEhIcKt9Dx486Fd9+GhCYGCbw8IS2qLVaik2NpZiY2PrJMnwV9rthmTbtm3OGBI//vhj0NumPlGpVLViZTQkDz74oPNoN9ubwNBc7c3jjz/udh0mk6lOMGEWFhbXRaFQUFxcnNs20mAw1Ikr6GvcsTleOZbS0tJo+vTpHgVuDCWC+ZKvUCjo5ZdfppqamgaDaBUUFDTrAVutVlNGRgZ16NCBtFpt0PUJtFx00UV1guG5g91uJ7vdTseOHaNly5bR3Llz6ZlnnqFZs2bRt99+SxUVFd78fALOhg0b3G7DsWPH+lUnftEPDGxzWFiCL4IgkFqtDou4IWPGjKFly5ZR165dg66LQ1QqVb0xAKuqqig1NbXee7RaLX3++eckyzLbmwDRnO1Ndna2M75sfTgSp+zfv5969OgR9N8UC0u4iyAIbs9x1Wo1rVixwu/xZN2xOV4FHqmpqcHEiROhVqu9KYZhGIZhmoRtDsMwDBMI2N4wDMO4iTcerPvuu49efvllb4oICUJh9Vij0VBGRgZlZGTQrbfeSuvXr6eTJ0/Snj17aPTo0WGZ0cQVaWzFU6VSkUqlohEjRtCKFSto6dKl1L59+6DrHIw2WrlypUce6bKyMhoxYgSNGDGiwRSfGo2Gpk6d6tWuKKIzRzaffvppGjVqFI0aNYrWrl1Loih6Vea5HDhwwKNda1dccQVJkuRTXc6GV5ADA9scFpbgikKhoDZt2tDw4cMpPT09LHYthYI4jgHOnDnTJVtut9vpm2++oW+++Yays7MpLi6OrrzySqqpqWF7EyDY3vxf3zUYDJSTk0ODBw+m5ORkEgSBf/ssbgv3Gd+25Z9//hnQMcTvWeGUSiVeeOEFrF69Gt27d68T2O7ll1/2pvhmhdVqRX5+PgDgiy++wK+//oo+ffqgpKQEf/75J2RZDrKGgccR1LxVq1ZITk7GyZMng5JpINgQEZ5//nlceumlzkxzrt63fv16/PLLLwDQYGYOq9WK119/Hb/++iv+97//oW3btoiKinIGb3Qli93XX3+NMWPG1Pps5cqVAID4+Hh06dIF3bp1w/9j77zjoyrW//85J1tTNpuQSghJkBKEQEBKuNQogihSvChXRRS/qCDeq2DFrlxBRUREBORaAAWVpnIVBCmCVOmR3klIL5vsJlvPeX5/8Nu9LNkk23eTzPv1el7KZs/MnLNz5pl55pnnuffee9G3b1+3dgBramowcuRIu+D4ztK7d2+7IPnW90kQhFrjFiN4YTqHwQgscrkcXbt2RXp6OkpKSljWJyeZOXMmAODFF1906vsSiQSjR48GAIwaNQo7d+6EwWBg3jN+hOmba4iiCI1Gg7179wa6KQz8b21EjSihk0wmw5QpU3DnnXfi2WefxbFjxwLdpEbPZ599hltuuSXQzaiFR4alI0eOoFu3bhBFEUeOHPFSk1xnwYIFmD17NgoLC5GZmYn58+ejZ8+eAWuPu1iNBunp6Rg3bhxatmyJlStXNulJW30Do8lkAnAtzeLBgwdRXFyMwsJCfzUtqDh37hzMZrNLhiWO49CyZUsIguDU948ePYqePXsiNDQUoija6powYQJmzJjhMEuIKIp4+OGH8fXXX9dZbkVFBf744w/88ccfWLhwITiOQ0JCAiZOnIjs7GwkJyfbsuRZswndCBHhwoULKC4udupebiQ1NdX2/0ajEe+88w6AawNz9+7dsX79eqcMaIzAwnQOg+EYqVSK7t27IzQ0FH/++Sd0Op1P6jGbzTh06BBOnTqF/Px8p/VLc+fOO+90+1qO4zBgwACIouhS2meGZzB9wwhGrHPVYFwbyuVyJCUlISwsDAAQHh6OSZMm4f7777cZZv/44w+o1epm6TDhLVq1aoWJEycGuhmO8cQ1KhiyVX377bckk8noiy++oOPHj9Njjz1GUVFRVFJS4nQZgT6WEBUVRfv377cFw7ueysrKOoM5Mmk+EhERQVqt1uX3w2w2U2RkJEVGRnpc/759++z6p1arpQEDBnhULs/zFBERQYMHD6bBgwfTwYMHyWQy2QLZC4JAJpOJqqur6fLlyzRhwgS3XGnffPNNWxDz//znP7XcuKOiojwKfseOJvgHpnMavyQkJNCwYcOobdu2zC3eCyKRSOjIkSO1+tju3bvrPP7MxP9iPZLujSCrTN/4B6ZvmDBxTmJiYmjTpk1kNpud6pOerh0am1jXHBKJxHYsWiaTUVxcHA0YMIAyMzNrZVGtS1Qqlc+Ddd+I37LC8TxP7dq1o3vvvZf+/e9/088//0y5ubl05swZevrppz0p2ml69epFTz31lO3fgiBQy5Ytafbs2U6XEchBNzo6usHYL9u2bQv4S8EksKJQKKiystKtd2T+/Pk0f/58r7QjPDycsrKyqH///h4bq6wilUopPj6e4uPjKTs7m+6//3669dZbqUOHDtSpUyd6/fXXqbi4mCwWCxmNRpozZ47LdbRt25ZOnDhBmzdvrjNGU5s2bWzvoiiKZDKZnI7LxCb6/oHpnMYrarWa1Go1rVq1inQ6HRmNRtJoNLRr1y565513aMaMGfTjjz/Sxo0bacyYMU02rqAn0q5dO/r000/p008/pWPHjpFer6+3nxUVFZFcLg94u5n8TwYPHuz22HPj+MH0jW9h+oYJk9qiVCpp5MiRtvfBYDC43K81Gk3A76M+USgUNGjQIHriiScoPT3d402wDh06UIcOHWjNmjV09epVqq6utotBKwgCrV27tsFy0tLS/G5UIvKjYenw4cP05Zdf0tNPP00DBgygyMhI4nmeJBIJqVQqT4p2CqPRSCEhIfTTTz/ZfT5+/Hi655576ryusrKScnNzbbJ///6Add5ffvmlwfu0WCxs57EJiDVFs1QqdTnwIc/zdPLkSbfeE61WS1qtNugWGBzHUVhYGPXq1YumTp1KU6dOpUmTJlGbNm3sLPepqam1dg5dNZRxHEfJycmkVCrr/V5YWBj94x//oHbt2pFCoSC1Wk1//vlng8+YTfT9A9M5/pHMzEz617/+5VXjjlKpJKVSSUuWLHEqfbfZbKbXX3/ddl2gnoVUKnV6J9EX0rZtW5e8E25k1qxZAe9PTOwlOjqaecg2Api+aVoik8koNTWVhg0bRh999BEdO3aMLl++TPPmzQvoGN8YpFWrVjRz5kw6d+6cU/rbGe64446A39eNwvM8HT161K6dVqOPu2sojuNo5cqVtHLlyno3q81mM8XExNRZjlQqdfnZb9u2jYYMGUK9evWiwYMH04QJE+iXX35xOZmR3wxLNyIIAm3YsIFSU1Np2bJl3izaIVevXiUAtG/fPrvPn3/+efrb3/5W53VvvPFGwDuvVfbu3dvgfYqiSBEREQFva3MRbx3PsBpO+vbtSzt27KCamhoSBIFEUbQdy6qurqaKigrKycmhHj161Fve4MGDbUfEXKGmpoZqamoCbliyun22bduWBg4cSLNnz6bLly+T0Wgki8VCFouF9Ho9rVixwq6/33HHHQ7vOTMz029tT09Pp/LyciovL3f4jNlEPzAwneN9USgUdu9benq618t/7733nHaZNxgMZDAY6NSpUzRhwgS/LQCKiorqbdfChQt9VnfPnj2ppqbGqefTEEePHg14n2JSW6Kiotz+TZm+CQxM3zROiYiIII1G0+DzfvfddwPe1mCTVatW0apVqzzuy44QRZHefvttioiICJpj8fUdf62qqqJXXnmF2rRpQ23atHEpQ/XOnTtp586d9T4Pi8VC8fHxdZYRFhbm9HONioqiqKioettUn8fzjVnCA2ZYsvLTTz9Rr169fFG0He4OusFkzU9OTm7wPqurq5nHkheE4zjq1asXrV+/npYtW0Zt27YlqVRKCoWCXnvtNTKZTLb4Plqtlvr162cb7KzeRjfu4Ft301977TW6ePEiaTQa0mq1ZDAYbEYkZ6mpqWlwoJowYQJNmDDB6TKJiD788EP68MMPvf48rWmnR48eTRkZGXUu+Pr06UMFBQVksVhshrGGnktubi6NGDGCRo4cWeeEQK/X+zXlrbWuV155pZa1n030AwvTOd6TrKysWu0fOHCg1+uJjY11arJvjT2o0+lo9uzZDscZhUJBO3fuJK1WS0VFRZSTk0N5eXmUl5dHer2eDAYDbd261c5grVAoaPz48TR//nwaP3483X333XTlyhW6cuWK0/3BbDZ7fYx5/PHHna7fGV588cWA9ykmjuWhhx5y6zdl+iawMH3TeKR169YuPXPr/PTMmTN0//33k0wmC/g9BEo4jnNrM9tVBEGgqqoqWr16tS0sRiDu9/3333ep3TU1NTRo0CCnym5o7SYIAn3xxRcNrmca8lgym80uORE4+m31ej3961//sjOy+c2wVJcr1dmzZ0mhUHhStFO46yZ6I4E+f1xWVlZn2ywWC6WmprpcZmpqKm3bto3efffdZh2rIjw8nDIzM2nFihUOd8jdGTAFQSC9Xm93PtYbiKJISUlJTt2XQqFocEfbZDLR1KlTffJcY2Nj6fz587Xar9Vq6cSJE3TixAkqLS31uUJ69dVX6dVXX/V7vzp9+rRdO9hE3z8wneN76dq1q8M2t2vXzif13XXXXaTT6WzB+g0GA+Xn59Pu3btp6dKlNGXKFJoyZQq1atXK4fU8zwck5oCVBQsWeO1ZyGQyunjxotfaJghC0OwEM3EsVVVVLv+uTN/4B6ZvGr846xlbF6IoUufOnQN+H4EQjuM8enbuPm9RFCk/P59mzJhBQ4cOpa5du1JiYiKFhYWRXC4npVJJ8fHxFBsb61X95urxMKJrhhxnThRZA3YfPHjQ7nqdTkcTJkxw2vupbdu2Duc7p0+fJrVa7fI9SyQSm3dSSUkJlZSUUHh4OAGg7t2728r3m2FJqVRSz5496bHHHqMFCxbQrl276OLFizRt2jS68847PSnaaXr16kX//Oc/bf8WBIGSkpIaXWC7nJycWu1yJpCXIwkPD7d7QYxGY0BjVDh6wZKTkykjI4Oio6Md7kBzHEdSqZSkUimFhYVReHh4La8tmUxG0dHRpFKpSCKREMdxpFAo6LnnnqPnnnuuwcCmwYYoii65VgLXsgNs3bqVDh48SAMGDPCLEfGxxx5zawD2BVZvBn8bT7/55hu7drCJvn9gOsf3IpFIHE5cqqurg9JIoVarvfK7uou3vQHee+89r7UtMTEx4L8Pk/olNTXV5d+V6Rv/wPRN4xXrUSBvIAhCwO8nUGINUxEMCIJAZrOZLBYLCYJAFouF8vLyqHXr1tS6dWuP7jMhIcHtdl25csUlL6H09HS6/fbbXV7vWUUul9OLL75Ic+bModjYWK/8znWdisrPzyci13QOR0QEN9m+fTuOHTuGo0eP4siRIzhx4gRMJhMA4M4770TPnj2RkZGBjIwMtG3b1t1q6uW7777Dww8/jMWLF6NXr1746KOPsGrVKpw5cwYxMTFOlZGXl4fk5GSftM8dZDKZ7Tm6w8GDB9G9e3e7z4gI2dnZ2LlzJ4gIHMcBAHieh8Vi8ai9jlAoFEhISEBcXByioqJwxx13AAAmTJiAyMjIWt+na0ZOWLsjx3G2Nlr/S0QQBAEWiwUSiQQSiaTW9TzPe/1e/IVWq4VKpQp0M+pl9erV+Pvf/x7oZtRi8+bNGDJkiN/qu3TpElJSUmz/to4hubm5aNWqld/a0dxgOsc/9OzZE3v37rUbTy0WC1QqFfR6fQBbVhue5yEIQsDqj4qKgkaj8WqZ+fn5SExMdPt6IkLr1q2Rl5fnxVYxfEV1dTVCQ0Od/j7TN/6B6ZvGi3UuXVlZ6ZXy5HK5R+uyxsq0adMAAHPmzAlwSxrm4sWLGDFiBE6fPg2z2ezStTt27ED//v3drttiscBkMkEul4PjOFRWVqJNmzZenxv4G57nodfrUVxc7LzOcdtE5wCLxUJ//fUXffPNN/T888/TkCFDKD4+nnie92Y1tZg/fz61bt2aZDIZ9erVq9Z55IZoStZ8qVRa77EAq5X3+nOzoiiS0Wikb7/91i0Lanh4OD3zzDP0559/UllZWdBYtxsbK1euDHj/qUsUCoXbWen8xaRJk1y+r7CwMJe9ncLCwmq9Y2wHOTAwneNbXfLhhx+STqcjo9FIP//8c1B6LAE+CRXpFCtWrPDZPQ0cONCpYxxGo5FWr15Nw4cPp/T0dLd3QZkETl555RWX+h3TN4GB6ZvGJ946uRBMpz78KdbYop4eKfQn1jVtTk4O9enTp8F5i6dZOuvCYrEE/PfzhkgkEurWrRsBzumc/7l8eIGQkBB06tQJnTp1wgMPPGD7vKioyJvV1OKpp57CU0895dM6GAwGgxFcMJ3DYDAYDH/A9A2DwWDUj8tH4QwGAxQKhc++Hwiakpvo9OnTMXPmTI/KyMvLw+jRo3HmzBlIJBLExcXZPq+pqQEAEBFatGiBLVu2oEuXLh63mwG8//77ePHFFwPdDKhUKvTo0QOjRo0CAIwePRpJSUm2I4nBTE1NDebMmYMPP/ywThdUnufx1ltvAQCmTJkCs9mM119/HUuWLIEoig3WcezYMWRkZNh9xo4m+A6mcwKPRCLxyZFpb1FTUwOlUum3+gwGAzp27IhLly75rc7GivVYe0hICCQSCWJjYzFw4EAMGjQIGo0Gc+fObfZH9tRqNSoqKpz+PtM3voPpm6aFRCKBXq+3C53hDo1h/utLzp07h5tuuinQzXAbjUaDZ599FitXroTBYIBEIsHw4cMBAKtWrUJISIhP6v3kk0/wz3/+0ydlBwKfHIVLSkqiOXPmUHFxcb3f27ZtG40YMYJmzpzpahV+p6m4ifI873N3RWfTxTNcp7i4OKCujo8//nijC3heH6WlpdShQwebGyzHcZSamkpnzpxx2IcFQaAjR45QRkaGQ9fZoUOH0tChQx3WxY4m+A6mc5g0JJGRkT75nSoqKigzM9NhggkmdYs18cbmzZvJZDKRIAh1zhlEUaTMzMyAtzmQwnGcSwkxmL7xHUzfNE0ZPXq020lnFi5cGPD2B1oqKyu93CubD4H+7bwpPjkKt3nzZrzyyit45ZVX0L17d/To0QMtW7aEQqFARUUFTpw4gd27dwMAXnrpJUyaNMnVKhhuMnLkSI+t8g3R3K32viQ2NhYPPvggvvnmG7/VmZ2dje+++w4xMTFN7rdt0aIFTp06BaPRCIPBAKVSCalUWud98jyPrl274tixYzCZTJgxYwbmzp0Ls9mMO++8E2vWrHF4XUFBARYuXOjLW2nWMJ3jGhzHYe/evbjlllug1+vRpUsXXLx40e/t4HneKQ9Ab1BZWYnRo0dj3bp1Ll1HRJg3bx6mT58Ok8kEqVQK4Noud01NjS2ZhKfwPG+XnKKp8+mnnwIABg8e3OB3rf012L0+fAkRQRTFRp18pKnA9E3TZN26dTavlNjYWKSkpNi8KG+77TZMmzbNYWKhnJwcTJ482d/N9QkymQzAtUDkRqPRqWDkVu+UYE8sFMx06tQJx48fD3Qz/IbbWeGuXLmCVatWYefOnbh8+TL0ej1iYmLQrVs3DBkyBHfeeafPXMu8TVNxEy0sLER8fHygm8HwEIPBgAULFuCTTz5BYWGhbcIZEhJiy34kCAIEQXBrscJxHL766iuMHz/eF81vUlgn/HWNZYIgIDExESUlJQCcdBNluAXTOfVjXZQajcZaGwzdunXDkSNHvFpfXcjlcjz88MN4+eWXkZubi1tvvdXlDC2eIJFIEBYWZhsX9Xq9Xf1yuRxhYWGorq6G0Wj0aVuioqJQWlpq+20uX76MDh06+LzeQLN//34A17ILOkvHjh1x6tQpt+q7frOgMRrvFAoFampqnN7cYUfhfA/TN80Tq4G7V69eOHz4MLRabYBbVJvrM2ZfP95d//8cx0Eul6Nz5874/PPP0blzZ4eGa0EQsGfPHtxxxx2orq62+1tERASqqqp8dBfNh8OHD9fK1N5Y8XtWuMZKY3cT5XmeeJ53282T0TQQRZHy8vLowQcfpOjoaFIoFBQWFkZJSUmUlJRETz/9NFVVVQW6mU0KnU5nd2yOHU1gOIMvdE5hYSEVFhY6rE8QBL/poieeeIJMJpOt7uXLlwdcRwZCDh48WOdvERsbG/D2+VK6du1KXbt2demd+Oqrr9yqq1evXnTkyBE6cuQInT17lkaPHh3w+3dVFi9e7NKzYkfhGK7Q2Nc4TEDDhg2j8vLyWuu868OTCIJQ77HjhjCZTLR48WJ64oknKC8vzxtdj0FEmzdvDnj/8Zb4PSscIzCMGDECAJgbdTOH4zgkJSXh66+/DnRTmg0hISG1do0YDH+zbt26er1VeZ63een4kpCQEAwfPtx2pAyALUBmU4XjOLz88ssAgM6dOyMuLg6DBg2qUx/zPI+LFy8iPDzcn830K0ePHgUAzJ8/3+nApQqFwrYT7+x4+o9//APLly+389Bbs2YNPv74YzzzzDNOt5fjOISHh8NkMtl5k/E8jwEDBmD58uVITEwEz/O1vIro/3sN63Q6/P7771ixYgWKiopw00034dZbb0XHjh0hkUiQm5sLANiwYQO2b9+O0tJSxMfH46OPPsKAAQOcbiuDwWherF27FqNHj3b4t+vHI0/DWUilUjz++OMelcGojXWN3lxw+yhcU8LqJnr69GlER0fjwoULePPNN7Fx40avLhh5nodMJkNERATuuOMOPPTQQ8jLy8Ozzz7rMCOINZtKXXEqpFIpsrOz8dNPPwG45uJfH2fOnEHXrl1hMBhs3z127Bjat2/v4Z0xGM0TURQRHR2NyspKAOwoHMM5vHU0oV27djh69KhTGdHS0tL8ksXs7bffxquvvmqb5F65cgUpKSk+rzdQxMXF4cqVKwAa1sFWRFGEVCr1WwyqQNKrVy+sX78esbGxdS58iAgdO3bE6dOnnS63Xbt2yMnJcfjMRVFEx44dcebMGafKGj58OL7//nsoFAoQEcxmMywWC5RKZVBu2LGjcAxXYEfhGi8KhQIajcZp3cIILkpLSxEbGxvoZngNZ3RO8GnMABIaGoqYmBj06tULv/zyC0pKSsDzvMcTC6lUivXr18NoNEKv16O4uBjLli3D7bffjgkTJqC8vBynTp1Cv3790K9fP2RnZ+Pw4cMwmUwwm80wmUzQaDTQaDQwmUwQRRGiKMJkMuHXX3+FXC53OOgQEYxGI5YtWwae59GhQwcYDAYA1+JwGI1GdOjQARzHITs7Gzt27LD9ncFgNAzHccjIyPB50HxG0+TgwYP49ttvGzQMxcbG4v7770eXLl0QFxeHUaNGoaamBmfOnHHKqATAZvz0NXPmzMHx48dhsVig1+sxatQov9QbKCorK2361Fm0Wm2z8XLcv38/EhMTkZ6ejr/++svhdx588EGXjEoA8Mwzz9S52OJ53ulA7gqFAmvWrIFSqQTHceB53haHKxiNSgwGo/lgMpmcCrIdKKiZJKUoKCjA8uXLbfFUneHq1atNyqjkNJ6cGywrK/Pk8qChvvPq586do3Pnzrl9HpHjODpy5Ihf70cURfrzzz8pISHBrTZLJBIqLS2tVWZFRQVptVrSarUsnhODQdfipYwbN47Cw8OdPn/McJ+mrHOmTp3qcDzeuXOnV+p0RxfIZDLavXs3mc1mqqmpobvuusvp65KTkykiIiLgMQH8IYMGDaJBgwbRsWPHKC8vj8rKyshsNtviXmi1Wjpw4ABt2rSJVq9eTd27dw94mwMliYmJlJOTQ0ajkYqLiyk1NdWtclavXl1vfxcEgXr16lXn9XK5nORyeZ1xyYIZFmPJPzQ1fdNYRSKRkEQioTFjxlBkZGTA2+NvefzxxwPdheywWCx0//3312onz/N09uzZQDfP65w5c8Yulqq1P77yyitUUlJC5eXldODAAXr33Xfp/vvvp/T0dOJ5PuD9xhfijM7xyLCkVqvpww8/JLPZ7EkxAccZJR0VFeXWj/DII4/48U6uUVlZSUql0uMOlJ6eTu+9916dgUY5jqOkpCT6+eef7YK1El0beCwWi9/vncHwJyUlJdS5c2eSy+VOD7oM92nqOqeqqor69+9P/fv3p+7du3st2P7777/v8vgfHx9PGo2mVlkTJkwI+OQmWIXnedsElOM4u38z8a5MnDixwX5vNBprGZfCw8Npx44dtoC3wYAoilReXk5FRUWk0WiorKyMTp8+TT/88AP98MMP9Nlnn9F3331HW7ZsoW3bttGXX35JANM3vqap6ZvGKIMHD7Z7V0VRpNatWwe8Xf6WQK+nrGOOq+JI/ykUCurYsSP17t2bYmJiSCaTkVwupy5dutDmzZtp8+bNdOXKFfr0009tm7Y8z9O8efPs2iSKIs2YMYMSEhIoISGBHnvsMZ84PWRlZQX896/r2S5fvpyqq6upuLiYevbs6fM6fW5Y2rBhA3Xq1Inatm1La9eu9aSogOKMYenEiRMuPfzExERKTEx0ODH3NXv27Al4h7dKu3btgmbyxggMnmSpaAiDwUAGg4Hy8/N9OvnLz8+nNWvW0Jo1a2jz5s107Ngx+v7772vtTLCJvm9pTjrHU0RRpKqqKre8Y8LCwmj58uUOyxUEgRQKBSkUioDrFya1heM4ysrKoj179tC2bduoe/fuTXL3NCoqyul3QaPR0IkTJ8hgMHjr9fIaoiiSWq126xkwfeNbmpq+cUUeeeQRmjdvntsnH7whs2bNcng/oig2+cyaN8ozzzzj515zDetaNtD3b5X4+Hjat28fbdiwwWZ0ul4iIiKosrLSq88gWD2vHXlUvvXWWz6t0+eGJaJrk8wFCxZQbGwsDRgwoM4Uu8GMM5N8URRJKpU69eCjoqLo4MGDdPDgwYAYVdavXx/wDn+93HXXXX5/BozAYzKZ7AZkpVJJiYmJ1Lt3b9q7d69bZa5atYrS0tLqXNSGh4d7bfEgCAJt3LjR5o3krUGX4RnNRee4ijXV8EcffeT2QtUqEomEpk+fXqf+mjVrFs2aNSvguqU5C8dx1KZNG3rsscfowQcfpH79+tG4cePo0qVLdr+bXq+nESNGkFQqdXoO01iksXuSEBGlp6e7ff9M3/iepqRvnJHevXvXGvfNZnODXhs8z5NEInH4+f333+/ykdevvvqq3nsSRZFee+01SkhIaDabHP7m4MGDAb9nd4TneXr66aepoKCATCaTx+twRwYsb7RRJpO5ff3s2bPrbO+gQYN89mz9YliyotFo6LnnnqPQ0FAaP3485eXleaton+PsJL9///4NPnSZTEYnT54MqJu1q95V/hCTyVTruByjaaNSqertE8OHD3e6rIKCApcmDwkJCfTxxx/Txo0b6dixY6TVau3eR+si/NKlSzRu3DiKjo4muVxuc8l1dwHGJvr+oynonCtXrnilvLy8PJLJZB5NVG4UhUJBly9fdljf1atX6erVqwHXK81RrDvIp06dctrt/9ixYxQdHU3R0dFN6mjeqVOnvPL+BApBEDy6f6Zv/EdT0Tc1NTVUVlZGer3etk4RRZEsFku9axZRFOs1DoWFhdHTTz9tF4YjLCzMofHXYrHYxi5RFOnkyZMUHR1NPM9TSkoK1dTUOH1vBoOBLl++TJ07dw74eORrGT16tOs//nVY573O6o1A36+nwnEc9ezZk4qKijx6bmlpaV5tV0ZGBr377ruUmZnp1vUKhaLBNqvVao83GB2JMzrHaykvlEol7rvvPkyaNAlff/012rdvjzfeeAN6vd5bVTAYDAaDAYDpHAaDwWD4B6ZvGAwGwwk8seItWbKEnnjiCbrllltILpeTRCKhLl260OOPP04LFiygvn37Ulpamt+zormKsx5L77//foO7fevXr/dTq+vGYDC4dHzHHzJp0iSaNGlSoB8Nww8UFBRQQUGB05b3NWvW2I6ODhkyxOZOzXEcyWSyRhUfhO0g+5ampnOSk5M9Prp55MgRn/VnlUrl8By/1WPJH94v1gwso0aNosOHD9P69esb9IZsiiKXy+mVV16xxZVzhUuXLtk8lgJ9H96UrKwsj96dQLNkyRKP7p/pG9/S1PSNp/1l+fLldfZFmUxGOTk5tGfPHsrKyqJhw4b5NeB0VVVVvUmLrL9foMcsT2Xw4MGk0+lIp9M5Fb+0qKiozuO2CoWCfvzxR4fXDRw4MOD36i3p2bOnR0G9p0+f7lH9PM/b1sCXLl2iyspKOnTokNv6WKvVNthmqyeit4+J+vwoXEJCAo0cOZJmzZpF27ZtI51OV+s7b731FmVkZHhSjc+xDrpxcXH0xhtvkF6vr/Udk8lEDz74YL2L3PT0dKePv/n6qNySJUvsBlGJROLSIsDbi3nr4oAF8m769O7dm3r37h1wZRIIYRN939LUdA4Aeuihh9wup6amxufGnbCwMFq/fj0ZjUYSBIGMRiPNnDmTZs6c6fP3SSqV0vLly2n58uV2E0NBEGjTpk2UmZlJ3bt3py+++IIuX75MW7ZsobCwsICPA94WlUpF69evdyumkCiKNHfuXJsODvS9eFtcOTYTTLgSt7MuYfrGtzQ1feNpf/nxxx/r7Y8LFy6ks2fP0q+//kolJSVear3zVFdXU1xcnF2bWrVqZReGQxRFMpvNDg0NoijawnZs27atUemSiIgIeuONN2jfvn306aefumy0yM7OJpPJRBaLhe69996A34+3Zc2aNW73q82bN7td788//1yrPLPZTFOmTHGrvBUrVrjUdrPZ7NUQCX6NsVQXhYWFFBIS4utqPMJRYDuVSkXPPfccffTRR/TRRx9Rz549G5wEnDx5ssG6zGYz/fOf/ySFQkEymYz69+/vlPXRVURRpKKiIrp69ardZLS4uJhSU1OJ4zibtG3blo4fP05ms9nuzLVer6dXXnnFqy93Uwi2yaif5pwxik30A09j0zlpaWlul+PLII2OdGKvXr2oZ8+efnvHs7KyyGKxuLTzbTabKSoqKuBjgTeld+/eVFBQ4PKuq8VioW+//bbRjscSiYRee+010uv1pNfr6fbbb6/1nSFDhrj62jiFXq+n4uJir2yGWSwW2z1YLBYyGAxeWbwxfRN4GpO+8bS/NLRhyPM8JSQkUFpaGq1bt847jXcDq4HEWx5TJpOJtFotnTlzpll6yzYVOXr0qFu//+zZs92q7/z58w7Ly8/Pd2uTJzs72632V1dXe824FBSGJVEUafv27b6uxiPcScV5o0ilUqqurq63Hq1WW6cFvH379qTRaEij0fjlns1mM5nNZqcH3oKCAsrKynI7s4w1sCzzWGraCILg9SDCjUnYRD/wNDad424aYZ1O1yQ9UK6XnTt3uvVsysrKAt52b0p4eDi99dZbdObMGSorK6OysjLSarVkMBhsgXCtBov8/HxatmwZZWVlNTqDUnZ2NmVnZ9c7D+rSpYvdNRzHeXURSXRtIWmdqymVSpo+fTrl5+eTwWBwKfgtEZHRaKT09HRSKpWkVCpJpVJ57Xdh+ibwNCZ940l/achbyZGcPXvWi3cRHIiiGPBxkon78v3337v0e5vNZrc811JTUx2ud0VRpPbt2ztdDs/zxPM89e/f36HHpLNYE7x4+vyCwrDUGPCGYYnjOCouLq6zjoYyKlwvAwYMIKPR6Mcn4B4Wi4Vyc3PpjTfeoPT09HrjOuXl5TWqLBoM9xBFkVq1akWtWrUKuAIJhLCJPsMZrDpn9OjRDW5IEFGtxazFYvH43H+wS3h4uNvHnERRpIiICIqIiAj4fXhTrCm9JRKJbcIpkUhIKpU2unh0N8rkyZOd/n1vvM+ioiKPM/9cz7Bhw+psp3XjpH///nTs2DEyGo31bph5GkepPmH6huEM7hqWdDodDR8+3KNxZffu3T66q8Bx4MCBgI+XTNyXvn37OuXkoNPpKDw83K06YmJiHGZCf/vtt526vkePHrR7924qLi6m4uJi0uv1HsWJIiLauXOnx5sazLDkJN4wLAGgMWPG1FnHuXPnXCqL4zgaN24cXb161a8B8LyB2Wym/fv306JFi+jkyZPMS8kPCIJAGo3Glk42kJw8eZJOnjzZpNJae3PQZTCuT/9cH4Ig0N69e2nkyJF066230iuvvEJr1qyh1157rVHFf3BHBg4c6LbuE0XRZ+l2mfhGHMW2rAu9Xm937blz5+jcuXNu9ZUbMZvNLsejVKvV9NFHHzmc63Tt2tVnz4zpG4YzOGtY2rVrl0+OEatUKvrll1/8dLf+IdDjJRPPJSYmhmJiYighIYEUCgXxPE9SqZSUSqVXvHvS09MpNzeXCgsLKSsri7Kyspy67uDBgw77nF6vpz///JPGjRtH0dHRtg2lrKwspzYoRVGkb775xiPjEjMsOYm3DEsA6NChQ7XKF0WRJkyY4HaZarWacnJyAvBkGMGOVqulbt262U2EOY6jn376KdBNo4MHD3ocnLSxCZvoM5yhvom+NcZddXU1vfPOO7Uy3Vg9VQLd130tjz32mMMdP2eorq52+9g2gCYb6NofwnGcW8/P1fiLp0+fJqlUSnK5vF6PJZ1OR5MnT6bPPvvMqTruuOMOt+89Li7Oztu8rKzMp8cRmb5hOEN9+iY/P5/y8/P9Okbs2rXLrg0Gg4Fyc3Mb1SZ027ZtAz7WMml68sQTTzjsb6Io0lNPPVXvtU8//XSD/dZisdAzzzzjUpumTp1Ke/bsIYAZlpzGm4aliIiIWtkQBEGg0aNHe1RuZGSkx25wjKbF2bNn6zx+GBcXF+jmEdG1+BL+DDAcaGETfYYz3DjRt3p5PvXUU9SzZ0/q2bMnRUVFNUuvP6tkZmbSwYMHqaqqiqqqqmzxhBrCaDTS+PHjXa4vISGBjh07RseOHSO9Xk81NTV06NAh6tGjR7Mw5Hkqcrm8ViISvV5PmZmZTl3vTjytX375hYYOHUrl5eVUXl5e6++VlZW13qGMjAzaunUrXb16la5evUqFhYWUn59PO3furDMttyvCcRxNnTqVPvvsM4qPj/fpM2f6huEMdRmW1q9fH7DxIjY2lmbMmEHdunUjnueJ4zjq06dPozEuXblyJeBjLpOmJTzPk8FgcNjfKisrnSrj888/b7Dv1tTUOO3NXVVVRUSuHafliIjQzMnLy0NycrJXyuI4Djt27EDfvn1t/waAgoICpKamwmQyuV22TqdDWFiYV9rJaNwYjUZkZmbi1KlTDv+ekpKCS5cu+bdR9XDx4kXcfPPNMBgMts8SExPxwgsvoEePHtDpdACAP/74Az/88APOnj3r0bsSKHJzc9GqVatAN4MR5Fh1Tm5uLqKjo9G3b18cOXIk0M0KKiQSCdRqNVQqFQBAFEUoFAr06tULzz33HNLT0yGRSEBEMJlMOH36NJYsWYI1a9agsLDQpbo4jsNff/2Fm2++udbf9Ho97rrrLmzbts0r99UUUSgU0Ov1df7dYrGguroaOp0Ob775Jv7zn//U+g7P87BYLAD+N29qiIqKCkyZMgX33nsvAGDkyJHgeR4AUF1djYiICDTlKS7TNwxnuF7fWPuL0WiEQqEIcMtqk56ejoMHDyI0NNQv9RER9uzZg8rKStxxxx1Ojz1EhNTUVFy5csXHLWQ0F2JiYlBUVGTTYdeTlpbm1JqO53lUVlYiPDy83u/98ccf6N+/f73fGTNmDFatWgXA8RhSJ85aZ5sy3vRYSk1NrXNX1WKx0PPPP+/27mdhYaGfn8w1GssOQnOioKCAMjMz6+xLx48fD3QTayEIAu3cuZOWLl1KZWVl9X5XFEXSarW0YMECn+/6elPYDjLDGaw6Z/v27RQdHR3wftsYRSKRUEREBIWFhXnsUSSVSutNmLF9+/Zmm+nSGXElPhIR1ZmyW6VSkUqlcjq21gsvvGA7dieRSCglJYWefvppp2NZNFaxJoJh+obhDI68DZKTkwPej+sSnucpNjaWunbtSv3797fFp0lJSSGlUklyuZw6derkcTzR06dP241F1vWbK9mye/XqZYvPwzxbmXgiYWFhNg8hK5s2baJNmza5VM6oUaNsIRXqIyEhod5yKisrbd91xWOJGZbIe4al9PR0p40wFouFUlJSXCrfUfwmX3H06NFaQfzUajUtWbKElixZQhUVFWQ0GslkMjV4RM9isZDZbHY5hgKjbkwmE128eJG2bt1K8+fPp+7du5NcLieZTEbTpk0LaNusitlbv7coipSTk1Mr1kwwCpvoM5zBm5sZTDwXiURSpws60bUFiC9j5TRm6d69u8v9//bbb2+w3KysLDp16pTD+YXFYvFpUOxgltTUVK+kj2c0Hxz1l6ZgBOE4jg4fPuzy89DpdDR16lSHMfhSUlIoJSXFljipvjWdIAhUWVlJR48epffee4/ee+89SklJadZH2Jl4JqmpqbRv3z66fPky3XfffW6VoVAoSKfTkU6nq/c9EEWxzliICoXCru8zw5KLeGOSf+DAAbfq/uijj5yu4+GHH/bujd+ATqej++67z+VBkeM4atWqFZ06dcquI1ZUVNDw4cMpJiaGsrOzKTs7m4qLi316D75AFEUymUxkNpuD2nvLYrHUuzjyJmazmQoKCux2dgRBoD59+tj1jWHDhnktNtihQ4eCXmGziT7DGZhhKfjkzJkzdf5ev/76a53x7JqjWHfn5XI5bdmyxeX+37lzZ5fqk0gklJqaSj179mzy2RAbko0bNzLDEsMlHPWXmJiYgPdlb0l4eDh16NCBunbtSpMmTarTI14QBNq4caNTxh+5XE5paWk0evRo+u6770ij0dSa/4uiSBaLhYxGoy0t/Ntvv+12inomTLwhHMdRaWkplZaWNjg2iKJIY8aMIblcbvP8jYyMpN9//73BMaQumGGJ3J/kJyQkUH5+vsf1O5uFpKFdVXepqKigdu3aeaVDd+zYkV599VUaNGiQ3W5AdHQ0RUdHB+w4n7vodDrKysoihUJBcrmcUlNT6dtvv23W3lf79++3U8oxMTHUpUuXOhW1TCajvLw8j+t1x8vPWxIWFkZKpbKW11RCQgKZTCY20We4BDMsBZ/06dOHBEGoZQjX6/V07733Nokdfm+ITCaj9PR0iouLI7VaTZs2bXKp74uiGPB7aMyyYsUKpm8YLuGov9TU1AS8L/tKeJ6nMWPG0JgxYygvL48qKytp165d1KVLF7eyfcpkMurUqRN98cUXdOXKFdJoNKTRaKiiosL23/Pnz9P58+dp6tSpzd74zSSwIpVKXTrSeSOOnAFc0Tm1I0QxGAwGg8FgMBgMBoPBYDAYzuCWOauJ4erucUxMjNfb4Gz8BpVK5bGXlCiKlJ+fT/n5+dSzZ0+vW0utqUOt/+Y4jiZMmEATJkzw2rEofyCKYp1BQCMjI+n777+vM3aUKIokCAIZjUY6e/YsTZkyhXr06EGTJ092yj0xGLDu3lvPmVssFvrhhx/c7hevvfaaR+0RRZH69u3rVt0cx1FGRgaNHTvW5WDgHTp0oJycHFq/fj2tX7+ekpKSSC6X03333WdrG9tBZrgC81gKTpkyZQpNmTKFysvLSa/XU1FREb355pt1BptujmI9IqJUKonneerUqZPT/V4UxaAOGhwswvM8JScnO/SSjY+PZ/qG4RJ19ZexY8cGvK/7WjiOc8tLyZFIpVKKiYmhdu3aUdeuXal37940dOhQGjt2LA0ePJgGDx5MsbGxQR+ygUnTlpSUFL+NIY5ghiVybZKfnZ3tkzYIguBSx+ndu3eDbm6iKJLZbCaDwUA6nY5OnDhBDz/8sM+DIHMcZ4vBIJPJaMSIEWQ0GuvNuhOMGAyGBjMBRUZGUmRkJL300ku0fft2+uabb2jYsGEUHx9PYWFhJJPJaimZqKgoOnfuHJ07dy5g9yYIgi1rgNUIZjKZqKSkhGbPnk1qtZo4jrP9luHh4aRWqz3uG/Pnz3e7zSaTqcEsBo6kZ8+etcqqrq6m6upqp+Km9OnTh44dO0ZLly6lpUuXUlpaGnXu3NmuP7OJPsMVmGEpuEWhUFBcXBxFRUWxbHBOyOLFixvs81u3bmXHCZ0QmUxGb775Jmk0Gvruu+/ou+++q/WdzZs3E8D0DcM56pufhIeHs5hAQSrWmDfMUMXEFXniiSf8OobciAQMO6KiojB27FhUVFTgxx9/hMFgsP3tyy+/xCOPPOKTenmex6pVqwAA9957b4Pf37dvH2JiYlBSUgKJxP5nJCJ89dVXmDJlCvR6vU/aWxdyuRxdu3bFbbfdhq5duyIrKwvJycng+cZ36jIkJAQcx9X7ncrKSgDAu+++i/feew9E1GC5FRUVmD9/PgDgww8/9Puz+emnn/Dkk0+irKwMRASO4yCVSiGKIvR6PURRtPs+EUGn03ml7qlTp+LJJ59065737duHoqIil6/bv39/rc9CQ0MBAAaDAUePHsX48eNx+vRpGI3GWt/ds2cPevfuDYvFAgCwWCyIj4+HVCp1uS0MBiP4MRgMdrqfUT9PPPEECgsL8frrr9t9brFYMHv2bLz++uu28ZNRPyaTCQUFBSAiXLp0yeF3xo8f799GMZosZ86cAQC0bNkywC1hXA/P8+B53qk1BYNxPYcPHw5sA7xu1mqEWC1x27dvr3VUy+rR4U9cydYwYsQIu4CjgiDQE0884XcLqVKppLFjx1JeXl6jOu7WEBkZGT55XllZWZSVleV2cDV3EQSBMjMzA2pNr6qqcqvd3bp1c7mujh07ulRPVVWVwxS0N4pMJnM7FSeD4anHEsdx1LZtW0pLSwvou8yEyY3Cdte9I4mJiTav4Rv/ZvU6Z/qG4Qz1zU8OHTpEhw4dCnh/Z2Iv1tMCbDxl4o5otVrSarW299x6gslisdhOrNSFxWKhkpISp8eQG2l8biTXcfToUdx///1ITk5GaGgobr75ZpsniDvcdNNNtTwpOI5r0GvF2xQXFyMiIsKp727ZsgUXLlzAhQsXYDAYsGnTJnz22Wc+buE1IiMjMXv2bBQUFKCqqgrffvstkpKSPPbAEQQBV65cgdFodOhB4k8WLVrkk3IvX76My5cvu+xRVlNTg5qaGvz55584cuQITCaTy3UH0ntMIpFALpe7fJ3FYsHly5ddvs7VdyEiIgKlpaUNfo/YLlKzw9v6xhP27t2Ls2fP4sKFC9i0aZPf6uU4DmFhYZDL5W69x4ymDxsbvYPVa8nR80xJSQlAixj+xtc6p7y8HLfccgtuueUWr5XJ8A5EBFEU2XjKcIuIiAhERERALpcjJCQEPM9DKpVCIpHY/m21b7Rq1Qpjx46FWq2GWq2GRCJBbGwsOnbs6FbdjdqwdPDgQcTFxeHrr7/GX3/9hZdffhkvvviiz4wB/oLjOFRVVeGDDz5o0AgQGxsLQRAgCAKqq6vxyy+/+GQg4jgOEREReOKJJ/DEE0+gqqoKGo0Gzz33HBISEmodx3OXiooKqNVqpKSkQKVSQaVS4ZlnnkFVVRUEQfD7INu9e3ev3dv1lJaWorS0FN98800t45AoiqiqqsLBgwexYsUKzJs3D0899RQ6dOiAqKgoREVFoVevXujevTvi4+OxYsUKmM1mp+rlOA69e/f2+v04A8/zWLp0KWQymcvXSqVS9OjRw6VrOI5Dnz59XK5LpVIhLi6u3u907tzZ7wZnRmAJFn0jk8nQq1cv279vv/12t94pV+B5HpWVlRBFETqdznZUjIhgNpuRmprq0/qBa/f98ccfQ6vVwmg0oqioCNnZ2T6vl8EINt56661AN4HhB3ylc4gIaWlpaNGiRZ3GSwaD0fgxmUy1wpvcyNWrV/H999+jsrLSFt4FAE6dOuXWhn6TOwr35JNP0u233+7SNcF8jEUURfrhhx9qZY1TKBT0z3/+kyoqKmxH4QRBoJycHK9lQFAoFPT8889TRUWF144DmkwmOnPmDJ09e7ZWNrWysrI6285xHMnlcoqPj6dly5b57Xii2WymsLAwn7krKhQK6t+/P02bNo2mTZtGw4cPp1atWjl1HOt66dixI+3du7fBAOkWi4XeffddvwVRjY6OphdffJEOHz5MNTU1Hv0WBoOB2rRp41S9PM/TkSNH3K6rqqrKYR/kOI7uuusuMhgMdt8P5jGE4Tvc0TdEnh2Fk8lktcrz1ZFdqzhzvPno0aNerZPneXrqqafIYrHUe2RYFEWf3z8TJsEkhw8fJoDpm+aIJ2ucixcv0tChQwPef5kwYdI4JC4uzm4MaZbBuysrKxEdHV3vd6qqqlBVVWX7d0FBga+b5TYcx2HkyJHQ6/UwGAwwm80IDQ1FSEiIw+937twZ//3vf3HHHXc4XUd6ejp27NiB6OhoEBEsFgtCQkK8GpzYajFdunQpXn31VRiNRvTv3x/z589HQkIC8vLykJmZWWeATyKy7VKPHz8e06dPx5EjRxATE+O1NjqirKzMreNmzmIwGLBz507s3LnTo3JOnjyJv/3tb2jdujWeffZZ3HfffYiKikJISIhtN8pkMuHMmTP47bffvNF0h0RGRmL16tUAgNtuu82rXj1yuRxnz57Fzp07MXPmTJw8eRIVFRUArh0RFEURPM+jf//++PXXXz06qhMREYGNGzfiH//4ByIjI/Hjjz+iS5cuAMA8lRg2nNE3gHd1jqMxcsCAAcjJyXG7zPqYOnWqU8dnu3TpgunTp2PWrFke1Tdw4EBs3rzZaf3DcRyOHTuG7t27Bz5oJYPhB/74449AN4ERIDxZ46Slpfm0bQxGc8O6HqAm6vVXXl7u+kUum8uDmN27d5NUKqUtW7bU+7033njDoWXOH7s/giD4JWDziRMn6gz6xnEcpaSkUEpKCl29etXnbSG65qlkMpnoH//4B8lkMuI4jhQKBQ0ZMoRmzpxJ6enpbllTw8PDqUOHDjR06FB64YUXaN26dXTs2DE6duwYXb16lfR6vdttFgSB+vTpE3CLsTsik8moVatW1L17d+ratSt17dqVWrduTZGRkS57QzkjI0eOpMrKSi/2mIYRRdHmzVBZWUlXrlzx2CvKXZjHUvPDWX1DVLfOcVdu5IUXXvDZWHKjZ2lDeFLX/v37XarrenJycgI+7jJh4g8JCQkhgOmb5oanaxwmTJh4LnfffTfdfffddidnRFGkhISEgLfN2xIVFUVErq1xgtKw5MygeOPN/fXXXxQbG0szZ85ssPzKykrKzc21yf79+51+YO6ydetWuwX9kCFDfFaXFYPBQKNGjaLU1FSaMmUKFRQUkNls9nuWO6L/ZdfbsmULJScnk0KhoOjoaBoxYgRNnTqVWrVq5ZOXQi6X02uvvebyPVssFho4cGDAX+pgF47jaPny5S4/X0EQqKioiL777jvatWtXg8ddgh1mWGq8+FrfENWtc9yVG49i9u7d22fvuKuo1Wq36uncubPLdV3PzJkzAz4eMmHiT2H6pnESqDUOEyZNWZRKJXXp0oUiIyPduj42NpbWrFlD8+fPp8TERJJKpaRQKGjgwIF08eJFp0IC/PzzzwF/Dt4U6zjU6A1LJSUldPLkyXrl+l3U48ePU1xcHL3yyitu1efrReG6desc/mB79+71SX3BjCiKlJ+fTz/99BPt3LmTCgsLqaysjFasWGFLoesLeeSRR5w2fuTl5bm9OGqqIpFISK1WU1hYmM0TTiaT0fTp0532aDCZTHTo0CF69NFH7Z4vx3F0++230+233+6yd0SwwAxLjRd/6xsiz2IsAaDhw4fbxjOj0egTL0TgWpwjV0lMTHSrrp9//tnt58l26Jk0R2H6pnESqDUOEyZNTcLDw0mr1ZJWq63V7zdt2kTh4eGkVCppyZIltjmTxWKhYcOGEc/zxPM8hYWFUVVVlXsvswOOHTsW8OfiqfA8Tzt27Kg1hjRaw5Ir/PXXXxQXF0fPP/+822X4elF4Y+Btq6Snp/ukvsZKbm4upaen+yywdGZmJh05coTy8vLo8OHD9Ouvv9L+/fvp0qVLlJOTQ/fddx/dd999dR4hbOrCcRxFRkZSVFQUKRQKm6Snp9OWLVuoqqqKKisrae/evfTmm2/S/PnzKS8vr0FPI6PRSMOGDXPquVqP1AXCq84TmGGpeeANfUPk/EQ/Li6OJk+eTF27dq31ty5dutCbb75JsbGxPhsToqOjXXoXBUFwO3nE0KFDXX6OdW3aMGHSHITpm6aPN9c4zUFUKhV17tyZevToQT169KC+ffvSiBEjaOzYsdSnTx+KiYnxWoIjJoEThUJBGzdu9Ojdsp6k8QV5eXkO252ZmUlffvklxcTEBPwZXi8ymYyOHj1KR48edfhMmk3w7r/++gu33norhg4dimnTpqGwsBAAEBISgtjY2AC3jsFgMBhNBaZvGAwGg+EvmM5hMBiNDY6o8YYyf/PNN/HWW2/V+jwlJQWXLl1yupy8vDwkJycjNzcXrVq18mILASKCXC6H2Wyu9beIiAi7zA2Ma8+rqqoKZ8+exX//+18AwMKFC1FcXOyzOjmO83tEf2smgcjISKjVahgMBmi1WpjNZnAch9DQUHTo0AG9evWCIAjYvXs3zp8/D6PRCADgeR4tWrRAbGwsCgoKUFRU5PE9jBw5EosXL0ZYWBh0Op0t+1RsbGytDGsGgwElJSXQ6/UQBAGVlZUoLi6GIAiIiIgAAOTm5mLWrFk4e/asS+1Qq9VITExE7969MXPmTCQmJnp0X/7Al2MIIzjwlr4B/tdf6uOdd97Biy++iJCQEIiiiGnTpmHevHku1eMpPXv2xKZNm6BSqQAAgiDUm63tzjvvxIYNG9yub+nSpRg/fnyD3+vYsSNOnTrldj0MRlOA6ZumjbfXOI0NtVqN3r17o3fv3gCA0NBQbNu2DVu3bq21puJ5HkeOHEFGRkaD5VosFpw6dQoTJ07En3/+actafWN5ISEh4DgOPM8jNDQUKpUKVVVVqKioaBJZwFJTU/Hkk0/i/fffR2lpaaCb0yCxsbF48cUX8eSTT0KpVAa6OU5RXV0NmUzmcN5UVlbm88zmzjBjxgy8+uqr9X7HpTWOV32/Gim+PsbSs2dPh65ncXFxPqmvqWE2m+ntt99uEu6rHMdRmzZtaP/+/bR//34ymUw2d0yLxULV1dVUVVVFJpOp1nMwmUxUUVFBFRUVpNPpyGKxkCiKJAgC5ebmUufOnd1uV2pqqsM660IQBDp06BANGzaMIiIifPq83nnnHaeC5gUSdhSO4Qp1HU2Qy+W0c+dO2rlzZy135JKSEp+NgTKZjP7zn/9QaWkpXbx4kebMmUPDhg2jYcOG0ZgxY6h9+/a2unmep7lz59LcuXPt2vfII494pS3h4eF2Y6MVvV5PvXr1CvgYzsRemuvR8WAQpm8YztDYjsLJ5XJauXJlnWEWBEGgzz//nJRKJfE8Tx07dnRp/no9RqORTp8+TVu3bqVz585RTU0N1dTUkCAIdR6VEgSB1q1bR3K5PODPyl05c+aM3T1t37494G1yJBKJhA4fPhz0awB3EUWR2rdv77XnderUKbvyLRYL9e/f3+55jhgxgs6fP+/SO9OsYix5A18vCnU6HSUlJdXqAJ4Ef22OXLp0iXr06NFoDEw8z5Narab09HQaPXo0ffHFF1RUVOTT+EFVVVX01FNPuaTw5HI5VVZWulSP0Wiku+66y2+LisGDB9OFCxdIp9ORwWAIOiXDDEsMV3A00ZdKpXT58uU6r9FoNG6PfRzHkVKppJiYGFKr1RQREUGpqam0ceNG2rhxo8MxqaCggHr37l3vOy6RSCg1NdVnwcO9LampqTR58mTq3r273bOUy+U0YcIEysnJoZycHDp06BBNnjyZ4uLiSCaTNRvjCc/ztfqYUqkkpVJJjz/+OO3bt4+OHz9OBw4coOPHj1NRURHl5+fTSy+9VGdsxMGDB9PatWvpqaeeqjPeJBP3hOkbhjMEu2FJLpfbxpm2bdvS4cOHnbov64ZsoLBYLNSvX7+APz+O4+qc87dq1Yqeeuopys7OpsGDB9PgwYOpvLzc4f2sWrUq4PdyvfA83+jirXqCKIpkNpttxs36+rYgCHTkyBEaN24cTZs2jWpqanzaNmZYchF/LApFUaSKigqaP38+9e3blx5//HEyGo1OXScIAplMJjIYDGQ2m5vVi3YjoihSZWUlTZ06NWgn++3bt6dNmzZRVVVVwJSeIAg0atQopwZuZ5X49Zw9e9bvi0mr8oyOjqZ7772XcnNzfRp8zxWYYYnhCo4m+osXL673GnfS2PI8Tz169KCcnByXMy6azWaKi4sL+HjqLfnzzz9r3aNVpzqLIAi0YcMGio6OJp7nieM4kslkpFKpSKVSUVhYWMDv05k+8cgjj9DJkydtiSsuXLhABoPBNp4ajUYqKysjnU7n9Bh79epVio+PJ4lEQomJiZSYmEh5eXl239HpdDRo0KCAP4PGLBzH0T333EMA0zcM5wikYUkikZBCoXC4KRIeHk4vvfQSHT16lHJycmjXrl22eV1jQRRFGjlyZMCer1qtJo1GQxaLhc6ePUvR0dG2Z3vu3DmX76empoYqKyttHlsXL16kixcvBmRDv7q62ge/GMMdmGHJRYJxUSiKIk2aNMnh4p3neQoPD6fMzExatGgRaTQa0mg0gW6y39FqtXZp6wMtCoWCrly5EujHYkd6enq9bX7wwQfdUuIPPvhgwJ93bGwsrV+/ntavX++UkdaXBOMYwghebpzocxxX5yRKEAQ6f/68y2Mdx3E0Y8YMt48ICIJAMpks4O+5N2T27Nme/Fwu8+233wb8nlUqFT322GP0/vvv01dffUX5+fmUn5/v0/u2WCxUVVXVoDHq559/9ln2V1+LTCYjmUxGqamplJKSYueFxXEcSaVSl+6N53mn3zOZTEbbt2+nK1euEMD0DcM5rPpGIpHYDOLefi8SEhJo0aJFdODAATp48CAdPXqUCgoKyGAwkMViIZPJRMXFxVRcXEy7d++mQ4cO2QzXRNfWPCaTyeUNkGBAFEXq3r07de/e3a9jEcdxtbyPRFG0bRJ4+x5fffVVSk1Npccee4zOnz9PRUVFdP/99/vk3ubMmePV9jM8gxmWXCQYF4UlJSUuTUx4nqfs7Gw6d+4cmUymoDsq5Cusg52/XOylUillZ2dT27Zt7ZQzx3F08ODBQD+OWpw9e7be+3n77bddLtNoNAbN2XLrJD8rK6vONJn+IBjHEEbwcqNhSa1W1/JuFASBioqK6I033nArjtmAAQM8mqSbzeaAv9/ekH79+nn6c7lFYWFhQO43ISGBKioqAnLPrqDT6UilUgW8f7giYWFhtGnTJtq0aZPdglmv19u838xmM+Xm5lLXrl0bLI/neerVqxe99tpr1Ldv33q9ApRKJa1atYpEUWT6huES1v7SunVrSktLo44dO1JWVhZlZWVRUlISJSUlue2BznEcvfTSS17xzhcEoVEalojI9u478957S9LS0gJ920REtG7dOo/vRS6X05AhQyg3N5eNa0EIMyy5SDAq6dmzZ7v1cvI8T7GxsTRgwACaPn06HT16tJY3h3U30ZVFeFlZGX333Xf0448/0o8//kh5eXmk0WjozJkztHz5cvrxxx9Jq9Xavm+xWOjIkSO0YsUKv3mTCIJAWq2WHnzwwQY9ajiOo/T0dHrwwQepffv2JJPJSCKR2Nx2IyMjHe46Hj58mERRJJ1OR23atLF9Hh4eHpTuuwcOHKj3OchkMtLr9S6VOXHiRI+VCMdxlJaWRjNmzKBHHnnEZhz1pEyJRELz5s0LyO8QjGMII3i50bDUpk0b24TaZDKRyWSi7777jhISEtzaXeY4js6fP+9RG13Z3AhGeeihh+ihhx4K6Lh86tQpv3jmSCQS+vjjj8lgMATsXt1BFEWf7Xj7QsaMGUMWi8WpRbROp6OoqKgGf7fJkyfTsWPHaOPGjdSjRw+7BT7HccRxHEVERNATTzxBOp2OiJi+YbiGtb9kZmbS8OHD6b333qPDhw9TYWEh5eXlUV5eHq1fv55GjBhBqamp1KpVK+rQoQN17tyZkpKSSKlU2rydZDIZxcfH09SpU2nq1Kl1xutxB4PBQPn5+W572QYDZrO5zoRN3pbu3bsH+naJ6No47sl9zJ492y96WhRF2rx5M73zzjvsmJ2LuKJzJGAEJStXrnTrOlEUUVJSgpKSEuzYsQPvvfceVCoVevTogQ4dOuDy5cs4ffq0LVVnp06d8Oijj6J9+/YoKCjAhg0bkJ+fj8zMTNx6660AgA8//BA//PCDLdU9AEgkEkgkElgsFltaeqlUioyMDKSkpGDTpk2orq4GcC1t55kzZwAAN910k9vPpCF4nkd4eDi+/vprAMDXX3+N0tJSLFq0CH/99RfCwsLQt29fjB49GlFRUXbXCoIAnU4HACAiiKKIFStW4F//+pctrWh0dDS6du0KjuMQFhaGe++9F++//77teXAc57N7c5d+/frV+3eTyYSIiAgYjUbwPN9geR9++CH+85//eNQmqVSKMWPGYNGiRYiIiIAgCKipqQEAfP/9926Xa7FYMHXqVHTt2hUDBgwIyt+DwXCEVqtFcXExwsLC8N577wEA5syZA5PJ5FZ5kZGRHqeX/vDDDz26PpBMmDABX3zxRaCbgQ4dOiAvLw9PP/008vPzIZVKcfjwYVRWVnqtDolEgqqqqkaTfvl6OI7DihUr8PrrryMjI8M2lwhW0tLSnNKTABAWFoaxY8di0aJFdX7HYrFg/fr1uOWWW6BWq5GcnIwzZ85AEAQQEUJCQgAAcrkcoaGhMBqNCA0N9cq9MJofV65cgSAI6NOnD+Li4tCiRQtbf05MTMQdd9wBURQREhJi+9w6H7Z+bu2T3oaIsHXrVsydOxdjx47FhAkTnH7XvIEoiuA4zuN5o0Qiwfbt29GiRQsYDAYvtc4x1rHCV7+Js3AcB57nIYqiS9fxPI9169ZhxIgRPmqZPZMmTcJnn30GADhw4ADWrl3rl3qbHb61cTUOgnH3JyEhIeC7c76Q0aNH0/bt22nx4sU0efJkOnr0aKAfdS2sAdMvXrxod8QuLCzMbqfy+iCkPM8HnQvvo48+6tJvU9/xidLSUo/iWUkkEoqKiqIuXbrQjBkz7LzbiMgWJ8wbu/uRkZG0adMmysvLoz///JOWLFlCy5cvp7y8vDqPiFoDFbpLMI4hjODlRo8lnufpjjvuoB49eti8FDx5Bzp16uTR0QRRFBttBi+pVBp0Y7HVy8VisZBGo6HMzEyv3W8w6lB3yM/PD3jfaUhSUlJIp9PZPIcawtlYWwqFghITE0mtVjvUgdasjllZWfTll1/Sjh07CGD6huEc1+sbuVxO6enptHbtWqqurg6aBCjl5eUUExNDwDVP+k8//dSrIT1EUaQzZ87QgAEDSK1Wk1qtptjYWAoPD7fTtwqFghQKBfXv358++OADWrt2LV24cMHltvjLa+mjjz7y2jNyF1EUXZqz8DxP77//vsunJTzhxtMb8fHxfqu7KcCOwrlIMC4Kk5OTAz6J8pdIpVIqLCwM9CO3KdjCwkI6dOgQjR07tlZbJ02aREajkfbu3VvrbyNHjnS5TuuZcr1eT+fOnaPnnnuOBg0aRJMmTaItW7ZQcXEx1dTUkMlkckn59+/f3+3fYtiwYTR16lTKyMigjIwMtxe5SqWSunXrRuvWrSONRkNGo5GMRmO9C97Ro0d7pU9ZjzZe/xnHcTYX7q+++oq++uoruv/++yksLIw4jqOwsDC3g+AH4xjCCF58naUnKSmJSkpKSBAE2xhjNBpt8fcaGkumTZsWcL3grnTp0sVPv6L7VFdXU79+/UgqlZJUKiWZTEZt27alkSNH2rL63Dh2ObrXxMTEQN+KV3nttdfotddec/k3t2bl69KlC0VHR9uN/RKJhNq2bUvr1q2j0tJSunz5MvXp08dhOTzPNxhrpl27dtSuXbtamyOO+Oabb3za15m+YTiDo2QR8fHxNH/+fKqqqrIF3A8kTz31lF0bJRIJvfnmm1RWVkZ6vd4ujllDbbVYLFRQUEAFBQW0fPlyys7O9spGSWxsLO3Zs4c0Gg1dvXqVDhw4QPn5+bXaYw3m7Q99x3EcTZ48mfLz80mv1wckE7XRaHS6vQqFwmtHHU0mk1NGfkEQamW4HT16tFfa0FxghiUXsT6wRYsW+cyjwRWqq6tp+PDhjXbH2F3ZsWOHX55vXQwZMoSGDBni1EBe19+WLVtm6ycGg4F++OEH+uyzz+jPP/+knTt30siRI90Okni9KJVKSk5OJpVK5ZMMH+6IRCKhmTNn2ryP3FFwBoOBBg8eTFFRURQXF0dKpdKv95CQkFCrTQUFBfTmm286zKqk0Wjs4uCwiT7DGXxtWOI4jjIzM2nUqFHUrl07UiqVtmxAEomEpFIpKZVKW1r4UaNG0RdffEFLly5tMJNksMv69esD/fM6hcFgoCNHjtCRI0fo0qVLNqNfTU0Nvf322xQbG0spKSn0/fffk1arpeLiYrrvvvtsO+pxcXFUVVUV6NvwKtbNnRs9tjt37kyXL1+mLVu2UFhYmO3zujKxCoJAJpOJjEZjnXO61atX0+rVq0mlUlFkZCS9++67VFFRQWfPnnVq7iWVSuvdiBBFkZ555hmf9nWmbxjOUJe+kUqlNGLECBoxYkRAxxK9Xu9wrmfd8FMqlaRUKkkmk5FcLie1Wk0dOnSgbt26UWZmJnXv3p0GDhxI/fv3p6SkpHqD4PtCIiIi6OzZs3T27Fkym8109epVv6/frBkprRnDf/31V78ZmSorK51uZ1FRkdfqXbFiBbVv395mHK2LwsJCu4RDPM8HPJN0Y4MZllzkRjfRlStX2iZykyZNokmTJpFarabMzEyfudgLgkD79u2jffv20euvv05bt26lmpoaMpvNlJOT4xVjRLALz/MBC9rnzZ1F68It0M/TnxIVFeW1wLHWo4iiKJLZbKbFixf7baLA87xtoWI2m6l169a1vhMeHk5jx451GJiVTfQZzuBrw1JzleHDhwfdMbj6qO8YitlsrmUUEUWRysvLqby8vEkHHxVFkX744Qd6/fXXqaamptbfrR543qrrRlavXu1Uf+M4rk7PpYqKCurcubNP+zvTNwxncEbfjBo1KmDZpH3t2edPSUhIaDDbJcdxpFAobJ6W0dHRlJKSQl26dKGMjAxq1aoVqdVq24aQu22Jjo6mAwcO+NwpQqfT1coUbfXGvX7j29vBxt977z1SKpW2Ewh1UVZWRl26dCGZTEYRERF06dIlr7ajOeCKYYkj+v+RiZsxeXl5Tgc6lUqlqKqqgkKh8KhOQRBQUFCAL774AnPnzoVGo7H9LSwsDFevXkVkZKTtM4PB0CiDc7rKnDlzMG3aNL/WSUR+DRLY1JBKpSgvL0d4eLjP6iguLkbPnj2Rm5sLXw5Z8fHxmDdvHhITE3H33XejqqrKpetzc3PRqlUrH7WO0VRwRec0d3r27AkA2LlzJ2QyGfR6PQYOHIgDBw7YvtOpUydbwFQWtJ/hKa7OCSZOnIgnn3wS1dXVKCwshMFgwM6dO7Fs2TKfBvBl+obhDM7oG47jsHnzZtx2221erdtiscBoNEIqlUIikdjqAq69Z7m5uejduzeKioq8Wm+wwvM8/v73v+PVV19FWloaAECpVCIkJAQcx4GuOXzAYrFAq9Xi999/x8SJE1FRUeF2nd27d8eSJUts9YmiiJqaGoSHhyMyMtLj9Y8gCBgzZgz++9//AgBSU1Pxf//3fwCAmpoa/Pe//wUR4ccff0Tr1q09qut6rl69ir///e/45JNPAAA9evRw+D0igk6ng0ajQUJCAqRSqdfa0FywjiHO6By2mmYwGAwGg8FgMBgMBoPBYLgF81iCe7vHSUlJWLFiBXr06AGlUllrl9SaNvfw4cP47bffcObMGezZsweXLl2C0WhssHytVlvLAyQ5ORl5eXkutbOxoVarPbLMu0NKSgquXLni1zqbEklJScjNzfW5p0BBQQF69uyJq1eveq3MqKgoHDhwAElJSbZdIp1Oh7fffhsLFy50uTy2g8xwBuax1DCxsbH466+/EBcX5/DvgiAgPz8fsbGxHnsQMxg3EhoaCr1e79a1HMdBIpHAbDZ7uVX2MH3DcAZn9Y1KpcKZM2cQHx8P4Jqnh9FohE6nQ3h4uMNxVhAEWCwWyGSyWnPA8vJyTJkyBXv27IFUKrW1ITU1FZGRkSgsLMTvv/+OgoICL9xl42D48OFYvnw5IiMjnZozW726MjIyXPagv5HrPcWsxMXFYdu2bbj55ps9KruyshLLli2DVCrFmDFjEBUVZavTaDTCYDB4xTvqeojIbq3MTp74jsuXLyM1NdUpncMMS/DOJF+hUECtVkOr1aK6utrjNi1fvhzjxo2z++ymm27ChQsXPC472Ll69Spatmzp83oMBgPuu+8+rF+/3ud1NWUkEgm0Wq3PF3eCIKBbt27IycnxuKzExEQAQH5+vsO/HzlyBN26dXO5XDbRZzgDMyzVhuM4hIaGom3btnj55ZcxevRo5rLOCBg7duzAwIEDA92MemH6huEMrugbtVqNhx9+GBEREVi9ejUuXLgAs9kMqVSKm2++GS+++CKSkpLwyy+/AAC+++476HQ69OvXDwsWLLBtBJw+fRpDhw5t8pvhrpCWloYDBw4gOjra5WsvXryIm2++2WdHa0eMGIEvv/wSarXabQONKIoAmIEnkFiNbdb1mEwmc/o6R4ZOIsLWrVuxYMECrFu3jhmWnCUYJ/k8z0MQBNu/BUGATCazvbhNmbi4OOTn5yMkJMQn5efm5mLEiBE4fvy4z3cUmwvR0dEoKyvzaR1GoxGxsbHQarUel2Xd+YmIiKjzO+np6Th9+rRL5bKJPsMZglHnBBKlUok2bdrgzjvvxNixY9GpUyfmheQlLBYLjhw5gsLCQgDAwIED6x33GP8jJCQkqOdcTN8wnMFf+kapVCIrKwscx2HPnj1ue/w1RaRSKU6cOIG2bdu6Xca5c+dwyy23eOy5VBcKhQKPPPIInn32WaSkpLCNnUYGEeG2227D77//bjPuxcTEYODAgejRowduvfVWZGRk2P2uRqMRL730ErZt24axY8cCACZPnoywsDCUlJTg7rvvxqFDh2zfd0rneC9meOMlWDP0JCcnk06no/LycoqOjg54e/wp7dq1o5KSEiopKXE5U4U1047FYrG71mKx0AsvvGCXpYCJ90StVtfKyGQwGKikpMQrGXw+/PBDr7W1vmxM1/cXV/sKy9LDcIZg1TmBEJ7nKTw8nNLS0mjkyJH02Wef0fnz5wOWIbSpYM0gl52dbZdVUyaT0bhx46i8vLzOMVAURdJoNFRQUEBGo9Fu/DYYDDR//nxKSEigqKgouv322yknJydgGaV8yYEDBwL+fjB9w/AUpm8CL8OGDfNKdjaNRkOPPvooPfroo5SYmEhqtZoUCoXX1jUKhYKmT59OVVVVXuh5DH/iTHZFuVxO48ePp82bN9MzzzxDMpms1nd4nieFQuHwepYVzknY7nFwYs0gERoaitDQUNx2221YtGiRXewpURRx6tQpfPnll8jJycH58+dtO7MmkwlyuRw33XQTEhISsHfvXrvsewzfYLWUO9rp5Xkebdu2xSeffIJBgwbV2hGxDkfXnwU3Go14/vnnbZkfvIHJZAKABndkysrKEBMT43S5bAeZ4Qx16RypVAq1Wg0A0Gg0zcqjkuM4hISEQCKRIDQ0FO3bt8e//vUv3H333QCuZUu1Zs0xm802D8mYmBiH77E1lmFBQQEMBgPi4uKgUqnssu+IogiTyQRRFMHzvG3cEQQBJpPJ1hZfec/6kurqajz11FNYunSpw0yaEokESUlJ+Nvf/obs7Gx07twZJpMJc+fOxc8//2yLE2mF4zhwHFenB09ERAQWLFiABx54oFE+r7ro2LEjTp06FehmOITpG4YzsDVO4Dl79qxH3kqOsFgsMJvNMBqNuHjxIt566y1s3LjRqTi+dSGTybBkyRI88MADtjUYo3EQGRnpM282K+wonJOwQbfxwHEcMjMz8cgjj+C3337Dr7/+ajMSMBonPM/bjFGCIDg0LnmbIUOGAAB+/fXXBr9bVFSEdu3aOXUEj030Gc5wo84JDw9HRUVFrYmc0WiEUqn0yTvQWLCODSqVCiqVCgaDwRbHMDo6GuPGjcNTTz2F2NhY29ElrVaLlStXAgBmzZqFoqIi23Hy5ORktG3bFiUlJTh79iyqq6shCIJdfIHrjSccx2HcuHFYunSpzxMUeAsiwvnz59G/f3/bRou/SEtLw4kTJwCgSRxnLCoqQmJiYlC+g0zfMJyBrXECj9ls9ouhRqvVYt68eViwYAFKS0trbRA0RO/evbF9+/agHrvNZrMtQQLjGnq9HqGhoT6vhxmWnIQNugxG86SmpgZKpbLB7xERSktLAVwzRq1evRpVVVXo168fxo8fD5PJhE6dOrGJPsMprtc5o0ePxtq1a+v9vkKh8GgXsqnC8zxatmyJu+++G7feeitatmwJURRx5MgRzJ07FwC8lvCib9+++OOPP7xSlj84ceIE+vTp4/MdTEdMnDgRALBkyRK/190QVo83q1dVQ95VRITXX38d//73v/3RPJdg+obhDGyN45j7778f8+fPh0qlAvA/T1UAKC4uxuLFi/HJJ594HDA7IiLC7+OwKIooLi7GJ598go8//tipjdHY2FhcuHChVkbyYIKIUFVVBUEQEBUV1Wg2e3zNkiVL8Pjjj/u8HmZYchI26DIYzRdnjUv1YR1D2ESf4QzW/rJ9+3anM0+5E0y+qSOTydC1a1cMHDgQkZGRtswmFy9exA8//ADgWsprb/Hee+/hhRde8Fp5viQ3NxddunQJyPFva3BwTxdTVEemGncpKytDr169kJuba/OES0pKwt///ncMHz4cHTt2RFRUVK2dcEEQsGbNGjz88MM+y8rkDkzfMJzB32scnuchl8sBXHt3zGZz0Hn8rVy5Ev/4xz8a/J5Wq8UTTzyBNWvWuH06Yv78+XjqqafcutYbmM1mLFu2DM899xwAoLKy0u734HkevXv3xrZt22y/WzBjNBphsVgQFhYW6Kb4let/s+tPdBQXFzt9qsJTmGHJSZhhicFovkilUhiNRo8WMMywxHAFd/tLfn4+UlJSXHZvb4pIpVJMnDgR06dPR3h4OKqqqpCbm4uqqioUFhbi448/BgAcPXrUq/W+9dZbePnll4PeDb+4uBjp6emoqKjwe93WmFeejKtEBEEQbDGxPOXkyZPo2rVrvXHLeJ5H+/bt8dtvvyEpKanW30VRxG+//QYAGDp0qMdt8hSmbxjO4M81Tnp6OtatW4e0tDRIJBLbe6zT6XD27FkAwNq1a/H111+joKDAL226kVtvvRW//fab0+OKxWLB2bNnMWPGDKxbt84l43JKSgouXrwYVJ41ZrMZ1dXVMJlMkMlkCA8PD3p9diPe3nTwBIvFgt27d+P5559HSUkJ/v3vf+OBBx7wuFyTyYSFCxcCAGbPnm3bJJNKpQgNDUVUVBR4nselS5ds4QF8DcsK5yQsYwITJs1bjh496pUxhGXpYTiDp/2lvLycpk2bRgkJCW5ng+F5nuRyOcnl8lpl8DxPERERDjOGBIMoFAr66aefamUis1gspNfrqbKykjZu3EgbN26sM7uJJ9K+fXsqLi72RlfwGefOnaOwsLCA/D48zxPP8x5nQfLG9QaDgT744AOX3pM333yzwboFQaCYmJiAPF9rlj+mbxjO4I81jlwup88//9yldzYvL4+kUqnf353y8nK3nqPFYqHCwkK666677NptHe94nrd9xnEcTZ061a16GI0HQRBo6dKldplXrbJ3717b96yZqGtqaqi4uJiqqqqoqqqKtmzZQsnJyTb9JJPJKDIyMmjnXs7onMZlovQxUqkU8fHxaNGiBU6dOsViWjAYzYShQ4cGbPeMwXCVqKgozJkzB3PmzIFer8egQYOwf/9+h9/leR6hoaG2LGgpKSn4/PPP0atXL1t8GVEUodFoUF5ejoSEBISFhYHneRARjh07hqysLJ8cAbIG7ud5HuHh4ZDL5SgrK6vzyAHHcejZsyfWr1+PuLi4Wn8PCQlBSEgIFAoFBg8eDAB455138Oyzz3q13WfOnMGAAQNw/Phx25GqYIKIsHTpUtTU1ASkfmvwc4PB4NExY3d3pDUaDb799lusWbMGBw4ccPk44PUZAuv7TklJCUpLS3HLLbfgypUrbrXVVS5evAiJRMK87BkBIysrCy+99BIAoE2bNmjZsqXNe8IVkpKSUF5eDpVK5bejcvfee68t86qrhISEID4+HuvXr0d+fj52796N1q1b4+abb7aNc0QEIoJUKg0ajxqG77BYLFi0aJFDL/KsrCxwHIcWLVrYjqk1ZFcwmUyNPyGVb2x4jYu6do81Gk3ArYNMmDDxj9zo/VAfZrOZLBZLg2MIg+EIX/SXzz//nD7//HPbTpdUKqVHHnmEKioqyGKxkCAIbnuACIJAXbp08dq7plQqaf369VReXk5arZZMJpOtbaIo0pUrVyg1NZV4niepVEpSqZQyMzPp8uXLLt+DxWKhTp06eX28UCgUZDAY3Hqe3qKuZ3Hw4EGfeGq5Ki+99JJfn4fZbKaXXnqJ5HK5R+3Oyclxq/63337bZ8+yTZs2Nh3F9A3DFVz1WLre8+bGz/Py8rzevoKCAo/fWWckLi6OSktLvd5+RvNFEAR6/PHHA65rfSkxMTH0yiuvOK1zmGGJ6lfSEydOpIkTJwb8h2XChIlvhed50uv1RHRNWRw8eJDmz59PWq3WdqTCYDDQ5MmTSSqVUnJysm1hxyb6DFfwZX+xWCxUU1NjZ/j0Fm+88YbH75lMJiOtVutUfYIg2MQTjEYjKZVKr44X6enpHrfLEzQaDS1cuJDmzJlD58+fJ71eT1qtlubNmxc0bvQcx9HEiROpsrLS42Nt9aHX60mv19OECRPcPhp6fZs9MRh6y6AnlUopNTWVUlNT6YknnrBrE9M3DFdw1rAkk8nIaDTartuzZw+pVCqSSqU0YMAAn+gUKwaDgX755ReaMWMGjRo1yuvjdY8ePSg/P9+n4xCjeVJTU0NqtTrg+taRtGvXjnbu3EkajYYMBgNVVVXRvHnzXCpj69atdOnSJad1TvD5cDMYDAaDwWAwGAwGg8FgMBoFLCsc6s/QY80gIpPJAtE0BoMRxBw+fBiZmZksKxzDJRpzfyksLMTLL78M4FpcwlGjRiE8PBwff/wxfvjhhzoz1llT0F+9etX2//5Er9cjJSUFJSUlHpeVmpqK48ePIzQ01Astcw1BEAAAL730EubPnw+TyWTLEmMwGHwSC8tTOI5DXFwc5s2bh1GjRkEmk4GIYDKZYDQaER4ebov35SqiKOLy5csAgCFDhuDcuXMetVWhUKC6utrt2Fk9e/bEgQMHPGqDFWsbYmNjce7cOYSHhwNo3OMHw/84mxWurKwM0dHRfmhRwwiCgIULF+LZZ5/1KOaMQqHAvn37kJGRwWIeMXyGIAgIDw8PCv3bunVrnD59GsC1/l8XLVq0sGWaq481a9age/fuSEtLc0rnMMMS6lfS1iCU7k56GAxG0yUxMRH5+flsos9wiabaXwRBwPHjx3H+/HmkpaUhJiYGRASJRGILth1IXUpEKCoqQlVVFQBg586deP7551FRUeHU9QqFAjt37kSPHj182cx6sW52DRw4EHv27AlYO9xFpVLhgQceQPfu3VFTU4OEhATceeedHhkbrZP5pUuX4tVXX4VGo0FISAiioqLQokULFBQUoKKiwqkAwUqlEpWVlZBKpW61RaFQOAzQai0vKioK5eXldRpg6yIiIsLWb5vq+MHwDc4aloJxOSiKIiorKwEApaWl+Ouvv/D222/j2LFjtvVZTEwM5s2bh969e+PChQs4cOAAbr/9dgDALbfcwgxKDL/x6KOP4ssvv/RbfTKZDFOmTEG/fv0AAH379kV8fLzT1yuVygaNYZGRkXjjjTcwbdo0ZlhylvqUtPWBe5LZpDEik8lgNpvtFE3Hjh0xd+5cAMB///tfLFiwICgVUXMhMTERixYtAs/zePzxx1lWswBBRGyiz3AJ1l+CD0EQbAuQ671VBEGAxWKBVCoNigxwVp37/vvv49VXX3XZQOEsUqkUCQkJtn9rtVoYDAbb8/BE9/M8j9atW2Pw4MF49NFH0bNnT0gknicpJiLo9XpUVVUhNDQUoaGh4Hkeoiji0qVLePHFF7F582bodLo62y+RSLB3717ccsstLtd/zz33YN26dbU+j4+PR35+PoD/9a2PPvoIU6dOdan85cuXY9y4cWz8YLiEM4almJgYr3hz+hNBEJzK4Mhg+BuLxYKCggI8/PDD2LZtm0/quHDhAtLS0jwq49SpU+jYsaPT33dK53g9ilUjpL5AiOfOnaNz584FPACXN0WpVNKQIUNoyJAh9OKLL9J9991HnTt3pv79+9Pvv/9OJpOJBEGg3NxcyszMJJVKRc8884xd4D6z2UytW7cO+L00dQkLC6MOHTpQcnIyqdVqysrKoqysLKqsrKzVVw0GA7Vp0ybgbW5uMn78eLpw4QIBLJgqwzlY8F2Gp5hMJpo1axYlJyd7PQPc/Pnz66xXEAQqLS2lJUuWUKdOnUgqlbpVR+vWrWnPnj0+DQjsqO2HDh2i9u3b19u2Vq1a0fHjx50K9KvRaGj69OkkkUjqLO/HH390eG1SUpLLzy0vL4+NHwyXcCZ4d0VFRaCbyWA0SU6fPu013RwREUHz58/3WhD6srIyl+pnWeGcpD4lfezYMTp27JhHHYHneQoPD28wnWZUVBRFRUXRhg0baNeuXV5PkaxQKGj06NF0/vx5slgsZLFY7FI8O0Kr1dKBAwccTv6mTJni1fYxsZdvvvnGrcGjpqaGhg0bFvD2N0dhE32GM/hzYajVamnGjBl04MABn9fF8D+CIJBOp6PZs2fXmSbcFdmxY4dLdefn51P//v1drueFF14ISFY9s9lMb7zxBvE8X+/zksvlNHDgQDp69CiZTCYSRZEEQaCioiIqKiqioUOHOv28x44d67Atq1atYvqG4XOs+ubEiRP01ltv2RmDs7OzKTs7O9BNZDCaNGVlZVRWVlbvRoxEIqGUlBR699136cKFC2QwGEgURZ9mMpw+fbrXdQ47Cof6jyXo9XoAcDlI5/333w8AWLZsmZ2LNxHh6NGjGDZsGIqKigAA7dq1w+HDhx3WIYoi9u/fjyVLlkCv1+Pmm29Gjx49kJaWhhYtWkAul9sC2/3++++2M5CiKILnecTFxWHMmDH429/+Bo7jEB0djczMTLRo0QJAw/Eu6P8H2JTL5bX+9p///AePPfaYS8+F4Rw9evTAn3/+6VEZZrMZ//rXv/DVV18BQFAElWvqsKMJDGfw9lEWs9mMWbNmAQAyMjJw5513QiKR4LPPPsOTTz5p+55UKoVOp2PJKAKI9cidL47VlZSUoHPnzigpKUFISIgtoLczwW8jIiJw4cIFxMTEuFwvEWH69Ol47733nPq+XC5HSUlJQIK4i6KIDz/8EC+88AIANHikj+M4hIaGQiqVorq62hbjylUuXrwI4Frgd2u9//73v/H666+7VR7A9A3DORzpGyKCIAheOYLKYDCch4j8fnzTqueur/fcuXNo166dS+U4o3PYiNIA1thKXbp0wbFjx+r9bnh4OBYvXoz777+/zk7DcRwyMzOdjofD8zyysrKQlZXV4Hfvuece3HPPPQ7/RkT49ddf8c9//hNVVVXo1q0bAGDatGno2bMnIiIiHE50zWYz9Hq9Q8OSNaAew/v8/PPPHpchlUqxcOFCLFy4EMC1BU1FRQUGDx6Mo0ePelw+g8EIDsaOHWsX2yUsLAw33XRTLZ1lNpuRlJSEoqKioIgX1BzhOM5nk8rY2FgUFRVBEAS7TSOdToeWLVsCuBYryUpqaip++ukndOrUyaP+wHEcZs2ahe+++w6XLl1q8Pv//ve/A2JUAq7FvtiwYYPTMaKICNXV1R7Xa42FMWTIEDz77LPYs2cPPvzwQ4/LZTDcgeM4ZlRiMAKAP41KlZWViIuLs9tc4nkePM/7LD5jk/FYOn/+PDIzMyGXy1FaWurStc7sHguCgIceeggrV660+zwpKQl79+5FUlJSUAeQIyLExcXV+Wzi4+Px448/olevXrb7KC4uxn333QdBEPDjjz/apSElIgwaNAg7duzwS/ubG6Io+rQ/HThwAD179vRZ+c0VtoPcPPBE3wDe91iKjIy0ZYyyIpFI6pw46PV6uzS0LAhq88JXO6ZGoxEqlcqhh5RCoUBqaipee+01jB07NiDZAQVBwG+//YZRo0YF1IPX+uw9nX4zfdN88PUah8FgNB00Gg2Aa1lIvUmz8ViyWCx48MEH0a9fP4+PD9VFSEgIVqxYgaVLl+LcuXOorKxEt27dHHryBCMajaZeZVRUVGTzipLJZLBYLLZUnsC1DGSrVq1CdskzIL8AAEl5SURBVHY2AGDPnj1+T3UcHh4OQRBsxxObKv5Y4PXo0QNXr15FWlqabREQERGBDh06ICMjA2lpaTavum+//dbpdNwMRlPHH/rGVVq2bFnLsBQWFga9Xl9rkc/zvEO9JYpiQBb7DP/jK/0il8tx9epVW+rj8vJyjBw5EjNnzkR0dHRAjJdEhJqaGly8eBFLlizB559/HvBj4U1kP5fhJ4JR5zAYjODF2wZkpVLp9Nq7SRiW3n77bbRp0wZDhgxxatCtqqqym4S7kqZdKpW6lJovWLjzzjud/q6j3UaTyYSRI0d6s0kuceLECdtzP3XqFLp27QqTyYSYmBh8+umnyM/PxzPPPBOw9nmTt956yy/1tGzZEjqdDufPn0dkZCSio6MhkUjAcZwtthYAJCcn4+WXX/ZLmxiMYMdVfQN4pnOcYevWrUhKSgJwbdEaFRWFQ4cOITo6GhkZGbhy5Yrtu19++WWtxX1ISAhb7DK8QkxMDE6ePAngWl8M1JFLIsKlS5fwj3/8A0ePHoXJZAqaPm7VsQyGM/hzjcNgMBo3xcXFXjm+DVxz6CgvL0dRURGSk5OduqbRB1nYvXs3li1bhgULFjh9zYcffojk5GSb9OrVy4ctDA4OHjwY0PolEgkkEkm9k8y6vL/OnTtnZ8xLT0+H0WgEEaGkpAT33nsvnn76aRCRLXZUY6Vt27Z45ZVX/FafVCpFeno6EhMTIZfLwfM8iAgWiwUajQYajQabN2/2W3sYjGDGHX0D+F7nJCYm4vDhwzh8+DAmTZqES5cuITU1FSqVCpcvX8bOnTsRGRmJhx56COPHj3dYBjsGx/AW1jhS9el7QRDsvKIdIYoizGYzBEFwql5rQOLCwkIMGzYMN910E/bv32+bLwQSqVQKqVSKf/7zn/jxxx/Rt2/fgLaH0ThgaxwGg3Ej9cVHevzxx71SR3h4OLRaLaRSqUvXNWrDklarxUMPPYQlS5a4dI7QmjnNKvv37wcA24K6rKwMO3bswKFDhyAIgtOTmmAmEEH6OI5DUlISDhw4AKPRCKPRCIvFgvz8fKjVatv3unXrBrPZDIPBACJCXl4evvjiC5jNZpjNZtx0001O13no0CHk5OQgJyen0QUmHDJkCE6dOhWQBZ41sPf333+PO+64AzfffDPS09ORnp6Obdu2+b09DEaw4a6+AerWOd6ka9eu6Nq1KxYuXAiVSmX3t379+kGj0WDZsmVer5fBcJVDhw6hbdu2iI+Px6hRo3Dy5EnU1NRAq9VCq9Xit99+Q7t27SCVSiGTySCVStG6dWv88ccfMJvNNgNSfn4+XnjhBaSlpSEtLQ0qlQoKhQKJiYn49ddf/W5MioiIQJcuXdC5c2eo1WrI5XKo1WosWrQIBoMBBoMBH3/8Me6++25s377d5mXIYDjC22scBoPRNKgv06s3QhpwHOd2gq6gNCy9+eabth2vuiQvLw//+te/cNddd+H22293qXyVSoVWrVrZJDEx0Ud3wmAwGIxgxtf6BmA6h8FgMBjXYGscBoPRVAnKrHClpaUNZj1o27Yt2rZti7y8PNtnRGQLQLps2TI88MADTtVnzZggl8shCIKdi1lGRgYA4PDhw406sOmaNWswZswYv9SVnZ2Nr776CvHx8ZDJZHV64FgsFlvaQ19i7eLWo3NDhgyxS8OtVquRkJCACxcuAKhtCQ4PD4fJZKrXQuwpcrkc5eXlCA0N9VkdjrDGoXj22Wfx888/+/QemwMs60rjw9/6BmBZehjNF41Gg5YtW9oFApVKpVAqlaipqQFQv5s/cM0DWxCEgB9vs6JWq/Hrr7+iR48etvkMEdmy79U1B9q0aROGDh3qdr1s/GicBGqNw/oLg9E0qC+zq8FgwJNPPgkA+Oqrr9zSk/v377fLHO7KGBKUZ4ViYmIQExPT4Pc2bdpktxD+8ccf8cEHH2Dnzp1OB5m6HqPRWOuznJwcAMCYMWOwdu3aRhuH4u9//zsmT56MhQsX+rSeF198Ee+++65T3/XXUTXrb8ZxHOLj43H06FEAdb+YgiCgqKgIMpnMlsnGbDZjwIAB2Lt3r0/aGBYW5vI5Vme5flCx3q/FYsEff/yBCRMm4PLly0EzQXeETCaDUqmEyWRq8hkBGf4nUPqGwWiOzJkzp9Y4bj327iwNGZ78SevWrXH8+HGEh4fbfV6fQcnKoEGDwPN8g7GmbiQkJKRJhGhorjCdw2AwPKE+3aJQKPDFF18AAL744gsUFxeja9euKCwsrLdM6xr0lVdesTMquUpQGpacpX379nb/PnDgAEJCQtC5c2ev1/XDDz/grbfewquvvmrzXLJYLDCbzTavG47jIAiCLV4QcM37RS6XQ6VSQSaTOV2fIAg4f/48VCoVEhISvHIPCxYsgCiKWLx4sVfKuxGO4zBr1iyflO0L6noxQ0JC0LJlS7vPpFIpdu3ahQkTJmD58uVeN8RUVVXh8OHDuOWWW7zqGXfo0CEMGDAAAFBTU2O7Z1cnsoFAIpFgzZo1uPPOOxESEgJRFHHixAkMGDAAGo0m0M1jNDP8qW+aK4IgBCQlPcM/EBFiY2Mhl8thNBrBcRwUCgUkEgm0Wm2gm+cybdq0wYkTJ+pMPNIQMpkMHTp0sGXRawiFQoEtW7agVatWSElJcatORuOB6RwGg+EpcXFxdpkhrz/F4whP519BGWMpWHnrrbeQmpqKe+65B/3790fr1q0RFxeHqKgoqFQqRERE2NK2x8fHIz4+Hq1atUJsbCyUSiUSExOxcuVKW5Dquti8ebNtwpGYmIjExESXdvPqguM4TJs2DWFhYR6X5YhWrVo16QUBz/P4/PPP8fHHHyMiIsKrZVssFgwcOBC33347zp0755UyN2zYgFtuuQXV1dWorq62uVE3BqMSAEyePBl33303JBIJOI5DSEgIMjIysHHjxkYXmJ3BaG6YTCanxxoiQocOHWzBmlNTUzFnzhxcvnzZ4TFkk8mE//u//4NCoYBUKsVNN92E3bt3w2g02sY4qwSzN2Zzg+M4PPnkk8jNzUVZWRmMRiN0Oh1KS0sxceLEQDfPJfr27YuTJ0+6bVSy8sMPPzg1b+I4DmfOnMHf/vY3n4cPYDAYDEbT5PqsrY7E03V8UMZY8jfWs4P+JCwsDMnJyRg6dCjuuusuCIKAqVOnAgBOnTpV6/tRUVHIz8+HQqFwu05BEPD222/j3//+t0+MC23atMH58+e9Xm4wQUQ4fPgw7rnnHly+fNkndUilUhw9ehQdO3Z06vuCICAvLw96vR5xcXEwm814/PHH8dNPP/mkff5i/fr1GD58eK3PKyoqkJqaiqqqqgC0qn5YDAOGMzT1mBe33nortm3bBolEYstqVJ8n5i233IJDhw41WK5MJoPFYnFZf1nTvL/77rtOHzkWRREvv/wyysrKsGjRokYdY7GxkJWVBQDYt29fgFvimPDwcHz88ccAgPHjx3utT4wfPx7Lly+v9zvZ2dnYunUrgKY/fjC8C+svjKaIwWCAXC6v1xBSXywihvO4MoYwwxICY1hyh6ioKKxbtw69evVy+DLV9/JotVrcfffd2LFjh892cKVSKaqrq+0m7k3tpb506RLuu+8+HDhwwKc74SqVCqWlpbZnKYoiTp06ZXOZ79ChA1QqFTZv3oznnnuuSR4NmzhxIhYvXmy3O0tE2Lp1K4YNG+YVLz5vwyZuDGdoyhN9q1HpRhYtWgQAeOKJJ+w+1+v1fk1awPM8wsLCYDabYbFYIJfL8eyzz+Lll1+2eUJu2LABd999t+0amUwGnU7nszh4DHsiIiKg0+kC3QwbcrkcixcvxtixYz3a3KsLi8WCFi1a1LtZUlFRAbVaDaBpjx8M78P6C6Op0bFjR5w6dQocx9mcMmbPng2e51FTU4O///3v2Lp1q80besOGDazvewAzLLlIYzEsWbHGbIqKioJMJrNNhjt27IipU6ciMzMTUqkURASdTodx48Zh/fr1fjkS0L59e6xbtw4hISH45JNPsHHjRmRnZ9uChjfmXd/PP/8ckyZN8lvg0AcffBCLFi2CTqfD3XffjYMHDzarYx0KhQKffvopRo8eDYVCgZqaGqxZswbTpk0LqkXH9bCJG8MZmupE/6+//rJlUq2LhIQE5ObmQiKRQBRFW2D+xkDHjh3RunVrHDp0CFqtFlKpFJ06dcKbb74JABg4cKBPDA/NkcjIyKDwSk1ISMCpU6cQGRnp0nVEhOLiYpjNZrRs2bLB42tnzpxBhw4d6mzD9TEymur4wfANrL8wmhLTpk3D3LlzXb4uPj4e27dvR3p6ug9a1bRhhiUXaWyGpYaQSqUIDw+HyWRCdXV1oJsDALYJ019//WUXH0cURVRVVYGIEBkZGZSxA0RRRN++fX2WEa4+IiMjUV1dHVRZcPwJz/O2oPcWi8Xvz8EadL+8vNyp4zds4sZwhqY40RcEwaXYZ7GxsSgrK2s0Md9coW/fvtiwYQPCw8NBRCgqKsL8+fOhVqsxdepU5vnkJIsWLcLkyZPtPuM4DlKp1CfGSGuML6PRCEEQEBcXhz///NPl+eGpU6fQrVs3WxIXiUSCw4cPA0C9gZezs7Oxffv2Wp9fvXrVLqFIUxw/GL6D9RdGU8HVeYYj2rRpg4MHD9o8QBkN48oYEnyreIbHmM1mVFRUBI1RCQBOnz6N06dPIzo6Gh9//DE2bdqEBx54AOHh4YiKikJ0dDSioqLw9ddf+3yhYQ1iTUQ2EUURRqMRRqMRWq0WFRUVuHjxIqZNmwa5XB4QoxIAVFZWNlujEnDNqGcwGGAwGPz6HEaPHg2TyYTKykqUlJRAEASsX78e69ev91sbGIzGxE033eTS90tKSpqkUQkAdu3aBZVKBZ7nbVlGZ82ahRdffBHR0dGBbl6jYdKkSXZ62qqr9Xo9PvvsM6/Vk56ejkuXLqG6uhpFRUVYvnw5hg8fjhdffNEuLTwRQavVQqvV4sKFC6isrLT1YSJCZWUlbr75ZnTs2NFmVAKubYpkZGQgIyMDRqOxznZs2bIF3bt3B8dxkMlk+Pnnn/Hzzz/XylLLYDAYzZG77rrL4zIuXLiA6Oho/PTTT40+Fm0wwjyW0PQ8lho7kZGR+PTTTzFy5EgA145EcRwHQRBgNptBRJBKpZBKpQ7jN1m7tMVigVarxeXLl/HDDz9g6dKluHr1arM21DAa5s0338Qbb7xR598rKirqXByyHUGGMzS1HeRjx46ha9eugW5GoyE/Px+JiYmBbgYqKyuhVCptXqGNCYPBAKVS6fb1mZmZAIB169YhJSXFbi5hNBqxbt06nDx5ErfffjvS09NhMBgwd+5cLF68GABQU1MDIoJEIgHP87a5SUPMmjULL730Ur3f0ev1kEgkdXq2NbXxg+FbWH9hNAUMBgPCwsK8viG1fft2DBw40KtlNjVcGUNYzm5G0FFZWYkHH3zQNtGTy+UICQmB2Wy2Td44joNCoUDfvn0xadIkxMbGYtu2bVi0aBGKiooAoFnFI2J4h+Tk5HqNSsC1IPo//vijzfDJYAQ7Vk8PX8S40+v1uO2227xeblPmzjvvtB2N8hV//PEHpkyZgm7dumHx4sWQy+W2v+n1erRo0QJ6vR4A0LZtWxw+fBihoaGwWCwwGAyIiIgI6sQbcrkcUqnUrSQO2dnZtp3q8PBwh9/ZuHEj1q5di/feew+iKMJisTicU7i6UbVgwYIGDUueGMwYDAajKUFEsFgs2L17t0+8nAcNGgRRFINa3zUm2FE4RtBidX03GAyorq6GyWSyTeyICHq9Hr/99hvGjBmDgQMH4s0330RhYaHtOgbDVZxJeQ4AI0aMsFuoMRjuQkQQBAGCINQ69nP9OEZEMJlMKCsrQ0VFhdML2r/++gsymQwymQy7d+/2Sput8c4uXLiA4cOHo7S01CvlNheOHDmC4uJir5drNBpxzz33gOM49O/fH8eOHcPSpUuhUCgQFRWFqKgotGrVCqGhoTajEgCcO3cOERERkEqlkMvliIyMhEQisaW3t2INSJ2fn++wfkEQoNPpbMfKTSYTLl26hHfffRfLli2DIAheu1eO4zBmzBiXr5NIJJgyZQrkcrnDMVwURSxduhTffPMNtFotjEaj095IzlBRUeGVchgMV2HzYoanGI1G5Obm1nuk11sQEU6cOIE1a9bg6NGjEATB5SQKzrJ8+XKflNssIQbl5uYSACZMvC5KpZKmT59Oy5cvp169egW8PUzqFrVaTaIoOj1uLFq0qFYZubm5PhypGE0Fq85RKpUkkUiI47hawvM8yWQyUiqVJJfLieM4u77GcRxFRERQ+/bt6fHHH6cLFy7QhQsX7Prw6tWra/VRvV5fqz2CIDTYZoPBQHPnzqUOHTpQZGQkRUZGkkKhqNUuJs5L27ZtqW3btjRv3jyqqanxqE+JokgqlcrrbQwPD6fw8HBq3749SaVS2+dSqZTWrl1LWq2WcnJyKCkpyanyPvjgAzIYDGQymchgMHh0z4Ig0IgRI1y6H4lEQnfffTdt2bKFtmzZQufOnaMrV67QuXPnaPXq1dS+fXuf/ubh4eEu6RlHWMcPpm8YzmDtLyNHjvS47zGCn4b0ucViIbPZXOffzWYzGY1GMpvNZLFYyGKxkE6noxkzZpBCoSAAJJfLae3atbb+JIoi5eTkUHZ2NqWnp9PIkSNp5MiRNGvWLPrmm28oJyeHLBZLrbpEUaSamhoyGAwkCIJNrly5Qh06dCCpVEpRUVH0/fffk06nozNnzlBERESd46tcLieVSmWnq5yR5ORkzx56E8cVncM8lhgMBoPBYDAYDAaDwWAwGO7hB0NX0MM8lpj4QubOnVurr5nNZpowYQLxPE88zwe8jUz+J+np6S6NG2azmeRyuV0ZbAeZ4Qy+1DmxsbE0c+ZMGjBgQJ39vKamhvR6Pa1cuZJWrlxJQ4cOpX379tXZ3pUrV7Lxyg+ybds2t/uUXq8PePvdkcjIyHp3z53Buqu+cOFCio+PJ5VKRUlJSZSSkmLbYQ8WSUlJ8eheiZjHEsM1rtc399xzT6Cbw/ARP//8s01PSyQS+u2332weRVqtlrKzsyk7O9vuO506daJVq1bR+fPnadeuXTRs2DBSKBTE8zxJpVKbd3JYWFitsYzjOLrnnnvoq6++op49ezbovaxWq+nYsWMkCAJZLBb69ttv7TyLrB7aSqXS7jqe5+n06dO2+xQEgX799VcaMmQIPf/881RaWkqlpaW1vPEqKyspNTXVqXG5c+fOfv2tGhuu6BxmWCJmWGLifVm1alW9fc7q7nno0CFKSEgIeHuZXFN6zhwJup68vDxKTU21GZjYRJ/hDIHWOYmJiaRWq23H7gCQQqGgAwcO2LXTZDLRwIEDPapLIpEwo5QL8ueff7rVp8rKygLedk/6iK+O6FgsFnrrrbeC5sjmCy+84PE9McMSwxVu1De//fabU9dVVlY6PDrNCA4EQaDTp0/T6NGj6x3fnB373B0jXblOIpFQly5dSK1Wu3SNJ5sPo0aNqrd8hUJBFy5c8OIv0/RgR+EYjAChUCiwb9++BoOK8jwPnufRrVs3FBQUYN68eX5qof+RSCRISUmpM/tOsKDRaLBixQqXrklKSsLFixdx7tw5H7WKwfA+BQUF0Gg0dgHCDQYD+vTpg1tvvRVTp07FLbfcgrCwMPz+++9u1xMZGYkxY8bg888/x6uvvopXX30VUVFR3rqNJknPnj0xdOhQl7OdWbOhNkYsFgvUajVMJhNMJpNXyw4JCcFrr73ms6CvrjJlypRAN4HRzBk8eDCOHDlS599NJhOUSiUiIyOhVCqhUqlqjS9W3bF161ao1WqEhIRAJpOhZcuW6N+/P7p164b27dtj1KhRuHLlSlAGDvckmcDhw4dRWFjoxdY4j1arhVarRVhYGDp06IB169bV+3ydffbu/kauXGexWHDs2DFoNBqnr1Gr1ZBI3E9iv27dOnTs2NGuvAsXLtiSkNTU1CAtLc3t8hk34Dv7VuMh0LvHTJqGpKWlkVardbsfZmZmBvwevC1qtZq++OILOnfuHE2dOjXg7WlIOI6jTz/91GGQQWfGELaDzHCG5qJz2rZtSydOnCCLxWLz0rx69SpFRUUFvG2NQUaNGuW0J89rr70W8PZ6KtYj4m3atKFHHnmEKioqvPbO9evXL+D3B4BMJpPH98L0DcMV6tI3w4cPt43LVnQ6HUkkEoffl0ql1Lp1a0pISLDzdnVWFAoFKRQKkslkdp/HxsbSiRMn/PpMdu/eTQqFglJTUx16ZVVVVdGECRPou+++qzUGb9myhSIjI2nkyJF+au3/MJvNbj37xixz5szx+LkJgkBTp06l77//3gu/QvODHYVzkcY0yZfJZJSenk6pqanNamAJdpHL5aTT6Tzqh3/++WfA78MbIpPJSCaTUdu2bWnNmjVUXV1NBoOBvvjiC4/LVqlU1Lt3b0pJSSGZTGZbiCgUCkpKSqL4+Pg6J0Wu3kN8fDyNGjWKysvLnR5D2ESf4QyNSed4IhEREXT8+PFa9//DDz8w/eWkREdHN3hEt6SkhGJjYwPeVm+LQqHw2lGcYcOGBfRerItBbxz5Y/qG4Qr16RuJREISiYTuv/9++sc//hHQY8sSiYS2bNnil2cybtw4W71yuZzeeecdOn/+PD3//PP0/PPP19JP7du3p127dtHy5cupVatWJJfL6b777vNLW60YDIZmeazc04ypVlhGRPdhhiUXCZZJvnXioVKpqFOnTjRgwADq3LkztWrVinr06EE7duyweVIIguCVhToT78jQoUM97oe///57wO/DG6JWq0mtVtPw4cPpt99+o7KyMsrNzaWOHTu6XM7bb79NX375Ja1fv540Go2dYhBF0Ra09cbPa2pqqKysjCoqKuj48eN1ppB2ZnGbmZnp9BjCJvoMZwgWneMPyc7OrmUYqaioIJVKFfC2NRaJiIig6upqu2doNBpp8+bNNHr0aIqLiwt4G30lzhjWnCE+Pj6g92H11mCGJYa/aWz6RqlUkkaj8ekzqaiooKSkJNsc0LpB2ZA3UHh4OGVkZND9999PxcXFPm2jFVEU6eOPPw747xIoYQQeV3SO+4cWGV4hLi4Oc+bMwahRoxAWFgYA4Diuwet4nseECRMwa9YsnD171tfNZDRAcnIyiMip384RgiDgscce83KrAkNlZSUAYPPmzdi1axdatGiB0tJSl85Up6am4vz58+D5usPAcRyHkJAQh58rlUoolUoA185Tnz59GmazGX/88QcqKirQvn17AMD58+fx8MMP29rsiL/++suj35bBaM5s27YNq1evxr333mv7TKfTeRQzobmh1WoRHh6Otm3b2mIv5eXlwWKxOHX99WMXBWGsk/ooLy9HTEwM1qxZg5tvvhlqtRpyudylMnJzcwMegyo+Pj6g9TMYjQW9Xo/Y2FiUlpZCpVL5pA61Wo28vDzk5OTgrrvuQmFhISwWi21OWdfYyvM8tmzZgpiYGL/MCUVRROvWrXH16lWf1xWMsHmC8xw6dAiCICAzMxNSqdT2uSAIICK/PUv2i3mRZcuWYezYsRBFERcuXAAA/PTTT6ioqEDbtm2RnJwMmUwGpVKJm266CTExMfUunJ1h8+bNSE1N9ULrGZ6wefNmlJWVITo6GhzHQRRFCIJgM35wHOdQCYmiiKtXr+K2225rMgZC68LFaDTCaDSioqLCpeutAbG9jVQqRXZ2tt1nnTt3xrp16zB48GCIoujwOkEQIIqiQyMWg8FomLFjx+K///0vAGD48OGYO3euS4ZmxrVx1R0dwXEcJBKJ00aoYKSiogK33nqr7d9du3bF4cOHG1zYmUwmvPLKK/jggw980q74+HgsXLgQpaWlmD17NnJzcyGRSBAZGQlBEKDRaGAymSCTyfDCCy/4pA0MRlPEbDbjt99+wz333OPTejIyMnDx4kV88MEHOHr0KP72t78BuJbM5e23366VROH//u//EBsb65W6rXPl+uaXn3zySbM1KgHweI3cHNDpdIiOjrbrq1YjEsdxEAQBSqUSGzduRL9+/XzeHo4a2/aVD8jLy0NycrJHZZw5cwbt2rXzUotcw+qZYTAYAlI/49rLq1arERkZibKyMlRXV9sZKiQSCSQSCRQKBQDYBgC9Xl+nQaM58uqrr2LGjBl+rZOI8NZbb2HNmjXo1q0bUlNT8dlnn9l2uHmeh8FgsNsBuBHrGJKbm4tWrVr5q+mMRoo3dA6DEaxYx8q1a9di2LBh4DgOBw4cQL9+/VzOdlcXHMdhw4YNyM7OhtFoBAB8+OGHmDt3LmpqamCxWHzqndW6dWucOnXKNv8SBAHl5eUwGAxQqVSQyWS2jENSqdSWlc4bGxRM3zBcwRl906pVKyxcuBAxMTF499138dNPPwXUu5HjOFy5csVv/Zv+f5a76w0ZOp0OERERdt+rrq5GaGioX9oEXMsSeuDAAb/VF2xYN+oZ1/poTU0NBEGARCKBRqPBXXfdVW+GxxvZsWMH+vfv73LdLukcX5zFa2x4ev5YJpMFtP0vvfQSvfTSSwE/B8uEibtSXl7uVJBsX+Eo7sW3335Lcrmc4uPjG8zkw2JeMFyhscW8YMKkLomIiKDTp0+TwWAgs9ncYAyhXbt2UXR0dNAHb+c4jrp06UIXL14kvV5PJSUltHTpUvr000/p008/9VpAWXdg+obhCvXpm/z8fMrPz3d43datW0kqlRJwLUbYjBkzaN++fZSamurTd4/neXrmmWeCItjy7Nmz7cYEfzN9+vSAj4WBFm8lcPAHer2eVq5cSSNHjqTp06eT0Whs8BpRFOnXX3+l559/nn7//XcyGAwkCAIZjUb6+OOP6eOPP7a9h96Q5cuXuxy30BWdwzyW4PnucVZWFvbs2ePFFrlGdXU1ACA8PDxgbWAw3EWv19s8uYKN06dP4+LFixg6dGi9xy7YDjLDFZjHEqMpoFAoUF1d7dZxBSKCyWSCwWCARqPBuXPn8OWXXwIA1qxZ43cP7Li4OLzwwgvo0KEDJBIJMjMzER8f79fYekQErVYLvV4PnudtxxdDQ0NtHk8A0zcM13Ckb6z9y93+bT2itm7dOrvPOY5z2dNJKpWid+/eeOCBB9C3b1+kpaUhPDw8KOJaEhHUajWqqqowfvx4LF261K/119TUQK1We83TszGSmJiIvLw8m54xmUy4dOkSUlNTIZPJfFYvORFbVavV4r///S/eeecdnD59utaR8+TkZFy+fLnOcsrKyhATE+O1NjsDz/NYtGgRHn30Uac9aJnHkot4unusVqsD2n5RFEkURZLL5QG3LPtCMjMzKS0tLSB1N5QhoimLP+49Ly8voO+OMziza8Z2kBmuwDyWmDQFOXHihE/eD7PZTLNmzfKL7o2NjaWdO3d6JfOcp+Tm5lJcXFyt++Y4jubOnWv3PYDpG4ZzONI33urv58+fpyVLlpBOp7N9JggCzZkzh1QqFSkUCmrfvj1NnDiRJkyYQBMmTKBu3bpRWloa3XHHHXTy5Mmg8Eyqj4qKClq8eLEtK7e/OXbsGMXGxtY7jqlUKtqwYQOtX7+eEhMTbZ/zPE8DBgyg9evX27wt1Wp1wHWHq6JQKGjo0KHUunVru8+7d+/u1WddU1ND4eHhdnXEx8fThQsXyGg0kkajoeeff56ef/55UigUTrV9586dDusSBCFgz7Nz584ued26onNYVCwGg8FgMBgMBoPBYDAYDIZbsKNw8M6xBKPR6FOXPGe46aabbNnoGjvx8fHIz88H8L+sABcvXkSbNm0C2awmi0QigUqlwt/+9jdMnjwZ3bt3tx1PKy4uxpIlS/D111+jrKzMay65Dz30EJYtW+aVsgINO5rAcAV2FI7R2JFIJDCZTD49rrJ//3706dPHa8FbeZ7H0KFDMXPmTKSnpwNA0BzDFgQBMTExdWZLlEgkNt3L9A3DFW7UN3fffTd++umnALaI4SoWiwU6nQ5fffUVpk+fDuB/CZtiY2Nx6dIlu6Dier3edozO0XEnIsKVK1ewYsUK5OTkoLS0FAcPHkR5ebnD+hUKhS05kfW4F8/ziIuLg06ng06nq/M6pVLpcnZoV0hJSQEAXLp0yaNyiAgKhQImk8kLrfofCQkJtvXs9fqyX79+2LVrl1frcpYRI0Zg9erVdkmJrHpWFEVbVjkr7Cici3jrWEJxcXFA7+OJJ54IuLuipyKRSGjv3r113uO3334b8DY2FWndujXt2LHDqeByVoxGIx09epQee+wxioqKcrvuQARB9CXsaALDFdhRuMBKWFgYxcTEkEQisfs8NTWVUlNTae3atTR8+HCH1/I8H/D2B4MoFAq/vCs5OTkUERHhcXtnzJgR1EduJkyY0OA9WI/iMH3DcIUb9U2gjnQxvIM1/ElVVRUVFRV5fVyzWCy0d+9e2rFjB5nNZjKbzQ7bcD0ajcYuHMvMmTNp5syZtr9XV1fX0rcAvBqU2mAweHTfZ8+e9YmulEgkpNfr7YKQ63S6gIVZSUxMpNLSUrt7LywspKysLMrKyqLY2Fh69dVX7Y7LuqJzmGGJvD/J5ziOZDIZyWQyuv322/02iO/fvz/o4gG1bt2aDh8+TAaDgQwGA1ksFhIEgQRBsBuYXBkY2cTeM3nrrbe8cr5eFEUyGAy0e/duateunUtt6NOnj9v15uXl0eXLlx32GUEQqLq62pPbcgs20We4gi8MS9aYaM11fKwvJpxaraZff/3VYXZHg8FAJSUlDsfECxcu2MqUSCS0fv16MhgM9OeffwadrvW38Dzvj1eFiIhMJhMdPHiQsrOzHS5O6hOVSuXS5kkgMBgMTt2LdWHC9A3DFW7UNwyGr7BYLPWu5wRBqKWHRVGk48ePU0ZGBkmlUreNTV26dPGo7S+++KJPdKVCoSCTyWR334HYXJRKpTR79uxahkJRFKlPnz61vq9Wq0mr1dq1l8VYChD0/7OdmEwmbN68GVKp1Guu3PXRtWtXjBs3DgqFAjzPQyKRICoqCmPHjsW+ffug0Wig0+lw5coVzJ8/H/Pnz0fPnj0RFxeHiIgIyOVyOzc9nucxbNgwFBYWQq/X49SpU+jduzd69+4NuVwOhUKB++67D2VlZRAEARaLBaWlpdi/fz9yc3MhiiIuX76MzMxMyOVyyOVyhISEgOd58DxvV5cr7vRJSUlefW5NnaioKERFRWHTpk0gIrz++utuZfG5EY7jIJfL0adPH5w5cwZnzpyBUql06lq1Wu1yfVu3bgXHcWjVqhVSUlLA8zwSEhKQkJCAbt26ISQkBCEhIQgLC4NcLnc5M4mr+Lp8BsNZdu7cCVEUIYoiBEEAEaGwsBADBgxw+Yi2XC5H9+7dHY7JYWFh+Oc//4nU1FSkpqZ6qfWeM3nyZBgMBpjNZpSWlmLt2rU4fPgwDh8+DIvFgoqKCgwZMsTO7duKXC5HTEyMwzExLS0NJpMJeXl5MJlMGD58OORyOXr06IGSkhJ/3FrQ4o85jRWpVIru3btj69atMJvNMBqN+O233zBjxgysX78eRUVFKCoqQnV1NcrKynDw4EHs27cPer0elZX/r717D4uqzv8A/p6RGWYAAZW7F1A35JKKmoC6ZraummlrN1ezdLMe09RSy7Lbz8umlav2bGRP5apsmVk9z7qbPbpJa1oqgpGQApprhEByEwTlMrfz/f3hMjQywNwv8H49zzyPHr7nnO93vjPnc85nzvl+69w+TEFn/vnPf1pUzhFxm7o3T5hpjbquHj16dPgZk8vlbeKwTCZDQkICfvjhB2g0Gmg0GtTX1+OVV15p80hWR86ePWtzvQEgLy/PrvXbs3HjRigUCpN2h4eHWzSTe2JiIhITExEdHW3zd1elUuGtt95Cc3Mznn32WbPv6enTp9ssu3r1Knr27AmlUonExESL98cxluCa8S7Cw8NRXl7u1H0AgE6nQ11dHfR6PQICAqBWqy2eTrCFJEkQQli9nqtMnToVX375pUO3KZPJjF82pVIJpVIJIQQ0Gg2am5s9OonQUteWqWODg4Oxbt06/OlPf4K/v79LTyQqKiqM36WOxmJSqVS4du1ap0FDkiQcPnwYU6ZMselC5urVqybTNDsLx7wgazgy5kRHR3c4toAQApIkQavV4sSJE5gxYwaamprMlp0wYQKOHDliXC8qKsoYt/z9/VFXV2cSFwwGA8LCwtodl8EaKpUKKSkpGDt2LP7xj3/g/PnzJn8PDAzE0aNHMWTIEFRVVWHnzp1oamrCK6+8YtEJmjPk5eUhKSnJLfv2BJ4cF73J5s2bsWrVqk7LSZIEmUzGeENWuTne8HtL3kKr1aJ///6orKy0qLzBYLA5Ab9w4UJs377dpnXbc9ddd+HAgQNm/3bo0CFMnTrV7PdRJpOhoaHB5Md6nU6HHTt2ID09HQ0NDairq0NFRYXJmFBqtRp33HEH5syZAwCYOHEioqKiOn1PVCoVNBpNp+3hGEsWctUtaQ8++KDxFsHr16+L9evXi3nz5omKigo3vwPexdwte9a+lEqliI+PF08//bTIyMgQlZWVQqPRCI1GI/R6vdDr9aK5uVmUlJSI5557TiiVSqd8JoKCgkRcXJyIjIy0+hGWkJAQceXKFePz1p4yfkTLVJyd1b9Xr14iPT1dHD9+XLz88svi5ZdfFuHh4Q5/xGTx4sVObzMfTSBrmIs5arVaxMTECLlcbtWxwNop3yVJEvHx8Wa/j+b8+c9/FuPHj+9w/IJffvlFPProo+K9994TjY2NQpIkYTAYRFpamtk6T5w4UdTW1gqtVis0Go3QarVtjl9arVZcuHBBVFVViaqqKqva6EolJSUiKChIBAUFdbvHEckxqqurO32vfXx8jOUZb8gaN8ebFStWuLtKRBaTJEmEhYV1eoyUyWR2DT1z/vx5h8VGhUIhTpw40ek+y8rKxIwZM0we8ZbJZOL69esdvh8tdDqdyM7OFitWrBD79u2z+bHvoKAgi9rFMZYs5AkDqfIEwXK9e/e2672+6667RE1NjcXjDEmSJHbs2OGwvu7bt6+oqakRNTU1JvtpGTAvLi6u0wuTBx54wBlvrUOUlZWJsrIyjxqDpOU5YWfhiT5Zo+XzolarxaRJk0RtbW2bMjExMRZ9ts2NG2SJnTt3GhMi48aNc1piWqfTiXfeeUds3bpVbN261WQAy66mJcGv1WqdNl6Dp7wCAgLc/XZ3KZ0N3v3BBx8YyzLekDXMXeMcPny43fKSJImamhq7B0MmchRJksTIkSM7PEa29+OYNdRqtd2xceTIkWYHPO9MU1OTyM/Pt+mczt7zN0sSd5bGHD4KB8+Y+tnHx8c4daSnPoLmKeRyuc238i5ZsgRpaWlWPx4mhMDQoUORn59v1Xoymcz4zLGfnx/eeOMNLFy4sNP9i/+N05Wfn49NmzYhOzsb/fv3x0cffQQAHn37e8vtlBEREe1OnexqRUVFTh0Tho8mkDUs/bwoFArj1L7taXk8hjxPaGgoqqur3V0NEy3TKd/8aHHPnj3Ro0ePdo/Zvr6+kCQJOp0Ocrkc+fn5iIuLc0GNu48LFy5g3rx5yM3NNZ4PAsBvfvMb/Pjjj8bvOeMNWaO9axy5XI5Zs2YBAKKiorBnz542Q3b07NkTlZWVUKlULqkrUUfq6uoQExNjNk7t378f06dPt2v7Go3Grs/6vHnzkJ6e7lXnZDqdDv7+/h0OX9LCkphj+ahY3UBsbCx+/PFHt+xbr9cbL3xLSkrcUgdvcOXKFZuTSuHh4Xjrrbds+sLLZDJ89913CAoKMnme9dd/B24khGQyGUJDQ7F3716MGzfOOI6QTCazeN8tA2OPHDkSe/futbq+7tQyQN38+fPx17/+1c21ucHdiWMiW2g0mg5/aFAoFF51AtPd5OTkIDo62mnbl8vlGDRoEEJCQlBUVISampo2J4cBAQHYsWMHHnjgAeM6wI3P1tGjR6FQKDB+/HhjnNLr9Zg1axYOHjyIwYMH49tvvwXQOuFCfX09dDodQkJCnNau7uqWW25BZmYm9Ho9Ll26hKKiIgDAmDFj+D0nh5MkqdPzy2vXrkGtVmPu3LnYvXu3i2pGZF5QUBBqa2uh0Whw7733IisrCwsWLAAA3H333XZv39fXFxUVFQgPD++0bFhYGN544w0kJCTAYDBg4MCBiIiIsLsOrnTx4kUkJydblFSyFO9YgumvP7fccovJL0XuMHToUPzwww9urYMn0uv16NOnD+rr621av7S01O4Z5WpqapCUlISqqiokJSUZA21L4kKv18PHx8fjZ6FxhYaGBowYMQIXLlxw6Hb9/f0xbNgwNDU1obCwEAA6HHTunnvuwb/+9S+H1uFm/AWZrGHN5yU7OxspKSltlqvVapSWlqJ3797OqiY5gKWDYlqq5QeoU6dOmU3utJzS2ZuIaPmRhDwP4w1Zw1FPZahUKjQ2NvK4QB7DWXEqKysLqampZv+WnJwMADh27JjZmWa9gSRJiIiIsHp2W0tiTpeYu3Tnzp249dZb4evri/DwcKxevdrmbT3++OMOrJltzpw5g4SEBJfvV9wYc8vl+23PlStXcOXKFWzevBkDBw6EUqm0Oak0ZMgQu5NKANC7d28UFxejoaEBmZmZGDx4MAYPHmycSc7Pz49Jpf/x9/dHfn6+wx5BU6vVqKqqwvXr13HixAmcPn0azc3NaG5uhiRJaG5uxvnz57Fy5UrExcUhPj4eR48edXpSiboXR8YbSyQnJ6O2thYTJ07EhAkTcPjwYej1ejQ2NjKp5AVaZtmzlVwux/Dhw/Hee++hqqoKRUVFKCoqaveOIWvujO0ILx6JPIOrY057mpubIZfL0djY6LBt6nQ6bNy4ETNnzsRrr72GI0eOYN++fRg/fjxUKhXkcjnCwsIQFhaGhoYGh+2XugZnxamUlBRkZGQgIiICgYGB6NevH6ZOnYpvvvkGJ0+exMmTJ702qVRVVQVfX1+rk0qW8vpH4bZu3YotW7Zgy5YtGD16NK5du4bLly/bvD1PuVOosLAQCQkJKCgocOp+DAYDPv74Yzz11FO4evUqhBDw8fHB6NGjsWfPHvTv3x8ymQySJEGj0Ri/xGq12uFfaEmSUFxcjAkTJjj0cUCZTIacnByHbo8n3ZZRKBS4ePEiRo0ahdzcXJu3s2LFCmzdurXdv7c8OhgbG2s8HhA5mqPjjaWCg4Nx+PBhp++HHC81NRVHjx7FtGnTLL4wksvliI2NRXp6Om677bYuOe6iEAIGgwH19fUoLy9HTU2N8YJVkiQMGDAAsbGxxkf0iLojd8Wcjvj7+2Pq1KkAgAMHDth8PpyamoqsrCzj/9v7EbDlAjggIABjxozBt99+ix49ekCSJOzatQtPP/00tFot+vTpgzlz5qBnz57YsWMHAOCXX34BcCNRcPz48TbTrkuSZPP09NS1TZo0CSUlJZDL5V3iM1JWVoZx48ahuLjYqvXKy8uh1WoxYMAAy1awaxhxN6upqRFqtVp89dVXdm3n1zNswANmW/n1Ky4uzkHvlqmdO3eKnTt32jxzV2BgoENm2jp48KCIiIgQCoXCKe+fj4+PKCwsdMA7RvbasGGD1Z83pVIpGhoa3F31TnGWnq7PUfFGCH5euiOdTifS0tI6PAYOGjRI/PLLL06boc+T5OTkiL59+3Y6A+ojjzzi7qp6HB4/ugdHX+M466VUKsWMGTPEu+++K55//nmRmJgoQkJCxK233ipOnDjRZgbmr776ym3XVAMGDBAjRoxoc9wZM2aMXVPVE3myRYsW2fR9yc7OFkJYF3O8+qegjIwMSJKEkpISDBkyBI2Njbj99tuxZcuWDgfQqq+vN3mkyt3ZfyIi8my2xhuAMYeIiKzDaxwi8jrOzpI502uvvSYUCoWIj48Xhw4dEsePHxe//e1vxahRo9pkyH9tzZo1ZjNzvr6+bsuid/SaM2eOw96zxsZG0atXL4fUq2fPnnbVo7NfKq19yWQy4evrKyIjI0VkZKTYsmWL0Gg0DnvvyH51dXUiNTXVov6MiIhwd3Utxl+Quz5b440Q7cccfl66H51OJ5599lnh6+sr5HK5kMvlIiYmRly5csXdVXMZg8Fg1XlIUFCQuHbtmpAkSWi1WlFdXd2tYzvjTffg6Gscvmx/+fv7dxrnrVFWVibGjx8vxo8fL8aMGSNeeOEF8fXXX4vGxkaH7YNICCGOHDli02deqVQaP/PWxByPTCxZclAsKSkRGzZsEABERkaGcd2ff/5ZABAnT55sd/t1dXWipKTE+MrOznb7Qauz188//2zz+1ldXS0WL14s/P39HV6v2tpaq+vT3Nzs0DqoVCqxa9cuce3aNYce+Ml5tFqtWLJkSbt9+uijj7q7ilbhib73cna8EaL9mMPPS/clSZIwGAzdMmbV19fbFOtv/jHKkT+6eRPGG+/GaxzvfTniMeX6+vp2h/+Qy+VixYoVdu+Dui9JkoROpxM6nU5s27bN5s/68uXLbUoseeSjcEuXLsXs2bM7LBMREWG8FTQuLs64PDo6Gn5+frh06ZLZKZoBIDAwEIGBgY6rsAvExMSguroaffr0sXgdg8EAhULh1JneVq1ahe3bt1u1TkBAgMP2P2zYMOTk5HCATy+jUCjw9ttv4+2338bVq1dx7NgxAMDgwYMRFxfHwdHJZZwdbwDvjDnkXN15EoivvvrKpvUkSTL5/8cff4yCggLj5BxdcZBz6np4jeO9kpKSkJeXZ9c2pkyZAp1OZ/ZvkiThzTffRGRkJFatWmXXfqj7WblyJbZt2watVmvzNmQyGZ555hksW7YMxcXFyMvLw/fff2/x+h55NR4SEtLuVLq/NnbsWADAhQsX0K9fPwA3Rj1vbGy0fPRyLxISEgJfX1/87W9/w7BhwyCEwMCBA80GEI1GA5VK5fQ67d6926rE0urVq6HX6x2y7+DgYOTm5jr85PzXibjueOIvhEBpaanxO6hWq526v+DgYEyfPt2p+yBqD+MNkWu99NJLDttWXl6e8ft46tQp47+JPBVjjveyd+ZwIQTOnj0LAMbp6gcPHozq6mpUV1cbyz333HNYtmyZS67jqGvQ6XR48803bV4/ODgYAFBRUQGlUgmdTodp06ZZ/UOQTDjzdhYXmDFjBoqLi/H+++/D398fK1euxNWrV5GVlWXx9IClpaXo37+/k2vqPC3Jj4yMDEyYMAGXL192adCx5iMkl8sddgdVYWGhyS859pAkyTjYYWlpKbRaLSIiIhASEgKFQtFtEkxCCAwYMAClpaXGNufn5yM+Pt7NNfNsLceQkpISXth0YY6INwA/L87W3X8c8GR6vR4BAQHQaDQO33ZwcDAOHz6MpKQkp/e7wWBw2x1SPH50H7zG8Tz2XMM0NjYiJCQEkiTh5ZdfBgA888wzqKqqwsCBA03uyoyPj0dBQYHd9aXu4fz583ZdE7fc5dSS8BRCwN/fH01NTcYylsQcj7xjyRq7d+/G008/jalTp8LHxwe/+93v8MEHH1h1ku+oO2jcpeUgd/fdd+O5557D7t27Xbr/0tLSTsu01NGReUwfHx+L9m0JrVaL8+fPAwBOnjyJ5uZmDB06FMOHD0dQUJBVnydv1tTUZHxPW/rqiSeewJ49e9xZLY/XMuuKtx9LqGOOiDdA6+eEs/U4hhDCJJEghDCeoMvlciaXPEhjY6Ndt+l3pK6uDu+88w5eeuklpz0e3xIXtVotfH19nbKPzjDedB+8xvE89lx31NbWQggBX19f3H777QCA6upq49Alv064X7x40WHXONT1tTwSbguFQoGKioo2y2+O1ZYcS7z+jiVHOHXqFJKTk91dDSLyctnZ2Rg9erS7q0EejjGHiOzFeEOWYLwhIkewJOYwsQSgubkZZ86cQWhoqEsGgb58+TKSk5ORnZ2NyMhIp+/PVdgu79NV2+bqdun1elRVVWHo0KF8Jp46xZjjGGyXd2G7HIPxhqzBeOMYbJf36apt8+SY4/WPwjmCSqVyy68+kZGRXfL5eLbL+3TVtrmyXTExMS7ZD3k/xhzHYru8C9tlP8YbshTjjWOxXd6nq7bNE2NO9xg4hoiIiIiIiIiIHI6JJSIiIiIiIiIisgkTS24QGBiINWvWIDAw0N1VcSi2y/t01bZ11XYR2aKrfh/YLu/CdhF1fV31+8B2eZ+u2jZPbhcH7yYiIiIiIiIiIpvwjiUiIiIiIiIiIrIJE0tERERERERERGQTJpaIiIiIiIiIiMgmTCwREREREREREZFNmFgiIiIiIiIiIiKbMLFEREREREREREQ2YWLJRWQyWZvX3r17O1ynpqYGc+fORWBgIHr16oXHH38cDQ0NLqpx5/Ly8jBnzhz0798ffn5+SEhIQFpaWqfrxcTEtHkvXn/9dRfUuH3btm1DTEwMVCoVUlNTcerUqQ7Lf/bZZ4iLi4NKpcLQoUPx73//20U1tdxrr72G0aNHo2fPnggLC8N9992HCxcudLhOenp6m75RqVQuqrFl1q5d26aOcXFxHa7jDf1F5EiMOa0Yc5yP8aaVp/cVkaMx3rRivHENxpxWntRfTCy50IcffojLly8bXzNnzuyw/Ny5c5Gfn4+MjAzs378fR48exeLFi11TWQvk5OQgLCwMu3fvxtmzZ/Hiiy/i+eefx7vvvtvpuhs3bjR5L5YtW+aCGpv3ySefYOXKlVizZg2+//57DBs2DFOmTEF1dbXZ8idOnMCcOXPw2GOP4fTp05g5cyb+8Ic/oLCw0MU179jRo0exZMkSnDx5EhkZGdBoNJg8eTKampo6XK93794mfVNcXOyiGltu+PDhJnU8duxYu2W9pb+IHI0xpxVjjnMx3tzgDX1F5AyMN60Yb5yPMecGj+svQS4BQOzfv9/i8gUFBQKA+O6774zLDh48KORyuSgvL3dGFR3iySefFL///e87LBMdHS3S0tJcVKPOJScni6VLlxr/bzAYRFRUlPjLX/5itvysWbPE9OnTTZalpKSIJUuWOLWe9qqsrBQAxPHjx9sts2vXLtGnTx8X1sp6a9asEaNGjbK4vLf2F5E9GHNaMea4HuNNK0/vKyJ7Md60YrxxD8acVu7sL96x5EKLFi1CaGgoUlJS8Pe//73DspmZmejTpw9GjRplXDZp0iTIZDJkZ2c7u6o2q6urQ+/evTstt2HDBoSEhGDEiBHYsmUL9Hq9C2rXllarRU5ODiZPnmxcJpfLMWnSJGRmZppdJzMz06Q8AEyZMqXd8p6irq4OADrtn7q6OgwYMAD9+/fHzJkzUVBQ4IrqWaWwsBCRkZEYNGgQHnnkEZSWlrZb1lv7i8hejDmtGHNci/Gmlaf3FZEjMN60YrxxPcacVu7sLx+37LUbWr9+Pe688074+fnhyy+/xBNPPIGGhgY8+eSTZsuXl5cjLCzMZJmPjw969+6N8vJyV1TZapmZmfj00087fbbzqaeewsiRI9G7d28cP34cL774IioqKrBp0yYX1bRVdXU1DAYDwsPDTZaHh4fjv//9r9l1ysvLzZb31H4BACEEVqxYgQkTJnT4rO6QIUOwY8cODBs2DHV1ddi8eTPGjRuH/Px8REVFubDG7UtJSUF6ejqGDBmCy5cvY926dbj99ttx5swZ+Pv7tynvjf1FZC/GnFaMOa7FeOM9fUXkCIw3rRhvXI8xx4P6yy33SXURa9asEQA6fJWUlJhd95VXXhExMTHtbnvDhg0iPj6+zfLQ0FDx/vvvO6wN5tjSrrNnz4rQ0FCxceNGq/e3Y8cOoVAohFardVQTLFZWViYAiKysLJPlq1atEmPHjjW7jkKhEJ988onJsm3btomoqCin1dNeTz75pIiJiRFlZWVWrafVasXgwYPF2rVrnVQz+9XW1orAwECRnp5u9u/e2F9E5jDmtGLM8dxjGOON9/QVUXsYb1ox3nj2MYwxx3P6i3cs2WHp0qWYPXt2h2UiIiLMLk9JScGrr74KvV4PH5+23RAREYHKykqTZXq9HjU1Ne1u01GsbVdBQQHuvPNOLFy4EC+88ILV+0tJSYFOp8OlS5cwePBgq9e3R0hICHr06IGKigqT5RUVFe2+zxEREVaVd7dly5bh888/xzfffGN1Rl6hUGDEiBHt/rLhCYKDgxEbG9tuHb2tv4jaw5hzA2OO5x7DGG+8p6+IOsJ4cwPjjWcfwxhzPKu/mFiyQ0hICEJCQmxaNzc3FyEhIWYPuAAwZswYXLlyBd9//z1GjhwJADh8+DCEEEhOTra5zpawpl35+fm48847MX/+fLz66qs27S83Nxc9evRAaGioTevbQ6lUYtSoUcjIyMCMGTMAAJIk4T//+Q+WL19udp0xY8YgIyPDZJaHjIwMjBkzxhVVtpgQAsuWLcO+fftw5MgRDBw40OptGAwGnDlzBvfcc48TaugY169fx8WLFxEZGWn2797SX0SdYcxhzGnhaccwxpsbvKGviCzBeMN408ITj2GMOTd4XH+55T6pbubzzz8X27dvF2fOnBEXLlwQ77zzjvDz8xPr1683lsnKyhJDhgwRpaWlxmVTp04VI0aMEFlZWeLYsWPilltuEQ8//LA7mmDWmTNnRGhoqHj44YfF5cuXja/KykpjmZvbdeLECfHmm2+K3NxccfHiRbF7924RGhoqFixY4K5miL179wpfX1+Rnp4uCgoKxMKFC0WvXr1EVVWVEEKIRx55RKxevdpY/vjx48LHx0ds3rxZFBYWijVr1gilUikKCgrc1QSzFi9eLIKCgsSRI0dM+qexsdFY5ua2rVu3Tnz55Zfi4sWLIicnR8yePVuo1Wpx7tw5dzTBrGeeeUYcOXJEFBUViePHj4tJkyaJ0NBQUV1dLYTw3v4ichTGHMYcV2O8ucEb+orIkRhvGG/cgTHnBk/rLyaWXODgwYMiKSlJBAQECH9/fzF8+HDx/vvvC0mSjGW+/vprAUAUFRUZl125ckXMmTNHBAQEiMDAQLFgwQJx/fp1N7TAvPaeU46OjjaWubldOTk5IiUlRQQFBQm1Wi0SEhLE66+/LjQajXsa8T9paWliwIABQqlUiuTkZJPnkSdMmCDmz59vUv7TTz8VsbGxQqlUisTERHHgwAEX17hz5voGgNi1a5exzM1tW758ufF9CA8PF3fffbfIzc11feU78Mc//lFERkYKpVIp+vbtK2bPni0uXrxo/Lu39heRozDmMOa4GuNNK0/vKyJHYrxhvHEHxpxWntRfMiGEcOINUURERERERERE1EXJ3V0BIiIiIiIiIiLyTkwsERERERERERGRTZhYIiIiIiIiIiIimzCxRERERERERERENmFiiYiIiIiIiIiIbMLEEhERERERERER2YSJJSIiIiIiIiIisgkTS0REREREREREZBMmloiIiIiIiIiIyCZMLBERERERERERkU2YWCICUFhYiL59+6KxsdHp+3r44YexdetWp++HiIg8E2MOERG5AuMNuYpMCCHcXQkid7v33nsxduxYrFq1yun7OnfuHMaNG4eioiIEBgY6fX9ERORZGHOIiMgVGG/IVXjHEnV7ly5dwoEDBzBv3jyX7C8uLg6xsbHYs2ePS/ZHRESegzGHiIhcgfGGXImJJepyPvzwQ/j7+6OyshIAIEkS7r//fowdOxZNTU1tyn/66acYOXIkwsPDTZYfOXIEarUaer3euCw3NxdyuRzXrl3DHXfcgeXLl2Pp0qUICgpCZGQkPvroI9TW1uLBBx9EQEAAEhMTkZWV1Waf06dPxyeffOLglhMRkasx5hARkSsw3pAnY2KJupy5c+ciJiYGmzdvBgA8++yzOHv2LPbv3w+1Wt2m/LfffovbbrutzfK8vDwkJibCx8fHuOz06dMYNGgQevbsCQDYuXMn+vXrh++++w6PPvooHnvsMcydOxf33nsvTp8+jYSEBMybNw83P3F622234eTJk9DpdI5sOhERuRhjDhERuQLjDXkyn86LEHkXuVyO9evXY/78+fDz88NHH32EzMxM9OnTx2z54uJipKamtlmel5eHpKQkk2W5ubkmy0aNGoXVq1cDANasWYNNmzYhNjYWDz30EADg+eefx+jRo1FWVoZ+/foZ14uMjERzczMqKyvRt29fO1tMRETuwphDRESuwHhDnox3LFGXdN999yE6OhqbNm3CF198gUGDBrVbtqmpCSqVqs3ymw+wwI1s/vDhw43/HzZsmPHfvr6+CAoKQmJionFZy62nLbestmj5VcEVMzQQEZFzMeYQEZErMN6Qp2JiibqkL774Aj/99BMMBgPCwsI6LBsSEoLa2lqTZXq9HgUFBSYHXYPB0CbDr1AoTNaTyWQmy2QyGYAbz0D/Wk1NDQAgNDTU4jYREZFnYswhIiJXYLwhT8XEEnU5p06dwkMPPYTdu3cjNTUV69at67D8iBEjUFBQYLLs3Llz0Gg0iIqKMi7LyMhAfX29STbfVgUFBYiJiUFwcLDd2yIiIvdhzCEiIldgvCFPxsQSdSk//fQTpk+fjnXr1uH+++/H2rVr8cEHH+D8+fPtrjN58mScOHHCJOOel5cHAEhLS8OFCxewf/9+LFq0CHK53OysC9Y6duwYJk+ebPd2iIjIfRhziIjIFRhvyNMxsURdRk1NDe666y7MmjULK1euBABMnDgRv/3tb/F///d/7a43bdo0ADem3myRm5uLadOm4dy5c7j11luxfv16rFu3Dn5+fti2bZtd9dRqtdi3bx8WLFhg13aIiMh9GHOIiMgVGG/IG8jEzXMEEnVDaWlpOHToEPbv3w/gRoZ/7NixWLt2rcP3tX37dnz22Wc4dOiQw7dNRESejzGHiIhcgfGGXIV3LBEBWLRoEVJTU40zGOTl5WHo0KFO2VePHj2QlpbmlG0TEZHnY8whIiJXYLwhV+EdS0Q3KS8vR2RkJM6fP4/Y2Fh3V4eIiLowxhwiInIFxhtyJiaWiIiIiIiIiIjIJnwUjoiIiIiIiIiIbMLEEhERERERERER2YSJJSIiIiIiIiIisgkTS0REREREREREZBMmloiIiIiIiIiIyCZMLBERERERERERkU2YWCIiIiIiIiIiIpswsURERERERERERDZhYomIiIiIiIiIiGzCxBIREREREREREdmEiSUiIiIiIiIiIrLJ/wNYluM2TEZzrwAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAABAAAAAQACAYAAAB/HSuDAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAQ6wAAEOsBUJTofAABAABJREFUeJzs3XdclWUbwPHfOewtewiCExERcOBW3OaeWWaOTCtnWlqa5kgtw0xLTbOcOXKP3LkHbsGNigNRBNl7n/cPXo8RmorAQbi+nw+ft3M/9/Oc6+Hh9b7Pde6hUKlUKoQQQgghhBBCCFGiKTUdgBBCCCGEEEIIIQqfJACEEEIIIYQQQohSQBIAQgghhBBCCCFEKSAJACGEEEIIIYQQohSQBIAQQgghhBBCCFEKSAJACCGEEEIIIYQoBSQBIIQQQgghhBBClAKSABBCCCGEEEIIIUoBSQAIIYQQQgghhBClgCQAhBBCCCGEEEKIUkASAKLUUSgUL/xZtmyZpsPMt0OHDqFQKDh79myBXVOhUDBr1qwCu96LzJkzh507dxbZ+72q2NhYJk+ezNWrVzUdihBCCPFKJk+enKvPY2lpSaNGjfLV7t65c4cWLVpgYmKCQqEgICAAX19fOnToUOBxHzp0iBkzZuQpnzx5MsbGxgX+fkKUVNqaDkCIoubv75/rdf369Rk+fDi9e/dWl1WsWLGowyowNWvWxN/fHzc3twK7pr+/P87OzgV2vReZM2cOHTp0oF27dkX2nq8iNjaWKVOmUL16dapVq6bpcIQQQohXYmBgwIEDBwB4+PAhM2bMoGPHjhw9epQGDRq89HUmTpzI7du32bBhA2ZmZlSpUqWwQubQoUPMmjWL8ePH5yr/8MMPad++faG9rxAljSQARKlTr169PGXlypV7ZvkTKSkpGBgYFGZYBcbU1PQ/7yU/Cvp6Re1Nen5PZGVlkZ2djY6OTq5ylUpFeno6enp6+brum/i7EEIIUbCUSmWutr1u3bo4OTmxfPnyV0oAXL9+ncaNG9OmTZvCCPOlODo64ujoqLH3F+JNI1MAhPiXJ0PJTp8+Tf369dHX12f+/PkAfPnll3h4eGBsbEzZsmV59913CQsLy3X+k6FvGzZswNXVFWNjY5o3b05wcHCuet999x2VKlVCX18fa2trWrZsyZ07dwC4e/cuCoWClStX8vHHH1OmTBlsbGyYPXs2AGvXrsXV1RVTU1O6detGbGys+rrPmgKwZMkS3N3dMTAwUA/1O3PmzEsff9YUgEWLFuHq6oqenh4uLi5MmzaN7Oxs9fFly5ahUCi4cOECb731FkZGRlSuXJkVK1b85+/fxcWFe/fuMX/+/DxTMlasWEGjRo2wsLDA3NwcX19fTp8+/dLP79ixY3h7e6Ovr0+NGjXYt28fXl5e9O/fP9c1/P39ad68OUZGRpiZmdG7d28iIiLUz6Z8+fIA9OzZUx3j3bt3n3tPsbGxDBkyBHt7e/T09KhVqxZ79+7NVefJ383y5cvVv9fAwED69+9P9erV2blzJ56enujp6bF9+3YANm3ahJeXF/r6+jg4ODB69GhSU1PV13zyt7Bjxw569OiBqakpPXv2/M/fvxBCiNKnbNmyWFtbExISoi57UVuoUCg4d+4cK1euRKFQ4OLi8tzrX7t2jc6dO2NmZoaRkRHt27fP0y/Kzs5m9uzZuLm5oaenh52dHT179iQuLo7JkyczZcoUkpKS1O2ur68v8OwpAPfu3aNHjx7q92vTpg2XLl3KVcfFxYVhw4Yxf/58nJ2dMTMzo0uXLjx+/Pg1fpNCFH8yAkCIZ0hPT6d3796MGjWKGTNmYGlpCUBERATjx4/HwcGBx48f88MPP9C0aVOuXr2KtvbT/zsFBATg5+fHd999R1ZWFqNHj6ZPnz7q6QcrVqxg4sSJTJ06lfr16xMXF8fRo0eJj4/PFcdXX31F9+7dWb9+PVu2bOGzzz7j8ePHHDp0iO+//574+HiGDx/O2LFj+fXXX595L0eOHGHgwIF8/vnntGvXjuTkZE6fPq1OGrzo+LP8/PPPjBgxguHDh9OhQwdOnDjB5MmTiY2NzZMoeO+99xg0aBCjR49m8eLF9O/fnzp16jx3isLmzZtp164djRo14rPPPgOeTsm4e/cuffv2pWLFiqSnp7NmzRqaNGnCxYsXcw07fNbzCwsLo23bttSsWZN169YRFxfHJ598QlxcHF5eXupz/f398fX1pV27dvz5558kJSUxYcIEOnfujL+/P/b29mzatIlu3boxY8YMmjVrBoC9vf0z7yc9PZ1WrVoRHh7O9OnTKVu2LH/88Qft27fn/PnzeHh4qOuePXuWu3fvMnXqVMzNzXFycgJyhmeOGDGCCRMmUK5cOcqVK8e2bdvo0aMH77zzDt999x3Xr19n/PjxhISEsGHDhlwxDB48mD59+rB582a0tLSe+1yFEEKUTomJiURHR6sT3C/TFvr7+9O3b18qV67MxIkTnzsy7fbt2zRo0IDq1auzbNkylEol06dPp0WLFgQFBanPGz58OIsWLWLUqFG0atWKhIQEduzYQWJiIh9++CGhoaGsXr1aPXXB1NT0me+XkJCAr68vSqWShQsXoq+vz/Tp09X9hSdtK8C2bdu4efMm8+fPJzIyklGjRjF8+HDWrl1bkL9eIYoXlRClHKDy8/NTv540aZIKUK1du/Y/z8vMzFSFhoaqANWePXvU5U2bNlUZGRmpIiIi1GVLly5VAar79++rVCqVaujQoaqaNWs+99p37txRAaq333471/vZ2tqqjIyMVJGRkeryzz77TFWmTBn164MHD6oA1ZkzZ1QqlUrl5+ensrCweO57vei4SpX7d5SZmamysrJSvfPOO7nqjBs3TqWrq6uO7ck9z58/X10nMTFRZWhoqPrmm2/+8/2cnZ1VQ4cO/c86WVlZqoyMDJWrq6tq3Lhx6vLnPb8xY8aozMzMVPHx8eqyo0ePqgBVv3791GVNmjRRNWjQQJWdna0uu3LlikqhUKh27NihUqmePp/169f/Z4wqlUq1ZMkSlba2turKlSu5yuvWravq2bOn+nXTpk1VOjo6qpCQkFz1+vXrpwJUJ0+ezFXu7e2tql+/fq6yRYsWqQDVxYsXVSrV07+Fjz/++IVxCiGEKB0mTZqkMjIyUmVkZKgyMjJU9+7dU/Xq1Utlbm6uun79ukqlerm2UKVSqTw9PXO1oSpVTnvWvn179eu+ffuqKlSooEpJSVGXRUREqIyNjdV9hKCgIJVCoVDNmDHjhXG/qHzu3LkqhUKhunr1qrosKipKZWRkpBo9erS6zNnZWeXo6KhKTU3NdS0dHR1VVlbWc+MQ4k0nUwCEeI5nLSiza9cuGjRogJmZGdra2uo5Zzdu3MhVz8vLC2tra/XrJwvFhYaGAjkL9V24cIHRo0dz7NgxMjIynhlDq1at1P+tpaVFhQoV8PLyUo9IAKhSpQqxsbEkJiY+8xo1a9YkOjqa/v37s2/fPpKTk1/p+L9dv36dyMjIPEPJe/XqRXp6ep4h+a1bt1b/t5GREc7Ozurfw6u6du0aXbt2xdbWFi0tLXR0dAgKCsrz+4e8z+/MmTM0a9YMExMTddmT6QRPJCcnc/z4cXr27ElWVhaZmZlkZmZSpUoVnJycck2LeFl79+7Fw8ODKlWqqK+XmZlJq1at8lyvRo0aub6ZeMLS0pK6deuqXycmJhIQEECPHj1y1evVqxeQM9Xhn2RxJCGEEP+UlJSEjo4OOjo6ODs7s2HDBlauXImrq2uBt4V79+6lU6dOaGtrq69lbm6Ot7e3+loHDhxApVIxcODA1763o0ePUr169VwjDS0sLGjVqlWe9rFp06a5Ri5Uq1aNjIwM9VQHIUoiSQAI8QyGhoZ55pOdOXOGTp064eDgwMqVK/H39+fkyZMAueZdA5QpUybXa11d3Vz1+vfvz48//siePXto3Lgx1tbWjBw5kpSUlBde50XX/rfmzZuzcuVKrly5Qps2bbCysqJv375ER0e/1PF/i4mJAcDW1jZX+ZPX/z7vWfE+L9b/kpCQQOvWrbl37x6zZ8/m6NGjnDlzBk9PzzzXe9bzCwsLy5WUecLGxkb93zExMWRlZTFq1Ch1x+jJT0hICPfv33/luCMjI7lw4UKe602bNi3P9f79O31eeWxsLCqVKk+5mZkZenp6eZ7B864rhBCidDIwMODMmTOcOnWKP/74A3t7e/r27UtYWFiBt4WRkZHMmTMnz7WOHj2qvlZUVBTa2tq52uT8iomJeWa7Z2tr+1J9FHh+n0qIkkDWABDiGRQKRZ6yzZs3Y2Zmxrp161Aqc3Jn9+7dy9f1lUolI0eOZOTIkTx48IC1a9fy5ZdfYmVlxcSJE18r9mfp06cPffr0ITIykq1bt6ob9d9///2ljv/Tk2/M/50dDw8Pz3W8oPn7+xMaGspff/2Fp6enujwuLi7P6r/Pen729vbPXNjnn/dRpkwZFAoF48ePp0uXLnnqWllZvXLcFhYW1KhR45m/y397VtzPKn8S57+fQVxcHGlpaXmewfOuK4QQonRSKpXUrl0bAB8fH1xdXalbty5Tp05l1qxZBdoWWlhY0L59e4YMGZLn2JNReZaWlmRmZhIREfHaSQALCwuCgoLylIeHhxdaH0WIN4kkAIR4SSkpKejo6OT6MLVq1arXvm7ZsmX57LPPWL16NdeuXXvt6/0XKysrBg4cyM6dO5/5Xi86DuDq6oq1tTXr16+na9eu6vJ169ahq6uLj4/Pa8f5rFECT0ZHPMnOA5w4cYK7d+/i7u7+wmvWqVOHRYsWkZCQoO5wHD16NNe3AUZGRtSvX59r164xbdq0/4wPXu4bgpYtW7Jz504cHBxwcHB4Yf2XYWxsjJeXFxs2bGDUqFHq8nXr1gE5UxuEEEKIl1W7dm3effddli5dyqRJk16qLXxZLVu25PLly3h7ez93IdrmzZujUChYunQpX3zxxTPr6OrqkpaW9sL3a9SoERs2bCAoKAhXV1cgZ1TA33//zeDBg/N/I0KUEJIAEOIltWrVijlz5jB8+HC6du2Kv78/K1euzNe1PvroI8zNzalXrx7m5uYcP36cwMDAZ2bHX9ekSZOIiorC19cXGxsbLl26xO7duxk9evRLHf83LS0tJk6cyIgRI7CxsaFdu3acPHmSmTNn8umnn+ZanyC/3NzcOHDgAPv27cPc3Jzy5ctTr149jI2NGTp0KF9++SUPHjxg0qRJlC1b9qWuOWrUKBYsWED79u0ZM2YMsbGxTJkyBSsrK/WIDgA/Pz+aN29Or169eOeddzA3Nyc0NJR9+/YxYMAAfH19sbOzo0yZMqxZs4by5cujp6dHjRo1ciUnnujbty+LFi3C19eXzz//XL1mw4ULF0hPT+fbb7/N1+9o8uTJdOnSRT16IygoiPHjx9O9e/dcOwsIIYQQL2PixImsXbuWOXPmvFRb+LKmTJlCnTp1aNOmDYMHD8bW1pZHjx5x+PBhGjduzLvvvkuVKlX4+OOPmTBhAtHR0bRo0YLk5GR27NjB5MmTKVu2LG5ubmRmZjJ37lwaNGiAqamp+gP+Pw0YMIAff/yR9u3bM23aNPUuANra2nz66acF9wsT4g0lawAI8ZLatWvHzJkz2bp1K506deLIkSP89ddf+bpWgwYNOHbsGAMHDqRt27asWrWKH3/8sUAWv/m3OnXqcP36dYYMGULr1q358ccfGTNmDJMmTXqp488yfPhwfvnlF3bu3EmHDh34/fffmTx5Mt9//32BxDxjxgwcHR3p3r07derUYfv27dja2rJ+/XoiIiLo3Lkzc+bMYdGiRVSqVOmlrmlvb8+uXbtISEigR48efPvtt8ydOxdjY2PMzMzU9Z48m8TERAYMGEC7du2YOnUqhoaG6vdSKpUsXbqUO3fu0KJFC+rUqcPDhw+f+b56enocOHCADh06MH36dFq3bs2QIUM4e/bsa31T36lTJ9avX8+lS5fo3Lkz3333HYMHD+aPP/7I9zWFEEKUXq6urrzzzjv88ssvuLu7v7AtfFmVKlXi9OnTWFpaMmTIENq0acOXX35JUlISNWrUUNebN28eM2bMYPPmzXTo0IFPPvkk16i9jh07MmTIEL799lvq1q3LRx999Mz3MzEx4dChQ3h6ejJ48GDee+89zM3NOXLkyDMX2hWitFGoVCqVpoMQQghNuHnzJlWrVmXJkiX069dP0+EIIYQQQghRqCQBIIQoNcaNG0eNGjVwcHDg9u3bzJgxg5SUFK5fv55n1wAhhBBCCCFKGlkDQAhRaqSnp/PFF18QHh6OgYEBvr6++Pn5yYd/IYQQQghRKsgIACGEEEIIIYQQohSQRQCFEEIIIYQQQohSQBIAQgghhBBCCCFEKSAJACGEEEIIIYQQohSQRQBfUmpqKpcuXcLa2hptbfm1CSGE0JzMzEweP36Mh4cH+vr6mg6nVJJ+gRBCiOLiVfoF0mK9pEuXLuHj46PpMIQQQgi106dPU6dOHU2HUSpJv0AIIURx8zL9AkkAvCRra2sg55dqb2+v4WiEEEKUZmFhYfj4+KjbJlH0pF8ghBCiuHiVfoEkAF7Az88PPz8/srKyALC3t8fR0VHDUQkhhBDI0HMNkH6BEEKI4upl+gWyCOALjBkzhoiICAIDAzUdihBCCCE0TPoFQggh3mSSABBCCCGEEEIIIUoBSQAIIYQQQgghhBClgCQAhBBCCCGEEEKIUkASAEIIIYQQQgghRCkgCQAhhBBCCCGEEKIUkASAEEIIIYQQQghRCkgCQAghhBBCCCGEKAUkAVBMZaenEn5iFekxDzUdihBCCCFKmOjUaP66/ReZ2ZmaDkUIIUQR0tZ0ACK3mKR0Dl+9j8nxGdgl3yAh6BCV+v8KCoWmQxNCCCFECbE+aD2nHp3C2sCauvZ1NR2OEEKIIiIJgGJApVJx6UEcf18N5+KdMHrFLyHyzkV+OBVFQ5dwvmp8ACq10HSYQgghhCgBYlNjORN+BoBTYackASCEEKWIJAA0KC45g0M3Ith/LYKIhFT0slMZnrWCG8GXGLDkCukZmew6D16Vp9P+mwagY6DpkIUosXx9falduzazZs3SdCjiNchzFOLFDoUeIluVjYG2AZciL5GckYyhjqGmwxJCCFEEZA2AIqZSqbj8II45f99g6OrzrDkdQkpGFl3dzVhgvYngy4H0++0i6RlP5+T9svsKXFynwaiFEJp05coVunfvjouLCwqFgnnz5mk6JJEPW7dupU6dOpQpUwYjIyO8vLxYuXKlpsMSr8jPzw8bGxs8PT01HUq+ZGZncuj+Icz1zOlWuRtZqizOR5zXdFhCCCGKiCQAilhiWibf7brOydtRVLY1ZnjzyizoXpFeUb+wYddRev8aQGZWdq5z9lx6TPiJNZDwSENRCyGKQnp6+jPLk5OTqVChAt999x12dnZFHJV4Vc97jubm5owbNw5/f38uXrzIwIED+eCDD/j777+LOELxOsaMGUNERASBgYGaDiVfzjw6Q3x6PM3KNcPHzgclSk6HndZ0WEIIIYqIJACKmIm+Dh81rcAPb3sxqaM7DctqobNvAgs3HqL/74FkZ6vynJOZreKP4yFw5ncNRCxE6bR8+XJq1aqFsbEx9vb29O/fn5iYGABSUlIwMzNjy5Ytuc75448/sLKyUn8AvHz5Mm3btsXIyAh7e3s+/PBD4uLi1PV9fX0ZOXIkI0aMwNLSkq5duz4zljp16uDn58c777yDnp5e4dxwCVWcnmOTJk3o1q0bbm5uVKxYkeHDh+Ph4cHx48cL5+aFeIb9IfvRVmjTxLEJJromVLOqxtWoqySkJ2g6NCGEEEVA1gDQgMaVrXP+Izka9oxnzvqjjFpzNVedn3/+mbVr16o7hr/5RzK6zQkUYYFg/2YOOxSl13e7rhORkFqk72ljos+Xb1XN9/kZGRlMnz6dKlWqEBYWxogRIxg6dCirV6/GwMCAd999l2XLltGlSxf1OcuWLaN3797o6uoSGxtL8+bN+fjjj5k7dy6JiYmMGjWK/v37s3nzZvU5S5YsYfjw4fj7+7/O7RaJH8/9SGRKZJG+p5WBFaNqjcr3+cX1OapUKg4cOEBQUBCNGzfO9/0J8Spux93mdtxtGjo0xFTXFAAfOx8uR17mXPg5fJ18NRugEEKIQicJAE1JioQ945mx+ghfbQxSFysUChYvXswHH3zAw7SH6gTA9ZDHnL6bQN3Tv0LHn0CppanIhSgVPvzwQ/V/V6hQgR9++IE2bdqQnZ2NUqlk4MCBNGzYkMePH2Ntbc39+/c5ePAgfn5+AMybN486deowdepU9XV+/fVX3NzciIiIwMbGBoCqVasyY8aMor25UqS4Pce4uDjKli1LWloaWlpaLFy4kObNmxfwXYvSLD0zm4NBETSubIWhbu5u3oGQAwC0dG6pLqtpU5PliuWcCjslCQAhhCgFJAGgCQnhqHaPY+KKo0z/65a6WEtLixUrVtC7d28O3T/E/Qr30TXQJT0lZxjqkktK6pa/Bzf2QNV2GgpeiFf3Ot/Ea8rZs2eZPHkyFy9eJCYmhqysLNLT03n06BEODg7UqVMHV1dX/vjjD0aNGsXy5cvx8PDA29sbgMDAQPbt24exsXGeawcHB6s/ONauXbtI7+t1vM438ZpS3J6jiYkJAQEBJCYmsn//fj799FMqVqwoowBEgVl/7j7bAx8SHp9K3/ou6vK4tDhOhZ2iollFnE2d1eWGOoZ4WHkQ+DiQ2NRYyuiXKfqghRBCFBlZA6CoJUej2jWWz38/lOvDv46ODn/++Se9e/cmLi2ODTc2oGOog0tjF3WdNX+fJ1lhBBdWQprM1ROisCQlJdG2bVssLCxYvXo1Z8+eZdWqVUDuBd4GDhzI0qVLgZy55gMGDFAfS0xMpEuXLgQEBOT6uXnzJl5eXup6RkZGRXNTpVBxfI5KpZJKlSrh5eXFZ599Ro8ePfjuu+8K4G6FgJCoZHZcDANg/7UIEtOe7ih0OPQwWaqsXN/+P1HXvi4qVJwJP1NksQohhNAMSQAUsWxdU4auucnsPXfUZXp6emzevJnu3bsDsP7GepIzk6lpU5NKrSup6yUkJLAxwiXnw3/g2qIOXYhS4/r160RFRTFz5kwaNWqEq6sr4eHheer16dOHoKAg5s6dy71793jvvffUx7y9vbly5Qrly5enUqVKuX4MDAyK8nZKrTfhOapUKtLS0l77OkKoVCoWH72NSgWtqtmRlpnF/ms5f+9Ptv4ro1eGWra18pzrZeOFrlJXdgMQQohSQBIARSgrK4uBgwbxy5ani0QZGhqyY8cO2rdvD8C1qGuceHiCahbV+KjGR5T3Ko+pQxl1/SU7T4NlRbi2HWJDivoWhCgVypUrh66uLj///DN37txh48aN6jnh/2RlZUXnzp0ZO3YsHTt2xMrKSn1s6NChhIeH895773H27FmCg4PZuXMngwcPfuV40tPT1d88p6en8+DBAwICAggJkX8D/ktxe47fffcde/fu5fbt21y/fp0ff/yRFStW5Eo4CJFf+69FcDMigVbVbOlb3xlzQ112X35ERlY258PPE5sWi6+TL9rKvLM/9bT08LTxJDguuMgX+hRCCFG0JAFQhI4cOcKyZcvUr01MTNi9ezctWrQAICM7g5VXV6Kl0KJPtT7oaOnQxLEJlVpXUJ9z6NAhgm3eAlU2nPmtqG9BiFLB2tqaZcuWsWbNGtzc3Jg7dy7ff//9M+sOGDCA9PT0XMPGAcqWLcuxY8dITU2lZcuWeHh4MGbMGKytrV85nocPH+Lt7Y23tzdhYWF89913eHt78/XXX+fr/kqL4vYcU1JSGDZsGO7u7jRo0ID169fzxx9/5HlPIV5VbHI6q0+HYG6oyzs+TuhoKWlb3Y6Y5HSO3Yrk75C/0VJo0dSx6XOv4WPnA8CZRzINQAghSjKFSqXKu/G8yCM0NBQnJyfu37+Po6Njvq+zYMEChg4dSpkyZdizZw8+Pj7qY9uDt7P51mY6VexEl0pdAAhPCmfk1pH82Wcd/P9RTZgwgW9amsCdI9ByMji+OYuICVHSLFmyhAkTJhASEoK2tqyr+qZ6055jQbVJIv+K0zP4ef9NjgdHMrJFFepXtAQgKS2ToavPo28QQ3qZP6nvUJ9BNQY99xoZWRmMPDgSG0MbJjeYXESRCyGEKAiv0ibJCIAiNmTIEObPn8+hQ4dyffh/nPyYv27/hY2hDe3Lt1eX2xrZUqdKHWy87dVly5YtI8urL2jpwulfISsTIUTRSk5O5tatW/j5+fHJJ5+8ER8aRV7yHMWb7mJoLMeDI/FyMqdeBQt1uZGeNs2r2nAz6QSJaZm0cG7xn9fR0dKhpm1NQhJCeJT0qLDDFkIIoSGSANCAIUOG4OnpqX6tUqn449ofZGRn8L7b++ho6eSq7+vkS+XWldWvQ0ND+ftkIHj0gPiHcH17kcUuhMjx/fff4+bmRrly5fj88881HY7IJ3mO4k2WlpnF78fuoKutxQcNXVAoFLmON65iTLLyOukpVlQwq/Ccqzz1ZBrA6UeyGKAQQpRUkgAoBs6Fn+NS5CV87Hxwt3LPc9zL2gvvZjXQNtZTly1ZsgSqdwcjKwhYDfFhRRmyEKXe5MmTycjIYM+ePbKq/xtMnqN4k2258IDw+FS61yyLjal+nuNX4k5iYqAkM8Gd248TX3i9apbVMNI24lTYKWSGqBBClEySANCwlMwUVl9fjb6WPu+4vvPMOlpKLVpUaI59Y2d12ZYtW4iKS4Q6gyAjBbYNg+s71OsECCGEEKLkCo1JZntgGE7mhrT3sM9zPCs7i4MhB3EuY4mRypVNp29z/vx5/vjjD8aNG0fnzp3x9fVl69at6nO0ldrUtqtNWFIYoYmhRXk7QgghiohMdtSwrbe2EpsWy3tV36OMfpnn1mvi2ISKrapwf9cNIGdbsNWrVzN8+HBoOQVO/AQnf4G7x6HhCDCxK6I7EEIIIURRUqlU/Hb0DpnZ2QxqUgFtLWWuYwEBAWw9upW9x/aiH6lP8LVtrAsPfeaXBMeOHePAgQM0adIEyJkGcDj0MKfDTuNk4lRk9ySEEKJoyAiAF/Dz88PGxibXnP2CEhIfwr57+3A2daZZuWb/WddC34IWPs0wKm+uLluyZEnOfzjWgi4LoHIreHQRtg6V0QBCCCFECXXoxmOuP4qnRVVbqtiaqMsfPHhAo0aNqFmzJlNGTuHy+sucPXiWmEf3n9snyMrKomfPnjx48AAAVwtXTHVNOfVIpgEIIURJJAmAFxgzZgwREREEBgYW6HVVKhUrrq4AoG+1vigVL34Unau0wraxi/p1QEAAFy5cyHmhawQNR+aMBtA1zhkNsOcrSJCVfIUQQoiCUphfDLyMuJQMVp28h6m+Du/WLacuP378OLVq1eLEiRMvvEa5cuWoU6eO+nVERAQ9evQgLS0NpUJJHbs6RKZEcif+TqHcgxBCCM2RBICGHA49zO242zRzakZ5s/IvdU51q+q4+nqh0NFSl6lHATwhowGEEEKIQlNYXwy8rFWn7pGYlknf+i4Y6+XM5Fy0aBHNmjUjPDw8V13Hco60a9eOzz//nC++/YmWX/7G6qPXuXfvHidPnqRLly7quidPnuTTTz8FoK5dXQBOh50mPTObuOSMIrk3IYQQhU8SABoQnx7PhhsbMNM1o1vlbi99nkKhoFnl1ljUclCXrVq1itTU1NwVZTSAEK/M19dXtoETQhRrVx7GceTGYzzKmtGwkiVpaWl89NFHfPzxx2RkPP2Q7lzfmbG7xxJyN4QdO3bg5+fHtDFDqeTuxeE7iWRkZaNUKlm+fDlVqlRRn7dw4UKWLFlCxTIVsdC34OA9fz5bF8DwtRd4EJuiiVsWQghRwCQBoAHrgtaRnJlMr6q9MNQxfKVzu1dtgXXjp3v5xsTE5FrBN5c8owGGQcT11wldCKEBixcvpnHjxpibm2NhYUHr1q05e/aspsMSQhShtMwsfj96Bx0tJQMbVeDRo0c0b96cX3/9NVe9RgMa0WxiM7rV6IZCoVCXa2specvDntiUdI7digTA1NSUzZs3Y2xsrK43ZMgQzpw5g2GWK4EPH/Aw+Q4ZmdksOHiLrOxnjya8FXOLn87/xLqgdYVw50IIIQqSJACKWGxqLGfDz1LNopp6iN2rqGBlTaXqTdGzepo4yDMN4J90jcjwGcIZq54cuPKIjN1fQ2xIfkIXQhSy9PT0Z5YfOnSId999l4MHD3LixAnKli1Lq1atCAsLK+IIhRCastL/Hg/jUuhe05G71wKoXbt2rvn+RsZGdPqmE5V7VaaXWy/q2uftY7SoaoO+jhZ/BYapF/irVq0ay5YtU9dJS0ujTYcunA3QRUdLSeMasbzlYUfw40T+uvgw1/Vuxdzih7M/MOP0DAIeB7D37l4S0hMK5xcghBCiQEgCoIiV0S/D9IbT6V+9f67M/Kto4NAUq0bO6tf79u0jJOTph/qYmBh27tzJV199ha+vL2ZmZvh07E+L747T5YfDZO/+ChIjXvtehCjJli9fTq1atTA2Nsbe3p7+/fsTExMDQEpKCmZmZmzZsiXXOX/88QdWVlbqD/KXL1+mbdu2GBkZYW9vz4cffkhcXJy6vq+vLyNHjmTEiBFYWlrStWvXZ8ayatUqhgwZgpeXF1WrVuW3334jKyuLgwcPFs7Nv8F8fX359NNPGTZsGGZmZtjb27Nq1SpiYmLo2bMnxsbGuLu7c+rUKfU5R48epWHDhhgYGODs7MzYsWNJS0tTH/+vvwWAZcuWYWVlxY4dO6hSpQqmpqb06NEj17MW4nWcvB3F39fCcbM3JfLcbpo2bcrDh08/jLtUdKHz3M5Y17Hmw+of0tal7TOvY6SnTYuqNjyITebC/Vh1effu3fnyyy/Vr2Mfh3Fr5UJ8yjpzJ/EiPWo5YG9mwPqzodyPTuZmzE1mnZnFjNMzuBp1FR87H9qXb0822VyIuFBovwchhBCvT1vTAZRGlgaWr3V+ExcPNtX34sHWa6DK2VHg888/p0yZMhw/fpyrV68+99ydFyNYtvciH+hOgLe+B4MyrxWLECVVRkYG06dPp0qVKoSFhTFixAiGDh3K6tWrMTAw4N1332XZsmW5FtFatmwZvXv3RldXl9jYWJo3b87HH3/M3LlzSUxMZNSoUfTv35/Nmzerz1myZAnDhw/H39//pWNLTk4mIyMDCwuLgrzl/5SSksLNmzeL7P3+rXLlyhgYGLxU3SVLljB+/HjOnj3L0qVLGThwIM2bN6dPnz7MmDGD8ePH07dvX65fv87t27dp164dM2bMYPny5YSFhfHJJ5+QkZHBjz/+CPz338ITCQkJzJs3j3Xr1pGcnEzPnj357rvv+Pbbbwvl9yFKj4iEVH49chtDLQX3/5rH5F8X5jreuGVjKg6piJ6xHp94fYKn9X/vTvCWhz27Lj9ie+BDapbL2VpYpVJRu/sn2G7dT/i1MwDcDDhJ8BpbLHpacCfhJp/4VuSLbXsYtnsTFhYRKBVKfOx86FSxEw7GDiSmJ7Lrzi7OhZ+jiWOTwvllCCGEeG0KlWzy+lJCQ0NxcnLi/v37ODo6ajSWuJQM3l21mFM/TSX6UviLT/gXCzNjgr6pj5VLNWgzA3RfbR0CIV7ZvkmQ+Op/q6/F2BZaTXnp6r6+vtSuXZtZs2Y98/ihQ4do06YNKSkpKJVKzpw5Q8OGDXnw4AHW1tbcv38fFxcXzp49i7e3N9OmTcPf358dO3aor3H9+nXc3NwIDw/HxsYGX19fkpKSOHPmzCvd2tChQ9m3bx+XL19GV1f3lc7Nr4sXL2ps2zOAwMBAatSo8cJ6vr6+KBQK9eiItLQ0jIyMGDZsGHPmzAHg7Nmz1KlTh/v37zN58mT09PSYP3+++hq7d++me/fuJCYmPnOk1r//FpYtW8aAAQO4d+8e5crlbMs2fvx4Dhw4wMmTJwvg7vMqTm1SaVUUzyAzK5sp269y6dY97m+YwflTubf46zeiH8q2Sgx1Dfm05qdUMq/0Utedd+Amx25FMq2LB9bGesw/dIuLobGYK1P5a2p/Qu8/HVXoO96XDl07oFKpOHj3PFGJ6fjY1eXLxu/hYOyQ67qzzswiKCaIuc3mvvIaR0IIIfLvVdokmQLwBjIz0KFamdpYNazwn/X0TfRx9HGkVr+6VOvRRV0eHZfImH0pEHULDkyDLNneR4h/O3v2LB06dKBcuXKYmJjQrl070tPTefQoZzeNOnXq4Orqyh9//AHkDBP38PDA29sbyPnAum/fPoyNjdU/tWvXBiA4OFj9Pk/KXtb333/P2rVr2bRpU5F9+H/T/DNRoKenh5mZGe7u7uoyW1tbAPVWbr/99luu59StWzeSk5PVz/pFfwuQs5jakw//APb29kREyFQr8XrWnQ3l1JkzHPUblOvDv5GRIV/N+wplOyVlDMrwpc+XL/3hH6BDjZwP7iv87/LFxotcDI2laRUbfuzXhK1bNqOvr6+ue/zH4xw7d4xr0ddoX6kJNQ0+IepBY9JSzfJct7ZdbbJUWQREBOT/poUQQhQqmQLwhvJ0tOW8Zwuiq94i8vpjACpVqkSNOjVQuajABaycrahu3oQzl51BpUv09RAeXT4PwLLtx+jfZjhNH12EI37Q9EtQSj5IFJJX+Ca+OEhKSqJt27a0a9eO1atXY21tzdWrV+nWrVuuhfoGDhzIkiVLGDVqFMuXL2fYsGHqY4mJiXTp0oUZM2bkuX7ZsmXV/21kZPTScc2aNYsZM2bw999/U7169XzeXcmno6OT67VCochV9uRb/ezsbBITExk6dChDhgzJcx1ra+uX/lt41ntmZ2cX5G2JUuZiaCw/Lfqdc6tmkpn+dE2KCtaGDBnuxhWzg9imOvGZ50isTF5tBIKLlREeZc249CAOPW0thvhWokkVawBq1qzJwoUL6d+/PwAZKRn4z/Bn1bpVNPVoyj3HVCZuucwvh24xvasHOlpP+w7eNt6svLqSs+FnaVC2wev/EoQQQhQ4SQC8oTzKmmF2qRY+XzfHR9eNHjV7cCT+CGcenUGBggYODahs2JzFhyLQVioY+1ZV3E1m81WflmRnZALwyfy/CfixF7r3TsDJ+VB/GORzYUIhSpLr168TFRXFzJkzsbe3B3jmgnt9+vThiy++YO7cudy7d4/33ntPfczb25utW7dSvnx5tLS0Xjum77//nunTp7Nnz55XHjVQECpXrkxgYGCRv+8/378weHt7c+XKFSpVeva3p4GBgS/1tyBEQYqMT6bPoKFc2r06V3nL+p50/Lo9AfFnKJ+WxsiYeEx3fwVlnMGlEZRvAmZln3PV3N6v58L2iw/p4l2WsmVyr6/Rr18/zpw5o54aEx4STst6LTEwMMDT0xNTxyrcNHBgVnIoo3u1RE9PDwAzPTOqmFfhcuRlUjJTMNB+uXU7hBBCFB1JALyhqtqZYKSwB6UDoSahzLk5hyxVFtUtq9PTtSfhUUbM+fsmetpKxrVzo5KNMRZt67KqfX8ub/kNgGvXrjHrjJLxtWvAjT2gbwY1+2r4zoTQvHLlyqGrq8vPP//MoEGDOH/+PH5+fnnqWVlZ0blzZ8aOHUvHjh2xsrJSHxs6dCi//vor7733Hp9//jnm5uYEBQWxZcuWPPt2v8jMmTP5+uuvWb16NS4uLuqh50+GrBcFAwODl5qD/6YZO3Ys9evXZ+TIkXzwwQcYGBhw+fJl/P398fPze+m/BSEKSmRkJHVbduR2YO71I95+vxXenzQnIP4G7hXaMNTjI/Qjb8CdIxByEgJW5fxYlIdyDUDHALLSn/5kPvnvNMhMp1xWOkP1TEDvQyDvB/XZs2dz4cKFXFsNpqSk/H9di5zYzq6ESR/qUL16dby9vWnWrBleDbwIigni4uOLz9yKUAghhGbJmO83lL6OFpVsjFEleZCRnYmDsQOf1fqM0bVHcz/CgB//voGBrhYTO1Sjkk3OBwRbU336DR6Jsb2d+jrfTJ/BbZf3wLIiXFwHV7Zo6I6EKD6sra1ZtmwZa9aswc3Njblz5/L9998/s+6AAQNIT09nwIABucrLli3LsWPHSE1NpWXLlnh4eDBmzBisra1fOZ5ffvmF9PR0evTogb29vfrneQsWipfn5eXFwYMHuXLlCg0aNKB27dpMmzZNvYDOq/wtCPE6VCoVx84co2oNj1wf/rV0FDT5rD5G7zlyI/4Gde3qMqLmCPT1jKFsTWj0KfT6A1pOhorNIOFRTiLgzG9wfgUEroXLm+D6X3BzL9w+DCH+EBYAtw/B4ZmQnZUnHl1dXTZu3Ejbts/eUvCJjIwMLly4wJIlS3j//fc5vPwwAOfCzxXcL0cIIUSBkV0AXlJxXHF547lQ1p0L4ePmljStWBmlQsnhG49ZeCgYMwMdvmrvhpNF7lV4gx8nMmjmCg7+MFRd1rZtW3ZuXI1i9xcQ/xAajYJKLYr6doR4Iy1ZsoQJEyYQEhKCtrYMqhJFozi2SaVNQT0DlUrF7HOz+Xv73+yb+TdZaZnqY6ZW+nz8w2AaNmxBOZNyOJk4vXgr4cx0iAwClQq09UBL9+mP9pP/1stZ9+fEzzkjAKt1Bp9Bz71kdHQ0AQEBnD9/nvPnz3PhwgWCgoJ4VhfS3Nyc4RuHE54Zzk/Nf0JXSxYrFUKIwvYqbZL0Vt9gHo5mrD+nICLGAKVCyb6r4fx+7DaWxnpMaO+GvVneIX0VrY1p5utLsH9zQk4cAHK2vNqw4296vjUNdn4OJ34Ciwo5wwiFEM+UnJzMw4cP8fPz45NPPpEP/0KIfMnOzmbLT1s4tvJYrvLGni5s2HkEGwenV7ugti7Yebxc3bofQ8xduLoVrCpDBd9nVrOwsKB58+Y0b95cXZaYmMi58xeYtmInNwLPEnL2bwBiYmKIPh5Nep10LkVeopZtrVeLXwghRKGSKQBvsApWRhjoaHHpQRw7L4Xx+7Hb2JjoM6ljtWd++H+is5cDNbt/jp7J09EBI0eOJD5bH3zH5wwFPPoDZGU+9xpClHbff/89bm5ulCtXjs8//1zT4Qgh3kCxsbF06tQpz4f/4b1asf900Kt/+H9VWjo57b6+GRz/CaLvvPSpxsbGNG3SmCXfT6TR4G+wdHq6kOauFbtQZas4++hsYUQthBDiNUgC4A2mraXEzd6UWxGJrPC/i4OZAZM7uWNjov+f53mUNaNKubJ4dX+6ZVlYWBgTJ04Em6rg0TPnG4GAVYV8B0K8uSZPnkxGRgZ79uzBwEBWuhZCvLro6Gj8/f3Vr3W1FPz+7Wf8tHYvOrpFNHTeyBJ8x0F2JhyYBmkJr3S6k4Uhb9dxokKzt9VlwTeDybiaQcDjADKyMgo6YiGEEK9BEgBvOI+yZgA4mRsyqaM7FkYv7jAoFAo6eTngXLcTzh5V1eXz5s3j3Llz4PUemLvApfUQcb2wQhdCCCFKtQoVKrDs98UoFWBjqsfejcv54EsNLO5pVx3qfAiJ4XDED7KzX+n0jjUcaN2xO3omZdRlVzZfIS0rjStRVwo4WCGEEK9DEgBvOF9XG3rXdebrjtUwM9R56fPqlrfA2tSAmu9MQqmV82eQnZ3NRx99RBYKaPwZKLXg2GzISC2s8IUQQohSrVPX7sydOZlte/6maef3NReIW8ecXQQenIeAP17pVKVSwVcd3GnYoZe6LOB4ADF3YzgbLtMAhBCiOJEEwBvOQFeLTp4OmOi//Id/yJk+0KGGPbpWzrzVp4+6/Ny5c/zyyy85CwB6v5+zK8C5ZQUctRBCCCGeGDZmEnXrNdJsEAoF1B+WswjwxXVwz//F50DOlIGANRhs6sfKdkq0dZ72R25vu0NARACZ2bKmkBBCFBeSACjFfF1tMNbTxtH3I6wcrNTl48eP5+HDh+DeDayr5uwd/PCCBiMVQgghRKHT1oNmX4GeSc4IwNj7z6+bEgvnlsOGD3LWDEpPxCEzhPd6dFZXubzvCmGPHnMt6lrhxy6EEOKlSAKgFNPX0aK1ux2x6Qo+nThTXZ6QkEDXrl2JjI7OmQqgrQfH5kBaouaCFUIIIUThM7GFpmMhIyVnUcD05NzHk6Ph9OKcD/6X1oOBOTT8FJpPBODTzjXVVbMzMjmz8TI7bx4vwhsQQgjxXyQBUMq1cbdDR0tJgnVtGr/VWF1++vRpGjZsyN3oNKg9EJKj4PQiDUYqhBBCiCLh4A21+kP8g5yRACoVJD6Gk7/kfPC/uhWMbaHJ59BlIVRuCWVrga4xXnqh+Pr6qi8VfuAOWy4f4fitCI3djhBCiKckAVDKmRno4Otqw92oJCZPX4yVy9OpADdu3KB+/foEpjrkdAaCD8K9ExqMVgghhBBFonp3cGkEISdh95ew6UO4vgPKlINm46HLAqjgC8r/dyW1tKFcPYi9x6eD3lNfJj0uhcizt/j+4EF2XAxDpVJp5n6EEEIAkgAQQIca9ihQ4P8wizMnzuBSw0V97NGjRzRp2pQDGTVB1whOzIOUGM0FK4QQQmiQn58fNjY2eHp6ajqUwqVQQMOROR/4w6+ARUVoMQk6zgXnBjnH/80lZyRhB1cDKlasqC6OOhCMlsFtVp68ywr/e2RnSxJACCE0RRIAAltTfepWsODSgzhUOtZc8b9Cw9YN1cfj4+Np27UXf0a6Qlo8nPg5ZzigEEIIUcqMGTOGiIgIAgMDNR1K4dMxgLbfQfvZ0P4HcKrz7A/+T9h7gq4xWvePM2LECHVxTHA0RJylso0Ruy6HsfTE3cKPXQghxDNJAkAA0MnTAYDtgQ8xNDTk0I5D9BnwdHvAjIwM3hn5DXPPKuD+abi1X1OhCiGEEKKo6JuCdZX//uD/hJY2ONeH2BAGdGmBqamp+tC5jWfp1VCHqnam7Lv6iMD7sYUXsxBCiOeSBIAAoIK1MdUdzPAPjiIiPhVtbW1W/L6CSZMn5ar36fy/GLPxNtknF0KiLOgjhBBCiH/4/zQAk6gAPvzwQ3VxiH8Ie8/vYohvRfS0tVh0JJiktExNRSmEEKWWJACEWicvB1So2Bb4EJVKhUKhYPKkyfz6668olU//VGb9dY13fvEn/cD3kJ2lwYiFEEIIUazY1QA9E7h7jOHDhz/tP6jgj8V/YG2ix3t1yxGdlM4K/3uajVUIIUohSQAINY+yZpS3MuLva+F8vfUKp+9Eo1KpGDRoEJs3b0ZfX19dd73/Q3zHLyXZf4kGIxZCCCFEsaKlDeXqQ9x9XMwUdO3aVX3o0s5LBIYE0qqaLR5lzTh8I4Jz92RhYSGEKEqSABBqCoWCz1q74utqw53IJGbvC2L0ukD2XwunbbsO7N+/HwsLC3V9/yvRjJg0DR6c02DUQgghhChWXBrl/O/do4waNUpdnJmSyY8Lf0ShUDC4SUUMdLRYfOQ2iTIVQAghiowkAEQuVsZ6fNy0Ij+/601HTwdik9NZfPQ2w9ecJ8LAmT0HDlGuXDl1/aUHQ7i25mtIitRg1EIIIYQoNuw91dMAGtSvT+3atdWHti7bSmZmJtYmerxf35nYlHSWHb+jwWCFEKJ0kQSAeCZzI13eq+vM/Pdq0ruuM0qFgrVnQph3PoWPpz9dEyA7Gz744xQcnglZksEXQgghSj2lFjg3gLhQFLH3co0CiHsUx+9rfwegmasNnk5lOHYrktN3ojUVrRBClCqSABD/yVBXm06eDvz0rjcfNa2IpZEegcmmVGjUSV3nZGAUGw4eggsrNBeoEEIIIYqP/+8GwN1j9OjRAwcHB/WhOXPmADlTDwc3roChrja/Hb1NfGqGBgIVQojSRRIA4qXoaClp5mrDrJ41GNOmKk3fHYqOvqH6+Ih1QWRe3AD3T2swSiGEEEIUC3YeoGcKd4+iq6PDsGHD1Ieun7vOcf/jAFga69G/gQvxqRksOSZTAYQQorBJAkC8EoVCQS1nc3o18cDtrb7q8rCQBMYfD4GjsyHxsQYjFEIIIYTGPZkGEP8QYu4yePBgDAwM1IcHDBpAeno6AI0rW1HL2ZyTt6PwD47SVMRCCFEqSAJA5EvDSpa4t34XM+unQ/rmbQrmblwUHP5O1gMQQgghSrvyT6YBHMXS0jLXKICbV24ydepUIOfLhUGNK2Csp83vx+4QlyxTAYQQorBIAkDki6GuNg1dHajW+WN1WUpsKh8eDEf1+DqcW6rB6IQQQgihcbbVQd8M7h4DlYopU6bg5uamPvztt99y6tQpAMoY6jKgYXkS0zL4/dhtVCqVpqIWQogSTRIAIt+aVrHGqXYLKlb3Vpcd2nKFjam6cHUrhJzUYHRCCCGE0Kh/TgOIvo2BgQHLly9HS0sLgOzsbPr27UtycjIADSpa4lPektN3ozl+S6YCCCFEYZAEgMg3dwdTbE0NcO86XF2WlZHN+HWXiNHRz1kPIOGRBiMUQgghhEa5NMr537vHAKhTpw7jxo1TH75x44b6tUKhYGCj8pjo67DsxB1iktKLPFwhhCjpJAEg8k2hUODrao2BY1VadeimLr95MJipcfqoMpLg0HeQJXP5hBBCiFLJ1iPXNACAiRMnUsm9krrKTz/9xIEDBwAwM9BhYKPyJKZlsvp0iEZCFkKIkkwSAOK1NKlijQIFtXoMQU9PT12+ev4+TpSrCVG34MTP6kZfCCGEEKWIUgnODSEhDKJvA6Crq8uaP9ag1HnaDR0wYABxcXEA1C1vgbuDGcduRhISlayRsIUQoqSSBIB4LVbGetRwNONumhFDho9Ul0dcjeCbg6eJtasGwQfg5AJJAgghhBCl0T92A3iitldteo7oqX4dEhLC6NGjgZwRhu/6lEOFSkYBCCFEASs1CYC//voLV1dXKleuzG+//abpcEoUX1cbVKio03kANjY26vLji0/wu4kVKtvqELQLTi+WJIAQQghR2ti450wDuHM0Vz9g5oSZ2Lrbql8vWbKE7du3A1DJxph6FSwJuB/DlYdxRR6yEEKUVKUiAZCZmcnnn3/OoUOHuHDhArNmzSIqSlaXLSi1Xcwx1tPm9INU9Z6+AInhiaxdup5T1d8C66pwbRucWyZJACGEEKI0USpzFgNMDIeoYHWxcxln3p/6Ptr62uqyQYMGERkZCUCvOk5oKRWsPhUi2wIKIUQBKRUJgNOnT+Ph4YG9vT3Gxsa0b9+evXv3ajqsEkNHS0mjSlaExaXQsH1Pqlevrj52ce1FFp5cSmSjEWBVGS5vhMA1GoxWCCGEEEXO5ck0gCO5it9u8DZ1BtVRvw4PD2fIkCGoVCrszQxoXtWW4MeJnLoTXZTRCiFEifVGJACOHDlCx44dcXBwQKFQ8Ndff+WpM3/+fFxcXNDX16devXqcOXNGfezhw4eULVtW/drR0ZEHDx4USeylRbOqOUP/jwXHMHv2bHV5elI6p1acYtG1lWS1mAQW5SFgNVxcr6lQhRBCCFHUbKqBgTncPZ5rJKC3jTc+XXxwru2sLlu/fj1r164FoHvNsuhpa/HnmftkZmUXedhCCFHSvBEJgKSkJDw9PZk/f/4zj//555+MHj2aSZMmcf78eWrUqEGbNm3UQ8jyIz4+ntDQUPVPWFhYvq9VGjhbGlHeyhj/4CgaNW1Ou3bt1MeCdgZx8vRJtoUehFbfQJlycH45XNmiuYCFEEIIUXRyTQO4pS7WVmrT1KkpdUfWxdjUWF0+dOhQHj58SBlDXdrXsCcsLoWDQY81EbkQQpQob0QC4K233mLatGl07dr1mcdnz57N4MGDGTBgANWqVWPhwoUYGBiwbNkyABwcHHJ94x8aGoqDg8N/vufs2bNxcnJS//j4+BTY/ZRUzVytScvM4uTtKPz8/NDS0gJAla3i8DeH+fP0nwSlhEPraWDqAGd+g+s7NBy1EEIIIYqEc8Oc/z3zOzy6rB4J0NSpKSbWJnT4rIO6akxMDB9++CEqlYqONRww1ddhw7n7pGZkaSJyIYQoMfKdAEhOTubEiRNs2bKFTZs25fopSunp6Zw7d47WrVury5RKJS1btsTf3x8AHx8fLl68SFhYGImJifz111+0adPmP687evRo7t+/r/45ffp0od5HSdCgkhU6WkoOBkVQrVo1xowZoz6WEJnA35P/ZsHpBSTp6EGbb8HYFk7+Ajf3aTBqIYQQBaG49AtEMWbrDk51Ifwy7P4Stg6Fa9uxUOrhZeOFvo8+7To9HUG4a9cu5s6di4GuFt1qliUuJYOdl2REphBCvA7tF1fJa8eOHfTt25eYmBj1t7xPKBQK0tPTCyS4lxEZGUlWVha2tra5ym1tbbl1K2eImba2Nn5+fjRt2pTs7GzGjh2LpaXlf17X1NQUU1PTQou7JDLW08bHxYLjwZE8iE1h2rRpXL58Wb1mQ9StKLZ8s4VKNpUY5j0MRdtvYddYOD4XtHSggq9mb0AIIUS+FKd+gSjGFApoMRGi7+RsD3z7IJxaBGeX0tzBnfMZqXQc25GzJ88SEREBwJgxY6hXrx4t6/iw89Ijtgc+pIWbLWYGOhq+GSGEeDPlawTA8OHD6dOnD48fPyYjIyPXT3Ft5Dt16sSNGze4desWgwcP1nQ4JdaTxQAPBUWgpaXF6tWr8fDwUB8PORHC4pmLORJ6BIxtckYCGJjD0R/g9iENRS2EEOJ1vIn9AqFBFuWh/hB4ewXUHwZmjrjdP49d1B0u3VvL7zOGoVAogJytnN9++23iYmPoVceJlIwstlyQhZyFECK/8pUAiIqKYsSIES/8Fr0oWFlZoaWlRXh4eK7y8PBw7OzsNBRV6eXuYIqVsR5HbjwmMysbExMTtm/fjo2NjbrOpXWXmPzTZB4mPgRTe2j7LeiXgSOzZE0AIYR4AxWnfoF4g+gYgGtb6DgXRfsfaW5Xj5SMZEy1DjKxS1V1tfv379O3b1/qlTenvJUR+66GExGfqsHAhRDizZWvBEDv3r3Zs2dPQceSL7q6utSqVYt9+57OI8/Ozmb//v3Ur19fg5GVTgqFAl9XG+JSMggMjQXA2dmZrVu3oqenp653ZM4Rxq8YT0Z2Bpg5Qju/p2sCXFyXa4sgIYQQxVtx6heIN5BCAdZVaNBiBrp2NThg7czEru40d3/65cHOnTvx8/PjXZ9yZGZns+7sfQ0GLIQQb658rQEwd+5cunTpwt9//427uzs6OrnnYX399dcFEtwTiYmJ6vn8AHfu3CEgIAA7Ozvs7OwYPXo0/fr1o1atWvj4+DBnzhySk5Pp379/gcYhXk7TKtZsPBfKgesR1HK2AKBevXosXbqU3r17A5Cdmc3acWvxquTFp60/BRO7nCTA3olwfgWkJUDtD3I6BUIIIYq1ou4XiJLJUMeQ+o6NORx6mLvePVg9KBavqSd5FJ0IwFdffUX9+vXxKGvNsVuRtK/hQHkrIw1HLYQQb5Z8JQDmzZvH7t27KVu2LCEhIep5WpDzDXBBN/Rnz56lWbNm6tcjRowAYNKkSUyePJlevXrx+PFjvv76ax49eoSXlxe7d+/GysqqQOMQL8faRA8PRzMuhMQSm5xOGUNdAN59912uX7/O1KlTAUiLT2PyoMnUOVCHhhUbgqEFvPUd/D0ZrmyG9ESoPzxn72AhhBDFVlH3C0TJ1cypGYdDD3MwO55B3q1ZOyiR5n6nyc7OJjs7m3fffZct+45x6UEca0+HMK6dm6ZDFkKIN4pCpXr1sdaWlpZMmzaNTz75pDBiKlb8/Pzw8/MjKyuL6Oho7t+/j6Ojo6bDKvZO3IrkpwM36V3XmU6eDupylUrFu+++y59//qkuK1e7HOcPncfS6P9zRzNS4MA0CAvM2TO4yec5uwQIIYQAIDQ0FCcnp2LTJpWmfsETxe0ZlCTTT07nbvxdfqg/FdNdX/LthrOMX39VfbxFixZ0GDuPk3djmNC+GtXLmmkwWiGE0LxXaZPy9dWqlpYWLVu2zFdwb5oxY8YQERFBYGCgpkN5o9R2scBYT5tDQRH8M8ekUChYunQpPj4+6rKQsyF0GtDpaT0dA2g5GcrVh3vHYf8UyJDFfoQQorgqTf0CUfhaOLcgS5XF7EuLuFajK1+0deGtWi7q4/v37yf04B9oKRWsOhVCPr7LEkKIUivf2wAuWLCgoGMRJYiutpKGlax4GJvCzYjEXMcMDAzYunUrTk5O6rIT60/w7vh3Sc38/wd9LR3w/RIqtYSHAbB3Qs66AEIIIYod6ReIguRj50Mb5zY8SHyA371t/Gxjw/f9yuNoa6GuM3vmDOwTb3AnMpGxGy5y+P+7DwkhhPhv+ZoC0LNnT/bu3YuNjQ3Vq1fPs9jPunXrCizA4kKG+r26O5FJjNt0kap2pnzV3g0drdz5psDAQBo2bEhSUlJOgQI6jOvAgi8X4GTy/+SASgVnfoOrW8HcGVp9k7NWgBBClGLFrU16E/sFPXr0YP/+/bRp04a1a9e+8vnF7RmUROFJ4Wy8uZGzj06jjLyF/fVEvpt5hczMTACsra0Zv3gbF6KUpGVmYW6oy1se9rR0s8FQN1/LXAkhxBup0KcAGBsb061bNxo1akSZMmUwMjLK9SMEQHkrI1pXs+P6o3gWHQ7OM0TP09OT1atXP10sSgV/ffsX7095nyOhR3LqKxRQ50Pw7gMx92DXWIgP08DdCCGEeJ43sV8wbNgwVqxYoekwxH+wNbJliNcQxtedgItjAx5U1qHO209HDz5+/JiNs8Ywt1cN3qlTjmyVitWn7jF01XlW+t8lMjFNg9ELIUTx9Mrp0czMTDp06EDjxo2xsbF58QmiVOvXwIXHiWkcuxWJjak+b9d2ynW8U6dOLFiw4OnCUSo4PPsw47PG029AP96v9j762vrg+Q7oGsOphbDzc2jxNVi7auCOhBBC/NOb2i/w9fXl0KFDmg5DvIRK5pX4qulMzp7wY132Bh7cSCLkbAQAx44dY8IXnzNnzhzaedhz/FYk2y8+ZMelMHZfeUSDilZ0qGGPs2XxTEQJIURRe+URANra2vTp04eUlJTCiEeUMFpKBSNbVKa8lRGbzodyMCgiT52PP/6YRYsWPS1QwfE5x1n2+zK+OfkNoQmhOeVuHaDZeMhIht3j4J5/Ed2FEEKI5ymMfsGRI0fo2LEjDg4OKBQK/vrrrzx15s+fj4uLC/r6+tSrV48zZ84U2PuL4kehUFCn/mfMsG7ED/0rY2prrD42f/586tevz43rV2lW1YYfenoypo0rlW1MOHrzMV9svMi3u65xPzpZg3cghBDFQ76mANSpU4eLFy8WdCyihNLX0WJsm6pYGuvx29HbXAqNy1Nn8ODBLF68ONfe0Sd+OsGhPw8x7eQ0joYezZkS4NwA2swAbT04OB2ubivKWxFCCPEMBd0vSEpKwtPTk/nz5z/z+J9//sno0aOZNGkS58+fp0aNGrRp04bIyEh1nerVqz/zJz09PV8xxcfHExoaqv4JC5PpaEVOqYVOk8/pYWbLjhEN0fnHPP+zZ89Ss2ZNpk+fTmZmJrWcLZjcyZ1pXarjU96SwPuxfLnpIn+cvEdKepYGb0IIITQrX4sArl+/nvHjx/PZZ59Rq1atPPP7qlWrVmABapqfnx9+fn5kZWURHR0ti/28hpCoZCZtuwzA1M7VcbIwzFNn6dKlDBw4MNd6Ac1GNMOlnQsNHBrQx61PzpSAuAfw92RICINqnXPWCfhH8kAIIUqy4rYAXWH2CxQKBdu3b6dDhw7qsrp16+Lj48PPP/8MQHZ2Nk5OTowaNYrPP//8pa996NAhFi5c+FKLAE6ePJkpU6bkKS8uz6BUCdoN/vM4nliO7n6bCA8Jz3XY29ubZcuWUaNGDXXZjfAElhy7w92oJMwNdXm/vjP1K1jm+uJBCCHeVK/SL8hXAkCpzDtwQKFQoFKpUCgUZGWVvMxqcetsvakuhcbx3e5rlDHUZVrn6pgb6eaps3z5cgYMGJArCdDl8y6YtzTH3sieTzw/wdHEEVJi4cA38DgoZ2RA489yRgYIIUQJV9zapMLsF/w7AZCeno6hoSGbN2+mY8eO6nr9+vUjMTGRjRs3vvS1XyUBEB8fT3x8vPp1WFgYPj4+xeYZlCoqFeyfCqFniKv1MW9Nm4H/en/4R49WR0eHCRMmMG7cOPWuFNnZKvZdC+fPM/dJTs/E3cGMAQ1dcDTP+4WEEEK8SV6lX5CvPVLu3LmTr8CE8HA048PGFVh0OJjv91xnUkd39HW0ctXp168fWlpa9OvXj+zsnD19t8zawod6HxLeOJxpJ6fxfrX3aVi2Yc50gCOz4N4JSI6GFhNB30wTtyaEEKVWUfYLIiMjycrKwtbWNle5ra0tt27deunrtG/fntOnT5OUlISjoyPbt2/H29v7ufVNTU0xNTXNd9yiACkU0HAEbBmK2aWVbB87iMF1yrB/zgniHuRMM8zIyGDSpEls3ryZpUuX4uXlhVKpoI27HfUqWLL6VAiHb0TwxcaLtPOwp3tNxzz9ESGEKInylQBwdnYu6DhEKdLM1YbH8WlsuhDK3P03+by1K1rK3EPw+vTpg1Kp5P3331cnAX6b/htjpowhs0kmv1/+naCYIPq49UHXdxyc/R2uboWdY6DlFDC118StCSFEqfQm9gt27Nih6RDE6zAwh0aj4NC3WF7ayBSrDIwnVeLGthhO7bijHkUYEBBAnTp1GD9+PF999RW6urqYGejwiW9Fmle1YcmxO2wPfMiJW1H0qedMvQoWMi1ACFGi5WsRQMj5B/X999+ndu3a1K5dm759+xIYGFiQsYkSrGdtRxpWtOJCSAzLTtzlWTNRevfuzapVq9DSepqR95vkh/FRY6pZVOPYg2N8c/IbwpLDwWdQzk/8Q9jxWc60ACGEEEWmqPoFVlZWaGlpER6ee953eHg4dnZ2Bf5+ohhzqgPvroHW06ju8R5dzCvi1t2cceM8qGL3dB2KzMxMpk6dSv369QkKeto/cLUzYUY3D/o3cCE5PZO5+28wd//NZ/ZJhBCipMhXAmDTpk3Url2b6OhounXrRrdu3YiKiqJ27dps2bKlgEMUJZFCoeBj34pUtTNl39VH7Lj07NWU33nnHdasWZMrCfDN199wY/ENOjh34GHiQ6acnMLJsJM5iwE2Gw+ZKbBrLFzaAP8fPSCEEKLwFGW/QFdXl1q1arFv3z51WXZ2Nvv376d+/foF+l7iDaCtBw5eUKs/nbuvoVrVboT5VGLB7x8zposn/xxgeP78eWrWrMlvv/2m/pCvpVTQtro9P/bywtOpDCdvR3H6TrRm7kUIIYpAvhYBrF69Ou+99x7jxo3LVf7tt9+yatUqLl++XGABFhfFbcGlkiIxLZOvt1zmYVwKY9q4UsvZ4pn1Nm7cyDvvvENmZqa6rFWrVkxbNI3Vd1cTnx5PU8em9K7aG53oO3DEL2eHAOuqOUMEzcoW1S0JIUShK25tUkH3CxITE9Xz+b29vfnpp59o3LgxdnZ22NnZ8eeff9KvXz8WLVqEj48Pc+bMYf369dy4cQMrK6sCu6//UtyegcgRnx7P5BOTSc5I5qt6X/Hg7FX6D/yQoDuhuep1796dX3/9FQuLp/2O2OR0Rq4NwMxAhx/e9kRHK98DZYUQoki9SpuUr3/Zbt68Sc+ePfOU9+zZ85UW4BHCWE+bL9+qipGuNr8cCiYyMe2Z9bp3786OHTswMTFRl+3bt48POn7ABw4f4GruyuHQw0w/NZ1wQzPo9DO4dYTH12Hb8Jz1AWRInxBCFIqC7hecPXsWb29v9aJ8I0aMwNvbm4ULFwLQq1cvZs2axddff42XlxcBAQHs3r27SD78+/n5YWNjg6enZ6G/l3h1prqmfOz5MZnZmSwIWIBn4yacvxzER+91zVVv48aNeHp6cvjwYXVZGUNdung7EJGQyu7Lj4o6dCGEKBL5SgA4Ojrm+gfziYMHD1K2rHzTKl6Njak+HzWtSGJaJvMO3CIr+9kf1Fu3bs3x48dxcnJSl125coXWTVvTVNWUjhU6cj/hPlP8p3Am6hLU/QjaTM/ZFeD0Ytg9DhKkQRdCiIJW0P0CX19fVCpVnp/Jkyer6wwbNox79+6RlpbGqVOn8PHxeZ1beGljxowhIiJC1j0qxqqYV6FHlR6EJ4ez7PIyDAwMWPjHJjbN/RILIx11vdDQUJo1a8ZXX31FRkYGAO087LE01mPT+VDiUjI0dQtCCFFo8pUAGDVqFEOHDmX48OGsWbOGNWvWMGzYMEaMGMFnn31W0DGKUsCnvAWtqtlx/VE8G8+FPreeh4cHp06dolatWuqy8PBwmjdrDpdhVK1RaCu1+SXwF346/xNRZRyh83yo0gbCL8PWoRC0S0YDCCFEAZJ+gShu2ri0wcvaizPhZzgQcgCAriO+JXDNVJpVtVTXU6lUzJgxg0aNGhEcHIyetha9fcqRkpHFhv/ojwghxJsqXwmAYcOGsWrVKs6fP8/QoUMZOnQoFy5cYNWqVQwZMqSgY9QoGepXdN6v54yzhRGbLzzg8v/38X0We3t7Dh8+TOfOndVlKSkpdO/enb0r9jKl/hRq29Ym4HEAXx37il0PDpNZ75Oc7QF1jcB/PuybCImPi+K2hBCixCtN/QLxZlAoFHzo8SFWBlasDVrL7djbADi2H8u+ucP4rkdVtP+xwPDp06fx8vJi5cqV1K9gQSUbY/ZfCyc0JllTtyCEEIUiX4sAlkay2E/ReBibwrhNlzDQ0WJmjxqYGeg8t25WVhZjx45l9uzZuco/+eQTfvrpJ67GXOWPa38QmRJJWeOy9K3Wl8qG9nB6EQQfBB0D8BkMlVqC7PkrhHiDSJukefIM3gx34+4y/dR0THRNaFe+HfUd6mOEFuz+kjNnztJ7xR1u3XuY65xp06bR88MRfL31Ml5O5nz5VlUNRS+EEC/nVdqk10oApKenExERQfa/tlorV65cfi9ZbElDX3QO33jML4du4elUhi/bVkXxgg/nCxYsYPjw4bn+Dt966y3WrFmDgbEBf93+i113dpGlyqJx2cb0rNIT40dX4MRPkBqXs31Q/WFgIvtHCyHeDMW1TZJ+gSiO/B/6s/LqSlKzUtFV6lLbrja+Vt5UPPozSTHhjDioy9I/t6nrKxQK9uzZw1WFC/63Ixn3lhueTmU0dwNCCPEChb4LwPXr12nYsCEGBgY4OztTvnx5ypcvj4uLC+XLl89X0EI80bSKNY0rWxN4P5btF8NeWH/IkCFs374dY2NjddmuXbtwc3Nj47qNdK3UlSkNpuBq7srRB0cZd2wcR5XpqDovgIrN4WEAbBkCVzbDvzqtQgghXkz6BaI4q+9Qnx+b/Uh/9/6UNS7LiYcnmHFxPpOsLThlCPM6aLNm8Vy0tbWBnHUB3nvvPXydlOhoKVl58t5zFygWQog3Tb5GANSrVw9DQ0PGjRuHvb19nm9o3d3dCyzA4kIy/UUrJT2L8ZsvEZGQypRO7lSyMXnhOYGBgbRv354HDx7kKm/WrBnz5s3Dzc0N/4f+/Bn0JwkZCVQxr0Iftz44xkeA/zxIjACrytBgBFhIh1UIUXwVtzapNPUL/Pz88PPzIysri+jo6GLzDMTLuxd/j0P3D3Ey7CRpyVHoxtzFR8eC2zfdmT756bTCRo0aMfi75ey4Es7ARhVoVc1Wc0ELIcR/KPQpAEZGRly4cIEqVarkO8g3TXHrbJUGdyKTmLjlMuZGunzXzQMjPe0XnvPw4UPeeecdjh49mqtcW1ubTz/9lK+//hqlvpINNzZwOPQwChQ0LNuQLs5tsbi2A65uBYUSPHqC5zug9fw1CIQQQlOKW5sk/QLNPwPx6lIyUzgddpqDV/4g5NEFVNr6nP0tlsuHr6jrjP7scxJq9AJgzjteGOq+uC8ihBBFrdCnANSqVYv79+/nKzghXlZ5KyP61CvH44RUFh+9zcvkqhwcHDh06BDLli3D2tpaXZ6ZmcmsWbNwc3Njx+Yd9K3Wlwl1J1DZvDLHHhxj3MkprDMzI6nNNDBzgot/wrbhEH61MG9RCCFKBOkXiDeRgbYBTZ2aMrntYr52fR+vTBU13iuDnaONus7sH2bhlHCN+NQMtlx4+B9XE0KIN0O+EgCjR49m1KhRrFq1isDAQK5evZrrR4iC0sbdjtrOFpy8HcX+axEvdY5SqaRfv37cuHGDYcOGoVQ+/TN/8OABvXr1olWrVqQ/SueLOl8wwnsENoY27L67my+u/sYuj7dIr9ELEsJg11g4+QukyzZAQgjxPNIvEG86l3oj+Lhid8rqZNDgQ2t0dZ5+0//jxJGYZsSw81IYEfGpGoxSCCFeX76mAPzzA5X6QgoFKpUKhUJBVlZWgQRXnMhQP81JTMvki40XiU/JYHoXD8pZGr7S+RcuXGDIkCGcPHkyV7mOjg6jR49m0qRJ6Onr4f/Qn823NhOdGo25njld7BvS8OZxlJFBYGgJ9T6BcvUK8taEECJfilubJP0CzT8DUTCuXN3AD+d/JHZfGJtX3FGXu3vWxG3QbBq62vNpy9Iz1UUI8WZ4lTYpXxOZ7ty58+JKQhQQYz1tRjSvzJTtV5i7/ybTulTHQFfrpc/39vbm+PHjLFu2jC+++ILIyEgAMjIymDlzJtu3b2fVqlU09GqIj50P++/vZ0fwDpbe/Ys9ZezpYdMWzxuHUByYlpMA8PkIjK1f8K5CCFF6SL9AlBTu1XrQKCOGo/pbaHEjhf0nHwFwJfA8pnt/46TOEIIeJeBq9+LFiYUQojjK1wiA0kgy/Zq35cID1p4JoaK1MePauWH8EosC/lt0dDQTJkxg4cKFudYU0NXVZfr06YwePRqlUklyRjI77+xk3719ZGRnUNGoLF2SUqgWdg2FtgHUfB+qdoRnfOslhBCFTdokzZNnUHIlZSQx4dgEEmOjODxiJzdDo9THGg+eSuO2XZjWpXqe3S6EEEJTCn0RwNLEz88PGxsbPD09NR1KqdfZy4GOng4EP05k+o6rJKRmvPI1LCwsWLBgAadPn871TNPT0xkzZgytW7fmwYMHGOoY0qNKD75r/B1NHZtyJzmMH4hmplNlgnSUcHox7BgNUcEFeYtCCCGKOekXlHxGOkb0qdaHLENtus36EAN9PfWx8yumEn1hB8duRWowQiGEyD8ZAfCSJNNfPKhUKtafC2XT+VDKWRjyVftqmBnkb6u+tLQ0JkyYwKxZs3KVm5ub8+uvv9KjRw912ePkx2wL3saJhydQZWfhlplN16hHVEIXqnUG7z6gY/Ba9yaEEC9L2iTNk2dQ8s0PmM+58HM4XXdi6qdT1eWudkaMGj2MOr2+oGY5cw1GKIQQOWQEgCixFAoFb9d2olcdJ0Kik5m6/SoxSen5upaenh5+fn7s27cPBwcHdXlMTAw9e/bkgw8+ICEhAQBrQ2sGegxkeqPp1CvbgOu6OsywsmS2gYrbVzfAlk/g/ukCuUchhBBCaF4ftz4YahsS6xFL3/591eVBj5L4e/1y/vhrP8duykgAIcSbRRIA4o3U1duR9+o68yA2mal/XSUqMS3f12rZsiUXL16ke/fuucqXLl2Kt7d3rt0D7IzsGFxjMN80/IY6jk24bGbDNFM95qbc4d7+ibD/G0h4lO9YhBBCCFE8mOmZ0cu1FwkZCfh84oOHh4f62IYzj8ja78e8AzfYfTlMg1EKIcSryVcCICoqiqiopwuiXLt2jWnTprFx48YCC0yIF+no6UD/Bi6ExaUwZftVIhLyvzevpaUl69evZ8mSJRgZGanLg4ODadSoEZMnTyYt7WmSwcHYgU+8PmFKw6nULN+aQKtyTNHP5Jf7e4jYPAgCVkNm/pMSQgjxJpF+gSipGpVtRDWLapyLOcf0X6djbGysPvbz5tPonV3GshN3WX/2PjKrVgjxJshXAqB79+5s3boVgMePH9OwYUPWrFnDBx98kGc+tRCFqW11ewY1rkBEQipTtl/lUVz+kwAKhYIBAwYQEBBA3bp11eVZWVlMmTIFd3d3tm7dmquBdzJxYpj3MCY1moZH5Q6csbBnvDKGVQELid88GEJOgXQIhBAlnPQLREmlUCjo594PXaUuh9MO8+uSX9Wr/6tUsGrJb2QH+7PxfCjLTtyVJIAQotjLVwLg4sWL1K9fH4B169ZRqVIlrly5wqpVq1i0aFGBBijEi7Rws+XjphWJTkxnyvYrPIhNea3rVapUiaNHj/L111+j/Mc2f8HBwXTp0oXWrVtz5cqVXOc4mzozqtYoxjScilP5luw3MePL5CD+OvAF6fsmQvzD14pJCCGKM+kXiJLM2tCabpW7EZ0aTXb17Fx/01nZKrbN+RL9x9fZc+UR8w7cIjMrW4PRCiHEf8tXAiAtLQ1DQ0MA9u7dS5cuXQDw9PQkNDS0wIIT4mX5utowrHkl4lIymLLtCvejk1/rejo6OkyZMoWjR4/i7u6e69jff/+Np6cnw4cPJzo6OtcxN0s3vm4wiY8aTMDYqS6b9LX58uE+jm7uR/a55ZCR/xEKQghRXEm/QJR0LZ1bUsGsAgdCDtCsRzP8/PzUx9LSM9j43XCsU0I5HhzJrL03SMvM0mC0QgjxfPlKALi7u7Nw4UKOHj3Kvn37eOuttwB48OABFhYWBRqgEC+rYSUrRrSoTFJ6Jl9vvcza0yHEpWS81jUbNGhAQEAAP//8M+bmT7f6ycrKYt68eVSuXJn58+eTmZmpPqZQKKhrX5fpvrN4p95YMmxcWaqVwteXfiFwYx9Ud47KtAAhRIki/QJR0ikVSgZUH4BSoWTplaWMHDWS8ePHq48nJiaxeurHVNKOJeB+DDN2XCMpLfM/riiEEJqRrwTAzJkzWbhwIb6+vvTo0QNvb28Atm3bho+PT4EGKMSrqFfBkjFtqmJmoMOWgAcMX3OBFf53ic7nVoEA2traDBs2jJs3bzJs2DC0tLTUx6Kjoxk2bBheXl7s378/13k6Sh1au7RmZquFvFV7OBFmdsxNv8/3h7/g2l9DUUXeyndMQghRnJSmfoGfnx82NjZ4enpqOhRRxMoal6VjxY6EJYWx/Opyxk0ax5AhQ9THo6OjWTrxQ2pbZBIUnsCU7Vc4ezeaO5FJxKVkyPoAQohiQaHK579GWVlZxMfH5/pW9O7duxgaGmJjY1NgARYXoaGhODk5cf/+fRwdHTUdjniB7GwVJ29HsfnCA+7HJKOtVOLrak0nTwdsTPVf69qXL1/m008/zfOBH6BDhw5MnjyZWrVq5TkWlRLF5mur8b+5HVVKNM7o0K5sE2o2+BwtI+vXikkIUboUxzZJ+gWiNMjMzuT7M99zK/YWhtqGvOXyFqu+XMyaDVvVdSpUqMC4Bev4+17uLx90tJRYGOliaaSHpbEulka6WBjpYmemT3UHM5RKRVHfjhCihHiVNinfCYDSRhr6N5NKpeLcvRg2X3hA8ONElAoFDStZ0dnLAUdzw9e67rZt2xg9ejS3b9/Oc7x9+/ZMnDgx124CTzxKesSeK6s4fusvMtMTsFLq0talHY3qfoqunnGe+kII8W/SJmmePIPSK1uVzYmHJ9h8czMxaTGYaZtxZuIOjvvfVNepXr06SzfsIEGlT2RiGlFJ6UQnpROVmE5UUhqpGbnXCKjtbMHwFpXQ09b699sJIcQLFXoCoHz58uotUJ7lWR+I3nTS0L/ZVCoVlx7Esen8A64/ikeBAp/yFvSo5YiTRf4TAWlpacyZM4dp06aRmJiY53ibNm34+uuvadCgQZ5jcalx/H3hFw4G/0VyZiom2ga0qNSZ5t4fYaxnku+YhBAlX3Frk6RfoPlnIIpeelY6+0P2s+P2DuITYjgyfgf3rsWpj/v4+PD3339jYpK7TVepVCSnZxGdlE5kYhoHgx5z+k4UVWxNGNu2KsZ62kV9K0KIN1yhJwDmz5+f63VGRgYBAQHs2LGDMWPGMHbs2Fe9ZLHl5+eHn58fWVlZREdHS0NfAlwLi2fLhQcEhsair6PF+HZuVLF9vQ/cYWFhfPfdd/z666+kpuZd6b9FixZMnDiRpk2b5jmWkhrHkdNz2Ht3DzHZ6ejqmdC4UhfaVH8PKwOr14pLCFEyFbcPn6WpX/BEcXsGQnOSMpLYcXsHO8+vZMf4A0TefboTkY+PD59++ikdOnTIkwh4QqVSsfzEXXZfeUTZMoaMa1cVK2O9ogpfCFECaGwKwOLFizl8+DB//PFHQV2y2JCGvuS5GBrLrL030FLAhA7VqGj9+sPvw8LCmDVrFr/88gspKSl5jjdp0oRJkybRrFmzPN+WZSZGcNp/FrseHOEBmSgMLPBwaY5v+bZ4WHmgpZRhgUKIHG9KmyT9AlGaRCY9ZuXqPkydfITYh7m/DNDX16ddu3a8/fbbtG/fHmPj3H0OlUrFtsCHrDkdgoWRLuPecnutEYpCiNJFYwmA4OBgvLy8SEhIKKhLFhvS0JdMl0Lj+H7PdfS0lUxoXw0XK6MCuW5ERAQ//PAD8+fPJykpKc9xX19fZs+erV4p+59Ukbe45P8D+6MuclmRicrYhjIWFWns2JTGjo1lVIAQ4o1pk6RfIEqdsIucWTuctt+dJToi+ZlVDAwMaN++PT179qR9+/YYGT3texy+8ZhFh4Mx0NHi8zauuNmbFlXkQog32Ku0SfnaBvBZ0tPTWbRoEba2tgV1SSEKnYejGaNbVSE1I5vpO69xP/rZjfWrsrGxYebMmdy9e5fx48fnGfZ36NAhatWqxQcffEBYWFiuYwqrStTosIBRvt8z06AyHRMS4OEFtl9dzRdHvmD22dmcCz9HZrbsLyyEKL6kXyBKJfsa1PFqS9CEhgwa1A0LB4s8VVJSUtiwYQO9evXC2tqat99+m9OnTwPQtIo1Y9tWJTNbxYyd1zh9J7qo70AIUcLlawSAtbV1ruHLKpWK2NhY9PX1Wb58Od26dSvQIIsDyfSXbGfvRvPj3zcw1tPm647ulC1jUKDXj46OZu7cucydO5e4uLhcx4yMjPjyyy/57LPPMDD41/tmpsHlTWRdXMel7ESOmJgRqK+PSlsXU11TGpZtSOOyjbEzsivQeIUQxVtxa5OkX6D5ZyCKkYRw2PwRmNij6vgTGw9vZd7yeZzbe47E8LwLBgPo6Ojw559/0rVrVwBuRSTy/e7rJKRmMqChC63dpZ0XQjxfoU8BWL58ea7XSqUSa2trfHx8sLDIm+ksCaShL/n8g6P4af9NyhjqMKmjO3Zm+gX+HjExMUybNo2ff/6ZjIyMXMecnJyYOXMm77zzTt7VtBMfw9klcPcoMQo45lCVI9pZRKXnJBMqmFWgnn09fOx9MNWV4YJClHTFrU2SfoHmn4EoZs6vhIt/gpMPePQE66pcjw5i/l/zObT9EHeO3iEpIvcUQS0tLVatWkWvXr0ACItL4dud14lISKWbtyM9azv+524bQojSS2NrAJRk0tCXDsdvRTLvwC0sjHWZ1LEaNiYFnwQAuHnzJmPGjGHr1q15jtWrV48ff/yRevXq5T3x0WU4tRBi7pKtZ8pV15Yc18rgQsQF0rPTUaLE3cqd+g718bbxRk9LVhEWoiSSNknz5BmI/5SRCgenw8MLOa8tK4FbRyjfhKC422y9tZWj/ke5uecmQbuC1KcplUqWLVvG+++/D0Bscjozd1/nTmQSzVxt+LBxBbSUkgQQQuRWKAmAq1evUrVqVZRKJVevXv3PutWqVXv5aN8Q0tCXHoeCIlh4OBhrE30mdaxWqFvxHDx4kFGjRhEYGJjn2LvvvsuMGTNwcXHJfSA7G27ugfMrIC0BLCqQ6tGT87panAw7yZWoK6hQoaulS02bmtS3r081y2qyi4AQJUhxaJNKa79AtgcWryT6NlzbDrcPQVYG6JuB61vg2o4baZFsu7WNdYvXcWbxGfUpCoWC3377jQ8++ACAlPQsZu8L4tKDOBpUtGKIb0W0tQpsGS8hRAlQKAkApVLJo0ePsLGxQalUolAo+OepT14rFAqysrJe7w6KoeLQ2RJFZ/+1cBYfvY2dqT6TOrpjbqRbaO+VlZXF8uXL+eqrr3j06FGuY7q6ugwdOpSvvvoKS0vL3CemJUDAagjaCdlZYO4Cnu8QZ+fBmfAz+D/05078HQBMdEyobVcbL2svqlpWRUepU2j3I4QofMWhTZJ+geafgXiDpMbDzb1w/S9IigSFElwag1tH/kq4xbQfpnHql1O5TlmwYAGffPIJABlZ2cz9+yZn70Xj42LBiBaVJQkghFArlATAvXv3KFeuHAqFgnv37v1nXWdn55eP9g0hDX3ps/vyI5aduINDGQMmdXDHzLBwPzQnJCQwc+ZMfvjhB1JTc+8fbGpqypdffsnIkSMxNPzXvsBJUXB5A9zYnfPtQplyUONtcGnCo5QI/B/6czLsJI9THgOgp6WHh5UHXjZeeFp7YqRTMFsfCiGKTnFok6RfoPlnIN5A2VkQchKubYPwKzllVpX5y9mLb3/7lRM/nchVfc6cOYwcORKAzKxsfj5wi1N3oqjlbM6nLaugI0kAIQSyBkChkIa+dPrr4kP+OHkPU30detctR9Mq1oW+AE9ISAjjxo1j9erVeY45ODgwZcoU+vfvj7a2du6DydFwZTNc3wFZ6WBaNicRUMEXlULJg8QHXIi4QEBEgHpkgBIllc0r42XjRU2bmlgbWhfqvQkhCoa0SZonz0C8tifTA279Dfpl2O7emu+X/sqxH4/BP3rnM2fOZOzYsQBkZatYcPAWx4Mj8XQqw+hWVdDTlil+QpR2RZIACAoK4vDhw0RERJCdnZ3r2Ndff52fSxZr0tCXXkduPGaF/z0S0zJwtTVhYKMKlLM0fPGJr+n8+fN8+eWX7Nu3L88xNzc3vv32Wzp16pQ3IZESC1e35nQqMlPB2BZq9IKKzUErJ2kQmxpL4ONAzkec51rUNTJVmQA4GDngZeOFl7UXFcpUQKmQbxaEKI6KY5sk/QIh8un2YTjiB0ZWbK/WklkrFnN01lFU2U+76FOnTmXixIkAZGer+OVwMEdvPsajrBmft3FFT1uLtKw0Dt0/RHpWOh0qdJAdA4QoRQo9AbBgwQKGDx+OnZ0d9vb2uf6BUSgUnD59+tWjLuakoS/dEtMyWXs6hP3XIlAooI27HT1rO2Koq/3ik1/Tvn37+OKLL7hw4UKeYw0aNGDmzJk0atQo74lpCTmJgKvbICMZDC3BvQtUbgO6TxMYqZmpXIm6woWICwQ+DiQpI2dbIhMdEzysPfCy9sLdyh0DbYPCukUhxCsqbm2S9As0/wzEG+7W33BsDhjbsr1aC2avWsyRmUfIznqaTJswYQJTp05Vr6+x+OhtDlyPoIqdAT7uYey7t5uEjAQAPqv1Ge5W7hq6GSFEUSv0BICTkxOjRo1i9OjR+Q7yTSMNvQC4FZHIkuN3uP04kTIGuvSp50zDSpaFnmXPzs7mzz//5KuvvuLOnTt5jtevX5+hQ4fSo0cP9PT+tWtBehJc+ytnvmFqHOgYQtV24NYJDHPvz52tyuZW7C0CHwcSEBFAWFIYAFoKLapaVMXL2gtPG0+sDKwK7V6FEC9W3Nok6Rdo/hmIEiBoF/jPB1MHtlX1Ze663zk0/RDZmU+TAI0bN6Zjx460a9eOSlUqMXn/Bg4/3IOeXhoedva0cmnBtuBtOJo48nW9r2UUgBClRKEnAMzNzTl79iwVK1bMd5BvGmnoxRPZ2SoOXI9g7ZkQEtMycbM35YOG5XGyKPxpAWlpaSxatIhvvvmGyMjIPMdtbGwYNGgQH330EU5OTrkPZqZB8AG4vAkSwkCplTMtwL0blHHKcy2AiOQIdTIgKCaIbFVOJ8TR2BFPa088rT1lqoAQGlDc2iTpF2j+GYgS4upWOL0YypRjm2sTft7wOwenHSQrPe9OGiY2JjjUdqBM9XKYOLWmdtnmTGhXgy23/2R/yH4+8fyEOnZ1NHATQoiiVugJgNGjR2NnZ6dekKQ0kIZe/FtcSgZrT4dwMCgCLaWCttXteau6HVbGei8++TXFx8fj5+fH7NmzSU5OznNcS0uLzp07M3ToUJo1a5b7G4DsbLh/Ei6th8ibOWVOdaF6d7B9/l7dyRnJXIm6QkBEABcfXyQpM2eqgJGOkToZ4G7pjqFO4SdChCjtilubJP0CzT8DUYJc2gDnloFFebZWacSCzUs4OPUgGakZzz1FW0cXy0qeuPs0YfLIt1kVuQRLA0umNpiKllIWCRSipCuSBMDSpUupVasWHh4e6Ojk3h7t+++/f9VLFlt+fn74+fmRlZVFdHS0NPQijxvhCSw5doe7UTkfiB3KGFCjrBk1nMpQzd4UfZ3Ca3ijoqJYsmQJv/zyyzOnBkDOgoFDhgyhb9++mJqaPj2gUuVsQXR5I4SeySmzrgruXaFcvZwRAs+RrcomODaYwMeBXHx8kdDEUODprgKeNp54WXtha2grww+FKATF7cNnaeoXPFHcnoEoYQJW5/xYVWZrpQasOrueOwfvcP/MfSKuRORaIDAPhYLm/Tri9LY5Az0G0tixcdHFLYTQiEJPADRr1uz5F1QoOHDgwKtestiThl78l+xsFSfvRHEhJJZLoXHEpqQDoK1UUsXWhBqOZtRwNKO8lVGhfCDOyspi9+7dzJs3j927dz+zjpGRET169KBfv340bdoUpfIfw/Zj7sGVTXD7UM4exUZWULUDVGkDeiYvfP/IlEguPr5I4OPAXLsKWBtYU82yGtUsq+Fq4YqprukLriSEeBnFrU2SfoHmn4EoYVQqOL88ZzSAjRvbK9Xn4MNj+Dr5Utu0NicOn2Dnzp3s2rWLR48ePfMSzt1qUO/9Rixo7YeFoYzOE6IkK5JtAEsbaejFy1KpVNyPTuHig1guhsZxLSyejP+v4muir4Onoxlv13bCxlS/UN7/1q1b/PLLLyxZsoTY2Nhn1nF2dqZfv3707ds395zd5GgI2pmzEFFqHGjpQsVmOckAi/Iv9f5pWWlci7pG4ONALkVeIjo1Wn3M0diRapbVqGpRFVcLV9lZQIh8kjZJ8+QZiEKnUuWsB3BtG9jVgJaTQDv3NMPs7GwCAwPVyQB/f/9c23A6ve2BZ5uP6Vy5LW952FO2jLS7QpRERZYAiIyMJDg4GC8vr7wrj5cw0tCL/ErLzCLoUQIXQ+O4GBpLSHQy+jpa9G/gQtMq1oU2RD45OZnVq1czf/58AgICnluvcePG9O/fn549e2Ji8v9v+7My4M6RnMWIom/nlNnVALeOOesFKF9u0T+VSkVEcgTXoq9xLeoa16KvkZiRCORMF3Axc6GaZTXcLNyoVKYSOlo6L7iiEAKKb5sk/QIhCphKBScX5CTmHbyg9sD/TMjv3r2bTp06kZHxdL0A1371qNHgO5To4l3OnPYe9rg7mMoUPSFKkEJPAMTHx9O/f3+2bNmCQqHg5s2bVKhQgY8++ggbGxu++eabfAdfXElDLwpK4P1YfjkUTGxKOnXLWzKoSQWM9bQL7f1UKhWnT59m2bJlrFmzhri4uGfWMzAwoHv37gwYMABfX9+cKQIqFTy+Dle3wb1jOa+NbaBqe6jc+qWmB/w7ltDEUK5GXeV69HWCooNIzUoFQFuhTSXzSrhZuOFm4YaLmQvaysL7vQjxJitubVJp6hfI2kCiyKlUcHwu3Po757VlRajUEso3Bf28U+u2bNlCjx49yMp6unPA+xM/xqPhSM7fi0WFCmcLI7rVLItPeQtJBAhRAhR6AmDQoEHcvHmThQsXUqdOHQIDA6lQoQI7d+7kiy++4NKlS/kOvrgqbp0t8WaLS8lg8ZHbnL0XjYWRLkN8K1G9rFmhv29qairbtm1j2bJl7NmzJ9cwwX8qX748AwcOpH///pQtWzanMCkSru+AG7shLSFnekClljmjAp6zjeCLZGZncjfuLtdjrnMt6hq3Ym+RkZ3zrYWuli6u5q45CQFLN5xMnGS7QSH+r7i1SdIv0PwzECWcSgXhl+HWfrh7NGdrX6VWzqi8Si2hbK1ci/euXbuW3r17o+7mK2DJ8iW07fQOOy894vCNx6RnZuHjYsGAhuUxN9LV0I0JIQpCoScAHBwc2LFjB97e3piYmKgb+tu3b1OjRg0SExPzHXxxJQ29KGgqlYqDQREsO3GP9Mws2tdw4J06TuhoFc2H3IcPH7Jq1SqWLVvG1atXn1lHqVTSrl07Bg4cSPv27XNW9s5Mezo9IOZuTkUHb6jWOacD8hrfJGRkZRAcF6yeLnA77jbZqpwkhZG2EVUsquBm4YarhSuOxo7yrYUotYpbmyT9As0/A1GKZKTAveM5yYBH/0+u6ZvlrNlTqSWYuwCwdOlSPvjgA/VpSi0lG9ZvoGvXrsQmp7Pk2B1O343GWE+bvvVdaFzZStpVId5QhZ4AMDY2JiAggEqVKuVq6M+dO0erVq2Ijo5+8UXeMNLQi8ISFpfCvAO3CH6cSDkLQ4Y3r4yTRdGt1qtSqTh79izLly9n1apVz1040NbWlv79+zNw4EAqV66c823Eo0s5ixOFnMypZFoWqnWCis1B5/UXGkrNTOVmzE2uRV/jatRV7ifcR0XOP1nGOsZUtaiq/rE3speOiyg1ilubJP0CzT8DUUolPILgAznTAxIjcsps3aHRaDCxZcGCBQwdOlRdXUdHh23bttG2bVsATt6OYsmxO8SnZuDpVIZBjStgZVyy1+8QoiQq9ATAW2+9Rb169Zg0aRImJiZcvHgRFxcXevfuTVpaGps2bcp38MWVNPSiMGVmZbPpwgM2n3+AtpaC9+qWo427XZF/oE1JSWHz5s38/vvv/7ltV5MmTRg0aBA9evRAX18/pwNybTvc3AcZyaBjCFVaQ9WOYGJbYPElZSRxI+YG16KucT36OqGJoepjZrpmuFq4qkcI2BraSkJAlFjFrU2SfoHmn4Eo5Z4k5W/ugduHQdcYmnwOjrX54Ycf+Pzzz9VV9fX12bFjB82bNwcgPjWDFSfucuxWJAY6WrxX15kWbjbShgrxBin0BMDly5dp0aIFPj4+7N27l65du3LlyhXCw8M5duwYVapUyXfwxZU09KIoBD1KYN7BWzxOSMXTsQwfN62osXl5wcHBLF26lKVLl/Lw4cNn1rG0tKR///4MHjw45//3GSk5QxKvbYP4/5/jWCdn0cDXnB7wLAnpCQRFB3E9+jrXoq8RlhSmPlZGrwyu5q7qLQclISBKkuLWJkm/QPPPQAi1e/5w7MechHyNt8GrD1OnTWPSpEnqKkZGRuzZs4eGDRuqy87di+a3o3eISU7H3cGMj5pUKLQti4UQBatItgGMi4tj3rx5BAYGkpiYiLe3N0OHDsXBwSFfQRd30tCLopKSnsWS43c4evMxxnrafNCoPA0qWmksnszMTHbv3s3vv//O9u3bc60q/E/Nmzfn448/pnPnzujq6MCDczmjAh6cy6lgbAuub+XMTzQoUyixxqXFERQdRFBMTlJAEgKipCqObZL0C4QoRuLD4OD0nLV67D1RNf6cj776gsVzFqurmJqacuDAAWrVqqUuS0rL5I+T9zgYFIGuthbv1nGijbsdSqW0l0IUZ0WSAChtpKEXRe3U7SgWH71DYloGDStaMaBR+ULdLvBlPHr0iOXLl7N48WKCg4OfWcfW1pYPPviAQYMGUb58+ZzpAUG7cqYHpMXnrFLs0ghc24ONW4GPCvinuLQ4bsTc4Hr09TwJATNdM9ws3ahmWY1qltWw0LcotDiEKGjSJmmePANR7GWmwclfctYHMLRA1fRLGn86mONrj6urWFtbc/z48Zy1ff7hYmgsvx65TWRiGp6OZfi0ZRUMdLX+/Q5CiGKiSBIADx484JdffuHatWsAVKtWjY8++qjENoLS0AtNiE1O59cjtzkfEoO5oS4fN62Ip1MZTYdFdnY2+/fvZ9GiRWzZsuWZowIUCgVt27alX79+dOzYEUM9Hbh7DIJ2QkTOvxuYO4NrO6jQDHQLf+HD+PT4nBEC0UF5pgzYGdqpkwFVLapiqFN0CzEK8aqKY5sk/QIhiqmb++DkAsjOIrhae9pNms2NXTfUh11cXDh+/Hie0Tr/HJFYzsKQsW2rygKBQhRThZ4A2LVrF926daNy5crUq1cPgFOnTnHjxg02btxIu3bt8hd5MSYNvdAUlUrFoaDHLPe/S2pGFq2q2fFe3XLo6xSPTPzDhw9ZsmQJixcvJiQk5Jl1jIyM6NKlC++++y6tW7dGJyE0JxEQfBAyU0FbHyo0zUkGWFYssthjU2O5GnWVq9FXuRp1ldi0WAAUKChvVl6dEKhoVhEdLZ0ii0uIFylubZL0CzT/DIT4T1HBcOhbSHjEXBMj5sw5xd1j99SHq1evzpEjRzA3N891mkqlYtP5B6w/dx9zQ13Gtq1KeSujoo5eCPEChZ4AqFKlCp07d8bPzy9X+dixY9myZQs3btx4zplvLmnohaZFxKey4FAw1x/FY2eqz5Bmlahia6LpsNSysrLYvXs3CxcuZMeOHTzvnxYLCwt69OhB7969aVy3Fsq7h3OSATH/74hYVspZK6B8kwLZSvBlqVQqwpLCchICUVe5Hn2d1KxUAHSUOlQsUxE3CzfcLNxwMXNBW6nZ6RiidCtubZL0CzT/DIR4obREOD6H0JCjTFDFc/jnUO5eeLqbTsOGDdm7dy+GhnlHwB27GcnCw8EolQpGtqhELWeZNidEcVLoCQBDQ0MCAwPzzBe6efMmnp6eJCcnv+oliz1p6EVxkJ2tYselMP48c5+sbBWdvRzoUcsRbS2lpkPLJSQkhN9++42VK1dy9+7d59YrW7YsvXr14t133qFWOWMUN3fDnaOQlZ7z4b9CM6jSpkhHBTyRlZ3Fnbg7XI3OSQbcirlFpioTAF0tXaqUqYKbZc6Wg84mzmgpi8eIDFE6FLc2SfoFmn8GQrwUlQoub2TX+fmsSU9hp98tom5GqQ936NCBTZs2oaOTd9TbtbB4ftgbRFJaFv0aONO2un1RRi6E+A+FngBo06YNffr04f33389VvnLlSlasWMG+ffte9ZLFnjT0ojgJiUpm/sFb3ItOwt7MgDbutjSpYo2hbvH6VlqlUnHy5EnWrFnDn3/+SURExHPruri40K1bN7p3fIt6Vokob+2F2P9PKbCqnDM9wKUx6GhmS6KMrAxuxd5Sbzl4O+422apsAPS19KlqUZWqFlVxs3TD0dhRdhgQhaq4tUnSL9D8MxDilZxbzv1Lq5ln6MDC0ZuIfxCvPtSvXz+WLl36zHYsLC6Fmbuu8yg+lbbudvSt7yI7BAhRDBRKAmDnzp253uDrr7+md+/e+Pj4ADlz/dauXcuUKVMYPHjwa4RfPElDL4qbzKxsNl14wK5LYaRkZKGrrUXjSla0rGZbLOfnZWZmcvDgQdasWcOmTZuIi4t7bl17e3u6dulC9xa1aWIRiXaoP2Rl/H9UgC9UaauRUQH/lJaVxq2YWzkjBKKuczf+Lipy/jk10TGhqkVV9YKCNoY2khAQBao4tEnSL9D8MxAi35KjYcMAss0rsLKMF0O6DiE56ulInTFjxvD9998/89T41Ax+2BNEUHgCtZzNGd68crFZl0iI0qpQEgBK5csNMVYoFM/dJ/xNJg29KK5SM7I4fiuSfVfDuRuVBEAlG2NaVbOjXgUL9LSLX6OcmprKrl27WLNmDdu3byc1NfW5da2srOjcoR3d6pajhWUEekkPcg5YVMiZHlC+KegZF1Hkz5eckcyNmBtci77GtahrhCY+nVdpoW+hXj+gqmVV2XJQvLbi0CZJv0Dzz0CI13JsTs4WgW99z5GQSNq2aEtKQor68MyZMxk7duwzT03PzGbh4WBOBEdS3sqIsW2qYm6kW0SBCyH+rUi2ASxtpKEXxZ1KpeJWRCJ7r4Zz8nYUGVnZGOtp09TVhlZuttiZaWbo/IskJCSwc+dONm7cyM6dO0lKSnpuXVNTU7q0bcbbtW1oZf0YXTJASxdcGkLlNmDrDsXkm/YnWw5ejbrKtehrRCQ/nf5gY2hDVfOqVLWsiqu5K+b65v9xJSHykjZJ8+QZiDdezD3YOhTK1YPmEzh27BgtW7UkLTVNXeWnRT8xfPDwZ56uUqlYd/Y+my88wNJIj3oVLDA10KGMoS5lDHQwM9ChjKEOpvo6Mk1AiEImCYD/sXfX4VEdbQOHfxt39wSSQAS3QHB3K0VqVKDeUi8FKm8Ldcnblhba0r4VWvq1FHd3dwsQSALBE+JGPDvfH1sWQoQEEnZDnvu69iJ7zuycOTshM/vsSDWKiIggIiKC4uJiUlNTpaEXtUJWXiGbo5NYe/wylzN136438XakS7Ar4YGu2Fka11oBV+Xm5rJmzRrmz5/PkiVLKpwm4OTkxL292nF/c1t6++VjYWYCDr4Q0g8a9gJr4/pQnZKbQlRqFCdST3Ai9QSpean6c542njRyaUSoSyiNnBvhZOVkuIKKWkE+fBqe1IG4K6ydDBf3w/AfwdGX5cuXM2zYMP2oHY2Jhqe+fIoOfTpgZ26ne1iU/Pfg2Tz+3nWZonIG+mjQYG9lhpONLjjgYGWGg7UuMGB/3c8O1mbYW5lja2Eq0+aEqKI7EgBYsmQJERERREVFAdCkSRMmTJjA0KFDbyU7oycNvaiNlFJEXsxg3fHLHDiXTpFWi5mJCa3rO9E5yI3W9Z2McooAQEFBARs3bmTBggUsXLiQpKSkctM6OzkyvGtT7m9iRq8gW8zNTcE3DBr2hnrtwcy4hiUqpUjOTeZE6glOpp0kKiWKtPw0/XlPG09CnUMJcQ4hxCUEVytX6QyJEoyxTaor/QL5YkDcVeIPw+p3dAvtdhwHwB9//MGYMWP0STQmGrxbeRPUO4j6netjblV6hwANJvSrdw+tXXuSnlNIek4BGbmFZOQWkp7z77+5uuOFxdoKi2RqosHXyZqxnQJp4uNQvfcrxF2qxgMAM2bM4NVXX+XJJ5+kc+fOAGzbto3ffvuNqVOn8uyzz95ayY2YMXa2hKiK7Pwidp9OYXtsClHxmSgU1uamtAt0oUuQG019HDE10iF6xcXFbNu2jblz5zJv3jwuX75cbloXJweGd2jAA80s6NnIFTMrOwjsqgsGeDQ2mikC17s+IHD1cX1AwNnSmRDnEIKdgwl1CcXH1kcCAnWcsbVJ0i8wfB0IcUuUgqUvQ8YFuG8mWDkC8NVXXzF+/PhSyW1sbeg5qCe97u1FaHgoOdocrhRcISo1iqTcJAYEDOC+kPvKbaOUUuQXacnMLSQzr4jMvEL9z1l5ukBBZm4Rxy5lUFisZUBTLx4Mry+LDApxEzUeAAgKCmLSpEk8/fTTJY7/9NNPfPHFF8TGxlY1S6MnDb24myRn57PzVAo7TiUTl6ybc+9obU7HBq70aeKJn7ONgUtYvuLiYrZu3cqcOXOYN29ehSMD3JztGdmuHg+0sqdbqCumjt66QEDDXmDveQdLXTVXAwIxaTFEp0UTnRZNQk6C/rytmS3BzsH6oIC/gz9mJsY5rUPUDGNrk6RfYPg6EOKWndoIW7+EVg9Dq4f0hz/88EMmT55MeR8VfHx8ePjhh3n00UcJDA3k6/1fE5cZR1ffrjzW5DFMTW79Q/vF9FxmbDpFTGIWHvZWPNe9oYwGEKICNR4AsLS05NixYwQFBZU4HhsbS7NmzSpc0bu2koZe3K0upOWwIzaFbbHJJGbp/u+G+TszrJUvIZ72Bi5dxYqKitiyZQtz5sxh/vz5JCcnl5vW08WBUW09eSDMjc5Bzph4N9MFAvw7G8UuAjeTkZ9RIiBwPuu8fttBcxNzAh0DCXYKJsg5iCCnIGzNjW8rSFF9jK1Nkn6B4etAiFtWXATznwRtEYz6rcS0ubi4OP78809mzZpFTExMuVm0bNmSXn16ccnuEjluOfQI68FL4S9hblp6ukBlabWKZZHxzN13XkYDCHETNR4AaNq0KY899hiTJk0qcfyzzz7jzz//5OjRo1XN0uhJQy/udkopTiRksezIJfaf1Q0/b+TlwLBWPrSq52T0Q86LiorYtGmTPhiQmppablofVwfuC3NjVJgnHUPcMK3fHhr2BL92cBudlTsptyiXU+mniEmLISY9htPppynQFujPe9t660YI/BsUcLd2N/o6FJVnbG2S9AsMXwdC3JajC2Dfr9DxRQgdUOq0Uordu3cza9YsZs+eXWEbC7p1A1x9XekU1omWzVvSrFkzmjVrRnBwMObmVWtnrx8N4OmgGw3Q2FtGAwhxvRoPAMydO5eHHnqIAQMG6Of6bd++ndWrVzN79mxGjhx5ayU3YtLQi7rkfGoOSw5fYntsMlqlqO9iwz0tfenY0NVo1wm4XmFhIRs2bOCff/5h4cKFpKenl5vW3dGGe1q4cm8bT3q3qo91cHddMMCzmVGuF1CeIm0R57POE5MWQ2x6LLHpsaTnp+vPO1g4EOwcTJBTEMHOwdS3ry/TBmoxY2uTpF9g+DoQ4rYUXIG5Y8HaBYbPqLD9KygoYMWKFcyaNYtly5ZRUFBQbtobWVpaMmTIEMaNG0fPnj0rHZiW0QBCVOyO7AKwd+9epk6dql/tt3Hjxrz22mu0bdv2VrIzetLQi7ooKSuf5UcuseFkEgVFxbjbWzG4uTc9G7kb7e4BNyooKGDt2rX8888/LFq0iKysrHLT2lqZMaCZG8NaezK4Y2NcmveDBj3AJfDOFbiaXL+OQEy6LihwMfui/ryFiYVu2sC/QYEgpyBszI137QdRkjG2SdIvEKKW2/szHFsEvd+DeuGVeklqaipz5sxh2bJlHD16lLNnz1b6co0aNeL555/nsccew8nJqVKvuXE0wDPdGtDUx7HS1xTiblWjAYCioiJee+01xo8fT0BAwO2Us1aRhl7UZZl5haw+msDqYwlk5xdhb2XOsFY+9GvihYWZiaGLV2l5eXmsXr2af/75h6VLl5KdnV1uWlMTDd1DXbi3jSf3dm9DvXaDILAbOPrewRJXryuFV/TTBmLTY4nLiNNPG9CgwcfOh4aODWng1IBAx0B87Xwx0dSe+q1LjKlNkn6B4etAiGqRnaRbC8CjCQz87JayyMzM5Pjx4xw9epSjR4+yed9mTh4/SW5abrmvsbGxYfTo0Tz//PO0adPmpte4cTRA54ZuPNzBHxdb49ryV4g7qcZHADg4OHD48GECA2vft2K3Shp6ISCvsJiNJxJZcvgSaTkFuNpZMirMj27B7rViasD18vLy2LBhA4sWLWLx4sUkJiZWmD68gRMj2ngxvFdbQroMg4CuRr2TQGUUaYs4l3VON0ogLYZT6afIKMjQn7c0tSTQMZAGjg1o6NSQBo4NcLSUb1qMgbG1SdIvMHwdCFEttkTA6c0w+CtwD6mWLHdc3MH327/nyoUruJxyYcFfC8qdmte+fXvGjRvH/fffj5WVVYX5XkrP5fcdZzh8IR1LM1NGtPFlUHNvzE0lcC3qnhoPADz66KO0a9eOl19++ZYLWdtIQy/ENflFxaw+dpnFBy9ypaAIXycbHgyvR1t/51q50FxxcTG7d+9m0aJFLFy48KZbljXztWdEmBcj+rSnRc/haAK7g63rHSptzVFKkZqXyumM05xOP83pjNOcyTxDobZQn8bFyoWGTg0JcQ4hxDkEPzu/WlnntZ2xtUnSLzB8HQhRLVJOwdJXdEHuHpNunr6SDiUe4odDP1BcnI+Z1orYTbFELokkMbrs4Ludkx3Tv5nOmMfGVJivUor9Z9P4Y+dZErPy8Ha05rGO/rSu71xtZReiNqjxAMCnn35KREQE/fr1IywsDFvbkttNjRs3rqpZGj1p6IUoLTu/iKWHL7HyaAIFRcUEe9jzUHj9Wr1Xr1KKqKgoFi1axKJFi9i7d2+F6Ru42+iCAX070n7gaEwadAVL494+sSqKtEVczL7IqfRT+sBAQk6C/ryNmQ1BTkH6gECAY4AsLngHGFubJP0Cw9eBENVm1dtwORJG/Fx9I91S44je/gXLU46Q7xdGsZ0nxaqYc8fPsXfBXo6vO05RQVGpl/3nP//hgw8+uGmguaBIy7Ijl1h06BIFRcW0ru/MmI4BeDlWPIpAiLtFjQcAKhrip9FoOH36dFWzNHrS0AtRvrQrBcw/cIENJxLRKkWres482K4eAW61fy/68+fPs2jRIhYsWMCWLVvQarXlpvVwsGBwS0+G9ulK31GPYxfavdZsK1gVWQVZxKTFEJ0WTUxaDGczz6JF975cXVwwxDmEEJcQGjo2xMpMOmDVzdjaJOkXGL4OhKg2F/bBuinQZBiEP317eeVnwcH/gxPLdM/NLEFjAkO+Bsdr/29SU1OZOXMmP/zwQ6lReA899BC//vrrTacEACRn5/PnrrPsOp2CmYkJQ1p4c29rX9ktQNz1aiwAkJqaiouLy20XsDaShl6Im4vPyOWfvefZdToFgE4N3RjYzIsgD7u7Yph4UlISS5YsYcGCBaxdu5bCwsJy01qYmdCriQdD+3ZlyINPUz+sT63aVrAq8oryOJV+iui0aKLTojmdcVo/bcAEE/wd/AlxDiHUJZRg52BszWt/YMjQjKVNkn6B4etAiGqnFCwaB1eS4L6ZYGlX9Ty0WohZAwf+gPxMcAuG9s9DQTasfQ+c6uvWGTC3uuFlWmbNmsXTzzxNYcG1NrZz584sXLgQd3f3Sl3+6MUMZu44w4W0HFxsLXiySyBh/nXzb5WoG2osAGBqakp8fDweHh4APPHEE3z++eeV/s9Ym0lDL0TlnUrKZvaec0Re1C0oV9/Fhj6NPekS7IaNxd0xPDwjI4MVK1awYMECVqxYQU5OToXpW/g7M7R3Z4Y++ATteg/DxOTuXaSoUFvI2YyzRKdFczLtJLHpseQWXVsB2tfOVz9lINQ5FCcrJ8MVtpYyljZJ+gWGrwMhakTMWtj+DYSNheajqvbapJOw6wdIiQUrR10eQdcFwQ/PhoN/QmB36PZGmcHxrVu30n9of3IzrrUdDRs2ZPny5YSGhlaqGMVaxdrjCczZd4GcgiLubeXL/W3rYVLLFi0WojJqLABgYmJCQkKCvqG3t7fn8OHDNGjQ4PZKXAtIQy9E1cUlX2Hd8ctsP5VMXmExFmamdG7oSu/GnjR0t70rRgUA5Obmsn79epYuXcqyZcu4dOlShek9nawZ3KMDQ+9/lD5D78PO7ha+XalFtErLhawL+hEC0WnRZBZk6s+7WbnR0KkhQc5BBDkF4Wfnh6mJDNesiLG0SdIvMHwdCFEjigth3uOABkb9BqaVCN7npsH+3yF2ne5DfaOh0Gp06REESummGFzcDx2eh0aDy8xuzb413HfvfWRevNZeODs7s2DBAnr06FHpW0nMyuPrtdHEJV+hhZ8TL/UKwt7q7pueJ+o2CQDUAGnohbh1uQXFbI9NZv2Jy8QlXwEg0M2W3o086RzkhrXF3fNhTynFwYMHWbp0KUuXLmX//v0Vprc0N6Vn+xYMHfEQQ0Y+QP369e9QSQ1HKcXlnMv6YMCp9FNczrmsP29hakEDxwYEOQXpAgNOQTJt4AbG0iZJv8DwdSBEjTkyRzeEv157sPMAEzPdujYm5v/+++9zUwvdh//IuVCYC14toP0z4BxQft75WbrdBnJSYOAX4F72t/pfbPqCr17+isuR19oIc3Nzfv75Zx577LFK30p+UTG/bjvD5uhE3O2teL1vCIF3wTpFQlxVo1MAEhIS9EP77O3tOXLkSJ3Y91caeiFun1KKU0lX2HDiMttiUygoKsbK3JQODVxpH+hCM1/Hu27/3osXL7J8+XKWLl3KunXryMvLqzB9i9BAht47kqHDR9GuXbu7eqrA9TILMjmdfpqY9BhOpZ8iLiOuxPaD3rbeBDoG0sCxAYGOgdSzr1endxswljZJ+gWGrwMhakx+Fix8DvIyKpfexhXaPQUBXSq35k1yLKx4QzdNYOg3YO1UKklSThKTNkxi7/S9HF19tMS5d999l/fff7/SowmVUqyLSuT3HWfQaOCprg3oHnL3T1cSdUONjgAYOnQolpaWACxcuJB+/fqV2u5nzpw5t1Bs4yYNvRDVK7egmK0xSayPSuRsqm5UgLW5Ka3rO9MuwIVW9ZzuqpEBADk5Oaxfv55ly5ZVaqqAl7szQ4fcw7CR99GrVy+sra3vUEkNr0hbxLmsc5xKP0VsWiyx6bGk5afpz5tqTKlvX58GTg0IdAikgVMDPG0875ppJTdjLG2S9AsMXwdC1KjiQii4ovtXWwjaIt3PV59f/RnAu2WpRf1u6uQq2DkdfFpBnw+gjKD33Oi5rDi9AtbCzK9mljj34IMP8sknn1Qp6BhzOYuv1kaTllNA3yZejOnoj9ld9uWDqHtqLADw+OOPVyrdb7/9Vtksaw1p6IWoORfScth7JpU9cWnEJWcDYG5qQnNfR9oFuhDm74zDXTZfTynFgQMH9OsG3GyqgI21Jf379GHYyPsYPHgwbm5ud6ikxiM9L50zmWc4nXGauIw44jLiyCm6tviitZk1gQ6BBDkHEewcfFdvQWgsbZL0CwxfB0LUakrB9qkQux5aPgitHymVJLcolze3vAlAy/Mtef6Z5ykoKCiRpk2bNowaNYqRI0cSEhKiP16sLWbD+Q363WiuysgpZOr6aKLiMwnxtOfVPiG42FrUzD0KcQfUWACgLpOGXog7Izk7n31nUtkdl8qJ+CwUCg0aGns70KGBC52D3LC1vPuGfl+dKrBs2TLWrVtHbm5uuWlNTEzo3KEdw0bcx5AhQwgJCakz33xf7+paAnEZcfqgwLnMcxSpIkC3BWE9h3oEOwUT7BxMsFPwXbPjgLRJhid1IEQ1KcqH5eMh7Qz0mQJ+bUsl2Xx+M78f/50BAQPwTvRm+PDhpKSklJld8+bNGTlyJIOGDWJTwSai0qJwsnTi826fY25y7cuEomItf+85x/LIeByszHmtbwiNvR1q6CaFqFkSAKgB0tALcedl5BZy4Fwae+JSibyQQZFWi4WZKe0DXejVyINGXvZ35QffnJwc1q1bx5IlS1i6dCmJiYkVpg+s78eAQUMYMHAgPXv2xN7e/g6V1Phc3YIwJj2GmDTd40rRFf15N2s3QpxD9EEBb1vvWvk7JG2S4UkdCFGNMi/B0ldBY6JbD8Des8RprdIyZccU4q/E83GXj8m8lMnzzz/P+vXrqeijjKOfI017NcWrqxcv9nuRnvV7lkqzIzaZGVtOU1Ss5eH2/gxq7lUr2wVRt0kAoAZIQy+EYeUWFLPjVDIbTiRyKkk3TcDb0ZqejTzoHuyOo83dNUXgquLiYvbs2cPixYtZvHgxJ06cqDC9ubkZXTq2Z8DgexgwYADNmzev0x0ZpRTxV+J1wYD0GKLToknOTdaftzO3I9g5WBcUcA6mvn39WrG4oLRJhid1IEQ1O7cLNnwErg1hYASYlRySH5USRcS+CNp4tOHF1i8CEB8fz8KFC5k/fz6bNm1Cq9WWmbWJqQkD3xrIovcXlfk3/lxKDl+tPUlCZh7hga48373hXbcOkbi7SQCgBkhDL4TxOJeS8+9OAslk5xdhaqIhrL4zPRt50NLPCROTu/cDb3R0NEuWLGHJkiVs37693M7OVT6e7vQfMIChw4aXuThbXZSel64PBsSkxXA+6zwKXVNoYWJBA6cGhDiHEOIcQkOnhliaWhq4xKVJm2R4UgdC1ID9MyFynm4ngYa9wd5L9zDVBfm/PfAth5IOMandJEJdSm4dmJiYyKe/fsrceXOJPxSPtrhk+6gx0fDRTx/x9pNvl3npnIIiZmw6xZ4zqXg7WvNanxDqu9rUyG0KUd0kAFADpKEXwvgUFGnZeyaVjScSOXpJt02Rq60lvRt70KeJ5123cOCNUlJSWLduHatWrWLVqlUkJCRUmN7aypJ+/fpx7/ARDB06FFdX1ztUUuOWU5jDqfRTuoBAegyn00/r1xEw1ZjSwLEBjVwa0di1MQ0dG2JuavjfK2mTDE/qQIgaoC2GNe9CwpGSx23dwN6HBGs73k3Zha+tD++FjcfEOQBMzSnUFjLr+Cy2XdyGp40nYwLHsGfDHubOncuyZcv02Ziam7Js6TIG9B9Q5uWVUqyITOD/dp/FzNSEp7oE0k22ChS1gAQAaoA09EIYt8TMPDaeTGTTySTScgowNzWhe4g7A5t74+t092+fp5TiyJEj+mDAtm3bKCoqKje9qakpXbt2Zfjw4QwbNgx/f/87WFrjdnUdgei0aE6knSA6LZqCYt2K0+Ym5jR0akhjl8Y0dmlMgGOAQaYMSJtkOBEREURERFBcXExqaqrUgRDVrbhIFwDISoCs+GuPzHgoLmA2WazhCo/jSFfHYDL7vMd3x38nJj2GJi5NeL7V89iaXxvt9uWXX/LGG2/on1tZW7Fu7To6d+5cbhFOJGTyzboY0nIK6N3IkzGdArAwk60ChfGSAEANkM6WELVDUbGWXadTWR55ibhk3eJvres7M7i5N019HOrMfPjMzEw2btzIqlWrWLp0KRcvXqwwfZs2bbj33nvp378/YWFhmJrK3MerirRFnMk4Q1RqFFGpUcSmxepHCFiaWhLiHEJj18Y0dW2Kn53fHfkdkzbJ8KQOhLjDlILcNK6kxfHmgf9ilp/NuOx8frQ2IdXRh97+vXkw9EFMTUq3X1OmTOH999/XP3dwcGDjxo20adOm3Mtl5BTy7YYYjl3KINDNltf6hODhcHduLStqPwkA1ABp6IWoXZRSRMVnsTzyEgfOpqNQ+LvYMriFN50aumJmWnci+Uop9u/fz8KFC1m4cCFRUVEVpnd0dKRHjx706tWL3r1706RJkzoTOKmMwuJCYtNjOZF6guMpx4nLjEOrdHNNHSwcaOLahKauTWnq2rTGth2UNsnwpA6EMJz159bzf8f/DzLOYZKbwaOBQ+jefXK56ZVSjB8/nq+//lp/zNXVlS1bttCkSZNyX1esVczdd55Fhy5ia2HGuJ5BhPk7V+u9CFEdJABQA6ShF6L2is/IZUVkApujkygoKsbZxoL+Tb3oGuyGq53xLfBW006ePMmiRYtYtGgRu3btuml6Ly8vfTCgd+/eMl3gBnlFeZxMO8mx5GMcSzlG/JV4/TlvW29dMMCtKaHOoViZVc+3R9ImGZ7UgRCGU6wt5oNdH5Cam8wL6VdolJUMvd+DeuHlvkYpxdinxvLHr3/oj/n4+LB161YaNGhQ4fX2n03l+42nuFJQxOAWPgR72KEUKJTuXwVapVtOVv37r5O1Oa3qOVUYQM8ryiO/OB9HS8eqvgVClCABgGokc/2EuHtk5RWyPiqRVUcTSM/VzekO8bSnfaAr4YEuuNvXvWDApUuXWLx4MQsXzGfLlq3kFxTc9DVBQUEMGjSIIUOG0K1bNywt6977VpHUvFSOpxznWPIxjqccJ6swC9AtKDgieAQDAwfe9jXkw6fhSR0IYVj5xfkAWOakwdJXdJ/Ch3wNjr7lvqa4uJhuw7qxY/kO/bGAgAC2bt160//HiZl5fL0uWj+9sDIGNPViTKeAMoMAOYU5fLTrI1LzUnm97euEOIdUOl8hbiQBgBogDb0Qd4/CYt3uAbtPp3LwfDoFRcUANHS3IzzQhQ4NXPGsg/P8cnNz2b59O+vXrmX9muXsP3IcrbbiJsLW1pa+ffsyZMgQBg0ahLe39x0qbe2glOJC1gWOpehGB/Sq34vWHq1vO19pkwxP6kAII3JhH6ybAk7+MPi/YF7+4r9JWUm07deWc7vO6Y81atSIzZs34+HhUeFlCoq0HDqfTmGxFg2ABjRoMNGARqNBo4GrOxEvPRzPiYRMuga781z3hphet0WxVmmZemAqR5OPYoIJFqYWjG87noZODW/jTRB1mQQAaoA09ELcnfIKizl8Pp3dcakcOJdGXqEuGBDgakv7Bi60D3TFpw7sIlCW9PR0Nm3cyPrlC1i/YQNRcZdu+pqwsDAGDx7M4MGDadu2LSYmdWethTtJ2iTDkzoQwsgcng0H/4SArtB9IlQw9P6Xg7/w7hPvEn/o2pStVq1asXHjRpycnKqlOPlFxXy9NoZD59MI83fmld4h+p0E5pycw6ozq+jo3ZGufl2Zun8qpiamvNH2DQIdA6vl+qJukQBADZCGXoi7X0GRlsiL6ew6ncr+s2nkFOhWeg/1tKdPE0/aB7rW6W2A4uPjWb90LisXz2Xllr2kZedXmN7Dw4OBAwcyePBg+vbtW22dKiFtkjGQOhDCyCgFGz6E83ug3ZPQdHi5SVNyUxi/Zjwb/rOB80fP64/7+PgQFhZGaGgojRo10v/r5uZ2S0UqKtby/aZT7DiVTFMfR97oF8rB5N38HPkzgQ6BTAqfhIWpBcdSjvHN/m+wNLVkQrsJ1Heof0vXE3WXBABqgDT0QtQthcVajl7MYFtMMrvjUinSarGzNKN7iDu9G3vW2VEBVxUVFbFrwwqWzZnJ8nVbOXo2ucL0pqamdO7cmcGDBzNo0CCaNm0qOwvcBmmTDE/qQAgjVHAFlr0GWfHQ7yPwbllu0t+P/c6aE2s4MOUAJ46eqDBbFxcXQkNDcfBzoMi9iBcefYHhHcoPMFxPq1X8uj2OdVGXcXfJ4IrdfJys7Hm3w7s4W13bUeBI0hGmHZyGlZkVk9pNws9e/q6IypMAQA2Qhl6Iuiszr5DNJ5NYH3WZhMw8AJp4O9KnsQftAl0wr0NbCpbnbNQhlv/9I8tWrmHDoTPkF2krTF+vXj0GDRrE4MGD6dWrF7a2tneopHcHaZMMT+pACCOVdhaWvw5mVjBkKti5l5ksKSeJt7a+hZfyYsHrC266Re71NKYa+j3Yj5lfzsTL0+um6ZVS/LbzGL+ciMDcvICvek+mjU+jUukOJR5i+qHp2JrZMil8Ej52PpUuk6jbJABQA6ShF0IopTh2KZN1UZfZeyaVYq3Cwcqc7qHu9Grkgbdj3R4VcFVOyiXWz/mJFSuWsWLncc6l5FaY3tzcnM6dO9O3b1/69u1LmzZtMDU1vUOlrZ2kTTI8qQMhjFjcVtj8ObgFw4DPwcyizGQ/R/7Mjks7eLX5qxxce5DDhw9z8uRJTpw4wZkzZ9BqKw5mW9pYMnHSRN58401sbGzKTVdYXMjnez9nz8UotKk9CbBtwzuDG5fZb9iXsI8Zh2fgYOnAxHYT8bK9eYBBCAkA1ABp6IUQ10vPKWDTySTWn0gkKUs3KsDHyZrW9ZxoXd+ZRl72mMnIAFT+FY5vms+KRf+wfPNetp1MpvgmOwu4uLjQu3dvfUAgICDgzhS2FpE2yfCkDoQwcvt+haMLILgfdH65zCQJVxJ4Z9s7NHJpxIR2E0qcO3n5JF+v+Zro6Gi0l7U4ZTpx6fQl9u3bx40fnzy9Pfnko08YM2ZMqQC2Uopfjv7Cjks76OffDw968r8tcThYm/H2oMb4u5YeAbc7fjc/HfkJJ0sn3gx/E3ebskcxCHGVBABqgDT0QoiyKKU4fCGDnadSOHgujcy8QgCszU1p7utI6/rOtKrnhLNt2d8+1CnFRWTE7mLtgj9YsWYjKw6c53JmxQsJAgQHB9O3b1/69etHz549cXBwuAOFNW7SJhme1IEQRk5bDGvehYQjEDoIAruCe2MwNSuR7MfDP7I7YTdvh79NkHMQBcUFLIpdxOozq9GgYWDgQO5peA/mpuYAREZGMmnSJFauXFnqks2aNePzzz9n4MCB+nVuVp9ZzT8n/6Gpa1NebfMqpiam7DqdwvQNsViYmTBpQCNCvexL5bXj4g5+OfoLLlYuTAqfhJt16YUIlVJkFWaRnJNMYm4iaXlpNHBsQIhziKyzU8dIAKAGSEMvhLgZpRSnk69w8Fw6B8+lcTrpCgrdn9hAN1ta13Omjb8TDd3tpGFWCm1yLIfWzWXtmlWs3RPF1uhUCm6ydoCpqSkdO3akf//+9OvXj7CwsDo5XUDaJMOTOhCiFshNh5WTIPOi7rm5NXi3At8w3cPOnYvZF3l3+7s0d2vOoMBB/HbsNxJzEqlvX58nmj1R7or869evZ8KECRw8eLDUuV69evHZZ59h6m3K9KPT8bT15D8d/oOt+bVv+49cSOe/a6LRahX3t6vHkObemJiU7BtsvbCV3479hpu1Gw81eoi0vDSScpJIyv33kZNEXnFeqevXt69PP/9+hHuHY2ZiVuq8uPtIAKAGSEMvhKiqjNxCDp9P58C5NI5cyNBvK+hia0G7ABfCA11o5OWAqUkdDwYA5GeTE7eHrSvns3bjFtYcPEvkhaybvszZ2Zk+ffroAwL16tW7A4U1PGmTDE/qQIhaQquF5Gi4uA8u7ofkmGvnHOuBbxu+yzvL/pwLoDHBTGPGsKBh9A/of9MPz1qtlr///pu333mbc2fPlZvO0tISKysr/cPa2horKyswNSfLxA7nRu3p0XcQE+5th4e9VYnXbjq/iT+O/1HimAYNzlbOuFu7427jrv/X0cKRvQl72XFpBwXaAhwtHOlVvxc96vXA3qL0KANx95AAQA2Qhl4IcTuKirXEJGaz70wqu+NSSc7WDX23tzKnrb8z4YEuNPN1lB0FrsqMJ+HwetatWMTabftYE5lAQsbNpws0atSIfv360b9/f7p3737X7i4gbZLhSR0IUUvlZcClg7pgwMUDkJfBeQr5SJNOgLUHj9frg5dPO3ALBVvXymWZl8f06dOZ8uEUrmReuaViaTQmeIa24r6RI5nw7KMlAtrHko+RkJOAh7UH7jbuuFq7Ym5iXm5e2QXZbLqwiQ3nNpCen465iTmdfDrR17+v7Cxwl5IAQA2Qhl4IUV2UUpxJyWFPXAp74tK4mJ4D6NYNaFPfmXaBLrSu74SlWd0b2l6m4iJUYhRHNy9kzaqVrN4Xy5aTqTfdatDCwoKuXbvqAwItWrS4a6ZeSJtkeFIHQtwFlILU03BxP7kX9mKVHItGW3jtvI2LLhDgHgrujcA1CMytys0uNTWV1/7zGn/+/CfaworbqJtp2y6c+0aNZOTIkTRs2PCW8ijSFrEnYQ9rzqzhXJZuhEIz12b0C+hHU9emd02bKCQAUCOkoRdC1JQLaTnsO5PG7rhU4pKzAbCxMKNbsBu9G3tSz6X8rYXqpMxL5MZsYeuqRazZtpfVkUkcvXjz6QKenp76YEDfvn3x8PC4A4WtGdImGZ7UgRB3IW0xpJ3RTRlIOgFJ0ZBx/tp5jQZcGkKnl8C1/A/lUWeiWLNtDT6WPuTn55Obm0teXp7+cfV5Tk4OO3fu5MiRIxUWq0WLFtx///089dRTeHp6Vvm2lFJEp0Wz5uwaDiUeQqEIdgrmgUYP0MCxQZXzE8ZHAgA1QBp6IcSdkJiVx564VDacSORSei4Ajbwc6NPYk/BAFyzMZIpACfnZcHE/lw6uZc2ataw5fIG1x5JJzi646UtbtWql312gS5cuuvmYtYS0SYYndSBEHVFw5d+AQDQkn9RNHTC3gQGfgnNAtVwiJiaGhQsXMn/+fPbs2VNuOnNzcx544AFefvll2rVrd0vXSsxJZPnp5Wy7uA2FoqN3R0YEj8DVunLTHYRxkgBADZCGXghxJymlOJGQxbrjl9kdl0qRVoudpTndQ93p09gDb0drQxfR+GiLITEK7YV9HNy6mtXbD7L6aBI7YtMoKq64qbOysqJbt276gEDz5s2NemiktEmGJ3UgRB11bjds/Bgs7WHAZ+BUvYvPnj9/noULF/LP3Hns3LEdpS17KkGHDh14+eWXGTlyJBYWVd9q+HzmeWafnE1UahTmJuYMCBjAwMCBWJnVnmC4uEYCADVAGnohhKFk5BayOTqJ9VGXuZyp2+6nqY8jfRp70i7AGTNZOLBsuelw6QBZMdvZuG4tqw+eY83RJGITc276Uk9PT30wYODAgbi5ld5/2ZCkTTI8qQMh6rAz22DTZ2DtDAM/B4eaWVgvIeEyH33/B/Pm/MPlk/vLTOPp5c0L457nmWeeqfL0AKUUR5KPMOfkHOKvxONo4cjw4OF08e2CiUb6FrWJBABqgDT0QghDU0oReTGDdccvs+9sGlqlsLcyp2uwGz1CPKjvKmsFlEspSImFiwc4tW8da7fsYu2xZNYfTyYjt6jCl2o0Gjp06MCQIUMYMmSIUYwOkDbJ8KQOhKjjTm2ErV+CrRsM/ALsam5dmeQLMSzfFcWvs2azY9VCigrySqUxNTenc997eOSBUbRuEoSvry8eHh6Ymt58QeEibRGbL2xmUewirhRewc/OjwcaPUBT16Y1cTuiBkgAoAZIQy+EMCZpVwrYeDKRTSeTSMzSdQQC3ezoGepOpyA37Cwr3ru4zsvPgov7KYrbxb5t61hz6DxrjyWx81Q6xdqKm0U/Pz99MKBnz57Y2Nz5wIu0SYYndSCEIGYtbP8G7Dx1IwFsa2C02MUDsP59sHSAe78nLaeIn37+henTpnPh/NkKX2pmZoa3tzd+fn74+vrq/61fvz49e/bE3d29RPqcwhyWnV7G2rNrKVbFhDiHYGNmQ6G2UPcoLrz283XPPWw8eLv921iYVn0qgqgeEgCoAdLQCyGMkVKKqPgsNkUnsut0KgVFxZibmtAuwIUeoe4093U0+LfVRu/ftQO4sIfMk9vZtOcIa44mseZYMjGXK97P2crKit69ezN48GAGDx5M/fr170iRpU0yPKkDIQQAJ1bAru910wAGfKbbOrC6JJ6A1W+DKta1Vf6doceboNFQXFzMsmXL+Pbbb9mwYUOVs7aysuLpp59mwoQJ1KtXch2DpJwk5kbPZf9l3bQDcxNz3cPUHDMTs2vPTcwp1BZyLusco4JHMajBoNu6XaUUK+NW0tCpIaEuobeVV10jAYAaIA29EMLY5RYUs+t0ChtPJhJ9WbctnqudJd1D3OkZ6oG7vaWBS1hLZMbDhb1wfjcxh3ay/PBllh2+zJboNAqLKt7XuWnTpgwePJhBgwbRqVMnzM3Na6SI0iYZntSBEELv+GLY8z9wrKfbHcDa6fbzTDsDK9+E4gLo9yEcXQDnd0OXVyGoT4mkR48eZdq0acyePZvMzMwqXcbc3JwxY8bw5ptv0rBhya0Ni7XFmGhMKvwiobC4kLe2vUVeUR6fd/scW3PbKl3/ervid/HTkZ+wMrXiw84fys4EVSABgBogDb0Qoja5lJ7LppNJbI1JIi2nAA0aWtV3ok9jT1rXc8LEREYFVErBFd2WT+d2kxm9g7WHz7HscCIrIpNJzCg9B/N6jo6O9OvXj8GDBzNgwIBb2ru5PNImGZ7UgRCihMh5sH8mOPtD/0/ByuHW88pKgBUTIC8Der8Hfm11Py9+AQrzYNh0sPcq9TKlFKmpqVy8eJELFy4Qd/Yc2w5Hc/jkadISE8jNSKYgI4nc7NJBAhMTE0aPHs1bb71FkyZNqlTcbRe38evRXxkQMID7Q++/pVvOL87nra1vcaXwCoXaQhq5NGJC2wkyirGSJABQA6ShF0LURsVaxaHzaayLSuTQuXQUClc7S3qFetCrkQfOtjJfr9KKi+DyUTi/G+2Znew7Fsvyw4ksO5LEgTPpN315u3btGDRoECNHjqR58+a3VRRpkwxP6kAIUcqhv+HQ/4FrQ+j3MVjaVT2PnFRYOVEXBOj2BjToce3chf2wbjK4N9KtOWBy8wX+QNcX2B2XwvIj8ZxKyib17Ali18wibt/GUmk1Gg0jRozgnXfeoXXr1pXKX6u0vLf9PZJyk/i066e4WFV9GsTCmIUsPb2UB0Mf5EL2BbZd3MaDoQ/SL6BflfOqi6rSJskqUUIIcRczNdEQ5u9CmL8LSVn5bDhxmY0nkpi7/zzzD1ygrb8zfZp4yloBlWFqBj6twKcVJuHPEJ4WR/i53bx/fhfxp46x8kgSKyITWXMshazcwlIv37t3L3v37qWgoOC2AwBCCCGMUMsHdUP2I+fC2neh00vg0qDyr8/PhrXv6T78t3+u5Id/AL8waDQETizTXaPlg5XK1tREQ6eGbnRs4EpMYjYbTnhwqlUbjh49yvFVf3B+7zqU0k1xU0oxf/585s+fT/8BA3lh3PP069cPS8vypxGaaEwYFTKKbw9+y+LYxTze7PHK3zOQnJvMqjOr8Lb1plf9XhRqCzmRcoJ50fNo6tYUXzvfKuUnKiYjACpJIv1CiLtFUbGW/WfTWBd1mciLGQB42FvRq5EHbeo7U8/FWoIBVZWbBpcOwsX9FJzdx7bIs6w4ksjyyGROXMoqkXTbtm107tz5ti4nbZLhSR0IIcqkFOz/TTdnH6B+R2g1GlwCK35dUT6s+Y9uUdpWD0Orh8pPt/RVyLwAg74E95CqlS8nFaJXQ4Pu5Fl7cjYlh637jvDr91PZvWYR2uLSW+M6ODhw7733ct9999G3b98ygwFKKT7d8ymn0k/xYecP8bHzqXSRfjj0A3sv7+XVNq/Swr0FACdTT/LF3i+oZ1+P/3T4D2Ym8r11RWQKQA2Qhl4IcTdKyMhj/b+jArLzdd9aO1qb08LPiea+jrTwc8TJRqYJVIlSkBILF/bBxf2cPnaAFUcSWXEkkSOXizh7KalS+zJXRNokw5M6EEJUKCkaDv+lawsA/DtBy4fKDgQUF8GGD3VrzjQeCuHPQEWB+JRTsPx13faDQ78Bc+vKlenCPtj6FeRngqkFtHsKQgfqr3X27Fk+/ewLfvvtFwry88vMwtHRsUQwwMLiWh8hJi2GT/d8ShuPNrzY+sVKFelk6kk+3/s5zd2a0zytOW+99RYNGjRgxowZrE1cy6ozqxjSYAgjgkdU7h7rKAkA1ABp6IUQd7PCYi1HL2YQeTGDw+czuJieoz9X38WGFn5OtPBzJNTLHkuz2/vwWufkZ8GlQ3BxP0X+XTGrF3bbWUqbZHhSB0KISkmK1q0LcFG3pV6pQIBSsOW/ELcZGvaELq9X/OH/qquLDob01001qEhxoS7t8cW6YEGzkXByJeSkgE9r6Pwq2F5bcT8+Pp6vv/6an3/7nbTkxHKzdXJy4t577+XBBx+kX79+aDQavj3wLYeSDvFO+3do6NSw3NeCbu2AD3Z+wIXsCwwoHMDDIx6moKAAgP79+7No6SI+2fMJF7Mv8lb4WwQ5B938fTG0xCiIWgZezSF0wB27rAQAaoA09EKIuiQlO58jFzM4eiGDIxczyMrTjQ4wNzWhqY8jnYNcaRfggpW5BAMMQdokw5M6EEJUSalAQGfdMP+TK+HEcqgXDj3e1q03UxlaLax5BxIiode7UL992ekyLsLmzyH1NLiFQPeJuh0E8rNh9ww4vQks7KDD89Cge4mXFhUV8eLXf7F+xRJSjm4hLTmp3OKMGDGC//u//yO5MJnJOyYT7BzMpHaTKpxSuOXCFmYem0nDzIZ89sRnZGdnlzj/5ptvMu7tcXyw8wNcrV2Z0nEKVmZWlXt/7iSldKMrjs6Dy8d0x0wtYNSv1bMlZCVIAKAGSEMvhKirlFKcScnhyIV0Dp/P4ERCJlqlsDAzpZ2/M52D3Wjh64iZqYmhi1pnSJtkeFIHQohbknQSDv11LRAA4NkU+n4AZuUvtFem7CTd1oAmZrqtAW2uW31fKTi1Hnb9oFs3oPkoaPVI6QDDmW2w8zvdaLXAbrpAgKW9/nRmXiGT5h0hK6+AYV6ZbFyxmPnz55OYWHpkQPfu3Vm8eDHzzs1j+6XtJeb03yinMIe3tr5FypkUVk1YQUpqWpnp5syZg11bO+ZGz6W7X3fGNB1TtfeoJmmLIW6L7oN/2lnQmOgWbnT0gwN/6EZatK3agoi3qiptkvTWhBBCVEij0RDoZsuwVr68N7QJPzwSxthOgfi72LD9VDJfrDrB8/93gF+2xRF9OQuJKwshhBDlcA+Fvu/DoP+CX1vwbgm936v6h38AO3foOE43p3/7N7oP/QAFObppBdum6ob89/sQwsaWPbogoAsM+w782uk+zC4ap9tu8F8OVua80DOIYq2G/fnefPPZZC5tmcWGb8bxfL9GONua69Nu3ryZ7t2709GuI2YaM+ZFzyu3T7Ds9DIunb/I6jeXlPjwP3zIACzMrn1Effzxx/HN9iXEOYTNFzZzJOlI1d+n6laUD1FLYf5TsPVLyIyHxvfAyF+g6+vQbJQuCHBiGeRlGLq0pcgIgEqSSL8QQpSWkJHH9thktsUmE5+RC+h2FOgc5ErnIDf8nG0MXMK7k7RJhid1IIQwGlsi4PRm3bf3rsG6If/Zl8E3DLq8Vrlh6EpBzFrY8xMU5ekWB2z7pO4D7OVIDu/bSvbZQzS0ysbL8d9FB+08OK31od9rMzh1KUWfVQM/T17+aTyHTaJ4qvlTdPLpVOJSCVcSGD//WVZNXEvq5Vz98dGjRzNr1ixm/vgdT457WX+8YcOGrNy8kq+ivsLK1IoPOn+AvYU9d1x+lm66xvEluqCLhZ1u0cbGQ8DKsWTaUxt1wYHm90FYzY9akCkANUAaeiGEKJ9SitPJV9gem8yO2BTSc3WL+AS62dE12I1ODV1lN4FqJG3S7Tl58iRPPPEEGRkZWFhY8PXXX9O9e/ebv/A6UgdCCKORnw1LXoTcdFBa3SKCYY9Dk2GVW1DwelkJsO1r3Vx2Uwso1rXnWqU4mmlNZFF9wjt1J7h5R7DzAODy5csM6NeXQ0ci9dl4OFrS7Z12BLZuyce9vsbc5N+RAldS+HTh00S8vYq089c+/A8ZMoQFCxZgbq5L98JTj/H9L7P05wcOHMjEHybyx4k/CPMMY1zLcXdmy2JtsW6b39h1cG6n7rmNKzQbAcH9yt+BQauFRc/ptl0c9StYOdRoMSUAUAOkoRdCiMrRahVHL2WwNSaZPXGp5BcVo0FDi3qOdA1yp22AsyweeJukTbo9Z8+eJS8vj9DQUE6cOMHQoUOJiYmpUh5SB0IIo5IQCaveAgcf6D4JXCtegb9CWi0cXwhxW3W7FXg1B8/mJCp7Js07gpmpCV+MbIGz7bXAfkZGBvfeey+bNm3SH7OxNqXbyw15vVNX+oaNg/Rz7Nk5g6GfbyMx9oo+Xbdu3Vi1ahUFyozfd56hua8jnRs40atLB7bvPahP9/bbb+M50pNDSYd4qtlTdPItObKgoLiA1LxUUvNSSctLIzUvFa3S0se/D7bmtlV7D9LP6T70n9qgC6yAbq2G4H4Q2L1yizXGrtcFU1rcD20eq9r1q0gCADVAGnohhKi6vMJi9p9NY2tMMkcupKNVCkszU8IDXegS5EYzX0dMTe5ABP8uI21S9VFK4eXlRUJCQpW+TZI6EEIYnazLuuH+t7KeQCXtOJXMt+tjaObjyDuDG5f4u5mXl8fDDz/MggUL9MdMzU3o90wg89uGoIoUzaft5vSRa3P+27Rpw4YNG0grNCNizUlSsvPRoOHVPsH42xQS1qo5ly4n69PP+mcWe932UqgtpL13e/2H/bS8NK4UXQsqALppDUV51Lfz4/U2r+Jg5w0mFSyBl5+lWwchdh0k/xsUtnWDoD7QsJcuuFIV2mJY+BzkpetGAVjW3LQFCQDUAGnohRDi9mTkFLLzdDJbY5I5laTb6sfR2pzOQW50DnKjgZvtnRnOdxe429ukLVu2EBERwf79+4mPj2fp0qUMGTKkRJrvvvuOiIgIEhISaNWqFdOmTaNdu3ZVvtbixYuZMWMGK1eurNLr7vY6EEKI8vy4+RQbTybyUHh9hrXyLXGuuLiYcePG8dNPP+mPaUw0PPNib05GxrNp4zH98dDQULZu3UpctinTN8ai1SpGhfmxIjKe3MJi3h3ShNS4Y3Tv1pWCwiIAbG1t+X3F7yzPXQ6AicYEJ0snXKxccLZyxtXKFWczG1ySYnA+t4fDOfEsJRsfzJiAM44WjroP4pZ2YOlw7d/ctGtD/E0tIKCz7oO/V4uqT6O4Xuw63WKMLR+E1o/cej43UZU2qZIbTQohhBC3x9HGnAHNvBnQzJtL6blsi01mW0wyKyLjWREZj7ejNV2C3OgS7IangxHu8yvumCtXrtCyZUueeOIJRowYUer8P//8w+uvv86MGTNo3749U6dOpX///kRHR+Pm5gZAs2bNysz7wIEDWFjohq2ePXuWCRMmsGLFipq7GSGEuMuM6RTAyYQs5uw7T1MfB4I8rn2zbWpqyowZM/D09OTDDz8EQGkVP367rkQe9erVY/Xq1Ww9n8+cfeextzLn9b4hNPZ2oJmvA+8vPU7E6pN8dG8rvvvue55+5hlA1z689dRbrNy8EldnVxwsHTDR/PutflaCbnX+mLlQmAuW9jRo8jCWmdHMSznMZyamTLTxxrkgD64kQepp3Qf+qzya6D70B3QBi1tbxDg3N5cdO3bg4eFB8+bNoUFPODwbji/WrclQg6MAKktGAFSSRPqFEKL6KaWIScxma0wyO0+lkJ1fCECQhx1dgtzo2NANR2vzm+RS99SlNkmj0ZQaAdC+fXvCw8OZNm0aAFqtlnr16vHaa6/xxhtvVCrfzMxMunXrxhdffEG/fv0qlT4zM1P/PD4+nvDw8DpRB0IIcaO45Cu8u+goLrYWfDayOTYWpb9XnjZtGq+88kqprQDd3d1Zv3ETGxPM2XEqmXrONkzoH4rHdcH/PXGpfL02Gi9HKz4Y1pQJr7zIj9eNKhg8eDBLlizBRKOBxCgKDs8j/sgmLqblcbHAjovmgVwqsKNIqxgyZAjFDYv5+8TfuFm7MbHdRNys3fRTBMjPAo0p2Lre0nuhlGL79u38/vvvzJkzh8zMTExNTZk1axYPPfSQbneF7d9Aq9G6Rw2QKQA1oC51toQQwhCKirUcuZjB9phk9p5No6CoGBONhuZ+jnQJcqNdgIssHvivutQm3RgAKCgowMbGhoULFzJ06FB9ujFjxpCdnc38+fNvmmdxcTGDBw9m2LBhPP/885Uqx5QpU3j//fdLHa8LdSCEEGVZGRnP7zvP0Ka+MyPD/Mqcyjd79mwee+wxCgt1AX4HBwcWrVjD2kQbTidlE+bvzIs9g7G2KN2+Lz8Sz6xdZ2jk5cD43g3o36cXO3ft0p9v36oxBZnJXEzOIDGzoMKy3nvvvYwaP4r1V9bjYuXCxHYT8bDxuK37P3PmDH/88Qd//PEHp06dKnXe3t6ew4cPE1i/Hix8FgqydWsBWFRxQcJKkCkAQgghah0zUxPa1HemTX1n8gqL2XsmlW2xyUReyODw+XT94oHdQ9xp4u2AiSweWCclJydTXFyMp6dnieOenp7ExsZWKo+VK1eyfv16EhIS+PHHHwHYtGkTTk5O5b7m9ddf56mnntI/vzoCQAgh6qoBzbw4dimTfWdTOXAuDSdrC1rVd6JNfWea+zpibWHKgw8+iKurK88++ywajYZPvpnBnDgz0nKyGdbKlwfa1iu3PR/U3IvErDxWH0vgt10XmDd/Pm3DwohPSABg96GoSpd10aJFrFy5kvufvp/E3ol8tuczJrabiJetV5XuOSsri3nz5vH777+zefPmm6Z99NFH2bx5M6YtHoAd38LxJdDqoSpds7pJAEAIIYTRsTI3pWuwO12D3fWLB26JSWZrTBJbY5JwsbWgS5A7XYPdqOdya/P0RN01ZMgQ/bdRleXg4ICDQ83u4yyEELWJRqPhtb4hRMVncvBcGgfOpbPpZCKbTiZiZmJCY297Wtd3pnV4F06fPs322GRmbD6FUkWM6xFEtxD3m+Y/pmMAydn57DiVjIe9JfPmz6dHjx43/RtuZ2eHr68vFy9eJDtbt/Bwfn4+s6bPwn2+O00fa8qn2k+Z0G4CfvYVf2OekpLC6tWrWbp0KYuXLCY3J7fMdJa2lvQY3IP01HR2r9sNwPbt2/n88895e9JEOPz3tbUAbnGNgeogAQAhhBBG7frFAy+k5bA1Rrd44JLDF1ly+CKBbrZ0C3anU5CsF1AXuLm5YWpqyuXLl0scv3z5Ml5eVfsmRwghxO0xNdHQzNeRZr6OPNoREjLy/g0GpBEVn0XkxQz+2Anu9lYkZeXhaG3OG/1CCfas3GJ4JiYaXuoVzPtLj7Po0EWe6daQJUuWMG3aNCwtLfH19cXHxwdfX98SD3t7Xf7x8fG89dZb/P777/o8k+KT2PT5JqKWRXH5pct8/tDn+Dv4688rpThw8ABzFs9h5YqVHD1wFKUte9a8RqOhc4/OPPPEM4wcMRIbGxvS09MJaBxARkIGAJMnT6Zfv360bfEA7JyuW6iw5QO3+pbfNlkDoJLq0nxLIYQwdkopjl3KZEtMEnviUskr1K0X0LKeE12C3Ggb4Iyl2d27XkBdapPKWwSwffv2fPvtt4BuEcD69evz6quvVnoRwNtVl+pACCFuRW5BMZEXMzh4Lo3DF9LxsLfixV5BuNlZVjmv9JwC/rPoKKlXCnhzYCNa+DlV6fW7d+/mpZdeYu/evSVPaKDJoCZ8MfkLIo9EsnrFavZv2U9WclaF+TVq3IixY8byyCOP4OvrW+r8/y3/Px4Z+gj8+0k7JCSEA3v3YLv6FSjM+3ctgOobBSCLANYAaeiFEMI45RUWs+9MGltikoi8kIFC6dcL6BzkRnNfR0zvsvUC7vY2KTs7Wz+fv3Xr1nz77bd07doVLy8vvLy8+OeffxgzZgw//vgj4eHhTJ06lblz55bYBrCm3e11IIQQxuZ8ag6TlxxDKcWUe5ri71q1xfS0Wi2///47b775JomJiVW+foMGDRgyZAiPPPIIbdu2LbXg4Y36P9mfNb+u0T9//vnn+f7lIbDre2jzGLS4v8plKI8EAGqANPRCCGH80q4UsONUCttPJXM6STfnz8HKnI4NXekS5EaQh91NG+za4G5vkzZt2kTPnj1LHZ88eTJTpkwBYPr06URERJCQkECrVq2YNm3aHVmULyIigoiICIqLi0lNTb1r60AIIYzR0YsZfLoyCkdrc57vHkRjb3vMTE2qlEdGRgYffvgh33zzDUVFReWmMzc3p3v37gwaNIhBgwYREhJSpT7EhfQLtGrXipTYFP2xpYsWMiR/IRQX6EYBmFtXqezlXksCAKWNGjWK9evX079/f2bPnl3l19/tnS0hhLjbXErPZVtsMttjk7mcmQeAp4MVnYPc6NTQFT/n2rt4oLRJhid1IIQQhrE5OokfNulGiVmbm9LCz4k2/s60qudUpbWATpw4wauvvsrq1av1x/z8/PQf+Hv16qVfS+BWfb3yayYMn0BxfjEA7u7uRC74Cs/Y2RA2FpqPuq38r5IAQBk2bdpEVlYW//d//ycBACGEqEOUUpxKymZbTDI7TqWQmadbOdjb0Zowf2faBjgT4mFfq7YVlDbJ8KQOhBDCcM6l5LD3jG77wVP/jvjToCHIw442/rqtCOu72Nz0G3ulFBs3biQqKoquXbvSvHnzah0pmFOYw6A3BrH522tbBg4ZPIglj7qg0Rb/OwrA6ravU5U2qc7sAtCjRw82bdpk6GIIIYS4wzQaDUEe9gR52PNoxwCOXsxgd1wK+8+msezIJZYduYS9lTlt6uuCAc19HbEyv3sXEBRCCCFqu/quNtR3tWFkmB/pOQUcPJ/OwbNpHL6QQUxiFv/sPY+rrSVh/s6MDPMrd2SARqOhV69e9OrVq0bKaWNuw7uvv0vszlgu7r0IwLLlK/ip7TieDTgLJ5dDs5E1cu3yVG3CRA3ZsmULQ4cOxcfHB41Gw7Jly0ql+e677wgICMDKyooOHTqUXsFRCCGEuAlTE91OAc90a8iMR8L4cFgz7m3li4OVOZujE/lyzUme/mMfX6w6wfqoy2TkVG2veCGEEELcWU42FvQM9eD1fqH8PKYtbw9qzICmXpiYaFhzPIG3F0QSm1jxqv7VKSkrn4zca/2HHvV6MPKdkVg5Xvum/7UvfuNkvgfYuN6xcl1lFCMArly5QsuWLXniiScYMWJEqfP//PMPr7/+OjNmzKB9+/ZMnTqV/v37l1jtt1mzZmXmfeDAASwsLGq0/EIIIWofjUZDsKc9wZ72PBhen4SMPPafTWPvmVQOnkvnwLk0ftkWR3M/R7oGudM2wFlGBgghhBBGzNzUhBZ+TrTwc2JMJ8Wmk0n8uj2OKUuO81hHf/o28ayRxYCz84vYEZvM1phkYhKz0KAh2NPu36mGLjzZ6UmOvXqM9e+vByA3N5dHfo5kxxOdqfyqBdXDKAIAAwcOZODAgeWe/+qrr3jmmWd4/PHHAZgxYwbLly9n5syZ+v1+jx49Wq1lyszMJDMzU/88Pj6+WvMXQghhXLwcrRjcwpvBLbzJyivkwLl0dpxK5sj5DA6fT9dvLdg12I1mPo61as0AIYQQoq7RaDT0bOSBv6sNX6+L4dftccQkZvNU10AszW4/oF9UrOXwhXQ2Rydz4GwaRVotFmamdGroRmGxlsMXMoi+nMXfe87h5WCFf5vONOh/jtOrYwDYt28fH3zwAR9++OFtl6UqjCIAUJGCggL279/Pf/7zH/0xExMT+vTpw86dO2vsul999RXvv/9+jeUvhBDCeNlbmdM9xJ3uIe6k5xSw81QKW2OT2RqTxNaYJJysLegc5EqXYHcCXG++yJC4e1y/DaAQQgjj18Ddjk9HNGfahhi2xiRxNuUKr/cNxcux6ovvKaWIS77Clugktp9KIevfhYUbezvQLcSdDoGuWFvoggv5RcUcvZjJ/rOp7D+bRlpCW1zuPUz8oSRyL6cD8MknnzBgwAA6d+5cbfd7M0a3C4BGo2Hp0qUMGTIEgEuXLuHr68vu3btL7O87ceJEtm/fzvbt2yuV7+DBg9mzZw9XrlzBxcWFpUuX0rp163LTlzUCIDw8XFb7FUKIOuxCWg7b/x3il5ydD4Cvkw1dg3VbC3o43P5KvpUqh6xAb3BSB0IIUbsopZi3/wILDlzE2sKUF3o2JMzf5aavK9YqTidlc/hCBjtPpXAxPQcALwcruga70zXEDQ/7itt/pRSxidl8d+BXNu9eyuEPN6K0WgDatGnDvn37buvLBNkFoAzLly+vUnoHBwccHBxqqDRCCCFqIz9nGx5oV5/729bj5OUstkYns+t0CrP3nmP23nMEe9jTOciVjg3ccLS507P6hBBCCFEejUbDfW3rEeRhx3cbY4lYfZJ7W/lyf9t6pab1JWbmceRCBkcupHPsUiZXCooAsLUwo09jT7qFuBPsYVfpD+1X1x36oPfjvGl+EotHc9jz+046dO3O3L/+vKMjCY0+AODm5oapqSmXL18ucfzy5ct4eXkZqFRCCCHqMo1GQyMvBxp5OTC2cwCHz6ezPTaF/efSiNmRxe87ztLcz5GODV1pH+iCjYXRN7dCCCFEndC6vjOfDG/O1+uiWXToIrGJ2TzdrQHnU3M4fCGDyAvpJGTmAaBBQ4CbLS39HGnu50iIpz3mpre+kZ6DhQNDGgwh5/4curboxBevfoGJyZ3dmM/oeyQWFhaEhYWxdu1ahg4dCoBWq2X9+vW8+uqrhi2cEEKIOs/c1IS2AS60DXAht6CY/WfT2BabTOTFdI5cSOfXbXG0rudEpyA3Wtd3qpaFh4QQQghx6zwcrHj/nmb8tj2OjScTeWX2Qf05F1sLeoR60MLXkaa+jjhaV++Ivr7+fdl0fhPZLbLJKszC0dKxWvO/GaMIAGRnZxMbG6t/HhcXx6FDh/Dy8sLLy4vXX3+dMWPGEBYWRnh4OFOnTiUnJ4exY8cartBCCCHEDawtTOkS7EaXYDcy8wrZfTqV7bHJ7DmTyp4zqQxp4cMjHfwNXUwhhBCizrMwM+HZ7g1p5O3AwXNphHja08LPEV8n6xodkm9uas59offxw+EfWBS7iDFNx9TYtcpiFAGAffv20bNnT/3zl19+GYDJkyczZcoUHnjgAZKSknjvvfdISEigVatWrFq1Cjc3N0MVWQghhKiQg5U5fZt40reJJ8nZ+ew8lUJLPydDF0sIIYQQ17m668+d1NazLYMDB9PZ986t/n+VUQQAevTowc02I3jxxRd58cUX71CJrpHtfoQQQtwuNztLhrb0MXQxhBBCCGEENBoNI0NGGuTad3bFgVpowoQJJCYmcvjwYUMXRQghhBAGFhERgYeHBy1btjR0UYQQQogqkwCAEEIIIUQlyRcDQgghajMJAAghhBBCCCGEEHWABACEEEIIIYQQQog6QAIAQgghhBBCCCFEHSABACGEEEIIIYQQog6QAIAQQgghhBBCCFEHSABACCGEEEIIIYSoAyQAcBOy368QQgghhBBCiLuBmaELYOwmTJjAhAkTOHPmDIGBgcTHxxu6SEIIIeq4q21RUVGRgUtS90RERBAREaF/76VfIIQQwtCq0i/QKKVUTRfobrB3717Cw8MNXQwhhBBCb8+ePbRr187QxaiTpF8ghBDC2FSmXyABgErKy8sjMjISd3d3zMzKHjgRHx9PeHg4e/bswdvb+w6XsHrIPRgHuQfjIPdgPO6G+6jOeygqKiIpKYnmzZtjZWVVTSUUVSH9gtpD7sE4yD0Yj7vhPuQeSqpKv0CmAFSSlZVVpb9l8fb2xs/Pr4ZLVLPkHoyD3INxkHswHnfDfVTXPQQEBNx+YcQtk35B7SP3YBzkHozH3XAfcg/XVLZfIIsACiGEEEIIIYQQdYAEAIQQQgghhBBCiDpAAgDVyMHBgcmTJ+Pg4GDootwyuQfjIPdgHOQejMfdcB93wz2Iqrkb6lzuwTjIPRiHu+Ee4O64D7mHWyeLAAohhBBCCCGEEHWAjAAQQgghhBBCCCHqAAkACCGEEEIIIYQQdYAEAIQQQgghhBBCiDpAAgBCCCGEEEIIIUQdIAEAIYQQQgghhBCiDpAAQDX67rvvCAgIwMrKig4dOrB3715DF6nSpkyZgkajKfFo1KiRoYtVoS1btjB06FB8fHzQaDQsW7asxPm8vDxeeOEFXF1dsbOzY+TIkSQmJhqotGW72T306NGjVL0899xzBipt2T799FPatWuHvb09Hh4ejBgxgpiYmBJpjL0uKnMPxl4XP/30Ey1atMDBwQEHBwc6duzIypUr9eeNvQ7g5vdg7HVQlueffx6NRsP06dP1x1JTU3n44YdxcHDA2dmZp556iitXrhiwlKKmSL/gzpJ+gXGQfoFxkH6BcTKGfoEEAKrJP//8w+uvv87kyZM5cOAALVq0oH///iQnJxu6aJXWsmVL4uPj9Y9t27YZukgVunLlCi1btuS7774r8/xrr73G0qVLmTt3Lps3b+bSpUuMGjXqDpeyYje7B9D9obi+Xr744os7WMKb27x5My+88AK7du1i7dq15Ofn069fP3Jzc/VpjL0uKnMPYNx14ePjw6effsr+/fvZt28fffr0YdiwYURFRQHGXwdw83sA466DGy1btoydO3fi4+NT4vjDDz/MsWPHWLt2LUuXLmXz5s08//zzBiqlqCnSL7jzpF9gHKRfYBykX2B8jKZfoES1CA8PVy+++KL+eXFxsfLx8VEREREGLFXlTZ48WYWFhRm6GLcMUEuXLtU/T09PV+bm5mrevHn6Y1FRUQpQe/fuNUQRb+rGe1BKqe7du6vx48cbqES3JjExUQFq+/btSqnaWRc33oNStbMunJ2d1cyZM2tlHVx19R6Uql11kJCQoPz8/NSRI0eUv7+/mjZtmlJKqePHjytA7du3T5925cqVysTERCUkJBiquKIGSL/AsKRfYDykX2A8pF9gOMbUL5ARANWgoKCA/fv3069fP/0xExMT+vTpw86dOw1YsqqJiorC29ubBg0a8Oijj3LhwgVDF+mW7d+/n8LCwhJ10qhRI+rXr1+r6gTg999/x83NjWbNmvHOO++Uij4bm4yMDABcXFyA2lkXN97DVbWlLoqLi5k9ezY5OTl06NChVtbBjfdwVW2pg8cff5yXX36Z5s2blzi+c+dOXF1dCQsL0x/r06cPGo2GPXv23Oliihoi/QLjUxv/DpantvwdvEr6BYYn/QLDM6Z+gVmN5FrHJCcnU1xcjKenZ4njnp6exMbGGqhUVdO+fXtmzpxJaGgo8fHxvP/++3Tr1o3IyEhsbW0NXbwqS0hIwNraGnt7+xLHPT09SUhIMFCpqm706NH4+/vj4+PD4cOHefPNN4mJiWHOnDmGLlqZlFK89tprdO/eXT9XtLbVRVn3ALWjLiIjI+nYsSN5eXnY2dmxaNEiQkND2b9/f62pg/LuAWpHHQBMnz6dK1euMH78+FLnEhIS8PDwKHHMzMwMFxcXo6sLceukX2B8altbVJ7a8nfwKukXGJb0C4yDsfULJAAgABg4cKD+5xYtWtC+fXv8/f2ZN28eY8aMMWDJ6rZnnnlG/3Pz5s3x8fGhd+/enD17Fn9/fwOWrGwvvvgiR48eZfv27YYuyi0r7x5qQ12EhoZy6NAhMjIymDdvHo899hhbt241dLGqpLx7CA0NrRV1cOLECT788EN2796NiYkMshO1l/QLjFNt+Dt4PekXGJb0CwzPGPsFxlGKWs7NzQ1TU1MuX75c4vjly5fx8vIyUKluj5OTEyEhIbXmm4obeXl5kZubS1ZWVonjtblOQPeNDGCU9fLSSy+xZMkSNmzYUGJxk9pUF+XdQ1mMsS4sLCwICgoiLCyMTz/9lBYtWvDtt9/Wqjoo7x7KYox1sGvXLpKSkggKCsLMzAwzMzPOnj3LK6+8QqNGjfDy8iq1ynJRURGpqalGVxfi1km/wPjUpr+DVWGMfwevkn6B4Um/wPCMsV8gAYBqYGFhQVhYGGvXrtUf02q1rF+/no4dOxqwZLcuOzubU6dO4e3tbeii3JKwsDDMzc1L1MnJkyc5d+5cra0TgEOHDgEYVb0opXjxxRdZsGABGzZsIDAwsMT52lAXN7uHshhjXdxIKUV+fn6tqIPyXL2HshhjHdx7770cOXKEQ4cO6R8+Pj68+eabLF26lI4dO5KSksKBAwf0r9mwYQNKKcLDww1YclGdpF9gfGrz38GKGOPfQekXGE9d3Ej6BXeeUfYLamRpwTpo9uzZytLSUs2cOVMdP35cPfPMM8rZ2VklJSUZumiVMn78eLVp0yYVFxentm/frvr06aPc3d1VcnKyoYtWrqysLHXw4EF18OBBBahvv/1WHTx4UMXHxyullHruuedU/fr11YYNG9S+fftUx44dVdeuXQ1c6pIquofY2Fj1wQcfqH379qm4uDi1ePFi1aBBA9WrVy9DF7uE559/Xjk6OqpNmzap+Ph4/SMnJ0efxtjr4mb3UBvq4u2339b/H46MjFRvv/22MjExUevWrVNKGX8dKFXxPdSGOijP9av9KqXUgAEDVOvWrdXu3bvVtm3bVHBwsHrkkUcMWEJRE6RfcOdJv8A4SL/AOEi/wHgZul8gAYBqNG3aNFW/fn1lYWGhwsPD1e7duw1dpEp74IEHlLe3t7KwsFC+vr7qwQcfVKdOnTJ0sSq0ceNGBZR6TJ48WSmlVG5urho3bpxydnZWNjY2asSIEUa3zVZF93Du3DnVrVs35eLioiwtLVVQUJCaNGmSyszMNHSxSyir/ID67bff9GmMvS5udg+1oS6eeeYZ5e/vrywsLJS7u7vq3bu3WrNmjf68sdeBUhXfQ22og/Lc2NCnpKSohx56SNnZ2SkHBwf1xBNPqOzsbAOWUNQU6RfcWdIvMA7SLzAO0i8wXobuF2iUUqr6xxUIIYQQQgghhBDCmMgaAEIIIYQQQgghRB0gAQAhhBBCCCGEEKIOkACAEEIIIYQQQghRB0gAQAghhBBCCCGEqAMkACCEEEIIIYQQQtQBEgAQQgghhBBCCCHqAAkACCGEEEIIIYQQdYAEAIQQQgghhBBCiDpAAgBC3IK2bdsyZcqUastv5syZuLm5VVt+d1qPHj144403biuPKVOm0LZt22oqUdlq+/sshBDCOEm/oCTpFwhhvCQAIIQReOCBBzh+/Lihi3FTmzZtQqPRkJ2dXeL4ggULmDx58m3l/cYbb7B69erbyuN6AQEBTJ8+vcQxY3ifNRoNy5YtM2gZhBBCGDdjaK8qQ/oFt0/6BeJOMzN0AYQQYG1tjbW1taGLcctcXFxuOw87Ozvs7OyqoTTlq+3vsxBCiLqhtrdX0i8QwnjJCAAhbiI7O5tHHnkEW1tbfH19+f7770ulSUtL48knn8TNzQ1HR0f69+/PiRMnADh27BgajYbY2NgSr5k8eTJt2rQByh6CtmjRIsLCwrCyssLDw4PHHnusUteryNy5c2nSpAkWFhY0aNCAH374ocR5jUbDjz/+SL9+/bC2tiY4OJgVK1YAcObMGXr27AmAvb09Go2GsWPHAqWH+gUEBPDpp58yevRobG1tadCgAWvXruXcuXP07dsXW1tb2rdvT0xMjP411w/1O3PmDBqNptSjR48eACQlJfHggw/i6+uLjY0NrVq1YvHixfq8evTowdmzZ3nppZf0ry3vfZ4+fToNGjTAwsKCJk2aMH/+fP25q+VYuHAhXbt2xcbGhvbt21f4bUFBQQEvvPACXl5eWFlZ0aBBA6ZNm6Z/XwCGDh2KRqPRPwddfbdq1QorKyuCgoL44osv0Gq1laobIYQQd470C6RfIP0CUaspIUSFnnnmGRUQEKDWr1+vDh8+rPr27avs7OzU5MmT9Wn69Omj7r33XrVv3z518uRJNW7cOOXn56eys7OVUkq1bNlSffDBByXyDQ4OVhEREUoppX777Tfl6uqqP7dx40ZlZmamPvzwQxUVFaUOHDigT1uZ65Vlz549ysTERH388cfq5MmT6scff1QWFhZq4cKF+jSAcnd3V7/99ps6ceKEGj9+vLK0tFTnzp1TRUVFav78+QpQp06dUvHx8So9PV0ppVT37t3V+PHj9fn4+/srV1dX9b///U9FR0erMWPGKA8PD9WvXz+1bNkyFRUVpTp37qz69Omjf83kyZNVWFiYUkqpoqIiFR8fr38cPnxYubm5qXfffVcppdTZs2fVl19+qQ4ePKhiY2NVRESEMjMzU8ePH1dKKZWSkqL8/PzUJ598os+jrPd53rx5ysLCQv3444/q5MmT6uOPP1YmJiZq//79Siml4uLiFKCaNm2qVq9eraKiolSPHj1Uhw4dyn2fIyIiVL169dTWrVvVmTNn1MaNG9W8efOUUkolJiYqQM2aNUvFx8erxMREpZRSW7ZsUY6OjuqPP/5Qp06dUitWrFC+vr5q6tSplaobIYQQd470C6RfIP0CUZtJAECICmRmZipzc3O1YMEC/bFLly4pc3NzfUO/detW5ezsrPLz8/VpiouLlbe3t/rnn3+UUkp9/vnnqnHjxvrzVxvdCxcuKKVKN0A9evRQjz/+eJllqsz1yvLQQw+pgQMHljj2/PPPq06dOumfA+rll18ukaZZs2bqrbfeUkrpOiCAysrKKpGmrIZ+7Nix+ucxMTEKUF9//bX+2Ny5c5W5ubkqLi5WSpVs6K9XUFCgunTpooYMGaJPW5bu3burDz/8sEQZpk2bViLNje9zx44d1fPPP18izcCBA9Xo0aOVUtca+t9//11/fvXq1QpQubm5ZZbjpZdeUr169VJarbbM84BaunRpiWO9e/dWX3zxRYljP/zwQ4nfmZvVjRBCiJon/QLpF0i/QNR2MgVAiAqcPn2awsJC2rdvrz/m7e2Nv7+//vnhw4fJyMjAxcVFP1/NwcGBy5cvc+rUKQAeeughTpw4waFDhwD466+/6NatG76+vmVe98iRI/phdTe62fXOnTunP25nZ8cnn3wCQFRUFJ07dy6RV+fOnYmKiipx7Pp7BejQoUOpNJXRokUL/c+enp4ANG3atMSxwsJC0tPTK8znpZdeIjU1lb/++gsTE92frOLiYj744AOaN2+ufx+2bdvGuXPnqlTGyr4nzZs31//s7e0NQGJiYpl5PvbYYxw4cIBGjRrx6quvsmHDhpuW4/Dhw7z33nsl6u21117T//5cVV11I4QQ4tZIv0D6BSD9AlG7ySKAQtym7Oxs/Pz8WL9+falzVxfBqVevHl27duXvv/+mRYsW/PPPP3zwwQc1cj0HBwd9h+L6Mtxp5ubm+p+vzrUr69j189lu9MMPPzB37lz27NmDvb29/nhERATTp09n6tSpNG3aFFtbW55++mkKCgqq+zaqXO62bdsSFxfHypUrWbt2LcOGDePBBx/kf//7X7n5Z2dn89FHHzFs2LDqLbgQQog7TvoFZZN+gfQLhHGQEQBCVKBBgwaYm5uze/du/bGEhATOnj2rf966dWsuXbqEpaUlQUFBJR7XN7IPP/wws2fPZsOGDaSkpDBq1Khyr9uiRQs2btxY5rmbXc/MzKzMMjRu3Jjt27eXyGv79u00adKkxLHr7/Xq88aNGwNgYWEB6CLtNW3Lli2MHz+eOXPm0LBhwxLntm/fzvDhwxk9ejQtW7bE39+/1GJKFhYWNy1nZd+TqnJycuKhhx7i119/5eeff2bmzJn6joG5uXmpcrVu3Zro6OhS9RkUFFQiXUV1I4QQouZJv0D6BbdC+gXCmMgIACEqYG9vz5gxY3jjjTdwdnbGxcWFiRMnYmlpqU/Tp08fwsPDGTZsGJ9//jlBQUFcvHiRxYsX8+STT9KoUSMARo0axYsvvsj48eMZNGgQTk5O5V538uTJ9O3bl4YNGzJq1Cjy8/NZv349r732WqWvd6PXXnuNDh068OmnnzJq1Cg2btzIL7/8wj///FMi3ezZswkLC6NDhw78/PPPnDx5Ur8/rb+/v36/2qurztbEFj0JCQmMGjWK8ePH07RpUxISEgBd4+3i4kJwcDALFixg165d2Nvb89lnn5GRkVEij4CAADZv3syoUaOwtLQstcovwPjx4xk9ejStWrWiZ8+ezJs3j9WrV7N3795bLvvXX3+Nj48PrVq1QinFokWLCA4O1g9TDAgIYN26dbRv3x5LS0ucnZ159913ueeee/Dz82PkyJEAHDx4kDNnzvDOO+/o866oboQQQtQ86RdIv6CqpF8gjI6hFyEQwthlZmaqhx56SFlbWytvb281bdo0FRYWVmK134yMDDVu3Djl7e2tLCwslL+/vxozZoy6fPlyibzuueceBag5c+aUOH7jIjRK6VaibdGihbKwsFAeHh4lFs+p7PVuNGfOHNW4cWNlbm6uAgMD1XfffVfiPKB++OEH1bt3b2VpaakaNmyolixZUiLNBx98oLy8vJRGo1FjxoxRSpW92M/1C+1kZWUpQG3cuFF/bOvWrQpQSUlJSqmSi/1cXVToxkf37t2VUrrVfIcNG6ZsbW2Vl5eX+vDDD9XIkSP15VFKqZ07d6oWLVooS0tLdfVPXVnv87Rp01RAQIAyNzdXjRs31q/Mq9S1xX4iIyP1xyIjIxWg4uLiynyPf/zxR9WyZUtla2urHB0dVf/+/fWrECul1JIlS1RQUJAyMzNT/v7++uMrVqxQHTp0UFZWVsrR0VF17NhR/fnnn1WqGyGEEDVP+gXSL5B+gajNNEopdaeCDUII46bRaFi6dClDhgwxdFHEDaRuhBBC3GnS9hgvqRtxq2QNACGEEEIIIYQQog6QAIAQQgghhBBCCFEHyBQAIYQQQgghhBCiDpARAEIIIYQQQgghRB0gAQAhhBBCCCGEEKIOkACAEEIIIYQQQghRB0gAQAghhBBCCCGEqAMkACCEEEIIIYQQQtQBEgAQQgghhBBCCCHqAAkACCGEEEIIIYQQdYAEAIQQQgghhBBCiDpAAgDCaGk0mps+Zs6caehi3rJNmzah0WjYt29fteWp0Wj473//W2351RYTJ07E29sbExMTXn31VWbOnIlGoyE5Oblar5Oens6UKVM4fvx4ieNnzpxBo9Ewb968ar2eEEKI2m/KlCll9mGaNWtW6TwCAgJ48cUXb7kMPXr0YMiQIbf8+vIsWrSI77//vtTxsWPHVun+7lZl9fWmTJnCjh07DFgqUdeZGboAQpRn586dJZ537NiRl156idGjR+uPNWzY8E4Xq9q0adOGnTt30rhx42rLc+fOnfj7+1dbfrXBunXriIiI4Ouvv6Z9+/b4+PiwcePGGrlWeno677//Ps2aNaNJkyb6497e3uzcuZOQkJAaua4QQojazdramg0bNpQ4ZmNjc8eu//3332Nqalrt+S5atIh9+/Yxbty4Esffffddrly5Uu3Xuxu8//772NnZ0alTJ0MXRdRREgAQRqtDhw6ljtWvX7/M41fl5uZibW1dk8WqNg4ODhXey62o7vyqasqUKWzatIlNmzbdVj5VqccTJ04A8PLLL2NiYphBTZaWlgZ/7yurvPf2dv7v1Kb/d0IIYQgmJiYGaSeu/n2+Pmh9J9TmL2iEuNvJFABRa02ZMgU7Ozv27NlDx44dsbKy4rvvvgPgzTffpHnz5tjZ2eHr68tDDz1EfHx8iddfHQ43b948QkNDsbOzo1evXpw6dapEus8++4ygoCCsrKxwd3enT58+xMXFAdeGfs+aNYvnnnsOJycnPDw8+OqrrwCYPXs2oaGhODg4MGLECNLT0/X5ljUs7Ndff6Vp06ZYW1vj6upKly5d2Lt3b6XPlzUF4McffyQ0NBRLS0sCAgL46KOP0Gq1+vNXh8sfPHiQgQMHYmtrS3BwMH/88cetVEuVXX0fli9fzqhRo3BwcOC+++4DdN+4jxs3Dm9vbywtLQkLC2PNmjX61/bo0YOXXnoJAFNTUzQaTbnBh/z8fN5++238/f2xtLSkcePG/PXXX6XS7dy5k379+uHg4IC9vT3t27dn7dq1nDlzhsDAQADuu+8+/RDOM2fOlDkFQKvV8tFHHxEQEIClpSWNGjXixx9/LHGtq7/DkZGRdOnSBRsbG5o1a8bq1atv+r4ppfjvf/9LSEgIlpaWNGjQgK+//rrM/G/8P3K1znfu3Enfvn2xtbVlwoQJAERGRtK/f39sbW1xdHRk1KhRnDt3rkS+Go2Gzz77jEmTJuHl5YWHh8dNyyuEEKK0K1eu8OKLLxIaGoqNjQ0BAQE899xzZGRklJk+IiICX19fbGxsGDZsWIm+zdW2aObMmTz99NO4uroSHh4OlD0FICoqihEjRuDi4oKNjQ0tW7bk77//1p//8ssvadeuHY6Ojnh4eDBkyBCio6P158eOHcvvv//OsWPH9G3i2LFj9edunAJQ2fbliy++YMqUKXh6euLm5sbjjz9+09EEV9u7vXv3Eh4ejpWVFY0bN2bZsmWl0i5fvpz27dtjbW2Nu7s7zz//fIn8r/ZL1q5dy+jRo7G3t8ff358vvviiRD47d+7knnvuwcfHB1tbW1q1asWsWbMqLKdGowFgwoQJ+vds06ZNjBw5ks6dO5dK/8MPP2BlZUVqamqF+QpRFRIAELVaQUEBo0eP5pFHHmHlypX069cPgMTERN5++22WL1/ON998w5kzZ+jevTtFRUUlXn/o0CEiIiL47LPPmDlzJrGxsTzyyCP683/88QfvvvsuTz75JKtWreLnn3+mVatWZGZmlsjnnXfewdramrlz53Lfffcxfvx43nrrLb755hu++OILvvvuOzZs2MDEiRPLvZctW7bw5JNPMmjQIFasWMEff/xB79699UGDm50vy7Rp03juuefo378/S5cuZezYsUyZMqXMcjz88MP069ePRYsW0bp1a8aOHUtUVNTNqqDaPPPMMzRs2JCFCxfyxhtvUFBQQN++fVm2bBkff/wxS5YsoUmTJgwePJjIyEhAN6Tx1VdfBXQN8c6dO2nTpk2Z+d9///38+OOPjB8/nmXLljFgwAD9781V27dvp0ePHuTn5/Pzzz8zf/58hg0bxrlz5/D29mbBggUAfPLJJ/rreXt7l3m9CRMmMGXKFMaOHcvSpUvp168fzz33HNOnTy+RrrCwkIcffpixY8eycOFCPDw8GDlyJCkpKRW+X6+88grvvfceY8aMYfny5YwdO5ZJkyYxY8aMEunK+z8CMHr0aHr16sWyZct49NFHOX/+PN26dSMlJYU///yTGTNmcODAAbp3705WVlaJfL/55huio6P55Zdf+PPPPyssqxBCCCgqKirxUEqRk5NDcXExH3/8MStXruSjjz5i8+bN3HvvvaVev3DhQhYuXMgPP/zADz/8wO7duxkxYkSpdG+99RZKKf7++28iIiLKLEtMTAwdO3YkJiaGb7/9liVLlvD444+X+EB+4cIFXnzxRRYvXszPP/+MVqulU6dO+g+j7777LoMGDaJBgwb6NvHdd98t83pVaV+mT59OTEwMv//+O++99x5//fUXH3744U3f38LCQh544AHGjBnDggULCAoKYvjw4fo+A8C8efO45557aN68OQsXLuSLL75gwYIFPPnkk6Xye+655wgJCWHhwoUMHTqUSZMmsWrVKv35s2fP0rlzZ37++WeWLl3KyJEjefLJJ/n999/LLePV6a0vvfRSiX7L008/zY4dOzh58mSJ9L/++ivDhw/HxcXlpvcvRKUpIWoJQEVEROifT548WQFq9uzZFb6uqKhIXbhwQQFq9erV+uPdu3dXtra2KjExUX/st99+U4A6f/68UkqpF154QbVp06bcvOPi4hSg7r///hLX8/T0VLa2tio5OVl/fPz48crJyUn/fOPGjQpQe/fuVUopFRERoVxcXMq91s3OK1XyPSoqKlJubm7qwQcfLJHmrbfeUhYWFvqyXb3n7777Tp8mOztb2djYqA8//LDC6xUXF6vCwkL9491331XdunUrcayoqKjCPK6+D88991yJ47/++qsyMzNTx44dK3G8ffv26r777tM///rrr9WNf8qu3lNSUpJSSqkNGzaUqn+llHrggQdUu3bt9M87deqkmjRpUm6Zr9b33LlzKzyelJSkzM3N1Ztvvlki3UMPPaTc3d31+V/9HV6+fHmpvGbNmlVmGZRSKjY2Vmk0GvXjjz+WOD5p0iTl5eWliouLS+R/4/+Rq+/PZ599VuL4a6+9pmxtbVVKSor+WFRUlNJoNOrbb7/VHwNUkyZNlFarLbeMQgghdK7+Lb7xUdbf+cLCQrVt2zYFqJMnT+qP+/v7K3t7e5Wenq4/tn79egWoVatWKaWutR8DBgwolW/37t3V4MGD9c9Hjx6t3N3dVUZGRqXuoaioSOXk5Cg7O7sSbc+YMWNU06ZNS6W/8XhV2pfw8PBSeTVs2LDC8l19j3/55ZcSZQ4MDNT3g7RarfL391cPPfRQideuXLlSaTQadfToUaXUtX7JhAkT9Gm0Wq0KCAhQTz75ZJnX12q1qrCwUD3zzDOqY8eO+uM39vWu3uP1/VmldP2p+vXrq4kTJ+qPRUZGKkCtWbOmwnsXoqpkBICo9QYPHlzq2MqVK+nUqROOjo6YmZnh5+cHUGLoGkCrVq1wd3fXP786R+7ChQuAbqG+gwcP8vrrr7Nt2zYKCwvLLEPfvn31P5uamtKgQQNatWqFq6ur/nhISAjp6elkZ2eXmUebNm1ITU1l7NixrF27lpycnCqdv9GJEydITk7WD6e/6oEHHqCgoIA9e/aUOH79N8O2trb4+/vr34fyPPHEE5ibm+sfH374IVu2bClxrLLzAG+sxzVr1tC8eXNCQkJKfGPSt2/fEtMeKmPNmjW4uLjQq1evUnkdPHiQ4uJicnJy2LVrF2PGjLnthZJ2795NYWFhme99UlJSid9DExMT+vTpo38eEBCAtbV1he/9unXrABg5cmSJ++nTpw8JCQmcP3++RPqy/o+UdXzr1q306tWrxDcNjRo1omXLlmzbtq1E2oEDB+qHMgohhKiYtbU1e/fuLfEYNGgQALNmzaJ169bY2dlhbm5Oly5dgNJ9lp49e+Lo6Kh/fvXv9e7du0ukK+9v/vXWr1+vn3ZXnl27dtG3b19cXV0xMzPDxsaG7OzsUuWqjKq0L9f3qUDXN7tZf+Sq4cOH6382NTXl3nvv1b8/0dHRnD17lvvvv79E29m9e3dMTExK7cp0fb9Io9HQuHHjEuVIS0vj5Zdfxt/fX9/n+emnn27p/TExMeHJJ5/kjz/+0I9W/fXXX/H396d3795Vzk+IikgAQNRqNjY22NnZlTi2d+9e/ZysWbNmsXPnTnbt2gVAXl5eibROTk4lnltYWJRIN3bsWL7++mtWr15N165dcXd355VXXiE3N/em+dws7xv16tWLWbNmcezYMfr374+bmxuPPfaYfqjdzc7fKC0tDQBPT88Sx68+v/F1ZZW3vLJeNWXKlBKdmaeffpo2bdqUOLZ06dIK87ixXFclJydz8ODBEsEEc3NzPvroo1IfcG8mOTmZ1NTUUnk99dRTFBUVER8fT1paGlqtFh8fnyrlXZaqvPfW1tb6342rbvbeJycno5TCzc2txP1c7TRd//6U9X/kxvJcX+4bj11Nd+PvS1nphBBClM3ExIS2bduWeLi4uLBw4UIee+wxwsPDmTNnDrt27WLhwoVA6f5CWeuteHh4lFrjqDJ/n1NSUips786dO0e/fv0oLi7mxx9/ZPv27ezduxcPD4+b9g3KUpX2paz+SH5+/k2vYW5ujrOzc6n8r74/V7cGHj58eIm208bGhuLi4lJ9i5v1i8aOHcvff//NG2+8wZo1a9i7dy9PPPHELb0/oPtSJSkpiRUrVlBYWMiff/7J2LFjDbbAsbh7yS4AolYr6xvIhQsX4ujoyJw5c/R/NM+ePXtL+ZuYmPDKK6/wyiuvcPHiRWbPns2bb76Jm5tbufPcbscjjzzCI488QnJyMosXL+a1117D3NycX375pVLnr3c1yp6YmFji+OXLl0ucvx0BAQEEBATony9btozo6Gjatm1b5bxurEsXFxdatGhR5r1VlYuLC+7u7qxYsaLM8x4eHhQWFmJiYsKlS5eq5Xqge+99fX31x6vrvXdxcUGj0bBt27ZSwQOA0NBQ/c8VfUtf1nt+4+8L6Mp94xaH8u2/EELcvrlz59KqVasSi8Ru3ry5zLRl/X1OTEwstRZNZf4+u7q6VtjerVq1iuzsbBYsWKD/IFxUVHTLi9FVpX25VYWFhaSlpZUIAly+fFn//lxte6dPn0779u1Lvb4qXwDk5eWxbNkyvvrqK/1ixECJRZarys/PjwEDBvDrr79SVFREcnIyjz/++C3nJ0R5JAAg7jq5ubmYm5uXaAD/7//+77bz9fX1Zfz48fz11181vjiem5sbTz75JCtWrCjzWjc7D7oPge7u7sydO7fEkLg5c+ZgYWGhXxnYWPXp04cVK1bg4+Nz29/K9+nThy+++AILCwtatGhRZhoLCws6duzIH3/8wfjx48ucBnCzURxXhYeHY25uzty5c2ndurX++Jw5c/Dw8Ljtzs7V4YApKSkMHTr0tvK6XpcuXfjpp59KdKBOnjzJkSNHeOKJJ6rtOkIIIXRyc3NLBXLL67Ns3LiRjIwM/TSADRs2kJqaWuaH2Zvp06cP8+bN4/PPP8fe3r7Mcmk0GszNzfXH5syZU2ox5cqMFoQ7174sXLhQn19xcTGLFi3Svz+NGjXCz8+P06dP88ILL9zWdfLz89FqtSXqLisriyVLltz0tebm5uW+Z08//TSjRo0iMTGR3r174+/vf1vlFKIsEgAQd52+ffsydepUXnrpJYYPH87OnTtvui1LeZ599lmcnZ3p0KEDzs7ObN++ncOHDzNu3LhqLjVMnjyZlJQUevTogYeHB5GRkaxatYrXX3+9UudvZGpqyrvvvsvLL7+Mh4cHgwYNYteuXXz++ee8+uqrJdYnMEaPPfYYP/74Iz169OCNN97Qr6Fw8OBBCgoK+PTTTyudV9++fRk6dCgDBgxg4sSJtGjRgitXrnDs2DFiY2P5+eefAd2Wj7169aJPnz6MGzcOZ2dnDhw4gJubG0888QReXl44OTnx999/ExgYiKWlZZkBBTc3N1566SUiIiKwsrKiQ4cOrFixgr/++otp06bd9hoDISEhvPDCCzz66KNMmDCB9u3bU1hYSHR0NBs3bmTRokW3lO9rr73Gb7/9Rr9+/XjnnXfIy8vjP//5D/Xr19dv7SSEEKL69O3blxdeeIEPP/yQjh07smLFCtavX19mWnt7ewYOHMibb75Jeno6kyZNIjw8nP79+1f5upMnT2bZsmV06dKFiRMn4u3tzfHjx8nJyWHixIn06tULgMcff5xnn32WY8eO8eWXX5YaFt+4cWN+/fVX/v77b4KDg3FzcysxMvCqO9G+WFhY8NFHH5GXl0dgYCDff/8958+f17eJGo2Gr776itGjR3PlyhUGDx6Mra0tZ8+eZfny5XzyySeVDtA7OjrSrl07PvvsM9zd3TEzM+Ozzz7D0dGxzJEO12vcuDGLFy+ma9eu2NraEhoaqg/CDB48GHd3d3bu3FliS0YhqpMEAMRdZ9CgQXz++edMmzaN3377jc6dO7Ns2bJb+ta1U6dO/O9//+N///sfOTk5+r3Wy9ou5na1a9eOqVOnMmfOHDIzM/Hz82PChAn85z//qdT5srz00kuYm5vz1Vdf8f333+Pt7c2UKVN4++23q7381c3S0pINGzYwZcoUPv74Y+Lj43Fzc6N169a3FICZN28en332Gd9//z1nz57F0dGRZs2alRhe16VLFzZt2sR//vMfxo4di6mpKU2bNuWjjz4CdFNCfvvtN95++2169+5Nfn4+cXFxZV4vIiICJycnfv75Zz766CMCAgKYMWMGzz777K29ITf49ttvCQ0N5ccff+SDDz7Azs6O0NDQUgsPVkW9evXYvHkzb7zxBg8//DCmpqb07duXr776qsxviIQQQtyeZ599ltOnTzNt2jQiIiLo378/f/31Fx06dCiVdvjw4fj5+fHcc8+RlpZG3759S239WlnBwcHs2LGDt956i3HjxlFUVERISAhvvvkmAM2bN2fmzJlMmTKFIUOG0KpVK+bNm1eqjXnyySfZs2cPL730EikpKYwZM4aZM2eWut6daF/Mzc35+++/eeGFF4iMjCQwMJD58+eXCNTfd999ODk58fHHH+u3sA0ICGDAgAFVXtvmr7/+4tlnn2XMmDG4urry8ssvk52dzX//+98KX/fdd9/xyiuvMHDgQHJzc9m4cSM9evQAwMzMjKFDh5YavSlEddIopZShCyGEEEIIIYQQt2LKlCn897//LXenpdpCq9XSsGFDhgwZwrRp0wxdHHGXkhEAQgghhBBCCGEgBQUFHD58mHnz5nH+/HlefPFFQxdJ3MUkACCEEEIIIYQQBnLp0iXCw8Nxd3dn+vTpJXbzEaK6yRQAIYQQQgghhBCiDjAxdAGEEEIIIYQQQghR8yQAIIQQQgghhBBC1AESABBCCCGEEEIIIeoACQAIIYQQQgghhBB1gOwCUEl5eXlERkbi7u6OmZm8bUIIIQynqKiIpKQkmjdvjpWVlaGLUydJv0AIIYSxqEq/QFqsSoqMjCQ8PNzQxRBCCCH09uzZQ7t27QxdjDpJ+gVCCCGMTWX6BRIAqCR3d3dA96Z6e3sbuDRCCCHqsvj4eP2e0cIwpF8ghBDCWFSlXyABgEq6OrzP29sbPz8/A5dGCCGEQIaeG5D0C4QQQhibyvQLZBFAIYQQQgghhBCiDpAAgBBCCCGEEEIIUQdIAEAIIYQQQgghhKgDJAAghBBCiDpn2bJlhIaGEhwczM8//2zo4gghhBB3hKweJIQQQog6paioiDfeeINNmzZhb29P27ZtGT58OK6uroYumhBCCFGjZATATURERODh4UHLli0NXRQhhBBCVIM9e/bQvHlzvL29sbOzY/DgwaxZs8bQxRJCCCFqnAQAbmLChAkkJiZy+PBhQxdFCCGEEMCWLVsYOnQoPj4+aDQali1bVirNd999R0BAAFZWVnTo0IG9e/fqz126dAlfX1/9cz8/Py5evHhHyn6j1NRUEhISqvRITEwkKSmJlJQU0tLSSE9PJzMzk6ysLK5cuUJBQYFB7kUIIYTxkykARkopRXxGHh72lpiZSpxGCCGEuOrKlSu0bNmSJ554ghEjRpQ6/88///D6668zY8YM2rdvz9SpU+nfvz/R0dG4ubkZoMTlGzFiBJs3b67WPE1NTXnkkUf47bff0Gg01Zq3EEKI2k0+WRqh45cy+W7uCmJ+fITtq+cYujhCCCGEURk4cCAfffQRw4cPL/P8V199xTPPPMPjjz9OkyZNmDFjBtbW1sycORMAHx+fEt/4X7hwAR8fnwqvmZmZyYULF/SP+Pj4aruf6lZcXMzvv/9e7YEFIYQQtZ8EAIxI9OUsPlp2nF8XLqdN1JfsOXiMjA3forKTDF00IYQQolYoKChg//799OvXT3/MxMSEPn36sHPnTgDCw8M5cuQI8fHxZGdns2zZMvr3719hvl999RX16tXTP8LDw2v0PqrD2rVrDV0EIYQQRkamABiB00nZzNl3gUPn0/AvjOPexJ94dMY+TidewdrChHWB79HphR8MXUwhhBDC6CUnJ1NcXIynp2eJ456ensTGxgJgZmZGREQE3bt3R6vVMnHixJvuAPD666/z1FNP6Z/Hx8dXSxDgyy+/JC0trdLplVIopdBqtfp/r//5yy+/ZNu2bQCsWbuWjz/++LbLKIQQ4u4hAQADOpeSw9z959l7JhWAIe7JtDrxC4O+28P5lFwAcgu0/Pe3hSwYOgbqdzBkcYUQQoi7xj333MM999xT6fQODg44ODhUeznCwsKqNb9z587pAwAH9u8nPT0dJyenar2GEEKI2kumABjAhbQcpq6LZuL8w+w9k0qYvzNfdtbS5uRU+n2xQ//h/6olBxM5szQCCnIMVGIhhBCidnBzc8PU1JTLly+XOH758mW8vLwMVKo7p3fv3vqftVqtrAMghBCiBAkA3GEZOYW8OT+SXadTaOHnxEf3NmNCk0wSF7xD90+2EZ+eV+o1xVpFxIJ9cOj/DFBiIYQQovawsLAgLCysxPx3rVbL+vXr6dixowFLdmc0adIEd49rOx2sXiPrAAghhLhGpgDcYY425tzfrh7BHnY09naAszvZ/eskBvx3F+k5hfp0w4YNo7i4WL+38W/bLvHhnrm4NOgJbkGGKr4QQghhcNnZ2fr5/ABxcXEcOnQILy8vvLy8eP311xkzZgxhYWGEh4czdepUcnJyGDt2rOEKfYdoNBr69OnL33/9DcAqCQAIIYS4jowAMIB7WvroPvzHbWXzjPH0+WJniQ//Dz74IHPnzuWpV68tNpRbUMT3G8/Bjm9BW2yIYgshhBBGYd++fbRu3ZrWrVsD8PLLL9O6dWtmzJgBwAMPPMB///tf3nvvPVq1asWhQ4dYtWoVbm5uFWV71+jbp6/+57jYaC5dumTA0gghhDAmEgAwlFMbWT39DQZ8uYfsvCL94SeeeII///yTo2lHWVy0mJA2Ifpz32y4RG5CDEQtNUSJhRBCCKPQo0cP/Wr41z+mTJmiT/Piiy9y9uxZ8vPz2b17d63Ytq+6XL8OAMDatesMVBIhhBDGRgIAhhCzjsXfTOCeb/eRV3jt2/wXX3yR//3vf+QU5zDz6EwA/If5688np2fxx750ODgLspPucKGFEEIIURvUr1+f+oH19M8XLF9lwNIIIYQwJhIAuNOuJDP76zcZ+d0BCoq0+sMTJ07k22+/RaPRMOv4LLIKs+jo3RHfdr54B3rr03257iLFBXmw+wdQyhB3IIQQQggj17tPH/3PWzdtQEmfQQghBBIAuON+m7OU0TMOUKy91hC///77fPbZZ2g0GvYk7GHf5X20cm/FU82fwt/Rn6Dh1xb9i4k7z+ILznB+D5zbaYhbEEIIIYSRG9x/sP7ntKTLnDx50oClEUIIYSwkAHAHbdiwgSeeeKJEFD4iIoL33nsPjUZDel46fx7/E1tzW8Y0HYNGo2FY0DACewTi4Oaof80Xy06gzKxg9wwoyDHErQghhBDCiPXs2RONRqN//s/ilQYsjRBCCGMhAYA7qHv37owePVr//LvvvuONN94AQCnFzGMzuVJ0hceaPIajpe4Dfyv3VgS6BhJ6z7XFAJ4RUB4AAQAASURBVHfv3c822kFOqm49ACGEEEKI67i4uBDUtKH++fJVqw1YGiGEEMZCAgB3kKmpKTNnzmTkyJH8+uuvjBs3Tn9u28VtHEk+Qnuv9rTzaqc/rtFoGNpwKMGDgjG3ttQfj5izHdxCdDsCJEXf0fsQQggh6qqIiAg8PDxo2bKloYtyUz1799L/fGTvDoqLZRthIYSo6yQAcIeZm5szd+5cHn/8cf2x5Nxk/j7xN44WjjzS5JFSr2nj0YaGXg0JHhCsP7Z06VKOuwwAjQns+BaKi0q9TgghhBDVa8KECSQmJnL48GFDF+Wm7h1wr/7n/CtZrNosawcJIURdJwEAA7h+Tp5Sil+P/kpecR5jm43F1ty2zPT3NLyHpsMbozG9VmVf/vIPNB0OaWdg2SsQf+ROFF8IIYQQtUD3bt0xNTfVP5+9aLkBSyOEEMIYSADAwDac28CJ1BN08e1CS/fyhxOGeYYR2iAUvy6B+mOzZs3ikmdvaD4KMi7A6rdh02eQnXgnii6EEEIII2ZjY0Oj1o30z7dt3mS4wgghhDAKEgAwoIQrCcyNnouLlQsPNXqowrRXRwE0H9VEf6ywsJBvv/sewsbCsO/Brx2c2QYLn4NDf0NRvj7t2cyzrIxbSbFW5v8JIYQQdUX3nt31P5+POsCF5AwDlkYIIYShSQDAQLRKyy+Rv1CgLeCJZk9gbWZ909e09WxLq1bNcWnhrT/2ww8/kJmZCY6+0Gcy9JkCtm5w6P90gYAz2zmWfIxP93zK3Oi57Li0owbvSgghhBDGZPig4fqfiwsL+HPxGgOWRgghhKFJAMBAVp9ZzamMU/Su35smrk1u/gKujQIIGX4tfWZmJj/99NO1RH5tdaMB2j4OBdns2zSZr9e8QPa5ZK6cvcKSmCUUaWXBQCGEEKIu6NGpBxY2FvrnK1evM2BphBBCGJqZoQtQF13MvsiCmAV42HgwKmRUlV7bzqsd4V3aEBlwgCtn0gCYOnUqL7/8MhYWugY+t6CQ/eme/BXpwPINm0k+mUZOpu5Df4MeDRj8+2B61O9RrfckhBBCCONjZmZG43aNObxZt2vBsX3bycorxN7K3MAlE0IIYQgSALjDirRF/O/I/9AqLU82exJLU8sqvd5EY8JDTUewdshWoqbvAuDixYtMmjQJgB07dnDw4EEKCwvLfP3pTaf578//pcuULpiZSPULIYQQd7suPbroAwCpZ6LYHHmGIe2Cb/IqIYQQdyOZAnCH5RTlYGlqSf+A/gQ731rjG+4VTsue7bB0v7Zl4NSpU5k6dSp79uwp98P/VRu+XcvKYytv6dpCCCGEqF3uHXiv/meltMxbLusACCFEXSUBgDvMwcKBSeGTGBE84pbzMNGYMLrZCLz6B1WYztLSks6dOzNhwgTefPNN/fHcjAL+M3E8hdqKAwVCCCGEqP16tuuJjfO1xYZ3bd1MXqHsCiSEEHWRBAAMwERjctvD7wcFdSWoRxi2/s76Y04eTgR0DWDIa0PYtG0TmZmZbNy8heHPTsKuy6P4NWmrT3tkVQw//P6f2yqDEEIIIYyfqYkpIeGh+ufxx/dy6Hy64QokhBDCYGQS+E1EREQQERFBcbFxRcpNTUwZEDyM9EnJdDRvhrO3KRfMLtDKvRXPt3yey5mF/LP/Epujk8nOL0SDhhYPvkH8h49S/O8UgQ/+n737Do+q2ho4/Jv03nshhRAgCSmEhN67NOl6UVEs2K6FYkVsqBdjQWxcxUJTadJ7ld4hkISQQAIhpPfeZub7I9fBfKGGhElZ7/PMg7PPnjPrEMw+s2bvtd/5micHTcLUNVDLVyOEEEKIhtS9T3fObDsDQEHaZXYeP08X7x7aDUoIIcR9JzMAbmPmzJlkZGQQGRmp7VBqeTiwP0aGdsSZJZCsl0y4Y1f8Tcbz4cYLzFgZyaZzqZga6vJweCu+m9SRnp2CaD9ksub12ddKeWnaRChM1+JVCCGEEKKhjRg8osbz7bt2UaVUaSkaIYQQ2iIJgCbM1cqU9mb9KSyrxKQyhCOnA/lx32USs4rp4WPHO8P9mDcxmFHBrlibGjC5mwcBQx/DxsVTc45Fay4Qu+RlKC/U3oUIIYQQokH1COiBuYu55vnVqGNEpxRoMSIhhBDaIAmAJm64b29cK54jK6UTDuZGPN7Nk+8fCeXFfm3wd7FEoVBo+jpbGjMq1IOgh2dq2pSVaiZ9tx31zg+gqkIblyCEEEI0GRERETg4OBAUFKTtUO6Kqb4pPmHXiwdnxJ7gaEK2FiMSQgihDZIAaOIG+zvxaOf2zHmwA3PHBjIkwBkzw5uXdngwxJV2IZ1p0/P6VMBT0bksWb8D9n8OavX9CFsIIYRokhrz0sDb6dKri+a/S3Iz2HX0NCqVjPtCCNGSSAKgiTPS12VkkAs+DmY1vu2/Vf9HOnvg/+DzmFle30Hg5RVx5ETvgeMLGzJcIYQQQmjJ0IFD4R+3ChfPHCE+o0h7AQkhhLjvJAHQAnVtbUtwG3f8x7yoacvLK2XmhlSIWQfRa7QYnRBCCCEaQqhXKLatbTXPM2JPcvxyjhYjEkIIcb9JAqAFUigUPNHNC68uQ/EM7Kxp/3l7FPuTdeD4T5B0VIsRCiGEEKK+OZs606pjK83zzAsnOZqQiVqW/wkhRIshCYAWqpWtCYP9nfAbNw19A0NN+zNLzlOhYwz7IiAnUYsRCiGEEKI+KRQKOvXspHleXlLIhaizJOeWajEqIYQQ95MkAFqwcZ3ccfHwJnD4E5q22LiLRMQ4gbICdr0PpblajFAIIYQQ9WlA7wHo6F2//UuPPcGxRFkGIIQQLYUkAFowM0M9/hXeCq9+D+Hs0VrT/uG8H4l3GgXFWbD7I9keUAghhGgm/F38cWhvr3medeEkJ65IAkAIIVoKSQC0cH3a2uPrYoPf+OmatvLycvo//T7HCYLMWDj8tWwPKIQQQjQD3pbeuAS7ap5nXowkPiWHzMJyLUYlhBDifpEEQAunUCh4orsndm2CCRkwWtN+9epVej77OT+f04FLeyBqtRajFEIIIUR9MNYzJqh7kOZ5ZUU5GRdOclJmAQghRIsgCQCBj4M5fdo64DXiBQK7Xt8VoLy8nCe/2MBjv1+k4ujPcOWwFqMUQgghRH3o2bUnRpbXCwCnRx3iWKLU/BFCiJZAEgACgIfDWmFpYUG3575m+oyZNY4t2X6BdnMPcmzdbMi+pKUIhRBCCFEffG19cQtz1zxPjz5ETEo+BWWVWoxKCCHE/SAJAAGApYk+40PdyC2tInT8i6xcuRJTU1PN8cSLBfSZ/Rf//moiF1NPajFSIYQQQtyL1latce98PQGQn5lG3rWLnLoiswCEEKK5kwSA0Bjo54i7tQnrzlwjxyGEvw4cok2bNprjpfmVfPvxSR59cyL/OfIxl/Mvay9YIYQQQtSJo4kjvp190dG9fhuYcvYgxy9LHQAhhGjuJAEgNPR0dXh9aDv8nC3ZHZvBr+eVLFq3g+HDh2v6qJVwZNElfnr9Gz47/BllVWVajFgIIYQQd0uhUODn6odTB0dNW27sEc4m51NWqdRiZEIIIRqaJABEDXZmhrwzvD2Tu3qSV1LBV/tTGPP6V8yaPbtGv4v7UvnjhSWsPi27AwghhBBNjY+VD27/WAZwLe4shXnZnE3O12JUQgghGpokAEQtCoWCoR2cmTs2EB8HM7bFpFPkN5r/Ll6OpaWlpl92QgHvvz6bgooCLUYrhBBC3D8RERE4ODgQFBR0+86NWKB9YI06AGq1mtSoI7IMQAghmjlJAIibcrEy5v2RATwU1orMwnL2lLbi3YXr8PP31/SJ35vAd1u+02KUQgghxP0zc+ZMMjIyiIyM1HYo98TVzBXv1t5Yu11P7OdfOMqpK7lUKVVajEwIIURDkgSAuCVdHQUPhrjy0egA3G2MOZpjQPfnPkVfX7+6gxoWfDKfzJJM7QYqhBBCiDumUCjo6NARl3A3TVvS2cMUlJQSm1aoxciEEEI0JEkAiDviYWvKx6M7MDrElUJ9Gzy7j9Acu3I0lc9XfqLF6IQQQghxt0IcQmosAygtLiTrYiTHEmUZgBBCNFeSABB3TE9Xh4lhrfjwQX+6jX0GXX1DzbElny/iSsEVLUYnhBBCiLvhY+WDV7AXhqb6mrbc2KOcuJKDWq3WYmRCCCEaiiQAxF3zcTBnUr9g2vQdp2lLOZfDJz+9rsWohBBCCHE3dHV0CXUOxaWjs6YtLeogOcUVXMos1mJkQgghGookAESd9GxjR8iIyRgYm2ra/vxuE1Fpp7QYlRBCCCHuRohDCO5dPDXP069epjA9iROyG4AQQjRLkgAQdWKkr8vQTr74DnhY05Z5sYiPv50m0waFEEKIJiLALgDPcE8U/7gjzD5/hOOXc7UXlBBCiAYjCQBRZ4P9HGnb/yFMLKw0bVsXHePwhbVai0kIIYQQd85A14BQ71DsfW00bXmxR7iWV0JKXqkWIxNCCNEQJAEg6szBwojO7VxpM+gRTVvu1VI++e5dKpUVWoxMCCGEEHeqejeAVprnF8+doKKkkOOyDEAIIZodSQCIezI0wBmf3mOxsnPUtP21PI6dh77QYlRCCCH+v1GjRrFu3TqUSqW2QxGNTJBDEK26emmeK6uqyIo9LgkAIYRohiQBIO6Jv4sFHg7WtH/gcU1bYUY5Eb/8SElhivYCE0IIUYO9vT2TJ0/GxcWFadOmERUVpe2QRCNhYWBBWHAYZvbGmraSi8e4mFFEbrHM6BNCiOZEEgDinigUCoYEOOHWZRhObh6a9mPrrrJ+xywtRiaEEOKfFi5cSGpqKp9//jnnzp0jODiYTp068d1335GbKwXfWroQxxDcwq5vBxh/cj8qlVJmAQghRDMjCQBxz3q2scPM2IjgB5/RtBXnVPL1qp3kJe7TYmRCCCH+ydjYmEceeYQdO3Zw+fJlhg0bxvTp03FxceGhhx7i0KFD2g5RaEmIfUiNZQAFebnkXY7mxBVJDgkhRHMiCQBxz4z0denb1h5z/1609m2naT+1MZXle+dAVbkWoxNCCPH/RUZG8tlnn/Hdd99hY2PDyy+/jKGhIQMGDODtt9/Wdnj33bhx47C2tuahhx7Sdiha42jqSEjXTugb6mrayhNOEJ2ST3F5lRYjE0IIUZ8kASDqxWB/J3R19Og64QVNW1lhFT9ujCZ1fwSo1VqMTgghRHZ2NvPnz6djx46EhYVx5coVfvnlF65evcp//vMfFi1axNatW5k/f762Q73vXnzxRRYvXqztMLQuvFU4zoF2mudJZw6gVKk5nZSnvaCEEELUK0kAiHrhYGFERw8rKtw6EtwxVNN+bms6P8VsQH3gS1CptBihEEK0bC4uLixYsIB//etfJCcns2bNGoYPH46OzvVbgb/rArQ0ffr0wdzcXNthaF2wQ3CN7QAvx8dSnJUqdQCEEKIZkQSAqDdD/J1RKBQMfOwVTVtFiZKV29M4emkT7P8clDKNUAghtGHPnj3ExMQwY8YMHBwcbtjHwsKCPXv23PE5k5OT+de//oWNjQ3GxsaEhIRw/vz5+gqZffv2MWLECFxcXFAoFGzcuPGG/b799ls8PT0xMjKiS5cuHD9+vN5iaEm8LLzw6x1co63y8knOXM2jrFK2jxRCiOZAEgCi3gS4WuBqZUKGeRt69+mjaY/ZnsKPpVUUJe6Bv+ZKEkAIIbRg1qxZ5OXl1WovKCigX79+d32+3NxcevTogZGREdu2bSM6OpqPP/74pt+kHzhwgKqq2r//T506RUFBwQ1fU1xcTFBQEN9+++1N41i+fDnTpk3j3Xff5dSpUwQGBjJ48GCysrI0fQICAm74qKiQLe7+SaFQ0NOvJ3be13+GWTGHKa9ScjRRZgEIIURzIAkAUW/+3hKwrErFqCena9qryqrY+E0sS00tIekw7JkDVXLTJYQQ99PevXtv+IG3vLyc/fv33/X55s6di7u7Oz///DNhYWF4e3szdOhQ3NzcavVVKpU8++yzPPbYY6j+sRzs9OnT9O/fnzVr1tzwPYYOHcqcOXMYPXr0TeP44osveOaZZ3jiiSfw8/NjwYIFGBsb8+uvv2r6REVF3fBhYGBw19fd3HV06IhbmIvm+bnjB1FXlLEnNkOLUQkhhKgvkgAQ9apnGztMDPS4qu/GuHHjNO0ZMRnMX3KGaJcASD4Buz+Q3QGEEOI+iImJISYmBoC4uDjN85iYGM6dO8evv/6Kq6vrXZ93/fr1dOrUibFjx+Lg4EBoaChLly69YV9dXV22bNnCoUOHePrpp1Gr1URHRzNo0CBeeOEFJk+eXKdrq6io4OTJkwwaNEjTpqOjw4ABAzh8+HCdznk7ERERODg4EBQU1CDn17a2Nm3x6d5W87yiogKznPPEphWQml+qxciEEELUB0kAiHr195aAKfmlvDQ7gtatW2uOnd8Qy8y9Z6lo3RdSzsCOd6GiRHvBCiFECxAQEECHDh1QKBT07t27xhT4oKAg3nvvPWbPnn3X501ISOC7777Dz8+P7du3M2XKFKZMmcK6detu2N/d3Z1du3axdetWHnvsMQYMGMCkSZOYM2dOna8tKysLpVKJo6NjjXZHR0fS0tLu+DzDhg1j/PjxrF+/Hjc3N06fPn3TvjNnziQjI4PIyMg6x92Y6eno0bfHYIyt9DVtebFHAdh7IVNbYQkhhKgnkgAQ9W6wvxMKFBxMLmPt2rWYmJhojm3/fDtfZFZC2wcgPQp2zIaKYi1GK4QQzVtiYiKXLl1CrVZz9OhREhMTNY9r165RUFDAlClT7vq8KpWKsLAwPvzwQ4KDg3nhhRd45JFHWLBgwU1f07p1axYuXMjSpUtxdHTkyy+/vJdLqzebNm0iMzOTkpISkpOTCQkJ0XZIWhXqFIp7x+uFIg/v3YGNiT774jJRqmRbXyGEaMokASDq3d9bAp65moute2t++eUXzTFlhZI5z83htGMX8BsFmbGw7W0oL9RixEII0Xx5eHjg6emJSqWiU6dOeHh4aB7Ozs7o6urW6bxOTk60a9euRlv79u1JSkq66WuSk5N54YUXGD16NMnJybz77rt1eu+/2dnZoaurS3p6eo329PR0nJyc7uncLVkHuw54dPbQPE9NTaWVOp3ckgrOXM3VYmRCCCHulZ62AxDN0xB/Z05eyWV7dDqTJ0zg+PHjfPbZZwAUZxQzduI4zh+IwVDXAM6thK1vwKCPwNhKu4ELIUQzsnnz5jvu+8ADD9zVubt160Z8fHyNtri4OFq1anXD/unp6fTv35/w8HB+++03TQFAU1NTXn/99bt6778ZGBgQGhrKjh07GDFiBFA9M2HXrl288sordTqnABN9E/oMGMDuiMMoq6q/8c85fwSF5zD2xGYS6mGj5QiFEELUVYtJAGzcuJHp06ejUql4/fXXeeqpp7QdUrP295aAey9kMKGTO5988gmnTp1i9+7dACSeSOSRlx5l5YIVoGsAZ5bB9rdh8MdgZKnl6IUQonkYPnz4HfVTKBQolXe3z/urr75K9+7dmTt3LmPHjuXgwYMsWbKElStX1uqrVCoZMmQI7du3Z+nSpejo6BAaGsrmzZsZPHgwbm5uTJo0qdbrioqKuHjxouZ5YmIiZ86cwcnJSfMN/7Rp05g8eTKhoaGEh4czb948SkpKePzxx+/qekRNXXx64+T3NdfOVn/jv2PLRsbNeZhTSbnklVRgZSI7KAghRFPUIpYAVFVVMWPGDPbu3cvp06f57LPPyM7O1nZYzZpCoWCwvyOllUp2xaajp6fHH3/8UeOboVU/rGLhsp8g+GEIeQRyr8hyACGEqEcqleqOHnf74R+gc+fOrF69miVLlhAQEMCnn37Kjz/+qPkm/p90dXWZO3cuK1asQE/v+ncP3bp1Y9u2bQwZMuSG73HixAlCQkI0a/JfeuklQkJCatQZmDhxIp999hmzZ88mODiYM2fOsHXrVuzs7O76msR1wQ7BtAp31jw/c+YMLlVpqNRq9sVnaTEyIYQQ96JFJACOHTtGhw4dcHZ2xszMjGHDhrF9+3Zth9Xs9fK1x8bUgOXHr3Ipswh7e3v+/PNPDA0NNX1eeOYFzp07B0EPQfC/IPeyJAGEEKKJGDVqFFFRUZSVlREdHc2jjz56076DBg3CwKD2t8bdunXD1tb2hq/p06cParW61uO9996r0e/FF1/kypUrlJeXc/ToUcLDw+/pugTYGNnQe1gPdPUUmrajW1dhZqjH3tgM1GopBiiEEE1Rk0gA7Nu3jxEjRuDi4oJCoWDjxo21+nz77bd4enpiZGREly5dOH78uOZYSkpKjT2O3dzcuHbt2n2JvSUz0tdl2kBf1Gr4Ykcc+aWVhIaG1vjmpqK0ggdGPUBeXh4EPQyBEyEnAba/A+VF2gteCCGaoZycHH777Tf+85//8MEHH9R4CPH/dfMfikeYteb5H7//Ric3U1LyS4lLlzFaCCGaoiaRACguLiYoKIhvv/32hseXL1/OtGnTePfddzl16hSBgYEMHjyYrKy6T1ErKCggOTlZ80hNTa3zuVoyHwdznujuSXZROfN3xaNUqXn88cd5/vnnNX2SE5N56F8PoVKrq5cCdBgH2Rf/t0VgiRajF0KI5uPgwYO0bt2at99+m3feeYdly5Yxd+5cPv/88xsm1oUIcepE2wHXl+7l5+dTHHsQgD0XMrQVlhBCiHvQJBIAQ4cOZc6cOYwePfqGx7/44gueeeYZnnjiCfz8/FiwYAHGxsb8+uuvALi4uNT4xj85ORkXF5dbvucXX3yBu7u75iHTCeuuf3tH+rVzIDoln9+OVW8P9eWXX9K9e3dNn21btvH++++DQgEdJ4P/aMiKkySAEELUk5kzZ/LUU0+RmJiIkZERW7ZsITk5mW7duvHss89qOzzRCLmauRIQ3gErx+tL99b+sRgvO1MOX8qmtOLua0cIIYTQriaRALiViooKTp48yaBBgzRtOjo6DBgwgMOHDwMQHh7O2bNnSU1NpaioiI0bNzJ48OBbnnfatGlcvXpV8zh27FiDXkdz90R3L1rbm7HpbAqHLmVhYGDAypUrcXa+XmDogw8+YOHChdVJgE5TwG8UZMbCzvegslR7wQshRDMQFRXF1KlTAdDT06O0tBRra2s+/vhj5syZo+XoRGOkUCjo3HooPr3tNW0HDhygtX4+5VVKjiRIQWUhhGhqmnwCICsrC6VSiaOjY412R0dH0tLSgOobnYiICHr37k1wcDDTp0+/acGhv1lYWODm5qZ5/PODqrh7+ro6TBvoi4WRPgv+SiApuwRnZ2dWrVqFvr6+pt8zzzzD0t+XVicBwp6C9iMgI+Z/SYAy7V2AEEI0cSYmJlRWVgLg5OREQkICUF2hPyNDpnOLG+vtOZA2/bzR0b1eDPDcnrXo6+rIMgAhhGiCmnwC4E6NHDmSuLg4Ll68yDPPPKPtcFokWzNDXhngS5VSxec7LlBUXkW3bt34+eefNX3UajWTH53Mzyt/rk4ChD8DbR+A9GjY9QFUlWvxCoQQounq3LkzBw9Wr99+4IEHmDFjBnPnzuWpp56ic+fOWo5ONFZ2xnaEt++Be7Clpu33pUvo6GpGXHohybmyTE8IIZqSJp8AsLOzQ1dXl/T09Brt6enpODk5aSkqcTN+LhY82sWD9IIyvtl9EbVazSOPPFKjwKNKqeKZR57hsz8+Qw3Q5TnwHQJpZ6uTALIcQAgh7trnn39OaGgoUL3kqm/fvixbtgx3d/caiVgh/r9+7Sbg2/f6TMjMzEzUV04CsPdCprbCEkIIUQdNPgFgYGBAaGgoO3bs0LSpVCp27dpF165dtRiZuJkhAU708LHjzNVcVp5MBuD555/nk08+0fRRVih5c8qbTF8ynaLKYuj6ArQZBKmRsHkGFKZpK3whhGiSfHx8CAkJAcDU1JQFCxZw9uxZVq9ejYeHh5ajE41ZgH0HArsGYGZjoGnb9ucyHMyN2BeXSZVSpcXohBBC3I0mkQAoKirizJkznDlzBoDExETOnDmjWeM/bdo0fvjhBxYtWsT58+d57rnnKCkp4fHHH9de0OKmFAoFT/fyxtPWlD9PJXPicg4Ab7zxBm+++aamX1VpFd++8C3PL3ueC7lx0O3fEDwJcq/AxlerkwFCCCHuSkVFBcnJySQlJdV4CHEzOgod+rUfi0/P6/WTduzYQXuzMgrKKjmVlKe94IQQQtyVJpEAOHHiBCEhIZpvLl566SVCQkJYsGABABMnTuSzzz5j9uzZBAcHc+bMGbZu3YqdnZ02wxa3YKiny7SBvpgZ6vHtnouk5FVP6//oo4944YUXNP0qiipYPWM1s9bNYn3CBlRBE6Hv26CshO2zIGY9qNXaugwhhGgyYmNj6d69O8bGxnh4eODl5YWXlxeenp54eXlpOzzRyPVoPZS2/TxR/K8WoFqt5tLBDShQSDFAIYRoQuqUAMjOziY7+/rWL+fPn2fOnDmsXr263gL7pz59+qBWq2s93nvvPU2fF198kStXrlBeXs7Ro0cJDw+vl/eOiIjAwcGBoKCgejmfuM7BwoiX+rehrFLFZ9svUFqhRKFQMH/+fB599FFNv5KcEna8tYOlh5fy2YnPKHD2h2Gfg5kjHPsBDn5VnRAQQghxU48//jiGhoZs3bqVyMhIzp49y9mzZzl37hxnz57VdniikbMwsKB/UB9cAiw0bX8sXUyAixlnkvLILa7QYnRCCCHuVJ0SAGPHjmXdunVAdSGY7t278/vvvzNlyhQ+++yzeg1Q22bOnElGRgaRkTLdvCEEulnxULg7KXmlLDp8GQAdHR1+/vlnRo8eremXn5bP/nf2czrhNHOOzCFFXx+GfwkuwXBxJ2x9A0pytHMRQgjRBJw7d44FCxYwcOBAAgIC8Pf3r/EQ4nb6+j+Kb28HzfNr165hlH4ONWr+ipNigEII0RTUKQFw9uxZTYG9FStW4OPjQ3R0NMuWLeO///1vvQYomr+RQS74u1iy90IGp5NyAdDT0+P3339n4MCBmn5pl9M48cEJUjNTmXNkDlGFV2DA++D/IGRegA0vV/8phBCiltDQUK5evartMEQT1tq2Hd16BWFsoadp27dhOWaG+uy9kIFaluQJIUSjV6cEQHl5OSYmJgBs376dBx98EICgoCCSk5PrLTjRMigUCqb28sZQT5cf9ydQXF4FgKGhIWvWrKFbt26avhdjLnLqw1OU5JQw7+Q8dif/BWFPQY9XobwQtrxWPSNACCFEDdOmTePVV19l2bJlREZGEhMTU+MhxO0oFAoG+o+jdffrxQA3bdxIoK2atIIyzqcWajE6IYQQd6JOCQB/f38WLFjA/v372bFjB0OHDgWqp4LZ2NjUa4CiZXCwMGJS51bkFFew5MgVTbupqSmbNm0iODhY0xYTGcOO6TuoulbF0vNLWXZ+GUrvPjD0UzCyhAPz4OgPoKy679chhBCN1ZgxY4iKiuLRRx8lJCSEgIAAOnTooPlTiDvRuc0oOvRz1zxXKpWkHNsCIMUAhRCiCahTAmDu3LksWLCAPn36MG7cOE11/vXr19db8T3R8gz0c6y1FADAysqK7du3ExAQoGlLSU5h9curUUWr2JW0i69Of0WJlRsMnwf27eD8etj6OhTJzYgQQkD1Frr//5GQkKD5U9yZll4c2EjfmGGh/XFsa6ZpW/XbYto4mHH4UjY5UgxQCCEaNYW6jgu2lEolBQUFWFtba9ouX76MiYkJDg4Ot3hl05ScnIy7uztXr17Fzc1N2+E0WxmFZby26izG+rpEjA/CzPD6OsP8/HwmTJjA9u3bNW06OjqMnzEe477GuJq58nLHl7E3tIaTv0DMOjAwq14e0KqzNi5HCCEahIxJ2teSfwYp2Rd4+K2h7PshUdP2/W9r2VvowAMdnHmsq6f2ghNCiBbobsakOs0AANDV1dV8+M/MzGTp0qVkZmY2yw//4v5xMDfikc4e5JZUsPh/uwL8zdLSkk2bNvH8889r2lQqFcs/XU7G0gySC5KZc2QOFwsuQ/jT0G8WoIbdH8KxH2VJgBCixduwYQPDhg3Dz89PUxDwv//9Lzt27NByZKIpcbFty8DegRgY62ra9m9cQSsbE3aezyC/VLbmFUKIxqpOCYChQ4cyf/58AAoLCwkNDeXf//433bt3Z/HixfUaoLa19Kl+2tC/vQMdXC3ZF5fJqX8sBYDq3QG++eYbvvrqK3R0rv/z3bxsMxc+vUBBQQFzj8/l0LVDqN07w4j5YNemejbAltdkSYAQosX69ddfefTRRwkMDCQxMZHKyuoPaTo6Onz66adajk40NYMDxuLd9Xrdp9WrV9PP04SKKiVbzqVqMTIhhBC3UqcEwIkTJ+jXrx8Aq1atwtzcnIyMDH766admdxMxc+ZMMjIyiIyM1HYoLYZCoeCZXq0x1tflx30JFJVX1Tr+0ksvsX79eszMrq9BPPLXEQ6+eRBVtoqFUQuZd2oe6TrA0AjwGwVZcbD+35B09D5fkRBCaN9nn33GwoUL+eSTT9DTu768qkuXLjLGibsW4jeB0H6umufl5eVcOLgZZ0tjtkWn1Rq7hRBCNA51SgAUFRVhYWEBwLZt2xgzZgz6+vr07t2bxMTE27xaiNuzNzfkkS7VSwEWHbp8wz7Dhg3j4MGDuLtfr0YcHxvP+pfXY5dmx7msc8w6OIs1CRuoCJ0M/d4BFLIkQAjRIl26dImwsLBa7UZGRhQWyvZt4u7o6RkyNrwfdp4mmraFCxcyIsiZ0kol26LStBidEEKIm6lTAsDHx4e1a9dy9epVtmzZwpAhQ4DqWgD//EZWiHvRr50DgW5W7I/P5OSVnBv2CQwM5OjRozVuarMys5g/dT6uka7YG9mzIWEDbx94m5OGeqhHfAV2vv9bEjATCtPv1+UIIYRWeXh4cPbs2Vrt27dvp127dlqISDR1vYOeoG1ve83zqKgoDHMSsDUzZEtUKmWVSi1GJ4QQ4kbqlAB49913mTFjBp6enoSGhtK9e3eg+iaiY8eO9RqgaLmqlwJ4Y6yvy8L9iTedTujs7MzevXsZN26cpq28vJw5r89hzxt7CCecosoivj3zLV9eWEZar+ng/yBkxcP6FyF2M9RtMwwhhGgypk+fzgsvvMDq1atRq9WcOnWKuXPn8uabbzJjxgxthyeaIBuHAEb18UPP4Prt5H8XfM+oIBeKyqvYESNJdiGEaGzqlAAYN24cSUlJnDhxgp07d2ra+/fvz5dffllvwQlhZ2bIo11vvRQAwMTEhOXLl/PWW2/VaD9y+Aj/Hv5vTHaYEGIVQlR2FO8ceY/VltaU930b9I3hyHew9Q3Iv9bAVyOEENrz9NNP88knn/DGG29QUlLChAkTmD9/PhEREUyaNEnb4Ykm6oHAMXh1vr4l9LJly3DVycfK2ICNZ1Mor5JZAEII0ZjUeRtAJycn2rVrR0xMDFFRUZSWlhIeHi7TCEW969vWgaDbLAWA6krWH330ERs2bKix/2VVVRVffPoF8x+ZT6/SXjiaOLIpcRNvX17N6e7Pgu8QSI+ung1wbhWo5GZFCNE8TZo0ifj4eIqKikhLS+PatWtMnTpV22GJJszP/2H6DnNHoah+rlKpmPvJRwwPcia/tJK9FzK1G6AQQoga6pQAqKysZNq0adjY2BAYGEhgYCA2NjZMnz5ds62QEPVFoVDw9P+WAvy4L5GsovJb9h8+fDgxMTG8/PLLKP6+IwEuXrzIE6OfIOnHJIbYD6GksoSvoxaywFSPwn5vg4ktnPwVNk2DnIQGviohhNCOixcvsmvXLo4ePcqlS5e0HY5o4hSGpowJ7FFjS8Bly5bRSicPM0N91kemUKVUaTFCIYQQ/1SnBMD06dNZtWoVixcvJjk5meTkZBYtWsTKlSuZOXNmfccoBHZmhjzR3Yu80greXRfN1ZySW/Y3Nzdn3rx5HD16lKCgoBrHlixewguDXyAwKZAA2wCOpR1j1sU/ONn1KfAfDdmXYMMrcGoJKCWhJYRoHjIzMxkxYgS+vr6MHz+e8ePH4+vry/Dhw8nIyNB2eKIJ6xHwCGEjXFDoVCfdVSoVEXM/4YEOTmQXlbP/YpaWIxRCCPG3OiUA/vjjD37++WfGjx+Pi4sLLi4uTJgwgYULF/L777/Xd4xCANDL157n+viQW1LBe+ujuZB2+22rwsLCOH78OJ9++inGxsaa9qysLJ578jm2vLmFETYjqFJX8e25H1hgUEnhoA/Byh3OLof1L0HG+Ya8LCGEuC+mTJlCcnIyx48fp6ysjLKyMo4dO0ZqaipPPfWUtsMTTZipWzjDPDxo3c1W0/bbb7/hpZ+Psb4u605fQ6WSYrtCCNEY1CkBUFhYiKura612Nze3ZreXcEREBA4ODrW+RRba0dvXnpmD21KpUjNnUwwnLt+8JsDf9PX1mTlzJtHR0QwePLjGsZ07d/LciOcYrhhOoF1g9WyA2F85GT4ZgidBYQpsngnHfwLljXchEEKIpmDXrl38+OOPhIaGatpCQ0NZsGBBjYK+Qtw1hYLhgU8SOtypxiyAz/7zMYP9nUgrKONwQraWgxRCCAF1TAB06dKFDz/8kIqKCk1beXk5H374IV26dKm34BqDmTNnkpGRQWRkpLZDEf8T0sqa2cPbY6iny+fb49h1/s62GfLy8mLLli389ttv2Ntf37c4PT2dUUNGYXTciCcDnqyeDXB2AQsU+RQO+QTs2kD0muqdAoqkmJEQomlydXWtURflbwqFAicnJy1EJJoTq3YjeNDDs8YsgN9//53WBvkY6Omy9vQ11LLlrhBCaF2dEgDz5s1jz549uLm5MXjwYAYPHoy7uzt//fUXX331VX3HKEQtPg7mfDDKH1szA37cn8Dqk8l3dGOhUCh4+OGHiY2NZeTIkZr2yspKnnvuORZ/sJjZYbOvzwaI+i8nQx8Gv1GQGQsbXoLkEw15aUII0SDmzp3LSy+9xNmzZzVtkZGRvPrqq0RERGgxMtEs6OrxQMizdBpxfRaAWq3my08/YWB7B67mlnDiSq6WgxRCCKFQ1zEdW1JSwtKlS4mNjQWgffv2TJo0CRMTk3oNsLFITk7G3d2dq1ev1thiTmhXbnEFn2w5T1JOCQPaOzKluxc6OrW/4boRlUrFBx98wPvvv1+jvVu3bqxcuZLL6sv8FvsbJVUlBNsHM9q4Fe6nlkFlKXQYDyGPgI5uQ1yWEELcUl3GJHt7ewoLC6msrMTQ0BConr2nr6+PhYVFjb5SFPD25L7gBlQqVq0ay1vfHCB+f3XhP4VCwcFjp/n2TBmtbE346MGAG85EEUIIUXd3Mybp1fVNTExMeOaZZ+r6ciHqhbWpAe+N9OezbXHsPJ9OQWklL/Zrg4He7Se36Ojo8N577xEcHMyjjz5KUVERAIcOHSIsLIw1a9Ywp/sclsUu42T6SSKJJKxNOA+mxON0bmV1ccDer4GJzW3eSQghtO+zzz7TdgiiudPRYUjoi6wdfolLh7JRKdWo1Wrmf/4f+j//ETvPp3M2OZ8gdyttRyqEEC3WHc8A2Lx58x2f9IEHHqhzQI2VZPobt4oqFd/uucjRxGzaOVkwc3BbTA3vPL8VExPDqFGjuHjxoqbNwMCABQsW8MQTT5CQn8Ca+DVEZ0ejo4ZuSl1GZiZjZ2QDvWaCS3ADXJUQQtyYjEnaJz+Dm1CrWbNqAq9/s5f4fddnAew9coIFkRX4Oprz3kh/LQcphBDNS4PMABg+fPgd9VMoFCiVyjs9rRD1wkBPh5f7t2HRYX22RafxztooJnVpRcdW1nc01dDPz4/jx4/zr3/9iy1btgBQUVHBlClTOHXqFF988QXTO03nQs4F/oz/kwN58Ry2NqVPfhrDt7+JZfCjEPgQ6NSprIYQQgjRPCgUDA57mbUj4rh08PosgG8/n0vv5z5iX1wm51MLaO9scftzCSGEqHd3/GlFpVLd0UM+/Att0dFR8Hg3T/7V2YPMonIitl3gnXVRRF3Lv6PXW1lZsWHDBt56660a7d988w0DBgzg8uXLtLVpyxvhb/Bqx1dxtQ9gl60Tr+sXs/LMfyna9gaU3H5bQiGEEKI5M/Hozngvf3x6XN8RYOXKlbQzyEOBgt+PJcmOAEIIoSXydaVoVhQKBSODXJg3MZgB7R1JzCpmzqYYPtwYQ1x64W1fr6ury0cffcSKFStqFLTct28fAQEBfP3116jVajrYd+Ddru/yfOir2LbqzhYTQ15L38uGVROpiPwDlJUNeZlCCCFE46VQMKDzq3Qd7oKO7vUdARbM+5T+7R2ISy9k7wXZVlcIIbRBEgCiWbI1M+Spnt58MSGYnm3siUkpYPa6KP6zJZbErOLbvn78+PEcPnwYLy8vTVtxcTEvvfQSPXv25Pz58ygUCjo5deLDHh/xVI/3MHPswBpFMW+c/pL9qx5GlXS0IS9RCCFEPRk3bhzW1tY89NBD2g6l2TByC+Mhn+BaswA6mORjYaTPsqNXKCiTZLkQQtxvkgAQzZqjhREv9PUhYnwgnb1sOXM1lzf/PMuXO+JIzi255WsDAwM5ceIEjzzySI32Q4cOERwczJw5c6isrERHoUM3l258NHgBD3d/h0pLV34pS+Ld3S9zdtO/UeclN+QlCiHEHZkyZQqFhbVnQhUXFzNlyhQtRNR4vPjiiyxevFjbYTQ7/TpPp8cIV80sAICITz7isa6eFJVX8dvRJC1GJ4QQLZMkAG4jIiICBwcHgoKCtB2KuAdu1ia8OtCXT8YEEuxuzdHEbGauPMviw5dvuQ7RxsaGJUuWsHnzZtzd3TXtFRUVvPPOO3Tq1IkTJ04AoK+jz0DvocwdvpQhIc+SbmzBvMzDRKx7iCsHv4CKWycchBCiIS1atIjS0tJa7aWlpS3+w2+fPn0wNzfXdhjNjoFzIA+36USbXtdnAaxevRrzkmv4u1iy90IG51MLtBihEEK0PJIAuI2ZM2eSkZFBZGSktkMR9cDLzpQ3hrbj/ZEBeNubsvlcKuvOpNz2dUOHDiU6OpoXXnihRvvZs2fp3Lkzr732GiUl1R/wTfRNmBA4hU9G/k433we5oAfvx//GDytHkXV+LUjhIyHEfVRSUkJxcTFqtZrS0lJKSko0j8LCQrZv346Dg8M9vcdzzz2HQqHgm2++qaeoq+3bt48RI0bg4uKCQqFg48aNN+z37bff4unpiZGREV26dOH48eP1Goeou95dZ9BrWM1ZAB988AFP9vBCT0eHhfsTqVKqtBihEEK0LHecAPjnDcPtHkI0dm2dzJk1zA83axP+OJ7EkYTs277G3Nycb775hn379uHr66tpV6lUREREEBgYyI4dOzQzCmyNbXmq2yxmD1uMn3M4R5QFvHn0I1asfoii9KgGuzYhhPgnMzMzLCwsUCgUeHt7Y25urnlYWVnx2GOP1Upu3o2NGzdy+PBhXFxcbtnvwIEDVFVV1Wo/deoUBQU3/ha4uLiYoKAgvv3225ued/ny5UybNo13332XU6dOERgYyODBg8nKytL0CQgIuOGjoqLiDq9S1JW+fTsmte+Oby87Tduff/5JxuULjAx24VpeCZvOpWoxQiGEaFnuOAFgZmZW46bhVg8hmgJjA11eG9wWCyN9vtt7iUuZRXf0up49exIZGcmbb76Jrq6upv3SpUsMGjSIHj16sHnzZk0iwMPKmxmDv2Na//k4W3qytegSr22dwvod0yktzW2QaxNCiL/t2bOHXbt2oVarWbVqFbt379Y8Dhw4QFJSEm+//Xadzp2ens5zzz3HkiVL0NfXv2k/pVLJs88+y2OPPYZKdf3b3tOnT9O/f3/WrFlzw9cNHTqUOXPmMHr06Jue+4svvuCZZ57hiSeewM/PjwULFmBsbMyvv/6q6RMVFXXDh4GBwd1ftLhr3TtPp89wV3T0rs8CeOWVVxgZ5IyjhRGrT10jo7BMixEKIUTLoXenHffs2dOQcQihFQ4WRswY3JYPNsTw2bYLzHkwAFszw9u+zsjIiI8//pjx48fz5JNPcvr0ac2xQ4cOMWzYMEJCQnj77bcZPXo0Ojo6BLh2xu/B5RyJXc3a0wtYe+0vdq4+yrB2D9M35GkMdOVGVAhR/3r37g1AYmIi7u7u6OjU3+q/J554gpdeeokOHTrcsp+uri5btmyhZ8+ePP300yxcuJCYmBgGDRrECy+8wOTJk+v0/hUVFZw8eZJZs2Zp2nR0dBgwYACHDx+u0zlvJyIigoiICJRKZYOcvznSs/Vmkl9v9vVLIWZ7BgB//fUXa1evYkr3IXyy5Ty/HLzMa4PbolAobnM2IYQQ9+KOEwB/30AI0dz4OprzbO/WfLMnns+2X+DdEf4Y6eve/oVASEgIx44d4/PPP+fjjz+uMY319OnTjBs3jvbt2/PWW2/x0EMPoaenR7f24wlvM5L9R79kw8V1LI/6hW0JGxkZ/Cw9fIahp3PH/1sKIcQd8/DwIDc3l+PHj5ORkVHjm3iAxx577K7O980331BcXMz06dPvqL+7uzu7du2iV69ePPbYY+zcuZNJkyYxZ86cu3rff8rKykKpVOLo6Fij3dHRkYsXL97xeYYNG8axY8coLi7Gzc2NDRs2EBIScsO+M2fOZObMmSQnJ9coDiturWvX6QxKOEDCkVzKCqq3/5s+fToXLgynq7cdhxOyOH45l3AvGy1HKoQQzds9fdJISUkhKSmp1hq6Xr163VNQQtxvPdrYkZJXyp+nk/l2z0WmDfS9428h9PT0eP3115k6dSrffPMN8+bNIzv7ek2B8+fP8+ijj/Luu+/y+uuvM3nyZAwNDenb/Q26d3iM3fveZ1PWaRYf/ogtF1bwYMfn6ezSFR2F1OgUQtSfNWvW8Nhjj1FaWoqVlVWN33EKheKuEgCxsbF8+OGHHD169K5mFLRu3ZqFCxfywAMPEBQUxJdffnlX19BQNm3apO0Qmj1dS3cmtunPiXFZHPj5ClB9H/nRRx/x2qz3OXM1l0WHLhPoZnnHSXghhBB3r06fMJKTk+nRowdubm50796dPn360LdvX81DiKZofCc3unjbcvxyDr8fu3rXr7eysmLWrFlcvnyZzz//HGdn5xrHExISmDp1Kq1bt+aHH35ApVJhYOHCkOH/5dM+nzPKwJHC7Hh+3PsGs3e9wvG041QopUCVEKJ+zJw5k6lTp1JUVERWVhaZmZmaR0ZGxl2d68iRI2RmZuLj44Oenh56enpcuXKFl19+mXbt2t30dcnJybzwwguMHj2a5ORk3n333Xu6Jjs7O3R1dUlPT6/Rnp6ejpOT0z2dW9S/zl2m07eHM/atr9eL+vzzz8m8dpmJYe5kF5ez8mSyFiMUQojmr04JgJdeegkzMzMSEhIwMTHh2LFjbNq0icDAQLZv317fMQpxXygUCp7r0xpvezPWR15j74W7uyH+m5mZGdOmTSMhIYHvvvsODw+PGsevXbvG1KlT6dGjB2fPngXA2LMno8at5NP2TzCkSpfM5MN8v28WL+18nm9Of8PBawcpqrizIoVCCHEj6enpPP/88xgZGd3zuR588EHOnj3LmTNnNA8XFxfeeOMNNmzYcNP379+/P+Hh4axatYpt27Yxf/585s6dW+c4DAwMCA0NZceOHZo2lUrFrl276Nq1a53PKxqGwtyBh9s8SJdJrvw9AaWyspKXXnqJge0d8bIzY8u5VJKyZUcpIYRoKHVKAOzfv5///Oc/eHp6olAosLCwYMiQIXz66ae8/vrr9R2jEPeNoZ4uMwe1xdbUkIX7EzmfeuOtqe6EkZERzz33HPHx8fz666+0bdu2xvHDhw/TsWNHXnvtNYqLi0HfCLPOzzFhxC/Mte3KuJIK3DPiOZ24g5/OLeTlPS/zn2P/YdvlbWSU1C05IYRoucaMGcNff/1VL+eysrKqtaWevr4+zs7OtGnTplZ/pVLJkCFDaN++PUuXLkVHR4fQ0FA2b97MnDlzWLZs2Q3fp6ioSJNggOpChmfOnCEtLU3TZ9q0afzwww8sWrSI8+fP89xzz1FSUsLjjz9eL9cq6lf7zi8xyNeNNr3sNW3btm1j48YNPNXTC7UaFh5I0OykI4QQon7VqQZAVVUVlpaWQPX0u9TUVHx9fWndujUxMTH1GqAQ95u1qQEzBrfl3fXRfL49jo9GB+BoUfdvzPT19Zk8eTKPPPIIK1euZMaMGVy7dg2ovimOiIhgxYoVfPPNNwwfPhxsvLAa/hUPXNrNAyd/Jb8gi8iqIk47tCY6L4G43DiWX1iOi6kLIQ4hhDuH424uhaiEELV99913mv/28/PjjTfe4NChQ5oP7P/0/PPPN1gcurq6zJ07lz59+qCnd/3Wo1u3bmzbtq1WgvRvJ06cqLG08KWXXgLg3Xff5b333gNg4sSJZGZmMnv2bNLS0ggODmbr1q3Y2dnd6JRC2/SNmdDxRY6OfZekk3mUFVUXBHzllVeIiYlhoJ8j22PS2B2bQf/2jrc5mRBCiLulUNchxdqjRw9mzpzJqFGjePjhhyksLOSdd97hv//9L8eOHSMqKqohYtWqv6v9Xr16FTc3N22HI+6D45dz+GJ7HM5WRnw4KgBTw/qpzl9YWMjs2bOZP39+rSrcY8aM4auvvrr+b6yyFKJWVz+UlZQ7BxLVujunS1OJzIykuLIYgI4OHRnlM0oSAUK0EHc6Jnl5ed3R+RQKBQkJCfUVXosg9wX3QK1mxZp/8eXagxxZcr3mzvvvv8+MN95i2vJIqlQqPp8QjKWx/i1OJIQQAu5uTKpTAmDz5s2UlJQwbtw4Ll68yPDhw4mLi8PW1pbly5fTr1+/OgffWMlA3zKtj0zht6NXcLc24fm+PnjZmdbbuU+dOsXUqVM5ceJEjXYzMzPmzJnDiy++iK7u/yohF2XCyV8h8S9QKKDtAygDJxJflsHWxK2czTqLAgWdnDrxYOsHcTZzrv2GQohmQ8Yk7ZOfwb0pzTjP6xsf4/cPYsm6Ul3jxsjIiPPnz5NSZcb83fEEu1vz+pC2d7wrjxBCtFQNngC4kZycHKytrZvdL+mIiAgiIiJQKpXk5OTIQN/CqNVq/jx1jdWnqqsSPxjiypgQV/R062eLPqVSyffff89bb71FYWFhjWMdO3Zk/vz5dO/e/Xpjxnk49gNkxYOBKQQ9DO2Gc6nwCmsvriU6OxoFCrq6dGWE9wgcTWX6pBDNkXz41D75Gdy7fTteZ+6edWz+5IKmbfTo0axevZrv9l5if3wmYzq6MaGTzG4TQohbafAEQFpaGlVVVbVOnpycjL6+Po6Oze9Dhwz0LVtCZhHf773E1dwSWtmY8Fyf+p0NkJKSwiuvvMLKlStrHRs6dChz5syhY8eO1Q1qNSTsqZ4RUJID5s4QMgm8enMhN461F9dyIfcCOujQzbUbI1uPxM5Y1sIK0ZzUZUyaMmXKDdsVCgVGRkb4+Pgwfvx4GePukNwX3DtVWT4frBzB0gXnuXQoS9O+detW+vQfwLvrormcXczMwW0J9bDRYqRCCNG43c2YVKevMSdNmsS2bdtqte/YsYNHH320LqcUolHztjfj4zEdGB3iSnJuKbPWnmPliatUKVW3f/EdcHFxYcWKFWzevBlPT88ax7Zs2UJoaCjjx4/n/Pnz1UsAWveD0T9UzwAozYV9n8H6F2lblMfrYa8xs9NMvCy9OHDtAG/uf5PF0YvJLMmsl1iFEE1TYWEhf/75J5s3b+batWtcu3aNzZs38+eff3LlyhXmzZtHu3btOHnypLZDFS2EjpElD/s/TqfxLhgaX6+z89JLL6FQKZk20BczQz2+2X2R1PxSLUYqhBDNR50SACdOnKBnz5612nv06MHx48fvOSghGiN9XR0mhrXiwwcDcLIwZvWpZGatjeJKdnG9vcfQoUOJjo5m1qxZmJrWnGGwatUqAgICmDx5MomJiaBvVP3N/9iF4P8g5F+D3R/Cpmm0Ly/jrfA3mRY6jVbmrdibvJfX97/Oh4c/ZGviVrJKs24cgBCi2QoICGDMmDFcvXqVbdu2sW3bNpKSkhg7dizh4eEkJCQwduxYpk+fru1QRQvSNvhxejm3InCkk6YtLi6Or776CgcLI/7drw1llSo+2xZHaYVSi5EKIUTzUKclABYWFuzfv5+goKAa7adPn6Znz54UFRXVW4CNhUz1E/9UqVSx+mQy686koKMDY0LcGBXsUm+1AQDS09P55JNP+P7776moqKhxTF9fn6eeeopZs2bh4uJS3VicDWf/gLhtoFaBUwfo+Bhq+3acyzrH4ZTDnMk8Q7myHABvS2/CnMLo5NgJW2PbeotbCNHw6jImOTg4sH///lpb7sXGxtKrVy8yMjKIjIykT58+5ObmNkTYzYrcF9SfzCsHeXPHS6x77wJZ16qT6mZmZsTGxuLq6sra09f443gSnb1seWVAm2ZXb0oIIe5Vgy8B6NGjB59++in/zB2o1WoiIiJqFiwTopnS19XhofDrswFWnrzKO+ui2BeXSVZReb28h6OjI/PmzePixYs8/fTT13cEACorK/n+++9p3bo1M2bMICMjA0xtoesLMOYHaN0X0s7B5pkodr1PoI4pU4Om8lXfr3gh+AXCnMJILkxm+YXlzNw3k4+OfMTOKzvJK8url9iFEI1PRUUFly5dqtV+6dIlTZLRxMTkfoclBPYe3RnqHErowy6atqKiIl577TUARgW7EO5pw9HEbDacTdVWmEII0SzUaQbAuXPn6NevH7a2tpqlAPv37ycnJ4fdu3cTEBBQ74Fqm2T6xc1UVKlYdTKZDZEpqKn+38nRwgh/Fwv8XSzxc7bA2tTgnt8nPj6e9957j99//53//7+tsbExzz77LDNnzsTZ+X9bAOYlwemlcOVQ9XOv3hD2JJhUF1KqUFYQmRnJibQTRGZGUqGqQIECTwtPOth3INAuEE9LT3QU9TerQQhRP+oyJr344ousXLmSWbNmERYWBsDx48eZM2cOEydOZP78+fz888/89NNPHDx4sCHDbxbkvqB+lRak8NaasWz4Np5Lx7M17Rs3bmTYsGGUVih5e+05UvPKeOuB9nRws9RitEII0bjcl20Ac3Jy+Prrrzl37hwAgYGBvPjii9jYNM8qrTLQi9vJLionKqWA6JR8olMKyP7HTAAXS2P8XauTAX4uFlga69f5fc6dO8fs2bNZu3ZtrWOGhoY888wzvPbaa9f/nWZfgpO/QMoZ0DOC4H9B+5Gge73gUllVGWczz3I8/TjRWdGUKcsAMNU3JcA2gA52HQiwD8DCwKLOcQsh6k9dxqSqqirmzp3LN998Q3p6OlA90+jf//43r732Gnp6ely+fBkdHR1atWrVkOE3C3JfUP/2H/iEr4/8xrpZsVSUVwFga2vLmTNncHNz41peKbPWnENXR4ePxwTgYG6k5YiFEKJxuC8JgJZGBnpxN9RqNZmF5UT/IyGQW1I9xVZHoWBcqBujQ1zvaR3jsWPHmD179g135DAwMGDKlCm88cYbeHh4VG8dmHQEjv0AxZlg6Q5dngXnoFqvrVJVcSnvEmezznIu8xzJRckAKFDgYeFBB7sOdLDrQGur1rIOUwgtudcxqaCgAKiu6SPqRu4L6p+6qpL3Vwxh+5aLHF6apGnv1asXu3btQk9Pj2OJOXyx4wJedqa8N9IfQz3dW5xRCCFahgZJAMTExNCuXTt0dHSIiYm5ZV8/P787j7aJkIFe3Au1Wk1aQRnR1wrYEpXGtbwSAt2seKGvzz3NBgA4evQoH374IZs2bap1TE9Pj8cff5w333wTb29vqCqHcyvh3CpQVYFnTwh7qrp+wE3klOUQlRXF2cyzxGTHaGYHWBta09m5M52dO9PKvJUkA4S4j2RM0j75GTSMC+fX8p8jH3Lyv+mcO3pN0z579mzef/99AP44lsTaM9fo5WvPc70lGS2EEA2SANDR0SEtLQ0HBwd0dHRQKBS11iEDKBQKlMrmt02LDPSivpRVKvn10GX2XsjA2sSAl/q3ob3zvX8Ld/LkST788EPWrVtX65iuri6TJk1i+vTpBAYGQkEKHP0vXDsJeoYQ9DD4PVhjWcCN/D074HTGaY6nHSe3vLpSuKOJY3UywKkzzmbO93wtQohbu9MxKTw8nG3btmFtbU1YWNgtPygdO3asIUJttuS+oOF8v2YiB1IusPfjFFJSMoHq+8tdu3bRt29fVCo1c7fGEpmcx5TuXgzyd7rNGYUQonlrkATAlStXaNWq+lu+K1eu3LKvh4fHnUfbRMhAL+rbX3GZ/HQgkcoqFRPD3BkV7FIv32JERkYyZ84cVq1adcPjAwcOZNq0aQweNAhF8nE49l8oygBLN+j8LLgE39H7qNVq4nLjOJZ2jONpxymqrN7+s5V5Kzo7dybcKVy2FxSigdzpmPT+++8zc+ZMTExMNN+e3sy7775b32E2a3Jf0HCyMs8za/Pj5F8qZeXHMZovlpydnTlz5gwODg4UlVfx1p/nyC4u553hfrRzkuUsQoiWq8FrAOzbt49u3bqhp1fz28KqqioOHTpEr1697vaUjZ4M9KIhXM0pYd7OeK7llRDkZsXz9bAk4G9RUVF89NFHLF++/Iazdfz8/Jg2bRqTJo7DKH7D9WUBTh2g7VBo1e22MwL+VqWq4nz2eY6mHeVU+inNMoHWlq3xs/XD18YXHysfDHUN6+XahGjpZEzSPvkZNKzdx75iacwSCnZWsHrZOU37kCFD2LRpEzo6OlzJLuadddEY6enw8ZgO2JnJGCOEaJkaPAGgq6tLamoqDg4ONdqzs7NxcHCQJQBC3IWySiU/HUhkf3wmNqbVSwLq85uM2NhY5s6dy2+//abZ6/ufHBwceOGFF3jukTHYJ22CKwdBrQIjS2gzEHyHgPmdT6+sUFZwNvMsR9OOci7zHBWqv4sf6uBp4YmvtS9tbdrSxqoNJvqy57gQdVHXMam0tJRNmzZx6dIlpk6dipWVFXFxcdjY2GBnZ9eAETc/cl/QsNRqNV+sf4So7Fji/lvEoWNxmmOffvopM2fOBODwpWy+2hWHp211UUAjfSkKKIRoeRo8AaCjo0N6ejr29vY12uPj4wkNDdVUF25OZKAXDW3PhQx+OXiZKmX1koCRQfWzJOBvaWlpfPvtt3z//fdkZ2fXOm5oaMhjjz3Gy888jr9BMlzYUr1jAIBrR/AdCu7hoHPnN1dVqiou518mLjeOC7kXiM+N18wOUKDA3dwdX2tf/Gz9CLALQE/nzmYcCNHS1WVMunDhAgMHDkSpVJKRkcGFCxfw9vbmtddeIysri59//rmBo25e5L6g4WUXpfLOuoeoyi5g/ZyrpGdWj116enrs37+fLl26ALDixFX+PJVMF29bXu7fRooCCiFanAZLAEyYMAGA1atXM3z4cAwNr0+1UiqVREZG4uPjw9atW+sYeuMTERFBREQESqWSnJwcGehFg7qaU8KXO+NIySsl2N2a5/u2xsKofpYE/K2kpITFixfz5ZdfEhcXd8M+3bp146kpU5jQ0xfTq3vg6v+Kg5nYQJvB4DsYTO/+20KVWsXVwqvE5sQSlxtHXE4cxVXFAJjqmxLuFE43l254W3rLDZwQt1CXD59DhgyhTZs2fPXVV1haWhIZGYm3tzcHDhzgscceIyEhoYGjbl4kAXB/HLiwhp+PfIJ5bBVfzz2jWdLm4eHB6dOnsba2rp4tsCOO45dzmBjmzugQ+XkIIVqWBksAPPHEEwAsWrSICRMmYGxsrDlmYGCAp6cnTz/9dLOcRigDvbhf/v+SgH/3q59dAv4/lUrF5s2b+eKLL9izZ88N+5ibm/Ovf/2Lp/41llCzNBTx26G0uvI/LiHQui+06gr6xjd8/e2o1WqSi5I5k3GGQymHSC9JB8DBxIGuzl3p4twFR1PHOp1biOasLmOSlZUVJ06cwMfHB3Nzc00C4PLly7Rv357S0tIGjrp5kfuC+0OtVjN/93Qir+5DZ4uKn1ac1hwbM2YMq1atQqFQUFqh5J11USTnljBjUFs6edpoMWohhLi/GnwJwPvvv8+MGTMwNTWtc5BNjQz04n5Sq9Xsjcvkl4OXqaxSMSHMjQeDXRvsW/FTp07x5Zdfsnz5ciorK2/YJygoiKefnMK/evtinX4YUk6BWl29jWCrrtXJAOfgu1oi8E9qtZrEgkQOpxzmaOpRza4CrS1b09WlK+FO4ZgZmNX1EoVoVuoyJtnb27Njxw6Cg4NrJAB27tzJ448/TnJycgNH3bzIfcH9k1eWxzsbJ6HKz+D0N/kcPhOvOfbtt9/y/PPPA5BRUMZba85RpVLz4agA3G2kzowQomVo8ATA3y5evMj58+eB6orirVu3ruupGj0Z6IU2/HOXgEA3K16ox10CbiQjI4MlS5bw448/cuHChRv2MTIyYty4cTz16ER6uSpRJO6FrP/djBlbgVdvaN0PbLyhjgmLKlUV0dnRHEo5xJmMM1SqKtFV6OJj5YO7uTutLFrhbu6Oi5kL+joN9/chRGNVlzHpySefJD8/nz/++ANra2vOnj2LgYEBo0aNomvXrnz99dcNHHXzIvcF99fR5AP896838EwvY/6ci2Tn5gPV9WuOHDlCcHAwAFHX8vl483nszAz5aHQA5vW8jE4IIRqjBk8AZGVl8cQTT7Bp0yYMDAwAqKysZOjQofz888+1dgdoDmSgF9pSVqnkl4OX+SsuAytjA17s50OAq2WDvqdarebgwYMsXLiQFStW3HRqcJs2bZgyZQqTRw/EuTgGEvZAUUb1QUv36kRA2yFgaF7nWEqrSjmRdoIjqUe4lHdJs6sAVO8s4GLqgru5O+4W7tV/mrtjYSD7QYvmrS5jUl5eHuPHj+f06dPk5eXh7u5OSkoK4eHhbNmyBTMzmWFzN+S+4P5Sq9UsOPYpx2NX0/6cgtc+P6Y51qZNGw4dOqRZgro1Ko1fDyXi72LJm0Pboaero62whRDivmjwBMCIESNITk5m4cKFhIaGAnDy5EmeeeYZXF1dWb9+fd0ib8RkoBfati8uk4UHEqmsUjE21I0xIa7o6DR8obz8/Hx+++03Fi5cyKlTp27YR1dXl2HDhvHklCk80MkLvaT9kLgfKopAzwjaPQD+o8HY+p5iUalVZJRkcLXwKkkFSSQVJnG18Cp55Xk1+rUyb0VXl650duqMlZHVPb2nEI3RvYxJBw4c4OzZsxQVFRESEsKAAQOk6GYdyH3B/VdYUcis7c9SlRWPep2S79deH5O6du3Kzp07MTExQa1W8+P+BHbHZjDE34nHu3tpMWohhGh4DZ4AMDExYd++fXTq1KlG+/Hjx+nduzclJSV3e8pGTwZ60Rgk55bw1c54ruaW4O9iyYt9fbA2Nbhv73/q1CkWLlzIb7/9Rn5+/g37ODs7M3nyZKZMfpQ2eilwdiUUXANd/eodBALGgpn9DV9bV4UVhdVJgcIkLudfJjIzknJlOQoU+Nn60dW5Kx0dO2KkZ1Sv7yuEttRlTCosLMTcvO6zcURNcl+gHafST/HNX2/QtqCQ9d9kcyjyej2AkSNHsnr1avT09KhSqvhwYwwX0guZ2qs1fds1v9mpQgjxt7sZk+o0J8rV9cbFyBQKBU5OTnU5pRDiDrhZmzBndAD92zkSnZLP66vPcvJKDvdQyuOudOzYke+++46UlBQWL15M7969a/VJTU3lP//5D77t/enz1Bx+yQ0nP+QFsHCF2I3w51Nw8CsoSKm3uMwNzPGz9WOI5xCeDXqWr/p+xdTAqXSw68D57PMsjFrIK3te4YezP3Au8xxKlbLe3luIpsLa2pqwsDBmzJjBhg0byMvL03ZIjca4ceOwtrbmoYce0nYo4jY6Onakm+8YLhjr8tpTjrRt7aE5tn79el588UXUajV6ujpMG9gWWzNDfjqQyIW0Qi1GLYQQjUedZgD8+eeffP7553z//fcEBgYCEBkZyYsvvsgrr7zC2LFj6z1QbZNMv2hsDl7M4sf9CZRVKnG1MmGwvyO9fO0x0q9bFf66io+P5+eff+bXX38lLS3thn2MjIwYOXIkkwaFMcQ2GYO8i9UHvHpD4Hiw9myw+AoqCjiWeozDKYdJLEgEwFzfnHDncPxt/fG28paaAaLJqcuYdObMGfbt28fevXvZv38/ubm5dOjQgd69e9OnTx8efPDBhg26Edu7dy+FhYUsW7aMP/74445eI/cF2lNSWcKsvdMpSTnN0/m2DP/4BGnpGZrjH374IbNmzQIgMauYd9dHY6Snw+tD29HaXmpdCCGanwZfAmBvb09hYSGVlZUYGhoCUF5ejr6+PhYWNW+kMzIybnSKJkcGetEYZRSUsflcKn/FZVJaqcRYX5c+bR0Y5O+Is6XxfY2lqqqKzZs389NPP7Fp0yaUyht/y25jY8PEEf2Z1MGIbjbZ1bOJ3MOrlwe4darzNoJ3Iq04jcMphzmcepis0ixNu52xHd6W3pqHh4UH+rpSOVo0XvUxJkVGRvLll1+ybNkyVCrVTf+fbSn27t3LggULJAHQRERlRfHFgdn45qUxON2G3h/9RWFhkeb4zz//zBNPPAHAscQc5u+KR0dHwQt9WtPZ21ZbYQshRINo8ATAokWL7rjv5MmT7/b0jZIM9KIxK61Qsj8+k23R6VzLq67BEeRuxRB/J4Ldre57ga/U1FQWLVrE4sWLNVuF3ohXKzcm9fRikr8O7ZzNqosE+vQHn4Fg6dpg8anVaq4UXOFi3kUS8hNIyE8go+R6slJXoUsr81Z4W1UnBPzt/GWWgGhU6jImKZVKTpw4wV9//cVff/3FoUOHsLa2pk+fPvTu3fuux+sffviBb775hsuXLwPg7+/P7NmzGTp06N1ezk3t27ePiIgITp48SWpqKhs2bGD48OG1+n377bdERESQlpZGcHAwX3/9NWFhYXf1XpIAaHoWRS/ir7i1DMvPwTJejwci9lNZWQlUF6fdsGGD5t/jhbRCPt9+gYKySh4Ka8WoYBcpfimEaDYaPAHQEslAL5oCtVpN1LUCtkWncfJKLmrUOFoYMcjPiT5t7TE11Lvv8Zw5c4alS5fy22+/3XSJAEB4gDeTO9vzULAFNmYG4OgPbQaCRw/Qb/jifUUVRZpkQEJ+Aol5iRRXFWuOe1p40sGuA4H2gXhZeqGjkG2lhPbUZUwyMzPDxMSEUaNG0adPH3r16oW7u3udY9i4cSMKhQJfX1/UajVLlixh7ty5REZG0r59+1r9Dxw4QJcuXdDTq/l76NSpU/j4+NSaQQiwZcsWDh48SGhoKGPGjLlhAmD58uU89thjLFiwgM6dOzNv3jxWrVpFXFycZlu4gICAG17DqVOnNNsZSwKg6SlXlvPJ0U9IyjjLU/kFJB4r4pHvjmqOm5iYsHfvXk0yKKOgjLlbL3Atr4Sebex5ppc3+rJFoBCiGbgvCYCysjKWLVum+XbP39+fhx9+GCOj5lllWwZ60dRkFJaxIyadPbEZFJVXYaCnS1dvWwa0d8DHwey+f/OhVCrZvXs3S5cu5c8//6SoqOiG/QwM9BnRpS2Ph5ow2M8WfWNT8OoFbQaBnS/cp7jVajXpJenE58ZzLuscUVlRlCnLADDVNyXANoBA+0AC7AIwN5DK6uL+qsuYNHDgQI4cOYKTkxN9+/ald+/e9O7du17HNBsbG7788staswmUSiVBQUEEBgaydOlSdHSqP3SdPn2afv36MW/evNvOQFAoFDdMAHTu3Jnw8HC+/vprAFQqFe7u7rz66qvMmDHjjmO/0wRAREQEERERKJVKcnJy5L5Ay3LLcvnwyIcUFlxjRm4B67de47U/zmmO29vbc+jQIXx8fAAoqajiq13xRF7No52TBa8O9MXSWJZ8CSGatgZPAERFRTFkyBDKy8sJCQkBqgdxIyMjtmzZctNMe1MmCQDRVJVXKTl0MZud59O5lFn9obuVjQn92zvSs40dJgb3d1YAQElJCevXr2fp0qVs3br1pmuPHWwtmdTdk8mhFgS1sqguFhgwBjx7ge79jbtKVcWlvEuczTrLucxzJBclA6BAgaeFJ/52/riZueFi5oKTqRN6Ovf/71W0HHUdk6qqqjTLAPbt28ehQ4ewtbWlT58+LFy4sM7xKJVKVq5cyeOPP05kZCRt27at1efq1av07NmT/v37s3DhQmJiYujTpw9Tp05lzpw5t32PGyUAKioqMDExYc2aNYwYMULTPnnyZIqKili9evUdX4PMAGi6rhRc4ZOjn6BfWcrbmTl88tt55m+/pDneunVrDh06hIND9VaASpWaJYcvszU6DQdzI14b0hY3axNthS+EEPeswRMA/fr1w8HBgV9++QVj4+pCY6WlpTz++ONkZmaye/fuukXeiMlAL5qDxKxidp1P58DFLMoqlRjo6dKtdfWsgNb2939WAFQXCv39999ZtGgRp0+fvmm/IB9XJofbMD7UHjc3V/AbBb5DwMD0PkZ7XU5ZDucyz3Eu6xzR2dGUK8s1x3QUOjiaOOJq5oqrmSsuZi64mrniYOIgiQFRL+51TIqOjmbv3r3s2rWLDRs2oFarqaqquuvznDt3jq5du1JWVoaZmRl//PEHQ4YMuWn/S5cu0atXL/r168fOnTuZOHEi8+bNu6P3ulECICUlBVdXV44ePUp4eLim/bXXXuPgwYMcPHjwjs49bNgwjh07RnFxMTY2NmzYsEHzBcfNyH1B43I64zTfnP4GRx1D3kxN5clvjrHy+PXtZjt16sSePXswM7u+C8D26DR+PXQZQz0dXhngS5C7lRYiF0KIe9fgCQBjY2NOnjyJn59fjfbo6GjCwsIoKSm521M2ejLQi+akrFLJwYtZ7DyfQWJW9awADxtT+rd30MpWgn87d+4cixYtYunSpaSnp9+0X4+29kzs5MDYLp44h48CvwfBzP7+Bfr/VKmqSC5MJqUoheSi6j9TilLIKsuq0e/v4oLBDsEEOwTjZuYmRahEndRlTPr666813/z/vQVgr1696N27N7169cLW9u4ro1dUVJCUlER+fj6rVq3ip59+Yv/+/TecAfC3LVu28MADDxAUFMTp06fv+P+BhkwA1IXcFzQ+WxO3siJuBe2MnXk+IY5h/9nNvgs5muM9e/bkzz//1NSGADibnMeXO+Ior1IxuZsng/2dtBG6EELckwZPADg4OPD777/Tv3//Gu07duzgkUceueWNe1MlA71orhIyi9h1PoMDF7Mor1JiYaTPmI6u9G/vqLXiSFVVVWzbto1Fixaxbt06KioqbthPoYDebW2YEO7C2NFjcOj5GNi2vs/R3lxZVRkpxSlcK7xGSlEK14quEZ8Xr5ktYGNkQ4hDCMH2wfja+KKvI+tQxZ2py5gUFhamWfffs2dPrKys6j2uAQMG0LZtW7799tsbHk9OTqZXr14EBwezb98+nn/+eT744IM7OndDLwG4W3Jf0Pio1WoWRS9i37V99LbpwIjIQ/R6byvR167XnPH29mbDhg01vsRKzi3h060XyCgso387Rx7p4oGxgXYS4UIIURd3MybVaS7qhAkTmDJlCl988QXdunUD4ODBg0yfPp2JEyfW5ZRCCC3xtjfD296MR7p48FdcBmtOX+PXQ5fZcDaVcaFu9Gpjj67O/f2WWk9Pj2HDhjFs2DByc3NZvnw5ixcv5vDhwzX6qdWwNzaHvbE5vLgkin7tv2PCgDDGPPFvbDsMAF3tfqA20jPC27J6K8G/VaoqicuJ43TGac5knmFX0i52Je3CSNeIALsAgu2DCbQPxMzA7BZnFuLuHT9+vMHfQ61WU15efsNj6enp9O/fn/DwcH777TdOnz5N//79MTU15fXXX6/T+xkYGBAaGsqOHTs0CQCVSsWuXbt45ZVX6noZoolSKBQ84vcIGaUZ/JVzDsduY9jyNvR5dzMJmdWzUxMSEujatSt//PGHZotAN2sT5owO4IvtceyKTedMch5TunsS6mGjzcsRQogGUacZAGVlZcycOZMffvhBs2ZQT0+PqVOn8umnnzbLnQAk0y9airJKJVuj0tgQmUJxRRUuVsZM6OROZy8brU9XT0pKYuXKlSxfvvyWH2YM9HQYE+bG0w+Pos/4qeg4+t233QPuhlqtJrkwmdOZp4nMiCSxIBGoLizYyqIVrS1bVycQrLxxNHHU+t+/aDzudUzq0KEDmzdvvqdtAN9++20GDRqEh4cHRUVF/P777/znP/9h+/bttWYIKpVKOnXqhIeHB6tWrdJsBXjo0CEGDx7MggULmDRpUq33KCoq4uLFiwCEhIQwf/58evbsiZOTE05O1VO1ly9fzuTJk/nvf/9LeHg48+bNY+XKlTW2AWwIcl/QeBVXFjPnyBwySjJ4se0juO/5mbFzN9dYDqCjo8Nnn33GK6+8ovndqlKp2R6Txh/Hr1JWqSTcy5YnunlibWqgrUsRQog7cl+2AQQoLi7m0qXqKqutW7fG1FQ7xbjuBxnoRUtTVF7FxsgUNkelUVGlxMvOjIfD3engatkoPogmJiayYsUKVqxYwalTp27az8fBhKcG+vP4E1NwDH8QzBvv+s68sjwiMyOJzIwkPjee4qpizTFTPVO8rbxpbVWdFPCy9MJUv/n+zhW3dq9jkrm5OZGRkXh7e9++801MnTqVbdu2kZqaiqWlJYGBgbz++usMHDjwhv23b99Onz59MDCo+WHq0KFDtG3b9oY1CPbu3Uvfvn1rtb/77ru89957mufffPMNERERpKWlERwczNdff12jJkBDkPuCxi29OJ05R+ZQqarkzaDncT70C89/sZqf9l+t0e+pp57i22+/rfHvMruonF8PXeb45RyM9XV5OLwVA/0kCSuEaLzuWwKgJZGBXrRUeSUVrDl9jV3nM6hSqWjvbMHD4a3wdTTXdmga8fHxmmTA2bNnb9hHT1fBqBBHnh7Vk4FjH0fHuxcYNt5p9mq1mvSSdBLyEkjIT+BS/iWuFl5FpVZp+jiZONHGug1trdvS1qYttsZ3X8RNNE2NIQHQ0sl9QeN3IecCn534DHMDc94JewOrk0uY9/1PzFgRi0p1/fa3d+/erF69ulYS6lhiDr8eSiSnuII2DuY83dObVrayXaAQovGRBEA9ioiIICIiAqVSSU5Ojgz0osXKKChj5clkDsRnoUZNkJsVozu60s7JQtuh1XDu3DkWLlzI4sWLycvLu2EfD1tjnuztwaPjhuPZbTS4dgK9xj/Fs0JZwZWCKyTkJ5CQl8DFvIvkludqjtsZ2eFr40tb67a0s2mHnbGdfGPVTN3rh88HHniAn376CWdn5waIrmWQBEDTcPDaQX6K+olW5q2YHjoN8/idbP7pPzy04DSFZde3vmzdujUbNmygffv2NV5fWqHkj+NJbI9OR0cHRgS6MLqjK4Z6UiRQCNF4SAKgAchAL0S1qzklrD6VzNGEHNSo8XO2ZExHV/xdLBrVh83S0lJWrVrFjz/+yP79+2/ar4ObOSNDXRn5wBA6PfAIOi4hoKOd3Q/ullqtJqs0iwu5F7iQc4ELuRfIKr2+9aC1oTVtbaqTAW2t2+Jg4tCofkai7uoyJu3bt49u3bpp1t//raqqikOHDtGrV6+GCLXZkvuCpmNN/Bo2JGzAztiOlzu+jGteKtHL3mLE5wdJzLy+dbWFhQXLly9nyJAhtc5xMaOQH/YlkJRTgqOFEU/28CLQzeo+XoUQQtycJAAagAz0QtSUnFvCujMpmhkBvo7mjA5xJdjdqtF9yDx//jwLFy5k0aJFZGdn37Sfk6Uhwzu6MfKBwfQf/zQmrYIaZfHAW8kuzeZC7gXicuK4kHuB9JLr27JaG1rTzqad5iEzBJquuoxJurq6pKam4uDgUKM9OzsbBwcHlEplQ4TabMl9QdOyO2k3v53/DQNdA6YGTSVI35qsNW8xdu6WWsUBZ82axdtvv12rXkWVUsXmqDRWnUymokpJDx87Hu3qiaWxbOEqhNAuSQA0ABnohbixtPwy1p65xv74TJQqNV52powOcSPM07rRfbgsLy9n7dq1/PDDD+zevfuWfY30dRgY6MqIIQMY9cQrOLQOvE9R1q+8sjxic2O5kHOB2JzYGgkBGyObWgkB0TTUZUzS0dEhPT0de3v7Gu3x8fGEhoZSUFDQEKE2W3Jf0PREZ0fz/ZnvKa0qZXzb8Qx27Erlzo95PuL3WsUBg4KC+PXXXwkODq51noyCMn46kEhkch5mhnr8q3Mr+raVGVZCCO2RBEADkIFeiFvLLCxnfWQKe2KriwW6W5vwYIgr4V426Os2vin1qampbNy4kQ0bNrBjxw7Kyspu2ldHAf2CPJg4fixjnpyOjaPLfYy0fuWW5RKbU50QOJ9znszSTM0xGyMbvC298bTwxNPSEw8LD9lpoJG6mzFpwoQJAKxevZrhw4djaGioOaZUKomMjMTHx4etW7c2aMzNjdwXNE1pxWl8deor0kvS6eHag0fbPozeiV+YN/8bZiyPRfWP22I9PT1mzZrFW2+9hb5+zW/51Wo1hxOyWXToMvmllbRzsuCpnl64WUuRQCHE/ScJgAYgA70Qdya3uIINZ1PYeT6DiiolZoZ6dG1tR682dvg4mDXKb0hKSkrYuXMnGzZsYMOGDaSnp9+0r56ugoFh7Znwr0d48JFnsbK2vo+R1r/s0uzq2QG5scTnxteYIQDgYOKgSQh4WlQnBYz1jLUUrfjb3YxJTzzxBACLFi1iwoQJGBtf//kZGBjg6enJ008/jZ2dzAC5G3Jf0HQVVxbz/ZnvicmJoY1VG14IeQGLhAMcWfYJj/90hgupRTX6BwcH8+uvvxIUFFT7XOVV/H4siZ3n09HT0WFEkDMPhkiRQCHE/SUJgAYgA70Qdye/tJI9sRnsi88kJa8UAGdLY3r42NHT1w4HcyMtR3hjKpWKEydOsH79etavX8+5c+du2tdAT4fBPToy8bGnGTnuYczNG8/WiHVVUlnClYIrXCm4QmJBIpfzL9eYJQDgZuZGqGMooY6huJq5NsqkTnNXlzHp/fffZ8aMGZiayqyO+iD3BU2bUqXkjwt/sCtpF3ZGdrzU8SXcSvIp3fUZs5fs4/NtCfzzDllPT4933nmHN998s9ZsAIC49EJ+3JfA1VwpEiiEuP8kAdAAZKAXom7UajUJWcXsj8vkwMVsisorAWjnZEFvX3s6e9tgYqB3m7NoT3x8PMuXL2fFihW3TAYY6uvRp1soQ0aOZ+iw4fj6+jabD8bFlcVcLrjMlfzqpEBsdizFVcUAOJk4EeoYSienTrQyb9VsrrmxkzFJ++Rn0Dz8XRxQX1efqYFTCbZpD6eXcHjdLzz+UyRxacU1+oeEhPDrr78SGFi7LkyVUsWmc6msPnWNiiol3Vvb8WhXD6xMGv82s0KIpk0SAA1ABnoh7l2VUkVkch5/xWVx6kouVSoV+ro6hHna0LONHYFuVujqNN4PkDExMaxYsYLly5cTGxt7y75eHm4MGTqcoQ88QN++fTEzM7tPUTa8KlUVF3IucCL9BKfST1FYWQiAnbEdnRw70cmpE14WXpIMaEB3OiaFh4ezbds2rK2tCQsLu+XP5NixYw0RarMl9wXNR0x2DN+f+Z6SqhLGthnLUK+hKLLiKd39Ge/8spMvtifWmA2gr6/PO++8w2uvvVajpsbf/lkk0Ehfl1HBLjzQwVmWBQghGowkABqADPRC1K+i8ioOX8pmf3wmcenVHyCtjA3o0caOXm3saWXbeAspqdVqzp07x/Lly1m+fDmXLl26ZX8DAwN69uzJ0KFDGTp0KO3bt282H46VKiXxefGcSDvBqYxT5JXnAdUFBdtat8XexB4HY4fqP00csDCwaDbXrk13Oia9//77zJw5ExMTE95///1bnvPdd9+t7zCbNbkvaF7SitOYf2o+aSVpdLDrwJMdnsRC1xjOLufg6gU8sfAM8ek1ZwP4+Pjw5ZdfMmzYsFq/19RqNUcTc/jtaBIZhWXYmhoyMcydnm1k+1UhRP2TBEADkIFeiIaTml/K/rgs9sVnklVUDoCXnSk929jT3ceuUe+xrFarOX36NBs3bmTLli0cPXqU2/1a9fb2ZuTIkYwcOZIePXrccD1pU6RWq7mYd5ET6Sc4mX6SnLKcWn0MdAywN7HH3rg6IWBvbI+PtY8sH7hLMiZpn/wMmp/SqlKWxCzhSOoRLA0seSrwKfxt/SEngZLdnzHrx63M21FzNgDA0KFD+fLLL2nbtm2tc1YqVWyLTuPPU9coqajCy86MR7t44OdicZ+uSgjREkgCoAHIQC9Ew1Or1cSkFrA/PosjCdmUVSrRUSgIdreil689oR7WjXJLwX/Kzs5mx44dbNmyha1bt5KRkXHL/lZWVgwdOpSRI0cyZMgQrKys7k+g90FJZQmZpZlklGSQWZJZ47+zy7JRc334sTK0Isg+iCD7INrbtsdQt/a0WnHdvYxJFRUVZGRkoFKparS3atWqPkNs9uS+oHlSq9UcTjnM4vOLqVRWMsRrCKN9RqOHAqLXcGD5V0z95QwxKTV3CtDT0+Pll19m9uzZWFjU/nBfWFbJ6pPJ7DifjlKlJszThn91boWzpeyqIoS4d5IAaAAy0Atxf5VVKjlxOZd98ZmcS85HjRpzI336t3NggJ8jdmaN/wOiSqXizJkz1cmAzRs5fPQYSqXqpv319PTo3bs3I0aMYOTIkXh5ed3HaO+vKlUV2aXZpJWkEZ0VTWRmpGa3AT2FHu1s22kSAnbGsj3d/1eXMen8+fM89dRTHDlypEa7Wq1GoVCgVCobItRmS+4Lmre04jQWRC4gqTAJb0tvpgZOxd7EHvKTqdz3Fd//sZnZa+LIL62q8TpHR0c++eQTJk+ejI5O7YR1an4py44kceJKDro6Cga2d2RsqBvmRs1jJpgQQjskAdAAZKAXQnuyi8o5cDGLneczyCwsQ4GCME9rBvk74e/SdNaU5+bmsnXrVtavW8uWLVvILyi8Zf/goCBGjxnD6NGjCQgIaDLXWRdqtZr0knTOZJ4hMiOS+Nx4VFQnS1xMXQi0D6SNdRtambfCxsimWf9d3Im6jEldunTBxMSEN998E2dn51p/h/7+/g0RarMl9wXNX6WqktVxq9l+ZTtGukZM9p9MZ+fOoFZD6hky9/7IrB828eO+pFrLAsLCwpg/fz5dunS54bmjU/JZeuQKiVnFmBroMaajG4P9HdFr5LPchBCNkyQAGoAM9EJon0ql5vTVXLZFp3M2OQ8AVysTBvs70rONPcYGTafCcmVlJfv372f9+vWsX7eOxMuXb9nfx8eH0aNHM3r0aDp37nzDb5aak5LKEqKzq2cGRGZGUlx5vfiWqb4pnhaetLJohYe5B60sWuFo4tiikgJ1GZNMTU05ffo0vr6+DRxdyyD3BS3H2cyzLDy3kKLKInq49mBS+0nVy5TUakg5zalVX/DSt5s5GJ9b67WPPPIIH3zwwQ1ndKnVavbHZ/HH8SRyiitwsjDiX509CPO0blG/z4QQ904SAA1ABnohGpeUvFK2R6fxV1wmpZVKjPV16e1rz0B/J1ytmtaaSrVaTUxMDOvXr2fDhg0cOXLkloUEnZ2dGTVqFGPGjKFPnz7NpojgzajUKi4XXOZK/hWSCpO4UnCFq4VXUaqvT1k30jWilUUrPC08aW/bnrbWbTHSM9Ji1A2rLmNSr169ePfdd+nfv38DR9cyyH1By5JXlseP537kfM55nEycmBo0FQ8Lj+qDajXqayf5fd5sXvt5D9dyy2q8Vl9fn6effppZs2bh7Oxc69zlVUo2RqayLjKFiiol7Z0teKyrJ152pvfj0oQQzYAkABqADPRCNE6lFUr2x2eyLTqda3klAIS0smZsRzd8HMy0HF3dpKWlsX79ev788092795FZWXVTfuamZnRt29fBg4cyKBBg/D19W0R3xxVqapILUrlcsFlTVIgqTCJCmUFALoKXXysfPC388fP1g9PC090FM1n1kRdxqS1a9cye/ZsXn/9dQICAmoljvz8/Boi1GZL7gtaHrVazebEzayJXwPAAI8BPOjz4PVko1pNUdwB/jN7Bp/9eYLyqpo1X4yNjfn3v//Na6+9hq2tba3z5xZXsPzEVf66UF0PpaevHQ+FtcLG1KBhL0wI0eRJAqAByEAvROOmVquJTilga1QaJ65Ubz8X5GbF2FA3fB3NtRxd3eXl5bF582b+XLWCLVu3UlJafsv+7u7uDBo0iIEDB9K/f3/s7FpOAT2VWsW1wmtEZ0cTnR1NXG4clapKAEz1TPGz9cPfzh9/W39sjWvffDcldRmTbrRsRKFQSBHAOpL7gpbrcv5lfo3+laTCJKwNrZnUfhIdHTte76BWk3BoHe+8/Qa/77tQqz6AhYUFM2bM4JVXXsHcvPb4lJhVzJLDV4hJzcdAT5eRQS4MD3TGSL/pLHMTQtxfkgBoADLQC9F0XMku5s9T1ziamA1AB1dLxoa60c6pae+7XFpayvZt21jzx2LWb95GbmHJLfsrFAo6duzIoEGDGDFiRIuoHfBPFcoK4vPiic6KJiY7hqTCJM0xBxMHWlu2xtvSG28rb9zN3dHT0dNitHenLmPSlStXbnncw8OjPkJrMeS+oGVTqVXsTtrNn/F/UqYsI9g+mEntJ9VMLqrVnN29indmvc36I/G1zmFnZ8ebb77Jc889h7FxzaVrarWaU0m5LD2SRGp+KdYmBkwMc6eHj50UChRC1CIJgAYgA70QTc/VnBLWnL7G4UvVe877u1gypqMr/i6W2g7tnlVWVnJw3z52bFzNjl07ORF18ZZ1AwDc3NwYO3Ys48aNo1u3bi0qGQCQX57P+ZzzRGVFEZcbR1ZpluaYnkIPDwsPWltdTwrYGtk22uUUMiZpn/wMBEBuWS6/xf7GyfSTGOga8KDPgwxsNRBdnZrf1h/ZsoK3336T3acTap3D1dWVt956iyeeeKJWIqBKqWJHTDqrTyVTVF6FrakhgwOc6NfOATPDppO0FEI0LEkANAAZ6IVoupJzS1h7+hoHL1YnAto5WTAu1K1JbSF4O9nZ2ezevZsdWzezffs2riSn3rK/s7MzY8aMYdy4cfTs2RNd3ZY3tTS/PJ/E/EQS8hO4lHeJxPxEypTXi3dZGFjgbelNG+s2tLFqg4elB/o6jaPgYl3GpMWLF9/y+GOPPVYfobUYcl8g/ikyM5KlMUvJLsvG3dydyX6T8bbyrtVv19rfePvtNzkak1TrmKOjI6+++irPPfccFhY1Z6wVlVexLSqNbdFpFJRVYqCnSx9fe4Z2cMLZsmkVvhVC1D9JADQAGeiFaPpS80tZc/oaB+KzUKnVuFqZ0KetPb3a2GNp0jg+2NUHtVrNxYsX2b59Ozt27GDHju2UlJTetL+DgwOjR4/WJAMMDQ3vY7SNh1qtJrU4lUt5lzRJgWtF11BTPUzqKfTwtPTEx8oHX2tfWlu1xtxAO/Ul6jIm2dvb13heWVlJQUEBhoaGmJubk5GR0RChNltyXyD+v3JlOesurmP7le2o1Wr6uPdhTJsxmOrXrOavVqvZsGIJb7/1JlEJKbXOY2lpyQsvvMDLL7+Mg4NDjWMVVSoOXspiy7lUknJKUKCgo4cVQwOcm1VSWwhxdyQB0ABkoBei+UgvKGPj2VQOXsyipKIKXR0FIe7W9G1nT5CbVbNbX1lSUsK2bdtYtWIFGzaup7Do5rUDTExM6N27NwMGDGDgwIEEBAS06BvK0qpSEvISiM+L52LuRS7lX6Jceb0Qo5OJEz7WPnSw60CQfRAGuvenWnd9jUmXL1/m2Wef5cUXX2T48OH1GGHzJ/cF4mauFl5lcfRiLuVfwkTPhAe8HmCAx4Bavx+USiXLF//ER3M+ICbhWq3zGBsb8+STTzJjxoxaNTr+Lny76Vwqp5NyAfCwMeWBQGe6tbZFv5mNY0KIW5MEQAOQgV6I5qe8SsmJy7nsvZBB1LUC1KixMNKnl689fdra42Ztou0Q611ZWRk7duxg5e9LWL9hE/m3SAYAODk5MWDAAE1CwMXF5T5F2jgpVUqSi5K5mHuRi3kXic+LJ6esetcJA10DQuxD6OzcGX87/wZdLlCfY9Lp06eZOHEicXFx9RRdyyD3BeJW1Go1B1MOsvbiWnLKcrAytGJU61F0d+1eq+CoSqVi/dq1fPLhbI6dia51Lj09PSZNmsTrr79O+/btax1PyStlS1Qaf8VlUlGlxMJIn56+9vTxtcfdpvmNY0KI2iQB0ABkoBeiecssLGdfXCZ74zLJLKxeB+7jYEYfXwe6tLZtlsWWysvL2bVzJ6uW/MjazdvJLbz5MoG/+fn5MWjQIMaOHdsiCwneSFZpFifTT3Is9RiJBYkAmOiZ0NGxI52dOtPOpl2tgmD3qj7HpCNHjjB48GDy8/PrKbqWQe4LxJ2oVFay++puNiZspLiyGEcTR8a0GUMnx061Zlep1Wr27NnDJx99wM7df9U6l0KhYFD/Pjw19XlGjhyJgUHNGQVF5VXsOp/OrvMZZPxjHOvb1oGurW0xMWh+45gQopokABqADPRCtAx/T6v8Ky6TIwnZVCpV6Ovq0LGVNb187ZrlEgGoXg9+9NBBdqz7g527dnE06hJK1a2HBxcXF8aPH8+ECRPo0qWLJAOAjJIMjqUd41jqMZKLkgEw1zenk1Mnwp3C8bX2rZclFXUZk7777rsaz9VqNWlpaSxevJjw8HBWrlx5z3G1JHJfIO5GaVUpWxO3su3KNiqUFXhYeDCuzTj8bP1u+Dvh+PHjfPLJJ6xZs+aG57O3NufxiaN58sUZtPXvUOPYP8exo4k5VFQpMdDTpbOXDX3a2uPnLLUChGhuJAHQAGSgF6LlKamo4vClbPbHZxGbVgCAmaE+3X1s6dnGntb2ps32Jio/P5+92zawc+Mqduw9xIWrmbfs7+bmpkkGdO7cudn+vdyNlKIUjqYe5VjaMdJL0gEY4jmECW0n3PO56zImeXl51Xiuo6ODvb09ffr04c0338TSsulvj3k/yX2BqIv88nw2Jmxk79W9KNVK2tm0Y5zvOLwta+8YAHD+/Hnmzp3LsmXLqKqqumGfXh1a8fSkMYx97HmMnXzgH79//x7H9lzI4GJGEQAO5kb09rWnp68dDuZG9X6NQoj7TxIADUAGeiFatoyCMvbHZ3HgYhap+dVT5Z0tjenla0cPH3vszZt35fyky5fZue43tm/ewKZ9Jykqq7xp31atWjF+/HhGjhxJaGgopqamN+3bEqjVapIKkziaepROTp1ueqN/N2RM0j75GYh7kVmSydqLazmSegQ1agJsAxjqNZR2Nu1umEBNSkrip59+4ueffyY5OfmG57Qy0eORXj489dAognoOAadAMLHRHL+aU8LeuEz2x2VS8L/f4V52poR52hDuZYOrlbEkb4VooiQB0ABkoBdCQPWHuUuZReyLy+LQpSyKyqu/kWnnZEEvXzu6eDf/dZalpaVs+/M3Viz7hfV7jlJcduNvpaD6W+Z27doRGhpKp06dCA0NJTg4uMUnBe6VjEnaJz8DUR+uFl5l3cV1nM44jRo1HhYePOD1AB0dOt6wdohSqWTbtm38+OOPbNiwAaVSecPzhrSyYHJ3Nx4eGIZDu3BwDgSnDmBkSZVSxemreRxNyObklVxKK6vP4WJpTJiXDWGeNs16hpsQzZEkAOpRREQEERERKJVKcnJyZKAXQmhUKVWcuZrHvvgsTl3JpUpVXS8g1MOanm2ab72AfyotLWXr6qWsWPYLG/Yev2Uy4G9/JwX+Tgj06dOHDh06yM3mXZAPn9onPwNRn9KK09h2eRsHrx2kSl2FnbEdQzyH0MO1x023F01LS+PXX39l4cKFXLp06YZ99HQVDO1gz+TubgwPcsDQwbt6ZoBTdUKgSs+EqJQCjifmcPxyjmZmgK2ZIWEe1oR52dDOyQJdHfn9LERjJgmABiADvRDiVorKqzhyKZv98ZlcSC8EwNxIn26tm3+9gL+VlJSwZdUSViz7lY1/naCk/PbJgL+1bduWiRMnMnHiRPz8/BowyuZBxiTtk5+BaAj55fnsStrF7qTdlFSVYKZvxgCPAfRz74eZgdkNX6NSqfjrr7/48ccfWb16NRUVFTfsZ21uzEOd3ZjcxZ5wbysUOrrgGADu4dCqCypTRy6kF3L8cg5HE3PILioHwEhfl3ZOFvi5WODnbIGXnakkBIRoZCQB0ABkoBdC3Km/6wXsj88kraB6KyYXS2N6tLGjR5uWUXSpoqKCqOMHOfHXZk4eO8zJqDjOXs6iUnn7IScgIECTDGjTps19iLbpkTFJ++RnIBpSaVUp+5P3s/3KdnLKcjDQMaCnW08Gew7Gztjupq/Lyclh+fLlLFq0iKNHj960X1svVx7p1YYHfcHf2aQ6QW3pDq06g3tn1Ha+XM4p43hiDlEp+VzKLNLsDGOsr0s7Zwv8XSzwd7HEw8YEHUkICKFVkgBoADLQCyHullqt5mJGEfviszj8/+oF9GxjR2dvW8wMm3e9gH8qz0snav9GTh7czYlTZzgZl8zZ5EKqbpEUCAkJYeLEiUyYMKFWFfuWTMYk7ZOfgbgfqlRVHEs7xtbErSQXJaODDp2cOjHUaygeFh63fG1sbCxLlixhyZIlXL169ab9vNxdGNmlNSPa6NHLywh9PR0wsgS3TuDeGZyDKVMYciGtkJjUAqJT8knILEb1v48QpgZ6tHM2p42DOd72pnjZmWJupF+vfw9CiFuTBEADkIFeCHEv/i66tP8f9QL0dHTo+L96ASHuzb9eQC1l+eTHHWbdH7/yx6a97IjOuGUywN/fn759+9KnTx969+6Nnd3NvwVr7mRM0j75GYj7Sa1WE5UVxZbLW4jNiQXAz8aPoV5D8bP1u+USM5VKxd69e1m0aBGrV6+muLj4pn0tLcwZ2qU9I/zMGeqji7WpfvW2grY+1XUDnAPBwZ9StT6xaQXEpBYQk1JAQmYxaq7//rY3N8LLzpTW/0sIeNubtaiEtxD3myQAGoAM9EKI+lJUXsXRhGz2x2cRm1YAgJmhHl28benla08bB7NmXy+glqpysqN2s2bZQpZv2c/umExUtxmdOnTooEkI9OrVC1tb2/sTayMgY5L2yc9AaEtifiJbE7dyIv0EatS4m7sz1GsoYY5hN9w54J+Kior4888/Wbp0KXv27KGq6ua1WnR1dekV6seQICd6u1bR0fV/swMUOmDnC85B1QkB+3aUqvS4nF1MQmYxiVlFJGQWk5pfViMp4GBuhKedKW7WxrhaVT+crYww1Lt1zEKI25MEQAOQgV4I0RAyCss4dDGbffGZpOSVAtU3Sb197end1h47M0MtR6gFVeVknNnB6mULWb71IPsuZHG7kUqhUBAYGEifPn0YOnQovXv3xsio+dZakDFJ++RnILQtsySTbZe3ceDaASpUFdga2TLIcxA9XXtipHf733/5+fls3bqV9evXs3nzZvLy8m7Z39TEhO7Bbejla00vNxXhrUww1NcFHV2wbw+uHcE1FGy8QaGgtEKpSQokZBaRkFVMan5pjXMqUGBnbvi/hIARLlbGuFgZ42ZtLMsIhLgLkgBoADLQCyEaklqtJjGrmP3xWRy8mEVBWSUKFAS5W9GvnQMdW7XAJQIAlWWknNzC5tXL2HvkJHuiUknJK7/ty0xNTRk4cCDDhw9n2LBhODk53Ydg7x8Zk7RPfgaisSisKGR30m52Ju2kuLIYUz1TBnoOpH+r/pjqm97ROSorKzlw4AAbNmxg3bp1JCQk3PY1hoYGdOngQ++2NvRyU9PFywxTQz0wtgKXjtU1BFxCwNBc85qySiWp+WVcyy3lWl4J1/Kq/zu9oIwqlarG+a2MDXC3McbN2gR3G2PcrU1wszbB2EBmDAjx/0kCoAHIQC+EuF/+rhewOzaDM0l5qFFjYaRP77b29G3rgIuVsbZD1A61GnV+MhePbGXPji3sPXKKPdFppOXfPiEQFhbG8OHDGT58OCEhIU1+iYWMSfVr3Lhx7Nq1i8GDB/PHH3/c0WvkZyAamwplBfuv7Wdr4layy7Ix0jWib6u+DPIYhKWh5R2fR61Wc/78edavX8+mTZs4evQolZWVt32drq4uIb5udPc2p1srfbq3scHV2gjs21XPDHANBbs21TUF/h+lSk1G4d+JgVKSc0tJzi0hObeUSmXNxICdmaEmKeBhY4q3vSnOlkZN/ve6EPdCEgANQAZ6IYQ2ZBeV81dcJnsuZJJZWL2lYDsnC/q2c6CLt03LXjupVqPOSyLuyFb27tjKniOn2HkuleyiW9+ouri48MADD9CnTx969OiBh8etK2k3RjIm1a+9e/dSWFjIsmXLJAEgmrwqVRVHUo+wKWET6SXp6Ovo08utF0M8h2BrfPe1UkpLSzl69Ch//fUX+/bt4/Dhw5SWlt7+hYCHo1V1QqC1Bd3bWNPBxw1dt/8tFXDpWD1b4BZUKjXphWUk55ZyNaeEqzmlXM0tITW/VLMtIVRvTehpZ4r3/woOetub4mQhSQHRckgCoAHIQC+E0Ca1Wk3UtQJ2x2Zw/HIOVSoVxvq6dPexo397R7zs7myaZ7OmVqPMusSRrSvYuGkzGw+eIyq54LYvc3d3p0ePHvTs2ZOePXvi5+eHjk7jXm4hY1L927t3LwsWLJAEgGg2VGoVJ9NPsjFhI1cLr6Kr0KWbSzce8HoAR1PHOp+3oqKCEydOaBICBw4coKio6I5ea26sT7iXBV1bW9O1tTWdOwVj275HdULAvl11PYE7UKVUkZJXxuXsYhKzqmsMJGaXUFGl1PQx1tfFy84ML/vqxICHrQkulsbo6EhSQDQ/kgBoADLQCyEai8KySg7EZ7ErNoPk3BIAvOxM6dvWge4+dtVrMAUoq7h8aicbVy1j48797Dl7lYoq1W1fZm1tTffu3TVJgU6dOmFgYHAfAr5zjWFM+uSTT/jzzz+JjY3F2NiYHj16MHfuXNq0aVNv77Fv3z4iIiI4efIkqampbNiwgeHDh9fq9+233xIREUFaWhrBwcF8/fXXhIWF3dV7SQJANFdqtZrIzEg2JmwkIT8BBQrCncIZ4DEAb0vve/6WvKqqijNnznDo0CEOHjzIwYMHuXbt2h2/3tfJlK6treni60DXbt3w7zYUvVadwNT+hssFbkalUpOSX1qj6ODl/5cUMNDTxd3aGC87UzxsTfG0NaGVrUnLnk0nmgVJADQAGeiFEI2NWq3mYkYRu2MzOHQpm/IqJQZ6unT2sqFfOwfaOZnL9Md/KMpOZefqRWzYsJ69x6NISC+8o9eZmJjQo0cP+vTpQ58+fejUqRP6+tqtTt0YxqQhQ4bw0EMPERYWRlVVFW+99RYxMTHExMRgbFy7TsWBAwfo0qULeno1E1SnTp3Cx8cHCwuLWq/ZsmULBw8eJDQ0lDFjxtwwAbB8+XIee+wxFixYQOfOnZk3bx6rVq0iLi4OOzs7AAICAm54DadOndIkdyQBIJo7tVpNbE4sGxI2EJsTC4C5vjkBdgF0sO9AgG0AZgZm9fI+SUlJNRICZ8+eRaW6fQIWwNRQl3AvK8J9nQjrGEh49z64BXRHYdcG9O4uGatSqbmWV8rl7GIu/y8hcCW7mKLy69sfKlDgbGWEp231FoVu1ia4WBnhZGHUMovviiZJEgANQAZ6IURjVlqh5HBCFrtjM7iYUT0V09nSmL7tHOjta4+lsWyn9P9duxjFgS2rOLBvD/tPRHP2SvZttxuExpEQaIxjUmZmJg4ODhw8eJBu3brVOKZUKgkKCiIwMJClS5dqllicPn2afv36MW/ePCZPnnzL8ysUihsmADp37kx4eDhff/01ACqVCnd3d1599VVmzJhxx/HfaQIgIiKCiIgIlEolOTk5jepnIMSdSshP4ETaCc5lneNaUfW39QoUeFt6E2gfSKB9IK3MW9VbErmgoIBjx45x6ND/sXff0VFUbRjAn02yu+m9FxJCAgklJARCkd4RECGoFOmIBfATBbuC2FAUEURERYoo0kQE6b0llNB7SwLpvdfdvd8fMSNLEkggyW7I8ztnD9k7d2fe2QmZO+/ce+cowsLCEB4e/sDHDt7N2UqJNg2tEdLcG21at0abTr1g27htlXsJACUJitTcIkSn5iIypSQhEJWaJ82zU8rQQAYnS2O4//toQjcbE7j9+7OxnD0GSL8wAVAD9LGxRURUntupedh7JRGHb6Qgp1AFQwMZgj1LegUEuFlx/GMFMhOicXTbWhzavweHT57D8WuJKKzEkAFTU1P06NEDo0aNwsCBA2Fs/ODnbz8qfTwn3bhxA76+vrh8+TL8/PzKLL9z5w46deqEHj164Oeff8alS5fQtWtXvPjii/jkk08euP7yEgBFRUUwNTXFxo0bMXDgQKl8zJgxyMnJwYYNGyodP3sAUH2Vmp+KCykXcDb5LC6lXUKRuggAYKmwRAv7FvC39Ye3tTecTJ2qLSGg0Whw7do1hIeHSwmBCxcuVLqXAAA0cjRFiI8D2jT3QZtWQQgKeQJmbk0A6waAourz4uQWqhCbUfIUgtj0kicRxGXkIzm7EALal0s2pgo4WRr/+1JKPztbGcOcw/BIB5gAqAE80RNRXVOk0uBEVBr2XknCxbhMAICduRJdGzugaxNHOFgodRyhfitIT8DxXX9i/+7t2B9+Ckcvxz8wIWBtbY1hw4ZhzJgxaNu2bY0NwdC3c5IQAk899RSys7Oxf//+CuvdvHkTnTt3Rvfu3bF7924899xzmD9/fqW2UV4CIC4uDm5ubjh27BhCQkKk8jfffFPqelwZ/fv3x/Hjx5GbmwtbW1ts3rwZQUFB9/2Mvh0DoupQrCnGtfRrOJ98HudTziM+N15aZi43h4+1D7ytveFr7QsvKy8oDavvPJKdnY0TJ04gLCwMx44dw/Hjx5GYmFjpzxvIgGZuFghpaI02fm5oE9gCLVq1hty+EWDlDpg7AcZWVe4xUKhSIz6jQEoOxGXkIzGrAAmZBcgvVpepb6YwgpOVMVwsjeFuWzKkwMPGFI4WSibgqcYwAVADeKInorosMasA+64k4cC1ZKTnFUEGGQLcrdDNzxGtPW04zrESCjJTcHzXBuzftQ37wyMQdjkOBcUVJwQaN26M0aNHY9SoUWjQoEG1xqJv56TJkydj69atOHLkCFxdXe9bd9u2bXjyySfRsmVLnD59utJJkppMADwMfTsGRDUhJT8F19Ov42bGTdzIuIGY7BhoUPJ3zwAGcLdwh6+NLxpZN0JDy4ZwNHWstsSnEAIxMTE4fvw4Tpw4gePHj+PkyZPIzq7c/C0AoDQyQGADS7T2skJgA0sENrRHsya+MLF3K0kIWDgD5s6AuWPJz/Ky85fcL77sQhWSsgqQkFlYkhTIKkDiv6/MfO1H0iqMDOFmbVySELA1hYeNCTxsTWFnpuB8PfTImACoATzRE9HjQK0ROHMnHXuvJOFUdAYEBCyM5ejc2AHdmjjA3cZU1yHWGYU5GTi+cwO2b9mIVZv34XZKXrn1ZDIZunXrhjFjxmDIkCEwN3/0Sbb06Zw0depU/PXXXzh48CAaNmx437oxMTHo3LkzAgMDcfDgQbzyyiuYPXt2pbZT00MAqkqfjgFRbSlUFyIyMxI3Mm5ISYHc4lxpuamRKTwtPeFl5QUvy5KXvYl9tQ4duHr1Ko4fPy4lBs6ePYuioqJKr8PQQAY/F3O09LAoSQo0sESghyUcLJWAiU3JEAIrD8Dao6TngJVHSXkV96F0SMGdtLySV3rJz1kF2okBY7khnP8dPuBsaQwXaxO4WJUMKbA0NmJygCqFCYAawBM9ET1u0nKLcPBaMvZeSULSv5Mf+Tiao7OvAzr42HMcYxVoiotwYO0irFi2FOsPX0FuYdluoQBgZmaG9957D++8884jbU8fzklCCEydOhUbN27E/v37H/j4v8TERHTu3BlBQUH4/fffcfr0afTo0QPvvPMO3nrrrQdu736TALZt2xYLFiwAUHKB0KBBA7z22mtVmgSwqvThGBDpmhACiXmJuJVxC5FZkYjKjMLt7Nso1vx3kWtmZPZfQsDKCz7WPrBSWlVbDIWFhTh//jxOnDghvS5dulSl+QQAwNXeEs3dreDvKEdTFzP4u5rD38Uc9haKkjkFSpMB1h6AnQ9g5wsoqp40z8wvRkx6HmL+TQjEZRQgPjMf6XllkximCiM4/zucwNFSCTszJezMFbA3L/nXVMHzNJVgAqAG8ERPRI8rIQQuxmVh/9UkHI9KR5FKDbmhAYI9bdClsQMC3K1hyHGLlZYTfQ5//vQFVmzciX2XU8o8WWDx4sV46aWXHmkb+nBOeuWVV/D7779j06ZNaNKkiVRuZWVV5jGAarUarVu3hqenJ9avXy89CvDo0aPo06cPfvjhB4wcObLMNnJycnDjxg0AQFBQEBYsWIBOnTrB2dkZzs7OAEoeAzhmzBgsWbIEISEhmD9/PtatW6f1GMCaoA/HgEgfqTVqxOXGISozClFZUVJSQC3+S4zam9jDx9pHermZu8HQoPpm1s/JycGpU6dw4sQJnDx5EmfOnMHVq1fxMJc9Dtbm8He3hr+jEk2dlfB3NUdTVwu4Wishs24A2PsC9o1LXrYNAcOHeypMQbEaiVkFiM8smV+g5N98xGcWlOk1UMpEbgi7f5MB9vckBxzMlbA1U3CIXz3BBEAN4ImeiOqD/CI1wm+l4sC1ZFxJyAIAWJso0NHXHl0aO8DDlkMEKq0gC7cP/Y5ff/kJK/ZdxfXEXCjkRkhITIKNjc0jrVofzkkVdUtdtmwZxo4dW6Z8586d6Nq1KxQK7ed4Hz16FE2aNIGdnV2Zz+zfvx/dunUrUz5z5kzMmjVLev/dd99h7ty5SEhIQGBgIBYuXKg1J0BN0IdjQFRXqDQqxObE4lbGLdzMLBk6kJSXJC1XGirhbeUtJQQaWTeCqbx6zze5ubm4cOECzpw5I73OnTuHvLzyh289iLW5MZq5WaKZszGauZmjmZsFmrlbwamhP2SlCQG7RiVDCh4xuZFXpEJKdhFScguRmlOE1JxCpOYWISWn5H1abhFU5fR4kEEGGzM57M2Vd70UsLdQSgkDU4Uhhxk8BpgAqAE80RNRfZOQWYCD15Nx8FoyUnIKAQAN7c3RpbE92jeyh5XJw93lqHc0GoiYEzi28QecL3LHCzM+fuRV8pykezwGRI8mqygLNzNuSpMMRmZGQiVUAEouXN3M3dDYprH0sja2rvYY1Go1bty4gTNnzuDs2bO4fPkyLl26hJs3b0KtLn8o14PYmivQzNUczd3MEeBhiZaetmjevDksPJoCto1Khg/YeD50T4HyCCGQmV+MlH+TAyk5JcmB0ldydhFyCsvvRWAsN4SdWUliwM5cUWaYgZWJHCZyJgn0HRMANYAneiKqr0qHCBy4loxjkWkoUqlhIJOhhbsVnmhkjzZetjBRVF/XTXownpN0j8eAqHqpNCrczrqN6xnXcT295JVd/N+M//Ym9loJASdTpxq7KC0sLMSNGzdw6dIlXL58WUoMXL16FYWFhQ+1zkaOpghwt0BLD0u0bGCFgOb+8PILhIG9T0kvAesGDzXZYGUVFKv/TQgUISW7EKm5JT+n3dWToLxeBAAgNzSApYkc1iZyWJnItX6W3pvKYW2qgBl7FOgEEwA1gCd6IqKSBsSJqDQcvpGC8zGZ0AgBhZEhghvYoKOvHVq6W3O8YS3gOUn3eAyIalbpBIPX0q9Jr5T8FGm5hdwCTWyboIltE/jb+sPFzKXGLzzVajUiIyNx8eJFrdeVK1ceKjFgYWyE5m7m0oSD/g0c4OfXBF6NW8DQzqtWEgOlhBDIyleVGWaQmV+MzPxiZP37b2Z+MTT3uXw0MjCAlWlJgsDaVA5rE4X03sJYDjOlIUwVRjBTGsJMaQRTuSHbDdWACYAawBM9EZG2zPxihN1MxZEbKbieVHKXxlxphHbednjCxx5+zha8C1BDeE7SPR4DotqXXpAuJQOup19HTE6MtMxSYSklA/xs/Wq0h8C9VCoVbt26pZUUOH/+PK5cufJQQwmURgZo7GxWkhRwNYefhz38mzZF46COMGkQCDj4AXLj6t+RShBCILtQhcy8/xIDGf8mBjLyipGRX4TMvJKfM/OLIfDgS02lkWFJQkBhBDOlERRGBjAykJW8DA1gaCCD4t9/5YYyGBoYwMiw5GcjAwPIDWWQGxrAyNAA8n8/U1qmMDKAudIIFsZGMFc+vo9VZAKgBvBET0RUsaSsAhy+kYLDN1IQl5EPALA0lqOpqyVauFmhmasVnCyVj+2Jt7bxnKR7PAZEupddlI2raVdxJe0KLqddRnxuvLTMWmkNP1s/6eVg4lDr56CCggJcvnwZZ8+exdmzZ3Hu3DmcPXsWqampD7U+mQxoaG8KPxdz+Hu7w79Zc/i36gC/tr1h69awmqN/dBqNQHaBCpn5xUjPK0JOoQq5hSrkFamRU6hCXpEKuYVq5BWpkPPvv7mFKhSpBdQaDdSa6r1MlUEGc+OSZIClsRwW//5sYSyHpbH837kPSuZBsDaV16k2CxMANYAneiKiBxNCICo1D0dupOBcTAZup/03u7KduRLNXa3QzNUSzd2sYGumuM+a6H54TtI9HgMi/ZNZmImraVdxOe0yrqRdQWJeorTMRmlTMmTApmTYQG32ELibEAJxcXFSMqB0noErV64gJyfnodfraGUC/4au8GnkjYY+jdGwSQAaNmkOr4YN4ezsXKcuZktpNAIqjYBaI1Cs0UCtFihWa6DSCKjUJWWqf8tKXgIqtQbFmn//VWtQqNIgp1CF7AIVsguKkVNQ8nNWQUmyoaIeCkYGBrA1U8DWTAEHCyXszBSwK32KgrkSDhZKGMv1Z/4jJgBqAE/0RERVl5lfjEtxWbgQm4mLcZlIyCqQlrlYmaC5mxXae9vB34XDBaqC5yTd4zEg0n8ZBRm4nHYZ19KvlUkIWCut0dimsZQQqI05BO5HCIHY2Fhp0sErV65IPycmJj54BfdhrDCCl5sTGno2gFcjXzRs3AzuHh5wc3ODm5sbXF1dYWJiUk17UndoNAI5RSUJgYy8IumRiqWTJab++xSF/OLyh3GYK+VwsFDCwbwkSVD6KnmCgrJWJ0RkAqAG8ERPRPToUnIKcfGuhEBabhEAwNPWDH1bOOOJRvZQGHEyoAfhOUn3eAyI6p6MggwpGXA1/arWkAELuQU8LT3hau5a8jIr+ddUbqrDiEukp6dLCYG7EwORkZHQVDBzf1XZWFnCzc0Vbu4N4ObuDldXV7i5ucHFxUV6OTs7Qy6vf48AzitSITXnv8RAyaMVC6V/0/OKyv2c0shQeqSirZkCdmb/PV7R9t+fq6sXARMANYAneiKi6iWEwJ20fOy6nIgD15JRpFLDwliOHn6O6N3MmUME7oPnJN3jMSCq+7KKsnA17ao0sWBcThzUQvtur7XSGi5mLnA1d4WbuRtczFzgYu4CS4WljqL+T0FBAa5fvy4lBq5cuYJbt24hMjISSUlJNbJNe3t7raSAi4sLXF1dtV7Ozs5QKpU1sn19VKTSlDxWMfu/5EByTiHScv97mkKxuvxETf8WLhjV3uuRY2ACoAbwRE9EVHNyClXYfzUJOy4mIjm7AIYGMoR42aFfC2f4OppzeMA9eE7SPR4DosePWqNGcn4y4nLiEJcbV/JvThzic+NRrCnWqmsmNytJDJi5wtncGa5mrnAxc4GdiR0MZLrvyZabm4uoqChERUUhMjJS6xUVFYWMjIwa3b69vb2UECgdZuDk5AQHBwfY29trvRSKxzvhL4RAVoFKSgik5BQhNbcQaTlFaOVpgyd87B95G0wA1ACe6ImIap5GIxBxOx3bLyTgYlwmAMDbwRx9mzmjrbctlEb6M+GOLvGcpHs8BkT1h0ZokJqfiticWMTnxktJgfjceOSr8rXqyg3kcDJ1gqu5K9wt3OFh4QF3c3fYGtvqVTI7Ly8PcXFxiI2NLfMqLY+Li0NxcfGDV/aILC0tpWSAg4MD7OzsyiQJ7i6ztbWFkZFRjcdVlzABUAN4oiciql23U/Ow/WI8Dl1PQbFaAxO5Idp626Gzr0O9nzSQ5yTd4zEgIiEEMgszpWRAfG484nNK/k0vTNeqa2pkKiUEPCw84G7hDjdzNygN9bervBACaWlpiI+PL/eVEBeD+Lg4xCUkIjcv/8ErrEbW1tZwdHSs8OXk5ARHR0c4ODjAxsYGBga675VRk6pyTmLqhIiI9FIDO1NM6twIw0Ma4MC1ZBy8loz9V5Ow/2oS7MyV6ORjj46+9nC30f0ETUREVP/IZDJYG1vD2tga/nb+WsvyivMQkxODmOwY3Mm+g5jsGERlReFa+rX/Pg8ZHEwd4Gr27/wC5i7SPAMKQ913i5fJZLCzs4OdnR2aN29+37pZWVmIi4sr+4qNRWxMNGJj45Cckoq8/IL7rqeyMjIykJGRgWvXrj2wrqGhIexsrGFvbwsHewfYOzjC3sERDo6OUq8DBwcHaciCtbX1Y32TgQkAIiLSaxbGcgwIcMWAAFfcTs3DwevJOHIjBX+dicVfZ2Lh7WCOzr72aN/IHlYm9W92YiIi0j+mclM0tmmMxjaNpTIhBJLzk6WEwJ3sO4jNicXZ5LM4k3xGqieDDPYm9nAzd5OeSOBs5gx7U3tYyPWzB5ylpSUsLS3h5+d333p5eXlITU1FcnIyUlJSpFfp++TkZKQmJyElJRmpqWlISUtDcbHqkWJTq9VISklFUkoqgOsPrK9UGMHVwRauTvZwdXaCq6srXFzd4OrhBTfPRnBr4Al3d3eYmZk9Uly6wiEAlcSufkRE+kOjEbgQl4lD11NwLDINRSo1DGQytPSwRrcmjmjVwBpGho9vdz+ek3SPx4CIqkuxuhgJuQmIzY2VJh6MzYlFUl4SBLQv1RQGCtiZ2MHexB4OJg6wN7HXepnJzfQyQfCwhBDIzs5GamqqlCwoTSAkJycjKSkJiYmJSEpKkn7Oz6+d4QjWZgq421vC3cEKbo62cHd2gLurE9xdXeDm4QU3Lx/YuHpBZmYPKMyBGjwuHAJARESPNQMDGQLcrRHgbo0JHdU4HpmGwzdScOZ2Bk7fToeViRxdGjuiu58jnK2MdR0uERFRheSGcnhYesDD0kOrvFhTkhiIy4lDUl4SUvJTkJKfguT8ZFxMvQiNKPtoOYWBomRYgtIaNkobWCtLhijYKG3++1dpDblh3egxJ5PJpN4FDRs2rNRncnNztZICd/cwuLe3QUpKCrKysh4qtozcImTkpuBCdAqAm+XWMZYbwNXaGG42JnBzsISrgy3cXBzh5uoGN/cGcG0aAreWXWv1sYlMABARUZ1mLDdE58YO6NzYASk5hdh/NRn7ribh77Ox+PtsLJq6WKGHvyPaeNlCYfT49gogIqLHi9xALk0aeC+N0CC9IB0p+SlIzU9Fcn4yUvJTkF6QjvTCdNzJvqM130B56zYxMoGJkQmMjYyln0tfpkamMDEygbnCHBYKi5KX3ALmCnMYGxrrdS8DMzMzeHt7w9vbu1L1i4qKkJiYiPj4eMTFxUn/3vtKSUmpciwFxRrcSs7DreQ84FoqgMgydT7++GO8//77VV73w2ICgIiIHhv25koMDXbHkCA3nI/NxJ4rSYiITsOl+EyYK43Q0cce3f2c0MCOEwcSEVHdZSAzgJ2JHexM7CqsU6guRHpBOjIKM5BRmFGSHChIR2ZhJvJUechX5SNflY/Mwkwk5CagUF1YqW0byYz+SwooLGCpsIStsW3Jy6TkXztjO5gYmeh1oqCUQqGAh4cHPDzKJlruVlhYiPj4eMTGxiImJgYxMTFaP8fExCAuLg5qtbpK23dzc3uU8KuMCQAiInrsGBiUzAfQ0sMamfnFOHAtGfuuJGH7xQRsv5iAhvZmCHC3RnNXKzR2NofSyFDXIRMREVUrpaESzmbOcDZzrlR9jdCgQFWAfFU+8lR5yCvOQ05xDnKKcpBVlIWc4hxkF2VLr5ziHMTnxqNYU1zh9kuTAbbGtrAxLhl+YKW0gpXSCjZKG1goLGBoUDfOwUqlEl5eXvDy8qqwjlqtRmJiIuLi4hAbG4vY2Fitn0vfZ2RkSJ9xdXWt+eDvwgQAERE91qxM5HiqpSsGBrjgSkI29l5JwsmoNESmxGLTmVjIDQ3Q2MkCLdys0NzNEg3tzWFooP93LIiIiKqTgcwApnJTmMpNYYeKexbcTQiBfFU+0grSyrxS81ORVpCGy2mXoRbl3xWXQQYLhYWUGLBWWsPexB7OZs5wMnWCk5kTlIa1Nz7+URkaGkqPE2zdunWF9XJzc6WhBQEBAbUYIRMARERUT8hkMvi7WMLfxRJqjUBkSg4uxGbhfGwmriVm42JcJnACMJEboqmrJVq4WSHA3RouVvo91pGIiEhXZDKZlDRwtyh/9nkhBLKKsqShCJmFmSU/F/z3PrMoEzE5MeVObGittIaTqZOUFCj918HUAUYGdfNy1szMDL6+vvD19a31bdfNb4yIiOgRGBrI4ONoAR9HCzwd5IZClRrXE3NwITYT52MzcSo6AxHR6QAAZ0tjtPK0QasGNvBztnisHy9IRERU3WQymdTt3xOeFdYTQiC7OBvJeclIzE1EYl4iEnITkJiXiMisSFxNv6pV31BmCBczF7hbuMPd3B3uFu5wM3eDrbEtE/f3UW8SAEOHDsWePXvQp08f/PHHH7oOh4iI9IjSyBDN3azQ3M0KwwDkFqpwKT4LZ25n4NTtdGw9H4+t5+NhIjdESw9rtGpgg6AG1rAwrhuPUSIiItJ3MpkMlgpLWCos0ci6kdYyIUTJZIV5CUjMLUkMxObEIiYnBuHx4Vp1TYxM4GbuBnfzkoSAnYldyWMRjW1gqbCs98mBepMAmDJlCsaMGYPffvtN16EQEZGeM1MaoY2XLdp42UIIgciUXJy6XdIrIPxWKsJvpUIGGRo7maOVpw1CGtrCxcpE12ETERE9lmQyGayNrWFtbA0/Wz+tZbnFuYjJjkFMTkzJv/++bmTcKLMeA5lBSTJAaSNNSmhjXPJz6ZMMrJXWdXZoQWU8vnt2j65du2L//v26DoOIiOoYmUwGbwdzeDuYY2iwO9Jzi3DqdjpO3U7H+dgsXE3Mxurjt9HQ3hwdfezRvpEdbM0Uug6biIioXjCTm6GJbRM0sW0ilQkhkFaQhvjceKQVpEmPQSz9OTEvETczb5a7PhlKhiyUPsHg7uSAvYk9HE0dYSqvu48T1osEwMGDBzF37lxEREQgPj4emzdvxoABA7TqLFq0CHPnzkVCQgICAwOxcOFCtGnTRkcRExFRfWVjpkAPfyf08HdCoUqNC7FZCL+ViuORafg1PAqrwqPh72KJJ3zs0NbbDuZKvTjVEhER1RsymQx2JnawM6n4aQbF6mJkFGYgrSAN6YXpUoKg9OkFSXlJuJV5q9zPmsvN4WjqCCdTJziaOmr9bCY30+thBnrRKsnNzUXLli0xfvx4DBkypMzyNWvW4PXXX8cPP/yAtm3bYv78+ejTpw+uXbsGe3t7AEDz5s3LXfepU6egUPBODBERVT+lkSGCPW0Q7GmDiZ3UiIhOx5EbKTh7JxOX4jOx7EgUWnpYoUMjewR72sBYXjeedUxERPS4kxvK4WDqAAdThwrrFKmLShIEBelILUhFSn4KkvKSkJSXhMS8xHITBKZGpiVDCYytYa201nrEYenPVkoryA10M4+QXiQA+vXrh379+lW4fN68eZg0aRLGjRsHAPjhhx/wzz//YPny5Zg+fToA4MKFC9UaU1ZWFrKysqT38fHx1bp+IiJ6vCiNDNGhkT06NLJHTqEKxyNTceRGqvREAYWRIUaEeKBvcxddh0pERESVoDBUwNnMGc5mzuUuzy3OlRICpUmBpLwkpBekIz41HmqhrnDdZnIz9PbsjYGNBtZU+OXSiwTA/RQVFSEiIgLvv/++VGZgYICePXsiLCysxrY7b948fPTRRzW2fiIienyZK43Q3c8J3f2ckJ5bhKM3U3H0ZgpszZS6Do2IiIiqiZncDA2tGqKhVcMyy4QQyC3ORUZhBjILM0vmIShMR2ZhJjILM5FekA4zuVmtx6z3CYCUlBSo1Wo4OTlplTs5OeHGjbIzO1akf//+OH78OHJzc+Hu7o7NmzcjKCiowvqvv/46Jk6cKL2Pj49HSEhI1XeAiIjqNRszBfoHuKB/gAuEELoOh4iIiGqBTCaDucIc5gpzuFu46zocid4nAKrLP//8U6X6lpaWsLS0rKFoiIioPtLnSYGIiIjo8Weg6wAexN7eHoaGhkhMTNQqT0xMhLNz+WMxiIiIiIiIiEib3icAFAoFgoODsWvXLqlMo9Fgz549aN++vQ4jIyIiIiIiIqo79GIIQE5OjtZ4/sjISJw5cwbOzs5wdnbG66+/jjFjxiA4OBghISGYP38+8vLyMHbsWN0FTURERERERFSH6EUC4OTJk+jWrZv0/tVXXwUAzJw5E7NmzcJzzz2H5ORkfPjhh0hISEBgYCC2b98Oe3t7XYVMREREREREVKfoRQKga9euD5wZecqUKZgyZUotRfSfuXPnYu7cuVCrK36GIxEREREREZG+0/s5AHRtxowZSEpKwtmzZ3UdChEREREREdFDYwKAiIiIiIiIqB5gAoCIiIiIiIioHtCLOQDqApVKBQCIj4/XcSRERFTflZ6LSs9NVPvYLiAiIn1RlXYBEwCVlJycDAAICQnRcSREREQlkpOT4eXlpesw6iW2C4iISN9Upl0gEw+afp8AAAUFBTh//jwcHBxgZFR+3iQ+Ph4hISE4fvw4XFxcajnC6sF90A/cB/3AfdAfj8N+VOc+qFQqJCcno0WLFjA2Nq6mCKkq2C6oO7gP+oH7oD8eh/3gPmirSruAPQAqydjYGG3atKlUXRcXF7i7u9dwRDWL+6AfuA/6gfugPx6H/aiufeCdf91iu6Du4T7oB+6D/ngc9oP78J/Ktgs4CSARERERERFRPcAEABEREREREVE9wARANbK0tMTMmTNhaWmp61AeGvdBP3Af9AP3QX88DvvxOOwDVc3jcMy5D/qB+6AfHod9AB6P/eA+PDxOAkhERERERERUD7AHABEREREREVE9wAQAERERERERUT3ABAARERERERFRPcAEABEREREREVE9wAQAERERERERUT3ABEA1WrRoEby8vGBsbIx27drhxIkTug6p0mbNmgWZTKb18vPz03VY93Xw4EEMHDgQrq6ukMlk2LJli9bygoICTJ48GXZ2djA3N0doaCiSkpJ0FG35HrQPXbt2LXNcXnrpJR1FW77PP/8cbdq0gYWFBRwdHTFkyBBcv35dq46+H4vK7IO+H4sff/wRAQEBsLS0hKWlJdq3b49t27ZJy/X9GAAP3gd9PwblefnllyGTyfDdd99JZWlpaRg5ciQsLS1hY2ODiRMnIjc3V4dRUk1hu6B2sV2gH9gu0A9sF+gnfWgXMAFQTdasWYPXX38dM2fOxKlTpxAQEIA+ffogJSVF16FVWsuWLREfHy+9Dh8+rOuQ7is3NxctW7bEokWLyl0+bdo0bN68GevWrcOBAwcQFxeHoUOH1nKU9/egfQBK/lDcfVy+/PLLWozwwQ4cOIDJkycjPDwcu3btQmFhIXr37o38/Hypjr4fi8rsA6Dfx8LV1RWff/45IiIicPLkSfTs2RODBg3C5cuXAej/MQAevA+Afh+De23ZsgVhYWFwdXXVKh85ciQuXryIXbt2YfPmzThw4ABefvllHUVJNYXtgtrHdoF+YLtAP7BdoH/0pl0gqFqEhISIKVOmSO/VarVwdXUVc+fO1WFUlTdz5kwRHBys6zAeGgCxefNm6X1GRoaQy+Vi/fr1Utnly5cFAHHixAldhPhA9+6DEEJ06dJFvPHGGzqK6OEkJSUJAOLIkSNCiLp5LO7dByHq5rGwsbERy5cvr5PHoFTpPghRt45BQkKCcHd3F+fOnROenp5i4cKFQgghLl26JACIkydPSnW3bdsmDAwMREJCgq7CpRrAdoFusV2gP9gu0B9sF+iOPrUL2AOgGhQVFSEiIgK9e/eWygwMDNCzZ0+EhYXpMLKquXz5MlxcXODt7Y1Ro0YhJiZG1yE9tIiICBQXF2sdEz8/PzRo0KBOHRMAWLFiBezt7dG8eXO89957ZbLP+iYzMxMAYGtrC6BuHot796FUXTkWarUaf/zxB/Ly8tCuXbs6eQzu3YdSdeUYjBs3Dq+++ipatGihVR4WFgY7OzsEBwdLZT179oRMJsPx48drO0yqIWwX6J+6+HewInXl72Aptgt0j+0C3dOndoFRjay1nklJSYFarYaTk5NWuZOTE27cuKGjqKqmbdu2WL58OZo0aYL4+Hh89NFH6Ny5M86fPw8zMzNdh1dlCQkJMDExgYWFhVa5k5MTEhISdBRV1Y0YMQKenp5wdXXF2bNn8fbbb+P69etYu3atrkMrlxAC06ZNQ5cuXaSxonXtWJS3D0DdOBbnz59H+/btUVBQAHNzc/z1119o0qQJIiIi6swxqGgfgLpxDADgu+++Q25uLt54440yyxISEuDo6KhVZmRkBFtbW707FvTw2C7QP3XtXFSRuvJ3sBTbBbrFdoF+0Ld2ARMABADo16+f9HNAQADatm0LT09PrF+/HmPGjNFhZPXbpEmTpJ9btGgBV1dX9OjRA9HR0fD09NRhZOWbMmUKLly4gCNHjug6lIdW0T7UhWPRpEkTnDlzBpmZmVi/fj1Gjx6NQ4cO6TqsKqloH5o0aVInjsGVK1fw8ccf49ixYzAwYCc7qrvYLtBPdeHv4N3YLtAttgt0Tx/bBfoRRR1nb28PQ0NDJCYmapUnJibC2dlZR1E9GmtrazRu3LjO3Km4l7OzM/Lz85Gdna1VXpePCVByRwaAXh6XqVOn4u+//8bevXu1JjepS8eion0ojz4eC4VCAR8fHwQHB+Pzzz9HQEAAFixYUKeOQUX7UB59PAbh4eFITk6Gj48PjIyMYGRkhOjoaPzvf/+Dn58fnJ2dy8yyrFKpkJaWpnfHgh4e2wX6py79HawKffw7WIrtAt1ju0D39LFdwARANVAoFAgODsauXbukMo1Ggz179qB9+/Y6jOzh5eTk4ObNm3BxcdF1KA8lODgYcrlc65hcvXoVt2/frrPHBADOnDkDAHp1XIQQmDJlCv7880/s3bsXDRs21FpeF47Fg/ahPPp4LO4lhEBhYWGdOAYVKd2H8ujjMXj66adx7tw5nDlzRnq5urri7bffxubNm9G+fXukpqbi1KlT0mf27t0LIQRCQkJ0GDlVJ7YL9E9d/jt4P/r4d5DtAv05Fvdiu6D26WW7oEamFqyH/vjjD6FUKsXy5cvFpUuXxKRJk4SNjY1ITk7WdWiV8sYbb4j9+/eLyMhIceTIEdGzZ0/h4OAgUlJSdB1ahbKzs8Xp06fF6dOnBQCxYMECcfr0aREfHy+EEOKll14SDRo0EHv37hUnT54U7du3F506ddJx1Nrutw83btwQs2fPFidPnhSRkZFi06ZNwtvbW3Tv3l3XYWt5+eWXhZWVldi/f7+Ij4+XXnl5eVIdfT8WD9qHunAs3n33Xen/8Pnz58W7774rDAwMxO7du4UQ+n8MhLj/PtSFY1CRu2f7FUKIvn37iqCgIHHs2DFx+PBh4evrK55//nkdRkg1ge2C2sd2gX5gu0A/sF2gv3TdLmACoBotXLhQNGjQQCgUChESEiKOHTum65Aq7bnnnhMuLi5CoVAINzc3MWzYMHHz5k1dh3Vf+/btEwDKvGbOnCmEECI/P1+88sorwsbGRpiamoohQ4bo3WO27rcPt2/fFp07dxa2trZCqVQKHx8f8dZbb4msrCxdh62lvPgBiGXLlkl19P1YPGgf6sKxmDRpkvD09BQKhUI4ODiIHj16iJ07d0rL9f0YCHH/fagLx6Ai957oU1NTxfDhw4W5ubmwtLQU48ePFzk5OTqMkGoK2wW1i+0C/cB2gX5gu0B/6bpdIBNCiOrvV0BERERERERE+oRzABARERERERHVA0wAEBEREREREdUDTAAQERERERER1QNMABARERERERHVA0wAEBEREREREdUDTAAQERERERER1QNMABARERERERHVA0wAEBEREREREdUDTAAQPYTWrVtj1qxZ1ba+5cuXw97evtrWV9u6du2K6dOnP9I6Zs2ahdatW1dTROWr698zERHpJ7YLtLFdQKS/mAAg0gPPPfccLl26pOswHmj//v2QyWTIycnRKv/zzz8xc+bMR1r39OnTsWPHjkdax928vLzw3XffaZXpw/csk8mwZcsWncZARET6TR/OV5XBdsGjY7uAapuRrgMgIsDExAQmJia6DuOh2draPvI6zM3NYW5uXg3RVKyuf89ERFQ/1PXzFdsFRPqLPQCIHiAnJwfPP/88zMzM4Obmhu+//75MnfT0dEyYMAH29vawsrJCnz59cOXKFQDAxYsXIZPJcOPGDa3PzJw5E61atQJQfhe0v/76C8HBwTA2NoajoyNGjx5dqe3dz7p169C0aVMoFAp4e3tj8eLFWstlMhmWLFmC3r17w8TEBL6+vti6dSsAICoqCt26dQMAWFhYQCaTYezYsQDKdvXz8vLC559/jhEjRsDMzAze3t7YtWsXbt++jV69esHMzAxt27bF9evXpc/c3dUvKioKMpmszKtr164AgOTkZAwbNgxubm4wNTVFYGAgNm3aJK2ra9euiI6OxtSpU6XPVvQ9f/fdd/D29oZCoUDTpk2xYcMGaVlpHBs3bkSnTp1gamqKtm3b3vduQVFRESZPngxnZ2cYGxvD29sbCxculL4XABg4cCBkMpn0Hig53oGBgTA2NoaPjw++/PJLaDSaSh0bIiKqPWwXsF3AdgHVaYKI7mvSpEnCy8tL7NmzR5w9e1b06tVLmJubi5kzZ0p1evbsKZ5++mlx8uRJcfXqVfHKK68Id3d3kZOTI4QQomXLlmL27Nla6/X19RVz584VQgixbNkyYWdnJy3bt2+fMDIyEh9//LG4fPmyOHXqlFS3Mtsrz/Hjx4WBgYH49NNPxdWrV8WSJUuEQqEQGzdulOoAEA4ODmLZsmXiypUr4o033hBKpVLcvn1bqFQqsWHDBgFA3Lx5U8THx4uMjAwhhBBdunQRb7zxhrQeT09PYWdnJ3766Sdx7do1MWbMGOHo6Ch69+4ttmzZIi5fviyeeOIJ0bNnT+kzM2fOFMHBwUIIIVQqlYiPj5deZ8+eFfb29uKDDz4QQggRHR0tvv76a3H69Glx48YNMXfuXGFkZCQuXbokhBAiNTVVuLu7i88++0xaR3nf8/r164VCoRBLliwRV69eFZ9++qkwMDAQERERQgghIiMjBQDRrFkzsWPHDnH58mXRtWtX0a5duwq/57lz5woPDw9x6NAhERUVJfbt2yfWr18vhBAiKSlJABC//vqriI+PF0lJSUIIIQ4ePCisrKzEypUrxc2bN8XWrVuFm5ubmD9/fqWODRER1R62C9guYLuA6jImAIjuIysrS8jlcvHnn39KZXFxcUIul0sn+kOHDgkbGxtRWFgo1VGr1cLFxUWsWbNGCCHEF198Ifz9/aXlpSfdmJgYIUTZE1DXrl3FuHHjyo2pMtsrz/Dhw0W/fv20yl5++WXRoUMH6T0A8eqrr2rVad68uXjnnXeEECUNEAAiOztbq055J/qxY8dK769fvy4AiG+++UYqW7dunZDL5UKtVgshtE/0dysqKhIdO3YUAwYMkOqWp0uXLuLjjz/WimHhwoVade79ntu3by9efvllrTr9+vUTI0aMEEL8d6JfsWKFtHzHjh0CgMjPzy83jqlTp4ru3bsLjUZT7nIAYvPmzVplPXr0EF9++aVW2eLFi7V+Zx50bIiIqOaxXcB2AdsFVNdxCADRfdy6dQvFxcVo27atVObi4gJPT0/p/dmzZ5GZmQlbW1tpvJqlpSUSExNx8+ZNAMDw4cNx5coVnDlzBgDw+++/o3PnznBzcyt3u+fOnZO61d3rQdu7ffu2VG5ubo7PPvsMAHD58mU88cQTWut64okncPnyZa2yu/cVANq1a1emTmUEBARIPzs5OQEAmjVrplVWXFyMjIyM+65n6tSpSEtLw++//w4Dg5I/WWq1GrNnz0aLFi2k7+Hw4cO4fft2lWKs7HfSokUL6WcXFxcAQFJSUrnrHD16NE6dOgU/Pz+89tpr2Lt37wPjOHv2LD788EOt4zZt2jTp96dUdR0bIiJ6OGwXsF0AsF1AdRsnASR6RDk5OXB3d8eePXvKLCudBMfDwwOdOnXC6tWrERAQgDVr1mD27Nk1sj1LS0upQXF3DLVNLpdLP5eOtSuv7O7xbPdavHgx1q1bh+PHj8PCwkIqnzt3Lr777jvMnz8fzZo1g5mZGV544QUUFRVV925UOe7WrVsjMjIS27Ztw65duzBo0CAMGzYMP/30U4Xrz8nJwSeffIJBgwZVb+BERFTr2C4oH9sFbBeQfmAPAKL78Pb2hlwux7Fjx6SyhIQEREdHS++DgoIQFxcHpVIJHx8frdfdJ9mRI0fijz/+wN69e5GamoqhQ4dWuN2AgADs27ev3GUP2p6RkVG5Mfj7++PIkSNa6zpy5AiaNm2qVXb3vpa+9/f3BwAoFAoAJZn2mnbw4EG88cYbWLt2LRo1aqS17MiRIxg8eDBGjBiBli1bwtPTs8xkSgqF4oFxVvY7qSpra2sMHz4cv/zyC37++WcsX75cahjI5fIycQUFBeHatWtljqePj49WvfsdGyIiqnlsF7Bd8DDYLiB9wh4ARPdhYWGBMWPGYPr06bCxsYGtrS3efPNNKJVKqU7Pnj0REhKCQYMG4YsvvoCPjw9iY2OxadMmTJgwAX5+fgCAoUOHYsqUKXjjjTfw5JNPwtrausLtzpw5E7169UKjRo0wdOhQFBYWYs+ePZg2bVqlt3evadOmoV27dvj8888xdOhQ7Nu3D0uXLsWaNWu06v3xxx8IDg5Gu3bt8PPPP+Pq1avS82k9PT2l59WWzjpbE4/oSUhIwNChQ/HGG2+gWbNmSEhIAFBy8ra1tYWvry/+/PNPhIeHw8LCAnPmzEFmZqbWOry8vHDgwAEMHToUSqWyzCy/APDGG29gxIgRCAwMRLdu3bB+/Xrs2LEDJ06ceOjYv/nmG7i6uiIwMBBCCPz111/w9fWVuil6eXlh9+7daNu2LZRKJWxsbPDBBx/gqaeegru7O0JDQwEAp0+fRlRUFN577z1p3fc7NkREVPPYLmC7oKrYLiC9o+tJCIj0XVZWlhg+fLgwMTERLi4uYuHChSI4OFhrtt/MzEzxyiuvCBcXF6FQKISnp6cYM2aMSExM1FrXU089JQCItWvXapXfOwmNECUz0QYEBAiFQiEcHR21Js+p7PbutXbtWuHv7y/kcrlo2LChWLRokdZyAGLx4sWiR48eQqlUikaNGom///5bq87s2bOFs7OzkMlkYsyYMUKI8if7uXuinezsbAFA7Nu3Tyo7dOiQACCSk5OFENqT/ZROKnTvq0uXLkKIktl8Bw0aJMzMzISzs7P4+OOPRWhoqBSPEEKEhYWJgIAAoVQqRemfuvK+54ULFwovLy8hl8uFv7+/NDOvEP9N9nP+/Hmp7Pz58wKAiIyMLPc7XrJkiWjZsqUwMzMTVlZWok+fPtIsxEII8ffffwsfHx9hZGQkPD09pfKtW7eKdu3aCWNjY2FlZSXat28vVq1aVaVjQ0RENY/tArYL2C6gukwmhBC1lWwgIv0mk8mwefNmDBgwQNeh0D14bIiIqLbx3KO/eGzoYXEOACIiIiIiIqJ6gAkAIiIiIiIionqAQwCIiIiIiIiI6gH2ACAiIiIiIiKqB5gAICIiIiIiIqoHmAAgIiIiIiIiqgeYACAiIiIiIiKqB5gAICIiIiIiIqoHmAAgIiIiIiIiqgeYACAiIiIiIiKqB5gAICIiIiIiIqoHmAAgIiIiIiIiqgeYACAC8Ntvv6FDhw6wsLCAubk52rdvj19//fWh1zd//nxs3bq1TLmXlxemTJnyKKGWq2vXrhgwYEC1r7ciS5cuRePGjWFsbIyWLVtiy5Ytlfrc4cOH0a1bN9jY2MDe3h79+vXDmTNnHvi5tLQ0DB48GDY2NpDJZPjrr78qtb39+/dDJpPh5MmTlap/r6ioKMhkMqxfv/6hPn8/s2bNwtGjR8uUy2QyfPXVV9W+PSKium7s2LFo3rx5uctee+01eHl51W5Ad7n3/H5vrMuXL4dMJkNKSkqNxlFR++NRBAYGYuzYsdW6zvv566+/8P3339fa9ipSW8eMqLYxAUD13tSpUzFq1Cg0bdoU69atw4YNG9C8eXOMGTMGU6dOfah1VnQC3rhxI6ZPn/6oIevUH3/8gRdeeAHPPfcctm3bhvbt22Pw4MEIDw+/7+euXr2K3r17w8zMDKtXr8bSpUuRlpaGHj16ICEh4b6fnTdvHvbt24cVK1YgLCwMXbp0qc5dqpCLiwvCwsLQvXv3al/3Rx99VG4CICwsDCNHjqz27RERUe354IMP8Pvvv9f6dmsiAVDb9CUBQPS4MtJ1AES69Pfff+O7777DzJkzMWvWLKm8T58+cHV1xezZs9G7d28MHDiwWrYXFBRULeupDvv370e3bt0ghKjS52bOnIlhw4bh448/BgB069YN586dw+zZs+/b6Ni4cSOEEFi3bh1MTEwAAAEBAfD29sauXbswatSoCj975coVBAQE4KmnnqpSrI8iPz8fJiYmaNeuXa1tE0Ctb4+IiKpfo0aNqmU9QggUFRVBqVRWy/rowdRqNTQaja7DqDH8nSL2AKB6bf78+bCxsSn3rvyMGTNgY2OD+fPnS2WlXfq2bduG5s2bw9jYGMHBwVp3v728vBAdHY1FixZBJpNBJpNh+fLl0rJ7hwCEhYWhd+/esLS0hIWFBdq2bYtdu3ZJy99++220aNEC5ubmcHNzw/DhwxEfH1+9X0Ql3bp1C9euXcOzzz6rVT5s2DDs2bMHhYWFFX62uLgYSqUSxsbGUpmVlRUA3DcJIZPJsGHDBhw6dEj6PoGS7+2pp56Cq6srzMzMEBgYWOGwjaSkJAwZMgRmZmZwcXHBZ599prV81qxZMDc3x/Hjx9G+fXsYGxtj0aJFFQ4BWLlyJYKCgmBsbAx7e3s8+eSTiI6OBgDEx8dj/Pjx8Pb2homJCXx9ffHuu+9qfTel+zBjxgxpn/bv3y8tu3cIwJIlS9CkSRMolUp4eXnhk08+0WqclHZTPH36NPr16wczMzP4+vpi5cqVFX6vRESPs6r8Xfznn3/wxBNPwNTUFDY2NujatStOnz4NAMjNzcWUKVPQpEkTmJqawsvLCy+99BIyMzPvu/2KhivcuHED3bt3l9b1yy+/lPu5rVu3omXLllAqldi8eXOl4rhf+6P0OwkICICxsTHc3Nzw3nvvQa1Wa23/6NGjCA4OhrGxsdTeqYzSoYjr169HkyZNYG5uju7du+PmzZta9QoLC/Huu+/C09MTSqUS/v7+Wj0lxo4dixUrVuDixYvSPowdO1ZqA9y9voEDB0Imk+HixYtS2fDhw9G/f3/pfVpaGsaPHw97e3uYmJigQ4cOOHjwYLmxr1ixQjrXnj17ttz9XLZsGRQKBZYuXVrhd1HZ9klGRgamTp0Kd3d3KJVKNGzYEO+8845Wnfv9blY0ROHeIRuP8jtVqqJ2T0pKCpRKJX766acyn2nbtm2Z9iLpByYAqN5SqVQ4evQounXrBnNz8zLLzc3N0a1bNxw9ehQqlUoqj4+PxyuvvIIZM2Zg7dq1UCqV6NOnD5KSkgCU3Ol2dnbG0KFDERYWhrCwMK2T0d2OHDmCrl27orCwED///DM2bNiAQYMG4fbt21KdpKQkvPvuu/jnn3/w7bffIioqCl26dNGKqbZcuXIFAODn56dV7u/vj6KiIkRGRlb42WHDhkGlUuH9999Hamoq4uLiMG3aNHh4eGDQoEEVfi4sLAydO3dGUFCQ9H0CQHR0NJ544gn8/PPP2Lx5M0JDQzFhwgSsWLGizDomTZqERo0a4c8//8Tzzz+P9957Dz/88INWnaKiIowYMQLPP/88tm3bht69e5cbz9y5czFmzBgEBwfjzz//xNKlS+Hr64vk5GQAQEpKCmxtbTFv3jxs374db775JlasWIGXXnpJa5+AkuEnpfvUqlWrcre3cOFCvPTSS+jTpw82b96MsWPHYtasWXjzzTfL1B05ciR69+6Nv/76C0FBQRg7diwuX75c4XdLRPS4e9DfxTVr1mDgwIFwdHTE77//jt9++w1PPPEEYmNjAQB5eXlQq9X49NNPsW3bNnzyySc4cOAAnn766YeKZ9iwYejVqxc2btyIbt26YcKECdi+fbtWnbi4OLz66quYNm0atm/fjsDAwErFcb/2x7x58zBx4kTpXPLWW29hwYIFeO+996TPJyQkoE+fPlAqlVi7di1mzJiBl19+WfouHuTMmTOYO3cu5syZg+XLl+PGjRt4/vnnteo8++yzWLJkCd544w1s2bIFffv2lc67QMnQiSeffBLe3t7SPnzwwQcICQmBsbGxdPGu0Whw+PBhrTIAOHjwIDp37gyg5E5+v379sHnzZnzxxRdYt24dzM3N0atXL0RERGjFdfLkScydO1fqzejh4VFm/0rPxytXrsSECRMq/B4q0z4pLCxE9+7d8dtvv2HGjBnYtm0bZs2apXUx/6Dfzap42N8p4P7tHnt7ewwePLhMIuvixYs4fvz4fb8n0iFBVE/Fx8cLAOK1116rsM5rr70mAIiEhAQhhBBjxowRAMSePXukOhkZGcLCwkK8/fbbUpmnp6eYPHlymfXdW96hQwfRtGlToVKpKhWzSqUSMTExAoDYsWOHVN6lSxfRv3//+35Wo9GI4uJi6bV7924BQKusuLj4vutYtWqVACDi4+O1yk+cOCEAiCNHjtz38+Hh4cLJyUkAEACEl5eXuHr16gP2WohBgwaJLl26PHDfJk2aJNq3by+V79u3TwAQo0aN0qo/atQo4ebmJtRqtRBCiJkzZwoA4o8//tCqFxkZKQCIdevWCSFKjrWpqamYNGnSA2MuVVxcLH777TdhZGQkcnNzpXIAYu7cuWXq312uUqmEvb29GDZsmFadd955RygUCpGSkiKEEGLZsmUCgFi0aJFUJycnR5iamoqPP/640rESEemzMWPGiGbNmpW77H//+5/w9PSU3lfm76JGoxHu7u6iT58+lY6huLhYHD58WADQOn/de36/N9bSeD744AOt9XXu3Fm0a9dO63MARHh4eLXEIYQQWVlZwtzcXLzzzjta5YsXLxYmJibSueStt94SFhYWIiMjQ6qzZ88eAUCMGTPmvvF06dJFmJmZiaSkpDL7fOfOHSGEEHv37i3TfhFCiOeee060adNG6zso7zh37txZjB07VgghxOnTp4VcLhcvvviieO6554QQQly/fl0AEEePHhVCCLFp0yYBQGzfvl1aR1FRkWjQoIEYMmSIVuxyuVzcvn1ba3ul8ScnJ4vPPvtMKJVKsWnTpvt+D/eqqH3y448/asVa3uce9Lt5d3x3a9mypdbxepTfqcq0e0rbk5cuXZLKXn/9deHh4SG1s0i/sAcAURVZWVlpTQpnZWWFnj174tixY1VaT15eHsLDwzFmzBgYGhpWWG/btm3o0KEDrKysYGRkBHd3dwDAtWvXqrS9FStWQC6XS6+ePXsCgFaZXC5HVFRUldZbWdeuXUNoaCh69+6NXbt2YfPmzfD09ES/fv2QmJhY5fWlp6fj1VdfhaenpxT7jz/+WO73MnjwYK33Q4cORWxsLGJiYrTKK+qpUSosLAx5eXn3zWgLITB//nw0bdoUJiYmkMvlGDlyJFQqFW7dulWFPSzpcZGSkoJnnnlGq/y5555DUVERjh8/rlV+d68FMzMzeHp6ltlHIqL65H5/F69evYqYmBiMHz/+vuv49ddfERQUBHNzc8jlcnTs2BFA1c/DQNnzUWhoKCIiIrS64tvZ2aFt27bVFsfRo0eRk5ODZ555BiqVSnr17NkT+fn5uHDhAgDg2LFj6NatmzQ8DwC6d+8OW1vbSu1bYGAgHBwcpPdNmzYFAOn73rlzJ2xtbdG9e3etOHr16oXTp0+XGY5wr86dO0t3+w8ePIjWrVujX79+WmWmpqZo3bo1AODQoUOwtLREnz59pHXI5XIMGTIEhw8f1lp3QEBAuXf9AeC9997Dp59+ii1btlRqLqLKtE/27NkDf39/tG/fvtx1VPZ3s7Ie9neqMu2e7t27w9vbW+oFoFKpsGrVKowdOxYGBrzU1Ec8KlRv2dvbQ6lUanW3v9ft27dhbGwMOzs7qezuk1spJyenKo/LT09Ph0ajgaura4V1Tpw4IY0j+/XXXxEWFibNN1BQUFCl7Q0cOBAnTpyQXqVd4O8uO3HixH3jsbGxAYAy48PS09MB4L6NhHfffRfOzs5YuXIlevbsiQEDBmDLli1IT0/Ht99+W6V9AUrGtK1evRrTp0/Hzp07ceLECYwfP77c78XR0VHrvZOTEwBoHTNTU9Nyh4LcLTU1FQDu+x3Nnz8fb7zxBgYNGoRNmzbh+PHjWLRoEYCqH7PS77U03nvjT0tL0yq3trbWeq9QKKq8TSIifWVkZFThRaJarYZcLi9Tfr+/i5X5m75x40aMHj0aISEhWLt2LcLDw7Fx40YAVf+bDpR/PiouLtbq+n3v3/xHjaN03a1atdJK+Pv6+gIA7ty5A6DknHhvfOXFXJHyvuu740tJSUFaWlqZGw8TJ06ESqV6YDuqS5cuuHXrFmJjY6Wu/p06dUJCQgKuX7+OgwcPol27dtLvQXp6ermxOzk5lTl/lvedl1q/fj1atGghXRw/SGXaJ6mpqff9vavM72ZVPOzvVGXikMlkmDhxIn799VeoVCps2bIFycnJGDduXLXETtWPTwGgesvIyAgdOnTA/v37kZubCzMzM63lubm52L9/Pzp06AAjo//+q5SO9b5bYmIiXFxcqrR9a2trGBgYIC4ursI6GzduhJWVFdauXStlUUsnm6sqOzs7rURGTk4OAEiZ8sooHft/5coVNGnSRCq/cuUKFAoFvL29K/zspUuXymS6zc3N4ePjU2aSoAcpKCjAli1bMG/ePK1HNVY0a2/p/AylSnsc3H3MSifmu5/S7y8uLk7qiXGvdevW4amnnsLnn38ulV26dOmB6y5PaUKlovgre1eGiOhx4ODgUOFjY+Pi4ip9oVrq7r/pFVm3bh0CAwOxZMkSqezAgQNV2s7dkpKS4ObmJr1PTEyEXC6Hvb29VFbe+ehR4ig9V/z555/l3uVu2LAhgJJz4r3nm9KYq4OtrS0cHBwqfGLQg45f+/btIZfLcfDgQRw6dAjjx4+Hra0tmjVrhgMHDuDgwYMYPXq01vbKiz0xMbHM+fN+bYC///4bQ4YMQWhoKP76669yE02lKts+sbOzw7lz5ypcT2V+N0snVS4qKtIqL715cLeH/Z2qTLsHAMaNG4cPP/wQW7ZswS+//IJu3bpJv1ekf9gDgOq11157DWlpafj666/LLPv666+RlpaG1157Tas8MzMTe/fu1Xq/e/dura5VlbnzamZmhvbt22PlypUV3tHIz8+HXC7X+sP922+/VWbXaoS3tzcaN26MdevWaZWvWbMGPXr0kLL95fH09MTp06e1ZvzPysrC9evX4eXlVaU4CgsLodFotLaXnZ2Nv//+u9z6pRntUuvXr4erq+t9T2blad++PUxNTbFs2bIK6+Tn55f5Hso7ZnK5/IG/I02aNIGDg0OZ73vt2rVQKBQICQmpQvRERHVbly5dkJGRUWYW96ysLOzbt0+a/K2ymjRpAnd392r5m15Z956PNmzYgODg4PsOBaxKHOW1P0rPXTExMWjdunWZV+lFXkhICPbt26fVy2/v3r1l7pY/rJ49eyI5ORkKhaLcOEr3r6I2lJmZGVq1aoUlS5YgNTVVuiPfpUsX/Pbbb4iMjNT6HejYsSOysrKwc+dOqUylUmHjxo2VvpsPlPye7N69G8eOHcPw4cPvO1Shsu2Tnj174vLlyxUOH63M72ZpG+buSS0vX74s9eh4kMr8TlWm3QMAzs7OGDBgAL788kts27at2oYuUM1gDwCq15566ilMmTIFs2bNwp07d6Sx1hs2bMBPP/2EKVOmYODAgVqfsbW1xYQJE/DRRx/B2toac+bMgRBCK1Hg7++PvXv3YteuXbCxsUHDhg217r6XmjNnDrp3746ePXvilVdegY2NDU6dOgV7e3uMHz8evXr1wvz58zF16lQMHjwYYWFhFT7qrrbMmjULI0eORKNGjdCtWzesWbMGx44d02qQRUdHo1GjRvjwww/x4YcfAgBeeuklPP300xg5ciRGjx6NgoICfP311ygsLMTEiROrFIOVlRXatGmDOXPmwMHBAUZGRpgzZw6srKzKzfbv3bsXM2bMQK9evbBr1y78+uuvWLRoUZXHpllZWWHmzJl46623oNFoMGjQIGg0Guzbtw/Dhw9H69at0atXL3z77bf47rvv0LhxY6xatQo3btwosy5/f39s2rQJnTp1gpmZGZo0aQILCwutOoaGhvjggw/w6quvwtHREU8++STCw8PxxRdf4LXXXiv3d4qI6HHVu3dvdOrUCUOGDMGHH36I5s2bIy4uDl9++SUMDQ3x6quvVml9pY9dHT58OEJDQzF69GgolUqEhYWhTZs2GDBgAHr16oXJkyfj448/Rvv27bF161bs2bPnofdh5cqVMDExQatWrfDHH3/g4MGD+Oeffx74ucrGUVH7Y/bs2XjzzTcRExODrl27wtDQELdu3cKmTZuwYcMGmJqa4rXXXsOiRYvQr18/vP3220hPT8fMmTOr7VzTq1cvDBw4EH379sWbb76JgIAA5Obm4uLFi7hx4wZ+/vlnaR9++eUXrF69Gr6+vrC3t5duFHTu3Blz585Fq1atYGlpKZUtWrQIcrlcq6dh//79ERISgueffx5z5syBk5MTFi5ciPj4eLz77rtVir1FixbYuXMnunfvjjFjxmDlypXltiEq2z4ZNWoUvv/+e/Tv3x8zZ85E8+bNpaENP/74Y6V+N9u2bQsPDw9MmzYNn3/+ObKysjBnzpxKH6/K/E5Vpt1T6oUXXkD//v1hbW2N0NDQKn2/VMt0PAkhkV5YtWqVaN++vTAzMxNmZmaiXbt2YuXKlWXqlc5Mu2XLFuHv7y8UCoUICgoqM/v9hQsXRKdOnYSFhYUAIJYtWyaEKH923iNHjohu3boJU1NTYWFhIdq1ayd2794tLf/iiy+Eu7u7MDU1Fb169RLXrl0rM4N8ZZ4CcK/SGfIfxs8//yx8fHyEQqEQLVq0EJs3b9ZaXjp7/syZM7XK165dK9q0aSMsLS2Fvb296NWr1wNnpRWi/KcAXL9+XXTv3l2YmpoKDw8PMXfuXDFz5kxhZmZWZh+3bNkinnrqKWFqaiqcnJzKzIx/7+fu3Y/SpwCU+uWXX0SLFi2EQqEQdnZ2YsCAASI6OloIIUR2drYYO3assLGxETY2NuKFF14QmzdvFgDEiRMnpHUcOnRItGrVSpiYmAgAYt++fUKI8p8OsHjxYuHr6yvkcrlo0KCB+Pjjj7Vm1q3sTMBERHVdVlaWeO2110SDBg2EkZGRsLOzE88884y4du2aVr2q/F38+++/Rdu2bYWxsbGwtrYW3bt3F6dPnxZClDyN5Y033hAODg7CwsJCDB06VISHh5c5N1T2KQBHjx4VXbp0EcbGxqJBgwbixx9/1IqlohnwKxtHRe0PIYRYvXq1aNOmjTAxMRGWlpYiKChIfPDBB1pPADp48KAIDAwUCoVC+Pv7iy1btlTqXFJeO+T06dNa5zchhCgsLBQfffSR8PX1FQqFQjg4OIhu3bpptbkyMzPFsGHDhJ2dXZknEGzZsqXME5xKn+p09yz7pVJSUsTYsWOFra2tUCqVon379mL//v0PjF2I8n+HwsLChLm5uZg4caLQaDTlfheVaZ8IIURaWpp4+eWXhbOzs1AoFMLb21u89957WnXu97sphBAnT56UjmmLFi3E7t27y30KwKP8Tglx/3bP3eszNTUVL7/8crnfC+kPmRB39cclovsaO3YsTp48Kc2YS0RERERU3+3duxc9evTAyZMnERwcrOtw6D44BICIiIiIiIiqLC4uDjdu3MCMGTPwxBNP8OK/DuAkgERERERERFRlP/74I7p16wYA0jwOpN84BICIiIiIiIioHmAPACIiIiIiIqJ6gAkAIiIiIiIionqACQAiIiIiIiKieoBPAaikgoICnD9/Hg4ODjAy4tdGRES6o1KpkJycjBYtWsDY2FjX4dRLbBcQEZG+qEq7gGesSjp//jxCQkJ0HQYREZHk+PHjaNOmja7DqJfYLiAiIn1TmXYBEwCV5ODgAKDkS3VxcdFxNEREVJ/Fx8cjJCREOjdR7WO7gIiI9EVV2gVMAFRSafc+FxcXuLu76zgaIiIisOu5DrFdQERE+qYy7QJOAkhERERERERUDzAB8ABz586Fo6MjWrZsqetQiIiIiIiIiB4aEwAPMGPGDCQlJeHs2bO6DoWIiIgeICsrC1OmTIGHhwdMTU3RvXt3XLp0SVpeUFCAyZMnw87ODubm5ggNDUVSUpIOIyYiIqo9TAAQERHRY2PixIk4cOAAVq9ejTNnzsDf3x+9evVCdnY2AGDatGnYvHkz1q1bhwMHDiAuLg5Dhw596O0FBATAwcFB69WnTx9p+e7du8ssL319+eWXUr133323wnoRERFSvbZt25Zbx8fHR6oTFRVV4bpefPFFqd7SpUsrrLdmzRqp3siRIyusl5KSItVzdnYut06PHj2kOgcOHKhwXZ999plU78MPP6ywXnh4uFSvY8eO5dbx8vKS6sTExFS4rgkTJkj1Vq5cWWG933//Xao3ZsyYCuslJCRI9Tw8PMqt07VrV6nOkSNHKlzX7NmzpXqzZ8+usN6RI0ekel27di23joeHh1QnISGhwnWNGTNGqvf7779XWG/lypVSvQkTJlRYLyYmRqrn5eVVbp2OHTtKdcLDwytc14cffijV++yzzyqsd+DAAalejx49yq3j7Ows1UlJSalwXSNHjpTqrVmzpsJ6S5culeq9+OKLFdaLioqS6vn4+JRbp23btlKdiIiICtf17rvvSvW+/PLLCuvt3r1bqtenT58K65XKyMiosM6wYcOkehs2bKiw3o8//ijVmzx5coX1bt68KdXz8/Mrt07r1q2lOmfPnq1wXW+99ZZUb968eRXW27Fjh1RvwIABFdZTqVQAgJycnArrhIaGSuvatGlThfW+//57qd6rr75aYb0rV65I9Zo3b15uncDAQKnOhQsXpPKAgABUFhMARERE9FjIz8/Hn3/+ia+++godO3ZE48aNsXDhQqhUKvz+++/IzMzE0qVL8c0336B79+4IDg7GsmXLcOjQIZw8eVLX4RMREdU4mRBC6DqIuiAmJgYeHh64c+cOZ/slIiKd4jmpfNnZ2bC0tMT+/fvRpUsXqdzDwwPdu3fHmDFj0KNHD2RlZcHCwkJa7unpienTp2Pq1KkVrjsrKwtZWVnS+9JHLvEYEBGRrlWlXcDnBxEREdFjwcLCAm3btsVHH32E33//HXZ2dliwYAFiYmKQkJCAhIQEmJiYaF38A4CTk5NW1+3yzJs3Dx999FFNhk9ERHqqSKXBhlMxuJ2WB09bU4QGu0NuWLYzfXXXqwlMABAREdFjY9WqVRgzZgxcXFxgaGiI7t27o1+/fnjUDo+vv/46Jk6cKL0v7QFARET6pzovxItUGoxaegzHItOkspVhUZjawxeFxRrkFqmQV6hGZn4xNpyKQXxmgVRv3q5r6OXvBCNDGWQyGQxkMgghsP1igla9v87E4dcJIbWSBGACQA8VFKux73w0sk/+gSYdBqBl88pP6kBERFSf+fj44MiRI8jOzkZ+fj4cHR3Rrl07tGrVCs7OzsjPz0d2drZWL4DExEStScHKY2lpCUtLy5oOn4iozqjuu9jVddFe3gX7n6djsXRM6zL1Jqw4gRNR6VLZsqNRGB7SAElZBYjPLEBcRj6uJ+YgLa9IK4ZL8dl4edWpB+5TUnYhfjt++4H1wm+lYkNEDIaFNHhg3UfFBIAeyS9SY+elBOw9fR0Dk3+AdfJNFGRHAH6/A0ZKXYdHRERUZ1hYWMDCwgK3bt3CyZMnMWvWLAQHB0Mul2PXrl0YMmQIAODq1au4ffs22rdvr+OIiYjqjvIustdHxGDZuDYwVxpBJpNp1b33gt1AJkNOgQpZBcXIzC9GWk4hPv7nMq4n5UifW7DnOro1cUR+sRq5RSrkFqqRXViMawk5yC9WS/Xe/+sCjOUGUGsAtUagWK3BvX2+jkemocWsnQ/cr6sJ2Zj198WH/2IeQXRaXq1shwkAPZBXpML2CwnYej4eBnkpGJ7+A7784yi2n0+Bu8157PH+Bo0Hv63rMImIiPTe9u3bYWBgAB8fH1y6dAn/+9//0L9/f/Tt2xdAySPLpk2bBhsbG1haWmLq1Kno1KmT1qOmiIgeV5Xt8r7hVAwiU3JhbSJHc3dLJGYWIjYjH7Hp+YjNyMeVhGyk5WrfFT8ZnY4Ws3ZCJgOMjQxhqjCE0sgAaXlFKCjWSPXe23ge6kqMyorLLKjU3XOVRiCnUP3AetXNy94U3vbmMFUYwkxhhJj0PBy5mVqmXp9mTmjhZgWNKElQnI/JwN6ryWXqedqa1kbYTADoUk6hClvPx2P7hQTkFangq0zHcwU/YvzPB3AiMhMAEJNeiC/nf4+fOzwFODXVccRERET6LT09He+++y5iY2Ph6OiI559/HrNmzZKWf/PNNzAwMEBoaCgKCwvRt29frWc0ExE9ropUGoxeegzhd921X3o4EsPaeCA1twhJ2YVIzCpARHQ68ooe/oJaCCC/WK11l/5ulbn416UWblZo29AWzlbGcLU2gb25AnO2XcGp2xlSnXbedmXG7Jf3/bbztsN3I1pVql5ocO08UYaPAayk6nzkUmZ+Mbaej8eOiwkoKFbD0cIYIxsVwO7op+g3Zx9uJGp3/1AYGeDm98/BfdwyDgUgIiI+BlAP8BgQkT65+86+m7UxQrxsEZ9ViJj0PNxJy8ed9DycvZ2BmIx8XYcqkckAC6URrEzlUKmF1qR4pfo0c0I7bzuYKY1gpjDCiag0LD8aVabeW/38MCTIDYYGJZPsvbzqFE5G/ze2v21DW/wytk2ZC/Hxy0/geJT2hXh5k/EVqzXYEBGD6AfMT1Dd9SqLjwHUY5l5xXj1j9MoVKnhYmWCwUFueMIsBueWvY+OXx1BYmZhmc8UqTT4dPURLG65Egh5QQdRExERERFRbSuvy76RgQzpecWITs3F7bQ83ErOxW/HopGSU/TgFT4kT1tTdGpsDzdrU7jZmMDRQokvt997V9wWS8e0gUojUFCsRl6RGhtPxWDB3htl1jdzYFOMae8FAwOZtJ+VuXveq6kTrsRnlak3sWNDrXqrJ7V74AW2wsgAv73QtlIX4nJDg0pN0Ffd9WoCewBUUnVm+n8Ni0IjB3O087aDwZ0w7F08HU9/ewLZBSqpTqdOnWBiYoKdO0smq1AYGSLyy65wHfEt4NTskbZPRER1G+8+6x6PARE9iorG4gshkFOoQkpOERIy8zFz00Vcu2tiPFOFIQwA5DxCF/17BXpYoY2XLRwtjHEjKQdrTt4pU2fOkBZlLlgrcxe7ogv72rjLXp+wB4CeG9Xeq+SHazuw5pt3MOqnsyhW/zcxxuDBg7Fq1SrsPrFbSgAUqdSYs+0WFjSYDwz6jkMBiIiIiIj0jHZXfBP09HdEbpEaWfkls91nFaiQmluIXw5F4k76f93xP/7nEqyM5UjNLUKhSlPh+qsyNt/OTIHWXjbwsDGFh60pXKyU+G7fTZyLyZTq3HsxXqTSIDo1t1Lj0ytzF1thZIBfJ+rmLjuVjwkAXTm/HgvmzMRrqy/h7j4YL774IhYtWoSj8UfxV8FfCOgSgHMHzgEAfjwQg3eejITLKQ4FICIiIiKqLXdf2LtaGaNDI7uSu/RZBUjKKkRCVskz4w9fT0F24X+9et//q3Lrzy1UI7cKM9kbyABXaxN42pmiSCVw4q5x7KVm9GlS5kK5m5/TfS/Gq3LBXlm8YNcvTADUNiEgTv6Cd2d9jjlbb2ot+uijj/DBBx8gPjcev13+DQDgOdRTSgAUFhXji32pmG+9CWjQHnBuXuvhExERERHVJ4XFagxZfBQX47JqbZvWpnLIDQ2QnF12frDpvRtjUudGUBj9d9e+srPKV+ZinBfsjzcmAGpZcWYiXpj+CVYcjJLKDAwMsHjxYkyaNAlF6iJ8f+Z7FGuKMdxvOFZjNfw7+ePyocsAgCU7L+OtHk5wOfIthwIQEREREdWQ/CI1/j4bi/m7r5c7Q31lGcsN4GplAgsTOaxM5EjPLcL52Mwy9aZ298Hz7Txha6aA3NCgwgv7F7s0qvG79vT4YgKgFuXm5uLZkROw9a6Lf2NjY6xevRpPP/00AOD3y78jLjcOT/s8jV6evRCVGYWUZ1OkBEBBQSG+PGGEbyzjgYgVQNtJOtgTIiIiIqLHU1RKLlaFR2NdRAwy84srrGdjKkczVys4WRrD2UqJO2l5+PtsfJl6swY207qjXtGF/as9fB/6wp537amymACoRWfPnsWuXbuk99bW1ti8eTM6duwIAAiPD8fB2IPws/XDAO8BAIDBvoNxPOE4fDr44sbR6wCAH9bvwZu9RsHl8t+AZwcOBSAiIiIiekhFKg3WRdzBkespuJGcg2uJOQ/+EIC3+vqVubBPyip8YFd8XtiTLjEBUIs6dOiAlStXYvjw4XB3d8f27dvRrFnJI/0SchOw4uIKWMgtMKnFJBjISv4A2JvYo5dnLyQOS5QSAAUFBZh7TGBeWyPgyHzgqe8AubGudouIiIiIqE66mpCF8ctPIjYjv9zl9uZKPNvaHWG3UnFa65n3vLCnuokJgFo2bNgwFBcXo2vXrvDw8AAAFKuL8cPZH1CkLsKUwCmwNrbW+kx/7/441PQQPEK8cOd4FABg8S+r8ObQBXCO3gScWgG0fbGW94SIiIiIqO5JzCrA5rNx+PtsnNYj8e7maWuK13s3Rr/mLlAYGVT62fO8sCd9xwSADowaNUrr/dpra3E7+zYGeA9AM/tmZeqbyc3Qv1F/RI2IkhIABQUF+PLvS5jXswlweTPg3hpwC66N8ImIiIiI9N7dj+5ztFDC2MgQW87H4ejNVK3HcJfnyQAXDAp0k97zwp4eF0wA6FhEYgT23N4DX2tfDGo0qMJ6PTx6YE/gHpxodQaJp2IAAD8sWYI3Xz4C54zPgP1zgP5fA9b8w0RERERE9VuRSoNRS4/h2F3j8avC09a0miMi0g98NoQOJecl45cLv8BMboYXW74IQwPDCuvKDeUY4jsEgSMDpLL8/HzMXbIK6Po2oCoAdn8E5GfUQuRERERERPprycGb9734b+Zqifee9MfBN7uiXUNbrWXlje8nelywB4COqDQq/HD2B+Sr8vG/Vv+DrbHtAz/TzqUd2rVrg5MtTyP130eMLF68GG+++Sac2r4EhC8G9n0K9PkMMJTX9C4QEREREekVtUbgl8ORmL/rWrnLgz2t8UVoAHwcLaSyyk7cR/Q44G/2A8ydOxeOjo5o2bJlta53w7UNiMyKRB/PPmjpULl1y2QyPNvkWTQbdk8vgLlzAb/+gP9AIOkycORbPHBgExERERHRY+RGUjaG/nAUn269DHUFTeFngj20Lv6B/8b3lz7Wjxf/9Djjb/cDzJgxA0lJSTh79my1rfNM0hnsiN6BhpYNEdo4tEqfbWrXFE926wnrFk5S2ffff4/ExESgzcSSiQBv7QfOra22eImIiIiI9JVKrcGifTfw5LeHtR7VpzTSvtRh134iJgBqXUZBBpaeXwoTIxO81PIlGBlUfRTGCP/n0PhZ7V4Ac+bMgZAZAF3eAqw9gdO/ApGHqjN0IiIiIiK9cjk+C4O/P4q5O66iSK0BAMhkwISODXHivZ6YM6QFXu7aCHOGtMCvE0J4d5/qPc4BUMsslZbo7dUbLmYucDB1eKh1eFh6YECXp3C1+TlkXkgEAMyfPx9Hjx7F9OnTMbjXezDaPgM4PA8wdwIcGlfnLhARERER6UyRSoM1J+5g09lYnI5O1+ru38jBDF8ObYlgTxsA4KP7iO7BFFgtM5AZYGCjgWjt3PqR1vNSq2HwfLq5Vtnx48fx7LPPwjfoCSy46YWc/GJgz0dATvIjbYuIiIiISB8UqTR4dkkYPth0ASej/rv4lwF4uWsj/PNqJ+nin4jKYg+AOsrBzB49n3gGWWPSkLD+Kgpy86RlUVFR+N/7n2GmpTnGdHTAczlToOz3P8gVFmjh0EKHURMRERERPbwFe67jzJ2MMuWTuzXC9D5+tR8QUR3DBEAdNikoFGFxB9G0WwDsLwtsXrYZ6Unp0vKMrBx8uzUHC3dEwfuJg2g2rC2+HPYlGttwSAARERER1S2Hr6dgycGb5S6raNZ/ItLGBEAd1sTJHj6m3XCjYDvsu1jgqU5PIepQFC5tuITkG/91+9eoBW4cTMCNg5tgcM0Af37zpw6jJiIiIiKqmk1nYjF93VkUV3Cl72lrWssREdVNnAOgjnvW/0k4Fj+HnJjBsC94EWMG/IKNWy9iw+at6NevX5n6fy34CxEXInQQKRERUc3Lzs7GK6+8Ajc3N5iamqJ58+ZYuXKltLygoACTJ0+GnZ0dzM3NERoaiqSkJB1GTEQP8vOhW/jfH2eki38jA5nWcj7ej6jy2AOgjuvXwgUGBh1xMS4TVxNysCM1ETsuJQKwRsPnP8FbQ6bg9NZfsXvTWmg0GgiNwJsfTseeP/fpOnQiIqJqN23aNBw8eBCrV6+Gh4cHtm7dinHjxsHT0xNdunTBtGnT8M8//2DdunWwsrLClClTMHToUBw8eFDXoRPRPTQagS+2X8GSg7ekMjdrE/wytjVO385AdFoePG1NERrszsf7EVUSEwB1nKGBDE+2cMGTLVwghEBcZgGuJWbjakI2riVkI0pjA5u+r8IjPgPR4dsBAPs2HcD1G9fh6+Or4+iJiIiqV3h4OMaNG4fOnTsDACZPnowFCxbgxIkTCAwMxNKlS7F69Wp0794dALBs2TL4+/vj5MmTaN360Z7QQ0TVp1itwZvrz2Hj6VipzM/ZAivGh8DJ0hhNnC11GB1R3cUEwGNEJpPBzdoEbtYm6NbEEQCQVVCM64nZ+Mfkdcw8tgMQoqQXwPuvYuMf23QcMRERUfXq0KEDNm3ahDFjxsDFxQU7d+5EbGwsevbsiYiICBQXF6N3795SfT8/PzRo0ABhYWH3TQBkZWUhKytLeh8fH1+j+0FUHxWpNNhwKgY3k3Jw4HoyrifmSMvaedvix9GtYWks12GERHUfEwCPOUtjOYI9bdHq+Z74bXEvXAvbCQDYvH4HbkdHo4Gnp44jJCIiqj4LFizAxIkT4ebmBiMjI8jlcqxcuRKBgYH4/fffYWJiAgsLC63PODk5ISEh4b7rnTdvHj766KOaDJ2oXitSaTB66TGER6aVWda/hQvmPdcSSiNDHURG9HjhYJl6QiaT4e133pXeq9UCM999WYcRERERVb/vvvsOp0+fxj///IOIiAh88sknGD9+PMLDwx9pva+//jru3LkjvY4fP15NERMRAGw4FVPuxX97b1ssGB7Ei3+iasIeAPXIqCc74ZM23XHrxF4AwG/rduCzz27CxbORjiMjIiJ6dPn5+Xj33XexefNm9OnTBwAQEBCA48ePY/78+Zg0aRLy8/ORnZ2t1QsgMTERzs7O9123paUlLC055pioplxNyC63PNDDGob3zPpPRA+PPQDqESNDA0yb8Zb0vrhYg8/fnqTDiIiIiKpPcXExiouLYWiofafQ0NAQGo0GwcHBkMvl2LVrl7Ts6tWruH37Ntq3b1/b4RLRvzLzi7HjYvnDcDztzGo5GqLHGxMA9cwLg3ugQWBH6f2Pf+5H0tUTOoyIiIioelhaWqJLly6YPn06Dh48iMjISPz4449Yu3YtBg0aBCsrK0yYMAHTpk3Dvn37EBERgXHjxqFTp058AgCRjuQWqjB22XHEZxaUWdbO2w6hwe46iIro8cUhAPWM0sgQk19/E2+NPgwAKCzS4Ov3JuOLdccAGbtXERFR3fbHH3/g7bffxvDhw5Geng4vLy98++23GDlyJADgm2++gYGBAUJDQ1FYWIi+ffvi+++/13HURPVTQbEaL6w8idO3M6SyJ1s4w9PODJ62pggNdofckPcriaqTTAghdB1EXRATEwMPDw/cuXMH7u51OxOZW6hC4+COiLt4DABgamyI2wfWwC4kVMeRERFRZTxO56S6iseA6NEUqTR4aVUE9l5Jkspe6+mL13o21mFURHVTVc5JTKnVQ2ZKI0ycOkN6n1egxrdzZgIFWff5FBERERHRo1NrBKatPaN18f9Cp4b4Xw9fHUZFVD8wAVBPTRs1EE5NWknvv91+FZkHf9BhRERERET0uNNoBN7ecA7/nIuXyka0bYB3n/SHjMNRiWocEwD1lLWpAs+//Lr0PitfhYU/LAWSrugwKiIiIiJ6XAkhMHvLJayLiJHKng50xSeDmvPin6iWMAFQj80YOwT2jVpI77/ZGYnsvfMBjVp3QRERERHRY6VIpcHq47cRuvgolh+Nksp7N3XCV8+0hIEBL/6JagsTAPWYk5UJnn3hNel9Wm4xFv95ALjyj+6CIiIiIqLHRpFKg9FLj+GdP8/j1F2z/T/hY4eFI4JgxFn+iWoV/8fVc29NfA42Xk2k91/tiEJe+DIgN0WHURERERHR42B9xB2ER6aVKe/TzBlKI0MdRERUvzEBUM81sDPDoLH/k94nZxVgya6rQNh3AJ8QSUREREQPSa0R+DU8utxl8ZkFtRwNEQFMABCAd14cCSsPL+n93F0xKIg8BkQe0F1QRERERFRnFarUmLr6FC7HZ5e73NPWtJYjIiKACQAC0NjZEn1G/NcLID41G0sOJQLHfgTyM3QXGBERERHVObmFKkxYfhJbzyeUu7ydtx1Cg91rOSoiAgAjXQdA+uGdV0Zj669fIieu5Jmsb625gGB3Y3R0/QnoMkPH0RERERFRXZCeW4Sxy0/g7J0MqezpQFe08bJFTEY+PG1NERrsDjkn/yPSCSYACADQ0sMGPZ9/HX99WXKxX1hUjKe+O42jFgr4eXcBPEJ0HCERERER6bP4zHyMWnocN5JypLLxTzTE+/39+ag/Ij3B1BsBAGQyGd56cRwa9e8tlaVnF6DfvBNI2DYXKMrTYXREREREpM9uJedg6OIwrYv/N3o1xgcDePFPpE+YACBJiJctBj4/B+7t20tlUSl5GPD5LuQc+kGHkRERERGRPipSafDVjqt4csEhxGbkAwBkMuDjp5tjag9fyGS8+CfSJ0wAkMTAQIZXuvmgy9i5cPIPkMojojLx3BtzoIo5rcPoiIiIiEifFKk0GLToML7bdwMFxRoAgAzAN88GYlQ7T90GR0TlYgKAtPg6WeDt/s3R5eV5sHH3lsq3nk3Gi+OHQRTzma1EREREBLy1/lyZx/wJAAXFat0EREQPxAQAldHczQpvPhWELlO/gZmNg1T+y65reHtqqA4jIyIiIiJdU6k1mPX3RWw8E1vu8ug0zh1FpK+YAHiAuXPnwtHRES1bttR1KLUq2NMWM4Z0QKcp8yA3NpPKv1yyFbPnvqa7wIiIiIhIZzLzijFu+QksPxpVYR1PW9PaC4iIqoQJgAeYMWMGkpKScPbsWV2HUus6+NjjzRG90eHFT2Fg+N8TIz96ZwFmLv8QGqHRYXREREREVJtuJufg6e+P4ND1FKnM0lj7qeLtvO0QGuxe26ERUSUZPbgK1Wfd/BxRMOFZ5Gem4PjyTwAAGrXA55M/h6GVET4c/KGOIyQiIiKimnbwWjIm/34K2QUqqWxsBy+81bcJNp2JQ3RaHjxtTREa7A65Ie8xEukrJgDogfq1cEH+1BcxMzUBFzb/DAAozlPhy0lfYGCLgQjyCdJxhERERERUE4QQWHYkCp/8cwkaUVJmZCDDR4OaYWTbkpn+h4U00GGERFQVTABQpQwOckPeu+/hw7RERB7ZDADITcnD5Ncn4+jfR3UcHRERERFVpyKVBmtO3MHvx6JxOeG/mf6tTeVYPDIY7RvZ6TA6InpY7J9DlSKTyTCyrSfe+uQrOPm3kcrDt4bjzLUzuguMiIiIiKpVkUqDYT+G4YNNF7Qu/n0czPD35I68+Ceqw5gAoEqTyWSY1MUXL7w5WyoTaoF3Pn1bh1ERERH9x8vLCzKZrMxr8uTJAICCggJMnjwZdnZ2MDc3R2hoKJKSknQcNZH+EELg7T/P4dTtjDLLnm/niQZ2nOGfqC5jAoCqRCaTYdboPmjcpqtUtnvtbkTFR+ksJiIiolInTpxAfHy89Nq1axcA4JlnngEATJs2DZs3b8a6detw4MABxMXFYejQoboMmUhv3EzOwbAfw/HnqdhylydmF9ZyRERU3TgHAFWZoYEMr70xA68M2w8AUBWo8dacGVjz7TrdBkZERHXKtWvXsGbNGhw6dAjR0dHIy8uDg4MDgoKC0Lt3bwwePBgKhaJK63RwcNB6P2fOHDRq1AhdunRBZmYmli5ditWrV6N79+4AgGXLlsHf3x8nT55E69atK1xvVlYWsrKypPfx8fFViotInxWpNFhy4CYW7ruBIlXFj3n2tOXdf6K6jj0A6KFMCO0Lp8Ytpfd/L/8bKVkp9/kEERFRidOnT6NXr14IDAzEoUOH0Lp1a0yZMgUzZ87EsGHDoFar8f7778PV1RVffPEFCgsf7q5jUVERVq1ahfHjx0MmkyEiIgLFxcXo3bu3VMfPzw8NGjRAWFjYfdc1b948eHh4SK+QkJCHiolI30REp2PAwkP4etc1rYt/RwulVr123nYIDXav7fCIqJqxBwA9FIWRAYZNmIJv33oBAFCQVYT3v3oLP8xequPIiIhI3w0dOhRvvfUWNmzYAEtLywrrnThxAt9++y3mzZuHd955p8rb+euvv5CRkYGxY8cCABISEmBiYgILCwutek5OTkhISLjvul5//XVMnDhReh8fH88kANVJRSoNNpyKwY2kHFyMy0T4rTSt5d4OZvh8cAu08rTBhogYRKflwdPWFKHB7pAb8t4hUV3HBAA9tNfGDcOybz9DVlwkAGD1kj/w1bvfwtzYXMeRERGRPrt69SqMjB7cBGnTpg1WrVoFlUr1UNtZunQp+vXrB1dX14f6/N0sLS3vm6wgqguKVBqMXnoM4ZFpZZbJDWV4pasPXunWCEojQwDAsJAGtR0iEdUwpvHooXk5mKPL0AnS+6ykPHy66D0dRkRERHVBZS7+H6U+AERHR2P37t1ad+2dnZ2Rn5+P7OxsrbqJiYlwdnau8jaI6pr1EXfKvfj3tDXF1lc7YVqvxtLFPxE9npgAoEcyZeIYmNo4Se9/WbQcReoiHUZERER1UWJiIp599lk4ODjA1tYWTz31FKKioh56fcuWLYOjoyP69+8vlQUHB0Mul0tPBgBKeiPcvn0b7du3f5TwifRefpEaPx2KLHdZvxbO8HWyKHcZET1emACgR9LZzwVN+wyX3idFZmHhslm6C4iIiOqkiRMnonHjxjhw4AD27NkDGxsbPP/88w+1Lo1Gg2XLlmHMmDFavQesrKwwYcIETJs2Dfv27UNERATGjRuHTp063fcJAER1XUpOIYb/FI7IlNxyl3vZmdVyRESkK0wA0CMxlhti1JhxUJj+lzVe8O2PUGvUOoyKiIj03Xvvvac1u//ly5cxa9YsNG3aFEFBQXjnnXdw4cKFh1r37t27cfv2bYwfP77Msm+++QYDBgxAaGgoOnfuDBcXF6xbx8fY0uPrZnIOBn9/BGfuZJS7nLP7E9UvnASQHtmTrbyxpGsoLm1dDgC4fSEVv677HGOfe1+3gRERkd4qLCxEUFAQvv/+e3Tt2hV9+/ZF3759ERoaiuLiYqxYsUKr+35V9O7dG0KIcpcZGxtj0aJFWLRo0aOET1QnHLuVikm/RiAzv1gqm9rdB67WJrjN2f2J6iUmAOiRNXIwQ9cho3F112qoi0vu5nz5zUKMeeZdyAx4QiEiorK++uorjBw5Ei+99BKaNm2KOXPmYP369di9ezc0Gg1GjBiByZMn6zpMojpr05lYzFh3DkVqDQDAyECGOaEBGMq7/UT1Gq/O6JHJZDIMbOuHhh3+u1Nz5XgSNm/5QodRERGRvgsKCkJ4eDgCAwPxxBNPwNraGhs2bMDGjRvxxhtvwNjYWNchEtU5Qgh8t/c6/vfHGeni38LYCCvHh/Din4hqJwFQWFiIw4cPIy4urjY2RzrQ0dcBzfqOlO74CwF8/O13EKriB3ySiIjqM5lMhv/973/Yv38/1q9fj759+yI6OlrXYRHVOUUqDVaFR6Pft4fw1c5rUrmbtQn+fLkDOvjY6zA6ItIXNZIAGD9+PJYsWQIAKCoqQtu2bdG5c2d4e3tj27ZtNbFJ0jFzpRF6tQ2AR3B3qez0wXgc2j1Ph1EREZG+On36NIKDg2FhYYEOHTogKysLGzduxIsvvojevXvjq6++gkaj0XWYRHVCkUqDZ5ccxft/XcCVhGypvIWbJTZO7sBH/BGRpEYSANu2bUNISAgAYOPGjcjMzERCQgJmz56NDz/8sCY2SXqgWxNH+PUeKb1XqwRmff89UJSnw6iIiEgfjRs3Dt27d8fJkyfx/PPP46WXXgIADB48GBEREbh9+7bUliCiiqXnFmHssuM4cyezzLJnWnvA0YJDaYjoPzWSAEhPT4e9fUk3o23btmHo0KFwdHTEc889hytXrtTEJkkP+LtYoGmLQLg1byuVHdkTi7N7OBcAERFpi4yMxIQJE9CkSRNMnDgRt2/flpaZm5tjwYIFWLx4sQ4jJNJvBcVq/HjwJjrP3YejN1PLrROfWVDLURGRvquRpwB4eHggLCwMtra22Lp1K37//XcAQGZmJpRKZU1skvSATCZDNz9HnOk1ErEXjgEAivLUeH/FCvzt3R6yJn11HCEREemLJ598Es8++ywGDhyII0eOoHfv3mXqtGnTRgeREek3IQQ2n4vHl9uvICY9/751PW1NaykqIqoraiQBMG3aNIwcORLm5uZwd3dHt27dAAAHDx5E8+bNa2KTpCe6+DrgD//WcPVphrgbFwEAe3fG41SvrxBs6QK4tNRxhEREpA+WL1+OH3/8EVeuXMFzzz2HCRMm6DokIr1UpNJgw6kY3E7Lg0YjEHYrFeditLv7O1ooYG4sx63kXKmsnbcdQjnrPxHdo0YSAK+88gpCQkJw584d9OzZE4aGhgCAhg0b4tNPP62JTZKesDKVo7WXHaK7D0fcjfcBAHnpRXhz1w3sNP4MhgPmAVZuOo6SiIh0TalUYurUqboOg0ivFak0GL30GMIj08pdbqowxEtdGmFip4aQGxpgQ0QMotPy4GlritBgd8gN+cRvItJWIwkAAGjdujVat24tvY+JiUHv3r0hl8trapOkJ7r7OSI8qAtcGngj/vYtAMD+DXewooUTxu/5COj/NaDkbLRERPXVxo0bMXjw4ErVTUhIQHR0NNq2bfvgykSPmQ2nYsq9+JcBGBbSANN6+WpN8jcspEEtRkdEdVGNpAXff/99/PrrrwBKxin169cPDRo0gLOzM44dO1YTmyQ9EuBmBQdLU7QaMV0q06g0ePuXa8hMuw3s+xxQq3QYIRER6dLXX3+Nli1b4ptvvsH169fLLM/JycHOnTsxZswYBAQEICEhQQdREunekRsp5ZY/28YDnw9pwRn+iajKaiQBsHLlSjRu3BgAsGXLFkRERCA8PByjR4/Gm2++WRObJD1iYCBD9yaOMG8YiGfHvCCVJ9/KwMT9qUDCOeDYYkAIHUZJRES6cvjwYcyePRtbt26Fn58fbGxs4O/vj6CgIHh5ecHGxgajR4+Gs7Mzzp07h0GDBuk6ZKJat+dyIrZdKD/5FeRhXbvBENFjo0aGACQlJcHNrWSc9z///IPnnnsOISEhsLOzQ6tWrWpik6RnujRxwPqIGDQd9DJ8j+6X7vBs+CMCu9sMR89rOwArD6DZ07oNlIiIdGLQoEEYNGgQUlJScPjwYURHRyM/Px/29vYICgpCUFAQDAw4fpnqp23n4zF19WmoNWVvlnByPyJ6FDWSAHB0dMSlS5fg4uKCbdu2YeHChQCAwsJCyGSymtgk6Rl7cyVaeljj7J0MfLv4Jwzo3R0ajQZCLTB6wV7c+rQfjE/8DFi5A+6tH7xCIiJ6LNnb2+Ppp5/WdRhEeuOv07F4Y91Z6eLf3lyBUe08UaDScHI/InpkNfLXY9y4cXj22WfRvHlzaDQa6dm+x44dg5+fX01skvRQD39HCAikmzfUGvoRfysBU/cXAgoz4MAXQHqU7oIkIiIi0hNrTtzGtLVnpIt/FytjrHupA/7XszHe6uuHYSENePFPRI+kRv6CfPTRR/j5558xadIkHD16FMbGJROUGBgY4J133qmJTZIeCvKwhpu1Kbaci8OoydPRvHlzadnSH1fjsGlfQFUI7P4IyM/QXaBEREREOrYyLApvbTgvTZHkYWuCtS+2R0N7M90GRkSPlRpLIQ4dOhTTpk2Dh4eHVDZmzBhO5FOPGBkaYEp3H8hkwM9H7+DnX5bByKhk1IkQAsOnfYjcgPFAbjKw9xNAVaTjiImIiIhq348Hb+LDTRel9972Zlj7Ynt42JrqMCoiehzVWALg77//RqdOnWBvbw97e3t07twZmzdvrqnNkZ5qaG+GocHuiMvIx+UiO8ycOVNaFhMVg+k/7QCaDgKSrwBHv+WTAYiIiKjeKCxWY+KKE/hs6xWprImTBda82B4uViY6jIyIHlc1kgD44Ycf8OyzzyIgIAALFizAggUL0Lx5czz77LNYsmRJTWyS9NhTLd3g62iB7RcTMGDUy2jTpo207IfFP2BXeoOSiQBvHQDO/qHDSImIqLZ98803SEkp/1nnRI+zIpUG3b/ej92Xk6QyU4UhVk4IgYOFUoeREdHjrEYSAF999RUWLlyIRYsWYcSIERgxYgS+//57fPvtt5g7d25NbJL0mKGBDK90awSFkSF+OhyNxT8thVL534lt3MQJyGz5ImDjCZz5DYg8qMNoiYioNi1evBhubm4YPHgwNm/eDLVareuQiGrF2xvOITajQKssr0iNfVeSKvgEEdGjq5EEwJ07d9CtW7cy5d27d0dMTExNbJL0nIuVCZ5v2wCpuYUITzPBZ599Ji2LjYnFa2++C/SYBRhbAYe/AZKv6i5YIiKqNdeuXcOePXtgb2+PUaNGwc3NDdOnT8fFixcf/GGiOurojRRsPB1b7rLotLxajoaI6pMaSQD4+Phgw4YNZcrXr18PHx+fmtgk1QG9mjqhpYc1Dl1PRrunRqGcDSntAACW70lEQVRz587SsuXLl+PvvWFAjw9LCvbMBnKYASciqg86duyIn376CfHx8fj6669x9uxZBAYGIiQkBEuWLEFubq6uQySqNjeTc/DSqghUNOuRJyf+I6IaVCMJgFmzZuG9997DgAED8Pnnn+Pzzz/HgAED8MEHH+Cjjz6qiU1SHSCTyfBS50YwVxrhlyNRmL9oCUzN/jvJvfDCC4grtgA6vg4UZAJ7PgKKmAUnIqovFAoFzMzMYGJiAplMBgMDA8yZMwceHh7YuHFjpdcTExODESNGwNbWFiYmJggKCsLly5el5QUFBZg8eTLs7Oxgbm6O0NBQJCUx6Uw1Lz23COOXn0BWgQpAyTDJu7XztkNosLsuQiOieqJGEgDPPPMMwsLCYGVlhXXr1mHdunWwsrJCWFgYQkNDa2KTVEfYmCkwoaM3cgpV2HEH+Pqrr6VlSUlJePrpp5Hv3BoIHAmkRwMHvgA0Gh1GTERENe3cuXOYNm0aXF1d8dJLL6FJkyY4e/YswsPDcevWLXz44Yd45ZVXKrWu9PR0dOzYEcbGxtixYwcuXryIzz77DBYWFlKdadOmYfPmzVi3bh0OHDiAuLg4DB06tKZ2jwgAUKhS48VVEYhOLbm5YWQgw7JxrTFnSAu83LUR5gxpgV8nhEBuWGMP6SIiglFNrbhNmzb47bffamr1VIe1b2SHk1H2OHIzBRM7P42+/Tdh+z/bAQAnTpzApEmTsHLFCsiyYkqeDHDiZ6DtJB1HTURENSEoKAgXL15E7969sXjxYjz11FMwMvqveSKTyfD888/j9ddfr9T6vvjiC3h4eOCXX36Ryry9vaWfMzMzsXTpUqxevRrdu3cHACxbtgz+/v44efIkWrduXe56s7KykJWVJb2Pj4+v0n5S/SaEwLt/XsDxyDSp7NPBzdHZ11GHURFRfVRtKca8vLxKv4jGdWwIWzMFfg2/jYU/rIBvE19p2apVq/D1vHlAh/8BDn7A5b+BK//oMFoiIqopzzzzDKKiorBlyxYMGTJE6+K/lL29PTSV7A32999/o3Xr1ggNDYWjoyOCg4OxatUqaXlERASKi4vRu3dvqczPzw8NGjRAWFhYheudN28ePDw8pFdISEgV9pLqu8UHbmLDqf8mwn6xszeea9NAhxERUX1VbQkAc3NzWFhY3PdVWofIXGmEl7o0QqFKjZURSdi8aQusrK2k5W+99Ra27twNdH8fMHcCjv0AxJ7SYcRERFQTpk+fDltb2zLlBQUFKCoqqvL6bt26he+//x5NmzbFzp07MX78eIwfPx6bNm0CACQkJMDExKRMe8TJyQkJCQkVrvf111/HnTt3pNfx48erHBvVT9vOx+PL7f893ah3Uye81ddPhxERUX1WbUMA9u3bV12ronoiwN0afZo5Y8fFBFxu0ADr1q5D3759odFooNFo8MywZxBxPAJ+PWcC/7wB7P8c6P81YM2MORHR4yI0NBQ9evTAa6+9plX+448/Yu/evfjrr7+qtD6NRoOQkBB8/PHHAIDAwEBERETghx9+wKBBgx46TktLS1haWj7056l+OheTgWlrz0jvm7tZYv6wQBjcM/kfEVFtqbYEQJcuXaprVVSPjGjbAOdjMrE+IgafDu6Ar7/+GtOmTQMA5GXnoWvfrrhw6gLsu74N7J4F7P4I6PclYGan28CJiKhaHD16FHPmzClT3rNnT+kiviqcnZ3h56d9d9Xf3x/Hjh2Tlufn5yM7O1urF0BiYiKcnZ2rvD2i8hSpNFh6+BYW7L2BguKS4StOlkr8PLoNTBU1NgUXEdEDcZpR0imlkSFe6eYDtUZgycFbmDr1VYwdO1ZanhidiE4DOyHfoSnQ9mUgJxHYNgPIitNd0EREVG0KCgrKLRdCIDc3t8rr69ChA65fv65Vdu3aNTRoUNJ7LDg4GHK5HLt27ZKWX716Fbdv30b79u2rvD2iexWpNBj5czi+2H4V+UVqAICBDFjyfDCcrYx1HB0R1XdMAJDO+Tia48kWzriVnIOdlxLxww8/aDXCrhy9gj7j+yDfpxvQfgqQkwRsnQGk3dJh1EREVB2Cg4O1Zuwv9fPPPyMoKKjK65s2bRqOHDmCL774Ajdu3MCKFSvw66+/So8RtLKywoQJEzBt2jTs27cPERERGDduHDp16lThEwCIKutOWh4mrjyBE1HpWuUaAVxJyNZRVERE/2EfJNILz7T2QHhkGtacvIM2DW3x559/onXr1oiNjQUAHPrtEEZ4j8CK91fAUmEGHPoK2PY20HMW4NRUt8ETEdFD++STT9C7d2+cPXsW3bp1A1Ayr9CRI0ewY8eOKq+vbdu22LBhA9577z3MnDkTjRo1wk8//YSBAwdKdb755hsYGBggNDQUhYWF6Nu3L77//vtq2yeqXzQagYPXk/FrWDT2Xk2CEOXXi07jk7CISPdkQlT0Z4ruFhMTAw8PD9y5cwfu7u66DuexFBGdjrk7riDY0wbTezdBREQEOnXqJHUPNZQbYtR3ozBv9DzYpN4C9n5a8sFu7wLuvGtDRPXH43ZOunbtGubMmYNz584BAAICAvDOO+/A19f3AZ/UncftGFDlFKk02HAqBrfT8uBorkSRWoPVx28jKvXBF/dzhrTAsBBOZExE1a8q56Qa7QFw8uRJ3Lx5EwMGDICZmRmysrJgbGwMhUJRk5ulOirY0wZtG9rhWGQqTkSlI6R1ayxduhQjR44EAKiL1VjzzhqYOpji434fw7bPpyUTA+6ZDXR6HfDuqtP4iYjo4TRu3LjcYQBE+qRIpcHopccQHpl233oB7lbILVThZvJ/c1i087ZDaDATRUSkezWSAIiPj8dTTz2FM2fOQKPR4Pr16/D29sbbb78NQ0NDLFy4sCY2S4+BsR28cD42E8uORKK5myVGjBiBc+fO4YsvvgAA5KflY82ba2AoN8TMHjNh13cOsOsD4OBXQFEu4Ndfx3tAREQPKyEhAUVFRVplpZP3Eena+og7FV78K40MMCjQFaPaeaGFuxWK1RpsiIhBdFoePG1NERrsDrkhp94iIt2rkb9Er776Kry8vJCeng5TU1OpfOjQodi5c2dNbJIeEzZmCgwPaYD0vCKsPn4HAPDpp5+if///LuxTb6Tit9d+w6zds5BqYgk8+RVg7gSELwbOrkGFg++IiEjvZGRk4Pnnn4eJiQnc3NzQsGFDrReRPlCpNfg1LLrcZR287XDs3R74cmhLtHC3AgDIDQ0wLKQB3urrh2EhDXjxT0R6o0b+Gu3fvx+zZ8+Gubm5Vrm3tzfu3LlTE5ukx0hPf0c0drLA7kuJuJaYDUNDQ/z2228ICAiQ6qTdTMNv//sNM3fNRIqREfDkXMDaEzj9K3DiZyYBiIjqiGnTpuHq1avYvn07jI2NsWHDBixatAgNGzbE+vXrdR0eEfKL1Hhp1SlcrmAW/6cCXWFtyuGtRFQ31EgCoLi4uNzy2NjYMkkBonvJZDK80MkbhgYy/HTwFlRqDaysrLBnzx4EBgZK9dIj0/Hbq79h5vaZSJFpgH5zAIcmwKVNwJH5gFqls30gIqLK2bFjBxYsWIAuXbrA0NAQzZo1w0svvYQvvvgC3377ra7Do3ouI68Izy89ht2XE8tdzrH9RFTX1EgCoHfv3lrj/GUyGXJzc/HRRx+hX79+NbHJB9qyZQuaNGkCX19f/PzzzzqJgSrPw9YUA1u64E56HraciwcA2NvbY8+ePQgODpbqZURn4Lf//Yb3t72PZHUB0PtTwDUQuLEH2PUhUMhn7hIR6bPs7Gy4uLgAAGxsbJCcnAwACA4OxvHjx3UZGtVzsRn5GPpDGCKi06WyZ4Pd8enTzfFy10aYM6QFfp0Qwu79RFSn1MhfrHnz5uHAgQMICAhAQUEBRo8eDW9vb0RFRUmTudUmlUqF6dOnY//+/Th9+jS++uorpKam1nocVDVPB7nB2dIYG07FICGz5FGAtra22L17N0JCQqR6mXcysfrV1Xh/6/tI/j979x1XVf0/cPx12XtvkY0IKqgoinujZkstTcssG19z5Sgry9HQyra2h/UrtXJkuVduRQUVHIiyBJQ9Zck6vz/ImwRu4AK+n4/HfcT9nPX+3JP3nPO+n1F2GfrPh1YhkBoJG2dC/iUN1UAIIcTN+Pj4cO7cOaBq+r9vv/2WtLQ0vv32W3ViQIiGFp16mRFfHCQmvUBdNrW/N++N9GdsV1fp2y+EaLLq5VvL2dmZiIgIZs+ezfTp02nXrh1vv/02J06cwMHBoT4OeUNHjhyhXbt2ODo6YmJiwn333SeDETYB+jraPNPTg7KKSr7bF4fyT79+CwsLtm3bRnBwsHrd/Iv5rJy6kjkb5pBWkgXBk6HT01UP/xtmQOpJTVVDCCHEDUydOpXk5GQA5s2bx4YNG3BycuKjjz5i4cKFGo5O3IsOx2Ux8quDpOZX/figUsHbD7VlxsBWqFQqDUcnhBB3p97Sljo6OowdO5b333+fL774gmeffbbajAC3Y+/evdx///04OTmhUqnYsGFDjXU+//xz3NzcMDAwoGvXrhw9elS97NKlS7Ro0UL93tnZmYsXL95RLKJhtW1hTq9Wtpy6lMe+85nqcnNzc7Zu3UqPHj3UZZdTLrNy2kpeW/8aqUVp0HY49HsDKstg2+twfocmqiCEEOIGxo0bx9NPPw1Ap06duHDhAkePHiUpKYlRo0ZpODpxrygtr2TlkUSe/zmMMd8d5nJJ1ThCejpafDm2I493ddVwhEIIUTfqJQHw2muv8dVXX9Uo//rrr3njjTdue3+FhYUEBATw+eef17r8t99+Y8aMGcybN49jx47h7+9PSEgImZmZta4vmpbHu7pioq/Lz6EXyC/5d4BJU1NTNm/eTJ8+fdRlBakF/DbtN15d9yqnM0+DSxcY8j4YmFcNDBj+o8wQIIQQjURZWRn+/v6cPXtWXWZkZETHjh2xsbHRYGTiXlJaXsm47w/z6tqTbD2dRkVl1X2Cqb42v0zowuC20hVFCNF81EsC4Oeff6Zjx441yjt16sRPP/102/sbMmQIb7/9Ng8//HCtyz/66COee+45nnrqKfz8/Pjqq68wNDTkxx9/BMDJyanaL/7Jyck4OTnd8Jj5+fkkJyerXykpKbcdt6gbZga6jAt25XJJGb+EVp+D18TEhI0bN9K/f391WWF6Iaumr2Luurksj1pOqUVLGPYJWHvBydWwayGUlTRwLYQQQvyXrq6uJOuFxq05lkxofHaN8gk9PQhyt9JAREIIUX/qJQGQkZGBtbV1jXILCwvS09Pr9FilpaWEh4czaNAgdZmWlhYDBgzg0KFDAAQFBREZGUlKSgoFBQVs2LCBkJCQG+73o48+omXLlurXtYPOiYbX09uGtk7m7D2Xwe7o6v8PGRkZsX79+mr/DxRmFLJh2ga+WfYNCw4tILG8AIa8B67dIPEQbJkNRTUv9kIIIRrWxIkT+eCDD6ioqNB0KOIedbSWh3+AK+WVDRyJEELUP5362Kmnpyc7duzA09OzWvm2bdtwc3Or02NlZmZSUVGBvb19tXJ7e3tiYmKAqvEIFi9eTO/evamsrOTll1+uNUFxrRkzZvDMM8+o36ekpEgSQINUKhX/6+PJvL9O8/WeOPS0tejm9W/zUENDQ/7880+GDx/O5s2bASgtKmXv4r1cOn6J5EnJjA4YTUjv2Wgd/wVOroINL0L/eWDteZ2jCiGEqG+RkZFs3bqVrVu34u/vj7GxcbXlv//+u4YiE/eC9MslbI9Kq3WZq9WdjV0lhBCNWb0kAF588UWmT59OZmamun/2rl27eO+99/jggw/q45A39cADD/DAAw/c8vpmZmaYmZnVY0TidtmY6PP6fb68uf4MS3fFoKOtVa1pnoGBAX/88QeTJk3i+++/V5fH7Igh62wWObNziAyK5Jl2z2Bt3gIOLqmaJrDzBGg9rGqYXyGEEA3KxMSEESNGaDoMcQ8qLa9k4i/H1AP+XaurhzUjAp01EJUQQtSvekkAPPvss+jq6vLmm2+qB/1zc3Pj888/Z9y4cXV6LBsbG7S1tUlLq569TUtL08iUg6J+OZobMuc+XxasP8NnO88zc1ArOrhYqpfr6+vz3XffMWDAAJ577jkuX74MQE5yDpumbyLt6TQuPHKBcW3G0XXwu7DnfTj8NVw6Dt2nVQ0WKIQQosEsW7ZM0yGIe9T89acJv5Cjfj8myAVzI11crYwYEeiMrna9TZYlhBAaU2/fbOPHjycuLo78/Hzy8/OJi4ur84d/AD09PQIDA9m+fbu6rLKykp07d1abJ140H86WRrx+ny/6Olp8tP0cpy7m1Vhn9OjRnDhxolq3jYryCo58c4TNr2/ms72f8XXKXgqHvAtuPSHpCPw5GS6daMCaCCGEEEITVhxOZMXhRPX7F/p4snB4O2YPbs3oIBd5+BdCNFv10gLgWiYmJne9j4KCAnV/foD4+HhOnDiBg4MDDg4OzJgxgyeffJLAwECCgoL45JNPKCoqYvz48Xd9bNE4uVob8+pQX97ZeIb3t0YzZ6gvPg6m1dbx8PBg3759vPHGG7z//vvq8oTDCWRPziZ7Vjbnu55nYsD/8GwRCIe/hG2vQ9sR0OEJ0K73fx5CCHHPc3d3R3WDLlhxcXENGI24F4RfyGbeX6fU7/v42DJzkI8GIxJCiIZTL084KSkpzJo1i127dpGeno7yn3nXb3ek37CwMPr27at+P3XqVADmzZvH/PnzGTVqFBkZGcydO5fU1FTat2/Pli1bZA7hZs7LzoTZQ1qzcNNZ3t0cxZz7/PCyq55w0tPT47333qN///488cQT6lko8jPz2fbqNtIeTSP7yWwe9X2UkGGfotq3GE6tgZQI6P0ymN14ukghhBB3Z9asWdXel5WVceLECTZu3MhLL72koahEc5WaV8L/fjlGWUXVvambtRGfju6AtpaMAySEuDeolP8+ndeBgQMHkpqaytSpU3F0dKyR2b/vvvvq+pD1Ljk5mZYtW5KUlISzswwK05icupjHe1vOoq+jxRvD/HC1Nq51vbS0NMaNG8e2bduqlXt08SD45WCC3IKY4PckxqfWwKm1oGMAXSeCZz8ZIFAI0ajcC9ekb7/9lj179vDLL79oOpRa3QvnoLm5Ul7BqK9DOZGUC4CxnjZ/TOpOK3vTG28ohBCN3O1ck+qlBcChQ4c4dOgQ7dq1q4/dC1FN2xbmzBzkwwdbo3l7YxTz7vfD2bLm1D329vZs3ryZDz/8kNdee43y8qpRf+MOx3Hl1SuUvlFK4uVE/uf/P7wc28P+j2D/x3DxGAS/AHq1JxaEEELUvX79+jFjxgxNhyGaCUVReGPdKfXDP8CHj7aXh38hxD2nXkY48fb2pqioqD523eAWL16MnZ0dAQEBmg5F3ED7lhZMG+BN4ZVy3t4QRUpeca3raWlp8dJLL3HgwIFq2bGL5y7y98y/iTsVx7tH32VLaTrK/UvAuRPE74EN0yHnQkNVRwgh7mmlpaV8/fXX2NvbazoU0cSVlley8kgi4344wu9hyeryqf28GNxWZosSQtx76iUB8OGHH/Lyyy9z4MAB8vLyKCoqqvZqSl566SXS09OJiIjQdCjiJjq7WTG5nxd5xWW8uf4MYQnZ1103KCiI0NBQOnTooC7LSs9i6+yt5B3P4/dzv/PZ2f+joOdM6DwBLqfAxhmQsL8hqiKEEPcMW1tb7Ozs1C9bW1uMjY358ssvqw3geqvmz5+PSqWq9mrdurV6eUlJCZMmTcLa2hoTExNGjBihHh9GNC+l5ZWM+/4wr649yb7zmeryvj62vDiglQYjE0IIzamXLgADBgwAoFevXrUuv91BAIW4Vd08bVAU+G5fHB9si6azmxVPdnPDxkS/xrotWrRg7969PPbYY2zYsAGAosIi1r62lkdeeoSIvhHMD11Q1SVg0Nuw+z3Y/S60GwkdxoGWTBEkhBB3a/HixdXGCtLS0sLW1pagoCCsrKzuaJ8BAQFs2bJF/V5H59/bnenTp7Nx40ZWrVqFubk5kydPZuTIkezdu/fOKyEapTXHkgmNr/ljQK9WtmjJoH9CiHtUvSQAdu3aVR+7FeKWdPeywdfRjB8PJnAkPouTF/N4tFNLQto41Bjl18TEhHXr1vHiiy+ydOlSACorK/ntvd8YkTECrZFavHvkXYZ5DmPo0MXo7X0fTq6GrBjoPRv0pe+gEELcjfqYsldHRwcHh5rNu/Py8vj+++9ZuXIl/fr1A2DZsmX4+voSFhZGp06d6jwWoTmJWYW1lqdfvtLAkQghRONRLwmA3r1718duhbhlVsZ6zBjYivAL2fxwIIH/O5TAvvMZPNPTA0/b6lMFamtrs2TJEry9vXnxxRfV01au+WENA1MHEvBiAH/F/sXBSwd5LHAM7WMPoIr9G9a/CP3mgJWHBmoohBDNw5IlS7C0tOTxxx+vVr58+XJyc3OZNGnSbe8zKioKR0dHDA0N6d69O4sWLcLZ2Znw8HDKysoYNGiQet3WrVvj4uLCoUOHbpgAyM/PJz8/X/0+JSXltuMSDSs1r/YHfVermgMFCyHEvaLe2jBHREQwefJkhgwZor5IrlmzhrCwsPo6pBA1BLpa8eEjAQzzd+JCVhGv/3GKHw/EU1xasxvK1KlTWbduHUZG/94YbN+0nZ2v7KSfeT/yS/NZcvJrPjaE1A5joDADNs6CuN0NWCMhhGhePv74Y1xdXWuUu7u78/HHH9/2/rp06cKPP/7I1q1b+fLLL4mNjaVXr14UFhaSmpqKoaEhpqbVW2/Z29uTmpp6w/1+9NFHtGzZUv0KCgq67dhEw7mQVciW0zWTNF09rBkRKNM2CiHuXfWSANi0aRNdu3YlKyuLXbt2UVxcNSJ7UlISb775Zn0cUojrMtDV5vGurix8uB0etsZsOZ3KjN9PcCQ+W/1r/1UPPPAAe/furdZ09Pix47z26Gs8wAN0cejCqaxTvJG2i1Vt+lOiow97P4Aj30KljG0hhBC369KlS7XOWezo6MjFixdve39DhgzhkUcewd/fn5CQEDZt2kRWVharV6++qzhnzJhBUlKS+nXkyJG72p+oPxWVCjN+j6C4rBIAc0MdJvRw593h7fh5QhC62jKGjxDi3lUv34Bz585lyZIlrFy5El1dXXV5r169OHr0aH0cUoibcrMx5q0H2/J0d3dKyir4aHs0S/+OobKyehIgMDCQw4cP065dO3VZUlISwwYNI+HXBKYHTMfR2JHNWRG8ZmtFqLkNypl1sO0NKLr+zANCCCFqatGiBYcPH65RHhoaWms//ttlYWFBq1atiImJwcHBgeLiYi5fvlxtnbS0tJsey8zMDGdnZ/XL0dHxrmMT9eOrPbGEX8hRv//y8UDeGObH6CAXefgXQtzz6uVbMCoqSj0TwLUsLCzIycmpZQshGoaWlopBbRz46NH2BLS04EBsJr8cvlBjPRcXF/bv31+tn6iiKLz77ruMGzKOkWYjGdt6LKUqFd8YqnjP0oyk1HD4438QvRn+07JACCFE7SZMmMC0adNYvnw5Fy9e5OLFi/zyyy+8+OKLPPPMM3e9/4KCAmJjY3F0dCQwMBBdXV22b9+uXh4dHU1iYiLBwcF3fSyheacv5fHJjnPq9xN6uNPN00aDEQkhRONSLwkAOzs74uLiapQfPHgQd3f3+jikELfF8p9BAlvZm7LpZApbTtXs+2lmZsbGjRt5++23q00hdeLECYI6B3Fq3Sne7v42vZx7c97AiPmWJiwnn6JDS2DTS5CT0IA1EkKIpunVV19l4sSJPPvss7i4uODi4sLzzz/PpEmTePXVV297f7NmzWLPnj0kJCRw8OBBHn74YXR0dBg1ahTm5uZMmDCB6dOns2vXLsLDw3nqqafo2bOnzADQDJSUVTD9txOUVVQl4b3tTHgpxEfDUQkhRONSLwmAZ599lmnTphEeHo5KpSItLY3ffvuNWbNm8fzzz9fHIevN4sWLsbOzIyAgQNOhiDqmr6PNzEE+2Jka8NPBhGrNBa/S0dFhzpw5HDp0CB+ff28irly5wosvvsgj9z/CAIsBzOk6Bze79uy0suc1Ux0OZhxH+WsKhP8E5TLdkBBCXI9KpWL+/Pnk5OQQERFBREQE2dnZzJ07Fy2t279NSU5O5rHHHsPHx4dHH30UGxsbQkNDsba2BqoGHRw2bBgjRoygV69eODo6smrVqrqultCAD7dFcy6tAAAdLRUfj2qPga62hqMSQojGRaX8dxS0OqAoCgsXLmTRokUUFRUBoKenx/Tp01m0aFFdH65BJCcn07JlS5KSkmodrEg0XZdyi5n75ynKKhTmP9AGdxvjWtcrKipi9uzZLF26tFq5hYUFX331FY8++ih7k/ey+txqCosyaFWQw9gr0NLEGYInQYuODVEdIcQ9oDldk1JTUykvL69Rj+TkZHR1dbG3t9dQZDfWnM5BcxAal8Vj34aqe+DNGtSKyf28NRuUEEI0kNu5JtV5C4CKigqOHTvGlClTyM7O5tSpU4SGhpKZmdlkH/5F8+ZkYciMgT5UVCq8v+UsWQW1/2JvZGTEkiVL2LJlS7XBn3Jzcxk9ejSPP/44AaYBLOq5iN4eQzhv2YIFZvr8WhRP8fbXYc9iKJYxMIQQ4lpjx45l69atNcq3b9/OE088oYGIRFNzuaSMmb9HqB/+O7hY8L/enpoNSgghGqk6TwBoa2vTrVs3MjMz0dPTw8/Pj6CgIExMTOr6UELUGT8nM57v7UFOUSnvbTlLcen1p/QLCQnh5MmTjBw5slr5ihUr8PX15efvf2ZMqzHMCX6dlo6BbLN2Yo5hBaHxW1DWPg/RW2SQQCGE+EdYWBg9e/asUd6jRw+ZOUjckgXrz3Axt2rKaUNdbT5+tD06Mtq/EELUql6+Hdu0aUNiYmJ97FqIetPT25aRgS1JzC7ik53nqKi8/kO6tbU1v//+O//3f/+HmZmZujw1NZUXXngBX19fjmw+wpygOTzRbgJlNt58Y2HOYiWDS4c+gS2vQF5yA9RKCCEaN0VRKC4urlFeUFBAWVmZBiISTcnW06msDv/3ejrnPl/crtOVTwghRD0lABYtWsTMmTPZsmULGRkZFBUVVXsJ0ViN6NiCnt62RCTlsuxAPDcaIkOlUvHEE08QGRlJ7969qy2LjY3lscceo3Onzlw5c4W3e7xDD69hnLV2Ya4RrEg7ROG6FyDiN6gor+9qCSFEo9WjRw/ef//9at+3iqKwePFiunfvrsHIRGNWWl7JN3vjmPbrcXVZHx9bxnZx0WBUQgjR+NXLIIDXjtqrUqlqLK+ouH7z6sZKBvu5d5RXVLJw01nOpOTxeFdXhvk73XSbyspK1qxZw5w5czh//nyN5X369GHRokXY+Niw/OxyLmScwTg/hQfKtelr4YtO92lgK1MVCSFuTXO6Jp08eZJ+/fphbW2t7gqwb98+srOz+fvvv2nbtq2GI6xdczoHTU1peSXjvj9MaHy2ukxbS8W+l/rgZGmkwciEEEIzbueapHPDpXdo165d9bFbIRqEjrYWMwa1Yu66UywPTcTO1IAgd6sbbqOlpcUjjzzCQw89xLJly1iwYAGXLl1SL9+9ezfBwcE89NBDvPPOO+S65LI6+ndWZp/j77xjjNo4iYDWj6AKHAe6hvVdRSGEaDTatWtHdHQ0S5Ys4eTJkwCMGTOGyZMnY2V14+9ecW9acyy52sM/QEWlwt7zmYwOkhYAQghxI/XSAqA5kkz/vSc9v4TX152ipLySOUN98XEwveVti4qKWLJkCe+++y65ubnVlmlpafHcc8+x4J0FHMo+xOZzayjNSaB1WTmjDV1w6T4LnDvVcW2EEM2JXJM0T86B5ry35Sxf7o6tUT6xjyezB7fWQERCCKFZGp0G8KqIiAgmT57MkCFDSElJAWDNmjWEhYXV1yGFqFN2ZgbMCvFBURTe2nCGP09cpPIGAwNey8jIiNmzZxMXF8crr7yCoeG/v+pXVlby1Vdf0dG/I1pRWizq9ynd2j3BWTMbFpTEsWzHdHJ3vQXFufVUMyGEaHwuXbpEaGgoe/furfYS4r/sTfVrLXe1kub/QghxM/WSANi0aRNdu3YlKyuLXbt2qUf3TUpK4s0336yPQwpRL1rZmzL/gTbYmuqz8kgib244Q8blK7e8vaWlJYsWLSImJobnn38ebW1t9bKLFy/ywAMP8MJTL/CAw4PM7f8Z3p6D2aevwysX/mLdmlHkRP4qgwQKIZq15ORkevTogbOzM927d6dPnz707dtX/RLiv1S13L129bBmRKC0xBBCiJuplwTA3LlzWbJkCStXrkRXV1dd3qtXL5nTVzQ5nrYmLBrejgG+9pxNzefl1RHsP595wxkC/svJyYmvvvqKU6dO1Zjv+tdff8XPz48DGw7wcrf5TOq7GDO7Nvyl5DHr2Ad88Pt9HIz4kZLykrqumhBCaNzUqVMxMTEhLi4OIyMjjhw5wsaNG/H392fbtm2aDk80Moqi8PvRf6f96+xmybvD2/HzhCB0teutYasQQjQb9fJNGRUVxYABA2qUW1hYkJOTUx+HrDeLFy/Gzs6OgIAATYciNMhAV5tnenrwUkhrdLW1WLrrPEv+jqHgyu39Ot+6dWt2797NF198gYmJibo8KyuLxx9/nPvvvx+7MnsWDv6OiX0/IMCuA2dLc/ju+FJeXH0f3x1ZzOnM01QqlXVdRSGE0Ih9+/bx7rvv4ubmhkqlwszMjMGDB/P+++8ze/ZsTYcnGpmI5DxOX8oHqkb+X/JYR0YHucjDvxBC3KJ6+ba0s7MjLi6uRvnBgwdxd3evj0PWm5deeon09HQiIiI0HYpoBAJdLVk8MoCOLpYcjM1k9upITl3Mu619aGlpMXHiRE6fPs3QoUOrLdu0aRN+fn5889U3BDp1Y+rQb/no/t8YY9eVFiVFHIz6nQ//nsGsv6fxe/TvJF1OqsvqCSFEgysvL8fc3BwAGxsb9bhBnp6enDlzRpOhiUZoxeEL6r/7t7bDwdxAg9EIIUTTUy8JgGeffZZp06YRHh6OSqUiLS2N3377jVmzZvH888/XxyGFaDDmRrq8FOLDMz08uHylnHc2RvFL6AXKKm7vV3kXFxc2bNjA8uXLsba2VpcXFBQwadIkevfuzalTpzCzcmfA0KW8MfQH3rHoxH1FJWhdDGfL6Z+Zd2Aub4e+TXR2dF1XUwghGkSbNm2IjIwEoEuXLixevJjDhw/z9ttv4+HhoeHoRGOSV1zGXxH/TrE7potM+SeEELdLpz52+uqrr6IoCr1796aoqIju3bujp6fH9OnTefHFF+vjkEI0KJVKxQA/e/yczFi6K4YNkZeITM7lkU4tCXC2QE/n1nJrKpWKMWPGMHDgQKZNm8bKlSvVy/bv34+/vz9PPvkkCxYswMXFF8cHvmBE3G6Ghy0jOj+VA1fSOHSlgPdy42hv155HfR7FwdihvqothBB17rXXXlMPFvzWW28xbNgwgoODsba25rffftNwdKIxWXf8IiVlVcl2Z0tDennbajgiIYRoelTK7YxkdgORkZG0bdsWLa1/H3xKS0uJiYmhoKAAPz+/an2emxqZ71dcT3lFJWuPXeSP4xdRUDDU1aaTmxVdPazwd7a4rX6JGzZs4H//+x8XL16sVq6vr8/kyZN59dVXq1oLlF+BU2vh5CpSK4pYZajLcQMDtAzM6evSl/s978dMz6yuqyqEaCSa+zUpOzsbS0tLVCqVpkO5ruZ+DhobRVEI+WQv59IKAHgpxIdJfb00HJUQQjQOt3NNqrMEgLa2NikpKdjZ2eHh4cHRo0erNWtu6uRCL24mPb+E0PhsDsVmEp9ZCKBOBnTztKZdC3N0biEZkJeXxxtvvMGXX35JeXn1QQbNzc155ZVXmDp1KkZGRlCUDRG/wvmtRFcW87uhDvGGJhgY2TDMYxgDXQeiq617nSMJIZoquSZpnpyDhhWWkM3Irw4BoKOl4tCr/bE11ddwVEII0TjczjWpzsYAMDc359Klqn5ZCQkJVFbKKOXi3mJnZsADAU4sGu7PJ6M6MLqzC/ZmBuw7n8F7W87y/M/hfLUnlsjk3BtOIWhubs5nn31GVFQUo0aNqrYsLy+PV199FW9vb7799lvK9cwg+AUY/i0+3vfxeokWz2VnYZwZy+rTP/Hq/lc5dOnQbU1ZKIQQQjQ2yw8nqv8OaeMgD/9CCHGH6qwFwJNPPslff/2Fl5cXx44dIyAgAB2d2ocYOHLkSF0cskFJpl/cqZS8Yg7FZhEal0VidhEAXdyteb63B0Z6Nx+GIywsjNmzZ/P333/XWObj48OiRYt46KGHqprK5l+CiJWUxf7NDorYYKBNsbENrja+POj5IG1t2qKjVS9DfwghGpBckzRPzkHDySkspcuinZSWV/24tOKZLnTzstFwVEII0XjczjWpzp4EfvjhB1avXs358+cJDw+nf//+TbrPvxB1xdHckOEdnRne0ZnknCJ+P5rE4fgsErIKeXFAK9xtjG+4fadOndixYwfbt29n9uzZnDhxQr0sOjqa4cOHExgYyIIFCxg6dCiqnjPRbfcIQ06soEfCXv4qucSuwgw+y4rGxMiGLo5dCHYMxt3cvVH3rxVCCCEA1hxLVj/8u9sYE+zZfLqYCiFEQ6uzFgDXeuqpp/jss88wNTWt611rjGT6RV1RFIXNp1JZfvgCWioV44LdGOBrd0sP45WVlfz666+8/vrrxMfH11geFBTEggULCAkJqdpfdhwcX05m0kEOUswhc2vSDExASxs7IzuCHYPp6tgVe2P7+qiqEKKeNKdr0t69e+nWrVuNVoPl5eUcPHiQXr16aSiyG2tO56AxUxSF/h/uIe6fsXXmDPXl2V4yPaQQQlxLI4MA1iYzM5PY2Fjat2+Pvn7T7qslF3pR12LSL/PxjvNkFVyhu6cNz/T0wFBP+5a2LS0t5euvv+att94iIyOjxvKuXbuyYMECBg4cWJUIyIiGw1+hZJ4jXk+fQy38OFKRz+WyqtGUPcw9CHYKprNDZ5k9QIgmoDldk64dRPhaWVlZ2NnZUVFRoaHIbqw5nYPG7GBsJmO+PQyAnrYWoa/1x8pYT8NRCSFE46KRQQCvdfnyZUaMGIGdnR3dunVTT2n2/PPP88Ybb9THIYVocrzsTHlvhD8dXSw5EJvJa3+cJDGr6Ja21dPTY8qUKcTFxfHuu+9iZWVVbXloaCghISH07NmTnTt3oti0gvs+QtV9Oh5ahoyNP8GHlyt40e0Bujh0IflyMsujljNj9ww+OPoB2y9sJ6OoZmJBCCHqmqIotbaAys7Oxtj4xl2kRPO34prB/4a2c5CHfyGEuEv1kgCYMWMGWVlZnDlzpmqqsn88+OCDrFu3rj4OKUSTZKKvw0shPozp4kpafgmv/3mKXdHpt769iQmzZ88mISGBd955B0tLy2rLDxw4wIABA+jTpw+7du9G8eoPw7+BNg+hk5uE/6HveD43n4+D3uCZts/ga+VLdE40K8+uZPa+2czZP4dV51ZxPuc8lYrM7CGEqDuPPvoojz76KCqVimeeeUb9/tFHH2XEiBEMGTKEbt263dUxJk6ciEqlYunSpeqy7Oxsxo4di5mZGZaWljzzzDMUFhbebXVEPcgsuMLW06nq92O6uGowGiGEaB7qJQGwceNGPv74Y1q3bl2tvHXr1rX2W27MFi9ejJ2dHQEBAZoORTRTKpWKBwKcmHd/G0z0tfl6Tyxf7I6hpOzWm72ampry2muvkZCQwJtvvomFhUW15Xv37qVfv34EBQXx69r1lHcYDw9+Dk7tIX4Phuun0i0rmZkdpvJZv8+YGDCRbk7duFx6mc3xm1l0ZBEv7nqR705+x9HUoxSXF9fpZyCEuPcYGxtjbGyMoigYGhqq3xsbG2NjY8OECRP45Zdf7nj/GzZs4NChQzg5OVUrHzt2LKdPn2b79u2sX7+ePXv2MHHixLutjqgHq8KSKauo6qnqbWdCZzfLm2whhBDiZuplDAATExNOnDiBl5cXpqamRERE4OHhQXh4OAMHDiQ7O7uuD1nvpK+faAh5xWV8sSuGiORcWlgYMa2/Ny7WRjff8D9yc3P59NNP+eijj8jPz6+x3NXVlWnTpvHMhAmY5kbBkW+gIA1MHcB/FLj3Ah19KpVK4nLjOJFxghPpJ7hUeAkAbZU27Wza0dWxK+3t2qOnLU0yhWhIzematGDBAmbNmlWnzf3T0tLo1KkTmzZt4v7772fWrFlMnjyZqKgo/Pz8CAsLIzAwEIAtW7Zw3333cenSJeztb31A1OZ0DhqjykqFPh/sVk+fO+9+P57q7q7hqIQQonHS+BgAPXv2ZPny5er3KpUKRVH44IMP6NOnT30cUohmwdxQl1eGtGZ0ZxdS8oqZs+4km0+mcLt5OgsLC+bNm0dCQgJvvPEGZmbVB/a7cOECM2bMwLllS15aspqkwNeg4zgoyoYDn8JvT8Dhr9HKTcLL0ouRrUbydo+3ea/ne4xpPQZvS28iMiL4KvIrpu2axreR3xKZEUl5ZXldfhxCiHvAvHnzqj38Z2Rk8MsvvxAWFnbH+3zqqaeYOnUq7dq1q1Z+6NAhrK2t1Q//AAMGDEClUnHkyJEb7jM/P5/k5GT1KyUl5Y7jEze3PyZT/fBvoKvF8A6SZBFCiLqgc/NVbt/ixYvp378/YWFhlJaW8uqrr3L69GnS0tLYv39/fRxSiGZDpVLxUIcW+DmZsfTvGH46lMCJ5Fwm9vbEwuj2fmm3tLTkzTffZNasWXz33Xd88sknJCUlqZfn5+fzwQcf8MknnzBq1ChmTplBB5NMiN4MUeurXnZ+4DMEXLtja2TLANcBDHAdQG5JLodTD3M45TCHUg5xKOUQprqmdHboTFfHrnhaeN7S1IZCiHvbkCFDGDJkCFOnTuXy5ct07NiRgoICCgsL+e677xg3btxt7W/p0qUUFhYyc+bMGstSU1NrzDago6ODlZUVqampNda/1kcffcSCBQtuKxZx55YfvqD+e5i/E+ZGuhqMRgghmo96aQHQtm1bzp07R9euXXnwwQfJz8/ngQce4MSJE7Rq1ao+DilEs9PKvmqWgJ7etkQk5fLy6kiOJebc0b7MzMyYMWMGsbGxrFixotqvX1A13/by5cvp2LUnvV/4mF8Ke1Dce15VV4DMaNj3Iax6Eo58C3lVs3pYGFgQ4hbC3OC5LOyxkAc9H8RI14i/k/5m4ZGFzN47m1XnVhGVFUVZRdldfx5CiOYpLCyMfv36AbB69WrMzMxIT0/n+++/5/3337+tfZ09e5a33nqLn376CS2tur3FmTFjBklJSerXzVoMiDuXnFPEtjNp6vejOsmv/0IIUVfqfAyAsrIyhg8fzscff4yXl1dd7lqjpK+f0KQDMZl8ty+O4rIKBvk5MLarC/o62ne8P0VR2Lt3Lx988AEbNmyodR1zc3PGjBnDhLGP0tE0A9X5rXD5n1/IHPzBewC4dANdg2r7vZB/gdCUUI6kHiH3Si4Aulq6eFl44Wvti5+1H25mbmip6iX/KMQ9oTldkwwNDYmOjsbFxYXRo0fj7e3NW2+9RWJiIr6+vrc1Qv+PP/7I008/Xe3hv6KiAi0tLby9vXn55Zd5+eWXyczMVC8vLy/HwMCAP/74g/vvv/+Wj9WczkFjUlpeSb8Pd5Oc8+9gs109rPh5Qhd0teW6IYQQtbmda1K9DAJoY2NDaGioJACEqEPpl0v4/O8YotMu42xpxNR+dzZA4H+dPXuWjz/+mJ9++okrV67Uuk5AQADPTJjA2P7+WKYdhMRDoFSCjgG4dQfPflVJgWua/FcqlcTnxXMm6wxR2VGczzlPhVI1s4GhjiE+lj74WfvhZ+2Ho7GjdBcQ4jY0p2tSu3btePbZZ3n44Ydp27YtmzZtonv37oSHhzN06FDS0tJuvpN/5ObmkpycXK0sJCSE8ePHM378eMrLy/Hz8yM8PJyOHTsCsG3bNoYMGSKDADYSK48k8urakzXK3x3ejtFBLhqISAghGj+NJwCmTZuGqakpb7/9dl3vWmPkQi8ag4pKhXXHL7LmWDLaWirGBLkwuK1DnTw8X21y+8MPPxATE1PrOvr6+gwfPpwJj4+ir0slWnG7IDuuaqGxTVUiwLM/mLeosW1pRSnnc88TlRVFVFYUCfkJKFR9/VgZWBHsGEw3p244mjjedV2EaO6a0zVp9erVjBkzhoqKCnr37s3ff/8NwKJFi9i7dy+bN2++q/27ubmpZwGAqjEH0tLS+OqrrygrK+Opp56iS5cu/Pzzz7e13+Z0DhqTBX+dZtnBhBrlE/t4Mntw65obCCGEuK1rUr0MAqhSqViyZAnbt2+nU6dONab2ud0+fUKIKtpaKkYEOtPO2Vw9QODh+GwebO9E+5YWd5UIsLOz49VXX+WVV15h7969fP/996xevZri4n+bYV65coWVK1eycuVK3NzcGD9+PE8++Ahu5echdhdE/l71svWpSgS49wR9UwD0tPVoY92GNtZtACgsKyQ6O5ozWWc4ln6MjfEb2Ri/EXczd7q16EYXhy6Y6Jnc3QcmhGj0Ro4cSY8ePUhJSSEgIEBd3r9/fx5++OE6P97y5cuZPHky/fv3R0tLi5EjR/LZZ5/V+XHEnbner1KuVnff4k0IIUQ9tQDo27fv9Q+oUqmz+02JZPpFY1NcWsFPhxLYE52BgoKjuSEhbRzo3coWQ707Hx/gWnl5eaxcuZLvvvuO8PDw667Xr18/nnrySYZ388To4kFIPAgVZaClA96DoO1wMHW47vaVSiVRWVEcvHSQ8LRwSitL0VZpE2AbQDenbvjb+qOjVS/5SiGapOZ4TcrMzCQ2Npb27dujr6+v6XBuqjmeg8bg4+3n+HTn+WplXT2s+XlCkIwBIIQQ16HxLgDNkVzoRWOVfrmErafT2HU2naLScgx1tenX2o6QNg7YmRncfAe3KCIigu+//55ffvmFnJzaZyMwMzNj9OjRPPX4Y3SxL0V1dsO/XQTce0O7kWDlfsPjFJcXE54WzsFLBzmbfRYAY11jujp2paNdR9zM3TDUMayzegnRFDWna1J+fj7jx49n3bp1qFQqzp8/j4eHB88//zx2dna89dZbmg6xVs3pHDQmE348ys6z6QD08LJmmL8TIwKd5eFfCCFuQBIA9UAu9KKxKymrYO+5DDafSiUlrxgVKgJdLRnc1oE2TmZ1NsheSUkJf/75J8uWLWPbtm1c7yukdevWPDV+PGP7B9Aicy+kRlYtaBEI7R4Bh7Y3PVZmcSaHLh3i4KWDpBVVDQSmQoWjsSMeFh54mFe9Wpi0QFurblo9CNEUNKdr0rPPPsv58+f56quv6Ny5MxEREXh4eLBp0yZmz57NyZM1B4RrDJrTOWgsFEWh8zs7ySyoGpB27Qvd6OhiqeGohBCi8ZMEQD2QC71oKhRF4URSLltOpRKRnAuAi5URIW0c6OZpU2fdAwCSkpL4v//7P5YtW0ZsbGyt66hUKnr37s1jw/oy0vMKVrkRVQvsfKsSAc6dq80ecL06xefHczbrLHF5ccTlxamnGATQ09LD1cy1KiFg4YGvla+MHyCateZ0TXJycmLjxo106NABU1NTdQIgLi4Of39/CgoKNB1irZrTOWgsLuUW0+3dqm6iOloqTi0IwUBXkrtCCHEzGh8EUAihOSqVig4ulnRwsSQ5p4itp9PYcy6Db/fF8XPoBXp42dDf1x53G+Ob7+wmWrZsyZw5c3jttdfYv38/P/zwA6tWrao2b7eiKOzevZvdu3czWVeXwf17M6aLI/eXnsY4PQosXKHtw+DaA3Rr77KgUqnUv/ZflVOSo04GxOXGEZ8fz/nc83ABGT9AiCYkPz8fU1PTGuU5OTno6elpICKhKZH/JK0BfBxM5eFfCCHqgdwVC9GMOVsaMaGHO6M7t2R/TCY7o9LY8c/L3caEAb52ddIqQKVS0bNnT3r27Mlnn33G6tWr+eGHH9i/f3+19crKyli/ZQfrt4CxsREP9mjLmDbZDMqMR9fgK3DrAV4DwL7NTVsFWBpYEmgQSKB9IFA1kODFgovE5MRwJPUIx9KPcSz9GMY6xnRx7EK3Ft1wN3Ovs64QQoi60bNnT5YvX868efOAqu8TRVH44IMP6NOnj2aDEw0qIjlP/XdASwvNBSKEEM2YdAG4RdLUTzQHiqIQm1HAjqh0DsZmUVpegb6ONj28bOjna4eHjXGdPiAnJCTw66+/snLlSiIjI6+7nrWFKY90deXxjqZ087JEZeoAnv3Aq/8NZw+4kdrGD3AwcqBbi24EOwZjbWh9R/sVojFoTtekU6dO0b9/f4KCgti2bRsPP/wwp0+fJi0tjf3799OqVStNh1ir5nQOGosx34ZyMDYLgPdGtGNUZxcNRySEEE2DjAFQhxYvXszixYupqKggOztbLvSi2SgqLWf/+Ux2RqVzIbuqyb67jTGD2zrS3dManToecfn06dOsXLmSFStWEB8ff9313BytGdPFgbGdrPFrYVrVGsBrALh2B73bnwdaURTi8+I5eOkgh1MOU1heVVcfSx/a2LTB09wTd3N3DHTqbsYEIepbc3v4zMvLY+nSpURERFBQUECHDh2YNGkSTk5Omg7tuprbOdC0ykqFgAXbuHylHIDN03ri62im4aiEEKJpkARAPZALvWiuqloFFPL32TQOxGRxpbwCaxN9Hghwoo+PLfo6ddsHU1EUDh8+zMqVK/ntt99IS0u77rodvBwZ28mS0UGOtLAxq+oi0HoY2HjftItAbcory4nMiOTgpYNEZERQoVQAVTMLOJs642nuiZeFFx4WHtgb2Ut3AdFoNadrUmJiIi1btqz131tiYiIuLo3zV+DmdA4ag9iMAvp/uAcAA10tTs0PqfNEtBBCNFeSAKgHcqEX94KCK+VsPZXK5lMpFFwpx9xQl/v8nRjoa1+nswdcVV5ezq5du1i+fDlr167l8uXLta6nUqno264FYwOteLCjPdauvuBzH3j0Bh39Ozr2lYorxOfFE5sbq35dLvv3+Ma6xlUJAUsv/Kz9ZPwA0ag0p2uStrY2KSkp2NnZVSvPysrCzs6OiooKDUV2Y83pHDQGfxxPZvpvVbPEdHK1ZPXEbhqOSAghmg5JANQDudCLe0lJWQU7o9LZEHmJnKJSjPV0CGnrwOC2DpgZ6NbLMYuKili/fj3Lly9n8+bNlJeX17qetrYW/XxtGNHRjoe6emAfOAx8hoJ5i7s6vqIoZBRnEJMbo04IJF9OppJKAEx0TWhr01b9MtOTpqlCc5rTNUlLS4vU1NQaCYDExER8fX2rzSrSmDSnc9AYzP/rND8eTABgQg933hjmp9mAhBCiCZFpAIUQd8VAV5v7/B0Z6GfPvvMZ/HniEmuPJbMhMoWBvnbc5++ElXHdTs9lZGTEqFGjGDVqFFlZWaxatYpffvmFAwcOVFuvoqKS7afS2X4qnRd+OU1P7/2M7PQpDw/pR4seo6FlF9C6/dYKKpUKOyM77Izs6OZU9cvTlYorxOTGcCrjFCczTxKaEkpoSigqVLiaudLOph3tbNrhbu6O9h0cU4h72csvvwxU/dt78803MTL6d4yPiooKQkNDad++vYaia95KyytZcyyZxOwiXK2MGBHojK6Gm9tHXDMFoL+zueYCEUKIZk5aANwiyfSLe1lFpcKh2CzWnbhIck4ROlpaBHtaM7itA562JvV67Pj4eFauXMny5cs5c+bMDdcN9rRgZDdPRo56DJcuD4K15x2NFXA9WcVZnM46TWRGJGeyzlBSUQKAsY4xPlY+uJi54GLqgrOpM9YG1tJlQNSb5nBN6tu3LwB79uwhODgYPb1/k4p6enq4ubkxa9YsvL29NRXiDTXVc1BaXsm47w8TGp+tLuvqYc3PE4I0lgQoq6ik7bytXCmvanG1e1Yf3GyMNRKLEEI0RdIFoB401Qu9EHVJURTCL+TwV8QlzqVV9Zf3tjNlcFsHurhb1fuATVFRUaxZs4Y1a9Zw4sSJG67bp7UV4/r5MeKR0Zi1GXjHAwdeT3llObG5sZzKrGodkHg5sdpyQx1DWpq2VL+cTZ1xNnFGT7tuW06Ie1NzuiY99dRTfPrpp5iZNa1uNU31HKw8ksira0/WKH93eDtGB2lmwMVTF/MYtmQ/AOaGupyYO1ASqEIIcRukC4AQol6oVCo6uVnRyc2K2IwCtpxK5VBsFkv+Ps/PhnoM9LNngK895kb1M06Ar68vr7/+Oq+//joxMTGsXbuW1atXc/To0Rrr7j6bze6z+5n03UEe7ujAuH5+9L9vBDpevcG29V0nA3S0dPCx8sHHyocRrUZQXF7MxcsXSbqcpH4l5CdwLuecehsVKlqatiTANoAA2wDczWVgQSGWLVum6RDuKYnZRbWWX7hOeUOITM5T/+3vbC7fi0IIUY8kASCEuCOetiZM6uvF411d2RmVxvYzaawKT+KP4xcJ9rQmpI0DXnb11z3Ay8uLl19+mZdffpkLFy6wdu1a1qxZU2PMgOLSSlaEXmJF6CUcv9jHmC5OjOvfBv9ew8C1G9i1Aa27b7lgqGOIl6UXXpZe6jJFUUgvSie5IJnE/ESSLidxPuc86+PWsz5uPaa6prSzbUeAbQBtbdpiqGN413EIIcSNuFgZ1Vruep3yhhB5Tf//AGcLjcUhhBD3AukCcIuaalM/IRpKeUUlRxKy2Xoqleh/ugd42prQzdOGzm6W2JkZNEgcSUlJLF++nP/7v/8jKirquusFtDTjkc4ODOnkQfueg9Fy6wGOAaBdv3nRisoKYnJjiMiIICIjgpTCFAC0VFq0smylbh3gYOxQr3GIpk2uSZrXVM9BTPplBny0t1qZpZEuR+YM0NgYAIM/2cvZ1KrrxjdPBDKojXz/CSHE7ZAxAOpBU73QC6EJ8ZmFVd0D4rIoLa+aw9vdxpjOblYEuVvhbFn/vzQpikJ4eDg///wzK1asIDMz87rr2pvpE9LWhsHtnRkYMhibgEHg1BF06z9pkVGUQWRGJBEZEURlR1GhVH1eFvoWeJh7VL0sPHA1c5UWAkJNrkma11TPwZKd5/lw+7lqZYa6WpyYNwh9nYafzaS4tIK287dSUVl1O3r4tf7YN1DCWAghmgtJANSDpnqhF0KTSsoqiEzO40h8FuEXciguq3q4dbIwJOifZIC7jXG99/csKytjy5Yt/N///R9//fUXpaWl111XpYIgdwsG+zswuH9vOg8aibZbN9Cr/6RFSXkJZ7LOEJkRyfnc86QWpqJQ9RWtQoWTiRPu5u7qxEALkxYy/eA9Sq5JmtcUz4GiKAz8eC8x6QU1li1/pgvdvWwaPKawhGxGfnUIAAczA0Jf69/gMQghRFMngwAKIRoFA11tgtyrHvTLKio5dTGPownZHE3IYd2Ji6w7cRFrE326uFvR2c0KH3tTtLTqPhmgq6vL/fffz/33309OTg6rVq3i999/Z9++fTWSAYoCh+NyORyXy4J1Z7Ey/oGhAQ48FNKHkEcnYOLdvd66CRjoGNDRviMd7TsCUFRWxIX8C8TlxRGXF0d8Xjz7L+5n/8Wq0bL1tPRwN3fHy8ILb0tvPC08MdaVqbOEELWLSrmsfvjX0VLR09uGXdEZAOw6m66RBEDEfwYAFEIIUb8kASCEaBC62lp0cLGkg4slE3ooRKde5kh8FkcTcth0MoVNJ1MwN9Sls5sVXdyt8XU0rZdpBS0tLXnuued47rnnKCgoYPfu3WzZsoXNmzcTFxdXY/3swjJ+OZjELwd/Rv+t5Qxo58BDg/ty/5jnsW/To06nFvwvI10jfK198bX2VZfllOSoEwJxuVVJgeicaIj/t5WAl4UX3hbeeFt6Y2NoIyNqCyEA+DPiovrvXq1seahDC3UCYPe5DF7XQEzVBgBsaaGBCIQQ4t4iCQAhRIPT1lLh52SGn5MZT3ZzIzajkMPxWRyJz2ZHVBo7otIw0dch0LWq9UC7Fubo6dR9MsDExIRhw4YxbNgwFEUhJiZGnQzYtWsXJSUl1da/Ul7JxuOX2Hh8Oap3lxPcyo6HBvfjoXEv4N2xZ53HVxtLA0sCDQIJtA8EoLyynMTLiZzPOU9Mbgznc86zJ3kPe5L3AFVjCXhZeOFp4Ym3hTcuZi7oaMlXvxD3mspKhfUnLqnfP9jeiV7eNmipoFKBmPQCkrKLaNnAswFEJOWq/5YWAEIIUf/kLlAIoVEqlQovOxO87EwYE+RCUnYxof8kA/acS2fPuXQMdbXp4GJJVw9rOrhY1MtI1SqVCm9vb7y9vZkyZQrFxcXs3buXDRs2sG7dOpKTk6utryhwMDqdg9G/8vKnv+Lb0pKQ3t0Y+OBj9Br8ICYm9TcF4rV0tHTUYwKEEIKiKGQUZxCTE8P53POcyzlHWFoYYWlhVeurdHAzd8PLwkudGDDXl5tuIZq7sAs5XMqrSmoa6GoxwNceY30dOrhYEn4hB6hqBfBEV9cGiymvqIyErCL1e/8WFg12bCGEuFdJAkAI0WioVCpcrI1wsTbi0U4tuZRbzJH4bA7HZ3MwNpODsZmY6OsQ7GlDL28bvOxM6q15u6GhISEhIYSEhPDZZ59x/Phx1q1bx7p16zh58mSN9aOScoj6ZSOf/LIRXR0tgtu3ZuCQBxh430N06tQJbe2GGaxPpVJhZ2SHnZEd3Vp0A6CwrJDY3Fhic2OJyY0hLi+OmNwY9TY2hjZ4W3hXzTZg6oqzqTMGOjIKt2iavvnmG5YuXUpCQgIAbdq0Ye7cuQwZMgSAkpISZs6cya+//sqVK1cICQnhyy+/xM7OToNR17+/rmn+P9DPAWP9qlvAPq1s1QmAPdHpDZoAiLyYq/7b3cYYcyPdBju2EELcq2QWgFvUFEf7FaI5Sb9cwsGYLPaey+BSXjEAjuaG9PS2oYe3DXamDffAGhcXx59//sm6devYv38/lZWVN1zfwsyYfn37MnDwfQwcOBBPT88GirR2lUolFy9f5HzueeLy4jifc56M4gz1chVVSQQXUxdamrXExdQFF1MXzPXNZTyBRkKuSde3YcMGVCoVrVq1QlEUfv75Z9577z0iIiLw9fVl4sSJbNy4kR9//BFzc3MmT56Mrq4ue/fuva3jNKVzUFZRSdA7O8gpKgPgu3GdGOBnD8Cpi3kMW1I1sKihrjbH5w7EQLdhEpaf74ph8dZooKpLwqejOzTIcYUQormRaQDrQVO60AvRnCmKQmxGIfvOZ3AgJouCK1U3tL6OZvRqZUtXd2sM9RpuarzMzEw2bNjAli1b2LFjB1lZWTfdxtPdhUEhQwkZPJh+/fphamraAJHeWH5pPnG5cSRdTiLpchKJlxNJL0qvto6prikuZi64m7vjb+OPh4UHWqq6744hbk6uSbfHysqKjz/+mIceeghbW1tWrlzJiBEjADh79iy+vr4cPXqUTp06XXcf+fn55Ofnq9+npKQQFBTUJM7BrrPpPPXjUQDMDXU5OmeAelyVykqFoIU7ySy4AsDPE4Lo6W3bIHE9+39hbD+TBsAbw/yY0MO9QY4rhBDNjUwDKIRotq4dM+CJrq6cSMpl7/lMjl3IISolnx/2x9PVw5qBfvZ412MXgatsbGwYP34848ePp7KykhMnTrB9+3Z27NjBvn37uHLlSo1tYuMT+fKrr/jyq6/Q0dGmW+eOhNz3ACGDh9ChQwe0tBr+odpMz4z2du1pb9deXVZcXkzy5WQSLyeSlF+VFIjOjuZ01mk2xG3ARNcEf1t/AmwDaGPdBiPdhh08TIibqaioYNWqVRQVFdG1a1fCw8MpKytj0KBB6nVat26Ni4sLhw4dumEC4KOPPmLBggUNEXad+/PEv83/h7ZzrDaoqpaWij4+tqwOrxrnZNfZjAZLAFSbAUAGABRCiAYhCYCbWLx4MYsXL6aiokLToQgh/kNHW4tOblZ0crOi4Eo5h2Kz2HMunX3nM9h3PgNXK2MG+tnTw9umQZq0amlp0bFjRzp27Mjs2bMpLi5m//796oTA8ePHa2xTXl7B3kNH2XvoKHNefwNbSzMG9u1JyP0jGDz0Po32SzbUMcTbsmo6wasqKiuIy4sjIiOCiIwIDl46yMFLB9FSadHKshX+tv60t22PvZG9dBcQGnPy5EmCg4MpKSnBxMSEdevW4ePjQ3h4OIaGhjVa3djb25OamnrDfc6YMYNnnnlG/f5qC4DGrri0gm3//MoOVU3t/+vaBMDuc+nMxa/e40rLLyEtvypBqq2loo2TJACEEKIhSALgJl566SVeeukldbMKIUTjZKKvw0A/ewb62ZOQWcj2M2nsj8nku/1xLD98gZ7etgz0s2/QKa4MDQ0ZOHAgAwcOBCA9PZ0dO3awdetWtm3bVusDR0ZOPivWbmTF2o0AdGrfliHDHmLofffRuXPnBhtM8Hq0tbTVSYGRrUaSWZxJZEYkERkRRGVFcTb7LL9H/46dkR1eFl7YGdlhY2iDnaEdtka2mOmZSWJA1DsfHx9OnDhBXl4eq1evZty4cezbt++u9mlmZoaZmVkdRdhwdkSlUVRa9SOGg5kBQW5WNdbp6WWrng4wLqOQxKwiXKzr97vy2un/WtmbNmjXLSGEuJdJAkAI0ey42RjzbC8PxnZ1Yd/5TLafSWPbmVS2nUmltYMZA/3sCXK3qpfpBG/Ezs6OMWPGMGbMGBRFITIykq1bt7J161b2799PaWlpjW3CTpwi7MQp3nr7baytrAgZPJghQ4YQEhKCrW3DNNO9ERtDG/q59KOfSz+uVFwhKiuqWuuA/9LT0sPWyBZbQ1v1fz0sPHAzc5PxBESd0dPTw8vLC4DAwECOHj3KZ599xogRIyguLuby5cvVWgGkpaXh4OCgqXDr1Z8nLqn/vj/AES2tmgk4cyNdAl0tOZpwdTrAdMYFu9VrXJHJeeq/pfm/EEI0HEkACCGaLSM9HULaODDIz56zqZfZfiaNI/HZnE3Nx8xAly4e1gS5WeHraIpOAycDVCoVAQEBBAQE8PLLL1NYWMiePXvYunUrW7Zs4dy5czW2ycrOZsWKFaxYsQKVSkWnTp0YOHAgvXr1olu3bhofTFBfW189joCiKBSVF5FelE5GUQbpxelkFmWSXlz1PiIjAoV/x6A11jXGz9qPttZtaWvTFksDSw3WRDQ3iqJw5coVAgMD0dXVZfv27QwfPhyA6OhoEhMTCQ4O1nCUdS+3qJQ95/4dzPPB9i2uu24fH7t/EwDRGfWeAIi4pv+/v7NFvR5LCCHEvyQBIIRo9lQqFb6OZvg6mpFXVMau6HT+PpvO9jOpbD+Tiom+Dh1cLOnsZkVAS3P0dRq+KaqxsTFDhw5l6NChQNVUg5s3b2bTpk3s2rWL4uLiausrisLRo0c5evQoCxcuREtLiw4dOtCrVy969uxJjx49NNpCQKVSYaxrjLu5O+7mNUf2Lq8sJ6s4i7SiNM5mn+VU5imOph7laGrVSOVOxk60talKBrSybIWetl5DV0E0UXPmzGHQoEG4urpSUFDAypUr2b17N6+99hrm5uZMmDCB6dOnY2lpiZmZGVOmTKFnz543HACwqdp8KpWyiqpEm4etMW2crt+FoY+PrXpKvoOxmZSUVdTb2CmKolRrAeAvLQCEEKLBSAJACHFPMTfS5aEOLXiwvROJ2UUcic/maEK2euBAPR1t2jub08nNio6ulpjoa+Zr0sPDg0mTJjFp0iSKi4vZu3cvmzZtYvOmjZyPia2xfmVlJeHh4YSHh/Pxxx8D4OvrS69evejVqxd9+/bF0dGxoatxXTpaOtgb22NvbI+/rT+P+jxKbkkuZ7LOcDLzJGeyzrDtwja2XdiGrpYurSxb4WHugZu5G65mrljqW8pYAqJWmZmZPPnkk6SkpGBubo6/vz9btmyhf//+AHz88cdoaWkxYsQIrly5wuDBg/niiy80HHX9uHb0/wcDWtzw34yfoxl2pvqkX75CSVklh+Oz6d2qfpKIF7KKyCuumsJVX0cLHwfNT4UqhBD3CpWiKMrNVxMy57IQzVtafglHE7I5Ep/N+bQCFBS0tVT4OZoR6GpJBxdL7M0MNB0mADExMWzevJltmzew/8BBcvMLbmk7f39/Bg0aREhICD169MDAoHHUpzaKopB4OZGTmSc5nXmamNwYKpR/Z2Mx1TXFzdwNN7OqhICbuds9lRSQa5LmNfZzkJpXQvC7O7l6l7drVh/cbYxvuM1LqyJY9c9sAOO7uTH/gTb1EtufJy4y7dcTAHR0sWDtC93r5ThCCHGvuJ1rkrQAEEIIwN7MgGH+TgzzdyK3qJSwhByOJmRz+lI+Jy/m8ePBBJwsDOnoYkkHFwt87Bt+3ICrvLy8mDJlClOmTKGyspJTp06xd+9e9u3bx949u0lNS691u8jISCIjI/nggw8wNDSkd+/e6oSAr69vo3p4VqlUuJq54mrmyjCPYZRVlJFUkERCXgIX8i9wIf8Cp7NOczLzpHqbq0mBVpat8LH0wc3cDR0tucyJ5qG0vJI1x5JJzC7C1cqIEYHONxzIdEPkJfXDv7+z+U0f/gH6trZTJwD2nMuok7hrU735v0W9HUcIIURNcmckhBD/YWGkxwA/ewb42VNcWkFkci7HEnM5npjDhshLbIi8hJGeDv7O5nR0saS9iwVmBroaiVVLSwt/f3/8/f2ZPHkyiqIQExNTlQz4JykQFxdXY7vi4mK2bNnCli1bAHB2dmbgwIH07NmTbt260apVq0aVENDV1sXD3AMPcw912dWkwIW8qoRAQn5CtaSAnpYeHhYe+Fj64GPlg4e5h4wlIJqk0vJKHly6n6jUy+qydScu8fOEoOsmAa4d/f+BAKdbOk53Lxu0tVRUVCrEZxaSkFmI2y0kDm7XtVMABrSU/v9CCNGQJAEghBA3YKinTRcPa7p4WKMoCrEZhRxLzOF4Yg6hcVmExmWhQoW3vQkdXSwJdLXE2dJQYw/PKpUKb29vvL29efrppwG4cOEC27ZtY+vWrezYvo28/Ms1tktOTmbZsmUsW7YMAGtra4KDg+nWrRvdunWjc+fOGBnV77zgt6u2pMCViivE5sYSnR3NuZxzxOTEcDb7LMSCtkobD3MPWlm2wtvSGzdzN8z0mt687uLes+ZYcrWHf4DQuCy+3RvHC329aqwfm1HAyYtVv7KrVHD/LSYAzA2rpgM8Ep8NwO7odMbb1BzE879up3VCeUUlpy5dOwWgxS3FJoQQom5IAkAIIW6RSqXCy84ELzsTHu3UkpzCUo4n5RB+IYeTF/M5l3aZX48mYmdqQEcXCwJdNTPF4H+5urry7LPP8uyzz1JeXs7Ro0fZtnUrWzet53D4cSoraw4Fk5WVxYYNG9iwYQMAOjo6tG/fnuDgYLp3707//v2xsbFp6KrclL62Pn7WfvhZ+wFVrQTi8uI4l3OOcznnOJ9znvO55yG+an0rAyv1OALu5u64mrliqicDkonGJSolv9byD7ZFk11YyqS+Xlga/9u65a9rfv0P9rC+rfFL+vjY/psAOJfB+O43TgCUllcy4suD6oQD3Lh1wvn0AkrKKgEwNdDBzbruWxgIIZqmTp06MWzYMObPn6/pUNRUKhXr169n2LBhmg6lzkgCQAgh7pClsR79WtvTr7U9V8orOHMpn/ALORxLzGHL6VS2nE7FUFebgJYW6rEDTDXUVeAqHR0dgoODCQ4OZt78+eTm5rJz5062rl/L3r17iI6/WOt25eXlhIWFERYWxpIlS1CpVAQGBjJo0CAGDRpEcHAwenqNr3m9rrYuPlZVXQCgavrBC/kXiMmNUY8lcDz9OMfSj6m3uZoUcDN3w92sahpDI93G1fpB3FsKr5TXWl6pwHf74/ktLIlJfb0Y380NfR0t1kf8mwB4sP2t/fp/VV8fO97fUjUd4KHYrJtOB/jZzvPVHv6hqnXCL4cu8FSPmsmDyORc9d/+zuZoaTWerkZCNAcJCQm4u7tz8uRJ2rZtW+/H69OnD506deKDDz6o92PdyPz589mwYQNhYWEajaMpkASAEELUAX0dbTq4VM0WoCgKCVlFHLuQQ9iF6l0FfBxMad/Sgg4uFrhYGWm8n72FhQUjRoxgxIgRQNUUaqGHDnFw11YO7t/LkcizFF8pq7GdoijqhMDChQsxMTGhb9++6kEFvby8NF632uho6eBp4Ymnhae6rLi8mMT8RBLyE66bFHA0dsTD3ANPC088zD1oYdICba36mSNdiP8qulJRo8xQV4vif35Jv1xSzrubz/J/BxN4uEML4jILAdBWQf/W9rd1rNYOpjiYGZCaX8KV8koOxWXR18eu1nUjknL5Zm/NaUkBFm+LxtnKiIF+1Y8fIQMAirtwu4Nh1vnxS0sbZbL7TjSnuojbo9l2qUII0QypVCrcbYwZEejMouHt+HJsIM/29KCDiwVxmYX8ejSR2WsieWH5Mb7ZG8uR+GyKS2ve4GuCjY0Nw+6/n4UfLWX3kUjyLhcSFhbGZ4vfYfSwvrS0s6h1u4KCAtavX8+UKVNo1aoVHh4ejB8/ng8++IDNmzeTmJhIY5111lDHEB8rH0LcQnjO/zne6fEOS/svZXbn2Tzq8yid7DtxpeIKBy4d4P/O/B/zD81n0s5JvHvkXX6P/p3wtHAKSm9tKkYhbld5RSUHYjPV7x/u4MS7w9tx7I2BvDeiHfZm+upll/JK+Hz3vw/kFQpMXnmcsorKWz6eSqWidytb9fvdZ2ufVST8Qg6Pf3eY0ora/10XlVbw7P+FMe3X42QXlqrLqw0AKAmAe5aiKFwpr7it1+WSMh7/LpRX157ky92xvLL2JI9/d5iCK2W3va9bvR716dOHadOmMXXqVKytrXn44YcBOHXqFIMHD8bY2BhHR0eeeeYZ8vL+TW5VVlaycOFCPDw80NfXx83NjU8//VS9fNeuXXTq1Al9fX1atGjBggULqKz899+pm5sb7777LuPGjcPExARPT0/Wrl2rXp6Tk8OYMWOwsbHB0NCQ1q1bs2rVKgDc3ata3rRr1w6VSkWfPn0AGD9+PCNHjuTNN9/E0dGRjh07AlX/5q9294Oq67lKpWL37t3qspMnTzJkyBBMTU0xMzOjb9++XLp0ifHjx7Nnzx4+/PBDVCoVKpWKhISEW/qMCgoKePzxxzE2NqZFixZ88cUXNz0fu3btUo9JZGlpSa9evcjIyODHH39kwYIFhIeHq+P48ccfAVi8eDFt27bFyMgIFxcXZsyYQUlJSbX9rlu3jsDAQAwMDLCzs2PcuHHXjeGll17CxcWFc+fO3TTexkpaAAghRD2zNNajv689/X2rugqcTbnM8cQcjifl8vfZdP4+m46OlhY+DqZ0cLGgfUsLWlhobiDBa+nq6hIYGEhgYCBTZr2mnmVg21+r2LrxT3aFnqCguLTGdgkJCeqbgKtMTU3x8/OjTZs21V4tWrRoFHW91tWkwNWuAwC5JbnE5sUSmxtLfF488XnxnMupugFQocLD3IMAuwACbAJwNnVudHUSTdOJpFzyS6q6AJgZ6LB4ZIB6XJFRnV14IKAFPxyI58vdsRTU0lUgNC6LNeHJjA5yueVj9m1ty29hSUDVOAD/dTQhm/E/HKHwn8SllqqqO8JV2qqq5ANUzUZwICaTNx9sS7/WdkRfM5ihzABw7yqtqMTn9S13vZ/D8dm0nbfttreLfnsw+jq31orrhx9+YMqUKRw6dAiA3Nxc+vXrx//+9z8+/fRTCgoKmD59OuPHj+ePP/4A4M033+Tzzz/nk08+oWvXriQnJ3PhwgWgatDdoUOH8txzz/HLL79w8uRJnn32WczNzXnxxRfVx/3www9ZtGgRc+fO5csvv2TcuHH07t0ba2tr3njjDaKiotiyZQvW1tZER0ejpVX1vXDkyBGCgoLYvXs3Pj4+1X7l37p1K2ZmZuzcufOWP6usrCz69u3LgAED2LNnD0ZGRuzbt4/y8nI+/fRTzp07R/v27Zk7dy4Atra2t/QZzZw5kwMHDrB+/XpsbGyYNWsW0dHR1+1rX15ezsMPP8xzzz3Hb7/9RnFxsfqcjBo1ilOnTrFjxw717Ebm5lXfLzo6OixduhQ3NzfOnTvH//73PwwMDFi4cCEAu3fv5pFHHmHevHksX76c4uLiWj+fyspKnn/+efbs2cP+/ftxcbn179TGRhIAQgjRgPR1qsYECGhpwXggJa+YE4m5HE/K5cylfE5fyuOX0AvY/jOQYAcXS/wczdDTaRwNttSzDMx8jUkzX6O0tJTQgwfYuu5Xtm3fQXhUHNf7YeXy5cscPnyYw4cPVyt3dHRkwIABDBgwgP79+9OiRYsGqMntszCwINAgkED7QAAqKiu4VHCJ87nnOZV5ijPZZ4jNi2Xt+bVY6lvib+tPgG0AftZ+Mv2guGO7o/99AO/pbVtjUFFDPW0m9fVidOeWjF92tEZ/fIAL2UW3dczuXjboaKkor1S4kFVEfGYh7v9MBxgal8XTPx6l6J+HfxN9Hb5/MpD4zCIu/NMsu4eXDfP+Os3Of1oPZBaU8sLyY7RvaU75P5kCE30drI3l34Vo/Fq3bq1+WAR4++236dy5M2+++aa67JtvvsHX15f09HTMzMx47733+Prrrxk7diwAnp7/djv74osv8PDw4JNPPkGlUtG6dWvi4+NZvHhxtQTA/fffzzPPPKM+5ieffMLRo0cZPHgwiYmJdOjQgU6dOgH//uoPVQ/gUDWbj4ODQ7W6mJmZ8fXXX6Ore+vjES1duhQrKyuWL1+Otra2+jO5Sk9PDyMjo2rHWrp06Q0/I0NDQ5YtW8Zvv/1Gv379APjpp59wdXW9bhz5+fnk5eVx33334eFRNftPmzZt1MtNTEzQ0dGpUefp06er/3Zzc2Pu3Lm8/fbb6nO6YMECnnjiCV5//XX1eh06dKi2j7KyMh577DHOnj3Lvn37sLe/va5VjY0kAIQQQoMczQ1xbGfIkHaOlJRVcPpSHsf/SQhsPZ3K1tOp6Olo066F2T8DCVpi1YhumvX09OjVpy+9+vTlHarGENixeQM7Nq4hIvIUZ+IuUlTLGALXSklJ4eeff+bnn38Gqm4sriYE+vTpo87iNzbaWtq0NGtJS7OW9HPpR1lFGdE50URkRBCREcGe5D3sSd6DrpYura1a42/rT3vb9lgbWms6dNGE7LnmF/jePrbXXc/aRJ8xXVx4de3JGstcrW5vEEtTA106uVkSGlc1G8Cus+m493DnQEwmE346Wm0U/58ndKF9Swu6eFTfx3dPduLPE5eYv/40uUVV3wEnkq5p/nulnHE/HL3ubAFCNBZXH7KvioiIYPv27ZiYmNRYNzY2FhMTE0pKSujbt2+t+4uKiqJbt27VWol1796d2bNnk5+fj5lZ1fS07dq1Uy83NDTEwsKC9PSqpNpzzz3HI488wvHjxwkJCWHEiBF07tz5pnXx9/e/rYd/gMjISHr27Kl++L8VN/uMjIyMKCsro0uXLupyR0fHGyYArKysePzxxxk8eDADBw5k0KBBPProo9jZ1T5GyVU7duxg4cKFnD17lvz8fCoqKqio+LfbZWRkpHra5OuZMmUKpqamHDx4EEtLyxuu2xRIAkAIIRoJA11tAl2tCHS1QlEUkrKLOZZYNavAsQu5hF/IAcDN2pgOLlUzC3jamjSqUbRtbGwY/cR4Rj8xHqhqMnchIYHTYQc4HX6A06ciOX0unqjEjOuOe3D27FnOnj3L0qVL0dLSIigoiAEDBtC9e3cCAwPVv240NrraurS1aUtbm7aMaT2GlMIUIjMiiciI4HTWaU5mnuRy6WUe8npI06GKJiKz4Eq1X/Sv7ZtfmxEdnfnz+EVC/5nGD6CrhzUjAp1v+9h9fOzUCYDd5zLwtDPhuf8L40p51cO/uaEuv0zoQjvn2hN0KpWKhzq0oJuXNXPXnWbL6dQa69xJ9wTRPOhpaxH99uDb2qa0vJIJPx7lSEKOuqyLuxXfj+9020kkvdtY39i4+lSVBQUFPPTQQ9VaBVzVokULYmJibiuW6/nvg7pKpVKPEzBs2DASEhLYuHEj27Zto0ePHsydO5c5c+bccJ//rcvV/V47JkJZ2Y2T9rfiZp/Rnfaf//nnn3nxxRfZvHkzP/30E6+//joHDhyo1hLgWgkJCQwbNozJkyezaNEiLC0t2bZtG1OmTLmt44aEhLBixQp27drF8OHD7yj2xkQSAEII0QipVCpcrI1wsTbioQ4tyC8pIyIpl+OJuUQk5fLH8Yv8cfwipga66lkFApwtMNZvXF/rWlpauHt44O7hwbBHn1CXV5SXk3DqKCcObmfX3zvZcSiC6Es1my5XVlYSGhpKaGiouszFxYVOnTqpX4GBgVhZWTVIfW6VSqXCycQJJxMnBrsPpqisiNNZp2lp2lLToYkmZO81v/77Opphb2Zww/X1dLT4+ZkurAlPVjfHv9NR0vv42PLu5rMA7D+fwYHzmVT885BgaaTLL890oY3TzVvn2Jka8OXjHXn+53C2nUmrsfx2uyeI5kGlUt1yH/yr9HW0Wf5s1zr5//tudOjQgT///BN3d/dafxX39vbG0NCQXbt21TqYnK+vL3/++SeKoqhbARw4cIAWLVqof/2/Ffb29jz99NM8/fTT6i4Hc+bMUff5v/ZX7huxtbUlNfXfBF1ERES15f7+/ixfvpyKiopa66unp1fjWDf7jDw8PNDV1eXw4cPqgRVTU1PV4yTcyNVxiebMmUObNm1Ys2YNbdq0qTWO8PBwgGpTFP7www816rdr1y6eeOIJrufhhx9m0KBBjB07lt9++40HHnjgpnE2Zo3rTlEIIUStzAx06eltS09vWyoqFc6lXeZYYg7HE3PZdz6Dfecz0FKpaGVvqm4d4GzZOAYSrI22jg6e7YPxbB/MiBeqBg5Kio5g57rl7Ni5k51Ho0jNLa5128TERBITE6uNiOzh4aFOCAQHB9OpUycMDG78sNSQjHSN6Oxw8+aZQlyrWvP/m/z6f5Wutlad/KLubm2MnraK0grlnwH+qh7+rYx0WfFcV1o73PqDikqlom9ru1oTALfbPUHc2+rq/++7MWnSJL755hvGjh3LrFmzsLS0JDo6mnXr1vHNN99gYGDA7NmzmTlzJjo6OnTt2pWUlBTi4+N5/PHHeeGFF/j444958cUXeeGFFzh58iQLFy5k/vz5txzDvHnzCAwMpE2bNhQWFrJ161Z1v3w7OzsMDQ3ZsmULjo6O6Ovr37ArXZ8+fVi6dCldunShoKCgRiuCyZMns2TJEh5//HFeeuklTExM2L9/PwMGDMDFxQU3NzdCQ0O5cOECxsbGWFlZ3fQzMjU15cknn1Qvs7Ky4uWXX0ZfX/86UUJ8fDzffPMNDzzwAC1atCAyMpKkpCR1vd3c3IiNjSUiIoIWLVpgamqKl5cXV65cYenSpQwdOpTdu3erZwe49rMcOHAgnp6ejBw5kitXrrBz585qYwdA1UCD5eXljB49mtWrVzN06NBbPl+NjXS6EkKIJkZbS4Wvoxlju7jywSMBfPZYB57u7o6/swWxGQWsPJLIS6sjmLLyON/vj+dYYg5XyhvHNIM30tIngPGz3+eXbeFcyirgVOguPnnteYYF+2JmeOM+i3Fxcfz++++8/PLL9OzZE3Nzc7p168ZLL73En3/+SUZGzZHMhWjMKiqVai0A+tyg/399WHv8Yq1T/D3Zze22Hv6vGtHRma7u1Vvq3Gn3BCE0qUWLFuzfv5+SkhIGDBhAu3bteOmll6p1T3v99deZOnUqr776Kr6+vjzxxBPk5FR1XXB2dmbTpk0cOHAAf39/pk2bxosvvsjUqVNvOQZdXV1mz55N27Zt6devH9bW1nz33XdA1aj3n332GZ9//jmOjo48+OCDN9zXhx9+iK2tLcHBwTz//PM1EhHW1tb8/fffZGZm0qNHDzp37syKFSvUXRRmzZoFVLVssLW1JTEx8ZY+o48++oguXbowdOhQBg8ezLBhw/Dx8eF6jIyMiIqKYvjw4Xh7ezNt2jRef/11Hn30UQBGjBjBoEGD6NOnD7a2tqxcuZKAgAA++ugjFi5cSNu2bVm7di1vv/12tf326dOHX3/9ld9//x1/f38GDhxIZGRkrTGMHTuWL7/8kpEjR7Jt2+3PPtFYqJTGOjFzI5OcnEzLli1JSkrC2VkuVkKIxulKeQVnLuVzLDGX44k5ZBZcAap+NfFzNKN9Swvau1jgYGbQaFsH1KayspKYk2GE7d1K2OFDhJ88Q3j0RQprmfbselq1akX37t3p3r073bp1w8fHRz1tUlMj1yTNq+9zcCIpl4c+PwBUjZh/fO7ABm3q/N6Ws3y5O7ZG+cQ+nswe3LqWLW6urKJS4823hRCiObqda5J0ARBCiGZEX0ebDv/MFqAobiTnFHM8qWrcgFOX8ohIzuWnQ1X9cq8mA9o4md12X8yGpqWlRauAIFoFBDHmn7F7KioqOBf5T1LgSChhEac5du4iJWW1t3Y4d+4c586dY9myZUDVYEjt27enQ4cOdOzYkQ4dOuDn51dtzmQhNGV3dLr67+5e1g3+oOxynab5d9NkvzE03xZCiHudJACEEKKZUqlUtLQyoqWVEQ8EOFFcWsHJi3lEJOVyIimXbWdS2XYmVd06IKClBe1amDfqsQOupa2tjW+HLvh26MLVoXtKS0s5dmgvB3Zu5MCBA+w/doaM3MJaty8sLOTAgQMcOHBAXaanp0fbtm3VCYHAwED8/f0xNDRsgBoJ8a/q/f9vPM1VfajLGQWEEEI0HpIAEEKIe4ShnjZB7lYEuf87zeCJ5FxOJP7bOgCqpvdq62RO2xbmtGlhhp1p4xlM72b09PTo2nsAXXsPYCagKAoxMTEc2LWNA7u3cyA0jKj4i9fdvrS0lGPHjnHs2DF1mY6ODm3btq0280C7du2kpYCoNzmFpZxIylW/793A/f+hbmcUEEII0XjIGAA3sXjxYhYvXkxFRQXZ2dnS31II0SwVl1Zw+lIepy7mcfJiPhdz/52ay87UgHb/JAPaOJljfpMB+Rq7rKwswsPDOX7kIMeOHOR45CnOX0i5rX3o6enh7++vTgh069aN1q1bN1jLCRkDQPPq8xz8FXGJqSuPA+BtZ8L2Gb3rdP9CCCGal9u5JkkC4BbJzZYQ4l6SU1jK6Uv5nLqUx8mLeWT9M5ggVPUN9nM0w9fRjNaOZk0+IQCQn59PREQEx46EcvzIAY6dOMGZ2CQqKipveR8tW7Zk8ODBDB48mP79+99w2qW7JdckzavPczDz9wjWHEsG4Jke7rw+zK9O9y+EEKJ5kUEAhRBC3BVLYz16eNvQw9sGRVFIy7/CqYt5nLqUx5lL+Ww5ncqW06kAOFsa4etoht8/L3OjppcQMDMzo2fPnvTs2RN4CYDi4mIiIyMJO3qEsIN7CQsP50xMApWVtefNk5KS+Pbbb/n222/R1tYmODhYnRDo0KFDk51xQDSsykqlWv//Pj4N3/9fCCFE8yUtAG6R/NoihBBVFEXhYm4xZy7lcyYln6iUfPKKy9TLnSwM8XM0w8vOBBcrI1pYGjb6WQZuVWFhISdOnCAsLIywwwcJO3qE6NgL3OxSamtrS0hICCEhIQwaNAg7u7t7qJNrkubV1zk4dTGPYUv2A2Coq82JeQObzb8fIYQQ9UNaAAghhKg3KpUKZ0sjnC2NGNTGAUVRSMkrISolX50U2BGVxo6otKr1UeFobkBLKyNcrIxwsa76r52pfpOYbeBaxsbGdO/ene7duwPTAMjJyWHnzp1s2fgXWzZv5mJaZo3tMjIy+OWXX/jll1+YMWMGH374YQNHfu9YtGgRa9eu5ezZsxgaGtKjRw/ee+89vL291euUlJQwc+ZMfv31V65cuUJISAhffvnlXSdm6sK1v/5387SWh38hhBB1ShIAQggh7opKpcLJwhAnC0P6+9qruwzEZxaSlF1E4j+vw/FZHI7PUm+nr6ONs6UhPg6mtHEyw8/RHEO9pvewY2lpyciRIxk5ciSKonD69Gm2bt7Ilr/WsPfwMUrLKqqtHxISoqFI7w179uxh0qRJdO7cmfLycl577TUGDRrEmTNn1NM5Tp8+nY0bN7Jq1SrMzc2ZPHkyI0eOZO/evRqOHvZEXzP9nwZG/xdCCNG8SReAWyTNLYUQ4u4Ul1aQnPNvQiAxu4ik7CIKrpQDoKVS4WFrrJ6C0NvepMn/+llYWMieXbvYsm4lW7btJDkzj+zsHAwM7m5qRbkm3bqMjAzs7Ow4cOAA3bp1Iy8vD1tbW1auXMmIESMAOHv2LL6+vhw9epROnTrVup/8/Hzy8/PV71NSUggKCqrTc5BXXEbHt7ZT8c84E3tf6ouLtVGd7FsIoXkqlYr169czbNiwejtGQUEBpqam7Nq1iz59+tTbce5VCQkJuLu7c/LkSdq2bavpcNSkC4AQQohGx1BPG297U7ztTdVliqKQlF3MyYt5nL6UR1RKPjHpBaw7cRFdbS1a2Ve1Dmjbwhx3G+MmNwe5sbExQ4cNY+g/N3tpaWl3/fAvbk9eXh4AVlZWAISHh1NWVsagQYPU67Ru3RoXFxcOHTp03QTARx99xIIFC+o11oMxmeqHf3cbY3n4F0LD+vTpQ6dOnfjggw/qZH8pKSlYWlrWyb7uhpubG7NmzWLy5MmaDgXQ/EP1jz/+yKxZs8jMrNmF779atmxJSkoKNjY2DRBZ/ZAEgBBCCI1RqVRVYwJYG3GfvyMVlQpxGQWcvpTPyYt5nEu7zOlLefweloSOlhZuNkZ42ZrgbW+Kl51JkxtHwN7eXtMh3FMURWH69On07t2b1q1bA5CamoqhoSGmpqbV1rW3tyc1NfW6+5oxYwbPPPOM+v3VFgB1afe1zf9bSfN/IZoCRVGoqKhAR+fmj1UODg4NEFHDKSsrQ1e36c38c6eu1repn8em9VOKEEKIZk1bS4W3vSkPdWjBG8P8+P7Jzrx+nx/DOzrj52TGpdwStpxOZcnf55n263Ge+zmcdzefZU14MpHJuRT+051ACIDJkydz6tQpVqxYcdf7MjMzw9nZWf1ydHSsgwj/pSjVp/+T/v9CaNb48ePZs2cPH374ISqVCpVKRUJCArt370alUrFlyxY6dOiAnp4ex48f5/z58zzwwAPY29tjampKcHAw+/fvr7ZPlUrFhg0bgKpfvVUqFX/88Qc9e/bEyMiILl26cObMmWrbrFu3jvbt22NgYICXlxfvv/8+lZWV6uXR0dH07NkTAwMD2rVrx759+25Yrz59+nDhwgWmTJmirhdUdZcaPXo0LVq0wMjIiPbt2/Pnn39W29bNzY2FCxfy+OOPY2pqyosvvgjAN998g7OzM8bGxowePZqFCxfi5uZWbdtvv/0WHx8fDAwM8PPzY9myZepl7u7uALRr1w6VSnXdrgtXP/utW7fi7++PoaEhQ4YMITc3l99//x1PT08sLCx44YUXqKj4d/ydn376icDAQExMTHB0dGT8+PHk5OSo9/nUU0+RlZWl/jzmz59/3fpePW+nTp1S7//kyZMMGTIEU1NTzMzM6Nu3L5cuXQKgsrJS/XkYGRnRsWNHNm7cqN42JyeHMWPGYGNjg6GhIa1bt2bVqlU3PId3S1oACCGEaLT0dLRo26JqTACoeki6lFfC+bTLxKQXEJtRQGRyLieSqi7kKlS0tKqahtDX0YzWjmaYG947v06If02ZMoW//vqLvXv34uTkpC53cHCguLiYy5cvV2sFkJaWptFfdc6lFZCaXwKAvo4WwR7WGotFiIZia1t7oqtjx45s3boVgB07dvDYY4/Vut5LL73Eyy+/DMBrr73Gt99+W+t6W7ZsITAw8LZi+/TTTzl37hzt27dn7ty56ngTEhIAePXVV/nwww9xcXHBxsaGuLg4hg0bxsKFC9HT0+Prr7/mvvvuIzY29obNxd944w0++ugjXFxcmDhxIhMmTODQoUMA7Nu3j/Hjx7NkyRK6d+9OdHQ0zz77LPr6+kybNo3KykoefvhhWrZsyZEjR8jMzGTq1Kk3rNfatWsJCAjghRde4KmnnlKXFxcXExQUxCuvvIKpqSl//PEHI0eOJDIyEl9fX/V677//PvPnz2fBggWoVCoOHDjAxIkT+fDDDxk6dCibNm1iwYIFmJubq7dZvnw5CxYsYOnSpQQEBHD06FGeeeYZrKysePDBBzly5AhBQUHs3r0bHx8f9PT0bliHN998k6+//hodHR1GjBjBiBEjMDU15c8//yQpKYnhw4fTvXt3xo4dC1T9cv/OO+/QqlUrUlJSmDp1KpMmTWLFihV069aNTz75hDfffJPTp08DYGJict36/ldWVhZ9+/ZlwIAB7NmzByMjI/bt20d5edUPEosWLWLFihV8++23eHp6smPHDoYPH05oaCgdOnTgjTfeICoqii1btmBtbU10dDRaWvX8G70ibklSUpICKElJSZoORQghxDVKysqVqJQ8ZX3EReXDrWeVZ346qoz6+qD6NeO3E8p3++KUAzEZSk7hFU2HWyfkmnR9lZWVyqRJkxQnJyfl3LlzNZbn5uYqurq6ypo1a9RlZ8+eVQDl6NGjt3ycuj4HX+2OUVxnb1BcZ29Qnvj+cJ3sU4jGzsbGptbXoEGD1Ots3779uuu999576vVeffXV664XFhZ2R/H17t1bmTlzZrWyXbt2KYCyYcOGm27v6uqq/Pzzz+r3gLJ+/XpFURQlPj5eAZSffvpJvXzr1q0KoBQXFyuKoij9+/dX3n///Wr7/PLLLxVfX19FURRly5Ytiq6urpKamqpevmrVKgVQdu3adcO4lixZctP4e/furbz11lvVths5cmS1dUaNGqU8+OCD1coefPBBxdXVVf3e09NT+f3336utM3v2bGXIkCGKovz7WZw8efKG8Vz97Hfv3q0umzNnjqKlpaVkZmaqy+677z5lwoQJN9yPnp6eUlFRoSiKoixbtkyxtrausV5t9f1vrPPnz1e8vb2V8vLyGtuXlJQoRkZGypEjR6qVjxo1Spk4caKiKIpy//33K0899dQN630rbueaJC0AhBBCNGn6Otq0djCjtYMZ+Fe1EkjOKSYqJZ8zKflEpeSz/Uwq289U9e92NK+aetDN2hhXayNcrY0w0pPLYXNx9VedP//8E1NTU3W/fnNzcwwNDTE3N2fChAlMnz4dS0tLzMzMmDJlCj179rzuAIANoVrzf+n/L+4RGRkZN11nwIABt7TewoULWbhwYV2EdUv++31RUFDAvHnz2LhxI6mpqZSXl1NcXExiYuIN99OuXTv131e7FqWnp+Pi4kJERAQHDhyoNgBpRUWFugvA2bNncXNzqza+THBw8B3Vp6KignfeeYdVq1Zx8eJFSktLKSkpoVWrVjesd3R0NI888ki1sqCgIE6cOAFUzYYTGxvLk08+Wa3FQVlZWY1uArfK399f/be9vT0ODg5YW1tXK0tPT1e/DwsLY/78+URGRpKTk0NFRQWlpaWkpqZWayFWm5tdFyIjI+nZsyfa2jVnLYqJiaGoqIi+fftWKy8tLVWXPffcczzyyCMcP36ckJAQRowYQefOnW94zLsldzxCCCGaFZVKRUsrI1paGTGojQOKopCSV0LUP8mAqJTL7I5Or7aNnakBbtZGuFob42ZjhIuVMTYmek1qgEFR5csvvwSo0Yd02bJljB8/HoCPP/4YLS0tRowYwZUrVxg8eDBffPFFA0f6r4Ir5RxNyFa/7yP9/4Vo9IyNjau9nzVrFjt37mTx4sV4enpiaGjI0KFDKS0tveF+rh1E7+o15+oDfkFBAW+//TYPPvhgHUdf0+LFi1m6dCmffPIJbdq0wdjYmGeffbZG/P+t980UFBQAVd/B/+2GcacDCP73M/vvflQqlfozLCwsZPDgwQwdOpQVK1Zga2vLmTNnGD58+E3PDdx+fa91te5btmyp0cXM0NAQgGHDhpGQkMDGjRvZtm0bPXr0YO7cucyZM+eOj3szkgAQQgjRrKlUKpwsDHGyMKS/rz2KopBTVMaFrEIuZBWR8M9/jybkcOSahzBjPR3cbIzxsDXG09YET1sTSQo0AYqi3HQdAwMDPv/8cz7//PMGiOjmDsVmUVZRFbezpSEeNnd+wymEqDt6enrVBpO7kQMHDvD000/z0EMPAVWDuyUnJ9/V8Tt06MC5c+fw8vKqdXnr1q1JSEggPT0dOzs7AEJDQ2+639rqdeDAAR5++GHGjBkDVP1CHxMTg6ur6w335ePjw9GjR6uVXfve3t4eR0dH4uLiGDVq1HXjAW75s74dZ8+eJSsri/fee0/dwmLXrl01jn+nx/b392f58uVUVFTUaAXg5+eHnp4eSUlJ9OjR47r7sLe35+mnn+bpp5/mvffe4+uvv5YEgBBCCFFXVCoVVsZ6WBnr0cHl3/mYS8oqSMouIiGriAtZhSRkFaqnIbzKzEAXD1sTPG2N8bSrSgrIIIPibl3bIqWPj60kmYRoJNzc3AgNDeXChQsYGxtjZWV13XW9vb1Zs2YNQ4cOpbKykldffbXWZuG344033uCBBx7A2dmZESNGAHD8+HESEhKYM2cOAwcOxMPDgyeffJL33nuPrKysat0FblSvPXv2MHLkSPT19bGxscHb25u1a9cSGhqKqakp7777Lnl5eTfd15QpU+jduzefffYZQ4YMYfPmzezevRsLCwv1OnPnzmXWrFmYmpoyaNAgSkpKCA0NpaKigokTJ2JnZ4ehoSFbtmzB0dERfX39aoMI3g0XFxf09PRYsmQJzz77LMeOHWPx4sU1Po+8vDx2795N27ZtMTIywsjI6Jb2P3nyZJYsWcLjjz/OSy+9hImJCfv372fAgAG4uLgwffp0pk2bRnl5Od26dSM3N5e9e/fi7OzMI488wrx58wgMDKRNmzYUFhaydetW9bS19UWmARRCCCEAA11tvO1NGehnzzM9PXj7oXYsG9+Zd4f782xPD/q3tsfKWI/I5FzWHEvm/S1nef7nMCatOMYnO86x+WQKMekFlFdU3vxgQvzjSlkFG0+mqN9397r+aOFCiIY1a9YsAHx9fbG1tb1hf/6PPvpIPf3fww8/zMiRI/Hx8bmr4w8ZMoS//vqLTZs2ERgYSLdu3fj888/Vfee1tLRYt24d+fn5dO7cmcmTJ7No0aKb7vfNN98kNjYWT09P9UwMr7/+Ou3bt2fAgAEMGDAAHx8fBg0adNN9de/enc8//5z33nuP9u3bc+DAASZPnoyBgYF6nf/97398+eWXfPvtt7Rr145+/frx22+/4eHhAYCOjg6fffYZn3/+OY6OjnXa5cHW1pYff/yRlStX4uvry6effsr7779fbZ1u3brx/PPPM3LkSGxtbWssvxFra2v+/vtvMjMz6dGjB507d2bFihXqbgmLFi3ilVde4e2338bX15ehQ4eyc+dOdcsKXV1dZs+eTdu2benXrx/W1tZ89913dVb/2qiUW2krJ0hOTqZly5YkJSXh7Oys6XCEEEJoyJXyCi5kFRGXUUBsRiEx6QWk5BWrl+vpaONpa4yPvSne9qa0sjfB1KBuWwnINUnz6uIclJZX8shXB4lI/vdXtiA3K5Y/2wVdbfmNRgjRND322GMUFBSwfv16TYdyz7ida5J0ARBCCCFug76ONq3sTWll/+8c8pdLyjifXsC51MucSysgJqOAqJR89XInC0Na2ZvSw8uGti3qplmjaPrWHEuu9vAPcCQhmzXhyYwOctFQVEIIcXsWL15MSEgIBgYG/PXXX/z+++/89ttvmg5LXIckAIQQQoi7ZGqgS0cXSzr+M6ZAeUUlidlFnEurSghEp1XNPOBiZSQJAKGWmF1Ua/mF65QLIURjFBoayuLFi7l8+TJeXl788MMPjBw5UtNhieuQBIAQQghRx3S0tfCwNcHD1oTBbavKsgquoKcjzbrFv1ysah9kyvU65UII0RitWbNG0yGI2yB3IkIIIUQDsDbRr/OxAETTNqKjM13dq48q3tXDmhGBMq6DEEKI+iEtAIQQQgghNEBPR4ufn+nCmvBkLmQX4WplxIhAZxkAUAghRL2RBIAQQgghhIboamvJgH9CCCEajKSYhRBCCCGEEEKIe4AkAIQQQgghhBBCiHuAJACEEEIIIYQQQoh7gCQAhBBCCCGEEEKIe4AkAIQQQgghhBBCiHuAJACEEEIIIYQQQoh7gEwDeIvKy8sBSElJ0XAkQggh7nVXr0VXr02i4cl9gRBCiMbidu4LJAFwizIyMgAICgrScCRCCCFElYyMDNzc3DQdxj1J7guEEEI0NrdyX6BSFEVpmHCatpKSEk6ePImtrS06OrXnTVJSUggKCuLIkSM4Ojo2cIR1Q+rQOEgdGgepQ+PRHOpRl3UoLy8nIyODdu3aYWBgUEcRitsh9wVNh9ShcZA6NB7NoR5Sh+pu575AWgDcIgMDAzp37nxL6zo6OuLs7FzPEdUvqUPjIHVoHKQOjUdzqEdd1UF++dcsuS9oeqQOjYPUofFoDvWQOvzrVu8LZBBAIYQQQgghhBDiHiAJACGEEEIIIYQQ4h4gCYA6ZGZmxrx58zAzM9N0KHdM6tA4SB0aB6lD49Ec6tEc6iBuT3M451KHxkHq0Dg0hzpA86iH1OHOySCAQgghhBBCCCHEPUBaAAghhBBCCCGEEPcASQAIIYQQQgghhBD3AEkACCGEEEIIIYQQ9wBJAAghhBBCCCGEEPcASQAIIYQQQgghhBD3AEkACCGEEEIIIYQQ9wBJANShzz//HDc3NwwMDOjatStHjx7VdEi3bP78+ahUqmqv1q1bazqsG9q7dy/3338/Tk5OqFQqNmzYUG15SUkJkyZNwtraGhMTE0aMGEF6erqGoq3dzerQp0+fGuflf//7n4aird2iRYvo3Lkzpqam2NnZMXz4cM6fP19tncZ+Lm6lDo39XHzzzTf4+/tjZmaGmZkZwcHBbN68Wb28sZ8DuHkdGvs5qM3EiRNRqVQsXbpUXZadnc3YsWMxMzPD0tKSZ555hsLCQg1GKeqL3Bc0LLkvaBzkvqBxkPuCxqkx3BdIAqCO/Pbbb8yYMYN58+Zx7Ngx/P39CQkJITMzU9Oh3bKAgABSUlLUr/3792s6pBsqLCwkICCAzz//vNbl06dPZ/369axatYo9e/Zw6dIlRo4c2cBR3tjN6gBVXxTXnpf333+/ASO8uT179jBp0iRCQ0PZvn07V65cYdCgQRQXF6vXaezn4lbqAI37XDg5ObFo0SLCw8MJCwtjwIABPPjgg0RFRQGN/xzAzesAjfsc/NeGDRs4dOgQTk5O1crHjh3L6dOn2b59O+vXr2fPnj1MnDhRQ1GK+iL3BQ1P7gsaB7kvaBzkvqDxaTT3BYqoE0FBQcrkyZPV7ysqKhQnJydl8eLFGozq1s2bN08JDAzUdBh3DFDWr1+vfp+bm6vo6uoqq1evVpdFRUUpgHL06FFNhHhT/62DoihK7969lZkzZ2ooojuTnp6uAMqBAwcURWma5+K/dVCUpnkuLC0tlR9//LFJnoOrrtZBUZrWOUhNTVWcnZ2VyMhIxdXVVVmyZImiKIpy5swZBVDCwsLU627evFnR0tJSUlNTNRWuqAdyX6BZcl/QeMh9QeMh9wWa05juC6QFQB0oLS0lPDycQYMGqcu0tLQYMGAAhw4d0mBktycqKgpHR0c8PDx44oknSE5O1nRIdyw8PJyysrJq56R169a4uLg0qXMC8NNPP2FjY0Pbtm2ZM2dOjexzY5OXlweAlZUV0DTPxX/rcFVTORcVFRX8+uuvFBUV0bVr1yZ5Dv5bh6uayjl46qmnmDp1Ku3atatWfujQIaytrQkMDFSXDRgwAJVKxZEjRxo6TFFP5L6g8WmK34PX01S+B6+S+wLNk/sCzWtM9wU69bLXe0xmZiYVFRXY29tXK7e3tycmJkZDUd2eLl268OOPP+Lj40NKSgoLFiygV69enDx5EmNjY02Hd9tSU1MxNDTE1NS0Wrm9vT2pqakaiur2jRkzBldXV5ycnIiIiOCVV17h/Pnz/P7775oOrVaKojB9+nR69+6t7iva1M5FbXWApnEuTp48SXBwMCUlJZiYmLBu3Tp8fHwIDw9vMufgenWApnEOAJYuXUphYSEzZ86ssSw1NRU7O7tqZTo6OlhZWTW6cyHunNwXND5N7Vp0PU3le/AquS/QLLkvaBwa232BJAAEAEOGDFH/7e/vT5cuXXB1dWX16tU8+eSTGozs3vbcc8+p/27Xrh1OTk7079+fCxcu4OrqqsHIajd58mROnTrFgQMHNB3KHbteHZrCufDx8eHEiRPk5eWxevVqxo0bx759+zQd1m25Xh18fHyaxDk4e/Ysb731FocPH0ZLSxrZiaZL7gsap6bwPXgtuS/QLLkv0LzGeF/QOKJo4mxsbNDW1iYtLa1aeVpaGg4ODhqK6u5YWFjQqlWrJvNLxX85ODhQXFzM5cuXq5U35XMCVb/IAI3yvEyZMoW//vqLv//+u9rgJk3pXFyvDrVpjOdCT08PLy8vAgMDWbRoEf7+/nz22WdN6hxcrw61aYznIDQ0lIyMDLy8vNDR0UFHR4cLFy4wbdo0WrdujYODQ41RlsvLy8nOzm5050LcObkvaHya0vfg7WiM34NXyX2B5sl9geY1xvsCSQDUAT09PQIDA9m+fbu6rLKykp07dxIcHKzByO5cQUEBsbGxODo6ajqUOxIYGIiurm61cxIdHU1iYmKTPScAJ06cAGhU50VRFCZPnszatWv5+++/cXd3r7a8KZyLm9WhNo3xXPyXoihcuXKlSZyD67lah9o0xnPw0EMPERkZyYkTJ9QvJycnXnnlFdavX09wcDBZWVkcO3ZMvc3ff/+NoigEBQVpMHJRl+S+oPFpyt+DN9IYvwflvqDxnIv/kvuChtco7wvqZWjBe9Cvv/6q6OvrKz/++KNy5swZ5bnnnlMsLS2VjIwMTYd2S2bOnKns3r1biY+PVw4cOKAMGDBAsbW1VTIzMzUd2nVdvnxZOX78uHL8+HEFUD777DPl+PHjSkpKiqIoivK///1PcXFxUf7++28lLCxMCQ4OVnr27KnhqKu7UR1iYmKUN998UwkLC1Pi4+OVP//8U/Hw8FD69eun6bCrmThxomJubq7s3r1bSUlJUb+KiorU6zT2c3GzOjSFc/Haa6+p/w2fPHlSee211xQtLS1lx44diqI0/nOgKDeuQ1M4B9dz7Wi/iqIogwcPVjp06KAcPnxY2b9/v+Lt7a08/vjjGoxQ1Ae5L2h4cl/QOMh9QeMg9wWNl6bvCyQBUIeWLFmiuLi4KHp6ekpQUJBy+PBhTYd0y0aNGqU4Ojoqenp6SosWLZTRo0crsbGxmg7rhnbt2qUANV7z5s1TFEVRiouLlRdeeEGxtLRUjIyMlOHDhze6abZuVIfExESlV69eipWVlaKvr694eXkps2fPVvLz8zUddjW1xQ8oy5YtU6/T2M/FzerQFM7Fc889p7i6uip6enqKra2t0r9/f2Xbtm3q5Y39HCjKjevQFM7B9fz3Qp+VlaU89thjiomJiWJmZqY8/fTTSkFBgQYjFPVF7gsaltwXNA5yX9A4yH1B46Xp+wKVoihK3bcrEEIIIYQQQgghRGMiYwAIIYQQQgghhBD3AEkACCGEEEIIIYQQ9wBJAAghhBBCCCGEEPcASQAIIYQQQgghhBD3AEkACCGEEEIIIYQQ9wBJAAghhBBCCCGEEPcASQAIIYQQQgghhBD3AEkACCGEEEIIIYQQ9wBJAAhxBzp16sT8+fPrbH8//vgjNjY2dba/htanTx9mzZp1V/uYP38+nTp1qqOIatfUP2chhBCNk9wXVCf3BUI0XpIAEKIRGDVqFGfOnNF0GDe1e/duVCoVBQUF1crXrl3LvHnz7mrfs2bNYuvWrXe1j2u5ubmxdOnSamWN4XNWqVRs2LBBozEIIYRo3BrD9epWyH3B3ZP7AtHQdDQdgBACDA0NMTQ01HQYd8zKyuqu92FiYoKJiUkdRHN9Tf1zFkIIcW9o6tcruS8QovGSFgBC3ERBQQGPP/44xsbGtGjRgi+++KLGOjk5OUyYMAEbGxvMzc0JCQnh7NmzAJw+fRqVSkVMTEy1bebNm0fHjh2B2pugrVu3jsDAQAwMDLCzs2PcuHG3dLwbWbVqFX5+fujp6eHh4cGXX35ZbblKpeLrr79m0KBBGBoa4u3tzaZNmwBISEigb9++AJiamqJSqRg/fjxQs6mfm5sbixYtYsyYMRgbG+Ph4cH27dtJTExk4MCBGBsb06VLF86fP6/e5tqmfgkJCahUqhqvPn36AJCRkcHo0aNp0aIFRkZGtG/fnj///FO9rz59+nDhwgWmTJmi3vZ6n/PSpUvx8PBAT08PPz8/1qxZo152NY4//viDnj17YmRkRJcuXW74a0FpaSmTJk3CwcEBAwMDPDw8WLJkifpzAbj//vtRqVTq91B1vtu3b4+BgQFeXl68//77VFZW3tK5EUII0XDkvkDuC+S+QDRpihDihp577jnFzc1N2blzpxIREaEMHDhQMTExUebNm6deZ8CAAcpDDz2khIWFKdHR0coLL7ygODs7KwUFBYqiKEpAQIDy5ptvVtuvt7e3snjxYkVRFGXZsmWKtbW1etmuXbsUHR0d5a233lKioqKUY8eOqde9lePV5siRI4qWlpbyzjvvKNHR0crXX3+t6OnpKX/88Yd6HUCxtbVVli1bppw9e1aZOXOmoq+vryQmJirl5eXKmjVrFECJjY1VUlJSlNzcXEVRFKV3797KzJkz1ftxdXVVrK2tlW+//VY5d+6c8uSTTyp2dnbKoEGDlA0bNihRUVFK9+7dlQEDBqi3mTdvnhIYGKgoiqKUl5crKSkp6ldERIRiY2OjvPHGG4qiKMqFCxeUDz/8UDl+/LgSExOjLF68WNHR0VHOnDmjKIqiZGVlKc7OzsrChQvV+6jtc169erWip6enfP3110p0dLTyzjvvKFpaWkp4eLiiKIoSHx+vAEqbNm2UrVu3KlFRUUqfPn2Url27Xvdz/v/27i0kqq6NA/jfF/dMYR4vykllLBWczFExUrOysghDHMK5SIMsogsjIzGCiAo0KvNCwUIii06YJ6QUDCmVNOkElXlhB0qTMjWKPECo2PNdiPt162TWl73G/H8wMHvtxVpr9hpmPSz2fiYnJ0d8fHyksbFR2tvbpb6+XsrLy0VEpKenRwDIlStX5MOHD9LT0yMiIg0NDeLq6iqXL1+W169fS3V1tXh5eUleXt605oaIiP4cxgWMCxgX0N+MGwBEU+jr6xNFUaSiokIt6+zsFEVR1IW+sbFR3N3dZXBwUK0zMjIiBoNBSkpKREQkOztbTCaTen5s0X337p2ITF6A1qxZIzt27LA5pun0Z0tSUpLExcVpylJTU2XFihXqMQDZu3evps7SpUvl4MGDIjIagACQ/v5+TR1bC/327dvV41evXgkAyc3NVcvKyspEURQZGRkREe1CP97Q0JCsXLlS4uPj1bq2xMTESFZWlmYM+fn5mjoTr3NUVJSkpqZq6sTFxUlycrKI/LvQX7p0ST1fU1MjAOTr1682x5GWlibr1q2Tb9++2TwPQKqqqjRlsbGxcurUKU1ZQUGB5jvzo7khIqKZx7iAcQHjAvrb8REAoim8efMGw8PDiIiIUMsMBgOMRqN63NzcjN7eXnh4eKjPq7m4uKC7uxuvX78GACQlJeH58+d4+vQpAKCoqAirV6+Gl5eXzX6fPXum3lY30Y/66+joUMvnzZuH48ePAwBaW1sRHR2taSs6Ohqtra2asvGfFQAiIyMn1ZkOs9msvl+wYAEAICgoSFM2PDyML1++TNlOWloaPn/+jKKiIvzzz+hP1sjICDIzMxEcHKxeh7t376Kjo+OnxjjdaxIcHKy+NxgMAICenh6bbW7btg2PHz9GYGAg9u3bh7q6uh+Oo7m5GUeOHNHMW3p6uvr9GfO75oaIiH4N4wLGBQDjAvq7MQkg0f9pYGAA3t7eqK2tnXRuLAmOj48PVq1ahWvXrsFsNqOkpASZmZkz0p+Li4saUIwfw5+mKIr6fuxZO1tl459nm6igoABlZWV4+PAhnJ2d1fKcnBycPn0aeXl5CAoKgpOTE3bt2oWhoaHf/TF+etzLli1DW1sbbt68iVu3bsFisWDLli04d+7cd9sfGBjAsWPHYLFYfu/AiYjoj2NcYBvjAsYFNDvwDgCiKSxevBiKouDBgwdqWVdXF96+faseh4WFobOzE3q9Hv7+/prX+EV269atKC4uRl1dHT59+gSr1frdfs1mM+rr622e+1F/jo6ONsdgMpnQ1NSkaaupqQlLlizRlI3/rGPHJpMJAKDT6QCM7rTPtIaGBmRkZKC0tBR+fn6ac01NTdi8eTOSk5MREhICo9E4KZmSTqf74Tine01+lpubG5KSknDhwgUUFhbi4sWLamCgKMqkcYWFheHly5eT5tPf319Tb6q5ISKimce4gHHBr2BcQLMJ7wAgmoKzszNSUlKwf/9+uLu7w8PDAwcOHIBer1frrF+/HsuXL4fFYkF2djb8/f3x/v173LhxAzt37kRgYCAAwGq1Ys+ePcjIyMCmTZvg5ub23X6PHj2KDRs2wM/PD1arFYODg6itrUV6evq0+5soPT0dkZGROHHiBKxWK+rr63H+/HmUlJRo6hUXFyM8PByRkZEoLCzEixcv1P+nNRqN6v/VjmWdnYm/6Onq6oLVakVGRgaCgoLQ1dUFYHTx9vDwQEBAACoqKnD//n04Ozvj5MmT6O3t1bTh6+uLO3fuwGq1Qq/XT8ryCwAZGRlITk5GaGgo1q5di/LyctTU1ODRo0e/PPbc3FwsXLgQoaGhEBFcv34dAQEB6m2Kvr6+uH37NiIiIqDX6+Hu7o7Dhw8jISEB3t7eSExMBAA8efIE7e3tOHTokNr2VHNDREQzj3EB44KfxbiAZp3/OgkB0WzX19cnSUlJMnfuXDEYDJKfny/h4eGabL+9vb2ye/duMRgMotPpxGg0SkpKinR3d2vaSkhIEABSWlqqKZ+YhEZkNBOt2WwWnU4n8+fP1yTPmW5/E5WWlorJZBJFUWTRokVy5swZzXkAUlBQILGxsaLX68XPz08qKys1dTIzM8XT01McHBwkJSVFRGwn+xmfaKe/v18ASH19vVrW2NgoAOTjx48iok32M5ZUaOIrJiZGREaz+VosFnFychJPT0/JysqSxMREdTwiIvfu3ROz2Sx6vV7GfupsXef8/Hzx9fUVRVHEZDKpmXlF/k3209LSopa1tLQIAGlra7N5jc+ePSshISHi5OQkrq6usnHjRjULsYhIZWWl+Pv7i6OjoxiNRrW8urpaIiMjZc6cOeLq6ipRUVFy9erVn5obIiKaeYwLGBcwLqC/mYOIyJ/abCCi2c3BwQFVVVWIj4//r4dCE3BuiIjoT+PaM3txbuhXMQcAERERERERkR3gBgARERERERGRHeAjAERERERERER2gHcAEBEREREREdkBbgAQERERERER2QFuABARERERERHZAW4AEBEREREREdkBbgAQERERERER2QFuABARERERERHZAW4AEBEREREREdkBbgAQERERERER2QFuABARERERERHZgf8BxGkinfbxekQAAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "if result_data is not None:\n", " density_layers = [\n", " np.squeeze(np.asarray(result_data[\"density\"])[layer])\n", " for layer in range(N_LAYERS)\n", " ]\n", " fig, axes = plt.subplots(\n", " 1, N_LAYERS, figsize=(3.75 * N_LAYERS, 3.2), constrained_layout=True\n", " )\n", " for layer, density in enumerate(density_layers):\n", " axes[layer].imshow(\n", " density.T,\n", " origin=\"lower\",\n", " extent=(-DESIGN_HALF, DESIGN_HALF, -DESIGN_HALF, DESIGN_HALF),\n", " cmap=\"gray_r\",\n", " vmin=0,\n", " vmax=1,\n", " interpolation=\"nearest\",\n", " )\n", " axes[layer].set(\n", " xlabel=r\"$x$ ($\\mu$m)\", ylabel=r\"$y$ ($\\mu$m)\", title=f\"Layer {layer + 1}\"\n", " )\n", " contours = gdstk.contour(density.T, 0.5, PIXEL, PIXEL / 10, layer=3)\n", " x_span, y_span = (density.shape[0] - 1) * PIXEL, (density.shape[1] - 1) * PIXEL\n", " for polygon in contours:\n", " polygon.translate(-x_span / 2, -y_span / 2)\n", " silicon = (\n", " gdstk.boolean(\n", " fixed_polygons(LAYER_OUTPUT_COUNTS[layer]) + contours,\n", " [],\n", " \"or\",\n", " layer=3,\n", " precision=0.001,\n", " )\n", " or []\n", " )\n", " library = gdstk.Library(unit=1e-6, precision=1e-9)\n", " cell = library.new_cell(f\"INVERSE_DESIGNED_LAYER_{layer + 1}\")\n", " cell.add(*silicon)\n", " library.write_gds(LAYOUT_DIR / f\"inverse_designed_layer_{layer + 1}.gds\")\n", " library.write_oas(LAYOUT_DIR / f\"inverse_designed_layer_{layer + 1}.oas\")\n", " fig.savefig(\n", " FIGURE_DIR / \"realized_device_densities.png\", dpi=180, bbox_inches=\"tight\"\n", " )\n", " plt.show()\n", "progress_source = (\n", " result_data\n", " if result_data is not None and \"test_accuracy_history\" in result_data\n", " else realization_progress\n", ")\n", "progress_accuracy = np.asarray(progress_source[\"test_accuracy_history\"], dtype=float)\n", "accuracy_recalculated_from_matrices = False\n", "if not np.any(np.isfinite(progress_accuracy)):\n", " transmission_values = np.asarray(\n", " progress_source[\"transmission_history\"], dtype=complex\n", " )\n", " progress_accuracy = np.full(transmission_values.shape[:2], np.nan)\n", " for step in range(len(transmission_values)):\n", " step_matrices = tuple(\n", " transmission_values[step, layer, : LAYER_OUTPUT_COUNTS[layer]]\n", " for layer in range(N_LAYERS)\n", " )\n", " if all(np.isfinite(matrix).all() for matrix in step_matrices):\n", " progress_accuracy[step, 0] = uncalibrated_test_accuracy(step_matrices)\n", " accuracy_recalculated_from_matrices = np.any(np.isfinite(progress_accuracy))\n", "has_realization_history = np.any(\n", " np.isfinite(np.asarray(progress_source[\"transmission_error_history\"], dtype=float))\n", ")\n", "if has_realization_history:\n", " iterations = np.asarray(progress_source[\"iterations\"], dtype=int)\n", " fig, axes = plt.subplots(3, 2, figsize=(9.2, 9.2), constrained_layout=True)\n", " metric_panels = (\n", " (\"transmission_error_history\", \"Frobenius norm\", \"Transmission target error\"),\n", " (\"reflection_error_history\", \"Frobenius norm\", \"Reflection\"),\n", " (\"realization_loss_history\", \"optical loss\", \"Transmission + reflection error\"),\n", " (\"fabrication_penalty_history\", \"unit-weight penalty\", \"Fabrication penalty\"),\n", " (\"fixed_reference_loss_history\", \"reference loss\", \"Optical + 0.8 fabrication\"),\n", " )\n", " colors = plt.cm.tab10(np.arange(N_LAYERS))\n", " for axis, (key, ylabel, title) in zip(axes.flat[:5], metric_panels):\n", " values = np.asarray(progress_source[key], dtype=float)\n", " valid_rows = np.any(np.isfinite(values), axis=1)\n", " for layer in range(N_LAYERS):\n", " valid = np.isfinite(values[:, layer])\n", " axis.plot(\n", " iterations[valid],\n", " values[valid, layer],\n", " color=colors[layer],\n", " linewidth=1.1,\n", " alpha=0.75,\n", " label=f\"layer {layer + 1}\",\n", " )\n", " mean_values = np.full(len(iterations), np.nan)\n", " mean_values[valid_rows] = np.nanmean(values[valid_rows], axis=1)\n", " axis.plot(\n", " iterations[valid_rows],\n", " mean_values[valid_rows],\n", " color=\"black\",\n", " linewidth=2.2,\n", " label=\"mean\",\n", " )\n", " axis.set(\n", " xlabel=\"device-optimization step\", ylabel=ylabel, title=title, yscale=\"log\"\n", " )\n", " axes[0, 0].legend(frameon=False, ncol=2)\n", " progress_mode = str(\n", " np.asarray(\n", " progress_source[\"mode\"]\n", " if \"mode\" in progress_source\n", " else progress_source[\"realization_mode\"]\n", " ).item()\n", " )\n", " accuracy_axis = axes[2, 1]\n", " if progress_mode == \"sequential\" and not accuracy_recalculated_from_matrices:\n", " for layer in range(N_LAYERS):\n", " valid = np.isfinite(progress_accuracy[:, layer])\n", " accuracy_axis.plot(\n", " iterations[valid],\n", " 100 * progress_accuracy[valid, layer],\n", " color=colors[layer],\n", " linewidth=1.8,\n", " marker=\"o\",\n", " markersize=3,\n", " label=f\"after layer {layer + 1} update\",\n", " )\n", " else:\n", " valid = np.isfinite(progress_accuracy[:, 0])\n", " accuracy_axis.plot(\n", " iterations[valid],\n", " 100 * progress_accuracy[valid, 0],\n", " color=\"#1f77b4\",\n", " linewidth=2.0,\n", " marker=\"o\",\n", " markersize=3,\n", " label=(\n", " \"matched saved matrices\"\n", " if accuracy_recalculated_from_matrices\n", " else \"reconstructed stack\"\n", " ),\n", " )\n", " accuracy_axis.axhline(\n", " 100 * test_accuracy,\n", " color=\"black\",\n", " linestyle=\"--\",\n", " linewidth=1.2,\n", " label=\"trained target matrices\",\n", " )\n", " accuracy_axis.set(\n", " xlabel=\"device-optimization step\",\n", " ylabel=\"test accuracy (%)\",\n", " title=\"Uncalibrated network accuracy\",\n", " )\n", " accuracy_axis.legend(frameon=False)\n", " fig.savefig(FIGURE_DIR / \"realization_progress.png\", dpi=180, bbox_inches=\"tight\")\n", " plt.show()\n", "if result_data is not None:\n", " fig, axes = plt.subplots(\n", " N_LAYERS, 4, figsize=(11.2, 2.7 * N_LAYERS), constrained_layout=True\n", " )\n", " for layer in range(N_LAYERS):\n", " images = (\n", " np.abs(result_data[\"target\"][layer, : LAYER_OUTPUT_COUNTS[layer]]),\n", " np.abs(realized_matrices[layer]),\n", " np.angle(result_data[\"target\"][layer, : LAYER_OUTPUT_COUNTS[layer]]),\n", " np.angle(realized_matrices[layer]),\n", " )\n", " titles = (\n", " \"target amplitude\",\n", " \"realized amplitude\",\n", " \"target phase\",\n", " \"realized phase\",\n", " )\n", " for column, (image, title) in enumerate(zip(images, titles)):\n", " cmap = \"viridis\" if column < 2 else \"twilight\"\n", " limits = {} if column < 2 else {\"vmin\": -np.pi, \"vmax\": np.pi}\n", " axes[layer, column].imshow(image, cmap=cmap, aspect=\"equal\", **limits)\n", " axes[layer, column].set(\n", " title=f\"Layer {layer + 1}: {title}\", xlabel=\"input\", ylabel=\"output\"\n", " )\n", " fig.savefig(\n", " FIGURE_DIR / \"realized_target_response.png\", dpi=180, bbox_inches=\"tight\"\n", " )\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 45, "id": "community-52", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "layer 1: mean=-49.99 dB, worst=-48.36 dB\n", "layer 2: mean=-49.28 dB, worst=-44.90 dB\n", "layer 3: mean=-50.58 dB, worst=-49.26 dB\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "reflection_summary = None\n", "if result_data is not None:\n", " reflected_power = np.sum(np.abs(realized_reflections) ** 2, axis=1)\n", " reflected_power_db = 10 * np.log10(np.maximum(reflected_power, 1e-12))\n", " reflection_summary = {\n", " f\"layer {layer + 1}\": {\n", " \"mean reflected power dB\": float(\n", " 10 * np.log10(max(np.mean(reflected_power[layer]), 1e-12))\n", " ),\n", " \"median reflected power dB\": float(\n", " 10 * np.log10(max(np.median(reflected_power[layer]), 1e-12))\n", " ),\n", " \"worst-case reflected power dB\": float(\n", " 10 * np.log10(max(np.max(reflected_power[layer]), 1e-12))\n", " ),\n", " }\n", " for layer in range(N_LAYERS)\n", " }\n", " for name, values in reflection_summary.items():\n", " print(\n", " f\"{name}: mean={values['mean reflected power dB']:.2f} dB, \"\n", " f\"worst={values['worst-case reflected power dB']:.2f} dB\"\n", " )\n", " insertion_loss_db = [\n", " -20 * np.log10(np.maximum(np.linalg.svd(matrix, compute_uv=False), 1e-12))\n", " for matrix in realized_matrices\n", " ]\n", " fig, axes = plt.subplots(1, 2, figsize=(8.4, 3.2), constrained_layout=True)\n", " axes[0].boxplot(\n", " [reflected_power_db[layer] for layer in range(N_LAYERS)],\n", " tick_labels=[str(layer + 1) for layer in range(N_LAYERS)],\n", " )\n", " for layer in range(N_LAYERS):\n", " singular_losses = np.sort(insertion_loss_db[layer])\n", " axes[1].plot(\n", " np.arange(1, len(singular_losses) + 1),\n", " singular_losses,\n", " marker=\".\",\n", " label=f\"layer {layer + 1}\",\n", " )\n", " axes[0].set(\n", " xlabel=\"layer\", ylabel=\"total reflected power (dB)\", title=\"Input reflection\"\n", " )\n", " axes[1].set(\n", " xlabel=\"singular channel\",\n", " ylabel=\"insertion loss (dB)\",\n", " title=\"Realized transmission\",\n", " )\n", " axes[1].legend(frameon=False)\n", " fig.savefig(\n", " FIGURE_DIR / \"reflection_insertion_loss.png\", dpi=180, bbox_inches=\"tight\"\n", " )\n", " plt.show()\n", "\n", "\n", "def confusion(labels, predictions):\n", " result = np.zeros((N_CLASSES, N_CLASSES), dtype=int)\n", " np.add.at(result, (np.asarray(labels), np.asarray(predictions)), 1)\n", " return result\n", "\n", "\n", "def normalized_confusion(labels, predictions):\n", " counts = confusion(labels, predictions)\n", " return counts / np.maximum(counts.sum(axis=1, keepdims=True), 1)\n", "\n", "\n", "def repeated_field_trace(matrices, features):\n", " fields = jnp.ones_like(features, dtype=jnp.complex64)\n", " phase = jnp.exp(1j * PHASE_SCALE * features)\n", " trace = []\n", " for layer in range(N_LAYERS):\n", " fields = fields * route_inputs_jax[layer] * phase\n", " fields = fields @ jnp.asarray(matrices[layer]).T\n", " trace.append(fields * route_output_jax if layer == N_LAYERS - 1 else fields)\n", " return tuple(trace)\n", "\n", "\n", "def highest_margin_correct_sample(scores, labels, predictions, class_label):\n", " labels = np.asarray(labels)\n", " predictions = np.asarray(predictions)\n", " scores = np.asarray(scores)\n", " candidates = np.flatnonzero((labels == class_label) & (predictions == class_label))\n", " if len(candidates) == 0:\n", " return int(np.flatnonzero(labels == class_label)[0])\n", " class_scores = scores[candidates]\n", " correct = class_scores[:, class_label]\n", " competitors = np.max(np.delete(class_scores, class_label, axis=1), axis=1)\n", " margins = (correct - competitors) / np.maximum(class_scores.sum(axis=1), 1e-12)\n", " return int(candidates[np.argmax(margins)])\n", "\n", "\n", "result_figure_summary = {\n", " \"repeated-encoding training\": \"repeated_encoding_training.png\",\n", " \"matrix-error response\": \"repeated_encoding_matrix_error.png\",\n", " \"singular amplitudes\": \"repeated_encoding_singular_amplitudes.png\",\n", " \"encoding comparison\": \"encoding_comparison.png\",\n", " \"target matrices\": \"repeated_encoding_target_matrices.png\",\n", " \"local simulation domains\": \"tidy3d_preflight_domain_permittivity.png\",\n", "}\n", "if result_data is not None:\n", " single_scores = np.asarray(\n", " single_encoding_scores(\n", " layer_matrices(single_params), jnp.asarray(test_features)\n", " )\n", " )\n", " repeated_scores = np.asarray(\n", " jnp.abs(\n", " optical_forward(jnp.asarray(trained_matrices), jnp.asarray(test_features))\n", " )\n", " ** 2\n", " )\n", " realized_scores = np.asarray(calibrated_scores)\n", " prediction_sets = (\n", " np.argmax(single_scores, axis=1),\n", " np.argmax(repeated_scores, axis=1),\n", " np.argmax(realized_scores, axis=1),\n", " )\n", " confusion_titles = (\n", " \"Encode once\",\n", " \"Repeat encoding: ideal matrices\",\n", " \"Repeat encoding: realized devices\",\n", " )\n", " fig, axes = plt.subplots(1, 3, figsize=(10.4, 3.25), constrained_layout=True)\n", " for axis, predictions, title in zip(axes, prediction_sets, confusion_titles):\n", " matrix = normalized_confusion(test_labels, predictions)\n", " image = axis.imshow(matrix, cmap=\"Blues\", vmin=0, vmax=1)\n", " for row in range(N_CLASSES):\n", " for column in range(N_CLASSES):\n", " color = \"white\" if matrix[row, column] > 0.55 else \"black\"\n", " axis.text(\n", " column,\n", " row,\n", " f\"{100 * matrix[row, column]:.1f}\",\n", " ha=\"center\",\n", " va=\"center\",\n", " color=color,\n", " fontsize=8,\n", " )\n", " accuracy = np.mean(predictions == np.asarray(test_labels))\n", " axis.set(\n", " xticks=np.arange(N_CLASSES),\n", " yticks=np.arange(N_CLASSES),\n", " xlabel=\"predicted digit\",\n", " ylabel=\"true digit\",\n", " title=f\"{title}\\naccuracy {100 * accuracy:.2f}%\",\n", " )\n", " fig.colorbar(image, ax=axes, label=\"fraction of true class\", shrink=0.82)\n", " fig.savefig(\n", " FIGURE_DIR / \"encoding_confusion_comparison.png\", dpi=180, bbox_inches=\"tight\"\n", " )\n", " plt.show()\n", "\n", " sample_indices = tuple(\n", " highest_margin_correct_sample(\n", " realized_scores, test_labels, prediction_sets[2], class_label\n", " )\n", " for class_label in CLASS_LABELS\n", " )\n", " sample_traces = tuple(\n", " tuple(\n", " np.asarray(values[0])\n", " for values in repeated_field_trace(\n", " realized_matrices, jnp.asarray(test_features[index : index + 1])\n", " )\n", " )\n", " for index in sample_indices\n", " )\n", " phase_map = plt.get_cmap(\"twilight\")\n", " fig, axes = plt.subplots(\n", " N_CLASSES,\n", " N_LAYERS + 1,\n", " figsize=(3.0 * (N_LAYERS + 1), 2.15 * N_CLASSES),\n", " constrained_layout=True,\n", " )\n", " axes = np.atleast_2d(axes)\n", " for row, (sample_index, trace) in enumerate(zip(sample_indices, sample_traces)):\n", " axes[row, 0].imshow(test_images[sample_index], cmap=\"gray\", vmin=0, vmax=255)\n", " axes[row, 0].set(\n", " title=f\"digit {test_labels[sample_index]}\\nsample {sample_index}\",\n", " xticks=[],\n", " yticks=[],\n", " )\n", " common_limit = 1.08 * max(np.max(np.abs(values)) for values in trace)\n", " for layer, values in enumerate(trace):\n", " amplitudes = np.abs(values)\n", " phases = np.angle(values)\n", " channel_index = np.arange(len(values))\n", " axes[row, layer + 1].bar(\n", " channel_index,\n", " amplitudes,\n", " color=phase_map((phases + np.pi) / (2 * np.pi)),\n", " edgecolor=\"black\",\n", " linewidth=0.25,\n", " )\n", " axes[row, layer + 1].set(\n", " xticks=channel_index,\n", " xlabel=\"channel\" if row == N_CLASSES - 1 else None,\n", " ylabel=\"amplitude\",\n", " ylim=(0, common_limit),\n", " title=(\n", " f\"after layer {layer + 1}\"\n", " if layer < N_LAYERS - 1\n", " else f\"detector fields\\npredicted {prediction_sets[2][sample_index]}\"\n", " ),\n", " )\n", " phase_scale = plt.cm.ScalarMappable(\n", " norm=plt.Normalize(-np.pi, np.pi), cmap=phase_map\n", " )\n", " phase_scale.set_array([])\n", " fig.colorbar(\n", " phase_scale,\n", " ax=axes[:, 1:],\n", " location=\"bottom\",\n", " shrink=0.55,\n", " pad=0.04,\n", " label=\"optical phase (rad)\",\n", " )\n", " fig.savefig(\n", " FIGURE_DIR / \"sample_channel_field_evolution.png\", dpi=180, bbox_inches=\"tight\"\n", " )\n", " plt.show()\n", " result_figure_summary.update(\n", " {\n", " \"optimization evolution\": \"realization_progress.png\",\n", " \"device densities\": \"realized_device_densities.png\",\n", " \"target and realized matrices\": \"realized_target_response.png\",\n", " \"reflection and insertion loss\": \"reflection_insertion_loss.png\",\n", " \"confusion matrices\": \"encoding_confusion_comparison.png\",\n", " \"sample channel fields\": \"sample_channel_field_evolution.png\",\n", " \"field sample indices\": list(sample_indices),\n", " \"field sample selection\": \"largest normalized correct-class margin\",\n", " }\n", " )" ] }, { "cell_type": "markdown", "id": "community-53", "metadata": {}, "source": [ "## Summary\n", "\n", "In this notebook, we trained a six-channel classifier for MNIST digits 0–3 and compared two ways of applying phase encoding. The repeated model applies the image phase before all three passive transformations, while the baseline applies it only once. We transferred the trained transformations to three inverse-designed silicon devices and included the routed PhotonForge circuit in the final classifier.\n", "\n", "Repeated encoding performs better than the single-encoding baseline. Most of this advantage remains when the trained matrices are replaced by the Tidy3D transmission matrices. The matrix, reflection, and insertion-loss plots show where the realized devices depart from their targets.\n", "\n", "The device optimization uses a two-dimensional effective-index model and therefore misses out-of-plane scattering. Before fabrication, the devices should be optimized in three dimensions or fine-tuned from the two-dimensional designs.\n" ] }, { "cell_type": "code", "execution_count": 46, "id": "community-54", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "classifier: 4 classes, 6 channels, 12.6 µm devices\n", "realization: mode=synchronized, completed=[40, 40, 40], complete=True\n", "latest uncalibrated test accuracy: 89.05%\n", "worst reflected power: -44.90 dB\n", "progress cache: output/deep/progress.npz\n", "saved figures: repeated_encoding_training.png, repeated_encoding_matrix_error.png, repeated_encoding_singular_amplitudes.png, encoding_comparison.png, repeated_encoding_target_matrices.png, tidy3d_preflight_domain_permittivity.png, realization_progress.png, realized_device_densities.png, realized_target_response.png, reflection_insertion_loss.png, encoding_confusion_comparison.png, sample_channel_field_evolution.png, largest normalized correct-class margin\n" ] } ], "source": [ "accuracy_series = (\n", " test_accuracy_history[:, 0]\n", " if REALIZATION_MODE == \"synchronized\"\n", " else test_accuracy_history.T.reshape(-1)\n", ")\n", "valid_progress = np.flatnonzero(np.isfinite(accuracy_series))\n", "latest_uncalibrated_accuracy = (\n", " float(reconstruction[\"repeated-encoding realized, uncalibrated\"][1])\n", " if reconstruction is not None\n", " else float(accuracy_series[valid_progress[-1]])\n", " if len(valid_progress)\n", " else None\n", ")\n", "print(\n", " f\"classifier: {N_CLASSES} classes, {N_CHANNELS} channels, \"\n", " f\"{DESIGN_EDGE_UM:g} µm devices\"\n", ")\n", "print(\n", " f\"realization: mode={REALIZATION_MODE}, \"\n", " f\"completed={completed_steps.tolist()}, complete={realization_complete}\"\n", ")\n", "if latest_uncalibrated_accuracy is not None:\n", " print(f\"latest uncalibrated test accuracy: {latest_uncalibrated_accuracy:.2%}\")\n", "if reflection_summary is not None:\n", " worst_reflection = max(\n", " values[\"worst-case reflected power dB\"]\n", " for values in reflection_summary.values()\n", " )\n", " print(f\"worst reflected power: {worst_reflection:.2f} dB\")\n", "print(f\"progress cache: {PROGRESS_PATH.relative_to(REPOSITORY_ROOT)}\")\n", "saved_figures = [\n", " value for value in result_figure_summary.values() if isinstance(value, str)\n", "]\n", "print(\"saved figures:\", \", \".join(saved_figures))" ] }, { "cell_type": "markdown", "id": "community-55", "metadata": {}, "source": [ "## References\n", "\n", "1. A. M. I. Muda and U. Teğin, “Deep inverse-designed nanophotonic processors with structural nonlinearity from repeated phase encoding,” arXiv:2608.02094 [physics.optics] (2026). [arXiv:2608.02094](https://arxiv.org/abs/2608.02094)\n", "\n", "2. M. Yildirim, N. U. Dinc, I. Oguz, D. Psaltis, and C. Moser, “Nonlinear processing with linear optics,” *Nature Photonics* **18**, 1076–1082 (2024). [doi:10.1038/s41566-024-01494-z](https://doi.org/10.1038/s41566-024-01494-z)\n", "\n", "3. Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner, “Gradient-based learning applied to document recognition,” *Proceedings of the IEEE* **86**, 2278–2324 (1998). [doi:10.1109/5.726791](https://doi.org/10.1109/5.726791)\n", "\n", "4. M. Hammer and O. V. Ivanova, “Effective index approximations of photonic crystal slabs: a 2-to-1-D assessment,” *Optical and Quantum Electronics* **41**, 267–283 (2009). [doi:10.1007/s11082-009-9349-3](https://doi.org/10.1007/s11082-009-9349-3)\n", "\n", "5. Flexcompute, [Effective index approximation in Tidy3D](https://www.flexcompute.com/tidy3d/examples/notebooks/EffectiveIndexApproximation/).\n", "\n", "6. V. Nikkhah *et al.*, “Inverse-designed low-index-contrast structures on a silicon photonics platform for vector–matrix multiplication,” *Nature Photonics* **18**, 501–508 (2024). [doi:10.1038/s41566-024-01394-2](https://doi.org/10.1038/s41566-024-01394-2)\n", "\n", "7. SiEPIC, [SiEPIC EBeam PDK](https://github.com/SiEPIC/SiEPIC_EBeam_PDK)." ] } ], "metadata": { "applications": [ "Passive photonic integrated circuit components" ], "description": "This notebook demonstrates training and inverse design of a repeated-phase-encoding photonic classifier for MNIST digit classification in PhotonForge and Tidy3D, using complex-matrix training under simulated transmission error and topology optimization of three cascaded silicon devices to evaluate how re-applying the input's phase encoding before every passive optical stage, rather than only once, affects classification accuracy and robustness, across the trained target matrices, single- versus repeated-encoding architectures, and their Tidy3D-realized silicon devices.", "feature_image": "./img/linear_layer_render.png", "features": [ "Adjoint inverse design", "2D simulation" ], "kernelspec": { "display_name": "test", "language": "python", "name": "python3" }, "keywords": "photonic neural network, repeated phase encoding, optical classifier, structural nonlinearity, silicon photonics, inverse design, topology optimization, PhotonForge, SiEPIC, MNIST classification, matrix-vector multiplication, Tidy3D, FDTD", "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.13.0" }, "title": "Repeated phase encoding in an inverse-designed photonic classifier in Tidy3D | Flexcompute" }, "nbformat": 4, "nbformat_minor": 5 }