diff --git "a/Q2/backup Copy of COMP5541 AlexNet CIFAR-10.ipynb" "b/Q2/backup Copy of COMP5541 AlexNet CIFAR-10.ipynb"
new file mode 100644--- /dev/null
+++ "b/Q2/backup Copy of COMP5541 AlexNet CIFAR-10.ipynb"
@@ -0,0 +1,3369 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "VGo_qfSb8i46"
+   },
+   "source": [
+    "## Importing Libraries\n",
+    "\n",
+    "The Notebook knows to use a GPU to train the model if it's available."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "executionInfo": {
+     "elapsed": 289,
+     "status": "ok",
+     "timestamp": 1750515281845,
+     "user": {
+      "displayName": "Yusheng Cai",
+      "userId": "12125344090096007129"
+     },
+     "user_tz": -480
+    },
+    "id": "w_2OoM5JQVmT",
+    "jupyter": {
+     "is_executing": true
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "from torchvision import datasets\n",
+    "from torchvision import transforms\n",
+    "from torch.utils.data.sampler import SubsetRandomSampler\n",
+    "from datetime import datetime\n",
+    "from tqdm import tqdm\n",
+    "import matplotlib.pyplot as plt\n",
+    "from torchvision import transforms\n",
+    "import numpy as np\n",
+    "\n",
+    "\n",
+    "# Device configuration\n",
+    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Twnee3ln8lIp"
+   },
+   "source": [
+    "## Loading the CIFAR10 Dataset\n",
+    "\n",
+    "Using torchvision (a helper library for computer vision tasks), we will load our dataset. This method has some helper functions that makes pre-processing pretty easy and straight-forward. Let's define the functions get_train_valid_loader and get_test_loader, and then call them to load in and process our CIFAR-10 data:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T20:18:01.846412Z",
+     "start_time": "2025-06-22T20:17:55.770377Z"
+    },
+    "executionInfo": {
+     "elapsed": 2579,
+     "status": "ok",
+     "timestamp": 1750516889052,
+     "user": {
+      "displayName": "Yusheng Cai",
+      "userId": "12125344090096007129"
+     },
+     "user_tz": -480
+    },
+    "id": "muLZxw7_TG5O"
+   },
+   "outputs": [],
+   "source": [
+    "def get_train_valid_loader(\n",
+    "    data_dir, batch_size, augment, random_seed, valid_size=0.1, shuffle=True\n",
+    "):\n",
+    "    normalize = transforms.Normalize(\n",
+    "        mean=[0.4914, 0.4822, 0.4465],\n",
+    "        std=[0.2023, 0.1994, 0.2010],\n",
+    "    )\n",
+    "\n",
+    "    # define transforms\n",
+    "    transform = transforms.Compose(\n",
+    "        [\n",
+    "            transforms.Resize((224, 224)),\n",
+    "            transforms.ToTensor(),\n",
+    "            normalize,\n",
+    "        ]\n",
+    "    )\n",
+    "\n",
+    "    # load the dataset\n",
+    "    train_dataset = datasets.CIFAR10(\n",
+    "        root=data_dir,\n",
+    "        train=True,\n",
+    "        download=True,\n",
+    "        transform=transform,\n",
+    "    )\n",
+    "\n",
+    "    valid_dataset = datasets.CIFAR10(\n",
+    "        root=data_dir,\n",
+    "        train=True,\n",
+    "        download=True,\n",
+    "        transform=transform,\n",
+    "    )\n",
+    "\n",
+    "    num_train = len(train_dataset)\n",
+    "    indices = list(range(num_train))\n",
+    "    split = int(np.floor(valid_size * num_train))\n",
+    "\n",
+    "    if shuffle:\n",
+    "        np.random.seed(random_seed)\n",
+    "        np.random.shuffle(indices)\n",
+    "\n",
+    "    train_idx, valid_idx = indices[split:], indices[:split]\n",
+    "    train_sampler = SubsetRandomSampler(train_idx)\n",
+    "    valid_sampler = SubsetRandomSampler(valid_idx)\n",
+    "\n",
+    "    train_loader = torch.utils.data.DataLoader(\n",
+    "        train_dataset, batch_size=batch_size, sampler=train_sampler\n",
+    "    )\n",
+    "\n",
+    "    valid_loader = torch.utils.data.DataLoader(\n",
+    "        valid_dataset, batch_size=batch_size, sampler=valid_sampler\n",
+    "    )\n",
+    "\n",
+    "    return (train_loader, valid_loader)\n",
+    "\n",
+    "\n",
+    "def get_test_loader(data_dir, batch_size, shuffle=True):\n",
+    "    normalize = transforms.Normalize(\n",
+    "        mean=[0.485, 0.456, 0.406],\n",
+    "        std=[0.229, 0.224, 0.225],\n",
+    "    )\n",
+    "\n",
+    "    # define transform\n",
+    "    transform = transforms.Compose(\n",
+    "        [\n",
+    "            transforms.Resize((224, 224)),\n",
+    "            transforms.ToTensor(),\n",
+    "            normalize,\n",
+    "        ]\n",
+    "    )\n",
+    "\n",
+    "    dataset = datasets.CIFAR10(\n",
+    "        root=data_dir,\n",
+    "        train=False,\n",
+    "        download=True,\n",
+    "        transform=transform,\n",
+    "    )\n",
+    "\n",
+    "    data_loader = torch.utils.data.DataLoader(\n",
+    "        dataset, batch_size=batch_size, shuffle=shuffle\n",
+    "    )\n",
+    "\n",
+    "    return data_loader\n",
+    "\n",
+    "\n",
+    "# CIFAR10 dataset\n",
+    "train_loader, valid_loader = get_train_valid_loader(\n",
+    "    data_dir=\"./data\", batch_size=64, augment=False, random_seed=1,shuffle=False\n",
+    ")\n",
+    "\n",
+    "test_loader = get_test_loader(data_dir=\"./data\", batch_size=64)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "urw6pzcZT6Xi"
+   },
+   "source": [
+    "## Building AlexNet\n",
+    "\n",
+    "- The first step to defining any neural network (whether a CNN or not) in PyTorch is to define a class that inherits `nn.Module` as it contains many of the methods that we will need to utilize\n",
+    "- There are two main steps after that. First is initializing the layers that we are going to use in our CNN inside `__init__`, and the other is to define the sequence in which those layers will process the image. This is defined inside the forward function\n",
+    "- For the architecture itself, we first define the convolutional layers using the `nn.Conv2D` function with the appropriate kernel size and the input/output channels. We also apply max pooling using `nn.MaxPool2D` function. The nice thing about PyTorch is that we can combine the convolutional layer, activation function, and max pooling into one single layer (they will be separately applied, but it helps with organization) using the `nn.Sequential` function\n",
+    "- Then we define the fully connected layers using linear (`nn.Linear`) and dropout (`nn.Dropout`) along with ReLu activation function (`nn.ReLU`) and combining these with the nn.Sequential function\n",
+    "- Finally, our last layer outputs 10 neurons which are our final predictions for the 10 classes of objects\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T20:18:01.875274Z",
+     "start_time": "2025-06-22T20:18:01.868417Z"
+    },
+    "executionInfo": {
+     "elapsed": 60,
+     "status": "ok",
+     "timestamp": 1750516891525,
+     "user": {
+      "displayName": "Yusheng Cai",
+      "userId": "12125344090096007129"
+     },
+     "user_tz": -480
+    },
+    "id": "K5hfwshJR9fz"
+   },
+   "outputs": [],
+   "source": [
+    "class AlexNet(nn.Module):\n",
+    "    def __init__(self, num_classes = 1000, dropout = 0.5):\n",
+    "        super().__init__()\n",
+    "        self.features = nn.Sequential(\n",
+    "            nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.MaxPool2d(kernel_size=3, stride=2),\n",
+    "            nn.Conv2d(64, 192, kernel_size=5, padding=2),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.MaxPool2d(kernel_size=3, stride=2),\n",
+    "            nn.Conv2d(192, 384, kernel_size=3, padding=1),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.Conv2d(384, 256, kernel_size=3, padding=1),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.Conv2d(256, 256, kernel_size=3, padding=1),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.MaxPool2d(kernel_size=3, stride=2),\n",
+    "        )\n",
+    "        self.avgpool = nn.AdaptiveAvgPool2d((6, 6))\n",
+    "        self.classifier = nn.Sequential(\n",
+    "            nn.Dropout(p=dropout),\n",
+    "            nn.Linear(256 * 6 * 6, 4096),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.Dropout(p=dropout),\n",
+    "            nn.Linear(4096, 4096),\n",
+    "            nn.ReLU(inplace=True),\n",
+    "            nn.Linear(4096, num_classes),\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.features(x)\n",
+    "        x = self.avgpool(x)\n",
+    "        x = torch.flatten(x, 1)\n",
+    "        x = self.classifier(x)\n",
+    "        return x\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "CGzCpjRbp2ut"
+   },
+   "source": [
+    "## Building VGGNet"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T20:18:01.898665Z",
+     "start_time": "2025-06-22T20:18:01.892686Z"
+    },
+    "executionInfo": {
+     "elapsed": 82,
+     "status": "ok",
+     "timestamp": 1750523869057,
+     "user": {
+      "displayName": "Yusheng Cai",
+      "userId": "12125344090096007129"
+     },
+     "user_tz": -480
+    },
+    "id": "PUJbOzCnp2Ss"
+   },
+   "outputs": [],
+   "source": [
+    "class VGG11(nn.Module):\n",
+    "    def __init__(self, num_classes=10):\n",
+    "        super().__init__()\n",
+    "\n",
+    "        def buildblock(numlayer, input_channels, output_channels):\n",
+    "            layers = [nn.Conv2d(input_channels, output_channels, kernel_size=3, stride=1, padding=1), nn.ReLU()]\n",
+    "            layers += [nn.Conv2d(output_channels, output_channels, kernel_size=3, stride=1, padding=1), nn.ReLU()] * (numlayer - 1)\n",
+    "            layers += [nn.MaxPool2d(2)]\n",
+    "            return nn.Sequential(*layers)\n",
+    "\n",
+    "        self.block1 = buildblock(numlayer=1, input_channels=3, output_channels=64)\n",
+    "        self.block2 = buildblock(numlayer=1, input_channels=64, output_channels=128)\n",
+    "        self.block3 = buildblock(numlayer=2, input_channels=128, output_channels=256)\n",
+    "        self.block4 = buildblock(numlayer=2, input_channels=256, output_channels=512)\n",
+    "        self.block5 = buildblock(numlayer=2, input_channels=512, output_channels=512)\n",
+    "\n",
+    "        self.conv_layers = nn.Sequential(\n",
+    "            self.block1, self.block2, self.block3, self.block4, self.block5\n",
+    "        )\n",
+    "\n",
+    "        self.output_layers = nn.Sequential(\n",
+    "            nn.Linear(7*7*512, 4096),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Linear(4096, 4096),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Linear(4096, num_classes)\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.conv_layers(x)\n",
+    "        x = torch.flatten(x, 1)\n",
+    "        x = self.output_layers(x)\n",
+    "        return x"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "DUW9zW0CIG_f"
+   },
+   "source": [
+    "## Building ResNet\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T20:18:01.929355Z",
+     "start_time": "2025-06-22T20:18:01.922524Z"
+    },
+    "id": "1pG1QAEVjFj5"
+   },
+   "outputs": [],
+   "source": [
+    "class ResBlock(nn.Module):\n",
+    "    def __init__(self, in_channels, out_channels):\n",
+    "        super().__init__()\n",
+    "        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=2, padding=1)\n",
+    "        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1)\n",
+    "        self.downsample = nn.Sequential(\n",
+    "                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=2),\n",
+    "                nn.BatchNorm2d(out_channels)\n",
+    "            )\n",
+    "        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2)\n",
+    "        self.relu = nn.ReLU()\n",
+    "    def forward(self, x):\n",
+    "        identity = self.downsample(x)\n",
+    "        out = self.conv1(x)\n",
+    "        out = self.relu(out)\n",
+    "        out = self.conv2(out)\n",
+    "        out = self.relu(out)\n",
+    "        out = out + identity\n",
+    "        out = self.relu(out)\n",
+    "        return out\n",
+    "\n",
+    "class ResNet(nn.Module):\n",
+    "    def __init__(self,num_classes):\n",
+    "        super().__init__()\n",
+    "\n",
+    "        self.conv1 = nn.Sequential(nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3), nn.ReLU())\n",
+    "        self.conv2 = ResBlock(64, 64)\n",
+    "        self.conv3 = ResBlock(64, 128)\n",
+    "        self.conv4 = ResBlock(128, 256)\n",
+    "        self.conv5 = ResBlock(256, 512)\n",
+    "        self.output_layers = nn.Sequential(\n",
+    "            nn.Linear(7*7*512, 4096),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Linear(4096, num_classes)\n",
+    "        )\n",
+    "    def forward(self, x):\n",
+    "        x = self.conv1(x)\n",
+    "        x = self.conv2(x)\n",
+    "        x = self.conv3(x)\n",
+    "        x = self.conv4(x)\n",
+    "        x = self.conv5(x)\n",
+    "        x = torch.flatten(x, 1)\n",
+    "        x = self.output_layers(x)\n",
+    "        return x"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "fLywGzaK-49r"
+   },
+   "source": [
+    "## Setting Hyperparameters\n",
+    "\n",
+    "Before training, we need to set some hyperparameters, such as the loss function and the optimizer to be used along with batch size, learning rate, and number of epochs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T20:18:01.948888Z",
+     "start_time": "2025-06-22T20:18:01.946063Z"
+    },
+    "executionInfo": {
+     "elapsed": 1188,
+     "status": "ok",
+     "timestamp": 1750529671175,
+     "user": {
+      "displayName": "Yusheng Cai",
+      "userId": "12125344090096007129"
+     },
+     "user_tz": -480
+    },
+    "id": "VlgLxD1BSFoz"
+   },
+   "outputs": [],
+   "source": [
+    "num_classes = 10\n",
+    "num_epochs = 20\n",
+    "batch_size = 64\n",
+    "learning_rate = 0.001\n",
+    "criterion = nn.CrossEntropyLoss()\n",
+    "early_stopping = 10"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "1IcOPh6vMODr"
+   },
+   "source": [
+    "## Training\n",
+    "\n",
+    "We are ready to train our model at this point:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "5PdTVFW_Hh4x"
+   },
+   "source": [
+    "### VGGNet\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Adam"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 107,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T20:18:02.731889Z",
+     "start_time": "2025-06-22T20:18:01.968436Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "vggnet = VGG11(num_classes).to(device)\n",
+    "vggnet_optimizer = torch.optim.Adam(vggnet.parameters(), lr=learning_rate)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 108,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T20:47:44.152533Z",
+     "start_time": "2025-06-22T20:18:02.752584Z"
+    },
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "2NAGdpAolF3C",
+    "outputId": "fdeca377-6490-4d4c-a978-379674aab98c"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 04:20:44.524153 - Epoch [1/20], Train Loss: 1.6914, Train Accuracy: 38.15%, Test Loss: 1.3849, Test Accuracy: 49.28%\n",
+      "2025-06-23 04:23:25.634491 - Epoch [2/20], Train Loss: 1.2069, Train Accuracy: 56.76%, Test Loss: 1.1299, Test Accuracy: 59.24%\n",
+      "2025-06-23 04:26:06.755900 - Epoch [3/20], Train Loss: 0.8893, Train Accuracy: 68.65%, Test Loss: 0.9190, Test Accuracy: 67.68%\n",
+      "2025-06-23 04:28:48.206214 - Epoch [4/20], Train Loss: 0.6472, Train Accuracy: 77.10%, Test Loss: 0.8593, Test Accuracy: 71.46%\n",
+      "2025-06-23 04:31:30.101735 - Epoch [5/20], Train Loss: 0.4086, Train Accuracy: 85.69%, Test Loss: 1.0176, Test Accuracy: 70.20%\n",
+      "2025-06-23 04:34:12.604158 - Epoch [6/20], Train Loss: 0.2352, Train Accuracy: 91.92%, Test Loss: 1.1922, Test Accuracy: 69.84%\n",
+      "2025-06-23 04:36:54.953503 - Epoch [7/20], Train Loss: 0.1550, Train Accuracy: 94.71%, Test Loss: 1.4235, Test Accuracy: 69.44%\n",
+      "2025-06-23 04:39:37.690299 - Epoch [8/20], Train Loss: 0.1191, Train Accuracy: 96.00%, Test Loss: 1.4372, Test Accuracy: 70.48%\n",
+      "2025-06-23 04:42:19.648764 - Epoch [9/20], Train Loss: 0.0907, Train Accuracy: 97.00%, Test Loss: 1.6494, Test Accuracy: 69.46%\n",
+      "2025-06-23 04:45:02.180740 - Epoch [10/20], Train Loss: 0.0941, Train Accuracy: 96.91%, Test Loss: 1.5076, Test Accuracy: 70.30%\n",
+      "2025-06-23 04:47:44.147419 - Epoch [11/20], Train Loss: 0.0821, Train Accuracy: 97.36%, Test Loss: 1.7451, Test Accuracy: 70.96%\n"
+     ]
+    }
+   ],
+   "source": [
+    "train_loss_history = []\n",
+    "test_loss_history = []\n",
+    "train_accuracy_history = []\n",
+    "test_accuracy_history = []\n",
+    "\n",
+    "total_step = len(train_loader)\n",
+    "\n",
+    "for epoch in range(num_epochs):\n",
+    "    if epoch>early_stopping:break\n",
+    "    # Training\n",
+    "    accumulate_train_loss,num_total_train_sample,num_accurate_train_prediction = 0.0 ,0,0\n",
+    "    for i, (images, labels) in enumerate(train_loader):\n",
+    "        # Move tensors to the configured device\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "\n",
+    "        # Forward pass\n",
+    "        outputs = vggnet(images)\n",
+    "        loss = criterion(outputs, labels)\n",
+    "\n",
+    "        # Backward and optimize\n",
+    "        vggnet_optimizer.zero_grad()\n",
+    "        loss.backward()\n",
+    "        vggnet_optimizer.step()\n",
+    "\n",
+    "        accumulate_train_loss += loss.item()\n",
+    "        num_total_train_sample += labels.size()[0]\n",
+    "        num_accurate_train_prediction += (outputs.argmax(1)==labels).sum().item()\n",
+    "\n",
+    "\n",
+    "\n",
+    "    #print ('{} - Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'\n",
+    "    #               .format(str(datetime.now()), epoch+1, num_epochs, i+1, total_step, accumulate_train_loss/len(train_loader)))\n",
+    "\n",
+    "    train_loss,train_accuracy = accumulate_train_loss/len(train_loader),num_accurate_train_prediction/num_total_train_sample\n",
+    "    train_loss_history += [train_loss]\n",
+    "    train_accuracy_history += [train_accuracy]\n",
+    "\n",
+    "    # Validation\n",
+    "    with torch.no_grad():\n",
+    "        correct = 0\n",
+    "        total = 0\n",
+    "        accumulate_test_loss = 0\n",
+    "        for images, labels in valid_loader:\n",
+    "            images = images.to(device)\n",
+    "            labels = labels.to(device)\n",
+    "            outputs = vggnet(images)\n",
+    "            loss = criterion(outputs, labels)\n",
+    "            accumulate_test_loss += loss.item()\n",
+    "            _, predicted = torch.max(outputs.data, 1)\n",
+    "            total += labels.size(0)\n",
+    "            correct += (predicted == labels).sum().item()\n",
+    "            del images, labels, outputs\n",
+    "        test_accuracy,test_loss = correct / total,accumulate_test_loss/len(valid_loader)\n",
+    "        #print('Accuracy of the network on the {} validation images: {} %'.format(5000, 100 * correct / total))\n",
+    "        test_accuracy_history += [test_accuracy]\n",
+    "        test_loss_history += [test_loss]\n",
+    "    print(f\"{str(datetime.now())} - Epoch [{epoch+1}/{num_epochs}], Train Loss: {train_loss:.4f}, Train Accuracy: {train_accuracy*100:.2f}%, Test Loss: {test_loss:.4f}, Test Accuracy: {test_accuracy*100:.2f}%\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "training loss is decreasing and test accuracy is increasing all the time\n",
+    "\n",
+    "however, test loss decreases before 2nd epoch and begin to rise after 2nd epoch, which is a sign of overfitting\n",
+    "\n",
+    "however, test accuracy is increasing before 4th epoch, and becomes stable after 4th epoch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 109,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T20:47:44.431116Z",
+     "start_time": "2025-06-22T20:47:44.265071Z"
+    },
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 452
+    },
+    "executionInfo": {
+     "elapsed": 658,
+     "status": "ok",
+     "timestamp": 1750529640037,
+     "user": {
+      "displayName": "Yusheng Cai",
+      "userId": "12125344090096007129"
+     },
+     "user_tz": -480
+    },
+    "id": "zmn4IOgQo_Eh",
+    "outputId": "079d6c74-1988-4ed1-eb41-408b061f967e"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABkoAAAHDCAYAAABrrUaWAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAA3u1JREFUeJzs3Qd4U3UXBvC3e9EWSill77333lP2FBAEQQQUcKAiKOBEXJ+CTNlbQGTKko3svTeUDaVldM8k33P+l5S2tNBC25u27+95YnNvbpKTNNJ7c+45x8pkMplARERERERERERERESUCVnrHQAREREREREREREREZFemCghIiIiIiIiIiIiIqJMi4kSIiIiIiIiIiIiIiLKtJgoISIiIiIiIiIiIiKiTIuJEiIiIiIiIiIiIiIiyrSYKCEiIiIiIiIiIiIiokyLiRIiIiIiIiIiIiIiIsq0mCghIiIiIiIiIiIiIqJMi4kSIiIiIiIiIiIiIiLKtJgoISKyMAULFsRbb72VYo/31VdfwcrKCpbk2rVrKqZffvklXcZPRERERET6HePQqzEfY/n7+79wW/7uiCizYKKEiCiZ9u7dq3YsHz9+rHcolIg7d+6o39Hx48f1DoWIiIiIyOLxGIdS0vr169XniYgoPWGihIjoJQ4ivv7661Q7iLhw4QJmzJiRKo+dHo0aNQphYWHJTpTI74iJEiIiIiKiF+MxDqXk704SJfJ5IiJKT5goISJKRUajEeHh4cm6j4ODA+zs7FItpvTG1tYWjo6OsAQhISF6h0BEREREpCse4yRfaGgo0itL+d29zOeOiCg5mCghIkoGKR/+9NNP1fVChQqpvq5ykZkbQq4PGTIEixYtQpkyZdRO5caNG9VtMo+jdu3ayJ49O5ycnFClShUsX778hT1g586dqx53z549GDZsGHLkyAEXFxd07NgRfn5+L/U6oqOj8e2336JIkSIqRnnOzz//HBEREXG2O3z4MFq0aAFPT08Vs7zmfv36xdlmyZIl6rW4urrCzc0N5cqVw4QJE5Icy/Tp02PiqFatGg4dOvTCGSWbN29G3bp1kTVrVmTJkgUlSpRQ8YsdO3aoxxF9+/aN+R3J+2j2119/qZjlNclr69WrF27fvh3nOeR3II995coVtGrVSr2+nj174ssvv1QHCgm99wMGDFAxcQeeiIiIiNKL9HiMc/LkSfV4hQsXVidVeXt7q+OUBw8ePLOt7Oe//fbbyJ07t4pdXuO7776LyMjImG2kkuajjz5Scco2efPmRe/evWNmeJjjNb8nZnLsIevlp1nDhg1RtmxZHDlyBPXr14ezs3PMscrq1avRunXrmFjkOEiOywwGwzNxHzhwQB2HZMuWTb035cuXjznOmjNnjnreY8eOPXO/77//HjY2Ns8c3yREXre8j3IM4+7uro6f4id14v/uoqKiVLVIsWLF1Hsvv3s5NpNjNCHbTp48WV03f5ZiH8/JyWcff/wx8uXLp94DOZaTz5HJZIrzvAl97jZs2KDiad++/TOvRY7B5DUMHDjwha+biCghtgmuJSKiBHXq1AkXL17En3/+id9++019yS5kx95s27ZtWLZsmdqpk9tlR07ITm27du3Ul+2yUy4Jhq5du+Kff/5RO8svMnToULWTLF/Uyw76+PHj1XMsXbo02a+jf//+mDdvHrp06aJ2UmUnfNy4cTh37hxWrlyptrl//z6aN2+uXtuIESPUzrM874oVK2IeR3aGe/TogSZNmuDHH39U6+Qx5IDngw8+eGEcixcvRlBQkNqZlR3hn376Sb3HV69eTfSspTNnzqBNmzbqQOGbb75RO8yXL19WzylKlSql1o8ZM0YlLurVq6fWywGc+SBHDgAkmSKv2dfXV/1u5P5yoCGvM3ZCSRJFsuMvO+9ykFOrVi31+PK+y/tvJr9TOSjs3LmzxVTAEBERERFlxGMcOQ6RYwbZr5ckiRwjyAlY8nP//v0xX8xLS97q1aurhIAcG5QsWVIlEGS/XRIC9vb2CA4OVscMchwjyZbKlSurBMmaNWtw69atmPcjOSRh89prr6F79+7qpKycOXPGHIvIyViSHJKf8r7KcUtgYCB+/vnnOK9Pjnly5cqljqvkNUp88r7KshzHDR48WCURKlWqFOe5ZZ0ka/LkyfPCOF9//XWVOJLjoqNHj2LmzJnw8vKKObZLLLEm28sxpby3ErucYCf3b9asmTq2k/ddXsOCBQvi3FeSIfJ52b59u0peVaxYEZs2bVKJOvm9yOcvtvifO4lV3k85bnz48CE8PDxitl27dq2KRW4nInopJiIiSpaff/5ZTnUx+fj4PHObrLe2tjadOXPmmdtCQ0PjLEdGRprKli1raty4cZz1BQoUMPXp0ydmec6cOepxmzZtajIajTHrP/roI5ONjY3p8ePHz433yy+/VPc3O378uFru379/nO0++eQTtX7btm1qeeXKlWr50KFDiT72Bx98YHJzczNFR0ebkkPeO3ns7Nmzmx4+fBizfvXq1Wr92rVrE43/t99+U8t+fn6JPr7ELNvIexf/Pffy8lLve1hYWMz6f/75R20/ZsyYmHXyO5B1I0aMeObxa9WqZapRo0acdStWrFDbb9++PVnvBRERERGR3tLbMU785xV//vmnesxdu3bFrOvdu7eKPaFjGvPzyjGA3E/25xPbxhxv/PdH9v3jHwM0aNBArZs2bVqS4h44cKDJ2dnZFB4erpbl2KpQoULqPXv06FGC8YgePXqYcufObTIYDDHrjh49muBxUHzmY6x+/frFWd+xY0d1jPa8312FChVMrVu3fu7jDx48OM4xnNmqVavU+u+++y7O+i5dupisrKxMly9ffuHn7sKFC+q2qVOnxlnfrl07U8GCBeO8R0REycHWW0REKaxBgwYoXbr0M+ulFN3s0aNHCAgIUGcuyZk3SSFnQMUuWZb7Son29evXkz1YT8hZTLFJZYlYt26d+mmurJCzlqS8OiGyjZROm8usk6tbt27qDDIzc/WHnB2WGHNcUrYufWqTQ850kkqZ9957L07Vh5ztJmeXmV97bFKWH5+U4UsVjrTlin3mlpSPy++fiIiIiCgjsbRjnNjPKy2XpAKkZs2aatn83HKssGrVKrRt2xZVq1Z95jHMz/v333+jQoUKqu1XYtskl1S9S7XL8+KWynqJW16zVLecP39erZcqdx8fH3z44Ydxqt3jxyPHJFK5IdUZsY9J5Dmkyj0pBg0aFGdZYpFqGKnMSIzEJJU7ly5dQnLJsai0BXv//fefORaV3Ii01nrR56548eKoUaOGeq1mUl0i95XKppf9nRERMVFCRJTCpBw4IZJwkJ13+YJeSoSllH3q1KnqYCIp8ufPH2fZnGCQA5LkkIMOa2trFC1aNM56KeeWnV7zQYnslMoOtvSflTJn6QMrvXBjzzGRhIPsqEpZufTxlVJ1c7/i1HpNklypU6eOKvWWEnYpZ5dy7KQkTcyvTfrgxieJkvgHZDJIXl5XQjHIwY9551x+h/L75Y45EREREWVElnaMI1+MSwsqOR6QxIA8rzlG83PLrBP5wl/mhTyPnPz0om2SS9peSVuv+CTBIAkZmaUh8x0lbnOrKHPc5pOxXhSTtLmS1lzmYxI5HpL2aXLcJvMVU+v9lzbE0spMjgNlPqW0zZKZMUkhx1synyV+fNI+2Xx7Uj53kiSS1snm7WUGpZzc9+abbyYpDiKihDBRQkSUwmKfJWT233//qV6scgAxZcoUdSaNVGG88cYbzwytS4yceZOQpN4/vhd9oS+3S+/effv2qZ6w0jNWEiEyoFH6+ArpX3v8+HHVv9fca1aSJn369Em11yTv765du7Blyxa1Iyw75ZK4kAOFhIYgvgpJhkhSKT45gJCeweaDEnmfJIHEfrhERERElBFZ2jGOzNaYMWOGqoiQGYr//vtvzAlbya06f5Vjp8SOPxJ6vyS5ICejnThxQiUbZKaGvF/meSDJjVveO3mvpSJGqmrkWEwqTJJzTPIy778MqJdkzuzZs1UyR+aayFwX+ZnSEnofhZwsJzMtzcdjCxcuVFVDCZ0QR0SUVEyUEBEl08tUDMjOqxxAyKA6STZIMqFp06bQQ4ECBdROePxSaRlqLjvvcntscobY2LFjVdsq2RGVs6BkSKOZnCkl5exycCQ7zDK8b/78+WrAemqR5IUMkP/1119x9uxZFZ8M+jOXnSf2OzK/tgsXLjxzm6yL/9qfR85ikqGXhw4dihmiWKZMmZd+TUREREREeklPxzhS7bB161aMGDFCVb9LhYacNFW4cOE420m1hlRtnD59+rmPV6RIkRduY660kOOl2JLTBnnHjh2qrZUMdJdqGDnxSt6v2K2IzfGIF8VkPiaRqhlJusgxibzmFi1aILVJ9ZC0FpMKlps3b6J8+fJqyLvZ847HJJkjbcdiM7cdS+rxmDy/tE+W1yy/A6kuYTUJEb0qJkqIiJLJxcUlwZ3kF52pIzuLsc84unbtmuqZm9ZatWqlfo4fPz7Oekk6CNnhNB+AxD+TqGLFiuqnuf2W7OjHT2DITnLsbVKalNnHFz+uxH5HcpaRVMFMmzYtTnzSz/bcuXMxrz0p5EBQWpLJGWA7d+5kNQkRERERpVvp6RjHXAUR/1gl/vGNHJt06NBBJRHkpK/4zPeXdsNS5bFy5cpEtzEnL6Sy3Uxe9/Tp018p7sjISHXCWWxSnSEtp+T1xP99xH/NcuwlF6nmkMSVVFpI++DUFP8YMEuWLKqtc+zjq8Q+T3IsKu/bpEmT4qz/7bff1GdJjrGSShIjctKctP6S91ZeOxHRq0jdfz2JiDIgaT0lvvjii5iSX6moMO8MJkS+gJdERMuWLVV5tAwUnzx5stqhTGo/15QigwqlNZbs1JvLvw8ePIh58+apA4lGjRqp7WRZdtrlDC05MJCzfqS8Xc7KMidbZE6IJC4aN26sZnnI2TwTJ05UiQtzn9mUJmXqcoAi76mccSTvpcQpz1+3bl21jcQr81YkISL9b+V3IwP/5IBDEhty9pO87h49eqhKmgkTJqBgwYL46KOPkhyH/N7l9y87+bJjLo9FRERERJQepadjHDkekfZPP/30k5pLIfNApPWWDECP7/vvv1e3yb6/DI6XY5S7d++qmRa7d+9WxwzyRbu00u3atWtMq2E5xpH2wnI8IcdPUjkulfYjR45Ut0lFg1TZR0dHJznu2rVrq+oRORaTYeaSGFiwYMEzyQ9J8MicF3n/5bhKjl1kFolUXUh1v1TwxK8q+eSTT9T1tDh5S4arN2zYUL1P8j5IEkreP2nXHP/zJK9TKlzMiQx5TXK8KZ8zSarJeyu/n9WrV6vh9eaEVFLI5y979uzqdykJFjkhjojolZiIiCjZvv32W1OePHlM1tbWsldr8vHxUevl+uDBgxO8z6xZs0zFihUzOTg4mEqWLGmaM2eO6csvv1T3ia1AgQKmPn36xCzLdrLNoUOH4my3fft2tV5+Pk9CzxEVFWX6+uuvTYUKFTLZ2dmZ8uXLZxo5cqQpPDw8ZpujR4+aevToYcqfP7+K2cvLy9SmTRvT4cOHY7ZZvny5qXnz5uo2e3t7te3AgQNNd+/efW5M8n5JTD///PMzt8l6iTmx+Ldu3Wpq3769KXfu3Oo55afEefHixTiPs3r1alPp0qVNtra26v7yPpotXbrUVKlSJfW6PDw8TD179jTdunUrzv3ld+Di4vLc13Hw4EH12PIeEBERERGlZ+npGEf23Tt27GjKmjWryd3d3dS1a1fTnTt3njmWENevXzf17t3blCNHDhVn4cKF1euJiIiI2ebBgwemIUOGqNcvxxh58+ZV8fr7+8dsc+XKFVPTpk3VY+TMmdP0+eefmzZv3vxMvA0aNDCVKVMmwbj37NljqlmzpsnJyUkdxwwfPty0adOmBF/z7t27Tc2aNTO5urqq45Ly5cubJk6c+MxjyrGXjY2NqXjx4qakMv+O/Pz84qw3/17Mv/uEfnffffedqXr16uq9l9chv/exY8eaIiMjY7aJjo42DR06VL3nVlZWcT4PQUFBpo8++ki9fjkWlc+PHBcajcY4sTzvc2f23nvvqe0WL16c5NdORJQYK/nPq6VaiIiIMicp0ZezvGQmC3viEhERERFRWvP391cVJ2PGjMHo0aORmUhHgFmzZuHevXtwdnbWOxwiSuc4o4SIiOglSSsy6cnbqVMnvUMhIiIiIqJMSIbDy9yPzHbiVnh4OBYuXKhmzDBJQkQpgTNKiIiIkkkGQsrgQJnzIr14n9e7mYiIiIiIKKVt27ZNHZOMHTtWzZqUmYuZgczC2bJli5qLIoPlP/jgA71DIqIMgq23iIiIkkkOQmQIvAwmlAGMMjCeiIiIiIgorchA9b1796JOnTqqskKG2mcGO3bsUAPhZXi7tBqLPUSeiOhVMFFCRERERERERERERESZFmeUEBERERERERERERFRpsVECRERERERURrbtWsX2rZti9y5c8PKygqrVq1KUruRypUrw8HBAUWLFlUDfImIiIiI6NVliGHuRqMRd+7cUT3i5SCDiIiIiCijkw66QUFB6ot2a2ue/5TehISEoEKFCujXrx86der0wu19fHzQunVrDBo0CIsWLcLWrVvRv39/5MqVS83MSgoeNxERERFRZmJKxjFThphRcuvWLeTLl0/vMIiIiIiI0tzNmzeRN29evcOgVyBJi5UrV6JDhw6JbvPZZ59h3bp1OH36dMy67t274/Hjx9i4cWOSnofHTURERESUGd1MwjFThqgokTOizC/Yzc1N73CIiIiIiFJdYGCg+tLbvC9MGdu+ffvQtGnTOOukkuTDDz9M9D4RERHqYmY+R47HTURERESUGQQm45gpQyRKzGXjsrPPHX4iIiIiykzYQilzuHfvHnLmzBlnnSzLwV9YWBicnJyeuc+4cePw9ddfP7Oex01ERERElJlYJeGYic2MiYiIiIiIMqCRI0ciICAg5iKVJERERERElEErSoiIiIiIiDIyb29v+Pr6xlkny1IZklA1iXBwcFAXIiIiIiJ6PlaUEBERERERWbhatWph69atcdZt3rxZrSciIiIiolfDihIiIiIiIqI0FhwcjMuXL8cs+/j44Pjx4/Dw8ED+/PlV26zbt29j/vz56vZBgwZh0qRJGD58OPr164dt27Zh2bJlWLduXYrHZjAYEBUVleKPS5mPnZ0dbGxs9A6DiIiI6IWYKCEiIiIiIkpjhw8fRqNGjWKWhw0bpn726dMHc+fOxd27d3Hjxo2Y2wsVKqSSIh999BEmTJiAvHnzYubMmWjRokWKxWQymdTQ+MePH6fYYxJlzZpVtY5LyhBVIiIiIr1YmWRvOJ0LDAyEu7u7GlAoPXqJiIiIiDI67gNTSn9mJDkjSRIvLy84Ozvzi216JfJVQ2hoKO7fv6+SJbly5dI7JCIiIspkApNxzMSKEiIiIiIiokxO2m2ZkyTZs2fXOxzKIJycnNRPSZbIZ4ttuIiIiMhScZg7ERERERFRJmeeSSKVJEQpyfyZ4twbIiIismRMlBAREREREZHCdluU0viZIiIiogyZKNm1axfatm2L3Llzqx2eVatWPXf7t956S20X/1KmTJmYbb766qtnbi9ZsuTLvSIiIiIiIiIiIiIiIqLUSpSEhISgQoUKmDx5cpK2nzBhghoKaL7cvHkTHh4e6Nq1a5ztJHESe7vdu3cnNzQiIiIiIiKiV1KwYEGMHz9e7zCIiIiIKA0le5j7a6+9pi5JJVPl5WImFSiPHj1C37594wZiawtvb+/khkNERERERESZ0ItaOn355Zeqe0FyHTp0CC4uLkgJf/75J3r16oVBgwYl+WRDIiIiIsoEM0pmzZqFpk2bokCBAnHWX7p0SbXzKly4MHr27IkbN26kdWhERERERESUTsTuSCAVIG5ubnHWffLJJzHbmkwmREdHJ+lxc+TIkWJD7eX4d/jw4SphEh4eDj1FRkbq+vxERERElixNEyV37tzBhg0b0L9//zjra9Sogblz52Ljxo2YOnUqfHx8UK9ePQQFBSX4OBEREQgMDIxzISIiIiJKU3eOAxf/1TsKokxLOhKYL9LFQCpMzMvnz5+Hq6urOv6sUqUKHBwcVHvnK1euoH379siZMyeyZMmCatWqYcuWLc9tvSWPO3PmTHTs2FElUIoVK4Y1a9a8MD45rt27dy9GjBiB4sWLY8WKFc9sM3v2bNWGWuLLlSsXhgwZEnPb48ePMXDgQBWro6MjypYti3/++UfdJpUyFStWjPNYErPEHnteaIcOHTB27Fh1UmKJEiXU+gULFqBq1arq/ZH36o033sD9+/fjPNaZM2fQpk0blXyS7eT4XN47mVlqZ2eHe/fuxdn+ww8/VNsQERFR5hUZbURAWBTuBYTDxz8EZ+4E4Mj1h/jvkh+uPwhBhmu99SrmzZuHrFmzqp212GK38ipfvrxKnEjFybJly/D2228/8zjjxo3D119/nSYxExERERE94+gCYN3HgI09MGA74FlM74iIUpRUYIRFGXR5bic7mxe21UoqSVL88ssvqnNBtmzZ1MzMVq1aqeSBJCfmz5+Ptm3b4sKFC8ifP3+ijyPHnz/99BN+/vlnTJw4UXVBuH79upq/mZg5c+agdevWKokj7bekukSSEmZykuCwYcPwww8/qGPigIAA7NmzR91mNBrVOjl5cOHChShSpAjOnj0LGxubZL3+rVu3qmTH5s2bY9ZFRUXh22+/VYkTSZBIDJJUWb9+vbr99u3bqF+/Pho2bIht27ap+0tcUpEj6+W9lGTLp59+GvN4ixYtUu8PERERWe6+XXiUUe3fhUZGI1z9NCAs0oDQKAPCI58sR2nrtO0MT7aLRpjcV/18er+YbZ9cjzaaEn3+T1uUwOBGRWHJbNPylyFny7z55puwt7d/7raSTJEzbi5fvpzg7SNHjlQ7c2ZSUZIvX74Uj5mIiIiIKI6ocGDDcODoPG25SGPAJYfeURGlODnYLT1mky7PffabFnC2T5lD1W+++QbNmjWLWZbERoUKFWKWJWGwcuVKVSESu5ojPkkk9OjRQ13//vvv8fvvv+PgwYNo2bJlgttLokO6JkhSRXTv3h0ff/yxqjIpVKiQWvfdd9+pdR988EHM/aTCRUiVizz+uXPn1LGxkARFcsmsFamGiX0M3q9fv5jr8pjyWuR5g4ODVZWNzFKR5M6SJUtU9YgwxyDkZEZJApkTJWvXrlVtxV5//fVkx0dERBmbfB8cGBatqgzkHAi5WFtZPbloVZvWsdZZWZuvaz8T2j6jijZoSYxnEhWJJDC05aeJi9iJD/O2cdan4QkwNtZWcLazgaO9DZztbdRJMO5O2j6FJUuzRMnOnTtV4iOhCpH4ZAdNynolqZIQOfNHLkREREREaebxDWDpm8Dd49KMB2g8Cqg7DLBO87F/RJRE0mIq/rGmtK1at26dmmMiVRJhYWEvnJEpnQ9iJx+kyiJ+u6rYpIIjJCREVa8IT09PlbCRkwclOSP3ldbUTZo0SfD+x48fR968eeMkKF5GuXLlnjlR8ciRI+o9OHHiBB49eqSSOkLeg9KlS6vnljZa5iRJQkmjUaNGYf/+/ahZs6ZKCEmSRN4XIiLKHMmPoIho+AdFwC8oAv7BkfALCn/yU5Yj4BccoW6XdZEG7e9MSomTWLFKILFi/ZxETELbx7/tSbIm7n2T8lixbrc2b6+tM5m0k1ASTmZIdYcxxd+n53GwtYaTJDHiJTOc7G3hZGetTlhxtIu9XvuplmOtk2VtO7nf09vsbdPn8VGyEyWyYxm70kPOiJEdKTkzR0qVpdpDSnWlhDk2KTOWllrSVzU+GbIn5c7Sbkt2Fr/88ktVUmw+Y4eIiIiISFeXtwJ/vw2EPQKcPIDOM4GiCX/BSZQRyEGuVHbo9dwpJf6X93LsKUkMacdVtGhRODk5oUuXLi8cdB4/aSBffpgTDAmR49+HDx+qxzeT7U+ePKnaeMVen5AX3W5tba2+qIpNWmC96PVL8qZFixbqIu2yZHC9JEhk2fwevOi5vby81PG7VJVIdYzMgdmxY8dz70NERJZN/qaERBq05MeTJMfTn7ESIE9+RkQn70t9RztrWMEKRpNJJQ3kp3ZJfqxyH7kv8BJ3TgckAeNsTlrYW8PZzlYlM8wJjPiJC8ckJDBibyc/peKDUiBRcvjwYTRq1Chm2dwCq0+fPupMEjkrJ/7ZONJr9e+//8aECRMSfMxbt26ppMiDBw/UjlrdunXV2SlynYiIiIhIN/JF6O7/AdvGagdjuSsBr88HsiY+y4AoI5BEQEq1v7IkMmtDKiJkMLv5RMBr166l6HPIce3q1atV6yoZ1G5mMBjUse6///6rWnbJ4HWZIRL7+Dp2BYscJ1+8eDHBqhI5VpaB6vLFlrkNiZzA+CIy5F7ik7ko5vbVcowf/7llvqgkXhKrKunfv786hpeqF5mfUqdOnSS8M0RElNakWsE/KFIlPeInO+JWf0QmuzVTFgdbeGaxRw5XB3hmcXjmZ+zb5Mv5xMjfMnPyI24iBTHLz93G+Gzy5cWP+fS+ydo+zuOb1KFCUrYXWhLDGk52kgBJuFpD3iep9sjILcYsWbL3fGWgW/wzV2KTZEl80t80NDQ00fvIDiQRERERkUUJewysHARc3KAtV+4DvPYTYOeod2RE9JKKFSuGFStWqIoI+RJi9OjRz60MeRky6Dx79uyqHVX8LzqkFZdUm0iiRNpfDRo0SFVomAe3SyJn6NChaNCggRqc3rlzZ/z666+q+kWSHPJ4cl85Lvfz81MD1KUiZuPGjaqyQ1qCPY90gZBWXDI7RZ779OnTqhVYbDKrRW6XuSrSMUKO5+VExurVq6sB8EIqUOS5ZM6KzIEhIqK0I+2b4iY7nlZ8xE+ESJVIcsgX9pLc0BIczyZB5OL15Lp8wZ8S5G+bjRVgI61tiXSU8U4RIiIiIiJ6VfdOA0t7AY98ABsHoPUvQOXeekdFRK9Ikg4yzLx27dpqbshnn32GwMDAFH0OmUMiFSsJnQ0qiQ+Zxenv76+6MsgQ9N9++021BJN4JOlhJl0ZZL1UbkjLLEmWSCWIKFWqFKZMmaIGy0uiQx5Xtp0+ffpzY5NKFDm58fPPP1dD3CtXrqzakLVr1y5mG0nybNu2TQ1rl4SNtMWuWLFinKoRaf0llTny/L17899GIqJXFRFtwIMEWlzFT4TIT5kPkhxSofA0+RHrZwKJEBcHflVMmZeV6XnlIemE7NjKWS7S4utFZ9AQERERET3XiaXA2g+A6DDAPT/Qbb7WcsvCcB+YUvIzI1/Yy/xJmTnh6MiqKXqxt99+W1W1rFmz5rnb8bNFRJlZYHgUbj8Kw72A8Oe0v4pEQNizc6aeR4Zl55AKD0mAZLFPsPWVuSpEWmSxlRNlVoHJOGZimpCIiIiISERHAps+Bw7N0JaLNNGGtjt76B0ZEZHFkC8aTp06hcWLF78wSUJElJEZjCaV6Lj9OBS3H4erhMidx2G4/fjJz0dhyar+sLOxSnTGR/yfbo5MfhClNCZKiIiIiIgCbgN/9QFuHdKWG3ymXaxTpvcyEVFG0b59exw8eFDNOGnWrJne4RARpZqwSAPuBITFSYCoiywHaFUiUYYXN+rxcLGHt5sjvNwSrvgwz/xwd7Jj8oNIR0yUpJBr/iEokN2Z/6ARERERpTc+u4Dl/YAQP8DRHeg4HSjRUu+oiIgs0o4dO/QOgYjolckkgochkbgjlSCJVIQ8CIl84ePYWlvB290RubM6IW9WJ/UzT7YnP9WyI5zt+fUrUXrA/1NTwIQtlzBx2yX83LU8OlbKq3c4RERERJQUMqpv7+/Alq8AkxHIWU6bR+JRWO/IiIiIiOgVRBmMquIjpgIkdkXIk0RIeJTxhY8j8z3MCY/YCRB1yeYEL1dH2FjzpGmijICJkhRga2OFaKMJ3/5zDg2LeyGbi73eIRERERHR84QHAqvfA86t1ZYr9ABa/wrYO+sdGRERERG9QJAMSY81C0RVhMRa9g0KV+fEvIi0vTInQGIqQmJVhnAWCFHmwURJChhQvzDWHL+DC75B+H79OfzctYLeIRERERFRYu6fB5b2Ah5cAqztgNd+BKr2A3gQTERERKQ7owxJD47ArQSGo5srQoLCXzwk3d7WOqb6Q1WEZHWOqQyRddIyy8GW8+iISMNESQqws7HG953KofPUvfjryC10qpwXtYpk1zssIiIiIorv9Apg9RAgKgRwywO8Ph/IW1XvqIiIiIgyjfAoQwIJEG1WiMwMuRsQlqQh6dmc7eJUgOSNMxvESQ1KZzUIESUVEyUppEqBbOhZIz8WHbiBL1aewvoP6sHRjllpIiIiIotgiAI2fwnsn6wtF6oPdJ4NZMmhd2REREREGVK0wYhTtwOw98oDnL4dEJMY8Q9+8ZB0mfvh7SZVIObh6E8rQiQhksvdCS4O/FqTiFIO/0VJQcNblsS/Z31x1T8EU3dcwUfNiusdEhEREREF+QJ/vQXc2Kst1/0IaDQKsOGuMBEREVFKtsw6fy8Ie6/4Y9+VBzjg8xDBEQm3yHKxt4kzHD1+RYjMDrG1sU7z10BEmRePDlOQu5MdvmpbBoMXH1WJkrYVcqOoVxa9wyIiIiLKvK7v05IkwfcAe1eg41SgVFu9oyIiIiJK90wmkzpZWCpG9j1JjjwKjXrmu7JahbOjasFsKJDdRasIyeoMNycOSSciy8JESQprVc4bjUt6Ydv5+/h85SkseacmrK35Dz8RERFRmjKZgAPTgH9HAcZoIEcpoNtCwLOo3pERUQp50RdsX375Jb766quXfuyVK1eiQ4cOSdp+4MCBmDlzJpYsWYKuXbu+1HMSEaUH0j5r72UtKSIJknuB4c9UilQv5IHaRTzV/N7Sudz4vRgRpQtMlKQw2aH+pn0Z9QfjoM9D/HXkJrpVy693WERERJQaIkMAazvA1l7vSCi2iGBg7fvA6b+15bKdgba/Aw6s9CXKSO7evRtzfenSpRgzZgwuXLgQsy5LlrT5fz40NFQlSIYPH47Zs2frniiJjIyEvT3/LhFRyvALisC+q1rFiCRGrj8IjXO7va01quTPhtpFsqN2UU+Uz+sOO7bMIqJ0iP9ypYK82Zwx7Ml8ku/Xn4d/cITeIREREVFKVyscnQ/8Uhz4tSSw82cg9KHeUZHwvwzMbKolSaxtgZY/Ap1nMUlClAF5e3vHXNzd3dVJa7HXSfKiVKlScHR0RMmSJTFlypQ4yYQhQ4YgV65c6vYCBQpg3Lhx6raCBQuqnx07dlSPaV5OzF9//YXSpUtjxIgR2LVrF27evBnn9oiICHz22WfIly8fHBwcULRoUcyaNSvm9jNnzqBNmzZwc3ODq6sr6tWrhytXrqjbGjZsiA8//DDO40mVy1tvvRWzLPF9++236N27t3qMAQMGqPXynMWLF4ezszMKFy6M0aNHIyoqbkuctWvXolq1auo98PT0VK9ZfPPNNyhbtuwzr7VixYrqcYgo4woIi8KmM/fw1ZozaP7bTlQbuwXv/3kMfx68qZIkMmS9cv6sGNKoKBb3r4GTXzbHnwNqYmiTYqhSIBuTJESUbrGiJJX0rVMQq47fxpk7gfjun7MY372S3iERERFRSgj2A9Z+AFxYpy1HBgPbvwN2/wZUeQuoNRhwz6N3lJnTubXAyneByCAgS06g6zygQC29oyJKvwnhqLhnDacZO2cp1X+lh1i0aJGqMJk0aRIqVaqEY8eO4Z133oGLiwv69OmD33//HWvWrMGyZcuQP39+ldwwJzgOHToELy8vzJkzBy1btoSNjc1zn0uSHr169VLJmtdeew1z586Nk0yQBMa+ffvUc1aoUAE+Pj7w9/dXt92+fRv169dXCZFt27apRMeePXsQHZ3w8OPE/PLLL+r1SrsxM0m6SCy5c+fGqVOn1OuXdVL5ItatW6cSI1988QXmz5+vkkfr169Xt/Xr1w9ff/21ei8kkSLkPTx58iRWrFiRrNiIyLKFRkbj0LVHMQPYT98OgNH09Hb551jaZ6mKkSKeqFbIA1kc+HUiEWU8/JctldjaWGNcp3LoMHkPVh2/g85V8qJesRx6h0VERESv4sJGYM0QIMRPa7nVeBTgnhfYPR7wPQXsnwwcnA6Ufx2o8wGQo4TeEWcOhmhg27fAnvHacv7aQNc5gKu33pERpV+SJPk+tz7P/fkdwN7llR5CEgb/+9//0KlTJ7VcqFAhnD17Fn/88YdKlNy4cQPFihVD3bp1VdWIVJSY5cihHbdlzZpVVaY8z6VLl7B///6Y5IEkTIYNG4ZRo0apx7148aJKxmzevBlNmzZV20h1h9nkyZNVgkWqX+zs7NQ6qQJJrsaNG+Pjjz+Os05iiF118sknn8S0CBNjx45F9+7dVULETBI5Im/evGjRooVKFpkTJXK9QYMGceInovQnItqAYzcexwxgP37zMaIMsTIjAIrkcFFJEUmO1CycHdlc2M6PiDI+JkpSUfm8WdGndkHM2XMNX6w8jU0f1oeT/fPPRiIiIiILnXnx7xfAkbnasldpoNN0wLvc0xkYl7dqX9Rf+w84vki7lGgN1P0QyFdd1/AzfIXP3/0An13acs3BQLOvARvtC0ciynxCQkJU66q3335bVVGYSZWGJCWEtK5q1qwZSpQooapGpPVV8+bNk/1cMpNEEgrStkq0atVKPa9UhzRp0gTHjx9XFSmSYEiI3C6ttsxJkpdVtWrVZ9bJ3BapYpH3Ijg4WL1+qViJ/dyx35/45DapLPn1119hbW2NxYsX47fffnulOIko7UUbjDh1O+BJYuQBDl17iIhoY5xt8mR1Qp2i2WMGsOd0c9QtXiIivTBRkso+bl4CG0/fw42Hofh92yV81rKk3iERERFRctw8BKwcADy8qi3XGgI0Hg3YOcbtSVCsqXa5dVhrw3V+ndaeSy5S4VD3I6BYs1duJ0OxyHu9rDcQeBuwcwHaTwLKamePE1EKtL+Syg69nvsVSFJAzJgxAzVq1Ihzm7mNVuXKlVULrA0bNmDLli14/fXXVcXH8uXLk/w8BoMB8+bNw71792BraxtnvSRQJFHi5OT03Md40e2SoDBJG7RY4s8ZEdJSLDZp9dWzZ09VLSKJHHPVilTZJPW527Ztq2aqrFy5Ug2Hl+ft0qXLc+9DRPozGk244BsUUzFy4OpDBEXEbefnmcXhSSstLTmSz8NJVcEREWVmTJSkMunb+HW7Mhiw4Ahm7LqK9hVzo6T307N4iIiIyEIZooBdPwO7fgFMBsAtL9BhClA44bOCY+StCnRfBPhfAvZMAE4sAW7sBRbvBbzKaC255Mt8Vjy8PPnS8PBsYMNngDEKyF4M6LYQ8OIJKUQpRr4we8X2V3rJmTOnmstx9epVlSxIjFRXdOvWTV0kASCVJQ8fPoSHh4eq8JCEx/PIPI+goCA1uyP2HJPTp0+jb9++ePz4McqVKwej0YidO3fGtN6KrXz58irZIkmIhKpKpA3Y3bt3Y5YlJnn8Ro0aPTe2vXv3qnZiMn/E7Pr1688899atW1WsCZHkj7Qpk5ZbkiiRNl0vSq4QUdqTZKqPf0hMxci+qw/wMCQyzjZujraqUsTcTquoVxYmRoiI4mGiJA00L+ONFmVyYtMZX3y+4hSWD6oNa2v+QSIiIrJYkuRYMQC4c1RbLvc60OpnwClr0h/Ds5hW4dDoc2D/FODwHOD+Ga06Zdt3QO0hQKVe6faLSN1EhgLrhgEn/tSWS7UF2k8BHHkiChE9JZUU77//vqqkkARIREQEDh8+jEePHqkZItJOKleuXGrQu1Rt/PXXX2oeicwlMc/0kCRCnTp1VFVFtmzZEhzi3rp165i5HmalS5fGRx99pAbKDx48WCUbpIWVeZi7JCzu37+vqliGDBmCiRMnqiTEyJEjVbwy86R69eqqLZjMHpF4ZfB6kSJFVNySgHkRmb8ic1ikikRmjMj9pTIk/hwXqXqRx5Xnl9Zckvz57LPPYrbp378/SpUqpa7LkHkisgy3H4dh72Vt+LokSO4Fhse53dneBtUKeqikSJ2iniiVyw02/B6KiOi5mChJI1+3K4s9lx/g6I3HWHTwBt6s+XRYIBEREVlSpcIsYNMoIDoMcHQH2vymzSB5WW65gebfAfU+Bg7NAg5MAwJuABuGAzt+AGoMBKoPAJw9UvKVZEzS/mxpb8D3FGBlDTT9Cqj9PtuZEdEz5At+Z2dn/Pzzz/j0009Vayqp7vjwww/V7a6urvjpp5/UMHapBpFkgiQJJGkipEWVJCikfVeePHlw7dq1OI/v6+urkg8ytyM+eYyOHTuqRIokSqZOnYrPP/8c7733Hh48eID8+fOrZZE9e3Y1z0RilDkmEkvFihVVgkZIguXEiRPo3bu3qvCQBMyLqklEu3bt1LaSiJEkkSR0Ro8eja+++ipmm4YNG6oE0bfffosffvhBVdjUr1//mYRL7dq1VaVN/DZmRJR2/IMjYpIi0k7r2oPQOLfb21ijcoGsMRUjMjPX3lb794yIiJLGyhS/4Wk6FBgYqM68CQgIiDOcztLM23sNX645A1cHW2z5uAGHYxEREVmSoHvA6iHA5c3acqEGQIepgHuelH2eqDDg+GJg7+/Ao2tP+/FX7gPUGgxkzZeyz5dRXNwErHgHCA8AnD2BrnOAQnG/0Mts0ss+MKWPz0x4eLia2VGoUCE4OvI4hTTydYEkSyTJI4mjl8HPFlHyBYRF4cBVc2LkgZo5EpsUh0gyxDyAvUqBbHC0e9oCkIiIkn/MxIqSNNSrZgGsOHYbJ24+xtdrz2BKzyp6h0RERETi7Bpg7QdA2EPAxgFo9jVQfaCcFpzyz2XnBFR7W0uMnFsN7B4P3DsJHJgKHJoBlOuqzTHx0lqdZHpGA7DzR+0i8lYDus5L+QQWERHF4efnp1p3ybD6xOaYEFHKCI2MxqFrj7D3itZO6/TtABjjndYs7bPMA9irFfKAmyPn3RERpSQmStKQ9IMc17Ec2k7ajfWn7mHrOV80KZVT77CIiIgyr/BAYOMI4Pgibdm7HNBpZtoMBbex1Vp6lekEXN0O7P4N8Nmlzd6QS/GWQJ0PgQK1kGmFPgT+7g9c2aotV3sHaPE9YGuvd2RERBmel5cXPD09MX369ARntBDRy4uINuD4jccxFSPHbj5ClCFuZqSwpwtqP6kYqVk4OzxcuP9DRJSamChJY6Vzu6F/3UL4Y9dVjFl9Rv2xc3Hgr4GIiCjNXd8LrBwIPL4h3UiBuh8BDUem/ZfwMl+jSGPtcvsIsGeCVuFycaN2yVcTqPshUKxF6lS4WKo7x7R5JDLPxdYJaDseqNBd76iIiDKNDNClm8hiGIwmnLodEFMxcujaQ4RHGeNsk9vdEbWLajNGahXJjlzuTrrFS0SUGfEbeh180LQY1p26i1uPwvDb5osY1aa03iERERFlHtGRwI7vtZZXMAFZ8wMdp1tG5UaeKsDr8wH/y9oME6ksubkf+LM7kKOU1pKrXBfAJoO3Wji6AFj3MWCIALIVArotBLzL6h0VERERUbJtv3Af3/1zFlf8QuKs98xij1pPhq/LJb+HM6zkBBoiItIFEyU6cLa3xbcdyqLvnEOYvccHHSrlQdk87nqHRURElPHdP6cNBL93Sluu2AtoOQ5wtLBB2J5FgXa/A40+B/ZPBQ7PBvzOAasGAdu+04a+V+4NOGRBhhIVDmwYDhydpy0Xfw3oOA1wyqp3ZERERETJcvl+ML5bdxY7Lvip5SwOtqpSREuMeKJ4zixMjBARWRAmSnTSqIQX2pTPhX9O3sXIFaew8r3asLXJRO00iIiI0pLRCByYBmz5SqtScPIA2k4ASreDRXP11gbL1xumJUv2TQECbwGbRgK7fgKqD9CGzrtkR7onLdCWvgncPa61Qmv8BVD348zVbozIAhjl30uiFMTPFGU2AaFRmLD1Eubvu4Zoowm21lZ4q3ZBDG1SDO5OGbwqmIgoHWOiREdj2pbGrot+qk/l/H3X0a9uIb1DIiIiyngCbgOr3gV8dmrLRZsB7ScDrjmRbji6azNUaryrteOStlwPrwI7fwT2/K5Vl9QeorURS48ubwX+fhsIewQ4ZQM6zwKKNtE7KqJMxd7eHtbW1rhz5w5y5MihlnmmM73qjJPIyEj4+fmpz5Z8pogysmiDEX8euolf/72AR6FRal2Tkl74onUpFM6RwaqAiYgyICtTBpjQFhgYCHd3dwQEBMDNzcJaZ7zA4gM38PnKU3Cxt8HmYQ2QOyuHdREREaWYU8uBdcOA8ABtIHiLsUDVftoA9fTMaADOrdHmrKgKDNmrswHKdtYGv+csg3RBzjLe/T9g21htXkyuikC3Bek34ZPG0vM+MFnmZ0a+1L579y5CQ0N1iY8yJmdnZ+TKlYuJEsrQ9lz2xzdrz+KCb5BaLuqVBaPblEaD4jn0Do2IKFMLTMYxExMlOjMaTXj9j304fP0RmpbKiRm9q/DMLSIiolcllQnrPwVO/aUt564MdJqhzf7ISGQ3TiplJGFydfvT9cWaA3U+BArUttykUNhjYOUg4OIGbVmqYl77GbBz1DuydCM97wOT5X5m5PAwOjoaBoMhzeOjjMfGxga2trY8xqUM6/qDEIxddw7/nvVVy9Ja66OmxdCzZgHYsb06EVG6OmZi6y2dWVtbYVyncmj1+3/Ycs4Xm87cQ8uyufQOi4iIKP26ulNrtRV4W6uyqP8pUP8TwCYD9oSWL54KN9Qud44BeyYAZ1cDl/7VLnmraS27ZCi6Jc36uHcaWNoLeOQD2DgArX4GqvTROyoiUv+sWMHOzk5diIgoYUHhUZi0/TLm7L6GSIMRNtZW6FUjPz5sWhzZXFg9RUSUHjFRYgGK5XTFwPpF1B/ZL9ecQZ2innB15IEJERFRskSFA1u/AfZP1pY9igCdpgN5qyJTyF0J6DoXeHAF2DsROL4YuHUIWPIG4FkCqPMBUK4rYKvzwfuJpcDaD4DoMMA9P9BtvhY7ERERkYUzGE1YfuQmft50Ef7BEWpdvWKeqs1W8ZyueodHRESvwIJOLczchjQuioLZneEbGIFfNl3QOxwiIqL05d4pYHrDp0kSmUMy6L/MkySJLXsRoO144MNTQN1hgIM74H8BWP0e8HtFYO8kIELrn52moiOBdZ8AKwdoSZIiTYCBO5kkoUxt8uTJKFiwIBwdHVGjRg0cPHgw0W2joqLwzTffoEiRImr7ChUqYOPGjWkaLxFRZnbQ5yHaT96Nz/4+pZIkhTxdMKtPVczvV51JEiKiDICJEgvhaGeDsR3Lqevz91/HsRuP9A6JiIgofQw1l/kc0xsBfucAFy/gjWVAm98Aexdkaq45gaZfAh+dBpp9A2Tx1tqR/fsF8FsZYNt3QLBf2sQScBuY2wo4NENbrj8c6PkX4OyRNs9PZIGWLl2KYcOG4csvv8TRo0dV4qNFixa4f/9+gtuPGjUKf/zxByZOnIizZ89i0KBB6NixI44dO5bmsRMRZSa3HoVi8OKjar7s6duBcHWwxRetSmHTh/XRpFROzuAhIsogOMzdwgxbdhwrjt5GSW9XrB1al8O/iIiIEvPoujaL5PoebblkG6DtBMDFU+/ILFN0BHBiCbD3d+DBZW2drSNQqRdQeyiQrWDqPK/PLmB5PyDET6tukXZoJVqmznNlMhlpHzgzkgqSatWqYdKkSWrZaDQiX758GDp0KEaMGPHM9rlz58YXX3yBwYMHx6zr3LkznJycsHDhwiQ9Jz8zRERJFxoZjak7rmD6rquIiDaq0XDdq+XHx82LwzOLg97hERFREnCYezo2qnVpbD9/H+fvBWHWbh8MalBE75CIiIgsi5zjIV/4r/8UiAwC7LMAr/0IVOypDTenhNk6aAPTJTFyfh2wZzxw+whwaCZweA5QpiNQ90PAW6twTZHfkyRltnwFmIxAznLaPBKPwinz+ETpWGRkJI4cOYKRI0fGrLO2tkbTpk2xb9++BO8TERGhWm7FJkmS3bt3J/o8ch+5xD5QJCKi5zMaTVh94jZ+2HBetUcXNQt7YEybMiidm0lmIqKMiuUKFsbDxR6ftyqlro/fchE3H4bqHRIREZHlCH0ILOsNrBqkJUny1QQG7da+/GeSJGmsbYDS7YD+W4E+a7VZISYDcHo5MK0usLAz4POfluh4WeGBwLI3gc1jtCRJ+e7A2/8ySUL0hL+/PwwGA3LmzBlnvSzfu3cvwftIW65ff/0Vly5dUtUnmzdvxooVK3D37t1En2fcuHHqDDrzRSpWiIgocdIGvdPUvfho6QmVJMmbzQlTe1bGn+/UZJKEiCiDY6LEAnWpkhe1CmdHeJQRo1adRgbojkZERPTqLm0BptQCzq0BrG2BJmOAvusBj0J6R5Y+SWKpUH3gzRXAwF1A2c6AlTVweQswrw0wswlwbq2cVpm8x71/HpjRWLuvtR3Q+n9Ax2mAvXNqvRKiTGHChAkoVqwYSpYsCXt7ewwZMgR9+/ZVlSiJkYoVaTNgvty8eTNNYyYiSi/uBYTjo6XH0XHKXhy/+RjO9jb4tEUJbBnWAK+Vy8U5JEREmQATJRZI/gCP7VgW9rbW2HnRD2tPJn6WGBERUYYXGQqs+wRY1BkIvgd4ltCqIep9rFVH0KvLVQHoMhsYehSo1l+bXSJtuZb2AiZXB47O12acvMjpFVqS5MElwDU30HeD9nj8coEoDk9PT9jY2MDX1zfOeln29vZO8D45cuTAqlWrEBISguvXr+P8+fPIkiULChdOvFLLwcFB9WKOfSEioqfCowz4feslNPplB1Yeux1z8uqOTxpicKOicLTjviYRUWbBRImFKpwjC4Y0Kqquf7P2DAJCo/QOiYiIKO3dPgr8UR84NENbrjEIGLgTyF1R78gyJqnOkQqQD08D9T4BHN21pMeaocCECsCe37W2WvEZooCNnwPL+wJRIUDBelqVSr5qerwKIosnFSFVqlTB1q1bY9ZJOy1ZrlWr1nPvK3NK8uTJg+joaPz9999o3759GkRMRJSxSOeOf07eQZP/7cSvmy8iLMqAKgWyYc2QOvilawV4ucWdCUVERBlfshMlu3btQtu2bZE7d25V+SBnNT3Pjh071HbxL/F7706ePBkFCxZUO/41atTAwYMHkdkNbFAYRXK4wD84Ej9sPKd3OERERGnHEA3s/AmY1exJdUIu4M2V2tB2Oye9o8v4suQAmowGPjoDNP9Oqw4JugtsHg38VhbY8jUQfF/bNsgXmNcO2D9ZW67zIfDmKu0xiChRw4YNw4wZMzBv3jycO3cO7777rqoWkXZaonfv3nGGvR84cEDNJLl69Sr+++8/tGzZUiVXhg8fruOrICJKf07fDsDrf+zDkMXHcPtxGHK5O+L3HpWwfFAtlM+bVe/wiIhIJ7bJvYPsvFeoUAH9+vVDp06dkny/CxcuxCn19vLyirm+dOlSdaAwbdo0lSQZP368GlYo94m9XWbjYGuDcZ3Kqz/gfx68iU6V86JaQQ+9wyIiIkpdD64AKwcCtw5py2U6Aq1/BZz5NzDNObgCtYcC1QcCp5YBeyYA/heB3b8C+yYD5btqs2OkJZq9K9BhijYonoheqFu3bvDz88OYMWPUSWQVK1bExo0bYwa837hxI878kfDwcIwaNUolSqTlVqtWrbBgwQJkzcov9YiIkuJ+UDh+2XQBfx25BRkF62hnjUENimBg/SJwsmeLLSKizM7K9AqTwqUyZOXKlejQocNzK0oaNWqER48eJboTL8mRatWqYdKkSWpZzozKly8fhg4dihEjRrwwjsDAQLi7u6sBhRmx7+6Iv09iyaGbKOaVBever6dmlxAREWU4sktydJ7WwknaNzm4A61/Acp15YwLSyGD3S+sB/aMf5rIEjlKAt0WAp7F9Iwu08no+8CU8viZIaLMKCLagNm7r2Hy9ssIjohW69pXzI3PWpZE7qysVCYiysgCk7H/m+yKkpclZ0hFRESgbNmy+Oqrr1CnTh21PjIyEkeOHIlTVi5nTjVt2hT79u1L8LHkceQS+wVnZCNfK4Ut53xx6X4w/th5BUOb8EsIIiLKYKSN05r3gYsbtGWZcdFhKpA1n96RUWxydnupNkDJ1sD1vcCBaYBzdq09l0MWvaMjIiIiiiHnBf971hdj153DjYehal35vO74sm1pVCnASmUiIkrjREmuXLlUS62qVauq5MbMmTPRsGFD1WO3cuXK8Pf3h8FgiCkxN5Pl8+fPJ/iY48aNw9dff43Mwt3ZDqPblMYHS45j4vbLaF0+lxr2TkRElCGcX68NCw/1B2zsgSZjgJqDtS/lyTJJhU/BOtqFiIiIyMKcvxeIb9aexd4rD9Syl6sDhrcsiU6V8sDampXKRESkQ6KkRIkS6mJWu3ZtXLlyBb/99pvqqfsypPpEZprEriiRVl0ZWbsKubH8yC38d8kfo1adxqL+NVTrMyIionQrIhjYNBI4Ol9b9ioDdJ4B5Cyjd2RERERElA49CI7Ar5sv4s+DN2A0QbUuf6deIbzXsChcHNKsqQoREaVDuvyVqF69Onbv3q2ue3p6wsbGBr6+vnG2kWVvb+8E7+/g4KAumYkkRcZ2KIfm43eqMyJWHL2NzlXy6h0WERHRy7l5EFjxDvDomvyVA2oPARqPBmwz1993IiIiInp1UQYj5u+7jvFbLiIoXJtD0qqct2plns/DWe/wiIgoHdClp8Xx48dVSy5hb2+PKlWqYOvWrTG3yzB3Wa5Vq5Ye4Vms/Nmd8UGT4ur6d+vO4mFIpN4hERERJY8hCtj2HTC7hZYkcc8H9FmrzbhgkoSIiIiIkmn7+ftoMX4Xvv3nrEqSlM7lhiUDamJKzypMkhARUepVlAQHB+Py5csxyz4+Pirx4eHhgfz586u2WLdv38b8+VobjfHjx6NQoUIoU6YMwsPD1YySbdu24d9//415DGmj1adPHzXHRKpN5D4hISHo27dvcsPL8PrXK4TVx2/j/L0gNZDsf69X0DskIiKipPG7qFWR3D2uLZfvDrT6CXB01zsyIiIiIkpnLt8Pwrf/nMPOi35qObuLPT5pUQKvV80HG84hISKi1E6UHD58GI0aNYpZNs8KkUTH3LlzcffuXdy4cSPm9sjISHz88ccqeeLs7Izy5ctjy5YtcR6jW7du8PPzw5gxY3Dv3j1UrFgRGzdufGbAOwF2Ntb4vlM5dJ66F38fvYXOlfOgdlFPvcMiIiJKnMkEHJwBbB4NRIcDjlmBtuOBMh31joyIiIiI0pmA0CiM33oRC/ZdR7TRBDsbK/StUwhDGheFm6Od3uEREVE6ZWUyybcX6ZsMc3d3d0dAQADc3NyQGYxedRoL9l9HIU8XbPigHhztbPQOiYiI6FmBd4HVg4ErT1psFmkMtJ8MuOXWOzKidC8z7gPTq+FnhojSs2iDUQ1pl2Htj0Kj1LqmpXLii9al1HcjREREr7L/q8swd3p1n7YsgU1n7sHHPwRTtl/GsOYl9A6JiIgorjOrgH8+BMIeAbaOQLNvgGrvANa6jEgjIiIionRq9yV/NYPkgm+QWi6eMwtGtymNesVy6B0aERFlEEyUpFNSTvp1uzJ4d9FRTN15BW0r5EaxnK56h0VERASEBwAbPgNO/Kkt56oAdJoB5GBSn4iIiIiS7pp/CL5bdw5bzvmq5azOdhjWrDjeqJ4ftjY8+YaIiFIOEyXpWMuy3mhaygtbzt3H5ytPYemAWrDmwDIiItLTtT3AykFAwA3AyhqoOwxo8Blga693ZERERESUTgSFR2HStsuYvccHUQaTGs7+Zs0C+LBpMWR15n4lERGlPCZK0jErKyt83b4s9l7ZiUPXHmHp4ZvoUT2/3mEREVFmFB0BbPsO2DtRprcD2QoCHf8A8tfUOzIiIiIiSicMRhP+OnwTv/x7Af7BkWpdg+I5MLpNKRT1YhcNIiJKPUyUpHN5sjqpslMpRR23/pwaZJbD1UHvsIiIKDPxPQusGAD4ntKWK70JtBwHOPBgloiIiIiS5sDVB/jmn7M4cydQLRfO4YLRrUujUUkvvUMjIqJMgImSDOCt2gWx6vhtnL4dqIab/d6jkt4hERFRemcyAVFhQFQoEBmiXdT1YCDyybqoEODRdWDfJMAQCThnB9r+DpRqo3f0RERERJRO3HwYinEbzmH9qXtq2dXRFh80KYbetQrC3pZzSIiIKG0wUZIByACzHzqVR7tJu7HmxB10qpwHDUvwjAsiokzBaNQSFip5ERw3sZFYciMyoe0TuL+00EqqYi2A9pOALPz7Q0REREQvFhIRjak7rmD6f1cRGW2EjFyVduLSNSN7FnbKICKitMVESQZRNo87+tYphFm7fTB69Wn8+2EDONnb6B0WERGZGaJeInkRe/tE7hsdlvqx2zoB9i6AvTNgnwWwc36y/ORSpAlQobsMz0r9WIiIiIgoXTMaTVh57DZ+2nQevoERal3tItkxuk1plMrlpnd4RESUSTFRkoHIWRcbTt3FzYdhGL/1Ika+VkrvkIiIMjZJVhyYCjy8GivRkUjiQ1pTpSqrp4kLlcjI8iSxkdCyy/MTH7G3l+vWTLwTERER0as7cv2RmkNy4uZjtZzfwxlftC6F5qVzwoon3RARkY6YKMlAXBxs8U37sug//zBm/ueDDhXz8GwMIqLU4ncR+KsPcP9s8u5nZfMkCeHycomLxLa3c2JFBxERERFZpHsB4fhhwzmsOn5HLbvY22Bok2LoW6cgHGx5Ug4REemPiZIMpmnpnHitrDc2nL6HkStO4e93a8NGGn0SEVHKObUcWPuBVi2SJSdQrT/g4Ja0xIeNPRMaRERERJRp7Lroh/eXHMPj0Ci1G9y1Sl580qIEvFwd9Q6NiIgoBhMlGdBX7cpg9yV/HL/5GIsOXEfvWgX1DomIKGOIjgA2jgQOz9KWC9YDOs8CXHPqHRkRERERkUUxmUyYuvMKftl0AUYTUC6PO77vWA7l8rrrHRoREdEzrJ9dReldTjdHDG9ZQl3/aeMFVeJKRESv6NE1YFbzp0mSep8Ab65ikoSIiIiIKJ7giGi8t+io+k5CkiTdq+XDX4NqMUlCREQWi4mSDOqNGgVQMV9WtXPy9dozeodDRJS+nV8P/FEfuHsccPIAei4HmowGbFiYSUREREQU21W/YHScvEe1BLe3sca4TuXwQ+fycLTjLBIiIrJcTJRkUDKXRHZGbK2t1M7JlrO+eodERJT+GKKAf0cBS3oA4QFA3mrAoP+AYs30joyIiIiIyOJsPuuL9pP24NL9YHi7OWLJwJroUT2/3mERERG9EBMlGVipXG7oX6+wuj5m9WmERETrHRIRUfoRcBuY2wbYO1FbrjkYeGs94J5X78iIiIiIiCyK0WjCr/9ewDvzDyMoIhrVC3pg7dC6qJw/m96hERERJQkTJSkh2A9YMRAIfQhL80GTYsjn4YQ7AeH4378X9Q6HiCh9uLwV+KMecHM/4OAGdFsItPwesLXXOzIiIiIiIosSEBqFt+cdwu/bLqvlt2oXxKJ3aiCHq4PeoRERESUZEyUpYdW7wMklwIzGgJ9lJSOc7G3wXYdy6vrcvT44dStA75CIiCyX0QBs/x5Y2BkIfQB4lwcG7gRKtdU7MiIiIiIii3P+XiDaTd6N7Rf84GBrjd+6VcBX7crAzoZfNxERUfrCv1wpodk3QNb8wCMfYGZT7UxkC9KgeA60q5AbRhMwcuVJRBuMeodERGR5gu8DCzoCO38EYAKq9AXe3gx4aC0MiYiIiIjoqbUn7qDj5L24/iAUebM54e93a6NjJbapJSKi9ImJkpSQszTwznYgfy0gIgBY1BU4OAOWZHSb0nBztMXp24GYu/ea3uEQEVmWa3uAafUAn52AnQvQaQbQdjxg56h3ZEREREREFkVOvhy77iyG/nkMYVEG1CvmibVD6qJsHne9QyMiInppTJSkFBdPoPdqoMIbgMkArP8EWPcxYLCMAerSG/TzVqXU9V83X8Ttx2F6h0REpD+jEdj9GzCvLRB8D8hREhiwHSj/ut6RERERERFZnAfBEeg9+yBm/Oejlt9tWARz+1ZHNhfO8iMiovSNiZKUZOsAdJgCNP0agBVwaCawqAsQ9hiW4PWq+VC9oAdCIw0Ys+o0TCaT3iEREekn9CGwpAew5SstwV2+G/DONiBHCb0jIyIiIiKyODLztN2kPdh75QGc7W0wtWdlfNayJGysrfQOjYiI6JUxUZLSrKyAuh8C3RYCds7A1e3a3JIHV/SODNbWVvi+U1nY2Vhh6/n72HD6nt4hERHp49YR4I8GwMWNgI0D0HYC0PEPwN5F78iIiIiIiCzOX4dvovO0vao7RWFPF6weXAevlculd1hEREQphomS1FKqDdBvE+CWB3hwCZjRGPD5T++oUNTLFe82KKKuf7XmDALDo/QOiYgo7Ugl3YE/gNktgIAbQLZCQP8tQJW3tEQ3ERERERHFiIw2YtSqU/h0+Ul1vWmpnFg1pA6K5XTVOzQiIqIUxURJaspVXhvynqcKEP4YWNABODJP76jwXqOi6gyQ+0ER+HnjBb3DISJKG+GBwF9vARuGA8YooFQ7YOBO7d9qIiIiIiKKwzcwHD1m7MfC/TfUOUXDmhXH9DerwM3RTu/QiIiIUhwTJanNNSfw1jqgbGfAGA2sfR/Y+DlgNOgWkqOdDb7rWFZdX3jgOo5cf6RbLEREaeLeKWB6Q+DsKsDaFmj5A/D6fMDRXe/IiIiIiIgszuFrD9Fm4m71fYGroy1m96mG95sUUy29iYiIMiImStKCnRPQeRbQ6Attef9k4M/u2tnNOqldxBNdquRVXWg+X3EKUQajbrEQEaUa+Ufu6HxtVtTDK4BbXqDvRqDmu2y1RUREREQUj8lkwoJ919B9+n74BUWgRE5XrB1SF41KeukdGhERUapioiStyBdyDYYDXeYAto7ApX+1HvmPrusW0uetSiGbsx0u+AZh5n8+usVBRJQqIkOAVe8Ba4YC0eFAsebAoP+AfNX0joyIiIiIyOKERxnULJLRq88g2mhC6/K5sOK92ijo6aJ3aERERKmOiZK0VrYT0Hc9kMUbuH9WG/J+Y78uoXi42GNU69Lq+oStF3HjQagucRARpTi/i8CMJsCJxYCVNdBkDNBjKeDsoXdkREREREQW59ajUHSdtg/Lj9yCdNf6vFVJTOpRCS4OtnqHRkRElCaYKNGDDHd/ZxvgXR4I9QfmtQWO/6lLKJ0q50GdotkRHmXEF6tOqTJbIqJ07dRybR6J3zkgS06gz1qg3seANf/kERERERHFt/eyP9pN2oNTtwNU14kFb9fAgPpFYMVWtURElInwWyO9uOcB+m0ESrUFDJHAqkHAlq8AY9rOCpEdn+86lIO9rTX+u+SPNSfupOnzExGlmKhw4J9hwN9vA1EhQMF6wMD/gIJ19Y6MiIiIiMjiyImS03ddQa9ZB/AwJBLl8rhj7dC6qFPUU+/QiIiI0hwTJXqydwG6ztfOdBa7fwOWvQlEBKdpGIU8XfB+46Lq+jdrz+JxaGSaPj8R0St76APMbg4cnqUt1/8U6L0acM2pd2RERERERBYnJCIaQ/48hu/Xn4fRBHSpkhd/DaqFvNmc9Q6NiIhIF0yU6M36Se/8jtMBG3vg/D/AnJZAwK00DUPKaot5ZcGDkEj8sOF8mj43EdErOfcP8EcD4O4JwMkD6Pk30HgUYG2jd2RERERERBbnmn8IOk3Zi3Un78LW2grfti+Dn7uUh6Md95+JiCjzYqLEUlToBry1DnDJAdw7pQ15v3UkzZ5eWm9936mcur7k0E0c9HmYZs9NRPRSDFHApi+ApT2BiAAgb3Vg0H9AsaZ6R0ZEREREZJG2nfdF20m7ccE3CDlcHbB0YE28Wasg55EQEVGmx0SJJclXXRvy7lUGCPYF5rbShhKnkWoFPdCjen51feSKk4iINqTZcxMRJUvAbWBua2DfJG251hCg73rAPa/ekRERERERWRyj0YQJWy7h7XmHERQejSoFsmHd0LqoUsBD79CIiIgsAhMlliZrfuDtTUDxlkB0uDaUePv3MmUtTZ5+RMuS8MzigCt+IZi242qaPCcRUbJc3gr8UQ+4eQBwcAe6LQRajAVs7PSOjIiIiIjI4gSGR2HAgiP4bctF9dXCmzUL4M93asLLzVHv0IiIiCwGEyWWyMEV6L4YqD1UW975I7C8LxAVlupP7e5shy/bllbXJ2+/jCt+aTtYnogoUUYDsG0ssLAzEPoA8C4PDNwBlGqrd2RERERERBbpkm8QOkzagy3nfFXLbZlF8m2Hsuo6ERERPcW/jJZKhhA3/w5oNwmwtgPOrATmtAKC7qX6U7cpnwsNiudApMGIL1aegimNqlmIiBIVfB9Y0AHY9RMAE1C1H/D2ZsCjsN6RERERERFZpPWn7qL95D246h+C3O6OWD6oFrpWzad3WERERBaJiRJLV/lNoPcqwCkbcOcoML0RcPdEqj6lDHH7rkNZONpZY//Vh1h+5FaqPh8R0XNd2wNMqwf47ALsXIBOM4E2vwF2bBVARERERBSfwWjCDxvO471FRxEaaUDtItmxdmhdlM+bVe/QiIiILBYTJelBwbrakHfP4kDQHWB2S+DsmlR9ynwezvioaXF1fez6c3gQHJGqz0dE9AyjEfjvV2BeGyD4HpCjJDBgO1C+q96RERERERFZpEchkXhrzkFM23lFLQ+oXxjz+1VH9iwOeodGRERk0ZgoSS+kvUz/LUCRJkBUKLDsTeC//6XqkPd+dQuhVC43PA6Nwth151LteYiInhH6EPizO7D1a8BkBMp31xLGOUroHRkREVGKmTx5MgoWLAhHR0fUqFEDBw8efO7248ePR4kSJeDk5IR8+fLho48+Qnh4eJrFS0SW7fTtALSZuBv/XfKHk50NJvaohM9blYKtDb/6ISIiehH+tUxPHN2BN5YB1Qdqy1u/AVYOBKJS5+DIzsYa4zqVg5UVsOLYbey57J8qz0NEFMetw8Af9YFLmwAbB6Dt70DHaYC9i96RERERpZilS5di2LBh+PLLL3H06FFUqFABLVq0wP379xPcfvHixRgxYoTa/ty5c5g1a5Z6jM8//zzNYyciy7Pi6C10nroXtx+HoUB2Z6wcXBttK+TWOywiIqKMmyjZtWsX2rZti9y5c6tZFqtWrXru9itWrECzZs2QI0cOuLm5oVatWti0aVOcbb766iv1WLEvJUuWTP6ryQxsbIFWPwGt/wdY2QAnlwLz2wHBfqnydBXzZUXvmgXUdRnsHh5lSJXnISJSFXL7p2ntBQNuPq2kq9JHhifpHR0REVGK+vXXX/HOO++gb9++KF26NKZNmwZnZ2fMnj07we337t2LOnXq4I033lBVKM2bN0ePHj1eWIVCRBlblMGIr9acwbBlJxARbUSjEjmwZnBdlPR20zs0IiKijJ0oCQkJUWc7SZl4UhMrkihZv349jhw5gkaNGqlEy7Fjx+JsV6ZMGdy9ezfmsnv37uSGlrlU6w/0+lurMrl5AJjRGPA9kypP9UmLEvB2c8S1B6GYtO1yqjwHEWVy4YHAX28BGz8DjFFAqXbAgB1ArvJ6R0ZERJTiIiMj1bFR06ZNY9ZZW1ur5X379iV4n9q1a6v7mBMjV69eVcdYrVq1SvR5IiIiEBgYGOdCRBnH/aBw9JxxAHP3XlPL7zcphll9qsHd2U7v0IiIiNId2+Te4bXXXlOXpJI+urF9//33WL16NdauXYtKlSo9DcTWFt7e3skNJ3Mr0gjovxVY3A14eAWY1RzoPAso0TJFn8bV0Q5ftSuDQQuPqIFw7SrmRvGcrin6HESUid07BSzrDTy8CljbAc2/A2oMZBUJERFlWP7+/jAYDMiZM2ec9bJ8/vz5BO8jlSRyv7p168JkMiE6OhqDBg16buutcePG4euvv07x+IlIf0dvPMK7C4/ANzACrg62+LVbRTQrHfffFCIiIrLgGSVGoxFBQUHw8PCIs/7SpUuqnVfhwoXRs2dP3LhxI9HH4JlRsXgW01rTFKwHRAZrw4/3TkrxIe8ty3qrna5oowkjV5yC0Zh6Q+SJKJOQf6eOzgdmNtWSJO75gH4bgZqDmCQhIiKKZ8eOHeqksylTpqiZJtLieN26dfj2228Tvc/IkSMREBAQc7l582aaxkxEqWPxgRvo9sc+lSQp6pUFq4bUYZKEiIgovSVKfvnlFwQHB+P111+PWVejRg3MnTsXGzduxNSpU+Hj44N69eqphEpiZ0a5u7vHXPLly4dMzdkDeHMlULmPfPMI/PsFsGYoEB2Zok/zdbsycLG3wZHrj7DkEA+yiOgVRIYAq9598m9VOFCsOTBwF5C3qt6RERERpTpPT0/Y2NjA19c3znpZTqzKfvTo0XjzzTfRv39/lCtXDh07dlSJEzk2kpPREuLg4KDmRMa+EFH6JTNDR/x9Ep+vPIUogwmvlfXGqsF1UCRHFr1DIyIiSvfSNFGyePFiVfq9bNkyeHl5xayXVl5du3ZF+fLl0aJFC9Vr9/Hjx2q7hPDMqATY2AFtJwAtfwCsrIFjC4AFHYHQhyn2FLmzOuHj5iXU9XEbzql+qEREyeZ3AZjRBDjxp/bvVZMvgR5LtaQvERFRJmBvb48qVapg69atMesk2SHLtWrVSvA+oaGhao5JbJJsEdKKi4gytjuPw9Bt+n510qK1FTC8ZQlM6VkZWRyS3VGdiIiI9EyULFmyRJ39JMmP2EMLE5I1a1YUL14cly8nPDicZ0YlQlrV1HwXeGMZYO8KXN+tDXmXLyVTSJ/aBVE+rzuCwqPxzdqzKfa4RJRJnPwLmN4I8DsHZMkJ9FkL1BsmE2z1joyIiChNDRs2DDNmzMC8efNw7tw5vPvuuwgJCUHfvn3V7b1791YniJm1bdtWVd/LcZVU4G/evFlVmch6c8KEiDKmfVceoO3E3Thx8zGyOtthbt/qeK9hUVixXS0REVGKSZNTD/7880/069dP7dS3bt36hdtLa64rV66o0nJ6CcWaAf03a0PeH/kAM5sBXecARZu88kPbWFvh+47l0H7yHvxz8i46V7mPRiWeVgcRESUoKhzYNBI4PFtbLlQf6DwLyMJ/P4iIKHPq1q0b/Pz8MGbMGNy7dw8VK1ZUrYjNA95lZmPsCpJRo0apL0Xl5+3bt5EjRw6VJBk7dqyOr4KIUpNUi83a7YNxG87DYDShdC43/PFmFeTzcNY7NCIiogzHypTMOm1JYpgrPSpVqoRff/0VjRo1UsPZ8+fPr856kh33+fPnx7Tb6tOnDyZMmIBOnTrFPI6Tk5OaLyI++eQTtZNfoEAB3LlzB19++SWOHz+Os2fPqgOAF5Fh7vJY0oaL1SWxhPgDS3sBN/YBVjZaW64aA1LkoceuO4sZ//kgT1YnbB5WH872LPclokQ89AH+6gPcPSF/doD6nwINRwDWPPuViOhVcB+YkoufGaL0IyzSgBErTmL18TtquWOlPOqkRSd77kMTERGlxv5vsnudHD58WCVI5GIuGZfrciaUuHv3rjr7yWz69OmIjo7G4MGDkStXrpjLBx98ELPNrVu30KNHD5QoUUINec+ePTv279+fpCQJPYeLJ9B7NVDhDcBkADZ8Cqz7GDBEvfJDf9i0uEqS3H4chglbLqVIuESUAZ1bC/zRQEuSOHkAPZcDjb9gkoSIiIiIKBE3HoSi45Q9KkkiXR2+bFsav75egUkSIiIiS6oosUQ8M+oF5Fe8ZwKw5StZAAo3BLrOBZyyvdLDbjvvi35zD6sdtzVD6qBMbq1CiIhIJWTl35x9k7TlfDWALrMB97x6R0ZElGFwH5iSi58ZIsu348J9fLDkOALCouCZxR6T36iMGoWz6x0WERFRupSqFSWUDsmAt7ofAt0WAnYuwNUd2tySB1de6WEbl8yJ1uVyqV6pn684pX4SESHgFjCn1dMkSa0hwFvrmCQhIiIiIkqEnMM6eftl9J17SCVJKubLin+G1mOShIiIKI0wUZKZlGoD9NsIuOUFHlwCZjQGfHa90kNKCbCroy1O3ArAlO3a7BoiysQubwGm1QNuHQQc3IFui4AWYwEbO70jIyIiIiKySEHhURi08Ah+3nRBNYToUT0/lg6sCW93R71DIyIiyjSYKMlscpUH3tkG5KkKhD8GFnQEjsx96YfzcnPEF61Kqev/23wRC/ZdS8FgiSjdMBqAbd8BC7sAYQ+BXBWAgTu1BC0RERERESXo8v1gdJi8B5vO+MLexho/dCqHcZ3KwcGW80iIiIjSEhMlmZFrTuCtf4CyXQBjNLD2A2DjSO2LzpfQvXp+DGlUVF0fvfoMlh2+mcIBE5FFC/IF5rcHdv2szUGq+jbQ71/Ao5DekRERERERWaxNZ+6pJMkVvxB4uzmqKhI5viYiIqK0Z6vDc5IlsHMCOs8EcpQAto8F9k8BHlwGOs8CHJM/2PHj5sURGmnA7D0+GPH3STjZ2aBthdypEjoRWQjpC3DqL+DfUUCwrzYDqe0EoHxXvSMjIiIiIrJYMt/z180XMHm7Nje0eiEPNbQ9h6uD3qERERFlWkyUZPYh7w2GA57FgJXvApf+BWY1B95YAmQrmMyHssLoNqUQFmXAnwdv4KOlx+Fga43mZbxTLXwi0tGtI8DGz4Bbh7TlHCWB1+dryVciIiIiIkrQ49BIfLDkOHZe9FPL/eoUwshWJWFnw4YfREREeuJfYgLKdAT6rgeyeAN+57Qh79f3JfthJFkytkNZdKqUB9FGE4YsPhaz80dEGUTgHWDFQGBmYy1JIlUkjUcDA3YySUJERERE9Bxn7wSi3aQ96jjZ0c4a47tVxJi2pZkkISIisgD8a0yaPJWBAdu1AcyhD4D57YDji5P9MNbWVvipS3m0KueNSIMRAxccxv6rD1IlZCJKQ1FhwM6fgIlVgJNLtHUV3gCGHgHqfwLYOeodIRERERGRxVp9/DY6Td2DGw9Dkc/DCX+/WxsdKuXROywiIiJ6gokSesotN9B3A1CqLWCIBFa9C2z+EjAak/UwtjZyZkwlNC7phfAoI96eewhHbzxKtbCJKJXnkJz+G5hUTZtnFBUK5KsJvLMd6DgVcMuld4RERERERBYrMtqIr9acUe225Pi4XjFPrB1SF2Vyu+sdGhEREcXCRAnFZe8CdJ0P1PtEW94zHlj2JhARnLyHsbXGlJ6VUadodoREGvDW7IM4cycgdWImotRx5xgw5zVgeT8g4CbglhfoPAvot1GrQiMiIiIiokT5BobjjRn7MXfvNbU8uFERzO1bHVmd7fUOjYiIiOJhooSeZW0NNBkNdJoB2DgA5/8BZrcEAm4l62Ec7Wwwo3dVVC2QDYHh0Xhz1kFc8g1KtbCJKIUE+QKrBgPTGwE39gF2zkDDz4Ehh4ByXWQgkd4REhERERFZtANXH6D177tx+PojuDrYqmPjT1uUhI0196WJiIgsERMllLjyrwNv/QO45AB8T2lfmt46nKyHcLa3xey+1VA+rzsehkSi58wDuOYfkmohE9EriAoH/vsfMLEycHyh9N0Cyr0ODDkMNPwMsHfWO0IiIiIiIotmMpkw87+reGPmAfgHR6CktyvWDK2LZqVz6h0aERERPQcTJfR8+aoD72wDvMoAIfeBOa2AU8uT9RBujnaY36+62kG8HxShkiW3HoWmWshE9BJzSM6uBiZXB7Z+A0QGA3mqAG9vATrPANw5ZJKIiIiI6EWCI6IxZPExfLfuHAxGEzpUzI0V79VGIU8XvUMjIiKiF2CihF4sa37g7U1A8ZaAIQL4+21g+/fJGvIuPVgXvF0DhXO44PbjMJUskX6tRKSzuyeBuW2AZb2Bx9cB19xAx+lakiRfNb2jIyIiIiJKFy7fD0aHyXuw7tRd2Fpb4Zv2ZfBbt4qqywIRERFZPiZKKGkcXIHui4Ha72vLO38E/u4HRCa9MiSHqwMW9a+BfB5OuP4gVCVLHgRHpF7MRJS4YD9gzfvAH/WB67sBW0eg/nBg6GGgQjdtVhEREREREb3QhlN30X7SbpUsyenmgKUDa6J3rYKw4mw/IiKidIPfhFHSWdsAzb8F2k0CrO2AMyuBua2AwLtJfohc7k5Y3L8mcrk7qp1IGfAeEBqVqmETUSzRkcCe37U5JEfnaXNIynTSBrU3/gKwZ1sAIiIiIqKkiDYY8f36c3h30VGERBpQo5AH/hlaD1UKeOgdGhERESUTEyWUfJXfBHqvApw8gDvHgBmNgTvHk3z3fB7OWNi/Bjyz2OPs3UD0mXNQ9XIlolSeQ3J+HTClBrB5NBARCOSqCPTdCHSdo7XYIyIiIiKiJPELikCvWQcwfddVtTygfmHVQUE6KRAREVH6w0QJvZyCdYF3tgKeJYCgO8DslsCJJdqXsUlQJEcWlSzJ6myH4zcfo9/cQwiLNKR62ESZku8ZYH57YMkbwMOrQJacQPspwDvbgQK19I6OiIiIiChdOXL9EdpM/A/7rz6Ei70NpvSsjM9blYKtDb9iISIiSq/4V5xenkdhoP9moEgTIDoMWDkQ+KsPEPowSXcv6e2GBf1qwNXBFgd9HmLAgsOIiGayhCjFhDwA/hkGTKsL+OwEbByAusOAoUeASj05h4SIiIiIKBlMJhPm7b2G7tP3wTcwAkW9smD1kLpoVS6X3qERERHRK+K3ZPRqHN2BN5YBjUcB1rbA2dXAlJrApc1Junu5vO6Y268anO1t8N8lfwxedAxRBmOqh02UoRmigH1TgImVgMOzAJMRKNUOGHIQaPol4OCqd4REREREROlKaGQ0Plp6HF+uOYMogwmty+XCqsF1VLKEiIiI0j8mSujV2dgC9T8F+m/RWnEF+wKLugD/fAREhrzw7jLobmbvqrC3tcaWc75q59NgTFoLLyKK5+K/wJRawKaRQHgAkLMc8NY6oNsCIFtBvaMjIiIiIkp3fPxD0HHyXqw6fgc21lYY1boUJr1RCVkcbPUOjYiIiFIIEyWUcnJXAgbuBGq+py0fnq21/Ll56IV3rV3UE3/0qgI7Gyv8c/IuPvv7JIxMlhAl3f3zwMLOwOKuwINLgEsOoO3v2v+TMlOIiIiIiIiS7d8z99Bu4m5c8A2CZxYHLO5fA/3rFYaVlZXeoREREVEKYqKEUpadE9ByHNB7NeCWRxscPbs5sG2s1g7oORqV9MLv3SupM3SWH7mlSpqlBywRPYfMBFo/HJhaG7i8BbC2A2q/r80hqdIHsLbRO0IiIiIionRHuhz8vOk8Biw4gqCIaFQtkA3r3q+LGoWz6x0aERERpQImSih1FG4IvLsXKN9Nm4+w6ydgZlPA78Jz7/ZauVz4X9cKkJNzFuy/jnEbzjNZQpQQQzRwYDowsTJw8A/AZABKtAYGHwCaf6vNDyIiIiIiomR7GBKJPrMPYvL2K2q5b52C+HNATeR0c9Q7NCIiIkolbKhJqccpK9BpOlC8pTav5O5x4I/6QNOvgeoDAOuE83QdKuVBWJQBI1ecwvRdV+FkZ4OPmhVP8/CJLNblrcCmzwG/89qyV2mtkksSlERERERE9NKO33yM9xYewZ2AcHUs+kPncmhfMY/eYREREVEqY6KEUl/ZTkD+WsDqwcCVrcDGz4AL64EOUwD3vAnepUf1/AiLNOCbf85iwtZLcLK3waAGRdI8dCKL4n8Z+PcL4OJGbdnJA2g8CqjcB7DhP+dERERERC9LOhn8efAmvlpzBpEGIwp5umBaryoo4e2qd2hERESUBvjNGqUNt1xAr7+Bw7OATaMAn53AlNpA6/8B5bpA9dqKp1/dQqqy5OdNF/DDhvPqbJ4+tQvqEj6RrsIeAzt/0lpsGaMBa1ug+kCgwXCtcouIiIiIiF5aeJQBo1edxl9Hbqnl5qVz4pfXK8DN0U7v0IiIiCiNMFFCaUeSIdX6A4UaAisHALePACv6AxfWAa1/BZw9nrnL4EZF1U7rxG2X1XB3SZa8Xi2fLuET6TKH5Og8YPtYIPSBtq5YC6DFWMCzmN7RERERERGlezcfhmLQwiM4cycQ1lbApy1KYlCDwrBK4GQ+IiIiyriYKKG051kU6Pcv8N//gJ0/AmdWAjf2A+0nAUWbPrP5sGbFERppwKzdPvhsxUk42FmzRyxlfFd3AhtHAvfPaMueJYCW3yf4/wgRERERESXf9gv38eGS4wgIi4KHiz0m9qiEOkU99Q6LiIiIdMBECelD5ik0/Awo1gxYMQB4cAlY2Bmo9g7Q7BvA3jlmUzmTZ1TrUqoN1+IDNzBs2Qk42tmgRRlvXV8CUap4cAXYPAY4/4+27JgVaPQ5ULUfYMPSfyIiIiKiV2U0mvD7tktqHqbJBFTIlxVTe1ZG7qxOeodGREREOrHW64mJlDyVgYG7tHkL4tAM4I96wK0jcTaTZMl37cuiU6U8MBhNGLr4GHZe9NMnZqLUEB4I/DsamFJTS5JY2Wj/X7x/DKgxkEkSIiIiIqIU8Dg0Em/PO4TxW7QkSa+a+bFsYE0mSYiIiDI5JkpIf1I90uon4M2VgGtu4MFlYFYzYPs4wBAVs5m1tRV+6lIercvlQqTBiAHzD2PflSdzG4jSK6MBODIPmFgZ2Ps7YIgEijQB3t2r/X+RwOweIiIiIiJKvtO3A9Bm4m5sv+AHB1tr/NK1Ar7rUA4OtjZ6h0ZEREQ6Y6KELEeRxsB7e4GyXQCTAdj5g5Yw8b8Us4mtjTV+61YRjUt6ISLaqM4EOnrjka5hE720a3uA6Q2Ate8DIX5A9qLAG8uAXn8DXiX1jo6IiIiIKMNYdvgmOk/di1uPwpDPwwkr3quNLlXy6h0WERERWQgmSsiyOGUDuswCOs8CHN2BO8eAafWAA9OlkazaxN7WGlN6Vkbdop5qyHuf2QfVmUFE6caja8Cy3sDcVsC9U4CDO9Die+DdfUDxFtJrTu8IiYiIiIgyhIhoA0auOIXhy0+qk+3kpLt/htRDmdzueodGREREFoSJErJM5boA7+0HCjcCosOADZ8CCzsBgXfUzTLMfXrvKqhWMBuCwqPx5qwDuOgbpHfURM8XEQRs+RqYVB04uxqwsgaqvg28fxSoNRiwtdc7QiIiIiKiDOP24zC8Pm0f/jx4Q52LNKxZcczsXRXuzpz/R0RERHExUUKWyy030GsF8NrPgK0jcHU7MKUWcPpvdbOzvS1mv1UNFfK641FoFHrOPAAf/xC9oyZ6llRDHVsETKwC7P4VMEQAhRoAg3YDbX4FXDz1jpCIiIiIKEPZfckfbX7/DyduBSCrsx3mvFUN7zcppmZfEhEREcXHRAlZNmtroMYAYOB/QO5KQPhjYHk/YPnbQNgjuDraYV6/6ijp7Qq/oAj0nLEftx6F6h010VM39gMzGwOr3wOCfYFshYDui4Heq4GcZfSOjoiIiIgoQzEaTZi8/TJ6zz6gTqgrm8cNa4fURcMSXnqHRkRERBaMiRJKH3IUB97eDDQYAVjZAKeXA1NqA1e2IauzPRb2r4HCOVxwJyAcb8w4AN/AcL0jpszu8U0tqTe7hTZrx94VaPYNMPgAULI155AQEREREaWwgLAoDFhwBD9vugCjCehWNR+WD6qNfB7OeodGREREFo6JEko/bOyARiO1hEn2okDQHWBBR2D9cHjaG7C4f03k93DGjYeheGPGfvgHR+gdMWVGkSHAtrHApKpP2sRZAZV7a3NI6nwA2DroHSERERERUYZz/l4g2k/ajS3nfGFva40fOpXDj13Kq/mWRERERC/CRAmlP3mraK24qr2jLR/8A/ijPryDz2JR/xrI5e6IK34heHPWQTwOjdQ7WspMc0hOLAUmVgV2/QREhwMF6gADdwLtJgJZWOpPRERERJQaVh27jQ6T9+Dag1DkyeqE5YNqoXv1/HqHRUREROkIEyWUPtk7A61/AXr9DWTxBh5cAmY1Q76TE7GoXxV4ZnHAubuB6DPnEILCo/SOljK6W4fV5w8rB2iVTlnzA6/PB95aB+SqoHd0REREREQZUmS0EV+uPo0Plx5HeJQR9Yp5Yu3QuiifNyssTngg8PAqEMU20URERBkiUbJr1y60bdsWuXPnhpWVFVatWvXC++zYsQOVK1eGg4MDihYtirlz5z6zzeTJk1GwYEE4OjqiRo0aOHjwYHJDo8yoaFPgvX1AmY6AMRrY8T0Kr+mMZV1yIJuzHU7cfIy35x5GWKRB70gpI7p/HljaC5jZBLh9GLBzAZqMAQYfAkq35xwSIiIiIqJUci8gHN2n78O8fdfV8tDGRTG3b3V4uNjDYkSGAqdXAH++AfxcBPi9EjA2J/BzUWB6Q+1YYuNIYO8k4Mwq4NYRIMhXq1YnIiKiNGWb3DuEhISgQoUK6NevHzp16vTC7X18fNC6dWsMGjQIixYtwtatW9G/f3/kypULLVq0UNssXboUw4YNw7Rp01SSZPz48eq2CxcuwMuL7WroBZw9gC5zgBKtgXUfqy+sCy9vgX9qjkLLPUVx8NpDDFhwGDN6V2V/WkoZD32AHT8AJ5cCMGlzSCq+oSVJXL31jo6IiIiIKEPbd+UBhv55FP7BkXB1tMVvr1dE09I5YREMUcCV7cCpv4AL64HI4Ke32TgAhgggxE+73DmW8GPY2ANuuQH3fIB7XsAtj/bTvOyeB3BwTbOXRERElBlYmUwm00vf2coKK1euRIcOHRLd5rPPPsO6detw+vTpmHXdu3fH48ePsXHjRrUsyZFq1aph0qRJatloNCJfvnwYOnQoRowY8cI4AgMD4e7ujoCAALi5ub3sy6GMIOAWsOo9wGentpinAdrd7I7rke5oWsoLU3tVgZ0NO87RSwq8A+z8CTi2QKtgEiXbAI2+AHKW1js6IiLKZLgPTMnFzwyld/L1xcz/fPDDxvMwGE0o6e2Kab2qoKCni76BSQXIjb3AqeXA2dVA2MOnt2UtAJTrApTtAniVAsIeacetgbe1nwE3n/x8siytfE1JqChxdI+VODEnU2Itu+YCbJJ9biwREdGrk3SDnCggbSfDA4CIQO0EAGlVb8H7v6n+V3Pfvn1o2rRpnHVSLfLhhx+q65GRkThy5AhGjhwZc7u1tbW6j9yXKFlkh/DNVdqA9y1fwf32TmxxPIFPTG9h9bnqqnft790rwcaaLZEoGUL8gd2/AQdnaGeAiSJNgMajgDyV9Y6OiIiIiCjDC46IxvDlJ7D+1D213LFSHnzfsRyc7G30+xLo7nEtOXJmpZb4MHPxAsp20pIjeavGbckrHRHkkqt8wo9riAaC7sZKppgTKeZkyk0g/LH2xZNcfJ+elBqHlbWWLEkskSIXp2xsF0xERAn/LYoIfPL3Jlayw/y3J8F1AbHWBQKmeGMQpAtLvY9hyVI9UXLv3j3kzBm3BFaWJZsTFhaGR48ewWAwJLjN+fPnE3zMiIgIdTGTxyKKYW0N1HwXKNIYWPEO7O6ewASb8WhsVQejT76F4bY2+LlLeVgzWUIvEvYY2DcJ2D/1acl8/lpA49FAwTp6R0dERERElClcvh+EgQuO4IpfCOxsrDCmTWn0qllAdblIc/6XtOTI6eXAg8tP1zu4A6XbasmRgvVevppD7pc1n3ZJTESQljQJNCdQ4l0kwWKI1H7K5eaBhB/Hzjlu4sQt1nVzcsXO8eVeBxER6ZfIjwqLl8gwJz3irwtIeF1USMrEYm2rVUDKxT4LLF26rMMcN24cvv76a73DIEuXowTw9hZg10/Af/9De+s9qO5wDh8fH4Qx9tb4tn1ZfXasyfJFhgAHpgF7ftf+kIhcFbUESdEmPOuKiIiIUsTkyZPx888/q5PLZA7kxIkTUb169QS3bdiwIXbu1NrLxtaqVSvV6pgoo/rn5B0MX34SoZEGeLs5YkqvyqicP1vaBiHJBxnKLsmRuyeerrd1Akq01JIjxZoBtg5pE4/MJ/EqqV0SawUmM1BU0iR2EuXm0xZfIfeBqFDA/6J2SYxLjkQSKVKdkkernpGTFYkorqhwIPgeEHwfCLqnfc8g/z9l8QKy5ARcPAFrztGlBBgNT6synlvJ8TjxZIcxKmVisXN5kuhwe5rwcHBLZF3WZ9fZOaWr79BSPVHi7e0NX1/fOOtkWXqCOTk5wcbGRl0S2kbumxBp0yXD32NXlMhME6Jn2Npr7ZGKtQBWDkCuh1ex2P57zD58FD/ZfIbhbSoxWUJPRUcAh+eoxJo6cBA5SmozSEq1TVf/uBMREZFlW7p0qTqmmTZtmprZOH78eNWi+MKFC/Dy8npm+xUrVqi2xWYPHjxQyZWuXbumceREaSPKYMSPG85j5m4ftVyrcHZMfKMSPLOkUTIi5AFwdhVw+m/g+p64Z8dK9wJJjpRsZZlD1SVx4ZpTu6BK4l/imuekJDgv5aaWSHnR4HlrOy1hIomTmKHzHDxPGfhMfZkzFOyrXYJ84yZDzOvlIl9YP4+0x3P21P4/zWK+eMX7+eS6fOHM7yPS3/dLoQ+A0IfaT5ld9dy2VbHWySUlyGcsTmLDPQnJDvcn67Jq/3bb2CEzSfVESa1atbB+/fo46zZv3qzWC3t7e1SpUgVbt26NGQovw9xleciQIQk+poODg7oQJVm+asCg3cC/o4DDs9HPdiMuHTqFRdE/oFfHdnpHR5bQe/HEYm1QuxwQiGwFgYYjgXJdeZYHERERpbhff/0V77zzDvr27auWJWEilSGzZ8/GiBEjntnew8MjzvKSJUvg7OzMRAllSPeDwjFk8TEc9NGGog9sUBifNi8BW5tUrlyQllbn1wOn/gKubgeM0U9vK1BHG8peqj3gkh3pnrTUyl5EuzzvC+HY7bziz0uRwfNy1vKja9rlRYPn5Wx6ObvY1lG7SAzm66+ybGPPL5Hp1URHaidLxiQ/fBNOhsiytLVLKhuHJ4kQb8DeBQj11x5Pko8mqfy6/+QkzVPPfxypXkssiRLnulfaVbZlts+HJDpiJz7iXw+Lt97cvv1VyO/dnMiIk+yIvy5rwtvJZ47/NqZuoiQ4OBiXLz/tw+nj44Pjx4+rHff8+fOrao/bt29j/vz56vZBgwZh0qRJGD58OPr164dt27Zh2bJlccrD5UyqPn36oGrVqqrUXM6mCgkJiTloIEoR8g9Em9+A4q8hdPm7KBZ5GwWPv4UDgQNRo9e3L99DltIvKUk/swLY/j3w8Iq2zjU30OBToNKbmS5zTkRERGlDKkOOHDmijp3MrK2t0bRpU+zbty9JjzFr1ix0794dLi4uiW7D2Y6UHh2+9hDvLTqK+0ERyOJgq+ZLvlYuV+qe9Xtps5YcubgJiA57eluuCtqJU2U6aZURmYl8ufZKg+efXGIPnk+9YFM28ZLUZflCml9CWi5J9knyMybhEaviI34yRL7cTg6nbLESFDmfJkNirj+5yJfVCX1G5P8deU71/E8SMHGu33+anJHqAvl36fF17fIi8qW5q3ciCZVY65w8MmfbPEOUlgR+JumRWOLj4ctXeFjZPPl3NLv2fsep6kgsASKVHPLTjUkvHST7m+HDhw+jUaNGMcvmFliS6Jg7dy7u3r2LGzduxNxeqFAhlRT56KOPMGHCBOTNmxczZ85UZeVm3bp1g5+fH8aMGaP681asWBEbN258ZsA7UYoo3hzOHxzElTnvoIj/VtTwmYL7v++GV++5iZ9NQxlvh+nCBmDbd8D9M9o6+cNV72Ogaj/tLCciIiKiVOLv7w+DwfDM8Y4snz9//oX3P3jwIE6fPq2SJc/D2Y6UnphMJszdew1j151DtNGEYl5ZMO3NKiiSIxWGv8qXlNd2Aaf+Bs6tBSJifYmfvajWVkuqRzyLpfxzZyTJGTwvSRM5mz46XEtOyaBh+SlfAL/sMkxPnsT0ZH2sJFdaSXaixUk73jRf1Hrz9fi3JbCcGb/YTmh+g1RkxEl4JND+Sm5LzmdC2urFJBO847XEyhk3+fCqX2DL/zsx7fFeIFJa4N1PPKGiXvOTZanwUsnJx4Df+Re/Xpkx9NxKlSc/HbJY7mchJunxnMRH7GqPl03aShsrSZDJd0cxl1hJkITWS8KD/8+mK1Ym2RtJ5+TMKHd3dwQEBKjZJ0RJYjJhw6LxqHPpR7hZhSHaxgm2r30PVOnLs0IyKvnn7uoOYNu3wO0j2joHd6D2UKDmIPbOJSKidIX7wOnXnTt3kCdPHuzduzemJbGQKnwZ2H7gwIHn3n/gwIGq8uTkyZPP3S6hihKZ7cjPDFma0MhojPj7FNacuKOW25TPhR87l4eLg23KHgvcOgScWg6cWfl0JqG5qrxcZy1BIlUkPB60fPL7lDPDk5VokSRNuDafxXw9uctxEjQ6kFZOCSZczNcl8eL8JAHj/JzkjPOLt03rFtSSEEgs4RE7GWJuW5VU9q6xKj68YiU8Yi97a1+Cp+cvtWPmp8SuSomdWImVUEluBY0M9I5JHD0nsSLt9V62M4d0/JAET2IVHglVe4Q9fsn/H60Ap6xJTHo8uU0qPdLz5yMTC0zGMRN7DVHmZWWFlj0/xMQVFVD1+BeojbPAPx9plQbtJmp/LCnjuHFAS5Bc+09blh3BGoO0JIn80SMiIiJKI56enrCxsYGvr2+c9bLs7f38fVBpUSzzSb755psXPg9nO1J6cNUvGO8uPIoLvkGwtbbCyFal0K9OQVilVLLC94yWHJGh7LHb1siXYWU6aMmR/LX4BVh6I58PW3vtokuC5hUSLSpp8+RnzLLcFqptKz9jLxueJrzVdbWcmq3MnpDZL89NwDwn4RKzHCs5I19oB/slngyJDEre2f3ypXxMwiNnIsmQnFob9szWLs+r5PO3lc+wuSonfkIldoWKXNTnMAR4eFW7vIgkFmJX4ph/D9JKShIbiVV7SJInOQmw2KRtVULJjQSTHpIMkaQHZ9HSs5gooUxNdr6HdmqE0VbTsPXIdAy3XQqHS/8CU2oBbccDpdvrHSK9qrsntRZblzY93dmT9lp1hyWtzJWIiIgohdnb26NKlSrYunUrOnTooNYZjUa1PGTIkOfe96+//lJVIr169UqjaIlSz6Yz9/DJshMIiohGDlcHTH6jMqoXSoGTmGSwuDk5cv9s3LOiS7XRkiNFGnEmIb1igsYt7doLmRMu8ZMoiS4/77bYCZp4yRq5mMnQcrnEbk2X2iQxE7vlVZzqj1jzP5w9OWf2Vci/fW65tcuLRAQnMD8l3owXte4+YDI8TYTE/rc3OaRdlbm6I05yI37bq1jr+VmgFMJPEmV6kiz5pkN5fBL9DtocK48J9pNROuw6sKw3UKEH8NqPWnaa0he/i8D2scDZVU+HaFXqCdQf/vweukRERERpQGY9ypzHqlWronr16hg/fryqFunbt6+6vXfv3qo9l8wZiU3mkkhyJXv27DpFTvTqog1G/G/zRUzdcUUtVyuYTSVJvNzkrPOXJGekS0ut08u1FltmcqJUseZA2c5A8ZaAvXMKvAKiNCRnvktVhKqMSOV/+6X9kTmZ8kzVS0LLSd02XKvGMVcXJDj/Q2ZhuLL1naWR+SRyedFMX/nsSHVIgoPpfbXZIOZkh6r0SCQZktZVYkSxMFFCJPsd1lb4qXN5fBBlRPtT32KY/QoMslkDqxN/Atd2Ax2mAoXq6R0mJfXssR0/AieXPCnbtNIOihp9/uI/7ERERERppFu3bvDz88OYMWNw7949VKxYERs3bowZ8H7jxg1Yx2sFdOHCBezevRv//vuvTlETvboHwRF4f8kx7Lms9ch/u24hjHitJOxsXqL1lbRxkWHskhzx2fW0bYu05SlUX6scKdVWa7NCRC8mf3ckmciEIr3MZ8fFU7vkLKN3NEQvhcPciWKJjDbi3YVHsPX8fdS2v4w57jPhEHRDu7HWEKDxaK3fJlmewLvAf78AR+YBxihtXYnWQOMv+EeaiIgyJO4DU3LxM0N6O37zsTreuhsQDmd7GzWwvW2FJLR+iT/w+eJGrbXW5c1aayCzvNW05EiZjmyzS0REROAwd6KXZG9rjck9K6P/vMPYfRmoF/QdNpbcAI/zfwL7JgGXtwKd/gByVdA7VDILeQDs+Q04OONpP9XCDbWkVt6qekdHREREREQAlhy8gTGrzyDSYERhTxdMe7MKiud0TdqdZfDwle3Aqb+AC+uByOCnt3mV1irI5eJRKNXiJyIiooyNiRKieBztbDC9dxX0mX0Qh649QpOLnbD2tRbIu2s44HcOmNEEaDQSqPOh1iuU9BEeCOybrF0ig7R1+WpoCRK2SSMiIiIishh/Hb6JEStOqestyuTEL10rwNXR7sX97m/s1SpHzq7Wet+bZc2vVY6U68LqcSIiIkoRTJQQJcDZ3haz36qGXjMP4MStAHTY7Irlvbeg4N7PgfP/AFu/AS5uAjpOAzwK6x1u5iKl9genA3vGA2GPtHXe5YDGY4BizTj4jYiIiIjIgmw56xuTJOlftxC+aF0KVonts0tn8LvHteSIDGYPvP30NhcvraVWua5a5Tj3+4mIiCgFMVFClAg5w2lev+roPn0/zt8LQo9Fl7FswHTkK7kaWD8cuHkAmFoXaPk9ULkPd9RTW3SENn9E5pAE+2rrPItrQ9pLtdcGhxERERERkcU4dO0hBi8+CoPRhM6V8yaeJPG/pCVHZCj7g8tP1zu4a8PYpXKkYD3Ahl9hEBERUergMHeiF/APjkC3P/bhil8I8ns4Y9nAWvA2+gKr3gWu79E2Kt5SG/aeqzzg6K53yBmLIRo4uQTY8SMQcONpqX3DkUC513mwREREmRb3gSm5+JmhtHT+XiBen7YPgeHRaFLSS80ksbOJdXJTwC3g9AotOXL3xNP1to5Aide01lpSMW7roEv8RERElLn2f5koIUqCewHheP2PfbjxMBRFcrhg6cBa8HS2A/ZP1tpwGSKfbpytEJC7ojbwXV0qAs4eeoafPklP4rMrge3jgAeXtHVZvIH6n2gVPLb2ekdIRESkK+4DU3LxM0Np5ebDUHSeuhf3gyJQtUA2LHi7BpzsbYCQB8DZVcDpv5+edCasbICiTbTkSMlWgEMSh7wTERERPQcTJUSptLMvlSV3AsJR0tsVSwbURFZne8D3DLDzJ+D20acVD/G559eqTSRpYk6iZPFK65eQPsg/STL/Zdt3gK/WyxhO2YC6w4Bq/QF7Z70jJCIisgjcB6bk4meG0qoiv+u0ffDxD0GJnK6qIt/dOhRY9wlwZgVgjH66cYE6QNnOQOkOgEt2PcMmIiKiDIiJEqJUctUvGK//sV/t/FfI646F/WuoWSYx5Aypeye00nG53DkOPPJJ+MFcc2mJk5jKkwqAW+7MPevEZ5dWoXPrkLZs7wrUHgLUfA9w5P/bREREsXEfmJKLnxlKbcER0egxfT9O3Q5AnqxO+Pvd2vAOvwIs7QU8vKptJMc9UjlSthPgnlfvkImIiCgDC2SihCj1XLgXhO7T9+FRaBSqFcymBr472z9nTkbYY+DeqSfJk+PaTxlWiAT+13PJETdxIokUmceR0ZMntw5rCRKfndqyrRNQYwBQ50O2LSMiIkoE94EpufiZodQUEW3A23MPY/dlf3i42OOvQbVQ5O56YM37QHQY4J4P6DIHyFdN71CJiIgokwhkooQodZ2+HYAeM/YjKDwadYt6YmafqnC0s0n6A0QEx0qePLn4nQdMhme3dcyqJU1i5p5U1OagWMcahJhe3Tuttdi6uEFbtrYDqrylzSFx9dY7OiIiIovGfWBKLn5mKLUYjCZ8sOQY/jl5F872NljSrzLKn/0ZODhd26BIY6DTTLbXIiIiojTFRAlRGjhy/RHenHUAoZEGNCnpham9qsDe9hWSF5GhwP2zWtWJtOyS5Mn9c4Ax6tltHdwA7/Jxq088iwHWyUjW6Mn/MrDje22Io7CyBiq8ATQYDmQroHd0RERE6QL3gSm5+Jmh1CBfKXy55gzm77sOOxsrLHw9L2oc+hi4dVDboP6nQMOR6edYhYiIiDIMJkqI0si+Kw/w1pyDiIg2ol4xT0zsUUkb8J5SoiO0ZIm5ZZdcpArDEPHstnbOgHe5uG27cpQAbGLNUNHb4xvAzh+B438+rZ4p0wlo9LmW6CEiIqIk4z4wJRc/M5Qaft96Cb9uvqi6BS9qEonaRz8BQv0BB3eg03SgREu9QyQiIqJMKpCJEqK0s+PCfQxaeAThUUbk83DCH72qonTuVPwcGqIAvwux2nYd19p4RYU+u62NA5CzTKy2XRUAr9KArQPSVJAv8N8vwJG5gCFSW1e8JdDoCyBX+bSNhYiIKIPgPjAlFz8zlNIW7r+OUatOq/mLy8sdQtXLvwMmI5CzHNBtPuBRWO8QiYiIKBMLZKKEKG2dvROIgQsP4+bDMDjaWePHzuXRvmKetAvAaAAeXNYSJ+a2XfdOAhGBz24rc0C8SsWtPPEuC9g5pXxcoQ+BPROAA39oAxxFofpA49FAvuop/3xERESZCPeBKbn4maGUtP7UXQxefBQuplCszL0IxR5u126Qlrqt/wfYO+sdIhEREWVygUyUEKW9x6GRGPrnMfx3yV8t969bCCNeKwlbG52GrhuNwCOfuG27JIkS/vjZba1stDZd5sSJ/JQ2Xg5ZXu65I4KAfVOAfZOeJmvyVAWajAYKN3y110VEREQK94EpufiZoZSy97I/3ppzCAWMN7DYdSJyRN7UTshq9RNQpS9UHy4iIiIinTFRQqQTg9GE//17AVN2XFHLtYtkV3NLsmdJ41ZXiZH/3WVOSOy2XZI8kR7Cz7ACsheN27ZLBsg7ZU388aPCgEMzgf9+BcIeautylgUaj9JabfGAiYiIKMVwH5iSi58ZSgmnbweg+/T9aBy1Cz87zISDKRxwywO8Ph/IW1Xv8IiIiIhiMFFCZAFl6J/8dQKhkQbkyeqEP96sgrJ53GGR5J+AoLtx23bJJehOwttnKxSrbdeTChQHV+DYfGDXL9pjCUmyyJD20h0Ba52qaoiIiDIw7gNTcvEzQ6/qmn8Iuk/diYERc9HXdpO2UirGO88CXDz1Do+IiIgoDiZKiCzARd8gDFxwBD7+IXCwtcb3Hcuhc5W8SDeC7z+tOlFJlBNAwI2Et7VzAaJCtOvu+YAGnwEVegA2tmkaMhERUWbCfWBKLn5m6FXcDwzHgCn/YFToj6hqfVFbWe9joNEXgLWN3uERERERvdL+L7/FJEolxXO6YtXgOvho6XFsO38fH/91AqduB+CL1qVgp9fckuTI4gUUa6ZdYg9nj922S34+vKolSVy8gPqfAFXeAmwtpNUYERERERG9soCwKPw8fRZmhP2IHNYBMNq7wrrTH0DJ1nqHRkRERJQimCghSkXuTnaY2bsqxm+9hN+3XsLcvddw9k4gJvesjByu6TCZ4OwBFGmkXczCA7RkiWcJwN5Zz+iIiIiIiCiFhUdGY/WUkRgXNAu2VkZEZi8F+zcWAdmL6B0aERERUYpJB6e1E6Vv1tZWGNasOKa/WQVZHGxx8NpDtJ24G8dvPkaG4OgO5K7EJAkRERERUQYTHRqA0xM6onfQDJUkeVy0E+wHbmOShIiIiDIcJkqI0kjzMt6qFVeRHC64FxiO16ftw9JDicz8ICIiIiIi0pHp/nk8nFAPVUN2IdJkA5/qXyFrz9k8QYqIiIgyJCZKiNJQUa8sKlnSvHRORBqM+OzvU/hi5SlERhv1Do2IiIiIiEhzegWipjWEV8R13DV54EjjxSjU6iPAykrvyIiIiIhSBRMlRGnM1dEO03pVwcfNiqvjjEUHbqDHjP3wDQzXOzQiIiIiIsrMDFHAxpHA8r6wN4Zhr6E09jddgVoNWuodGREREVGqYqKESKe5JUObFMPsPtXg6miLI9cfoc3E3Th87aHeoRERERERUWYUdA+Y1xbYP0UtTo1ui+ON5qBjvUp6R0ZERESU6pgoIdJRo5JeWDOkLornzAK/oAhVWbJw/3WYTCa9QyMiIiIioszi+l7gj/rAjX0IMjlhQORH8K0+Eu82KqF3ZERERERpgokSIp0V8nTByvfqoFU5b0QZTBi16jQ++/skwqMMeodGREREREQZmZygtW8yMLcNEOyLS6a8aBf5HRzLtceYNqVhxZkkRERElEkwUUJkAVwcbDH5jcoY8VpJWFsByw7fQrc/9uHO4zC9QyMiIiIioowoIljNIsGmzwGTARtQB+0ivkG+YuXxS9cKql0wERERUWbBRAmRhZCztQY1KIK5favD3ckOJ24FoN2k3Thw9YHeoRERERERUUbidxGY0Rg4sxIma1v8avs23g1/D8XzeWNqz8qwt+VXBURERJS5cO+HyMLUL54Da4fURalcbvAPjkTPmQcwZ48P55YQEREREdGrO7MKmNEI8L8AYxZvfOA4Fr8HN0HhHFkw561qqtqdiIiIKLNhooTIAuXP7owV79ZG+4q5EW004eu1Z/HxshOcW0JERERERC/HEA1s+gL4qw8QGQxD/jro5/g/rHmYD95ujljwdg14uNjrHSURERGRLpgoIbJQTvY2GN+tIka1LgUbayusOHYbnafuxa1HoXqHRkRERERE6UmQLzC/PbBvklo01BqCdzAaO25Zqba/C96ujjxZnfSOkoiIiEg3TJQQWfjckv71CqsDFzm768ydQLSduBt7L/vrHRoREREREaUHN/YDf9QHru8G7LPA2GUePnncFdsuPoSjnTVmv1UNxXK66h0lERERka6YKCFKB2oX8cTaoXVRLo87HoVGodesA5ix6yrnlhARERERUcLkWGH/NGBuayD4HuBZAqZ3tmHsteJYeey2qlqf2rMKqhTIpnekRERERLpjooQonZBS+L8G1UKnynlgNAFj15/D+0uOIzQyWu/QiIiIiIjIkkQEA3/3BzZ+BhijgTKdgHe2YdoZW8za7aM2+blLeTQq6aV3pEREREQWgYkSonTE0c4G/+taAV+3KwNbayusPXEHnabsxY0HnFtCREREREQA/C8DM5sCp5cD1rZAi3FAl9lYdvIRftx4Xm0icxA7Vc6rd6REREREFoOJEqJ0OLekT+2CWPxOTXhm+X979wFXZfn+cfzLXgoiKG7BvUeuHGX9MrFhmg3tn2la1q+yZdN+pQ3L9lLLtBxlw6apmWampeYotTL33go4QFA2/9d9EwQFKgo8wPm8X687n+ecZ1yng3Kecz33dXlr48Hj6jl2iX7cHO10aAAAAACctGGWNOEiKXqDVC5MGjhb6nin5m+I0qNf/mE3ub1rHdsHEQAAAOeYKBk3bpzCw8Pl6+urDh06aOXKlflue9FFF9kvdv85rrjiiuxtbr755n8936NHj7MJDXAZ7SMq2r4lLWtWUOzJFN08eaXeWrSVviUAAACAq0lLleaPkKb3l5KPS7U6Sbf/JNXuqJU7jmjoR6tt+d7r2tTQoz0aOR0tAABA6U+UTJ8+XcOGDdPIkSO1evVqtWzZUpGRkYqKispz+y+//FIHDhzIHn/++ac8PDx03XXX5drOJEZybvfxxx+f/asCXETVID99evv56teupu3V+OLcTbrro9WKT6JvCQAAAOAS4qOkD3pLS9/IXD//LmngTKl8FW04EKdbpv6ipNR0dWtcWaP7NLc3JgIAAOAcEyWvvvqqhgwZokGDBqlJkyYaP368/P39NWnSpDy3r1ixoqpUqZI95s+fb7f/Z6LEx8cn13bBwcEFDQ1wST6eHnr+mhZ67urm8vJw05y1B3X1uKXaEZPgdGgAAAAAitKeldI7XaWdiyWvAOnayVKP5yQPL+05ckIDJ63U8cRUtQsP1pgbzpOnB9W3AQAA8lKgT0nJyclatWqVunXr9vcB3N3t+rJly87oGO+995769eungICAXI8vWrRIlStXVsOGDXXHHXfo8OHD+R4jKSlJcXFxuQbg6v6vQy19cltHVS7voy1R8bpq7BL9sPGQ02EBAAAAKGxmOvmKCdLky6Xj+6XQBtJtC6VmfezTMfFJuum9FYo6nqSGYeX17oB28vP2cDpqAACAspEoiYmJUVpamsLCwnI9btYPHjx42v1NLxNTeuvWW2/9V9mt999/XwsWLNALL7ygH3/8UZdddpk9V15Gjx6toKCg7FGzZs2CvAygzGpTO1iz7+5i/zR3jt0y9Ve98f0WpZuCxAAAAABKv+QE6cvbpG8fktJTpCa9pCE/SJUa2qePJ2b2L9x5+ISqV/DT+7e0V5C/l9NRAwAAlGjFOu/WzCZp3ry52rdvn+txM8Pkqquuss/17t1bs2fP1i+//GJnmeRl+PDhio2NzR579uwpplcAlHyVA3318ZDzddP5te2NZq99v1m3T1tlL5gAAAAAlGKHt0nvdpPWfiq5eUjdn5Wumyr5lLdPJ6Wm6fYPVunPfXGqGOCtD25pr7BAX6ejBgAAKFuJktDQUNuI/dCh3OV8zLrpK3IqCQkJ+uSTT3TLLbec9jx16tSx59q6dWuez5t+JoGBgbkGgL95e7rrmd7N9OI1LeTt4a756w+p17il2hoV73RoAAAAAM7Gxm+kCRdJUeulgMrSwFlSp6HSX83Z09IzdP/03/TztsMK8PbQlEHtVKdSOaejBgAAKHuJEm9vb7Vp08aWyMqSnp5u1zt27HjKfT/77DPbW6R///6nPc/evXttj5KqVasWJDwA/3B9u5r69L8dVTXIV9ujE9R73FLNW3f6MnkAAAAASoi0VOn7J6VP/k9KipNqni/d/pMU3jl7k4yMDI2c+afmrD0oLw83vXNTW7WoUcHRsAEAAMp06a1hw4Zp4sSJmjp1qjZs2GAbr5vZIoMGDbLPDxgwwJbGyqvslimrFRISkuvx+Ph4PfTQQ1q+fLl27txpky69evVSvXr1FBkZeS6vDYCkVjUraNbdXdQhoqLik1LtVPxXvttE3xIAAACgpEuIkab1kZa8lrne4Q7p5tlSYO6bCt9YsEXTlu+2k0te69tKXeqHOhMvAABAKeVZ0B369u2r6OhojRgxwjZwb9WqlebOnZvd4H337t1yd8+df9m0aZOWLFmi77777l/HM6W8/vjjD5t4OXbsmKpVq6bu3bvrmWeesSW2AJy70HI+mnZrBz03Z4MmL92pMT9s1Z/7YvV6v9YK8qOxIwAAAFDi7P1V+nSAFLdP8vKXrhojNb/2X5t9sHyXXv9+i11++qqmurJFNQeCBQAAKN3cMswc3VIuLi5OQUFBtrE7/UqAU/tqzV49+sVaJaWmKzzE307Lb1gls/kjAAAoPfgMjILiZ6aUMJfov74nffuolJ4ihdST+k6TKjf+16bf/HFAQz9ebXe555L6GnZpA0dCBgAAKO2ffwtcegtA6XZ16xr64o5Oql7BTzsPn9DVby21F1gAAAAoXuPGjVN4eLh8fX3VoUMHrVy58pTbmxn4d911l+3laGbfN2jQQHPmzCm2eFEMkk9IM+6QvnkgM0nSuKc0ZGGeSZKlW2Ns83aTJLmxQy3d362+IyEDAACUBSRKABfUrHqQ7VvSuV6ITiSn6a6PVuv5bzcqjb4lAAAAxWL69Om2/+PIkSO1evVqtWzZ0vZojIqKynP75ORkXXrppbav4+eff27LG5vekdWrVy/22FFEjmyX3rtU+v1jyc1duvRp6foPJN9/3/24dm+sbnv/VyWnpevy5lX0dK9mcjMNSgAAAHBWKL0FuLDUtHS9NG+T3vlpu12/oH6o3uzXWsEB3k6HBgAAToPPwKWbmUHSrl07jR071q6np6erZs2auvvuu/Xoo4/+a/vx48frpZde0saNG+XldXY95viZKcE2fSt9ebuUFCsFVJKunSRFXJjnpjtiEnTt2z/rcEKyOtUN0eRB7eTj6VHsIQMAAJR0lN4CcEY8Pdw1/PLGevOG1vLz8tDiLTG6atwSrd8f53RoAAAAZZaZHbJq1Sp169Yt+zF3d3e7vmzZsjz3mTlzpjp27GhLb4WFhalZs2Z67rnnlJaWVoyRo9Clp0kLnpE+7peZJKnRXrr9p3yTJIfiEnXTeytskqRZ9UC9c1MbkiQAAACFgEQJAF3Vspq+vLOTalX0154jJ9Xn7aX6+rd9TocFAABQJsXExNgEh0l45GTWDx48mOc+27dvtyW3zH6mL8kTTzyhV155RaNGjcr3PElJSfYuupwDJUjCYWnaNdLilzPX298u3fyNFFgtz81jT6Zo4KSV2nv0pMJD/DX55vYq73t2s4sAAACQG4kSAFbjqoGaObSzLmxQSYkp6br3k980avZ6W54LAAAAzjKluSpXrqwJEyaoTZs26tu3r/73v//Zklz5GT16tC01kDVMaS+UEPtWSRO6StsXSl7+Up+J0uUvSp55l8BNTEnTrVN/0caDx1WpvI8+uKWD/RMAAACFg0QJgGwV/L01+eZ2uuviunb93SU7dNN7K3U4Psnp0AAAAMqM0NBQeXh46NChQ7keN+tVqlTJc5+qVauqQYMGdr8sjRs3tjNQTCmvvAwfPtzWY84ae/bsKeRXggIzLUJ/nSxN6iHF7pEq1pFu/V5qcX2+u5gbl4Z+tEa/7Dyq8r6een9we9Ws6F+sYQMAAJR1JEoA5OLh7qaHIhtpfP/zFODtoWXbD+uqsUu1dm+s06EBAACUCd7e3nZWyIIFC3LNGDHrpg9JXjp37qytW7fa7bJs3rzZJlDM8fLi4+Njm1bmHHBQyknp67uk2fdJaclSwyuk2xZJYU3z3SUjI0OPfbVW3284JG9Pd707oK2dCQ4AAIDCRaIEQJ56NKuqGXd1VkRogPYdO6lrxv+sz1ftdTosAACAMmHYsGGaOHGipk6dqg0bNuiOO+5QQkKCBg0aZJ8fMGCAnRGSxTx/5MgR3XvvvTZB8s0339hm7qa5O0qB+ChpUqT024eSm7t0yUip7zTJN+iUu704b5M+/XWv3N2ksTe0Voc6IcUWMgAAgCvxdDoAACVX/bDyNlkybPpvWrAxSg9+9rvW7j2mx69sIi8P8qwAAABny/QYiY6O1ogRI2z5rFatWmnu3LnZDd53794td/e/P2+Z/iLz5s3T/fffrxYtWqh69eo2afLII484+CpwRo7ulD64WjqyXfIPka6dJNW56LS7vbt4u95etM0uj+7TXN2b5l2WDQAAAOfOLcPM5S3l4uLibHNCU3eX6eRA4UtPz9AbC7bYYbQPr6hxN55HA0kAABzEZ2AUFD8zDji0TvqgjxR/UKpQS7pphhSS2Q/wVL5as1f3T//dLj8U2VB3XVyvGIIFAABw3c+/3BIO4LTc3d10/6UNNHFAW5X38dTKnUfUc8wSrdl91OnQAAAAgJJp93Jp8mWZSZLKTaTB351RkmThpig99Nkfdnlw5wjdedHp9wEAAMC5IVEC4Ixd2iRMM4Z2Vt1KAToYl6i+7yzX9F92Ox0WAAAAULJs/k56v7eUGCvV7CANmiMFVj3tbqt3H9Wd01YrNT1DvVtV0+NXNJabm1uxhAwAAODKSJQAKJC6lcrZviWRTcOUnJauR75Yq8e+Wquk1DSnQwMAAACc98en0ic3SKknpXqXZpbb8gs+7W5bDh3X4Cm/6GRKmro2qKQXr21pZ3YDAACg6JEoAVBg5X299PaNbWy9ZHOD20crdqvfhOU6GJvodGgAAACAc5aPl74cIqWnSs2vl274WPL2P+1u+4+d1IBJK3XsRIpa1aygt/ufJ29PLtcBAACKC5+8AJwVc3ebaSo56eZ2CvT11Jrdx3TlmMVatu2w06EBAAAAxSsjQ/phlDT3kcz1Dv+Vrn5H8vA67a5HE5J103srdCA2UfUql9Pkm9vJ39uz6GMGAABANhIlAM7JxQ0ra9bdXdS4aqBi4pPV/70VmvjTdmWYi0UAAACgrEtPk2bfL/30Uub6xY9LPZ43dxaddtcTyakaNOUXbYtOUNUgX70/uL2CA7yLPmYAAADkQqIEwDmrHRKgL+/opD6tqystPUPPztmgoR+tUXxSqtOhAQAAAEUnNUn6fLC0arIkN+mKV6SuD8nWpz2N5NR0/Xfaav2255gq+HvZJEm1Cn7FEjYAAAByI1ECoFD4eXvoletb6uleTeXp7qZv1h5Q73FLtS063unQAAAAgMKXFC99dL20fobk7iVdO0lqd+sZ7ZqenqGHPv9dP22Olp+Xhy1nWz+sfJGHDAAAgLyRKAFQaNzc3DSgY7im336+wgJ9tDUqXr3GLtXcPw86HRoAAABQeBIOS1N7StsXSV4B0o2fSs36nNGupkTtM9+s19e/7bc3GL3V/zydVyu4yEMGAABA/kiUACh0bWpXtH1L2kdUtOW3/jttlV6Yu1GpaelOhwYAAACcm9i90uQe0v7Vkl+wNHCWVPc/Z7z7W4u2afLSnXb55eta2p5/AAAAcBaJEgBFonJ5X314awfd2iXCrr+9aJsGTl6pw/FJTocGAAAAnJ3ozdJ7kVLMZimwujR4nlSjzRnv/snK3Xpp3ia7/PgVjdW7dfUiDBYAAABnikQJgCLj5eGux69sojE3tJa/t4eWbj2snmOW6Pc9x5wODQAAACiYfaukSZFS3F4ppH5mkqRSwzPefd66g3rsq7V2+Y6L6urWC+oUYbAAAAAoCBIlAIpcz5bVNOOuzqoTGqD9sYm6bvwyfbxyt9NhAQAAAGdm20JpSk/p5BGpWmtp8FypQs0z3n3fsZO675PflJ4hXd+2hh6OPPMECwAAAIoeiRIAxaJBWHnNGNpZ3ZuEKTktXcO/XKtHPv9DiSlpTocGAAAA5G/dDOnD66SUBCmia2ZPkoDQAh1i9JwNOpmSpnbhwXru6uZyc3MrsnABAABQcCRKABSbQF8vje/fRg/3aCh3N2n6r3vs7JK9R084HRoAAADwb79Okj67WUpPkZr0km78TPIpX6BDrNh+WLP/OGA//z51VTN5enAZDgAAUNLwCQ1AsXJ3d9OdF9XT+4M7KNjfS2v3xdq+JYu3RDsdGgAAAJApI0P66SVp9v1mRWozSLp2suTpU6DDpKVn6MlZ6+3yDe1rqUm1wCIKGAAAAOeCRAkAR3SpH6pZd3dRixpBOnoiRQMmrdS4hVuVbgo3AwAAAE5JT5fmDpd+GJW5fsGD0pWvSe4eBT7UJ7/s1oYDcQr09dQD3elLAgAAUFKRKAHgmBrB/vr09o7q166mvWnvpXmbdPu0VYpLTHE6NAAAALiitBRpxn+lFW9nrkeOli55QjqLniKxJ1L08rxNdnnYpQ1UMcC7sKMFAABAISFRAsBRvl4eev6aFnq+T3N5e7hr/vpD6jV2qTYdPO50aAAAAHAlySekT26U/pguuXlIV78jdbzzrA/32veb7czpBmHl1P/82oUaKgAAAAoXiRIAJUK/9rX02X87qnoFP+2ISVDvcUs16/f9TocFAAAAV3DyqPTB1dKWeZKnr3TDx1LLfmd9uM2HjuuD5bvs8sieTWngDgAAUMLxaQ1AidGyZgXbt6RLvVCdTEnT3R+v0TOz1yslLd3p0AAAAFBWxR2QJl8h7Vku+QZJN82QGkSe9eEyMjL09Kz1tpF7ZNMwda4XWqjhAgAAoPCRKAFQopjazVMHt9edF9W16+8t2aEb312hqOOJTocGAACAsubwNmlSpBS1TipXRbp5jlS74zkd8rv1h7Rka4y8Pd31+BVNCi1UAAAAFB0SJQBKHA93Nz3co5HG92+jcj6eWrnjiHqOWaJVu444HRoAAADKigN/SJN6SMd2ScER0uC5UpVm53TIxJQ0jfpmvV2+7YI6qlnRv5CCBQAAQFEiUQKgxOrRrIq+HtpZ9SuX06G4JPV9Z7mm/rzTljMAAAAAztrOpdKUK6SEKCmsuTR4nlQx4pwPa2ZD7zlyUlUCfXXnxZkzpAEAAFDykSgBUKLVrVROM+7qrCtaVFVqeoZGzlynYZ/+rpPJaU6HBgAAgNJo4xxpWh8pKU6q3Vka9I1UPuycD3swNlHjFm61y8MvbyR/b89CCBYAAADFgUQJgBIvwMdTY29orcevaGzLcn21Zp+ufmupdh1OcDo0AAAAlCZrPpSm95dSE6WGl0v9v8hs4F4Inv92g04kp6lt7WBd1bJaoRwTAAAAxYNECYBSwc3NTbdeUEcf3tpBoeW8tfHgcdu35IeNh5wODQAAAKXB0jelr++UMtKklv8nXf+B5OVXKIc2vfRm/LZfbm7Sk1c1tZ9dAQAAUHqQKAFQqpxfJ0Sz775A59WqoLjEVA2e8qtem79Z6en0LQEAAEAeTH+7+SOl+U9krnccKvUaJ3kUTmks8zn0yZmZDdz7tq2pZtULZ4YKAAAAig+JEgClTpUgX31yW0cN6Fjbrr+xYIsGT/1Fx04kOx0aAAAASpK0VGnm3dLS1zPXuz0lRT4ruRfepfBnq/Zo7b5Ylffx1IORDQvtuAAAACg+JEoAlErenu56ulczvXJdS/l4umvRpmj1HLtE6/bHOh0aAAAASoKUROmzgdKaDyQ3d+mqMVKX+wr1FHGJKXpp3ia7fG+3+got51OoxwcAAEAJTpSMGzdO4eHh8vX1VYcOHbRy5cp8t50yZYqtz5pzmP1yysjI0IgRI1S1alX5+fmpW7du2rJly9mEBsDFXNOmhr68s5NqVvTTniMn1eetn/XFqr1OhwUAAAAnJcZJH14rbZwteXhL178vnTeg0E/z5vdbFBOfrDqVAjSgY3ihHx8AAAAlNFEyffp0DRs2TCNHjtTq1avVsmVLRUZGKioqKt99AgMDdeDAgeyxa9euXM+/+OKLevPNNzV+/HitWLFCAQEB9piJiYln96oAuJSm1YI0e+gFurhhJSWlpuuBz37XEzP+VHJqutOhAQAAoLjFR0tTr5R2Lpa8y0v9v5Aa9yz002yNiteUn3fa5RFXNrEzngEAAFA6FfiT3KuvvqohQ4Zo0KBBatKkiU1u+Pv7a9KkSfnuY2aRVKlSJXuEhYXlmk3y+uuv6/HHH1evXr3UokULvf/++9q/f79mzJhx9q8MgEsJ8vfSewPb6b5u9eXmJn2wfJf6Tlimg7EkXAEAAFzG0V3SpEjpwO+Sf6h082wp4sJCP425jn1m9nqlpmfokkaVdVHDyoV+DgAAAJTQRElycrJWrVplS2NlH8Dd3a4vW7Ys3/3i4+NVu3Zt1axZ0yZD1q1bl/3cjh07dPDgwVzHDAoKsiW9TnVMAPgnd3c33detgSYNbKdAX0+t2X1MV45ZrOXbDzsdGgAAAIpa1IbMJMmRbVJQLWnwPKlaqyI51Q8bo/Tj5mh5ebjp8SubFMk5AAAAUEITJTExMUpLS8s1I8Qw6ybZkZeGDRva2SZff/21pk2bpvT0dHXq1El792b2EMjaryDHTEpKUlxcXK4BAFkublRZs+7uosZVA23N6BvfXaF3F2+3d/4BAACgDNqzUprUQzp+QKrUSLplnhRar0hOlZSaZmeTGIO7RCgiNKBIzgMAAIDiU+RFVDt27KgBAwaoVatW6tq1q7788ktVqlRJ77zzzlkfc/To0XbWSdYwM1UAIKfaIQH68o5O6tO6utLSMzTqmw0a+vEaJSSlOh0aAAAACtOW76X3e0mJx6Qa7aRB30qB1YrsdJOX7tTOwydUqbyP7v5P/SI7DwAAAEpooiQ0NFQeHh46dOhQrsfNuuk9cia8vLzUunVrbd261a5n7VeQYw4fPlyxsbHZY8+ePQV5GQBchJ+3h165vqWe7tVUnu5u+uaPA+o1bqm2Rcc7HRoAAAAKw9rPpY/7SiknpHrdpAFfS/4Vi+x0UXGJGrNgi11+pEcjlfPxLLJzAQAAoIQmSry9vdWmTRstWLAg+zFTSsusm5kjZ8KU7lq7dq2qVq1q1yMiImxCJOcxTSmtFStW5HtMHx8fBQYG5hoAkBc3NzcN6Biu6befr7BAH22NilevsUs198+8S/sBAACglFgxQfriVik9VWp2rdTvY8m7aMtgvTB3kxKS09SyZgU7cxkAAAAuWnpr2LBhmjhxoqZOnaoNGzbojjvuUEJCggYNGmSfN2W2zIyPLE8//bS+++47bd++XatXr1b//v21a9cu3XrrrdlfYt53330aNWqUZs6caZMo5hjVqlVT7969C/O1AnBhbWpXtH1L2kdUVHxSqv47bZVemLtRqWnpTocGAACAgjB95xaOlr59yKxI7W+T+kyUPL2L9LRrdh/VF6sze20+2bOJ3N3divR8AAAAKD4Fnifct29fRUdHa8SIEbbZuuk9Mnfu3Oxm7Lt375a7+9/5l6NHj2rIkCF22+DgYDsj5eeff1aTJk2yt3n44YdtsuW2227TsWPH1KVLF3tMX1/fwnqdAKDK5X314a0d9MK3G/Xukh16e9E2/bH3mN7s11oh5XycDg8AAACnk56emSD55d3M9YuGS10fMXfgFfFpM/TkrMwG7tecV0OtawUX6fkAAABQvNwyMsztOKWbKdVlmrqbfiWU4QJwJmb9vl+PfPGHTiSnqVqQr97u38aWUAAAoLTgMzBc7mcmNVn66nZp3ZfmUla6/CWp/ZBiOfXnq/bqwc9+V4C3hxY+eJEqB3JTHwAAQFn6/Fvg0lsAUBb0bFlNM+7qrIjQAO2PTdR145fp45W7nQ4LAAAAeUlOyGzabpIk7l7SNe8WW5LElG01JVuNuy+pT5IEAACgDCJRAsBlNQgrr6+Hdlb3JmFKTkvX8C/X6pHP/1BiSprToQEAACDLiSPS1KukbT9IXv7S/30iNb+22E4/5octij6epPAQfw3qHF5s5wUAAEDxIVECwKUF+nppfP82eiiyoUw/zum/7rGzS/YePeF0aAAAAIjdJ03qIe37VfILlgbMlOp1K7bT74hJ0KQlO+zyE1c2kY+nR7GdGwAAAMWHRAkAl+fu7qa7Lq6nqYPbK9jfS2v3xarnmCVavCXa6dAAAABcV8wWaVKkFLNJKl9NGjRXqtmuWEMYNXu9UtIy1LVBJf2nUeViPTcAAACKD4kSAPjLBfUradbdXdSiRpCOnkjRwEkrNW7hVqWnZzgdGgAAgGvZvyYzSRK7RwqpJ90yT6rcqFhDWLQpSgs2RsnT3c3OJnFzcyvW8wMAAKD4kCgBgBxqBPvr09s7ql+7mjL5kZfmbdLt01YpLjHF6dAAAABcw/YfpSlXSicOS1VbSYPnSRVqFWsIyanpenr2ert8c6dw1atcrljPDwAAgOJFogQA/sHXy0PPX9NCz/dpLm8Pd81ff0i9xy7V5kPHnQ4NAACgbFs/U/rwWik5Xoq4UBo4SwoILfYw3l+2U9ujExRazlv3dKtf7OcHAABA8SJRAgD56Ne+lj77b0dVC/LV9pgE9Rq7VLN+3+90WAAAoIwYN26cwsPD5evrqw4dOmjlypX5bjtlyhRb+innMPuVKaumSJ8NlNKSpcY9pf/7TPINLPYwoo8n6Y3vt9jlhyIbKtDXq9hjAAAAQPEiUQIAp9CyZgXbt6RzvRCdTEnT3R+v0TO2qWe606EBAIBSbPr06Ro2bJhGjhyp1atXq2XLloqMjFRUVFS++wQGBurAgQPZY9euXSoTMjKkxa9Ks+6VMtKl8wZI102VvJxJBL08b5OOJ6WqefUgXdempiMxAAAAoHiRKAGA0wgp56P3B3fQnRfVtevvLdmhG99doajjiU6HBgAASqlXX31VQ4YM0aBBg9SkSRONHz9e/v7+mjRpUr77mFkkVapUyR5hYWEq9dLTpe8elxY8lbneZZjU803J3cORcNbujdWnq/bY5SevaiJ3dxq4AwAAuAISJQBwBjzc3fRwj0Ya37+Nyvl4auWOI+o5ZolW7TridGgAAKCUSU5O1qpVq9StW7fsx9zd3e36smXL8t0vPj5etWvXVs2aNdWrVy+tW7dOpVpaivT1ndKysZnr3Z+Vuo00GSFHwsnIyNCTs9bZCS69W1VTm9oVHYkDAAAAxY9ECQAUQI9mVfT10M6qX7mcDsUlqd+E5bbZp7mwBgAAOBMxMTFKS0v714wQs37w4ME892nYsKGdbfL1119r2rRpSk9PV6dOnbR37958z5OUlKS4uLhco8RIOSlN7y/9/rHk5iH1Hi91GupoSF//tl+rdh2Vv7eHHr2ssaOxAAAAoHiRKAGAAqpbqZxm3NVZVzSvqpS0DI34ep2GvL9KO2MSnA4NAACUUR07dtSAAQPUqlUrde3aVV9++aUqVaqkd955J999Ro8eraCgoOxhZqKUCCePSR/0kTbPlTx9pX4fSq1ucDSkhKRUjf52g12+6+J6qhLkTH8UAAAAOINECQCchQAfT439v9Z6/IrGtizX9xsO6dLXftRzczYoLjHF6fAAAEAJFhoaKg8PDx06dCjX42bd9B45E15eXmrdurW2bt2a7zbDhw9XbGxs9tizJ7P3hqOOH5KmXCnt/lnyCZRu+kpqeJnTUemtRVvtbOFaFf11S5cIp8MBAABAMSNRAgBnyTRUvfWCOpp77wW6sEElO7tkwk/bdfFLizRt+S6lpqU7HSIAACiBvL291aZNGy1YsCD7MVNKy6ybmSNnwpTuWrt2rapWrZrvNj4+PgoMDMw1HHVkhzSpu3RorRRQWRo0R6rdydmYJO0+fEITF++wy/+7orF8vZxpJA8AAADnkCgBgHNUP6y83h/cXpMHtVPdSgE6nJCsx2f8qSveXKIlW2KcDg8AAJRAw4YN08SJEzV16lRt2LBBd9xxhxISEjRo0CD7vCmzZWaEZHn66af13Xffafv27Vq9erX69++vXbt26dZbb1WpcGi9NClSOrpTqlBbumWeVKW5SoJR36xXcmq6utQLVfcmufvGAAAAwDV4Oh0AAJQVFzesbC+wP1y+S699v0WbDh1X//dWqFvjynrs8saqU6mc0yECAIASom/fvoqOjtaIESNsA3fTe2Tu3LnZDd53794td/e/72s7evSohgwZYrcNDg62M1J+/vlnNWnSRKWCXwXJw0cKayb1/0Iqf2Ylxoqauanlu/WHbCnVkT2b2BnDAAAAcD1uGRkZGSrl4uLibHNCU3fX8enkACDp2Ilkvf79lswSXOkZ8nR308BO4brnP/UV5O/ldHgAgDKAz8AodT8zpvSWX3Bm0qQESElL1+VvLNaWqHjd3ClcT17V1OmQAAAA4NDnX0pvAUARqODvbS+25953of7TqLJNlry3ZIcuenmh3l+2k/4lAADA9VSMKDFJEsPc0GKSJMH+Xrq/WwOnwwEAAICDSJQAQBGqV7mcJt3cTlMHt1f9yuV09ESKRny9Tpe9sVg/bo52OjwAAACXdDg+Sa/N32yXH4xsyIxfAAAAF0eiBACKQdcGlfTtvRfomV5N7V2L5u7FgZNWatDkldoaFe90eAAAAC7llfmbFZeYqiZVA9WvXS2nwwEAAIDDSJQAQDHx9HDXTR3DtejBi3Vrlwjbt2ThpmhFvv6Tnpy5zvY1AQAAQNFatz9WH6/cbZdNqVTTyB0AAACujUQJABQzU9rh8Sub6Lv7L1S3xmFKS8/QlJ93qutLizRl6Q7bWBQAAACFLyMjQ0/NXK+MDOnKFlXVPqKi0yEBAACgBCBRAgAOqVOpnN4d2FbTbumghmHlFXsyRU/OWq8er/+khRuj7IU8AAAACs/sPw5o5c4j8vVy12OXN3Y6HAAAAJQQJEoAwGFd6ofqm3u66Nmrm6ligLe2RSdo0JRfNHDyL9p86LjT4QEAAJQJJ5PTNHrOBrt8R9d6qlbBz+mQAAAAUEKQKAGAEtK/5MYOtbXooYt0+4V15OXhpp82R+uyNxbriRl/6kgC/UsAAADOxds/btP+2ERVr+Cn27vWcTocAAAAlCAkSgCgBAn09dLwyxtr/v1dFdk0s3/JB8t3qetLC/Xu4u1KTqV/CQAAQEHtPXpC7/y4zS7/74rG8vXycDokAAAAlCAkSgCgBAoPDdA7N7XVR0M6qHHVQB1PTNWobzYo8vWf9P36Q/QvAQAAKIDn5mxQUmq6zq9TUZc1q+J0OAAAAChhSJQAQAnWqW6oZt/dRS9c01yh5by1IyZBt77/q256b6U2HoxzOjwAAIAS7+dtMZqz9qDc3aSRPZvKzc3N6ZAAAABQwpAoAYASzsPdTX3b1dLCBy/SHRfVlbeHu5ZsjdHlbyzWY1+tVUx8ktMhAgAAlEipael6etZ6u2z6wZmZugAAAMA/kSgBgFKivK+XHunRSN8P66rLm1dReob00YrduvilRZrw0zYlpaY5HSIAAECJ8vHK3dp48LiC/Lw07NIGTocDAACAEopECQCUMrVC/PXWjW00/bbz1ax6oI4npeq5ORvV/bWfNG/dQfqXAAAASDp2IlmvzN9slx/o3kDBAd5OhwQAAIASikQJAJRSHeqEaOZdXfTStS1UqbyPdh0+ods/WKX/m7hC6/fTvwQAALi2V+dv1rETKWpUpbz+r30tp8MBAABACUaiBABKMXd3N13XtqbtXzL04nry9nTXsu2HdcWYxRr+5R+KPk7/EgAA4Ho2HozTtOW77PKInk3k6cGlLwAAAPLHp0UAKAPK+XjqwciG+uGBrrqyRVWZ6lsfr9yji19epLcXbVNiCv1LAACAazBlSJ+aud72c7usWRV1qhvqdEgAAAAo4UiUAEAZUiPYX2P/7zx9/t+OalkjSPFJqXph7kZd+tqP+nbtAfqXAACAMm/unwftDFsfT3c9dnljp8MBAABAKUCiBADKoLbhFfXVnZ316vUtFRbooz1HTuqOD1er74Tl+nNfrNPhAQAAFAkzi3bUNxvs8u0X1lHNiv5OhwQAAIBSgEQJAJTh/iV9zqth+5fcc0l9e1flyh1H1HPsEj302e+Kikt0OkQAAIBCNeGn7dp37KSqBvnqvxfVdTocAAAAlBIkSgCgjPP39tSwSxvohwcvUq9W1Wz/ks9W7dVFLy/SuIVb6V8CAADKhP3HTuqtRVvt8vDLG9vPQAAAAMCZIFECAC6iegU/vdGvtb68s5Na1aygE8lpemneJl3yyo+a9ft++pcAAIBSbfS3G5WYkq724RXVs0VVp8MBAABAKUKiBABczHm1gvXlHZ30Rr9WtiyFKU9x98drdN34Zfp9zzGnwwMAACgwU17U3Pjh5iaN6NlEbmYBAAAAOEMkSgDARfuX9GpVXT88cJHu79ZAfl4e+nXXUfUat1TDPv1NB2PpXwIAAEqHtPQMPTlznV3u166WmlUPcjokAAAAuEKiZNy4cQoPD5evr686dOiglStX5rvtxIkTdcEFFyg4ONiObt26/Wv7m2++2d7xk3P06NHjbEIDABSAn7eH7u1W3zZ873NedfvYl6v36eKXF+nNBVt0Mpn+JQAAoGSb/sserT8Qp/K+nnqwewOnwwEAAIArJEqmT5+uYcOGaeTIkVq9erVatmypyMhIRUVF5bn9okWLdMMNN2jhwoVatmyZatasqe7du2vfvn25tjOJkQMHDmSPjz/++OxfFQCgQKoE+erV61tpxl2d1aZ2sE6mpOnV+Zt1ySuL9PVv++hfAgAASqTYEyl6+btNdtnMkg0p5+N0SAAAACiF3DIK+O2XmUHSrl07jR071q6np6fb5Mfdd9+tRx999LT7p6Wl2ZklZv8BAwZkzyg5duyYZsyYcVYvIi4uTkFBQYqNjVVgYOBZHQMAkMn8Wpj9xwE9/+1G27/EaF2rgkZc2UStawU7HR4A4C98BkZBlcWfmadmrdPkpTtVv3I5zbn3Anl5UF0aAAAABf/866kCSE5O1qpVqzR8+PDsx9zd3W05LTNb5EycOHFCKSkpqlix4r9mnlSuXNkmUf7zn/9o1KhRCgkJyfMYSUlJduR8wWfCJGnMuVH6eXl5ycPDw+kwgDLJlD/s2bKaLm0SpncXb9dbi7Zpze5juvqtn9W7VTU93KORqlXwczpMAADg4rYcOq73l+2yy6aBO0kSAAAAnK0CJUpiYmJssiEsLCzX42Z948aNZ3SMRx55RNWqVbPJlZxlt/r06aOIiAht27ZNjz32mC677DKbfMnry/DRo0frqaeeKtDd0QcPHrSzVlB2VKhQQVWqVLFf6gIofL5eHhr6n/q6rm1NvTxvkz5fvVczftuvuesO6vYL6+r2rnXk712gXyMAAACFwlzjPT17vW3kbm7uuKB+JadDAgAAQClWrN9wPf/88/rkk0/s7BHTCD5Lv379spebN2+uFi1aqG7duna7Sy655F/HMTNaTJ+UnDNKTPmv/GQlScyMFX9/f75YLwMXRWZmUlZfnKpVqzodElCmhQX66qXrWmpAx3A9M3u9Vu48ojcWbLGNUx+5rKF6tawud3f+XQUAAMVn/vpDWrwlRt4e7nr8isZOhwMAAABXSpSEhobaGR6HDh3K9bhZN3f2n8rLL79sEyXff/+9TYScSp06dey5tm7dmmeixMfHx44zYWbAZCVJ8ivlhdLHzy+z7I9Jlpj3ljJcQNFrXiNI028/X9/+eVDPzdmgvUdP6v7pv2vK0p0acmEddaobqooB3k6HCQAAyrjElDSN+maDXb71ggjVDglwOiQAAAC4UqLE29tbbdq00YIFC9S7d+/sZu5mfejQofnu9+KLL+rZZ5/VvHnz1LZt29OeZ+/evTp8+HChzBTI6kliZpKgbMl6T817TKIEKB5mRt7lzavqP40qa9LSHRr3w1b9vjdWQz9aY59vWi1QneuFqlPdELWPqEhpLgAAUOjeW7JDu4+cUFigj+66uJ7T4QAAAKAMKPA3WKbk1cCBA23Co3379nr99deVkJCgQYMG2ecHDBig6tWr2z4ixgsvvKARI0boo48+Unh4uC2DZZQrV86O+Ph422/kmmuusbNSTI+Shx9+WPXq1VNkZGShvVDKbZU9vKeAs/1L7ryonq5tU0PvLd6hRZuitenQca3bH2fHhJ+2y8vDTa1rBatLvVB1rheiFjUq0GQVAACck4OxiRq3cKtdfvSyRgrw4aYMAAAAnLsCf6rs27evoqOjbfLDJD1atWqluXPnZjd43717t9zd//4i7O2331ZycrKuvfbaXMcZOXKknnzySTsT4I8//tDUqVNtiSzT6L179+565plnzri8FgDAGZXL+2r45Y3tiDqeqGXbDmvp1hgt3XpY+46d1ModR+x4db5UzsdTHSIq2hknZjQIK0fCEwAAFMgLczfqRHKazqtVQb1bVXc6HAAAAJQRbhmmM3YpZ5q5BwUFKTY2VoGBgbmeS0xM1I4dOxQREZGrgbyrMrN67rvvPjtKO95boOQyv1p2HT6hJVtj9PM2Mw7r2InMUohZQsv52JkmneuGqnP9UFWvkNl7CABw7p+BgbL4M7Nq11Fd8/bPMvdZfH1XZztbFQAAACiMz7/MUy6hTneXddaMnIL65ZdfFBBwbs0OL7roIjuTyJRdA4D8/g0LDw2wo//5tZWenqH1B+LsbBOTPPll5xHFxCfp69/222GEh/hnzzbpWCdEwTSGBwAAfzGfJZ6atc4uX9emBkkSAAAAFCoSJSXUgQMHspenT59uS51t2rQp+zHT3yXnndtpaWny9Dz921mpUqUiiBYATs3d3U3NqgfZcXvXukpKTdPqXcfsbBOTOPljb6x2Hj6hnYd368MVu+2dolmN4c2Mk3bhFeXn7eH0ywAAAA75fNVe+3mhvI+nHops5HQ4AAAAKGPoqltCmcb2WcNMDzJ3Z2etb9y4UeXLl9e3336rNm3a2F4uS5Ys0bZt29SrVy/bL8YkUtq1a6fvv//+X6W3cs4EMcd99913dfXVV8vf31/169fXzJkzzyn2L774Qk2bNrVxmfO98soruZ5/66237HlMuSwTa87+NZ9//rmaN28uPz8/hYSEqFu3bkpISDineACUPD6eHupYN0QPdG+or+7srDUjLtXEAW11c6dw1a9cTqYo5J/74vTOj9s1YNJKtXzqO/WbsExjFmzR6t1HlZqW7vRLAAAAxSQuMUUvzttol++5pL4qlaeXJQAAAAqXS84oMTMwTqakOXJuPy+PQmte/Oijj+rll19WnTp1FBwcrD179ujyyy/Xs88+a5MU77//vnr27GlnotSqVSvf4zz11FN68cUX9dJLL2nMmDG68cYbtWvXLlWsWLHAMa1atUrXX3+9LQvWt29f/fzzz7rzzjtt0uPmm2/Wr7/+qnvuuUcffPCBOnXqpCNHjmjx4sXZs2huuOEGG4tJ3Bw/ftw+Vwba6AA4jUBfL13aJMwOIyouUUu3ZTaFN+W6DsQmavn2I3a8Mn+zvZu0Q50Q2+OkS71Q1atMY3gAAMoqc6NETHyy6lQK0MBO4U6HAwAAgDLIJRMlJknSZMQ8R869/ulI+XsXzv/2p59+Wpdeemn2uklstGzZMnv9mWee0VdffWVniAwdOjTf45gEhklQGM8995zefPNNrVy5Uj169ChwTK+++qouueQSPfHEE3a9QYMGWr9+vU3CmPPs3r3b9ki58sor7ayY2rVrq3Xr1tmJktTUVPXp08c+bpjZJQBcT+VAX13duoYdJlm6IyZBS7cd1tItMVq2/bBiT6bo+w2H7LDblzeN4UPVqa5JnoSqGo3hAQAoE7ZFx2vy0p12+Ykrm8jbk6IIAAAAKHwumSgpK9q2bZtrPT4+3s7k+Oabb7KTDidPnrTJiVNp0aJF9rJJYgQGBioqKuqsYtqwYYMt/5VT586dbbkv00fFJHZMEsTMgjGJGDOyyn6ZJI9JspjkSGRkpLp3727LcpnZMgBcl5kpUqdSOTtuOr+20tIztG5/bPZsE9MYPup4kr5as88Oo05owF+N4UPUsU6ogvy9nH4ZAADgLDwze71S0zP0n0aVdXHDyk6HAwAAgDLKJRMlpvyVmdnh1LkLi0lq5PTggw9q/vz5thxXvXr1bJ8Pk2hITk4+5XG8vLz+9aVkenrR1P83s0hWr16tRYsW6bvvvrNN6k1y55dfflGFChVs/KZcl3nOlAH73//+pxUrVigiIqJI4gFQ+ni4u6lFjQp23HFRXSWmmMbwR7NLdf2x95i2xyTY8cHyXbYxfPPqQepUN9SW6WobHizfQvy3GAAAFI0fNh7Sok3R8vJws7NJAAAAgKLikokSkwgorPJXJcnSpUtteSszQyNrhsnOnZnT1ItL48aNbRz/jMuU4PLwyPxi0tPT0zZpN2PkyJE2QfLDDz/YklvmvTEzUMwwSRQz+8SUDxs2bFixvg4ApYdJenQyZbfqheqhSNmyXCu2Z842MeW6tkbF64+9sXaM/3GbLdnRtnbwXzNOQm0SxSRfAABAyZGcmq5nZm+wy4M7RygiNPdNYgAAAEBhKnvZAhdWv359ffnll7aBu0k4mD4hRTUzJDo6Wr/99luux6pWraoHHnhA7dq1s/1RTDP3ZcuWaezYsXrrrbfsNrNnz9b27dt14YUX2pJac+bMsTE2bNjQzhxZsGCBLblVuXJlu27OY5IvAHCmgvy81L1pFTuMg7GJ+nlbjJZsjdHPWw/rYJxZP2zHS/M2qbyvpzraxvCZpbrqVqIxPAAATpu8dIftURZazkdD/1PP6XAAAABQxpEoKUNMI/XBgwerU6dOCg0N1SOPPKK4uLgiOddHH31kR04mOfL444/r008/tbNBzLpJnpim82ami2Fmj5hkjim3lZiYaJM7H3/8sZo2bWr7m/z000+2n4mJ28wmeeWVV3TZZZcVyWsA4BqqBPmqz3k17DCN4bdFJ2QmTv5qDH88MVXfrT9khxEW6KPOdTNnm5hh9gcAAMUn6niixvyw1S4/0qOhyvvSawwAAABFyy3DfGtUypkv1YOCghQbG2sbkedkvozfsWOH7XHh68uXXWUJ7y2Ac2Uaw6/dZxrDm/4mMfp111Fb6iOnupWyGsOH6vw6IXbGCgCU9M/AQGn+mXnws9/1+aq9alkjSF/d2VnulMgEAABAEX/+ZUYJAMBlmd4krWpWsOOui+vZxvCrdh39q0xXjP7YF2tnoJjx/rJdMt/TNK9RQZ3rhtjG8OfVpjE8AACF6bc9x2ySxBh5VVOSJAAAACgWJEoAAPiLSXpkzR4xYk+k2PJcmY3hY7Q9OkG/7zlmx1uLtsnHNIYPD1bTakGqFuSrahX87KgR7GdnntDrBACAM5eenqEnZ66zy31aV9d5tYKdDgkAAAAugkQJAAD5CPL3Uo9mVewwDsSe1NKtfyVOtsYo6njSX+uH/7Wvv7dHduKkuh2+udZN7xMvD3cHXhUAoKQYN26cXnrpJR08eFAtW7bUmDFj1L59+9Pu98knn+iGG25Qr169NGPGDJUVX63ZZ2eUmN+hj1zWyOlwAAAA4EJIlAAAcIaqBvnp2jY17DAtvrZGxWv59sPaEXNC+4+d1P7Yk/bPmPhknUhOs8+bkRcz2SSsvEme+P6dTAn2U7Wgv5MpgX6ezEoBgDJq+vTpGjZsmMaPH68OHTro9ddfV2RkpDZt2qTKlSvnu9/OnTv14IMP6oILLlBZEp+UqufnbrTLQ/9TT2GB9CAEAABA8SFRAgDAWTAJjPph5e34J9PrxCZOjiXaP/fZ5cxEyr6jmY8np6XrYFyiHat3H8vzHAHeHpnJkxwzUUxipXoFf/un+RKJWSkAUDq9+uqrGjJkiAYNGmTXTcLkm2++0aRJk/Too4/muU9aWppuvPFGPfXUU1q8eLGOHcv790dpNPaHrYo+nqTaIf66pUuE0+EAAADAxZAoAQCgCHqd1KlUzo78arAfTkj+K5mSmUjJTqb8lVwxzyckp2nzoXg78mL625pkyd9JlH+U+Ar2U6CvVxG/WgBAQSUnJ2vVqlUaPnx49mPu7u7q1q2bli1blu9+Tz/9tJ1tcsstt9hESVmxMyZBk5bssMuPX9FEPp4eTocEAAAAF0OiBACAYubu7qZK5X3saFmzQp7bnExOyy7llZlMSfxrNkrmzJQDf81KORCbaMeqXUfzPE55H8+/Eid/JVSC/06qmBFW3keezEoBgGIVExNjZ4eEhYXletysb9yYWX7qn5YsWaL33ntPv/322xmfJykpyY4scXFxKolGfbPe/k67oH6oujXOv+wYAAAAUFRIlAAAUAL5eXuobqVyduQ3KyUmISm7lFdeJb6OnkjR8aRUbTp03I68eLi7qYqdlZK72fzfyRRflWdWCgA46vjx47rppps0ceJEhYaGnvF+o0ePtmW6SrIfN0fr+w1R8nR308ieTejNBQAAAEeQKAEAoJTOSqlc3teO1rXy3uZEcmp2EiWvEl8HYk8qJS0j+3Epn1kpvp7/SJ5kJlBq/NU/pVI5ZqUAQEGYZIeHh4cOHTqU63GzXqVKlX9tv23bNtvEvWfPntmPpaen2z89PT1tA/i6dev+az9T2ss0jM85o6RmzZoqKVLS0vX0rHV2eUDHcNWr/O++XwAAAEBxIFECAEAZ5e/tqXqVy9mR36yU6PikHMmTzASKTZyYmSqxJ3XMzEpJTNXGg8ftyIu5+TckwFuh5TLLiZnESVZpsX+uB/l5cbcwAJfn7e2tNm3aaMGCBerdu3d24sOsDx069F/bN2rUSGvXrs312OOPP25nmrzxxhv5Jj98fHzsKKmm/rxT26IT7O+Qe7vVdzocAAAAuDASJSXU6b5EGjlypJ588smzPvZXX32VfVF2rtsBAErvrBTTDN6M82oF57lNQlKqnXmSq0dK1syUv3qlpJoyYPHJduSXTMni5eH2r0RKfgkWk+gBgLLKzPQYOHCg2rZtq/bt2+v1119XQkKCBg0aZJ8fMGCAqlevbstn+fr6qlmzZrn2r1Ahs8fVPx8vLWLik/TG91vs8oORDW0iHQAAAHAK30CUUAcOHMhenj59ukaMGGGn1GcpVy7vu4MBAChMAT5mVkr5fMuhpKVn6OiJZEUfT/p7xP+9bL4Iy3rMzE4xpb72xybacdpze3vkOzMlZ4IlJMBH3p6U/gJQuvTt21fR0dH2c/7BgwfVqlUrzZ07N7vB++7du+XuXnb/bXt53ibbR6tptUBd37bklAMDAACAayJRUkLlrE0cFBRkZ3fkfOzdd9/VK6+8oh07dig8PFz33HOP7rzzTvtccnKyvUPtiy++0NGjR+3F1n//+19bo9hsa1x99dX2z9q1a9t6xwVlSgOMGjVKEyZMsBd4jRs31vPPP68ePXqcNoaMjAzbVHLSpEm2DnNISIiuvfZavfnmm+f8/w0AULxMM3iTsDCjcdVTb5uUmqbD8cl5JlRyrkcdT1RiSroSktOUcPiEdh4+cdo4gv298k2oVCrnm71cwc/LzqQBgJLAlNnKq9SWsWjRolPuO2XKFJVWa/fGavqve+zyk1c1tb9LAAAAACe5ZqIkI0NKOf2XLkXCyz+zmPs5+PDDD+2dZ2PHjlXr1q21Zs0aDRkyRAEBAXb6vkk4zJw5U59++qlq1aqlPXv22GH88ssvqly5siZPnmyTGqaJ5NkwtZBNouadd96xMZikx1VXXaV169apfv36p4zBJE9ee+01ffLJJ2ratKm9g+73338/p/8nAICSz8fTI7sZ/KmYhLpJkuRKohxPtKW98pqxYkp/HT2RYsfmQ/GnPLanu5tCynn/O6Fil/9OqJhhZrTQTwUACpe9aWrWOntJdlXLamoXXtHpkAAAAAAXTZSYJMlz1Zw592P7Je+AczqE6U9ikhR9+vSx6xEREVq/fr1NWphEiZmmb5IVXbp0sV/wmFkjWSpVqpRd0zjnDJWCevnll/XII4+oX79+dv2FF17QwoULbW3lcePGnTIG85w5d7du3eTl5WUTKaYuMwAAhvm9Uc7H046I0FP/zjQN6Y+dTMkxKyUx3zJgJpFikiqH4pLsOB0/r79Lf4VmJ1dyJ1PM8PF0V3pGhtLTpTT7Z4YtSZa9nJG5nv38v7bJf7/0DOX9ePZjmc+bY/79eI7j5XFcc8y8z5f7XObLzJznyDOGjAx5urvb/1d+3h72T18vD/mbZe/MZfucl3v2uuk9k7m9+9/Pe//9p7eHOwkqoAyb+ft+/brrqP07P/zyRk6HAwAAALhwoqQUMw0et23bpltuucXOIsmSmppqS3QZN998sy699FI1bNjQzhq58sor1b1790KLIS4uTvv371fnzp1zPW7Ws2aGnCqG6667ziZU6tSpY5+7/PLL1bNnT3l68uMIACgYU0arYoC3HQ2r5N1HJUtyaroOJ/yjd0o+ZcDMjJaTKWnafeSEHSg+pgJPVtIkZyIlOwHz12O+OZZzJlqykjXZj2Ut51g3yS1KsAHF70RyqkbP2WiX77yorqoGnXqGIQAAAFBcXPObaVP+yszscOrc5yA+PrOkyMSJE9WhQ4dcz2WV0TrvvPNs75Jvv/1W33//va6//no7e+Pzzz9XcTlVDDVr1rSN6c3j8+fPt71VXnrpJf344492hgkAAEXBNHw3X8qdyRdzCUmpuZMp+SRWzDamQb2ZAOHh5iZ3M9z/WnZ3s3X3s5fdMtezn8/xeOa2OfbL9adJHuR3LLOcmTDKdcx/HOvvbXP8mbVfrsf1r20zz51/DGaWjkkqnUxO1UmbYEq364n2scyE0z//tM/943FzHMP8YfvTJKcV6c+Dr5nlkkciJa9ZLjm3y+v5trWD5Wn+JwE4pbcWbtPBuETVCPbTkAvrOB0OAAAA4OKJEvNtxjmWv3KKaYperVo1bd++XTfeeGO+2wUGBqpv3752mEbpZubGkSNHVLFiRZuMSEs7+y8fzLFNDEuXLlXXrl2zHzfrOUtonSoGPz8/O4vEjLvuukuNGjXS2rVrbYIFAACnBfh42lE75NSfF0x5KoNSUecuJe2vBEtW8iSfRMvfSZa/EzLmLnWboMn1fNZzfx/PzCrKkpiSbsdRpZxz7OufjiRRApzG7sMnNGHxdrv8+BWNbdIRAAAAKClcM1FSyj311FO65557bKktk3xISkrSr7/+qqNHj2rYsGF69dVXVbVqVdtk3d3dXZ999pntCWL6khjh4eFasGCBLZXl4+Oj4ODgfM9lZoX89ttvuR4zvUceeugh2yulbt26atWqlW0Ob7YzjeaNU8UwZcoUm6gxM2L8/f01bdo0mzjJ2ccEAIDSgARJ4fHycLcj0LfoZpeaPiunSqT8M0mT8/lcM2RMkuWvZZOk8fXkC1/gTHSIqGj/HkY2PfteiQAAAEBRIFFSCt166602wWDKVZmERUBAgJo3b6777rvPPl++fHm9+OKL2rJliy3H1a5dO82ZM8cmLAzTCN4kVEz5rurVq2vnzp35nsts90+LFy+2iZrY2Fg98MADioqKUpMmTTRz5kybRDldDCZZ8vzzz9tjm4SJiX3WrFkKCQkpsv9nAAAAplRY1mwhAMWrVoi/3h/c3pbVI8kMAACAksYtI6tmRClmmoub2RXmi3tT7imnxMREOysiIiJCvr6+jsWIwsd7CwAAXNmpPgMDeeFnBgAAAK4krgCffymmDAAAAAAAAAAAXBaJEgAAAAAAAAAA4LJIlAAAAAAAAAAAAJdFogQAAAAAAAAAALgsEiUAAAAAAAAAAMBluUyiJD093ekQUMh4TwEAAAAAAAAA58pTZZy3t7fc3d21f/9+VapUya67ubk5HRbOQUZGhpKTkxUdHW3fW/OeAgAAAAAAAABwNsp8osR8kR4REaEDBw7YZAnKDn9/f9WqVcu+xwAAAAAAAAAAnI0ynygxzIwD84V6amqq0tLSnA4HhcDDw0Oenp7MDgIAAAAAAAAAnBOXSJQY5gt1Ly8vOwAAAAAAAAAAAIyzqlk0btw4hYeHy9fXVx06dNDKlStPuf1nn32mRo0a2e2bN2+uOXPm/KvnxIgRI1S1alX5+fmpW7du2rJlC+8QAAAAAAAAAAAoWYmS6dOna9iwYRo5cqRWr16tli1bKjIyUlFRUXlu//PPP+uGG27QLbfcojVr1qh37952/Pnnn9nbvPjii3rzzTc1fvx4rVixQgEBAfaYiYmJ5/bqAAAAAAAAAAAATsEtw0znKAAzg6Rdu3YaO3asXU9PT1fNmjV1991369FHH/3X9n379lVCQoJmz56d/dj555+vVq1a2cSIOX21atX0wAMP6MEHH7TPx8bGKiwsTFOmTFG/fv1OG1NcXJyCgoLsfoGBgQV5OQAAAECpxGdgFBQ/MwAAAHAlcQX4/FugHiXJyclatWqVhg8fnv2Yu7u7LZW1bNmyPPcxj5sZKDmZ2SIzZsywyzt27NDBgwftMbKY4E1CxuybV6IkKSnJjizmhWa9cAAAAMAVZH32LeB9T3BhWT8rXDcBAADAFcQV4JqpQImSmJgYpaWl2dkeOZn1jRs35rmPSYLktb15POv5rMfy2+afRo8eraeeeupfj5uZLQAAAIArOX78uL3RCDiTnxWD6yYAAAC4kuNncM1UoERJSWFmtOScpWLKfx05ckQhISFyc3NzJDNlLjb27NnDFHYXxc+Aa+P9d228/66N99+1Of3+m7uizAd+U8YWOBPmZ8X8vJYvX57rJhQ73n/Xxvvv2nj/XRvvv2uLK0XXTAVKlISGhsrDw0OHDh3K9bhZr1KlSp77mMdPtX3Wn+axqlWr5trG9DHJi4+Pjx05VahQQU4zbzZ/4V0bPwOujffftfH+uzbef9fm5PvPTBIUhCmbXKNGDafD4N9MF8f779p4/10b779r4/13bYGl4JrJvSAH9fb2Vps2bbRgwYJcsznMeseOHfPcxzyec3tj/vz52dtHRETYZEnObUymacWKFfkeEwAAAAAAAAAAoDAUuPSWKXk1cOBAtW3bVu3bt9frr7+uhIQEDRo0yD4/YMAAVa9e3fYRMe6991517dpVr7zyiq644gp98skn+vXXXzVhwgT7vJnyfd9992nUqFGqX7++TZw88cQTdjpM7969C+VFAgAAAAAAAAAAFEqipG/fvoqOjtaIESNss3VTHmvu3LnZzdh3795tp3Rn6dSpkz766CM9/vjjeuyxx2wyZMaMGWrWrFn2Ng8//LBNttx22206duyYunTpYo/p6+ur0sCUARs5cuS/yoHBdfAz4Np4/10b779r4/13bbz/QMHwd8a18f67Nt5/18b779p4/12bTyl6/90yTEcTAAAAAAAAAAAAF1SgHiUAAAAAAAAAAABlCYkSAAAAAAAAAADgskiUAAAAAAAAAAAAl0WiBAAAAAAAAAAAuCwSJYVg3LhxCg8Pl6+vrzp06KCVK1c6HRKKwejRo9WuXTuVL19elStXVu/evbVp0yanw4JDnn/+ebm5uem+++5zOhQUk3379ql///4KCQmRn5+fmjdvrl9//dXpsFAM0tLS9MQTTygiIsK+93Xr1tUzzzyjjIwMp0NDEfnpp5/Us2dPVatWzf5bP2PGjFzPm/d+xIgRqlq1qv2Z6Natm7Zs2eJYvEBJxDWT6+K6CVm4ZnJNXDe5Lq6bXMtPZeCaiUTJOZo+fbqGDRumkSNHavXq1WrZsqUiIyMVFRXldGgoYj/++KPuuusuLV++XPPnz1dKSoq6d++uhIQEp0NDMfvll1/0zjvvqEWLFk6HgmJy9OhRde7cWV5eXvr222+1fv16vfLKKwoODnY6NBSDF154QW+//bbGjh2rDRs22PUXX3xRY8aMcTo0FBHzu918xjNf9ObFvP9vvvmmxo8frxUrViggIMB+HkxMTCz2WIGSiGsm18Z1EwyumVwT102ujesm15JQBq6Z3DJI450TczeUuTvG/KU30tPTVbNmTd1999169NFHnQ4PxSg6OtreIWUuBC688EKnw0ExiY+P13nnnae33npLo0aNUqtWrfT66687HRaKmPn3fenSpVq8eLHTocABV155pcLCwvTee+9lP3bNNdfYu2KmTZvmaGwoeubuqK+++sreEW2Yj9LmrqkHHnhADz74oH0sNjbW/oxMmTJF/fr1czhiwHlcMyEnrptcD9dMrovrJtfGdZPrciul10zMKDkHycnJWrVqlZ0qlMXd3d2uL1u2zNHYUPzMX3CjYsWKToeCYmTujrviiity/TuAsm/mzJlq27atrrvuOnuh37p1a02cONHpsFBMOnXqpAULFmjz5s12/ffff9eSJUt02WWXOR0aHLBjxw4dPHgw1++BoKAg+8UwnwcBrpnwb1w3uR6umVwX102ujesmlLZrJk+nAyjNYmJibL09k/3Kyaxv3LjRsbhQ/MxdcabOqplS2qxZM6fDQTH55JNPbPkIM40crmX79u12CrEpI/LYY4/Zn4F77rlH3t7eGjhwoNPhoRjujIuLi1OjRo3k4eFhPws8++yzuvHGG50ODQ4wH/iNvD4PZj0HuDKumZAT102uh2sm18Z1k2vjugml7ZqJRAlQSHfI/PnnnzYzDtewZ88e3XvvvbbOsmlKCte7yDd3Rj333HN23dwZZf4NMLU2+cBf9n366af68MMP9dFHH6lp06b67bff7Jc+Ziox7z8AAPnjusm1cM0ErptcG9dNKG0ovXUOQkNDbUb00KFDuR4361WqVHEsLhSvoUOHavbs2Vq4cKFq1KjhdDgoJqaEhGlAamrtenp62mHqLJvGVGbZ3CmBsqtq1apq0qRJrscaN26s3bt3OxYTis9DDz1k744ydVSbN2+um266Sffff79Gjx7tdGhwQNZnPj4PAnnjmglZuG5yPVwzgesm18Z1E0rbNROJknNgpgq2adPG1tvLmS036x07dnQ0NhQ904jIfNg3zYl++OEHRUREOB0SitEll1yitWvX2jsisoa5U8ZMITXL5gsBlF2mXMSmTZtyPWbqrtauXduxmFB8Tpw4Yevr52T+zpvPAHA95ve/+XCf8/OgKTGwYsUKPg8CXDOB6yaXxjUTuG5ybVw3obRdM1F66xyZOotmupj5Zd++fXu9/vrrSkhI0KBBg5wODcUwbdxMH/z6669Vvnz57Jp6phmRn5+f0+GhiJn3/J91lQMCAhQSEkK9ZRdg7oIxjenMFPLrr79eK1eu1IQJE+xA2dezZ09bW7dWrVp2CvmaNWv06quvavDgwU6HhiISHx+vrVu35mpGaL7gMY2Izc+BKSEwatQo1a9f314EPPHEE7akQO/evR2NGygpuGZybVw3uS6umcB1k2vjusm1xJeFa6YMnLMxY8Zk1KpVK8Pb2zujffv2GcuXL3c6JBQD89cnrzF58mSnQ4NDunbtmnHvvfc6HQaKyaxZszKaNWuW4ePjk9GoUaOMCRMmOB0SiklcXJz9u25+9/v6+mbUqVMn43//+19GUlKS06GhiCxcuDDP3/kDBw60z6enp2c88cQTGWFhYfbfhEsuuSRj06ZNTocNlChcM7kurpuQE9dMrofrJtfFdZNrWVgGrpnczH+cTtYAAAAAAAAAAAA4gR4lAAAAAAAAAADAZZEoAQAAAAAAAAAALotECQAAAAAAAAAAcFkkSgAAAAAAAAAAgMsiUQIAAAAAAAAAAFwWiRIAAAAAAAAAAOCySJQAAAAAAAAAAACXRaIEAAAAAAAAAAC4LBIlAAAAAAAAAADAZZEoAQAAAAAAAAAALotECQAAAAAAAAAAcFkkSgAAAAAAAAAAgFzV/wPBnSpWNZtQLwAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 2000x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(20,5))\n",
+    "plt.subplot(1,2,1)\n",
+    "plt.plot(train_loss_history,label=\"Train Loss\")\n",
+    "plt.plot(test_loss_history,label=\"Test Loss\")\n",
+    "plt.title(\"train loss history\")\n",
+    "plt.legend()\n",
+    "plt.subplot(1,2,2)\n",
+    "plt.plot(train_accuracy_history,label=\"Train Accuracy\")\n",
+    "plt.plot(test_accuracy_history,label=\"Test Accuracy\")\n",
+    "plt.title(\"train accuracy history\")\n",
+    "plt.legend()\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 110,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T20:47:57.680163Z",
+     "start_time": "2025-06-22T20:47:44.447319Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "torch.save(vggnet.state_dict(),\"adam_vggnet.pth\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### RMSProp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 111,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T20:47:58.302532Z",
+     "start_time": "2025-06-22T20:47:57.694317Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "vggnet = VGG11(num_classes).to(device)\n",
+    "vggnet_optimizer = torch.optim.Adam(vggnet.parameters(), lr=learning_rate)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 112,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:17:39.163284Z",
+     "start_time": "2025-06-22T20:47:58.315771Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 04:50:40.501190 - Epoch [1/20], Train Loss: 1.7087, Train Accuracy: 36.42%, Test Loss: 1.4292, Test Accuracy: 48.66%\n",
+      "2025-06-23 04:53:22.418651 - Epoch [2/20], Train Loss: 1.2031, Train Accuracy: 56.94%, Test Loss: 1.0615, Test Accuracy: 63.34%\n",
+      "2025-06-23 04:56:04.288794 - Epoch [3/20], Train Loss: 0.9421, Train Accuracy: 66.54%, Test Loss: 0.9265, Test Accuracy: 67.38%\n",
+      "2025-06-23 04:58:45.882516 - Epoch [4/20], Train Loss: 0.7686, Train Accuracy: 72.83%, Test Loss: 0.8521, Test Accuracy: 69.58%\n",
+      "2025-06-23 05:01:28.096352 - Epoch [5/20], Train Loss: 0.6449, Train Accuracy: 77.15%, Test Loss: 0.8663, Test Accuracy: 70.02%\n",
+      "2025-06-23 05:04:09.579174 - Epoch [6/20], Train Loss: 0.5151, Train Accuracy: 81.59%, Test Loss: 0.8479, Test Accuracy: 72.26%\n",
+      "2025-06-23 05:06:51.889913 - Epoch [7/20], Train Loss: 0.4149, Train Accuracy: 85.24%, Test Loss: 0.8980, Test Accuracy: 71.88%\n",
+      "2025-06-23 05:09:33.670596 - Epoch [8/20], Train Loss: 0.3185, Train Accuracy: 88.70%, Test Loss: 1.0517, Test Accuracy: 70.92%\n",
+      "2025-06-23 05:12:15.518445 - Epoch [9/20], Train Loss: 0.2554, Train Accuracy: 90.95%, Test Loss: 1.1934, Test Accuracy: 71.68%\n",
+      "2025-06-23 05:14:57.302865 - Epoch [10/20], Train Loss: 0.1939, Train Accuracy: 93.22%, Test Loss: 1.2796, Test Accuracy: 70.30%\n",
+      "2025-06-23 05:17:39.154287 - Epoch [11/20], Train Loss: 0.1616, Train Accuracy: 94.36%, Test Loss: 1.4073, Test Accuracy: 69.84%\n"
+     ]
+    }
+   ],
+   "source": [
+    "train_loss_history = []\n",
+    "test_loss_history = []\n",
+    "train_accuracy_history = []\n",
+    "test_accuracy_history = []\n",
+    "\n",
+    "total_step = len(train_loader)\n",
+    "\n",
+    "for epoch in range(num_epochs):\n",
+    "    if epoch>early_stopping:break\n",
+    "    # Training\n",
+    "    accumulate_train_loss,num_total_train_sample,num_accurate_train_prediction = 0.0 ,0,0\n",
+    "    for i, (images, labels) in enumerate(train_loader):\n",
+    "        # Move tensors to the configured device\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "\n",
+    "        # Forward pass\n",
+    "        outputs = vggnet(images)\n",
+    "        loss = criterion(outputs, labels)\n",
+    "\n",
+    "        # Backward and optimize\n",
+    "        vggnet_optimizer.zero_grad()\n",
+    "        loss.backward()\n",
+    "        vggnet_optimizer.step()\n",
+    "\n",
+    "        accumulate_train_loss += loss.item()\n",
+    "        num_total_train_sample += labels.size()[0]\n",
+    "        num_accurate_train_prediction += (outputs.argmax(1)==labels).sum().item()\n",
+    "\n",
+    "\n",
+    "\n",
+    "    #print ('{} - Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'\n",
+    "    #               .format(str(datetime.now()), epoch+1, num_epochs, i+1, total_step, accumulate_train_loss/len(train_loader)))\n",
+    "\n",
+    "    train_loss,train_accuracy = accumulate_train_loss/len(train_loader),num_accurate_train_prediction/num_total_train_sample\n",
+    "    train_loss_history += [train_loss]\n",
+    "    train_accuracy_history += [train_accuracy]\n",
+    "\n",
+    "    # Validation\n",
+    "    with torch.no_grad():\n",
+    "        correct = 0\n",
+    "        total = 0\n",
+    "        accumulate_test_loss = 0\n",
+    "        for images, labels in valid_loader:\n",
+    "            images = images.to(device)\n",
+    "            labels = labels.to(device)\n",
+    "            outputs = vggnet(images)\n",
+    "            loss = criterion(outputs, labels)\n",
+    "            accumulate_test_loss += loss.item()\n",
+    "            _, predicted = torch.max(outputs.data, 1)\n",
+    "            total += labels.size(0)\n",
+    "            correct += (predicted == labels).sum().item()\n",
+    "            del images, labels, outputs\n",
+    "        test_accuracy,test_loss = correct / total,accumulate_test_loss/len(valid_loader)\n",
+    "        #print('Accuracy of the network on the {} validation images: {} %'.format(5000, 100 * correct / total))\n",
+    "        test_accuracy_history += [test_accuracy]\n",
+    "        test_loss_history += [test_loss]\n",
+    "    print(f\"{str(datetime.now())} - Epoch [{epoch+1}/{num_epochs}], Train Loss: {train_loss:.4f}, Train Accuracy: {train_accuracy*100:.2f}%, Test Loss: {test_loss:.4f}, Test Accuracy: {test_accuracy*100:.2f}%\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "training loss is decreasing and test accuracy is increasing all the time\n",
+    "\n",
+    "however, test loss decreases before 3nd epoch and begin to rise after 3nd epoch, which is a sign of overfitting\n",
+    "\n",
+    "however, test accuracy is increasing before 4th epoch, and becomes stable after 4th epoch, and seems to "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 113,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:17:39.454809Z",
+     "start_time": "2025-06-22T21:17:39.301878Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(20,5))\n",
+    "plt.subplot(1,2,1)\n",
+    "plt.plot(train_loss_history,label=\"Train Loss\")\n",
+    "plt.plot(test_loss_history,label=\"Test Loss\")\n",
+    "plt.title(\"train loss history\")\n",
+    "plt.legend()\n",
+    "plt.subplot(1,2,2)\n",
+    "plt.plot(train_accuracy_history,label=\"Train Accuracy\")\n",
+    "plt.plot(test_accuracy_history,label=\"Test Accuracy\")\n",
+    "plt.title(\"train accuracy history\")\n",
+    "plt.legend()\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 114,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:17:52.760224Z",
+     "start_time": "2025-06-22T21:17:39.474325Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "torch.save(vggnet.state_dict(),\"rmsprop_vggnet.pth\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 115,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:17:52.815410Z",
+     "start_time": "2025-06-22T21:17:52.774788Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "del vggnet\n",
+    "torch.cuda.empty_cache()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ResNet"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Adam"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 116,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:17:53.350761Z",
+     "start_time": "2025-06-22T21:17:52.829414Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "resnet = ResNet(num_classes).to(device)\n",
+    "resnet_optimizer = torch.optim.Adam(resnet.parameters(), lr=learning_rate)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 117,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:31:25.898877Z",
+     "start_time": "2025-06-22T21:17:53.365713Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.07it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:19:07.547883 - Epoch [1/20], Train Loss: 1.7771, Train Accuracy: 44.64%, Test Loss: 1.2217, Test Accuracy: 56.62%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:10<00:00, 10.00it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:20:22.067992 - Epoch [2/20], Train Loss: 1.1118, Train Accuracy: 60.20%, Test Loss: 1.0549, Test Accuracy: 62.44%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.14it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:21:35.647345 - Epoch [3/20], Train Loss: 0.9123, Train Accuracy: 67.71%, Test Loss: 0.9352, Test Accuracy: 67.80%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.11it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:22:49.510506 - Epoch [4/20], Train Loss: 0.7586, Train Accuracy: 72.79%, Test Loss: 0.8830, Test Accuracy: 69.00%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.12it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:24:03.338762 - Epoch [5/20], Train Loss: 0.6262, Train Accuracy: 77.67%, Test Loss: 0.8580, Test Accuracy: 71.00%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.07it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:25:17.463466 - Epoch [6/20], Train Loss: 0.4943, Train Accuracy: 82.47%, Test Loss: 0.8950, Test Accuracy: 70.88%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.12it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:26:31.100507 - Epoch [7/20], Train Loss: 0.3866, Train Accuracy: 85.99%, Test Loss: 0.8949, Test Accuracy: 71.96%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.16it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:27:44.472171 - Epoch [8/20], Train Loss: 0.2787, Train Accuracy: 90.05%, Test Loss: 1.0742, Test Accuracy: 70.98%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.10it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:28:58.348512 - Epoch [9/20], Train Loss: 0.2043, Train Accuracy: 92.64%, Test Loss: 1.1987, Test Accuracy: 70.54%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.08it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:30:12.275953 - Epoch [10/20], Train Loss: 0.1604, Train Accuracy: 94.40%, Test Loss: 1.3451, Test Accuracy: 70.96%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.17it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:31:25.891467 - Epoch [11/20], Train Loss: 0.1357, Train Accuracy: 95.31%, Test Loss: 1.3470, Test Accuracy: 70.62%\n"
+     ]
+    }
+   ],
+   "source": [
+    "train_loss_history = []\n",
+    "test_loss_history = []\n",
+    "train_accuracy_history = []\n",
+    "test_accuracy_history = []\n",
+    "\n",
+    "total_step = len(train_loader)\n",
+    "\n",
+    "for epoch in range(num_epochs):\n",
+    "    if epoch>early_stopping:break\n",
+    "    # Training\n",
+    "    accumulate_train_loss,num_total_train_sample,num_accurate_train_prediction = 0.0 ,0,0\n",
+    "    for i, (images, labels) in enumerate(tqdm(train_loader)):\n",
+    "        # Move tensors to the configured device\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "\n",
+    "        # Forward pass\n",
+    "        outputs = resnet(images)\n",
+    "        loss = criterion(outputs, labels)\n",
+    "\n",
+    "        # Backward and optimize\n",
+    "        resnet_optimizer.zero_grad()\n",
+    "        loss.backward()\n",
+    "        resnet_optimizer.step()\n",
+    "\n",
+    "        accumulate_train_loss += loss.item()\n",
+    "        num_total_train_sample += labels.size()[0]\n",
+    "        num_accurate_train_prediction += (outputs.argmax(1)==labels).sum().item()\n",
+    "\n",
+    "\n",
+    "\n",
+    "    #print ('{} - Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'\n",
+    "    #               .format(str(datetime.now()), epoch+1, num_epochs, i+1, total_step, accumulate_train_loss/len(train_loader)))\n",
+    "\n",
+    "    train_loss,train_accuracy = accumulate_train_loss/len(train_loader),num_accurate_train_prediction/num_total_train_sample\n",
+    "    train_loss_history += [train_loss]\n",
+    "    train_accuracy_history += [train_accuracy]\n",
+    "\n",
+    "    # Validation\n",
+    "    with torch.no_grad():\n",
+    "        correct = 0\n",
+    "        total = 0\n",
+    "        accumulate_test_loss = 0\n",
+    "        for images, labels in valid_loader:\n",
+    "            images = images.to(device)\n",
+    "            labels = labels.to(device)\n",
+    "            outputs = resnet(images)\n",
+    "            loss = criterion(outputs, labels)\n",
+    "            accumulate_test_loss += loss.item()\n",
+    "            _, predicted = torch.max(outputs.data, 1)\n",
+    "            total += labels.size(0)\n",
+    "            correct += (predicted == labels).sum().item()\n",
+    "            del images, labels, outputs\n",
+    "        test_accuracy,test_loss = correct / total,accumulate_test_loss/len(valid_loader)\n",
+    "        #print('Accuracy of the network on the {} validation images: {} %'.format(5000, 100 * correct / total))\n",
+    "        test_accuracy_history += [test_accuracy]\n",
+    "        test_loss_history += [test_loss]\n",
+    "    print(f\"{str(datetime.now())} - Epoch [{epoch+1}/{num_epochs}], Train Loss: {train_loss:.4f}, Train Accuracy: {train_accuracy*100:.2f}%, Test Loss: {test_loss:.4f}, Test Accuracy: {test_accuracy*100:.2f}%\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "training loss is decreasing and test accuracy is increasing all the time\n",
+    "\n",
+    "however, test loss decreases before 5nd epoch and begin to rise after 5nd epoch, which is a sign of overfitting\n",
+    "\n",
+    "however, test accuracy is increasing before 5th epoch, and becomes stable after 5th epoch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 118,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:31:26.241463Z",
+     "start_time": "2025-06-22T21:31:26.073218Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(20,5))\n",
+    "plt.subplot(1,2,1)\n",
+    "plt.plot(train_loss_history,label=\"Train Loss\")\n",
+    "plt.plot(test_loss_history,label=\"Test Loss\")\n",
+    "plt.title(\"train loss history\")\n",
+    "plt.legend()\n",
+    "plt.subplot(1,2,2)\n",
+    "plt.plot(train_accuracy_history,label=\"Train Accuracy\")\n",
+    "plt.plot(test_accuracy_history,label=\"Test Accuracy\")\n",
+    "plt.title(\"train accuracy history\")\n",
+    "plt.legend()\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 119,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:31:37.323973Z",
+     "start_time": "2025-06-22T21:31:26.257911Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "torch.save(resnet.state_dict(),\"adam_resnet.pth\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### RMSProp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 120,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:31:37.852755Z",
+     "start_time": "2025-06-22T21:31:37.352299Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "resnet = ResNet(num_classes).to(device)\n",
+    "resnet_optimizer = torch.optim.RMSprop(resnet.parameters(), lr=learning_rate)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 121,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:44:33.021400Z",
+     "start_time": "2025-06-22T21:31:37.868176Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:06<00:00, 10.53it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:32:48.903460 - Epoch [1/20], Train Loss: 1859.9671, Train Accuracy: 31.96%, Test Loss: 2.4824, Test Accuracy: 28.88%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:06<00:00, 10.67it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:33:58.906021 - Epoch [2/20], Train Loss: 1.5068, Train Accuracy: 47.25%, Test Loss: 3.2892, Test Accuracy: 25.48%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:05<00:00, 10.67it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:35:09.563930 - Epoch [3/20], Train Loss: 1.2458, Train Accuracy: 55.40%, Test Loss: 1.6373, Test Accuracy: 43.82%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:07<00:00, 10.45it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:36:21.116295 - Epoch [4/20], Train Loss: 1.1347, Train Accuracy: 61.66%, Test Loss: 1.1753, Test Accuracy: 58.22%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:06<00:00, 10.54it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:37:31.933524 - Epoch [5/20], Train Loss: 0.9069, Train Accuracy: 67.75%, Test Loss: 1.4641, Test Accuracy: 55.56%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:05<00:00, 10.69it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:38:42.170325 - Epoch [6/20], Train Loss: 0.7611, Train Accuracy: 73.24%, Test Loss: 0.9630, Test Accuracy: 66.82%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:05<00:00, 10.69it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:39:52.094915 - Epoch [7/20], Train Loss: 0.6048, Train Accuracy: 78.73%, Test Loss: 1.0539, Test Accuracy: 67.42%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:05<00:00, 10.73it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:41:01.826187 - Epoch [8/20], Train Loss: 0.4501, Train Accuracy: 84.21%, Test Loss: 1.0981, Test Accuracy: 65.50%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:06<00:00, 10.60it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:42:12.497261 - Epoch [9/20], Train Loss: 0.3200, Train Accuracy: 88.69%, Test Loss: 1.2404, Test Accuracy: 66.90%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:06<00:00, 10.66it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:43:22.670162 - Epoch [10/20], Train Loss: 0.2183, Train Accuracy: 92.24%, Test Loss: 1.3505, Test Accuracy: 68.54%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:05<00:00, 10.71it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-23 05:44:33.016152 - Epoch [11/20], Train Loss: 0.1635, Train Accuracy: 94.24%, Test Loss: 1.5689, Test Accuracy: 68.40%\n"
+     ]
+    }
+   ],
+   "source": [
+    "train_loss_history = []\n",
+    "test_loss_history = []\n",
+    "train_accuracy_history = []\n",
+    "test_accuracy_history = []\n",
+    "\n",
+    "total_step = len(train_loader)\n",
+    "\n",
+    "for epoch in range(num_epochs):\n",
+    "    if epoch>early_stopping:break\n",
+    "    # Training\n",
+    "    accumulate_train_loss,num_total_train_sample,num_accurate_train_prediction = 0.0 ,0,0\n",
+    "    for i, (images, labels) in enumerate(tqdm(train_loader)):\n",
+    "        # Move tensors to the configured device\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "\n",
+    "        # Forward pass\n",
+    "        outputs = resnet(images)\n",
+    "        loss = criterion(outputs, labels)\n",
+    "\n",
+    "        # Backward and optimize\n",
+    "        resnet_optimizer.zero_grad()\n",
+    "        loss.backward()\n",
+    "        resnet_optimizer.step()\n",
+    "\n",
+    "        accumulate_train_loss += loss.item()\n",
+    "        num_total_train_sample += labels.size()[0]\n",
+    "        num_accurate_train_prediction += (outputs.argmax(1)==labels).sum().item()\n",
+    "\n",
+    "\n",
+    "\n",
+    "    #print ('{} - Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'\n",
+    "    #               .format(str(datetime.now()), epoch+1, num_epochs, i+1, total_step, accumulate_train_loss/len(train_loader)))\n",
+    "\n",
+    "    train_loss,train_accuracy = accumulate_train_loss/len(train_loader),num_accurate_train_prediction/num_total_train_sample\n",
+    "    train_loss_history += [train_loss]\n",
+    "    train_accuracy_history += [train_accuracy]\n",
+    "\n",
+    "    # Validation\n",
+    "    with torch.no_grad():\n",
+    "        correct = 0\n",
+    "        total = 0\n",
+    "        accumulate_test_loss = 0\n",
+    "        for images, labels in valid_loader:\n",
+    "            images = images.to(device)\n",
+    "            labels = labels.to(device)\n",
+    "            outputs = resnet(images)\n",
+    "            loss = criterion(outputs, labels)\n",
+    "            accumulate_test_loss += loss.item()\n",
+    "            _, predicted = torch.max(outputs.data, 1)\n",
+    "            total += labels.size(0)\n",
+    "            correct += (predicted == labels).sum().item()\n",
+    "            del images, labels, outputs\n",
+    "        test_accuracy,test_loss = correct / total,accumulate_test_loss/len(valid_loader)\n",
+    "        #print('Accuracy of the network on the {} validation images: {} %'.format(5000, 100 * correct / total))\n",
+    "        test_accuracy_history += [test_accuracy]\n",
+    "        test_loss_history += [test_loss]\n",
+    "    print(f\"{str(datetime.now())} - Epoch [{epoch+1}/{num_epochs}], Train Loss: {train_loss:.4f}, Train Accuracy: {train_accuracy*100:.2f}%, Test Loss: {test_loss:.4f}, Test Accuracy: {test_accuracy*100:.2f}%\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "rmsprop's resnet can reach 98% accuracy on train data, but only 69% accuracy on test data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 122,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:44:33.307945Z",
+     "start_time": "2025-06-22T21:44:33.148107Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "plt.figure(figsize=(20,5))\n",
+    "plt.subplot(1,2,1)\n",
+    "plt.plot(np.log(train_loss_history),label=\"Train Loss\")\n",
+    "plt.plot(np.log(test_loss_history),label=\"Test Loss\")\n",
+    "plt.title(\"train loss history\")\n",
+    "plt.legend()\n",
+    "plt.subplot(1,2,2)\n",
+    "plt.plot(train_accuracy_history,label=\"Train Accuracy\")\n",
+    "plt.plot(test_accuracy_history,label=\"Test Accuracy\")\n",
+    "plt.title(\"train accuracy history\")\n",
+    "plt.legend()\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 123,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:44:44.543491Z",
+     "start_time": "2025-06-22T21:44:33.323316Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "torch.save(resnet.state_dict(),\"rmsprop_resnet.pth\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "3qcjhswc5_Ay"
+   },
+   "source": [
+    "### Backup of Training Log\n",
+    "\n",
+    "#### AlexNet\n",
+    "```\n",
+    "Epoch [1/20], Step [704/704], Loss: 1.6327\n",
+    "Accuracy of the network on the 5000 validation images: 42.66 %\n",
+    "Epoch [2/20], Step [704/704], Loss: 1.1153\n",
+    "Accuracy of the network on the 5000 validation images: 52.42 %\n",
+    "Epoch [3/20], Step [704/704], Loss: 0.8354\n",
+    "Accuracy of the network on the 5000 validation images: 61.48 %\n",
+    "Epoch [4/20], Step [704/704], Loss: 0.5581\n",
+    "Accuracy of the network on the 5000 validation images: 62.56 %\n",
+    "Epoch [5/20], Step [704/704], Loss: 1.6696\n",
+    "Accuracy of the network on the 5000 validation images: 68.84 %\n",
+    "Epoch [6/20], Step [704/704], Loss: 0.6406\n",
+    "Accuracy of the network on the 5000 validation images: 70.98 %\n",
+    "Epoch [7/20], Step [704/704], Loss: 0.8516\n",
+    "Accuracy of the network on the 5000 validation images: 71.82 %\n",
+    "Epoch [8/20], Step [704/704], Loss: 0.3658\n",
+    "Accuracy of the network on the 5000 validation images: 69.96 %\n",
+    "Epoch [9/20], Step [704/704], Loss: 0.4399\n",
+    "Accuracy of the network on the 5000 validation images: 74.84 %\n",
+    "Epoch [10/20], Step [704/704], Loss: 0.1435\n",
+    "Accuracy of the network on the 5000 validation images: 76.46 %\n",
+    "Epoch [11/20], Step [704/704], Loss: 0.5190\n",
+    "Accuracy of the network on the 5000 validation images: 74.78 %\n",
+    "Epoch [12/20], Step [704/704], Loss: 0.5558\n",
+    "Accuracy of the network on the 5000 validation images: 76.96 %\n",
+    "Epoch [13/20], Step [704/704], Loss: 0.4064\n",
+    "Accuracy of the network on the 5000 validation images: 76.66 %\n",
+    "Epoch [14/20], Step [704/704], Loss: 0.4210\n",
+    "Accuracy of the network on the 5000 validation images: 76.6 %\n",
+    "Epoch [15/20], Step [704/704], Loss: 0.3571\n",
+    "Accuracy of the network on the 5000 validation images: 75.68 %\n",
+    "Epoch [16/20], Step [704/704], Loss: 0.8136\n",
+    "Accuracy of the network on the 5000 validation images: 76.82 %\n",
+    "Epoch [17/20], Step [704/704], Loss: 0.3949\n",
+    "Accuracy of the network on the 5000 validation images: 78.76 %\n",
+    "Epoch [18/20], Step [704/704], Loss: 0.3319\n",
+    "Accuracy of the network on the 5000 validation images: 78.0 %\n",
+    "Epoch [19/20], Step [704/704], Loss: 0.5933\n",
+    "Accuracy of the network on the 5000 validation images: 79.92 %\n",
+    "Epoch [20/20], Step [704/704], Loss: 0.3297\n",
+    "Accuracy of the network on the 5000 validation images: 75.88 %\n",
+    "```\n",
+    "\n",
+    "VGG11\n",
+    "we apply early stopping to avoid overfitting\n",
+    "```\n",
+    "\n",
+    "100%|██████████| 704/704 [07:16<00:00,  1.61it/s]\n",
+    "2025-06-21 16:45:56.248537 - Epoch [1/20], Train Loss: 1.8241, Train Accuracy: 31.59%, Test Loss: 1.4884, Test Accuracy: 47.34%\n",
+    "100%|██████████| 704/704 [07:12<00:00,  1.63it/s]\n",
+    "2025-06-21 16:53:30.465123 - Epoch [2/20], Train Loss: 1.1994, Train Accuracy: 56.53%, Test Loss: 1.1081, Test Accuracy: 60.92%\n",
+    "100%|██████████| 704/704 [07:13<00:00,  1.63it/s]\n",
+    "2025-06-21 17:01:05.513070 - Epoch [3/20], Train Loss: 0.9004, Train Accuracy: 68.23%, Test Loss: 0.9152, Test Accuracy: 67.56%\n",
+    "100%|██████████| 704/704 [07:13<00:00,  1.62it/s]\n",
+    "2025-06-21 17:08:40.880336 - Epoch [4/20], Train Loss: 0.6816, Train Accuracy: 76.00%, Test Loss: 0.8753, Test Accuracy: 70.18%\n",
+    "100%|██████████| 704/704 [07:12<00:00,  1.63it/s]\n",
+    "2025-06-21 17:16:14.916988 - Epoch [5/20], Train Loss: 0.4868, Train Accuracy: 82.80%, Test Loss: 0.9323, Test Accuracy: 70.28%\n",
+    "100%|██████████| 704/704 [07:13<00:00,  1.63it/s]\n",
+    "2025-06-21 17:23:49.801789 - Epoch [6/20], Train Loss: 0.3109, Train Accuracy: 89.14%, Test Loss: 1.1114, Test Accuracy: 71.10%\n",
+    "100%|██████████| 704/704 [07:13<00:00,  1.62it/s]\n",
+    "2025-06-21 17:31:25.042103 - Epoch [7/20], Train Loss: 0.2071, Train Accuracy: 92.81%, Test Loss: 1.2503, Test Accuracy: 71.28%\n",
+    "100%|██████████| 704/704 [07:13<00:00,  1.62it/s]\n",
+    "2025-06-21 17:39:01.094586 - Epoch [8/20], Train Loss: 0.1387, Train Accuracy: 95.29%, Test Loss: 1.3280, Test Accuracy: 70.26%\n",
+    "100%|██████████| 704/704 [07:16<00:00,  1.61it/s]\n",
+    "2025-06-21 17:46:39.042234 - Epoch [9/20], Train Loss: 0.1117, Train Accuracy: 96.21%, Test Loss: 1.5484, Test Accuracy: 71.40%\n",
+    "100%|██████████| 704/704 [07:16<00:00,  1.61it/s]\n",
+    "2025-06-21 17:54:17.174933 - Epoch [10/20], Train Loss: 0.1071, Train Accuracy: 96.52%, Test Loss: 1.5823, Test Accuracy: 69.84%\n",
+    "  1%|▏         | 9/704 [00:06<07:59,  1.45it/s]\n",
+    "\n",
+    "```\n",
+    "\n",
+    "ResNet\n",
+    "```\n",
+    "100%|██████████| 704/704 [01:11<00:00,  9.84it/s]\n",
+    "2025-06-22 03:37:47.552381 - Epoch [1/20], Train Loss: 1.4436, Train Accuracy: 47.92%, Test Loss: 1.2438, Test Accuracy: 55.76%\n",
+    "100%|██████████| 704/704 [01:10<00:00, 10.04it/s]\n",
+    "2025-06-22 03:39:01.986240 - Epoch [2/20], Train Loss: 1.1279, Train Accuracy: 59.60%, Test Loss: 1.0987, Test Accuracy: 61.04%\n",
+    "100%|██████████| 704/704 [01:11<00:00,  9.91it/s]\n",
+    "2025-06-22 03:40:17.410401 - Epoch [3/20], Train Loss: 0.9505, Train Accuracy: 66.48%, Test Loss: 0.9712, Test Accuracy: 65.80%\n",
+    "100%|██████████| 704/704 [01:11<00:00,  9.81it/s]\n",
+    "2025-06-22 03:41:34.491176 - Epoch [4/20], Train Loss: 0.8170, Train Accuracy: 71.10%, Test Loss: 0.9468, Test Accuracy: 67.10%\n",
+    "100%|██████████| 704/704 [01:10<00:00,  9.94it/s]\n",
+    "2025-06-22 03:42:50.428944 - Epoch [5/20], Train Loss: 0.6911, Train Accuracy: 75.64%, Test Loss: 0.8987, Test Accuracy: 69.74%\n",
+    "100%|██████████| 704/704 [01:10<00:00, 10.00it/s]\n",
+    "2025-06-22 03:44:05.027102 - Epoch [6/20], Train Loss: 0.5825, Train Accuracy: 79.30%, Test Loss: 0.8809, Test Accuracy: 71.00%\n",
+    "100%|██████████| 704/704 [01:12<00:00,  9.65it/s]\n",
+    "2025-06-22 03:45:21.973571 - Epoch [7/20], Train Loss: 0.4729, Train Accuracy: 83.17%, Test Loss: 0.9303, Test Accuracy: 70.92%\n",
+    "100%|██████████| 704/704 [01:08<00:00, 10.22it/s]\n",
+    "2025-06-22 03:46:35.133883 - Epoch [8/20], Train Loss: 0.3653, Train Accuracy: 87.13%, Test Loss: 1.0199, Test Accuracy: 70.80%\n",
+    "100%|██████████| 704/704 [01:08<00:00, 10.24it/s]\n",
+    "2025-06-22 03:47:47.784789 - Epoch [9/20], Train Loss: 0.2976, Train Accuracy: 89.47%, Test Loss: 1.0985, Test Accuracy: 70.20%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.19it/s]\n",
+    "2025-06-22 03:49:00.769455 - Epoch [10/20], Train Loss: 0.2226, Train Accuracy: 92.18%, Test Loss: 1.1940, Test Accuracy: 70.12%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.15it/s]\n",
+    "2025-06-22 03:50:14.153546 - Epoch [11/20], Train Loss: 0.1748, Train Accuracy: 93.76%, Test Loss: 1.2457, Test Accuracy: 70.96%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.20it/s]\n",
+    "2025-06-22 03:51:27.119316 - Epoch [12/20], Train Loss: 0.1418, Train Accuracy: 95.06%, Test Loss: 1.3119, Test Accuracy: 70.10%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.06it/s]\n",
+    "2025-06-22 03:52:41.577209 - Epoch [13/20], Train Loss: 0.1214, Train Accuracy: 95.76%, Test Loss: 1.5131, Test Accuracy: 69.92%\n",
+    "  4%|▍         | 27/704 [00:02<01:12,  9.34it/s]\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:44:44.569024Z",
+     "start_time": "2025-06-22T21:44:44.566015Z"
+    }
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "7PDLeXcXpLct"
+   },
+   "source": [
+    "#### VGGNet"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:46:14.213680Z",
+     "start_time": "2025-06-22T21:44:44.582898Z"
+    },
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "executionInfo": {
+     "elapsed": 107675,
+     "status": "ok",
+     "timestamp": 1750529265618,
+     "user": {
+      "displayName": "Yusheng Cai",
+      "userId": "12125344090096007129"
+     },
+     "user_tz": -480
+    },
+    "id": "Pp6MLe7PoYXm",
+    "outputId": "b8f8dbde-f821-4bc4-d618-7a3ae17496ce"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Adam VGGNet\n",
+      "[Test Time Augmentation] Accuracy of the network on the 10000 test images: 72.62 %\n",
+      "[No Test Time Augmentation] Accuracy of the network on the 10000 test images: 68.12 %\n",
+      "RMSProp VGGNet\n",
+      "[Test Time Augmentation] Accuracy of the network on the 10000 test images: 72.61 %\n",
+      "[No Test Time Augmentation] Accuracy of the network on the 10000 test images: 69.27 %\n"
+     ]
+    }
+   ],
+   "source": [
+    "test_time_augmentor = transforms.RandomHorizontalFlip(1.0)\n",
+    "vggnet = VGG11(num_classes)\n",
+    "vggnet.load_state_dict(torch.load(\"adam_vggnet.pth\"))\n",
+    "vggnet.eval().to(device)\n",
+    "print(\"Adam VGGNet\")\n",
+    "with torch.no_grad():\n",
+    "    correct = 0\n",
+    "    total = 0\n",
+    "    for images, labels in test_loader:\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "        outputs = (vggnet(images)+vggnet(test_time_augmentor(images)))/2\n",
+    "        _, predicted = torch.max(outputs.data, 1)\n",
+    "        total += labels.size(0)\n",
+    "        correct += (predicted == labels).sum().item()\n",
+    "        del images, labels, outputs\n",
+    "\n",
+    "    print('[Test Time Augmentation] Accuracy of the network on the {} test images: {} %'.format(total, 100 * correct / total))\n",
+    "with torch.no_grad():\n",
+    "    correct = 0\n",
+    "    total = 0\n",
+    "    for images, labels in test_loader:\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "        outputs = vggnet(images)\n",
+    "        _, predicted = torch.max(outputs.data, 1)\n",
+    "        total += labels.size(0)\n",
+    "        correct += (predicted == labels).sum().item()\n",
+    "        del images, labels, outputs\n",
+    "\n",
+    "    print('[No Test Time Augmentation] Accuracy of the network on the {} test images: {} %'.format(total, 100 * correct / total))\n",
+    "\n",
+    "test_time_augmentor = transforms.RandomHorizontalFlip(1.0)\n",
+    "vggnet = VGG11(10)\n",
+    "vggnet.load_state_dict(torch.load(\"rmsprop_vggnet.pth\"))\n",
+    "vggnet.eval().to(device)\n",
+    "print(\"RMSProp VGGNet\")\n",
+    "with torch.no_grad():\n",
+    "    correct = 0\n",
+    "    total = 0\n",
+    "    for images, labels in test_loader:\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "        outputs = (vggnet(images)+vggnet(test_time_augmentor(images)))/2\n",
+    "        _, predicted = torch.max(outputs.data, 1)\n",
+    "        total += labels.size(0)\n",
+    "        correct += (predicted == labels).sum().item()\n",
+    "        del images, labels, outputs\n",
+    "\n",
+    "    print('[Test Time Augmentation] Accuracy of the network on the {} test images: {} %'.format(total, 100 * correct / total))\n",
+    "with torch.no_grad():\n",
+    "    correct = 0\n",
+    "    total = 0\n",
+    "    for images, labels in test_loader:\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "        outputs = vggnet(images)\n",
+    "        _, predicted = torch.max(outputs.data, 1)\n",
+    "        total += labels.size(0)\n",
+    "        correct += (predicted == labels).sum().item()\n",
+    "        del images, labels, outputs\n",
+    "\n",
+    "    print('[No Test Time Augmentation] Accuracy of the network on the {} test images: {} %'.format(total, 100 * correct / total))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "cG1h1T2speNq"
+   },
+   "source": [
+    "#### ResNet"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-22T21:46:32.447350Z",
+     "start_time": "2025-06-22T21:46:14.287205Z"
+    },
+    "id": "i0mPxCxDpdT8"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Adam ResNet\n",
+      "[Test Time Augmentation] Accuracy of the network on the 10000 test images: 72.99 %\n",
+      "[No Test Time Augmentation] Accuracy of the network on the 10000 test images: 69.95 %\n",
+      "RMSProp ResNet\n",
+      "[Test Time Augmentation] Accuracy of the network on the 10000 test images: 70.09 %\n",
+      "[No Test Time Augmentation] Accuracy of the network on the 10000 test images: 67.07 %\n"
+     ]
+    }
+   ],
+   "source": [
+    "test_time_augmentor = transforms.RandomHorizontalFlip(1.0)\n",
+    "print(\"Adam ResNet\")\n",
+    "resnet = ResNet(num_classes)\n",
+    "resnet.load_state_dict(torch.load(\"adam_resnet.pth\"))\n",
+    "resnet.to(device)\n",
+    "with torch.no_grad():\n",
+    "    correct = 0\n",
+    "    total = 0\n",
+    "    for images, labels in test_loader:\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "        outputs = (resnet(images)+resnet(test_time_augmentor(images)))/2\n",
+    "        _, predicted = torch.max(outputs.data, 1)\n",
+    "        total += labels.size(0)\n",
+    "        correct += (predicted == labels).sum().item()\n",
+    "        del images, labels, outputs\n",
+    "\n",
+    "    print('[Test Time Augmentation] Accuracy of the network on the {} test images: {} %'.format(total, 100 * correct / total))\n",
+    "with torch.no_grad():\n",
+    "    correct = 0\n",
+    "    total = 0\n",
+    "    for images, labels in test_loader:\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "        outputs = resnet(images)\n",
+    "        _, predicted = torch.max(outputs.data, 1)\n",
+    "        total += labels.size(0)\n",
+    "        correct += (predicted == labels).sum().item()\n",
+    "        del images, labels, outputs\n",
+    "\n",
+    "    print('[No Test Time Augmentation] Accuracy of the network on the {} test images: {} %'.format(total, 100 * correct / total))\n",
+    "test_time_augmentor = transforms.RandomHorizontalFlip(1.0)\n",
+    "print(\"RMSProp ResNet\")\n",
+    "resnet = ResNet(num_classes)\n",
+    "resnet.load_state_dict(torch.load(\"rmsprop_resnet.pth\"))\n",
+    "resnet.to(device)\n",
+    "with torch.no_grad():\n",
+    "    correct = 0\n",
+    "    total = 0\n",
+    "    for images, labels in test_loader:\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "        outputs = (resnet(images)+resnet(test_time_augmentor(images)))/2\n",
+    "        _, predicted = torch.max(outputs.data, 1)\n",
+    "        total += labels.size(0)\n",
+    "        correct += (predicted == labels).sum().item()\n",
+    "        del images, labels, outputs\n",
+    "\n",
+    "    print('[Test Time Augmentation] Accuracy of the network on the {} test images: {} %'.format(total, 100 * correct / total))\n",
+    "with torch.no_grad():\n",
+    "    correct = 0\n",
+    "    total = 0\n",
+    "    for images, labels in test_loader:\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "        outputs = resnet(images)\n",
+    "        _, predicted = torch.max(outputs.data, 1)\n",
+    "        total += labels.size(0)\n",
+    "        correct += (predicted == labels).sum().item()\n",
+    "        del images, labels, outputs\n",
+    "\n",
+    "    print('[No Test Time Augmentation] Accuracy of the network on the {} test images: {} %'.format(total, 100 * correct / total))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "P7j0NIu2qCNr"
+   },
+   "source": [
+    "### Backup of Testing Log\n",
+    "\n",
+    "#### VGGNet\n",
+    "```\n",
+    "Adam VGGNet\n",
+    "[Test Time Augmentation] Accuracy of the network on the 10000 test images: 72.62 %\n",
+    "[No Test Time Augmentation] Accuracy of the network on the 10000 test images: 68.12 %\n",
+    "RMSProp VGGNet\n",
+    "[Test Time Augmentation] Accuracy of the network on the 10000 test images: 72.61 %\n",
+    "[No Test Time Augmentation] Accuracy of the network on the 10000 test images: 69.27 %\n",
+    "\n",
+    "```\n",
+    "#### ResNet\n",
+    "```\n",
+    "Adam ResNet\n",
+    "[Test Time Augmentation] Accuracy of the network on the 10000 test images: 72.99 %\n",
+    "[No Test Time Augmentation] Accuracy of the network on the 10000 test images: 69.95 %\n",
+    "RMSProp ResNet\n",
+    "[Test Time Augmentation] Accuracy of the network on the 10000 test images: 70.09 %\n",
+    "[No Test Time Augmentation] Accuracy of the network on the 10000 test images: 67.07 %\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Adam\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:12<00:00,  9.66it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 01:52:31.147162 - Epoch [1/40], Train Loss: 1.4280, Train Accuracy: 48.82%, Test Loss: 1.1677, Test Accuracy: 57.44%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:10<00:00, 10.01it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 01:53:45.688162 - Epoch [2/40], Train Loss: 1.0199, Train Accuracy: 63.50%, Test Loss: 0.9780, Test Accuracy: 64.42%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.10it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 01:54:59.332162 - Epoch [3/40], Train Loss: 0.7838, Train Accuracy: 72.22%, Test Loss: 0.8784, Test Accuracy: 69.30%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.12it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 01:56:12.862162 - Epoch [4/40], Train Loss: 0.5770, Train Accuracy: 79.86%, Test Loss: 0.8081, Test Accuracy: 71.80%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.08it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 01:57:26.671162 - Epoch [5/40], Train Loss: 0.3979, Train Accuracy: 86.51%, Test Loss: 0.8349, Test Accuracy: 72.06%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.12it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 01:58:40.221161 - Epoch [6/40], Train Loss: 0.2373, Train Accuracy: 92.76%, Test Loss: 0.8618, Test Accuracy: 73.28%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.08it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 01:59:54.091164 - Epoch [7/40], Train Loss: 0.1280, Train Accuracy: 96.59%, Test Loss: 0.9082, Test Accuracy: 73.12%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.08it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:01:07.899161 - Epoch [8/40], Train Loss: 0.0686, Train Accuracy: 98.55%, Test Loss: 0.9855, Test Accuracy: 72.46%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.12it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:02:21.654210 - Epoch [9/40], Train Loss: 0.0366, Train Accuracy: 99.42%, Test Loss: 1.0464, Test Accuracy: 72.98%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.13it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:03:35.108210 - Epoch [10/40], Train Loss: 0.0455, Train Accuracy: 98.96%, Test Loss: 1.2019, Test Accuracy: 71.04%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:10<00:00, 10.04it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:04:49.729211 - Epoch [11/40], Train Loss: 0.0434, Train Accuracy: 98.91%, Test Loss: 1.1916, Test Accuracy: 71.84%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.11it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:06:03.390210 - Epoch [12/40], Train Loss: 0.0319, Train Accuracy: 99.21%, Test Loss: 1.2314, Test Accuracy: 72.60%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.12it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:07:16.987210 - Epoch [13/40], Train Loss: 0.0303, Train Accuracy: 99.21%, Test Loss: 1.2236, Test Accuracy: 72.66%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.13it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:08:30.528210 - Epoch [14/40], Train Loss: 0.0323, Train Accuracy: 99.04%, Test Loss: 1.3886, Test Accuracy: 71.32%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.11it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:09:44.136211 - Epoch [15/40], Train Loss: 0.0279, Train Accuracy: 99.24%, Test Loss: 1.3493, Test Accuracy: 71.78%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.11it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:10:57.804210 - Epoch [16/40], Train Loss: 0.0324, Train Accuracy: 99.04%, Test Loss: 1.3193, Test Accuracy: 73.06%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.14it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:12:11.183211 - Epoch [17/40], Train Loss: 0.0168, Train Accuracy: 99.56%, Test Loss: 1.4429, Test Accuracy: 71.86%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.10it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:13:25.019211 - Epoch [18/40], Train Loss: 0.0260, Train Accuracy: 99.17%, Test Loss: 1.3549, Test Accuracy: 72.40%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:10<00:00, 10.00it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:14:39.530212 - Epoch [19/40], Train Loss: 0.0256, Train Accuracy: 99.21%, Test Loss: 1.5470, Test Accuracy: 71.60%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.12it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:15:53.112210 - Epoch [20/40], Train Loss: 0.0214, Train Accuracy: 99.38%, Test Loss: 1.4861, Test Accuracy: 72.94%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.12it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:17:06.736240 - Epoch [21/40], Train Loss: 0.0171, Train Accuracy: 99.47%, Test Loss: 1.4023, Test Accuracy: 73.42%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.11it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:18:20.621236 - Epoch [22/40], Train Loss: 0.0277, Train Accuracy: 99.07%, Test Loss: 1.4851, Test Accuracy: 72.78%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.11it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:19:34.485237 - Epoch [23/40], Train Loss: 0.0059, Train Accuracy: 99.88%, Test Loss: 1.5275, Test Accuracy: 73.98%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.14it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:20:47.898237 - Epoch [24/40], Train Loss: 0.0009, Train Accuracy: 100.00%, Test Loss: 1.5485, Test Accuracy: 74.66%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.11it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:22:01.514238 - Epoch [25/40], Train Loss: 0.0003, Train Accuracy: 100.00%, Test Loss: 1.5256, Test Accuracy: 74.98%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.10it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:23:15.165236 - Epoch [26/40], Train Loss: 0.0002, Train Accuracy: 100.00%, Test Loss: 1.5527, Test Accuracy: 74.70%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:09<00:00, 10.07it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:24:29.270238 - Epoch [27/40], Train Loss: 0.0001, Train Accuracy: 100.00%, Test Loss: 1.6148, Test Accuracy: 75.40%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:08<00:00, 10.27it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:25:41.450765 - Epoch [28/40], Train Loss: 0.0001, Train Accuracy: 100.00%, Test Loss: 1.6371, Test Accuracy: 74.96%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:06<00:00, 10.57it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:26:52.069808 - Epoch [29/40], Train Loss: 0.0000, Train Accuracy: 100.00%, Test Loss: 1.6650, Test Accuracy: 75.08%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:06<00:00, 10.57it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:28:02.463729 - Epoch [30/40], Train Loss: 0.0000, Train Accuracy: 100.00%, Test Loss: 1.6668, Test Accuracy: 75.08%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:06<00:00, 10.52it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:29:13.069314 - Epoch [31/40], Train Loss: 0.0001, Train Accuracy: 100.00%, Test Loss: 1.8749, Test Accuracy: 74.30%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:06<00:00, 10.54it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:30:23.805413 - Epoch [32/40], Train Loss: 0.0913, Train Accuracy: 97.14%, Test Loss: 1.5489, Test Accuracy: 72.60%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:06<00:00, 10.56it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:31:34.082492 - Epoch [33/40], Train Loss: 0.0064, Train Accuracy: 99.84%, Test Loss: 1.5181, Test Accuracy: 73.72%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:06<00:00, 10.54it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:32:44.537330 - Epoch [34/40], Train Loss: 0.0123, Train Accuracy: 99.60%, Test Loss: 1.5318, Test Accuracy: 71.36%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:06<00:00, 10.56it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:33:54.904164 - Epoch [35/40], Train Loss: 0.0224, Train Accuracy: 99.23%, Test Loss: 1.5537, Test Accuracy: 72.64%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:07<00:00, 10.38it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:35:06.621623 - Epoch [36/40], Train Loss: 0.0153, Train Accuracy: 99.53%, Test Loss: 1.6972, Test Accuracy: 71.24%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:06<00:00, 10.62it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:36:16.566354 - Epoch [37/40], Train Loss: 0.0156, Train Accuracy: 99.50%, Test Loss: 1.6090, Test Accuracy: 72.98%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:06<00:00, 10.57it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:37:26.837373 - Epoch [38/40], Train Loss: 0.0024, Train Accuracy: 99.96%, Test Loss: 1.6209, Test Accuracy: 74.48%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:06<00:00, 10.63it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:38:36.784972 - Epoch [39/40], Train Loss: 0.0274, Train Accuracy: 99.07%, Test Loss: 1.5927, Test Accuracy: 72.94%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [01:06<00:00, 10.53it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:39:47.594456 - Epoch [40/40], Train Loss: 0.0121, Train Accuracy: 99.59%, Test Loss: 1.6070, Test Accuracy: 73.10%\n",
+      "SGD\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.64it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:41:34.255639 - Epoch [1/40], Train Loss: 2.1868, Train Accuracy: 22.57%, Test Loss: 2.0919, Test Accuracy: 28.06%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.67it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:42:33.517609 - Epoch [2/40], Train Loss: 2.0392, Train Accuracy: 30.85%, Test Loss: 1.9881, Test Accuracy: 33.10%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.70it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:43:32.564905 - Epoch [3/40], Train Loss: 1.9496, Train Accuracy: 33.95%, Test Loss: 1.9118, Test Accuracy: 35.64%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.77it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:44:31.574836 - Epoch [4/40], Train Loss: 1.8820, Train Accuracy: 36.20%, Test Loss: 1.8502, Test Accuracy: 37.36%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.74it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:45:30.405675 - Epoch [5/40], Train Loss: 1.8275, Train Accuracy: 37.63%, Test Loss: 1.8014, Test Accuracy: 38.42%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.77it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:46:29.138808 - Epoch [6/40], Train Loss: 1.7839, Train Accuracy: 39.23%, Test Loss: 1.7714, Test Accuracy: 39.08%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.72it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:47:28.078673 - Epoch [7/40], Train Loss: 1.7460, Train Accuracy: 40.10%, Test Loss: 1.7319, Test Accuracy: 40.70%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.75it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:48:26.964125 - Epoch [8/40], Train Loss: 1.7162, Train Accuracy: 41.15%, Test Loss: 1.7022, Test Accuracy: 41.22%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.74it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:49:26.022220 - Epoch [9/40], Train Loss: 1.6879, Train Accuracy: 41.90%, Test Loss: 1.6826, Test Accuracy: 41.92%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.68it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:50:25.340291 - Epoch [10/40], Train Loss: 1.6651, Train Accuracy: 42.68%, Test Loss: 1.6550, Test Accuracy: 42.24%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.75it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:51:24.403384 - Epoch [11/40], Train Loss: 1.6434, Train Accuracy: 43.35%, Test Loss: 1.6437, Test Accuracy: 42.78%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.78it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:52:23.302279 - Epoch [12/40], Train Loss: 1.6244, Train Accuracy: 43.92%, Test Loss: 1.6255, Test Accuracy: 43.52%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.73it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:53:22.230288 - Epoch [13/40], Train Loss: 1.6080, Train Accuracy: 44.47%, Test Loss: 1.6026, Test Accuracy: 44.06%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.77it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:54:20.932420 - Epoch [14/40], Train Loss: 1.5926, Train Accuracy: 44.89%, Test Loss: 1.5978, Test Accuracy: 44.16%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.67it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:55:20.119694 - Epoch [15/40], Train Loss: 1.5781, Train Accuracy: 45.41%, Test Loss: 1.5816, Test Accuracy: 44.68%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.73it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:56:19.019310 - Epoch [16/40], Train Loss: 1.5643, Train Accuracy: 46.02%, Test Loss: 1.5688, Test Accuracy: 45.56%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.72it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:57:17.970590 - Epoch [17/40], Train Loss: 1.5537, Train Accuracy: 46.19%, Test Loss: 1.5560, Test Accuracy: 46.02%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.73it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:58:16.931478 - Epoch [18/40], Train Loss: 1.5384, Train Accuracy: 46.72%, Test Loss: 1.5518, Test Accuracy: 46.12%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.73it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 02:59:15.840693 - Epoch [19/40], Train Loss: 1.5282, Train Accuracy: 47.18%, Test Loss: 1.5391, Test Accuracy: 46.32%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.61it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 03:00:15.347053 - Epoch [20/40], Train Loss: 1.5178, Train Accuracy: 47.64%, Test Loss: 1.5279, Test Accuracy: 46.68%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.70it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 03:01:14.393323 - Epoch [21/40], Train Loss: 1.5066, Train Accuracy: 47.93%, Test Loss: 1.5242, Test Accuracy: 47.02%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.61it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 03:02:13.864149 - Epoch [22/40], Train Loss: 1.4976, Train Accuracy: 48.27%, Test Loss: 1.5106, Test Accuracy: 47.24%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.64it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 03:03:13.184535 - Epoch [23/40], Train Loss: 1.4871, Train Accuracy: 48.64%, Test Loss: 1.5088, Test Accuracy: 48.32%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.70it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 03:04:12.278857 - Epoch [24/40], Train Loss: 1.4775, Train Accuracy: 48.86%, Test Loss: 1.4948, Test Accuracy: 47.80%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:56<00:00, 12.50it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 03:05:12.436950 - Epoch [25/40], Train Loss: 1.4678, Train Accuracy: 49.33%, Test Loss: 1.4906, Test Accuracy: 48.98%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.69it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 03:06:11.527410 - Epoch [26/40], Train Loss: 1.4575, Train Accuracy: 49.76%, Test Loss: 1.4788, Test Accuracy: 48.42%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.71it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 03:07:10.483268 - Epoch [27/40], Train Loss: 1.4478, Train Accuracy: 50.06%, Test Loss: 1.4817, Test Accuracy: 48.80%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.72it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 03:08:09.484575 - Epoch [28/40], Train Loss: 1.4394, Train Accuracy: 50.25%, Test Loss: 1.4626, Test Accuracy: 49.34%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.66it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 03:09:08.707820 - Epoch [29/40], Train Loss: 1.4313, Train Accuracy: 50.61%, Test Loss: 1.4550, Test Accuracy: 49.04%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.68it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 03:10:07.851819 - Epoch [30/40], Train Loss: 1.4207, Train Accuracy: 50.92%, Test Loss: 1.4498, Test Accuracy: 49.70%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.70it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 03:11:06.924673 - Epoch [31/40], Train Loss: 1.4142, Train Accuracy: 51.27%, Test Loss: 1.4390, Test Accuracy: 49.76%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.72it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 03:12:05.879449 - Epoch [32/40], Train Loss: 1.4062, Train Accuracy: 51.51%, Test Loss: 1.4384, Test Accuracy: 50.32%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.74it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 03:13:04.839480 - Epoch [33/40], Train Loss: 1.3979, Train Accuracy: 51.65%, Test Loss: 1.4342, Test Accuracy: 50.78%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:56<00:00, 12.56it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 03:14:04.513014 - Epoch [34/40], Train Loss: 1.3903, Train Accuracy: 52.03%, Test Loss: 1.4238, Test Accuracy: 50.36%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.66it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 03:15:03.801946 - Epoch [35/40], Train Loss: 1.3832, Train Accuracy: 52.33%, Test Loss: 1.4147, Test Accuracy: 50.32%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.74it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 03:16:02.818824 - Epoch [36/40], Train Loss: 1.3747, Train Accuracy: 52.53%, Test Loss: 1.4178, Test Accuracy: 51.16%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.73it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 03:17:01.810527 - Epoch [37/40], Train Loss: 1.3698, Train Accuracy: 52.81%, Test Loss: 1.4074, Test Accuracy: 51.12%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.75it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 03:18:00.701375 - Epoch [38/40], Train Loss: 1.3602, Train Accuracy: 53.09%, Test Loss: 1.3984, Test Accuracy: 50.80%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.76it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 03:18:59.736929 - Epoch [39/40], Train Loss: 1.3536, Train Accuracy: 53.24%, Test Loss: 1.3983, Test Accuracy: 50.98%\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 704/704 [00:55<00:00, 12.65it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2025-06-24 03:19:59.237586 - Epoch [40/40], Train Loss: 1.3482, Train Accuracy: 53.58%, Test Loss: 1.3909, Test Accuracy: 51.36%\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Adam\")\n",
+    "num_epochs = 40\n",
+    "learning_rate = 0.0001\n",
+    "adam_train_loss_history = []\n",
+    "adam_test_loss_history = []\n",
+    "adam_train_accuracy_history = []\n",
+    "adam_test_accuracy_history = []\n",
+    "\n",
+    "total_step = len(train_loader)\n",
+    "resnet = ResNet(num_classes).to(device)\n",
+    "resnet_adam_optimizer = torch.optim.Adam(resnet.parameters(), lr=learning_rate)\n",
+    "\n",
+    "for epoch in range(num_epochs):\n",
+    "    # Training\n",
+    "    accumulate_train_loss,num_total_train_sample,num_accurate_train_prediction = 0.0 ,0,0\n",
+    "    for i, (images, labels) in enumerate(tqdm(train_loader)):\n",
+    "        # Move tensors to the configured device\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "\n",
+    "        # Forward pass\n",
+    "        outputs = resnet(images)\n",
+    "        loss = criterion(outputs, labels)\n",
+    "\n",
+    "        # Backward and optimize\n",
+    "        resnet_adam_optimizer.zero_grad()\n",
+    "        loss.backward()\n",
+    "        resnet_adam_optimizer.step()\n",
+    "\n",
+    "        accumulate_train_loss += loss.item()\n",
+    "        num_total_train_sample += labels.size()[0]\n",
+    "        num_accurate_train_prediction += (outputs.argmax(1)==labels).sum().item()\n",
+    "\n",
+    "\n",
+    "\n",
+    "    #print ('{} - Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'\n",
+    "    #               .format(str(datetime.now()), epoch+1, num_epochs, i+1, total_step, accumulate_train_loss/len(train_loader)))\n",
+    "\n",
+    "    train_loss,train_accuracy = accumulate_train_loss/len(train_loader),num_accurate_train_prediction/num_total_train_sample\n",
+    "    adam_train_loss_history += [train_loss]\n",
+    "    adam_train_accuracy_history += [train_accuracy]\n",
+    "\n",
+    "    # Validation\n",
+    "    with torch.no_grad():\n",
+    "        correct = 0\n",
+    "        total = 0\n",
+    "        accumulate_test_loss = 0\n",
+    "        for images, labels in valid_loader:\n",
+    "            images = images.to(device)\n",
+    "            labels = labels.to(device)\n",
+    "            outputs = resnet(images)\n",
+    "            loss = criterion(outputs, labels)\n",
+    "            accumulate_test_loss += loss.item()\n",
+    "            _, predicted = torch.max(outputs.data, 1)\n",
+    "            total += labels.size(0)\n",
+    "            correct += (predicted == labels).sum().item()\n",
+    "            del images, labels, outputs\n",
+    "        test_accuracy,test_loss = correct / total,accumulate_test_loss/len(valid_loader)\n",
+    "        #print('Accuracy of the network on the {} validation images: {} %'.format(5000, 100 * correct / total))\n",
+    "        adam_test_accuracy_history += [test_accuracy]\n",
+    "        adam_test_loss_history += [test_loss]\n",
+    "    print(f\"{str(datetime.now())} - Epoch [{epoch+1}/{num_epochs}], Train Loss: {train_loss:.4f}, Train Accuracy: {train_accuracy*100:.2f}%, Test Loss: {test_loss:.4f}, Test Accuracy: {test_accuracy*100:.2f}%\")\n",
+    "\n",
+    "torch.save(resnet.state_dict(),\"Adam_Resnet.pth\")\n",
+    "\n",
+    "print(\"SGD\")\n",
+    "sgd_train_loss_history = []\n",
+    "sgd_test_loss_history = []\n",
+    "sgd_train_accuracy_history = []\n",
+    "sgd_test_accuracy_history = []\n",
+    "\n",
+    "total_step = len(train_loader)\n",
+    "resnet = ResNet(num_classes).to(device)\n",
+    "resnet_sgd_optimizer = torch.optim.SGD(resnet.parameters(), lr=learning_rate)\n",
+    "\n",
+    "for epoch in range(num_epochs):\n",
+    "    # Training\n",
+    "    accumulate_train_loss,num_total_train_sample,num_accurate_train_prediction = 0.0 ,0,0\n",
+    "    for i, (images, labels) in enumerate(tqdm(train_loader)):\n",
+    "        # Move tensors to the configured device\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "\n",
+    "        # Forward pass\n",
+    "        outputs = resnet(images)\n",
+    "        loss = criterion(outputs, labels)\n",
+    "\n",
+    "        # Backward and optimize\n",
+    "        resnet_sgd_optimizer.zero_grad()\n",
+    "        loss.backward()\n",
+    "        resnet_sgd_optimizer.step()\n",
+    "\n",
+    "        accumulate_train_loss += loss.item()\n",
+    "        num_total_train_sample += labels.size()[0]\n",
+    "        num_accurate_train_prediction += (outputs.argmax(1)==labels).sum().item()\n",
+    "\n",
+    "\n",
+    "\n",
+    "    #print ('{} - Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'\n",
+    "    #               .format(str(datetime.now()), epoch+1, num_epochs, i+1, total_step, accumulate_train_loss/len(train_loader)))\n",
+    "\n",
+    "    train_loss,train_accuracy = accumulate_train_loss/len(train_loader),num_accurate_train_prediction/num_total_train_sample\n",
+    "    sgd_train_loss_history += [train_loss]\n",
+    "    sgd_train_accuracy_history += [train_accuracy]\n",
+    "\n",
+    "    # Validation\n",
+    "    with torch.no_grad():\n",
+    "        correct = 0\n",
+    "        total = 0\n",
+    "        accumulate_test_loss = 0\n",
+    "        for images, labels in valid_loader:\n",
+    "            images = images.to(device)\n",
+    "            labels = labels.to(device)\n",
+    "            outputs = resnet(images)\n",
+    "            loss = criterion(outputs, labels)\n",
+    "            accumulate_test_loss += loss.item()\n",
+    "            _, predicted = torch.max(outputs.data, 1)\n",
+    "            total += labels.size(0)\n",
+    "            correct += (predicted == labels).sum().item()\n",
+    "            del images, labels, outputs\n",
+    "        test_accuracy,test_loss = correct / total,accumulate_test_loss/len(valid_loader)\n",
+    "        #print('Accuracy of the network on the {} validation images: {} %'.format(5000, 100 * correct / total))\n",
+    "        sgd_test_accuracy_history += [test_accuracy]\n",
+    "        sgd_test_loss_history += [test_loss]\n",
+    "    print(f\"{str(datetime.now())} - Epoch [{epoch+1}/{num_epochs}], Train Loss: {train_loss:.4f}, Train Accuracy: {train_accuracy*100:.2f}%, Test Loss: {test_loss:.4f}, Test Accuracy: {test_accuracy*100:.2f}%\")\n",
+    "torch.save(resnet.state_dict(),\"Sgd_Resnet.pth\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "Ablation study on optimizer, training log backup\n",
+    "```\n",
+    "Adam\n",
+    "100%|██████████| 704/704 [01:12<00:00,  9.66it/s]\n",
+    "2025-06-24 01:52:31.147162 - Epoch [1/40], Train Loss: 1.4280, Train Accuracy: 48.82%, Test Loss: 1.1677, Test Accuracy: 57.44%\n",
+    "100%|██████████| 704/704 [01:10<00:00, 10.01it/s]\n",
+    "2025-06-24 01:53:45.688162 - Epoch [2/40], Train Loss: 1.0199, Train Accuracy: 63.50%, Test Loss: 0.9780, Test Accuracy: 64.42%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.10it/s]\n",
+    "2025-06-24 01:54:59.332162 - Epoch [3/40], Train Loss: 0.7838, Train Accuracy: 72.22%, Test Loss: 0.8784, Test Accuracy: 69.30%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.12it/s]\n",
+    "2025-06-24 01:56:12.862162 - Epoch [4/40], Train Loss: 0.5770, Train Accuracy: 79.86%, Test Loss: 0.8081, Test Accuracy: 71.80%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.08it/s]\n",
+    "2025-06-24 01:57:26.671162 - Epoch [5/40], Train Loss: 0.3979, Train Accuracy: 86.51%, Test Loss: 0.8349, Test Accuracy: 72.06%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.12it/s]\n",
+    "2025-06-24 01:58:40.221161 - Epoch [6/40], Train Loss: 0.2373, Train Accuracy: 92.76%, Test Loss: 0.8618, Test Accuracy: 73.28%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.08it/s]\n",
+    "2025-06-24 01:59:54.091164 - Epoch [7/40], Train Loss: 0.1280, Train Accuracy: 96.59%, Test Loss: 0.9082, Test Accuracy: 73.12%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.08it/s]\n",
+    "2025-06-24 02:01:07.899161 - Epoch [8/40], Train Loss: 0.0686, Train Accuracy: 98.55%, Test Loss: 0.9855, Test Accuracy: 72.46%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.12it/s]\n",
+    "2025-06-24 02:02:21.654210 - Epoch [9/40], Train Loss: 0.0366, Train Accuracy: 99.42%, Test Loss: 1.0464, Test Accuracy: 72.98%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.13it/s]\n",
+    "2025-06-24 02:03:35.108210 - Epoch [10/40], Train Loss: 0.0455, Train Accuracy: 98.96%, Test Loss: 1.2019, Test Accuracy: 71.04%\n",
+    "100%|██████████| 704/704 [01:10<00:00, 10.04it/s]\n",
+    "2025-06-24 02:04:49.729211 - Epoch [11/40], Train Loss: 0.0434, Train Accuracy: 98.91%, Test Loss: 1.1916, Test Accuracy: 71.84%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.11it/s]\n",
+    "2025-06-24 02:06:03.390210 - Epoch [12/40], Train Loss: 0.0319, Train Accuracy: 99.21%, Test Loss: 1.2314, Test Accuracy: 72.60%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.12it/s]\n",
+    "2025-06-24 02:07:16.987210 - Epoch [13/40], Train Loss: 0.0303, Train Accuracy: 99.21%, Test Loss: 1.2236, Test Accuracy: 72.66%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.13it/s]\n",
+    "2025-06-24 02:08:30.528210 - Epoch [14/40], Train Loss: 0.0323, Train Accuracy: 99.04%, Test Loss: 1.3886, Test Accuracy: 71.32%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.11it/s]\n",
+    "2025-06-24 02:09:44.136211 - Epoch [15/40], Train Loss: 0.0279, Train Accuracy: 99.24%, Test Loss: 1.3493, Test Accuracy: 71.78%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.11it/s]\n",
+    "2025-06-24 02:10:57.804210 - Epoch [16/40], Train Loss: 0.0324, Train Accuracy: 99.04%, Test Loss: 1.3193, Test Accuracy: 73.06%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.14it/s]\n",
+    "2025-06-24 02:12:11.183211 - Epoch [17/40], Train Loss: 0.0168, Train Accuracy: 99.56%, Test Loss: 1.4429, Test Accuracy: 71.86%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.10it/s]\n",
+    "2025-06-24 02:13:25.019211 - Epoch [18/40], Train Loss: 0.0260, Train Accuracy: 99.17%, Test Loss: 1.3549, Test Accuracy: 72.40%\n",
+    "100%|██████████| 704/704 [01:10<00:00, 10.00it/s]\n",
+    "2025-06-24 02:14:39.530212 - Epoch [19/40], Train Loss: 0.0256, Train Accuracy: 99.21%, Test Loss: 1.5470, Test Accuracy: 71.60%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.12it/s]\n",
+    "2025-06-24 02:15:53.112210 - Epoch [20/40], Train Loss: 0.0214, Train Accuracy: 99.38%, Test Loss: 1.4861, Test Accuracy: 72.94%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.12it/s]\n",
+    "2025-06-24 02:17:06.736240 - Epoch [21/40], Train Loss: 0.0171, Train Accuracy: 99.47%, Test Loss: 1.4023, Test Accuracy: 73.42%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.11it/s]\n",
+    "2025-06-24 02:18:20.621236 - Epoch [22/40], Train Loss: 0.0277, Train Accuracy: 99.07%, Test Loss: 1.4851, Test Accuracy: 72.78%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.11it/s]\n",
+    "2025-06-24 02:19:34.485237 - Epoch [23/40], Train Loss: 0.0059, Train Accuracy: 99.88%, Test Loss: 1.5275, Test Accuracy: 73.98%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.14it/s]\n",
+    "2025-06-24 02:20:47.898237 - Epoch [24/40], Train Loss: 0.0009, Train Accuracy: 100.00%, Test Loss: 1.5485, Test Accuracy: 74.66%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.11it/s]\n",
+    "2025-06-24 02:22:01.514238 - Epoch [25/40], Train Loss: 0.0003, Train Accuracy: 100.00%, Test Loss: 1.5256, Test Accuracy: 74.98%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.10it/s]\n",
+    "2025-06-24 02:23:15.165236 - Epoch [26/40], Train Loss: 0.0002, Train Accuracy: 100.00%, Test Loss: 1.5527, Test Accuracy: 74.70%\n",
+    "100%|██████████| 704/704 [01:09<00:00, 10.07it/s]\n",
+    "2025-06-24 02:24:29.270238 - Epoch [27/40], Train Loss: 0.0001, Train Accuracy: 100.00%, Test Loss: 1.6148, Test Accuracy: 75.40%\n",
+    "100%|██████████| 704/704 [01:08<00:00, 10.27it/s]\n",
+    "2025-06-24 02:25:41.450765 - Epoch [28/40], Train Loss: 0.0001, Train Accuracy: 100.00%, Test Loss: 1.6371, Test Accuracy: 74.96%\n",
+    "100%|██████████| 704/704 [01:06<00:00, 10.57it/s]\n",
+    "2025-06-24 02:26:52.069808 - Epoch [29/40], Train Loss: 0.0000, Train Accuracy: 100.00%, Test Loss: 1.6650, Test Accuracy: 75.08%\n",
+    "100%|██████████| 704/704 [01:06<00:00, 10.57it/s]\n",
+    "2025-06-24 02:28:02.463729 - Epoch [30/40], Train Loss: 0.0000, Train Accuracy: 100.00%, Test Loss: 1.6668, Test Accuracy: 75.08%\n",
+    "100%|██████████| 704/704 [01:06<00:00, 10.52it/s]\n",
+    "2025-06-24 02:29:13.069314 - Epoch [31/40], Train Loss: 0.0001, Train Accuracy: 100.00%, Test Loss: 1.8749, Test Accuracy: 74.30%\n",
+    "100%|██████████| 704/704 [01:06<00:00, 10.54it/s]\n",
+    "2025-06-24 02:30:23.805413 - Epoch [32/40], Train Loss: 0.0913, Train Accuracy: 97.14%, Test Loss: 1.5489, Test Accuracy: 72.60%\n",
+    "100%|██████████| 704/704 [01:06<00:00, 10.56it/s]\n",
+    "2025-06-24 02:31:34.082492 - Epoch [33/40], Train Loss: 0.0064, Train Accuracy: 99.84%, Test Loss: 1.5181, Test Accuracy: 73.72%\n",
+    "100%|██████████| 704/704 [01:06<00:00, 10.54it/s]\n",
+    "2025-06-24 02:32:44.537330 - Epoch [34/40], Train Loss: 0.0123, Train Accuracy: 99.60%, Test Loss: 1.5318, Test Accuracy: 71.36%\n",
+    "100%|██████████| 704/704 [01:06<00:00, 10.56it/s]\n",
+    "2025-06-24 02:33:54.904164 - Epoch [35/40], Train Loss: 0.0224, Train Accuracy: 99.23%, Test Loss: 1.5537, Test Accuracy: 72.64%\n",
+    "100%|██████████| 704/704 [01:07<00:00, 10.38it/s]\n",
+    "2025-06-24 02:35:06.621623 - Epoch [36/40], Train Loss: 0.0153, Train Accuracy: 99.53%, Test Loss: 1.6972, Test Accuracy: 71.24%\n",
+    "100%|██████████| 704/704 [01:06<00:00, 10.62it/s]\n",
+    "2025-06-24 02:36:16.566354 - Epoch [37/40], Train Loss: 0.0156, Train Accuracy: 99.50%, Test Loss: 1.6090, Test Accuracy: 72.98%\n",
+    "100%|██████████| 704/704 [01:06<00:00, 10.57it/s]\n",
+    "2025-06-24 02:37:26.837373 - Epoch [38/40], Train Loss: 0.0024, Train Accuracy: 99.96%, Test Loss: 1.6209, Test Accuracy: 74.48%\n",
+    "100%|██████████| 704/704 [01:06<00:00, 10.63it/s]\n",
+    "2025-06-24 02:38:36.784972 - Epoch [39/40], Train Loss: 0.0274, Train Accuracy: 99.07%, Test Loss: 1.5927, Test Accuracy: 72.94%\n",
+    "100%|██████████| 704/704 [01:06<00:00, 10.53it/s]\n",
+    "2025-06-24 02:39:47.594456 - Epoch [40/40], Train Loss: 0.0121, Train Accuracy: 99.59%, Test Loss: 1.6070, Test Accuracy: 73.10%\n",
+    "SGD\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.64it/s]\n",
+    "2025-06-24 02:41:34.255639 - Epoch [1/40], Train Loss: 2.1868, Train Accuracy: 22.57%, Test Loss: 2.0919, Test Accuracy: 28.06%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.67it/s]\n",
+    "2025-06-24 02:42:33.517609 - Epoch [2/40], Train Loss: 2.0392, Train Accuracy: 30.85%, Test Loss: 1.9881, Test Accuracy: 33.10%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.70it/s]\n",
+    "2025-06-24 02:43:32.564905 - Epoch [3/40], Train Loss: 1.9496, Train Accuracy: 33.95%, Test Loss: 1.9118, Test Accuracy: 35.64%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.77it/s]\n",
+    "2025-06-24 02:44:31.574836 - Epoch [4/40], Train Loss: 1.8820, Train Accuracy: 36.20%, Test Loss: 1.8502, Test Accuracy: 37.36%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.74it/s]\n",
+    "2025-06-24 02:45:30.405675 - Epoch [5/40], Train Loss: 1.8275, Train Accuracy: 37.63%, Test Loss: 1.8014, Test Accuracy: 38.42%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.77it/s]\n",
+    "2025-06-24 02:46:29.138808 - Epoch [6/40], Train Loss: 1.7839, Train Accuracy: 39.23%, Test Loss: 1.7714, Test Accuracy: 39.08%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.72it/s]\n",
+    "2025-06-24 02:47:28.078673 - Epoch [7/40], Train Loss: 1.7460, Train Accuracy: 40.10%, Test Loss: 1.7319, Test Accuracy: 40.70%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.75it/s]\n",
+    "2025-06-24 02:48:26.964125 - Epoch [8/40], Train Loss: 1.7162, Train Accuracy: 41.15%, Test Loss: 1.7022, Test Accuracy: 41.22%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.74it/s]\n",
+    "2025-06-24 02:49:26.022220 - Epoch [9/40], Train Loss: 1.6879, Train Accuracy: 41.90%, Test Loss: 1.6826, Test Accuracy: 41.92%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.68it/s]\n",
+    "2025-06-24 02:50:25.340291 - Epoch [10/40], Train Loss: 1.6651, Train Accuracy: 42.68%, Test Loss: 1.6550, Test Accuracy: 42.24%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.75it/s]\n",
+    "2025-06-24 02:51:24.403384 - Epoch [11/40], Train Loss: 1.6434, Train Accuracy: 43.35%, Test Loss: 1.6437, Test Accuracy: 42.78%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.78it/s]\n",
+    "2025-06-24 02:52:23.302279 - Epoch [12/40], Train Loss: 1.6244, Train Accuracy: 43.92%, Test Loss: 1.6255, Test Accuracy: 43.52%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.73it/s]\n",
+    "2025-06-24 02:53:22.230288 - Epoch [13/40], Train Loss: 1.6080, Train Accuracy: 44.47%, Test Loss: 1.6026, Test Accuracy: 44.06%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.77it/s]\n",
+    "2025-06-24 02:54:20.932420 - Epoch [14/40], Train Loss: 1.5926, Train Accuracy: 44.89%, Test Loss: 1.5978, Test Accuracy: 44.16%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.67it/s]\n",
+    "2025-06-24 02:55:20.119694 - Epoch [15/40], Train Loss: 1.5781, Train Accuracy: 45.41%, Test Loss: 1.5816, Test Accuracy: 44.68%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.73it/s]\n",
+    "2025-06-24 02:56:19.019310 - Epoch [16/40], Train Loss: 1.5643, Train Accuracy: 46.02%, Test Loss: 1.5688, Test Accuracy: 45.56%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.72it/s]\n",
+    "2025-06-24 02:57:17.970590 - Epoch [17/40], Train Loss: 1.5537, Train Accuracy: 46.19%, Test Loss: 1.5560, Test Accuracy: 46.02%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.73it/s]\n",
+    "2025-06-24 02:58:16.931478 - Epoch [18/40], Train Loss: 1.5384, Train Accuracy: 46.72%, Test Loss: 1.5518, Test Accuracy: 46.12%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.73it/s]\n",
+    "2025-06-24 02:59:15.840693 - Epoch [19/40], Train Loss: 1.5282, Train Accuracy: 47.18%, Test Loss: 1.5391, Test Accuracy: 46.32%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.61it/s]\n",
+    "2025-06-24 03:00:15.347053 - Epoch [20/40], Train Loss: 1.5178, Train Accuracy: 47.64%, Test Loss: 1.5279, Test Accuracy: 46.68%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.70it/s]\n",
+    "2025-06-24 03:01:14.393323 - Epoch [21/40], Train Loss: 1.5066, Train Accuracy: 47.93%, Test Loss: 1.5242, Test Accuracy: 47.02%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.61it/s]\n",
+    "2025-06-24 03:02:13.864149 - Epoch [22/40], Train Loss: 1.4976, Train Accuracy: 48.27%, Test Loss: 1.5106, Test Accuracy: 47.24%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.64it/s]\n",
+    "2025-06-24 03:03:13.184535 - Epoch [23/40], Train Loss: 1.4871, Train Accuracy: 48.64%, Test Loss: 1.5088, Test Accuracy: 48.32%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.70it/s]\n",
+    "2025-06-24 03:04:12.278857 - Epoch [24/40], Train Loss: 1.4775, Train Accuracy: 48.86%, Test Loss: 1.4948, Test Accuracy: 47.80%\n",
+    "100%|██��███████| 704/704 [00:56<00:00, 12.50it/s]\n",
+    "2025-06-24 03:05:12.436950 - Epoch [25/40], Train Loss: 1.4678, Train Accuracy: 49.33%, Test Loss: 1.4906, Test Accuracy: 48.98%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.69it/s]\n",
+    "2025-06-24 03:06:11.527410 - Epoch [26/40], Train Loss: 1.4575, Train Accuracy: 49.76%, Test Loss: 1.4788, Test Accuracy: 48.42%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.71it/s]\n",
+    "2025-06-24 03:07:10.483268 - Epoch [27/40], Train Loss: 1.4478, Train Accuracy: 50.06%, Test Loss: 1.4817, Test Accuracy: 48.80%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.72it/s]\n",
+    "2025-06-24 03:08:09.484575 - Epoch [28/40], Train Loss: 1.4394, Train Accuracy: 50.25%, Test Loss: 1.4626, Test Accuracy: 49.34%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.66it/s]\n",
+    "2025-06-24 03:09:08.707820 - Epoch [29/40], Train Loss: 1.4313, Train Accuracy: 50.61%, Test Loss: 1.4550, Test Accuracy: 49.04%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.68it/s]\n",
+    "2025-06-24 03:10:07.851819 - Epoch [30/40], Train Loss: 1.4207, Train Accuracy: 50.92%, Test Loss: 1.4498, Test Accuracy: 49.70%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.70it/s]\n",
+    "2025-06-24 03:11:06.924673 - Epoch [31/40], Train Loss: 1.4142, Train Accuracy: 51.27%, Test Loss: 1.4390, Test Accuracy: 49.76%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.72it/s]\n",
+    "2025-06-24 03:12:05.879449 - Epoch [32/40], Train Loss: 1.4062, Train Accuracy: 51.51%, Test Loss: 1.4384, Test Accuracy: 50.32%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.74it/s]\n",
+    "2025-06-24 03:13:04.839480 - Epoch [33/40], Train Loss: 1.3979, Train Accuracy: 51.65%, Test Loss: 1.4342, Test Accuracy: 50.78%\n",
+    "100%|██████████| 704/704 [00:56<00:00, 12.56it/s]\n",
+    "2025-06-24 03:14:04.513014 - Epoch [34/40], Train Loss: 1.3903, Train Accuracy: 52.03%, Test Loss: 1.4238, Test Accuracy: 50.36%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.66it/s]\n",
+    "2025-06-24 03:15:03.801946 - Epoch [35/40], Train Loss: 1.3832, Train Accuracy: 52.33%, Test Loss: 1.4147, Test Accuracy: 50.32%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.74it/s]\n",
+    "2025-06-24 03:16:02.818824 - Epoch [36/40], Train Loss: 1.3747, Train Accuracy: 52.53%, Test Loss: 1.4178, Test Accuracy: 51.16%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.73it/s]\n",
+    "2025-06-24 03:17:01.810527 - Epoch [37/40], Train Loss: 1.3698, Train Accuracy: 52.81%, Test Loss: 1.4074, Test Accuracy: 51.12%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.75it/s]\n",
+    "2025-06-24 03:18:00.701375 - Epoch [38/40], Train Loss: 1.3602, Train Accuracy: 53.09%, Test Loss: 1.3984, Test Accuracy: 50.80%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.76it/s]\n",
+    "2025-06-24 03:18:59.736929 - Epoch [39/40], Train Loss: 1.3536, Train Accuracy: 53.24%, Test Loss: 1.3983, Test Accuracy: 50.98%\n",
+    "100%|██████████| 704/704 [00:55<00:00, 12.65it/s]\n",
+    "2025-06-24 03:19:59.237586 - Epoch [40/40], Train Loss: 1.3482, Train Accuracy: 53.58%, Test Loss: 1.3909, Test Accuracy: 51.36%\n",
+    "\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x1000 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(20,10))\n",
+    "plt.subplot(2,2,1)\n",
+    "plt.plot(np.log(adam_train_loss_history),label=\"Train Loss\")\n",
+    "plt.plot(np.log(adam_test_loss_history),label=\"Test Loss\")\n",
+    "plt.title(\"adam train loss history\")\n",
+    "plt.legend()\n",
+    "plt.subplot(2,2,2)\n",
+    "plt.plot(adam_train_accuracy_history,label=\"Train Accuracy\")\n",
+    "plt.plot(adam_test_accuracy_history,label=\"Test Accuracy\")\n",
+    "plt.title(\"adam train accuracy history\")\n",
+    "plt.legend()\n",
+    "\n",
+    "\n",
+    "plt.subplot(2,2,3)\n",
+    "plt.plot(np.log(sgd_train_loss_history),label=\"Train Loss\")\n",
+    "plt.plot(np.log(sgd_test_loss_history),label=\"Test Loss\")\n",
+    "plt.title(\"sgd train loss history\")\n",
+    "plt.legend()\n",
+    "plt.subplot(2,2,4)\n",
+    "plt.plot(sgd_train_accuracy_history,label=\"Train Accuracy\")\n",
+    "plt.plot(sgd_test_accuracy_history,label=\"Test Accuracy\")\n",
+    "plt.title(\"sgd train accuracy history\")\n",
+    "plt.legend()\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "OWQ9Lrw1MbBt"
+   },
+   "source": [
+    "## Resources\n",
+    "\n",
+    "- [Writing AlexNet from Scratch in PyTorch](https://blog.paperspace.com/alexnet-pytorch/#training)\n",
+    "- [AlexNet | PyTorch](https://pytorch.org/hub/pytorch_vision_alexnet/)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "bawRnlZ4qVkh"
+   },
+   "source": [
+    "VGGNet and data totally take 13.9 GB of VRAM\n",
+    "\n",
+    "ResNet and data totally take 7.2 GB of VRAM"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "id": "oWuOLBUtqgFf",
+    "jupyter": {
+     "is_executing": true
+    }
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "gpuType": "T4",
+   "provenance": [
+    {
+     "file_id": "1s8ZM5vSQQ8o3dZINdOP6GdZykzAqr-L8",
+     "timestamp": 1750346413209
+    }
+   ]
+  },
+  "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.12.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}