vision_transformer_colab.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "UF1tAbti47xC"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import math\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "from torchvision import datasets, transforms\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class CustomLinear(nn.Module):\n",
        "    \"\"\"\n",
        "    Custom linear transformation layer for processing image patches.\n",
        "\n",
        "    Attributes:\n",
        "        P (int): Number of patches along one dimension.\n",
        "        H (int): Height of the input image.\n",
        "        W (int): Width of the input image.\n",
        "        C (int): Number of channels in the input image.\n",
        "        d (int): Dimensionality of the output features.\n",
        "        input_dim (int): Dimensionality of the input features after patching and flattening.\n",
        "        linear (nn.Linear): Linear layer for projecting input features to output features.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, P, H, W, C, d):\n",
        "        super(CustomLinear, self).__init__()\n",
        "        self.P = P\n",
        "        self.H = H\n",
        "        self.W = W\n",
        "        self.C = C\n",
        "        self.d = d\n",
        "\n",
        "        self.input_dim = (H * C // P) * (W * C // P)\n",
        "\n",
        "        self.linear = nn.Linear(self.input_dim, d)\n",
        "\n",
        "    def forward(self, x):\n",
        "        \"\"\"\n",
        "        Forward pass of the CustomLinear layer.\n",
        "\n",
        "        Args:\n",
        "            x (torch.Tensor): Input tensor of shape (B, P*P, input_dim), where\n",
        "                B is the batch size, P*P is the number of patches, and\n",
        "                input_dim is the dimensionality of each patch.\n",
        "\n",
        "        Returns:\n",
        "            torch.Tensor: Output tensor of shape (B, P*P, d), where\n",
        "                B is the batch size, P*P is the number of patches, and\n",
        "                d is the dimensionality of the output features.\n",
        "        \"\"\"\n",
        "        B, _, _ = x.shape\n",
        "\n",
        "        # Flatten the last dimension.\n",
        "        x = x.view(B, self.P * self.P, self.input_dim)\n",
        "\n",
        "        # Apply the linear projection.\n",
        "        x = self.linear(x)\n",
        "\n",
        "        return x"
      ],
      "metadata": {
        "id": "xrj18lYf4pm1"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class MHSA(nn.Module):\n",
        "    \"\"\"\n",
        "    Multi-Head Self-Attention (MHSA) class.\n",
        "\n",
        "    Attributes:\n",
        "        d (int): Dimensionality of the model.\n",
        "        n_heads (int): Number of attention heads.\n",
        "        head_dim (int): Dimensionality of each attention head.\n",
        "        query_layer (nn.Linear): Linear layer for query vectors.\n",
        "        key_layer (nn.Linear): Linear layer for key vectors.\n",
        "        value_layer (nn.Linear): Linear layer for value vectors.\n",
        "        out (nn.Linear): Output linear layer.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, d, n_heads=2):\n",
        "        super(MHSA, self).__init__()\n",
        "        assert d % n_heads == 0, \"Embedding dimension must be divisible by n_heads\"\n",
        "\n",
        "        self.d = d\n",
        "        self.n_heads = n_heads\n",
        "        self.head_dim = d // n_heads\n",
        "\n",
        "        self.query_layer = nn.Linear(in_features=d, out_features=d)\n",
        "        self.key_layer = nn.Linear(in_features=d, out_features=d)\n",
        "        self.value_layer = nn.Linear(in_features=d, out_features=d)\n",
        "        self.out = nn.Linear(in_features=d, out_features=d)\n",
        "\n",
        "    def split_heads(self, x):\n",
        "        \"\"\"\n",
        "        Split the input tensor into multiple heads.\n",
        "\n",
        "        Args:\n",
        "            x (torch.Tensor): Input tensor of shape (N, seq_length, token_dim).\n",
        "\n",
        "        Returns:\n",
        "            torch.Tensor: Tensor of shape (N, n_heads, seq_length, head_dim).\n",
        "        \"\"\"\n",
        "        N, seq_length, token_dim = x.shape\n",
        "        x = x.view(N, seq_length, self.n_heads, self.head_dim)\n",
        "        return x.permute(0, 2, 1, 3)\n",
        "\n",
        "    def forward(self, sequences):\n",
        "        \"\"\"\n",
        "        Forward pass for the MHSA.\n",
        "\n",
        "        Args:\n",
        "            sequences (torch.Tensor): Input tensor of shape (N, seq_length, token_dim).\n",
        "\n",
        "        Returns:\n",
        "            torch.Tensor: Output tensor of shape (N, seq_length, d).\n",
        "        \"\"\"\n",
        "        # Sequences has shape (N, seq_length, token_dim)\n",
        "        # Shape is transformed to   (N, seq_length, n_heads, token_dim / n_heads)\n",
        "        # And finally we return back    (N, seq_length, item_dim)  (through concatenation)\n",
        "        N, seq_length, token_dim = sequences.shape\n",
        "\n",
        "        q = self.split_heads(self.query_layer(sequences))\n",
        "        k = self.split_heads(self.key_layer(sequences))\n",
        "        v = self.split_heads(self.value_layer(sequences))\n",
        "\n",
        "        scores = torch.matmul(q, k.transpose(-2, -1)) / torch.sqrt(torch.tensor(self.head_dim, dtype=torch.float32))\n",
        "        self_attn_weights = F.softmax(scores, dim=-1)\n",
        "\n",
        "        self_attn_output = torch.matmul(self_attn_weights, v)\n",
        "        self_attn_output = self_attn_output.permute(0, 2, 1, 3).contiguous()\n",
        "        self_attn_output = self_attn_output.view(N, seq_length, self.d)\n",
        "\n",
        "        output = self.out(self_attn_output)\n",
        "\n",
        "        return output"
      ],
      "metadata": {
        "id": "frmO_nJ55LK1"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class ViTEncoder(nn.Module):\n",
        "    \"\"\"\n",
        "    Vision Transformer Encoder class.\n",
        "\n",
        "    Attributes:\n",
        "        hidden_d (int): Dimensionality of the hidden layer.\n",
        "        n_heads (int): Number of attention heads.\n",
        "        norm1 (nn.LayerNorm): Layer normalization layer before MHSA.\n",
        "        mhsa (MHSA): Multi-Head Self-Attention layer.\n",
        "        norm2 (nn.LayerNorm): Layer normalization layer before MLP.\n",
        "        mlp (nn.Sequential): Multi-Layer Perceptron.\n",
        "    \"\"\"\n",
        "    def __init__(self, hidden_d, n_heads):\n",
        "        super(ViTEncoder, self).__init__()\n",
        "        self.hidden_d = hidden_d\n",
        "        self.n_heads = n_heads\n",
        "\n",
        "        self.norm1 = nn.LayerNorm(normalized_shape=hidden_d)\n",
        "        self.mhsa = MHSA(d=hidden_d, n_heads=n_heads)\n",
        "        self.norm2 = nn.LayerNorm(normalized_shape=hidden_d)\n",
        "        self.mlp = nn.Sequential(\n",
        "            nn.Linear(in_features=hidden_d, out_features=4 * hidden_d),\n",
        "            nn.GELU(),\n",
        "            nn.Linear(in_features=4 * hidden_d, out_features=hidden_d)\n",
        "        )\n",
        "\n",
        "    def forward(self, x):\n",
        "        \"\"\"Forward pass for the ViTEncoder.\n",
        "\n",
        "        Args:\n",
        "            x (torch.Tensor): Input tensor of shape (B, seq_len, hidden_d).\n",
        "\n",
        "        Returns:\n",
        "            torch.Tensor: Output tensor of shape (B, seq_len, hidden_d).\n",
        "        \"\"\"\n",
        "        attn_output = self.mhsa(self.norm1(x))\n",
        "        x = x + attn_output\n",
        "\n",
        "        mlp_output = self.mlp(self.norm2(x))\n",
        "        x = x + mlp_output\n",
        "\n",
        "        return x"
      ],
      "metadata": {
        "id": "-AisZJrM5VbE"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class LightViT(nn.Module):\n",
        "    \"\"\"\n",
        "    Lightweight Vision Transformer (LightViT) class.\n",
        "\n",
        "    Attributes:\n",
        "        image_dim (tuple): Dimensions of the input image (B, C, H, W).\n",
        "        n_patches (int): Number of patches to divide the image into.\n",
        "        d (int): Dimensionality of the model.\n",
        "        n_blocks (int): Number of transformer blocks.\n",
        "        n_heads (int): Number of attention heads.\n",
        "        num_classes (int): Number of output classes.\n",
        "        patch_dim (tuple): Dimensions of each patch.\n",
        "        linear_map (nn.Linear): Linear mapping layer for patches.\n",
        "        cls_token (nn.Parameter): Learnable classification token.\n",
        "        pos_embedding (torch.Tensor): Positional embeddings.\n",
        "        encoders (nn.ModuleList): List of encoder blocks.\n",
        "        classifier (nn.Sequential): Classification head.\n",
        "    \"\"\"\n",
        "\n",
        "    def __init__(self, image_dim, n_patches=7, n_blocks=2, d=8, n_heads=2, num_classes=10):\n",
        "        super(LightViT, self).__init__()\n",
        "\n",
        "        # Class Members.\n",
        "        self.image_dim = image_dim\n",
        "        self.n_patches = n_patches\n",
        "        self.d = d\n",
        "        self.n_blocks = n_blocks\n",
        "        self.n_heads = n_heads\n",
        "        self.num_classes = num_classes\n",
        "\n",
        "        B, C, H, W = self.image_dim\n",
        "        patch_size_H = H // self.n_patches\n",
        "        patch_size_W = W // self.n_patches\n",
        "        self.patch_dim = (C, patch_size_H, patch_size_W)\n",
        "\n",
        "        # 1B) Linear Mapping.\n",
        "        self.linear_map = CustomLinear(self.n_patches, H, W, C, self.d)\n",
        "\n",
        "        # 2A) Learnable Parameter.\n",
        "        self.cls_token = nn.Parameter(data=torch.randn(1, 1, self.d))\n",
        "\n",
        "        # 2B) Positional embedding.\n",
        "        self.pos_embedding = self.get_pos_embeddings(embedding_num=n_patches * n_patches + 1, embedding_dim=self.d)\n",
        "\n",
        "        # 3) Encoder blocks\n",
        "        self.encoders = nn.ModuleList([ViTEncoder(hidden_d=self.d, n_heads=self.n_heads) for _ in range(self.n_blocks)])\n",
        "\n",
        "        # 5) Classification Head\n",
        "        self.classifier = nn.Sequential(\n",
        "            nn.LayerNorm(normalized_shape=self.d),\n",
        "            nn.Linear(in_features=self.d, out_features=self.num_classes)\n",
        "        )\n",
        "        # TODO: do we need layer norm in classifier?\n",
        "\n",
        "    def forward(self, images):\n",
        "        \"\"\"\n",
        "        Forward pass for the LightViT model.\n",
        "\n",
        "        Args:\n",
        "            images (torch.Tensor): Input tensor of shape (B, C, H, W).\n",
        "\n",
        "        Returns:\n",
        "            torch.Tensor: Output tensor of shape (B, num_classes).\n",
        "        \"\"\"\n",
        "        # Extract the patches from images.\n",
        "        patches = self.get_patches(images, num_patches_per_dim=self.n_patches)\n",
        "\n",
        "        # Linearly project patches to embeddings of size d.\n",
        "        embeddings = self.linear_map(patches)\n",
        "        # TODO: Check if I should do flattening and reshaping.\n",
        "\n",
        "        # Classification token is like a learnable kernel of size like a patch with all zeros.\n",
        "        # We add it to other patches -> shape = (B, num_patches + 1, patch_size*patch_size).\n",
        "        # We do that for each sample in the batch.\n",
        "        batch_size = embeddings.size(0)\n",
        "        cls_tokens = self.cls_token.expand(batch_size, -1, -1).to(images.device)\n",
        "        embeddings = torch.cat((cls_tokens, embeddings), dim=1)\n",
        "\n",
        "        # Add positional embeddings.\n",
        "        embeddings = embeddings + self.pos_embedding.to(images.device)\n",
        "        x = embeddings\n",
        "\n",
        "        # Pass through the encoder.\n",
        "        for layer in self.encoders:\n",
        "            x = layer(x)\n",
        "\n",
        "        # Get classification tokens.\n",
        "        cls_tokens_learned = x[:, 0]\n",
        "\n",
        "        # Pass through the classifier.\n",
        "        output = self.classifier(cls_tokens_learned)\n",
        "\n",
        "        return output\n",
        "\n",
        "    @staticmethod\n",
        "    def get_patches(x, num_patches_per_dim=7):\n",
        "        \"\"\"\n",
        "        Extract patches from an input image.\n",
        "\n",
        "        Args:\n",
        "        x (torch.Tensor): Input image of shape (B, C, H, W).\n",
        "        num_patches_per_dim (int): Number of patches along each dimension.\n",
        "\n",
        "        Returns:\n",
        "        torch.Tensor: Output patches of shape (B, num_patches, patch_dim),\n",
        "                      where num_patches = (H/P) * (W/P) and patch_dim = C * P * P.\n",
        "        \"\"\"\n",
        "        B, C, H, W = x.shape\n",
        "        patch_size_h = H // num_patches_per_dim\n",
        "        patch_size_w = W // num_patches_per_dim\n",
        "\n",
        "        assert H % num_patches_per_dim == 0 and W % num_patches_per_dim == 0, \"Image dimensions must be divisible by the number of patches per dimension.\"\n",
        "\n",
        "        # Calculate the number of patches along height and width.\n",
        "        num_patches_h = H // patch_size_h\n",
        "        num_patches_w = W // patch_size_w\n",
        "        num_patches = num_patches_h * num_patches_w\n",
        "        patch_dim = C * patch_size_h * patch_size_w\n",
        "\n",
        "        # Use unfold to create patches.\n",
        "        patches = x.unfold(2, size=patch_size_h, step=patch_size_h)  # unfold height dimension\n",
        "        patches = patches.unfold(3, size=patch_size_w, step=patch_size_w)  # unfold width dimension\n",
        "\n",
        "        # Re-arrange the patches to satisfy our required dimensions (B, P*P, CxHxW/P*P).\n",
        "        patches = patches.permute(0, 2, 3, 1, 4, 5).contiguous()\n",
        "\n",
        "        # Flatten the last dimensions.\n",
        "        patches = patches.view(B, -1, C * patch_size_h * patch_size_w)\n",
        "\n",
        "        return patches\n",
        "\n",
        "    @staticmethod\n",
        "    def get_pos_embeddings(embedding_num, embedding_dim):\n",
        "        \"\"\"\n",
        "        Generate positional embeddings.\n",
        "\n",
        "        Args:\n",
        "            embedding_num (int): Number of embeddings.\n",
        "            embedding_dim (int): Dimensionality of each embedding.\n",
        "\n",
        "        Returns:\n",
        "            torch.Tensor: Positional embeddings of shape (1, embedding_num, embedding_dim).\n",
        "        \"\"\"\n",
        "        # Create a matrix of size embedding_num * embedding_dim (d) to store all positional embeddings.\n",
        "        pos_embedding = torch.empty(embedding_num, embedding_dim)\n",
        "\n",
        "        position = torch.arange(0, embedding_num, dtype=torch.float).unsqueeze(1)\n",
        "        div_term = torch.exp(torch.arange(0, embedding_dim, 2).float() * (-math.log(10000.0) / embedding_dim))\n",
        "\n",
        "        # Embed even indices using sin, uneven using cos.\n",
        "        pos_embedding[:, 0::2] = torch.sin(position * div_term)\n",
        "        pos_embedding[:, 1::2] = torch.cos(position * div_term)\n",
        "        pos_embedding = pos_embedding.unsqueeze(0)\n",
        "\n",
        "        return pos_embedding"
      ],
      "metadata": {
        "id": "R3smCEdw5cQ8"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def train_model(model, device, train_loader, criterion, optimizer, epoch):\n",
        "    \"\"\"Train the model.\n",
        "\n",
        "    Args:\n",
        "        model (torch.nn.Module): The model to train.\n",
        "        device (torch.device): The device to run the training on.\n",
        "        train_loader (torch.utils.data.DataLoader): DataLoader for training data.\n",
        "        criterion (torch.nn.Module): Loss function.\n",
        "        optimizer (torch.optim.Optimizer): Optimizer.\n",
        "        epoch (int): Number of current epoch.\n",
        "\n",
        "    Returns:\n",
        "        list: List of train losses.\n",
        "    \"\"\"\n",
        "    model.train()\n",
        "    for batch_idx, (images, labels) in enumerate(train_loader):\n",
        "        images, labels = images.to(device), labels.to(device)\n",
        "        optimizer.zero_grad()\n",
        "        outputs = model(images)\n",
        "        loss = criterion(outputs, labels)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "    print(f'Epoch {epoch+1}, Loss: {loss.item():.4f}')\n",
        "\n",
        "    return loss.item()\n",
        "\n",
        "\n",
        "def test_model(model, device, test_loader, criterion):\n",
        "    \"\"\"\n",
        "    Test the model.\n",
        "\n",
        "    Args:\n",
        "        model (torch.nn.Module): The model to test.\n",
        "        device (torch.device): The device to run the training on.\n",
        "        test_loader (torch.utils.data.DataLoader): DataLoader for test data.\n",
        "        criterion (torch.nn.Module): Loss function.\n",
        "\n",
        "    Returns:\n",
        "        float: Loss at the current epoch.\n",
        "        float: Accuracy at the current epoch.\n",
        "    \"\"\"\n",
        "    model.eval()\n",
        "    total_loss = 0\n",
        "    total_correct = 0\n",
        "    with torch.no_grad():\n",
        "        for images, labels in test_loader:\n",
        "            images, labels = images.to(device), labels.to(device)\n",
        "            outputs = model(images)\n",
        "            loss = criterion(outputs, labels)\n",
        "            total_loss += loss.item()\n",
        "            _, predicted = torch.max(outputs, 1)\n",
        "            total_correct += (predicted == labels).sum().item()\n",
        "    total_loss = total_loss / len(test_loader)\n",
        "    total_correct = total_correct/len(test_loader.dataset)\n",
        "    print(f'Test Loss: {total_loss:.4f}, Accuracy: {total_correct:.4f}')\n",
        "\n",
        "    return total_loss, total_correct\n",
        "\n",
        "\n",
        "def train_test_model(model, device, train_loader, test_loader, transforms):\n",
        "    \"\"\"\n",
        "    Train and test the model, then plot the training and test loss over epochs.\n",
        "\n",
        "    Args:\n",
        "        model (torch.nn.Module): The model to train and test.\n",
        "        device (torch.device): The device to run the training on.\n",
        "        train_loader (torch.utils.data.DataLoader): DataLoader for training data.\n",
        "        test_loader (torch.utils.data.DataLoader): DataLoader for test data.\n",
        "        transforms (torchvision.transforms.Compose): Transformations to apply to the data.\n",
        "\n",
        "    \"\"\"\n",
        "    # Define the optimizer.\n",
        "    optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
        "\n",
        "    # Define the loss.\n",
        "    criterion = nn.CrossEntropyLoss()\n",
        "\n",
        "    train_losses = []\n",
        "    test_losses = []\n",
        "    test_accs = []\n",
        "\n",
        "    # Train the model.\n",
        "    for epoch in range(5):\n",
        "        train_loss = train_model(model, device, train_loader, criterion, optimizer, epoch)\n",
        "        test_loss, test_acc = test_model(model, device, test_loader, criterion)\n",
        "        train_losses.append(train_loss)\n",
        "        test_losses.append(test_loss)\n",
        "        test_accs.append(test_acc * 100.)\n",
        "\n",
        "    # Plot the training.\n",
        "    plt.figure(figsize=(10, 5))\n",
        "    plt.plot(train_losses, label='Training loss')\n",
        "    plt.plot(test_losses, label='Test loss')\n",
        "    plt.title(f'Training and test loss of LViT. lr: 0.001. Final Accuracy: {test_accs[-1]:.2f}%')\n",
        "    plt.xlabel('Epoch')\n",
        "    plt.ylabel('Loss')\n",
        "    plt.legend()\n",
        "    plt.show()"
      ],
      "metadata": {
        "id": "8aHHJFls5iu8"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "## Train and test on MNIST dataset.\n",
        "\n",
        "# Check if GPU is available.\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "# Define a transform to normalize the data.\n",
        "transform = transforms.Compose([\n",
        "    transforms.Resize((28, 28)),\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize((0.1307,), (0.3081,))\n",
        "])\n",
        "\n",
        "# Download and load the training data.\n",
        "train_set = datasets.MNIST(root='./data', train=True, download=True, transform=transform)\n",
        "train_loader = torch.utils.data.DataLoader(train_set, batch_size=32, shuffle=True)\n",
        "\n",
        "# Download and load the test data\n",
        "test_set = datasets.MNIST(root='./data', train=False, download=True, transform=transform)\n",
        "test_loader = torch.utils.data.DataLoader(test_set, batch_size=32, shuffle=False)\n",
        "\n",
        "# Define the model.\n",
        "model = LightViT(image_dim=(32, 1, 28, 28), n_patches=7, d=8)\n",
        "model.to(device)\n",
        "\n",
        "train_test_model(model, device, train_loader, test_loader, transform)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 661
        },
        "id": "AM3-E1FT5oe0",
        "outputId": "b342f3d9-20cd-42c4-f963-6a321ec1e104"
      },
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1, Loss: 1.0843\n",
            "Test Loss: 0.8197, Accuracy: 0.7149\n",
            "Epoch 2, Loss: 0.7075\n",
            "Test Loss: 0.6804, Accuracy: 0.7748\n",
            "Epoch 3, Loss: 0.5371\n",
            "Test Loss: 0.4637, Accuracy: 0.8464\n",
            "Epoch 4, Loss: 0.6618\n",
            "Test Loss: 0.3922, Accuracy: 0.8757\n",
            "Epoch 5, Loss: 0.2201\n",
            "Test Loss: 0.3654, Accuracy: 0.8805\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x500 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA04AAAHWCAYAAABACtmGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACYsElEQVR4nOzdd1yV5f/H8ddhL1kCigoOVHBPcK+ytMzShqtyVFrZ+rbnr2xa2bA0tbS0LPestFIrzZy4TcWt4AQHICLrnPv3x9GjCCIqcBjv5+NxHnWue30OcuC8ua77ukyGYRiIiIiIiIjIFTnYuwAREREREZHiTsFJRERERETkKhScRERERERErkLBSURERERE5CoUnERERERERK5CwUlEREREROQqFJxERERERESuQsFJRERERETkKhScRERERERErkLBSaQQDRw4kGrVql3XscOGDcNkMhVsQcXMgQMHMJlMTJo0yd6lXBeTycSwYcPsXcZ1i46OpnXr1nh6emIymdi0aVOhX7NatWoMHDiwUM5dFt4z9rR06VJMJhNLly4t1OuU9PeViJReCk5SJplMpnw9CvsDguTP9u3bGTZsGAcOHCjU64wZM6bEhrhrlZmZyX333cepU6f4/PPPmTx5MlWrVs113wsfmGfNmpWtfcOGDZhMJt54440rXmf37t2YTCaee+65HNuqVauWr/dhcfg3sVgsfPzxx1SvXh03NzcaNmzI1KlT8318YmIiQ4YMITAwEE9PTzp16sSGDRty3ffnn3+madOmuLm5ERoayltvvUVWVla2fSZNmnTFr9exY8eu6zVeCJ65PcaNG3dd5ywKO3bswGQy4ebmRmJior3LKfHWr1/PHXfcQcWKFfHy8qJhw4Z8+eWXmM3mbPulpaUxfPhw6tati4eHB5UrV+a+++5j27Zt+bpOft9TAwcOzPV7MiIiItt+iYmJ3H///fj5+VGjRg2+/fbbHOdat24dHh4e7N+//xq+IiIXOdm7ABF7mDx5crbnP/zwA4sXL87RXqdOnRu6zvjx47FYLNd17BtvvMErr7xyQ9cvLbZv387bb79Nx44dr7sHLz/GjBlDQEBAofWIFCd79+7l4MGDjB8/nkceeeS6ztG0aVMiIiKYOnUq7733Xq77TJkyBYAHHngAgJ07d+LgYP2b3ciRI0lJSbHtu3DhQqZOncrnn39OQECArb1169bXVV9Bev311/nwww8ZPHgwkZGRzJ8/n379+mEymejTp0+ex1osFrp168bmzZt58cUXCQgIYMyYMXTs2JH169dTq1Yt276//fYbPXr0oGPHjowaNYqtW7fy3nvvER8fz9ixY3Oc+5133qF69erZ2nx9fW/otY4dOxYvL69sbS1atCAsLIxz587h4uJyQ+cvaD/++CMVK1bk9OnTzJo167q/n8Uamlq3bk2tWrV4+eWX8fDw4LfffuOZZ55h7969fPHFF7Z977//fn7++WcGDx5M06ZNOXLkCF999RWtWrVi69atV/xDzAXX8p5ydXVlwoQJ2dp8fHyyPX/hhRdYunQpb7/9Nnv27GHw4MHUqVPH9vPDMAyefvpp/ve//+V4z4jkmyEixhNPPGHk5+1w9uzZIqim7Ni/f78BGBMnTsxzv5kzZxqA8ffffxdqPfXq1TM6dOiQ7/0B46233iq0egrTsmXLDMCYOXPmVff9+++/r7jvu+++awDGqlWrcj02PDzciIiIyFdNI0aMMABj//79+dr/cm+99dZV38dms9k4d+7cNZ330KFDhrOzs/HEE0/Y2iwWi9GuXTujSpUqRlZWVp7HT58+PcfXLz4+3vD19TX69u2bbd+6desajRo1MjIzM21tr7/+umEymYwdO3bY2iZOnGgARnR09DW9lrxc+PolJCQU2Dmvx7W8rywWi1GtWjXjueeeM3r27Gl07NixcIu7ASkpKfYu4aoGDx5suLi4GCdPnszW3r59e8Pb29v2/NChQwZgvPDCC9n2++uvvwzA+Oyzz/K8zrW8pwYMGGB4enpetfYKFSoY33//ve15hw4djFdeecX2fPLkyUalSpWMM2fOXPVcIleioXoiV9CxY0fq16/P+vXrad++PR4eHrz22msAzJ8/n27dulGpUiVcXV0JCwvj3XffzTGU4fJ7nC7c0/PJJ5/wzTffEBYWhqurK5GRkURHR2c7Nrf7NUwmE08++STz5s2jfv36uLq6Uq9ePX7//fcc9S9dupTmzZvj5uZGWFgYX3/9db7vAVm+fDn33XcfoaGhuLq6EhISwrPPPsu5c+dyvD4vLy8OHz5Mjx498PLyIjAwkBdeeCHH1yIxMZGBAwfi4+ODr68vAwYMyNewmkmTJnHfffcB0KlTp1yHUf7222+0a9cOT09PypUrR7du3XIMFzl27BiDBg2iSpUquLq6EhwczF133WUb/letWjW2bdvGsmXLbNfo2LHjVeu73MaNG7ntttvw9vbGy8uLm2++mdWrV2fbJzMzk7fffptatWrh5uZG+fLladu2LYsXL853vXn566+/bF8PX19f7rrrLnbs2GHbPnDgQDp06ADAfffdd92vFax/dYaLPUuXWr9+PTt37rTtA4V7j1NuLrxnfvrpJ+rVq4erq6vt/bJ371727t171XPMnz+fzMxMhg4dmu28jz/+OIcOHWLVqlV5Hj9r1iwqVKjA3XffbWsLDAykV69ezJ8/n/T0dMDas7p9+3aGDBmCk9PFASFDhw7FMIwcQyUvOHPmTI73W2HI7R6nCz8nt2/fTqdOnWxDtj7++ONsx2ZkZPDmm2/SrFkzfHx88PT0pF27dvz99983VNOKFSs4cOAAffr0oU+fPvzzzz8cOnQox34Wi4UvvviCBg0a4ObmRmBgIF27dmXdunXZ9vvxxx+JiorCw8MDPz8/2rdvz6JFi2zbr3T/1eXf1xeGUi5btoyhQ4cSFBRElSpVADh48CBDhw4lPDwcd3d3ypcvz3333ZfrezsxMZFnn32WatWq4erqSpUqVejfvz8nTpwgJSUFT09PnnnmmRzHHTp0CEdHR4YPH05mZiYxMTEcPXr0ql/P5ORk3NzccvRaBgcH4+7ubnt+5swZACpUqJBjPyDbvrm5nveU2WwmOTn5iuc8d+4cfn5+tuf+/v6kpqYCcPbsWV555RWGDx+eozdV5FpoqJ5IHk6ePMltt91Gnz59eOCBB2y/JCZNmoSXlxfPPfccXl5e/PXXX7z55pskJyczYsSIq553ypQpnDlzhkcffRSTycTHH3/M3Xffzb59+3B2ds7z2H///Zc5c+YwdOhQypUrx5dffsk999xDbGws5cuXB6wf3rt27UpwcDBvv/02ZrOZd955h8DAwHy97pkzZ5Kamsrjjz9O+fLlWbt2LaNGjeLQoUPMnDkz275ms5kuXbrQokULPvnkE5YsWcKnn35KWFgYjz/+OGAdInHXXXfx77//8thjj1GnTh3mzp3LgAEDrlpL+/btefrpp/nyyy957bXXbMMnL/x38uTJDBgwgC5duvDRRx+RmprK2LFjadu2LRs3brQF13vuuYdt27bx1FNPUa1aNeLj41m8eDGxsbFUq1aNkSNH8tRTT+Hl5cXrr78O5PxQcDXbtm2jXbt2eHt789JLL+Hs7MzXX39Nx44dWbZsGS1atACsoXj48OE88sgjREVFkZyczLp169iwYQO33HJLvuq9kiVLlnDbbbdRo0YNhg0bxrlz5xg1ahRt2rRhw4YNVKtWjUcffZTKlSvzwQcf8PTTTxMZGXnNr/WC6tWr07p1a2bMmMHnn3+Oo6OjbduFMNWvX7/rOndB+euvv5gxYwZPPvkkAQEBtq/fzTffDHDVMLpx40Y8PT1zDN2NioqybW/btm2exzdt2tQ2RPHS47/55ht27dpFgwYN2LhxIwDNmzfPtl+lSpWoUqWKbfulOnXqREpKCi4uLnTp0oVPP/0029C/63Hq1Klszx0dHbN9IL3c6dOn6dq1K3fffTe9evVi1qxZvPzyyzRo0IDbbrsNsH4gnzBhAn379mXw4MGcOXOGb7/9li5durB27VoaN258XbX+9NNPhIWFERkZSf369fHw8GDq1Km8+OKL2fZ7+OGHmTRpErfddhuPPPIIWVlZLF++nNWrV9u+3m+//TbDhg2jdevWvPPOO7i4uLBmzRr++usvbr311uuqb+jQoQQGBvLmm29y9uxZwDopy8qVK+nTpw9VqlThwIEDjB07lo4dO7J9+3Y8PDwASElJoV27duzYsYOHHnqIpk2bcuLECX7++WcOHTpE48aN6dmzJ9OnT+ezzz7L9t6bOnUqhmFw//33c/jwYerUqcOAAQOuer9gx44dmT59Oo8++ijPPfecbajenDlzsv1uCwsLo0qVKnz66aeEh4fTpEkTjhw5wksvvUT16tWvOnz1Wt9TqampeHt7k5qaip+fH3379uWjjz7KFoIiIyP57LPPiIiIYN++ffz++++MHz8egA8++IDKlSvz4IMP5lmXyFXZucdLpFjIbahehw4dDMAYN25cjv1TU1NztD366KOGh4eHkZaWZmsbMGCAUbVqVdvzC0PTypcvb5w6dcrWPn/+fAMwfvnlF1tbbsOOAMPFxcXYs2ePrW3z5s0GYIwaNcrW1r17d8PDw8M4fPiwrW337t2Gk5NTvoYk5vb6hg8fbphMJuPgwYPZXh9gvPPOO9n2bdKkidGsWTPb83nz5hmA8fHHH9vasrKyjHbt2t3QUL0zZ84Yvr6+xuDBg7O1Hzt2zPDx8bG1nz592gCMESNG5HmdGx2q16NHD8PFxcXYu3evre3IkSNGuXLljPbt29vaGjVqZHTr1u2K581vvblp3LixERQUlG2ozebNmw0HBwejf//+tra8ht9d7mr7fvXVVwZg/PHHH7Y2s9lsVK5c2WjVqlW2fatWrWoMGDAg1/MUxlA9wHBwcDC2bduWY/+qVatme39eSbdu3YwaNWrkaD979qwBZBsOlBtPT0/joYceytG+YMECAzB+//13wzAuvv7Y2Ngc+0ZGRhotW7a0PZ8+fboxcOBA4/vvvzfmzp1rvPHGG4aHh4cREBCQ6/H5ceHrd/njwtfowvfBpe/DCz8nf/jhB1tbenq6UbFiReOee+6xtWVlZRnp6enZrnf69GmjQoUKOb42l7+vriQjI8MoX7688frrr9va+vXrZzRq1CjbfheGjz399NM5zmGxWAzDsP58dHBwMHr27GmYzeZc98mrtsu/ry8MpWzbtm2OoZy5/XxdtWpVjq/jm2++aQDGnDlzrlj3H3/8YQDGb7/9lm17w4YNbT/LLvzeudL77lJZWVnGk08+aTg7O9v+/R0dHY2xY8fm2HfNmjVGWFhYtu+VZs2aGUePHr3qda7lPfXKK68YL7/8sjF9+nRj6tSptt87bdq0yTakdcuWLUaVKlVstdxzzz2G2Ww29u3bZ7i7u19xOLHItdBQPZE8uLq6MmjQoBztlw9ZOHHiBO3atSM1NZWYmJirnrd3797Z/oLbrl07APbt23fVYzt37kxYWJjtecOGDfH29rYdazabWbJkCT169KBSpUq2/WrWrGn76+/VXPr6zp49y4kTJ2jdujWGYeT6V+/HHnss2/N27dpley0LFy7EycnJ1gMF1r9iP/XUU/mq50oWL15MYmIiffv25cSJE7aHo6MjLVq0sA0Dcnd3x8XFhaVLl3L69OkbuuaVmM1mFi1aRI8ePahRo4atPTg4mH79+vHvv//ahpn4+vqybds2du/eneu5rrfeo0ePsmnTJgYOHIi/v7+tvWHDhtxyyy0sXLjwOl9d3nr37o2zs3O24XrLli3j8OHD2Ybp2UuHDh2oW7dujvYDBw7ka+jjuXPncHV1zdHu5uZm214Qx1/475X2vfQ6vXr1YuLEifTv358ePXrw7rvv8scff3Dy5Enef//9q76mvMyePZvFixfbHj/99FOe+3t5edkm/wBwcXEhKioq288AR0dH26QSFouFU6dOkZWVRfPmza84u+DV/Pbbb5w8eZK+ffva2vr27cvmzZuzDdWdPXs2JpOJt956K8c5LgxdnjdvHhaLhTfffDNHz+CNTHE/ePDgbD1BkP3na2ZmJidPnqRmzZr4+vpm+1rMnj2bRo0a0bNnzyvW3blzZypVqpTt3+i///5jy5Yttn+TatWqYRhGvmandHR0JCwsjC5duvD9998zffp0unfvzlNPPcW8efOy7evn50fjxo155ZVXmDdvHp988gkHDhzgvvvuIy0tLc/rXMt7avjw4Xz44Yf06tWLPn36MGnSJN5//31WrFiRbfhqgwYN2L17N9HR0ezevZtZs2bh4ODA888/zz333EPLli2ZM2cOjRo1onr16rzzzjsYhnHVr4nIpRScRPJQuXLlXGeQ2rZtGz179sTHxwdvb28CAwNtv6SSkpKuet7Q0NBszy+EqPx8SL782AvHXzg2Pj6ec+fOUbNmzRz75daWm9jYWNuH7wv3LV24J+by13fhfoEr1QPWMf3BwcE5xpaHh4fnq54ruRA8brrpJgIDA7M9Fi1aRHx8PGD9IPrRRx/x22+/UaFCBdq3b8/HH3983dM25yYhIYHU1NRcX1OdOnWwWCzExcUB1pnQEhMTqV27Ng0aNODFF19ky5Yttv2vt96DBw8CuX9d69Spw4kTJ2zDhQpS+fLl6dKlC3PnzrV9YJoyZQpOTk706tWrwK93rW50Bi13d3fbfUiXuvBar3Y/R36Pv/DfK+17teu0bduWFi1asGTJkjz3u5r27dvTuXNn26NNmzZ57l+lSpUc4eLynwEA33//PQ0bNrTd1xcYGMiCBQvy9TMzNz/++CPVq1fH1dWVPXv2sGfPHsLCwvDw8MgWJPbu3UulSpWy/THhcnv37sXBwSHXgH0jcvveO3fuHG+++SYhISG4uroSEBBAYGAgiYmJ2b4We/fupX79+nme38HBgfvvv5958+bZ7uf56aefcHNzs90bei0+/PBDPvroI6ZOnUr//v3p1asXc+fOpW3btjzxxBO2afGTkpJo164drVq1Yvjw4dx11108//zzzJ49m3///ZeJEyfmeZ0bfU89++yzODg45Phed3Nzo3nz5rbfdX/99ReLFi3iww8/ZOfOnfTp04f//e9/fPfdd2Vq+QkpOApOInnI7Yd3YmIiHTp0YPPmzbzzzjv88ssvLF68mI8++gggX9OPX/4XyAvy89evGzk2P8xmM7fccgsLFizg5ZdfZt68eSxevNj2C+by13eleorChVomT56c7S/kFx7z58+37fu///2PXbt2MXz4cNzc3Pi///s/6tSpk2sPWmFr3749e/fu5bvvvqN+/fpMmDCBpk2bZptutzjVmx8PPPAAycnJ/Prrr2RkZDB79mxuvfXWfN9XV5iu9iHsaoKDgzl27FiO99iFm+0v7dm90vG53Zh/+fEXbqy/0r5Xuw5ASEhIjnuUClt+fib9+OOPDBw4kLCwML799lt+//13Fi9ezE033XRdSzYkJyfzyy+/sH//fmrVqmV71K1bl9TUVKZMmVKkvQlXmpwjt++9p556ivfff59evXoxY8YMFi1axOLFiylfvvx1fS369+9PSkoK8+bNwzAMpkyZwh133JFjuu78GDNmDDfddFOOP3LdeeedHDlyxNZDO3v2bI4fP86dd96Zbb8OHTrg7e3NihUr8rzOjb6nLkyqkdf3utls5plnnuGVV16hcuXKzJgxg9atWzNo0CA6derEo48+etXeVJHLaXIIkWu0dOlSTp48yZw5c2jfvr2tvbgsqBcUFISbmxt79uzJsS23tstt3bqVXbt28f3339O/f39b+6Uzvl2rqlWr8ueff5KSkpLtF/LOnTvzdfyVhspcGLIYFBRE586dr3qesLAwnn/+eZ5//nl2795N48aN+fTTT/nxxx/zvE5+BAYG4uHhketriomJwcHBgZCQEFubv78/gwYNYtCgQaSkpNC+fXuGDRuWbQ2aq9V7uQvrplyphoCAADw9Pa/7NeblzjvvpFy5ckyZMgVnZ2dOnz5dLIbpFYTGjRszYcIEduzYka1HYs2aNbbtVzt++fLlWCyWbMPA1qxZg4eHB7Vr1852nnXr1tlukgc4cuQIhw4dYsiQIVetdd++fcUirF5u1qxZ1KhRgzlz5mR7n+U2fC4/5syZQ1paGmPHjs225hdYv//feOMNVqxYQdu2bQkLC+OPP/7g1KlTV+x1CgsLw2KxsH379jz/Pf38/HLMBpqRkZGvGesumDVrFgMGDODTTz+1taWlpeU4b1hYGP/9999Vz1e/fn2aNGnCTz/9RJUqVYiNjWXUqFH5rudSx48fzzUEZmZmAth6nI4fPw7kDIyGYWA2m3Ms2Hy5G31PXRgin9f3+tixYzlz5gwvvPACYH0fXRrIKlWqxOHDh/O8jsjl1OMkco0u/HX10r+UZWRkMGbMGHuVlI2joyOdO3dm3rx5HDlyxNa+Z88efvvtt3wdD9lfn2EY2RY+vFa33347WVlZ2RbwNJvN+f7lfuHD/uUfLLp06YK3tzcffPCB7Rf7pRISEgDrjEyXj7kPCwujXLly2YaLeHp65muK9Nw4Ojpy6623Mn/+/Gz3zRw/fpwpU6bQtm1bvL29AetsjZfy8vKiZs2atlryW+/lgoODady4Md9//3221/Hff/+xaNEibr/99ut6bfnh7u5Oz549WbhwIWPHjsXT05O77rqrQM6d32nDC+u8d911F87Oztne44ZhMG7cOCpXrpxtgd6jR48SExOT7fvx3nvv5fjx48yZM8fWduLECWbOnEn37t1t93rUq1ePiIgIvvnmm2wfSMeOHYvJZOLee++1tV343r7UwoULWb9+PV27dr2u11mYcvu5smbNmqtO5X4lP/74IzVq1OCxxx7j3nvvzfZ44YUX8PLysvUm3HPPPRiGwdtvv53jPBfq6dGjBw4ODrzzzjs5en0urTksLIx//vkn2/bL/72uxtHRMUdPy6hRo3Kc45577mHz5s3MnTv3inVf8OCDD7Jo0SJGjhxJ+fLls93Pei3TkdeuXZvFixdn+xllNpuZMWMG5cqVs/2x6kLYnzZtWrbjf/75Z86ePUuTJk1sbUlJScTExGQbhpjf91RaWppt6vNLvfvuuxiGkeN7/YJTp07x1ltvMWLECNt9UxUqVMh2D/KOHTuoWLHiVb8mIpdSj5PINWrdujV+fn4MGDCAp59+GpPJxOTJk4vVTabDhg1j0aJFtGnThscffxyz2czo0aOpX78+mzZtyvPYiIgIwsLCeOGFFzh8+DDe3t7Mnj37hiZV6N69O23atOGVV17hwIED1K1blzlz5uT73obGjRvj6OjIRx99RFJSEq6urtx0000EBQUxduxYHnzwQZo2bUqfPn0IDAwkNjaWBQsW0KZNG0aPHs2uXbu4+eab6dWrF3Xr1sXJyYm5c+dy/PjxbNPmNmvWjLFjx/Lee+9Rs2ZNgoKCuOmmm/L9Ot977z0WL15M27ZtGTp0KE5OTnz99dekp6dnW9embt26dOzYkWbNmuHv78+6deuYNWsWTz75JEC+683NiBEjuO2222jVqhUPP/ywbTpyHx+fXNefuRazZ8/OdfKTAQMGEBISwgMPPMAPP/zAH3/8wf33319gvVv5nTa8sM5bpUoV/ve//zFixAgyMzOJjIxk3rx5LF++nJ9++inbULVXX32V77//nv3799umPb/33ntp2bIlgwYNYvv27QQEBDBmzBjMZnOOD/MjRozgzjvv5NZbb6VPnz78999/jB49mkceeSTb1M2tW7emSZMmNG/eHB8fHzZs2MB3331HSEiIbb25a32dhemOO+5gzpw59OzZk27durF//37GjRtH3bp1SUlJuaZzHTlyhL///punn3461+2urq506dKFmTNn8uWXX9KpUycefPBBvvzyS3bv3k3Xrl2xWCwsX76cTp068eSTT1KzZk1ef/113n33Xdq1a8fdd9+Nq6sr0dHRVKpUieHDhwPwyCOP8Nhjj3HPPfdwyy23sHnzZv74448cvV5X+1pMnjwZHx8f6taty6pVq1iyZIltOYkLXnzxRWbNmsV9993HQw89RLNmzTh16hQ///wz48aNo1GjRrZ9+/Xrx0svvcTcuXN5/PHHsy1rcS3Tkb/yyis88MADtGjRgiFDhuDu7s7UqVNZv3497733nu283bt3p169erzzzjscPHiQli1bsmfPHkaPHk1wcDAPP/yw7Zxz585l0KBBTJw40bbWVX7fU8eOHaNJkyb07duXiIgIAP744w8WLlxI165dr/jHmf/7v/+jQYMG2e7zuueee3jnnXd4/PHHqVq1Kl9//TWfffbZVf61RC5TdBP4iRRfV5qOvF69ernuv2LFCqNly5aGu7u7UalSJeOll16yTQt76VS9V5qOPLdpprlsmtsrTa186UrrF+Q2xfOff/5pNGnSxHBxcTHCwsKMCRMmGM8//7zh5uZ2ha/CRdu3bzc6d+5seHl5GQEBAcbgwYNt055fOnX4lVZ0z632kydPGg8++KDh7e1t+Pj4GA8++KCxcePGfE1HbhiGMX78eKNGjRqGo6Njjq/z33//bXTp0sXw8fEx3NzcjLCwMGPgwIHGunXrDMMwjBMnThhPPPGEERERYXh6eho+Pj5GixYtjBkzZmS7xrFjx4xu3boZ5cqVM4CrTk1++b+ZYRjGhg0bjC5duhheXl6Gh4eH0alTJ2PlypXZ9nnvvfeMqKgow9fX13B3dzciIiKM999/38jIyLimeq9kyZIlRps2bQx3d3fD29vb6N69u7F9+/Zs+1zPdORXeixfvtwwDOtUxsHBwQZgLFy4MNdzXc905PmdNvxa3jPXcl7DsE6v/sEHHxhVq1Y1XFxcjHr16hk//vhjjv0uTJV8+Ws4deqU8fDDDxvly5c3PDw8jA4dOhjR0dG5Xmvu3LlG48aNDVdXV6NKlSrGG2+8YfveuOD11183GjdubPj4+BjOzs5GaGio8fjjjxvHjh277td54euXkJCQ6/YrTUee28/Jy3/2WSwW29fP1dXVaNKkifHrr7/m2M8wrj4d+aeffmoAxp9//nnFfSZNmmQAxvz58w3DsH5vjhgxwoiIiDBcXFyMwMBA47bbbjPWr1+f7bjvvvvOaNKkieHq6mr4+fkZHTp0MBYvXmzbbjabjZdfftkICAgwPDw8jC5duhh79uy54nTkuf0bnz592hg0aJAREBBgeHl5GV26dDFiYmJyfW+cPHnSePLJJ43KlSsbLi4uRpUqVYwBAwYYJ06cyHHe22+/3QBy/Ly5lunIDcMwfv/9d6NDhw5GQECA4eLiYjRo0CDXZTlOnTplPPvss0bt2rUNV1dXIyAgwOjTp4+xb9++bPtd+Fpc/nM+P++p06dPGw888IBRs2ZNw8PDw3B1dTXq1atnfPDBBzneExds2bLFcHFxMTZu3Jhj26RJk4xq1aoZ5cuXN5577rkcU8WLXI3JMIrRn8lFpFD16NEjz2mwRUSkZOrZsydbt27N172sInJ9dI+TSCl1+doyu3fvZuHChXTs2NE+BYmISKE4evQoCxYs4MEHH7R3KSKlmnqcREqp4OBgBg4cSI0aNTh48CBjx44lPT2djRs3UqtWLXuXJyIiN2j//v2sWLGCCRMmEB0dzd69ezXhgUgh0uQQIqVU165dmTp1KseOHcPV1ZVWrVrxwQcfKDSJiJQSy5YtY9CgQYSGhvL9998rNIkUMvU4iYiIiIiIXIXucRIREREREbkKBScREREREZGrKHP3OFksFo4cOUK5cuUwmUz2LkdEREREROzEMAzOnDlDpUqVcHDIu0+pzAWnI0eOEBISYu8yRERERESkmIiLi6NKlSp57lPmglO5cuUA6xfH29vbztWIiIiIiIi9JCcnExISYssIeSlzwenC8Dxvb28FJxERERERydctPJocQkRERERE5CoUnERERERERK5CwUlEREREROQqytw9TiIiIiJSOhmGQVZWFmaz2d6lSDHi7OyMo6PjDZ9HwUlERERESryMjAyOHj1KamqqvUuRYsZkMlGlShW8vLxu6DwKTiIiIiJSolksFvbv34+joyOVKlXCxcUlX7OkSelnGAYJCQkcOnSIWrVq3VDPk4KTiIiIiJRoGRkZWCwWQkJC8PDwsHc5UswEBgZy4MABMjMzbyg4aXIIERERESkVHBz00VZyKqjeR313iYiIiIiIXIWCk4iIiIiIyFUoOImIiIiIlCLVqlVj5MiR+d5/6dKlmEwmEhMTC60mgEmTJuHr61uo1yhMCk4iIiIiInZgMpnyfAwbNuy6zhsdHc2QIUPyvX/r1q05evQoPj4+13W9skKz6tlZ0rlMfNyd7V2GiIiIiBSxo0eP2v5/+vTpvPnmm+zcudPWdum6Q4ZhYDabcXK6+sf3wMDAa6rDxcWFihUrXtMxZZF6nOzon10JtP3oLxZvP27vUkRERERKFcMwSM3IssvDMIx81VixYkXbw8fHB5PJZHseExNDuXLl+O2332jWrBmurq78+++/7N27l7vuuosKFSrg5eVFZGQkS5YsyXbey4fqmUwmJkyYQM+ePfHw8KBWrVr8/PPPtu2XD9W7MKTujz/+oE6dOnh5edG1a9dsQS8rK4unn34aX19fypcvz8svv8yAAQPo0aPHNf07jR07lrCwMFxcXAgPD2fy5MnZ/g2HDRtGaGgorq6uVKpUiaefftq2fcyYMdSqVQs3NzcqVKjAvffee03XvlbqcbKj6eviOJOWxZDJ63jrjroMbFPd3iWJiIiIlArnMs3UffMPu1x7+ztd8HApmI/Zr7zyCp988gk1atTAz8+PuLg4br/9dt5//31cXV354Ycf6N69Ozt37iQ0NPSK53n77bf5+OOPGTFiBKNGjeL+++/n4MGD+Pv757p/amoqn3zyCZMnT8bBwYEHHniAF154gZ9++gmAjz76iJ9++omJEydSp04dvvjiC+bNm0enTp3y/drmzp3LM888w8iRI+ncuTO//vorgwYNokqVKnTq1InZs2fz+eefM23aNOrVq8exY8fYvHkzAOvWrePpp59m8uTJtG7dmlOnTrF8+fJr+MpeOwUnOxrZuzHebk5MXRvHsF+2E3vqHK93q4Ojg1a6FhERERF45513uOWWW2zP/f39adSoke35u+++y9y5c/n555958sknr3iegQMH0rdvXwA++OADvvzyS9auXUvXrl1z3T8zM5Nx48YRFhYGwJNPPsk777xj2z5q1CheffVVevbsCcDo0aNZuHDhNb22Tz75hIEDBzJ06FAAnnvuOVavXs0nn3xCp06diI2NpWLFinTu3BlnZ2dCQ0OJiooCIDY2Fk9PT+644w7KlStH1apVadKkyTVd/1opONmRs6MDH/RsQKi/Jx/9HsN3K/Zz6HQqX/RpgrvL9a9qLCIiIlLWuTs7sv2dLna7dkFp3rx5tucpKSkMGzaMBQsWcPToUbKysjh37hyxsbF5nqdhw4a2//f09MTb25v4+Pgr7u/h4WELTQDBwcG2/ZOSkjh+/LgtxAA4OjrSrFkzLBZLvl/bjh07ckxi0aZNG7744gsA7rvvPkaOHEmNGjXo2rUrt99+O927d8fJyYlbbrmFqlWr2rZ17drVNhSxsOgeJzszmUw83jGMUX2b4OLkwKLtx+nzzSoSzqTbuzQRERGREstkMuHh4mSXh8lUcKOHPD09sz1/4YUXmDt3Lh988AHLly9n06ZNNGjQgIyMjDzP4+ycfTIyk8mUZ8jJbf/83rtVUEJCQti5cydjxozB3d2doUOH0r59ezIzMylXrhwbNmxg6tSpBAcH8+abb9KoUaNCnVJdwamY6N6oElMeaYGfhzObDyXRc8wK9sSfsXdZIiIiIlKMrFixgoEDB9KzZ08aNGhAxYoVOXDgQJHW4OPjQ4UKFYiOjra1mc1mNmzYcE3nqVOnDitWrMjWtmLFCurWrWt77u7uTvfu3fnyyy9ZunQpq1atYuvWrQA4OTnRuXNnPv74Y7Zs2cKBAwf466+/buCV5U1D9YqR5tX8mTO0DYMmruXAyVTuHrOScQ82o3VYgL1LExEREZFioFatWsyZM4fu3btjMpn4v//7v2saHldQnnrqKYYPH07NmjWJiIhg1KhRnD59+pp621588UV69epFkyZN6Ny5M7/88gtz5syxzRI4adIkzGYzLVq0wMPDgx9//BF3d3eqVq3Kr7/+yr59+2jfvj1+fn4sXLgQi8VCeHh4Yb1k9TgVN9UDPJkztA3NqvqRnJbFgO/WMnv9IXuXJSIiIiLFwGeffYafnx+tW7eme/fudOnShaZNmxZ5HS+//DJ9+/alf//+tGrVCi8vL7p06YKbm1u+z9GjRw+++OILPvnkE+rVq8fXX3/NxIkT6dixIwC+vr6MHz+eNm3a0LBhQ5YsWcIvv/xC+fLl8fX1Zc6cOdx0003UqVOHcePGMXXqVOrVq1dIrxhMRlEPVrSz5ORkfHx8SEpKwtvb297lXFFappnnZ25mwRbrfPnPdq7N0zfXLNAxsyIiIiKlQVpaGvv376d69erX9MFdCo7FYqFOnTr06tWLd999197lZJPX98e1ZAMN1Sum3JwdGdWnCSF+HoxbtpfPl+wi9lQqw+9ugIuTOgpFRERExH4OHjzIokWL6NChA+np6YwePZr9+/fTr18/e5dWaPQJvBhzcDDxym0RfNCzAY4OJmZvOMSA79aSdC7T3qWJiIiISBnm4ODApEmTiIyMpE2bNmzdupUlS5ZQp04de5dWaNTjVAL0axFKJV83nvhpA6v2neTesSv5bmAkIf6FN0+9iIiIiMiVhISE5JgRr7RTj1MJ0TE8iJmPtaaitxu741PoOWYlWw4l2rssEREREZEyQcGpBKlbyZu5T7SmTrA3J1LS6f31ahZtO2bvskRERERESj0FpxIm2MedmY+1okPtQM5lmnn0x/VMXLHf3mWJiIiIiJRqCk4lkJerE98OaE6/FqEYBrz9y3be/mUbZkuZmlleRERERKTIKDiVUE6ODrzfoz6v3BYBwMQVB3jsx/WkZmTZuTIRERERkdJHwakEM5lMPNYhjNH9muDi5MDi7cfp881q4s+k2bs0EREREZFSRcGpFLijYSWmDm6Bn4czWw4l0fOrlew+fsbeZYmIiIhIMXbgwAFMJhObNm2ydyklgoJTKdGsqj9zh7aheoAnhxPPcffYlazcc8LeZYmIiIjIFZhMpjwfw4YNu6Fzz5s3r8BqFQWnUqVagCdzHm9N86p+nEnLYsDEtcxef8jeZYmIiIhILo4ePWp7jBw5Em9v72xtL7zwgr1LlEsoOJUyfp4u/PhIC7o3qkSm2eD5mZv5fPEuDEMz7omIiEgZYhiQcdY+j3x+7qpYsaLt4ePjg8lkytY2bdo06tSpg5ubGxEREYwZM8Z2bEZGBk8++STBwcG4ublRtWpVhg8fDkC1atUA6NmzJyaTyfY8P5YtW0ZUVBSurq4EBwfzyiuvkJV1cfKxWbNm0aBBA9zd3SlfvjydO3fm7NmzACxdupSoqCg8PT3x9fWlTZs2HDx4MN/XLu6c7F2AFDw3Z0e+6N2YED93xizdyxd/7ibuVCof3tMQFydlZRERESkDMlPhg0r2ufZrR8DF84ZO8dNPP/Hmm28yevRomjRpwsaNGxk8eDCenp4MGDCAL7/8kp9//pkZM2YQGhpKXFwccXFxAERHRxMUFMTEiRPp2rUrjo6O+brm4cOHuf322xk4cCA//PADMTExDB48GDc3N4YNG8bRo0fp27cvH3/8MT179uTMmTMsX74cwzDIysqiR48eDB48mKlTp5KRkcHatWsxmUw39HUoThScSikHBxMvdY0gxN+DN+b9x5yNhzmalMa4B5rh4+Fs7/JEREREJA9vvfUWn376KXfffTcA1atXZ/v27Xz99dcMGDCA2NhYatWqRdu2bTGZTFStWtV2bGBgIAC+vr5UrFgx39ccM2YMISEhjB49GpPJREREBEeOHOHll1/mzTff5OjRo2RlZXH33XfbrtegQQMATp06RVJSEnfccQdhYWEA1KlTp0C+FsWFglMp1zcqlEq+7jzx0wZW7TvJPeNWMnFgJCH+HvYuTURERKTwOHtYe37sde0bcPbsWfbu3cvDDz/M4MGDbe1ZWVn4+PgAMHDgQG655RbCw8Pp2rUrd9xxB7feeusNXXfHjh20atUqWy9RmzZtSElJ4dChQzRq1Iibb76ZBg0a0KVLF2699Vbuvfde/Pz88Pf3Z+DAgXTp0oVbbrmFzp0706tXL4KDg2+opuJE47bKgA61A5nxaCsqeruxJz6FnmNWsDku0d5liYiIiBQek8k6XM4ejxscnpaSkgLA+PHj2bRpk+3x33//sXr1agCaNm3K/v37effddzl37hy9evXi3nvvveEvW14cHR1ZvHgxv/32G3Xr1mXUqFGEh4ezf/9+ACZOnMiqVato3bo106dPp3bt2rZ6SwMFpzKibiVv5j3RhrrB3pxIyaD3N6tYtO2YvcsSERERkctUqFCBSpUqsW/fPmrWrJntUb16ddt+3t7e9O7dm/HjxzN9+nRmz57NqVOnAHB2dsZsNl/TdevUqcOqVauyTSq2YsUKypUrR5UqVQDrNOdt2rTh7bffZuPGjbi4uDB37lzb/k2aNOHVV19l5cqV1K9fnylTptzIl6JYUXAqQyr6uDHjsVZ0DA8kLdPCoz+u57t/99u7LBERERG5zNtvv83w4cP58ssv2bVrF1u3bmXixIl89tlnAHz22WdMnTqVmJgYdu3axcyZM6lYsSK+vr6AdWa9P//8k2PHjnH69Ol8XXPo0KHExcXx1FNPERMTw/z583nrrbd47rnncHBwYM2aNXzwwQesW7eO2NhY5syZQ0JCAnXq1GH//v28+uqrrFq1ioMHD7Jo0SJ2795dqu5z0j1OZYyXqxMT+jfnrZ+38dOaWN75dTuxp1L5vzvq4uhQemY9ERERESnJHnnkETw8PBgxYgQvvvginp6eNGjQgP/9738AlCtXjo8//pjdu3fj6OhIZGQkCxcuxMHB2i/y6aef8txzzzF+/HgqV67MgQMHrnrNypUrs3DhQl588UUaNWqEv78/Dz/8MG+88QZg7eH6559/GDlyJMnJyVStWpVPP/2U2267jePHjxMTE8P333/PyZMnCQ4O5oknnuDRRx8trC9RkTMZZWyBn+TkZHx8fEhKSsLb29ve5diNYRh8888+hv8WA0DnOhX4sm9jPFyUpUVERKRkSUtLY//+/VSvXh03Nzd7lyPFTF7fH9eSDTRUr4wymUw82iGMr/o1xcXJgSU7jtPnm9XEn0mzd2kiIiIiIsWOXYPTP//8Q/fu3alUqRImk4l58+Zd9ZilS5fStGlTXF1dqVmzJpMmTSr0Okuzbg2DmTq4Bf6eLmw5lETPr1ay6/gZe5clIiIiIlKs2DU4nT17lkaNGvHVV1/la//9+/fTrVs3OnXqxKZNm/jf//7HI488wh9//FHIlZZuzar6M+fx1lQP8ORw4jnuGbuSlXtO2LssEREREZFiw643tNx2223cdttt+d5/3LhxVK9enU8//RSwTpn477//8vnnn9OlS5fCKrNMqBbgyZzHWzNk8jqiD5ym/3dr+fCehtzbrIq9SxMRERERsbsSdY/TqlWr6Ny5c7a2Ll26sGrVqisek56eTnJycraH5M7P04XJD7ege6NKZFkMXpi5mc8W76KMzR8iIiIiJZQ+s0huCur7okQFp2PHjlGhQoVsbRUqVCA5OZlz587leszw4cPx8fGxPUJCQoqi1BLLzdmRL3o35olOYQB8+edunp+xmYwsi50rExEREcmds7MzAKmpqXauRIqjjIwMABwdHW/oPKV+7ulXX32V5557zvY8OTlZ4ekqHBxMvNglghA/D16f9x9zNh7mSNI5vn6gOT4ezvYuT0RERCQbR0dHfH19iY+PB8DDwwOTSetTClgsFhISEvDw8MDJ6caiT4kKThUrVuT48ePZ2o4fP463tzfu7u65HuPq6oqrq2tRlFfq9IkKpZKvO0N/2sDqfae4e+wKJg2KIsTfw96liYiIiGRTsWJFAFt4ErnAwcGB0NDQGw7TJSo4tWrVioULF2ZrW7x4Ma1atbJTRaVf+9qBzHysFQ9NimZvwll6jlnBhAGRNA7xtXdpIiIiIjYmk4ng4GCCgoLIzMy0dzlSjLi4uODgcON3KNk1OKWkpLBnzx7b8/3797Np0yb8/f0JDQ3l1Vdf5fDhw/zwww8APPbYY4wePZqXXnqJhx56iL/++osZM2awYMECe72EMqFOsDfznmjDoInRbD+aTJ9vVjGydxO61q9o79JEREREsnF0dLzhe1lEcmPXySHWrVtHkyZNaNKkCQDPPfccTZo04c033wTg6NGjxMbG2vavXr06CxYsYPHixTRq1IhPP/2UCRMmaCryIlDB240Zj7WiU3ggaZkWHv9pPd/+u1+z14iIiIhImWAyytgn3+TkZHx8fEhKSsLb29ve5ZQ4WWYLb/28jZ/WWAPtwNbV+L876uLooBswRURERKRkuZZsUKKmIxf7c3J04L0e9Xnt9ggAJq08wKOT15GakWXnykRERERECo+Ck1wzk8nEkPZhjLm/Ka5ODizZEU/vr1cTn5xm79JERERERAqFgpNct9sbBDNlcEv8PV3YejiJnmNWsuv4GXuXJSIiIiJS4BSc5IY0q+rH3KGtqRHgyeHEc9wzdiUr9pywd1kiIiIiIgVKwUluWNXynsx+vDWR1fw4k5bFgO/WMnNdnL3LEhEREREpMApOUiD8PF2Y/HAL7mxUiSyLwYuztvDZop2arlxERERESgUFJykwbs6OjOzdmCc71QTgy7/28NyMzaRnme1cmYiIiIjIjVFwkgLl4GDihS7hfHRPAxwdTMzdeJj+364lKTXT3qWJiIiIiFw3BScpFL0jQ5k4MBIvVyfW7D/F3WNXEHcq1d5liYiIiIhcFwUnKTTtawcy6/FWVPJxY2/CWXqOWcHG2NP2LktERERE5JopOEmhiqjozdwn2lCvkjcnUjLo881qfv/vmL3LEhERERG5JgpOUugqeLsx49FW3BQRRHqWhcd/Ws+E5fs0456IiIiIlBgKTlIkPF2d+ObBZjzQMhTDgPcW7GDYz9swWxSeRERERKT4U3CSIuPk6MC7d9Xn9dvrYDLB96sOMuSHdZxNz7J3aSIiIiIieVJwkiJlMpkY3L4GY/o1xdXJgT9j4un9zSrik9PsXZqIiIiIyBUpOIld3NYgmKlDWlLe04X/DifTc8xKdh47Y++yRERERERypeAkdtM01I85Q1tTI8CTw4nnuHfsSv7dfcLeZYmIiIiI5KDgJHZVtbwnc4a2JqqaP2fSsxg4cS0z1sXZuywRERERkWwUnMTufD1cmPxIFHc1rkSWxeClWVv4dNFOTVcuIiIiIsWGgpMUC65Ojozs3ZinbqoJwKi/9vDs9E2kZ5ntXJmIiIiIiIKTFCMmk4nnbw3n43sa4uRgYt6mIzz47VoSUzPsXZqIiIiIlHEKTlLs9IoMYeKgSMq5OrF2/ynuHruS2JOp9i5LRERERMowBScpltrVCmTm462o5OPGvoSz9Byzgo2xp+1dloiIiIiUUQpOUmxFVPRm7hNtqF/Zm5NnM+jzzWp+/++ovcsSERERkTJIwUmKtQrebkwf0oqbIoJIz7Lw+E8bmLB8n2bcExEREZEipeAkxZ6nqxPfPNiMB1tWxTDgvQU7eOvnbWSZLfYuTURERETKCAUnKRGcHB145656vNGtDiYT/LDqII9OXs/Z9Cx7lyYiIiIiZYCCk5QYJpOJR9rVYOz9TXF1cuDPmHh6fb2K48lp9i5NREREREo5BScpcbrWD2bqkJaU93Rh25Fken61gphjyfYuS0RERERKMQUnKZGahvoxd2gbagR6ciQpjfvGruLf3SfsXZaIiIiIlFIKTlJihZb3YM7jrYmq7s+Z9CwGTlzLjOg4e5clIiIiIqWQgpOUaL4eLkx+OIoejSuRZTF4afYWPvljp6YrFxEREZECpeAkJZ6rkyOf927M0zfVBGD033v43/RNpGeZ7VyZiIiIiJQWCk5SKphMJp67NZyP722Ik4OJ+ZuO8OCEtSSmZti7NBEREREpBRScpFTp1TyESYOiKOfqxNoDp7h77EoOnjxr77JEREREpIRTcJJSp22tAGY93prKvu7sSzhLzzEr2RB72t5liYiIiEgJpuAkpVJ4xXLMHdqa+pW9OXU2g77frOa3rUftXZaIiIiIlFAKTlJqBXm7MX1IK26OCCI9y8LQKRsY/88+zbgnIiIiItdMwUlKNU9XJ77p35wBrapiGPD+wh28OX8bWWaLvUsTERERkRJEwUlKPUcHE8PurMf/3VEXkwkmrz7IkMnrOZueZe/SRERERKSEUHCSMsFkMvFw2+qMvb8prk4O/BUTT6+vV3E8Oc3epYmIiIhICaDgJGVK1/rBTBvSkvKeLmw7kkzPr1YQcyzZ3mWJiIiISDGn4CRlTpNQP+YObUONQE+OJKVx79hVLN+dYO+yRERERKQYU3CSMim0vAdzHm9Ni+r+pKRnMWhiNNOjY+1dloiIiIgUUwpOUmb5erjww8NR9GxSmSyLwcuzt/LJHzs1XbmIiIiI5KDgJGWaq5Mjn/VqxNM31QRg9N97eGbaJtKzzHauTERERESKEwUnKfNMJhPP3RrOiHsb4uRg4ufNR3hwwlpOn82wd2kiIiIiUkwoOImcd1/zEL5/KIpyrk6sPXCKe8au5ODJs/YuS0RERESKAQUnkUu0qRnA7KGtqezrzr4TZ+k5ZiXrD562d1kiIiIiYmcKTiKXqV2hHHOHtqZBZR9Onc2g3/jVLNx61N5liYiIiIgdKTiJ5CLI243pj7akc50g0rMsDP1pA9/8s1cz7omIiIiUUQpOIlfg4eLE1w82Z2DragB8sDCG/5v/H1lmi30LExEREZEip+AkkgdHBxPD7qzH/91RF5MJflwdy+Af1nE2PcvepYmIiIhIEVJwEsmHh9tWZ+z9zXBzduDvnQncN24Vx5LS7F2WiIiIiBQRBSeRfOpavyLThrQiwMuF7UeT6TlmBTuOJtu7LBEREREpAgpOItegcYgvc4e2ISzQk6NJadw3bhX/7Eqwd1kiIiIiUsgUnESuUYi/B3Meb0PLGv6kpGcxaFI009bG2rssERERESlECk4i18HHw5kfHmrB3U0qY7YYvDJnKyP+iMFi0XTlIiIiIqWRgpPIdXJxcuDTXo145uZaAHz1916emb6JtEyznSsTERERkYKm4CRyA0wmE8/eUptP7muEk4OJXzYf4cFv13D6bIa9SxMRERGRAqTgJFIA7m1Whe8fiqKcmxPRB05z99iVHDhx1t5liYiIiEgBUXASKSBtagYw+/HWVPZ1Z/+Js9w9diXrD562d1kiIiIiUgAUnEQKUO0K5Zj7RGsaVvHh1NkM+o5fzYItR+1dloiIiIjcIAUnkQIWVM6NaUNa0rlOBTKyLDwxZQNfL9uLYWjGPREREZGSSsFJpBB4uDjx9YPNGNi6GgDDf4vhjXn/kWW22LcwEREREbkuCk72tOsPmNwT1n0HZ47buxopYI4OJobdWY8376iLyQQ/rYnlkR/WkZKeZe/SREREROQamYwyNn4oOTkZHx8fkpKS8Pb2tm8xcx+DzVPPPzFBaEuo0x0i7gC/qnYtTQrWH9uO8cy0jaRlWqgb7M13AyOp6ONm77JEREREyrRryQYKTvZ0ci9snw87foEjG7JvC25kDVF17oTAcPvUJwVqc1wiD38fzYmUDCp6uzFxUCR1gu38PSgiIiJShik45aFYBadLJcZBzAJriIpdCcYl98IE1L4YooIbgclkvzrlhsSdSmXQpGj2xKfg5erEV/c3pUPtQHuXJSIiIlImKTjlodgGp0ulJMDOhdYQtW8pWDIvbvMJhTp3WINUSAtwcLRbmXJ9klIzefTHdazedwpHBxPv9ahP36hQe5clIiIiUuZcSzaw++QQX331FdWqVcPNzY0WLVqwdu3aPPcfOXIk4eHhuLu7ExISwrPPPktaWloRVVtEvAKh2QB4YBa8tBfunmDtbXL2gKRYWD0GJt4Gn4bDL8/AniWQlWHvqiWffDyc+eGhFtzdpDJmi8Grc7by0e8xWCxl6m8YIiIiIiWKXXucpk+fTv/+/Rk3bhwtWrRg5MiRzJw5k507dxIUFJRj/ylTpvDQQw/x3Xff0bp1a3bt2sXAgQPp06cPn332Wb6uWSJ6nK4kIxX2/mXtidr1G6QlXdzm6gPhXa09UWE3g4uH/eqUfDEMgy/+3M3IJbsBuKNhMJ/c1wg3Z/UiioiIiBSFEjNUr0WLFkRGRjJ69GgALBYLISEhPPXUU7zyyis59n/yySfZsWMHf/75p63t+eefZ82aNfz777/5umaJDk6XysqAA8utISpmAZyNv7jNyR1qdbb2UtXuAm4+9qtTrmrW+kO8OmcLmWaD5lX9GN+/OX6eLvYuS0RERKTUKxFD9TIyMli/fj2dO3e+WIyDA507d2bVqlW5HtO6dWvWr19vG863b98+Fi5cyO23337F66Snp5OcnJztUSo4uUDNm6H7SHg+Bh76A1o9ab0HKuucNVDNGQwfh8GP98D6SdZ7p6TYubdZFb4fFEU5NyfWHTzN3WNXcuDEWXuXJSIiIiKXsFtwOnHiBGazmQoVKmRrr1ChAseOHcv1mH79+vHOO+/Qtm1bnJ2dCQsLo2PHjrz22mtXvM7w4cPx8fGxPUJCQgr0dRQLDo7WNaC6vA//2wKP/gPtXoCAcOvEEnuWWO+F+rQ2TLwdVo+1zuInxUbrmgHMebw1lX3d2X/iLD3HrGD9wVP2LktEREREzrP75BDXYunSpXzwwQeMGTOGDRs2MGfOHBYsWMC77757xWNeffVVkpKSbI+4uFIeGEwm65TlN/8fPLkWnlgLN/0fBDe2TnF+cAX8/gqMrA/fdITln8KJ3fauWoBaFcox94nWNKziw+nUTPqOX8OCLUftXZaIiIiIYMd7nDIyMvDw8GDWrFn06NHD1j5gwAASExOZP39+jmPatWtHy5YtGTFihK3txx9/ZMiQIaSkpODgcPUcWGrucboeibGw41eI+RUOrgQu+acPjDi/VlR3qNhQa0XZUWpGFs9M28Ti7ccBeOW2CB5tXwOT/k1EREREClSJuMfJxcWFZs2aZZvowWKx8Oeff9KqVatcj0lNTc0RjhwdrTOQlbHlqK6Pbyi0GgqDFsILu6D7F1CzMzg4Q0IM/DMCvm4PXzSEP16H2NVgsVz9vFKgPFycGPdAMwa1qQbAh7/F8Pq8/8gy699CRERExF6c7Hnx5557jgEDBtC8eXOioqIYOXIkZ8+eZdCgQQD079+fypUrM3z4cAC6d+/OZ599RpMmTWjRogV79uzh//7v/+jevbstQEk+eQVBs4HWx7lE2L0IdvwMu5dYe6ZWjbY+vCpARDdrT1S1duDobOfCywZHBxNvda9HiJ8H7y7YzpQ1sRw+fY6v7m+Kl6td37YiIiIiZZJdpyMHGD16NCNGjODYsWM0btyYL7/8khYtWgDQsWNHqlWrxqRJkwDIysri/fffZ/LkyRw+fJjAwEC6d+/O+++/j6+vb76uV6aH6uVHRirs/dM6K9/O3yH9krWi3Hwh/Lbza0XdBM7udiuzLFm07RhPT9tIWqaFOsHeTBwYSUUfN3uXJSIiIlLilZh1nOxBwekaZGXAgX8uWSvqkunMnT0vrhVV61Zw09eyMG2OS+Th79dxIiWdit5ufDcwkrqV9DUXERERuREKTnlQcLpOFjPErbGGqB2/QNIlsxM6ukCNjtaeqPDbwTPAbmWWZnGnUhk0KZo98Sl4ujjy1f1N6RgeZO+yREREREosBac8KDgVAMOAo5usAWr7z3DykunMTQ5QtY01REXcAT6V7VZmaZR0LpPHJq9n1b6TODqYePeu+vRrEWrvskRERERKJAWnPCg4FYKEndaJJXb8Akc3Z99Wudn5ac7vhPJh9qmvlMnIsvDKnC3M2XAYgMc6hPFSl3AcHDRduYiIiMi1UHDKg4JTITt90LpO1I5frNOZX7pWVFDdi2tFVaivtaJugGEYfPnnHj5fsguAbg2D+fS+Rrg5a3ZJERERkfxScMqDglMROnMcdi6whqj9/4Al6+I2v2oXe6IqN4d8LF4sOc1ef4hX5mwh02zQvKof3/Rvjr+ni73LEhERESkRFJzyoOBkJ+dOw64/rCFqzxLISru4zasi1LnDGqSqttFaUddo5d4TPDp5PWfSsqhW3oOJg6KoHuBp77JEREREij0FpzwoOBUDGWet4WnHL9YwlZ58cZu7n3VmvjrdoUYncNZ6RfmxJ/4MAydGc+j0Ofw8nBnfvznNq/nbuywRERGRYk3BKQ8KTsVMVrp1GN+On61rRaWevLjNxQtq3WINUbVuBddy9quzBEg4k84j30ez+VASLk4OfHpfI7o3qmTvskRERESKLQWnPCg4FWPmLIhbfXGtqOTDF7c5ukJYp4trRXmoNyU35zLMPDNtI4u2Hwfg5a4RPNahBiZNxCEiIiKSg4JTHhScSgjDgCMbLq4VdWrvxW0mR6jWxjqxREQ38FavyqXMFoP3F+zguxX7AegbFcq7d9XDyVETcIiIiIhcSsEpDwpOJZBhQELM+Z6on+HY1uzbq0RenObcv4Z9aiyGJq3Yzzu/bsdiQIfagXx1f1O8XJ3sXZaIiIhIsaHglAcFp1Lg1P6La0XFrcm+rUL9iyEqqG6ZXytq8fbjPD11I+cyzdQJ9ua7gc0J9nG3d1kiIiIixYKCUx4UnEqZ5KOXrBW1HAzzxW3+NS6uFVWpaZldK2rLoUQemrSOEynpVPB25buBkdSr5GPvskRERETsTsEpDwpOpVjqKdj1+/m1ov4Ec/rFbeUqXVwrKrQ1OJatIWuHTqcyaGI0u+NT8HRxZPT9TekUHmTvskRERETsSsEpDwpOZUR6CuxZfHGtqIyUi9vc/SHidmtPVI2O4ORqtzKLUtK5TB7/cT0r957E0cHEu3fVp1+LUHuXJSIiImI3Ck55UHAqgzLTYP+y82tFLYRzpy5ucykHtW+19kTVvAVcvexXZxHIyLLw2tytzFp/CIBHO9Tg5S4RODiU7XvBREREpGxScMqDglMZZ86C2JXnZ+j7Fc4cubjN0RVq3mwNUbW7ltq1ogzDYNRfe/hs8S4AujUI5tNejXBzdrRzZSIiIiJFS8EpDwpOYmOxnF8r6mfrWlGn91/cZnKE6u2sISriDihX0X51FpI5Gw7x8uwtZJoNmlX1Y3z/5vh7uti7LBEREZEio+CUBwUnyZVhQPz28z1Rv8Dx/y7ZaIKQqIshyr+63cosaKv2nuTRyetITsuiWnkPJg6KonqAp73LEhERESkSCk55UHCSfDm59+JaUYeis2+r2MA6sUSd7hAYUeLXitoTf4aBE6M5dPocfh7OfNO/OZHVSucwRREREZFLKTjlQcFJrlnyEYhZYB3Sd2BF9rWiyte8uOBupaYlNkQlnEnnkR/WsTkuERdHBz7t1YjujSrZuywRERGRQqXglAcFJ7khZ0/Crt+sPVF7/wJzxsVt3lUuWSuqFTiUrMkWzmWY+d/0jfyx7TgAL3UN5/EOYZhKaBgUERERuRoFpzwoOEmBSUu+ZK2oRZB59uI2j4CLa0VVb19i1ooyWww+WLiDb/+1TpTRNyqEd+6qj7Ojg50rExERESl4Ck55UHCSQpF5DvYttYaonQvh3OmL21y9oXaX82tFdQaX4j/5wvcrD/D2L9uwGNC+diBf9WtCOTdne5clIiIiUqAUnPKg4CSFzpwJB1dcXCsq5djFbU5u1vBUp7s1TLn72a/Oq1iy/ThPTd3IuUwzERXLMXFQJME+7vYuS0RERKTAKDjlQcFJipTFAofXWSeW2PELnD5wcZuDk3UYX53uEN4NylWwW5lXsvVQEg99H03CmXQqeLvy3cBI6lXysXdZIiIiIgVCwSkPCk5iN4ZhXR/qwlpR8dsv2WiC0JYX14ryq2q3Mi936HQqD02KZtfxFDxdHBl9f1M6hQfZuywRERGRG6bglAcFJyk2TuyBmPMh6vD67NuCG52f5vxOCAy3T32XSDqXydCf1rNiz0kcHUy8c1c97m9RfMKdiIiIyPVQcMqDgpMUS0mHzq8V9Yv1/ijDcnFbQO2La0UFN7bbWlEZWRZem7uVWesPAfBohxq83CUCBwdNVy4iIiIlk4JTHhScpNg7e8I6M9+OX2Dv32DJvLjNJ+RiiAppUeRrRRmGwei/9vDp4l0AdGsQzCf3NcLdpWStWSUiIiICCk55UnCSEiUtCXYvtk4usXsxZKZe3OYZCBHdrCGqWntwcimysuZuPMRLs7aQaTbw9XCmZ5PK9IkMJbxiuSKrQURERORGKTjlQcFJSqzMc7D3r4trRaUlXdzm6gPhXa0hKuxmcPEo9HJW7zvJ8zM2czjxnK2tSagvfSJDuKNhJTxdnQq9BhEREZEboeCUBwUnKRXMmXBg+cW1os7GX9zm5A61Olsnlqh1K7j7Fl4ZFoN/dicwfW0cS3YcJ8ti/XHi6eLInY0r0TsylEZVfDDZ6b4sERERkbwoOOVBwUlKHYsZDkWfD1E/Q2LsxW0OzlCjw8W1orwCC62M+DNpzNlwmOnRcew/cdbWHlGxHH0iQ+jRpDK+HkU3nFBERETkahSc8qDgJKWaYcCxLRfXikqIubjN5AChrS6uFeUbUkglGKzdf4pp0XEs3HqU9CzrDIEuTg7cVr8ivSNDaFWjvHqhRERExO4UnPKg4CRlSsKui2tFHdmYfVulJhfXigqoVSiXT0rNZP7mw0xdG8eOo8m29mrlPegVGcK9TasQ5O1WKNcWERERuRoFpzwoOEmZlRgHMb+eXytqJXDJWz8w4uI05xUbFvhaUYZhsPVwEtOi4/h50xFS0rMAcHQwcVNEEH2jQmhfKxAnR4cCva6IiIhIXhSc8qDgJAKkxF9cK2rfsuxrRfmGWnuh6nSHKlHgULBhJjUji1+3HGV6dBzrD562tVf0duO+5lXo1TyEEP/CnxVQRERERMEpDwpOIpdJS4Jdf5xfK2oJZF2cXhyvCpesFdUOHJ0L9NK7j59hWnQcczYc4nSqNbyZTNC2ZgC9I0O4pW4FXJ20uK6IiIgUDgWnPCg4ieQhIxX2/nl+rajfIf2StaLcfCD89vNrRd0Ezu4Fdtn0LDOLtx9nenQcy3efsLX7e7pwd5PK9I4MoVYFLa4rIiIiBUvBKQ8KTiL5lJUBB/6xhqiYBXA24eI2Zw+odYt1SF/47QW64G7cqVRmrItjxro4jien29qbVfWjT2QI3RoG4+GixXVFRETkxik45UHBSeQ6WMwQt/biNOdJl6wV5RkIbf4HzR8q0ACVZbawbFcC06Lj+CsmHvP5xXW9XJ24s3El+kaGUr+yt6Y1FxERketW6MEpLi4Ok8lElSpVAFi7di1Tpkyhbt26DBky5PqqLiIKTiI3yDDg6GZrgNoy42KI8gyENs+cD1CeBXrJ+OQ0Zm04xPToOA6eTLW11w32pk9UCHc1royPe8HefyUiIiKlX6EHp3bt2jFkyBAefPBBjh07Rnh4OPXq1WP37t089dRTvPnmm9ddfGFTcBIpQOZM2DwNln8Cpw9Y2zwCrAEq8uECD1AWi8Hq/SeZHh3Hb/8dI+P84rquTg50axBM78gQoqr7qxdKRERE8qXQg5Ofnx+rV68mPDycL7/8kunTp7NixQoWLVrEY489xr59+667+MKm4CRSCMyZsGU6/DPisgD1NEQ+UuABCiAxNYO5Gw8zbW0cO4+fsbXXCPCkV2QI9zStQmA51wK/roiIiJQehR6cvLy8+O+//6hWrRp33nknbdq04eWXXyY2Npbw8HDOnTt39ZPYiYKTSCEyZ1qH7/0zAk7vt7Z5lIfW5wOUq1eBX9IwDDYfSmLa2lh+3nyE1AwzAE4OJjrXqUCfqBDa1QrE0UG9UCIiIpJdoQenFi1a0KlTJ7p168att97K6tWradSoEatXr+bee+/l0KFD1118YVNwEikC5izYOgOWfXxZgHoKIgcXSoACSEnPYsGWI0xdG8emuERbeyUfN+5rHsJ9zatQxU+L64qIiIhVoQenpUuX0rNnT5KTkxkwYADfffcdAK+99hoxMTHMmTPn+iovAgpOIkXInAVbZ8I/H8Op80N43f2tASpqMLgW3tpMMceSmR4dx9yNh0m8ZHHd9rUC6RMZws11KuDi5FBo1xcREZHir0imIzebzSQnJ+Pn52drO3DgAB4eHgQFBV3PKYuEgpOIHZiz4L9Z1h6oU3utbe7+0PpJiBpSqAEqLdPMH9uOMT06jpV7T9raA7xcuKdpFXpFhhAWWDg9YCIiBS0pNZPlexJYsecEYYFePNy2uibEEbkBhR6czp07h2EYeHhYh7wcPHiQuXPnUqdOHbp06XJ9VRcRBScRO8o1QPmd74Eq3AAFcPDkWWasi2PmukPEn7m4uG5UNX96R4Zwe4Ng3F0cC7UGEZFrYRgG244ks2xXAkt3xrMhNtG2rh3A4x3DeKlLuMKTyHUq9OB06623cvfdd/PYY4+RmJhIREQEzs7OnDhxgs8++4zHH3/8uosvbApOIsWAOQv+m20dwndyj7XN3Q9ane+Bcivc92aW2cLfOxOYHh3LXzHxXPgMUs7NiR6NK9M7MoT6lX0KtQYRkStJOpfJv7tPsHRnPMt2JWT7Qw9AzSAv6gR788vmIwA8fVNNnrs13B6lipR4hR6cAgICWLZsGfXq1WPChAmMGjWKjRs3Mnv2bN5880127Nhx3cUXNgUnkWLEYrYGqGUfXQxQbr7nh/A9WugBCuBYUhqz1scxfV0ccacuzghav7I3fSJDubNxJbzdtLiuiBQewzDYcfQMS3fFszQmgfWxp7P1Krk7O9KmZnk6hgfRoXYgIf7WET/f/bufd37dDsCznWvzTOdadqlfpCQr9ODk4eFBTEwMoaGh9OrVi3r16vHWW28RFxdHeHg4qamp1118YVNwEimGLGb4b875ALXb2ubma+2BajEE3Aq/98diMVi59yTTomNZtO04GWbr4rpuzg50a1CJvlEhNKvqp+EwIlIgktMyWbH7BEt3JrB0VzzHk7P3KoUFetIxPIiO4YFEVffH1Sn3YcQTlu/jvQXWP1i/cGttnrxJ4UnkWhR6cGrYsCGPPPIIPXv2pH79+vz++++0atWK9evX061bN44dO3bdxRc2BSeRYsxihm1zrQHqxC5rm5vP+QD1aJEEKIBTZy8srhvL7vgUW3tYoCd9IkO5u2llyntpcV0RyT/DMNh5/Ax/x1jvVVp/8DRZl/QquTk70DosgE7hgXQMD7L1KuXHuGV7+fC3GABe7hrB4x3DCrx+kdKq0IPTrFmz6NevH2azmZtuuonFixcDMHz4cP755x9+++2366u8CCg4iZQAtgD1MZzYaW1z84GWT0DLx4osQBmGwYbYRKZHx/LL5qOcy7QuruvsaOLWuhXpHRlC25oBOGhxXRHJxZm0TFbsOcmyXfEs3ZnA0aS0bNtrBHjSITyQTuFBRFX3x835+ien+ervPYz4w/rz8vXb6zC4fY0bql2krCiS6ciPHTvG0aNHadSoEQ4O1rVQ1q5di7e3NxEREddzyiKh4CRSgljMsH0eLP3osgA1FFo8Bu6+RVbKmbRMftl8lOnRsWw+lGRrr+zrTu9I6+K6wT7uRVaPiBQ/hmGw63gKS3dag1L0gVM5epVa1ShvG4JXtbxngV7/iyW7+XyJtbf+/+6oy8Ntqxfo+UVKoyIJThccOnQIgCpVqtzIaYqMgpNICXQhQC37GBKsw1Fw9YGWj1sfRRigALYfSWZ6dCxzNx4mOS0LAAcTdKgdSJ+oUG6KCMLZUYvripQFKelZrNhjvVdp2c54jlzWq1StvIctKLWsUf6GepXy47NFO/nyL+tkO2/fWY8BrasV6vVESrpCD04Wi4X33nuPTz/9lJQU6/j/cuXK8fzzz/P666/beqCKIwUnkRLMYrkkQJ2fvdOOASot08zv/x1j6tpY1uw/ZWsP8HLl3mZV6B0ZQvWAgv2LsojYl2EY7IlPYenOBP7eGU/0gVNkmi9+lHJ1cqBljfK2e5WqFfHPAMMwGPHHTsYsta6V926P+jzYsmqR1iBSkhR6cHr11Vf59ttvefvtt2nTpg0A//77L8OGDWPw4MG8//7711d5EVBwEikFLBbYMd86hM8WoLwvCVB+RV7SvoQUZqw7xKz1hziRcnF2rJY1/OkTGUrX+hUL/S/NIlI4zqZnsXLvSdsQvMOJ57JtD/X3sAaliCBaVi9v94W0DcPgw99i+PqffQAMv7sBfaNC7VqTSHFV6MGpUqVKjBs3jjvvvDNb+/z58xk6dCiHDx++1lMWGQUnkVLEYoEdP1tn4Yu3rmWCq7f1/qeWj4OHf5GXlGm28OeOeKZHx7JsV4JtcV0fd2d6NrEurlsnWD97RIozwzDYm3DWFpTW7j9lW6IAwOV8r1LH2oF0DA+keoBnsVuqwDAM3luwg2//3Q/Ax/c0pFdkiJ2rEil+Cj04ubm5sWXLFmrXrp2tfefOnTRu3Jhz585d4Uj7U3ASKYUsFoj5xdoDFb/N2uZSzjoDX8uhdglQAEcSzzFz3SFmrIvL9hfqRlV86BMVSvdGlfBydbJLbSKSXWpGFqv2nuTv82Hp0Onsn2VC/N3pWDuIThHWe5U8XIr/e9cwDN7+ZTuTVh7AZIJP7m3EPc1Kxj3pIkWl0INTixYtaNGiBV9++WW29qeeeoq1a9eyZs2aaz1lkVFwEinFLBaI+dXaA3X8P2ubSznrGlCtnrBbgDJbDFbsOcG06FgWbz9uux/Cw8WROxoG0zsylKahvsXuL9YipZlhGOw7cda6AO3OeNbsP0VG1iW9So4OtKjhT4fagXSKCKJGMexVyg/DMHhz/jYmrz6IyQSf92pMjyaV7V2WSLFR6MFp2bJldOvWjdDQUFq1agXAqlWriIuLY+HChbRr1+76Ki8CCk4iZYDFAjsXwNIPLwtQQ6yL6dopQAGcSEln7obDTIuOZW/CWVt77Qpe9I4M5e4mlfHzdLFbfSKl2bkMM6v3XexVij2Vmm17ZV93OkUE0rF2EK1rloxepfywWAzemP8fU9bE4mCCL/o0oXujSvYuS6RYKJLpyI8cOcJXX31FTIx1auA6deowZMgQ3nvvPb755pvrOWWRUHASKUNsAeojOL7V2ubiBVHnA5RnebuVZhgG6w6eZtraOBZsPUJapvUv3S6ODnSpX5E+kSG0qlFei+uK3KD9J6z3Kv29M4HV+05m61VydjQRVd2fTuenCw8L9CqRvUr5YbEYvDpnK9PXxeHoYGJU3ybc3iDY3mWJ2F2RruN0qc2bN9O0aVPMZnNBnbLAKTiJlEEWC+xcCMs+hGOXBqjB0OopuwYogOS0TOZvOsL06Fj+O5xsaw/xd6d38xDuax5CBW83O1YoUnKkZZpZte8ky85PF37wZM5epQ7hgXQKD6J1WHk8y9B9hhaLwUuztzBr/SGcHEyM7teUrvUr2rssEbtScMqDgpNIGWYY1gC19EM4tsXa5ux5fgif/QMUwH+Hk5geHce8jYc5k35xcd2bIoLoHRlKp/BAnLS4rkg2B873Ki3dlcCqvSdJv6xXKbKaPx3Pr6tUK6j09irlh9li8MLMzczdeBgnBxNjH2jGLXUr2LssEbtRcMqDgpOIWAPUb7B0ePYAFTUYWj8FngH2rQ/rvRgLtx5lenQcaw9cXFw3qJwr9zWvQq/mIVQtr8V1pWxKyzSzZv8p/o6JZ9muBPafOJtte7CPGx3PD79rUzNAs1dexmwxeHb6Jn7efARnRxNfP9iMmyIUnqRsUnDKg4KTiNgYBuz63Rqgjm62tjl7QtQj0PrpYhGgAPbEpzBjXRyz1x/i5NkMW3ubmuXpHRnKrXUraHFdKfViT6aydFc8f8fEs2rfSdt9gQBODiaaV/OjY3gQncKDqF2hbPcq5UeW2cIz0zaxYOtRXBwd+KZ/MzqGB9m7LJEiV2jB6e67785ze2JiIsuWLVNwEpGSxTBg1x/nA9Qma5uzB0SeD1BegXYt74KMLAt/7jjO1Og4lu9O4MJPb18P6+K6fSJDCa9Yzr5FihSQtEwza/efsk4XviuefQnZe5UqerudH35n7VUq5+Zsp0pLrkyzhaembOT3bcdwcXLg2wHNaVerePy8EykqhRacBg0alK/9Jk6cmN9TFjkFJxG5IsOA3YusAerIRmubswdEPgytnyk2AQrg0OlUZq47xMx1cRxJSrO1Nwn1pU9kCHc0rFSmbnqX0iHuVCpLdyWwNCaelXtPci7z4h9iHR1MNK/qZxuCF1GxnHqVCkBGloUnpmxg8fbjuDo5MHFgJK1rFo/edpGiYLehetfjq6++YsSIERw7doxGjRoxatQooqKirrh/YmIir7/+OnPmzOHUqVNUrVqVkSNHcvvtt+fregpOInJVtgD1IRzZYG1z9oDmD0GbZ8Cr+AxnMVsM/tmdwPS1cSzZcZwsi/VHuqeLI3c2rkTvyFAaVfHRB0wpltKzzETvP31+uvD4bGubgfWevo7nZ8BrUysAb/UqFYqMLAuP/7ieP2PicXN2YNKgKFrWsP9kOSJFocQEp+nTp9O/f3/GjRtHixYtGDlyJDNnzmTnzp0EBeX8YJKRkUGbNm0ICgritddeo3Llyhw8eBBfX18aNWqUr2sqOIlIvhkG7F5sncb88Hprm5P7+R6op6Fc8bqZOuFMOrM3HGJ6dFy2m+UjKpajT2QIPZpUxtdDi+uKfR06nWodfrczgZV7T5Cakb1XqVmon2268DrB6lUqKulZZh6dvJ6lOxPwcHFk0qAooqrbb7FwkaJSYoJTixYtiIyMZPTo0QBYLBZCQkJ46qmneOWVV3LsP27cOEaMGEFMTAzOztf3VycFJxG5ZoYBe5ZYe6AOr7O2Oblf7IEqZgHKMAzW7j/F9Og4Fmw9apua2cXJgdvqV6T3+cV19YFUikJGloV1B07x9854lu5MYHd8SrbtgeVc6VjbOlV421oB+LirV8le0jLNDP5hHct3n8DTxZEfHo6iWVWFJyndSkRwysjIwMPDg1mzZtGjRw9b+4ABA0hMTGT+/Pk5jrn99tvx9/fHw8OD+fPnExgYSL9+/Xj55ZdxdMx9Rqn09HTS09Ntz5OTkwkJCVFwEpFrZxiw50/rPVC2AOUGzR8ulgEKICk1k/mbDzN1bRw7jl5cXLdaeQ96RYZwb7MqBJXT4rpSsI4knmPp+QVoV+45wdlLepUcTNA01I9OEUF0qB1I3WBvHBwU4ouLtEwzD38fzYo9J/FydWLyw1E0CfWzd1kihaZEBKcjR45QuXJlVq5cSatWrWztL730EsuWLWPNmjU5jomIiODAgQPcf//9DB06lD179jB06FCefvpp3nrrrVyvM2zYMN5+++0c7QpOInLdDAP2/mntgToUbW1zcrukB6qifevLhWEYbD2cxLToOH7edISU84vrOjqYuDkiiD5RIbSvpcV15fpkZFlYd/AUy86HpV3Hs/cqBXi50qF2IJ0iAmlXMxAfD/UqFWfnMswMmrSW1ftOUc7ViR8faUGjEF97lyVSKEptcKpduzZpaWns37/f1sP02WefMWLECI4ePZrrddTjJCKFxjBg71/nA9Raa5uTGzQbBG3/VywDFEBqRha/brEurrv+4Glbe0VvN3o1r8J9zUMI8fewY4VSEhxNOnf+XqV4Vuw5aQvjYO1VahLqZxuCV6+SepVKmtSMLAZ+F83aA6fwdnNiyuCW1K/sY++yRApciQhO1zNUr0OHDjg7O7NkyRJb22+//cbtt99Oeno6Li5Xv+lZ9ziJSIEzDNj3N/w9/GKAcnSF5oOgzf/AO9iu5eVl9/EzTI+OY/aGQ5xOzQTAZIK2NQPoHRnCLXUr4OqkxXXFuubP+oOnbWEp5tiZbNvLe7rQIdwalNrXCtBEJKVASnoWA79by7qDp/Fxd2bK4BbUq6TwJKVLiQhOYJ0cIioqilGjRgHWySFCQ0N58sknc50c4rXXXmPKlCns27cPBwfrcJIvvviCjz76iCNHjuTrmgpOIlJoLgSopR9C3Plec0dXaDbQ2gPlXcme1eUpPcvM4u3HmR4dx/LdJ2zt/p4u3N2kMn2iQqgZpMV1y5rjyWksPT+pw7+7T3Dmkl4lkwkah/jSsXYQnSICqV/JR71KpdCZtEz6f7eWjbGJ+Hk4M3VISyIq6vOTlB4lJjhNnz6dAQMG8PXXXxMVFcXIkSOZMWMGMTExVKhQgf79+1O5cmWGDx8OQFxcHPXq1WPAgAE89dRT7N69m4ceeoinn36a119/PV/XVHASkUJnGLBv6fkAtdra5ugKzQZA22eLdYAC6yKkM9bFMWNdHMeTLw51bl7Vj96RIXRrGIyHixbXLY2yzBY2xCbaZsC7dEIRsAbpDrUD6RgeSLtagfh7qlepLEhOy+TBCWvYfCiJ8p4uTB3SktoV9IcUKR1KTHACGD16tG0B3MaNG/Pll1/SokULADp27Ei1atWYNGmSbf9Vq1bx7LPPsmnTJipXrszDDz+c56x6l1NwEpEiYxiwf5k1QMWusrY5ukDT8wHKp7J967uKLLOFf3YnMHVtHH/FxGM+v7iul6sTdzauRN/IUOpX9ta05iVcfHIaS3dZh98t332CM2nZe5UaVfGl4/kheA0rq1eprEo6l8kDE9aw9XASAV4uTBvSUr3QUiqUqOBU1BScRKTIGQbs/+d8gFppbXN0gab9zweoKvatLx/ik9OYdX5x3YMnU23tdYO96RMVwl2NK2v9nRIiy2xhY1yibQjetiPZe5X8PJxpX9u6AG27WgGU93K1U6VS3CSmZtBv/Bq2H00msJwr04a0JCzQy95lidwQBac8KDiJiN0YBhxYbg1QB1dY20pYgLJYDFbvP8n06Dh+++8YGecX13V1cqBbg2B6R4YQVd1fvVDFTPyZNJbtTGDprgSW70og+ZJeJYBGVXzoEB5Ep/BAGlbxxVG9SnIFp89m0Hf8amKOnSGonCvTH21F9QBPe5clct0UnPKg4CQixcL+CwHqX+tzRxdo8iC0e65EBCiw/vV57sbDTFsbx87jF2dYqxHgSe/IEO5uWoXAcuqtsAezxWBT3Gn+jklg6a54/jucvVfJ18OZ9rWs9yq1rx1IgHqV5BqcTEmn7/jV7DqeQkVvN6Y/2pKq5RWepGRScMqDgpOIFCv7l8Oyj6w9UQAOztD0QWj7HPiG2Le2fDIMg82Hkpi2NpafNx8hNcMMgJODic51KtAnKoR2tQLVi1HITqSk23qV/tmVQNK5zGzbG1T2oVN4IB3Cg2gcol4luTEJZ6zhaU98CpV83Jj+aCut/yYlkoJTHhScRKRYyi1ANXnA2gPlG2rf2q5BSnoWC7YcYVp0HBtjE23tlXzcuK95CPc1r0IVP324Kghmi8HmQ4ksjYln6a4EthxKyrbdx92ZdrUC6BQeRPvager9kwIXfyaNPt+sZl/CWar4uTNtSEu9v6XEUXDKg4KTiBRrB/61DuHLFqDuh3bPl6gABRBzLJnp0XHM3XiYxEsW121fK5A+kSHcXKcCLk4Odq6yZDmZks4/uxP4OyaB5bsTbIsWX1C/sjcdawfRMTyQxiG+ODnq6yuF63iyNTztP3GWUH8Ppg1pSSVfd3uXJZJvCk55UHASkRLhwApY9qF1Nj6wBqjG/awByq+qfWu7RmmZZhZtP860tbGs3HvS1h7g5cI9TavQKzJEM3NdgdlisOVQIkvPD8HbciiRS39rl3Nzst2r1CE8kKBybvYrVsqso0nn6PPNag6eTKVaeQ+mDWlFRR99L0rJoOCUBwUnESlRDq609kDtX2Z97uB0SYCqZtfSrsfBk2eZsS6OmesOEX/m4uK6UdX86RMVwm31g3F3yd+6fKXVqbMZ/HN+XaV/dp/g1NmMbNvrBnvTMTyQThFBNFGvkhQTRxLP0fubVcSdOkeNAE+mDWlJkLfCkxR/Ck55UHASkRLp4CprD9S+pdbnJTxAZZkt/L0zgenRsfwVE8/5tXUp5+ZEj8aV6R0ZQv3KPvYtsohYLAZbDyfx9/l1lTZf3qvk6kS72gF0rB1Eh/BAKujDqBRTh06n0vvr1RxOPEdYoCfThrTSvXVS7Ck45UHBSURKtNjV1h6ofX9bnzs4QaO+1gDlX92+tV2nY0lpzFofx/R1ccSdOmdrb1DZh96RIdzZuBLebqVrcd3TZzP4Z3cCy3YmsGxXAicv61WKqFiOThFBdKwdSNOqfjirV0lKiNiTqfT5ZhVHktKoFeTF1CEtNd29FGsKTnlQcBKRUiF2jbUHau9f1ucmR2jcF9q9UGIDlMVisGrfSaaujWXRtuNkmK2L67o7O9KtYTB9IkNoVtWvRC6ua7EY/HckyXqv0s54NsUl2nrZALxcnWhbM4BOEYF0qB2k+0OkRDtw4ix9vlnNseQ0IiqWY8rglvh7uti7LJFcKTjlQcFJREqVuLXWHqi9f1qfmxytPVDtnwf/Gvat7QacOnthcd1Ydsen2NrDAj3pExnK3U0rU76Y/xU7KTXTOgPeznj+2ZXAiZScvUodwgPpFB5EM/UqSSmzLyGFPt+sJv5MOnWCvZk6uAW+HgpPUvwoOOVBwUlESqVcA1Qf6xC+8mH2re0GGIbBhthEpkfH8svmo5zLtC6u6+xo4ta6FekdGULbmgE4FIPFXC0Wg+1Hk1m6M56/dyawMfZ0tl4lTxdH2tYKoGN4EB1qB2rKZin19sRbw9OJlHTqVfJmyiMt8fEoXcNupeRTcMqDgpOIlGpx0dYhfHuWWJ+bHKFhb2j/QokOUABn0jL5ZfNRpkfHsvmSxV4r+7rTO9K6uG6wT9GGkaTUTJbvSWDp+XuVEi6ZKRCgdgUvOoZb11VqXtVf61ZJmbP7+Bn6fLOak2czaFjFh8kPt8DHXeFJig8FpzwoOIlImXBonbUHas9i63OTIzTsBe1fLPEBCmD7kWRmrItjzoZDJKdlAeBggg61A+kTFcpNEUGFMvTNMC70KlnvVdoQm4j5km4lDxdH2tQMoGN4IB3Dg6isXiURdh47Q9/xqzl1NoNGIb5Mfjiq1E34IiWXglMeFJxEpEw5tN7aA7V7kfW5yQEanA9QATXtW1sBSMs08/t/x5gWHcvqfads7QFertzbrAq9I0OoHuB5Q9dITsvk390nWHp+uvD4y3qVagV52YJS82p+uDqV7XWoRHKz/Ugy/SasJjE1k6ahvvzwcAu8XJ3sXZaIglNeFJxEpEw6tB6WfQS7/7A+L2UBCmD/ibNMj45j1vpDnEi5GG5a1vCnT2QoXetXxM356qHGMAxijp2xrau0/uDpbL1K7s6OtKlZ3jYEr4qfR6G8HpHS5r/DSfQbv5rktCwiq/kxaVAUngpPYmcKTnlQcBKRMu3welj2Mez63frc5AAN7jsfoGrZt7YCkmm28FdMPNPWxrJsV4JtggYfd2d6NrEurlsnOPvP/zNpmazYc4K/Y6z3Kh1LTsu2PSzQk47hQXQKDyKyunqVRK7XlkOJ3D9hDWfSsoiq7s+kQZF4uCg8if0oOOVBwUlEBDi84XyA+s363OQA9e+1BqjA2vatrQAdSTzHrPWHmB4dx+HEi4vrNqriw33NQ0hJz+LvmHjWHzxN1iW9Sm7ODrQJu3ivUoi/epVECsqmuEQenLCGM+lZtKpRnu8GRuLuoj9GiH0oOOVBwUlE5BJHNsLSjy4GKEzQ4F5o/1KpClAWi8G/e04wPTqORduPkWnO+auvRoCnbfhdVHX/fA3rE5HrsyH2NP2/XUtKehZtawYwYUBzvefELhSc8qDgJCKSiyMbrT1QOxeebzBB/Xugw0sQGG7X0grayZR05mw4zIKtR/HzcLaFparlb2wSCRG5NusOnKL/d2tJzTDToXYgXz/YTOFJipyCUx4UnERE8nBk0/kAteB8gwnq323tgQqKsGdlIlIKrdl3koETozmXaeamiCDGPtBU9xBKkbqWbKCV+ERE5KJKjaHvFHj0H4i4AzDgv9kwpiXMHATxO+xdoYiUIi3O3+Pk5uzAXzHxPPHTRjKyLPYuSyRXCk4iIpJTcCPo8xM8uvxigNo2B8a0gpkDFaBEpMC0CivPtwMicXVyYMmO4zw1dQOZZoUnKX4UnERE5MqCG1oD1GP/Qp3uWAPU3IsB6vh2e1coIqVAm5oBjO/fHBcnB/7Ydpxnpm1UeJJiR8FJRESurmID6P0jPLYC6tyJLUCNbQUzBihAicgNa187kK8faIaLowMLtx7j2embyFJ4kmJEwUlERPKvYn3oPfmSAAVsn3c+QPWH49vsWp6IlGydIoIYc39TnB1N/LrlKM/P3IzZUqbmMZNiTMFJRESu3YUA9fhKqHuXtW37fBjbGqY/CMf+s299IlJida5bgdH9muLkYGL+piO8qPAkxYSCk4iIXL8K9aDXD+cDVA/ABDt+hnFtYPoDcGyrvSsUkRKoS72KjOrbBEcHE3M2HuaV2VuwKDyJnSk4iYjIjatQD3p9bw1Q9XpiDVC/wLi2MO1+OLrF3hWKSAlzW4NgvujTGAcTzFx/iNfmblV4ErtScBIRkYJToS7cNwmGroJ6dwMmiPkVvm6nACUi1+yOhpX4vLc1PE2LjuP/5v+HYSg8iX0oOImISMELqgP3TYShq6H+PWQLUFP7wdHN9q5QREqIuxpX5tNejTCZ4Kc1sQz7eZvCk9iFgpOIiBSeoAi497vzAepewAQ7F8DX7RWgRCTfejapwoh7reHp+1UHeefX7QpPUuQUnEREpPAFRcC938ITa3IJUH3hyCZ7Vygixdy9zarw4d0NAJi44gAfLNyh8CRFSsFJRESKTmD4xQDV4D4wOcDOhfBNB5jSB45stHeFIlKM9Y4M5YOe1vA0fvl+Pvp9p8KTFBkFJxERKXqB4XDPBBi6Bhr0sgaoXb/BNx1hSm84vMHeFYpIMdWvRSjv3lUPgHHL9vLpol0KT1IkFJxERMR+AmvDPePhibXQsPf5APU7jO8EP/WCw+vtXaGIFEMPtqrGW93rAjD67z188eduO1ckZYGCk4iI2F9ALbj7G3giGhr2sQao3X/A+Jvgp/vgkAKUiGQ3qE113uhWB4CRS3YzSuFJCpmCk4iIFB8BNeHur60BqlHf8wFqEUy4CX68Fw6ts3eFIlKMPNKuBq/eFgHAp4t38dXfe+xckZRmCk4iIlL8BNSEnuPgyXXQqJ81QO1ZDBNuhh/vgbhoe1coIsXEox3CeLFLOAAj/tjJ18v22rkiKa0UnEREpPgqHwY9x14SoBxhzxL4trMClIjYPNGpJs/dUhuA4b/FMGH5PjtXJKWRgpOIiBR/tgAVDY3vzx6gJt8NcWvtXaGI2NnTN9fi6ZtrAfDegh1MWrHfzhVJaaPgJCIiJUf5MOgxBp5aB40fsAaovX/Ct7fA5J4Qu8beFYqIHT3buRZPdAoDYNgv25m86oB9C5JSRcFJRERKHv8a0OMreGo9NLkQoP6C726FH3pA7Gp7VygidmAymXjh1nAe62ANT/83fxtT1sTauSopLRScRESk5PKvDnddCFAPgoMT7PsbvusCP9ylACVSBplMJl7uGs7gdtUBeG3uVmZEx9m5KikNFJxERKTk868Od422Bqim/c8HqKXWAPX9nXBwlb0rFJEiZDKZeO32OgxqUw2Al+dsYdb6Q/YtSko8BScRESk9/KrBnaPgqQ3QdIA1QO1fBhO7wvfd4eBKe1coIkXEZDLx5h116d+qKoYBL87azNyNCk9y/RScRESk9PGrCnd+eVmA+gcm3gaT7oADK+xdoYgUAZPJxNt31uP+FqEYBjw/YzM/bz5i77KkhDIZhmHYu4iilJycjI+PD0lJSXh7e9u7HBERKQqnD8K/n8HGn8CSaW2r1g4a9oagOhBQG9z0O0GktLJYDF6bu5Vp0XE4Opj4sk8TujUMtndZUgxcSzZQcBIRkbIjMRaWfwYbf7wYoC7wrgKB4RAYkf2/7r52KVVECpbFYvDSbOu9To4OJr7q14Su9RWeyjoFpzwoOImICIlxED0ejmyChJ2QcuzK+3pVvBikgiLOB6oI8PAvsnJFpGCYLQYvztzMnI2HcXIwMeb+ptxar6K9yxI7UnDKg4KTiIjkcO40JOyChJhLHjsh+fCVj/EMzNk7FRhhbTeZiq52EbkmZovBczM2MX/TEZwdTYx7oBk316lg77LEThSc8qDgJCIi+ZaWDCd2ZQ9TCTHWIX9X4u53sVfq0kBVrqIClUgxkWW28Mz0TSzYchQXRwe+7t+MTuFB9i5L7EDBKQ8KTiIicsPSU84Hqp3ZA9XpA8AVfq26+pwPUeHZQ5VPFQUqETvINFt4eupGfvvvGC5ODkzo35z2tQPtXZYUMQWnPCg4iYhIock8Byd2XxKozoeqU/vAMOd+jItX7pNS+ISCg1YNESlMmWYLT/y0gUXbj+Pq5MB3AyNpUzPA3mVJEVJwyoOCk4iIFLmsdDi5J3vvVMJOa5slK/djnNwhsPZlgSrCusivg2ORli9SmmVkWRj603qW7IjHzdmBiQOjaBVW3t5lSRFRcMqDgpOIiBQb5kxrb9SlgSo+Bk7uBnNG7sc4ulrXnbq8l8q/Ojg6F239IqVEepaZxyav5++dCbg7O/L9Q1FEVdfMmWWBglMeFJxERKTYM2dZ75e6fFKKE7sgKy33YxycoXxNa5AKqnNJoAoDJ5ciLV+kJErLNDNk8nr+2ZWAh4sjPzwURfNqCk+lnYJTHhScRESkxLKYrTP6ZbuHKsY6lXrm2dyPMTlC+bCck1KUrwXObkVbv0gxl5Zp5pHv1/HvnhN4uTrxw8NRNA31s3dZUogUnPKg4CQiIqWOxQLJh3JOSpGwE9KTcz/G5GC9XyqwTvZhfwG1wcWjSMsXKU7OZZh5aFI0q/adpJyrEz8+0oJGIb72LksKiYJTHhScRESkzDAMOHP04r1TtkC1A9KSrnCQCXxDc05KEVgbXMsVafki9pKakcXAidGs3X8KbzcnfnqkJQ2q+Ni7LCkECk55UHASEZEyzzAgJT7nLH8JMZB64srH+YTknJQioDa4+xZZ6SJF5Wx6FgO+W8u6g6fxcXdmyuAW1Kuk8FTaKDjlQcFJREQkD2dP5JyUImEnpBy/8jHlgi/rnTofrDx0Y72UbCnpWfT/dg0bYhPx83BmyuCW1AnW58fSRMEpDwpOIiIi1yH1lHVWv8sDVfLhKx/jGZTL4r4R4BkAJlPR1S5yA5LTMnnw27VsjkvE39OFqYNbEl5Rw1ZLCwWnPCg4iYiIFKC0JOusfpdPSpEUe+Vj3P2tASooInuo8qqgQCXFUtK5TB6YsIath5Mo7+nCtCEtqVVB4ak0UHDKg4KTiIhIEUhPOd9DddnU6acPAlf46OHmc1nv1Pn/eldWoBK7S0zN4P4Ja9h2JJkAL1emDWlJzSAve5clN0jBKQ8KTiIiInaUkQond+eclOLUPjAsuR/jUi6XIX/h1skqHByKtn4p006fzaDv+NXEHDtDUDlXpj/aiuoBnvYuS26AglMeFJxERESKocw0OLUX4ndkD1Wn9oIlK/djnD2ss/pdCFJB59ek8q0KDo5FW7+UGSdT0uk3fg07j5+horcb0x9tSdXyCk8llYJTHhScRERESpCsDGtv1OWTUpzcDeaM3I9xcoOAWjknpfCrDo5ORVu/lEonUtLp+81qdsenUMnHjemPtiLEXwtHl0QKTnlQcBIRESkFzFlwen/OqdNP7IastNyPcXSB8jXPh6k6F0OVfw1wcina+qXESziTTp9vVrE34SyVfd2Z/mhLqvgpPJU0Ck55UHASEREpxSxmSDyY8x6qhJ2QmZr7MQ5O4B+W8z6q8jXB2a1o65cSJT45jT7frGbfibOE+LszfUgrKvm627ssuQYlLjh99dVXjBgxgmPHjtGoUSNGjRpFVFTUVY+bNm0affv25a677mLevHn5upaCk4iISBlksUBSXO6BKuNM7seYHKy9UZdPSlG+FrioZ0GsjiWl0fubVRw8mUrV8h5MH9KKij4K3CVFiQpO06dPp3///owbN44WLVowcuRIZs6cyc6dOwkKCrricQcOHKBt27bUqFEDf39/BScRERG5doYByUcuC1PnH2lJVzjIBH5VcwaqgHBw1fTUZdGRxHP0/mYVcafOUT3Ak+lDWhLkrfBUEpSo4NSiRQsiIyMZPXo0ABaLhZCQEJ566ileeeWVXI8xm820b9+ehx56iOXLl5OYmKjgJCIiIgXHMCDleM7eqfgdcO7UlY/zCT0fpi6ZlCKwtnWNKinVDp1OpffXqzmceI6wQE+mDmlJUDmFp+LuWrKBXaeWycjIYP369bz66qu2NgcHBzp37syqVauueNw777xDUFAQDz/8MMuXL8/zGunp6aSnp9ueJycn33jhIiIiUrqZTFCuovVRo2P2bWdPXOyVir9kcoqz8ZAUa33sWZz9mHKVLoapoPOBKqA2ePgX2UuSwlXFz4NpQ1rS+2vrhBH3j1/D1CEtCfBytXdpUkDsGpxOnDiB2WymQoUK2dorVKhATExMrsf8+++/fPvtt2zatClf1xg+fDhvv/32jZYqIiIiYuUZAJ5toVrb7O2pp3K/h+rMkYuPfX9nP8arQi6L+0ZYryElToi/B1OHtKT319apyu8fv4Ypg1tQXuGpVChRixmcOXOGBx98kPHjxxMQkL8fKK+++irPPfec7XlycjIhISGFVaKIiIiUVR7+ULWV9XGptCRI2AUJly3umxRnHQ6Ychz2/3PZucpfMtTvklDlFWTtDZNiq2p5z/PhaRU7j5/h/glrmDq4JX6emvK+pLNrcAoICMDR0ZHjx49naz9+/DgVK1bMsf/evXs5cOAA3bt3t7VZLBYAnJyc2LlzJ2FhYdmOcXV1xdVVKV9ERETsxM0HQiKtj0uln4ETu3L2Up0+CKkn4eAK6yPbuXwvBimfEOu53bzP//f8w/X8cxcvcHAospcpF1UP8LT1PMUcs4anKYNb4Ouh8FSSFYvJIaKiohg1ahRgDUKhoaE8+eSTOSaHSEtLY8+ePdna3njjDc6cOcMXX3xB7dq1cXHJ+xtSk0OIiIhIsZaReoVAtR8MS/7PY3K4GKLcvK2h6/JwZXtc/vz8Pg6OhfYyy4Ldx8/Qd/xqTqRk0KCyDz8+0gIfd2d7lyWXKDGTQwA899xzDBgwgObNmxMVFcXIkSM5e/YsgwYNAqB///5UrlyZ4cOH4+bmRv369bMd7+vrC5CjXURERKREcvGASo2tj0tlpsHJPRfDVMpx6zDA9GTrfy99mDOsISst0fq47lrKXTlc5QhflwU0V29wKts9LLUqlOOnR1rSd/xqth5Oov93a5n8cBTebgpPJZHdg1Pv3r1JSEjgzTff5NixYzRu3Jjff//dNmFEbGwsDupmFhERkbLO2Q0q1rc+riYzLXuQSr8sWKVdFrYuD1+ZqdbzZJyxPpIPXV/NTu7569ly87mkR+ySfZzcSvw9XeEVy/HTIy3oN341m+MSGfDdWn54KIpyCk8ljt2H6hU1DdUTERERuQpz5vlwlXjlcHV5+Lp0n/QCWv7F0SUfwwp9r7yPi1exCV7bjiTRb/waks5l0ryqH98/FIWnq937MMq8ErUAblFTcBIREREpZBbz+RCVR7i60uPC9mu5n+tKTA5XGFbom4+hh94Ffp/Xf4eT6Dd+NclpWURV92fSoEg8XBSe7EnBKQ8KTiIiIiLFnGFARkoeQwuvMvQwLQksmQVTy6WB6mq9X9m2+1q3O2Yfkrc5LpEHJqzhTHoWrWqU57uBkbi7aBIOe1FwyoOCk4iIiEgpZxiQlZZLuEq8Ss/XJW1Z5wqmFmePHOHqlMWdRXvTOGl2o7x/IPe0qYezp2/uQw+d3QqmDslViZpVT0RERESkQJlM4OxufZTLuTZovmRlXBKuEq9+X9fl4SvjjPU8manWx5mjtlP7A31MWD+JJwO/5VGHo2s+ZzS8wqQbLp7F5j6vkk7BSURERETkck4u4BQAngHXd7w5yxqq8ujZOhZ/nFXb9uFhnCXUI5NwXwsO6ZeELwwwp8PZBOvjepgcrzCsMLfAlUtAc/XWQsrnKTiJiIiIiBQ0Ryfw8Lc+rqAiUHHvSQZNWktakoWbg4MYO7gZLk4OYLFkv88r156txLyHHlqywDDDuVPWx3UxXbaQ8pWmk88tfPlatzuWjsihe5xEREREROxoxZ4TPDQpmvQsC7fUrcCY+5vi7HiDvTyGAZnnrjCsMDF/Qw+z0grk9eHsmXu46vrh9ffoFRBNDpEHBScRERERKW7+2ZXAIz+sIyPLwm31K/Jl3yY3Hp5uVFb6ZeEq8eqTalwavjJS8j7/C3vAK7BIXsqVKDjlQcFJRERERIqjv3fG8+gP68kwW+jWMJgvejfGyd7h6UZcuM/rSut1RQ3JMV17UdOseiIiIiIiJUyn8CDGPtCUx35cz4ItR3E0mfi8d2McHUrorHj5uM+rJCnBEVZEREREpHS5uU4FxtzfDCcHEz9vPsKLMzdjtpSpAWLFloKTiIiIiEgxckvdCozu1xRHBxNzNh7m5dlbsCg82Z2Ck4iIiIhIMdO1fkW+7NMERwcTs9Yf4rW5WxWe7EzBSURERESkGOrWMJjPezfGwQTTouN4Y/5/lLF53YoVBScRERERkWLqzkaV+KxXY0wmmLImlrd+3qbwZCcKTiIiIiIixViPJpUZcW8jTCb4YdVB3vl1u8KTHSg4iYiIiIgUc/c2q8JHdzcEYOKKA7y/YIfCUxFTcBIRERERKQF6RYbwQc8GAEz4dz8f/h6j8FSEFJxEREREREqIfi1CebdHfQC+XraPEX/sVHgqIgpOIiIiIiIlyIMtqzKse10Axizdy+dLdtu5orJBwUlEREREpIQZ2KY6b3SrA8CXf+7mC4WnQqfgJCIiIiJSAj3Srgav3R4BwOdLdvHV33vsXFHppuAkIiIiIlJCDWkfxstdreFpxB87Gbdsr50rKr0UnERERERESrDHO4bxwq21AfjwtxgmLN9n54pKJwUnEREREZES7smbavG/zrUAeG/BDiau2G/nikofBScRERERkVLgmZtr8dRNNQF4+5ft/LDqgH0LKmUUnERERERESgGTycRzt9Tm8Y5hALw5fxs/rTlo56pKDwUnEREREZFSwmQy8VKXcIa0rwHA63P/Y3p0rJ2rKh0UnEREREREShGTycSrt0XwUJvqALwyZysz18XZuaqST8FJRERERKSUMZlM/N8ddRjQqiqGAS/N3sKcDYfsXVaJpuAkIiIiIlIKmUwmht1ZjwdahmIY8MLMzczfdNjeZZVYCk4iIiIiIqWUyWTinTvr0zcqBIsBz07fxC+bj9i7rBJJwen/27v/oKrq/I/jr8uve/ktiPJDKTKL1BJTBLFtrGSjcpp1v7WVS4aWmhs6Os7uxja7YeN+R+vbZDtprKup02rSWoPb7JauUupkogZSWOb2a41SQDMBMUG5n+8fTXy/V4HLBe89XHg+Zs6MnPs5+L7vec8ZX557zgUAAAD6sIAAm/576g36xbihchpp4auVeqvquNVl+R2CEwAAANDHBQTYtOye0fqvsUPU6jSav+mgtn1UY3VZfoXgBAAAAPQDgQE2/c+9aZo6JkkXnEbzXqnQjo9rrS7LbxCcAAAAgH4iMMCmZ3+RprvTknS+1eixjRV655M6q8vyCwQnAAAAoB8JCgzQ8vvSNOWGRLW0OvXohnLt+vcJq8vq9QhOAAAAQD8TFBig5x8Yo5xR8Wq54NScl9/Xu5+etLqsXo3gBAAAAPRDwYEBemHaWGWPiFfzBadmvXxA731OeOoIwQkAAADop0KCArQy90bddt1gnTvv1CPr39e+L761uqxeieAEAAAA9GP2oEC9mDtWk64dpO/Pt2rm+gN6/z+nrC6r1yE4AQAAAP2cIzhQq6aP083XxOlsS6vy1u5X+dHvrC6rVyE4AQAAAJAjOFB/mZ6uiVcPVFNLq2as3a/K6tNWl9VrEJwAAAAASJJCQwK1Ji9dmVfFqrH5gqa/tE8ffn3a6rJ6BYITAAAAgDZhIUFaO2O8xqfEqPHcBT24Zp8OfVNvdVmWIzgBAAAAcBFuD9K6mRkad2WMGs5d0IMv7dPHxxqsLstSBCcAAAAAl4iwB2n9zPEakzxAp8+eV+6aMn1S03/DE8EJAAAAQLsiHcF6+ZEMpQ2N1ndnzyt39T59WttodVmWIDgBAAAA6FCUI1gvP5yp64dE6dumFk1bvU+f1Z2xuiyfIzgBAAAA6FR0WLA2PJKpkYlROnmmWb9cXaYvTvSv8ERwAgAAAODWgLAQbZiVqesSIlXX2Kxpq8v0n5NNVpflMwQnAAAAAF0SGx6ijbMydW18hGobfghPX3171uqyfILgBAAAAKDLBkbYtXHWBF09KFzH689p2uoyVZ/q++GJ4AQAAADAI4Mi7do0e4KGxYXrm9Pf65dryvTN6e+tLsurCE4AAAAAPDY4yqFXZk9QysAwVZ/6XtP+Uqbj9X03PBGcAAAAAHRLQrRDm+ZM0BWxYfrq1FlN+0uZahvOWV2WVxCcAAAAAHRbYnSoNs2ZoKExofrPtz+Ep7o+GJ4ITgAAAAB6ZMiAUG2aPUFDBoTqi5NN+uWafTrR2Gx1WZcVwQkAAABAjyXHhmnT7AlKjHbos7ozyl1Tpm/P9J3wRHACAAAAcFlcMfCH8BQfZde/a88od80+nWpqsbqsy4LgBAAAAOCySYkL16bZEzQo0q5Pahr14Jp9On3W/8MTwQkAAADAZTVsUIQ2zZ6guAi7Pj7eoAdf2qf6s+etLqtHCE4AAAAALrvhgyP0yuxMDQwP0aFvGvTQ2n1qOOe/4YngBAAAAMArro2P1MbZmYoJC9YHX9crb+1+NfppeCI4AQAAAPCa6xKitHHWBA0IC9bBr05rxroDOtN8weqyPEZwAgAAAOBVI5OitOGRTEU5glR+9Ds9vO6Azrb4V3giOAEAAADwuuuHRGvDrExFOoJU+fVpfXysweqSPBJkdQEAAAAA+ofRQwfo5Ycz1HjugtJTYq0uxyMEJwAAAAA+c+MVMVaX0C18VA8AAAAA3OgVwWnlypVKSUmRw+FQZmam9u/f3+Ha1atX6+abb1ZMTIxiYmKUnZ3d6XoAAAAA6CnLg9Orr76qRYsWqbCwUBUVFUpLS1NOTo7q6uraXb9z505NmzZN77zzjvbu3avk5GTdfvvt+uabb3xcOQAAAID+wmaMMVYWkJmZqfHjx2vFihWSJKfTqeTkZM2fP18FBQVuj29tbVVMTIxWrFihhx56yO36hoYGRUdHq76+XlFRUT2uHwAAAIB/8iQbWHrFqaWlReXl5crOzm7bFxAQoOzsbO3du7dLv+Ps2bM6f/68YmPbfypHc3OzGhoaXDYAAAAA8ISlwenkyZNqbW1VfHy8y/74+HjV1NR06Xc8/vjjSkpKcglf/9/SpUsVHR3dtiUnJ/e4bgAAAAD9i+X3OPXEsmXLVFxcrJKSEjkcjnbX/O53v1N9fX3bVl1d7eMqAQAAAPg7S7/HKS4uToGBgaqtrXXZX1tbq4SEhE6PffbZZ7Vs2TLt2LFDo0eP7nCd3W6X3W6/LPUCAAAA6J8sveIUEhKicePGqbS0tG2f0+lUaWmpsrKyOjzumWee0ZIlS7R161alp6f7olQAAAAA/ZilV5wkadGiRcrLy1N6eroyMjL0/PPPq6mpSTNnzpQkPfTQQxoyZIiWLl0qSXr66af15JNP6pVXXlFKSkrbvVARERGKiIiw7H0AAAAA6LssD07333+/Tpw4oSeffFI1NTUaM2aMtm7d2vbAiK+++koBAf93YayoqEgtLS269957XX5PYWGhFi9e7MvSAQAAAPQTln+Pk6/xPU4AAAAAJD/6HicAAAAA8AcEJwAAAABww/J7nHztx08mNjQ0WFwJAAAAACv9mAm6cvdSvwtOjY2NkqTk5GSLKwEAAADQGzQ2Nio6OrrTNf3u4RBOp1PHjh1TZGSkbDab1eWooaFBycnJqq6u5mEVXkB/vYv+ehf99S76613017vor3fRX+/qTf01xqixsVFJSUkuT/JuT7+74hQQEKChQ4daXcYloqKiLB+cvoz+ehf99S76613017vor3fRX++iv97VW/rr7krTj3g4BAAAAAC4QXACAAAAADcIThaz2+0qLCyU3W63upQ+if56F/31LvrrXfTXu+ivd9Ff76K/3uWv/e13D4cAAAAAAE9xxQkAAAAA3CA4AQAAAIAbBCcAAAAAcIPgBAAAAABuEJy8bOXKlUpJSZHD4VBmZqb279/f6frNmzfruuuuk8Ph0A033KA333zTR5X6L096vH79etlsNpfN4XD4sFr/sXv3bt19991KSkqSzWbTli1b3B6zc+dOjR07Vna7XcOHD9f69eu9Xqe/8rS/O3fuvGR2bTabampqfFOwn1m6dKnGjx+vyMhIDR48WFOnTtWRI0fcHsc5uGu601/Ov11XVFSk0aNHt305aFZWlt56661Oj2F2u87T/jK7PbNs2TLZbDYtXLiw03X+MMMEJy969dVXtWjRIhUWFqqiokJpaWnKyclRXV1du+vfe+89TZs2TY888ogOHjyoqVOnaurUqTp06JCPK/cfnvZY+uFbqo8fP962HT161IcV+4+mpialpaVp5cqVXVr/5ZdfasqUKbr11ltVWVmphQsXatasWdq2bZuXK/VPnvb3R0eOHHGZ38GDB3upQv+2a9cu5efnq6ysTNu3b9f58+d1++23q6mpqcNjOAd3XXf6K3H+7aqhQ4dq2bJlKi8v1/vvv6/bbrtNP/vZz/TRRx+1u57Z9Yyn/ZWY3e46cOCAVq1apdGjR3e6zm9m2MBrMjIyTH5+ftvPra2tJikpySxdurTd9ffdd5+ZMmWKy77MzEzz6KOPerVOf+Zpj9etW2eio6N9VF3fIcmUlJR0uua3v/2tGTVqlMu++++/3+Tk5Hixsr6hK/195513jCTz3Xff+aSmvqaurs5IMrt27epwDefg7utKfzn/9kxMTIxZs2ZNu68xuz3XWX+Z3e5pbGw011xzjdm+fbuZNGmSWbBgQYdr/WWGueLkJS0tLSovL1d2dnbbvoCAAGVnZ2vv3r3tHrN3716X9ZKUk5PT4fr+rjs9lqQzZ87oyiuvVHJystv/YULXMb++MWbMGCUmJuqnP/2p9uzZY3U5fqO+vl6SFBsb2+EaZrj7utJfifNvd7S2tqq4uFhNTU3Kyspqdw2z231d6a/E7HZHfn6+pkyZcslstsdfZpjg5CUnT55Ua2ur4uPjXfbHx8d3eE9CTU2NR+v7u+70ODU1VWvXrtXf//53bdiwQU6nUxMnTtTXX3/ti5L7tI7mt6GhQd9//71FVfUdiYmJ+vOf/6zXX39dr7/+upKTk3XLLbeooqLC6tJ6PafTqYULF+qmm27S9ddf3+E6zsHd09X+cv71TFVVlSIiImS32zV37lyVlJRo5MiR7a5ldj3nSX+ZXc8VFxeroqJCS5cu7dJ6f5nhIKsLAHwpKyvL5X+UJk6cqBEjRmjVqlVasmSJhZUBnUtNTVVqamrbzxMnTtTnn3+u5cuX669//auFlfV++fn5OnTokN59912rS+mTutpfzr+eSU1NVWVlperr6/Xaa68pLy9Pu3bt6vAf9/CMJ/1ldj1TXV2tBQsWaPv27X3uIRoEJy+Ji4tTYGCgamtrXfbX1tYqISGh3WMSEhI8Wt/fdafHFwsODtaNN96ozz77zBsl9isdzW9UVJRCQ0Mtqqpvy8jIIAy4MW/ePP3jH//Q7t27NXTo0E7Xcg72nCf9vRjn386FhIRo+PDhkqRx48bpwIED+tOf/qRVq1ZdspbZ9Zwn/b0Ys9u58vJy1dXVaezYsW37WltbtXv3bq1YsULNzc0KDAx0OcZfZpiP6nlJSEiIxo0bp9LS0rZ9TqdTpaWlHX6GNisry2W9JG3fvr3Tz9z2Z93p8cVaW1tVVVWlxMREb5XZbzC/vldZWcnsdsAYo3nz5qmkpERvv/22rrrqKrfHMMNd153+Xozzr2ecTqeam5vbfY3Z7bnO+nsxZrdzkydPVlVVlSorK9u29PR05ebmqrKy8pLQJPnRDFv9dIq+rLi42NjtdrN+/Xrz8ccfmzlz5pgBAwaYmpoaY4wx06dPNwUFBW3r9+zZY4KCgsyzzz5rDh8+bAoLC01wcLCpqqqy6i30ep72+KmnnjLbtm0zn3/+uSkvLzcPPPCAcTgc5qOPPrLqLfRajY2N5uDBg+bgwYNGknnuuefMwYMHzdGjR40xxhQUFJjp06e3rf/iiy9MWFiY+c1vfmMOHz5sVq5caQIDA83WrVutegu9mqf9Xb58udmyZYv59NNPTVVVlVmwYIEJCAgwO3bssOot9Gq/+tWvTHR0tNm5c6c5fvx423b27Nm2NZyDu687/eX823UFBQVm165d5ssvvzQffvihKSgoMDabzfzrX/8yxjC7PeVpf5ndnrv4qXr+OsMEJy974YUXzBVXXGFCQkJMRkaGKSsra3tt0qRJJi8vz2X93/72N3PttdeakJAQM2rUKPPPf/7TxxX7H096vHDhwra18fHx5q677jIVFRUWVN37/fj464u3H/uZl5dnJk2adMkxY8aMMSEhIWbYsGFm3bp1Pq/bX3ja36efftpcffXVxuFwmNjYWHPLLbeYt99+25ri/UB7vZXkMpOcg7uvO/3l/Nt1Dz/8sLnyyitNSEiIGTRokJk8eXLbP+qNYXZ7ytP+Mrs9d3Fw8tcZthljjO+ubwEAAACA/+EeJwAAAABwg+AEAAAAAG4QnAAAAADADYITAAAAALhBcAIAAAAANwhOAAAAAOAGwQkAAAAA3CA4AQAAAIAbBCcAADxgs9m0ZcsWq8sAAPgYwQkA4DdmzJghm812yXbHHXdYXRoAoI8LsroAAAA8cccdd2jdunUu++x2u0XVAAD6C644AQD8it1uV0JCgssWExMj6YeP0RUVFenOO+9UaGiohg0bptdee83l+KqqKt12220KDQ3VwIEDNWfOHJ05c8Zlzdq1azVq1CjZ7XYlJiZq3rx5Lq+fPHlSP//5zxUWFqZrrrlGb7zxhnffNADAcgQnAECf8oc//EH33HOPPvjgA+Xm5uqBBx7Q4cOHJUlNTU3KyclRTEyMDhw4oM2bN2vHjh0uwaioqEj5+fmaM2eOqqqq9MYbb2j48OEuf8dTTz2l++67Tx9++KHuuusu5ebm6tSpUz59nwAA37IZY4zVRQAA0BUzZszQhg0b5HA4XPY/8cQTeuKJJ2Sz2TR37lwVFRW1vTZhwgSNHTtWL774olavXq3HH39c1dXVCg8PlyS9+eabuvvuu3Xs2DHFx8dryJAhmjlzpv74xz+2W4PNZtPvf/97LVmyRNIPYSwiIkJvvfUW91oBQB/GPU4AAL9y6623ugQjSYqNjW37c1ZWlstrWVlZqqyslCQdPnxYaWlpbaFJkm666SY5nU4dOXJENptNx44d0+TJkzutYfTo0W1/Dg8PV1RUlOrq6rr7lgAAfoDgBADwK+Hh4Zd8dO5yCQ0N7dK64OBgl59tNpucTqc3SgIA9BLc4wQA6FPKysou+XnEiBGSpBEjRuiDDz5QU1NT2+t79uxRQECAUlNTFRkZqZSUFJWWlvq0ZgBA78cVJwCAX2lublZNTY3LvqCgIMXFxUmSNm/erPT0dP3kJz/Rxo0btX//fr300kuSpNzcXBUWFiovL0+LFy/WiRMnNH/+fE2fPl3x8fGSpMWLF2vu3LkaPHiw7rzzTjU2NmrPnj2aP3++b98oAKBXITgBAPzK1q1blZiY6LIvNTVVn3zyiaQfnnhXXFysxx57TImJidq0aZNGjhwpSQoLC9O2bdu0YMECjR8/XmFhYbrnnnv03HPPtf2uvLw8nTt3TsuXL9evf/1rxcXF6d577/XdGwQA9Eo8VQ8A0GfYbDaVlJRo6tSpVpcCAOhjuMcJAAAAANwgOAEAAACAG9zjBADoM/j0OQDAW7jiBAAAAABuEJwAAAAAwA2CEwAAAAC4QXACAAAAADcITgAAAADgBsEJAAAAANwgOAEAAACAGwQnAAAAAHDjfwGw6so5obcpTQAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "### Train and test on FASHION MNIST dataset.\n",
        "\n",
        "# Check if GPU is available.\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "# Define a transform to normalize the data.\n",
        "transform = transforms.Compose([\n",
        "    transforms.Resize((28, 28)),\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize((0.2860,), (0.3530,))\n",
        "])\n",
        "\n",
        "# Download and load the training data.\n",
        "train_set = datasets.FashionMNIST(root='./data', train=True, download=True, transform=transform)\n",
        "train_loader = torch.utils.data.DataLoader(train_set, batch_size=64, shuffle=True)\n",
        "\n",
        "# Download and load the test data\n",
        "test_set = datasets.FashionMNIST(root='./data', train=False, download=True, transform=transform)\n",
        "test_loader = torch.utils.data.DataLoader(test_set, batch_size=64, shuffle=False)\n",
        "\n",
        "# Define the model.\n",
        "model = LightViT(image_dim=(64, 1, 28, 28), n_patches=7, d=8)\n",
        "model.to(device)\n",
        "\n",
        "# Train and test the model\n",
        "train_test_model(model, device, train_loader, test_loader, transform)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 661
        },
        "id": "TrRuT1uj6HqU",
        "outputId": "231ec291-5892-4716-fc87-bf4943c1c8e9"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1, Loss: 0.9256\n",
            "Test Loss: 0.8003, Accuracy: 0.7006\n",
            "Epoch 2, Loss: 0.8231\n",
            "Test Loss: 0.6997, Accuracy: 0.7422\n",
            "Epoch 3, Loss: 0.3893\n",
            "Test Loss: 0.6748, Accuracy: 0.7535\n",
            "Epoch 4, Loss: 0.4906\n",
            "Test Loss: 0.6165, Accuracy: 0.7755\n",
            "Epoch 5, Loss: 0.4587\n",
            "Test Loss: 0.5951, Accuracy: 0.7833\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x500 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}