{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# VQ-VAE (Vector Quantized Variational Auto-Encoder)\n",
        "\n",
        "Lecture 12 | CMU ANLP Spring 2026 | Instructor: Sean Welleck\n",
        "\n",
        "VQ-VAE learns discrete representations of images using a learned codebook of vectors.\n",
        "\n",
        "The model has three parts:\n",
        "1. Encoder: maps images to continuous vectors\n",
        "2. Vector Quantizer: replaces each vector with the nearest codebook vector  \n",
        "3. Decoder: reconstructs images from the quantized codes\n",
        "\n",
        "The quantization creates a discrete representation, which then lets us use autoregressive models for generation."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "id": "e4470586",
      "metadata": {},
      "outputs": [],
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "from torchvision import datasets, transforms"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "47a3fa8b",
      "metadata": {},
      "source": [
        "## 1. Vector Quantizer\n",
        "\n",
        "The Vector Quantizer learns a codebook of K embedding vectors, each of dimension D.\n",
        "\n",
        "The quantizer takes encoder output $z_e$ of shape [B, D, H, W] and for each spatial location, finds the nearest codebook vector. It computes distances between each latent vector and all K codebook vectors, selects the closest one, and outputs a quantized representation $z_q$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "id": "dd55be94",
      "metadata": {},
      "outputs": [],
      "source": [
        "import torch.nn as nn\n",
        "import torch.nn.functional as F"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "id": "04c7504d",
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Input shape: torch.Size([4, 32, 7, 7])\n",
            "Output shape: torch.Size([4, 32, 7, 7])\n",
            "Indices shape: torch.Size([4, 7, 7])\n",
            "Indices range: [0, 126]\n",
            "VQ loss: 1.2562\n"
          ]
        }
      ],
      "source": [
        "class VectorQuantizer(nn.Module):\n",
        "    def __init__(self, num_embeddings=128, embedding_dim=32, beta=0.25):\n",
        "        super().__init__()\n",
        "        self.codebook = nn.Embedding(num_embeddings, embedding_dim)\n",
        "        nn.init.uniform_(self.codebook.weight, -1/num_embeddings, 1/num_embeddings)\n",
        "        self.beta = beta\n",
        "        \n",
        "    def forward(self, z_e):\n",
        "        B, D, H, W = z_e.shape\n",
        "        # Reshape: [B, D, H, W] → [B*H*W, D]\n",
        "        flat = z_e.permute(0, 2, 3, 1).reshape(-1, D)\n",
        "        \n",
        "        # Compute L2 distances to all codebook vectors\n",
        "        # ||a - b||^2 = ||a||^2 - 2<a,b> + ||b||^2\n",
        "        distances = (\n",
        "            flat.pow(2).sum(1, keepdim=True)\n",
        "            - 2 * flat @ self.codebook.weight.T\n",
        "            + self.codebook.weight.pow(2).sum(1)\n",
        "        )\n",
        "        \n",
        "        # Find nearest codebook vector for each position\n",
        "        indices = distances.argmin(dim=1)  # [B*H*W]\n",
        "        \n",
        "        # Look up the quantized vectors\n",
        "        z_q = self.codebook(indices).view(B, H, W, D).permute(0, 3, 1, 2)  # [B, D, H, W]\n",
        "        \n",
        "        # VQ losses\n",
        "        # Codebook loss: move codebook vectors toward encoder outputs\n",
        "        codebook_loss = F.mse_loss(z_e, z_q.detach())\n",
        "        \n",
        "        # Commitment loss: encourage encoder to commit to codebook\n",
        "        commitment_loss = self.beta * F.mse_loss(z_e.detach(), z_q)\n",
        "        \n",
        "        # Straight-through estimator: copy gradients from z_q to z_e\n",
        "        z_q = z_e + (z_q - z_e).detach()\n",
        "        \n",
        "        return z_q, indices.view(B, H, W), codebook_loss + commitment_loss\n",
        "\n",
        "# Test the quantizer\n",
        "vq = VectorQuantizer(num_embeddings=128, embedding_dim=32)\n",
        "test_input = torch.randn(4, 32, 7, 7)\n",
        "z_q, indices, loss = vq(test_input)\n",
        "\n",
        "print(f\"Input shape: {test_input.shape}\")\n",
        "print(f\"Output shape: {z_q.shape}\")\n",
        "print(f\"Indices shape: {indices.shape}\")\n",
        "print(f\"Indices range: [{indices.min()}, {indices.max()}]\")\n",
        "print(f\"VQ loss: {loss.item():.4f}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7ecda01e",
      "metadata": {},
      "source": [
        "## 2. Encoder and Decoder\n",
        "\n",
        "The encoder and decoder are simple convolutional networks. The encoder takes 28x28 MNIST images and applies 2 conv layers with stride 2 (downsampling), producing a 7x7 spatial grid with 32 channels (49 vectors to quantize). The decoder takes quantized latent codes and applies 2 transposed conv layers (upsampling) to reconstruct 28x28 images."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "id": "1b3a1366",
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Input: torch.Size([4, 1, 28, 28])\n",
            "Encoded: torch.Size([4, 32, 7, 7])\n",
            "Reconstructed: torch.Size([4, 1, 28, 28])\n"
          ]
        }
      ],
      "source": [
        "class Encoder(nn.Module):\n",
        "    def __init__(self, embedding_dim=32):\n",
        "        super().__init__()\n",
        "        self.net = nn.Sequential(\n",
        "            nn.Conv2d(1, embedding_dim, kernel_size=3, stride=2, padding=1),\n",
        "            nn.ReLU(),\n",
        "            nn.Conv2d(embedding_dim, embedding_dim, kernel_size=3, stride=2, padding=1),\n",
        "        )\n",
        "    \n",
        "    def forward(self, x):\n",
        "        return self.net(x)\n",
        "\n",
        "class Decoder(nn.Module):\n",
        "    def __init__(self, embedding_dim=32):\n",
        "        super().__init__()\n",
        "        self.net = nn.Sequential(\n",
        "            nn.ConvTranspose2d(embedding_dim, embedding_dim, kernel_size=4, stride=2, padding=1),\n",
        "            nn.ReLU(),\n",
        "            nn.ConvTranspose2d(embedding_dim, 1, kernel_size=4, stride=2, padding=1),\n",
        "            nn.Sigmoid()  \n",
        "        )\n",
        "    \n",
        "    def forward(self, z):\n",
        "        return self.net(z)\n",
        "\n",
        "\n",
        "# Test the encoder/decoder\n",
        "encoder = Encoder(embedding_dim=32)\n",
        "decoder = Decoder(embedding_dim=32)\n",
        "\n",
        "test_img = torch.randn(4, 1, 28, 28)  # Batch of 4 MNIST-sized images\n",
        "z_e = encoder(test_img)\n",
        "recon = decoder(z_e)\n",
        "\n",
        "print(f\"Input: {test_img.shape}\")\n",
        "print(f\"Encoded: {z_e.shape}\")\n",
        "print(f\"Reconstructed: {recon.shape}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "fb37d664",
      "metadata": {},
      "source": [
        "## 3. Load MNIST Data\n",
        "\n",
        "We train on MNIST handwritten digits (28x28 grayscale images)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "id": "cf0daf75",
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Dataset size: 60000\n",
            "Number of batches: 469\n"
          ]
        }
      ],
      "source": [
        "# Load MNIST dataset\n",
        "train_dataset = datasets.MNIST(\n",
        "    root=\".\", \n",
        "    train=True, \n",
        "    download=True,\n",
        "    transform=transforms.ToTensor()\n",
        ")\n",
        "\n",
        "# Create data loader\n",
        "train_loader = torch.utils.data.DataLoader(\n",
        "    train_dataset, \n",
        "    batch_size=128, \n",
        "    shuffle=True\n",
        ")\n",
        "\n",
        "print(f\"Dataset size: {len(train_dataset)}\")\n",
        "print(f\"Number of batches: {len(train_loader)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "376cd359",
      "metadata": {},
      "source": [
        "## 4. Training the VQ-VAE\n",
        "\n",
        "We train for a few epochs and track reconstruction loss (how well we reconstruct the input), VQ loss (codebook + commitment losses), and codebook usage (how many of our K=128 codebook vectors are actually used)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "id": "51ccd7f8",
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch [1/3], Batch [100/469], Recon Loss: 0.1286, VQ Loss: 0.1485\n",
            "Epoch [1/3], Batch [200/469], Recon Loss: 0.0802, VQ Loss: 0.0803\n",
            "Epoch [1/3], Batch [300/469], Recon Loss: 0.0581, VQ Loss: 0.0546\n",
            "Epoch [1/3], Batch [400/469], Recon Loss: 0.0460, VQ Loss: 0.0416\n",
            "\n",
            "======================================================================\n",
            "Epoch 1 Summary:\n",
            "  Reconstruction Loss: 0.0404\n",
            "  VQ Loss: 0.0359\n",
            "  Codebook Usage: 81/128 (63.3%)\n",
            "======================================================================\n",
            "\n",
            "Epoch [2/3], Batch [100/469], Recon Loss: 0.0072, VQ Loss: 0.0029\n",
            "Epoch [2/3], Batch [200/469], Recon Loss: 0.0069, VQ Loss: 0.0030\n",
            "Epoch [2/3], Batch [300/469], Recon Loss: 0.0067, VQ Loss: 0.0031\n",
            "Epoch [2/3], Batch [400/469], Recon Loss: 0.0065, VQ Loss: 0.0031\n",
            "\n",
            "======================================================================\n",
            "Epoch 2 Summary:\n",
            "  Reconstruction Loss: 0.0064\n",
            "  VQ Loss: 0.0032\n",
            "  Codebook Usage: 71/128 (55.5%)\n",
            "======================================================================\n",
            "\n",
            "Epoch [3/3], Batch [100/469], Recon Loss: 0.0057, VQ Loss: 0.0034\n",
            "Epoch [3/3], Batch [200/469], Recon Loss: 0.0056, VQ Loss: 0.0034\n",
            "Epoch [3/3], Batch [300/469], Recon Loss: 0.0055, VQ Loss: 0.0034\n",
            "Epoch [3/3], Batch [400/469], Recon Loss: 0.0055, VQ Loss: 0.0034\n",
            "\n",
            "======================================================================\n",
            "Epoch 3 Summary:\n",
            "  Reconstruction Loss: 0.0054\n",
            "  VQ Loss: 0.0034\n",
            "  Codebook Usage: 76/128 (59.4%)\n",
            "======================================================================\n",
            "\n"
          ]
        }
      ],
      "source": [
        "# Initialize model components\n",
        "embedding_dim = 32\n",
        "num_embeddings = 128\n",
        "\n",
        "encoder = Encoder(embedding_dim=embedding_dim)\n",
        "quantizer = VectorQuantizer(num_embeddings=num_embeddings, embedding_dim=embedding_dim)\n",
        "decoder = Decoder(embedding_dim=embedding_dim)\n",
        "\n",
        "# Optimizer\n",
        "params = list(encoder.parameters()) + list(quantizer.parameters()) + list(decoder.parameters())\n",
        "optimizer = torch.optim.Adam(params, lr=1e-3)\n",
        "\n",
        "# Training loop\n",
        "num_epochs = 3\n",
        "train_losses = []\n",
        "\n",
        "for epoch in range(num_epochs):\n",
        "    total_recon_loss = 0\n",
        "    total_vq_loss = 0\n",
        "    all_indices = []\n",
        "    \n",
        "    for batch_idx, (images, _) in enumerate(train_loader):\n",
        "        # Forward pass\n",
        "        z_e = encoder(images)\n",
        "        z_q, indices, vq_loss = quantizer(z_e)\n",
        "        reconstructed = decoder(z_q)\n",
        "        \n",
        "        # Losses\n",
        "        recon_loss = F.mse_loss(reconstructed, images)\n",
        "        loss = recon_loss + vq_loss\n",
        "        \n",
        "        # Backward pass\n",
        "        optimizer.zero_grad()\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        \n",
        "        # Track statistics\n",
        "        total_recon_loss += recon_loss.item()\n",
        "        total_vq_loss += vq_loss.item()\n",
        "        all_indices.append(indices.flatten())\n",
        "        \n",
        "        if (batch_idx + 1) % 100 == 0:\n",
        "            avg_recon = total_recon_loss / (batch_idx + 1)\n",
        "            avg_vq = total_vq_loss / (batch_idx + 1)\n",
        "            print(f\"Epoch [{epoch+1}/{num_epochs}], Batch [{batch_idx+1}/{len(train_loader)}], \"\n",
        "                  f\"Recon Loss: {avg_recon:.4f}, VQ Loss: {avg_vq:.4f}\")\n",
        "    \n",
        "    # Epoch statistics\n",
        "    avg_recon = total_recon_loss / len(train_loader)\n",
        "    avg_vq = total_vq_loss / len(train_loader)\n",
        "    \n",
        "    # Calculate codebook usage\n",
        "    all_indices = torch.cat(all_indices)\n",
        "    unique_codes = torch.unique(all_indices).numel()\n",
        "    usage_percent = 100 * unique_codes / num_embeddings\n",
        "    \n",
        "    print(f\"\\n{'='*70}\")\n",
        "    print(f\"Epoch {epoch+1} Summary:\")\n",
        "    print(f\"  Reconstruction Loss: {avg_recon:.4f}\")\n",
        "    print(f\"  VQ Loss: {avg_vq:.4f}\")\n",
        "    print(f\"  Codebook Usage: {unique_codes}/{num_embeddings} ({usage_percent:.1f}%)\")\n",
        "    print(f\"{'='*70}\\n\")\n",
        "    \n",
        "    train_losses.append((avg_recon, avg_vq))\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c1870e5d",
      "metadata": {},
      "source": [
        "## 4.5 Visualizing the Vector Quantization Lookup\n",
        "\n",
        "The figure shows what happens during quantization. The left shows the original image. The right shows discrete codebook indices after quantization. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "id": "e62ff6b5",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1200x600 with 3 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Visualize the quantization process for a single image\n",
        "with torch.no_grad():\n",
        "    sample_img, _ = next(iter(train_loader))\n",
        "    sample_img = sample_img[0:1] \n",
        "    \n",
        "    z_e = encoder(sample_img)\n",
        "    z_q, codes, _ = quantizer(z_e)\n",
        "\n",
        "fig, axes = plt.subplots(1, 2, figsize=(12, 6))\n",
        "\n",
        "# 1. Original image\n",
        "axes[0].imshow(sample_img[0, 0], cmap='gray')\n",
        "axes[0].set_title('Original Image (28×28)', fontsize=14, fontweight='bold')\n",
        "axes[0].axis('off')\n",
        "\n",
        "# 2. After quantization \n",
        "im = axes[1].imshow(codes[0], cmap='tab20', interpolation='nearest', vmin=0, vmax=127)\n",
        "axes[1].set_title('After Quantization (7×7)\\nDiscrete Code Indices\\n(integers 0-127)', \n",
        "                 fontsize=14, fontweight='bold')\n",
        "for i in range(7):\n",
        "    for j in range(7):\n",
        "        axes[1].text(j, i, str(codes[0, i, j].item()), \n",
        "                    ha='center', va='center', color='white', \n",
        "                    fontsize=11, fontweight='bold',\n",
        "                    bbox=dict(boxstyle='round,pad=0.3', facecolor='black', alpha=0.5))\n",
        "axes[1].set_xticks(range(7))\n",
        "axes[1].set_yticks(range(7))\n",
        "plt.colorbar(im, ax=axes[1], fraction=0.046, ticks=range(0, 128, 16))\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "5e4f7c7e",
      "metadata": {},
      "source": [
        "## 5. Visualize Reconstructions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "id": "cb471047",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1600x400 with 16 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Mean Squared Error: 0.0052\n"
          ]
        }
      ],
      "source": [
        "# Get a batch of test images\n",
        "encoder.eval()\n",
        "quantizer.eval()\n",
        "decoder.eval()\n",
        "\n",
        "with torch.no_grad():\n",
        "    test_images, _ = next(iter(train_loader))\n",
        "    test_images = test_images[:8]  # Use first 8 images\n",
        "    \n",
        "    z_e = encoder(test_images)\n",
        "    z_q, codes, _ = quantizer(z_e)\n",
        "    reconstructions = decoder(z_q)\n",
        "\n",
        "# Visualize\n",
        "fig, axes = plt.subplots(2, 8, figsize=(16, 4))\n",
        "for i in range(8):\n",
        "    # Original\n",
        "    axes[0, i].imshow(test_images[i, 0], cmap='gray')\n",
        "    axes[0, i].axis('off')\n",
        "    if i == 0:\n",
        "        axes[0, i].set_title('Original', fontsize=12, fontweight='bold')\n",
        "    \n",
        "    # Reconstruction\n",
        "    axes[1, i].imshow(reconstructions[i, 0], cmap='gray')\n",
        "    axes[1, i].axis('off')\n",
        "    if i == 0:\n",
        "        axes[1, i].set_title('Reconstructed', fontsize=12, fontweight='bold')\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()\n",
        "\n",
        "# Show reconstruction error\n",
        "mse = F.mse_loss(reconstructions, test_images)\n",
        "print(f\"\\nMean Squared Error: {mse.item():.4f}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4d1738b2",
      "metadata": {},
      "source": [
        "## 6. Codebook Usage\n",
        "\n",
        "We visualize which codebook vectors are used most frequently."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "id": "edfc59c9",
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAABW0AAAGGCAYAAAAAW6PhAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAphNJREFUeJzs3Qd4U9X7wPG3LXvvvfeWvWSDDEFBUFmyhyxlyJaNgDgYIj8QEVABEVRAhuwlspfIlL03sjfN/3mP3vyTNl20adL2+3metMm9JzcnJzfJuW/OfY+PzWazCQAAAAAAAADAK/h6ugIAAAAAAAAAgP9H0BYAAAAAAAAAvAhBWwAAAAAAAADwIgRtAQAAAAAAAMCLELQFAAAAAAAAAC9C0BYAAAAAAAAAvAhBWwAAAAAAAADwIgRtAQAAAAAAAMCLELQFAAAAAAAAAC9C0BaIQmbNmiU+Pj7mUqVKlXBty9qOXk6fPi3eoHXr1vY6DRs2zNPViZbeeecd075JkyaVW7duebo6CAN9z1vvD/0sQMg2bNhgb7Ns2bLZlz979kxy5MhhlleqVMmjdQQAICJEVt8+qO/WmIw+GgB3IWgLvAB/f39ZvHixvP3226azEj9+fEmSJInkz5/fBMWWLFkiNpvN09WMsRw7k646ro7Bb73EFLt27ZK5c+ea6126dJFkyZLZ1zm2R1AXVx3zAwcOSLNmzSRDhgwSJ04c819vHzx4MNi6lClTxmzTKrdp0ybp3LmzlCxZUuLGjRvijxNavlevXmY7GTNmNPfR92Dp0qVl/Pjx8uTJk0D3efr0qUyaNEkqVKggKVKkkFixYkmiRImkUKFC0rt3b7ly5UqY2xRRk772ffv2Ndd///13WbhwoaerBABwM/rvoe9H6+AJvSxatMjT1QmTmzdvyscffyyVK1eW1KlTm75punTppFSpUjJo0CA5evSoRFWOffKAgWE91nFcr68hgOghlqcrAEQ1GtjRzp4GjRw9evRIjhw5Yi5z5syRf/75xykoBnjaiBEjzMGIduY0aBtWsWPHdrr922+/yRtvvCGPHz+2L7t06ZL88MMPJgj266+/yiuvvBJoO+fPn5edO3dKnjx5pGDBgmbZL7/8IlOnTg11XUaPHi0rV650WqaBWt2uXvSgbM2aNSY4Z2nSpIl5HEf37983gWO9zJ8/X/bu3SspU6YMdT0QdbVq1Ur69Okj9+7dk+HDh5t9GQAQPdF/Dz0N+On3ovVd2aBBA6f1xYoVMz94qnjx4om3WLZsmbRs2dIEbgO+9nrRwQs62CCqBaIBxGwEbYEwePDggdSqVUv+/PNPc9vX19ec0l+vXj1zuvm5c+dMICtgYAjwtDNnzpjOrNKRppkzZ3Zab3W+A9JA54ULF8x1Pdix6EGNdoytgK1ef+utt2TBggXy3XffmYMgHbXy999/m/eGI+0sa/C4YcOG9mVp0qSR119/3Yy0/euvv8x2QqIjbPVg4uWXXzYB2y+++ELWr19v1m3cuNGMKtZ6qePHjzu9Lzt16iSNGjWS/fv3mxGXz58/N+9fDdzqiF9EfzrCSg9EZ8+ebT7Tt23bJmXLlvV0tQAAEYz+e8TSNtO+pLcFmvXHVz2rSqVPn166d+8uJUqUMCmRtG9pnW0GAFGKDUCojR49Ws+Zsl9++OEHl+WOHj1qe/z4sf22v7+/bebMmbYqVarYkidPbosVK5Ytbdq0ttdff922Zs2aQPd/+vSpbcSIEbasWbPa4saNaytUqJC5v16sx65cuXKg+82bN8/2yiuv2FKmTGmLHTu2LV26dLYmTZrY/vzzz0BlHZ/HkSNHbIMHD7Y/XoECBWzTp093+dwWL15sq1Onji116tTmeehj6WMuWLDAZfl9+/bZWrRoYcuSJYstTpw4tsSJE9tKlSpl+/TTT22PHj1yKtuqVSt7nYYOHWpfrs/b19fXLI8XL55t2bJltuCsX7/e6fmdOnXKab1jOwb8GNy6dat5XbTt9PlpfXPmzGlr2LChbfbs2fZy169ft7377ru20qVLm7Lablo3Ldu+fXvbiRMnAtVL79OuXTvTZgkSJLBVqlTJ9scffwT5vNX9+/dtY8eONW2mddE2zJUrl61nz562q1ev2kJL29t6jI8//jhU91m7dq39Pvr8Ll26ZF/3xRdf2NflyZPH7OPq+fPntty5c9vXffnll4G2W7VqVbNux44dLh9X2yC4/VytWrXK6T2mHjx4YEuTJo39vp07d7av27lzp9NrfvfuXfu6ggUL2pdPmDDBFlqLFi2y1a1b17yX9f2mr2v58uVts2bNcip3+fJlW+/evW358+e3xY8f3+wnefPmtfXo0cN24cKFQNs9efKkrVGjRrYkSZKY17xevXq2w4cPm7aw6qn7sKMbN27YBg0aZCtSpIgtYcKE5jH0faxt6fhclb7vhg8fbsrqfqh11+dQtmxZ23vvvef0OgcluH1WP0esdfpetOhzaNasmS1TpkzmMfWxtay24cSJEwM9xsqVK8170WrfVKlS2V577TXbpk2bXNZp8uTJpl2t98hnn33mtA/rYwWkn+HW+u7du4f4vAEAMaP/HlyfO6jvQMf+i5bR/mrx4sVNHypHjhy2SZMmmXJ///23+T7T7/ikSZPaGjduHKhPF9R3qfZpg+rDBtX31cetXbu2LVu2bOYxtX+r/fiaNWvafvnllyC3HfBifY869rOtZXosYS3T5/Tw4UOnuulxjbW+adOm9uXPnj2zTZ061VahQgVbsmTJzPe9HjNoX1r7Q6Ghfc98+fI51Un7Xq789ddfXt1HC47jaxHwMQK+do77zPnz520dO3a0Zc+e3fSR9PG1L1ajRg3bkCFDnLajdapWrZotc+bMpq76eqRPn97WoEEDp206vn4fffSR2bd0P9c+9TfffBOhx6xATEfQFggD/RK3voD0Cy009MtMv+iC6wSNGjXK6T4tW7Z0Wa5YsWIuvwC1s6LBkKC2r1+iv/76q9NjBLVdx4t2ch1pQCe456EdAkfaKdYv4qDKlyhRwnbnzp1gO8HfffedPWCbKFEi27p160Js8xcN2mqnS9sqqPrWqlXLqWxwbaHBecfArQZfNfju6rVxDBo6dv6vXbvm8j7WJWPGjKHu0Gqn0lVHLjivvvqq/T5t27Z1Wue4T7du3dppnePrqMHugIFrPz8/0xkMSmiCtkEpWbKk/b59+vSxL9eDB+10Wus6depkfjD5/PPPTX2s/ev06dMhPoYGqPU5B/W61K9f31720KFDToHkgBcNRDp2UPUAQTuurvYn7RC76qwfO3bMdL6Degzdh/SAIaTPF+uiP1xEdNBWX/cUKVIE+Zj62eqoX79+QZbVz4MpU6Y4ldeDDldlHT/bXAVt9f1jrdeDKQBA9PMi/ffwBm31R3yr/+p40e83V9+Hjn3MiA7alilTJtjv/fHjx7vcdliCturll1+2L//pp5+c6uYYVNUfVK0f260f8l1dNIi7ffv2EF8r7bc43k+PHULDG/towXmRoO2TJ0/MvhjU4+txiCP9oTyosj4+Praff/7ZqXybNm1cltUfKyLqmBWI6ZiIDAglzX3pmLy+Zs2aobrf5MmT7bmTNCeo5hVdvny5tG/f3l7mww8/lB07dthP69bTyy1aTstrGeu0roC++uor+yk/qVKlMo+5evVqk3Bf85fqKewtWrQwp7S7cvLkSfnyyy/NBAx169a1Lx8yZIg5rV5pflKdxMnSs2dPU69+/frZJ/OaNm2a/bT2y5cvS7t27eynKdWpU8ds/3//+5/9dPndu3dL//79g2w7zS2mp6/pxBF6n1WrVknVqlXFXZYuXWo/3V9P9V+xYoV5jtq+zZs3N21rSZ48uXktf/zxR1NOT8vS56cpAZS29eeff24vr9c1j5bSSRE0J6s+3quvvhrkpF1du3a136do0aImV6yevqen9StNW6DpAUJDTwuz5M6dO8Tyhw8fNo+l9PX94IMPAu0zFp3gwZHj7RMnTjit0/1IUxG4I3+opmLYt2+f/bamW7BozjV9LYsXL25ua/7cGjVqmOel9dHrW7dulaxZs4b4OF9//bXTBBBvvvmm/PTTT+a56XtOJ76w6P5w9epVe7vra6jvkQIFCphl169fN/uW7uNK3+f63lG6z+v7Rbf70ksvBTkTtD6G5glW+v7QfMK6L+okHEr3oR49etjL//zzz/btz5w5U9atWyfz5s0zE47oRB162mhE07QVVo45raPu+5qTeMaMGeYzTlNdWHS/Gzt2rD2FwSeffGI+z/Q9pBPOaVu999575vVWp06dklGjRtnvrykPdPuffvqpHDp0KNh6Zc+e3Z73WN+H1usAAIjZ/ffw0v6P9iU1NZXVb1P6/ZY4cWLTf3TsV+t3orsmydK+4jfffGO+G7W/qt+p2u/X71Sl3/+aQkBTCmi6rDZt2tjvq/13XaYX7esER/v9jn14y549e0zOYOt71+rL6+Naaa10ufZJtK+vKazUrVu3pGnTpqZuwdHjCUehfY29sY8W0fTY0eqLFylSxDy+vv7ffvutSR+RK1cup/JaF12n+63uK7pf6jGL0rjx4MGD7WV1n9DXzKL7jfa19dhO54hwxzErECN5OmoMRBV6aonjL4Fff/11qO7nONJLR6oGNSqwS5cuZlm3bt2cRok5evvtt13+aqkjVh1HF/7+++/2i+Pj6+lHFsfnoqcVW/RXbz1lylo3btw4s/yNN96wL9NTuhy9+eab9nU6OlPp6c7WMt2e42lSesq8tU5PL9LRyAFHLmg6AGsEpP7SvWfPHltovehI22nTptmXffDBB7YzZ87YT/t3ZenSpebUbiuVgqtfmS2OI2bff/99+3I9DS9DhgyBRmz8888/9uevl7lz59pfU31+jiOY9ZS0kOip6Fb5gKesuaKnpQV8TR05/mof8NQqTbVhrdNyrkb8btiwIUJH2ur703EkTcBR39aoSj31ytXIF20ffR7Bvd6u3rf6vgiKjs5wfIzdu3fb1x04cMBpnaaK0NEHekqhtcwxZYCOwtDT9gKOsNDT/Kxluk9oSgFrP9FRLo7rrFPwrP1N/2t6jnv37tnCKqwjbTWdhbVMR1joyBPrfR+QnnZoldXUKo6fZ46jv/v372/KaxoEa5mOEHFMm9G3b99gR9oqx1E2YUk5AgCIvv338I601e9YTXem9DvesQ7Lly+338fxbCvHEYYROdL27Nmz5jhD+0mOfQnHy/79+10+D32uAQU10lb7E5oywBoxqX1Z1atXL3v5kSNHmmXa3wp4vOH4fe94dtSKFSuCfa309HzH52K1e3C8tY8WnBcZaaupOKxl1atXtx08eNCMvg2KrtczsjSVQlBnH1pnSToes7700ktBHhuG95gViOkYaQuEUsCZZG/cuBGq+1m/LKuASfsdb1vldMIkS7ly5ZzK64RLrjiOJtPRZRUrVrRfHH/ptEZtBuRYDx3Zpkn7LceOHXuh5+FYXieXcpxd1rH8nTt35OLFi4HqtHPnTjMCUulIZZ2pNrQCjhT8t5/j+rY1SljVr1/fPkpUR/XpqMuECROa0Zm9e/c2E1VYdISgTmChv0Trr+6uRgE4/kpstWPA11FH3ZYuXTrQfXUUofX8VbNmzeyvqf5Sb41gDu51DUrA9ghIRx18//339tv63APSdrFYo5Nd3U6UKJH9+r1798yv6ToSVZ9HRNHnrxNIWSNUtK109IMjHa2h7ycdUaojJnTEidZH75s3b14zSYmOnJ44cWKIj+f4fnOcTC0gx/eAvq+sUb6qYMGCTp8pWvbatWty+/Ztl+//FClSSL58+YKti+4TOtGKtZ/oCGDHdVb7WCNY9H2n+6K+RpkyZTL7v478cQetjz5npSMsdERLggQJpFChQtKlSxen5+F4XfdDx88zHcERcL93/MzUzy59T4X0mRmW9wMAIOb138NL+3bWmRwpU6Z0Wuf4/e54Fpd1RkpE0j6q9sO1X6T9gIcPH7osFxEjG7Vv2LhxY3tfUEfmap/L6ltYE8Ap7fPoxdKrVy+n7/tLly6Fup/7Iq+xt/bRguN4zBLcsY3jsZCOpNWzydTatWvNc9Pnq31ffS10ElbHs/J0v9UzPvUspoD9+4D7iuOxTfny5Z3KBDVRXXiPWYGYiKAtEIaOiH7BWdasWSNRjQapogo/Pz/7dT2F/e7du6G+r5525khPb3Lk2Em0UjWoNGnSmFO4NHj3yiuvSJYsWeTRo0emE6FBXO1QaJBZffzxx/b71a5d25wepacJjR8/3r7c8VRrx46W4/XIel0dT9kP6aBAT5mzOmoaBHOVkiJHjhz269apYhbHjnbOnDnt1zXgptvV4GBEnYKvp25px9A69UxP65o9e7bT/mOlBLhy5Yq5rqextW3b1ryntfPauXNnezl3BS29gbWf6Kltur/q6ZL6Y4gGbTXVhi5r0qRJqALXjvtwwB8sAr7flP5o88cff8hnn31mUrDofqE/SmhKgilTppjO/tmzZ1/o+YSXdfCh+2TAA2sAQMzsvwf3PefYjwyKY/8yYJ8nYJAxpEEFjo8fmsd2pIMMrBQAadOmNT9aayo27bM6BowjKj2Q9q8cUyToY2kfQ2nQUn8kDquQvu8dB5tE52M0x+Ob4I5tHPc/3Y80HYOmBdPUZPpe0P1RB4doGoRKlSrJrl27TFlN16HpRJT+uK6v36ZNm0xf25G1r3j62AaIKQjaAmFg/TpsdQis/K0B6S+PT548Mdcdf3nVoIUjx9tWOccgl+Ovn2rLli0uHy9//vxOuYL+m2TQ6aLBMs0564pjPTRIqYFLi5XrKKzPw7G85prS7boqnyRJEpNDK6Bu3bqZ3Etq+/btZlSrjoYMjTx58pj8wRbH0XlKR8darLxVSttJ66JBLc2ppfl8NcBp/Zqut63XwDHApL8Uv/baayZ4GFQnwzGPrOPrqvuJlc844HNwDDzqL/CuXld9vNDktS1cuLDTtoKiIzA0iGYJmMvWUq1aNft1bROrA6f/HV9fx3K//PJLiKNTw0Jzj+kBgI580A7ohAkTTNDcVcfRsTMb8AcAx5ETjteD4rjPaG6woA66HN8D2q6OIwh0pIGO/rVoWQ2s6/vB1X6i+6HjqBBX730dOaHbDGo/sfKn6W3dXzUvr77X9YeI+fPnO7VrSDSns8UKmCvNj2t1+AO2iR5A6P6kOfV0dKw+rpXnT9vdep86PqcBAwa4fD4a8LVyLjt+ZurzcRyFHtRnpkXzvFkHwxrAd0c+XwBA1Ou/O37PWUFHpd+zmzdvdmt9g/ue1QBcWDj2VzW/qgZVNVCnAxOCGpHq+F0Y1mCu9pmt73EN+GleeovjfB7a53EMGmvu1KD6L0OHDg32MXV0qGPfQfvxVqA6IGseCW/towXHOmNJWX0gi/atLHoMZB136Pb1h/N3333X9MO1ntpPe//998167TNZuYod9xVdb53lF3AghKtjGz1Wc6Q/CrjjmBWIif49ZwNAqGjCdj292poQTJPja3BPA4r6Ra6dOp2USjuDOqpPT9PVjqLVEdBfOXU0p/4irMEeTQFgsQJverqMJmW3AhD6Jau/jGrwIahOpib+twKtGhTRAJVOKKQdTz2lX39B1VF0+njZsmULdP+BAwea/9qB0y9Qq6OjX9JWgE2fhxWg0g6jnjKvp9toh8ya2Mgqp95++20TcNFAq25Pn5eelq0dT03k79iBtE4fCzgKQTtwenqzTnqlj6PtoM/DmjghuFEVOhmR1V46clY74jo6VDsRui3Hx7do+XHjxpmRoFpWXys9hVxPEbJYwWddr5N1qY8++si8BhqcdpwQyZG2hzUZmL6+moZBO1/Tp093mR5Cn7+2vfUcdMKyPn36mCC6dvo0gKzPQztfrjqKAVWpUsXeodMgsWMw1ZH+6m79eq/pIXQSDVe03YYPH246/Nq2+rrrc9T3hzVJmXbGdQIHpR0wDcpp4K569eqBtuf4PByfj9bFmshP90/r9DUdDawdSitAqu9NfV85HkjpY1nBah1da9H6dezY0eyTOnGE4+hofd+ERA86rFEJ2gHW0al6OqB2knUf0H1cJyvTHx20vtZ7Uz8vtM30faX/LZoiQOuuB0m6j+trYE0EqJ8hOkmX7peuTmnU56d11ve2rtfXVdslc+bM5nNA910NpOpBlzXyRH9c0AMQPbDKkCGDqbd+blkcf2AJiv6o4Bjk1QlE9KBAf8BwRfe5Dh062Ed56P6vBzmOk/BZj6vvJSvAr9vTuusBpraPHlDs379fFi9ebFIn6H6t7xOdEFHL6ahvfT10G7ofhTRq2PEHk9AcMAEAYkb/3fF7TvsK2s/RNAM6UtU668qd9PGt4wedpEl/cNbv9C+++CJM23E8M0qDc/rdr9+X2g8JKj2Q41kn2m/WwQ7ap9Lv7oATV7mi38F6nKCPY/UvNOipPxhb9Ad2nbjK6je0bNnSTGClfSINYur3vQZGte8aUntr/0DTP+gEZBqE1HbSM4n07Cv9r/XQ/oaOHNWRvtqv9NY+WnC0762T5iqdwE23p3067dc6/uCu9dQUVEr3Zz2W0h/JtT46OEWPzax+bMBjG4sen+gxo/bVdP9zRfv91mR62v/VY1Y9/tJ9xurHRfQxKxAjeTqpLhDVXLp0yVapUiWXidkdL1byfZ1sp0GDBsGW1QT6jpo3b+6ynONES45J3TU5ftOmTUOsk+OkBI7L8+XL57K8NVmAxTHhvKtLhw4dnMr/8MMPThNmBbxoMvrbt28HO7HDiRMnzERf1vLXX3892AT6lgsXLpgk+sHVVycRc5wMSesbXPlMmTLZk+9rgnxXZapUqeJycob79+87TUZmXeLEiWPLnz9/oOetdFIkV/dxvAQ1uVJAOqmaNQFXhQoVXJbRSSHy5MkTaBK64CZi0/q7qpdOXvDbb785lbUmoXLFcdKLoC6Ok2Ho/h9Secf3iD63OnXqBFteJ8Q4fvx4iG2p7zedICuo7dSvX99pQgfHia4CXlKmTGkmw3CcMEUn0wpYLmHChLaMGTO6nIBCJ5nQfTO0beH4OeLqEtLrrvR9q3V39R5JlixZoIkwtm7dGuxj6sQlp0+fdjmBWFAXx4lZPvzwQ5dlHJ+rq/eK42etTsoGAIiewtp/V6+88orLfptjXymoicgc+yzBTR7m2J9x/G7fvHmzy/oF7Bc6ctXn1+edPHnyQNspUKCAU//E8Tv10KFDLidtbdeuXbATkVmuXLkSqP+vE/wGpJMfO/abg7qElvY1U6RIEey2vL2PFhw9ZtFjl+C2pcc+Fy9etN9HX//gyutEytu3bzdldTI6V8dtAV8jx+PJtm3butxu0aJFI+yYFYjpCNoCL0C/cBYuXGhmxsySJYstXrx4tkSJEpkAgQalFi9e7DQLvV6fMWOG+dLSgIZ+QWonQQOQa9asCbR9nfV02LBhZtvaOdTtTpo0KdiZbNX8+fNttWvXNsEnfYxUqVLZihQpYuvUqZOZqdYxQOn4xaizpGpnSjsVVhDxq6++cvnc9XnrY+i29TG0c1SjRg3z2K7s3bvX9s4779gyZ85sOgLaThqs/eSTT2wPHz4M1Wy82mFyDAS9/fbbQc4870g73tqOxYsXN0EhPz8/0wGrWrWqbfr06eZ1dHTy5Elb7969beXKlTOBYm0LDT7mypXLtOG5c+ecyk+ZMsUEvPX1z507t23ChAm2devWBdmRvXbtmuncaJvpLLMaPN20aZNTUF/bJWCH9rPPPrOVLVvWzFqrbagzEuttDVTt2rXLFlqvvfaaeQwfHx8TxA1I91urHvpYVoA6OPraNG7c2LSX1k3/N2nSxGkWYsdOnc6W64mgrdJg/+TJk81Bm74Guj/o66AHLj169DCB/rDQ5/Lqq6+a97L1XihfvnygGX0vX75s3l/WvqIXPeDr3r27y8fUHyreeOMNs8/q+0UPGnVW46AO7NTNmzdtQ4YMMTPv6n10v9XPD32uo0aNsh0+fNheVu/71ltvmf06SZIkph207top//7770P9/LWTr/uwPpbeXwPZ+nxczXit+77ur/ocdP/V++j+onXUzwc9QAxo1apVph10Bmktqwed+lrprMba9gE/P/QzUttV37fZsmUz733dRlDvR31vaVvpOv2cBABEb2Htv2vAS/uc+l2ZIEECW/Xq1W3btm0Lsr8akUFb9e2335q6Wd+XgwcPNt/nQW0rqKCX9tW0r67PQ/vB+r2rgVVX39eW2bNn2woWLOgUxAtt0FY1bNjQqT6uvueV9uenTZtm+iDal9D+lAZG9VihZ8+etg0bNtjC4saNG7YxY8bYKlasaI5VtP7aT9PtDRw40Kk/5I19tNDsw3oMo8cy+lpqH07rosc62u9x/NFBaV9JB+HUrFnTPKb2e7WNtS+mr5H+qO5I21uPgzQQrX16HbBz9+7dIPctff108JHuB9YxpL6e48ePt5fXvnJ4jlmBmM5H/3h6tC8AxAT6cRsw36qekqSnmln50vSULU3P4A56ypHm/dJ69O3bV8aOHSuRQfOP6il1mkNL0x1Yp2wBnqSnUnbt2tVc19P49HRCAAAAvPixjdJ0DFaKBE1T4ZiKDEDYELQFgEiiuZ80l5jmn9KcUpqXdvTo0fYJmDSwqRMjuTOo2aJFC5k9e7aZgVbzhQU1g3FE0pzGGiDTnLSOswoDnqKTj+kEGpqnUCfZcMxzDQAAgJDpvB6ac7hu3bomJ67mwNXcwVauYg3o6qARa04KAGFH0BYAIknZsmUDza5qSZQokUm8X7Vq1UivFwAAAACEhU4eF9SZexqw/fjjj83ZfQBeXOAp2wEAbhvlGjduXDl69Kj5JVpnnc2ePbvUqFHDnDqUNWtWT1cRAAAAAEKkxzCHDh2Sffv2mRRo/v7+5mzCl19+Wbp06SLly5f3dBWBKI+RtgAAAAAAAADgRXw9XQEAAAAAAAAAwP8jaAsAAAAAAAAAXoSctm6i+VwuXrxoZmjXJNwAAACIPJoB7O7du5IhQwbx9WWcgiP6qQAAAN7fTyVo6ybaEc6cObOnqwEAABCjnTt3TjJlyuTpangV+qkAAADe308laOsmOnLBegGSJEkSqSMnrl27JqlTp2ZUSQSjbd2HtnUf2tZ9aFv3oW3dI6a16507d0xg0uqTwXP91Ji270U02i/8aMPwof3CjzYMH9ov/GhD72q/0PZTCdq6iXWqmXaEIzto++jRI/OYvBEjFm3rPrSt+9C27kPbug9t6x4xtV05/d/z/dSYuu9FFNov/GjD8KH9wo82DB/aL/xoQ+9sv5D6qbxSAAAAAAAAAOBFCNoCAAAAAAAAgBchaAsAAAAAAAAAXoSctgAAAAAC5W578uRJhG3r6dOnJhdcdM+jFydOnGj/HAEAQOQgaAsAAADAToO1p06dMsHWiGCz2cy27t69G+0nhtOAbfbs2U3wFgAAIDwI2gIAAACwB1gvXbokfn5+kjlz5ggZNarbfPbsmcSKFStaB201MH3x4kXTflmyZInWzxUAALgfQVsAAADAQzZt2iSffvqp7N692wT7Fi5cKA0aNAj2Phs2bJBevXrJwYMHTWB10KBB0rp16wipjwZXHzx4IBkyZJAECRJEyDZjStBWpU6d2gRu9fnGjh3b09UBAABRGAmXAAAAAA+5f/++vPTSSzJ58uRQlde0BXXr1pWqVavKvn37pEePHtK+fXtZuXJlhNTn+fPn5j+n978Yq92sdgQAAHhRjLQFAAAAPKROnTrmElpTp041OVM///xzczt//vyyefNmGT9+vNSqVSvC6hXdR8S6C+0GAAAiCkFbAAAAIIrYunWr1KhRw2mZBmt1xC0AAIA7aKoj2/Pn4v/8uflvrj975nTb5u///7f9/YNeZm3H1e3/LmLdz995mblus2mF/q2TLv/vuv7/r7JO9Xa4EeLyFPnzS+ZKlcRbELQFAAAAoojLly9L2rRpnZbp7Tt37sjDhw8lfvz4ge7z+PFjc7FoWWviLL040tvmIMg6AIog1rYicpveyGo3V237oqzXJKK2FxPRhuFD+4UfbRg+tF/YaCDzyd278vj2bXl865b5/+jWLblx4YJc9vOTZw8eyJN79+SpXu7fN//N7fv35dnDh//+f/BAnurF4bpjcDO6Kty+vWSsUMHt+2Bot0PQFgAAAIjGxowZI8OHDw+0/Nq1a/Lo0SOnZU+fPjUHEjqRll4igh7kWDle3Zk+4O7duzJs2DBZvHixXL16VYoWLSrjxo2TkiVL2uuh7TBjxgy5deuWlC9fXiZNmiS5c+c26zWw/e6778qSJUtMIFzXVa9e3b59TUlx7tw5mTBhQpB10DbT9rtx40aETUSm27t9+7apv68vU5K8CNowfGi/8KMNwyemtd/zJ0/k6Z078uS/i/367dvy9O7df/87rr992wRp7f/v3o0RAVZ30B/AtQ/h7n1Q+yyhQdAW8KAh83bar49oUsqjdQEAAN4vXbp0cuXKFadlejtJkiQuR9mqAQMGSK9evZxG2mbOnFlSp05t7udIg7h6IBErVixziUgRFcQMSufOneXAgQPy3XffSYYMGWT27NlSu3ZtOXjwoGTMmFHGjh1rJnybNWuWyQs8ZMgQqVevnlkfL148mTJliuzdu1e2bNkiv/32m7Rs2dKMbNZAs04Ap8HenTt3Btsuuk4P5lKmTGm2GRH0QFHroK9XTAhWuANtGD60X/jRhjG7/XTk68Pr1+X+5cvm8kD/X7ny/7evXDGXR//8Y0bG6mhXj/LxkdgJE0rsBAnM/1gJEpiLX5w44uPnJ75+fuLj6/vvdf3e09vWxVrucN1xmfj6Bipvv+1Y3rr4OdzWH36t/z4+/y77r77WMnMJ+COxw/WQlifPk0fSpEnj9n0wtH0EgrYAAABAFFGuXDlZvny507LVq1eb5UGJGzeuuQSkBx0BDzz0th6UWJeIoKNSrG25a6Stjoz5+eefzSjbypUrm2U6qnbp0qVm8raRI0fKxIkTZdCgQdKgQQOzXoO7OqJW79OkSRM5cuSIvP7661KoUCHJmTOn9O3b14yY1QO0Ll26mKBv0qRJg62H1W6u2jY83LHNmIY2DB/aL/xow+jZfvodpwHZ26dOyd3z5+Xe+fPmv+P1excumNGz7uSn3/VJk0rcZMn+/e9wPY5ekiSRJz4+kiJdOombJInETpTo30vChBLnv//mtgZn48ZlYk0374Oh3QZBWwAAAMBD7t27J8ePH7ff1hGd+/btkxQpUkiWLFnMKNkLFy6YAKPq1KmTfPnllyag2LZtW1m3bp3Mnz9fli1b5tZ6PgnmYFMPPBxHnwYsqwe0VtoALes44jao7caJEydM9dPtawqGgCNXdPTx5s2bTbvqqFnHSdw0AFumTBkzuZsGbV966SX5/vvvTQB45cqVkj59ekmVKpXMmTPHbPeNN94IU50AANGDfo/dPXdObp04IbeOH//3v8N1TUkQXjqSNX6KFP8GWq3Aq+P1pEklXvLkJgAbL2CZpEklVggjN/U7WE/711Gk3hb4RtAI2gIAAAAesmvXLqlatar9tpXGoFWrVuY0/kuXLsnZs2ft6/W0fg3Q9uzZ04wczZQpk0yfPl1q1arl9ry4QdGcsM2aNbPf/uyzz0xuXFeyZs0qrVu3tt/W5/BAJzcJYOjQoWGqX+LEic1oYx1Rmz9/fjOC9ocffjAB2Vy5cpmArXI1iZu1ToPg+/fvlwIFCphgrQbD//nnH5NGYcOGDWaU7rx588woXE2VoCkXAADRi//z53Lz6FG5umePXNm71/y/unevmczrRWigNVGmTJIoY0ZJlCGDJEyX7v8v6dPbr+toVyAggrYAAACAh1SpUsWM4AmKBm5d3Udzr8KZjpLVwKsGU/38/KR48eLStGlT2b17d6juryOANeetozZt2sj7779v2nvRokXy559/yieffGKWaToGAEDU9uDaNTmzZo1c2LzZBGev/vmnPHPxY6Irmm81SdaskixnTnNJkiWLCdAmtoK0GTNKnIQJ3f4cEH0RtAUAAAAQLE3TEJSAp1n27t3bZXoEa5IuR927d4+wOuoI2I0bN8r9+/fNZGua3qBx48aSI0cOM4GbNWmbLrfo7aJFi7rc3vr1680kZTqSuU+fPvLqq69KwoQJ5e233zYpKgAAUc/Thw9NgPbM6tXmcnXfvhDvo8HXNEWLSvK8ee0BWhOkzZpV/Nw8ySZiNoK2AAAAAIIVlhyzActq0NbKextwYpOw5q4NDQ2s6kVTG2huWh0Zq2klNHC7du1ae5BWA7vbt2+Xzp07B9rGo0ePpGvXriafrY7a1Xy51ohoTf2gtwEA3k8/u68fOCCnfvvNBGk1YPvs0aMgyyfNkUPSFi9uLmmKFTOXhAFS6wCRhaAtAAAAgChPA7R6cJ43b14zuZuOjs2XL59JcaDB4h49eshHH31kcvBqEHfw4MGSIUMGadCgQaBtaW5cHVlbrFgxc/vll18229Nt6ShbvQ0A8E4alD27fr2cXLpUTixdKncdcsMHpEHZrK+8IlmrV5d0pUqZHLSAtyBoCwAAACDKu337tknjcP78eUmRIoU0atRIRo0aZXLVqr59+5rUCR07dpRbt25JhQoVZMWKFRIvwIzbBw4cMJOQ7XM4ZfbNN980k5FVrFjRBIXnzp0b6c8PABC0excvyslly0yQVnPUBpWXNnHmzCZIm+2VVyRL9eqSIHXqSK8rEFoEbQEAAABEeZprVi9B0dG2I0aMMJfgFCpUSI4dO+a0TNM7/O9//zMXAIDn6ZkV1/78U47/+quc+PVXuRLEpJN+ceJI5qpVJUfdupKtVi1Jnjt3oFQ9gLciaAsAAAAAAACv9vzJEzn7++8mSKvB2qDSHiRIm9YEaXPWq2dG1cZJlCjS6wpEBIK2AAAAAAAA8DqPb9+W40uWyKEFC+TS+vXy5O5dl+XSFC0qOV9/XXLUqyfpSpQQH1/fSK8rENEI2gIAAAAAAMAr3Lt0SY4vXizHFy40E4r5P30aqIxv7NiSpVo1E6jN+dprkiRzZo/UFXAngrYAAAAAAADwmH+OHZNjCxeay6Vt21yWiZs8ueTUtAevv27y08ZNkiTS6wlEJoK2AAAAAAAAiNSJxG4cOiR///STuVw/cMBlucRZskiu+vUlZeXKUrBePYkdN26k1xXwFIK2AAAAAAIdTCPsaDcACP4z8tr+/fZA7c0jR1yWS1mwoOR+4w1zSVOsmLnf1atXxS927EivM+BJBG0BAAAAGLFjxxYfHx+5du2apE6d2lwPLz3YfvbsmcSKFStCtufVwYhr18xz1HYEAPz72Xhlzx57oPbW8eMuy6UvW1ZyN2wouRs0kOS5cwfaBhATEbQFAAAAYPj5+UmmTJnk/Pnzcvr06QjZph5s+/v7i6+vb7QO2ip9ftp+2o4AEFOZkbF798rR+fPl6IIFcvvkycCF9POyYkXJ8+abZkRt4kyZPFFVwKsRtAUAAABglyhRIsmdO7c8dTFb94vQgO2NGzckZcqUJnAbnekIWwK2AGJsoHbfPhOo/XvBArl14kSgMj6+vpK5ShV7oDZhunQeqSsQVRC0BQAAAOBEA48RFXzUoK0GM+PFixftg7YAENMCtdf/+kuO/PijCda6Sn2ggdos1apJnrfeMoHaBKlTe6SuQFRE0BYAAAAAAAChcuPIETn6449yZN48l5OJmRG1VatK3rffJlALhINX/dQ9ZswYKVWqlCROnFjSpEkjDRo0kKNHjzqVqVKliskV5Xjp1KmTU5mzZ89K3bp1JUGCBGY7ffr0MZMfONqwYYMUL15c4saNK7ly5ZJZs2YFqs/kyZMlW7ZsZlRAmTJlZMeOHW565gAAAAAAAN7p1smTsn3MGPn2pZdkZv78smXYMKeArRWorTFlinS6dEneXrNGXurYkYAtEF1G2m7cuFG6du1qArcaZB04cKDUrFlTDh06JAkTJrSX69Chg4wYMcJ+W4OzlufPn5uAbbp06WTLli1y6dIladmypTkla/To0abMqVOnTBkN9s6ZM0fWrl0r7du3l/Tp00utWrVMmR9//FF69eolU6dONQHbCRMmmHUaRNZAMAAAAAAAQHR159y5fycT+/FHubxzp8syOplY3saNJU+jRuSoBaJz0HbFihVOt3X0qwZId+/eLZUqVXIK0mpQ1pVVq1aZIO+aNWskbdq0UrRoURk5cqT069dPhg0bJnHixDGB2OzZs8vnn39u7pM/f37ZvHmzjB8/3h60HTdunAkOt2nTxtzW+yxbtkxmzJgh/fv3d2MrAAAAAAAARL77ly/L0Z9+MoHaC5s3uyyTvkwZE6jN+9ZbkjhTpkivIxBTeFV6hIBu375t/qdIkcJpuY6OTZUqlRQqVEgGDBggDx48sK/bunWrFC5c2ARsLRqIvXPnjhw8eNBepkaNGk7b1DK6XD158sQEih3L6KQJetsqAwAAAAAAENU9vHFD9n/9tcyvUUOmZswo6957L1DANk3RolLx44+l/cmT0nzbNinZsycBWyAmjbQNOMtsjx495OWXXzbBWUuzZs0ka9askiFDBtm/f78ZQaspC3755Rez/vLly04BW2Xd1nXBldHA7sOHD+Wff/4xaRZclTniIsm2evz4sblYdFvW89BLZNHH0hkcI/MxYwr3tK3NafsxFfut+9C27kPbug9t6x4xrV1jyvMEAOBFPHv0SE4sWSKHZs+WU8uXi3+AeYBUivz5JX/TpmZUbYo8eTxSTyAm89qgrea2PXDggElb4Khjx4726zqiVvPQVq9eXU6cOCE5c+YUT06iNnz48EDLr127Jo8ePYrUAxQdoawHZTo6GN7dtkl9/z/Qf/XqVYmp2G/dh7Z1H9rWfWhb94hp7Xr37l1PVwEAAK9i8/eXc5s2yeHZs+XoggXy5L/BZo6S5cwp+Zo0MYHaVIUKmcnfAXiGVwZtu3XrJkuXLpVNmzZJphCG2+skYer48eMmaKu5bnfs2OFU5sqVK+a/lQdX/1vLHMskSZJE4sePL35+fubiqkxQuXQ1TYNOXOY40jZz5sySOnVqs93IPCDTD1V93JhwQBaZ3NG2t/3P2q/H5Anu2G/dh7Z1H9rWfWhb94hp7RovXjxPVwEAAK9w/dAhOfT993J4zhy5e+5coPWJMmSQfE2bmmBt2hIlCNQCXsKrgrY68uO9996ThQsXyoYNG8xkYSHZt2+f+a8jblW5cuVk1KhRZtSiFQRbvXq1CZwWKFDAXmb58uVO29EyulzpZGUlSpSQtWvXSoMGDewHOnpbA8quxI0b11wC0oOiyD4w0g9YTzxuTBDxbfv/X4Yx/fViv3Uf2tZ9aFv3oW3dIya1a0x4jgAABDeh2OEffjDB2qt79wZaHztRIsnz5ptS4J13JHOVKuLr5+eRegKIIkFbTYkwd+5cWbx4sSROnNiegzZp0qRmBKymQND1r776qqRMmdLktO3Zs6dUqlRJihQpYsrWrFnTBGdbtGghn3zyidnGoEGDzLatoGqnTp3kyy+/lL59+0rbtm1l3bp1Mn/+fFm2bJm9LjpqtlWrVlKyZEkpXbq0TJgwQe7fvy9t2rTxUOsAAAAAAAC49uT+fTm+cKHJU3tm9WqTDsGRj5+fZK9d2wRqc77+usROkMBjdQUQxYK2U6ZMMf+rVKnitHzmzJnSunVrMwJ2zZo19gCqph9o1KiRCcpaNK2Bplbo3LmzGTmbMGFCE3wdMWKEvYyO4NUArQZ8J06caFIwTJ8+XWrVqmUv07hxY5OPdsiQISbwW7RoUVmxYkWgyckAAAAAAAA8wf/5czm7dq0J1B775Rd5ev9+oDLpSpUygdq8TZpIwhiclg+IarwuPUJwNEi7cePGELeTNWvWQOkPAtLA8F4Xpwg40lQIQaVDAAAAAAAA8ITrBw/Kwe++M5OK3bt4MdD6JNmymUCtXlLkzeuROgKIRkFbAAAAAAAABHb/6lU5onlqv/tOruzZE2h93GTJJO/bb0uBFi0kY/ny4kN+dyBKI2gLAAAAAADghZ49fiwnliwxgdpTv/0m/s+eOa33jRVLctStawK1+j9WvHgeqyuAiEXQFgAAAAAAwItSR17du1cOzJwph+fOlUc3bwYqk7ZkSSnYqpXka9xYEqRO7ZF6AnAvgrYAAAAAAAAe9uDaNTk8Z44J1l7bvz/Q+kQZM5oRtXpJVaCAR+oIIPIQtAUAAAAAAPCA50+fmrQHB2fNMmkQAqY/0HQHuRs1kkKtW0vmqlXF18/PY3UFELkI2gIAAAAAAESiG4cPmxG1B7/7Th5cuRJoffqyZaVQmzYm/UHcpEk9UkcAnkXQFgAAAAAAwM0e37kjxxYskL9mzJBL27YFWp8wXTop0LKlGVWbMn9+j9QRgPcgaAsAAAAAAOAGNn9/Obt+veyeOlXOLVsmzx4+dFrvGzu25Hz9dTOqNnutWuIbizANgH/xaQAAAAAAABCB7pw9Kwe//dakQLh96lSg9amLFJFCbdtK/ubNJUGqVB6pIwDvRtAWAAAAAAAgnJ49eiTHFy0y6Q/OrFkjYrM5rY+bLJkJ0hZu21bSFCsmPj4+HqsrAO9H0BYAAAAAAOAF2Gw2ubJnjxyYMUMOz50rj2/dci7g4yNZa9SQzI0aSfEWLSROggSeqiqAKIagLQAAAAAAQBgnFdMg7f6vvpKr+/YFWp80Rw6Tp7Zgy5aSKFMmuXr1qsSKF88jdQUQNRG0BQAAAAAACM2o2t275c+vvpIjP/wgT+/fd1ofK358yfPWWyZYm7lSJfHx9TXL/f39PVRjAFEZQVsAAAAAAIAgPLl714yq1WDt1b17A61PV6qUFG7fXvI1aSJxkyTxSB0BRD8EbQEAAAAAAAK4vHu3SX9wWEfV3rvntC5O4sRmUrEiHTtK2mLFPFZHANEXQVsAAAAAAAAdVXvvnkl9oKNqNRWCq1G1GqjVUbVxEiXySB0BxAwEbQEAAAAAQIymk4lpoPbwnDkmHYKj2IkSSQFrVG3x4h6rI4CYhaAtAAAAAACIcZ4+eCBH58+XP6dOlUvbtwdarwHaIu++K/mbNjXpEAAgMhG0BQAAAAAAMcaNw4fNqNqD334rj2/dcloXO2FCyde0qbz07ruSrmRJj9URAAjaAgAAAACAaO3Z48dyfOFC2Td1qpzfuDHQ+jRFi/47qrZZM4mbJIlH6ggAjgjaAgAAAACAaOn26dMm/cFfM2bIw2vXnNbFihdP8jZpIkU7dZJ0pUuLj4+Px+oJAAERtAUAAAAAANGGzWaTs2vXyp5Jk+TEkiW6wGl9irx55aVOnaRgq1YSL3lyj9UTAIJD0BYAAAAAAER5T+7elYPffy97v/xSbh4+7LTON3Zsyd2woQnWZq5cmVG1ALyer6crAAAAAMRkkydPlmzZskm8ePGkTJkysmPHjiDLPn36VEaMGCE5c+Y05V966SVZsWJFpNYXALzNP8eOybru3WVqpkyytmtXp4BtoowZ5eWRI+Xdc+fktXnzJEuVKgRsAUQJjLQFAAAAPOTHH3+UXr16ydSpU03AdsKECVKrVi05evSopEmTJlD5QYMGyezZs+Xrr7+WfPnyycqVK+WNN96QLVu2SLFixTzyHADAE2z+/nJq5UrZO2mSnPrtt0DrM1WqJMW6dZNcDRqIX+zYHqkjAIQHQVsAAADAQ8aNGycdOnSQNm3amNsavF22bJnMmDFD+vfvH6j8999/Lx9++KG8+uqr5nbnzp1lzZo18vnnn5tgblg8efLEXALy9fWVWLH+/zDBVRmLjlaL7RAMcVXW39/fjBDWS9y4ce3L9bbmnQzNdiOqrIoTJ84LlX327Jl5LhFRVutrjfQLqayfn98Lbff58+fmEhFldX/Q/cJbymobaFsE12ZWu2lZ3S/1tdb/1jaCKhuW7Ya2rO5j+vgRUdbx/emusgHfy9Z72Gq/iP6MCKpsUO/Px3fvyuE5c+SvL780I2zN8/vvfrHix5e8jRvLS+++K6kLF/63/trGDvf3xGdEwOUR+RnxomWj4meEq/ewq7Luei9H5c+IgO/j4MqGtN2Q3sue/oxwR1nH9tMznUKz3eA+I4J7no4I2gIAAAAeoB323bt3y4ABA5wOdGrUqCFbt251eZ/Hjx87HSyo+PHjy+bNm4N8HL2PXix37twx/zXQG3BbKleuXNK0aVP77c8++yzIA7msWbNKy5Yt7bcnTpwoDx48cFk2ffr00r59e6e0ELdv33ZZNlWqVCYgbZk2bZpcv37dZdmkSZPK+++/b789c+ZMuXTpksuyCRIkkA8++MB+e86cOXLmzBmXZfUAzjFwrqOijx8/LkEZPHiw/fovv/wihwPk03TUr18/+4HckiVLZP/+/UGW7dGjhzkg1AM9HVm9a9euIMu+9957kixZMnN97dq1Qe5H6t1337WP5t60aZO5BKVdu3aSIUMGc123qdsOSosWLUy6D6V1DS59R5MmTSR37tzmurbBr7/+GmTZRo0aSYECBcz1Q4cOyc8//xxk2ddff92kDlHHjh2TefPmBVm2du3aUqpUKXP99OnT5oeRoFSvXl3Kly9vrl+8eFG++eabIMtWqlRJKleubK5fvXpVvvrqqyDLlitXzrzv1a1bt2TSpElBli1ZsqTUqVPHXL9//7754ScoRYoUkfr169s/b8aOHRtk2fz588ubb75pvz1mzJggy3rDZ4TP1auS4L+ArXl+XbrIs/8mFNupl6VLRfTiRZ8RHTt2tAdsIvIzQs/WSJgwobkeXT8jtN30vTx9+vQgy/IZ8S8+I6JGP+LRo0cSGgRtAQAAAA/QgwcdOZQ2bVqn5Xr7yJEjLu+jqRP0AEwP9jSvrR4Y68F/cCOV9MBq+PDhoa6XHrjpAaQluBEkAcsGN8JLD9gcywZXZ133omWDG9mk9XMsG9xIF33eoS2rHMs6BslduXbtmn1UT0gHbrqf6GNrfYI6kLXcuHHDXk89WA/OzZs37ddDU9YaNXXv3r1gy2pAwWqLu3fvhrqs9WNCUPTA3Cob1EG6RbdlldXHCI7WMbRl9blbZR3bzxVt0xcpG1Kb6T5glX348GGwZXXfssoGN4LO2mcd92FPfEboeze073tLugoVJG+7drLl9u0gXz9v+YzQ+ul99Me5iP6MsN7D0fUzQl+XkJ4bnxH/4jMi6vYjXPGxBdd6eGH6IaDRev2wSJIkSaQ9rrUD6S9iQZ02AO9p2yHz9Hfgf41o8u+vdzER+6370LbuQ9u6D23rHjGtXT3VFwsLHYWTMWNGk49WR9FY+vbtKxs3bpTt27e7PJDXdAo68kpP59PArY6+0XQKQR2cuRppmzlzZrly5YrLtnFHegQNKqROnZr0CC+YHsFqPy0XnU99dmd6BG1DHXlFeoSQy7pKj+DYfpFx6vPThw/lwOzZsu9//3OaVMyeAqFJEynRpYs9BYK3f0bocv0+0vexth/pEcJWVp+TfmclT56c9AjhSI8Q8HOQ9AhhS49gtV9EpEfQvpj+SB9SP5WRtgAAAEAIzp49K6NHj5b169ebwOmiRYvMaFftwI8YMcLkpA3rRGDa8deDMD0QdaS306VL5/I+esCvj62jY3TElJ6Oqqfe5ciRI8jH0UCpY7DUogcdrtIjuCoXWq7K6gGKHrRoHRwPtl3VKSjeUNbxwCsyy2r76QFlwIPgkGh5x4PQ6FY2tG1hBRm1nXX/DO5Hq7BuNyyvh2Nu4qhQ1vG9bL2Hg2q/8H5GOLp/5YoJ1Orl4X+nMv8bNhRJnCWLmViscLt2Ej9Fiij1GaFtqEEax/0xIrYbnrLe8l4ObVndf0N6D7v7vRyVPyNCeh+HdbsR+b5/0bJxI/F9H1T7vehnBDltAQAAgAigufEqVqxoOuxlypQx+cis0TMaeNV8snrqYnC564LqvJcoUcKkOGjQoIFZpo+ht7t16xbsffWgQUfp6ggPzdv39ttvh+MZAoBnXfvrL9k9fryZYOx5gGBGxpdflhI9e0qu+vXFNwxBMACI6vjEAwAAAIKh6Qp04pZt27aZEY/WxCyWunXrmsklXoROINOqVSszcUjp0qVlwoQJJgCsI3eVTs6hwVlrwg9NmXDhwgUpWrSo+T9s2DAT6NU6AkBUYvP3l1MrV8rucePkzJo1Tut8/Pwk79tvm2Bt+v8mgQKAmIagLQAAABAMnTF7yJAhJjWBpiQIKEuWLCaA+iIaN25s0i3o9i9fvmyCsTqTtjU5maZlcDwNT9MiDBo0SE6ePCmJEiWSV1991cxkbc0GDgDeTvPVHp49W3aNHx8oX23cZMmkSMeOJg1CksyZPVZHAPAGBG0BAACAYOhI1gQJEgS5XoOuYclpFpCmQggqHcKGDRucbleuXNmkawCAqMZVvlpLspw5pXiPHlKodWuJkyiRx+oIAN6EoC0AAAAQjOLFi8uyZcukS5cugdZpbtt58+ZJ2bJlPVI3APB21w8elF3jxpnRtQHz1WaqVElK9uolOerVE98wTIIEADEBQVsAAAAgGAMGDJB69epJ586dpUmTJmbZlStXZM2aNTJ69Gg5fPiwfPnll56uJgB4DZvNJuc2bJCdn34qp377LVC+2nyNG5t8telKlvRYHQHA2xG0BQAAAIJRp04dmTVrlnTv3l2mTZtmlr3zzjsmKJEkSRL57rvvpFKlSp6uJgB4nP+zZ/L3Tz+ZYO2VPXuc1sVNmvTffLXvvUe+WgAIBYK2AAAAQAhatGghDRs2lFWrVsnx48dNntucOXNKrVq1JHHixJ6uHgB41JN79+Svb76R3ePHy50zZ5zWJcma1YyqLdy2rcTh8xIAQo2gLQAAABAKCRMmlDfeeMPT1QAAr5pcbM/EibJvyhR5fOuW07q0JUpIqT59JE+jRuIbi9ADAIQVn5wAAABAMM6ePRvseh8fH4kXL56kSpXKXAeA6O7WiROy87PP5MDMmfL88WOndTnq1pWSvXtL5sqV+UwEgHAgaAsAAAAEI1u2bKEKPGjgtmLFijJ48GB5+eWXI6VuABCZNE/tjrFjTd5am7+/fblfnDiS/513pGSvXpKqYEGP1hEAogtf8SJjxoyRUqVKmbxgadKkkQYNGsjRo0edyjx69Ei6du0qKVOmlESJEkmjRo3M7L0BR0PUrVtXEiRIYLbTp08fefbsmVOZDRs2SPHixSVu3LiSK1cuM7lEQJMnTzaddO2AlylTRnbs2OGmZw4AAABv9c0330iRIkUkefLk0q1bN5kwYYK5aJ9UlxUtWlQmTpwoHTp0kF27dkm1atVk/fr1nq42AEQInXTx8ubN8nOtWvJ9iRJydP58e8BWc9RqCoQOp05J7W++IWALANE1aLtx40bT+d22bZusXr1anj59KjVr1pT79+/by/Ts2VOWLFkiCxYsMOUvXrxoJoWwPH/+3ARsnzx5Ilu2bJFvv/3WBGSHDBliL3Pq1ClTpmrVqrJv3z7p0aOHtG/fXlauXGkv8+OPP0qvXr1k6NChsmfPHnnppZfMRBNXr16NxBYBAACAp2l/U/uWOgGZBmffe+89c/niiy/k77//locPH5qLBnJ1wEH69Oll+PDhnq42AISLBmb//uUXmVuunKx56y05s2aNfV2CNGmk4ujR0vHsWan8ySeSKEMGj9YVAKIjrwrarlixQlq3bi0FCxY0QVINtuqo2d27d5v1t2/fNiMdxo0bZ0YwlChRQmbOnGmCsxroVTqj76FDh2T27Nlm1EOdOnVk5MiRZtSsdrbV1KlTJXv27PL5559L/vz5zYiJN998U8aPH2+viz6GjpZo06aNFChQwNxHR+7OmDHDQ60DAAAAT9B+oP7AnyxZskDrUqRIYdZ9+eWX5raeDda2bVt7/xUAoprnT57IXzNmyMwCBeRXPbN15077uqQ5ckiNKVOkw+nTUmbAAInn4nMRABANg7YBaZDW6gwr7fzq6NsaNWrYy+TLl0+yZMkiW7duNbf1f+HChSVt2rT2MjpC9s6dO3Lw4EF7GcdtWGWsbWhwVx/LsYyvr6+5bZUBAABAzHDjxg158OBBkOv1rLBr167Zb6dLl86cTgwAUcmTe/dk17hx8nWOHLKyXTu56ZCqMHmhQlJ37lxpd/SoFO3USWLHj+/RugJATOC1E5H5+/ubtAU6iUOhQoXMssuXL0ucOHECjXLQAK2us8o4Bmyt9da64MpoYFdPbfvnn39MmgVXZY4cOeKyvo8fPzYXi27Leh56iSz6WHqQEJmPGVO4p23//4AuJr9m7LfuQ9u6D23rPrSte8S0do3I56lzLmhahNdff90MDnC0f/9+mTRpkpQuXdq+7PDhw5IpU6YIe3wAcKcH16/L3kmTzOXRP/84rctcpYqU6ttX4hctao6HdTATACCGB201t+2BAwdk8+bNEhXoJGqucpfpqAudPC0yD1B0hLIelPGF6v1tm9T3/wP9MTlfMvut+9C27kPbug9t6x4xrV3v3r0bYdvSoKzOhVCsWDEpV66cmcRWaY5bPQsrSZIkJr+t0n6fTnirqbcAwJvdvXBBdn32mfw5bZo8C3A2Qa769aV0//6SoWxZ8/0Rk49VAMBTvDJoqzlmly5dKps2bXIapaCnmmnqglu3bjmNtr1y5YpZZ5XZsWOH0/Z0vbXO+m8tcyyjHe748eOLn5+fubgqY20joAEDBpiJyxxH2mbOnFlSp05tthtZ9AvVx8fHPG5MOCCLTO5o29v+Z+3X06RJIzEV+6370LbuQ9u6D23rHjGtXePFixdh2ypSpIj89ddf8vHHH5uJa3f+l98xa9as0qVLF+nbt6+9z6qPu3fv3gh7bACIaLdOnJAdY8fKgVmzxP/pU/ty31ixJF+zZlK6Xz9JVaCAR+sIAPCyoK2O/NCZeBcuXGhGKOhkYY504rHYsWPL2rVrpVGjRmaZztCrk5XpqAel/0eNGmV+CbSCYKtXrzaBU51QzCqzfPlyp21rGWsbmoJBH0sfp0GDBvYDHb2tAWVX4saNay4B6UFRZB8Y6QGZJx43Joj4tvWxX4vprxf7rfvQtu5D27oPbeseMaldI/o5ZsiQwT6aFgCiomsHDsiOjz+WIz/8IDaHFDKx4sWTwu3bS8nevSVp1qwerSMAwEuDtpoSYe7cubJ48WJJnDixPQdt0qRJzQhY/d+uXTszolUnJ9NArAZ5NdhatmxZU7ZmzZomONuiRQv55JNPzDYGDRpktm0FVTt16mRm+NVRETq777p162T+/PmybNkye130MVq1aiUlS5Y0OcomTJhgJplo06aNh1oHAAAAAICwubRzp2wfPVqOL1rktDxO4sRStGtXKdGzpySMwWf9AYC38qqg7ZQpU8z/KlWqOC2fOXOmtG7d2lwfP368GTmhI2114q9atWrJ//73P3tZTWugqRU6d+5sgrkJEyY0wdcRI0bYy+gIXg3Q9uzZ00wqoaezTZ8+3WzL0rhxY5OPdsiQISbwW7RoUVmxYkWgyckAAAAQ/Wmu2p9//ln27NljcgMHnOhMRzF/8803HqsfAAR0cetW2TJihJxescJpefyUKaV4jx5SrFs3iRdgkm8AgPfwuvQIIdE8YZMnTzaXoGh+sYDpDwLSwHBI+cY0FUJQ6RAAAAAQM5w5c8ZMRHb69Gkzr4IGbfWsL51n4fnz55IqVSpJlCiRp6sJAMb533+XrSNGyJk1a5yWJ8qQQUr16SOFO3SQOAkTeqx+AIDQif4JzQAAAIBw6NOnjwnUbtu2Tf7++28z0ODHH3+Ue/fuydixY00aL52gDAA8RT+Xzq5fLz9WrSrzKlVyCtgmyZpVXpk6VdqfPCklevQgYAsAUYRXjbQFAAAAvI3Of9ClSxczz8HNmzftARKdL0EDuocPH5YePXo4zY8AAJFBP4s0QKsjay9s3uy0LmmOHFL2ww+lQIsW4hc7tsfqCAB4MQRtAQAAgGA8ePBAsmXLZq7rRLiav1ZH3lp0HoXevXt7sIYAYmKw9vSqVbJ1+HCTu9ZR8ty5peygQZK/WTPxjcUhPwBEVXyCAwAAAMHIkiWLnD9/3lyPFSuWZMyY0aRKaNiwoVl26NAhM+8CAERGsPbUihUmWHtp+3andSny5ZNygwdL3saNxdfPz2N1BABEDIK2AAAAQDCqVasmixcvlqFDh5rbrVu3ljFjxsg///wj/v7+8v3330vLli09XU0A0T1Y+9tvsmX4cLm8Y4fTupQFC5pgbZ433yRYCwDRCEFbAAAAIBj9+/eXnTt3yuPHj00e24EDB8rFixflp59+Ej8/P2nWrJmMGzfO09UEEE2DtSeXLTPB2iu7djmtS1WokJQbMkTyNGokPr7MMQ4A0Q1BWwAAACCE9Ah6sWgqhOnTp5sLALgtWLt06b/B2t27ndalLlLEBGtzv/EGwVoAiMYI2gIAAAAv4MmTJ/L06VNJmDChp6sCIBoFa08sWWJy1l7Zs8dpXZqiRU2wNlf9+gRrASAG4JMeAAAACMa8efOkZ8+eTsuGDx8uiRIlkmTJkskbb7wh9+7d81j9AESPYO3xxYvl+xIlZFH9+k4B2zTFikn9hQulxZ49jK4FgBiET3sAAAAgGJ9//rncv3/ffnvLli0maFurVi0TzF2xYoWMGjXKo3UEEHWDtccWLZLvixeXRQ0ayNW9e52CtQ0WL5YWu3dL7gYNxMfHx6N1BQBELtIjAAAAAME4ceKEtGrVyn577ty5ki5dOlm4cKHEihVL/P395eeff5YxY8Z4tJ4Aog6bv78ZWas5a6/9+afTurTFi0v5YcMkR716BGoBIAYL10jbS5cuRVxNAAAAAC/0+PFjM/mYZdWqVVKnTh0TsFUFChSQ8+fPe7CGAKJSsPbvX36R74oXl8UNGzoFbNOWKCFvLFki7+zaJTlfe42ALQDEcOEK2mbOnFlq1qwp33//vdMpYwAAAEB0kT17dlmzZo25vmvXLjl+/LjUrl3bvv7KlSsmvy0AhBisLVZMfm3UyDlYW7Lkv8HanTslJ6NrAQAREbQdMWKEXLx40ZwuljZtWnnnnXdMTi89RQwAAACIDt59912ZP3++FClSxAxYyJQpk9SrV8++/o8//pCCBQt6tI4AvDhY+/PP8m3Rov8Ga/fvt69LV6qUNFy2TN7ZsYNgLQAgYoO2AwcOlAMHDsju3bulU6dOsmHDBnn11VclQ4YMZlIGHYkAAAAARGXvvfeefPXVV5IzZ06pX7++SY8QP358s+7mzZty+fJlad68uaerCcALJxgzI2vffFOu//WXfV260qVNsLb59u2S49VXCdYCANw3EVmxYsXM5dNPP5V169aZyRlmzpwpX3zxheTNm9eMwNVLlixZIuLhAAAAgEjVoUMHcwkoRYoUDFQA4BSsPbl8uWwZMkSu7NnjtC59mTJSbuhQyV67NoFaAIB7R9oGpF88FStWNKNty5Yt+++vi8eOyTCd+TJHDnnrrbeYvAwAAAAAEK3ose+plStlTtmysrBePaeArUmDsHy5NNu6VXLUqUPAFgAQeSNt1fr162XOnDny888/y507d6Rw4cLy2WefmVPFdGZdHXk7evRoadGihX0iBwAAAMAbVatWLch1GnCJFy+eZM2a1QxWcMxvCyDmBWvPrlsnfwwZIhe3bHFal6ZYMXl5xAjJUbcugVoAQOQGbf/8808TqP3hhx/MhGTp0qWT9u3bS8uWLU3Q1lHv3r1N51b/AwAAAN7s6tWrwQZZHjx4IKtXrza5bmvVqiWLFy+W2LFjR2odAXjWxa1b5fcPP5Rz69c7LU9dpIiUHz5cctWvT7AWAOCZoK3msdVJGBo0aGACta+88or4+gadcUFn1S1Xrlx4HhIAAABwO51sNyQPHz40QdtevXrJJ598Ih9++GGk1A2AZ13bv182DxokJ5YscVqeskABKT9smORp1Eh8gjkuBgDA7UHbGTNmyJtvvimJEiUKVfmqVauaCwAAABDV6eCFHj16yI4dO8xEvARtgejtn2PH5I+hQ+XIDz84LU+WK5e8PHy45G3cWHz9/DxWPwBA9BKuoG3r1q0jriYAAABAFPTyyy/LokWLPF0NAG5y59w52TZypPw1Y4bYnj+3L0+UMaOUHzpUCrZuLX6kRwEARLBwnbPxxRdfmBxeQalTp45MmTIlPA8BAAAAeDXNb6sT7wKIXh5cuybre/WSb3Lnlv1ff20P2MZPlUqqjBsn7Y8flyIdOhCwBQB4X9D2m2++kQIFCgS5XtdNmzYtPA8BAAAAePXM8b/++mugSXgBRF2Pb9+WzUOGyNc5csju8ePl+ePHZnmcJEnk5REjpMPJk1KyZ0+JFS+ep6sKAIjGwjUk4MSJE9K1a9cg1+fLl0++/vrr8DwEAAAAEOlu3rwZ4iRkR48eNWeVbdmyRWbPnh1pdQPgHk8fPJC9X34pOz7+WB798499eaz48aVYt25Sul8/iZ8ypUfrCACIOcIVtI0TJ45cvnw5yPWXLl0SX2bNBAAAQBSTKlUq8fHxCbFc7NixZeTIkdK0adNIqReAiPf8yRPZP326yVt73+H41jdWLCnSsaOU/fBDSZQhg0frCACIecIVtC1btqzMmjVLevbsKYkTJ3Zad/v2bZk5c6YpAwAAAEQlQ4YMCTZoGy9ePMmaNatUr15dUqdOHal1AxAx/J8/l8Nz5sgfQ4fKndOn/3+Fj48UaNHCTDKWLEcOT1YRABCDhStoO3ToUKlcubIULVpUevToIQULFjTLDxw4IBMmTDAjbefOnRtRdQUAAAAixbBhwzxdBQBuzEV9fNEi2TxokNw4dMhpXe6GDU3e2lT/HdsCABAlg7ZlypSRJUuWyLvvvivdu3e3j0bQL8Hs2bObSRnKlSsXUXUFAAAAAOCFnVmzRn4fOFAu79zptDzrK69IhVGjJH2pUh6rGwAAERa0Va+88oocP35c9u7dayYmUzlz5pTixYuHKg8YAAAAAADudG33btk4bpycW7fOaXn6smWl4pgxkqVKFY/VDQAAtwRtlU42VqJECXMBAAAAAMAbXDtwQDYPHCgnlixxWp6qcGGpOGqU5KhXj8FGAIDoG7Q9dOiQnDx5Uv755x+TGiGgli1bRsTDAAAAANHO5MmT5dNPP5XLly/LSy+9JJMmTZLSpUsHWV7njpgyZYqcPXtWUqVKJW+++aaMGTPGTI4G4F+3T582E4wd+v57zd9nX54sZ055eeRIyde4sfj4+nq0jgAAuC1oq+kQ3nnnHdmxY4fLYK3SXy0J2gIAAACB/fjjj9KrVy+ZOnWqmS9CA7K1atWSo0ePSpo0aQKV10l++/fvLzNmzJDy5cvL33//La1btzZ97nHjxnnkOQDe5MG1a7Jt1Cj5c8oUef7kiX15/HTp5OWhQ6Vwu3biFzu2R+sIAIDbg7Y6Adlff/1lOpcVK1aU5MmTh2dzAAAAQIyigdYOHTpImzZtzG0N3i5btswEZTU4G9CWLVvk5ZdflmbNmpnb2bJlk6ZNm8r27dsjve6AN3ly967sGjdOdn72mTy9d8++PF7y5FKqf3/J+NZbkiFrVpPaDwCAaB+0/eOPP2TgwIHy3nvvRVyNAAAAAC9z584d+d///ifr16+Xq1evyldffWVSGNy8eVNmzZolr7/+uuTKlStM23zy5Ins3r1bBgwYYF+mAaUaNWrI1q1bXd5HR9fOnj3bnOmmj68pypYvXy4tWrQI93MEoqJnjx/Ln1OnyraPPpKH16/bl8eKH19K9Owppfr0kThJkpj3LQAAMSZoqzm0kiZNGnG1AQAAALzM+fPnpXLlynLu3DnJnTu3HDlyRO79N5IvRYoUJoB75swZmThxYpi2e/36dXn+/LmkTZvWabne1sdwRUfY6v0qVKhg0pM9e/ZMOnXqZAZSBOXx48fm4hiAVv7+/ubibvoYWtfIeKzoiPZzzf/5czkyd65sGTZM7pw+bV/uGyuWFG7fXsoMGiSJ0qf/tyxtGC60X/jRhuFD+4Ufbehd7Rfa7YQraKsdRP2lv2vXruLn5xeeTQEAAABeqU+fPnL37l3Zt2+fyTMbMNdsgwYNZOnSpZFSlw0bNsjo0aPNqF/NgXv8+HHp3r27jBw5UgYPHuzyPjpJ2fDhwwMtv3btmjx69MjtddYDk9u3b5uDHU5NDzvaz5m2w4W1a2Xf6NFy6/Bhp3XZ3nhDXurTRxJnzy4PNL/tf6NracPwof3CjzYMH9ov/GhD72o/7Ve6PWibJ08eMzpAZ7lt27atZM6c2WXwtmHDhuF5GAAAAMBjVq1aJT179pQCBQrIjRs3Aq3PkSOHGYX7Imetad/5ypUrTsv1drp06VzeRwOzmgqhffv25nbhwoXl/v370rFjR/nwww9dHkho+gWd7MxxpK3221OnTi1JkiSRyDjQ0YnS9PE4UAw72u//Xdy6VX4fMEAu/P670/KsNWtKxdGjJU2xYi7vRxuGD+0XfrRh+NB+4Ucbelf7xYsXz/1B28aNG9uv9+7d22UZfVIa2AUAAACioocPH5pOenhHSwQUJ04cKVGihKxdu9aM1rUOCvR2t27dXN7nwYMHgQ4WrEETOvrDlbhx45pLQLqdyDpw02OCyHy86Camt9/1Q4dk88CBcnzxYqfl6UqXlkoffyxZqlYNcRsxvQ3Di/YLP9owfGi/8KMNvaf9QruNcAVtdSIGAAAAIDrTEbabNm2Sd9991+X6RYsWSbEgRviFREfAtmrVSkqWLGkmFpswYYIZOdumTRuzvmXLlpIxY0aT4kC99tprMm7cOPN4VnoEHX2ry0lXhujm3qVL8sfgwXJg5kyxOeT/S54njxlZm7thQ3MQDQBAdBSuoK1OyAAAAABEZz169DCB1SJFishbb71lHxGrAVPNFbt161b5+eefX/jMNc0tO2TIELl8+bIULVpUVqxYYZ+c7OzZs06jMQYNGmSCVPr/woULZgSwBmxHjRoVQc8W8LynDx7Irs8/lx1jx8rT+/ftyxNlyCDlhw2TQm3amAnHAACIziJkTLTORqud1cWLF5vZbF+UjmDQTmeGDBlMZ1RHLThq3bq1We54qV27tlOZmzdvSvPmzU1+rmTJkkm7du3ss/ta9u/fLxUrVjQ5JDSf1yeffBKoLgsWLJB8+fKZMporbPny5S/8vAAAABB1vfPOOzJixAgTKNU5HZT2QfPmzSvz5s0zE4NZ6Q1ehKZCOHPmjOlTb9++3YygdZx4bNasWfbbsWLFkqFDh5qAsaZt0KDu5MmTTb8XiOp0NO3B776Tb/LkkT+GDLEHbOMmTSoVP/5Y2h07JkU6dCBgCwCIEcIdtP3iiy8kffr0UqFCBTPhmAZElQZvdXKFGTNmhHpbeiqYTmqmHc+gaAf50qVL9ssPP/zgtF4DtgcPHpTVq1ebWXw1EKwTMzhOvFCzZk3JmjWr7N69Wz799FMZNmyYTJs2zV5my5Yt0rRpUxPw3bt3r+mE6+XAgQNhbB0AAABEBzrJ14kTJ0zfsXPnztKhQwcZO3asHD16VPr16+fp6gFR3rmNG2V2qVLyW6tWcu/CBbPMx89PinXrJu2OH5cy/fpJ7AQJPF1NAAAiTbh+opw5c6Y5XaxJkyYmENq2bVv7Og3YVqtWzYw+cFwenDp16phLcHQShaBm0z18+LA5nWznzp0mL5iaNGmSvPrqq/LZZ5+ZEbxz5syRJ0+emGCyTv5QsGBB2bdvn8kNZgV3J06caILDffr0MbdHjhxpgsBffvmlTJ06NdTtAwAAgOgjS5Ys0rNnT09XA4hW/jl2TDb27SvHA5xlmaNePan86aeSMl8+j9UNAIAoO9L2888/l/r168vcuXNNWoOAdDZcHfUakfQUsTRp0pjT0XSUw40bN+zrNEWDnhpmBWxVjRo1TB4wPdXMKlOpUiUTsLXUqlXLjJL4559/7GX0fo60jC4HAABAzKIThI0fP17Onz/v6aoA0cbDmzdlfc+eMrNAAaeAbeqXXpK31qyRhkuWELAFAMRo4Rppq7m03n///SDXp0iRwimoGl46+lVTMGTPnt2cnjZw4EAzMleDqTpbrk7eoAFdR5r3S+uh65T+1/s7siZ60HXJkyc3/61ljmWsbbiiOcj04piGwZqkQi+RRR/LZrNF6mPGFO5pW5vT9mMq9lv3oW3dh7Z1H9rWPWJau0bk89R+5gcffGDOwipbtqw5y+zNN98M8uwvAEF7/uSJ7JsyRbYOHy6P/hs0oxKmSycVRo2Sgq1aia+fn0frCABAlA/a6qjW4CYeO3ToUIR2ZrWDbNHJwXQG35w5c5rRt9WrVxdPGjNmjJk9OCCdDfjRo0eReoBy+/Ztc1DmONMwvLNtk/r+f6D/6tWrElOx37oPbes+tK370LbuEdPa9e7duxG2LR0goBN+/fjjjzJ//nwzaEHTJOjEtto/1UEFmhoMQND0s+fEr7/Kxj59TEoES6z48aVk795Sum9fiZMokUfrCABAtAnaaq5YncCrS5cugdZpWoSvv/461PlsX0SOHDlMB1lH/GrQVgPEAQNfz549k5s3b9qDx/r/ypUrTmWs2yGVCS4APWDAAOnVq5fTSNvMmTNL6tSpJUmSJBKZB2Q+Pj7mcWPCAVlkckfb3vY/a78ecJR4TMJ+6z60rfvQtu5D27pHTGvXePHiRXg+Wx1pq5eTJ0/aA7idOnWSbt26mbkcdG4FAIFd2bNHNnzwgZzbsMFpeYEWLczo2iSZM3usbgAARMug7UcffSRlypSRQoUKmZy2eiDw7bffmkm+fv75Z0mfPr0MGTJE3EXzimn6BX0cVa5cObl165bs3r3b5NNV69atMwcpWk+rjM7++/TpU4kdO7ZZppOMaY5cTY1glVm7dq2ZZM2iZXR5cBOk6SUgPSiK7AMjfR088bgxQcS3rY/9Wkx/vdhv3Ye2dR/a1n1oW/eISe3qzueoAwf0B/v+/fvL9OnTpXfv3qavCMDZvYsX5fcPP5SD336rQ23tyzNVrChVxo2TdA5zkQAAAGfh6s1myJDBBEg116yONtBTXr7//ntZsmSJNG3aVLZt2xamU8Xu3bsn+/btMxd16tQpc11PR9N1OrJBt3n69GkTVNVJ0HLlymUmCVP58+c3denQoYPs2LFD/vjjDzPyQU9b07qqZs2amUnI2rVrZ0YDa70nTpzoNEq2e/fuZqSETrR25MgRGTZsmOzatctsCwAAADGb9ke176ijb3WkrdXHBPCvJ/fvy5YRI2R67txycNYse8A2Wc6c8vrPP0vjjRsJ2AIA4M6RttYp3TrCQC+av1VHtb7oaXcaGK1atar9thVIbdWqlUyZMkX2799vRvLqaFoNwtasWVNGjhzpNMJ1zpw5Jriq6RK0Do0aNZIvvvjCvj5p0qSyatUq6dq1qxmNq0FlHQ3csWNHe5ny5cvL3LlzZdCgQWays9y5c8uiRYvMiGIAAADEPDpQwUqJcO7cOYkfP77Uq1dPGjdubFKGuTrjCohpbP7+cmj2bPl94EC5d+GCfXncpEml3JAhUqxbN/GLE8ejdQQAIMYEbR1psDY8qlSpYkbrBmXlypUhbiNFihQm4BocncDs999/D7bMW2+9ZS4AAACI2XTiWz3TS8/WqlOnjowdO9akBkuQIIGnqwZ4jfO//y7re/aUK7t325f5+PlJ0S5dTMA2AZP1AQAQeUHbESNGhCp32uDBg8PzMAAAAIDHFChQQIYPH25ScyVOnNjT1QG8yq0TJ2Rjv35y7OefnZbnqFdPKn/6qaTMl89jdQMAIMYGbTXXa3DBWh01S9AWAAAAUZnO1wDA2ePbt2XrRx/J3i++kOdPntiXpy5SRKp8/rlkrVHDo/UDACBGB201f62rZWfOnJHJkyfLpk2b5LfffgvPQwAAAACRSifBVTrRmOPtkFjlgejM/9kz2f/11/LHkCHy8Pp1+/IEadNKhY8+kkJt2oivn59H6wgAQHQQoTltlU7+lT17dvnss8+kefPm8t5774WYYxYAAADwFtmyZTNniz18+NDksbVuh+T58+eRUj/AU06tXCkbPvhAbhw8aF/mFzeulPzgAynTv7/EIX0IAADeG7R1VKlSJenXr587HwIAAACIUDNmzDBB2tixYzvdBmKqG4cPy4beveXU8uVOy/M1aSIVP/5YkmbN6rG6AQAQXbk1aLtr1y4z8hYAAACIKlq3bh3sbSCmeHjzpmwZNkz2/e9/YnMYSZ6udGmpOn68ZCxf3qP1AwAgOgtX0Pa7775zufzWrVsmn+0vv/wi7du3D89DAAAAAB7Vtm1beffdd6VMmTIu1+/YsUOmTp1qRuQC0SVv7Z/TpskfgwfLo5s37csTZ8pkRtbmb9pUfBicAwCA9wZtgxt1kCpVKunfv78MGTIkPA8BAAAAeNSsWbOkRo0aQQZtT506Jd9++y1BW0QLZ9evl3Xdu8v1v/6yL4uVIIHJWau5a2MnSODR+gEAEFOEK2irHdSANN9X8uTJJTFJ6AEAABADXLx4UeLHj+/pagDhcvv0aZO39tjPPzstz9+8uVQaO1YSZ8zosboBABAThStom5WE8wAAAIiGFi9ebC6WadOmyZo1a1ymBdPlpUqViuQaAhHjyf37suPjj2Xnp5/K88eP7cvTligh1b74gry1AABEx4nIAAAAgKjo0KFDsmDBAvuZZNu3b5fdu3c7ldHlCRMmlEqVKsm4ceM8VFPgxdhsNjk6f75s7N1b7p4/b1+eIE0aqThmjBRq3Zq8tQAARNWgra+vr+mshoWWf/bsWXgeFgAAAHCrAQMGmIvV5/3mm2+kWbNmnq4WECGu/fWXrHv/fTm3YYN9mW/s2FK8e3cpN2iQxE2a1KP1AwAA4Qza6iRjixYtkoMHD0qtWrUkb968ZvmRI0dk1apVUqhQIWnQoEFE1RUAAACIdP7+/p6uAhAhHt26JVuGDpW9kyeL7flz+/LsdepI1QkTJEWePB6tHwAAiKCgbYYMGeTq1aty4MABe8DWcvjwYalWrZop06FDh/A8DAAAAADgBdn8/eXArFmyqX9/eXjtmn150hw5pNqECZKjXr0wn0EJAADcK1xJij799FPp1q1boICtyp8/v1n3ySefhOchAAAAAI/77bff5JVXXpGUKVNKrFixxM/PL9AF8EaXdu6UOeXKycp27ewB21jx40uFjz6SNgcPSs7XXiNgCwBAdBtpe/78eYkdO3aQ63WdlgEAAACiqp9//lnefvttKViwoDRp0kSmTJli8tvqRE6LFy+W3LlzkxIMXufB9evy+4AB8tc33+isY/bled56S6p89pkkyZLFo/UDAABuHGmrOWv/97//yYULFwKt02CtritcuHB4HgIAAADwqDFjxkjp0qVl7969Mnz4cLOsbdu2MmfOHJMm7NKlS5I9e3ZPVxMw/J8/l31TpsiMPHnkr+nT7QHblAULyttr18rr8+cTsAUAILqPtB0/fryZgCxPnjzyxhtvSK5cuczyY8eOmQnKdPTB7NmzI6quAAAAQKQ7dOiQCdxqCgRNjaCePn1q/mfLlk26dOkiY8eOlZYtW3q4pojpLm7dKmu6dpWre/fal8VJkkTKDxsmxbp1E79gzpIEAADRKGhboUIF2b59uwwePFgWLlwoDx8+NMvjx49vgrk6EoGRtgAAAIjKEiRIIHHixDHXkyVLJnHjxjWjay1p06aVU6dOebCGiOnuX70qm/r1k4OzZjktL9CihVT+5BNJmC6dx+oGAAA8ELS1UiRowNbf31+u/ZfYPnXq1OLrG67MCwAAAIBX0El3dbStpWjRovL999/LO++8I8+ePZO5c+dKFk43hwf4P3tmUiH8MXiwPL5927489UsvSfUvv5RMFSp4tH4AAODFRVhkVYO08eLFk1SpUhGwBQAAQLShacB0wrHHjx+b2x9++KFs2LDBjLrVwQq///679O/f39PVRAxzYcsW+b5kSVn3/vv2gG3cpEml2qRJ0mLXLgK2AABEceGOru7atUtq165tThtLmTKlbNy40Sy/fv261K9f33RoAQAAgKiqd+/ecvbsWZMWQdWrV8/0cTt06CDvvvuurF27Vlq3bu3paiIGpUJY0bat/PDyy3Ltzz/tywu1aSNt//5binfrJr7/5V4GAABRV7i+zbds2SLVqlWTjBkzmtPDpuvspP/REbe3b9+Wr776SqpUqRIRdQUAAAC8QsWKFc0FiCz+z5/Ln1OnyuYPP5THt27Zl6cpWlRq/O9/kqFcOY/WDwAAeNFI24EDB0r+/PlNjq/Ro0cHWl+1alUzURkAAAAA4MVc37NH5pYtK2u7drUHbDUVguatfWfXLgK2AABEQ+Eaabtz504ZM2aMOVXs3r17gdbrCNzLly+H5yEAAACASJU9e3bx8fEJ0320/IkTJ9xWJ8RMT+7fl/U9e8pfX3/ttLxgq1ZSaexYSZg2rcfqBgAAvDhoGzt2bPH39w9y/YULFyRRokTheQgAAAAgUlWuXDnMQVsgot0+fVoWNWjglLc2dZEiUn3yZCYZAwAgBghX0LZs2bLy008/SY8ePQKtu3//vsycOdN0egEAAICoYtasWZ6uAmK4s+vWyZK335aHN26Y27ESJpQKH33EJGMAAMQg4cppO3z4cNm1a5fUrVtXfvvtN7Pszz//NBOSlShRQq5duyaDBw+OqLoCAAAAQLRls9lk98SJsqBmTXvANlnu3FJn+XIp/v77BGwBAIhBwvWtX6ZMGVm+fLl07txZWrZsaZZ98MEH5n/OnDnNuiJFikRMTQEAAAAP2LRpU6jKVapUye11QfT17NEjWd2pkxz89lv7sux16kid2bPlzpMnHq0bAACIQkFb/RX47t27Ur58eTl69Kjs27dPjh07ZnLcasBWR9qSCwwAAABRXZUqVULVr33+/Hmk1AfRz93z52Vxw4ZyeedO+7IyAwbIyyNH6ix3cufqVY/WDwAARKGg7ZMnTyRFihQyevRo6du3rxQtWtRcAAAAgOhk/fr1LgO0p0+flmnTpplBCx9//LFH6oao78Iff8jiRo3kwZUr5nasBAmk9syZku/tt83t4CZ+BgAA0dcLB23jxo0r6dKlM/8BAACA6Cq4iXVbt24tFStWlA0bNki1atUitV6I+vZ//bWs6dpV/J8+NbeTZMsmDRYtkjQvveTpqgEAgKg8EZl2Ur/77jsz6hYAAACIaXx9faVJkyZmIl4gtJ4/fWqCtas6drQHbLNUqyYtdu0iYAsAAMI/EVnhwoVl0aJFUrBgQRPAzZYtm8SPHz9QuYYNG4bnYQAAAACvdfPmTbl165anq4Eo4sG1a/Lrm2/KeYcJ7op37y5VPvtMfGOF6/AMAABEI+HqFTRt2tR+ffDgwS7L6KQNTMoAAACAqOrs2bMul2ugdtOmTfLpp5+aFAlASK7u2ycL69eXu//tU35x4sgrX30lhVq39nTVAABAVA/aDhw40JwCVqRIEZeTMgAAAADRiZ5NpgMRXLHZbFK2bFn56quvIr1eiFqOzJ8vK1q3lmcPH5rbCdOnlwYLF0r6MmU8XTUAABAdgrY6M26hQoVM0FYnZbhx44akSZNGVq9ezeQLAAAAiHZmzJgRKGirt5MnTy45c+aUAgUKeKxu8H42f3/ZPHiwbB892r5MA7X1f/lFEmXI4NG6AQAA7xUhSZN0hAEAAAAQHencDcCLeHznjixr3lxOLl1qX1awdWt5ZcoUiRUvnkfrBgAAvBuZ7gEAAAAggt06eVIWvvaa3Dh0yNz28fOTquPGSbH33gsy3QYAAICFoC0AAAAQgs2bN5s0CSdPnpR//vkn0JlmGoT7888/PVY/eJdzGzfKr40aycMbN8zteClSyGvz50vW6tU9XTUAABCdg7anT5+WPXv2mOu3b982/48dOybJkiVzWb548eLhqSMAAADgMePGjZM+ffpIvHjxJG/evJIiRYoI3f7kyZPl008/lcuXL8tLL70kkyZNktKlS7ssW6VKFdm4cWOg5a+++qosW7YsQuuFF7P/669lTZcu4v/smbmdIl8+eWPJEkmeK5enqwYAAKIQ3xe50+DBg6VUqVLmUqNGDbOsS5cu9mXWpWTJkuZ/aG3atElee+01yZAhgxmtsGjRIqf1OqJhyJAhkj59eokfP755bA0WO7p586Y0b95ckiRJYoLI7dq1k3v37jmV2b9/v1SsWNF0vDNnziyffPJJoLosWLBA8uXLZ8oULlxYli9fHsZWAgAAQHSgAdWXX35ZLl68aAYurF+/3uXlRfz444/Sq1cvGTp0qNm2Bm1r1aolV69edVn+l19+kUuXLtkvBw4cED8/P3nrrbfC+SwRXhqkXdejh6zq2NEesM1Wu7Y037aNgC0AAHD/SNuZM2eKu9y/f990VNu2bSsNGzYMtF6Dq1988YV8++23kj17dhM81k7toUOHTHBVacBWO7CrV6+Wp0+fSps2baRjx44yd+5cs/7OnTtSs2ZNE/CdOnWq/PXXX+bxNMCr5dSWLVukadOmMmbMGKlXr565b4MGDUxHulChQm57/gAAAPA+Dx48MH3MpEmTumUUb4cOHUyfVWn/VEfMaiqG/v37ByofcJTvvHnzJEGCBARtPezx7duypHFjOb1ypX1ZiR49pPKnn4pvLDLSAQCAsAtzD6JVq1biLnXq1DEXV3SU7YQJE2TQoEFSv359s+y7776TtGnTmhG5TZo0kcOHD8uKFStk586dZpSv0tPL9HSxzz77zIzgnTNnjjx58sR0hOPEiSMFCxaUffv2mQ6zFbSdOHGi1K5d25wGp0aOHGmCwF9++aXpSAMAACDmqFq1qvmhP6Jpn3T37t0yYMAA+zJfX18zuGDr1q2h2sY333xj+sEJEyYMsszjx4/NxaKDGJS/v7+5uJs+hvblI+OxPOGf48dlcf36cvPIEXNbg7TVJ0+Wwu3bm9vhfd7Rvf0iA20YPrRf+NGG4UP7hR9t6F3tF9rtRJmffU+dOmXyfFnpGJSOdihTpozp1GpnVf/riFkrYKu0vHZ+t2/fLm+88YYpU6lSJROwteho3bFjx5pJJZInT27K6GlqjrRMwHQNAAAAiP50EICeqaWDAPQMrYjKaXv9+nV5/vy5GYTgSG8f+S8AGJwdO3aY9AgauA2Onj02fPjwQMuvXbsmjx49EnfTAxOdB0MPdrRfHp1c/uMP2dS+vTy5dcvcjps8uVSaPl3Sli8fZIqLsIrO7RdZaMPwof3CjzYMH9ov/GhD72q/u3fvRq+grQZslatOrbVO/6dJk8ZpfaxYsUzH2rGMplYIuA1rnQZt9X9wj+ONIxgs/HoS1dr2/2eejsmvGfut+9C27kPbug9t6x4xrV0j8nnqHAjvvvuu9O7dW/r162fScmkeWUc6H4M1QW9k0WCtzr0Q1KRlFh3J6zggQfup+pxSp05t5oGIjNdC20cfLzodKO6fNk3WvfeePX9tygIFpP7ixZIsR44IfZzo2n6RiTYMH9ov/GjD8KH9wo829K72s1K8Rpugrbfz9AgGC7+eRK22Ter7/4H+iBqNERWx37oPbes+tK370LbuEdPaNbQjGEJDJ8IdNWqUZMyY0ZzRFVG5bVOlSmWCv1euXHFarrfTpUsX4lwQms92xIgRIT5O3LhxzSUg3Q8ia1/QA53IfDx30iDtht69Zc/EifZl2V99Ver98IPEdVMQPDq1n6fQhuFD+4UfbRg+tF/40Ybe036h3UaUCdpaHVftxKZPn96+XG8XLVrUXiZg4OvZs2dy8+ZN+/31v6uOseNjBFUmuM6zp0cwWPj1JGq17W3/s/brAUeJxyTst+5D27oPbes+tK17xLR2De0IhtDQOQ3q1q1rUmVFZNtpuq4SJUrI2rVrzaS31uukt7t16xbsfRcsWGDO8nrnnXcirD4I3YRjS5s2lVO//WZfVqJXL6n8ySfiG2D0NQAAQHhEmaCtpjTQoKl2Yq0grQZGNVdt586dze1y5crJrVu3zIQO2gFW69atM51fzX1rlfnwww/l6dOnEjt2bLNMJxnLmzevSY1gldHH6dGjh/3xtYwu9+YRDBZ+PYlKbetjvxbTXy/2W/ehbd2HtnUf2tY9YlK7RuRz1AnDNGjrjnbTH/11ol8dwatpDnTiXR1F26ZNG7O+ZcuWZoSvntUVMDWCBnpTpkwZ4XWCa7dOnpSFr70mNw4dsk84VmPKFCny34RjAAAA0TZoe+/ePTl+/LjT5GP79u0zOWmzZMligqgfffSR5M6d2wRxBw8eLBkyZLCPTMifP7/Url1bOnToYEZEaGBWRynoJGVaTjVr1sykMWjXrp3JSaaTN0ycOFHGjx9vf9zu3btL5cqV5fPPPzcddD31bNeuXTJt2jQPtAoAAAA8qV69evL777+bvLYRrXHjxiadlqZg0PkTdHDCihUr7PMrnD17NlCw+OjRo7J582ZZtWpVhNcHrp3btEl+bdhQHt64YW7HS5FCXv/5Z8lSpYqnqwYAAKIprwraamC0atWq9ttWugEdfTBr1izp27evGXnQsWNHM6K2QoUKplPrePrbnDlzTKC2evXqpoPbqFEj+eKLL+zrNQeZdnC7du1qRuNqLjHtJOs2LeXLl5e5c+fKoEGDZODAgSZIrKfDFSpUKNLaAgAAAN5h6NChJrjapUsX88O/DiYIOBGZ0oEGL0L7rkGlQ9iwYUOgZXqGmOYmRuT4a+ZMWf3uu+L/9Km5nSJfPnljyRJJniuXp6sGAACiMa8K2lapUiXYDqie0qeTLQQ34YJ2ljXgGpwiRYqY0RLBeeutt8wFAAAAMZsGSZWeAfbVV18FWe758+eRWCu4m83fX37/8EPZ8fHH9mXZataUej/+KPGSJfNo3QAAQPTnVUFbAAAAwNvoWVk6eAAxx7PHj2VF69ZyZN48+7Ji3bpJ1fHjTS5bAAAAd6PHAQAAAARj2LBhnq4CItHDmzdlcYMGcv6/M/N8fH2l6sSJUjyIFBYAAADuQNAWAAAAAETk1smT8surr8rNo0fN7VgJEshr8+ZJztde83TVAABADEPQFgAAAAhGcPMpWDR9wuDBgyOlPnCPS9u3yy+vvSYPr10ztxOkTSsNly6VdCVLerpqAAAgBiJoCwAAALxgegQN1upEugRto7ZjCxfKsubN5dnDh+Z2ivz5pdHy5ZI0WzZPVw0AAMRQvp6uAAAAAODN/P39A12ePXsmJ06ckJ49e0rJkiXl6tWrnq4mXtDuCRNkcaNG9oBtpsqVpdkffxCwBQAAHkXQFgAAAAgjX19fyZ49u3z22WeSO3duee+99zxdJbyALcOHy/qePUVsNnO7wDvvyJsrV0q85Mk9XTUAABDDEbQFAAAAwqFSpUqyfPlyT1cDYbRr/HjZ4pD6ouygQVLnu+8kVty4Hq0XAACAIqctAAAAEA67du0yI28Rdfz1zTeyoVcv++2q48dLiR49PFonAAAARwRtAQAAgGB89913LpffunVLNm3aJL/88ou0b98+0uuFF3N0wQJZ1bGj/Xb54cMJ2AIAAK9D0BYAAAAIRuvWrYNclypVKunfv78MGTIkUuuEF3Pyt99kWfPmYvP3N7dL9Owp5QYP9nS1AAAAAiFoCwAAAATj1KlTgZb5+PhI8uTJJXHixB6pE8Lu/O+/y6+NGon/06fmduF27aTK55+b1xIAAMDbELQFAAAAgpE1a1ZPVwHhdGXPHvmlXj159vChuZ3nrbfkla++ImALAAC8FjMmAAAAAAE8evRIOnXqJJMmTQq23BdffCGdO3eWp/+N3oT3uXH4sPxUq5Y8uXPH3M5Wu7bUnT1bfP38PF01AACAIBG0BQAAAAKYNm2azJo1S+rWrRtsOV0/c+ZMmT59eqTVDaF3+8wZWfDKK/Lw+nVzO2OFClL/55/FL04cT1cNAAAgWARtAQAAgADmz58vjRo1khw5cgRbLmfOnPLWW2/JDz/8EGl1Q+g8e/xYfm3YUO5duGBupy1eXBouXSqxEyTwdNUAAABCRNAWAAAACOCvv/6SChUqhKps+fLlZf/+/W6vE8Lm9wEDTC5blSxXLmm0YoXETZrU09UCAAAIFYK2AAAAQABPnjyROKE8hV7LPX782O11QuidWLpUdo8fb65rKoTXFyyQBKlTe7paAAAAoUbQFgAAAAggQ4YMcuDAgVCV1XJaHt7h7oULsqJ1a/vtyp9/LmmKFvVonQAAAMKKoC0AAAAQQI0aNeS7776Tq1evBltO12u5V155JdLqhqD5P38uy995Rx7euGFu56pfX4p17erpagEAAIQZQVsAAAAggH79+smjR4+kWrVqsn37dpdldHn16tVNuT59+kR6HRHY9tGj5dyGDeZ64kyZpNaMGeLj4+PpagEAAIRZrLDfBQAAAIjecuTIIfPnz5emTZuaicb0duHChSVx4sRy9+5dkxLhxIkTkiBBApk3b57kzJnT01WO8c7//rtsGTbMXPfx9ZW6c+dK/BQpPF0tAACAF0LQFgAAAHChbt26sn//fhk7dqwsXbpUFi1aZF+nOWw7dOggffv2NQFdeJamQ1jWrJnY/P3N7fLDhkmmihU9XS0AAIAXRtAWAAAACEK2bNlkypQp5qIjbO/cuSNJkiQxI27hHWw2m6xo21bunj9vbmeuUkXKDBzo6WoBAACEC0FbAAAAIBQ0UEuw1vvs/fJLOfHrr+Z6/FSppO6cOeLr5+fpagEAAIQLE5EBAAAAiJKu7N0rG3v3tt+uPWuWJMqQwaN1AgAAiAgEbQEAAABEOc+fPJHfWrY0/1WJnj0lZ926nq4WAABAhCBoCwAAACDK2TZ6tFw/cMBcT1O0qFQcM8bTVQIAAIgwBG0BAAAARCnX9u+X7aNGmeu+sWJJ7ZkzJVbcuJ6uFgAAQIQhaAsAAAAgyvB/9kxWtG1r/qvS/fqZkbYAAADRCUFbAAAAAFHGrnHj5Mru3eZ6ivz5pezgwZ6uEgAAQIQjaAsAAAAgSrj599+yZejQf2/4+EjtGTNIiwAAAKIlgrYAAAAAvJ7N319Wtmsnzx49MrdL9OghGcqW9XS1AAAA3IKgLQAAAACvt2/KFLmwebO5njRHDqnw0UeerhIAAIDbELQFAAAA4NVunz4tm/r1s9+uNX26xE6QwKN1AgAAcCeCtgAAAAC8ls1mk1UdO8rT+/fN7SIdO0qWqlU9XS0AAAC3ImgLAAAAwGsdmDVLzqxeba4nyphRKn/yiaerBAAA4HYEbQEAAAB4pXuXLsmGXr3st1/56iuJmzSpR+sEAAAQGQjaAgAAAPBKGz74QB7fumWu52/eXHLWrevpKgEAAEQKgrYAAAAAvM7Nv/+WI/PmmevxU6WSqhMmeLpKAAAAkYagLQAAAACvs1Nz19ps5nrJDz6QBKlSebpKAAAAkSZKBW2HDRsmPj4+Tpd8+fLZ1z969Ei6du0qKVOmlESJEkmjRo3kypUrTts4e/as1K1bVxIkSCBp0qSRPn36yLNnz5zKbNiwQYoXLy5x48aVXLlyyaxZsyLtOQIAAAAx3d3z5+Xgd9+Z65rDtmjnzp6uEgAAQKSKUkFbVbBgQbl06ZL9snnzZvu6nj17ypIlS2TBggWyceNGuXjxojRs2NC+/vnz5yZg++TJE9myZYt8++23JiA7ZMgQe5lTp06ZMlWrVpV9+/ZJjx49pH379rJy5cpIf64AAABATLTr88/F/+lTc71o165MPgYAAGKcWBLFxIoVS9KlSxdo+e3bt+Wbb76RuXPnSrVq1cyymTNnSv78+WXbtm1StmxZWbVqlRw6dEjWrFkjadOmlaJFi8rIkSOlX79+ZhRvnDhxZOrUqZI9e3b5/PPPzTb0/hoYHj9+vNSqVSvSny8AAAAQkzy4fl3+nDbNXI8VL54U797d01UCAACIdFFupO2xY8ckQ4YMkiNHDmnevLlJd6B2794tT58+lRo1atjLauqELFmyyNatW81t/V+4cGETsLVoIPbOnTty8OBBexnHbVhlrG0AAAAAcJ+9kybJswcPzPXCHTpIwjRpPF0lAACASBelRtqWKVPGpDPImzevSY0wfPhwqVixohw4cEAuX75sRsomS5bM6T4aoNV1Sv87Bmyt9da64MpoYPfhw4cSP358l3V7/PixuVi0vPL39zeXyKKPZbPZIvUxYwr3tK3NafsxFfut+9C27kPbug9t6x4xrV1jyvOMbp7cvSt7vvjCXPeNFUtK9e7t6SoBAAB4RJQK2tapU8d+vUiRIiaImzVrVpk/f36QwdTIMmbMGBNEDujatWtmgrTIPEDRVBF6UObrG+UGUns1d7RtUt//D/RfvXpVYir2W/ehbd2HtnUf2tY9Ylq73r1719NVwAv486uv5PGtW+Z6/ubNJUmWLJ6uEgAAgEdEqaBtQDqqNk+ePHL8+HF55ZVXzARjt27dchpte+XKFXsOXP2/Y8cOp23oemud9d9a5lgmSZIkwQaGBwwYIL169XIaaZs5c2ZJnTq1uW9kHpD5+PiYx40JB2SRyR1te9v/3/QeKk0MPvWP/dZ9aFv3oW3dh7Z1j5jWrvHixfN0FRBGzx49MhOQGT4+UrpfP09XCQAAwGOidND23r17cuLECWnRooWUKFFCYseOLWvXrpVGjRqZ9UePHjU5b8uVK2du6/9Ro0aZEY1WgGz16tUmqFqgQAF7meXLlzs9jpaxthGUuHHjmktAelAU2QdGekDmiceNCSK+bX3s12L668V+6z60rfvQtu5D27pHTGrXqPQcJ0+eLJ9++qlJ0/XSSy/JpEmTpHTp0kGW10EKH374ofzyyy9y8+ZNc+bZhAkT5NVXX5Wo7OC338r9/1KW5X7jDUmZP7+nqwQAAOAxUac3KyK9e/eWjRs3yunTp2XLli3yxhtviJ+fnzRt2lSSJk0q7dq1M6Nd169fbyYma9OmjQm2li1b1ty/Zs2aJjirQd4///xTVq5cKYMGDZKuXbvaA66dOnWSkydPSt++feXIkSPyv//9z6Rf6Nmzp4efPQAAAKKbH3/80fRfhw4dKnv27DFBW50EN6i0SXpmmZ5hpv3hn376yQxS+PrrryVjxowSlfk/eyY7PvnEfrvMgAEerQ8AAICnRamRtufPnzcB2hs3bphT+ypUqCDbtm0z19X48ePNqAodaauTgmmHV4OuFg3wLl26VDp37myCuQkTJpRWrVrJiBEj7GWyZ88uy5YtM0HaiRMnSqZMmWT69OlmWwAAAEBEGjdunHTo0MEMNlBTp041fdEZM2ZI//79A5XX5Tq6Vgcw6FlmKlu2bBLVHZ0/X26fPGmuZ33lFUlXsqSnqwQAAOBRUSpoO2/evBBzl+npZXoJip4+FjD9QUBVqlSRvXv3vnA9AQAAgJDoqFk9O0znRrDoAIQaNWrI1q1bXd7n119/NYMP9EyxxYsXm8ELzZo1k379+pkBClGRTo63/eOP7bcZZQsAABDFgrYAAABAdHH9+nV5/vy5pE2b1mm53tY0Xa5oGq9169ZJ8+bNzUAEnZC3S5cu8vTpU5NiwRU9A00vjhPmWpPT6cXd9DE0MBvUY51culSu//WXuZ6+bFnJWKlSpNQrqgip/RAy2jB8aL/wow3Dh/YLP9rQu9ovtNshaAsAAABEEdrJ1wl1p02bZkbW6mS8Fy5cMBOZBRW0HTNmjAwfPjzQ8mvXrsmjR48ipc63b982BzsBJ4jTZZtHjrTfztOpk6kXQtd+CB3aMHxov/CjDcOH9gs/2tC72u/u3buhKkfQFgAAAPCAVKlSmcDrlStXnJbr7XTp0rm8T/r06U0uW8dUCPnz55fLly+bdAtx4sQJdB9Nv6CTnTmOtM2cObNJrZAkSRKJjAMdHx8f83gBD3TObdwo13ftMtdTFiwoxZs3Fx8OJkPdfggd2jB8aL/wow3Dh/YLP9rQu9pP07uGBkFbAAAAwAM0wKojZdeuXSsNGjSwHxTo7W7durm8z8svvyxz58415ayDhr///tsEc10FbFXcuHHNJSC9f2QduOmBjqvH2/355065bP1icXgSlvZD6NGG4UP7hR9tGD60X/jRht7TfqHdBq8UAAAA4CE6Avbrr7+Wb7/9Vg4fPiydO3eW+/fvS5s2bcz6li1bOk1Uputv3rwp3bt3N8HaZcuWyejRo83EZFHNk7t35fSqVeZ64kyZJF/jxp6uEgAAgNfgp2wAAADAQxo3bmxyuA4ZMsSkOChatKisWLHCPjnZ2bNnnUZjaFqDlStXSs+ePaVIkSKSMWNGE8Dt16+fRDVn160T/6dPzfUcr70mvoyyBQAAsKNnBAAAAHiQpkIIKh3Chg0bAi0rV66cbNu2TaK6k8uX26/nePVVj9YFAADA25AeAQAAAECk0tmXT/32m7nuFyeOZK5a1dNVAgAA8CoEbQEAAABEqusHD8rdc+fM9cxVqkichAk9XSUAAACvQtAWAAAAQKQ65ZAaITupEQAAAAIhaAsAAAAgUlmpEVT2OnU8WhcAAABvRNAWAAAAQKR5fOeOXNi82VxPljOnJM+d29NVAgAA8DoEbQEAAABEmjNr1oj/s2f2UbY+Pj6erhIAAIDXIWgLAAAAINKQzxYAACBkBG0BAAAARAqbzWbPZxsrXjzJXKWKp6sEAADglQjaAgAAAIgU1/bvl3sXL5rrmatWldjx43u6SgAAAF6JoC0AAACASEFqBAAAgNAhaAsAAAAgUlipEVQOgrYAAABBImgLAAAAwO0e/fOPXNiyxVxPniePJMuRw9NVAgAA8FoEbQEAAAC43ZnVq8X2/Lm5zihbAACA4BG0BQAAAOB2p1essF/PXqeOR+sCAADg7QjaAgAAAHArm7+/nPovaBsrQQLJVKmSp6sEAADg1WJ5ugIAAMREQ+btdLo9okkpj9UFANzt5oED8uDKFXM9a/XqEitePE9XCQAAwKsx0hYAAACAW11cu9Z+ndQIAAAAISNoCwAAAMCtLqxbZ79O0BYAACBkBG0BAAAAuM3DGzfkxp495nqK/PklabZsnq4SAACA1yNoCwAAAMBtzqxaZSYiUzlefdXT1QEAAIgSCNoCAAAAcJtTK1bYrxO0BQAACB2CtgAAAADcQkfYnv4vaBs7USLJWKGCp6sEAAAQJRC0BQAAAOAWl3ftkofXr5vrWapXF784cTxdJQAAgCiBoC0AAAAAtzj122/269lr1/ZoXQAAAKKSWJ6uAAAAQGQbMm+n/fqIJqU8WhcgOju5fLn9evY6dTxaFwAAgKiEkbYAAAAAItyDa9fk8s5/fyBJlj+/JM6c2dNVAgAAiDIYaQsAAAAgwsVLkUKabt5sRtv6J0rk6eoAAABEKQRtAQAAAEQ4Xz8/yVi+vKQvW1auXr3q6eoAAABEKQRtAQCIBORQBQAAAACEFkFbAECoAo2KYCMAAAAAAO7HRGQAAAAAAAAA4EUYaQtEEE59BgAAAAAAQERgpC0AAAAAAAAAeBFG2gKIciJrVDOjp727nci3i4jE/gQAAADAmzDSNgSTJ0+WbNmySbx48aRMmTKyY8cOT1cJAAAAAAAAQDTGSNtg/Pjjj9KrVy+ZOnWqCdhOmDBBatWqJUePHpU0adJ4unpRWmSOaIqIUYD/bsMmSX0fS88308SIkV8B2y00dYnuI1NdtcGLPGdvaidvqktIwtvWob0fIy4jrt1e/DWL/M/b0IhK73f2YwAAACBqI2gbjHHjxkmHDh2kTZs25rYGb5ctWyYzZsyQ/v37e7p6XiOiDtQjizfXLSJ4+4F6SO3v7fVH9HsPRfd90pt/bIhqP+AFt83QbtebfgCL6vs2AAAAEJ0RtA3CkydPZPfu3TJgwAD7Ml9fX6lRo4Zs3bpVogIOxhAVePOoOrhPdAv8wn34Lov6eA0BAACAsCNoG4Tr16/L8+fPJW3atE7L9faRI0cClX/8+LG5WG7fvm3+37p1S/z9/SOhxiJjftlj/ifxfSydXy8jjx/cdVqvdbHKqAENi4dpu0Hdx9XjOC7T26G5j7sErEtIdQtuG498H5v7aAA/pMcJrh2ttnRHO0VU2wbXbkFtN+B9QvOcA7btizzOi3BVt5Ae50X2dVciov6hpZ8/d+7ckThx4rzQfhua5xya1z2sj+uOfTI0ZVxtNyBrGyG1bUTUPyJE1Gd0RNwn4L4R0It+JoRGSPttROwr7rrPi3D1OAH3WU/ug5FBn6uy2WyR8nhRidUmVhu5m+57d+/eNXNEhObzEs5ov/CjDcOH9gs/2jB8aL/wow29q/1C20/1sdGTdenixYuSMWNG2bJli5QrV86+vG/fvrJx40bZvn27U/lhw4bJ8OHDPVBTAAAABOXcuXOSKVMmT1fDq5w/f14yZ87s6WoAAADEaOdC6Kcy0jYIqVKlEj8/P7ly5YrTcr2dLl26QOU1jYJOWuYYhb9586akTJlSfHx8JLJotF474frCJ0mSJNIeNyagbd2HtnUf2tZ9aFv3oW3dI6a1q45L0BERGTJk8HRVvI62ie4HiRMnjpR+akzb9yIa7Rd+tGH40H7hRxuGD+0XfrShd7VfaPupBG2DoKcOlihRQtauXSsNGjSwB2L1drdu3QKVjxs3rrk4SpYsmXiK7kS8Ed2DtnUf2tZ9aFv3oW3dh7Z1j5jUrkmTJvV0FbySntbnidHHMWnfcwfaL/xow/Ch/cKPNgwf2i/8aEPvab/Q9FMJ2gZDR862atVKSpYsKaVLl5YJEybI/fv3pU2bNp6uGgAAAAAAAIBoiqBtMBo3bizXrl2TIUOGyOXLl6Vo0aKyYsWKQJOTAQAAAAAAAEBEIWgbAk2F4CodgrfSFA1Dhw4NlKoB4Ufbug9t6z60rfvQtu5D27oH7QpPYd8LH9ov/GjD8KH9wo82DB/aL/xow6jZfj42zX4LAAAAAAAAAPAKvp6uAAAAAAAAAADg/xG0BQAAAAAAAAAvQtAWAAAAAAAAALwIQdtoZPLkyZItWzaJFy+elClTRnbs2OHpKkU5Y8aMkVKlSknixIklTZo00qBBAzl69KhTmUePHknXrl0lZcqUkihRImnUqJFcuXLFY3WOqj7++GPx8fGRHj162JfRti/uwoUL8s4775i2ix8/vhQuXFh27dplX6/py4cMGSLp06c362vUqCHHjh3zaJ2jgufPn8vgwYMle/bspt1y5swpI0eONO1poW1DZ9OmTfLaa69JhgwZzHt/0aJFTutD0443b96U5s2bS5IkSSRZsmTSrl07uXfvnsR0wbXt06dPpV+/fuYzIWHChKZMy5Yt5eLFi07boG3hLvRPI/dzMiajHx8+U6ZMkSJFipjvAb2UK1dOfvvtN/t62i7sON4Ju2HDhpk2c7zky5fPvp72CxnHheGjfZaA+6BedL/zxD5I0Daa+PHHH6VXr15mNrs9e/bISy+9JLVq1ZKrV696umpRysaNG80bcNu2bbJ69WpzsFuzZk25f/++vUzPnj1lyZIlsmDBAlNeD3wbNmzo0XpHNTt37pSvvvrKdAwd0bYv5p9//pGXX35ZYseObTrXhw4dks8//1ySJ09uL/PJJ5/IF198IVOnTpXt27eb4I1+RuiXDoI2duxYcxDz5ZdfyuHDh81tbctJkybZy9C2oaOfo/rdpAEcV0LTjhpUPHjwoPl8Xrp0qQlwdOzYUWK64Nr2wYMHpl+gPz7o/19++cUEMV5//XWncrQt3IH+aeR/TsZk9OPDJ1OmTCbIuHv3bhPgqVatmtSvX998NyjaLmw43nlxBQsWlEuXLtkvmzdvtq+j/YLHcWHEvHcd9z/9PlFvvfWWZ/ZBG6KF0qVL27p27Wq//fz5c1uGDBlsY8aM8Wi9orqrV6/qcDrbxo0bze1bt27ZYseObVuwYIG9zOHDh02ZrVu3erCmUcfdu3dtuXPntq1evdpWuXJlW/fu3c1y2vbF9evXz1ahQoUg1/v7+9vSpUtn+/TTT+3LtL3jxo1r++GHHyKpllFT3bp1bW3btnVa1rBhQ1vz5s3Nddr2xej7euHChfbboWnHQ4cOmfvt3LnTXua3336z+fj42C5cuBDJzyDqtK0rO3bsMOXOnDljbtO2cBf6p5H7OQln9OPDL3ny5Lbp06fTdmHE8c6LGzp0qO2ll15yuY72CxnHhRFP3785c+Y0beeJfZCRttHAkydPzC+iOqzd4uvra25v3brVo3WL6m7fvm3+p0iRwvzXdtZf7R3bWk/XyJIlC20dSjoCom7duk5tqGjbF/frr79KyZIlza9/ejpgsWLF5Ouvv7avP3XqlFy+fNmpbZMmTWpOU6Vtg1e+fHlZu3at/P333+b2n3/+aX7tr1OnjrlN20aM0LSj/tfT9nVft2h5/b7TUQII23ebnual7aloW7gD/dOIxfdN2NGPD196qHnz5plRypomgbYLG453wkdP1dc0MTly5DBnAp09e9Ysp/1CxnFhxPdlZs+eLW3btjV9Z0/sg7HcslVEquvXr5sv1rRp0zot19tHjhzxWL2iOn9/f5N/SE8vKFSokFmmH3Bx4sSxH+g6trWuQ/C086enR+opBwHRti/u5MmT5hR+PQV14MCBpn3ff/99056tWrWyt5+rzwjaNnj9+/eXO3fumC9jPz8/81k7atQo04FUtG3ECE076n/tfDqKFSuWORinrUNPT33THLdNmzY1OQsVbQt3oH8asfi+CRv68S/mr7/+MkFa/a7QXI0LFy6UAgUKyL59+2i7UOJ4J3w0eDhr1izJmzevOTV9+PDhUrFiRTlw4ADtFwocF0YszS1/69Ytad26tbntiX2QoC0QzC+k+uXgmEMHL+7cuXPSvXt3kxNGJyNBxB6Y6C+qo0ePNrf1F1XddzVPkX4548XNnz9f5syZI3PnzjX5tfSgRQ8C9dd/2hZRjY4MePvtt80EFNqhB4Doin78i9FAmfZ1dJTyTz/9ZPo6mrMRocPxTvhZZ7MpzQesQdysWbOaPrlOmoXgcVwYsb755huzT+qxn6eQHiEaSJUqlRkBFnDGOr2dLl06j9UrKuvWrZuZiGX9+vUmKb9F21OHyOuvLY5o65DpqQQ68Ujx4sXNCC69aCdQk6Drdf11irZ9MTrzp46CcJQ/f377qURW+/EZEXZ9+vQxo22bNGliZl5t0aKFST6vM1Qr2jZihKYd9X/AyYuePXsmN2/epK3DELA9c+aMOZi0Rtkq2hbuQP80YvF9E3r041+cjiDLlSuXlChRwvR1dGK8iRMn0nahxPFOxNMRjXny5JHjx4+zH4YCx4URR/vMa9askfbt29uXeWIfJGgbTb5c9YtV8y46/sKit/X0FoSejj7Sjp6eCrRu3TrJnj2703ptZ52J0bGtdRZu/RCkrYNXvXp1c8qV/npvXfRXQD3N3LpO274YPfVP28qR5mDVX6WV7sf6JeLYtnrKv+aqpG2D9+DBA5OD0ZEGIfQzVtG2ESM07aj/tYOkB0QW/ZzW10JHYSDkgK3miNPOZ8qUKZ3W07ZwB/qnEYvvm5DRj494+p59/PgxbRdKHO9EvHv37smJEydMMJL9MGQcF0acmTNnmvRhmp/a4pF90C3TmyHSzZs3z8z4N2vWLDMLdMeOHW3JkiWzXb582dNVi1I6d+5sS5o0qW3Dhg22S5cu2S8PHjywl+nUqZMtS5YstnXr1tl27dplK1eunLkg7BxnU1W07YvRmeBjxYplGzVqlO3YsWO2OXPm2BIkSGCbPXu2vczHH39sPhMWL15s279/v61+/fq27Nmz2x4+fOjRunu7Vq1a2TJmzGhbunSp7dSpU7ZffvnFlipVKlvfvn3tZWjb0M+kvHfvXnPR7se4cePM9TNnzoS6HWvXrm0rVqyYbfv27bbNmzebmZmbNm1qi+mCa9snT57YXn/9dVumTJls+/btc/pue/z4sX0btC3cgf5p5H9OxmT048Onf//+to0bN5r+ju5fetvHx8e2atUqs562ezEc74TNBx98YN7Duh/+8ccftho1api+99WrV8162i94HBdGjOfPn5v9rF+/foHWRfY+SNA2Gpk0aZLZeeLEiWMrXbq0bdu2bZ6uUpSjHWRXl5kzZ9rL6IdZly5dbMmTJzcfgG+88YbpECL8nRja9sUtWbLEVqhQIXNwnC9fPtu0adOc1vv7+9sGDx5sS5s2rSlTvXp129GjRz1W36jizp07Zh/Vz9Z48eLZcuTIYfvwww+dgl20beisX7/e5eerBsZD2443btwwgcREiRLZkiRJYmvTpo0JcsR0wbWtHvQE9d2m97PQtnAX+qeR+zkZk9GPD5+2bdvasmbNat6rqVOnNvuXFbBVtN2L4XgnbBo3bmxLnz692Q914ITePn78uH097RcyjgvDb+XKleb7w1W7RPY+6KN/3DOGFwAAAAAAAAAQVuS0BQAAAAAAAAAvQtAWAAAAAAAAALwIQVsAAAAAAAAA8CIEbQEAAAAAAADAixC0BQAAAAAAAAAvQtAWAAAAAAAAALwIQVsAAAAAAAAA8CIEbQEAAAAAAADAixC0BQAvkC1bNmndunWY73f69Gnx8fGRzz77TCLbrFmzzGPv2rVLvIXWZ9iwYZ6uBgAAANzU//VW2g/t1q2bp6sBIBohaAsAwThx4oS8++67kiNHDokXL54kSZJEXn75ZZk4caI8fPjQ09WLsjZs2GA6tj/99JOnqwIAAIBo0P+tUqWK6V9al/jx40uRIkVkwoQJ4u/v7+nqAUCYxQr7XQAgZli2bJm89dZbEjduXGnZsqUUKlRInjx5Ips3b5Y+ffrIwYMHZdq0aZ6uJgAAABAhonr/N1OmTDJmzBhz/fr16zJ37lzp2bOnXLt2TUaNGuXp6gFAmBC0BQAXTp06JU2aNJGsWbPKunXrJH369PZ1Xbt2lePHj5tOLQAAABAdRIf+b9KkSeWdd96x3+7UqZPky5dPJk2aJCNGjBA/Pz+P1g8AwoL0CADgwieffCL37t2Tb775xqnDasmVK5d0797dfvvZs2cycuRIyZkzpxmZoDm6Bg4cKI8fP3a6n81mk48++siMAkiQIIFUrVrVjFhw5datW9KjRw/JnDmz2aY+5tixY4M8vWv8+PGmk62nglWuXFkOHDgQqIx2wCtWrCgJEyaUZMmSSf369eXw4cOByu3du1fq1KljTodLlCiRVK9eXbZt2xZiu/3zzz9SunRp8/yOHj0qYaG5aPVUNj0g0PxmWj/teLdp00YePHjgVFbbVUdNpE6dWhInTiyvv/66nD9/3uV2L1y4IG3btpW0adOadixYsKDMmDHDvl5P89POvF4cT/m7efOmee3Lly8vz58/D9NzAQAAiGqiYv83JJreoVSpUnL37l25evWqffn+/ftNf9NKAZEuXTrTX7xx48YL909d0eft6+trgsYAEFaMtAUAF5YsWWI6cRqwC4327dvLt99+K2+++aZ88MEHsn37dnNqlgZEFy5caC83ZMgQ03l79dVXzWXPnj1Ss2ZNc9qZI+0EauBVA46aUyxLliyyZcsWGTBggFy6dMnk5nL03Xffmc6ojoJ49OiRyTlWrVo1+euvv0ywUq1Zs8YEYvV5aQdUA5TagdQcZVoP7Wgr7URrYFcDtn379pXYsWPLV199ZfKEbdy4UcqUKeOyDfQUtFdeecUEO7WcduBfxNtvvy3Zs2c37af1mj59uqRJk8Z02B3be/bs2dKsWTPzGmkwum7duoG2deXKFSlbtqx9YggN8v7222/Srl07uXPnjjko0CC3vnbaDh9++KGMGzfO3Ffb8vbt22bCNUZlAACA6C6q9X/DOnGvBlwtq1evlpMnT5rgqwZsrbQP+l8HKmj5sPZPAxo0aJCMHj3a9KM7dOjwQnUHEMPZAABObt++bdOPx/r164eq/L59+0z59u3bOy3v3bu3Wb5u3Tpz++rVq7Y4ceLY6tata/P397eXGzhwoCnXqlUr+7KRI0faEiZMaPv777+dttm/f3+bn5+f7ezZs+b2qVOnzH3jx49vO3/+vL3c9u3bzfKePXvalxUtWtSWJk0a240bN+zL/vzzT5uvr6+tZcuW9mUNGjQw9Txx4oR92cWLF22JEye2VapUyb5s5syZ5jF27txpu3Tpkq1gwYK2HDly2E6fPh1im61fv97cd8GCBfZlQ4cONcvatm3rVPaNN96wpUyZMlB7d+nSxalcs2bNzHLdjqVdu3a29OnT265fv+5UtkmTJrakSZPaHjx4YF82YMAA0xabNm0y9dJtTZgwIcTnAgAAENVFpf5vUCpXrmzLly+f7dq1a+Zy5MgRW58+fczj6OM7cuwDWn744QdTVvuCYe2fKi3XtWtXc/2DDz4w/cpZs2YFW2cACA7pEQAgAB2BqfS0+9BYvny5+d+rVy+n5TriQFm5v3Skq44oeO+995x+vdfRngEtWLDAjHZNnjy5GcFqXWrUqGFO1d+0aZNT+QYNGkjGjBnttzVFgY6IteqmoxP27dtnTutKkSKFvZzOqKujY61yuu1Vq1aZ7elIC4ueIqejWnUSCqt9LJqWQEdFPH361NRLUzSEh+Yec6TtoKeqWY9r1fX99993KhewHbXv/PPPP8trr71mrju2Y61atcwoWh0pYdHRx5o6oVWrVtKlSxfznAI+BgAAQHQUFfu/rhw5csScWaUXTX316aefmjRaeuaUIz3TyqJnqenj6NlZyrF/GNr+qUX7nHp2l571pmeFab8SAF4U6REAIABNC6A03UBonDlzxuSq0pxbjvRUKz0NS9db5VTu3LmdymmnUjunjo4dO2Zybek6VxxzcrnapsqTJ4/Mnz/f6bHz5s0bqFz+/Pll5cqVcv/+ffOc9dS0oMppPrFz586Z4KalRYsWEitWLHMqnD7n8NJT4RxZbaP5cvW1sdo7YPqFgHXWWYI1L5qe6hbULMeO7RgnThyT61bznmlus5kzZwY6NQ4AACA6ior9X1c03dfXX39t+qwnTpyQUaNGmT6h9u0caTqv4cOHy7x58wJtV3/YD2v/1DFlmeYFnjJlijRt2jTE+gJAcAjaAkAA2vHKkCGDy4m8ghORAT7taOoIWM0p64oGZL1Fw4YNTQdVRxRonq/wCip/7L9nnYWeNWGFziAc1CgHHWnsSIPX1ogLPXDQ3GUAAADRXXTp/+pkuzoy16JzFhQvXtxMkPbFF1845ajVfLl9+vSRokWLmol39fFr167tctKz0PZP9fH07LYvv/zSPIbjGW4AEFYEbQHAhXr16pnRmVu3bpVy5coFW1bTAWjnToN8OhrVcRIsHelppQuw/ms5x9QD+uu//krvSEeR6q/0jp3O4Og2A/r777/tk4tZj3306FGXp5GlSpXKdHJ1FILO6htUOR1RobP5OtLT3XSUhU4yobPp9u/fX9zJam8dPeE4ujZgnXWUhp7ip6fThaYddWTHiBEjzIQU2tnWyTV0Ijd9TgAAANFdVOv/hob+QK8/4OtkYL179zYjZvVx165da0baav81uP50WGmf+JNPPjET+GoA+P/au3tQev8wjuPnXx7yrBhQQplQBlk8yyDJIHSyMMggUUZFUgblYTllkLJZGLAYKCYDISWD1BlIyWAweO769/nWLYejfv791P37/d+vwcM533N/z/c+y3Wu+7q/l+b51S0nAOAj9rQFgCh0hV9JTCXuFHx+pIShKktFXXDlY0fb2dlZ97u5udn9VgAaGxsbCIVCEVflo3XC1ZV5Bcxe5ed7CoRfXl4iHltdXXWddj17e3uug29TU9PbnrSqIlCHX73eo2oK7WHrrUFVBOrmu7a25jrtenQOlpaWAlVVVRG3gHlGR0ddIKzuvrod7Cd5a3pfLRHtPGotbW1tbl/baFUj+rLg0X682u9XFSb6XLXvmdY8NDT0Y+sAAADwkz8t/v3OuhTree/Nq5r9WCUb7T3910Sx9vzV1mHqrXB/f/9bjgvg/4dKWwCIQlf6laQMBoOueqCrqytQUlLiGinoVio1SlCST0pLS93t96pMUECpBlZKmipBqoZe9fX1b5WfSmxqCwFVMijYPTo6CmxsbLhK1/d0q9b6+robp3nKysrcnrOq/FxZWXEJ1fev0VV9JVT7+voCj4+PLujMyMiIuL1MjRiU8FTlRE9PjwsgFUCrklRNuDwTExOBzc1Ndzw15NJ+tapO0HFVOfAVHV97gPX397uKAlU1/AQln7VH2NzcnJuvoqLCVTGcn59/Gjs5ORnY3t52Tdl6e3sDRUVFbg8zNZhQYwz97a1Z1bVeNYSCbVVejIyMBNrb29++mAAAAPyt/rT491cp/tO8CwsLrtBAMXJNTY2La5XMVTNfFTGEw+HfdCYDrqmZiiA0r2JJFVgoeQ0A32IAgC+dnZ1Zb2+v5efnW1xcnKWkpFhlZaWFQiF7eHh4G/f8/Gzj4+NWUFBgsbGxlpuba8PDwxFj5PX11Y3Lzs62hIQEq6urs5OTE8vLy7Pu7u6IsXd3d+4YhYWFbu7MzEyrqKiw6elpe3p6cmPC4bBKBGxqaspmZmbcvPHx8VZdXW3Hx8ef1rO1teXev+ZOTU21lpYWOz09/TTu8PDQGhsbLTk52RITE62+vt52d3cjxiwuLrq59/f3I9bX2dlpMTExtrq6+uV53d7edq9dXl5+e2xsbMw9dnNzE3UerdVzf39vg4ODlpGRYUlJSW4dFxcXbpyO89719bX19/e7c6PPJisryxoaGmx+ft49f3Bw4N7vwMBAxOteXl6svLzccnJy7Pb29su1AAAA/E38Hv9+pba21oqLi6M+t7OzExEnXl5eWmtrq6Wnp1taWpp1dHTY1dXVp1jyO/Gp/lfM+d7a2pqLM4PBoDsPAPAd/+jH99K8AAAAAAAAAICfwp62AAAAAAAAAOAjJG0BAAAAAAAAwEdI2gIAAAAAAACAj5C0BQAAAAAAAAAfIWkLAAAAAAAAAD5C0hYAAAAAAAAAfISkLQAAAAAAAAD4CElbAAAAAAAAAPARkrYAAAAAAAAA4CMkbQEAAAAAAADAR0jaAgAAAAAAAICPkLQFAAAAAAAAAB8haQsAAAAAAAAAAf/4F025KnxpckeqAAAAAElFTkSuQmCC",
            "text/plain": [
              "<Figure size 1400x400 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "Top 36 codes account for 90% of usage\n",
            "Most common codes: [25, 84, 106, 83, 64, 22, 49, 73, 43, 66]\n"
          ]
        }
      ],
      "source": [
        "# Analyze codebook usage across the dataset\n",
        "from collections import Counter\n",
        "\n",
        "all_codes = []\n",
        "with torch.no_grad():\n",
        "    for images, _ in train_loader:\n",
        "        z_e = encoder(images)\n",
        "        _, codes, _ = quantizer(z_e)\n",
        "        all_codes.extend(codes.flatten().tolist())\n",
        "        \n",
        "        # Just use first few batches for speed\n",
        "        if len(all_codes) > 50000:\n",
        "            break\n",
        "\n",
        "# Count code frequencies\n",
        "code_counts = Counter(all_codes)\n",
        "used_codes = len(code_counts)\n",
        "\n",
        "# Plot code usage histogram\n",
        "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 4))\n",
        "\n",
        "# Histogram of code frequencies\n",
        "codes_sorted = sorted(code_counts.items())\n",
        "code_ids = [c[0] for c in codes_sorted]\n",
        "frequencies = [c[1] for c in codes_sorted]\n",
        "\n",
        "ax1.bar(code_ids, frequencies, color='steelblue', alpha=0.7)\n",
        "ax1.set_xlabel('Codebook Index', fontsize=12)\n",
        "ax1.set_ylabel('Frequency', fontsize=12)\n",
        "ax1.set_title(f'Codebook Usage ({used_codes}/{num_embeddings} codes used)', fontsize=13, fontweight='bold')\n",
        "ax1.grid(alpha=0.3)\n",
        "\n",
        "# Cumulative distribution\n",
        "sorted_freqs = sorted(frequencies, reverse=True)\n",
        "cumsum = np.cumsum(sorted_freqs) / np.sum(sorted_freqs)\n",
        "ax2.plot(cumsum, color='darkred', linewidth=2)\n",
        "ax2.axhline(0.9, color='gray', linestyle='--', label='90%')\n",
        "ax2.set_xlabel('Code Rank', fontsize=12)\n",
        "ax2.set_ylabel('Cumulative Usage', fontsize=12)\n",
        "ax2.set_title('Cumulative Code Usage', fontsize=13, fontweight='bold')\n",
        "ax2.legend()\n",
        "ax2.grid(alpha=0.3)\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()\n",
        "\n",
        "# Find how many codes account for 90% of usage\n",
        "num_90 = np.where(cumsum >= 0.9)[0][0] + 1\n",
        "print(f\"\\nTop {num_90} codes account for 90% of usage\")\n",
        "print(f\"Most common codes: {[c[0] for c in code_counts.most_common(10)]}\")"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "anlp",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.10.18"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}