1-ecgnet-train-test.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c20ad946-d13a-4bf6-9b39-b1a7b1cbcea6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"Using device: {device}\")\n",
    "print(torch.cuda.get_arch_list())\n",
    "\n",
    "print(f\"Is CUDA supported by this system?{torch.cuda.is_available()}\")\n",
    "print(f\"CUDA version: {torch.version.cuda}\")\n",
    " \n",
    "# Storing ID of current CUDA device\n",
    "cuda_id = torch.cuda.current_device()\n",
    "print(f\"ID of current CUDA device:{torch.cuda.current_device()}\")\n",
    "       \n",
    "print(f\"Name of current CUDA device:{torch.cuda.get_device_name(cuda_id)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8400c13c-7fb9-4687-8e16-dd24385653a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(torch.cuda.memory_summary(device=None, abbreviated=False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17050c3e-d358-43b5-8fa9-3dcd36b2949c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf75cfb5-aab4-4e16-81f7-2805f196ab48",
   "metadata": {},
   "source": [
    "## Software Implementation of ECGNet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f67e823b-4e59-403b-b394-52792133420b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import onnx\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "from torch.utils.data import DataLoader, Dataset\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from torch.optim.lr_scheduler import CosineAnnealingWarmRestarts\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import itertools\n",
    "import os\n",
    "from PIL import Image\n",
    "from torch import optim\n",
    "from tqdm import tqdm\n",
    "import netron\n",
    "import time\n",
    "from IPython.display import IFrame\n",
    "\n",
    "\n",
    "class CustomDataset(Dataset):\n",
    "    def __init__(self, root_dir):\n",
    "        self.root_dir = root_dir\n",
    "        self.samples = []\n",
    "        self.labels = []\n",
    "        for label in os.listdir(root_dir):\n",
    "            label_dir = os.path.join(root_dir, label)\n",
    "            for file in os.listdir(label_dir):\n",
    "                file_path = os.path.join(label_dir, file)\n",
    "                self.samples.append(file_path)\n",
    "                self.labels.append(int(label))\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.samples)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        sample = np.load(self.samples[idx])\n",
    "        sample = np.squeeze(sample)  \n",
    "        sample = np.expand_dims(sample, axis=0)  \n",
    "        sample = np.expand_dims(sample, axis=0) \n",
    "        sample = torch.from_numpy(sample).float()\n",
    "        label = self.labels[idx]\n",
    "        return sample, label\n",
    "\n",
    "# Load training data\n",
    "train_data = CustomDataset(root_dir='datasets/ecgdata/train_data')\n",
    "# Load testing data\n",
    "test_data = CustomDataset(root_dir='datasets/ecgdata/test_data')\n",
    "\n",
    "# Create data loaders\n",
    "train_loader = DataLoader(train_data, batch_size=32, shuffle=True)\n",
    "test_loader = DataLoader(test_data, batch_size=32, shuffle=False)\n",
    "\n",
    "def show_netron(model_path, port):\n",
    "    time.sleep(3.)\n",
    "    netron.start(model_path, address=(\"localhost\", port), browse=False)\n",
    "    return IFrame(src=f\"http://localhost:{port}/\", width=\"100%\", height=400)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f88227b-dc6b-4728-bfe6-f8b4f5cf1b84",
   "metadata": {},
   "source": [
    "## Define Quantized Model in Brevitas "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ec34be85-1e22-4e5d-96c2-ef544e6f4f11",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import brevitas.nn as qnn\n",
    "import numpy as np\n",
    "\n",
    "class ECGNet(nn.Module):\n",
    "    def __init__(self, num_classes=2):\n",
    "        super().__init__()\n",
    "        myWeight_bit_width = 4\n",
    "        self.features = nn.Sequential(\n",
    "            qnn.QuantIdentity(),\n",
    "\n",
    "            qnn.QuantConv2d(1, 16, kernel_size=(1, 5),\n",
    "                            weight_bit_width=myWeight_bit_width),\n",
    "            qnn.QuantReLU(inplace=True, weight_bit_width=myWeight_bit_width),\n",
    "            qnn.QuantConv2d(16, 32, kernel_size=(1, 5),\n",
    "                            weight_bit_width=myWeight_bit_width),\n",
    "            qnn.QuantReLU(inplace=True, weight_bit_width=myWeight_bit_width),\n",
    "            nn.MaxPool2d(kernel_size=(1, 4), stride=(1, 4)),\n",
    "\n",
    "            qnn.QuantConv2d(32, 16, kernel_size=(1, 3),\n",
    "                            weight_bit_width=myWeight_bit_width),\n",
    "            qnn.QuantReLU(inplace=True, weight_bit_width=myWeight_bit_width),\n",
    "            qnn.QuantConv2d(16, 16, kernel_size=(1, 3),\n",
    "                            weight_bit_width=myWeight_bit_width),\n",
    "            qnn.QuantReLU(inplace=True, weight_bit_width=myWeight_bit_width),\n",
    "            nn.MaxPool2d(kernel_size=(1, 2), stride=(1, 2)),\n",
    "        )\n",
    "\n",
    "        self.classifier = nn.Sequential(\n",
    "            qnn.QuantLinear(16 * 13, num_classes, bias=True,\n",
    "                            weight_bit_width=myWeight_bit_width),\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.features(x)\n",
    "        x = x.reshape(x.shape[0], -1)\n",
    "        x = self.classifier(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99056333-64f2-44b6-95e1-3439617a52e1",
   "metadata": {},
   "source": [
    "## Train Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2aa4e34-c366-49ac-aa3d-e7c77a2969e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(device)\n",
    "torch.manual_seed(876)\n",
    "np.random.seed(0)\n",
    "\n",
    "model = ECGNet()\n",
    "\n",
    "model.to(device)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e09db47-ad02-49d3-afac-f52f0af04911",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Number of epochs\n",
    "num_epochs = 20\n",
    "# Loss criterion and optimizer\n",
    "\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "if torch.cuda.is_available():\n",
    "    criterion = criterion.cuda()\n",
    "\n",
    "optimizer = optim.SGD(model.parameters(), lr=1e-2, momentum=0.9)\n",
    "lr_scheduler = CosineAnnealingWarmRestarts(optimizer, T_0=5, T_mult=1)\n",
    "\n",
    "\n",
    "train_losses = []\n",
    "test_losses = []\n",
    "test_accuracies = []\n",
    "\n",
    "for epoch in range(num_epochs):\n",
    "    model.train()\n",
    "    train_running_loss = 0.0\n",
    "    correct_train = 0\n",
    "    total_train = 0\n",
    "\n",
    "    train_progress_bar = tqdm(train_loader, desc=f'Epoch {epoch+1}/{num_epochs} Training', leave=True)\n",
    "    for images, labels in train_progress_bar:\n",
    "        images, labels = images.to(device), labels.to(device)\n",
    "        # Forward pass\n",
    "        optimizer.zero_grad()\n",
    "        outputs = model(images)\n",
    "        # Backward pass + run optimizer to update weights\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        # Keep track of loss value\n",
    "        train_running_loss += loss.item()\n",
    "\n",
    "        pred = torch.argmax(outputs, dim=1)\n",
    "        total_train += labels.size(0)\n",
    "        correct_train += (pred == labels).sum().item()\n",
    "\n",
    "        train_progress_bar.set_postfix(loss=f'{train_running_loss/(len(train_progress_bar)):.4f}')\n",
    "\n",
    "    train_loss_avg = train_running_loss / len(train_loader)\n",
    "    train_losses.append(train_loss_avg)\n",
    "    print(f'Epoch [{epoch+1}/{num_epochs}], Training Loss: {train_loss_avg:.4f}')\n",
    "\n",
    "    # Testing phase\n",
    "    model.eval()\n",
    "    test_running_loss = 0.0\n",
    "    correct_test = 0\n",
    "    total_test = 0\n",
    "\n",
    "    test_progress_bar = tqdm(test_loader, desc=f'Epoch {epoch+1}/{num_epochs} Validation', leave=True)\n",
    "\n",
    "    with torch.no_grad():\n",
    "        for images, labels in test_progress_bar:\n",
    "            images, labels = images.to(device), labels.to(device)\n",
    "            outputs = model(images)\n",
    "            loss = criterion(outputs, labels)\n",
    "\n",
    "            test_running_loss += loss.item()\n",
    "\n",
    "            predicted = torch.argmax(outputs, dim=1)\n",
    "\n",
    "            total_test += labels.size(0)\n",
    "            correct_test += (predicted == labels).sum().item()\n",
    "\n",
    "            test_progress_bar.set_postfix(val_loss=f'{test_running_loss/(len(test_progress_bar)):.4f}')\n",
    "\n",
    "    test_loss_avg = test_running_loss / len(test_loader)\n",
    "    test_losses.append(test_loss_avg)\n",
    "    test_accuracy = correct_test / total_test\n",
    "    test_accuracies.append(test_accuracy)\n",
    "    lr_scheduler.step()\n",
    "\n",
    "    print(f'Epoch [{epoch+1}/{num_epochs}], Validation Loss: {test_loss_avg:.4f}, Validation Accuracy: {test_accuracy:.4f}')\n",
    "\n",
    "print(\"Training Finished!\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6aa8c75-3765-44bd-9875-ffa69a489cdb",
   "metadata": {},
   "source": [
    "## Plot train and test curves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7e2659c-99ff-4f08-a13d-1f7e4a471899",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# training and test loss\n",
    "plt.figure(figsize=(10, 5))\n",
    "plt.plot(range(1, num_epochs + 1), train_losses, label='Training Loss')\n",
    "plt.plot(range(1, num_epochs + 1), test_losses, label='Test Loss')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Loss')\n",
    "plt.title('Training and Test Loss over Epochs')\n",
    "plt.legend()\n",
    "plt.grid(True)\n",
    "plt.show()\n",
    "\n",
    "# training and test accuracy\n",
    "plt.figure(figsize=(10, 5))\n",
    "plt.plot(range(1, num_epochs + 1), test_accuracies, label='Test Accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.title('Training and Test Accuracy over Epochs')\n",
    "plt.legend()\n",
    "plt.grid(True)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "caac57a5-538e-4154-b8f7-fc482bebd46d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# model_path = \"trained_models/ecgnet_w4a4_model.pth\"\n",
    "# torch.save(model.state_dict(), model_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7bcbecd-b62c-4fb2-8d66-6569dbbfd604",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "bd81893c-980b-4a3a-be7a-d812bd431e06",
   "metadata": {},
   "source": [
    "## Classify single image and measure time taken"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "81cecc3b-1630-4b40-ae15-8ecfcfaebdb3",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cpu\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Device is CPU only for single image classification\n",
    "import torch\n",
    "device = torch.device(\"cpu\")\n",
    "print(device)\n",
    "model_path = \"trained_models/ecgnet_w4a4_model.pth\"\n",
    "model = ECGNet()\n",
    "model.to(device)\n",
    "model.load_state_dict(torch.load(model_path),strict = False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "85c1bf68-98c9-4cb4-9938-e34bb8e717d8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAS4AAAE8CAYAAAB+XlzTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAABEAklEQVR4nO3dd3xTVf8H8E+SJulMB5100jLKaBllC7ZAWygIIqgsAUFFecAB6KOogFX5FReiqCwR0EcRRVHZVBmVvTcUWlpauktHOtM0ub8/0lwIadOkJE1u8n2/Xrw0Nzc3Jze3n5xz7rnn8hiGYUAIIRzCN3cBCCHEUBRchBDOoeAihHAOBRchhHMouAghnEPBRQjhHAouQgjnUHARQjiHgosQwjkUXKTFYmJiEBMTY7Ttbdy4ETweD5mZmUbbprkcPHgQPB4PW7duNfl7qffb6dOnTf5eloKCy4TUB5S9vT1ycnK0no+JiUG3bt3MULLWVVdXhy+++AI9e/aERCKBm5sbunbtilmzZuH69evmLp7eYmJiwOPx2H8ODg6IjIzEihUroFQqTf7+33zzDTZu3Gjy9+ECCq5WIJPJsGzZMnMXw2zGjx+PBQsWoFu3bli2bBkSExPx6KOPYvfu3Th+/Di73tSpU1FTU4Pg4GAzlla3gIAA/PDDD/jhhx+QlJQEe3t7zJs3D4sWLTL5e1Nw3WNn7gLYgh49emDdunVYuHAh2rZta5L3YBgGtbW1cHBwMMn2W+rUqVPYsWMHli5dirffflvjua+++gplZWXsY4FAAIFA0MolNIyrqyueeeYZ9vFLL72E8PBwrFy5Eu+//77Fl99aUI2rFbz99ttQKBR61brq6+vxwQcfICwsDGKxGCEhIXj77bchk8k01gsJCcFjjz2GvXv3onfv3nBwcMCaNWvYvpVffvkFiYmJ8Pf3h4uLC5588kmUl5dDJpPhtddeg7e3N5ydnTFjxgytbW/YsAFDhw6Ft7c3xGIxunTpglWrVrXos6enpwMAHnnkEa3nBAIB2rRpwz5urI9L/TkPHz6Mvn37wt7eHqGhofj+++81tvXee++Bx+NpvUdj2zx9+jSGDx8OT09PODg4oF27dpg5c2aLPp+9vT369OmDiooKFBYWaj2vVCqxdOlSBAQEwN7eHsOGDUNaWhr7/JIlSyAUClFUVKT12lmzZsHNzQ21tbUICQnBlStXcOjQIbap+mD/okwmw/z58+Hl5QUnJyc88cQTWttV78+DBw+yx01ERAQOHjwIAPj9998REREBe3t7REVF4dy5cy3aL6ZGwdUK2rVrh2nTpmHdunXIzc3Vue7zzz+PxYsXo1evXvj8888RHR2NpKQkTJw4UWvd1NRUTJo0CXFxcfjiiy/Qo0cP9rmkpCTs3bsXb731FmbOnInff/8dL730EmbOnIkbN27gvffew7hx47Bx40Z89NFHGttdtWoVgoOD8fbbb+Ozzz5DYGAg/vOf/+Drr782+LOrm30//vgj6uvrDX49AKSlpeHJJ59EXFwcPvvsM7i7u+PZZ5/FlStXDN5WYWEh4uPjkZmZibfeegsrV67ElClTNJqshsrMzASPx4Obm5vWc8uWLcO2bdvw+uuvY+HChTh+/DimTJnCPj916lTU19djy5YtGq+rq6vD1q1bMX78eNjb22PFihUICAhAeHg421R95513NF7z8ssv48KFC1iyZAlmz56N7du3Y+7cuVplSktLw+TJkzF69GgkJSWhtLQUo0ePxo8//oh58+bhmWeeQWJiItLT0/H000+3Sv+dwRhiMhs2bGAAMKdOnWLS09MZOzs75pVXXmGfj46OZrp27co+Pn/+PAOAef755zW28/rrrzMAmP3797PLgoODGQDMnj17NNY9cOAAA4Dp1q0bU1dXxy6fNGkSw+PxmISEBI31BwwYwAQHB2ssq66u1vosw4cPZ0JDQzWWRUdHM9HR0Tr3gVKpZKKjoxkAjI+PDzNp0iTm66+/Zm7fvq21rnp/ZWRkaH3OlJQUdllhYSEjFouZBQsWsMuWLFnCNHY4P7jNbdu2sd+JoaKjo5nw8HCmqKiIKSoqYq5fv8688cYbDABm1KhRGuuqv4fOnTszMpmMXf7FF18wAJhLly6xywYMGMD069dP4/W///47A4A5cOAAu6xr166N7m/1Z4yNjWWUSiW7fN68eYxAIGDKysrYZer9efToUXbZ3r17GQCMg4ODxveyZs0arTJYCqpxtZLQ0FBMnToVa9euRV5eXqPr7Nq1CwAwf/58jeULFiwAAOzcuVNjebt27TB8+PBGtzVt2jQIhUL2cb9+/cAwjFaTqF+/fsjOztaoDd3fT1ZeXo7i4mJER0fj1q1bKC8vb+6jauDxeNi7dy8+/PBDuLu7Y/PmzZgzZw6Cg4MxYcIEjT6upnTp0gWDBw9mH3t5eaFTp064deuWQWUBwNaKduzYAblcbvDrr1+/Di8vL3h5eSE8PByffPIJxowZ02Sn+YwZMyASidjH6s9xf9mnTZuGEydOsM1qQFVDDQwMRHR0tN5lmzVrlkZzefDgwVAoFLh9+7bGel26dMGAAQPYx/369QMADB06FEFBQVrLW7KfTY2CqxW9++67qK+vb7Kv6/bt2+Dz+Wjfvr3Gcl9fX7i5uWkdgO3atWvyve4/AAFVpzIABAYGai1XKpUagXTkyBHExsbCyckJbm5u8PLyYjvWDQ0uABCLxXjnnXdw7do15ObmYvPmzejfvz9++eWXRpsyzX0WAHB3d0dpaanBZYmOjsb48eORmJgIT09PPP7449iwYYNWP19TQkJCkJycjL179+Kbb76Bv78/ioqKYG9vr1fZ3d3dAUCj7BMmTIBYLMaPP/4IQLWPd+zYgSlTpjTab9cUfd6rsfV0HRuNvd4SUHC1otDQUDzzzDM6a10A9D5YdZ1BbOrsVlPLmYYZvNPT0zFs2DAUFxdj+fLl2LlzJ5KTkzFv3jwAeOj+Dj8/P0ycOBEpKSno0KEDfvnll2b7vporM9D0PlMoFBqP1YNCjx07hrlz5yInJwczZ85EVFQUKisrmy2/k5MTYmNjER8fj9mzZ2PXrl04efKk1hlTQ8ru7u6Oxx57jA2urVu3QiaTaZy91Ic+76VrPX1fbwkouFqZutb1YIc4oOrIViqVuHnzpsbygoIClJWVtcr4pu3bt0Mmk+Gvv/7Ciy++iJEjRyI2NtbowyyEQiEiIyMhl8tRXFz80NtT1y4ebHo+WEtV69+/P5YuXYrTp0/jxx9/xJUrV/Dzzz8b/L6RkZF45plnsGbNGmRlZRn8erVp06bhxo0bOHXqFH788Uf07NkTXbt21VjHkNqXtaPgamVhYWHsgZ6fn6/x3MiRIwEAK1as0Fi+fPlyAMCoUaNMXj71r+79v7Ll5eXYsGFDi7Z38+bNRv+gy8rKcOzYMbi7u8PLy6tlhb1PWFgYACAlJYVdVlVVhU2bNmmsV1paqlWDUJ+N1be5+KD//ve/kMvl7PfUEgkJCfD09MRHH32EQ4cONVrbcnJy0qtP0BbQAFQzeOedd/DDDz8gNTVV41e1e/fumD59OtauXYuysjJER0fj5MmT2LRpE8aOHYshQ4aYvGzx8fEQiUQYPXo0XnzxRVRWVmLdunXw9vbW2bxtyoULFzB58mQkJCRg8ODB8PDwQE5ODjZt2oTc3FysWLHCKIM24+PjERQUhOeeew5vvPEGBAIBvvvuO3h5eWkE56ZNm/DNN9/giSeeQFhYGCoqKrBu3TpIJBL2h8NQXbp0wciRI/Htt99i0aJFGmPT9CUUCjFx4kR89dVXEAgEmDRpktY6UVFRWLVqFT788EO0b98e3t7eGDp0aIvKzHVU4zKD9u3bN9l/8e233yIxMRGnTp3Ca6+9hv3792PhwoUtasa0RKdOnbB161bweDy8/vrrWL16NWbNmoVXX321Rdt79NFH8cEHH6C8vBzLly/Hiy++iM8//xzBwcHYunVri7f7IKFQiG3btiEsLAyLFi3Cl19+ieeff16r8z86Ohq9e/fGzz//jFdeeQUff/wxOnTogP379+s82dGcN954A1VVVVi5cmWLtzFt2jQAwLBhw+Dn56f1/OLFizFy5Eh8/PHHmDRpEt5///0WvxfX8RhL7HkjxAZduHABPXr0wPfff4+pU6eauzgWjWpchFiIdevWwdnZGePGjTN3USwe9XERYmbbt2/H1atXsXbtWsydOxdOTk7mLpLFo6YiIWYWEhKCgoICDB8+HD/88ANcXFzMXSSLR8FFCOEc6uMihHAOBRchhHNsqnNeqVQiNzcXLi4udPkEIRaGYRhUVFSgbdu24PN116lsKrhyc3O1roAnhFiW7OxsBAQE6FzHpoJLfbYmOzsbEomkyfXkcjn27duH+Ph4jTmtSMvQ/jQea96XUqkUgYGBep1VtangUjcPJRJJs8Hl6OgIiURidQeHOdD+NB5b2Jf6dONQ5zwhhHMouAghnEPBRQjhHAouQgjnUHARQjiHgosQwjkUXMTibT6ZhVc2n4OsXtH8ysQmUHARi1Ypq0fi9iv460IujqbfNXdxiIWg4CIWbc/lfNTKVfdyzC6pNnNpiKWg4CIWbdu5O+z/U3ARNQouYrHyyms0mofZJTVmLA2xJBRcxGLtvpQPhgHEdqrDNLuUalxEhbPBtWzZMvB4PLz22mvmLgoxEXVQDWrvqXpMTUXSgJPBderUKaxZswaRkZHmLgoxodKqOgBAZIAbAEBaW4/yarkZS0QsBeeCq7KyElOmTMG6devg7u5u7uIQEyppCCl/dwd4OosAUHORqHBuPq45c+Zg1KhRiI2NxYcffqhzXZlMBplMxj6WSqUAVHMayeVN/3Krn9O1DtFfS/dnSaXqu5OI+fB3c0BxZR0yiirQydvR6GXkCms+Ng35TJwKrp9//hlnz57FqVOn9Fo/KSkJiYmJWsv37dsHR8fmD/7k5GSDy0iaZuj+zCkWAODh2vlTENTwAfDx97GzUN6mO+pZ47FZXa1/bZozwZWdnY1XX30VycnJsLe31+s1CxcuxPz589nH6qlh4+Pjm50BNTk5GXFxcVY7y2Rraun+fOv03wCUGBUXg5ozOTibkgFnnxCMHNnZdIW1cNZ8bKpbRPrgTHCdOXMGhYWF6NWrF7tMoVAgJSUFX331FWQyGQQCgcZrxGIxxGKx1raEQqFeX7q+6xH9GLI/a+oUqGkYMe/j6ohgT2cAQE55LX0nsM5j05DPw5ngGjZsGC5duqSxbMaMGQgPD8ebb76pFVqE20qrVWcUhQIenMV2CHRXNe2zaEgEAYeCy8XFBd26ddNY5uTkhDZt2mgtJ9xX0jAUwt1RBB6PB19XVfdAUYVM18uIjeDccAhiG9Q1Lg8n1TAIib3qN7ZSVg+lkjrnbR1nalyNOXjwoLmLQEzk/hoXALjYq/o/GAaoqqtnHxPbRDUuYpHUwaWucdkL+RAKVPfbq6itN1u5iGWg4CIWqfSB4OLxeGwti4KLUHARi1TS0Mfl3hBcAODS0M9VUWt9o8aJYSi4iEUqrVKFk4fjvb4sdXBJKbhsHgUXsUhs5/z9NS4xNRWJCgUXsUgPDocAAImDusZFwWXrKLiIRXpwOASA+zrnqalo6yi4iMVhGKbRGte9znmqcdk6Ci5icSpk9ZArVKPjNYNLVeOS1lCNy9ZRcBGLox7D5SgSwF547+J5CdW4SAMKLmJxyhtqVK4Ompf1SKiPizSg4CIWR12jUvdpqVEfF1Gj4CIW515wada46JIfokbBRSyOuinoLG6qxkVNRVtHwUUsTlNNRUlDnxcNQCUUXMTiVMqaairem0xQQZMJ2jQKLmJx1E3BpjrngXvhRmwTBRexOGxT8YE+LrGdACI7fsM61M9lyyi4iMVpqo8LuH8sF9W4bBkFF7E4FU30cQE0ep6oUHARi8MOh2ikxsVOJkjXK9o0zgTXqlWrEBkZCYlEAolEggEDBmD37t3mLhYxAV1NRXYQqoyCy5ZxJrgCAgKwbNkynDlzBqdPn8bQoUPx+OOP48qVK+YuGjGyyobgkjTSVKTLfgjAofsqjh49WuPx0qVLsWrVKhw/fhxdu3Y1U6mIKTQ1ch6gznmiwpngup9CocCvv/6KqqoqDBgwoMn1ZDIZZLJ7t2yXSqUAALlcDrm86aaG+jld6xD9GbI/FUoGVXUKAIC9nfZrnESqRkJZlcwmvx9rPjYN+UycCq5Lly5hwIABqK2thbOzM7Zt24YuXbo0uX5SUhISExO1lu/btw+Ojo7Nvl9ycvJDlZdo0md/VtcD6sPyyIG/YfdAZ0ZuNg+AAFdu3sIuRZrRy8gV1nhsVldX670uj2EYzlw7UVdXh6ysLJSXl2Pr1q349ttvcejQoSbDq7EaV2BgIIqLiyGRSJp8H7lcjuTkZMTFxUEopFu9PyxD9mdOWQ1iPvsXYjs+Li+J1Xr+uyOZSNpzA2Mi/fDZUxGmKrLFsuZjUyqVwtPTE+Xl5Tr/PgGO1bhEIhHat28PAIiKisKpU6fwxRdfYM2aNY2uLxaLIRaLtZYLhUK9vnR91yP60Wd/1tTXAFB1wje2rouDuGE9pU1/N9Z4bBryeThzVrExSqVSo0ZFuK+pubjUnMSqqZyr66hz3pZxpsa1cOFCJCQkICgoCBUVFfjpp59w8OBB7N2719xFI0ZUKWv8Ams1J5F6hghFq5WJWB7OBFdhYSGmTZuGvLw8uLq6IjIyEnv37kVcXJy5i0aMSF3jamwoBAA4NSyvptkhbBpngmv9+vXmLgJpBVIdo+aBe03FKgoum8bpPi5ife7NxdV4H5djQ1NRPdaL2CYKLmJRKpupcambkFWyenBoJA8xMgouYlGamkRQzbGhqVivZFCnULZauYhloeAiFqW5pqL6rCIAVNGZRZtFwUUsyr0bZTRe4xLwebAXqg5b6qC3XRRcxKJImxmACtzr56qmDnqbRcFFLAo7jquJGhdw78wi3enHdlFwEYuinpJZoiO42EGodNmPzaLgIhZF2tA57+rQdFPRSUSDUG0dBRexGAolwzYVJTqCy5Edy0V9XLaKgotYjMr7pmNubL55NWf1ZT/UVLRZFFzEYpQ39G85CO/dsbox7GU/VOOyWRRcxGKog0tX/xagedkPsU0UXMRiqDvmJQ66Jy1xFFFT0dZRcBGLoW+N696cXNRUtFUUXMRi3BvD1UxwNdS4KqnGZbMouIjFMLzGRcFlqyi4iMW418elX3DRWUXbRcFFLIa6xtVccFHnPKHgIhZDWqMKIhoOQZpDwUUsRrkeF1gDNO884VBwJSUloU+fPnBxcYG3tzfGjh2L1NRUcxeLGBENQCX64kxwHTp0CHPmzMHx48eRnJwMuVyO+Ph4VFVVmbtoxEj07Zx3ZO9mrYBSSTfMsEWcua/inj17NB5v3LgR3t7eOHPmDB599FEzlYoYk9TAGhcA1MgV7FlGYjta9I2XlZVh69atSE9PxxtvvAEPDw+cPXsWPj4+8Pf3N3YZG1VeXg4A8PDwaHIdmUwGmUzGPpZKpQAAuVwOuVze5OvUz+lah+hPn/3JMAzbVHS0070un2HA5wFKBiirqoWILzZugS2YNR+bhnwmHmPgzekuXryI2NhYuLq6IjMzE6mpqQgNDcW7776LrKwsfP/99wYX2FBKpRJjxoxBWVkZDh8+3OR67733HhITE7WW//TTT3B0dDRlEYmB6hTAGydVv6Mf9a2HvUD3+m+dFKBGwcM7Perh7dAKBSQmV11djcmTJ6O8vBwSiUTnugYHV2xsLHr16oWPP/4YLi4uuHDhAkJDQ3H06FFMnjwZmZmZD1N2vcyePRu7d+/G4cOHERAQ0OR6jdW4AgMDUVxcrHPHyOVyJCcnIy4uDkKh7mYLaZ4++7NAWotBn6RAwOfh2nux4PF4Orc56JNDKJDK8Mfs/ujaVvdBbk2s+diUSqXw9PTUK7gMbiqeOnUKa9as0Vru7++P/Px8QzdnsLlz52LHjh1ISUnRGVoAIBaLIRZrNyOEQqFeX7q+6xH96Nqf1fW1AFRDIUQiUbPbUvVrySBTwCa/I2s8Ng35PAYHl1gsZvuK7nfjxg14eXkZujm9MQyDl19+Gdu2bcPBgwfRrl07k70XaX36jppXY4dE0Oh5m2TwcIgxY8bg/fffZzvSeDwesrKy8Oabb2L8+PFGL6DanDlz8L///Q8//fQTXFxckJ+fj/z8fNTU1JjsPUnr0feMohp72Q9dr2iTDA6uzz77DJWVlfD29kZNTQ2io6PRvn17uLi4YOnSpaYoIwBg1apVKC8vR0xMDPz8/Nh/W7ZsMdl7ktaj7+BTNRqEatsMbiq6uroiOTkZhw8fxsWLF1FZWYlevXohNjbWFOVjGXgOgXCMvnNxqdFlP7atxSP3Bg0ahEGDBhmzLMSGldc0f1uy+9GcXLZNr+D68ssv9d7gK6+80uLCENt1t0o1bKWNU/NnFAGaBdXW6RVcn3/+ucbjoqIiVFdXw83NDYBqJL2joyO8vb0puEiLFFeqgsvTWc/gonnnbZpenfMZGRnsv6VLl6JHjx64du0aSkpKUFJSgmvXrqFXr1744IMPTF1eYqWKK+sAAG2c9bt8x0l9U1hqKtokg88qLlq0CCtXrkSnTp3YZZ06dcLnn3+Od99916iFI7bjXo1Lv+C61zlPwWWLDA6uvLw81NdrHywKhQIFBQVGKRSxPcUVhjUVnWneeZtmcHANGzYML774Is6ePcsuO3PmDGbPnm3yIRHEOtXVKyGtVf0Y6l/jonnnbZnBwfXdd9/B19cXvXv3Zq8F7Nu3L3x8fPDtt9+aoozEyqnPKNrxeTQAlejF4HFcXl5e2LVrF27cuIHr168DAMLDw9GxY0ejF47YhuIKVce8h5MIfL7uWSHUHKmpaNNaPAC1Y8eOFFbEKIqrDOuYBwBndvpmqnHZIoODa+bMmTqf/+6771pcGGKb2I55F/2Diz2rSDUum2RwcJWWlmo8lsvluHz5MsrKyjB06FCjFYzYDvUYLk89R80DgFNDcNUplKirV0Jkx5n7vhAjMDi4tm3bprVMqVRi9uzZCAsLM0qhiG25W9mCGpf43tzO1XX1ENnpH3qE+4zyM8Xn8zF//nytS4MI0Yehl/sAgFDAZ2tZNEOE7TFa/To9Pb3RgamENOduVcPlPk6G3a2HhkTYLoObivPnz9d4zDAM8vLysHPnTkyfPt1oBSO2o6gFnfOAahBqSRUFly0yOLjOnTun8ZjP58PLywufffZZs2ccCWkM2zlvQFMRoMt+bJnBwXXgwAFTlIPYKKWSQUkLxnEBdNmPLTO4j2vo0KEoKyvTWi6VSmk4BDFYaXUdlA2zcnsYMBwCuG9OLgoum2NwcB08eBB1dXVay2tra/Hvv/8apVDEduSVq+6n6OEkglBg2OGoHstVSU1Fm6N3U/HixYvs/1+9elXj5q8KhQJ79uyBv7+/cUtHrN7lnHIAQLivi8GvVY/lonnnbY/ewdWjRw/weDzweLxGm4QODg5YuXKlUQv3oJSUFHzyySc4c+YM8vLysG3bNowdO9ak70lM61JDcEUEuBr8WhoOYbv0Dq6MjAwwDIPQ0FCcPHlS467VIpEI3t7eEAgEOrbw8KqqqtC9e3fMnDkT48aNM+l7kdbBBpe/4cFFtyizXXoHV3BwMADV5T3mkpCQgISEBLO9PzGuunolrudVAAAi/d0Mfr0zzTtvs/QKrr/++gsJCQkQCoX466+/dK47ZswYoxTMGGQyGWQyGftYKpUCUF0YLpfLm3yd+jld6xD9NbU/r+ZKUadQwtXBDr4udgbvb7Gdau6uilrd36c1seZj05DPxGP0uEU0n89Hfn4+vL29wec3feaHx+NBoWidajuPx2u2j+u9995DYmKi1vKffvoJjo6OJiwd0cfRAh623BKgo6sSc7oYXpM/XsjD5nQBurgp8WJn87UEiHFUV1dj8uTJKC8vh0Qi0bmuXjWu+5uH5mwqGmrhwoUalyhJpVIEBgYiPj5e546Ry+VITk5GXFwchEL9phImTWtqfx798ypw6w5iIkMxMr4Fk1Jeysfm9ItwdmuDkSP7GLHElsuaj011i0gfLZ4BlQvUc+I/SCgU6vWl67se0c+D+/NyrupA7R7o0aL9LGm4KLtGrrS578mcxybDMNh3tQA/HLuNMT3a4unegUbZriGfR6/g+vLLL/XeIN3JmuijvFqOq3mq4Ood4t6ibTiJaDhEa2MYBrP/dxZ7rqjGcZ7MKEGfEA+083Rq1XLoFVz6zrPF4/FMGlyVlZVIS0tjH2dkZOD8+fPw8PBAUFCQyd6XGN/xjLtgGCDMywk+EvsWbUN9rWIlBVerSb5agD1X8iES8OHv7oCM4ios/vMyvp/ZFzyefjc6MQa9gisjI8PU5dDL6dOnMWTIEPaxuv9q+vTp2Lhxo5lKZdkYhsH/TmTBw1GEUZF+5i4O61j6XQDAwDDPFm9DfSuziloKrtagVDJYnnwDAPD84HZ4qncghn+egn9vFmPLqWxM7Nt6lYeH6uNSn5BsraSNiYmBHidByX32XM7Hoj8ug88DegUPhZ+rg7mLBAA4klYMABgY1qbF25DYq4KrRq6geedbwfaLubieXwEXezu8+GgYXB2FeGVYe3y67wbe+eMyvCViDA33aZWytOibXr9+Pbp16wZ7e3vY29ujW7dudDNYC1Qlq8f7O64CAJQMsOVUtplLpFJYUYubhZXg8YD+oS0PLmf7e7+7FbXWN67JklTX1ePjPakAgBcGh8LVUfWjMWdIe4zvFQCFksHLP51DeXXrfA8GB9fixYvx6quvYvTo0fj111/x66+/YvTo0Zg3bx4WL15sijKSFlq5Pw155bVsTWTLqWzUK8w/nOXfG6raVhc/CdwNnMrmfgI+Dy4N1ytKqbloUl/tT0NOWQ383RzwwuBQdjmPx8Oy8REI9XJCVZ0CB28Utkp5DA6uVatWYd26dUhKSsKYMWMwZswYJCUlYe3atfjmm29MUUbSAmmFFfj231sAgBUTesDdUYi88locTC0ya7lKq+rwyV7VL/fQcO+H3p6koZ9LWkM1LlPJuluNdQ3H0uLRXeAg0rwmWSjgY3hXXwDA39csNLjkcjl69+6ttTwqKopulmEhGIbB4j+voF7JILazN0ZG+OHJqAAAwK9nzNdcZBgGb/52EfnSWoR5OWF2zMPfzs7FXl3jouAyld/O3oFcwWBgWBvEd2m8Dyu2s+pH6GBqIeStUKs3OLimTp2KVatWaS1fu3YtpkyZYpRCEd0OpBbi3T8u4c/zOY327ey9ko+j6XchtuNjyeiuAICxPVVzpR1MLTLbuKejt0qw72oBRAI+vpzUk53d4WHcq3HRj6ap7L6cBwAY3yugyRNxPQLd4eEkQkVtPU5llJi8TC06ctavX499+/ahf//+AIATJ04gKysL06ZN07jEZvny5cYppRXafiEXv5+9g3olA1+JPQZ39EJCN1+ds4AyDINvDqazTa3/Hc9CkIcjdr4yCC4NZ9gYhsGqg+kAVJ2ogR6qazK7+EkQ0sYRmXercSC1EI9FtjXxJ9S2/nAmAGByvyB0bWv4NDaNUZ9ZpBqXfhRKBvuu5CPlZhEcRXZ4c0S4zrOxaYUVuFFQCaGAh9gmaluAqr9xSCdv/Hb2Dv6+VoiB7Vs+zEUfBgfX5cuX0atXLwCqeykCgKenJzw9PXH58mV2vdYcjMYlSiWDj/Zcx5qUWxrLfz1zByMjfPHNlKgmX7sm5RYbWrGdvXE+uxxZJdVY8fdNLHqsCwDVSOYLd8ohtuPj2UdC2NfyeDwkRPhh1cF07LqU1+rBlVMF/Jt2F3we8NygdkbbrsShoalIfVx6ee+vK/jh+G328d1KGZY/3QN8fuN/r7suqUbID2rvyY6ba0pcFx/8dvYO9lzOw7ujOje5TWOgu/y0si/+ucmG1nOD2qFrWwmu5Umx4Ugmdl3Kx/7rBY2OhTmfXYZPG0LrnZGd8cKjoTh0owjTvzuJjUcz8URPf3RtK2G3PT4qQOuuOSO7qYLrwPUiVNfVG6Wppq8Deapf9YQIP7YWaAxU49LfraJK/HQyCwDwZFQA/jiXgz/O56KtmwP+OyJca32GYbDzoqqZODKi+cHLMZ284GJvh9zyWpzIKMGAhxij1xwasdeKTmaUYOX+mwCAZeMisOixLhjXKwDvjOqCmQ21kEV/XMHyfak42jBAE1D9Kr6y+RzqlQxGRfjh+cGqdaMbmpcKJYNxq44i4Yt/sf96IXhN1Gq6+UsQ4O6AGrkCh1rx7GJGcRXOFKl+fWfddyrdGKiPS38r/r4JRcMJm0+f6o5PnooEAKw+lI6rudozMxxMLUJqQQXEdnzE6WgmqtkLBRjVEHDbzt0xbuEfYHBw1dbW4pNPPsHIkSPRu3dv9OrVS+MfaVxNnQKv/XwOSkbVyfng5RGvDOsAX4k9cspq8OX+NEz+9gT+PJ+DKlk9Zm48haySagS4O+D/xkVoNMPff7wbBoa1Uc0mml8BB6EA743uijAvZ60y8Hg89sDaeSnPtB/4Pl/uT4cSPAzp5InugW5G3baEI2cVa+XmnV46rbAC2y/mAgDmxammEHqiZwBGRfhByQCL/7wMpfLeVSkMw+DTfaoa/vSBIXBz1G+83RMNJ4F2X8o36Wc2uK3w3HPPYd++fXjyySfRt2/rXljJZd8fy0RueS383RyQ+HhXreedxXZYN603fjt7B5l3q3AwtQiv/3oB9kIBKmrr4e4oxKaZfbX6GbxcxPjx+X44eKMIF7LLMLlvELx1XLScEOGHNSm3sP96IWrlCtgLTXufgOv5Uuy8rOoneW1Ye6Nv39LHcTEMg2W7r2PDkUx8OLYbnu5jnClgDPXr6TtgGCC2s4/GiZF3H+uMA6mFOH27FC/97wwWjuyMdp5O+OtCLq7kSuEkEuClaP2HrfQJ8YC/mwNyymoQ/3kKRnTzxUvRYQbfM7M5BgfXjh07sGvXLjzyyCNGLYg1q6iVY/Uh1YmM12I7sHeneVBEgCsiAlyhVDJ4+edz2HkxD3JFPbxdxFgzNarRWhSgqkkN6eSNIZ2aH9DZPcAVbV3tkVtei0M3itiBg6ayfN8NMAzQo40SXfx0z2rZEvf6uCyrqbj+cAbO3i6Fk1iAX06rmk0f7LiKmE5eOn9Y9KFQAmezytDZ3439/LrXZ/DH+RwAwFO9AzSe83N1wOLHuuDtbZew72oB9l8vRFwXHyRfLQCg6nIwJHT4fB7mDm2PxX9eRlZJNdam3MLmE1n4z5D2eGFwO9gZeO/MphgcXP7+/nBxMfweeLZsw5FMlFbLEerlxFaldeHzeVgxoQdGdPVFgLsDIgPcIDDSGRr12cX1hzOw61KeSYPr4p0y7LtaAD4PSAgwzaBESzirmF1SjRMZJeAB6BXsjrTCSnzQcI2omqezCMWVdUjcfhXLxkeww1da4rdMPo6cOAkBn4fgNo4Q8Hjo4OOMzr4SnMsug4NIgE+f7M6OcD+WfhcFUhlcHYSI6eSltb2JfYPQK9gdSbuu4UBqEXY31JAf79EWc4YaXkue1DcIo7u3xeGbRfjynzRczZNi75V8vBRtvP5Ng4Prs88+w5tvvonVq1ezd/4hTaupU2DDEdW0QK/FdtT7F0co4GN0d9MMWRjZEFz/XCs06awKn+5TTYHyeHc/+DqYZsS+uc8q7rqUh/m/nEetXBXMAj4P9g37c0gnLygZ4JH2bdA/tA0e//oIdl7Kw54r+ZjaPxhLRncxuKsl824VjhWoXqNQMrhVVAUAuFlYyQ5dAAA3ByGWPhEBAPi9oaP8sUg/iO0a7xro6OOCDTP64mhaMb49nIGBYW3w3KB2Le4KchbbYUQ3P8R38cW2czlo5+Vk1G4lg4Ord+/eqK2tRWhoKBwdHbWmWy0pMf2oWS7ZevYOSqvlCPRwYDvGza1noBs8nEQoqarD2azSh5qhoSmXc8qRcqMIdnwe5gwJw5XjpgkuVzOeVfzzfA5e/fk8AKCznwSOIgHO3C5FVZ0C3fwlWDO1t8aPQtITEVh9KB2Zd6ux8WgmxEI+FiZ0Nug91Sc6ojt64sOxEcgurUa9gsHZrFLcLKiEv7sD1v17Cz+eyEJwG0fUKxlsO6dqJo7r1Xxtf2B7T6MOHuXzeRgfFdD8igYyOLgmTZqEnJwc/N///R98fHyoc14HhZLB+oaLU58fFGq05t7D4vN5GNzBE3+ez0XKjSKTBNePJ1TjhRIi/BDs4YgrRn8HFXPNyaW4b1K9yf2C8P6YrrAT8HH81l3sv16IZweGaJVlYt8gTOwbhF9OZ+O/Wy9izaFb4IGH/w7vBD6fh5MZJfjzfI7GtX5hXs54tKMXwn1dsONiHnY01KrmDWuPQA9Hdkzcox3vNQF5PGDNoVv4v13X2WVT+wejV1DLpsi2RAYH19GjR3Hs2DF0797dFOWxGkolg0/2piLzbjVcHYRanaLmFt3RSxVcN4saHXz4MCpl9firoTN4solnxXxwTq42zto3RzGF5Kv5uN3w3b47qjPbBdA/tE2zPwRP9w5EaVUdknZfx+pD6TiaXgyxHR+nMksbXT9p93W2jwwA+nkp0bVt0yc6Xo/vBFcHIfZczkd6YSVeH94Jzw4MsapKhsHBFR4ejpqaGlOUxWpk3a1G4vYr+Oe6aoqPebEdWnWUuj4Gd1D9Ql/OkaK4UqY1yv5h/Hk+B1V1CoR6OaF/qIdJZw1Rz8lVIauHtLa+1YJrbcMVClP7B7fou30xOgw+Env897eLuHinHIDqs4zv5Y+QhhtP1CsYnMsqxfFbJWxoPfdIMLop0nVuWyjg4z8x7fGfGOMPP7EUBu/xZcuWYcGCBVi6dCkiIiK0+riau5GjNSurrsPK/Wn4/lgm5AoGIgEfSeMiTNLGf1heLmJ08ZPgap4U/94swhM9jVPGKlk9+0c9uW9Qq/zKSxyEquBqpTOLey7n42xWGUQCPqYNbPkJqrE9/REZ4IpTmSXggYfeIe4IbWTIi6xegTOZpeDxeOgdJMGuXbqDyxYYHFwjRowAAAwbNkxjOcMwrXona0tSK1fg+2OZ+Gp/GjueaHAHT7w9sjM6m2DskrFEd/LC1Twpdl/Kb3Fwrfj7BvZczseXk3qio48Llvx1BbfvVsPP1R5PGel+e81pzTm58spr8NbvFwEAMwe1g7fLw43JCvVybjSs7ie2E7Ad5obcpt6aGfUi60uXLj1UYbioolaOJ1cdQ2pBBQCgk48L3h7VGdEdtcfLWJpxPf2x6mA6kq8V4PbdKgS3MezeeHnlNfhqfxrqlQymrT+JIeFe2HrmDvg81ayrzc0mYCyteb3iwt8voaxajsgAV8yPa8Hdt4lRGHwKJjo6WuNfr169kJqaijfeeAOvvvqqKcqo4euvv0ZISAjs7e3Rr18/nDx50uTvqcuiPy4jtaACbZxE+Hh8JHa9OpgToQUAHXxcMKSTFxhGNdLbUBuPZKK+4fq2fGktNp9UDXmYH9cR/UxwprIprTWWK6+8BgdTi8DjAZ9P6EF3FTKjFu/5lJQUTJ8+HX5+fvj0008xdOhQHD9+3Jhl07JlyxbMnz8fS5YswdmzZ9G9e3cMHz4chYWtM8/1g348cRt/nM8FnwesmRqFp/sEWsyQB3298KhqNPMvp7ORU6bfSZfskmqk3CjCTw1DHj4Y2w2d/SToFeSGzS/0x9yhHUxW3sa01uj53Q1DEXoHuzd5+RVpHQY1FfPz87Fx40asX78eUqkUTz/9NGQyGf744w906dLFVGVkLV++HC+88AJmzJgBAFi9ejV27tyJ7777Dm+99ZbJ319NfWPMrw6o7qr96rCO6B3i0Wrvb0wDQtsgMsAVF++U44mvj2DttN7ooWMGh+ySasR9fogdKR7m5YQpfYMwtb/5rqJorRqXegrjhG6WMZDYlukdXKNHj0ZKSgpGjRqFFStWYMSIERAIBFi9erUpy8eqq6vDmTNnsHDhQnYZn89HbGwsjh071uhrZDIZZDIZ+1gqVc05JJfLdXZyqp9T/1epZLA6JQN7rxZgYp8A/HvzLpIb7mYya3AIXhoczOlO0y+ejsSL/zuHG4WVmLb+BPa9+kiTwwq+/TcdtXIl3B2F8HdzwPy49lAo6qHrnMyD+9PYXMSqhkNJpcxk71EgrcXp26pxVrHhnmb7vk29L83JkM+kd3Dt3r0br7zyCmbPno0OHVq3KQAAxcXFUCgU8PHRnNDMx8cH169fb/Q1SUlJSExM1Fq+b98+ODo2Pwvnnn3JyKoE9ufycbFE9cex+K9rAAABj8GkMCW61qdhz540Qz+OxXkuBPiyUoCc6nq88t0BTGmvfVF0dT2w+YwAAA8Tg2sR7laDihsnseuGfu+RnJxs1DKr5ebxAAhwLT0Lu3ZlmuQ9UvJ4YBgBQpwZnDuyH+dM8i76M9W+NKfq6mq919U7uA4fPoz169cjKioKnTt3xtSpUzFx4sQWFbC1LFy4UOPmHVKpFIGBgYiPj9c53kwul2P77mRsyHbD9fxKAIBQwMPTUQHYeSkfIjs+vprUHT2NPCmeuYX2KMNTa0/iZBEf8x7vh97BmpeIrD50C3XKNHTycca8SQP0HqMll8uRnJyMuLg4rXF/xqC8mIffMi9BJGmDkSP7GH37DMNg9TfHAVRg8uBwjHyIsVsPy9T70pzULSJ96B1c/fv3R//+/bFixQps2bIF3333HebPnw+lUonk5GQEBgaadLobT09PCAQCFBQUaCwvKCiAr2/jU7OIxWKIxdpNHqFQqPNLZxgGv2Twcb24Es5iOzza0RMvDA5FzyB3LBnTDQyYJq+y57I+oV6Y2CcQP5/KxlvbrmDnK4PZucNO3LqLlQdVA0tfeDQMIpHhE8M1t99byttVVXsurZabZPvns8twLb8CIjs+nu4TZBGBYap9aU6GfB6Dzyo6OTlh5syZOHz4MC5duoQFCxZg2bJl8Pb2xpgxYwzdnN5EIhGioqLwzz//sMuUSiX++ecfDBgwwKjv9cf5PJwp5kPA52HTzL74ZkoUejZcoCqy41tlaKktTOgMfzcH3L5bjXe3XYKsXoHkqwV4/vvTqKtXIrazt15zirUm9UR3pdV1Jtn+TydUd8UZFeGn9xTGxLQeaiBKp06d8PHHH+POnTvYvHmzscrUpPnz52PdunXYtGkTrl27htmzZ6Oqqoo9y2gM9QolVjdcsvLykDBEBVvPFfX6cHUUYsXEHuDzgD/O56Lbkr144fvTqKitR+9gd6yc1MvihnzcCy65xrzpxlBRK8f2C6qziZP7mfaCcaI/o4ygEwgEGDt2LP766y9jbK5JEyZMwKefforFixejR48eOH/+PPbs2aPVYf8w7AR8bH6+L4b7K/HSo8a7/x+X9AnxQNK4CHi5iFXXXNrx8VJ0GDbN7MvOqmlJ3BtqQQolg3Ijj+U6fqsENXIF2nk6afX5EfOxrCkL9DB37lzMnTvXpO/h4STCyCClxdUsWtOEPkF4uncg0ouq4OEkMvrNDoxJZMdnZ4goqa6DuxHLej5bNQSiT4i7VU0Lw3V0zQJpEo/HQ3tvZ4sOLTUPZ1UZS6qM2891IVs15Yyxb6tGHg4FF7EK6nA1ZnAplQwuZJcBgM6rCUjro+AiVsHD0fjBdau4ChWyetgL+ejkQ3e2siQUXMQqmKLGdb6hthXh72q0+wES46Bvg1gFUwSXupnYPcDNaNskxkHBRayCKWtcPYLcjLZNYhwUXMQqqIPrrpGCq16hZGe1jfB3Nco2ifFQcBGrwI6eN1Jw3S6pRl29Eg5CAQLdm59JhLQuCi5iFYzdVLyRr6ptdfRxBt+GByJbKgouYhWMHVzqZmJHGgZhkSi4iFVQB1eNXIGauoe/RV5qQ42rky8FlyWi4CJWwVlsB1HDWKu7VbJm1m4ee7s5Ci6LRMFFrAKPx4O7k2oiuodtLtbKFcgsrgIAGjFvoSi4iNXwlajuKp1XXvtQ20kvqoSSAdwchfByafymIcS8KLiI1QhoGLaQXaL/TRcac+O+jnmaysYyUXARqxHg4QAAuFOq341tm5LacIMUaiZaLgouYjXUNa47pQ9X48ooVgVXmJfTQ5eJmAYFF7Eage7GqXFlNHTMt/NyfugyEdOg4CJW4/4+LoZp2U0zFEoGmXdVNbZQT6pxWSoKLmI1AhpqXFV1CpRVt+ymGbllNairV0Ik4KOtm4Mxi0eMiIKLWA17oYAdvpDdwn4udTMxuI2jTd8sxdJxJriWLl2KgQMHwtHREW5ubuYuDrFQD9vPlXm3oX+LmokWjTPBVVdXh6eeegqzZ882d1GIBXvYsVy3iii4uIAz91VMTEwEAGzcuNG8BSEWLfAhx3KxZxQpuCwaZ4KrJWQyGWSyexfcSqVSAIBcLodc3nTnrfo5XesQ/bXm/vSTqPq4su5Wtej9bhWpxnAFuost8vu35mPTkM9k1cGVlJTE1tTut2/fPjg6Nj+rZXJysimKZbNaY3/mlvEACHD9ThF27dpl0GvrlcCdUgEAHm6dP47iqyYpolFY47FZXa1/896swfXWW2/ho48+0rnOtWvXEB4e3qLtL1y4EPPnz2cfS6VSBAYGIj4+HhKJpMnXyeVyJCcnIy4uDkKhsEXvTe5pzf3Z9W41vrl2GGVyARIS4g261jCtsBLMiaNwEgsw4fE4i7xO0ZqPTXWLSB9mDa4FCxbg2Wef1blOaGhoi7cvFoshFmtf3S8UCvX60vVdj+inNfZnkKcLeDxAVq9EmUwJbxd7vV+bXabqVgj1dIZIJDJVEY3CGo9NQz6PWYPLy8sLXl5e5iwCsTIiOz78JPbILa/FndIag4JL3TEfQh3zFo8zwyGysrJw/vx5ZGVlQaFQ4Pz58zh//jwqKyvNXTRiYVo6JILOKHIHZzrnFy9ejE2bNrGPe/bsCQA4cOAAYmJizFQqYokCPBxwMtPwIRHq4KJrFC0fZ2pcGzduBMMwWv8otMiDWjq9DdW4uIMzwUWIvlpy2U+lrB6FFarOeerjsnwUXMTqtKSPS31zDE9nEVwdrOtsnTWi4CJWR33ZT05ZDZRK/eblukXNRE6h4CJWx1diDwGfB7mCQUGFfnf8yWi4uDqkDQUXF1BwEatjJ+CjrZtq/Ja+/Vzqeebb0TzznEDBRaxSgJth/Vw0FIJbKLiIVVL3c2WXNF/jYhjmvnm46AYZXEDBRaxSkIeqxnW7pKrZdfPKa1Ehq4cdn0ed8xxBwUWsUnBDJ7t6mIMuqQ13rg7xdILIjv4kuIC+JWKV1DUn9a3GdLnZEFx052ruoOAiVkk9+r2kqg7lNbpn1rxRoDqj2MGH+re4goKLWCVnsR17q7LmmovqGldHqnFxBgUXsVrt1P1cd5sOLqWSwc1CVY2rI9W4OIOCi1itEE/VmcUMHTWunLIaVNcpIBTw2A59YvkouIjVUvdz6Woq3ixUNRNDPZ0hFNCfA1fQN0WslrqpmKHjzCJ1zHMTBRexWvrUuG5QxzwnUXARq6We6aG8Ro7SqrpG17kXXFTj4hIKLmK1HEQC+LmqZom41UitS6lkkFaobipSjYtLKLiIVWvvrapJpRdq3w0qu7QatXIlRHZ8BHs0f2dzYjkouIhVUweXukl4P3XHfJiXM+zojCKncOLbyszMxHPPPYd27drBwcEBYWFhWLJkCerqGu+3IEStg7eqCXizkRoX9W9xFyfuq3j9+nUolUqsWbMG7du3x+XLl/HCCy+gqqoKn376qbmLRyyYephDWiPBRZf6cBcngmvEiBEYMWIE+zg0NBSpqalYtWoVBRfRqb2XKrhyympQKauHs/jeIc+O4fKmGhfXcCK4GlNeXg4PDw+d68hkMshkMvaxVCoFAMjlcsjlTc8YoH5O1zpEf+bcn84iHjydRSiurENqbhkiA1wBAAolg/QiVXCFtnHgzHdtzcemIZ+Jk8GVlpaGlStXNlvbSkpKQmJiotbyffv2wdGx+bNIycnJLS4j0Wau/enO56MYfPz+91Hc8VbdrqygBpDV20HIY3Dp+EFc4ZmlaC1mjcdmdbX+98HkMQyj343nTOCtt97CRx99pHOda9euITw8nH2ck5OD6OhoxMTE4Ntvv9X52sZqXIGBgSguLoZEImnydXK5HMnJyYiLi4NQSDcHfVjm3p+JO67hfyey8cKgEPx3eEcAwIajt/F/u1PRJ8QdPz3Xp9XL1FLm3pemJJVK4enpifLycp1/n4CZa1wLFizAs88+q3Od0NBQ9v9zc3MxZMgQDBw4EGvXrm12+2KxGGKxWGu5UCjU60vXdz2iH3Ptz06+qj+C9OJq9v33Xi0EAIyK8OPkd2yNx6Yhn8esweXl5QUvLy+91s3JycGQIUMQFRWFDRs2gM/nxEgOYgHUo+Kv5UnBMAzypbU4c7sUAJAQ4WfOopEW4kQfV05ODmJiYhAcHIxPP/0URUVF7HO+vr5mLBnhgsgAV4js+Mgrr8WNgkocTS8GAPQOdoePxN7MpSMtwYngSk5ORlpaGtLS0hAQEKDxnBm76AhHOIrs8EhYGxxILcLf1wrwz7UCAFTb4jJOtLeeffZZMAzT6D9C9BHbxQcA8N3hDJzNKoNIwMdjkRRcXMWJ4CLkYQ0LVwXX3YbpbSb3C6JmIodRcBGb4Otqj27+qrOL9kI+/jMkzMwlIg+DgovYjCd6qvpHZw0OhbcL1ba4jBOd84QYw4yBIRjU3pNmg7ACFFzEZvD5PHTypZkgrAE1FQkhnEPBRQjhHAouQgjnUHARQjiHgosQwjkUXIQQzqHgIoRwjk2N41JflK2ee74pcrkc1dXVkEqlVjdZmznQ/jQea96X6r9LfSZPsKngqqhQ3Y4qMDDQzCUhhDSloqICrq6uOtcx65zzrU2pVCI3NxcuLi7g8Zq+O4J6bvrs7Oxm574mzaP9aTzWvC8ZhkFFRQXatm3b7AzHNlXj4vP5WhMR6iKRSKzu4DAn2p/GY637srmalhp1zhNCOIeCixDCORRcjRCLxViyZEmjtzYjhqP9aTy0L1VsqnOeEGIdqMZFCOEcCi5CCOdQcBFCOIeCixDCORRcjfj6668REhICe3t79OvXDydPnjR3kSzee++9Bx6Pp/EvPDycfb62thZz5sxBmzZt4OzsjPHjx6OgoMCMJbYcKSkpGD16NNq2bQsej4c//vhD43mGYbB48WL4+fnBwcEBsbGxuHnzpsY6JSUlmDJlCiQSCdzc3PDcc8+hsrKyFT9F66LgesCWLVswf/58LFmyBGfPnkX37t0xfPhwFBYWmrtoFq9r167Iy8tj/x0+fJh9bt68edi+fTt+/fVXHDp0CLm5uRg3bpwZS2s5qqqq0L17d3z99deNPv/xxx/jyy+/xOrVq3HixAk4OTlh+PDhqK2tZdeZMmUKrly5guTkZOzYsQMpKSmYNWtWa32E1scQDX379mXmzJnDPlYoFEzbtm2ZpKQkM5bK8i1ZsoTp3r17o8+VlZUxQqGQ+fXXX9ll165dYwAwx44da6UScgMAZtu2bexjpVLJ+Pr6Mp988gm7rKysjBGLxczmzZsZhmGYq1evMgCYU6dOsevs3r2b4fF4TE5OTquVvTVRjes+dXV1OHPmDGJjY9llfD4fsbGxOHbsmBlLxg03b95E27ZtERoaiilTpiArKwsAcObMGcjlco39Gh4ejqCgINqvzcjIyEB+fr7GvnN1dUW/fv3YfXfs2DG4ubmhd+/e7DqxsbHg8/k4ceJEq5e5NVBw3ae4uBgKhQI+Pj4ay318fJCfn2+mUnFDv379sHHjRuzZswerVq1CRkYGBg8ejIqKCuTn50MkEsHNzU3jNbRfm6feP7qOyfz8fHh7e2s8b2dnBw8PD6vdvzY1OwQxnYSEBPb/IyMj0a9fPwQHB+OXX36Bg4ODGUtGrBHVuO7j6ekJgUCgdbaroKAAvr6+ZioVN7m5uaFjx45IS0uDr68v6urqUFZWprEO7dfmqfePrmPS19dX6+RRfX09SkpKrHb/UnDdRyQSISoqCv/88w+7TKlU4p9//sGAAQPMWDLuqaysRHp6Ovz8/BAVFQWhUKixX1NTU5GVlUX7tRnt2rWDr6+vxr6TSqU4ceIEu+8GDBiAsrIynDlzhl1n//79UCqV6NevX6uXuVWY++yApfn5558ZsVjMbNy4kbl69Soza9Ysxs3NjcnPzzd30SzaggULmIMHDzIZGRnMkSNHmNjYWMbT05MpLCxkGIZhXnrpJSYoKIjZv38/c/r0aWbAgAHMgAEDzFxqy1BRUcGcO3eOOXfuHAOAWb58OXPu3Dnm9u3bDMMwzLJlyxg3Nzfmzz//ZC5evMg8/vjjTLt27Ziamhp2GyNGjGB69uzJnDhxgjl8+DDToUMHZtKkSeb6SCZHwdWIlStXMkFBQYxIJGL69u3LHD9+3NxFsngTJkxg/Pz8GJFIxPj7+zMTJkxg0tLS2OdramqY//znP4y7uzvj6OjIPPHEE0xeXp4ZS2w5Dhw4wADQ+jd9+nSGYVRDIhYtWsT4+PgwYrGYGTZsGJOamqqxjbt37zKTJk1inJ2dGYlEwsyYMYOpqKgww6dpHTStDSGEc6iPixDCORRchBDOoeAihHAOBRchhHMouAghnEPBRQjhHAouQgjnUHARQjiHgotYtGeffRZjx441dzGIhaFpbYjZ8Hg8nc8vWbIEX3zxBejiDvIgCi5iNnl5eez/b9myBYsXL0Zqaiq7zNnZGc7OzuYoGrFw1FQkZuPr68v+c3V1BY/H01jm7Oys1VSMiYnByy+/jNdeew3u7u7w8fHBunXrUFVVhRkzZsDFxQXt27fH7t27Nd7r8uXLSEhIgLOzM3x8fDB16lQUFxe38icmxkLBRThn06ZN8PT0xMmTJ/Hyyy9j9uzZeOqppzBw4ECcPXsW8fHxmDp1KqqrqwEAZWVlGDp0KHr27InTp09jz549KCgowNNPP23mT0JazMyzUxDCMAzDbNiwgXF1ddVaPn36dObxxx9nH0dHRzODBg1iH9fX1zNOTk7M1KlT2WV5eXkadxD64IMPmPj4eI3tZmdnMwC0poch3EB9XIRzIiMj2f8XCARo06YNIiIi2GXqG0uopzO+cOECDhw40Gh/WXp6Ojp27GjiEhNjo+AinCMUCjUe83g8jWXqs5VKpRKAahrp0aNH46OPPtLalp+fnwlLSkyFgotYvV69euG3335DSEgI7OzokLcG1DlPrN6cOXNQUlKCSZMm4dSpU0hPT8fevXsxY8YMKBQKcxePtAAFF7F6bdu2xZEjR6BQKBAfH4+IiAi89tprcHNzA59PfwJcRHPOE0I4h35uCCGcQ8FFCOEcCi5CCOdQcBFCOIeCixDCORRchBDOoeAihHAOBRchhHMouAghnEPBRQjhHAouQgjn/D+4q7//C8csbAAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 300x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "input_data = np.load(\"datasets/val_data/1/118_104895.npy\")\n",
    "input_data_1d = np.flip(input_data.squeeze(),axis=0)\n",
    "\n",
    "# Plot the data\n",
    "plt.figure(figsize=(3, 3))\n",
    "plt.plot(input_data_1d)\n",
    "plt.xlabel('Time')\n",
    "plt.ylabel('Amplitude')\n",
    "plt.title('Normal Sinus Rhythm')\n",
    "plt.grid(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "87caba3b-08a8-4ff2-aecc-dc69367362b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Returned Normal Sinus Rhythm\n",
      "Inference time taken for single image on CPU: 0.0410 seconds\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\asrin\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.10_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python310\\site-packages\\torch\\_tensor.py:1394: UserWarning: Named tensors and all their associated APIs are an experimental feature and subject to change. Please do not use them for anything important until they are released as stable. (Triggered internally at ..\\c10/core/TensorImpl.h:1911.)\n",
      "  return super().rename(names)\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "model.eval() \n",
    "\n",
    "input_tensor = torch.from_numpy(input_data).float().unsqueeze(0)\n",
    "\n",
    "start_time = time.time()\n",
    "with torch.no_grad():\n",
    "    output = model(input_tensor)\n",
    "inference_time = time.time() - start_time\n",
    "\n",
    "if np.argmax(output[0]) == 1:\n",
    "    print(\"Returned Normal Sinus Rhythm\")\n",
    "else:\n",
    "    print(\"Wrong Prediction!!\")\n",
    "\n",
    "print(\"Inference time taken for single image on CPU: {:.4f} seconds\".format(inference_time))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "823bb2a8-2969-4b81-a7b1-1476cd9b08d5",
   "metadata": {},
   "source": [
    "## Validation Accuracy on CPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9c5ed524-4dd1-46fc-87df-dedc05b38322",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation Accuracy Score: 0.9407744874715261\n",
      "F1 Score: 0.9433688870707131\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAGUCAYAAAAiScWBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAABElUlEQVR4nO3dd1gU1/4G8HdBWZCygCLFgmBBsbcYgooYBOyFxKBGwIhGA2pEjJdrYk1CYq+xxnJtSbwqRjSKwYJGNIoitiAalCiCigKiNGF+f/hjryszytJ2hfeTZ55HZs7OfGc1+3LOmZmVCYIggIiIqIR0NF0AERG9XRgcRESkFgYHERGphcFBRERqYXAQEZFaGBxERKQWBgcREamFwUFERGphcBARkVoYHFShEhIS4O7uDoVCAZlMhrCwsHLd/61btyCTybBp06Zy3e/brEePHujRo4emy6AqjMFRDdy8eROffvop7O3toa+vDxMTEzg7O2Pp0qXIzs6u0GP7+vri0qVL+Oabb7BlyxZ06tSpQo9Xmfz8/CCTyWBiYiL6PiYkJEAmk0Emk2HBggVq7z85ORmzZs1CbGxsOVRLVH5qaLoAqlj79+/Hhx9+CLlcDh8fH7Rq1Qp5eXk4efIkpk6diitXrmDt2rUVcuzs7GxER0dj+vTpCAwMrJBj2NraIjs7GzVr1qyQ/b9JjRo18OzZM+zbtw9Dhw5V2bZt2zbo6+sjJyenVPtOTk7G7Nmz0ahRI7Rr167Er4uIiCjV8YhKisFRhSUmJsLb2xu2trY4cuQIrK2tldsCAgJw48YN7N+/v8KO/+DBAwCAqalphR1DJpNBX1+/wvb/JnK5HM7OztixY0ex4Ni+fTv69u2LXbt2VUotz549Q61ataCnp1cpx6NqTKAqa9y4cQIA4Y8//ihR+/z8fGHOnDmCvb29oKenJ9ja2gohISFCTk6OSjtbW1uhb9++wokTJ4TOnTsLcrlcsLOzEzZv3qxsM3PmTAGAymJraysIgiD4+voq//yyote8LCIiQnB2dhYUCoVgaGgoNGvWTAgJCVFuT0xMFAAIGzduVHldZGSk0LVrV6FWrVqCQqEQBgwYIFy9elX0eAkJCYKvr6+gUCgEExMTwc/PT3j69Okb3y9fX1/B0NBQ2LRpkyCXy4XHjx8rt/35558CAGHXrl0CAGH+/PnKbWlpacKUKVOEVq1aCYaGhoKxsbHg6ekpxMbGKtscPXq02Pv38nm6uLgILVu2FM6dOyd069ZNMDAwECZNmqTc5uLiotyXj4+PIJfLi52/u7u7YGpqKty9e/eN50r0Ms5xVGH79u2Dvb093nvvvRK19/f3x4wZM9ChQwcsXrwYLi4uCA0Nhbe3d7G2N27cwAcffIBevXph4cKFMDMzg5+fH65cuQIAGDJkCBYvXgwAGDZsGLZs2YIlS5aoVf+VK1fQr18/5ObmYs6cOVi4cCEGDBiAP/7447Wv+/333+Hh4YH79+9j1qxZCAoKwqlTp+Ds7Ixbt24Vaz906FA8efIEoaGhGDp0KDZt2oTZs2eXuM4hQ4ZAJpNh9+7dynXbt29H8+bN0aFDh2Lt//77b4SFhaFfv35YtGgRpk6dikuXLsHFxQXJyckAgBYtWmDOnDkAgLFjx2LLli3YsmULunfvrtxPWloaevfujXbt2mHJkiVwdXUVrW/p0qWwsLCAr68vCgoKAABr1qxBREQEli9fDhsbmxKfKxEA9jiqqoyMDAGAMHDgwBK1j42NFQAI/v7+KuuDg4MFAMKRI0eU62xtbQUAQlRUlHLd/fv3BblcLkyZMkW5rqg38PJv24JQ8h7H4sWLBQDCgwcPJOsW63G0a9dOqFu3rpCWlqZcd/HiRUFHR0fw8fEpdrxPPvlEZZ+DBw8WateuLXnMl8/D0NBQEARB+OCDD4T3339fEARBKCgoEKysrITZs2eLvgc5OTlCQUFBsfOQy+XCnDlzlOvOnj0r2psShBe9CgDC6tWrRbe93OMQBEE4dOiQAED4+uuvhb///lswMjISBg0a9MZzJBLDHkcVlZmZCQAwNjYuUfsDBw4AAIKCglTWT5kyBQCKzYU4OjqiW7duyp8tLCzg4OCAv//+u9Q1v6pobmTv3r0oLCws0Wvu3buH2NhY+Pn5wdzcXLm+TZs26NWrl/I8XzZu3DiVn7t164a0tDTle1gSw4cPx7Fjx5CSkoIjR44gJSUFw4cPF20rl8uho/Pif72CggKkpaXByMgIDg4OOH/+fImPKZfLMWrUqBK1dXd3x6effoo5c+ZgyJAh0NfXx5o1a0p8LKKXMTiqKBMTEwDAkydPStT+9u3b0NHRQZMmTVTWW1lZwdTUFLdv31ZZ37Bhw2L7MDMzw+PHj0tZcXEfffQRnJ2d4e/vD0tLS3h7e+OXX355bYgU1eng4FBsW4sWLfDw4UM8ffpUZf2r52JmZgYAap1Lnz59YGxsjJ9//hnbtm1D586di72XRQoLC7F48WI0bdoUcrkcderUgYWFBeLi4pCRkVHiY9arV0+tifAFCxbA3NwcsbGxWLZsGerWrVvi1xK9jMFRRZmYmMDGxgaXL19W63UymaxE7XR1dUXXCyX4JmKpYxSNvxcxMDBAVFQUfv/9d4wcORJxcXH46KOP0KtXr2Jty6Is51JELpdjyJAh2Lx5M/bs2SPZ2wCAb7/9FkFBQejevTu2bt2KQ4cO4fDhw2jZsmWJe1bAi/dHHRcuXMD9+/cBAJcuXVLrtUQvY3BUYf369cPNmzcRHR39xra2trYoLCxEQkKCyvrU1FSkp6fD1ta23OoyMzNDenp6sfWv9moAQEdHB++//z4WLVqEq1ev4ptvvsGRI0dw9OhR0X0X1RkfH19s219//YU6derA0NCwbCcgYfjw4bhw4QKePHkiekFBkf/+979wdXXFjz/+CG9vb7i7u8PNza3Ye1LSEC+Jp0+fYtSoUXB0dMTYsWMxb948nD17ttz2T9ULg6MK++KLL2BoaAh/f3+kpqYW237z5k0sXboUwIuhFgDFrnxatGgRAKBv377lVlfjxo2RkZGBuLg45bp79+5hz549Ku0ePXpU7LVFN8Ll5uaK7tva2hrt2rXD5s2bVT6IL1++jIiICOV5VgRXV1fMnTsXK1asgJWVlWQ7XV3dYr2ZnTt34u7duyrrigJOLGTVNW3aNCQlJWHz5s1YtGgRGjVqBF9fX8n3keh1eANgFda4cWNs374dH330EVq0aKFy5/ipU6ewc+dO+Pn5AQDatm0LX19frF27Funp6XBxccGff/6JzZs3Y9CgQZKXepaGt7c3pk2bhsGDB2PixIl49uwZVq1ahWbNmqlMDs+ZMwdRUVHo27cvbG1tcf/+ffzwww+oX78+unbtKrn/+fPno3fv3nBycsLo0aORnZ2N5cuXQ6FQYNasWeV2Hq/S0dHBl19++cZ2/fr1w5w5czBq1Ci89957uHTpErZt2wZ7e3uVdo0bN4apqSlWr14NY2NjGBoaokuXLrCzs1OrriNHjuCHH37AzJkzlZcHb9y4ET169MBXX32FefPmqbU/Il6OWw1cv35dGDNmjNCoUSNBT09PMDY2FpydnYXly5er3NyXn58vzJ49W7CzsxNq1qwpNGjQ4LU3AL7q1ctApS7HFYQXN/a1atVK0NPTExwcHIStW7cWuxw3MjJSGDhwoGBjYyPo6ekJNjY2wrBhw4Tr168XO8arl6z+/vvvgrOzs2BgYCCYmJgI/fv3l7wB8NXLfTdu3CgAEBITEyXfU0FQvRxXitTluFOmTBGsra0FAwMDwdnZWYiOjha9jHbv3r2Co6OjUKNGDdEbAMW8vJ/MzEzB1tZW6NChg5Cfn6/SbvLkyYKOjo4QHR392nMgepVMENSYASQiomqPcxxERKQWBgcREamFwUFERGphcBARkVoYHEREpBYGBxERqYXBQUREaqn2d44btK+Y78Im7ZQUtUTTJVAlsjAu20dcWT4fsi+sKNOxtVm1Dw4iIkkyDsqIYXAQEUkpxycUVyUMDiIiKexxiGJwEBFJYY9DFOOUiIjUwh4HEZEUDlWJYnAQEUnhUJUoBgcRkRT2OEQxOIiIpLDHIYrBQUQkhT0OUXxXiIhILexxEBFJ4VCVKAYHEZEUDlWJYnAQEUlhj0MUg4OISAp7HKIYHEREUhgcoviuEBGRWtjjICKSosM5DjEMDiIiKRyqEsXgICKSwquqRDE4iIiksMchisFBRCSFPQ5RjFMiIlILexxERFI4VCWKwUFEJIVDVaIYHEREUtjjEMXgICKSwh6HKAYHEZEU9jhE8V0hIiK1sMdBRCSFQ1WiGBxERFI4VCWKwUFEJIXBIYrBQUQkhUNVohgcRERS2OMQxXeFiIjUwh4HEZEUDlWJYnAQEUnhUJUoBgcRkRT2OEQxOIiIJMgYHKLYDyMikiCTyUq9qCM0NBSdO3eGsbEx6tati0GDBiE+Pl6lTU5ODgICAlC7dm0YGRnBy8sLqampKm2SkpLQt29f1KpVC3Xr1sXUqVPx/PlzlTbHjh1Dhw4dIJfL0aRJE2zatEnt94XBQUSkYcePH0dAQABOnz6Nw4cPIz8/H+7u7nj69KmyzeTJk7Fv3z7s3LkTx48fR3JyMoYMGaLcXlBQgL59+yIvLw+nTp3C5s2bsWnTJsyYMUPZJjExEX379oWrqytiY2Px+eefw9/fH4cOHVKrXpkgCELZT/vtZdA+UNMlUCVKilqi6RKoElkYl2003vDDjaV+7dOdo0r92gcPHqBu3bo4fvw4unfvjoyMDFhYWGD79u344IMPAAB//fUXWrRogejoaLz77rv47bff0K9fPyQnJ8PS0hIAsHr1akybNg0PHjyAnp4epk2bhv379+Py5cvKY3l7eyM9PR0HDx4scX3scRARSSjLUFVubi4yMzNVltzc3BIdNyMjAwBgbm4OAIiJiUF+fj7c3NyUbZo3b46GDRsiOjoaABAdHY3WrVsrQwMAPDw8kJmZiStXrijbvLyPojZF+ygpBgcRkYSyBEdoaCgUCoXKEhoa+sZjFhYW4vPPP4ezszNatWoFAEhJSYGenh5MTU1V2lpaWiIlJUXZ5uXQKNpetO11bTIzM5GdnV3i94VXVRERSSjLVVUhISEICgpSWSeXy9/4uoCAAFy+fBknT54s9bErGoODiEhCWYJDLpeXKCheFhgYiPDwcERFRaF+/frK9VZWVsjLy0N6erpKryM1NRVWVlbKNn/++afK/oquunq5zatXYqWmpsLExAQGBgYlrpNDVUREGiYIAgIDA7Fnzx4cOXIEdnZ2Kts7duyImjVrIjIyUrkuPj4eSUlJcHJyAgA4OTnh0qVLuH//vrLN4cOHYWJiAkdHR2Wbl/dR1KZoHyXFHgcRkZRKuv8vICAA27dvx969e2FsbKyck1AoFDAwMIBCocDo0aMRFBQEc3NzmJiYYMKECXBycsK7774LAHB3d4ejoyNGjhyJefPmISUlBV9++SUCAgKUPZ9x48ZhxYoV+OKLL/DJJ5/gyJEj+OWXX7B//3616mVwEBFJqKw7x1etWgUA6NGjh8r6jRs3ws/PDwCwePFi6OjowMvLC7m5ufDw8MAPP/ygbKurq4vw8HCMHz8eTk5OMDQ0hK+vL+bMmaNsY2dnh/3792Py5MlYunQp6tevj/Xr18PDw0OtenkfB+/jqFZ4H0f1Utb7OMw+3lbq1z7eOqJMx9Zm7HEQEUngs6rEMTiIiCQwOMTxqioiIlILexxERFLY4RDF4CAiksChKnEMDiIiCQwOcQwOIiIJDA5xDA4iIinMDVG8qoqIiNTCHgcRkQQOVYljcBARSWBwiGNwEBFJYHCIY3AQEUlgcIjj5DgREamFPQ4iIinscIhicBARSeBQlTgGBxGRBAaHuLcyOHbt2gWZTIYhQ4ZouhQiqsIYHOLeusnxixcvwsfHBykpKajm33pLRBVNVoalCnurehxXrlzBr7/+ismTJ+Ozzz7TdDlERNXSWxMcN27cwNSpU3H27FmMGjUKAFBYWAgdnbeu01Qugj9xx6CebdGskSWyc/Nx5uLfmL50LxJu31e2WT7dGz27OMDaQoGs7FycvpiIL5fuxfVbqQAAc4UhNn7ji9bN6sFcUQsPHmUh/FgcZqzYhydPcwAAVnVM8F3QEHRwbIjGDerghx3HMXXBLo2cM6mKPX8O27dsQPy1q0h7+ADfLliG7j3eV2lzK/EmVi1bhNjz51BQUIBG9vb4et4SWFnZAADu3knCiiULcCn2PPLy89DFqSsmT/03zGvX0cQpaR0OVYl7Kz51Dxw4gGPHjqFnz56wsbHBr7/+isTEROjo6FTb4apuHZpg9c9RcPFZgH7jV6BGDV2ErwpELX09ZZsL1/7B2Flb0W7I1xjw2UrIZDKE/xAAHZ0X/zMUFhYi/HgcPvh8DdoMmoMxM7fAtYsDlk/3Vu5Dr2YNPHz8BN+tP4i463cr/TxJWnZ2Npo0dUDQtC9Ft9+9k4TP/EfCtpEdlq/ZhM0/7Ybf6HGQ68n///XPMDlgLGQyGZau3oBVP27F8/x8TJscgMLCwso8Fa0lk8lKvVRlWt/juHjxIgYOHIjt27fD398flpaWWLFiBUJCQhAaGgo7OzsIglDl/6JeNTDwB5Wfx87cin+OfIf2jg3wx/mbAIANu/9Qbk+69wizV+7D2V/+DVub2ki88xDpT7KxbufJl9o8xtqdJzDZx03ldcHzX/QwfAc6VeQpkZqcnLvBybmb5Pa1K5fB6b3u+GxSsHJdvfoNlX++dPECUu7dxcZt/4WhkREAYPrsb9Hb1QkxZ8+gcxf+fVe3z5WS0uoeR0xMDG7cuIHg4GB8+OGHAICRI0dizJgxSE5Oxr///W/cunULMpms2vY8ipgY6QMAHmc8E91eS18PPgPeReKdh7iT8li0jbWFAgN7tsOJmIQKq5MqR2FhIU79cRwNbG0RFDgG/Xp1wxhfb0Qdi1S2ycvLg0wmQ029//VS9fTk0NHRQVzseU2UrXXY4xCntcGRm5uLESNG4MMPP8T169dVgsHf3x8+Pj5ITU1FYGAgbt++XeX/ol5HJpNhfvAHOHXhJq7evKeybeyH3fDgj4VIi14Ed2dH9B2/AvnPC1TabA71Q9qpRfg74htkPs3B+DnbK7N8qgCPH6Uh+9kzbN30I7o4dcXiFWvR3fV9TJ86CRdizgIAWrZuC319A6xavhA5OdnIzn6GlUvmo6CgAGkPH2j4DLQEr6oSpbXBIZfLERERAWdnZ5w7dw7Xrl0DAGWA+Pv7Y8iQIRAEATVqlGzELTc3F5mZmSqLUFjw5hdquSUhQ9GyiTV8/rWx2LaffjuLd4d9B7fRi5GQ9ABbv/8Ecj3V9+uLBbvgNPx7fPD5GtjXr4Pvp/D+mLdd0f8nXV1c8dEIXzR1aIGRfmPwXlcXhO36GQBgZmaOud8vwh9Rx9GrW2d49ngXWU+eoFlzx2p70QmVjNbNccTHx+PJkyfIzs5Gt27dsGPHDvTu3Ru+vr7YvXs3GjRooJzTCAwMxMcffwxTU9MS7Ts0NBSzZ89WWadr2Rk1rd+pgDOpHIunfYg+3VrBbfQS3L2fXmx7ZlYOMrNycDPpAf6Mu4V7UfMwsGdb/HIwRtkmNe0JUtOe4PqtVDzOeIrIjUH4bt1BpDzMrMQzofKkMDWFrm4NNLJrrLLe1s4el14ahnrnXWf8svcg0tMfQ1dXF8bGJhjg0R029XpXdslaqTqPZLyOVv1aERYWBk9PT/j4+MDDwwOjRo2Crq4uDhw4gOzsbHh5eeHOnTsqcxolDQ0ACAkJQUZGhspSw7JjBZ1NxVs87UMM6NkWnp8uw+3ktDe2l8lkkEEGvZrSvy/I/v+Kq9e1Ie1Xs6YeWrRshX9u31JZ/0/SbVha2xRrb2pqBmNjE8ScPY3Hjx6ha3fXSqpUu3GOQ5zWfDpERERg1KhR+P777+Hn54fIyEj07dsX2dnZWLBgAX777TcMGDAArq6uOHbsGOrVq6f2MeRyOeRyuco6mY5ueZ1CpVoSMhQf9e6EDyevRdbTHFjWNgYAZGTlICc3H43q1cYHHh0RGX0NDx9noZ6lKaaMckd2bj4OnbwCAPDo6oi65iaIuXIbWc9y4djYGt9OHoRTF24i6d4j5bHaNHvxXhvWkqOOmRHaNKuHvOcF+OvvlMo/cVJ69uwp7v6TpPz53t07SIi/BmOFAlZWNhg2chRmhkxB2w4d0aHTOzhz6iROnTiGZWv+N6S5/9c9sLWzh5mZGS7HXcTShaEYOtwHDRvZaeCMtE8V//wvNZmgBZcjZWZmYurUqahXrx5mzJiBxMRE9OrVC+3bt8fhw4fh4uKCZcuWAQCGDRuGbdu2wc6ufP5hG7QPLJf9VLbsCytE14+ZsQVb952BtYUCP8wYjvYtGsDMpBbupz3ByfM38O3a35Q3CXbv1BSzA/ujub0V5DVr4E5qOvYeicWCDYeRkZX92mPdTk5D874zK+bkKlBS1BJNl1Buzp/7ExPHjSq2vne/gZg+61sAQPje3di6aR3u309FQ9tGGD02EN169FS2XbV8EX4LD0NmRgasbOph0JCh+GiEb5X5jdnCuGy/GzederDUr02Y71mmY2szrQiOvLw87N27Fx06dICZmRnc3NzQoUMHrF+/Hjt27MCIESPg6emJdevWwdLSssST4SXxtgYHlU5VCg56s7IGR7MvSh8c1+dV3eDQiqEqPT099O/fH/r6+ti6dSv09fUxa9YsAC/GGF1cXHD16lUUFBSUa2gQEZH6tGZyXF//xQ1siYmJePLkCQwNDQG8uHPcy8sLCQkJaNiw4et2QURUrjg5Lk7rfn3v168fvvnmG2UP5OzZszhx4gRq1qyp6dKIqJqp4p//paY1PY4i7du3x9GjR2FnZ4fmzZvj1KlTaNOmjabLIqJqSEdHVuqlKtO6HgcAODk5oUuXLtWiy0dE2osfP+K0MjgA8JEHRKRx/MVVHD+diYhILVrb4yAi0jR2OMQxOIiIJHCoShyDg4hIAoNDHIODiEgCc0Mcg4OISAJ7HOJ4VRUREamFPQ4iIgnscIhjcBARSeBQlTgGBxGRBOaGOAYHEZEE9jjEMTiIiCQwN8TxqioiIlILexxERBI4VCWOwUFEJIG5IY7BQUQkgT0OcQwOIiIJzA1xDA4iIgnscYjjVVVERFogKioK/fv3h42NDWQyGcLCwlS2+/n5QSaTqSyenp4qbR49eoQRI0bAxMQEpqamGD16NLKyslTaxMXFoVu3btDX10eDBg0wb948tWtlcBARSZDJSr+o6+nTp2jbti1Wrlwp2cbT0xP37t1TLjt27FDZPmLECFy5cgWHDx9GeHg4oqKiMHbsWOX2zMxMuLu7w9bWFjExMZg/fz5mzZqFtWvXqlUrh6qIiCRU5lBV79690bt379e2kcvlsLKyEt127do1HDx4EGfPnkWnTp0AAMuXL0efPn2wYMEC2NjYYNu2bcjLy8OGDRugp6eHli1bIjY2FosWLVIJmDdhj4OISMKrQ0PqLLm5ucjMzFRZcnNzy1TPsWPHULduXTg4OGD8+PFIS0tTbouOjoapqakyNADAzc0NOjo6OHPmjLJN9+7doaenp2zj4eGB+Ph4PH78uMR1MDiIiCSUZagqNDQUCoVCZQkNDS11LZ6envjPf/6DyMhIfP/99zh+/Dh69+6NgoICAEBKSgrq1q2r8poaNWrA3NwcKSkpyjaWlpYqbYp+LmpTEhyqIiKSUJahqpCQEAQFBamsk8vlpd6ft7e38s+tW7dGmzZt0LhxYxw7dgzvv/9+qfdbGuxxEBFVALlcDhMTE5WlLMHxKnt7e9SpUwc3btwAAFhZWeH+/fsqbZ4/f45Hjx4p50WsrKyQmpqq0qboZ6m5EzEMDiIiCZV5VZW67ty5g7S0NFhbWwMAnJyckJ6ejpiYGGWbI0eOoLCwEF26dFG2iYqKQn5+vrLN4cOH4eDgADMzsxIfm8FBRCShLJPj6srKykJsbCxiY2MBAImJiYiNjUVSUhKysrIwdepUnD59Grdu3UJkZCQGDhyIJk2awMPDAwDQokULeHp6YsyYMfjzzz/xxx9/IDAwEN7e3rCxsQEADB8+HHp6ehg9ejSuXLmCn3/+GUuXLi02pPYmnOMgIpJQmTeOnzt3Dq6ursqfiz7MfX19sWrVKsTFxWHz5s1IT0+HjY0N3N3dMXfuXJXhr23btiEwMBDvv/8+dHR04OXlhWXLlim3KxQKREREICAgAB07dkSdOnUwY8YMtS7FBQCZIAhCGc/3rWbQPlDTJVAlSopaoukSqBJZGJftd+NeK06X+rWHA98t07G1mdpDVZs3b8b+/fuVP3/xxRcwNTXFe++9h9u3b5drcUREmqTNcxyapHZwfPvttzAwMADw4maSlStXYt68eahTpw4mT55c7gUSEZF2Ubsf988//6BJkyYAgLCwMHh5eWHs2LFwdnZGjx49yrs+IiKN4dNxxand4zAyMlLe5h4REYFevXoBAPT19ZGdnV2+1RERaZCOrPRLVaZ2j6NXr17w9/dH+/btcf36dfTp0wcAcOXKFTRq1Ki86yMi0hj2OMSp3eNYuXIlnJyc8ODBA+zatQu1a9cGAMTExGDYsGHlXiARkaZwclyc2j0OU1NTrFixotj62bNnl0tBRETaQoYqngClVKLgiIuLK/EO27RpU+piiIhI+5UoONq1aweZTAapewWLtslkMuUjfomI3nZVfZK7tEoUHImJiRVdBxGR1uHkuLgSBYetrW1F10FEpHWYG+JK9XTcLVu2wNnZGTY2NsrHjCxZsgR79+4t1+KIiDRJRyYr9VKVqR0cq1atQlBQEPr06YP09HTlnIapqSmWLFlS3vUREWkML8cVp3ZwLF++HOvWrcP06dOhq6urXN+pUydcunSpXIsjIiLto/Z9HImJiWjfvn2x9XK5HE+fPi2XooiItAEnx8Wp3eOws7NTfkPVyw4ePIgWLVqUR01ERFqBQ1Xi1O5xBAUFISAgADk5ORAEAX/++Sd27NiB0NBQrF+/viJqJCLSiKo+yV1aageHv78/DAwM8OWXX+LZs2cYPnw4bGxssHTpUnh7e1dEjUREGsHYEFeq71UcMWIERowYgWfPniErKwt169Yt77qIiDSOcxziSv2FvPfv30d8fDyAF2+uhYVFuRVFRETaS+3J8SdPnmDkyJGwsbGBi4sLXFxcYGNjg48//hgZGRkVUSMRkUbwi5zEqR0c/v7+OHPmDPbv34/09HSkp6cjPDwc586dw6effloRNRIRaYRMJiv1UpWpPVQVHh6OQ4cOoWvXrsp1Hh4eWLduHTw9Pcu1OCIiTarin/+lpnZw1K5dGwqFoth6hUIBMzOzcimKiEgbVPWeQ2mpPVT15ZdfIigoCCkpKcp1KSkpmDp1Kr766qtyLY6IiLRPiXoc7du3V0nehIQENGzYEA0bNgQAJCUlQS6X48GDB5znIKIqo6pPcpdWiYJj0KBBFVwGEZH24VCVuBIFx8yZMyu6DiIircPYEFfqGwCJiKo6PqtKnNrBUVBQgMWLF+OXX35BUlIS8vLyVLY/evSo3IojItIk5oY4ta+qmj17NhYtWoSPPvoIGRkZCAoKwpAhQ6Cjo4NZs2ZVQIlERKRN1A6Obdu2Yd26dZgyZQpq1KiBYcOGYf369ZgxYwZOnz5dETUSEWkE7xwXp3ZwpKSkoHXr1gAAIyMj5fOp+vXrh/3795dvdUREGsQvchKndnDUr18f9+7dAwA0btwYERERAICzZ89CLpeXb3VERBqkI5OVeqnK1A6OwYMHIzIyEgAwYcIEfPXVV2jatCl8fHzwySeflHuBRESawh6HOLWvqvruu++Uf/7oo49ga2uLU6dOoWnTpujfv3+5FkdEpElVfa6itNTucbzq3XffRVBQELp06YJvv/22PGoiIiItJhMEQSiPHV28eBEdOnRAQUFBeeyu0uQ813QFVJnikvhlY9XJO/bFn+Stjgl7rpX6tcsHtyjTsbUZ7xwnIpLAoSpxDA4iIgl8Oq44BgcRkQQGh7gSB0dQUNBrtz948KDMxRARaRMOVYkrcXBcuHDhjW26d+9epmKIiEj7lTg4jh49WpF1EBFpHQ5VieMcBxGRBI5UiWNwEBFJqOrPnCotBgcRkYQyP1qjimJwEBFJYIdDHAOViIjUUqrgOHHiBD7++GM4OTnh7t27AIAtW7bg5MmT5VocEZEm8fs4xKkdHLt27YKHhwcMDAxw4cIF5ObmAgAyMjL4dFwiqlL4fRzi1A6Or7/+GqtXr8a6detQs2ZN5XpnZ2ecP3++XIsjItIkHVnpl6pM7cnx+Ph40TvEFQoF0tPTy6MmIiKtUNWHnEpL7R6HlZUVbty4UWz9yZMnYW9vXy5FERFpAw5ViVM7OMaMGYNJkybhzJkzkMlkSE5OxrZt2xAcHIzx48dXRI1ERKRF1B6q+te//oXCwkK8//77ePbsGbp37w65XI7g4GBMmDChImokItKIqj5XUVpq9zhkMhmmT5+OR48e4fLlyzh9+jQePHiAuXPnVkR9REQaIyvDf+qKiopC//79YWNjA5lMhrCwMJXtgiBgxowZsLa2hoGBAdzc3JCQkKDS5tGjRxgxYgRMTExgamqK0aNHIysrS6VNXFwcunXrBn19fTRo0ADz5s1Tu9ZS3wCop6cHR0dHvPPOOzAyMirtboiItFZlXlX19OlTtG3bFitXrhTdPm/ePCxbtgyrV6/GmTNnYGhoCA8PD+Tk5CjbjBgxAleuXMHhw4cRHh6OqKgojB07Vrk9MzMT7u7usLW1RUxMDObPn49Zs2Zh7dq1atUqEwRBUOcFrq6ur/1ykyNHjqhVgKblPNd0BVSZ4pIyNF0CVaJ37BVlev28ozdL/dpJ79VX3udWRC6XQy6Xv/G1MpkMe/bswaBBgwC86G3Y2NhgypQpCA4OBvDi3jlLS0ts2rQJ3t7euHbtGhwdHXH27Fl06tQJAHDw4EH06dMHd+7cgY2NDVatWoXp06cjJSUFenp6AF5MP4SFheGvv/4q8bmp3eNo164d2rZtq1wcHR2Rl5eH8+fPo3Xr1urujohIa8lkslIvoaGhUCgUKktoaGip6khMTERKSgrc3NyU6xQKBbp06YLo6GgAQHR0NExNTZWhAQBubm7Q0dHBmTNnlG26d++uDA0A8PDwQHx8PB4/flzietSeHF+8eLHo+lmzZhUbSyMiqq5CQkKKfeV2SXobYlJSUgAAlpaWKustLS2V21JSUlC3bl2V7TVq1IC5ublKGzs7u2L7KNpmZmZWonrK7SGHH3/8MTZs2FBeuyMi0riyzHHI5XKYmJioLKUNDm1TbsERHR0NfX398todEZHGacsNgFZWVgCA1NRUlfWpqanKbVZWVrh//77K9ufPn+PRo0cqbcT28fIxSkLtoaohQ4ao/CwIAu7du4dz587hq6++Und3RERaS1seOWJnZwcrKytERkaiXbt2AF5cIXXmzBnljddOTk5IT09HTEwMOnbsCODFxUqFhYXo0qWLss306dORn5+vfNbg4cOH4eDgUOJhKqAUwaFQqF6loKOjAwcHB8yZMwfu7u7q7o6ISGtV5g2AWVlZKo9zSkxMRGxsLMzNzdGwYUN8/vnn+Prrr9G0aVPY2dnhq6++go2NjfLKqxYtWsDT0xNjxozB6tWrkZ+fj8DAQHh7e8PGxgYAMHz4cMyePRujR4/GtGnTcPnyZSxdulRy7lqKWsFRUFCAUaNGoXXr1mqlExHR26gyOxznzp2Dq6ur8ueiiXVfX19s2rQJX3zxBZ4+fYqxY8ciPT0dXbt2xcGDB1WmCLZt24bAwEC8//770NHRgZeXF5YtW6bcrlAoEBERgYCAAHTs2BF16tTBjBkzVO71KAm17+PQ19fHtWvXis3Mv614H0f1wvs4qpey3sex/I/EUr92gnPV+IwUo/bkeKtWrfD3339XRC1ERFpFB7JSL1VZqb7IKTg4GOHh4bh37x4yMzNVFiKiqkJbrqrSNiWe45gzZw6mTJmCPn36AAAGDBig8ugRQRAgk8lQUFBQ/lUSEWkAn44rrsTBMXv2bIwbNw5Hjx6tyHqIiLSGtlyOq21KHBxFc+guLi4VVgwRkTZhbohTa47jdU/FJSKi6kGt+ziaNWv2xvB49OhRmQoiItIWHKoSp1ZwzJ49u9id40REVRVzQ5xaweHt7V3ssb1ERFVVuT0FtoopcXBwfoOIqht+7olT+6oqIqLqgrEhrsTBUVhYWJF1EBHRW0Ltx6oTEVUXvKpKHIODiEgCY0Mcg4OISAI7HOIYHEREEnhVlTgGBxGRBN7HIY7vCxERqYU9DiIiCRyqEsfgICKSwNgQx+AgIpLAHoc4BgcRkQROAotjcBARSWCPQxwDlYiI1MIeBxGRBPY3xDE4iIgkcKRKHIODiEiCDvscohgcREQS2OMQx+AgIpIgY49DFK+qIiIitbDHQUQkgUNV4hgcREQSODkujsFBRCSBPQ5xDA4iIgkMDnGcHCciIrWwx0FEJIGX44pjcBARSdBhboh664NDEAQ++piIKgR7HOLe2jmOhIQEAHxePhFVHJms9EtV9lYGx969ezFo0CCcPXtW06UQURUmK8N/VdlbFxzJyclYt24dJk6ciM6dO2u6HCKiauetmuOIiorCf/7zH+Tn58Pd3R0A5zheJ+bcWWza8COuXb2MBw8eYPGylej5vpty+6qVy3Hwt/1ISUlBzZo14ejYEoGTJqNNm7YarJpKYvfWtdizbb3KOuv6tpi3bqfy54Rrcdi5eRVu/nUFOjq6sG3cFF98vQx6cn0AQNaTDPznhwW4cOYkdHRk6OTsipHjpkDfoFalnos24+S4uLcqOO7fv4+ffvoJ+fn5uH79Ouzs7Bgar5Gd/QwODg4YNMQLQZMCi223tW2EkOkzUL9+A+Tk5mDrfzZh/JhPsO+3wzA3N9dAxaSOerb2+Ne3K5Q/6+r+73/nhGtxmP/lJPT/yA8+44Ohq1sDSX9fh0z2v0GGVfNmIP3RQ0z7djkKnj/HusVzsWHZt/hs2teVeh7arKoPOZXWWxEct2/fhrW1NT744AOYmprC19cXGzduRL169dCqVStNl6e1unZzQdduLpLb+/Trr/Jz8Bch2LPrv0i4Ho8u7zpVdHlURrq6ujA1ryO6bduaJXAf+BH6D/VVrrOub6v8892kRMSdi8bspZtg38wRAOAzPhgLZnyOYf6TYFbbomKLf0vw91JxWj/H8euvv2LYsGFYt24dCgoK4ObmhtWrV+PUqVNYtmwZrl69qukSq4T8vDzs2vkzjI2N0czBQdPlUAmk3P0HE0b0QdCoQfjh+6/w8H4KACAj/RFuxl+GicIMs4NGI2CYJ76e+iniL8cqX3vj2iXUMjJWhgYAtGzfGTKZDm7+dbmyT0VrycqwVGVa3eMICwuDt7c35s+fD3d3d+jq6gIA+vfvj+fPn2PixInQ1dXF+PHj0aZNGw1X+3Y6fuwopgUHIScnG3UsLLB63QaYmXGYSts1dmiFsVNmwLq+LdIfPcSebevx9dSxCF21Aw/u3QUA7Nm2DsP8J6GhfTOcjNyP70ICELp6B6zqNUTG4zSYKMxU9qmrWwOGxiZIf5ymiVPSSjrscojS2uBITk7G3LlzsXDhQgQEBCA/Px9ZWVn4/fff0blzZwwePBi6uroYNmwY5HI55s2bBz09vdfuMzc3F7m5uSrrBF055HJ5RZ6KVuv8Thf8sisM6emPseu/v2DqlM+xdcdO1K5dW9Ol0Wu07fye8s8N7ZqisUMrTPYdgDMnfodNAzsAgGufIeju/mI4slETB1yNPYfjEfvw0agAjdRMVYfWDlU9f/4cjx8/RqNGjVBYWIjvvvsOHh4eGDVqFNq2bYuLFy9iwIAB2LlzJwICAt4YGgAQGhoKhUKhssz/PrQSzkZ71apVCw1tbdGmbTvMnvstaujWQNju/2q6LFKToZExrOo1RGryHZiavwj9eg3tVNrYNGyEtP8fzlKY1UZmxmOV7QUFz/H0SSZMzfhLQxEOVYnTuuBIS0vD06dPoVAo4OLigkmTJqFu3bqIiYnB4MGDcevWLdSvXx9r1qwBAPTp0wdNmzYt0b5DQkKQkZGhskydFlKRp/PWKRQKkZeXp+kySE052c9w/95dmJrXgYWlDcxqW+DendsqbVLuJKGOpTUAoEmL1niW9QSJCdeU26/GnoMgFKJxc15wosTkEKVVQ1VhYWFYsGABHj58CB8fH7i4uGDQoEFITk7G0KFDlcMn9vb2sLOze8PeipPLiw9L5Twvl9K10rOnT5GUlKT8+e6dO/jr2rUXvS1TU6xfuxo9XHuijoUF0h8/xk87tuF+aip6eXhqsGoqie3rlqJ9l26oY2mFx2kPsXvrWujo6MDJxR0ymQx9vD7G7q1r0dCuKWwbN8OJ3/cj+c5tTJj+HYAXvZE2nZzw49JvMWrCv1Dw/Dn+s2o+3nXpxSuqXsLLccXJBEEQNF0EAJw/fx49e/bElClT8ODBA0RHR8PW1hZTp05Fly5dAAAPHz7EsmXLsHr1apw4cQIO5XD1T1UOjrN/noH/KJ9i6wcMHIwvZ87Gv76YgktxF5H++DFMTU3RslVrjPl0PFq1rroXGsQlZWi6hHKxInQ64i9fQFZmBowVZmjWsi0+9B0PS5v6yjb7ftmM3/ftRNaTTDS0bwrvTybAoVU75fYXNwDOx4UzJyGTydDZuSdGjq9aNwC+Y68o0+v//Lv0/17KemxtphXBcfPmTezYsQMymQzTp08HAISHh2PRokVQKBQIDg6GTCbDmjVrEBkZiX379qF9+/blcuyqHBxUXFUJDiqZsn54ny1DcHSuwsGh8TmOzMxMeHt7Y/ny5cjKylKu79evH6ZMmYL09HSsWLECx48fh7u7O44fP15uoUFEROrTeHCYmJhg7dq1MDU1xYkTJ3DlyhXltr59+yI4OBg3btxAfHw8BgwYgMaNG2uwWiKqVjg5LkorJsfbt2+PnTt3wtfXF8uWLcPEiRPRsmVLAC/CQ1dXFy1atICxsbGGKyWi6oST4+I03uMo0qZNG2zYsAHnzp3DkiVLVB4l4unpCVtb29e8moio/FXWFznNmjULMplMZWnevLlye05ODgICAlC7dm0YGRnBy8sLqampKvtISkpC3759UatWLdStWxdTp07F8+cVM4mrNcEBvOh5rF+/HnFxcZg7dy7++usvTZdERNVYZY5UtWzZEvfu3VMuJ0+eVG6bPHky9u3bh507d+L48eNITk7GkCFDlNsLCgrQt29f5OXl4dSpU9i8eTM2bdqEGTNmlOq830SrggN4ER4rVqzAvXv3oFBU3asSiOgtUInJUaNGDVhZWSmXOnVePPk4IyMDP/74IxYtWoSePXuiY8eO2LhxI06dOoXTp08DACIiInD16lVs3boV7dq1Q+/evTF37lysXLmyQm7o1brgAIDOnTvj4MGDsLa21nQpRESlkpubi8zMTJXl1WflvSwhIQE2Njawt7fHiBEjlDfvxsTEID8/H25u//sStubNm6Nhw4aIjo4GAERHR6N169awtLRUtvHw8EBmZqbKBUflRSuDAwD09fU1XQIRVXNl+c5xsWfjhYaKPxuvS5cu2LRpEw4ePIhVq1YhMTER3bp1w5MnT5CSkgI9PT2YmpqqvMbS0hIpKS+ePZaSkqISGkXbi7aVN624qoqISBuV5anqISEhCAoKUlkn9STu3r17K//cpk0bdOnSBba2tvjll19gYGBQ+iIqiNb2OIiINK0sUxxyuRwmJiYqS0m/wsHU1BTNmjXDjRs3YGVlhby8PKSnp6u0SU1NhZWVFQDAysqq2FVWRT8XtSlPDA4iIikaugEwKysLN2/ehLW1NTp27IiaNWsiMjJSuT0+Ph5JSUlwcnrxFc9OTk64dOkS7t+/r2xz+PBhmJiYwNHRsdj+y4pDVUREEirrBsDg4GD0798ftra2SE5OxsyZM5VfVKdQKDB69GgEBQXB3NwcJiYmmDBhApycnPDuu+8CANzd3eHo6IiRI0di3rx5SElJwZdffomAgIAK+aI6BgcRkYbduXMHw4YNQ1paGiwsLNC1a1ecPn0aFhYvHnG/ePFi6OjowMvLC7m5ufDw8MAPP/ygfL2uri7Cw8Mxfvx4ODk5wdDQEL6+vpgzZ06F1KsVT8fVJD4dt3rh03Grl7I+HffSnaw3N5LQur5RmY6tzdjjICKSwCdViWNwEBFJYXKIYnAQEUng03HFMTiIiCSU5QbAqoz3cRARkVrY4yAiksAOhzgGBxGRFCaHKAYHEZEETo6LY3AQEUng5Lg4BgcRkQTmhjheVUVERGphj4OISAq7HKIYHEREEjg5Lo7BQUQkgZPj4hgcREQSmBviGBxERFKYHKJ4VRUREamFPQ4iIgmcHBfH4CAiksDJcXEMDiIiCcwNcQwOIiIpTA5RDA4iIgmc4xDHq6qIiEgt7HEQEUng5Lg4BgcRkQTmhjgGBxGRBPY4xDE4iIgkMTnEMDiIiCSwxyGOV1UREZFa2OMgIpLADoc4BgcRkQQOVYljcBARSeCd4+IYHEREUpgbohgcREQSmBvieFUVERGphT0OIiIJnBwXx+AgIpLAyXFxDA4iIinMDVEMDiIiCcwNcQwOIiIJnOMQx6uqiIhILexxEBFJ4OS4OAYHEZEEDlWJ41AVERGphT0OIiIJ7HGIY4+DiIjUwh4HEZEETo6LY3AQEUngUJU4BgcRkQTmhjgGBxGRFCaHKAYHEZEEznGI41VVRESkFvY4iIgkcHJcHIODiEgCc0Mcg4OISAqTQxSDg4hIAifHxTE4iIgkcI5DHK+qIiIitcgEQRA0XQRVrtzcXISGhiIkJARyuVzT5VAF4983lTcGRzWUmZkJhUKBjIwMmJiYaLocqmD8+6byxqEqIiJSC4ODiIjUwuAgIiK1MDiqIblcjpkzZ3KitJrg3zeVN06OExGRWtjjICIitTA4iIhILQwOIiJSC4ODiIjUwuAgIiK1MDiIqjFeVEmlweAg7Nq1C7t379Z0GVSJEhISAAAyPjecSoHBUc1dvHgRPj4+SElJ4W+f1cTevXsxaNAgnD17VtOl0FuKNwBWY1euXMHu3buRm5uLr7/+WtPlUCVITk7G2LFj0b9/f3z66aeaLofeUuxxVFM3btzA1KlTsWzZMuTl5QEACgsLNVwVVaSoqCjMmDED+fn5cHd3B8A5DiodBkc1dODAARw7dgw9e/aEjY0Nfv31VyQmJkJHR4cfJFXY/fv38dNPP+HYsWO4fv06AM5xUOkwOKqZixcvYuDAgVAoFAgODkZwcDAUCgVCQkKQmJgImUzG8Khibt++jby8PHzwwQcICwtDnTp1sHHjRly+fFnTpdFbisFRjcTExODGjRsIDg7Ghx9+CAAYOXIkxowZg+TkZPz73//GrVu3GB5VyK+//ophw4Zh3bp1KCgogJubG1avXo1Tp05h2bJluHr1qqZLpLcQg6OayM3NxYgRI/Dhhx/i+vXrKsHg7+8PHx8fpKamIjAwELdv3+YQRhUQFhaGoUOHYtiwYXB3d4euri4AoH///li6dCl+++03LF++HHFxcRqulN42NTRdAFUOuVyOiIgIjBgxAufOncO1a9fg6OgIQRAgk8ng7++PnJwc/Pbbb6hRg/8s3nbJycmYO3cuFi5ciICAAOTn5yMrKwu///47OnfujMGDB0NXVxfDhg2DXC7HvHnzoKenp+my6S3By3GruPj4eDx58gTZ2dno1q0b7ty5g969e0NfXx+7d+9GgwYNlOEBAOnp6TA1NdVs0VRmSUlJ6NGjB5YvX47evXvjm2++wcGDB3H16lXo6uoiMjISbdu2xYEDB9C0aVM0bdpU0yXTW4RDVVVYWFgYPD094ePjAw8PD4waNQq6uro4cOAAsrOz4eXlhTt37qjMaTA03m5paWl4+vQpFAoFXFxcMGnSJNStWxcxMTEYPHgwbt26hfr162PNmjUAgD59+jA0SG0ck6iiIiIiMGrUKHz//ffw8/NDZGQk+vbti+zsbCxYsAC//fYbBgwYAFdXVxw7dgz16tXTdMlURmFhYViwYAEePnwIHx8fuLi4YNCgQUhOTsbQoUNRu3ZtAIC9vT3s7Ow0XC29zdjjqIIyMzOxa9cuTJ48GWPHjsXdu3cxYcIEeHl54eDBgwgICEBhYSHCwsJgYWGhvAGQ3l7nz5+Hn58fPDw84O7ujj179iA8PBxWVlYYP348ateujYcPH2LGjBk4efIkBgwYoOmS6S3GOY4qKC8vD3v37kWHDh1gZmYGNzc3dOjQAevXr8eOHTswYsQIeHp6Yt26dbC0tORk+Fvu5s2b2LFjB2QyGaZPnw4ACA8Px6JFi5T368hkMqxZswaRkZHYt28f2rdvr+Gq6W3GHkcVpKenh/79+6Nx48Y4cOAA9PX1MWvWLAAv7hR2cXHB1atXUVBQwNB4y2VmZsLb2xvLly9HVlaWcn2/fv0wZcoUpKenY8WKFTh+/Djc3d1x/PhxhgaVGYOjitLX1wcAJCYm4smTJzA0NATw4s5xLy8vJCQkoGHDhposkcqBiYkJ1q5dC1NTU5w4cQJXrlxRbuvbty+Cg4Nx48YNxMfHY8CAAWjcuLEGq6WqgkNVVdyFCxfg5OSETp06QV9fH2fPnsWJEyfQpk0bTZdG5SguLg6+vr545513MHHiRLRs2VK57eDBg2jRogVsbW01WCFVJQyOaiA6Oho//PADFAoFxo8fr/KhQlXHhQsX4O/vjw4dOmDy5MlwdHTUdElURTE4qonCwkLIZDI+SqSKu3DhAsaNGwd7e3vMnDkTzZs313RJVAVxjqOa0NHRYWhUA+3bt8eKFStw7949KBQKTZdDVRR7HERVUE5OjvICCaLyxuAgIiK1cKiKiIjUwuAgIiK1MDiIiEgtDA4iIlILg4OIiNTC4CAiIrUwOEhj/Pz8MGjQIOXPPXr0wOeff17pdRw7dgwymQzp6ekVdoxXz7U0KqNOopJgcJAKPz8/5aNJ9PT00KRJE8yZMwfPnz+v8GPv3r0bc+fOLVHbyv4QbdSoEZYsWVIpxyLSdvwyBirG09MTGzduRG5uLg4cOICAgADUrFkTISEhxdrm5eVBT0+vXI5rbm5eLvshoorFHgcVI5fLYWVlBVtbW4wfPx5ubm749ddfAfxvyOWbb76BjY0NHBwcAAD//PMPhg4dClNTU5ibm2PgwIG4deuWcp8FBQUICgqCqakpateujS+++AKvPrTg1aGq3NxcTJs2DQ0aNIBcLkeTJk3w448/4tatW3B1dQUAmJmZQSaTwc/PD8CLhzmGhobCzs4OBgYGaNu2Lf773/+qHOfAgQNo1qwZDAwM4OrqqlJnaRQUFGD06NHKYzo4OGDp0qWibWfPng0LCwuYmJhg3LhxKl/bW5LaX3b79m30798fZmZmMDQ0RMuWLXHgwIEynQtRSbDHQW9kYGCAtLQ05c+RkZEwMTHB4cOHAQD5+fnw8PCAk5MTTpw4gRo1auDrr7+Gp6cn4uLioKenh4ULF2LTpk3YsGEDWrRogYULF2LPnj3o2bOn5HF9fHwQHR2NZcuWoW3btkhMTMTDhw/RoEED7Nq1C15eXoiPj4eJiQkMDAwAAKGhodi6dStWr16Npk2bIioqCh9//DEsLCzg4uKCf/75B0OGDEFAQADGjh2Lc+fOYcqUKWV6fwoLC1G/fn3s3LkTtWvXxqlTpzB27FhYW1tj6NChKu+bvr4+jh07hlu3bmHUqFGoXbs2vvnmmxLV/qqAgADk5eUhKioKhoaGuHr1KoyMjMp0LkQlIhC9xNfXVxg4cKAgCIJQWFgoHD58WJDL5UJwcLByu6WlpZCbm6t8zZYtWwQHBwehsLBQuS43N1cwMDAQDh06JAiCIFhbWwvz5s1Tbs/Pzxfq16+vPJYgCIKLi4swadIkQRAEIT4+XgAgHD58WLTOo0ePCgCEx48fK9fl5OQItWrVEk6dOqXSdvTo0cKwYcMEQRCEkJAQwdHRUWX7tGnTiu3rVba2tsLixYslt78qICBA8PLyUv7s6+srmJubC0+fPlWuW7VqlWBkZCQUFBSUqPZXz7l169bCrFmzSlwTUXlhj4OKCQ8Ph5GREfLz81FYWIjhw4crv7McAFq3bq0yr3Hx4kXcuHEDxsbGKvvJycnBzZs3kZGRgXv37qFLly7KbTVq1ECnTp2KDVcViY2Nha6uruhv2lJu3LiBZ8+eoVevXirr8/LylN+zfe3aNZU6AMDJyanEx5CycuVKbNiwAUlJScjOzkZeXh7atWun0qZt27aoVauWynGzsrLwzz//ICsr6421v2rixIkYP348IiIi4ObmBi8vL36zI1UKBgcV4+rqilWrVkFPTw82NjaoUUP1n0nR95cXycrKQseOHbFt27Zi+7KwsChVDUVDT+rIysoCAOzfvx/16tVT2SaXy0tVR0n89NNPCA4OxsKFC+Hk5ARjY2PMnz8fZ86cKfE+SlO7v78/PDw8sH//fkRERCA0NBQLFy7EhAkTSn8yRCXA4KBiDA0N0aRJkxK379ChA37++WfUrVsXJiYmom2sra1x5swZdO/eHQDw/PlzxMTEoEOHDqLtW7dujcLCQhw/fhxubm7Fthf1eAoKCpTrHB0dIZfLkZSUJNlTadGihXKiv8jp06fffJKv8ccff+C9997DZ599plx38+bNYu0uXryI7OxsZSiePn0aRkZGaNCgAczNzd9Yu5gGDRpg3LhxGDduHEJCQrBu3ToGB1U4XlVFZTZixAjUqVMHAwcOxIkTJ5CYmIhjx45h4sSJuHPnDgBg0qRJ+O677xAWFoa//voLn3322WvvwWjUqBF8fX3xySefICwsTLnPX375BQBga2sLmUyG8PBwPHjwAFlZWTA2NkZwcDAmT56MzZs34+bNmzh//jyWL1+OzZs3AwDGjRuHhIQETJ06FfHx8di+fTs2bdpUovO8e/cuYmNjVZbHjx+jadOmOHfuHA4dOoTr16/jq6++wtmzZ4u9Pi8vD6NHj8bVq1dx4MABzJw5E4GBgdDR0SlR7a/6/PPPcejQISQmJuL8+fM4evQoWrRoUaJzISoTTU+ykHZ5eXJcne337t0TfHx8hDp16ghyuVywt7cXxowZI2RkZAiC8GIyfNKkSYKJiYlgamoqBAUFCT4+PpKT44IgCNnZ2cLkyZMFa2trQU9PT2jSpImwYcMG5fY5c+YIVlZWgkwmE3x9fQVBeDGhv2TJEsHBwUGoWbOmYGFhIXh4eAjHjx9Xvm7fvn1CkyZNBLlcLnTr1k3YsGFDiSbHARRbtmzZIuTk5Ah+fn6CQqEQTE1NhfHjxwv/+te/hLZt2xZ732bMmCHUrl1bMDIyEsaMGSPk5OQo27yp9lcnxwMDA4XGjRsLcrlcsLCwEEaOHCk8fPhQ8hyIygu/AZCIiNTCoSoiIlILg4OIiNTC4CAiIrUwOIiISC0MDiIiUguDg4iI1MLgICIitTA4iIhILQwOIiJSC4ODiIjUwuAgIiK1/B9zcLs/PiEwUAAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 400x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: total: 20.7 s\n",
      "Wall time: 7.4 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "import torch\n",
    "from sklearn.metrics import accuracy_score, confusion_matrix, f1_score\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from torchvision import datasets\n",
    "\n",
    "\n",
    "def validate(model, validation_loader):\n",
    "    model.eval()\n",
    "    y_true = []\n",
    "    y_pred = []\n",
    "    with torch.no_grad():\n",
    "        for inputs, labels in validation_loader:\n",
    "            inputs, labels = inputs.to(device), labels.to(device)\n",
    "            outputs = model(inputs)\n",
    "            _, predicted = torch.max(outputs, 1)\n",
    "            y_true.extend(labels.cpu().numpy())\n",
    "            y_pred.extend(predicted.cpu().numpy())\n",
    "    return y_true, y_pred\n",
    "\n",
    "validation_transform = transforms.Compose([\n",
    "    transforms.RandomHorizontalFlip(),\n",
    "    transforms.ToTensor(),\n",
    "])\n",
    "\n",
    "class CustomDataset(Dataset):\n",
    "    def __init__(self, root_dir):\n",
    "        self.root_dir = root_dir\n",
    "        self.samples = []\n",
    "        self.labels = []\n",
    "        for label in os.listdir(root_dir):\n",
    "            label_dir = os.path.join(root_dir, label)\n",
    "            for file in os.listdir(label_dir):\n",
    "                file_path = os.path.join(label_dir, file)\n",
    "                self.samples.append(file_path)\n",
    "                self.labels.append(int(label))\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.samples)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        sample = np.load(self.samples[idx])\n",
    "        # Assume the shape of sample is (1, 1, 128)\n",
    "        sample = np.squeeze(sample)  # Remove single-dimensional entries\n",
    "        sample = np.expand_dims(sample, axis=0)  # Add a dimension for the channel\n",
    "        sample = np.expand_dims(sample, axis=0)  # Add a dimension for the height (1)\n",
    "        sample = torch.from_numpy(sample).float()\n",
    "        label = self.labels[idx]\n",
    "        return sample, label\n",
    "\n",
    "\n",
    "validation_data = CustomDataset(root_dir=\"datasets/last_val_data/\")\n",
    "\n",
    "validation_dataloader = DataLoader(validation_data, batch_size=32, shuffle=True)\n",
    "\n",
    "\n",
    "y_true, y_pred = validate(model, validation_dataloader)\n",
    "\n",
    "\n",
    "accuracy = accuracy_score(y_true, y_pred)\n",
    "f1 = f1_score(y_true, y_pred, average='weighted')\n",
    "\n",
    "print(f'Validation Accuracy Score: {accuracy}')\n",
    "print(f'F1 Score: {f1}')\n",
    "\n",
    "class_names = ['arr','nsr']\n",
    "\n",
    "\n",
    "cm = confusion_matrix(y_true, y_pred)\n",
    "fig, ax = plt.subplots(figsize=(4, 4))\n",
    "sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',xticklabels=class_names, yticklabels=class_names)\n",
    "plt.xlabel('Predicted Labels')\n",
    "plt.ylabel('True Labels')\n",
    "plt.title('Confusion Matrix')\n",
    "ax.xaxis.set_ticklabels(class_names, rotation=45)\n",
    "ax.yaxis.set_ticklabels(class_names, rotation=45)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d630493-dacf-49f2-962f-c8d2fdec085b",
   "metadata": {},
   "source": [
    "## Total Time taken only to calculate validation accuracy on CPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4ebe2c6-456f-4210-9f87-fd5ee974a379",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "#Only time taken on CPU\n",
    "y_true, y_pred = validate(model, validation_dataloader)\n",
    "\n",
    "# Calculate accuracy score and f1 score\n",
    "accuracy = accuracy_score(y_true, y_pred)\n",
    "f1 = f1_score(y_true, y_pred, average='weighted')\n",
    "\n",
    "# Print accuracy score and f1 score\n",
    "print(f'Validation Accuracy Score: {accuracy}')\n",
    "print(f'F1 Score: {f1}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d60992e4-01aa-4b65-aba2-d18de8d6686f",
   "metadata": {},
   "source": [
    "## Throughput and Latency Measurements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "0ca850fc-4f26-4398-a045-28d2c8f32b37",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU Latency: 0.01988598585128784 seconds\n",
      "CPU Throughput: 50.2866695912508 inferences per second\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import time\n",
    "\n",
    "\n",
    "input_size = (1,1,1,128)\n",
    "num_iterations = 100\n",
    "\n",
    "def benchmark_cpu(model, input_size):\n",
    "    model.eval()\n",
    "    input_data = torch.randn(input_size)\n",
    "    total_time = 0.0\n",
    "    for _ in range(num_iterations):\n",
    "        start_time = time.time()\n",
    "        with torch.no_grad():\n",
    "            _ = model(input_data)\n",
    "        end_time = time.time()\n",
    "        total_time += end_time - start_time\n",
    "    latency = total_time / num_iterations\n",
    "    throughput = num_iterations / total_time\n",
    "    return latency, throughput\n",
    "\n",
    "\n",
    "# Example usage\n",
    "cpu_latency, cpu_throughput = benchmark_cpu(model, input_size)\n",
    "\n",
    "# Print results\n",
    "print(\"CPU Latency:\", cpu_latency, \"seconds\")\n",
    "print(\"CPU Throughput:\", cpu_throughput, \"inferences per second\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6dca2525-dcf4-4227-a229-ee70877d7bd1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d7e4e1a-4c70-4ccf-bc2c-89eaa74769e9",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}