moderno_cabo_fonte.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Roteiro\n",
    "1. Leitura dos dados\n",
    "2. Criação dos datasets e dataloaders\n",
    "3. Definição do modelo, otimizador e loss function\n",
    "4. Definição das funções de treino, validação e teste\n",
    "5. Treinamento\n",
    "6. Inferência"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Leitura dos dados\n",
    "\n",
    "Carregando dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Copying files: 50 files [00:00, 451.65 files/s]\n"
     ]
    }
   ],
   "source": [
    "import splitfolders\n",
    "splitfolders.ratio('cabo_crop', output=\"cabo_crop_splitted\", seed=1337, ratio=(0.6, 0.2, 0.2))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Criação dos datasets e dataloaders\n",
    "\n",
    "Criando as transformações nos dados\n",
    "- resize\n",
    "- normalização\n",
    "\n",
    "O dataset de treino sofre resize e normalização de acordo com o ImageNet Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# imports\n",
    "import os\n",
    "import torch\n",
    "from torchvision import datasets\n",
    "import torchvision.transforms as transforms\n",
    "\n",
    "train_transform = transforms.Compose([\n",
    "        transforms.Resize((224,350)),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "    ])\n",
    "\n",
    "transform = transforms.Compose([\n",
    "        transforms.Resize((224,350)),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "    ])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Criação dos datasets e dataloarders de treino, teste e validação"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Quantidade de classes: 2\n",
      "Nome das classes: \n",
      "['crop_bom', 'crop_ruim']\n"
     ]
    }
   ],
   "source": [
    "data_dir = 'cabo_crop_splitted'\n",
    "\n",
    "train_dataset = datasets.ImageFolder(os.path.join(data_dir + \"/train\"), transform=train_transform)\n",
    "val_dataset = datasets.ImageFolder(os.path.join(data_dir + \"/val\"), transform=transform)\n",
    "test_dataset = datasets.ImageFolder(os.path.join(data_dir + \"/test\"), transform=transform)\n",
    "\n",
    "train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=2, shuffle=True)\n",
    "val_dataloader = torch.utils.data.DataLoader(val_dataset, batch_size=2, shuffle=True)\n",
    "test_dataloader = torch.utils.data.DataLoader(test_dataset, batch_size=2, shuffle=True)\n",
    "\n",
    "num_classes = len(train_dataset.classes)\n",
    "class_names = train_dataset.classes\n",
    "\n",
    "print(f'Quantidade de classes: {num_classes}')\n",
    "print(f'Nome das classes: \\n{class_names}')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Definido modelo, otimizador e função de perda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ResNet(\n",
      "  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
      "  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "  (relu): ReLU(inplace=True)\n",
      "  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
      "  (layer1): Sequential(\n",
      "    (0): BasicBlock(\n",
      "      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU(inplace=True)\n",
      "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    )\n",
      "    (1): BasicBlock(\n",
      "      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU(inplace=True)\n",
      "      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    )\n",
      "  )\n",
      "  (layer2): Sequential(\n",
      "    (0): BasicBlock(\n",
      "      (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
      "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU(inplace=True)\n",
      "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (downsample): Sequential(\n",
      "        (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
      "        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      )\n",
      "    )\n",
      "    (1): BasicBlock(\n",
      "      (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU(inplace=True)\n",
      "      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    )\n",
      "  )\n",
      "  (layer3): Sequential(\n",
      "    (0): BasicBlock(\n",
      "      (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
      "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU(inplace=True)\n",
      "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (downsample): Sequential(\n",
      "        (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
      "        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      )\n",
      "    )\n",
      "    (1): BasicBlock(\n",
      "      (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU(inplace=True)\n",
      "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    )\n",
      "  )\n",
      "  (layer4): Sequential(\n",
      "    (0): BasicBlock(\n",
      "      (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
      "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU(inplace=True)\n",
      "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (downsample): Sequential(\n",
      "        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
      "        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      )\n",
      "    )\n",
      "    (1): BasicBlock(\n",
      "      (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "      (relu): ReLU(inplace=True)\n",
      "      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
      "    )\n",
      "  )\n",
      "  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n",
      "  (fc): Linear(in_features=512, out_features=2, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "from torchvision import models\n",
    "import torch.nn as nn\n",
    "from torch import optim\n",
    "\n",
    "device = torch.device('cpu')\n",
    "\n",
    "model = models.resnet18(pretrained=True)\n",
    "model.fc = nn.Linear(in_features=512, out_features=num_classes, bias=True)\n",
    "print(model)\n",
    "\n",
    "model.to(device)\n",
    "\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=3e-4)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Definição das funções de treino, validação e teste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "from datetime import datetime\n",
    "import copy\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "def plot_losses(train_losses, valid_losses):\n",
    "    '''\n",
    "    Function for plotting training and validation losses\n",
    "    '''\n",
    "    \n",
    "    plt.style.use('seaborn')\n",
    "\n",
    "    train_losses = np.array(train_losses) \n",
    "    valid_losses = np.array(valid_losses)\n",
    "\n",
    "    fig, ax = plt.subplots(figsize = (8, 4.5))\n",
    "\n",
    "    ax.plot(train_losses, color='blue', label='Training loss') \n",
    "    ax.plot(valid_losses, color='red', label='Validation loss')\n",
    "    ax.set(title=\"Loss over epochs\", \n",
    "            xlabel='Epoch',\n",
    "            ylabel='Loss') \n",
    "    ax.legend()\n",
    "    \n",
    "def get_accuracy(model, data_loader, device):\n",
    "    correct_pred = 0 \n",
    "    n = 0\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        model.eval()\n",
    "        for inputs, labels in data_loader:\n",
    "\n",
    "            inputs = inputs.to(device)\n",
    "            labels = labels.to(device)\n",
    "\n",
    "            output_prob = model(inputs)\n",
    "            _, predicted_labels = torch.max(output_prob, 1)\n",
    "\n",
    "            n += labels.size(0) # add batch_size num of samples being iterated\n",
    "            correct_pred += (predicted_labels == labels).sum() # sum array of bools (1's are correct predictions)\n",
    "\n",
    "    return correct_pred.float() / n\n",
    "\n",
    "def train(train_loader, model, criterion, optimizer, device):\n",
    "    model.train()\n",
    "    running_loss = 0\n",
    "    \n",
    "    for inputs, labels in train_loader:\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        inputs = inputs.to(device)\n",
    "        labels = labels.to(device)\n",
    "    \n",
    "        # Forward pass\n",
    "        outputs = model(inputs) \n",
    "        loss = criterion(outputs, labels) \n",
    "        running_loss += loss.item() * inputs.size(0)\n",
    "\n",
    "        # Backward pass\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "    epoch_loss = running_loss / len(train_loader.dataset)\n",
    "    return model, optimizer, epoch_loss\n",
    "\n",
    "def val(val_loader, model, criterion, device):\n",
    "  \n",
    "    model.eval()\n",
    "    running_loss = 0\n",
    "    \n",
    "    for inputs, labels in val_loader:\n",
    "    \n",
    "        inputs = inputs.to(device)\n",
    "        labels = labels.to(device)\n",
    "\n",
    "        # Forward pass and record loss\n",
    "        with torch.no_grad():\n",
    "            outputs = model(inputs) \n",
    "            loss = criterion(outputs, labels) \n",
    "            running_loss += loss.item() * inputs.size(0)\n",
    "\n",
    "    epoch_loss = running_loss / len(val_loader.dataset)\n",
    "        \n",
    "    return model, epoch_loss\n",
    "\n",
    "\n",
    "def training_loop(model, criterion, optimizer, train_loader, valid_loader, test_dataloader, epoches, device, print_every=1):\n",
    "    '''\n",
    "    Function defining the entire training loop\n",
    "    '''\n",
    "    # set objects for storing metrics\n",
    "    best_acc = 0.0\n",
    "    best_loss = 1e10\n",
    "    train_losses = []\n",
    "    valid_losses = []\n",
    "\n",
    "    # Train model and validate\n",
    "    for epoch in range(epoches):\n",
    "\n",
    "        # training\n",
    "        model, optimizer, train_loss = train(train_loader, model, criterion, optimizer, device)\n",
    "        train_losses.append(train_loss)\n",
    "\n",
    "        # validation\n",
    "        with torch.no_grad():\n",
    "            model, valid_loss = val(valid_loader, model, criterion, device)\n",
    "            valid_losses.append(valid_loss)\n",
    "\n",
    "        # accuracies\n",
    "        if epoch % print_every == (print_every - 1):\n",
    "            \n",
    "            train_acc = get_accuracy(model, train_loader, device=device)\n",
    "            valid_acc = get_accuracy(model, valid_loader, device=device)\n",
    "            test_acc = get_accuracy(model, test_dataloader, device=device)\n",
    "            \n",
    "            print(f'{datetime.now().time().replace(microsecond=0)} --- '\n",
    "                    f'Epoch: {epoch}\\t'\n",
    "                    f'Train loss: {train_loss:.4f}\\t'\n",
    "                    f'Valid loss: {valid_loss:.4f}\\t'\n",
    "                    f'Train accuracy: {100 * train_acc:.2f}\\t'\n",
    "                    f'Val accuracy: {100 * valid_acc:.2f}\\t'\n",
    "                    f'Test accuracy: {100 * test_acc:.2f}')\n",
    "\n",
    "        # create a copy of our model when it test its best\n",
    "        if test_acc >= best_acc:\n",
    "            best_acc = test_acc\n",
    "            best_model_wts = copy.deepcopy(model.state_dict())\n",
    "        \n",
    "    plot_losses(train_losses, valid_losses)\n",
    "    print('Best val Acc: {:4f}'.format(best_acc))\n",
    "    model.load_state_dict(best_model_wts)\n",
    "    return model"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Treinamento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10:17:39 --- Epoch: 0/tTrain loss: 0.4874\tValid loss: 0.0110\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 100.00\n",
      "10:17:49 --- Epoch: 1/tTrain loss: 0.5977\tValid loss: 1.0055\tTrain accuracy: 83.33\tVal accuracy: 80.00\tTest accuracy: 100.00\n",
      "10:17:59 --- Epoch: 2/tTrain loss: 0.5910\tValid loss: 0.0934\tTrain accuracy: 96.67\tVal accuracy: 100.00\tTest accuracy: 100.00\n",
      "10:18:09 --- Epoch: 3/tTrain loss: 0.2530\tValid loss: 0.0255\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 100.00\n",
      "10:18:19 --- Epoch: 4/tTrain loss: 0.1598\tValid loss: 0.0138\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 100.00\n",
      "10:18:29 --- Epoch: 5/tTrain loss: 0.0776\tValid loss: 0.0069\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 100.00\n",
      "10:18:40 --- Epoch: 6/tTrain loss: 0.0929\tValid loss: 0.0131\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 100.00\n",
      "10:18:49 --- Epoch: 7/tTrain loss: 0.0480\tValid loss: 0.0092\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 100.00\n",
      "10:18:59 --- Epoch: 8/tTrain loss: 0.0436\tValid loss: 0.0066\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 100.00\n",
      "10:19:09 --- Epoch: 9/tTrain loss: 0.0278\tValid loss: 0.0072\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 100.00\n",
      "10:19:19 --- Epoch: 10/tTrain loss: 0.0277\tValid loss: 0.0036\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 100.00\n",
      "10:19:29 --- Epoch: 11/tTrain loss: 0.0372\tValid loss: 0.0041\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 100.00\n",
      "10:19:39 --- Epoch: 12/tTrain loss: 0.0168\tValid loss: 0.0028\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 100.00\n",
      "10:19:49 --- Epoch: 13/tTrain loss: 0.0167\tValid loss: 0.0025\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 100.00\n",
      "10:20:00 --- Epoch: 14/tTrain loss: 0.0164\tValid loss: 0.0016\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 100.00\n",
      "10:20:10 --- Epoch: 15/tTrain loss: 0.0199\tValid loss: 0.0015\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 100.00\n",
      "10:20:20 --- Epoch: 16/tTrain loss: 0.0121\tValid loss: 0.0015\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 100.00\n",
      "10:20:30 --- Epoch: 17/tTrain loss: 0.0111\tValid loss: 0.0012\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 100.00\n",
      "10:20:41 --- Epoch: 18/tTrain loss: 0.0104\tValid loss: 0.0012\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 100.00\n",
      "10:20:51 --- Epoch: 19/tTrain loss: 0.0091\tValid loss: 0.0011\tTrain accuracy: 100.00\tVal accuracy: 100.00\tTest accuracy: 100.00\n",
      "Best val Acc: 1.000000\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAe8AAAEvCAYAAABsYUl5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAABJ+ElEQVR4nO3deXhTVf7H8fe9SdMmbWkLDbQsVaiAK7K4I6ggKpsgyCYWFRTEdRDFZWRfBMUNQcWRQQVGRNxwXMYFFH+MoqKMgIKigGxdgEL3pMk9vz/SpC202CVpk/T7ep4+Se69Sc5pCp+cc885V1NKKYQQQggRMvT6LoAQQgghqkfCWwghhAgxEt5CCCFEiJHwFkIIIUKMhLcQQggRYiS8hRBCiBAj4S1EHdi3bx+dOnWq72KEvB49erBly5b6LoYQ9U7CWwghhAgx5vougBANXW5uLtOnT2f79u1omka3bt247777MJvNLFiwgE8//ZSIiAgSEhJ47LHHaNq0aaXbq/K6b731FmvXrmXx4sUA/P7779x888188cUX7N69m9mzZ3P06FHcbjdpaWlcf/31bNy4kdmzZ2Oz2SgoKGD16tVYLBbfe2VkZDBjxgwOHjxIcXExffv25fbbb2ffvn2kpaVxwQUXsH37dpRSTJkyhfPOO4/i4mLmzp3L119/jclkokOHDjz88MPExMSwa9cupkyZwpEjR9B1nfHjx9OnTx8A3njjDaZOncqRI0cYMGAAEyZMID8/n4cffpg9e/ag6zpnnXUWM2bMQNelfSLClBJCBNzevXtVx44dK9w3adIkNXPmTGUYhnI4HGr06NFq8eLF6sCBA6pz587K4XAopZRasmSJ+vTTTyvdXtXXzc3NVV26dFGZmZlKKaUef/xx9dRTT6ni4mLVp08ftXXrVqWUUjk5Oap3797qxx9/VN988406/fTT1b59+yqsQ1pamvr888+VUkoVFRWptLQ09cEHH6i9e/eqdu3aqTVr1iillPriiy9U165dldPpVM8++6y66667lNPpVG63Wz300ENq8uTJSimlBg4cqJYvX66UUurAgQOqZ8+eKjc3V11xxRVqxowZSimlMjMz1dlnn60OHDig3nnnHTV69GillFIul0v9/e9/V7t3767mpyRE6JCvpULUs/Xr13PjjTeiaRoWi4Xhw4ezfv16mjVrxumnn851113HvHnzOOOMM7jyyisr3V7V142JieHqq69mzZo1uN1u1qxZw/XXX8/u3bv5888/eeSRRxgwYAA33ngjRUVF/PzzzwAkJyfTokWLE96noKCA7777jmeffZYBAwYwdOhQDh48yPbt2wGIi4ujf//+AFx22WWYTCZ27NjB+vXrGT58OBEREei6TlpaGl999RVHjx5l+/btDBkyxPe+n332GTExMQD069cPALvdTmJiIocPH6ZLly7s3LmTtLQ0XnrpJW666SZOOeUU/39YQgQJ6TYXop4ZhnHCY5fLha7rLF++nC1btvD1118zZ84cLrzwQh599NFKt1fldQGGDBnC5MmTSU1N5bTTTqNVq1bs2LGDRo0a8d577/mec+jQIWJjY9m8eTM2m63S8iulWLlyJVarFYAjR44QGRlJdnY2JpPphONNJlOF5SsuLsZs9vy3pGmab98ff/xB8+bNAXz7vccopWjVqhWffvopGzdu5JtvvuGWW27h0Ucf5Zprrqnkty5EaJOWtxD17NJLL2XFihUopXA6naxatYpLLrmE7du3069fP1JTUxk3bhw333wzO3bsqHR7VV8XoGPHjgAsWrTI18Jt3bo1kZGRvvA+ePAg/fr1Y+vWrSctf0xMDB07dmTp0qUA5OTkMGLECD7//HPAE+Tr168HYO3atURERNCuXTu6devGypUrKS4uxjAMVqxYQdeuXYmJieGss87i3Xff9ZVjxIgR5ObmVlqGf/3rXzz88MNceumlPPDAA1x66aX89ttvVfwEhAg90vIWoo4UFBScMF1s5cqVPProo8yaNYv+/ftTXFxMt27duP3227FYLPTu3ZvBgwdjs9mIiori0Ucf5fTTT69w+/Eqe12vIUOG8Pzzz/u63C0WC88//zyzZ8/m5ZdfxuVyce+999KlSxc2btx40rrNnz+fmTNn0r9/f5xOJ/369ePaa69l3759vi8E8+fPJyoqikWLFmEymRg/fjzz5s1j4MCBuFwuOnTowOTJkwF48sknmT59OsuWLUPTNGbPno3dbq/0/QcOHMi3335Lnz59sFqtNG/enFGjRlX5sxEi1GhKySVBhRCBsW/fPvr378+PP/5Y30URIqxIt7kQQggRYqTlLYQQQoQYaXkLIYQQIUbCWwghhAgxEt5CCCFEiAmZqWJZWZXP8ayJhAQb2dkFfn3NYBCO9QrHOkF41kvqFDrCsV7hVie7PbbSfQ225W02m/76oBAUjvUKxzpBeNZL6hQ6wrFe4VinyjTY8BZCCCFClYS3EEIIEWIkvIUQQogQI+EthBBChBgJbyGEECLESHgLIYQQIUbCWwghhAgxAQ3v//3vf6SlpZ2wfe3atQwePJhhw4axatWqQBZBCCFEEHruuae5666x3HDDYAYN6stdd43l0UcfrNJzly17hZ9/3lrp/meffZL09PQal23JksW8++7qGj+/LgRshbV//OMfrFmzBqvVWm57cXExjz32GKtXr8ZqtTJixAh69OhBYmJioIpSN5Qi6rWlOLtdhtEmtb5LI4QQQe3uuycA8OGH77Nnz27Gj7+7ys9NS7v5pPvvvXdibYoWEgIW3ikpKTz33HNMmjSp3Pbff/+dlJQU4uLiAOjSpQvfffcdvXv3DlRR6oTpt1+JfeBvFN6QRt4zi+q7OEIIEZJmz57GsWPHyMk5xrx5T/HCC8+RmZnB4cOH6Nq1O2PH3sHs2dPo2fMqjhw5zNdfb8DhKGL//n3cfvs4unXrxV13jeWBBx7hs8/+w8GDB8jOziYj4yB3330fF154MRs2fMWSJS8SHR1DbGwjUlNPY8yYcRWW57nnnuannzYD0KvXNQwdOoIvv1zL8uWvYjabSUy0M336HLZu/YmFC5/BbDYTFRXFrFnzsNmiA/Z7Clh4X3311ezbt++E7Xl5ecTGlq7XGh0dTV5eXqCKUWf0/Z66miqosxBCBLNp0yJ5/33/xkH//i6mTXPU6LldupzHsGEjOXjwAGeddQ4PPTQZh8PBoEF9GDv2jnLH5ufn8dRTC9m7908eeWQi3br1Krc/IsLCk08u4LvvvuH111dw3nkX8Mwz81m8+J80btyE6dMfrbQcGzZ8xcGDB3jppVdwu92MHz+GLl3O59NP/8MNN6RxxRVX8tFH/yY/P5+vvvqSHj2uZOjQG/i//1tPTk5uaIZ3ZWJiYsjPz/c9zs/PLxfmlUlIsPl93dqTLfpebYXHALBkpfv3dWugvt8/EMKxThCe9ZI6hQ5vvWw20P08Aspms2C3W/7yuNjYqJJjPWWJiorgnHPOwG6PxWptwerVvzF37jRiYmIoLi7Gbo8lKiqCuDgrxcVRdOhwNnZ7LI0anYbT6cRuj8ViMZOQYCM6OpKUlA7Y7bG0b98GcGMyFRMXF0v79qcC0LXrRRw6dKjcZxwdHUlMTBSHDh2ga9eLaNq0EQDnndeZI0cOMm3aZBYvXsyaNW/Rpk0bBg3qz4QJd/Piiy9y//130axZM7p1uzCgfzd1Ht6pqans2bOHo0ePYrPZ+P777xkzZsxfPs/fV4qx22P9eqUy6849xADGvv0c9vMV0KrD3/UKBuFYJwjPekmdQkfZek2a5Pnxt6ysvz4mN7eIggKnryxFRcXk5BSRlZXLm2+uxGSK5KGHHmDfvr2sWrWKzMwcioqKOXaskNzcIgoLi8nKysXhcJS8Zy5Op4vs7ALy8x1ERTnIysolO7sAp9OFYVjIycnl11//JCEhgY0bvycpKbncZ+x5XhF2e3M+/HANffsOxuVy8d13m7j88qtZunQZN9xwCwkJjXn88dm8/fb75OfncfnlVzF69B0sW7aUpUuXMXr02Fr9/k4W/nUW3u+//z4FBQUMGzaMhx56iDFjxqCUYvDgwTRr1qyuihEweqZnZKOemwN5eRATU88lEkKI0Naly/lMn/4o27ZtISIigpYtW3HoUBW+EZyErutMmDCJBx64l+joGJQyaNmyVYXHdu3ajR9/3MS4cbdQXFxMjx5X0r796WRlZTJp0t+w2aKxWq1ccsml7Nu3j7lzZ2G1WtE0jUmT/l6rcv4VTSmlAvoOfuLvb77+/jYde9vNRL33NgBH/rsJ92lt/fba1RGOrYRwrBOEZ72kTqEjHOtV1TotW7aUYcNGYrFYmDFjMueffyG9e/ergxJWT1C0vMOdnlE6p1A/eKDewlsIIcTJ2Ww2xo27maioKJKSmtOz51X1XaRqk/D2k+PDWwghRHAaPHgYgwcPq+9i1Iosj+onpowM3309/WA9lkQIIUS4k/D2h7w8tIJ83EnJAJgO7K/nAgkhhAhnEt5+YCoZae7q2AkA/aC0vIUQQgSOhLcf6CVd5q7Tz0RZLOjpcs5bCCFE4Eh4+4F3sJrRLAkjqbm0vIUQ4i/cdddYNm36rty2Z56Zz/vvv1vh8ddf3x+Hw1HhFcUcDgfXX9//pO/33ntv43K5+O23HSxd+o9alf3aa6+u1fP9QcLbD3zh3bQZRnIyemYGuFz1XCohhAhe/fsP5OOPP/A9Li4uZsOGr7jyypMHY1razZx55tnVfr9ly5bidrtp27Y9t9xyW7WfH2xkqpgfeLvNjWZJuJOTiTAM9KxMjOTm9VwyIYQITpdf3pPFixdRVFREVFQUX331JRdccCG5uTlMnfoITqeDw4cPcdttd9C9++W+53mvKNahQ0dmzHiU3NxcWrRo6dv/44+bWLr0HxiGQWFhIVOnzuKnn37kyJHDTJv2CEOGjOC9995i+vTH+OSTj1i16nUiIiJo1SqFSZP+zieffFTuSmUjR95Enz4Vt+p//XU7Tz/9BCaTCYvFwqRJj5KQkMCUKQ+Rn59PUVERY8fewQUXXMScOdPZt28vDoeDIUOGc801fWv1+5Pw9gM90xvezTCSPIGtHzwg4S2ECAnR0x4lspLu6ppy9B9I/rRZle6PjIyke/fLWb9+HVdd1ZsPP1zD2LF3sGfPboYPH0nnzuexZcv/WLJkcbnw9nr33bdo3TqVcePuZNu2rfzww/cA7Nr1B1OmzCQx0c5rr/2Tdes+46abxvDKK0uYNm0O27ZtAeDYsaMsWbKYpUtXYLNFs2DBk7z33ltYrbZyVyp78MEJlYb3vHmzeeihR2nbtj1fffUFCxc+xejR4zh27BhPPrmA7Oxs9u7dQ0FBPps3/8Dixa+gaRrffvtNbX+9Et7+UO6cd7I3vOW8txBCnEz//texaNGzdOrUhdzcXNq1O50//vidV19dwgcfvAdouCo5Bbl3759ccklXAM4662zMZk+c2e12nnnmCaxWG1lZmZxzzrkVPv/Agf20bt3Gd9nOc8/tzHfffcOZZ57Naae1A6Bp02Y4nc5Ky3/oUBZt27b3Pf/FFxfSpk0qAwYMYtq0v+Nyubj++uHYbNHcc89EHn98NgUF+Vx1Ve8a/b7KkvD2Az0zAyMuHqKiMJI9c71lxLkQIlTkT5t10lZyoKSmnkZhYT5vvrmSvn2vBeDll1+kf/+BXHxxVz74YA0fffTvCp/bunVrtm7dQrdul/Prr9t9IT9v3mxWrXoXmy2aWbOm+o7XNJ2yl/JITm7B7t27KCwsxGq1snnzD7RqlVJyrFal8icm2tm58zdOO62t7/m//76TgoJ8nnjiWQ4dOsT48aNp3/4Mduz4hccem4/D4WDw4L5cfXUf3xeOmpDw9gM9Ix2j5Mpo7pJuc5O0vIUQ4i/17XstixYt4K23PCF9xRU9WbToWZYvfwW7vSlHjx6t8HkDBgxm1qypjB8/hlNOOZWIiAgArr66N3fccRtWaxQJCU18VyE799yO3H//Pb7LdMbHxzN69DjuuWccmqbTsmUrbr/9Lj7//JMql/3BB//O008/jlIKk8nEQw9NJjHRztKlL7F27WcYhsGYMeNo0qQJR44c5vbbR6PrOsOH31ir4Aa5qljtX8jpxN4yEeel3Tn29r/R9+ymyfkdKBoynNxFL9X+9aupIV8pKNSEY72kTqEjHOsVbnU62VXFZKpYLfkGqzX1tLyNJG+3ubS8hRBCBIaEdy2VjjRP8myIjMRo0kSuLCaEECJgJLxrqewcby8jqTmmAwcgNM5ICCGECDES3rVUOk2smW+bOzkZrSAfLTenvoolhBAijEl411LZOd5eMtdbCCFEIEl419LxA9agbHjLeW8hhBD+J+FdSxV1m/vCW0acCyGECAAJ71rSMzNQUVGoRnG+be6SVdZM0vIWQggRABLetaRnZGA0TYIyy+mVvTiJEEII4W8S3rXhvfRnmS5zoMz65tJtLoQQwv8kvGtBO3wYzeUqN9IcQMUnoKKiZLS5EEKIgJDwrgXfYLWmTcvv0DSMpGTpNhdCCBEQEt61oGeeOMfby53cHD0rE4qL67pYQgghwpyEdy3omZlAxeFtJCejKeWbBy6EEEL4i4R3LVQ0x9tLRpwLIYQIFAnvWvCGt7tpxS1vkCVShRBC+J+Edy2YKriimJe7ZJU108H9dVomIYQQ4U/Cuxb0jHSUrqOaNDlhX2m3ubS8hRBC+JeEdy3oGekY9qZgMp2wz2gu57yFEEIEhoR3TSlVsrraiV3m4OlKV5omq6wJIYTwOwnvGtLyctEKCiocaQ5ARAQq0S4tbyGEEH4n4V1D+kkGq3m5k5tjSj8IStVVsYQQQjQAAQtvwzCYMmUKw4YNIy0tjT179pTb/89//pNBgwYxePBgPv3000AVI2BKl0atpOVNyUIthYVox47WUamEEEI0BOZAvfBnn32G0+nkjTfeYPPmzcydO5cXXngBgJycHF577TU++eQTCgsLGThwIL169QpUUQKiSuFdZsS5Oz6hTsolhBAi/AWs5b1p0ya6desGQMeOHdm6datvn9VqpXnz5hQWFlJYWIhW5lrYoaIq3ealC7XIeW8hhBD+E7CWd15eHjExMb7HJpMJl8uF2ex5y+TkZPr27Yvb7WbcuHGBKkbAnGxpVC/fQi3pB5HLkwghhPCXgIV3TEwM+fn5vseGYfiCe/369WRmZvL5558DMGbMGDp37kyHDh0qfb2EBBtm84nzqWvDbo+t+ZNzjgCQcOZpUNnrnJ4KQGzOYWJr817VVKt6BalwrBOEZ72kTqEjHOsVjnWqSMDCu3Pnzqxbt44+ffqwefNm2rVr59sXFxdHVFQUFosFTdOIjY0lJyfnpK+XnV3g1/LZ7bFkZeXW+Plxe/ZhAbJM0VDJ65is8TQGCnfuJq8W71Udta1XMArHOkF41kvqFDrCsV7hVqeTfREJWHj36tWLDRs2MHz4cJRSzJkzh6VLl5KSkkLPnj3573//y9ChQ9F1nc6dO9O1a9dAFSUg9Mx0jIQEiIys9BjfOe90OecthBDCfwIW3rquM2PGjHLbUlNTfffvuece7rnnnkC9fcDpGeknHawGoBrFoWw2Wd9cCCGEX8kiLTVRVIR+9ChGBZcCLUfTcCcly5XFhBBC+JWEdw3omd5pYpWPNPcymrdAP3QIHI5AF0sIIUQDIeFdA6Xh/Rctb8BIKjnvXTK1TAghhKgtCe8aKF2gpQot72S5rrcQQgj/kvCugdIFWv665e0uGXFukhHnQggh/ETCuwb0zL9e19yrdH1zCW8hhBD+IeFdA1VZ19yrdH1z6TYXQgjhHxLeNVCVdc29fOe8pdtcCCGEn0h414CemYmy2VAxf72GrtG0GUrXpeUthBDCbyS8a0DPSPec767KpUzNZgx7U0xyzlsIIYSfSHhXl9uNnpVZpfPdXkZyMnr6QVAqgAUTQgjRUEh4V5N26BCaYVRppLmXkdQczeFAyz4SwJIJIYRoKCS8q8lUMk3MXYXBal4y4lwIIYQ/SXhXU3UWaPHyjjiXC5QIIYTwBwnvatIzM4HqhbdblkgVQgjhRxLe1eRreVfnnHeyrLImhBDCfyS8q6lW4Z0uLW8hhBC1J+FdTdVZGtWrdMCatLyFEELUnoR3NekZ6SizGdWkSZWfo2JiMWJiMck5byGEEH4g4V1NemYGhr0p6NX71XkWapGWtxBCiNqT8K4OpTzhXY053l5GUnP0I0egqCgABRNCCNGQSHhXg5ZzDK2oqFrnu718571l0JoQQohakvCuBt9gtWqMNPfyLdQi4S2EEKKWJLyroSbTxLzcSTLiXAghhH9IeFdDTZZG9TJklTUhhBB+IuFdDTWZ4+0lc72FEEL4i4R3NeiZ3vCu+TlvGbAmhBCitiS8q6FW3eb2piiTCdMBubKYEEKI2pHwrgZfy9vetPpPNpkwmiVJy1sIIUStSXhXg56RjtG4MVgsNXq+Z5W1g2AYfi6ZEEKIhkTCuxr0jIwadZl7GUnN0YqL0Q4f9mOphBBCNDQS3lVVWIiec6xGc7y93CUjzk2yxrkQQohakPCuotKR5rVreYNMFxNCCFE7Et5VVJs53l6lc71l0JoQQoiak/CuotKlUWsw0rxE6Spr0vIWQghRcxLeVaRn1nyOt5dcWUwIIYQ/SHhXkT+6zd0l57xN0vIWQghRC+ZAvbBhGEybNo0dO3ZgsViYNWsWp5xyim//l19+yaJFi1BKcdZZZzF16lQ0TQtUcWqtdHW1mo82Jzoao1GctLyFEELUSsBa3p999hlOp5M33niDiRMnMnfuXN++vLw8nnjiCV588UXefPNNWrRoQXZ2dqCK4hfe0ebupjVveUPJQi3S8hZCCFELAWt5b9q0iW7dugHQsWNHtm7d6tv3448/0q5dO+bNm8fevXsZMmQIjRs3DlRR/ELPyMCIjoGYmEqP2blT4/BhnYQERVycIj5eERlZ/hgjKRnzju1QUAA2W4BLLYQQIhwFLLzz8vKIKRN0JpMJl8uF2WwmOzubjRs38u6772Kz2Rg5ciQdO3akdevWlb5eQoINs9nk1zLa7bFVPzgrA5KTKn3O8uWQlnbidpsNGjf2/CQkwORdp9IT+OfMHIzUZiQklO4re1yjRqDXsF+kWvUKEeFYJwjPekmdQkc41isc61SRgIV3TEwM+fn5vseGYWA2e94uPj6ec845B7vdDsB5553HL7/8ctLwzs4u8Gv57PZYsrJyq3awy0ViZibFrVM5VsFzvvrKxOjRVuLiIC3NSU6OxtGjGtnZGseOee7v3q3x008aPWlBT+CjJfv5kraVvqWuK+LiID5e0b27iyeecPi/XiEiHOsE4VkvqVPoCMd6hVudTvZFJGDh3blzZ9atW0efPn3YvHkz7dq18+0766yz+PXXXzly5AiNGjXif//7H0OHDg1UUWpNP5SFplSFI81/+UXnllusaBq8+mohl1zirvR1XC7QXmoC0+DZB/5ge5cLyM72hPuJP3D0qMa+fTqvvmrh3nudtGypAldJIYQQISNg4d2rVy82bNjA8OHDUUoxZ84cli5dSkpKCj179mTixInceuutAFxzzTXlwj3YVDbSPD1d44YbrOTkaLzwwsmDG8BsBkuqZ7pYatR+mvc4+fEAS5ZE8PDDUXz+uZmbbiquYQ2EEEKEk4CFt67rzJgxo9y21NRU3/2+ffvSt2/fQL29X/nWNS8z0jwvD264wcr+/TqPPupg8GBXlV6rdKGWqo0479HD87qff26S8BZCCAHIIi1VUrpAi6flXVwMY8ZY2brVxKhRTu6+21nl1ypdqKVqc71bt1a0aWPw1VdmHFU77S2EECLMSXhXQem65s1QCh58MJJ168xceaWLuXMdVGdtGZWYiIqIqNZc7549XeTna2zc6N/R9kIIIUKThHcVlJ7zTuKZZywsX26hQwc3L71UiLm6Jx50HaNZUrVWWevZ09t1HrCzHEIIIUKIhHcVeLvN393Ygscei6RVK4MVKwpPtl7LSRlJyZ4vBIZRpeMvvthNVJRi7VppeQshhJDwrhI9Mx3DHMHtf29BXJziX/8qpFmzmk/bMpKbo7lcaFlZVTreaoVLL3WzY4eJffuCd/13IYQQdUPCuwrc+zPZ705C0zVefbWQ9u2r1mKu9PVKRpybqjjiHKTrXAghRCkJ779w8ABo6ekcUMk8+2zRX87lrgqjZMS5XsUR51B+ypgQQoiGrcrhnZmZCcD333/PihUrKCjw73KlwSgvD24fVkQkThq1a1rludx/xTfXuxojzstOGXNWfWaaEEKIMFSl8J46dSovvPACO3fuZOLEiWzbto0HH3ww0GWrV9653Md2eL60nHpRU7+9ttG8BVD1hVq8ZMqYEEIIqGJ4b9myhSlTpvDRRx9x/fXXM2fOHA4cCN9rUisFkyZ55nL37bQPOHFp1NpwJ5Wc867m71DOewshhIAqhrfb7cYwDD7//HO6d+9OYWEhhYWFgS5bvXn6aQsrVnjmcj9w4x6ACi9KUlNGkrfbvOrnvEGmjAkhhPCoUngPHDiQSy+9lBYtWnDuuecyaNAghg0bFuiy1Ys33jAzd27pXG7rMU+3uT/DG6sVIyGh2t3mVit07epm+3YT+/fLlDEhhGioqtT/essttzBq1ChMJk+L71//+hcJCQkBLVh9WL/exIQJUcTFKV5/3TOXu7IritWWkdQcfd/eaj+vZ08Xn39u5vPPzYwaJRcqEUKIhqhKLe9169bx1FNPkZ+fT+/evbnmmmtYsWJFoMtWp7zX5dZ1eO21Qtq188zl1jNL1zX3JyM5GT03xzOkvRpkypgQQogqhffChQsZNGgQH374IR06dGDt2rW89dZbgS5bnTl4UGPECCu5uRoLFhRx8cWlc7n1jAyUpmHY/TfaHMCdXHJ1sWqscQ7Qpo2idWuD9etlypgQQjRUVZ7nnZqayhdffEGPHj2Ijo6muDg8umy91+U+cMBzXe5Bg8rP5dYz0lFNmkBEhF/ft3TQWvVH7XunjH37rbS+hRCiIapSeCcmJjJz5ky2bNlCt27dmDt3Ls2bNw902QLOO5d72zYTN91U8XW59YwMjKZ+HKxWwkj2rrJWs/AGmTImhBANVZXC+8knn+Scc85h+fLl2Gw2WrVqxZNPPhnosgVU2bncvXq5eOyxCq7LnZ+Pnpfr98FqUGaVtWp2mwNccolMGRNCiIasSk236Oho8vPzmT9/Pi6XiwsvvBCbzRbosgXU7NmwYoWFc891s3hxxdfl1jM9lwL16zSxEu6S9c1NNWh5W62eAF+71sz+/RotWtT8CmdCCCFCT5Va3o8//jgbNmxgwIABDBo0iI0bN/LYY48FumwBs3aticmToVUrg+XLK78ut/c63v4eaQ5lu82r3/KG0q7ztWul61wIIRqaKv3Pv2HDBt5991103ZP1l19+Of379w9owQLJYoFLL4W5c09+XW7fNLEAdJurJk1QFku1F2rx6tnTxd//7pkylpYWHoMHhRBCVE2Vl0d1uVzlHnsXbAlFl17q5quv8M3lroypZIEWdwC6zdE0z0ItNWx5t2mjOPVUmTImhBANUZVa3v3792fUqFH07dsXgA8++IB+/foFtGDBoLTbPADhjWfQmvn7b8HlosKT7n+hZ08XS5ZY+O47E1271v4640IIIUJDlVret99+O+PHj+fAgQPs37+f22+/nfT09ECXrd6VDljzf7c5gDs5Gc3tRs/KrNHzS6eMhW4viBBCiOqr8iItl112GQ8++CAPPfQQl19+OWvWrAlkuYKCb13zAAxYA8/65lCzud5QOmVM5nsLIUTDUuXwPp5S4T89Sc/IwIiJhejogLx+bUec22yeAP/lFxMHDshVxoQQoqGocXhrJ6xoEn70zPSAdZlD2YVaatbyBlltTQghGqKT/o+flpZWYUgrpXA4HAErVFAoLkY/dAhXu9MD9halC7XUrOUNMmVMCCEaopOG9913311X5Qg63kFkddLyruE5b5ApY0II0RCdNLwvuOCCuipH0PGNNA/QNDEoc2WxGqxvXlbZKWMtWvijZEIIIYJZjc95h7tALo3qExmJ0aRJrVreIFPGhBCioZHwroRvmlgAu82BWq2y5nXJJW4iI2XKmBBCNBQS3pUoDe/AdZuDZ6EWPT8PLTenxq9RdsrYvn1+LJwQQoigJOFdCV+3eYDDu7Zzvb28Xecff1zrIgkhhAhyEt6VCOQVxcoqDW//nPf+6KNaF0kIIUSQk/CuhJ6ZgbJYUPEJAX0ff4V3mzaKU04x+OwzKJbp3kIIEdYCFt6GYTBlyhSGDRtGWloae/bsqfCYW2+9lddffz1QxagxPSPDM9I8wCvJuUvmeptqGd6a5ml95+TAd9/JqHMhhAhnAQvvzz77DKfTyRtvvMHEiROZO3fuCcc888wz5OTUfKBWwCiFnpkR8C5zqP3FScqSKWNCCNEwBCy8N23aRLdu3QDo2LEjW7duLbf/448/RtM03zHBRDtyBK24OKALtHiVrm9euwFrAF27uomMlHXOhRAi3AXsf/m8vDxiYmJ8j00mEy6XC7PZzK+//sq///1vFixYwKJFi6r0egkJNsxm/7Yo7fbYinek7wYg8tRWlR/jL4kxEBVFZFaGX97rssvgk09MOJ2xYbXaWsA/h3oSjvWSOoWOcKxXONapIgEL75iYGPLz832PDcPAbPa83bvvvktGRgY33XQT+/fvJyIighYtWtC9e/dKXy87u8Cv5bPbY8nKyq1wX8QvvxMP5DdqTEElx/hT46Rk2LuPI354r969Y/nkE3jzzSJGjgyPkWsn+6xCWTjWS+oUOsKxXuFWp5N9EQlYt3nnzp1Zv349AJs3b6Zdu3a+fZMmTeLNN99k2bJlXHfdddx8880nDe665lvXPMBzvL3cyc09F0LxwzDx3r09t3LeWwghwlfAWt69evViw4YNDB8+HKUUc+bMYenSpaSkpNCzZ89Ava1flK5r3rRO3s9ITkbzDpJr0bJWr9WuHaSkGHz5pZniYoiI8FMhhRBCBI2Ahbeu68yYMaPcttTU1BOOC8bLjpYu0FI3Le+yI85rG97eKWNLl1r4/nsTF1/s9kcRhRBCBBFZpKUCdbU0qlfpdb1rP+IcZMqYEEKEOwnvCugZ6ShNw0i018n7uUtWWTOl136uN3injMlVxoQQIlxJeFdAz0hHJdrBXDfhV9pt7p+Wd3Q0XHyxm23bTKSnB3aFOCGEEHVPwrsCemYm7jrqMgcwmvtvlTUvb9f52rXSdS6EEOFGwvt4eXno+XmoOhppDp5z60rT/LLKmlfpeW/pOhdCiHAj4X0cU8lI87pseRMRgUq0+7XlnZqqyk0ZE0IIET4kvI9T1yPNvdzJzT1XFlPKL69XepUxje+/l65zIYQIJxLex9EzvHO8A39FsbKM5GS0wkK0Y0f99poyZUwIIcKThPdxfOFdB1cUK8vfI87BM2XMYpEpY0IIEW4kvI+jZ2YCdd9tXrpQi//Oe8uUMSGECE8S3scpbXnX3WhzKLtQi/9a3iBTxoQQIhxJeB+n9Jx3XXeb+7/lDdCzp2dtc+k6F0KI8CHhfRw9MwOjURxYrXX6vkay/895A5x2muGbMuZy+fWlhRBC1BMJ7+PoGel1PtIcypzz9tP65l6aBj16yJQxIYQIJxLeZTmd6EeO1HmXOYBqFIey2fze8gaZMiaEEOFGwrsMPatkpHnTum95o2m4k5I9C7X42aWXypQxIYQIJxLeZZSONK+H8AaM5i3QD2WB0+nX142OhosucrN1q4mMDJkyJoQQoU7Cu4z6WhrVyzfivORLhD/JlDEhhAgfEt5l1NfSqF6BGnEOMmVMCCHCiYR3GfU1x9vLXTLi3HRwv99fu21bg1atZMqYEEKEAwnvMvTM+u4297a8/T9ozTtl7NgxmTImhBChTsK7jNLwrq9uc+8qa/7vNge48ko57y2EEOFAwrsMPSMdFRmJahRXL+/vO+ft54VavGTKmBBChAcJ7zL0jAxPl7lWP9OpjKbNULoesJa3d8rYli0yZUwIIUKZhLeXYaBnZdbbHG8AzGYMe9OALNTi5Z0ytm6ddJ0LIUSokvAuoR0+jOZy1dtgNS8jORk9/SAoFZDXlyljQggR+iS8S9T3HG8vI6k5msOBln0kIK/vnTL2xRcyZUwIIUKVhHeJ+p4m5hXoEedlp4y9/760voUQIhRJeJfwhXd9nvOmdMS5KUAjzgFGjSrGZlPceWeUBLgQQoQgCe8SwdJt7g7gEqle55xjsHJlIVFRcNttUaxeLQEuhBChRMK7RH0vjepVur554Fre4Jky9uabBcTGwp13RrFiRURA308IIYT/SHiXMJVcUczdNEjCOz1wLW+vLl0M3n67gIQExYQJUSxZIgEuhBChQMK7hJ6RjtJ1VGJivZajdMBaYFveXuecY/DOO4XY7QYPPxzFokUS4EIIEewkvEvomRkYiXYw1e/iJSomFiMmFtOBuglvgDPOMFizpoDkZIPp06N46ilLnb23EEKI6pPwBlDKE971fL7by7NQS92FN0BqquK99wpISTGYOzeSOXMsgVonRgghRC1JeANaXi5aQUG9jzT3MpKaox85AkVFdfq+p57qCfDWrQ2eeSaSKVMiJcCFECIIBSy8DcNgypQpDBs2jLS0NPbs2VNu/yuvvMKQIUMYMmQICxcuDFQxqkTPCI4FWrx8573rYNDa8Vq0UKxZU0D79m4WL7YwaVIkhlHnxRBCCHESAQvvzz77DKfTyRtvvMHEiROZO3eub9/evXtZs2YNK1euZNWqVfzf//0f27dvD1RR/lKwzPH2Kl2ope7DG6BZM8U77xRy1lluXn3Vwt/+FoXbXS9FEUIIUYGAhfemTZvo1q0bAB07dmTr1q2+fUlJSbz88suYTCY0TcPlchEZGRmoovwlX3jX8zQxL3dS3Y44r0hiouLttwvo1MnNypUR3HlnFMXF9VYcIYQQZQQsvPPy8oiJifE9NplMuEquhBEREUHjxo1RSjFv3jzOPPNMWrduHaii/KVgWRrVy6iDVdaqIiEB3nyzgPPPd/P22xHcdlsUTme9FkkIIQQQsHUxY2JiyM/P9z02DAOzufTtHA4HjzzyCNHR0UydOvUvXy8hwYbZ7N9pXHZ7rOdObjYAcae3Ae+2+nTmaQDEHDtETA3KY/djHex2WLsWrr0WPvwwgrFjI3jrLYiK8ttbVLEcQfC5BEA41kvqFDrCsV7hWKeKBCy8O3fuzLp16+jTpw+bN2+mXbt2vn1KKe644w4uvPBCxo4dW6XXy84u8Gv57PZYsrJyAYjd9SdRwGFLLEbJtvqkR8XRBCj6Yw+51SxP2Xr50yuvwC23WPnwQzNXXeXitdcKiY72+9tUKFB1qm/hWC+pU+gIx3qFW51O9kUkYOHdq1cvNmzYwPDhw1FKMWfOHJYuXUpKSgqGYfDtt9/idDr56quvALjvvvvo1KlToIpzUr7R5sHSbW5vijKZMNXjOe/jWa3w6quF3HZbFB9/HMGIEVZWrCgktmF8yRVCiKASsPDWdZ0ZM2aU25aamuq7v2XLlkC9dbXpmekY8fF13xdcGZMJo1lSvUwVO5nISFiypIg77oD33otg6FAbr79eQHx8fZdMCCEaFlmkBc9o82CZ4+3lWWXtIMG2SkpEBLz4YhFDhxazaZOJQYNsHD6s1XexhBCiQZHwdjjQjx4Nmi5zLyOpOZrTiXb4cH0X5QQmEyxYUERampOtW01cd52VjAwJcCGEqCsNPryDbZqYl7uOry5WXboO8+c7uO02J9u3mxg40MaBAxLgQghRFyS8faurBVm3eVLJKmsH99dzSSqnaTBrloO773bw++86115rY88eCXAhhAg0Ce8gW9fcq/S63sE1aO14mgaPPupk0iQHf/6p06ePjR9/bPB/VkIIEVAN/n/ZYFvX3Kt0lbXg7DYvS9Pg/vudzJlTxOHDGgMH2nj//YBNZBBCiAZPwjszSLvN6/HKYjV1663FLFtWiK7DmDFWnntOrgkuhBCBIOGdmQkE4YA13znv4G95l9Wrl5v33y+geXODmTMjue++SLmgiRBC+JmEd5B2mxMdjdEoLqRa3l5nn23w8ccFdOjgZsUKC8OHWzl6tL5LJYQQ4UPCOyMDZbWiYhvVd1FOYCQnh8Q574okJSnee6+Aa64p5quvzPTpY2PXLhmJLoQQ/iDhnZHu6TLXgi9YjKRk9KNHobCwvotSI9HRsHRpEXfc4WTnThN9+tjYuNG/V4YTQoiGqGGHt9uNnpUZdIPVvNzNWwChMeK8MiYTTJvmYP78Io4e1Rg82Mpbb8lIdCGEqI0GHd7aoUNohhG04e0dcW4KwfPexxs1qpjXXy8kMhLGj7cyf76MRBdCiJpq0OFdujRq03ouScW8q6yFcsu7rMsvd/PhhwWkpBg8/ngkd94ZhcNR36USQojQ06DD2xSkc7y9ShdqCf2Wt1f79gYffVRAly5uVq+O4PrrrXJVMiGEqKYGHd7epVHdQRve3oVawqPl7WW3K95+u4CBA4vZuNFM7942du6UABdCiKpq4OEdpHO8S/gWajkQXuENYLV6rgt+330Odu/W6d07mv/7PxmJLoQQVSHhDRhNg7PlrRITURERYXPO+3i6Dg895GTBgkIKCmDoUCuvvy4j0YUQ4q806P8pg/WKYj66jtEsCX3fXnA6wWKp7xIFxPDhLlJSCrn5Ziv33mvl998dPPKIE93PXy2PHYPfftP57TedjAyda65xcfrphn/fRAgh6kDDDu/MDJTJhGrSpL6LUilXpy5Evv8u8X17kfv8P3C3bVffRQqISy5x89FH+YwcaWPBgkh27dJZuLAIq7V6r6MUpKdr/Pqrzs6dOr/+6gnrX3/Vycws/21gzpxIrr7axV13ObnwQrcfayOEEIHVsMM7IwPD3hS/N/H8KPeZhRgxMVhfX07Cld3ImzabopvHBOWKcLWVmqr48MN8brnFyvvvR7B/v85rrxVit594rMsFu3dr/PabyRfOO3d6gjo398TfTUqKQY8eLtq2NWjXzsBmUyxZYuE//zHzn/+YueACF/fc4+TKK93B/OcghBAAaEqFxlIZWVm5fn09e2IMymbD1f4Mjn76pV9fOxAs779L7P33omdn4+h1NblPL0JVMD/dbo/1+++qrjkcMHFiFKtWRdCqlcHixTq7dxf6urx/+03njz90iovLh3REhCI11aBt29Kfdu0MUlMNbLYT30cp2LjRxHPPWfj0U8/32NNPd3PnnU4GDXIRERHYeobDZ3U8qVPoCMd6hVud7PbYSvc13PCOcENCAo6rriFn+Sq/vnag6AcPEHvPeCxfrsNITCT36UU4r+5d7phw+eNVCp55xsJjj0WesC8mRtGuXdmAdtO2rcEppyjMNexL+vlnnYULLbzzjhm3W6NlS4Pbb3cycmQx0dG1rEwlwuWzKkvqFDrCsV7hVicJ7wrYD+2DM8+kMO1m8p5c4NfXDijDwPryi0TPnIrmcFA4ajR502fjTZhw++P99FMT335rIympyNeSbtZMBeyswd69Gi++aGH58ggKCzUSEhSjRzu59dZimjTx7z+VcPusQOoUSsKxXuFWp5OFd8M9u1eyapnRNDjneFdK1ykcewfZn3yJ68yzsb72TxJ6Xor5x031XbKA6NXLzTPPwJgxxXTv7iYpKXDBDdCqlWL2bAc//JDP/fd71m598slIOneO5pFHItm7N/zGGgghQk/DDe907xzvEAvvEu4zziT7P+souOMeTLv+IL7PldieetwzkkvUWpMmikmTnPzwQx6zZhXRuLHi5ZctXHBBNHfcEcXPPzfcfzpCiPrXcP8H8ra8g3WOd1VERpI/bRbHVq/BaJZE9NxZcNll6Lt31XfJwkZ0NIwdW8y33+bz3HOFtG1rsHp1BJdfHs3IkVa++cYkV0cTQtQ5Ce8gXRq1Ooq7XUb2F/+laOAg+O9/SbiiK5ErVyCp4j8RETBsmIsvvihg+fICLrzQxaefmrn2Wht9+9r4+GMThqz3IoSoIw13nnc4tLzLUPEJ5C5eStT1g2D8HTS6ZzyOTz4md/4zqMbBuwhNqNF1uOoqN1ddVcjGjSYWLvTMFR81ykb79m569HATHa2IjlbYbJTcp+Rx6X3Pref7VRhO2RdCBJiEd4ie866QpsHIkWSf0ZHYO8cS+e/3MH+3kdwFL1B8Rc/6Ll3YufBCNxdeWMj27Z5pZm+/bWbHjupdXEXTYsqFvCfgy96HhATFaacZtG/vmRbXuHGAKiSECBkNOryNxo3Dcr1wo1UKx975AOuiZ4meO4v4YddRMHY8+X+fRrXXGxV/6fTTDRYuLGLqVI19+zTy8zXy8yE/X6OgoPR+fj4ljz33Xa4IsrPdJY81Cgrg0CGd/HwwjMqb44mJ3iD3/Hjv2+2BHYlf1xwOyMjQcDg02rQxMMlF54TwabjhnZ6OkZRc36UIHJOJwnvuo/jyHsSOvxXbSy9gWf8FOc+/jPvsc+q7dGHJblfY7VUfZ2C3R5CVVXjCdqWgqAhf8Gdlafz2m86OHSZ+/VVnxw6dDRvMbNhQ/nkJCYp27dy+UPcGe3JycIV6QYEnlDMy9JJbzfc4PV0jM9NzPzu7tNA2m+Lcc9106mTQpYubTp3ctGgRXPUSoi41zPAuLISjRzE6dKrvkgScq0NHsj9dT8yMyVj/+Q8SrrmC/IenUDj+rqBe070h0zRPB4nVqmjSBFJSFF26GEDpNMD8fPj9d0+Qe4Jd59dfTXz3nYmNG8v/s46JUWVa6m7at698ydjaOnIEfvnF5Avk9HRPQHsC2fO4orXny4qLUzRrZnD22YpmzRQmE/z0k84335j4+uvSutntBp07G3Tu7AnzTp3cxMX5v05CBKMGGd56pvdSoGF0vvtkbDby5j6J88qriL33TmKmP4rlPx9S3ONK3C1b4W6ZgtGqlacnQvomQ0J0NHToYNChQ/kh7g6HJ9S9LXTvRVt++kln0yYTEOAF2wGo+FtBkyYGLVt6Vshr1kyRlFR6v2lTz+OmTVWlZ3by8uCnn0xs2mTixx91fvzR5LuwjFdqqifMvYF+1lkGkSeusCtEyGuY4R3s1/EOEOeVV3Pky2+Ive9uIj/+AMs3/y23X5nNGM1b4G7ZCqNlK89tq5SS21a4W7RC/icMbpGRcOaZBmeeWT7Ui4th925vC13n99/1Kq/nU9UZh0pBYmIEcXGOkjD2tKC94Vzb4SUxMZ5Lx15ySenlWzMyNH74wRPmnlsTb74ZwZtver6kWCyKs882fC3zLl3ctG6twrrTqbi49LRLUREUFWkUFpbeFhZqOByQnAxms06TJoomTRSxsTLzIZQ00PAuWV2tobS8y1CJieS8+i9MO3/DtGcX+t69mPbtRd/3J6a9e9H37SXi6w1olfyP7W7azBPkLVPKBHxp613FNqrjGomqiIjAdyGXQPKcx3cG9D3KatZM0bu3i94l1+cxDE/Pww8/eFrmP/xgYssWT7B7xcUpOnRwEx9f+beSsiEWGQkOR1SF+yp7rvfn+Mcn/qi/PF4pcDi8AewJX28YH/+4sBDc7uokcOlVdyIiFI0bK1+Yl/1p3FiRmFh+f+PGNb8QkKi9gP3qDcNg2rRp7NixA4vFwqxZszjllFN8+1etWsXKlSsxm82MHz+eK664IlBFOYGe6Q3vhtXy9tE03G3b4W7bruL9Dgf6gf0lob4X094/y903//Q/IjZ9X+FTldWKEZ+Aik/AaNy4/G1CY1RCgmd/48blbmvVone50I4dQzt2FP3YUbRjx3y32tGj6DnHSvZno5ccp+XloSyRYLOhrFaU1Yaylf5gLdlus5Xus9pQNivYoss/p+SWqChputQzXS/9kjJsmKdroagItm3zhLmny93EV19V97++ujjdUHW6roiK8oyLsFohPl4RFeW57721Wj3HHP/YalUl/9yi+PNPJ4cPaxw+rHHkiMahQxp79+r8/HPV/o7j40uDvEkTg9hYz5k3XVclt56fE++fuL/0sSq3TdNKb73H67o67rHnJz4ecnPN5Y7z3q/oeM97eMpiNpduM5tVmfulZTObla9cZX+8r1+XAhben332GU6nkzfeeIPNmzczd+5cXnjhBQCysrJYtmwZb731Fg6HgxtuuIGuXbtiqaNpW5qzGAD3KafWyfuFnMhIjNZtMFq3qXi/242emVHSav+zJNQ9rXf98CH0I9no+/dh/mVbld9S2aIxEhIqDHviY4g+mFkavMeOoR89ipZTEs75edWqnrJYUDEx4CxGK8hH89PSaErTIDLS86XAYkFFRqIsFs/9Mtt8tzE2YpVesi0SFWnx3FoiSm4jIdKCMkd4mpQoT1kNw9McM1TpfeW5Lb/f8D0Po2SfKn2OiopEWT1fOpT3y0qUFWzWco+9X1Sweo4L+IXO/SwqCrp0MejSxeDWWz3/9vPyPC3Vihzf6ZSYGMOhQ3kV7qvsuUpV/af88VqF+6OiPIv+REV5AthiqX1Y2O1RZGU5KtzncMCRI5ov2MuGe9nt3m27dukYRrCMl6mf6bAmk+Kssww++aSgTk7LBCy8N23aRLdu3QDo2LEjW7du9e376aef6NSpExaLBYvFQkpKCtu3b6dDhw6BKk45hTeNJubSC3Gd3blO3i/smEwYyc0xkpvjuuDCyo9zuTzhejQb7cgR9KNHSm6z0Y5mox85UnJb8jj7CPqe3Zi3bTnhpY4fAmU0ikPFx+Nu3QZXfDyqURxGya2Kj8eIi0PFxaPi4jAaxaPiS+7HxZdvISsFTidaYQFaYSFaQT4UFKIVFHi2eW+9+0putYJC3zbfbUEBOB1oDqfn1un0PP9otueLgtOBVlxcrh5RhB5lNntC3tv7YI0qDfgoC3FOl+8LQrkvDKgTvnhoFe4rvdVKEkz5mkDmkvveZo+5zD5T6X3dc6tMOphK9pU8H5NOjMmEKttc0jSg4v5rW3QkMYXF5bYp3zEVPLekKaZMJtC8TU3PdqXrnrKVaY6q45qn5Z+ne55bnaSu6rHx0ViOFVS4ywLEAt6+UhWvQTxQyfd5ZXhmQBQVabgNDYXm+e6IjmF47ivAXXLfUBqG0lEK3Eorc4yGoTTcbjCU7jmu5Piyfxplf8p+X42KiiS/wIlR8n229E9JQ1G6zVcGA897lby/2yh575LtbkP3He95XPY54HJrnj9lt+d0RWz7Fmha3Zw6DFh45+XlERMT43tsMplwuVyYzWby8vKIjS29Tml0dDR5edVrPdWKzQY9ekAYXfc1KJnNqMRE3ImJ1XtecTFadrYv9BOizWSrCIySMFaxjfw3Kt7bWo6MRMUn+Oc1T8YwPF8WnA4SG0Vy+MBhcJQEvdPhuV9cXLLNAQ4nmtvlCQxd9/ynXrb/T6M0ANBO7B8sua98z9N8UwQ1h8PzZaSw0PMFpagIrbCgzDbPdkq2e76kFKIVFZYc43mOnpXpOx48//FDSU+EdlyZTihPmXJ5H6OVBqu3rG635/fgdoPLjWa4PVfQc7vR3O4Tfs3+FoBZdUHBnzPr6uBfT9Az9sdz2NhVJ7N2AhbeMTEx5Ofn+x4bhoG5ZHTD8fvy8/PLhXlFEhJsmM3+/YWc7ELnoSws6tW8/Bqg4fofQxO7vb6L4D/eZk5J8J6s/efX04Pe5pfL5Qv0k956fyrr467KtsqOKdtM8+dtdX4X/jyuJsce//vxx31/l7Wi447fVt3HgH7mmdiT4qtWhloKWHh37tyZdevW0adPHzZv3ky7dqWDozp06MAzzzyDw+HA6XTy+++/l9tfkezsirt3aspujyUrDFve4VivcKwThGe9gqNOGp4BZhGe/+HMQC3GQwZHnfwvHOsVFHXy4/ufrCEWsPDu1asXGzZsYPjw4SilmDNnDkuXLiUlJYWePXuSlpbGDTfcgFKKCRMmECnzh4UQQogq0ZQKjYs++/vbVFB8QwuAcKxXONYJwrNeUqfQEY71Crc6nazlHcbrDAkhhBDhScJbCCGECDES3kIIIUSIkfAWQgghQoyEtxBCCBFiJLyFEEKIECPhLYQQQoSYkJnnLYQQQggPaXkLIYQQIUbCWwghhAgxEt5CCCFEiJHwFkIIIUKMhLcQQggRYiS8hRBCiBATsOt5BwvDMJg2bRo7duzAYrEwa9YsTjnlFN/+VatWsXLlSsxmM+PHj+eKK66ox9JWTXFxMY888gj79+/H6XQyfvx4evbs6dv/yiuv8Oabb9K4cWMApk+fTps2beqruNVy3XXXERMTA0DLli157LHHfPtC8bN6++23eeeddwBwOBz88ssvbNiwgUaNGgEwa9YsfvjhB6KjowF4/vnniY2t/DKA9e1///sf8+fPZ9myZezZs4eHHnoITdNo27YtU6dORddL2wNFRUU88MADHD58mOjoaObNm+f7mww2Zev1yy+/MHPmTEwmExaLhXnz5pGYmFju+JP9nQaLsnX6+eefGTduHKeeeioAI0aMoE+fPr5jQ/WzmjBhAocOHQJg//79nHvuuTz99NO+Y5VSdO/e3Vfvjh07MnHixPootv+pMPef//xHPfjgg0oppX788Ud1++23+/ZlZmaqfv36KYfDoXJycnz3g93q1avVrFmzlFJKZWdnq8suu6zc/okTJ6otW7bUQ8lqp6ioSA0YMKDCfaH6WZU1bdo0tXLlynLbhg8frg4fPlxPJaqel156SfXr108NGTJEKaXUuHHj1DfffKOUUmry5Mnqk08+KXf8P//5T7VgwQKllFL//ve/1cyZM+u2wFV0fL1Gjhypfv75Z6WUUq+//rqaM2dOueNP9ncaLI6v06pVq9SSJUsqPT5UPyuvo0ePqmuvvVZlZGSU27579241bty4uixinQn7bvNNmzbRrVs3wPOta+vWrb59P/30E506dcJisRAbG0tKSgrbt2+vr6JW2TXXXMO9994LeL5Zmkymcvu3bdvGSy+9xIgRI1i8eHF9FLFGtm/fTmFhIaNHj2bUqFFs3rzZty9UPyuvLVu2sHPnToYNG+bbZhgGe/bsYcqUKQwfPpzVq1fXYwn/WkpKCs8995zv8bZt27jgggsA6N69O//973/LHV/231737t35+uuv666w1XB8vZ566inOOOMMANxuN5GRkeWOP9nfabA4vk5bt27liy++YOTIkTzyyCPk5eWVOz5UPyuv5557jhtvvJGmTZuW275t2zYyMjJIS0vjtttu448//qirogZc2Id3Xl6er3sLwGQy4XK5fPvKdlFGR0ef8EcdjKKjo4mJiSEvL4977rmHv/3tb+X29+3bl2nTpvHqq6+yadMm1q1bVz8FraaoqCjGjBnDkiVLmD59Ovfff3/If1Zeixcv5s477yy3raCggBtvvJEnnniCl19+mX/9619B/YXk6quvxmwuPdOmlELTNMDzeeTm5pY7vuxnVtH+YHF8vbwB8MMPP7B8+XJuvvnmcsef7O80WBxfpw4dOjBp0iRWrFhBq1atWLRoUbnjQ/WzAjh8+DBff/01gwYNOuF4u93O2LFjWbZsGePGjeOBBx6oq6IGXNiHd0xMDPn5+b7HhmH4Pvzj9+Xn5wf1+cayDh48yKhRoxgwYAD9+/f3bVdKcdNNN9G4cWMsFguXXXYZP//8cz2WtOpat27Ntddei6ZptG7dmvj4eLKysoDQ/qxycnLYtWsXF110UbntVquVUaNGYbVaiYmJ4aKLLgrq8D5e2fPb+fn5vvP4XmU/s4r2B7MPP/yQqVOn8tJLL51w7vdkf6fBqlevXpx99tm++8f/nxDKn9XHH39Mv379TuiBBDj77LN944HOO+88MjMzUWGyInjYh3fnzp1Zv349AJs3b6Zdu3a+fR06dGDTpk04HA5yc3P5/fffy+0PVocOHWL06NE88MADXH/99eX25eXl0a9fP/Lz81FKsXHjRt8/2mC3evVq5s6dC0BGRgZ5eXnY7XYgdD8rgO+++46LL774hO27d+9mxIgRuN1uiouL+eGHHzjrrLPqoYQ1c+aZZ7Jx40YA1q9fz3nnnVduf+fOnfnyyy99+7t06VLnZayJ9957j+XLl7Ns2TJatWp1wv6T/Z0GqzFjxvDTTz8B8PXXX5/wdxaqnxV46tO9e/cK9y1cuJBXX30V8JzuSE5O9vUWhbqwH23eq1cvNmzYwPDhw1FKMWfOHJYuXUpKSgo9e/YkLS2NG264AaUUEyZMOOH8VjB68cUXycnJ4fnnn+f5558HYMiQIRQWFjJs2DAmTJjAqFGjsFgsXHzxxVx22WX1XOKquf7663n44YcZMWIEmqYxZ84cli1bFtKfFcCuXbto2bKl73HZv78BAwYwdOhQIiIiGDBgAG3btq3HklbPgw8+yOTJk3nqqado06YNV199NQCjR4/mxRdfZMSIETz44IOMGDGCiIgInnzyyXou8V9zu93Mnj2b5ORk7r77bgDOP/987rnnHiZNmsTf/va3Cv9Oj+/KDTbTpk1j5syZREREkJiYyMyZM4HQ/qy8du3adcKXLG+9xo4dywMPPMCXX36JyWQKylkBNSVXFRNCCCFCTNh3mwshhBDhRsJbCCGECDES3kIIIUSIkfAWQgghQoyEtxBCCBFignt+gxDCb/bt28c111xDampque1Dhw5l5MiRtX79jRs3snDhQpYtW1br1xJCnJyEtxANSNOmTXnvvffquxhCiFqS8BZCcNFFF3HFFVewdetWoqOjmT9/Pi1btmTz5s3Mnj0bh8NBQkICM2bM4JRTTuGXX35hypQpFBUVERcXx/z58wE4cuQIt912G3/++SetW7dmwYIFWCyWeq6dEOFHznkL0YBkZmYyYMCAcj87duwgOzubCy64gPfff5++ffsya9YsnE4n9913H5MnT2bNmjUMHz6c++67D4D777+fO+64g/fff58+ffr4lqA8cOAAU6ZM4aOPPuLQoUMnXGlMCOEf0vIWogGprNs8MjKSgQMHAnDdddfx1FNPsXv3bho1akSHDh0A6N27N1OmTGH//v1kZWVxxRVXAHDDDTcAnnPep59+um+pytTUVLKzs+ugVkI0PBLeQgh0XfddsMEwDEwmE4ZhnHBcRaspOxwOMjMzAcqt8a1pWthcwUmIYCPd5kIICgsLWbt2LQBvv/023bt3p02bNhw9etR3NaoPP/yQ5s2b06JFC5KSktiwYQPguQrXs88+W29lF6Ihkpa3EA2I95x3Weeffz7guS7y008/TdOmTZk3bx4Wi4Wnn36amTNnUlhYSFxcHE8//TQATzzxBNOmTePxxx8nISGBxx9/nF27dtV5fYRoqOSqYkII2rdvz44dO+q7GEKIKpJucyGEECLESMtbCCGECDHS8hZCCCFCjIS3EEIIEWIkvIUQQogQI+EthBBChBgJbyGEECLESHgLIYQQIeb/AWuKdjU2vdGjAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 576x324 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = training_loop(model=model, \n",
    "    criterion=criterion, \n",
    "    optimizer=optimizer, \n",
    "    train_loader=train_dataloader, \n",
    "    valid_loader=val_dataloader, \n",
    "    test_dataloader=test_dataloader,\n",
    "    epoches=20, \n",
    "    device=device, \n",
    "    print_every=1\n",
    ")\n",
    "\n",
    "torch.save(model.state_dict(), \"cabos_fonte_classificador.pth\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.9.5"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "41f14c764d27c962d5d4530fd3a129dfbfc6c63683c24b6097e69cef7d6a7dc1"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}