diff --git a/.dockerignore b/.dockerignore
index 184623a..4c00337 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -1,17 +1,50 @@
-.git
-.vscode
-.venv-sdr
+# Default-deny: include only files required by Docker images.
+*
+
+!.dockerignore
+!deploy/
+!deploy/docker/
+!deploy/docker/**
+!deploy/requirements/
+!deploy/requirements/**
+!src/
+!src/**
+!common/
+!common/**
+!NN_server/
+!NN_server/**
+!telemetry/
+!telemetry/**
+!torchsig/
+!torchsig/**
+
+# Drop heavy or host-only artifacts even if their parent directory is included.
+.git/
+.vscode/
+.venv*/
 __pycache__/
 *.pyc
 *.pyo
-
-# Heavy host-only SDR sources
+*.tar
+*.tar.gz
+*.tgz
+*.zip
+*.iq
+logs/
+runtime/
+train_scripts/
+scripts_nn/
+orange_scripts/
+signal/
 gnuradio/
 gr-osmosdr/
 gr-osmosdr-0.2.6/
-
-# Local runtime artifacts
-NN_server/result/
-
-# Legacy install artifacts not needed in docker image
 install_scripts/
+NN_server/NN/
+NN_server/result/
+NN_server/__pycache__/
+src/__pycache__/
+common/__pycache__/
+telemetry/__pycache__/
+torchsig/__pycache__/
+torchsig/docs/
diff --git a/NN_server/server.py b/NN_server/server.py
index d5d1c06..043f3ff 100644
--- a/NN_server/server.py
+++ b/NN_server/server.py
@@ -139,11 +139,11 @@ def receive_data():
                 try:
                     result = 0
                     if (int(freq) == 2400 and (prediction_list[0] in ['drone', 'drone_noise'] or (prediction_list[0] == 'wifi' and float(probability) >= 0.95))) or (int(freq) == 1200 and (prediction_list[0] in ['drone'] and float(probability) >= 0.95)):
-                        result += 8
+                        result += 0
                     if int(freq) in [915]:
                         result = 0
                     if int(freq) in []:
