Generative Models/PixelCNN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b4b9de65",
   "metadata": {
    "id": "b4b9de65"
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "import logging"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "124cb0bd",
   "metadata": {
    "id": "124cb0bd"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c6b214fe",
   "metadata": {
    "id": "c6b214fe"
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "624951e7",
   "metadata": {
    "id": "624951e7"
   },
   "outputs": [],
   "source": [
    "from torch.utils.data import DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ed48fac7",
   "metadata": {
    "id": "ed48fac7"
   },
   "outputs": [],
   "source": [
    "import torchvision\n",
    "from torchvision import datasets\n",
    "from torchvision.utils import make_grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ef301599",
   "metadata": {
    "id": "ef301599"
   },
   "outputs": [],
   "source": [
    "logging.basicConfig(\n",
    "    level=logging.INFO,\n",
    "    format=\"%(asctime)s - %(name)s - %(levelname)s - %(message)s\",\n",
    "    handlers=[logging.StreamHandler(sys.stdout)],\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Data Load"
   ],
   "metadata": {
    "id": "Od6ldOX-keC1"
   },
   "id": "Od6ldOX-keC1"
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4ef88e0f",
   "metadata": {
    "id": "4ef88e0f"
   },
   "outputs": [],
   "source": [
    "train_dataset = datasets.MNIST(\n",
    "    root='data',\n",
    "    train=True,\n",
    "    transform=torchvision.transforms.Compose([\n",
    "        torchvision.transforms.ToTensor(),\n",
    "        torchvision.transforms.Lambda(lambda x: torch.ceil(x)),\n",
    "    ]),\n",
    "    download=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "de510645",
   "metadata": {
    "id": "de510645"
   },
   "outputs": [],
   "source": [
    "test_dataset = datasets.MNIST(\n",
    "    root='data',\n",
    "    train=False,\n",
    "    transform=torchvision.transforms.Compose([\n",
    "        torchvision.transforms.ToTensor(),\n",
    "        torchvision.transforms.Lambda(lambda x: torch.ceil(x)),\n",
    "    ]),\n",
    "    download=False,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b40393f2",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "b40393f2",
    "outputId": "930c1a41-438f-4111-fd02-aada7e0d107e"
   },
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "(60000, 10000)"
      ]
     },
     "metadata": {},
     "execution_count": 9
    }
   ],
   "source": [
    "len(train_dataset), len(test_dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "37c18bb2",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 310
    },
    "id": "37c18bb2",
    "outputId": "10906dec-5d2c-4459-f372-2a201d3ed33d"
   },
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7e2a7eb5a020>"
      ]
     },
     "metadata": {},
     "execution_count": 10
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": [
       "<Figure size 300x300 with 1 Axes>"
      ],
      "image/png": "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\n"
     },
     "metadata": {}
    }
   ],
   "source": [
    "plt.figure(figsize=(3,3))\n",
    "plt.imshow(train_dataset[9][0].detach().cpu().numpy()[0], cmap='gray')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "227a6505",
   "metadata": {
    "id": "227a6505"
   },
   "outputs": [],
   "source": [
    "train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, num_workers=2, pin_memory=True)\n",
    "test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False, num_workers=2, pin_memory=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "f5a8d3ba",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "f5a8d3ba",
    "outputId": "5bea9952-c5f5-4efb-a7cc-8e9daa94c055"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stderr",
     "text": [
      "/usr/lib/python3.10/multiprocessing/popen_fork.py:66: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n",
      "  self.pid = os.fork()\n"
     ]
    },
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "torch.Size([64, 1, 28, 28])\n",
      "torch.Size([64])\n"
     ]
    }
   ],
   "source": [
    "for batch in train_loader:\n",
    "    data, labels = batch\n",
    "    print(data.shape)\n",
    "    print(labels.shape)\n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Model"
   ],
   "metadata": {
    "id": "lQkq6iCGkiKD"
   },
   "id": "lQkq6iCGkiKD"
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ddbcb9b8",
   "metadata": {
    "id": "ddbcb9b8"
   },
   "outputs": [],
   "source": [
    "class MaskedConv2d(nn.Conv2d):\n",
    "    def __init__(self, mask_type, *args, **kwargs):\n",
    "        super().__init__(*args, **kwargs)\n",
    "        assert mask_type in ('A', 'B')\n",
    "        self.register_buffer('mask', self.weight.data.clone())\n",
    "        _, _, kH, kW = self.weight.size()\n",
    "        self.mask.fill_(1)\n",
    "        self.mask[:, :, kH // 2, kW // 2 + (mask_type == 'B'):] = 0\n",
    "        self.mask[:, :, kH // 2 + 1:] = 0\n",
    "\n",
    "    def forward(self, x):\n",
    "        self.weight.data *= self.mask\n",
    "        return super(MaskedConv2d, self).forward(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "60a32fe6",
   "metadata": {
    "id": "60a32fe6"
   },
   "outputs": [],
   "source": [
    "def test_masked_conv2d():\n",
    "    layer = MaskedConv2d(mask_type='A', in_channels=2, out_channels=2, kernel_size=5)\n",
    "    assert np.allclose(layer.mask[:, :, 2, 2].numpy(), np.zeros((2, 2)))\n",
    "\n",
    "    layer = MaskedConv2d('B', in_channels=2, out_channels=2, kernel_size=5)\n",
    "    assert np.allclose(layer.mask[:, :, 2, 2].numpy(), np.ones((2, 2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "00de2268",
   "metadata": {
    "id": "00de2268"
   },
   "outputs": [],
   "source": [
    "test_masked_conv2d()"
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "class LayerNorm(nn.LayerNorm):\n",
    "    def __init__(self, n_filters):\n",
    "        super().__init__(n_filters)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = x.permute(0, 2, 3, 1).contiguous()\n",
    "        out = super().forward(x)\n",
    "        return out.permute(0, 3, 1, 2).contiguous()"
   ],
   "metadata": {
    "id": "dhw0oOVHkkaz"
   },
   "id": "dhw0oOVHkkaz",
   "execution_count": 16,
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "0ce0e0cc",
   "metadata": {
    "id": "0ce0e0cc"
   },
   "outputs": [],
   "source": [
    "class ConvBlock(nn.Module):\n",
    "    def __init__(\n",
    "        self,\n",
    "        mask_type: str,\n",
    "        in_channels: int,\n",
    "        out_channels: int,\n",
    "        kernel_size: int,\n",
    "        padding: int,\n",
    "    ):\n",
    "        super(ConvBlock, self).__init__()\n",
    "\n",
    "        self.layer = nn.Sequential(\n",
    "            MaskedConv2d(\n",
    "                mask_type=mask_type,\n",
    "                in_channels=in_channels,\n",
    "                out_channels=out_channels,\n",
    "                kernel_size=kernel_size,\n",
    "                padding=padding,\n",
    "            ),\n",
    "            LayerNorm(out_channels),\n",
    "            nn.ReLU()\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.layer(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "2614bb11",
   "metadata": {
    "id": "2614bb11"
   },
   "outputs": [],
   "source": [
    "class PixelCNN(nn.Module):\n",
    "    def __init__(\n",
    "        self,\n",
    "        input_shape: tuple,\n",
    "        n_filters: int,\n",
    "        n_layers: int,\n",
    "        kernel_size: int,\n",
    "    ):\n",
    "        super(PixelCNN, self).__init__()\n",
    "        self.input_shape = input_shape\n",
    "        padding = kernel_size // 2\n",
    "\n",
    "        layers = nn.ModuleList()\n",
    "        layers.append(ConvBlock('A', 1, n_filters, kernel_size, padding))\n",
    "        for _ in range(n_layers):\n",
    "            layers.append(ConvBlock('B', n_filters, n_filters, kernel_size, padding))\n",
    "        layers.append(MaskedConv2d(\n",
    "            mask_type='B',\n",
    "            in_channels=n_filters,\n",
    "            out_channels=2,\n",
    "            kernel_size=kernel_size,\n",
    "            padding=padding,\n",
    "        ))\n",
    "\n",
    "        self.model = nn.Sequential(*layers)\n",
    "\n",
    "    def forward(self, x):\n",
    "        batch_size = x.shape[0]\n",
    "        normalized = (x.float() - 0.5) / 0.5\n",
    "        out = self.model(x)\n",
    "        return out.view(batch_size, 2, 1, *self.input_shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "aa17b964",
   "metadata": {
    "id": "aa17b964"
   },
   "outputs": [],
   "source": [
    "def count_parameters(model: nn.Module):\n",
    "    \"\"\"Количество обучаемых параметров модели\"\"\"\n",
    "    return sum(p.numel() for p in model.parameters() if p.requires_grad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "cd526282",
   "metadata": {
    "id": "cd526282"
   },
   "outputs": [],
   "source": [
    "model = PixelCNN(\n",
    "    input_shape=(28, 28),\n",
    "    n_filters=64,\n",
    "    n_layers=5,\n",
    "    kernel_size=5,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "a0804a5e",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "a0804a5e",
    "outputId": "fa91ee98-7777-434d-e766-19bd2a97d52e"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "The model has 517,954 trainable parameters\n"
     ]
    }
   ],
   "source": [
    "print(f\"The model has {count_parameters(model):,} trainable parameters\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "7bca157e",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "7bca157e",
    "outputId": "1774316c-6d06-4ce6-efea-8b900ea34b92"
   },
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "torch.Size([64, 2, 1, 28, 28])"
      ]
     },
     "metadata": {},
     "execution_count": 22
    }
   ],
   "source": [
    "model(data).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "1b200e42",
   "metadata": {
    "id": "1b200e42"
   },
   "outputs": [],
   "source": [
    "def sample(n, device='cpu'):\n",
    "    # read carefully the sampling process\n",
    "    model.eval()\n",
    "    samples = torch.zeros(n, 1, *model.input_shape)\n",
    "    with torch.no_grad():\n",
    "        for r in tqdm(range(model.input_shape[0])):\n",
    "            for c in range(model.input_shape[1]):\n",
    "                logits = model(samples.to(device))[:, :, :, r, c]\n",
    "                probs = F.softmax(logits, dim=1).squeeze(-1)\n",
    "                samples[:, 0, r, c] = torch.multinomial(probs, num_samples=1).squeeze(-1)\n",
    "    return samples.cpu().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "803e3df0",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "803e3df0",
    "outputId": "cb6ff648-19bd-49db-9d47-6d48095581fc"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stderr",
     "text": [
      "100%|██████████| 28/28 [00:29<00:00,  1.06s/it]\n"
     ]
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "(2, 1, 28, 28)"
      ]
     },
     "metadata": {},
     "execution_count": 24
    }
   ],
   "source": [
    "sample(2).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "2a9ade3e",
   "metadata": {
    "id": "2a9ade3e"
   },
   "outputs": [],
   "source": [
    "criterion = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "f38c559a",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "f38c559a",
    "outputId": "ba8c3d8e-730b-455a-81bb-d148238ff84e"
   },
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "tensor(0.6479, grad_fn=<NllLoss2DBackward0>)"
      ]
     },
     "metadata": {},
     "execution_count": 26
    }
   ],
   "source": [
    "criterion(model(data), data.long())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "fad08d87",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "fad08d87",
    "outputId": "a7c29332-d8b1-4886-83ba-2126ea29ce8d"
   },
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "torch.Size([64, 1, 28, 28])"
      ]
     },
     "metadata": {},
     "execution_count": 27
    }
   ],
   "source": [
    "data.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Train"
   ],
   "metadata": {
    "id": "kNjKfUH5kypl"
   },
   "id": "kNjKfUH5kypl"
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "8fccf867",
   "metadata": {
    "id": "8fccf867"
   },
   "outputs": [],
   "source": [
    "def train(\n",
    "    model: nn.Module,\n",
    "    train_loader: DataLoader,\n",
    "    criterion: nn.Module,\n",
    "    optimizer: torch.optim.Optimizer,\n",
    "    device: str,\n",
    "    clip: float = 3.0,\n",
    "    train_history=None,\n",
    "    valid_history=None,\n",
    "):\n",
    "    epoch_loss = 0\n",
    "    history = []\n",
    "\n",
    "    model.train()\n",
    "    for i, batch in enumerate(tqdm(train_loader)):\n",
    "        data = batch[0].to(device)\n",
    "        labels = batch[1].to(device)\n",
    "\n",
    "        output = model(data)\n",
    "\n",
    "        loss = criterion(\n",
    "            output,\n",
    "            data.long(),\n",
    "        )\n",
    "        epoch_loss += loss.item()\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        # torch.nn.utils.clip_grad_norm_(model.parameters(), clip)\n",
    "        optimizer.step()\n",
    "\n",
    "        history.append(loss.cpu().data.numpy())\n",
    "        if ((i + 1) % 30 == 0) or (i == (len(train_loader) - 1)):\n",
    "            fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(12, 6))\n",
    "\n",
    "            clear_output(True)\n",
    "            ax[0].plot(history, label=\"train loss\")\n",
    "            ax[0].set_xlabel(\"Batch\")\n",
    "            ax[0].set_title(\"Train loss\")\n",
    "            if train_history is not None:\n",
    "                ax[1].plot(train_history, label=\"general train history\")\n",
    "                ax[1].set_xlabel(\"Epoch\")\n",
    "            if valid_history is not None:\n",
    "                ax[1].plot(valid_history, label=\"general valid history\")\n",
    "            plt.legend()\n",
    "\n",
    "            plt.show()\n",
    "        i += 1\n",
    "\n",
    "    return epoch_loss / len(train_loader), loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "76c33c68",
   "metadata": {
    "id": "76c33c68"
   },
   "outputs": [],
   "source": [
    "def validate(\n",
    "    model: nn.Module, valid_loader: DataLoader, criterion: nn.Module, device: str\n",
    "):\n",
    "\n",
    "    epoch_loss = 0\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        for batch in tqdm(valid_loader):\n",
    "            data = batch[0].to(device)\n",
    "            labels = batch[1].to(device)\n",
    "\n",
    "            output = model(data)\n",
    "            loss = criterion(\n",
    "                output,\n",
    "                data.long(),\n",
    "            )\n",
    "            epoch_loss += loss.item()\n",
    "\n",
    "    return epoch_loss / len(valid_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "ae330102",
   "metadata": {
    "id": "ae330102"
   },
   "outputs": [],
   "source": [
    "def fit(\n",
    "    model: nn.Module,\n",
    "    train_loader: DataLoader,\n",
    "    valid_loader: DataLoader,\n",
    "    criterion,\n",
    "    optimizer,\n",
    "    start_epoch: int,\n",
    "    end_epoch: int,\n",
    "    clip: float = 3.0,\n",
    "):\n",
    "\n",
    "    train_losses = []\n",
    "    valid_losses = []\n",
    "\n",
    "\n",
    "    for epoch in range(start_epoch, end_epoch):\n",
    "        train_loss, last_batch_loss = train(\n",
    "            model,\n",
    "            train_loader,\n",
    "            criterion,\n",
    "            optimizer,\n",
    "            device,\n",
    "            clip,\n",
    "            train_losses,\n",
    "            valid_losses,\n",
    "        )\n",
    "        valid_loss = validate(model, valid_loader, criterion, device)\n",
    "        logging.info(\n",
    "            f\"Epoch: {epoch}, Training Loss: {train_loss}, Valid Loss: {valid_loss}\"\n",
    "        )\n",
    "\n",
    "        train_losses.append(train_loss)\n",
    "        valid_losses.append(valid_loss)\n",
    "\n",
    "    return train_losses, valid_losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "59eaa3b4",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "59eaa3b4",
    "outputId": "69baf553-632b-4030-c310-ac3d75a530e0"
   },
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "'cuda'"
      ],
      "application/vnd.google.colaboratory.intrinsic+json": {
       "type": "string"
      }
     },
     "metadata": {},
     "execution_count": 31
    }
   ],
   "source": [
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "model.to(device)\n",
    "print()"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "rPbqVJcD64zT",
    "outputId": "17b8e45c-6ee1-46c6-bb65-e467e20d087a"
   },
   "id": "rPbqVJcD64zT",
   "execution_count": 32,
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "\n"
     ]
    }
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "481304eb",
   "metadata": {
    "id": "481304eb"
   },
   "outputs": [],
   "source": [
    "start_epoch = 0\n",
    "end_epoch = 10\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=5e-4, weight_decay=0.0001)\n",
    "criterion = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "ec390d2e",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 598
    },
    "id": "ec390d2e",
    "outputId": "ec961cff-8e26-4f29-e202-7d88ce209f47"
   },
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": [
       "<Figure size 1200x600 with 2 Axes>"
      ],
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+cAAAIjCAYAAABh8GqqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3wU1fo/8M+mJ0ACBEwoCQFEikDoCN4riLkmil5RfoiIglwEW1SMcq94EVBUVIrwFRQbYAFBrNhAiIBeiJQACtKkhpbQE0gv+/sj7GZmd2Z2ZnZmWz5vX3mZ7M6cOTNbOM+cc55jsVqtVhARERERERGR1wR5uwJEREREREREtR2DcyIiIiIiIiIvY3BORERERERE5GUMzomIiIiIiIi8jME5ERERERERkZcxOCciIiIiIiLyMgbnRERERERERF7G4JyIiIiIiIjIyxicExEREREREXkZg3MiwgMPPICkpCTDylu3bh0sFgvWrVtnWJlERERERIGMwTmRD7NYLKp+GAQTEREREfm3EG9XgIjkffzxx6K/P/roI6xevdrp8fbt27t1nPfeew9VVVVulUFERERERPoxOCfyYffdd5/o799++w2rV692etxRUVERoqKiVB8nNDRUV/2IiIiIiMgYHNZO5Of69++Pjh07Ijs7GzfccAOioqLw3HPPAQC++eYbDBw4EE2bNkV4eDhat26NqVOnorKyUlSG45zzI0eOwGKxYMaMGXj33XfRunVrhIeHo2fPntiyZYvuui5fvhzdu3dHZGQkGjVqhPvuuw8nTpwQbZObm4tRo0ahefPmCA8PR5MmTXDHHXfgyJEj9m22bt2K1NRUNGrUCJGRkWjZsiX+9a9/6a4XEREREZG3seecKACcO3cOt9xyC+655x7cd999iIuLAwAsWrQIdevWRUZGBurWrYuff/4ZkyZNQkFBAaZPn+6y3CVLluDSpUt46KGHYLFY8Prrr+Ouu+7CoUOHNPe2L1q0CKNGjULPnj0xbdo05OXlYc6cOdiwYQO2b9+O+vXrAwAGDx6MP//8E48//jiSkpJw+vRprF69Gjk5Ofa/b775ZjRu3BjPPvss6tevjyNHjuDLL7/UfN2IiIiIiHwFg3OiAJCbm4v58+fjoYceEj2+ZMkSREZG2v9++OGH8fDDD+Ott97CSy+9hPDwcMVyc3Jy8Ndff6FBgwYAgLZt2+KOO+7AqlWrcNttt6muX3l5Of7zn/+gY8eO+OWXXxAREQEA+Nvf/obbbrsNb7zxBl544QVcvHgRGzduxPTp0/HMM8/Y958wYYL9940bN+LChQv46aef0KNHD/vjL730kur6EBERERH5Gg5rJwoA4eHhGDVqlNPjwsD80qVLOHv2LP7+97+jqKgIe/fudVnu0KFD7YE5APz9738HABw6dEhT/bZu3YrTp0/j0UcftQfmADBw4EC0a9cO33//vb2+YWFhWLduHS5cuCBZlq2H/bvvvkN5ebmmehARERER+SoG50QBoFmzZggLC3N6/M8//8Sdd96JmJgYREdHo3HjxvZkcvn5+S7LTUxMFP1tC9TlAmc5R48eBVDd8+6oXbt29ufDw8Px2muv4ccff0RcXBxuuOEGvP7668jNzbVv369fPwwePBgvvPACGjVqhDvuuAMLFy5EaWmppjoREREREfkSBudEAUDYQ25z8eJF9OvXD7///jtefPFFfPvtt1i9ejVee+01AFC1dFpwcLDk41ar1b0KKxg3bhz279+PadOmISIiAs8//zzat2+P7du3A6he+/3zzz9HVlYW0tPTceLECfzrX/9C9+7dcfnyZdPqRURERERkJgbnRAFq3bp1OHfuHBYtWoQnn3wSt912G1JSUkTD1D2lRYsWAIB9+/Y5Pbdv3z778zatW7fG008/jZ9++gm7du1CWVkZZs6cKdrmuuuuw8svv4ytW7di8eLF+PPPP7F06VLzToKIiIiIyEQMzokClK3XW9jLXVZWhrfeesvjdenRoweuuuoqzJ8/XzT8/Mcff8SePXswcOBAANXrs5eUlIj2bd26NerVq2ff78KFC0499126dAEADm0nIiIiIr/FbO1EAapv375o0KABRo4ciSeeeAIWiwUff/yxqUPS5YSGhuK1117DqFGj0K9fPwwbNsy+lFpSUhKeeuopAMD+/ftx00034e6770aHDh0QEhKCr776Cnl5ebjnnnsAAB9++CHeeust3HnnnWjdujUuXbqE9957D9HR0bj11ls9fm5EREREREZgcE4UoGJjY/Hdd9/h6aefxsSJE9GgQQPcd999uOmmm5Camurx+jzwwAOIiorCq6++iv/85z+oU6cO7rzzTrz22mv2DOwJCQkYNmwYMjMz8fHHHyMkJATt2rXDZ599hsGDBwOoTgi3efNmLF26FHl5eYiJiUGvXr2wePFitGzZ0uPnRURERERkBIvVG91oRERERERERGTHOedEREREREREXsbgnIiIiIiIiMjLGJwTEREREREReRmDcyIiIiIiIiIvY3BORERERERE5GUMzomIiIiIiIi8rNasc15VVYWTJ0+iXr16sFgs3q4OERERrFYrLl26hKZNmyIoiPfLjcB/74mIyJdo+be+1gTnJ0+eREJCgrerQURE5OTYsWNo3ry5t6sREPjvPRER+SI1/9bXmuC8Xr16AKovSnR0tJdrQ0REBBQUFCAhIcH+bxS5j//eExGRL9Hyb32tCc5tQ9uio6P5jzUREfkUDr82Dv+9JyIiX6Tm33pOcCMiIiIiIiLyMgbnRERERERERF7G4JyIiIiIiIjIy2rNnHMiIiIiIjJXZWUlysvLvV0NIo8KDQ1FcHCw2+UwOCciIiIiIrddvnwZx48fh9Vq9XZViDzKYrGgefPmqFu3rlvlMDgnIiIiIiK3VFZW4vjx44iKikLjxo25CgXVGlarFWfOnMHx48fRpk0bt3rQGZwTEREREZFbysvLYbVa0bhxY0RGRnq7OkQe1bhxYxw5cgTl5eVuBedMCEdERERERIZgjznVRka97xmcExEREREREXkZg3MiIiIiIiIiL2NwTkRERERE5Kf69++PcePGeex4DzzwAAYNGmR6GUlJSZg9e7Zbx/E3DM6JiIiIiIgC1JQpU9ClSxfDypszZw4WLVpkWHlytmzZgrFjx6raNlACeWZrJyIiIiIi8jHl5eUIDQ31uePFxMR4oDbVGdA9raysDGFhYR4/rg17zomIiIiIyFBWqxVFZRVe+bFararreenSJQwfPhx16tRBkyZN8MYbbzgNEy8tLcUzzzyDZs2aoU6dOujduzfWrVtnf37RokWoX78+Vq1ahfbt26Nu3bpIS0vDqVOnRMd6//330b59e0RERKBdu3Z466237M8dOXIEFosFy5YtQ79+/RAREYHFixfj3LlzGDZsGJo1a4aoqCh06tQJn376qerzW7RoEV544QX8/vvvsFgssFgs9l5vi8WCt99+G//85z9Rp04dvPzyy6isrMTo0aPRsmVLREZGom3btpgzZ46oTMch6f3798cTTzyBf//732jYsCHi4+MxZcoUVfWbMWMGmjRpgtjYWDz22GMoLy+3PyfsDbdarZgyZQoSExMRHh6Opk2b4oknnrAf/+jRo3jqqafs52jzxRdf4Nprr0V4eDiSkpIwc+ZM0fGTkpIwdepUjBgxAtHR0Rg7diwGDBiA9PR00XZnzpxBWFgYMjMzVZ2XXrp6zufNm4fp06cjNzcXycnJePPNN9GrVy/Z7ZcvX47nn38eR44cQZs2bfDaa6/h1ltvtT9/+fJlPPvss/j6669x7tw5tGzZEk888QQefvhhUTlZWVn473//i02bNiE4OBhdunTBqlWruJYiEREREZEPKS6vRIdJq7xy7N0vpiIqTF2Yk5GRgQ0bNmDFihWIi4vDpEmTsG3bNtEw8PT0dOzevRtLly5F06ZN8dVXXyEtLQ07d+5EmzZtAABFRUWYMWMGPv74YwQFBeG+++7DM888g8WLFwMAFi9ejEmTJmHu3Lno2rUrtm/fjjFjxqBOnToYOXKk/VjPPvssZs6cia5duyIiIgIlJSXo3r07/vOf/yA6Ohrff/897r//frRu3Vox/rIZOnQodu3ahZUrV2LNmjUAxD3fU6ZMwauvvorZs2cjJCQEVVVVaN68OZYvX47Y2Fhs3LgRY8eORZMmTXD33XfLHufDDz9ERkYGNm3ahKysLDzwwAO4/vrr8Y9//EN2n7Vr16JJkyZYu3YtDhw4gKFDh6JLly4YM2aM07ZffPEF3njjDSxduhTXXnstcnNz8fvvvwMAvvzySyQnJ2Ps2LGifbOzs3H33XdjypQpGDp0KDZu3IhHH30UsbGxeOCBB+zbzZgxA5MmTcLkyZMBAJs2bUJ6ejpmzpyJ8PBwAMAnn3yCZs2aYcCAAS6vuTs0B+fLli1DRkYG5s+fj969e2P27NlITU3Fvn37cNVVVzltv3HjRgwbNgzTpk3DbbfdhiVLlmDQoEHYtm0bOnbsCKD6Q/Hzzz/jk08+QVJSEn766Sc8+uijaNq0Kf75z38CqA7M09LSMGHCBLz55psICQnB77//jqAgdv4TEREREZE2ly5dwocffoglS5bgpptuAgAsXLgQTZs2tW+Tk5ODhQsXIicnx/74M888g5UrV2LhwoV45ZVXAFQPCZ8/fz5at24NoDqgf/HFF+3lTJ48GTNnzsRdd90FAGjZsiV2796Nd955RxScjxs3zr6NzTPPPGP//fHHH8eqVavw2WefqQrOIyMjUbduXYSEhCA+Pt7p+XvvvRejRo0SPfbCCy/Yf2/ZsiWysrLw2WefKQbnnTt3tge3bdq0wdy5c5GZmakYnDdo0ABz585FcHAw2rVrh4EDByIzM1MyOM/JyUF8fDxSUlIQGhqKxMRE+/k3bNgQwcHBqFevnugcZ82ahZtuugnPP/88AOCaa67B7t27MX36dFFwPmDAADz99NP2v5s1a4b09HR888039nNetGgRHnjgAcPWM5ejOTifNWsWxowZY38R58+fj++//x4LFizAs88+67T9nDlzkJaWhvHjxwMApk6ditWrV2Pu3LmYP38+gOoAfuTIkejfvz8AYOzYsXjnnXewefNme3D+1FNP4YknnhAdo23btlqrT0R+7FJJOY6eK8K1TaNN/3Ikototv6gc245dQHlFFW6+1rlBS0TKIkODsfvFVK8dW41Dhw6hvLxcFOTGxMSIYoydO3eisrIS11xzjWjf0tJSxMbG2v+OioqyB+YA0KRJE5w+fRoAUFhYiIMHD2L06NGiwLOiosJp/naPHj1Ef1dWVuKVV17BZ599hhMnTqCsrAylpaWIiopSdY6uOB4PqB4lvWDBAuTk5KC4uBhlZWUuE8p17txZ9Lfw/OVce+21CA6uea2aNGmCnTt3Sm47ZMgQzJ49G61atUJaWhpuvfVW3H777QgJkQ9n9+zZgzvuuEP02PXXX4/Zs2ejsrLSfmzHaxAREYH7778fCxYswN13341t27Zh165dWLFiheL5GEFTcF5WVobs7GxMmDDB/lhQUBBSUlKQlZUluU9WVhYyMjJEj6WmpuLrr7+2/923b1+sWLEC//rXv9C0aVOsW7cO+/fvxxtvvAEAOH36NDZt2oThw4ejb9++OHjwINq1a4eXX34Zf/vb3ySPW1paitLSUvvfBQUFWk6ViHzQzW/8glP5JVg4qidubOs8UoeIyCi7TxVg1MItSIqNYnBOpIPFYlE9tNyXXb58GcHBwcjOzhYFkgBQt25d+++OidQsFot97vvly5cBAO+99x569+4t2s6xzDp16oj+nj59OubMmYPZs2ejU6dOqFOnDsaNG4eysjL3TkzmeEuXLsUzzzyDmTNnok+fPqhXrx6mT5+OTZs2KZYjdf5VVVWG7ZOQkIB9+/ZhzZo1WL16NR599FFMnz4d69evdztpnuM1AIAHH3wQXbp0wfHjx7Fw4UIMGDAALVq0cOs4amgaE3727FlUVlYiLi5O9HhcXBxyc3Ml98nNzXW5/ZtvvokOHTqgefPmCAsLQ1paGubNm4cbbrgBQPVdLaB6TsSYMWOwcuVKdOvWDTfddBP++usvyeNOmzYNMTEx9p+EhAQtp0pEPuhUfgkA4Medp1xsSUTknhax1b1Sxy8Uo7JKfXIpIvIfrVq1QmhoKLZs2WJ/LD8/H/v377f/3bVrV1RWVuL06dO4+uqrRT9Sw8SlxMXFoWnTpjh06JBTGS1btlTcd8OGDbjjjjtw3333ITk5Ga1atRLVT42wsDBUVlaq2nbDhg3o27cvHn30UXTt2hVXX301Dh48qOl4ZomMjMTtt9+O//u//8O6deuQlZVl72mXOsf27dtjw4YNosc2bNiAa665xummiKNOnTqhR48eeO+997BkyRL861//MvZkZPjE7aw333wTv/32G1asWIEWLVrgl19+wWOPPYamTZsiJSXFfgfloYcesg+n79q1KzIzM7FgwQJMmzbNqcwJEyaIeuwLCgoYoBMFCA1JWImIdImLjkBYcBDKKqtw8mIxEhoaM4SUiHxHvXr1MHLkSIwfPx4NGzbEVVddhcmTJyMoKMg+fe6aa67B8OHDMWLECHuitjNnziAzMxOdO3fGwIEDVR3rhRdewBNPPIGYmBikpaWhtLQUW7duxYULF5xGGQu1adMGn3/+OTZu3IgGDRpg1qxZyMvLQ4cOHVSfZ1JSEg4fPowdO3agefPmqFevnj3RmdTxPvroI6xatQotW7bExx9/jC1btri8iWC2RYsWobKyEr1790ZUVBQ++eQTREZG2nuzk5KS8Msvv+Cee+5BeHg4GjVqhKeffho9e/bE1KlTMXToUGRlZWHu3LmiLPlKHnzwQaSnp6NOnTq48847zTw9O009540aNUJwcDDy8vJEj+fl5cneOYqPj1fcvri4GM899xxmzZqF22+/HZ07d0Z6ejqGDh2KGTNmAKiefwDA6U3Yvn175OTkSB43PDwc0dHRoh8iIiJSZ968eUhKSkJERAR69+6NzZs3y277559/YvDgwUhKSoLFYrEvfSP0yy+/4Pbbb0fTpk1hsVhE09tsbMl2hD9paWkGnpV6wUEWNG9QvRrMsfNFXqkDEZlv1qxZ6NOnD2677TakpKTg+uuvty93ZrNw4UKMGDECTz/9NNq2bYtBgwZhy5YtSExMVH2cBx98EO+//z4WLlyITp06oV+/fli0aJHLoHfixIno1q0bUlNT0b9/f8THx4uWMVNj8ODBSEtLw4033ojGjRsrLsX20EMP4a677sLQoUPRu3dvnDt3Do8++qim45mhfv36eO+993D99dejc+fOWLNmDb799lv7vP8XX3wRR44cQevWre3ro3fr1g2fffYZli5dio4dO2LSpEl48cUXRcnglAwbNgwhISEYNmyY6P1gKqtGvXr1sqanp9v/rqystDZr1sw6bdo0ye3vvvtu62233SZ6rE+fPtaHHnrIarVarfn5+VYA1h9++EG0zdixY63/+Mc/rFar1VpVVWVt2rSpdeLEiaJtunTpYp0wYYKqetuOk5+fr2p7IvI9Lf7znbXFf76zPvPZDm9XhcgQvvpv09KlS61hYWHWBQsWWP/880/rmDFjrPXr17fm5eVJbr9582brM888Y/3000+t8fHx1jfeeMNpmx9++MH63//+1/rll19aAVi/+uorp21GjhxpTUtLs546dcr+c/78eU11N/Kajvhgk7XFf76zfrrpqNtlEQW64uJi6+7du63FxcXeropbLl++bI2JibG+//773q4Kednhw4etQUFB1uzsbJfbKr3/tfy7pHlYe0ZGBkaOHIkePXqgV69emD17NgoLC+3DzUeMGIFmzZrZh5o/+eST6NevH2bOnImBAwdi6dKl2Lp1K959910AQHR0NPr164fx48fbhyasX78eH330EWbNmgWgOjnA+PHjMXnyZCQnJ6NLly748MMPsXfvXnz++efu36EgIiIiO60rs/Ts2RM9e/YEAMnnAeCWW27BLbfc4vLY4eHhqudxms027zyHPedEAWv79u3Yu3cvevXqhfz8fPvyZ45Zvqn2KC8vx7lz5zBx4kRcd9116Natm8eOrTk4Hzp0KM6cOYNJkyYhNzcXXbp0wcqVK+1J33JyckRrj/ft2xdLlizBxIkT8dxzz6FNmzb4+uuv7WucA9VZASdMmIDhw4fj/PnzaNGiBV5++WU8/PDD9m3GjRuHkpISPPXUUzh//jySk5OxevVq0ZIFRERE5B49K7MYad26dbjqqqvQoEEDDBgwAC+99JJouSJHZq7OktiQwTlRbTBjxgzs27cPYWFh6N69O3799Vc0atTI29UiL9mwYQNuvPFGXHPNNR7vCNaVEC49PR3p6emSz61bt87psSFDhmDIkCGy5cXHx2PhwoUuj/vss8/K3pEnIiIi9ymtzLJ3715Tj52Wloa77roLLVu2xMGDB/Hcc8/hlltuQVZWlmxm3WnTpuGFF14wpT4JDM6JAl7Xrl2RnZ3t7WqQD+nfv799GTxP84ls7URERET33HOP/fdOnTqhc+fOaN26NdatW4ebbrpJch8zV2dhzzkREXmSpmztREREFNj0rMxillatWqFRo0Y4cOCA7DZmrs5i6zm/WFSO/OJyw8olIiKSwuCciIiI7GxzLjMzM+2PVVVVITMzE3369PFoXY4fP45z587Zl1T1tLrhIWhUNwwAl1MjIiLzcVg7ERERiWhdmaWsrAy7d++2/37ixAns2LEDdevWxdVXXw0AuHz5sqgH/PDhw9ixYwcaNmyIxMREXL58GS+88AIGDx6M+Ph4HDx4EP/+979x9dVXIzU11cNXoEZCwyicvVyGnPNF6Ngsxmv1ICKiwMfgnIiIiES0rsxy8uRJdO3a1f73jBkzMGPGDPTr18+eKHbr1q248cYb7dvY5omPHDkSixYtQnBwMP744w98+OGHuHjxIpo2bYqbb74ZU6dORXh4uAfOWlpiwyhsz7nIeedERGQ6BudERETkRMvKLElJSS4z27rKfhsZGYlVq1ZprqfZmBSOiIg8hXPOiYiIiGTYgnPOOSciX9W/f3+MGzfO1GM88MADGDRokKZjJiUlYfbs2arL1FNGoGHPOREREZEM9pwTETn78ssvERoaavpxtmzZgjp16qjaNikpCePGjTP9RoWZGJwTkd9RHjxLRGScxNjq4PzEhWJUVFYhJJiDDonIM8rLyz0SAOvRsGFDjxyncePGHjmOUFlZGcLCwjx+XIDD2omIiIhkxdWLQFhwECqqrDiVX+Lt6hD5D6sVKCv0zo+LHBhCly5dwvDhw1GnTh00adIEb7zxhtOQ7dLSUjzzzDNo1qwZ6tSpg969e4tybyxatAj169fHqlWr0L59e9StWxdpaWk4deqU6Fjvv/8+2rdvj4iICLRr1w5vvfWW/bkjR47AYrFg2bJl6NevHyIiIrB48WKcO3cOw4YNQ7NmzRAVFYVOnTrh008/VX1++/fvh8Viwd69e0WPv/HGG2jdujUAoLKyEqNHj0bLli0RGRmJtm3bYs6cOYrlOl6j06dP4/bbb0dkZCRatmyJxYsXq67jjBkz0KRJE8TGxuKxxx5DeXm5/TnhsHar1YopU6YgMTER4eHhaNq0KZ544gl7fY4ePYqnnnoKFosFFovFXsYXX3yBa6+9FuHh4UhKSsLMmTNFx09KSsLUqVMxYsQIREdHY+zYsRgwYIBT3pUzZ84gLCxMtNSo0dhzTkRERCQjKMiC5g0jcehMIXLOFyHhyjB3InKhvAh4pal3jv3cSSBM3VDojIwMbNiwAStWrEBcXBwmTZqEbdu2oUuXLvZt0tPTsXv3bixduhRNmzbFV199hbS0NOzcuRNt2rQBABQVFWHGjBn4+OOPERQUhPvuuw/PPPOMPUhdvHgxJk2ahLlz56Jr167Yvn07xowZgzp16mDkyJH2Yz377LOYOXMmunbtioiICJSUlKB79+74z3/+g+joaHz//fe4//770bp1a/Tq1cvl+V1zzTXo0aMHFi9ejKlTp9ofX7x4Me69914AQFVVFZo3b47ly5cjNjYWGzduxNixY9GkSRPcfffdqq7jAw88gJMnT2Lt2rUIDQ3FE088gdOnT7vcb+3atWjSpAnWrl2LAwcOYOjQoejSpQvGjBnjtO0XX3yBN954A0uXLsW1116L3Nxc/P777wCqh9knJydj7Nixon2zs7Nx9913Y8qUKRg6dCg2btyIRx99FLGxsXjggQfs282YMQOTJk3C5MmTAQCbNm1Ceno6Zs6caV8x5JNPPkGzZs0wYMAAVddEDwbnRERERApaNIyyB+fXe7syRGSYS5cu4cMPP8SSJUtw0003AQAWLlyIpk1rbirk5ORg4cKFyMnJsT/+zDPPYOXKlVi4cCFeeeUVANVD0OfPn2/vjU5PT8eLL75oL2fy5MmYOXMm7rrrLgBAy5YtsXv3brzzzjui4HzcuHH2bWyeeeYZ+++PP/44Vq1ahc8++0xVcA4Aw4cPx9y5c+3B+f79+5GdnY1PPvkEABAaGooXXnjBvn3Lli2RlZWFzz77TFVwvn//fvz444/YvHkzevbsCQD44IMP0L59e5f7NmjQAHPnzkVwcDDatWuHgQMHIjMzUzI4z8nJQXx8PFJSUhAaGorExET7NWjYsCGCg4NRr149xMfH2/eZNWsWbrrpJjz//PMAqm9W7N69G9OnTxcF5wMGDMDTTz9t/7tZs2ZIT0/HN998Y78GixYtwgMPPCDqlTcag3MiIiIiBbakcEfPMSkckWqhUdU92N46tgqHDh1CeXm5KMiNiYlB27Zt7X/v3LkTlZWVuOaaa0T7lpaWIjY21v53VFSUPTAHgCZNmth7jgsLC3Hw4EGMHj1aFHRWVFQgJiZGVG6PHj1Ef1dWVuKVV17BZ599hhMnTqCsrAylpaWIilI/iueee+7BM888g99++w3XXXcdFi9ejG7duqFdu3b2bebNm4cFCxYgJycHxcXFKCsrE40eULJnzx6EhISge/fu9sfatWuH+vXru9z32muvRXBwsP3vJk2aYOfOnZLbDhkyBLNnz0arVq2QlpaGW2+9FbfffjtCQuRD2j179uCOO+4QPXb99ddj9uzZqKystB/b8bpHRETg/vvvx4IFC3D33Xdj27Zt2LVrF1asWOHynNzB4JyIiIhIQQKXUyPSzmJRPbTcl12+fBnBwcHIzs4WBZEAULduXfvvjonbLBYLrFfmvl++fBkA8N5776F3796i7RzLdMxMPn36dMyZMwezZ89Gp06dUKdOHYwbNw5lZWWqzyE+Ph4DBgzAkiVLcN1112HJkiV45JFH7M8vXboUzzzzDGbOnIk+ffqgXr16mD59OjZt2qT6GHpJXbeqqirJbRMSErBv3z6sWbMGq1evxqOPPorp06dj/fr1bifOk8oI/+CDD6JLly44fvw4Fi5ciAEDBqBFixZuHccVBudERERECricGlFgatWqFUJDQ7FlyxYkJiYCAPLz87F//37ccMMNAICuXbuisrISp0+fxt///nddx4mLi0PTpk1x6NAhDB8+XNO+GzZswB133IH77rsPQPX88P3796NDhw6ayhk+fDj+/e9/Y9iwYTh06BDuuece0TH69u2LRx991P7YwYMHVZfdrl07VFRUIDs72z6sfd++fbh48aKmOqoRGRmJ22+/Hbfffjsee+wxtGvXDjt37kS3bt0QFhaGyspK0fbt27fHhg0bRI9t2LAB11xzjdONEUedOnVCjx498N5772HJkiWYO3eu4efjiME5EfkdDUlYiYjc1iK2ukeFwTlRYKlXrx5GjhyJ8ePHo2HDhrjqqqswefJkBAUF2ecVX3PNNRg+fDhGjBhhT9R25swZZGZmonPnzhg4cKCqY73wwgt44oknEBMTg7S0NJSWlmLr1q24cOECMjIyZPdr06YNPv/8c2zcuBENGjTArFmzkJeXpzk4v+uuu/DII4/gkUcewY033iiaV9+mTRt89NFHWLVqFVq2bImPP/4YW7ZsQcuWLVWV3bZtW6SlpeGhhx7C22+/jZCQEIwbNw6RkZGa6ujKokWLUFlZid69eyMqKgqffPIJIiMj7b3ZSUlJ+OWXX3DPPfcgPDwcjRo1wtNPP42ePXti6tSpGDp0KLKysjB37lxRpnwlDz74INLT01GnTh3ceeedhp6PFC6lRkRERKQgoWF1AzO/uBz5ReUutiYifzJr1iz06dMHt912G1JSUnD99dfblzuzWbhwIUaMGIGnn34abdu2xaBBg0S97Wo8+OCDeP/997Fw4UJ06tQJ/fr1w6JFi1wGwBMnTkS3bt2QmpqK/v37Iz4+HoMGDdJ8nvXq1cPtt9+O33//3an3/qGHHsJdd92FoUOHonfv3jh37pyoF10NWyK9fv364a677sLYsWNx1VVXaa6nkvr16+O9997D9ddfj86dO2PNmjX49ttv7XP/X3zxRRw5cgStW7e2r4/erVs3fPbZZ1i6dCk6duyISZMm4cUXXxQlg1MybNgwhISEYNiwYaL3hFksVmvt6IMqKChATEwM8vPzER0d7e3qEJEOSc9+DwAY3K05Zt6d7OXaELmP/zYZz6xr2uOlNTh7uRTfpv8NnZrHuN6BqJYpKSnB4cOH0bJlS48EMWYpLCxEs2bNMHPmTIwePdrb1SEvswX7W7ZsQbdu3WS3U3r/a/l3iT3nRERERC4kXuk959B2osCyfft2fPrppzh48CC2bdtm71V2zPBNtUt5eTlyc3MxceJEXHfddYqBuZEYnBMRERG5wKRwRIFrxowZSE5ORkpKCgoLC/Hrr7+iUaNG3q4WedGGDRvQpEkTbNmyBfPnz/fYcZkQjoiIiMiFRCaFIwpIXbt2RXZ2trerQT6mf//+8Mbsb/acExEREblQ03Ne6OWaEBFRoGJwTkREROQCh7UTqVNLck0TiRj1vmdwTkREROSCLTg/ebEE5ZVVXq4Nke8JDg4GAJSVlXm5JkSeZ3vf2z4HenHOOREREZELV9ULR3hIEEorqnDqYgkSY6O8XSUinxISEoKoqCicOXMGoaGhCApiHyDVDlVVVThz5gyioqIQEuJeeM3gnIiIiMiFoCALEhpG4cDpy8g5X8TgnMiBxWJBkyZNcPjwYRw9etTb1SHyqKCgICQmJsJisbhVDoNzIiIiIhUSrwTnR88X4m/gMktEjsLCwtCmTRsObadaJywszJDRIgzOiYiIiFRgUjgi14KCghAREeHtahD5JU4GISIiIlLBFpwfY3BOREQmYHBOAclqteKxJdsw4cs/vF0VMoEVXKaFiDyPPedERGQmBucUkHLOF+H7P07h083HUMElb4iIyAC2JHBHzxVxLWciIjIcg3MKSBVVNY0md7MmEhERAUBCg+rg/FJJBfKLy71cGyIiCjQMzomIiIhUiAwLRuN64QA4tJ2IiIzH4JyIiIhIpRacd05ERCZhcE4Bj/MCiYjIKLakcEfPMTgnIiJjMTgnIiIiUimBy6kREZFJGJxTwGO/eQDii0pEXsLl1IiIyCwMzomIAtCB05fx/q+HUFJe6e2qEAWUFrEMzomIyBwh3q4Akdk45Zxqo5RZ6wFUL/n01D+u8XJtiAKHref85MVilFdWITSY/RxERGQM/otCRBTAth+76O0qEAWUxvXCER4ShCorcOJCsberQ0REAURXcD5v3jwkJSUhIiICvXv3xubNmxW3X758Odq1a4eIiAh06tQJP/zwg+j5y5cvIz09Hc2bN0dkZCQ6dOiA+fPnS5ZltVpxyy23wGKx4Ouvv9ZTfaplrJygTLWYxdsVIAowFouF886JiMgUmoPzZcuWISMjA5MnT8a2bduQnJyM1NRUnD59WnL7jRs3YtiwYRg9ejS2b9+OQYMGYdCgQdi1a5d9m4yMDKxcuRKffPIJ9uzZg3HjxiE9PR0rVqxwKm/27NmwWNjcJCJSg1+XRMZjcE5ERGbQHJzPmjULY8aMwahRo+w93FFRUViwYIHk9nPmzEFaWhrGjx+P9u3bY+rUqejWrRvmzp1r32bjxo0YOXIk+vfvj6SkJIwdOxbJyclOPfI7duzAzJkzZY9FJIVzzqk2Y2xOZLzEWC6nRkRExtMUnJeVlSE7OxspKSk1BQQFISUlBVlZWZL7ZGVlibYHgNTUVNH2ffv2xYoVK3DixAlYrVasXbsW+/fvx80332zfpqioCPfeey/mzZuH+Ph4l3UtLS1FQUGB6IeIqLYJYtc5keFsPedHzzE4JyIi42gKzs+ePYvKykrExcWJHo+Li0Nubq7kPrm5uS63f/PNN9GhQwc0b94cYWFhSEtLw7x583DDDTfYt3nqqafQt29f3HHHHarqOm3aNMTExNh/EhIS1J4mEVHAYGxOZDwOayciIjP4xFJqb775Jn777TesWLECLVq0wC+//ILHHnsMTZs2RUpKClasWIGff/4Z27dvV13mhAkTkJGRYf+7oKCAAToR1UKMzomMZgvOj50vgtVqZS4cIiIyhKbgvFGjRggODkZeXp7o8by8PNmh5vHx8YrbFxcX47nnnsNXX32FgQMHAgA6d+6MHTt2YMaMGUhJScHPP/+MgwcPon79+qJyBg8ejL///e9Yt26d03HDw8MRHh6u5fQoQHHOOdVmQYwZiAyXcCU4v1RagYtF5WhQJ8zLNSIiokCgaVh7WFgYunfvjszMTPtjVVVVyMzMRJ8+fST36dOnj2h7AFi9erV9+/LycpSXlyMoSFyV4OBgVFVVAQCeffZZ/PHHH9ixY4f9BwDeeOMNLFy4UMspEBHVKuzQIzJeRGgw4qKrOwA4tJ2IiIyieVh7RkYGRo4ciR49eqBXr16YPXs2CgsLMWrUKADAiBEj0KxZM0ybNg0A8OSTT6Jfv36YOXMmBg4ciKVLl2Lr1q149913AQDR0dHo168fxo8fj8jISLRo0QLr16/HRx99hFmzZgGo7n2X6plPTExEy5YtdZ881Q5c55xqMwuHtROZIrFhFPIKSnH0fBGSE+p7uzpERBQANAfnQ4cOxZkzZzBp0iTk5uaiS5cuWLlypT3pW05OjqgXvG/fvliyZAkmTpyI5557Dm3atMHXX3+Njh072rdZunQpJkyYgOHDh+P8+fNo0aIFXn75ZTz88MMGnCIRUe3FnnMicyQ0jMKWIxe4nBoRERlG8zrnAJCeno6jR4+itLQUmzZtQu/eve3PrVu3DosWLRJtP2TIEOzbtw+lpaXYtWsXbr31VtHz8fHxWLhwIU6cOIHi4mLs3bsXGRkZiglWrFYrBg0apKf6VMtwzrnv+XRzDn7em+d6Qxl8SdVjcE56zZs3D0lJSYiIiEDv3r2xefNm2W3//PNPDB48GElJSbBYLJg9e7bTNr/88gtuv/12NG3aFBaLBV9//bXTNlarFZMmTUKTJk0QGRmJlJQU/PXXXwaelXFaNKwDAMjhcmpERGQQXcE5EZFef+VdwoQvd+Jfi7Z6uyq1ArNIkx7Lli1DRkYGJk+ejG3btiE5ORmpqak4ffq05PZFRUVo1aoVXn31VdkEsYWFhUhOTsa8efNkj/v666/j//7v/zB//nxs2rQJderUQWpqKkpKSgw5LyMlxkYC4JxzIiIyDoNzCnjsZdWmvLIK7/96CPtyL5lSfl5BqSnlkjSG5qTHrFmzMGbMGIwaNQodOnTA/PnzERUVhQULFkhu37NnT0yfPh333HOP7Eopt9xyC1566SXceeedks9brVbMnj0bEydOxB133IHOnTvjo48+wsmTJyV72b2Na50TEZHRGJwTkcjCDYfx0vd7kDr7F29XRWTn8XxvV8EvseectCorK0N2djZSUlLsjwUFBSElJQVZWVmmHffw4cPIzc0VHTcmJga9e/dWPG5paSkKCgpEP55gW07tZH4xyiqqPHJMIiIKbAzOKeBZOelck999NAi+fe7/vF0Fv8TQnLQ6e/YsKisr7YlebeLi4pCbm2vacW1laz3utGnTEBMTY/9JSEgwrY5CjeuGIzI0GFYrcOJisUeOSUREgY3BORGJmB3McWk7zwoy+AXNKyjBW+sO4HxhmbEFE+k0YcIE5Ofn23+OHTvmkeNaLBYObSciIkMxOKeAx1CQajOjh7UPf38TXl+5D49/us3Qcsl3NGrUCMHBwcjLE6+okJeXJ5vszQi2srUeNzw8HNHR0aIfT0lgcE5ERAZicE5EHmXELANOVVDP6JEQB05fBgBsOHDO4JLJV4SFhaF79+7IzMy0P1ZVVYXMzEz06dPHtOO2bNkS8fHxouMWFBRg06ZNph7XHfae83OFXq4JEREFghBvV4DIbIzjqFbjpHPSISMjAyNHjkSPHj3Qq1cvzJ49G4WFhRg1ahQAYMSIEWjWrBmmTZsGoDqJ3O7du+2/nzhxAjt27EDdunVx9dVXAwAuX76MAwcO2I9x+PBh7NixAw0bNkRiYiIsFgvGjRuHl156CW3atEHLli3x/PPPo2nTphg0aJBnL4BKiQ25nBoRERmHwTkReRTvlXiWhdE56TB06FCcOXMGkyZNQm5uLrp06YKVK1fak7Xl5OQgKKhm8N3JkyfRtWtX+98zZszAjBkz0K9fP6xbtw4AsHXrVtx44432bTIyMgAAI0eOxKJFiwAA//73v1FYWIixY8fi4sWL+Nvf/oaVK1ciIiLC5DPWp0VsHQBAznkmhCMiIvcxOKfAx2jQp3BIumcZnRCOao/09HSkp6dLPmcLuG2SkpJcfrb79+/vchuLxYIXX3wRL774oqa6eottzvmx80WwWq1cupCIiNzCOedEJMLGZWDhy0lknuYNqoe1Xy6t4AoGRETkNgbnFPC4dJdv4avhWRzWTmSeiNBgxEdXD7nnvHMiInIXg3MKSAxH9OO1CyzsOScyF9c6JyIiozA4p4DHKc5Um3GaApG5EmNr5p0TERG5g8E5EXkWb5Z4FGNzInOx55yIiIzC4JwCHmNBbRjMBRa+nETmsgXnR88xOCciIvcwOPdjhaUV+CjrCE5e5Pqq5D+YoM+zeLOFyFzC5dSIiIjcweDcj730/R5M+uZPDJq3wdtV8WlcV1sbxnKBhdnaiczV4sqc81MFJSitqPRybYiIyJ8xOPdjv+w/AwA4fanUyzWhQMJbGYEliLE5kali64QhKiwYVitw4gJHshERkX4MzikgWWV+J+/jQAbP8sds7ScuFqOyim8U8g8Wi6Vm3jmHthMRkRsYnBORiD+EcgzbAtfq3Xm4/tWf8dDHW71dFSLVOO+ciIiMwOCcApKwd5Y9tb6Fr4dnearjfM+pAlz/6s/4Ivu4W+W898shAMCaPaeNqBaRR9iXU2PGdiIicgODcyLyGibrM1+Qh6LzcUt34MTFYjy9/HePHI/Il9iSwnGtcyIicgeDcwpQVsFvDAC18OQcZcbm5vPUq1lWWWVIOfy8kj+yDWtncE5ERO5gcE5EHsXQy7M8da+FoyCoNksUBOf8LBARkV4MzikgWZmuXTdPJoTz9EtTVWVFflG5h4/qXf6WrZ1xDfmj5g0iYbEARWWVOFdY5u3qEBGRn2JwTkSGK6+sQnFZpeRz3uxVGvPRViS/+BP+PJnvtTp4mn+F5ryXRv4pPCQYTaIjAHBoOxER6cfgnGQVlVUg6+A5v1xvmB3n3jVywWYkv/ATzl0udXpO9Np4OFDP3FudAfyjjUc9elxv8lTPuVGvJIcEk7/icmpEROQuBuck64EFWzDsvd8wf/1Bb1eFPMmAWG7jwXMoq6zCit9POj3H2MuzPDfn3KByjCmGyONs886Pcjk1IiLSicE5ydp85DwAYNmWY16uiXt8JRgsr6zC0Hey8PL3u71dFY85eOay4vN6XxpfeU39gb8NayfyV4nM2E5ERG5icE6qWa1WTPjyD7z7i+/3pPti8Pbz3tPYdPg83vv1sLer4jHHLxQrPu+t18nPcqRpJhwa7rGec4P6vLW+J37YeQrTV+3lcHjyukSudU5ERG5icO4BCzccxpw1f3m7Gm7bcuQCPt18DK/8sNeQ8vblXsKtc35F5p48Q8qT4yvrJldU+kY9PEk6XUHtuw6eJoxTgwL8TsSji7dh3tqDWLfvjLerQrVcIuecExGRmxicm8xqteKFb3fjjTX7/f4f7KKyCkPLe+STbOw+VYDRH241tFzAdwJyUuat1ynQO1mrhD3nXqyHHnpfmjOXnJMPEnmSLTjPLShBSbn0ahVERERKGJybqLC0ApdLawLaYoP/sfZ0h5jRWZ/ziz2z3nSgB2JGsxgYzkkNNQ6E18NqtWLXiXzR59uXiEYseCpbu3Hp2vXtxhty5GUN64ShTlgwrFbXU3qIiIikhHi7AoGqvLIK105eJXrM33qwbGxte6Prb2ZTOhACwNrAX1+nNXtOY8xHW5EUG4V142/0dnWcCANVPZ/b84VlKCqrQPMGUeqPyWztVMtZLBYkNIzC3txLOHa+CFdfVdfbVSIiIj/DnnOTXCgsc3rMX6d+2hrdflt/b1eAAs63V5aIO+KjSyYJA2U9n9tuU1fjb6+txVmJdep9lb/e6KHA0oJJ4YiIyA0Mzj3KT6PbK4wc7gxID3nWuv+DH27FQx87z1n3xYa6v9zcMLuevvDSuDsE2tdfS6MSwu3Pu2RAbbTR+9n1hfcVEZdTIyIid3BYuwf5eoPeFaPr725j+uzlMqy5kuk9v6gcMVGh0sfxxUidAPjmTRQ1fPWjfOD0ZZRVVNl77wD36mr0DTkz+et7iQKLLTg/6qOjaoiIyLcxOPcg/2nmipk159xdwt7PKoeWOZND6Wf26xwIQZTRyRGNYLVakTJrPQBgw7MD7I/7YFUV8bNL/iyBy6kREZEbOKyd1DO659zNNrjaXr1ACAYDlb8GYr4Y8Arf56cu1mSK9tSNBKNGqOgf1u6f7yUKLC1i6wCoHtbOUVtERKQVg3OzSLSHfbG3TQthMOxrjQ7H2vhY9QJKRWWVYWX56+vkzjxutX7ceQqbD59Xvb3wUpYJXiN3quqNryzdwbmfvpcosDSrHwmLpXrp1LOXnRPDEhERKdEVnM+bNw9JSUmIiIhA7969sXnzZsXtly9fjnbt2iEiIgKdOnXCDz/8IHr+8uXLSE9PR/PmzREZGYkOHTpg/vz59ufPnz+Pxx9/HG3btkVkZCQSExPxxBNPID8/X0/1DXP2cinK5QIViYaif4fm4oa6EQ1hdwP8IFF92DL3hKnf7UanKT/h6LlC3WUY0cPpbgnuj9ow15GzhXhk8Tbc/U6W6n2En4GKSuFSavprq2VPb38CvX18IgAICwlC05hIAEDOef3fk0REVDtpDs6XLVuGjIwMTJ48Gdu2bUNycjJSU1Nx+vRpye03btyIYcOGYfTo0di+fTsGDRqEQYMGYdeuXfZtMjIysHLlSnzyySfYs2cPxo0bh/T0dKxYsQIAcPLkSZw8eRIzZszArl27sGjRIqxcuRKjR4/WedruO3D6Enq8tAb/nLtB9T6B1Hj0hXMRjkTwhfrUBh/87zCKyysxb+0BQ8rz19fN7B7lk/nFrjdyILyWFVXG9JxrOr6frHOeV1DC+cBkqoSGtuCc7zMiItJGc3A+a9YsjBkzBqNGjbL3cEdFRWHBggWS28+ZMwdpaWkYP3482rdvj6lTp6Jbt26YO3eufZuNGzdi5MiR6N+/P5KSkjB27FgkJyfbe+Q7duyIL774Arfffjtat26NAQMG4OWXX8a3336LiooKnafunhU7qtc53nOqQPU+jknL/I1wKK8R52Lk1VCqjq9e9hmr9uGutzagpLzSo8c9fLYQ23IuuFVGZGiw7n199fXQwuws5nrKF17XckHP+erdefrr4U9TcVS8saxWK3q/kom/v74Wl0rKPVApqo3sy6md036TjYiIajdNwXlZWRmys7ORkpJSU0BQEFJSUpCVJT38MisrS7Q9AKSmpoq279u3L1asWIETJ07AarVi7dq12L9/P26++WbZuuTn5yM6OhohIdIJ50tLS1FQUCD6MZKe+MLooMTT7Wbh8Qy50WDi0GJ/CADnrj2AbTkX8e3vJz163BtnrMNdb22U7T1U876KcCc4F/7uDy+UBF+PWYXTbbKPXsDO496dAqSF3veEmr2qBBvlFZToOg6RK8KkcERERFpoCs7Pnj2LyspKxMXFiR6Pi4tDbm6u5D65ubkut3/zzTfRoUMHNG/eHGFhYUhLS8O8efNwww03yNZj6tSpGDt2rGxdp02bhpiYGPtPQkKC2tM0hkTj3V8DERvhKdlOpbLKime/+AM3zliH3SeNvQGihdI8Zl/P4qzlRkdVlRUXCo1JMnTorP75kO4E50LeemXcPa7ZPcp6ihe+z4VzzgHgr9OX1JejOzj2jc/ZjztPyY5oEg7390RSP6qduJwaERHp5RPZ2t9880389ttvWLFiBbKzszFz5kw89thjWLNmjdO2BQUFGDhwIDp06IApU6bIljlhwgTk5+fbf44dO2ZonV22XyWe942mq35SCeG+33kKS7ccw+Gzhbj1/37VVJ6710PYuPaH+x5yoYCWIGHsx9noOnW128PSlagZUq02OL9YVI7/y/xL1Ej195tUgPk953oukXCfMjcy6gvL8aVs7YfPFmLWT/twsUj65pTVWj1K4JHF23DLHOnvIuFNi+AgBudkDtuw9qNMCEdERBpJjwmX0ahRIwQHByMvTzyHMS8vD/Hx8ZL7xMfHK25fXFyM5557Dl999RUGDhwIAOjcuTN27NiBGTNmiIbEX7p0CWlpaahXrx6++uorhIaGytY1PDwc4eHhWk5PEz29RP4+51zIdv55+fqHhpoZpAlfH1+/7FqChDV7qj9LCzccQbfEBm4dV+v1rxKMCY4MVXdfb+eJfOw8kY9FG49g2/P/kKiDpirIKq2oxCOfbEPf1rF48O+tjClUga+HdY4951oIv6c0ZWtXecjDZwvx4cYjeKhfKzS5ktVajVvn/Iri8kocOHMZbw3vLnF8K/blKo8QqKhicE7mswXneQWlKCmvNGykERERBT5NPedhYWHo3r07MjMz7Y9VVVUhMzMTffr0kdynT58+ou0BYPXq1fbty8vLUV5ejqAgcVWCg4NRJRiCWFBQgJtvvhlhYWFYsWIFIiIitFTdcC4bopLD2k2pigcJE8LZ/u8bJ+Uj1dDFX4KE0oqaz2NkmLbG5nmDhuLL+Xr7Cfy89zRe+n6PqcexMXtItK5h7YLPgHD4tuZyTN7v/729EYs2HsHDH2fLlCNdUvGVxIlbj0iPGrFCvLyilEoG5+QBDaJCUS+8uu/j+AUObSciIvU09ZwD1cuejRw5Ej169ECvXr0we/ZsFBYWYtSoUQCAESNGoFmzZpg2bRoA4Mknn0S/fv0wc+ZMDBw4EEuXLsXWrVvx7rvvAgCio6PRr18/jB8/HpGRkWjRogXWr1+Pjz76CLNmzQJQE5gXFRXhk08+ESV4a9y4MYKDPX9XWk8D1lcCWa1sTVjxsPbqc6ny4ikpzjO3CrfzPcJea1/LiC1XnaKympURwkMM+swZ9OIUlno2470vxnXCz0O5Gz3nZg9rP3flRs3vJiSpC3Lxwrhz04JILYvFgoSGUdh9qgA554tw9VX1vF0lIiLyE5qD86FDh+LMmTOYNGkScnNz0aVLF6xcudKe9C0nJ0fUC963b18sWbIEEydOxHPPPYc2bdrg66+/RseOHe3bLF26FBMmTMDw4cNx/vx5tGjRAi+//DIefvhhAMC2bduwadMmAMDVV18tqs/hw4eRlJSk+cS9wU9jc3uTX9jstQXl7iSBMnQpNZ8MweUJg6dgHRGQN+ZtFwuWfDMqaPO3181Gzw2VX/86g/LKKgxoF+dyWz2XV9Rz7jDnXMvbxduviau6yj1ttbq+bu4M9yfSIvFKcH70HHvOiYhIPc3BOQCkp6cjPT1d8rl169Y5PTZkyBAMGTJEtrz4+HgsXLhQ9vn+/fv7XBIpdxM2+SOLKAGb9cr/9Zdn5PVw7MFXWq5r44GzOHahCEN7JhpXAY2EPXjBbqRlrKqy4v3/HULXxAbomdTQgJrJKy6rCc595XW3MaOHd/XuPHz821HM+H+dUVRWiaeX/45H+7fGTe1dB9eOyiqqcP8HmwEAv0+6GTFR8vky9BJeVuEUBM3l6Hx9PPX9Jnec6mHtym8E4bB2f/8+Jt+WGHtlrXNmbCciIg10Beekr3fJ2z1Selkc/g/UNGyrvDiuXW/j+t73q0dhdGgSg07NYwyskXrlFTWVd2f+8nc7T+GVH/YCAI68OtDteikRJtMSvpcvl1agbnjNV4mWG2n6A0Grw9/6ylEy5qOtAIAXvtuNkxeLsT3nIkZ/uBVHXh2o+WaAcN3xS6XlLoNzPT3zwmtSWmHUMH/373oUllbgsSXbkHZtPO7p5fqGmOuXUn4LV/PIxe9hIvMkcjk1IiLSwSeWUvNLOlp23pyfbQRhvFBlwJxzI29WOAdrrhvhJy4WG3Z8rcoNWm/50JnLss9VVVnx2ZZjLjNYqyWax3/l92k/7EHHyauwbt9pye0ky/GzsOjc5VKnhHZqlpuTY1aOAVHPebn+nnP9uTGk91u44TDW7TuDZ7/cqa4UveusW60ub5pUCj53vjYaiwKLLThnzzkREWnB4FwnPc06f28MCgMS25m4k+TO3cshHrruXlmeIAwchD2pZlX92z9O4t9f/IHU2b9o2k9N7Gi73u/8cggA8LIgS7qW8zHq3LXGu5rmYFudt9eaEM6d81T7vSHczHFYu5brY3RCuPzick3buzpbpcvh6kaXMNeDP3xneNu8efOQlJSEiIgI9O7dG5s3b5bd9s8//8TgwYORlJQEi8WC2bNn6yqzf//+sFgsoh9b/hl/IgzO/f3ffiIi8hwG5zq5/MdW4ml/7zkX9njagnJvnlKZwrxaXw/chYmpKk16Y+w0OBu2aO14h+f0BnH+0Gi1wrm33+wE++KVEVTuJArOxcPatSWEE9RD/W7yc8E9OBddy5xzUrZs2TJkZGRg8uTJ2LZtG5KTk5GamorTp09Lbl9UVIRWrVrh1VdfRXx8vFtljhkzBqdOnbL/vP7664afn9ma1o9EkAUoKa/CmUul3q4OERH5CQbnOulLCGdsw9CdobVus2Vr13lOF4vK3Epadex8Ea6blllTHR9rc+ecK8KWI+dlny8T9JybtcSeUQHkucul+GbHCZSUqxsS7Oo9ofT059nH8c76g5rr6GlGDU1X8/lRH5sL55y7kxDO2Pej5tJ0ZmsHXI9oqGBCONVmzZqFMWPGYNSoUejQoQPmz5+PqKgoLFiwQHL7nj17Yvr06bjnnnsQHh7uVplRUVGIj4+3/0RHRxt+fmYLCwlCk5hIABzaTkRE6jE4N4lUu8+f2oJS85SFjVlbG1dvYHnX2xt17WezcMMRxefF1fL8lb9h+loMmZ+F/XnS872FPed6rqG5ZySOcO559zc8uXQHXl+5V9XxtQxLdtz2meW/Y9qPe3H4bKGqmnqLO6G5bd9nlv+Om9/4BSXlxiRvEw1rd2POudHvLaODYLmbB1ZYJW+aVFVZkZtfAsBhzrlffSN7VllZGbKzs5GSkmJ/LCgoCCkpKcjKyjK9zMWLF6NRo0bo2LEjJkyYgKIi5eC2tLQUBQUFoh9f0IIZ24mISCMG5zrpadZJZTZfuSsXN7y+Fr8fu+h2nYw09uOtis+7mxDu0Bn3gi/HNrivNrR3n5RuJArnnPv6UNu/Tlcnndt0WDASQKHK+teprnmmsLRCZe08w/GctPacC8/tqWU7AFSPEvjr9GVRMj2lfS+VlCvO3xZWsazSmKXUtJyn7Osq84xc0S5v7sg9bhX3nNu+b59Yuh3XTcvEyl25nHOu0tmzZ1FZWYm4OPGygXFxccjNzTW1zHvvvReffPIJ1q5diwkTJuDjjz/Gfffdp1j2tGnTEBMTY/9JSEjQVUejMSkcERFpxeBcJ5cBiMTzUrs8/Ek2cs4X2Zdt8hVnBXPkbA100TzuK/83a0i2K47teuf41jda3nKBiSghnElV1Tv0WlVCOMc52KJkga6GtUsHSFWioNB1Hdyh6WaOwQnhRDc5IP36i5YtRPUNnE5TfkLyCz/JLpNm2FJqXv7ouDOsXjjnvPJKOd/9cQoA8Pb6g+J1znUfhcw0duxYpKamolOnThg+fDg++ugjfPXVVzh4UH66y4QJE5Cfn2//OXbsmAdrLC/BFpyfY3BORETqMDjXyWUAIvG8UiBbXKbcmP7j+EWcyvfc0l/ihGpW0f8BwSgAH2nhKs+B9mBFVCr3QEI4V9w5qnNPsr7jCj8nFYIhx67Wq3ZKSKf+8IYw++aBkNUKFJXVjCQ4d7lMejvB7yUGLaWmLSGczHBzjW80LdMiHPeTWu7RxgLHOec++MXgIxo1aoTg4GDk5eWJHs/Ly5NN9mZWmb179wYAHDhwQHab8PBwREdHi358AXvOiYhIKwbnOulq1ykNBVbY7cDpy/jn3A3oM+1nhfqoq9Dl0gqXNwKqy1NVnPd6zp2GtTv8raJangywrhzR/luFQQnhvJUUUHHOuc5xycKbFMGef3E00Xrdtb7EomztKjPFC4/hzjx24dH03nRxh96Pg2O29iqH+xMWi/hzx9BcXlhYGLp3747MzJqkm1VVVcjMzESfPn08WuaOHTsAAE2aNNF1XG/inHMiItIqxNsVCFRSDUylDlKl4PqP4xclHxc2nHu9konvH/8broqOkC2nqKwCf3vtZ9QJC8GajH6IDAuWr49E01X4iLtzzo2m1KBXmqPqLUZla1cawWFmeFtYWoFxS7fr2ldUZ8Gvwl7NIK3jxk3m+Pn0dM+51ndIuVtzzo39YMiVp/cSKiWEE75vKl32nOusQC2RkZGBkSNHokePHujVqxdmz56NwsJCjBo1CgAwYsQINGvWDNOmTQNQnfBt9+7d9t9PnDiBHTt2oG7durj66qtVlXnw4EEsWbIEt956K2JjY/HHH3/gqaeewg033IDOnTt74Sq4x9ZzfvpSKYrLKhX/zSUiIgIYnOumpwGrFEjp6ogX7HTmUineWncQU/55rez2Zy6V4mJROS4WlWPdvtO4pZO6ngjJDMi2Ue1eauA618k3W9plFVVYuSsXfVrFih4X9hLrusHh5dOdt/YALhRJJydz9Z6QO99KwVB/V+tVe5rTMHov1k+u1174/SKcNqGV0W8treUJz+NiURnqR4WpLk94ZaSmi4gf883vDF8xdOhQnDlzBpMmTUJubi66dOmClStX2hO65eTkICioZvDdyZMn0bVrV/vfM2bMwIwZM9CvXz+sW7dOVZlhYWFYs2aNPWhPSEjA4MGDMXHiRM+duIFiIkNRLyIEl0oqcPxCEdrE1fN2lYiIyMcxODeJVLNPuefctKpIHqPQxdB2yYR2wg5Pe8+5byaEE8+ZlynDA/HVzJ/24/SlUnRqFoPHbrxask7emnMud/pqLotcYA6oSQgn3LaGsKfT9JdGUz44q/Mce+HzVuklvJSOl/HZjpqyJHcVJNhTW1fBdu71nHt2PyWPf7odH4/u7XAg+eMLb+o4j3awsOdco/T0dKSnp0s+Zwu4bZKSklTdtFYqMyEhAevXr9dcT19lsViQ2DAKf54swNFzDM6JiMg1zjnXyXXSIolh4UpJy5SGJxsUqUgNS1ezbU29nXt7vZZUyXHOuY82tE9fyXq/80S+6HEtr4Vu2uJFjxG+1+VuUrhTt1/2n3Fjb2eS2dQtys87leFwRl9uO6H++BI3B6S3q6ElOP/1rzN4Z/3BmsSPMq+PXpoTwgm2//Wvs5r2Fc6GcLzpZQHnnJPnMSkcERFpweBcJz2NVqV9PN15KrXmuojL+vjYnHOHCot7Z32kkgLCgNzla6HAWwnhHFks6nt65Z53J5O28PgjFmxGXkGJpv1dUVo6Ts3NFaVNPv7tKB5dnC0KqLUG/47bVWgY1n7/B5sx7ce9WLfvjFM5Wl4FpbngWrh8/6g8vtOccwvnnJPnJTIpHBERacDgXCctQ3dV7aOjoai1R13YeHVsuDpXRzDE2LbOuWCXmpXUvDUkW3zy/tbQFr8WXqyIBHdHargcVSL6XXAdBBfC3UtidHDuSLxkl+vtlTbZcOAcftiZi292nNS8r3i7mi3LdAxrP36xeqlG3cPa5R730vtb6rji0Rk+9sGjgGTrOT/G4JyIiFRgcO5Bjkv7CHmioSgeSu1iW5XPe6vn3DGAdOy9FAa/vhi4S83fDxQuz0fmeeE65+5eE729r3LbOpYXJArO1fScu97mUon8PH4hNUup6ZpzLjms3f33ptHvbqX11IXPOA9r55xz8jxbcH6UwTkREanAhHA66RrWrrM8M4Yu6xlKLTVP2luBpVOudj9raAsvv5qEcEfOFmLXyXynx32l90+UIM3FtuJ8BjW/V5ocOLnzXnXcUziMXlVwrvvIV+qtsXfecVi7tuHp+vbTSi6JnqvXSbaHHvLvp+oDijfwt+8M8k/CnvOqKqvPLRNJRES+hcG5TnradUqNeOEzJeWVmPTNLqS0j8PN18arr5OrRq2GgFDqWfGw9itzzvUnhXaLluTYvtgIF805l6jfqfxinLtcho7NYgAA/WesEz1vZlDu7s0gQ+acu1UD5/2tViv+3/wsN0utoXlYuxsn5HRjQPYYNVtWuDGkRfeeMjsa/flTKk9LMjtfubFFga1p/UgEB1lQWlGFM5dLERcd4e0qERGRD+Owdp30BCCKjUrBkws3HMFnW49j7MfZOmsnexT7by6ztasM9L21lJojH6mGIovMUGipa9hn2s+47c3/4dCZy8plKgTSWoPsP45fxDvrD7rMR+Au0ZQDweNm9pyXVVYh++gF+99abz84L6Wmtedc2wmJl2pTt7/y6Bv1jJ8SIl2I7E0GvUdx2NEpIZxD2f7wnUH+LzQ4CE3rVwfkTApHRESuMDjXzVXPs/Pzykup1cjNL9ZVo7OXy5TrJNHzraY+Nfs7N9q91b51DDyd55wLfvfBHjK1oxgcl2Bz/7jyx/rn3A2Y9uNeLN2c4+ZB1D8t19v7/q+HNB3SzDXrq+soPinhyFSr2aNHrJ4NJMXHUn9g2eHmGuuut8fbcck5pznnHE1MXmJfTu0cg3MiIlLG4NyDlNqcir1eMo1Kx4e/33kKC/53WFVdHPNFZR+9gHvezcLukwUu6wPUNJCVErF5ku+F38qE2bS9NvpA5rDCmEbt6yla+kvHSgYAUCmYI7E8+7iq48qVqXfeslpyoyDcOaCwGNHSdI5XVEVCOD1su+vO1q6QqE1bPfRVwHFqvmN9LLA4JGLUdRgizZgUjoiI1GJwrpOeYe1qgzB32owvfrdbVbmOdRn89kb8dug87v9gk9N+tlhAvP+Vxxwqa2b29r/yLuGpZTtw+Gyh0w0Lx4a4lrmn3vDvz/+w/+7OOudKpG7qGN2LKXUsLZnShdtqWZtbS++8GbQPa9fPalV3k0QpqJV7RmrUhq9/dtTWSWp6RqCtjED+IYHLqRERkUpMCKeTrmztKvcxq/0oGtYuExCeK3QeGi/Vo2Zr5Do2diurrAg2KRvt/5ufhfzicmQfvYBBXZpK1lELXxnl6k5srrWXUU0PrOz2eo4h9bzMG9ydue4uEwS626vs2DMvyt+gfX9XHLPfq9ldzTFOF5QgOjIUEaHB+HlvHh75ZJtiOUZ8Fcm9R9UsCSddnsJzgp1dDWv3xekuFJhaNKwDgHPOiYjINfac6+Ry6K7EY+p7zs1vNLqb9MvW7nUMTIwaoj1lxZ9IfeMXlJRX2h/LL65eBzrnfJFTS9sp4DNmpLFHKL0W3u7oe2DhZo8dS82ScmoZed2kgmOpG1XKZeivkNUqnkstmxXdRTk554rQ65VM9J++Dit35eJfi7aitEK4try6cmTrKfe40e9hhfMXje5xmLpjsciP2iAyk33OOYNzIiJygcG5Tr7QsNNaBVFvn651zoXDXa2SdTAqwFq08Qj25V3Cd3+cUrX9psPnDTmuEbQOndVzQ2PrkQsAXGVrd6a1br/+dVbT9mqOITfv153lvxzd824Wzl0ulTxO9d/qj+VqWLmaG13uTEuvDjrVHEN5m5/35gEAcgtK8PAn8itBGJ2tXfv3lN4Difd0/Fw5flZ84CucaglbcH7mUimKyiq8XBsiIvJlDM510jN0V3XPuSeGtWs4hr1JKzHc1TEANHoZLtt1dBqi6rDd6yv3ifcTlSFdtlnD2rVeAj03Sk5fKnU/86+BL5Uw8HH52ZDZolLLnHOn44uVV1rx8vd7XB5TLaeec8Hvqoa1u3E8x2TxSkG8EovKdOV6EgIq8Vy2dogugvScc+HvDM/JM2KiQhEdUT2L8Nh5fauxEBFR7cDgXCc98yJVzzlXWQd3gku3h7XLRCRGJDeTKmPEAnGiOl9eFknrFVC6ZEpB5YEzlzQeybzeQk0J4USBZs0f7vScS+158Gyh6jppPp7wRpeKeqsa+q5yqUWznLlUii1Hzus+mlz1ZeecG7zSeXW2dvnRQU7D2nUdhUifFrGcd05ERK4xOPcgtbGHNxPCKe4v8btjkOzusPayiiqkzFrv9PiGA+cc/lY/3NrTiZ+09sjpvWZLNimvR+6tGxiurrfc6Ro55xwAzl4SDGt3syylhHBmfF5FQ8thdejxldvHvWPOXXsAQ+ZnIetgzWdNS5Ge+pwp3QTQMjqIHefkSZx3TkREajA410nPWs7q5xY79vgYE2UJ6+xuIGQ7F8dTcrdHflvOBRwS9HjK2XJlzrWc0opKxefNJHdp5V5FvUn01uw5rXkfjwQkGoYli+ecV0ls7boMQPranhEG526cuNXF/qqWUnPjuheVVooSIzo6XVCC57/ehX258iMprFYrihXKEPqf4MaXIe8Xw4e1C7eV31hymTg1mfUc7M0tcH8KCdV6XE6NiIjU4FJqeulptBrQ0LVarbqDdb1zzqX2t52L01xcH+iNevn73Xjv18P2vz1dJ609iErBnS9cT6PJLdVldM95WaUgE7ljHdwsW/xZMv5FEpbYf8Y6h+fEx3vqsx3YcOAcPv7tqGx54z//w8DaSZPv0Tb6ODJzzq3Kr4vj96aal+3c5VKkzf4VAHDk1YHaKkokYOs5P3rO9c1nIiKqvdhzrpOKvjKnR4xICGdUHKAnoFCztrO79TNijIAwMHfkiSRQWg9Rqb7D2PlYCu9EqTm9nhh6rPcIRmZrd+T2OucKz0lV2/FGg6FLuzmU9efJAuMKh+PNE/crLvuZk1vnXFPZ4v2E+zpna9d+nGMXxMm7ftl/hj2fpEuLWA5rJyIi1xic66RluSj7Y6rLVnhOZRmuGDes3Sr5uF5GDeEXEg+DNbx4t7lzw8DEeFYT4avmOiGcVfJ3I5IJyh/U4OKE9XY44ddX7kXnKatEPWRag1wtbwmjPzGil8EKrN6dpynHgyPDe85Vlu20woPFIZhXUbEgwcX97dA5jFiwGX9/fa2qehIJ2XrOj10oNve7joiI/BqDcw9S3XOuMJ9WWIbWQNbdobhSw5GNHi7syIxg3Wyal1JzIziv1DBPGzDx5oRFuJSa9htX1fv5qOo04E4PSf0OAG+tO4jCskq8sXq/7DYqDqr6GeM/IzVHOHO5FGM+2orh729S2F66XrqPrvNN6rgevavPlZrjBAmubfbRC/bfl2zKwdfbT+ioJdVWTWIiEBxkQVlFFU4L8mEQEREJMTjXyVWzTup5vYGRGT2/7vZw2/d3KMZVj0BFZRWOX5Af1ucYZxgRdogzX5tP7trKBVHuTGNQGhLvtWztrnrOZX43k9HrnKsp2xvnaQTh63fucpngcQ0vrEx5qo6vZVvHrPaC5xzvW1kgfq3UHEfuM/TcVzvx8g97VNeTKCQ4CM3qRwLgvHMiIpLH4FwnPbGt2h4h5WHt+pv57mZrt0r84Vgfqbq/vnIvpqz4EwAwcuFm/O21wB4WqvXKuhO4CW8EeGI+vRHkep3dqb6r97PTUmgajiV5o03NfqJzM25Yu9mvs3h0jvBxfeUJdzt3uabHUHaVc5fTIlQcCM4rR1gsFh3D2gUjQhx2CPK/QT3kZVxOjYiIXGFwrpPLnnOJDdS2bZUawe60y4X7KvW4fpx1RPyAxba/85BRp6DH4SyLyyrx1rqDWLTxCE4XlDitV+7IjPaueOSB+QGs1mMUllbgnfUHkXOuCJsPn8fKXadU71tRWXOs2978H15x0Ztn5unbztv1qBK5nmZ9lauqsmLKt7tdHNM9jq+pmiBP800anZX0VIzocpi43Osq2K/7S2sMrZPTtBrh1B3HOedO+7q+4MKbE46nL5VwkUhJYiyXUyMiImVcSs2D1CaBUZpzblRwpRRAPv/Nnyr2l66P4ykWllXYfw/yga4mT/Qtaz3Gj7ty8eOuXLyxZj9KysV3TVyVJZxz/ufJAvx5sgDP3doegOeCNgAoLqvAgJnr8fc2jTD2hlaK24rfM+6/IvnF5S63cWudc6tUbgWr6HlXxzRyNIXZ95eExcvlu9Bbnqrt3TqOYHSQRDla33qinnOH5/wwHQZ5GXvOiYjIFfac6+QyW7tEy091k9O0Ye01pBqurnYUzeeUXWvYuefcJshLrVlPj/a26lwazTEwV0Pr8mNmLaW2P+8yDp8txEdZRzXNORc9bmavvtHlCXvO1cw5N/HcjP5YCetqEQ3rNvY4RlCaOlBlBSZ+vdP+t+N1UnM6SvcTvfV9Rv6LwTkREbnC4FwnPcPaq6xAWUUV/sq75FZGYldeW7lXZl9Br5LbS6ldKRPODWKh4vKa4FzNOZvd3vVEgOGJtcRt3Ens58l6ig8s3etsZm3cfd11Je1zY4SANwNhufdUldWqOPpH7VxwG7nPupZTV8p5UVVlxSe/5QiPqHnOua/fnCD/wuCciIhc0RWcz5s3D0lJSYiIiEDv3r2xefNmxe2XL1+Odu3aISIiAp06dcIPP/wgev7y5ctIT09H8+bNERkZiQ4dOmD+/PmibUpKSvDYY48hNjYWdevWxeDBg5GXl6en+sbQ0VCzWq148KOt+Mcbv+CHnbkoq5DuKVUc0qriOG+vO+hyX00NTVv7VCLYcC5Hvudc3SHNnXUubMybtUyb1LU166bDp5uPyT8pcVBfCDCsMr+be0z3juQUBGrcR811V1tH57LMu6PlmBDuI8d8FALysbnGa6/zpXKcfiB1A9Iq810gR6l3nB3npJVtzvnZy2UoLK1wsTUREdVGmoPzZcuWISMjA5MnT8a2bduQnJyM1NRUnD59WnL7jRs3YtiwYRg9ejS2b9+OQYMGYdCgQdi1a5d9m4yMDKxcuRKffPIJ9uzZg3HjxiE9PR0rVqywb/PUU0/h22+/xfLly7F+/XqcPHkSd911l45TNoaetZytVuCX/WcAAO/9eghzMvc7bwTnHmZxA7n6uZLyShw+q385Fn3Z2mv2qek5F3MstkgYnPtAYOgJUqfZs0VDj9fDW/Rn2/bNce2Sn3WZ3n+ZTTw279pojnPOv9Sxtre5S6nJ/+04AsBpWLuannNRvcQ7cFg7aRUdEYr6UaEAgGMKS4oSEVHtpTk4nzVrFsaMGYNRo0bZe7ijoqKwYMECye3nzJmDtLQ0jB8/Hu3bt8fUqVPRrVs3zJ07177Nxo0bMXLkSPTv3x9JSUkYO3YskpOT7T3y+fn5+OCDDzBr1iwMGDAA3bt3x8KFC7Fx40b89ttvOk/dPbqWUhM07gpKyvH19pMy27k+7oMfbtV+fEHBmuacA/j92EXMW1vTIy+XEM7x7+Lymt4BpRsaX28/AavV6rzOuQHtX6OW61JLaliwu+vKG8UTtXB540qmR9nUYe3u7Gt1zgcg7v2XmXOu8X33yg8101GUR88oB53ukr3Z4CIlgvCGwubD52uy92sNzg1KPOcUnEP7+00xWztjc9LBPrT9HINzIiJypik4LysrQ3Z2NlJSUmoKCApCSkoKsrKyJPfJysoSbQ8Aqampou379u2LFStW4MSJ6gBt7dq12L9/P26++WYAQHZ2NsrLy0XltGvXDomJibLHLS0tRUFBgejHSK6TXkkFaDW/XyqRH9KmWPaV5/534KxyBZR2hvrM8TZ3zNuA7KMXava3V1JcjmODuLC0pudcqTU8btkO/Lgr1+lxf2wAu7OMnnNZ+sNKb1063T3nOo+h5j3izjH/PKn83SG/lJq2IdSA2szz4r+Nfp2rZC6uluHpd7+ThTV7pEdT2Ys2uObVw9pr6ui4XKRzz7nr81HaxA+/msgHJHDeORERKdAUnJ89exaVlZWIi4sTPR4XF4fcXOfACgByc3Ndbv/mm2+iQ4cOaN68OcLCwpCWloZ58+bhhhtusJcRFhaG+vXrqz7utGnTEBMTY/9JSEjQcqqmsIqC83Jdgddb6w7g9KUSt+vy58kCvPLDHuQXuQ4GpNhDc4dTcAzOtcw5/+N4vq66uOLpPmvJTP1Wq8cb81Ln7ZF13jU8b4XVPsXCeRSGVfJ3fXXSPmdcsTw1c8j1jNiQGZHiSXLH1joT5ue91cG51jnnum9kwao4rF3PcawyvwMc1k76MCkcEREp8Yls7W+++SZ+++03rFixAtnZ2Zg5cyYee+wxrFmzRneZEyZMQH5+vv3n2DGFxFk66JlzLmwslpRXyTZ2HR8W9jC988shjPkoW201ZeuUW1CCd385hBe+c72muRS5nvdXf9yLEkGGdnG2duUygyzm90Z5JOgxsOfcH7lcZlDw9KINR9Bpyipsz7ngtN93f5yS3Edfndzb36k8Ua+43DbulSu/jbnk6qA12LUtQ2ZqKgGFGyDOw9otovfYyYvFmPbDHpy4WCxZdkFJObYJRguZPmSBaoUWDM6JiEhBiJaNGzVqhODgYKcs6Xl5eYiPj5fcJz4+XnH74uJiPPfcc/jqq68wcOBAAEDnzp2xY8cOzJgxAykpKYiPj0dZWRkuXrwo6j1XOm54eDjCw8O1nJ4mhgzNlZ2rqlz478cu6jyesz+O52PXCe091rYA3LHMX/86i3fWH8KTKW0AiBPPuQo8giwWUzKoq1mTWs6yLTn45a+zeOPuLggLkb+XVVVVXXJwkEXypove94s7bzOpK+kLNwmE7++lW6pvmv378z8wvHeiaLvHP92O25ObVu/j7jHd3N+pPFFQaMycc9G+Xnyl5G4aVlmtiuchNydb65m4890q3NUx6aXjV8t/v6pOSrpmTx4yn+7vVNbA//sVx87XBO7ON02JtGPPORERKdHUcx4WFobu3bsjMzPT/lhVVRUyMzPRp08fyX369Okj2h4AVq9ebd++vLwc5eXlCAoSVyU4OBhVVdWTBrt3747Q0FBROfv27UNOTo7scc2mp/3o2NssP1fV8W/zGuoHTl/GbW/+T3EbqUaobc68VGBy8Mxl+++iYaEqes59zX++2Inv/ziFz7OPy25jtVpx51sbkDJrPSoqq6SHtZtZSYn6yD/ngePreL6yypx3+cINh00oVXm4s9QzRp6d0moORhNPLdB3HnLvOWG9P9t6DN/sqM4Er+UYjtsKl6eUCs6l6nLwjPSqF8LAHHDel8PaSQ/bnPPj54t1rZpCRESBTVPPOVC97NnIkSPRo0cP9OrVC7Nnz0ZhYSFGjRoFABgxYgSaNWuGadOmAQCefPJJ9OvXDzNnzsTAgQOxdOlSbN26Fe+++y4AIDo6Gv369cP48eMRGRmJFi1aYP369fjoo48wa9YsAEBMTAxGjx6NjIwMNGzYENHR0Xj88cfRp08fXHfddUZdC00ce84ce3zVJAVT+++yUQGVkb23BSXlss/lFpTgi+zjuD25qbhx7+I47vaa5+aXID4mwulxxwBDD6VEXZVVVvx+Zb780fNFiAwNdt5I54GLSitwTGMPy4HTl/G/A2dRUeUivbZJ5E71wOlLOHimEO/+csjpOde9svpuOLzw7W6Mur6l0/5Gzr1XtZSa5u5j9ZsanVgNMvXWuuKA2nqdu1yKf3/+BwDg1k5NNF0rx/o9s/x3yefMwNic9GgSE4GQIAvKKquQV1CCpvUjvV0lIiLyIZqD86FDh+LMmTOYNGkScnNz0aVLF6xcudKe9C0nJ0fUC963b18sWbIEEydOxHPPPYc2bdrg66+/RseOHe3bLF26FBMmTMDw4cNx/vx5tGjRAi+//DIefvhh+zZvvPEGgoKCMHjwYJSWliI1NRVvvfWWO+duGKtVXUPNuXGrruvcqDamkQFJTc+583ObD5/H5sPnseXIeazdV5Ox2dXxgywW515BDYHHddMyseuFVNXba6H0+gprbIH066X3yk/5djemfLtb0z7/eOMXAECI1FAET/Scy7zOKbN+kd1H69J+ouOp2cboOeei8mSGtbtTvs7njCBe6q7md6WbiVuPnHd6rObtp1xj4YoO7vQkCpNPAs7vKQssbl07qTnsRFqFBAeheYNIHDlXhJzzRQzOiYhIRHNwDgDp6elIT0+XfG7dunVOjw0ZMgRDhgyRLS8+Ph4LFy5UPGZERATmzZuHefPmaaqreZSbedIZu5X/lttXT1B9+GwhWjaq41CucQqK5XvObWzzie3Hd1GB4CD365ib75zcSd0QZP3EK09ZJJPlVQ8J9qwKLw2Z1HPcqiptAamaOd9mklurXbSN1Yovso9j54l83NWtmXHHlpnbbRThyyf6XeF1/WX/GafHbCNhXL08Tkucuayh9LaO+zkF+jLD2vVizznpldAwyh6cX9cq1tvVISIiH6IrOCfHJGPKz8ttJ9dONKIBeeOMdTjy6kD3C4L0nPMChTnnuo9jsbh97sFBymkUzAjkhD1qcu11byb4EvJEPfT0flZWWTW9Nlp62q1WKy7qXDJQvlDJX502efrKMOvoCG1ftd5dSk16KopSncoVXnO5Z6Q+K2qHzpdXViE0WPxZV1qKzwiOpZmRvJJqB1tSOK1TloiIKPD5xFJq/kjcaNU3eVxNlmepv/Uysq1qm3NuJMlh7Rrbv1JDuY04b6VqiHvOZW7MWL3Tw6vErOroCs41LL8GAKt35+GHndVLrbk62sOfZOP2ucpJD80grPO5wjLN+yhsJfrLzBBRPKxdvnIVlfL5DVy974Wf8QEz1ouSuslp898fsXp3nsONBPFxHKtkkdhGC66kRkaxBedHzzE4JyIiMQbnOrlcy1nFY2qbiUb1duotR2ovPQGYnmHtu08V4O+v/6z6GMEuUr6bEY+Ke84tqqY0eIsn6qFvWLv2fR5dvA2A63Na9Wee02PuXgY1Pcp6jmG1/1/93kb34Mqdm1KNyiudn1WbzVxY/9yCElX7AMCYj7aKH3CogtOcczdH5ji+Ji4G6RDJahHL5dSIiEgah7XrZMQ8ZvVzznUewES2gFRTZmUV65w7lvfOeufM3kqkgnO5+cFGhTSi4Nzi3GNXXQfPzzkXHV9iRQGz6LlxU1HlIlu74oJlXphzLloBQG4EjPTwcLXlym+jsjCdqkQBubjnXO7YUisDqF3nXO+70mIRl+3Ys++cXNJYTAhHeiVwWDsREcngvX+dXC2TJNXIdjUnss+0TGw8eNa0Ye16YxjpuaG2IrXM/XVxHIlh7VqZ1VxWm60dkHvtvXuHxWp/vcynZwk3PT3ndl64tGp7lGu2V1dJe8+54o0Kz1GbeE/qhoztIyO3m+1mkat7RiXllcob2I6jok5GXjtOOSe9bMH5ucIyXC6t8HJtiIjIlzA4N4DaANWpR9zh+VP5Jbj3vU26h787Hc+xJ0lnOXJlXygsw4YD59Tv4+L5IIv7dZTc34hhDkrHdIhF5Q7h1SRfHjyWnuXVK61W5d5xHxo98v0fp/Bh1hH732rWOVd7TXziPGWWT5O7f7Lqz1x8uvmY0+Pqe86Vo9y31h6Q2c/hGrsc1u6iIi44Z8lndE76REeEokFUKAAgh/POiYhIgMG5Tq4anJJzznVG3Xp7Xc1cSavKasWzX/6haR9165y7UyvXwc2FInWJuRwpBRCOw9rlEsJ5k+3ae6IHX8+a5ZUuhrUr8fSlfWzJNtEca7mbCo5DwtWw7aO0tTeHtUt56ONsycdrllJz9blXrs/uU5fknxQF5+LjZB+5IK5PdWWUD6ZBbQjN582bh6SkJERERKB3797YvHmz7LZ//vknBg8ejKSkJFgsFsyePVtXmSUlJXjssccQGxuLunXrYvDgwcjLc84b4e9sSeE475yIiIQYnOsknnMq9bzEYxD33qjtYTWs59zARn1VFZB99ILrDYXHd/F8dc+58ZGHrcT56w+i/4x1hpcvDs6lh+Z7eyk1q8P/zVSpo+vcrURdevYV7HPwzGUUujO0VEXPueoq2qYfaDgpoztw5XI0aH1ZzQ5eHXuuHa/ZVofvJ4vF4tb7392VJPzNsmXLkJGRgcmTJ2Pbtm1ITk5GamoqTp8+Lbl9UVERWrVqhVdffRXx8fG6y3zqqafw7bffYvny5Vi/fj1OnjyJu+66y5Rz9KbE2DoAOO+ciIjEGJzrpGdIo9UqzmAs3wA3Jjp37Dk3MkBUSg4lR92cc/11ApTP8dUf97pXuAxRT6NVugbV5+W9AN2TvfkVEpm7XamUuW5quPO+/v3YRdw0cz1u/b9fdZdhO/r3f5xCxrIdNY8r9Oq6Kkt5G3PfR3LzzNWeg51tWLvcnHPbMVwVI/NV67g0mp7pFFo4fp+qzUbvr2bNmoUxY8Zg1KhR6NChA+bPn4+oqCgsWLBAcvuePXti+vTpuOeeexAeHq6rzPz8fHzwwQeYNWsWBgwYgO7du2PhwoXYuHEjfvvtN9PO1RsSG0YCYM85ERGJMTg3gHTjU7r3VNickxt2blRQbVTWd6llkqxW7aHmd3+cVHzeiGHtUgxZ51wpIZyKEQrenkpsHy6tpzdXI13rnLvK1q7zOVlXXs8fd+UCcG+9YdvxH1uyDV9uP2F/POuQIB+D6iksmjYHYELPudX172qozWZu1Gfe1c0DxznqWjm+rwM5NC8rK0N2djZSUlLsjwUFBSElJQVZWVmmlZmdnY3y8nLRNu3atUNiYqLicUtLS1FQUCD68XUc1k5ERFIYnOukZ+7uhcIy0RrQsnNVDRqOblSjV6rxUN1zru0As9f8pfi8EcPavTG3u8ohgJE6Bz0jDYzkyWPrWefcW8KCPRNiqb0im4+cd12WyZfXKvO71p7zmoRw5lVYKSGcc4XcO5bj+Qdyx/nZs2dRWVmJuLg40eNxcXHIzc01rczc3FyEhYWhfv36mo47bdo0xMTE2H8SEhJ01dGTEhicExGRBAbnBpBqfEq1Yz/betzlNtLl62PU3HUpVVar4QnnDEkIJ/mYycOA1YxQ8JF4VTyfWPp3d+npOQeUXyfl53QdDAAQElzzFaj3GlhhRV5BifI2Kst+4tPtovpJlyX+2+j1tuXyaWgNzq3W6qH+Jy4UK2+n88PhGByrWiNe5li/H7vocl+nnvNAjs79zIQJE5Cfn2//OXbMefUAX9Piypzz4xeKdH9nEhFR4GFwbgCjs0w7Pq63fMfGtJEBmNVqbHkAEBTkXsImwM31sjUqq6jCz3vzcKmkJpmY1SodxFjh3fjc1Uul5qVUG4t4uqHpzvtQWNeScn2Tlj/PPo7er2QqbmPmJTEzRhS+l63Q9l305bbjeGzJNhxxMWXAZS4K2cfF3xeuh7XL3/y7Y94GAMprqjv1nCsezb81atQIwcHBTlnS8/LyZJO9GVFmfHw8ysrKcPHiRU3HDQ8PR3R0tOjH18VHRyA02ILySityXdzcIyKi2oPBuQH0dpTKBRXOPd56e/RqfPC/w3hg4RZd5UgxY5h2kMX9gF8yMJYp0t3qz/xpH/61aCse/HCroEzp6+KJJcyU2N9Dgmqs+jMPJy8WOz4sS20worvn3JNzzlGdA2FOZs1Ui0sl5brK+WaHci4FQEevs85RBEZwDMjtv2tM2nf6UqnyBirXQVciTljn4nAu3sC//nUG7Z5fiXky66o795yrqqJfCgsLQ/fu3ZGZWXPTqaqqCpmZmejTp49pZXbv3h2hoaGibfbt24ecnBzdx/VVwUEWNG9wZWg71zonIqIrGJwb4L1fDuHXv86IHlPTFlcTNB44fdmQnvOp3+3WV4hs2cb3BB84fdntMs2a7yw1hHXJphwA4jmD89YekKyD1l5Ho0kd+4ttx9H31Z8B6MjErcBf5pynL9ku+rtAZ3CuhtErG5jJapX+w+deVsdh7So2V9rm2S92AgCmr9on+Xylw8CKQM/WnpGRgffeew8ffvgh9uzZg0ceeQSFhYUYNWoUAGDEiBGYMGGCffuysjLs2LEDO3bsQFlZGU6cOIEdO3bgwIEDqsuMiYnB6NGjkZGRgbVr1yI7OxujRo1Cnz59cN1113n2AnhAzbzzQi/XhIiIfEWItysQCGy9b0deHahpPzVt3ZRZ6zH59g46amVuA19PQjhX3lp3ELPj6rlVhvQa4+q31UIqoP1s63HJpcS83HHucp1zI+tXacLJeuLy5Re7sda5C0b2dnvyvSQMyM2aMuLqc6i8lJr6ctxVmxLCAcDQoUNx5swZTJo0Cbm5uejSpQtWrlxpT+iWk5ODoKCa+/snT55E165d7X/PmDEDM2bMQL9+/bBu3TpVZQLAG2+8gaCgIAwePBilpaVITU3FW2+95ZmT9jAup0ZERI4YnJtEVXIi2WHt4seLFeZBKnn/10N4+ua2uvZ1Rc9SamqcuKicPMoVx94tNaxWq67kTnKxyu5Tzsv4WK/85y2u3o9G1q1Sz4sANxKy6dhN6nzPXDJv3qfWNbi1nJPRMaIo4BWuI27S21dvPgTHj6yr6RQWi6vpEcr7Oy+lFuDROYD09HSkp6dLPmcLuG2SkpJUfYaVygSAiIgIzJs3D/PmzdNUV3/UomF1Uric8+79u0dERIGDw9q9SG1bV2+H0Js/S8+dNEJ1tnbjW+vu9s5JNdBlb4IA+GzLMXSduhrbcy7YH88vKndKDCXVDNcS0PpMz7ncVApVCeHUBSMSAwdU0Rs4GZXtOzffvODcyJsfn2cfx/z1B+1/H3ORDV0ruWztRvdMGxHaCqvkMjiHxa2s/7Vpzjl5BpdTIyIiRwzOTaIuIZy2x32JWet2uzskWssNA6sV+PcXf+BiUbl9/nFBSTmSX/wJ103LdBmMaLmPUJ3dXv32RrMdWy44MXRYu9ZuYjfprbtjbJVb4CKBmRs0zzlXeG7RxiN49ce9OHD6MrKPXjA8O77c2uFSh5n1k/T8bG9wmfXdRTDtan/nYe2Mzsk9iVeC82MMzomI6AoG5yZxJ9jx5vBntapMCjbdjTMke8417P/nieoh6ReLyl3WRW22fZ/g6lwMfM/pTQintJcZl9QxuDrjKru4G8yof35xGb793XWmeK3kh7U7n8X/GTA6R29Q7dgTrurGnNLoDBevkvOwdiL3JMZWB+fnC8t0rxZBRESBhcG5H/D2MlxSquecm5D4y81z1dbzXrOtLa9RaHBNk7vCRQ+wXAwqdV20LkNlNNvR3RmtobaHtlLnuHa9L72e3axW5+DK1evtDu3Z2tXkrNBZGS3HFvWcG58EsvoQymWu+jMP+UWuAxdXn32LxcUNII0950GMzslNdcNDEFsnDACHthMRUTUG5yZxJxTzwVjcidWkYe3uzmOXnLOuZj71lVAtJLjmI1FcVjPvXKr3Ti5YlVzn3HUVvMrXl1JzJ5GXHMfX1Mwl4MwIak1L0KbidyNYLBacuFiML7KPu9x27MdbJfYXV8p1vgrlaFr7nHNG5+S+BA5tJyIiAWZr90HbBMnJAN8M1qtM6gnWmehbsL++JG22dnaIoDusSBicu1etK3POvfdC1sw5l3newGPpDfT35TlnuVfDqLrr7fFXQ+s1mfr9bsPLVEsuCZwZ798bZ6xDWYXrD/2mw+edHnNcSk3NR18xsaCL/R1v3jA0JyMkNozCjmMX2XNOREQA2HNuKLnhoFqVlIsbqyZ26OlWZTUnOBBmodZDamirmtsItoa2MLgXBudaSB3N23kEXB3dyJdSbw/0Dztz5Z9U7DnXfiyr1bnn08yec61FH1OxtJInhpmL1zk39jhVVVZVgblaapZSU1az/8pdp1wejz3nZARbUrij5xicExERg3NDmdW2f2PNfrf2P3jmskE1qWFWtnZ3aQkghNW3NbSFAZpwOTV3G+Levla2IE4+iZ1xFTSrR9dIVlidej7NzDKvKROCyutXnffBeMLLIHwtjX5dL5VWuLW/xWJxyCzvIjiHq+kRNb8//Mk2p+e5lBqZIZHLqRERkQCDcwMJG2++FJ4MmrvB8DIdG7m+khxJqoGuJgmaoT3nkr333uXJnnN316qXojTyoKhMe5B3USLBmK/MOS9V2ZvsiZsgwkMcPFOIvbmXTD+mWo5fOWqyvitt4up6Oi2lpnw4IlVsGds555yIiADOOTeUKDj3djQm4G4PlRTnzMUWn+gx1VsHWy+YMGO3nqBPjs+scy53o8LAY3lyGsbRc4X4p46bT1JzmI1eL1xIy2tfrPKmkFnVFV6HtftO239/beVecw7oBuFNG5fZ2t1MCOd4vYPYdU4GsPWcH79QjMoqK4J95U43ERF5BXvOdZJqB5q5FJOvcQrOfaRBIZkpXTYgrXnCNmxdGJhIZWtfvOkobp3zK/IKSuTroOFRT3E1593Xh7XLFbl4U45hx9h48JzLALRxvXBdZWvJOVBSoTY4N3/FBH+aB+tqxIbFon5Yu/TzHNZOxouLjkBYcBAqqqw4le861wQREQU2Buc6STW2hbG5txOAmc25F8k79XCku+f8yv+FQ5uLy52DpP9+tQu7TxVg+qp98oVJVOHs5TLMWu1e7gC3uLgsRvbCenKEQIXBGdbfXqeckFDv21zLNXFMCClfqL66uOILI2BUcQi23a23qxtUjp8RBudkhOAgC5o3iAQA5PjRzTAiIjIHg3OdanvPuVMvko/MwNSyzLnUUmrC5bSU5pxLBe6ujufNhD+uwpaVfypkStfIjOHhciV6OpDUezQt9SxReG8JmTUM38zh/UbSupRa9fbyG7ke1u7Yc+4b33nk/2zzzpkUjoiIGJwbSDjn0V86n/Ty1fa7dEI415UNksjWrjT3N9jPGuau5pw///Uuw45ldMC849hFPP3ZDsnnPH1DTO/wfy2fF6UbP+IyraaM0PGX4NyRq3r/euAsCt3Iv+E4bN6/vgHIlzFjOxER2TAhnE5SbXR/bdTq4atDX6WqNfbjbLw+uLPzthL7C1/DckHg59gwVxrGb8ba0+46fLYQocEWLN501PRjGf3eGDRPPuGbpz9zeg+n5T2htufcrFP3l6+x6qXUairr6n136EwhDp0plN9A49QP9pyTURicExGRDYNznaR6rITzX/2kfaubYzvYV9qpcg30f3/xh9NjwoZ9zTrnNQF5pcLrqZSp2VXWaG8Y9t5v6Nw8Bn8czzf9WJ7szPZ0cK73xouW3UrVzjk36VvGX28yuntTyNXn1nmFCrcOR2SXwOCciIiuYHCuk1Q7rko0rN0/G7j+zt2EcMLARDjEXUuv2bHzvplx1xOBOeDZURWVHk7zoPfMth69oHrbl77frWq7qd/twYmLxr/XfPHmkhTH7Ovu3lNwdVPC6TvAvcMR2bXgnHMiIrqCc851kmrGlVbUnoRwjnyloao3rqhZ51ywbnKV/M2WL7Yd13egWsCTHa+VHp5z7mq5LiMcVBp6LWBGYA74z41Fx+8cd18bV9/fzkup+cq3Hvm7hAbVwfnFonLkF5d7uTZERORNDM4NdPMbv6D0yhrF/tG8DTy6e85t2dpl5pyTeh7tOffwB602fK5r67B2VxyvC2NzMkqd8BA0qhsGADjG3nMiolqNwbleMu3AP08WeLYePsJXepG0tM9FS6nBOVu7MIeArybA80WeHdbuJ+Pa/Yi/xOaO3zlm31RwWkrNZ8YLUSCwzTtncE5EVLsxONdJbgmjkCALvtx2HKMWbvFwjaR5qhfMV5qpegPDIPs654KEcKJh7W5Vq1bx7LB2T2dr5xvBlwhfDrNfGl9NgkmBwZax/SiDcyKiWo3BuU5yDcHgIAsyPvvds5VRcP8Hm7xdBY/SEquJbrBIrHMuzNzuL72Jeqz6M9fQ8jzbc+4fS6mR8SwQf4bNTmTHbO1kphbM2E5ERGBwrptcMzAkyLcu6caD5zxzIB9pqGpJZrVu3xn777bqyw1rt8LqN4mytHro42xDy/NE0jSbCk8vpVYbxrX7Cceea7NvCjlna/eRLz0KCBzWTkREgM7gfN68eUhKSkJERAR69+6NzZs3K26/fPlytGvXDhEREejUqRN++OEH0fMWi0XyZ/r06fZt9u/fjzvuuAONGjVCdHQ0/va3v2Ht2rV6qm8IuUAtJJgNNm/S0j7/ZsdJ++9SCeEqHIa1ezoQ9FeB3HMeoPdn/JaRS6m5woRwZKZE9pwTERF0BOfLli1DRkYGJk+ejG3btiE5ORmpqak4ffq05PYbN27EsGHDMHr0aGzfvh2DBg3CoEGDsGvXLvs2p06dEv0sWLAAFosFgwcPtm9z2223oaKiAj///DOys7ORnJyM2267Dbm5xg7JdVdQLW2x+cpZ659zfmVYu6C33HEptXJPL6rtpzx5mX7966znDobACc4DcUi22SM2uJQamSnxylrnJy4Uo4L/1hAR1Vqag/NZs2ZhzJgxGDVqFDp06ID58+cjKioKCxYskNx+zpw5SEtLw/jx49G+fXtMnToV3bp1w9y5c+3bxMfHi36++eYb3HjjjWjVqhUA4OzZs/jrr7/w7LPPonPnzmjTpg1effVVFBUViYJ8T5JrBgbq0Gd/obd9bmtmC7N/C4NxqxUo9/S6XX4qED4DtiURHQXKsPaQYN+afqOPRfRqmD/n3OHojM3JQHH1IhAWEoSKKitO5Zd4uzpEROQlmlpoZWVlyM7ORkpKSk0BQUFISUlBVlaW5D5ZWVmi7QEgNTVVdvu8vDx8//33GD16tP2x2NhYtG3bFh999BEKCwtRUVGBd955B1dddRW6d+8uWU5paSkKCgpEP0aSawfW1pHPvtKL5O4658Kh66Kec4A95yoZOazdG4G+1WrF5G/+lHwuUG7QBPvI59Udjsvomf1WcQz+/f8Kki8JCrIgoUEkAA5tJyKqzTQF52fPnkVlZSXi4uJEj8fFxckOL8/NzdW0/Ycffoh69erhrrvusj9msViwZs0abN++HfXq1UNERARmzZqFlStXokGDBpLlTJs2DTExMfafhIQELafqknw7MDAa71r5SltfbzBnS+4kDMjLHdY5Z3CujpE3qApKKowrTCWrFVi65ZjHj+tJgTCsvaLSs0kaHY9VW6cwkXk475yIiHxubOOCBQswfPhwRERE2B+zWq147LHHcNVVV+HXX3/F5s2bMWjQINx+++04deqUZDkTJkxAfn6+/efYMYMb2zKNwgAY0evXdAeGV9rZ5aI55+Jh7RUB0mtqNiN7zpNf+MmwstSqDWuZBwVAdF5e5dmbZRzWTmZjcE5ERCFaNm7UqBGCg4ORl5cnejwvLw/x8fGS+8THx6ve/tdff8W+ffuwbNky0eM///wzvvvuO1y4cAHR0dEAgLfeegurV6/Ghx9+iGeffdaprPDwcISHh2s5PU3kmu9ltbR3NSIkGEC5t6uhf1j7lf8Le8crHBLC1dbXVit/D25rw9SU4AAIzuuEhXh0nJLj+9r/ryD5GttyajnnGJwTEdVWmnrOw8LC0L17d2RmZtofq6qqQmZmJvr06SO5T58+fUTbA8Dq1aslt//ggw/QvXt3JCcnix4vKqr+hyrIYQ3xoKAgVHm498SV4jLpRFKBrn5UqLerAED/yIWaOeeC4Fy0zrnnl+3yV/54nRY/2Nv+u7/fXFAjEIZkXxUd4dGRSo7Z4H0lzwYFjhaxdQCw55yIqDbTPKw9IyMD7733Hj788EPs2bMHjzzyCAoLCzFq1CgAwIgRIzBhwgT79k8++SRWrlyJmTNnYu/evZgyZQq2bt2K9PR0UbkFBQVYvnw5HnzwQadj9unTBw0aNMDIkSPx+++/Y//+/Rg/fjwOHz6MgQMHaj0FQ8g1Cos8HJy3alzHo8eT4yvBubtLqZVVCNc5Fw9r98eg0xv88TKFCHqSGZz7B08nC3Q8XABcQvIxHNZORESahrUDwNChQ3HmzBlMmjQJubm56NKlC1auXGlP+paTkyPq4e7bty+WLFmCiRMn4rnnnkObNm3w9ddfo2PHjqJyly5dCqvVimHDhjkds1GjRli5ciX++9//YsCAASgvL8e1116Lb775xqmX3VPkllQqq/BsT76vtA/rR4Z5uwoADO45F0SZVVZrrQjajOCPS6kFi4JzL1bEQwJhJbXqz6PnXiznYe2+8u1LgSKhYXW29vzicuQXlSPGR256ExGR52gOzgEgPT3dqefbZt26dU6PDRkyBEOGDFEsc+zYsRg7dqzs8z169MCqVas01dNMcvFHhY8Ns/cUf+85tzW0K0QJ4cTD2mvpS6uZPwa3wbWs5zwQllLz9PvMcSm1AJi2Tz4mKiwEjeqG4+zlUuScL0KnqBhvV4mIiDwsAPpPvEOu/e7pdZB9Zd5j18T63q4CAP0NdttlFCZ9c1xKzbFxTtL8cfh/iGC0j+Pc4kDkK98b7rBarZ6dc85h7eQBLWI5tJ2IqDZjcK7DF9nHsftUgeRznl4L21fah9c2jUF0hK6BGIaSm27gii1YqRC8fsKl1MA556pxWLvvC4Rs7Z5+mzm+rwPhBgf5Hs47JyKq3Ric63Aqv1j2OU+vhe1L7cOUDnHeroL+OedX/i/sLXfM1l4bhjsbwR+D21o3rD0AgvMqq95bcXqPJ/7bl757KXAkMDgnIqrVGJzroNRjsmRzjgdr4jtJiSwW36iL3iHJtpdUbp3zqiore85VKq3wv+UEgyw1c4j9PTgPC3H9tR4AsTmqrJ7tPWdCOPKEmp7zQi/XhIiIvIHBucF2HLvo0eP5Su+NrzRUdc85v/L/ctGwdvac61FY6n/BucVSs7yYvyf+szXulQTCUmqe/jxyKTXyBM45JyKq3Ric6xAIDVujWSy+0VhVarBHhMq/3e1zzgUBuTBQr7Ja/T5o85RLJeXeroJmFosFQVe6ky8Wl3m5Nu5Rk4k9EIa1W636c0wYIQAuIfkg2821kxdLPJ7DhoiIvI/BuQ6+EITa+EpSouph7d6nlIysQZT8WuwWAO+sP4g/jufbHxMG6lar81JKJK2wzP96zoMsFnuwNWPVPu9Wxk1qvhIC4QZjZZUVT3y63WvH95XRQhRYGtcNR3hIECqrrDh1scTb1SEiIg9jcK6DLzXJfKUuvtJQVRrWrtSrXlZZhWk/7hU9VuHQa1Ebltgygj/OzQ8SDGs/4ecNYjU37IIC4Js/t6AE+/Mue+34AXB/g3xQUJCFSeGIiGqxAGiieZ4v9Tr5SlX8YVi7Uswo7DG3EQaZVVYmhAtkFljsn2sfeBu7Rc1wazVD30mZr4xaosBjG9p+lEnhiIhqHQbnOrBN5ruUwmelUen5xc7zpMs5rL3WsAiytfv751vNzcMgTph2G68gmYVrnRMR1V4Mzv2crwQSFvjG0HblnnNtwbU4W7uVw9qviAwN9nYVDBcUVJMQzpdGxujBnnPPqA2XcN68eUhKSkJERAR69+6NzZs3K26/fPlytGvXDhEREejUqRN++OEH0fN5eXl44IEH0LRpU0RFRSEtLQ1//fWXaJv+/fvDYrGIfh5++GHDz82X2YLzYwzOiYhqHQbnOnhjOOPiB3tLPu4LATHgOw1VpfjbcQ65K+Jh7cDrfp4oTKtm9SO9XQWPsaAmKPeV97JeanrF/f0GhC8I9Gu4bNkyZGRkYPLkydi2bRuSk5ORmpqK06dPS26/ceNGDBs2DKNHj8b27dsxaNAgDBo0CLt27QJQnaxz0KBBOHToEL755hts374dLVq0QEpKCgoLxcO3x4wZg1OnTtl/Xn/9ddPP15ew55yIqPZicK6DN0aEyrUDfad9aPGJuij1ble40fNttQKHz9au+X9yy215c/kqswiztfvA29gtaoLGQFhKzdsC/RrOmjULY8aMwahRo9ChQwfMnz8fUVFRWLBggeT2c+bMQVpaGsaPH4/27dtj6tSp6NatG+bOnQsA+Ouvv/Dbb7/h7bffRs+ePdG2bVu8/fbbKC4uxqeffioqKyoqCvHx8faf6Oho08/XlyReWev86LkixRVIiIgo8DA418GMJpmrhp5cg9vM5uG4lDaqt/WdhHDyz1VUuhOc174GUoDHHiLCbO3HLhR7uTbuUTWsPcBf3KvqhZt+DF/4vjNLWVkZsrOzkZKSYn8sKCgIKSkpyMrKktwnKytLtD0ApKam2rcvLS0FAERERIjKDA8Px//+9z/RfosXL0ajRo3QsWNHTJgwAUVFyj3IpaWlKCgoEP34s4QG1cH5pZIKyXwoREQUuBic62DGsPZV4/6Ou7o1kz+mfGUMr4tNr6SGqrf1lXaq0rzyiiptw9qFamFsHvDDdoUslpps7ecLy7xcG/eoW0qt9ry2Zgnkeftnz55FZWUl4uLiRI/HxcUhNzdXcp/c3FzF7du1a4fExERMmDABFy5cQFlZGV577TUcP34cp06dsu9z77334pNPPsHatWsxYcIEfPzxx7jvvvsU6ztt2jTExMTYfxISEvScts+IDAu232Di0HYiotolxNsV8EdmtWuVgiG5xrSpzUMNhVcHBL7dWHUnn1sgDuV2Re7tGIg3KoTZ2v2duoRw5tcj0AX66AOjhYaG4ssvv8To0aPRsGFDBAcHIyUlBbfccotoZNLYsWPtv3fq1AlNmjTBTTfdhIMHD6J169aSZU+YMAEZGRn2vwsKCvw+QE9sGIXTl0qRc74InZvX93Z1iIjIQ9hzrocpPSYWxUa13HNmdt74SrI5LbRmZFdfrinF+rTa1HMedCUrdCDgnHPlJRWNEijvFymNGjVCcHAw8vLyRI/n5eUhPj5ecp/4+HiX23fv3h07duzAxYsXcerUKaxcuRLnzp1Dq1atZOvSu3d1MtQDBw7IbhMeHo7o6GjRj79jUjgiotqJwbkOpoTmFuVGtVxD0MzmoZa2p0Xj9mYxKzgPxN5iV2R7zj1bDY8IsgAnLho319yby82pCc4DObD0lEAefRAWFobu3bsjMzPT/lhVVRUyMzPRp08fyX369Okj2h4AVq9eLbl9TEwMGjdujL/++gtbt27FHXfcIVuXHTt2AACaNGmi40z8V4ItOD/H4JyIqDbhsHYdzGrXKjWYZRPC+Ugj22LxjUHtn/yWY0q5vpYQLjoiBAUlFaYeQ+4952vXwghGjxLxZs+0mvnkgTxf2lMCfd5+RkYGRo4ciR49eqBXr16YPXs2CgsLMWrUKADAiBEj0KxZM0ybNg0A8OSTT6Jfv36YOXMmBg4ciKVLl2Lr1q1499137WUuX74cjRs3RmJiInbu3Iknn3wSgwYNws033wwAOHjwIJYsWYJbb70VsbGx+OOPP/DUU0/hhhtuQOfOnT1/EbyoRSx7zomIaiMG5zqYMdy3ep1l5ec9Tcsx/XEIvBZm9cjrlfl0f/R8eY2px6gTXnu+HiwGjyHyZuyrJmYMCvAxU574uAb6tI+hQ4fizJkzmDRpEnJzc9GlSxesXLnSnvQtJycHQYI3Ut++fbFkyRJMnDgRzz33HNq0aYOvv/4aHTt2tG9z6tQpZGRkIC8vD02aNMGIESPw/PPP258PCwvDmjVr7DcCEhISMHjwYEycONFzJ+4jOKydiKh2qj2tbwOZM6zdopwQzgvD2rX0DPnKUmpmcWMVNlM09sBSUXVlgnMfu09hCKMDLW8GbmqO7Y+BZULDSBw77zvL3PnjNdQqPT0d6enpks+tW7fO6bEhQ4ZgyJAhsuU98cQTeOKJJ2SfT0hIwPr16zXXMxDZgvOTF4tRXlmF0OAAv6NGREQAOOdcFzPaZC57zr2SEI5sKt1Yhs1f1YuoPffujB6h7M0Rz4G6znmYjwUnPlYdCjCN64UjIjQIVVbgxAXfuSlFRETmYvNCB7Pmeeuac25iCK3lPKvnnPtfg1+tsgrvdRe3i6+H25Obevy4csF5AHac63rvhoXIf316s1dVzefWH+eca7um5r9La0PPOXmPxWLh0HYiolqIwbkOZmVrV2rryc4RNbPnnG1Puwov9pz/s0tTNIwK9fhx5Ye1ux/4XH91rNtlGMno97o3k4WpObSvJJLUQkswzDnnFAgYnBMR1T4MznUwo2FrgQ/OOdfUc24J6GC+vNJ7wbm3goC64dI3BIyIe+7ukWBAKcYJsljwn7R22nZSuBDeHDWuZsi6H45q97nvF3+cGkD+xbac2jEG50REtQaDcx3MapPpydbuK3POLRq39zflXswIV72GvOevbmSY9NeDEb2SvhbYWCxAj6QGhpXnzWHjat4rvhbo+iNeQzIbe86JiGofBuc6mJIQzqLcQyrX4DZznre2nnPTquETKrzYc+6ta2tmj32IjwXnQRaLodmQg4NrZ7b2Ofd0Qf+2jU0pW9OwdlNqIOZrN5go8NiC86PnGJwTEdUWDM51MCsgVk4IJ7ePKVXRXLYFFqf6f/SvXgbXyHu82XPujWHtAzs1MbW3PtjHFtoOsgChGgNqq0IIGOLF81M359ycYzetH4nmDSJNKdvH3jJ+mVSP/EuL2Jph7Ubk+iAiIt/nY80d/2Bez7n887Jzzn0lOJfY9oZrzOlB8wZvzjn3htSO8aZOU/C1nnOLjp5zpbayN89Pzc0cM2+8mBVD+NpqEP6YVI/8S/MG1cH5pdIKXCwq93JtiIjIExic62BWo0xPQjgzaWkMB3oz1ZvBuTeS7VXPczevfF8cEmzksPYQLy6CreZ1M+vq+8qr6qqX8b+3tnf7GL74HqbAEhEajLjocACcd05EVFswONfBnKXUlAMwuedMnXOu5d3hYik4f1dR5c1h7Z5ZGspRbek5f/nOjgCMrZOv95ybdbPPYjFvvreRVTYisPahtzAFMPu8cwbnRES1AoNzHUwZ1q7zmOZma2fr06a8QrrnvGGdMNOP7Y1XwWIxd9iuL/Y6hoVoHNau8FyIivnrPVoYlx1eyJtzzgEzh7Ubx4i3nzfXsqfaI7FhHQBcTo2IqLZgcK6DWb1OSo1arwxr15oQzovBfOfmMaaWXy7oOQ8LCUKrxnXQp1UswjUGdHp4Y25rdYI/88pXE7x6iu196+me8+hI6XXk3eXNnvPqENr7iatc1cCIwJoJ4cgT7MupMWM7EVGtwOBcB3OGtQNVCtG5fEI4M5dSU79toLdThUupLR17HVY/1Q9LxvT2yO2I6mHtzu+NrAkD8NWjfdGsvjnZsc08N1/K1m5774YaeKNFTbZ2s4a+q/lOePTG1k6PDe7W3IBjmzgFw8AvGSO+N71xw5Rqn8TY6u93zjknIqodfKeF7EfMGdZugdK0Zu+MoNSWEE54XcaltFG9b7KOXu8nbxKXb/blES6l1qlZDIKDLFfyBHjghbFYJHsCm8REomuiOUOjzR7W7uk52U1jIlxuE6Y5W7vCUmoqRgaYNXrA1aW9tmk0rqrnfD1u7RRvSn2MouVqubpBYMSV96H7SxTA7D3nDM6JiGoFNi90Mb5RbZHpHa15Xqbn3PCa1NDWcy7euE+rWINrI/b4gKsdK2Dq8YTZ2j19n8QbCeECKVv7HV2a4vNH+so+b6uJp4e1m7UWut4eXSNebwu8k7zQkats7Ub0erPnnDzBNuf8VH4xymRynxARUeBgcK6DWXGF8rB26cfNXedcW+HCrW37DuzUxMAaOZfvKaLgXHBsT1QjIiTY/INIMDOHgCeD84duaI2mCkP/ba+hY53CQoIw5fYOaBtXD28O6+q0n3JCOO8Na9dbrBGfKYvFAqsPzDl3xYjPrS8mNaTA06huGCJDg1FlBU5cLPZ2dYiIyGQMznUwKzBUGtbu6z3nVqtV1OC1/T73XuegxmlfjfUCnM/b7Gay8LUR34Qw+cCoXuvW0wGPxeSl8TzZ6+iqg9p2E8LxM/aPDnF44PqWWPXUDRjQ7ipNx1QTeJuV7VttuWNvaCX626jamJat3cDLZUi2dsbm5AEWi4VD24mIahEG5zqY0SazWvX2nJvXQnSn59S2p1n18+aIUtFNCA8Mco8MC/LCUGFzz8yTgY3uYd7C3yWKUHpNHHvOHQNhAAg1ac652lfuuVvbo3/bxjX7GdFzDl/I1e4aE8KRP0lgcE5EVGswONfBrERASo19b/Sca2l7WuHZ4d6O18OT7WRvDGv3dMDjbs+5qyG/Hu05d3UoE6oS6nDQ525t77SNWXPOXV1aue8Zx+s0rFeC4cd2h6aEcDrL0rIkI4e1k6fULKdW6OWaEBGR2Ric62BWn6JSEiPvzDl3a2/VWxrRK+ytZrInjhsRFuzixo05x3Xnfe5qDWjP9joqH0vuWdFNGI3XQk3PrFnBnZZSRaMDHPbUWz/zhrWb/57RcgT2nJOntIhlzzkRUW2hKzifN28ekpKSEBERgd69e2Pz5s2K2y9fvhzt2rVDREQEOnXqhB9++EH0vG1JKsef6dOni7b7/vvv0bt3b0RGRqJBgwYYNGiQnuq7z4Q2WfU65/LPyzcEzWsgam18GjkX+8U7rnWvAJM4npcnAobqhHDybw4zgiF3s7W7nOft0WHt+vZz5/2sZnvThrVrKFZpFIienn0L/CUhnMxIJA0Xj8E5eUrNnHMmhCMiCnSaW1/Lli1DRkYGJk+ejG3btiE5ORmpqak4ffq05PYbN27EsGHDMHr0aGzfvh2DBg3CoEGDsGvXLvs2p06dEv0sWLAAFosFgwcPtm/zxRdf4P7778eoUaPw+++/Y8OGDbj33nt1nLL7vDPnXK4xaUJl9JZtkfxVl76tY/HG0GT1h/ZQQ9nTiegAICLU83PO3V3D3VVgZ1YyNMljXTmPZWOvw3WtGuK5W9uJnjfjvaPm9My6Bq7OR/hWssj8DujLJm/x4qTzwd2a1/yhc51zLW8FrnNOnmKbc37sfJHLZQKJiMi/aW5ezJo1C2PGjMGoUaPQoUMHzJ8/H1FRUViwYIHk9nPmzEFaWhrGjx+P9u3bY+rUqejWrRvmzp1r3yY+Pl7088033+DGG29Eq1bVSZQqKirw5JNPYvr06Xj44YdxzTXXoEOHDrj77rt1nrZ7zOoxUc7WLvO4KTWp5s55SgUIYSHit9vr/68zfnrqBsmetuCgIJ/smXI6Lw9UMTJMvJSabYijvQqmDWvXz1VcpybuM+q8bO+j3q1isXRsH7SNjxYfx4TjqxkSbtZSapqGtQtvqDmcsJrl4DzJ1XnNvDsZI/u0AAD8O62trmNo+c5xNXWDyCjNG0TCYgEul1bgQlG5t6tDREQm0tT6KisrQ3Z2NlJSUmoKCApCSkoKsrKyJPfJysoSbQ8Aqampstvn5eXh+++/x+jRo+2Pbdu2DSdOnEBQUBC6du2KJk2a4JZbbhH1vjsqLS1FQUGB6Mco5rXJ5KNzb7QDNSVgsornrErtGxEShOG9E+1/390jAdfE1ZMsr2FUmIaje27OuVd6zkPEc85XP9VP9LwvDmt3JyHcXd2aYXxqW8kM53o4HkpPTKz9WqgJzk0Kfl0mhJPuO3ce1q5zzrmuvVxT8xpM+ee12PDsANzfJ0lXWVpO2ZOjP6h2iwgNRnx0BADgKJPCEREFNE2tw7Nnz6KyshJxcXGix+Pi4pCbmyu5T25urqbtP/zwQ9SrVw933XWX/bFDhw4BAKZMmYKJEyfiu+++Q4MGDdC/f3+cP39espxp06YhJibG/pOQoD3zsBwzEsJZYUVVlfzznh7WvnTsdaqH+zaJiUDDOuJgWrjr/Pu6oVn9SCwc1Uv18aMjQzT1Ynnq5kWlQyTsieH0kWHidc4dRyCYwf1s7cp1VCq7Q5NoPHbj1QgPCZbfSAPn4Nyi+Lz9cTeOqSZuM6/nXN/nxnEvPQnhqnNneG/YrcViQbP6kfr313DtfHFkDwUuLqdGRFQ7+Na4RQALFizA8OHDERERYX+s6krU+t///heDBw9G9+7dsXDhQlgsFixfvlyynAkTJiA/P9/+c+zYMcPqaFaHia455ybcKBjWKxHXtYpVFZxZLMCv/74RwUEW2fW/0zo2wYZnB6B7iwaq61A951lLrT3D8SXyRBXDQ7yxzrmb2dpdfLOoCWyMuraugnHZ4NyNbO1qzs+sYeOaEsKJ9hPvaFbCOr2M/K6Tf83Vl8Fh7eRJiYJ550REFLhCtGzcqFEjBAcHIy8vT/R4Xl4e4uPjJfeJj49Xvf2vv/6Kffv2YdmyZaLHmzRpAgDo0KGD/bHw8HC0atUKOTk5kscNDw9HeHi465PSw6Q2mVL85Y2l1NQEGKHBQZJBhtyuamJMW8+wWUvWGcnM698rqSFu6RQPi8WieN3MqIPbPeduLKVmuxFh1Hm56jnXU4YrenrO28XXw97cS5qO0zWxPrbnXBQ9pnfOuWOd9dw8sMAiupGU0DASx7yUYdpikZ/yIffdoi3TvY5KEemUyJ5zIqJaQVPrKywsDN27d0dmZqb9saqqKmRmZqJPnz6S+/Tp00e0PQCsXr1acvsPPvgA3bt3R3KyOEt39+7dER4ejn379tkfKy8vx5EjR9CiRQstp2AIs4LGKkFGOLVLdgkfvrZptOQ22lXXQ81ZWmR+ly3ZRXQ+e2gXrH2mPwBtIxS8NZLWzBsIz6S2xajrWwJQPj9z5py7l63d1Xxcpaet9vefMdfWMRh36kmXC9QEv4cGB+GOLk3VH1PFm9eIOctvD+/u9Fi/axrrKsuIOef+HrBqSgjHOefkQbbg/Og5BudERIFMc9dIRkYG3nvvPXz44YfYs2cPHnnkERQWFmLUqFEAgBEjRmDChAn27Z988kmsXLkSM2fOxN69ezFlyhRs3boV6enponILCgqwfPlyPPjgg07HjI6OxsMPP4zJkyfjp59+wr59+/DII48AAIYMGaL1FNxmRpvMcSk1tY1EYWCx7CHpGyR6qRp6bHH9uyvC4HJQ12b2OaNaypCaEvBA3yT1BehkZjAiHFbsjbWj3Ztzrby3UuBvfs+58vNy5tzTVTTf/+9tGgEA6oQ5z41Xc2PBiDnnwqn9/05ri68fux69W8WiW2J9VftbFG6vGZEQzpurPinVXj4hHINz8k2JsRzWTkRUG2gOzocOHYoZM2Zg0qRJ6NKlC3bs2IGVK1fak77l5OTg1KlT9u379u2LJUuW4N1330VycjI+//xzfP311+jYsaOo3KVLl8JqtWLYsGGSx50+fTruuece3H///ejZsyeOHj2Kn3/+GQ0aqJ/HbBSzkoAJl1JTPZ9RsFndcE2zFGTZG9QOVRjYuXp6gbBnTvtceC2tdVcBXs3vUsvQJTksOeZvQoXDinUss+cWN4e1V1QqZDeEq55zexUM4TznXPtnq6asmt/n3NMV41PbYvGY6xS3k62XEcG54FwaRoWhS0J9AMDnD/fFnV2budxfaVh7sMyw9r6tY3FTu6tkyxNmg/e3JZk5rJ18la3n/FRBCUorKr1cGyIiMouujETp6ek4evQoSktLsWnTJvTu3dv+3Lp167Bo0SLR9kOGDMG+fftQWlqKXbt24dZbb3Uqc+zYsSgqKkJMTIzkMUNDQzFjxgzk5eWhoKAAq1evxrXXXqun+m4zo1EWFhIkir/UrrKktyp392gu+5ytQe3YWB/SvTn2vZSGwd1r9i0qq2kkiJZSM+AaaRvW7hwFeGKdZqVA77bOTfDrv2/UXbYwOFeKcUxbSs2N8LjMZXCubVSGOxyLcScmFl6ThnXC8NiNV6NJTITTdmoy6hvRcy5XQlCQRVXPruI65zL7v/DPa/H2fc7D6avro5wfwZe8Oayr02NabrwyWzt5UmydMESFVS+reeKCd/I4EBGR+XwuW7s/MLpJNj61LRrVDRcNzTY7E/Dr/y/Z5TaODVWLxYLwkGBVwY0R1dfSUJYKCDyRbVrpCEEWi335Gz28mS3b3Wz5ZRXagvOYyFD77zXD2j0059zN40jt3S3R9Yie5g30L/llIzwXtUGx8GaO6Iaaw3ZywblSskCLRVwRqZtmnqL0ulosFtye3BSbn7sJtyfX5BLQcr8k1AM3/4hsLBYLk8IREdUCbF3oYOSw9gf6JuGxG68GANH6vKrnnJsQxNvmNzvNzb3yf7kbB2qqItVWl8+orJ5UGSFqhx+4Qc/ljwxVt363qOdcIcgx6z6OmbcGhHWuFxGCHZP+Yf/b6Pn1rhPCaSlL4kGJx4KDLBjYqYliWQ3rhKF9E/eSOLr92ivkiQiRvTmkPKZC+Pr5ei/6VdERuKVjzcohWi5nGINz8jAG50REgY+tCx2MDIaEgcLjA67GkO7N8dG/eqF+nVCFvQR1Ma4qdvaeS9nlhuTmmQt/NzbZlStSCeHkgwvjKL0X5J5TWs9eSDg02tNBjgXu3fhxdYrC931VlVXyWIYNa3d4H7lTrmQ9pd7rFrj8cFqtsM8Rd+WlQR0lH9fzORMGz8K9HW9ayN3cqu45l/8O8Id55haZ37UMVfe1deAp8NmDc2ZsJyIKWAzOdTCySSbsfKkXEYrpQ5JxwzWN8c59PWqOd+WAt3ZyXhvezNHvzsu5Vf9f61xWV8antQUA3Ns7UVyGq4Rwgt+91nOuJzhSGbyIe841H8Yt7q5z7qq6wrdQpcPJubo5pJXznHPHYe01v7eNq6e9fLkh3ppLkhcdKX2zTnjjQc97ROkGjFzwqXTfwbE4X83WLruPhp2YrZ08zZaxnT3nRESBi8G5DkYmApIrq4PEmuVvSaxpbErPua1smcJl26SCHeQ2kWqs39j2KuyY9A+87Ng7qOHkfLLnXOZxx2BUjngpNc9z5+q5mmss7jmXOb5BL5/TsHbHnnTBmb47QjrRWc22+h+TLE/lhlVSyxFoOI7s8RXqEizbc66cj0D40ntjCUA15JeAVH9FzVq1g0hOAoe1ExEFPAbnOhg6rN3N3hczG4jOc3Or/1ZTZ63Vqh8V5nQuWm6CSMWC3k4IJ6dSJtBypHbOuRkssLg3rN1V+Yo959Yr/9d9eBFXc86F6keGKRcmNYJdcki+e9fPUUSo9Fe12s/Id4//TfJxUWCqcp1z5SkPFvGccwPftloDfeUbZ9ID29kZTr6shSA492ayRSIiMg+Dcx2MGm4LuJ+V3Z2914/vj4WjeqJTM/HydTXDiqXJr21uVM20lyDVcPfEsHalCEAugFGzzBbg3WzQFot7r6DjSIZeLRs6lF9TutqbFXo5vgxOiQ7lJiBLVEtLL7mr66e2bX1Lx3iktI+TPobgIErBa0fBZ1ycrb2G48dFbti2qzwL4p5zZQ/d0MrFFp5l5Hc7kdGaNYiExVK9hOm5wjJvV4eIiEzA4FwHNfG02h4YVcuS6X5S2sSB7QEALWLr4Ma2Vzk9X5OtXXpurpps7cYspaZ+W6n4LkJlVnR36DnNDk2i8f+6N8cTA65W3E4YHHllWLuBccqgLs3waP/Wqra1BXdqe0pd1dM5d4L8bSTXZUn1kktsB+N6Yd++rztCZG7UKAWTWjvWnHrOZeecK5+Y8LCu6vBof+XPgFnkvqs8cT+PSK/wkGA0iY4AwKHtRESBik0RHdQELWp7bd0e1q4jPHzw7+p6q5yCmiv/d+eGgpahqS4TwgnXeHaIAj4dcx1aN66j+lh66ZlzbrVaMWNIMjJubqv+QJ5OCAc3E8I51NcKqz3TsMt9ZcqQIzf82kbLsHYRySHsUpvJ3azybs4DdftbBL+Ln5MbuaHnPW/cDlqKVhjVIvs7e87Jt9nmnR9jcE5EFJAYnOugpgGnNhmZ28PazWhL2oa1yxQud0NBeF2MSJqn5b6FYxzXp3UsYuuGO23Xp1Wse5VyIKzikze1UbWPnjjb44m1LO4Fl07BuVX9e1Vrj6+r95pzcC5+XjzvWlgR57Ikj6QyiHfk+Jrqud5uB+cyvwP6spFbLBaH10/5xfRWTjW5WjHHG/k6203Oo1xOjYgoIDE4N0nGP65RtZ265Grmthidlj+S3bD6f2oCbyOCc7nzjgpzHq4uF9DNvber6G+pLPjuENbxb20aOTwpvY+rdc6/eex6rB/fX/SYN3L/uPMKSt1MMKtX0lUQ6fis83tT2HusfrRGzWNSx9R+tnoSPAnPRe3uos1Ew7sdhrXrmHPueARXdfJWLCz8DArP28iVOIjM0ILLqRERBbQQb1cgUI3sm4Sb2sfhxhnrFLdztzFoRFNSa0wgl6dMzZxzLceSCsI3P3cT6kU4r/ksF9jc1rkpTheU4sXvdlfXC9U9p0blIFPqeZQjt3SYTXJCfZ210aZJTARO5ZdIPmeBBTEya2ur4TysXcO+sGVrV7eXq8+Q85xzDZVxLMvgjd39/Lq/v/ywdvmEcMrDxbUkhDP1xqNC0XKff8bm5Ou4nBoRUWBjz7kOUg24mzuIsylbALRs5HrOs7sJubU2JpvERLjcRi4osjXk1TSojWjk1gl3Ds4b1glDpETQLmxs//DE32XLsViMnb6tZ41kVz3nUszoOV84qid6tGhg/7thnZplxCwW4Kpo1+8VOU7VtVpVR5L2hHAqz9nV4BNXS/TJDmuXLMv5scpKiVECFhWJ0wx4TZVuTKiZCqF07rJzzlWWB0h/l7x8Z0dVZZlJWC9hHdhzTr4ukXPOiYgCGoNzHaTab3f3SMA/Okgvd6TE/Z5zbft/7xC4AtoDadls7YLf5c5LSzxSJ9x5YIdcACwMeB2HrgvLMbqnTjzPXt0+eoIypUBL7ym1i4/G54/0tf+dem18TZkAGkvM2VdLzw0IveQymctxCs7lNlQ5wVxuVQBPxHlGzjl3vC56h7VbZX63CQ8R3yxzx22dm+DZW9rh23TnddyVPo/iYe2Q/J2AefPmISkpCREREejduzc2b96suP3y5cvRrl07REREoFOnTvjhhx9Ez+fl5eGBBx5A06ZNERUVhbS0NPz111+ibUpKSvDYY48hNjYWdevWxeDBg5GXl2f4ufkrW3CeW1CCkvJKL9eGiIiMxuDcIBYLECYIEtQGgWqCcy09Va4Ie0fluEqWJLvOueHD2pVnXQgPoVRuHUE5jsNu1VC8xoLn1N5o0ZPcTanOZsXBatdjl+JYpzu7NVd9G8nq8H9XtN7gUgraREVJJYST2DcyLBifP9xHlGfCAs/0Cuu52WRVGZjKrTihnAXdIirf9Zxz965SSJAFD/drjU7NY5yeUypbbmoJs7XXWLZsGTIyMjB58mRs27YNycnJSE1NxenTpyW337hxI4YNG4bRo0dj+/btGDRoEAYNGoRdu3YBqH7fDRo0CIcOHcI333yD7du3o0WLFkhJSUFhYaG9nKeeegrffvstli9fjvXr1+PkyZO46667PHLO/qBhnTDUDQ+B1Qocv1Ds7eoQEZHBGJzrINWAk1t2zCZWJijWkxFZ6bhGkGtQ2w6lZpU4I4aHSs05lytVaX6yqBwd1aqrcJNAz5BYPfPd9cTfD/RNwtMqExMC+oboq9EloT7qhoeoL9NqFf7PpRscE/G54LTOuXA5MVfL98k83iOpIbolNhBtqKWH2VtEc84dzi5Ybp1zFzc3xOucm5utXek9pfTVWilzg8KotekDwaxZszBmzBiMGjUKHTp0wPz58xEVFYUFCxZIbj9nzhykpaVh/PjxaN++PaZOnYpu3bph7ty5AIC//voLv/32G95++2307NkTbdu2xdtvv43i4mJ8+umnAID8/Hx88MEHmDVrFgYMGIDu3btj4cKF2LhxI3777TePnbsvs1gsXE6NiCiAMTg3iAUWxcBPrg2pJjhXbsB6vjUp33MuaOgbUC25Oa9SlEIA4Rx1PT1jUnPc7eXpGBJr9JxzueNO+ee1eFzl8m6AQ3I7hXMJDbZgYOcm6svVeMlres7VXacX7rgWE25phzoSr9OAdlc5Pea0lJqGurkKTMXlevazqfZdJdxO6f0r99Xk6qxcJYTTe1WMXGJPPOfc2O+tQFBWVobs7GykpKTYHwsKCkJKSgqysrIk98nKyhJtDwCpqan27UtLSwEAERE1uSyCgoIQHh6O//3vfwCA7OxslJeXi8pp164dEhMTZY9rK7ugoED0E8gSG0YCYFI4IqJAxODcKBaIWqLOGaKlW31hbmaEM6XnXPZY1QdTdUNBpgnu7nrdeobLu9v4lptT7Fi26mHtui6B/E6eXmbNagXm3dtN835mxT31IkLxUL/W9t4koSckbk4oJoRzUUnlId3i7QZ1bQYAuPqqupLbW61WrweDysG5zuhcSMXUAHeuQf+2jWWfUypX7jOj9jM8pHtzVdv5q7Nnz6KyshJxceI8KnFxccjNzZXcJzc3V3F7W5A9YcIEXLhwAWVlZXjttddw/PhxnDp1yl5GWFgY6tevr/q4ADBt2jTExMTYfxISErSesl9JZMZ2IqKAxeBcB+l1jR23ET8iF8+GyAwdVV0XDdtK9SxKcTUUVc3QT7OGh6pJCOe8j+B3HceMVArOdfSc61nP2hPUXie9yd7ULhGnNVu7nAm3tEMXiWO6M+VCbf4BAOjTOhY/P90P3z3unKwMMH9Y+9gbWgEABnVpqmp7p+H+ctsp3aBwHNbu8pjiv/92dSN89K9eLvYC7uzaDB/+qxf+mSx/bkEKX0LCYe1Ka71LSWwYhdf/X2eX25FYaGgovvzyy//f3p3HN1HmfwD/JGmSNr3vg15Q7qtgC6WggNC1IB4IssiiICJ4UEXrsgIrID/XxQsvRFldERURlt0FURQXC+IByCEIyCEgUK6Wo/S+m/n9kTYkbY7JOUn7eb9eA0nmmZlnJknzfOe58NtvvyEsLAwajQZbt27FyJEjIRfTV8qCOXPmoKSkRL+cPXvWSbn2TE3B+ZmrDM6JiFobznNuB1PFN2uFOnMFWjEjTVsrDIu1669ZJl8Xu4umY5k7V8Og01lTEo3p2w7/3XfeYn4Ay/24DfNiX825+ffIuL+qC/uc29Gs3RHm9hmg9sE799peaw7oapA35AxCZKDlUeD185zbuP/mn8uHhqSYTtfs7bTl+lmOzVt+zjpEmq41d4euMUE4/H/ZLW8uGV1YmYlHjc9FDPwI6MY2WLH99PXdW7mrYhwXG+9s5YMZFrdtEhGgwpDO5mvNdfs2z5F5ziMCVK6dn90DREREQKFQtBglvbCwEDExMSa3iYmJsZo+LS0N+/fvR0lJCWpraxEZGYmMjAykp6fr91FbW4vi4mKj2nNLxwUAtVoNtdr+2SW8TWK4bppW9jknImp9WHPuJPYW1VQO1pzbwtTUZKZYC4rMlb0FC836Re+8mVfH9zEaBdt8nsTWnNt+vcU3a2+eKdPb2NXn3OYtbCfm2hxYcAtu6mQ5KLKkd3wIYoP9xCW28TqJba3Rcio18TdvLAVltrbQcHoDChM71KgsD8RnT59zy/sw3sjU97J5n3ex30hbL5f4PueG2zg/H95IpVIhLS0NeXl5+te0Wi3y8vKQmZlpcpvMzEyj9ACwefNmk+mDg4MRGRmJ48ePY8+ePbjzzjsB6IJ3pVJptJ9jx44hPz/f7HHbIsNm7Z7aEouIiOzDmnMnkclgsZRprp+2uemKRB/XBT15k0z03dUdq4npwoBxodt5+RLT9N9S8cTRWnyLwbmNTWIBO+c5d0MBzDj7Lc9l2b03WGwq7Cz2nqrYt9niVGoOfJ+8sS7VODBt3hffXAsZ4+c94q5PYyZrtt5qs3brWbSbpe+j1qDq3DCdmL8VbSUWys3NxeTJk5Geno7+/fvj9ddfR0VFBaZMmQIAmDRpEtq1a4dFixYBAGbOnIkhQ4Zg8eLFGDVqFFavXo09e/bg3Xff1e9z7dq1iIyMRGJiIg4ePIiZM2di9OjRuOWWWwDogvapU6ciNzcXYWFhCAoKwmOPPYbMzEwMGDDA/RfBQ7UL8YNMBlTVNeBKea3V1khEROQ9GJzbwXSfc5nFkqi5OaMd7nPu5NLtpMwk5AzraPFY5pqEao2atTs3X9aIrjl3crN2Q2LP2Z5A2z015waPTZzLiJ7iR2gXdTyZ6UDH1nnOm8QE+eHQeeujNLcIwGxp1m4psDfqPmF9pwFqH7M3A2aP7IoXvjqKWdldxGfODpZq+619nnfNHY6SqjpcKa812p/hoI9W5zl3YfNwS/k326zdNVnxSuPHj8fly5cxf/58FBQUoE+fPti0aZN+0Lf8/HyjvuIDBw7EqlWr8Mwzz2Du3Lno1KkT1q9fj549e+rTXLx4Ebm5uSgsLERsbCwmTZqEefPmGR33tddeg1wux9ixY1FTU4Ps7Gy8/fbb7jlpL6HykSMu2A/ni6uQX1TJ4JyIqBVhcO4k1sqYSjNBuKjR2i3s21l9u5v83509raYx1yzbuFm7mVo3u3JlneU+59cf23O1LA8IZ77WzVyW7Olz7g7ODJSig9QoLK2xmGZ0n3ZYt+88+iaGmFxv6z2M5+/qiW+OFFpNZyk2t96s3b51zc24OQVdYgLNrn94SArG9G2HqCBfs2mas2cqtTv7tMPKnfloH+Hf4sth7fMQFeSLqCBfXK24arx/o5pzE83amzUpl5m7S+MgS38btWaatYv5Dnjo19clcnJykJOTY3Ldt99+2+K1cePGYdy4cWb39/jjj+Pxxx+3eExfX18sXboUS5cutSmvbU1imKYxOK9AWlKo1NkhIiInYZ9zJ5Hp/zGtW2yQydfFDAjnOXQnqNWaXmtYaHVHzblhraPlmnPxVeejesdixZR+Rq9Z7nMuetd6zp7n3BVsefumDEo2ej68axQ+nnp9YC9zef/b6J54+e7eWD7Z+Hrbe67RQb54c0Jfq+mcfUOridjPQoDaB7Oyu1rdny2Bub36JYdhy1ND8OXjN1mcYs5Q84DbaMDFZp8cSy0jmo7hqj8Vlv4GmRsfQ9RHo620ayePpu93frVK4pwQEZEzeVNk6EFMtms3WaWy7tGBmHtrV4xPNz3vqqPN2p3hxk4RACzXEBtKCjfdJx1Gzdqdd15i+gFbKi7LzDw2ZemfbsDQLlFGr4ntc+7S0dpt38QhttSidze48RSiUeL9+/uhc7T5WuEm/mofjEtPQKi/yuj166O1mz7rZ0Z1E503Uyz1rbZ21pbeY0en7HOUqXneTWl+I6tDZAD8VAoTzdrFnUXz4NZq7CqihY0zWOxzbiaTrrpxQ+RsieGc65yIqDVis3Y7mO1zbkLfxFD0TQzF3jNFJteLadZuqbjojLLkY8M6IS7Ez/rURI3H8lf7YOec4Xjlf8cwqvf1fshiAkhXDWxmabf2TKX25eM3YfH/juHOvu2wP7/YbDp7as7tCbXdPSCcLR+ruJDro687M5vm9vXgTR2w8eBF7LPwvljSvEbVlmbNjqx1lU+nDcDhi6UYauX7a43Yec6bf3ybpzPqc+5QjhxjaaxNwxtkRqP1i9gv683JEzTdjON0akRErQuDcyexNlq7SmG69tXhAeGcEBD4KhWYmJFk0zYxwb54ZVyq0WuGwZRTa85F7MpSU3FLzW7N6R4XhPfv1zW3PnC22ELebBvpGXBtn/OYIF8UlFa77gAGVkzph2MFZRiYEu7cHQtG/5lk7lqLeQdcVVvr6MCDtuoYpZtDPTMlHJlOeA/srzk3Dm7n3dYdo5f+iBk3d8TbW0+K2F5c/my9QWXpu27U59zN7xuRMzQ1az9TVCFxToiIyJnYrN1JrJXplD6mU4iZSs1Zg1A5ytqhDGvM3F3ItRScNy98hzdrRm2Nxetv8Fh8cO66Pud/H2N9QL/mHhjUHrHBvrhvgG03aIZ2icJDQ1KcHuyKOVWFueDcjqzY0mLAYrN22w9tV379VQoc/r9sbJp5kx1HNE9sn3N/tY/5dDLd1GpH/m8EnsjqbHpAOCfUPYv5zFkcrd3MHTJOpUbeomnK08LSGlTXNUicGyIichYG53YwVXyzVlhUmmm+Lmq0dhvz4irWztFVNediWCowNw++DAcrE0NsP2NzwUD7CH+j54aBQVa3qObJTRIb0MQE+VlP1Mz827tj++xhCNXYdtNCLHs/Cha7KjjxL5dRs2ZrebV4o8yW0Q3sJ5PJoFH52D2YpNnL2ry5v4lT+NdDmS2DcxO7asqbyQHhWjSLt/1aialFtzxau+HxYeaJmWOzYTt5gBCNEoGN38Vz19i0nYiotWBw7iQyMwPCNTEXhDvarL35YFpSEjNau6uKtRYHhGvW57x7nOmR88Vsb2Kt1XRrHhqARWN66Z8bxhVvT0zDxsdvRM92tuXJnO5xQXhxbC98PLW/Tds5q/bbGX3jm/ZhKQgyF3ilxoc4fHx72Tf+gOdonmdT17h/+7AWr1kcrd3EcRTumMoBlt8Dc58t1pyTt5DJZPp+5xwUjoio9WCfczsYDoDVxFqRTuXjmuB8VK9YnC2qRHpyy0Kzs1lt1u6iUZjN7slghaWg0GieczvyJbZbQfN0TXmKCvTFhP6JmPPfgwCMm7WrfOToERdsNSiwJSAY3y9RfGIDnhJQ6s/VwjmbC/ASwjTY/ORgBGuUoo8ns+HzIbYVhSu56jD29zk3/Rgw/l4+kdUJggAE+TV7b+zqiiCmWbuFmnMzVeduum9A5BSJYRocvliK/KsMzomIWgvWnNvBV6nA3mey8K+HMvWvWR8Q7vqlDjEIHBxt1q6Qy/DC2N64Oy3eof04g5jmnq6qdRI7Wrs9xBbYxR7HVFZtufHhKD+lAgvv6GEiD9dzYe/hnHFTRsyxLV3rTtGBiAoUP0e4LTm23IZCJiqdvcd2bCPrWvQ5F7mdpWbphu/lE1md8eQfOova5445w9DfwRuOlj6K5kdrZ805eY+maU3PsOaciKjVYHBup/AAtVGQDcBiVKE0qDl/5e7ro5yL6TfqjBHZncFq3CWi0Oqqcq3FAeEMH9tTS2cp+DDqZy9ufybzaq3m3IlX7ru/3IzJA5NN5MHxfTunWXvj/xbSOLWG00n7suezJUWcZ+4tap5/sedj6xR8Yj4iscF+6BDpbz2hBZb7nJtr1m59v4zNyVNwOjUiotaHwbkDbKlnUho0X68yGFnVx8Eow1oBOiJA1ye9W6xz+jRbImWh1dL0ZMZTPdl+vS2/RYYj1Ivbt6m8WvsYWBzwzsZzMtck3JFK7z90jwYATBnU3v6dNGMp0HdXv+XmxAeszs/f5EzdaPqzR3Z1+r6Blp8j+7qANOtz7sAfBUfv85jKf2p8MABgdN92Buksb0PkqRLZ55yIqNVhn3MHtOhrKbJZu9LMYzHHsdVDg1PQKToAfRND7d9JUz6sBIFiak2DfG3/yDlaXpY3f5+cmAF7as5NXSdrN2ksXVlba9XNTUPmiCUT+uLXCyXok+D456zpfFzZVaHZAUWz9B2wtQbZlnQA8OwdPfDQkBSTY144g72X1PbtjC+4uc0dbS1i6iv1n0cGoriqDhEBapPHF3MuzmgdQuQMhsG5IAi8uURE1AowOHeI+D6mhj+awX5KvHR3b/gpFQ7XAFr7MVbIZRjaRdx0XdaPZXm9pdrrJk/d0gXHL5Xjj+kJjudHbDoX9jk3HqFeZJ9zE9fJT2Xlq+jEeEBm5n6QI1fJV6lAWpJzBiUUE/s4Mzi35dJanvPetQVjmUzmssBct387t7PwdzDMX4WiilqXHNcaU58RH4XcKDBvkRcP6UJEJEa7UD/IZUB1nRaXy2oQFSR+rA0iIvJMDM4dYG9zyDB/FTJTwsUfx5ZMebgwf5XRQHpiOFpgNgyu7an0shQIGtaiif0ImOrv6q9S2Jwv/XFtbdZuJqNS17qEaJQorqzTN5G39FY5s1m7sypCLY1a7knM1Ug7IzBtft4fTumPv64/aNQUX+z1dvR9EfsRMfzccw5z8iZKhRxxIX44d60K+UWVDM6JiFoBBucOkDV/bKVc989J6bhQUoUuMYEuyYMrzLutO5774rCotJ7a2tPRoEPs1mJrc021MPBXW/4qOjNoMNvn3GlHsM+2P9+MM0UV6N04V7nFZu2S9TkX16zdG7miWXuv+GBsyLnR8vZmPnnN335bvwGuutnkqX/nqG1KDNPog3N3TKlKRESuxQHhnERMOTCrezQmZSa7PC+GHC2f3tQpQnRaSyOmS8mwGbeza8YM99Zijmcb9mOt5tyZl9bcZ0Jm1MLA/e9lsEapD8ytcWZsbu4zYeuUd7ZOyQVI01rB7Gjtdu7PuK+99b00P/zIXjEAWg5a6b6ac4PHkt+iIrINB4UjImpd7ArOly5diuTkZPj6+iIjIwO7du2ymH7t2rXo2rUrfH190atXL3z55ZdG62Uymcnl5ZdfbrGvmpoa9OnTBzKZDPv377cn+07TYhRwCcp1ri7b2zpYkicyrNF2dsxpPCCc/RdIY7Xm3HnMNmv3sMDE0o2U+wboRi7P7CC+e4jZ49gyIJylPude0qzdHDHTOlplx3k/d2dPvDi2F1ZO7W/0uqM30sTe+DBMJeaYbPpOniSBwTkRUatic2lszZo1yM3NxYIFC/Dzzz8jNTUV2dnZuHTpksn027dvx4QJEzB16lTs27cPo0ePxujRo3Ho0CF9mosXLxoty5cvh0wmw9ixY1vs7y9/+Qvi4uJszbZLtAhcW2GZzZYgw1W1rWJqei1u77ysWMyDI8G59Zpz1zdrNyR1/3PActCcnhyGXXOHY+WDGY4fx8zrpq6A5QHhvN//3dnD5m1svanT/H31V/tgfL9EhDcfqM1NNee28tAGQtRGJYU3BudXGZwTEbUGNgfnr776KqZNm4YpU6age/fuWLZsGTQaDZYvX24y/RtvvIERI0Zg1qxZ6NatG5577jnccMMNeOutt/RpYmJijJbPPvsMN998Mzp06GC0r6+++gr/+9//8Morr9iabZdwV/xisZ+rlYKxM7NodSo1Jx7LmcQGze3MjIRtaXPDWmhrwcDfRvcEALw5oW+Lddb7nDuPuc+T1M3abRUV5OuUgeHMnavpZu2tt885YO/c5qYfO8rRT6DomnMryVIi/Y0GsfT8bwa1JWzWTkTUutgUnNfW1mLv3r3Iysq6vgO5HFlZWdixY4fJbXbs2GGUHgCys7PNpi8sLMTGjRsxderUFq9PmzYNH3/8MTQajdW81tTUoLS01GhxNqM+pjK0jqqzFpqdowWeGs+JDTpXTx9gx75lJh+bcu+AJBx9bgTuSG3Z8qNHXLDFbR25tiunOl673Jo5ayo1b/kDYOmz5OgZiNlebLNwR28Qib9vYznhuhmD0L89B9oiz9QUnF8qq0FVbYPEuSEiIkfZFJxfuXIFDQ0NiI6ONno9OjoaBQUFJrcpKCiwKf2HH36IwMBAjBkzRv+aIAi4//778fDDDyM9PV1UXhctWoTg4GD9kpDg+LzazblrICHDPf/jvjSzeXDJsW1p1u7mOiXxg26J21+Qn9LM9uZ3YGs3XV+l6ebr/duH4dU/pmLdowNNrnfkyt7YKQIT+idaTedpNb+eWHtvcUA4L+9zbi9Xnaqld1/MMR3pZmLrsYikEuynRKCvruXVuWusPSci8nYeN1r78uXLMXHiRPj6Xp+vc8mSJSgrK8OcOXNE72fOnDkoKSnRL2fPnnVFdvXcVRjP7hGDZfemWU/oJLYMCOeBsRQA8QPC2fMeWmpWbev1GHNDPPomhtqeCRHEBLquusHkr7Jvxka3fZycVHVuPLWid4Z09gS0xjclRIzW7oR5zsXsonlWxt4QLyqdNZ5404jaLplMpu93fob9zomIvJ5NwXlERAQUCgUKCwuNXi8sLERMTIzJbWJiYkSn//7773Hs2DE8+OCDRq9v2bIFO3bsgFqtho+PDzp27AgASE9Px+TJk00eV61WIygoyGhxthY1ZW4qsxnX2FtL674gwVOLrGKvgD1Xylm1c1Y5GBBIEU+8cU8fdIsNwvN39bRre8M8xwb7mk/oIHMtPkwOCGdhP/aMDu5pmp/CJzYOuOfMc3P0I2v43Tz2txFY/MdUk+lszbOn/p2jtov9zomIWg+bgnOVSoW0tDTk5eXpX9NqtcjLy0NmZqbJbTIzM43SA8DmzZtNpn///feRlpaG1FTjQtSbb76JX375Bfv378f+/fv1U7GtWbMGzz//vC2n4DLurClzZ+G+xXRxFrgqAHT0BoNRzbmTj+Ou4NzRS9sgpubcyadyZ592+GrmTUgK97dr+57tnH9DzRRzl8bkgHAiR2v31mbtzbM9qGMEHh2aInorZ563pX7eYg5j+H1W+1ieDUHsfgAwOiePw+nUiIhaD5vbm+bm5mLy5MlIT09H//798frrr6OiogJTpkwBAEyaNAnt2rXDokWLAAAzZ87EkCFDsHjxYowaNQqrV6/Gnj178O677xrtt7S0FGvXrsXixYtbHDMx0bi/bEBAAAAgJSUF8fGmmyq6g/FgYHBb1Cyzperc0WPZkNZTm3saDwjn3H07Y7RwMRzNt1ZUs3aD4zX+L5cBWone1rvTElBbr0V6chimrtgtTSaa8dKY24il76k9wbWt2/yhezSSwjXomxBiMd2f+ifC10eOWf8+YHumIH5AOE+YNpDIEU0152cZnBMReT2bg/Px48fj8uXLmD9/PgoKCtCnTx9s2rRJP+hbfn4+5PLrFfIDBw7EqlWr8Mwzz2Du3Lno1KkT1q9fj549jZu6rl69GoIgYMKECQ6ekvvImj92VRDTrOxoSzzoaLnTkwe5Ej3PuVHNuYXAxI7juK1Vu4MfLjHBvakgRSaTSTaYgEIuw32ZyS4/ji2nZ3FaQw/+rohlbsBCscS0IPJVKvDtn4daDYoVchnGpSfog3NbP4auGhDOM29BUlvGZu1ERK2HXSM15eTkICcnx+S6b7/9tsVr48aNw7hx4yzuc/r06Zg+fbqo4ycnJ3tELa1UhXF3jRLf4rhW1nvAW2KVsweEsxQAOPNy3JEah0PnS5ESaV8TcXEDwrUklwGtfXIeMa0Kmljsc27YvNvJMwm4y8iesfi0Qz76JV9vUm7t6tjTnN8dtdWia84NHov5KHjCbw+RoaQw3e9CflEltFoBcje16CIiIuezbxhlAtC8AC5zWZvX5rt1b0Au/liumkrNXWdrz3VVuCm6mnpjB3SODkTfBPtGc28QVXNu6jU3jnToBTyhFYUrqXzkWD3d9Pgh5nhqs3DRA/RZSeahp0ekFxviC4Vchpp6LS6X1yA6yHUDaBIRkWt53FRq3kSyZqxuPK4t5+gNFUqWB4Qz87qFoN1dNRQKuQxDu0QhWNNyLnYxnwFbaoeN9m3XVs7nygDQppnUvLRG3JAXfE1NsjXf9nw1xbxv3nr9qPVSKuSIC9EF5GzaTkTk3RicO6BFn3M3saUvpTvz5aqBw5wa6Dj5DoLCA75Bok7Jzj7nbpsqTkK2fCRuSDLfckHspTJ3uBE9ddNLJoT5ic+QG1i7Pp46Sr3oGykG6Uyda/P9eMNNSGp79P3OOdc5EZFXY7N2J9ENnOXCfRs+N/PYFOdmyYNK3m5kKeDwluDV3przttF1Ufy1mTm8E4L9lPhD96gW64ynHRTHMPB7dGhHdIoKREYH81OIeSJP/QrIRd44szX/ruq+Q+SIxDB//IirOMOacyIir+YB9X5eTKJCqVSDz1nj7kKrPZfBnmbtlnhCcC4mCw02NmtoiuU9tT+xM9ly38JPpcAjQ1PQMSqwxTpHa5BVPnKM6h2LiAC17Ru7kC3fa0+qVR7UMcIp+2kDXwFqBTidGhFR68CacwcYj84MSYJ1a8GTo1lqMZe7BZ5UMDfH4mjtdlwti6O1u+mCiDmMvV0O2kJg4qx3yZ5rld0jGst/PIWIAJWTcmGdrR/L+wcmY/kPp3BHajuT6905QKUt7umXiEBfJW5IDJE6K0Qux+nUiIhaBwbnDmgxWJqbglOppk+zPpWaF0TnjZZM6It3v/sdAzuG4x/bfgdgX3DlCX3OxbHtvWm6Fp7QMsBbtJi9QYSMDuH4auZNiA/1rH7mhmKD/fDrwhFQ+Zj+sEcFXa/pV7rrCyHi8irkMtyRGuf0Q3vRnzlqQxicExG1DgzOHeC2Kb5k5p97UujkqjKrU8eDa8zl7alxuD01Dit3nrF6HEvH94T5ZMWN1m7bPq83a7c9P97GWcGWvbM3dIsNck4GXMhcYA4AvkoFdv11OBQyGRTu+j448Y+NzX3OGZyTB0oM1wXnl8tqUFXbAD+VQuIcERGRPbym3s8TtWhS7qZyqVtnbTMKOCwfubUWWi2dtrvmOXeUvQPCZXfXjSDeIdLfmdnxKM4aK8E7PgmuERXoi3BX95V30R8Yay2RvOQrTm1csJ8SwX66qTZZe05E5L1Yc+4ATyizWSs4Du4c6dj+bThLd8fm9gxW1rx8b/jUnv15S7Nve/ucL7ijO/okhmB4t5ajk7cWTov5PLRFS3OtYrRxCS5wuxA/nC+uatXfBfJuiWEaHDxfgvyiSnSJaTloJREReT7WnDvAXXFZi8OIPO6OOcOQFO68Gs/W0Ofc4mjtduzPE5q1i2Hve6NR+WBC/0REBfo6OUfSem18qtP3KX5ebfIk1v6ON72v6x4diBfG9MKckd3ckCsi27HfORGR92Nw7iQyuG6ec5PHMvG4udhgxweZsm0qNddw6XReBkGrfVOpOTEvLiS2WXvv+GCE+avQI86z+kE7+yNwV994/WNXjNbuyVPQecE9NLcS+1ZFBfninv6J7MtLHiuB06kREXk9Nmt3gLtGTW9e0HfrPOe2HNcLCv0Wp1Izc4KW3mev6XOuFZdu/aOD0CAI7ht12wN0igpwyn6845NAlpj68+AlX3EiJDUOCnfmaoXEOSEiInsxOHdE80KbFIU4Vx/TqB+tlQHhXBSd21I4dkVB2tI+O0WbD+w86V6F2JpzuVwGeRsJM79+YjAulFSZHS3d1q4Anlxb3tokhTmzuw7fN2od2KydiMj7MTh3QIuyuNuatXsmsbWzrnBnnzh8tv8CHhqcYjGds28gZPeIwfzbuiM1Idip+3U2NmVuqUtMoFMHTTL8XnrD+Ave6NNpA7Dj5BX8MT3eemI7mPrb6ql/b4maawrOz16rglYreM2YKEREdB2DcwdI9bNnWEPn6so6o/7tHvw7//LdqZiUmYw+CSGWE1oYrd0eMpkMD9zY3sG9uJ69U6m1ZbbWhHvy98OQN38SMlPCkZkS7tR9Gr5v7E9O3iw22Bc+chlq67W4VFaDmODWNZAnEVFb0HY6lrqAZPOcu7PPuU0Dwrm32G+YNZWPHGlJoVC4uKbgpbG9La5/ZZzzRwF3Bgbnrsfm0d7J8F27PTUOQ7tEIjXes1vCEJnio5CjXahuIFj2Oyci8k4Mzh3grqK4peO4scu5VfbOpe3MPFjTPIu2xqx/7Jdgcf3daa5pbusoV7037uIVtdIGefTyy91mqRRyrJjSH9MNuse05bEEli5diuTkZPj6+iIjIwO7du2ymH7t2rXo2rUrfH190atXL3z55ZdG68vLy5GTk4P4+Hj4+fmhe/fuWLZsmVGaoUOHQiaTGS0PP/yw08+ttWK/cyIi78bg3EmkGkHdk3hD5axb+wJ70PVgH2jXa8MxnFcz9b7xvQTWrFmD3NxcLFiwAD///DNSU1ORnZ2NS5cumUy/fft2TJgwAVOnTsW+ffswevRojB49GocOHdKnyc3NxaZNm7By5UocOXIETzzxBHJycrBhwwajfU2bNg0XL17ULy+99JJLz7U14XRqRETejcG5A9xVgGvRet6N8ykb7t96fOeqqnPXnaOYXXt6zZmY3Hl7zbk3MB4QruV6X6Xuz21viQcP9Nb7NK7LtuVxNTz72+86r776KqZNm4YpU6boa7g1Gg2WL19uMv0bb7yBESNGYNasWejWrRuee+453HDDDXjrrbf0abZv347Jkydj6NChSE5OxvTp05GamtqiRl6j0SAmJka/BAWZnlGBWmLNORGRd2Nw7pXcV1y05UieHsQCLQMTMYGKp5+VmKCFfc5dz9rn/4vHbsIDg9rjtfF93JMhspmnf9fdpba2Fnv37kVWVpb+NblcjqysLOzYscPkNjt27DBKDwDZ2dlG6QcOHIgNGzbg/PnzEAQBW7duxW+//YZbbrnFaLtPPvkEERER6NmzJ+bMmYPKSsuBZk1NDUpLS42WtorBORGRd2Nw7hXMFxld3ufchgM8M6obogLVmHtrV9dlyBBL0qJNbRxRfljXKIlzYh8pBluzeZ5zK+s7RgVg/u3dERXIEZQ9ibW/cV5wz9Hprly5goaGBkRHRxu9Hh0djYKCApPbFBQUWE2/ZMkSdO/eHfHx8VCpVBgxYgSWLl2KwYMH69P86U9/wsqVK7F161bMmTMHH3/8Me69916L+V20aBGCg4P1S0KC5bFBWjMG50RE3o1TqTmTBJWTnlRwTAr3x09zh3t0DXrLAeG8v0ZZzNUec0M8UhNCkNRYcCPnM/7Ye//nqq0w/BPgyX+7WoMlS5Zg586d2LBhA5KSkvDdd99hxowZiIuL09e6T58+XZ++V69eiI2NxfDhw3Hy5EmkpKSY3O+cOXOQm5urf15aWtpmA/TEcN3f+CvltaioqYe/msU8IiJvwr/aXsi9g8/ZOtez8zPn1NHaW2HMJPaUUiIDXJqP1sbmec69pimHd30JuscG4fDFUozp287lxzL1DrbFgD0iIgIKhQKFhYVGrxcWFiImJsbkNjExMRbTV1VVYe7cuVi3bh1GjRoFAOjduzf279+PV155pUWT+CYZGRkAgBMnTpgNztVqNdRqtfgTbMWCfJUI0ShRXFmHs9cq0TWG/fWJiLwJm7U7k7sGiDN67OKDGk0P5V2Femext2zeVq9Xa2Fzs3bD74oHv/WenDdT1jw0AJ9OG4BJmclSZ6XNUKlUSEtLQ15env41rVaLvLw8ZGZmmtwmMzPTKD0AbN68WZ++rq4OdXV1kMuNix0KhQJardZsXvbv3w8AiI2NtedU2iR90/arbNpORORtWHPuAD+lAsO7RqGytgHxoX5uO647a3JaW6VRawyYW9lbRGQk0FeJzJRwtxyrtf29c0Rubi4mT56M9PR09O/fH6+//joqKiowZcoUAMCkSZPQrl07LFq0CAAwc+ZMDBkyBIsXL8aoUaOwevVq7NmzB++++y4AICgoCEOGDMGsWbPg5+eHpKQkbNu2DR999BFeffVVAMDJkyexatUq3HrrrQgPD8eBAwfw5JNPYvDgwejdu7c0F8ILJYZpcOBcCfudExF5IQbnDpDJZHj//n5uOI5961o7e069xWjtLjoOtT1t+bvozfi+mTZ+/HhcvnwZ8+fPR0FBAfr06YNNmzbpB33Lz883qgUfOHAgVq1ahWeeeQZz585Fp06dsH79evTs2VOfZvXq1ZgzZw4mTpyIoqIiJCUl4fnnn8fDDz8MQFdj/8033+hvBCQkJGDs2LF45pln3HvyXo6DwhEReS8G517InWVJTyi3psaHSJ0Fkpg3BFCGXUxaX/uM1stoQDiP+IvnOXJycpCTk2Ny3bffftvitXHjxmHcuHFm9xcTE4MPPvjA7PqEhARs27bN5nySMQbnRETei8G5F2heXHTrgHAeEBX1ig/GJw9moF2I410Hmvcj9rb+t+Q+Ng8IJ/1XRRR+5C3wkveQyBIG50RE3osDwnkhd9bueEpZdVDHCCRH+EtybE+4QWFJx6hAqbPQKjkyzzlv+ngPD/96E9ksoTE4P1dUBa2Wf4yIiLwJg3NnauPznHuyP3TX9ZO8d0CS247prgDthbG9MKF/AjbkDHLPAYlaEeN5zqXLB5GzxIX4wUcuQ22DFgWl1VJnh4iIbMBm7V7Ivc3arz/2tNpAW2q0370vDRW1DQhQ2/6R9/QCe0SAGovGtO6RjD38LQBg/Hn09M8Mmca3jVoDhVyG+FA/nL5aifyiSsQ5oUsYERG5B2vOnUmCkp2rm7i3lgGSZDKZXYE5ANyRGodAXx+M6sV5dsk8b2nWbmtzfSLyPgnsd05E5JVYc+4FmtfCSVVz3hqJCVNCNCrsm/cHKOSt/GKQQ1r7d6Ut8PTxJUgC378KdLsdiOgkdU5s0jQo3FkG50REXoU1516OZUn38FHIWXAniww/H4IHj4nuuTmTBr/WZNbxzUDeQuCdQcB3rwANdVLnSLSkcF1wfuYqg3MiIm/C4NwLNG9a3lqamnsCNvElZ2pqXJEUJs3MAmQ743nOiQxEdgFShgMNNcCW54B3bwYu7JM6V6JwOjUiIu/E4NzLteXCJGu8yNP8unAEDjx7C/xUCqmzQnZo+pvCPy0EAAhJBO79D3DXPwC/UKDwIPDeMOB/84Bazw56E9isnYjIKzE490IMSqmt8ZYuBX4qBYJ8lVJnw6ROUQEAgBE9YiTOiWfxko8WSUUmA1LvAWbsBnqMAQQtsP1N4J2BwKnvpM6dWU0151cralFeUy9xboiISCwG587kohbSlgaEc2fQwgbgtmGLefIkn04fgJfu7o35t3eXOisei12GyKyASGDcB8CE1UBgHHDtFPDh7cCGx4CqYqlz10KgrxJh/ioArD0nIvImDM69kDsLkKxVImodIgLU+GN6AjQqTtJBZLcuI4EZO4H0B3TPf/4IWJoBHPlC2nyZ0NS0nYPCERF5DwbnziTJPOdEROQMvBlJovgGA7e9Btz/JRCWApQXAGsmAv+aBJQVSp07PU6nRkTkfewKzpcuXYrk5GT4+voiIyMDu3btsph+7dq16Nq1K3x9fdGrVy98+eWXRutlMpnJ5eWXXwYAnD59GlOnTkX79u3h5+eHlJQULFiwALW1tfZk3+tZKkAO6hgOAOgeG+SUY6kUciSFaxDur0J8qJ9T9uksnl6O9uTptLyNp7/XRNQGJQ8CHvkRuPFJQKYADn8GLO0P7FvpEf2aEsN0v9kcsZ2IyHvYHJyvWbMGubm5WLBgAX7++WekpqYiOzsbly5dMpl++/btmDBhAqZOnYp9+/Zh9OjRGD16NA4dOqRPc/HiRaNl+fLlkMlkGDt2LADg6NGj0Gq1+Mc//oFff/0Vr732GpYtW4a5c+faedrepXlgYvi8eaC+ZMINmDOyK1Y80M85x5bJsOWpodg5dziUCja0ICIi0lP6AVnPAtO3ArGpQHUx8NkM4OPRQNEpSbPG6dSIiLyPzdHWq6++imnTpmHKlCno3r07li1bBo1Gg+XLl5tM/8Ybb2DEiBGYNWsWunXrhueeew433HAD3nrrLX2amJgYo+Wzzz7DzTffjA4dOgAARowYgQ8++AC33HILOnTogDvuuAN//vOf8d///tdsPmtqalBaWmq0tBbBGvOjQYf5q/DQkBREBfo67XgKuazVBuYeULlBRBIymuecTTTIXrGpwINbgKyFgI8v8Pu3uhHddywFtA2SZCkxzB8A8HP+Naz48RRKq+skyQcREYlnU8RVW1uLvXv3Iisr6/oO5HJkZWVhx44dJrfZsWOHUXoAyM7ONpu+sLAQGzduxNSpUy3mpaSkBGFhYWbXL1q0CMHBwfolISHB4v68SVSgL964pw/em5TuNVNMERF5Oo7WTg5R+AA3PgE8sh1IuhGoqwS+ngu8/weg8Fe3Z6d7XBAiAlQoq67Hs58fxoC/52HuuoM4crH1VFYQEbU2NgXnV65cQUNDA6Kjo41ej46ORkFBgcltCgoKbEr/4YcfIjAwEGPGjDGbjxMnTmDJkiV46KGHzKaZM2cOSkpK9MvZs2fNpvVUah/d25OW3PImxJ192uEP3aNbvE5EROLx/iY5XXgKMPlz4LbXAXUQcH4v8I/BwJbngfoat2Uj2E+JrX8eiufu7IFOUQGorG3Aqp/yMfKN7zFu2XZ8tv88auu1bssPERFZ53Fz6ixfvhwTJ06Er6/pZtnnz5/HiBEjMG7cOEybNs3sftRqNdRqtauyaZqTm0h/NfMmrN9/AVMHtXfujlsJZ7Qa4KBtZA4/GW0PA3VyGrkcSJ8CdM4GNv4ZOLYR+O4l3aBxdywBEjPcko1AXyXuy0zGvQOS8NOpIny88wy+PlSA3aevYffpa3gu4DDu6ZeICRmJaBfiWYO+EhG1RTbVnEdEREChUKCw0HiqkMLCQsTExJjcJiYmRnT677//HseOHcODDz5ocl8XLlzAzTffjIEDB+Ldd9+1JeteqUNkAHL/0NliH/O2bGjnSABggaItYNBEbsQgnZwmKA645xNg3ArAPxK4cgxYng18+Regptxt2ZDJZBjQIRxL/3QDfpw9DE9mdUZ0kBpXymvx1tYTuOnFLZj20R58f/wytFremiQikopNwblKpUJaWhry8vL0r2m1WuTl5SEzM9PkNpmZmUbpAWDz5s0m07///vtIS0tDampqi3Xnz5/H0KFDkZaWhg8++AByuQcOUMYCnVstvLMHFtzeHf9+xPRnj8gR/Dq3PXzPySVkMqDHXcCMXUCfiQAEYNc/gLcHAMe/cXt2ooN8MTOrE354ehjemXgDBqaEQysAmw8X4r73d2H4q9vw/g+nUFLJAeSIiNzN5gg3NzcX7733Hj788EMcOXIEjzzyCCoqKjBlyhQAwKRJkzBnzhx9+pkzZ2LTpk1YvHgxjh49imeffRZ79uxBTk6O0X5LS0uxdu1ak7XmTYF5YmIiXnnlFVy+fBkFBQVm+61T2xDoq8SUQe0RG+yZNeccCZ7Iu3CATXIpTRgw+m3g3v8CIYlAyVngk7HAfx8CKovcnh2lQo6RvWKxatoAfJM7GPcPTEag2genrlTguS8OI2PRN3j63wdw6HyJ2/NGRNRW2dznfPz48bh8+TLmz5+PgoIC9OnTB5s2bdIP+pafn29Uqz1w4ECsWrUKzzzzDObOnYtOnTph/fr16Nmzp9F+V69eDUEQMGHChBbH3Lx5M06cOIETJ04gPj7eaJ3ACIgcwI8PERG5VcfhwCM7gK3PAzvfAQ6sBk58A4x8Eeg5VpJ+FR2jAvHsHT0wK7sLPtt/AR/tOI2jBWVYs+cs1uw5i76JIbhvQBJu7RULX6XC7fkjImor7GobnpOTgzNnzqCmpgY//fQTMjKuD2zy7bffYsWKFUbpx40bh2PHjqGmpgaHDh3Crbfe2mKf06dPR2VlJYKDg1usu//++yEIgsmFiFq/cH+V24/Jvy5E5DLqAGDEImDqZiCyG1B5BfjPVODTe4CS85Jly1/tgz9lJOKrmTfh3w9n4o7UOCgVMuzLL0buv37BwBe24IWvjuJsUaVkeSQias08sOM2kfswAPMOi8f1Qb/kUPxzUrrUWaFWJilMg+ggNVIi/SFnq3Zyt4R+wEPfAUPnAHIl8NsmYGkGsPt9QCvdNGcymQzpyWF4c0JfbJ89HLOyuyAu2BdFFbVYtu0kBr+8FVNX7MbWY5c4gBwRkRN53FRqRETNJYZrsPbhgW49JuO0tsFHIccPTw+DXCZjn3OSho8KGDob6H4nsOEx4NxuYGMucOg/wO1vAhEdJc1eZKAaM27uiIcGd8CWo5fw8c4z+P74FeQdvYS8o5eQGKbBvQMSMS4tAaEStHIiImpNWHPuTLx5TNRq8OvcdigVcihYbU5Si+oGPPA1MOJFQOkPnPkReGcg8P1ioEH6kdN9FHLc0iMGH0/NwJanhmDqje0R5OuD/KJK/P3LoxiwKA9/XvsLfjlbLHVWiYi8FoNzIiIiIk8gVwADHgYe3QGkDAMaaoC8/wPeuxm4sE/q3Ol1iAzAvNu646e5WXhxbC/0iAtCTb0W/957Dncu/RF3vPUD1u45i+q6BqmzSkTkVRicOxMrXrwOxxQkc/h1JiLJhCbpplwbvQzwCwUKDgLvDQc2zwfqqqTOnZ6fSoHx/RLxxWM3Yt2jAzGmbzuoFHIcOFeCWf8+gIy/5+H5jYdx+kqF1FklIvIKDM6JXIRxv3fj+9eW8dYMeQCZDOgzAZixC+gxBhAagB/f0DV1P/W91LkzIpPJ0DcxFK+O74Mdc4bh6RFdER/qh5KqOrz3/SkMfeVbTF6+C98cLkQDB5AjIjKLwTkRERGRpwqIAsZ9ANzzKRAYBxT9Dnx4G7DhcaCqWOrctRAeoMYjQ1OwbdbNWH5/OoZ2iYRMBmz77TIe/GgPBr+0FW9/ewJXy2ukzioRkcdhcE5t2p/6JyI22Bf3D0yWOitERETmdb0VmLETSJuie/7zh8DbA4CjG6XNlxkKuQzDukZjxZT++PbPQzF9cAeEaJQ4X1yFlzYdQ+aiLXhyzX7sPXMNAvuYEREB4FRq1MYFa5TYPnsYp1AiIiLP5xsM3P460OtuXc150Ulg9Z+A7qOBW1/W1bJ7oKRwf8y9tRty/9AZXxy4iI93nsEvZ4uxbt95rNt3Ht1jgzApMwl39ImDRsWiKRG1Xaw5pzaPgTmZwk8FEXms5BuBR34EbnwSkCmAw+uBt/oB+z7x6JFOfZUK3J0Wj89mDMKGnEEYlxYPtY8chy+WYvZ/DyLj73lY+Pmv+P1yudRZJSKSBINzIiITPLd4S67WIy5I6iwQWaf0A7KeBaZvBWJ6A9XFwGePAh/fBVw7LXHmrOsdH4KXx6Xip7nD8ddbuyEpXIOy6np88ONpDFu8Dff+8ydsOlSA+gat1FklInIbth0ichEPrrwgIgsSwjT4auZNCNWopM4KkXWxqcC0rcCOJcC3LwC/bwXezgSGzQMyHtLNne7BQjQqTBvcAVNvbI/vjl/Gyp1nkHf0En44cQU/nLiCQF8fpCeFon/7cPRvH4pe7UKg8mHdEhG1TgzOiYiImukWy9pz8iIKH10T92536Pqin/kB+HoOcOg/wJCngYhOQHCCLp2HkstlGNolCkO7ROFsUSVW7crHmt1nUVRRi63HLmPrscsAAF+lHH0SQnTBenIYbkgKYT91Imo1+NeMiIiIqDUITwEmf64byX3zfOD8HmDVON06uRIITQLCUoCwDrolvPH/4ESPCtwTwjR4ekRXPPWHzjhysQw/nbqK3aeLsPv0NRRV1GLn70XY+XsRAMBHLkOPdsHIaB+Gfslh6JccihC2eiEiL+U5f4mJiIiIyDFyOZA+BeicDWx5XhegF50CGmqAqyd0S4ttfICQJF1wH9bhegAfLm3g7qOQo1d8MHrFB+PBmzpAEAScvFyOn04VYfepIuw6VYQLJdX45WwxfjlbjHe/+x0A0CU6EP3bh6Ff+zBktA9DdJCvJPknIrIVg3MiIiKi1iYoDhi9VPdYqwVKzwNFv+umXyv6Hbj6e+Pz33WBe9FJ3dJcU+Ae1qFZ8N5e97obA3eZTIaOUYHoGBWIiRlJAIBz1yqxqzFQ33W6CL9frsCxwjIcKyzDxzvPAACSwjXolxyG/u3D0D85DEnhGs7UQkQeicE5kctwRDgiIvIAcjkQkqBbOgwxXqfVAmUXgKsnDYL3U7rn104B9dXXA/cTm5vt1wcISWzWVL7xcUgioFC6/NTiQzWID9VgzA3xAIDLZTXYc7pIV7t+ugiHL5bizNVKnLlaiX/vPQcAiApU62vV+yWHoUt0IORyButEJD0G5040rEsUNh64iAA1LysRERF5AbkcCI7XLeYC96LfDYJ3g6W++vrj5mQKXYDeoql8iksD98hANUb2isXIXrEAgNLqOuw9cw27GpvC/3KuGJfKarDxwEVsPHARABDsp2wcEV7XFL5Xu2AoFRwRnojcj1GkE93Vtx3CAlToGRcsdVaIiIiIHGMYuLcfbLxOqwXKLjZrKt9Y6170O1Bfpat5v3aq5X6bAvcWTeU76Aatc2LgHuSrxM1donBzlygAQHVdA/afLdYF66eLsPfMNZRU1SHv6CXkHb0EAPBTKtA3MUTfDL5vYij8VJ49JR0RtQ4Mzp1ILpfp//gTERERtVpyORDcTre0v8l4nVYLlBc0aypv0M/dMHA/mWe8rUyha37fFKzH9dUNbucf4ZRs+yoVGNAhHAM6hAMA6hq0OHyhVN9nfffpIhRX1mH7yavYfvIqAECpkKFnu2D0b2wKn5YUhmA/1zfZJ6K2h8E5ERERtbB06VK8/PLLKCgoQGpqKpYsWYL+/fubTb927VrMmzcPp0+fRqdOnfDiiy/i1ltv1a8vLy/H7NmzsX79ely9ehXt27fH448/jocfflifprq6Gk899RRWr16NmpoaZGdn4+2330Z0dLRLz5WcTC7XDUgXFNcycBcEgxp3E83l6yqBa6d1S1PgLpMDCRlAl1uBrqN0te1OolTIkZoQgtSEEEwb3AFarYATjSPCNzWFLyitxr78YuzLL8Y/tv0OmQzoGhOE/smh6N8+HP3ahyIqkCPCE5HjGJwTERGRkTVr1iA3NxfLli1DRkYGXn/9dWRnZ+PYsWOIimrZQmz79u2YMGECFi1ahNtuuw2rVq3C6NGj8fPPP6Nnz54AgNzcXGzZsgUrV65EcnIy/ve//+HRRx9FXFwc7rjjDgDAk08+iY0bN2Lt2rUIDg5GTk4OxowZgx9//NGt508uJJNdD9yTbzReJwhAWcH12vYrx4HftwIFB4H8Hbpl8zwgogvQZaQuUG+XrrsZ4CRyuQydowPROToQ9w1IgiAIOFtUhV2ni7Dr1FXsPn0Np65U4MjFUhy5WIoPd+hGhG8f4Y9+jcF6/+QwJIT5cUR4IrKZTBCENjGkdGlpKYKDg1FSUoKgoCCps0OtWPLsjQCA4V2j8P79/STODdmq6f27s08c3rinr8S5odbOU3+bMjIy0K9fP7z11lsAAK1Wi4SEBDz22GOYPXt2i/Tjx49HRUUFvvjiC/1rAwYMQJ8+fbBs2TIAQM+ePTF+/HjMmzdPnyYtLQ0jR47E3/72N5SUlCAyMhKrVq3C3XffDQA4evQounXrhh07dmDAgAGi8u6p15QcUHwWOPYVcGwjcPoHQFt/fZ1/FNBlhK5WvcNQQOnn8uxcKq3G7tPXsOvUVew6fQ1HC0rRvDQdE+SLfu3DkBofjE7RgegYFYC4YF8G7ERtkC2/S6w5JyIiIr3a2lrs3bsXc+bM0b8ml8uRlZWFHTt2mNxmx44dyM3NNXotOzsb69ev1z8fOHAgNmzYgAceeABxcXH49ttv8dtvv+G1114DAOzduxd1dXXIysrSb9O1a1ckJiZaDM5rampQU1Ojf15aWmrzOZOHC0kAMqbrlqpi4MQ3wLEvgeObgYpLwM8f6RalBkgZpgvUO48A/MNdkp2oIF+M6h2LUb11I8KXVNZhb37j9G2ninDgXAkKSqvx+S8X8PkvF/TbaVQKpEQGoGOUbml6nBSu4ejwRASAwTkRkUmhGpXUWSCSxJUrV9DQ0NCin3d0dDSOHj1qcpuCggKT6QsKCvTPlyxZgunTpyM+Ph4+Pj6Qy+V47733MHjwYP0+VCoVQkJCLO6nuUWLFmHhwoW2nCJ5M78QoNfduqW+FjjzA3D0S13Neuk54OgXusWF/dSbC9YoMaxrNIZ11X0HqmobsO+sbvq2oxfLcOJyOU5fqUBlbQMOni/BwfMlRtsrFTIkh/vrg/amwD0lMoCjxBO1MQzOiYgMLJnQF//5+RyeyOokdVaIWpUlS5Zg586d2LBhA5KSkvDdd99hxowZiIuLM6ott9WcOXOMau1LS0uRkJDgjCyTp/NR6WrKU4YBt74MFBxoDNQ3urWfenN+KgUGpkRgYMr1EebrGrQ4c7UCJy6VX18ul+PkpQpU1TXg+KVyHL9UbrQfmQxoF+KHTgZBe8eoAHSMDESwhqPFE7VGDM6JiAzcnhqH21PjpM4GkWQiIiKgUChQWFho9HphYSFiYmJMbhMTE2MxfVVVFebOnYt169Zh1KhRAIDevXtj//79eOWVV5CVlYWYmBjU1taiuLjYqPbc0nEBQK1WQ61W23Oq1JrIZEBsqm65eU7LfupXjumWH1+XpJ+6UiFHx6hAdIwKNHpdqxVwoaRKH7CfvFyO44W6wL24sg7nrlXh3LUqbD122Wi7iAA1OkY11rZHBuj7tUcFqtmvnciLMTgnIiIiPZVKhbS0NOTl5WH06NEAdAPC5eXlIScnx+Q2mZmZyMvLwxNPPKF/bfPmzcjMzAQA1NXVoa6uDvJmtZUKhQJarRaAbnA4pVKJvLw8jB07FgBw7Ngx5Ofn6/dDJJqH9VM3Ry6XIT5Ug/hQDYZ2uT4TgiAIuFpRa1TTfvKy7v+LJdW4Ul6DK+U12Pl7kdH+AtU+SDGqZdf9nxCmgULOoJ3I0zE4JyIiIiO5ubmYPHky0tPT0b9/f7z++uuoqKjAlClTAACTJk1Cu3btsGjRIgDAzJkzMWTIECxevBijRo3C6tWrsWfPHrz77rsAgKCgIAwZMgSzZs2Cn58fkpKSsG3bNnz00Ud49dVXAQDBwcGYOnUqcnNzERYWhqCgIDz22GPIzMwUPVI7kUke2E/dGplMhogANSIC1BjQwfiGQVl1HU5ermgRuJ+5WoGymnrsP1uM/WeLjbZR+cjRIcK4X3vHqAC0j/CH2of92ok8BYNzIiIiMjJ+/HhcvnwZ8+fPR0FBAfr06YNNmzbpB33Lz883qgUfOHAgVq1ahWeeeQZz585Fp06dsH79ev0c5wCwevVqzJkzBxMnTkRRURGSkpLw/PPP4+GHH9anee211yCXyzF27FjU1NQgOzsbb7/9tvtOnFo/D+2nbotAXyX6JISgT0KI0es19Q04faXSqE/78cIy/H6lArX1WhwtKMPRgjKjbeQyIDFM09jk3nBAOn8E+rJfO5G7cZ5zIidrmid7WNcoLOc850RkAX+bnI/XlOzmYfOpO0uDVsC5a5UtBqM7cakcZdX1ZreLCfJF+wh/JIT5ISFUg4QwDeJD/ZAQpkFkgBpyNpMnEoXznBMRERER2cJL+qnbSiGXISncH0nh/hje7fqUh4Ig4HJZDY4bBu2NgfvlshoUlFajoLQaO35vuU+Vj1wXqIdqkBDmh/hQjf5xQqgGIRolB6YjsgODcyIiIiIiQ17YT91WMpkMUUG+iAryxaCOEUbrSirrcKKxH/vZoiqcu1aJs9cqcbaoChdLqlBbr8Xvlyvw++UKk/sOUPvoa9mvB/HXg3d/NUMQIlP4zSAiIiIiMqcV9FO3VbBGibSkUKQlhbZYV9egxcXiapy9VqkL2ouqGgP3Spy9VoXLZTUor6k32ce9SZi/Sh+0xxs0m08I9UNciB98lRykjtomBudERERERGLYOp964gAgJBEITtA1mw9OAILjAb9Q3b68kFIhR2K4BonhGpPrq+sacO6aLmA/1xiwny2q1L9WXFmHoopaFFXU4sC5EpP7iA5SGwXs8QY18LHBvvBReOdNDyJrGJwTEREREdnDWj/1IxtMb6cKMAjY4xsfJ14P3gNjALl31h77KhX6Ud9NKa2uwzmD2vZz16qMauAraxtQWFqDwtIa7DlzrcX2PnIZYkN8dcF76PVB6pqazEcGqtnfnbwWg3MiIiIiIkc176eevx24dERXu17SuBSfBSqvALXlwOUjusUUuRIIijMO2Jtq3kMSgaB2gNLXrafnLEG+SnSPU6J7XMtRqwVBQFFFrb6W/WyzIP78tSrUNmh1rxdVAbhquDX8UINInyp0CapHh4A6aILDUR/RDRGBfogIUCM8QIWIADUiA9QI8vNhEE8eh8E5kYu0kVkKiYiIqDkflW7KtQ5DW66rrQRKzwPF+dcD9pJz1x+Xnge0dUDxGd1ijn+UcVN5o+bz8YBviNc1nZfJZAjX+CBcrkWqpgoIKwaqr+laJVRdg7ayCFWlV1FVcgV15VchVF2DvKYE6roS+GvLoELj1HCVjcsl4PJvwfhe2wubG3rje20vXEUwAECpkCHcX42IQF3A3hS8RzY+Ngzmw/xVUHDqOHIDBudERERERO6i0gARnXSLKQ31QNlFg4C9MYgvOXe9Fr6uUtdsvuIScH6vmeMEGtS2m2g+HxDt2gHr6qqBqmvXl+pig+fF5tdVlwIwXcEhB+DfuJgjyH1QpwpGtSIQvlWFiNSWYIziB4xR/AAAOIz2+La+F77T9sbe0s4oKLUeDsllukHsTAXzTTXxTc/DA1RQ+3hnlwSSHoNzIiIiIiJPofDRBdMhCQAyW64XBKCyyLipvD6IbwzoK68CtWXApcO6xRS5EghuZxCwx7ccuE6uBGpKrQTYxSbWXQPqqx27DqoA3cB5fiG6VgB+oQZLs+cG62Uqf6hkMqgAXfeCszuBE3nAyTyg4CC64xS6+5zCo9iABqU/iiIzcDY0E4f9++H3hmhcKa8xWGpxrbIWWgG4Ul6LK+W1OFZoPetBvj6ICFQjwkww3xTQhweoOK0cGbHr07B06VK8/PLLKCgoQGpqKpYsWYL+/fubTb927VrMmzcPp0+fRqdOnfDiiy/i1ltv1a8319/jpZdewqxZswAARUVFeOyxx/D5559DLpdj7NixeOONNxAQYHqwCSIiIiKiVkcmA/zDdUtcH9NpaiuMm8o3bz7f1HT+2mndYvZYckDQOpBXuckA2lqADd9gXdcAR/mogPaDdcsfFgLll4CTWxqD9S1QVF5B5IUtiLywBTcAQGgykDIc6Dtct406EPUNWhRV1uJKWS2ulNfgakWN/vHl8hpcLa/VB/NXy2tRrxVQWl2P0up6s/PAG/JTKvQBfLi/GpH6xyqEN/4f6q9CmL8KoRoVVD4cqb41szk4X7NmDXJzc7Fs2TJkZGTg9ddfR3Z2No4dO4aoqKgW6bdv344JEyZg0aJFuO2227Bq1SqMHj0aP//8M3r27AkAuHjxotE2X331FaZOnYqxY8fqX5s4cSIuXryIzZs3o66uDlOmTMH06dOxatUqW0+ByC3Y45yIiIgkofIHIrvoFlMa6oGyCwYBe77BwHWNzefrq64H5kpNswA6xHJw3ZRGFehZc70HRAGp9+gWrVY3Z/3JPODEFl0N+7XTwJ73dYvcB0jIgE/KMER1HI6omFRA3nIQO0NarYDS6jpd4F5mHLQ3Pb5cXourjY+r67SoqmswGODOukC1D0KbAnaNEmH+aoT5Kxuf617XB/QaFYL9lJCzv7zXkAk2jlqVkZGBfv364a233gIAaLVaJCQk4LHHHsPs2bNbpB8/fjwqKirwxRdf6F8bMGAA+vTpg2XLlpk8xujRo1FWVoa8vDwAwJEjR9C9e3fs3r0b6enpAIBNmzbh1ltvxblz5xAXF2c136WlpQgODkZJSQmCgix/sYgckTx7IwBgaJdIrJhivkUJERF/m5yP15TICQRB1zReW68Lur10ZHib1JQBp75vDNbzgGunjNdrIoCUm3U16ynDgMBohw4nCAIqahtwpUxXG28qmL/aOB/8tYrrzettJZcBoRqVQfCuRJhBTXyYv0FA3/hco1JwJHsnsuV3yaaa89raWuzduxdz5szRvyaXy5GVlYUdO3aY3GbHjh3Izc01ei07Oxvr1683mb6wsBAbN27Ehx9+aLSPkJAQfWAOAFlZWZDL5fjpp59w1113tdhPTU0Nampq9M9LS0tFnSMRERERUZsmkwH+EVLnwr3UgUDXW3ULABT93tj8fStwaptuCryDa3ULAET3AjoO0wXriQMAH7VNh5PJZAhQ+yBA7YPkCEtD3Ok01coXNQbsRY0Be1FFHa5V1uJqedPz6/+XVddDKwBXK2pxtaJWdN5UPnKENQbqYQa19M1r5Zueh7C5vdPYFJxfuXIFDQ0NiI42vlMUHR2No0ePmtymoKDAZPqCggKT6T/88EMEBgZizJgxRvto3mTex8cHYWFhZvezaNEiLFy40Oo5ERERERERGQnrAPTvAPSfBjTUAWd3Xa9Vv7gfKDyoW358A1D6A8k3Ah2H64L18BSnT2Mnl8sQotEFwh0ixW1TW69FcWUtipqC9oo6FFXU6AP6pkC+KbC/WlGL2notauu1KCitRkGp+EH9DJvbN9XCh2iUCPT1QaCv7v8gXyWCDJ43rWNgf53HDQ+4fPlyTJw4Eb6+jjWfmTNnjlGNfWlpKRISEhzNHhERERERtSUKJZA8SLcMnw9UXNHVqDcF6xWXgONf6xZAN/p9ynBdsN5+sG6AOwmofOSICvJFVJC4uEoQBFTVNZisndcH9RW6YP+awXqtAJTV1KOsph75RZU251PtI0egPnD3QZBfY/CuNg7umx43BfhBftfXKRWtI8C3KTiPiIiAQqFAYaHxHAKFhYWIiYkxuU1MTIzo9N9//z2OHTuGNWvWtNjHpUuXjF6rr69HUVGR2eOq1Wqo1bY1LyEiIiIiIrLIPwLoPU63CAJQeOj6dG35O3XT2u39QLfIFEBC/8ZgfRgQ29ezBskzIJPJoFH5QKPyQXyoRtQ2hs3tjZvX16G4Ste0vqy6HqVVdSirrtM/L6uuQ0VtAwCgpl6Lmsb+9vbyVcoNgvjrgX6g2jiINwz0g5q95gkBvk3BuUqlQlpaGvLy8jB69GgAugHh8vLykJOTY3KbzMxM5OXl4YknntC/tnnzZmRmtpy38f3330daWhpSU1Nb7KO4uBh79+5FWloaAGDLli3QarXIyMiw5RSIiIiIiIicQyYDYnrplhuf0E1jd/qH68H61RNA/g7dsvVvgF+Y8cByQbFSn4FDDJvb26pBK6C8uh6ljUF7qT54N/6/tPFxqYl1lY0BfnWdFtV1NbhcZn+A76dUGNXQB/r6YOEdPdAh0n1Td9vcrD03NxeTJ09Geno6+vfvj9dffx0VFRWYMmUKAGDSpElo164dFi1aBACYOXMmhgwZgsWLF2PUqFFYvXo19uzZg3fffddov6WlpVi7di0WL17c4pjdunXDiBEjMG3aNCxbtgx1dXXIycnBPffcI2qkdiIiIiIiIpdT+QOds3ULoJuerWlu9VPfAVVFwKH/6BYAiOphMLBcZtsYGb+RQi5DsEaJYI3S7n3UN2hRXlOvD+5Lq1oG8GU1hsF9y1r8qjpdgF9V14CqugZcMgjwG+wZIt8BNgfn48ePx+XLlzF//nwUFBSgT58+2LRpk37Qt/z8fMgNmmoMHDgQq1atwjPPPIO5c+eiU6dOWL9+vX6O8yarV6+GIAiYMGGCyeN+8sknyMnJwfDhwyGXyzF27Fi8+eabtmafyG1sm6SQiIiIiFqd0GQg/QHd0lAHnNtzva/6hX3ApV91y/YlgI+f8cByEZ2cPrBca+OjkIuvuddqgboKXeuG2gqgthyorUR9dRmqK0pRU1mGmspS1FWVob66HNrqcsSq0gAEuvw8mtg8z7m34ryn5C5N85wP6RyJDx/gPOdEZB5/m5yP15SIvEbFVeD3rddr1subzUKl9AeUfrrFx1dXq+7TuCj9dNO3+fg1vt74XJ/Wynr9/vyu71eh8oybAYIA1FcbBdDXHxsE1nWmXm++NK6rq9QttnpkOxDdw6HTcdk850REREREROQE/uFAr7t1iyAAlw5f76t+Zruulreuwo0ZkpkO3i0G/WYCfZ/G5vkmA+jKloF2UwDd9FzQuvA05YAqQNcFQb8EAErN9cdNr/uFui4fJjA4J3KRuJC202eIiIiIiBwgk+lqaKN7AIMe1wWwZRd1Nch11br/66sMHlcDdVUGjw1fqzFI2/i8RVqD9XqC/TXMrqLUmA6a9c9NrTMTaDc99lF7RgsBExicEznZRw/0x7/3nsPTI7pKnRUiIiIi8kYqDRCe4vrjCALQUGsheDd3I6BZ0N/ipkC1bt9qG4Jmlcb4daUGkCtcfw08CINzIicb3DkSgztHSp0NIiIiIiLLZLLGZupqqXNCAKSfaZ2IiIiIiIiojWNwTkRERERERCQxBudEREREREREEmNwTkRERERERCQxBudEREREREREEmNwTkRERERERCQxBudEREREREREEmNwTkRERERERCQxBudEREREREREEmNwTkRERERERCQxBudEREREREREEmNwTkRERERERCQxBudEREREREREEmNwTkRERERERCQxBudEREREREREEmNwTkRERERERCQxBudEREREREREEmNwTkRERERERCQxH6kz4C6CIAAASktLJc4JERGRTtNvUtNvFDmOv/dERORJbPmtbzPBeVlZGQAgISFB4pwQEREZKysrQ3BwsNTZaBX4e09ERJ5IzG+9TGgjt+u1Wi0uXLiAwMBAyGQyh/dXWlqKhIQEnD17FkFBQU7IYdvE6+gcvI7OwevoHLyO4gmCgLKyMsTFxUEuZ08zZ3Dm7723f5aZf2kx/9Ji/qXF/F9ny299m6k5l8vliI+Pd/p+g4KCvPID52l4HZ2D19E5eB2dg9dRHNaYO5crfu+9/bPM/EuL+ZcW8y8t5l9H7G89b9MTERERERERSYzBOREREREREZHEGJzbSa1WY8GCBVCr1VJnxavxOjoHr6Nz8Do6B68jtRbe/llm/qXF/EuL+ZcW82+fNjMgHBEREREREZGnYs05ERERERERkcQYnBMRERERERFJjME5ERERERERkcQYnBMRERERERFJjMG5HZYuXYrk5GT4+voiIyMDu3btkjpLHmPRokXo168fAgMDERUVhdGjR+PYsWNGaaqrqzFjxgyEh4cjICAAY8eORWFhoVGa/Px8jBo1ChqNBlFRUZg1axbq6+vdeSoe5YUXXoBMJsMTTzyhf43XUZzz58/j3nvvRXh4OPz8/NCrVy/s2bNHv14QBMyfPx+xsbHw8/NDVlYWjh8/brSPoqIiTJw4EUFBQQgJCcHUqVNRXl7u7lORTENDA+bNm4f27dvDz88PKSkpeO6552A4niivI7U23vxb/9133+H2229HXFwcZDIZ1q9fL3WWbCKmLOHJ3nnnHfTu3RtBQUEICgpCZmYmvvrqK6mzZRdT5Q9P9+yzz0ImkxktXbt2lTpbNrFWdvFkycnJLa6/TCbDjBkzpM6aKGLKPK7E4NxGa9asQW5uLhYsWICff/4ZqampyM7OxqVLl6TOmkfYtm0bZsyYgZ07d2Lz5s2oq6vDLbfcgoqKCn2aJ598Ep9//jnWrl2Lbdu24cKFCxgzZox+fUNDA0aNGoXa2lps374dH374IVasWIH58+dLcUqS2717N/7xj3+gd+/eRq/zOlp37do1DBo0CEqlEl999RUOHz6MxYsXIzQ0VJ/mpZdewptvvolly5bhp59+gr+/P7Kzs1FdXa1PM3HiRPz666/YvHkzvvjiC3z33XeYPn26FKckiRdffBHvvPMO3nrrLRw5cgQvvvgiXnrpJSxZskSfhteRWhNv/62vqKhAamoqli5dKnVW7CKmLOHJ4uPj8cILL2Dv3r3Ys2cPhg0bhjvvvBO//vqr1Fmzibnyhzfo0aMHLl68qF9++OEHqbMkmpiyiyfbvXu30bXfvHkzAGDcuHES50wcMWUelxLIJv379xdmzJihf97Q0CDExcUJixYtkjBXnuvSpUsCAGHbtm2CIAhCcXGxoFQqhbVr1+rTHDlyRAAg7NixQxAEQfjyyy8FuVwuFBQU6NO88847QlBQkFBTU+PeE5BYWVmZ0KlTJ2Hz5s3CkCFDhJkzZwqCwOso1tNPPy3ceOONZtdrtVohJiZGePnll/WvFRcXC2q1Wvj0008FQRCEw4cPCwCE3bt369N89dVXgkwmE86fP++6zHuQUaNGCQ888IDRa2PGjBEmTpwoCAKvI7U+rem3HoCwbt06qbPhkOZlCW8UGhoq/POf/5Q6G6KZK394gwULFgip5s+dogAADlxJREFUqalSZ8Nu1sou3mbmzJlCSkqKoNVqpc6KKNbKPK7GmnMb1NbWYu/evcjKytK/JpfLkZWVhR07dkiYM89VUlICAAgLCwMA7N27F3V1dUbXsGvXrkhMTNRfwx07dqBXr16Ijo7Wp8nOzkZpaanX3XV21IwZMzBq1Cij6wXwOoq1YcMGpKenY9y4cYiKikLfvn3x3nvv6defOnUKBQUFRtcxODgYGRkZRtcxJCQE6enp+jRZWVmQy+X46aef3HcyEho4cCDy8vLw22+/AQB++eUX/PDDDxg5ciQAXkdqXfhb73malyW8SUNDA1avXo2KigpkZmZKnR3RzJU/vMXx48cRFxeHDh06YOLEicjPz5c6S6JZK7t4k9raWqxcuRIPPPAAZDKZ1NkRxVqZx9V83HKUVuLKlStoaGgwCnYAIDo6GkePHpUoV55Lq9XiiSeewKBBg9CzZ08AQEFBAVQqFUJCQozSRkdHo6CgQJ/G1DVuWtdWrF69Gj///DN2797dYh2vozi///473nnnHeTm5mLu3LnYvXs3Hn/8cahUKkyePFl/HUxdJ8PrGBUVZbTex8cHYWFhbeY6zp49G6WlpejatSsUCgUaGhrw/PPPY+LEiQDA60itCn/rPYupsoQ3OHjwIDIzM1FdXY2AgACsW7cO3bt3lzpbolgqf3iDjIwMrFixAl26dMHFixexcOFC3HTTTTh06BACAwOlzp5V1sou3mT9+vUoLi7G/fffL3VWRLNW5nE1BufkMjNmzMChQ4e8qp+Ppzh79ixmzpyJzZs3w9fXV+rseC2tVov09HT8/e9/BwD07dsXhw4dwrJly7zuB05K//rXv/DJJ59g1apV6NGjB/bv348nnngCcXFxvI5E5FLeWpbo0qUL9u/fj5KSEvz73//G5MmTsW3bNo8P0FtD+cOwhrN3797IyMhAUlIS/vWvf2Hq1KkS5kyc1lR2ef/99zFy5EjExcVJnRXRpC7zsFm7DSIiIqBQKFqMiF1YWIiYmBiJcuWZcnJy8MUXX2Dr1q2Ij4/Xvx4TE4Pa2loUFxcbpTe8hjExMSavcdO6tmDv3r24dOkSbrjhBvj4+MDHxwfbtm3Dm2++CR8fH0RHR/M6ihAbG9uiINStWzd987am62DpOx0TE9NiEKj6+noUFRW1mes4a9YszJ49G/fccw969eqF++67D08++SQWLVoEgNeRWhf+1nsOc2UJb6BSqdCxY0ekpaVh0aJFSE1NxRtvvCF1tqyyVv5oaGiQOos2CwkJQefOnXHixAmpsyKKtbKLtzhz5gy++eYbPPjgg1JnxSbWyjyuxuDcBiqVCmlpacjLy9O/ptVqkZeX51X9iFxJEATk5ORg3bp12LJlC9q3b2+0Pi0tDUql0ugaHjt2DPn5+fprmJmZiYMHDxoV5Ddv3oygoCCPv+PsLMOHD8fBgwexf/9+/ZKeno6JEyfqH/M6Wjdo0KAW0+/89ttvSEpKAgC0b98eMTExRtextLQUP/30k9F1LC4uxt69e/VptmzZAq1Wi4yMDDechfQqKyshlxv/XCgUCmi1WgC8jtS68LdeetbKEt5Iq9WipqZG6mxYZa38oVAopM6izcrLy3Hy5EnExsZKnRVRrJVdvMUHH3yAqKgojBo1Suqs2MRamcfl3DLsXCuyevVqQa1WCytWrBAOHz4sTJ8+XQgJCTEaEbste+SRR4Tg4GDh22+/FS5evKhfKisr9WkefvhhITExUdiyZYuwZ88eITMzU8jMzNSvr6+vF3r27Cnccsstwv79+4VNmzYJkZGRwpw5c6Q4JY/RfLRUXkfrdu3aJfj4+AjPP/+8cPz4ceGTTz4RNBqNsHLlSn2aF154QQgJCRE+++wz4cCBA8Kdd94ptG/fXqiqqtKnGTFihNC3b1/hp59+En744QehU6dOwoQJE6Q4JUlMnjxZaNeunfDFF18Ip06dEv773/8KERERwl/+8hd9Gl5Hak28/be+rKxM2Ldvn7Bv3z4BgPDqq68K+/btE86cOSN11kQRU5bwZLNnzxa2bdsmnDp1Sjhw4IAwe/ZsQSaTCf/73/+kzppdvG209qeeekr49ttvhVOnTgk//vijkJWVJURERAiXLl2SOmuiiCm7eLqGhgYhMTFRePrpp6XOis3ElHlcicG5HZYsWSIkJiYKKpVK6N+/v7Bz506ps+QxAJhcPvjgA32aqqoq4dFHHxVCQ0MFjUYj3HXXXcLFixeN9nP69Glh5MiRgp+fnxARESE89dRTQl1dnZvPxrM0/3HkdRTn888/F3r27Cmo1Wqha9euwrvvvmu0XqvVCvPmzROio6MFtVotDB8+XDh27JhRmqtXrwoTJkwQAgIChKCgIGHKlClCWVmZO09DUqWlpcLMmTOFxMREwdfXV+jQoYPw17/+1WhKPl5Ham28+bd+69atJn+LJ0+eLHXWRBFTlvBkDzzwgJCUlCSoVCohMjJSGD58uNcG5oLgfcH5+PHjhdjYWEGlUgnt2rUTxo8fL5w4cULqbNnEWtnF03399dcCgBblAG8gpszjSjJBEAT31NETERERERERkSnsc05EREREREQkMQbnRERERERERBJjcE5EREREREQkMQbnRERERERERBJjcE5EREREREQkMQbnRERERERERBJjcE5EREREREQkMQbnRERERERERBJjcE5ELrdixQqEhIRInQ0iIiJyMZlMhvXr10udDSKvxOCcqA25//77IZPJ9Et4eDhGjBiBAwcOiN7Hs88+iz59+rguk0RERGSX5r/zTcuIESOkzhoRicDgnKiNGTFiBC5evIiLFy8iLy8PPj4+uO2226TOFhERETmB4e980/Lpp59KnS0iEoHBOVEbo1arERMTg5iYGPTp0wezZ8/G2bNncfnyZQDA008/jc6dO0Oj0aBDhw6YN28e6urqAOiapy9cuBC//PKL/m78ihUrAADFxcV46KGHEB0dDV9fX/Ts2RNffPGF0bG//vprdOvWDQEBAfrCAxERETmP4e980xIaGgpA1+T8nXfewciRI+Hn54cOHTrg3//+t9H2Bw8exLBhw+Dn54fw8HBMnz4d5eXlRmmWL1+OHj16QK1WIzY2Fjk5OUbrr1y5grvuugsajQadOnXChg0bXHvSRK0Eg3OiNqy8vBwrV65Ex44dER4eDgAIDAzEihUrcPjwYbzxxht477338NprrwEAxo8fj6eeego9evTQ340fP348tFotRo4ciR9//BErV67E4cOH8cILL0ChUOiPVVlZiVdeeQUff/wxvvvuO+Tn5+PPf/6zJOdNRETUVs2bNw9jx47FL7/8gokTJ+Kee+7BkSNHAAAVFRXIzs5GaGgodu/ejbVr1+Kbb74xCr7feecdzJgxA9OnT8fBgwexYcMGdOzY0egYCxcuxB//+EccOHAAt956KyZOnIiioiK3nieRVxKIqM2YPHmyoFAoBH9/f8Hf318AIMTGxgp79+41u83LL78spKWl6Z8vWLBASE1NNUrz9ddfC3K5XDh27JjJfXzwwQcCAOHEiRP615YuXSpER0c7dkJERESk1/x3vml5/vnnBUEQBADCww8/bLRNRkaG8MgjjwiCIAjvvvuuEBoaKpSXl+vXb9y4UZDL5UJBQYEgCIIQFxcn/PWvfzWbBwDCM888o39eXl4uABC++uorp50nUWvlI+mdASJyu5tvvhnvvPMOAODatWt4++23MXLkSOzatQtJSUlYs2YN3nzzTZw8eRLl5eWor69HUFCQxX3u378f8fHx6Ny5s9k0Go0GKSkp+uexsbG4dOmSc06KiIiIABj/zjcJCwvTP87MzDRal5mZif379wMAjhw5gtTUVPj7++vXDxo0CFqtFseOHYNMJsOFCxcwfPhwi3no3bu3/rG/vz+CgoL4m08kAoNzojbG39/fqPnZP//5TwQHB+O9997DqFGjMHHiRCxcuBDZ2dkIDg7G6tWrsXjxYov79PPzs3pcpVJp9Fwmk0EQBPtOgoiIiExq/jvvTGJ+7wHTv/lardYVWSJqVdjnnKiNk8lkkMvlqKqqwvbt25GUlIS//vWvSE9PR6dOnXDmzBmj9CqVCg0NDUav9e7dG+fOncNvv/3mzqwTERGRjXbu3Nniebdu3QAA3bp1wy+//IKKigr9+h9//BFyuRxdunRBYGAgkpOTkZeX59Y8E7UVrDknamNqampQUFAAQNes/a233kJ5eTluv/12lJaWIj8/H6tXr0a/fv2wceNGrFu3zmj75ORknDp1St+UPTAwEEOGDMHgwYMxduxYvPrqq+jYsSOOHj3KuVWJiIjczPB3vomPjw8iIiIAAGvXrkV6ejpuvPFGfPLJJ9i1axfef/99AMDEiROxYMECTJ48Gc8++ywuX76Mxx57DPfddx+io6MBAM8++ywefvhhREVFYeTIkSgrK8OPP/6Ixx57zL0nStQKseacqI3ZtGkTYmNjERsbi4yMDP1orEOHDsUdd9yBJ598Ejk5OejTpw+2b9+OefPmGW0/duxYjBgxAjfffDMiIyP1c6f+5z//Qb9+/TBhwgR0794df/nLX1rUsBMREZFrGf7ONy033nijfv3ChQuxevVq9O7dGx999BE+/fRTdO/eHYBufJivv/4aRUVF6NevH+6++24MHz4cb731ln77yZMn4/XXX8fbb7+NHj164LbbbsPx48fdfp5ErZFMYKdPIiIiIqJWTyaTYd26dRg9erTUWSEiE1hzTkRERERERCQxBudEREREREREEuOAcEREREREbQB7sxJ5NtacExEREREREUmMwTkRERERERGRxBicExEREREREUmMwTkRERERERGRxBicExEREREREUmMwTkRERERERGRxBicExEREREREUmMwTkRERERERGRxP4fosk5JzzoIPwAAAAASUVORK5CYII=\n"
     },
     "metadata": {}
    },
    {
     "output_type": "stream",
     "name": "stderr",
     "text": [
      "100%|██████████| 938/938 [00:54<00:00, 17.31it/s]\n",
      "100%|██████████| 157/157 [00:02<00:00, 58.30it/s]\n"
     ]
    }
   ],
   "source": [
    "train_losses, valid_losses = fit(\n",
    "    model=model,\n",
    "    train_loader=train_loader,\n",
    "    valid_loader=test_loader,\n",
    "    criterion=criterion,\n",
    "    optimizer=optimizer,\n",
    "    start_epoch=start_epoch,\n",
    "    end_epoch=end_epoch,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Test"
   ],
   "metadata": {
    "id": "pC4nEIWSk37a"
   },
   "id": "pC4nEIWSk37a"
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "2035ace6",
   "metadata": {
    "id": "2035ace6"
   },
   "outputs": [],
   "source": [
    "def show_samples(samples, title, figsize=None, nrow=None):\n",
    "    if isinstance(samples, np.ndarray):\n",
    "        samples = torch.FloatTensor(samples)\n",
    "    if nrow is None:\n",
    "        nrow = int(np.sqrt(len(samples)))\n",
    "    grid_samples = make_grid(samples, nrow=nrow, pad_value=1, padding=1)\n",
    "\n",
    "    grid_img = grid_samples.permute(1, 2, 0)\n",
    "    if figsize is None:\n",
    "        figsize = (6, 6)\n",
    "    plt.figure(figsize=figsize)\n",
    "    plt.title(title)\n",
    "    plt.imshow(grid_img)\n",
    "    plt.axis('off')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "6f3f28ed",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "6f3f28ed",
    "outputId": "69d39b24-ae8f-4bf0-b17c-a2f33a82223a"
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stderr",
     "text": [
      "100%|██████████| 28/28 [00:05<00:00,  4.87it/s]\n"
     ]
    }
   ],
   "source": [
    "samples = sample(25, device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "0eccc80d",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 521
    },
    "id": "0eccc80d",
    "outputId": "cc5681f1-b3a8-4550-a53e-975e88e0ab16"
   },
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": [
       "<Figure size 600x600 with 1 Axes>"
      ],
      "image/png": "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\n"
     },
     "metadata": {}
    }
   ],
   "source": [
    "show_samples(samples, title='MNIST samples', nrow=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Blind Spot"
   ],
   "metadata": {
    "id": "3pzLG3NJk8Sx"
   },
   "id": "3pzLG3NJk8Sx"
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "4faa739c",
   "metadata": {
    "id": "4faa739c"
   },
   "outputs": [],
   "source": [
    "def plot_receptive_field(model, n_layers, size=28, device='cpu'):\n",
    "\n",
    "    x_center = size // 2\n",
    "    y_center = size // 2\n",
    "    dummy_input = torch.zeros(\n",
    "        (1, 1, size, size),\n",
    "        requires_grad=True,\n",
    "        device=device\n",
    "    )\n",
    "\n",
    "    output = model(dummy_input)\n",
    "    output[0, :, 0, size // 2, size // 2].sum().backward()\n",
    "\n",
    "    binary_map = (\n",
    "        dummy_input\n",
    "        .grad\n",
    "        .view(size, size)\n",
    "        .abs()\n",
    "        .cpu()\n",
    "        .detach()\n",
    "        .numpy() > 1e-8\n",
    "    ).astype(np.float64)\n",
    "\n",
    "    # stack the maps to get RGB image\n",
    "    binary_map = np.stack([binary_map, binary_map, binary_map], axis=-1)\n",
    "\n",
    "    # center point will be red\n",
    "    binary_map[x_center, y_center] = [1, 0, 0]\n",
    "\n",
    "    plt.imshow(binary_map, vmin=0.0, vmax=1.0)\n",
    "    plt.title(f\"Binary receptive field for {n_layers} layers\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "for n_layers in [1, 2, 3, 5]:\n",
    "    model = PixelCNN(\n",
    "        input_shape=(28, 28),\n",
    "        n_filters=64,\n",
    "        n_layers=n_layers,\n",
    "        kernel_size=5,\n",
    "    )\n",
    "    plot_receptive_field(model, n_layers, 28)"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "zW_1lKWQlD3a",
    "outputId": "daa18b67-9d3a-4ad6-d7e9-5ad8d2e79cb1"
   },
   "id": "zW_1lKWQlD3a",
   "execution_count": 39,
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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\n"
     },
     "metadata": {}
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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\n"
     },
     "metadata": {}
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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\n"
     },
     "metadata": {}
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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\n"
     },
     "metadata": {}
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "PixelCNN имеет blind spot на правой стороне рецептивного поля из-за использования маски для исключения «будущих» пикселей при предсказании текущего пикселя. Маска обнуляет пиксели справа от прогнозируемого пикселя, что приводит к потере информации и созданию слепых пятен."
   ],
   "metadata": {
    "id": "0PAPEbG1lL2v"
   },
   "id": "0PAPEbG1lL2v"
  },
  {
   "cell_type": "code",
   "source": [],
   "metadata": {
    "id": "VuVM1-rXlJUE"
   },
   "id": "VuVM1-rXlJUE",
   "execution_count": 39,
   "outputs": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.11"
  },
  "colab": {
   "provenance": [],
   "gpuType": "T4"
  },
  "accelerator": "GPU"
 },
 "nbformat": 4,
 "nbformat_minor": 5
}