diff --git a/examples/13_retention_drift.ipynb b/examples/13_retention_drift.ipynb
new file mode 100644
index 0000000..d1895f5
--- /dev/null
+++ b/examples/13_retention_drift.ipynb
@@ -0,0 +1,603 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "07154d42-19ec-4b85-a1c9-fa32fcf3b903",
+   "metadata": {},
+   "source": [
+    "# XBTorch::Example 12:Retention & Drift\n",
+    "\n",
+    "## Introduction\n",
+    "\n",
+    "In many emerging memory technologies, programmed conductance values are not perfectly stable over time. Instead, devices may exhibit retention loss, conductance drift, and other forms of time-dependent behavior that gradually alter the physical state of the accelerator after deployment. These effects can lead to discrepancies between the conductances observed during inference and those originally programmed from the trained neural network.\n",
+    "\n",
+    "To enable deployment-time reliability studies, XBTorch provides configurable retention and conductance drift models as part of its hardware-aware inference framework. These models operate directly on the programmed conductance state and can be combined with other inference-time nonidealities such as programming error, read noise, stuck-at defects, and limited DAC/ADC precision.\n",
+    "\n",
+    "In this notebook, we demonstrate how to:\n",
+    "\n",
+    "1. Configure retention and conductance drift parameters in an XBTorch inference accelerator.\n",
+    "2. Evaluate the effect of increasing retention time on inference accuracy.\n",
+    "3. Evaluate the effect of different drift coefficients on inference accuracy.\n",
+    "4. Study deployment-time degradation using realistic, time-evolving conductance states.\n",
+    "\n",
+    "Throughout these experiments, the neural network weights remain unchanged; only the underlying hardware realization evolves according to the specified retention model. This allows us to isolate and study the impact of time-dependent conductance evolution on inference robustness."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8d79269c-e90b-4bd4-b0bd-7a42d74eb642",
+   "metadata": {},
+   "source": [
+    "## Getting Started\n",
+    "\n",
+    "Let's import necessary dependencies."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "929afff3-4807-47c1-ab90-fa9b993c9418",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# General imports\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import random\n",
+    "import time\n",
+    "import pickle\n",
+    "from pathlib import Path\n",
+    "\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "\n",
+    "from torchvision import datasets, transforms\n",
+    "from torch.utils.data import DataLoader, ConcatDataset\n",
+    "\n",
+    "from functools import partial\n",
+    "import torch.optim as optim"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "16d35280-9a4e-4dad-a47b-95b97d91186a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "W0604 19:19:33.322000 2608752 torch/utils/cpp_extension.py:2425] TORCH_CUDA_ARCH_LIST is not set, all archs for visible cards are included for compilation. \n",
+      "W0604 19:19:33.322000 2608752 torch/utils/cpp_extension.py:2425] If this is not desired, please set os.environ['TORCH_CUDA_ARCH_LIST'] to specific architectures.\n",
+      "/mnt/osama.yousuf1/xbtorch/env/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    }
+   ],
+   "source": [
+    "# XBTorch imports\n",
+    "import xbtorch\n",
+    "\n",
+    "from xbtorch.patches import xbtorch_model\n",
+    "\n",
+    "from xbtorch.nn.utils import test_classifier\n",
+    "\n",
+    "from xbtorch.deployment import SimpleFixedPoint, map_random, encode_simple_binary, encode_MAO, encode_LEA1, encode_LEA2, compute_error\n",
+    "\n",
+    "from nets.mlp import SimpleMLP"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d12c9e5b-9e1d-4d98-ba11-7a51ebdfb7d8",
+   "metadata": {},
+   "source": [
+    "Let's fix the seed for reproducibility, and initialize network and XBTorch-specific parameters."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "1d082657-2f38-4468-8793-9d2f5ffc7fe7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Using device: cuda:0\n"
+     ]
+    }
+   ],
+   "source": [
+    "seed = 0\n",
+    "\n",
+    "torch.manual_seed(seed)\n",
+    "np.random.seed(seed)\n",
+    "random.seed(seed) # controls weight updatejump table stochasticity\n",
+    "\n",
+    "# Check if CUDA is available and select the device\n",
+    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+    "print(f\"Using device: {device}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "779524a9-dd83-4443-baec-2b1392b449a1",
+   "metadata": {},
+   "source": [
+    "## Initialize XBTorch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c4e1bf6a-b7ba-40ee-80e9-59d3d86507e4",
+   "metadata": {},
+   "source": [
+    "Like last time, let's initialize the XBTorch library."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "174e1100-568a-43d7-9e1f-56123ff9f572",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "xb_size = (2500, 2500)\n",
+    "g_min = 133\n",
+    "g_max = 233\n",
+    "read_noise = 0.0\n",
+    "write_noise = 0.0\n",
+    "weight_encoding_scheme = encode_simple_binary\n",
+    "mapping_scheme = map_random\n",
+    "output_polling_mode = \"avg\"\n",
+    "adc_precision = dac_precision = 8\n",
+    "stateful = False\n",
+    "input_encoding_scheme = \"instant\"\n",
+    "\n",
+    "# Parameters not previously shown.\n",
+    "retention_time=10\n",
+    "drift_coefficient=0.05\n",
+    "drift_t0=0.5\n",
+    "drift_variation=0.5"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eb618857-d3ca-4c8c-aa27-745c4a6d3b79",
+   "metadata": {},
+   "source": [
+    "In the cell above, we initialize various XBTorch parameters pertaining to hardware-aware inference. The newly introduced retention and drift parameters are summarized below:\n",
+    "\n",
+    "| Parameter | Purpose |\n",
+    "|------------|----------|\n",
+    "| `retention_time` | Elapsed deployment time of the network on the accelerator |\n",
+    "| `drift_coefficient` | Nominal value of the drift coefficient, $\\nu$ |\n",
+    "| `drift_t0` | Reference time constant, $t_0$ |\n",
+    "| `drift_variation` | Device-to-device variation in $\\nu$. If set to `0.0`, all devices experience identical deterministic drift. |\n",
+    "\n",
+    "XBTorch models retention-induced conductance evolution using a power-law drift model similar to that employed in NeuroSim:\n",
+    "\n",
+    "$$\n",
+    "G(t) = G_0 \\left(\\frac{t}{t_0}\\right)^{-\\nu}\n",
+    "$$\n",
+    "\n",
+    "where:\n",
+    "\n",
+    "- $G_0$ is the programmed conductance,\n",
+    "- $G(t)$ is the conductance after retention time $t$,\n",
+    "- $t_0$ is a reference time constant,\n",
+    "- $\\nu$ is the drift coefficient.\n",
+    "\n",
+    "When `drift_variation > 0`, each device samples its own value of $\\nu$, allowing heterogeneous drift behavior across the crossbar array. Larger values of `retention_time` or `drift_coefficient` generally produce larger deviations from the originally programmed conductance state.\n",
+    "\n",
+    "For more details on the API and available inference accelerators, see the full XBTorch documentation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "3ccbdd9e-ac09-460f-88b0-70701346c219",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "inference_accelerator = SimpleFixedPoint(g_min=g_min, \n",
+    "                                         g_max=g_max, \n",
+    "                                         adc_bits=adc_precision, \n",
+    "                                         dac_bits=dac_precision, \n",
+    "                                         read_noise=read_noise, \n",
+    "                                         write_noise=write_noise, \n",
+    "                                         xb_size=xb_size,\n",
+    "                                         weight_encoding_scheme=weight_encoding_scheme, \n",
+    "                                         input_encoding_scheme=input_encoding_scheme,\n",
+    "                                         xb_mapping_scheme=mapping_scheme,\n",
+    "                                         stateful=stateful,\n",
+    "                                         retention_time=retention_time,\n",
+    "                                         drift_coefficient=drift_coefficient,\n",
+    "                                         drift_t0=drift_t0,\n",
+    "                                         drift_variation=drift_variation,\n",
+    "                                         device=device)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3352e60f-309e-44be-acb6-83f3934a97d2",
+   "metadata": {},
+   "source": [
+    "We can now initialize XBTorch. Recall that if a parameter is not provided, default values are utilized. The reader is directed to `XBParams.__init__()` for the underlying implementation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "07caa63f-2170-4457-9842-4cc01021c2b1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "wage_params = { \"wl_weight\": 2, # 2 = ternary weights\n",
+    "                \"wl_grad\": 8,\n",
+    "                \"wl_activation\": 8,\n",
+    "                \"wl_error\": 8,\n",
+    "                \"rounding_weight\" : \"nearest\",\n",
+    "                \"rounding_activation\" : \"nearest\",\n",
+    "                \"rounding_grad\" : \"nearest\",\n",
+    "                \"rounding_error\" : \"nearest\",\n",
+    "               }\n",
+    "\n",
+    "# Init xbtorch\n",
+    "xbtorch.initialize(pytorch_device=device,\n",
+    "                   inference_accelerator=inference_accelerator,\n",
+    "                   wage_quantize=True, # since the trained solution utilized wage quantization\n",
+    "                   wage_params=wage_params\n",
+    "                   )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91ed9cf6-646f-491c-bc37-6c81880b3898",
+   "metadata": {},
+   "source": [
+    "## Prepare the dataset\n",
+    "\n",
+    "We can now prepare the dataset for our neural network."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "be1c9077-2138-4b17-82ee-38d0187aa229",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define transforms to apply to the data\n",
+    "transform = transforms.Compose([\n",
+    "    transforms.ToTensor(),  # Convert images to tensors\n",
+    "    transforms.Normalize((0.1307,), (0.3081,))  # Normalize the image data\n",
+    "])\n",
+    "\n",
+    "# Load the MNIST training and test datasets\n",
+    "train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)\n",
+    "test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)\n",
+    "\n",
+    "# Create data loaders for batching and shuffling\n",
+    "train_loader = DataLoader(train_dataset, batch_size=4096, shuffle=True, generator=torch.Generator(), num_workers=4)\n",
+    "test_loader = DataLoader(test_dataset, batch_size=10000, shuffle=False, generator=torch.Generator(), num_workers=4)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2ef1caab-9b88-415c-86a5-f3d41cf1396f",
+   "metadata": {},
+   "source": [
+    "## Prepare the model\n",
+    "\n",
+    "We simply instantiate and load the state dictionary of our HWA pre-trained simple 2-layer perceptron network. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "e367f430-0b49-46b4-bbcb-bdbc4466866e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define the model\n",
+    "input_size = 28 * 28\n",
+    "hidden_size = 150\n",
+    "output_size = 10\n",
+    "\n",
+    "# Create Model\n",
+    "model = SimpleMLP(input_size, hidden_size, output_size).to(device)\n",
+    "model = xbtorch_model(model)\n",
+    "\n",
+    "# Override state dict. \n",
+    "# If we had dumped the final state_dict directly, model.load_state_dict(torch.load(..)) could be used instead\n",
+    "with open(\"checkpoints/hwa_train_mlp_hwa_example.pkl\", \"rb\") as f:\n",
+    "    full_weights_hwa = pickle.load(f)\n",
+    "    \n",
+    "epoch = -1 # load last epoch's weights\n",
+    "\n",
+    "for name, param in model.named_parameters():\n",
+    "    new_tensor = torch.from_numpy(full_weights_hwa[name][epoch, ...]).to(\n",
+    "        device=param.device,\n",
+    "        dtype=param.dtype,\n",
+    "    )\n",
+    "    param.data = new_tensor"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bdf4684e-77ba-4578-b0d9-9212ab5f6034",
+   "metadata": {},
+   "source": [
+    "## Baseline performance\n",
+    "\n",
+    "We can firstly compute the baseline test accuracy of our network. This is the accuracy before activating the inference accelerator (i.e. all computations of the network happen without the accelerator primitive's intervention)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "5f6953d2-d3d7-441a-a707-5614cc4f4a86",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "89.7\n"
+     ]
+    }
+   ],
+   "source": [
+    "baseline_acc, _ = test_classifier(test_loader, model, device)\n",
+    "\n",
+    "print(baseline_acc)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "839b6144-9133-43d5-a73e-160bcaee4e59",
+   "metadata": {},
+   "source": [
+    "## Retention Time Sweep\n",
+    "\n",
+    "We first investigate the effect of deployment time on inference accuracy.\n",
+    "\n",
+    "In this experiment, the drift coefficient is held constant while the retention time is varied over several orders of magnitude. As retention time increases, the programmed conductance values drift farther from their original states, resulting in increasing mismatch between the trained network parameters and the realized hardware conductances.\n",
+    "\n",
+    "For each retention time, inference is repeated multiple times to capture variability introduced by stochastic drift behavior."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "b602c2fb-5b6d-4d6d-88a9-fde89306b2d4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "iterations = 10\n",
+    "\n",
+    "retention_times = np.logspace(\n",
+    "    np.log10(0.5),\n",
+    "    np.log10(100),\n",
+    "    10\n",
+    ")\n",
+    "\n",
+    "model.xb_eval()\n",
+    "\n",
+    "ret_time_sweep_accs = np.zeros((len(retention_times), iterations))\n",
+    "\n",
+    "for j, ret_time in enumerate(retention_times):\n",
+    "    inference_accelerator.retention_time = ret_time\n",
+    "    for i in range(iterations):    \n",
+    "        acc, _ = test_classifier(test_loader, model, device)\n",
+    "        ret_time_sweep_accs[j, i] = acc"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "f28d5324-2eaf-4c52-9d07-4a737ec983fe",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Let's visualize results\n",
+    "\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "means = np.mean(ret_time_sweep_accs, axis=1)\n",
+    "stds = np.std(ret_time_sweep_accs, axis=1)\n",
+    "\n",
+    "plt.figure(figsize=(8,5))\n",
+    "\n",
+    "plt.errorbar(\n",
+    "    retention_times,\n",
+    "    means,\n",
+    "    yerr=stds,\n",
+    "    marker='o',\n",
+    "    capsize=4\n",
+    ")\n",
+    "\n",
+    "for i, t in enumerate(retention_times):\n",
+    "    plt.scatter(\n",
+    "        np.full(ret_time_sweep_accs.shape[1], t),\n",
+    "        ret_time_sweep_accs[i],\n",
+    "        alpha=0.5\n",
+    "    )\n",
+    "\n",
+    "plt.xscale('log')\n",
+    "plt.xlabel(\"Retention Time\")\n",
+    "plt.ylabel(\"Inference Accuracy (%)\")\n",
+    "plt.title(\"Impact of Retention Time on Inference Accuracy\")\n",
+    "plt.grid(True, alpha=0.3)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "206c02d9-68d0-43c5-b393-8d8a93508f36",
+   "metadata": {},
+   "source": [
+    "The figure above shows inference accuracy as a function of retention time.\n",
+    "\n",
+    "As expected, increasing retention time causes larger deviations from the originally programmed conductance values, which in turn degrades inference accuracy. The precise degradation trend depends on both the drift model parameters and the network's inherent robustness to hardware perturbations.\n",
+    "\n",
+    "This experiment demonstrates that XBTorch can capture deployment-time accuracy degradation arising from long-term conductance evolution."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f925ac76-b8c6-4e49-87bd-d970b5a34f63",
+   "metadata": {},
+   "source": [
+    "## Drift Coefficient Sweep\n",
+    "\n",
+    "Next, we hold retention time fixed and vary the drift coefficient $\\nu$.\n",
+    "\n",
+    "The drift coefficient controls the rate at which conductance evolves over time. Larger values correspond to more severe retention-induced drift and therefore larger deviations from the originally programmed device state.\n",
+    "\n",
+    "This experiment isolates the impact of device technology characteristics from deployment duration."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "148efbb6-4b33-40e2-9c13-dd58dde63d4f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "drift_coefficients = [0.0, 0.1, 0.25, 0.5, 1.0, 1.5, 2.0]\n",
+    "retention_time = retention_times[1]\n",
+    "inference_accelerator.retention_time = retention_time\n",
+    "\n",
+    "drift_coeff_sweep_accs = np.zeros((len(drift_coefficients), iterations))\n",
+    "\n",
+    "for j, drift_coeff in enumerate(drift_coefficients):\n",
+    "    inference_accelerator.drift_coefficient = drift_coeff\n",
+    "    for i in range(iterations):\n",
+    "        acc, _ = test_classifier(test_loader, model, device)\n",
+    "        drift_coeff_sweep_accs[j, i] = acc"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "98c42670-3d65-40a8-bd88-3c14bcd4f631",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxYAAAHqCAYAAACZcdjsAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQAApcRJREFUeJzs3Xd4U2X/BvD7ZKdp0r0XbRlll1GmDKGIOAAFEUFAkKGgLCcuhNeF/lReRQVUUJDxOnCgIrIERUbZyKYtULp307QZTc7vj9pAKaMpKem4P9fVi+ack5NvnpyU3DnneR5BFEURREREREREN0Hi6gKIiIiIiKj+Y7AgIiIiIqKbxmBBREREREQ3jcGCiIiIiIhuGoMFERERERHdNAYLIiIiIiK6aQwWRERERER00xgsiIiIiIjopjFYEBERERHRTWOwIKJatXLlSsTExEAul8PT09PV5Tjs1VdfhSAIri6j0erbty/69u1baVlmZiaGDx8OHx8fCIKAhQsXuqS2W+G3335DbGwsVCoVBEFAQUGBq0siIromBguiGvriiy8gCAL27dvn6lJu2q+//opXX33V6fs9efIkHnnkEURHR+PTTz/F0qVLb3ifQ4cO4eGHH0ZYWBiUSiW8vb0RHx+P5cuXw2q1Or1GVzt+/DheffVVnDt3ztWlOEVFEKv4cXNzQ3h4OO69914sX74cJpPpph9j1qxZ2LhxI+bMmYOVK1fizjvvrLVj+GY1adIE99xzT43um5ubixEjRkCtVuOjjz7CypUrodFonFxh/fTss89CEAQ8+OCDri6FiC4jc3UBROR6v/76Kz766COnfzD7448/YLPZ8N///hdNmza94fafffYZHnvsMQQEBGDMmDFo1qwZ9Ho9tmzZgkcffRTp6el44YUXnFqjqx0/fhzz5s1D37590aRJE1eX4zSffPIJ3N3dYTKZkJqaio0bN2LChAlYuHAhfv75Z4SFhVVrP7///nuVZVu3bsWQIUPw9NNP25ctWrSoVo5hV0pISIBer8d//vMfxMfHu7qcOkMURaxZswZNmjTB+vXrodfrodVqXV0WEYHBgohqUVZWFgBU6xKo3bt347HHHkP37t3x66+/VvqgMHPmTOzbtw///PNPbZVKTjZ8+HD4+vrab7/yyitYtWoVxo4diwceeAC7d+++7v1LSkrg5uYGhUJRZV1WVla9vKzOUY68f6rLYDDU+7Mef/zxBy5evIitW7di4MCBWLduHcaNG+fqsq6q4jgmajREIqqR5cuXiwDEhIQE+7Jx48aJGo1GPH/+vHj33XeLGo1GDA4OFhctWiSKoigeOXJEvP3220U3NzcxPDxcXLVq1VX3uX37dnHy5Mmit7e3qNVqxTFjxoh5eXmVtv3hhx/Eu+66SwwKChIVCoUYFRUlzp8/XywrK6tS6+7du8VBgwaJnp6eopubm9i2bVtx4cKF9poBVPm5kY8++khs1aqVqFAoxKCgIHHq1Klifn6+fX1ERESVfc6dO/ea+7vzzjtFmUwmnj9//oaPLYqiWFxcLM6ePVsMDQ0VFQqF2Lx5c/Gdd94RbTZbpe0AiNOmTRO///57sXXr1qJCoRBbtWolbtiwoco+//zzT7Fz586iUqkUo6KixMWLF4tz586t1B7JyckiAHH58uVV7n+153jx4kVxwoQJ9tepSZMm4mOPPSaaTCb7633lz7Zt20RRrP5r3KdPH7F169bisWPHxL59+4pqtVoMDg4WFyxYUKXG0tJSce7cuWKzZs1EpVIpBgYGivfdd5949uxZ+zZWq1V8//33xVatWolKpVL09/cXJ0+eXOUYvJqK9srOzr7q+smTJ4sAxN9//71K/fv27RN79eolqtVqccaMGfZ1ffr0EUVRvGZ71dYxfHlt1Wnbq4mIiBDvvvtu++2K4+edd94RlyxZIkZFRYkKhULs3LmzuHfv3kqPe7XnWWH37t3iwIEDRZ1OJ6rVarF3797iX3/9VemxK16LY8eOiQ899JDo6ekpxsbG2tevXLlS7Nixo6hSqUQvLy/xwQcfFC9cuFDj51/bx1aFRx99VGzVqpUoiqI4aNAgccCAAVfd7nrvvQr5+fnizJkzxYiICFGhUIghISHimDFj7MdvxTGXnJxcad/btm2r9F69vK2udhw76+/1smXLRADigQMHqtzv9ddfFyUSiXjx4sVqtyWRs/GMBZGTWa1WDBo0CL1798bbb7+NVatW4YknnoBGo8GLL76I0aNH4/7778fixYsxduxYdO/eHZGRkZX28cQTT8DT0xOvvvoqTp06hU8++QTnz5/HH3/8Ye9I/MUXX8Dd3R2zZ8+Gu7s7tm7dildeeQVFRUV455137PvatGkT7rnnHgQFBWHGjBkIDAzEiRMn8PPPP2PGjBmYMmUK0tLSsGnTJqxcubJaz/HVV1/FvHnzEB8fj8cff9xeY0JCAnbu3Am5XI6FCxdixYoV+P777+2XxbRr1+6q+yspKcGWLVvQu3dvhIeH3/DxRVHE4MGDsW3bNjz66KOIjY3Fxo0b8cwzzyA1NRXvv/9+pe3/+usvrFu3DlOnToVWq8UHH3yAYcOG4cKFC/Dx8QEAHD16FHfccQf8/Pzw6quvoqysDHPnzkVAQEC12uRq0tLS0KVLFxQUFGDy5MmIiYlBamoqvv32W5SUlKB3796YPn06PvjgA7zwwgto2bIlANj/re5rDAD5+fm48847cf/992PEiBH49ttv8dxzz6Ft27YYNGgQgPJj85577sGWLVswcuRIzJgxA3q9Hps2bcI///yD6OhoAMCUKVPwxRdfYPz48Zg+fTqSk5OxaNEiHDx40P761tSYMWOwdOlS/P777xgwYIB9eW5uLgYNGoSRI0fi4Ycfvmq79+7dGytXrsSYMWMwYMAAjB07FgAQHR1dK8ewI23rqNWrV0Ov12PKlCkQBAFvv/027r//fiQlJUEul+PFF19EixYtsHTpUsyfPx+RkZH212fr1q0YNGgQOnXqhLlz50IikWD58uXo168f/vzzT3Tp0qXSYz3wwANo1qwZ3njjDYiiCAB4/fXX8fLLL2PEiBGYOHEisrOz8eGHH6J37944ePBgpbMkdenYMplM+O677/DUU08BAB566CGMHz8eGRkZCAwMtG93o/eeQqFAcXExevXqhRMnTmDChAno2LEjcnJy8NNPP+HixYuVzrhV17WOY2f9vR4+fDimTZuGVatWoUOHDpUee9WqVejbty9CQkIcrpvIaVydbIjqq2udsQAgvvHGG/Zl+fn5olqtFgVBENeuXWtffvLkySrfcFfss1OnTqLZbLYvf/vtt0UA4o8//mhfVlJSUqWmKVOmiG5ubqLRaBRFURTLysrEyMhIMSIioso3sZd/sz9t2rRqfcMriqKYlZUlKhQK8Y477hCtVqt9+aJFi0QA4rJly+zLbvTtdYXDhw+LAOzf7t3IDz/8IAIQX3vttUrLhw8fLgqCUOkbUgCiQqGotKzi8T788EP7sqFDh4oqlarSGZPjx4+LUqm0xmcsxo4dK0okkkrHSIWK9v/mm2+qfPNZoTqvsShe+nZ7xYoV9mUmk0kMDAwUhw0bZl9W8W3ne++9d816/vzzTxFAlbNpv/3221WXX+lGr3l+fr4IQLzvvvuq1L948eIq219+xqIC/j0LdbnaOoar27bXcq0zFj4+PpW+pf/xxx9FAOL69evty672N8Zms4nNmjUTBw4cWOk9XFJSIkZGRlb69r7itXjooYcq1XTu3DlRKpWKr7/+eqXlR48eFWUyWaXldenYEkVR/Pbbb0UA4pkzZ0RRFMWioiJRpVKJ77//fqXtqvPee+WVV0QA4rp16665jaNnLK51HDvz7/VDDz0kBgcHVzp2Dxw4cM2/S0S3EkeFIqoFEydOtP/u6emJFi1aQKPRYMSIEfblLVq0gKenJ5KSkqrcf/LkyZW+uXv88cchk8nw66+/2pep1Wr773q9Hjk5OejVqxdKSkpw8uRJAMDBgweRnJyMmTNnVrlOu6ZDqG7evBlmsxkzZ86ERHLpT8ikSZOg0+nwyy+/OLzPoqIiAKh2B8xff/0VUqkU06dPr7T8qaeegiiK2LBhQ6Xl8fHx9m9MAaBdu3bQ6XT2trdardi4cSOGDh1a6YxJy5YtMXDgQIefDwDYbDb88MMPuPfee9G5c+cq66vT/tV5jSu4u7vj4Ycftt9WKBTo0qVLpePru+++g6+vL5588slr1vPNN9/Aw8MDAwYMQE5Ojv2nU6dOcHd3x7Zt22785K/D3d3d/nwup1QqMX78+Jvad3U5egxXp20d9eCDD8LLy8t+u1evXgBww30eOnQIZ86cwahRo5Cbm2t/fQwGA/r3748dO3bAZrNVus9jjz1W6fa6detgs9kwYsSISq9xYGAgmjVrVuU1rkvH1qpVq9C5c2f7YBBarRZ33303Vq1aZd+muu+97777Du3bt8d99913zW0cda3j2Jl/r8eOHYu0tLRK7bVq1Sqo1WoMGzasRnUTOQsvhSJyMpVKBT8/v0rLPDw8EBoaWuU/Kw8PD+Tn51fZR7NmzSrddnd3R1BQUKUhSY8dO4aXXnoJW7dutX8wr1BYWAgASExMBAC0adOmxs/nSufPnwdQHowup1AoEBUVZV/vCJ1OB6Dqh83r1RAcHFwliFRcQnRlDVe7vMrLy8ve9tnZ2SgtLa3S7kD587w80FVXdnY2ioqKbqrtq/MaV7ja8eXl5YUjR47YbycmJqJFixaQya79p//MmTMoLCyEv7//VddXdCiuqeLiYgBVQ2RISMhVO2rXBkeP4eq0raOuPCYrQsbV/h5c7syZMwBw3c7KhYWFlULLlZdanjlzBqIoXvV4B1DlcqS6cmwVFBTg119/xRNPPIGzZ8/al/fs2RPfffcdTp8+jebNm1f7vZeYmOj0D+LXOo6d+fd6wIABCAoKwqpVq9C/f3/YbDasWbMGQ4YM4ehY5HIMFkROJpVKHVou/nvNsyMKCgrQp08f6HQ6zJ8/H9HR0VCpVDhw4ACee+65Kt9Y1nVNmzaFTCbD0aNHa2X/zmz7a32T6ew5Nhx9jZ31HG02G/z9/St9A3y5K0OzoypG9rpy+OHLv9Gta5x5/NzsPite93feeQexsbFX3abirFCFK9vWZrNBEARs2LDhqnVcef+6cmx98803MJlMePfdd/Huu+9WWb9q1SrMmzfPoZpuxNH3+9WOY2f/vZZKpRg1ahQ+/fRTfPzxx9i5cyfS0tIqnVUichUGC6I66MyZM7j99tvtt4uLi5Geno677roLQPlwi7m5uVi3bh169+5t3y45ObnSfiou//nnn3+uOw6+I6f9IyIiAACnTp1CVFSUfbnZbEZycnKNxtt3c3NDv379sHXrVqSkpNxwjoOIiAhs3ry5yvj1FZcUVNRYXX5+flCr1fZvgy936tSpSrcrvgm+cgbkK7/l9vPzg06nu+EQuddq++q+xo6Ijo7Gnj17YLFYrtlJNjo6Gps3b0bPnj1r5cN+Refqml5idi2uPoZvlYr3tE6nq3Gd0dHREEURkZGRaN68udPqqu1ja9WqVWjTpg3mzp1bZd2SJUuwevVqzJs3r9rvvejo6BtuU933+/U4++81UH451Lvvvov169djw4YN8PPzc/p7iqgm2MeCqA5aunQpLBaL/fYnn3yCsrIy+wgsFd8gXv6Nodlsxscff1xpPx07dkRkZCQWLlxY5T/Gy+9bMa79ldtcTXx8PBQKBT744INK+/j8889RWFiIu+++u3pP8gpz586FKIoYM2aM/XKZy+3fvx9ffvklAOCuu+6C1WrFokWLKm3z/vvvQxAEh0fqkUqlGDhwIH744QdcuHDBvvzEiRPYuHFjpW11Oh18fX2xY8eOSsuvbHuJRIKhQ4di/fr1V52dvaLtrtX21X2NHTFs2DDk5ORUabfLH2fEiBGwWq34z3/+U2WbsrKyah0j17J69Wp89tln6N69O/r371/j/VxNXTiGb4VOnTohOjoa//d//3fV90l2dvYN93H//fdDKpVi3rx5Vc46iKKI3Nxch+uq7WMrJSUFO3bswIgRIzB8+PAqP+PHj8fZs2exZ8+ear/3hg0bhsOHD+P777+/5jYVH/Yvf79brVYsXbr0Oq1RmbP/XgPl/cTatWuHzz77DN999x1Gjhx53cvQiG4VHoVEdZDZbEb//v0xYsQInDp1Ch9//DFuu+02DB48GADQo0cPeHl5Ydy4cZg+fToEQcDKlSur/OcjkUjwySef4N5770VsbCzGjx+PoKAgnDx5EseOHbN/aO7UqRMAYPr06Rg4cCCkUilGjhx51dr8/PwwZ84czJs3D3feeScGDx5srzEuLq7Gp+N79OiBjz76CFOnTkVMTEylmbf/+OMP/PTTT3jttdcAAPfeey9uv/12vPjiizh37hzat2+P33//HT/++CNmzpxZqaN2dc2bNw+//fYbevXqhalTp6KsrAwffvghWrduXeVa+okTJ+Ktt97CxIkT0blzZ+zYsQOnT5+uss833ngDv//+O/r06YPJkyejZcuWSE9PxzfffIO//voLnp6eiI2NhVQqxYIFC1BYWAilUol+/fpV+zV2xNixY7FixQrMnj0be/fuRa9evWAwGLB582ZMnToVQ4YMQZ8+fTBlyhS8+eabOHToEO644w7I5XKcOXMG33zzDf773/9i+PDhN3ysb7/9Fu7u7jCbzfaZt3fu3In27dvjm2++qfFzuJa6cAzfChKJBJ999hkGDRqE1q1bY/z48QgJCUFqaiq2bdsGnU6H9evXX3cf0dHReO211zBnzhycO3cOQ4cOhVarRXJyMr7//ntMnjy50qzm1VHbx9bq1avtw0xfzV133QWZTIZVq1aha9eu1XrvPfPMM/j222/xwAMPYMKECejUqRPy8vLw008/YfHixWjfvj1at26Nbt26Yc6cOcjLy4O3tzfWrl2LsrKyareNs/9eX97mFa9TXT5mqZG5NYNPETU815sg70oVEydd6cqhKK+cIM/Ly0t0d3cXR48eLebm5la6786dO8Vu3brZJ6x69tlnxY0bN1516NK//vpLHDBggKjVakWNRiO2a9eu0lCrZWVl4pNPPin6+fmJgiBUa9jORYsWiTExMaJcLhcDAgLExx9/vMoQidUdbvZy+/fvF0eNGiUGBweLcrlc9PLyEvv37y9++eWXlYZX1Ov14qxZs+zbNWvW7LoT5F0pIiKi0oRjoiiK27dvFzt16mSfwOpqE+SJYvnQkY8++qjo4eEharVaccSIEWJWVtZVJ8g7f/68OHbsWNHPz88+8d60adMqTdL16aefilFRUfahbStev+q+xtc6vsaNGydGRERUqf3FF18UIyMjRblcLgYGBorDhw8XExMTK223dOlSsVOnTqJarRa1Wq3Ytm1b8dlnnxXT0tKqPM7lKtqr4kelUomhoaHiPffcIy5btqzSMLk3qr9iXXWGm62tY9iRtr2a602Qd6Urj5+r/Y2pcPDgQfH+++8XfXx8RKVSKUZERIgjRowQt2zZYt/mRu+/7777TrzttttEjUYjajQaMSYmRpw2bZp46tSpGj3/2jy22rZtK4aHh19zvSiKYt++fUV/f3/RYrGIoli9915ubq74xBNPiCEhIaJCoRBDQ0PFcePGiTk5OfZtEhMTxfj4eFGpVIoBAQHiCy+8IG7atKna70NRdO7f6wrp6emiVCoVmzdvft12IbqVBFG8ia+/iMipKiaOSkhIuOowiURERACQk5ODoKAgvPLKK3j55ZddXQ4RAPaxICIiIqp3vvjiC1itVowZM8bVpRDZsY8FERERUT2xdetWHD9+HK+//jqGDh2KJk2auLokIjsGCyIiIqJ6Yv78+fj777/Rs2dPfPjhh64uh6gS9rEgIiIiIqKbxj4WRERERER00xgsiIiIiIjopjX4PhY2mw1paWnQarUQBMHV5RARERER1RuiKEKv1yM4OBgSyfXPSTT4YJGWloawsDBXl0FEREREVG+lpKQgNDT0uts0+GCh1WoBlDeGTqdzSQ02mw3Z2dnw8/O7YdKja2M7Ogfb0TnYjs7BdnQetqVzsB2dg+3oHHWhHYuKihAWFmb/TH09DT5YVFz+pNPpXBosjEYjdDod31w3ge3oHGxH52A7Ogfb0XnYls7BdnQOtqNz1KV2rE6XAr7SRERERER00xgsiIiIiIjopjFYEBERERHRTWOwICIiIiKim8ZgQUREREREN43BgoiIiIiIbhqDBRERERER3TQGCyIiIiIiumkMFkREREREdNMYLIiIiIiI6KYxWBARERER0U2TubqAhiq1oBT5BjMKio1YsPEkFFYjzFIVnhsYA093Fbw0CoR4ql1dJhERERGRUzBY1ILUglL0+78/YCqzXbGmGA8v3wcAUMok2Pp0X4YLIiIiImoQeClULcg3mK8SKiozldmQbzDfooqIiIiIiGoXg0UtKCg2OnU7IiIiIqK6jsHCyY6nFeL5749Wa9vnvz+K42mFtVwREREREVHtY7Bwsnnrj+Nigala214sMGHe+uO1XBERERERUe1jsHCyufe2QqinslrbhnoqMffeVrVcERERERFR7WOwcLJWwR5467621dr2rfvaolWwRy1XRERERERU+xgsaoGnu6pa2607lA6bTazlahoGm2hDWnEaUotTkVacBpt4/VG3iIiIiOjW4jwWtcBLo4BSJrnhkLPrDqbCYC7Dwgc7QK2Q3qLq6p+kgiRsubAFyQXJ0Jg0MKQZEOkZif7h/RHlGeXq8oiIiIgIDBa1IsRTja1P973uzNsJyXl4c8NJbDyWiQeX7sJnYzvDX1e9Mx2NSVJBEladWIV8Uz4C1YHwlnojT5aHE3knkGHIwOiWoxkuiIiIiOoABotaEuKp/ndWbQ/0aOaHrKws+Pv7QyIpv/qsTYgH2oR6YPKKfThysRBDP9qJZePjEBOoc34xNhtQmAKYiwGFO+ARBkjq/lVwNtGGLRe2IN+Uj2iPaAgQILFK4K5wR7QiGomFidhyYQuaeDSBRKj7z4eIiIioIWOwcKG4Jt74fmpPTPgiAUk5Bgz/ZBcWjeqAvi38nfcg2aeAE+uBnDNAmRGQqQDfZkDLewG/Fs57nFqQbkhHcmEyAt0CAQBF5iKYzWYYpUZoFVoEugUiuTAZ6YZ0hLiHuLhaIiIiosaNX/O6WBNfDdZN7YFuUd4oNpVhwhcJWLnrnHN2nn0K2L0YSDsMSGSAyrP837TD5cuzTznncWqJwWKAyWqCscyIg1kHsS9jH84WnMW+jH04mHUQxjIjTFYTDBaDq0utN0SbDebUNJgvpsKcmgbRxk7wRERE5Bw8Y1EHeLopsGJCV7zw/VF8u/8iXv7xGJJzSvDi3S0hlQg126nNVn6mIv8cYCsD8hLL/5XIADef8suiTv4M+DSrs5dFaeQamK1mHMo+BKvNCq1cC42ggUpUIbskG3nGPIS4h0Aj17i61HrBlJgI/abNMCYnoUjjDomhGKrIKGgHxEMZHe3q8oiIiKieq5ufKBshhUyCd4a3wzMDyy9PWrYzGVNW7oPBVFazHRamABf3AcWZ5T9yNeDmXf5vxbKUhPLt6qgAtwCYrCYUmgrhqfSEQqqABBIopAp4Kj1RaCqEyWpCgFuAq0ut80yJichbuRLGE8ch9fSCLCAAUk8vGE8cR97KlTAlJrq6RCIiIqrnGCzqEEEQMO32plg0qgMUMgk2n8jCiCW7kFFodHxnpqLysxVWS/kZCpkSECTl/7r5AFYzUHCufLs6KrMkE0qpEh5KDxSYC2C2mmGDDWarGQXmAngoPKCUKpFZkunqUus00WaDftNmWPPzoYhuCqm7OwSpBFJ3dyiim8Kanw/95i28LIqIiIhuCoNFHXRPu2CsndwNPhoFjqUVYchHf+Gf1ELHdmLSA5YSQK4ChCsupxIEQKYGzCXl29VRBosBCqkCsf6x8FX7wmg1wmAxwGg1wlfti1j/WCikCvaxuAFLWjpMyUmQBQZBuOJYEAQBsoBAmJISYUlLd1GFRERE1BAwWNRRHcO98MO0nmjq747MIhNGLNmFzccd+GZeoQXkboDFCIhi+YhQZkP5v6IIlJUCCk35dnVQVpERF3MEGIq9oS/yRIisGyJUt0EntEaE6jaEyLpBr/eEodgbF3MEZBXV4KxOI2EzGCAaTZCo1VddL3Fzg2gyw2ZgQCMiIqKaY+ftOizM2w3fPd4D01YdwF9nczB55T68dHcrjO/ZpMo3z1WodIBXEyD7NJB9ErBZAYgABEAiBdRegGdE+XZ10Ko9F/DfLWcAxN5w29/+Oo0Z/UXMGtC81uuqjyQaDQSVErbSUkjd3aust5WUQFAqINGwEzwRERHVHINFHeehlmP5+Di88uM/WLM3BfN/Po5zuQa8ck8ryKRXP+GUVWREVrEOkLUGDBmARQaINtiDhSABrG5AYBugWAd/qbHOzfo9ums4BrQKwEX9Raw4tgKJ+SnIPDsaAOAd9QUUMgFRHpEY23osQrWh8NcqXVxx3SUPDoIyMgrGE8chiW5a6dI4URRRlpkBVavWkAcHubBKIiIiqu8YLOoBuVSCN+5ri0hfDd7ccBIrdp3HhbwSfPhQB2hV8irbX/q2v+O/P1dRCuAAgAN/Y0b/ZnXu235/nQr+OhVyUw4hH0cgKovt6xRuWYBgQj70UGty0CaktQsrrfsEiQTaAfGwZKTDnHgW0oBAiAoFrHo9rJkZkHp5QxvfH0IdHXaYiIiI6gcGi3pCEARM7h2NcG83zPzfIfxxKhsPLN6Fzx+JQ4hn5WvnR3cNx4CQMuD3VwBTEYyiDMMLpgEAvtUuhEomASACSh1wx3z4h4a74BndWJmtDKtOrEJJWQm0Mndk/btcgAB3uRYlZSVYdWIVeob0hEzCQ/l6lNHR8B4zxj6PRZnVCmuxHqpWraGN7895LIiIiOim8dNYPXNnmyD8z0ONiSv24WSGHkM/2onPx3VGu1BP+zb+OhX85WmA7STg5Y8SiQooKF/XyleAm1xa3nm7+CQgTwN0rVzyXG7kcPZhJBUkwWK1wFB2aVQsi9WMArMBcokcSQVJOJx9GJ0COrmw0vpBGR0NeUQEDAcPwZydDQ8/P2g6xEIi458BIiIiunm89qEeah/miR+m9URMoBbZ+vIRo377J+OKrcRL/17ez1umunRbuHy7uienNAdF5iIYy4wQxUt1SiRSiKIIY5kRReYi5JTmuLDK+sOUmIi8zz5H4bffoGTfPhR++w3yPvuck+MRERGRUzBY1FMhnmp881h39GnuB6PFhsdX7cfSHYmXPoD7NAPUnkBpQdXsIKJ8udqzfLs6ShRFmExusJQGQjSF2pdbjUGAKQyW0kCYTG6VQgddHWfeJiIiotrGayDqMa1Kjs/Hdca89cexcvd5vPHrSSTnlGD+kNaQe4YDTW4DTv0KGC77Rr/MBJjzANEKRPQCPOtm/woAMJQqUHh2JiBW7qCemzju0g3BAkN3xa0trJ65cuZtCIJ95m1pdFOYE89Cv3kLFJGR7MBNRERENcZPEfWcTCrB/CGt8fI9rSAIwJq9FzDhiwQUma1A5/FASKfyeSsqGPXlt0M6AZ0fAerwB8kSk7RKqKhClJdvR9fEmbeJiIjoVuAZiwZAEAQ8elskIrzdMH3tQfx5JgfDPv4bb97fFqqWM2GU/Qmklm97XBMHVUAzILIXvOThCHFt6ddktFihgi+A4htuG6QJrP2C6qmsIiNSzueiwKSAXOYJwSyBCKBIkEFnVkAAIMq9YDGXIuN8LsJ0PnVuThMiIiKqHxgsGpD4VgH4ekp3PPplAs5kFWP44l3/rom0bzP87B3AWQA7L0IpS8PWp/tWGa7WWcqsNhQZy1BYakFBiRmFpRb7T0FJ+U/5bbN9WWGpBQWlFpjLbNV+nMPnRAS4FaJZgDtUcp69uFz5nCYpgKobkHudDZVhwPoUzChR1bk5TYiIiKh+YLBoYNqEeOCHaT0x6tM9SM4xXHdbU5kN+QbzdYOFKIooMVtRcHk4uCwAVASColILCkrNl8JCiQV6U9lNPReJANiq0S/7w62J+HBrIqQSAU393NEqWIdWQTq0CtahZZAO3prG2wdjdNdwxMf4oXDd9yg9fgylVmC6bz8AwPtnvoObpw4SmRTq1m3gcd9QBHjUTsgkIiKiho/BogEK8lDj7WHt8MCSXTfc9qdDqdh0PPOyMwlme2go+jc0lFXn0/11uCtl8FDL4aGWw9Pt0r86tRyeakWl5Zdvdy7HgHsX7bzh/tuFeuBCXgkKSiw4lanHqUw9vj+Yell7qOxBo1VQedgI93aDRCJcZ68NQ8UM5vp2Ucj8eS2KC/RA//Jg0STtDNTnSiHz9kbAyHuhDfNycbVERERUnzFYNFBqRfUuCVr6Z3K1tlNIJfCoCAUVAcB+WwEPtQyebgr78optdGo55NKadRC/sqPxtbxxX1u0DtYhvdCIE+lFOJ5WhOPp5T/nc0uQXmhEeqERW05m2e+jUUjR8rKw0SpYh+YB2gZ5KZVos8GwaxdsZjOguNQZXpBIAIUcNrMZhl274N6nN0eFIiIiohpjsGiobNXro9CrqS/CfdwunUlQK8rPJLjJKy1TySXV/qDvLDaxes/BJtogCAKCPdUI9lSjf8sA+zq90YKTGfrysPFv4DiVqYfBbMW+8/nYdz7fvq1UIiDaT3PZ2Q0PtAzSwsdd6fTndiuZU1NRsncvJColFP5B9uXysDAoZQKs2VkoSUiAOTUVyrAwF1ZKRERE9RmDRUNVnFmtzZ7r6YE2LWNquZiasQgFkEhssNmu/S26RGKDRSgAcPXLeLQqOeKaeCOuifel/VptSMo2lJ/d+PcMx7G0QuSXWHA6sxinM4vxw6E0+/YBOmWlsNEqWIeIenQplTn5HKxFhZD6+FYKh4JSAcFWBolWB2teLszJ5xgsiIiIqMYYLBoq8/U7bju8nQto3SwY2GsXfBQRsNmkWL2l/Nv2Uf3SIZMBNtGKXPN5aN1aOLRfuVSCFoFatAjUYmiH8gF3RVFEZpEJx9ML7Wc2TqTrkZxjQGaRCZlF2dh2Ktu+D7eKS6ku6yTeIkBb7UvQbjkRuGYMEgRcZy0RERFRtTBYNFTmG8//4NB2LqCRa+DlDuiUhZAL7vblak0uvN3cYbAYYDOVb3ezBEFAoIcKgR4q9Iu5dClVsakMpzIu67eRVoSTGXqUmK3Yfz4f+y+7lEoiAFF+7pU6ircK1sHXxZdSKZo0gdTDA9aiIogqt0rrRFGErbAQUg8dFE2auKZAIiIiahAYLBooL6kRSlhgwrVnrlbCAi+p8RZW5ZggTRAiPSKRkJkAsxkAIgAABzIPwttNA6lUiriAOARpgq67n5vhrpShU4Q3OkVcupSqzGpDco7B3kG8ov9GrsGMs1nFOJtVjJ8OX7qUyl+rtJ/VqAgbTXw0kN6iS6kUoSFw69IFxVu3wpqXj4pZEW0mM6xF+YDNBre4LlCE1tXpEomIiKg+YLBooEK0Emz1+A/yTRIYRSmGm14GAHyrfhMqsRSABF5KESHaN11b6HVIBAmaezXHz0k/o6j0UgCSQIJzRefgrnBHc6/mkAi3diQjmVSCZgFaNAvQYkjspUupsvUmHLtsVKoTaUVIzjUgS29C1qls/HHZpVRquRQxQdpKZzdiAnW1cimVIJHA68ERKMvOhjHx0ihgtuJiCFIJlG3bwuvBERwRioiIiG4Kg0VD5R2NELkeIdZClAgawFS+uJXkPNykImCzAHIPwDvatXVeQ1aRERlFpdiemAy1tTmkgoiKj8QFend4uwVCapVie2IyvIR2CNSp4a9TuaxeQRDsc0bc3sLfvrzEXHZpVCr7pVRFKLVYcfBCAQ5eKLBvKxGASF8NWgWXj0ZVETr8tTf/vJTR0fB7YhqsGzYBF8uXyYMCoe0YC487BkAZXTePAyIiIqo/GCwaKkEAlB6ASQ9YLZeWi2L5bYmkfP0tHkK2ulbtuYD/bjkDwA9A30rrEk8MQeK/v+8GsAx/Y0b/Zpg1oPmtLbIa3BQydAz3QsfwS6NWWW3ipUupLgscOcUmJGYbkJhtwPrDl/bh666s1GejVZAOkb6OXUqVWlCKzBwjci2XZiFPdPNHjkkOTY4RAT6l152BnYiIiOhGGCwaKksJ4OYNGDIBq/XSchGAYAOkyvL1lhKXlXg9o7uGo3moEV8d/wo5pTnQm/WACARLg5FmTQMEQKvQwlfth4dbjUZcSLirS642qURAU393NPV3x+D2wfblWXojTqRffnajEEk5BuQUm7DjdDZ2nL50KZVKLkFMoK5S342YQC00yqpv6dSCUtz+zjaYrSKASx3Tn1B3BTIAfH8OCul5bHvmdoYLIiIiqjEGi4ZK7gaYSwCFFpArgIr8oNQACk8AYvl6udt1duI6/joV2gleMJw8Cb2QBblaDqVUCR+JJ4ps+TBZTdDbUqCW+KNdqJdTLhdyNX+tCv5aFfo097MvKzGX4VSG3n5W48S/w+CWWqw4lFKAQykF9m0FAYj00aDlZWc3WgfpkFtU+m+ouDazVUSe3shgQURERDXm0mBhtVrx6quv4quvvkJGRgaCg4PxyCOP4KWXXrJP5CWKIubOnYtPP/0UBQUF6NmzJz755BM0a9bMlaXXAwIAEZAqAE0oUPFlt1cEIJcC+gxAEFGX5y+wiTbozXrYRBtUUhUkkvLZv6USKVRQlYeLf9c3VG4KGTqEe6HDFZdSnc+teilVlt6EpBwDknIM+OVIun17D2X1OoSXZecAYVefaJCIiIjoRlwaLBYsWIBPPvkEX375JVq3bo19+/Zh/Pjx8PDwwPTp0wEAb7/9Nj744AN8+eWXiIyMxMsvv4yBAwfi+PHjUKnq/7fUtSGryIisi3mAtCWAfBgLLn3wPm7yh8pQBEijAYkXcDEP/rJAl3Z8vpYUfQoAQCVTwWgzQgklRIkIq80Kk80ElUxl3y5CF+HKUm8pqURAlJ87ovzccU+7S5dSZetN/57RuBQ2ErOLUWiyXmdvl9hKS2urZCIiImoEXBos/v77bwwZMgR33303AKBJkyZYs2YN9u7dC6D8bMXChQvx0ksvYciQIQCAFStWICAgAD/88ANGjhzpstrrsvKOz+kAhlZZNzztocoLktIxo797nez4DAByiRyeck+UlJXAVGaCBRaU2cqgkWmglqlhsNTdmcNvNT+tEn5aP/S+7FIqo8WKn7Yfx7ObL9zw/hI1L4MiIiKimnNpsOjRoweWLl2K06dPo3nz5jh8+DD++usvvPfeewCA5ORkZGRkID4+3n4fDw8PdO3aFbt27WKwuIbRXcMxIMYPOLQKyDkDeEYAFkP5ELMSOSDXAAXnAb9mQPvR8Peomx8oI3QR8FB6oKSsBIFugSizlcHb5g2LxAKZRIYcYw48lB6N6myFo1RyKWKahwDVCBbvH8jDc4GFaB3scQsqIyIioobGpcHi+eefR1FREWJiYiCVSmG1WvH6669j9OjRAICMjAwAQEBAQKX7BQQE2NddyWQywWQy2W8XFRUBAGw2G2w211yLb7PZIIriLXt8X3cFfN0VgDIe2J0ElB4GtMGA4t8O3fqzgK8P0CUe8PWw11jXBLkFobN/Z2xP3Y4CUwF0Mh3kEjkkogQFpgKIolg+87ZbUJ2sv64wZ2XfeCMAO87mYMcHf6FXM19M6R2F7lHe9r5OVNWtfl83VGxH52FbOgfb0TnYjs5RF9rRkcd2abD4+uuvsWrVKqxevRqtW7fGoUOHMHPmTAQHB2PcuHE12uebb76JefPmVVmenZ0No9F4lXvUPpvNhsLCQoiiCMktnd3YE2gxCkhJAIrSgJJiQKIAfLsBoXGAzRPIyrqF9ThuoO9AWIutSC9Oh1gmQg01POABT8ETwR7BuMPnDuRk57i6zDot98KNz1YAQJy3gP35Iv48k4M/z+Qgxt8ND3cOwO1NvRyaM6OxcN37umFhOzoP29I52I7OwXZ0jrrQjnq9vtrbujRYPPPMM3j++eftlzS1bdsW58+fx5tvvolx48YhMDAQAJCZmYmgoCD7/TIzMxEbG3vVfc6ZMwezZ8+23y4qKkJYWBj8/Pyg0+lq78lch81mgyAI8PPzu/UHhb8/EB0LFF0EzMWAwh3QhZZPkFcP+Pv7Q+ujxZbzW3Ay9yTKTGVQKBVo6dsS/cL7IdIj0tUl1nkRahnkVgMsUvk1t5FbLfhPWw+o4+Lw+V/n8PX+FJzMKsFLvyYj3DsDE2+LxPBOoVDJqzfCVGPg0vd1A8J2dB62pXOwHZ2D7egcdaEdHRksyaXBoqSkpEojSaVS+ymXyMhIBAYGYsuWLfYgUVRUhD179uDxxx+/6j6VSiWUSmWV5RKJxKUHtiAIrq1BEC79SCT1JlgAQLRXNCI9I5GmT0NmViYC/AMQrA2GRKg/z8GVQn3dsWz3GyiQq1Gm0WJW61EAgPeOr4XKaoG1tASellKEjngD7r7umD+0DWYOaI4v/z6HFbvO4UJeKV756Tj+u+UsHunRBGO6R8DTTXGDR20cXP6+biDYjs7DtnQOtqNzsB2dw9Xt6MjjujRY3HvvvXj99dcRHh6O1q1b4+DBg3jvvfcwYcIEAOUNOXPmTLz22mto1qyZfbjZ4OBgDB061JWl1x/Zp4AT68s7cZcZAZkK8G0GtLwX8Gvh6uqqTSJIEOweDFmJDP7u/gwVDpC6axHkJoFfXgaMxnz78mh9BpSlesBqg8zbG1J3rX2dt0aBWQOaY0qfKHyz7yI+/TMJF/NL8e6m0/hkeyJGxoXj0V6RnFCPiIiI7FwaLD788EO8/PLLmDp1KrKyshAcHIwpU6bglVdesW/z7LPPwmAwYPLkySgoKMBtt92G3377jXNYVEf2KWD3YqAkF/AIKR8NymIA0o8AhalAt8fqVbigmpFqtVBERwNCMgR9iX25zWyCRCKFxNMTiqgoSLXaKvd1U8gwrkcTjO4ajl+OpmPx9iScSC/Csp3J+HLXOQxuH4zJvaPQMsg1lxkSERFR3eHSYKHVarFw4UIsXLjwmtsIgoD58+dj/vz5t66whsBmKz9TUZIL+MWUXwIFAEod4KcFsk8CJ38GfJrVq8uiyHHy4CC4tWsP0WSC/LK58qSeXlD4ekGQSeHWPhby4KBr7kMmlWBIbAgGtw/Gn2dysGRHInaezcX3B1Px/cFU9G3hhym9o9GNI0kRERE1Wi4NFlSLClPKL3/yCLkUKioIAqALAbJPl2/nxXkgGjJBIoF2QDwsGekw5RXal6vbtYPUUAiZtw+08f0hVCNgCoKA3s3LJ+E7erEQi3ckYsPRdPxxKht/nMpG+zBPPNY7Cne0DuRIUkRERI0Mv6puqMzF5X0q5Jqrr1e4la83F9/ausgllNHR8B4zBuqYlpcW2sqgbt0G3mMehjI62uF9tg31wEejOmLb030xplsElDIJDqcU4PFVBxD/3nas3nMBRov1xjsiIiKiBoHBoqFSuJd31LYYrr7eXFK+XuF+a+sil1FGR8N7wiP22z5THoPPpIk1ChWXi/DR4D9D22Dn8/0wvV9TeKjlSM4x4IXvj+K2Bdvw0bazKCyx3GT1REREVNcxWDRUHmHloz8VpgKiWHmdKAJFqYBf8/LtqNG4/HInRXBQtS5/qi5fdyVm39ECfz/fD6/c0wohnmrkFJvwzsZT6PHWFrz283GkFZQ67fGIiIiobmGwaKgkkvIhZd18yjtqG4sAW1n5v9knAY0PEHMPO26T02mUMky4LRJ/PNMX7z/YHjGBWhjMVnz2VzJ6v70NT319GKczqz+LJxEREdUP7LzdkPm1KB9StmIeC31a+eVPwe3LQwWHmqVaJJdKcF+HUAyNDcH209lYsj0Ju5Jy8d2Bi/juwEX0j/HHlD7RiGvixZGkiIiIGgAGi4bOr0X5kLKFKeUdtRXu5Zc/8UxFoyT+O6s9AJjT0iE2CXPq5VBXIwgC+rbwR98W/jiUUoClOxKx4Z8MbDmZhS0ns9Ah3BNTekfjjlYBkHAkKSIionqLwaIxkEg4pGwjlVVkRJbeBAAwX7yIvF17AfgDAHYvWQldcDDcunWFIjQUAOCvVcJfV3uTT8aGeeLj0Z2QnGPAp38m4dv9F3HwQgEe+2o/onw1mNw7Cvd1DIFSJq21GoiIiKh2MFgQNWCr9lzAf7ecuWyJv/23qUIHIB3A9+cAnAMAzOjfDLMGNK/1uiJ9NXjjvraYFd8cX/ydjJW7ziMpx4Dn1x3Fu5tOY0LPSIzuFg6dSl7rtZDriDYRRbmlKMothUpaCg8fNwg8a0VEVG8xWBA1YKO7hiM+xg+F676HKTkJ8tAwQBBQpFRAZzIDogjLxRQoo6Lhcd9QBHiob2l9flolnhkYg8f7NsXavRfw+V/JSC80YsFvJ/HRtrMY3TUc43tGItCj9s6ikGvkpRuQdCgbeRnFsAjFOCca4B3ojqhYP3gHXWP+HSIiqtMYLIgaMH+dCp5FuchOOwVpgBekSgtEAPkqCbxEMwQAVn8NrKkn4SeUQKHzckmd7koZJvaKwtjuTbD+cBqW7EjE6cxiLNmRhGU7kzE0NgRT+kShqb/WJfWRc+WlG3BkawqMBgs0ngoolUpITHLkpOhRnGdEu35hDBdERPUQe/ASNXA2gwGi0QSJ+upnIyRubhBNZtgM15hM8RZSyCQY1ikUG2f2xrJHOqNLpDcsVhHf7L+I+Pd2YOKX+7DvXJ6ry6SbINpEJB3KhtFggVegGxQqGQRBgEIlg1egG4wGC5IOZUO0iTfeGRER1Sk8Y0HUwEk0GggqJWylpZC6V51p3VZSAkGpgERTd74hFgQB/WIC0C8mAAcu5GPJ9kT8fjwTm0+U/3SK8MJjfaLRP8afI0nVM/o8I/IzDHD3VEIQBIiXTeApCAI0nkrkZxigzzNC53trL80jIqKbwzMWRA2cPDgIysgolGWkV/oQBwCiKKIsMwPKqGjIg4NcVOH1dQz3wpIxnbF5dh881CUMCqkE+8/nY9KKfbhj4Q58vS8FpjKrq8ukarKYrLBabJAprz7yl1whhdVig8XE15SIqL5hsCBq4ASJBNoB8ZB6ecGceBZWvR6i1QarXg9z4llIvbyhje9f6/NZ3KxoP3e8eX87/PXc7Xi8bzS0KhnOZhXj2W+PoPfb27BkeyL0Roury6QbkCulkMolKLtGcLCYrZDKJZBfI3gQEVHdVbc/SRCRUyijo+E9ZgxULVvBWliAsqwsWAsLoGrVGt5jHoYyOtrVJVabv06F5+6Mwd/P98MLd8UgQKdEZpEJb244iR5vbsVbG04iq8jo6jLpGrTeKngFalBcYLrqGTRDgQlegRpovTkSGBFRfcM+FkSNhDI6GorISJhS02DLzIRvQACUIcF1/kzFtWhVckzuHY1HekTih0OpWLojCWezirF4eyKW/ZWM+zuGYFLvKET7Ve1XQq4jSARExfqhOM+IvHQD5CopbAoLzGYjLEYr1FoFomL9OJ8FEVE9VD8/URBRjQgSCRQhwVCEhkBRj0PF5RQyCUZ0DsPvM3vjs7Gd0TnCC2arDWsTUhD/3nZMWbkPBy7ku7pMuox3kAYRbX1hLrUi7XQ+si/okXY6H2ajFRFtfDnULBFRPcUzFkSNiGizwZyaBnNmJsyWsnp9xuJKEomA+FYBiG8VgH3n8rBkRxI2Hc/ExmPlP12aeGNKnyjc3oIjSblaXroB54/mQKGWIqS5F6yKEkjNbjAbrTh/NAcefmqGCyKieojBgqiRMCUmQr9pM4zJSSjSuENiKIYqMgraAfH1qo9FdXRu4o3OTbxxNkuPpTuS8P3BVOw9l4e95/LQPMAdk3tHY3D7YChkDSNU1SeXz2NRER5MsECpKe9TkZ9RgqRD2fAKcOPlUERE9Qz/VyVqBEyJichbuRLGE8ch9fSCLCAAUk8vGE8cR97KlTAlJrq6xFrR1F+Lt4e3x1/P9cOU3lFwV8pwOrMYT39zGH3e2YbP/kxCsanM1WU2KlfOY3G5K+exICKi+oXBgqiBE2026DdthjU/H4roppC6u0OQSiB1d4ciuims+fnQb94C0WZzdam1JkCnwpy7WuLvOf3w/KAY+GuVSC804rVfTqDHm1vwzsaTyNabXF1mo8B5LIiIGi4GC6IGzpKWDlNyEmSBQVf9hlgWEAhTUiIsaekuqvDW0ankeKxPNP587nYsGNYWUX4aFBnL8NG2RPRcsBVz1h1Fco7B1WU2aJzHgoio4WKwIGrgbAYDRKMJErX6quslbm4QTWbYDI3nA7VSJsWDceHYPKsPlozphA7hnjCX2bBm7wX0e/cPPP7VfhxKKXB1mQ0S57EgImq42HmbqIGTaDQQVErYSkshda86p4OtpASCUgGJpvGNwiORCBjYOhB3tArAvvP5WPxHIraczMKGfzKw4Z8MdIvyxpQ+0ejb3K/K2R6qmcvnscjPKIGbpwKiQoTJXIaSAjNU7nLOY0FEVE8xWBA1cPLgICgjo2A8cRyS6KbAZR+QRVFEWWYGVK1aQx4c5MIqXUsQBMQ18UbcI944nanHku1J+PFQKnYn5WF3Uh5iArWY0icK97QLhlzKE703yztIg3b9wpB0KBt5GcWwlJggF+XwDdMiKtaPQ80SEdVTDBZEDZwgkUA7IB6WjHSYE89CGhAIUaGAVa+HNTMDUi9vaOP7N5j5LG5W8wAt3h3RHk8PbI5lfyVj9Z4LOJmhx6z/HcY7v53Co72iMDIuDGo52+tmeAdp4BXghsLcEmRlZcHf3x8ePhxiloioPuP/jESNgDI6Gt5jxkDVshWshQUoy8qCtbAAqlat4T3m4QY3j4UzBHmo8eLdrfD3nP54ZmAL+LorkVZoxH9+Po4eb23Fe5tOI6/E4uoy6zVBIkDno7b/MFQQEdVvPGNB1Egoo6OhiIyEKTUNtsxM+AYENKiZt2uLh1qOabc3xaO3ReL7g6lYuiMJyTkGLNqWiE93CBjeuQCTe0chwoeX79xIVpERWVcM62uz2ZCXX4IsSyEkVxyL/lol/HXsxE1EVF8wWBA1IoJEAkVIMBRyGRT+/gwVDlDJpXioSzhGdA7DpuMZ+OSPRBy+WIhVey5gzd4LGNQmCI/1iUbbUA9Xl1pnrdpzAf/dcqba28/o3wyzBjSvxYqIiMiZGCyIiBwglQi4s00QBrT0x8aDSfj6aD7+OJWNX46m45ej6egR7YPH+kSjVzNfjiR1hdFdwzGgVYD9ttFixfDFuwAAX0/uCjelvNL2/lrlLa2PiIhuDoMFEVENCIKAjqFa3NkxGqezirF0exJ+OpyGvxNz8XdiLloG6fBYnyjc3TYIMo4kBQDw16kqXdpUYi6z/94qWAd3lcIVZRERkZPwfzsiopsUE6jDew/GYvuzt+PR2yLhppDiRHoRZqw9hD7v/IEvdiZX+hBNRETUEDFYEBE5SYinGi/f0wp/P98PT9/RHD4aBVILSvHq+stGkjKYXV0mERFRrWCwICJyMk83BZ7o1ww7n++H14a2QYSPGwpKLPhgyxn0eGsLXvnxH6Tklbi6TJcTbaL9d32esdJtIiKqfxgsiIhqiUouxcPdIrD1qb74aFRHtA3xgNFiw4pd59HnnW14cs1B/JNa6OoyXSIv3YCDm1Pst/dtOIf9G88jL93gwqqIiOhmsPM2EVEtk0oE3N0uCHe1DcSupFws3p6EHaezsf5wGtYfTkOvZr6Y0jsaPZv6NIqRpPLSDTiyNQWFl81poXKTIydFj+I8I9r1C4N3EOcFISKqbxgsiIhuEUEQ0CPaFz2ifXE8rQhLdyRi/ZF0/HkmB3+eyUGbEB2m9I7GoDaBDXYkKdEmIulQNowGCzwD3IBz5csVKhlUGgXyM0qQdCgbXgFunImbiKieaZj/cxER1XGtgnVYOLID/ni6Lx7p0QRquRT/pBbhyTUH0e/d7Vi56xxKzVZXl+l0+jwj8jMMcPdUVjk7IwgCNJ5K5GcYoM8zuqhCIiKqKQYLIiIXCvN2w6uDW+Pv5/thVnxzeGsUuJBXgpd/PIaeC7biv5vPIL8BjSRlMVlhtdggU0qvul6ukMJqscFianihioiooWOwICKqA7w0CsyIb4adz/XDf4a0Rpi3GnkGM97ffBo93tqKV3861iBGkpIrpZDKJSi7RnCwmK2QyiWQXyN4EBFR3cVgQURUh6gVUozp3gTbnuqLDx/qgNbBOpRarPji73Po+39/YMbagzieVuTqMmtM662CV6AGxQUm2Gw2+3JzqQU2mw2GAhO8AjXQequusxciIqqL2HmbiKgOkkkluLd9MO5pF4SdZ3OxZEci/jyTgx8PpeHHQ2no3dwPj/WOQvfo+jWSlCAREBXrh9yLepw7kmtffvFkPpRSKXxCNIiK9WPHbSKieojBgoioDhMEAbc188VtzXzxT2ohluxIwi9H0rDjdDZ2nM5Gu1APTOkdjTvbBEJarz6MC8DlgUhA+W2xPj0HIiK6HC+FIiKqJ9qEeODDhzpg+zO3Y2z3CKjkEhy5WIhpqw+g37t/4Kvd52G01O1OzxXDzYqiiCZtfezLQ1t4I6q9L0Tx3/WchZuIqN5hsCAiqmfCvN0wf0gb7HyuH2b0bwZPNznO55bgpR/+Qc+3tuLDLWdQUFI3R5K6fLhZyWVnWBRqGSQSDjdLRFSfMVgQEdVTPu5KzBrQHH8/3w+v3tsKIZ5q5BrMeHdT+UhS89cfR2pBqavLrITDzRIRNVwMFkRE9ZybQoZHekZi+zN98d+RsWgZpEOJ2YplO5PR5+1tmP2/QziZUTdGkuJws0REDReDBRFRAyGTSjAkNgS/Tr8NKyZ0QY9oH5TZRKw7mIo7F/6J8cv3YndSLkTRdf0XLh9u9so6RFHkcLNERPUYR4UiImpgBEFA7+Z+6N3cD0cuFmDJjiRsOJqObaeyse1UNtqHeeLxPlEY0OrWjyRVMdxscZ4RBZmXJvwzG8tQqi+Dyl3O4WaJiOopnrEgImrA2oV64qNRHbH1qb54uFs4lDIJDqcU4LGvDiD+ve1YvefCLR9JyjtIg3b9wuATqrUvM5ZY4BumRbvbw+AdpLml9RARkXMwWBARNQJNfDV4bWhb7Hy+H57s1xQeajmScwx44fujuG3BNny07SwKSy23rB7vIA06xIfZb3ce1ASdBkYwVBAR1WMMFkREjYivuxJP3dECfz/fD6/c0wrBHirkFJvwzsZT6PHmFrz+y3GkF9atkaSIiKh+YLAgImqENEoZJtwWie3P3o73H2yPmEAtDGYrPv0zGb0WbMNTXx/G6Ux9rT1+XroBBzen2G/v23AO+zeeR166odYek4iIahc7bxMRNWJyqQT3dQjF0NgQ/HE6G0u2J2J3Uh6+O3AR3x24iP4x/nisbzQ6R3hBEJzToTov3YAjW1NQqDfZl6nc5MhJ0aM4z4h2/djPgoioPqpRsLBYLMjIyEBJSQn8/Pzg7e3t7LqIiOgWEgQBt7fwx+0t/HEopQBLtifit2MZ2HIyC1tOZqFjuCem9InGgJYBlWbMdpRoE5F0KBtGgwWeAW7AufLlCpUMKo0C+RklSDqUDa8AN44MRURUz1T7Uii9Xo9PPvkEffr0gU6nQ5MmTdCyZUv4+fkhIiICkyZNQkJCQm3WSkREt0BsmCc+ebgTtj7VFw91CYdCJsGBCwWYsnI/4t/fjv8lXICprGYjSenzjMjPMMDdU1nlDIggCNB4KpGfYYA+z+iMp0JERLdQtYLFe++9hyZNmmD58uWIj4/HDz/8gEOHDuH06dPYtWsX5s6di7KyMtxxxx248847cebMmdqum4iIalmkrwZv3t8Wfz13O6bdHg2dSoakbAOe++4oei3YhsXbE1FkdGwkKYvJCqvFBtk1ZtaWK6SwWmywXGNmbiIiqruqdSlUQkICduzYgdatW191fZcuXTBhwgQsXrwYy5cvx59//olmzZo5tVAiInINf60KzwyMweN9m2Lt3gv4/K9kpBca8daGk1i09SxGdw3H+J6RCPS48WzZcqUUUrkEZSYroKj63ZbFbIVULoH8GsGDiIjqrmoFizVr1lRrZ0qlEo899thNFURERHWTu1KGib2iMLZ7E6w/nIYlOxJxOrMYS3YkYdnOZNzXIQSTe0ehqb/2mvvQeqvgFahBTooear/KQUQURRgKTPAN00LrfeOQQkREdctNjQplsVhw+vRpWK1WtGjRAkql0ll1ERFRHaWQSTCsUyju6xCCP05nYfEfSdh7Lg9f77uIr/ddxIBWAXisTxQ6RVQd2EOQCIiK9UNxnhEFmSX25WZjGUr1ZVC5yxEV68eO20RE9VCNg8Wff/6JkSNHwmKxoKysDDKZDCtWrMCdd97pzPqIiKiOkkgE9IsJQL+YAOw/n4+lOxLx+/FMbPr3p3OEFx7rE41+Mf6VRpLyDtKgXb8wHN+faR8VylhiQVCYDlGxfhxqloionqr2qFA2m63S7ZkzZ2LVqlXIyspCXl4eXnvtNTz++ONOL5CIiOq+ThFeWDKmMzbP7oORcWFQSCXYdz4fE1fswx0Ld+DrfSkwl5X/P5JaUIo0WxmUrTzs99d28oWyjSfSbGVILeDM30RE9VG1z1h07doVS5YsQceOHQEAZrMZ4eHh9vXh4eEwGjk8IBFRYxbt5463hrXD7AHNsWznOazafR5ns4rx7LdH8O7vpzC8Uyg+/TPZHjIqPLL2oP13pUyCrU/3RYin+laXT0REN6HawWLRokWYOHEi+vTpg9deew1z585Fp06d0KJFC1gsFpw8eRIffvhhbdZKRET1hL9OhecHxWDa7dFY8+9IUplFJny0LfGG9zWV2ZBvMDNYEBHVMw6dsUhISMDbb7+NTp064e2338apU6ewZ88eWK1WxMXFISQkpDZrJSKiekarkmNy72iM69EEPx5KwwebT+NiAc9uExE1RA513pZKpZgzZw5GjBiBxx57DF9++SU+/PBDBAcH11Z9RETUAChlUozoHIaYAC0Gf7TT1eUQEVEtqHbnbQA4duwYvvvuO1itVmzatAmDBw9Gr1698PHHH9dWfURE1IBIOIwsEVGDVe1g8d577yEuLg7vvPMOunfvjk8//RTjxo3Dnj17sHv3bnTv3h1Hjx6tzVqJiIiIiKiOqnawePvtt/HLL79g9+7dOHDgAN577z0AgK+vL1asWIH58+djxIgRtVYoERERERHVXdUOFqIoQiIp31wqlUIUxUrrBwwYgIMHD17trkRERA75el+Kq0sgIiIHVTtYPPPMM7jrrrvQo0cPxMbGYvbs2VW2UalUTi2OiIgaFk+1HPJq9LNYses8Ptp29hZUREREzlLtUaGefvppDBw4ECdPnkTbtm0RExNTm3UREVEDpLMJ+E+TEFgUAkS5BK8cPQ8AmNcmHEqpBBaTFX9mFuL3/CK8s/EUbDYRT/Zv5uKqiYioOhwabrZt27Zo27ZtbdVCREQNnMVkhSck8PRyg/myS2qbaFRQy6SwqUX4mQU0i/HBR7uS8e6m07CJwIx4hgsiorquWpdCvfXWWygpKanWDvfs2YNffvnlpooiIqKGSa6UQiqXoMxkrdRXz1xqgSiKsJitkMolmNIzEs/dWX5m/P3Np7Fw82lXlUxERNVUrWBx/PhxREREYOrUqdiwYQOys7Pt68rKynDkyBF8/PHH6NGjBx588EFotdpaK5iIiOovrbcKXoEa5KUbkJ5UYF+efrYQaWcLkJ9ugFegBlpvFR7vG43nB5WHi4Wbz+C9TaerDBxCRER1R7UuhVqxYgUOHz6MRYsWYdSoUSgqKoJUKoVSqbSfyejQoQMmTpyIRx55hJ24iYjoqgSJAJ8Qd5zek4Fio+WyFUBhVikUahl8Qtwh/NvB+7E+0ZAIwBu/nsQHW84AoohZA5pDEDjRHhFRXVPtPhbt27fHp59+iiVLluDIkSM4f/48SktL4evri9jYWPj6+tZmnURE1ACINhG5qcVw91JCUiYFsovKl4uAh78aUqkEuanFaNLGxx4uJveOhkQQ8NovJ/DB1rMQAcxmuCAiqnOqPdys/Q4SCWJjYzFkyBCMHDkS8fHxNxUqUlNT8fDDD8PHxwdqtRpt27bFvn377OtFUcQrr7yCoKAgqNVqxMfH48yZMzV+PCIich19nhH5GQZ4B2kQFOVlXx7c1BPBTb3gFaRBfoYB+jxjpftN7BWFl+5uCQD4cOtZ/N/vp3hZFBFRHeNwsHCm/Px89OzZE3K5HBs2bMDx48fx7rvvwsvr0n82b7/9Nj744AMsXrwYe/bsgUajwcCBA2E0Gq+zZyIiqossJiusFhtkSikuP+GgUMsgCIBcIYXVYoPFZK1y34m9ovDKPa0AAB9tS8TbGxkuiIjqEoeGm3W2BQsWICwsDMuXL7cvi4yMtP8uiiIWLlyIl156CUOGDAFQ3t8jICAAP/zwA0aOHHnLayYiopq7fFQoKKp+t1UxKpRcKb3q/SfcFglBAOatP45P/kiEKALP3dmCl0UREdUBLg0WP/30EwYOHIgHHngA27dvR0hICKZOnYpJkyYBAJKTk5GRkYH4+Hj7fTw8PNC1a1fs2rXrqsHCZDLBZDLZbxcVlV+/a7PZYLPZavkZXZ3NZoMoii57/IaC7egcbEfnYDvWjMZTAc8AN+Rc1EPte2mgj4q2LC4wwjdUC42n4pptO657BAQAr64/jsXbE2Gz2RguwGPSWdiOzsF2dI660I6OPLZLg0VSUhI++eQTzJ49Gy+88AISEhIwffp0KBQKjBs3DhkZGQCAgICASvcLCAiwr7vSm2++iXnz5lVZnp2d7bLLp2w2GwoLCyGKIiQSl159Vq+xHZ2D7egcbMea82wioKDIjLwCg32ZwVIIQ5EVCg8ZPJsIyM7Jvs4egDuj1Si+PQz/ty0FS/9MhqGkBE/cFtKowwWPSedgOzoH29E56kI76vX6am/rcLBYvnw5HnzwQbi5uTl61ypsNhs6d+6MN954A0D5kLX//PMPFi9ejHHjxtVon3PmzMHs2bPtt4uKihAWFgY/Pz/odLqbrrkmbDYbBEGAn58f31w3ge3oHGxH52A71py/P+Dt6YPj+7OA03kAAGuxAkFBOkTF+sIrUFOt/Uwd4A+tVou5Px3Hqv2ZUKnVeGFQTKMNFzwmnYPt6BxsR+eoC+3oyDQSDgeL559/HjNmzMADDzyARx99FD169HB0F3ZBQUFo1apVpWUtW7bEd999BwAIDAwEAGRmZiIoKMi+TWZmJmJjY6+6T6VSCaVSWWW5RCJx6YEtCILLa2gI2I7OwXZ0DrZjzfkEa9HRWwXsPAkAiBsUicBArX2I2eoa1yMSUokEL/3wDz7/6xxEUcDL97RstOGCx6RzsB2dg+3oHK5uR0ce1+EKU1NT8eWXXyInJwd9+/ZFTEwMFixYcM1Lk66nZ8+eOHXqVKVlp0+fRkREBIDyjtyBgYHYsmWLfX1RURH27NmD7t27O/x4RETU8DzcLQJv3NcWALBsZzLm/3yco0UREbmAw8FCJpPhvvvuw48//oiUlBRMmjQJq1atQnh4OAYPHowff/yx2p08Zs2ahd27d+ONN97A2bNnsXr1aixduhTTpk0DUJ7QZs6ciddeew0//fQTjh49irFjxyI4OBhDhw51tHQiIqoj8tINOLg5xX5734Zz2L/xPPLSDde517WN6hqON+8vDxfLd57DvPUMF0REt9pNnVMJCAjAbbfdhu7du0MikeDo0aMYN24coqOj8ccff9zw/nFxcfj++++xZs0atGnTBv/5z3+wcOFCjB492r7Ns88+iyeffBKTJ09GXFwciouL8dtvvzl0vRcREdUdeekGHNmagtyLlzoEqtzkyEnR48jWlBqHi4e6hGPBsLYQBOCLv8/h1Z+OMVwQEd1CNQoWmZmZ+L//+z+0bt0affv2RVFREX7++WckJycjNTUVI0aMqHbn63vuuQdHjx6F0WjEiRMn7EPNVhAEAfPnz0dGRgaMRiM2b96M5s2b16RsIiJyMdEmIulQNowGCzwDLg0ColDJ4BXoBqPBgqRD2RBtNQsED8aFY8H97SAIwJe7zuOVHxkuiIhuFYeDxb333ouwsDB88cUXmDRpElJTU7FmzRr7XBMajQZPPfUUUlJSbrAnIiJqbPR5RuRnGODuqazSwVoQBGg8lcjPMECfV/PhwUfEhWHBsPJwsXL3ebz84z+w1TCoEBFR9Tk8KpS/vz+2b99+3c7Tfn5+SE5OvqnCiIio4bGYrLBabJAppTBf5UyCXCGFocAEi8l6U48zonMYJIKAZ749jK92X4BNBF4b0gYSB0edIiKi6nM4WHz++ec33EYQBPvITkRERBXkSimkcgnKTFZAUfWkucVshVQugVwpvenHGt4pFAKAp789jNV7LkAUgdeHMlwQEdUWhy+Fmj59Oj744IMqyxctWoSZM2c6oyYiImqgtN4qeAVqUFxgqtL3QRRFGApM8ArUQOvtnAE6hnUKxXsj2kMiAGv2XsAL3x/lZVFERLXE4WDx3XffoWfPnlWW9+jRA99++61TiiIiooZJkAiIivWDSiNHQWaJfbnZWIb8jBKo3OWIivVzeKK867mvQyjeGxELiQCsTUjBnHUMF0REtcHhYJGbmwsPD48qy3U6HXJycpxSFBERNVzeQRq06xcGn1CtfZmxxALfMC3a3R4G7yCN0x9zaIcQvP9gebj4374UPPfdEYYLIiInczhYNG3aFL/99luV5Rs2bEBUVJRTiiIioobNO0iDDvFh9tudBzVBp4ERtRIqKgyJDcHCkR0gEYBv9l/Es98dgZXhgojIaRzuvD179mw88cQTyM7ORr9+/QAAW7ZswbvvvouFCxc6uz4iImqgLr/cSeutcurlT9cyuH0wBAAz/3cI3+6/CJso4p3h7SFlh24iopvmcLCYMGECTCYTXn/9dfznP/8BADRp0gSffPIJxo4d6/QCiYiInOne9sGQCAKmrz2IdQdSARF45wGGCyKim+VwsACAxx9/HI8//jiys7OhVqvh7u7u7LqIiIhqzd3tgiAIwJNrDmLdwVTYRBHvjohluCAiugk1ChYV/Pz8nFUHERHRLXVX2yAIKA8XPxxKgwjg3QfaQyZ1uPshERGhhsHi22+/xddff40LFy7AbDZXWnfgwAGnFEZERFTbBrUNwiJBwBOrD+DHQ2kQReC9EQwXREQ14fBfzg8++ADjx49HQEAADh48iC5dusDHxwdJSUkYNGhQbdRIRERUa+5sE4iPRneETCLgp8NpmPX1YZRZba4ui4io3nE4WHz88cdYunQpPvzwQygUCjz77LPYtGkTpk+fjsLCwtqokYiIqFYNbB2Ij0d3hFwqYP3hNMz43yGGCyIiBzkcLC5cuIAePXoAANRqNfR6PQBgzJgxWLNmjXOrIyIiukXuaB2Ij0d3glwq4Jcj6Zix9hAsDBdERNXmcB+LwMBA5OXlISIiAuHh4di9ezfat2+P5ORkiCInGiIioqvLKjIiS2+y3zZarPbfj6cVwU0pr7S9v1YJf53qltUHAANaBWDxw53w+FcH8MvRdNhEER881AFy9rkgIrohh4NFv3798NNPP6FDhw4YP348Zs2ahW+//Rb79u3D/fffXxs1EhFRA7BqzwX8d8uZq64bsXRPlWUz+jfDrAHNa7usKvq3DMDiMR3x2MoD2PBPBp5cfRAfjmK4ICK6EYeDxdKlS2GzlZ8anjZtGnx8fPD3339j8ODBmDJlitMLJCKihmF013AMaBVQaZnNZkNefj68vbwgkVT+4O6vVd7K8irpFxOAJWM6YcrK/fjtWAaeWH0AHz7UEQoZwwUR0bU4FCzKysrwxhtvYMKECQgNDQUAjBw5EiNHjqyV4oiIqOHw16mqXNpks9mQJTfB39+jSrBwtdtj/LF0bCdMXrkfG49lYtrqA/hoFMMFEdG1OPTXUSaT4e2330ZZWVlt1UNERFRn9G3hj0/HdoZCJsGm45mYuuoAzGXs0E1EdDUOf+3Sv39/bN++vTZqISIiqnP6NPfDZ2M7QymTYPOJTExdtR+mMuuN70hE1Mg43Mdi0KBBeP7553H06FF06tQJGo2m0vrBgwc7rTgiIqK6oHdzP3w2rjMmfrkPm09k4fGvDuCThztCKZO6ujQiojrD4WAxdepUAMB7771XZZ0gCLBa+S0OERE1PL2a+eHzcXF49MsEbD2ZhcdW7scnD3eCSs5wQUQE1OBSKJvNds0fhgoiImrIbmvmi2WPxEEll2DbqWw89tX+SvNxEBE1ZhzagoiIyAE9m14KF3+cysaUlQwXRERADS6Fmj9//nXXv/LKKzUuhoiIqD7oEe2L5Y90wYQvErD9dDYmrdiHT8d25mVRRNSoORwsvv/++0q3LRYLkpOTIZPJEB0dzWBBRESNQvdoHywfH4fxyxPw55kchgsiavQcDhYHDx6ssqyoqAiPPPII7rvvPqcURUREVB90i/LBF+PjMP6L8nAx8cvycKFWMFwQUePjlD4WOp0O8+bNw8svv+yM3RERUSMg2kQU5Zbaf0Sb6OqSaqRrlA++GN8Fbgop/jqbg4krElBqZp8LImp8nNZ5u7CwEIWFhc7aHRERNWB56Qbs33gee39OxpmETOz9ORn7N55HXrrB1aXVSJdIb3w5oQs0Cil2ns3Fo18yXBBR4+PwpVAffPBBpduiKCI9PR0rV67EoEGDnFYYERE1THnpBhzZmgKjwQKNpwJKpRISkxw5KXoU5xnRrl8YvIM0N95RHRPXpDxcjFu2F38n5mLCFwn4/JHOcFM4/F8tEVG95PBfu/fff7/SbYlEAj8/P4wbNw5z5sxxWmFERNTwiDYRSYeyYTRY4BXoBgAwQYBCJYMiUIb8jBIkHcqGV4AbBIng4mod17mJN1Y82gXjliVgV1Iuxi9PwPLxcQwXRNQoOPyXLjk5uTbqICKiRkCfZ0R+hgHunkoIggBRvNSvQhAEaDyVyM8wQJ9nhM5X7cJKa65TxL/h4vO92JOch0eWJ2D5I3HQKBkuiKhhc7iPRWFhIfLy8qosz8vLQ1FRkVOKIiKihslissJqsUGmvPqoSXKFFFaLDRZT/e6f0DHcCyse7QKtUoa9yXkYvzwBBlOZq8siIqpVDgeLkSNHYu3atVWWf/311xg5cqRTiiIiooZJrpRCKpeg7BrBwWK2QiqXQH6N4FGfdAj3wsqJXaFVybD3XB4eWb4XxQwXRNSAORws9uzZg9tvv73K8r59+2LPnj1OKYqIiBomrbcKXoEaFBeYKl0GBZQPBmIoMMErUAOtt8pFFTpXbJgnvnq0PFwknMvHI8sYLoio4XI4WJhMJpSVVf2jaLFYUFpa6pSiiIioYRIkAqJi/aDSyJGXboA+3wijwQJ9vhF56Qao3OWIivWrlx23r6V9mCdWTewKnUqGfefzMW7ZXuiNFleXRUTkdA4Hiy5dumDp0qVVli9evBidOnVySlFERNRweQdpENHWF+ZSK9JO5yP7gh5pp/NhNloR0ca3Xg41eyPtQj2xamI3eKjl2H8+H2OX7UURwwURNTAOD1Hx2muvIT4+HocPH0b//v0BAFu2bEFCQgJ+//13pxdIREQNS166AeeP5kChliKkuResihJIzW4wG604fzQHHn7qBhku2oZ6YNXErhj92R4cvFCAsZ/vxYpHu0Cnkru6NCIip3D4jEXPnj2xa9cuhIWF4euvv8b69evRtGlTHDlyBL169aqNGomIqIG4fB4L7yAN3L1UUGnkcPdSwTtIA6PBgqRD2RBt4o13Vg+1CSkPF55uchxKKcCYz/eisJRnLoioYajRoNqxsbFYtWqVs2shIqIGrjHMY3EjFeFi9Gd7cDilAGM/34MVj3aFh5pnLoiofnP4jMWvv/6KjRs3Vlm+ceNGbNiwwSlFERFRw9RY5rG4kdbBHlg9sRu83OQ4fLEQYz7fg8ISnrkgovrN4WDx/PPPw2qt+gdfFEU8//zzTimKiIgapsY0j8WNtArWYfWkbvDWKHDkYiEeZrggonrO4WBx5swZtGrVqsrymJgYnD171ilFERFRw9TY5rG4kZZBOqye1BXeGgWOphZi9Oe7UVBidnVZREQ14nCw8PDwQFJSUpXlZ8+ehUbT8EbxICIi57l8Hov8jBKYjGUQbSJMxjLkZ5Q0yHksbiQmUIc1k7rBR6PAP6lFGP3ZHoYLIqqXHA4WQ4YMwcyZM5GYmGhfdvbsWTz11FMYPHiwU4sjIqKGxztIg3b9wuAbpoXRYEFxgQlGgwW+YVq0uz2sQQ41eyMtArVYM7kbfN0VOJZWhFGf7kG+geGCiOoXh4PF22+/DY1Gg5iYGERGRiIyMhItW7aEj48P3nnnndqokYiIGhjvIA06DYxAl3si0SwuAF3uiUSngRGNMlRUaB6gxZpJ3eDrrsTx9CKM+mwP8hguiKgecXi4WQ8PD/z999/YtGkTDh8+DLVajXbt2qF37961UR8RETVQgkSAzkcNo1UNnY+6UV3+dC3NArRYO7krRi7dgxPpRRj16W57B28iorrO4TMWQPlY43fccQeeeeYZPPHEE+jVqxc2bNiA4cOHO7s+IiKiRqWpvxZrJ3eDn1aJkxl6jPp0N3KLTa4ui4johmoULCokJyfj5ZdfRnh4OO677z4YjUZn1UVERNRoNfV3x9rJ3eBvDxd7kMNwQUR1nMPBwmQyYdWqVejXrx9atGiBN954A7Nnz0ZWVhZ+/vnn2qiRiIio0Yn2c8eaf8PFqczyMxcMF0RUl1U7WOzfvx9Tp05FYGAgFi5ciKFDhyIlJQUSiQQDBw6ETqerzTqJiIganWi/8jMXATolTmcW46Glu5GtZ7ggorqp2sGia9euUCqV2L17NxISEjB9+nQEBATUZm1ERESNXpSfO9ZO7o5AnQpnsorx0Ke7kaXnpcdEVPdUO1j0798fn3/+OebPn4/ffvutyoypREREVDsifTVYO7kbgjxUOJtVfuYiq4jhgojqlmoHi40bN+LYsWNo0aIFHn/8cQQFBWHGjBkAykeJIiIiotrT5N9wEeyhQmK2ASM/ZbggorrFoc7bYWFheOWVV5CcnIyVK1ciOzsbMpkMQ4YMwQsvvIADBw7UVp1ERESNXoSPBmsnd0eIpxpJ2QaMXLobmQwXRFRH1Hi42QEDBmD16tVIS0vDk08+iQ0bNiAuLs6ZtREREdEVwn3csHZyt/JwkVMeLjIKGS6IyPVuah4LAPDy8sKTTz6JgwcPIiEhwRk1ERER0XWEeV8KF8k5BoxcugvphaWuLouIGrmbDhaX69ixozN3R0RERNdQES5CvdQ4l1uCUZ/uRZbe7OqyiKgRc2qwICIiolunIlyEeatxPq8EU789jbQCnrkgItdgsCAiIqrHQr3csHZyd4R5qXGx0IRRn+1BKsMFEbkAgwUREVE9F+KpxppJXRHiocCFvFKMXLoLF/NLXF0WETUyNQoWZWVl2Lx5M5YsWQK9Xg8ASEtLQ3FxsVOLIyIiouoJ9lTjk+EtEOHthpS8UoxcuhspeQwXRHTrOBwszp8/j7Zt22LIkCGYNm0asrOzAQALFizA008/7fQCiYiIqHr8tQqsntQFTXzccDGf4YKIbi2Hg8WMGTPQuXNn5OfnQ61W25ffd9992LJli1OLIyIiIscEeaixdnJ3RPpqkFrAcEFEt47DweLPP//ESy+9BIVCUWl5kyZNkJqa6rTCiIiIqGYCPVRYO7kboi4LFxdyGS6IqHY5HCxsNhusVmuV5RcvXoRWq3VKUURERHRzAnQqrJncDVF+FeFiF87nGlxdFhE1YA4HizvuuAMLFy603xYEAcXFxZg7dy7uuusuZ9ZGRERENyFAp8LaSd0Q7adBWqERI5fuxrkchgsiqh0OB4t3330XO3fuRKtWrWA0GjFq1Cj7ZVALFiyojRqJiIiohvz/PXMR7adBOsMFEdUih4NFaGgoDh8+jBdffBGzZs1Chw4d8NZbb+HgwYPw9/evjRqJiIjoJvhrVVg7uTua+bsjo8iIB5fuQjLDBRE5maxGd5LJMHr0aIwePdrZ9RAREVEt8NMqsXpSN4z6dDfOZBVj5NJdWDOpG6L83F1dGhE1EA6fsXjzzTexbNmyKsuXLVvGS6GIiIjqMD+tEmsmd0PzAHdkFpkwculuJGZzclsicg6Hg8WSJUsQExNTZXnr1q2xePFipxRFREREtcPXXYk1k7ohJlCLLH15uDibxXBBRDfP4WCRkZGBoKCgKsv9/PyQnp7ulKKIiIio9vi4K7FqYlfEBGqRrTfhoU9342yW3tVlEVE953CwCAsLw86dO6ss37lzJ4KDg51SFBEREdUuH/fyPhcV4WLk0j04k8lwQUQ153CwmDRpEmbOnInly5fj/PnzOH/+PJYtW4ZZs2Zh0qRJtVEjERER1QJvjQJrJnVDqyAdcorLz1ycZrggohpyeFSoZ555Brm5uZg6dSrMZjMAQKVS4bnnnsOcOXOcXiARERHVHi+NAqsmdsXDn+/BsbQiPLR0N1ZP6oYWgVpXl0ZE9YzDZywEQcCCBQuQnZ2N3bt34/Dhw8jLy8Mrr7xSG/URERFRLasIF62Ddcg1mDHq0904mVHk6rKIqJ5xOFhUcHd3R1xcHNq0aQOlUnnThbz11lsQBAEzZ860LzMajZg2bRp8fHzg7u6OYcOGITMz86Yfi4iIiCrzdCsPF21DPP4NF3twIp3hgoiqz+FgYTAY8PLLL6NHjx5o2rQpoqKiKv3UREJCApYsWYJ27dpVWj5r1iysX78e33zzDbZv3460tDTcf//9NXoMIiIiuj5PNwW+erQr2oV6IO/fMxfH0xguiKh6HO5jMXHiRGzfvh1jxoxBUFAQBEG4qQKKi4sxevRofPrpp3jttdfsywsLC/H5559j9erV6NevHwBg+fLlaNmyJXbv3o1u3brd1OMSERFRVR5ucqx8tCvGfr4Hhy8WYvRnu/HVxK5oHezh6tKIqI5zOFhs2LABv/zyC3r27OmUAqZNm4a7774b8fHxlYLF/v37YbFYEB8fb18WExOD8PBw7Nq165rBwmQywWQy2W8XFZV/02Kz2WCz2ZxSs6NsNhtEUXTZ4zcUbEfnYDs6B9vROdiOzuPMttQqpfhyfBzGLU8oDxef7sHKR+MaRbjgMekcbEfnqAvt6MhjOxwsvLy84O3t7ejdrmrt2rU4cOAAEhISqqzLyMiAQqGAp6dnpeUBAQHIyMi45j7ffPNNzJs3r8ry7OxsGI3Gm665Jmw2GwoLCyGKIiSSGndrafTYjs7BdnQOtqNzsB2dpzba8t17IzHj+zM4lmHA6E/34INhzRHj7+aUfddVPCadg+3oHHWhHfX66g9B7XCw+M9//oNXXnkFX375Jdzcav7HJSUlBTNmzMCmTZugUqlqvJ8rzZkzB7Nnz7bfLioqQlhYGPz8/KDT6Zz2OI6w2WwQBAF+fn58c90EtqNzsB2dg+3oHGxH56mNtvQHsGqyL8Yv34eDKQWY8f1ZrJgQh7YhDffMBY9J52A7OkddaEdHPqc7HCzeffddJCYmIiAgAE2aNIFcLq+0/sCBA9Xaz/79+5GVlYWOHTval1mtVuzYsQOLFi3Cxo0bYTabUVBQUOmsRWZmJgIDA6+5X6VSedVRqiQSiUsPbEEQXF5DQ8B2dA62o3OwHZ2D7eg8tdGWnm5KrHi0C8Yt24sDFwow5vO9+GpiV7QL9XTaY9Q1PCadg+3oHK5uR0ce1+FgMXToUEfvclX9+/fH0aNHKy0bP348YmJi8NxzzyEsLAxyuRxbtmzBsGHDAACnTp3ChQsX0L17d6fUQERERDemVcmx4tGuGLdsL/afz8fDn+3Byke7on2Yp6tLI6I6xOFgMXfuXKc8sFarRZs2bSot02g08PHxsS9/9NFHMXv2bHh7e0On0+HJJ59E9+7dOSIUERHRLeaulOHLCV3wyLK92Hc+Hw9/Xh4uYhkuiOhfNTqnUlBQgM8++wxz5sxBXl4egPJLoFJTU51a3Pvvv4977rkHw4YNQ+/evREYGIh169Y59TGIiIioetyVMnwxoQvimnhBbyzDmM/24OCFfFeXRUR1hMNnLI4cOYL4+Hh4eHjg3LlzmDRpEry9vbFu3TpcuHABK1asqHExf/zxR6XbKpUKH330ET766KMa75OIiIicx10pwxfju2D88gTsPZeHsZ/vxZePdkHHcC9Xl0ZELubwGYvZs2fjkUcewZkzZyr1Er/rrruwY8cOpxZHREREdY9GKcPy8XHoGukNvakMYz8v73tBRI2bw8EiISEBU6ZMqbI8JCTkuvNLEBERUcNRES66RXmj2FT2b8fuPFeXRUQu5HCwUCqV9tmsL3f69Gn4+fk5pSgiIiKq+9wUMix7JA7do3xQ/O+Zi33nGC6IGiuHg8XgwYMxf/58WCwWAOVj6164cAHPPfecfVhYIiIiahwqwkWPaB8YzFaMXbYXCQwXRI2Sw8Hi3XffRXFxMfz9/VFaWoo+ffqgadOm0Gq1eP3112ujRiIiIqrD1AopPh8Xh9ua+qLEbMW4ZXuxN5nhgqixcXhUKA8PD2zatAk7d+7E4cOHUVxcjI4dOyI+Pr426iMiIqJ6QK2Q4rNxnTFpxT78eSYHjyzfi2WPxKFblI+rSyOiW8ShYGGxWKBWq3Ho0CH07NkTPXv2rK26iIiIqJ5RyaX4dOylcDF+eUJ5H4xohguixsChS6HkcjnCw8NhtVprqx4iIiKqxyrCRe/mfii1WDHhiwT8nZjj6rKI6BZwuI/Fiy++iBdeeME+4zYRERHR5VRyKZaO6YQ+l4eLswwXRA2dw30sFi1ahLNnzyI4OBgRERHQaDSV1h84cMBpxREREVH9pJJLsWRMJzz+1X5sO5WN8V+UXxbVs6mvq0sjolricLAYOnRoLZRBREREDY1KLsXiMZ3w+FcHsPVkFiZ8kVA+elSzuhkuRJsNhdlZKMzOhFIAPP38IUgcvriDqNFyOFjMnTu3NuogIiKiBkgpk+KThzti6lcHsOVkFh79MsHeB6Muyb2YgrMJu5CTmgKrXIGzFjN8Q8LQNK47fELDXF0eUb1QoxheUFCAzz77DHPmzLH3tThw4ABSU1OdWhwRERHVf0qZFB8/3BHxLQNgKrNh4op92H4629Vl2eVeTMGBDT8hMzkRaq0O7t4+UGt1yExOxIENPyH3YoqrSySqFxwOFkeOHEHz5s2xYMEC/N///R8KCgoAAOvWrcOcOXOcXR8RERE1AEqZFB+P7ogBrQJgLrNh0op9+ONUlqvLgmiz4WzCLpTqi+ATGgalmxsEQQKlmxt8QsNQqi/C2YRdEG02V5dKVOc5HCxmz56NRx55BGfOnIFKpbIvv+uuu7Bjxw6nFkdEREQNh0ImwUejOuKOf8PF5BX7se2ka8NFUU42clNToPXxhSAIldYJggCtjw9yU1NQlFN3zrAQ1VUOB4uEhARMmTKlyvKQkBBkZGQ4pSgiIiJqmBQyCT4a3REDWwfAbLVhysr92Hoy02X1mI2lsFrMkKuUV10vV6pgtVhgNpbe4sqI6h+Hg4VSqURRUVGV5adPn4afX93qiEVERER1j1wqwaJRHTGoTSDMVhseW3kAW064JlwoVGpI5QpYjKarrreYjJDK5VCo1Le4MqL6x+FgMXjwYMyfPx8WiwVA+WnCCxcu4LnnnsOwYcOcXiARERE1PHKpBB881AF3tf03XHy1H5uP3/pwofP1g09IGPS5ORBFsdI6URShz82FT0gYdL788pToRhwOFu+++y6Ki4vh7++P0tJS9OnTB02bNoVWq8Xrr79eGzUSERFRAySXSvDfkR1wd9sgWKwiHl+1H5tucbgQJBI0jesOtVaH3IspMJUYINpsMJUYkHsxBWqtDk3junM+C6JqcHgeCw8PD2zatAk7d+7E4cOHUVxcjI4dOyI+Pr426iMiIqIGrDxcxEIQgJ+PpGPqqv1YNKojBrYOvGU1+ISGoeOgwZfmsTCaIbWYEBAZzXksiBxQrWDh7e2N06dPw9fXFxMmTMB///tf9OzZEz179qzt+oiIiKiBk0klWPhgLARBwPrDaZi26gAWjeqIO9vc2nDhHRyCguwsZGVlwt8/gDNvEzmoWu8Ws9ls77D95Zdfwmg01mpRRERE1LjIpBK8P6I9hsQGo8wm4onVB/DbP+m3tAZBIoGHnz88/ALgwVBB5LBqnbHo3r07hg4dik6dOkEURUyfPh1q9dVHR1i2bJlTCyQiIqLGQSaV4N0H2kMA8MOhNExbfRAfPgTc1Tboljy+aLOhMDsLhdmZUArgGQsiB1UrWHz11Vd4//33kZiYCEEQUFhYyLMWRERE5HQyqQTvjoiFRBCw7mAqnlxzEKII3N2udsNF7sWUS30s5AqctZjhGxLGPhZEDqhWsAgICMBbb70FAIiMjMTKlSvh4+NTq4URERFR4ySVCHjngfaAAKw7kIrpaw9ChIh72gXXyuPlXkzBgQ0/oVRfBHcfX8BNA5QYkJmciKKcbHQcNJjhgqgaHD6/l5yczFBBREREtUoqEfDO8PYY1jEUVpuIGWsP4afDaU5/HNFmw9mEXSjVF8EnNAxKNzcIggRKNzf4hIahVF+Eswm7INpsTn9soobG4eFmAWDLli3YsmULsrKyYLvijcY+FkREROQMUomAt4e3g0QAvtl/ETPXHoQoihgSG+K0xyjKyUZuagq0Pr4QBAGXT5EnCAK0Pj7ITU1BUU42PPwDnPa4RA2Rw8Fi3rx5mD9/Pjp37oygoCAIglAbdRERERFBKhGwYFg7CALw9b6LmPW/QwDgtHBhNpbCajFDrlJedb1cqUJxXh7MxlKnPB5RQ+ZwsFi8eDG++OILjBkzpjbqISIiIqpEIhHw1v3tIBEErE1Iwaz/HYJNFHFfh9Cb3rdCpYZUroDFaILSza3KeovJCKlcDoXq6qNhEtElDvexMJvN6NGjR23UQkRERHRVEomAN+5ri4e6hMEmArO/Pox1By7e9H51vn7wCQmDPjcHNpsNRkMxjCUGGA3FsNls0OfmwickDDpfPyc8C6KGzeFgMXHiRKxevbo2aiEiIiK6JolEwOtD22JU13CIIvDUN4fx7f6bCxeCRIKmcd0hSCQ4u3cXzh85hJwL53H+yCGc3bur0noiuj6HL4UyGo1YunQpNm/ejHbt2kEul1da/9577zmtOCIiIqLLSSQCXhvSBgKAVXsu4JlvD0MURTzQ2fHhYLOKjMjSm1CQVYIUiwoF0EEURMisbigTdBAgoMSiwomsEngKhfDXKuGvUzn/SRE1EA4HiyNHjiA2NhYA8M8//1Rax47cREREVNskEgGvDW0DiSBg5e7zePa7IxBFYEScY+Fi1Z4L+O+WM//eagrIm5b/Wgqg4nvTXABfnwVwFjP6N8OsAc2d8ySIGiCHg8W2bdtqow4iIiKiahMEAfOHtIYgACt2ncdz645AhIgH48KrvY/RXcPRPVCGQ5t+hdLNHVCoMO+0FgDwSnM9lFLAXFoKU4kBsQPuQlRE7UzQR9RQ1GgeCyIiIiJXEwQB8wa3hkQQ8MXf5/Dcd0chisDILtULF/46FQQPCbIFPby8dDCLVvu6CDcr1FLAppQiv7QY0R4S+PEyKKLrqnawuP/++6u13bp162pcDBEREZEjBEHA3HtbAQC++Pscnl93FDYRGNW1euHi8uFmoeRws0Q3o9rBwsPDozbrICIiIqqRinAhCMDynefwwvdHIULE6K4RN7xvxXCzmcmJ0ARV7qMhiiL0ubkIiIzmcLNE1VDtYLF8+fLarIOIiIioxgRBwCv3tIJEEPD5X8l48ft/YBOBMd2uHy4qhpMtyslGXtpFAF4AAHNpCQz5OVBrdRxulqia+C4hIiKiBkEQBLx0d0tM6hUJAHj5h3+wcte5G97PJzQMHQcNhn9ElH1ZqV6PgMhodBw0GD6hjg9lS9QYsfM2ERERNRiCIOCFu1pCEAQs3ZGEl388BpsIjOvR5Lr38wkNQ+d7AoB9mwAA3e5/EEHBQTxTQeQAvluIiIioQREEAXMGxWBKn/IzEHN/OoYvdibf+H6XhQidrx9DBZGD+I4hIiKiBkcQBDx/Zwwe7xsNAHh1/XEs++vG4YKIao7BgoiIiBokQRDw7MAWmPpvuJj/83F89meSi6siargYLIiIiKjBEgQBzwxsgSdubwoAeO2XEwwXRLWEwYKIiIgaNEEQ8NQdzTG936Vw8ekOhgsiZ2OwICIiogZPEATMGtAc0/s3AwC8/usJLNme6OKqiBoWBgsiIiJqFARBwOwBzTEzvjxcvLnhJD75g+GCyFk4jwURERE1KjPjm0OAgPc3n8aC306isNSMe9oFw2ix2rc5nlYEN6UcAOClUSDEU+2qconqDQYLIiIianRmxDeDIADvbTqNxduTsHh75T4XI5busf+ulEmw9em+DBdEN8BLoYiIiKhRmt6/GcZ0C7/hdqYyG/IN5ltQEVH9xmBBREREjdaDcTcOFkRUPQwWRERE1GiJNptTtyNqzBgsiIiIqNEyFOQ7dTuixozBgoiIiBots7G0Wtt9vDMFBy7kQxTFWq6IqP7iqFBERETUaFlMpmptt+NcMXZ8/DdaBGjxYFwY7usQAi+NoparI6pfeMaCiIiIGi2ZonrhoEeYBkqZBKcy9Zj/83F0fXMLpq85iL/P5sBm41kMIoBnLIiIiKgR0whWSEUrrIL0mttIRStmd/FCszY98dOhVKzZm4Lj6UX46XAafjqchggfN4zoHIYHOoXCX6e6hdUT1S0MFkRERNRohftp8aR1OwpKy2A0l2Gtz10AgAey1kMpFSBTKOCpliHcbxo81HKM6d4ED3eLwD+pRViTcAE/HUrD+dwSvLPxFN7bdBr9YvwxMi4MfZr7QSblhSHUuDBYEBERUaOldNMgWKeALC8VpstGlA2WlkBqLoHEKoN/QCSUbhr7OkEQ0DbUA21D2+Klu1vi5yPp+F9CCvafz8em45nYdDwTgToVHugcihGdwxDm7eaCZ0Z06zFYEBERUaOl9faBRCqFRCqFUq22LxcEASp3LcrMZkikMmi9fa56fzeFDCM6h2FE5zCcydRjbUIK1h24iIwiIz7cehaLtp3FbU198WBcGAa0CoBSdu1LrojqOwYLIiIiarT0ebmQyhXQeHrBaL3UCdvd0xvSslIo3dwglcuhz8uFh3/AdffVLECLl+9phWfvbIHfj2Xifwkp+OtsDv48U/7jrVHg/g4hGNklDE39tbX91IhuOQYLIiIiarTMxlLI5HIEN49BZloG8O+0FmVlZug8veEVGAyjobja810AgFImxb3tg3Fv+2BcyC3B1/tS8M3+FGQWmfDZX8n47K9kdI7wwsgu4bi7bRDUCp7FoIaBwYKIiIgaLYVKDalcAYvZXGXyO1EUYbGYIJXLoVCpr7GH6wv3ccPTA1tgZnwz/HEqG2sTUrDtVBb2nc/HvvP5mPfTMQzpEIyRceFoE+LhjKdE5DIMFkRERNRo6Xz9oHbXInH/HljlKuDfaS2UKjeUFOZDn5OF6E5dofP1u6nHkUkliG8VgPhWAcgsMuLb/RexNuECUvJK8dXuC/hq9wW0DtZhZJdwDIkNhk4ld8KzI7q1OA4aERERNWpixY9Yeakoli+HIDj18QJ0Kky7vSm2P307Vk3sinvbB0MhleBYWhFe/uEfdHl9M576+jASzuVVOYtCVJfxjAURERE1WkU52TAW6xES0xq52bmAsXy5yVgKL08vaH39UKovQlFO9g07bztKIhHQs6kvejb1RZ7BjO8PpmLt3gs4k1WM7w5cxHcHLiLaT4ORceG4v2MIfNyVTn18ImfjGQsiIiJqtMzGUlgtZsgVCgiVzkwIEAQBcrkCVovFoc7bNeGtUeDR2yLx+6ze+O7xHhjRORRquRSJ2Qa8/usJdHtzC6atOoAdp7Nhs/EsBtVNPGNBREREjZZCpUaZxYK00ydhtOKyPhZqGAryUaovhM4voMadtx0lCAI6RXihU4QXXr6nFdYfTsf/Ei7g8MVC/HI0Hb8cTUeIpxoPxoXhgc6hCPK4NXURVQeDBRERETVaWm8fWC1mlOqLoPYPBszly2VyOWRyLQozM6Dx9L7mBHm1WptKjlFdwzGqaziOpxXhfwkX8P3BVKQWlOK9TaexcPNp9G3hjwfjwtAvxh9yKS9EIddisCAiIqJGq3yCPCVU7joYi4vtZyzKLGaUGQ1QuWshlSuqNUFebWoVrMO8IW0w566W2PBPOtbsTcHe5DxsPZmFrSez4KdVYninUDzYOQxNfDUuq5MaNwYLIiIiarTKJ8iTIbhFS2SlpV+aIM9SBg9PL3gGBcNU7NgEebVJJZfivg6huK9DKJKyi/G/hBR8u/8isvUmfPJHIj75IxHdo3wwsksYBrYOhErOyffo1mGwICIiokYpq8iIpEIbUkUtlFYNxNDWwJnyddbIWJjdlEg1GmESgcRCG8QiI/x1KtcWfZkoP3fMuaslnrqjBbaezMSavSnYcSYbu5JysSspFx5qOe7rEIKHuoSjRaDW1eVSI8BgQURERI3Sqj0X8N8tZwBEVln31oWKCfF0/258AjP6l2HWgOa3rL7qUsgkuLNNEO5sE4TUglJ8sy8FXyekIK3QiC/+Pocv/j6H2DBPPNQlDPe0C4ZGyY9/VDt4ZBEREVGjNLprOAa0CkBBZgZO/r0DJoMBbh4egEoNGEtRUlgIpUaDmB694RkQCH9t3Z9HIsRTjZnxzfFkv2b480w21u5NweYTmTiUUoBDKQWYv/44BscG48G4cLQP9bhiiF2im8NgQURERI2Sv05VfmlTiAda+rvhbMIu5KSmwGpSQlpmgm/zMDSN6w6f0DBXl+owqURA3xb+6NvCH9l6E747cBH/S0hBco4Ba/amYM3eFMQEajEyLgxDO4TA003h6pKpAWCwICIiokbPJzQM3sEhKMjOQlZWJvz9A+Dp5w9BUv+HcPXTKvFYn2hM6R2FPcl5+F9CCn49mo6TGXq8uv443thwEne1CcSDceHoFuXNsxhUYwwWRERERAAEiQQefv4wiYBHAwkVlxMEAd2ifNAtygev3tsaPxxKxZq9F3AyQ48fDqXhh0NpaOLjhgfjwjGsUwj8tXWnozrVDwwWRERERI2Mh5sc43o0wdjuEThysRBrE1Lw06FUnMstwYLfTuLd30+hf0t/jIwLR+/mfpBKeBaDbsylUfzNN99EXFwctFot/P39MXToUJw6darSNkajEdOmTYOPjw/c3d0xbNgwZGZmuqhiIiIiooZDEAS0D/PEm/e3xd4X4/H2sHboGO6JMpuIjccyMf6LBNy2YCve23QaF/NLXF0u1XEuDRbbt2/HtGnTsHv3bmzatAkWiwV33HEHDAaDfZtZs2Zh/fr1+Oabb7B9+3akpaXh/vvvd2HVRERE1BCJNhsKs7NQmJ2JwuwsiDabq0u6pTRKGUbEhWHd1J7YOLM3JvSMhKebHOmFRnyw5Qx6vb0NY5ftxa9H02Eua1xtQ9UjiKIourqICtnZ2fD398f27dvRu3dvFBYWws/PD6tXr8bw4cMBACdPnkTLli2xa9cudOvW7Yb7LCoqgoeHBwoLC6HT6Wr7KVyVzWZDVlYW/P39IWlg12veSmxH52A7Ogfb0TnYjs7Dtrw5uRdTLo0KJVdAajHDN6T+jgrlLEaLFb8fz8TavRfwd2KufbmPRoFhnULxYFwYov3cq9yPx6Nz1IV2dOSzdJ3qY1FYWAgA8Pb2BgDs378fFosF8fHx9m1iYmIQHh5+zWBhMplgMpnst4uKigCUvzA2F33zYLPZIIqiyx6/oWA7Ogfb0TnYjs7BdnQetmXN5aVexIHf1qNUXwR3H1/ATQOUGJCRnIjCnGx0vPNeeIeEurpMl1BIBdzTNhD3tA3E+VwDvtmfim/3X0SW3oSlO5KwdEcS4pp4YWRcGO5sHQi1QgqAx6Oz1IV2dOSx60ywsNlsmDlzJnr27Ik2bdoAADIyMqBQKODp6Vlp24CAAGRkZFx1P2+++SbmzZtXZXl2djaMRqPT664Om82GwsJCiKLI1H4T2I7OwXZ0Drajc7AdnYdtWTOizYbT+/ai1GqDNrwJAAFlggQyjRZajTv0OTk4tm8vmktlDW6UKEepAYyN9cSodh74O7kQPx3Lwd/JhUg4l4+Ec/mY++Mx3NnSG4Nb+6Kpr4rHoxPUhfe1/v/bu/e4qOr8f+CvM/fhNoAw3BwRvIAi3oGgWjRFvOTqZgVuF+2R1vawfvWttm2/7Vfk66/Nys1y1y5rpbWbomVeflZqoliZFxRNUSRRFEQREZA7DDOf3x8ukxMolxmZAV7Px2MeznzOZw7v8+Yzw3l7zvmcqqp293WawmLBggXIzs7GDz/8YNN6/vznP+P555+3vK6srITBYICvr69DT4WSJAm+vr78cNmAebQP5tE+mEf7YB7th7nsnGtXSlBddB7u7h5QCzOazw9XCRMkANCqUV10Hhr5XdD56h0YqXO5398P98cORvG1+us33zt0ARfK6/DFT1fwxU9XMCzQA1PDdZht8IaON9/rNGf4XGs07Z922CkKi6effhpbt27Fd999h759fznU6O/vj8bGRlRUVFgdtbh8+TL8/f1bXZdarYZarW7RLpPJHPpFK0mSw2PoCZhH+2Ae7YN5tA/m0X6Yy45raqiH2dgIlUaN5glVpRseKrUGNWVlaGqoZ15bEejlgmcmDMaC8YPw45mrWJtZgB0nipF9sRLZFyvx9+8v4t7hAUiONmB0Py/efK8THP257sjPdWhhIYTAM888g40bNyIjIwMhISFWy8eMGQOlUon09HTMmjULAJCbm4uCggLExsY6ImQiIiLqQVQaLeRKFYz1DVC7uLRYbmyoh1yphEqjdUB03YdMJuGuQT64a5APymoa8cXhQqzZfw7nyurx+eEL+PzwBQzSuyEpyoD7RveFtyuPYvREDi0sFixYgDVr1mDz5s1wd3e3XDeh0+mg1Wqh0+nw+OOP4/nnn4e3tzc8PDzwzDPPIDY2tl0zQhERERHdioePL/oEGXA5/wxUWgNww/+oCyFQdfUq/EIGwMPH14FRdi/erirMuysE0we54EK9CusOXcDWYxdxuqQa//erHLyxLReTIvyQHNUPcQP6QMab7/UYDi0s3nvvPQDAuHHjrNpXrVqFuXPnAgCWLVsGmUyGWbNmoaGhAYmJiXj33Xe7OFIiIiLqiSSZDAOjYlFZegVXLxTCrU8fQOuGhroaVF+9Cq27BwZGxfb6C7c7Q5IkjAn2QlRIHyycPhRbjl7EusxCHC+6hq3HLmHrsUsweGuRNNaA+8cY4K9r/7n85Jyc6j4WtwPvY9FzMI/2wTzaB/NoH8yj/TCXtrG+j4UacmMD72Nhg1uNx+yia1iXWYhNR4tQVd8EAJBJwD3heiRF9cP4MF8o5BzDwixgLK+z5FHppYXkgKM73fY+FkRERESO0KevAd6BQai4UoKSksvQ6/3g6avnkYrbYFiQDsOCdPjvqUPw9fFLWJdZiIPnyrAzpwQ7c0qgd1fjgbF9kTS2H/r1aXndS29gLKlFXXYpGq/UoFZUoVKqg8rXFdphPlDqnTcnLCyIiIiIcP20KJ2vHg0C0LGouO20KjlmjemLWWP6Iq+kGusPFWLDf26+t2L3GazYfQZ3DuyDpKh+SIzwg1ohd3TIXcJYUovqvUUw1xgh81BBplBD1qSE8WI1TNca4HZnkNMWFywsiIiIiMihBurd8N9Th+DFSWHYmXMZaZmF+P70FezNu4q9eVfh5aLE70b1RXK0AYP93B0d7m0jzAJ12aUw1xgh17tAAJBMEiSNAjKNAqaSWtSdKIXCx+CQ06LawsKCiIiIiJyCSiHD1MgATI0MQGFZ7fWpag8V4tK1eny8Nx8f783H6H6eSI7uh3uHB8BF1bN2ZU0VDTBeqYVMp4YkSbjxUmhJkiDTqWEsqYWpogEKb+e72L1n/TaIiIiIqEcweLvg+YTBeHbCIHz38xWkZRZgZ04JsgoqkFVQgf/9fyfx25GBSI4yIDJI1yNuvicaTRBNZkiq1k/7klRyiMpGiEZTF0fWPiwsiIiIiMhpyWUSxofrMT5cj5Kqemw4XIR1mQU4d7UWaw4UYM2BAgwJ8MDsaANmjAiCzkXp6JA7TVLJISlk1wsHtRyirglmcxOErAlCq4BoNEFSSDctPByNhQURERERdQt6dw2eGjcAf4gPxf6zZViXWYCvs4uRc6kSCzefwKtf5WBqZACSowyIDvHudkcx5J5qKH1d0HC2AsIMmGobYVTXoaHBDLmLCpIMUA/whNxT7ehQW8XCgoiIiIi6FUmSEDugD2IH9MGi2kZsOlKEtMxCnCquwsYjRdh4pAihPq5IijLgvtF94evunDvivybJJCgDXFF7tATm+iZIrgpIajnQCDSV1kKmUUDp7+qUF24DLCyIiIiIqBvzdFFh7p0hmBPXHz9duIa0gwXY8tNFnC2twWvfnMKb23ORMNQPSVEG3D3IF3In3SkH/nNTvEs1kOvUkFyVMNcZr58WJQC5jxYyuQzG4hpowrydsrhgYUFERERE3Z4kSRhp8MRIgyf+cu9QfHXsItYeLMTRwgp8k12Mb7KLEeSpxQNj++KBsQYEeWodHXILzbNCKfQukKnlMNU1QWWWQS3zgFyrgLnBxFmhiIiIiIi6iptagaSofkiK6odTxZVIO1iIjUeKUFRRh7d3nsY76acRP9gXyVEGTBjiB6XcOW6GaDUrlCRB0iogmRSQ5IrrrzkrFBERERGRY4T7e2DRbyPw8pRwbD9RjLSDhdh39ioycq8gI/cKfNxUmDWmL5Kj+iHEx9Whsd44K5SkabmbzlmhiIiIiIgcTKOUY8bIIMwYGYRzpTVYd6gQnx+6gNLqBnyw5yw+2HMWMSHemB3dD5OH+UOj7Nqd95LKelyuqUeNWkJTcSXkXmqYG8yoFHXwkGSQqWUwlTdAoXeBa009/BSA3sO5TodiYUFEREREvUp/H1f8aXI4nk8YjF2nSrAusxAZuSU4kF+GA/ll8NiswO9GBSE5uh+GBHh0SUyfHSjAO+mnb7K09JenZwDsy8OzEwbhvxIGd0Vo7cbCgoiIiIh6JaVchsQIfyRG+OPStTp8fugC1mUWoqiiDp/sO49P9p3HiL46JEf3w/QRgXBT375d54di+iFhqB+ayupRfeASaq7W4snycgDAe56e0MpkUHhr4RYTAIW3BnonnEKXhQURERER9XoBOi3+z4RBeHr8QPyQV4p1mYXYcbIYP124hp8uHMfirScxfXggkqINGGXwtPvN9/QeGvi6qVGVew1GjQoNke7Ad9cLi+GDfeHiqoT5Sh2UpQ1wj9BzulkiIiIiImcmk0n4zWBf/GawL0qrG7AxqwhpmQU4c+X6dRnrDhUizM8dSVEG/G5UELxcVXb72c3Tzcp06haFiyRJkOnUnG6WiIiIiKi78XFTY/5vQjHv7hAcOl+OtIOF+Or4ReRersL/bj2JJd+cwuRh/kiOMuCO0D6Q2XgUoXm6WWE0o7GoxtLecO4alG5qKHy0EE2C080SEREREXVHkiQhqr83ovp7Y+H0odjy00WkHSzAiYuV2PLTRWz56SKC+7jgwbEGPDCmb6dna5JUcogmMxrPV8JkMv/SrpRgqmqEucYIubea080SEREREXV3Oq0Sj9wRjEfuCEZ20TWsPViALUcv4vzVWry5PRdvffsz7gnXIznKgPjBvlB04OZ7Mg8VYDTDXGeEpPvlFCtJIYOkkMFcXg95k/J6PyfEwoKIiIiIqBOGBenw6u8i8cq0Ifj6eDHSDhbg0PlyfHvyMr49eRn+Hho8MLYvHhxrgMHbpc31mSsbAaUcMhcFUPfL6U6iyQw0miHTKgCFHObKRsh4jQURERERUc/iolLg/jF9cf+YvsgrqcK6zEJsyCpCcWU9/r4rD//YnYe7BvogKcqAhKF+UCtaP5Wp+c7aqn461F+utty+wlxvgqTTQOnjAnNdE6+xICIiIiLq6Qbq3fHKtKF4MTEMO0+WIC2zAN+fLrU8vF1VuG9UEJKjDRiod7d6r6SSQ1LIIIymX80KJUGCdL1dIfEaCyIiIiKi3kKtkGPa8ABMGx6AwrJarD9UiPWHCnG5sgEf/pCPD3/Ix9hgLyRH98O0yABoVXLIPdW4LANKfr6KuhsuzTgtmqAuq4Z0RUAf1gfens53czyAhQURERER0W1l8HbBC5PC8OyEQdjz8xWkZRZi16kSHDpfjkPny5G65QRmjArE+MF6PJV1Fo1CWL3/D2Xllueqw9ew655+6NuOaza6GgsLIiIiIqIuoJDLMGGIHyYM8UNJZT0+P3wB6zILUVBWi3/vL8C/9xe0uY5GIVBaXM3CgoiIiIiIAL2HBgvGD8RT8QOw/+xVpGUW4uvjF9Fkbvu9wsiLt4mIiIiI6AYymYS4gT6IG+iD+wzemLs1u833mBvaUX04QPvv2EFERERERLeNzq19N76TqZxzF945oyIiIiIi6mXaO42ss043y8KCiIiIiMgJyN3bd8Sivf26GgsLIiIiIiInIMmktjt1oF9XY2FBREREROQEvFxVUCtuvXuuVsjg5eqcRyw4KxQRERERkRMI8tRix9wYFO0vQm11I+adKwYAfDg4EJomAZmLEkF3BCHIU+vgSFvHwoKIiIiIyAkIs4BXQTXcIEdjsBfwn8JiaIAOLnIZTCW1UBZWQ4R6OeXpUDwVioiIiIjICZgqGmC8UguZTg1I1oWDJEmQ6dQwltTCVNHgoAhvjYUFEREREZETEI0miCbz9elkhfilva4JQghIKjlEk4Bo5J23iYiIiIjoJiSVHJJCBlNFPRrL6y3tDeeuQemmhlyngqSQeB8LIiIiIiK6ObmnGjKtEo3nKmGqMlotM1U2ovFcJWQuSsg91Q6K8NZ4xIKIiIiIyFlIgDAJmOp/KSxMVY0wSRJkCuc8UtGMRyyIiIiIiJyAqaIBTWX1kJQySLjx4m0BCRIkpYSmsnqnvXibRyyIiIiIiByspLIeRQXluFZcCQiBRp0cqLu+7KyrHBqlHKKuCbhcCV1BOYIUXtB7aBwb9K+wsCAiIiIicrDPDhTgnfTTrS57srTMuiGtDM9OGIT/ShjcBZG1HwsLIiIiIiIHeyimH8bp3XFt+znADEhaOSABlaoGeDSqAQGIOhMgk6BLDEZQiJejQ26BhQURERERkYPpPTTwNnih3O8qTGUNEE0CkkaGCnUTPE0KiHozJI0cci81vAxeUDjZaVAACwsiIiIiIqcg91RDbfBAg7ECwgyYahthbjBBGM2Qu6sgyQB1Pw9ON0tERERERDcnySRoh/nAdK0BTVWNkLu4QCE3Q+7mAsksoHBXQRvhA0kmtb0yB+B0s0RERERETkKpd4Em3BtoNMFYVIWmK3UwFlUBjSZowr2h1Ls4OsSb4hELIiIiIiInYSypRf2pMkhqOdShOijkCqhNrkC9CfWnyqDoo3Xa4oJHLIiIiIiInIAwC9Rll8JcY4TCzxVynQZyrRJynQYKP1eYa4yoO1EKYRaODrVVLCyIiIiIiJyAqaIBxiu1kOnUkCTr6ygkSYJMp4axpNZp77zNwoKIiIiIyAmIRhNEkxmSSt7qckklh2gSEI2mLo6sfVhYEBERERE5AUklh6SQ3bRwEI0mSArppoWHo7GwICIiIiJyAnJPNZS+LjBfa4AQ1tdRCCFgvtYApd7Fae9jwcKCiIiIiMgJNN/HQuaqhKmkFqK+CUIIiPommEpqIXNV8j4WRERERETUNqXeBW53BkEZ6AZznRHmykaY64xQBrldb3fSqWYB3seCiIiIiMipKPUuUIwzwFheh/qSEnjo9VB6aZ32SEUzFhZERERERE5GkklQeGmgMGqg8NI4fVEB8FQoIiIiIiKyAxYWRERERERkMxYWRERERERkMxYWRERERERkMxYWRERERERkMxYWRERERERkMxYWRERERERkMxYWRERERERkMxYWRERERERkMxYWRERERERkMxYWRERERERkM4WjA7jdhBAAgMrKSofFYDabUVVVBY1GA5mMtVxnMY/2wTzaB/NoH8yj/TCX9sE82gfzaB/OkMfmfejmfepb6fGFRVVVFQDAYDA4OBIiIiIiou6pqqoKOp3uln0k0Z7yoxszm824ePEi3N3dIUmSQ2KorKyEwWBAYWEhPDw8HBJDT8A82gfzaB/Mo30wj/bDXNoH82gfzKN9OEMehRCoqqpCYGBgm0dNevwRC5lMhr59+zo6DACAh4cHP1x2wDzaB/NoH8yjfTCP9sNc2gfzaB/Mo304Oo9tHaloxpPeiIiIiIjIZiwsiIiIiIjIZiwsuoBarUZKSgrUarWjQ+nWmEf7YB7tg3m0D+bRfphL+2Ae7YN5tI/ulscef/E2ERERERHdfjxiQURERERENmNhQURERERENmNhQURERERENmNh0QkrVqxA//79odFoEBMTg4MHD96y/+eff47w8HBoNBpERkbi66+/tlouhMDChQsREBAArVaLiRMn4vTp07dzE5xGR3K5cuVK3H333fDy8oKXlxcmTpzYov/cuXMhSZLVY/Lkybd7MxyuI3lcvXp1ixxpNBqrPr11THYkj+PGjWuRR0mSMG3aNEuf3jgev/vuO0yfPh2BgYGQJAmbNm1q8z0ZGRkYPXo01Go1Bg4ciNWrV7fo09Hv3e6uo3n88ssvkZCQAF9fX3h4eCA2Nhbbt2+36rNo0aIW4zE8PPw2boXjdTSPGRkZrX6ui4uLrfpxPG66Zf/WvvskSUJERISlT28cj6+99hqioqLg7u4OvV6PmTNnIjc3t833daf9SBYWHbRu3To8//zzSElJQVZWFkaMGIHExESUlJS02v/HH3/E7Nmz8fjjj+PIkSOYOXMmZs6ciezsbEufN954A8uXL8f777+PAwcOwNXVFYmJiaivr++qzXKIjuYyIyMDs2fPxu7du7Fv3z4YDAZMmjQJRUVFVv0mT56MS5cuWR5r167tis1xmI7mEbh+o50bc3T+/Hmr5b1xTHY0j19++aVVDrOzsyGXy/HAAw9Y9ett47GmpgYjRozAihUr2tU/Pz8f06ZNw/jx43H06FE899xzmDdvntVOcWfGeHfX0Tx+9913SEhIwNdff43Dhw9j/PjxmD59Oo4cOWLVLyIiwmo8/vDDD7cjfKfR0Tw2y83NtcqTXq+3LON4bNs777xjlb/CwkJ4e3u3+H7sbeNxz549WLBgAfbv349vv/0WRqMRkyZNQk1NzU3f0+32IwV1SHR0tFiwYIHltclkEoGBgeK1115rtf+DDz4opk2bZtUWExMjnnzySSGEEGazWfj7+4s333zTsryiokKo1Wqxdu3a27AFzqOjufy1pqYm4e7uLj755BNL25w5c8SMGTPsHapT62geV61aJXQ63U3X11vHpK3jcdmyZcLd3V1UV1db2nrjeLwRALFx48Zb9nnppZdERESEVVtSUpJITEy0vLb1d9PdtSePrRk6dKhITU21vE5JSREjRoywX2DdTHvyuHv3bgFAlJeX37QPx2PHx+PGjRuFJEni3LlzlrbePh6FEKKkpEQAEHv27Llpn+62H8kjFh3Q2NiIw4cPY+LEiZY2mUyGiRMnYt++fa2+Z9++fVb9ASAxMdHSPz8/H8XFxVZ9dDodYmJibrrOnqAzufy12tpaGI1GeHt7W7VnZGRAr9cjLCwMTz31FK5evWrX2J1JZ/NYXV2N4OBgGAwGzJgxAydOnLAs641j0h7j8aOPPkJycjJcXV2t2nvTeOyMtr4j7fG76Y3MZjOqqqpafD+ePn0agYGBCA0NxUMPPYSCggIHRejcRo4ciYCAACQkJGDv3r2Wdo7Hzvnoo48wceJEBAcHW7X39vF47do1AGjxOb1Rd9uPZGHRAaWlpTCZTPDz87Nq9/Pza3H+ZbPi4uJb9m/+tyPr7Ak6k8tf+9Of/oTAwECrD9PkyZPx6aefIj09Ha+//jr27NmDKVOmwGQy2TV+Z9GZPIaFheHjjz/G5s2b8e9//xtmsxlxcXG4cOECgN45Jm0djwcPHkR2djbmzZtn1d7bxmNn3Ow7srKyEnV1dXb5ruiNli5diurqajz44IOWtpiYGKxevRrbtm3De++9h/z8fNx9992oqqpyYKTOJSAgAO+//z42bNiADRs2wGAwYNy4ccjKygJgn79dvc3FixfxzTfftPh+7O3j0Ww247nnnsOdd96JYcOG3bRfd9uPVHT5TySygyVLliAtLQ0ZGRlWFx4nJydbnkdGRmL48OEYMGAAMjIyMGHCBEeE6nRiY2MRGxtreR0XF4chQ4bggw8+wOLFix0YWff10UcfITIyEtHR0VbtHI/kCGvWrEFqaio2b95sdW3AlClTLM+HDx+OmJgYBAcHY/369Xj88ccdEarTCQsLQ1hYmOV1XFwczpw5g2XLluFf//qXAyPrvj755BN4enpi5syZVu29fTwuWLAA2dnZPe66Eh6x6AAfHx/I5XJcvnzZqv3y5cvw9/dv9T3+/v637N/8b0fW2RN0JpfNli5diiVLlmDHjh0YPnz4LfuGhobCx8cHeXl5NsfsjGzJYzOlUolRo0ZZctQbx6QteaypqUFaWlq7/hD29PHYGTf7jvTw8IBWq7XLGO9N0tLSMG/ePKxfv77F6RO/5unpicGDB3M8tiE6OtqSI47HjhFC4OOPP8YjjzwClUp1y769aTw+/fTT2Lp1K3bv3o2+ffvesm93249kYdEBKpUKY8aMQXp6uqXNbDYjPT3d6n+AbxQbG2vVHwC+/fZbS/+QkBD4+/tb9amsrMSBAwduus6eoDO5BK7PfLB48WJs27YNY8eObfPnXLhwAVevXkVAQIBd4nY2nc3jjUwmE44fP27JUW8ck7bk8fPPP0dDQwMefvjhNn9OTx+PndHWd6Q9xnhvsXbtWjz22GNYu3at1bTHN1NdXY0zZ85wPLbh6NGjlhxxPHbMnj17kJeX167/eOkN41EIgaeffhobN27Erl27EBIS0uZ7ut1+ZJdfLt7NpaWlCbVaLVavXi1OnjwpnnjiCeHp6SmKi4uFEEI88sgj4uWXX7b037t3r1AoFGLp0qUiJydHpKSkCKVSKY4fP27ps2TJEuHp6Sk2b94sjh07JmbMmCFCQkJEXV1dl29fV+poLpcsWSJUKpX44osvxKVLlyyPqqoqIYQQVVVV4sUXXxT79u0T+fn5YufOnWL06NFi0KBBor6+3iHb2BU6msfU1FSxfft2cebMGXH48GGRnJwsNBqNOHHihKVPbxyTHc1js7vuukskJSW1aO+t47GqqkocOXJEHDlyRAAQb731ljhy5Ig4f/68EEKIl19+WTzyyCOW/mfPnhUuLi7ij3/8o8jJyRErVqwQcrlcbNu2zdKnrd9NT9TRPH722WdCoVCIFStWWH0/VlRUWPq88MILIiMjQ+Tn54u9e/eKiRMnCh8fH1FSUtLl29dVOprHZcuWiU2bNonTp0+L48ePi2effVbIZDKxc+dOSx+Ox7bz2Ozhhx8WMTExra6zN47Hp556Suh0OpGRkWH1Oa2trbX06e77kSwsOuHvf/+76Nevn1CpVCI6Olrs37/fsiw+Pl7MmTPHqv/69evF4MGDhUqlEhEREeKrr76yWm42m8X//M//CD8/P6FWq8WECRNEbm5uV2yKw3Ukl8HBwQJAi0dKSooQQoja2loxadIk4evrK5RKpQgODhbz58/v0V/2zTqSx+eee87S18/PT0ydOlVkZWVZra+3jsmOfrZPnTolAIgdO3a0WFdvHY/N03X++tGcuzlz5oj4+PgW7xk5cqRQqVQiNDRUrFq1qsV6b/W76Yk6msf4+Phb9hfi+jS+AQEBQqVSiaCgIJGUlCTy8vK6dsO6WEfz+Prrr4sBAwYIjUYjvL29xbhx48SuXbtarJfjse3PdUVFhdBqteKf//xnq+vsjeOxtRwCsPrO6+77kZIQQty2wyFERERERNQr8BoLIiIiIiKyGQsLIiIiIiKyGQsLIiIiIiKyGQsLIiIiIiKyGQsLIiIiIiKyGQsLIiIiIiKyGQsLIiIiIiKyGQsLIiIiIiKyGQsLIqJeJCMjA5IkoaKiwtK2adMmDBw4EHK5HM8995zDYruV4uJiJCQkwNXVFZ6enjdtkyQJmzZtatc6Fy1ahJEjR96WeImIeiMWFkRE3cjcuXMhSRIkSYJSqYSfnx8SEhLw8ccfw2w2t/n+uLg4XLp0CTqdztL25JNP4v7770dhYSEWL16MuXPnYubMme2Kp7i4GM888wxCQ0OhVqthMBgwffp0pKend3YTW7Vs2TJcunQJR48exc8//3zTtkuXLmHKlCntWueLL75o9zhXr15tKXKIiHobhaMDICKijpk8eTJWrVoFk8mEy5cvY9u2bXj22WfxxRdfYMuWLVAoWv9qNxqNUKlU8Pf3t7RVV1ejpKQEiYmJCAwM7FAc586dw5133glPT0+8+eabiIyMhNFoxPbt27FgwQKcOnXKpu280ZkzZzBmzBgMGjTolm03bltb3Nzc4ObmZrcYiYh6PUFERN3GnDlzxIwZM1q0p6enCwBi5cqVljYA4t133xXTp08XLi4uIiUlRezevVsAEOXl5ZbnNz7i4+NbtO3evbvVWKZMmSKCgoJEdXV1i2Xl5eWW5+fPnxe//e1vhaurq3B3dxcPPPCAKC4utuq/adMmMWrUKKFWq0VISIhYtGiRMBqNQgghgoODreKZM2dOq23N27xx40bLegsLC0VycrLw8vISLi4uYsyYMWL//v1CCCFSUlLEiBEjrOJYuXKlCA8PF2q1WoSFhYkVK1ZYluXn5wsAYsOGDWLcuHFCq9WK4cOHix9//FEIIVrNZ0pKSqu5IyLqiXjEgoioB7jnnnswYsQIfPnll5g3b56lfdGiRViyZAnefvttKBQKnD171rIsLi4Oubm5CAsLw4YNGxAXFwcXFxfMnz8flZWVWLVqFQDA29u7xc8rKyvDtm3b8Oqrr8LV1bXF8ubTgcxmM2bMmAE3Nzfs2bMHTU1NWLBgAZKSkpCRkQEA+P777/Hoo49i+fLluPvuu3HmzBk88cQTAICUlBRkZmbi0UcfhYeHB9555x1otVo0Nja2aPu16upqxMfHIygoCFu2bIG/vz+ysrJuesrYZ599hoULF+If//gHRo0ahSNHjmD+/PlwdXXFnDlzLP1eeeUVLF26FIMGDcIrr7yC2bNnIy8vD3FxcXj77bexcOFC5ObmAgCPiBBRr8LCgoiohwgPD8exY8es2n7/+9/jscces7y+sbBQqVTQ6/UArhcPzacRabVaNDQ03PK0ory8PAghEB4efsuY0tPTcfz4ceTn58NgMAAAPv30U0RERCAzMxNRUVFITU3Fyy+/bNl5Dw0NxeLFi/HSSy8hJSUFvr6+UKvV0Gq1VjG11najNWvW4MqVK8jMzLQURwMHDrxprCkpKfjb3/6G++67DwAQEhKCkydP4oMPPrAqLF588UVMmzYNAJCamoqIiAjk5eUhPDwcOp0OkiR16JQsIqKegoUFEVEPIYSAJElWbWPHjr1tP6s9cnJyYDAYLEUFAAwdOhSenp7IyclBVFQUfvrpJ+zduxevvvqqpY/JZEJ9fT1qa2vh4uLSqRiPHj2KUaNGtXrE5ddqampw5swZPP7445g/f76lvampyepCdwAYPny45XlAQAAAoKSkpM0ii4iop2NhQUTUQ+Tk5CAkJMSqrbXTlOxh0KBBkCTJLhdoV1dXIzU11XKk4EYajabT623t9KhbxQAAK1euRExMjNUyuVxu9VqpVFqeNxdy7ZmRi4iop+N0s0REPcCuXbtw/PhxzJo1y+Z1qVQqmEymW/bx9vZGYmIiVqxYgZqamhbLm++TMWTIEBQWFqKwsNCy7OTJk6ioqMDQoUMBAKNHj0Zubi4GDhzY4iGTdf7P1PDhw3H06FGUlZW12dfPzw+BgYE4e/Zsixh+XazdSntyR0TUU7GwICLqZhoaGlBcXIyioiJkZWXhr3/9K2bMmIF7770Xjz76qM3r79+/P44dO4bc3FyUlpbCaDS22m/FihUwmUyIjo7Ghg0bcPr0aeTk5GD58uWIjY0FAEycOBGRkZF46KGHkJWVhYMHD+LRRx9FfHy85TSthQsX4tNPP0VqaipOnDiBnJwcpKWl4S9/+YtN2zF79mz4+/tj5syZ2Lt3L86ePYsNGzZg3759rfZPTU3Fa6+9huXLl+Pnn3/G8ePHsWrVKrz11lvt/pn9+/dHdXU10tPTUVpaitraWpu2gYioO2FhQUTUzWzbtg0BAQHo378/Jk+ejN27d2P58uXYvHlzi9N2OmP+/PkICwvD2LFj4evri71797baLzQ0FFlZWRg/fjxeeOEFDBs2DAkJCUhPT8d7770H4PqpQps3b4aXlxd+85vfYOLEiQgNDcW6dess60lMTMTWrVuxY8cOREVF4Y477sCyZcsQHBxs03aoVCrs2LEDer0eU6dORWRkJJYsWXLTHM2bNw8ffvghVq1ahcjISMTHx2P16tUdOmIRFxeHP/zhD0hKSoKvry/eeOMNm7aBiKg7kUR7r8AjIiIiIiK6CR6xICIiIiIim7GwICIiIiIim7GwICIiIiIim7GwICIiIiIim7GwICIiIiIim7GwICIiIiIim7GwICIiIiIim7GwICIiIiIim7GwICIiIiIim7GwICIiIiIim7GwICIiIiIim7GwICIiIiIim/1/9Uyb5auHDqcAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 800x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Let's visualize again\n",
+    "\n",
+    "means = np.mean(drift_coeff_sweep_accs, axis=1)\n",
+    "stds = np.std(drift_coeff_sweep_accs, axis=1)\n",
+    "\n",
+    "plt.figure(figsize=(8,5))\n",
+    "\n",
+    "plt.errorbar(\n",
+    "    drift_coefficients,\n",
+    "    means,\n",
+    "    yerr=stds,\n",
+    "    marker='s',\n",
+    "    capsize=4\n",
+    ")\n",
+    "\n",
+    "for i, coeff in enumerate(drift_coefficients):\n",
+    "    plt.scatter(\n",
+    "        np.full(drift_coeff_sweep_accs.shape[1], coeff),\n",
+    "        drift_coeff_sweep_accs[i],\n",
+    "        alpha=0.5\n",
+    "    )\n",
+    "\n",
+    "plt.xlabel(\"Drift Coefficient\")\n",
+    "plt.ylabel(\"Inference Accuracy (%)\")\n",
+    "plt.title(\"Impact of Conductance Drift on Inference Accuracy\")\n",
+    "plt.grid(True, alpha=0.3)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "45d96429-3792-48ed-8ad0-78188bfe140b",
+   "metadata": {},
+   "source": [
+    "The figure above illustrates the sensitivity of inference accuracy to the drift coefficient.\n",
+    "\n",
+    "For a fixed deployment time, larger drift coefficients produce more aggressive conductance evolution and generally lead to larger accuracy degradation. Conversely, technologies exhibiting smaller drift coefficients maintain conductance stability for longer periods and therefore preserve inference accuracy more effectively.\n",
+    "\n",
+    "Together with the retention-time sweep, this experiment demonstrates how XBTorch can be used to study both deployment-time effects and technology-dependent retention characteristics."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e2849886-4210-401b-a21e-118c9e96c61a",
+   "metadata": {},
+   "source": [
+    "## Conclusion\n",
+    "\n",
+    "In this notebook, we demonstrated XBTorch's retention and conductance drift modeling capabilities for hardware-aware inference.\n",
+    "\n",
+    "Using a power-law conductance evolution model, we examined two key dimensions of deployment-time reliability:\n",
+    "\n",
+    "1. **Retention Time** — representing how long a network remains deployed on hardware before evaluation.\n",
+    "2. **Drift Coefficient** — representing the intrinsic retention characteristics of the underlying memory technology.\n",
+    "\n",
+    "The experiments show that both parameters can materially impact inference accuracy by perturbing the programmed conductance state over time. Furthermore, because XBTorch supports device-to-device drift variability through `drift_variation`, users can investigate both deterministic and heterogeneous conductance evolution scenarios.\n",
+    "\n",
+    "Importantly, retention and drift are modeled independently from other inference-time nonidealities such as programming error and read noise. This allows users to isolate individual error mechanisms or study their combined effects within a unified hardware-aware inference framework.\n",
+    "\n",
+    "The implementation provided here is intentionally lightweight and extensible. Alternative drift formulations, technology-specific retention models, and additional time-dependent nonidealities can be incorporated by extending the inference accelerator interface, enabling rapid exploration of deployment-time reliability across emerging memory technologies."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/src/xbtorch/deployment/base.py b/src/xbtorch/deployment/base.py
index e472de6..9e9aab7 100644
--- a/src/xbtorch/deployment/base.py
+++ b/src/xbtorch/deployment/base.py
@@ -10,6 +10,7 @@
 - DAC and ADC quantization (fixed-point or board-specific)
 - Noise modeling (read/write)
 - Stuck-at defect simulation
+- Input encoding schemes
 - Weight encoding and mapping schemes
 - Array visualization and utility functions
 
@@ -41,8 +42,8 @@ class GenericAccelerator(metaclass=abc.ABCMeta):
 
     This class simulates memristive crossbar arrays, incorporating
     hardware non-idealities such as stuck devices, read/write noise,
-    limited precision DAC/ADC, and weight encoding/mapping schemes.
-    Subclasses implement specific quantization methods for DAC and ADC.
+    limited precision DAC/ADC, input encoding schemes, and weight encoding/mapping schemes.
+    Provided subclasses implement specific quantization methods for DAC and ADC. 
 
     Parameters
     ----------
@@ -55,7 +56,7 @@ class GenericAccelerator(metaclass=abc.ABCMeta):
     read_noise : float
         Amplitude of uniform read noise applied during chip readout.
     write_noise : float
-        Standard deviation of Gaussian noise applied during weight writes.
+        Standard deviation of Gaussian noise applied during weight writes. Simulates device programming error.
     stateful: bool, optional
         In stateful mode, a physical representation of the entire crossbar is maintained, and weights are mapped to these limited devices.
         In stateless mode, weights are mapped and VMM is performed on the fly. This is more memory-efficient. Essentially behaves like an infinite size stateful crossbar.
@@ -77,6 +78,19 @@ class GenericAccelerator(metaclass=abc.ABCMeta):
     xb_mapping_scheme : callable, optional
         Function for mapping weights to crossbar positions.
         Default: :func:`map_random`.
+    retention_time : float, optional
+        elapsed deployment time.
+        Default: 1.0.
+    drift_coefficient : float, optional
+        nominal ν.
+        Default: 0.0.
+    drift_t0 : float, optional
+        reference time.
+        Default: 1.0.
+    drift_variation : float, optional
+        device-to-device spread in ν.
+        Default: 0.0.
+
     device : str, optional
         PyTorch device for simulation (e.g., "cpu" or "cuda").
 
@@ -110,6 +124,10 @@ def __init__(self,
                  input_encoding_scheme='instant',
                  weight_encoding_scheme=encode_simple_binary, 
                  xb_mapping_scheme=map_random,
+                 retention_time=1.0,
+                 drift_coefficient=0.0,
+                 drift_t0=1.0,
+                 drift_variation=0.0,
                  device="cpu"):
 
         self.read_noise = read_noise
@@ -123,6 +141,11 @@ def __init__(self,
         self.stuck_percentage = stuck_percentage
         self.stateful = stateful
 
+        self.retention_time = retention_time
+        self.drift_coefficient = drift_coefficient
+        self.drift_t0 = drift_t0
+        self.drift_variation = drift_variation
+
         if (self.stuck_percentage > 0 and not self.stateful):
             raise ValueError("Stuck devices can not be simulated without a stateful representation of a crossbar. See examples for usage.")
     
@@ -172,6 +195,43 @@ def get_xb_size(self):
         """
         return (self.columns, self.rows)
 
+    def apply_conductance_drift(self, G):
+        """
+        Apply retention-induced conductance drift.
+
+        Parameters
+        ----------
+        G
+
+        Returns
+        -------
+        torch.Tensor
+            Subarray with applied drift.
+
+        """
+
+        if self.drift_coefficient == 0:
+            return G
+
+        if self.drift_variation > 0:
+            # device-to-device variation
+            nu = torch.normal(
+                mean=self.drift_coefficient,
+                std=self.drift_variation,
+                size=G.shape,
+                device=G.device
+            )
+        else:
+            # deterministic global drift
+            nu = self.drift_coefficient
+
+        drift_factor = (self.retention_time / self.drift_t0) ** (-nu)
+
+        G_drifted = G * drift_factor
+        G_drifted = torch.clamp(G_drifted, self.g_min, self.g_max)
+
+        return G_drifted
+
     def read_chip(self, row, n_rows, col, n_cols, fast_mode=True):
         """
         Read a subarray of the chip, optionally with read noise.
@@ -211,11 +271,16 @@ def read_chip(self, row, n_rows, col, n_cols, fast_mode=True):
             raise RuntimeError("Cannot read chip when self.stateful is False.")
 
         subarray = self._chip[row:row+n_rows, col:col+n_cols]
+
+        # conductance drift
+        subarray = self.apply_conductance_drift(subarray)
+
+        # read noise
         noise = torch.empty_like(subarray).uniform_(-self.read_noise, self.read_noise)
         if (not fast_mode): raise ValueError("Not implemented")
         if (self.read_noise > 0): subarray = subarray + noise
-        return subarray
-    
+        return torch.clamp(subarray, self.g_min, self.g_max)
+
     def read_chip_stateless(self, subarray):
         """
         Read a subarray of the chip, optionally with read noise.
@@ -243,8 +308,9 @@ def read_chip_stateless(self, subarray):
         """
 
         noise = torch.empty_like(subarray).uniform_(-self.read_noise, self.read_noise)
+        subarray = self.apply_conductance_drift(subarray)
         if (self.read_noise > 0): subarray = subarray + noise
-        return subarray
+        return torch.clamp(subarray, self.g_min, self.g_max)
 
     def gen_defect_map(self, stuck_percentage):
         """
@@ -287,13 +353,12 @@ def map_weights_to_array_stateless(self, sw_weight):
         for i, Gpos in enumerate(Gposs):
             if (self.write_noise > 0):
                 noise = torch.randn_like(Gposs[i]) * self.write_noise + 0.0 # 0 mean
-                Gposs[i] = Gposs[i] + noise
-
+                Gposs[i] = torch.clamp(Gposs[i] + noise, self.g_min, self.g_max)
 
         for i, Gneg in enumerate(Gnegs):
             if (self.write_noise > 0):
                 noise = torch.randn_like(Gnegs[i]) * self.write_noise + 0.0 # 0 mean
-                Gnegs[i] = Gnegs[i] + noise
+                Gnegs[i] = torch.clamp(Gnegs[i] + noise, self.g_min, self.g_max)
 
         return Gposs, Gnegs
 
@@ -334,7 +399,7 @@ def map_weights_to_array(self, sw_weight, pos_idxs=[], neg_idxs=[], additional_a
         for i, pos_idx in enumerate(pos_idxs):
             if (self.write_noise > 0):
                 noise = torch.randn_like(Gposs[i]) * self.write_noise + 0.0 # 0 mean
-                Gposs[i] = Gposs[i] + noise
+                Gposs[i] = torch.clamp(Gposs[i] + noise, self.g_min, self.g_max)
 
             self._chip[pos_idx[0]:pos_idx[0]+sw_weight_shape[0], 
                     pos_idx[1]:pos_idx[1]+sw_weight_shape[1]] = Gposs[i]
@@ -342,7 +407,7 @@ def map_weights_to_array(self, sw_weight, pos_idxs=[], neg_idxs=[], additional_a
         for i, neg_idx in enumerate(neg_idxs):
             if (self.write_noise > 0):
                 noise = torch.randn_like(Gnegs[i]) * self.write_noise + 0.0 # 0 mean
-                Gnegs[i] = Gnegs[i] + noise
+                Gnegs[i] = torch.clamp(Gnegs[i] + noise, self.g_min, self.g_max)
 
             self._chip[neg_idx[0]:neg_idx[0]+sw_weight_shape[0], 
                     neg_idx[1]:neg_idx[1]+sw_weight_shape[1]] = Gnegs[i]
@@ -479,10 +544,30 @@ def __init__(self,
                  stuck_mode='real', 
                  input_encoding_scheme='instant',
                  xb_mapping_scheme=map_random, 
-                 weight_encoding_scheme=encode_simple_binary, 
+                 weight_encoding_scheme=encode_simple_binary,
+                 retention_time=1.0,
+                 drift_coefficient=0.0,
+                 drift_t0=1.0,
+                 drift_variation=0.0, 
                  device='cpu'):
                 # TODO: Input encoding modes and output encoding modes should go here
-        super().__init__(g_min, g_max, v_read, read_noise=read_noise, write_noise=write_noise, stateful=stateful, xb_size=xb_size, stuck_percentage=stuck_percentage, stuck_mode=stuck_mode, input_encoding_scheme=input_encoding_scheme, xb_mapping_scheme=xb_mapping_scheme, weight_encoding_scheme=weight_encoding_scheme, device=device)
+        super().__init__(g_min, 
+                         g_max, 
+                         v_read, 
+                         read_noise=read_noise, 
+                         write_noise=write_noise, 
+                         stateful=stateful, 
+                         xb_size=xb_size, 
+                         stuck_percentage=stuck_percentage,
+                         stuck_mode=stuck_mode,
+                         input_encoding_scheme=input_encoding_scheme,
+                         xb_mapping_scheme=xb_mapping_scheme,
+                         weight_encoding_scheme=weight_encoding_scheme, 
+                         retention_time=retention_time,
+                         drift_coefficient=drift_coefficient,
+                         drift_t0=drift_t0,
+                         drift_variation=drift_variation,
+                         device=device)
         self.adc_bits = adc_bits
         self.dac_bits = dac_bits
 
@@ -588,8 +673,35 @@ class Daffodil(GenericAccelerator):
     
     """
 
-    def __init__(self, g_min=50, g_max=100, v_read=0.3, read_noise=10, write_noise=10, stuck_percentage=0.0, stuck_mode='real', input_encoding_scheme='instant', xb_mapping_scheme=map_random, device='cpu'):
-        super().__init__(g_min, g_max, v_read, read_noise, write_noise, stuck_percentage, stuck_mode, input_encoding_scheme, xb_mapping_scheme, device=device)
+    def __init__(self,
+                 g_min=50,
+                 g_max=100,
+                 v_read=0.3,
+                 read_noise=10,
+                 write_noise=10,
+                 stuck_percentage=0.0,
+                 stuck_mode='real',
+                 input_encoding_scheme='instant',
+                 xb_mapping_scheme=map_random,
+                 retention_time=1.0,
+                 drift_coefficient=0.0,
+                 drift_t0=1.0,
+                 drift_variation=0.0, 
+                 device='cpu'):
+        super().__init__(g_min,
+                         g_max,
+                         v_read,
+                         read_noise,
+                         write_noise,
+                         stuck_percentage,
+                         stuck_mode,
+                         input_encoding_scheme,
+                         xb_mapping_scheme,
+                         retention_time=retention_time,
+                         drift_coefficient=drift_coefficient,
+                         drift_t0=drift_t0,
+                         drift_variation=drift_variation,
+                         device=device)
 
         # Board level parameters, calibrated from hardware experiments
         # Can be overridenn based on further experimentation