{ "cells": [ { "cell_type": "markdown", "id": "cc8e9454", "metadata": {}, "source": [ "# PyTorch CNN activity: Experimenting with model architecture and data - solution\n", "\n", "In this activity, you will experiment with different aspects of the CNN model from the Lesson 31 demo to understand how architectural choices and data preprocessing affect model performance.\n", "\n", "## Activity overview\n", "\n", "You will conduct **three experiments** using the code provided in the demo notebook:\n", "\n", "1. **Experiment 1**: Add more convolutional blocks and/or modify filters and filter sizes\n", "2. **Experiment 2**: Use RGB images instead of grayscale\n", "3. **Experiment 3**: Add image augmentation using PyTorch transforms\n", "\n", "For each experiment, you will:\n", "- Modify the relevant code sections\n", "- Train the model\n", "- Compare results with the baseline model\n", "- Document your observations\n", "\n", "**Note**: You may want to reduce the number of epochs (e.g., to 20-30) to speed up experimentation.\n", "\n", "## Notebook setup\n", "\n", "### Imports" ] }, { "cell_type": "code", "execution_count": 1, "id": "fdd302c7", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Using device: cuda\n" ] } ], "source": [ "# Standard library imports\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", "\n", "from sklearn.metrics import (\n", " confusion_matrix, roc_curve, auc, \n", " precision_recall_curve, average_precision_score\n", ")\n", "\n", "from sklearn.preprocessing import label_binarize\n", "from torchvision import datasets, transforms\n", "from torch.utils.data import DataLoader\n", "\n", "# Set random seeds for reproducibility\n", "torch.manual_seed(315)\n", "np.random.seed(315)\n", "\n", "# Check for GPU availability\n", "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", "print(f'Using device: {device}')" ] }, { "cell_type": "markdown", "id": "665bb71a", "metadata": {}, "source": [ "### Hyperparameters" ] }, { "cell_type": "code", "execution_count": 2, "id": "df8b361b", "metadata": {}, "outputs": [], "source": [ "batch_size = 1000 # Training images come in 5 batches of 10,000\n", "learning_rate = 1e-3\n", "epochs = 30\n", "print_every = 5 # Print training progress every n epochs\n", "\n", "# CIFAR-10 class names in class order\n", "class_names = [\n", " 'airplane', 'automobile', 'bird', 'cat', 'deer',\n", " 'dog', 'frog', 'horse', 'ship', 'truck'\n", "]" ] }, { "cell_type": "markdown", "id": "fc030588", "metadata": {}, "source": [ "---\n", "\n", "## Experiment 1: Modify convolutional architecture\n", "\n", "**Objective**: Explore how adding more convolutional blocks or changing filter counts and kernel sizes affects model performance.\n", "\n", "### 1.1. Load and preprocess data (baseline - grayscale)" ] }, { "cell_type": "code", "execution_count": 3, "id": "4da77825", "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", "Image shape: torch.Size([1, 32, 32])\n" ] } ], "source": [ "# Make sure data directory exists\n", "data_dir = Path('../data')\n", "data_dir.mkdir(parents=True, exist_ok=True)\n", "\n", "# Data preprocessing: convert to grayscale, tensor, and normalize\n", "transform_exp1 = 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 training and test datasets\n", "train_dataset_exp1 = datasets.CIFAR10(\n", " root=data_dir,\n", " train=True,\n", " download=True,\n", " transform=transform_exp1\n", ")\n", "\n", "test_dataset_exp1 = datasets.CIFAR10(\n", " root=data_dir,\n", " train=False,\n", " download=True,\n", " transform=transform_exp1\n", ")\n", "\n", "print(f'Training samples: {len(train_dataset_exp1)}')\n", "print(f'Test samples: {len(test_dataset_exp1)}')\n", "print(f'Image shape: {train_dataset_exp1[0][0].shape}')" ] }, { "cell_type": "markdown", "id": "1eb6f135", "metadata": {}, "source": [ "### 1.2. Create data loaders" ] }, { "cell_type": "code", "execution_count": 4, "id": "65ff48e6", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Training batches: 40\n" ] } ], "source": [ "# Create training, validation and testing tensors\n", "X_train_full = torch.stack([img for img, _ in train_dataset_exp1]).to(device)\n", "y_train_full = torch.tensor([label for _, label in train_dataset_exp1]).to(device)\n", "\n", "X_test_exp1 = torch.stack([img for img, _ in test_dataset_exp1]).to(device)\n", "y_test_exp1 = torch.tensor([label for _, label in test_dataset_exp1]).to(device)\n", "\n", "# Split training data into train and validation sets (80/20 split)\n", "n_train = int(0.8 * len(X_train_full))\n", "indices = torch.randperm(len(X_train_full))\n", "\n", "X_train_exp1 = X_train_full[indices[:n_train]]\n", "y_train_exp1 = y_train_full[indices[:n_train]]\n", "X_val_exp1 = X_train_full[indices[n_train:]]\n", "y_val_exp1 = y_train_full[indices[n_train:]]\n", "\n", "# Create TensorDatasets and DataLoaders\n", "train_tensor_dataset_exp1 = torch.utils.data.TensorDataset(X_train_exp1, y_train_exp1)\n", "val_tensor_dataset_exp1 = torch.utils.data.TensorDataset(X_val_exp1, y_val_exp1)\n", "test_tensor_dataset_exp1 = torch.utils.data.TensorDataset(X_test_exp1, y_test_exp1)\n", "\n", "train_loader_exp1 = DataLoader(train_tensor_dataset_exp1, batch_size=batch_size, shuffle=True)\n", "val_loader_exp1 = DataLoader(val_tensor_dataset_exp1, batch_size=batch_size, shuffle=False)\n", "test_loader_exp1 = DataLoader(test_tensor_dataset_exp1, batch_size=batch_size, shuffle=False)\n", "\n", "print(f'Training batches: {len(train_loader_exp1)}')" ] }, { "cell_type": "markdown", "id": "e926ebcb", "metadata": {}, "source": [ "### 1.3. Define modified CNN architecture\n", "\n", "**TODO**: Modify the model architecture below. Try one or more of these changes:\n", "\n", "- Add another convolutional block (Conv2d -> BatchNorm2d -> ReLU -> Conv2d -> BatchNorm2d -> ReLU -> MaxPool2d -> Dropout)\n", "- Increase the number of filters (e.g., change 32 to 64 or 128)\n", "- Experiment with different kernel sizes (e.g., 5x5 instead of 3x3)\n", "- Try different pooling strategies\n", "\n", "**Important**: Remember to update the input size to the first Linear layer if you change the architecture! The size depends on:\n", "- Number of filters in the last conv layer\n", "- Final spatial dimensions after pooling\n", "\n", "*Hint*: For a 32x32 image, each MaxPool2d(2,2) layer divides dimensions by 2. So:\n", "- After 1 pooling: 32 → 16\n", "- After 2 poolings: 32 → 16 → 8\n", "- After 3 poolings: 32 → 16 → 8 → 4" ] }, { "cell_type": "code", "execution_count": 5, "id": "4e834bc1", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Sequential(\n", " (0): Conv2d(1, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (2): ReLU()\n", " (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (5): ReLU()\n", " (6): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", " (7): Dropout(p=0.25, inplace=False)\n", " (8): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (9): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (10): ReLU()\n", " (11): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (12): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (13): ReLU()\n", " (14): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", " (15): Dropout(p=0.25, inplace=False)\n", " (16): Flatten(start_dim=1, end_dim=-1)\n", " (17): Linear(in_features=8192, out_features=256, bias=True)\n", " (18): ReLU()\n", " (19): Dropout(p=0.5, inplace=False)\n", " (20): Linear(in_features=256, out_features=10, bias=True)\n", ")\n", "\n", "Total parameters: 2359754\n" ] } ], "source": [ "num_classes = 10\n", "\n", "model_exp1 = nn.Sequential(\n", "\n", " # Conv block 1: grayscale input -> 64 filters\n", " nn.Conv2d(1, 64, kernel_size=3, padding=1),\n", " nn.BatchNorm2d(64),\n", " nn.ReLU(),\n", " nn.Conv2d(64, 64, kernel_size=3, padding=1),\n", " nn.BatchNorm2d(64),\n", " nn.ReLU(),\n", " nn.MaxPool2d(2, 2),\n", " nn.Dropout(0.25),\n", " \n", " # Conv block 2: 64 -> 128 filters\n", " nn.Conv2d(64, 128, kernel_size=3, padding=1),\n", " nn.BatchNorm2d(128),\n", " nn.ReLU(),\n", " nn.Conv2d(128, 128, kernel_size=3, padding=1),\n", " nn.BatchNorm2d(128),\n", " nn.ReLU(),\n", " nn.MaxPool2d(2, 2),\n", " nn.Dropout(0.25),\n", " \n", " # Classifier\n", " nn.Flatten(),\n", " nn.Linear(128 * 8 * 8, 256),\n", " nn.ReLU(),\n", " nn.Dropout(0.5),\n", " nn.Linear(256, num_classes)\n", "\n", ").to(device)\n", "\n", "trainable_params = sum(p.numel() for p in model_exp1.parameters() if p.requires_grad)\n", "print(model_exp1)\n", "print(f'\\nTotal parameters: {trainable_params}')" ] }, { "cell_type": "markdown", "id": "c0c435f3", "metadata": {}, "source": [ "### 1.4. Train modified model" ] }, { "cell_type": "code", "execution_count": 6, "id": "8e4102e5", "metadata": {}, "outputs": [], "source": [ "def train_model(\n", " model: nn.Module,\n", " train_loader: DataLoader,\n", " val_loader: DataLoader,\n", " criterion: nn.Module,\n", " optimizer: optim.Optimizer,\n", " epochs: int = 10,\n", " print_every: int = 1,\n", " device: torch.device = None\n", ") -> dict[str, list[float]]:\n", " '''Training loop for PyTorch classification model.\n", " \n", " Args:\n", " device: If provided, moves batches to this device on-the-fly.\n", " If None, assumes data is already on the correct device.\n", " '''\n", "\n", " history = {'train_loss': [], 'val_loss': [], 'train_accuracy': [], 'val_accuracy': []}\n", "\n", " for epoch in range(epochs):\n", "\n", " # Training phase\n", " model.train()\n", " running_loss = 0.0\n", " correct = 0\n", " total = 0\n", "\n", " for images, labels in train_loader:\n", " \n", " # Move batch to device if specified\n", " if device is not None:\n", " images, labels = images.to(device), labels.to(device)\n", "\n", " # Forward pass\n", " optimizer.zero_grad()\n", " outputs = model(images)\n", " loss = criterion(outputs, labels)\n", "\n", " # Backward pass\n", " loss.backward()\n", " optimizer.step()\n", "\n", " # Track metrics\n", " running_loss += loss.item()\n", " _, predicted = torch.max(outputs.data, 1)\n", " total += labels.size(0)\n", " correct += (predicted == labels).sum().item()\n", "\n", " # Calculate training metrics\n", " train_loss = running_loss / len(train_loader)\n", " train_accuracy = 100 * correct / total\n", "\n", " # Validation phase\n", " model.eval()\n", " val_running_loss = 0.0\n", " val_correct = 0\n", " val_total = 0\n", "\n", " with torch.no_grad():\n", "\n", " for images, labels in val_loader:\n", " \n", " # Move batch to device if specified\n", " if device is not None:\n", " images, labels = images.to(device), labels.to(device)\n", "\n", " outputs = model(images)\n", " loss = criterion(outputs, labels)\n", "\n", " val_running_loss += loss.item()\n", " _, predicted = torch.max(outputs.data, 1)\n", " val_total += labels.size(0)\n", " val_correct += (predicted == labels).sum().item()\n", "\n", " val_loss = val_running_loss / len(val_loader)\n", " val_accuracy = 100 * val_correct / val_total\n", "\n", " # Record metrics\n", " history['train_loss'].append(train_loss)\n", " history['val_loss'].append(val_loss)\n", " history['train_accuracy'].append(train_accuracy)\n", " history['val_accuracy'].append(val_accuracy)\n", "\n", " # Print progress\n", " if (epoch + 1) % print_every == 0 or epoch == 0:\n", "\n", " print(\n", " f'Epoch {epoch+1}/{epochs} - ' +\n", " f'loss: {train_loss:.4f} - ' +\n", " f'accuracy: {train_accuracy:.2f}% - ' +\n", " f'val_loss: {val_loss:.4f} - ' +\n", " f'val_accuracy: {val_accuracy:.2f}%'\n", " )\n", "\n", " print('\\nTraining complete.')\n", "\n", " return history" ] }, { "cell_type": "code", "execution_count": 7, "id": "865041b6", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch 1/30 - loss: 2.5536 - accuracy: 15.65% - val_loss: 2.1629 - val_accuracy: 20.44%\n", "Epoch 5/30 - loss: 1.6481 - accuracy: 38.15% - val_loss: 1.4567 - val_accuracy: 50.04%\n", "Epoch 10/30 - loss: 1.3034 - accuracy: 52.06% - val_loss: 1.2594 - val_accuracy: 57.08%\n", "Epoch 15/30 - loss: 1.1554 - accuracy: 57.55% - val_loss: 0.9194 - val_accuracy: 67.87%\n", "Epoch 20/30 - loss: 1.0719 - accuracy: 60.40% - val_loss: 0.8509 - val_accuracy: 70.68%\n", "Epoch 25/30 - loss: 0.9858 - accuracy: 63.65% - val_loss: 0.7907 - val_accuracy: 72.85%\n", "Epoch 30/30 - loss: 0.9423 - accuracy: 65.09% - val_loss: 0.7871 - val_accuracy: 73.28%\n", "\n", "Training complete.\n", "CPU times: user 3min 43s, sys: 544 ms, total: 3min 44s\n", "Wall time: 3min 42s\n" ] } ], "source": [ "%%time\n", "\n", "criterion_exp1 = nn.CrossEntropyLoss()\n", "optimizer_exp1 = optim.Adam(model_exp1.parameters(), lr=learning_rate)\n", "\n", "history_exp1 = train_model(\n", " model=model_exp1,\n", " train_loader=train_loader_exp1,\n", " val_loader=val_loader_exp1,\n", " criterion=criterion_exp1,\n", " optimizer=optimizer_exp1,\n", " epochs=epochs,\n", " print_every=print_every\n", ")" ] }, { "cell_type": "markdown", "id": "73fdf140", "metadata": {}, "source": [ "### 1.5. Evaluate and visualize results" ] }, { "cell_type": "code", "execution_count": 8, "id": "08942db9", "metadata": {}, "outputs": [], "source": [ "def evaluate_model(\n", " model: nn.Module,\n", " test_loader: DataLoader,\n", " device: torch.device = None\n", ") -> tuple[float, np.ndarray, np.ndarray]:\n", " '''Evaluate model on test set.\n", " \n", " Args:\n", " device: If provided, moves batches to this device on-the-fly.\n", " If None, assumes data is already on the correct device.\n", " '''\n", "\n", " model.eval()\n", " correct = 0\n", " total = 0\n", " all_predictions = []\n", " all_labels = []\n", "\n", " with torch.no_grad():\n", "\n", " for images, labels in test_loader:\n", " \n", " # Move batch to device if specified\n", " if device is not None:\n", " images, labels = images.to(device), labels.to(device)\n", "\n", " outputs = model(images)\n", " _, predicted = torch.max(outputs.data, 1)\n", "\n", " total += labels.size(0)\n", " correct += (predicted == labels).sum().item()\n", "\n", " all_predictions.extend(predicted.cpu().numpy())\n", " all_labels.extend(labels.cpu().numpy())\n", "\n", " accuracy = 100 * correct / total\n", " return accuracy, np.array(all_predictions), np.array(all_labels)" ] }, { "cell_type": "code", "execution_count": 9, "id": "5c0afcf2", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAGGCAYAAABmGOKbAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAA2DtJREFUeJzs3XdcVeUfwPHPZW+QJUMEBPfCnXuL5sg9spxpmVpqZmnDkWk2zTIttz81R44syxy5xb1zoiioICICsuFyfn8cuUaAAl64iN/363Vf995zn3PO94LXw/c+z/N9NIqiKAghhBBCCCGEEELvjAwdgBBCCCGEEEIIUVJJ0i2EEEIIIYQQQhQSSbqFEEIIIYQQQohCIkm3EEIIIYQQQghRSCTpFkIIIYQQQgghCokk3UIIIYQQQgghRCGRpFsIIYQQQgghhCgkknQLIYQQQgghhBCFRJJuIYQQQgghhBCikEjSLYR4ZkyZMgWNRmPoMIQQQgihZ7t370aj0bB7925DhyKE3knSLUQuli5dikaj4dixY4YORW8y31Nut0OHDhk6xBJhxowZbNq0Kc/t582bR69evShbtiwajYZBgwYVWmxCCGEIP/zwAxqNhgYNGhg6lBLr+vXrj73Gf/bZZ4YOsURYtWoVs2fPznP7bdu2MXToUKpVq4axsTE+Pj6FFpsovkwMHYAQouhNmzYNX1/fbNv9/f0NEE3effjhh7z//vuGDuOJZsyYQc+ePenatWue2s+aNYsHDx5Qv359wsPDCzc4IYQwgJUrV+Lj48ORI0cIDg4u9tebZ1m/fv148cUXs22vVauWAaLJu2bNmpGUlISZmZmhQ3msVatWce7cOcaMGZPn9mvWrKF27dp4eHgUbnCi2JKkW4jnUIcOHahbt66hw8izhIQErK2tMTExwcSk5P23tWfPHl0vt42NjaHDEUIIvQoJCeHgwYNs2LCB119/nZUrVzJ58mRDh5WjzOvNs6x27dq88sorhg4jz5KTkzEzM8PIyAgLCwtDh6N3M2bMYMGCBZiamtKpUyfOnTtn6JCEAcjwciGe0smTJ+nQoQN2dnbY2NjQunXrbMO009LSmDp1KuXLl8fCwgInJyeaNGnC9u3bdW0iIiIYPHgwZcqUwdzcHHd3d1566SWuX79exO8IJk+ejJGRETt37syyffjw4ZiZmXH69Gng0fyrNWvWMGnSJNzc3LC2tqZLly6EhYVlO+7hw4dp37499vb2WFlZ0bx5cw4cOJClTea87fPnz/Pyyy9TqlQpmjRpkuW1f9NoNIwaNYp169ZRpUoVLC0tadiwIWfPngXgxx9/xN/fHwsLC1q0aJHjzzM/cQUHBzNo0CAcHBywt7dn8ODBJCYmZoknISGBZcuW6Yb0PWm4uLe3t8xVF0KUWCtXrqRUqVJ07NiRnj17snLlyhzbxcTEMHbsWHx8fDA3N6dMmTIMGDCAqKgoXZvk5GSmTJlChQoVsLCwwN3dne7du3P16lUg93nBmUOvly5dqts2aNAgbGxsuHr1Ki+++CK2trb0798fgH379umm/Zibm+Pl5cXYsWNJSkrKFvfFixfp3bs3Li4uWFpaUrFiRT744AMAdu3ahUajYePGjdn2W7VqFRqNhqCgoHz9PJ/W33//jZGRER9//HGO8cybN0+3LfMau3LlSipWrIiFhQV16tRh79692Y5769YthgwZQunSpTE3N6dq1aosXrw4S5vM38/q1av58MMP8fT0xMrKiri4uBx/dy1atKBatWqcOXOG5s2bY2Vlhb+/P7/88gugfmndoEED3c99x44dTxXX2rVr+fTTTylTpgwWFha0bt2a4ODgLPFs2bKFGzdu6K7xTxou7uHhgamp6WPbiJKv5HUZCVGE/vnnH5o2bYqdnR0TJkzA1NSUH3/8kRYtWuguBKAmbDNnzuS1116jfv36xMXFcezYMU6cOEHbtm0B6NGjB//88w+jR4/Gx8eHyMhItm/fTmhoqN7n/8TGxmb5IwbUC6uTkxOgDuP+7bffGDp0KGfPnsXW1pa//vqLBQsW8Mknn1CzZs0s+3766adoNBree+89IiMjmT17Nm3atOHUqVNYWloC6kW+Q4cO1KlTR5fUL1myhFatWrFv3z7q16+f5Zi9evWifPnyzJgxA0VRHvt+9u3bx+bNmxk5ciQAM2fOpFOnTkyYMIEffviBN998k/v37/P5558zZMgQ/v77b92++Y2rd+/e+Pr6MnPmTE6cOMHChQtxdXVl1qxZAPzvf//T/Z6HDx8OgJ+fX55+L0IIURKtXLmS7t27Y2ZmRr9+/Zg3bx5Hjx6lXr16ujbx8fE0bdqUCxcuMGTIEGrXrk1UVBSbN2/m5s2bODs7o9Vq6dSpEzt37qRv3768/fbbPHjwgO3bt3Pu3LkC/V+bnp5OYGAgTZo04csvv8TKygqAdevWkZiYyIgRI3BycuLIkSN899133Lx5k3Xr1un2P3PmDE2bNsXU1JThw4fj4+PD1atX+e233/j0009p0aIFXl5erFy5km7dumX7ufj5+dGwYcMC/mRzlpiYmO0aD+Dg4ICJiQmtWrXizTffZObMmXTt2pXatWsTHh7O6NGjadOmDW+88UaW/fbs2cOaNWt46623MDc354cffqB9+/YcOXKEatWqAXDnzh1eeOEFXZLu4uLCn3/+ydChQ4mLi8s2FPuTTz7BzMyM8ePHk5KS8tgh5ffv36dTp0707duXXr16MW/ePPr27cvKlSsZM2YMb7zxBi+//DJffPEFPXv2JCwsDFtb2wLF9dlnn2FkZMT48eOJjY3l888/p3///hw+fBiADz74gNjYWG7evMk333wDICPURN4oQogcLVmyRAGUo0eP5tqma9euipmZmXL16lXdttu3byu2trZKs2bNdNtq1qypdOzYMdfj3L9/XwGUL774Qj/B5yLzPeV0Mzc3z9L27NmzipmZmfLaa68p9+/fVzw9PZW6desqaWlpuja7du1SAMXT01OJi4vTbV+7dq0CKN9++62iKIqSkZGhlC9fXgkMDFQyMjJ07RITExVfX1+lbdu2um2TJ09WAKVfv37Z4s987d8yYw8JCdFt+/HHHxVAcXNzyxLXxIkTFUDXtiBxDRkyJMv5u3Xrpjg5OWXZZm1trQwcODBb/HnxNPsKIURxc+zYMQVQtm/friiK+v9umTJllLfffjtLu48//lgBlA0bNmQ7Rub/z4sXL1YA5euvv861TeZ1adeuXVleDwkJUQBlyZIlum0DBw5UAOX999/PdrzExMRs22bOnKloNBrlxo0bum3NmjVTbG1ts2z7dzyKol57zM3NlZiYGN22yMhIxcTERJk8eXK28xRU5nvM7RYUFKRrm5CQoPj7+ytVq1ZVkpOTlY4dOyp2dnbZ3kfmvseOHdNtu3HjhmJhYaF069ZNt23o0KGKu7u7EhUVlWX/vn37Kvb29rqfZ+bvp1y5ctl+xjn97po3b64AyqpVq3TbLl68qACKkZGRcujQId32v/76K9vvOL9xVa5cWUlJSdG1+/bbbxVAOXv2rG5bx44dFW9vb6UgnmZf8WyT4eVCFJBWq2Xbtm107dqVcuXK6ba7u7vz8ssvs3//fuLi4gD12+V//vmHK1eu5HgsS0tLzMzM2L17N/fv3y/02OfOncv27duz3P78888sbapVq8bUqVNZuHAhgYGBREVFsWzZshznVA8YMED3rTJAz549cXd3548//gDg1KlTXLlyhZdffpl79+4RFRVFVFQUCQkJtG7dmr1795KRkZHlmP/9pv1xWrdunWU0QOYIgx49emSJK3P7tWvX9BZX06ZNuXfvnu53LYQQ4pGVK1dSunRpWrZsCaijqvr06cPq1avRarW6duvXr6dmzZrZeoMz98ls4+zszOjRo3NtUxAjRozIti1zlBao87yjoqJo1KgRiqJw8uRJAO7evcvevXsZMmQIZcuWzTWeAQMGkJKSohsSDbBmzRrS09MLZe718OHDs13jt2/fTpUqVXRtrKysWLp0KRcuXKBZs2Zs2bKFb775Jtv7AGjYsCF16tTRPS9btiwvvfQSf/31F1qtFkVRWL9+PZ07d0ZRFN21NCoqisDAQGJjYzlx4kSWYw4cODDLz/hxbGxs6Nu3r+55xYoVcXBwoHLlylmq4f/3Gl+QuAYPHpyl171p06ZZjilEQcnwciEK6O7duyQmJlKxYsVsr1WuXJmMjAzCwsKoWrUq06ZN46WXXqJChQpUq1aN9u3b8+qrr1KjRg0AzM3NmTVrFu+88w6lS5fmhRdeoFOnTgwYMAA3N7dcY0hKSiI2NjbLtse1z1S/fv08FVJ79913Wb16NUeOHGHGjBlZLtj/Vr58+SzPNRoN/v7+uvnTmV82DBw4MNdzxcbGUqpUKd3znKqr5+a/fyTY29sD4OXlleP2zC82ChLXf8+V+dr9+/exs7PLc8xCCFHSabVaVq9eTcuWLQkJCdFtb9CgAV999RU7d+6kXbt2AFy9epUePXo89nhXr16lYsWKei2oaWJiQpkyZbJtDw0N5eOPP2bz5s3ZvgzPvO5mJmKZQ6xzU6lSJerVq8fKlSsZOnQooH4Z8cILLzy2irtWq+Xu3btZtjk6Oj6xunf58uVp06bNY9sANG7cmBEjRjB37lwCAwMZMmRIrsf7rwoVKpCYmMjdu3cxMjIiJiaGn376iZ9++inHY0RGRmZ5np9rfJkyZbJ9qWJvb//Ea/zdu3fzHdfjrvFCPA1JuoUoAs2aNePq1av8+uuvbNu2jYULF/LNN98wf/58XnvtNQDGjBlD586d2bRpE3/99RcfffQRM2fO5O+//851mY81a9YwePDgLNuUJ8x/zo9r167pEtPMwmQFkdlb/MUXXxAQEJBjm//OicrrN+AAxsbG+dqe+TMqSFxPOqYQQgjV33//TXh4OKtXr2b16tXZXl+5cqUu6daX3Hq8/92r/m/m5uYYGRlla9u2bVuio6N57733qFSpEtbW1ty6dYtBgwZlGwGVFwMGDODtt9/m5s2bpKSkcOjQIb7//vvH7hMWFpYtOd21axctWrTI9/lzkpKSoitadvXqVRITE3Vz2vMj8+fxyiuv5PoldmYnQ6aivMbnJy65xovCIkm3EAXk4uKClZUVly5dyvbaxYsXMTIyyvItrKOjI4MHD2bw4MHEx8fTrFkzpkyZoku6QS249c477/DOO+9w5coVAgIC+Oqrr1ixYkWOMQQGBmapgK5PGRkZDBo0CDs7O8aMGaNbe7p79+7Z2v532LyiKAQHB+suZpnFbezs7PL07XtRKay4pBK5EEKoSbWrqytz587N9tqGDRvYuHEj8+fPx9LSEj8/vycupeTn58fhw4dJS0vLtRp0Zs9kTExMlu03btzIc9xnz57l8uXLLFu2jAEDBui2//d6mzm1LC9LQPXt25dx48bx888/k5SUhKmpKX369HnsPm5ubtnO+d9Cpk9j8uTJXLhwgS+//JL33nuP999/nzlz5mRrl9PUuMuXL2NlZYWLiwsAtra2aLXaYnWNd3FxKZS45BovCkLmdAtRQMbGxrRr145ff/01yzJUd+7cYdWqVTRp0kQ33PjevXtZ9rWxscHf35+UlBRArTSanJycpY2fnx+2tra6Njlxd3enTZs2WW768vXXX3Pw4EF++uknPvnkExo1asSIESNyrIi6fPlyHjx4oHv+yy+/EB4eTocOHQCoU6cOfn5+fPnll8THx2fb/7/D54pKYcVlbW2d7Q8+IYR4niQlJbFhwwY6depEz549s91GjRrFgwcP2Lx5M6DW4Dh9+nSOS2tl9jL26NGDqKioHHuIM9t4e3tjbGycbUmrH374Ic+xZ/Z2/rt3U1EUvv322yztXFxcaNasGYsXLyY0NDTHeDI5OzvToUMHVqxYwcqVK2nfvj3Ozs6PjcPCwiLbNf7f052exuHDh/nyyy8ZM2YM77zzDu+++y7ff/89e/bsydY2KCgoy9znsLAwfv31V9q1a4exsTHGxsb06NGD9evX5/gFhKGu8YUVl7W1dbapfUI8ifR0C/EEixcvZuvWrdm2v/3220yfPp3t27fTpEkT3nzzTUxMTPjxxx9JSUnh888/17WtUqUKLVq0oE6dOjg6OnLs2DF++eUXRo0aBajfGLdu3ZrevXtTpUoVTExM2LhxI3fu3MlSPERf/vzzTy5evJhte6NGjShXrhwXLlzgo48+YtCgQXTu3BmApUuXEhAQwJtvvsnatWuz7Ofo6EiTJk0YPHgwd+7cYfbs2fj7+zNs2DAAjIyMWLhwIR06dKBq1aoMHjwYT09Pbt26xa5du7Czs+O3337T+/t8ksKKq06dOuzYsYOvv/4aDw8PfH19sxR7+a/ffvtNt/Z5WloaZ86cYfr06QB06dIl2/A3IYQo7jZv3syDBw/o0qVLjq+/8MILuLi4sHLlSvr06cO7777LL7/8Qq9evRgyZAh16tQhOjqazZs3M3/+fGrWrMmAAQNYvnw548aN48iRIzRt2pSEhAR27NjBm2++yUsvvYS9vT29evXiu+++Q6PR4Ofnx++//55t7u7jVKpUCT8/P8aPH8+tW7ews7Nj/fr1Oc7rnTNnDk2aNKF27doMHz4cX19frl+/zpYtWzh16lSWtgMGDKBnz56AumRWYTlx4kSOI+QylydLTk5m4MCBlC9fnk8//RSAqVOn8ttvvzF48GDOnj2LtbW1br9q1aoRGBiYZcmwzH0yffbZZ+zatYsGDRowbNgwqlSpQnR0NCdOnGDHjh1ER0cX2vt9nMKIq06dOqxZs4Zx48ZRr149bGxsdH8r5eTMmTO6L5eCg4OJjY3VXeNr1qz52H1FCVL0BdOFeDY8bnktQAkLC1MURVFOnDihBAYGKjY2NoqVlZXSsmVL5eDBg1mONX36dKV+/fqKg4ODYmlpqVSqVEn59NNPldTUVEVRFCUqKkoZOXKkUqlSJcXa2lqxt7dXGjRooKxdu7ZI39OSJUuU9PR0pV69ekqZMmWyLG+iKI+WzlizZo2iKI+W2Pj555+ViRMnKq6uroqlpaXSsWPHbMuOKIqinDx5Uunevbvi5OSkmJubK97e3krv3r2VnTt36tpkLs119+7dbPvntmTYyJEjs2zLXDblv0uwZca7bt06vcWV+TP995JlFy9eVJo1a6ZYWloqwBOXAMtctia334kQQjxrOnfurFhYWCgJCQm5thk0aJBiamqqW87p3r17yqhRoxRPT0/FzMxMKVOmjDJw4MAsyz0lJiYqH3zwgeLr66uYmpoqbm5uSs+ePbMs3Xn37l2lR48eipWVlVKqVCnl9ddfV86dO5fjkmHW1tY5xnb+/HmlTZs2io2NjeLs7KwMGzZMOX36dI7/L587d07p1q2b4uDgoFhYWCgVK1ZUPvroo2zHTElJUUqVKqXY29srSUlJefkx5suTlgzLvBaNHTtWMTY2Vg4fPpxl/2PHjikmJibKiBEjdNsyr7ErVqxQypcvr5ibmyu1atXKtiSboijKnTt3lJEjRypeXl66303r1q2Vn376Sdcmt+vwv1/775JhVatWzdbW29s7x6VYc/qb4Gniymmpufj4eOXll19WHBwcFOCJS4A97m8vWSL0+aFRFKkMIIQomN27d9OyZUvWrVun+/ZeCCGEENmlp6fj4eFB586dWbRokaHDyRONRsPIkSOfWPRNCPF4MqdbCCGEEEKIQrZp0ybu3r2bpTibEOL5IHO6hRBCCCGEKCSHDx/mzJkzfPLJJ9SqVYvmzZsbOiQhRBGTnm4hhBBCCCEKybx58xgxYgSurq4sX77c0OEIIQxA5nQLIYQQQgghhBCFRHq6hRBCCCGEEEKIQiJJtxBCCCGEEEIIUUikkFoOMjIyuH37Nra2tmg0GkOHI4QQ4jmlKAoPHjzAw8MDI6Pn93tyuS4LIYQoDgp6XZakOwe3b9/Gy8vL0GEIIYQQAISFhVGmTBlDh2Ewcl0WQghRnOT3uixJdw5sbW0B9YdpZ2dn4GiEEEI8r+Li4vDy8tJdl55Xcl0WQghRHBT0uixJdw4yh67Z2dnJxV0IIYTBPe9DquW6LIQQojjJ73X5+Z0gJoQQQgghhBBCFDJJuoUQQgghhBBCiEIiSbcQQgghhBBCCFFIZE63EEI8Y7RaLWlpaYYOQ+iJmZnZc70cmD7JZ6PkMDU1xdjY2NBhCCGEXkjSLYQQzwhFUYiIiCAmJsbQoQg9MjIywtfXFzMzM0OH8sySz0bJ5ODggJub23NfSFAI8eyTpFsIIZ4RmUmFq6srVlZW8odoCZCRkcHt27cJDw+nbNmy8jstIPlslCyKopCYmEhkZCQA7u7uBo5ICCGejiTdQgjxDNBqtbqkwsnJydDhCD1ycXHh9u3bpKenY2pqauhwnjny2SiZLC0tAYiMjMTV1VWGmgshnmkyiUwIIZ4BmfNUraysDByJ0LfMYeVardbAkTyb5LNRcmX+TmWevhDiWSdJtxBCPENk2GzJI79T/ZCfY8kjv1MhREkhSXcRUBTF0CEIIYQQQgghhDAAmdNdiNK1GfScH0RwZDx7J7TE0Voq0wohhD74+PgwZswYxowZY+hQhCg25HMhhMi31ES4exEiz8Od8xD5DyTeg85zwLO2oaPLu/QUSIhSY0+MgsTo/zy/B51mg5WjQcKTpLsQmRgbcfdBCvEp6QRHxlPf1zC/ZCGEMJQnDQ+dPHkyU6ZMyfdxjx49irW1dQGjEsKw5HMhhChy2nSIvqYm1ZEX4M4/aqIdHQLkMCp34xvwxn4wKUadhtp0OLYIbp9Uk2hdUn0PUuOfvH+LiZJ0l1T+rjbcikmSpFsI8VwKDw/XPV6zZg0ff/wxly5d0m2zsbHRPVYUBa1Wi4nJky9NLi4u+g1UiCIknwshRKHKyFAT6hsH4dZxNdG+exm0KTm3t3YB18rgWhVcK8Hf0yHqEhycA83GF23suYm+BhuGw82jubcxMgErp6w3a2ewcn743Lno4v0PSboLmb+rDXsu3yU4Mg/fvgghRAnj5uame2xvb49Go9Ft2717Ny1btuSPP/7gww8/5OzZs2zbtg0vLy/GjRvHoUOHSEhIoHLlysycOZM2bdrojvXfYbQajYYFCxawZcsW/vrrLzw9Pfnqq6/o0qVLkb5fIfJCPhdCCL1KT4Xw03DjAIQGqbfk2OztTK0eJtdV1FvpKmqibeOSvd2GYbD3C6jaDZz8iuZ95ERR4NQq+HOC2pttbg8N3wQ7z38l1Q8TbAt7KKYFGCXpLmT+ruq31cF3JekWQuiXoigkpRlmmSlLU2O9VRZ+//33+fLLLylXrhylSpUiLCyMF198kU8//RRzc3OWL19O586duXTpEmXLls31OFOnTuXzzz/niy++4LvvvqN///7cuHEDR0cZZfQ8kc9FVvK5EKIESk1Qe3xvBKmJ9s1jkJ6UtY2ZDXjVB68XwK2ammQ7eINRHupoV+8Fp1bCtd2w5R14daNhktmk+/DbGDi/SX1ethF0/xEccv8/r7gyaNI9c+ZMNmzYwMWLF7G0tKRRo0bMmjWLihUr5rrP0qVLGTx4cJZt5ubmJCcn654risLkyZNZsGABMTExNG7cmHnz5lG+fPlCey+5yUy6r0pPtxBCz5LStFT5+C+DnPv8tECszPRzCZk2bRpt27bVPXd0dKRmzZq655988gkbN25k8+bNjBo1KtfjDBo0iH79+gEwY8YM5syZw5EjR2jfvr1e4hTPBvlcZCWfCyHyKDkWgneAb3O197S4uX0Kzq1Xh4yHn4KM9KyvWzqCdyP1VrYhuNUA4wL+f6TRQMev4YeGcG0XnP0FavR62neQPyF71XnlcbfUYeMtJkKTsWBkXLRx6IlBk+49e/YwcuRI6tWrR3p6OpMmTaJdu3acP3/+sYVA7Ozsssx9+u+3yp9//jlz5sxh2bJl+Pr68tFHHxEYGMj58+exsLAotPeTEz8XNem+FZNEQko61uYyuEAIIf6tbt26WZ7Hx8czZcoUtmzZQnh4OOnp6SQlJREaGvrY49SoUUP32NraGjs7OyIjIwslZiEKm3wuhCgi6alwfAnsmaUW5DK3g6bjoMEIMC3avCFXp36GzaOyJtp2nv9KshuBS0X99kY7+UHzd9X53X9NhPJtwLKU/o6fm/RU2PUpHPgWUMDRD3osAM86hX/uQmTQDHDr1q1Zni9duhRXV1eOHz9Os2bNct3v33Of/ktRFGbPns2HH37ISy+9BMDy5cspXbo0mzZtom/fvvp7A3ngaG2Go7UZ0QmpXLubQPUy9kV6fiFEyWVpasz5aYEGO7e+/PdL1vHjx7N9+3a+/PJL/P39sbS0pGfPnqSmpj72OKamplmeazQaMjIy9BaneDbI5yIr+VwIkQtFgfO/ws6papEuUIdkp8TBjilwdDG0mQzVehhunrCiwL4v1cQXoHw7NZ6yDdUh1oUdV6O34cw6tajajinQ+dvCPd/dy7DhNXV+OkDtARA4E8xtHr/fM6BYdbvGxqoT/p80zyg+Ph5vb28yMjKoXbs2M2bMoGrVqgCEhIQQERGRpbCIvb09DRo0ICgoqMiTbgB/FxuOJEQTfPeBJN1CCL3RaDR6G8panBw4cIBBgwbRrVs3QP0///r164YNSjwz5HMhhHii0EOw7SO4eUR9bu0KLSdCwCvwzwbYMRViQ2H9UDg8HwJnqPOji5I2Hf4Yr/bCAzQeA60n521Otr6YmEHn2bCkAxxfCjX7QdkX9H8eRVHf59ZJ6tx0y1LQ5Tuo3Fn/5zKQIvytPV5GRgZjxoyhcePGVKtWLdd2FStWZPHixfz666+sWLGCjIwMGjVqxM2bNwGIiIgAoHTp0ln2K126tO61/0pJSSEuLi7LTZ/8dPO6E/R6XCGEKInKly/Phg0bOHXqFKdPn+bll1+Wnjnx3JPPhRB6EBUMq/vD4kA14Ta1gubvw1snoO4QNcms2RdGH4eWH4KptVqwbFFbWDcI7l8vmjhTE2DNKw8Tbg28+CW0nVq0CXcm70ZQ61X18W9j1OHf+pQQBatfht/Hqgl3uRYwIqhEJdxQjJLukSNHcu7cOVavXv3Ydg0bNmTAgAEEBATQvHlzNmzYgIuLCz/++GOBzz1z5kzs7e11Ny8vrwIfKye6CuZSTE0IIZ7o66+/plSpUjRq1IjOnTsTGBhI7dq1DR2WEAYlnwshnkL8XdgyHn5oABd/B40R1B4Ib51Ue7jNbbO2N7NS5zO/dUId4owG/tkI39dTe8iTYgo31mWd4fKfYGIBfVZA/WGFd768aDtNXeP67gUI+k5/xw3eAfMawaU/wNgM2n0Kr2wEO3f9naOY0CiKohg6iFGjRvHrr7+yd+9efH19871/r169MDEx4eeff+batWv4+flx8uRJAgICdG2aN29OQEAA336bfS5CSkoKKSmPFouPi4vDy8uL2NhY7OzsCvSe/m3P5bsMXHwEf1cbdoxr/tTHE0I8f5KTkwkJCcHX17fIC0KKwvW4321cXBz29vZ6ux49qx73c5DPRsklv1vx1FIT4dBc2P8tpD5Qt1VoD22mqOtV51XEOdj2gbqEFqiVwltOgjqDwNj0cXvmz72rsKIH3A9Rh1j3WwNlG+jv+E/j9BrYOFz9IuDNQ+CY/5xNJyMDds+EvZ+rz10qQY+F4FZdP7EWooJelw3a060oCqNGjWLjxo38/fffBUq4tVotZ8+exd1d/UbE19cXNzc3du7cqWsTFxfH4cOHadiwYY7HMDc3x87OLstNnzJ7uq9HJZCmlaFgQgghhBBCFJoMLZxcAd/VUYuQpT4A9wAY+Bu8vCZ/CTeo61y/ugleXgfOFSEpWp1v/UNDuLRVnZP8tG4eU4ex3w9R19Meur34JNwANXqry6mlJ6trdxf0PSfdh5/7PEq4670Gw3c/Ewn30zBo0j1y5EhWrFjBqlWrsLW1JSIigoiICJKSHi3uPmDAACZOnKh7Pm3aNLZt28a1a9c4ceIEr7zyCjdu3OC1114D1AIqY8aMYfr06WzevJmzZ88yYMAAPDw86Nq1a1G/RQA87C2wMjMmPUPhxr1Eg8QghBBCFAYfHx80Gk2228iRIwG1t3LkyJE4OTlhY2NDjx49uHPnjoGjFkIYRHwkxN0u3HNEXoBF7eDXkfDgNtiXhe4LYdgu8M19daQn0migQjsYcRA6fgVWTnDvippAzmsEuz+DO+cLloxe+hOWdlKXLHMPUBNu5/IFj7UwZK7dbWwOV3eqa4bn153z8FNLuLJN7THv9pP6szS11H+8xYxBy3vOmzcPgBYtWmTZvmTJEgYNGgRAaGgoRv8qGnD//n2GDRtGREQEpUqVok6dOhw8eJAqVaro2kyYMIGEhASGDx9OTEwMTZo0YevWrQYbmqTRaPBzseHsrViCI+N1Pd9CCCHEs+7o0aNotVrd83PnztG2bVt69eoFwNixY9myZQvr1q3D3t6eUaNG0b17dw4cOGCokIUQhnBuA/w6CrQpUP91aPEeWOhxVR9tGhyYDXs+B22qut528wlQb5h+19s2NlF7Z6v3gn1fw6F5EHleve2eCU7+ULkLVOmiJtBPWtbr2OKHPccZ4N8Wei0tvktkOftDs/HqOtpbJ4J/G7B0yNu+5zaoX4SkJapfhPT5H3gEFGa0xUqxmNNd3BTGHLqxa06x8eQt3g2syMiW/no5phDi+SFzG0uukjane8yYMfz+++9cuXKFuLg4XFxcWLVqFT179gTg4sWLVK5cmaCgIF54IW9Lz8ic7ueT/G5LCG06/D0NDvynrpK1izq3uubLT1+VO/y0mtBFnFWfV2gPnb4BO4+nO25eJEbD5a1wfjNc/Vv9UiGTQ1k1Aa/cBcrUy/o+FQX+/gT2faU+r/UKdJqt3znihSE9BeY3gajLasX3Tt88vr02XV0L/eAc9Xm5FtBjMVg7FXqoheGZnNP9PPFzsQakgrkQQoiSKzU1lRUrVjBkyBA0Gg3Hjx8nLS2NNm3a6NpUqlSJsmXLEhQUlOtxCnspTyFEEUmMhpU9HiXcjUar86Kd/CHhrpooL2ytzmcuiPQU2PmJOmQ54qxafKz7Qui3umgSbgArRwh4GV5eDROuQo9FUOUldTmymFAI+h4Wt4NvqqgV1EP2QloSbBrxKOFuMRG6fF/8E24AE/NHifaxxRB2JPe2CfdgRfdHCXfjt6H/+mc24X4aBh1e/jyRZcOEEEKUdJs2bSImJkY3RSwiIgIzMzMcHByytCtdujQRERG5HmfmzJlMnTq1ECMVQhS68NOw+hWIDVUT0Je+h2o91NfKtYDD89Wh4LdPqIl3QH9oPRlsS+ft+DePqUn73Yvq8ypd4cUvwMa1MN5N3pjbQvWe6i01UZ37fH6z2hP+IByOLlBvxmbqEHiNMXT+Fmq/ariYC8KnCQS8AqdWwG9vw+t7s39hcPsUrHn14e/f+uHvv7tBwi0OpKe7iGQm3VfvxiMj+oUQQpREixYtokOHDnh4PF0P08SJE4mNjdXdwsLC9BShEKJInF6tFjOLDYVSPvDajkcJN4CJGTR+C0YfV5NtgFMr1WrjB7+D9NTcj52aCH99oFb6vnsRrF2h93LovcywCfd/mVlB5c7QYwG8G6z28Nd6RV1uTJuqJqIvr3n2Eu5M7T5Ri8lFnld78//t1M+wOPDh79/34e//+U24QXq6i4y3kzUmRhoSU7WExybj4VDyq/QJIYR4fty4cYMdO3awYcMG3TY3NzdSU1OJiYnJ0tt9584d3Nzccj2Wubk55ubmhRmuEKIwaNNg24dqLzaohcF6LFCHfefEtjR0/UGdG/zHu2qv97YP4cRyaP8Z+LfO2v76ftg8GqKvqc9r9oPAGeoQ7+LMxFytfF6hHXRKh5tHwNb96da6NjQrR2j3KWx6A3bPgqrdwM4T/poER35S25RvB90X5L3YWgkmPd1FxNTYCG8nK0CGmAshhCh5lixZgqurKx07dtRtq1OnDqampuzcuVO37dKlS4SGhtKwYUNDhCmEKCzxkbD8pUcJd7N31Z7c3BLufytTF17bCS/NVQusRV1W5wL//DJEh0DKA7XC99KOasJt56n2HHebX/wT7v8yNgHvRs92wp2pZl/waQrpSeqXIcu6PEq4m78H/dZIwv2QJN1FSOZ1CyFE/rVo0YIxY8bonvv4+DB79uzH7qPRaNi0adNTn1tfxynpMjIyWLJkCQMHDsTE5NEgOnt7e4YOHcq4cePYtWsXx48fZ/DgwTRs2DDPlctFzuRzIYqVm8fgx+Zw4wCY2UKfldDqQzAyzvsxjIzU4dejj0PDUWBkApe2wNwG8H09OLpQbVdnELwZpPYaC8PSaNSiasZmaoG40IPq77/vKmg56emr0pcg8pMoQrqk+64k3UKI50Pnzp1p3759jq/t27cPjUbDmTNn8nXMo0ePMnz4cH2EpzNlyhQCAgKybQ8PD6dDhw56PVdJtGPHDkJDQxkyZEi217755hs6depEjx49aNasGW5ublmGoD+P5HMhSpTjy2BJB3hwG5wrwLC/oXKngh/Pwh4CP4URB6FcS3UJrgfh4OANA35VC4/pc31v8XScy0OzCQ8fV4Dhu6BSx8fv8xySOd1FSHq6hRDPm6FDh9KjRw9u3rxJmTJlsry2ZMkS6tatS40aNfJ1TBcXF32G+FiPm3csHmnXrl2uRUItLCyYO3cuc+fOLeKoii/5XIgSIT0F/pwAx5eqzyt1gq7zwCLvaxc/lktFeHUjXNn2aE1oM2v9HFvoV7Px6vx7l0pqATmRjfR0FyF/F1sArkrSLYR4TnTq1AkXFxeWLl2aZXt8fDzr1q2ja9eu9OvXD09PT6ysrKhevTo///zzY4/532G0V65coVmzZlhYWFClShW2b9+ebZ/33nuPChUqYGVlRbly5fjoo49IS0sDYOnSpUydOpXTp0+j0WjQaDS6eP87jPbs2bO0atUKS0tLnJycGD58OPHxj/5PHzRoEF27duXLL7/E3d0dJycnRo4cqTuXECCfC/lclADJcbC008OEW6MOJe/9P/0l3Jk0GqgQqK7vLQl38aXRgGdtSbgfQ3q6i1A5F/U/i3sJqdxPSKWUtZmBIxJCPNMUBdISDXNuUyv1IvsEJiYmDBgwgKVLl/LBBx+gebjPunXr0Gq1vPLKK6xbt4733nsPOzs7tmzZwquvvoqfnx/169d/4vEzMjLo3r07pUuX5vDhw8TGxmaZ55rJ1taWpUuX4uHhwdmzZxk2bBi2trZMmDCBPn36cO7cObZu3cqOHTsAdS7yfyUkJBAYGEjDhg05evQokZGRvPbaa4waNSpL8rRr1y7c3d3ZtWsXwcHB9OnTh4CAAIYNG/bE9yP0QD4X8rkQhUubDr8MVitwW9hDj0VQvq2hoxKiWJOkuwhZm5vgYW/B7dhkgu/GU8/6Gau2KIQoXtISYcbTrYdcYJNu57nXYciQIXzxxRfs2bOHFi1aAOoQ2h49euDt7c348eN1bUePHs1ff/3F2rVr85Rc7Nixg4sXL/LXX3/p1oaeMWNGtvmmH374oe6xj48P48ePZ/Xq1UyYMAFLS0tsbGwwMTF57LDZVatWkZyczPLly7G2Vt/7999/T+fOnZk1axalS5cGoFSpUnz//fcYGxtTqVIlOnbsyM6dOyW5KCryuZDPxfMsZC+c/QUavA6lq+r/+IqiDikP3gEmlvDqJrWHUwjxWDK8vIj5ybxuIcRzplKlSjRq1IjFixcDEBwczL59+xg6dCharZZPPvmE6tWr4+joiI2NDX/99RehoaF5OvaFCxfw8vLSJRZAjktRrVmzhsaNG+Pm5oaNjQ0ffvhhns/x73PVrFlTl1gANG7cmIyMDC5duqTbVrVqVYyNH1XsdXd3JzIyMl/nEiWffC7kc6FXcbfhlyGwrDOcWKYurRVxVv/nOTwfji0CNNBjoSTcQuSR9HQXMX9XG/ZdiZJ53UKIp2dqpfasGerc+TB06FBGjx7N3LlzWbJkCX5+fjRv3pxZs2bx7bffMnv2bKpXr461tTVjxowhNTVVb6EGBQXRv39/pk6dSmBgIPb29qxevZqvvvpKb+f4N1NT0yzPNRoNGRkZhXIukQP5XOSJfC5KCG2amgjv/gxS40FjBHZlIDZUXTN50O/66/G+9Cdsnag+bjvt6SqUC/GckaS7iMmyYUIIvdFonpnCMr179+btt99m1apVLF++nBEjRqDRaDhw4AAvvfQSr7zyCqDORb18+TJVqlTJ03ErV65MWFgY4eHhuLu7A3Do0KEsbQ4ePIi3tzcffPCBbtuNGzeytDEzM0Or1T7xXEuXLiUhIUHXq3fgwAGMjIyoWLFinuIVRUA+F/K5eF6E7IU/3oW7F9XnZepDxy/VpbX+1xVun3yUeLtWfrpzhZ+GX4YCirpOdqPRTxm8EM8XGV5exPxdZHi5EOL5Y2NjQ58+fZg4cSLh4eEMGjQIgPLly7N9+3YOHjzIhQsXeP3117lz506ej9umTRsqVKjAwIEDOX36NPv27cuSRGSeIzQ0lNWrV3P16lXmzJnDxo0bs7Tx8fEhJCSEU6dOERUVRUpKSrZz9e/fHwsLCwYOHMi5c+fYtWsXo0eP5tVXX9XNWxUiP+RzIQokLlxNgJd1VhNuKyd4aS4M+Qvca4Klg7rUlntNSIxS20VefIrz3YZVfSEtAcq1gBe/zFPBQCHEI5J0F7HMnu5bMUkkpT7+22MhhChJhg4dyv379wkMDNTNNf3www+pXbs2gYGBtGjRAjc3N7p27ZrnYxoZGbFx40aSkpKoX78+r732Gp9++mmWNl26dGHs2LGMGjWKgIAADh48yEcffZSlTY8ePWjfvj0tW7bExcUlx+WZrKys+Ouvv4iOjqZevXr07NmT1q1b8/333+f/hyHEQ/K5EHmmTYOD38H3deHcL+pQ8nqvwejjUOsVMPrXn/WWpdQiZ27VIeHuwwT9cv7PmRIPq/rAg9vqGsy9loGx6ZP3E0JkoVEURTF0EMVNXFwc9vb2xMbGYmen5/UGgVrTtnE/MY3fRzehmmf25TeEEOK/kpOTCQkJwdfXFwsLC0OHI/Tocb/bwr4ePSse93OQz0bJJb/bfwnZB3+M/9dQ8npqj7NHwOP3S4xWh5jfOQs2bjBoCzj75+2cGVpY8wpc+gOsnGHYTijl8zTvQohnXkGvy9LTbQCZvd1XZV63EEIIIYTITVw4rH8NlnV6NJS8y/cwZNuTE24AK0cY8Cu4VoX4CPU4967m7dzbP1YTbmNz6PezJNxCPAVJug3AX5YNE0IIIYQQj3PpT/i+HpxdB2ig7lAYdQxqv5p1KPmTWDvBwM3gUhkehMPSThB97fH7HF0EQQ+nCHSbB15PXh9eCJE7SboNwE+KqQkhhBBCiNxkZMCfEyD1AXjWgeG7oNPXas91QVg7q4m3c0V1fvbSznD/es5tg3eoVdEBWn0I1XoU7JxCCB1Jug3AT3q6hRBCCCFEbq7vg5hQMLeDgb+DR62nP6aNKwz8DZzKQ9zNh4l31mXiuHMe1g0GRQs1+0HT8U9/XiGEJN2GkLls2PV7CaRrMwwcjRBCCCGEKFZO/k+9r94TzKz0d1zb0mri7egHsaHqHO+YMPW1+Ei1UnlKHHg3hs7fytJgothRFIWMjGevDriJoQN4Hnk6WGJpakxSmpbQ6ETKPUzChRDiSTIy5Iu6kkYWEdEP+WyUPM/t7zTpPpzfrD6u9Yr+j2/nDoN+h6Ud1bndyzrBKxtgw3A1EXf0gz4rwMRc/+cWooDuxCWz8tANVh0JIy45jTIOlniWsqRMKSu8HB/eP3zubGOGpph9YSRJtwEYGWko52LNP7fjCI6Ml6RbCPFEZmZmGBkZcfv2bVxcXDAzK34XFJF/iqJw9+5dNBoNpqay9m1ByGej5FEUhdTUVO7evYuRkRFmZmaGDqlonVsP2hRwrQIetQvnHHYe6rD1pS+qc7vnNoCMNHV97/7rCj53XAg9UhSFE6ExLD14nT/PhpP+rx7ua1EJXItKyHE/C1OjLEl4ZlLe2M8ZeyvDXGsl6TYQf1cbNem+G087QwcjhCj2jIyM8PX1JTw8nNu3bxs6HKFHGo2GMmXKYGxsbOhQnkny2Si5rKysKFu2LEb5qdRdEpx4OLS81quFO7zb3vNh4t0RYm6AkSn0WQlOfoV3TiHyICVdy++nw1kWdJ0zN2N12+v7ODKwkQ/VPe25GZPIzegkbt5P5Ob9JMIe3kfEJZOclkFwZHy2+llb3mqCvZV9Ub8dQJJug/GXCuZCiHwyMzOjbNmypKeno9VqDR2O0BNTU1NJuJ+SfDZKHmNjY0xMTJ6/UQsRZyH8lJoA1+hT+Odz8FKHmu+eBVW6gE/jwj+nELl4NIQ8lKj4VADMTIx4qaYHAxv5UM3zUcJc1skKcvh+KCVdS3hM8r8S8YdJeXQiZUrpsT5CPknSbSCZa3VflaRbCJEPmcOQZSiyEFnJZ0OUCCdXqPeVXlTX1y4KDmWh69yiOZcQ/5HbEHJ3ewteecGbvvW8cLLJe30BcxNjfJyt8XG2LqyQC0SSbgPRJd13E1AU5fn7JlcIIYQQQjySngJn1qiPa71q2FjEcytNm0F4TDIZioKRRoNGo9ajMtKAhof3GvXeSKPBSKMBjToTIl2rkKbNIDU9g9SH99mfP2oTm5TG+hM3cxxC3q5qaUyNS87UEoMm3TNnzmTDhg1cvHgRS0tLGjVqxKxZs6hYsWKu+yxYsIDly5dz7tw5AOrUqcOMGTOoX7++rs2gQYNYtmxZlv0CAwPZunVr4byRAvB2ssbYSEN8SjoRccm421saOiQhhBBCCGEoF7eolcttPcCvlaGjEc8BbYbCtbvxnLkZy5mbMZy5Fcv523GkpBftygG5DSEvSQyadO/Zs4eRI0dSr1490tPTmTRpEu3ateP8+fNYW+c8JGD37t3069ePRo0aYWFhwaxZs2jXrh3//PMPnp6eunbt27dnyZIluufm5sVr2QMzEyO8Ha24FpVAcGS8JN1CCCGEEM+zzKHlAS+DkdR5EPqlKAo37iVy5lYsZ2/GcPpmLP/ciiUhNXsdDAtTI0yNjMhQFDIUyFAUlIf3mdtyY2ykwdRYg5mxEWYmRpgZG2Gaef+vbWYm6q2Od6l8DyF/Fhk06f5vz/PSpUtxdXXl+PHjNGvWLMd9Vq5cmeX5woULWb9+PTt37mTAgAG67ebm5ri5uek/aD3yc7XRJd1Ny7sYOhwhhBBCCGEIMWFw9W/1ca3+ho1FPDPStRkkpGpJSEknISWd+JR0ElK0JKSm67aFxybrerLjktOzHcPKzJhqHvZUL2NPjTL21CjjgLejFUZGj5/6quSQkJsaG2H8hP2eV8VqTndsrDqe39Ex72sDJiYmkpaWlm2f3bt34+rqSqlSpWjVqhXTp0/HyamIClLkkb+rDdvP3+HqXSmmJoQQQghR7KUlw8991Ori/X4GYz0V7jv9M6CAT1NwLKefY4oS43RYDMuDbnA+PC5Lgp3fYeBmxkZU9rCjZhl7qnvaU9PLAT8XmwIlyhqNBmMNGCNJdl4Um6Q7IyODMWPG0LhxY6pVq5bn/d577z08PDxo06aNblv79u3p3r07vr6+XL16lUmTJtGhQweCgoJyXJYlJSWFlJQU3fO4uLinezN5JMuGCSGEEEI8Q/Z/A9d2q4+D5kKTMU9/zIwMOPmvtbmFQC1otvVcBEsOhHAiNOaxbU2NNVibm2BtZoKNuQlW5sbYPHzuaGNGNQ+1F7tCaVvMTEpOcbJnSbFJukeOHMm5c+fYv39/nvf57LPPWL16Nbt378bCwkK3vW/fvrrH1atXp0aNGvj5+bF7925at26d7TgzZ85k6tSpT/cGCiCzgnlwZEKRn1sIIYQQQuTDvauw/+tHz/fMgmrd1SW3nsb1fRATCuZ2ULnz0x1LPPOiE1L5+Ugo/wu6QURcMqAm1Z1qeNCphjsOVqbZEmxzE6kBUNwVi6R71KhR/P777+zdu5cyZcrkaZ8vv/ySzz77jB07dlCjRo3Hti1XrhzOzs4EBwfnmHRPnDiRcePG6Z7HxcXh5eWVvzdRAH4Pk+6o+BRiE9Owt5K1RYUQQgghih1FgS3jQJsK5Vqqy3uFHoQ/31OHmT+NzF7u6j3BzOrpYxXPpAvhcSw9cJ1Np27pho0725jRv4E3/V8oi6utxROOIIozgybdiqIwevRoNm7cyO7du/H19c3Tfp9//jmffvopf/31F3Xr1n1i+5s3b3Lv3j3c3d1zfN3c3Nwg1c1tzE1wt7cgPDaZ4LsPqOOd97nsQgghhBCiiJxbrw4rNzaHjl+pyff8JnDpD7j4B1R6sWDHTboP5zerj2u9ordwxbNBm6Gw48IdlhwI4dC1aN326p72DG7sQ8ca7tKLXUIYNOkeOXIkq1at4tdff8XW1paIiAgA7O3tsbRUl9AaMGAAnp6ezJw5E4BZs2bx8ccfs2rVKnx8fHT72NjYYGNjQ3x8PFOnTqVHjx64ublx9epVJkyYgL+/P4GBgYZ5o4/h72qjJt2R8ZJ0CyGEEEIUN8mx8Nck9XHTceDkpz5uOAoOzIY/J0C55mCW83K3j3X2F9CmgGtV8Kitt5BF4UvTZnD8xn0OXbtHanoGFqbGmJsYYWFqjIWp0cPnjx5nbjc3McbESMPWcxEsC7rOzftJgLrUVvtqbgxu5EMd71JoNFKgrCQxaNI9b948AFq0aJFl+5IlSxg0aBAAoaGhGBkZZdknNTWVnj17Ztln8uTJTJkyBWNjY86cOcOyZcuIiYnBw8ODdu3a8cknnxS7tboB/Fxs2HclSoqpCSGEEEIUR39/CvF3wNEPGo95tL35BDi3AWJDYc/n0LYA9YEy1+au9QpIklXs3YpJYs+lu+y5HMmB4HvEp2Rfgiu/HKxM6Ve/LK++4I2Hg6UeohTFkcGHlz/J7t27szy/fv36Y9tbWlry119/PUVURetRMTVJuoUQQgghipXbJ+HoAvVxx6/A9F/zas2s4cXP4ee+EPQ91OgDpavk/dgRZyH8lLr8WI0+eg1b6Edympaj16MfJtp3ufKfv9cdrc1o4u+Mo7UZKekZpKRpSU7XkpyWQXKa9uEtg5T0rPfJaVrKl7ZlYENvXgrwxNJMhpCXdMWikNrzzC9z2TBZq1sIIYQQovjI0MLvY0HJgGo9wK9l9jYVO0DFjnBpC2x5Bwb/kfce68xe7kovgrWT/uIWT+V6VAJ7LqtJdtDVeySlaXWvGWmgVtlSNK/gQouKLlTzsMeoAGtci+ePJN0GltnTffN+EslpWixM5ZsuIYQQQgiDO7ZY7ek2t4PAGbm36zALru1Sq5mfWgW1+j/52OkpcGaN+ljW5ja4uOQ0fj4cys9HQrl+LzHLa6625g+TbFea+DvLakOiQCTpNjBnGzPsLU2JTUrj2t0EqnjYGTokIYQQQojn24M7sPMT9XGrj8DWLfe2Dl7Q/D3YMRm2f6T2fls9oTjuxS1q5XJbD/Brpb+4Rb6ExyaxeH8IPx8J083PNjHSUNenFC0qutK8gguV3GylqJl4apJ0G5hGo8Hf1YbjN+4TfDdekm4hhBBCCEPb9gGkxIJ7ANQb+uT2DUfC6dVw94KafHf57vHtM4eWB7wMRjLKsahdCI9jwd5rbD59m/QMtcaUv6sNw5uW48Ua7tiYS4ok9Ev+RRUD/i4Pk24ppiaEEEKI513KA7i0FSp3AlMDVHO+thvOrgM00OmbvCXFxqZq2yXt4cRyCHgFyjbIuW1MGFz9W32cl6HoQi8UReFA8D1+2neNvZfv6rY38HXk9eblaFHBVeZni0IjSXdRUJTHFtXInNd9VZJuIYQQQjzv/ngXTv8MVbpCr6VFu5RWeopaEA2g3mvgmY+1s70bqsn2qRWwZRwM3wPGOfypffpnQAGfpuBYTi9hi9ylaTP442w4P+29xj+34wC1IFqH6u4Mb1qOml4Ohg1QPBck6S5MqYmwaQTcPAqjjoGZVY7NZNkwIYQQz7Jbt27x3nvv8eeff5KYmIi/vz9Lliyhbt26gNrDNHnyZBYsWEBMTAyNGzdm3rx5lC9f3sCRi2InJgzOrFUfn9+kJqgBLxfd+Q/MgXvBYO0KrT7M//5tp6mVzO+cg8PzodGorK9nZMDJ/6mPpYDaYyWlajlzM4bjofcJj0nGxsIEWwsTbC1MsbMwwc7CVPfc9uFr1mYmut7q+JR01hwNY/H+EG7FJAFgaWpMn3peDGnsS1mnnP8uF6IwSNJdmEwt4eYxiLsFN49AuRY5NstMukOiEkjXZmBibFSEQQohhBAFd//+fRo3bkzLli35888/cXFx4cqVK5QqVUrX5vPPP2fOnDksW7YMX19fPvroIwIDAzl//jwWFhaPObp47hyaB4pWrRieEqf2epd9oWh6hKOvwd4v1MftZ4KlQ/6PYe2kJt6bR8OuGVC1K9iXefT69X0QE6q+v8qd9RF1iRERm8zxG/cf3qL553acbr51Xmk0YGuuJuJxSWk8eFgczdnGjIENfXjlBW9KWZsVRvhCPJYk3YVJowGfJnBmNYTsyzXp9nSwxMLUiOS0DMLuJ+HrbF20cQohhBAFNGvWLLy8vFiyZIlum6+vr+6xoijMnj2bDz/8kJdeegmA5cuXU7p0aTZt2kTfvn2LPGZRTCXdhxPL1Mc9FsGB2XDjAKwfBkO2qvOmC4uiqAm+NgV8m6vrchdUwCtqobSww7D1feiz4tFrmb3c1XvmOgLyeZCuzeBixIN/Jdn3db3R/+Zia05d71L4udiQkJrOg+R0NZlOTudBysP75HQeJKeRplVQFIhLTicuWU22yzlbM6xZObrV8pRleYVBSdJd2DKT7uv7c21iZKShnLMN58PjCI6Ml6RbCCHEM2Pz5s0EBgbSq1cv9uzZg6enJ2+++SbDhg0DICQkhIiICNq0aaPbx97engYNGhAUFJRj0p2SkkJKSorueVxcXOG/EWF4xxZDajy4VoXybcG1MsxrDLeOqT3QLScV3rnP/wrBO8DYDDp+/XTzyI2M1GP82Awu/AaXt0GFduqXCuc3q21qvaKfuJ8RqekZnAqL4UBwFEevR3MqLIbEVG2WNkYaqORmR12fUtTxLkXtsqUoU8oyT8t1KYpCSnoGcclpxCWpSbhGo6GGp70URxPFgiTdhc23qXp/6zikJoBZzgm1n+ujpLttldJFGKAQQghRcNeuXWPevHmMGzeOSZMmcfToUd566y3MzMwYOHAgERERAJQunfXaVrp0ad1r/zVz5kymTp1a6LGLYiQtGQ7/qD5u/Jaa9Dp4Qedv4JchatLt10odaq5vyXFqjzRAk7Hg7P/0x3SrBg3fhIPfwR/jwecQnP1F7Ul3rQoe+SjQ9gzKyFA4Hx7HgeAoDly9x9GQaJLSsibZtuYm1PIuRV1vNcmu6eVQ4KW6NBoNFqbGWJga42qrj3cghH5J0l3YHLzB3gtiwyDsCPi1zLGZv8vDCuZ3pZiaEEKIZ0dGRgZ169ZlxowZANSqVYtz584xf/58Bg4cWKBjTpw4kXHjxumex8XF4eXlpZd4RTF1Zg3E3wG7MlmHdlfrAVe2qwXV1g+DEfvBwl6/5949Ex6EQylfaDLuye3zqvn7cG4jxNyAfV9C8E51e61XirYiexFQFIVrUQkcDI7i4NV7BF27R0xiWpY2TtZmNPRzoqGfE3W9HSnvaiO90OK5IUl3Ycuc1336Z7V4Rm5Jt1QwF0II8Qxyd3enSpUqWbZVrlyZ9evXA+Dm5gbAnTt3cHd317W5c+cOAQEBOR7T3Nwcc3PzwglYFD8ZGWqPMMALI7LP3e7wOYQGwf3rsGU89Figv3OHn1GrjAN0/BJM9VjYz9wGOnwGa16B/bPVAnFGplCjj/7OYSAZGQq3YpI4EhLNgatRHAy+R0RccpY2NuYmNPB1pJG/M439najgaitJtnhuSdJdFHRJd+7zuv+9VreiKHmavyKEEEIYWuPGjbl06VKWbZcvX8bb2xtQi6q5ubmxc+dOXZIdFxfH4cOHGTFiRFGHK4qjy1vh3hUwt4c6OYyOsLCD7gtgcXs4u1ad712j99OfNz1VXU9byVDXBPdv88Rd8q1SJ6jQXn2PAJVeVCucPwMURSEqPpWQqARCouIJiUp8eJ/A9XuJpKZnZGlvZmxEbW8HGvs508jfmRpl7DGVFXmEACTpLho+T57X7eNshZEGHqSkE/kghdJ2soSKEEKI4m/s2LE0atSIGTNm0Lt3b44cOcJPP/3ETz/9BKhzLceMGcP06dMpX768bskwDw8PunbtatjgRfFw4Fv1vt4QMM9lQq5XfWj+HuyeAVveAa8GUMq74OeMvga/DIXbJ8DMVl0irDBoNGpP/bU9kJ4EtQYUznmegqIoXIx4wOU7D7h2N+Fhkp3A9agE3ZJbOTE11lDF3U7tyfZzpo53KSzNpEK4EDmRpLsolPIG+7IQG6ouH+HXKlsTcxNjvJ2sCYlKIDgyXpJuIYQQz4R69eqxceNGJk6cyLRp0/D19WX27Nn0799f12bChAkkJCQwfPhwYmJiaNKkCVu3bpU1uoVa7ybskFo1vMEbj2/b9B24ulP9W2rDcBi0BYwL8KfsmbXw+zhIfQAWDtBjIdh5FCj8PCnlDf3Xwr1g8G9deOfJJ22GwrZ/Ivhx7zVOhcXk2EajUZe29XW2znIr52yDh4MFJtKTLUSeSNJdVHyawOlV6nrdOSTdAH4uNrqku7G/cxEHKIQQQhRMp06d6NSpU66vazQapk2bxrRp04owKvFMyOzlrtEbbN0e39bYBLr/BPOaqIn6/m+g+bt5P1dKvFpJ/PTP6vOyjdT54fZlChZ7fvg2U2/FQHKall+O32Thvmtcv5cIgJmJEQFlHNSk2sUaHydryrlYU9bRSta3FkIP8pV0X7hwgdWrV7Nv3z5u3LhBYmIiLi4u1KpVi8DAQHr06CGFT3KTmXQ/YV73jgt3pJiaEEIIIUq+qGC4uEV93OitvO1Tygc6fgUbh6tVx/1aQpm6T97v9il16bHoq6AxUoeqNx1fsJ7yZ9T9hFT+d+gGyw5e515CKgD2lqYMaOjNgIY+uNjK3/BCFJY8/U9z4sQJJkyYwP79+2ncuDENGjSgW7duWFpaEh0dzblz5/jggw8YPXo0EyZMYMyYMZJ8/5dPE/X+9gn1m1Zzm2xNpIK5EEIIIZ4bQd8BClToAC4V875fjd5wZRuc+wXWvwZv7Mt9LriiwKEfYPtkyEgDO091OLl3I728hWdBWHQii/aHsOZomG6tbE8HS15r6kvvul5YF3BtbCFE3uXpU9ajRw/effddfvnlFxwcHHJtFxQUxLfffstXX33FpEmT9BVjyVDKGxzKQszDed05zOnRJd2yVrcQQgghSrL4SDj1cJh34zz2cmfSaNTe7rAjcD8E/nwfus7N4Rx34dc31QQd1EriXb4DK8eni/0Zce5WLD/uvcYfZ8PRZigAVPWwY3izcnSs7i7zsYUoQnlKui9fvoypqekT2zVs2JCGDRuSlpb21IGVSD5N4dRKdb3uHJLuci5qVfO7D1KITUrD3vLJP3MhhBBCiGfO4R9BmwJl6kHZhvnf39IBuv8ISzvCqRVQvg1U7fbo9Wu71WJr8XfAxAICZ0DdIWrCXkIpikJccjonQu+zcN81DgTf073WtLwzrzfzo7G/kyxLK4QB5Cnp/nfCfe3aNcqVK5fn9uJffJo8TLpzntdtZ2FKaTtz7sSlcPVuPLXLliriAIUQQgghCllKPBxdqD5u9FbBE2HvRmpF871fwG9vqwm8TWnY9Snsnw0o4FIJei6B0lX0Fb3BJKdpiYhN5nZsErdjkgmPSeJ2bBK3Mh/HJJGQqtW1NzbS0LmGO8OalaOqh70BIxdC5HsSh7+/P82bN2fo0KH07NlTlvvIj8x53bceP6/7TlwKwZGSdAshhBCiBDr5P0iOAcdyUKnj0x2r+Xtw9W+4dVxddzsjHW4dU1+rM1jt4TazeuqQi9qD5DQ2n77NvstRD5PsJKLiU/O0r7ONGV1qejKkiQ9lSj17712IkijfSfeJEydYsmQJ48aNY9SoUfTp04ehQ4dSv379woivZHEoCw7eEHNDXerCv022Jv4uNhwIvsdVKaYmhBBCiJJGmw5BP6iPG40Go6dcjsrYFLovgPlN1b+tACzs1bnbVV56umMXMUVROBUWw89HQvn9TDiJ/+q1zmRpaoy7gwWeDpa421vg4WCp3uwt8XCwwN3eEkszWeJLiOIm30l3QECArlja5s2bWbp0KU2aNKFChQoMGTKEV199FRcXl8KItWTwaQqnbqjrdeeUdEsFcyGEEEKUVOc3QWwoWDlDzX76OaaTH3T6BjaNUIeY91igdnQ8I2IT09h48iarj4ZxMeKBbrufizU96pShvKstHg4WeNhb4mBlKnOyhXgGFXiNABMTE7p3707Hjh354YcfmDhxIuPHj2fSpEn07t2bWbNm4e7urs9YSwafJmrBj1zmdftJBXMhhBBCFDfJsbDpTbh/A9pOzbEg7BMpChyYrT5u8DqYWuovvpp9oEI7sHB4JoqlKYrCkZBoVh8N44+z4aSkZwBgbmJExxru9KtflrrepSTBFqKEKHDSfezYMRYvXszq1auxtrZm/PjxDB06lJs3bzJ16lReeukljhw5os9YSwbdet0nIeVBtnUlM3u6w6ITSU7TYmEqQ4SEEEIIYUBx4bCyJ9w5pz5f0R2q91LnS9u45v0413ZDxFkwtYJ6r+k/TsviXwvnXnwKG07c4uejoVy7m6DbXsnNlpcblOWlAE9ZvUaIEijfSffXX3/NkiVLuHTpEi+++CLLly/nxRdfxMhIXevP19eXpUuX4uPjo+9YSwYHLyjlA/evQ+hhdYmLf3GxMcfOwoS45HRCohKo7G5nkDCFEEIIIbh7CVb0gNgwsHaFih3UQmhn16nrX7edBrUGgFEe1nw+OEe9r/Xqc7NWNqi92odDovnfoRts+yeCNK26ZraVmTFdanrQt35Zapaxl15tIUqwPPwPmdW8efN4+eWXuXHjBps2baJTp066hDuTq6srixYteuKxZs6cSb169bC1tcXV1ZWuXbty6dKlJ+63bt06KlWqhIWFBdWrV+ePP/7I8rqiKHz88ce4u7tjaWlJmzZtuHLlSv7eaGHK7O2+vjfbSxqNhvKl1d7vIyHRRRmVEEIIIcQjoYdgUTs14Xb0g6HboMsceG0nuNVQh5z/9jYsfREiLz7+WOFn1CrjGmNoOLJo4jcwbYbCljPhdJ17gL4/HWLLmXDStAo1y9gzs3t1jnzQhs961CDAy0ESbiFKuHwn3VeuXGHixImPna9tZmbGwIEDn3isPXv2MHLkSA4dOsT27dtJS0ujXbt2JCQk5LrPwYMH6devH0OHDuXkyZN07dqVrl27cu7cOV2bzz//nDlz5jB//nwOHz6MtbU1gYGBJCcn5+/NFhafpup9LvO6O9VQf7bz91wlOS175UohhBBCiEJ14XdY/pK6tJdnXRi6HRx91dc8a8OwXdDuU3WoeGgQzG8Cf0+HtKScj3fwO/W+alco5V0U78BgktO0/O/QDVp9tZuRq05w+mYs5iZGvNygLFveasKvo5rQr35ZbMwLPMtTCPGM0SiKouR3p/v377No0SIuXLgAQOXKlRkyZAiOjk83VOju3bu4urqyZ88emjVrlmObPn36kJCQwO+//67b9sILLxAQEMD8+fNRFAUPDw/eeecdxo8fD0BsbCylS5dm6dKl9O3b94lxxMXFYW9vT2xsLHZ2hTC8O/YmfFNV/bb3vetgkfUcyWlaWnyxm4i4ZKZ0rsKgxr76j0EIIUSxV+jXo2eE/ByK2NGF8Me7oGRAhfbQc0nua13HhKptL29VnzuWg45fg1/LrG2+DQBFC8P3gEdAYb8Dg7ifkMryoBssC7pOdIK6praDlSkDGvowsKE3TjbmBo5QCPG0Cno9yndP9969e/Hx8WHOnDncv3+f+/fv89133+Hr68vevdmHS+dHbGwswGOT96CgINq0yToPOjAwkKCgIABCQkKIiIjI0sbe3p4GDRro2hicfRko5atefMIOZ3vZwtSYka38AZi7+ypJOazTKIQQQgihV4oCO6fBlnfUhLv2QOizMveEG9Slufqtht7/A1t3iL4G/+sKG4ZDQpTa5tA89W8e3+YlMuEOi05k8q/naPTZ33yz4zLRCamUKWXJ1C5VOfh+K8a1rSAJtxDPuXyPaxk5ciR9+vRh3rx5GBurlbW1Wi1vvvkmI0eO5OzZswUKJCMjgzFjxtC4cWOqVauWa7uIiAhKly6dZVvp0qWJiIjQvZ65Lbc2/5WSkkJKSorueVxcXIHeQ774NIH7IRCyF8q3zfZyn7pezN99lVsxSaw4dINhzcoVfkxCCCGEeD5p02DzW3B6lfq8xSRoPiFvy29pNFClC5Rrrg4xP7IAzqxRC621mATHl6ntGr9VePEbwNmbsfy49yp/nA0n4+G40aoedrze3I8Xq7lhYpzvvi0hRAmV7/8NgoODeeedd3QJN4CxsTHjxo0jODi4wIGMHDmSc+fOsXr16gIfo6BmzpyJvb297ubl5VX4J33CvG4zEyPeaq32ds/bc5WElPTCj0kIIYQQz5+UeFjVR024NcbQeQ60eC//611b2MOLX8BrO6B0NUi6D3++C2kJ6nO/AqztXcwoisLey3fpv/AQnb/fz+9n1IS7aXlnVr7WgN9HN6FLTQ9JuIUQWeT7f4TatWvr5nL/24ULF6hZs2aBghg1ahS///47u3btokyZMo9t6+bmxp07d7Jsu3PnDm5ubrrXM7fl1ua/Jk6cSGxsrO4WFhZWoPeRL5kVzMNPQXLOPevda5fB28mK6IRUlgVdL/yYhBBCCPF8iY+EpR3h6k4wsYS+q6DOk4vhPlaZujB8N7T9RC20BtBkbP6T+GIkXZvBr6du0XHOfgYsPsKB4HsYG2noGuDBlrea8L+hDWjs7yxVyIUQOcr38PK33nqLt99+m+DgYF544QUADh06xNy5c/nss884c+aMrm2NGjUeeyxFURg9ejQbN25k9+7d+Po+uWBYw4YN2blzJ2PGjNFt2759Ow0bNgTUdcLd3NzYuXMnAQEBgDpc/PDhw4wYMSLHY5qbm2NuXsRzbew91WIj0dfUJTkqtMvWxNTYiLdbl2fc2tP8tPcar77gja2FadHGKYQQQoiS6d5VWNEd7l8HKyd4ea2aMOuDsak6nLxaD3U6XWZnwzMmKVXL2mNhLNh3jZv31crslqbG9KnnxWtNfSlT6jHz3YUQ4qF8J939+vUDYMKECTm+ptFoUBQFjUaDVvv4AmAjR45k1apV/Prrr9ja2urmXNvb22NpaQnAgAED8PT0ZObMmQC8/fbbNG/enK+++oqOHTuyevVqjh07xk8//QSo61yPGTOG6dOnU758eXx9ffnoo4/w8PCga9eu+X27hcuniZp0X9+bY9IN8FKAJ3N3BXP1bgKL91/n7TblizhIIYQQQpQ4N4/Dql6QeA8cvOGVDeDsr//z2Huqt2fM/YejDJcdvM79xDQAHK3NGNTIh1df8KaUtZmBIxRCPEvynXSHhITo7eTz5s0DoEWLFlm2L1myhEGDBgEQGhqKkdGjUfCNGjVi1apVfPjhh0yaNIny5cuzadOmLMXXJkyYQEJCAsOHDycmJoYmTZqwdetWLCws9Ba7Xvg0hRPLc53XDWBspGFMmwqM/vkkC/dfY1AjH+ytpLdbCCGEEAUUHQLLu0BqPLjXhP6/gI2roaMqFm7eT2ThvhDWHA0jKU3tPPJytGRY03L0quOFpZnxE44ghBDZFWid7pKuyNYDjb0F31QBjdHD9brtc2yWkaHw4px9XIx4wKiW/owPrFh4MQkhhCg2ZH1qlfwc9EhRYFlnuL4PytSHVzeAua2hozK4C+Fx/LjnKr+dCUf7sBS5VCIXQvxXQa9H+e7pBrh69SqzZ8/WFVSrUqUKb7/9Nn5+fgU53PMr27zuwBybGT3s7X5jxXGWHAhhSBNfHGVYkxBCCCHy6/hSNeE2sYRu85/7hPvwtXv8sPsqey7f1W1r7O/EG839aCKF0YQQepLvpPuvv/6iS5cuBAQE0LhxYwAOHDhA1apV+e2332jbNvua0+IxfJqqSXfI3lyTboDAqqWp6mHHP7fj+HHvVSZ2qFyEQQohhCgpMjIy2LNnD/v27ePGjRskJibi4uJCrVq1aNOmTdEsmykMI/YmbPtIfdz6Y3B6fjtLgiPjmfHHBf6+GAmAkQY6VHfnjWZ+VC+T88hDIYQoqHwPL69VqxaBgYF89tlnWba///77bNu2jRMnTug1QEMo0mFsZ9bBhtfAPQBe3/PYpjsv3GHosmNYmhqzd0JLXGyLuOK6EEKIIqXP61FSUhJfffUV8+bNIzo6moCAADw8PLC0tCQ6Oppz585x+/Zt2rVrx8cff6xboaQ4kOHleqAosLIXBG9Xh5UP2QpGz9/85PsJqXy78worDt0gPUPBxEhD73pevN6sHN5O1oYOTwhRzBXZ8PILFy6wdu3abNuHDBnC7Nmz83s44aOOFiDiDCTFgKVDrk1bVXIlwMuBU2ExzNt9lY87VymSEIUQQjz7KlSoQMOGDVmwYAFt27bF1DR7Uc4bN26watUq+vbtywcffMCwYcMMEKkoFKd/VhNuY3N4ae5zl3CnpmewPOg6c3ZeIS45HYA2lV2Z+GJl/FxsDBydEKKky3dVCBcXF06dOpVt+6lTp3B1lcqX+WbnAY5+oGSo87ofQ6PRMK5tBQBWHL5BRGxyUUQohBCiBNi2bRtr167lxRdfzDHhBvD29mbixIlcuXKFVq1aFXGEotA8iICt76uPW7wPLhUMG08RUhSFbf9EEDh7L9O3XCAuOZ1KbrasfK0BCwfWk4RbCFEk8t3TPWzYMIYPH861a9do1KgRoM7pnjVrFuPGjdN7gM8F36YQfVUtbFKx/WObNi3vTD2fUhy9fp+5u4L5pGu1x7YXQgghACpXznstEFNTUymOWlIoCvw+DpJj1alsjd4ydERF5p/bsUz//QJB1+4B4Gxjzvh2FehV1wtjIymQJoQoOvlOuj/66CNsbW356quvmDhxIgAeHh5MmTKFt956fv4j1yufpo+qiT6B2ttdkX4LDrH6aCivNy9HmVJWhR+jEEKIEic9PZ0ff/yR3bt3o9Vqady4MSNHjsTCwsLQoQl9+WcDXNoCRqbqsHLjAi1c80yJjEvmy22XWHf8JooCZiZGDGvqy4gW/tiYl/z3L4QofvL1P096ejqrVq3i5ZdfZuzYsTx48AAAW9vne7mJp+b9cF53+JPndQM09HOikZ8TB6/eY+6uYGZ2r1HoIQohhCh53nrrLS5fvkz37t1JS0tj+fLlHDt2jJ9//tnQoQl9SIiCP95VHzcbD24le3RccpqWhfuu8cPuqySmagHoXNOD99pXlA4KIYRB5SvpNjEx4Y033tCtzy3Jtp7YuYOTP9wLhtAgqNjhibu8064CB+cFse7YTUY096esk1xMhBBCPN7GjRvp1q2b7vm2bdu4dOkSxsZqUa3AwMBiVbVcPKU/J0DiPXCtCk1K9hTAg1ejeHfdGW7FJAEQ4OXAR52qUMe7lIEjE0KIAhRSq1+/PidPniyMWJ5vPk3V+5AnDzEHqOPtSPMKLqRnKHy780ohBiaEEKKkWLx4MV27duX27dsA1K5dmzfeeIOtW7fy22+/MWHCBOrVq2fgKIVeXPgdzq0HjTF0nQsmZoaOqFBkZCh8//cVXll4mFsxSXjYW/Bt3wA2vtlIEm4hRLGR74ktb775Ju+88w43b96kTp06WFtnXdOwRg0Z6lwgPk3g+JI8zevONLZtBfZcvsvGkzd5s6WfVOAUQgjxWL/99htr1qyhRYsWjB49mp9++olPPvmEDz74QDene8qUKYYOUzytxGjY8rBnu/Fb4FHLsPEUkuiEVMauOcWey3cB6FWnDNNeqoal2fO1HJoQovjTKIqi5GcHI6PsneMajQZFUdBoNGi1Wr0FZygFXfT8qTyIgK8qAhp4LwQs8/bt7GvLjrLjQiRdanowp1/JvKgKIcTzqrCuRzExMUyYMIHTp08zf/58atUq3tcPg1yXn2UbR8DpVeBcAV7fB6YlrzDe8Rv3Gb3qBLdjkzE3MeKTrtXoXdfL0GEJIUq4gl6P8t3THRISkt9dRF7YuoFTebh3BW4EQaUX87Tb2LYV2HEhkt/O3GZkS38qusk8eyGEEI/n4ODATz/9xN69exkwYADt27fnk08+karlJcGV7WrCjUatVl7CEm5FUVh84Doz/7hAeoaCr7M1P/SvTWV3+TJGCFF85XtO940bN/D09MTb2zvLzdPTkxs3bhRGjM8P34fzuvMxxLyqhz0dqrmhKDB7x+VCCkwIIURJEBoaSu/evalevTr9+/enfPnyHD9+HCsrK2rWrMmff/5p6BDF00iOg9/eVh+/8CZ41TdsPHoWl5zGiBUn+OT386RnKHSs7s7mUY0l4RZCFHv5TrpbtmxJdHR0tu2xsbG0bNlSL0E9t3yaqPf5SLpB7e3WaODPcxGcuxVbCIEJIYQoCQYMGICRkRFffPEFrq6uvP7665iZmTF16lQ2bdrEzJkz6d27t6HDFAW1/WOIuwWlfKHVh4aORq/+uR1L5+/2s/WfCEyNNUztUpXvX66FrYWpoUMTQognynfSnTl3+7/u3buXraiayCfvh0l3xDm1CEoeVShtS+caHgB8sOkc6dqMwohOCCHEM+7YsWN8+umntG/fnq+//pozZ87oXqtcuTJ79+6lTZs2+TrmlClT0Gg0WW6VKlXSvZ6cnMzIkSNxcnLCxsaGHj16cOfOHb29J/HQtT1qQVaALt+BWclYSlRRFH4+Ekq3Hw5y414ing6WrHujEQMb+eT496gQQhRHeZ7T3b17d0AtmjZo0CDMzc11r2m1Ws6cOUOjRo30H+HzxLa0WvQk6rK6XneljnnedeKLldh1KZLTYTHM33OVUa3KF2KgQgghnkV16tTh448/ZuDAgezYsYPq1atnazN8+PB8H7dq1ars2LFD99zE5NGfF2PHjmXLli2sW7cOe3t7Ro0aRffu3Tlw4EDB3oTILiUeNo9WH9cd+mi62jMuMTWdDzeeY8PJWwC0quTK171r4mBVMpc/E0KUXHnu6ba3t8fe3h5FUbC1tdU9t7e3x83NjeHDh7NixYrCjPX5kM/1ujO521sy7aWqAHy78wr/3JZh5kIIIbJavnw5KSkpjB07llu3bvHjjz/q5bgmJia4ubnpbs7OzoA69WzRokV8/fXXtGrVijp16rBkyRIOHjzIoUOH9HJuAfz9CcTcAHsvaDvV0NHoRXDkA7rOPcCGk7cwNtLwXvtKLBxQVxJuIcQzKc893UuWqEOWfHx8GD9+vAwlLyw+TeDYIri+P9+7dg3w5K9zd9j6TwTj1pxm8+jGmJvIWpVCCCFU3t7e/PLLL3o/7pUrV/Dw8MDCwoKGDRsyc+ZMypYty/Hjx0lLS8syZL1SpUqULVuWoKAgXnjhhRyPl5KSQkpKiu55XFyc3mMuMSIvwOGHX550/hbMn+1VTDIyFFYfDWP6lvMkpmpxtTXnu361aFDOydChCSFEgeV7TvfkyZMl4S5MmcXU7uRvXjeoQ/8/7VYNZxszLt15wDfbrzx5pwyZ/y2EEM+DhISEQmnfoEEDli5dytatW5k3bx4hISE0bdqUBw8eEBERgZmZGQ4ODln2KV26NBEREbkec+bMmVlG1Hl5yfrLuQrZByhQriX4tzZ0NE/lUsQDev0YxKSNZ0lM1dLIz4ktbzWVhFsI8czLd9J9584dXn31VTw8PDAxMcHY2DjLTTwlG1dwrggocGplvnd3sjHn027qHL2f9l7l+I3HJO5XtsMsH9g/u0ChCiGEeHb4+/vz2WefER4enmsbRVHYvn07HTp0YM6cOXk6bocOHejVqxc1atQgMDCQP/74g5iYGNauXVvgWCdOnEhsbKzuFhYWVuBjlXi3T6r3z/DyYEmpWj7fepGOc/Zx/MZ9rM2M+bhTFf43tAEutuZPPoAQQhRzeR5enmnQoEGEhoby0Ucf4e7uLpUjC0P9YfDHeNgxFbxeAK96+do9sKob3Wt7suHELcatPc2fbzfFyuw/v+roa/DLUEiJhVOroMkY/cUvhBCi2Nm9ezeTJk1iypQp1KxZk7p16+qGhN+/f5/z588TFBSEiYkJEydO5PXXXy/QeRwcHKhQoQLBwcG0bduW1NRUYmJisvR237lzBzc3t1yPYW5unqVgq3iM8FPqvXuAIaMosD2X7/LRpnOERicC0K5KaaZ0qYqHg6WBIxNCCP3Jd9K9f/9+9u3bR0BAQCGEIwCo95q6Vvf5X2HdQHh9H1jnb2jV5M5VCbp6jxv3Epn5x0U+6Vrt0YupibBmgJpwA0RdUoeyWznq8U0IIYQoTipWrMj69esJDQ1l3bp17Nu3j4MHD5KUlISzszO1atViwYIFdOjQ4alGrsXHx3P16lVeffVV6tSpg6mpKTt37qRHjx4AXLp0idDQUBo2bKivt/b8Sk2AuxfVxx61DBtLPkU+SOaT3y/w2+nbALjbWzClS1UCq+b+ZYwQQjyr8p10e3l5oShKYcQiMmk00OV7uPMP3AuGDa9B/1/AKO9/BNlbmvJFz5q8sugw/zt0g3ZVS9O0vAsoCmwZB3fOgpUzmJhD3C24eRQqBBbimxJCCFEclC1blnfeeYd33nlHL8cbP348nTt3xtvbm9u3bzN58mSMjY3p168f9vb2DB06lHHjxuHo6IidnR2jR4+mYcOGuRZRE/kQcQ6UDLApDXbuho4mTzIyFH4+Gspnf17kQXI6RhoY1MiXce0qYGOe7z9LhRDimZDvOd2zZ8/m/fff5/r164UQjtCxsIPey8HEEq7+DXu/yPchmpR3ZkBDbwAm/HKG2KQ0OLYYTv8MGiPotUQtvAIQdlif0QshhHhO3Lx5k379+lGxYkV69+6Nk5MThw4dwsXFBYBvvvmGTp060aNHD5o1a4abmxsbNmwwcNQlRObQ8mekl/tiRBw95x/kg43neJCcTnVPezaPasLHnatIwi2EKNHy/T9cnz59SExMxM/PDysrK0xNTbO8Hh2dv4rb4jFKV4XOs2Hj67D7MyhTF/zbPHG3f3u/QyX2Xr7L9XuJLFn7C2NC31dfaD0ZfJtBdAicWgGhknQLIYTIv9WrVz/2dQsLC+bOncvcuXOLKKLnSGYRtWI+nzspVcucv6+wYO810jMUrM2MGR9YkQENfTA2ktpAQoiSL99J9+zZswshDJGrmn0hNAiOL4X1w+CNfWBfJs+7W5mZ8FXvmrw+/y96XfsANKlQqRM0flttUPbh8L5bx0GbBsamuR9MCCGEEMXH7VPqfTHu6T56PZpxa08RFp0EQGBVtVCau70UShNCPD/ynXQPHDiwMOIQj9N+lvptdvhpWDsQBv8JJmZ53r2Olz3rXBbjGXeP63hg2/ZbnDKrzjuVBwsHSI6BiDPgWadQ3oIQQggh9Cg1QS2ECuARYNBQcnMxIo7BS44Sn5KOh70FU1+qRtsqpQ0dlhBCFLl8z+kGuHr1Kh9++CH9+vUjMjISgD///JN//vknX8fZu3cvnTt3xsPDA41Gw6ZNmx7bftCgQWg0mmy3qlWr6tpMmTIl2+uVKlXK93ssVkwt1PndFvZw6xhs+zB/++/6FN+4IyRjzrCUMUz64/qjYnhGRuDVQH0cdkS/cQshhBCicEScfVhEzQ1si1/F78gHyQx5mHA38HVk+7jmknALIZ5b+U669+zZQ/Xq1Tl8+DAbNmwgPj4egNOnTzN58uR8HSshIYGaNWvmeZ7Xt99+S3h4uO4WFhaGo6MjvXr1ytKuatWqWdrt378/X3EVS6V8oNtP6uMjP8K59Xnb7+IfsO8rAO62+pLrRl789c8dNp689aiNV331PvSQ/uIVQghRbPn4+DBt2jRCQ0MNHYooqMz53MVwaHlSqpZhy45xOzaZcs7W/PhqHaylUJoQ4jmW76T7/fffZ/r06Wzfvh0zs0dDnFu1asWhQ/lL2jp06MD06dPp1q1bntrb29vj5uamux07doz79+8zePDgLO1MTEyytHN2ds5XXMVWxfbQZJz6ePNbcPfy49vfu6oWYQNo8AZezQbwduvyAEze/A+3Y9T5VY96ug+rS4oJIYQo0caMGcOGDRsoV64cbdu2ZfXq1aSkpBg6LJEfuvncAYaMIpuMDIVxa09x+mYsDlamLB5UDwervE+JE0KIkijfSffZs2dzTJJdXV2JiorSS1B5tWjRItq0aYO3t3eW7VeuXMHDw4Ny5crRv3//kvVNfssPwKcppMbD2lfVOV05SU2ENa9CSpyaVLf9BIA3mvtR08uBB8npvLf+jDrM3LMOaIzhQTjEhhXhmxFCCGEIY8aM4dSpUxw5coTKlSszevRo3N3dGTVqFCdOnDB0eCIviulyYV9su8Sf5yIwNdbw06t18XG2NnRIQghhcPlOuh0cHAgPD8+2/eTJk3h6euolqLy4ffs2f/75J6+99lqW7Q0aNGDp0qVs3bqVefPmERISQtOmTXnw4EGux0pJSSEuLi7LrdgyNoEei9Q5XHcvwm9jsvdOKwr8PgYi/wFrV+i1TFd4zcTYiK961cTcxIh9V6JYcTgUzKzAvYa6r8zrFkKI50bt2rWZM2cOt2/fZvLkySxcuJB69eoREBDA4sWLH9X/EMVLSjzcfVhErRgtF7b2aBjzdl8FYFaPGtT3dTRwREIIUTzkO+nu27cv7733HhEREWg0GjIyMjhw4ADjx49nwIABhRFjjpYtW4aDgwNdu3bNsr1Dhw706tWLGjVqEBgYyB9//EFMTAxr167N9VgzZ87E3t5ed/Py8irk6J+SbWnotUTtnT67Fo4tzvr60YVwZo36eq8lYOee5WV/Vxvea68Wl5ux5QLXoxLA6+HSYTKvWwghnhtpaWmsXbuWLl268M4771C3bl0WLlxIjx49mDRpEv379zd0iCInEWcBBWw91L8JioGDwVFM2ngWgLda+dO9dt6XNxVCiJIu30n3jBkzqFSpEl5eXsTHx1OlShWaNWtGo0aN+PDDfFbVLiBFUVi8eDGvvvpqlnnlOXFwcKBChQoEBwfn2mbixInExsbqbmFhz8AQa+9G0GaK+njr+3Dr4XDAsKOwdaL6uM0U8GmS4+6DGvnQsJwTSWlaXv/fcRJK1364/+FCDVsIIYThnThxIsuQ8qpVq3Lu3Dn279/P4MGD+eijj9ixYwcbN240dKgiJ7oiagEGDSNTcGQ8b6w4TnqGQueaHoxtW8HQIQkhRLGS76TbzMyMBQsWcO3aNX7//XdWrFjBxYsX+d///oexsXFhxJjNnj17CA4OZujQoU9sGx8fz9WrV3F3d8+1jbm5OXZ2dlluz4RGo6FSJ9Cmqut3370MawdARhpU7qK+ngsjIw1f9q6Jq605l+48YPR+c/WFO+fUYWtCCCFKrHr16nHlyhXmzZvHrVu3+PLLL7Mtr+nr60vfvn0NFKF4rMz53MVgaHl0QipDlh4lLjmd2mUd+KJnDTQajaHDEkKIYqXA6zd4eXkRGhpK69atMTc3L9Ax4uPjs/RAh4SEcOrUKRwdHSlbtiwTJ07k1q1bLF++PMt+ixYtokGDBlSrVi3bMcePH0/nzp3x9vbWzVEzNjamX79+BYqxWNNo4KW5cOcfuB8C85uANgWcykPXH9TXH8PTwZL/DW1An5+C+Ps23LV2xUUbqa4FXq5F0bwHIYQQRe7atWvZipD+l7W1NUuWLCmiiES+FJPlwlLStQxffozQ6ES8HC1ZMKAuFqZF0wEjhBDPknz3dP9bhw4duHXr1pMb5uLYsWPUqlWLWrXUi8a4ceOoVasWH3/8MQDh4eHZKo/Hxsayfv36XHu5b968Sb9+/ahYsSK9e/fGycmJQ4cO4eLiUuA4izVLB+jzPzCxUBNuU2voswLMbfO0e0U3W5YOro+1mTEHU/0B0N6QIeZCCFGSRUZGcvhw9v/rDx8+zLFjxwwQkcizlAcQdUV9bMDh5Yqi8N4vZzh24z62FiYsHlgPJ5uCdcIIIURJV+CebuCpq5q2aNHiscdYunRptm329vYkJibmus/q1aufKqZnklt16DYf9nwOrT4C10pP3udfArwcWDCwLjuWVuAlDnL52A4qNp+AkZEMDxNCiJJo5MiRTJgwgQYNGmTZfuvWLWbNmpVjQi6KicwianaeYONqsDDm7Axm06nbGBtpmNe/DuVL5+3LfiGEeB49VU+3KEaqdoM3g6DSiwXavZGfM4HtuwLgGX+WaZvPylIxQghRQp0/f57atWtn216rVi3Onz9vgIhEnmUOLTfgfO5fT93imx2XAZjetRpNyjsbLBYhhHgWPFXS/eOPP1K6dPFYqkI8vQYvNCXd2BI7TRJBhw/w9fbLhg5JCCFEITA3N+fOnTvZtoeHh2Ni8lSD4ERhu31KvTfQfO5j16N5d90ZAIY3K0e/+mUNEocQQjxLnirpfvnll9FqtWzatIkLFy7oKyZhKMYmmJStB0Adoyt893cwP+29auCghBBC6Fu7du10y2VmiomJYdKkSbRt29aAkYknMuByYTfuJTD8f8dJ1WbQrkpp3m+fv+lsQgjxvMp30t27d2++//57AJKSkqhbty69e/emRo0arF+/Xu8BiiLm9QIAA8pEADDjj4v8fCT0cXsIIYR4xnz55ZeEhYXh7e1Ny5YtadmyJb6+vkRERPDVV18ZOjyRm+Q4uPdw1ZciHl4eFZ/C4CVHiU5IpbqnPbP7BkjtFyGEyKN8J9179+6ladOmAGzcuBFFUYiJiWHOnDlMnz5d7wGKIualFtWpmHqe15uXA2DSxrP8fua2IaMSQgihR56enpw5c4bPP/+cKlWqUKdOHb799lvOnj2Ll5eXocMTuYk4g1pErQzYFN2qLLGJaby66AjXohLwsLdg4cC6WJnJNAQhhMirfP+PGRsbi6OjIwBbt26lR48eWFlZ0bFjR9599129ByiKWJm6gAbN/RDeb+JIXFI6Px8JZeyaU1ibm9CyouEqpQohhNAfa2trhg8fbugwRH7o5nMHFNkp41PSGbjkCBfC43C2MWflsBcobWdRZOcXQoiSIN9Jt5eXF0FBQTg6OrJ161bdEl3379/HwkL+E37mWTqAa2WIPI/m5hGmd+3Eg+Q0fj8TzogVx1k+pAH1fR0NHaUQQgg9OH/+PKGhoaSmpmbZ3qVLFwNFJB4r/JR6X0RJd3KalteWHeVUWAwOVqaseK0+vs7WRXJuIYQoSfKddI8ZM4b+/ftjY2ODt7c3LVq0ANRh59WrV9d3fMIQvBpA5HkIO4xx5c583TuAhJR0dl26y9ClR/l5+AtU87Q3dJRCCCEK6Nq1a3Tr1o2zZ8+i0Wh0S0RqNOocXa1Wa8jwRG50y4UVfuXy1PQM3lx5gkPXorExN2HZ4PpUcrMr9PMKIURJlO853W+++SZBQUEsXryY/fv3Y2SkHqJcuXIyp7ukeDivm9DDAJiZGPFD/zrU93XkQUo6AxYfITgy3oABCiGEeBpvv/02vr6+REZGYmVlxT///MPevXupW7cuu3fvNnR4Iif/LqJWyD3d2gyFsWtP8ffFSCxMjVg0sC41vRwK9ZxCCFGSFWjJsLp169KtWzdsbGzQarWcOnWKRo0a0bhxY33HJwyh7MOkO/wUpCUDYGlmzKKBdanuaU90QioDFx8h8kGy4WIUQghRYEFBQUybNg1nZ2eMjIwwMjKiSZMmzJw5k7feesvQ4YmchJ9W7+29wNq50E6TkaHw/vozbDkTjqmxhh9frUuDck6Fdj4hhHge5DvpHjNmDIsWLQLU4WfNmzendu3aeHl5ybfjJUUpX7B2AW3qo/ljgK2FKcuGqPO5bsUkMXz5cZLTZAiiEEI8a7RaLba2tgA4Oztz+7a6QoW3tzeXLl0yZGgiN0Uwn1tRFKb9fp51x29ibKThu361aF6h6KqkCyFESZXvpPuXX36hZs2aAPz222+EhIRw8eJFxo4dywcffKD3AIUBaDSPhpiHHc7ykqO1GYsH1cPe0pRTYTGMX3eajAzFAEEKIYQoqGrVqnH6tNpz2qBBAz7//HMOHDjAtGnTKFeunIGjEznKrFxeiOtzf7ntEksPXgfgi541aF/NvdDOJYQQz5N8J91RUVG4ubkB8Mcff9CrVy8qVKjAkCFDOHv2rN4DFAbyn3nd/+brbM38V+pgYqTh9zPhzN55pYiDE0II8TQ+/PBDMjIyAJg2bRohISE0bdqUP/74gzlz5hg4OpGjzCJqHoVTRO2H3cHM3XUVgE9eqkr32mUK5TxCCPE8ynfSXbp0ac6fP49Wq2Xr1q20bdsWgMTERIyNjfUeoDCQsi+o92GHQcnek93Qz4kZ3dRq9XN2XmHTyVtFGZ0QQoinEBgYSPfu3QHw9/fn4sWLREVFERkZSatWrQwcncgmORai1YS4MJLu5UHX+XyrOq3g/Q6VeLWhj97PIYQQz7N8J92DBw+md+/eVKtWDY1GQ5s2bQA4fPgwlSpV0nuAwkDca4KxGSRGQfS1HJv0rufF683VYYgTfjnDsevRRRmhEEKIAkhLS8PExIRz585l2e7o6KhbMkwUM7oiamXBylGvh/7l+E0+/vUfAEa38ueN5n56Pb4QQogCJN1Tpkxh4cKFDB8+nAMHDmBubg6AsbEx77//vt4DFAZiYv7o2/Sw7EPMM70XWIl2VUqTqs3g9f8dJyw6sYgCFEIIURCmpqaULVtW1uJ+lmTO59ZzEbU/zoYz4Rc1oR/c2IdxbSvo9fhCCCFUBVoyrGfPnowdO5YyZR7N9xk4cCAvvfSS3gITxYBuXvehXJsYGWmY3TeAqh523EtIZcjSo8QlpxVRgEIIIQrigw8+YNKkSURHywilZ4JuPneA3g6562Ikb68+SYYCfep68XGnKjLSQQghCkmBku49e/bQuXNn/P398ff3p0uXLuzbt0/fsQlD01UwP/LYZlZmJiwaWI/SduZciYxn5MoTpGsziiBAIYQQBfH999+zd+9ePDw8qFixIrVr185yE8WMbrkw/cznDo6MZ8TK46RpFTrX9GBG9+qScAshRCEyye8OK1asYPDgwXTv3p233noLgAMHDtC6dWuWLl3Kyy+/rPcghYFkJt13L0BSDFg65NrUzd6CRQPr0Wt+EPuuRDHt9/NMe6lakYQphBAif7p27WroEEReJcU8qq2ih+XC0rQZjFt7iuS0DBr7O/F175oYG0nCLYQQhUmjKDmUpn6MypUrM3z4cMaOHZtl+9dff82CBQu4cOGCXgM0hLi4OOzt7YmNjcXOzs7Q4RjWnFrqxb7/L1C+7RObbz0XwYiVx1EUmNK5CoMa+xZBkEIIUTLJ9Uj1XP8cru2B5V3AwRvGnHnqw83ecZnZO65gZ2HCtrHNcbO30EOQQgjxfCjo9Sjfw8uvXbtG586ds23v0qULISEh+T2cKO68/rV0WB60r+bGe+3VKvbTfj/PrkuRhRWZEEIIUfLphpYHPPWhztyM4bu/gwH4pGs1SbiFEKKI5Dvp9vLyYufOndm279ixAy8vL70EJYoRr/rq/WOKqf3X683K0btuGTIUGL3qJJciHhRScEIIIQrCyMgIY2PjXG+iGMksovaUQ8uT07SMXXMKbYZCpxruvBTg+fSxCSGEyJN8z+l+5513eOuttzh16hSNGjUC1DndS5cu5dtvv9V7gMLAyj7s6b51HLTpYPzkfzIajYbpXasTGp3IoWvRDFl6lE0jG+Nia17IwQohhMiLjRs3ZnmelpbGyZMnWbZsGVOnTjVQVCJHuuXCnq6I2qytF7l6NwFXW3Omd5WaK0IIUZTynXSPGDECNzc3vvrqK9auXQuo87zXrFkjS4aVRM4VwcIekmPhztk8X/TNTIyY/0oduv1wkJCoBIb/7xg/D3sBC1PpQRFCCEPL6Xrds2dPqlatypo1axg6dKgBohLZJN2H+w+n7rnXLPBhDgRHseTAdQA+71kDByszPQQnhBAir/I1vDw9PZ1p06ZRr1499u/fz71797h37x779++XhLukMjKCMg+HmD9h6bD/crAyY9HAuthbmnIyNIZ31p2WpcSEEKIYe+GFF3KcQpZXn332GRqNhjFjxui2JScnM3LkSJycnLCxsaFHjx7cuXNHD9E+B8JPq/elfMDKsUCHiE1KY/w69Tj9G5SlRUVXPQUnhBAir/KVdJuYmPD555+Tnp5eWPGI4ihz6bB8zOvOVM7Fhnmv1MbESMOWM+GM/vkkKelaPQcohBDiaSUlJTFnzhw8PQs21/fo0aP8+OOP1KhRI8v2sWPH8ttvv7Fu3Tr27NnD7du36d69uz5CLvkyh5Y/xXzuqb/9Q3hsMt5OVnzQsbJewhJCCJE/+S6k1rp1a/bs2VMYsYjiyqtgPd2ZGvk58/3LtTEzNuLPcxG8tuwYianyxY0QQhhKqVKlcHR01N1KlSqFra0tixcv5osvvsj38eLj4+nfvz8LFiygVKlSuu2xsbEsWrSIr7/+mlatWlGnTh2WLFnCwYMHOXQo/1/kPncyi6gVcD731nPhbDhxCyMNfN27JlZm+Z5VKIQQQg/y/b9vhw4deP/99zl79ix16tTB2to6y+tdunTRW3CimPCsAxpjiLsJsTfBvky+D9G+mhuLB9Vj2PJj7LsSxauLjrB4UD3sLU0LIWAhhBCP880336DRaHTPjYyMcHFxoUGDBlmS5rwaOXIkHTt2pE2bNkyfPl23/fjx46SlpdGmTRvdtkqVKlG2bFmCgoJ44YUXcjxeSkoKKSkpuudxcXH5jqlEeIrlwiIfJDNxw1kA3mjuRx3vgg1PF0II8fTynXS/+eabAHz99dfZXtNoNGi1eR86vHfvXr744guOHz9OeHg4GzdupGvXrrm23717Ny1btsy2PTw8HDc3N93zuXPn8sUXXxAREUHNmjX57rvvqF+/fp7jEv9hbgNu1dS5ZWGHC5R0AzQp78yK1xoweMkRjt+4T7+fDrF8aH2cbaSquRBCFKVBgwbp7VirV6/mxIkTHD16NNtrERERmJmZ4eDgkGV76dKliYiIyPWYM2fOlCrqidFw/7r6OJ9F1BRFYeL6s9xPTKOyux1j2lTQf3xCCCHyLN/DyzMyMnK95SfhBkhISKBmzZrMnTs3X/tdunSJ8PBw3c3V9VFRkDVr1jBu3DgmT57MiRMnqFmzJoGBgURGRubrHOI/vB72RhRwiHmmOt6lWD28Ic42ZpwPj6P3/CBuxSTpIUAhhBB5tWTJEtatW5dt+7p161i2bFmejxMWFsbbb7/NypUrsbCw0Ft8EydOJDY2VncLCwvT27GfGboiar5gmb/RB2uPhbHzYiRmxkbM7hOAmUm+/9wTQgihRwb9X7hDhw5Mnz6dbt265Ws/V1dX3NzcdDcjo0dv4+uvv2bYsGEMHjyYKlWqMH/+fKysrFi8eLG+w3++ZM7rLkAxtf+q4mHHujca4elgybWoBHrNO8i1u/FPfVwhhBB5M3PmTJydnbNtd3V1ZcaMGXk+zvHjx4mMjKR27dqYmJhgYmLCnj17mDNnDiYmJpQuXZrU1FRiYmKy7Hfnzp0sI9T+y9zcHDs7uyy3504Bh5aH3ktk2m/nARgfWIGKbrb6jUsIIUS+5Tvpfuutt5gzZ0627d9//32WJUIKU0BAAO7u7rRt25YDBw7otqempnL8+PEsc8eMjIxo06YNQUFBRRJbiVX2YU93xFlITXjqw/k6W7PujYaUc7HmdmwyvX8M4p/bsU99XCGEEE8WGhqKr69vtu3e3t6Ehobm+TitW7fm7NmznDp1SnerW7cu/fv31z02NTXNsgzZpUuXCA0NpWHDhnp5LyVWAYqoaTMUxq87TUKqlvo+jgxtUq6QghNCCJEf+U66169fT+PGjbNtb9SoEb/88otegsqNu7s78+fPZ/369axfvx4vLy9atGjBiRMnAIiKikKr1VK6dOks+z1p7lhKSgpxcXFZbuI/7MuAnScoWrh1XC+H9HCwZO3rDanibkdUfCp9fzrE8RvRejm2EEKI3Lm6unLmzJls20+fPo2Tk1Oej2Nra0u1atWy3KytrXFycqJatWrY29szdOhQxo0bx65duzh+/DiDBw+mYcOGuRZREw8VYLmwRfuvceR6NNZmxnzVuybGRpon7ySEEKLQ5TvpvnfvHvb29tm229nZERUVpZegclOxYkVef/116tSpQ6NGjVi8eDGNGjXim2++earjzpw5E3t7e93Ny8tLTxGXMJnrdYcd1tshnW3M+Xn4C9T1LsWD5HReWXiEfVfu6u34QgghsuvXrx9vvfUWu3btQqvVotVq+fvvv3n77bfp27evXs/1zTff0KlTJ3r06EGzZs1wc3Njw4YNej1HsZVWwJolidEQc0N9nMciahcj4vjyr8sAfNy5Cl6OVgU7txBCCL3Ld9Lt7+/P1q1bs23/888/KVeu6Icx1a9fn+DgYACcnZ0xNjbmzp07Wdo8ae6YFGzJo8ykO1R/STeAvaUp/xvagGYVXEhK0zJ06TG2ngvX6zmEEEI88sknn9CgQQNat26NpaUllpaWtGvXjlatWuVrTndOdu/ezezZs3XPLSwsmDt3LtHR0SQkJLBhw4bHXpNLjL+nwwxP+OsD0Kbnb9/M+dyO5cDS4YnNU9MzGLvmNKnaDNpUdqV3Xek8EEKI4iTfS4aNGzeOUaNGcffuXVq1agXAzp07+eqrr7JcZIvKqVOncHd3B8DMzIw6deqwc+dO3dJjGRkZ7Ny5k1GjRuV6DHNzc8zNZdmqJyr7MOm+eQQyMsBIf3X4LM2MWTigLmPWnOSPsxG8ufIEs3rUoJf84SCEEHpnZmbGmjVrmD59OqdOncLS0pLq1avj7e1t6NBKhpB9sPcL9XHQ93DnHPRcAlZ5XCs7n/O5Z++4zIXwOBytzZjZvUaWNdiFEEIYXr6T7iFDhpCSksKnn37KJ598AoCPjw/z5s1jwIAB+TpWfHy8rpcaICQkhFOnTuHo6EjZsmWZOHEit27dYvny5QDMnj0bX19fqlatSnJyMgsXLuTvv/9m27ZtumOMGzeOgQMHUrduXerXr8/s2bNJSEhg8ODB+X2r4r9KVwNTK0iOhahL4FpZr4c3MzHiu361sTE/w9pjN3n3lzM8SE5nSJPsxX6EEEI8vfLly1O+fHlDh1GypDyAX99UH/s0hVsn4Npu+Kk59F0FbtWffIx8zOc+fiOa+XuuAjCjWzVcbKUTQQghipsCdVWOGDGCmzdvcufOHeLi4rh27Vq+E26AY8eOUatWLWrVUr/JHTduHLVq1eLjjz8GIDw8PEsV1dTUVN555x2qV69O8+bNOX36NDt27KB169a6Nn369OHLL7/k448/JiAggFOnTrF169ZsxdVEARibgmcd9bEe53VnOYWRhlk9ajD0YaI97ffzjF93msTUfA7NE0IIkasePXowa9asbNs///xzevXqZYCISpBtH0JMKDiUhX4/w2s71LW2Y0JhYVs4m4eis3lcLuxBchpj1pwiQ4H/t3ff8VFU6x/HP7vphSSkJzQh9K7UiPSuIggqXvGKiCgINvRexYbl5wVFsSJcFAWvCggCFlSE0KRJkY4gPZQkkIT0nszvj4FgpCVhN5uQ7/v12ldmZ2dnnh1XTp6cc54z8IZq9GkadtXhi4iI7VkMwzAcHUR5k5KSgq+vL8nJyZVzbdDLiXoNfn0LWtwDt0+122UMw2DaqkNMWrKXAgPqBXszZcgN1A/ReqMiUnnYqz0KCgpi+fLlNGtWtNd1586d9OjR44LaKI5WYdrl/cvgy0Hm9tAfoHZHczvzDMwfDgfPLp1242PQ42WwOl14joxEePPsCK9no8H9wuK15zw9bzvztxynelUPfnq8I1XcXWz3WURE5AKlbY+K1dPdp08fNmzYcMXjUlNTeeONN5gyZUqxA5AK5lwxtUMrIDfLbpexWCyM6hLBlw+2J7iKG/tPpXHbh2v4etMx9HciEZGrk5aWhqur6wX7XVxctGxmaWWege/O1o9pN+p8wg3gURWGzIObnjSfr3sfvhhkJth/d24+t3/EZRPuH3fGMH/LcawWmHxXSyXcIiLlWLGS7jvvvJNBgwbRuHFjnnnmGebNm8fatWvZsmULy5Yt4/333+euu+4iLCyM33//nX79+tk7bnGU2h2hShikxsDmT+1+uciIAH58vCMd6wWSlVvAv7/Zwdivt5OereHmIiKl1axZM+bOnXvB/jlz5tC4cWMHRHQN+OkZs20MqAvdX7rwdauT2bt950yzPsqhFTC9C8TuKnpcMYqoxSZnMW7BTgBGdYmgbe1iFmgTERGHKFYhteHDh3Pvvfcyb9485s6dy/Tp00lOTgbMHsnGjRvTu3dvNm3aRKNGti2uJeWMiwd0eRa+f9wcZn79veBu36F+gd5uzBrWlqmrDvL2L/tYuPUE248nMeWeG2gUVo6HGYqIlFMvvvgiAwcO5ODBg0VWIpk9ezbz5s1zcHQV0J7vYMdcsFhhwDRwvcwa2U1uh4B6MOcecy3uGT2h/xRoOtB8/QrzuQsKDJ6et53kzFyaV/fliR71bfpRRETE9ko9pzs5OZnMzEwCAgJwcbm2hjRVmLljjpKfBx+1g4QD0PkZ6PpcmV164+FEHpu9ldiULNycrbx8WxPublNDy6OIyDXJnu3R4sWL+c9//lO4ZFjz5s0ZP348nTt3tul1bKFct8tpp+Gj9pARDx2fungv98VkJMI3w+HgcvN5h8eh+3h4rwUkH4P7F8N1N13wthlrDvPaD3twd7Gy+LGORAR52/DDiIjI5ZS2PVIhtYso1417ebF7EcwbCi5e8Ph28A4qs0snpucw9uttrNx3GoDbWoTzn4HN8HYr8Qp4IiLlmiPao127dtG0adMyuVZxldt22TBg7r2w9wdzWc0Ry8G5BEt2FeRD1Cuw9j3zea2b4Ogac/vZYxeMJNsbm8JtH64lJ6+A/xvQlHvba111EZGyZNdCaiIXaNzfnG+Wmw6rJ5Xppf29XPl0aBue7dsQJ6uF77afpN8Ha9h9MrlM4xARuVakpqYyffp02rZtS4sWLRwdTsWx42sz4ba6wO3TSpZwgznPu+ercMen5jzvcwl3QL0LEu6s3HyemLONnLwCujcMZki7mjb6ECIiYm9KuqV0LBazIAyYBdXOHCnTy1utFkZ2juDrh9sT7uvO4fh0bv9oHf/bcFTVzUVEimn16tXcd999hIWF8dZbb9GtW7dirVYiQPIJ+PFf5naXZyC02eWPv5ymg2D4L+ba3gDV21xwyFtL9rE3NpVAb1feuKO5plWJiFQgSrql9Op0MR8FubBigkNCaFXLn8WPdaRHo2By8gp4cdEuxszeypn0HIfEIyJS3sXGxjJx4kTq1avHnXfeia+vL9nZ2SxatIiJEyfSps2FCZ/8jWHAd49CdjKE3wAdnrz6c4Y2g4dWQd83ofuLRV5aeyCeT9YcBuCNQc0J9C5hj7qIiDiUkm65Ot3Hmz93zL1w2ZMyUtXLlY/va80LtzTC2Wph8Y4Yur29kjkboykoUK+3iMg5/fr1o0GDBuzYsYN3332XkydP8sEHHzg6rIpny0w4GAXO7nD7f8HJRjVFPP2h3cPgE164Kykjh6e+3g7AkHY16d4oxDbXEhGRMlPipPvYsWMcP3688PnGjRt54oknmD59uk0Dkwqi2g3QeABgwPLXHBaGxWLhwY51mD/qRhqGVuFMRi7PLtjJoGnr2HVCc71FRAB++uknhg8fziuvvMItt9yCk5OTo0OqeBIPw5Lnze3uL0GQ/ZbsMgyD5xbuJDYlizqBXjx/i5ZlFRGpiEqcdN9zzz2sWLECMIeo9ezZk40bN/L888/z6quv2jxAqQC6vQgWJ/jzZzi63qGhtKzhx/eP3sQLtzTCy9WJrdFJ3PbhGsZ/u4vkzFyHxiYi4mhr1qwhNTWVVq1a0a5dOz788EPi4+MdHVbFUVAA3442i4jW6gDtRtn1cgt+P8GPO2Nxtlp49+6WeLpqlQ4RkYqoxEn3rl27aNu2LQBff/01TZs2Zd26dXz55ZfMnDnT1vFJRRBYF274p7m97GVzrpsDuThZebBjHZY/3YV+LcIpMGDW+qN0f3sl32w5rkJrIlJptW/fno8//piYmBgefvhh5syZQ3h4OAUFBSxdupTU1FRHh1i+/TYNjq41l8vsPwWs9puldywxg/Hf7QbgyZ71aV7dz27XEhER+ypxa5Gbm4ubm1nAY9myZdx2220ANGzYkJiYGNtGJxVH52fMuW3HNpg93uVAiI87H/zjer58sB0RQV7Ep+Xw1LztDP7vBvbGpjg6PBERh/Hy8uKBBx5gzZo17Ny5k6eeeoqJEycSHBxc2K7L35z+01xTG6D3/4F/bbtdKi+/gCfnbiMtO4/WtaoysnOE3a4lIiL2V+Kku0mTJkybNo1ff/2VpUuX0qdPHwBOnjxJQECAzQOUCsInHNqNNLejXoWCfMfG8xcd6gby0+Od+HefBni4OLHxSCK3vL+G//thD2nZeY4OT0TEoRo0aMCbb77J8ePHmT17tqPDKZ/y82DRSMjLgohu0GqYXS83bdVBNh89g7ebM+8MbomTVcuDiYhUZCVOut944w3++9//0qVLF/7xj3/QokULAL777rvCYedSSd30BLj7wqk9sHOeo6MpwtXZyiNd6rLsqc70aRJKfoHBJ2sO0/3tlXy3/aSGnItIpefk5MSAAQP47rvvHB1K+bPufTixBdx84bYPwY5rZG8/lsS7y/YD8MptTajh72m3a4mISNmwGKXINvLz80lJSaFq1aqF+44cOYKnpyfBwcE2DdARUlJS8PX1JTk5GR8fH0eHU7Gsecec1+1bEx7dDM7lcy3RlftOMf673RxNyACgQ90AXu3flIggbwdHJiJyntojk8Pvw3st4cxhuO0DuOE+u10mIyePW99fw6H4dG5pFsaH91yPxY4JvoiIlExp26MS93RnZmaSnZ1dmHAfPXqUd999l3379l0TCbdcpbYPQ5UwSI6GzZ85OppL6tIgmCVPdOLJHvVxc7ay9kACfd/9lclL/yQrt/wMjRcREQfLTDITboCGt9r1UpOW7ONQfDqhPu68fntTJdwiIteIEifd/fv35/PPPwcgKSmJdu3a8fbbbzNgwACmTp1q8wClgnH1NIuqAayeBNnltxKuu4sTj/eox9InO9OlQRA5+QW8H7WfPu+uZs1+LaEjIiJA7E7zp19N8PS322W2HUti5rojAEwc1Aw/T1e7XUtERMpWiZPu33//nY4dOwIwf/58QkJCOHr0KJ9//jnvv/++zQOUCuj6e8E/AjLiYf0UR0dzRTUDPPns/jZ8NOQGQnzcOJKQwb0zfuPxOVs5nZrt6PBERMSRYrabP8Na2O0SufkFPPvNDgwDBrQMp0sDjRwUEbmWlDjpzsjIoEqVKgD88ssvDBw4EKvVSvv27Tl69KjNA5QKyMkFur9obq/7ANLLf6+xxWLh5mZhLBvbmftvvA6rBb7ddpJub6/kiw1HKShQoTURkUrpXNIdar+ke/rqQ+yNTaWqpwsv3trYbtcRERHHKHHSXbduXRYtWsSxY8dYsmQJvXr1AuDUqVOVusiL/E2j/hDWEnLSYPVbjo6m2Kq4u/DybU1YNLoDzar5kpqVxwuLdjFw6jr2nNTa3iIilY6de7oPx6fzXpRZrfyFWxoT4F0+C5CKiEjplTjpfumll3j66ae57rrraNu2LZGRkYDZ63399dfbPECpoKxW6PGyub15BpypWKMgmlf3Y9HoDozv1xhvN2e2HUui34dreH3xHtK1treISOWQkw7xf5rbdki6DcPguQU7yckroGO9QAbeUM3m1xAREccrcdJ9xx13EB0dzebNm1myZEnh/u7du/POO+/YNDip4CK6Qu3OkJ8DKyc4OpoSc7JaGNahNsvGdubmZuba3h//epiek1fxy+5YR4cnIiL2FrsLMMA7FKqE2Pz08zYfZ/2hBNxdrLw+oJmqlYuIXKNKnHQDhIaGcv3113Py5EmOHz8OQNu2bWnYsKFNg5NrQI/x5s/tcyBuj2NjKaVQX3c+GtKKz+5vQ/WqHpxMzuKh/21hxOebOXQ6zdHhiYiIvdhxaPnp1Gxe//EPAJ7sUZ+aAZ42v4aIiJQPJU66CwoKePXVV/H19aVWrVrUqlULPz8/XnvtNQoKCuwRo1Rk1VpB4/6AAUtfhPyKOzS7a8Nglj7ZmUe6ROBstbB0Txzd3l7FP6Zv4PvtJ8nJ0/dfROSaEmu/pPuV73eTnJlLk3Afht9U2+bnFxGR8sO5pG94/vnnmTFjBhMnTqRDhw4ArFmzhpdffpmsrCxef/11mwcpFVy3F+GPH+DAMvjfABg0wy7D9ADISoHEQxDe0i6n93B14t99GjLg+mq88dNeVuw7xfpDCaw/lECAlyt3tKrOP9rW5LpAL7tcX0REypCderqX743jhx0xWC0wcWBznJ1KNfBQREQqCIthGCVaCyk8PJxp06Zx2223Fdn/7bff8sgjj3DixAmbBugIKSkp+Pr6kpycrIrstrJ7EXw72qxm7h0Cd3wK191k22vs+wm+fwLSYqHvJGj3kG3PfxEnkjKZu+kYczdFE5dyfk3vDnUD+EfbmvRqHIqrs36ZEpHSUXtkcsh9yMuG/4RDQR48sQv8atjktGnZefSavIqTyVmM6Fib52/REmEiIhVFadujEmcDiYmJF5273bBhQxITE0t6OqksmgyAESsgqBGkxcGsfrDmHbDFlISMRFjwEMy+20y4AaJehZSYqz/3FVTz82Bsz/qsfaYb0//Zii4NgrBYYO2BBMZ8tZUbJ0Yx8ae9HE1It3ssIiJiQ6f2mAm3hz/4VrfZad/+ZR8nk7OoXtWDJ3vWt9l5RUSk/Cpx0t2iRQs+/PDDC/Z/+OGHtGhhnzUs5RoRVB9GREHzu8EogGUvw5x/mElzaf3xA0xpBzvmgsUKNz4G1VpDTiosGWez0K/E2clKryahzBzWll//3ZVHu9UluIob8Wk5TFt1kM6TVnLvJ7/x484YcvM191tEpNz769ByG1UV33YsiZnrjgDwn9ub4ela4ll+IiJSAZU46X7zzTf59NNPady4McOHD2f48OE0btyYmTNnMmnSpBKda/Xq1fTr14/w8HAsFguLFi267PELFiygZ8+eBAUF4ePjQ2RkZJFlywBefvllLBZLkYeqqpcjrl5w+zTo9x44ucGfP8N/O8OJ30t2noxEmD8c5g6B9FMQWB+GL4Ver8Gt75gJ+O6FcCDKPp/jMqpX9eSpXg1Y+2w3pt3bik71zd7vNQfieeTL3+kwcTnvLdvPqdSsMo9NRESKqTDpbm6T0+XmF/DsNzswDLj9+mp0qh9kk/OKiEj5V+Kku3Pnzvz555/cfvvtJCUlkZSUxMCBA9m3bx8dO3Ys0bnS09Np0aIFU6ZMKdbxq1evpmfPnvz4449s2bKFrl270q9fP7Zu3VrkuCZNmhATE1P4WLNmTYniEjuzWKDV/fDgUqhaG5Kj4dPesPFjKE6JgT3fwZS2sGu+mVx3eAIe/hWqtzZfD2sO7Uaa2z8+Dbl2SG7zcmDrF3B63yUPcXGy0qdpKJ8/0JbV/+rK6K4RBHq7cSo1m3eW/UmHict5Ys5WtkafsX18IiJydWxcRG366kPsjU2lqqcLL9zSyCbnFBGRiqHEhdQu5fjx47z66qtMnz69dIFYLCxcuJABAwaU6H1NmjRh8ODBvPTSS4DZ071o0SK2bdtWqjhAhWvKVGaSWWBt7w/m86aDoN/74OZ94bHp8fDjv2D3AvN5UEPo/xFUb3Xhsdmp8GEbSI2Bzs9CVxsPNf/uMfh9Fjh7QP8PodkdxXpbTl4BP+2KYda6I/wenVS4v0UNP+6/sRY3NwvDzdnJtrGKSIWl9shU5vchPw8mVIO8LHj0dwiIuKrTHY5Pp/e7q8nJK2DyXS0YeIPt5oiLiEjZKbNCapeSkJDAjBkzbHW6YikoKCA1NRV/f/8i+/fv3094eDh16tRhyJAhREdHX/Y82dnZpKSkFHlIGfHwg8FfQK/XweoMu76Bj7vCqT+KHrd7kTl3e/cCsDhBx6fg4dUXT7gB3KpAnwnm9prJkHDQdjFvmWkm3AB5mfDNcFjyfLHWIHd1ttK/ZTUWPNKB78Z0YOAN1XB1srL9WBJPzt1Oh4nLmfzLPuJSNPRcRMRh4v80E27XKuaIrKtgGAbPLdhJTl4BHesFcvv11WwUpIiIVBQVei2jt956i7S0NO66667Cfe3atWPmzJn8/PPPTJ06lcOHD9OxY0dSU1MveZ4JEybg6+tb+KhRwzbLgkgxWSxw4xi4fzFUCTd/2fm4G2yfA2mn4euhMG8oZMRDcGOzGFv3l8DZ7fLnbTwAIrpDfg4sfqp4Q9ev5Phms7cdoOvzcNNYc3v9h/DFwBIVhWte3Y/Jd7Vk3bhuPN2rPqE+7sSn5fD+8gN0mLicR2dvZcvRRGw0GEVExC6mTp1K8+bN8fHxKay38tNPPxW+npWVxejRowkICMDb25tBgwYRFxfnwIiL4a/zua1X96vSvM3HWX8oAXcXK68PaIbFRkXZRESk4rDZ8PLt27dzww03kJ+fX7pASji8/KuvvmLEiBF8++239OjR45LHJSUlUatWLSZPnszw4cMvekx2djbZ2efXWE5JSaFGjRqVfjifQ6THwzcPwqEV5nMXL8hNP9+73enpKyfbf5VwED6KhPxsGDSj2MPALyrtlFn0LfUkNLzV7KG3WMxe+EWPmHH61YS7v4LQZiU+fW5+Ab/sjmPWuiNsPHI+eW9azYd/tjeHnldxdyl9/CJS4VSE4eXff/89Tk5O1KtXD8MwmDVrFpMmTWLr1q00adKEUaNGsXjxYmbOnImvry9jxozBarWydu3aYl+jzO/DT8/Cb1Oh/SPnR02VwunUbHpMXkVyZi7P3dyQhzpd3TB1ERFxLIcPLy9Lc+bM4cEHH+Trr7++bMIN4OfnR/369Tlw4MAlj3Fzcyv8C/25hziIVyDc+w10GQdYzEQ2pCmMWA7dni9Zwg3mPLyOT5nbS56DrOTSxZWfC/OGmQl3YH0YMPX8EjJNBsCDy6DqdZAUDZ/0hJ3zS3wJFycrtzQP4+uRkSx+7Cbual0dN2cru06k8Mw3O2n9f8sY/dXvLNsTR06elh0TkfKhX79+3HzzzdSrV4/69evz+uuv4+3tzYYNG0hOTmbGjBlMnjyZbt260apVKz777DPWrVvHhg0bHB36pdmoiNor3+8mOTOXptV8eKDD1Q1TFxGRiqvYC0QOHDjwsq8nJSVdbSzFMnv2bB544AHmzJnDLbfccsXj09LSOHjwIP/85z/LIDqxCasTdHkW6nQxq4O3+Ac4u5b+fDc9Ya7jnXgQlr8ON79Z8nMsfQmOrjHn9w3+Etz/9oeZkMYwYoXZS38wypznHbMderxsfp4SahLuy5t3tGBc30bM3XyM+VuOc+BUGot3xLB4Rwx+ni7c2jyM26+vxg01q2q4ooiUC/n5+cybN4/09HQiIyPZsmULubm5Rf5A3rBhQ2rWrMn69etp3779Rc9zsRFoZaagAGJ3mNtXkXSv2HuKH3bEYLXAxIHNcXaqkP0cIiJiA8VOun19fa/4+n333Veii6elpRXpgT58+DDbtm3D39+fmjVrMm7cOE6cOMHnn38OmEPKhw4dynvvvUe7du2IjY0FwMPDozC+p59+mn79+lGrVi1OnjzJ+PHjcXJy4h//+EeJYpNyoGZ783G1nN3glrfhfwNg08fQ8h4Ib1n89++YBxs+MrdvnwpB9S9+nKc/DJkHy1+DNe/Auvchdifc8an5WilU9XJlZOcIHu5Uh90nU1i09QTfbj/J6dRsvtgQzRcboqnp78mAluH0v74aEUEXqfouImJnO3fuJDIykqysLLy9vVm4cCGNGzdm27ZtuLq64ufnV+T4kJCQwjb8YiZMmMArr7xi56gvIfEQ5KSZq1ME1CvVKfLyC3ht8R4Aht9Um6bVLv87lIiIXNtsNqe7NFauXEnXrl0v2D906FBmzpzJ/fffz5EjR1i5ciUAXbp0YdWqVZc8HuDuu+9m9erVJCQkEBQUxE033cTrr79ORETx51FVhDl0Ugrzh5tre4ffYA4HL04PdOxOc7h4XqY5TL37S8W71q4F5lJouRngV+vsPO+mVxf/WfkFBusOxrNw6wmW7IolPed8HYXm1X0Z0LIa/VqEE1SlhEPxRaTcqSjtUU5ODtHR0SQnJzN//nw++eQTVq1axbZt2xg2bFiRXmuAtm3b0rVrV954442Lns+htVZ2zjdHK1VrbRbuLIW5m6J55pudVPV0YfW/u6oeh4jINaK07bJDk+7yqqL8kiMllBoHH7aG7BSz57vNg5c/PiMRpneBpKNmFfQh80o2VDx2F8y5x3y/iyf0nwJNLz9No6QycvJYuieOb7edZNWfp8kvMP93drJauKluIINaVadX4xDcXbT2t0hFVFHbox49ehAREcHgwYPp3r07Z86cKdLbXatWLZ544gmefPLJYp2vTO/DLy+aI5VaD4dbJ5f47Vm5+XR9ayUxyVm8cEsjHuxYxw5BioiII1SqQmoipVIlBLq9aG4ve9WsRn4pBfmwYISZMPvVgkGflHxudmhTeGglRHQze7znD4Ol481z24inqzP9W1bj0/vb8Ntz3Xnltia0rOHHTWyj1aEpjJ29ibavL+P5hTvZdixJy4+JSJkoKCggOzubVq1a4eLiQlTU+R7jffv2ER0dTWRkpAMjvIyrLKL2v/VHiUnOItzXnXvb17JhYCIiUlEVe063yDWhzXDY9iXEbINfXoCB0y9+3MoJcGCZOafv7i9LPSfbnOc9H6JegbXvwdp34cwRuHPm+ernNhLo7cbQG69jaHNPCt67E2tuOunuYfw3rSNf/hbNl79FUy/YmztaVef266sR7ONu0+uLSOU0btw4+vbtS82aNUlNTeWrr75i5cqVLFmyBF9fX4YPH87YsWPx9/fHx8eHRx99lMjIyEsWUXMow7iqImopWblMWWnWqnmiZ32NMhIREUA93VLZWJ3g1ncAi1nR/NCFNQLYuxhWTzK3b3u/VGtuX3DNnq+aBdWcXGHPIvhzydWd83JWTsCamw7As4Fr+eKBtvRvGY6bs5X9p9KY8NNeIicu54GZm/hxZwzZebbreReRyufUqVPcd999NGjQgO7du7Np0yaWLFlCz549AXjnnXe49dZbGTRoEJ06dSI0NJQFCxY4OOpLSD4GmWfA6gLBjUr89umrDpGUkUvdYG8GXl/NDgGKiEhFpDndF1FR59BJCSx+CjZ9YlamHbX2/Prf8fthelfISYV2o6DvRNted+l4s7c7oC6MWn91S6FdzOl98FEkGPlgdYaCPHgwCqq3JiUrlx+2xzB/yzF+j04qfIufpwv9W4RzZ+saNAn30fJjIuWI2iNTmd2HP76HufdCaHMY+WuJ3noqNYvOb64kMzef//6zFb2bhNopSBERcRTN6RYpiW4vglcwJOw3C+YAZKfCnCFmwl2rA/R6zfbX7fgUeAVBwgEz6be1pePNhLvBLdDsTnPf2ev4uLtwT7uaLHikA8vGdmZUlwhCfNxIyshl1vqj3PrBGnq/u5rnFu7ky9+Osv1YElm56gUXkUrkKuZzf7j8AJm5+bSs4UevxiE2DkxERCoyzemWysnDD3q/bhZLW/0WNB1kJqzx+6BKmDnn2skOS7y4+5gJ//ePwaqJ0HwweAXY5tyHV8OfP4HFCXq+AlnJsH22uXxZ7/8UmZdeN9ibZ/o05OleDfh1/2nmbTnO0t1x/BmXxp9xaYXHOVkt1Av2pnG4D03DfWkS7kPjcB8tfyMi16ZSJt3RCRl89Vs0AM/0aagRQyIiUoSSbqm8mt0JW/9nJquf9oG0OHMe313/A+9g+133+nth08fmGuArJ8Atb139OQsKzMJwAK0fgMB6ZkGg0OZmUaCtX0CHxy54m5PVQpcGwXRpEExSRg6/7o9n98kUdp9MZvfJFBLTc9gbm8re2FQW/H6i8H3XBXjSJNyXJtXMZLxtbX8VDBKRiq8w6W5Zore9vXQfeQUGneoHERlhoz+kiojINUNJt1ReFgvcMhmm3mgm3AA3T4Iabex7XasT9J4As26FzZ+aFdVLUbCniF3zzV8WXatAl2fNfRaLuRb594+Z14kcA9ZLzyjx83SlX4tw+rUIB8AwDGKSswqT8F0nUthzMpmTyVkcScjgSEIGi3fGAFDFzZk+TUO5/fpqtKsTgJNVvTwiUsGkxpptgcUKIU2K/bbdJ5P5dttJAP7du4G9ohMRkQpMSbdUboH1oOPTsPI/cMNQaHV/2Vy3dkdo1M8s2rPkObh3QemXEMvNhKhXze2OT4JX4PnXmt0Bv7wIZw7DoeVQt0exT2uxWAj38yDcz4Oef5mfmJieU9gTvutEMluOniEmOYt5W44zb8txQnzc6N+yGgNaVqNRWBUNsxSRiuFcL3dgfXD1LPbb3lqyD4Bbm4fRtJqvPSITEZEKTkm3SOd/Q+P+ENTA5mtnX1bPV82lww4uh/2/QP3epTvPb9PMZW58qkH7R4q+5uoFLf9hHrPp0xIl3Zfi7+VKx3pBdKwXBEBBgcHmo2dYuPUEi3ecJC4lm+mrDzF99SHqh3gz4Ppq9G9ZjWp+Hld9bRERuynFfO7fDiWwYt9pnK0Wnu6lXm4REbk4VS8XsVgguGHZJtwA/nWg/Shze8lzkJ9b8nOkJ8Cvk83tbi+Cy0US29YPmD///AmSjpUu1suwWi20re3PhIHN2PRCD/77z1b0bRqKq7OVP+PSePPnfXSYuJy7/ruer36LJjmjFJ9TRMTeSph0G4bBm2d7uQe3qcF1gV72ikxERCo49XSLOFLHp2HbV+eXEDuXhBfXqjcgOwVCm5mV0C8mqAFc1xGO/Aq/z4JuL1x93Jfg5uxE7yah9G4SSnJmLj/vimHR1pNsOJzAxsOJbDycyMvf7aZrwyAi6wQQEexNnSBvwnzcsWoeuIg4UswO82cxk+5lf5xiy9EzuLtYeax7PTsGJiIiFZ2SbhFHcvcxk+DvHzcrmTcfXGRpr8uKPwCbZ5jbvV6/bJE02gw3k+4ts6DTv8HZ9epjvwJfDxcGt6nJ4DY1iUnO5LttJ1m49QR7Y1NZsjuOJbvjCo/1cHGidqCXmYSf/RkR5EWdQG88XFUVXUTsLCMRks0lvwhtdsXD8wsMJi3ZC8CwDrUJ8XG3Z3QiIlLBKekWcbTr/wkbP4a4XWbiffOk4r1v2XgoyIN6vaFO58sf2/BW8A4xK/Pu/QGaDrz6uEsgzNeDhztH8HDnCPbGpvDjzlj2xqRw8HQaRxMyyMzNZ09MCntiUi54bzU/D+oEeRERZK4XfmNEANWrFr/IkYjIFZ0bWu5fB9yvXAxt0dYT/BmXho+7MyM7Rdg5OBERqeiUdIs4mtUJ+kyAWf1g0wxoPdycY345R9ebybPFahZkuxInF7M6++o3zWuUcdL9Vw1DfWgY6lP4PDe/gGOJGRw6nc7B02nnf8ank5iew4mkTE4kZfLr/vjC99T09+TGiAAizz6Cq6iXSUSuQgnmc2fn5TN56Z8APNK1Lr6eLvaMTERErgFKukXKg9qdzN7ovT/AL8/Dvd9c+ljDMI8BuOG+Kyfo57S6H359G46ugVN7i/8+O3NxslInyJzb3YOQIq8lpudw6GwifuB0GpuPJLL9eDLRiRlEJ2YwZ5NZGK5esPfZJDyQ9nX88fO0//B5EbmGlCDp/uq3aE4kZRLi48bQyOvsG5eIiFwTlHSLlBfnlhA7sAz2L4V6PS9+3O4FcGILuHhBl+eKf37fatCgr5nYb55R/GHsDuTv5Yq/lz+trzs/zz0tO49NhxNZdzCedQcT2BOTwv5Taew/lcas9UexWKBJuA83RgQSGRFAq1pV8XFXT5SIXEYxk+607Dw+XH4AgMe711fNCRERKRYl3SLlRUAEtB8J6z4wlxCr08UcFv5Xedmw7BVzu8PjUCXkgtNcVpvhZtK9fQ50Hw9u3jYJvSx5uznTtWEwXRsGA3AmPYffDiew7qD5OHAqjV0nUth1IoXpqw8BEFzFjTpBXmaPeqA5P7xOkBfVq3ripKrpIpVbVgokHjS3Qy+fdH/y6yES0nOoHejFna2rl0FwIiJyLVDSLVKedPoXbJsN8X/C5k+h3cNFX9/4MSQdBe9QuHFMyc9fu4tZKCjxEOycB62H2SJqh6rq5UqfpmH0aRoGwKmULNYfSmDdgQTWHYrnWGImp1KzOZWazYZDiUXe6+pkpVaAZ5GEvE6QN7UCPPHzcMHZ6TIV4UXk2hC70/zpUx28Ai55WEJaNh+f/UPeU73q46J/H0REpJiUdIuUJ+6+0O15+OFJWPEfaHbn+SXEMhLNQmhgLjPm6lXy81utZqG2X543h5i3uh8s11ZPb7CPO/1bVqN/y2oAJGfmcjg+vXBu+KF48+fh+HSy8woKh6ZD3AXnquLmjK+nC36eLvh6uODn4Ypv4fa5/a74ergQVMWViCBvLNfY/RS55sUWb33uKSsOkp6TT9NqPtx89o98IiIixaGkW6S8uf4+2PgJnNoNq96Avm+Y+1e/BVnJENwEWt5T+vO3vAeWv2b27hzfBDXa2ibucsrXw4WWNfxoWcOvyP6CAoMTSZmFFdPPJeOHTqcTm5IFQGp2HqnZeRw/k1msa9UJ8mJw6xoMvKE6QVXcbP1RRMQeijGf+/iZDL7YcBSAZ/o0xKppKSIiUgJKukXKGydncwmxz28zh5O3fgCcXGHjdPP1Xq+ay4yVlqc/NB0E2740lw+7xpPuS7FaLdTw96SGvyddGhR9LTe/gJTMXJIzc0nKzCU54+x2Ro75/Oy+c9tJGebSZodOpzPhp71MWrKP7o2CubtNTTrVD9K8cZHyrBhJ9wdRB8jJL+DGiABuqhtYRoGJiMi1Qkm3SHlUpzM0uAX2LYZfzg4lL8iFiG5Qt8fVn7/1cDPp3r0Aev/nsvMYKyMXJysB3m4EeBe/tzotO48ftp9kzqZjbDuWxJLdcSzZHUeojzt3tq7OXa1rUMPf045Ri0iJ5WTA6b3m9iWS7py8AhbvjAHgiR71NYVERERKTFVARMqrXq+B1QX2/wK7FwIW6Pmabc5d7QYIawn5ObDtC9ucs5LzdnPm7rY1WTS6A0ue6MQDHWrj5+lCbEoWHyw/QMc3VzDkkw18u+0EWbn5jg5XRABO7QGjALyCoUroRQ/57XACadl5BFVxo3WtqmUcoIiIXAuUdIuUVwERRauXXz8EQpva5twWi7l8GJhV0gsKbHNeAaBBaBVe6teY357rzof3XE/HeoFYLLD2QAKPz9lGu/9E8fJ3u9lzMgXDMBwdrkjlFbPN/BnW4pJFJaP+OAVAtwbBmsstIiKlouHlIuVZp3/BrgWQmwFdn7ftuZveAUtegDNH4OByqGeDYetShJuzE7c2D+fW5uEcP5PBvM3Hmbf5GCeTs5i57ggz1x3Bx92ZusHeRAR5Uzf4/ENriIuUgSvM5zYMg2V/mCsbdG8UXFZRiYjINUZJt0h55uEHo9ZCQT54B9n23K6eZiXz36bCpk+UdNtZ9aqePNmzPo91r8eaA/HM3RTN0j1xpGTl8Xt0Er9HJxU53tXZSp1ALyL+kpBHBHkREeSNu8tVFNITkfMKk+7mF335z7g0jp/JxNXZyk31VEBNRERKR0m3SHl3bp1ue2gz3Ey69y+BpGjwq2m/awkATlYLnesH0bl+EFm5+RyOT+fg6TQOnDIfB0+ba4pn5xWwNzaVvbGpRd5vsUCQtxshPu6E+LgR7ONOSBVzO8T3/HZVT1cNhRW5nLwcOPWHuX2Jnu5zvdwdIgLwdNWvTCIiUjoObUFWr17NpEmT2LJlCzExMSxcuJABAwZc9j0rV65k7Nix7N69mxo1avDCCy9w//33FzlmypQpTJo0idjYWFq0aMEHH3xA27aVc1kkkcsKrAe1O8Hh1bBlJnR/ydERVSruLk40CvOhUZhPkf35BQYnzmT+LRlP48DpNJIycjmVms2p1Gx2nrj0uV2cLARXcSfYx41QH3fqh1Sha8NgmlfzVTIuAmbV8vwccPcFv1oXPSSqcGh5SFlGJiIi1xiHJt3p6em0aNGCBx54gIEDB17x+MOHD3PLLbcwcuRIvvzyS6KionjwwQcJCwujd+/eAMydO5exY8cybdo02rVrx7vvvkvv3r3Zt28fwcGajyVygTYPmkn3759D52fB2dXREVV6TlYLNQM8qRngSdeG5//dMgyDxPQcYpKziEvJIi4lm9iULE6lnH8el5JFQnoOufkGJ5IyOZGUCcBPu2J5L2o/gd6udK4fTLeGwXSsH4iPu4ujPqaIY/11PvdFiqjFp2Wz9VgSoPncIiJydRyadPft25e+ffsW+/hp06ZRu3Zt3n77bQAaNWrEmjVreOeddwqT7smTJzNixAiGDRtW+J7Fixfz6aef8uyzz9r+Q4hUdA1uBu9QSIuFP76DZnc4OiK5BIvFUrh+eNNqvpc8LievgNNpZgIel5xFTHIWm44k8uv+eOLTcvjm9+N88/txnK0WWl9XlW4NzSQ8IshbaxBL5XGFImor9p7CMKBpNR/CfD3KMDAREbnWVKgJSuvXr6dHj6LFnnr37s0TTzwBQE5ODlu2bGHcuHGFr1utVnr06MH69esved7s7Gyys7MLn6ekpNg2cJHyzMkFWt0Pqyaay4cp6a7wXJ2tVPPzoJrf+UThgZtqk5NXwOYjiSzfe4rl+05x6HQ6Gw4lsuFQIv/5cS81/D3o1iCYrg2DaV8nQAXb5NpWmHS3vOjL55YK695QQ8tFROTqVKikOzY2lpCQoo1fSEgIKSkpZGZmcubMGfLz8y96zN69ey953gkTJvDKK6/YJWaRCqHVUFg9CY6uhZNbIfx6R0ckduDqbOXGuoHcWDeQF25tzNGEdDMB33uK3w4lciwxk1nrjzJr/VE8XJxoWcOPwCpu+Hu64O/lhr+XC1W9XPE/9/B0xc/TFVdnq6M/mkjJFORD7E5z+yI93dl5+fy6/zQAPTSfW0RErlKFSrrtZdy4cYwdO7bweUpKCjVq1HBgRCJlzCccGt0Ke76F/90Od38FtW603/VyM8HZ/aLzKKXs1ArwYliH2gzrUJv07DzWHohnxb5TrNh7mtiULNYfSijWeaq4O+Pv5UpVT1eCq7jRKMyHptV8aVbNlxAfNw1Zl/Infj/kZYKrN/hHXPDyhkOJpOfkE+LjRtNqPhc5gYiISPFVqKQ7NDSUuLi4Ivvi4uLw8fHBw8MDJycnnJycLnpMaGjoJc/r5uaGm5ubXWIWqTBufhuSj8OJLfB5f+j/ETS/07bXMAxYPwWiXoXwljBoBvjpD1zlgZebM72ahNKrSSiGYbAnJoU/41JJTM/lTHoOCek5nEnPITHj7M/0HM5k5FBgQGpWHqlZeRxNyADglz3n/w0O9HalSbgvTav50DTcl6bVfKle1UOJuDjWuaHloc3AeuFIjXNVy7s1DNF3VURErlqFSrojIyP58ccfi+xbunQpkZGRALi6utKqVSuioqIKlx4rKCggKiqKMWPGlHW4IhWLdxAM/QEWPgR/fA8LHoQzR6DT07bpkc5IhEWj4M+fzefHfoP/doSBn0C9Hpd/r5Qpi8VCk3BfmoRfulgbQEGBQUpW7vmEPD2HE0mZ7D6Zwq4Tyew/lUZ8Wg6r/jzNqj9PF77P18OlMAlvUs2XxmE+hPq64+XqpARHysZliqgZhlE4n7uHqpaLiIgNODTpTktL48CBA4XPDx8+zLZt2/D396dmzZqMGzeOEydO8PnnnwMwcuRIPvzwQ/7973/zwAMPsHz5cr7++msWL15ceI6xY8cydOhQWrduTdu2bXn33XdJT08vrGYuIpfh6gl3fg7LXoJ1H8CK/4Mzh+HWd69uKbGj6+Gb4ZByApzcoOs42L0IYrbBl3eYiX2XcWBV4a6KxGq14Hd2XjdBF76elZvP3thUdp1IZvfJZHaeSGZfbCrJmbmsPZDA2gNFh6+7OlsJ8HIlwNsVfy83As7OHQ/wdj277faXbVe83ZyVpEvpxO4wf4Y2v+ClvbGpnEjKxN3FSoe6gWUcmIiIXIscmnRv3ryZrl27Fj4/N6966NChzJw5k5iYGKKjowtfr127NosXL+bJJ5/kvffeo3r16nzyySeFy4UBDB48mNOnT/PSSy8RGxtLy5Yt+fnnny8oriYil2C1Qq//g6rXwY//gm1fQvIxuOt/4OFXsnMV5MOaybBiAhj5EFAX7vgMwppDu1Gw5DnYPMMs4nbsN3O4ubd6lq4V7meLsbWs4Ve4LyevgD/jUtl9MpldJ1LYddJMxDNy8snJKyDm7BJnxeFsteDj4YKPuzO+Hi74eLgU+enr4YKP+/ltXw8Xrgv0pIrWJq/cCgou29N9bmj5TXUDVcFfRERswmIYhuHoIMqblJQUfH19SU5OxsdHBVSkEtu/FObdDzlpENgAhnxtJuPFkRpnDlU/tNJ83nww3DIZ3LyLHrdjHnz/OOSmm+uF3/EpXNfBhh9CKoKMnDwS0swh6onpOcSnZf9lO4fE9Oy/bOeQmZtfqus4WS00reZLZJ0AIiMCaF2rKl5u5Xemldojk03vQ+IheP96c9TNcyfMZRP/ov+UtWw/lsSEgc34R9uaV3ctERG5ppS2PSq/v2mIiOPV6wkP/Axf3gXx++Dj7nDPXKje+vLvO7gCFjwE6afAxRNufgta3nPxueHN7zR7vr++D07vhVn9oPtLcONjFy1wJNcmT1dnPP2dqeHvWazjM3PySc7MLXyk/GU7OTOXlKyi+1My80jMyOF0ajbbjyWx/VgS01YdxNlqoXl1XyIjAoisE0irWlXxcFXv5jXtXC93SJMLEu5TqVlsP5YEQPeGGnUjIiK2oaRbRC4vtBmMiIKv7jLXtZ15CwycDo37X3hsfh6smgir3wIMCG5sDicPbnj5awQ1gBHL4YcnYcdcWDYeojfA7VPBo6pdPpZUbB6uTni4OhHq616i951MymT9wQTWH0pg/cEETiRl8nt0Er9HJzFlxUFcnay0rOFH+4gAIusEcH1Nv8Ihxn/vjU9IN3vgE9JzSEz76z7z8c2oG2kQWsUeH1+uxmWGlq/YaxZQa17dl2Cfkn23RERELkVJt4hcmU84DPsJ5j8A+3+Br4dCz1fhxkfP914nn4BvHoTodebzG4ZCn4lmcbbicPWC2/8LNSPhp2fgz5/gv53grs8h/Hr7fC6pdML9PBjUqjqDWlUH4FhiBusPJrDhkJmIxyRnsfFIIhuPJPJ+1H5cna0EermSmJFDVm5Bia6VkJ4NXPtJ94QJE1iwYAF79+7Fw8ODG2+8kTfeeIMGDRoUHpOVlcVTTz3FnDlzyM7Opnfv3nz00UeOqbdymaR72dmq5d0bqg6MiIjYjpJuESketypw92z4+VnY9DEsfdGcG3nzW3AwChaOhMxEcK0C/d6FZneU/BoWC7QeZibZ84aaS5bN6AV9JkDr4bZZukzkL2r4e1LD35O72tTAMAyOJmQU9oKvP5TA6dRsTv6lsJvb2QrrVc9VVv9LVXX/IvtcCffzcOAnKzurVq1i9OjRtGnThry8PJ577jl69erFnj178PLyAuDJJ59k8eLFzJs3D19fX8aMGcPAgQNZu3Zt2QZrGJdMurNy81mzPx6A7loqTEREbEiF1C5ChWtELsMwYMNHsOR5wDALrMXvM18La2EOJw+IuPrrZCbBt6Nh7w/m86Z3QL/3LizEJpVPTjps+gSuuwmqtbLbZQzD4FB8OqlZeYWJtGcZryVeEduj06dPExwczKpVq+jUqRPJyckEBQXx1Vdfcccd5h/j9u7dS6NGjVi/fj3t27e/4jltdh8yk+CTHpB0FJ49Bi7nh5Cv2HuKYTM3Eebrzrpnu2k5OhERuUBp2yNVKRKRkrFYIHI0DP4CnD3OJ9ztRsLwpbZJuMFcnmzwF+byZRYn2DUfpneGk1ttc36puJY8B0tfMkdBrP/I/EOQHVgsFiKCvGlZw48a/p54aV3wYklOTgbA398fgC1btpCbm0uPHj0Kj2nYsCE1a9Zk/fr1Fz1HdnY2KSkpRR424eEHj26GZ44WSbgBlp1dKqxbw2D9dxYREZtS0i0ipdPoVhj2IzS5He7+Cvq+Ac5utr2GxWLOGx/2I1QJh4QDZi/Vr5PNNcCl8jm6HrbMNLcL8mDJOHMqQpaNkjK5KgUFBTzxxBN06NCBpk2bAhAbG4urqyt+fn5Fjg0JCSE2Nvai55kwYQK+vr6Fjxo1atg20L/VmjAMg+Vni6j1aKT53CIiYltKukWk9KrdAHfOhIa32Pc6NdvDqLXQ6DYz0Yp6BWbdBknH7HtdKV/yss013QFuuA/6TgKrC+z5FqZ3gbjdDg1PYPTo0ezatYs5c+Zc1XnGjRtHcnJy4ePYMfv+v777ZAoxyVl4uDgRGRFg12uJiEjlo6RbRCoGT3+zknn/KeDqDUfXwNQOsHO+7a5hGHAgyuxJzUi03XnFNta+Z05n8Ao2q+e3e8isqu9THRIPmuvIb/vK0VFWWmPGjOGHH35gxYoVVK9evXB/aGgoOTk5JCUlFTk+Li6O0NDQi57Lzc0NHx+fIg97ijpbtfymeoGFS8SJiIjYipJuEak4LBa4/l4Y+StUbwPZyfDNcPhmBGQll/68ORmw+VOY0g6+GGj2pr7XAlZNguw028UvpRe/H1ZPMrf7TDi/fnuNNvDwaojoDnmZsGgUfPcY5GZd+lxiU4ZhMGbMGBYuXMjy5cupXbt2kddbtWqFi4sLUVFRhfv27dtHdHQ0kZGRZR3uRUXtNedz91DVchERsQMl3SJS8fjXgWE/Q+dnwWKFnV/D1Jvg6LqSnSf5BCx7Gd5pDD88afaiulaBgHqQnQIr/s9Mvtd/pCTOkQwDvn8C8nOgbk9oOqjo614BMGQ+dH0esMDvs2BGT0g87IhoK53Ro0fzxRdf8NVXX1GlShViY2OJjY0lMzMTAF9fX4YPH87YsWNZsWIFW7ZsYdiwYURGRharcrm9xaVkseO4+Ue7rg2VdIuIiO1pybCLqIhLtIhUWsc2woIR5preFivc9CR0GQdOLpd+z/HN5rJnuxeBcbYgW9XrzArsLYeYw9d3L4AVr5trkQP4VIPOz0DLey5/bkczDMjPhdwMyM00f+ZlgV+tirvc2u//g+/GgIsnPLIBqta69LEHl8M3D0JGArj7woBp0PDmsovVxipCe3SpSt+fffYZ999/PwBZWVk89dRTzJ49m+zsbHr37s1HH310yeHlf2fP+zB7YzTjFuykRQ0/vh3dwabnFhGRa0tp2yMl3RdREX7JEZG/yE6Fn56BbV+az8NvgIEfQ2Dd88fk58Ef38GGqXB84/n9tW6CyEegfh+w/m0uZ36uOUd41RuQcsLc51/H7FFtMhCsZTxYKOWkOcQ6Kfp8Qp2b+bdHxvk/JPyVux8M+Mj+Re9sLe00fNgaspLM5eNufPTK70k+DvOGnf/v3OEJ6PYiODnbM1K7UHtksud9eHDWJpb9cYqnetbn0e71bHpuERG5tijptiH9kiNSQe1eZM7Hzkoye0X7TIDG/WHLLNj4MaQcN49zcoWmd0D7kRDW4srnzc0y53z/+pbZgwoQ0hS6vWAm6/Ze09cwYMdc+OnfJZu7brGa9wEL5KSa+9qNgp6v2H55N3v55kHYOQ9Cm8OIFcVPnPNyYNl4c0QDmH9cueNTqFKxloNSe2Sy133Iys2n5au/kJVbwI+PdaRxeOW9xyIicmVKum1Iv+SIVGDJJ2DRSDi82nxudTaXGQPwDIQ2D0LrB0qXfGWnwoZpsO59c843mAXdur8EtTvZJv6/S40z55vvW2w+D78B2gwHVy8zoXbxAGcP86eLx/l9Lp7mMHiLxUxAo16B9R+a5whrAXd8BgER9onZVg4sgy8GmX88eDDKXKKupHYvhG/HQE4aeIeYn/u6ijOEWO2RyV73IeqPOIbP2ky4rztrn+12yaHyIiIioKTbpvRLjkgFV1AAG6ZA1Ktm8a2QptB+lNm77eJ+9efPSDQT7w3TzIrZALU7Q8ex5k9b/OJuGLDrG/jxacg8Y65H3eVZc6h0aYdJ/7kEFo6EzESzYFy/d6HZHVcfqz3kZMBH7SHpKLR/xBy1UFrx++Hr++DUHvOPMP3eh+uH2C5WO1J7ZLLXfRi3YCezN0bzz/a1eG1AU5udV0RErk1Kum1Iv+SIXCMSDprDwau3sc8Q8NRY+PVt2PwZFOSa+84l+M3uLP0Q7vR4WDwW9nxrPg9tDrdPg5AmVx9z8glzyHb02UrvNwyFPhPB1fPqz21LS18y1+X2rWEWT7vaInA5GfDtaLNAHkCnf5lz88t5z6baI5M97oNhGLSfEEVcSjYzh7WhSwNVLhcRkcsrbXukJcNE5NoVEAE12tovsaoSCjdPgke3QJsR5pDuuF1mcvdOE1j5hlkIrCT2fGeuF77nW7NXtss4GLHcNgk3gG81GPo9dPo3hctrfdwNTu21zfltIWYHrDs7FP7mt2xTdd3VEwbNgI5Pm89XTzL/+KCl4CqtXSdSiEvJxtPVifZ1AhwdjoiIXMOUdIuIXK2qteCWt+DJ3dDjZagSDumnYeV/zOT72zEQt+fy58hIhPnD4et/QkY8BDcx5zF3edb2S5Q5OUO35+G+ReAVDKf/gOldYOsX5rB2RyrIN4vhGflmEbwGfWx3bqsVur8I/aeYf9DYNR8+7w/pCba7hlQYy/6IA6BjvUDcXZyucLSIiEjpKekWEbEVT39znfAndpi9quE3QH42bP0fTI2EzwfA/qXmnPO/2veTOX9513ywOJm9sQ+tgPCW9o23ThcYtRbqdDXnpn87GhY8ZBaMc5SNH8PJ38HNF/q+aZ9rXH8v3LvAvMaxDfBJd4g/YJ9rSbkVtddMurs3qlgV7UVEpOJR0i0iYmtOLmaBshHL4YEl0Og2swL3oRXw5R3wUTtzCbLUWFg4CmbfDWlxENgAHlxq9saW1ZJe3sFmAtp9vJnw7/wa/tvZHOJd1pKPw/LXzO0e483h+/ZSp7N5r/1qwpnDZuJ9ZK39riflSmxyFrtOpGCxQLeGmsstIiL2paRbRMReLBao2R4G/w8e2wrtR5tVw+P/NJcBe7sBbP8KsMCNj8HDq6Faq7KP02o1K68P+xF8qkPiQfikB6x5FxIPl82Qc8OAH/9lLu1Vox20Gmb/awY1gAeXm4X2spLMoebb59j/uuJw53q5W9bwI9C7gqxZLyIiFZaSbhGRslD1OujzHxi7B3pPAL9a5n7/CLM3vNdrtlnO7GrUbA8jf4UGN5vD4peNh/dbmvPSvxkBW2aay2/ZIwn/43vY96O5NFq/98w/BJQF7yCzsFzjAWYF+oUPw4oJjp/bLnYV9ccpAHpoaLmIiJSBUi72KiIipeLuA5GPQLuHIWabWTDN0cn2X3n6w91fwZbPzF7fE79Dyglz2PnOr81jvEOg1o1Qq4P5CGp4dUlyVrLZyw1w0xMQ3OiqP0aJuHjAHZ/B8tqw5h1YNdEccn7bB2U3zF/KTEZOHmsPxAPQvZGGlouIiP0p6RYRcQSrk2OGkheHxQKtHzAfORlwfCMcXWfOeT6+yZx/vnuh+QDw8D+fhFdvDe6+ZiLr4mn+dPa4fFIe9SqkxZq9/ueW9CprVqtZeb5qbXPo/465kHQM7v7S/EOEXDPW7I8nO6+Aan4eNAip4uhwRESkElDSLSIil+bqaVY5r9PFfJ6bBSe2mEn40TVwbCNkJsLeH8zHpTi7F03Ez207u8Ph1eYx/d51fK9/q6HgVwO+HgrR68y57f0/BCdXyM00H3lnf+ZmmPcjN+Ps/qyi+3q8DP61Hft55ALnh5YHY7FYHByNiIhUBkq6RUSk+Fzc4boO5oN/QV4OxGw3E/Aja+HUnqJJ6Dl5WeYj88zFz9tyCNTuVCYf4YoiusHwX+DLu8yicp/1Ld15Ikcr6S5nCgoMovaaSbeWChMRkbKipFtERErP2RVqtDEfNz1Z9LWCgr/1Cl/sZ6Z5bKN+ZR/75QQ3ggeXmWuXx2wr2jPv4mn+8aFw+Pzf9p177lvD0Z9C/iY+PZtQXzeycvNpV0fTBkREpGyUi6R7ypQpTJo0idjYWFq0aMEHH3xA27ZtL3psly5dWLVq1QX7b775ZhYvXgzA/fffz6xZs4q83rt3b37++WfbBy8iIhdntYKrl/moiKqEwL3zHR2F2FBwFXd+eLQjyZm5uDk7OTocERGpJByedM+dO5exY8cybdo02rVrx7vvvkvv3r3Zt28fwcEXVhVdsGABOTk5hc8TEhJo0aIFd955Z5Hj+vTpw2effVb43M1NFWhFREQEfD1cHB2CiIhUIg5fp3vy5MmMGDGCYcOG0bhxY6ZNm4anpyeffvrpRY/39/cnNDS08LF06VI8PT0vSLrd3NyKHFe1atWy+DgiIiIiIiIihRyadOfk5LBlyxZ69OhRuM9qtdKjRw/Wr19frHPMmDGDu+++Gy+vosMXV65cSXBwMA0aNGDUqFEkJCRc8hzZ2dmkpKQUeYiIiIiIiIhcLYcm3fHx8eTn5xMSUrSCaEhICLGxsVd8/8aNG9m1axcPPvhgkf19+vTh888/JyoqijfeeINVq1bRt29f8vPzL3qeCRMm4OvrW/ioUUPFb0REREREROTqOXxO99WYMWMGzZo1u6Do2t1331243axZM5o3b05ERAQrV66ke/fuF5xn3LhxjB07tvB5SkqKEm8RERERERG5ag7t6Q4MDMTJyYm4uLgi++Pi4ggNDb3se9PT05kzZw7Dhw+/4nXq1KlDYGAgBw4cuOjrbm5u+Pj4FHmIiIiIiIiIXC2HJt2urq60atWKqKiown0FBQVERUURGRl52ffOmzeP7Oxs7r333ite5/jx4yQkJBAWFnbVMYuIiIiIiIgUl8Orl48dO5aPP/6YWbNm8ccffzBq1CjS09MZNmwYAPfddx/jxo274H0zZsxgwIABBAQEFNmflpbGv/71LzZs2MCRI0eIioqif//+1K1bl969e5fJZxIRERERERGBcjCne/DgwZw+fZqXXnqJ2NhYWrZsyc8//1xYXC06OhqrtejfBvbt28eaNWv45ZdfLjifk5MTO3bsYNasWSQlJREeHk6vXr147bXXtFa3iIiIiIiIlCmLYRiGo4Mob1JSUvD19SU5OVnzu0VExGHUHpl0H0REpDwobXvk8OHlIiIiIiIiItcqhw8vL4/Odf6npKQ4OBIREanMzrVDlX1QmtplEREpD0rbLivpvojU1FQArdUtIiLlQmpqKr6+vo4Ow2HULouISHlS0nZZc7ovoqCggJMnT1KlShUsFstVnSslJYUaNWpw7NixSj0PTffBpPtg0n0w6T7oHpxzqftgGAapqamEh4dfUFS0MlG7bHu6DybdB5Pug0n3QffgHFu3y+rpvgir1Ur16tVtek4fH59K/cU9R/fBpPtg0n0w6T7oHpxzsftQmXu4z1G7bD+6DybdB5Pug0n3QffgHFu1y5X3z+YiIiIiIiIidqakW0RERERERMROlHTbmZubG+PHj8fNzc3RoTiU7oNJ98Gk+2DSfdA9OEf3oezoXpt0H0y6DybdB5Pug+7BOba+DyqkJiIiIiIiImIn6ukWERERERERsRMl3SIiIiIiIiJ2oqRbRERERERExE6UdNvZlClTuO6663B3d6ddu3Zs3LjR0SGVqZdffhmLxVLk0bBhQ0eHZXerV6+mX79+hIeHY7FYWLRoUZHXDcPgpZdeIiwsDA8PD3r06MH+/fsdE6ydXOke3H///Rd8N/r06eOYYO1owoQJtGnThipVqhAcHMyAAQPYt29fkWOysrIYPXo0AQEBeHt7M2jQIOLi4hwUsX0U5z506dLlgu/EyJEjHRSxfUydOpXmzZsXrvsZGRnJTz/9VPh6ZfguOJraZbXLapfVLqtdVrt8Tlm1y0q67Wju3LmMHTuW8ePH8/vvv9OiRQt69+7NqVOnHB1amWrSpAkxMTGFjzVr1jg6JLtLT0+nRYsWTJky5aKvv/nmm7z//vtMmzaN3377DS8vL3r37k1WVlYZR2o/V7oHAH369Cny3Zg9e3YZRlg2Vq1axejRo9mwYQNLly4lNzeXXr16kZ6eXnjMk08+yffff8+8efNYtWoVJ0+eZODAgQ6M2vaKcx8ARowYUeQ78eabbzooYvuoXr06EydOZMuWLWzevJlu3brRv39/du/eDVSO74IjqV02qV2+kNplk9plU2X4t1jtsqnM2mVD7KZt27bG6NGjC5/n5+cb4eHhxoQJExwYVdkaP3680aJFC0eH4VCAsXDhwsLnBQUFRmhoqDFp0qTCfUlJSYabm5sxe/ZsB0Rof3+/B4ZhGEOHDjX69+/vkHgc6dSpUwZgrFq1yjAM87+9i4uLMW/evMJj/vjjDwMw1q9f76gw7e7v98EwDKNz587G448/7rigHKRq1arGJ598Umm/C2VJ7bLaZcNQu2wYapf/Su2ySe3yefZol9XTbSc5OTls2bKFHj16FO6zWq306NGD9evXOzCysrd//37Cw8OpU6cOQ4YMITo62tEhOdThw4eJjY0t8t3w9fWlXbt2le67sXLlSoKDg2nQoAGjRo0iISHB0SHZXXJyMgD+/v4AbNmyhdzc3CLfh4YNG1KzZs1r+vvw9/twzpdffklgYCBNmzZl3LhxZGRkOCK8MpGfn8+cOXNIT08nMjKy0n4Xyora5fPULheldvk8tctql9Uu26dddrZ1sGKKj48nPz+fkJCQIvtDQkLYu3evg6Iqe+3atWPmzJk0aNCAmJgYXnnlFTp27MiuXbuoUqWKo8NziNjYWICLfjfOvVYZ9OnTh4EDB1K7dm0OHjzIc889R9++fVm/fj1OTk6ODs8uCgoKeOKJJ+jQoQNNmzYFzO+Dq6srfn5+RY69lr8PF7sPAPfccw+1atUiPDycHTt28Mwzz7Bv3z4WLFjgwGhtb+fOnURGRpKVlYW3tzcLFy6kcePGbNu2rdJ9F8qS2mWT2uULqV02qV1Wu6x22X7tspJusau+ffsWbjdv3px27dpRq1Ytvv76a4YPH+7AyMTR7r777sLtZs2a0bx5cyIiIli5ciXdu3d3YGT2M3r0aHbt2lUp5k9ezqXuw0MPPVS43axZM8LCwujevTsHDx4kIiKirMO0mwYNGrBt2zaSk5OZP38+Q4cOZdWqVY4OSyoJtctyKWqXKy+1y/ZvlzW83E4CAwNxcnK6oLpdXFwcoaGhDorK8fz8/Khfvz4HDhxwdCgOc+6/v74bRdWpU4fAwMBr9rsxZswYfvjhB1asWEH16tUL94eGhpKTk0NSUlKR46/V78Ol7sPFtGvXDuCa+064urpSt25dWrVqxYQJE2jRogXvvfdepfsulDW1yxendlnt8qWoXU4qcvy1+n1Qu1w27bKSbjtxdXWlVatWREVFFe4rKCggKiqKyMhIB0bmWGlpaRw8eJCwsDBHh+IwtWvXJjQ0tMh3IyUlhd9++61SfzeOHz9OQkLCNffdMAyDMWPGsHDhQpYvX07t2rWLvN6qVStcXFyKfB/27dtHdHT0NfV9uNJ9uJht27YBXHPfib8rKCggOzu70nwXHEXt8sWpXVa7fClql6/tf4vVLl+aXdplW1Z6k6LmzJljuLm5GTNnzjT27NljPPTQQ4afn58RGxvr6NDKzFNPPWWsXLnSOHz4sLF27VqjR48eRmBgoHHq1ClHh2ZXqampxtatW42tW7cagDF58mRj69atxtGjRw3DMIyJEycafn5+xrfffmvs2LHD6N+/v1G7dm0jMzPTwZHbzuXuQWpqqvH0008b69evNw4fPmwsW7bMuOGGG4x69eoZWVlZjg7dpkaNGmX4+voaK1euNGJiYgofGRkZhceMHDnSqFmzprF8+XJj8+bNRmRkpBEZGenAqG3vSvfhwIEDxquvvmps3rzZOHz4sPHtt98aderUMTp16uTgyG3r2WefNVatWmUcPnzY2LFjh/Hss88aFovF+OWXXwzDqBzfBUdSu6x2We2y2mW1yya1y6ayapeVdNvZBx98YNSsWdNwdXU12rZta2zYsMHRIZWpwYMHG2FhYYarq6tRrVo1Y/DgwcaBAwccHZbdrVixwgAueAwdOtQwDHN5khdffNEICQkx3NzcjO7duxv79u1zbNA2drl7kJGRYfTq1csICgoyXFxcjFq1ahkjRoy4Jn/xvdg9AIzPPvus8JjMzEzjkUceMapWrWp4enoat99+uxETE+O4oO3gSvchOjra6NSpk+Hv72+4ubkZdevWNf71r38ZycnJjg3cxh544AGjVq1ahqurqxEUFGR07969sGE3jMrxXXA0tctql9Uuq11Wu6x2+ZyyapcthmEYJesbFxEREREREZHi0JxuERERERERETtR0i0iIiIiIiJiJ0q6RUREREREROxESbeIiIiIiIiInSjpFhEREREREbETJd0iIiIiIiIidqKkW0RERERERMROlHSLiIiIiIiI2ImSbhEpVywWC4sWLXJ0GCIiIoLaZRFbUNItIoXuv/9+LBbLBY8+ffo4OjQREZFKR+2yyLXB2dEBiEj50qdPHz777LMi+9zc3BwUjYiISOWmdlmk4lNPt4gU4ebmRmhoaJFH1apVAXOI2dSpU+nbty8eHh7UqVOH+fPnF3n/zp076datGx4eHgQEBPDQQw+RlpZW5JhPP/2UJk2a4ObmRlhYGGPGjCnyenx8PLfffjuenp7Uq1eP7777zr4fWkREpJxSuyxS8SnpFpESefHFFxk0aBDbt29nyJAh3H333fzxxx8ApKen07t3b6pWrcqmTZuYN28ey5YtK9J4T506ldGjR/PQQw+xc+dOvvvuO+rWrVvkGq+88gp33XUXO3bs4Oabb2bIkCEkJiaW6ecUERGpCNQui1QAhojIWUOHDjWcnJwMLy+vIo/XX3/dMAzDAIyRI0cWeU+7du2MUaNGGYZhGNOnTzeqVq1qpKWlFb6+ePFiw2q1GrGxsYZhGEZ4eLjx/PPPXzIGwHjhhRcKn6elpRmA8dNPP9nsc4qIiFQEapdFrg2a0y0iRXTt2pWpU6cW2efv71+4HRkZWeS1yMhItm3bBsAff/xBixYt8PLyKny9Q4cOFBQUsG/fPiwWCydPnqR79+6XjaF58+aF215eXvj4+HDq1KnSfiQREZEKS+2ySMWnpFtEivDy8rpgWJmteHh4FOs4FxeXIs8tFgsFBQX2CElERKRcU7ssUvFpTreIlMiGDRsueN6oUSMAGjVqxPbt20lPTy98fe3atVitVho0aECVKlW47rrriIqKKtOYRURErlVql0XKP/V0i0gR2dnZxMbGFtnn7OxMYGAgAPPmzaN169bcdNNNfPnll2zcuJEZM2YAMGTIEMaPH8/QoUN5+eWXOX36NI8++ij//Oc/CQkJAeDll19m5MiRBAcH07dvX1JTU1m7di2PPvpo2X5QERGRCkDtskjFp6RbRIr4+eefCQsLK7KvQYMG7N27FzArmM6ZM4dHHnmEsLAwZs+eTePGjQHw9PRkyZIlPP7447Rp0wZPT08GDRrE5MmTC881dOhQsrKyeOedd3j66acJDAzkjjvuKLsPKCIiUoGoXRap+CyGYRiODkJEKgaLxcLChQsZMGCAo0MRERGp9NQui1QMmtMtIiIiIiIiYidKukVERERERETsRMPLRUREREREROxEPd0iIiIiIiIidqKkW0RERERERMROlHSLiIiIiIiI2ImSbhERERERERE7UdItIiIiIiIiYidKukVERERERETsREm3iIiIiIiIiJ0o6RYRERERERGxEyXdIiIiIiIiInby/2ZNF+3uKoIeAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "Experiment 1 Test Accuracy: 72.79%\n" ] } ], "source": [ "# Learning curves\n", "fig, axes = plt.subplots(1, 2, figsize=(10, 4))\n", "\n", "axes[0].set_title('Loss - Experiment 1')\n", "axes[0].plot(history_exp1['train_loss'], label='Train')\n", "axes[0].plot(history_exp1['val_loss'], label='Validation')\n", "axes[0].set_xlabel('Epoch')\n", "axes[0].set_ylabel('Loss (cross-entropy)')\n", "axes[0].legend(loc='best')\n", "\n", "axes[1].set_title('Accuracy - Experiment 1')\n", "axes[1].plot(history_exp1['train_accuracy'], label='Train')\n", "axes[1].plot(history_exp1['val_accuracy'], label='Validation')\n", "axes[1].set_xlabel('Epoch')\n", "axes[1].set_ylabel('Accuracy (%)')\n", "axes[1].legend(loc='best')\n", "\n", "plt.tight_layout()\n", "plt.show()\n", "\n", "# Test accuracy\n", "test_accuracy_exp1, predictions_exp1, true_labels_exp1 = evaluate_model(model_exp1, test_loader_exp1)\n", "print(f'\\nExperiment 1 Test Accuracy: {test_accuracy_exp1:.2f}%')" ] }, { "cell_type": "markdown", "id": "62d510de", "metadata": {}, "source": [ "### 1.6. Experiment 1 observations\n", "\n", "**TODO**: Document your findings:\n", "- What architectural changes did you make?\n", "- How did these changes affect the number of parameters?\n", "- Did the model perform better or worse than the baseline?\n", "- What did you observe about training time and convergence?\n", "- Did you notice any overfitting or underfitting?\n", "\n", "*Your notes here:*\n", "\n" ] }, { "cell_type": "markdown", "id": "cbc07230", "metadata": {}, "source": [ "---\n", "\n", "## Experiment 2: Use RGB images instead of grayscale\n", "\n", "**Objective**: Compare model performance using full RGB color information versus grayscale.\n", "\n", "### 2.1. Load and Preprocess RGB Data\n", "\n", "**TODO**: Modify the transform to keep RGB channels (3 channels) instead of converting to grayscale. Update the normalization to use 3 mean and std values.\n", "\n", "*Hint*: For RGB, use `transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))`" ] }, { "cell_type": "code", "execution_count": 10, "id": "9cf37587", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Files already downloaded and verified\n", "Files already downloaded and verified\n", "Image shape: torch.Size([3, 32, 32])\n" ] } ], "source": [ "# TODO: Modify this transform to use RGB instead of grayscale\n", "transform_exp2 = transforms.Compose([\n", " transforms.ToTensor(),\n", " transforms.Normalize((0.5, 0.5, 0.5), (0.5, 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 training and test datasets with RGB\n", "train_dataset_exp2 = datasets.CIFAR10(\n", " root=data_dir,\n", " train=True,\n", " download=True,\n", " transform=transform_exp2\n", ")\n", "\n", "test_dataset_exp2 = datasets.CIFAR10(\n", " root=data_dir,\n", " train=False,\n", " download=True,\n", " transform=transform_exp2\n", ")\n", "\n", "print(f'Image shape: {train_dataset_exp2[0][0].shape}') # Should be [3, 32, 32]" ] }, { "cell_type": "markdown", "id": "742ac7b8", "metadata": {}, "source": [ "### 2.2. Visualize RGB sample images" ] }, { "cell_type": "code", "execution_count": 11, "id": "72836e10", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAswAAAEkCAYAAAA7LmdoAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAwOpJREFUeJzsvXmYJVWV7r0i4sxDnpPzXJlZWQM1MBbzVAwCIkijAqK32wK1wUblclvta+vXAk7c1m6xG6/adLeAytf3AioOKCDKDDIXUNSUVZWZVZVZOefJMw8Rsb8//CrWWjurDllSUAdcv+fhYZ/c+8SJ2LH3jqhYb7zLUEopEARBEARBEARhn5iHegcEQRAEQRAEoZaRG2ZBEARBEARBqILcMAuCIAiCIAhCFeSGWRAEQRAEQRCqIDfMgiAIgiAIglAFuWEWBEEQBEEQhCrIDbMgCIIgCIIgVEFumAVBEARBEAShCnLDLAiCIAiCIAhVeMfcMD/33HNw8sknQzQaBcMwYP369Yd6lwThdbnhhhvAMAyYmpo61LsivM2RsfTnw95zLQhvV3p7e+HCCy983XaPPPIIGIYBjzzyiPe3K664Anp7e9+8ndsP74gb5kqlApdeeinMzMzAzTffDD/60Y+gp6fnUO+W8DbgqaeeghtuuAFSqdSh3hXhbY6MJUEQDiXf/e534fbbbz/Uu/GO5R1xw7x9+3YYHh6Gz372s3DVVVfBX/7lX0J9ff2h3i3hbcBTTz0FN954o9zkCG8YGUuCIBxK3ok3zKeffjoUCgU4/fTTD/WuvDNumCcmJgAAIJlMVm2Xy+Xegr0R3om4rgvFYvFQ74bwDkDGkvB2RK6fwqHANE0IhUJgmof+dvXQ78Eb5IorroC1a9cCAMCll14KhmHAGWecAVdccQXEYjHYvn07vOc974F4PA7/7b/9NwD448T/zGc+A93d3RAMBmH58uXwT//0T6CUYtsuFApw7bXXQlNTE8TjcbjoootgZGQEDMOAG2644a0+VOEgc8MNN8DnPvc5AADo6+sDwzDAMAwYGhoCwzDgU5/6FNx5552watUqCAaDcP/99+9TTwUA3nf0f91v3rwZLrvsMmhuboZwOAzLly+HL37xi1X3a3h4GJYsWQKrV6+G8fHxg3nIwpuEjCXhzeKJJ56A4447DkKhEPT398O//du/7bPdj3/8Y1izZg2Ew2FoaGiAyy+/HHbt2jWv3TPPPAPvfve7IZFIQCQSgbVr18KTTz7J2uzVSG/cuBE+/OEPQ319PZx66qlvyvH9uTI8PAzXXHMNLF++HMLhMDQ2NsKll14KQ0NDrN3+9Oq33367t8YA/FET/Nprr8Gjjz7qrT9nnHGG137Hjh1w6aWXQkNDA0QiETjxxBPhvvvuY9vcuybdddddcOONN0JnZyfE43G45JJLYG5uDkqlElx33XXQ0tICsVgMrrzySiiVSmwbtm3DV77yFejv74dgMAi9vb3whS98YV67vTz44INw1FFHQSgUgpUrV8JPf/rTfe6Tvk7quK4L3/72t2HVqlUQCoWgtbUVrr76apidna36vQPBd9C2dIi4+uqrobOzE77+9a/DtddeC8cddxy0trbCnXfeCbZtw3nnnQennnoq/NM//RNEIhFQSsFFF10EDz/8MHzsYx+Do446Ch544AH43Oc+ByMjI3DzzTd7277iiivgrrvugr/6q7+CE088ER599FG44IILDuHRCgeT97///bB161b4r//6L7j55puhqakJAACam5sBAOD3v/893HXXXfCpT30KmpqaoLe394DC7a+88gqcdtpp4Pf74aqrroLe3l7Yvn07/PKXv4Svfe1r+/zO9u3b4ayzzoKGhgb47W9/6+2TUNvIWBLeDF599VU499xzobm5GW644QawbRuuv/56aG1tZe2+9rWvwT/8wz/AZZddBh//+MdhcnISbrnlFjj99NPhpZde8qKvv//97+H888+HNWvWwPXXXw+macJtt90GZ511Fjz++ONw/PHHs+1eeumlsHTpUvj6178+74GS8MZ47rnn4KmnnoLLL78curq6YGhoCL73ve/BGWecARs3boRIJHJA2/v2t78Nn/70pyEWi3n/kN47TsbHx+Hkk0+GfD4P1157LTQ2NsIdd9wBF110Edxzzz3wvve9j23rpptugnA4DJ///Odh27ZtcMstt4Df7wfTNGF2dhZuuOEG+MMf/gC333479PX1wZe+9CXvux//+MfhjjvugEsuuQQ+85nPwDPPPAM33XQTbNq0CX72s5+x3xkYGIAPfvCD8IlPfALWrVsHt912G1x66aVw//33wznnnHNAx3/11VfD7bffDldeeSVce+21MDg4CN/5znfgpZdegieffBL8fv8BbW+fqHcADz/8sAIAdffdd3t/W7dunQIA9fnPf561vffeexUAqK9+9avs75dccokyDENt27ZNKaXUCy+8oABAXXfddazdFVdcoQBAXX/99W/OwQhvKd/85jcVAKjBwUH2dwBQpmmq1157jf1971h7+OGH2d8HBwcVAKjbbrvN+9vpp5+u4vG4Gh4eZm1d1/XK119/vQIANTk5qTZt2qQ6OjrUcccdp2ZmZg7K8QlvHTKWhIPNxRdfrEKhEDvvGzduVJZlqb2X76GhIWVZlvra177Gvvvqq68qn8/n/d11XbV06VJ13nnnsXGTz+dVX1+fOuecc7y/7R1LH/rQh97Mw/uzJp/Pz/vb008/rQBA/fCHP/T+tvdc6Nx2223z1ptVq1aptWvXzmt73XXXKQBQjz/+uPe3TCaj+vr6VG9vr3IcRymFa9Lq1atVuVz22n7oQx9ShmGo888/n233pJNOUj09Pd7n9evXKwBQH//4x1m7z372swoA1O9//3vvbz09PQoA1E9+8hPvb3Nzc6q9vV0dffTR3t/2tU6uW7eO/e7jjz+uAEDdeeed7Hfvv//+ff79T+VtL8l4Pf7mb/6Gff71r38NlmXBtddey/7+mc98BpRS8Jvf/AYAAO6//34AALjmmmtYu09/+tNv4t4KtcTatWth5cqVf9J3Jycn4bHHHoOPfvSjsGjRIla3r/Dahg0bYO3atdDb2wsPPfSQvLT6DkPGknCgOI4DDzzwAFx88cXsvK9YsQLOO+887/NPf/pTcF0XLrvsMpiamvL+a2trg6VLl8LDDz8MAADr16+HgYEB+PCHPwzT09Neu1wuB2effTY89thj4Lou24dPfOITb83B/hkSDoe9cqVSgenpaViyZAkkk0l48cUXD+pv/frXv4bjjz+eyWpisRhcddVVMDQ0BBs3bmTtP/KRj7AnsieccAIopeCjH/0oa3fCCSfArl27wLZt73cAAP72b/+WtfvMZz4DADBPAtLR0cGebtfV1cFHPvIReOmll2BsbGzBx3f33XdDIpGAc845h82BNWvWQCwW8+bAG+VtL8mohs/ng66uLva34eFh6OjogHg8zv6+YsUKr37v/03ThL6+PtZuyZIlb+IeC7WEfu4PhB07dgAAwOrVqxfU/r3vfS+0trbCAw88ALFY7E/+XaE2kbEkHCiTk5NQKBRg6dKl8+qWL1/u3ZwMDAyAUmqf7QDAu/EZGBgAAIB169bt9zfn5ubYP7DeyLgVqlMoFOCmm26C2267DUZGRpjkZW5u7qD+1vDwMJxwwgnz/k7ve+j6ov/DPJFIAABAd3f3vL+7rgtzc3PQ2Njo3Tfp90ltbW2QTCa9+6u9LFmyZN4/+pctWwYAf3yXo62tbUHHNzAwAHNzc9DS0rLP+r3GEG+Ud/QNczAYrIk3K4W3J/QJwF72lyzAcZw39Fsf+MAH4I477oA777wTrr766je0LaH2kLEkvFm4rguGYcBvfvMbsCxrXv3efzTtfXr8zW9+E4466qh9bkv/B9a+xq1wcPj0pz8Nt912G1x33XVw0kknQSKRAMMw4PLLL2dP+t+sdaIa+xpH1f6uNH37W51Ux3VdaGlpgTvvvHOf9XvfJXmjvKNvmPdFT08PPPTQQ5DJZNhT5s2bN3v1e//vui4MDg6yf7lv27btrd1h4U3lQCf23qcv+gtb+r+cFy9eDAB/DI8vhG9+85vg8/ngmmuugXg8Dh/+8IcPaL+EQ4+MJeFgstcNZe+TYcqWLVu8cn9/PyiloK+vz3s6ty/6+/sB4I9h73e9610Hf4eFA+Kee+6BdevWwT//8z97fysWi/PWA7pOUOtcfZ0A2P8a1NPTw8bMXvT7njfK3vumgYEB7+k1wB9fOkylUvN+Z9u2baCUYvu9detWAIADyuTX398PDz30EJxyyilv6j/y/uwev77nPe8Bx3HgO9/5Dvv7zTffDIZhwPnnnw8A4GnEvvvd77J2t9xyy1uzo8JbQjQaBYD5Ny37o6enByzLgscee4z9XR8nzc3NcPrpp8MPfvAD2LlzJ6vT/zUO8MeF7tZbb4VLLrkE1q1bB7/4xS8O4CiEWkDGknAwsSwLzjvvPLj33nvZed+0aRM88MAD3uf3v//9YFkW3HjjjfPGg1IKpqenAQBgzZo10N/fD//0T/8E2Wx23u9NTk6+SUci7AvLsuadr1tuuWXek+O9/9Ch60Qul4M77rhj3jaj0eg+15/3vOc98Oyzz8LTTz/NtnHrrbdCb2/vn/x+xb5+B+CPjh2Ub33rWwAA81zGRkdHmXNGOp2GH/7wh3DUUUctWI4BAHDZZZeB4zjwla98ZV6dbdsHLZnUn90T5ve+971w5plnwhe/+EUYGhqCI488Eh588EH4+c9/Dtddd503ONesWQMf+MAH4Nvf/jZMT097tnJ7//XzVocchDeHNWvWAADAF7/4Rbj88svB7/fDe9/73v22TyQScOmll8Itt9wChmFAf38//OpXv9qnRupf//Vf4dRTT4VjjjkGrrrqKujr64OhoSG47777YP369fPam6YJP/7xj+Hiiy+Gyy67DH7961/DWWedddCOVXhzkbEkHGxuvPFGuP/+++G0006Da665BmzbhltuuQVWrVoFr7zyCgD88Ybqq1/9Kvz93/89DA0NwcUXXwzxeBwGBwfhZz/7GVx11VXw2c9+FkzThP/4j/+A888/H1atWgVXXnkldHZ2wsjICDz88MNQV1cHv/zlLw/xEf/5cOGFF8KPfvQjSCQSsHLlSnj66afhoYcegsbGRtbu3HPPhUWLFsHHPvYx+NznPgeWZcEPfvADaG5unvcP6DVr1sD3vvc9+OpXvwpLliyBlpYWOOuss+Dzn/88/Nd//Recf/75cO2110JDQwPccccdMDg4CD/5yU8OmnT1yCOPhHXr1sGtt94KqVQK1q5dC88++yzccccdcPHFF8OZZ57J2i9btgw+9rGPwXPPPQetra3wgx/8AMbHx+G22247oN9du3YtXH311XDTTTfB+vXr4dxzzwW/3w8DAwNw9913w7/8y7/AJZdc8sYP8KB4bRxi9mcrF41G99k+k8mo//E//ofq6OhQfr9fLV26VH3zm99kVjtKKZXL5dQnP/lJ1dDQoGKxmLr44ovVli1bFACo//W//tebekzCW8dXvvIV1dnZqUzT9Gx6AEB98pOf3Gf7yclJ9YEPfEBFIhFVX1+vrr76arVhw4Z5VmBKKbVhwwb1vve9TyWTSRUKhdTy5cvVP/zDP3j11ApsL/l8Xq1du1bFYjH1hz/84U05ZuHNQcaScLB59NFH1Zo1a1QgEFCLFy9W3//+9/dpNfaTn/xEnXrqqSoajapoNKoOO+ww9clPflJt2bKFtXvppZfU+9//ftXY2KiCwaDq6elRl112mfrd737ntdnXWBIOLrOzs+rKK69UTU1NKhaLqfPOO09t3rxZ9fT0qHXr1rG2L7zwgjrhhBNUIBBQixYtUt/61rf2aSs3NjamLrjgAhWPxxUAMIu57du3q0suucRbP44//nj1q1/9iv3Ovu6llEILu+eee479fV/jpFKpqBtvvFH19fUpv9+vuru71d///d+rYrHIvtvT06MuuOAC9cADD6gjjjhCBYNBddhhh8377YXYyu3l1ltvVWvWrFHhcFjF43F1+OGHq7/7u79To6Oj89r+KRhKiRv5gbB+/Xo4+uij4cc//rGXOVAQBEEQBEF45/Jnp2E+EAqFwry/ffvb3wbTNOH0008/BHskCIIgCIIgvNX82WmYD4RvfOMb8MILL8CZZ54JPp8PfvOb38BvfvMbuOqqq+b5EQqCIAiCIAjvTESSUYXf/va3cOONN8LGjRshm83CokWL4K/+6q/gi1/8Ivh88m8NQRAEQRCEPwfkhlkQBEEQBEEQqiAaZkEQBEEQBEGogtwwC4IgCIIgCEIV5IZZEARBEARBEKqw4DfXTjl9rVdOpWZYXdB0vXJjgEuiFzVFvHJzQ9QrNyXjrF3A8uNOBbVc4Bbu5sxsyiuXbf5b9cmEVzadCqsrlUpeuVgseuVQOMTaOYBpKfMFnj40kazDD4qnryyXyri7gMdiWRZrF4/FvPLeVLp78ftxXwpke8rQ/l1jYn/Q3wUAsBVmIPzkV74Ptci//+Ihr7x78wusbnJwk1d2HD48Wxcd5pUX9WOe+vq2RaxdKIzf2/raU6xueNsrXrmSwfNrab9VV49jyReKsLrjT0FLwSXLcJ+Kc3xevLbhJa/suvw8lSs4Bje+9iqrS6emvHKpjOO2UuZjaWY675UzOW6BaDv4vZYWzBxV3xBj7RyVwe/wKQPFAs6ve3/6ANQ6ruu+fqNagyxhNHtoIZdnzaZncEw0NNSzOqeMYykc4WPVCgTxp8g64gLPVMpH1pvLwcoqdrDpase+C4f5NYieG5/Je4sej+2S64KWDTY1l/bKITPA6qJkTc+UcC6bkSBrFw7i9/TrRzKR9Mozs7gWlXMl1o5eNStlbdKTXbZ8/DgDfjzORBSvVR0tfDzuHhv3yrkyv07W1WFbu4J7ksvNsXbdXXit9fv52kxfuL/rly9DLXL3fZiCWl+XwkE8p4EQv/9wLayzFfa3T5uhFulWv77skdfSlA+3UTG0tOmkbDraq2wK72HoeXJMfj6hSsJj+nrcvFflyPdcl2xf2yD9lr4N2q96OvH9bcOelzoet/HRi1btdxt7qc2VSxAEQRAEQRBqBLlhFgRBEARBEIQqLFiS8drG17zy3PQ0q6snUSOjkYeQmhyUXhjhFq+cc3n4OktCAsrg4ap8EcPZ+QIJUTs8FjFl4eP8kI8/erdtbGuR8FcwyPc3X8zhd7QwulHE0LYWlYMKkXyEfRhmyWqSiRnH9sqRCA+pGSaGQQwiUQEthJkvYhjNrvCQmuXjx1OLpEm4sDHZwOpUcyuWfXWsrn3RYq/suHjcpsvD124e+7g4y8eqKmD4urMJx+Oi7iWsXfeSHq/c0dnF6lpacB/9fhJCS/JweHdXG9bZfBwUixh2Tc1y6c/UFPaPL0BCdgYfdPVkroWiPLQ3l8ZtBEM43l1ls3Z+Ml7Sc7Osrlx6ezlO1mqo/0+hlOch6pndO7zyrk28bi6Na9YpZ53N6uqY5Az7x9BCn++cnvvT8RP5nKPpk1xyrTEC/PpUsnFOMRmDJslIxnF9qNPkFOUMnkO3gGtFxM+lIYkIfo5qcsJYEK8Zk+Q66SouyQiFcM63NDexuplZXAN0uWJnB66XFgl0U8kXAICffG/HzlFWF/Rjn9TXYx/Ec6wZNCZQEqeP1Vxea1yDuGSXfeS8AACUiWwnN5dhdf4oftGi517xPqCSKluTWjjk/qA4h9eZQIjfGziAYzqryU9NA9vGonguFPB7LpdIIQxj4XIKustUkqFLxRRr52p1RMpRZT9csiduFVnHQpB1UhAEQRAEQRCqIDfMgiAIgiAIglAFuWEWBEEQBEEQhCosWMMc9hFdCJdwQQ/RUva1JlhdSwtqVMNEs6vrTAol1JYWK5oNDmkboHY/mq2ccvF7iQauJ6XWKAGiDdLdSKgNU4nYNQEAVGzcj0iA64F8UdxmiNTZBtdbmcTGxNatncjHGNG4ZXN8GxWirzM1W5dMmusbaxKiuy6XuFYwn0f9Xu+yTlZH+4HasjU08THnI/ZHS5cuY3Unn3isV+5sRW1yItHMd9GHAyOiab+oPN4g+sVCjuvASuQ4I2E+HuuTqAfsX7yS1W3atIX8AG6jVOJa7QSxaPJrc3IuTWwJActULwYAMDuLfVrIa/Pu7SVhnm9d9DaA7rNJhH1juwZZu1eefswrVwp8HPhjOA4K2vyva8D1l+oDdavKt7Ln9LW/VggQCy5D65/6JtTp5vT+d1C3bJP1wNDGY0cbzvk2Tfe7Y2C7V27y4XrW3tnG2pkV3C9T60eqV29K4LtDytJ00MR+NRLVbAhN3P/mNq5vDgVQi0uvM7bia3gimfTKXdo1mjjEgs+PdUGLr7EusaOri/P1XVVq3z4yTa4FFe09o6lJfK9m98gEq7NCeN2PxXFeB03eP1TSXNb19hU8h3linRr2a+83ETvgTJlrqctl/IHFfUu98pL+HtYuTGzxdD0w+6xNeUX+4FJBs+5uV82abj/o64tJfwve2NiRJ8yCIAiCIAiCUAW5YRYEQRAEQRCEKixYkhEy8DF/PM7trZZ3YuigMczr/C6GzrMzGBp2XH6vXsjh9rXoA9QlMTuZj8gdUpolC0kABA1xHmrKEOulMrGOKxR5OIOGCmKa9U+lTDIwaZnh/MSeziFZBn0WDw+UiAQhoMXRTRf7oJQltntaFp4g6WJbC4PMZXlYvRaxiaWaYXNNTDCA4cO5qSlW19iGEopFq9AGrqW7g7Xz037VwlUVG8fj5j0YGsvvmOTtTByrW17l2aSOW4ESitOPP84r6yGjNAlb7hzm9koBktUxEOD2eU3NKEXZuWsA22kZB7MFHMfpNO8rH7FvqqvD7xW0cDJxOWTWiwAAwaCm86hxajXUXw1q01QhkpvRXcOsXR2xE4toWVInZnEdnN4zwupau0kWTOKFqQc3DV3b9WdIog77VbdUa21FOcX4FLeqDBPJVmom5ZXbmrnMK0gW7nCYz62uRSi9oBn8KmVuAxkgeshggO9jnszt7k7cX6WlgguQa1W5zK8XTUTe5jP590olXG/idE3RpGIZkvG0VOLre2MT9nE4itdQn8Hb+cp4nEUt66Wtyfhqkaf+gJn+sppUzySZgAuadWfRwbHlD2DZ0u6XHDJdi5pVKLWZi5ExEjb4PUuIjEfH5LanuRz28fOvYMbaiSl+HVvc1+eVm5q4hIdmHVWaFJDawLlEpmpox/mn6AKVbj9HrgvVsgUuBHnCLAiCIAiCIAhVkBtmQRAEQRAEQaiC3DALgiAIgiAIQhUWrGGuD2LTsJZOOhFDfV1zHU8D6ZA0kFSlxFKIArD0zyWXa5R8RJzsI3oXp1Rg7ZSF25iYSPH9qOCvZ/Koico7XLsTCxM9qaa/soje0NTSUVpB7INCDvcr4tcsz4iGpljkv10gdjA0nWMqy+3tUkRflM1z/VKxUvv/BiqR1KYxTStY14C6v2OOPIrVdS9Ge5sMsW/asmMXa5cm5zebSrG66RTqwvaMYRrYOs1WDkzU9v3y/9zDqvwfvMwrrz3pVPy7n4/btjairVZcY5wiutMXX3qF1fmI/U80juPR1rTs5WzKK1vaaW9uRtsqh4zx6Rmu1TYBdWZ0ngEAJIk9lHBw0DV0dB2ZnMGxOTS0k7Urkbp4iOtf89m0V9788kusrq233ysn24hNo7Yf9OPbUQt+MKBzRtc2lou4Bre1t7C6CHm3IEjSa7c383aVCq5701PjrC5O9NPUFtMt8/3wE3tX0+TnsJDHcUBtvMwQv9aWyLs4JU3DHCTX9myavyMUjeFxUg3q9Mwsaxf0U/tYVsU005ksantNzXesPOeQ7/B1NRbj7xbVIqks9rHS0lob5NruC/D7pQjRGVsmlgOal2+R3E3Z2nPPNLm+FogVa9Dg4yCu8Fxb2p2gn9zPFMn9x/Zd/B2J4T1jXjlZx+91urvwnaPmJm6jmKzH99585N0KS+0//bUOvRwyy8x5axtuc35q7APTSNf+3ZUgCIIgCIIgHELkhlkQBEEQBEEQqrBgSUZLEkPncT9/tB8iIR/T4o+4wyQzX4VYiLlaCEYpDBuXtexADgnJuCSrkNLkFMqHYYtMmWfHc0g2prxDsu1pVlqZLG5/pMS34Sc2O3VZvv+VMQx1F1IoCVjUvJS1a2np9spGnGflKs1i2D6bxd+eS3NJxtQchnsGd6VZnWNpUpcaJBjEMFTF4hZZhTBaCA6mueRm/RPPeuWZaQznjYzy8KafWPn5dWskG8cMlcS0N/OpMDGGtl51mgQpk8I+3zqIGdna27mtjt+P22zv5hm7OsjnnWNcUrLlVfzc0o5SkaGdXNYBJOOVHrp1SKZCmnky6OMhwEKRZNTSQmo+n+bvKBwE9HAh9v/I7t1eeXDnbtZu17YdXrkpHmN1XU0Yot6zk9vRvfr8c1752DOSXjminWs9E9efIyaR3FEJBgCAU0Ipga2vKUVc731EG5VOcfs5g4TRlZZidmR0j1dOxHFNjPh4KD5dwmuGHnoOhHC9odlgK5rswiDyR1ez9XQt/BzU5AJ06OYLuM1AkNtdBoikLBLiA4taVc7NprxyKsWvhfEQjk9Du6bNG7s1SIGsx/Q68EeIfMDRbW3xs0HOhaYAZZluK9rm6yK4PqTTODbTZX49LRHZUSDAx1ldAH/QsrAua/Ox5CM2cKUpfg5TKbxGR2M822R7O8oV+/sWe+WYlkE5SPZLz5hIEz4qwDHiVpF16AoP58AUGfKEWRAEQRAEQRCqITfMgiAIgiAIglCFBUsyOlow7FcX4M4MsQg+NjeUnoVHkTp8VF7SMo7Rt2Qb4zzkEo2iHCQ9h2HpRB3PkJYhWfuGd/PwdbaEj+wD5Il9Z4R3gc+PYYuh6RSrKyrchl+LkSTJW84nr8Lsb+k9POSl8vi9RBMPeZXyuC/ZLP5bJujn7brb8LdaWlpZ3bgm36hFIhHc54kUH0vbdqEcYeNrG1idSUJbDsn2VMhw6YxFQqaFEpeszGbwM31Le3D3JtYuFsY+PmzJcn4ARNbx5OOPeOUekvUIAGDZ8mVeubGRj+kgCZ8m6ngYyrQxtJUr4Tgo5Hk4rJDCt9gdh4fbQmEcM/Rt97q4vh84pvW30fN5PkdrHz1rUzWdwQI1CIoWtfgdDf0ROwCj6nMI/rsuye5Jw+iZPJ/Hu8cwvD8+xkP9joPzqauF//bm51DG1NLW7pWXHXe8tl84Hk39rX562GTzWjO2vlfFqM3nNNS9IBDg1wUa1rW1MHqpgHOvPoLXSb+WPdFn4pwslrnMIBDCa1y5ROSJc3xtC8QxtK2H0Q0ilXRI6Dwc4uHwCpnn8bokqwuR/TC07Ht0vayUiVzAz9cvug3QwuglsoY5ZXKN83GZUV1jA9kEv0akc7W/LuVLOH8tzbmKutCwvgIu2KLzy9XuN+hnPZNgKIxfDNIxUeHjsUhcxmxDz46H2w8SF4v5Sxtx/NCcz+g2Mnm+j3MDeL2dmsZ7NSrFAQDo6kSnjXrirAEAEAjScY3H5tpa5kNyaLqjiKP4GH89anPlEgRBEARBEIQaQW6YBUEQBEEQBKEKcsMsCIIgCIIgCFVYsIa5gWinfOUUqwsSbWlEs5gpFYi9DdHrJZNcj0I1YmWH38dXiIVKJIZap9FJruncPoTaz4kM17HQhHi9YdTaXHz60axdVztu/54XtrO6pwcwq43tcks7H8m6lElN4O9m+D7G40SP7HBNUSiEdQGiLY0YXMNsO3gwizo6WF18hmdnqkWSDWi/tm3XVlY3OoQ2bVE/77tUDjNKZefQSs7QsnKlMqiXShW4FtRHLO2aWlH7Gda0vZ29R3rlbi1T1uDLT3tly8BxUNGsoianUGt6+OErWN2SpWil093OswzGTsQx+cpmzPhWKnK9W8lPbOWA6/ldhWNkbAyzMwX0LJ31VAPP9ZKFQu1rBTkL9whS+9Mw65tglkSaJRxgHzPdspbezACqb9bBvyzq7fXKkTg/n3Mke6iuAd6wE+dCWLMC9BHrxNeeetQrN3bydx/qu3A8Gpqtp0HElLTfXC3TnLnA7q/VRIImsVtT2sGEIyTzmab3DERRt+zkyJpl8MtrWytaSdrTWmeR9yKixFqrlOHaz0QbanurvWPQ1IprSinLr1UWuZ74df0xuX4XC/xaEgxgH5gBvE7O5fg6XSFZdS1Hy0RL3jMCF9fVsKbl9RF9drHC939ikmcrrUXKRM9vOHy80CySjlllMgTJvNNSubom9quWoBUqxD4u4MN+jYW1DKFlvDbawM9TiQzPkk31zNo7X8TOTWnPX+n9ng382kjn2tgM3i+Nlvj7GduG8frX3MxtWzs60KI3FsN3jkJBTRdONNgVpWmYHdEwC4IgCIIgCMJBQ26YBUEQBEEQBKEKC8/0R8LohRke5jZJ6Cmb5zYyhTIJHRgk215Fe0RPv6OFYJL1GJ4sk9QsO3aNsnbTaZJJScuQZJGQRl0I27X4uO1YiBzb0rp2VrenAbcxTmQXAAClPO7zS1tQZmBqmQQrMRJqTfCwKJBwRyKBobG4y8N3RWILpMp8/3ubo1DrbN+OVlebt29jdaOjKINxtHBkPIFhwMOWoYXb6hWrWbs9kxiSGp7kMoPmNuzznn7cRryxhbUbn8XvqalBVjc8hNnUJkk2rxUrWTM4ZxnKMHJZbvvmkuGvyny8v/YHlHwsXX6UV27tTLJ2f3j2Ma88Ns7HAbViKpKxOaNJdsIxlEbpGZKyed53tc/C//2vZ87aiy67ADL3XM2CqELC6NTiy5i3cSpp0KtwTayvxzX21NPPYM1eXb/ZKw/uGGJ1DsnWts3aw+pCfZ3YbssAbu/RJ1m7E96LIfxwhFt8UeUYlVPowWS7iiSGylIWfNF5i9k9sf8setEizo14kq+xRWKxFrMwHNzZ3sDaBSPYB9Ysq4J6Ys2aJPKPeBuXa5WIVGTrGL/+JZN4bSkR+Voxz8PtfrKPlbQmmSAZDV2DS9EsYlGWzeI6YvOljV2jm5NcotlQh30ykMa1vrGBSzTpT9dFuS2em+TZYWsRu4rFokOkCsUsX499RF9B553f5NcIl9b5+Uz00xlG5YraumSRTI6a8x2QBH5QIduwtezKJpGHKe1eh8owHC0DNFVo0Klm6PJTks5vbpRPmqE9Q145FMAxHYnwMUet+4KaFaOfWfYeAa+HPGEWBEEQBEEQhCrIDbMgCIIgCIIgVEFumAVBEARBEAShCguWk9U3oZaqPsY1RSZJ+ZlKc51JJYcaHZNYeLhaGltFrOliMW4LUgH8vU3bt3jlbIlrLEMhtMgJa6lNw1HUtdRbqCF6Yds4a2eX8XulRBura24gaUM1G6+KjdrnPLF1yeW5dqdMtKWGptUGplkiukeTa8n8ROdkl7ilj3IWbq11qPjDY7/1yr5WnnZ6ycrDvXK4zMfIipVLvfLyZZgy0ylqKTlN0v/AU6T7/HgOLSvplSs2t1fKZWa8cqKspdokfTw8ju1CsRHWLlGHurzF/b18H8m/VQspbg+1+ZmXsF0B+2D1ee9m7Q4/Aq3ACs9zDfP2bai7jkRRk5qo59Y8VEyWTs+wmlLxbWYrNy9Xc7W2xC6OaG/n6XKJPd/AtgFWVyjg+nPYCtSrB4N8PJpVfNRchW1dshyffMpprN3OQRxb//69f+f7WMB1ZHgyxeqCURzvS8k7GFsef561aya2coedwtNm54nllJ+IGwPacc3kUQNcKvN1ieqs+1p5CvlaoUQ0mDMzfC5ESKrykrZuU81oKI765iLpDwCALNUSa0PCIul8Sxm8hjbHuZ58y8AOrxwLca1mLIzXyRJJe1zf3sjaGQ5er20tBXuIXDYzRa7ZD5JUxGNUP+3y+4FYIumVi5o1pU1SZYeJXWc8yrWlM+T9lWKJ72Nc65NahI4RQ5snLnkvQtfK2+S8FUrYd/4A1/ZaRDsc9PE6RWwPDbq+aParirxIo70mBXliB1gm92qmdi9SJsfm19ZfZeL3KiYfS/SwTYts09DejyOPdPU7G5esReUCjpe5nGYVR3XXJf5eFD83fwWvhzxhFgRBEARBEIQqyA2zIAiCIAiCIFRh4Q4/RHZh+P37bRYM8boIYPjER+7PaaYXAIAKeewfDPOsa1NjKOvIT2G4qr9By3xGnuaHojxctXwJ2iuZpKFt8f1NE0mJz+IhtXgAw22N9UtYXf/SRV55cCexTdvCw/QBkr1OKR4esG08HSaxxdPDMTS04mqxPcOo/X8Dje/ETE3HHHkBqwsGUfrTwKM/0N6BMpiZFI6JXdt4+LTsorzCNHh4xvKRLEuKhI1tPhUcEhpTWqameBL3cTqDYXkzwO2mXBZu0+3KsBgLcXlPbweOpRCx4zGBj5fDV2NoO5lMsrpfkDD92B7sn84WnhnSISEwv5/XpdN8/Nc6rhbepC5K87L0kZAjmzJa+HTXCGaa+uWvf8XqaP+cPIU2k2euPYu1C5Lsivo+0pFlk3EWi3PrrAv/4kKvvI3YVgIA/PbXD+I+Vbh8aNNutJmrNzB0HirydeIP9+M2fI085G22Jr1yLoXH7Hf53NqT3u2V5zJ87BSLOM763nMV1CKtDdjndlGztIzhOVQ2l2RYPuzLMMmmpjsU5smcLNu8/4NEC7FiOUrPxsa4ZLBEUrA1NXMrTGr55QJeMyIxvi6V8zjOrDCXU1gkdJ6b4Rn15ojEJJHANSuryQ4dF2UXQe1eoUKkJ509uM7p17HZOcyqq0sJkg38uGuRPBnvPlP3bNuP7RsAFLJ4vgNB7NeG1i7WLkKmnqllU7ToGDTxXKRmeRa9QhZlfL19XBqZqeCYmZnF8x7UMjlXqPREy+bH1jq+i6yOqkgDwG2JTSKftSt8jDjU+47a22lSXXd2l1eeHuHZm0Ed2P1S7d9dCYIgCIIgCMIhRG6YBUEQBEEQBKEKC5ZkFIr4qNyoaKl9yPP2XI6H4sokhYxtYvgnm+dv9afzGGLv7Oa7pWxs29OEj+X7O3m4J1/Eus5lR7G6gMIQyewceVM3qbkGTKMOoLuNh6hTOXzUv/iwpayurj5CypjybXaSZ/KZpSFNLYRvKgz7VegbrFrSIIeEXU3tbet5mcpqkEgM39r2a7ubIhkUgw1JVpcnb7GTiBeE63n4OkjTIGlveisytIoVfAs5FOZjzjRIeNPkdbFGHBcBhXIHK8yzVakAeUPZ4G+LGw6ee9Pi2/eTN8bDMSzbJT6WpkcwfNcY5RnB/uI953nl518e8srZAg8nF0sYdi0V+LxOxvnx1D7a29EkTDerhSPnZvG8GRaOl7FJnsHz6edRXvXCay+zuvRMyivTt+JXHc4zT7Y04xpjaec6ncFxkUrh9nq7eAi2owvD0Ff89V+yul0kzPiH9XwfSzkcgwO7UJ4Raed6p+kNG7xy/qesCvpPOcYrz5LMZHltDS8ZuP/lCnfJcPXX8GuQGHFtWLlkEasLk+xh+nwd24n9att43NEYz+SayuKiZRncFYJmQszMYR9PTnBZBDfo4Nc/mn3PVXiNy2sZO7NpnOd1ES4HKwP+gDK0UD+RFtQRyVA4wvfD5yPuF3Eum7TMfbs2DO7cydoZfuyfgMXHaiav33/UHg6RnuhqvHriNpLQpKP5CBlb5BoU0DLFhoikp6WFS1SKYezzsk1dSfhvWSSjZKSOj4NkFLMctzWR7I/azUiR3G/ktbo9k3h9quRSrM5PxqePOIxZLr8+VSo4pn0W338X8DjZNbrAr5PpUXSMKs1yiVM2y9ep10OeMAuCIAiCIAhCFeSGWRAEQRAEQRCqIDfMgiAIgiAIglCFBWuYHWLPpTQbE6qb1XUysTh+Hp1EHc7gLq7N8hExa2CcW7EVx7Dt0lbUS519BtcRbx9BXWK8k2s6mxoxa98E0dYkk5qO2MXtB7SsNhOTuF++UIrVTaZQxzayBy2J/H7eH8kE6nwKBc3qitgTGUSc7Gr2TTRzmKFZ1rwNEv1BRw/aoen7XyyiLnI8zYdngOjNKzZq3HSbw0IW+7+i2cb4fKgTty0s6xqulsaUV1YzXD/GsjW61FJKy4BJho+r+JxxSNZL069lKrRwm1mSKdPQNGJB0nfpSa7NCkcavPLpJx3hlbdsH2btNmxE+6ZsmmsdA36uP6xNqL5O1zBjcS7NMz4+/tQTXnl4FO3QptIp1m6WZirVspGFSrh2TEzj9h9/6nHWrre32ytTizkAgJHduLZVyqjfK+T5fmQz+NmvrdorjsMsfS8NvMLqyhlcEHalcG5FAnz97Uri2B18/kVWZwWJHWgHjqs5m+vy2ShWvK9KpQPTCh4KYuSdg2iEXxf8ATyeRLKB1YXJOJudRq38axu3sHY2WSuCAW7d19CO2xwdwfE4PcnHbdHGOZme4xpyZq1FlopUittuUh10ucQ1o5EI9kFDI7d3pZalJZK5UWn69EIR1zoFPHObTTMakjHhaHM3rPU/xecP7LeuZiDWg4kIf8emnuiUd49y7XaBrA8lan25Z4i162tEfXxLdyer2zSKWRgVeZ8nktPeUSFZQF/Zyd99iLXjtSAexOvrji0bWTsnhu+5JJcewepiHWi9mxvexOosYmmXIPa6ObLOAQDkM8Rmz8/nTJpk+A0nUcfdGOEvdmWpVZ2eDFa3/Hsd5AmzIAiCIAiCIFRBbpgFQRAEQRAEoQoLlmQkk/g43Pbx8HKW2OWoCg+tzJFH7MPD+Hg9m+WZlMIhvHffs4OHmlpDGILp7OzBfepYzNr5MyQOpWUc7DryeKwaQ2lF2OahSYeEkHI5Hk5qj6DMo6xlfzOi2D9dUbQdiyfbWLvMNIbAJ8Z5uK1CrIaKZfLbJg95RYPENqbA+1HPCliLKANDKRUtM1k+gyHwoCZxyKQxtFguYjgvn+Y2Mn4SdolHeQi8uR5Dn3UNGPZrTvLfcnwYjiwE+T7O9OD5LTkoxYEKD1E7JCznulqWIhPHj6FJMpINGOZyHdymo/VVIoH7HDD4GEmReacqOEaOWsHHYzKO/fOrXz3I6ibH+NyoRV7bhKFEn0/LKkYkDrPEsg0AIJVFe8ede3A9SLQ0snYNpI8bm7jMa3I7nvtNG171yr996LesXaIOt2H5+LkulfG8lUkG0vsf4GuPnzzaoBZzAACRJjzuo45ewepefHyzV86TvIJbpjUJD7E5rK/wEPK2P7zglVPNuPbMmHwN9JexztbndZ7Mjb+BmqSrDcPcukSgPolz0jL4OfQ34ZrSRiwEH/r9I6yd6+L36uN8PRgbxfPdSjLY0usuAEBqHMPqU+NjrC7ZgLKyKJEPJeq5tCIexf2NJ3hdNIZjydZsJndsG/LKFpG25TW5TZnMu3JJy7RK5GYGGY/hEF+nHQP3o1Lh2d8qJT43ahGT2Lm1x/g5HJtF68pKHR8HPmLXZ5JxZpdnWbveNau88izweVgmFreWQbIH13GJ3Sy5bmaK/Fy7RBJWIhKbRIJvY1eGyCkmuXVnD8k+27GcyzVSG/EcZncP4T6Nc8lgOofbdLTsmHMF7LtwPfZpvJuv0zaxvywW+Fg1Ndnt6yFPmAVBEARBEAShCnLDLAiCIAiCIAhVkBtmQRAEQRAEQajCgjXMmRRqSXxlXTNK7rs1SYiPpLXME91gfZzbxiRjqI0pzHANc0sn6go7jzjDK2/YzS1xtm7Dzye3c+ufVArrWvuP9MomcN1pmaQKTiquDUpPYB+Ey1xX1d6Av5dyUI/lP4KnFy4Q+7knf/0LVrd7F+pwLKZF5jon6kZX0f7NY2p6r5qEaHt9WipMKpHqTvDjPmxx0ivHQkQXavA+yBFrsGKep2oPR7F/li/Fc9bdw1MRm37Uymc1/Wt3O6YNXT6I56yugeu7GupRU+jzcSsk6sSktDkTIulSbaIf06Ts4CeWOEXg2qzGJtTNZYl+NJfiusfOZtR7Xfzec1ndvfc9BLXOU88+5ZULmi1eNIRrzIUX/gWrs0ka+hdeRZ1vQksHXnBRa9fRwlMdV4ieNJXD384NbGbtGogtWzTB9Yyxeuz/UBTXm0SSD4oEsT2sq+PbCMdwvJxx1gmsbm4q5ZVffXWHV3YqfG4Np/A4/ZpNo28PvmuRmcHxaNdpNophPJbdO0dZXVo7N7WIIut9UHsXhGpvKzl+LEGSWl2RFygcV1ubTdzmvCdVLq5LPT34bk5TM9djdhHL0mCQ72NdAse7RfZpYoLbtJ58Ar7P09bRwepsheMgPc3fYZidQh3tdAr7wGfxham5KemV9ZToLrFKS8RQrzurWeQpYqtaLnDNsv4uRy3SkMBja4rxdwJmZ/D9gQbtXasgGT/0PYDWJctZu8XtaFX52s4drC4ZxGuNTTwEW9uSrJ1JrhE5nzZW47iN2Um8ZvS28OtkPkDeE3H4vJiZxfFjtvNU890rT/TKu3fhelks8PsxP51bmmeuReZMKYXX4Ung96c2uf6ZFj9OR3MifT3kCbMgCIIgCIIgVEFumAVBEARBEAShCguWZJAn4+AU+CNvRSQDJmgZzYg1ygxRC/jSWpY7knGoXcu+d9yZZ3nlruX4KP+nt/2AtWsj1m5WmdukjOzYju0Wr/TKocYlrF1U4bHlZyZYXdjFcG1ZCx1MZfBzshkz2TW29bJ2hSyGVk2eXA6cAIaeaKa/SoXLFgySZclQPKZg2ws+pYeMtSet8cqLVx7J6kZHMHzY2cFlNcuW9nvltma01rIUDy9niKVaSbN6o/0ai+I4i8W4nMIKYLjZr8lGCjkMNR2zGqUbvct6WbsKCRkp7d+mtkuyYVl8/y2Syq1SxHniaqFIk2aGDGkpjEhdich0fBYPATrllFdubuKh/lNPOw5qnR1DGI6cm+DWS0v7MBNoOMzXlNFRnNtDg5htKxblMgM6fow0X1MKKXI+yLha2t/P2vU3o3VXvJ5P+okJIlNrwHPW3s33N5PG/QhwpRiEiF1ZXTO3CTvn3bh2ThOp2/huvrZNlXCjUS083kLkID5iX9gZ5xZ80Va0LNw9OMjqynl+zahFdu7a5ZXp2gAAkCH2WUktW2MZcH1wiPQqGueh+FIBx0tLC5f+BE0cW/2LMXNbMMilXKafWElqkoxwmEg+yHhU2vW6lCaZUBN8TDe24/gxbV7X043h+GAIx0g6l2LtAgFcv3wGvx7ZZC2iFouOZk1nhXAtUjavi0X5uKtFetvw2vX+889idcM7er1ypshtYUtFHEt2CcdLbweXNNDsiqqJW4XOkfuFXB6339XE7ShtIkHKaha6itj8xRSxVNTsFluJ7WZugkt4siO4ZlVKfNGKtuJY6lx9mld2KynWbmIU79vyWW0NIftSF8Wx5AM+bhUZgpU833+lp/57HeQJsyAIgiAIgiBUQW6YBUEQBEEQBKEKC47f00RijubEYJC39bWXLUEVsC1NDNXQGGHt2qIYfjjmWP5G6IqTUYYxO0HeErZTrN3iLnxz1DV4CKCtBd82ps4D+RQPt5dtrKsUePc4gGGi7SO7Wd2rG573yiefiNtsbOPho3QGQ6F+3gXQ1IthQJf0qVPWZBdEvjI3mWJ1pYy20RpkzRGHeeVVR3NJRmE1hrOjCR6+pmdUGUQGpMkMGqIYolLaeKQfXRe3qGcmAzLGSyUe4ulfguGxcADPWSHHHTmUScaPFppUZEK5isuTHHJs9C3zspZ5y3Hxt00fDy2Z5Egz0xgaGx7cxdqdcurRXjlf4SGviC7zqEFyc9jneS1bVTCCMpu5DD83w7uGvHI9GWeOFpo0SEbJPWPbWN2eEQxBGia2u+wD72ft3CxmqPz9E4/w/XgF15HGBIZBxwZ433eSkOxchWfpAz+uKQ2N3Mnj8OWrvXL5fTgG//M/fsjaFTJ43CMpHiYGH81ASsK4UzxTaQfpx0CYz8mmliTUOvk8nkNXC9WWiQyuoVlzvCHyqmIR143uRd2s3WuvbvHKfm2+trdhuLy5mWYV1LIpkm4NBPmaEiHjnbpkQIGH7AtplFPMTHJpjjJxHIS1+U+3XxfHdSmdn2HtlIN9EA5xiZNBxhKVGtZpkimH9E9dhPe3/8CSsx0S6izsx5OO4XKK41eh5CaT53KTCrlgVWzsYzuvycHIutRX7mR1eZJdMZvD7/n9fLzMknEQ6uN9XCASGZXE7JUjY3tYu61Ezraqnks+hifIuHD5SXNCKFeK9RzjlU/v72XtZnahJGPzCy+wuokxdNeIGkSOV+JuHUUHf9tw+XzyHeBgkifMgiAIgiAIglAFuWEWBEEQBEEQhCrIDbMgCIIgCIIgVGHBGmaXaLgKmkVIgNi56RnNLKLtW9KO2qxQmN+r9/agzufIU89kde3Lj/DK65++zSsv6ua2Y22rDsd9aubWTr4I2uXkiZVLIc11m+OjqPGcHec6ZYdYTIXj3IasqQnFZbtGX/LKre1cX2QTmxdV4PolI4c6HEeh9ojqXQEAwsROKNDGtYLpYO3rTsPUzi3ELZqiETIkfVxfRJNGGVTDbBhaOxyfbsXV6nAjVHtvA29HXJlAaZkEY0kcd7aD33M0nRa4xNoJuA6d2j6Bw/ff8eE5VUAO2tbsBYmtTlD7bb9DsssVsU6Ncy3c5A7Uw3Yt51mcpkxNy1qDlIm+PK9p17YNoub4Z/f+hNU98eijXtkgtoTjaX7ME0Oo0fNrdm4V0v+BNlxfnnzscdaulEat78aBLawuO4b619QEbi/ZxNeXSdIurWmM6+tRJ1p2+PYfeeRFrxyuw/cp6jWLqakKZjHNl7iefzfRNyuyvuRSvL8tooetJ9neAAAsq/btLum7EKUCn2tBcl0rlbnOPRjCuWaS9cbRrE0zsymvnM9y676+RWhvGiZ9HItwa7oEOdcVm79L5Di4zzQzYVMT38bEBO7XnkmuP35hwyteeckSrr2dmMR9Ht2D+n1byzKarMPf82vrajCI49om63upyPuULJ0QaeAWfOls7a9L2Rm8lu8e3MDqujrRdraznb9z4CPn2yXvvaS19wVSKdx+YwN/TypH3hvLk3Gcy/L5msnimrW8fzGry5FslkXy7kxzmF+v/SX8rTUnnMzqZvJYNzTG3yEpmzgOHJrJsZ5ntuw4Avuq+YhzWJ09i9eumU3PeOUdrz7H2k1txzXRDPA+MH3aov46yBNmQRAEQRAEQaiC3DALgiAIgiAIQhUWHCfzk5DabIZnT3OKGD8JR7iNjGViSLmFWMntGk2xdv3ve7dX7jr83cDBkEwlg4/UE3Ge1ap52VFeOefjco3XXsLH9KUCbiOd5vsxNYIhWMvhYblQCPugs49LLY5YhiE120LJgd9Ksnb+AMm6ptlg5Ycxyx2VwNjaP2uyFoayIo3cjqe1o/azIMUTeG6UZgmXJ5Z5Ssv+VCrtO7xU1jIhlkiYyLZ5yKVC7OKorVE+z8d0PodSHVuzook3kMxtiaRXTsabWLtQAMO4jpYtEAwMe+vZMeNE7jM9gd8rFngo0iWZJw3QrK4c7Lu6OIbRehbxEGAhj/2oXL4fiTgfW7VIgpyLijZP0iTsvXH9elY3tgMzBJpkGYz4+HgMmtivbpmfQ5NYj3V3oJylIc5DyLPEEmpx72GsbtjB0OrsNIZd40G+jXFiD5XTslXNzmBo0rC4NKdI7JZSeZSomAG+TrsWHqcK8G3kSVjdIfMpqm0jliB2aBY/Ga6WkbQWaWtG+7WgZjcVIRn3whEuobLJdcJPdGN1IT6flnTi3Etq18kOYrsXC5LMjVEuzSmaJNOfy+d8eg5/L0QyVvojfEyPTeI6smuGr3tbto1huwkuk0jPkQyBxIJy5YoO1i4Wwt9zNNs0ai+miDwuFNAykNJstpqcx3a4FKUWSRKbvMz0GKvbQ64nTW18LCXIsUbjSVLBZTWWgX0Q50MJEjFsq8j6ZWvXyU0b0ZatuZlLISIRlOPkybX2yF5+37P2WLSEK9hcOponw39pN5//49O4no2OoSxoTLM93engNouaPCmcxDU3uRrvGY9efhJr1zWIMqOXn7yP1U2O8Yykr4c8YRYEQRAEQRCEKsgNsyAIgiAIgiBUQW6YBUEQBEEQBKEKC9Ywl4j1R0RLyWmEUJfkN7luSzn4ORzDdhdd/hes3cnnn+2V65q4znJ8xyavbJHtp7R0t5NDaB8ymuGamUfu/ZlXjpG0rcUS14W2taImsi4eY3WDu1HfXNaOs6Gj1ysvO3wNVjjchmUmhVZ1+SL/98psAbdpKOzjYoFraLNE+6WyXGe2Igk1z72/+I1XdvzcgmuWWMVk57iVDpHDMz3z+DhPFewQHWFDM7fPqm9CjXeQ6MVyMynWbusAjrm5DLceXLS41ytbJFdtXZzrx/v6UAfW1c3T0/YtRi1Yg2YFGCcaQJemB9f0qRUytywtJ71Fttnai9rqUB0fjxWiLbW4JBIaGnhq8lokRjTMPk1zXZ5G7d3UVq6NWxTD7xlE55cp8PlUIPPcCHM9acjA8zE5hrZsLzzzMmvXGkft3TSxFgMASBHtfJZM88IkX9uA6KV92okK+4nOT9NZT6bw9xyTvPvg01IWE4tFM6TZI1JrMIXayVyOv4ORTuPn+saktonat7tUpH9C4Qir85P55Q/yuVbMoE63UsHxor9jc9TRqBOl5wwAwO/Hc0qtWR3t/QkgqauDAX4djsWI3SiZ/8rl7fzkXG/cvJnV5YgVGDjcgouuuQHy7olp8jVFEZtP1+TX4TSxKMvk8Vj0MV0uYz/aJT4ny9q7LbVIO1mXjDLXXM+Mo/3iy69sY3UvbcB7mNZOTK1+2trTWbvOZtx+cZbr0C06t006rvg4WNSB7xyEQ9q7GwEcI3UBMhfi/DxVHNxGpsCPs0DsUjcNDLG62RLaEh6zGOdFtoXv4+Ae1H9vGuZjdf0O7LtMMOmVm+r43F3Vitfa49aey+pefOpBOBDkCbMgCIIgCIIgVEFumAVBEARBEAShCgvP9KdIqM/lYRaDWA3Zij+WN0iWulAQQ7xHrVnD2gVJaHvj+pdY3ezodq9cIuGZzOw0a7dr20avnFU85Oh38HsxkmGoLsTDuM31Sa+8Z3wPq7OJJVk+w6UcuwZ3kk+v4X5keTg/5MP+sINcLjBtY/+ESfg3ovnGhH0YAsvkecYoW7MGq0V++/BTXjnZtZzVKQf79cUnf8/qersxRNXUiPKH3bu080TGZ6QhyerKJo7V8d0Ypj/7eG5Fc9QRq7xyXgsJmn6cNoM7h73y1oHtrN0rr+I4rk9yec8HLnmfVz5l1TJWF1D479iudjzmsibJMEi2QJrBEACgQjILmj6SETDJZQVhEp51LR7O50G62sQloUOlZUwMEGszf4WvWYsSOH5sEorPFPhYsurwvFlBPg/zYymvXEphWDQ9zef8lIv7MVvi4dO+NUd65T2TuJ6lNIlQLIb7Uczztafix3Na1LL0FUjmOZpdMhTg40ARmypHy85mkVCuSayjXE0uMD6BFna25iLnC9S+JKNM1vdMjp8nM45h3kKKr7k0414kjGu4ZfLwdWo65ZVLmiRjLotSBRrmVtr59PuwH/2mZv9HrCRpYtGyllGWSirH9vDxXlQ4LkoWv5YHiFTECuNv5zWbQ5vIgoIB3gdzxEp1bBrtxBRoMiCSfdMw+PbDwQXfthwyXnnpWa+spodZXaIRJQgvvLaJ1W3aOuSVTz3rXV75x3f+iLV779mneuX6EB9LoTBKwHx+Mm6LfEw3N+L9hxvk90Gz+5G9GJpdZIU8czX8fE3ZNozy05v/+VusbnICz/2JJ53mlS+89K9Yu5Y27KuozSVgHTaOkddSxPpSk8uOk2v0Ms1Wtf+wVXAgyBNmQRAEQRAEQaiC3DALgiAIgiAIQhXkhlkQBEEQBEEQqnAAYiDUiLg21zpSnYyjidfKJO1vK0mJ/MAvfsXaNbSi7reF6DYBAMp5tFjy+1G/G4ty2x4f0XRF/VyB2daC1lqFDOpnwha3xJmeRLuTSpkfSzyEGsaypk0eIKm392ze6pVLmu4GSMpVR9OgRbuIjiiKfWwGuYY2RHTK9cB1lStWLYZa59IPfcQrB1uWsrp8Bm1ktr7C7bna23BcmER7Gw7xcVB2sc+Xrebbr29H3Va+CbWCF57/LtaO6sZzmoaZOmTZCudF0ebtJohOa3hwlG8/glrHsd1ciz/02oBXNou4zR1jE6zd8ece65V7enl6Wmo5Z4aIjtCvvX9ANe+aVjBgaJZWNUgqhfOwlOfrUrSM86u5jffP9DD25bbBIa88UeHnsJFo5c0Qn2s5F8+vU8FBYWvpgIslkube4HrDiT1onUjTvasKbxcN4RpbLvA1xQiidtAu8t8ORHFNUQ4ZqyXeVy7xbCxr63uQWJ4FQmT9jXBdfjiK2smKtv90vtYqU0Q33tHKLSKpptl2+RhpIGMkk8ZzaNuaLRvR9rq8e2DzNkzRa5J5F9A0o4vIPDdj/NpVzOE4c8hv2WU+XoJkm7Oz3L5w6wjqPfua21ldI7HJ81m4fuVyXOs8a6ewnZbyOkPG7iyxcHQVP06D3Jr4Da5JzenptmuQCWL1ttnP121rAuf88CjXkK9915le+Qv/zxe98i3f+S5rd98vf+GVD+vkY9VPUttH43ieHIev7w3kfqy5gWt7qQVdgOjQTYPfMmbJdaasWZt+7/u3eeXXNr/K6uia8tOf3+WVu5YfztodvhTf7wkHuUa6TuFvd5ClyNb2I0febVFlPnZ6OhfBgVD7q5ggCIIgCIIgHELkhlkQBEEQBEEQqrBwWzkShw74uJQg5COhW5PbBykLQ4IuyXgzNcVDEdlJ/ByurOa/TSxnGuox/JDsaGbtbGKrMzI6xuoUYAzMNPGwyzYP91gGhpBoGBQAgLjngWVr4WoSanXKKfwtLcNVmlhClYM8VBbvwP3PhXEbGZeHSIs5/HdOYx2XYDS18PBMLUKzCG3dvIHVpefwvCndKo2EGbMkfG0YvI9DQTyHlTyXzsxN4jbHd6Kt3G8e+A1rN0uy+81ledgyXodhrkQ9hrWiWha93btRhtHS1MnqQnUoDXn8Pv7bMwMoRXFKOGe2jfGMhrtzaG+1dAW3pkuQbEeJegylhiM8rJWIYl/5tQxvkQg/npqkQEK+WqTWNjDsl9Ncq/aQLH2jZC5ny9q8nkp5RcvPQ+x5YqumyDwvaGuKItkUA35uszVCJGA2kUwYwMf0xAzKP0Ab7zSbqj/MZSN1JJxK5XL63KKZIsOaoaBJ7fnI/htBLcMb6Q/dfkoP5dYiO0dxvtKwNgCAXcK1unsRz9pJJQLpLJFu2FofEwleXpO9bNqGlpRUWji6i0u5mhpwvUkkkqxuYAClXPR6d9EFJ7N2QYXrV0MyzurCaVxvpkmWSAAAl8wNP5EWprPckixXwnmS1+QgZgDHTLFCxwsfH9SycFbL6NtUx8d4LdLVh1JAB/g1qFLBPglGuaypvRuvE4rcU3R3dLF2v733Hq+cGatndZEw9nGQrQd83QgSm0BdXhUhmS7pmhUK8L5XRKI1WeDHuWEjymzPOYdLHo88Cu00b/33H3jlpx/j18LFbUncjwifk1NjeK+wfivKYP0xvo9tdbgNp6BZFAYO7JmxPGEWBEEQBEEQhCrIDbMgCIIgCIIgVGHBcTLTwEfvIS3jlSJOGNEwlzFE4yibyJM30BvjPDTpI9soz/HQs0syJuX9GKppbe3j7UjIfvkRPITx1MO/w+0rDBn5tfBmgYTU6sgbpgAAAR+GKi3NUSBL3AwG92DGq9QsD8+WDPzt5uX83yudSeLCofCYZ6d4hp5AkchGtDdkC1rWpVokM42hlN/dex+r2zWGMgmzwsN5L79MQnPkvNlaCBzIW+YP/vJ3rCpAshEdfcwxXrkc4KHJNMnItmMnf8t5ehqzM5WL+FsjewZZu8EhbHfs0Tyz5X//1Ge88rNPP8Xq7Dl0zZgjGZcKwEO825/DvnrseS5xivowtErDy5YWRq8jkoyuXj6f/uIDl3tlvve1g49IqCqazCBLMpzNpHl2tmnSrzbJ3KhsHvYrkjf5Dc1ZokIcUkzq0JPg64ZFMjTSrHkAANQcgMokLC2ro0VC1qYme6MGFK7mvGNauB5YRDrnaNlaFdmmqf02dbgwDPJjBl+/XLLNijYlffocrUFs0v9TKS4DSBApE5VdAPBzSuWDuYKWLZCea1eT45HMeRMzeI1Y/wrPEhcNo4SnVOTuFNTJKkDkVZsG+DZaI+gYFY9pblJtWDc9zGWNBskyOE6kRF3dTaydQ+RJJU2WkifuUhXSztH6oy6BEoGSZimS02VTNYhNUi062v4HSFY9zeiLja3xCezjqZlZ1m73GF4jlM3HAb0/q5AMp5oxC4TIuhcN8nFgEdltOIRjP6Td37kWnsPhCX7fRrM1Xvy+97Gqk09GmdCuXZgR8Kc//wVr99LLPV7ZKfL1d3Yc52h5Grfhc/j6m7NRBrt9dheriwb5fejrIU+YBUEQBEEQBKEKcsMsCIIgCIIgCFWQG2ZBEARBEARBqMKCNcwBYjuUL3H/JitErOO0zHn5CmpyLD+qaIIBroXx+3EbgQgX9iTqsG5sEnUy+U6uU27pXuKVR0g2HQCAVced4pWzk2jVs2Pra6xdLpvyyj6L66oSCWKpBFxHtWcEt7lzCLU1ZpBb7tS14XE3N3CtjUF00MYMfq9+lp+mzha0FupK8qyI2zai7uxMLhuqGdpbMYPUsj6um1WkX30W72OfQXWWOB6VrhEj4xH83EatowNte8447zyvHI/w8ZgIoVXPxg084+CWgW1eua0L97+oZauyiN5rw9bNrG4jscGJ9K1kdSMjeH4b6nE//AGut4oQ+5yZMa5TnNqNFlOTUzhnio5m1Ud0hKMpPs5OPptrZWuRbAb1aek0t33LZXH+5nI8OxuV39YlcR4Gw/u30jO0bHVhYsvkD+A40/XH/gD2q0/TMNvUmo5psPl5olWWnjWPWlpq2byovp/Ok4qmKXbIvNN11j6q8SY7EgrxuUU1kUrTSAeDtW9RWN+IWtxEgq/b9Nhm0tw+K0zmOc0OW67wPvARC6uApp0sO6hDnZjB7Rdsfq4b4kmv3NXPtcMVIhxPp1NeeWg3fwcj0Ix6VVPxcRCLkGtcC7crS4RxnmRS+E7A0BB/d6N/OepOy4qvIWWHzEPSPfkc79N6cm0Mh3hflQpcy1qLTKbw/qOiZQ/1kfmrtMzIL72CNquHH7mG/J1nyquQZ51lH3+nrFzB9WcPySRa1DLWBsg89/MlixnQ+Um2Rr+frw0OeY8jW+T3Sw1NmD2wqZG/a5Uh75S0taNN48zsJGv3wAP4jlMxy9f36Wlc+3NkQfdpa7hFxmB9K7cibmnl2SxfD3nCLAiCIAiCIAhVkBtmQRAEQRAEQajCgiUZrc14b12ZnmZ1BZKhKsefmoMyMeRAw5F1dTycFPDjY/9CjltAhWkYoIzl55/idlyLl2PoefdubolDrZgixELF0iQk4TCG4mhIFwCgUMDPtpapKUbCACcfg1nXQnEuL7EtDL05FW47VNiFIRMzg+HOlgi3PDt6GWZCbEm2sroX9uyAWmdmErOWnXgCz0J18tq1XjkY5HEiH5FhUKsrV3HphkWsnWiIFACgUMY+n96NocQZzaJpZgr3cTuRYAAAjE7g2Iq1kAx+QR6iNojsqGxzGdODjz7hlXv7D2d1ixpwmyGSlTLi52O1VMQw5vY5njExTiwRHRJ2HZvNsnZNTb1eOV/h/fj7R5/1yh//649ALTJF1iL9XBeJDVGpzOdrIOQnZWJbmdcyk/nomNPiluSzImE/2+FhbrqNsJY9kck8iNzBcfdvnaVnttSzAlJyeRzvVK7hC/Cln9rK6dIT+ntcNqL9LqkKhXiY+O0gyciQvnJdvh50tmFmzoBmrZUndoPRCM47w8fHo2FhB/kD/PwaRHqRJ9nIgmG+psSa0G6tYvJxZvvwc6ge99H1ccuwDLEuW7q4l29jDNeU0RyfC6ksronLlmImu107B1g7KvcxtFuMzBzpY/K8TpfExcg8yeU0Gz/teliLOMTa1LC4pCRLxlkhy9fjsUlcz27+11u88vA2LrnLkrVu2wiXMVDpFZ3zFW1NMcp4TbK0Z6d0TTHIeFSGrbWjP8yqIBzF7U9r94xBIi9Mz+H9XqnEtz80hHZxhiZfqZDfU0EcP7p9Hs1UGA3yjIb53IHZXcoTZkEQBEEQBEGogtwwC4IgCIIgCEIV5IZZEARBEARBEKqwYA3zom7UgSQMrqvatoukc5zkCpKyg1qkWAx/LpdPsXaOi9opXU8zM4nWKJksak6KFZ6+1FK4zXisgdWNk1SSu4nFlKvZ3rQ2o7ba0HRssynUcAWjXJOXTKCuKkBspUplPUcs9mNOs3kpZ0nKaxf7YEk3tz7paEOLll27eTrK6Umu96pFokSfNp3mffDSKy945RbN1qi1Bc9NpYLnZnY2xX+A2PP5dC1iX4dX7q7HczaylaeWzmVRf9Xaxvs/0oT75QuhZjFf4MfS3r7IK4+N7mZ1U1O4zx0dXPhvEJ1otkT238fHXMWlWkeuzQoS3Wl5mmjcTK5nbCW2eGUt9ajSxWA1SKVC9lmz9fMR7WZIk9AGw0RjS5YAQ1sRqUWc5l4IDtMtkxTUmtbZR1KTm36+jwGyj1QfrNvDqSongzq4mZr+uD6Z9Mp0zuiabodY0+kaafrbVJ9qayl5iw79zPdXP55aJBJFHaSjvaNSIn3n0zy4/EQjyS0F+bmgU8/n379GvUTWLMPHfytCrE0zGd3eDsf0JHlPxOfjmt/6MO5XJMnfsYmF8PrR1sLrJscxPXOE2M+1tuzfMkx7rQBoVvcEGZvxOq55T8/hb01OcotYZfK1rhZpZDZq/BwWiD1aMcaPxST2aKmZFG6vuYW1SzSgPZqtLUyuwrFrV/A65mhWkjRttlvZ/3wtEY2+q69D5P0hU3unIUXGwZNPPcnqzjzzTK/82sZN+LvatCiTY7O0fqQa+Ar5olPi6xKUcRu7hnlqbCt4YHp4ecIsCIIgCIIgCFWQG2ZBEARBEARBqMKCJRl19cT2TQv717eQR+VRbg8zNY4hgSIJA/oCPMsdjRC6WoakioPbmCtgqCaqZXQp5jEkXihyqxWadckhZaX4Y/4syRZWV8ePpa4OQ1SFAu+DqWncr1gMrenmWTTZGB4IaBl6qCtZgIRxe5f0snaFPG7jscd4psJXtvCsTrVIkIQjS8UUq3vyyYe8stIyJNVFsL9oVqtigdsf+ci/A3v7FrG61SdiVr3+RSjPSO3ikomxWQwDBrRxtqQRMxNNTqIt0BGHrWbtVh2+3Cv/14/u0PYRt1nRstCVy/iZZYIK8ZCaRay6+hYvZnUTu7bgByIRCGtSopUr0AKxmOcWR93tPAxYi9DQpwlcbuI4VErAY31UglAkGaoMS7NsIyFSV7NlKpMwoOVqlnMELuvQ1jayX9Xs4ahKwtVCsDYZI66WydEiIX2a9a+sh2dd/GxqmQr3ZyunZzS0YP+SEr3vapEwkRmYBrcCKxALrqB2rsMka58B2I8BPX0aGVt1CS5jKJLMfGUfuU4Geb8VyNpgaXZlJPoOZXKN2FPgkoaGLrStrOzhkr4wmRehON//5gSuB1PTaHPWkOTXcqo9yWp2moe145rrkmtvPs/D6Pkcfm4k0g0AgMqBOYEdEmjmTH3s+8h4SQT5PQa13m2oJ1npbH0+4XnS56tNrFNdB8dStTmpKy1sIiXN5PC6UNKyPFNJnKPtI237y1/9itVt2LjRKz/3PMowDUNbw8maaGs7SfsYyDrqaLae9E7N0ORyIaXJN14HecIsCIIgCIIgCFWQG2ZBEARBEARBqMKCJRm+EDYN1fFQUEMM77t9Bf7I3h/GR+XpWfJzDr9XD4cwY52jvUHslFDuEIjgNvw+vh+WheGNkpb9rUxCBzQrl6G/9ElCXg6PlPPfC/DQdmoW97FQxsf8CS1c5SMSDVNzPciTcN74FL4BPZvlIYZMDt1BfvvwZlY3XvsmGZCnchZNsvLu97zXK7tl7h5hkVicS8LhSg8Nk/MU0iRCYykMv2dSW73yTEHLYBRCfczml7azuumnUO6zuO8wr3z8kqWsXZm4ZoS18aLIeNTdNUwLx7hLQvEFPbRHQk89XVySUcyiK8yqOpQIPfP8i6zd6DBKNwpamk6Vn4Vap64O55fr6JnncGyVyjz0libyE+p6YGlhdBbG1N7495Oxa5Nz4+qhTyrDMDSJFnXp0W042DawztVeJVfkuYee9bJUwHFGXTJcPR8WsS/Q94KFbkltJMTdkgJE/mFqThs01FyrBEgm0YiWeY6OA0sbCBaRWjjEKUTPBqvI9nWHiwJxFKDbD4V4v5XJGljR1qx8Cq+9VO4Xb0yydvTaVdEyW1oBIhkM8uurIhl3qatFUHPySDagdEOleYY3g2T+LWZwvSnkeZ+GSP/rri1vB/sew8A+8WvOOEz2pa1ZfpLxmE5EpfVBkF7ztDqaxNMAnKO2pmVh2US1PjXrcPuNzSgfqmjbUIpKIfja4xL7nmyWX1v2jGG23N5edGrK5DRpDpNbalI06ipE9kNp10kqWdFdhGgG6IUgT5gFQRAEQRAEoQpywywIgiAIgiAIVZAbZkEQBEEQBEGowoKFZVmShQ4snp0mFkUNpj/MdSZR4pWWSKC2JJvm2qlsGjUtWU3PVCni53gA9TQhP7cgsYmNic+nZdQiH/1B1LQYmqYwQrIRmlrv2ESfFgjz365LouZqZgb1aRlNU1jXgPuf1yx3BoZQ77XpFcxI09rAddCtXahJBZNvvylxYJlrDgXRGLHV0eRo8Wa0OdMtbELk33cBYvukwpo9H7GHcovcKi2TIVrBCPZrS3+SteuPoBXT1kGuYQaqTyM2bSN7drJmjSQjYFMzzzxZypNsTyWesTKXLZJ2OJYqJS5Q94VwzLV2NLO6oVG0ixrfuQ1/K8t/a9uGl3B/G/k2VD3f51rEIGPC0F5IKBOfrWKJrzfUDolq3Hyaxk0RXZ5uxVYiNkoG0cLpVpJUz6tr6FxiM0n3XlfW0Vmu6xmpFlEZfD2wfKStxdcsCpVS61kFqT0fk1lraxvNUqbX2ZpVaC0SJdpen3YG6FkLadrtbBbXGGq1Fwjy9xbC0ej+68gPFOZSXrm1hdtiFom+ORnl656/mayJpPsrwNdReh0LEwtUAAA/ycKqD8IKGXdNzSSzrcsvlBbJXhkM8n1UCte2SATvI8IRLRUn6UfdwrWg2YjWItSuVrm8I6l9pC7Ppu8LMD2zb/9Wj/r7ArStRdYbv/aOBH2nYV4mTroe0Gx7mu2bTd6j0V4lYu94hONJVtfVQ67RZPsFLTUk1Uzr9nwGeSeArll6Ozon9eMsavcYr4c8YRYEQRAEQRCEKsgNsyAIgiAIgiBUYcGSjN2Y2AdKKR6SijfjY/NQmNuCJIh6o6EBfy6b42GWVAo/z05zO5tZ4kxDM2q580KH5HG7yx+9038Z0PCppdkdFYjdndIyCvldYhmUn+G/TcJGDglJpbL8OGnEYUaTpQwO4IGmpvF75Rw/lrYEZppb2dPJ6tK1H62CfAbt3MDl/2bzGzhgxse5fGBg45BXDhHbpEAiydo1taAUoqMpwepoyL2RZNvSHHGgSDJKtrZwSUxXB0oVRok9zpYtG1m7vjJavRWLPPSTyaS8cj4/xurScygbKRH7M6esWUAFMZy6YQOXU5RJqKmlBS0bu448nLVraca6puY2VhcK8nBtLULDb6USt/GisguaPREAoEzaUqsu3ZaNhk/1zHYhElY3SRjUsXXrpf2HC2nmKfpbunQjoMc7CcUiHput/TYNyVIrKl12QUOTec1qjIZ/qRxBl6/YJBueqUndQiEt5F6D+EmfmFq2sACxetQzMtJzRc9vQJcM2sTWz+XXyRDZRiKOa6DuehUK4Jx0tfB1JIYSrQoZ38UCt/SiUqJIgF///ESWksvz74XiJNMtyQRX0OadX+FxW1pmNdPCdZs6y+YLfF6kUnh91cd0IMDvD2qRMpGR6rZ4REnAZAsAfPzQexNDk2RQe0fdIpLKTE0iofBrMlJl4RgMWtWene470ycAPzeVMh8HdC3Vz2G+TO3oiNWgzecF6zstC6si36NWcvr4qGZpGdXsI18PecIsCIIgCIIgCFWQG2ZBEARBEARBqILcMAuCIAiCIAhCFRasYXb8TV65EjiO1ZVcol2zp1hdKIG6k2Qz6t/qTa5pacijBiU1w61oUlPEYiaHu+zYmpaJpMJ1ba6JKpL0w1TjYmnaoEwRv1fIct2jX6FGJ25yXatrot62UsF9DEa55ifkxz5IBriutR+SXvmIo1CrtvyIo1i73iVLvPLxJ3GN9O5RbqNWi7hET2pq/2bzVfB81Gkp0p9/+hGvPDaO48zwc33kCScc65VPPelYVjc3h+fplRef8cq5Ij/XW4bRIm7H0BCrK+Sxz2ma9VAd1xGn08RecJbPi1waNdK6hZiPaLUScdRYdfT1sXYNTR1euaWD6487jkatcgNJja1rYZku19B0sqr2/z1NrZGoZhlA081p2juma2M6Yo5VJa2qIgLTCvktXTNHNXqGpje0iNWbSfdD0z1S7aCe+pWuZ/o+7k/f7Nf0tb4qx0n3n24jqOmSI0GSzhg489Ib1yDhAPaJbj+lyDsxlmbPx9Kzk3OjH3MqhXNeufz6lyDWmDGiK1Yun5OFEhlLmk2YS7T48SjavumZpOmR5cr8GuSv4FgqFDQ7OhO17VPkPYvsVJq1S9bjvcJ0bpbVhYh/nlJ4nLPT/DqWJmtsWLMNjUT451qEXhf02eAQDTkYfJwFyXsR3PaNa3v9ZKzq70X4gIxjMiZsbRywdyu0dYmmjKbjWLfMpBa9lp/fj9Hv6fOJ7nOF6JZNbV64dO3RtmGRPnbJuqTrrPXPFH2tez1q/4ooCIIgCIIgCIcQuWEWBEEQBEEQhCoYqtrzakEQBEEQBEH4M0eeMAuCIAiCIAhCFeSGWRAEQRAEQRCqIDfMgiAIgiAIglAFuWEWBEEQBEEQhCrIDbMgCIIgCIIgVEFumAVBEARBEAShCnLDLAiCIAiCIAhVkBtmQRAEQRAEQaiC3DALgiAIgiAIQhXkhvkg0tvbCxdeeOHrtnvkkUfAMAx45JFHvL9dccUV0Nvb++btnLBgbrjhBjAMA6ampqq26+3thSuuuOIN/dYZZ5wBZ5xxxhvahnBoWeh4EYQ3izPOOANWr179uu2GhobAMAy4/fbb3/ydEoR3GDV/w/zd735XJrcgCIIgCEKNMjo6CjfccAOsX7/+UO/Km4bvUO/A6/Hd734Xmpqa3vCTvFri9NNPh0KhAIFA4FDvivAG2LJlC5hmzf+bUxAEAQAAenp6oFAogN/vP9S7IrzDGB0dhRtvvBF6e3vhqKOOOtS786YgV/tDgGmaEAqF5GbrbU4wGHzdC08ul3uL9kZ4p6KUgkKhcKh3Q3gHYBgGhEIhsCzrUO+KILztOKh3bMPDw3DNNdfA8uXLIRwOQ2NjI1x66aUwNDTE2u3V/OncfvvtYBiG1763txdee+01ePTRR8EwDDAMg+k9d+zYAZdeeik0NDRAJBKBE088Ee677z62zb164bvuugtuvPFG6OzshHg8DpdccgnMzc1BqVSC6667DlpaWiAWi8GVV14JpVKJbcO2bfjKV74C/f39EAwGobe3F77whS/Ma7eXBx98EI466igIhUKwcuVK+OlPf7rPfaIa5n3hui58+9vfhlWrVkEoFILW1la4+uqrYXZ2tur3hIPD1NQUXHbZZVBXVweNjY3w3//7f4disejV6xrmveP30UcfhWuuuQZaWlqgq6vLq7/11luhv78fwuEwHH/88fD444+/lYcjvMmkUim44oorIJlMQiKRgCuvvBLy+bxXv9B1ZO+7EA888AAce+yxEA6H4d/+7d8AAOC3v/0tnHrqqZBMJiEWi8Hy5cvhC1/4Avt+qVSC66+/HpYsWQLBYBC6u7vh7/7u7/a7Xgm1TyaTgeuuuw56e3shGAxCS0sLnHPOOfDiiy+ydhs3boQzzzwTIpEIdHZ2wje+8Q1Wvy8N8xVXXAGxWAx27NgB5513HkSjUejo6IAvf/nLoJR6Kw5POMSMjIzAxz72Mejo6IBgMAh9fX3wN3/zN1Aul2FmZgY++9nPwuGHHw6xWAzq6urg/PPPh5dfftn7/iOPPALHHXccAABceeWV3v3aO01Oe1AlGc899xw89dRTcPnll0NXVxcMDQ3B9773PTjjjDNg48aNEIlEDmh73/72t+HTn/40xGIx+OIXvwgAAK2trQAAMD4+DieffDLk83m49tprobGxEe644w646KKL4J577oH3ve99bFs33XQThMNh+PznPw/btm2DW265Bfx+P5imCbOzs3DDDTfAH/7wB7j99tuhr68PvvSlL3nf/fjHPw533HEHXHLJJfCZz3wGnnnmGbjppptg06ZN8LOf/Yz9zsDAAHzwgx+ET3ziE7Bu3Tq47bbb4NJLL4X7778fzjnnnAM6/quvvhpuv/12uPLKK+Haa6+FwcFB+M53vgMvvfQSPPnkkxJWe5O57LLLoLe3F2666Sb4wx/+AP/6r/8Ks7Oz8MMf/rDq96655hpobm6GL33pS94T5v/8z/+Eq6++Gk4++WS47rrrYMeOHXDRRRdBQ0MDdHd3vxWHI7zJXHbZZdDX1wc33XQTvPjii/Af//Ef0NLSAv/4j/8IAAe2jmzZsgU+9KEPwdVXXw1//dd/DcuXL4fXXnsNLrzwQjjiiCPgy1/+MgSDQdi2bRs8+eST3vdc14WLLroInnjiCbjqqqtgxYoV8Oqrr8LNN98MW7duhXvvvfet7BLhIPGJT3wC7rnnHvjUpz4FK1euhOnpaXjiiSdg06ZNcMwxxwAAwOzsLLz73e+G97///XDZZZfBPffcA//zf/5POPzww+H888+vun3HceDd7343nHjiifCNb3wD7r//frj++uvBtm348pe//FYconCIGB0dheOPPx5SqRRcddVVcNhhh8HIyAjcc889kM/nYceOHXDvvffCpZdeCn19fTA+Pg7/9m//BmvXroWNGzdCR0cHrFixAr785S/Dl770JbjqqqvgtNNOAwCAk08++RAf3UFGHUTy+fy8vz399NMKANQPf/hD72/XX3+92tdP33bbbQoA1ODgoPe3VatWqbVr185re9111ykAUI8//rj3t0wmo/r6+lRvb69yHEcppdTDDz+sAECtXr1alctlr+2HPvQhZRiGOv/889l2TzrpJNXT0+N9Xr9+vQIA9fGPf5y1++xnP6sAQP3+97/3/tbT06MAQP3kJz/x/jY3N6fa29vV0Ucf7f1t7z49/PDD3t/WrVvHfvfxxx9XAKDuvPNO9rv333//Pv8uHDz2js+LLrqI/f2aa65RAKBefvllpdQfz/e6deu8+r3j99RTT1W2bXt/L5fLqqWlRR111FGqVCp5f7/11lsVAOxzfAtvH/aOl49+9KPs7+973/tUY2OjUupPW0fuv/9+1vbmm29WAKAmJyf3uy8/+tGPlGmabF1USqnvf//7CgDUk08++Scdo3BoSSQS6pOf/OR+69euXTvvOlsqlVRbW5v6wAc+4P1tcHBQAYC67bbbvL+tW7dOAYD69Kc/7f3NdV11wQUXqEAgUHW8CW9/PvKRjyjTNNVzzz03r851XVUsFr37qb0MDg6qYDCovvzlL3t/e+655+aNrXcaB1WSEQ6HvXKlUoHp6WlYsmQJJJPJeaGjN8qvf/1rOP744+HUU0/1/haLxeCqq66CoaEh2LhxI2v/kY98hD2RPeGEE0ApBR/96EdZuxNOOAF27doFtm17vwMA8Ld/+7es3Wc+8xkAgHkSkI6ODvZ0u66uDj7ykY/ASy+9BGNjYws+vrvvvhsSiQScc845MDU15f23Zs0aiMVi8PDDDy94W8Kfxic/+Un2+dOf/jQA4JjYH3/913/NNILPP/88TExMwCc+8Qn2oucVV1wBiUTiIO6xcCj5xCc+wT6fdtppMD09Del0+oDXkb6+PjjvvPPY35LJJAAA/PznPwfXdfe5D3fffTesWLECDjvsMLZunHXWWQAAsm68TUkmk/DMM8/A6OjoftvEYjH4y7/8S+9zIBCA448/Hnbs2LGg3/jUpz7llQ3DgE996lNQLpfhoYce+tN3XKhpXNeFe++9F9773vfCscceO6/eMAwIBoPe+1aO48D09LQnBzvY93W1zkG9YS4UCvClL30Juru7IRgMQlNTEzQ3N0MqlYK5ubmD+VMwPDwMy5cvn/f3FStWePWURYsWsc97b1T0cHgikQDXdb39HR4eBtM0YcmSJaxdW1sbJJPJeb+zZMmSefrsZcuWAQDM03JXY2BgAObm5qClpQWam5vZf9lsFiYmJha8LeFPY+nSpexzf38/mKb5uuexr6+Pfd47RvTt+f1+WLx48RvfUaEm0NeY+vp6APhjqPxA1xF9DAEAfPCDH4RTTjkFPv7xj0NraytcfvnlcNddd7Gb54GBAXjttdfmrRl71yBZN96efOMb34ANGzZAd3c3HH/88XDDDTfMuxHu6uqad+2pr69f0DsvpmnOW4v+lOuW8PZicnIS0ul0VQ9v13Xh5ptvhqVLl7L7uldeeeWg39fVOgdVw/zpT38abrvtNrjuuuvgpJNOgkQiAYZhwOWXX84W9X298Afwx3+9vFns763g/f1daS877G+f3yxc14WWlha4884791nf3Nz8lu6PsPAxQCMtwp8PC1lL3sgYCofD8Nhjj8HDDz8M9913H9x///3wf//v/4WzzjoLHnzwQbAsC1zXhcMPPxy+9a1v7XO7opd/e3LZZZfBaaedBj/72c/gwQcfhG9+85vwj//4j/DTn/7U0ycv9FomCAfC17/+dfiHf/gH+OhHPwpf+cpXoKGhAUzThOuuu26/ka53Kgf1hvmee+6BdevWwT//8z97fysWi5BKpVi7vU9eUqmUF2YEmP9UGGD/F5ienh7YsmXLvL9v3rzZqz8Y9PT0gOu6MDAw4D29BvjjS4epVGre72zbtg2UUmy/t27dCgBwQJn8+vv74aGHHoJTTjlFbsAOEQMDA+xJ37Zt28B13QPOyLh3jAwMDHihcYA/ypYGBwfhyCOPPCj7K9QuB7qO7A/TNOHss8+Gs88+G771rW/B17/+dfjiF78IDz/8MLzrXe+C/v5+ePnll+Hss89+y/+RL7y5tLe3wzXXXAPXXHMNTExMwDHHHANf+9rXXveFvoXgui7s2LHDe6oM8Kddt4S3F83NzVBXVwcbNmzYb5t77rkHzjzzTPjP//xP9vdUKgVNTU3e5z+H9eagSjIsy5r3r9lbbrll3pPj/v5+AAB47LHHvL/lcjm444475m0zGo3Ou+EGAHjPe94Dzz77LDz99NNsG7feeiv09vbCypUr38ihsN8B+KNjB2XvE5wLLriA/X10dJS98Z5Op+GHP/whHHXUUdDW1rbg373sssvAcRz4yle+Mq/Otu199olwcPnf//t/s8+33HILAMABX6COPfZYaG5uhu9///tQLpe9v99+++1yHv9MONB1ZF/MzMzM+9veBAF7LeMuu+wyGBkZgX//93+f17ZQKIgv+NsQx3Hmhb5bWlqgo6PjoFoFfuc73/HKSin4zne+A36/H84+++yD9htCbWGaJlx88cXwy1/+Ep5//vl59Uqpfd7X3X333TAyMsL+Fo1GAQDe0de0g/qE+cILL4Qf/ehHkEgkYOXKlfD000/DQw89BI2NjazdueeeC4sWLYKPfexj8LnPfQ4sy4If/OAH0NzcDDt37mRt16xZA9/73vfgq1/9KixZsgRaWlrgrLPOgs9//vPwX//1X3D++efDtddeCw0NDXDHHXfA4OAg/OQnPzloSUGOPPJIWLduHdx6662QSqVg7dq18Oyzz8Idd9wBF198MZx55pms/bJly+BjH/sYPPfcc9Da2go/+MEPYHx8HG677bYD+t21a9fC1VdfDTfddBOsX78ezj33XPD7/TAwMAB33303/Mu//AtccsklB+UYhX0zODgIF110Ebz73e+Gp59+Gn784x/Dhz/84QN+Iuz3++GrX/0qXH311XDWWWfBBz/4QRgcHITbbrtNNMx/JhzoOrIvvvzlL8Njjz0GF1xwAfT09MDExAR897vfha6uLu/l57/6q7+Cu+66Cz7xiU/Aww8/DKeccgo4jgObN2+Gu+66y/N2Ft4+ZDIZ6OrqgksuuQSOPPJIiMVi8NBDD8Fzzz3HorlvhFAoBPfffz+sW7cOTjjhBPjNb34D9913H3zhC18Q+d87nK9//evw4IMPwtq1az0ryj179sDdd98NTzzxBFx44YXw5S9/Ga688ko4+eST4dVXX4U777xz3rWrv78fkskkfP/734d4PA7RaBROOOGEfb6P8bblYFpuzM7OqiuvvFI1NTWpWCymzjvvPLV58+Z59ltKKfXCCy+oE044QQUCAbVo0SL1rW99a5+2cmNjY+qCCy5Q8Xh8ngXX9u3b1SWXXKKSyaQKhULq+OOPV7/61a/Y7+y1cLv77rvZ3/f+lm6lstciilrpVCoVdeONN6q+vj7l9/tVd3e3+vu//3tVLBbZd3t6etQFF1ygHnjgAXXEEUeoYDCoDjvssHm/vRBbub3ceuutas2aNSocDqt4PK4OP/xw9Xd/93dqdHR0Xlvh4LB3DGzcuFFdcsklKh6Pq/r6evWpT31KFQoFr93+bOX2Zc+jlFLf/e53VV9fnwoGg+rYY49Vjz32mFq7dq3Yyr3N2deaodR8m8wDXUd0fve736m/+Iu/UB0dHSoQCKiOjg71oQ99SG3dupW1K5fL6h//8R/VqlWrVDAYVPX19WrNmjXqxhtvVHNzcwf34IU3nVKppD73uc+pI488UsXjcRWNRtWRRx6pvvvd73pt1q5dq1atWjXvu/p1ZX+2ctFoVG3fvl2de+65KhKJqNbWVnX99dfPsxMT3pkMDw+rj3zkI6q5uVkFg0G1ePFi9clPflKVSiVVLBbVZz7zGdXe3q7C4bA65ZRT1NNPP73Pa9fPf/5ztXLlSuXz+d6RFnOGUvJGgCAIgiD8OXLFFVfAPffcA9ls9lDviiDUNAdVwywIgiAIgiAI7zTkhlkQBEEQBEEQqiA3zIIgCIIgCIJQBdEwC4IgCIIgCEIV5AmzIAiCIAiCIFRBbpgFQRAEQRAEoQpywywIgiAIgiAIVVhwpr/br77KKxdyZVZn+fC+2+huZ3WpSNgrH5EIeOWdr7zE2v3yKfw8W6rwnbTI9km+cn8wxNo1tGBGorow/7fA0kVYd8Ypx3tlu8J/a2oOvSj98XpWt2nbsFf+3cNPsTrw4+8FSTnhD7BmAZ/tlcvab9sVkotdubg9K8ja5RX2/2yBS9BNsslfPvUM1CJ3vnSpV37y92OsLh5a4ZWjkTpW5zdwuMaifq/clOhg7eojXV45mUiwuj1TmElyx+TLXrmuk3uQNnZiCmF/MM/qCrmUVw6F8PxaRpK1cx08146T4ftYh/sYDEZYnQ+w7VwaU99Oj/PpWsziseVLMVanAMfF7MwebJfnqXTT2TnyHZvVzc7gfvz4S09DLdLVv9wrm8rP6qyI5ZW7D+NjhCwjMLQNU7y6Lu/jeCKO5WSY1wVw++3tmPY+leXneio165UbG5tYXXm24JUzY1NeuaGOj/22nk6vnLWLrG5uehq3keHj2ALsk0oRz+9cmqdaDtfjsVUcvi5VyDrluI5XVqQMABDwY9+Fw3xtLpdwzXrlqZehFrnpt0Ne2dGOzXFxPeajDCBAssoaFq4HZddg7TJlPNeW/qiqiGtMXQTX+7oY70ebTNFMxWJ1JhnUFcD9dxXfD0P7/EbRX4NS4NJKVueyz1X2o8qbVfQe4Przexewh289X/rS57zy3NgeVlfM4fz1BaP8i2Qs9S/p98qL+/t5O9KPI7t3saqNzz3nlYe2b/fKjjbmTDJfgxF+DUrG8dpSl9h3GQCgvgHvkRKJBlYXiWFdPM6/F47h74XIb4fCvD+sAK5LrjZeyCgDVe3Rr4N95bouqzLJRDzuyBXwesgTZkEQBEEQBEGogtwwC4IgCIIgCEIVFizJmB0ZxC85/LG230fCA4qHfAcKGM47YsVir+yWebvWZgxVhvM8JEjjMzQcky/xbcxNz3jlrMFDaiUS8jrymBO8ciXPw5tT0xg+bQ3xEKxbTuM+hrRQEwkQtMQxjLt68RLWbnICw7+FAg/dZmko18TAX9DHQ+UdbUnc/0ALq9u2cRBqHaowiTbxEPIrLzzplbvb1rC6eBTPR7GM4chChp+LQhLHiG1wOUV9Bw75pd1YLoTGWbuMm/LKbprLaoIOho1UEH+74vDf8lkok2io46H4SIB8Lxdndekcypoy0zjmdm4dZu2sIJmHfj5ndo+g1CUew/3PZvi8sG16bNqY5tO8JlEV3Gc9jF4g0oKx0RlW19KM5yZEJGWmwee8n0g0SjM5VtfQguOgq7XRK0fDfFnNp8lvl/h4X7ECpRZtJx/mlWNhLsMKxvBzyeWSuFIJ5T3pFF9TqIxpcnTSKw8O85MbaMCQqRXioX7HwN8L16FEIBTk8yIewv7w+3gfuG7tu5cqC9dcPfxLHy0VSnw9LjrYNkCO0zD5Nnwm9onh8m3QH6ASilyRX58sA/vcMLk4xCThfJPuvzaPjWpSiAVCz6b+1M0ix20Cn5OVCn6uVFlfqqpGjIMrKXkzqG9GCVhzYyurW9TVg+0aNImWgefU8OG51mUvxSLKe5a39bK6/sOO8Mo7tm71ynOzfA1MzeDnncP8vmHX8A6v7CPdHQ7wMeeU8Zrn9/F1IxRGSYYvyNfVUBzXinAc1+JkYzNrl2zAfkwkuUQ2lkDZWpyUwzF+PbWI5NHS1iWfxff59ZAnzIIgCIIgCIJQBblhFgRBEARBEIQqyA2zIAiCIAiCIFRhwRrmwSJq6PL5FKsLGERn5XD7EJNorqaGUSf6wii3Qtk0jtphpWnEqG45HEINXdnm+ihqyRLWNICpPAqmnn11wCu3N/L9LdlUH8V1Q0HSW36/pqMieqzlxAKmd1EPa5aMo55mbM8Q30QFdUmxetTuOH6u/4kEUQfZ0cTtxHZZmk1NDTIygTZYHX3cisayUH/UEFsMHNSkjgyixmpwhNv2dHagriqnuJ6p3ofjzK7b7JXN2BRrV6qgViuT4vrgBh+ewwDRItcl+LmIh1FbWtIsBMs2apPB5mK+uXHUcc3uwEG39fn1rF20G+dJ5xKuZQ8R2710Bn+rVNS0k0QzNzU9wfexwvWTtUgwgP2jHD4nHWInBDbXqrXWo3awOI3a5EKW90+I2A5Fo3xurViO7ycsXdbrlec0Wzl/iDyXMPmasvJw/F5fL875conrpZWJ+2Vqsjufn2hvy5pmlFiAlnNofXdikVsoGX5cV82IpmEOVEgd/t3U1sAAGUumpjPVNZi1SIXMQ+Xw/aVHY2ongH7PdUlf6d5o1EtOew8oEMDrlU1e8shX+HgME8tS08e3oZhumRzLvL439lOGqnZuVDtM7bkM7VybBu7jfMs5Rer2/1PVxsvbYSwtW47za2DLAKubmsP1IaLZrQXDOIeKRbzOBwL8fQGXWBTmSvzdmeYWfAfmpM5erzyyc4i1y8+lsN0pp7K6PeP4rlXAj+MxqemDN7yCFnaPPnQfq7Mn8BptaXp+l4wZH3kXQj9Oi1gz+rU6XxD3KxLDe6REYxtrF2/A63B9Pb/faGzEd0/WrD4MXg95wiwIgiAIgiAIVZAbZkEQBEEQBEGowoIlGQULH43PmDzsZzho79ao2XbE6tAKpJjD7FKptJZxrIihLKVt33Hws0Xa+fT7fWIxldNs6+IkjPPsy5hpatmSpazdYf2LcPsBnv2mtxelFjmX26uM70HLpnQGwyUQ4mHcY09Hy5f1zz3K6gokjVOmgr89neN2Kg0FDJV3Wjz8W8zUvuXO1q0oEehdzKUEfcux/3cMbGN1uTyGqKJE2pIp8KxlG7a86pVjHfz8NsYxRG2bGFbcvWOatQOF268PdPIqkhEvFED5REOC2wdl5zCEtHkTD63WRzFsFK/j47jSiCHf3Ai2GxtPsnZ9XdguEuPbsF3c/zIJ7fkCvB3N5pfPcQmGcWCOO4eEaBLXG5/Ljy3uoMwgrNkaEac0iBDJU7HIx1I+i/Na5fj2J0Zx+y8RS8GitvY0tuAYb+/i4cL2DmKnmcTt8eAjAHVwCwX4iaHygUqO/zaE8Yslcu5VSct45ZB1O8jXkHALho3tMP5WyeD2dsrYf0YtV9W+RyEN9R9I2N8w9iN/0CyraJ0uY6iU8JoRAOzXgI9n+tOzDLJtEF0gy6dX7ZIwT61x4NcP/VxX6HHqbVlKtv2PCb1/KLUvyACoJ9ayi7V7jN270B50ZobbmdYRiUaQ2NoGLH7UUTKXC0VtHhJpGs0MmUjw+4gyGXO2w7fRTWSl4VDSK8ciSdauqbvPK+e1OfPAT/+PV7ZsXhcgFo6K2GS6Bb4fJrEGLVaRdUzQsW9wCQxYeC30aXKqIJF1XPmpv4HXQ54wC4IgCIIgCEIV5IZZEARBEARBEKogN8yCIAiCIAiCUIUFa5iDBmo826Ncj5kkyqqGeq4VHFSokYyGUWcSNLimJUJSuFai3BKuYhMdC0mH7Wj3++EIsfsKcrVX2yK0bOro6vbKU1mu2xxLo67nhBOOZ3Uz45hu+P0fOIXV/fpXD3jlp5/6g1detPoY1u6sIzDd8/aRHaxu8Em0aJkrowYqq9mOrTgOt1mozLK6pmaueatFdu1ETbqCAqtLN6LdYNnkelLHh/qmZP0yr7x0eR9rNz6B38tp1mivvIbj2CZa+WTTMtYOFOqs/UG+j/UNaE0Ti6AGNZPmGqupcRyrbplPtVAdnt90mWvLXi2inV6pAW1vzBaeGjsSwmOZTfG0p3tGcd7ZxKaxUuL9kSXvFdi2ZqkW4POwFulbjZrgYJHPE5ukTN+9m8+TzS+jjaCpSPrrNLdoMmw896am+93xHPadReztbE2v29yGGubZrnZWF3XxnYaWOrSiamvnWucIScGur51l8s5EtszPYTmNcyY7RN6zmOD9Uc7guCgAt0BsWobrpUnW91ALt1E0kqgP1NNC+3UvvBqkQtSxhqbHrGLExiz0KsQGztI0zAaxPXW0lNHUcS5C7Pqi/HIKdh7HZ8nk79iUYN99rO+vYuPz4J8XpgWvUvenU/vv6Wx6Fd+Tqmvk7+mEfXiyZzUrzwLR8La0kXdntPe6KkQLXtb0wQZJz26Sst/Pr0H19ZhO+sknH2Z1cWLLu3IV3geVLD7mqItlXTNfsyo+HLyzs3y9iRBLxAjRMwe1d+AMH+6HPnLIobFU6kp/X6KcIXV8K+n8gY1HecIsCIIgCIIgCFWQG2ZBEARBEARBqMKCJRmBKDZdHOf2WX0kpJkIaJKAud1eMZLEx+u5AA99un58tn/c0WtYXSuxZdqxDa3Gdg7vZu0salVi89BziIQ0TjoBJQ2TfDfg2Ucf8cpbtixidU6BNI7yMHqK2DllK/jvkG17uF1ZziWWYbZmU5XCfS6FMNy5tIdnvEu2orxkcppv/6yzVkGtY5fwPKUmuA1WJY/SgmCUh0vq21CeoIIY+mxZwkPDaRdt1LKaTU0YUE4xPY39HQ/wjEsdXUncJ+DWP3Mufi83g6H9kMW3kSVKjngdlzfYAQxRTeR4yO6+nxGbHTXqlZcEeDtL4ViaGk2zunIR+87yYbyqqGUcVCScHNOyThmq9kOf7774NK+cG+Lhzad/87RXtrTMefk0rgeOQzKEaoG/RATHaszPw6KNJDyZjJC+82lh7gquj+YIP0/rf/WkVx5ev9Ern3Huyazd6sN6vXLUz7cfmMO5YEzxfZzeifOpuBkzYubGJlm7IrGYGk3z8OnwAMqkfCQzamQRXwNXnnO4V/ZHNFmd8zawlSPDXVOUgEVkAPq0YJntaGhYG0s+EhI3NVmBRWzDKg6ez6KWNTI7iuewadlqVlchz7+ois91+X7QfTRcvh80Yq3P/v2tBtVkF1UlGAuOhmsN3waZ/mZSOL82rH+G1fnJyWnr45mAy6QuEkNL2kiES7nUfs41AEC+gGOGKqEqmt3l5pdf8MovPvIAq6NZTdub8bdbu7lGKEDG9OErj2R1H/nIJ73yyC4uJ5xL4XUzk8Y1KjvH155sjmRhLXBpZIVcy+hcMwx+XxUg0pCAn0t1oxEuMXk95AmzIAiCIAiCIFRBbpgFQRAEQRAEoQoLlmRky5gxKmHx7HWVKXyMvmuWyyROPQrf/C6U8fF6pxZGCEXwkfqJSb79lc3oRJAn4aWpIA/75efw0b6WuAZ8ZQyF9uwc9MrhFH+rvKE56ZUrG15idSaRfDy9cROr2zKKofMicWYY2cn7Y2IaQzXHH30iq+tJ4tvo//r/3uuVy4Ux1u6F5zCcMT6+ndUdc/ZhUOsEDezHSoFLZ+rbMPwzMs6PO13EvlTmFq985OrlrN1J5+HbutFAnNVV8vh561YM8aRneYg6TN4SdgI8zL07jeGlxjiGhTrqeX62eAMJBWn/Ns2RN5u37+bhqh2Po/tCOYPn11ikZaGbwDHd3sNDS+Ek2RcT+9i0+D5GiOSgrMlX/OaBhasOBauPwjfJtxV4yHFuBiVUTRE+DmwSzpvK4LrRkeT9sySJ3/NpzgZ+4uxTnyDnOszXL+rmEwrxkGY0ioHuuQncjy2/4m+tJ8eImwZ5ux0AwCaZvtyy5k5RIO4aZO3Mp/h4p0nXnBTXqaUmMcQbmUS5UyXF5QKlo1E6ZvXyS4vDlUA1ycjgTq9sGfwC5ScyGyPAw7oGsbgI+nH8mK42XkrYztXcAEIkky7Y+D1b8fEYbOv1yrN5Pt5zJBTtI/Ncaa4qNOuioa1LJnHyALeaFIJIVDSxhtpPWYc7qWiCD+ICoUtbXKP2B1NdAqVLgyRDLQDA1Bhe1wouP5Z4E8ruaLbDcIhLXRubUZbp8/HxWCLS0TDJ9Dmwld+zPP3E417ZtPlYTU3iPcbobpRkBeONrF0ggnLIpJZJ8LQzzsLtaxqnQhHvBfN5XEdyGX6NGyfXxqHBQVY3sA0z+kWjuB9dxAUNAKCxESXE4TBffxuI49VCkCfMgiAIgiAIglAFuWEWBEEQBEEQhCrIDbMgCIIgCIIgVGHBGuZmCzU0nVp2oDqStWz9zC5WN1tCTUoP0adeMsGt0vxp1Pk0DnDdb3A7Wuk4RPPTq8me/A7+wfRxzY9DdLOlZ1/0ygnNfs5tQi2Mo/u1ECuqOotbmZVyuP8NpFcjSstkN4aanM4VPLtcPIr7fHw/ajMn5ri2dCyLGqV8jmd42zEwALVOehb7KtHE9WnTadSCh2L8BGdzJGMd0Vxt3sgzJu4ZwfEZj/Nx0NqKVoEtvajvyg9zndmuSbQvDMf5OGhsRg1pfR3RB5t83PqIxWLA5JZtdhl1+W5FG8guvhOw4gicPyv6uL4rHkENY30z38d8HnW0ZfL+QWaa68KdMn4vHODaW3Bq374pkcB5PTXFLRb9Jh5PzOLjIOCSeanwHAY0z7BFdbiNcJCve2XyuKFUxjmZmeMWdoEwjhfl59uPGLhfLU04JgI+3vf5XXje9kxw/bFNXtgwTS01HLEe9AXxt+MNWpa4NPZBRNNLzmRx3OXHcL1JxPlvxQyi+ze1jIO1P5TghZ14nQHFNZ1U2+vXbKt8RH9L9aQBTTtM3QAL2pRvTeAY6W3AcluIX6JjERyPhSK/dhnEsnQ2jeesUObtHJLR0/JzjXQgQDOr8f23iO66VMS1x9D0xzTzYanMr130t33E4iusaftN8n6APnTst8NjPpKhLlnPdbLj21GLGyrw9wXSu1FHPz6OdqYvvPgia7eSWLhFovydhjLJ5kqlw6+8+CxrN0fsI21Nw+w6VOeO6DaBlTLej2UVX/eoY1vQz89vmOxzoh512yHt/YCAiZ/Tc7yvzjqr3yu3tqJOORbn/eEL4Y64Lr9OhrS17vV4Oww9QRAEQRAEQThkyA2zIAiCIAiCIFRhwZKMw+L4WDs6PcXqLBMfcy/r5pYemXGSfYuEOzu1cFUkgHVWnodWDWJvQwM8JVO73yfhJL8WOvAReYXfxK1U4jzMqohVj13ij++pPVSryUNNZ4VRolE2MMzldPCsiKGhIa+c59EwACJtWXXYEq/cnue/1V7BsNay/g5Wt6SJS0VqEdOl0hlNdlFIeeXWVi2zHaCsYXQUQ0FpxcMq6VnsL1+Ih6+nc/g5EUcbnFCMh4zqGru8cjjIp0lrfQepo+OHWwRVKg4p8zGt/DiW0rPN/LeJeuPMc9DGJwg8k117G57rgCYX2Poqjt2ZWQxlFdNcIqRIKC7RxK3XHC1MV4uEyZw3tP1Nz6a8sqlJMnzEmkqRGK9t8/lTIXKWaESzCbOwzzNpDEcGNOuieAx/2x/g5ylHpFzg4Dhr0Kw1iyVclxzttFRK5PxqEq1MBusiUTyW+hg/zok0bj8U4nIN5aLtU5GEYHcNc3lP3y6cWy29XazOcbkFWi1iRJP4Qbt+0E8lTSNAV2eHtlRclhIh17GK5rMXy2MYXcVIOL+Brz3tcXKdTPJzOEWkQNsn8Lxvm+ahcsOiY5CHuQ1yXQ5aPDzuJ2njaNjf0OQl9KMuyaDZ2ajMRbdbNA38LaX4dZhPodrMbFsk9xsBbT5ZJDueXeH9o4h94dgoSjK27eBS16eewiympnaefBZuv6UhiRUVLs3xkdundJpbRDbF6bUF1w1Du+dyiHWiW9bWRyL3SSS55RyVfBSJtGjrFm599+Qjv/fKQ0NcetnRgbLVqVm8vuo2h74QrqU+LdMftRc9+7x3weshT5gFQRAEQRAEoQpywywIgiAIgiAIVZAbZkEQBEEQBEGowoI1zDOjmKK3pNlgFXyoR8knuK4qnEeNSHEjWnU5Fte72DHcFdPiup5ghVqcoB7Qdvl+OGQ/lKZV2V+6Tl9LP2sXT+G/IYqa40i5B3U49Ta3IYuS9LQ2SbedndDSGY8+6ZX3PP8yq6tbhTZz02OoByxHuC2NTWSo+elZVpf2aznBa5BMBvVSVo7/my1O9F2VPNfXmURvFw6iJtI0+ImK1ye9smNxHWGhjP2aH8e+6utczdolwkRXXNGsdOZwjNdHiT5N6/s8Sf8JPr4fLtGZbd/Gx2p9K2oYj1mDGuYwLOX74eAYLOb4XLArqH8rFzCFdtDi6eTDUfxscXktGKZmq1iLED2/X9P2+snzgGSC67MjLo6ZXUR/XHT4kpgpku1r49EXxL6jWsSuRfw9jkQjzt+paa5lr5Dv2eSnK5r2k6ZcLmopwB1iTZVP87r0DK4/ykadaKyZrykV0o/ZHNfX5ktEi09SuhenuO5xcCvqLJtO4u9W+Pza4KpBFNGJKy0tNE1T7M4zOjNoQ/J3Pn9skm47pNvWudj/Y3O4wLsuXzeGSNryksv7NEXO21wev5fT7CHT5Fyb2jMzetw+Uz9Ooj8m3zM0jTGTf2upvV2X2MXR/dLeP1C0f5R+LqDmSZIU1+MDXJfrIwttscD15UBs1fzk/R79PZosfdeqwuer68M+n0vh+2ZOkf9WIpn0ymVtvNN3JrJZvM5QfTQAQJbYC9Zpdm4uuW+bGhtndbkcrh1bSMru5597hrXbvn0zfifL77l2DOH9pJ/cN7iaNahJ0sRb2kXOJjaHN375Bng95AmzIAiCIAiCIFRBbpgFQRAEQRAEoQoLlmRMZ1JeeVeO25PYJGwUMNpYXaQeQ9vTeXwM3+bTQsNFvHd35niIoUSsjKAZs2FFl/EQdZHIJLJTaVYXJPINi4QbSpM8rAhBlF0Ymm2Pj1juuGneB+FVJHNhAL8XmeA2XrmREa+c2ryN1bk7MWwRb8AQ8kySh7ymx/A490zw7HJ9gXaodawgnut8kZ/rzDCej9IU77uWDuz/aBjHzxyxogMAiPvw/Da08hDM5CSRIDgkq2OJtyuSbIpBg1t8mVbSK89MYTtflIcVpzO4HwUtnAQ+3MauEc06qgvD6KEYjmNfkYfpCwWUg6hSktV1dWLbBJGNjA3zsFw0RrahWSUaXClSk6SJJCmnyZMaIjiHQgEu2ymXcNy5PjxveYOPudkSjtW41iF+EhuuI7aEyQS3kYrHaIhUGyPplFe2APe3uYFLSCjFombRRtLolct8rchmcJ3KEgu7YJCvvw5JCTalWUzNkt8rkjBrscL3Y3QEw7+0fwEAXJ8e3q89aBY6Pb+cQfpHzxZGJQPUdkvPgGeT60fc5OMgRB5dTZG1p1jhY84kksG8lj4xZJF9JGMzpv1WmdhdOg4fB1TGpEDL/ka3T2QYytAkGfSjFh6n6gpXVRkTxv5ElNr2a5Tu7l6vvPW5p1jddIpkztTsFrv7erwyzZhoanZuVJai2+65xM7QJlZv0bBmv0qkkZkc348w+T2aZXBIk5jGE3i/FI3w62SArJdbt25mdbMplEYODm4lf+eSNYdIc3SZFJ1ejkPb8WaK3PvpmQr1fn095AmzIAiCIAiCIFRBbpgFQRAEQRAEoQoLlmTMkmwsY3keXq6Qt8yb2njWMtWNb4sG6zHMGEzzt399I5jFrJzlb6NnydvGDgkh+3sW8W0YJPyQ5NuobN2JZSLxKJo8dBg/faVXzpM3TAEAYAsJK9javzX2YNuSm8J9bONvi7etPdErB8NcBjCzFZ1IknmsS/TwsNlO8sZp2OIhBppdp1YxSMhIFXnYr6UOJTdWgY8RO4MhHpe8NVwu8hDy1BSOR+XnIcGoH8NGzS2YKailsYm1a06SLIMVfp785K3bioVzIZ3jWQV3j2NmorHd/C3hGfLRLh3B6uqSuJ2xqY1eOWHwUH8kgGO1pWMZq+voxLlm2BiKy6zgGbXKRMbkGHzO5EtcnlCLuGQuVzJ8/xti+Nb2XIqHEicK+LmJuN80xHgIfGwXZrOrK3C5U9CHbRsbcBuxiJZV0ML1q66O143uxHU1l6Nhfz4eszRMr7l1uERJM6tlckxlsNJVJAPmGB+rgTjOi6zmzDBHpApFEmIvaS5FReLaYGvhU6dS++49JpFdGPPS1+2/joZ5Wd28DHhEdqj49SNIHGmyPpyj6QqPL0fDuFFfgPdxkDgFzBVwXkQ1h5JYANsNzmrOPmQf/RY/ALr/Bt19XVpBv1bFUIRvQpdd1H6W0WpESGbRdiLPAACoEDmhXdLlp9gPqTlcGyqatMVP5BWGw8eIQyRUtolrlNIcknxBrPOVeH+XyPh8dStKJqaff4m1i5AMxwEfv51UZJ8LBW3NolILoqGwLF0HSMau5tpCx4xJ3Tu0cUvHpz7O5k3S10GeMAuCIAiCIAhCFeSGWRAEQRAEQRCqIDfMgiAIgiAIglCFBWuYuxd1eWVzxwirCxPZnFPSdFXEWmQ2hxZZT+3cxdp1EB3qYcB1eNRWrrAbbdTKL25k7QpEMGV0drK64jK0u8vbqAU9on8la5czUZNTGB1idQGiKbLruFa4vJNopMdRQ+tvmWDt8q2ojfU3JFhd/dnHeOXUrj1eOdnENWjHxNB65rdPcCutYJJryGuSCvZjwMc1S7EA6qz8WtY1apFjBHEbkRDXZk1N4HhxuPsfrFiMuvfOxj6v7PPx81nMkYxLwHW/BtFIZYnmbMvgMGu3J4VjwqxoFk0p3H6D4uN9WT3+O9bO4wGUfVz/alVQN29o9jiBMH6vtQntF5vquO4/ncPxU9JswqK+Rqh1fFRzafDxUi5gH6Qz/L2LgsIxctq5p3jlVSu5TvmJO+/zylO7+XlqT6JGOhHHdaNc5oOuRDTArqNpFqlVoI1avumZGdYOXJqFjmuMc1n8XirFf9sxcG6YZK6Nabab9Fggwsd72iVWjy4ZmwZfl6wIsWmcJwGufVs5qmfUrboo83WQ+6nTddxE31zUdKd2FueyMvC64A9ya9NWct0JW3zO9zSh7r2vBa9x0RBvRyT18Pi2MVb3yADux3SZn0QL9q3Vtm1dWwr7bKdXKrV//ajuIEZ5O2T6K5L3KTo7eObPWD2uq/kxvqbMzKS8MsvmZ/M5D9TmUFtTXAfblsk5m03zOR8gWQWpbSIAQKGE61K2hGuKfo2wSYZGS88aSeX82vWJWuZRm0b9vJtV1g3H2d8cXeD8hAMfS/KEWRAEQRAEQRCqIDfMgiAIgiAIglCFBUsy2jpQ0pDZze3WIvX02buWOYg86t8zhd/795dfY+0Oa8TQ07UhnjEmQm7rFclWNfMK38ZMM4aydpR4RjMamuhYhlZvi+q5LKK8B/2+YkQWAQBgUP+mDH+WHzSJFVAef9vZvp21U6MYApuN876KLkfZS0dfv1cujnFLsmaSUefo1UtYXXdfF9Q6CZIJLRTl4V/lw36NapkWbYeGqLCPs3PcssaXxXMd9PHtQ4FIQAoYwjR8XMri2PjbQT/fjwoJgc0RRYxKc3lPuIKht7Di0pOghZKhPannWV2vD2U7XaHV+LuaBWKB2DvOlflYdWfQNs1wMRSXjPKwnGviGMykuWwkEK2HWieocCy1NfezuhccnGszwMdI52rs45PPwPN22ApuA9kYwSXy/v96iNWlU9j/+RyOkRlN7lAmEiTl488oMiUq78HzW1/goc8gYJjV0cKzqTQeW1kLj/tJhsNiBbc/W+ThTD+RFhUsPt4LgHOtTCw+8zaXuVhkPYtEuXzIqZbVrUag81p/kmQSH7VqkgwtBRurok5ymtoM/IB9eWwS+/HINceydi11+EVXs6YLmCiR6W7G9cbULNpsG9v5lreyunQB296/PcX3n1iBUSsznybNUST8ruZJMsi4I9IBR9tHZjmnh9irSDlqhVIRpRY+i5/s+jpcV+0iX5fooeYKuI2Aj/dxgdj8uhV+XfARySDtflOzZSuS3zYNbcSTL5bL+7eEpHOBWsUBaOdey465P9NAfW65pENMTTYyT+6zkG3qc3JBW0DkCbMgCIIgCIIgVEFumAVBEARBEAShCnLDLAiCIAiCIAhVWLCGec5BmyOf4mlm/SQlYllL1ZyyUYczk8c6W/GfnvOj1nTEz1MAJ0kq5bJJ0iorrvObc1GTs3uca5jrTNTUzRJZ6y9GfsHaLSd2dP0NXIfXGEQdd26IW+s5BZKOmWizZmd5Clo1hX1Q1uzQKnPYtvzKgFeOaEqbUgj1aT0rV/FtjHJrs1rEItaDjsH1mBVi95XXBEb5LLHrI2lh67SU0UGi5QvYdawuaqEln1VCzatb4Fq+sD+JHxz+70rDQQVWexy315Y8kbUrOGjHlZvh9kGDE3ieGnxci58gutxFLbiPm8a4Ht40UAvnN7iOrUxSnRaJLrEQe4a1cwJEe1/k4z2TIrrowy+AWiSfJrrTID/XJTLPO3u5tdO7P3iSV16yHLXsgTAfdKtORX2zra2WT/w7rh3rt+G5MUq8oUPs4iDAtYgzRKvcUI/97wtzm8NCGjWLmRTXDueIxNDS9JIlGyvniO4xb/L92LQb157hKa5ZzDjU9gn7p6Slla1rwvdBYlE+J2eyfD2uRRQ5Tl17q8z9qx2pRlIRraah9Y8i+m9Lt4iM9+L3yEs7pRy/1s748P2VuJaCfWAStfPPbU555dz0KGsXaUM7TVPz/6vkcT7FTK47LZJU6IpYOM7To5I13NG0q1RD6trYztXaMR2uvnm14NuWQ0Y+jy+3DA8NsLpwCOd2sk5bs4ge2STvx7Q0NfB2xPatkOc66DLZRpm8F+HTdNAWsSWsVPh1mNrFsXM4TwNMzqfu8kYt4RaYTl5pG9Ht7v4U2PycX3lA25InzIIgCIIgCIJQBblhFgRBEARBEIQqLDi2ESB2MD6Xh3+bTJQIlH380b6vgqGDPLEy6mzmNl7dizFkOpLh4Wv62DxA5AiGFiMtk2xY7STrEQAA3a30JIaa1TQPZ4xOE6uuCJdMLCJhEHOSSzKggD9g2ib5Mw9F5h3chjJ5SC2SJxZ8JKNhRAtn5IitVLLE+7vpiGVQ67gTJIwT5iGYskmyAGph6YAfbdrMMgmf2jyE7JJx0dJxNKvzO8u98uQoxuyprAgAwA4Ty6Myl/4UCvh7oTCeQ1ObTYkkZo0L1Gmh+Gbc/4AWvk4XMRY3XtjglWNt/N+3IQclGaUitwKzHLRHUySoOTbzImsX9GNIsKHhCFZnVvg2a5Hd02gd99SrT7G65iVJr3zZVe9ndYtXUktBXG9Kuh0lyS65es0KVjf8IsowHhr4nVcOlLktZoXIY1zF52sihOemu4NYQmoZrrJkDOqWcKkSyeYHHL8ft5Px4zb89XzM7dw17ZXHMny8Ny1CC75RIt2wK3xMmwbO1/RshtUVbb7NWsRimf40eysSKtbrWMh3P6Hm/78S61xuM7krj583zeH1deM0z4ibaIjjPjma/HEOx3FlN2bB9c0OsXYX/zeUZEyOcLlGfwLHrhmKs7onh3FdosrLZIAvfPEgjotggK/hhoV1LINvnl/zU0WcM5Ol2pdg6Dz73KNeeWTnIKvz+7DzclmeqdcXwnkZJ9lDu9q53eXcDH5v1uGiGCeM68FsKuWVtWR7YBMJUqHA1z0LyHlboGxhnssb/UMVSQb7+4J+ae8m9z1fq9o+6r8nkgxBEARBEARBOHjIDbMgCIIgCIIgVGHBsY5wAUM1ozbPjtdCwuj1+RT/gQkM+dgZDCOsXNXH2i1ajlKCmZc3s7p2mkmIhBj9WqajcAbDCj7t4X4kgqGOrduGvHJTjm9jcR+G/XcHuPRkfACPJZyZYXUGybBlOLi/RYuHYMskLlLO8boZ4qoQiWCoPKNJAnLEZWJm9xir8y1qg1pnZRdmr3I02Yvjx9Bke5LLakIJ7BODvLE9ObmTtZsh/WqFeCbEYjHplQskA1sozN9GL5exrpDjsp1cjmRyJOEwx+Hnsy6OIc1wjGccHJnE8VO0eHh8Tw7D3rFpPNdWPd9GJT3klSMmD33Wh3u9si+AfWWXeLtoEMd7V9tSVueHTqh12vpRxmDH+Dw56tijvPKSI/m8cBRKryoOnuuyw+c8kLf1AzG+XC46HPsr89Pfe2Vfha896RzuV0DL9HfUisVeubcPy3M5zQljAsfgWJ7v41ieyOUsHp61fLimxNpxXTrlPaewduO/QPeU0QoP01/8l+d45cd+j7KXpx/hjjwjRK5RKS1idYaWDa4WsaiDg3b9CBD3EVtxSUzJps5N9Ht6hjo894bmLUEdKKaJ5CZg8VB2vEjWHr7cQKyImXSLCh0zKtr+2rMoSRzbtYXXEcnQSWe+m9U1EflZSwzX6e5GLt0Ik2t0KMjXGx+RvlH3BbvE5+7gWMor//sTQ6xuT3F/eeJqh+1bUEo3M8mdshb393rlYJjLMotEplIq4brk19YNOn4sTe6QJvIWRdxwgiF+/bBzuDYoTdZRdnEcuGwY79+1Qhc3UMmELk9aaJa+P4UDkVmYuk7l9dof6M4IgiAIgiAIwp8TcsMsCIIgCIIgCFWQG2ZBEARBEARBqMLCM/3lUFvzyJyWFQZlkHCKyy2+wuOosQ1VUId39JqzWbuObtSa/vKZV/hvEy2P48P9qGi6uLBCXUxxF9f2Wo2YKWdxPWpjiw7XrvqiqLk64tTjWd0MkVnNPD/B6kpE6OP6UJdbUFyrE42Szgpz+6kCyQLmksw+ReDHOTaBFlBzqSlWN7t5q1e+EGqTI448wyubCa5/M2PYJ8kQ1/ZaQexXC1BD99qW51m76Z3jXnlwjOuP/T4cS+EYyQhY4TZYqoLjIDfHLY9skmEyEMD9yGf5NnYMoe1YLMS1fI6LUy9T4XNmMoPntL+CWv+ZEa5d3TmE1lH+Mh8jyRiO/45efOdgzubaezeJ/d3g51q7WJCfm1ok2Y7z5OP/40pWFwiTTFYmPzcm0QCaZBkMh/kxK4XtbJfrLDt6UBe9fCXqmXe/omX3dPB7lp/rCMs+/Lx+O2qCJ4gdFADA2ARqmifm+HhJk3XQtPhYjYVwzJxw5ule+fjzT2Dtnn4Zra/y27iVWTSJY/e971/rlbds+Clr99Jzr3rlM97L9fBtvfVQ6wT8OA4Mk2s6k8SqK2dzjWQhjWOLPoGqJqUMWPxZFbV+9BHNcU8df8djZWvSK8/MpljdXAbXuoqL+z+e5nr4Rx5Fy7PVx57E6oJB7IP6GF9/u1vRCraZaJiT2nsopoH7H9HWPZMcN81Cl8rydXrLLtTRO+RdEwAAw619PfzULrSFdbRsikDW/nCEz4vxCZx78QjaymWyfN32k/dSCkXeP8T1FMLkXai5OW5hp0imxYh2L5Im2WFdMt7N+d5xuD1NxUxbLlSzXE1/bGrZSf8UK7k3qqWWJ8yCIAiCIAiCUAW5YRYEQRAEQRCEKixYklGew8x2A9PjrC5PwtfJLm4FdqQfH/vHSbq9vu5u1q4uhqHVksNDjqU8fg74MVRQVLxdgFhrBcpcNlKYxpCGSaxtXIs/yh+fRsud2U08nBQJYUggE+JZ0DJhDF+VYhjWpRZkAACRZjzOmRIPpWRsEiYm8pXRPTykZoUwfDKnhfOjc1xiUossOeI4r6z83FaHSm58lpZ9yMG2RhjPRX4DD5+OkKxl08VpVlcXw/Nmj5GQVJCfz5YGzG7WWMdtFLN53C9qP1cp8nORSaG1U8Hl49Ei0qVskdviZUnbtIvhXsPkY9VvtHrljdu2s7pEE35v1ofj0R/lso4skaJMa9nZ+lrxPK1p/UuoRXIl3OdoAx9LLuCxUmkFAIBBQsN2iWZx058hYJ+XtdBwshX79b0feI9X/j9jP+f7mKK2XjysOG2iXKOpJemVs3aKtSsSyY1PywwZJtaVrS2trO6Ek1Z55RPftcYrG0l+nB19uC65Wha6bdtQrvHeC1Cmdthh7azd8y+gRdnuoT2srmcJz1RWi0RJv1radWGahLPzZV7n0Ix7xKZqfqY/HAemq2VnI3N+TVfSK5++tIG1c0lm1znt6u2QjKf5DF4H4tr6deQatPU89sRTWV2MyCvKJb6emfRwqNRQO8wAkc5VKny92T2EUoXHnn/ZKz+/h689G1PYP3Na5kzT9+ZZkh0s5gq4VkS0a1yayK18mq1cNIKfiUIISkUuB4sRuUaxyGVYqkRkq+QeSc+IS1UMjiZpoFkA6Qk2DE1KtEApxIFm1NvX9yzNAs4ldY7zp1kN0gyeC0GeMAuCIAiCIAhCFeSGWRAEQRAEQRCqIDfMgiAIgiAIglCFBWuYz+1FHdHkDNd7PjeIetvfDnENbXgxfi8SQ21TXEsHXMkQ6ziD61FyROsbIilKHc2aB4i+xtX0LjMk1awqog4skOO6xEqKaH62cW1phPz7okzsWgAAXrVRYzQ4hZZzIU0iE3BRbxQI8e43KsQqJoWa65ziVle+GGqrHT/Xc/U0JKHWiSRQU2e7/DwxBx4/1/26CsdZiFjCVXLcxmts62teWcX5WG1uQ03nwBa0Lsob3O7LIOmMfZ26XQ5+3rNzyCtn82nWLk/GnKVprAxF9NnhFKtTJD34rjEcg/UJruXrXoTvAZRKfP8LZfztcgnL8QauTy0S/W45zeduEIguejXUJDbR5bnz5MfY574K1w7b1JKILINK8TlZsXF9UKaWYtiPY6T7iF6vHG7jmtG5jfj+h+Hj/d99AqbDvuiyc73ynnGuAZ6YSHnlTI7rQm0D50lnO3+HZNEi1OKXyfsBswWu7e/qQa2sz+TjbMdW1J1GLyX612O4ddyLLwx45UKO6yWdyoFpBQ8F6TTOX31/y9Q+S7u2BPZzFdVttui3LIPXLW3FPv9va3GNmtOuT7NzKa9cH+Q/PJLF+XvE6pVe+YRTz2Lt6hvQyiysjcegwjFSX8f1tSFyoAETx9z0FF9/X9uMWvbHn/4Dq3visSe98qwv6ZUbTuEmqHkb98vV7gdAex+kFikQyzwL+P7OTOJ60NzG3wPo7MB3EGha8Zlpbh87NYGfXYevBxETPweIFVtrRxtrt2cKx8usZj24fw3z/vXj1SzbDoaG2dH0xuZ+3hfQ9czV0l+LrZwgCIIgCIIgHETkhlkQBEEQBEEQqrBgScayDmz60cgiVtcdxBDD77fwR/u/G8LwwFE9aC2U3T7I2qXIvbulPXpPlTEU3xxBeYKjeJi14uJvTSq+jSlqw0Ls7eIG74IoyTznatZ0MI0hu2CQhy13EWuXaWIz1ObnIa9oFPcjHuPbUHkMv9ll3J7P4lmQrBkM0x+uuPVdLM3DM7UITdijHN7HFWKTZzs8HOkGMATuZvA4jSwPL9tZtD1saOF9XJrEutw49qPt8tBMJYPnemqS2yhaQTyAQh7tkAoFLsnI5DFsZpnaVLPw2LoW87qWdpT70CRaelgrV8GwfV9vD6vzOZ1eOV9GiYrp41ncyg5KOaIxbvXo1v5QAoOEC23NwsrnI5kzNUVAPo9jicsweEOHZMPyh/hcLpPHDeEk/lasI8najeVwjCQSXMrV0o/h8UQvrg2hDn4+lxj4uVLgcocssZxytflkkox1BlkTgxbPztbUjBlI41ooPuDH/YrEUW5y5PFcklH/U5TZ6WMnHFzwpeaQUSahXKVdP3zEysyw+FpBHQttch0LaOFeRWxD22J83X7f8SjN6SKZFfNaqLw1iden+iC//jVFMWvfiuUrvHJdglvTlcs4XoKWFr4mkoyZCS4LGiaZS599/kUsv/gya7eNWFxmsnxNdIitYv2J7/PKBYePOYNIrfy69HKe9WPtYRdQ7uDqzyUdIiVQ+pqF466tHSUULU3cLvLX2+7zyp3t3LIxTIZWnqwV2Qo/1zbNTqzto0ksTKupKaikoZq8Qbdvo9cy/j3+Y/STvo39SS30v9PP+jX0QKUitT/yBEEQBEEQBOEQIjfMgiAIgiAIglAFuWEWBEEQBEEQhCosWFhWIjrihhDXqpy0HK2MpnJcZ/LCCGp5No1jetGlWjrHMrGsUZo/VIZo9FQJBTp+zZZNEU0OuFybEg6iRiqjUD+aXsS1QY2rUftlabrHV+9/xCt3a6kqu+ub8QNJKRryaXrsCh53doprk9uJzrqjCTWFAU3/6p/BPu3JcI1bd30Sap0CSSddLnBdVZFotx3Fx4hto9WeDSQN7BxPq2oGcXz6orzvUlNEm7wH7bLKiuulbQfPTQy4RswuEG1sGe3h8gVur1R00F7QCHD9q8+P47O5i1sLLVmGesYxkoY+wOWvYJhjuP85ruNuqz8cP5i4/yrGreO2bMY52d7M50I0yK0fa5ECSVNsWbrdF557W9PG5ckcLRRx/MzXxeH3oha3KHSIjaVp4vhJttezdraF5970c+1wA7H4qhD9cRm4ttEktpWGVgdEp1yucH2zQVIYU5uzgKW9+1CH6019Ex+r7Z04fhxiOde4iPdpzxLchnL4NcJ3gPZNhwKDjRGuBTcUtVTja0oign1Zopp6m2/DIhrSrhgfZ8vJmCkU8RwaDr/OREPY/z19XOduLsb3FoIBHGdOma+jmSlcN17Yto3VvfYavu/w4stcm7x9O9Emk3c8HO04XaIF1zKMQ6gR15h4M+6v0rdBrOOUlk5ef8+gFulpwrWzsZGvo8l67AN/hFtQFh0895PEnrans5+1W9SF5765KcnqbGIzN7Jho1eeSvHrZJl0o6GtewazPXzj6a/n65up9nnff//jp33b2+17m39EX8MtC8ePPicPFHnCLAiCIAiCIAhVkBtmQRAEQRAEQajCgiUZBsmwZ9g8TNSeRLnDyYt5iCFNwu9DKQxz5zVrnpZutLSyAjyEUbTxUX8xg2EFn2aTEvCjRRbfCwB7HMPldST0WUpzWcQMyfCUbOCh1SQJwfqL/HudUQyVBci/Q4woD8EaAWxnZnj4tNWHx01VL2aJH2ee9EFCs5zrX8TteWoRh1i4uXrILoC2SZVSjtWVU2hzNFNJeeVIY5K1O+O8073yaH6W1e2cQRlGcz+eG9fg/3Z0KtivZeChrGgCQ4kTOzFbYLHMJRlLjyZ2TmF+oNNzKKFItvAsfWBgSLyQxb5qaOYWeTaxFGxqTbK65mYqF0DJVKrA51ZzEtsFteybE6M8lFuLFIk6wdRshypEtlOp8DWLhhwDJKOWY/O55pIBWizx+VokMc0KWUnjCS7dsAIYEvSH+LkO+vHclPK4Pdvk++uWcDz6XB6idskuKy1saVdwrcsXcBslk0syZmZwrhXKfE2JRHGfp4gczNbW3yixnMvltDUrX/sehUEindFVAMs7MGNif3szq+tpwDU3lcV+nMvy9StAskbGK3xdKhexv0olYnsa53MyQmRShqZMiEZxP2ZnMZz/8MOPs3ZPPfWMV964aTurm5pG2VtZu86zTGvO/kP2FrlX0K/l/kaUEhikznQ1KRHZhm7xp1TtZ/rrX4TzOqJlm/VH8b5ieJRfM6ZJtskcyZY52TPD2rV1ooxvcnKM1W0fRLvUkTGyfYMPakU+K+1CfKAZ8PYFlWiYpmaxSMcMGVfzlRv0XoGvKYrZC9L91zZS7VAO8DDlCbMgCIIgCIIgVEFumAVBEARBEAShCguWZCj6trWrSSFcDN2sbOCbnGzHcESuhO3sAnclaGrEMFconmR1KRIuqJQxtGeXeZivRLKnmVr4oY7804CKFspp7hoARdyGGptgVV3k+b3f4mGhOMns02JhCHM2xcObwTiGY9wK//eKnU955TQJwWqKDHCJVKF9VQur61vEP9ciZRLKNrQhaFCHFEdzBwmhhCJEMl7FcnHWLrMDs9kdu4qHT/tXkXFhYialcoGfi2cfw7DW1CR3DQjH8ffyBXQpSTTwdkce1+uVByc2szqI41jqWMRdMurr8XMsig4FBZtnHMyQbHWu4r+9e2qDV25I0rB/krVLhPG4K5pjSUlzgqlFciQbp605RPj8eGyZTIrVxUn4urmRuDv4eWiShhWpewEAQCFPHF2IpY7jatn2AniuU1rms+FBDM3Xt+O4ssLc/UaRN9/dCl/bMsRxqFjm54zuf4VkQrS149y5C+VOcxm+jybpx3QW98vUsowWirjNgW0jrG7ubZCB9IwjMHNhMsL7p78ZLWqiDp8nCZI5tkKySxaifE7aOVy3S3ntWRV9s5/IhSIB3s5PMrBlp0ZZXXYUz9vvnnnJK//o7vtYu6kJvK7pGTBpxjdXu4bSLICKuBcYmvNLgMhGAro7UGsn+UCuxNo9hQvEFUaP02uh+VokmiDSyyCXduZJpj9Xc/bxEalUhGRyzORSrF2ugmNp+yDPmjwzg+PAdvcvVaBZUuc7XOw7O57erqp0g4xjpTXzEYmGS+QUShuQLnPT4H1FXYUcItvR1B9gknsMd57jh2T6EwRBEARBEISDhtwwC4IgCIIgCEIV5IZZEARBEARBEKqwYA0ztd1ydM8dG7VNCR8XkBxN7FWmM8SyZnwPa1ch+q5AlFsvFclvV4iViOlyXZxDbI4MLdOUTbZR9tM6LaMTsZVytGxYVByjZzdSRPscclC3pTRd5Vgo5ZUrQb59l0jB/ET/ls/zbQSIXqd5URurC/m0fa5BnDLp4yLXsvt8qCkyfNzWLF6H48IppLzyyM5NrN3AhgH8TmgFqys24LgrkHPTGOZZsywX96u5YTmrC4VRn1YiNoSJ5iRrVyG2TOnMFKvr6kJtteHwPnj093/wyv4Ibr9lkfbugIUawLFRrrcvO2hbN5NF3WBDqJO1S8RQm2n7NE29LnCsQTJEUxvw87Ef9OEcCgS4ztI0iE0mKZfL/Fzk8/guQUWzUaPyN6qEq2i2V1YI+zWV4nZiv/r1Q165rvE9Xrl3sZZVkGT3sx2+/XwBxxntDwCe2cpP9KSmy7Wle8ZxvJQ1az1f0LfPOkfTS1fIeBkZ5hrm6Wm+X7XIZcf1eeVAkGsbh/egPddTj3KbtlXEFtIgY7Bs8G1s34LvFSxZuozVmeQ6lBpBq7fcLH/HZmwPzvOB7dwSbtcUnkM7gteFhq4+1k5ZNAsgH0s2WQJK2rXLzqM2NkyuoaamKS7m8VruhPg7JOF6fMeG6vJtTcOsgFzLNZ2s49S+rVyiCd9D2bmH25IOk7Xa0QS3pTweW7GA/T+b4+uS4cc5WdLWJSpb9pFsp652T+SS+Tpvqdc9C/9/dA0z/azLmX1En+3q1oDk1pNq4JXD21nUVk57d8B2qLaaaJ0Vv44ZbK3Xjss4MD28PGEWBEEQBEEQhCrIDbMgCIIgCIIgVGHBkowACUNbIZ69p5zCcJujhQc6ktj28DkMK2xK8ew0Y6No45UucFujDIkXFIn9jl/LTmOT0JCp+KHlyKP9PHl879P+zeCWSJiipIVBaPhE++2iD3/bJWHQnN4uSMKYJu+rEAlNuA6GY6IuD30uaUX7qfoA335+OuWVudla7eD3YyiukuW2ez6SFa3ocBnD6PgrXnnz86965bjFw9f/X3vn8iPHVYXxenRVv6a7Z6ZnPDOeseNnnDhxYkhCAlIMIRJIiAXif2PDEgmJFRvYsAAilAgQIQHydOLYsT3vGfdr+lldDxZIfb5zJt3YUqT04vutanSvq6vuq67rfPWd8likCp/8+X1Vlr8offgI5CCly9r658KWjNvtA5PxCsKYuVBCsOvnbWhM5kXa13KBkid9fe/2Z6rsnb9LNsKt6xBSqxiLqVjs0OKOPv/yqvy7L+/dmRx/ChkGHcdxfvSGZEVc39JSqF6s684jRZA1FQq6DUKwQyss6dyfeZAuDcDist3SIfABZMdbAPmK42h7TZRu2NcQ5ZqMpW9/5yVVdu+B9P0vf/GryfEPbr2q6j3zgmRCra1peUmWyZzJ+TrTpwuh7RjG7VG7perd+QKsqcz1JyAxwSydg0iH7EsLsDafmPV3oOvOIwN4ZjRMCPxTCKu//eHHqmwbZFP1Bcg2G2jpQBXsKIsVPR6392St+/y+zLt//us9Ve+zbbGSOxma8HJOxsWb37o+Of7Js5dUNVAIOQUjVdoBy7ntQ73+droikbv9kchLbr/7jqqHofPw7FVdhnKQPmSvsxZ2IG05LcmYf1s5SNbobO9oO9CHkH0vsqluwVYV52uprLO85mKwsRwbmQScEy0hM2shCPsqa67mwiLgedPfq2ImVCvJcJVmTf8C9qHvSd+75rcwa3JmskOjHETJS4ysIwXpmGcawfNpK0cIIYQQQsjXBjfMhBBCCCGEzIAbZkIIIYQQQmbw2Bpmx0NrDpPuEqSPQ09bvQWgsT2/IVq+e9ta0xZBuufEaHZbsdQ9BouQiq91T66yONF6lzZIV/bB1swz6RZ9m8MRwJqBsdbbB4u7NugGu0Y3tAk66CWj9/YbopNbg7ShL53T1nGXz0uDlwbarmkE2ud51TA3x5K6Ohpp67geSEEPWh+ost3mW5Pj4/3W5Hg9eF7Vq4MergP2c47jOMG+6FBDsPDZTm6retd+KDZzj1J9jsaujMHVDenDF17RY6kA6ZePj8+rsqMj0e+VF3RPXX92a3Jc3ZIGyRLdVslYrmN/p6fKeg2wAgMtfqurNbo7z4rtU7mi06rvHf/bmXcCmGteoteUAqSozxyr80PNm5Tl81oDHIJGvVjUOsKTE/h2I5F+KpT0OWKwDLt8TdsXPn1jbXL8+9+8NTn+7a/fVvV+3BPt88tv6nOksDbHZk3BdLJovXR4qPXpna6MkXMX9Fg96cq6tH8o+sucpx8ftTrY1gVrqqzb0+NzHvnbrlj+2bTwewfSBmX9CY/T6EvZ3X3RAG9W9LcVP//Z65Pj6zdeVGVhUdaA+obo1c88oy0t3wBd65llrYNeLEp/1IpykfmCHo9l+DswmtHuSO67YexM91oyRv6yKnaxA6PD3X0kYyszGtF+QzTY6HJWLOm2ylDX6k7Xrs4rgx7aUeo9Ee45krHV9su6hLZsvrlncF91QpPyOs2LTlxbRNq9zRRfTEfrkT1MYz3DadQzFnku3Ivv6HXJgx/0wFbVN+cogi1eLmf2e/Ccj8dou2kvEtvf2Nb50/d7XwXfMBNCCCGEEDIDbpgJIYQQQgiZweNLMsDuZDTQ4TWUMbjmlXoWyevwBbBGWanqUETjSEJZJ3s6a1kbQhPvgPRhyYQRaiAVKZswztiTyu1YjocmVID/yrcWJyABKZ8Kb4C1E2STKXn6ItOxhNQik3mnCNdSWwBfmrG22es25fydqpbHuJB1ccWZT5pdybbX62h7wQTGVqurM1mlQ5Ek1ErSrv3256peeVn6wjNWYEFBQn/VsYQ0vTUdZ11alXB+tab76f7t1uTYhX5vHOjxMorFlmlt/Zwqe7gjIbtHx3o+ZYHMjTMQTc3nTcgLxvhopENNu5/JmCkHcpJrN3XWr263NTk+buqxGuTn374phsx8cWTClhDBK5W0ZV4AtlU+SAtstkAM/9owfYrSLsjuGY90u43HEOZuainEd29JJsrXXn9lcvzXtz5U9e7dFxnT+kNtBZZfkDFdqy2rsghCvp2OjLMTY+f49PUrk+PFRS0Bqy5JQ7baMq7QDspxHOf8VckiOezrudCP5l+S0WyIJMMkcnVcyEoXunqMRGARubEs42Xryk1V79KL0r+VRS3DQuuu6oLM67W6lmSEGCo3Fllo4+XC8ymxEoZExmMUG5stCHOXQv1sWavJPHn15Zcnx/mFRVXvd3/64+T4we59/dOprOExrEueb2SejrSx59lQ/JOF0b8Jhl2ZJ+OBltK5CUoVrN2aDDyUHGRjvfbkcJ9lmiMDWVmcYV+b7MSn9jBwHShZg/EzSw2TGTlrCue3b2ZLOdgjQdbIakmvbeUSjhE9DjCLIc6fzM4LuCyUuTiO4wT5J3tnzDfMhBBCCCGEzIAbZkIIIYQQQmbw2JKMBL6EzcxXsS685g5zJqQ5gC8U4Z+dKet67/1HHBGOd49UWQzOGEfwmr8Tm0xTEOoomWhDHq4xCzHco//PgOGeXE6HiRJ41d9O9JevMXyNiiGB0P6XBCQZqQkPePDpawpfdrYgbO44juND5q28p0N7bvr4KptvisGJyDBcX/d1UJEQe8104uiuyCYqq5AtcKWh6rmBhKXPLt9QZds7Igdpfy6OEdc3n1P1FhakL85t6XH2aFfC6l98JPUGHR0y8ksS9g6LOgS+dlaucX9bZ9QaphC+RucX84VvdVHCVxdNpsLDOxLCjyHzYaehQ3v7exI6HCUtVVZfWXTmnV4fxkGs5+Q4lvkVRXoslYrSripzmAkr+r7MpyQyUgtY2/pdmZMHO1p2sXZGxFFLtUVV1odQ61M3xLGkOdSOJWFO7qWrFVrO2JPfDos67JqA/CyXl/mztrml6l24BF/WR/ocaCQUjWWMtzvacaUMWe6KBSOPKem1dB7ZqIlkcGyyyY3dxclxvryoyh7AlApr0tev39JZHZfBNWNspBBp9tXOStjvjuM4Ff3YVORg7HrosGBkkqpDU32fGWRyPOVGAX8uVuW5c+2ylnl9fHtjcryzoyUZMfweSnpsOF8ZOBhrhvn3yHCcNJbnWN3IJgOQIwyN9CdLpYMDkKnkzV4khLZLUl3WAulFIQAHnYJu4yiS64hNtkBscpRn2DGB0h/fOKKEkP24VtZOLevg8FIryTUWQv0M9WD8WykOrs24V7P1XJDF+kbW4fuUZBBCCCGEEPK1wQ0zIYQQQgghM+CGmRBCCCGEkBk8tuDVC0QjEtisMPC365tTghYs6UlmrI2KtvGqB1IvGGobliroqoagv7JZ+mLQBvWMznqAViOgP/bj6Zocz2ikUb+TudbSRwjADiYw7VGCa14w/10pu9AGSlqmdWZo69c7UUVOyTNpqOaQQePTybGf15raEbRrWNG6p43nxLZqDBnNYmMNk7bFSq5zqO2sui3REg92ZZx98A+d6a9eBcuaQGeheu0HonW8cFEymi2v6nupnhFdaLGubc08T6y7jncuqbLDhtjkpfkHUjA2OlDQu4UlLW50wZ2nugAWQakeMF3Q3saeFtQVCvqa55FWezC1LIHMf/2BsY9M5V5HsN74Zr5ilrQw1JZH3b7oFMewjlSW9XcF3/u+WHCdv7ChyrxArqOyLOPq5ivXVb1SKPO6WtVWiSMHrt9k33NBA5hHey6zhg/Bns9mJisUZRxUKnJvYV63hx9idkk9F2zdeeTSirRrkuq1vwXPlr7RoV9dku8HLr8kGfw2N3XGxAja1WYYy6b8kZrnWJaBfanRX/rw/kvbu9pzTM/whqRGO4zXkgfPxqrJbHnlvNz3nbt3Vdl2QwT4GWSz9Uz2YNSh2gxy9huqecSFb5BW63ptXl2Re02NhtxzZJ7YuYxg39h+qkKGxiAva4ptx9FQfhumv+M403XLVsOMln+h+WCrGIKlsLGLK0EmSl/p7c13XTBPbHt4HrYrfKNmB7U39Y8nHkt8w0wIIYQQQsgMuGEmhBBCCCFkBo8vyYCsKn5m9tkodzglyZDX5pidZsHVIa9bz5+dHLf7uuz9B2K7dTSSEObQvE4fgTDCWral8H8DtMjzXCPJwExK3vTX9b6Rg4AjnFOE0EHZ06GmSk5+oOLpUEodmq4EFxI4OlQewnVliS4bDqeHqOeF9aLcaN9kr8s5EqbLjKVSuCT3FjUlNNzXiSGd5idi6xV2tZyiOqpPjuMAsldmesyliYSMmgc6XnUC2dMuXRQrsNFY90XjoYxbr3ugygqgx7l48UVVtrYpIfDmUEJZR0daTpFG0lZ+qNvx5qsXpCyRDGapo+3tBrG0qevo0Ko7Y/zPCylkBAuM9ZIDc6/b0/MiiUQy0OuKbMc3Y25p0Ycy3T4OyAwKYJu2Huo1sLwiUrRiRZ8/gQyquVTOl1vS91KG0GqQ0+cfD+RePJM9NAbpUudEbOBGkZZMoHQjZ64fl/d8Aa4x0NfY68N1eEa+cmJivnPISkXm3TjSbdDty9wuPa/t4s6BlOPaJVkPQvM+ygOLr8C4qAWglsEMla7JxpZz8dmlz6GfXSBdnCFpyIzcL8MEs5nJDAfn8SHDabmo+/qFG5K9cmTC4394+93J8WFbxoRnLcPU83V6htO5BaQLObOm4N9BoNeUwMe2nG7xh1aY1gYSpQuVqjzHUvOMwyy1jmOyKXpyflftkab3he1D1YOnxipkh4a+Pm0dhxlZjeWch1ZymPXP2spBO9p3xNbO8P/AN8yEEEIIIYTMgBtmQgghhBBCZsANMyGEEEIIITN4/DzKIWptTOpU1NcYfV0M6WpT+Dmrvd0AN7Sf3txUZWuBiOjuHIgtzUFP2x81Y7CfS7XeZQSXOHbltzPX2pigbY/R9cBxYPTT4DrklEHHnTfnz4NtWtXX+rEl0DeXQYON6S3/d11ybC2grH3WPLISiw3TaENbZB1ut+BY637jkmgkc9Hi5Njb0fdcaMDYMlpKJ5aUnOWrogutX9b96UdSzzlsqbL9u5LaO2mKJvjMxZqq58EYLI7OqrJGW3StQfJAldXXxKpufVlSdifDHVXv4Y5cR3FB2wkurcp8jYdynLPiyWO571HbpAO2eVvnkAhSusZmLgwgdXWvp7Xb+QC0cbkyHOvzZ2AROYqNvWMic3kciQ7a6kLzYFEYu1rLG4G1UzKS8416WmMc+WAVZbTaxw0R8S8vLaqyFNbm4z1JQz+MtJ5xZUNsDhOjI2x0mvAXaGhNY+3tglberI9JOv/rUhZLmw+NLV4Rvnd47oq2izu7JPOrCNpPz7e63Ol2bh70E1azulB81mamSVP8tgXqxYnRzYP+dZzoC+lBuuTuULfBAMZnkknfD8y8SCCl88bWU6qsvvTl5PhR5+Hk2LffEoFw3j2lM51/DbMLGnKbjjkMpX0KBT2Xc9B2qF+31nHYhzZ1eCkQLX4AYzA26d5d+IbKZohGHTDei9XUqz9tJnW0Gzb/DO3o1Bh37YVAPathdr+6zDPWdMrC0Xx/5z7hO2O+YSaEEEIIIWQG3DATQgghhBAyAzezfiWEEEIIIYSQCXzDTAghhBBCyAy4YSaEEEIIIWQG3DATQgghhBAyA26YCSGEEEIImQE3zIQQQgghhMyAG2ZCCCGEEEJmwA0zIYQQQgghM+CGmRBCCCGEkBlww0wIIYQQQsgM/gtInJyQ/u/Z2QAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Plot first 10 RGB images from the training dataset\n", "ncols = 5\n", "nrows = 2\n", "\n", "fig, axes = plt.subplots(nrows=nrows, ncols=ncols, figsize=(ncols*1.5, nrows*1.5))\n", "axes = axes.flatten()\n", "\n", "for i, ax in enumerate(axes):\n", " img, label = train_dataset_exp2[i]\n", " \n", " # Unnormalize and transpose for plotting\n", " img = img * 0.5 + 0.5\n", " img = img.numpy().transpose(1, 2, 0) # Change from CxHxW to HxWxC\n", " ax.set_title(class_names[label])\n", " ax.imshow(img)\n", " ax.axis('off')\n", "\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "da306112", "metadata": {}, "source": [ "### 2.3. Create data loaders for RGB" ] }, { "cell_type": "code", "execution_count": 12, "id": "0a11adc1", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "X_train shape: torch.Size([40000, 3, 32, 32])\n" ] } ], "source": [ "# Create training, validation and testing tensors\n", "X_train_full_exp2 = torch.stack([img for img, _ in train_dataset_exp2]).to(device)\n", "y_train_full_exp2 = torch.tensor([label for _, label in train_dataset_exp2]).to(device)\n", "\n", "X_test_exp2 = torch.stack([img for img, _ in test_dataset_exp2]).to(device)\n", "y_test_exp2 = torch.tensor([label for _, label in test_dataset_exp2]).to(device)\n", "\n", "# Split training data\n", "n_train = int(0.8 * len(X_train_full_exp2))\n", "indices = torch.randperm(len(X_train_full_exp2))\n", "\n", "X_train_exp2 = X_train_full_exp2[indices[:n_train]]\n", "y_train_exp2 = y_train_full_exp2[indices[:n_train]]\n", "X_val_exp2 = X_train_full_exp2[indices[n_train:]]\n", "y_val_exp2 = y_train_full_exp2[indices[n_train:]]\n", "\n", "# Create DataLoaders\n", "train_tensor_dataset_exp2 = torch.utils.data.TensorDataset(X_train_exp2, y_train_exp2)\n", "val_tensor_dataset_exp2 = torch.utils.data.TensorDataset(X_val_exp2, y_val_exp2)\n", "test_tensor_dataset_exp2 = torch.utils.data.TensorDataset(X_test_exp2, y_test_exp2)\n", "\n", "train_loader_exp2 = DataLoader(train_tensor_dataset_exp2, batch_size=batch_size, shuffle=True)\n", "val_loader_exp2 = DataLoader(val_tensor_dataset_exp2, batch_size=batch_size, shuffle=False)\n", "test_loader_exp2 = DataLoader(test_tensor_dataset_exp2, batch_size=batch_size, shuffle=False)\n", "\n", "print(f'X_train shape: {X_train_exp2.shape}') # Should show 3 channels" ] }, { "cell_type": "markdown", "id": "ee7a5f59", "metadata": {}, "source": [ "### 2.4. Define CNN for RGB images\n", "\n", "**TODO**: Modify the first Conv2d layer to accept 3 input channels instead of 1." ] }, { "cell_type": "code", "execution_count": 13, "id": "aadebd5e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Sequential(\n", " (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (2): ReLU()\n", " (3): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (4): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (5): ReLU()\n", " (6): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", " (7): Dropout(p=0.5, inplace=False)\n", " (8): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (9): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (10): ReLU()\n", " (11): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", " (12): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (13): ReLU()\n", " (14): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", " (15): Dropout(p=0.5, inplace=False)\n", " (16): Flatten(start_dim=1, end_dim=-1)\n", " (17): Linear(in_features=8192, out_features=256, bias=True)\n", " (18): ReLU()\n", " (19): Dropout(p=0.5, inplace=False)\n", " (20): Linear(in_features=256, out_features=10, bias=True)\n", ")\n", "\n", "Total parameters: 2360906\n" ] } ], "source": [ "# Updated first conv layer to accept 3 channels (RGB)\n", "model_exp2 = nn.Sequential(\n", "\n", " # Conv block: RGB input (3 channels -> 64 feature maps)\n", " nn.Conv2d(3, 64, kernel_size=3, padding=1),\n", " nn.BatchNorm2d(64),\n", " nn.ReLU(),\n", " nn.Conv2d(64, 64, kernel_size=3, padding=1),\n", " nn.BatchNorm2d(64),\n", " nn.ReLU(),\n", " nn.MaxPool2d(2, 2),\n", " nn.Dropout(0.5),\n", "\n", " # Conv block: 64 feature maps -> 128 feature maps\n", " nn.Conv2d(64, 128, kernel_size=3, padding=1),\n", " nn.BatchNorm2d(128),\n", " nn.ReLU(),\n", " nn.Conv2d(128, 128, kernel_size=3, padding=1),\n", " nn.BatchNorm2d(128),\n", " nn.ReLU(),\n", " nn.MaxPool2d(2, 2),\n", " nn.Dropout(0.5),\n", " \n", " # Classifier\n", " nn.Flatten(),\n", " nn.Linear(128 * 8 * 8, 256),\n", " nn.ReLU(),\n", " nn.Dropout(0.5),\n", " nn.Linear(256, num_classes)\n", "\n", ").to(device)\n", "\n", "trainable_params = sum(p.numel() for p in model_exp2.parameters() if p.requires_grad)\n", "print(model_exp2)\n", "print(f'\\nTotal parameters: {trainable_params}')" ] }, { "cell_type": "markdown", "id": "6c4f01b3", "metadata": {}, "source": [ "### 2.5. Train RGB model" ] }, { "cell_type": "code", "execution_count": 14, "id": "d6104f3f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch 1/30 - loss: 2.2982 - accuracy: 21.84% - val_loss: 1.9132 - val_accuracy: 28.58%\n", "Epoch 5/30 - loss: 1.4719 - accuracy: 43.82% - val_loss: 1.3099 - val_accuracy: 55.70%\n", "Epoch 10/30 - loss: 1.2325 - accuracy: 54.02% - val_loss: 1.0230 - val_accuracy: 64.59%\n", "Epoch 15/30 - loss: 1.1008 - accuracy: 59.33% - val_loss: 0.8796 - val_accuracy: 68.92%\n", "Epoch 20/30 - loss: 1.0253 - accuracy: 62.22% - val_loss: 0.7482 - val_accuracy: 73.71%\n", "Epoch 25/30 - loss: 0.9649 - accuracy: 64.52% - val_loss: 0.7611 - val_accuracy: 73.59%\n", "Epoch 30/30 - loss: 0.9145 - accuracy: 66.46% - val_loss: 0.7192 - val_accuracy: 75.38%\n", "\n", "Training complete.\n", "CPU times: user 3min 44s, sys: 398 ms, total: 3min 45s\n", "Wall time: 3min 44s\n" ] } ], "source": [ "%%time\n", "\n", "criterion_exp2 = nn.CrossEntropyLoss()\n", "optimizer_exp2 = optim.Adam(model_exp2.parameters(), lr=learning_rate)\n", "\n", "history_exp2 = train_model(\n", " model=model_exp2,\n", " train_loader=train_loader_exp2,\n", " val_loader=val_loader_exp2,\n", " criterion=criterion_exp2,\n", " optimizer=optimizer_exp2,\n", " epochs=epochs,\n", " print_every=print_every\n", ")" ] }, { "cell_type": "markdown", "id": "e8ea58e7", "metadata": {}, "source": [ "### 2.6. Evaluate RGB model" ] }, { "cell_type": "code", "execution_count": 15, "id": "5ed85bed", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "Experiment 2 Test Accuracy: 75.19%\n" ] } ], "source": [ "# Learning curves\n", "fig, axes = plt.subplots(1, 2, figsize=(10, 4))\n", "\n", "axes[0].set_title('Loss - Experiment 2 (RGB)')\n", "axes[0].plot(history_exp2['train_loss'], label='Train')\n", "axes[0].plot(history_exp2['val_loss'], label='Validation')\n", "axes[0].set_xlabel('Epoch')\n", "axes[0].set_ylabel('Loss (cross-entropy)')\n", "axes[0].legend(loc='best')\n", "\n", "axes[1].set_title('Accuracy - Experiment 2 (RGB)')\n", "axes[1].plot(history_exp2['train_accuracy'], label='Train')\n", "axes[1].plot(history_exp2['val_accuracy'], label='Validation')\n", "axes[1].set_xlabel('Epoch')\n", "axes[1].set_ylabel('Accuracy (%)')\n", "axes[1].legend(loc='best')\n", "\n", "plt.tight_layout()\n", "plt.show()\n", "\n", "# Test accuracy\n", "test_accuracy_exp2, predictions_exp2, true_labels_exp2 = evaluate_model(model_exp2, test_loader_exp2)\n", "print(f'\\nExperiment 2 Test Accuracy: {test_accuracy_exp2:.2f}%')" ] }, { "cell_type": "markdown", "id": "629a099e", "metadata": {}, "source": [ "### 2.7. Experiment 2 observations\n", "\n", "**TODO**: Document your findings:\n", "- Did RGB improve accuracy compared to grayscale?\n", "- How did the number of parameters change?\n", "- Which classes benefited most from color information?\n", "- Were there any classes that performed similarly with both grayscale and RGB?\n", "\n", "*Your notes here:*\n", "\n" ] }, { "cell_type": "markdown", "id": "ed2ee0bd", "metadata": {}, "source": [ "---\n", "\n", "## Experiment 3: Add image augmentation\n", "\n", "**Objective**: Use PyTorch transforms to augment training data and improve model generalization.\n", "\n", "### 3.1. Define augmented transforms\n", "\n", "**TODO**: Add image augmentation transforms to the training data. Consider:\n", "- `transforms.RandomHorizontalFlip(p=0.5)` - Randomly flip images horizontally\n", "- `transforms.RandomCrop(32, padding=4)` - Random crop with padding\n", "- `transforms.RandomRotation(degrees=15)` - Small random rotations\n", "- `transforms.ColorJitter(brightness=0.2, contrast=0.2)` - Random brightness/contrast adjustments\n", "\n", "**Note**: Apply augmentation only to training data, not validation or test data!" ] }, { "cell_type": "code", "execution_count": 16, "id": "1f4575d0", "metadata": {}, "outputs": [], "source": [ "batch_size = 64\n", "learning_rate = 5e-4\n", "epochs = 100" ] }, { "cell_type": "code", "execution_count": 17, "id": "26c96439", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Files already downloaded and verified\n", "Files already downloaded and verified\n", "Datasets loaded with augmentation\n" ] } ], "source": [ "# Training transform with augmentation\n", "transform_train_exp3 = transforms.Compose([\n", " transforms.RandomHorizontalFlip(p=0.5),\n", " transforms.RandomCrop(32, padding=4),\n", " transforms.RandomRotation(degrees=15),\n", " transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),\n", " transforms.ToTensor(),\n", " transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n", "])\n", "\n", "# Validation and test transforms (no augmentation)\n", "transform_test_exp3 = transforms.Compose([\n", " transforms.ToTensor(),\n", " transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n", "])\n", "\n", "# Load datasets with augmentation\n", "train_dataset_exp3 = datasets.CIFAR10(\n", " root=data_dir,\n", " train=True,\n", " download=True,\n", " transform=transform_train_exp3 # Augmented transform\n", ")\n", "\n", "test_dataset_exp3 = datasets.CIFAR10(\n", " root=data_dir,\n", " train=False,\n", " download=True,\n", " transform=transform_test_exp3 # No augmentation\n", ")\n", "\n", "print('Datasets loaded with augmentation')" ] }, { "cell_type": "markdown", "id": "ce43da7e", "metadata": {}, "source": [ "### 3.2. Visualize augmented images\n", "\n", "Run this cell multiple times to see different augmentations of the same images!" ] }, { "cell_type": "code", "execution_count": 18, "id": "cafa7a78", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Visualize augmented versions of the same images\n", "ncols = 5\n", "nrows = 2\n", "\n", "fig, axes = plt.subplots(nrows=nrows, ncols=ncols, figsize=(ncols*1.5, nrows*1.5))\n", "axes = axes.flatten()\n", "\n", "for i, ax in enumerate(axes):\n", " # Get augmented version each time this is run\n", " img, label = train_dataset_exp3[i]\n", " \n", " # Unnormalize and transpose for plotting\n", " img = img * 0.5 + 0.5\n", " img = img.numpy().transpose(1, 2, 0)\n", " ax.set_title(class_names[label])\n", " ax.imshow(img)\n", " ax.axis('off')\n", "\n", "plt.suptitle('Augmented Training Images (run cell again to see different augmentations)', y=1.02)\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "ba0683e5", "metadata": {}, "source": [ "### 3.3. Create data loaders with augmentation" ] }, { "cell_type": "code", "execution_count": 19, "id": "842ee568", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Training samples: 40000\n", "Validation samples: 10000\n", "Test samples: 10000\n" ] } ], "source": [ "# For data augmentation, we must NOT preload data to GPU as tensors.\n", "# Transforms need to be applied on-the-fly during each epoch so each \n", "# batch sees different augmented versions of the images.\n", "\n", "# Split training data into train and validation sets using Subset\n", "n_train = int(0.8 * len(train_dataset_exp3))\n", "n_val = len(train_dataset_exp3) - n_train\n", "indices = torch.randperm(len(train_dataset_exp3)).tolist()\n", "\n", "train_subset_exp3 = torch.utils.data.Subset(train_dataset_exp3, indices[:n_train])\n", "val_subset_exp3 = torch.utils.data.Subset(train_dataset_exp3, indices[n_train:])\n", "\n", "print(f'Training samples: {len(train_subset_exp3)}')\n", "print(f'Validation samples: {len(val_subset_exp3)}')\n", "print(f'Test samples: {len(test_dataset_exp3)}')" ] }, { "cell_type": "code", "execution_count": 20, "id": "70daf63e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Training batches: 625\n", "Validation batches: 157\n", "Test batches: 157\n" ] } ], "source": [ "# Create DataLoaders directly from Dataset/Subset objects\n", "# Transforms are applied on-the-fly when batches are loaded\n", "train_loader_exp3 = DataLoader(\n", " train_subset_exp3,\n", " batch_size=batch_size,\n", " shuffle=True\n", ")\n", "\n", "val_loader_exp3 = DataLoader(\n", " val_subset_exp3,\n", " batch_size=batch_size,\n", " shuffle=False\n", ")\n", "\n", "test_loader_exp3 = DataLoader(\n", " test_dataset_exp3,\n", " batch_size=batch_size,\n", " shuffle=False\n", ")\n", "\n", "print(f'Training batches: {len(train_loader_exp3)}')\n", "print(f'Validation batches: {len(val_loader_exp3)}')\n", "print(f'Test batches: {len(test_loader_exp3)}')" ] }, { "cell_type": "markdown", "id": "ed1a28d8", "metadata": {}, "source": [ "### 3.4. Define model for augmented data" ] }, { "cell_type": "code", "execution_count": 21, "id": "ac5365b2", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Total parameters: 2360906\n" ] } ], "source": [ "# Same architecture as Experiment 2 (RGB)\n", "model_exp3 = nn.Sequential(\n", "\n", " # Conv block: RGB input (3 channels -> 64 feature maps)\n", " nn.Conv2d(3, 64, kernel_size=3, padding=1),\n", " nn.BatchNorm2d(64),\n", " nn.ReLU(),\n", " nn.Conv2d(64, 64, kernel_size=3, padding=1),\n", " nn.BatchNorm2d(64),\n", " nn.ReLU(),\n", " nn.MaxPool2d(2, 2),\n", " nn.Dropout(0.5),\n", "\n", " # Conv block: 64 feature maps -> 128 feature maps\n", " nn.Conv2d(64, 128, kernel_size=3, padding=1),\n", " nn.BatchNorm2d(128),\n", " nn.ReLU(),\n", " nn.Conv2d(128, 128, kernel_size=3, padding=1),\n", " nn.BatchNorm2d(128),\n", " nn.ReLU(),\n", " nn.MaxPool2d(2, 2),\n", " nn.Dropout(0.5),\n", " \n", " # Classifier\n", " nn.Flatten(),\n", " nn.Linear(128 * 8 * 8, 256),\n", " nn.ReLU(),\n", " nn.Dropout(0.5),\n", " nn.Linear(256, num_classes)\n", "\n", ").to(device)\n", "\n", "trainable_params = sum(p.numel() for p in model_exp3.parameters() if p.requires_grad)\n", "print(f'Total parameters: {trainable_params}')" ] }, { "cell_type": "markdown", "id": "b46d131b", "metadata": {}, "source": [ "### 3.5. Train model with augmented data" ] }, { "cell_type": "code", "execution_count": 22, "id": "00a6fc79", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch 1/100 - loss: 1.8807 - accuracy: 29.45% - val_loss: 1.5897 - val_accuracy: 41.87%\n", "Epoch 5/100 - loss: 1.4239 - accuracy: 48.00% - val_loss: 1.2206 - val_accuracy: 55.29%\n", "Epoch 10/100 - loss: 1.2601 - accuracy: 54.43% - val_loss: 1.0360 - val_accuracy: 62.20%\n", "Epoch 15/100 - loss: 1.1801 - accuracy: 57.80% - val_loss: 0.9678 - val_accuracy: 65.23%\n", "Epoch 20/100 - loss: 1.1125 - accuracy: 60.50% - val_loss: 0.8887 - val_accuracy: 68.10%\n", "Epoch 25/100 - loss: 1.0655 - accuracy: 62.09% - val_loss: 0.8628 - val_accuracy: 68.88%\n", "Epoch 30/100 - loss: 1.0233 - accuracy: 63.74% - val_loss: 0.7863 - val_accuracy: 71.69%\n", "Epoch 35/100 - loss: 0.9601 - accuracy: 66.22% - val_loss: 0.7415 - val_accuracy: 73.64%\n", "Epoch 40/100 - loss: 0.9114 - accuracy: 68.36% - val_loss: 0.7491 - val_accuracy: 74.20%\n", "Epoch 45/100 - loss: 0.8582 - accuracy: 70.48% - val_loss: 0.6792 - val_accuracy: 75.88%\n", "Epoch 50/100 - loss: 0.8231 - accuracy: 72.14% - val_loss: 0.6483 - val_accuracy: 77.44%\n", "Epoch 55/100 - loss: 0.7814 - accuracy: 73.44% - val_loss: 0.6380 - val_accuracy: 77.91%\n", "Epoch 60/100 - loss: 0.7478 - accuracy: 74.58% - val_loss: 0.6242 - val_accuracy: 78.58%\n", "Epoch 65/100 - loss: 0.7291 - accuracy: 75.31% - val_loss: 0.6186 - val_accuracy: 78.77%\n", "Epoch 70/100 - loss: 0.6996 - accuracy: 76.12% - val_loss: 0.5978 - val_accuracy: 79.33%\n", "Epoch 75/100 - loss: 0.6818 - accuracy: 76.70% - val_loss: 0.5770 - val_accuracy: 80.02%\n", "Epoch 80/100 - loss: 0.6677 - accuracy: 76.98% - val_loss: 0.5658 - val_accuracy: 80.59%\n", "Epoch 85/100 - loss: 0.6526 - accuracy: 77.73% - val_loss: 0.5533 - val_accuracy: 80.97%\n", "Epoch 90/100 - loss: 0.6343 - accuracy: 78.44% - val_loss: 0.5543 - val_accuracy: 81.22%\n", "Epoch 95/100 - loss: 0.6292 - accuracy: 78.58% - val_loss: 0.5282 - val_accuracy: 82.16%\n", "Epoch 100/100 - loss: 0.6121 - accuracy: 79.21% - val_loss: 0.5336 - val_accuracy: 82.20%\n", "\n", "Training complete.\n", "CPU times: user 2h 59min 4s, sys: 11.9 s, total: 2h 59min 15s\n", "Wall time: 2h 59min 38s\n" ] } ], "source": [ "%%time\n", "\n", "criterion_exp3 = nn.CrossEntropyLoss()\n", "optimizer_exp3 = optim.Adam(model_exp3.parameters(), lr=learning_rate)\n", "\n", "# Pass device to move batches on-the-fly (required for on-the-fly augmentation)\n", "history_exp3 = train_model(\n", " model=model_exp3,\n", " train_loader=train_loader_exp3,\n", " val_loader=val_loader_exp3,\n", " criterion=criterion_exp3,\n", " optimizer=optimizer_exp3,\n", " epochs=epochs,\n", " print_every=print_every,\n", " device=device\n", ")" ] }, { "cell_type": "markdown", "id": "85ad8659", "metadata": {}, "source": [ "### 3.6. Evaluate augmented model" ] }, { "cell_type": "code", "execution_count": 23, "id": "bc7e3481", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "Experiment 3 Test Accuracy: 85.06%\n" ] } ], "source": [ "# Learning curves\n", "fig, axes = plt.subplots(1, 2, figsize=(10, 4))\n", "\n", "axes[0].set_title('Loss - Experiment 3 (Augmented)')\n", "axes[0].plot(history_exp3['train_loss'], label='Train')\n", "axes[0].plot(history_exp3['val_loss'], label='Validation')\n", "axes[0].set_xlabel('Epoch')\n", "axes[0].set_ylabel('Loss (cross-entropy)')\n", "axes[0].legend(loc='best')\n", "\n", "axes[1].set_title('Accuracy - Experiment 3 (Augmented)')\n", "axes[1].plot(history_exp3['train_accuracy'], label='Train')\n", "axes[1].plot(history_exp3['val_accuracy'], label='Validation')\n", "axes[1].set_xlabel('Epoch')\n", "axes[1].set_ylabel('Accuracy (%)')\n", "axes[1].legend(loc='best')\n", "\n", "plt.tight_layout()\n", "plt.show()\n", "\n", "# Test accuracy (pass device for on-the-fly batch loading)\n", "test_accuracy_exp3, predictions_exp3, true_labels_exp3 = evaluate_model(\n", " model_exp3, test_loader_exp3, device=device\n", ")\n", "print(f'\\nExperiment 3 Test Accuracy: {test_accuracy_exp3:.2f}%')" ] }, { "cell_type": "markdown", "id": "bcbd1142", "metadata": {}, "source": [ "### 3.7. Experiment 3 observations\n", "\n", "**TODO**: Document your findings:\n", "- Which augmentation techniques did you use?\n", "- Did augmentation improve test accuracy?\n", "- Did you notice any effect on the gap between training and validation accuracy (overfitting)?\n", "- How did training time compare to non-augmented training?\n", "- Would you recommend augmentation for this dataset?\n", "\n", "*Your notes here:*\n", "\n" ] } ], "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 }