DroneDetector/train_scripts/Training_models_1.2-Copy1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5a13ad6b-56c9-4381-b376-1765f6dd7553",
   "metadata": {
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "# Импортирование библиотек"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7311cb4a-5bf3-4268-b431-43eea10e9ed6",
   "metadata": {
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1336"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from torch import default_generator, randperm\n",
    "from torch.utils.data.dataset import Subset\n",
    "import torchvision.transforms as transforms\n",
    "from torchvision.io import read_image\n",
    "from importlib import import_module\n",
    "import matplotlib.pyplot as plt\n",
    "from torchvision import models\n",
    "import torch, torchvision\n",
    "from pathlib import Path\n",
    "from PIL import Image\n",
    "import torch.nn as nn\n",
    "from tqdm import tqdm\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "import os, shutil\n",
    "import mlconfig\n",
    "import random\n",
    "import shutil\n",
    "import timeit\n",
    "import copy\n",
    "import time\n",
    "import cv2\n",
    "import csv\n",
    "import sys\n",
    "import io\n",
    "import gc\n",
    "\n",
    "plt.rcParams[\"savefig.bbox\"] = 'tight'\n",
    "torch.manual_seed(1)\n",
    "#matplotlib.use('Agg')\n",
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "print(device)\n",
    "torch.cuda.empty_cache()\n",
    "cv2.destroyAllWindows()\n",
    "gc.collect()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "384de097-82c6-41f5-bda9-b2f54bc99593",
   "metadata": {
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "# Подготовка и обучение детектирование"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "46e4dc99-6994-4fee-a32e-f3983bd991bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_and_learning_detection(num_classes, num_samples, path_dataset, model_name, config_name, model):\n",
    "    num_samples_per_class = num_samples // num_classes\n",
    "\n",
    "    #----------Создаём папку для сохранения результатов обучения--------------\n",
    "    \n",
    "    ind = 1\n",
    "    while True:\n",
    "        if os.path.exists(\"models/\" + model_name + str(ind)):\n",
    "            ind += 1\n",
    "        else:\n",
    "            os.mkdir(\"models/\" + model_name + str(ind))\n",
    "            path_res = \"models/\" + model_name + str(ind) + '/'\n",
    "            break\n",
    "    \n",
    "    #----------Создаём файл dataset.csv для обучения--------------\n",
    "    \n",
    "    pd_columns = ['file_name']\n",
    "    df = pd.DataFrame(columns=pd_columns)\n",
    "    \n",
    "    subdirs = os.listdir(path_dataset)\n",
    "    for subdir in subdirs:\n",
    "        files = os.listdir(path_dataset + subdir + '/')\n",
    "        num_samples_per_class = min(num_samples_per_class, len(files))\n",
    "    for subdir in subdirs:\n",
    "        files = os.listdir(path_dataset + subdir + '/')\n",
    "        random.shuffle(files)\n",
    "        files_to_process = files[:num_samples_per_class]\n",
    "        for file in files_to_process:\n",
    "            row = pd.DataFrame({pd_columns[0]: [str(path_dataset + subdir + '/' + file)]})\n",
    "            df = pd.concat([df, row], ignore_index=True)\n",
    "    \n",
    "    df.to_csv(path_res + 'dataset.csv', index=False)\n",
    "    \n",
    "    #----------Импортируем параметры для обучения--------------\n",
    "    \n",
    "    def load_function(attr):\n",
    "        module_, func = attr.rsplit('.', maxsplit=1)\n",
    "        return getattr(import_module(module_), func)\n",
    "    \n",
    "    config = mlconfig.load('config_' + config_name + '.yaml')\n",
    "    \n",
    "    #----------Создаём класс датасета--------------\n",
    "    \n",
    "    class MyDataset(Dataset):\n",
    "        def __init__(self, path_dataset, csv_file):\n",
    "            data=[]\n",
    "            with open(path_dataset + csv_file, newline='') as csvfile:\n",
    "                reader = csv.reader(csvfile, delimiter=' ', quotechar='|')\n",
    "                for row in list(reader)[1:]:\n",
    "                    row = str(row)\n",
    "                    data.append(row[2: len(row)-2])\n",
    "            self.sig_filenames = data\n",
    "            self.path_dataset = path_dataset\n",
    "    \n",
    "        def __len__(self):\n",
    "            return len(self.sig_filenames)\n",
    "    \n",
    "        def __getitem__(self, idx):\n",
    "            image_real = np.asarray(cv2.split(cv2.imread(self.sig_filenames[idx][:-8]+'real.jpg')), dtype=np.float32)\n",
    "            if 'drone' in list(self.sig_filenames[idx].split('/')):\n",
    "                label = torch.tensor(0)\n",
    "            if 'noise' in list(self.sig_filenames[idx].split('/')):\n",
    "                label = torch.tensor(1)\n",
    "            return image_real, label\n",
    "    \n",
    "    #----------Создаём датасет--------------\n",
    "    \n",
    "    dataset = MyDataset(path_dataset=path_res, csv_file='dataset.csv')\n",
    "    train_set, valid_set = torch.utils.data.random_split(dataset, [0.7, 0.3], generator=torch.Generator().manual_seed(42))\n",
    "    batch_size = config.batch_size\n",
    "    train_dataloader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, shuffle=True, drop_last=True)\n",
    "    valid_dataloader = torch.utils.data.DataLoader(valid_set, batch_size=batch_size, shuffle=True, drop_last=True)\n",
    "    \n",
    "    dataloaders = {}\n",
    "    dataloaders['train'] = train_dataloader\n",
    "    dataloaders['val'] = valid_dataloader\n",
    "    dataset_sizes = {}\n",
    "    dataset_sizes['train'] = len(train_set)\n",
    "    dataset_sizes['val'] = len(valid_set)\n",
    "\n",
    "    #----------Обучаем модель--------------\n",
    "\n",
    "    val_loss = []\n",
    "    val_acc = []\n",
    "    train_loss = []\n",
    "    train_acc = []\n",
    "    epochs = config.epoch\n",
    "    \n",
    "    best_acc = 0.0\n",
    "    best_model = copy.deepcopy(model.state_dict())\n",
    "    limit = config.limit\n",
    "    epoch_limit = epochs\n",
    "    \n",
    "    start = timeit.default_timer()\n",
    "    for epoch in range(1, epochs+1):\n",
    "        print(f\"Epoch : {epoch}\\n\")\n",
    "        dataloader = None\n",
    "    \n",
    "        for phase in ['train', 'val']:\n",
    "            running_loss = 0.0\n",
    "            running_corrects = 0\n",
    "    \n",
    "            for (img, label) in tqdm(dataloaders[phase]):\n",
    "                img, label = img.to(device), label.to(device)\n",
    "                optimizer.zero_grad()\n",
    "    \n",
    "                with torch.set_grad_enabled(phase == 'train'):\n",
    "                    output = model(img)\n",
    "                    _, pred = torch.max(output.data, 1)\n",
    "                    loss = criterion(output, label)\n",
    "                    if phase=='train' :\n",
    "                        loss.backward()\n",
    "                        optimizer.step()\n",
    "                \n",
    "                running_loss += loss.item() * img.size(0)\n",
    "                running_corrects += torch.sum(pred == label.data)\n",
    "    \n",
    "            epoch_loss = running_loss / dataset_sizes[phase]\n",
    "            epoch_acc = running_corrects.double() / dataset_sizes[phase]\n",
    "                \n",
    "            print('{} Loss: {:.4f} Acc: {:.4f}'.format(phase, epoch_loss, epoch_acc))\n",
    "                    \n",
    "            if phase=='train' :\n",
    "                train_loss.append(epoch_loss)\n",
    "                train_acc.append(epoch_acc)\n",
    "            else :\n",
    "                val_loss.append(epoch_loss)\n",
    "                val_acc.append(epoch_acc)\n",
    "                if val_acc[-1] > best_acc :\n",
    "                    ind_limit = 0\n",
    "                    best_acc = val_acc[-1]\n",
    "                    best_model = copy.deepcopy(model.state_dict())\n",
    "                    torch.save(best_model, path_res + model_name + '.pth')\n",
    "                else:\n",
    "                    ind_limit += 1\n",
    "                    \n",
    "                if ind_limit >= limit:\n",
    "                    break\n",
    "                \n",
    "        if ind_limit >= limit:\n",
    "            epoch_limit = epoch\n",
    "            break\n",
    "            \n",
    "        print()\n",
    "    \n",
    "    end = timeit.default_timer()\n",
    "    print(f\"Total time elapsed = {end - start} seconds\")\n",
    "    epoch_limit += 1\n",
    "    \n",
    "    #----------Вывод графиков и сохранение результатов обучения--------------\n",
    "    \n",
    "    train_acc = np.asarray(list(map(lambda x: x.item(), train_acc)))\n",
    "    val_acc = np.asarray(list(map(lambda x: x.item(), val_acc)))\n",
    "    \n",
    "    np.save(path_res+'train_acc.npy', train_acc)\n",
    "    np.save(path_res+'val_acc.npy', val_acc)\n",
    "    np.save(path_res+'train_loss.npy', train_loss)\n",
    "    np.save(path_res+'val_loss.npy', val_loss)\n",
    "    \n",
    "    plt.figure()\n",
    "    plt.plot(range(1,epoch_limit), train_loss, color='blue')\n",
    "    plt.plot(range(1,epoch_limit), val_loss, color='red')\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.ylabel('Loss')\n",
    "    plt.title('Loss Curve')\n",
    "    plt.legend(['Train Loss', 'Validation Loss'])\n",
    "    plt.show()\n",
    "    plt.clf()\n",
    "    plt.cla()\n",
    "    plt.close()\n",
    "    \n",
    "    plt.figure()\n",
    "    plt.plot(range(1,epoch_limit), train_acc, color='blue')\n",
    "    plt.plot(range(1,epoch_limit), val_acc, color='red')\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.ylabel('Accuracy')\n",
    "    plt.title('Accuracy Curve')\n",
    "    plt.legend(['Train Accuracy', 'Validation Accuracy'])\n",
    "    plt.show()\n",
    "    \n",
    "    plt.clf()\n",
    "    plt.cla()\n",
    "    plt.close()\n",
    "    torch.cuda.empty_cache()\n",
    "    cv2.destroyAllWindows()\n",
    "    del model\n",
    "    gc.collect()\n",
    "\n",
    "    return path_res, model_name"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93c136ee",
   "metadata": {},
   "source": [
    "### Ensemble"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "52e8d4c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\snytk\\miniconda3\\envs\\python311\\Lib\\site-packages\\torchvision\\models\\_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
      "  warnings.warn(\n",
      "C:\\Users\\snytk\\miniconda3\\envs\\python311\\Lib\\site-packages\\torchvision\\models\\_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet18_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet18_Weights.DEFAULT` to get the most up-to-date weights.\n",
      "  warnings.warn(msg)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch : 1\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1011/1011 [00:59<00:00, 17.03it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.2450 Acc: 0.8981\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 433/433 [00:12<00:00, 33.55it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.1915 Acc: 0.9192\n",
      "\n",
      "Epoch : 2\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1011/1011 [00:59<00:00, 16.96it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.1875 Acc: 0.9219\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 433/433 [00:12<00:00, 33.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.1749 Acc: 0.9279\n",
      "\n",
      "Epoch : 3\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1011/1011 [00:59<00:00, 16.98it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.1548 Acc: 0.9362\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 433/433 [00:13<00:00, 32.83it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.1660 Acc: 0.9221\n",
      "\n",
      "Epoch : 4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1011/1011 [00:59<00:00, 17.13it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.0797 Acc: 0.9726\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 433/433 [00:12<00:00, 33.63it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.1211 Acc: 0.9475\n",
      "\n",
      "Epoch : 7\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1011/1011 [00:58<00:00, 17.21it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.0610 Acc: 0.9778\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 433/433 [00:12<00:00, 33.87it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.0871 Acc: 0.9636\n",
      "\n",
      "Epoch : 8\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1011/1011 [00:58<00:00, 17.16it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.0315 Acc: 0.9884\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 433/433 [00:12<00:00, 33.69it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.2154 Acc: 0.9452\n",
      "\n",
      "Epoch : 9\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1011/1011 [00:58<00:00, 17.23it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.0404 Acc: 0.9852\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 433/433 [00:12<00:00, 33.85it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.0957 Acc: 0.9729\n",
      "\n",
      "Epoch : 10\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████| 1011/1011 [00:58<00:00, 17.19it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train Loss: 0.0285 Acc: 0.9896\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 433/433 [00:18<00:00, 24.04it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val Loss: 0.1035 Acc: 0.9735\n",
      "\n",
      "Total time elapsed = 725.3019790999999 seconds\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHFCAYAAAAaD0bAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAByT0lEQVR4nO3dd1iV5RsH8O8B2QKKAzARt7gHLtwTd5J7a2lmuZDKkVtT036mqWlpuTJnzspS1BT3RlNxpCak4hbEgQLv74+7AxyGss55z/h+rutcnPGe99wHkXPzPPdzPxpFURQQERERWRArtQMgIiIiMjQmQERERGRxmAARERGRxWECRERERBaHCRARERFZHCZAREREZHGYABEREZHFYQJEREREFocJEBEREVkcJkBElG3Lly+HRqPBiRMn1A4lQ/bv348uXbrgrbfegq2tLVxdXVGnTh0sWrQIT58+VTs8IjIAJkBEZFEmTpyIBg0a4ObNm5g6dSqCg4Oxdu1aNG3aFJMmTcK4cePUDpGIDCCX2gEQERnKhg0bMGXKFPTv3x9LliyBRqNJfKxVq1YYOXIkDh8+nCOv9ezZMzg6OubIuYgo53EEiIgM5sCBA2jatCmcnZ3h6OiIOnXq4LffftM55tmzZ/jkk09QrFgx2Nvbw83NDdWrV8eaNWsSj7l27Rq6deuGQoUKwc7ODu7u7mjatClCQ0Nf+/pTpkxB3rx5MW/ePJ3kR8vZ2Rn+/v4AgH/++QcajQbLly9PdZxGo8GkSZMSb0+aNAkajQanTp1Cp06dkDdvXpQoUQJz586FRqPB33//neoco0aNgq2tLe7fv594365du9C0aVO4uLjA0dERdevWxe7du1/7nogoa5gAEZFB7Nu3D02aNEFUVBR++OEHrFmzBs7OzmjXrh3WrVuXeFxQUBAWLVqEYcOG4Y8//sCPP/6Izp0748GDB4nHtG7dGidPnsSsWbMQHByMRYsWoWrVqnj8+HG6r3/79m2cO3cO/v7+ehuZ6dChA0qWLIkNGzbg22+/Ra9evWBra5sqiYqPj8eqVavQrl075M+fHwCwatUq+Pv7w8XFBStWrMD69evh5uaGFi1aMAki0geFiCibli1bpgBQjh8/nu4xtWvXVgoWLKg8efIk8b64uDilQoUKSuHChZWEhARFURSlQoUKSkBAQLrnuX//vgJAmTt3bqZiPHLkiAJAGT16dIaOv379ugJAWbZsWarHACgTJ05MvD1x4kQFgDJhwoRUx3bo0EEpXLiwEh8fn3jf9u3bFQDKL7/8oiiKojx9+lRxc3NT2rVrp/Pc+Ph4pXLlykrNmjUzFDMRZRxHgIhI754+fYqjR4+iU6dOyJ07d+L91tbW6N27N/79919cunQJAFCzZk38/vvvGD16NPbu3Yvnz5/rnMvNzQ0lSpTAl19+ia+++gqnT59GQkKCQd9Pejp27JjqvnfffRf//vsvdu3alXjfsmXL4OHhgVatWgEADh06hIcPH6Jv376Ii4tLvCQkJKBly5Y4fvw4V6cR5TAmQESkd48ePYKiKPD09Ez1WKFChQAgcYpr3rx5GDVqFLZs2YLGjRvDzc0NAQEBuHLlCgCpv9m9ezdatGiBWbNmoVq1aihQoACGDRuGJ0+epBtDkSJFAADXr1/P6beXKK3316pVK3h6emLZsmUA5Huxbds29OnTB9bW1gCAO3fuAAA6deoEGxsbncvMmTOhKAoePnyot7iJLBFXgRGR3uXNmxdWVla4fft2qsdu3boFAIm1ME5OTpg8eTImT56MO3fuJI4GtWvXDhcvXgQAeHt744cffgAAXL58GevXr8ekSZPw8uVLfPvtt2nG4OnpiYoVK2Lnzp0ZWqFlb28PAIiNjdW5P3ktUkppFVZrR7nmzZuHx48fY/Xq1YiNjcW7776beIz2vc+fPx+1a9dO89zu7u6vjZeIMocjQESkd05OTqhVqxY2bdqkM6WVkJCAVatWoXDhwihdunSq57m7u6Nfv37o3r07Ll26hGfPnqU6pnTp0hg3bhwqVqyIU6dOvTaO8ePH49GjRxg2bBgURUn1eExMDHbu3Jn42vb29jh79qzOMVu3bs3Qe07u3XffxYsXL7BmzRosX74cfn5+8PHxSXy8bt26yJMnDy5cuIDq1aunebG1tc306xJR+jgCREQ5Zs+ePfjnn39S3d+6dWvMmDEDzZs3R+PGjfHJJ5/A1tYWCxcuxLlz57BmzZrE0ZNatWqhbdu2qFSpEvLmzYuwsDD8+OOP8PPzg6OjI86ePYshQ4agc+fOKFWqFGxtbbFnzx6cPXsWo0ePfm18nTt3xvjx4zF16lRcvHgR/fv3R4kSJfDs2TMcPXoU3333Hbp27Qp/f39oNBr06tULS5cuRYkSJVC5cmUcO3YMq1evzvT3xcfHB35+fpgxYwYiIiKwePFincdz586N+fPno2/fvnj48CE6deqEggUL4t69ezhz5gzu3buHRYsWZfp1ieg1VC7CJiIzoF0Flt7l+vXriqIoyv79+5UmTZooTk5OioODg1K7du3ElVBao0ePVqpXr67kzZtXsbOzU4oXL66MGDFCuX//vqIoinLnzh2lX79+io+Pj+Lk5KTkzp1bqVSpkjJnzhwlLi4uQ/Hu27dP6dSpk+Lp6anY2NgoLi4uip+fn/Lll18q0dHRicdFRUUpAwYMUNzd3RUnJyelXbt2yj///JPuKrB79+6l+5qLFy9WACgODg5KVFRUunG1adNGcXNzU2xsbJS33npLadOmjbJhw4YMvS8iyjiNoqQxDkxERERkxlgDRERERBaHCRARERFZHCZAREREZHGYABEREZHFYQJEREREFocJEBEREVkcNkJMQ0JCAm7dugVnZ+c0W9sTERGR8VEUBU+ePEGhQoVgZfX6MR4mQGm4desWvLy81A6DiIiIsiAiIgKFCxd+7TFMgNLg7OwMQL6BLi4uKkdDREREGREdHQ0vL6/Ez/HXYQKUBu20l4uLCxMgIiIiE5OR8hUWQRMREZHFYQJEREREFkf1BGjhwoUoVqwY7O3t4evri/3796d77KZNm9C8eXMUKFAALi4u8PPzw44dO3SOWb58OTQaTarLixcv9P1WiIiIyESoWgO0bt06BAYGYuHChahbty6+++47tGrVChcuXECRIkVSHR8SEoLmzZtj+vTpyJMnD5YtW4Z27drh6NGjqFq1auJxLi4uuHTpks5z7e3t9f5+iIgoSXx8PF69eqV2GGRmbG1t37jEPSM0iqIoORBPltSqVQvVqlXDokWLEu8rW7YsAgICMGPGjAydo3z58ujatSsmTJgAQEaAAgMD8fjx4yzHFR0dDVdXV0RFRbEImogokxRFQWRkZLZ+DxOlx8rKCsWKFYOtrW2qxzLz+a3aCNDLly9x8uRJjB49Wud+f39/HDp0KEPnSEhIwJMnT+Dm5qZzf0xMDLy9vREfH48qVapg6tSpOiNEKcXGxiI2NjbxdnR0dCbeCRERJadNfgoWLAhHR0c2lKUco21UfPv2bRQpUiRbP1uqJUD3799HfHw83N3dde53d3dHZGRkhs4xe/ZsPH36FF26dEm8z8fHB8uXL0fFihURHR2Nr7/+GnXr1sWZM2dQqlSpNM8zY8YMTJ48OetvhoiIAMi0lzb5yZcvn9rhkBkqUKAAbt26hbi4ONjY2GT5PKoXQafM3hRFyVBGt2bNGkyaNAnr1q1DwYIFE++vXbs2evXqhcqVK6N+/fpYv349Spcujfnz56d7rjFjxiAqKirxEhERkfU3RERkwbQ1P46OjipHQuZKO/UVHx+frfOoNgKUP39+WFtbpxrtuXv3bqpRoZTWrVuH/v37Y8OGDWjWrNlrj7WyskKNGjVw5cqVdI+xs7ODnZ1dxoMnIqLX4rQX6UtO/WypNgJka2sLX19fBAcH69wfHByMOnXqpPu8NWvWoF+/fli9ejXatGnzxtdRFAWhoaHw9PTMdsxERERkHlRdBh8UFITevXujevXq8PPzw+LFixEeHo5BgwYBkKmpmzdvYuXKlQAk+enTpw++/vpr1K5dO3H0yMHBAa6urgCAyZMno3bt2ihVqhSio6Mxb948hIaG4ptvvlHnTRIRkUVq1KgRqlSpgrlz56odCqVB1QSoa9euePDgAaZMmYLbt2+jQoUK2L59O7y9vQEAt2/fRnh4eOLx3333HeLi4jB48GAMHjw48f6+ffti+fLlAIDHjx9j4MCBiIyMhKurK6pWrYqQkBDUrFnToO+NiIhMw5umVJJ/xmTGpk2bslWkCwD9+vXD48ePsWXLlmydh1JTtQ+QsdJnH6B//gGePgXKl8/R0xIRGYUXL17g+vXriR3+TUHyWtR169ZhwoQJOs10k88yAFLond3EJqOYAKX2up+xzHx+q74KzJJs2gT4+AADBgBMO4mIjIOHh0fixdXVFRqNJvH2ixcvkCdPHqxfvx6NGjWCvb09Vq1ahQcPHqB79+4oXLgwHB0dUbFiRaxZs0bnvI0aNUJgYGDi7aJFi2L69Ol477334OzsjCJFimDx4sXZin3fvn2oWbMm7Ozs4OnpidGjRyMuLi7x8Z9//hkVK1aEg4MD8uXLh2bNmuHp06cAgL1796JmzZpwcnJCnjx5ULduXdy4cSNb8ZgSJkAG5OcH5MoFHDkCrF+vdjRERPqnKDLqrcYlJ//QHDVqFIYNG4awsDC0aNECL168gK+vL3799VecO3cOAwcORO/evXH06NHXnmf27NmoXr06Tp8+jY8++ggffvghLl68mKWYbt68idatW6NGjRo4c+YMFi1ahB9++AGff/45ACkj6d69O9577z2EhYVh79696NChAxRFQVxcHAICAtCwYUOcPXsWhw8fxsCBAy1q9Z6qNUCWxtMTGDUKmDBBvrZvD5jICDERUZY8ewbkzq3Oa8fEAE5OOXOuwMBAdOjQQee+Tz75JPH60KFD8ccff2DDhg2oVatWuudp3bo1PvroIwCSVM2ZMwd79+6Fj49PpmNauHAhvLy8sGDBAmg0Gvj4+ODWrVsYNWoUJkyYgNu3byMuLg4dOnRIrK2tWLEiAODhw4eIiopC27ZtUaJECQCyFZUl4QiQgX38MfDWW8CNG8DXX6sdDRERZUT16tV1bsfHx2PatGmoVKkS8uXLh9y5c2Pnzp06C3fSUqlSpcTr2qm2u3fvZimmsLAw+Pn56Yza1K1bFzExMfj3339RuXJlNG3aFBUrVkTnzp2xZMkSPHr0CADg5uaGfv36oUWLFmjXrh2+/vpr3L59O0txmComQAbm6Aho93mdPh3I4s89EZFJcHSUkRg1LjnZjNopxVDS7NmzMWfOHIwcORJ79uxBaGgoWrRogZcvX772PCmLpzUaDRISErIUU1o7J2jXNWk0GlhbWyM4OBi///47ypUrh/nz56NMmTK4fv06AGDZsmU4fPgw6tSpg3Xr1qF06dI4cuRIlmIxRUyAVNCzJ+DrC0RHA5MmqR0NEZH+aDQyDaXGRZ/lLPv370f79u0Tt14qXrz4a3cc0Idy5crh0KFDSL6Y+9ChQ3B2dsZbb70FQBKhunXrYvLkyTh9+jRsbW2xefPmxOOrVq2KMWPG4NChQ6hQoQJWr15t0PegJiZAKrCyAmbPluvffQdcuKBuPERElDklS5ZEcHAwDh06hLCwMHzwwQcZ3sg7s6KiohAaGqpzCQ8Px0cffYSIiAgMHToUFy9exNatWzFx4kQEBQXBysoKR48exfTp03HixAmEh4dj06ZNuHfvHsqWLYvr169jzJgxOHz4MG7cuIGdO3fi8uXLFlUHxCJolTRsCAQEAFu2AJ9+Cvz2m9oRERFRRo0fPx7Xr19HixYt4OjoiIEDByIgIABRUVE5/lp79+5F1apVde7TNmfcvn07Pv30U1SuXBlubm7o378/xo0bBwBwcXFBSEgI5s6di+joaHh7e2P27Nlo1aoV7ty5g4sXL2LFihV48OABPD09MWTIEHzwwQc5Hr+xYiPENOizEWJyV64A5coBcXHAjh2Av7/eXoqIyCBMsREimRY2QjQDpUoBQ4bI9U8+AeLj1Y2HiIjIUjABUtn48UDevMBffwHLlqkdDRERkWVgAqQyNzdpjAgA48YBT56oGw8REZElYAJkBD76CChZErhzB5g5U+1oiIiIzB8TICNgawvMmiXXZ88GIiLUjYeIiMjcMQEyEgEBQIMGwIsXwGefqR0NERGReWMCZCQ0GuCrr+T6qlXAiRPqxkNERGTOmAAZEV9foHdvuR4UBLBDExERkX4wATIy06YBDg7A/v1Asu1aiIiIKAcxATIyXl7Axx/L9ZEjgTdsLExEREaiUaNGCAwMTLxdtGhRzJ0797XP0Wg02LJlS7ZfO6fOY0mYABmhUaMADw/g6lXgm2/UjoaIyLy1a9cOzZo1S/Oxw4cPQ6PR4NSpU5k+7/HjxzFw4MDshqdj0qRJqFKlSqr7b9++jVatWuXoa6W0fPly5MmTR6+vYUhMgIxQ7tzA55/L9SlTgAcP1I2HiMic9e/fH3v27MGNGzdSPbZ06VJUqVIF1apVy/R5CxQoAEdHx5wI8Y08PDxgZ2dnkNcyF0yAjFS/fkClSsDjx8DUqWpHQ0Rkvtq2bYuCBQti+fLlOvc/e/YM69atQ//+/fHgwQN0794dhQsXhqOjIypWrIg1a9a89rwpp8CuXLmCBg0awN7eHuXKlUNwcHCq54waNQqlS5eGo6MjihcvjvHjx+PVq1cAZARm8uTJOHPmDDQaDTQaTWLMKafA/vrrLzRp0gQODg7Ily8fBg4ciJiYmMTH+/Xrh4CAAPzvf/+Dp6cn8uXLh8GDBye+VlaEh4ejffv2yJ07N1xcXNClSxfcuXMn8fEzZ86gcePGcHZ2houLC3x9fXHivyXPN27cQLt27ZA3b144OTmhfPny2L59e5ZjyYhcej07ZZm1tTRFbN5cpsE++ggoXVrtqIiIMklRgGfP1HltR0fpMfIGuXLlQp8+fbB8+XJMmDABmv+es2HDBrx8+RI9e/bEs2fP4Ovri1GjRsHFxQW//fYbevfujeLFi6NWrVpvfI2EhAR06NAB+fPnx5EjRxAdHa1TL6Tl7OyM5cuXo1ChQvjrr7/w/vvvw9nZGSNHjkTXrl1x7tw5/PHHH9i1axcAwNXVNdU5nj17hpYtW6J27do4fvw47t69iwEDBmDIkCE6Sd6ff/4JT09P/Pnnn/j777/RtWtXVKlSBe+///4b309KiqIgICAATk5O2LdvH+Li4vDRRx+ha9eu2Lt3LwCgZ8+eqFq1KhYtWgRra2uEhobCxsYGADB48GC8fPkSISEhcHJywoULF5A7d+5Mx5HZoCmFqKgoBYASFRWldihKmzaKAihK+/ZqR0JE9GbPnz9XLly4oDx//lzuiImRX2JqXGJiMhx3WFiYAkDZs2dP4n0NGjRQunfvnu5zWrdurXz88ceJtxs2bKgMHz488ba3t7cyZ84cRVEUZceOHYq1tbUSERGR+Pjvv/+uAFA2b96c7mvMmjVL8fX1Tbw9ceJEpXLlyqmOS36exYsXK3nz5lVikr3/3377TbGyslIiIyMVRVGUvn37Kt7e3kpcXFziMZ07d1a6du2abizLli1TXF1d03xs586dirW1tRIeHp543/nz5xUAyrFjxxRFURRnZ2dl+fLlaT6/YsWKyqRJk9J97eRS/Ywlk5nPb06BGbkvv5TRoK1bgf+SaCIiymE+Pj6oU6cOli5dCgC4evUq9u/fj/feew8AEB8fj2nTpqFSpUrIly8fcufOjZ07dyI8PDxD5w8LC0ORIkVQuHDhxPv8/PxSHffzzz+jXr168PDwQO7cuTF+/PgMv0by16pcuTKcnJwS76tbty4SEhJw6dKlxPvKly8Pa2vrxNuenp64e/dupl4r+Wt6eXnBy8sr8b5y5cohT548CAsLAwAEBQVhwIABaNasGb744gtcvXo18dhhw4bh888/R926dTFx4kScPXs2S3FkBhMgI1e2LPDBB3I9KAhISFA3HiKiTHF0BGJi1LlksgC5f//+2LhxI6Kjo7Fs2TJ4e3ujadOmAIDZs2djzpw5GDlyJPbs2YPQ0FC0aNECLzPYq0RJo7OtJsX03JEjR9CtWze0atUKv/76K06fPo2xY8dm+DWSv1bKc6f1mtrpp+SPJWTxQya910x+/6RJk3D+/Hm0adMGe/bsQbly5bD5v4Z3AwYMwLVr19C7d2/89ddfqF69OubPn5+lWDKKCZAJmDQJcHEBTp8GfvxR7WiIiDJBowGcnNS5ZKD+J7kuXbrA2toaq1evxooVK/Duu+8mfnjv378f7du3R69evVC5cmUUL14cV65cyfC5y5Urh/DwcNy6dSvxvsOHD+scc/DgQXh7e2Ps2LGoXr06SpUqlWplmq2tLeLj49/4WqGhoXj69KnOua2srFBaT8Wk2vcXkWw37wsXLiAqKgply5ZNvK906dIYMWIEdu7ciQ4dOmDZsmWJj3l5eWHQoEHYtGkTPv74YyxZskQvsWoxATIBBQoAY8fK9bFjgWQ/00RElENy586Nrl274rPPPsOtW7fQr1+/xMdKliyJ4OBgHDp0CGFhYfjggw8QGRmZ4XM3a9YMZcqUQZ8+fXDmzBns378fY7W/2JO9Rnh4ONauXYurV69i3rx5iSMkWkWLFsX169cRGhqK+/fvIzY2NtVr9ezZE/b29ujbty/OnTuHP//8E0OHDkXv3r3h7u6euW9KCvHx8QgNDdW5XLhwAc2aNUOlSpXQs2dPnDp1CseOHUOfPn3QsGFDVK9eHc+fP8eQIUOwd+9e3LhxAwcPHsTx48cTk6PAwEDs2LED169fx6lTp7Bnzx6dxEkfmACZiGHDgKJFgZs3ZXUYERHlvP79++PRo0do1qwZihQpknj/+PHjUa1aNbRo0QKNGjWCh4cHAgICMnxeKysrbN68GbGxsahZsyYGDBiAadOm6RzTvn17jBgxAkOGDEGVKlVw6NAhjB8/XueYjh07omXLlmjcuDEKFCiQ5lJ8R0dH7NixAw8fPkSNGjXQqVMnNG3aFAsWLMjcNyMNMTExqFq1qs6ldevWicvw8+bNiwYNGqBZs2YoXrw41q1bBwCwtrbGgwcP0KdPH5QuXRpdunRBq1atMHnyZACSWA0ePBhly5ZFy5YtUaZMGSxcuDDb8b6ORklrYtLCRUdHw9XVFVFRUXBxcVE7nETr1gHdusm09pUrQKFCakdERKTrxYsXuH79OooVKwZ7e3u1wyEz9Lqfscx8fnMEyIR06QLUri0tNVL8UUBERESZwATIhGg0wJw5cn3ZMiA0VNVwiIiITBYTIBNTuzbQtat0+fr4Y/lKREREmcMEyAR98QVgZwfs2QP89pva0RAREZkeJkAmqGhRQLuFzCefANnYu46ISC+4vob0Jad+tpgAmagxY4D8+YFLl4DFi9WOhohIaLsLP1NrA1Qye9rO2Mm38cgK7gZvolxdgSlTZJf4iROBnj2BPHnUjoqILJ21tTXy5MmTuKeUo6NjutsyEGVWQkIC7t27B0dHR+TKlb0UhgmQCXv/fWD+fCAsDJg2TTZOJSJSm4eHBwBkeWNNotexsrJCkSJFsp1YsxFiGoy1EWJatm8H2rQBbG0lESpeXO2IiIhEfHw8XrFIkXKYra0trKzSruDJzOc3R4BMXKtWQPPmQHAwMHo0sH692hEREQlra+ts12kQ6QuLoE2cRgP873/ydcMG4OBBtSMiIiIyfkyAzEClSkD//nI9KAhISFA3HiIiImPHBMhMTJ0KODkBx47JpqlERESUPiZAZsLDQ2qAAPn6/Lm68RARERkzJkBmJCgIKFwYCA8Hvv5a7WiIiIiMFxMgM+LoCMyYIdenTwfu3FE3HiIio6AowIULLJAkHUyAzEyPHkD16sCTJ9IhmojI4i1eDJQvL0tmif7DBMjMWFkBs2fL9SVLgPPn1Y2HiEh1P/8sX9euVTcOMipMgMxQgwZAhw4y2vvJJ2pHQ0SkopcvkxqknT4N3LunbjxkNJgAmamZMwEbG+CPP4AdO9SOhohIJceO6S6L3b1bvVjIqDABMlMlSwJDhsj1jz8G4uLUjYeISBV79+reDg5WJQwyPkyAzNi4cUDevFIHtHSp2tEQEalAmwC9/bZ8DQ6WVWFk8ZgAmTE3t6SVYOPHy8owIiKLERubVP8zfjxgawtERACXL6sbFxkFJkBm7sMPgVKlgLt3gS++UDsaIiIDOnYMePECKFgQ8PUF6tWT+zkNRmACZPZsbYFZs+T6V19Jl2giIovw55/ytVEjQKMBmjeX20yACEyALEL79kDDhvKH0GefqR0NEZGBaOt/GjWSr9oE6M8/gVev1IiIjAgTIAug0cjoj0YD/PSTjAoTEZm1Fy+Aw4fleuPG8rVqVSBfPimI5C9Ci8cEyEJUqwb07i3Xg4K4CIKIzNzRo5IEubsDZcrIfVZWQNOmcp3TYBaPCZAFmTYNcHCQRRGbNqkdDRGRHiWf/tJoku5nHRD9hwmQBSlcGPj0U7k+cqSsECUiMkvaAmjt9JeWNgE6ehSIijJsTGRUmABZmE8/BTw8gGvXgAUL1I6GiEgPXrwAjhyR69oCaC1vb+kNEh+fuks0WRQmQBYmd26ZCgOAqVOB+/fVjYeIKMcdOSJD3J6eQOnSqR/nNBiBCZBF6tsXqFRJRn+nTFE7GiKiHJay/09KTIAITIAskrU1MHu2XF+0CLh0Sd14iIhyVMr+Pyk1biy/CC9fZndYC8YEyEI1awa0bSu7xI8cqXY0REQ55PnzpPqflAXQWq6uQM2acp2jQBaLCZAF+/JL+SNo2zZgzx61oyEiygGHDwMvXwKFCgElS6Z/HKfBLJ7qCdDChQtRrFgx2Nvbw9fXF/v370/32E2bNqF58+YoUKAAXFxc4Ofnhx07dqQ6buPGjShXrhzs7OxQrlw5bN68WZ9vwWT5+ACDBsn1jz+WRRFERCYtvf4/Kfn7y9fdu4GEBH1HRUZI1QRo3bp1CAwMxNixY3H69GnUr18frVq1Qng6c7IhISFo3rw5tm/fjpMnT6Jx48Zo164dTp8+nXjM4cOH0bVrV/Tu3RtnzpxB79690aVLFxw9etRQb8ukTJwoo8GhocCPP6odDRFRNqXX/yelmjUBZ2dZChsaqvewyPhoFEW9TRFq1aqFatWqYdGiRYn3lS1bFgEBAZgxY0aGzlG+fHl07doVEyZMAAB07doV0dHR+P333xOPadmyJfLmzYs1a9Zk6JzR0dFwdXVFVFQUXFxcMvGOTNOXX0odkKcncOUK4OSkdkRERFnw7BmQJ49sdHrlyuunwADZKXrbNuCLL4BRowwSIulXZj6/VRsBevnyJU6ePAl/7TDkf/z9/XHo0KEMnSMhIQFPnjyBm5tb4n2HDx9Odc4WLVpk+JyWaOhQoFgx4PZt4H//UzsaIqIsOnRIkp/ChYESJd58vLYOaOdO/cZFRkm1BOj+/fuIj4+Hu7u7zv3u7u6IjIzM0Dlmz56Np0+fokuXLon3RUZGZvqcsbGxiI6O1rlYEnt7YOZMuT5rFnDzprrxEBFlSUbrf7S0CdCBAzJ6RBZF9SJoTYofUkVRUt2XljVr1mDSpElYt24dChYsmK1zzpgxA66urokXLy+vTLwD89CpE1CnjvwOGDdO7WiIiLLgTf1/UipdGvDyklVjr1mAQ+ZJtQQof/78sLa2TjUyc/fu3VQjOCmtW7cO/fv3x/r169GsWTOdxzw8PDJ9zjFjxiAqKirxEhERkcl3Y/o0mqTmiCtWAMnqyomIjN/Tp8CxY3L9TQXQWhoNl8NbMNUSIFtbW/j6+iI4xQ9dcHAw6tSpk+7z1qxZg379+mH16tVo06ZNqsf9/PxSnXPnzp2vPaednR1cXFx0Lpaodm2gWzdAUWRZvHrl8UREmaSt//HykqLGjGICZLFUnQILCgrC999/j6VLlyIsLAwjRoxAeHg4Bv3XnGbMmDHo06dP4vFr1qxBnz59MHv2bNSuXRuRkZGIjIxEVFRU4jHDhw/Hzp07MXPmTFy8eBEzZ87Erl27EBgYaOi3Z5JmzADs7GQl6S+/qB0NEVEGJV/+npH6H62mTeXr2bPAnTs5HxcZLVUToK5du2Lu3LmYMmUKqlSpgpCQEGzfvh3e3t4AgNu3b+v0BPruu+8QFxeHwYMHw9PTM/EyfPjwxGPq1KmDtWvXYtmyZahUqRKWL1+OdevWoVatWgZ/f6aoaFFgxAi5/umn8gcVEZHRy2z9j1aBAkDVqnJ9166cjIiMnKp9gIyVpfUBSik6Wtpn3LsHzJsny+SJiIxWTAyQN69sbnjtWuamwADpATRrFtC3L7B8uV5CJMMwiT5AZLxcXIApU+T6pEnAo0eqhkNE9HoHD0ry4+2d+eQH0K0D4piAxWACRGkaMAAoVw54+BCYNk3taIiIXiOr019a9epJQ7Rbt4CwsJyKiowcEyBKU65cSV2h580Drl5VNx4ionRldP+v9NjbA/Xry3WuBrMYTIAoXS1byobJr15xmxwiMlJPngAnTsj1hg2zfh4uh7c4TIAoXRqNjAJZWQEbN0q3eCIio3LwIBAfL0tYixbN+nm0CdDevdIZmsweEyBD27pVOpaaiIoVgf795XpQEJCQoG48REQ6sjv9pVWpkiyJf/oUOHIk+3GR0WMCZEjnzgHvvAMULw58/TXw4oXaEWXIlClA7tzA8ePAmjVqR0NElEx2C6C1rKwA7dZKnAazCEyADOn+fUl+7t4FAgOl2c533xl9t0EPD2DMGLk+Zgzw/Lm68RARAZCmZSdPyvXsJkAA64AsDBMgQ2rUSJZYLl4MFC4M3LwJDBoE+PgAK1fKPLaRGjFCttiJiADmzFE7GiIiSGFifLz8YVmkSPbPp02Ajh9nAzQLwATI0GxsgPffB65ckfXl7u7SubRvX6BCBWDDBqMstHFwkH3CAPkaGaluPEREOTb9pVW4sPxBmpCQVFtEZosJkFrs7WWPiatXgZkzATc34OJFoEsXwNcX+PVXo+tI2r07UL26dJ2fOFHtaIjI4uVUAXRynAazGEyA1ObkBIwcKaNAkyYBzs5AaCjQrh1Qpw6we7fRJEJWVsBXX8n177+Xmm4iIlVERQGnTsn1nBoBApgAWRAmQMbC1VWGVa5fl66DDg6yFLNZM6BJE+l1YQTq1wc6dpQR4mHDjL5+m4jM1f798ouoZEmZusopjRpJK/yrV+X3MZktJkDGJl8+4IsvZERo2DDA1lbmuevVA1q3TlrxoKKZMwE7Oxl97tlT9iAkIjKonK7/0XJ2BmrXluscBTJrTICMlYeH9Ar6+29g4ED5i+T336UIp2NHVeefSpQAfv5Z6rk3bAB69WISREQGpq8ECOA0mIVgAmTsvLykV9DFi0Dv3rI/xaZN0rW0Z09ZTaaCtm2TkqB162QRmxGv4icic/L4MXD6tFzXZwK0ezd/sZkxJkCmokQJ6RV07hzQqZMURq9eDZQtCwwYAISHGzykt98G1q+XwanVq4F+/fi7gogMQFv/U6oU8NZbOX/+GjWkLvPRo6RCazI7TIBMTblyMu906pQMw8THAz/8IL8Ihg4Fbt82aDgBAcDatYC1NbBqlewbxiSIiPRKH8vfk8uVK+ncnAYzW0yATFXVqsAvvwCHDgFNm8ruxQsWyEjRyJGy7YaBdOwoe4RZWwMrVkifRyPs5UhE5kKf9T9arAMye0yATJ2fH7BrF7Bnj/QNev4c+PJLaQ0/caL0yjCAzp2Bn36SXkHLlgEffMAkiIj04NEj6ZUG6DcB8veXrwcPyg7xZHaYAJmLxo1lX5zt24Fq1YAnT2Qb92LFZO8KA/wH7tpVpsGsrKRR4ocfMgkiohwWEiI1kGXKAJ6e+nudEiWAokWl2dm+ffp7HVINEyBzotEArVoBJ04AGzdKvdCjR8Bnn8mI0Ny5wIsXeg2he3eZBtNoZM/XIUOMppE1EZkDQ0x/AfJLjNNgZo0JkDnSaIAOHYCzZ2VIpkQJ4O5d2dK9ZEng22+lZkhPevUCli+XMBYtktpsJkFElCP0XQCdHBMgs8YEyJxZW0uvoLAwYMkS6Sl086bMTfn4yFCNnpZs9ekji9M0GuCbb4DAQCZBRJRNDx/KH3YA0LCh/l+vSRP5JXb+PHDrlv5fjwyKCZAlsLGRXkFXrgDz50uX6evXpXFPhQrSzEcPxTrvvit5FwDMmwcEBTEJIqJs0Nb/+PjI7zF9y5cP8PWV67t26f/1yKCYAFkSOzspyrl6FZg1C3Bzkw7TXbtK4fQvv+R4htK/v9QCAVKC9OmnTIKIKIsMOf2lxWkws8UEyBI5Okomcv06MHky4OICnDkjrZ21y+pzMEt5/32pBQKA2bOB0aOZBBFRFhiqADo5bQKUw78XSX1MgCyZiwswYYIkQqNHS2J09Kj8h9cuq88hgwZJn0ZABp/GjuXvEiLKhPv3k+p/DJkA1akjvxsjI1XdhJpyHhMgkqmwGTOAa9ekWtnOTvpe1K+ftKw+BwweLLVAgLzchAlMgogog0JC5Gu5ckDBgoZ7XTs7oEEDuc5pMLPCBIiSuLsDc+ZIsfQHH8h+OH/8IRsDduiQI3/9DB0qLwEAn38uM3BERG+kxvSXFuuAzBITIErNy0t6BV28KOvZrayAzZuBSpWAHj0kQcqGwECpBQIkAZoyJfshE5GZU6MAWkubAO3bB8TGGv71SS+YAFH6SpSQXkHnzslmX4oiu56WLSvLuy5ezPIcVlCQ1AIBsmXZtGk5GDcRmZd795JGoA3R/yelChVk2f3z57IBNZkFJkD0ZmXLSq+g06eBtm2leeLSpXJ/8eIyXbZxo2y7kQmffiq1QAAwbhzwxRd6iJ2ITJ92L64KFYACBQz/+hoN0KyZXOc0mNlgAkQZV6WK9Ao6fBho3VoaLP7zjzT66dQJyJ9fltFPmiR/JcXFvfGUo0dLLRAAjBkjG9kTEelQs/5Hi3VAZkejKFyHk1J0dDRcXV0RFRUFFxcXtcMxXjExsjJj5065hIXpPu7iAjRtCvj7y6V48XRPNXWqrAoDpD4oKEiPcRORaalQQbaj+PlnoGNHdWK4dQt46y0ZDbp3T7pEk9HJzOc3E6A0MAHKovBw+eto505pGvbwoe7jJUokJUONGwOurjoPT5qUtCpszhwpliYiC3f3rqxQBSTxyJ9fvVi0idj69VIXSUYnM5/fnAKjnFOkiBRHr1snv7SOHZP5rQYNZEn91avSEvqdd+Svp3r1ZAnYkSNAfDwmTpRaIEA2rtf2DCIiC6at/6lYUd3kB+A0mJlhAkT6YW0t/YPGjpVfYA8fAtu2yV5kpUtLIfXBg7IEzM8PyJ8fmi6dMcVrCWZ+dAMAMHy47CRPRBZMzeXvKSVPgDh5YvI4BZYGToEZwD//6E6XPX6s8/C9vKWx9pE/dsIfAXMaoX+gsyphEpHKypWT+sJNm2T0WE1PnwJ58wKvXkk/tJIl1Y2HUmENUDYxATKw+HjZbmPnTmDHjsQpMa1XyIV7peqgUN//6oeqVZMRJiIyb3fuSP8dYyo8btRIRrUXLgQ+/FDtaCgF1gCRabG2BmrVAsaPlw1YHzwANm+GMuhD3HctARvEodCVECkQqllT9gHq2hX44QcgIkLt6IlIX7TL3ytVMo7kB2AdkBlhAkTGx9UVCAiAZtFC5Hv0N6b2/RuDsAib8A5eOrhIPdH69cCAAVJ4Xa6cLBnbvl2GqInIPBhD/5+UtAnQnj0Z6nVGxotTYGngFJhxURRg2DBgwQIgF+KwdewxtM71X++ho0eBhISkg21sZHWZdrl9lSqylxkRmR4fH+DSJWDLFqB9e7WjEfHx0o360SNpClu7ttoRUTKcAiOzotHIkvgPPwTikAttp9fBqpKTpNv0/fuyDccHHwBFi0px4p9/SltpX1/pH9KjB7B8OXDzpsrvhIgy7PZtSX40GqB+fbWjSWJtDTRpItc5DWbSmACRSdBoZARo4EAZEerbF1i9GrIio0MH2b3+2jXg8mU58O23gdy5JUFaswZ4912gcGFpZBYUBPzxB/Dsmdpvi4jSo+3/U7ky4OambiwpsQ7ILDABIpNhZSV9FAcMkFmv3r2l52IijQYoVQoYPBjYulVqhUKSFU9rNNLFdc4coFUrSZ6aNZMd74nIuBhT/5+UtAnQ4cPAkyfqxkJZxgSITIqVFfDdd8B770kS1LMnsGFDOgfb2MjQ+dSpUit0715S8bSXF/DyJbB7N9CvnxxDRMbDGAugtYoXl0tcXNJIFZkcJkBkcqysgCVLZBosPh7o3l3KgN4oXz7Zv2fJEuDGDeDiRWDUKHlswgTgiy/0GjcRZdCtWzKdrdHIVjrGiNNgJo8JEJkkKytpA9S7tyRB3boBmzdn4gQaDVCmjCQ906fLfWPGAF99pZd4iSgTtKM/VasCefKoGUn6mACZPCZAZLKsrYFly2SRV1wc0KWLbDeWaWPGJG1D//HHwPz5ORonEWWSMU9/aTVpIn+JhYUB//6rdjSUBUyAyKRZW0sNc7dukgR16gT8+msWTjR+vGzcCkjToW+/zdE4iSgTjLkAWitvXtnwGeAokIliAkQmL1cu4McfZQTo1SugY0dpCp0pGo0UQo8cKbc//FDm2IjIsP79F/j7bxldqVdP7Whej9NgJo0JEJmFXLmAVask+Xn5UjaN/uOPTJ5Eo5GaoMBAuf3++1wiT2RoplD/o6VNgHbt0u1ITyaBCRCZDRsb6Xn4zjuSBAUEyG4ZmaLRSCH04MHScfHdd//ruEhEBqFNgIx5+kurdm3AyUlabJw9q3Y0lElMgMis2NgAa9fKtkGxsfJ1165MnkS794a27XTv3q9pNkREOcoUCqC1bG2T4uQ0mMlhAkRmx9ZW+h22awe8eCG7YuzZk8mTaNtOv/uuDG13757JdfZElGkREcDVq/L/z5j2/3od1gGZLCZAZJZsbWXQpk0b4PlzoG3bpD8sM0zbcVHbbKhrV+CXX/QRLhEBSf9JfX2BN+zkbTS0CdD+/fIXF5kMJkBktuzsgJ9/Blq2lCSoTRvZGixTtM2GunWTJWadOmWhupqIMkS7/N0Upr+0ypYFChWS5OfAAbWjoUxgAkRmzd5eZq78/WXz99ats/A7ytpa1tlrl5gFBGShsIiI3siUCqC1NBpOg5koJkBk9uztgS1bZOP3p09lI/hDhzJ5kly5ZImZtrr67bezMKdGROm6cQO4fl3+4DD2/j8pMQEySUyAyCI4OABbt0r3+pgYmRY7ciSTJ7GxAdatk2Ek7Zza/v16iZfI4mj/oKheHXB2VjWUTGvWTL6ePi1L4skkMAEii+HoKDXMjRoBT54ALVoAx45l8iR2drL1fPI5tcOH9REukWUxpeXvKbm7A5UqyfXdu9WNhTKMCRBZFEdH2SusQQMgOlrymBMnMnkS7Zxa8uGk48f1ES6R5TDFAujkOA1mcpgAkcVxcgJ++03KDKKiZPQ60+U8Dg6y9XzyTOrUKX2ES2T+/vlHaoBMsf5HK3kCpCjqxkIZwgSILFLu3LJhav36kgS1aCHlPZni5CTDSXXqAI8fyy9AtsMnyjztXyA1ash/TlNUv740IIuIAC5fVjsaygAmQGSxnJ2BHTuADh1kdXu3brINWKZP8vvvQK1awMOHQNOmwPnzeomXyGxpp79Mafl7So6OSaNXnAYzCUyAyKI5OMi2GUOHyu2PPwZGjMjkxs4uLtIc0dcXuH9fkqCLF/USL5HZURTTLoBOjnVAJkX1BGjhwoUoVqwY7O3t4evri/2vWVZ8+/Zt9OjRA2XKlIGVlRUCAwNTHbN8+XJoNJpUlxdsUU7psLYGvv4amDVLbs+dK1t/ZepHJk8e2Xq+cmXgzh0pkL5yRQ/REpmZ69eB8HDptVWnjtrRZI82AfrzT+kcT0ZN1QRo3bp1CAwMxNixY3H69GnUr18frVq1Qnh4eJrHx8bGokCBAhg7diwqV66c7nldXFxw+/ZtnYu9vb2+3gaZAY0G+PRT4KefpN3P+vVSF/ToUSZO4uYmHaIrVABu35Yk6No1vcVMZBa0oz81a5pu/Y9W1apAvnzSZyPTPTbI0FRNgL766iv0798fAwYMQNmyZTF37lx4eXlh0aJFaR5ftGhRfP311+jTpw9cXV3TPa9Go4GHh4fOhSgjevSQ2SwXF9k3rF49qWnMsPz5pQ9I2bLAv/9KTcONG3qLl8jkmcv0FyAbKDdtKtc5DWb0VEuAXr58iZMnT8Lf31/nfn9/fxzK9D4FumJiYuDt7Y3ChQujbdu2OH369GuPj42NRXR0tM6FLFeTJtLguVAh4MIFoHbtTC7uKlhQkqDSpWVov3HjTGZRRBZCUcyjADo51gGZDNUSoPv37yM+Ph7u7u4697u7uyMyMjLL5/Xx8cHy5cuxbds2rFmzBvb29qhbty6uvKYeY8aMGXB1dU28eHl5Zfn1yTxUqiQNnsuVA27dkhWue/Zk4gSenvKEEiWkxqFJEzkRESW5dk1GSm1sAD8/taPJGdoE6OhR6bFBRkv1ImiNRqNzW1GUVPdlRu3atdGrVy9UrlwZ9evXx/r161G6dGnMnz8/3eeMGTMGUVFRiZcI/rVOAIoUkZ3jtb0OW7aU/VAz7K23JAkqWhT4+29JgrKR3BOZHe3oT82a0lfLHHh7A6VKAfHx3DDZyKmWAOXPnx/W1tapRnvu3r2balQoO6ysrFCjRo3XjgDZ2dnBxcVF50IEAHnzSq+gzp1lUUePHsCXX2ai0WuRIvJL3ssLuHRJ6gO4WSKR0CYI5jL9pcVpMJOgWgJka2sLX19fBKf4AQkODkadHFwKqSgKQkND4enpmWPnJMtibw+sXQtouy6MHAkMHy5/4GVI0aKSBGmLipo1Ax480FO0RCbCnPr/pMQEyCSoOgUWFBSE77//HkuXLkVYWBhGjBiB8PBwDBo0CIBMTfXp00fnOaGhoQgNDUVMTAzu3buH0NBQXLhwIfHxyZMnY8eOHbh27RpCQ0PRv39/hIaGJp6TKCusrIA5c4DZs+X2/PlA167A8+cZPEGJEpIEeXhIRXXz5plcY09kZv7+G7h5U7aPMJf6H63GjaXB2OXLshCCjFIuNV+8a9euePDgAaZMmYLbt2+jQoUK2L59O7y9vQFI48OUPYGqVq2aeP3kyZNYvXo1vL298c8//wAAHj9+jIEDByIyMhKurq6oWrUqQkJCULNmTYO9LzJfQUEykNO3L7Bxo/Q83LpVWgC9UenSUhPUsCFw+rQ0GgoOBl7T0oHIbGlHf2rVkm0kzImrq9Q1HT4s/8f791c7IkqDRlG4bW1K0dHRcHV1RVRUFOuBKE179wIBAbLIo2xZ2Q7sv7z9zc6dkyH/Bw9kjf3OnbKnGJEl6dFDVhWMHw9MmaJ2NDlv4kR5X127yhw6GURmPr9VXwVGZIoaNZIVYm+9BYSFyQh+aGgGn1yhgnSMzpsXOHIEaN0aiInRY7RERiZ5/Y+5FUBraXvc7dqVyc0FyVCYABFlUYUKkr9od75o0CATNY9VqiRNfx04ALRrBzx7ps9wiYzHlSvyn8bWVkZBzVHNmjKy++CBTHmT0clSAhQREYF///038faxY8cQGBiIxYsX51hgRKagcGHpGt2okWz/07o18OOPGXyyr6+ssXd2lr+G27fPRFU1kQnT9v/x8wMcHNSNRV9sbJJGt7gazChlKQHq0aMH/vzvBzgyMhLNmzfHsWPH8Nlnn2GKOc7lEr1Gnjyyf1i3bkBcHNCnD/DFFxnsFVSrlhQQOTnJUHmHDkBsrL5DJlKXuS5/T4nL4Y1alhKgc+fOJa6qWr9+PSpUqIBDhw5h9erVWL58eU7GR2QS7OxkJ/lPPpHbY8YAQ4ZksFdQ3brA9u3yl/AffwCdOgEvX+o1XiLVJN//y1ISoAMHOMVthLKUAL169Qp2dnYAgF27duHtt98GIPtw3b59O+eiIzIhVlbSJXruXECjARYulFwmQ7NaDRoAv/4qXRd//VWGk1690nfIRIZ36ZL0j7CzM9/6H63SpaUL/MuXMldORiVLCVD58uXx7bffYv/+/QgODkbLli0BALdu3UK+fPlyNEAiUzN8OLB+vfx+37JFdr/IUOPnJk2kqZCtLbB5M9Czp8ypEZkT7fSXn58k/OZMo+E0mBHLUgI0c+ZMfPfdd2jUqBG6d++OypUrAwC2bdvGhoNEkJGf4GCpDzp8WGa5rl/PwBP9/SX5sbEBNmyQjosZ3nODyARop7/Mdfl7SkyAjFaWGyHGx8cjOjoaefPmTbzvn3/+gaOjIwoWLJhjAaqBjRApp1y4ILvIR0QA7u5S6lOtWgaeuHWrZFFxcZIELV0qc2xEpkxRZDuYu3eBfftk6tfc3bsHaD8TIyPlFwHpjd4bIT5//hyxsbGJyc+NGzcwd+5cXLp0yeSTH6KcVK6c9AqqVEnKHho2lJXvb9S+vXSPtbYGVqwABg5kMzUyfWFhkvzY28sKSEtQoACg3cJp1y51YyEdWUqA2rdvj5UrVwKQvbdq1aqF2bNnIyAgAIsWLcrRAIlMXaFCQEiI1ALFxABt2wIZWizZsSOwapWM/PzwAzB4cAbX1hMZKW39T506UiRnKTgNZpSylACdOnUK9evXBwD8/PPPcHd3x40bN7By5UrMmzcvRwMkMgeurjL9pa1rfvddYNq0DOQz3brJCJBGA3z7rVRYMwkiU2Up/X9SSp4A8f+v0chSAvTs2TM4/7d5486dO9GhQwdYWVmhdu3auHHjRo4GSGQubG2BlSuBUaPk9rhxwIcfZmChV69eMgIEAPPnS7Mh/hIlU2MJ+3+lp149mfa7dUumAckoZCkBKlmyJLZs2YKIiAjs2LED/v9t+nb37l0WDRO9hpWVdIlesEAGdb77Tpo/v7FH2rvvysEA8NVXwGefMQki03LhghQEOzgANWqoHY1h2dsD/82acBrMeGQpAZowYQI++eQTFC1aFDVr1oSfnx8AGQ2qqi32IqJ0DR4MbNwovxd/+UVaAN2794YnDRwomRMgWdSkSfoOkyjnaJe/W1r9jxbrgIxOlhKgTp06ITw8HCdOnMCOZEtamjZtijlz5uRYcETm7J13ZFGImxtw9Kh8Lly9+oYnDR4MaP+PTZkCfP653uMkyhGWOv2lpU2A9u7lVjdGIsuNRTw8PFC1alXcunULN2/eBADUrFkTPj4+ORYckbmrWxc4eBDw9gb+/luSoBMn3vCkwEBg1iy5Pn48MHOmvsMkyp6EBOn7A1heAbRWpUqyJP7pU+mNQarLUgKUkJCAKVOmwNXVFd7e3ihSpAjy5MmDqVOnIoG9SogyxcdHukVXqSItUho1kg3iX+vTT5NGf0aPThoVIjJG588D9+8Djo6WV/+jZWUFNGsm1zkNZhSylACNHTsWCxYswBdffIHTp0/j1KlTmD59OubPn4/x48fndIxEZs/TU/5Abt5c/kBs106aP7/W2LHAxIlyPShIVogRGSPt9FfdurIc0lKxDsio5MrKk1asWIHvv/8+cRd4AKhcuTLeeustfPTRR5g2bVqOBUhkKVxcZCP499+X5fL9+8sWGhMmyIqxNE2cKPUEM2YAw4ZJw6E+fQwaN9EbaQugLXX6S0ubAB0/Djx6BCTbSooML0sjQA8fPkyz1sfHxwcPHz7MdlBElsrWVrpEf/aZ3J40SRZ/pdsrSKORjoojRsjt994DfvvNAJESZVDy+h9LLYDWKlxY5rwTEpKSQlJNlhKgypUrY4F2OW4yCxYsQKVKlbIdFJEl0+Y0ixZJ2cD33wMBATI1lu4T/vc/oHdv2Tm+c2eprCYyBufOAQ8fAk5OQPXqakejPk6DGY0sTYHNmjULbdq0wa5du+Dn5weNRoNDhw4hIiIC27dvz+kYiSzSoEFSG9S9uwzqNG4sU2Rp7jes3S/swQPZc6NtW2D/fqBCBYPHTaRDO9JRrx5gY6NuLMageXOp12MCpLosjQA1bNgQly9fxjvvvIPHjx/j4cOH6NChA86fP49ly5bldIxEFqt9e2D3biBfPikbqFNHlsunycYGWL8e8PMDHj8GWrQAuDUNqc1S9/9KT6NGQK5c0vTr+nW1o7FoGkXJuX76Z86cQbVq1RAfH59Tp1RFdHQ0XF1dERUVxa09yChcvgy0bCm/L/PnlxGhmjXTOfjhQ2m7f+ECULo0cOCA9B8hMrSEBPmBffRIej3Urq12RMahfn35f/ndd1LkRzkmM5/fWW6ESESGU7q0fH74+ko7lUaNZDosTW5uwI4dgJeXZE6tWwNPnhgyXCJx9qwkP7lzyw8vCdYBGQUmQEQmwt1dZhNatgSeP5fpscWL0zm4cGFg506ZOztxQnZcjY01ZLhESdNfrP/RpU2Adu+WhQukCiZARCYkd25g2zbZHD4hAfjgA+kTlOZEto+PFEQ7OcmmY337ypOIDEVbAG3py99TqlFDenY9egScOqV2NBYrU6vAOnTo8NrHHz9+nJ1YiCgDbGxkwZeXl+yHOnUq8O+/Uk6Q6o/smjWBTZtkVdi6dVILNG/eazorEuWQ+HggJESuswBaV65ckhRu2SIjtZa6PYjKMjUC5Orq+tqLt7c3+rALLZHeaTTA5MkyBWZlBSxbBrz9NvDsWRoH+/sDK1bIkxYs4A7yZBhnzshqRGdnoFo1taMxPqwDUl2mRoC4xJ3IuLz/vvQK6toV+OMPaZi4dSvg4JDiwO7dpXp62DCZMytYUObPiPRFW/9Tv76MeJAuf3/5eugQEBMj89tkUKwBIjJxbdvKKLqTk/wx+c47wIsXaRw4dCgwbpxc//BDYONGg8ZJFob9f16vRAmgaFHg1aukqUIyKCZARGagbl2pd3Z0lBXw6S76mjJF+o4oCtCjB/cjIv1IXv/DAui0aTScBlMZEyAiM9GggTRIdHAAfv8d6NgxjSRIowEWLpQM6eVLWUvPVSiU00JDgagowMUFqFJF7WiMFxMgVTEBIjIj2gaJ9vaSDHXuLHmODmtr4Kef5OAnT4BWrV6zvwZRFmhHFln/83pNmsgfJefPA7duqR2NxWECRGRmmjQBfvlFkqBffpEC6VevUhxkby/V0lWqAHfvSkHm7dtqhEvmSFv/w+mv18uXL6lD9q5d6sZigZgAEZmhZs0kv7Gzk1Yj3bqlkQS5uMjSsRIlZJOxli1l2TJRdsTFAfv3y3UWQL8Zp8FUwwSIyEz5+0vyY2srvRB79pTPJh3u7rKEzMND9m1q31722aCsi48H/vc/SSgvXFA7GsM7fRqIjpZOx6z/eTNtArRrVzot3UlfmAARmbGWLYHNmyUJ2rAB6NUrjSSoeHEZCXJxkZU73buncRBlyK1bknl++qksx2vWDLh6Ve2oDEs7/dWggdSb0evVqSPLNyMjgXPn1I7GojABIjJzrVtLyx8bG9kNo0+fNPKbypVlkzE7O5k7GzSIf41m1q+/ApUqAXv2yAdaiRJSV9W0KRARoXZ0hqMtgOb0V8bY2UmyCHAazMCYABFZgLZtZQQoVy5gzRqgX780NqFu2BBYu1b21vjhB2DsWDVCNT0vXkiH7XbtgAcPZNrn1CngwAGgVCngxg0ZCbpzR+1I9S95/Q8LoDOOdUCqYAJEZCHatwfWr5ck6KefgPfeSyMJCgiQXVUBYMYMYO5cA0dpYsLCgFq1gPnz5XZgIHDkCFCmjNRV7doFFCkCXL4sU2MPH6oart6dOiXbOuTJI6NhlDHaBGjfvnQ6mJI+MAEisiDvvCODPNbWwMqVwIABQEJCioMGDACmT5frI0ZItkS6FAX4/ntZwnz2LJA/v0yBzZkjUxpaRYoAu3cnFZm3aiW9l8yVdvqL9T+ZU6GC/Iw8fy57g5FBMAEisjAdOwKrV8vn0/LlsjNGqiRo9Ghg+HC53q+ftJYm8fixNFd6/335wGrWTJKbNm3SPr5kSZnacHMDjh2TqbJnzwwassGw/0/WaDTycwRwGsyAmAARWaAuXYBVq5LKfT78MEUSpNEAX30l+4XFxQGdOsnUjqU7dEhqfLQFVTNnymovT8/XP69CBWk34OIi0xydOqXRotvEvXoldU8AC6CzgnVABscEiMhCdesG/PijJEGLFwNDhqRY+GVlBSxbBrRoISMWbdpYZl8bQIqlPv9cpnZu3JDWAQcPAiNHyvcpI3x9dTdr0yaX5uLkSan/yZuX9T9ZoR0BOnlSiulJ75gAEVmwHj2AFStkwGfRImDo0BRJkK2trKGvVUsKeFu0sKwl3QDw77+ylH38eEmEevSQZn81a2b+XPXqSZsB7fe1f/805h9NlHb6q2HDjCeFlKRQIaB8efkPuGeP2tFYBP6UElm4Xr1koEejAb75Rkp/dJIgJycZuShbVpIBf3/L+Qt161bpkbRvn3wfVqyQuUMXl6yfs3lzWY6nrURPNfRmotj/J/s4DWZQTICICH37yqImQFZ0BwWl+EzOl09qXQoXBi5elOmwp09VidUgnj8HBg+WtgAPHwLVqsmoT58+kilmV/v2kvxoh95GjzbtJCh5/Q8LoLMueQJkyj8PJoIJEBEBkL5AS5bI9blzZTcHnd/BXl6SBLm5AUePynIycyvkBYDz52V6a+FCuf3xx8Dhw9LUMCf16JHUc2nWLGDatJw9vyGdOCF1YvnyScE3ZU3DhtKy/Z9/LG8LFRUwASKiRAMGAN9+K9dnz05jYKJcOZkOc3SUZOjdd82nhkVRJCGpXl32ZCpYUPZI+9//pGZHH95/X1bbAVJjZKqNJ7XTX6z/yR4nJ9kbDOA0mAHwJ5WIdHzwgdQCATIwMXZsiiSodm0p4M2VSxoKpZovM0EPH8rS9EGDZGuLFi2kt0+LFvp/7REjgClTkq5r5yJNibYAmvU/2cc6IINhAkREqXz0UdLuDjNmABMmpMhxWraULooA8PXXwBdfGDrEnLN/v/T22bRJph/+9z9g+3bA3d1wMYwbJ3OOgHSmXLPGcK+dXS9fSksAgAlQTtAmQHv2mFebBCPEBIiI0jRkSNKMzOefA5MnpzigZ0/Z+gEAPvvM9EYu4uKASZPkQzsiQjo2HzokNT+GnsbRaKSp4ocfSqbZuzewbZthY8iq48el/id/flnGTdnj6yu9lKKipLaK9IYJEBGla/jwpBKVyZOTZmoSBQYCY8bI9Q8+ALZsMWB02RAeDjRpIm8qIUFWd506JfU/atFogAULJPmJjwc6d5bNVI0d+//kLGtr+dkEOA2mZ/xpJaLXGjEC+PJLuT5xYhqLlaZNS2ro162b9MwxZhs3Sm+f/fuB3Lmlr8+KFYCzs9qRSQKxdCnQoYNMLbVvn7S83FhpC6C5/D3nsA7IIJgAEdEbffJJUpnPuHEpSn40Glk6FhAAxMYCb78NnDmjRpiv9+yZFDl36iQbmtaoAYSGylSeMcmVS2qAWrZM2oLk5Em1o0pbbGzS7uWs/8k52gTo8GHgyRN1YzFjTICIKENGjUoa/RkzJmlUCEDSirAGDYDoaFk9de2aKnGm6a+/JOHR9t0ZNUpGVkqUUDeu9Gi3ykj+/Tx/Xu2oUjt2TJpGFiggLRIoZxQvLpe4uKQpRspxTICIKMM++yypDmjkyKT6IACyyefWrbIR5p07smXGnTuqxJlIUWRNf40aspGrh4fsyv7FF/rr7ZNTHB2BX36R2B88kFGBv/9WOypdyZe/50SHbErCaTC9YwJERJkyfrzUAgGyYEqnd1+ePNI8sFgx6WTbsqWsZlHDgwfAO+/IcrbYWKB1a5ma036wmAIXF/l+VqwI3L4tm7Ia02a07P+jP0yA9I4JEBFl2sSJUgsESJG0tmcQAMDTU0ZZChaUGpuAAGkuaEh790qh89at0ttnzhzg118lJlPj5iYfgqVLy+q1Zs3UH1kDdOt/WACd85o0kaL4ixdlE2LKcUyAiCjTNBqZCtOugB82LGnrLADSU+ePP2Rl1d69UmgcH6//wOLiZIiqSRPg5k1JGo4eleX6pjxF4+4uS+K9vYHLl2V04OFDdWM6elQS24IFAR8fdWMxR3nzyvQnwFEgPWECRERZotFIUfSoUXJ78OCkfcQAAFWrygiMra10Wf7oI/1umfHPP9KL5vPP5XXee09WT1Wtqr/XNCQvL0mCPDykqLtVKymQVot2+Tvrf/SH02B6xQSIiLJMo5GtMj75RG5/+CGweHGyAxo3ltVhGo08oC0eymkbNsh2FocOSd3MmjXADz9Inx9zUrKkJEH58skKrHbtZKm8GrT1P5z+0h9tArRrl/lsOmxEmAARUbZoNLJp6ogRcvuDDyT3SNSxI7BokVyfOjVFwVA2PX0qO6p36SLF1rVrS91Rt2459xrGpnx5qbFycQFCQuT7Gxtr2BhevJAeNQALoPWpdm3ZIf7ePdmc1xzcuycjwoGBwOzZqobCBIiIsk2jkd9lw4fL7fffT9orFYBkRVOnyvXhw4G1a7P/omfOyNYV338vAXz2mSQExYpl/9zGrlo12bDV0VFqrXr0MOzGmUeOSNLl4QGUKWO417U0trZJCaapToNFRAA//SRNSMuVk5qxjh1lE+Uff1Q1NCZARJQjNBpZbDVkSFIJzsqVyQ4YOzbpwT59ZBQjKxQFmDcPqFlTVsh4esoUwbRpsuLLUtStq1tj9d57hpsmYf8fwzGlOiBFkSL9H34A+vaVP0aKFAF69ZImpGFhclzFilITOHas2vGq65tvvlGKFi2q2NnZKdWqVVNCQkLSPfbWrVtK9+7dldKlSysajUYZPnx4msf9/PPPStmyZRVbW1ulbNmyyqZNmzIVU1RUlAJAiYqKytTziEhREhIU5cMPFQVQFI1GUVatSvZgfLyidOsmDzo5KcrRo5k7+d27itK2rTwfkOv37uVo/CZn61ZFsbaW78egQfIPoG8NGsjrffut/l/L0p0/L99re3tFef5c7Wh0xccrypkzijJ/vqJ07qwo7u5J/ze1F2trRalRQ1E+/lh+Vu/f12tImfn8VjUBWrt2rWJjY6MsWbJEuXDhgjJ8+HDFyclJuXHjRprHX79+XRk2bJiyYsUKpUqVKmkmQIcOHVKsra2V6dOnK2FhYcr06dOVXLlyKUeOHMlwXEyAiLInPl5RBg6U339WVoqyenWyB2NjFaV5c3kwXz5FCQvL2El371YUT095np2d/NI1xIe9KVi9WrJNQFE+/VS/35dnzxTF1lZe69Il/b0OiYQERSlUSL7fwcHqxvLypaIcOaIos2YpSrt2ipInT+qEx85OEuRx4xRlxw5FiY42aIgmkwDVrFlTGTRokM59Pj4+yujRo9/43IYNG6aZAHXp0kVp2bKlzn0tWrRQunXrluG4mAARZV98vKIMGJCUBK1dm+zB6Gj5qxBQlCJFFCUiIv0TvXypKGPGJH3A+/goSmio3uM3OUuWJH0ITZmiv9fZs0dew9OTCaih9O0r3/ORIw37us+eKcrevfLz1KyZojg6pk54nJwUxd9fUT7/XFFCQlQfpcrM53cutabeXr58iZMnT2L06NE69/v7++OQtrtoFhw+fBgjtMtR/tOiRQvM1enXrys2NhaxyVZRRKvZW4PITFhZybR/fDywbJn0QrSyAjp3hjRI/O03oH594NIl2TIjJES6Hid3/TrQvbs03QOkunrOHFkZQ7oGDABiYmQ53oQJ0gIgxe/CHKHt/9O4Met/DKV5c2DFCqkDmjlTf68THS2tJEJC5HL8OPDype4xbm7y/7ZBA7lUqSKbIZsg1aK+f/8+4uPj4e7urnO/u7s7IiMjs3zeyMjITJ9zxowZmDx5cpZfk4jSZmUFLFkitbkrVkguY20NdOgA2UF8xw4p5j1/HmjbVoqZHR3lyWvWyMqR6GjA1VVO1Lmzqu/H6AUGShI0fjwQFCRJ0Pvv5+xrcP8vw2vWTL6ePi3LyAsUyJnz3r8P7N8vl5AQOX/KQnpPz6Rkp0EDWcllZR7rp1RP2zQp/oJQFCXVffo+55gxYxAUFJR4Ozo6Gl5eXtmKgYiEtbUsCklIkFWvXbtK38KAAMjWDjt2yF+Uhw9LgvPTTzJyoV1HX6eONFP09lbxXZiQsWOBJ0+kOdMHH8hoWY8eOXPuZ89kCTzABMiQ3N2BSpWkF9Du3Vnvc/Xvv0nJTkgIcOFC6mOKF9dNeIoXN9uRPtUSoPz588Pa2jrVyMzdu3dTjeBkhoeHR6bPaWdnBzs7uyy/JhG9nrW1TIPFx0su06ULsHGjNDJG+fKyUWmzZtLbpnBhaXCo0ciOqxMmmOwQuyo0GuCLL2QkaOFCaTng5AS0b5/9cx8+DLx6Bbz1lnSlJsNp3lwSoODgjCVAigJcvZqU7ISEyJRySuXLJ01p1a8v//8shGrjWLa2tvD19UVwit4GwcHBqFOnTpbP6+fnl+qcO3fuzNY5iSj7rK1lGqxbN/kM7dhRyoAAyCjPhg1y0NOn8gG7Z4/suMrkJ/M0Gum43aePZJ1duuRMHxn2/1FP8n5Aae2pl5Age8R98438J3vrLaBUKaB/f/mPd/26TF35+soI6+bNMp127px0au/e3aKSH0DlKbCgoCD07t0b1atXh5+fHxYvXozw8HAMGjQIgExN3bx5EyuTdVMLDQ0FAMTExODevXsIDQ2Fra0typUrBwAYPnw4GjRogJkzZ6J9+/bYunUrdu3ahQMHDhj8/RGRrly5ZBosPl7ynQ4dgC1bZF9PtGkjGdG+fcDHH8t+V5R1VlYy9/j0qQy3tW8vzSfr1cv6OZMXQJNh1a8vTS8jIqTZYIkSUrOjHd3Zvx949Ej3Oba20jBUO7pTp45soUJC72vS3uCbb75RvL29FVtbW6VatWrKvn37Eh/r27ev0rBhQ53jAaS6eHt76xyzYcMGpUyZMoqNjY3i4+OjbNy4MVMxcRk8kX69fKkoHTsmtQ354w+1IzJjsbGK0qqVfLNdXBTlxImsnScmRlFsbOQ8f/+dszFSxjRpIt//MmVk+XnKJemOjrJcfcoUWb7+7JnaERtcZj6/NYqS1liaZYuOjoarqyuioqLgwmyZSC9evZKZmS1bAHt7YNu2pFF+ymHPn8sw2759sox53z6gQoXMnSM4GPD3l2mS8HBOgalh1ixg1Kik23ny6C5Jr1rVsraDSUNmPr85uU5EqrCxAdatk4Vf27YBb78ttdBNm6odmRlycAB++UUyzKNH5WtIiNSIZJS2/of9f9QzeLCs8HN3l4SnQgWzWZKuBn7niEg1trbA+vVS/vPihawK05aZUA5zdgZ+/12WU0dGyqq78PCMP5/9f9Tn5ARMnSqbCleqxOQnm/jdIyJV2dlJjW7r1kkzNYMGSW9EymF580ohdOnSkvw0aybJ0JvExADHjsl1FkCTmWACRESq0yZBbdsCsbGyhUaFCjIdtnWrrBqjHOLuLs30ihYFrlyR6bAHD17/nEOHgLg4oEgReR6RGWACRERGQVsI/eefsjzeykpaAQUESM+9L78EHj5UO0ozUbiwbDvi6Sl9YFq2lC1H0qOdl2T/HzIjTICIyGhoNPIZu3EjcO2aLHhxcwP++QcYOVI+twcOlH5vlE0lSkgSlD8/cOKEDL89e5b2sckLoInMBBMgIjJK3t6yo8O//wLffw9Uriw1QkuWSP1n48bApk0yM0NZVK6c7MXm4iKN9Dp0kDnI5GJiZFdwgAXQZFaYABGRUXNwkG7+2qa3nTrJjhl798p2GiVKADNnvrmMhdJRrZqsDnN0lGSoe3fdrPLAASnCKlqU9T9kVpgAEZFJ0Gik59uGDbKt0ZgxsltGeDgwerRMj/XvD/y3Ww5lRp06UoBlZyd7RL37ruwtBXD5O5ktJkBEZHK8vIDp02V6bNkyaYD74gWwdKlcb9BAEiVOj2VC06byTcuVC1i1SpruKYpuATSRGWECREQmy94e6NcPOHlSZmq6dpXpsf37ZZuNYsUkUbp3T+1ITUS7drJbrUYDfPutNNw7eVIeYwJEZoZ7gaWBe4ERma6bN+Wz+7vvkhIfOzspbRk6VEpe6A2WLpX5RK1ixWRZHpGRy8znN0eAiMisvPWW7BYQHg6sWAH4+srCpuXL5Xq9erIH2atXakdqxN57D/j666TbXP5OZogJEBGZJXt7oE8fWcF96JCMAOXKBRw8CHTrJguaPv8cuHtX7UiN1LBhwP/+Jxnlu++qHQ1RjuMUWBo4BUZknm7flqmxb78F7tyR+2xtJSEaOhSoXl3d+IgoezgFRkSUBk9PYNIk4MYNWehUsybw8iWwciVQowbg5wesWSP3EZF5YwJERBbHzg7o2RM4elQuvXoBNjbAkSNAjx7ShXrKlIxtlE5EpokJEBFZtJo1ZeV3eDgwebKMEkVGAhMnyubnvXpJkkRE5oUJEBERAA8PYMIE2Xh19WqZDnv1CvjpJ6B2baBWLZk2S7lVFhGZJiZARETJ2NrKirFDh2QFWZ8+ct+xY0Dv3jI9NnGiFFQTkeliAkRElI7q1aWXUESE9BYqVEhWj02ZItNjPXoAhw/LjhFEZFqYABERvUHBgsC4cTI9tnYtULeu7DO2Zo3sI1qzpqwk4/QYkelgAkRElEE2NrLf2IEDskVWv36youzECaBvX9mkdfx42Y6DiIwbEyAioiyoVk12oo+IkA1XCxeWvcc+/1y6THfrBly+rHaURJQeJkBERNlQoAAwZgxw/TqwYQPQoIFMj61bB1SoAHz6KRAdrXaURJQSEyAiohyQKxfQqROwbx9w+jTQurUso//f/4DSpWW0KCFB7SiJSIsJEBFRDqtSBfjtN7mUKiUrx957T/oJHTmidnREBDABIiLSm9atgXPngC+/BJydpa+Qn5/0Frp1S+3oiCwbEyAiIj2ytQU++UQKot99V+778UeZFvviCy6dJ1ILEyAiIgPw8ACWLpWO0rVrA0+fSvF0+fLAtm1spkhkaEyAiIgMqEYN4OBBaZzo6QlcvQq0bw+0bAmEhakdHZHlYAJERGRgVlayr9ilS8Do0TJNtnMnULEiEBgIPH6sdoRE5o8JEBGRSpydgRkzgPPngbffBuLjga+/lpVjixfLbSLSDyZAREQqK1kS2LoV2LEDKFsWuH8f+OADmS47cEDt6IjMExMgIiIj4e8PnDkDzJkDuLpKQ8X69YHu3WXLDSLKOUyAiIiMiI2N1AFduQK8/z6g0cgO9D4+wNSpwPPnakdIZB6YABERGaECBaQO6MQJoF494NkzYMIEoFw5YONGLpsnyi4mQERERqxaNSAkBFizRnac/+cf2XOsaVPgr7/Ujo7IdDEBIiIychoN0K0bcPEiMH48YGcH/Pmn7Dk2ZAjw8KHaERKZHiZAREQmwskJmDJFEqGOHWV3+W++kWXzCxcCcXFqR0hkOpgAERGZmKJFgZ9/BnbvBipUkBGgwYNlumzvXrWjIzINTICIiExUkyayVH7BAiBvXqkJatwY6NwZuHFD7eiIjBsTICIiE5Yrl4z+XLkCfPSRbLPx88+ybH7CBFk9RkSpMQEiIjID+fJJPdDp00CjRsCLF9I3qEwZ6SPEZfNEupgAERGZkUqVgD17ZBTI2xv491/pJN2woSRHRCSYABERmRmNRlaJhYXJqjEHB2D/fsDXV/YYu3dP7QiJ1McEiIjITDk4SN+gS5ekj5CiSHfp0qVl1/lXr9SOkEg9TICIiMycl5d0kg4JkeaJjx/LfmNVqgDBwerGRqQWJkBERBaifn3ZW+y774D8+YELF2QH+oAA4OpVtaMjMiwmQEREFsTaGhg4ELh8GRg+XG5v3SqbrH72GRATo3aERIbBBIiIyALlzQvMnQucPQs0bw68fAnMmCHL5let4rJ5Mn9MgIiILFi5csCOHcCWLUDx4sCtW0Dv3kDdujJdRmSumAAREVk4jQZo315qgmbMkE1XDx8GatYE+veXomkic8MEiIiIAAB2dsDo0VIf1Lu3TIMtXQo0aCAjQ0TmhAkQERHpKFQIWLkSOHgQ8PSUTVbr1pX9xojMBRMgIiJKU506kgSVLAn8848kQadOqR0VUc5gAkREROkqVgw4cACoWlW20GjUSPYaIzJ1TICIiOi13N2BvXuBxo2BJ0+AVq1ks1UiU8YEiIiI3sjFBdi+XTZZffkS6NIF+PZbtaMiyjomQERElCH29sC6dbKjvKIAH34ITJ3KpolkmpgAERFRhllbA4sWyS7zADBhAjBsGJCQoG5cRJnFBIiIiDJFowGmTAHmzZPbCxYAPXvK1BiRqWACREREWTJ0KLB6NZArF7B2LdCuHTdTJdPBBIiIiLKse3fg119l+4ydO4GmTYH799WOiujNmAAREVG2tGgB7N4N5MsHHDsG1KsHhIerHRXR6zEBIiKibKtVC9i/H/DyAi5dki7SFy6oHRVR+lRPgBYuXIhixYrB3t4evr6+2L9//2uP37dvH3x9fWFvb4/ixYvj2xSNKJYvXw6NRpPq8uLFC32+DSIii1e2rGydUbYscPOmjAQdPqx2VERpUzUBWrduHQIDAzF27FicPn0a9evXR6tWrRCeztjp9evX0bp1a9SvXx+nT5/GZ599hmHDhmHjxo06x7m4uOD27ds6F3t7e0O8JSIii+blJSNBtWoBjx4BzZoBv/+udlREqWkURb0WVrVq1UK1atWwaNGixPvKli2LgIAAzJgxI9Xxo0aNwrZt2xAWFpZ436BBg3DmzBkc/u/PjOXLlyMwMBCPHz/OclzR0dFwdXVFVFQUXFxcsnweIiJL9fSpdI3esUNWiS1fLkvlifQpM5/fqo0AvXz5EidPnoS/v7/O/f7+/jh06FCazzl8+HCq41u0aIETJ07g1atXiffFxMTA29sbhQsXRtu2bXH69OmcfwNERJQuJydg2zagRw8gLg7o1Qv4+mu1oyJKoloCdP/+fcTHx8Pd3V3nfnd3d0RGRqb5nMjIyDSPj4uLw/3/1l36+Phg+fLl2LZtG9asWQN7e3vUrVsXV65cSTeW2NhYREdH61yIiCh7bG2BH38Ehg+X24GBwNix3DqDjIPqRdAajUbntqIoqe570/HJ769duzZ69eqFypUro379+li/fj1Kly6N+fPnp3vOGTNmwNXVNfHi5eWV1bdDRETJWFkBc+YA06fL7enTgYEDZVSISE2qJUD58+eHtbV1qtGeu3fvphrl0fLw8Ejz+Fy5ciFfvnxpPsfKygo1atR47QjQmDFjEBUVlXiJiIjI5LshIqL0aDTAmDHAkiWSEH3/PdC5M8DFuaQm1RIgW1tb+Pr6Ijg4WOf+4OBg1KlTJ83n+Pn5pTp+586dqF69OmxsbNJ8jqIoCA0NhaenZ7qx2NnZwcXFRedCREQ5a8AA4OefATs7YMsWoGVLICpK7ajIUqk6BRYUFITvv/8eS5cuRVhYGEaMGIHw8HAMGjQIgIzM9OnTJ/H4QYMG4caNGwgKCkJYWBiWLl2KH374AZ988kniMZMnT8aOHTtw7do1hIaGon///ggNDU08JxERqeedd4A//gCcnYF9+4CGDYF0yj6J9CqXmi/etWtXPHjwAFOmTMHt27dRoUIFbN++Hd7e3gCA27dv6/QEKlasGLZv344RI0bgm2++QaFChTBv3jx07Ngx8ZjHjx9j4MCBiIyMhKurK6pWrYqQkBDUrFnT4O+PiIhSa9RIkp+WLYEzZ4C6dWUfsRIl1I6MLImqfYCMFfsAERHp399/yz5i164B7u4yMlSlitpRkSkziT5ARERk2UqWBA4cACpXBu7ckemwffvUjoosBRMgIiJSjacnsHcv0KABEB0tI0JbtqgdFVkCJkBERKSqPHlk+qt9eyA2VrbQ+OEHtaMic8cEiIiIVOfgIEvk33sPSEiQJfNffMGu0aQ/TICIiMgo5MolTRJHj5bbY8YAH38sCRFRTmMCRERERkOjAWbMAGbPlttz5gB9+wLJ9rsmyhFMgIiIyOgEBQErV8qo0KpVUh/09KnaUZE5YQJERERGqXdvYOtWqQ/6/XegeXPg4UO1o1JHVBSwaZNMC65dCzx/rnZEpk/VTtBERESv07o1sHs30KYNcPgwUL8+sGMHULiw2pHpV3w8cPKkvNcdO4AjR+Q+LRcXoEsXmR6sW1emDilz2Ak6DewETURkXM6flx5BN28CXl6ydYaPj9pR5aybN+V97dgBBAenHu0qUwaoXVv6Jt24kXR/8eIyWtanj1y3ZJn5/GYClAYmQERExufGDcDfH7h8GciXD9i+HTDlbR5fvAD2708a5Tl3TvdxV1egaVNJ/Fq0AP7bJhMJCUBIiNRIbdgAxMQkPadePRkV6txZnm9pmABlExMgIiLjdO+eTIudOAE4OQGbN0ttkClQFCAsLCnh2bdPkiAtjQaoUSMp4alVS4rAX+fZM/kerFwpo0baT3R7eykc79tXvj9vOo+5YAKUTUyAiIiM15MnQIcOwK5dgI0N8OOPQNeuakeVtkePJM4dO2R6KyJC9/FChZISnmbNZGQrq27eBH76CVixArhwIel+d3egZ09JhipVyvr5TQEToGxiAkREZNxiY+UDfd06GTmZPx8YPFjtqIC4OOD48aRRnmPHdBs52tnJpq/apKdcuZwvYFYU4NQpGRVavRq4fz/pscqV5fvWo4ckRuaGCVA2MQEiIjJ+8fHA8OHAN9/I7QkTgEmTDL8iKiIiKeHZtQt4/Fj38XLlkhKeBg1kWb+hvHolLQRWrgR++QV4+VLut7aWePr2Bd5+W6bMzAEToGxiAkREZBoUBZg6FZg4UW4PGgQsWCAf8Pry7JnU72iTnosXdR/Pm1ems1q0kKJtLy/9xZIZDx/KiNmKFcDRo0n3u7rKFGKfPkCdOqa9pJ4JUDYxASIiMi2LFskUmKIAnTpJ92g7u5w5t6LICi1twrN/v0zBaVlZScGydpSnRg39JmA54dIlGRX68UfduqQSJSQR6t0bKFZMvfiyiglQNjEBIiIyPRs2SLHvq1dAkybAli2As3PWzvXggayq0hYv37ql+7iXV1LC07SpjPqYooQEGc1asQL4+Wfd7Ubq15cpsk6dTGdJPROgbGICRERkmnbtAt55R3rj+PpKr6CCBd/8vFevpNuythHhiRNJS8oBqdtp1Cgp6SlTxrSnitLy9KksqV+xQrpvJ19S/847MjLUrJlxL6lnApRNTICIiEzXiRPSK+jePaBUKUlqihZNfdz160nTWnv2ANHRuo9XrJiU8NSrZz6Fwhnx778yjbhihW6Nk6enjLL16SPfH2PDBCibmAAREZm2y5elAPnGDfnQ3rFDalr27k1Keq5c0X1OvnzSNFBbvFyokCqhGxVFkT3JVqwA1qyRqUGtKlVkiqx7d+NZUs8EKJuYABERmb5btySZOXcOcHSUaa5Xr5Iet7YG/PySRnmqVTP+4mU1vXwpU4orVwK//pr0vbS2Blq1klGhdu3UHSljApRNTICIiMzDo0fyoXzwoNwuWjQp4WnSxHSKe43N/fuypH7lSmn2qJUnT9KSej8/w9dJMQHKJiZARETm48ULaQZYvrzUBJlb8bLawsJkOf2PP0rtkFbJkklL6tOqwdIHJkDZxASIiIgoc+LjpcZq5Upg40bdJfUNG0oy1KkToM+PVSZA2cQEiIiIKOtiYoBNm6R4+s8/k5bUOzjoLqnP6ZorJkDZxASIiIgoZ4SHJ+1Sf+lS0v2lS8v0mZVVzr1WZj6/c/BliYiIiHQVKQKMGSPJztGjsmWJmxtQu3bOJj+ZxRGgNHAEiIiISH9iY6XxZIECOXtejgARERGR0bKzy/nkJ7OYABEREZHFYQJEREREFocJEBEREVkcJkBERERkcZgAERERkcVhAkREREQWhwkQERERWRwmQERERGRxmAARERGRxWECRERERBaHCRARERFZHCZAREREZHGYABEREZHFyaV2AMZIURQAQHR0tMqREBERUUZpP7e1n+OvwwQoDU+ePAEAeHl5qRwJERERZdaTJ0/g6ur62mM0SkbSJAuTkJCAW7duwdnZGRqNRu1wjFJ0dDS8vLwQEREBFxcXtcOxePz3MC789zA+/DcxLvr691AUBU+ePEGhQoVgZfX6Kh+OAKXBysoKhQsXVjsMk+Di4sJfJkaE/x7Ghf8exof/JsZFH/8ebxr50WIRNBEREVkcJkBERERkcZgAUZbY2dlh4sSJsLOzUzsUAv89jA3/PYwP/02MizH8e7AImoiIiCwOR4CIiIjI4jABIiIiIovDBIiIiIgsDhMgIiIisjhMgCjDZsyYgRo1asDZ2RkFCxZEQEAALl26pHZY9J8ZM2ZAo9EgMDBQ7VAs2s2bN9GrVy/ky5cPjo6OqFKlCk6ePKl2WBYpLi4O48aNQ7FixeDg4IDixYtjypQpSEhIUDs0ixASEoJ27dqhUKFC0Gg02LJli87jiqJg0qRJKFSoEBwcHNCoUSOcP3/eYPExAaIM27dvHwYPHowjR44gODgYcXFx8Pf3x9OnT9UOzeIdP34cixcvRqVKldQOxaI9evQIdevWhY2NDX7//XdcuHABs2fPRp48edQOzSLNnDkT3377LRYsWICwsDDMmjULX375JebPn692aBbh6dOnqFy5MhYsWJDm47NmzcJXX32FBQsW4Pjx4/Dw8EDz5s0T9+PUNy6Dpyy7d+8eChYsiH379qFBgwZqh2OxYmJiUK1aNSxcuBCff/45qlSpgrlz56odlkUaPXo0Dh48iP3796sdCgFo27Yt3N3d8cMPPyTe17FjRzg6OuLHH39UMTLLo9FosHnzZgQEBACQ0Z9ChQohMDAQo0aNAgDExsbC3d0dM2fOxAcffKD3mDgCRFkWFRUFAHBzc1M5Ess2ePBgtGnTBs2aNVM7FIu3bds2VK9eHZ07d0bBggVRtWpVLFmyRO2wLFa9evWwe/duXL58GQBw5swZHDhwAK1bt1Y5Mrp+/ToiIyPh7++feJ+dnR0aNmyIQ4cOGSQGboZKWaIoCoKCglCvXj1UqFBB7XAs1tq1a3Hq1CkcP35c7VAIwLVr17Bo0SIEBQXhs88+w7FjxzBs2DDY2dmhT58+aodncUaNGoWoqCj4+PjA2toa8fHxmDZtGrp37652aBYvMjISAODu7q5zv7u7O27cuGGQGJgAUZYMGTIEZ8+exYEDB9QOxWJFRERg+PDh2LlzJ+zt7dUOhwAkJCSgevXqmD59OgCgatWqOH/+PBYtWsQESAXr1q3DqlWrsHr1apQvXx6hoaEIDAxEoUKF0LdvX7XDI8jUWHKKoqS6T1+YAFGmDR06FNu2bUNISAgKFy6sdjgW6+TJk7h79y58fX0T74uPj0dISAgWLFiA2NhYWFtbqxih5fH09ES5cuV07itbtiw2btyoUkSW7dNPP8Xo0aPRrVs3AEDFihVx48YNzJgxgwmQyjw8PADISJCnp2fi/Xfv3k01KqQvrAGiDFMUBUOGDMGmTZuwZ88eFCtWTO2QLFrTpk3x119/ITQ0NPFSvXp19OzZE6GhoUx+VFC3bt1UrSEuX74Mb29vlSKybM+ePYOVle7HnLW1NZfBG4FixYrBw8MDwcHBife9fPkS+/btQ506dQwSA0eAKMMGDx6M1atXY+vWrXB2dk6cw3V1dYWDg4PK0VkeZ2fnVPVXTk5OyJcvH+uyVDJixAjUqVMH06dPR5cuXXDs2DEsXrwYixcvVjs0i9SuXTtMmzYNRYoUQfny5XH69Gl89dVXeO+999QOzSLExMTg77//Trx9/fp1hIaGws3NDUWKFEFgYCCmT5+OUqVKoVSpUpg+fTocHR3Ro0cPwwSoEGUQgDQvy5YtUzs0+k/Dhg2V4cOHqx2GRfvll1+UChUqKHZ2doqPj4+yePFitUOyWNHR0crw4cOVIkWKKPb29krx4sWVsWPHKrGxsWqHZhH+/PPPND8z+vbtqyiKoiQkJCgTJ05UPDw8FDs7O6VBgwbKX3/9ZbD42AeIiIiILA5rgIiIiMjiMAEiIiIii8MEiIiIiCwOEyAiIiKyOEyAiIiIyOIwASIiIiKLwwSIiIiILA4TICKiDNBoNNiyZYvaYRBRDmECRERGr1+/ftBoNKkuLVu2VDs0IjJR3AuMiExCy5YtsWzZMp377OzsVIqGiEwdR4CIyCTY2dnBw8ND55I3b14AMj21aNEitGrVCg4ODihWrBg2bNig8/y//voLTZo0gYODA/Lly4eBAwciJiZG55ilS5eifPnysLOzg6enJ4YMGaLz+P379/HOO+/A0dERpUqVwrZt2/T7polIb5gAEZFZGD9+PDp27IgzZ86gV69e6N69O8LCwgAAz549Q8uWLZE3b14cP34cGzZswK5du3QSnEWLFmHw4MEYOHAg/vrrL2zbtg0lS5bUeY3JkyejS5cuOHv2LFq3bo2ePXvi4cOHBn2fRJRDDLbtKhFRFvXt21extrZWnJycdC5TpkxRFEVRACiDBg3SeU6tWrWUDz/8UFEURVm8eLGSN29eJSYmJvHx3377TbGyslIiIyMVRVGUQoUKKWPHjk03BgDKuHHjEm/HxMQoGo1G+f3333PsfRKR4bAGiIhMQuPGjbFo0SKd+9zc3BKv+/n56Tzm5+eH0NBQAEBYWBgqV64MJyenxMfr1q2LhIQEXLp0CRqNBrdu3ULTpk1fG0OlSpUSrzs5OcHZ2Rl3797N6lsiIhUxASIik+Dk5JRqSupNNBoNAEBRlMTraR3j4OCQofPZ2Nikem5CQkKmYiIi48AaICIyC0eOHEl128fHBwBQrlw5hIaG4unTp4mPHzx4EFZWVihdujScnZ1RtGhR7N6926AxE5F6OAJERCYhNjYWkZGROvflypUL+fPnBwBs2LAB1atXR7169fDTTz/h2LFj+OGHHwAAPXv2xMSJE9G3b19MmjQJ9+7dw9ChQ9G7d2+4u7sDACZNmoRBgwahYMGCaNWqFZ48eYKDBw9i6NChhn2jRGQQTICIyCT88ccf8PT01LmvTJkyuHjxIgBZobV27Vp89NFH8PDwwE8//YRy5coBABwdHbFjxw4MHz4cNWrUgKOjIzp27Iivvvoq8Vx9+/bFixcvMGfOHHzyySfInz8/OnXqZLg3SEQGpVEURVE7CCKi7NBoNNi8eTMCAgLUDoWITARrgIiIiMjiMAEiIiIii8MaICIyeZzJJ6LM4ggQERERWRwmQERERGRxmAARERGRxWECRERERBaHCRARERFZHCZAREREZHGYABEREZHFYQJEREREFocJEBEREVmc/wODMr3wfuY1+gAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "67"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#----------Инициализируем модель и параметры обучения--------------\n",
    "\n",
    "torch.cuda.empty_cache()\n",
    "cv2.destroyAllWindows()\n",
    "gc.collect()\n",
    "\n",
    "config_name = \"ensemble\"\n",
    "    \n",
    "def load_function(attr):\n",
    "    module_, func = attr.rsplit('.', maxsplit=1)\n",
    "    return getattr(import_module(module_), func)\n",
    "    \n",
    "config = mlconfig.load('config_' + config_name + '.yaml')\n",
    "\n",
    "model = models.resnet18(pretrained=True)\n",
    "\n",
    "num_classes = 2\n",
    "\n",
    "model.fc = nn.Linear(model.fc.in_features, num_classes)\n",
    "\n",
    "class Model(nn.Module):\n",
    "    def __init__(self, model):\n",
    "        super(Model, self).__init__()\n",
    "        self.model = model\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.model(x)\n",
    "        return x\n",
    "\n",
    "model = Model(model)\n",
    "\n",
    "optimizer = load_function(config.optimizer.name)(model.parameters(), lr=config.optimizer.lr)\n",
    "criterion = load_function(config.loss_function.name)()\n",
    "scheduler = load_function(config.scheduler.name)(optimizer, step_size=config.scheduler.step_size, gamma=config.scheduler.gamma)\n",
    "\n",
    "if device != 'cpu':\n",
    "    model = model.to(device)\n",
    "\n",
    "#----------Создания датасета и обучение модели--------------\n",
    "\n",
    "path_res, model_name = prepare_and_learning_detection(num_classes = num_classes, num_samples = 20000, path_dataset = \"C:/Users/snytk/Lerning_NN_for_work/datasets_jpg/1.2_jpg_learning/\", \n",
    "                     model_name = config_name+\"_1.2_jpg_\", config_name = config_name, model=model)\n",
    "\n",
    "\n",
    "torch.cuda.empty_cache()\n",
    "cv2.destroyAllWindows()\n",
    "del model\n",
    "gc.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4234ee26",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Отсутствует",
  "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.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}