notebooks/vision_swin_s_training.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fae6a100"
      },
      "outputs": [],
      "source": [
        "# Consolidated Imports\n",
        "import os\n",
        "import random\n",
        "import pandas as pd\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torch.utils.data import Dataset, DataLoader, random_split, WeightedRandomSampler\n",
        "from torchvision import transforms, models\n",
        "from PIL import Image\n",
        "import numpy as np\n",
        "from sklearn.metrics import accuracy_score, precision_recall_fscore_support, confusion_matrix\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "import kagglehub\n",
        "from google.colab import drive"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5b9b52f0",
        "outputId": "aa4e422c-cdb3-4e47-a6c7-f6521b14032e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Mounted at /content/drive\n",
            "Dataset downloaded to: /kaggle/input/fer2013\n",
            "Train size after filtering: 28709, Test size after filtering: 7178\n",
            "Train class distribution:\n",
            " sentiment\n",
            "0    13358\n",
            "2    10386\n",
            "1     4965\n",
            "Name: count, dtype: int64\n",
            "Test class distribution:\n",
            " sentiment\n",
            "0    3340\n",
            "2    2605\n",
            "1    1233\n",
            "Name: count, dtype: int64\n"
          ]
        }
      ],
      "source": [
        "# Consolidated Setup and Data Loading\n",
        "\n",
        "# Mount Google Drive\n",
        "drive.mount('/content/drive')\n",
        "\n",
        "# Set random seed\n",
        "random.seed(42)\n",
        "np.random.seed(42)\n",
        "torch.manual_seed(42)\n",
        "\n",
        "# Download FER2013\n",
        "dataset_path = kagglehub.dataset_download('msambare/fer2013')\n",
        "print(f\"Dataset downloaded to: {dataset_path}\")\n",
        "\n",
        "# Paths\n",
        "TRAIN_DIR = os.path.join(dataset_path, 'train')\n",
        "TEST_DIR = os.path.join(dataset_path, 'test')\n",
        "\n",
        "# Load data\n",
        "emotion_map = {0: 0, 1: 0, 2: 0, 3: 2, 4: 0, 5: 2, 6: 1}  # neg=0, neu=1, pos=2\n",
        "emotion_folders = ['angry', 'disgust', 'fear', 'happy', 'sad', 'surprise', 'neutral']\n",
        "\n",
        "def load_data(data_dir, split='train'):\n",
        "    data = []\n",
        "    for emotion_idx, emotion in enumerate(emotion_folders):\n",
        "        folder = os.path.join(data_dir, emotion)\n",
        "        if os.path.exists(folder):\n",
        "            for img_name in os.listdir(folder):\n",
        "                img_path = os.path.join(folder, img_name)\n",
        "                if os.path.isfile(img_path):\n",
        "                    data.append({'image_path': img_path, 'sentiment': emotion_map[emotion_idx], 'usage': split})\n",
        "        else:\n",
        "            print(f\"Warning: Folder {folder} not found.\")\n",
        "    return pd.DataFrame(data)\n",
        "\n",
        "# Filter valid images\n",
        "def filter_valid_images(df):\n",
        "    valid_rows = []\n",
        "    for idx, row in df.iterrows():\n",
        "        try:\n",
        "            img = Image.open(row['image_path']).convert('RGB')\n",
        "            valid_rows.append(row)\n",
        "        except:\n",
        "            continue\n",
        "    return pd.DataFrame(valid_rows)\n",
        "\n",
        "train_df = load_data(TRAIN_DIR, 'train')\n",
        "test_df = load_data(TEST_DIR, 'test')\n",
        "train_df = filter_valid_images(train_df)\n",
        "test_df = filter_valid_images(test_df)\n",
        "\n",
        "print(f\"Train size after filtering: {len(train_df)}, Test size after filtering: {len(test_df)}\")\n",
        "print(\"Train class distribution:\\n\", train_df['sentiment'].value_counts())\n",
        "print(\"Test class distribution:\\n\", test_df['sentiment'].value_counts())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6dbddd60"
      },
      "outputs": [],
      "source": [
        "# Consolidated Dataset and DataLoader\n",
        "\n",
        "# Custom Dataset\n",
        "class SentimentDataset(Dataset):\n",
        "    def __init__(self, df, transform=None):\n",
        "        self.df = df\n",
        "        self.transform = transform\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.df)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        img_path = self.df.iloc[idx]['image_path']\n",
        "        label = self.df.iloc[idx]['sentiment']\n",
        "        image = Image.open(img_path).convert('RGB')\n",
        "        if self.transform:\n",
        "            image = self.transform(image)\n",
        "        return image, label\n",
        "\n",
        "# Transforms\n",
        "train_transform = transforms.Compose([\n",
        "    transforms.Resize(224),\n",
        "    transforms.RandomCrop(224, padding=4),\n",
        "    transforms.RandomHorizontalFlip(),\n",
        "    transforms.RandAugment(num_ops=2, magnitude=9),\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),\n",
        "    transforms.RandomErasing(p=0.5, scale=(0.02, 0.2)),\n",
        "])\n",
        "val_test_transform = transforms.Compose([\n",
        "    transforms.Resize(224),\n",
        "    transforms.CenterCrop(224),\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),\n",
        "])\n",
        "\n",
        "# Datasets\n",
        "train_dataset = SentimentDataset(train_df, transform=train_transform)\n",
        "test_dataset = SentimentDataset(test_df, transform=val_test_transform)\n",
        "\n",
        "# Split train into train/val\n",
        "train_size = int(0.8 * len(train_dataset))\n",
        "val_size = len(train_dataset) - train_size\n",
        "train_subset, val_subset = random_split(train_dataset, [train_size, val_size])\n",
        "\n",
        "# Create sampler for train_subset\n",
        "train_indices = train_subset.indices\n",
        "train_sentiments = [train_dataset.df.iloc[idx]['sentiment'] for idx in train_indices]\n",
        "train_class_counts = pd.Series(train_sentiments).value_counts().sort_index()\n",
        "train_class_weights = 1.0 / np.array([train_class_counts[i] for i in range(3)])\n",
        "train_weights = [train_class_weights[label] for label in train_sentiments]\n",
        "sampler = WeightedRandomSampler(train_weights, len(train_weights), replacement=True)\n",
        "\n",
        "# DataLoaders\n",
        "batch_size = 16  # Reduced for Colab Free\n",
        "train_loader = DataLoader(train_subset, batch_size=batch_size, sampler=sampler, num_workers=2, pin_memory=True)\n",
        "val_loader = DataLoader(val_subset, batch_size=batch_size, shuffle=False, num_workers=2, pin_memory=True)\n",
        "test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, num_workers=2, pin_memory=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bbea6c2f"
      },
      "outputs": [],
      "source": [
        "# Consolidated Training and Validation Functions\n",
        "\n",
        "# Training function with gradient accumulation\n",
        "def train_epoch(model, loader, criterion, optimizer, device, scaler, accum_steps=2):\n",
        "    model.train()\n",
        "    running_loss = 0.0\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    optimizer.zero_grad()\n",
        "    for i, (images, labels) in enumerate(loader):\n",
        "        images, labels = images.to(device), labels.to(device)\n",
        "        with torch.amp.autocast(device_type='cuda'):\n",
        "            outputs = model(images)\n",
        "            loss = criterion(outputs, labels) / accum_steps\n",
        "        scaler.scale(loss).backward()\n",
        "        if (i + 1) % accum_steps == 0:\n",
        "            scaler.unscale_(optimizer)\n",
        "            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)\n",
        "            scaler.step(optimizer)\n",
        "            scaler.update()\n",
        "            optimizer.zero_grad()\n",
        "        running_loss += loss.item() * accum_steps\n",
        "        _, predicted = outputs.max(1)\n",
        "        total += labels.size(0)\n",
        "        correct += predicted.eq(labels).sum().item()\n",
        "        del images, labels, outputs\n",
        "        torch.cuda.empty_cache()\n",
        "    return running_loss / len(loader), correct / total\n",
        "\n",
        "# Validation function\n",
        "def validate_epoch(model, loader, criterion, device):\n",
        "    model.eval()\n",
        "    running_loss = 0.0\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    with torch.no_grad():\n",
        "        with torch.amp.autocast(device_type='cuda'):\n",
        "            for images, labels in loader:\n",
        "                images, labels = images.to(device), labels.to(device)\n",
        "                outputs = model(images)\n",
        "                loss = criterion(outputs, labels)\n",
        "                running_loss += loss.item()\n",
        "                _, predicted = outputs.max(1)\n",
        "                total += labels.size(0)\n",
        "                correct += predicted.eq(labels).sum().item()\n",
        "                del images, labels, outputs\n",
        "                torch.cuda.empty_cache()\n",
        "    return running_loss / len(loader), correct / total"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a1f745b5"
      },
      "source": [
        "### Swin-S Model Configuration\n",
        "\n",
        "Run the cell below to configure the notebook for training the Swin-S model."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2037a9c9"
      },
      "outputs": [],
      "source": [
        "# Swin-S Model Definition and Configuration\n",
        "\n",
        "# Define the base directory for saving models\n",
        "BASE_SAVE_DIR = '/content/drive/MyDrive/Models/Vision'\n",
        "os.makedirs(BASE_SAVE_DIR, exist_ok=True) # Create directories if they don't exist\n",
        "\n",
        "CHECKPOINT_PATH = os.path.join(BASE_SAVE_DIR, 'swin_s_fer2013_sentiment.pth')\n",
        "\n",
        "# Model: Swin-S\n",
        "model = models.swin_s(weights=models.Swin_S_Weights.IMAGENET1K_V1)\n",
        "model.head = nn.Sequential(\n",
        "    nn.Dropout(0.5),\n",
        "    nn.Linear(model.head.in_features, 3)\n",
        ")\n",
        "\n",
        "# Freeze early layers\n",
        "for name, param in model.named_parameters():\n",
        "    if 'layers.0' in name or 'layers.1' in name:\n",
        "        param.requires_grad = False\n",
        "\n",
        "# Device\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "model.to(device)\n",
        "\n",
        "# Class weights for loss (using overall train_df)\n",
        "class_weights = torch.tensor(1.0 / np.array([train_class_counts[i] for i in range(3)]), dtype=torch.float).to(device)\n",
        "class_weights = class_weights / class_weights.sum() * 3.0\n",
        "\n",
        "# Loss and optimizer\n",
        "criterion = nn.CrossEntropyLoss(weight=class_weights, label_smoothing=0.1)\n",
        "optimizer = optim.AdamW(filter(lambda p: p.requires_grad, model.parameters()), lr=3e-5, weight_decay=0.05)\n",
        "scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=30)\n",
        "\n",
        "# Warmup scheduler\n",
        "class WarmupScheduler:\n",
        "    def __init__(self, optimizer, warmup_epochs, base_lr):\n",
        "        self.optimizer = optimizer\n",
        "        self.warmup_epochs = warmup_epochs\n",
        "        self.base_lr = base_lr\n",
        "        self.current_epoch = 0\n",
        "\n",
        "    def step(self, epoch):\n",
        "        self.current_epoch = epoch\n",
        "        if epoch < self.warmup_epochs:\n",
        "            lr = self.base_lr * (epoch + 1) / self.warmup_epochs\n",
        "            for param_group in self.optimizer.param_groups:\n",
        "                param_group['lr'] = lr\n",
        "\n",
        "# Mixed precision\n",
        "scaler = torch.amp.GradScaler()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5039fe83"
      },
      "source": [
        "### Training Loop\n",
        "\n",
        "Run the cell below after configuring either the Swin-S or ResNet-50 model."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aa8f8dd3",
        "outputId": "f5d8cb53-2889-4f8b-b6ba-0f46f38a9cd4"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch 1/30 - Train Loss: 1.0163, Acc: 0.3335 | Val Loss: 1.1615, Acc: 0.1649\n",
            "Epoch 2/30 - Train Loss: 0.9440, Acc: 0.3875 | Val Loss: 1.0480, Acc: 0.3617\n",
            "Epoch 3/30 - Train Loss: 0.8386, Acc: 0.5285 | Val Loss: 0.9682, Acc: 0.4594\n",
            "Epoch 4/30 - Train Loss: 0.7730, Acc: 0.6085 | Val Loss: 0.9122, Acc: 0.5394\n",
            "Epoch 5/30 - Train Loss: 0.7185, Acc: 0.6616 | Val Loss: 0.8513, Acc: 0.6075\n",
            "Epoch 6/30 - Train Loss: 0.6835, Acc: 0.6937 | Val Loss: 0.8378, Acc: 0.6289\n",
            "Epoch 7/30 - Train Loss: 0.6551, Acc: 0.7244 | Val Loss: 0.8159, Acc: 0.6346\n",
            "Epoch 8/30 - Train Loss: 0.6192, Acc: 0.7517 | Val Loss: 0.7672, Acc: 0.6952\n",
            "Epoch 9/30 - Train Loss: 0.5918, Acc: 0.7759 | Val Loss: 0.7731, Acc: 0.7065\n",
            "Epoch 10/30 - Train Loss: 0.5689, Acc: 0.7954 | Val Loss: 0.7863, Acc: 0.6991\n",
            "Epoch 11/30 - Train Loss: 0.5488, Acc: 0.8064 | Val Loss: 0.7654, Acc: 0.7339\n",
            "Epoch 12/30 - Train Loss: 0.5374, Acc: 0.8207 | Val Loss: 0.7737, Acc: 0.7276\n",
            "Epoch 13/30 - Train Loss: 0.5151, Acc: 0.8350 | Val Loss: 0.7707, Acc: 0.7278\n",
            "Epoch 14/30 - Train Loss: 0.4988, Acc: 0.8516 | Val Loss: 0.7740, Acc: 0.7483\n",
            "Epoch 15/30 - Train Loss: 0.4856, Acc: 0.8550 | Val Loss: 0.7592, Acc: 0.7623\n",
            "Epoch 16/30 - Train Loss: 0.4682, Acc: 0.8698 | Val Loss: 0.7725, Acc: 0.7428\n",
            "Epoch 17/30 - Train Loss: 0.4663, Acc: 0.8701 | Val Loss: 0.7889, Acc: 0.7423\n",
            "Epoch 18/30 - Train Loss: 0.4538, Acc: 0.8815 | Val Loss: 0.7706, Acc: 0.7679\n",
            "Epoch 19/30 - Train Loss: 0.4462, Acc: 0.8875 | Val Loss: 0.7534, Acc: 0.7677\n",
            "Epoch 20/30 - Train Loss: 0.4445, Acc: 0.8910 | Val Loss: 0.7630, Acc: 0.7732\n",
            "Epoch 21/30 - Train Loss: 0.4335, Acc: 0.8956 | Val Loss: 0.7774, Acc: 0.7807\n",
            "Epoch 22/30 - Train Loss: 0.4269, Acc: 0.8995 | Val Loss: 0.7648, Acc: 0.7790\n",
            "Epoch 23/30 - Train Loss: 0.4228, Acc: 0.9029 | Val Loss: 0.7731, Acc: 0.7736\n",
            "Epoch 24/30 - Train Loss: 0.4197, Acc: 0.9059 | Val Loss: 0.7672, Acc: 0.7757\n",
            "Early stopping at epoch 24\n"
          ]
        }
      ],
      "source": [
        "# Consolidated Training Loop with Early Stopping\n",
        "num_epochs = 30\n",
        "warmup_scheduler = WarmupScheduler(optimizer, warmup_epochs=7, base_lr=3e-5)\n",
        "best_val_loss = float('inf')\n",
        "patience = 5\n",
        "counter = 0\n",
        "train_losses, val_losses = [], []\n",
        "train_accs, val_accs = [], []\n",
        "\n",
        "for epoch in range(num_epochs):\n",
        "    # The model-specific unfreezing logic from the original cells is removed\n",
        "    # as it might differ and is now managed within the model configuration cells.\n",
        "    # If needed, add model-specific unfreezing logic back into the respective\n",
        "    # model configuration cells or handle it within the training loop based on a flag.\n",
        "\n",
        "    warmup_scheduler.step(epoch)\n",
        "    train_loss, train_acc = train_epoch(model, train_loader, criterion, optimizer, device, scaler, accum_steps=2)\n",
        "    val_loss, val_acc = validate_epoch(model, val_loader, criterion, device)\n",
        "    scheduler.step()\n",
        "    train_losses.append(train_loss)\n",
        "    val_losses.append(val_loss)\n",
        "    train_accs.append(train_acc)\n",
        "    val_accs.append(val_acc)\n",
        "    print(f\"Epoch {epoch+1}/{num_epochs} - Train Loss: {train_loss:.4f}, Acc: {train_acc:.4f} | Val Loss: {val_loss:.4f}, Acc: {val_acc:.4f}\")\n",
        "    if val_loss < best_val_loss:\n",
        "        best_val_loss = val_loss\n",
        "        torch.save(model.state_dict(), CHECKPOINT_PATH)\n",
        "        counter = 0\n",
        "    else:\n",
        "        counter += 1\n",
        "        if counter >= patience:\n",
        "            print(f\"Early stopping at epoch {epoch+1}\")\n",
        "            break"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ba7e7cb3",
        "outputId": "ebd72140-aa1e-432d-bed3-af2bd14bb6ac"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Test Evaluation:\n",
            "Accuracy: 0.7938\n",
            "Precision (macro): 0.7629\n",
            "Recall (macro): 0.7923\n",
            "F1 Score (macro): 0.7712\n"
          ]
        }
      ],
      "source": [
        "# Consolidated Evaluation\n",
        "\n",
        "# Load best model\n",
        "model.load_state_dict(torch.load(CHECKPOINT_PATH))\n",
        "model.to(device)\n",
        "\n",
        "# Evaluation function\n",
        "def evaluate(model, loader, device):\n",
        "    model.eval()\n",
        "    all_preds = []\n",
        "    all_labels = []\n",
        "    with torch.no_grad():\n",
        "        with torch.amp.autocast(device_type='cuda'):\n",
        "            for images, labels in loader:\n",
        "                images = images.to(device)\n",
        "                outputs = model(images)\n",
        "                _, predicted = outputs.max(1)\n",
        "                all_preds.extend(predicted.cpu().numpy())\n",
        "                all_labels.extend(labels.numpy())\n",
        "                del images, outputs\n",
        "                torch.cuda.empty_cache()\n",
        "    acc = accuracy_score(all_labels, all_preds)\n",
        "    precision, recall, f1, _ = precision_recall_fscore_support(all_labels, all_preds, average='macro', zero_division=0)\n",
        "    cm = confusion_matrix(all_labels, all_preds)\n",
        "    return acc, precision, recall, f1, cm\n",
        "\n",
        "test_acc, test_precision, test_recall, test_f1, cm = evaluate(model, test_loader, device)\n",
        "\n",
        "print(\"\\nTest Evaluation:\")\n",
        "print(f\"Accuracy: {test_acc:.4f}\")\n",
        "print(f\"Precision (macro): {test_precision:.4f}\")\n",
        "print(f\"Recall (macro): {test_recall:.4f}\")\n",
        "print(f\"F1 Score (macro): {test_f1:.4f}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 954
        },
        "id": "7f903f15",
        "outputId": "f0a838e4-9c58-42b1-f969-76df43fbd879"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 800x600 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAGGCAYAAACqvTJ0AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAzVFJREFUeJzs3Xd4U9UbwPFv0r1b2lIKFAote7TMskEBy95DUJkOUBAEVBBEBBV/MkQRwcEUEJCtIKvI3iB7z0IpHUAnncn9/XHbQGyBAm3T8X6e5z5JTk7ufXPT25y895xzNYqiKAghhBBCCCGEEEIIkYu0pg5ACCGEEEIIIYQQQhQ+kpQSQgghhBBCCCGEELlOklJCCCGEEEIIIYQQItdJUkoIIYQQQgghhBBC5DpJSgkhhBBCCCGEEEKIXCdJKSGEEEIIIYQQQgiR6yQpJYQQQgghhBBCCCFynSSlhBBCCCGEEEIIIUSuk6SUEEIIIYQQQgghhMh1kpQSQogC7vr162g0GqZOnWrqUIQQQgghCiVvb2/atWtn6jCEyHMkKSVEIbRgwQI0Gg1HjhwxdSgFQnrS53HL119/beoQhRBCiELtxx9/RKPREBAQYOpQRA7x9vZ+bFusVatWpg5PCPEY5qYOQAghCopevXrRpk2bDOU1atQwQTRCCCGESLdkyRK8vb05dOgQly9fxtfX19QhiRzg7+/PyJEjM5QXL17cBNEIIbJCklJCCJEF8fHx2NnZPbFOzZo1ef3113MpIiGEEEJkxbVr19i3bx+rV6/mnXfeYcmSJXz22WemDitTWWlvFFapqano9XosLS0fW6dEiRLSFhMin5Hhe0KIx/r3339p3bo1jo6O2Nvb07x5cw4cOGBUJyUlhc8//5xy5cphbW2Nq6srjRo1YuvWrYY6d+7coX///pQsWRIrKys8PT3p2LEj169ff2oM27dvp3HjxtjZ2eHs7EzHjh05d+6c4fmVK1ei0WjYuXNnhtf+9NNPaDQaTp8+bSg7f/483bp1o0iRIlhbW1O7dm3Wr19v9Lr04Y07d+7k3XffpWjRopQsWTKru+2J0ucT2LJlC/7+/lhbW1O5cmVWr16doe7Vq1fp3r07RYoUwdbWlnr16rFhw4YM9RITE5kwYQLly5fH2toaT09PunTpwpUrVzLU/fnnn/Hx8cHKyoo6depw+PBho+df5LMSQggh8qIlS5bg4uJC27Zt6datG0uWLMm0XlRUFB988AHe3t5YWVlRsmRJ+vTpQ2RkpKHO075zd+zYgUajYceOHUbrTh/qv2DBAkNZv379sLe358qVK7Rp0wYHBwdee+01AHbv3k337t0pVaoUVlZWeHl58cEHH5CQkJAh7vPnz9OjRw/c3d2xsbGhQoUKjB07FoB//vkHjUbDmjVrMrxu6dKlaDQa9u/f/8T997T2SFhYGObm5nz++ecZXnvhwgU0Gg0//PCD0X4ePnw4Xl5eWFlZ4evry//+9z/0en2G/TV16lRmzJhhaLucPXv2ibFmRfp+v3r1KoGBgdjZ2VG8eHEmTpyIoihGdePj4xk5cqQh1goVKjB16tQM9QAWL15M3bp1sbW1xcXFhSZNmrBly5YM9fbs2UPdunWxtrambNmyLFq0yOj5rLSthShIpKeUECJTZ86coXHjxjg6OvLRRx9hYWHBTz/9RLNmzdi5c6dhToYJEyYwefJk3nzzTerWrUtMTAxHjhzh2LFjtGzZEoCuXbty5swZhg4dire3N+Hh4WzdupXg4GC8vb0fG8O2bdto3bo1ZcuWZcKECSQkJDBz5kwaNmzIsWPH8Pb2pm3bttjb27NixQqaNm1q9Prly5dTpUoVqlatanhPDRs2pESJEowePRo7OztWrFhBp06dWLVqFZ07dzZ6/bvvvou7uzvjx48nPj7+qfvswYMHRg3XdM7OzpibP/x3e+nSJXr27MmgQYPo27cv8+fPp3v37mzatMmwz8LCwmjQoAEPHjzg/fffx9XVlYULF9KhQwdWrlxpiFWn09GuXTuCgoJ49dVXGTZsGLGxsWzdupXTp0/j4+Nj2O7SpUuJjY3lnXfeQaPR8M0339ClSxeuXr2KhYXFC31WQgghRF61ZMkSunTpgqWlJb169WL27NkcPnyYOnXqGOrExcXRuHFjzp07x4ABA6hZsyaRkZGsX7+eW7du4ebm9kzfuVmVmppKYGAgjRo1YurUqdja2gLwxx9/8ODBAwYPHoyrqyuHDh1i5syZ3Lp1iz/++MPw+pMnT9K4cWMsLCx4++238fb25sqVK/z55598+eWXNGvWDC8vL5YsWZKhnbNkyRJ8fHyoX7/+Y+PLSnvEw8ODpk2bsmLFigw90JYvX46ZmRndu3cH1LZS06ZNCQkJ4Z133qFUqVLs27ePMWPGEBoayowZM4xeP3/+fBITE3n77bexsrKiSJEiT9yfKSkpmbbF7OzssLGxMTzW6XS0atWKevXq8c0337Bp0yY+++wzUlNTmThxIgCKotChQwf++ecfBg4ciL+/P5s3b+bDDz8kJCSEb7/91rC+zz//nAkTJtCgQQMmTpyIpaUlBw8eZPv27bzyyiuGepcvX6Zbt24MHDiQvn37Mm/ePPr160etWrWoUqUKkLW2tRAFiiKEKHTmz5+vAMrhw4cfW6dTp06KpaWlcuXKFUPZ7du3FQcHB6VJkyaGMj8/P6Vt27aPXc/9+/cVQJkyZcozx+nv768ULVpUuXv3rqHsxIkTilarVfr06WMo69Wrl1K0aFElNTXVUBYaGqpotVpl4sSJhrLmzZsr1apVUxITEw1ler1eadCggVKuXDlDWfr+adSokdE6H+fatWsK8Nhl//79hrqlS5dWAGXVqlWGsujoaMXT01OpUaOGoWz48OEKoOzevdtQFhsbq5QpU0bx9vZWdDqdoiiKMm/ePAVQpk+fniEuvV5vFJ+rq6ty7949w/Pr1q1TAOXPP/9UFOXFPishhBAiLzpy5IgCKFu3blUURf1uLFmypDJs2DCjeuPHj1cAZfXq1RnWkf59mpXv3H/++UcBlH/++cfo+fTv4vnz5xvK+vbtqwDK6NGjM6zvwYMHGcomT56saDQa5caNG4ayJk2aKA4ODkZlj8ajKIoyZswYxcrKSomKijKUhYeHK+bm5spnn32WYTuPymp75KefflIA5dSpU0avr1y5svLyyy8bHk+aNEmxs7NTLl68aFRv9OjRipmZmRIcHKwoysP95ejoqISHhz8xxnTpbazMlsmTJxvqpe/3oUOHGsr0er3Stm1bxdLSUomIiFAURVHWrl2rAMoXX3xhtJ1u3bopGo1GuXz5sqIoinLp0iVFq9UqnTt3NuyPR9f73/h27dplKAsPD1esrKyUkSNHGsqe1rYWoqCR4XtCiAx0Oh1btmyhU6dOlC1b1lDu6elJ79692bNnDzExMYDaC+jMmTNcunQp03XZ2NhgaWnJjh07uH//fpZjCA0N5fjx4/Tr18/orFj16tVp2bIlGzduNJT17NmT8PBwo67yK1euRK/X07NnTwDu3bvH9u3b6dGjB7GxsURGRhIZGcndu3cJDAzk0qVLhISEGMXw1ltvYWZmluWY3377bbZu3ZphqVy5slG94sWLG52tdHR0pE+fPvz777/cuXMHgI0bN1K3bl0aNWpkqGdvb8/bb7/N9evXDd3XV61ahZubG0OHDs0Qj0ajMXrcs2dPXFxcDI8bN24MqN3y4fk/KyGEECKvWrJkCR4eHrz00kuA+t3Ys2dPli1bhk6nM9RbtWoVfn5+GXoTpb8mvU5Wv3OfxeDBgzOUPdqrJz4+nsjISBo0aICiKPz7778AREREsGvXLgYMGECpUqUeG0+fPn1ISkpi5cqVhrLly5eTmpr61PmXstoe6dKlC+bm5ixfvtxQ7/Tp05w9e9bQFgO1B1jjxo1xcXExtMUiIyNp0aIFOp2OXbt2GW2/a9euuLu7PzHGRwUEBGTaFuvVq1eGukOGDDHc12g0DBkyhOTkZLZt22Z472ZmZrz//vtGrxs5ciSKovD3338DsHbtWvR6PePHj0erNf55/d+/i8qVKxvaXwDu7u5UqFDB0BaDp7ethShoJCklhMggIiKCBw8eUKFChQzPVapUCb1ez82bNwGYOHEiUVFRlC9fnmrVqvHhhx9y8uRJQ30rKyv+97//8ffff+Ph4UGTJk345ptvDMmXx7lx4wbAY2OIjIw0DKlr1aoVTk5ORg2h5cuX4+/vT/ny5QG1u7SiKHz66ae4u7sbLeldzcPDw422U6ZMmafuq0eVK1eOFi1aZFgcHR2N6vn6+mZopKTHmT53040bNx773tOfB7hy5QoVKlQwGh74OP9tsKYnqNITUM/7WQkhhBB5kU6nY9myZbz00ktcu3aNy5cvc/nyZQICAggLCyMoKMhQ98qVK4bh/o/zLN+5WWVubp7pvJXBwcGGE3P29va4u7sbpimIjo4GHp5UelrcFStWpE6dOkZzaS1ZsoR69eo99SqEWW2PuLm50bx5c1asWGGos3z5cszNzenSpYuh7NKlS2zatClDW6xFixbAi7fF3NzcMm2LlS5d2qieVqs1OvEKmbfFihcvjoODwxPf+5UrV9BqtRlOQmbmv20xUNtjj54MfFrbWoiCRpJSQogX0qRJE65cucK8efOoWrUqv/76KzVr1uTXX3811Bk+fDgXL15k8uTJWFtb8+mnn1KpUiXDmb4XZWVlRadOnVizZg2pqamEhISwd+9eozNz6ZNnjho1KtMzaFu3bs3QMHv0LGVB8LheX8ojk3Xm9GclhBBC5Jbt27cTGhrKsmXLKFeunGHp0aMHwGMnPH8Rj+sx9WivrEdZWVll6F2j0+lo2bIlGzZs4OOPP2bt2rVs3brVMEn6oxOCZ1WfPn3YuXMnt27d4sqVKxw4cCDbr1L36quvcvHiRY4fPw7AihUraN68OW5uboY6er2eli1bPrYt1rVrV6N1Fsa2WFba1kIUJDLRuRAiA3d3d2xtbblw4UKG586fP49Wq8XLy8tQVqRIEfr370///v2Ji4ujSZMmTJgwgTfffNNQx8fHh5EjRzJy5EguXbqEv78/06ZNY/HixZnGkH5G63ExuLm5GV0yuWfPnixcuJCgoCDOnTuHoihGSan0s2EWFhaGs3Gmkt5r69GG68WLFwEMk4mXLl36se89/XlQ9+vBgwdJSUkxTFb+op71sxJCCCHyoiVLllC0aFFmzZqV4bnVq1ezZs0a5syZg42NDT4+PkZX681MVr5z03shR0VFGZWn96rJilOnTnHx4kUWLlxInz59DOX/vfpaetvmaXGDmjAaMWIEv//+OwkJCVhYWBi1kx4nq+0RgE6dOvHOO+8Yeq5fvHiRMWPGGL3Ox8eHuLg4k7fF9Ho9V69eNfSOgszbYtu2bSM2Ntaot1RmbTG9Xs/Zs2fx9/fPlviy0rYWoqCQnlJCiAzMzMx45ZVXWLdunaELM6hXYFm6dCmNGjUyDEm7e/eu0Wvt7e3x9fUlKSkJUK+ykpiYaFTHx8cHBwcHQ53MeHp64u/vz8KFC40adqdPn2bLli20adPGqH6LFi0oUqQIy5cvZ/ny5dStW9eoy3fRokVp1qwZP/30E6GhoRm2FxER8eSdko1u375tdGnmmJgYFi1ahL+/P8WKFQOgTZs2HDp0yOgyzfHx8fz88894e3sbuoh37dqVyMhIo0stp1MyuVzxkzzvZyWEEELkNQkJCaxevZp27drRrVu3DMuQIUOIjY1l/fr1gPp9euLECaPv53Tp36dZ+c4tXbo0ZmZmGeZG+vHHH7Mce3pvmke/xxVF4bvvvjOq5+7uTpMmTZg3bx7BwcGZxpPOzc2N1q1bs3jxYpYsWUKrVq2MejA9TlbbI6DOhRQYGMiKFStYtmwZlpaWdOrUyWh9PXr0YP/+/WzevDnDtqKiokhNTX1qTNnl0c9RURR++OEHLCwsaN68OaC+d51Ol+Hz/vbbb9FoNLRu3RpQk3FarZaJEydm6MX2rG0xeHrbWoiCRnpKCVGIzZs3j02bNmUoHzZsGF988QVbt26lUaNGvPvuu5ibm/PTTz+RlJTEN998Y6hbuXJlmjVrRq1atShSpAhHjhxh5cqVhskjL168SPPmzenRoweVK1fG3NycNWvWEBYWxquvvvrE+KZMmULr1q2pX78+AwcOJCEhgZkzZ+Lk5MSECROM6lpYWNClSxeWLVtGfHw8U6dOzbC+WbNm0ahRI6pVq8Zbb71F2bJlCQsLY//+/dy6dYsTJ048x1586NixY5n2Jvrv5ZbLly/PwIEDOXz4MB4eHsybN4+wsDDmz59vqDN69Gh+//13Wrduzfvvv0+RIkVYuHAh165dY9WqVYau/n369GHRokWMGDGCQ4cO0bhxY+Lj49m2bRvvvvsuHTt2zHL8L/JZCSGEEHnJ+vXriY2NpUOHDpk+X69ePdzd3VmyZAk9e/bkww8/ZOXKlXTv3p0BAwZQq1Yt7t27x/r165kzZw5+fn5Z+s51cnKie/fuzJw5E41Gg4+PD3/99VeGuZKepGLFivj4+DBq1ChCQkJwdHRk1apVmV6E5Pvvv6dRo0bUrFmTt99+mzJlynD9+nU2bNhgGEaXrk+fPnTr1g2ASZMmZSmWrLZH0vXs2ZPXX3+dH3/8kcDAQJydnY2e//DDD1m/fj3t2rWjX79+1KpVi/j4eE6dOsXKlSu5fv16lpJljxMSEpJpW8ze3t4oQWZtbc2mTZvo27cvAQEB/P3332zYsIFPPvnEMLF6+/bteemllxg7dizXr1/Hz8+PLVu2sG7dOoYPH46Pjw+gzhU6duxYJk2aROPGjenSpQtWVlYcPnyY4sWLM3ny5Gd6D09rWwtR4Jjgin9CCBObP3/+Yy+ZCyg3b95UFEVRjh07pgQGBir29vaKra2t8tJLLyn79u0zWtcXX3yh1K1bV3F2dlZsbGyUihUrKl9++aWSnJysKIqiREZGKu+9955SsWJFxc7OTnFyclICAgKUFStWZCnWbdu2KQ0bNlRsbGwUR0dHpX379srZs2czrbt161YFUDQajeE9/NeVK1eUPn36KMWKFVMsLCyUEiVKKO3atVNWrlyZYf8cPnw4SzGmX7b4cUvfvn0NdUuXLq20bdtW2bx5s1K9enXFyspKqVixovLHH39kGmu3bt0UZ2dnxdraWqlbt67y119/Zaj34MEDZezYsUqZMmUUCwsLpVixYkq3bt2UK1euGMU3ZcqUDK8FDJeDftHPSgghhMgr2rdvr1hbWyvx8fGPrdOvXz/FwsJCiYyMVBRFUe7evasMGTJEKVGihGJpaamULFlS6du3r+F5RXn6d66iKEpERITStWtXxdbWVnFxcVHeeecd5fTp0wqgzJ8/31Cvb9++ip2dXaaxnT17VmnRooVib2+vuLm5KW+99ZZy4sSJDOtQFEU5ffq00rlzZ0N7oUKFCsqnn36aYZ1JSUmKi4uL4uTkpCQkJGRlNyqKkvX2iKIoSkxMjGJjY6MAyuLFizOtExsbq4wZM0bx9fVVLC0tFTc3N6VBgwbK1KlTDe3HJ7VdHqd06dKPbYuVLl3aUC99v1+5ckV55ZVXFFtbW8XDw0P57LPPFJ1OlyHWDz74QClevLhiYWGhlCtXTpkyZYqi1+szbH/evHlKjRo1FCsrK8XFxUVp2rSpsnXrVqP42rZtm+F1TZs2VZo2bWp4/LS2tRAFjUZRnqNPoRBCiOfi7e1N1apV+euvv0wdihBCCCEKkdTUVIoXL0779u2ZO3euqcMxmX79+rFy5Uri4uJMHYoQAplTSgghhBBCCCEKvLVr1xIREWE0eboQQpiazCklhBBCCCGEEAXUwYMHOXnyJJMmTaJGjRo0bdrU1CEJIYSB9JQSQgghhBBCiAJq9uzZDB48mKJFi7Jo0SJThyOEEEZkTikhhBBCCCGEEEIIkeukp5QQQgghhBBCCCGEyHWSlBJCCCGEEEIIIYQQua7QTXSu1+u5ffs2Dg4OaDQaU4cjhBBCiDxOURRiY2MpXrw4Wm3hPZ8nbSghhBBCZFVW20+FLil1+/ZtvLy8TB2GEEIIIfKZmzdvUrJkSVOHYTLShhJCCCHEs3pa+6nQJaUcHBwAdcc4OjqaOBohhBBC5HUxMTF4eXkZ2hCFlbShhBBCCJFVWW0/FbqkVHp3c0dHR2lQCSGEECLLCvuQNWlDCSGEEOJZPa39VHgnRhBCCCGEEEIIIYQQJiNJKSGEEEIIIYQQQgiR6yQpJYQQQgghhBBCCCFyXaGbU0oIIYTIDjqdjpSUFFOHIbKBhYUFZmZmpg6jwJBjQ2QXOTaFEKLgk6SUEEII8QwUReHOnTtERUWZOhSRjZydnSlWrFihn8z8RcixIXKCHJtCCFGwSVJKCCGEeAbpP7qLFi2Kra2t/FDK5xRF4cGDB4SHhwPg6elp4ojyLzk2RHaSY1MIIQoHSUoJIYQQWaTT6Qw/ul1dXU0djsgmNjY2AISHh1O0aFEZLvQc5NgQOUGOTSGEKPhkonMhhBAii9LnybG1tTVxJCK7pX+mMhfS85FjQ+QUOTaFEKJgk6SUEEII8YxkWFLBI59p9pD9KLKb/E0JIUTBJkmpnJBw39QRCCGEEKKAmzVrFt7e3lhbWxMQEMChQ4ceWzclJYWJEyfi4+ODtbU1fn5+bNq0KRejFUIIIYTISOaUyk56PWwcBceXwDu7wL2CqSMSQgghcoy3tzfDhw9n+PDhpg6l0Fm+fDkjRoxgzpw5BAQEMGPGDAIDA7lw4QJFixbNUH/cuHEsXryYX375hYoVK7J582Y6d+7Mvn37qFGjhgneQcElx4UQQojcoCgKSal6YhNTiUtKJS79NimVuKQU4hJTiU1KJT7tudi02/hk48cbhzXGzd7KZO9DklLZSauFuDBITYRdU6HrL6aOSAghhHjq8JfPPvuMCRMmPPN6Dx8+jJ2d3XNGpWrWrBn+/v7MmDHjhdZT2EyfPp233nqL/v37AzBnzhw2bNjAvHnzGD16dIb6v/32G2PHjqVNmzYADB48mG3btjFt2jQWL16cq7HnFXn5uEj3+++/8/rrrzNo0CBmzZqVLesUQghheoqikJiiJzYxhZjEFGISU4lJUG9jE1OISUh9+Fza/fTkU+wjySedXnnhWOISUyUpVaA0+RDO/wWnV0Kz0eDqY+qIhBBCFHKhoaGG+8uXL2f8+PFcuHDBUGZvb2+4rygKOp0Oc/OnNxHc3d2zN1CRJcnJyRw9epQxY8YYyrRaLS1atGD//v2ZviYpKQlra2ujMhsbG/bs2fPY7SQlJZGUlGR4HBMT84KR5y354biYO3cuH330ET/99BPTpk3L8BnmpuTkZCwtLU22fSGEyGt0eoXYxBSiHqQQlZBC1INkohNSiE5Qy2IS1ERSTOLD20fLUnQvnlAC0GjAztIceytz7K3VW4e0Wzsr48fpzxsWa3M8nU333QKSlMp+xf2hfCu4uAl2T4NOP5o6IiGEEIVcsWLFDPednJzQaDSGsh07dvDSSy+xceNGxo0bx6lTp9iyZQteXl6MGDGCAwcOEB8fT6VKlZg8eTItWrQwrOu/w5Q0Gg2//PILGzZsYPPmzZQoUYJp06bRoUOH54591apVjB8/nsuXL+Pp6cnQoUMZOXKk4fkff/yRb7/9lps3b+Lk5ETjxo1ZuXIlACtXruTzzz/n8uXL2NraUqNGDdatW5dtvVhMJTIyEp1Oh4eHh1G5h4cH58+fz/Q1gYGBTJ8+nSZNmuDj40NQUBCrV69Gp9M9djuTJ0/m888/z9bY85K8flxcu3aNffv2sWrVKv755x9Wr15N7969jerMmzePadOmcfnyZYoUKULXrl354YcfAIiKiuLjjz9m7dq1REdH4+vry9dff027du2YMGECa9eu5fjx44Z1zZgxgxkzZnD9+nUA+vXrR1RUFHXq1GHWrFlYWVlx7do1fvvtN7777jsuXLiAnZ0dL7/8MjNmzDAaNnrmzBk+/vhjdu3ahaIo+Pv7s2DBAkJCQmjevDk3b9402v/Dhw/n6NGj7N69O+sfoBBCZJPkVD1RCclEG5JLGRNMjyadoh6o5TGJKSgvmFfSasDB2gIHa3McrS1wtDHHwdoCx/QyGwsc055zsP5v0skCe2tzbC3M0Grz70UhJCmVE5p8pCalTixTe04VKWPqiIQQQuQQRVFISHn8D/ucZGNhlm1Xpho9ejRTp06lbNmyuLi4cPPmTdq0acOXX36JlZUVixYton379ly4cIFSpUo9dj2ff/4533zzDVOmTGHmzJm89tpr3LhxgyJFijxzTEePHqVHjx5MmDCBnj17sm/fPt59911cXV3p168fR44c4f333+e3336jQYMG3Lt3z/CjNjQ0lF69evHNN9/QuXNnYmNj2b17N8qLth7zqe+++4633nqLihUrotFo8PHxoX///sybN++xrxkzZgwjRowwPI6JicHLyytL25PjwtjzHBfz58+nbdu2ODk58frrrzN37lyjpNTs2bMZMWIEX3/9Na1btyY6Opq9e/cCoNfrad26NbGxsSxevBgfHx/Onj2LmZnZM73/oKAgHB0d2bp1q6EsJSWFSZMmUaFCBcLDwxkxYgT9+vVj48aNAISEhNCkSROaNWvG9u3bcXR0ZO/evaSmptKkSRPKli3Lb7/9xocffmhY35IlS/jmm2+eKTYhhHic5FQ99+KTuRufxN24ZO7FJxMZl8S9+PT7ydyLT+JufDL34pKJTUp9oe3ZWZrhbGuJk40Fzrbq4mRjkZZkephwSk8yPUxAWWBnmX3fWfmVJKVyQsla4NsCLm+DPdOhw0xTRySEECKHJKToqDx+s0m2fXZiILaW2fNVPnHiRFq2bGl4XKRIEfz8/AyPJ02axJo1a1i/fj1Dhgx57Hr69etHr169APjqq6/4/vvvOXToEK1atXrmmKZPn07z5s359NNPAShfvjxnz55lypQp9OvXj+DgYOzs7GjXrh0ODg6ULl3aMGl3aGgoqampdOnShdKlSwNQrVq1Z44hL3Jzc8PMzIywsDCj8rCwMKPeJ49yd3dn7dq1JCYmcvfuXYoXL87o0aMpW7bsY7djZWWFldXzzTEhx4WxZz0u9Ho9CxYsYOZMtQ356quvMnLkSK5du0aZMurJzi+++IKRI0cybNgww+vq1KkDwLZt2zh06BDnzp2jfPnyAE/8rB/Hzs6OX3/91WjY3oABAwz3y5Yty/fff0+dOnWIi4vD3t6eWbNm4eTkxLJly7CwsAAwxAAwcOBA5s+fb0hK/fnnnyQmJtKjR49njk8IUfAlpeqISXg49C0mMZWoB48kluKS1eRSfDJ349REU2zisyeZNBrUpJKNBU62ljinJ5hs1ASTUZmtBU42ahLKycYCS3NtDrzzwkOSUjml6cdqUur4UrW3lPPjz54JIYQQpla7dm2jx3FxcUyYMIENGzYYEjwJCQkEBwc/cT3Vq1c33Lezs8PR0ZHw8PDniuncuXN07NjRqKxhw4bMmDEDnU5Hy5YtKV26NGXLlqVVq1a0atWKzp07Y2tri5+fH82bN6datWoEBgbyyiuv0K1bN1xcXJ4rlrzE0tKSWrVqERQURKdOnQA1iREUFPTExAiAtbU1JUqUICUlhVWrVkki4ClMdVxs3bqV+Ph4w8T0bm5utGzZknnz5jFp0iTCw8O5ffs2zZs3z/T1x48fp2TJkkbJoOdRrVq1DPNIHT16lAkTJnDixAnu37+PXq8HIDg4mMqVK3P8+HEaN25sSEj9V79+/Rg3bhwHDhygXr16LFiwgB49euT7YbVCiIzSJ/N+mFBKeZhgMkzs/eik3qkZ6iWn6p9r22ZaDS62lrjZW1LEzhJXeytc7dLvW+KaVlbETr3vaG2Rr4fA5WeSlMopXnWhTFO4thP2fAvtvjV1REIIIXKAjYUZZycGmmzb2eW/PwhHjRrF1q1bmTp1Kr6+vtjY2NCtWzeSk5OfuJ7//hDVaDSGH63ZzcHBgWPHjrFjxw62bNnC+PHjmTBhAocPH8bZ2ZmtW7eyb98+tmzZwsyZMxk7diwHDx409DTJz0aMGEHfvn2pXbs2devWZcaMGcTHxxuuxtenTx9KlCjB5MmTATh48CAhISH4+/sTEhLChAkT0Ov1fPTRRzkSnxwXxp71uJg7dy737t3DxsbGUKbX6zl58iSff/65UXlmnva8VqvNMJQ1JSUlQ73/vv/4+HgCAwMJDAxkyZIluLu7ExwcTGBgoGEfPG3bRYsWpX379syfP58yZcrw999/s2PHjie+RgiR9+j1CvceJHMnOpHQ6ETuxCRyJzpBvZ++xCTyIPnFh3JrNGBv9XAInItt5oml9Ptu9pJkyk8kKZWTmn6sJqX+XQyNR4FTCVNHJIQQIptpNJpsGyqUl+zdu5d+/frRuXNnQO0hkj4Bcm6pVKmSYY6cR+MqX768YW4cc3NzWrRoQYsWLfjss89wdnZm+/btdOnSBY1GQ8OGDWnYsCHjx4+ndOnSrFmzxmiepPyqZ8+eREREMH78eO7cuYO/vz+bNm0yTH4eHByMVvtwOEFiYiLjxo3j6tWr2Nvb06ZNG3777TecnZ1zJD45Lp7f3bt3WbduHcuWLaNKlSqGcp1OR6NGjdiyZQutWrXC29uboKAgXnrppQzrqF69Ordu3eLixYuZ9pZyd3fnzp07KIpimMvk0UnPH+f8+fPcvXuXr7/+2jC/2JEjRzJse+HChaSkpDy2t9Sbb75Jr169KFmyJD4+PjRs2PCp2xZC5J5UnZ6IuCRDcik96aQmnBK4E5NIWHQSybqsnXTSakibsFudyNvR2nheJeMJvs2N69pYYG9pLgmmAqzgtRbyEu+GULoR3NgDe7+DNjKBoxBCiPyhXLlyrF69mvbt26PRaPj0009zrMdTREREhh/Enp6ejBw5kjp16jBp0iR69uzJ/v37+eGHH/jxR/XKtn/99RdXr16lSZMmuLi4sHHjRvR6PRUqVODgwYMEBQXxyiuvULRoUQ4ePEhERASVKlXKkfdgCkOGDHnscL3/9jxp2rQpZ8+ezYWoCrbcOC5+++03XF1d6dGjR4bJb9u0acPcuXNp1aoVEyZMYNCgQRQtWtQwqfnevXsZOnQoTZs2pUmTJnTt2pXp06fj6+vL+fPn0Wg0tGrVimbNmhEREcE333xDt27d2LRpE3///TeOjo5PjK1UqVJYWloyc+ZMBg0axOnTp5k0aZJRnSFDhjBz5kxeffVVxowZg5OTEwcOHKBu3bpUqFABUK8G6ejoyBdffMHEiROzdf8JIbIuOVXP+TsxnLwVzclbUVwMi+NOdCLhsYnos3BdEI0G3Oyt8HSyxsPRGk8na4o5WT/y2AY3e0vsrcwL/WTe4vEkKZXTmn4Ei/bA0QXQeAQ4ZD4BqRBCCJGXTJ8+nQEDBtCgQQPc3Nz4+OOPiYmJyZFtLV26lKVLlxqVTZo0iXHjxrFixQrGjx/PpEmT8PT0ZOLEifTr1w8AZ2dnVq9ezYQJE0hMTKRcuXL8/vvvVKlShXPnzrFr1y5mzJhBTEwMpUuXZtq0abRu3TpH3oMoHHLjuJg3bx6dO3fO9Adc165deeONN4iMjKRv374kJiby7bffMmrUKNzc3OjWrZuh7qpVqxg1ahS9evUiPj4eX19fvv76a0Dthfjjjz/y1VdfMWnSJLp27cqoUaP4+eefnxibu7s7CxYs4JNPPuH777+nZs2aTJ06lQ4dOhjquLq6sn37dj788EOaNm2KmZkZ/v7+Rr2htFot/fr146uvvqJPnz4vusuEEFmQqtNzOSKOkzejORkSxclb0ZwPjX1sbyczrYZijtZ4OFrh6WRjSDYVc7KmmKN6W9TBWib5Fi9MoxSyayPHxMTg5OREdHT0U88GZQtFgXmt4OYBqPcetPoq57cphBAiRyQmJhqufmVtbW3qcEQ2etJnm+tthzzqSftBjg3xrAYOHEhERATr169/Yj352xLi2en1CtfuxnPylpp8OnUrmjO3Y0hIyTi/k7OtBdVKOOFX0pnKxR0p4WyDp5M1rvZWmMmQOfECstp+kp5SOU2jgaYfwuKucGQeNBoO9kVNHZUQQgghhBC5Ljo6mlOnTrF06dKnJqSEEE+nKAq37icYhuCdvBXN6ZBoYpNSM9S1tzKnaglH/Eo6U62kE9VLOONVxEaG1gmTkqRUbvBpDiVqQchR2DcTXpn09NcIIYQQQghRwHTs2JFDhw4xaNAgWrZsaepwhMhxYTGJHL5+jwdJOhQU9Io6mEavKCgASnpZ2i3qfUXBqL5CWllavYQUHWdux3DqVhT3H2S8eqa1hZYqxZ3UXlBeTlQr4UxZNzuZMFzkOZKUyg0ajXolvqU94PBcaDgc7FxNHZUQQgghhBC56r+T8AtR0MQmpnDw6j32XI5k7+VILoXH5fg2Lcw0VPJ0NAzDq1bSiXJF7TE3k/meRN4nSancUu4V8PSD0BNwYBY0H2/qiIQQQgghhBBCvIDkVD3/Bt9n75W77L0cyfGbUegeuXSdRgOVPR3xcLRG7aSkQaMBrQY0aNBq1Vs0oNVo0JD2XNp9jca4vibtOQszDeU8HPAr6USFYg5YmZuZaA8I8WIkKZVb0ntLLesNB3+G+kPAtoipoxJCCCGEEEIIkUV6vcKFsFj2Xo5kz+VIDl27x4Nk4wnEvV1taejrRkNfN+qXdcXFztJE0QqR90lSKjdVaAMeVSHsNBycAy99YuqIhBBCCCGEEEI8wa37D9h3+S57Lkey70okkXHJRs+72lnSwNeNRr6uNPBxw6uIrYkiFSL/kaRUbtJooMmH8EdfODAH6r0LNs6mjkoIIYQQQgghRJqoB8nsv3LXMC/U9bsPjJ63sTAjoGwRGqX1hqrg4SATiAvxnCQpldsqdQD3ihBxHg79DE0/MnVEQgghhBBCCFGgKIpCYoqemMQUYhJS0m5T1dvEVKOy2EfKohNSuH43HuXhtFCYaTX4lXQyJKFqlHLB0lwmERciO5g0KbVr1y6mTJnC0aNHCQ0NZc2aNXTq1Omx9UNDQxk5ciRHjhzh8uXLvP/++8yYMSPX4s0WWq3aW2rVQNg/C+oNBisHU0clhBBCCCGEEPnGtch4gs6FcSksjpjEFGITUx9JQKkJptRHJhx/VuWK2tPQ141Gvm4ElC2Cg7VFNkYvhEhn0qRUfHw8fn5+DBgwgC5dujy1flJSEu7u7owbN45vv/02FyLMIVU6w46v4e4lOPQLNB5h6oiEEEKIp2rWrBn+/v7574SQEDlIjgshckeKTs/h6/fYfi6c7efDuRoZn6XXaTXgaGOBo7UFjjbmOFipt+pjtdzB2jztvjkO1haUdbfDw9E6h9+REAJMnJRq3bo1rVu3znJ9b29vvvvuOwDmzZuXU2HlPK2Z2ltqzduw/weo+zZY2Zs6KiGEEAVU+/btSUlJYdOmTRme2717N02aNOHEiRNUr179hbazYMEChg8fTlRU1AutR4jckFvHRbqEhARKlCiBVqslJCQEKyurbFmvEAXZ/fhkdlwMJ+hcODsvRhCbmGp4zsJMQ0AZV2p7u+Bia/nYRJOdpRkajcz3JEReVeDnlEpKSiIpKcnwOCYmxoTRPKJqV9gxGe5fgyPzoOH7po5ICCFEATVw4EC6du3KrVu3KFmypNFz8+fPp3bt2tn2w1uI/CK3j4tVq1ZRpUoVFEVh7dq19OzZM9vW/awURUGn02FuXuB/Coh8RlEULoXHEXQunKBzYRwLvs+jI/CK2FnyUoWiNK9UlMbl3GRInRAFQIGfnW3y5Mk4OTkZFi8vL1OHpDIzhyaj1Pv7vofkB0+uL4QQQjyndu3a4e7uzoIFC4zK4+Li+OOPPxg4cCB3796lV69elChRAltbW6pVq8bvv/+erXEEBwfTsWNH7O3tcXR0pEePHoSFhRmeP3HiBC+99BIODg44OjpSq1Ytjhw5AsCNGzdo3749Li4u2NnZUaVKFTZu3Jit8YnCJbePi7lz5/L666/z+uuvM3fu3AzPnzlzhnbt2uHo6IiDgwONGzfmypUrhufnzZtHlSpVsLKywtPTkyFDhgBw/fp1NBoNx48fN9SNiopCo9GwY8cOAHbs2IFGo+Hvv/+mVq1aWFlZsWfPHq5cuULHjh3x8PDA3t6eOnXqsG3bNqO4kpKS+Pjjj/Hy8sLKygpfX1/mzp2Loij4+voydepUo/rHjx9Ho9Fw+fLl59pPovBJStWx62IEE9afocmUf3jl2138b9N5jtxQE1IViznw3ks+rH63AYfHtmBaDz/aVPOUhJQQBUSBPz0yZswYRox4OGdTTExM3klMVe8JO/8HUcFwdAHUf9fUEQkhhHhWigIpJjqxYGELWRiSYG5uTp8+fViwYAFjx441DGP4448/0Ol09OrVi7i4OGrVqsXHH3+Mo6MjGzZs4I033sDHx4e6deu+cKh6vd6QkNq5cyepqam899579OzZ0/DD+bXXXqNGjRrMnj0bMzMzjh8/joWF+qPjvffeIzk5mV27dmFnZ8fZs2ext5eh73mWHBdGrly5wv79+1m9ejWKovDBBx9w48YNSpcuDUBISAhNmjShWbNmbN++HUdHR/bu3UtqqjpUafbs2YwYMYKvv/6a1q1bEx0dzd69e59514wePZqpU6dStmxZXFxcuHnzJm3atOHLL7/EysqKRYsW0b59ey5cuECpUqUA6NOnD/v37+f777/Hz8+Pa9euERkZiUajYcCAAcyfP59Ro0YZtjF//nyaNGmCr6/vM8cnCo+I2CT+OR9O0Pkwdl+K5EGyzvCcpbmWhj6uvFzJg5crFqWEs40JIxVC5LQCn5SysrLKu2P2zSyg8Uj4cxjs/Q5qDwALmVBPCCHylZQH8FVx02z7k9tgaZelqgMGDGDKlCns3LmTZs2aAeqPx65duxp6Ez/6w3Lo0KFs3ryZFStWZEtSKigoiFOnTnHt2jXDyaFFixZRpUoVDh8+TJ06dQgODubDDz+kYsWKAJQrV87w+uDgYLp27Uq1atUAKFu27AvHJHKQHBdG5s2bR+vWrXFxcQEgMDCQ+fPnM2HCBABmzZqFk5MTy5YtMyRiy5cvb3j9F198wciRIxk2bJihrE6dOlnefrqJEyfSsmVLw+MiRYrg5+dneDxp0iTWrFnD+vXrGTJkCBcvXmTFihVs3bqVFi1aAMbHXr9+/Rg/fjyHDh2ibt26pKSksHTp0gy9p4RI1ek5fTuGXRcjCDofzombUUbPF3Wwonmlorxc0YOGvq7YWhb4n6lCiDQFfvhenufXGxxLQtwd+Pc3U0cjhBCigKpYsSINGjQwXCjk8uXL7N69m4EDBwKg0+mYNGkS1apVo0iRItjb27N582aCg4OzZfvnzp3Dy8vLqLdy5cqVcXZ25ty5cwCMGDGCN998kxYtWvD1118bDV16//33+eKLL2jYsCGfffYZJ0+ezJa4ROGWG8eFTqdj4cKFvP7664ay119/nQULFqDX6wF1yFvjxo0NCalHhYeHc/v2bZo3b/4ibxWA2rVrGz2Oi4tj1KhRVKpUCWdnZ+zt7Tl37pzh/R0/fhwzMzOaNm2a6fqKFy9O27ZtDfvvzz//JCkpie7du79wrCJ/0+sVzt6O4dfdVxm44DA1Jm6l06y9TN960ZCQql7SieEtyvHnkEYcGNOcyV2q07KyhySkhChkTHrEx8XFGY03v3btGsePH6dIkSKUKlWKMWPGEBISwqJFiwx10sfLx8XFERERwfHjx7G0tKRy5cq5HX72MLeERsNh4yjY8y3U7APmebRnlxBCiIwsbNWeGaba9jMYOHAgQ4cOZdasWcyfPx8fHx/Dj80pU6bw3XffMWPGDKpVq4adnR3Dhw8nOTk5JyLP1IQJE+jduzcbNmzg77//5rPPPmPZsmV07tyZN998k8DAQDZs2MCWLVuYPHky06ZNY+jQobkWn3gGclwYbN68mZCQkAwTm+t0OoKCgmjZsiU2No8fnvSk5wC0WvUcs6I8nA06JSUl07p2dsY9yEaNGsXWrVuZOnUqvr6+2NjY0K1bN8P7e9q2Ad58803eeOMNvv32W+bPn0/Pnj2xtX22z0Dkf4qicDUynn1X7rL/SiT7r9zl/gPjv0NHa3PqlXXl5YpFebliUYo6yggRIYSJk1JHjhzhpZdeMjxOn/upb9++LFiwgNDQ0AxnomrUqGG4f/ToUZYuXUrp0qW5fv16rsScI2q8AbunQUwIHF+iDuMTQgiRP2g0WR4qZGo9evRg2LBhLF26lEWLFjF48GDDPDp79+6lY8eOht4cer2eixcvZttJn0qVKnHz5k1u3rxp6C119uxZoqKijLZRvnx5ypcvzwcffECvXr2YP38+nTt3BsDLy4tBgwYxaNAgxowZwy+//CJJqbxKjguDuXPn8uqrrzJ27Fij8i+//JK5c+fSsmVLqlevzsKFC0lJScnQW8rBwQFvb2+CgoKM2s3p3N3dAQgNDTW0kx+d9PxJ9u7dS79+/QzHWFxcnFGbulq1auj1enbu3GkYvvdfbdq0wc7OjtmzZ7Np0yZ27dqVpW2L/O/mvQfsv3KXfVci2XflLuGxSUbP21qaUbdMERr4uFK/rBuViztipn36fG9CiMLFpEmpZs2aGZ3V+a//Xg0FeGL9fMvCGhoOh00fw+7p4P+62oNKCCGEyEb29vb07NmTMWPGEBMTQ79+/QzPlStXjpUrV7Jv3z5cXFyYPn06YWFhz5yU0ul0GX4QW1lZ0aJFC6pVq8Zrr73GjBkzSE1N5d1336Vp06bUrl2bhIQEPvzwQ7p160aZMmW4desWhw8fpmvXrgAMHz6c1q1bU758ee7fv88///xDpUqVXnSXCJGjx0VERAR//vkn69evp2rVqkbP9enTh86dO3Pv3j2GDBnCzJkzefXVVxkzZgxOTk4cOHCAunXrUqFCBSZMmMCgQYMoWrQorVu3JjY2lr179zJ06FBsbGyoV68eX3/9NWXKlCE8PJxx48ZlKb5y5cqxevVq2rdvj0aj4dNPPzUMKQTw9vamb9++DBgwwDDR+Y0bNwgPD6dHjx4AmJmZ0a9fP8aMGUO5cuWoX79+lrYt8p+wmET2X7mrJqKuRnLzXoLR85bmWmqVcqGBjysNfF2pXtIZCzOZLUYI8WQyYDevqNVX7S0VfRNOLlOH8QkhhBDZbODAgcydO5c2bdpQvPjDiajHjRvH1atXCQwMxNbWlrfffptOnToRHR39TOuPi4sz6tUM4OPjw+XLl1m3bh1Dhw6lSZMmaLVaWrVqxcyZMwH1h+3du3fp06cPYWFhuLm50aVLFz7//HNATXa999573Lp1C0dHR1q1asW33377gntDCFVOHReLFi3Czs4u0/mgmjdvjo2NDYsXL+b9999n+/btfPjhhzRt2hQzMzP8/f1p2LAhoI4iSExM5Ntvv2XUqFG4ubnRrVs3w7rmzZvHwIEDqVWrFhUqVOCbb77hlVdeeWp806dPZ8CAATRo0AA3Nzc+/vhjYmJijOrMnj2bTz75hHfffZe7d+9SqlQpPvnkkwz776uvvqJ///5Z2i8if7gfn8yBq3fZl9Yb6kpEvNHz5loNfl7Oak8oH1dqlnLB2sLMRNEKIfIrjVIgux49XkxMDE5OTkRHR+Po6GjqcIzt+wG2jAUXbxhyFMwkZyiEEHlJYmIi165do0yZMlhby1wYBcmTPts83XbIRU/aD3JsFG67d++mefPm3Lx5Ew8Pj2xdt/xt5Z6YxBQOX7uXloS6y7lQ4wSlRgNVijvSwMeN+j6u1PEugr2V/F4RQmQuq+0n+S+Sl9TuD3umw/3rcOoP8O9l6oiEEEIIIYTIVFJSEhEREUyYMIHu3btne0JK5KwHyakcuX6f/Wm9oU7dikL/n+4K5T3sDUmogDJFcLaVKUaEENlLklJ5iaUdNBgK2ybArilQvQdopQusEEIIIYTIe37//XcGDhyIv7+/0dWyRd6UlKrj3+Ao9l25y4Erd/n35n1SdMZZKG9XW+qnJaHqlS1CUQfpnSaEyFmSlMpr6rwJe7+De1fg9Gqo3t3UEQkhhBBCCJFBv379jCaGF3lLqk7PyZBowxXyjly/T1Kq3qhOcSdr6vu4GeaFKu5sY6JohRCFlSSl8horB6j/Hmz/Qu0tVbUraOWqFUIIIYQwNmvWLKZMmcKdO3fw8/Nj5syZ1K1b97H1Z8yYwezZswkODjZMlD158mSZp0eIAkKvVzgbGmNIQh2+fp+4pFSjOm72VoYEVAMfV0oVsUWj0ZgoYiGEkKRU3lT3bdg3EyIvwLl1UKWzqSMSQgghRB6yfPlyRowYwZw5cwgICGDGjBkEBgZy4cIFihYtmqH+0qVLGT16NPPmzaNBgwZcvHiRfv36odFomD59ugnegRDiRUXEJnH6djSnb0VzMiSaQ9fuEZ2QYlTH2daCemVcaeDrSv2yrvgWtZcklBAiT5GkVF5k7QQBg2Hn17BzClTqKL2lhBAiD9Hr9U+vJPKV/PaZTp8+nbfeeov+/fsDMGfOHDZs2MC8efMYPXp0hvr79u2jYcOG9O7dGwBvb2969erFwYMHszWu/LYfRd4nf1OgKAp3YhI5HRLDqZBozoREc/p2NGExSRnq2luZE1CmCPXTekNVKuaIVitJKCFE3iVJqbyq3iDYPwvCz8CFDVCpvakjEkKIQs/S0hKtVsvt27dxd3fH0tJSzjjnc4qikJycTEREBFqtFkvLvH9lqeTkZI4ePcqYMWMMZVqtlhYtWrB///5MX9OgQQMWL17MoUOHqFu3LlevXmXjxo288cYb2RKTHBsiu+XHYzM7KIrCrfsJnE5LPJ0KieFMSDR345Mz1NVowMfdnqrFHalawolapV2oVsIJczM5mS2EyD8kKZVX2bhAwDuweyrs/B9UbKd+8wghhDAZrVZLmTJlCA0N5fbt26YOR2QjW1tbSpUqhTYf9EyOjIxEp9Ph4eFhVO7h4cH58+czfU3v3r2JjIykUaNGKIpCamoqgwYN4pNPPnnsdpKSkkhKetgTIyYm5rF15dgQOSU/HZvPSq9XuH43ntO31cTTqZBoTodEE5OYmqGumVZDuaL2VC3hRNXijlQr6UTFYo7YWcnPOSFE/ib/xfKy+u/Bgdlw5xRc3AQVWps6IiGEKPQsLS0pVaoUqamp6HQ6U4cjsoGZmRnm5uYFumfPjh07+Oqrr/jxxx8JCAjg8uXLDBs2jEmTJvHpp59m+prJkyfz+eefZ3kbcmyI7FbQjk1FUTgXGsufJ29z9Pp9ztyOJj4547FiYaahQjEHqpVwokpxJ6qWcKJiMQesLcxMELUQQuQsSUrlZbZFoO5bsHeG2luqfCvpLSWEEHmARqPBwsICCwsLU4ciCiE3NzfMzMwICwszKg8LC6NYsWKZvubTTz/ljTfe4M033wSgWrVqxMfH8/bbbzN27NhMe6GMGTOGESNGGB7HxMTg5eX1xNjk2BAio+C7D1h/IoR1x29zKTzO6Dkrcy2VPB2pWsLRkIQq7+GApXnB6xkmhBCZkaRUXld/CBz6GW7/C0cXQO3+po5ICCGEECZkaWlJrVq1CAoKolOnToA6GXRQUBBDhgzJ9DUPHjzIkHgyM1N7XSiKkulrrKyssLKyyr7AhShEImKT2HDyNutO3Obf4ChDuaW5lpcrFKV5paJUL+mMj7udzAElhCjUJCmV19m7w0ufwJZxsPkTKNMEXH1MHZUQQgghTGjEiBH07duX2rVrU7duXWbMmEF8fLzhanx9+vShRIkSTJ48GYD27dszffp0atSoYRi+9+mnn9K+fXtDckoI8WJiE1PYciaMdSdus/dyJDq9mvDVaqCBjxsd/IsTWKUYTjbSk1AIIdJJUio/qPceXNwM13fD6rdhwGYwk49OCCGEKKx69uxJREQE48eP586dO/j7+7Np0ybD5OfBwcFGPaPGjRuHRqNh3LhxhISE4O7uTvv27fnyyy9N9RaEKBCSUnXsuBDB+uO32XYujKRUveE5Py9nOvoVp111T4o6WpswSiGEyLs0yuP6bBdQMTExODk5ER0djaOjo6nDybqomzC7ISRFQ7NPoNnHpo5ICCGEKBTybdshm8l+EEKl0yscvHqXdcdvs/F0KLGPXC2vrLsdnfxL0MGvON5udiaMUgiRJXo9xIUBCphbg7mVequVXsQvKqvtBuluk184e0HbqbD6LXXSc98WULKWqaMSQgghhBCiwFMUhdMhMaw9HsKfJ24THptkeK6YozUd/IvTwa84VYo7FpirBQpRYCTHw/0bcP863L+m3t5Lu426AbrkjK/RmhsnqZ711sIG7NzB3kNdHIqpjyXZlYEkpfKTat3hwt9wZrWanBq0GyzlDIwQQgghhBA5IfjuA1b/e4v1x29zNTLeUO5kY0Gbap509C9OXe8iaLWSiBLCZBRF7e30aLLp0QRUXNiTX68xU69yr3/Y6xF9KiTHqUt20WjTElVFwb4YOHik3RbLWGaRjUN+FQVSEyElAVIeQEqiepuadluqvppMMxFJSuUnGg20nQbBB+DeFdjyKbSbbuqohBBCCCGEKDAURWHflbvM33uNoPPhpE92Ym2hpWXlYnT0K06T8u5YmstV84TIFXodxEdAbCjE3oGo4IwJqNSEJ6/D2hlcvKFIGfXWJf3WG5xKqj2YdKmgS4LUJDVhk5r4yP2n3f6nLDke4sLVhFhcmBq/on/4mFNPidfJuJeVvQfYOKvrTkl4uKQm/CfZlEnZ0/bNB2fUfWAikpTKb2yLQKcf4bdOcGQulG8F5V8xdVRCCCGEEELkawnJOtYeD2HB3utcCIs1lDcu50bXmiVpWdkDOyv5+SREtjFKNoU9TDrF3VFv08vjw9WEzpNotGpiJT3RlJ50Sk9C2bg8PR4zc3XJidFIulR4EJn2/sLT3mPYw/f6aJkuCRKj1SXyYvbGobUAC1t1eKGFtXr/afs2h8l/1fzI5yUIGAwHZ8O69+DdA2DnauqohBBCCCGEyHduRyXw24Eb/H4omKgHKQDYWprRrVZJ+jbwxsfd3sQRCpEL4iLg1qG0BIVGHaVD2rDU9PuZlvHIcxjX02gg+YGaXIp7JOmUvmQl2ZROowW7omqvofTk06O9npy8wNwym3ZGDjAzV2N3KPbkeooCiVFpCau0JfaOepsYrSaTzNOSSelJJQsbMLdJSzQ9shjK0uqa26hx5DF5LyKRNS0+g6v/QMR5+PN96Ln4kX8EQgghhBBCiMdRFIWjN+4zf991Np2+g06vjtHzKmJD3/redK/thZONhYmjFCIX3L0C+2bC8aVqD53c9miyycFTnVPJwTNt2Jrnw0ROYZkkXKNRe3XZuEDRiqaOJldIUioHJKfqc36MuYUNdPkZfmkO5/+C40ugxus5u00hhBBCCCHysaRUHRtOhjJ/73VOhUQbyuuXdaV/Q2+aV/LATCYtL7wURU3SWDmoyZGC7NYR2DsDzv0FpE2c5lZBncsI1DJFeeT2P2XwyPNkUpb22NxKkk3iiSQplc3+OHKT74IusWpwAzwcs3HG/Mx4+sFLn0DQ5/D3x1C6odqFUQghhBBCCGEQEZvEkoM3WHwgmMg4tTeIlbmWTv4l6NfQm0qejiaOUJiEokDEBbi+G67vUZcHkYAGvBupVz+v3CFr8xHlB3o9XNoC+76HG3sflpdvBQ2HqVdhk9E3IpdJUiobJafqmbvnGrfuJzBk6TGWvlUPC7Mc7jHVcBhc2grB+2DNIOi/UTLNQgghhBBCAKdDopm39xp/nQglWafOXVPM0Zo36pemV91SFLHLw3PQiOz32CTUI8ys1GFs13ery4aRUK4lVO0KFVrnzCTYOS01GU79oSajIs6rZVoLqN4TGgwtNMPERN6kURRDX7xCISYmBicnJ6Kjo3F0zP4zItci4+kwcw+xSam82agM49pVzvZtZHD/BsxuCMmx0Hw8NB6Z89sUQgghComcbjvkF7IfRH6RqtOz+UwYC/Zd4/D1+4bymqWc6d+wDK2qFsv5E8cib8hKEsrcBrzqgndjtXdUiZrqpNKnV8GplRB2+mFdCzuo2BaqdQOfl8Esj887lhgNRxfAgdnqJOMAlg5Quz/UGwyOxU0anijYstpuMGlSateuXUyZMoWjR48SGhrKmjVr6NSp0xNfs2PHDkaMGMGZM2fw8vJi3Lhx9OvXL8vbzI0G1abTdxi0+CgAP75WkzbVPHNkO0b+XQLr3gWtObwZBMX9c36bQgghRCEgyRiV7AeR10U/SGHpoWB+23+d29GJAFiYaWhbzZP+Dcvg5+Vs2gBFzvtvEurGXoiPMK5jbg1eAcZJKHOrx68z7CycXqkmqKJuPCy3KQJVOkHVbuqwN20eSnTG3FYTUUcXQFKMWubgqSaiavV7ZN4oIXJOVtsNJh2+Fx8fj5+fHwMGDKBLly5PrX/t2jXatm3LoEGDWLJkCUFBQbz55pt4enoSGBiYCxFnTauqxXinSVl+2nWVj1aepGIxB8rm9KVk/XvDxb/h3J+w+m14Z6c6GboQQgghhBAF2P34ZObuucbCfdeJTUoFwNXOktcCSvF6vdIUzel5XoXpKApEXjTuCfWiSaj/8qgMHuPh5U/VycFP/QFnVqvbOTJPXRxLqMP7qnWDYtVNNy9T+Dn1SnonV4A+RS1zr6gO0avW/dnetxC5JM8M39NoNE/tKfXxxx+zYcMGTp9+2IXy1VdfJSoqik2bNmVpO7l1li9Vp6f3rwc5dO0eFTwcWPNeA2wtczgHGH8XZtdXu5sGDILW/8vZ7QkhhBCFgPQQUsl+EHlNZFwSv+y+ym/7b/AgWQdAxWIODGxUhvZ+xbG2kHlWC6y7V+DEMji5DKKCjZ970SRUVuhS4foutffUuT8f9kYCcCuvJoCqdgVXn+zdbmYUBW7sU+eLuvjIb+JSDdT5h8u9krd6cYlCI1/0lHpW+/fvp0WLFkZlgYGBDB8+/LGvSUpKIikpyfA4JibmsXWzk7mZlh961aDtzD1cCItl7JrTTO/hhyYns+Z2rtBxFizpBgfnQPlAdayzEEIIIYQQBUR4TCI/77rK4oM3SExRJy+vUtyR95uXo2UlD7RauXpYgZRwH86sUZNRNw8+LM+NJNR/mZmrv7N8Xoa209Ur2p36Ay5uVntu/fOluhSvmZag6gIOxbI3Br0Ozm+Avd9ByJG0Qg1UagcNhoFXnezdnhA5JF8lpe7cuYOHh4dRmYeHBzExMSQkJGBjk3G42uTJk/n8889zK0QjRR2t+aFXDXr/epA1/4ZQq7QLr9crnbMbLdcS6rwJh3+Fte/C4H1gWyRntymEEEIIIUQOC41O4KedV1l6KJjkVDUZ5eflzLDmvrxUoWjOnvwVpqFLgSvb4fhSuPC3elU8AI1WTQj59YIKbcDS1nQxWlhD5Q7qkhitJopO/QFXd8DtY+qy+ROwtFfj1mrVW40WNGZpZWbqkL8MZVrj5dGy2NCHvcTMrMC/F9QfCm6+ptsXQjyHfJWUeh5jxoxhxIgRhscxMTF4eXnl2vYDyrrycasKfLXxPBP/PEu1Ek45P8liy0lwdSfcvQR/fQDdF5huXLMQQgghhBAv4Nb9B8zZeYUVh2+RrFOTUbVKu/B+83I0KecmyaiCKPSk2iPq1ArjOaKKVlYTUdW6g2MuXEzqWVk7qXP9+veGuHA4s1ZNUN06pF4pPSe2V+ctCHgH7Itm//qFyAX5KilVrFgxwsLCjMrCwsJwdHTMtJcUgJWVFVZWpp3Q7a3GZTl64z6bz4Tx7pJj/DW0ES52ljm3QUtb6PIzzG0JZ9eqE9359cy57QkhhBBCCJHNgu8+4Mcdl1l59BapenUa3IAyRRjWvBz1fVwlGVXQxIapSagTyyDs4RzC2LqpSSj/XqadRPxZ2ReFgLfVJS5CnXdKUUDRg6JTb/Vpt48uRmXp9fQZy7Tm6pBFqxy+oJYQOSxfJaXq16/Pxo0bjcq2bt1K/fr1TRRR1mg0GqZ09+PCnT1cv/uA4cuPM79fnZwd716iJjT9WB3LvHEUlK4PzqVybntCCCGEEEJkg6sRccz65wprj4egS0tGNfR1ZejL5ahX1tXE0eVB0SHqfLJ6HTiVUK8E51QSHIuDvYc65CuvSkmACxvh+O9wJUhNtgCYWUKF1mqvKN8WYGZh2jhflL27ugghMjBpUiouLo7Lly8bHl+7do3jx49TpEgRSpUqxZgxYwgJCWHRokUADBo0iB9++IGPPvqIAQMGsH37dlasWMGGDRtM9RayzNHagtmv16Lzj3vZeTGCmdsvM6xFuZzdaKMR6qR7tw7DmsHQd33e/lISQgghhBCF1uXwWH7Yfpn1J26TlouiaXl33m/uS63SMkdqBnodHPoFtk+C5LjM62jNwcFTTVQ5Fk9LWpV8mLxyLAF27rl7dTZFgeADcOJ3dXhbUvTD50rWURNRVTrLvLhCFBImTUodOXKEl156yfA4fe6nvn37smDBAkJDQwkOfniJzzJlyrBhwwY++OADvvvuO0qWLMmvv/5KYGBgrsf+PCp5OvJlp2qM/OMEM4IuUqOUM03K52DG3MwcOv8EcxrDjT2wfxY0fD/ntieEEEIIIcQzOn8nhpnbL7PxVChKWjKqRaWiDHm5HP45PRdrfnX7OPw1HG7/qz4uWRdKBai9pmJC1NvYUNCnQvRNdXkcM0s1ceVU8pHkVUn1anHatJ+LigIoGD4gw/2nlT3yWoB7V9Vk1P3rD5938oLqPdVklEzSLUSho1GUR/9jFHwxMTE4OTkRHR2No6OjSWIYs/oUvx8KxsXWgr/eb0wJ58znw8o2RxfAn8PUL5y3/oFiVXN2e0IIIUQBkhfaDnmB7AeR3U6HRDNz+yU2n3k4Z2xgFQ+GvlyOqiWcTBhZHpYUB/98BQdnq0PdrJyg5edQs2/G3k56HcSFpSWqbj1MWKUnrWJCIPYOhoRRbrK0h8odwe9VKN0od3tqCSFyRVbbDflqTqmC4rP2lTkVEsXpkBjeXXKMFe/Uw8o8B4fV1ewLFzer47VXv6Umpiysc257QgghhBBCPMaNu/F8s+kCG06FAuq81W2qejLkZV8qeUrC87HOb4SNH6oJJoCqXSFwMjh4ZF5fa6b2enIsDtTJvI4uRe1R9biElaJPm1g8bS7c9PtPKnt0IvL/llnaQ6UOUKkdWNq9wM4QQhQUkpQyAWsLM2a/Vot2M/dw4mYUX244x8SOOdh7SaOB9t+rc0uFn1XHnQd+mXPbE0IIIYQQ4j/uxyfz/fZLLD5wgxSdojZRqxdn6Mu+lPNwMHV4eVd0CPz9EZz/S33sXBraTodyLV583WYW6sWQ5IJIQggTkX6SJuJVxJZve/oBsGj/DdYdD8nZDdq7Q4eZ6v39P8DVnTm7PSGEEEIIIYDEFB1zdl6hyZR/mL/3Oik6hSbl3dn4fmO+71VDElKPo9fBgTkwq66akNKaQ6MP4N0D2ZOQEkKIPEB6SpnQyxU9GPqyLzO3X2b0qlNU8nSkfE5+KVdorQ7lO7YQ1r4Lg/eCjXPObU8IIYQQQhRaer3C+hO3mbL5AiFRCYB64Z9P2lSkcbkcvNhPQRB6Qp0T9tGJzNvPAI8qJg1LCCGymySlTGx4i/L8GxzFnsuRDFp8lPVDGmFvlYMfS+BXcH23euWLP4dBt/kysaAQQgghhMhW+65E8tXGc5wOiQGgmKM1owIr0LlGCcy0mqe8uhBLioMdk+HAjw8nMm/xGdTqL212IUSBJP/ZTMxMq+G7V/3xdLLmakQ8H686SY5eENHKHjr/DBozOLsW/hoGen3ObU8IIYQQQhQal8JiGbDgML1/OcjpkBjsrcz5MLAC/4xqRrdaJSUh9SQX/oZZAepUG4oeqnSBIYegzkBJSAkhCiz575YHuNpb8UPvmphrNWw4Gcr8vddzdoNedaDLz6DRwrFF8NdwSUwJIYQQ+cysWbPw9vbG2tqagIAADh069Ni6zZo1Q6PRZFjatm2bixGLgiw8JpExq08SOGMX28+HY67V0Kd+aXZ82Iz3XvLFxjIHrzSdExQFom7C2fXw72K4tlt9rNdl/7ZibsPy1+H3V9Ur6zmXgtdWQvf54FAs+7cnhBB5iAzfyyNqlXZhXNtKTPjzLF9tPIeflxO1ShfJuQ1W66Z+2a55W51jSqOBtt/KWRghhBAiH1i+fDkjRoxgzpw5BAQEMGPGDAIDA7lw4QJFixbNUH/16tUkJycbHt+9exc/Pz+6d++em2GLAig+KZWfd13ll91XeZCsJmwCq3jwcauKlHW3N3F0zyAmVJ2/6dHlQWTGemaWatLIxRtcyqi3RdJuXbzB0i7r29Tr4PCvEDQJkmPVkQwNhkLTj8HSNnvelxBC5HEaJUfHiuU9MTExODk5ER0djaOjo6nDMaIoCu8vO86fJ27j4WjFhvcb42ZvlbMbPbkC1ryjdhGu1U8SU0IIIcR/5MW2Q0BAAHXq1OGHH34AQK/X4+XlxdChQxk9evRTXz9jxgzGjx9PaGgodnZZ+xGdF/eDMJ1UnZ4VR27x7baLRMQmAeDv5czYtpWo452DJ1azQ1wEhB43TkDFhmaspzEDj8pg6wZRNyAqGPSpT163XdH/JKoeSVg5FFNPBEMmE5nXgXYzoFjV7HqXQghhUlltN0hPqTxEo9HwdZdqnAuN4XJ4HO///i+/DQzI2bH31XuoPabWDoKjCwANtJ0uiSkhhBAij0pOTubo0aOMGTPGUKbVamnRogX79+/P0jrmzp3Lq6+++sSEVFJSEklJSYbHMTExzx+0KDAUReGfC+FM3nieS+FxAJQqYsvHrSrSploxNJo8NmfUg3v/SUAdh+ibGetptOBeEYrXeLh4VAELm4d19DqICYF71+D+dbifdpv+ODEK4sPV5VYmw2nNbcCltJqcurYrbSJzx7SJzAdI+1sIUShJUiqPsbMyZ87rNenww172XbnL9K0X+DCwYs5u1K+nervmHTg6Xz2D02aafDEKIYQQeVBkZCQ6nQ4PDw+jcg8PD86fP//U1x86dIjTp08zd+7cJ9abPHkyn3/++QvFKgqWU7ei+WrjOfZfvQuAs60F779cjtfrlcbSPA+0G/U6uLEPbh97mIS6fz2TihpwK2ecgCpW7elD77Rm6tA951JA04zPJ9xPS1Zdz5i4ir4FqQkQcV5dAKp0hlZfy7xRQohCTZJSeZBvUQe+7lqd93//l1n/XKFmKReaV/J4+gtfhF9PQIE1g+DIPNQeU9MedjEWQgghRIEwd+5cqlWrRt26dZ9Yb8yYMYwYMcLwOCYmBi8vr5wOT+RBt6MS+GbTedYevw2ApbmW/g28efclX5xsLEwcXZqURPi9J1zdkfE5lzLGCShPP7DOgSGoNi7qUrxGxudSk9UeWvevq0MB3SqAd8Psj0EIIfIZSUrlUR38inPsxn0W7LvOB8uP89fQxpRyzeEJD/1eTRvKNxiOpJ09lcSUEEIIkae4ublhZmZGWFiYUXlYWBjFij25x0V8fDzLli1j4sSJT92OlZUVVlY5PLelyNMSknX8vOsqs3deJjFFvVJzJ//ijAqsQEmXPDQRt14Hq99UE1IWtuDb4pEklL+aKDI1c0tw9VEXIYQQBpKUysM+aVOJE7ei+Dc4isFLjrLm3YY53zXavxegwNp31cSURgNtpkpiSgghhMgjLC0tqVWrFkFBQXTq1AlQJzoPCgpiyJAhT3ztH3/8QVJSEq+//nouRCryK0VR+OtkKJM3nuN2dCIAdbxdGN+uCtVKOpk4uv9QFPhrOJz7U70yXq9lUDaToXVCCCHypDww+Fs8jqW5lh9fq4mLrQVnbsew/EgmkzLmBP/e0OlHQKNepnbjh+oXvhBCCCHyhBEjRvDLL7+wcOFCzp07x+DBg4mPj6d///4A9OnTx2gi9HRz586lU6dOuLq65nbIIp84HRJNj5/2M/T3f7kdnUhxJ2t+6F2DFe/Uz3sJKYCgiXBskTpRede5kpASQoh8RnpK5XGeTjZ80LI849ed4fugS3SrWRIbS7Oc37B/bzURte49OPyLWtZmivSYEkIIIfKAnj17EhERwfjx47lz5w7+/v5s2rTJMPl5cHAw2v9csOTChQvs2bOHLVu2mCJkkcdFxCYxdfMFVhy9iaKAtYWWwU19ebtJ2dxpez6P/bNgz3T1frtvoXIH08YjhBDimWkUpXB1gYmJicHJyYno6GgcHXNggsMckJyqp/n0Hdy8l8BHrSrwbjPf3Nv4v4th3RBAgbpvQ+tvJDElhBCiUMmPbYecIPuhYEpO1bNg3zW+D7pMXFIqAB39i/Nxq4oUd7YxcXRPcPx3WDtIvd98PDQeadp4hBBCGMlqu0GG7+UDluZaRrQsD8CcHVeIfpCSexuv8Tp0mAlo4NDP8PfHMpRPCCGEECKfUxSFbWfDCJyxi682nicuKZVqJZxYOag+371aI28npC78rfbmB6j3HjQa8eT6Qggh8ixJSuUTHfxKUMHDgZjEVH7adSV3N17zjbTEFHDoJ9g0WhJTQgghhBD51KWwWPrMO8Sbi45wLTIeN3srvulWnXXvNaS2dxFTh/dkN/bBH/1A0YFfL3jlC+nFL4QQ+ZgkpfIJM62GDwMrADBv7zXCYxJzN4BHE1MH58CmMZKYEkIIIYTIR6IeJDNh/Rlafbeb3ZcisTTTMqipD/+MakqP2l5otXk8uXPnFCx9FVIToXwrtW2qlZ8zQgiRn8lE5/lI80pFqVnKmWPBUczcfplJnarmbgA1+6iJqD/fh4Oz1bNSgV/J2SkhhBBCiDwsVafn90PBTNt6kai0aSBeqezB2LaVKO1qZ+LosujeNVjcFZKioVR96L4AzCxMHZUQQogXJKcW8hGNRsNHrSoC8PuhYILvPsj9IGr1hfbfq/cP/Aibx0qPKSGEEEKIPGrv5Ujafr+HT9edIepBCuU97Fk8MICf+9TOPwmp2DD4rRPEhYFHVei1DCzy8JxXQgghskx6SuUz9cq60qS8O7suRvDttot829M/94Oo1RdQ4M9hcGCW2lNKxvMLIYQQQuQZN+7G8+WGc2w5GwaAs60FI1uWp1fdUpib5aPz0glRsLgL3L8OLt7w+iqwcTZtTEIIIbKNJKXyoY8CK7DrYgRrj4fwTtOyVCxmgssy1+qn9pD6azjs/0Etk8SUEEIIIYRJ6fUKM7ZdZM7OqyTr9JhpNbxRrzTDW5TD2dbS1OE9m5QE+L0XhJ0Gu6LwxhpwKGbqqIQQQmSjfHSaRKSrWsKJttU9URSYuvmC6QKp3R/afave3/8DbBknQ/mEEEIIIUwkVadn5B8n+H77ZZJ1ehqXc2PTsMZM6FAl/yWkdKnwR38I3gdWTvDGaihS1tRRCSGEyGaSlMqnRrYsj5lWw7Zz4Ry9cc90gdQeAG2nq/f3/wDbJpguFiGEEEKIQiopVcd7S4+x5t8QzLUapvfwY9GAupTzcDB1aM9Or4f1Q+Hi32BuDb2XQbFqpo5KCCFEDsgTSalZs2bh7e2NtbU1AQEBHDp06LF1U1JSmDhxIj4+PlhbW+Pn58emTZtyMdq8oay7Pd1rlQTgf5suoJiyh1KdgdB2mnp/7wzY+73pYhFCCCGEKGQSknW8vegom8+EYWmuZc7rtehSsySa/DitgqLA1k/hxFLQmKlX2SvdwNRRCSGEyCEmT0otX76cESNG8Nlnn3Hs2DH8/PwIDAwkPDw80/rjxo3jp59+YubMmZw9e5ZBgwbRuXNn/v3331yO3PSGtSiHpbmWQ9fusfNihGmDqfMmtPhcvb/1Uzi+1LTxCCGEEEIUAnFJqfSbf4idFyOwsTBjfr86tKjsYeqwnt/eGQ/nK+04Cyq0Nmk4QgghcpbJk1LTp0/nrbfeon///lSuXJk5c+Zga2vLvHnzMq3/22+/8cknn9CmTRvKli3L4MGDadOmDdOmTcvlyE3P08mGvvVLAzBl8wX0ehPP59RoODQYqt5fNwQu/G3ScIQQQgghCrKoB8m89utBDl67h4OVOb8NrEtDXzdTh/X8ji58OBXEK1+Cfy+ThiOEECLnmTQplZyczNGjR2nRooWhTKvV0qJFC/bv35/pa5KSkrC2tjYqs7GxYc+ePTkaa141uJkv9lbmnLkdw4ZToaYOB1pMBL/eoOjgj35wI/PPUQghhBBCPL+I2CRe/fkAJ25G4WJrwdK36lHbu4ipw3p+Z9erV3UGaPQBNBhi0nCEEELkDpMmpSIjI9HpdHh4GHcx9vDw4M6dO5m+JjAwkOnTp3Pp0iX0ej1bt25l9erVhIZmnpBJSkoiJibGaClIithZ8lZj9Uok07deJEWnN21AWi10+B7Kt4LURFjaE+6cNm1MQgghhBAFSGh0Aj1/2s/5O7G4O1ix/J36VCvpZOqwnt+1XbBqICh6qNkHmn9m6oiEEELkEpMP33tW3333HeXKlaNixYpYWloyZMgQ+vfvj1ab+VuZPHkyTk5OhsXLyyuXI855AxuXwdXOkmuR8aw8esvU4YCZBXSbD6XqQ1I0LO4K96+bOiohhBBCiHwv+O4Dus/Zz9XIeEo42/DHO/Upnx+vsJfu9nH4vTfokqFSe2j7LeTHCdqFEEI8F5Mmpdzc3DAzMyMsLMyoPCwsjGLFimX6Gnd3d9auXUt8fDw3btzg/Pnz2NvbU7Zs2UzrjxkzhujoaMNy8+bNbH8fpmZvZc57L/kC8N22SySm6EwcEWBpC71+h6JVIO4O/NYZ4jKfvF4IIYQQQjzd5fBYuv+0j1v3EyjjZseKQfXxdrMzdVjPL/KyevIyORa8G0OXX8HM3NRRCSGEyEUmTUpZWlpSq1YtgoKCDGV6vZ6goCDq16//xNdaW1tTokQJUlNTWbVqFR07dsy0npWVFY6OjkZLQfRavVKUcLbhTkwii/ZfN3U4KhsXeH0VOJeCe1fVRkdiwRo+KYQQQgiRG87cjqbHTwcIi0migocDy9+pRwlnG1OHlXVJsRB5Ca7uhBPLYc8M9aTlg0jw9INXl4KF9VNXI4QQomAx+amIESNG0LdvX2rXrk3dunWZMWMG8fHx9O/fH4A+ffpQokQJJk+eDMDBgwcJCQnB39+fkJAQJkyYgF6v56OPPjLl2zA5K3Mzhrcox4crT/Ljjiu8WrcUjtYWpg4LHD3hjbUw9xW4cxKW9YbXVkqjQwghhBAii44F36ffvEPEJKZSrYQTiwbUxcXO0tRhqVKT1V7xMaEQGwqxdyD2tnobk3Ybe0ftDZUZV194bRVYF8wTx0IIIZ7M5Empnj17EhERwfjx47lz5w7+/v5s2rTJMPl5cHCw0XxRiYmJjBs3jqtXr2Jvb0+bNm347bffcHZ2NtE7yDu61CzJT7uucjk8jl93XWXEKxVMHZLK1UftMbWgHVzfDavfhO4LQWtm6siEEEIIIfK0fVcieXPhER4k66jj7cLcfnVy/8RjYjRc+Fvt+Z6eeEpPQj2IzPp6rBzBoRg4eKqLcymoMxDs3XMudiGEEHmaRlEUxdRB5KaYmBicnJyIjo4ukEP5Np0OZdDiY9hamrHzw5dwd7AydUgPXdulDuHTJUOtftBuhkxkKYQQIs8r6G2HrJL9kPv+OR/OoMVHSUrV07icGz+9UQtby1w6p6wocH0P/LsYzq6D1ITH1zWzNE42OXiqveUffexQDKzscyd2IYQQJpfVdoPJe0qJ7BVYpRh+JZ04cSuaWf9cZkKHKqYO6aEyTaDrXPijLxxdALZu0PxTU0clhBBCCJHn/H0qlPeX/UuKTqFFJQ9+6F0Da4tc6GUecxuOL4F/l8D9aw/L3SpA6QaZJ5xsi8iJRiGEEM9FklIFjEaj4aNWFXnt14MsPRjMwEZl8Cpia+qwHqrcAdpOh7+Gw+6pYOcG9QabOiohhBBCiDxj1dFbfLjyBHoFOvgVZ1oPPyzMcvD6RKnJcPFvOPYbXAkCRa+WWzpA1S5Q4w0oWVsST0IIIbKdJKUKoIa+bjT0dWXv5bvM2HaJaT38TB2Ssdr91fkHtn8Bm0aDrStU72HqqIQQQgghTO63Azf4dO1pAF6t48WXnathps2hZFDYWXV43sll8ODuw/JSDaDmG1C5I1ja5cy2hRBCCCQpVWB9GFiRvZf3subfWwxqWpZyHg6mDslY41EQfxcOzoa1g8GmCJRrYeqohBBCCCFM5qedV5j893kA+jf0Zny7ymiyu3dSYjScXqUmo0KOPiy3Lwb+vcD/dXDzzd5tCiGEEI8hSakCyt/LmcAqHmw+E8bULRf46Y3apg7JmEYDgV+pPaZO/QEr3oA+68CrrqkjE0IIIYTIVYqi8O22S3wfdAmAIS/5MvKV8tmXkFIUuLFXHZ736KTlWnMo30odnufbAszkp4EQQojcJd88BdioVyqw9WwYm8+EcfxmFP5ezqYOyZhWCx1/hIT7cHkbLOkOAzZB0UqmjkwIIYTIdt7e3gwYMIB+/fpRqlQpU4cj8ghFUfhywzl+3aNOKv5Rqwq82yybeirF3IbjS9VeUf+dtLzmG1C9J9gXzZ5tCSGEEM8hB2dMFKZWzsOBLjVLAvDNpvMmjuYxzC2hxyIoWQcSo+C3LhB109RRCSGEENlu+PDhrF69mrJly9KyZUuWLVtGUlLSc69v1qxZeHt7Y21tTUBAAIcOHXpi/aioKN577z08PT2xsrKifPnybNy48bm3L7LH53+eNSSkPu9QJXsSUle2qyf7vq0C2yepCSlLe6jZBwZug/cOQoOhkpASQghhcpKUKuCGtyiHpZmWfVfusudSpKnDyZylHfReAe4VIfY2/NZZnW9KCCGEKECGDx/O8ePHOXToEJUqVWLo0KF4enoyZMgQjh079kzrWr58OSNGjOCzzz7j2LFj+Pn5ERgYSHh4eKb1k5OTadmyJdevX2flypVcuHCBX375hRIlSmTHWxPPadPpUBbsu45GA990q07fBt4vvtJzf6ltqUtb1KvolWoAnWbDqIvQYSZ41ZGr6AkhhMgzNIqiKKYOIjfFxMTg5OREdHQ0jo6Opg4nV0xYf4YF+65TvaQT695rmP0TZmaX6BCY+wrE3ILiNaHverDKYxO0CyGEKHRyqu2QkpLCjz/+yMcff0xKSgrVqlXj/fffp3///k/9rg4ICKBOnTr88MMPAOj1ery8vBg6dCijR4/OUH/OnDlMmTKF8+fPY2Fh8VzxFsY2VE4Kj00k8Ntd3H+QwuBmPnzcquKLrzTsjNqWSo6Dql2h2ScyabkQQgiTyGq7QXpKFQJDXvbF1tKMk7ei2XT6jqnDeTynEvDGGvVKfLePwfLXIfX5hzUIIYQQeVFKSgorVqygQ4cOjBw5ktq1a/Prr7/StWtXPvnkE1577bUnvj45OZmjR4/SosXDq9ZqtVpatGjB/v37M33N+vXrqV+/Pu+99x4eHh5UrVqVr776Cp1O99jtJCUlERMTY7SI7KEoCh+vPMn9BylU9nTkgxblX3yl8Xfh915qQqpME+j8kySkhBBC5HmSlCoE3OyteLNRGQCmbrlAqk5v4oiewL08vLYSLOzg6g5Y8w7oUk0dlRBCCPHCjh07ZjRkr0qVKpw+fZo9e/bQv39/Pv30U7Zt28aaNWueuJ7IyEh0Oh0eHh5G5R4eHty5k/nJp6tXr7Jy5Up0Oh0bN27k008/Zdq0aXzxxReP3c7kyZNxcnIyLF5eXs/+pkWmlh4K5p8LEViaa5nxqj+W5i/YJNelwB99IeoGuHhD94Vg9nw94oQQQojcJEmpQuLNJmVxtrXgSkQ8q/8NMXU4T1ayFry6GLQWcGYN/K+0OgH6rqlwY7/0nhJCCJEv1alTh0uXLjF79mxCQkKYOnUqFSsaD9kqU6YMr776arZvW6/XU7RoUX7++Wdq1apFz549GTt2LHPmzHnsa8aMGUN0dLRhuXlTLkSSHa5FxvPFX+cA+LhVRcp7ZMNUBZs/geu71cnMX/0dbIu8+DqFEEKIXGBu6gBE7nC0tuC9Zr58ufEc3227RAe/4lhbmJk6rMfzeRm6zYM/h0HCPbgSpC4A5tbq1fpKN1CXknXUydKFEEKIPOzq1auULl36iXXs7OyYP3/+E+u4ublhZmZGWFiYUXlYWBjFihXL9DWenp5YWFhgZvbwu79SpUrcuXOH5ORkLC0tM7zGysoKKyurJ8Yink2qTs8Hy4+TkKKjgY8r/bNjYvOjC+DQz+r9Lj+DR+UXX6cQQgiRS6SnVCHyRv3SFHO0JiQqgSUHg00dztNV7gAfXoZBe6D1N1C5I9i5Q2qiejZw5/9gUUf4uhT82gK2fgYXt0BitKkjF0IIITIIDw/n4MGDGcoPHjzIkSNHsrweS0tLatWqRVBQkKFMr9cTFBRE/fr1M31Nw4YNuXz5Mnr9wyH8Fy9exNPTM9OElMgZs/65wvGbUThYmzO1ux9a7QtefObGftgwSr3/0jio2PbFgxRCCCFykSSlChFrCzOGtSgHwKx/LhOXlA/matKaQbFqEPAO9FgEoy7BkCPQbgZU6wGOJUCfCrcOw94ZsLQ7/M8b5jSGv0fDuT8hPtLEb0IIIYSA9957L9MhcCEhIbz33nvPtK4RI0bwyy+/sHDhQs6dO8fgwYOJj4+nf//+APTp04cxY8YY6g8ePJh79+4xbNgwLl68yIYNG/jqq6+eebvi+Z24GcX32y8B8EWnqhR3tnmxFUbdVC8Ko0+Byp2gyagXD1IIIYTIZTJ8r5DpXqskP++6yrXIeObuvmZIUuUbGg24lVOX2v1BUSAqGG7sgxt71Nt7V+HOSXU5OFt9nXvFtOF+DdXF0dO070MIIUShc/bsWWrWrJmhvEaNGpw9e/aZ1tWzZ08iIiIYP348d+7cwd/fn02bNhkmPw8ODkarfXju0cvLi82bN/PBBx9QvXp1SpQowbBhw/j4449f7E2JLElI1vHB8uPo9ArtqnvSwa/4i60wOR6W9YIHkerJu04/qm0kIYQQIp/RKIqimDqI3BQTE4OTkxPR0dE4OjqaOhyT+OvkbYYs/Rcrcy3L36mPv5ezqUPKXjGhELxPTVBd3wsR5zLWKdsMavZVu7mby3wZQgghHi+72g6urq789ddfGYbY7du3j7Zt23L//v0XDTVHSRvq+Y1fd5pF+29QzNGaTcMb42z7AkMmFQX+6Adn14KtG7y9A5zlyohCCCHylqy2G2T4XiHUpqonL1csSlKqnjcXHiEkKsHUIWUvR0+o2hXaToP3DsCHV6HnEqj3Hnj6qXWu7oCV/WFaRdj0CYSfN2nIQgghCr5XXnnFcEW7dFFRUXzyySe0bNnShJGJnLTjQjiL9t8AYEr36i+WkALYPVVNSGktoOdvkpASQgiRr0lPqUIqLimVbrP3cf5OLBWLOfDHoPo4WFuYOqzccf86/LsE/l0MsbcflnsFQM0+UKWzXM1PCCGEQXa1HUJCQmjSpAl3796lRo0aABw/fhwPDw+2bt2Kl1feTi5IG+rZ3Y9PJnDGLsJjk+jXwJsJHaq82ArPb4BlvdX77b+DWv1eOEYhhBAiJ2S13SBJqULsdlQCHWftJSI2iWYV3Pm1T23MzQpR5zldKlwJgmOL4MLfoOjUcksHqNZNTVAVryFzNAghRCGXnW2H+Ph4lixZwokTJ7CxsaF69er06tULC4u8f2JI2lDPRlEU3lt6jI2n7uDjbseG9xtjbWH2/CsMOwtzW0JyHNR5C9pOzb5ghRBCiGwmSanHkAaVsZO3oujx034SU/TZcwYvv4q9A8eXqgmq+9celntUg1p91SSVjYvp4hNCCGEy0nZQyX54NquP3WLEihOYazWsebch1Uo6Pf/KHtyDX15Se3t7N4Y31oBZ3k9kCiGEKLwkKfUY0qDKaNPpUAYtPgbAhPaV6dewjIkjMiG9Hm7shWML4ex60CWp5ebWULmjOjl66QbSe0oIIQqR7G47nD17luDgYJKTk43KO3To8MLrzknShsq6W/cf0HrGbmKTUhn1SnmGvPwCVzvWpcDiLnBtFziXhrf+ATvX7AtWCCGEyAFZbTeY52JMIo9qVdWT0a0r8vXf55n411lKu9rxUsWipg7LNLRaKNNYXVrfg1N/wNGFEH4GTi5XF1dfqPEG+PcG+0K6n4QQQjyzq1ev0rlzZ06dOoVGoyH9vKAm7USHTqczZXgim+j1CiNXnCA2KZWapZwZ1NTnxVa4eayakLKwg16/S0JKCCFEgfJcEwjdvHmTW7duGR4fOnSI4cOH8/PPP2dbYCJ3vdOkLD1re6FXYMjSY5wLjTF1SKZnWwQC3oHBe+HN7WovKUt7uHsZtn0G0yvB8tfh0lbQyw8JIYQQTzZs2DDKlClDeHg4tra2nDlzhl27dlG7dm127Nhh6vBENpm75xoHr93D1tKMb3v6v9h8nUcXwqGf1PtdfgKPQjrNghBCiALrub4le/fuzT///APAnTt3aNmyJYcOHWLs2LFMnDgxWwMUuUOj0TCpU1Xql3UlPlnHwAWHCY9NNHVYeYNGAyVrQYfvYeQF6DATStYBfSqc+xOWdINZdSHigqkjFUIIkYft37+fiRMn4ubmhlarRavV0qhRIyZPnsz7779v6vBENjh/J4Ypm9X2wPh2lSnt+gJX872xHzaMVO+/NBYqtc+GCIUQQoi85bmSUqdPn6Zu3boArFixgqpVq7Jv3z6WLFnCggULsjM+kYsszbXMeb0WZd3tuB2dyFsLj5CQLD2AjFjZq1fle3MbDN4P9d5VJ0C/e1m9Is71PaaOUAghRB6l0+lwcHAAwM3Njdu3bwNQunRpLlyQExv5XVKqjuHLjpOs09OiUlF61vF6/pVF3YQVb4A+RZ3TssmH2ReoEEIIkYc8V1IqJSUFKysrALZt22aYmLNixYqEhoZmX3Qi1znZWjCvbx1cbC04cSuaESuOo9cXqrnws86jMrSaDEOOglcAJEbDb53h5B+mjkwIIUQeVLVqVU6cOAFAQEAA33zzDXv37mXixImULVvWxNGJFzV960XO34nF1c6SyV2qG+YKe2bJD2BZb4iPUK8C3Gm2XGBFCCFEgfVcSakqVaowZ84cdu/ezdatW2nVqhUAt2/fxtX12SdfnDVrFt7e3lhbWxMQEMChQ4eeWH/GjBlUqFABGxsbvLy8+OCDD0hMlKFm2cXbzY6f3qiNpZmWv0/fYcoWOXv7RHau0GcdVOoAumRY/Sbsng6F68KWQgghnmLcuHHo9XoAJk6cyLVr12jcuDEbN27k+++/N3F04kUcuHqXn3ddBWByl2q4O1g934oUBda9B3dOgq0b9FoKli8wBFAIIYTI454rKfW///2Pn376iWbNmtGrVy/8/PwAWL9+vWFYX1YtX76cESNG8Nlnn3Hs2DH8/PwIDAwkPDw80/pLly5l9OjRfPbZZ5w7d465c+eyfPlyPvnkk+d5K+Ix6pYpwv+6VQNg9o4rrDhy08QR5XEWNtB9IdQfoj4O+hz+Gg66VJOGJYQQIu8IDAykS5cuAPj6+nL+/HkiIyMJDw/n5ZdfNnF04nnFJKYwcsUJFAV61vbilSrFnn9lu6fBmdWgNYeev4FzqewLVAghhMiDNIryfN05dDodMTExuLi4GMquX7+Ora0tRYsWzfJ6AgICqFOnDj/88AMAer0eLy8vhg4dyujRozPUHzJkCOfOnSMoKMhQNnLkSA4ePMiePU+fzycmJgYnJyeio6NxdHTMcpyF1fQtF/h++2XMtRoWDaxLAx83U4eU9x38Cf7+GFCg3CvQbb46F5UQQoh8KTvaDikpKdjY2HD8+HGqVq2azRHmDmlDZW7kihOsOnaLUkVs2TisMfZW5s+3ovMb1WF7KNDuW6g9IFvjFEIIIXJTVtsNz9VTKiEhgaSkJENC6saNG8yYMYMLFy48U0IqOTmZo0eP0qJFi4cBabW0aNGC/fv3Z/qaBg0acPToUcMQv6tXr7Jx40batGmTaf2kpCRiYmKMFpF1H7QsT3u/4qTqFQYvPsaViDhTh5T3BbwDry4Bcxu4tAUWtIHYO6aOSgghhAlZWFhQqlQpdDq5gEhB8vepUFYdu4VWA9N7+D1/Qir8HKx+C1CgzpuSkBJCCFFoPFdSqmPHjixatAiAqKgoAgICmDZtGp06dWL27NlZXk9kZCQ6nQ4PDw+jcg8PD+7cyfxHfO/evZk4cSKNGjXCwsICHx8fmjVr9tjhe5MnT8bJycmweHm9wJVQCiGNRsOUbtWpWcqZ6IQUBiw4zP34ZFOHlfdVbAv9NqjzQYSegF9bqA1OIYQQhdbYsWP55JNPuHfvnqlDEdkgPCaRT9acAmBwMx9qexd5vhU9uAe/94LkOPBuDK2+zsYohRBCiLztuZJSx44do3HjxgCsXLkSDw8Pbty4waJFi3J8os4dO3bw1Vdf8eOPP3Ls2DFWr17Nhg0bmDRpUqb1x4wZQ3R0tGG5eVPmRnpW1hZm/NynNiVdbLhx9wHv/HaUpFQ50/tUJWvBm9vA1Reib8LcQLi2y9RRCSGEMJEffviBXbt2Ubx4cSpUqEDNmjWNFpF/KIrCR6tOcv9BClWKOzKsefnnW5FeD6sGwv1r6vxR3ReCmUX2BiuEEELkYc/Vx/jBgwc4ODgAsGXLFrp06YJWq6VevXrcuHEjy+txc3PDzMyMsLAwo/KwsDCKFct8kshPP/2UN954gzfffBOAatWqER8fz9tvv83YsWPRao3zbFZWVlhZPecVUISBm70V8/vVocuP+zh0/R5jVp9iWne/57/ccWFRpAwM3KrOERG8H37rAh1ngV9PU0cmhBAil3Xq1MnUIYhssuRgMDsuRGBprmVGT38szZ/rPC8c+gmubFeH/L/6u3pFXyGEEKIQea6klK+vL2vXrqVz585s3ryZDz74AIDw8PBnmvjS0tKSWrVqERQUZGio6fV6goKCGDJkSKavefDgQYbEk5mZGaCetRI5p5yHAz++XpN+8w+z+lgIZd3sGPJyOVOHlffZFoE31sLaQXBmDax5G6KDofEokKSeKIwUBcLPwsVNcGkb6FOgQmuo3AlcfUwdnRA55rPPPjN1CCIbXI2I48sN6pD80a0qUs7D4flWFH4Otqb9TQR+AcXy5wT4QgghxIt4rqTU+PHj6d27Nx988AEvv/wy9evXB9ReUzVq1HimdY0YMYK+fftSu3Zt6taty4wZM4iPj6d///4A9OnThxIlSjB58mQA2rdvz/Tp06lRowYBAQFcvnyZTz/9lPbt2xuSUyLnNC7nzsSOVRi75jRTt1zE282OdtWLmzqsvM/CGrrOAycv2Pc9bP8CooKh7fT81U0/NQluH1d7fQUfgLuXwbsR+L8GJWtLkk08XkqCOnz14mZ1ibll/PytwxA0ETyqQuWO6uJewTSxCiHEY6To9Hyw/DgJKToa+rrSr4H3860oNVmd2FyXBL4tofbAbI1TCCGEyC+eKynVrVs3GjVqRGhoKH5+foby5s2b07lz52daV8+ePYmIiGD8+PHcuXMHf39/Nm3aZJj8PDg42Khn1Lhx49BoNIwbN46QkBDc3d1p3749X3755fO8FfEcXgsozbWIeH7dc40RK05Q3NmGmqVcTB1W3qfVwiuT1Dkj/v4Iji2C6BDosRCsnvMsa05LjIabhx4moUKOQmqicZ27l+DofHXuLP/eUP1VcCphmnhF3hJ962ES6touSE14+Jy5NZRpCuUDQWsGZ9fDtZ0Qdlpd/vkS3Cs+TFAVrSxJT5HvabXaJw57lyvz5X0/77rKiVvROFqbM7W7H1rtc/5f2jEZ7pwCmyLQ8Qf5/yaEEKLQ0igvOObt1i31bHfJkiWzJaCcFhMTg5OTE9HR0c801FAY0+kV3vntKNvOheFmb8madxviVcTW1GHlHxf+hpUDIOUBFKsGvf8AR09TRwUxt+HGPjUBFXxATQ7wn38Rtm5Qqh6Uqg8upeHcX3BuvfpeANBA2WZq76mKbcFS/i4KDb0Obh1JG5a3Je3v5xGOJdUkVPlA9QpT//3beHBPPTbOrlPnWNGnPHzO1fdhgqpYdfkBJ3JVdrUd1q1bZ/Q4JSWFf//9l4ULF/L5558zcGDe7i1T2NtQKTo99SdvJzIuiand/ehW6znbvjf2w4I2oOihx29QuUP2BiqEEELkAVltNzxXUkqv1/PFF18wbdo04uLiAHBwcGDkyJGZTjaelxT2BlV2ik9KpcdP+zlzO4byHvasHNwAR+t8NBTN1EKOwdIeEB+h/lh/7Q/wqJx729frIfJiWi+otCUqOGM9lzJqAqp0ffXW1TdjQiApVk0kHF8KN/Y+LLd0gKqd1QSVV4AkEgqihPtwOUhNQl3aCgmPXOpeo4WSdaH8K1C+1bP1dkqIUntYnV0Hl7epQ1zSuXg/TFAVryl/V3o9hJ+BqzshNhQ8/cGrrtors7Dvm2yS022HpUuXsnz58gxJq7ymsLehNp0OZdDiY7jZW7F/zMtYmD1HezcxBuY0VL9v/XpD59nZH6gQQgiRB+RoUmrMmDHMnTuXzz//nIYNGwKwZ88eJkyYwFtvvZWnh9IV9gZVdrsTnUjHWXsIi0micTk35verg/nzNNIKq/vXYUl3NTlk5Qg9f1N7GeWE1GQIPa4mn27sh5sH1ITCozRatedWqbQEVKl64JD5lTAf6941OLEMTiw1TnIVKas2wP16qj+Wc4MuRY0hKVYdImnlqN6aW5n2x7ouFZJi1OGRidHq/eR4cCuv7qe8nEhQFIi4AJfShuUFHwDlkSFH1k7g20JNQvm2UCf6f1FJsQ8TVJe2Gg8DdPJ6mKAqUVsdJlvQKQrcvQLXdqjDIq/tNk4GprMvpianvALUxbO6+rcvnllOtx2uXr1K9erVDSf68qrC3obqO+8QOy9G8G4zHz5qVfH5VrLuPfh3MTiVgsF7wbrw7UchhBCFQ44mpYoXL86cOXPo0MG4u/G6det49913CQkJefaIc0lhb1DlhNMh0XSfs5+EFB09apfk6y7Vn3+OhcLowT1Y/rraw0hrDh1+AP9ez7aO5AdqD4mY24+5DYW4O6BPNX6duY06QXl6T6iSdbJvfiu9HoL3qb2nzqyFlPiHz5VpovaeqtQeLO1ebDuKor7Hu5fTlisP79+/nvE9g7qfrRyME1UZlszKHynTp6YllWLSEkxpSaakzMpiHimLfmSoYyacSkHZJlD2JXU/2Rd9sf3zohQFom6oiczg/XB1h/r4Ue4V1SF55QLV5IfZc01XmDXJ8Wpi6uw6NVH16N+VQ3F1GEylDmpCVVuALn4RfUvtCXVtl7rE3jZ+3sIOSjdQh9SGHIM7JzP+7ZtZQfEa4FXnYaIqJ/++Eu6rx2PkJePj894V9Rh08FSHLTsUT7v1BMfiD2/t3PPMZ5iTbYeEhATGjBnD33//zYULF7J13dmtMLehbt1/QONv/kFRYOeHzSjt+hzfXef+guWvARrov1E9ZoUQQogCKkeTUtbW1pw8eZLy5csblV+4cAF/f38SEhIe80rTK8wNqpy05cwdBi0+il6BbrVK8r+u1TGTxFTWpSbB2sFwepX6uNkn0PQjNSHw4K76AzQm9OFtzG3jssTorG3H1vVhD6hS9cHTL3eu/pcUB+f+hONL4Pruh+WW9lC5k5qEK9Xgyb1cHtyDe1cf+XH7yI/cJyV5zG3AxlmNITk2u95R9rCwVXsWWTmCuSWEnzeeRwmgaBW191zZpuoPmJyeFF+vg/Czag+o9PnF/psAMbNUE2blAtWheS7eORvT46QkqEMHz65T56J69PO1c1d7a1Vsq+4/CxvTxPi84iLUY+VaWiLq3lXj580s1aRSmSbqhPElahofy8kP1J6RNw+qFyu4eVD9X/JfLt5pCaq0HlVFKz9bIiglQe0defdSxqRwZtt7FlpzsPcwTlRldpsL89ZlV9vBxcXFaKJzRVGIjY3F1taWxYsXZzjZl9cU5jbU9K0X+T7oEg19XVnyZr1nX0FsGMyurx4XDYdDy8+zPUYhhBAiL8nRpFRAQAABAQF8//33RuVDhw7l0KFDHDx48NkjziWFuUGV09YdD2HEihPo9Aqd/IsztbufDOV7Fno9bJ8Ie75VH9sXUxuv/01SPI6FXea9Df57a+qhYfdvwMnlaoLq/vWH5c6lwa+XOuQr9vaz/cDVmKk/rl190xafh/cdPB8mu/R6SI5Th4Mlxabdj3n42LBkVvZIeWKMmgCwclSHXqTfpieYHr199HlDmZOaXPpvQjA5Xu2RdPUfNRlx55Tx81pztTdbmaZqoqVk7RdPKqYmqT1rgtMnuD+o9vb673aL11CTmaUbqpOUW9m/2HazW2oSXPlHnXT//F/GiVpzG/BtDhXaqIkqO1fTxfk4idFqEjC9N1T4GePnNVp1/qwyTdQEpVfAsyXaFEVNbN08mLYcVpOP/72QgaW9+ndVMi1JVbK2+rcafRMiM0kIR9/MuI5HORQHN99Hjk1fKOKjTvD832T7o70748LUOllh7aRux+dlaPVV1vfJM8iutsOCBQuMklJarRZ3d3cCAgJwccn7V7EtrG0onV6h0f+2ExqdyMxeNWjvV/zZVqAosLSnOuzZoxq8FSRDaYUQQhR4OZqU2rlzJ23btqVUqVLUr18fgP3793Pz5k02btxI48aNnz/yHFZYG1S5ZeOpUN7//V9S9QrtqnvybU//55sItDA7Mg82jHzkB5lG7fVhNMyluJpgerTMytH0CadnoShqEuT4EnV4X1Z6MTkUN044pS8upXOnx1dui49Uk1NXd2Y+bM7CDrwbqgmqMk3Terk85XhLiFJ7zqRPbh9yzHgScUhLTNRRe2aVqqfO1ZSfrqKoS1GHw57fCBc2piVO0mi04FUPKrZRk1SuPqaJ8cE9tSfTtbTeULf/zZiE8aia1hOqifpZWDtlbwyJ0erVEtN7Ut06kslxqFGPLV3y49dj5fRI4qncw2O0SNnnT17qUiE+PK1naMjjhyU/Onyzckfosej5tvcUebXtMGvWLKZMmcKdO3fw8/Nj5syZ1K1bN9O6CxYsoH///kZlVlZWJCYmZnl7eXU/5LTt58MYsOAILrYWHPikOVbmzzis9Mg8+OsDdQjt2zty96ImQgghhInkaFIK4Pbt28yaNYvz588DUKlSJd5++22++OILfv755+eLOhcU1gZVbtp85g5Dlh4jRafQqkoxvu9VA0tzSUw9k6ib6o8uB091ovGCmHB5VPIDtXfL8SUQdkbtNfXfXk8v8gO3oLh3LS1JtUPtTfPf3mN27mk9aZqpi3Mp9Yd78L60OaEOQNhpMvRssXNPG9LZQJ1bzKNazs4LlZsURe1xdmEjnN+gzrX0KPeKanKqYlu1J9L/27vz+Kjqe//jr5lJMtknCSErgQBB9jWQEMSVKC7VotaiVUFKcUOvbWpv5VpBtDVu9cdtpaIUXKtQe9VqVRQDoigYBEHWsJOwZAOSyUImy5zfHwPRSJAgyZxJ8n4+HucxZ858z8x7chjyzWe+53tae6J0V6VnYvjiLVC89dvbysKT20b1/rYI1fN8CIlu3Syn426Akm1NT/k7cdqgze75DJ74PEb3+fYzGtzFnIK4YXhGL54YbWV3QLfUNnmp1uo7vPDCC4SGhnL99dc32f7GG29QXV3N5MmTW/xcixcvZtKkScybN4/09HTmzJnDG2+8QV5eHjExJ88V9uKLL3Lvvfc2mbfKYrEQGxvb4tfsrH2oaS9/xdItRfxqbE/+8JMzLCgd3gXzxnpOMx//KGRMb5uQIiIiPqbNi1LN2bBhAyNGjKChoeH0jU3SWTtU3paztYg7X11HbYObzP6xzL1p+Jl/sygip+Z2ewpMJ4pU+744eW6toMiTr7AIENnz21FQ3cd4Cg3taZTd2Sgr8Mw/lfce7F3ZdDLw0Djoexn0vdJTFPIPbPnz1rs8E3p/t/BUvOXk0W3fFdHdczpkz/M9p0RGJP3499VWqko9p5U6uvnMpONmaK2+wznnnMNzzz3HRRdd1GT7ihUruO22285oovP09HRGjRrFM888A4Db7SYpKYl77rmH+++//6T2L774Ir/+9a8pKyv70fk7Yx+qyFnDmMeW0eA2+DjrfFJizmBev4Z6WDgeDnzl+YxPeqdzXCFURESElvcbOshX4eJrxvWPZf7kkdz28ld8vLWIO15Zy7M3pxLo33n/qBFpVVYrxA/xLGPugfpa2L/m+CiqFZ5TsY4dBSwQN+jbUVDdMzyj7zqriCRIv82zHCuDnR97RlDtWOoZvbT2Rc/iH+KZh6rfldDnUgiO8uzvbvCMWPv+yKfDO8E4xRcyobEQ099zeuWJ2659237S+tYQEu39EVsdWH5+Pj179jxpe48ePcjPz2/x89TW1rJ27VpmzJjRuM1qtZKZmcmqVatOuV9lZSU9evTA7XYzYsQIHn30UQYOHHhmb6KTeeOrAhrcBqOSI8+sIAXw2Z89BSm7A66Zp4KUiIhIM1SUkjZzwTldWXjrKKa+tIbleSVMe/krnr9lJEEBKkyJtDq/AM/8UsnnAg94JmMv3e45zaq15yLqKIIiYPDPPEt9redqd3nve+aiqjjomTR96zueifST0jwjhkryTp6D64RAR9PCU0x/6NrfNydWF1PExMTwzTffkJyc3GT7hg0b6NKl5f9OSktLaWhoOOnUu9jY2MZpFb6vb9++LFy4kCFDhlBeXs5TTz3FmDFj2Lx5M926dWt2H5fLhcv17b93p9PZ4owdgdttsPgrz5x0N4zqfmY7H1gLKx73rF/5Z89oQxERETmJilLSps5NiebFKWn88sU1fLajlF++uIYFt44kOED/9ETaVGC458pp0jJ+AZ6RUSnj4IqnPJOQn5govWiTZ1L4xrZBENPvOwWo40WosPjOcxqk/Cg33ngj//Vf/0VYWBjnn38+4Dl179577+WGG25o09fOyMhovDgNwJgxY+jfvz/PPfccjzzySLP7ZGdnM3v27DbN5cs+31VKwZFjhAX6ccXg+JbvWFsNb97mGT058FpP4VtERESadUaVgWuvvfYHHz+beQqk4xrdqwsv/TKNWxfmsmr3YW5duIaFU0YRaldhSkR8kMUCCcM9y8UPwNG9nqvkBUd5ClARyToNR36URx55hL179zJu3Dj8/Dy/A91uN5MmTeLRRx9t8fNER0djs9koKipqsr2oqIi4uJadnuvv78/w4cPZuXPnKdvMmDGDrKysxvtOp5OkJB+c+6yNLMr1jJK6ZnjimY3yXvqg55TesATPKCkVq0VERE7pjKoCDscPnwLicDiYNGnSWQWSjmlUchSv/CqdyQtyyd17hMkLc3lxyijCAjv4VeVEpP2LTPYsImcpICCAxYsX88c//pH169cTFBTE4MGD6dGjxxk/T2pqKjk5OUyYMAHwFLdycnK4++67W/QcDQ0NbNy4kSuuuOKUbex2O3a7/YyydRSHK118tMVzlcwzOnVvx1JY83fP+oS5385HJyIiIs06o6LUCy+80FY5pBMY0T2Sf0xL5+a/f8nafUe5eUEuL/8yDUeQClMiItJ59OnThz59+pzVc2RlZTF58mRGjhxJWloac+bMoaqqiilTpgAwadIkEhMTyc7OBuDhhx9m9OjRpKSkUFZWxpNPPsm+ffv41a9+ddbvpyP6v3X7qWswGNrNwYCEFl5psPoI/Hu6Zz39Duh9cdsFFBER6SB0/oF41ZBuEbw2bTSRwf5sKCjjpr+vpqy61uxYIiIibe66667j8ccfP2n7E088wfXXX39GzzVx4kSeeuopZs6cybBhw1i/fj1LlixpnPw8Pz+fQ4cONbY/evQo06ZNo3///lxxxRU4nU6++OILBgwYcHZvqgMyDINFazyn7t2Y1sJRUoYB794LlUUQ3RcyH2q7gCIiIh2IxTAMw+wQ3uR0OnE4HJSXlxMe3sJvvqTVbT3k5Oa/f8nhqlr6x4fzj1+lExUSYHYsERGRk7RW36Fr164sW7aMwYMHN9m+ceNGMjMzT5ojytd0lj7Ul7sPM/H51YQE2Mh9IJOQlsyBuf51ePsOsPrBr3IgYVib5xQREfFlLe03aKSUmKJ/fDiLbhtNdKidrYec3Pj8akorT3GZdRERkQ6gsrKSgICTv4Dx9/fH6XSakEiac2KU1NXDElpWkDq6D97/nWf9whkqSImIiJwBFaXENH1iw1h8+2hiw+3kFVVww/OrKXbWmB1LRESkTQwePJjFixeftH3RokU6jc5HlFXX8t5Gz2mPLZrg3N0Ab98JtRWQlA5jf9PGCUVERDqWM5roXKS19e4ayuLbMrhx/mp2Flcy8fnVvDYtnXhHkNnRREREWtWDDz7Itddey65du7j4Ys8k2Dk5Obz22mv861//MjmdALz19QFq6930jw9nSLcfvuo0AKuegX2fQ0AoXPMcWG1tH1JERKQD0UgpMV1ydAj/vD2DxIgg9pRWMfG51RwoO2Z2LBERkVZ11VVX8fbbb7Nz507uuusufvvb33LgwAGWLVtGSkqK2fE6PcMwWJR7YoLzJCwWyw/vULgRch7xrF+WDVE92zihiIhIx6OilPiEpKhgFt8+mu5RweQfqWbic6soOFJtdiwREZFWdeWVV/L5559TVVXF7t27+fnPf859993H0KFDzY7W6X1dUEZeUQWB/lZ+OizxhxvX1cCbt4G7DvpeCcNv8U5IERGRDkZFKfEZ3SI9hame0SHsP3qMic+tYm9pldmxREREWtWnn37K5MmTSUhI4M9//jMXX3wxq1evNjtWp7coNx+AKwbH4wjy/+HGyx6B4i0Q0hWu+l843agqERERaZaKUuJT4h1BLLptNL27hnCwvIaJz69i04Fys2OJiIiclcLCQh577DH69OnD9ddfT3h4OC6Xi7fffpvHHnuMUaNGmR2xU6uoqePdDZ4Jzm9MO80E53s+hVVzPetXPwOhXds4nYiISMelopT4nNjwQBbdlsE5saEUOV38dO7n/Om9LVTX1psdTURE5IxdddVV9O3bl2+++YY5c+Zw8OBB/vrXv5odS77jnQ0HOVbXQEpMKCN7RJ664bEyeOtOwIDUW6HvZV5KKCIi0jGpKCU+qWuYnUW3ZXDl4Hga3AbzP9vDJU9/yrJtRWZHExEROSMffPABU6dOZfbs2Vx55ZXYbLpCm685McH5DaNOM8H5R38A536I6gWX/slL6URERDouFaXEZ0WFBDD3phEsvHUkiRFBHCg7xi9f/Irp/1hHkbPG7HgiIiItsnLlSioqKkhNTSU9PZ1nnnmG0tJSs2PJcZsOlLPxQDkBNivXjuh26oYHv4avX/WsT3gW7KHeCSgiItKB+URRau7cuSQnJxMYGEh6ejq5ubmnbHvhhRdisVhOWq688kovJhZvurhfLEuzzue283ths1p4b+MhMv+8gldW7cXtNsyOJyIi8oNGjx7N/PnzOXToELfffjuLFi0iISEBt9vN0qVLqaioMDtip7ZojWeC80sHxhIVEtB8I8OAJf8DGDBkInQf7b2AIiIiHZjpRanFixeTlZXFrFmzWLduHUOHDmX8+PEUFxc32/7NN9/k0KFDjcumTZuw2Wxcf/31Xk4u3hQc4Mf/XNGfd+4+l6HdHFS46nnw35u5bt4XbD3kNDueiIjIaYWEhPDLX/6SlStXsnHjRn7729/y2GOPERMTw9VXX212vE6puraef399EDjNBOdb/g35X4BfEIyb5aV0IiIiHZ/pRamnn36aadOmMWXKFAYMGMC8efMIDg5m4cKFzbaPiooiLi6ucVm6dCnBwcEqSnUSAxMcvHnXucy+eiChdj++zi/jqr+u5LEPtnGstsHseCIiIi3St29fnnjiCfbv38/rr79udpxO671vDlHhqqdHl2AyenVpvlFdDSx90LN+7r3gSPReQBERkQ7O1KJUbW0ta9euJTMzs3Gb1WolMzOTVatWteg5FixYwA033EBISEizj7tcLpxOZ5NF2jeb1cLkMckszTqfywbGUe82mLdiF5fOWcEnec2PsBMREfFFNpuNCRMm8M4775gdpVN6Pddz6t7EUUlYraeY4Hz136AsH8IS4Nz/8mI6ERGRjs/UolRpaSkNDQ3ExsY22R4bG0thYeFp98/NzWXTpk386le/OmWb7OxsHA5H45KUlHTWucU3xDuCmHdLKvMnjSTBEUjBkWPc+sIa7nn9a4orNBG6iIiInNr2ogrW5ZfhZ7Xws9RTTHBeUQSf/dmznvkQBDT/JaiIiIj8OKafvnc2FixYwODBg0lLSztlmxkzZlBeXt64FBQUeDGheMMlA2JZmnUBU8f2xGqBdzccJPPPK3jty3xNhC4iIiLNOjFKalz/GGLCAptvtOwRqK2ExFQYrKkiREREWpupRano6GhsNhtFRUVNthcVFREXF/eD+1ZVVbFo0SKmTp36g+3sdjvh4eFNFul4Qux+PPiTAfx7+lgGJYbjrKnnf97ayM+fW8X2Il3VSERERL5VU9fAW18fAOCGU01wfmgDfP2qZ/2yx8Darr/LFRER8Umm/nYNCAggNTWVnJycxm1ut5ucnBwyMjJ+cN833ngDl8vFzTff3NYxpR0Z3M3B23edy4M/GUBwgI2v9h3liv/9jCc/3EZNnSZCFxEREfhwcyFl1XUkRgRxfp+uJzcwDFjyP4ABg34GSacelS8iIiI/nulf+WRlZTF//nxeeukltm7dyp133klVVRVTpkwBYNKkScyYMeOk/RYsWMCECRPo0uUUV0qRTsvPZmXq2J58nHUBmf1jqXcbzF2+i/FzPmXljlKz44mIiIjJTpy6d/3Ibtiam+B867uwbyX4BXrmkhIREZE24Wd2gIkTJ1JSUsLMmTMpLCxk2LBhLFmypHHy8/z8fKzfGy6dl5fHypUr+eijj8yILO1EQkQQf588kiWbCnnonc3sO1zNzQu+ZMKwBH53WT8SI4LMjigiIiJetqe0itW7j2C1wM9HNnMBnHoXLH3Qsz7mvyBCF8kRERFpKxbDMDrVTNBOpxOHw0F5ebnml+pEKmrq+PNH23lp1V4MA/xtFm4Y1Z3pF6UQ5zjF5KYiIiKo73BCR/k5ZH+wledW7Oaivl15YUozp+V9/r+wdCaExcPdX4E91PshRURE2rmW9htMP31PxBvCAv156OqBvH3XuYzp3YW6BoNXVu/j/CeXM/vdzRRX1JgdUURERNpYbb2b/1u7HzjFBOeVxbDiSc/6uFkqSImIiLQxFaWkUxmaFMFr00bz+rTRpCVHUVvv5oXP93L+E8v503tbOFzpMjuiiIiItJGcrUWUVtbSNczOxf1iTm6w/E9QWwEJw2HIRO8HFBER6WRUlJJOKaN3FxbfPppXp6YzvHsENXVu5n+2h/OeWM7jS7ZxtKrW7IgiIiLSyl5fUwDA9and8Ld9rxtcuBHWvexZH58NVnWTRURE2pp+20qnZbFYGNsnmjfvHMMLU0YxpJuD6toGnv1kF+c9sZynP8qj/Fid2TFFRESkFRQcqeazHSUATBz1vcnLDQOWzADDDQOvgR4ZJiQUERHpfFSUkk7PYrFwUd8Y/j39XOZPGkn/+HAqXfX8ZdlOxj6+jL/k7KCiRsUpERGR9uyfXxVgGDA2JZoeXUKaPpj3Puz9DGx2yJxtTkAREZFOSEUpkeMsFguXDIjlvXvGMu/mEfSNDaOipp6nl27nvCeWM3f5Tqpc9WbHFBERkTNU3+Dmn195Tt27Ie17o6TqXfDhA571MXdDZA8vpxMREem8VJQS+R6r1cJlg+L54N7z+OuNw+ndNYSy6jqe/DCP855YzvOf7uJYbYPZMUVEpJObO3cuycnJBAYGkp6eTm5ubov2W7RoERaLhQkTJrRtQB/ySV4JRU4XUSEBXDIgtumDuc/D0T0QGgtjf2NOQBERkU5KRSmRU7BaLVw1NIGPfnMB/2/iUJK7BHOkqpZH39/GeU8sZ+HKPdTUqTglIiLet3jxYrKyspg1axbr1q1j6NChjB8/nuLi4h/cb+/evdx3332cd955XkrqGxatyQfguhGJ2P1s3z5QVQornvCsj5sJ9jAT0omIiHReKkqJnIbNauGa4d34OOsCnvzZEJKigiitdPHwf7ZwwZPLeXnVXlz1Kk6JiIj3PP3000ybNo0pU6YwYMAA5s2bR3BwMAsXLjzlPg0NDdx0003Mnj2bXr16eTGtuQrLa1i2zVOsmziqe9MHl/8JXE6IGwJDf2FCOhERkc5NRSmRFvKzWbl+ZBLLfnsh2dcOJsERSJHTxcx/b2bcn1ewYnuJ2RFFRKQTqK2tZe3atWRmZjZus1qtZGZmsmrVqlPu9/DDDxMTE8PUqVNb9Doulwun09lkaY/e+KoAtwFpyVGkxIR++0DRZlj7omf9ssfAqm6xiIiIt+m3r8gZ8rdZuTGtO8t/dyGP/HQgseF29h89xuSFuWQtXs/RqlqzI4qISAdWWlpKQ0MDsbFN50aKjY2lsLCw2X1WrlzJggULmD9/fotfJzs7G4fD0bgkJSWdficf43YbLG5ugnPDgA//Bww3DPgpJJ9rUkIREZHOTUUpkR/J7mfjloxklv32Qn55bk8sFnjz6wNkPr2CdzccxDAMsyOKiIhQUVHBLbfcwvz584mOjm7xfjNmzKC8vLxxKSgoaMOUbWPlzlL2Hz1GeKAfVwyO//aB7R/C7k/AFgCXPGxaPhERkc7Oz+wAIu1diN2PmVcN4Kqh8dz/fxvJK6rgnte/5t/rD/DIhEHEO4LMjigiIh1IdHQ0NpuNoqKiJtuLioqIi4s7qf2uXbvYu3cvV111VeM2t9sNgJ+fH3l5efTu3fuk/ex2O3a7vZXTe9eJCc6vGZ5IoP/xCc7ra+GjBzzrGdMhMtmccCIiIqKRUiKtZXj3SN69Zyy/yTwHf5uFj7cWc8nTn/Lq6n243Ro1JSIirSMgIIDU1FRycnIat7ndbnJycsjIyDipfb9+/di4cSPr169vXK6++mouuugi1q9f3y5Py2uJkgoXH232FO5uSPvOBOdr/g6Hd0JIVxibZVI6ERERAY2UEmlVAX5W7s3swxWD4/j9/33Duvwy/vD2Jt7ZcJDsawfTu2vo6Z9ERETkNLKyspg8eTIjR44kLS2NOXPmUFVVxZQpUwCYNGkSiYmJZGdnExgYyKBBg5rsHxERAXDS9o6ivsHN7Hc3U+82GJoUQf/4cM8DVYdhxWOe9YsfhMBw80KKiIiIilIibaFPbBhv3DGGV1bt5YkP88jdc4TL//cz7h3Xh9vO74W/TYMURUTkx5s4cSIlJSXMnDmTwsJChg0bxpIlSxonP8/Pz8faSa8mV1vv5t5FX/PBpkL8rBZ+e8k53z74STbUlEPsYBh+s3khRUREBACL0clmY3Y6nTgcDsrLywkP17dj0vb2H63mgbc2sWJ7CQD948N54rohDO7mMDmZiIi0hPoOHu3h5+Cqb2D6P9bx8dZiAmxW/nbTCDIHHL9KYfFWePZcMBpg8rvQ83xzw4qIiHRgLe03dM6v0ES8qFtkMC9OGcX/mziUyGB/th5y8tO5K8l+fyvHahvMjiciItIh1NQ1MO3ltXy8tRi7n5XnJ6V+W5AyDPjwfzwFqX4/UUFKRETER6goJeIFFouFa4Z3Y2nWBVw9NAG3Ac99upvL/vdTvthVanY8ERGRdq26tp4pL6zh0+0lBPnbeOHWUVzYN+bbBjuWwq5lYPWHSx8xL6iIiIg0oaKUiBdFh9r5y43DWTB5JPGOQPYdruYX87/k/v/7hvJjdWbHExERaXcqauqYvDCXVbsPE2r34+WpaYxJif62QUOdZ5QUwOg7IaqXOUFFRETkJCpKiZhgXP9YPvrN+dw82nOJ6kVrCrjk6RUs2VRocjIREZH2o7y6jpsX5LJm71HCA/14ZWoao5KjmjZaswAO74DgaDj/PnOCioiISLNUlBIxSVigP3+cMJh/3p5Br+gQiitc3PHqWu58dS3FFTVmxxMREfFpR6tq+cXfV7OhoIzIYH9emzaa4d0jmzaqPuK54h7AxX+AQF1kRERExJeoKCVisrSeUbx/73lMv6g3flYLH2wqJPPPK3hl9T5q691mxxMREfE5JRUubpy/ms0HnUSHBvD6baMZlNhMwWnF41BTBrGDYMQkr+cUERGRH6ailIgPCPS38bvx/Xjn7rEMTnTgrKnnwbc3ceGTy3ll1V5q6nSVPhEREYDC8hpueH4V2woriAmzs+i2DPrFNXOp6ZLtkDvfsz7+UbDavBtURERETktFKREfMiAhnLfuGsNDVw0gJszOwfIaHvz3Zi54cjkLV+5RcUpERDq1A2XHmPj8KnaVVJHgCOSft2eQEhPafOOvFoLRAOdcDr0u8G5QERERaREVpUR8jJ/Nyq3n9uTT/76Ih386kHhHIEVOFw//ZwtjH1/O/E93U11bb3ZMERERr8o/XM3P561i3+FqkqKCWHx7BsnRIafeYefHntthv/BOQBERETljPlGUmjt3LsnJyQQGBpKenk5ubu4Pti8rK2P69OnEx8djt9s555xzeP/9972UVsQ7Av1tTMpI5pPfXcij1wwmMSKI0koXf3p/K2MfX87fPtlJpUvFKRER6fh2l1Ty8+dWcaDsGD2jQ/jn7RkkRQWfeoejez1X3LP6aZSUiIiIDzO9KLV48WKysrKYNWsW69atY+jQoYwfP57i4uJm29fW1nLJJZewd+9e/vWvf5GXl8f8+fNJTEz0cnIR77D72fhFenc++d2FPHHdEHp0CeZIVS1PLMlj7OPL+EvODsqP1ZkdU0REpE1sL6rg58+tptBZQ5+YUBbfNpp4R9AP73RilFRSuq64JyIi4sMshmEYZgZIT09n1KhRPPPMMwC43W6SkpK45557uP/++09qP2/ePJ588km2bduGv7//Gb+e0+nE4XBQXl5OeHgzk2KK+Lj6BjfvbDjIM8t3srukCoCwQD+mjEnml2N7EhEcYHJCEZGORX0HDzN+DlsOOrl5wZccqaqlf3w4r05No0uo/fQ7vnYDbP8Axs2E837b9kFFRESkiZb2G0wdKVVbW8vatWvJzMxs3Ga1WsnMzGTVqlXN7vPOO++QkZHB9OnTiY2NZdCgQTz66KM0NGgCaOkc/GxWrh3RjaW/uYC/3DicPjGhVNTU85dlOzn3sWU8sWQbR6pqzY4pIiJyVr7ZX8aN81dzpKqWwYkOXp+W3rKCVL0L9nzqWU+5pG1DioiIyFnxM/PFS0tLaWhoIDY2tsn22NhYtm3b1uw+u3fvZtmyZdx00028//777Ny5k7vuuou6ujpmzZp1UnuXy4XL5Wq873Q6W/dNiJjEZrVw9dAEfjI4niWbC/lLzg62FVbwt0928cLne7klowfTzutF17AWdOBFRER8yNp9R7l1YS4VrnpGdI/gxV+mER7YwhHy+augrgpCYyFucNsGFRERkbNi+pxSZ8rtdhMTE8Pzzz9PamoqEydO5IEHHmDevHnNts/OzsbhcDQuSUlJXk4s0rasVgtXDI7n/f86j+dvSWVQYjjH6hp4/tPdjH18GbPf3UyRs8bsmCIiIi2yevdhblnwJRWuetJ6RvHy1PSWF6Tg2/mkUjLBYmmbkCIiItIqTC1KRUdHY7PZKCoqarK9qKiIuLi4ZveJj4/nnHPOwWazNW7r378/hYWF1NaefMrSjBkzKC8vb1wKCgpa902I+Air1cKlA+N49+6xvHDrKIYlReCqd/PC53s574nlPPj2JgqOVJsdU0RE5JRW7ijl1hdyqa5tYGxKNC9NSSPUfoYD+3ecKEqNa/2AIiIi0qpMLUoFBASQmppKTk5O4za3201OTg4ZGRnN7nPuueeyc+dO3G5347bt27cTHx9PQMDJEzzb7XbCw8ObLCIdmcVi4aJ+Mbx11xhemZrGyB6R1Na7eWX1Ps5/cjm3vpDLx1uKaHCbeo0DERGRJpZvK+aXL62hps7NRX278vfJIwkKsJ1+x+8q3w8lW8FihV4XtU1QERERaTWmn76XlZXF/Pnzeemll9i6dSt33nknVVVVTJkyBYBJkyYxY8aMxvZ33nknR44c4d5772X79u289957PProo0yfPt2styDikywWC+f16cobd2Tw2rR0zusTjWHAJ3kl/Orlrzj/ieU8s2wHJRWu0z+ZiIhIG1q6pYjbXvmK2no3lw6IZd4tqQT6n2FBCmDn8S86E0dCcFTrhhQREZFWZ+pE5wATJ06kpKSEmTNnUlhYyLBhw1iyZEnj5Of5+flYrd/WzpKSkvjwww/5zW9+w5AhQ0hMTOTee+/l97//vVlvQcSnWSwWxvSOZkzvaPaUVvHal/t4Y+1+DpQd46mPtvO/OTsYPzCOm0f3IL1nFBbNvyEiIl7WNcyO3c/GpQO7MmfiMPxtP/J7051LPbcpmT/cTkRERHyCxTCMTnUOj9PpxOFwUF5erlP5pNOqqWvgvW8O8eqX+/g6v6xxe5+YUG5K7861qd3ObFJZEZEOTH0Hj7b+OewsriC5Swh+P7Yg1VAHT/QClxOmLYPE1NYNKCIiIi3W0n6D6SOlRMT7Av1tXJfajetSu7H5YDmvrs7n3+sPsKO4kofe3cLjS/L46bAEbh7dg0GJDrPjiohIJ5ASE3Z2T1CQ6ylIBXeB+OGtE0pERETalIpSIp3cwAQH2dcOZsYV/Xj76wO8unof24sqWbSmgEVrChiaFMHN6d25amjCj5vfQ0RExBt2Hr/qXu9xYDV92lQRERFpARWlRASA8EB/JmUkc8voHqzZe5RXV+/jg02H2FBQxoaCMv743lZ+ltqNm9K706trqNlxRUREmtJ8UiIiIu2OilIi0oTFYiGtZxRpPaMorRzAP78q4LUv89l/9BgLVu5hwco9jE2J5ubR3cnsH/vj5/4QERFpLRWFULjRs977YnOziIiISIupKCUipxQdaueuC1O4/fzefLq9hFdX72NZXjErd5aycmcpseF2rhnejWuGJ9I37iznAhEREfmxduZ4bhOGQ2hXc7OIiIhIi6koJSKnZbNauKhfDBf1i2H/0Wpez81n8ZoCipwu5q3YxbwVuxgQH841wxP56bAEYsIDzY4sIiKdyYn5pHTqnoiISLui825E5Ix0iwzmd+P78cX945h38wguHRCLv83ClkNO/vT+VkZn53DLgi95c91+qlz1ZscVEemw5s6dS3JyMoGBgaSnp5Obm3vKtm+++SYjR44kIiKCkJAQhg0bxiuvvOLFtG2ooR52LfOsp1xibhYRERE5IxopJSI/SoCflcsGxXPZoHjKqmv5zzeHePvrA3y17yif7Sjlsx2lBPlvYvzAWCYMT2RsSrTmnxIRaSWLFy8mKyuLefPmkZ6ezpw5cxg/fjx5eXnExMSc1D4qKooHHniAfv36ERAQwH/+8x+mTJlCTEwM48ePN+EdtKKD66CmDAIdkJhqdhoRERE5AxbDMAyzQ3iT0+nE4XBQXl5OeHi42XFEOpz8w9W8vf4Ab319gD2lVY3bo0PtXD00gWuGJzIoMRyLxWJiShGRlvPFvkN6ejqjRo3imWeeAcDtdpOUlMQ999zD/fff36LnGDFiBFdeeSWPPPJIi9r74s8BgOWPworHYeA1cP2LZqcRERERWt5v0EgpEWlV3bsE81/j+nDPxSls2F/OW+v28+43hyitdLHw8z0s/HwPKTGhjfNPdYsMNjuyiEi7Ultby9q1a5kxY0bjNqvVSmZmJqtWrTrt/oZhsGzZMvLy8nj88cdP2c7lcuFyuRrvO53OswveVnYs9dxqPikREZF2R0UpEWkTFouFYUkRDEuK4A8/GcCn20t46+sDLN1SxM7iSp78MI8nP8wjrWcU1w5P5PLB8TiC/M2OLSLi80pLS2loaCA2NrbJ9tjYWLZt23bK/crLy0lMTMTlcmGz2fjb3/7GJZeceg6m7OxsZs+e3Wq520RVKRz82rPee5y5WUREROSMqSglIm3O32ZlXP9YxvWPpaKmjg82FfL21wdYtfswuXuOkLvnCDPf2cy4fjFcPTSB1ORIYsJ0BT8RkdYUFhbG+vXrqaysJCcnh6ysLHr16sWFF17YbPsZM2aQlZXVeN/pdJKUlOSltC20axlgQOxgCI83O42IiIicIRWlRMSrwgL9+fnIJH4+MomDZcd4Z8NB3lp3gLyiCj7YVMgHmwoBiAsPZEg3B0O6ORjcLYIhiQ4iQwJMTi8iYr7o6GhsNhtFRUVNthcVFREXF3fK/axWKykpKQAMGzaMrVu3kp2dfcqilN1ux263t1ruNrHzY89tikZJiYiItEcqSomIaRIigrjjgt7cfn4vth6q4K2v9/NJXgk7SyopdNZQuKWGj7Z8+0dXUlQQQxIjGHy8WDUo0UF4oE75E5HOJSAggNTUVHJycpgwYQLgmeg8JyeHu+++u8XP43a7m8wZ1e643bAzx7Pe59SnIYqIiIjvUlFKRExnsVgYkBDOgIQBPHAlVLnq2XzQyTf7y/hmfzkbD5Szp7SKgiPHKDhyjPc2Hmrct1d0yLejqbo5GJgQTnCA/msTkY4tKyuLyZMnM3LkSNLS0pgzZw5VVVVMmTIFgEmTJpGYmEh2djbgmR9q5MiR9O7dG5fLxfvvv88rr7zCs88+a+bbODuH1kN1KQSEQVK62WlERETkR9BfbiLic0LsfqT1jCKtZ1TjtvLqOjYdLD9epCpjQ0E5B8qOsbu0it2lVby9/iAAVgv0iQljcDcHQ48Xq/rHh2H3s5n1dkREWt3EiRMpKSlh5syZFBYWMmzYMJYsWdI4+Xl+fj5Wq7WxfVVVFXfddRf79+8nKCiIfv368eqrrzJx4kSz3sLZO3HqXq8LwKZRsyIiIu2RxTAMw+wQ3uR0OnE4HJSXlxMeHm52HBE5C4crXWw84ClUnShWFTlPPhUlzO7HhOGJ3JjWnQEJ+tyLyJlR38HD534OCy6Fgi/hJ3Ng5BSz04iIiMh3tLTfoJFSItJudQm1c2HfGC7sG9O4rchZ4ylQ7S/jm+MFqyNVtbyyeh+vrN7HsKQIfpHenZ8MiddpfiIi7dWxo7B/jWc9JdPcLCIiIvKj6S8yEelQYsMDuWRAIJcM8JzC4nYbrNp9mNe+zOfDzYWsLyhjfUEZj7y7hWtGeEZP9Y/3gW/8RUSk5XYtB8MNXftBRJLZaURERORHUlFKRDo0q9XCuSnRnJsSTUmFi3+t3c/rufnkH6nm5VX7eHnVPoZ3j+AXad35yZAEggI095SIiM87cdU9jZISERFp11SUEpFOo2uYnTsv7M3t5/fii12HeS13Hx9tLuLr/DK+zi/j4f9s4drhifwivQd948LMjisiIs0xjG8nOVdRSkREpF1TUUpEOh2r1cLYPtGM7RNNcUVN4+ipgiPHeGnVPl5atY8R3SP4RXoPrhwcr9FTIiK+pGgTVBaCfzD0GGN2GhERETkLKkqJSKcWExbIXRemcMf5vfl8VymvfZnP0i1FrMsvY11+GQ+/u5lrR3TjxrTuGj0lIuILdiz13PY8H/zs5mYRERGRs6KilIgIntFT5/Xpynl9ulJcUcMbX3lGT+0/eowXv9jLi1/sJbVHJL9I686VQ+IJ9NfoKRERU2g+KRERkQ5DRSkRke+JCQtk+kUp3HlBbz7bWcrrX+azdGsRa/cdZe2+o8x+dzNXDonn4n6xnJvSheAA/VcqIuIVNU4oWO1ZV1FKRESk3dNfUiIip2C1WrjgnK5ccE5Xip01/POrAl7PLeBA2TFez/WsB9ispPeK4uJ+MVzcL4YeXULMji0i0nHtWQHueojqDVE9zU4jIiIiZ8lqdgCAuXPnkpycTGBgIOnp6eTm5p6y7YsvvojFYmmyBAYGejGtiHRGMeGB3H1xHz7974t4ZWoakzN6kBQVRG2Dm892lDL73S1c8OQnXPzUJzzyny18vrOU2nq32bFFRDoWXXVPRESkQzF9pNTixYvJyspi3rx5pKenM2fOHMaPH09eXh4xMTHN7hMeHk5eXl7jfYvF4q24ItLJ2b4z99RDhsGukkqWbyth2bZi1uw9wu7SKnav3MOClXsItfsxNiWai/p15aK+McSEq4AuIvKjGQbsOF6U6nOJuVlERESkVZhelHr66aeZNm0aU6ZMAWDevHm89957LFy4kPvvv7/ZfSwWC3Fxcd6MKSJyEovFQkpMGCkxYUw7vxfOmjpW7ihl2bZiPskrobTSxZLNhSzZXAjAoMRwLu4bw4X9YhjaLQKbVQV1EZEWK8kD536w2aHHuWanERERkVZgalGqtraWtWvXMmPGjMZtVquVzMxMVq1adcr9Kisr6dGjB263mxEjRvDoo48ycOBAb0QWETml8EB/rhgczxWD43G7DTYdLGfZtmKWbytmw/5yNh1wsumAk78s20lUSAAXntOVC/vFcEGfrjiC/c2OLyLi23Yu9dwmj4WAYHOziIiISKswtShVWlpKQ0MDsbGxTbbHxsaybdu2Zvfp27cvCxcuZMiQIZSXl/PUU08xZswYNm/eTLdu3U5q73K5cLlcjfedTmfrvgkRkWZYrRaGdItgSLcIfp15DiUVLlZsL2H5tmI+3V7Ckapa3vz6AG9+fQCb1UJq90jGpHRhVHIUw7tH6Ip+IiLfp/mkREREOpx291dPRkYGGRkZjffHjBlD//79ee6553jkkUdOap+dnc3s2bO9GVFE5CRdw+z8LLUbP0vtRl2Dm6/2HuWTvGKWbStmR3EluXuPkLv3COCZt2pQQjijkqMYmRzFqORIuoTaTX4HIiImclXCvi8865pPSkREpMMwtSgVHR2NzWajqKioyfaioqIWzxnl7+/P8OHD2blzZ7OPz5gxg6ysrMb7TqeTpKSkHx9aROQs+dusZPTuQkbvLsy4oj8FR6pZsb2E3D1HWLP3CIfKa9iwv5wN+8v5+8o9APTqGkLa8SJVWnIUSVFBusiDiHQee1dCQy1EdIcuKWanERERkVZialEqICCA1NRUcnJymDBhAgBut5ucnBzuvvvuFj1HQ0MDGzdu5Iorrmj2cbvdjt2uEQYi4ruSooK5eXQPbh7dA4D9R6v5au9Rcvce4au9R9heVMnukip2l1SxaE0BADFhdkYdH0U1MjmK/vHhmjhdRDquE/NJpWSCCvIiIiIdhumn72VlZTF58mRGjhxJWloac+bMoaqqqvFqfJMmTSIxMZHs7GwAHn74YUaPHk1KSgplZWU8+eST7Nu3j1/96ldmvg0RkVbTLTKYbpHBTBieCEBZdS1f7T3Kmn1HWLPnCBsPlFNc4eK9jYd4b+MhAELtfozoEUna8SLVsKQIAv1tZr4NEZHWYRiw40RRSqfuiYiIdCSmF6UmTpxISUkJM2fOpLCwkGHDhrFkyZLGyc/z8/OxWq2N7Y8ePcq0adMoLCwkMjKS1NRUvvjiCwYMGGDWWxARaVMRwQFkDoglc4Dn/8WaugbWF5Tx1d4j5O49yrp9R6l01fPp9hI+3V4CgL/NM9H6xf1iuHRALCkxoTrdT0TapyO7oWwfWP2h53lmpxEREZFWZDEMwzA7hDc5nU4cDgfl5eWEh4ebHUdE5Kw1uA22HnLy1d4jrDl+2l9JhatJm57RIVw6IJZLB8YyPCkSq071E2kx9R08TPs5rJ4HS34PPc+Hye9673VFRETkR2tpv8H0kVIiInJ2bFYLgxIdDEp0cOu5PTEMg4Ijx1i5s5SlWwr5fOdh9pRW8dynu3nu091Eh9q5ZEAMlw6II6N3F53mJyK+befHntuUTHNziIiISKtTUUpEpIOxWCx07xLML7p05xfp3al01bMir4SPthSybFsxpZUuXs8t4PXcAkICbFzYN4ZLB8ZyUb8YwgP9zY4vIvKtumOw9zPPuuaTEhER6XBUlBIR6eBC7X5cOSSeK4fEU1vv5ss9h/locxEfbSmkyPnthOn+Nguje3Xh0oFxXNI/ljhHoNnRRaSz2/c51NdAWALE9Dc7jYiIiLQyFaVERDqRAD8r5/Xpynl9ujL76oF8c6CcjzYX8tGWInYWV/LZjlI+21HKg29vYmhSBJcOiGX8wFhSYsLMji4indGO46fu9ckEXaxBRESkw1FRSkSkk7JaLQxLimBYUgT/fVk/dpVUsnRLER9tLmRdfhkbCjzLkx/m0atrCJcOiOO8PtGEBfoR6G8j0M+G3d/aeGv3s+oKfyLSujSflIiISIemopSIiADQu2sovS8I5Y4LelPsrOHjrcV8tKWQL3YeZndJFfNW7GLeil0/+Bx2PyuB/rbG20B/K3Y/z+2J7fbvFbS6htkZ3j2Cod0iCArQpOsictzRvXB4B1hs0PMCs9OIiIhIG1BRSkREThITHsgv0j0TpVfU1PFJXgkfbi5k80EnNXUNuOrd1NQ1UFPXgNv4dj9XvRtXvftHvabNamFAfDgjukcwokckI7pH0i0ySKOvRE5h7ty5PPnkkxQWFjJ06FD++te/kpaW1mzb+fPn8/LLL7Np0yYAUlNTefTRR0/Z3iecGCWVlA5BEaZGERERkbahopSIiPygsEB/rhqawFVDE056zDAM6t3G8QKVG1e95/ZE4cpV10BNfQOuOve3t3UN1NS7G7ftO1zF2n1HKXK62HignI0Hynlp1T4AuobZPUWq7pGk9ohkUKKDQH+NphJZvHgxWVlZzJs3j/T0dObMmcP48ePJy8sjJibmpPaffPIJN954I2PGjCEwMJDHH3+cSy+9lM2bN5OYmGjCO2iBnTme25Rx5uYQERGRNmMxDMM4fbOOw+l04nA4KC8vJzw83Ow4IiKCp7h1sLyGdfuOsi7/KOv2HWXzQSf17qa/ovxtFgYkOEjtHsmIHp5iVUJEkEmppbPwxb5Deno6o0aN4plnngHA7XaTlJTEPffcw/3333/a/RsaGoiMjOSZZ55h0qRJLXpNr/4c6l3weE+oq4LbP4X4oW37eiIiItKqWtpv0EgpERExncViITEiiMSIoMYRWTV1DWw8UM66fUdZu+8o6/LLKK10NU7AvvBzz75x4YGk9ohk+PHT/gYmhGP302gq6bhqa2tZu3YtM2bMaNxmtVrJzMxk1apVLXqO6upq6urqiIqKaquYZyd/tacgFRIDsYPNTiMiIiJtREUpERHxSYH+NkYlRzEq2fNHs2EY7D96jHX5J4pUR9l6qIJCZw3vbTzEexsPARDgZyWlayg9ugTTvUswyV1C6BHlWY93BGGzao4qad9KS0tpaGggNja2yfbY2Fi2bdvWouf4/e9/T0JCApmZp76qncvlwuVyNd53Op0/LvCPsXOp5zYlE6xW772uiIiIeJWKUiIi0i5YLBaSooJJigrmp8M8c+BU19azoaCcdflH+TrfM5rqSFUtWw452XLo5D+gA2xWukUF0SMqmB5dQugeFUyPLp71pKggjbCSTuGxxx5j0aJFfPLJJwQGBp6yXXZ2NrNnz/Zisu/QfFIiIiKdgopSIiLSbgUH+JHRuwsZvbsAntFU+w5Xs6ukkn2Hq8k/Us2+w1XsO1xNwdFqahvc7C6pYndJFVDS5LksFogPD6R7l2B6RIXQI/r47fERV2F2P10JUHxCdHQ0NpuNoqKiJtuLioqIi4v7wX2feuopHnvsMT7++GOGDBnyg21nzJhBVlZW432n00lSUtKPD95S5fuheAtYrND74rZ/PRERETGNilIiItJhWCwWkqNDSI4OOemxBrfBofJj5B+uZu/havYdqSL/cDX7DnsKV1W1DRwsr+FgeQ2rdx9p9vkD/KzYbVbs/lbsfjbP/eOLZ932nfXvtfG3EmCzHd/XSkiAH31iQ+kfH64rCsoZCQgIIDU1lZycHCZMmAB4JjrPycnh7rvvPuV+TzzxBH/605/48MMPGTly5Glfx263Y7fbWyt2y50YJZWYCsE+OueViIiItAoVpUREpFOwWS10iwymW2QwY1KaPmYYBoerao+Prqo6XqjyFKvyj1RTWlkLQG29m9p6NxWuZl7gLHKldA1lUKKDQYnhDEp0MCA+nBC7fkXLqWVlZTF58mRGjhxJWloac+bMoaqqiilTpgAwadIkEhMTyc7OBuDxxx9n5syZvPbaayQnJ1NYWAhAaGgooaGhpr2PZn13PikRERHp0NTjFRGRTs9isRAdaic61E5qj8iTHj9W20B1bT2uejeu44UpV31D0/U6N7UNblx13z7WXPsT7cqqa9l6yElpZS15RRXkFVXwf+tO5IFe0SGeQlWCg0GJDgYmhhMe6O/ln4z4qokTJ1JSUsLMmTMpLCxk2LBhLFmypHHy8/z8fKzfmSD82Wefpba2lp/97GdNnmfWrFk89NBD3oz+wxrqYPcKz3rKJeZmERERkTZnMQzDMDuENzmdThwOB+Xl5YSHh5sdR0REOjHDMCiucLFxfzmbDpaz6YCTTQfKKXTWNNu+R5fg7xSqwhmU4CAyJMDLqTsf9R08vPJz2Ps5vHgFBEXB73aCVae2ioiItEct7TdopJSIiIhJLBYLseGBxA4IJHNAbOP2kgoXmw+Ws/mgs7Fgtf/oscbTCt/75lBj28SIoMYCVf/4cLpFBZEYEUSYRlVJe7TzY89tyjgVpERERDoBFaVERER8TNcwOxf2jeHCvjGN28qqaz0jqQ6Ws+mAZ9l7uJoDZcc4UHaMDzc3vRJbWKAfiRGeAlVCRBCJkcdvjy8xYXasVl1NUHxMY1FK80mJiIh0BipKiYiItAMRwQGM7RPN2D7RjducNXVsOehsLFLtKK7kQNkxyqrrqKipZ1thBdsKK5p9Pn+bhThHIAkOT8HqpAKWI4igAI1UES+qKILCbzzrvS82N4uIiIh4hYpSIiIi7VR4oD+je3VhdK8uTbZXueo5VH6M/UePcbCshgNl1Z7bo55RVYXOGuoaDAqOHKPgyDHY0/zzdwkJoGuYncjgACJD/IkIDiAiyJ/I4AAigj33I79z6wjyx89mbf7JRE5nV47nNn4YhMb8YFMRERHpGFSUEhER6WBC7H6kxISREhPW7OP1DW6KK1wcPH7q34GyYxw4euzb+0ePUVXbwOGqWg5X1Z7Ra4cF+p1ctApqWsByBPkTGuhHqN2PsEA/wuye+zadTti57VjqudWpeyIiIp2GilIiIiKdjJ/NSsLxU/VGNvO4YRg4a+o5cPQYJZUuyqprKauu4+jx27LqWo5+79ZZUw9ARU09FTX15B8581zBAbbGQlVooD/hxwtXnm2ewlVY4+PHtx2/HxUSQHSo/ex+MGIedwPsWuZZ73OJuVlERETEa1SUEhERkSYsFguOIM/peC1V3+Cm/FgdZceOF6uqvrPeWMzyFLYqauqpdNVTUeOZ+8pV7waguraB6toGiitcZ5z5wr5deXFK2hnvJz7iwFqoKYNAByQ2VyoVERGRjkhFKRERETlrfjYrXULtdPkRo5Vq691UuuqprKnHWVPXuF7hqjt+6xl9VVnjKWRVHr9/orhV6aonMjigDd6VeE1lMYTFQ1I62NQ9FRER6Sz0W19ERERMFeBnJcovgKgQFZY6rf4/gX5Xgqv5q0WKiIhIx6RL5IiIiIiI+SwWCAw3O4WIiIh4kU8UpebOnUtycjKBgYGkp6eTm5vbov0WLVqExWJhwoQJbRtQRERERERERERalelFqcWLF5OVlcWsWbNYt24dQ4cOZfz48RQXF//gfnv37uW+++7jvPPO81JSERERERERERFpLaYXpZ5++mmmTZvGlClTGDBgAPPmzSM4OJiFCxeecp+GhgZuuukmZs+eTa9evbyYVkREREREREREWoOpRana2lrWrl1LZmZm4zar1UpmZiarVq065X4PP/wwMTExTJ069bSv4XK5cDqdTRYRERERERERETGXqUWp0tJSGhoaiI2NbbI9NjaWwsLCZvdZuXIlCxYsYP78+S16jezsbBwOR+OSlJR01rlFREREREREROTsmH763pmoqKjglltuYf78+URHR7donxkzZlBeXt64FBQUtHFKERERERERERE5HT8zXzw6OhqbzUZRUVGT7UVFRcTFxZ3UfteuXezdu5errrqqcZvb7QbAz8+PvLw8evfu3WQfu92O3W5vg/QiIiIiIiIiIvJjmTpSKiAggNTUVHJychq3ud1ucnJyyMjIOKl9v3792LhxI+vXr29crr76ai666CLWr1+vU/NERERERERERNoJU0dKAWRlZTF58mRGjhxJWloac+bMoaqqiilTpgAwadIkEhMTyc7OJjAwkEGDBjXZPyIiAuCk7SIiIiIiIiIi4rtML0pNnDiRkpISZs6cSWFhIcOGDWPJkiWNk5/n5+djtbarqa9EREREREREROQ0LIZhGGaH8Kby8nIiIiIoKCggPDzc7DgiIiLi45xOJ0lJSZSVleFwOMyOYxr1oURERKSlWtp/Mn2klLdVVFQAaP4pEREROSMVFRWduiilPpSIiIicqdP1nzrdSCm3283BgwcJCwvDYrG0+vOfqAbqW0TfpOPj23R8fJuOj2/T8Wk7hmFQUVFBQkJCp55SQH2ozk3Hx7fp+Pg2HR/fpuPTNlraf+p0I6WsVivdunVr89cJDw/XP2gfpuPj23R8fJuOj2/T8WkbnXmE1AnqQwno+Pg6HR/fpuPj23R8Wl9L+k+d9+s+ERERERERERExjYpSIiIiIiIiIiLidSpKtTK73c6sWbOw2+1mR5Fm6Pj4Nh0f36bj49t0fKS9079h36bj49t0fHybjo9v0/ExV6eb6FxERERERERERMynkVIiIiIiIiIiIuJ1KkqJiIiIiIiIiIjXqSglIiIiIiIiIiJep6JUK5s7dy7JyckEBgaSnp5Obm6u2ZEEeOihh7BYLE2Wfv36mR2r0/r000+56qqrSEhIwGKx8Pbbbzd53DAMZs6cSXx8PEFBQWRmZrJjxw5zwnZCpzs+t95660mfp8suu8ycsJ1QdnY2o0aNIiwsjJiYGCZMmEBeXl6TNjU1NUyfPp0uXboQGhrKddddR1FRkUmJRU5P/SffpP6Tb1H/ybep/+Tb1H/yXSpKtaLFixeTlZXFrFmzWLduHUOHDmX8+PEUFxebHU2AgQMHcujQocZl5cqVZkfqtKqqqhg6dChz585t9vEnnniCv/zlL8ybN48vv/ySkJAQxo8fT01NjZeTdk6nOz4Al112WZPP0+uvv+7FhJ3bihUrmD59OqtXr2bp0qXU1dVx6aWXUlVV1djmN7/5De+++y5vvPEGK1as4ODBg1x77bUmphY5NfWffJv6T75D/Sffpv6Tb1P/yYcZ0mrS0tKM6dOnN95vaGgwEhISjOzsbBNTiWEYxqxZs4yhQ4eaHUOaARhvvfVW4323223ExcUZTz75ZOO2srIyw263G6+//roJCTu37x8fwzCMyZMnGz/96U9NySMnKy4uNgBjxYoVhmF4Pi/+/v7GG2+80dhm69atBmCsWrXKrJgip6T+k+9S/8l3qf/k29R/8n3qP/kOjZRqJbW1taxdu5bMzMzGbVarlczMTFatWmViMjlhx44dJCQk0KtXL2666Sby8/PNjiTN2LNnD4WFhU0+Sw6Hg/T0dH2WfMgnn3xCTEwMffv25c477+Tw4cNmR+q0ysvLAYiKigJg7dq11NXVNfkM9evXj+7du+szJD5H/Sffp/5T+6D+U/ug/pPvUP/Jd6go1UpKS0tpaGggNja2yfbY2FgKCwtNSiUnpKen8+KLL7JkyRKeffZZ9uzZw3nnnUdFRYXZ0eR7Tnxe9FnyXZdddhkvv/wyOTk5PP7446xYsYLLL7+choYGs6N1Om63m1//+tece+65DBo0CPB8hgICAoiIiGjSVp8h8UXqP/k29Z/aD/WffJ/6T75D/Sff4md2ABFvuPzyyxvXhwwZQnp6Oj169OCf//wnU6dONTGZSPtzww03NK4PHjyYIUOG0Lt3bz755BPGjRtnYrLOZ/r06WzatElzvIhIm1D/SaT1qP/kO9R/8i0aKdVKoqOjsdlsJ83OX1RURFxcnEmp5FQiIiI455xz2Llzp9lR5HtOfF70WWo/evXqRXR0tD5PXnb33Xfzn//8h+XLl9OtW7fG7XFxcdTW1lJWVtakvT5D4ovUf2pf1H/yXeo/tT/qP5lD/Sffo6JUKwkICCA1NZWcnJzGbW63m5ycHDIyMkxMJs2prKxk165dxMfHmx1Fvqdnz57ExcU1+Sw5nU6+/PJLfZZ81P79+zl8+LA+T15iGAZ33303b731FsuWLaNnz55NHk9NTcXf37/JZygvL4/8/Hx9hsTnqP/Uvqj/5LvUf2p/1H/yLvWffJdO32tFWVlZTJ48mZEjR5KWlsacOXOoqqpiypQpZkfr9O677z6uuuoqevTowcGDB5k1axY2m40bb7zR7GidUmVlZZNvhfbs2cP69euJioqie/fu/PrXv+aPf/wjffr0oWfPnjz44IMkJCQwYcIE80J3Ij90fKKiopg9ezbXXXcdcXFx7Nq1i//+7/8mJSWF8ePHm5i685g+fTqvvfYa//73vwkLC2uc58DhcBAUFITD4WDq1KlkZWURFRVFeHg499xzDxkZGYwePdrk9CInU//Jd6n/5FvUf/Jt6j/5NvWffJjZl//raP76178a3bt3NwICAoy0tDRj9erVZkcSwzAmTpxoxMfHGwEBAUZiYqIxceJEY+fOnWbH6rSWL19uACctkydPNgzDc1njBx980IiNjTXsdrsxbtw4Iy8vz9zQncgPHZ/q6mrj0ksvNbp27Wr4+/sbPXr0MKZNm2YUFhaaHbvTaO7YAMYLL7zQ2ObYsWPGXXfdZURGRhrBwcHGNddcYxw6dMi80CKnof6Tb1L/ybeo/+Tb1H/ybeo/+S6LYRhG25e+REREREREREREvqU5pURERERERERExOtUlBIREREREREREa9TUUpERERERERERLxORSkREREREREREfE6FaVERERERERERMTrVJQSERERERERERGvU1FKRERERERERES8TkUpERERERERERHxOhWlRETOksVi4e233zY7hoiIiEi7of6TiICKUiLSzt16661YLJaTlssuu8zsaCIiIiI+Sf0nEfEVfmYHEBE5W5dddhkvvPBCk212u92kNCIiIiK+T/0nEfEFGiklIu2e3W4nLi6uyRIZGQl4hoY/++yzXH755QQFBdGrVy/+9a9/Ndl/48aNXHzxxQQFBdGlSxduu+02Kisrm7RZuHAhAwcOxG63Ex8fz913393k8dLSUq655hqCg4Pp06cP77zzTtu+aREREZGzoP6TiPgCFaVEpMN78MEHue6669iwYQM33XQTN9xwA1u3bgWgqqqK8ePHExkZyZo1a3jjjTf4+OOPm3Sann32WaZPn85tt93Gxo0beeedd0hJSWnyGrNnz+bnP/8533zzDVdccQU33XQTR44c8er7FBEREWkt6j+JiFcYIiLt2OTJkw2bzWaEhIQ0Wf70pz8ZhmEYgHHHHXc02Sc9Pd248847DcMwjOeff96IjIw0KisrGx9/7733DKvVahQWFhqGYRgJCQnGAw88cMoMgPGHP/yh8X5lZaUBGB988EGrvU8RERGR1qL+k4j4Cs0pJSLt3kUXXcSzzz7bZFtUVFTjekZGRpPHMjIyWL9+PQBbt25l6NChhISEND5+7rnn4na7ycvLw2KxcPDgQcaNG/eDGYYMGdK4HhISQnh4OMXFxT/2LYmIiIi0KfWfRMQXqCglIu1eSEjIScPBW0tQUFCL2vn7+ze5b7FYcLvdbRFJRERE5Kyp/yQivkBzSolIh7d69eqT7vfv3x+A/v37s2HDBqqqqhof//zzz7FarfTt25ewsDCSk5PJycnxamYRERERM6n/JCLeoJFSItLuuVwuCgsLm2zz8/MjOjoagDfeeIORI0cyduxY/vGPf5Cbm8uCBQsAuOmmm5g1axaTJ0/moYceoqSkhHvuuYdbbrmF2NhYAB566CHuuOMOYmJiuPzyy6moqODzzz/nnnvu8e4bFREREWkl6j+JiC9QUUpE2r0lS5YQHx/fZFvfvn3Ztm0b4Lmyy6JFi7jrrruIj4/n9ddfZ8CAAQAEBwfz4Ycfcu+99zJq1CiCg4O57rrrePrppxufa/LkydTU1PD//t//47777iM6Opqf/exn3nuDIiIiIq1M/ScR8QUWwzAMs0OIiLQVi8XCW2+9xYQJE8yOIiIiItIuqP8kIt6iOaVERERERERERMTrVJQSERERERERERGv0+l7IiIiIiIiIiLidRopJSIiIiIiIiIiXqeilIiIiIiIiIiIeJ2KUiIiIiIiIiIi4nUqSomIiIiIiIiIiNepKCUiIiIiIiIiIl6nopSIiIiIiIiIiHidilIiIiIiIiIiIuJ1KkqJiIiIiIiIiIjXqSglIiIiIiIiIiJe9/8B1l9VvlKVPsUAAAAASUVORK5CYII=",
            "text/plain": [
              "<Figure size 1200x400 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Consolidated Plotting\n",
        "\n",
        "# Plot confusion matrix\n",
        "labels = ['Negative', 'Neutral', 'Positive']\n",
        "plt.figure(figsize=(8, 6))\n",
        "sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=labels, yticklabels=labels)\n",
        "plt.xlabel('Predicted')\n",
        "plt.ylabel('True')\n",
        "plt.title('Confusion Matrix')\n",
        "plt.show()\n",
        "\n",
        "# Plot metrics\n",
        "epochs_range = range(len(train_losses))\n",
        "plt.figure(figsize=(12, 4))\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.plot(epochs_range, train_losses, label='Train Loss')\n",
        "plt.plot(epochs_range, val_losses, label='Val Loss')\n",
        "plt.legend()\n",
        "plt.title('Loss over Epochs')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Loss')\n",
        "plt.subplot(1, 2, 2)\n",
        "plt.plot(epochs_range, train_accs, label='Train Accuracy')\n",
        "plt.plot(epochs_range, val_accs, label='Val Accuracy')\n",
        "plt.legend()\n",
        "plt.title('Accuracy over Epochs')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "68a47274"
      },
      "outputs": [],
      "source": [
        "# Consolidated Saving and Inference\n",
        "\n",
        "# Save final model\n",
        "torch.save(model.state_dict(), CHECKPOINT_PATH.replace('.pth', '_final.pth'))\n",
        "\n",
        "# Inference function\n",
        "def predict_image(model, image_path, transform, device):\n",
        "    model.eval()\n",
        "    try:\n",
        "        image = Image.open(image_path).convert('RGB')\n",
        "        image = transform(image).unsqueeze(0).to(device)\n",
        "        with torch.no_grad():\n",
        "            with torch.amp.autocast(device_type='cuda'):\n",
        "                output = model(image)\n",
        "                _, predicted = output.max(1)\n",
        "        return predicted.item()  # 0: neg, 1: neu, 2: pos\n",
        "    except Exception as e:\n",
        "        print(f\"Error predicting {image_path}: {e}\")\n",
        "        return None"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}