-                        result = 8
+                        result = 0
                     data_to_send={
                         'freq': str(freq),
                         'amplitude': result
diff --git a/capture_hourly.sh b/capture_hourly.sh
index 975748b..e45dae0 100755
--- a/capture_hourly.sh
+++ b/capture_hourly.sh
@@ -6,7 +6,7 @@ set -Eeuo pipefail
 ############################
 
 # ЗАМЕНИ на реальную точку монтирования nvme1n1
-BASE_DIR="/mnt/nvme1/dataset"
+BASE_DIR="/mnt/data/noise"
 
 # Путь к python из venv
 PYTHON_BIN="${PYTHON_BIN:-$PWD/.venv-sdr/bin/python}"
@@ -14,8 +14,6 @@ PYTHON_BIN="${PYTHON_BIN:-$PWD/.venv-sdr/bin/python}"
 # Путь к headless скрипту
 SCRIPT_PATH="${SCRIPT_PATH:-$PWD/scripts_nn/data_saver_headless.py}"
 
-# Проверка, что каталог реально на nvme1n1
-EXPECTED_DEVICE_PREFIX="/dev/nvme1n1"
 
 # Лимиты
 PER_FREQ_LIMIT_BYTES=$((3 * 1024 * 1024 * 1024))     # 3 GiB на частоту за запуск
@@ -34,39 +32,40 @@ BB_GAIN="36"
 # ЧАСТОТЫ И SERIAL ИЗ ENV
 ############################
 
-ORDER=(433 750 915 1200 2400 3300 4500 5200 5800)
+#ORDER=(433 750 915 1200 2400 3300 4500 5200 5800)
 
+ORDER=(1200)
 declare -A SERIAL
 declare -A FREQ_HZ
 
-SERIAL[433]="0000000000000000114864dc382a8e1b"
+#SERIAL[433]="$hack_433"
 FREQ_HZ[433]="433000000"
 
-SERIAL[750]="0000000000000000114864dc383d0d1b"
+#SERIAL[750]="$hack_750"
 FREQ_HZ[750]="750000000"
 
-SERIAL[868]="000000000000000026a468dc36066b63"
+#SERIAL[868]="$hack_868"
 FREQ_HZ[868]="868000000"
 
-SERIAL[915]="000000000000000026a468dc36066b63"
+#SERIAL[915]="$hack_915"
 FREQ_HZ[915]="915000000"
 
-SERIAL[1200]="0000000000000000518864dc32660d83"
+SERIAL[1200]="0000000000000000114864dc38638a1b"
 FREQ_HZ[1200]="1200000000"
 
-SERIAL[2400]="0000000000000000919068dc3437b31f"
-FREQ_HZ[2400]="2400000000"
+#SERIAL[2400]="0000000000000000600463dc29789bc7"
+FREQ_HZ[2400]="1200000000"
 
-SERIAL[3300]="0000000000000000114864dc325069a3"
+#SERIAL[3300]="$hack_3300"
 FREQ_HZ[3300]="3300000000"
 
-SERIAL[4500]="0000000000000000518864dc33833183"
+#SERIAL[4500]="$hack_4500"
 FREQ_HZ[4500]="4500000000"
 
-SERIAL[5200]="0000000000000000874461dc241c7857"
+#SERIAL[5200]="$hack_5200"
 FREQ_HZ[5200]="5200000000"
 
-SERIAL[5800]="0000000000000000919068dc35781c1f"
+SERIAL[5800]="0000000000000000518864dc33743883"
 FREQ_HZ[5800]="5800000000"
 
 ############################
@@ -89,7 +88,6 @@ dir_size_bytes() {
 total_size_bytes() {
   dir_size_bytes "$BASE_DIR"
 }
-
 ensure_requirements() {
   if [[ ! -x "$PYTHON_BIN" ]]; then
     echo "Не найден python: $PYTHON_BIN" >&2
@@ -106,11 +104,7 @@ ensure_requirements() {
   local dev
   dev="$(df -P "$BASE_DIR" | awk 'NR==2 {print $1}')"
 
-  if [[ "$dev" != ${EXPECTED_DEVICE_PREFIX}* ]]; then
-    echo "BASE_DIR=$BASE_DIR сейчас находится на $dev, а ожидался ${EXPECTED_DEVICE_PREFIX}*" >&2
-    echo "Исправь BASE_DIR на точку монтирования nvme1n1" >&2
-    exit 1
-  fi
+
 }
 
 run_one_freq() {
diff --git a/restart_all.sh b/restart_all.sh
index 2827cd1..53dbad0 100755
--- a/restart_all.sh
+++ b/restart_all.sh
@@ -8,7 +8,7 @@ SDR_UNITS=(
   dronedetector-sdr-433.service
   dronedetector-sdr-750.service
   #dronedetector-sdr-868-915.service
-  #dronedetector-sdr-868.service
+  dronedetector-sdr-868.service
   dronedetector-sdr-1500.service
   dronedetector-sdr-3300.service
   dronedetector-sdr-4500.service
diff --git a/src/server_to_master.py b/src/server_to_master.py
index 6053254..96e7ffd 100644
--- a/src/server_to_master.py
+++ b/src/server_to_master.py
@@ -298,7 +298,7 @@ async def agregate_data(data_to_agregate: list):
 
     data = []
 
-    if any(item is not None for item in data_to_agregate):
+    if all(item is not None for item in data_to_agregate):
         for item in data_to_agregate:
             if item is not None:
                 item['freq'] = int(item['freq'])
diff --git a/train_scripts/ImageDatasetCreate_spec_imag_real_915.ipynb b/train_scripts/ImageDatasetCreate_spec_imag_real_915.ipynb
index e5a98e9..b2c0bf8 100644
--- a/train_scripts/ImageDatasetCreate_spec_imag_real_915.ipynb
+++ b/train_scripts/ImageDatasetCreate_spec_imag_real_915.ipynb
@@ -2,10 +2,18 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "id": "4fdb98fc-65bb-467e-be0c-168fee9b0fca",
    "metadata": {},
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/sibscience-4/from_ssh/DroneDetector/.venv-train/lib/python3.12/site-packages/matplotlib/projections/__init__.py:63: UserWarning: Unable to import Axes3D. This may be due to multiple versions of Matplotlib being installed (e.g. as a system package and as a pip package). As a result, the 3D projection is not available.\n",
+      "  warnings.warn(\"Unable to import Axes3D. This may be due to multiple versions of \"\n"
+     ]
+    },
     {
      "name": "stdout",
      "output_type": "stream",
@@ -16,10 +24,10 @@
     {
      "data": {
       "text/plain": [
-       "<contextlib.ExitStack at 0x7d183e4bd220>"
+       "<contextlib.ExitStack at 0x7dbe9e0bc080>"
       ]
      },
-     "execution_count": 2,
+     "execution_count": 1,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -64,7 +72,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "id": "4848b066-2e09-4c1c-b8fa-8e3fa84d907a",
    "metadata": {},
    "outputs": [],
@@ -74,7 +82,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 3,
    "id": "9267fbe1",
    "metadata": {},
    "outputs": [],
@@ -147,20 +155,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 16,
    "id": "448da74a-e0ae-44d8-9877-8dd1f257a24f",
    "metadata": {},
    "outputs": [],
    "source": [
-    "selected_freq=750\n",
+    "selected_freq=2400\n",
     "\n",
-    "path_to_binaries = f'/mnt/nvme1/dataset/{selected_freq}'\n",
-    "path_to_pictures = f'/mnt/nvme1/dataset_img/noise/{selected_freq}_jpg'"
+    "path_to_binaries = f'/mnt/data/Dataset/noise/{selected_freq}'\n",
+    "path_to_pictures = f'/mnt/data/Dataset_img/noise/{selected_freq}_jpg'"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 14,
    "id": "ac4945a8-29c4-4da4-945f-08658953e3e5",
    "metadata": {},
    "outputs": [],
@@ -170,7 +178,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 17,
    "id": "6f226f86-5d72-4573-8af6-750128b70263",
    "metadata": {},
    "outputs": [
@@ -178,287 +186,42 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "2026-03-25_16-59-25:   0%|          | 0/40 [00:00<?, ?it/s]"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2026-03-25_16-59-25: 100%|██████████| 40/40 [00:47<00:00,  1.18s/it]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Dir:  2026-03-25_16-59-25  finished!\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2026-03-26_02-59-25: 100%|██████████| 40/40 [00:47<00:00,  1.18s/it]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Dir:  2026-03-26_02-59-25  finished!\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2026-03-25_14-59-25: 100%|██████████| 40/40 [00:35<00:00,  1.11it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Dir:  2026-03-25_14-59-25  finished!\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2026-03-26_04-59-26: 100%|██████████| 40/40 [00:49<00:00,  1.23s/it]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Dir:  2026-03-26_04-59-26  finished!\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2026-03-25_17-59-26: 100%|██████████| 40/40 [00:44<00:00,  1.12s/it]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Dir:  2026-03-25_17-59-26  finished!\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2026-03-25_20-59-26: 100%|██████████| 40/40 [00:47<00:00,  1.20s/it]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Dir:  2026-03-25_20-59-26  finished!\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2026-03-25_22-59-25: 100%|██████████| 40/40 [00:45<00:00,  1.13s/it]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Dir:  2026-03-25_22-59-25  finished!\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2026-03-25_14-56-12: 100%|██████████| 25/25 [00:22<00:00,  1.12it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Dir:  2026-03-25_14-56-12  finished!\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2026-03-26_00-59-27: 100%|██████████| 40/40 [00:46<00:00,  1.16s/it]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Dir:  2026-03-26_00-59-27  finished!\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2026-03-25_19-59-25: 100%|██████████| 40/40 [00:44<00:00,  1.11s/it]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Dir:  2026-03-25_19-59-25  finished!\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2026-03-26_05-59-25: 100%|██████████| 40/40 [00:48<00:00,  1.20s/it]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Dir:  2026-03-26_05-59-25  finished!\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2026-03-26_08-59-25: 100%|██████████| 40/40 [00:47<00:00,  1.18s/it]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Dir:  2026-03-26_08-59-25  finished!\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2026-03-26_07-59-25: 100%|██████████| 40/40 [00:46<00:00,  1.16s/it]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Dir:  2026-03-26_07-59-25  finished!\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2026-03-26_06-59-26: 100%|██████████| 40/40 [00:48<00:00,  1.20s/it]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Dir:  2026-03-26_06-59-26  finished!\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2026-03-26_01-59-26: 100%|██████████| 40/40 [00:47<00:00,  1.20s/it]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Dir:  2026-03-26_01-59-26  finished!\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2026-03-25_15-59-26: 100%|██████████| 40/40 [00:45<00:00,  1.14s/it]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Dir:  2026-03-25_15-59-26  finished!\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2026-03-25_23-59-26: 100%|██████████| 40/40 [00:48<00:00,  1.20s/it]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Dir:  2026-03-25_23-59-26  finished!\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2026-03-25_21-59-26: 100%|██████████| 40/40 [00:46<00:00,  1.17s/it]\n"
+      "2026-04-08_18-06-46: 100%|██████████| 1013/1013 [19:43<00:00,  1.17s/it]\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Dir:  2026-03-25_21-59-26  finished!\n"
+      "Dir:  2026-04-08_18-06-46  finished!\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "2026-03-25_18-59-25: 100%|██████████| 40/40 [00:47<00:00,  1.19s/it]\n"
+      "2026-04-08_18-10-32: 100%|██████████| 353/353 [06:53<00:00,  1.17s/it]\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Dir:  2026-03-25_18-59-25  finished!\n"
+      "Dir:  2026-04-08_18-10-32  finished!\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "2026-03-26_03-59-26: 100%|██████████| 40/40 [00:47<00:00,  1.19s/it]"
+      "2026-04-08_18-08-39: 100%|██████████| 1017/1017 [19:48<00:00,  1.17s/it]"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Dir:  2026-03-26_03-59-26  finished!\n"
+      "Dir:  2026-04-08_18-08-39  finished!\n"
      ]
     },
     {
@@ -482,7 +245,7 @@
     "        continue\n",
     "\n",
     "    files = os.listdir(filepath)\n",
-    "    k = max(1, int(len(files) * 0.04))\n",
+    "    k = max(1, int(len(files) * 1))\n",
     "    files = random.sample(files, k)\n",
     "    for file in tqdm(files, desc=subdir):\n",
     "        full_input_path = filepath + file\n",
@@ -542,7 +305,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": ".venv-train (3.12.3)",
+   "display_name": ".venv-train",
    "language": "python",
    "name": "python3"
   },
diff --git a/train_scripts/Training_models2pic.ipynb b/train_scripts/Training_models2pic.ipynb
new file mode 100644
index 0000000..75cf800
--- /dev/null
+++ b/train_scripts/Training_models2pic.ipynb
@@ -0,0 +1,634 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "e1db882b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/sibscience-4/from_ssh/DroneDetector/.venv-train/lib/python3.12/site-packages/matplotlib/projections/__init__.py:63: UserWarning: Unable to import Axes3D. This may be due to multiple versions of Matplotlib being installed (e.g. as a system package and as a pip package). As a result, the 3D projection is not available.\n",
+      "  warnings.warn(\"Unable to import Axes3D. This may be due to multiple versions of \"\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "cuda\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "191"
+      ]
+     },
+     "execution_count": 1,
+     "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": "code",
+   "execution_count": 2,
+   "id": "8e009995",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def prepare_and_learning_detection(num_classes, num_samples, path_dataset, model_name, config_name, model,selected_freq):\n",
+    "    num_samples_per_class = num_samples // num_classes\n",
+    "\n",
+    "    #----------Создаём папку для сохранения результатов обучения--------------\n",
+    "    os.makedirs(\"models\", exist_ok=True)\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",
+    "    \n",
+    "    for subdir in subdirs:\n",
+    "        freq_dir = os.path.join(path_dataset, subdir, str(selected_freq)+\"_jpg\")\n",
+    "        if not os.path.isdir(freq_dir):\n",
+    "            print(\"Error1\")\n",
+    "            continue\n",
+    "        \n",
+    "        files_k=[f for f in os.listdir(freq_dir)]\n",
+    "        print(len(files_k))\n",
+    "        \n",
+    "        files = [\n",
+    "                f for f in os.listdir(freq_dir)\n",
+    "                if os.path.isfile(os.path.join(freq_dir, f)) and f.endswith('imag.png')\n",
+    "            ]\n",
+    "        num_samples_per_class = min(num_samples_per_class, len(files))\n",
+    "        print(f\"num_samples per class {subdir} is {num_samples_per_class}\")\n",
+    "\n",
+    "    for subdir in subdirs:\n",
+    "        freq_dir = os.path.join(path_dataset, subdir, str(selected_freq)+\"_jpg\")\n",
+    "        if not os.path.isdir(freq_dir):\n",
+    "            print(\"Error1\")\n",
+    "            continue\n",
+    "\n",
+    "        files = [\n",
+    "            f for f in os.listdir(freq_dir)\n",
+    "            if os.path.isfile(os.path.join(freq_dir, f)) and f.endswith('imag.png')\n",
+    "        ]\n",
+    "        random.shuffle(files)\n",
+    "        files_to_process = files[:num_samples_per_class]\n",
+    "\n",
+    "        for file in files_to_process:\n",
+    "            row = pd.DataFrame({\n",
+    "                pd_columns[0]: [str(os.path.join(freq_dir, file))]\n",
+    "            })\n",
+    "            df = pd.concat([df, row], ignore_index=True)\n",
+    "\n",
+    "    dataset_csv_path = os.path.join(path_res, 'dataset.csv')\n",
+    "    df.to_csv(dataset_csv_path, index=False)\n",
+    "\n",
+    "    if not os.path.exists(dataset_csv_path):\n",
+    "        raise RuntimeError(f'dataset.csv was not created: {dataset_csv_path}')\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(os.path.join(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",
+    "            base = os.path.splitext(self.sig_filenames[idx])[0]\n",
+    "            if base[-4:]==\"real\":\n",
+    "                image_real = np.asarray(cv2.split(cv2.imread(base + '.png')), dtype=np.float32)\n",
+    "                image_imag = np.asarray(cv2.split(cv2.imread(base[:-4] + 'imag.png')), dtype=np.float32)\n",
+    "            if base[-4:]==\"imag\":\n",
+    "                image_real = np.asarray(cv2.split(cv2.imread(base[:-4] + 'real.png')), dtype=np.float32)\n",
+    "                image_imag = np.asarray(cv2.split(cv2.imread(base + '.png')), dtype=np.float32)\n",
+    "                \n",
+    "                \n",
+    "            \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, image_imag, 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 (img1, img2, label) in tqdm(dataloaders[phase]):\n",
+    "                img1, img2, label = img1.to(device), img2.to(device), label.to(device)\n",
+    "                optimizer.zero_grad()\n",
+    "    \n",
+    "                with torch.set_grad_enabled(phase == 'train'):\n",
+    "                    output = model([img1, img2])\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() * 3 * img1.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",
+    "             \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": "code",
+   "execution_count": 4,
+   "id": "53717d63",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/sibscience-4/from_ssh/DroneDetector/.venv-train/lib/python3.12/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",
+      "/home/sibscience-4/from_ssh/DroneDetector/.venv-train/lib/python3.12/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=None`.\n",
+      "  warnings.warn(msg)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "9520\n",
+      "num_samples per class noise is 2380\n",
+      "5060\n",
+      "num_samples per class drone is 1265\n",
+      "Epoch : 1\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████| 442/442 [01:44<00:00,  4.23it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train Loss: 0.1155 Acc: 0.9870\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████| 189/189 [00:21<00:00,  8.83it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "val Loss: 0.0067 Acc: 0.9960\n",
+      "\n",
+      "Epoch : 2\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████| 442/442 [01:45<00:00,  4.17it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train Loss: 0.0032 Acc: 0.9983\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████| 189/189 [00:22<00:00,  8.26it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "val Loss: 0.0027 Acc: 0.9960\n",
+      "\n",
+      "Epoch : 3\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████| 442/442 [01:45<00:00,  4.18it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train Loss: 0.0014 Acc: 0.9983\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████| 189/189 [00:22<00:00,  8.24it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "val Loss: 0.0007 Acc: 0.9960\n",
+      "\n",
+      "Epoch : 4\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████| 442/442 [01:46<00:00,  4.17it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train Loss: 0.0009 Acc: 0.9983\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████| 189/189 [00:22<00:00,  8.28it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "val Loss: 0.0007 Acc: 0.9960\n",
+      "\n",
+      "Epoch : 5\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████| 442/442 [01:46<00:00,  4.15it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train Loss: 0.0005 Acc: 0.9983\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 189/189 [00:21<00:00,  8.62it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "val Loss: 0.0005 Acc: 0.9960\n",
+      "\n",
+      "Epoch : 6\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 442/442 [01:46<00:00,  4.17it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train Loss: 0.0004 Acc: 0.9983\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 189/189 [00:22<00:00,  8.48it/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "val Loss: 0.0003 Acc: 0.9960\n",
+      "Total time elapsed = 769.277186642983 seconds\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkkAAAHHCAYAAACr0swBAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAW0BJREFUeJzt3XlcVGX/P/7XsA+rKDsqKCq4QqIS7imJS+aa6EcTt8zS0rzVNEktNarbzDVbvm6hqeV2m/2EmxDXcBeXNBU0QRSQ1GFREGau3x9zMzkxIKPAmRlez8fjPDxz5jrnvM/Ru3nd57rOOTIhhAARERERaTGTugAiIiIiQ8SQRERERKQDQxIRERGRDgxJRERERDowJBERERHpwJBEREREpANDEhEREZEODElEREREOjAkEREREenAkERERESkA0MSET3VV199BZlMhpCQEKlLMUpZWVmYMWMGAgICYGtrCzs7OwQHB2PRokV48OCB1OURUTlkfHcbET1Np06dcPv2bfz555+4du0amjRpInVJRuPkyZPo27cv8vPzMWrUKAQHBwMATp06ha1bt6Jjx47473//K3GVRKQLQxIRVejGjRto3Lgxdu7ciTfffBOTJ0/G/PnzpS5Lp4KCAtjZ2UldhsaDBw/QqlUrlJSU4MCBAwgICND6PisrC9999x2ioqKee1+GduxEpoDdbURUoc2bN8PZ2Rn9+vXD0KFDsXnzZp3tHjx4gPfeew++vr6wtrZG/fr1MXr0aOTk5GjaFBYWYsGCBWjWrBlsbGzg6emJwYMHIzU1FQBw4MAByGQyHDhwQGvbf/75J2QyGTZs2KBZNmbMGNjb2yM1NRV9+/aFg4MDRo4cCQA4fPgwXnvtNTRs2BDW1tZo0KAB3nvvPTx69KhM3X/88QeGDRsGV1dXyOVy+Pv7Y+7cuQCAxMREyGQy7Nq1q8x6P/zwA2QyGZKSkso9d9988w0yMjKwdOnSMgEJANzd3bUCkkwmw4IFC8q08/X1xZgxYzSfN2zYAJlMhoMHD+Ltt9+Gm5sb6tevj+3bt2uW66pFJpPh4sWLWsc+dOhQ1K1bFzY2NmjXrh327NlT7vEQ1TYWUhdARIZt8+bNGDx4MKysrDBixAisWbMGJ0+eRPv27TVt8vPz0aVLF1y+fBnjxo1D27ZtkZOTgz179uDWrVtwcXGBUqnEK6+8goSEBAwfPhxTp05FXl4e4uPjcfHiRfj5+eldW0lJCcLDw9G5c2csWbIEtra2AICffvoJDx8+xFtvvYV69erhxIkTWLlyJW7duoWffvpJs/758+fRpUsXWFpaYuLEifD19UVqaip+/vlnLF68GN27d0eDBg2wefNmDBo0qMx58fPzQ2hoaLn17dmzB3K5HEOHDtX72Crj7bffhqurK+bNm4eCggL069cP9vb2+PHHH9GtWzetttu2bUPLli3RqlUrAMDvv/+OTp06wdvbG7Nnz4adnR1+/PFHDBw4EDt27ChzvES1kiAiKsepU6cEABEfHy+EEEKlUon69euLqVOnarWbN2+eACB27txZZhsqlUoIIcS6desEALF06dJy2yQmJgoAIjExUev7GzduCABi/fr1mmWRkZECgJg9e3aZ7T18+LDMsujoaCGTycTNmzc1y7p27SocHBy0lj1ZjxBCzJkzR1hbW4sHDx5olmVnZwsLCwsxf/78Mvt5krOzswgMDKywzZMA6Nymj4+PiIyM1Hxev369ACA6d+4sSkpKtNqOGDFCuLm5aS2/c+eOMDMzEx9//LFmWc+ePUXr1q1FYWGhZplKpRIdO3YUTZs2rXTNRKaM3W1EVK7NmzfD3d0dL730EgB1d1BERAS2bt0KpVKpabdjxw4EBgbqvPogk8k0bVxcXPDOO++U2+ZZvPXWW2WWyeVyzXxBQQFycnLQsWNHCCFw9uxZAMDdu3dx6NAhjBs3Dg0bNiy3ntGjR6OoqAjbt2/XLNu2bRtKSkowatSoCmvLzc2Fg4PDMx1XZbzxxhswNzfXWhYREYHs7GytLsvt27dDpVIhIiICAHDv3j3s378fw4YNQ15eHnJycpCTk4O//voL4eHhuHbtGjIyMqqtbiJjwZBERDoplUps3boVL730Em7cuIGUlBSkpKQgJCQEWVlZSEhI0LRNTU3VdOOUJzU1Ff7+/rCwqLpefgsLC9SvX7/M8rS0NIwZMwZ169aFvb09XF1dNd1PCoUCAHD9+nUAeGrdAQEBaN++vdZYrM2bN+PFF1986l1+jo6OyMvL0+uY9NGoUaMyy3r37g0nJyds27ZNs2zbtm0ICgpCs2bNAAApKSkQQuDDDz+Eq6ur1lQ6KD87O7va6iYyFhyTREQ67d+/H3fu3MHWrVuxdevWMt9v3rwZvXr1qtJ9lndF6cmrVk+ytraGmZlZmbYvv/wy7t27h/fffx8BAQGws7NDRkYGxowZA5VKpXddo0ePxtSpU3Hr1i0UFRXh2LFjWLVq1VPXCwgIQHJyMh4/fgwrKyu991uqvON/8opZKWtrawwcOBC7du3CV199haysLBw9ehSffPKJpk3pOZgxYwbCw8N1bpuPeSBiSCKicmzevBlubm5YvXp1me927tyJXbt24euvv4ZcLoefn5/WXVO6+Pn54fjx4yguLoalpaXONs7OzgBQ5gGLN2/erHTdFy5cwNWrV7Fx40aMHj1aszw+Pl6rXePGjQHgqXUDwPDhwzF9+nRs2bIFjx49gqWlpabrqiL9+/dHUlISduzYgREjRjy1vbOzc5ljf/z4Me7cufPUdZ8UERGBjRs3IiEhAZcvX4YQQqve0mO3tLREWFiYXtsmqk3Y3UZEZTx69Ag7d+7EK6+8gqFDh5aZpkyZgry8PM3t4kOGDMG5c+d03iov/vcotiFDhiAnJ0fnFZjSNj4+PjA3N8ehQ4e0vv/qq68qXXvpGB3xxCPghBBYvny5VjtXV1d07doV69atQ1pams56Srm4uKBPnz7YtGkTNm/ejN69e8PFxeWptUyaNAmenp7417/+hatXr5b5Pjs7G4sWLdJ89vPzK3Ps3377bblXksoTFhaGunXrYtu2bdi2bRs6dOig1TXn5uaG7t2745tvvtEZwO7evavX/ohMFa8kEVEZe/bsQV5eHl599VWd37/44otwdXXF5s2bERERgZkzZ2L79u147bXXMG7cOAQHB+PevXvYs2cPvv76awQGBmL06NH4/vvvMX36dJw4cQJdunRBQUEBfv31V7z99tsYMGAAnJyc8Nprr2HlypWQyWTw8/PD3r179RofExAQAD8/P8yYMQMZGRlwdHTEjh07cP/+/TJtV6xYgc6dO6Nt27aYOHEiGjVqhD///BO//PILkpOTtdqOHj1acyv/woULK1WLs7Mzdu3ahb59+yIoKEjridtnzpzBli1btB4hMGHCBEyaNAlDhgzByy+/jHPnziEuLq5SgexJlpaWGDx4MLZu3YqCggIsWbKkTJvVq1ejc+fOaN26Nd544w00btwYWVlZSEpKwq1bt3Du3Dm99klkkqS7sY6IDFX//v2FjY2NKCgoKLfNmDFjhKWlpcjJyRFCCPHXX3+JKVOmCG9vb2FlZSXq168vIiMjNd8Lob41f+7cuaJRo0bC0tJSeHh4iKFDh4rU1FRNm7t374ohQ4YIW1tb4ezsLN58801x8eJFnY8AsLOz01nbpUuXRFhYmLC3txcuLi7ijTfeEOfOnSuzDSGEuHjxohg0aJCoU6eOsLGxEf7+/uLDDz8ss82ioiLh7OwsnJycxKNHjypzGjVu374t3nvvPdGsWTNhY2MjbG1tRXBwsFi8eLFQKBSadkqlUrz//vvCxcVF2NraivDwcJGSklLuIwBOnjxZ7j7j4+MFACGTyUR6errONqmpqWL06NHCw8NDWFpaCm9vb/HKK6+I7du363V8RKaKryUhIqqEkpISeHl5oX///li7dq3U5RBRDeCYJCKiSti9ezfu3r2rNRiciEwbryQREVXg+PHjOH/+PBYuXAgXFxecOXNG6pKIqIbwShIRUQXWrFmDt956C25ubvj++++lLoeIahCvJBERERHpwCtJRERERDowJBERERHpwIdJPiOVSoXbt2/DwcHhud5gTkRERDVHCIG8vDx4eXmVeffjPzEkPaPbt2+jQYMGUpdBREREzyA9PR3169evsA1D0jNycHAAoD7Jjo6OEldDRERElZGbm4sGDRpofscrwpD0jEq72BwdHRmSiIiIjExlhspw4DYRERGRDgxJRERERDowJBERERHpwJBEREREpANDEhEREZEODElEREREOjAkEREREenAkERERESkA0MSERERkQ4MSUREREQ6MCQRERER6cCQRERERKQDX3BLtVZuLnD/vtRVEBFReRwdAWdn6fbPkES10pUrQGAgUFQkdSVERFSeOXOATz6Rbv8MSVQrbd+uDkjm5oClpdTVEBGRLhYSpxSGJKqV4uPVf65cCbz1lrS1EBGRYeLAbap18vOB335Tz7/8srS1EBGR4WJIolrn8GGguBjw8QH8/KSuhoiIDBVDEtU6pV1tL78MyGTS1kJERIZL8pC0evVq+Pr6wsbGBiEhIThx4kS5bYuLi/Hxxx/Dz88PNjY2CAwMRGxsrFabvLw8TJs2DT4+PpDL5ejYsSNOnjyp1SY/Px9TpkxB/fr1IZfL0aJFC3z99dfVcnxkeJ4MSUREROWRNCRt27YN06dPx/z583HmzBkEBgYiPDwc2dnZOttHRUXhm2++wcqVK3Hp0iVMmjQJgwYNwtmzZzVtJkyYgPj4eMTExODChQvo1asXwsLCkJGRoWkzffp0xMbGYtOmTbh8+TKmTZuGKVOmYM+ePdV+zCStzEzg4kX1FaQePaSuhoiIDJqQUIcOHcTkyZM1n5VKpfDy8hLR0dE623t6eopVq1ZpLRs8eLAYOXKkEEKIhw8fCnNzc7F3716tNm3bthVz587VfG7ZsqX4+OOPK2zzNAqFQgAQCoWi0uuQ9GJihACEaNtW6kqIiEgK+vx+S3Yl6fHjxzh9+jTCwsI0y8zMzBAWFoakpCSd6xQVFcHGxkZrmVwux5EjRwAAJSUlUCqVFbYBgI4dO2LPnj3IyMiAEAKJiYm4evUqevXqVW69RUVFyM3N1ZrI+LCrjYiIKkuykJSTkwOlUgl3d3et5e7u7sjMzNS5Tnh4OJYuXYpr165BpVIhPj4eO3fuxJ07dwAADg4OCA0NxcKFC3H79m0olUps2rQJSUlJmjYAsHLlSrRo0QL169eHlZUVevfujdWrV6Nr167l1hsdHQ0nJyfN1KBBgyo4C1SThAB+/VU9z5BERERPI/nAbX0sX74cTZs2RUBAAKysrDBlyhSMHTsWZmZ/H0ZMTAyEEPD29oa1tTVWrFiBESNGaLVZuXIljh07hj179uD06dP44osvMHnyZPxa+guqw5w5c6BQKDRTenp6tR4rVb3Ll4HbtwEbG6BTJ6mrISIiQyfZE7ddXFxgbm6OrKwsreVZWVnw8PDQuY6rqyt2796NwsJC/PXXX/Dy8sLs2bPRuHFjTRs/Pz8cPHgQBQUFyM3NhaenJyIiIjRtHj16hA8++AC7du1Cv379AABt2rRBcnIylixZotX99yRra2tYW1tXxaGTREq72rp0UQclIiKiikh2JcnKygrBwcFISEjQLFOpVEhISEBoaGiF69rY2MDb2xslJSXYsWMHBgwYUKaNnZ0dPD09cf/+fcTFxWnaFBcXo7i4WOvKEgCYm5tDpVJVwZGRoeJ4JCIi0oek726bPn06IiMj0a5dO3To0AHLli1DQUEBxo4dCwAYPXo0vL29ER0dDQA4fvw4MjIyEBQUhIyMDCxYsAAqlQqzZs3SbDMuLg5CCPj7+yMlJQUzZ85EQECAZpuOjo7o1q0bZs6cCblcDh8fHxw8eBDff/89li5dWvMngWpEcTFw4IB6vpyLhURERFokDUkRERG4e/cu5s2bh8zMTAQFBSE2NlYzmDstLU3rik9hYSGioqJw/fp12Nvbo2/fvoiJiUGdOnU0bRQKBebMmYNbt26hbt26GDJkCBYvXgzLJ171vnXrVsyZMwcjR47EvXv34OPjg8WLF2PSpEk1duxUs44dAwoKAFdXIDBQ6mqIiMgYyIQQQuoijFFubi6cnJygUCjg6OgodTn0FPPmAQsXAsOHA1u2SF0NERFJRZ/fb6O6u43oWfHWfyIi0hdDEpk8hQIofSUgxyMREVFlMSSRyUtMBJRKoFkzoGFDqashIiJjwZBEJo+3/hMR0bNgSCKTVzoeiV1tRESkD4YkMmlpacDVq4C5OfDSS1JXQ0RExoQhiUxaaVdbhw6Ak5O0tRARkXFhSCKTxlv/iYjoWTEkkclSqTgeiYiInh1DEpmsc+eAnBzA3h548UWpqyEiImPDkEQmq3Q8UvfuwBOv7iMiIqoUhiQyWexqIyKi58GQRCapsBA4fFg9z0HbRET0LBiSyCQdOaIOSl5eQPPmUldDRETGiCGJTNKTt/7LZNLWQkRExokhiUxS6aBtjkciIqJnxZBEJicnBzh7Vj3PkERERM+KIYlMTkICIATQujXg4SF1NUREZKwYksjk8NZ/IiKqCgxJZFKE+Hs8Em/9JyKi58GQRCYlJQW4eROwsgK6dpW6GiIiMmYMSWRSSrvaOnYE7OykrYWIiIwbQxKZFN76T0REVYUhiUxGSQmwf796nuORiIjoeTEkkck4dQpQKIA6dYDgYKmrISIiY8eQRCajdDxSjx6Aubm0tRARkfFjSCKTwVv/iYioKjEkkUnIzweSktTzDElERFQVGJLIJBw6BBQXA76+QOPGUldDRESmgCGJTMKTXW0ymbS1EBGRaWBIIpPA8UhERFTVGJLI6N25A/z+u/oKUo8eUldDRESmgiGJjF7prf9t2wL16klbCxERmQ6GJDJ67GojIqLqwJBERk2Iv68kMSQREVFVYkgio3bpknpMko0N0LGj1NUQEZEpYUgio1ba1da1qzooERERVRWGJDJqHI9ERETVhSGJjNbjx8DBg+p5hiQiIqpqDElktI4dAwoKAFdXoHVrqashIiJTw5BERqu0qy0sDDDjv2QiIqpi/Gkho8XxSEREVJ0YksgoPXgAnDypng8Lk7QUIiIyUQxJZJQSEwGVCvD3Bxo0kLoaIiIyRQxJZJTY1UZERNWNIYmMEl9FQkRE1Y0hiYzOzZvAtWuAuTnQrZvU1RARkaliSCKjU9rVFhICODlJWwsREZkuyUPS6tWr4evrCxsbG4SEhODEiRPlti0uLsbHH38MPz8/2NjYIDAwELGxsVpt8vLyMG3aNPj4+EAul6Njx444WXob1BMuX76MV199FU5OTrCzs0P79u2RlpZW5cdHVY/jkYiIqCZYSLnzbdu2Yfr06fj6668REhKCZcuWITw8HFeuXIGbm1uZ9lFRUdi0aRO+++47BAQEIC4uDoMGDcJvv/2GF154AQAwYcIEXLx4ETExMfDy8sKmTZsQFhaGS5cuwdvbGwCQmpqKzp07Y/z48fjoo4/g6OiI33//HTaG8IZUIYCHD6WuwmCpVEDSr4AtgF6dABRIXREREVUbW1tAJpNu/0JCHTp0EJMnT9Z8ViqVwsvLS0RHR+ts7+npKVatWqW1bPDgwWLkyJFCCCEePnwozM3Nxd69e7XatG3bVsydO1fzOSIiQowaNeq5alcoFAKAUCgUz7WdMvLzhVBHJU6cOHHixKl2T/n5VfsbK/T7/Zasu+3x48c4ffo0wp54EqCZmRnCwsKQlJSkc52ioqIyV3vkcjmOHDkCACgpKYFSqaywjUqlwi+//IJmzZohPDwcbm5uCAkJwe7du6vw6IiIiMjYSdbdlpOTA6VSCXd3d63l7u7u+OOPP3SuEx4ejqVLl6Jr167w8/NDQkICdu7cCaVSCQBwcHBAaGgoFi5ciObNm8Pd3R1btmxBUlISmjRpAgDIzs5Gfn4+Pv30UyxatAifffYZYmNjMXjwYCQmJqJbObdLFRUVoaioSPM5Nze3Kk5DWba2QH5+9WzbBPTvD+xPBJb8G3jrLamrISKiamVrK+nuJR2TpK/ly5fjjTfeQEBAAGQyGfz8/DB27FisW7dO0yYmJgbjxo2Dt7c3zM3N0bZtW4wYMQKnT58GoL6SBAADBgzAe++9BwAICgrCb7/9hq+//rrckBQdHY2PPvqomo8Q6r5XO7vq348RevQIiP8NKALQvR8AniYiIqpGknW3ubi4wNzcHFlZWVrLs7Ky4OHhoXMdV1dX7N69GwUFBbh58yb++OMP2Nvbo3Hjxpo2fn5+OHjwIPLz85Geno4TJ06guLhY08bFxQUWFhZo0aKF1rabN29e4d1tc+bMgUKh0Ezp6enPeuj0jI4cAYqKAG9vICBA6mqIiMjUSRaSrKysEBwcjISEBM0ylUqFhIQEhIaGVriujY0NvL29UVJSgh07dmDAgAFl2tjZ2cHT0xP3799HXFycpo2VlRXat2+PK1euaLW/evUqfHx8yt2ntbU1HB0dtSaqWU/e+i/lzQ5ERFQ7SNrdNn36dERGRqJdu3bo0KEDli1bhoKCAowdOxYAMHr0aHh7eyM6OhoAcPz4cWRkZCAoKAgZGRlYsGABVCoVZs2apdlmXFwchBDw9/dHSkoKZs6ciYCAAM02AWDmzJmIiIhA165d8dJLLyE2NhY///wzDhw4UKPHT/opfRXJE2P9iYiIqo2kISkiIgJ3797FvHnzkJmZiaCgIMTGxmoGc6elpcHM7O+LXYWFhYiKisL169dhb2+Pvn37IiYmBnXq1NG0USgUmDNnDm7duoW6detiyJAhWLx4MSwtLTVtBg0ahK+//hrR0dF499134e/vjx07dqBz5841duykn7t3gbNn1fMMSUREVBNkQgghdRHGKDc3F05OTlAoFOx6qwFbtwIjRgBt2gDnzkldDRERGSt9fr8lfy0JUWWUdrXxVSRERFRTGJLI4Anx96BtdrUREVFNYUgig3ftGpCWBlhZAV27Sl0NERHVFgxJZPBKryJ16iT5w1eJiKgWYUgig8db/4mISAoMSWTQSkqA/fvV8xy0TURENYkhiQzayZNAbi7g7Ay0bSt1NUREVJswJJFBK+1q69kTMDeXthYiIqpdGJLIoPHWfyIikgpDEhmsvDwgKUk9z/FIRERU0xiSyGAdOqQeuN24sXoiIiKqSQxJZLDY1UZERFJiSCKDVRqS2NVGRERSYEgig5SRAVy6BMhkQI8eUldDRES1EUMSGaSEBPWfwcFA3brS1kJERLUTQxIZJHa1ERGR1BiSyOAI8fdDJBmSiIhIKgxJZHB+/x3IzATkcqBjR6mrISKi2oohiQxOaVdb166AtbW0tRARUe3FkEQGh+ORiIjIEDAkkUEpKgIOHlTPMyQREZGUGJLIoBw7Bjx8CLi5Aa1aSV0NERHVZgxJZFCefBWJGf91EhGRhPgzRAaF45GIiMhQMCSRwbh/Hzh1Sj3Pl9oSEZHUGJLIYCQmAioVEBAA1K8vdTVERFTbMSSRwWBXGxERGRKGJDIYDElERGRIGJLIINy4AaSmAubmQLduUldDRETEkEQGovSFti++CDg6SlsLERERwJBEBoJdbUREZGgYkkhyKhWQkKCeZ0giIiJDwZBEkjt7Frh3D3BwANq3l7oaIiIiNYYkklxpV9tLLwGWltLWQkREVIohiSTH8UhERGSIGJJIUg8fAkeOqOf5KhIiIjIkDEkkqSNHgMeP1a8h8feXuhoiIqK/MSSRpJ7sapPJpK2FiIjoSQxJJKnSh0hyPBIRERkahiSSTHY2kJysnu/ZU9JSiIiIymBIIsmUPkAyMBBwc5O2FiIion9iSCLJ8NZ/IiIyZAxJJAkh/h6PxFv/iYjIEDEkkSSuXgXS0wErK6BLF6mrISIiKoshiSRR2tXWuTNgayttLURERLowJJEkeOs/EREZOoYkqnElJUBionqe45GIiMhQMSRRjTtxAsjNBerWBV54QepqiIiIdGNIohpX2tXWsydgbi5tLUREROUxiJC0evVq+Pr6wsbGBiEhIThx4kS5bYuLi/Hxxx/Dz88PNjY2CAwMRGxsrFabvLw8TJs2DT4+PpDL5ejYsSNOnjxZ7jYnTZoEmUyGZcuWVdUhUQVKB22zq42IiAyZ5CFp27ZtmD59OubPn48zZ84gMDAQ4eHhyM7O1tk+KioK33zzDVauXIlLly5h0qRJGDRoEM6ePatpM2HCBMTHxyMmJgYXLlxAr169EBYWhoyMjDLb27VrF44dOwYvL69qO0b6W14ecOyYep6DtomIyKAJiXXo0EFMnjxZ81mpVAovLy8RHR2ts72np6dYtWqV1rLBgweLkSNHCiGEePjwoTA3Nxd79+7VatO2bVsxd+5crWW3bt0S3t7e4uLFi8LHx0d8+eWXla5boVAIAEKhUFR6HRJizx4hACH8/KSuhIiIaiN9fr8lvZL0+PFjnD59GmFP9LuYmZkhLCwMSUlJOtcpKiqCjY2N1jK5XI4jR44AAEpKSqBUKitsAwAqlQqvv/46Zs6ciZYtWz611qKiIuTm5mpNpD/e+k9ERMZC0pCUk5MDpVIJd3d3reXu7u7IzMzUuU54eDiWLl2Ka9euQaVSIT4+Hjt37sSdO3cAAA4ODggNDcXChQtx+/ZtKJVKbNq0CUlJSZo2APDZZ5/BwsIC7777bqVqjY6OhpOTk2Zq0KDBMx517cbxSEREZCwkH5Okr+XLl6Np06YICAiAlZUVpkyZgrFjx8LM7O9DiYmJgRAC3t7esLa2xooVKzBixAhNm9OnT2P58uXYsGEDZDJZpfY7Z84cKBQKzZSenl4tx2fKbt0CLl8GzMyAHj2kroaIiKhikoYkFxcXmJubIysrS2t5VlYWPDw8dK7j6uqK3bt3o6CgADdv3sQff/wBe3t7NG7cWNPGz88PBw8eRH5+PtLT03HixAkUFxdr2hw+fBjZ2dlo2LAhLCwsYGFhgZs3b+Jf//oXfH19de7X2toajo6OWhPpJyFB/We7doCzs7S1EBERPY2kIcnKygrBwcFIKP31hHqsUEJCAkJDQytc18bGBt7e3igpKcGOHTswYMCAMm3s7Ozg6emJ+/fvIy4uTtPm9ddfx/nz55GcnKyZvLy8MHPmTMTFxVXtQZIGu9qIiMiYWEhdwPTp0xEZGYl27dqhQ4cOWLZsGQoKCjB27FgAwOjRo+Ht7Y3o6GgAwPHjx5GRkYGgoCBkZGRgwYIFUKlUmDVrlmabcXFxEELA398fKSkpmDlzJgICAjTbrFevHurVq6dVh6WlJTw8PODv719DR167CMFB20REZFwkD0kRERG4e/cu5s2bh8zMTAQFBSE2NlYzmDstLU1rvFFhYSGioqJw/fp12Nvbo2/fvoiJiUGdOnU0bRQKBebMmYNbt26hbt26GDJkCBYvXgxLS8uaPjz6nwsXgKwswNYWeMpFQiIiIoMgE0IIqYswRrm5uXBycoJCoeD4pEpYuhT417+A3r2BffukroaIiGorfX6/je7uNjJOpeOR2NVGRETGgiGJql1REXDwoHqeIYmIiIwFQxJVu6Qk4NEjwN0daNVK6mqIiIgqhyGJqt2Tt/5X8tmdREREktM7JPn6+uLjjz9GWlpaddRDJojjkYiIyBjpHZKmTZuGnTt3onHjxnj55ZexdetWFBUVVUdtZALu3QNOnVLP8yGSRERkTJ4pJCUnJ+PEiRNo3rw53nnnHXh6emLKlCk4c+ZMddRIRiwxUf0gyebNAW9vqashIiKqvGcek9S2bVusWLECt2/fxvz58/H//t//Q/v27REUFIR169aBj18igF1tRERkvJ75idvFxcXYtWsX1q9fj/j4eLz44osYP348bt26hQ8++AC//vorfvjhh6qslYwQQxIRERkrvUPSmTNnsH79emzZsgVmZmYYPXo0vvzySwQEBGjaDBo0CO3bt6/SQsn4XL+uniwsgG7dpK6GiIhIP3qHpPbt2+Pll1/GmjVrMHDgQJ3vQ2vUqBGGDx9eJQWS8Sp9oe2LLwIODtLWQkREpC+9Q9L169fh4+NTYRs7OzusX7/+mYsi08CuNiIiMmZ6D9zOzs7G8ePHyyw/fvw4TpXe6021nlIJJCSo5xmSiIjIGOkdkiZPnoz09PQyyzMyMjB58uQqKYqM39mzwP37gKMjwOFpRERkjPQOSZcuXULbtm3LLH/hhRdw6dKlKimKjF9pV9tLL6kHbhMRERkbvUOStbU1srKyyiy/c+cOLPhrSP/D8UhERGTs9A5JvXr1wpw5c6BQKDTLHjx4gA8++AAv8xeRADx8CBw9qp7nPwkiIjJWel/6WbJkCbp27QofHx+88MILAIDk5GS4u7sjJiamygsk43P4MPD4MdCgAdC0qdTVEBERPRu9Q5K3tzfOnz+PzZs349y5c5DL5Rg7dixGjBih85lJVPs82dUmk0lbCxER0bN6pkFEdnZ2mDhxYlXXQiaC45GIiMgUPPNI60uXLiEtLQ2PHz/WWv7qq68+d1FkvLKygPPn1fM9ekhbCxER0fN4piduDxo0CBcuXIBMJoMQAgAg+1+/ilKprNoKyaiUPkAyKAhwc5O0FCIiouei991tU6dORaNGjZCdnQ1bW1v8/vvvOHToENq1a4cDBw5UQ4lkTNjVRkREpkLvK0lJSUnYv38/XFxcYGZmBjMzM3Tu3BnR0dF49913cfbs2eqok4yAEH+/1JYhiYiIjJ3eV5KUSiUc/vdKdxcXF9y+fRsA4OPjgytXrlRtdWRUrlwBbt0CrK2Bzp2lroaIiOj56H0lqVWrVjh37hwaNWqEkJAQfP7557CyssK3336Lxo0bV0eNZCRKu9o6dwbkcmlrISIiel56h6SoqCgUFBQAAD7++GO88sor6NKlC+rVq4dt27ZVeYFkPDgeiYiITIlMlN6e9hzu3bsHZ2dnzR1utUFubi6cnJygUCjg6OgodTmSKy4G6tUD8vKAU6eA4GCpKyIiIipLn99vvcYkFRcXw8LCAhcvXtRaXrdu3VoVkKisEyfUAalePeB/b6shIiIyanqFJEtLSzRs2JDPQqIySrvaevYEzPS+HYCIiMjw6P1zNnfuXHzwwQe4d+9eddRDRoq3/hMRkanRe+D2qlWrkJKSAi8vL/j4+MDOzk7r+zNnzlRZcWQccnOBY8fU82Fh0tZCRERUVfQOSQMHDqyGMsiYHTgAKJVAkyaAr6/U1RAREVUNvUPS/Pnzq6MOMmLsaiMiIlPEIbb03EoHbbOrjYiITIneV5LMzMwqvN2fd77VLrduAX/8ob6jrUcPqashIiKqOnqHpF27dml9Li4uxtmzZ7Fx40Z89NFHVVYYGYfSq0jt2wN16khaChERUZXSOyQNGDCgzLKhQ4eiZcuW2LZtG8aPH18lhZFxKB2PxK42IiIyNVU2JunFF19EQkJCVW2OjIBKxUHbRERkuqokJD169AgrVqyAt7d3VWyOjMSFC0B2NmBnB4SGSl0NERFR1dK7u+2fL7IVQiAvLw+2trbYtGlTlRZHhq30KlK3boCVlbS1EBERVTW9Q9KXX36pFZLMzMzg6uqKkJAQODs7V2lxZNh46z8REZkyvUPSmDFjqqEMMjaFhcChQ+p5jkciIiJTpPeYpPXr1+Onn34qs/ynn37Cxo0bq6QoMny//QY8egR4eAAtW0pdDRERUdXTOyRFR0fDxcWlzHI3Nzd88sknVVIUGb4nb/2v4NmiRERERkvvkJSWloZGjRqVWe7j44O0tLQqKYoMX+l4JHa1ERGRqdI7JLm5ueH8+fNllp87dw716tWrkqLIsP31F3D6tHqeg7aJiMhU6R2SRowYgXfffReJiYlQKpVQKpXYv38/pk6diuHDh1dHjWRgEhMBIdRjkby8pK6GiIioeugdkhYuXIiQkBD07NkTcrkccrkcvXr1Qo8ePZ55TNLq1avh6+sLGxsbhISE4MSJE+W2LS4uxscffww/Pz/Y2NggMDAQsbGxWm3y8vIwbdo0+Pj4QC6Xo2PHjjh58qTWNt5//320bt0adnZ28PLywujRo3H79u1nqr+24a3/RERUG+gdkqysrLBt2zZcuXIFmzdvxs6dO5Gamop169bB6hmeKLht2zZMnz4d8+fPx5kzZxAYGIjw8HBkZ2frbB8VFYVvvvkGK1euxKVLlzBp0iQMGjQIZ8+e1bSZMGEC4uPjERMTgwsXLqBXr14ICwtDRkYGAODhw4c4c+YMPvzwQ5w5cwY7d+7ElStX8Oqrr+pdf23E8UhERFQbyIQQQsoCQkJC0L59e6xatQoAoFKp0KBBA7zzzjuYPXt2mfZeXl6YO3cuJk+erFk2ZMgQyOVybNq0CY8ePYKDgwP+85//oF+/fpo2wcHB6NOnDxYtWqSzjpMnT6JDhw64efMmGjZs+NS6c3Nz4eTkBIVCAUdHR30P22ilpgJNmgAWFsD9+4C9vdQVERERVZ4+v996X0kaMmQIPvvsszLLP//8c7z22mt6bevx48c4ffo0wp7otzEzM0NYWBiSkpJ0rlNUVAQbGxutZXK5HEeOHAEAlJSUQKlUVthGF4VCAZlMhjp16uh1DLVN6a3/oaEMSEREZNr0DkmHDh1C3759yyzv06cPDpU+grmScnJyoFQq4e7urrXc3d0dmZmZOtcJDw/H0qVLce3aNahUKsTHx2Pnzp24c+cOAMDBwQGhoaFYuHAhbt++DaVSiU2bNiEpKUnT5p8KCwvx/vvvY8SIEeWmyqKiIuTm5mpNtRG72oiIqLbQOyTl5+frHHtkaWlZI8Fh+fLlaNq0KQICAmBlZYUpU6Zg7NixMDP7+1BiYmIghIC3tzesra2xYsUKjBgxQqtNqeLiYgwbNgxCCKxZs6bc/UZHR8PJyUkzNWjQoFqOz5AplcD+/ep5hiQiIjJ1eoek1q1bY9u2bWWWb926FS1atNBrWy4uLjA3N0dWVpbW8qysLHh4eOhcx9XVFbt370ZBQQFu3ryJP/74A/b29mjcuLGmjZ+fHw4ePIj8/Hykp6fjxIkTKC4u1moD/B2Qbt68ifj4+Ar7JufMmQOFQqGZ0tPT9TpWU3DmjHockpMT0K6d1NUQERFVL71fcPvhhx9i8ODBSE1NRY8ePQAACQkJ+OGHH7B9+3a9tmVlZYXg4GAkJCRg4MCBANQDtxMSEjBlypQK17WxsYG3tzeKi4uxY8cODBs2rEwbOzs72NnZ4f79+4iLi8Pnn3+u+a40IF27dg2JiYlPfRCmtbU1rK2t9To+U1Pa1fbSS+qB20RERKZM75+6/v37Y/fu3fjkk0+wfft2yOVyBAYGYv/+/ahbt67eBUyfPh2RkZFo164dOnTogGXLlqGgoABjx44FAIwePRre3t6Ijo4GABw/fhwZGRkICgpCRkYGFixYAJVKhVmzZmm2GRcXByEE/P39kZKSgpkzZyIgIECzzeLiYgwdOhRnzpzB3r17oVQqNWOg6tat+0yPMqgNOB6JiIhqk2e6HtCvXz/N7fW5ubnYsmULZsyYgdOnT0OpVOq1rYiICNy9exfz5s1DZmYmgoKCEBsbqxnMnZaWpjWWqLCwEFFRUbh+/Trs7e3Rt29fxMTEaN2VplAoMGfOHNy6dQt169bFkCFDsHjxYlhaWgIAMjIysGfPHgBAUFCQVj2JiYno3r27nmfE9BUUAEePqucZkoiIqDZ45uckHTp0CGvXrsWOHTvg5eWFwYMHY8iQIWjfvn1V12iQattzkmJjgT59gIYNgT//BGQyqSsiIiLSnz6/33pdScrMzMSGDRuwdu1a5ObmYtiwYSgqKsLu3bv1HrRNxuXJrjYGJCIiqg0qfXdb//794e/vj/Pnz2PZsmW4ffs2Vq5cWZ21kQHheCQiIqptKn0lad++fXj33Xfx1ltvoWnTptVZExmYzEzgwgX1fM+e0tZCRERUUyp9JenIkSPIy8tDcHAwQkJCsGrVKuTk5FRnbWQgEhLUf77wAuDiIm0tRERENaXSIenFF1/Ed999hzt37uDNN9/E1q1b4eXlpXk1SF5eXnXWSRJiVxsREdVGz3x3GwBcuXIFa9euRUxMDB48eICXX35Zc2u9qastd7cJAdSvD9y+rQ5LT7yLmIiIyOjo8/ut92tJnuTv74/PP/8ct27dwpYtW55nU2Sg/vhDHZCsrYFOnaSuhoiIqOY8V0gqZW5ujoEDB9aaq0i1SWlXW5cugFwubS1EREQ1qUpCEpkujkciIqLaiiGJylVcDBw4oJ5nSCIiotqGIYnKdfw4kJ+vvu0/MFDqaoiIiGoWQxKVq7SrrWdPwIz/UoiIqJbhTx+V69df1X+yq42IiGojhiTSSaFQd7cBfDYSERHVTgxJpNOBA4BSCTRtCvj4SF0NERFRzWNIIp146z8REdV2DEmkE8cjERFRbceQRGWkpwNXrqjvaOveXepqiIiIpMGQRGWUdrV16ADUqSNpKURERJJhSKIy2NVGRETEkET/oFL9HZJ46z8REdVmDEmk5fx54O5dwM4OePFFqashIiKSDkMSaSkdj9S9O2BlJWkpREREkmJIIi3saiMiIlJjSCKNwkLg0CH1PAdtExFRbceQRBpHj6qDkpcX0KKF1NUQERFJiyGJNJ7sapPJpK2FiIhIagxJpFE6aJvjkYiIiBiS6H/++gs4c0Y9z5BERETEkET/k5AACAG0agV4ekpdDRERkfQYkggAb/0nIiL6J4YkghB/j0firf9ERERqDEmE1FTgzz8BS0ugWzepqyEiIjIMDEmk6Wrr2FH9zjYiIiJiSCLw1n8iIiJdGJJqOaUS2L9fPc/xSERERH9jSKrlTp0CHjwAnJyAdu2kroaIiMhwMCTVcqXjkXr0AMzNpa2FiIjIkDAk1XK89Z+IiEg3hqRaLD8f+O039TxDEhERkTaGpFrs8GGguBjw9QX8/KSuhoiIyLAwJNViT976L5NJWwsREZGhYUiqxTgeiYiIqHwMSbXUnTvAxYvqK0g9ekhdDRERkeFhSKqlEhLUf77wAuDiIm0tREREhoghqZZiVxsREVHFGJJqISEYkoiIiJ6GIakWunxZPSbJxgbo1EnqaoiIiAwTQ1ItVHoVqUsXdVAiIiKisgwiJK1evRq+vr6wsbFBSEgITpw4UW7b4uJifPzxx/Dz84ONjQ0CAwMRGxur1SYvLw/Tpk2Dj48P5HI5OnbsiJMnT2q1EUJg3rx58PT0hFwuR1hYGK5du1Ytx2do2NVGRET0dJKHpG3btmH69OmYP38+zpw5g8DAQISHhyM7O1tn+6ioKHzzzTdYuXIlLl26hEmTJmHQoEE4e/asps2ECRMQHx+PmJgYXLhwAb169UJYWBgyMjI0bT7//HOsWLECX3/9NY4fPw47OzuEh4ejsLCw2o9ZSsXFwIED6nmGJCIiogoIiXXo0EFMnjxZ81mpVAovLy8RHR2ts72np6dYtWqV1rLBgweLkSNHCiGEePjwoTA3Nxd79+7VatO2bVsxd+5cIYQQKpVKeHh4iH//+9+a7x88eCCsra3Fli1bKlW3QqEQAIRCoahUe0Nx6JAQgBCurkIolVJXQ0REVLP0+f2W9ErS48ePcfr0aYSFhWmWmZmZISwsDElJSTrXKSoqgs0/BtLI5XIcOXIEAFBSUgKlUllhmxs3biAzM1Nrv05OTggJCalwv7m5uVqTMSrtauvZEzCT/DoiERGR4ZL0ZzInJwdKpRLu7u5ay93d3ZGZmalznfDwcCxduhTXrl2DSqVCfHw8du7ciTt37gAAHBwcEBoaioULF+L27dtQKpXYtGkTkpKSNG1Kt63PfqOjo+Hk5KSZGjRo8FzHLhWORyIiIqoco7uWsHz5cjRt2hQBAQGwsrLClClTMHbsWJg9cVkkJiYGQgh4e3vD2toaK1aswIgRI7Ta6GvOnDlQKBSaKT09vSoOp0YpFEDpmPgnLqIRERGRDpKGJBcXF5ibmyMrK0treVZWFjw8PHSu4+rqit27d6OgoAA3b97EH3/8AXt7ezRu3FjTxs/PDwcPHkR+fj7S09Nx4sQJFBcXa9qUbluf/VpbW8PR0VFrMjaJiYBKBTRrBjRsKHU1REREhk3SkGRlZYXg4GAklL5IDIBKpUJCQgJCQ0MrXNfGxgbe3t4oKSnBjh07MGDAgDJt7Ozs4Onpifv37yMuLk7TplGjRvDw8NDab25uLo4fP/7U/RozdrURERFVnoXUBUyfPh2RkZFo164dOnTogGXLlqGgoABjx44FAIwePRre3t6Ijo4GABw/fhwZGRkICgpCRkYGFixYAJVKhVmzZmm2GRcXByEE/P39kZKSgpkzZyIgIECzTZlMhmnTpmHRokVo2rQpGjVqhA8//BBeXl4YOHBgjZ+DmvLrr+o/GZKIiIieTvKQFBERgbt372LevHnIzMxEUFAQYmNjNYOq09LStMYSFRYWIioqCtevX4e9vT369u2LmJgY1KlTR9NGoVBgzpw5uHXrFurWrYshQ4Zg8eLFsLS01LSZNWsWCgoKMHHiRDx48ACdO3dGbGxsmbviTEVaGnD1KmBuDnTvLnU1REREhk8mhBBSF2GMcnNz4eTkBIVCYRTjk9auBSZMAEJDgd9+k7oaIiIiaejz+210d7fRs+F4JCIiIv0wJNUCKhVQOkadIYmIiKhyGJJqgXPngJwcwN4eCAmRuhoiIiLjwJBUC5R2tXXvDjwxdp2IiIgqwJBUC/DWfyIiIv0xJJm4wkLg8GH1PF9FQkREVHkMSSbuyBF1UPLyApo3l7oaIiIi48GQZOKevPVfJpO2FiIiImPCkGTiSscjsauNiIhIPwxJJiwnBzh7Vj3PkERERKQfhiQTlpAACAG0bg14eEhdDRERkXFhSDJhvPWfiIjo2TEkmSgh/h60za42IiIi/TEkmaiUFODmTcDKCujaVepqiIiIjA9DkokqvYrUsSNgZydtLURERMaIIclE8dZ/IiKi58OQZIJKSoD9+9XzHLRNRET0bBiSTNCpU4BCATg7A8HBUldDRERknBiSTFBpV1uPHoC5ubS1EBERGSuGJBPEW/+JiIieH0OSicnPB5KS1PMcj0RERPTsGJJMzMGDQHEx0KgR4OcndTVERETGiyHJxPDWfyIioqrBkGRiSscjsauNiIjo+TAkmZDbt4HffwdkMvWdbURERPTsGJJMSEKC+s/gYKBePWlrISIiMnYMSSaEt/4TERFVHYYkEyHE34O2OR6JiIjo+TEkmYhLl4A7dwC5HOjYUepqiIiIjB9Dkoko7Wrr0gWwsZG2FiIiIlPAkGQieOs/ERFR1WJIMgGPH6uftA0wJBEREVUVhiQTcOwYUFAAuLkBrVtLXQ0REZFpYEgyAaVdbT17Amb8GyUiIqoS/Ek1ARyPREREVPUYkozcgwfAyZPqeT5EkoiIqOowJBm5xERApQL8/YEGDaSuhoiIyHQwJBk5drURERFVD4YkI8eQREREVD0YkozYn38CKSmAuTnQvbvU1RAREZkWhiQjVvpC25AQwNFR2lqIiIhMDUOSEWNXGxERUfVhSDJSKhWQkKCeZ0giIiKqegxJRio5GfjrL8DBAejQQepqiIiITA9DkpEq7Wrr3h2wtJS0FCIiIpNkIXUB9Gw4HomInodSqURxcbHUZRBVOUtLS5ibm1fJthiSjNCjR8CRI+p5hiQi0ocQApmZmXjw4IHUpRBVmzp16sDDwwMymey5tsOQZISOHAGKigBvb/XrSIiIKqs0ILm5ucHW1va5f0SIDIkQAg8fPkR2djYAwNPT87m2J3lIWr16Nf79738jMzMTgYGBWLlyJTqUMxK5uLgY0dHR2LhxIzIyMuDv74/PPvsMvXv31rRRKpVYsGABNm3ahMzMTHh5eWHMmDGIiorS/McgPz8fs2fPxu7du/HXX3+hUaNGePfddzFp0qQaOebn9WRXG//7RkSVpVQqNQGpXr16UpdDVC3kcjkAIDs7G25ubs/V9SZpSNq2bRumT5+Or7/+GiEhIVi2bBnCw8Nx5coVuLm5lWkfFRWFTZs24bvvvkNAQADi4uIwaNAg/Pbbb3jhhRcAAJ999hnWrFmDjRs3omXLljh16hTGjh0LJycnvPvuuwCA6dOnY//+/di0aRN8fX3x3//+F2+//Ta8vLzw6quv1ug5eBalD5FkVxsR6aN0DJKtra3ElRBVr9J/48XFxc8VkmRCCFFVRekrJCQE7du3x6pVqwAAKpUKDRo0wDvvvIPZs2eXae/l5YW5c+di8uTJmmVDhgyBXC7Hpk2bAACvvPIK3N3dsXbt2nLbtGrVChEREfjwww81bYKDg9GnTx8sWrSoUrXn5ubCyckJCoUCjjX4uOu7d4HS/JiZCbi719iuicjIFRYW4saNG2jUqBFsbGykLoeo2lT0b12f32/JHgHw+PFjnD59GmFhYX8XY2aGsLAwJCUl6VynqKiozMHK5XIcKR3FDKBjx45ISEjA1atXAQDnzp3DkSNH0KdPH602e/bsQUZGBoQQSExMxNWrV9GrV6+qPMRqUfoAyTZtGJCIiJ6Hr68vli1bJnUZZMAkC0k5OTlQKpVw/8cvvbu7OzIzM3WuEx4ejqVLl+LatWtQqVSIj4/Hzp07cefOHU2b2bNnY/jw4QgICIClpSVeeOEFTJs2DSNHjtS0WblyJVq0aIH69evDysoKvXv3xurVq9G1a9dy6y0qKkJubq7WJAXe+k9EtY1MJqtwWrBgwTNt9+TJk5g4cWKV1LhlyxaYm5tr9XSQ8TOqh0kuX74cTZs2RUBAAKysrDBlyhSMHTsWZmZ/H8aPP/6IzZs344cffsCZM2ewceNGLFmyBBs3btS0WblyJY4dO4Y9e/bg9OnT+OKLLzB58mT8WjrYR4fo6Gg4OTlppgYNGlTrseoixN8h6YkLcEREJu3OnTuaadmyZXB0dNRaNmPGDE1bIQRKSkoqtV1XV9cqG5+1du1azJo1C1u2bEFhYWGVbPNZPX78WNL9mxQhkaKiImFubi527dqltXz06NHi1VdfrXDdR48eiVu3bgmVSiVmzZolWrRoofmufv36YtWqVVrtFy5cKPz9/YUQQjx8+FBYWlqKvXv3arUZP368CA8PL3efhYWFQqFQaKb09HQBQCgUisocbpW4ckUIQAgrKyEKCmpst0RkIh49eiQuXbokHj16JHUpz2z9+vXCyclJ8zkxMVEAEP/f//f/ibZt2wpLS0uRmJgoUlJSxKuvvirc3NyEnZ2daNeunYiPj9falo+Pj/jyyy81nwGI7777TgwcOFDI5XLRpEkT8Z///OepNV2/fl3I5XLx4MEDERISIjZv3lymzdq1a0WLFi2ElZWV8PDwEJMnT9Z8d//+fTFx4kTh5uYmrK2tRcuWLcXPP/8shBBi/vz5IjAwUGtbX375pfDx8dF8joyMFAMGDBCLFi0Snp6ewtfXVwghxPfffy+Cg4OFvb29cHd3FyNGjBBZWVla27p48aLo16+fcHBwEPb29qJz584iJSVFHDx4UFhYWIg7d+5otZ86daro3LnzU8+J1Cr6t65QKCr9+y3ZlSQrKysEBwcjoXSQDdQDtxMSEhAaGlrhujY2NvD29kZJSQl27NiBAQMGaL57+PCh1pUlADA3N4dKpQKgHuleXFxcYRtdrK2t4ejoqDXVtNKrSJ06Abw5hYiqghBAQYE0U1XeNjR79mx8+umnuHz5Mtq0aYP8/Hz07dsXCQkJOHv2LHr37o3+/fsjLS2twu189NFHGDZsGM6fP4++ffti5MiRuHfvXoXrrF+/Hv369YOTkxNGjRqldeMQAKxZswaTJ0/GxIkTceHCBezZswdNmjQBoP7d69OnD44ePYpNmzbh0qVL+PTTT/W+IyshIQFXrlxBfHw89u7dC0D9e7dw4UKcO3cOu3fvxp9//okxY8Zo1snIyEDXrl1hbW2N/fv34/Tp0xg3bhxKSkrQtWtXNG7cGDExMZr2xcXF2Lx5M8aNG6dXbUatOhJcZW3dulVYW1uLDRs2iEuXLomJEyeKOnXqiMzMTCGEEK+//rqYPXu2pv2xY8fEjh07RGpqqjh06JDo0aOHaNSokbh//76mTWRkpPD29hZ79+4VN27cEDt37hQuLi5i1qxZmjbdunUTLVu2FImJieL69eti/fr1wsbGRnz11VeVrl2fJFpVBg5UX0n65JMa2yURmRBd/+86P1/93xUppvx8/Y+hvCtJu3fvfuq6LVu2FCtXrtR81nUlKSoq6olzky8AiH379pW7TaVSKRo0aKDZ/927d4WVlZW4fv26po2Xl5eYO3euzvXj4uKEmZmZuHLlis7vK3slyd3dXRQVFZVbpxBCnDx5UgAQeXl5Qggh5syZIxo1aiQeP36ss/1nn30mmjdvrvm8Y8cOYW9vL/Kf5S+uhhn9lSQAiIiIwJIlSzBv3jwEBQUhOTkZsbGxmsHcaWlpWoOyCwsLERUVhRYtWmDQoEHw9vbGkSNHUKdOHU2blStXYujQoXj77bfRvHlzzJgxA2+++SYWLlyoabN161a0b98eI0eORIsWLfDpp59i8eLFBv0wyZISYP9+9TzHIxERaWvXrp3W5/z8fMyYMQPNmzdHnTp1YG9vj8uXLz/1SlKbNm0083Z2dnB0dNQ8vVmX+Ph4FBQUoG/fvgAAFxcXvPzyy1i3bh0A9QMNb9++jZ49e+pcPzk5GfXr10ezZs0qdZzlad26NaysrLSWnT59Gv3790fDhg3h4OCAbt26AYDmHCQnJ6NLly6wLOct6WPGjEFKSgqOHTsGANiwYQOGDRsGOzu756rVmEj+xO0pU6ZgypQpOr87cOCA1udu3brh0qVLFW7PwcEBy5Ytq/C2Tg8PD6xfv17fUiV18iSQmws4OwNt20pdDRGZCltbID9fun1XlX/+cM+YMQPx8fFYsmQJmjRpArlcjqFDhz51UPM/A4NMJqtwKMbatWtx7949zVOeAXUX2vnz5/HRRx9pLdflad+bmZlB/KNfUteLif95/AUFBQgPD0d4eDg2b94MV1dXpKWlITw8XHMOnrZvNzc39O/fH+vXr0ejRo2wb9++Mr/Lpk7ykESVUzoeqWdPoIpebkxEBJkMMMULA0ePHsWYMWMwaNAgAOorS3/++WeV7uOvv/7Cf/7zH2zduhUtW7bULFcqlejcuTP++9//onfv3vD19UVCQgJeeumlMtto06YNbt26hatXr+q8muTq6orMzEwIITSv1kpOTn5qbX/88Qf++usvfPrpp5q7sU+dOlVm3xs3bkRxcXG5V5MmTJiAESNGoH79+vDz80OnTp2eum9TYlSPAKjNSp9OwK42IqKna9q0KXbu3Ink5GScO3cO//d//1fhFaFnERMTg3r16mHYsGFo1aqVZgoMDETfvn01A7gXLFiAL774AitWrMC1a9dw5swZrFy5EoC6h6Rr164YMmQI4uPjcePGDezbtw+xsbEAgO7du+Pu3bv4/PPPkZqaitWrV2Pfvn1Pra1hw4awsrLCypUrcf36dezZs0dr2Amg7snJzc3F8OHDcerUKVy7dg0xMTG4cuWKpk14eDgcHR2xaNEijB07tqpOndFgSDICeXlA6UPI+RBJIqKnW7p0KZydndGxY0f0798f4eHhaFvFYxXWrVuHQYMGaa7wPGnIkCHYs2cPcnJyEBkZiWXLluGrr75Cy5Yt8corr+DatWuatjt27ED79u0xYsQItGjRArNmzYJSqQQANG/eHF999RVWr16NwMBAnDhxQuu5UOVxdXXFhg0b8NNPP2nG3i5ZskSrTb169bB//37k5+ejW7duCA4Oxnfffad1VcnMzAxjxoyBUqnE6NGjn/VUGS1J391mzGry3W179wL9+wONGwOpqdW6KyIyYXx3Gz2L8ePH4+7du9izZ4/UpVRaVb27jWOSjEBpVxuvIhERUU1RKBS4cOECfvjhB6MKSFWJIckI8FUkRERU0wYMGIATJ05g0qRJeLmW/r90hiQDl5EBXLqkvgOlRw+pqyEiotqitt3urwsHbhu40re2tGsH1K0rbS1ERES1CUOSgWNXGxERkTQYkgyYEBy0TUREJBWGJAN28SKQmal+dH/HjlJXQ0REVLswJBmw0qtIXbsC1tbS1kJERFTbMCQZMI5HIiIikg5DkoEqKgIOHlTPczwSEdHz6969O6ZNm6b57Ovri2XLllW4jkwmw+7du59731W1HapZDEkG6tgx4OFDwM0NaN1a6mqIiKTTv39/9O7dW+d3hw8fhkwmw/nz5/Xe7smTJzFx4sTnLU/LggULEBQUVGb5nTt30KdPnyrdV3kePXqEunXrwsXFBUVFRTWyT1PFkGSgnuxq0/HuRCKiWmP8+PGIj4/HrVu3yny3fv16tGvXDm3atNF7u66urrC1ta2KEp/Kw8MD1jU0uHTHjh1o2bIlAgICJL96JYRASUmJpDU8D4YkA1UaktjVRkS13SuvvKJ5q/2T8vPz8dNPP2H8+PH466+/MGLECHh7e8PW1hatW7fGli1bKtzuP7vbrl27hq5du8LGxgYtWrRAfOl/iJ/w/vvvo1mzZrC1tUXjxo3x4Ycfori4GACwYcMGfPTRRzh37hxkMhlkMpmm5n92t124cAE9evSAXC5HvXr1MHHiROTn52u+HzNmDAYOHIglS5bA09MT9erVw+TJkzX7qsjatWsxatQojBo1CmvXri3z/e+//45XXnkFjo6OcHBwQJcuXZD6xNvT161bh5YtW8La2hqenp6YMmUKAODPP/+ETCZDcnKypu2DBw8gk8k0T+c+cOAAZDIZ9u3bh+DgYFhbW+PIkSNITU3FgAED4O7uDnt7e7Rv3x6/lt6d9D9FRUV4//330aBBA1hbW6NJkyZYu3YthBBo0qQJlixZotU+OTkZMpkMKSkpTz0nz4qvJTFA9+8Dp06p5xmSiKhaCaHu25eCrW2lLpVbWFhg9OjR2LBhA+bOnQvZ/9b56aefoFQqMWLECOTn5yM4OBjvv/8+HB0d8csvv+D111+Hn58fOnTo8NR9qFQqDB48GO7u7jh+/DgUCoXW+KVSDg4O2LBhA7y8vHDhwgW88cYbcHBwwKxZsxAREYGLFy8iNjZWEwCcnJzKbKOgoADh4eEIDQ3FyZMnkZ2djQkTJmDKlClaQTAxMRGenp5ITExESkoKIiIiEBQUhDfeeKPc40hNTUVSUhJ27twJIQTee+893Lx5Ez4+PgCAjIwMdO3aFd27d8f+/fvh6OiIo0ePaq72rFmzBtOnT8enn36KPn36QKFQ4OjRo089f/80e/ZsLFmyBI0bN4azszPS09PRt29fLF68GNbW1vj+++/Rv39/XLlyBQ0bNgQAjB49GklJSVixYgUCAwNx48YN5OTkQCaTYdy4cVi/fj1mzJih2cf69evRtWtXNGnSRO/6Kk3QM1EoFAKAUCgUVb7tHTuEAIRo3rzKN01EtdijR4/EpUuXxKNHj/5emJ+v/g+OFFN+fqVrv3z5sgAgEhMTNcu6dOkiRo0aVe46/fr1E//61780n7t16yamTp2q+ezj4yO+/PJLIYQQcXFxwsLCQmRkZGi+37dvnwAgdu3aVe4+/v3vf4vg4GDN5/nz54vAwMAy7Z7czrfffiucnZ1F/hPH/8svvwgzMzORmZkphBAiMjJS+Pj4iJKSEk2b1157TURERJRbixBCfPDBB2LgwIGazwMGDBDz58/XfJ4zZ45o1KiRePz4sc71vby8xNy5c3V+d+PGDQFAnD17VrPs/v37Wn8viYmJAoDYvXt3hXUKIUTLli3FypUrhRBCXLlyRQAQ8fHxOttmZGQIc3Nzcfz4cSGEEI8fPxYuLi5iw4YNOtvr/Lf+P/r8frO7zQDx1n8iIm0BAQHo2LEj1q1bBwBISUnB4cOHMX78eACAUqnEwoUL0bp1a9StWxf29vaIi4tDWlpapbZ/+fJlNGjQAF5eXpploaGhZdpt27YNnTp1goeHB+zt7REVFVXpfTy5r8DAQNjZ2WmWderUCSqVCleuXNEsa9myJczNzTWfPT09kZ2dXe52lUolNm7ciFGjRmmWjRo1Chs2bIBKpQKg7qLq0qULLC0ty6yfnZ2N27dvo2fPnnodjy7t2rXT+pyfn48ZM2agefPmqFOnDuzt7XH58mXNuUtOToa5uTm6deumc3teXl7o16+f5u//559/RlFREV577bXnrrUi7G4zQByPREQ1xtYWeGIsTI3vWw/jx4/HO++8g9WrV2P9+vXw8/PT/Kj++9//xvLly7Fs2TK0bt0adnZ2mDZtGh4/flxl5SYlJWHkyJH46KOPEB4eDicnJ2zduhVffPFFle3jSf8MMjKZTBN2dImLi0NGRgYiIiK0liuVSiQkJODll1+GXC4vd/2KvgMAMzP1dRUhhGZZeWOkngyAADBjxgzEx8djyZIlaNKkCeRyOYYOHar5+3navgFgwoQJeP311/Hll19i/fr1iIiIqPaB97ySZGBu3ABSUwFzc6B7d6mrISKTJ5MBdnbSTHreujts2DCYmZnhhx9+wPfff49x48ZpxicdPXoUAwYMwKhRoxAYGIjGjRvj6tWrld528+bNkZ6ejjt37miWHTt2TKvNb7/9Bh8fH8ydOxft2rVD06ZNcfPmTa02VlZWUCqVT93XuXPnUFBQoFl29OhRmJmZwd/fv9I1/9PatWsxfPhwJCcna03Dhw/XDOBu06YNDh8+rDPcODg4wNfXFwkJCTq37+rqCgBa5+jJQdwVOXr0KMaMGYNBgwahdevW8PDwwJ9//qn5vnXr1lCpVDhY+oBAHfr27Qs7OzusWbMGsbGxGDduXKX2/TwYkgxM6WD/F18EHBykrYWIyJDY29sjIiICc+bMwZ07dzBmzBjNd02bNkV8fDx+++03XL58GW+++SaysrIqve2wsDA0a9YMkZGROHfuHA4fPoy5c+dqtWnatCnS0tKwdetWpKamYsWKFdi1a5dWG19fX9y4cQPJycnIycnR+ZyikSNHwsbGBpGRkbh48SISExPxzjvv4PXXX4e7u7t+J+V/7t69i59//hmRkZFo1aqV1jR69Gjs3r0b9+7dw5QpU5Cbm4vhw4fj1KlTuHbtGmJiYjTdfAsWLMAXX3yBFStW4Nq1azhz5gxWrlwJQH2158UXX8Snn36Ky5cv4+DBg4iKiqpUfU2bNsXOnTuRnJyMc+fO4f/+7/+0ror5+voiMjIS48aNw+7du3Hjxg0cOHAAP/74o6aNubk5xowZgzlz5qBp06Y6u0OrGkOSgcnJAeRydrUREekyfvx43L9/H+Hh4Vrjh6KiotC2bVuEh4eje/fu8PDwwMCBAyu9XTMzM+zatQuPHj1Chw4dMGHCBCxevFirzauvvor33nsPU6ZMQVBQEH777Td8+OGHWm2GDBmC3r1746WXXoKrq6vOxxDY2toiLi4O9+7dQ/v27TF06FD07NkTq1at0u9kPOH777+HnZ2dzvFEPXv2hFwux6ZNm1CvXj3s378f+fn56NatG4KDg/Hdd99puvYiIyOxbNkyfPXVV2jZsiVeeeUVXLt2TbOtdevWoaSkBMHBwZg2bRoWLVpUqfqWLl0KZ2dndOzYEf3790d4eDjatm2r1WbNmjUYOnQo3n77bQQEBOCNN97QutoGqP/+Hz9+jLFjx+p7ip6JTDzZuUiVlpubCycnJygUCjg6OlbptouK1FMVb5aIarnCwkLcuHEDjRo1go2NjdTlEOnt8OHD6NmzJ9LT0yu86lbRv3V9fr85cNsAWVurJyIiIlI/aPLu3btYsGABXnvttWfultQXu9uIiIjIoG3ZsgU+Pj548OABPv/88xrbL0MSERERGbQxY8ZAqVTi9OnT8Pb2rrH9MiQRERER6cCQRERERKQDQxIRUS3Dm5rJ1FXVv3GGJCKiWqL0WTgPHz6UuBKi6lX6b1zXO+r0wUcAEBHVEubm5qhTp47mJam2traa13oQmQIhBB4+fIjs7GzUqVNH6wXBz4IhiYioFvHw8ACACt8mT2Ts6tSpo/m3/jwYkoiIahGZTAZPT0+4ubmV+wZ3ImNmaWn53FeQSjEkERHVQubm5lX2Q0Jkqjhwm4iIiEgHhiQiIiIiHRiSiIiIiHTgmKRnVPqgqtzcXIkrISIiosoq/d2uzAMnGZKeUV5eHgCgQYMGEldCRERE+srLy4OTk1OFbWSCz6d/JiqVCrdv34aDg0OVP4wtNzcXDRo0QHp6OhwdHat02/Q3nueawfNcM3ieawbPc82ozvMshEBeXh68vLxgZlbxqCNeSXpGZmZmqF+/frXuw9HRkf8jrAE8zzWD57lm8DzXDJ7nmlFd5/lpV5BKceA2ERERkQ4MSUREREQ6MCQZIGtra8yfPx/W1tZSl2LSeJ5rBs9zzeB5rhk8zzXDUM4zB24TERER6cArSUREREQ6MCQRERER6cCQRERERKQDQxIRERGRDgxJBuTQoUPo378/vLy8IJPJsHv3bqlLMjnR0dFo3749HBwc4ObmhoEDB+LKlStSl2WS1qxZgzZt2mgeBhcaGop9+/ZJXZZJ+/TTTyGTyTBt2jSpSzE5CxYsgEwm05oCAgKkLsskZWRkYNSoUahXrx7kcjlat26NU6dOSVILQ5IBKSgoQGBgIFavXi11KSbr4MGDmDx5Mo4dO4b4+HgUFxejV69eKCgokLo0k1O/fn18+umnOH36NE6dOoUePXpgwIAB+P3336UuzSSdPHkS33zzDdq0aSN1KSarZcuWuHPnjmY6cuSI1CWZnPv376NTp06wtLTEvn37cOnSJXzxxRdwdnaWpB6+lsSA9OnTB3369JG6DJMWGxur9XnDhg1wc3PD6dOn0bVrV4mqMk39+/fX+rx48WKsWbMGx44dQ8uWLSWqyjTl5+dj5MiR+O6777Bo0SKpyzFZFhYW8PDwkLoMk/bZZ5+hQYMGWL9+vWZZo0aNJKuHV5KoVlMoFACAunXrSlyJaVMqldi6dSsKCgoQGhoqdTkmZ/LkyejXrx/CwsKkLsWkXbt2DV5eXmjcuDFGjhyJtLQ0qUsyOXv27EG7du3w2muvwc3NDS+88AK+++47yerhlSSqtVQqFaZNm4ZOnTqhVatWUpdjki5cuIDQ0FAUFhbC3t4eu3btQosWLaQuy6Rs3boVZ86cwcmTJ6UuxaSFhIRgw4YN8Pf3x507d/DRRx+hS5cuuHjxIhwcHKQuz2Rcv34da9aswfTp0/HBBx/g5MmTePfdd2FlZYXIyMgar4chiWqtyZMn4+LFixxXUI38/f2RnJwMhUKB7du3IzIyEgcPHmRQqiLp6emYOnUq4uPjYWNjI3U5Ju3JoRBt2rRBSEgIfHx88OOPP2L8+PESVmZaVCoV2rVrh08++QQA8MILL+DixYv4+uuvJQlJ7G6jWmnKlCnYu3cvEhMTUb9+fanLMVlWVlZo0qQJgoODER0djcDAQCxfvlzqskzG6dOnkZ2djbZt28LCwgIWFhY4ePAgVqxYAQsLCyiVSqlLNFl16tRBs2bNkJKSInUpJsXT07PM/4lq3ry5ZF2bvJJEtYoQAu+88w527dqFAwcOSDogsDZSqVQoKiqSugyT0bNnT1y4cEFr2dixYxEQEID3338f5ubmElVm+vLz85GamorXX39d6lJMSqdOnco8luXq1avw8fGRpB6GJAOSn5+v9f9Kbty4geTkZNStWxcNGzaUsDLTMXnyZPzwww/4z3/+AwcHB2RmZgIAnJycIJfLJa7OtMyZMwd9+vRBw4YNkZeXhx9++AEHDhxAXFyc1KWZDAcHhzLj6ezs7FCvXj2Os6tiM2bMQP/+/eHj44Pbt29j/vz5MDc3x4gRI6QuzaS899576NixIz755BMMGzYMJ06cwLfffotvv/1WmoIEGYzExEQBoMwUGRkpdWkmQ9f5BSDWr18vdWkmZ9y4ccLHx0dYWVkJV1dX0bNnT/Hf//5X6rJMXrdu3cTUqVOlLsPkRERECE9PT2FlZSW8vb1FRESESElJkbosk/Tzzz+LVq1aCWtraxEQECC+/fZbyWqRCSGENPGMiIiIyHBx4DYRERGRDgxJRERERDowJBERERHpwJBEREREpANDEhEREZEODElEREREOjAkEREREenAkEREVEVkMhl2794tdRlEVEUYkojIJIwZMwYymazM1Lt3b6lLIyIjxXe3EZHJ6N27N9avX6+1zNraWqJqiMjY8UoSEZkMa2treHh4aE3Ozs4A1F1ha9asQZ8+fSCXy9G4cWNs375da/0LFy6gR48ekMvlqFevHiZOnIj8/HytNuvWrUPLli1hbW0NT09PTJkyRev7nJwcDBo0CLa2tmjatCn27NlTvQdNRNWGIYmIao0PP/wQQ4YMwblz5zBy5EgMHz4cly9fBgAUFBQgPDwczs7OOHnyJH766Sf8+uuvWiFozZo1mDx5MiZOnIgLFy5gz549aNKkidY+PvroIwwbNgznz59H3759MXLkSNy7d69Gj5OIqohkr9YlIqpCkZGRwtzcXNjZ2WlNixcvFkIIAUBMmjRJa52QkBDx1ltvCSGE+Pbbb4Wzs7PIz8/XfP/LL78IMzMzkZmZKYQQwsvLS8ydO7fcGgCIqKgozef8/HwBQOzbt6/KjpOIag7HJBGRyXjppZewZs0arWV169bVzIeGhmp9FxoaiuTkZADA5cuXERgYCDs7O833nTp1gkqlwpUrVyCTyXD79m307NmzwhratGmjmbezs4OjoyOys7Of9ZCISEIMSURkMuzs7Mp0f1UVuVxeqXaWlpZan2UyGVQqVXWURETVjGOSiKjWOHbsWJnPzZs3BwA0b94c586dQ0FBgeb7o0ePwszMDP7+/nBwcICvry8SEhJqtGYikg6vJBGRySgqKkJmZqbWMgsLC7i4uAAAfvrpJ7Rr1w6dO3fG5s2bceLECaxduxYAMHLkSMyfPx+RkZFYsGAB7t69i3feeQevv/463N3dAQALFizApEmT4Obmhj59+iAvLw9Hjx7FO++8U7MHSkQ1giGJiExGbGwsPD09tZb5+/vjjz/+AKC+82zr1q14++234enpiS1btqBFixYAAFtbW8TFxWHq1Klo3749bG1tMWTIECxdulSzrcjISBQWFuLLL7/EjBkz4OLigqFDh9bcARJRjZIJIYTURRARVTeZTIZdu3Zh4MCBUpdCREaCY5KIiIiIdGBIIiIiItKBY5KIqFbgyAIi0hevJBERERHpwJBEREREpANDEhEREZEODElEREREOjAkEREREenAkERERESkA0MSERERkQ4MSUREREQ6MCQRERER6fD/A9PC0U27QqdhAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "67"
+      ]
+     },
+     "execution_count": 4,
+     "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",
+    "model1 = models.resnet18(pretrained=False)\n",
+    "model2 = models.resnet50(pretrained=False)\n",
+    "\n",
+    "num_classes = 2\n",
+    "\n",
+    "model1.fc = nn.Linear(model1.fc.in_features, num_classes)\n",
+    "model2.fc = nn.Linear(model2.fc.in_features, num_classes)\n",
+    "\n",
+    "class Ensemble(nn.Module):\n",
+    "    def __init__(self, model1, model2):\n",
+    "        super(Ensemble, self).__init__()\n",
+    "        self.model1 = model1\n",
+    "        self.model2 = model2\n",
+    "        self.fc = nn.Linear(2 * num_classes, num_classes)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x1 = self.model1(x[0])\n",
+    "        x2 = self.model2(x[1])\n",
+    "        x = torch.cat((x1, x2), dim=1)\n",
+    "        x = self.fc(x)\n",
+    "        return x\n",
+    "model = Ensemble(model1, model2)\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 = 10000, path_dataset = \"/mnt/data/Dataset_img\", \n",
+    "                     selected_freq=2400,model_name = config_name+\"2400_\", config_name = config_name, model=model)\n",
+    "\n",
+    "\n",
+    "torch.cuda.empty_cache()\n",
+    "cv2.destroyAllWindows()\n",
+    "del model\n",
+    "gc.collect()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/train_scripts/Training_models_1.2.ipynb b/train_scripts/Training_models_1.2.ipynb
index 5e170f5..c2a7f77 100644
--- a/train_scripts/Training_models_1.2.ipynb
+++ b/train_scripts/Training_models_1.2.ipynb
@@ -24,6 +24,14 @@
     "tags": []
    },
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/sibscience-4/from_ssh/DroneDetector/.venv-train/lib/python3.12/site-packages/matplotlib/projections/__init__.py:63: UserWarning: Unable to import Axes3D. This may be due to multiple versions of Matplotlib being installed (e.g. as a system package and as a pip package). As a result, the 3D projection is not available.\n",
+      "  warnings.warn(\"Unable to import Axes3D. This may be due to multiple versions of \"\n"
+     ]
+    },
     {
      "name": "stdout",
      "output_type": "stream",
@@ -34,7 +42,7 @@
     {
      "data": {
       "text/plain": [
-       "112"
+       "191"
       ]
      },
      "execution_count": 1,
@@ -98,7 +106,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": null,
    "id": "46e4dc99-6994-4fee-a32e-f3983bd991bd",
    "metadata": {},
    "outputs": [],
@@ -106,6 +114,7 @@
     "def prepare_and_learning_detection(num_classes, num_samples, path_dataset, model_name, config_name, model,selected_freq):\n",
     "    num_samples_per_class = num_samples // num_classes\n",
     "\n",
+    "\n",
     "    #----------Создаём папку для сохранения результатов обучения--------------\n",
     "    os.makedirs(\"models\", exist_ok=True)\n",
     "    ind = 1\n",
@@ -177,6 +186,7 @@
     "                for row in list(reader)[1:]:\n",
     "                    row = str(row)\n",
     "                    data.append(row[2: len(row)-2])\n",
+    "\n",
     "            self.sig_filenames = data\n",
     "            self.path_dataset = path_dataset\n",
     "    \n",
@@ -186,6 +196,9 @@
     "        def __getitem__(self, idx):\n",
     "            base = os.path.splitext(self.sig_filenames[idx])[0]\n",
     "\n",
+    "            #raise(base)\n",
+    "\n",
+    "            exit(1)\n",
     "            image_real = np.asarray(cv2.split(cv2.imread(base + '_real.png')), dtype=np.float32)\n",
     "            image_imag = np.asarray(cv2.split(cv2.imread(base + '_imag.png')), dtype=np.float32)\n",
     "            image_spec = np.asarray(cv2.split(cv2.imread(base + '_spec.png')), dtype=np.float32)\n",
@@ -193,11 +206,12 @@
     "            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",
+    "                exit(1)\n",
     "                label = torch.tensor(1)\n",
     "            return image_real, image_imag, image_spec, label\n",
     "    \n",
     "    #----------Создаём датасет--------------\n",
-    "    \n",
+    "    exit(1)\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",
@@ -332,242 +346,40 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 13,
    "id": "52e8d4c5",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/sibscience-4/from_ssh/DroneDetector/.venv-train/lib/python3.12/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",
-      "/home/sibscience-4/from_ssh/DroneDetector/.venv-train/lib/python3.12/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=None`.\n",
-      "  warnings.warn(msg)\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "['noise', 'drone']\n",
-      "Epoch : 1\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 168/168 [01:10<00:00,  2.39it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "train Loss: 0.0628 Acc: 0.9956\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 72/72 [00:11<00:00,  6.27it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "val Loss: 0.0029 Acc: 1.0000\n",
-      "\n",
-      "Epoch : 2\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 168/168 [01:10<00:00,  2.38it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "train Loss: 0.0018 Acc: 0.9956\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 72/72 [00:11<00:00,  6.13it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "val Loss: 0.0011 Acc: 1.0000\n",
-      "\n",
-      "Epoch : 3\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 168/168 [01:10<00:00,  2.38it/s]\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "train Loss: 0.0008 Acc: 0.9956\n"
+      "['noise', 'drone']\n"
      ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|██████████| 72/72 [00:11<00:00,  6.20it/s]\n"
+      "/tmp/ipykernel_3754538/2835334388.py:103: UserWarning: Length of split at index 0 is 0. This might result in an empty dataset.\n",
+      "  train_set, valid_set = torch.utils.data.random_split(dataset, [0.7, 0.3], generator=torch.Generator().manual_seed(42))\n",
+      "/tmp/ipykernel_3754538/2835334388.py:103: UserWarning: Length of split at index 1 is 0. This might result in an empty dataset.\n",
+      "  train_set, valid_set = torch.utils.data.random_split(dataset, [0.7, 0.3], generator=torch.Generator().manual_seed(42))\n"
      ]
     },
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "val Loss: 0.0006 Acc: 1.0000\n",
-      "\n",
-      "Epoch : 4\n",
-      "\n"
+     "ename": "ValueError",
+     "evalue": "num_samples should be a positive integer value, but got num_samples=0",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
+      "\u001b[31mValueError\u001b[39m                                Traceback (most recent call last)",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[13]\u001b[39m\u001b[32m, line 49\u001b[39m\n\u001b[32m     45\u001b[39m     model = model.to(device)\n\u001b[32m     46\u001b[39m \n\u001b[32m     47\u001b[39m \u001b[38;5;66;03m#----------Создания датасета и обучение модели--------------\u001b[39;00m\n\u001b[32m     48\u001b[39m \n\u001b[32m---> \u001b[39m\u001b[32m49\u001b[39m path_res, model_name = prepare_and_learning_detection(num_classes = num_classes, num_samples = 10000, path_dataset = \"/mnt/data/Dataset_img\", \n\u001b[32m     50\u001b[39m                      selected_freq=\u001b[32m2400\u001b[39m,model_name = config_name+\u001b[33m\"_2.4_jpg_\"\u001b[39m, config_name = config_name, model=model)\n\u001b[32m     51\u001b[39m \n\u001b[32m     52\u001b[39m \n",
+      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[12]\u001b[39m\u001b[32m, line 105\u001b[39m, in \u001b[36mprepare_and_learning_detection\u001b[39m\u001b[34m(num_classes, num_samples, path_dataset, model_name, config_name, model, selected_freq)\u001b[39m\n\u001b[32m    101\u001b[39m     exit(\u001b[32m1\u001b[39m)\n\u001b[32m    102\u001b[39m     dataset = MyDataset(path_dataset=path_res, csv_file=\u001b[33m'dataset.csv'\u001b[39m)\n\u001b[32m    103\u001b[39m     train_set, valid_set = torch.utils.data.random_split(dataset, [\u001b[32m0.7\u001b[39m, \u001b[32m0.3\u001b[39m], generator=torch.Generator().manual_seed(\u001b[32m42\u001b[39m))\n\u001b[32m    104\u001b[39m     batch_size = config.batch_size\n\u001b[32m--> \u001b[39m\u001b[32m105\u001b[39m     train_dataloader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, shuffle=\u001b[38;5;28;01mTrue\u001b[39;00m, drop_last=\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[32m    106\u001b[39m     valid_dataloader = torch.utils.data.DataLoader(valid_set, batch_size=batch_size, shuffle=\u001b[38;5;28;01mTrue\u001b[39;00m, drop_last=\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[32m    107\u001b[39m \n\u001b[32m    108\u001b[39m     dataloaders = {}\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/from_ssh/DroneDetector/.venv-train/lib/python3.12/site-packages/torch/utils/data/dataloader.py:394\u001b[39m, in \u001b[36mDataLoader.__init__\u001b[39m\u001b[34m(self, dataset, batch_size, shuffle, sampler, batch_sampler, num_workers, collate_fn, pin_memory, drop_last, timeout, worker_init_fn, multiprocessing_context, generator, prefetch_factor, persistent_workers, pin_memory_device, in_order)\u001b[39m\n\u001b[32m    392\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:  \u001b[38;5;66;03m# map-style\u001b[39;00m\n\u001b[32m    393\u001b[39m     \u001b[38;5;28;01mif\u001b[39;00m shuffle:\n\u001b[32m--> \u001b[39m\u001b[32m394\u001b[39m         sampler = \u001b[30;43mRandomSampler\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mdataset\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mgenerator\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mgenerator\u001b[39;49m\u001b[30;43m)\u001b[39;49m  \u001b[38;5;66;03m# type: ignore[arg-type]\u001b[39;00m\n\u001b[32m    395\u001b[39m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m    396\u001b[39m         sampler = SequentialSampler(dataset)  \u001b[38;5;66;03m# type: ignore[arg-type]\u001b[39;00m\n",
+      "\u001b[36mFile \u001b[39m\u001b[32m~/from_ssh/DroneDetector/.venv-train/lib/python3.12/site-packages/torch/utils/data/sampler.py:149\u001b[39m, in \u001b[36mRandomSampler.__init__\u001b[39m\u001b[34m(self, data_source, replacement, num_samples, generator)\u001b[39m\n\u001b[32m    144\u001b[39m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\n\u001b[32m    145\u001b[39m         \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mreplacement should be a boolean value, but got replacement=\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m.replacement\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m\n\u001b[32m    146\u001b[39m     )\n\u001b[32m    148\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(\u001b[38;5;28mself\u001b[39m.num_samples, \u001b[38;5;28mint\u001b[39m) \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m.num_samples <= \u001b[32m0\u001b[39m:\n\u001b[32m--> \u001b[39m\u001b[32m149\u001b[39m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[32m    150\u001b[39m         \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mnum_samples should be a positive integer value, but got num_samples=\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m.num_samples\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m\n\u001b[32m    151\u001b[39m     )\n",
+      "\u001b[31mValueError\u001b[39m: num_samples should be a positive integer value, but got num_samples=0"
      ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 168/168 [01:10<00:00,  2.38it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "train Loss: 0.0005 Acc: 0.9956\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 72/72 [00:11<00:00,  6.13it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "val Loss: 0.0004 Acc: 1.0000\n",
-      "\n",
-      "Epoch : 5\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 168/168 [01:10<00:00,  2.38it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "train Loss: 0.0003 Acc: 0.9956\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 72/72 [00:11<00:00,  6.12it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "val Loss: 0.0003 Acc: 1.0000\n",
-      "\n",
-      "Epoch : 6\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 168/168 [01:10<00:00,  2.38it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "train Loss: 0.0002 Acc: 0.9956\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 72/72 [00:11<00:00,  6.11it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "val Loss: 0.0002 Acc: 1.0000\n",
-      "Total time elapsed = 493.41988416798995 seconds\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkkAAAHHCAYAAACr0swBAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAASbFJREFUeJzt3Xl4Dvf+//HXnci+CSILEUs1QYnTWBot6jQVSx1LVDg0obTVojRHW0pLq6qLqrW6HEuLllqr9cVJY2k5WooopZbQIhKhJRsics/vD7/ex92MJRpu0ufjuua63J/7fc+8Z5pz3a8z87lnLIZhGAIAAIAdJ0c3AAAAcCsiJAEAAJggJAEAAJggJAEAAJggJAEAAJggJAEAAJggJAEAAJggJAEAAJggJAEAAJggJAEAAJggJAG4qnfffVcWi0VNmzZ1dCu3pePHj2vo0KGKiIiQp6envLy8FBUVpVdffVWnT592dHsALsPCs9sAXM29996rY8eO6eeff9b+/ft1xx13OLql28aWLVvUrl075eXlqVevXoqKipIkff/995o/f76aNWum//znPw7uEoAZQhKAKzp06JBq1qypJUuW6IknntCAAQM0atQoR7dlKj8/X15eXo5uw+b06dO66667dOHCBa1bt04RERF27x8/flwffvihRo4c+ae3davtO1AWcLkNwBXNmzdP/v7+at++vbp27ap58+aZ1p0+fVrPPPOMqlevLjc3N1WtWlUJCQk6efKkrebcuXMaPXq07rzzTrm7uys4OFhdunRRWlqaJGndunWyWCxat26d3bp//vlnWSwWzZ492zbWu3dveXt7Ky0tTe3atZOPj4969uwpSfrmm2/08MMPq1q1anJzc1NoaKieeeYZnT17tljfP/30k7p166aAgAB5eHgoPDxcI0aMkCStXbtWFotFS5cuLfa5Tz75RBaLRZs2bbrssXv//feVnp6uCRMmFAtIkhQYGGgXkCwWi0aPHl2srnr16urdu7ft9ezZs2WxWLR+/Xo99dRTqly5sqpWrapFixbZxs16sVgs2rVrl92+d+3aVRUqVJC7u7saNWqk5cuXX3Z/gL+aco5uAMCtbd68eerSpYtcXV3Vo0cPTZ8+XVu2bFHjxo1tNXl5eWrevLn27NmjRx99VHfffbdOnjyp5cuX6+jRo6pUqZKKior00EMPKSUlRd27d9fgwYOVm5ur5ORk7dq1S7Vq1SpxbxcuXFBsbKzuu+8+jR8/Xp6enpKkhQsX6syZM3ryySdVsWJFbd68WVOmTNHRo0e1cOFC2+d/+OEHNW/eXC4uLnr88cdVvXp1paWl6YsvvtDYsWN1//33KzQ0VPPmzVPnzp2LHZdatWopOjr6sv0tX75cHh4e6tq1a4n37Vo89dRTCggI0EsvvaT8/Hy1b99e3t7e+uyzz9SyZUu72gULFqhevXq66667JEk//vij7r33XlWpUkXDhg2Tl5eXPvvsM3Xq1EmLFy8utr/AX5IBAJfx/fffG5KM5ORkwzAMw2q1GlWrVjUGDx5sV/fSSy8ZkowlS5YUW4fVajUMwzBmzpxpSDImTJhw2Zq1a9cakoy1a9favX/o0CFDkjFr1izbWGJioiHJGDZsWLH1nTlzptjYuHHjDIvFYvzyyy+2sRYtWhg+Pj52Y5f2YxiGMXz4cMPNzc04ffq0bSwrK8soV66cMWrUqGLbuZS/v78RGRl5xZpLSTJdZ1hYmJGYmGh7PWvWLEOScd999xkXLlywq+3Ro4dRuXJlu/GMjAzDycnJeOWVV2xjDzzwgFG/fn3j3LlztjGr1Wo0a9bMqF279jX3DJRlXG4DcFnz5s1TYGCgWrVqJeni5aD4+HjNnz9fRUVFtrrFixcrMjLS9OyDxWKx1VSqVEmDBg26bM31ePLJJ4uNeXh42P6dn5+vkydPqlmzZjIMQ9u3b5cknThxQl9//bUeffRRVatW7bL9JCQkqKCgQIsWLbKNLViwQBcuXFCvXr2u2FtOTo58fHyua7+uxWOPPSZnZ2e7sfj4eGVlZdldsly0aJGsVqvi4+MlSb/99pvWrFmjbt26KTc3VydPntTJkyf166+/KjY2Vvv371d6evoN6xu4XRCSAJgqKirS/Pnz1apVKx06dEgHDhzQgQMH1LRpUx0/flwpKSm22rS0NNtlnMtJS0tTeHi4ypUrvav85cqVU9WqVYuNHz58WL1791aFChXk7e2tgIAA2+Wn7OxsSdLBgwcl6ap9R0REqHHjxnZzsebNm6d77rnnqr/y8/X1VW5ubon2qSRq1KhRbKxNmzby8/PTggULbGMLFixQw4YNdeedd0qSDhw4IMMw9OKLLyogIMBu+X1SflZW1g3rG7hdMCcJgKk1a9YoIyND8+fP1/z584u9P2/ePLVu3bpUt3m5M0qXnrW6lJubm5ycnIrVPvjgg/rtt9/0/PPPKyIiQl5eXkpPT1fv3r1ltVpL3FdCQoIGDx6so0ePqqCgQN9++62mTp161c9FREQoNTVV58+fl6ura4m3+7vL7f+lZ8x+5+bmpk6dOmnp0qV69913dfz4cW3cuFGvvfaareb3YzB06FDFxsaarpvbPACEJACXMW/ePFWuXFnTpk0r9t6SJUu0dOlSvffee/Lw8FCtWrXsfjVlplatWvruu+9UWFgoFxcX0xp/f39JKnaDxV9++eWa+965c6f27dunjz76SAkJCbbx5ORku7qaNWtK0lX7lqTu3bsrKSlJn376qc6ePSsXFxfbpasr6dChgzZt2qTFixerR48eV6339/cvtu/nz59XRkbGVT97qfj4eH300UdKSUnRnj17ZBiGXb+/77uLi4tiYmJKtG7gr4TLbQCKOXv2rJYsWaKHHnpIXbt2LbYMHDhQubm5tp+Lx8XFaceOHaY/lTf+/63Y4uLidPLkSdMzML/XhIWFydnZWV9//bXd++++++419/77HB3jklvAGYahSZMm2dUFBASoRYsWmjlzpg4fPmzaz+8qVaqktm3bau7cuZo3b57atGmjSpUqXbWX/v37Kzg4WP/617+0b9++Yu9nZWXp1Vdftb2uVatWsX3/4IMPLnsm6XJiYmJUoUIFLViwQAsWLFCTJk3sLs1VrlxZ999/v95//33TAHbixIkSbQ8oqziTBKCY5cuXKzc3V//4xz9M37/nnnsUEBCgefPmKT4+Xs8++6wWLVqkhx9+WI8++qiioqL022+/afny5XrvvfcUGRmphIQEffzxx0pKStLmzZvVvHlz5efn66uvvtJTTz2ljh07ys/PTw8//LCmTJkii8WiWrVq6csvvyzR/JiIiAjVqlVLQ4cOVXp6unx9fbV48WKdOnWqWO3kyZN133336e6779bjjz+uGjVq6Oeff9aKFSuUmppqV5uQkGD7Kf+YMWOuqRd/f38tXbpU7dq1U8OGDe3uuL1t2zZ9+umndrcQ6Nevn/r376+4uDg9+OCD2rFjh1avXn1NgexSLi4u6tKli+bPn6/8/HyNHz++WM20adN03333qX79+nrsscdUs2ZNHT9+XJs2bdLRo0e1Y8eOEm0TKJMc98M6ALeqDh06GO7u7kZ+fv5la3r37m24uLgYJ0+eNAzDMH799Vdj4MCBRpUqVQxXV1ejatWqRmJiou19w7j40/wRI0YYNWrUMFxcXIygoCCja9euRlpamq3mxIkTRlxcnOHp6Wn4+/sbTzzxhLFr1y7TWwB4eXmZ9rZ7924jJibG8Pb2NipVqmQ89thjxo4dO4qtwzAMY9euXUbnzp2N8uXLG+7u7kZ4eLjx4osvFltnQUGB4e/vb/j5+Rlnz569lsNoc+zYMeOZZ54x7rzzTsPd3d3w9PQ0oqKijLFjxxrZ2dm2uqKiIuP55583KlWqZHh6ehqxsbHGgQMHLnsLgC1btlx2m8nJyYYkw2KxGEeOHDGtSUtLMxISEoygoCDDxcXFqFKlivHQQw8ZixYtKtH+AWUVjyUBgGtw4cIFhYSEqEOHDpoxY4aj2wFwEzAnCQCuwbJly3TixAm7yeAAyjbOJAHAFXz33Xf64YcfNGbMGFWqVEnbtm1zdEsAbhLOJAHAFUyfPl1PPvmkKleurI8//tjR7QC4iTiTBAAAYIIzSQAAACYISQAAACa4meR1slqtOnbsmHx8fP7UE8wBAMDNYxiGcnNzFRISUuzZj39ESLpOx44dU2hoqKPbAAAA1+HIkSOqWrXqFWsISdfJx8dH0sWD7Ovr6+BuAADAtcjJyVFoaKjte/xKCEnX6fdLbL6+voQkAABuM9cyVYaJ2wAAACYISQAAACYISQAAACYISQAAACYISQAAACYISQAAACYISQAAACYISQAAACYISQAAACYISQAAACYcGpK+/vprdejQQSEhIbJYLFq2bNlVP7Nu3TrdfffdcnNz0x133KHZs2cXq5k2bZqqV68ud3d3NW3aVJs3b7Z7/9y5cxowYIAqVqwob29vxcXF6fjx46W0VwAAoCxwaEjKz89XZGSkpk2bdk31hw4dUvv27dWqVSulpqZqyJAh6tevn1avXm2rWbBggZKSkjRq1Cht27ZNkZGRio2NVVZWlq3mmWee0RdffKGFCxdq/fr1OnbsmLp06VLq+wcAAG5fFsMwDEc3IV180NzSpUvVqVOny9Y8//zzWrFihXbt2mUb6969u06fPq1Vq1ZJkpo2barGjRtr6tSpkiSr1arQ0FANGjRIw4YNU3Z2tgICAvTJJ5+oa9eukqSffvpJderU0aZNm3TPPfdcU785OTny8/NTdnZ26T7g1jCkM2dKb30AANyuPD2la3gQbUmU5Pu7XKlu+QbbtGmTYmJi7MZiY2M1ZMgQSdL58+e1detWDR8+3Pa+k5OTYmJitGnTJknS1q1bVVhYaLeeiIgIVatW7YohqaCgQAUFBbbXOTk5pbVb9s6ckby9b8y6AQC4neTlSV5eDtv8bTVxOzMzU4GBgXZjgYGBysnJ0dmzZ3Xy5EkVFRWZ1mRmZtrW4erqqvLly1+2xsy4cePk5+dnW0JDQ0tnpwAAwC3ptjqT5EjDhw9XUlKS7XVOTs6NCUqenheTMwAAf3Weng7d/G0VkoKCgor9Cu348ePy9fWVh4eHnJ2d5ezsbFoTFBRkW8f58+d1+vRpu7NJl9aYcXNzk5ubW+ntzOVYLA49tQgAAC66rS63RUdHKyUlxW4sOTlZ0dHRkiRXV1dFRUXZ1VitVqWkpNhqoqKi5OLiYlezd+9eHT582FYDAADg0DNJeXl5OnDggO31oUOHlJqaqgoVKqhatWoaPny40tPT9fHHH0uS+vfvr6lTp+q5557To48+qjVr1uizzz7TihUrbOtISkpSYmKiGjVqpCZNmmjixInKz89Xnz59JEl+fn7q27evkpKSVKFCBfn6+mrQoEGKjo6+5l+2AQCAss+hIen7779Xq1atbK9/n/OTmJio2bNnKyMjQ4cPH7a9X6NGDa1YsULPPPOMJk2apKpVq+rf//63YmNjbTXx8fE6ceKEXnrpJWVmZqphw4ZatWqV3WTud955R05OToqLi1NBQYFiY2P17rvv3oQ9BgAAt4tb5j5Jt5sbdp8kAABww5Tk+/u2mpMEAABwsxCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATDg8JE2bNk3Vq1eXu7u7mjZtqs2bN1+2trCwUK+88opq1aold3d3RUZGatWqVXY1ubm5GjJkiMLCwuTh4aFmzZppy5YtdjXHjx9X7969FRISIk9PT7Vp00b79++/IfsHAABuTw4NSQsWLFBSUpJGjRqlbdu2KTIyUrGxscrKyjKtHzlypN5//31NmTJFu3fvVv/+/dW5c2dt377dVtOvXz8lJydrzpw52rlzp1q3bq2YmBilp6dLkgzDUKdOnXTw4EF9/vnn2r59u8LCwhQTE6P8/Pybst8AAODWZzEMw3DUxps2barGjRtr6tSpkiSr1arQ0FANGjRIw4YNK1YfEhKiESNGaMCAAbaxuLg4eXh4aO7cuTp79qx8fHz0+eefq3379raaqKgotW3bVq+++qr27dun8PBw7dq1S/Xq1bNtNygoSK+99pr69et3Tb3n5OTIz89P2dnZ8vX1/TOHAQAA3CQl+f522Jmk8+fPa+vWrYqJiflfM05OiomJ0aZNm0w/U1BQIHd3d7sxDw8PbdiwQZJ04cIFFRUVXbGmoKBAkuxqnJyc5ObmZqsBAABwWEg6efKkioqKFBgYaDceGBiozMxM08/ExsZqwoQJ2r9/v6xWq5KTk7VkyRJlZGRIknx8fBQdHa0xY8bo2LFjKioq0ty5c7Vp0yZbTUREhKpVq6bhw4fr1KlTOn/+vN544w0dPXrUVmOmoKBAOTk5dgsAACi7HD5xuyQmTZqk2rVrKyIiQq6urho4cKD69OkjJ6f/7cacOXNkGIaqVKkiNzc3TZ48WT169LDVuLi4aMmSJdq3b58qVKggT09PrV27Vm3btrVbzx+NGzdOfn5+tiU0NPSG7y8AAHAch4WkSpUqydnZWcePH7cbP378uIKCgkw/ExAQoGXLlik/P1+//PKLfvrpJ3l7e6tmzZq2mlq1amn9+vXKy8vTkSNHtHnzZhUWFtrVREVFKTU1VadPn1ZGRoZWrVqlX3/91a7mj4YPH67s7GzbcuTIkT95BAAAwK3MYSHJ1dVVUVFRSklJsY1ZrValpKQoOjr6ip91d3dXlSpVdOHCBS1evFgdO3YsVuPl5aXg4GCdOnVKq1evNq3x8/NTQECA9u/fr++//9605ndubm7y9fW1WwAAQNlVzpEbT0pKUmJioho1aqQmTZpo4sSJys/PV58+fSRJCQkJqlKlisaNGydJ+u6775Senq6GDRsqPT1do0ePltVq1XPPPWdb5+rVq2UYhsLDw3XgwAE9++yzioiIsK1TkhYuXKiAgABVq1ZNO3fu1ODBg9WpUye1bt365h4AAABwy3JoSIqPj9eJEyf00ksvKTMzUw0bNtSqVatsk7kPHz5sN0/o3LlzGjlypA4ePChvb2+1a9dOc+bMUfny5W012dnZGj58uI4ePaoKFSooLi5OY8eOlYuLi60mIyNDSUlJOn78uIKDg5WQkKAXX3zxpu03AAC49Tn0Pkm3M+6TBADA7ee2uE8SAADArYyQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYKLEIal69ep65ZVXdPjw4RvRDwAAwC2hxCFpyJAhWrJkiWrWrKkHH3xQ8+fPV0FBwY3oDQAAwGGuKySlpqZq8+bNqlOnjgYNGqTg4GANHDhQ27ZtuxE9AgAA3HQWwzCMP7OCwsJCvfvuu3r++edVWFio+vXr6+mnn1afPn1ksVhKq89bTk5Ojvz8/JSdnS1fX19HtwMAAK5BSb6/y13vRgoLC7V06VLNmjVLycnJuueee9S3b18dPXpUL7zwgr766it98skn17t6AAAAhypxSNq2bZtmzZqlTz/9VE5OTkpISNA777yjiIgIW03nzp3VuHHjUm0UAFB6ioqKVFhY6Og2gFLn4uIiZ2fnUllXiUNS48aN9eCDD2r69Onq1KmTXFxcitXUqFFD3bt3L5UGAQClxzAMZWZm6vTp045uBbhhypcvr6CgoD897afEIengwYMKCwu7Yo2Xl5dmzZp13U0BAG6M3wNS5cqV5enpWabnjuKvxzAMnTlzRllZWZKk4ODgP7W+EoekrKwsZWZmqmnTpnbj3333nZydndWoUaMSrW/atGl66623lJmZqcjISE2ZMkVNmjQxrS0sLNS4ceP00UcfKT09XeHh4XrjjTfUpk0bW01ubq5efPFFLV26VFlZWfrb3/6mSZMm2V3+y8vL07Bhw7Rs2TL9+uuvqlGjhp5++mn179+/RL0DwO2kqKjIFpAqVqzo6HaAG8LDw0PSxbxSuXLlP3XprcS3ABgwYICOHDlSbDw9PV0DBgwo0boWLFigpKQkjRo1Stu2bVNkZKRiY2NtCfCPRo4cqffff19TpkzR7t271b9/f3Xu3Fnbt2+31fTr10/JycmaM2eOdu7cqdatWysmJkbp6em2mqSkJK1atUpz587Vnj17NGTIEA0cOFDLly8vUf8AcDv5fQ6Sp6engzsBbqzf/8b/9Lw7o4S8vLyMtLS0YuMHDx40vL29S7SuJk2aGAMGDLC9LioqMkJCQoxx48aZ1gcHBxtTp061G+vSpYvRs2dPwzAM48yZM4azs7Px5Zdf2tXcfffdxogRI2yv69WrZ7zyyitXrLma7OxsQ5KRnZ19zZ8BAEc6e/assXv3buPs2bOObgW4oa70t16S7+8Sn0lyc3PT8ePHi41nZGSoXLlrv3p3/vx5bd26VTExMbYxJycnxcTEaNOmTaafKSgokLu7u92Yh4eHNmzYIEm6cOGCioqKrlgjSc2aNdPy5cuVnp4uwzC0du1a7du3T61bt75svwUFBcrJybFbAABA2VXikNS6dWsNHz5c2dnZtrHTp0/rhRde0IMPPnjN6zl58qSKiooUGBhoNx4YGKjMzEzTz8TGxmrChAnav3+/rFarkpOTtWTJEmVkZEiSfHx8FB0drTFjxujYsWMqKirS3LlztWnTJluNJE2ZMkV169ZV1apV5erqqjZt2mjatGlq0aLFZfsdN26c/Pz8bEtoaOg17ysA4NZTvXp1TZw40dFt4BZW4pA0fvx4HTlyRGFhYWrVqpVatWqlGjVqKDMzU2+//faN6NFm0qRJql27tiIiIuTq6qqBAweqT58+cnL6327MmTNHhmGoSpUqcnNz0+TJk9WjRw+7milTpujbb7/V8uXLtXXrVr399tsaMGCAvvrqq8tu+/dg+PtiNi8LAFD6LBbLFZfRo0df13q3bNmixx9/vFR6/PTTT+Xs7Fziubm4tV3XY0ny8/M1b9487dixQx4eHmrQoIF69Ohhes+kyzl//rw8PT21aNEiderUyTaemJio06dP6/PPP7/sZ8+dO6dff/1VISEhGjZsmL788kv9+OOPxXrMyclRcHCw4uPjlZeXpxUrVujs2bPy8/PT0qVL1b59e1t9v379dPToUa1ateqa+uexJABuN+fOndOhQ4dUo0aNYtMSbmWXXl1YsGCBXnrpJe3du9c25u3tLW9vb0kXfwJeVFRUoukfpSEmJkaNGzfW+++/r2PHjjn0+J4/f16urq4O2/6t4Ep/6yX5/i7xmSTp4n2QHn/8cU2bNk3jx49XQkJCiQKSJLm6uioqKkopKSm2MavVqpSUFEVHR1/xs+7u7qpSpYouXLigxYsXq2PHjqY9BgcH69SpU1q9erWtprCwUIWFhXZnliTJ2dlZVqu1RPsAALjxgoKCbIufn58sFovt9U8//SQfHx+tXLlSUVFRcnNz04YNG5SWlqaOHTsqMDBQ3t7eaty4cbGrBX+83GaxWPTvf/9bnTt3lqenp2rXrn1Nv3o+dOiQ/vvf/2rYsGG68847tWTJkmI1M2fOVL169eTm5mZ7KPzvTp8+rSeeeEKBgYFyd3fXXXfdpS+//FKSNHr0aDVs2NBuXRMnTlT16tVtr3v37q1OnTpp7NixCgkJUXh4uKSLV1YaNWokHx8fBQUF6Z///GexX4//+OOPeuihh+Tr6ysfHx81b95caWlp+vrrr+Xi4lJs+suQIUPUvHnzqx6TsuK6o/bu3bt1+PBhnT9/3m78H//4xzWvIykpSYmJiWrUqJGaNGmiiRMnKj8/X3369JEkJSQkqEqVKho3bpyki/diSk9PV8OGDZWenq7Ro0fLarXqueees61z9erVMgxD4eHhOnDggJ599llFRETY1unr66uWLVvq2WeflYeHh8LCwrR+/Xp9/PHHmjBhwvUeDgC4LRmGdOaMY7bt6SmV1r0shw0bpvHjx6tmzZry9/fXkSNH1K5dO40dO1Zubm76+OOP1aFDB+3du1fVqlW77Hpefvllvfnmm3rrrbc0ZcoU9ezZU7/88osqVKhw2c/MmjVL7du3l5+fn3r16qUZM2bon//8p+396dOnKykpSa+//rratm2r7Oxsbdy4UdLFkwNt27ZVbm6u5s6dq1q1amn37t0lvrdPSkqKfH19lZycbBsrLCzUmDFjFB4erqysLCUlJal37976v//7P0kXb93TokUL3X///VqzZo18fX21ceNGXbhwQS1atFDNmjU1Z84cPfvss7b1zZs3T2+++WaJerutlfRndWlpaUaDBg0Mi8ViODk5GRaLxfZvJyenkq7OmDJlilGtWjXD1dXVaNKkifHtt9/a3mvZsqWRmJhoe71u3TqjTp06hpubm1GxYkXjkUceMdLT0+3Wt2DBAqNmzZqGq6urERQUZAwYMMA4ffq0XU1GRobRu3dvIyQkxHB3dzfCw8ONt99+27BardfcN7cAAHC7MftZdF6eYVyMSjd/ycsr+T7MmjXL8PPzs71eu3atIclYtmzZVT9br149Y8qUKbbXYWFhxjvvvGN7LckYOXLkJccmz5BkrFy58rLrLCoqMkJDQ23bP3HihOHq6mocPHjQVhMSEnLZW8ysXr3acHJyMvbu3Wv6/qhRo4zIyEi7sXfeeccICwuzvU5MTDQCAwONgoKCy/ZpGIaxZcsWQ5KRm5trGIZhDB8+3KhRo4Zx/vx50/o33njDqFOnju314sWLDW9vbyPvev7D3WSldQuAEp9JGjx4sGrUqKGUlBTVqFFDmzdv1q+//qp//etfGj9+fIlD2sCBA+1OO15q3bp1dq9btmyp3bt3X3F93bp1U7du3a5YExQUxGNTAKAM+ePTHvLy8jR69GitWLFCGRkZunDhgs6ePavDhw9fcT0NGjSw/dvLy0u+vr6XvcGxJCUnJys/P1/t2rWTJFWqVEkPPvigZs6cqTFjxigrK0vHjh3TAw88YPr51NRUVa1aVXfeeee17qqp+vXrF5uHtHXrVo0ePVo7duzQqVOnbFNKDh8+rLp16yo1NVXNmze/7HSZ3r17a+TIkfr22291zz33aPbs2erWrZu8vLz+VK+3kxKHpE2bNmnNmjWqVKmSnJyc5OTkpPvuu0/jxo3T008/bXf3awDArc3TU8rLc9y2S8sfv7iHDh2q5ORkjR8/XnfccYc8PDzUtWvXYlNE/uiPgcFisVxxvuqMGTP022+/2R6FIV28hPbDDz/o5Zdfths3c7X3nZycZPzh91Vmd5H+4/7n5+crNjZWsbGxmjdvngICAnT48GHFxsbajsHVtl25cmV16NBBs2bNUo0aNbRy5cpiJy/KuhKHpKKiIvn4+Ei6mJiPHTum8PBwhYWF2f3aAABw67NYpLJ4YmDjxo3q3bu3OnfuLOnimaWff/65VLfx66+/6vPPP9f8+fNVr14923hRUZHuu+8+/ec//1GbNm1UvXp1paSkqFWrVsXW0aBBAx09elT79u0zPZsUEBCgzMxMGYZhexhxamrqVXv76aef9Ouvv+r111+33dfv+++/L7btjz76SIWFhZc9m9SvXz/16NFDVatWVa1atXTvvfdeddtlSYl/3XbXXXdpx44dkqSmTZvqzTff1MaNG/XKK6+oZs2apd4gAAAlVbt2bS1ZskSpqanasWOH/vnPf5b6L5jnzJmjihUrqlu3brrrrrtsS2RkpNq1a6cZM2ZIuvgLtbfffluTJ0/W/v37tW3bNk2ZMkXSxWkkLVq0UFxcnJKTk3Xo0CGtXLnSdjua+++/XydOnNCbb76ptLQ0TZs2TStXrrxqb9WqVZOrq6umTJmigwcPavny5RozZoxdzcCBA5WTk6Pu3bvr+++/1/79+zVnzhy7Ex6xsbHy9fXVq6++avsB1F9JiUPSyJEjbX9or7zyig4dOqTmzZvr//7v/zR58uRSbxAAgJKaMGGC/P391axZM3Xo0EGxsbG6++67S3UbM2fOVOfOnW1neC4VFxen5cuX6+TJk0pMTNTEiRP17rvvql69enrooYe0f/9+W+3ixYvVuHFj9ejRQ3Xr1tVzzz2noqIiSVKdOnX07rvvatq0aYqMjNTmzZs1dOjQq/YWEBCg2bNna+HChapbt65ef/31YvOGK1asqDVr1igvL08tW7ZUVFSUPvzwQ7uzSk5OTurdu7eKioqUkJBwvYfqtnVdN5P8o99++03+/v6mfyhlFTeTBHC7uV1vJgnH6tu3r06cOHFN94y6VTjkZpKFhYUqV66cdu3aZTdeoUKFv1RAAgCgrMvOztaGDRv0ySefaNCgQY5uxyFKNHHbxcVF1apVs50GBAAAZVPHjh21efNm9e/fv0QPsC9LSvzrthEjRuiFF17QnDlzrngHUgAAcPv6q/3c30yJQ9LUqVN14MABhYSEKCwsrNi9GbZt21ZqzQEAADhKiUNSp06dbkAbAAAAt5YSh6RRo0bdiD4AAABuKSW+TxIAAMBfQYnPJDk5OV3x5/788g0AAJQFJQ5JS5cutXtdWFio7du366OPPtLLL79cao0BAAA4UolDUseOHYuNde3aVfXq1dOCBQvUt2/fUmkMAIDSdP/996thw4aaOHGiJKl69eoaMmSIhgwZctnPWCwWLV269E//aKm01oObq9TmJN1zzz1KSUkprdUBACBJ6tChg9q0aWP63jfffCOLxaIffvihxOvdsmWLHn/88T/bnp3Ro0erYcOGxcYzMjLUtm3bUt3W5Zw9e1YVKlRQpUqVVFBQcFO2WVaVSkg6e/asJk+erCpVqpTG6gAAsOnbt6+Sk5N19OjRYu/NmjVLjRo1UoMGDUq83oCAAHl6epZGi1cVFBQkNze3m7KtxYsXq169eoqIiNCyZctuyjYvxzAMXbhwwaE9/BklDkn+/v6qUKGCbfH395ePj49mzpypt95660b0CAD4C3vooYdsT7W/VF5enhYuXKi+ffvq119/VY8ePVSlShV5enqqfv36+vTTT6+43urVq9suvUnS/v371aJFC7m7u6tu3bpKTk4u9pnnn39ed955pzw9PVWzZk29+OKLKiwslCTNnj1bL7/8snbs2CGLxSKLxWLr2WKx2AWWnTt36u9//7s8PDxUsWJFPf7448rLy7O937t3b3Xq1Enjx49XcHCwKlasqAEDBti2dSUzZsxQr1691KtXL82YMaPY+z/++KMeeugh+fr6ysfHR82bN1daWprt/ZkzZ6pevXpyc3NTcHCwBg4cKEn6+eefZbFYlJqaaqs9ffq0LBaL7e7c69atk8Vi0cqVKxUVFSU3Nzdt2LBBaWlp6tixowIDA+Xt7a3GjRvrq6++suuroKBAzz//vEJDQ+Xm5qY77rhDM2bMkGEYuuOOOzR+/Hi7+tTUVFksFh04cOCqx+R6lXhO0jvvvGP36zYnJycFBASoadOm8vf3L9XmAAA3mGFIZ844ZtuentI1PBy9XLlySkhI0OzZszVixAjbd9DChQtVVFSkHj16KC8vT1FRUXr++efl6+urFStW6JFHHlGtWrXUpEmTq27DarWqS5cuCgwM1Hfffafs7GzTuUo+Pj6aPXu2QkJCtHPnTj322GPy8fHRc889p/j4eO3atUurVq2yBQA/P79i68jPz1dsbKyio6O1ZcsWZWVlqV+/fho4cKBdEFy7dq2Cg4O1du1aHThwQPHx8WrYsKEee+yxy+5HWlqaNm3apCVLlsgwDD3zzDP65ZdfFBYWJklKT09XixYtdP/992vNmjXy9fXVxo0bbWd7pk+frqSkJL3++utq27atsrOztXHjxqsevz8aNmyYxo8fr5o1a8rf319HjhxRu3btNHbsWLm5uenjjz9Whw4dtHfvXlWrVk2SlJCQoE2bNmny5MmKjIzUoUOHdPLkSVksFj366KOaNWuWhg4datvGrFmz1KJFC91xxx0l7u+aGbgu2dnZhiQjOzvb0a0AwDU5e/assXv3buPs2bP/G8zLM4yLUenmL3l519z7nj17DEnG2rVrbWPNmzc3evXqddnPtG/f3vjXv/5le92yZUtj8ODBttdhYWHGO++8YxiGYaxevdooV66ckZ6ebnt/5cqVhiRj6dKll93GW2+9ZURFRdlejxo1yoiMjCxWd+l6PvjgA8Pf39/Iu2T/V6xYYTg5ORmZmZmGYRhGYmKiERYWZly4cMFW8/DDDxvx8fGX7cUwDOOFF14wOnXqZHvdsWNHY9SoUbbXw4cPN2rUqGGcP3/e9PMhISHGiBEjTN87dOiQIcnYvn27bezUqVN2/13Wrl1rSDKWLVt2xT4NwzDq1atnTJkyxTAMw9i7d68hyUhOTjatTU9PN5ydnY3vvvvOMAzDOH/+vFGpUiVj9uzZpvWmf+v/X0m+v0t8uW3WrFlauHBhsfGFCxfqo48++jN5DQAAUxEREWrWrJlmzpwpSTpw4IC++eYb2y+qi4qKNGbMGNWvX18VKlSQt7e3Vq9ercOHD1/T+vfs2aPQ0FCFhITYxqKjo4vVLViwQPfee6+CgoLk7e2tkSNHXvM2Lt1WZGSk3bNP7733XlmtVu3du9c2Vq9ePTk7O9teBwcHKysr67LrLSoq0kcffaRevXrZxnr16qXZs2fLarVKuniJqnnz5nJxcSn2+aysLB07dkwPPPBAifbHTKNGjexe5+XlaejQoapTp47Kly8vb29v7dmzx3bsUlNT5ezsrJYtW5quLyQkRO3bt7f99//iiy9UUFCghx9++E/3eiUlDknjxo1TpUqVio1XrlxZr732Wqk0BQC4STw9pbw8xywlnDTdt29fLV68WLm5uZo1a5Zq1apl+1J96623NGnSJD3//PNau3atUlNTFRsbq/Pnz5faodq0aZN69uypdu3a6csvv9T27ds1YsSIUt3Gpf4YZCwWiy3smFm9erXS09MVHx+vcuXKqVy5curevbt++eUX26/PPTw8Lvv5K70nXZxeI12cjP27y82RujQAStLQoUO1dOlSvfbaa/rmm2+Umpqq+vXr247d1bYtSf369dP8+fN19uxZzZo1S/Hx8Td84n2JQ9Lhw4dVo0aNYuNhYWElTtMAAAezWCQvL8cs1zAf6VLdunWTk5OTPvnkE3388cd69NFHbfOTNm7cqI4dO6pXr16KjIxUzZo1tW/fvmted506dXTkyBFlZGTYxr799lu7mv/+978KCwvTiBEj1KhRI9WuXVu//PKLXY2rq+tVnzxRp04d7dixQ/n5+baxjRs3ysnJSeHh4dfc8x/NmDFD3bt3V2pqqt3SvXt32wTuBg0a6JtvvjENNz4+Pqpevfplb+cTEBAgSXbH6NJJ3FeyceNG9e7dW507d1b9+vUVFBSkn3/+2fZ+/fr1ZbVatX79+suuo127dvLy8tL06dO1atUqPfroo9e07T+jxCGpcuXKpvej2LFjhypWrFgqTQEA8Efe3t6Kj4/X8OHDlZGRod69e9veq127tpKTk/Xf//5Xe/bs0RNPPKHjx49f87pjYmJ05513KjExUTt27NA333yjESNG2NXUrl1bhw8f1vz585WWlqbJkycXewpF9erVdejQIaWmpurkyZOm9ynq2bOn3N3dlZiYqF27dmnt2rUaNGiQHnnkEQUGBpbsoPx/J06c0BdffKHExETddddddktCQoKWLVum3377TQMHDlROTo66d++u77//Xvv379ecOXNsl/lGjx6tt99+W5MnT9b+/fu1bds2TZkyRdLFsz333HOPXn/9de3Zs0fr16/XyJEjr6m/2rVra8mSJUpNTdWOHTv0z3/+0+6sWPXq1ZWYmKhHH31Uy5Yt06FDh7Ru3Tp99tlnthpnZ2f17t1bw4cPV+3atU0vh5a2EoekHj166Omnn9batWtVVFSkoqIirVmzRoMHD1b37t1vRI8AAEi6eMnt1KlTio2NtZs/NHLkSN19992KjY3V/fffr6CgoBLd3drJyUlLly7V2bNn1aRJE/Xr109jx461q/nHP/6hZ555RgMHDlTDhg313//+Vy+++KJdTVxcnNq0aaNWrVopICDA9DYEnp6eWr16tX777Tc1btxYXbt21QMPPKCpU6eW7GBc4uOPP5aXl5fpfKIHHnhAHh4emjt3ripWrKg1a9YoLy9PLVu2VFRUlD788EPbpb3ExERNnDhR7777rurVq6eHHnpI+/fvt61r5syZunDhgqKiojRkyBC9+uqr19TfhAkT5O/vr2bNmqlDhw6KjY3V3XffbVczffp0de3aVU899ZQiIiL02GOP2Z1tky7+9z9//rz69OlT0kN0XSzGpRcXr8H58+f1yCOPaOHChSpX7uIdBKxWqxISEvTee+/J1dX1hjR6q8nJyZGfn5+ys7Pl6+vr6HYA4KrOnTunQ4cOqUaNGnJ3d3d0O0CJffPNN3rggQd05MiRK551u9Lfekm+v0t8nyRXV1ctWLBAr776qlJTU+Xh4aH69evb7sEAAABQmgoKCnTixAmNHj1aDz/88HVfliypEoek39WuXVu1a9cuzV4AAACK+fTTT9W3b181bNhQH3/88U3bbonnJMXFxemNN94oNv7mm2/e8PsVAACAv57evXurqKhIW7duvanPiS1xSPr666/Vrl27YuNt27bV119/XSpNAQAAOFqJQ1JeXp7p5GwXFxfl5OSUSlMAgBunhL/XAW47pfU3XuKQVL9+fS1YsKDY+Pz581W3bt1SaQoAUPp+/5n3GUc90Ba4SX7/Gzd7/EpJlHji9osvvqguXbooLS1Nf//73yVJKSkp+uSTT7Ro0aI/1QwA4MZxdnZW+fLlbc//8vT0tN2xGigLDMPQmTNnlJWVpfLly9s9++56lDgkdejQQcuWLdNrr72mRYsWycPDQ5GRkVqzZo0qVKjwp5oBANxYQUFBknTFB6UCt7vy5cvb/tb/jBLfTPKPcnJy9Omnn2rGjBnaunXrVZ9ZU1ZwM0kAt7OioqLLPpwUuJ25uLhc8QzSDb2Z5O++/vprzZgxQ4sXL1ZISIi6dOmiadOmXe/qAAA3kbOz85++FAGUdSUKSZmZmZo9e7ZmzJihnJwcdevWTQUFBVq2bBmTtgEAQJlyzb9u69Chg8LDw/XDDz9o4sSJOnbsmO3JwAAAAGXNNZ9JWrlypZ5++mk9+eSTPI4EAACUedd8JmnDhg3Kzc1VVFSUmjZtqqlTp+rkyZM3sjcAAACHueaQdM899+jDDz9URkaGnnjiCc2fP18hISGyWq1KTk5Wbm7ujewTAADgpvpTtwDYu3evZsyYoTlz5uj06dN68MEHtXz58tLs75bFLQAAALj9lOT7u8SPJblUeHi43nzzTR09elSffvrpn1kVAADALeVP30zyr4ozSQAA3H5u2pkkAACAsoqQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYIKQBAAAYOKWCEnTpk1T9erV5e7urqZNm2rz5s2XrS0sLNQrr7yiWrVqyd3dXZGRkVq1apVdTW5uroYMGaKwsDB5eHioWbNm2rJli12NxWIxXd56660bso8AAOD24vCQtGDBAiUlJWnUqFHatm2bIiMjFRsbq6ysLNP6kSNH6v3339eUKVO0e/du9e/fX507d9b27dttNf369VNycrLmzJmjnTt3qnXr1oqJiVF6erqtJiMjw26ZOXOmLBaL4uLibvg+AwCAW5/FMAzDkQ00bdpUjRs31tSpUyVJVqtVoaGhGjRokIYNG1asPiQkRCNGjNCAAQNsY3FxcfLw8NDcuXN19uxZ+fj46PPPP1f79u1tNVFRUWrbtq1effVV0z46deqk3NxcpaSkXFPfOTk58vPzU3Z2tnx9fUuyywAAwEFK8v3t0DNJ58+f19atWxUTE2Mbc3JyUkxMjDZt2mT6mYKCArm7u9uNeXh4aMOGDZKkCxcuqKio6Io1f3T8+HGtWLFCffv2/TO7AwAAyhCHhqSTJ0+qqKhIgYGBduOBgYHKzMw0/UxsbKwmTJig/fv3y2q1Kjk5WUuWLFFGRoYkycfHR9HR0RozZoyOHTumoqIizZ07V5s2bbLV/NFHH30kHx8fdenS5bK9FhQUKCcnx24BAABll8PnJJXUpEmTVLt2bUVERMjV1VUDBw5Unz595OT0v12ZM2eODMNQlSpV5ObmpsmTJ6tHjx52NZeaOXOmevbsWezs06XGjRsnPz8/2xIaGlrq+wYAAG4dDg1JlSpVkrOzs44fP243fvz4cQUFBZl+JiAgQMuWLVN+fr5++eUX/fTTT/L29lbNmjVtNbVq1dL69euVl5enI0eOaPPmzSosLLSr+d0333yjvXv3ql+/flfsdfjw4crOzrYtR44cuY49BgAAtwuHhiRXV1dFRUXZTZa2Wq1KSUlRdHT0FT/r7u6uKlWq6MKFC1q8eLE6duxYrMbLy0vBwcE6deqUVq9ebVozY8YMRUVFKTIy8orbc3Nzk6+vr90CAADKrnKObiApKUmJiYlq1KiRmjRpookTJyo/P199+vSRJCUkJKhKlSoaN26cJOm7775Tenq6GjZsqPT0dI0ePVpWq1XPPfecbZ2rV6+WYRgKDw/XgQMH9OyzzyoiIsK2zt/l5ORo4cKFevvtt2/eDgMAgNuCw0NSfHy8Tpw4oZdeekmZmZlq2LChVq1aZZvMffjwYbu5ROfOndPIkSN18OBBeXt7q127dpozZ47Kly9vq8nOztbw4cN19OhRVahQQXFxcRo7dqxcXFzstj1//nwZhqEePXrclH0FAAC3D4ffJ+l2xX2SAAC4/dw290kCAAC4VRGSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATBCSAAAATDg8JE2bNk3Vq1eXu7u7mjZtqs2bN1+2trCwUK+88opq1aold3d3RUZGatWqVXY1ubm5GjJkiMLCwuTh4aFmzZppy5Ytxda1Z88e/eMf/5Cfn5+8vLzUuHFjHT58uNT3DwAA3J4cGpIWLFigpKQkjRo1Stu2bVNkZKRiY2OVlZVlWj9y5Ei9//77mjJlinbv3q3+/furc+fO2r59u62mX79+Sk5O1pw5c7Rz5061bt1aMTExSk9Pt9WkpaXpvvvuU0REhNatW6cffvhBL774otzd3W/4PgMAgNuDxTAMw1Ebb9q0qRo3bqypU6dKkqxWq0JDQzVo0CANGzasWH1ISIhGjBihAQMG2Mbi4uLk4eGhuXPn6uzZs/Lx8dHnn3+u9u3b22qioqLUtm1bvfrqq5Kk7t27y8XFRXPmzLnu3nNycuTn56fs7Gz5+vpe93oAAMDNU5Lvb4edSTp//ry2bt2qmJiY/zXj5KSYmBht2rTJ9DMFBQXFzvZ4eHhow4YNkqQLFy6oqKjoijVWq1UrVqzQnXfeqdjYWFWuXFlNmzbVsmXLrthvQUGBcnJy7BYAAFB2OSwknTx5UkVFRQoMDLQbDwwMVGZmpulnYmNjNWHCBO3fv19Wq1XJyclasmSJMjIyJEk+Pj6Kjo7WmDFjdOzYMRUVFWnu3LnatGmTrSYrK0t5eXl6/fXX1aZNG/3nP/9R586d1aVLF61fv/6y/Y4bN05+fn62JTQ0tJSOBAAAuBU5fOJ2SUyaNEm1a9dWRESEXF1dNXDgQPXp00dOTv/bjTlz5sgwDFWpUkVubm6aPHmyevToYauxWq2SpI4dO+qZZ55Rw4YNNWzYMD300EN67733Lrvt4cOHKzs727YcOXLkxu4sAABwKIeFpEqVKsnZ2VnHjx+3Gz9+/LiCgoJMPxMQEKBly5YpPz9fv/zyi3766Sd5e3urZs2atppatWpp/fr1ysvL05EjR7R582YVFhbaaipVqqRy5cqpbt26duuuU6fOFX/d5ubmJl9fX7sFAACUXQ4LSa6uroqKilJKSoptzGq1KiUlRdHR0Vf8rLu7u6pUqaILFy5o8eLF6tixY7EaLy8vBQcH69SpU1q9erWtxtXVVY0bN9bevXvt6vft26ewsLBS2DMAAFAWlHPkxpOSkpSYmKhGjRqpSZMmmjhxovLz89WnTx9JUkJCgqpUqaJx48ZJkr777julp6erYcOGSk9P1+jRo2W1WvXcc8/Z1rl69WoZhqHw8HAdOHBAzz77rCIiImzrlKRnn31W8fHxatGihVq1aqVVq1bpiy++0Lp1627q/gMAgFuXQ0NSfHy8Tpw4oZdeekmZmZlq2LChVq1aZZvMffjwYbv5RufOndPIkSN18OBBeXt7q127dpozZ47Kly9vq8nOztbw4cN19OhRVahQQXFxcRo7dqxcXFxsNZ07d9Z7772ncePG6emnn1Z4eLgWL16s++6776btOwAAuLU59D5JtzPukwQAwO3ntrhPEgAAwK2MkAQAAGCCkAQAAGCCkAQAAGCCkAQAAGCCkAQAAGCCkAQAAGCCkAQAAGCCkAQAAGCCkAQAAGCCkAQAAGCCkAQAAGCCkAQAAGCCkAQAAGCCkAQAAGCCkAQAAGCCkAQAAGCCkAQAAGCCkAQAAGCCkAQAAGCCkAQAAGCCkAQAAGCCkAQAAGCCkAQAAGCCkAQAAGCinKMbgD3DkM6ccXQXAAA4nqenZLE4bvuEpFvMmTOSt7ejuwAAwPHy8iQvL8dtn8ttAAAAJjiTdIvx9LyYnAEA+Kvz9HTs9glJtxiLxbGnFgEAwEVcbgMAADBBSAIAADBBSAIAADBBSAIAADBBSAIAADBBSAIAADBBSAIAADBBSAIAADBBSAIAADBBSAIAADBBSAIAADBBSAIAADBBSAIAADBRztEN3K4Mw5Ak5eTkOLgTAABwrX7/3v79e/xKCEnXKTc3V5IUGhrq4E4AAEBJ5ebmys/P74o1FuNaohSKsVqtOnbsmHx8fGSxWEp13Tk5OQoNDdWRI0fk6+tbquvG/3Ccbw6O883Bcb45OM43x408zoZhKDc3VyEhIXJyuvKsI84kXScnJydVrVr1hm7D19eX/xHeBBznm4PjfHNwnG8OjvPNcaOO89XOIP2OidsAAAAmCEkAAAAmCEm3IDc3N40aNUpubm6ObqVM4zjfHBznm4PjfHNwnG+OW+U4M3EbAADABGeSAAAATBCSAAAATBCSAAAATBCSAAAATBCSbiFff/21OnTooJCQEFksFi1btszRLZU548aNU+PGjeXj46PKlSurU6dO2rt3r6PbKpOmT5+uBg0a2G4GFx0drZUrVzq6rTLt9ddfl8Vi0ZAhQxzdSpkzevRoWSwWuyUiIsLRbZVJ6enp6tWrlypWrCgPDw/Vr19f33//vUN6ISTdQvLz8xUZGalp06Y5upUya/369RowYIC+/fZbJScnq7CwUK1bt1Z+fr6jWytzqlatqtdff11bt27V999/r7///e/q2LGjfvzxR0e3ViZt2bJF77//vho0aODoVsqsevXqKSMjw7Zs2LDB0S2VOadOndK9994rFxcXrVy5Urt379bbb78tf39/h/TDY0luIW3btlXbtm0d3UaZtmrVKrvXs2fPVuXKlbV161a1aNHCQV2VTR06dLB7PXbsWE2fPl3ffvut6tWr56Cuyqa8vDz17NlTH374oV599VVHt1NmlStXTkFBQY5uo0x74403FBoaqlmzZtnGatSo4bB+OJOEv7Ts7GxJUoUKFRzcSdlWVFSk+fPnKz8/X9HR0Y5up8wZMGCA2rdvr5iYGEe3Uqbt379fISEhqlmzpnr27KnDhw87uqUyZ/ny5WrUqJEefvhhVa5cWX/729/04YcfOqwfziThL8tqtWrIkCG69957dddddzm6nTJp586dio6O1rlz5+Tt7a2lS5eqbt26jm6rTJk/f762bdumLVu2OLqVMq1p06aaPXu2wsPDlZGRoZdfflnNmzfXrl275OPj4+j2yoyDBw9q+vTpSkpK0gsvvKAtW7bo6aeflqurqxITE296P4Qk/GUNGDBAu3btYl7BDRQeHq7U1FRlZ2dr0aJFSkxM1Pr16wlKpeTIkSMaPHiwkpOT5e7u7uh2yrRLp0I0aNBATZs2VVhYmD777DP17dvXgZ2VLVarVY0aNdJrr70mSfrb3/6mXbt26b333nNISOJyG/6SBg4cqC+//FJr165V1apVHd1OmeXq6qo77rhDUVFRGjdunCIjIzVp0iRHt1VmbN26VVlZWbr77rtVrlw5lStXTuvXr9fkyZNVrlw5FRUVObrFMqt8+fK68847deDAAUe3UqYEBwcX+z9RderUcdilTc4k4S/FMAwNGjRIS5cu1bp16xw6IfCvyGq1qqCgwNFtlBkPPPCAdu7caTfWp08fRURE6Pnnn5ezs7ODOiv78vLylJaWpkceecTRrZQp9957b7Hbsuzbt09hYWEO6YeQdAvJy8uz+38lhw4dUmpqqipUqKBq1ao5sLOyY8CAAfrkk0/0+eefy8fHR5mZmZIkPz8/eXh4OLi7smX48OFq27atqlWrptzcXH3yySdat26dVq9e7ejWygwfH59i8+m8vLxUsWJF5tmVsqFDh6pDhw4KCwvTsWPHNGrUKDk7O6tHjx6Obq1MeeaZZ9SsWTO99tpr6tatmzZv3qwPPvhAH3zwgWMaMnDLWLt2rSGp2JKYmOjo1soMs+MryZg1a5ajWytzHn30USMsLMxwdXU1AgICjAceeMD4z3/+4+i2yryWLVsagwcPdnQbZU58fLwRHBxsuLq6GlWqVDHi4+ONAwcOOLqtMumLL74w7rrrLsPNzc2IiIgwPvjgA4f1YjEMw3BMPAMAALh1MXEbAADABCEJAADABCEJAADABCEJAADABCEJAADABCEJAADABCEJAADABCEJAEqJxWLRsmXLHN0GgFJCSAJQJvTu3VsWi6XY0qZNG0e3BuA2xbPbAJQZbdq00axZs+zG3NzcHNQNgNsdZ5IAlBlubm4KCgqyW/z9/SVdvBQ2ffp0tW3bVh4eHqpZs6YWLVpk9/mdO3fq73//uzw8PFSxYkU9/vjjysvLs6uZOXOm6tWrJzc3NwUHB2vgwIF27588eVKdO3eWp6enateureXLl9/YnQZwwxCSAPxlvPjii4qLi9OOHTvUs2dPde/eXXv27JEk5efnKzY2Vv7+/tqyZYsWLlyor776yi4ETZ8+XQMGDNDjjz+unTt3avny5brjjjvstvHyyy+rW7du+uGHH9SuXTv17NlTv/32203dTwClxGGP1gWAUpSYmGg4OzsbXl5edsvYsWMNwzAMSUb//v3tPtO0aVPjySefNAzDMD744APD39/fyMvLs72/YsUKw8nJycjMzDQMwzBCQkKMESNGXLYHScbIkSNtr/Py8gxJxsqVK0ttPwHcPMxJAlBmtGrVStOnT7cbq1Chgu3f0dHRdu9FR0crNTVVkrRnzx5FRkbKy8vL9v69994rq9WqvXv3ymKx6NixY3rggQeu2EODBg1s//by8pKvr6+ysrKud5cAOBAhCUCZ4eXlVezyV2nx8PC4pjoXFxe71xaLRVar9Ua0BOAGY04SgL+Mb7/9ttjrOnXqSJLq1KmjHTt2KD8/3/b+xo0b5eTkpPDwcPn4+Kh69epKSUm5qT0DcBzOJAEoMwoKCpSZmWk3Vq5cOVWqVEmStHDhQjVq1Ej33Xef5s2bp82bN2vGjBmSpJ49e2rUqFFKTEzU6NGjdeLECQ0aNEiPPPKIAgMDJUmjR49W//79VblyZbVt21a5ubnauHGjBg0adHN3FMBNQUgCUGasWrVKwcHBdmPh4eH66aefJF385dn8+fP11FNPKTg4WJ9++qnq1q0rSfL09NTq1as1ePBgNW7cWJ6enoqLi9OECRNs60pMTNS5c+f0zjvvaOjQoapUqZK6du1683YQwE1lMQzDcHQTAHCjWSwWLV26VJ06dXJ0KwBuE8xJAgAAMEFIAgAAMMGcJAB/CcwsAFBSnEkCAAAwQUgCAAAwQUgCAAAwQUgCAAAwQUgCAAAwQUgCAAAwQUgCAAAwQUgCAAAwQUgCAAAw8f8ACZxtfqce0qEAAAAASUVORK5CYII=",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "67"
-      ]
-     },
-     "execution_count": 29,
-     "metadata": {},
-     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -577,7 +389,7 @@
     "cv2.destroyAllWindows()\n",
     "gc.collect()\n",
     "\n",
-    "num_classes = 3\n",
+    "num_classes = 2\n",
     "config_name = \"ensemble\"\n",
     "    \n",
     "def load_function(attr):\n",
@@ -588,31 +400,27 @@
     "\n",
     "model1 = models.resnet18(pretrained=False)\n",
     "model2 = models.resnet50(pretrained=False)\n",
-    "model3 = models.resnet101(pretrained=False)\n",
     "\n",
     "num_classes = 2\n",
     "\n",
     "model1.fc = nn.Linear(model1.fc.in_features, num_classes)\n",
     "model2.fc = nn.Linear(model2.fc.in_features, num_classes)\n",
-    "model3.fc = nn.Linear(model3.fc.in_features, num_classes)\n",
     "\n",
     "class Ensemble(nn.Module):\n",
-    "    def __init__(self, model1, model2, model3):\n",
+    "    def __init__(self, model1, model2):\n",
     "        super(Ensemble, self).__init__()\n",
     "        self.model1 = model1\n",
     "        self.model2 = model2\n",
-    "        self.model3 = model3\n",
-    "        self.fc = nn.Linear(3 * num_classes, num_classes)\n",
+    "        self.fc = nn.Linear(2 * num_classes, num_classes)\n",
     "\n",
     "    def forward(self, x):\n",
     "        x1 = self.model1(x[0])\n",
     "        x2 = self.model2(x[1])\n",
-    "        x3 = self.model3(x[2])\n",
-    "        x = torch.cat((x1, x2, x3), dim=1)\n",
+    "        x = torch.cat((x1, x2), dim=1)\n",
     "        x = self.fc(x)\n",
     "        return x\n",
     "\n",
-    "model = Ensemble(model1, model2, model3)\n",
+    "model = Ensemble(model1, model2)\n",
     "\n",
     "optimizer = load_function(config.optimizer.name)(model.parameters(), lr=config.optimizer.lr)\n",
     "criterion = load_function(config.loss_function.name)()\n",
@@ -623,8 +431,8 @@
     "\n",
     "#----------Создания датасета и обучение модели--------------\n",
     "\n",
-    "path_res, model_name = prepare_and_learning_detection(num_classes = num_classes, num_samples = 10000, path_dataset = \"/mnt/nvme1/dataset_img\", \n",
-    "                     selected_freq=1200,model_name = config_name+\"_1.2_jpg_\", config_name = config_name, model=model)\n",
+    "path_res, model_name = prepare_and_learning_detection(num_classes = num_classes, num_samples = 10000, path_dataset = \"/mnt/data/Dataset_img\", \n",
+    "                     selected_freq=2400,model_name = config_name+\"_2.4_jpg_\", config_name = config_name, model=model)\n",
     "\n",
     "\n",
     "torch.cuda.empty_cache()\n",
@@ -645,7 +453,7 @@
  "metadata": {
   "celltoolbar": "Отсутствует",
   "kernelspec": {
-   "display_name": ".venv-train (3.12.3)",
+   "display_name": ".venv-train",
    "language": "python",
    "name": "python3"
   },