{ "cells": [ { "cell_type": "markdown", "id": "1e1e6687", "metadata": {}, "source": [ "# Lesson 30 demo part: Optimizer comparison\n", "\n", "**TLDR**: see [optimizers overview](https://gperdrizet.github.io/fullstack-2605/resources/optimizers-overview)\n", "\n", "This notebook compares four common optimizers used in deep learning:\n", "\n", "1. **SGD** (Stochastic Gradient Descent) - vanilla, no momentum\n", "2. **SGD + Momentum** - SGD with momentum=0.9\n", "3. **RMSprop** - Adaptive learning rate per parameter\n", "4. **Adam** - Adaptive learning rate + momentum (most popular)\n", "\n", "We'll see how they differ in:\n", "- **Part 1**: Batch size effect (true SGD vs mini-batch)\n", "- **Part 2**: Momentum effect (SGD with different momentum values)\n", "- **Part 3**: Convergence speed at the same learning rate\n", "- **Part 4**: Sensitivity to learning rate choice\n", "\n", "> **Note**: PyTorch's \"SGD\" optimizer is a bit of a misnomer; it's only true *stochastic* gradient descent when batch_size=1. With larger batches, it's technically *mini-batch* gradient descent.\n", "\n", "## Notebook set up\n", "\n", "### Required packages\n", "\n", "To run this notebook you need to install my [`image_classification_tools`](https://pypi.org/project/image-classification-tools) package via pip:\n", "\n", "```\n", "pip install image_classification_tools`\n", "```\n", "\n", "If you are not working in one of the course deeplearning containers, you may also need to pip install `optuna` and `optuna-dashboard`.\n", "\n", "```\n", "pip install optuna optuna-dashboard\n", "```\n", "\n", "The Optuna dashboard can be viewed either via the VS Code extension 'Optuna Dashboard', or via the built-in web server, though the built in web server has more features/plots than the extension. Start it with:\n", "\n", "```\n", "optuna-dashboard sqlite:///data/simple_optimization.db --host 0.0.0.0\n", "```\n", "\n", "> **Note**: running this notebook on a GPU requires >12 GB VRAM, if you run into OOM (out-of-memory) errors, try decreasing the maximum number of convolutional blocks, or the maximum number of filters." ] }, { "cell_type": "markdown", "id": "91e4c182", "metadata": {}, "source": [ "### Imports" ] }, { "cell_type": "code", "execution_count": null, "id": "a0a84698", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Using device: cuda\n" ] } ], "source": [ "# Standard library imports\n", "import time\n", "from pathlib import Path\n", "\n", "# Third party imports\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import torch\n", "import torch.nn as nn\n", "import torch.optim as optim\n", "from torchvision import datasets, transforms\n", "from torch.utils.data import DataLoader\n", "\n", "# Custom package import\n", "from image_classification_tools.pytorch import train_model" ] }, { "cell_type": "markdown", "id": "7c47a27c", "metadata": {}, "source": [ "### Trial hyperparameters" ] }, { "cell_type": "code", "execution_count": null, "id": "3c65784d", "metadata": {}, "outputs": [], "source": [ "# Configuration\n", "batch_size = 10000 # Default for validation loader\n", "print_every = 10\n", "\n", "# Part 1 settings (batch size comparison)\n", "batch_sizes_part1 = [1, 4, 16, 64, 256, 1024]\n", "n_samples_part1 = 1024 # Full dataset -validation = 40000\n", "n_epochs_part1 = 50\n", "lr_part1 = 0.01\n", "\n", "# Part 2 settings (momentum comparison)\n", "momentum_values = [0.0, 0.5, 0.9, 0.95, 0.99]\n", "batch_size_part2 = 16\n", "n_epochs_part2 = 50\n", "lr_part2 = 0.01\n", "\n", "# Part 3 settings (optimizer comparison)\n", "n_epochs_part3 = 50\n", "lr_part3 = 0.001\n", "\n", "# Part 4 settings (learning rate sensitivity)\n", "n_epochs_part4 = 10\n", "learning_rates = [0.1, 0.01, 0.001, 0.0001]\n", "\n", "# Optimizer configurations\n", "optimizer_configs = {\n", " 'SGD': lambda params, lr: optim.SGD(params, lr=lr),\n", " 'SGD+Momentum': lambda params, lr: optim.SGD(params, lr=lr, momentum=0.9),\n", " 'RMSprop': lambda params, lr: optim.RMSprop(params, lr=lr),\n", " 'Adam': lambda params, lr: optim.Adam(params, lr=lr)\n", "}" ] }, { "cell_type": "markdown", "id": "474120c7", "metadata": {}, "source": [ "### Other configuration" ] }, { "cell_type": "code", "execution_count": null, "id": "3bbb32c9", "metadata": {}, "outputs": [], "source": [ "# Set random seed for reproducibility\n", "torch.manual_seed(315)\n", "np.random.seed(315)\n", "\n", "# Check for GPU\n", "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", "print(f'Using device: {device}')\n", "\n", "class_names = [\n", " 'airplane', 'automobile', 'bird', 'cat', 'deer',\n", " 'dog', 'frog', 'horse', 'ship', 'truck'\n", "]\n", "\n", "num_classes = len(class_names)" ] }, { "cell_type": "markdown", "id": "bb6666cf", "metadata": {}, "source": [ "## 1. Load CIFAR-10 data (grayscale)" ] }, { "cell_type": "code", "execution_count": null, "id": "37bddf2c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Files already downloaded and verified\n", "Files already downloaded and verified\n", "Training samples: 50000\n", "Test samples: 10000\n" ] } ], "source": [ "# Data directory\n", "data_dir = Path('../data')\n", "data_dir.mkdir(parents=True, exist_ok=True)\n", "\n", "# Grayscale transform for faster training\n", "transform = transforms.Compose([\n", " transforms.Grayscale(num_output_channels=1),\n", " transforms.ToTensor(),\n", " transforms.Normalize((0.5,), (0.5,))\n", "])\n", "\n", "# Use the fast BrainChip mirror for downloading CIFAR-10\n", "datasets.CIFAR10.url = 'https://data.brainchip.com/dataset-mirror/cifar10/cifar-10-python.tar.gz'\n", "\n", "# Load datasets\n", "train_dataset = datasets.CIFAR10(\n", " root=data_dir,\n", " train=True,\n", " download=True,\n", " transform=transform\n", ")\n", "\n", "test_dataset = datasets.CIFAR10(\n", " root=data_dir,\n", " train=False,\n", " download=True,\n", " transform=transform\n", ")\n", "\n", "print(f'Training samples: {len(train_dataset)}')\n", "print(f'Test samples: {len(test_dataset)}')" ] }, { "cell_type": "code", "execution_count": null, "id": "508f6b43", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "X_train: torch.Size([40000, 1, 32, 32])\n", "X_val: torch.Size([10000, 1, 32, 32])\n" ] } ], "source": [ "# Preload to GPU\n", "X_train_full = torch.stack([img for img, _ in train_dataset]).to(device)\n", "y_train_full = torch.tensor([label for _, label in train_dataset]).to(device)\n", "X_test = torch.stack([img for img, _ in test_dataset]).to(device)\n", "y_test = torch.tensor([label for _, label in test_dataset]).to(device)\n", "\n", "# Train/val split (80/20)\n", "n_train = int(0.8 * len(X_train_full))\n", "indices = torch.randperm(len(X_train_full))\n", "\n", "X_train = X_train_full[indices[:n_train]]\n", "y_train = y_train_full[indices[:n_train]]\n", "X_val = X_train_full[indices[n_train:]]\n", "y_val = y_train_full[indices[n_train:]]\n", "\n", "# Validation loader (fixed batch size)\n", "val_loader = DataLoader(\n", " torch.utils.data.TensorDataset(X_val, y_val),\n", " batch_size=batch_size,\n", " shuffle=False\n", ")\n", "\n", "print(f'X_train: {X_train.shape}')\n", "print(f'X_val: {X_val.shape}')" ] }, { "cell_type": "markdown", "id": "0f1be871", "metadata": {}, "source": [ "## 2. Variable batch size training data loader" ] }, { "cell_type": "code", "execution_count": null, "id": "a1eee363", "metadata": {}, "outputs": [], "source": [ "def create_train_loader(batch_size: int, n_samples: int = None) -> DataLoader:\n", " '''Create a training DataLoader with specified batch size and optional sample limit.'''\n", "\n", " if n_samples is not None and n_samples < len(X_train):\n", "\n", " # Use a random subset\n", " indices = torch.randperm(len(X_train))[:n_samples]\n", " X_subset = X_train[indices]\n", " y_subset = y_train[indices]\n", " dataset = torch.utils.data.TensorDataset(X_subset, y_subset)\n", "\n", " else:\n", " dataset = torch.utils.data.TensorDataset(X_train, y_train)\n", "\n", " return DataLoader(dataset, batch_size=batch_size, shuffle=True)" ] }, { "cell_type": "markdown", "id": "4be5e40b", "metadata": {}, "source": [ "## 3. Define CNN architecture\n", "\n", "We use a simple 1-block grayscale CNN for fast training." ] }, { "cell_type": "code", "execution_count": 6, "id": "8bdcb94a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model parameters: 273,258\n" ] } ], "source": [ "def create_cnn():\n", " '''Create a fresh 1-block grayscale CNN.'''\n", "\n", " return nn.Sequential(\n", " \n", " # Conv block: 1 -> 32 channels, 32x32 -> 8x8\n", " nn.Conv2d(1, 32, kernel_size=3, padding=1),\n", " nn.BatchNorm2d(32),\n", " nn.ReLU(),\n", " nn.MaxPool2d(2, 2),\n", " nn.Dropout(0.5),\n", " nn.Conv2d(32, 32, kernel_size=3, padding=1),\n", " nn.BatchNorm2d(32),\n", " nn.ReLU(),\n", " nn.MaxPool2d(2, 2),\n", " nn.Dropout(0.5),\n", " \n", " # Classifier\n", " nn.Flatten(),\n", " nn.Linear(32 * 8 * 8, 128),\n", " nn.ReLU(),\n", " nn.Dropout(0.5),\n", " nn.Linear(128, num_classes)\n", " )\n", "\n", "# Show model summary\n", "model = create_cnn().to(device)\n", "params = sum(p.numel() for p in model.parameters() if p.requires_grad)\n", "print(f'Model parameters: {params:,}')\n", "del model" ] }, { "cell_type": "markdown", "id": "f6444f57", "metadata": {}, "source": [ "## 4. Training function" ] }, { "cell_type": "code", "execution_count": 7, "id": "1eda330c", "metadata": {}, "outputs": [], "source": [ "def train_with_optimizer(\n", " optimizer_name: str,\n", " learning_rate: float,\n", " n_epochs: int,\n", " print_every: int,\n", " train_loader: DataLoader = None,\n", " batch_size: int = 10000,\n", " n_samples: int = None\n", ") -> dict:\n", " '''Train a fresh model with the specified optimizer and return history.'''\n", " \n", " # Create train loader if not provided\n", " if train_loader is None:\n", " train_loader = create_train_loader(batch_size, n_samples)\n", " \n", " # Create fresh model with same initialization\n", " torch.manual_seed(315)\n", " model = create_cnn().to(device)\n", " \n", " # Create optimizer and criterion\n", " optimizer = optimizer_configs[optimizer_name](model.parameters(), learning_rate)\n", " criterion = nn.CrossEntropyLoss()\n", " \n", " # Train the model\n", " history = train_model(\n", " model=model,\n", " train_loader=train_loader,\n", " val_loader=val_loader,\n", " criterion=criterion,\n", " optimizer=optimizer,\n", " epochs=n_epochs,\n", " print_every=print_every\n", " )\n", " \n", " return history" ] }, { "cell_type": "markdown", "id": "4449f0aa", "metadata": {}, "source": [ "---\n", "\n", "## Part 1: Batch size effect (true SGD vs mini-batch)\n", "\n", "PyTorch's `SGD` optimizer is only *true* stochastic gradient descent when `batch_size=1`. \n", "With larger batches, it's mini-batch gradient descent.\n", "\n", "Let's see how batch size affects training with vanilla SGD (no momentum):\n", "- **batch_size=1**: True SGD - update after every sample (noisy but can escape local minima)\n", "- **batch_size=4, 16, 64**: Mini-batch - smoother gradients, faster per epoch\n", "\n", "> We use a subset of the training data (`n_samples_part1`) to keep runtime reasonable." ] }, { "cell_type": "code", "execution_count": 8, "id": "2e3245fe", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Using 1024 samples\n", "\n", "Training with batch_size=1 (1024 batches/epoch)\n", "Epoch 1/50 - loss: 2.3429 - acc: 8.98% - val_loss: 2.3029 - val_acc: 9.78%\n", "Epoch 10/50 - loss: 2.2816 - acc: 12.79% - val_loss: 2.2772 - val_acc: 11.30%\n", "Epoch 20/50 - loss: 1.9437 - acc: 30.27% - val_loss: 2.1242 - val_acc: 21.86%\n", "Epoch 30/50 - loss: 1.6111 - acc: 40.53% - val_loss: 2.1542 - val_acc: 24.10%\n", "Epoch 40/50 - loss: 1.3565 - acc: 51.46% - val_loss: 2.1505 - val_acc: 24.82%\n", "Epoch 50/50 - loss: 1.1365 - acc: 59.57% - val_loss: 2.3688 - val_acc: 24.66%\n", "-> Final val acc: 24.66% (took 384.0s)\n", "\n", "Training with batch_size=4 (256 batches/epoch)\n", "Epoch 1/50 - loss: 2.3070 - acc: 13.96% - val_loss: 2.1872 - val_acc: 23.06%\n", "Epoch 10/50 - loss: 1.8807 - acc: 30.47% - val_loss: 1.8597 - val_acc: 33.58%\n", "Epoch 20/50 - loss: 1.5843 - acc: 45.02% - val_loss: 1.7411 - val_acc: 37.17%\n", "Epoch 30/50 - loss: 1.3685 - acc: 50.10% - val_loss: 1.7077 - val_acc: 41.01%\n", "Epoch 40/50 - loss: 1.1583 - acc: 58.40% - val_loss: 1.6565 - val_acc: 42.71%\n", "Epoch 50/50 - loss: 0.9381 - acc: 68.26% - val_loss: 1.6913 - val_acc: 43.28%\n", "-> Final val acc: 43.28% (took 167.5s)\n", "\n", "Training with batch_size=16 (64 batches/epoch)\n", "Epoch 1/50 - loss: 2.3366 - acc: 12.21% - val_loss: 2.2489 - val_acc: 22.01%\n", "Epoch 10/50 - loss: 1.8354 - acc: 32.81% - val_loss: 1.8908 - val_acc: 32.22%\n", "Epoch 20/50 - loss: 1.6414 - acc: 41.11% - val_loss: 1.7544 - val_acc: 37.42%\n", "Epoch 30/50 - loss: 1.4528 - acc: 47.46% - val_loss: 1.6877 - val_acc: 39.38%\n", "Epoch 40/50 - loss: 1.3435 - acc: 49.71% - val_loss: 1.6378 - val_acc: 41.28%\n", "Epoch 50/50 - loss: 1.1694 - acc: 57.32% - val_loss: 1.6584 - val_acc: 42.59%\n", "-> Final val acc: 42.59% (took 63.8s)\n", "\n", "Training with batch_size=64 (16 batches/epoch)\n", "Epoch 1/50 - loss: 2.3678 - acc: 9.67% - val_loss: 2.2945 - val_acc: 11.12%\n", "Epoch 10/50 - loss: 2.0736 - acc: 24.61% - val_loss: 2.0692 - val_acc: 28.39%\n", "Epoch 20/50 - loss: 1.8955 - acc: 30.76% - val_loss: 1.9393 - val_acc: 31.49%\n", "Epoch 30/50 - loss: 1.7879 - acc: 35.16% - val_loss: 1.8724 - val_acc: 33.31%\n", "Epoch 40/50 - loss: 1.7086 - acc: 40.43% - val_loss: 1.8178 - val_acc: 35.23%\n", "Epoch 50/50 - loss: 1.6265 - acc: 42.77% - val_loss: 1.7712 - val_acc: 36.92%\n", "-> Final val acc: 36.92% (took 35.7s)\n", "\n", "Training with batch_size=256 (4 batches/epoch)\n", "Epoch 1/50 - loss: 2.4081 - acc: 9.47% - val_loss: 2.3031 - val_acc: 8.59%\n", "Epoch 10/50 - loss: 2.2538 - acc: 16.50% - val_loss: 2.2565 - val_acc: 22.04%\n", "Epoch 20/50 - loss: 2.1579 - acc: 21.29% - val_loss: 2.1728 - val_acc: 25.46%\n", "Epoch 30/50 - loss: 2.0739 - acc: 26.37% - val_loss: 2.1045 - val_acc: 27.52%\n", "Epoch 40/50 - loss: 2.0178 - acc: 28.03% - val_loss: 2.0511 - val_acc: 29.13%\n", "Epoch 50/50 - loss: 1.9434 - acc: 30.37% - val_loss: 2.0041 - val_acc: 30.18%\n", "-> Final val acc: 30.18% (took 29.9s)\n", "\n", "Training with batch_size=1024 (1 batches/epoch)\n", "Epoch 1/50 - loss: 2.4103 - acc: 9.77% - val_loss: 2.3049 - val_acc: 7.69%\n", "Epoch 10/50 - loss: 2.3206 - acc: 11.62% - val_loss: 2.2998 - val_acc: 9.42%\n", "Epoch 20/50 - loss: 2.3107 - acc: 14.06% - val_loss: 2.2905 - val_acc: 11.93%\n", "Epoch 30/50 - loss: 2.2731 - acc: 14.45% - val_loss: 2.2746 - val_acc: 17.99%\n", "Epoch 40/50 - loss: 2.2393 - acc: 18.95% - val_loss: 2.2538 - val_acc: 23.24%\n", "Epoch 50/50 - loss: 2.2306 - acc: 16.80% - val_loss: 2.2317 - val_acc: 24.69%\n", "-> Final val acc: 24.69% (took 30.3s)\n", "\n", "CPU times: user 11min 27s, sys: 3.58 s, total: 11min 31s\n", "Wall time: 11min 51s\n" ] } ], "source": [ "%%time\n", "\n", "print(f'Using {n_samples_part1} samples')\n", "\n", "# Select data sample once for fair comparison across batch sizes\n", "subset_indices = torch.randperm(len(X_train))[:n_samples_part1]\n", "X_train_subset = X_train[subset_indices]\n", "y_train_subset = y_train[subset_indices]\n", "\n", "results_part1 = {}\n", "\n", "for bs in batch_sizes_part1:\n", " \n", " # Create loader from the same subset with different batch size\n", " train_loader_part1 = DataLoader(\n", " torch.utils.data.TensorDataset(X_train_subset, y_train_subset),\n", " batch_size=bs,\n", " shuffle=True\n", " )\n", "\n", " print(f'\\nTraining with batch_size={bs} ({len(train_loader_part1)} batches/epoch)')\n", " \n", " start = time.time()\n", " results_part1[bs] = train_with_optimizer(\n", " 'SGD', lr_part1, n_epochs_part1, \n", " print_every=print_every, \n", " train_loader=train_loader_part1\n", " )\n", " elapsed = time.time() - start\n", " \n", " final_acc = results_part1[bs]['val_accuracy'][-1]\n", " print(f'-> Final val acc: {final_acc:.2f}% (took {elapsed:.1f}s)')\n", "\n", "print()" ] }, { "cell_type": "code", "execution_count": 9, "id": "42c18f82", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAGMCAYAAADHg8H9AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xd0FFUbwOHflmTTeyMkhBBC7733LtJBigKKoCJSrKBSVawfIqiIqIACKh0s9N6k91ADIbSQ3pNNdne+PxYWQhJIICEB3uecObs7c+fOnaHcffc2laIoCkIIIYQQQgghhChw6qIugBBCCCGEEEII8aSSoFsIIYQQQgghhCgkEnQLIYQQQgghhBCFRIJuIYQQQgghhBCikEjQLYQQQgghhBBCFBIJuoUQQgghhBBCiEIiQbcQQgghhBBCCFFIJOgWQgghhBBCCCEKiQTdQgghhBBCCCFEIZGgWwghxGMhOTmZl19+GR8fH1QqFaNHjwbgxo0b9OrVC3d3d1QqFdOnTy/ScuZHbveUE5VKxYgRIx5d4e6jRYsWVKlSpdDyDwsLQ6VSMW/evEK7hhBCCPEoaIu6AEIIIZ5e8+bN48UXX8z1+J49e2jQoAEAU6dOZd68eYwfP56goCAqVqwIwJgxY1i3bh0TJ07Ex8eHOnXqFHg5p06dSqVKlejWrVuB55vTPT0KISEhLF68mMGDB1O6dOlHdl0hhBDiaSNBtxBCiCI3ZcoUAgMDs+0vW7as5f3mzZtp0KABEydOzJJm8+bNdO3albfffrvQyjd16lR69epV4EF3bvf0KISEhDB58mRatGhRLIPugIAA0tLSsLKyKuqiCCGEEA9Fgm4hhBBFrmPHjvdtoY6MjKRSpUo57ndxcSmkkhWu3O5JmLvT29jYFHUxhBBCiIcmY7qFEEIUa1u3bkWlUnHx4kX++ecfVCqVZayvSqVCURS+++47y/5b4uPjGT16NP7+/uh0OsqWLcvnn3+OyWTKkr/JZOKbb76hatWq2NjY4OnpSYcOHThw4ABgDv5SUlKYP3++5RqDBw++Z5kjIyMZMmQI3t7e2NjYUL16debPn3/fewoLC7vv81i4cCHly5fHxsaG2rVrs3379izHL126xPDhwylfvjy2tra4u7vTu3fvLHnPmzeP3r17A9CyZUvL9bdu3WpJs2bNGpo3b46joyNOTk7UrVuXRYsWZStPSEgILVu2xM7OjpIlS/LFF1/c9x4ANmzYQJMmTXBxccHBwYHy5cvz/vvvW47fPab71jPLabu7pX7NmjU0bdoUe3t7HB0deeaZZzh58mSeyiWEEEIUNGnpFkIIUeQSEhKIjo7Osk+lUuHu7k7FihX57bffGDNmDH5+frz11lsA1KxZk99++40XXniBtm3bMnDgQMu5qampNG/enKtXr/LKK69QqlQpdu/ezbhx47h+/XqWydaGDBnCvHnz6NixIy+//DIGg4EdO3bw33//UadOHX777Tdefvll6tWrx7BhwwAICgrK9V7S0tJo0aIF58+fZ8SIEQQGBrJkyRIGDx5MfHw8o0aNyvWePD097/mctm3bxp9//snIkSPR6XR8//33dOjQgX379lkmNdu/fz+7d++mb9+++Pn5ERYWxqxZs2jRogUhISHY2dnRrFkzRo4cyYwZM3j//fctY8lvvc6bN4+XXnqJypUrM27cOFxcXDh8+DBr166lf//+lvLExcXRoUMHevToQZ8+fVi6dCnvvfceVatWpWPHjrnex8mTJ+ncuTPVqlVjypQp6HQ6zp8/z65du3I959Yzu1N8fDxvvvkmXl5eln2//fYbgwYNon379nz++eekpqYya9YsmjRpwuHDh4tlV3ohhBBPOEUIIYQoInPnzlWAHDedTpclbUBAgPLMM89kywNQXn/99Sz7PvroI8Xe3l45e/Zslv1jx45VNBqNEh4eriiKomzevFkBlJEjR2bL12QyWd7b29srgwYNytM9TZ8+XQGUBQsWWPZlZGQoDRs2VBwcHJTExMT73lNObj2XAwcOWPZdunRJsbGxUbp3727Zl5qamu3cPXv2KIDy66+/WvYtWbJEAZQtW7ZkSRsfH684Ojoq9evXV9LS0rIcu/OZNG/ePFueer1e8fHxUXr27HnPe/n6668VQImKiso1zcWLFxVAmTt3bo7HTSaT0rlzZ8XBwUE5efKkoiiKkpSUpLi4uChDhw7NkjYiIkJxdnbOtl8IIYR4FKR7uRBCiCL33XffsWHDhizbmjVrHji/JUuW0LRpU1xdXYmOjrZsbdq0wWg0WrpkL1u2DJVKleNEZnd2Vc+Pf//9Fx8fH/r162fZZ2VlxciRI0lOTmbbtm0PdlNAw4YNqV27tuVzqVKl6Nq1K+vWrcNoNAJga2trOZ6ZmUlMTAxly5bFxcWFQ4cO3fcaGzZsICkpibFjx2YbU333M3FwcOD555+3fLa2tqZevXpcuHDhnte4NQZ/1apV2br759VHH33E33//zbx58yzj4jds2EB8fDz9+vXL8ueu0WioX78+W7ZseaBrCSGEEA9DupcLIYQocvXq1SvQpb7OnTvHsWPHcu2uHRkZCUBoaCi+vr64ubkV2LUvXbpEcHAwanXW37Vvdd2+dOnSA+cdHBycbV+5cuVITU0lKioKHx8f0tLS+PTTT5k7dy5Xr15FURRL2oSEhPteIzQ0FCBPa3D7+fllC8RdXV05duzYPc977rnn+Omnn3j55ZcZO3YsrVu3pkePHvTq1Svbc8vJ2rVrmTx5MuPGjaNnz56W/efOnQOgVatWOZ7n5OR037yFEEKIgiZBtxBCiCeOyWSibdu2vPvuuzkeL1eu3CMu0aPzxhtvMHfuXEaPHk3Dhg1xdnZGpVLRt2/fB25Vzo1Go8lx/52Bfk5sbW3Zvn07W7Zs4Z9//mHt2rX8+eeftGrVivXr1+eaL8DFixcZMGAAbdu25eOPP85y7Nb9/fbbb/j4+GQ7V6uVrz1CCCEePal9hBBCPHGCgoJITk6mTZs29023bt06YmNj79nanZ+u5gEBARw7dgyTyZSl1fb06dOW4w/qVkvunc6ePYudnZ2lVX/p0qUMGjSI//3vf5Y06enpxMfHZzkvt3u6NUnciRMnsqyTXtDUajWtW7emdevWTJs2jalTp/LBBx+wZcuWXP/c0tLS6NGjBy4uLvz+++/ZWsVvld3Ly+u+f/ZCCCHEoyJjuoUQQjxx+vTpw549e1i3bl22Y/Hx8RgMBgB69uyJoihMnjw5W7o7W2vt7e2zBa256dSpExEREfz555+WfQaDgZkzZ+Lg4EDz5s3zeTe37dmzJ8u47MuXL7Nq1SratWtnaR3WaDTZWppnzpxpGfN9i729PUC2+2rXrh2Ojo58+umnpKenZzl2vxbsvIqNjc22r0aNGgDo9fpcz3v11Vc5e/YsK1aswNXVNdvx9u3b4+TkxNSpU8nMzMx2PCoq6sELLYQQQjwgaekWQghR5NasWWNpCb5To0aNKFOmTL7ze+edd1i9ejWdO3dm8ODB1K5dm5SUFI4fP87SpUsJCwvDw8ODli1b8sILLzBjxgzOnTtHhw4dMJlM7Nixg5YtWzJixAgAateuzcaNG5k2bRq+vr4EBgZSv379HK89bNgwZs+ezeDBgzl48CClS5dm6dKl7Nq1i+nTp+Po6Jjv+7mlSpUqtG/fPsuSYUCWHw06d+7Mb7/9hrOzM5UqVWLPnj1s3LgRd3f3LHnVqFEDjUbD559/TkJCAjqdjlatWuHl5cXXX3/Nyy+/TN26denfvz+urq4cPXqU1NTULOuNP6gpU6awfft2nnnmGQICAoiMjOT777/Hz8+PJk2a5HjOP//8w6+//krPnj05duxYlnHjDg4OdOvWDScnJ2bNmsULL7xArVq16Nu3L56enoSHh/PPP//QuHFjvv3224cuvxBCCJEvRTl1uhBCiKfbvZYM467lovKzZJiimJePGjdunFK2bFnF2tpa8fDwUBo1aqR89dVXSkZGhiWdwWBQvvzyS6VChQqKtbW14unpqXTs2FE5ePCgJc3p06eVZs2aKba2tgpw3+XDbty4obz44ouKh4eHYm1trVStWjXHpa/yu2TY66+/rixYsEAJDg5WdDqdUrNmzWxLfsXFxVmu7eDgoLRv3145ffq0EhAQkK3cc+bMUcqUKaNoNJpsy4etXr1aadSokWJra6s4OTkp9erVU37//XfL8ebNmyuVK1fOVs5BgwYpAQEB97yXTZs2KV27dlV8fX0Va2trxdfXV+nXr1+WJd7uXjLsXn9X7r7eli1blPbt2yvOzs6KjY2NEhQUpAwePDjLcmtCCCHEo6JSlALqKyaEEEIIIYQQQogsZEy3EEIIIYQQQghRSCToFkIIIYQQQgghCokE3UIIIYQQQgghRCGRoFsIIYQQQgghhCgkEnQLIYQQQgghhBCFRIJuIYQQQgghhBCikEjQLYQQQgghhBBCFBIJuoUQQgghhBBCiEIiQbcQQgghhBBCCFFIJOgWQgghhBBCCCEKiQTdQgghhBBCCCFEIZGgWwghhBBCCCGEKCQSdAshhBBCCCGEEIVEgm4hhBBCCCGEEKKQSNAthBBCCCGEEEIUEgm6hRBCCCGEEEKIQiJBtxBCCCGEEEIIUUgk6BZCCCGEEEIIIQqJBN1CCCGEEEIIIUQhkaBbCCGEEEIIIYQoJBJ0CyGEEEIIIYQQhUSCbiGEEEIIIYQQopBI0C2EEEIIIYQQQhQSCbqFEEIIIYQQQohCIkG3EEIIIYQQQghRSCToFqIAhIWFoVKpmDdvnmXfpEmTUKlUeTpfpVIxadKkAi1TixYtaNGiRYHmKYQQQhSUnOrOwlC6dGkGDx5cqNfIyd11+7x581CpVISFhd333MIo8+DBgyldunSB5imEyBsJusVTp0uXLtjZ2ZGUlJRrmgEDBmBtbU1MTMwjLFn+hYSEMGnSpDxV4EIIIcSjdCvIzGkbO3ZsURfviXTt2jUmTZrEkSNHirooQog7aIu6AEI8agMGDOCvv/5ixYoVDBw4MNvx1NRUVq1aRYcOHXB3d3/g63z44YeF/qUiJCSEyZMn06JFi2y/Xq9fv75Qry2EEELkxZQpUwgMDMyyr0qVKgQEBJCWloaVlVURlezReuGFF+jbty86na7QrnHt2jUmT55M6dKlqVGjRpZjc+bMwWQyFdq1hRC5k6BbPHW6dOmCo6MjixYtyjHoXrVqFSkpKQwYMOChrqPVatFqi+6fmLW1dZFd+3GSkpKCvb19URdDCCGeWB07dqROnTo5HrOxsXnEpSk6Go0GjUZTZNd/Wn7ceFjyvUAUBuleLp46tra29OjRg02bNhEZGZnt+KJFi3B0dKRLly7Exsby9ttvU7VqVRwcHHBycqJjx44cPXr0vtfJaUy3Xq9nzJgxeHp6Wq5x5cqVbOdeunSJ4cOHU758eWxtbXF3d6d3795ZupHPmzeP3r17A9CyZUtLl72tW7cCOY/pjoyMZMiQIXh7e2NjY0P16tWZP39+ljS3xth99dVX/PjjjwQFBaHT6ahbty779++/733n55mlp6czadIkypUrh42NDSVKlKBHjx6EhoZa0phMJr755huqVq2KjY0Nnp6edOjQgQMHDmQpb05jAu8eT3frzyQkJIT+/fvj6upKkyZNADh27BiDBw+mTJky2NjY4OPjw0svvZTjEIOrV68yZMgQfH190el0BAYG8tprr5GRkcGFCxdQqVR8/fXX2c7bvXs3KpWK33///b7PUQghnnQ5/f89ePBgHBwcuHr1Kt26dcPBwQFPT0/efvttjEZjlvO/+uorGjVqhLu7O7a2ttSuXZulS5fmuxyZmZm4ubnx4osvZjuWmJiIjY0Nb7/9NgAZGRlMmDCB2rVr4+zsjL29PU2bNmXLli33vU5OY7oVReHjjz/Gz88POzs7WrZsycmTJ7Odm5e6devWrdStWxeAF1980fK94NbzzWlMd0pKCm+99Rb+/v7odDrKly/PV199haIoWdKpVCpGjBjBypUrqVKlCjqdjsqVK7N27dr73nd+ntn96vxbFixYQL169bCzs8PV1ZVmzZpl6eGX21w5d4+Vv/Vnsm3bNoYPH46Xlxd+fn5A3r6L3RIfH8+YMWMoXbo0Op0OPz8/Bg4cSHR0NMnJydjb2zNq1Khs5125cgWNRsOnn3563+coHm/S0i2eSgMGDGD+/PksXryYESNGWPbHxsaybt06+vXrh62tLSdPnmTlypX07t2bwMBAbty4wezZs2nevDkhISH4+vrm67ovv/wyCxYsoH///jRq1IjNmzfzzDPPZEu3f/9+du/eTd++ffHz8yMsLIxZs2bRokULQkJCsLOzo1mzZowcOZIZM2bw/vvvU7FiRQDL693S0tJo0aIF58+fZ8SIEQQGBrJkyRIGDx5MfHx8tspg0aJFJCUl8corr6BSqfjiiy/o0aMHFy5cuOev5RcuXMjTMzMajXTu3JlNmzbRt29fRo0aRVJSEhs2bODEiRMEBQUBMGTIEObNm0fHjh15+eWXMRgM7Nixg//++y/XlpP76d27N8HBwUydOtXyxWLDhg1cuHCBF198ER8fH06ePMmPP/7IyZMn+e+//yw/oFy7do169eoRHx/PsGHDqFChAlevXmXp0qWkpqZSpkwZGjduzMKFCxkzZkyW6y5cuBBHR0e6du36QOUWQojHUUJCAtHR0Vn2eXh45JreaDTSvn176tevz1dffcXGjRv53//+R1BQEK+99pol3TfffEOXLl0YMGAAGRkZ/PHHH/Tu3Zu///47x7o1N1ZWVnTv3p3ly5cze/bsLD3FVq5ciV6vp2/fvoA5CP/pp5/o168fQ4cOJSkpiZ9//pn27duzb9++bF2672fChAl8/PHHdOrUiU6dOnHo0CHatWtHRkZGlnR5qVsrVqzIlClTmDBhAsOGDaNp06YANGrUKMdrK4pCly5d2LJlC0OGDKFGjRqsW7eOd955h6tXr2b78Xjnzp0sX76c4cOH4+joyIwZM+jZsyfh4eH3HI6Xn2eWlzp/8uTJTJo0iUaNGjFlyhSsra3Zu3cvmzdvpl27dvl6/rcMHz4cT09PJkyYQEpKCpC372IAycnJNG3alFOnTvHSSy9Rq1YtoqOjWb16NVeuXKFGjRp0796dP//8k2nTpmXp7fD777+jKMpD964UjwFFiKeQwWBQSpQooTRs2DDL/h9++EEBlHXr1imKoijp6emK0WjMkubixYuKTqdTpkyZkmUfoMydO9eyb+LEicqd/8SOHDmiAMrw4cOz5Ne/f38FUCZOnGjZl5qamq3Me/bsUQDl119/texbsmSJAihbtmzJlr558+ZK8+bNLZ+nT5+uAMqCBQss+zIyMpSGDRsqDg4OSmJiYpZ7cXd3V2JjYy1pV61apQDKX3/9le1ad8rrM/vll18UQJk2bVq2PEwmk6IoirJ582YFUEaOHJlrmpye/S13P9dbfyb9+vXLljanZ/77778rgLJ9+3bLvoEDBypqtVrZv39/rmWaPXu2AiinTp2yHMvIyFA8PDyUQYMGZTtPCCGeRHPnzlWAHDdFyfn/70GDBilAlvpCURSlZs2aSu3atbPsu/v/7YyMDKVKlSpKq1atsuwPCAi47/+969aty7GO69Spk1KmTBnLZ4PBoOj1+ixp4uLiFG9vb+Wll17Ksv/uOujW87h48aKiKIoSGRmpWFtbK88884yl/lAURXn//fcVIEuZ81q37t+/P9c6cdCgQUpAQIDl88qVKxVA+fjjj7Ok69Wrl6JSqZTz589nuRdra+ss+44ePaoAysyZM7Nd6055fWZ5qfPPnTunqNVqpXv37tmex53P8O5nf8vdfxdu/Zk0adJEMRgMWdLm9bvYhAkTFEBZvnx5ruW+9fdrzZo1WY5Xq1Yty3c18eSS7uXiqaTRaOjbty979uzJ0k1o0aJFeHt707p1awB0Oh1qtfmfidFoJCYmBgcHB8qXL8+hQ4fydc1///0XgJEjR2bZP3r06GxpbW1tLe8zMzOJiYmhbNmyuLi45Pu6d17fx8eHfv36WfZZWVkxcuRIkpOT2bZtW5b0zz33HK6urpbPt34xv3Dhwj2vk9dntmzZMjw8PHjjjTey5XGrVXnZsmWoVComTpyYa5oH8eqrr2bbd+czT09PJzo6mgYNGgBYym0ymVi5ciXPPvtsjq3st8rUp08fbGxsWLhwoeXYunXriI6O5vnnn3/gcgshxOPou+++Y8OGDVm2+7n7/+mmTZtmq3/u/H87Li6OhIQEmjZt+kD1ZKtWrfDw8ODPP//MkueGDRt47rnnLPs0Go2lJdxkMhEbG4vBYKBOnTr5vu7GjRvJyMjgjTfeyFKn5fS9oCC/j9zy77//otFosn0veeutt1AUhTVr1mTZ36ZNG0svNIBq1arh5OR03+8FeX1meanzV65ciclkYsKECZbncXeaBzF06NBs4+3z+l1s2bJlVK9ene7du+da7jZt2uDr65vle8GJEyc4duyYfC94SkjQLZ5at7ryLFq0CDCPq9mxYwd9+/a1/MdrMpn4+uuvCQ4ORqfT4eHhgaenJ8eOHSMhISFf17t06RJqtTpLhQVQvnz5bGnT0tKYMGGCZYzVrevGx8fn+7p3Xj84ODhbJXWrO/qlS5ey7C9VqlSWz7cC8Li4uHteJ6/PLDQ0lPLly99zsrnQ0FB8fX1xc3O7/w3mw92z6IJ5aMGoUaPw9vbG1tYWT09PS7pb5Y6KiiIxMZEqVarcM38XFxeeffZZy98tMHctL1myJK1atSrAOxFCiOKvXr16tGnTJst2L7fG8t7J1dU1W/3z999/06BBA2xsbHBzc8PT05NZs2Y9UD2p1Wrp2bMnq1atQq/XA7B8+XIyMzOzBN0A8+fPp1q1atjY2ODu7o6npyf//PPPA30vAAgODs6y39PTM8uP3lCw30fuvL6vry+Ojo5Z9uf1ewHk/OeSk7w8s7zU+aGhoajVaipVqnTfa+ZHTt8L8vpdLDQ09L7fC9RqNQMGDGDlypWkpqYC5u8FNjY2lvl5xJNNgm7x1KpduzYVKlSwTGqV07iaqVOn8uabb9KsWTMWLFjAunXr2LBhA5UrVy7UZTfeeOMNPvnkE/r06cPixYtZv349GzZswN3d/ZEt95HbDKvKXZOr3O1RP7Pcftm+e8KdO9356/Utffr0Yc6cObz66qssX76c9evXWyaIeZByDxw4kAsXLrB7926SkpJYvXo1/fr1y/ajhxBCiKzyMsP3jh076NKlCzY2Nnz//ff8+++/bNiwgf79+9+3nspN3759SUpKsrTwLl68mAoVKlC9enVLmgULFjB48GCCgoL4+eefWbt2LRs2bKBVq1aFWj8X1feROz3o94KiemY5ye27QU7fCwr6u9jAgQNJTk5m5cqVKIrCokWL6Ny5M87OzvnOSzx+ZCI18VQbMGAA48eP59ixYyxatIjg4GDLzJ8AS5cupWXLlvz8889ZzouPj7/nJDA5CQgIwGQyWVp4bzlz5ky2tEuXLmXQoEH873//s+xLT08nPj4+S7r8dKUKCAjg2LFjmEymLIHf6dOnLccLQl6fWVBQEHv37iUzMzPXidmCgoJYt24dsbGxuf7yfas14O5nc/cv9PcSFxfHpk2bmDx5MhMmTLDsP3fuXJZ0np6eODk5ceLEifvm2aFDBzw9PVm4cCH169cnNTWVF154Ic9lEkIIkbtly5ZhY2PDunXrsqx7PXfu3AfOs1mzZpQoUYI///yTJk2asHnzZj744IMsaZYuXUqZMmVYvnx5ljo4py7R93Or3j137hxlypSx7I+KisrWepzXujW/3ws2btxIUlJSltbuwvhekJdnlpc6PygoCJPJREhIyD0nrXN1dc32vSAjI4Pr16/nq9x5+S4WFBSUp+8FVapUoWbNmixcuBA/Pz/Cw8OZOXNmnssjHm/S5CKeardatSdMmMCRI0eyzR6p0Wiy/YK7ZMkSrl69mu9rdezYEYAZM2Zk2T99+vRsaXO67syZM7P9QntrHcm7K4CcdOrUiYiIiCzj1QwGAzNnzsTBwYHmzZvn5TbuK6/PrGfPnkRHR/Ptt99my+PW+T179kRRFCZPnpxrGicnJzw8PNi+fXuW499//32+ynxnnrfc/WejVqvp1q0bf/31V7blS+4+X6vV0q9fPxYvXsy8efOoWrUq1apVy3OZhBBC5E6j0aBSqbLUi2FhYaxcufKB81Sr1fTq1Yu//vqL3377DYPBkK1reU71xd69e9mzZ0++r9emTRusrKyYOXNmlvzy+r0gp7o1v98LjEZjtnr466+/RqVSWb63PKy8PrO81PndunVDrVYzZcqUbK3Nd+YfFBSU7XvBjz/+eM9ecDmVOy/fxXr27MnRo0dZsWJFruW+5YUXXmD9+vVMnz4dd3f3AnvGoviTlm7xVAsMDKRRo0asWrUKIFvQ3blzZ6ZMmcKLL75Io0aNOH78OAsXLszyi3Re1ahRg379+vH999+TkJBAo0aN2LRpE+fPn8+WtnPnzvz22284OztTqVIl9uzZw8aNG7MtyVGjRg00Gg2ff/45CQkJ6HQ6WrVqhZeXV7Y8hw0bxuzZsxk8eDAHDx6kdOnSLF26lF27djF9+vRsY7oeVF6f2cCBA/n1119588032bdvH02bNiUlJYWNGzcyfPhwunbtSsuWLXnhhReYMWMG586do0OHDphMJnbs2EHLli0ty729/PLLfPbZZ7z88svUqVOH7du3c/bs2TyX2cnJiWbNmvHFF1+QmZlJyZIlWb9+PRcvXsyWdurUqaxfv57mzZszbNgwKlasyPXr11myZAk7d+7ExcUlyz3OmDGDLVu28Pnnnz/YAxVCCJHNM888w7Rp0+jQoQP9+/cnMjKS7777jrJly3Ls2LEHzve5555j5syZTJw4kapVq2ZbhrNz584sX76c7t2788wzz3Dx4kV++OEHKlWqRHJycr6udWv98U8//ZTOnTvTqVMnDh8+zJo1a7L1pstr3RoUFISLiws//PADjo6O2NvbU79+/RzHLD/77LO0bNmSDz74gLCwMKpXr8769etZtWoVo0ePzjYHzYPK6zPLS51ftmxZPvjgAz766COaNm1Kjx490Ol07N+/H19fX8t61y+//DKvvvoqPXv2pG3bthw9epR169blq5diXr+LvfPOOyxdupTevXvz0ksvUbt2bWJjY1m9ejU//PBDluEJ/fv3591332XFihW89tpr91yCVTxhHuFM6UIUS999950CKPXq1ct2LD09XXnrrbeUEiVKKLa2tkrjxo2VPXv2ZFuOKy9LhimKoqSlpSkjR45U3N3dFXt7e+XZZ59VLl++nG1pi7i4OOXFF19UPDw8FAcHB6V9+/bK6dOnc1z2ZM6cOUqZMmUUjUaTZfmwu8uoKIpy48YNS77W1tZK1apVsy0rcutevvzyy2zP4+5y5iSvz0xRzMtxfPDBB0pgYKBiZWWl+Pj4KL169VJCQ0MtaQwGg/Lll18qFSpUUKytrRVPT0+lY8eOysGDB7PkM2TIEMXZ2VlxdHRU+vTpo0RGRua6ZFhUVFS2cl+5ckXp3r274uLiojg7Oyu9e/dWrl27luM9X7p0SRk4cKDi6emp6HQ6pUyZMsrrr7+ebUkURVGUypUrK2q1Wrly5co9n5sQQjxpbi3HlNMSi4qS+5Jh9vb22dLmVKf+/PPPSnBwsKLT6ZQKFSooc+fOzTFdXpYMu8VkMin+/v45LqV16/jUqVOVgIAARafTKTVr1lT+/vvvbMtxKcr9lwxTFEUxGo3K5MmTLXVmixYtlBMnTmQrc37q1lWrVimVKlVStFptluebUxmTkpKUMWPGKL6+voqVlZUSHBysfPnll1mW37p1L6+//nq255GXZ5ufZ5aXOl9RzMuO1qxZU9HpdIqrq6vSvHlzZcOGDVme63vvvad4eHgodnZ2Svv27ZXz58/numRYTn9H8/NdLCYmRhkxYoRSsmRJxdraWvHz81MGDRqkREdHZ8u3U6dOCqDs3r37ns9NPFlUivKAs00IIYS4r5o1a+Lm5samTZuKuihCCCGEKGLdu3fn+PHjOfZ0FE8uGdMthBCF5MCBAxw5coSBAwcWdVGEEEIIUcSuX7/OP//8IxOrPoWkpVsIIQrYiRMnOHjwIP/73/+Ijo7mwoUL2NjYFHWxhBBCCFEELl68yK5du/jpp5/Yv38/oaGh+Pj4FHWxxCMkLd1CCFHAli5dyosvvkhmZia///67BNxCCCHEU2zbtm288MILXLx4kfnz50vA/RQqNkH3Z599hkqlYvTo0ZZ9LVq0QKVSZdleffXVoiukEELkwaRJkzCZTJw6darAlmIT4lHavn07zz77LL6+vqhUqmzLMCmKwoQJEyhRogS2tra0adMm27r2sbGxDBgwACcnJ1xcXBgyZEi+Z3cWQognweDBg1EUhUuXLtGrV6+iLo4oAsUi6N6/fz+zZ8/OcQ3boUOHcv36dcv2xRdfFEEJhRBCiKdHSkoK1atX57vvvsvx+BdffMGMGTP44Ycf2Lt3L/b29rRv35709HRLmgEDBnDy5Ek2bNjA33//zfbt2xk2bNijugUhhBCi2CjydbqTk5MZMGAAc+bM4eOPP8523M7O7qG6YJhMJq5du4ajoyMqlephiiqEEEIUOEVRSEpKwtfXF7W6WPwWTseOHenYsWOOxxRFYfr06Xz44Yd07doVgF9//RVvb29WrlxJ3759OXXqFGvXrmX//v3UqVMHgJkzZ9KpUye++uorfH19c8xbr9ej1+stn00mE7Gxsbi7u0sdLoQQotjJcx1eZIuV3TRw4EBl9OjRiqKY1xUeNWqU5Vjz5s0VDw8Pxd3dXalcubIyduxYJSUl5Z75paenKwkJCZYtJCREAWSTTTbZZJOtWG+XL18uzOr2gQHKihUrLJ9DQ0MVQDl8+HCWdM2aNVNGjhypKIp5/WQXF5csxzMzMxWNRqMsX74812vdWmNZNtlkk0022R6n7X51eJG2dP/xxx8cOnSI/fv353i8f//+BAQE4Ovry7Fjx3jvvfc4c+YMy5cvzzXPTz/9lMmTJ2fbf/nyZZycnAqs7EIIIURBSExMxN/fH0dHx6IuSp5EREQA4O3tnWW/t7e35VhERAReXl5Zjmu1Wtzc3CxpcjJu3DjefPNNy+eEhARKlSoldbgQQohiKa91eJEF3ZcvX2bUqFFs2LAh15l97xz7VbVqVUqUKEHr1q0JDQ0lKCgox3PurrBvPQgnJyepsIUQQhRb0n0adDodOp0u236pw4UQQhRn96vDi2zw2MGDB4mMjKRWrVpotVq0Wi3btm1jxowZaLVajEZjtnPq168PwPnz53PNV6fTWSpnqaSFEEKIgnVrnpUbN25k2X/jxg3LMR8fHyIjI7McNxgMxMbGylI5QgghnjpFFnS3bt2a48ePc+TIEctWp04dBgwYwJEjR9BoNNnOOXLkCAAlSpR4xKUVQgghBEBgYCA+Pj5s2rTJsi8xMZG9e/fSsGFDABo2bEh8fDwHDx60pNm8eTMmk8nyA7oQQgjxtCiy7uWOjo5UqVIlyz57e3vc3d2pUqUKoaGhLFq0iE6dOuHu7s6xY8cYM2YMzZo1y3FpMSGEEEIUjOTk5Cy9yi5evMiRI0dwc3OjVKlSjB49mo8//pjg4GACAwMZP348vr6+dOvWDYCKFSvSoUMHhg4dyg8//EBmZiYjRoygb9++uc5cLoQQQjypinzJsNxYW1uzceNGpk+fTkpKCv7+/vTs2ZMPP/ywqIsmhBBCPNEOHDhAy5YtLZ9vzZUyaNAg5s2bx7vvvktKSgrDhg0jPj6eJk2asHbt2ixztCxcuJARI0bQunVr1Go1PXv2ZMaMGY/8XoQQQoiiprq5HMgTKzExEWdnZxISEmR8txBCiGJH6qncybMRQghRnOW1niqyMd1CCCGEEEIIIcSTToJuIYQQQgghhBCikEjQLYQQQgghhBBCFBIJuoUQQoj8UBTYMhViQou6JEIIIYR4DEjQLYQQQuTH1k9h2+cwtyPok4q6NEIIIYQo5iToFkIIIfJq3xxzwA3Q/D3QORZteYQQQghR7EnQLYQQQuTFyZXw7zvm9y3GQd0hRVocIYQQQjweJOgWQoinUXoiHF8KSTeKuiQPJCYthsuJlx/dBS9sg+VDAQXqDEFp9u6ju7YQQgghHmvaoi6AEEKIRygpAv6bBQd+AX0iuJeFYVsLvpt0aixEnYFSDUClyv/5cWFwcbt50rI7KIrC8rjjfB6xhQyTgR9qvUOD4K5g45T3omWmMn7XeJx1zoyrPw4rtdW9T7h+FP4YAMYMqNiFtHZTGLnxFQZUHEAL/xb5vzchhBBCPFUk6BZCiKdB9HnY/Q0c/cMcPAKo1BBzHv4aBT1/frDg+G5RZ2DvD3DkdzCkQePR0HZy/vJIiYZfOkDS9Sy7Y9RqJnm4sdXezrLvnf2f8ueqUfjq3M0/IHiUNb+6l4WSdcDRO0seJsXE2B1j2XJ5CwCZpkymNJqCKrd7j70AC3pBRhKUboqh2yze2TGW/67/x5nYM6zpuQZ7K/v83Z8QQgghnioSdAshRHFl0IPG+uGC4SsHYNd0OPU3cLPV2L8BNB4Fdm4w7xk4sQwCGj/4GGVFgdBN5hb08xuzHts1HUo3heA2ecvLZIIVr5oDbqeSUKI6ANtNSYw3XCEWI1aoeF3jxTpDLKc0MMbLg1+v30CXEgnhu2/npbWFzl9DjX6WXd8d+Y4tl7dgpbbCqBhZeX4lvva+vFbjtexlSY6E33pASiR4V0V5bgGTD3zOtivb0Gl0TG85XQJuIYQQQtyXBN1CCFFcmIxw7TCEbobQLXBlHzj7Q6+foWTt/OUVE2puwQ7bcXtf+U7mYLtUg9v72kyC9R/C2rHma/jWyPs1MlLh2B/w3w8QfebmThVUeAYavAYnV8D+n2DFMHh1FziVuH+e/30H5zeA1gYGLCHVLZCvDnzFkrNLACjrUpbPmn5GebfydEy+xnN/P0cI8XzccABTvFugig01t95HHIPos7DyVXMg3vEL1l7Zxo/HfgRgcqPJpBnS+Oi/j/j+6Pf42PvQPbj77XKkJ8KCnhB3EVwC4PllfBMyj5XnV6JWqfmy2ZfU8q6V92clhBBCiKeWBN1CCFGU4sJuB9kXt0F6wl3HL5q7Wnf6CmoPylueJ5bB6lHmLtFqK6j2HDR6A7wqZE/bcARc2gNn/oElg2DYNrB1uXf+igKHfoWNEyEtzrzP2hFqDYR6Q8EtkPj0eI4oqTS6/B/WESdg2cswaDWoNbnne+UgbJxkft/hU46rTYz7uw+XEi8BMLDSQEbWGolOowPA18GXz5t9zmsbX2Pl9R1UDWhBn5bjzOebjLD9S9j6GRz6lZPXDzDeztyt/sXKL/Js0LMAXE+5zk/Hf2Lynsl42XnRuGRjuBEC/75tDtztPOCFFfx2eT0/n/gZgIkNJ9KyVMv7/jEIIYQQQgCoFOWuWWqeMImJiTg7O5OQkICTU94n2hFCiPsyZJgnI7P3yP+58eGwbChc/i/rfhtnCGwGQa3Avz5s/sQcEAPUGgSdvgStLuc8M9PMLdYH55k/l2oEPWaDS6l7lyUtDmY3M5epQmf0vX7mjzN/svL8SlqXas3QakMtgS76JPhrNJxYav7sWhrqvwY1+lsmM9t2eRsTdk8gNj2WCk6BfHbuMEGpidB8LNwKiu+WngA/NIX4S+grPsuccg346fhPGBUjXnZefNLkExqUaJDjqT8f/5nph6ajVWuZ12Ee1T2r3z4YupnoFUPp62rNDa2Wps7lmNllMZqbwb+iKIzbOY5/LvyDnVrHPJMHFS/uMZ9r7QCD/+bf9Ou8t+M9AEbVGsXLVV++9/PMJ6mncifPRgghRHGW13pKgm4hhHgQigK/djW3TjcYDq0ngJVt3s49v9Hc8psWB2ot+NU1B9llWoJvTdDc0QnJZIKd02Dzx4ACvrXgud/A2S9rnlFnYclgiDwJqKDZ2+YgV5PHDk1XD2H6pT1rbLTM9A3kqiHJcijAKYAJDSZQD535GrEXQKUx33OjNyyt1ymZKXy5/0uWnVuWJWudSstbUZH0TUpBNXAVlGme9dqKYs43ZCX7PUoxxdefsCTzcmAdS3fkgwYf4KxzzrXoiqLw1ra32HBpA162Xvz57J942Jp/CNEb9bz0zwsciztFYEYmC69F4Fj/NWgzGbTWoE8m88gCXjvxPXu1Cp4GAwuvR1EiuCM0f5fdxiRe3/w6BpOBARUH8F7d93KfdO0BST2VO3k2QgghijMJum+SClsIUShOrjAHire4B0P32eB3j7HXJhPs+Aq2TMUcQNeEPr/m2BKdoE9gzcU1eNh60CagTdZA3c4des29Hbwe+R3+eRMyU8HeE3r8aA7i82F/xH7+t20sJ9MjAfCydqFHxb4sO7uMqLQoALomp/J2TCwuDr7Q6xcoVd9y/qEbh3h/5/tcTb6KChUDKw2kX8V+fLTnI3Zd2wVA09Q0pqSq8XhlFzh43r74gV9I+Pct/ufuygoH88RkHrYejK03lval2+ep/CmZKfT7px8XEy5S27s2c9rNQavS8uGuD1kduhonaycWOdcjYN8v5hP86pp7Ehz6DfQJJKlUDCzpy3krDUGOpZj/zCIuJ13mpXUvkWZIo2NgRz5r+hlqlTpfzzUvpJ7KnTwbIYQQxZkE3TdJhS2EKHAGPXxXzzweu1I3CP8PkiPMrb9N34Rm74LWGpNiIlGfiIuNizlYXv4KnFtnzqP2YOjwOVjZWLJVFIXj0cf588yfrAtbh96oB2BEjREMqzYMVfwl+PN5iDhuXu6r1XjzpGFHFpozCGwGPX7KtkzWvVyIv8C0g9PYdmUbAHaoGRIbyws4Y/vKdpIyU/nmrxdYbIhCUalwRcM79cbSucJzqFQqMowZfHvkW+admIeCgq+9Lx83+Zi6PnUB8xJdv5/+nWkHppFhysDNaGSK1o/mz68FtRol4gT/LurEFy4OxGrMLea9y/VmdO3ROFnn7//sCwkX6P9Pf1IyU3i+4vP42Pvw1YGv0Kg0zGozi4a+DeH0v+bJ1e4cO+8WBA1eI6JsKwZsGkZkaiTVPasTnhhOnD6OBiUa8H3r77HS3Gc97wck9VTu5NkIIYQoziTovkkqbCFEgdv9Laz/ABx8YOQhcxD+7zu3xzn7VOVsmw8YdXQGV5KvUNLGk1oJUdRMiqFWJpRp9zmqWi9YskvNTOXfi/+y+MxiTsWesuz3d/Tn8s1u1oMqDeKtOm+hMqTD32Pg6O+3y6NSQ4tx0PQtS1dvk2Jiy+UtRKZGYjAZMJqMGBSD+b1ixGAyEJESwZqLazAqRjQqDb3K9eK1Ci/g/ms3cxfygCaQcBniL3HE1o7JpYI5n2GeOK1hiYY8X+l5vjn0DWfjzgLQrWw33qv7Hg7WDtke2bm4c4zdMoazSeZJ0Z5zqkDfJhP4cvXz7NaaAAhyLsPERpOo6VXzgf9oNl3axOito82PBRUKCmPrjWVAxQG3E8WFmcelqzVQbxiUbQtqcwv2mdgzDFo7iJTMFAAqu1fm5/Y/F+rSYFJP5U6ejRBCiOJMgu6bpMIWQhSo1FiYUcPcUtplpnnG7ltOroC/32STKo1xnu6kqXPuiuyic6GGVw1qe9Xmesp1VoeuJjkzGQBrtTUdAjvQp3wfqnlUY8GpBXyx/wsAegT3YEKDCWhUavNSXGvHmSdx6/kTlG5iyf9S4iUm7JrAochDebqlVv6tGF17NIHOgeYdEcdhTmu42dKOSwD0nkumTzXmnZzHD0d/IMOUYTnfzcaNCQ0n0LpU63teR2/U882aV/kt5kCW/daKwitVXubFmq8XSGvyjEMzmHN8DgA9g3syseHEfI3D3nNtD29sfgNfB1/mtp+Lu637Q5fpXqSeyp08GyGEEMWZBN03SYUtRDFnzARDeu7HFZM5wE2NubnF3vE+BjJSILgdVO5+7+WoCsra981rSXtVhld3ZLmmoij8eGAa34bMA6B+WjpTomMI01pxyLcihzxKcTz2FOnG7Pfr7+hPn3J96Fa2m7k7+h1WnFvBpD2TMCkm2gW047Omn5mD0+Qo0DlYJnAzmowsPLWQGYdnoDfqsdPa0bhkY7RqLVqVFq1ai0atQaPSYKW2wkpjRQu/FjmvN33kd/M63xU6QefpWZYRC08MZ8p/U9h7fS8t/FswqeGkvAemisLuxX34MPkEUVot9dPSGd/sUwIq9crb+XlgNBmZdnAaeqOe9+q+90CBfII+ATsrO6zUhdOl/E5ST+VOno0QQojiTILum6TCFqIYiz4HP7WB9PiHz8ujHDR/r3CD79gL8G09MGXC88uh7O2W3TRDGhN2TWBt2FoA+rvX5u1jG7HKSIaW70PTt0GtJtOYyanYUxy6cYjDkYex1ljTvWx3Gvg2uOckXRsvbeSd7e9gMBloXLIxX7f4Glvt7dnSwxLCGL9rPEeijgDQoEQDJjeajK+D74PfryHDPMN3DhRFISY9Bncb9/zP5q1PIml2My6kXKFa/dGoWn3w4GV8Akg9lTt5NkIIIYozCbpvkgpbiGJKUWBBTwjddP+0GmvzjN05bYZ087rUtwJ3j3Lmicyq9Lh38G0ymichS0+AkrXzFqgvHgQhKyGoNbyw3LI7IiWCkZtHcir2FFqVlg8afECvcr0gJcZcLveg++edB7uv7mb01tGkGdKo6VWTb1t/i73WngWnFjDz8Ez0Rj32Vva8Xedtegb3LPClrQpUWhxcOwJlWkBxLucjIPVU7uTZCCGEKM4k6L5JKmwhHlL0eXNg61OlYPM9sxZ+f84cUL+yA1wDck+rtbl3YJaeCPtmmyc4uxV8uwebW76r9ABUEBsK1w6bA71rh+H6Ubg5WRZlWpiX4LJzy/0al/fBz23Nk5a9uhO8KwNwJPIIo7eMJiY9BledK9NaTKOOT518PIj8ORJ5hOGbhpOUkUQFtwroNDqORh0FzJObTW40mRIOJQrt+qLgST2VO3k2QgghijMJum+SCluIh3B+I/wxwDyu+vW94FamYPI16OH7Bubu2o1HQ9vJ2ZJEpESw6vwqNl/eTPvS7Xmx8ov3b7lNT4R9P8Keb80tqQBOJc37M5Kyp7eyM9+bId08WVjfRZYfFxRF4UbqDcITw0nOSCZl4wRS4i+S7Feb1OA2JGcmk5SRxLqwdWSaMinnWo4ZrWZQ0qHkQz6c+zsTe4ZhG4YRmx4LgL2VPe/UeYcewT2Kd+u2yJHUU7mTZyOEEKI4e+yC7s8++4xx48YxatQopk+fDkB6ejpvvfUWf/zxB3q9nvbt2/P999/j7Z33NWilwhbiAZ1dZ14T2nhzluo6L0Hnrwsm753TYeNEcPCGNw6CzhGADGMGWy5vYcW5Fey+thuF2/89WZbMyktQeTP43nToB36zUWGvKJQyKvjb+eDvWo5SvnXwDWiGlVcliDyF6Y9+hCdf47SdA6cqd+KUysjp2NPE6ePydDutS7VmapOp2FnZPcjTeCCXEi/x3vb38LLzYly9cdK6/RiTeip38myEEEIUZ3mtp7SPsEy52r9/P7Nnz6ZatWpZ9o8ZM4Z//vmHJUuW4OzszIgRI+jRowe7du0qopIK8ZQ4/Y95/LIp0zze+epBOLwQmo8Fx7z/6JWjpBuw/Uvz+zaTQOfI2bizrDi3gr8v/E28Pt6StI53Hcq7lWfhqYXMD5lPcmYy4xuMR3Of8dcmnQPfO9ow29X2riOJkHgAEg+gOTOHEvYlcNG5cMHTllTXmxOORey0pNaoNPg7+uEUewmHjDTs3cth51sLB2sH7LR2OFg74O/oT+tSre85CVphCHAK4I/OfzzSawohhBBCiPwr8qA7OTmZAQMGMGfOHD7++GPL/oSEBH7++WcWLVpEq1atAJg7dy4VK1bkv//+o0GDBjnmp9fr0ev1ls+JiYmFewNCPGlCVsHSl8BkMM8E3mMOzO0IV/bD3lnmQPlhbJoMGclQsjax5doxZs2gLOtJe9l50TWoK93KdqOUUykAyruWZ9KeSSw7t4zUzFQ+afpJrks5pWSmMG7HOLZc3gJA3/J9KedWjsuJlwlPCic8KZzLiZdJN6ZzJfkKV5KvAKDT6CivtqNCTDgVMjKo6FWTst1+xubEcjg6ztwq/9Ji8xJdQgghhBBC5FGRB92vv/46zzzzDG3atMkSdB88eJDMzEzatGlj2VehQgVKlSrFnj17cg26P/30UyZPzj4+VAiRByeWwbKhoBiham/o9gNotNBkDPzRH/b/bH5v4/xg+V89CEcWAmDq8Bkf7B7PochDaNVaWvq3pHvZ7jTybZStJbt7cHfsrOwYu2Msa8LWkGpI5avmX2GjtcmS7nLiZUZuGcn5+PNYqa2Y0HAC3cp2y1YMRVGISosiPDGc2PRYyjiXobRzabRqLRxbAqtHQOhO848NqeZx07T8QAJuIYQQQgiRb0UadP/xxx8cOnSI/fv3ZzsWERGBtbU1Li4uWfZ7e3sTERGRa57jxo3jzTfftHxOTEzE39+/wMosxBPr6J+w8lXzxGLV+0PXb28vo1WuI3iUh+gzcOAXc+CdXyYTrHnP/L56PxYknmbn1Z3oNDoWdlpIebfy9zy9fen22GntGLN1DNuubOP1Ta8zo9UM7K3sAdh9bTfvbHuHxIxEPG09md5yOtU8q+WYl0qlwsvOCy87r+wHq/UGj2DzePbYC+Z9XpWg5vP5v2chhBBCCPHUe7SDEO9w+fJlRo0axcKFC7Gxsbn/CXmk0+lwcnLKsgkh7uPwQljxijngrvkCdP0u67rVajU0GW1+v+d7yEzP/zWOLzF3UbeyJ6R2f74+ZJ6U7Z0679w34L6lqV9TZrWZhb2VPfsi9jFs/TAS9An8evJXXtv4GokZiVT1qMofnf/INeDOE98aMGwrBDYHrS10/Dxv63gLIYQQQghxlyILug8ePEhkZCS1atVCq9Wi1WrZtm0bM2bMQKvV4u3tTUZGBvHx8VnOu3HjBj4+PkVTaCGeRAfnw6rhgGKeofzZGeYg+25VeoGTH6REwtHf83cNfbJ5tnIgpcko3j34BQaTgdalWtOnfJ98ZVXXpy4/tfsJZ50zx6KP8cyKZ/jywJeYFBNdgrowt8PcnFuw88veAwathvfCILDZw+cnhBBCCCGeSkUWdLdu3Zrjx49z5MgRy1anTh0GDBhgeW9lZcWmTZss55w5c4bw8HAaNmxYVMUW4slycgX8Ncr8vt4r8My0nANuAK01NBphfr/rGzAZ836dndMg6Tq4lmaqKo5LiZfwtvNmcqPJD7SudBWPKsxtPxd3G3cS9AmoVWrerfsuHzf+GJ1Gl+/87smq4HriCCGEEEKIp0+Rjel2dHSkSpUqWfbZ29vj7u5u2T9kyBDefPNN3NzccHJy4o033qBhw4a5TqImhMiH0C3mSdNQoPaL5i7U9wuAaw2EbZ9D3EXzLOdVetz/OrEXYfe3APxduzerQ/9ErVLzebPPcdY94IRsQLBrML91/I35IfNpF9COeiXqPXBeQgghhBBCFJYia+nOi6+//prOnTvTs2dPmjVrho+PD8uXLy/qYgnx+Lt6yDxRmCkTKnWFZ/53/4AbwNoe6r9qfr/za1CUe6dXFFj/IRj1XA5szMfhfwPwarVXqe1d+yFvAvyd/PmwwYcScAshhBBCiGJLpSj3+9b8eEtMTMTZ2ZmEhASZVE08nkI3w/avwCUAfKqAdxXwqQp2bg+WX/R5+KUdpMaYJwobsAS0+eiSnRoLX1eGzFSMA5YS5lkGnUaHn6Nf1nT6JHPX9RPLyFRpGFi9GScSQqnlVYuf2/9sXp5LCCH11D3IsxFCCFGc5bWekm+9QhRnyZGwdAikxcKlXXD0jmOOvreDcN+aENzu/uOPE6/Bb93MAXeJGtB3Yb4C7tj0WI7HHOdo+QYciz7BiV1vkaIy/24X4BRA05JNaVqyKbXRoVs2FGJDQa1lZq1nORFzECdrJz5v9rkE3EIIIYQQ4qkh33yFKK4UBf4eYw64vSpDpS4QcRxunIC4MEi6Zt7OrTent3M3j82uOwScfLPnlxoLv/WAhMvgXpa0vgvZFbGXjeEbuZx4GWuNNTqtDp1ah06rw0Zjg06jw0ZrQ1RaFMeijnE56fLt/GxtAAVbjY5Mk5FLiZe4lHiJBacWYGtSqK9No6mnH3b1XmFuyBwApjSago+9rD4ghBBCCCGeHhJ0C1FcHVsMp/8GtRX0+NHcqn1LeiJEhtwOws9thMQrsOMr81jrSl3MY6/965vHamekwqLnSI4+zXZ3XzaWr8POv3uQZkjLd7GCnIOo5lmNqlePU+3cDsqWaUdanx/5L3wrO/ZOY0f6daK0Wrba27EV4GbA/Vz552gd0LpAHo0QQgghhBCPCwm6hSiOEq/Bv++Y37d4L2vADWDjBKUamDcAowHO/AN7f4RLO81LgZ1cgVKiGtdr9GPf2RVszLzI7gA/MlUquL4bAF97X9oEtKGWVy0ylUz0Bj164+0t3ZCO3qjH3sqeap7VqOJRBSfrm+NVos5ASD048w8O5zbQZvMntIk5h6LScLbpCHa4+7Pj2k6ORB2hglsF3q7z9iN6eEIIIYQQQhQfMpGaEMWNosDCXnB+I/jWgiEbQHP/38fSDemExodyJmwTZ879y5nEi5y10pKkybpIQWmn0rQJaEObgDZUcqv0QOtkW/wxwNwaf4tTSeg1F0rVt+xKzUzFSmOFldrqwa8jxBNM6qncybMRQghRnMlEakLkx5k1YO8Ffg+/jNVDO/SrOeDW6KD7D7kG3JGpkeyL2Mf+iP0ciTxCWGIYJsV0O4GNNQBaRSE400DLMs/QptarlHUp+3CB9p0aj74ddJdtC91ng717liR2VnYFcy0hhBBCCCEeQxJ0CxFxHH7vCzYu8PY50Frn73xFMQfthnSw9wQHL/OrjQuo1fc9PYv4cFj3gfl96/HgWd5yKDotmgMRByyBdlhiWLbTXXQulHctTzm3cpR3LU95t/KUcQzA2mQEnUP+ypIX/nWh+49gMkD1fvm/XyGEEEIIIZ5wEnQLEbLK/JoeD5f3QmDT/J1/+m/48/ns+9VasPMwB+CO3lC+I1TvD9a5tPyaTLDqdchIAv8GRFfvw4GLazlw4wAHIg4QmhCaJbkKFRXdK1LPpx61vWtT0a0iXnZeBdeKnVfVn3u01xNCCCGEEOIxIkG3EKf+uv3+3Pr8B90hq82vLqXMXcJToswBvMkAyRHm7cZxc5fxLVOh7lCoNxTsPbJkE7FnOvsjD3DQ04uDzhC2tE22S5V3LU9dn7rmQNun9u1JzYQQ4hEyGo1MmjSJBQsWEBERga+vL4MHD+bDDz+0/PCnKAoTJ05kzpw5xMfH07hxY2bNmkVwcHARl14IIYR4tCToFk+3qLMQdfr25/Mbod1HeT/faIDzG8zvu8+GgEbm94YMSI2GlCjORx5j/Km5pKRGgTETzs+H0F/NM5DbuoHGilR9IjfSY8DrZiCecg0VKiq4VaC2d23qeNehtndtXGxcCuS2hRDiYXz++efMmjWL+fPnU7lyZQ4cOMCLL76Is7MzI0eOBOCLL75gxowZzJ8/n8DAQMaPH0/79u0JCQnBxsamiO9ACCGEeHQk6BZPt9M3W7lL1oZrh81rXydcAWe/vJ1/ZT+kxZnHb/vVu71faw1OvhgcvPjg4FRC9FGgATR3zOBtTIXkVMtHjaJQSaWjdqV+1PGpS03vmtKSLYQolnbv3k3Xrl155plnAChdujS///47+/btA8yt3NOnT+fDDz+ka9euAPz66694e3uzcuVK+vbtW2RlF0IIIR41CbrF0+3UzZm3a74AKrU5iD6/EWoPztv5Z9eaX4Pb5TjL+KJTiwiJCcHR2pGvmn2FtcYaUCDiBJxYBlfMX1C1ikIwOuxf223upi6EEMVYo0aN+PHHHzl79izlypXj6NGj7Ny5k2nTpgFw8eJFIiIiaNPm9jAZZ2dn6tevz549e3INuvV6PXq93vI5MTGxcG9ECCGEeAQk6BZPr/jLcO0QoIIKz0BypDnoPrchH0H3OvNrufbZDl1Lvsa3R74F4K3ab9GoZKPbB33qQo0XIfI07PnWHOi3/0QCbiGKOWNiIhlhYWSEhaHS2eDUvl1RF6lIjB07lsTERCpUqIBGo8FoNPLJJ58wYMAAACIiIgDw9vbOcp63t7flWE4+/fRTJk+eXHgFF0IIIYqABN3i6XX6H/NrqYbmZb6C28DWqXBhm3lM9v2WDosLg6hToNJA2dZZDimKwid7PyHNkEYtr1p0D+6ecx5eFaDrtw9/L0KIh6YYjZiSkzEmJWFMSCDz6lUywi5ZguyMsDCMsbGW9LbVqz+1QffixYtZuHAhixYtonLlyhw5coTRo0fj6+vLoEGDHjjfcePG8eabb1o+JyYm4u/vXxBFFkIIIYqMBN3i6XVr1vKKnc2vJWqal/hKjc7b0mG3WrlLNQRb1yyH1l1ax/Yr27FSWzGx4UTUKlm/WojiQMnIIHnXLpLWbyAjPBxTUhLGpCRMiYmYUlLylIfWywvr0qWxqVKlkEtbfL3zzjuMHTvW0k28atWqXLp0iU8//ZRBgwbh4+MDwI0bNyhRooTlvBs3blCjRo1c89XpdOh0ukItuxBCCPGoSdAtnk4p0RC+2/y+ws2gW62Gsm3g2B95Wzrs1njuu7qWJ+gT+GzvZwAMrTqUMi5lCrLkQoh8UgwGUv7bS+Kaf0nasBHTfcYJq2xt0Tg4oPXxwbp0aaxLB6ALDMS6dGmsSgWgcbB/RCUvvlJTU1Grs/6YqNFoMJlMAAQGBuLj48OmTZssQXZiYiJ79+7ltddee9TFFUIIIYqUBN3i6XTmX1BMUKI6uAbc3h/c1hx032/pMH0ShO00vy/fMcuh6YemE5MeQ6BzIEOqDimEwgsh7kcxGkk9cNAcaK/fkKVbuMbTA6f2HbCrUxuNkxNqRyc0jg6onZzQODigsr7P0BLBs88+yyeffEKpUqWoXLkyhw8fZtq0abz00ksAqFQqRo8ezccff0xwcLBlyTBfX1+6detWtIUXQgghHjEJusXjIT0B0uKzBsgPw9K1/Nms+4NamWcxv9/SYRe2gjED3MqAe1nL7oM3DrL07FIAJjSYcHO2ciFEYTPGx5N2/DhpR46SdvQoaceOZWnR1ri64tiuHU6dOmFXpzYqjaYIS/v4mzlzJuPHj2f48OFERkbi6+vLK6+8woQJEyxp3n33XVJSUhg2bBjx8fE0adKEtWvXyhrdQgghnjoSdIvHw4Je5uW1KnWFtlPAtfSD55WeaA6aASrcFXTbuZnX7L7f0mFnbnUt7wAqFQAZxgwm7zHPutszuCd1fOo8eBmFeEwpRiNpR46QtGEjmVev4NKnDw5N7zNUI59MKSnoQ0NJDwmxBNkZFy9mS6d2csKxbRucOnbCvkF9VFqp8gqKo6Mj06dPZ/r06bmmUalUTJkyhSlTpjy6ggkhhBDFkHwDEcVf5GnLetaErIIza6DBcGj6Ftg45T+/c+vNrdTuweBZPvvxsm3vvXSYyQTnsi8V9vOJn7mYcBF3G3fG1B6T/3IJ8Zgy6fWk7NlD8qZNJG3egjEmxnIsacNGnJ55Bu9xY9F6eOQrX2NyChmh59GfD0V//jz60PPoz5/HcO16jumtAwKwrVEdm+rVsa1eHZty5VBZWT3UvQkhhBBCPCwJukXxF7LK/OpXF6zs4OI22DUdjiyEVuOh5vOgzkdX0Tu7lt9spc4iuO29lw67dhhSokDnBKXMa29fSLjAnGNzABhbbyzOOud83qQQjxclI4PEDRtI2rCRlO3bMaWmWo6pnZxwbNkClZ0d8X8uJvGff0jeuRPvd97GuWdPVDn9u7vJlJZG4r9riF+8mLSjR3NNp/HwwKZcOWxr3Aywq1VD6+qaa3ohhBBCiKIiQbco/k6tNr/WeQmq9zPPGr7uA4gNhb9Gwr450GEqBDa7f16ZaeYWbMg+nvuWEjXA3tMcWF/+z5Kv0WQkzZBG6qkVpGm1pAU2IC32JGmZafxw7AcyTZk0LdmU9qXb55yvEE+IzGvXuDJmDOlHj1n2ab28cGzTGsc2bbCrW9fSwuzSsxfXJ4xHH3KK6x+OJ2HlKnymTEZXJuus/ulnzxL/52ISVq/GlJRk2a/x9EBXtiy6oLLm17JBWAcFSYAthBBCiMeGBN2ieIs+DzdOgFprniVcpTK/BrWG/T/Bts/gxnGY/yxU6gbdZoG1Xe75hW6BzBRw8gPfmjmnUavN+R/7A85t4ISjG+9uf5fLSZdvp/H3Bf1pWDPQsstWa8uHDT68ZyueEI+75J27uPb22xjj41E7OeH63HM4tm2DTZUqqNTZ16O3rVKZwMWLif31N6JmziT1wAEudu2G+7BhuA0aSNLmzcT/uZi0w4ct51j5+eHSpw/OXbti5e31KG9PCCGEEKLAZf+G9AjNmjWLatWq4eTkhJOTEw0bNmTNmjWW4y1atEClUmXZXn311SIssXjkTt3sWh7YHGzvaNnSWkPD4TDyCNQbBioNhKyEP/qZW7Nzc/pv82vFzjl3Lb8luC0A+y+sZci6IVkCbpWiYG8y4WHjhr+jP+Vcy1HTqyZTGk/B18H3we5TiEJgTEzEEBeHkpn50HkpJhNR337H5aFDMcbHY1OpEoHLl+H11pvYVquWY8B9i0qrxf2lFynz11/YN2+GkplJ9HffcbZBQ66PHWcOuDUaHNu2xf+nnwhavw6PYUMl4BZCCCHEE6FIW7r9/Pz47LPPCA4ORlEU5s+fT9euXTl8+DCVK1cGYOjQoVlmPrWzu0crpnjyhNzsWl6pS87H7dyg05dQuQcs6GmelfyPAdB3EVjdtSyNMdO8Pjfk3rX8lqBWbLOz401dGhkGFfV86vFp009xOrES3b/voPKrB89teKhbE6IgKSYTGaGhpB4+TNrhI6QdPkxGWJjluMraGrWDA2p7e/PmYI/GwRGbalVxbNMGXXBwrr00DHFxXHvnXVJ2mtemd+nTB+8P3ket0+WrjNZ+JfH/4QeS1q4l4pOpGKOjsfL1xaVPb5x79MDKS4JsIYQQQjx5ijTofvbZrIHPJ598wqxZs/jvv/8sQbednR0+Pj5FUTxR1OLC4PoR87rZFTrfO21AQxiwBBb2gtBNsPgFeG4BaO8ICi7tgrQ4sPOAUg3vmd0/EXv40MsDgwpaOAbxVZvv0Wl0cH6TOUH5Dg91a0I8KFNGBsbYWAzRMRiio9CfOmUOtI8czbIu9d2Um+cZY2Oz7E/eupXoGTOxCiiFY+s2OLZpg22N6paW67Rjx7gyajSG69dR2djgM2kiLt26PXD5VSoVTh07Yt+0KRmhoeZu6bJmthBCCCGeYMVmTLfRaGTJkiWkpKTQsOHtgGjhwoUsWLAAHx8fnn32WcaPH3/P1m69Xo9er7d8TrzHl1BRzN1q5S7dBOzzsNRQ6cbQfzEs7G1eFmzxIOjz6+3Zx2/NWl6+4z1nO//z9J98svcTFBV0Tk5hirUdVhodZKTeXt+7nATdonApGRnE/vYbaUePYYiJwRgTgyEmJsskY3dT2dpiW60atjVrYFerFrbVq6O2t8eUkoIpJQVjcrL5fbL5syEmmpTtO0jZs4fMS+HE/vILsb/8gsbDA8dWrdB6eRE9ezZkZmIdEEDJGd9gUz6HZfYegMbBAdvq1QskLyGEEEKI4qzIg+7jx4/TsGFD0tPTcXBwYMWKFVSqVAmA/v37ExAQgK+vL8eOHeO9997jzJkzLF++PNf8Pv30UyZPnvyoii8K061Zyyvm0rX8DumGdFIyU3APbAr9/4BFz8HZNbBkMPSZbx7zferWeO7c8/vp+E98c+gbAPr6tWbcjrmoE24uHRa2Awzp4OwPXpUe9u6EyFXGpUtcfett0k+cyDmBVovWzQ2Nuzu6wNLY1qyFba2a2JQvj0qb/b91jbMzGmdnclqx2m3AAIzJKaTs3EHSxk0kb92KMTqa+MWLLWkc27alxNRP0Dg6FtAdCiGEEEI8PVSKoihFWYCMjAzCw8NJSEhg6dKl/PTTT2zbts0SeN9p8+bNtG7dmvPnzxMUFJRjfjm1dPv7+5OQkICTk1Oh3YcoYAlX4etKgAreOg2OOQ8xSDeks+j0In46/hNJGUl42XlRxb0KVdW2VNm3gMppyThW6AwNhsPcjmDtCO+GZu12DiiKwvRD0/nlxC8ADKs2jBHVhqOaVt68dNigv+DkCjjwC9R9GZ75X2E/AfGUSli9mohJkzGlpqJ2dsZj6MtYlSyJxt0d7c1N7eR0z4nLHoaSkUHKvv0kbdxA2sFDOPfsgdugQTIrfyFKTEzE2dlZ6qkcyLMRQghRnOW1nirylm5ra2vKli0LQO3atdm/fz/ffPMNs2fPzpa2fv36APcMunU6Hbp8Tu4jiqFbXcFLNcwx4DaajPx14S++O/IdESkRlv2RqZFsTt3MZgBvV8CV0okHqPrvi/i4OqN4VsB09HsURcGkmDBhQlEULiddZtuVbQC8XedtBlUeZM7QsnTYeji7zrxPupaLQmBMTuHGR1NIWGXu4WFXpw6+X36BVYkSj7QcKmtrHJo0xqFJ40d6XSGEEEKIJ1WRB913M5lMWVqq73TkyBEASjziL6GiCITcXCrsrlnLFUVhx9UdTD80nXNx5wDwsfdhRI0RtC7VmjNxZzgRfYIT0Sc4Hn2cq8lXCbO2IswasLOGzOtwszX7bipUTGw4kZ7let7eGdzWHHQf+hXSE8DKDko3LYw7Fk+xtOPHufrW22SGh4NajceI1/F45RWZYEwIIYQQ4glQpEH3uHHj6NixI6VKlSIpKYlFixaxdetW1q1bR2hoKIsWLaJTp064u7tz7NgxxowZQ7NmzahWrVpRFlsUtqQbEL7H/P6Opb1ORJ9g2sFp7I/YD4CjtSNDqw6lf8X+5pnFgdretantXdtyTmx6LCePzOPE3hnEW1mjrvkCKq0ONWrUarX5VaVGpVLRyLdRlnMBCGplnj09PcH8uUzL7EuRCfGAFJOJ2Llzifx6OhgMaH1LUPLLL7GrXfu+5wohhBBCiMdDkQbdkZGRDBw4kOvXr+Ps7Ey1atVYt24dbdu25fLly2zcuJHp06eTkpKCv78/PXv25MMPPyzKIotH4fRfgAIl64CzHwn6BD7f9zl/XTB3ObdWWzOg4gCGVB2Cs875nlm52bjRtMGbNA3qbJ6x3D3nYQm5snMzl+PKPvPncu0f4IbEk8IQG0vGhQvoL1wg48JF9BdCMURGgdGIopjApIDJhGIywc1NIfdpM5SMTIzR0QA4tm9PiSmT0Tjf+++0EEIIIYR4vBRp0P3zzz/neszf359t27Y9wtKIYsPStbwrO6/uZOKuiUSmRaJCxbNBzzKixghKOORziIFnuQcvT3Db20F3cLsHz0c8NkwZGejPnCHt2DH0p0+jD71AxoULGOPjC/xaKhsbvD94H5devWSyMiGEEEKIJ1CxG9MtnnIp0RC2kxSViq8yw1m6cQ4ApZ1K80mTT6jmWQRDCyp1he1fQUAjcJL5BJ40islERlgYaceOkX7sOGknTqA/dQolMzPH9Fa+vlgHBaErE4h1YBmsSvqal+lSqUGtMo/DVqlRqVWgVsN9AmkrPz+0rq6FcWtCCCGEEKIYkKBbFAyTESKOgXcV0OS0GnAenf6HAzorPvQuwdVL5tnCn6/4PCNrjcRWa1tAhc0nz/Iw6gjoZLmax5kpNZWMS5fICAuzbPqwMDJCL2BKTs6WXuPigk3VqthUqYwuqCy6oDJYly6N2raI/h4KIYQQQojHkgTdomCsHQf7ZoOTHzR8HWoNBJ1DvrLQG/XMOPETv/l4oahM+Nr78lHjj6hXol4hFTofnHyLugQijwxxcejPnSMjNBT9ufPm8dcXL2K4cSPXc1Q2NthUroxtlSrYVKuKbbVqWPn5SXdvIYQQQgjx0CToFg8v9gIcuDk+P/EKrBsH2z6HekOh3ivg4HnfLI5FHWP8zve5QDyoVPTwb8M7TT7CwTp/gbt4ehhiY9GfP4/+/Hkyzp9Hfz4U/fnzGGNjcz1H4+KCdenSWAcGml9vbrqgMuYu4kIIIYQQQhQw+ZYpHt7Wz8BkMC+nVakr7J5hDsS3fwm7Z0LN56HhCHALzHZqdFo03xz6hpXnVwLgYTAy2eBAs1ZfP+KbEEXFlJKCMSUl9wRGIxnhl9Gfv6P1OjT0nsG1VcmS6MqWRRdcFusy5vHXVgEBMnZaCCGEEEI8chJ0i4cTeQqOLTa/bzMRfGuau5af/ht2Todrh2D/T3DgF6jYBar3hTItyVRrWHR6ET8c/YHkTPN42i4qZ965ehKXZmOL7n7EI5N+9iyxc+eR8PffkMukZfdj5eeHLijIHFyXLWsZe622syvg0gohhBBCCPFgJOgWD2fLJ4ACFZ81B9xgXg+7UldzkB22A3Z9A+c3QshKCFnJbkcXPvP04qKSDkBl98qMqzGS6nO7mtc2rtSlyG5HFC5FUUjdu5eYX34hZfuO2wc0mtxPUqmwKlHC3HJdNghd2bJYB5VFVyZQgmshhBBCCFHsSdAtHty1w3DqL0AFLT/IflylgsBm5i3iOJf3z+bL61vYolODko6b0cjohBS6WqtRH1kKxgzwKAeeFR75rYjCpRgMJK5dR+wvv5AeEmLeqVbj2LYt7i+9iG316kVbQCGEEEIIIQqJBN3iwW3+2PxarQ94VcwxiaIoHI06ysoLK/krfg8ZOjValYZ+dqV59doFnBLiIeGf2ydU6nrfdY1F8acoCobISPRnz5J+8iRxixdjuHYdMM8U7tKjB26DB2FdqlQRl1QIIYQQQojCJUG3yJPUzFT+ufgPXrZeVPaojEfkOXOXcbUWWmQfgx2REsHfF/5m1flVhCWGWfY3KNGAsfXGEuQSBIoCEcfh1GoIWQ36RPOka6LYU0wmFL0eU3o6il5P5tWr6M+dMwfZZ8+iP3ceU0JClnM0bm64Pj8A1379ZEIzIYQQQgjx1JCgW+TJjMMzWHhqoeWzl6KhkpcHlTwqUzn1CpVsnXCwcmBz+GZWha5iz7U9KCgA2GptaRvQlm5lu1HHu87ttY9VKihRzby1+rAobkvcR0Z4OFHTvyHt+HGU9HRMej1KejpKRsb9T9ZozMtxBQdj36ghzl26oLaxKfxCCyGEEEIIUYxI0C3uK0GfwPJzywHwd/TnStIVIlVGIu3t2Jp2ETa9DoBWrcVgMljOq+Ndh65lu9I2oC32VvZFUnbxYIzJKcTMnk3svHko95tZXKtF6+GBrlwwuuBgbMqVQ1euHNZlyqDW6R5NgYUQQgghhCimJOgW97Xs3DLSDGmUcy3H0s5LSPupJadjThFSviUnPcsQEhPCxYSLGEwGfO196VK2C13KdMHfyb+oi/7UUzIySD91CkNcHHY1aqBxcbl3epOJhJWriPx6GsaoaADsGzfG/eUhaJydUdnYoNbpUNnYoNLZoLbRodLKfyNCCCGEEELkRr4ti3vKNGVaupW/UOkFVGf+xe7aEWpZ2VOr3bfg4AlASmYKkamRBDgFoFapi7LITzVDbCxpR46QdvgwqYcPk378BIpebz6oUmFTsSJ2DRtg37ARdrVroba1tZybevgwNz6ZSvqJEwBYBZTCe+xYHFq0uD0kQAghhBBCCJEvEnSLe1oftp7I1EjcbdzpFNAe5rQyH2jwqiXgBrC3sifQObCISvl0UDIyMMTFY4yPwxhn3gyxsRjj4sm8coW0I0fICAvLdp7G2RmNqysZYWGkh4SQHhJC7M+/oLKywrZGDewaNiDjYhiJf/0FgNreHo/hw3F94XnU1taP+C6FEEIIIYR4skjQLXKlKAq/hfwGQL8K/bA+9TdEhoDOGRq9UcSle/IoJhOGiAgywi+TEX6JzPBwMi6Fk3H5MplXrmBKTs5TPtZBQdjWrIFdzVrY1qyJdWBpVCoVmTciSd37Hyl7/iPlv/8wXL9O6v79pO7fbz5RpcK5Zw+8Ro9G6+FRiHcqhBBCCCHE0yNfQbfJZGLbtm3s2LGDS5cukZqaiqenJzVr1qRNmzb4+8sY3ifJochDnIw5iU6jo0/Z7vBze/OBxm+ArSz59LBMKSmk7N1Hys4dpO7fT8al8PvPCq5Wo3F1RePqgtbF9eZ7V7SenthWq4pt9eq5jtu28vbCuUsXnLt0QVEUMi9dImXPHlL2/AcqFe5Dh2JbpXLB36gQotBJ/SyEEEIUX3kKutPS0vjf//7HrFmziI2NpUaNGvj6+mJra8v58+dZuXIlQ4cOpV27dkyYMIEGDRoUdrnFI/DryV8B6BLUBdez6yH2Ath5QP3XirhkjydFUdCfOUPKzp0k79hJ6qFDcPfM4Fot1n5+WJXyx7pUANalSmEdUAorf3+07u6oHR1RqR9+zLxKpcK6dGmsS5fGtV+/h85PCFE0pH4WQgghir88Bd3lypWjYcOGzJkzh7Zt22JlZZUtzaVLl1i0aBF9+/blgw8+YOjQoQVeWPHohCeGs+XyFgCer/Q8LL7559loBOgcirBkj17aiZPcmDoVY2ICWjd3tB7uaNzc0bq7oXF3R+vujsbVDYwGjMnJmFJSMSUnY0pJwZRifjXExJK6dy+GqKgseVv5++PQtAn2jRujK18eKx8fmQ1cCJFnUj8LIYQQxZ9KURTlfolOnTpFxYoV85RhZmYm4eHhBAUFPXThCkJiYiLOzs4kJCTg5ORU1MV5bEzdO5XfT/9O05JN+b7aSPi+Pqg08NZpcPAq6uI9EoqiEP/HH9yY+un916rOI5WtLfb16mHftCkOTZtgHRBQIPkKIR5fD1NPPc71c15IHS6EEKI4y2s9lacmtbxW6ABWVlaPVYUuskvQJ7Dy/EoABlYeCEcWmA+U6/DUBNzG5BQiJk4k8Z9/AHBo3Rq3Af0xxMZhjI3BEB2DITYGY0wshpgYjLGxqLRa1A4OqO3tb77aobF8djSPua5dW2YEF0IUGKmfhRBCiOLvgfuxGgwGZs+ezdatWzEajTRu3JjXX38dGxubgiyfKAJLzy4lzZBGOddy1PesBUefNx+oOaBoC/aIpJ89y9VRo8m4eBE0Grzeegu3FwfLWtVCiMeC1M9CCCFE8fLAQffIkSM5e/YsPXr0IDMzk19//ZUDBw7w+++/F2T5xCOWacpk0elFAAysNBDV+Y2QEgX2nhDcrohLV/jiV64kYtJklPR0tN7elPx6Gna1ahV1sYQQIs+kfhZCCCGKlzwH3StWrKB79+6Wz+vXr+fMmTNoNBoA2rdvL7OiPgHWh60nMjUSD1sPOgZ2hMWDzQeqPQea7BP0PClM6elEfPwxCUuXAWDfqBG+X32J1s2tiEsmhBD3JvWzEEIIUbzlee2hX375hW7dunHt2jUAatWqxauvvsratWv566+/ePfdd6lbt26+Lj5r1iyqVauGk5MTTk5ONGzYkDVr1liOp6en8/rrr+Pu7o6DgwM9e/bkxo0b+bqGyDtFUZh/cj4A/Sr0wzotHs6tMx+s+XzRFawQKSYTievXE9a7tzngVqnweGME/nN+lIBbCPFYKIz6WQghhBAFJ88t3X/99Rd//vknLVq04I033uDHH3/ko48+4oMPPrCMGZs0aVK+Lu7n58dnn31GcHCwOeCbP5+uXbty+PBhKleuzJgxY/jnn39YsmQJzs7OjBgxgh49erBr16783ucTLz49njc2v0FyZjIl7Evg6+Br3ux9KeFQAl9Fg/v++agrPgNlWuSYx8EbBzkVewqdRkfvcr3h0AIwGaBkbfDK+2Q9hcEQF4cxOhpdcHCB5KcYDCT++y/RP/5IxvlQADRubvh++QUOjRsXyDWEEI8PRVFIT8kkJV5Pcpye1IQM9KkGMjOMGPRGMvXG2+8zzJ9dve1o+ULR/t8IhVM/CyGEEKLg5GnJsDvFx8fz7rvvcvToUX744Qdq1qxZoAVyc3Pjyy+/pFevXnh6erJo0SJ69eoFwOnTp6lYsSJ79uzJc1e5p2W5ka/2f8X8kPn3TGNtUihlNBIY0JxAj8oEOgeaN6dA7KzsGLl5JFsub6F3ud5MaDAevm8AUaeh89dQ56VHdCfZpR0/weVXX8UYE4N9s6Z4vfkmNhUqPFBepowMElauJGbOT2RevgyA2tER1wH9cRs0CK2ra0EWXQhRzCiKQlR4EmHHY4iLSCElXn9zy8BoMOUrL89SjvR5/+FbkAuqnirs+rkoPC11uBBCiMdTgS4ZdicXFxd+/PFHtm/fzsCBA+nQoQMfffTRQ8+KajQaWbJkCSkpKTRs2JCDBw+SmZlJmzZtLGkqVKhAqVKl7hl06/V69Hq95XNiYuJDletxEJUaxR9n/gDg7TpvY29lz7Xka1xLucb1qBCuxp0nSqMmQ63ivFrL+Wu74FrW3gI+9j7cSDF33X++0vNw9ZA54NbaQJWej/yebkneto0ro8egpKUBkLJ9Bxd37MSpc2c8R76Btb9/nvIxpaURv2QJMT//guHmEAWNqytugwbhOqA/GkfHQrsHIUTBMhpNJMemY8xUcPSwwcpac+/0mSaunI0j7Gg0F49FkxKvzzWtjYMV9i467J112DhosbLWoNVpsLLWYKUzb9qb7+2citc8F4VVPwshhBDi4eQ56A4PD+ftt9/m1KlTVKtWja+++oqDBw/yySefUL16daZPn07Hjh3zXYDjx4/TsGFD0tPTcXBwYMWKFVSqVIkjR45gbW2Ni4tLlvTe3t5ERETkmt+nn37K5MmT812Ox9lPx39Cb9RT3bO6ecbxW0tb7f8Jjs8GxURm6SZE1B9G2OrhXNSquFi+DRfUCmGJYcSmxxKRYn6mLfxaUMa5DOwYY86jYhewcS6S+4pbvJiIyVPAaMS+cWO83nqTmJ9+JvHff0n86y8S167FtU8fPF57Fa2HR5ZzlcxM0k+eJGXvPlL37iX18GFL4K718sJ9yEu49O6N2s6uKG5NCHEPiqKQmphBUkw6iTFpJEbdfI1OIzE6neTYdO7so2XnZI2Thw1OHrY3Nxuc3G1Jjkvn4rFowk/Gkqk3WtJrdRpKVXKjRJCzOcB20eFwM9DWWOV5qpNio7Dq5/u5evUq7733HmvWrCE1NZWyZcsyd+5c6tSpA5j/HCdOnMicOXOIj4+ncePGzJo1i+ACGiYkhBBCPC7y3L28RYsW+Pj4MHjwYNatW0doaCirV68G4NSpU7zyyiv4+PiwePHifBUgIyOD8PBwEhISWLp0KT/99BPbtm3jyJEjvPjii1larQHq1atHy5Yt+fzzz3PML6eWbn9//ye2a1pESgSdlnci05TJnHZzaFCiAZiMsGEC7PnWnKjGAOg8HbTWsGUqbPvcvATY6/vAzo349HguJl7kRsoNGvo2xFltDV+VB30CDFwNZZo/0ntSFIXomTOJ/n4WAM7du1NiymRUVuZWpfSQECKnfU3Kzp0AqOzscB88CPumTUk7eJCUvftIO3gQU2pqlnyt/PxwHzoU5+7dUFtbP9J7EuJpYTIppMTrSYpJJzUxA5Ua1Bo1arUKtUaFWq1CpTG/NxkUkmLTzVtM1ldj5r27emus1Gg0KjLSjfdMd4udszWB1TwoXc0DvwquaK3u3Tr+KD1sF+rCqp/vJS4ujpo1a9KyZUtee+01PD09OXfuHEFBQQQFBQHw+eef8+mnnzJ//nwCAwMZP348x48fJyQkJM+t79K9XAghRHGW13oqz0G3g4MDR48eJSgoCEVRCAwMJCwsLEuaH3/8kWHDhj1Uwdu0aUNQUBDPPfccrVu3Ji4uLktrd0BAAKNHj2bMmDF5yu9Jr7An75nM0rNLqeNdh1/a/4IqMxWWDYUz/5gTtBoPTd+CW63fBj380ASiz5pnJO/6XfZMjy2B5S+DSykYeRTUj67lR8nM5Pr4CSSsXAmAx/DheLwx4nbr/R1S/ttL5LRppB87lmNeGmdn7OrVxa5efezq10MXHJxjPkKI20wmhRsXE7l0Iprr5xNQqVVY22iwttFileVVg0arJjleT/LNQDkxJp2UOD0mU76mCsmZChxcdLdbrm+1Yrvb4ORpi52jNSq1ivSUTEsLeGJ0GokxN1+j07DSaShd1Rxoe5VyRKUunv/+H7aeelT1853Gjh3Lrl272LFjR47HFUXB19eXt956i7fffhuAhIQEvL29mTdvHn379s3TdZ70OlwIIcTjrcDHdNeuXZsJEyYwaNAgNm7cSNWqVbOlKYgK3WQyodfrqV27NlZWVmzatImePc1jis+cOUN4eDgNGzZ86Os8CS4nXWbluZUAjKg5AlXyDVj0HFw/AhoddJ+VfTy2VgfPzoC5HeDwAqjaJ3tL9uHfzK81BjzSgNuYnMzVkaNI2b0bNBp8Jk3EtXfvXNPbN6hP6T//IGnDBqK//Y7MGzewq1ULu/r1sK9fH1358qgeYfmFeFylJWUQfjKGSydiCD8Viz7F8FD5qTUqHFzN3bYBTEbl9mZSMBlNKCYFVCoc3XQ4utmYN3dbHN3N7x1cdWi09//3a2NvhY29FV4BT29A9qjq5zutXr2a9u3b07t3b7Zt20bJkiUZPnw4Q4cOBeDixYtERERkmZfF2dmZ+vXrs2fPnlyD7qdxXhYhhBBPvjwH3b/++itvvfUWY8aMoUaNGsyePfuhLz5u3Dg6duxIqVKlSEpKYtGiRWzdupV169bh7OzMkCFDePPNN3Fzc8PJyYk33niDhg0b5nnm8ifd7KOzMSgGGpZoSG2nIPihKSSEg5079P0dStXP+cSAhlBnCBz4Gf4aBcP3gJWt+VjcJbi4HVBBjf6P7F4yb9zg8quvoT91CpWtLX7Tv8ah+f27tatUKpzatcOpXbtHUEohipeUBD1qjQobe6s89+JQFIWkmHSiryQTFZ5EeEgskZcS4Y7GaZ2dllKV3PCr6IbWWk1GmpHMdCMZegOZaTdf040YMk3YOVvj6GaDk/vtwNnO2Rp1MW1VfhIVRv18PxcuXGDWrFm8+eabvP/+++zfv5+RI0dibW3NoEGDLHOveHt7ZzlP5mURQgjxNMpz0B0QEMDSpUsL9OKRkZEMHDiQ69ev4+zsTLVq1Vi3bh1t27YF4Ouvv0atVtOzZ0/0ej3t27fn+++/L9AyPK7CEsL468JfgLmVm1N/mQNuZ38YtBrcytw7gzYT4cy/EHfRPMa7zSTz/qO/AwoENjd3Ly9kxqQkYn75hdj5v6KkpqJxd8f/hx+wrVql0K8txONEn5pJ5KUkboQlEnlzS0nIAMDaVouzpy3OXrY4e9x89bTDycOG1MQMoi8nE30lmegrScRcTSEjLXtLtoe/AwGV3Qmo4o53oBNqjfQSeVwURv18PyaTiTp16jB16lQAatasyYkTJ/jhhx8YNGjQA+c7btw43nzzTcvnW/OyCCGEEI+zPAXdKSkp2Nvb5znTvKb/+eef73ncxsaG7777ju++y2Hc8VPu+6PfY1JMNPdrTjXParD5C/OBms/fP+AG84zkz/wP/ugPu2ZA5R7gXQWOLLyZzwuFV3jMS3jFLVxI9JyfMCUkmItUtSolp/0vz8uACfEkM5kUzu2/QXhIDJFhScTfSM2WRqUCRYGMNANR4UlEhSflKW+1RoVrCXs8/BzwDXYhoLK7pSu4eLwUVv18PyVKlKBSpUpZ9lWsWJFly5YB4OPjA8CNGzcoUaKEJc2NGzeoUaNGrvnqdDp0Ovm7KIQQ4smSp6C7bNmyjBo1ikGDBmWpPO+kKAobN25k2rRpNGvWjHHjxhVoQcVt5+LOsfbiWgBer/G6eXK00C3mg8H56GZd4RnzkmCnVsNfI6H1BIgPB50zVOxcCCUHJSOD+GXLiP5+FoaoKACsg4LwHDUSx7ZtZaIzIYCICwls/+NstiDaycMG79JOeN3cPP0dUakgMTqdhKhUEqLSSIhMs7xPiknHxsEK95IOePiZN3c/R1x97PI0XloUf0VVPzdu3JgzZ85k2Xf27FkCAgIACAwMxMfHh02bNlmC7MTERPbu3ctrr7320NcXQgghHid5Crq3bt3K+++/z6RJk6hevTp16tTB19cXGxsb4uLiCAkJYc+ePWi1WsaNG8crr7xS2OV+qs06OgsFhTal2lDRvaI54M5IBgdvKFEjf5l1+hIubINrh2H5zYl2qva8Pca7ACiKgikhgeTt24ma+S2Zly8DYOXri8cbb+Dc5VlUmuKzfI8QRSU1MYM9K0M5vfs6ANY2Gqq28KNEWRe8Sjti65DzUnduvva4+WZvvTSZFFQq5MesJ1hR1c9jxoyhUaNGTJ06lT59+rBv3z5+/PFHfvzxR8D8d2706NF8/PHHBAcHW5YM8/X1pVu3bgVSBiGEEOJxkaegu3z58ixbtozw8HCWLFnCjh072L17N2lpaXh4eFCzZk3mzJlDx44d0UjwVKhOx55mw6UNqFAxvMZw885z682vwW3zP9u4ow+0+8jc0p1ibnmmxvP5LpcxOZmkdevJjLiOISoKQ1Q0hugoDFFRGKOiUTIzLWk1Hh54vPoqLn16y3rZQgAmo4kT26+yd/VFy3jrCg19aNi9LHZOD/5vRCYze/IVVf1ct25dVqxYwbhx45gyZQqBgYFMnz6dAQMGWNK8++67pKSkMGzYMOLj42nSpAlr167N8xrdQgghxJMiz+t0P64elzU+FUXhk72fcDX5Kk1KNqGZXzP8HbOPbX5j0xtsvbKVjoEd+aLZzXHcM2pBbCj0+Q0qdXmQi8O8znBpJ3hWNM9mno+WMX1oKJeHDyfzUvg902k9PXF94QXcnh+A2s4u/+UU4gl07Vwc2/84S8zVFAA8SznSrG85fMo4F3HJxKPyuNRTRUGejRBCiOKswNfpFoVrz/U9/HnmTwB2Xt3JZ/s+o4xzGZr7NaeZXzNqeNUgJCaErVe2olapea36zTFx0efNAbfaCoJaPtjFVSrzmt7rx0Odl/IVcCdt3sK1d97BlJKCtkQJHJo0QevpidbTw/zqYX7VeHpKq7Z4ahiNJm5cSCD8ZCwJUWk316g23Vyj+vZmyDQSfTkZAJ29lgZdg6jUxFdaqIUQQgghniASdBcTv4b8CkBdn7oAHLpxiAsJF7iQcIG5J+fiaO2Ig5UDAJ3LdCbQOdB84rl15tfSjUHn+OAFcCkFfebnObmiKMTM/pGob74BRcGubl1KfjMdrZvbg5dBiMdYYkwa4SdjuRwSy+XTsWSmG/N2ogoqN/GlQdcgbBysCreQQgghhBDikZOguxgIjQ9l19VdqFAxueFk/J38ScxIZPfV3Wy7so0dV3eQoE8gKSMJrUrLq9VfvX3y2ZtBd3D7R1ZeU2oq197/gKS15hnUXfv3w3vcOFRWEjCIJ4uiKBgyTWSkGchMN5KRfvNVbzTv0xuJi0jhckgscRFZl/SysbfCv5Ib3qWd0FipUWtU5k2tQq1R33xV4eJth4u3DLcQQgghhHhSSdBdDPwW8hsALf1b4u9kHsftZO1Eh8AOdAjsgNFk5Fj0MXZf200Ftwq3x3qnJ8Kl3eb35R5N0J1x5SpXRoxAf/o0WFnh8+GHuD7X55FcWzx9Ii8lcnhDOBqtGndfB9xL2uNe0gE7Z+sCmZE7I91AxIUEUuL1pCRkkJqYQWqCntTEDPPnBD2GDFOe8lKpwKeMM6Uqu+FfyR3PUo7STVwIIYQQQkjQXdRi02P5+8LfAAysPDDHNBq1hppeNanpVTPrgQtbwJQJbkHgHlTYRSVl3z6ujhqNMS4Ojbs7fjO+wa527UK/rnj6ZKQb2Lv6Ase3XCGnqR519lpzEO5rj1tJB0qUdcathH2eAnFFUbh+Pp5Tu69z/lAUBn0euoGrwEqnwdpGi7WNBqubr9Y2WmydrPGv4IpfBVd0dtLbQwghhBBCZJXvoLt06dK89NJLDB48mFKlShVGmZ4qi88sRm/UU8m9ErW8auXv5LM3lwor16HgC3aXpM2buTJyFBgM2FSqhN+3M7Hy9S3064qnz8WjUWz/4yzJcXoAgut64+pjR8zVFGKvJRN/IxV9ioFr5+K5di7ecp6dkzUly7viX9EVvwpuOLplXZYoMSaNM/9FcHrPdRKj0y37Hd1scPWxw87ZGjsnHXbO1tg767Bzsjbvc7TGSqdBJa3WopiT+lkIIYQonvIddI8ePZp58+YxZcoUWrZsyZAhQ+jevTs6na4wyvdEyzBm8MfpPwAYWGkgquhz5gOe5e5/ssl0e33ucu3um1zJyCBpy1Zsa1THyts7X+U0REVx/f0PwGDAsWMHfKdORW1rm688hLif5Dg9Oxaf5cJh83rxTh42NO9fnlKV3LOkM2QaibueSsy1ZGKuphB9OYnroQmkJmZwbv8Nzu2/AYCzpy1+FVxx87XnwpForp6Js+RhZaOhbG0vKjYsgU+Qc4F0VReiqEn9LIQQQhRPD7xO96FDh5g3bx6///47RqOR/v3789JLL1GrVj5bawtZcV7jc+X5lYzfNR4vOy/Wtl+A1czaoJjM62S7Bd775KuHYE5LsHaEdy+ANvfluNKOH+f6Bx+iP3sWbYkSBC5dgtbdPdf0d1IUhSuvDSd561Z0FSoQuPhPVLL0lyhAiknhxPar7FkZSma6EZVaRc22/tR5JhAra02e8jBkGom4kMiV07FcOR1H5KUkFFP2/9r8KrhSoWEJytTwxEqXt7yFKGwFXU89LvVzXhTnOlwIIYTIaz31wEH3LZmZmXz//fe89957ZGZmUrVqVUaOHMmLL75YLFqPimuFrSgKvf7qxdm4s4yuNZoh8fGwaYr5YPlO0O/3e2ew5VPY9hlUfBaeW5BjElNaGlEzZhI7f765Zfwmu3r1KPXLz6i09+/oELdkCRHjJ6CysqL0sqXYlMtDK7wQ96EoCvE3Url0Ioaz+24QFZ4EgHegEy0GVMDDz+Gh8s9IM3D1XDxXTscSey0F32AXyjfwwcldemiI4qew6qniXj/nRXGtw4UQQgjIez31wBOpZWZmsmLFCubOncuGDRto0KABQ4YM4cqVK7z//vts3LiRRYsWPWj2T7x9Efs4G3cWW60tvcr2gB+a3j545l84twGC2+aewa31uXMZz53y339cHz+BzMuXAXDq3BnX5/pw+ZVXSd23j8iv/of32PfuWcaMy5eJ/PQzADxHj5aAWzyUzAwjV8/EEX4ihksnY7KMq7ay0dCgaxBVmpcskBm/rW21BFbzILCax0PnJcTjRupnIYQQonjJd9B96NAh5s6dy++//45arWbgwIF8/fXXVKhQwZKme/fu1K1bt0AL+qT5NeRXALoGdcX50m5IuAy2blClJ+yfA2veg8BmoM1hLF7SDbh22Py+bNbA3JiYSOSXXxK/ZCkAWh8ffCZNxLFFCwBKfPYpV0eOInbePGyqVMG58zM5lk8xGrk2bhym1FRs69TGbfCggrlx8cRSTAr6NAPpyZmkJWeSnpxBWnImqYkZXD8fz9Wz8Rgzb/e4UGtVlAx2IaCKB2XreGHvLONOhXgYUj8LIYQQxVO+g+66devStm1bZs2aRbdu3bCyyr5ETmBgIH379i2QAj6JLiZcZPuV7ahQ8Xyl52HlKPOBWi9A07fh1GqIDYU930HTN7NncH6D+dW3JjjenhQtafNmIiZOwhBlnojKtX8/PN98E43D7a66Tu3akT5sGDE//sj1Dz9EVzYImzu+kN0SO28eaQcOorazw/ezz1BpZPzr4+rM3gguh8RSpUVJfAKdCyxfk9HEhSPRnNh+ldhryaSnGHIcR30nBzcdAVU8CKjiTslyLljbyKqFQhQUqZ+FEEKI4inf33gvXLhAQEDAPdPY29szd+7cBy7Uk25BiHkMdnP/5gRkZJrX20YFdV4CGydo+xGsGAbbv4Rqz4FzyawZnF1rfg1ub9mVvGMnV4a/DoB16dKU+Pgj7OrUyfH6nqNGkh4SQsrOnVwZ8QaBS5egcXGxHE8/c5ao6d8A4P3+OKz9/ArmxsUjd2L7VbYtOgOYg+/S1Tyo3yUQDz/HB84zLTmDkJ3XOLHtqmVZrztZ22iwcbDCxsEaWwcrbOytcCtpT0AV9zyvpS2EyD+pn4UQQojiKd9Bd2RkJBEREdSvXz/L/r1796LRaKiTS6AnzOLT41kduhowLxPGgZ/NB8q1B9fS5vfV+sCBX+Dyf7BhPPT65XYGhgwI3XrzHPNSYaaUFCImTgTAuWsXfKZMQX2PJWJUGg0lv/qSi716k3nlClfffgf/2T+g0mhQMjK49t57KJmZOLRogXPPngV5++IRCtl1zRJwewc6ERmWSNixaMKORVO2thd1OwfiVsI+z/lFhSdxbOsVzu27gdFg7iZu62hF5aYlKVPDEzsna2zsrdBYqQvlfsTTw2hS2HomkqgkPb3r+KORNdLzROpnIYQQonjK97fj119/ncs3J+e609WrV3n99dcLpFBPsiVnl5BuTKeiW0XquFaEwwvNB+oOvZ1IpYJOX4JKDSeWwcUdt4+F74aMJLD3ghI1AYiaMZPMa9ew8vXFZ8KEewbct2hcXPD7diYqGxtSdu4kasZMc17ffof+9Gk0Li6U+GiKtEo+ps7sjWDLgtMAVGvpR893a9NvYn2C63qDCs4fjOSPKXvZOC+EhKi0LOeajCaS49KJuJhA6OFIjm66zPKvDrJ46n5O776O0WDCs5QjrQdXZNDUxtTvUgbPUo7Yu+gk4BYPJSEtk592XKDFV1sYMv8AY5cf54MVx3nIRTaeGlI/CyGEEMVTvlu6Q0JCclzrs2bNmoSEhBRIoZ5UmcZMfj9tXgrshUovoDqxFPQJ4BoIQa2yJi5RzdzdfP9PsOZdeGUHaLRw9uas5cHtQK0m7fhxYn/7DQCfyZNQ2+e95dKmQgVKfPwx195+m5jZs0FRiPnpp5t5TUbr6fnwNy0euXMHbrBpXggoUKVZSZr0CUalUuHqY0+7IZWp3SGAvasvcPFoNGf+i+Dcvhv4lnNBn2ogJV5PalIG5BDjqNUqgmp5Uq2VP96BTvKDjCgw524kMW93GMsPXSUt0wiAk42WZL2BP/ZfxtnOinEdKxZxKYs/qZ+FEEKI4infQbdOp+PGjRuUKVMmy/7r16+jzcO6z0+ztWFriUqLwtPWkw4B7WH9zUC77hBQ59BC2PIDOLEcIkPMwXeDV28H3eXaoWRmcv3D8WAy4fTsszg0bZo9j/tw7vwM6cePEzt/PjE//mje17ULTu3bPehtiiIUejiSDb+EoChQqXEJmvUtly04di/pQKfXqhF5KZG9qy8SfjKGK6fjsqRRq1XYOVtj76LDwUWHu58DlRr7Yu8iM4yLgpGiN7AnNIZ5u8PYeT7asr+CjyODG5Wma42S/HX0Gu8uO8bsbRdwsbXmtRZBRVji4k/qZyGEEKJ4ynct3K5dO8aNG8eqVatwdjbPhBwfH8/7779P27b3WFf6KZZpymRd2DpmHJ4BQL8K/bC6dghuHAetDdQYkPOJdm7QegL8PRq2fAK+NcyzmqutoExLYubOQ3/mDBoXF7zHjX3g8nm98zbpp06Rum8fWh8fvD/44IHzEkXn4tEo1s85iWJS/s/encfHeO0PHP/Mnsm+L0gEWeyxE1RtFUtpNb0uXdRefkHR29qql6suVa7WUm1V0ZbqotraiiKWNrYQe4IQQURk32f//TEyFYksJJJw3vc1t/LM85znzIR55vucc75fGnbwpOurDZGUsBbWva49/ScEkXg1g5Qb2Vjbm4NsG0cV1nbKEo+trgwGAzqdrqq7IQAanYHj19K4k6UhOfveh5aUbC25Wr1l3zr2Mjo2cGVgy9q08HY03ygy6hjQzI38/AA+PxDLt39ewk0t4fmgWlX4qh6OQqFA9hgqQIjrsyAIgiBUTxJTORfL3bx5ky5dupCSkkLLluY1xVFRUXh4eLB79268vb0rpaMPKzMzEwcHBzIyMrC3t3+s587V5bL58mbWnVvHrZxbALhbu7Op/yYct74NZ3+Clq/BCyse3IjRAKu6w60osHaF3GSo9yzaZ5dyZcALmLRaan24AIcXXnikvhrS00nbuBG7Xr1Q3TdKIjwabb6erNR8TEYTEonE/JBy338lyJVSFEoZMoW03FO3484ks+OzMxgNJvzbetBzeGOkNTBoflgmk4nExETS09OruisVxmQykZGnx4QJK7kMlUKKtAZN6U/L0ZKjNZS4j0wC1io5NioZ8uJm+9yVkacjK1+PBHCyUWKtrHklDB0dHfH09Cz233ZFXadq2vW5LKryGi4IgiAIpSnrdarcQTdATk4O69ev59SpU6jVapo3b86QIUOKrQla1arigp2Wn8aG6A18F/0dGZoMAJytnHmt0WsMChyEg04D/2sMRh2M2W8ewS7J9WOwuqflR1OvecR/dozco0ex6dgR79VfivW1lez21UwyU/KQK2XIFVLz426ALFdIkcml5GRoyEjKI+NOLhl38syPpDxyM7XlOpdEAnKVDIVSZvmvQiVFKpMikUqQySRIZBKkUglSmTlgvxqVjEFvpEErN3qNbIJU9nQlNLt16xbp6em4u7tjbW392P496A1GtAYjVnJZhd7kMBpNJGTkkaP5ezRYIpGgVkixVSmwUclQyis/8NQbjMikknK/n1qdgbiUHEyArUqOXCZFLpMgl0jM/5VKkcukZc5KbjKZSMrMJz1Ph0QiobajFTaq6ne9KY7JZCI3N5ekpCQcHR3x8vIqsk9FXqdq0vW5LETQLQiCIFRnZb1OPdQiLxsbG8aMGfPQnSswf/58fv75Z6Kjo1Gr1XTs2JEPP/yQwMBAyz5du3Zl//79hY578803+eyzzx75/BXtTu4dVp1ZxeZLm8k35APgbefNsCbDGNBgAFZyK/OORz4yB9y125QecAN4tzVPQY8yZzrPuCgl9+hRJGo1nv+ZIwLuShb1Rzx//nT5kdpQWcuRyaWYTCZMRvMXcZPpnv8aTJYyXCYT6PIN6PJLHiW8X70gV557CgNug8FgCbhdXFwe23n1BiPX0rPR6I1IJQaslTJsreTYquSoFbKH/ndpNJqIS8kh1yBFplDhZK0gW2NAozeQZ4S8PCN38oyo5Ebs1XKsFDJkEgkyqfkhlRT8l4fqg9FkIjNPR/LdKeDudlZ4OliVq43k3FyQK3GwUuDrWvbkjiXxsbJCkppHep6WW9lG6lnJsVHVjHXKarUaMJf0cnd3r9Sp5hV1fRYEQRAEoeI89DeW8+fPEx8fj1ZbeBRvwIABZW5j//79hIWF0bZtW/R6PTNmzKBXr16cP38em3uycI8ePZr//Oc/lp+tra0fttuVxmQy8X97/o/oVHOZpsYujRnRdAQ9fXoik97zBcugh+NrzH9uN7pQG8a8PEwGIzLbYr6k9pwNcQfRK+ty+9N1ALhNmICyTp3KeDnCXTFHEi0Bt7uv+e6VQWdArzWi1xnR6wwYtEb0eiPW9koc3NR3H9Y4uJv/bO+qxsqm9FEmo9GEXmtApzE/zH82otPo0WuNGA0mjEajOUA3mDAZTeZtBhNWtgr8Wrsje8oCbsCyhvthPhfScrUkZ2vwtLfCzqrsI4FGo4lrKblo9EYkmAPVbI2e7Lsj0zKpBBulHFsrOXZWclRlHJU2GE1cS8khW6NHKpHg62qD7d3AUqMzkJmvJytfR87dIPxO1oNvzEiQIJWCWmG+GWCnUmBVwtIFvcFIaq55vbXOYLRsv5OtwclagUpRtteg1RtJyzX/TtzsKi7xnkQioY6zGkOKiax8HXEpOdR3tUVdQ6aaF/z91Ol0lb6+uyKuz4IgCIIgVJxyB91Xrlxh4MCBnDlzBolEYqmfWvBFzmAo++jc77//XujntWvX4u7uTmRkJF26dLFst7a2xtPTs0xtajQaNBqN5efMzMwy9+dRnE85T3RqNCqkLG86jvYtxyApbo3ixR2QeROsXaDxi5bN2mvXuPba6+hTU1EHBWHTuRO2zzyDVZMm5nZs3WHiKRKnvI0xMxarJk1wHvr6Y3ltT6tr51LYu+4CAEHdven0D78HBiwmk+mRZxxIpRKUVnKUVjVj9K66Ke/7n5Wv40ZqHiZMxKXkUtfZGnt16YG3yWTiRloeOVo9MqmEBm62AOagO19PjkaPwWgiM19HZr45+HSyVuJhrypxSrjBaCIuOcfc7t2A+96RXJVChptChpudCr3RSHa+nqx8PTqDEYPJhNFowmA0t1PwP4MRy82ARPJRyKTYqsw3AgqmfefrDKRka0jL1WG8+3kul0pxsVWSU3BsZj51Xco2Yn0nW4MJE7aqih+Jlkok1HW25urd9+lqcg61HK1wUCuq/Yyfx9G/irw+C4IgCIJQccr9jeitt96iXr167Nmzh3r16nH06FFSUlJ4++23WbRo0SN1JiPj7vpnZ+dC29evX8+3336Lp6cn/fv3Z9asWQ8c1Zo/fz5z5sx5pH48jK1nvwage3YWHbZMhb++NI9kBw0Bq3vm9x9dZf5vq6GgME/Z1N+5Q/yo0ejv3AEg78QJ8k6cIHnpMmROTth07IjNM53BaCLr999BJsPrg7lIRAmYSpN4NYPfPz+D0WhOTNbp5QcH3PB4vlALFSdfZyA+NRcTJuQyqXmqeGrZAu/bmRrS87RIMAeAVndHgK0UMlxtVZhMJvK0BrI1erI05iA8LVdLep4OFxsl7nYq5PfNSDAYjVxNziX3AQH3/eRSKY7WShytlUWeM5lMGE3m0Xe9wUSO1nwzIFtjDtDTcrWk5ZpHQFVyGRr934FYwWtwVCuQSiXk6wxcup1FRp6OHI2+1CBaZzCSmmNu292ufFPSy0oqlVDX1Zqrd3LIu/t7tFXJqe2oRqWQYTQY0OXno83Pw2g0IJVIkUgLPwxGyNQYMBhNSCUSJBKQSkAKlj9LAJlMilwmQ6GQI5PJkN49vrqqzOuzIAiCIAgPr9yJ1FxdXdm7dy/NmzfHwcGBo0ePEhgYyN69e3n77bc5efLkQ3XEaDQyYMAA0tPTOXTokGX7F198Qd26dalVqxanT59m6tSptGvXjp9//rnYdoob6fb29q7UJCx6g44e37QhVWJkea6cZ9OSQJttflJhA0GDzQG4RAYr2gISeOsUONXFkJXFtdeHoomORuHtTe0lS8g/d46cQwfJiTiMMTu7yPlcRo/C/e23K+W1CJCWmMPPH50gP0eHd2Nn+v1fc2Ty6vtF+2mXn5/P1atXqVevHlZWpQd6eoORy3ey0eqN2Cjl+LracCMtl4y7Sbp8nK1xeEDgnZqj5UZaLgB1nKxxtika9N4vV6snMSP/76nnEgmudipcbVXIpBL0RiNxBQG3VEI9VxuslRV/Q81ovBuAa8wj5Pm6v4NteysFrrYqbFRF16LfSMslNUeLtVJOAzebEm8w3UrP4062BhulnPql7FsRr+dOtoaUzFzkRh1Kow4riR70lVwyTiLBJJGCRIpUocSjdtlKmJX097SikoVV1vW5KolEaoIgCEJ1VmmJ1AwGA3Z2doD5Ap+QkEBgYCB169YlJibmoTscFhbG2bNnCwXcQKGEMM2aNcPLy4sePXoQGxtLgwYNirSjUqlQqSpuHWFZHDm8mFSJEUeDkY6DfgIbNzj9vXlUOzkGjq82P2w9zAcE9Aanuhg1Gm6EjUcTHY3MxQWf1V+i9PFB3bQJTv8chEmnI+/UKbIPHiLn0CHyz51D5e+Ha1jYY319T5PsNA2/LY0iP0eHe107eo9pKgLuJ4jRZOJaai5avRGlXEpdF2tkUnOgfT01l/Q8HfEpufi4qHFQFw6os/N13EzLA8DdTlWmgBvAWimnnquNeZp2Rj55OgO3M/NJydYy+p/P49+oKVPe/y/yuwG3uhICbjCPENtZKUhJvElgvXocPRZJQJOmWClkJa4597C3Ij1XR65WT0aertjRdTDfzPh99x5GDOpP/K0kJBLbCuu70WjEqNdj0Osw6O4+9DqkWi3OxdRll8oVqNRqZHI5RqMRjU5PvtaAyWhAggmJyYTs7oi2CczD25j/bOLun013/89kRIIRacH9aZMJickAGNAXOXPVqqzrsyAIgiAIj6bc3+6aNm3KqVOnqFevHu3bt2fhwoUolUq++OIL6j9kfefx48ezdetWDhw4QJ1SEoO1b98egMuXLxcbdD92miy2nv0GrKT0dmyIwuVun9qNhraj4OoBOLYKordB9u27z43CZDCQ8O5Uco8eRWpjg8+qL1D6+BRqWqJQYN2mDdZt2sDkSRgyM5GoVEgf802Fqpafo+Pwr1e4fTUDG0cVds5W2LlYYedshb2LGjsXK9R2j76mMz9Hx5ZlUWSnanBwV/P8+CCxvvoJYjKZuJlmLsMlk0jwdbGxTPOWSCR4O1tDWh7puVriU/LwcQaHuwFmvs7AtbvT0R3VCjzsyzd1WiIxB7y2KjkZeTpuZ+aj0RvR6o3ojSbkUundgLt8CbbCw8Pp1q0baWlpODo6lutYhVxa5MZCsfvJpLjZqbidmU9iRj72Vopiy6MlZ2tp3rodf56+RG33h88ib9Dr0Obno8vPQ6fRYtTrMOhLCG8loFCqMMlVfL9lO+u/+ZrzZ06RkZ7GnoOH8WrQCJ1BATKQyiU42ShxtVGWOTEcmNfJ6w1GdHoDer0evcGAQW9AVc2mmlfG9VkQBEEQhEdX7ojivffeIycnB4D//Oc/PP/88zzzzDO4uLjw/fffl6stk8nEhAkT2Lx5M+Hh4dSrV6/UY6KiogCKrXVaFXL3/Zc9d7+3Ph88rfCTEgnUf9b8yLgBJ78FmRJT/e4kzp1L1s6dSBQK6qxYjlXjxqWeS/YUTq27EnWH/RtiLLWuk68XnW4PIFNIca1jS9Nna+Pf2gOZonxfhvVaA9tXniY1IQdrByUDJrZAbVe2kUyhZkjO1pCWq0UC+Lj8vRa7gEQiwdtJjQRzVvP41Dy8ARuVnLiUHAxGE9ZKOXWcHr4OuEQiwdFaib1aQVqOFonEXOKrvptNkf5UJ262KlJztGgNRpJzNEXWa+uNRlKyNSiUSvy86iItYzBqMpkw6LSWIFubn4+hmJFrAIlUikyhQC5XIJPLkSkUyBRKFFYqpHcrRNgqZXTq3Jle/V9izrsTSc7R4mowopCZE8M5WyuLrKcvC3M5NtndQL36fi5U5PVZEAAWLFjA9OnTeeutt/j4448Bc9nWP/74g4SEBGxtbS3lXhs2bPjAdmbPns3GjRu5fv06SqWS1q1bM2/ePMtAikajYdSoUfz66694enry6aef0rNnT8vxH330EfHx8SxbtqxSX68gCEJlKfe3j5CQEF566SUA/Pz8iI6OJjk5maSkJLp3716utsLCwvj222/ZsGEDdnZ2JCYmkpiYSF6eeQpnbGwsc+fOJTIykri4OH777TeGDh1Kly5daN68eXm7XvGSotl77hvypFK8VS4092zz4H0d6kDXafDMFJJXriT9u40gkVDro4XYdOjw+PpcQ+Rladn55Vl2fHaG3EwtTp7W9BrZhK6vBtK6d13823rg1cABG0cVSMCgM3L7aiZ71l5g3Yw/OfLbFbLTNKWeR5un5+qpO2z79DS3LmegVMvpP6EF9q7qx/AqhYeVrzNw+EoKy/Zc4j9bzpGZZ57+XJCiwmQykavVWx63MvK4mpxDvs6Ao7USmVRS6PmCR57OgLONAiu5jDydnku3szifkElmnjmzt7udkny9odhjCx5lSZMhlUhwsVVhrZRhp5Twr8lv4eDggKurK7NmzbK08c0339CmTRvs7Ozw9PTklVdeISkpCYC4uDi6desGgJOTExKJhGHDhgHm6dgLFy7Ez88PlUqFj48P8+bNK9SHK1eu0K1bN6ytrQkKCiIiIuLB/ZVKLKP7p85f4vnnn8fJyQkbGxsaN27M99//iEqfy4U//8DRWsmV82e5c+0qHTu0RyKRFHlEHjrInfg4Lp85xRuvvYa3bz3q1Pdj4D+HcO7CBRQqFdYOjjh4eOJS2xt33/q4+9bHtY4Pjp5e2Lm6Ye3giMra2hJwA7zxxlA++u9cBr/QFzAnhvN2tibQ0w53O6uHCrhrkoq8PgvCsWPH+Pzzz4t832rdujVr1qzhwoUL7Ny5E5PJRK9evUrMjh8QEMDy5cs5c+YMhw4dwtfXl169enHnbgLZL774gsjISCIiIhgzZgyvvPKK5XPw6tWrrFq1qshn2OO2YMECJBIJkyZNAiA1NZUJEyYQGBiIWq3Gx8eHiRMnWpICl+TChQsMGDAABwcHbGxsaNu2LfHx8Zbnp0yZgrOzM97e3qxfv77QsT/++CP9+/ev0NcmCELlK9dIt06nQ61WExUVRdOmTS3b7882XlYrV64EoGvXroW2r1mzhmHDhqFUKvnjjz/4+OOPycnJwdvbm9DQUN57772HOl+FMplgxztsszZ/Ee3X8B9lGv1K2/g9ycuWA+Ax6z3se/eu1G7WNCaTicvHkzjw/UXys3VIpBJa9vKhbT9f5A8YCTTojWSl5hN7Iomz+2+Snabh+PY4Tvx+jQat3GjWzRvP+vZIJBKMBiNJ17K4fiGV6xdSSbySiclovrDL5FL6/V8zXOtU3FpUoWKk52o5HpfGsbhUjsWlcuZmBjqD+fdW205Gt9ruXE/N5Va2wVwKSyql04d7q6Sv5/8TUq5EaF9//TUjR47k6NGjHD9+nDFjxuDj48Po0aPR6XTMnTuXwMBAkpKSmDJlCsOGDWP79u14e3uzadMmQkNDiYmJwd7eHrXafLNo+vTprFq1iiVLltC5c2du3bpFdHR0ofPOnDmTRYsW4e/vz8yZMxkyZAiXL19G/oCqCE7WCtIyTfx3xhSMOi2/bNyAlVLJxcuxWGPAVp+NQp8PgE6jwaBSsXrFcksddYDps+cQc+kSzk6OGHQ6Rv1fGFZWVvyw/htcXN1Y9+16/jlsBBcvXsTe2ZmDBw/Sp0+fEt+/zz//nFdffbXQNqu70/R9nK1xesAa9CdNRV+fhadbdnY2r776KqtWreKDDz4o9Ny9uXZ8fX354IMPCAoKIi4u7oHL/l555ZVCP//vf/9j9erVnD59mh49eliC0CZNmlC/fn3eeecdkpOTcXNzY9y4cXz44YdVmkivuBsQCQkJJCQksGjRIho3bsy1a9cYO3YsCQkJ/PTTTw9sKzY2ls6dOzNy5EjmzJmDvb09586dsyRY3LJlCxs2bGDXrl1cunSJESNGEBISgqurKxkZGcycOZM//vij0l+zIAgVq1xBt0KhwMfHp8JqfZY2IuTt7c3+/fsr5FwV7txmkq8dIsKnNgD96vUr9ZDMXbtI/M9/AHD9v//D+b6L0NMuJ0PD/g0xXD2VDIBLbVu6D22Ie92SL7QyuRRHd2ta9/al5XM+XIlK5kz4DRIupXPpeBKXjifh5mOHnbMVN2LS0OYVXh/q4KbGu5EzjTp5lXou4fFIzdFy5EoKEVdSOHwlhYu3iy4rcLdT0baeM61q22CtzEcqlWAwmsjI0xXKzF3deXt7s2TJEiQSCYGBgZw5c4YlS5YwevRoRowYYdmvfv36LF26lLZt25KdnY2tra0loHJ3d7es6c7KyuKTTz5h+fLlvPHGGwA0aNCAzp07Fzrvv/71L/r1M39uzZkzhyZNmnD58mXLFFGTyYROk482Lw9dfj46TR42BiO3b16nX0gvAv38AKhbrx46kxSdVIbK1nzDysHNAxdXV9x8fM1tAR9//DF/HTnKoYMHqdPAj0N//knUmbPcvp2IlZX5ZkGLtu3Ysm0bP/30E2PGjKFNmzaWJUUP4uHh8XBv/BOmoq/PwtMtLCyMfv360bNnzyJB971ycnJYs2YN9erVw9vbu0xta7VavvjiCxwcHAgKCgIgKCiIb775hry8PHbu3ImXlxeurq6sX78eKysrBg4cWCGv62E86AZE06ZN2bRpk+XnBg0aMG/ePF577TX0ev0Db2DOnDmTvn37snDhwkLHFrhw4QJdu3alTZs2tGnThkmTJnH16lVcXV159913GTduHD735QASBKH6K/ea7pkzZzJjxgy++eabp/cOuiYbds5kp601BomEZq7N8HXwLfEQk15P4qz3wWjEcdAgXCeMfzx9rQEMBiMXDiVw+NcraHL1SGUS2vT1pVVI3XJnDpfKpPi1dsevtTvJN7I4ve8GF4/e5k58FnfiswBQWcup09AJ70bOeDdyFlPJS3HxdhZZ+Xpa13WqtHNk5Oo4ctUcZEfEphCdmFVknwZuNrT1dbY8vJ3VSCQSSykmXzdbjFIFWRo9WXk6fnjz72UbKrmMem7WyB9D4it1Oddmd+jQodAsmeDgYBYvXozBYCAqKorZs2dz6tQp0tLSMBqNAMTHx9P4AXkgLly4gEajoUePHiWe994Rm4IcGUlJSQQEBJCflUVuZjp6rbbQMRKplBHDhzP9vffYF3GEPiG9aPVsHxo0bEwdJ2tsHBwBsLK1RXFPWawdO3Yw87332LJlC03ujsKej44mOzsbV1e3QufIy8sjNjYWALVajd/d4F4onbg+CxVh48aNnDhxgmPHjj1wn08//ZR3332XnJwcAgMD2b17N0plybNKtm7dyuDBg8nNzcXLy4vdu3fj6uoKwIgRIzh9+jSNGzfG1dWVH374gbS0NN5//33Cw8N577332LhxIw0aNOCrr76idu3aFfqaS1LWGxCApWTQgwJuo9HItm3bePfddwkJCeHkyZPUq1eP6dOn8+KLLwLmGxBffPEFaWlpXLlyhby8PPz8/Dh06BAnTpzg008/reiXKAjCY1DuoHv58uVcvnyZWrVqUbduXWxsbAo9f+LEiQrrXLV14CPISmCrt/lOY7/6pY9y5587hyEjA6mDA57vz6rU+rU1hclo4vKJJI78doWMpLulmOra0X1oI1xqP/oUb9c6dnR/vRHBAxtw8chtdFoD3g2dcatrV2z2ZaGojFwdoZ/+RZZGz7Q+DXmzS/0K+btrMJqIup5OeEwS4TF3OJuQwf0TXwI8bAmu70JwAxfa+jrjYlty1n6JRIKNSo6NSo6nvRV6g5FsjXmdtouNCmUNK/2Wn59PSEgIISEhrF+/Hjc3N+Lj4wkJCUF7XzB8r4Ip5qVRKP6uRV7wO81OSyM5/ipGgzm4l0ilqNTWKKzUKNVWyJUqxk/5F0Hdnmf/np0c+zOcBR9+yNT35/Gfmf8q9jznz59n8ODBLFiwgF69elm2Z2dn4+XlRXh4eJFjCkbtH3Z6+dNKXJ+FR3X9+nXeeustdu/eXaSe/L1effVVnnvuOW7dusWiRYsYNGgQf/75Z4nHdOvWjaioKJKTk1m1ahWDBg3iyJEjuLu7o1AoWLFiRaH9hw8fzsSJEzl58iS//PILp06dYuHChUycOLHQCHNlKssNiALJycnMnTu30PT7+yUlJZGdnc2CBQv44IMP+PDDD/n999956aWX2LdvH88++ywhISG89tprtG3bFrVazbp167CxsWHcuHGsXbuWlStXsmzZMlxdXfniiy9o0qRJRb5kQRAqSbmD7oI7cU+tOxchYjlxcjln5SCTyOjtW/q67JzDRwCwadcWyQPugD5Nrp9PJeKXWMvos9pOQZu+vjTtUhtpBSc7UtsqCepRtmlvQmEbjsaTpTFPx1+wI5rEjHxmPd8Y2UPctEjJ1nDg0h32Rd/hwKU7pOcWzlJd383GEmR3qO+CaylBdmnkMimO1kocH6mVynfkyJFCPx8+fBh/f3+io6NJSUlhwYIFlmmbx48fL7RvwcjSvVOK/f39UavV7Nmzh1GjRpV47oIp5BlJiQDkZ2dhNBiRKRRYOziitrVDKis8cm+lkNHYvz4etUYw6PURfLJgDps3fs0H771TpP3k5GT69+9PaGgokydPLvRcq1atSExMRC6X4+vrW2z/xPTy8nnqr8/CI4uMjCQpKYlWrVpZthkMBg4cOMDy5cvRaDTIZDIcHBxwcHDA39+fDh064OTkxObNmxkyZMgD27axscHPzw8/Pz86dOiAv78/q1evZvr06UX23bdvH+fOnePLL7/knXfeoW/fvtjY2DBo0CCWL19eKa/9fmW9AQGQmZlJv379aNy4MbNnz37gfgWzlV544QXLZ2KLFi3466+/+Oyzz3j22WcBc7b3e9uZM2cOPXv2RKFQ8MEHH3DmzBm2bt3K0KFDiYyMfLQXKgjCY1Hu6O/f//53ZfSjZribPA2jnm2+rcCUTHCtYFzUpdekzT1yGADr9k93pvLbcZkc/iWWG9FpACisZLR8zoegHt6iJnY1o9UbWfvXVQC6N3Rnb3QSa/+KIykrn/8NalGmElfZGj3fRFxj57lETt1ILzSabW8lp0uAG10D3XnG37Xcta+fFPHx8UyZMoU333yTEydOsGzZMhYvXoyPjw9KpZJly5YxduxYzp49y9y5cwsdW7duXSQSCVu3bqVv376o1WpsbW2ZOnUq7777Lkqlkk6dOnHnzh3OnTvHyJEjLbk0cjMzSL15A50mn/y7ZabkKhWOnl6orG0eOKNh0qRJ9OoVgsypFunp6RyPOESTB0x1Dw0NxdramtmzZ5OYmGjZ7ubmRs+ePQkODubFF19k4cKFBAQEkJCQwLZt2xg4cCBt2rQp9/Ty1NRU4uPjSUhIACAmJgYAT09PPD09y9xOTfVUX5+FCtGjRw/OnDlTaNvw4cNp2LAhU6dORSYr+rlvMpkwmUxoNKVXDLmX0Wgs9pj8/HzCwsJYv349MpkMg8Fg+dzS6XSPLW9BWW9AZGVl0bt3b+zs7Ni8eXOhWUT3c3V1RS6XF1ke1KhRIw4dOlTsMdHR0Xz77becPHmSr776ii5duuDm5sagQYMYMWIEWVlZ2NnZVcyLFgSh0ogopzzO/wpXwjHJVGxVyyEXnq//fKmHGbVaciPN0/psOrSv7F5WS5kpefy16TKxJ8zlQaRyCc261KF1n7qiHnYl2xeTxOHYFCY/F1CuWtBbTydwO1ODm52Kla+1Yte527z9wym2n0kkOfsoq15vg4N18V8uNHoDG47Es3zvZVJy/p4K3cjLnm6BbnRr6E5Lb8cnvoRTWQwdOpS8vDzatWuHTCbjrbfeYsyYMUgkEtauXcuMGTNYunQprVq1YtGiRQwYMMBybO3atZkzZw7Tpk1j+PDhDB06lLVr1zJr1izkcjnvv/8+CQkJeHl5MWrEcDLu3Cb15g0AcjPS0WnykUgkWNmav7DZu7phZVPy0g6DwcDEiRO4ceMG1rZ2PNcrhE+XfVLsvgcOHADMNwfudfXqVXx9fdm+fTszZ85k+PDh3LlzB09PT7p06fLQo9e//fYbw4cPt/w8ePBgwByMljT6JAiCmZ2dXaHs92AeoXZxcaFp06ZcuXKF77//nl69euHm5saNGzdYsGABarWavn37Wo5p2LAh8+fPZ+DAgeTk5DBv3jwGDBiAl5cXycnJrFixgps3b/KPf/yjSB/mzp1L3759admyJQCdOnXinXfeYfjw4SxfvpxOnTpV7ptwV1luQGRmZhISEoJKpeK3334rdURcqVTStm1byw3BAhcvXizyOQnmGxpvvvkm//vf/7C1tcVgMFgqQhT8VyRPFISaQWIqS1HZe0il0hLXdFa3f/yZmZk4ODhYkls8NL0GlraCzBtEtR/B60l/oJarCR8UjrXCusRDc44eJX7oG8hcXfE/eOCpW899Oy6TbStOkZelAwk0bO9J2/71sHcRCcwq24n4NAZ/fhitwcjEHv5MeS6gTMeZTCb6Lj3EhVuZvBMSSFg382jjX7HJvPl1JFkaPQEetqwd3o5ajn//Hg1GE79G3eR/uy9yI828Tr+eqw2jn6lP94bueDpU/Gh2QSK1evXqlfqF52lhNBrRazToNPlocnPR5ecVqhYhkUhQqq1RWVujsrFF9pBLXoxGk8iPUEYl/T2tqOtUTbs+l0WFXcOFh9a1a1datGjBxx9/TEJCAqNGjSIyMpK0tDQ8PDzo0qUL77//PoGBgZZjJBKJpfxrfn4+r7zyCkeOHCE5ORkXFxfatm3Le++9R9u2bQud6+zZswwcOJCoqChLTgKj0cj48eNZv349gYGBbNiwocoSLN77XmRmZtKrVy9yc3PZvHlzoRwKbm5ullkB996AANi8eTP//Oc/WbFiBd26deP3339n0qRJhIeHF6kysWrVKnbu3GkpQXb06FGee+45du7cyY4dO/jpp584d+7cY3r1giAUp6zXqXJ/09q8eXOhn3U6HSdPnmTdunXMmTOn/D2tKeQqGLAUIpazzcERkqCHT49SA26A3IL13O3bP3UBd9zpZHZ+eRa91oirty09hzWukCRpQumSsvIZ920k2rtJsT7fH8s/23pT27H0mx0RsSlcuJWJWiHj1fZ/lybp2MCVH8YGM2zNUS7ezualT/9i3Yh2BHjYsjc6iY92xlgyj7vbqZjUM4B/tKmDQoxoVxqTyYReq0Wnyb9b2kuDXlt0yqZMoUBlbYPK2pwYTVoBmdxFwF29PLXXZ6FS3ZvssFatWmzfvr3UY+69yWdlZcXPP/9cpnM1bdqUS5cuFdomlUr59NNPq13W7hMnTlhyctx/E6BgNg+Yl7lkZGRYnhs4cCCfffYZ8+fPZ+LEiQQGBrJp06YiAfft27eZN28ef/31l2Vbu3btePvtt+nXrx/u7u6sW7eukl6dIAgVrdwj3Q+yYcMGvv/+e3799deKaK7CVPRdcp1RR/cfupOuSeeznp/RqXbp05ziXn2NvMhIPOf+B6diplI9qc4dvMn+DTGYTODTxJmQ0U3Fuu3HRKs38sqqwxy/loafuy2OagXHr6XxQotafDK4ZanHD19zlH0xdxgaXJf/vNC0yPM30/N446ujXE7Kxs5KToCHHZHXzOv07a3kjOvqx7COvqiV5Suf9TCexpFuo8FAfk42+dlZ6PLzKe5jXCaXo1CpUFiZR7TlpZTzKdCnTx8OHjxY7HMzZsxgxowZj9T3p9XjGOl+kOp6fS4LMdJdeXynbavqLlS4uAWlV5MRBEGoSJU20v0gHTp0KLFMwpPir5t/ka5Jx8XKhfZepa/PNubmknf6NAA2HZ6OJGomk4mjW65yfHscAA07etH11UBkYrTzsZm79TzHr6VhZyXni9dbk6s10H/5IX6NSuCNjr608nlwze3LSVnsi7mDRAIjOtUrdp/ajmp+GhvMqHXHOX4tjchraajkUoZ3qse4Zxs8cK238PBMJhPa3FzysjPR5OQUCrSlUilylRUKKxUKlRUKlQqZ/OF+B19++SV5eXnFPidqP9dMT8v1WRAEQRCqqwoJuvPy8li6dCm1a9euiOaqta1XtgLQp14f5NLS377cEydBp0NRqxaKOnUqu3tVzmAwEv5NNNGHzZmK2/bzpe3z9Z66afVV6Ydj1/nm8DUkEvhkcAvqu5mn87/cqg4/Rt7gP1vOs/n/Oj7wd/LlQXPG8ucaeeDralPsPgCO1kq+HdWeD3+PxmSCsc82qJQ120+zgqnj+VmZ5GVnYbxnTa5cqURtZ4fK2haZQlFh/8aehs/xp8nTdH0WhIclRv0FQahs5Q66nZycCn25M5lMZGVlYW1tzbfffluhnatusrXZ7Lu+Dyhb1nK4p1RYhw5PfOCpzdPz+xdnuH4hDYlUQtdXA2ncqVZVd+upcjI+jfd+OQvA5J4BdG/4dxbod0IC2XbmFlHX0/ntVAIvtCj6JTw5W8PPJ28CMLpL/VLPZ6WQ8e/+TSqo94LJaESn1ZjXZWvy0ebnY9D9Xc9cKpNhZWuH2s4OuVL1xH+mCOXzNF+fBUEQBKE6K3fQvWTJkkIXdalUipubG+3bt8fJ6cFTVp8Ee+L3oDFo8LX3pbFL8XVp75dTkETtCS8VlpOhYevyUyRfz0auktF7dFPqNi29frlQccyJ006gNRjp1diD8d0KJ3Zxt7fi/7o2YNGui3y4I5pejT2LrLn+JuIaWr2RIG9H2tR9sv89VwcGvQ5tbp45CZomH71WW2R9tkQiQWVtg5WdXYn1swXhab4+C4IgCEJ1Vu6ge9iwYZXQjZqhYGr58/WfL9MXX0NmJvl3SzlYt39yg+6s1Hx+WXKSzDt5qO2VPB/WHPe6IuFNedxIy8XLQY3sIbNBa/VGwtafIDEznwZuNiweFFRsZulRz9Tnu6PXuZmex6qDV5jYw9/yXL7OwDeHrwEw+hmxJKAymUwmcjMzyE5JLhJkS2Uyy7pshZUVCpUVUlnlJ6QTar6n+fosCIIgCNVZuTNbrVmzhh9//LHI9h9//PGJLl1gNBmpbVsbO4Udfev3LdMxucePg9GI0tcXhYdH6QfUQJnJeWxefILMO3nYu1oR+k5rEXCX05o/r9L5w330W3qQfdFJxWaiLs3crec5FpeGnUrOF0PbYGdVfBItK4WMqX0aArAyPJbEjHzLcz+fuElqjpbajmp6N/F8uBcjlMqg05F26yZZyXcwmUwoVCpsHJ1w9PDEzccXt7r1cPKqha2zCyprGxFwC2VWldfnBQsWIJFImDRpkmVbfn4+YWFhuLi4YGtrS2hoKLdv367UfgiCUPFWrlxJ8+bNsbe3x97enuDgYHbs2FFon4iICLp3746NjQ329vZ06dLlgUk5AbKyspg0aRJ169ZFrVbTsWNHjh07VmifRYsW4e7ujru7O4sXLy703JEjR2jdujV6vb7iXqggVKJyB93z58/H1dW1yHZ3d3f++9//VkinqiOpRMrsjrPZ/8/9eNt5l+mYnMMF67mfzFHu9Nu5bF58gqyUfBzc1bw4pRUObqXXgBb+lq8zsGLfZQCiE7MYvvYYQ1YdJup6epmOj07M5N+/nrWMUH88uAUN3Equg96/uRetfBzJ0xn4aGcMAEajidWHrgAwvJMvcpFpvsKZTCbyMjNJvhGPNi8PiVSCvasbzrW9sXNxxcrWrkIToglPn6q6Ph87dozPP/+c5s2bF9o+efJktmzZwo8//sj+/ftJSEjgpZdeqrR+CIJQOerUqcOCBQuIjIzk+PHjdO/enRdeeIFzd2dzRkRE0Lt3b3r16sXRo0c5duwY48ePRyp98HeJUaNGsXv3br755hvOnDlDr1696NmzJzdvmvPKnD59mvfff5+NGzfy3Xff8d5773HmzBkA9Ho9Y8eO5bPPPkMuF6VohZqh3N+s4+PjqVevaBmhunXrEh8fXyGdqs4UsrKX4cm1rOd+8kqFpSbksHnxCbLTNDh5WjPw7VbYOT+dmaszcnW8+c1xtp2+Ve5jf4y8QXK2eXT5zS71UcqlHL6Syosr/iRs/QniknOKHHMrI4/P98fS++MD9P74IOsizAH35J4B9GhU+owKiUTC+3eTn206cYPTN9IJv5hE7J0c7FRy/tm2bDeVhLIz6PWk375Fxp3bmIxGFFZWuNT2oe8LLzJ58uTH2pe4uDgkEglRUVEV3nZ4eDgSiYT09PQKb1soXVVcn7Ozs3n11VdZtWpVoXXjGRkZrF69mv/97390796d1q1bs2bNGv766y8O370hXRyNRkNmZmahhyAIVat///707dsXf39/AgICmDdvHra2tpZ/y5MnT2bixIlMmzaNJk2aEBgYyKBBg1CpVMW2l5eXx6ZNm1i4cCFdunTBz8+P2bNn4+fnx8qVKwGIjo6mefPmdO/enR49etC8eXOio6MB+Oijj+jSpQtt27Z9PG+AIFSAcgfd7u7unL5bd/pep06dwsVFJM4qoE9JQXPxIgDW7dpVcW8qVvKNbH5ZcoLcTC0utW14cUorbByK/2B9GvwYeZ2d524zddNpUrI1ZT5ObzCy6oB5dHnUM/WY3rcR+/7VldBWdZBIYNuZW/T8335m/XKWq8k5/HDsOkO+OEzHBXuZvyOa6MQsFDIJvRp78MXrrZnYw6+UM/6thbcjA1uas5f/Z8t5Vh0wlwkb0t7ngVPThYeTn51Fyo14NDk5SCQS7FxccK5VB7lS+chtV7cgt2PHjty6dQsHB4eq7gpjx45FIpHw8ccfV3VXHpuquD6HhYXRr18/evbsWWh7ZGQkOp2u0PaGDRvi4+NDRETEA9ubP38+Dg4Oloe3t7gJKAjVicFgYOPGjeTk5BAcHExSUhJHjhzB3d2djh074uHhwbPPPsuhQ4ce2IZer8dgMGBlVXiwRq1WW45r1qwZFy9eJD4+nmvXrnHx4kWaNm1KbGwsa9as4YMPPqjU1ykIFa3cczKGDBnCxIkTsbOzo0uXLgDs37+ft956i8GDB1d4B2uq3KNHAVAFBiJ3dq7i3lScpGuZ/LY0Ck2OHjcfOwZMbIGV7dMdpP15ORmAbI2eZXsvM3tA2Upo7TibSHxqLk7WCsvocm1HNYsHBTHqmXp8+Hs04TF3+ObwNcv08QLtfJ15sWVt+jbzxNH64YK3d3sHsuPsLY5fSwNALpUwrKPvQ7UlFGXQ68lKuUN+djYAcpUKBzcPFA+48/8kUCqVeHpWfT6AzZs3c/jwYWrVerpKFj7u6/PGjRs5ceJEkXWYAImJiSiVShwdHQtt9/DwIDEx8YFtTp8+nSlTplh+zszMFIG3IFQDZ86cITg4mPz8fGxtbdm8eTONGze2jHbPnj2bRYsW0aJFC77++mt69OjB2bNn8ff3L9KWnZ0dwcHBzJ07l0aNGuHh4cF3331HREQEfn7mAYRGjRrx3//+l+eeew4w35Br1KgRPXv2ZOHChezcuZPZs2ejUCj45JNPLJ95glBdlXuke+7cubRv354ePXqgVqtRq9X06tWL7t27P9FrusvrSSwVlnglg18/NgfcHvXseWGSCLi1eiNHrqZafl5/5BrXUopOCb+fyWTis/2xAAwN9sVaWfj+VyMve9YOb8eG0e0JqmMeNfRzt+WdkEAOvtuNH8YG80p7n4cOuAG8HNS82aWB5ed+zb2o5fiErMk3mUCbUyUPk9FIXlYmKTfizQG3BGydnHGpXafYgFuv1zN+/HgcHBxwdXVl1qxZlmR633zzDW3atMHOzg5PT09eeeUVkpKSAPM08W7dugF/12cuyF5tNBpZuHAhfn5+qFQqfHx8mDdvXqHzXrlyhW7dumFtbU1QUFCJo4/3unbtGv3798fJyQkbGxuaNGnC9u3bgaIj7127dkUikRR5xMXFAZCens6oUaNwc3PD3t6e7t27c+rUqXL9qu938+ZNJkyYwPr161Eonq7Pp8d5fb5+/TpvvfUW69evLzJa9ShUKpUlWVPBQxCEqhcYGEhUVBRHjhxh3LhxvPHGG5w/fx6j0QjAm2++yfDhw2nZsiVLliwhMDCQr7766oHtffPNN5hMJmrXro1KpWLp0qUMGTKk0DrwsWPHEhMTQ0xMDGPHjmXdunWWgH3UqFFs3ryZ//3vfwwePBiNpuwzDQWhKpR7pFupVPL999/zwQcfEBUVhVqtplmzZtStW7cy+ldj5RYkUWv/ZKznvhOfxW+fRKHTGPDyc+D5sCCUapG8Iup6OrlaAy42ShrXsufgpWQW7brIsiEtSzzu0OVkziVkYqWQ8kYJo8sdG7jyS1gnMvP12FvJKzzJ1pvP1uenyBskZuYz+pn6Fdp2ldLlwn+rZpQzbfhxtHeTqZpHt91RqB4clKxbt46RI0dy9OhRjh8/zpgxY/Dx8WH06NHodDrmzp1LYGAgSUlJTJkyhWHDhrF9+3a8vb3ZtGkToaGhxMTEYG9vj1ptvmkyffp0Vq1axZIlS+jcuTO3bt2yrIUrMHPmTBYtWoS/vz8zZ85kyJAhXL58udSkNGFhYWi1Wg4cOICNjQ3nz5/H1rb45H0///wzWq220LHnzp3D4241h3/84x+o1Wp27NiBg4MDn3/+OT169ODixYs4Oztz8OBB+vTpU2J/Pv/8c1599VXAfLPh9ddf55133qFJk7LNOHmSPM7rc2RkJElJSbRq1cqyzWAwcODAAZYvX87OnTvRarWkp6cXGu2+fft2tZgNIQhC+SiVSssodOvWrTl27BiffPIJ06ZNA6Bx48aF9m/UqFGJuSQaNGjA/v37ycnJITMzEy8vL/75z39Sv37x30WSk5OZM2cOBw4c4MiRIwQEBODv74+/vz86nY6LFy/SrFmzCnq1glDxHjpqKviLLhSlS0xEe+0aSKVYt21T1d2pEEe3XkWnMVA7wJF+YUEoVKKMEZiDZ4COfq6Me7YBhy4fZMupBEY/U4/mdRwfeFzBKPfgtj4425Q8Wi2RSHBQV86InbVSzub/60hqrpaGnmJEqSLo8vKQKK2xdXbG2sGp1Bsl3t7eLFmyBIlEQmBgIGfOnGHJkiWMHj2aESNGWParX78+S5cupW3btmRnZ2Nra4vz3aUr7u7ulsAmKyuLTz75hOXLl/PGG28A5i83nTt3LnTef/3rX/Tr1w+AOXPm0KRJEy5fvkzDhg1L7G98fDyhoaGWLzcP+oIEWPoHsGTJEvbu3cuRI0cs6/aOHj1KUlKSJdnOokWL+OWXX/jpp58YM2YMbdq0KTXhm8c95Rg//PBD5HI5EydOLPGYJ93juD736NHDkkm4wPDhw2nYsCFTp07F29sbhULBnj17CA0NBSAmJob4+HiCg4MrtW+CIFQ+o9GIRqPB19eXWrVqERMTU+j5ixcvlnrTFMDGxgYbGxvS0tLYuXMnCxcuLHa/yZMnM3nyZOrUqcOxY8fQ6XSW5wrWiAtCdVbuoDs0NJR27doxderUQtsXLlzIsWPHiq0R+rTJPWKeWm7VtCkyO7sq7s2jy0zOI+6MObh89pVAEXDfo2A9d2c/FxrXsufFFrXZfPImC3ZEs35U+2IDrjM3MvjzcgoyqYSRnYtmGn7c3O2tcLd/wjLPK6xhRsJjOZVOk09m8h30GvOIrsLOCXt3D+SKsk3979ChQ6G/J8HBwSxevBiDwUBUVBSzZ8/m1KlTpKWlWabxxcfHFxlVKHDhwgU0Gg09evQo8bz3lnfy8vICICkpqdSge+LEiYwbN45du3bRs2dPQkNDi5SKut+OHTuYNm0aW7ZsISAgADAn98rOzi6S4CsvL4/YWPNNKbVabRlZKU1kZCSffPIJJ06ceGrLrj3O67OdnR1NmzYttM3GxgYXFxfL9pEjRzJlyhScnZ2xt7dnwoQJBAcH0+EJrOghCE+y6dOn06dPH3x8fMjKymLDhg2Eh4ezc+dOJBIJ77zzDv/+978JCgqiRYsWrFu3jujoaH766SdLGz169GDgwIGMHz8egJ07d2IymQgMDOTy5cu88847NGzYkOHDhxc5/+7du7l48SLr1q0DoG3btkRHR7Njxw6uX7+OTCYjMDDw8bwZgvCQyh10HzhwgNmzZxfZ3qdPnyKF659WlvXc7Z+MrOXnDiaACeo0dMLJ06aqu1NtZOXrLPW0O/mZa+NOeS6Abadv8VdsCvsv3qFroHuR4wpGufs398Lb2fqx9fepIpGAsnL/rppMRrJTU8lJTwNkSK1ssHNxw8rWrkKCvvz8fEJCQggJCWH9+vW4ubkRHx9PSEhIoSnb9yuYYl6ae9c7F/S3IKgvyahRowgJCWHbtm3s2rWL+fPns3jxYiZMmFDs/ufPn2fw4MEsWLCAXr16WbZnZ2fj5eVFeHh4kWMKRu3LM7384MGDJCUl4ePjY3nOYDDw9ttv8/HHH1vWkT/Jqtv1ecmSJUilUkJDQ9FoNISEhPDpp58+9n4IgvBokpKSGDp0qKU6RfPmzdm5c6clydmkSZPIz89n8uTJpKamEhQUxO7du2nQ4O+8MbGxsSQnJ1t+zsjIYPr06dy4cQNnZ2dCQ0OZN29ekVwceXl5jB8/nu+//96y3rtOnTosW7aM4cOHo1KpWLduXZmvfYJQVcoddGdnZ6MsptSNQqEodz3N+fPn8/PPPxMdHY1araZjx458+OGHhe5W5efn8/bbb7Nx48ZCF+17pxRWJyaTiZwjT856boPOyPk/zSOGzZ6tU8W9qV6OXk3FYDTh62JNHSdz8OztbM3Q4Lp8eegqC3ZE08XfDan07wAsLjmHHWfN9bzffLZBse0K1Z9eqyUjKRHd3cQtVrZ22Lm4IitlPXRxjtydGVPg8OHD+Pv7Ex0dTUpKCgsWLLBkbz5+/HihfQs+i++dVufv749arWbPnj2MGjWq3P0pC29vb8aOHcvYsWMt68eLC7qTk5Pp378/oaGhReqRt2rVisTERORyOb6+vsWepzzTy19//fUiZatCQkJ4/fXXix05eRJV5PX5Ydx/A8XKyooVK1awYsWKSj+3IAiVZ/Xq1aXuM23aNMv67uLcf+Nz0KBBDBo0qNR21Wp1kanrYL4BXFnXOEGoDOXOXt6sWTO+//77Its3btz4wOmOD7J//37CwsI4fPgwu3fvRqfT0atXL3Jy/s7+PHnyZLZs2cKPP/7I/v37SUhI4KWXXipvtx8b3fXr6BNugUKBdauSk2nVBJdPJJGfrcPWSYVvc1GH/V4F67kLRrkLhHXzw85KTnRiFr9E3Sz03BcHr2A0QddANxp5iTXUNY3JZCI3M4OUm9fRaTRIZTIcPbxw9PB8qIAbzFPFp0yZQkxMDN999x3Lli3jrbfewsfHB6VSybJly7hy5Qq//fYbc+fOLXRs3bp1kUgkbN26lTt37pCdnY2VlRVTp07l3Xff5euvvyY2NpbDhw+X6UtTWUyaNImdO3dy9epVTpw4wb59+2jUqFGx+4aGhmJtbc3s2bNJTEy0PAwGAz179iQ4OJgXX3yRXbt2ERcXx19//cXMmTMtNxcKppeX9LC7u4SnYFrzvQ+FQoGnp+dTM+2wIq/PgiAIgiBUnHJ/S5w1axYvvfQSsbGxdO/eHYA9e/bw3XfflXu92O+//17o57Vr1+Lu7k5kZCRdunQhIyOD1atXs2HDBsu51qxZQ6NGjTh8+HC1XBeWczdruTqoOVLrmj91+Oz+GwA0eaYWUlm579E80f5ez1046HayUTKuawMW/h7D4l0X6dvMCyuFjKSsfH6KNL+fY8Uod41jNBjITE6y1N1WqtU4uHsgkz9akruhQ4eSl5dHu3btkMlkvPXWW4wZMwaJRMLatWuZMWMGS5cupVWrVixatIgBAwZYjq1duzZz5sxh2rRpDB8+nKFDh7J27VpmzZqFXC7n/fffJyEhAS8vL8aOHftI/SxgMBgICwvjxo0b2Nvb07t3b5YsWVLsvgcOHAAokj376tWr+Pr6sn37dmbOnMnw4cO5c+cOnp6edOnSpdrOZKruKvL6LAjC08l32raq7kKFi1vQr6q7IAjlD7r79+/PL7/8wn//+19++ukn1Go1zZs3548//uDZZ599pM5kZGQAf2e8jYyMRKfTFZoy2LBhQ3x8fIiIiCg26NZoNIVq9T2OKXX3yrWs565+NwTK6058FolXMpFKJTTqVDXll6qrpMx8Lt7ORiKB4AZFZwCM6FSPr/+6xs30PL6JuMboLvVZ+2ccWr2RFt6OtK/nXEyrQnWlzcsjIykRg16PRCLBxskZG8fSM5OX5t7puCtXrizy/JAhQxgyZEihbQU1vAvMmjWLWbNmFdomlUqZOXMmM2fOLNKmr69vkTYcHR2LbHuQZcuWPfC5rl27FmqntDbt7OxYunQpS5cuLdO5y+tpWMd9r8q8PguCIAiC8PAeaj5kv379LKVm7nX27Nki2UzLymg0MmnSJDp16mRpIzExEaVSWajGJ5jX8CUmJhbbzvz585kzZ85D9eFRmddz3w26O7Svkj5UpIJR7vqt3LBxUFVxb6qXP2PNo9xNazngaF10DaWVQsaU5wJ4d9Nplu+7TN/mXnxz+BpgHuV+WrMr1zQmk4mctFSy01IBkCkUOLp7orB6wrK9C0+Myrg+C4IgCILwaB55vnBWVhZffPEF7dq1Iygo6KHbCQsL4+zZs2zcuPGR+jN9+nQyMjIsj+vXrz9Se+WhvXwZQ0oKEisrrB7hvagO8nN0XDx6GxAJ1Ipz6FIKUHQ9971CW9chwMOWjDwdg7+IICtfT303G3o1FlNnqzujwUBOehrJ169ZAm61nT0udbyf+IC7T58+2NraFvv473//W9XdE8qhoq7PgiAIgiA8mofL/IN5rd6XX37Jzz//TK1atXjppZceOkPp+PHj2bp1KwcOHKBOnb8DPE9PT7RaLenp6YVGu2/fvo2np2exbalUKlSqqhmVLSgVZt2qFdJiMsjWJDGHE9HrjDjXssHLz6Gqu1OtmEymB67nvpdMKuHdkIaM+vo411PzAHizS/1C2cyF6kWv05KbkUFeViamu+WzpDIZdq5uqG3tqrh3j8eXX35JXl5esc8VLP0RqreKvD4LgiAIgvDoyhV0JyYmsnbtWlavXk1mZiaDBg1Co9Hwyy+/PFRmVJPJxIQJE9i8eTPh4eHUq1ev0POtW7dGoVCwZ88eQkNDAYiJiSE+Pp7g4OByn6+y5R69G3RXwwRv5WEymjhzd2p5s651xFTo+8TeySExMx+lXEobX6cS9+3RyJ12vs4cjUvFw17Fiy1rP6ZeCmVlMpnQ5ueRm5GO5p7KCXKlEmsHR6xs7Sy1QZ8GtWuLv6M1UUVfnwVBEARBqDhl/ibZv39/AgMDOX36NB9//DEJCQklJtQpi7CwML799ls2bNiAnZ2dpZxMwSiLg4MDI0eOZMqUKezbt4/IyEiGDx9OcHBwtcxcnnfqNADWbdpUcU8ezY3oNDKS8lBYyQhoJ6ZC369glLutrxNWClmJ+0okEua+2JQW3o7M7t8Elbzk/YXHx2QykZ+TTcqN66Ql3LQE3CprG5y8auNSxwdre4enKuAWaqbKuD4LgiAIRa1cuZLmzZtjb2+Pvb09wcHB7Nixw/J8fn4+YWFhuLi4YGtrS2hoKLdv335gezqdjqlTp9KsWTNsbGyoVasWQ4cOJSEhwbKPRqPh9ddfx97enoCAAP74449CbXz00UdMmDCh4l+sUKHKPNK9Y8cOJk6cyLhx4/D396+Qkxdk6+3atWuh7WvWrGHYsGEALFmyBKlUSmhoKBqNhpCQED799NMKOX9FMubloU9KAkBVv14pe1dvBaPcDdt7orR66BUIT6w/H1Cf+0ECPe34JaxTZXZJKCe9VktWyh00ubkASKQS1Lb2WDs4Iq/hS0OEp09lXJ8FQRCEourUqcOCBQvw9/fHZDKxbt06XnjhBU6ePEmTJk2YPHky27Zt48cff8TBwYHx48fz0ksv8eeffxbbXm5uLidOnGDWrFkEBQWRlpbGW2+9xYABAzh+/DgAX3zxBZGRkURERLBjxw5eeeUVbt++jUQi4erVq6xatcqyr1B9lTmiOnToEKtXr6Z169Y0atSI119/ncGDBz/SyctSosbKyooVK1ZU+/Vo2rsJ26QODsjuy7Zek2Sl5hN3+m5m7mqUQO2nyBtEXktlRt9G2Fk9Wl3kR6E3GIm4Yk6iVtJ6bqF6MhqN5KSlkpuRjslkQiKRYO3giI2jE1KZmIUg1EyVcX0WBEEQiurfv3+hn+fNm8fKlSs5fPgwderUYfXq1WzYsIHu3bsD5oHERo0acfjw4WJn6To4OLB79+5C25YvX067du2Ij4/Hx8eHCxcuMGDAAJo0aUL9+vV55513SE5Oxs3NjXHjxvHhhx9ib29feS9aqBBlnjfZoUMHVq1axa1bt3jzzTfZuHEjtWrVwmg0snv3brKysiqzn9WeLj4eAKW3dxX35NGcO3gTkwlqBzjiXMumqrsDgNFoYs6Wc3x39Doj1x4nT2uosr6cuZlBVr4eB7WCJrVEgrmawmQykZ+dRcr1a+Skp2EymVBZW+NSxwc7F1cRcAs1mrg+C4IgPH4Gg4GNGzeSk5NDcHAwkZGR6HQ6evbsadmnYcOG+Pj4EBERUeZ2MzIykEgkliTSQUFBHDp0iLy8PHbu3ImXlxeurq6sX78eKysrBg4cWNEvTagE5V6saGNjw4gRIzh06BBnzpzh7bffZsGCBbi7uzNgwIDK6GONoL12N+j28aninjw8g97I+UPmNSTVaZT7akoOWfl6AI7GpTL220i0emOV9KVgannHBi7IRBbyGkGn1ZB26ybptxMx6PXmWtueXjh61hJTyYUnirg+C4IgVL4zZ85ga2uLSqVi7NixbN68mcaNG5OYmIhSqSxUcQnAw8ODxMTEMrWdn5/P1KlTGTJkiGX0esSIEQQFBdG4cWPmzZvHDz/8QFpaGu+//z7Lli3jvffew8/Pj5CQEG7evFnRL1eoII+UISgwMJCFCxdy48YNvvvuu4rqU42kvW4OuhV1a27QHXsyibwsHTYOSuq1qD5Tp09dTwegtqMatULG/ot3eGvjSfSGxx94HyoIusXU8mpPp9GQkZRIyo14tHl5SCQSbJ2ccanjg5WNbbXIyt+1a1cmTZr0WM8ZFxeHRCIhKiqqwtsODw9HIpGQnp5e4W0L5SOuz4IgCJUjMDCQqKgojhw5wrhx43jjjTc4f/78I7er0+kYNGgQJpPJkvcKQKFQsGLFCq5evcqxY8fo3Lkzb7/9NhMnTuTkyZP88ssvnDp1ig4dOjBx4sRH7odQOSokLa9MJuPFF1/kt99+q4jmaqS/p5fX3KD77H7z3bHGz9RGJqs+GZtP38gAIKSJJ18MbY1SJmXH2USm/XwGo7H0vABlkZSZT65WX+I+uVo9J66lA2I9d3VlMpnQ5OSQmnCDlBvx5GVlgQlUNja4eNfF1tnlicpGXt2C3I4dO3Lr1i0cHKpm6cXPP/9Mr169cHFxKfHGQkREBN27d8fGxgZ7e3u6dOnywNrkNZ24PguCIFQspVKJn58frVu3Zv78+QQFBfHJJ5/g6emJVqstck2+ffs2np6eJbZZEHBfu3aN3bt3l7hGe9++fZw7d47x48cTHh5O3759sbGxYdCgQYSHh1fAKxQqw5Pz7bOKWaaX19CR7uQb2dy6nIFEKqFJ51pV3Z1Cou6OdAd5O/CMvxtLh7REJpXwU+QN/rP1fJkS8pUkJjGLrovCeebDfZy5G+AX51hcGlqDkdqOanxdrB/pnELFMplM5GVnkXIjnrTEBLR5eSABK1s7nGt74+RZC7mi6hLwPS2USiWenp5VNosgJyeHzp078+GHHz5wn4iICHr37k2vXr04evQox44dY/z48U/UzRhBEATh8TEajWg0Glq3bo1CoWDPnj2W52JiYoiPjyc4OPiBxxcE3JcuXeKPP/7AxcXlgfsWlCT7/PPPkclkGAwGdDqdpR2DoeryHgklE98yKoBJq0V36xZQc9d0nz9oHuWuH+SKjaOqinvzN63eyPmETACC6jgC0LupJ4v+0RyAtX/FsXjXxYdu32Qy8f6vZ8nVGkjJ0TL4iwj+ik0udt+/S4W5VIupyQJocnM4seM3slNTyE5NQa/VIpFKsXZwxNbLA6WzPXqZkVxd7mN7lPcmkF6vZ/z48Tg4OODq6sqsWbMsbXzzzTe0adMGOzs7PD09eeWVV0i6W5owLi6Obt26AeDk5IREIrGUWjQajSxcuBA/Pz9UKhU+Pj7Mmzev0HmvXLlCt27dsLa2JigoqMxJXq5du0b//v1xcnLCxsaGJk2asH37dqDoyHvXrl2RSCRFHnFxcQCkp6czatQo3NzcsLe3p3v37pw6dapc79+9Xn/9dd5///1CSWzuN3nyZCZOnMi0adNo0qQJgYGBDBo0CJWq+nzuCYIgCNXT9OnTOXDgAHFxcZw5c4bp06cTHh7Oq6++ioODAyNHjmTKlCns27ePyMhIhg8fTnBwcKHM5Q0bNmTz5s2AOVB++eWXOX78OOvXr8dgMJCYmEhiYiJarbbI+efOnUvfvn1p2bIlAJ06deLnn3/m9OnTLF++nE6dRIna6koUYa4A2ps3wWhEYm2NzLXmTTvWaw3EHL0NQJNnaldxbwqLScxCazDioFZQ957R5YEt65CtMTDrl7Ms33cZWys5Y59tUO72fzuVwJGrqajkUprXceBYXBrDvjrG0iEt6N3Uq9C+hy6Vrz63UHlMJhPRf+4n/OsvQSan1ZDhyOQK7JxdUNvbkW/Q0H5D+yrp25FXjmCtKPtMiHXr1jFy5EiOHj3K8ePHGTNmDD4+PowePRqdTsfcuXMJDAwkKSmJKVOmMGzYMLZv3463tzebNm0iNDSUmJgY7O3tUavVgPlLwapVq1iyZAmdO3fm1q1bREdHFzrvzJkzWbRoEf7+/sycOZMhQ4Zw+fJl5PKSLwthYWFotVoOHDiAjY0N58+fx9bWtth9f/7550JfGsLCwjh37hweHh4A/OMf/0CtVrNjxw4cHBz4/PPP6dGjBxcvXsTZ2ZmDBw/Sp0+fEvvz+eef8+qrr5b6PgMkJSVx5MgRXn31VTp27EhsbCwNGzZk3rx5dO7cuUxtCIIgCE+vpKQkhg4dallK1bx5c3bu3Mlzzz0HwJIlS5BKpYSGhqLRaAgJCeHTTz8t1EZMTAwZGeaZlTdv3rQs/2nRokWh/fbt20fXrl0tP589e5Yffvih0NKpl19+mfDwcJ555hkCAwPZsGFDxb9ooUKIoLsC3FsurCaOgMaeSEKbp8fO2Yo6DZ2qujuFRN1IByDI27HIe/t6h7rkaPQs2BHNgh3R2KjkvN6hbpnbzsrXMW/bBQDGd/NjdJf6TNoYxe/nEvm/9SeYN7AZQ9qZZy6kZGs4f8s84t6xgQi6q1Jqwg32rF5J/FnziKhnYGPU9vY4edWyBJ3UoNlV3t7eLFmyBIlEQmBgIGfOnGHJkiWMHj2aESNGWParX78+S5cupW3btmRnZ2Nra4uzszMA7u7ulmypWVlZfPLJJyxfvpw33ngDgAYNGhQJKv/1r3/Rr18/AObMmUOTJk24fPkyDRs2LLG/8fHxhIaG0qxZM0u/HqSgf2D+IrJ3716OHDmCWq3m0KFDHD16lKSkJMso86JFi/jll1/46aefGDNmDG3atCk14VtBAF8WV65cAWD27NksWrSIFi1a8PXXX9OjRw/Onj2Lv79/mdsSBEEQnj6rV68u8XkrKytWrFjBihUrHrjPvTPifH19yzxDrmnTply6dKnQNqlUyqeffloksBeqHxF0VwBt/HUAlD41s0b3+T/NU+MbdfJCUs3KYBVkLm9Rp/jETGOfbUB2vp7l+y7z/q9n8bBT0atJyckqCizdc4mkLA11XawZ3aU+VgoZK15txczNZ9h47DrTfz5Dao6W/+vagIgrKQA09LTDzU5MQ60KOq2Go5t/4NhvmzDo9cgVStoPHETTXv24fuNGoZsyarmaI68cqZJ+quXqcu3foUOHQn0PDg5m8eLFGAwGoqKimD17NqdOnSItLQ2j0ZyxPz4+nsaNGxfb3oULF9BoNPTo0aPE8zZv3tzyZy8v86yOpKSkUoPuiRMnMm7cOHbt2kXPnj0JDQ0t1FZxduzYwbRp09iyZQsBAQEAnDp1iuzs7CJr1/Ly8oiNjQVArVbj5+dXYtvlUfD+vfnmmwwfPhyAli1bsmfPHr766ivmz59fYecSBEEQBEEoIILuCqC9O9KtqIHrudNv55JwKR2JBBp19Cr9gMfs9N2R7uZ313MX5+1eAaTlall/JJ63Nkbx49hgmtYuOXvypdtZrPkzDoDZ/ZtgpZABIJNKmP9SM5xtlHwaHstHO2NIzdGSfbdOuMhaXjWunDzG3q8+IyPJvAyiXovWdB8xDkcPT/Lz84vsL5FIyjXFuzrKz88nJCSEkJAQ1q9fj5ubG/Hx8YSEhBS7zquAZbS/FIp7EssVBP0FQWlJRo0aRUhICNu2bWPXrl3Mnz+fxYsXM2HChGL3P3/+PIMHD2bBggX06tXLsj07OxsvL69iM60WjNpX9PTygpsL99+waNSoEfF3P8cFQRAEwXfatqruQqWIW9Cvqrvw1BJBdwXQxl8DQOlT9qnN1cX5PxMA8Gnqgq2TVRX3prBsjZ5LSdkANPd+cBAtkUiYM6AJ8am5HLyUzKh1x/klrBOeDsW/HnPytHPojSZ6NvKgW0P3Iu2927shzjZKPth2gdWHrlIwENnJXwTdj1NOehp7Vq/k0tG/ALB1dqHbsDH4t+tYI5dyFOfIkcIj8ocPH8bf35/o6GhSUlJYsGAB3t7mWTTHjx8vtK9SqQQolK3U398ftVrNnj17GDVqVKX02dvbm7FjxzJ27FjL+vHigu7k5GT69+9PaGgokydPLvRcq1atSExMRC6X4+vrW+x5Knp6ua+vL7Vq1SImJqbQ9osXL5Ya3AuCIAiCIDwsEXRXAF0NnV5u0BuJjjBPLW/cqXqVCQM4cyMDkwlqO6pxtyv5hoBcJmXFq60I/fQvLiVlM+rrY/zwZjDWyqJ/xbecvkXElRRUcin/7l/8FF2AUc/Ux8laybubTmMwmpBLJbTzdX7g/kLFio08ys7PPiEvMwOJVEqrvi/Q8eUhKNU1ewT7fvHx8UyZMoU333yTEydOsGzZMhYvXoyPjw9KpZJly5YxduxYzp49y9y5cwsdW7duXSQSCVu3bqVv376o1WpsbW2ZOnUq7777Lkqlkk6dOnHnzh3OnTvHyJEjH7m/kyZNok+fPgQEBJCWlsa+ffto1KhRsfuGhoZibW3N7NmzSUxMtGx3c3OjZ8+eBAcH8+KLL7Jw4UICAgJISEhg27ZtDBw4kDZt2pR7enlqairx8fEkJJhvJhYE156enpZSZu+88w7//ve/CQoKokWLFqxbt47o6Gh++umnR3hXBEEQBEEQHkyUDHtEJoMB7Y0bQM0rFxZ3Jpm8LB1qeyV1mz24JmBVOWWZWl7yVPEC9lYKvhrWFmcbJWdvZjJpYxRGY+HkFNkaPfO2nQfg/7r64e1ccgAX2roOX7zeGluVnL7NvLBRiftUlU2nyeePLz/ll4X/IS8zA1cfX16b/zFdXx/5xAXcAEOHDiUvL4927doRFhbGW2+9xZgxY3Bzc2Pt2rX8+OOPNG7cmAULFrBo0aJCx9auXZs5c+Ywbdo0PDw8GD9+PACzZs3i7bff5v3336dRo0b885//tJQae1QGg4GwsDAaNWpE7969CQgIeGAClwMHDnD27Fnq1q2Ll5eX5XH9+nUkEgnbt2+nS5cuDB8+nICAAAYPHsy1a9fKNXp9r99++42WLVtaEsQNHjyYli1b8tlnn1n2mTRpEtOnT2fy5MkEBQWxZ88edu/eTYMG5a9+IDw55s+fT9u2bbGzs8Pd3Z0XX3yxyIyIAiaTiT59+iCRSPjll19KbLe4knkSiYSPPvoIAI1Gw+uvv469vT0BAQH88ccfhY7/6KOPHrh0QxAEoSqJz83yERHEI9InJoJOh0ShQO5ZtgRe1cX5Q3cTqAV7IZNVv/svp+/JXF5W3s7WfPF6a15ZdYRd52+zcGcM0/r8nRhq2Z5L3M7U4ONszZvPPjjr8r16NPIgclZPlNXwPXrS3L5yme3LFpGaYL6R1brfC3Qe/Abyu9OonzT3rmdeuXJlkeeHDBnCkCFDCm27P8vprFmzmDVrVqFtUqmUmTNnMnPmzCJtFpcp1dHRsczZU5ctW/bA57p27VqondLatLOzY+nSpSxdurRM5y7NsGHDLLXKSzJt2jSmTZtWIecUngz79+8nLCyMtm3botfrmTFjBr169eL8+fPY2NgU2vfjjz8u8/KWW7duFfp5x44djBw5ktDQUAC++OILIiMjiYiIYMeOHbzyyivcvn0biUTC1atXWbVqVZFlJYIgCNWB+NwsHxF0PyJLErU6dZDIZFXcm7LLSs0n/rw5I3d1TKAGcOq6uYZhUAlJ1IrTxteZhS83Z9L3UXy2P5b6bjYMauPN5aQsVh+6CsC/+ze2JE8rC5W85vxuayKj0cDxLZv58/tvMRr02Dg50/v/JuPbvGVVd00QhKfA77//XujntWvX4u7uTmRkJF26dLFsj4qKYvHixRw/ftySmK8knvfdjP/111/p1q2bpdTehQsXGDBgAE2aNKF+/fq88847JCcn4+bmxrhx4/jwww+xt7evgFcoCIJQscTnZvmIobtHpL12t0Z3DZtaHh1xC0xQO8ARR4/qN2X3TpaGm+l5SCTQrIzTy+/1YsvaTOxhrrk74+czRMSmWJKn9WjoTo9GDzd9Vah4mcl3+GnuexzcsBajQY9f22De+Gi5CLirSJ8+fbC1tS328d///requycIj0VGhvmm77215nNzc3nllVdYsWJFkS+FZXH79m22bdtWKLdCUFAQhw4dIi8vj507d+Ll5YWrqyvr16/HysqKgQMHPvqLEQRBeAzE52bJxEj3I9JevzvSXbfmBN1Go8mStbxRNUygBn9PLfdzs8X2IddRT+7pz9XkHLacSuCNNUfR6o0o5VL+3b9JBfZUeFgmk4lz4X8Q/s2XaHJyUKis6DZsDE27PffEZCavib788kvy8vKKfe7eC6kgPKmMRiOTJk2iU6dONG3a1LJ98uTJdOzYkRdeeOGh2l23bh12dna89NJLlm0jRozg9OnTNG7cGFdXV3744QfS0tJ4//33CQ8P57333mPjxo00aNCAr776itq1az/y6xMEQaho4nOzdCLofkS6u9PLld41J+i+cSGV7FQNKms5DVq5VXV3inXqejpQvvXc95NIJHz0cnNupOVyMt7c3rhnG+DjUv1G9p82GUmJ7PpiOfFnogDwbOBP3wn/wsmrenwwPs2qy8VJEKpKWFgYZ8+e5dChQ5Ztv/32G3v37uXkyZMP3e5XX33Fq6++ipXV39U4FAoFK1asKLTf8OHDmThxIidPnuSXX37h1KlTLFy4kIkTJ7Jp06aHPr8gCEJlEZ+bpRPTyx+RZXp5DRrpLhjlDmjvibwc65ofp6gbBeu5yz+1/F5WChlfvN4GP3dbmtSyZ1xXkaG4KhmNBiK3/craf4URfyYKuUJJl1eHM2TuIhFwC4JQ5caPH8/WrVvZt28fderUsWzfu3cvsbGxODo6IpfLkcvNYxahoaF07dq11HYPHjxITEwMo0aNKnG/ffv2ce7cOcaPH094eDh9+/bFxsaGQYMGFUq8KAiCUF2Iz82yESPdj8BkMqG9XlCju2YE3bmZWq6eSgaqZ21uML+vD5O5/EHc7FTsntxFTFmuYsnXr7Hrs6XcumwuJ1GncVN6jZkggm1BEKqcyWRiwoQJbN68mfDwcOrVq1fo+WnTphX54tesWTOWLFlC//79S21/9erVtG7dmqCgoAfuk5+fT1hYGOvXr0cmk2EwGCwVAHQ6HQaD4SFemSAIQuUQn5vlI4LuR6C/cwdTXh5IpShqVc8A9n4xhxMxGky417XDtY5tVXenWPGpuaTn6lDKpDT0rJjsgyLgrjoGvY4jm3/kyOYfMBr0KNXWPPvaCJp174VEKibbCIJQ9cLCwtiwYQO//vordnZ2JCYmAuDg4IBarcbT07PYJEA+Pj6Fvmg2bNiQ+fPnF0rkk5mZyY8//sjixYtL7MPcuXPp27cvLVuak0h26tSJd955h+HDh7N8+XI6depUES9VEAShQojPzfIRQfcjKFjPrahVC0kNqCNsMv2dQK1x5+p7kyDq7nruRrXsUcpFUFZTmYxGLh87zJ8/fEvKDfO/lfqt29Fz5P9h5+Jaxb0TBEH428qVKwGKTHlcs2ZNmWq/F4iJibFk8C2wceNGTCYTQ4YMeeBxZ8+e5YcffiAqKsqy7eWXXyY8PJxnnnmGwMBANmzYUOZ+CIIgVDbxuVk+Iuh+BNr4mjW1/FZsBum3c5GrZPi3rb4lswrqc7d4xPXcQtUwmUzERh7lrx/XcyfuCgBqewe6D3+TwOBnxKwDQRCqnYLpiI96THHbxowZw5gxY0psq2nTply6dKnQNqlUyqeffsqnn35a7r4JgiBUNvG5WT4i6H4E2vhrACh8vKu4J2Vz4ZB5lNu/tTtKq+r7q6/I9dzC42MymbgadZy/ftjA7SvmD0GlWk2rPgNo3W8gVrbVczlDVeratSstWrTg448/fmznjIuLo169epw8eZIWLVpUaNvh4eF069aNtLQ0HB0dK7RtQRAEQRCEmqpKI68DBw7w0UcfERkZya1bt9i8eTMvvvii5flhw4axbt26QseEhITw+++/P+aeFs9SLsynbhX3pHSaPD2XI5OA6j21XGcwcjbBPNLdvI5j1XZGKBOTycS10yf564f1liRpCpUVLfv0p83zA1HbVcy6fKGo6hbkduzYkVu3buHgUHWzVC5cuMDUqVPZv38/er2exo0bs2nTJnzum5FkMpno27cvv//+e5Frj/Dk8p22raq7UCniFvSr6i4IgvCEEp+bFaNKg+6cnByCgoIYMWJEoaLn9+rduzdr1qyx/KxSqR5X90plmV5eA8qFRWyORa8z4lzLBo961TcIung7i3ydETuVnPquNlXdHaEUWSnJ7FjxP66fOw2AXKmiRUg/2g4IxdpeLA942iiVymKTpjwusbGxdO7cmZEjRzJnzhzs7e05d+5cofqeBT7++GOx1EEQBEEQhMeiSrNU9enThw8++KBQtrr7qVQqS/Y7T09PnJycSmxTo9GQmZlZ6FEZTCYT2mt3p5d7V+/p5Zcjkzh34CYAnV/2r9ZfNE/frc/d3NsBqbT69lOAa6ej+GbqRK6fO41coaR1vxcYtexLnn1tRJUH3CaTCWNubpU8yrvGSa/XM378eBwcHHB1dWXWrFmWNr755hvatGmDnZ0dnp6evPLKKyQlmWesxMXF0a1bNwCcnJyQSCSWxCVGo5GFCxfi5+eHSqXCx8eHefPmFTrvlStX6NatG9bW1gQFBREREVGm/l67do3+/fvj5OSEjY0NTZo0Yfv27YB55F0ikZCeng6Yp89LJJIij7i4OADS09MZNWoUbm5u2Nvb0717d06dOlWu9+9eM2fOpG/fvixcuJCWLVvSoEEDBgwYgLu7e6H9oqKiWLx4MV999dVDn0sQBEEQBKGsqu/C3rvCw8Nxd3fHycmJ7t2788EHH+Di4vLA/efPn8+cOXMqvV+G9HSMWVkAKKtx0J2ZnMe+b6MBaBVSF+/GzlXco5Kdupu5PEhMLa+2TEYjRzb/wJ8/rgeTCTff+gyYPB1HT6+q7pqFKS+PmFatq+TcgScikVhbl3n/devWMXLkSI4ePcrx48cZM2YMPj4+jB49Gp1Ox9y5cwkMDCQpKYkpU6YwbNgwtm/fjre3N5s2bSI0NJSYmBjs7e1Rq9UATJ8+nVWrVrFkyRI6d+7MrVu3iI6OLnTemTNnsmjRIvz9/Zk5cyZDhgzh8uXLyOUlXxbCwsLQarUcOHAAGxsbzp8/j+0D1uv//PPPaLXaQseeO3cODw9zIsd//OMfqNVqduzYgYODA59//jk9evTg4sWLODs7c/DgQfr06VNifz7//HNeffVVjEYj27Zt49133yUkJISTJ09Sr149pk+fXmjqeG5uLq+88gorVqyo0lF5QRAEQRCeHtU66O7duzcvvfQS9erVIzY2lhkzZtCnTx8iIiKQyWTFHjN9+nSmTJli+TkzMxPvSgiKddfNU8vl7u5I737RrW4MBiO7vzqHNk+PRz172g2oV/pBVaygXJhYz1095WVnsWP5Yq6ePA5A02696D7iTRTK6rPso6bx9vZmyZIlSCQSAgMDOXPmDEuWLGH06NGMGDHCsl/9+vVZunQpbdu2JTs7G1tbW5ydzTfR3N3dLWu6s7Ky+OSTT1i+fDlvvPEGAA0aNKBz586Fzvuvf/2Lfv3M65nmzJlDkyZNuHz5Mg0bNiyxv/Hx8YSGhtKsWTNLvx6koH8AS5YsYe/evRw5cgS1Ws2hQ4c4evQoSUlJlmVDixYt4pdffuGnn35izJgxtGnTplApkOIUBPBJSUlkZ2ezYMECPvjgAz788EN+//13XnrpJfbt28ezzz4LwOTJk+nYsSMvvPBCie0KgiAIgiBUlGoddA8ePNjy52bNmtG8eXMaNGhAeHg4PXr0KPYYlUr1WNZ9a68VJFGrvuu5j265SuKVTJRqOb1GNkEmq941r3O1ei7eNs8eaCEyl1c7ibGX2LJkPpl3kpArlPQYOY6m3Z6r6m4VS6JWE3gissrOXR4dOnQotOQjODiYxYsXYzAYiIqKYvbs2Zw6dYq0tDSMRiNgDnwbN25cbHsXLlxAo9E88DOyQPPmzS1/9vIyz1JISkoqNeieOHEi48aNY9euXfTs2ZPQ0NBCbRVnx44dTJs2jS1bthAQEADAqVOnyM7OLjJzKS8vj9jYWADUajV+fn4ltl2g4L154YUXmDx5MgAtWrTgr7/+4rPPPuPZZ5/lt99+Y+/evZw8ebJMbQqCIAiCIFSEah10369+/fq4urpy+fLlUr9QVjbtdXPQraimSdSuX0jlxE7zmvNurzXE3rV6jsbf61xCJkYTeNir8HQomvhIqBomk4nTf/zOvrWfY9DrcfTwov+U6bj7PniEs6pJJJJyTfGujvLz8wkJCSEkJIT169fj5uZGfHw8ISEhhaZs309dxqBfoVBY/lwQ9BcEriUZNWoUISEhbNu2jV27djF//nwWL17MhAkTit3//PnzDB48mAULFtCrVy/L9uzsbLy8vAgPDy9yTMGofXmml7u6uiKXy4vcjGjUqBGHDh0CYO/evcTGxhbJ9B4aGsozzzxTbF8EQRAEQRAeVY0Kum/cuEFKSoplVKYq6QpGur2rX9Cdm6nljzXnwQSNn6mFX2v30g+qBk6JqeXVikGvJ+7UCU7v+Z0rkUcB8GvbgZBxk7CyETW3K8qRI0cK/Xz48GH8/f2Jjo4mJSWFBQsWWJbIHD9+vNC+SqUSAIPBYNnm7++PWq1mz549jBo1qlL67O3tzdixYxk7dqxl/XhxQXdycjL9+/cnNDTUMvpcoFWrViQmJiKXy/H19S32POWZXq5UKmnbti0xMTGFnr948SJ165rLOk6bNq3Ie9KsWTOWLFlC//79SzyPIAiCIAjCw6rSoDs7O5vLly9bfr569SpRUVE4Ozvj7OzMnDlzCA0NxdPTk9jYWN599138/PwICQmpwl6baQtqdFezkW6T0cSetefJzdTiXMuGzv/wr+oulVnBem4xtbzqmEwmbl2K5sKhcGL+Okheljn7v0Qq5Zkhb9Cm/0vVOvt9TRQfH8+UKVN48803OXHiBMuWLWPx4sX4+PigVCpZtmwZY8eO5ezZs8ydO7fQsXXr1kUikbB161b69u2LWq3G1taWqVOn8u6776JUKunUqRN37tzh3LlzjBw58pH7O2nSJPr06UNAQABpaWns27ePRo0aFbtvaGgo1tbWzJ49m8TERMt2Nzc3evbsSXBwMC+++CILFy4kICCAhIQEtm3bxsCBA2nTpk25ppcDvPPOO/zzn/+kS5cudOvWjd9//50tW7ZYRrALqmDcz8fHh3r1qn/OC0EQBEEQaqYqDbqPHz9uKXkDWBKgvfHGG6xcuZLTp0+zbt060tPTqVWrFr169WLu3LnVola39m4iNUU1W9N98o944s+nIlNI6TWqCQpl8QnnqqOCcmEic/njl5pwkwuHwok+FE767VuW7dYOjjTs9CxNuz2Hm49v1XXwCTZ06FDy8vJo164dMpmMt956izFjxiCRSFi7di0zZsxg6dKltGrVikWLFjFgwADLsbVr12bOnDlMmzaN4cOHM3ToUNauXcusWbOQy+W8//77JCQk4OXlxdixYyukvwaDgbCwMG7cuIG9vT29e/dmyZIlxe574MABAMtIc4GrV6/i6+vL9u3bmTlzJsOHD+fOnTt4enrSpUsXy+h1eQ0cOJDPPvuM+fPnM3HiRAIDA9m0aVORJHJCxZg/fz4///wz0dHRqNVqOnbsyIcffkhgYKBln/z8fN5++202btyIRqMhJCSETz/99KF/x4IgCIJQE0lM5S0qW8NkZmbi4OBARkYG9vb2FdKmITuHi23aABBw7CgyO7sKafdR3b6ayc8fRWI0muj6aiBNnqld1V0qs9QcLa3m7gbg1L974aBWlHKE8ChMJhMp169x+dhhLh2LIOlqrOU5hcoK/3bBNHqmGz5Ng5A+oFJAdZGfn8/Vq1epV68eVlYiF4BQPZX097QyrlOPQ+/evRk8eDBt27ZFr9czY8YMzp49y/nz57GxsQFg3LhxbNu2jbVr1+Lg4MD48eORSqX8+eefZTpHRb83vtO2PXIb1VHcgn7lPuZJfC8e5n0A8V7cS7wXZk/i+wDivbjXw/4buV9Zr1M1ak13daG7m0RN5uRUbQJubZ6eXavPYjSaaNDKncada1V1l8rl1I10AOq72oiAu5KYjEYSLsVw+VgEl49FkJ7494i2RCrFN6gVjTp3xa9NBxQieBUEoRS///57oZ/Xrl2Lu7s7kZGRdOnShYyMDFavXs2GDRvo3r07AGvWrKFRo0YcPnyYDh06FGlTo9Gg0WgsP2dmZlbuixAEQRCEx0AE3Q9BG2+eWl6dyoX99fNlMpPzsXO2ottrgTVu3W1BErUgsZ67QplMJm7GnOfCgX1cPn6Y3Ix0y3MyhYK6zVrg1y6YBq3bY23vUHUdFaqNPn36cPDgwWKfmzFjBjNmzHjMPRJqiowM8xKhgvrskZGR6HQ6evbsadmnYcOG+Pj4EBERUWzQPX/+fObMmfN4OiwIgiAIj4kIuh+CNt5ciqu6rOe+EZ3KuYMJAHQf2hCVdc0aKc7K17H7/G0AmtcRgV9FMOh1xEQc4sT2X7l95e9khSprG+q3aotf2w74tmiN0qr6l5ITHq8vv/ySvLy8Yp8rCKYE4X5Go5FJkybRqVMnmjZtCkBiYiJKpbJIiTYPD49CifXuNX36dEt+FzCPdBdk7xcEQRCEmkoE3Q9BV5C5vBoE3TqNgX3fRgNw3VnKN1duM71hzflifCsjj+FrjhGdmIVaIaNHQ5Fc51HkZmZwevcOonZtIyc9DQC5QknDzs8SGPwM3k2aIZPXrJsywuNVu3bNyQUhVB9hYWGcPXvWUhP9YalUqmqRLFUQBEEQKpIIuh+CZXp5NSgXdvjXWDKT8zGpZfxsyEZ74Ar/aFMHP/fqsda8JOcSMhix9hi3MzW42qpY/UYbfFysq7pbNdKda1c5seM3LhwKx6DTAWDr5EyLkOdp1iNETB0XBKHSjB8/nq1bt3LgwAHq1Klj2e7p6YlWqyU9Pb3QaPft27eLLd0mCIIgCE8qEXQ/hIIa3YoqnvJ263I6p/fdAGC3jRat3rz98/1X+OgfQVXYs9Lti0li/PoT5GgN+LnbsmZYW7ydRcBdXrcuxRDx0wauRkVatnk28KdV3xcI6NBJjGoLglBpTCYTEyZMYPPmzYSHhxepdd66dWsUCgV79uwhNDQUgJiYGOLj4wkODq6KLguCIAhClRBBdzkZNRr0d9eiKe+rPfs46bUG9n4TDSaw8rfj1J0k7FRysjR6fom6yZReAXg5VM/1uuuPXOP9X89hMJro2MCFla+1FhnLyynh4gUifvqOuFMnAHP2cf92HWnd7wW8/BvWuER6giDUPGFhYWzYsIFff/0VOzs7yzptBwcH1Go1Dg4OjBw5kilTpuDs7Iy9vT0TJkwgODi42CRqgiAIgvCkEkF3Oelu3ACTCamtLTInpyrrx9GtV0m/nYu1g5LNEnPSo7DufuyNTuLo1VRWH7zKe883rrL+FcdoNPHhzmg+338FgNBWdZj/UjOUcmkV96zmSLh4gb9+3MC10ycBc7Dd5NketH9xEI6eXlXcO0EQniYrV64EoGvXroW2r1mzhmHDhgGwZMkSpFIpoaGhaDQaQkJC+PTTTx9zTwVBEAShaomgu5y01+5OLffxrrLRxNtxmUTtNvfDs3stTu+7gFohY3BbbwI97Th6NZXvjsYzobs/DtUkk3m+zsDbP5xi2xlzbegpzwUwobufGJEto5sxF4j4qZhge+A/cfQQayMFQXj8TCZTqftYWVmxYsUKVqxY8Rh6JAiCIAjVkwi6y6mgXJjSp2qmlht0RvZ+fQGTCfzbevBDYioAoa1r42itpGuAGw097YhOzOKbw3GM7+5fJf28V57WwIi1x4i4koJCJuHD0Oa81KpO6Qc+5UxGI7EnjhG5bTM3zp8FCoLtnrQfOEgE20+Arl270qJFCz7++OPHds64uDjq1avHyZMnadGiRYW2HR4eTrdu3UhLSytSJkoQBEEQBOFpJeb1lpOuIHN5FSVRO/57HKkJOajtFPj2rM2eaHN96+GdzAlsJBIJ47o2AGDNn3Hk6wxV0s8C+ToDo78+TsSVFGyUMtaNaCcC7lLo8vOJ2rmNNVPG8utHc7lx/ixSmYym3Xox4uMvCBk7UQTcAmAOciUSCenp6VXdFQA6duzIrVu3cHB4/NnydTodU6dOpVmzZtjY2FCrVi2GDh1KQkJCof18fX2RSCSFHgsWLCi0j8lkYtGiRQQEBKBSqahduzbz5s17nC9HEARBEIQniBjpLqeCzOVVUS4s+UYWJ3aYR9qf+WcA60/dxGSCboFuNHCztezXr5kXH+2M4UZaHj8ev87rwb6Pva/wd8B96HIy1ncD7ja+NaeG+OOWnZpC1K5tnNq9g/zsLABU1jY079mblr37Y+fiWsU9FISSKZXKKisFlZuby4kTJ5g1axZBQUGkpaXx1ltvMWDAAI4fP15o3//85z+MHj3a8rOdXeESi2+99Ra7du1i0aJFNGvWjNTUVFJTUx/L6xAEQRAE4ckjRrrLSXu9YE334w26DXoje7+Oxmg0Ub+lG+5NnPjxuHnUfUTnwmVa5DIpY7rUB+DzA1fQG4yPta8AGr2Bsd9GcvBSMmqFjDXD2oqAuxgmk4mEixfYseJ/rBo/kiObfyA/OwsHD0+6DXuTMSvX0uXV4SLgLieTyYROY6iSR1nWud5Lr9czfvx4HBwccHV1ZdasWZY2vvnmG9q0aYOdnR2enp688sorJCUlAeZp4t26dQPAyckJiURiSV5lNBpZuHAhfn5+qFQqfHx8iozUXrlyhW7dumFtbU1QUBARERFl6u+1a9fo378/Tk5O2NjY0KRJE7Zv3w4UHXnv2rVrkVFliURCXFwcAOnp6YwaNQo3Nzfs7e3p3r07p06dKtf7V8DBwYHdu3czaNAgAgMD6dChA8uXLycyMpL4uzdLCxS8nwUPGxsby3MXLlxg5cqV/PrrrwwYMIB69erRunVrnnvuuYfqlyAIgiAIghjpLgeTTofupnmqovIhgm6TyYTRBDJp+ZOHHfn1Cnfis1BZy+kyOIDvjt8gR2vA392Wzn5FA7J/tPbm4z8ucSMtj21nbvFCi9rlPufD0uqN/N+3JwiPuYOVQspXw9rSvr7LYzt/TZCbkc75A3s5s283qTevW7bXbtiY1v1epEGb9kilsirsYc2m1xr54q39VXLuMZ88i0JV9t/dunXrGDlyJEePHuX48eOMGTMGHx8fRo8ejU6nY+7cuQQGBpKUlMSUKVMYNmwY27dvx9vbm02bNhEaGkpMTAz29vao1eYygdOnT2fVqlUsWbKEzp07c+vWLaKjowudd+bMmSxatAh/f39mzpzJkCFDuHz5MnJ5yZeFsLAwtFotBw4cwMbGhvPnz2Nra1vsvj///DNarbbQsefOncPDwwOAf/zjH6jVanbs2IGDgwOff/45PXr04OLFizg7O3Pw4EH69OlTYn8+//xzXn311WKfy8jIQCKRFFlfvmDBAubOnYuPjw+vvPIKkydPtrzuLVu2UL9+fbZu3Urv3r0xmUz07NmThQsX4uwsbhwKgiAIglB+IuguB92tW6DXI1GpkLu7l/v4V788wrWUXH4d3wlXW1WZj7t2NoWTd7OVd3u9IVZ2Stb+FQeYR7mLywCuVsoY3tGXxbsv8tn+KwwIqvVYMoVr9UbCNpxgT3QSKrmU1W+0JbiBCLgBjAYDV6MiObtvN1dOHMVoMK+3lytVBLTvSIvez+PlF1jFvRQeN29vb5YsWYJEIiEwMJAzZ86wZMkSRo8ezYgRIyz71a9fn6VLl9K2bVuys7OxtbW1BIHu7u6WwDIrK4tPPvmE5cuX88YbbwDQoEEDOnfuXOi8//rXv+jXrx8Ac+bMoUmTJly+fJmGDRuW2N/4+HhCQ0Np1qyZpV8Pcm+QumTJEvbu3cuRI0dQq9UcOnSIo0ePkpSUhEpl/jxctGgRv/zyCz/99BNjxoyhTZs2REVFldifggD+fvn5+UydOpUhQ4Zgb29v2T5x4kRatWqFs7Mzf/31F9OnT+fWrVv873//A8wzAK5du8aPP/7I119/jcFgYPLkybz88svs3bu3xL4IgiAIgiAURwTd5aAtSKLm441EWr6Z+XHJOfwVmwLA/3Zf5L8Dm5XpuJx0DX+sPQ9As2dr06ClO7+fTeRGWh5O1goGtnzwCPbQYF8+2x/LhVuZ7L94h66B5b9RUB46g5GJ351k9/nbKOVSvnyjDZ2KGYV/2uSkp3Fix2+c27+HnLS/14V6+gXQrFsvAjs+g8rapoQWhPKSK6WM+eTZKjt3eXTo0KHQDbHg4GAWL16MwWAgKiqK2bNnc+rUKdLS0jAazUtF4uPjady4cbHtXbhwAY1GQ48ePUo8b/PmzS1/9vIy13hPSkoqNeieOHEi48aNY9euXfTs2ZPQ0NBCbRVnx44dTJs2jS1bthAQEADAqVOnyM7OxsWl8E25vLw8YmNjAVCr1fj5+ZXYdnF0Oh2DBg3CZDJZakkXmDJliuXPzZs3R6lU8uabbzJ//nxUKhVGoxGNRsPXX39t6evq1atp3bo1MTExBAaKG2OCIAiCIJSPCLrLoaBcmMK7/FPL91+8Y/nzxqPxvN6hLo287Es4AoxGE7vXnCM/W4erty0dXzZ/+fzqz6sAvNq+LlaKB09jdbBWMKSdD18eusrK8NhKDbr1BiOTNkbx+7lElDIpX7zemmf83SrtfDVBbkY6R3/bxKld29FrNQCo7exp3KUbTbs+h6uPb9V28AkmkUjKNcW7OsrPzyckJISQkBDWr1+Pm5sb8fHxhISEFJqyfb+CKealUSgUlj8XBP0FQX1JRo0aRUhICNu2bWPXrl3Mnz+fxYsXM2HChGL3P3/+PIMHD2bBggX06tXLsj07OxsvLy/Cw8OLHFMwav8w08sLAu5r166xd+/eQqPcxWnfvj16vZ64uDgCAwPx8vJCLpdbAm6ARo0aAeabHSLoFgRBEAShvETQXQ66a3czlz/Eeu4Dd4NuG6WMHK2BD7ad59uR7Uuc8h25I46bMenIVTJCRjVFrpBx9mYGR6+mIpdKeD249FrhI5+px7qIOI5cTeVEfBqtfJzK3feSJGXm8/2x62w8dp2b6XkoZBI+e71VpY+qV2e5mRkc37qZk79vQa8xB9te/oG0eX4gDdq0RyZXlNKC8DQ5cuRIoZ8PHz6Mv78/0dHRpKSksGDBArzvlii8Pwu3UqkEwGD4uzSgv78/arWaPXv2MGrUqErps7e3N2PHjmXs2LGW9ePFBd3Jycn079+f0NBQJk+eXOi5Vq1akZiYiFwux9fXt9jzlHd6eUHAfenSJfbt21dkFL04UVFRSKVS3O8uGerUqRN6vZ7Y2FgaNDCXX7x48SIAdeuW/pkrCIIgCIJwPxF0l4P2+t3p5eUsF6bVG4m4Yp5avnhQCyZuPMmfl1PYcyGJno2LX49482Iax7aaR7S7DgnA0cMa+HuU+/nmXnjYW5V6bi8HNS+2qM2PkTf4LDyWL4a2KVffi2M0mjh4OZkNR67xx4UkDEZzpmUHtYL/DQqie8PiX9OTLi87i8itmzmxYwu6/DwAPBv403HQa/gGtXosa+qFmic+Pp4pU6bw5ptvcuLECZYtW8bixYvx8fFBqVSybNkyxo4dy9mzZ5k7d26hY+vWrYtEImHr1q307dsXtVqNra0tU6dO5d1330WpVNKpUyfu3LnDuXPnGDly5CP3d9KkSfTp04eAgADS0tLYt2+fZST4fqGhoVhbWzN79mwSExMt293c3OjZsyfBwcG8+OKLLFy4kICAABISEti2bRsDBw6kTZs25ZpertPpePnllzlx4gRbt27FYDBYzuns7IxSqSQiIoIjR47QrVs37OzsiIiIYPLkybz22ms4OZlvSPbs2ZNWrVoxYsQIPv74Y4xGI2FhYTz33HOFRr8FQRAEQRDKSgTd5fCw08uPX0slV2vA1VZFr8YejOxcj5XhsczbfoEuAW4o5YXXgOZla9n91XlMJmjYwZPADnfXW2bms+WUOXv6/WXCSvLms/X56cQNdp2/zeWkLPzc7Uo/qBh3sjT8cPw6G4/Fcz01z7K9dV0nXmnnQ7/mXiVOd39SZaUmc/qP3zmx/Ve0eeb3xd23AR0HvUr9Vm1FsC2UaOjQoeTl5dGuXTtkMhlvvfUWY8aMQSKRsHbtWmbMmMHSpUtp1aoVixYtYsCAAZZja9euzZw5c5g2bRrDhw9n6NChrF27llmzZiGXy3n//fdJSEjAy8uLsWPHVkh/DQYDYWFh3LhxA3t7e3r37s2SJUuK3ffAgQNA0RHiq1ev4uvry/bt25k5cybDhw/nzp07eHp60qVLlwcmRyvJzZs3+e233wBo0aJFoef27dtH165dUalUbNy4kdmzZ6PRaKhXrx6TJ08utM5bKpWyZcsWJkyYQJcuXbCxsaFPnz4sXry43H0SBEEQBEEAEXSXi+/Gjeji41H4lG+K4YGLyQB08XdFKpXwf10b8OPxG1xNzuHriDhGPfN39l+TycTedRfISdfg6GHNM4P/Hln59vA1dAYTbeo60byOY5nP7+dux3ONPNh1/jaf77/CR/8IKlf/AcJjkhjzdSTauzW/7azkvNSyNkPa+9DQs+Q1k08ig15HbORRzu7dRdypk5hM5vfFzceX4EGv4temgwi2hVLdu575/oRfAEOGDGHIkCGFtt1fB3zWrFnMmjWr0DapVMrMmTOZOXNmkTZ9fX2LtOHo6Fjm+uLLli174HNdu3Yt1E5pbdrZ2bF06VKWLl1apnOXpLjXdb9WrVpx+PDhUtuqVasWmzZteuQ+CYIgCIIggAi6y0Vma4vsARmDS1KQRK1LgDmxmJ2VgndCApi66QxL91zipVZ1cLYxr808tec6cWdSkMmlhIxugtLK/Cu6mZ7Ht0fMa8rLM8pdYFzXBuw6f5vNJ28y+bkAajmWLdkSmKeT/3f7BbQGI01r2zM02Jf+zWuhVj59o9rJ8XGcDd/N+QP7yMvKtGyv3bAJrfr0x79dx3JnthcEQRAEQRAE4cklgu5KlpSVz4Vb5uCss//f5bNebu3Nur+ucf5WJh//cZH/vNCUpGuZRGw2l8rp9LIfrnXM08Cjrqczat1xUnO01He1odcD1oGXpKWPE8H1XYi4ksKqg1f4d/8mZT72jwu3uXg7GzuVnA2jO2Bv9XQkAjMZjWSnpZJ26ybJ8XFc+HM/iZcvWp63cXKmSZfuNOn6HM61Hly6TRBqkj59+nDw4MFin5sxYwYzZsx4zD0SBEEQBEGo2ao06D5w4AAfffQRkZGR3Lp1i82bN/Piiy9anjeZTPz73/9m1apVpKen06lTJ1auXIm/v3/VdbqcDt6dWt6stgOutirLdplUwnvPN+KVVUfY9td1OmTLuHUyGaPBRIOWbjR91hzEbTt9iyk/RKHRG2nkZc/qN9oglz3cSOr/dWtAxJUUvjsaz/hufrjc058HMZlMrAg33wh4PbjuExdwm0wmcjPSyUhKJD3xFqkJN0m7dfeRmGDJPl5AKpNRv1U7mnZ7jnotWiOVPX2j/cKT7csvvyQvL6/Y55ydnR9zbwRBEDAjLDcAACwtSURBVARBEGq+Kg26c3JyCAoKYsSIEbz00ktFnl+4cCFLly5l3bp11KtXj1mzZhESEsL58+exsio9c3d1cOBSwdRy10LbdRoDzkk6xhltsc00cPXgLQCcPK3p9npDAFbsu8xHO2MA6N7QnaVDWmKrevhfWWc/V5rXceD0jQzW/hXH271KrzcbEZvCqevpqOTSh5rWXh2YTCYykm6TfP0amUmJpCclkpF0m4zbiWTcuV0ksL6XRCrF0cMTR89a+DRpTqNnumHjWLFl1wShOqldW8zaEARBEARBqEhVGnT36dOHPn36FPucyWTi448/5r333uOFF14A4Ouvv8bDw4NffvmFwYMHP86uPhSj0cTBSwVJ1NwwmUzcjsvkwp+3uHT8Nrp8A7aAERNxciNdQnx5vk8D9Jj414+n2XTiBgAjOtVjZr9GyKSPlphLIjEncRv77QnW/hXHmC71sStl5PrTu6Pc/2zrXWikvrrLSU8j/uwpyyPzTtKDd5ZIsHN2xdHDE6datXHy+vvh4O6BTC5WYQiCIAiCIAiC8HCqbTRx9epVEhMT6dmzp2Wbg4MD7du3JyIi4oFBt0ajQXPPyGVmZmax+z0sk8lU5qzUZxMySM3RYquS00Ct4uePTpB4JcPyvL2rFY061mJ3Xjabjl0j6uJNgrt6M379SY7GpSKTSpgzoAmvdShftvSS9GrsSQM3G2Lv5LD+SDxjn23wwH1PXU/n0OVk5FIJY7rUf+B+Vc1oMJCbkc7tq5eJP2MOspOvXyu0j1Qmw9XbF0cPT+zdPXD08MTBzQMHD0/sXN2RK56safOCIAiCIAiCIFQP1TboTkxMBChSr9XDw8PyXHH+v707D4uqbP8A/h1mGPZ9R9kUUMDABSOUTMVXtMUl3rIkJTMRwzLRSjNzadG33M0lraA3+2mvlraYqeG+B4KouGEouLDJvsg2z+8PcnRilRiG5fu5rrmcOdvc5/YwZ+4553meRYsWYcGCBc0eT5VC4H+xafj62DV8N9kfJnoNF2mHLmcBAnja0AjfL45DZVkVpNpa6NrbCp797GHvZgqJlgTudyuwNek2rmYVY/CSgygqq4SRjgxrQnorezxvLlpaEkwZ6IqZW8/gi8MpeLmfc51ja689kAwAGNHTHp3N9Js1jsaoqqxEcV4OinLuVD9yc1Ccl4vi3FwU5/31PC8XJQX5QC1DBVk5d4FjDx849fBBJw8vyHUb32M7ERERERFRc2i1RXdTzZ49G5GRkcrXBQUFcHBwaJZtRx1NweWMImw89CdmBjXcHvpYUhZGlMjhcPUuKgHYu5liyARPGJmrtkc31tVG5L/c8d6Ocygqq0RnMz1EvdwXbjZGzRL3343saY/ley/jZl4ptsbdwLharqRfySjE7vMZkEiA1wbWfTW8ISUF+chOvY7stGsoyMqorTZWqiwv+6vAzkFR7p06i+naSCRaMLGxgaOXDxwf8YGDlzf0jU2aHDcREREREVFzaLVFt62tLQAgIyMDdnZ2yukZGRno2bNnnevp6OhAR6f52x5LtSSYMbQbJn8Th6+OpiC0nzOsjOp+n0uJmfA5XwpDIYVES4LHRnZBz385QquOdtkv9HXAH9dyUF6pwAejeqi1/bS2VAthA7pg3k/n8fnBq3ixr0ONHtHXHaxuyz3U0wau1vUX/0IIlBYWoOCvzsqy064hK/U67qRdR3Fe7j+KVUsqg6G5OQzMzGFoZg4D03v/mlU//nquZ2wMLS32JE5ERERERK1Lqy26XVxcYGtri5iYGGWRXVBQgJMnT2LKlCkaiWmopw16OpgiIS0Pa/YnY/6ImmNdV1UocOLHq0j4PQ2GkKBAG5g4sw+snYzr3bZMqoWVL/RSV+g1PO/rgFUxV3AjtxQ/J97C6F6dlfPSckrwY8ItAMBrA11RWV6OguxM5GdmoDA7C4V3slB4J/uBf++gsrzuHsBNrG1g6egMU1t7SOsZYktLpg1DM3MYmlvA0NwCRuYW0DMyhkSraUOkEbV2AwcORM+ePbFixYoWe89r167BxcUF8fHx9f6A2RQHDhzAoEGDkJubC1NT02bdNhEREVFbpdGiu6ioCMnJycrXKSkpSEhIgLm5ORwdHfHmm2/iww8/hJubm3LIMHt7e5WxvFuSRCLB20HdMPaLk/j25HVMDHCBg/n9ts7ZN4rwe3QS7twoAgAkyCvRaZB9gwW3JujJpXglwAWf/nYRG39PwgBrCUoLclGQlYnthxIxKCMNDrJSnPj4f/g9N6dRt3nrm5jC0sERFg5OsHRwhpWjMyw6O0Cu1/LtwYk6gtZW5Pbr1w+3b9+GiYlmmnb88MMPWL9+PeLi4pCTk1PrDwt3797FjBkzsGXLFpSVlSEoKAhr165V9h9y5swZLF68GEeOHEF2djacnZ0RHh6OadOm1fqeR48exRNPPIEePXogISFBzXtIREREbZFGi+7Y2FgMGjRI+fpeW+zQ0FBER0fj7bffRnFxMcLCwpCXl4eAgAD89ttvGh2ju5+rJQJcLXEkORsrfr+Cpc/74M7NIsT+eg3JpzMBAegaamO3QQVOlVXgK4/m7QjtYVRVVqIwO6t6TOrM6jGpi3NzUVKQh5L8fEjzcvFabi6k16oQHXt/PV0AHn89L/rrX20dXZhY28DI0grGllYwsrCCkYXlXw8rGFpYsgdwog5OLpcrmwZpQnFxMQICAvD8889j0qRJtS4zffp07Ny5E1u3boWJiQmmTp2KZ599FkePHgUAxMXFwdraGps2bYKDgwOOHTuGsLAwSKVSTJ06VWVbeXl5GD9+PAIDA5GRkaH2/SMiIqK2SaNF98CBAyHquYIqkUiwcOFCLFy4sAWjathbQd1wJDkbh2JvYluGAhnn77db7trbGk5D7PHBhuOQS7XwWBcLtccjhEDW9RSknk3AnZs3qgvsv24FF0JR77r3bvaulMphYWmBXC0DXCiUwcDSBq890xemNnYwsbGtvs27kUOlEWmaEAKVZXU3eVAnmY7OQ/2tVFZWYurUqfjmm2+gra2NKVOmYOHChZBIJPjmm2+wcuVKXLp0CQYGBhg8eDBWrFgBa2trXLt2TfmjpZmZGYD7P1gqFAosWbIEGzZsQFpaGmxsbDB58mTMmTNH+b5//vknpk+fjpMnT8LNzQ3r16+Hv79/g/Fev34dU6dOxZEjR1BeXg5nZ2d8+umnePLJJ2tceR84cCAOHjxYYxspKSlwdnZGXl4eZs6ciR9//BFlZWXw9fXF8uXL4ePj0+j8PWjcuHEAqm+hr01+fj6+/PJL/N///R8GDx4MAIiKioKHhwdOnDiBxx57DK+88orKOl26dMHx48fxww8/1Ci6w8PDMXbsWEilUuzYsaNJMRMREVH712rbdLdmnbVkmCQ1gmlepbLg7trbCn2fcoFFJ0NEHU0BAPg6m0Ffrp4UlxYW4HpiPK6dOY1rifEozs2pdTmZthzG1jYw+ethaGYBfVNT6BubQt/EBHdl+nhqQzxKFFKsf6kPVm49g0LdSmwc7wsPT5tat0nU2lWWlWFV6L818t5vfL0N2g9xN87XX3+NiRMn4tSpU4iNjUVYWBgcHR0xadIkVFRU4IMPPkC3bt2QmZmJyMhIvPzyy/j111/h4OCA77//HsHBwbh06RKMjY2hp1c9LN7s2bOxceNGLF++HAEBAbh9+zYuXryo8r5z5szBkiVL4Obmhjlz5uDFF19EcnIyZLL6P7MiIiJQXl6OQ4cOwcDAAElJSTA0NKx12R9++AHl5eUq654/f155K/dzzz0HPT097Nq1CyYmJvj8888RGBiIy5cvw9zcHIcPH8bw4cPrjefzzz9HSEhIg3kGqq9iV1RUYMiQIcpp3bt3h6OjI44fP47HHnus1vXy8/Nhbm6uMi0qKgp//vknNm3ahA8//LBR709EREQdE4vuh5B9owixO1NwNT4Lpn9Nu6hdiRdefgT9+9zvYf3Q5SwAwBPNMMZ2ZXk5SgryUVpYgNL8PNy8fBHXzsQh/eoVlXbWMh0dOHp5w7arO0xsbGFiZQMTG1sYmJg22BHZv/3y8d/j1zFtSzzKKhVwtzFEYHfrfxw7ETXMwcEBy5cvh0QiQbdu3XD27FksX74ckyZNUrnq2qVLF6xatQp9+/ZFUVERDA0NlYWgtbW1sk13YWEhVq5cic8++wyhoaEAgK5duyIgIEDlfWfOnImnnnoKALBgwQJ4eXkhOTkZ3bt3rzfe1NRUBAcH45FHHlHGVZcHC9Xly5dj3759OHnyJPT09HDkyBGcOnUKmZmZyhEnlixZgh07dmDbtm0ICwuDr69vg+2k7xXwjZGeng65XF6j/buNjQ3S09NrXefYsWP47rvvsHPnTuW0K1euYNasWTh8+HCDP1IQERER8dtCI1VVKfDzqgSUFJQDEsC1tzX2S8vw8+V05ManKovussoqnPiz+qrzgEYU3Q+OY52ddh2Fd7JReq/ILihARdndOte1dHSGs09vOPv0RqfuXk1uUx02oAv+72Qqyiqrb0V/baBrnUObEbUFMh0dvPH1No2998N47LHHVG5H9/f3x9KlS1FVVYWEhATMnz8fZ86cQW5uLhSK6r/R1NRUeHp61rq9CxcuoKysDIGBgfW+r7e3t/L5vWEZMzMzGyy633jjDUyZMgV79uzBkCFDEBwcrLKt2uzatQuzZs3Czz//DHd3dwDVHZYVFRXBwkK1CU5paSmuXq0eslBPTw+urq71bludzp07h5EjR2LevHkYOnQoAKCqqgpjx47FggULlPtCREREVB8W3Y0klWqhd5AT0lPy4fukMyzsDeGZU4Lvl2bgSHI2jiVno5+rJWKv5aK0ogrWRjrobnt/fOuykmLk3LyB7BvV41dnpV5Hduo1lOTnNfjeWlIZ9IyNoWdoBPPOjnDx6Q0nn14wMrdsln3rbKaPET3t8cPpm3Aw18PT3nYNr0TUikkkkoe6xbs1unv3LoKCghAUFIRvv/0WVlZWSE1NRVBQkMot23937xbzhmg/8CPdvaL/XlFfn1dffRVBQUHYuXMn9uzZg0WLFmHp0qV4/fXXa10+KSkJL7zwAhYvXqwsXIHq0Svs7Oxw4MCBGuvcuxLd3LeX29raory8HHl5eSpXuzMyMmp0AJeUlITAwECEhYXhvffeU04vLCxEbGws4uPjlW28FQoFhBCQyWTYs2ePsr04EREREcCi+6F4D+4MH4mD8rWDuT5C/JwQfewa/rP7ErZ3McfB+CtwKL2BQcYCMV9dQc7NNOTculFnm2sAMLGx/WuILSeY2NhB39gEekbG1Q9jY8j19NXeidk7w7qjvFKBED8nyKQcF5uopZw8eVLl9YkTJ+Dm5oaLFy/izp07WLx4MRwcqj93YmNjVZaVy+UAqq++3uPm5gY9PT3ExMTg1VdfVUvMDg4OCA8PR3h4uLL9eG1Fd3Z2Np555hkEBwdj+vTpKvN69+6N9PR0yGQyODs71/o+zX17eZ8+faCtrY2YmBgEBwcDAC5duoTU1FSVTuTOnz+PwYMHIzQ0FB999JHKNoyNjXH27FmVaWvXrsW+ffuwbds2uLi4NDoeIiIi6hhYdD+E2grfiEGu2H0sEbqJp/DZa19AJzcLowAgHTjzt2UNzMxh0akzLB2cYenoDEsHJ1g4OEKu27grU+pkY6yLz8b21nQYRB1OamoqIiMjMXnyZJw+fRqrV6/G0qVL4ejoCLlcjtWrVyM8PBznzp3DBx98oLKuk5MTJBIJfvnlFzz55JPQ09ODoaEh3nnnHbz99tuQy+Xo378/srKycP78eUycOPEfx/vmm29i+PDhcHd3R25uLvbv3w8PD49alw0ODoa+vj7mz5+v0mbaysoKQ4YMgb+/P0aNGoVPPvkE7u7uuHXrFnbu3InRo0fD19f3oW8vz8nJQWpqKm7dugWguqAGqq9w29rawsTEBBMnTkRkZCTMzc1hbGyM119/Hf7+/spO1M6dO4fBgwcjKCgIkZGRyrilUimsrKygpaWFHj16qLyvtbU1dHV1a0wnIiIiAlh0N1lxXi4uHTuEpMMH8O+UKwCACgAKSJCvbQKfHu6wdXSEeScHmNt3hpl9J+ga1N7DLxF1XOPHj0dpaSkeffRRSKVSTJs2DWFhYZBIJIiOjsa7776LVatWoXfv3liyZAlGjBihXLdTp05YsGABZs2ahQkTJmD8+PGIjo7G3LlzIZPJ8P777+PWrVuws7NDeHh4s8RbVVWFiIgI3LhxA8bGxhg2bBiWL19e67KHDh0CUP3jwIPuDRn266+/Ys6cOZgwYQKysrJga2uLAQMGPNTV6wf99NNPmDBhgvL1Cy+8AACYN28e5s+fD6C6QzctLS0EBwejrKwMQUFBWLt2rXKdbdu2ISsrC5s2bcKmTZuU052cnOocioyIiIioPhJR30DZ7UBBQQFMTEyQn58PY2Pjf7St8rulSP7jBC4cOYDrifEQf7V/lGhpIU3fEef0XJGi7wwvR0v8ODWgga0RUXO4e/cuUlJS4OLiAt023o6b2q/6jtPmPE+1N82dG+dZOxteqA26tviph16nPeaiKXkAmIsHMRfV2mMeAObiQU39G/m7xp6neKW7kYRCgejI11B4J0s5zc61GzweH4hu/o/j6/g72P5b9Ti4jem1nIiIiIiIiNo/Ft2NJNHSgkuvPkg9dwYeAQPhETAQZnadlPNf7meE6GMpyCgoQ6BH026NJCLStOHDh+Pw4cO1znv33Xfx7rvvtnBERERERG0bi+6HMHDcq5Dp6NTaoZqeXIqtk/shNacEPR1MWz44IqJm8MUXX6C0tLTWeebm5i0cDREREVHbx6L7ITQ07q+jhT4cLfRbKBoioubXqVOnhhciIiIiokbjgMxE1C608z4hqY3j8UlERNRxsegmojZNW1sbAFBSUqLhSIjqdu/4vHe8EhERUcfB28uJqE2TSqUwNTVFZmYmAEBfX7/WfheINEEIgZKSEmRmZsLU1BRSqVTTIREREVELY9FNRG2era0tACgLb6LWxtTUVHmcEhERUcfCopuI2jyJRAI7OztYW1ujoqJC0+EQqdDW1uYVbiIiog6MRTcRtRtSqZTFDRERERG1KuxIjYiIiNRmzZo1cHZ2hq6uLvz8/HDq1ClNh0RERNSiWHQTERGRWnz33XeIjIzEvHnzcPr0afj4+CAoKIj9LxARUYfCopuIiIjUYtmyZZg0aRImTJgAT09PrF+/Hvr6+vjqq680HRoREVGLafdtuoUQAICCggINR0JERFTTvfPTvfNVe1FeXo64uDjMnj1bOU1LSwtDhgzB8ePHa12nrKwMZWVlytf5+fkAmu8crigraZbttDZNyU97zEVTjxPm4j7molp7zAPAXDyouc4rjT2Ht/uiu7CwEADg4OCg4UiIiIjqVlhYCBMTE02H0Wyys7NRVVUFGxsblek2Nja4ePFiressWrQICxYsqDGd5/D6mazQdAStA/NwH3NxH3NxH3NxX3PnoqFzeLsvuu3t7ZGWlgYjIyNIJJJ/tK2CggI4ODggLS0NxsbGzRRhx8DcNR1z988wf03H3DXdw+ROCIHCwkLY29u3UHSt1+zZsxEZGal8rVAokJOTAwsLi398Dm9J/Nu5j7moxjzcx1zcx1zc11Zz0dhzeLsvurW0tNC5c+dm3aaxsXGbOhhaE+au6Zi7f4b5azrmrukam7v2dIX7HktLS0ilUmRkZKhMz8jIgK2tba3r6OjoQEdHR2WaqampukJUO/7t3MdcVGMe7mMu7mMu7muLuWjMOZwdqREREVGzk8vl6NOnD2JiYpTTFAoFYmJi4O/vr8HIiIiIWla7v9JNREREmhEZGYnQ0FD4+vri0UcfxYoVK1BcXIwJEyZoOjQiIqIWw6L7Iejo6GDevHk1bn2jhjF3Tcfc/TPMX9Mxd03H3FUbM2YMsrKy8P777yM9PR09e/bEb7/9VqNztfaG///3MRfVmIf7mIv7mIv72nsuJKK9jVFCRERERERE1EqwTTcRERERERGRmrDoJiIiIiIiIlITFt1EREREREREasKim4iIiIiIiEhNWHQ/hDVr1sDZ2Rm6urrw8/PDqVOnNB1Sq3Po0CE888wzsLe3h0QiwY4dO1TmCyHw/vvvw87ODnp6ehgyZAiuXLmimWBbmUWLFqFv374wMjKCtbU1Ro0ahUuXLqksc/fuXURERMDCwgKGhoYIDg5GRkaGhiJuPdatWwdvb28YGxvD2NgY/v7+2LVrl3I+89Z4ixcvhkQiwZtvvqmcxvzVbv78+ZBIJCqP7t27K+czbx1PQ+fAjqq2z5X2qjHHwIULFzBixAiYmJjAwMAAffv2RWpqassHq2Y3b97ESy+9BAsLC+jp6eGRRx5BbGxsrcuGh4dDIpFgxYoVLRukGjTm+9zAgQNrnD/Cw8NrbCs6Ohre3t7Q1dWFtbU1IiIiWmo3muSf1gHXrl3DxIkT4eLiAj09PXTt2hXz5s1DeXl5re+XnJwMIyMjmJqaqnGvmgeL7kb67rvvEBkZiXnz5uH06dPw8fFBUFAQMjMzNR1aq1JcXAwfHx+sWbOm1vmffPIJVq1ahfXr1+PkyZMwMDBAUFAQ7t6928KRtj4HDx5EREQETpw4gb1796KiogJDhw5FcXGxcpnp06fj559/xtatW3Hw4EHcunULzz77rAajbh06d+6MxYsXIy4uDrGxsRg8eDBGjhyJ8+fPA2DeGuuPP/7A559/Dm9vb5XpzF/dvLy8cPv2beXjyJEjynnMW8fT0DmwI6rrc6W9augYuHr1KgICAtC9e3ccOHAAiYmJmDt3LnR1dVs4UvXKzc1F//79oa2tjV27diEpKQlLly6FmZlZjWW3b9+OEydOwN7eXgORNr/GfJ8DgEmTJqmcPz755BOV+cuWLcOcOXMwa9YsnD9/Hr///juCgoJaclce2j+tAy5evAiFQoHPP/8c58+fx/Lly7F+/Xq8++67NbZVUVGBF198EY8//rha96nZCGqURx99VERERChfV1VVCXt7e7Fo0SINRtW6ARDbt29XvlYoFMLW1lZ8+umnyml5eXlCR0dHbN68WQMRtm6ZmZkCgDh48KAQojpX2traYuvWrcplLly4IACI48ePayrMVsvMzEx88cUXzFsjFRYWCjc3N7F3717xxBNPiGnTpgkheNzVZ968ecLHx6fWecwb/f0c2BHV9bnSUdR2DIwZM0a89NJLmgmoBb3zzjsiICCgweVu3LghOnXqJM6dOyecnJzE8uXL1R9cC/v79zkhRIN/Dzk5OUJPT0/8/vvvLRChejRXHfDJJ58IFxeXGtPffvtt8dJLL4moqChhYmLSnKGrBa90N0J5eTni4uIwZMgQ5TQtLS0MGTIEx48f12BkbUtKSgrS09NV8mhiYgI/Pz/msRb5+fkAAHNzcwBAXFwcKioqVPLXvXt3ODo6Mn8PqKqqwpYtW1BcXAx/f3/mrZEiIiLw1FNPqeQJ4HHXkCtXrsDe3h5dunRBSEiI8hZR5o2o7s+VjkqhUGDnzp1wd3dHUFAQrK2t4efn1y6bIfz000/w9fXFc889B2tra/Tq1QsbN25UWUahUGDcuHF466234OXlpaFI1e/v3+fu+fbbb2FpaYkePXpg9uzZKCkpUc7bu3cvFAoFbt68CQ8PD3Tu3BnPP/880tLSWjT25tTUOiA/P79G7vbt24etW7e2qbuKWHQ3QnZ2NqqqqmBjY6My3cbGBunp6RqKqu25lyvmsWEKhQJvvvkm+vfvjx49egCozp9cLq/RboX5q3b27FkYGhpCR0cH4eHh2L59Ozw9PZm3RtiyZQtOnz6NRYsW1ZjH/NXNz88P0dHR+O2337Bu3TqkpKTg8ccfR2FhIfNGHV59nysdVWZmJoqKirB48WIMGzYMe/bswejRo/Hss8/i4MGDmg6vWf35559Yt24d3NzcsHv3bkyZMgVvvPEGvv76a+Uy//nPfyCTyfDGG29oMFL1qu37HACMHTsWmzZtwv79+zF79mx88803eOmll5Tz//zzTygUCnz88cdYsWIFtm3bhpycHPzrX/+qs31za9eUOiA5ORmrV6/G5MmTldPu3LmDl19+GdHR0TA2NlZfwM1MpukAiKimiIgInDt3TqV9KNWvW7duSEhIQH5+PrZt24bQ0NB29yVGHdLS0jBt2jTs3bu33bUpVLfhw4crn3t7e8PPzw9OTk743//+Bz09PQ1GRqRZ/FypnUKhAACMHDkS06dPBwD07NkTx44dw/r16/HEE09oMrxmpVAo4Ovri48//hgA0KtXL5w7dw7r169HaGgo4uLisHLlSpw+fRoSiUTD0apPXd/nwsLClM8feeQR2NnZITAwEFevXkXXrl2hUChQUVGBVatWYejQoQCAzZs3w9bWFvv372/1bbubw82bNzFs2DA899xzmDRpknL6pEmTMHbsWAwYMECD0T08XuluBEtLS0il0hq9zmZkZMDW1lZDUbU993LFPNZv6tSp+OWXX7B//3507txZOd3W1hbl5eXIy8tTWZ75qyaXy+Hq6oo+ffpg0aJF8PHxwcqVK5m3BsTFxSEzMxO9e/eGTCaDTCbDwYMHsWrVKshkMtjY2DB/jWRqagp3d3ckJyfzuKMOraHPlaqqKk2HqBGWlpaQyWTw9PRUme7h4dHuei+3s7Ordz8PHz6MzMxMODo6Ko+R69evY8aMGXB2dtZAxM2vru9ztfHz8wNQfWUXqM4fAJUcWllZwdLSss0eKw9TB9y6dQuDBg1Cv379sGHDBpV5+/btw5IlS5THzcSJE5Gfnw+ZTIavvvpKvTvxD7DobgS5XI4+ffogJiZGOU2hUCAmJgb+/v4ajKxtcXFxga2trUoeCwoKcPLkSeYR1cMoTJ06Fdu3b8e+ffvg4uKiMr9Pnz7Q1tZWyd+lS5eQmprK/NVCoVCgrKyMeWtAYGAgzp49i4SEBOXD19cXISEhyufMX+MUFRXh6tWrsLOz43FHHVpDnytSqVTTIWqEXC5H3759awwfdfnyZTg5OWkoKvXo379/vfs5btw4JCYmqhwj9vb2eOutt7B7925NhNxsGvo+V5uEhAQA94vt/v37A4BKDnNycpCdnd1mj5XG1gE3b97EwIED0adPH0RFRUFLS7VcPX78uMpxs3DhQhgZGSEhIQGjR49usf15aJruya2t2LJli9DR0RHR0dEiKSlJhIWFCVNTU5Genq7p0FqVwsJCER8fL+Lj4wUAsWzZMhEfHy+uX78uhBBi8eLFwtTUVPz4448iMTFRjBw5Uri4uIjS0lINR655U6ZMESYmJuLAgQPi9u3bykdJSYlymfDwcOHo6Cj27dsnYmNjhb+/v/D399dg1K3DrFmzxMGDB0VKSopITEwUs2bNEhKJROzZs0cIwbw9rL/3qsr81W7GjBniwIEDIiUlRRw9elQMGTJEWFpaiszMTCEE89YRNXQO7Mg6Su/lDR0DP/zwg9DW1hYbNmwQV65cEatXrxZSqVQcPnxYw5E3r1OnTgmZTCY++ugjceXKFfHtt98KfX19sWnTpjrXaS+9lzf0fS45OVksXLhQxMbGipSUFPHjjz+KLl26iAEDBqhsZ+TIkcLLy0scPXpUnD17Vjz99NPC09NTlJeXa2K3GuWf1gE3btwQrq6uIjAwUNy4cUMlf3VpK72Xs+h+CKtXrxaOjo5CLpeLRx99VJw4cULTIbU6+/fvFwBqPEJDQ4UQ1cMFzJ07V9jY2AgdHR0RGBgoLl26pNmgW4na8gZAREVFKZcpLS0Vr732mjAzMxP6+vpi9OjR9X4QdRSvvPKKcHJyEnK5XFhZWYnAwEBlwS0E8/aw/v7lmPmr3ZgxY4SdnZ2Qy+WiU6dOYsyYMSI5OVk5n3nreBo6B3ZkHaXobswx8OWXXwpXV1ehq6srfHx8xI4dOzQXsBr9/PPPokePHkJHR0d0795dbNiwod7l20vR3dD3udTUVDFgwABhbm4udHR0hKurq3jrrbdEfn6+ynby8/PFK6+8IkxNTYW5ubkYPXq0SE1N1cAeNd4/rQOioqLqzF9d2krRLRFCCHVdRSciIiIiIiLqyNimm4iIiIiIiEhNWHQTERERERERqQmLbiIiIiIiIiI1YdFNREREREREpCYsuomIiIiIiIjUhEU3ERERERERkZqw6CYiIiIiIiJSExbdRERERERERGrCopuIWoREIsGOHTs0HQYREVGHEh0dDVNT02bb3rVr1yCRSJCQkNBs2yRq71h0E3UAL7/8MiQSSY3HsGHDNB0aERFRu/f387CFhQWGDRuGxMTEh9rO/Pnz0bNnT/UE2UgODg64ffs2evToodE4iNoSFt1EHcSwYcNw+/ZtlcfmzZs1HRYREVGH8OB5OCYmBjKZDE8//bSmw3poUqkUtra2kMlkmg6FqM1g0U3UQejo6MDW1lblYWZmBqD61u9169Zh+PDh0NPTQ5cuXbBt2zaV9c+ePYvBgwdDT08PFhYWCAsLQ1FRkcoyX331Fby8vKCjowM7OztMnTpVZX52djZGjx4NfX19uLm54aefflLvThMREbUSD56He/bsiVmzZiEtLQ1ZWVnKZd555x24u7tDX18fXbp0wdy5c1FRUQGg+jbxBQsW4MyZM8or5tHR0QCAvLw8TJ48GTY2NtDV1UWPHj3wyy+/qLz/7t274eHhAUNDQ+UPAHXJzc1FSEgIrKysoKenBzc3N0RFRQGoeXt5XXfTHThwAABQVlaGmTNnolOnTjAwMICfn59yHlFHwaKbiAAAc+fORXBwMM6cOYOQkBC88MILuHDhAgCguLgYQUFBMDMzwx9//IGtW7fi999/Vymq161bh4iICISFheHs2bP46aef4OrqqvIeCxYswPPPP4/ExEQ8+eSTCAkJQU5OTovuJxERkaYVFRVh06ZNcHV1hYWFhXK6kZERoqOjkZSUhJUrV2Ljxo1Yvnw5AGDMmDGYMWMGvLy8lFfMx4wZA4VCgeHDh+Po0aPYtGkTkpKSsHjxYkilUuV2S0pKsGTJEnzzzTc4dOgQUlNTMXPmzDrjmzt3LpKSkrBr1y5cuHAB69atg6WlZa3Lrly5UuUuumnTpsHa2hrdu3cHAEydOhXHjx/Hli1bkJiYiOeeew7Dhg3DlStXmiOVRG2DIKJ2LzQ0VEilUmFgYKDy+Oijj4QQQgAQ4eHhKuv4+fmJKVOmCCGE2LBhgzAzMxNFRUXK+Tt37hRaWloiPT1dCCGEvb29mDNnTp0xABDvvfee8nVRUZEAIHbt2tVs+0lERNQa/f08DEDY2dmJuLi4etf79NNPRZ8+fZSv582bJ3x8fFSW2b17t9DS0hKXLl2qdRtRUVECgEhOTlZOW7NmjbCxsanzfZ955hkxYcKEWuelpKQIACI+Pr7GvO+//17o6uqKI0eOCCGEuH79upBKpeLmzZsqywUGBorZs2fX+f5E7Q0bYxB1EIMGDcK6detUppmbmyuf+/v7q8zz9/dX3jp24cIF+Pj4wMDAQDm/f//+UCgUuHTpEiQSCW7duoXAwMB6Y/D29lY+NzAwgLGxMTIzM5u6S0RERG3Gg+fh3NxcrF27FsOHD8epU6fg5OQEAPjuu++watUqXL16FUVFRaisrISxsXG9201ISEDnzp3h7u5e5zL6+vro2rWr8rWdnV29598pU6YgODgYp0+fxtChQzFq1Cj069ev3jji4+Mxbtw4fPbZZ+jfvz+A6qZpVVVVNWIrKytTucJP1N6x6CbqIAwMDGrc7t1c9PT0GrWctra2ymuJRAKFQqGOkIiIiFqVv5+Hv/jiC5iYmGDjxo348MMPcfz4cYSEhGDBggUICgqCiYkJtmzZgqVLl9a73cacg2s7/woh6lx++PDhuH79On799Vfs3bsXgYGBiIiIwJIlS2pdPj09HSNGjMCrr76KiRMnKqcXFRVBKpUiLi5O5XZ3ADA0NGwwbqL2gm26iQgAcOLEiRqvPTw8AAAeHh44c+YMiouLlfOPHj0KLS0tdOvWDUZGRnB2dkZMTEyLxkxERNRWSSQSaGlpobS0FABw7NgxODk5Yc6cOfD19YWbmxuuX7+uso5cLkdVVZXKNG9vb9y4cQOXL19u1visrKwQGhqKTZs2YcWKFdiwYUOty929excjR45E9+7dsWzZMpV5vXr1QlVVFTIzM+Hq6qrysLW1bdZ4iVozXukm6iDKysqQnp6uMk0mkyk7Rtm6dSt8fX0REBCAb7/9FqdOncKXX34JAAgJCcG8efMQGhqK+fPnIysrC6+//jrGjRsHGxsbANVjh4aHh8Pa2hrDhw9HYWEhjh49itdff71ld5SIiKgVevA8nJubi88++wxFRUV45plnAABubm5ITU3Fli1b0LdvX+zcuRPbt29X2YazszNSUlKUt5QbGRnhiSeewIABAxAcHIxly5bB1dUVFy9ehEQiwbBhw5oU6/vvv48+ffrAy8sLZWVl+OWXX5Q/xP/d5MmTkZaWhpiYGJWe2M3NzeHu7o6QkBCMHz8eS5cuRa9evZCVlYWYmBh4e3vjqaeealJ8RG0Nr3QTdRC//fYb7OzsVB4BAQHK+QsWLMCWLVvg7e2N//73v9i8eTM8PT0BVLcF2717N3JyctC3b1/8+9//RmBgID777DPl+qGhoVixYgXWrl0LLy8vPP300+yZlIiI6C8Pnof9/PyUo4EMHDgQADBixAhMnz4dU6dORc+ePXHs2DHMnTtXZRvBwcEYNmwYBg0aBCsrK2zevBkA8P3336Nv37548cUX4enpibfffrvGFfGHIZfLMXv2bHh7e2PAgAGQSqXYsmVLrcsePHgQt2/fhqenp8p3jGPHjgEAoqKiMH78eMyYMQPdunXDqFGj8Mcff8DR0bHJ8RG1NRJRX4MOIuoQJBIJtm/fjlGjRmk6FCIiIiKidoVXuomIiIiIiIjUhEU3ERERERERkZqwIzUiqnfYECIiIiIiajpe6SYiIiIiIiJSExbdRERERERERGrCopuIiIiIiIhITVh0ExEREREREakJi24iIiIiIiIiNWHRTURERERERKQmLLqJiIiIiIiI1IRFNxEREREREZGa/D8DBQKGn5sSdgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Plot part 1 results\n", "fig, axes = plt.subplots(1, 2, figsize=(10, 4))\n", "\n", "fig.suptitle('Effect of batch size')\n", "\n", "# Validation accuracy over epochs\n", "axes[0].set_title('Validation accuracy')\n", "\n", "for bs, history in results_part1.items():\n", " axes[0].plot(history['val_accuracy'], label=f'batch_size={bs}')\n", "\n", "axes[0].set_xlabel('Epoch')\n", "axes[0].set_ylabel('Accuracy (%)')\n", "axes[0].legend()\n", "\n", "# Final accuracy bar chart\n", "axes[1].set_title('Final validation accuracy')\n", "\n", "batch_sizes = list(results_part1.keys())\n", "final_accs = [results_part1[bs]['val_accuracy'][-1] for bs in batch_sizes]\n", "\n", "bars = axes[1].bar([str(bs) for bs in batch_sizes], final_accs)\n", "axes[1].set_xlabel('Batch size')\n", "axes[1].set_ylabel('Accuracy (%)')\n", "axes[1].set_ylim(0, 100)\n", "\n", "# Add value labels\n", "for bar, acc in zip(bars, final_accs):\n", " axes[1].text(bar.get_x() + bar.get_width()/2, bar.get_height() + 1,\n", " f'{acc:.1f}%', ha='center')\n", "\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "52303945", "metadata": {}, "source": [ "---\n", "\n", "## Part 2: Momentum effect (SGD with different momentum values)\n", "\n", "Momentum helps SGD accelerate in relevant directions and dampen oscillations. Let's see how different momentum values affect training:\n", "- **momentum=0.0**: Vanilla SGD (no momentum)\n", "- **momentum=0.5**: Light momentum\n", "- **momentum=0.9**: Standard momentum (commonly used)\n", "- **momentum=0.95**: High momentum\n", "- **momentum=0.99**: Very high momentum (can overshoot)\n", "\n", "We use batch_size=16 and lr=0.01 (from Part 1's good settings)." ] }, { "cell_type": "code", "execution_count": 10, "id": "84a03134", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Training with momentum=0.0\n", "Epoch 1/50 - loss: 1.8941 - acc: 30.59% - val_loss: 1.5878 - val_acc: 46.00%\n", "Epoch 10/50 - loss: 1.2983 - acc: 54.43% - val_loss: 1.0782 - val_acc: 62.82%\n", "Epoch 20/50 - loss: 1.1775 - acc: 59.18% - val_loss: 0.9965 - val_acc: 66.98%\n", "Epoch 30/50 - loss: 1.1235 - acc: 61.00% - val_loss: 0.9386 - val_acc: 68.29%\n", "Epoch 40/50 - loss: 1.0828 - acc: 61.93% - val_loss: 0.9099 - val_acc: 69.65%\n", "Epoch 50/50 - loss: 1.0550 - acc: 63.37% - val_loss: 0.8873 - val_acc: 69.40%\n", "-> Final val acc: 69.40% (took 1311.8s)\n", "\n", "Training with momentum=0.5\n", "Epoch 1/50 - loss: 1.8948 - acc: 30.36% - val_loss: 1.5764 - val_acc: 44.97%\n", "Epoch 10/50 - loss: 1.2902 - acc: 54.77% - val_loss: 1.0739 - val_acc: 64.11%\n", "Epoch 20/50 - loss: 1.1804 - acc: 58.70% - val_loss: 0.9954 - val_acc: 66.27%\n", "Epoch 30/50 - loss: 1.1286 - acc: 60.83% - val_loss: 0.9364 - val_acc: 67.98%\n", "Epoch 40/50 - loss: 1.0961 - acc: 61.34% - val_loss: 0.9099 - val_acc: 69.38%\n", "Epoch 50/50 - loss: 1.0626 - acc: 62.99% - val_loss: 0.8745 - val_acc: 70.20%\n", "-> Final val acc: 70.20% (took 1011.9s)\n", "\n", "Training with momentum=0.9\n", "Epoch 1/50 - loss: 2.1619 - acc: 17.70% - val_loss: 1.7828 - val_acc: 34.67%\n", "Epoch 10/50 - loss: 1.5105 - acc: 47.12% - val_loss: 1.2720 - val_acc: 55.54%\n", "Epoch 20/50 - loss: 1.4135 - acc: 50.72% - val_loss: 1.2475 - val_acc: 56.32%\n", "Epoch 30/50 - loss: 1.3762 - acc: 52.27% - val_loss: 1.0981 - val_acc: 62.28%\n", "Epoch 40/50 - loss: 1.3580 - acc: 52.63% - val_loss: 1.0541 - val_acc: 64.15%\n", "Epoch 50/50 - loss: 1.3387 - acc: 53.75% - val_loss: 1.0387 - val_acc: 64.67%\n", "-> Final val acc: 64.67% (took 1009.8s)\n", "\n", "Training with momentum=0.95\n", "Epoch 1/50 - loss: 2.2961 - acc: 11.48% - val_loss: 2.2019 - val_acc: 17.68%\n", "Epoch 10/50 - loss: 1.9905 - acc: 27.65% - val_loss: 1.8795 - val_acc: 33.05%\n", "Epoch 20/50 - loss: 1.9795 - acc: 28.50% - val_loss: 1.8367 - val_acc: 33.08%\n", "Epoch 30/50 - loss: 1.9646 - acc: 29.20% - val_loss: 1.8529 - val_acc: 33.78%\n", "Epoch 40/50 - loss: 1.9619 - acc: 29.07% - val_loss: 1.8226 - val_acc: 35.36%\n", "Epoch 50/50 - loss: 1.9596 - acc: 29.45% - val_loss: 1.8470 - val_acc: 33.37%\n", "-> Final val acc: 33.37% (took 1027.4s)\n", "\n", "Training with momentum=0.99\n", "Epoch 1/50 - loss: 2.3134 - acc: 10.75% - val_loss: 2.3103 - val_acc: 10.58%\n", "Epoch 10/50 - loss: 2.3164 - acc: 10.07% - val_loss: 2.3143 - val_acc: 9.43%\n", "Epoch 20/50 - loss: 2.3190 - acc: 9.86% - val_loss: 2.3285 - val_acc: 10.12%\n", "Epoch 30/50 - loss: 2.3153 - acc: 9.80% - val_loss: 2.3139 - val_acc: 10.25%\n", "Epoch 40/50 - loss: 2.3165 - acc: 10.13% - val_loss: 2.3206 - val_acc: 9.63%\n", "Epoch 50/50 - loss: 2.3184 - acc: 9.94% - val_loss: 2.3287 - val_acc: 9.63%\n", "-> Final val acc: 9.63% (took 1034.5s)\n", "\n", "CPU times: user 1h 27min 7s, sys: 29.1 s, total: 1h 27min 36s\n", "Wall time: 1h 29min 55s\n" ] } ], "source": [ "%%time\n", "\n", "# Create train loader for Part 2\n", "train_loader_part2 = create_train_loader(batch_size_part2)\n", "\n", "# Dictionary to store results for Part 2\n", "results_part2 = {}\n", "\n", "for momentum in momentum_values:\n", "\n", " print(f'\\nTraining with momentum={momentum}')\n", " \n", " # Create fresh model\n", " torch.manual_seed(42)\n", " model = create_cnn().to(device)\n", " \n", " # Create optimizer with specified momentum\n", " optimizer = optim.SGD(model.parameters(), lr=lr_part2, momentum=momentum)\n", " criterion = nn.CrossEntropyLoss()\n", " \n", " # Train the model\n", " start = time.time()\n", " results_part2[momentum] = train_model(\n", " model=model,\n", " train_loader=train_loader_part2,\n", " val_loader=val_loader,\n", " criterion=criterion,\n", " optimizer=optimizer,\n", " epochs=n_epochs_part2,\n", " print_every=print_every\n", " )\n", " elapsed = time.time() - start\n", " \n", " final_acc = results_part2[momentum]['val_accuracy'][-1]\n", " print(f'-> Final val acc: {final_acc:.2f}% (took {elapsed:.1f}s)')\n", "\n", "print()" ] }, { "cell_type": "code", "execution_count": 11, "id": "594766c2", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Plot part 2 results\n", "fig, axes = plt.subplots(1, 2, figsize=(10, 4))\n", "\n", "fig.suptitle(f'Effect of momentum')\n", "\n", "# Validation accuracy over epochs\n", "axes[0].set_title('Validation accuracy')\n", "\n", "for momentum, history in results_part2.items():\n", " axes[0].plot(history['val_accuracy'], label=momentum)\n", "\n", "axes[0].set_xlabel('Epoch')\n", "axes[0].set_ylabel('Accuracy (%)')\n", "axes[0].legend(title='Momentum')\n", "\n", "# Final accuracy bar chart\n", "axes[1].set_title('Final validation accuracy')\n", "\n", "momentums = list(results_part2.keys())\n", "final_accs = [results_part2[m]['val_accuracy'][-1] for m in momentums]\n", "\n", "bars = axes[1].bar([str(m) for m in momentums], final_accs)\n", "axes[1].set_xlabel('Momentum')\n", "axes[1].set_ylabel('Accuracy (%)')\n", "axes[1].set_ylim(0, 100)\n", "\n", "# Add value labels\n", "for bar, acc in zip(bars, final_accs):\n", " axes[1].text(bar.get_x() + bar.get_width()/2, bar.get_height() + 1,\n", " f'{acc:.1f}%', ha='center')\n", "\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "22df1884", "metadata": {}, "source": [ "---\n", "\n", "## Part 3: Optimizer comparison (same learning rate)\n", "\n", "Now we compare all four optimizers with the **same learning rate (0.001)** to see how they differ in convergence speed.\n", "\n", "We'll use a larger batch size for efficiency." ] }, { "cell_type": "code", "execution_count": 16, "id": "497f2ec6", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Training with SGD\n", "Epoch 1/50 - loss: 2.4251 - acc: 9.84% - val_loss: 2.3054 - val_acc: 8.12%\n", "Epoch 10/50 - loss: 2.3770 - acc: 10.64% - val_loss: 2.2986 - val_acc: 10.35%\n", "Epoch 20/50 - loss: 2.3555 - acc: 10.57% - val_loss: 2.2884 - val_acc: 13.76%\n", "Epoch 30/50 - loss: 2.3389 - acc: 11.19% - val_loss: 2.2822 - val_acc: 15.90%\n", "Epoch 40/50 - loss: 2.3264 - acc: 11.67% - val_loss: 2.2774 - val_acc: 17.11%\n", "Epoch 50/50 - loss: 2.3136 - acc: 12.22% - val_loss: 2.2732 - val_acc: 18.07%\n", "\n", "Training with SGD+Momentum\n", "Epoch 1/50 - loss: 2.4232 - acc: 9.84% - val_loss: 2.3050 - val_acc: 8.22%\n", "Epoch 10/50 - loss: 2.2899 - acc: 13.55% - val_loss: 2.2753 - val_acc: 18.86%\n", "Epoch 20/50 - loss: 2.2389 - acc: 16.61% - val_loss: 2.2226 - val_acc: 25.76%\n", "Epoch 30/50 - loss: 2.1819 - acc: 19.32% - val_loss: 2.1598 - val_acc: 27.43%\n", "Epoch 40/50 - loss: 2.1315 - acc: 21.61% - val_loss: 2.1021 - val_acc: 28.77%\n", "Epoch 50/50 - loss: 2.0868 - acc: 23.50% - val_loss: 2.0530 - val_acc: 29.96%\n", "\n", "Training with RMSprop\n", "Epoch 1/50 - loss: 6.5869 - acc: 10.21% - val_loss: 2.2995 - val_acc: 10.45%\n", "Epoch 10/50 - loss: 2.1453 - acc: 22.46% - val_loss: 2.1177 - val_acc: 26.11%\n", "Epoch 20/50 - loss: 2.0231 - acc: 26.37% - val_loss: 1.9279 - val_acc: 33.81%\n", "Epoch 30/50 - loss: 1.9446 - acc: 28.61% - val_loss: 1.8259 - val_acc: 38.07%\n", "Epoch 40/50 - loss: 1.8694 - acc: 31.50% - val_loss: 1.7288 - val_acc: 40.99%\n", "Epoch 50/50 - loss: 1.8095 - acc: 33.18% - val_loss: 1.6625 - val_acc: 43.15%\n", "\n", "Training with Adam\n", "Epoch 1/50 - loss: 2.4524 - acc: 11.29% - val_loss: 2.2977 - val_acc: 12.30%\n", "Epoch 10/50 - loss: 2.0058 - acc: 25.52% - val_loss: 2.0452 - val_acc: 24.25%\n", "Epoch 20/50 - loss: 1.8264 - acc: 31.48% - val_loss: 1.6986 - val_acc: 41.26%\n", "Epoch 30/50 - loss: 1.7513 - acc: 34.48% - val_loss: 1.5837 - val_acc: 45.91%\n", "Epoch 40/50 - loss: 1.6810 - acc: 37.61% - val_loss: 1.4915 - val_acc: 49.26%\n", "Epoch 50/50 - loss: 1.6301 - acc: 39.81% - val_loss: 1.4104 - val_acc: 51.92%\n", "\n", "CPU times: user 9min 23s, sys: 990 ms, total: 9min 24s\n", "Wall time: 9min 10s\n" ] } ], "source": [ "%%time\n", "\n", "# Create train loader with default batch size for Parts 3 & 4\n", "train_loader = create_train_loader(batch_size)\n", "\n", "results_part3 = {}\n", "\n", "for name in optimizer_configs.keys():\n", "\n", " print(f'\\nTraining with {name}')\n", "\n", " results_part3[name] = train_with_optimizer(\n", " name, lr_part3, n_epochs_part3, print_every, train_loader=train_loader\n", " )\n", "\n", "print()" ] }, { "cell_type": "code", "execution_count": 17, "id": "c82bac14", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Plot part 3 results\n", "fig, axes = plt.subplots(1, 2, figsize=(10, 4))\n", "\n", "fig.suptitle(f'Optimizer comparison')\n", "\n", "# Validation accuracy over epochs\n", "axes[0].set_title('Validation accuracy')\n", "\n", "for name, history in results_part3.items():\n", " axes[0].plot(history['val_accuracy'], label=name)\n", "\n", "axes[0].set_xlabel('Epoch')\n", "axes[0].set_ylabel('Accuracy (%)')\n", "axes[0].legend()\n", "\n", "# Final accuracy bar chart\n", "axes[1].set_title('Final validation accuracy')\n", "\n", "names = list(results_part3.keys())\n", "final_accs = [results_part3[n]['val_accuracy'][-1] for n in names]\n", "\n", "bars = axes[1].bar(names, final_accs)\n", "axes[1].set_ylabel('Accuracy (%)')\n", "axes[1].set_ylim(0, 100)\n", "\n", "# Add value labels\n", "for bar, acc in zip(bars, final_accs):\n", " axes[1].text(bar.get_x() + bar.get_width()/2, bar.get_height() + 1,\n", " f'{acc:.1f}%', ha='center')\n", "\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "e58b3594", "metadata": {}, "source": [ "## Part 4: Learning rate sensitivity\n", "\n", "Learning rates tested: `[0.1, 0.01, 0.001, 0.0001]`" ] }, { "cell_type": "code", "execution_count": 18, "id": "3c8f4d0e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Training with SGD, lr=0.1\n", "Epoch 1/10 - loss: 2.3505 - acc: 11.09% - val_loss: 2.2978 - val_acc: 9.48%\n", "-> Final val acc: 28.26%\n", "\n", "Training with SGD, lr=0.01\n", "Epoch 1/10 - loss: 2.4029 - acc: 9.96% - val_loss: 2.3033 - val_acc: 8.75%\n", "-> Final val acc: 21.02%\n", "\n", "Training with SGD, lr=0.001\n", "Epoch 1/10 - loss: 2.4251 - acc: 9.84% - val_loss: 2.3054 - val_acc: 8.12%\n", "-> Final val acc: 10.35%\n", "\n", "Training with SGD, lr=0.0001\n", "Epoch 1/10 - loss: 2.4281 - acc: 9.82% - val_loss: 2.3057 - val_acc: 7.96%\n", "-> Final val acc: 8.19%\n", "\n", "Training with SGD+Momentum, lr=0.1\n", "Epoch 1/10 - loss: 2.3397 - acc: 11.74% - val_loss: 2.2974 - val_acc: 9.48%\n", "-> Final val acc: 36.07%\n", "\n", "Training with SGD+Momentum, lr=0.01\n", "Epoch 1/10 - loss: 2.3939 - acc: 10.13% - val_loss: 2.3013 - val_acc: 9.99%\n", "-> Final val acc: 29.90%\n", "\n", "Training with SGD+Momentum, lr=0.001\n", "Epoch 1/10 - loss: 2.4232 - acc: 9.84% - val_loss: 2.3050 - val_acc: 8.22%\n", "-> Final val acc: 18.86%\n", "\n", "Training with SGD+Momentum, lr=0.0001\n", "Epoch 1/10 - loss: 2.4279 - acc: 9.81% - val_loss: 2.3057 - val_acc: 7.98%\n", "-> Final val acc: 10.04%\n", "\n", "Training with RMSprop, lr=0.1\n", "Epoch 1/10 - loss: 10.8645 - acc: 9.85% - val_loss: 2.3133 - val_acc: 9.89%\n", "-> Final val acc: 10.12%\n", "\n", "Training with RMSprop, lr=0.01\n", "Epoch 1/10 - loss: 84.7242 - acc: 9.78% - val_loss: 2.3049 - val_acc: 9.48%\n", "-> Final val acc: 13.53%\n", "\n", "Training with RMSprop, lr=0.001\n", "Epoch 1/10 - loss: 6.5869 - acc: 10.21% - val_loss: 2.2995 - val_acc: 10.45%\n", "-> Final val acc: 26.14%\n", "\n", "Training with RMSprop, lr=0.0001\n", "Epoch 1/10 - loss: 2.4490 - acc: 11.57% - val_loss: 2.2940 - val_acc: 13.57%\n", "-> Final val acc: 29.54%\n", "\n", "Training with Adam, lr=0.1\n", "Epoch 1/10 - loss: 91.5965 - acc: 9.90% - val_loss: 2.3192 - val_acc: 9.74%\n", "-> Final val acc: 14.88%\n", "\n", "Training with Adam, lr=0.01\n", "Epoch 1/10 - loss: 6.8103 - acc: 9.98% - val_loss: 2.3435 - val_acc: 11.28%\n", "-> Final val acc: 15.83%\n", "\n", "Training with Adam, lr=0.001\n", "Epoch 1/10 - loss: 2.4524 - acc: 11.29% - val_loss: 2.2977 - val_acc: 12.31%\n", "-> Final val acc: 24.29%\n", "\n", "Training with Adam, lr=0.0001\n", "Epoch 1/10 - loss: 2.3794 - acc: 10.30% - val_loss: 2.3004 - val_acc: 10.30%\n", "-> Final val acc: 29.33%\n", "\n", "CPU times: user 7min 19s, sys: 498 ms, total: 7min 20s\n", "Wall time: 7min 9s\n" ] } ], "source": [ "%%time\n", "\n", "results_part4 = {name: {} for name in optimizer_configs.keys()}\n", "\n", "for name in optimizer_configs.keys():\n", " for lr in learning_rates:\n", "\n", " print(f'\\nTraining with {name}, lr={lr}')\n", "\n", " results_part4[name][lr] = train_with_optimizer(\n", " name, lr, n_epochs_part4, print_every=n_epochs_part4 + 1, train_loader=train_loader\n", " )\n", "\n", " print(f'-> Final val acc: {results_part4[name][lr][\"val_accuracy\"][-1]:.2f}%')\n", "\n", "print()" ] }, { "cell_type": "code", "execution_count": 19, "id": "516b8ea9", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Final Validation Accuracy Matrix:\n", "\n", "Optimizer 0.1 0.01 0.001 0.0001\n", "SGD 28.3% 21.0% 10.3% 8.2%\n", "SGD+Momentum 36.1% 29.9% 18.9% 10.0%\n", "RMSprop 10.1% 13.5% 26.1% 29.5%\n", "Adam 14.9% 15.8% 24.3% 29.3%\n" ] } ], "source": [ "# Create results matrix for heatmap\n", "optimizer_names = list(optimizer_configs.keys())\n", "accuracy_matrix = np.zeros((len(optimizer_names), len(learning_rates)))\n", "\n", "for i, name in enumerate(optimizer_names):\n", " for j, lr in enumerate(learning_rates):\n", " accuracy_matrix[i, j] = results_part4[name][lr]['val_accuracy'][-1]\n", "\n", "print('Final Validation Accuracy Matrix:')\n", "print()\n", "print(f'{\"Optimizer\":<15}', end='')\n", "\n", "for lr in learning_rates:\n", " print(f'{lr:>10}', end='')\n", "\n", "print()\n", "\n", "for i, name in enumerate(optimizer_names):\n", " print(f'{name:<15}', end='')\n", "\n", " for j, lr in enumerate(learning_rates):\n", " acc = accuracy_matrix[i, j]\n", " print(f'{acc:>9.1f}%', end='')\n", "\n", " print()" ] }, { "cell_type": "code", "execution_count": 20, "id": "b06e9955", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Plot part 4 results\n", "fig, axes = plt.subplots(1, 2, figsize=(12, 5))\n", "\n", "plt.suptitle(f'Learning rate sensitivity')\n", "\n", "# Heatmap\n", "axes[0].set_title('Validation accuracy heatmap')\n", "\n", "im = axes[0].imshow(accuracy_matrix, aspect='auto', vmin=10, vmax=70)\n", "\n", "axes[0].set_xticks(range(len(learning_rates)))\n", "axes[0].set_xticklabels([str(lr) for lr in learning_rates])\n", "axes[0].set_yticks(range(len(optimizer_names)))\n", "axes[0].set_yticklabels(optimizer_names)\n", "axes[0].set_xlabel('Learning rate')\n", "\n", "# Add text annotations\n", "for i in range(len(optimizer_names)):\n", " for j in range(len(learning_rates)):\n", "\n", " text = f'{accuracy_matrix[i, j]:.1f}%'\n", " color = 'white' if accuracy_matrix[i, j] < 40 else 'black'\n", " axes[0].text(j, i, text, ha='center', va='center', color=color, fontsize=11)\n", "\n", "plt.colorbar(im, ax=axes[0], label='Validation accuracy (%)')\n", "\n", "# Line plot: accuracy vs learning rate\n", "axes[1].set_title('Accuracy vs learning rate')\n", "\n", "for name in optimizer_names:\n", " accs = [results_part4[name][lr]['val_accuracy'][-1] for lr in learning_rates]\n", " axes[1].plot(range(len(learning_rates)), accs, 'o-', label=name)\n", "\n", "axes[1].set_xticks(range(len(learning_rates)))\n", "axes[1].set_xticklabels([str(lr) for lr in learning_rates])\n", "axes[1].set_xlabel('Learning rate')\n", "axes[1].set_ylabel('Validation accuracy (%)')\n", "axes[1].legend()\n", "axes[1].set_ylim(0, 80)\n", "\n", "plt.tight_layout()\n", "plt.show()" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.12" } }, "nbformat": 4, "nbformat_minor": 5 }